getAs();
+
+} // Model
diff --git a/tests/org.eclipse.xtext.tests/src-gen2/org/eclipse/xtext/lexer/backtrackingTestLanguage/Xb.java b/tests/org.eclipse.xtext.tests/src-gen2/org/eclipse/xtext/lexer/backtrackingTestLanguage/Xb.java
new file mode 100644
index 000000000..8e1d04c34
--- /dev/null
+++ b/tests/org.eclipse.xtext.tests/src-gen2/org/eclipse/xtext/lexer/backtrackingTestLanguage/Xb.java
@@ -0,0 +1,79 @@
+/**
+ * generated by Xtext
+ */
+package org.eclipse.xtext.lexer.backtrackingTestLanguage;
+
+import org.eclipse.emf.ecore.EObject;
+
+/**
+ *
+ * A representation of the model object 'Xb'.
+ *
+ *
+ *
+ * The following features are supported:
+ *
+ *
+ * - {@link org.eclipse.xtext.lexer.backtrackingTestLanguage.Xb#getX X}
+ * - {@link org.eclipse.xtext.lexer.backtrackingTestLanguage.Xb#getY Y}
+ *
+ *
+ * @see org.eclipse.xtext.lexer.backtrackingTestLanguage.BacktrackingTestLanguagePackage#getXb()
+ * @model
+ * @generated
+ */
+public interface Xb extends EObject
+{
+ /**
+ * Returns the value of the 'X' attribute.
+ *
+ *
+ * If the meaning of the 'X' attribute isn't clear,
+ * there really should be more of a description here...
+ *
+ *
+ * @return the value of the 'X' attribute.
+ * @see #setX(String)
+ * @see org.eclipse.xtext.lexer.backtrackingTestLanguage.BacktrackingTestLanguagePackage#getXb_X()
+ * @model
+ * @generated
+ */
+ String getX();
+
+ /**
+ * Sets the value of the '{@link org.eclipse.xtext.lexer.backtrackingTestLanguage.Xb#getX X}' attribute.
+ *
+ *
+ * @param value the new value of the 'X' attribute.
+ * @see #getX()
+ * @generated
+ */
+ void setX(String value);
+
+ /**
+ * Returns the value of the 'Y' attribute.
+ *
+ *
+ * If the meaning of the 'Y' attribute isn't clear,
+ * there really should be more of a description here...
+ *
+ *
+ * @return the value of the 'Y' attribute.
+ * @see #setY(String)
+ * @see org.eclipse.xtext.lexer.backtrackingTestLanguage.BacktrackingTestLanguagePackage#getXb_Y()
+ * @model
+ * @generated
+ */
+ String getY();
+
+ /**
+ * Sets the value of the '{@link org.eclipse.xtext.lexer.backtrackingTestLanguage.Xb#getY Y}' attribute.
+ *
+ *
+ * @param value the new value of the 'Y' attribute.
+ * @see #getY()
+ * @generated
+ */
+ void setY(String value);
+
+} // Xb
diff --git a/tests/org.eclipse.xtext.tests/src-gen2/org/eclipse/xtext/lexer/backtrackingTestLanguage/impl/AbImpl.java b/tests/org.eclipse.xtext.tests/src-gen2/org/eclipse/xtext/lexer/backtrackingTestLanguage/impl/AbImpl.java
new file mode 100644
index 000000000..05719ebdf
--- /dev/null
+++ b/tests/org.eclipse.xtext.tests/src-gen2/org/eclipse/xtext/lexer/backtrackingTestLanguage/impl/AbImpl.java
@@ -0,0 +1,234 @@
+/**
+ * generated by Xtext
+ */
+package org.eclipse.xtext.lexer.backtrackingTestLanguage.impl;
+
+import org.eclipse.emf.common.notify.Notification;
+
+import org.eclipse.emf.ecore.EClass;
+
+import org.eclipse.emf.ecore.impl.ENotificationImpl;
+import org.eclipse.emf.ecore.impl.MinimalEObjectImpl;
+
+import org.eclipse.xtext.lexer.backtrackingTestLanguage.Ab;
+import org.eclipse.xtext.lexer.backtrackingTestLanguage.BacktrackingTestLanguagePackage;
+
+/**
+ *
+ * An implementation of the model object 'Ab'.
+ *
+ *
+ * The following features are implemented:
+ *
+ *
+ * - {@link org.eclipse.xtext.lexer.backtrackingTestLanguage.impl.AbImpl#getX X}
+ * - {@link org.eclipse.xtext.lexer.backtrackingTestLanguage.impl.AbImpl#getY Y}
+ *
+ *
+ * @generated
+ */
+public class AbImpl extends MinimalEObjectImpl.Container implements Ab
+{
+ /**
+ * The default value of the '{@link #getX() X}' attribute.
+ *
+ *
+ * @see #getX()
+ * @generated
+ * @ordered
+ */
+ protected static final String X_EDEFAULT = null;
+
+ /**
+ * The cached value of the '{@link #getX() X}' attribute.
+ *
+ *
+ * @see #getX()
+ * @generated
+ * @ordered
+ */
+ protected String x = X_EDEFAULT;
+
+ /**
+ * The default value of the '{@link #getY() Y}' attribute.
+ *
+ *
+ * @see #getY()
+ * @generated
+ * @ordered
+ */
+ protected static final String Y_EDEFAULT = null;
+
+ /**
+ * The cached value of the '{@link #getY() Y}' attribute.
+ *
+ *
+ * @see #getY()
+ * @generated
+ * @ordered
+ */
+ protected String y = Y_EDEFAULT;
+
+ /**
+ *
+ *
+ * @generated
+ */
+ protected AbImpl()
+ {
+ super();
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ @Override
+ protected EClass eStaticClass()
+ {
+ return BacktrackingTestLanguagePackage.Literals.AB;
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ public String getX()
+ {
+ return x;
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ public void setX(String newX)
+ {
+ String oldX = x;
+ x = newX;
+ if (eNotificationRequired())
+ eNotify(new ENotificationImpl(this, Notification.SET, BacktrackingTestLanguagePackage.AB__X, oldX, x));
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ public String getY()
+ {
+ return y;
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ public void setY(String newY)
+ {
+ String oldY = y;
+ y = newY;
+ if (eNotificationRequired())
+ eNotify(new ENotificationImpl(this, Notification.SET, BacktrackingTestLanguagePackage.AB__Y, oldY, y));
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ @Override
+ public Object eGet(int featureID, boolean resolve, boolean coreType)
+ {
+ switch (featureID)
+ {
+ case BacktrackingTestLanguagePackage.AB__X:
+ return getX();
+ case BacktrackingTestLanguagePackage.AB__Y:
+ return getY();
+ }
+ return super.eGet(featureID, resolve, coreType);
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ @Override
+ public void eSet(int featureID, Object newValue)
+ {
+ switch (featureID)
+ {
+ case BacktrackingTestLanguagePackage.AB__X:
+ setX((String)newValue);
+ return;
+ case BacktrackingTestLanguagePackage.AB__Y:
+ setY((String)newValue);
+ return;
+ }
+ super.eSet(featureID, newValue);
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ @Override
+ public void eUnset(int featureID)
+ {
+ switch (featureID)
+ {
+ case BacktrackingTestLanguagePackage.AB__X:
+ setX(X_EDEFAULT);
+ return;
+ case BacktrackingTestLanguagePackage.AB__Y:
+ setY(Y_EDEFAULT);
+ return;
+ }
+ super.eUnset(featureID);
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ @Override
+ public boolean eIsSet(int featureID)
+ {
+ switch (featureID)
+ {
+ case BacktrackingTestLanguagePackage.AB__X:
+ return X_EDEFAULT == null ? x != null : !X_EDEFAULT.equals(x);
+ case BacktrackingTestLanguagePackage.AB__Y:
+ return Y_EDEFAULT == null ? y != null : !Y_EDEFAULT.equals(y);
+ }
+ return super.eIsSet(featureID);
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ @Override
+ public String toString()
+ {
+ if (eIsProxy()) return super.toString();
+
+ StringBuffer result = new StringBuffer(super.toString());
+ result.append(" (x: ");
+ result.append(x);
+ result.append(", y: ");
+ result.append(y);
+ result.append(')');
+ return result.toString();
+ }
+
+} //AbImpl
diff --git a/tests/org.eclipse.xtext.tests/src-gen2/org/eclipse/xtext/lexer/backtrackingTestLanguage/impl/BacktrackingTestLanguageFactoryImpl.java b/tests/org.eclipse.xtext.tests/src-gen2/org/eclipse/xtext/lexer/backtrackingTestLanguage/impl/BacktrackingTestLanguageFactoryImpl.java
new file mode 100644
index 000000000..11914e19a
--- /dev/null
+++ b/tests/org.eclipse.xtext.tests/src-gen2/org/eclipse/xtext/lexer/backtrackingTestLanguage/impl/BacktrackingTestLanguageFactoryImpl.java
@@ -0,0 +1,188 @@
+/**
+ * generated by Xtext
+ */
+package org.eclipse.xtext.lexer.backtrackingTestLanguage.impl;
+
+import org.eclipse.emf.ecore.EClass;
+import org.eclipse.emf.ecore.EDataType;
+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;
+
+import org.eclipse.xtext.lexer.backtrackingTestLanguage.*;
+
+/**
+ *
+ * An implementation of the model Factory.
+ *
+ * @generated
+ */
+public class BacktrackingTestLanguageFactoryImpl extends EFactoryImpl implements BacktrackingTestLanguageFactory
+{
+ /**
+ * Creates the default factory implementation.
+ *
+ *
+ * @generated
+ */
+ public static BacktrackingTestLanguageFactory init()
+ {
+ try
+ {
+ BacktrackingTestLanguageFactory theBacktrackingTestLanguageFactory = (BacktrackingTestLanguageFactory)EPackage.Registry.INSTANCE.getEFactory(BacktrackingTestLanguagePackage.eNS_URI);
+ if (theBacktrackingTestLanguageFactory != null)
+ {
+ return theBacktrackingTestLanguageFactory;
+ }
+ }
+ catch (Exception exception)
+ {
+ EcorePlugin.INSTANCE.log(exception);
+ }
+ return new BacktrackingTestLanguageFactoryImpl();
+ }
+
+ /**
+ * Creates an instance of the factory.
+ *
+ *
+ * @generated
+ */
+ public BacktrackingTestLanguageFactoryImpl()
+ {
+ super();
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ @Override
+ public EObject create(EClass eClass)
+ {
+ switch (eClass.getClassifierID())
+ {
+ case BacktrackingTestLanguagePackage.MODEL: return createModel();
+ case BacktrackingTestLanguagePackage.AB: return createAb();
+ case BacktrackingTestLanguagePackage.XB: return createXb();
+ default:
+ throw new IllegalArgumentException("The class '" + eClass.getName() + "' is not a valid classifier");
+ }
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ @Override
+ public Object createFromString(EDataType eDataType, String initialValue)
+ {
+ switch (eDataType.getClassifierID())
+ {
+ case BacktrackingTestLanguagePackage.ENUM_NAME:
+ return createEnumNameFromString(eDataType, initialValue);
+ default:
+ throw new IllegalArgumentException("The datatype '" + eDataType.getName() + "' is not a valid classifier");
+ }
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ @Override
+ public String convertToString(EDataType eDataType, Object instanceValue)
+ {
+ switch (eDataType.getClassifierID())
+ {
+ case BacktrackingTestLanguagePackage.ENUM_NAME:
+ return convertEnumNameToString(eDataType, instanceValue);
+ default:
+ throw new IllegalArgumentException("The datatype '" + eDataType.getName() + "' is not a valid classifier");
+ }
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ public Model createModel()
+ {
+ ModelImpl model = new ModelImpl();
+ return model;
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ public Ab createAb()
+ {
+ AbImpl ab = new AbImpl();
+ return ab;
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ public Xb createXb()
+ {
+ XbImpl xb = new XbImpl();
+ return xb;
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ public EnumName createEnumNameFromString(EDataType eDataType, String initialValue)
+ {
+ EnumName result = EnumName.get(initialValue);
+ if (result == null) throw new IllegalArgumentException("The value '" + initialValue + "' is not a valid enumerator of '" + eDataType.getName() + "'");
+ return result;
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ public String convertEnumNameToString(EDataType eDataType, Object instanceValue)
+ {
+ return instanceValue == null ? null : instanceValue.toString();
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ public BacktrackingTestLanguagePackage getBacktrackingTestLanguagePackage()
+ {
+ return (BacktrackingTestLanguagePackage)getEPackage();
+ }
+
+ /**
+ *
+ *
+ * @deprecated
+ * @generated
+ */
+ @Deprecated
+ public static BacktrackingTestLanguagePackage getPackage()
+ {
+ return BacktrackingTestLanguagePackage.eINSTANCE;
+ }
+
+} //BacktrackingTestLanguageFactoryImpl
diff --git a/tests/org.eclipse.xtext.tests/src-gen2/org/eclipse/xtext/lexer/backtrackingTestLanguage/impl/BacktrackingTestLanguagePackageImpl.java b/tests/org.eclipse.xtext.tests/src-gen2/org/eclipse/xtext/lexer/backtrackingTestLanguage/impl/BacktrackingTestLanguagePackageImpl.java
new file mode 100644
index 000000000..8a744d8fc
--- /dev/null
+++ b/tests/org.eclipse.xtext.tests/src-gen2/org/eclipse/xtext/lexer/backtrackingTestLanguage/impl/BacktrackingTestLanguagePackageImpl.java
@@ -0,0 +1,373 @@
+/**
+ * generated by Xtext
+ */
+package org.eclipse.xtext.lexer.backtrackingTestLanguage.impl;
+
+import org.eclipse.emf.ecore.EAttribute;
+import org.eclipse.emf.ecore.EClass;
+import org.eclipse.emf.ecore.EEnum;
+import org.eclipse.emf.ecore.EPackage;
+import org.eclipse.emf.ecore.EReference;
+import org.eclipse.emf.ecore.EcorePackage;
+
+import org.eclipse.emf.ecore.impl.EPackageImpl;
+
+import org.eclipse.xtext.lexer.backtrackingTestLanguage.Ab;
+import org.eclipse.xtext.lexer.backtrackingTestLanguage.BacktrackingTestLanguageFactory;
+import org.eclipse.xtext.lexer.backtrackingTestLanguage.BacktrackingTestLanguagePackage;
+import org.eclipse.xtext.lexer.backtrackingTestLanguage.EnumName;
+import org.eclipse.xtext.lexer.backtrackingTestLanguage.Model;
+import org.eclipse.xtext.lexer.backtrackingTestLanguage.Xb;
+
+/**
+ *
+ * An implementation of the model Package.
+ *
+ * @generated
+ */
+public class BacktrackingTestLanguagePackageImpl extends EPackageImpl implements BacktrackingTestLanguagePackage
+{
+ /**
+ *
+ *
+ * @generated
+ */
+ private EClass modelEClass = null;
+
+ /**
+ *
+ *
+ * @generated
+ */
+ private EClass abEClass = null;
+
+ /**
+ *
+ *
+ * @generated
+ */
+ private EClass xbEClass = null;
+
+ /**
+ *
+ *
+ * @generated
+ */
+ private EEnum enumNameEEnum = 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 org.eclipse.xtext.lexer.backtrackingTestLanguage.BacktrackingTestLanguagePackage#eNS_URI
+ * @see #init()
+ * @generated
+ */
+ private BacktrackingTestLanguagePackageImpl()
+ {
+ super(eNS_URI, BacktrackingTestLanguageFactory.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 BacktrackingTestLanguagePackage#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 BacktrackingTestLanguagePackage init()
+ {
+ if (isInited) return (BacktrackingTestLanguagePackage)EPackage.Registry.INSTANCE.getEPackage(BacktrackingTestLanguagePackage.eNS_URI);
+
+ // Obtain or create and register package
+ BacktrackingTestLanguagePackageImpl theBacktrackingTestLanguagePackage = (BacktrackingTestLanguagePackageImpl)(EPackage.Registry.INSTANCE.get(eNS_URI) instanceof BacktrackingTestLanguagePackageImpl ? EPackage.Registry.INSTANCE.get(eNS_URI) : new BacktrackingTestLanguagePackageImpl());
+
+ isInited = true;
+
+ // Initialize simple dependencies
+ EcorePackage.eINSTANCE.eClass();
+
+ // Create package meta-data objects
+ theBacktrackingTestLanguagePackage.createPackageContents();
+
+ // Initialize created meta-data
+ theBacktrackingTestLanguagePackage.initializePackageContents();
+
+ // Mark meta-data to indicate it can't be changed
+ theBacktrackingTestLanguagePackage.freeze();
+
+
+ // Update the registry and return the package
+ EPackage.Registry.INSTANCE.put(BacktrackingTestLanguagePackage.eNS_URI, theBacktrackingTestLanguagePackage);
+ return theBacktrackingTestLanguagePackage;
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ public EClass getModel()
+ {
+ return modelEClass;
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ public EAttribute getModel_Enums()
+ {
+ return (EAttribute)modelEClass.getEStructuralFeatures().get(0);
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ public EAttribute getModel_Ycs()
+ {
+ return (EAttribute)modelEClass.getEStructuralFeatures().get(1);
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ public EReference getModel_Abs()
+ {
+ return (EReference)modelEClass.getEStructuralFeatures().get(2);
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ public EReference getModel_Xbs()
+ {
+ return (EReference)modelEClass.getEStructuralFeatures().get(3);
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ public EAttribute getModel_Ys()
+ {
+ return (EAttribute)modelEClass.getEStructuralFeatures().get(4);
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ public EAttribute getModel_As()
+ {
+ return (EAttribute)modelEClass.getEStructuralFeatures().get(5);
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ public EClass getAb()
+ {
+ return abEClass;
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ public EAttribute getAb_X()
+ {
+ return (EAttribute)abEClass.getEStructuralFeatures().get(0);
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ public EAttribute getAb_Y()
+ {
+ return (EAttribute)abEClass.getEStructuralFeatures().get(1);
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ public EClass getXb()
+ {
+ return xbEClass;
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ public EAttribute getXb_X()
+ {
+ return (EAttribute)xbEClass.getEStructuralFeatures().get(0);
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ public EAttribute getXb_Y()
+ {
+ return (EAttribute)xbEClass.getEStructuralFeatures().get(1);
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ public EEnum getEnumName()
+ {
+ return enumNameEEnum;
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ public BacktrackingTestLanguageFactory getBacktrackingTestLanguageFactory()
+ {
+ return (BacktrackingTestLanguageFactory)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
+ modelEClass = createEClass(MODEL);
+ createEAttribute(modelEClass, MODEL__ENUMS);
+ createEAttribute(modelEClass, MODEL__YCS);
+ createEReference(modelEClass, MODEL__ABS);
+ createEReference(modelEClass, MODEL__XBS);
+ createEAttribute(modelEClass, MODEL__YS);
+ createEAttribute(modelEClass, MODEL__AS);
+
+ abEClass = createEClass(AB);
+ createEAttribute(abEClass, AB__X);
+ createEAttribute(abEClass, AB__Y);
+
+ xbEClass = createEClass(XB);
+ createEAttribute(xbEClass, XB__X);
+ createEAttribute(xbEClass, XB__Y);
+
+ // Create enums
+ enumNameEEnum = createEEnum(ENUM_NAME);
+ }
+
+ /**
+ *
+ *
+ * @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
+ EcorePackage theEcorePackage = (EcorePackage)EPackage.Registry.INSTANCE.getEPackage(EcorePackage.eNS_URI);
+
+ // Create type parameters
+
+ // Set bounds for type parameters
+
+ // Add supertypes to classes
+
+ // Initialize classes and features; add operations and parameters
+ initEClass(modelEClass, Model.class, "Model", !IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS);
+ initEAttribute(getModel_Enums(), this.getEnumName(), "enums", null, 0, -1, Model.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_UNSETTABLE, !IS_ID, !IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
+ initEAttribute(getModel_Ycs(), theEcorePackage.getEString(), "ycs", null, 0, -1, Model.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_UNSETTABLE, !IS_ID, !IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
+ initEReference(getModel_Abs(), this.getAb(), null, "abs", null, 0, -1, Model.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
+ initEReference(getModel_Xbs(), this.getXb(), null, "xbs", null, 0, -1, Model.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
+ initEAttribute(getModel_Ys(), theEcorePackage.getEString(), "ys", null, 0, -1, Model.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_UNSETTABLE, !IS_ID, !IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
+ initEAttribute(getModel_As(), theEcorePackage.getEString(), "as", null, 0, -1, Model.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_UNSETTABLE, !IS_ID, !IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
+
+ initEClass(abEClass, Ab.class, "Ab", !IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS);
+ initEAttribute(getAb_X(), theEcorePackage.getEString(), "x", null, 0, 1, Ab.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_UNSETTABLE, !IS_ID, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
+ initEAttribute(getAb_Y(), theEcorePackage.getEString(), "y", null, 0, 1, Ab.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_UNSETTABLE, !IS_ID, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
+
+ initEClass(xbEClass, Xb.class, "Xb", !IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS);
+ initEAttribute(getXb_X(), theEcorePackage.getEString(), "x", null, 0, 1, Xb.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_UNSETTABLE, !IS_ID, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
+ initEAttribute(getXb_Y(), theEcorePackage.getEString(), "y", null, 0, 1, Xb.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_UNSETTABLE, !IS_ID, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
+
+ // Initialize enums and add enum literals
+ initEEnum(enumNameEEnum, EnumName.class, "EnumName");
+ addEEnumLiteral(enumNameEEnum, EnumName.ABC);
+ addEEnumLiteral(enumNameEEnum, EnumName.EFG);
+
+ // Create resource
+ createResource(eNS_URI);
+ }
+
+} //BacktrackingTestLanguagePackageImpl
diff --git a/tests/org.eclipse.xtext.tests/src-gen2/org/eclipse/xtext/lexer/backtrackingTestLanguage/impl/ModelImpl.java b/tests/org.eclipse.xtext.tests/src-gen2/org/eclipse/xtext/lexer/backtrackingTestLanguage/impl/ModelImpl.java
new file mode 100644
index 000000000..fe240a6f5
--- /dev/null
+++ b/tests/org.eclipse.xtext.tests/src-gen2/org/eclipse/xtext/lexer/backtrackingTestLanguage/impl/ModelImpl.java
@@ -0,0 +1,376 @@
+/**
+ * generated by Xtext
+ */
+package org.eclipse.xtext.lexer.backtrackingTestLanguage.impl;
+
+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.EDataTypeEList;
+import org.eclipse.emf.ecore.util.EObjectContainmentEList;
+import org.eclipse.emf.ecore.util.InternalEList;
+
+import org.eclipse.xtext.lexer.backtrackingTestLanguage.Ab;
+import org.eclipse.xtext.lexer.backtrackingTestLanguage.BacktrackingTestLanguagePackage;
+import org.eclipse.xtext.lexer.backtrackingTestLanguage.EnumName;
+import org.eclipse.xtext.lexer.backtrackingTestLanguage.Model;
+import org.eclipse.xtext.lexer.backtrackingTestLanguage.Xb;
+
+/**
+ *
+ * An implementation of the model object 'Model'.
+ *
+ *
+ * The following features are implemented:
+ *
+ *
+ * - {@link org.eclipse.xtext.lexer.backtrackingTestLanguage.impl.ModelImpl#getEnums Enums}
+ * - {@link org.eclipse.xtext.lexer.backtrackingTestLanguage.impl.ModelImpl#getYcs Ycs}
+ * - {@link org.eclipse.xtext.lexer.backtrackingTestLanguage.impl.ModelImpl#getAbs Abs}
+ * - {@link org.eclipse.xtext.lexer.backtrackingTestLanguage.impl.ModelImpl#getXbs Xbs}
+ * - {@link org.eclipse.xtext.lexer.backtrackingTestLanguage.impl.ModelImpl#getYs Ys}
+ * - {@link org.eclipse.xtext.lexer.backtrackingTestLanguage.impl.ModelImpl#getAs As}
+ *
+ *
+ * @generated
+ */
+public class ModelImpl extends MinimalEObjectImpl.Container implements Model
+{
+ /**
+ * The cached value of the '{@link #getEnums() Enums}' attribute list.
+ *
+ *
+ * @see #getEnums()
+ * @generated
+ * @ordered
+ */
+ protected EList enums;
+
+ /**
+ * The cached value of the '{@link #getYcs() Ycs}' attribute list.
+ *
+ *
+ * @see #getYcs()
+ * @generated
+ * @ordered
+ */
+ protected EList ycs;
+
+ /**
+ * The cached value of the '{@link #getAbs() Abs}' containment reference list.
+ *
+ *
+ * @see #getAbs()
+ * @generated
+ * @ordered
+ */
+ protected EList abs;
+
+ /**
+ * The cached value of the '{@link #getXbs() Xbs}' containment reference list.
+ *
+ *
+ * @see #getXbs()
+ * @generated
+ * @ordered
+ */
+ protected EList xbs;
+
+ /**
+ * The cached value of the '{@link #getYs() Ys}' attribute list.
+ *
+ *
+ * @see #getYs()
+ * @generated
+ * @ordered
+ */
+ protected EList ys;
+
+ /**
+ * The cached value of the '{@link #getAs() As}' attribute list.
+ *
+ *
+ * @see #getAs()
+ * @generated
+ * @ordered
+ */
+ protected EList as;
+
+ /**
+ *
+ *
+ * @generated
+ */
+ protected ModelImpl()
+ {
+ super();
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ @Override
+ protected EClass eStaticClass()
+ {
+ return BacktrackingTestLanguagePackage.Literals.MODEL;
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ public EList getEnums()
+ {
+ if (enums == null)
+ {
+ enums = new EDataTypeEList(EnumName.class, this, BacktrackingTestLanguagePackage.MODEL__ENUMS);
+ }
+ return enums;
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ public EList getYcs()
+ {
+ if (ycs == null)
+ {
+ ycs = new EDataTypeEList(String.class, this, BacktrackingTestLanguagePackage.MODEL__YCS);
+ }
+ return ycs;
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ public EList getAbs()
+ {
+ if (abs == null)
+ {
+ abs = new EObjectContainmentEList(Ab.class, this, BacktrackingTestLanguagePackage.MODEL__ABS);
+ }
+ return abs;
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ public EList getXbs()
+ {
+ if (xbs == null)
+ {
+ xbs = new EObjectContainmentEList(Xb.class, this, BacktrackingTestLanguagePackage.MODEL__XBS);
+ }
+ return xbs;
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ public EList getYs()
+ {
+ if (ys == null)
+ {
+ ys = new EDataTypeEList(String.class, this, BacktrackingTestLanguagePackage.MODEL__YS);
+ }
+ return ys;
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ public EList getAs()
+ {
+ if (as == null)
+ {
+ as = new EDataTypeEList(String.class, this, BacktrackingTestLanguagePackage.MODEL__AS);
+ }
+ return as;
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ @Override
+ public NotificationChain eInverseRemove(InternalEObject otherEnd, int featureID, NotificationChain msgs)
+ {
+ switch (featureID)
+ {
+ case BacktrackingTestLanguagePackage.MODEL__ABS:
+ return ((InternalEList)getAbs()).basicRemove(otherEnd, msgs);
+ case BacktrackingTestLanguagePackage.MODEL__XBS:
+ return ((InternalEList)getXbs()).basicRemove(otherEnd, msgs);
+ }
+ return super.eInverseRemove(otherEnd, featureID, msgs);
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ @Override
+ public Object eGet(int featureID, boolean resolve, boolean coreType)
+ {
+ switch (featureID)
+ {
+ case BacktrackingTestLanguagePackage.MODEL__ENUMS:
+ return getEnums();
+ case BacktrackingTestLanguagePackage.MODEL__YCS:
+ return getYcs();
+ case BacktrackingTestLanguagePackage.MODEL__ABS:
+ return getAbs();
+ case BacktrackingTestLanguagePackage.MODEL__XBS:
+ return getXbs();
+ case BacktrackingTestLanguagePackage.MODEL__YS:
+ return getYs();
+ case BacktrackingTestLanguagePackage.MODEL__AS:
+ return getAs();
+ }
+ return super.eGet(featureID, resolve, coreType);
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ @SuppressWarnings("unchecked")
+ @Override
+ public void eSet(int featureID, Object newValue)
+ {
+ switch (featureID)
+ {
+ case BacktrackingTestLanguagePackage.MODEL__ENUMS:
+ getEnums().clear();
+ getEnums().addAll((Collection)newValue);
+ return;
+ case BacktrackingTestLanguagePackage.MODEL__YCS:
+ getYcs().clear();
+ getYcs().addAll((Collection)newValue);
+ return;
+ case BacktrackingTestLanguagePackage.MODEL__ABS:
+ getAbs().clear();
+ getAbs().addAll((Collection)newValue);
+ return;
+ case BacktrackingTestLanguagePackage.MODEL__XBS:
+ getXbs().clear();
+ getXbs().addAll((Collection)newValue);
+ return;
+ case BacktrackingTestLanguagePackage.MODEL__YS:
+ getYs().clear();
+ getYs().addAll((Collection)newValue);
+ return;
+ case BacktrackingTestLanguagePackage.MODEL__AS:
+ getAs().clear();
+ getAs().addAll((Collection)newValue);
+ return;
+ }
+ super.eSet(featureID, newValue);
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ @Override
+ public void eUnset(int featureID)
+ {
+ switch (featureID)
+ {
+ case BacktrackingTestLanguagePackage.MODEL__ENUMS:
+ getEnums().clear();
+ return;
+ case BacktrackingTestLanguagePackage.MODEL__YCS:
+ getYcs().clear();
+ return;
+ case BacktrackingTestLanguagePackage.MODEL__ABS:
+ getAbs().clear();
+ return;
+ case BacktrackingTestLanguagePackage.MODEL__XBS:
+ getXbs().clear();
+ return;
+ case BacktrackingTestLanguagePackage.MODEL__YS:
+ getYs().clear();
+ return;
+ case BacktrackingTestLanguagePackage.MODEL__AS:
+ getAs().clear();
+ return;
+ }
+ super.eUnset(featureID);
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ @Override
+ public boolean eIsSet(int featureID)
+ {
+ switch (featureID)
+ {
+ case BacktrackingTestLanguagePackage.MODEL__ENUMS:
+ return enums != null && !enums.isEmpty();
+ case BacktrackingTestLanguagePackage.MODEL__YCS:
+ return ycs != null && !ycs.isEmpty();
+ case BacktrackingTestLanguagePackage.MODEL__ABS:
+ return abs != null && !abs.isEmpty();
+ case BacktrackingTestLanguagePackage.MODEL__XBS:
+ return xbs != null && !xbs.isEmpty();
+ case BacktrackingTestLanguagePackage.MODEL__YS:
+ return ys != null && !ys.isEmpty();
+ case BacktrackingTestLanguagePackage.MODEL__AS:
+ return as != null && !as.isEmpty();
+ }
+ return super.eIsSet(featureID);
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ @Override
+ public String toString()
+ {
+ if (eIsProxy()) return super.toString();
+
+ StringBuffer result = new StringBuffer(super.toString());
+ result.append(" (enums: ");
+ result.append(enums);
+ result.append(", ycs: ");
+ result.append(ycs);
+ result.append(", ys: ");
+ result.append(ys);
+ result.append(", as: ");
+ result.append(as);
+ result.append(')');
+ return result.toString();
+ }
+
+} //ModelImpl
diff --git a/tests/org.eclipse.xtext.tests/src-gen2/org/eclipse/xtext/lexer/backtrackingTestLanguage/impl/XbImpl.java b/tests/org.eclipse.xtext.tests/src-gen2/org/eclipse/xtext/lexer/backtrackingTestLanguage/impl/XbImpl.java
new file mode 100644
index 000000000..3270bb134
--- /dev/null
+++ b/tests/org.eclipse.xtext.tests/src-gen2/org/eclipse/xtext/lexer/backtrackingTestLanguage/impl/XbImpl.java
@@ -0,0 +1,234 @@
+/**
+ * generated by Xtext
+ */
+package org.eclipse.xtext.lexer.backtrackingTestLanguage.impl;
+
+import org.eclipse.emf.common.notify.Notification;
+
+import org.eclipse.emf.ecore.EClass;
+
+import org.eclipse.emf.ecore.impl.ENotificationImpl;
+import org.eclipse.emf.ecore.impl.MinimalEObjectImpl;
+
+import org.eclipse.xtext.lexer.backtrackingTestLanguage.BacktrackingTestLanguagePackage;
+import org.eclipse.xtext.lexer.backtrackingTestLanguage.Xb;
+
+/**
+ *
+ * An implementation of the model object 'Xb'.
+ *
+ *
+ * The following features are implemented:
+ *
+ *
+ * - {@link org.eclipse.xtext.lexer.backtrackingTestLanguage.impl.XbImpl#getX X}
+ * - {@link org.eclipse.xtext.lexer.backtrackingTestLanguage.impl.XbImpl#getY Y}
+ *
+ *
+ * @generated
+ */
+public class XbImpl extends MinimalEObjectImpl.Container implements Xb
+{
+ /**
+ * The default value of the '{@link #getX() X}' attribute.
+ *
+ *
+ * @see #getX()
+ * @generated
+ * @ordered
+ */
+ protected static final String X_EDEFAULT = null;
+
+ /**
+ * The cached value of the '{@link #getX() X}' attribute.
+ *
+ *
+ * @see #getX()
+ * @generated
+ * @ordered
+ */
+ protected String x = X_EDEFAULT;
+
+ /**
+ * The default value of the '{@link #getY() Y}' attribute.
+ *
+ *
+ * @see #getY()
+ * @generated
+ * @ordered
+ */
+ protected static final String Y_EDEFAULT = null;
+
+ /**
+ * The cached value of the '{@link #getY() Y}' attribute.
+ *
+ *
+ * @see #getY()
+ * @generated
+ * @ordered
+ */
+ protected String y = Y_EDEFAULT;
+
+ /**
+ *
+ *
+ * @generated
+ */
+ protected XbImpl()
+ {
+ super();
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ @Override
+ protected EClass eStaticClass()
+ {
+ return BacktrackingTestLanguagePackage.Literals.XB;
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ public String getX()
+ {
+ return x;
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ public void setX(String newX)
+ {
+ String oldX = x;
+ x = newX;
+ if (eNotificationRequired())
+ eNotify(new ENotificationImpl(this, Notification.SET, BacktrackingTestLanguagePackage.XB__X, oldX, x));
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ public String getY()
+ {
+ return y;
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ public void setY(String newY)
+ {
+ String oldY = y;
+ y = newY;
+ if (eNotificationRequired())
+ eNotify(new ENotificationImpl(this, Notification.SET, BacktrackingTestLanguagePackage.XB__Y, oldY, y));
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ @Override
+ public Object eGet(int featureID, boolean resolve, boolean coreType)
+ {
+ switch (featureID)
+ {
+ case BacktrackingTestLanguagePackage.XB__X:
+ return getX();
+ case BacktrackingTestLanguagePackage.XB__Y:
+ return getY();
+ }
+ return super.eGet(featureID, resolve, coreType);
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ @Override
+ public void eSet(int featureID, Object newValue)
+ {
+ switch (featureID)
+ {
+ case BacktrackingTestLanguagePackage.XB__X:
+ setX((String)newValue);
+ return;
+ case BacktrackingTestLanguagePackage.XB__Y:
+ setY((String)newValue);
+ return;
+ }
+ super.eSet(featureID, newValue);
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ @Override
+ public void eUnset(int featureID)
+ {
+ switch (featureID)
+ {
+ case BacktrackingTestLanguagePackage.XB__X:
+ setX(X_EDEFAULT);
+ return;
+ case BacktrackingTestLanguagePackage.XB__Y:
+ setY(Y_EDEFAULT);
+ return;
+ }
+ super.eUnset(featureID);
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ @Override
+ public boolean eIsSet(int featureID)
+ {
+ switch (featureID)
+ {
+ case BacktrackingTestLanguagePackage.XB__X:
+ return X_EDEFAULT == null ? x != null : !X_EDEFAULT.equals(x);
+ case BacktrackingTestLanguagePackage.XB__Y:
+ return Y_EDEFAULT == null ? y != null : !Y_EDEFAULT.equals(y);
+ }
+ return super.eIsSet(featureID);
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ @Override
+ public String toString()
+ {
+ if (eIsProxy()) return super.toString();
+
+ StringBuffer result = new StringBuffer(super.toString());
+ result.append(" (x: ");
+ result.append(x);
+ result.append(", y: ");
+ result.append(y);
+ result.append(')');
+ return result.toString();
+ }
+
+} //XbImpl
diff --git a/tests/org.eclipse.xtext.tests/src-gen2/org/eclipse/xtext/lexer/backtrackingTestLanguage/util/BacktrackingTestLanguageAdapterFactory.java b/tests/org.eclipse.xtext.tests/src-gen2/org/eclipse/xtext/lexer/backtrackingTestLanguage/util/BacktrackingTestLanguageAdapterFactory.java
new file mode 100644
index 000000000..8c73e9be3
--- /dev/null
+++ b/tests/org.eclipse.xtext.tests/src-gen2/org/eclipse/xtext/lexer/backtrackingTestLanguage/util/BacktrackingTestLanguageAdapterFactory.java
@@ -0,0 +1,173 @@
+/**
+ * generated by Xtext
+ */
+package org.eclipse.xtext.lexer.backtrackingTestLanguage.util;
+
+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;
+
+import org.eclipse.xtext.lexer.backtrackingTestLanguage.*;
+
+/**
+ *
+ * The Adapter Factory for the model.
+ * It provides an adapter createXXX method for each class of the model.
+ *
+ * @see org.eclipse.xtext.lexer.backtrackingTestLanguage.BacktrackingTestLanguagePackage
+ * @generated
+ */
+public class BacktrackingTestLanguageAdapterFactory extends AdapterFactoryImpl
+{
+ /**
+ * The cached model package.
+ *
+ *
+ * @generated
+ */
+ protected static BacktrackingTestLanguagePackage modelPackage;
+
+ /**
+ * Creates an instance of the adapter factory.
+ *
+ *
+ * @generated
+ */
+ public BacktrackingTestLanguageAdapterFactory()
+ {
+ if (modelPackage == null)
+ {
+ modelPackage = BacktrackingTestLanguagePackage.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 BacktrackingTestLanguageSwitch modelSwitch =
+ new BacktrackingTestLanguageSwitch()
+ {
+ @Override
+ public Adapter caseModel(Model object)
+ {
+ return createModelAdapter();
+ }
+ @Override
+ public Adapter caseAb(Ab object)
+ {
+ return createAbAdapter();
+ }
+ @Override
+ public Adapter caseXb(Xb object)
+ {
+ return createXbAdapter();
+ }
+ @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 org.eclipse.xtext.lexer.backtrackingTestLanguage.Model Model}'.
+ *
+ * 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 org.eclipse.xtext.lexer.backtrackingTestLanguage.Model
+ * @generated
+ */
+ public Adapter createModelAdapter()
+ {
+ return null;
+ }
+
+ /**
+ * Creates a new adapter for an object of class '{@link org.eclipse.xtext.lexer.backtrackingTestLanguage.Ab Ab}'.
+ *
+ * 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 org.eclipse.xtext.lexer.backtrackingTestLanguage.Ab
+ * @generated
+ */
+ public Adapter createAbAdapter()
+ {
+ return null;
+ }
+
+ /**
+ * Creates a new adapter for an object of class '{@link org.eclipse.xtext.lexer.backtrackingTestLanguage.Xb Xb}'.
+ *
+ * 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 org.eclipse.xtext.lexer.backtrackingTestLanguage.Xb
+ * @generated
+ */
+ public Adapter createXbAdapter()
+ {
+ 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;
+ }
+
+} //BacktrackingTestLanguageAdapterFactory
diff --git a/tests/org.eclipse.xtext.tests/src-gen2/org/eclipse/xtext/lexer/backtrackingTestLanguage/util/BacktrackingTestLanguageSwitch.java b/tests/org.eclipse.xtext.tests/src-gen2/org/eclipse/xtext/lexer/backtrackingTestLanguage/util/BacktrackingTestLanguageSwitch.java
new file mode 100644
index 000000000..a0891217c
--- /dev/null
+++ b/tests/org.eclipse.xtext.tests/src-gen2/org/eclipse/xtext/lexer/backtrackingTestLanguage/util/BacktrackingTestLanguageSwitch.java
@@ -0,0 +1,166 @@
+/**
+ * generated by Xtext
+ */
+package org.eclipse.xtext.lexer.backtrackingTestLanguage.util;
+
+import org.eclipse.emf.ecore.EObject;
+import org.eclipse.emf.ecore.EPackage;
+
+import org.eclipse.emf.ecore.util.Switch;
+
+import org.eclipse.xtext.lexer.backtrackingTestLanguage.*;
+
+/**
+ *
+ * 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 org.eclipse.xtext.lexer.backtrackingTestLanguage.BacktrackingTestLanguagePackage
+ * @generated
+ */
+public class BacktrackingTestLanguageSwitch extends Switch
+{
+ /**
+ * The cached model package
+ *
+ *
+ * @generated
+ */
+ protected static BacktrackingTestLanguagePackage modelPackage;
+
+ /**
+ * Creates an instance of the switch.
+ *
+ *
+ * @generated
+ */
+ public BacktrackingTestLanguageSwitch()
+ {
+ if (modelPackage == null)
+ {
+ modelPackage = BacktrackingTestLanguagePackage.eINSTANCE;
+ }
+ }
+
+ /**
+ * Checks whether this is a switch for the given package.
+ *
+ *
+ * @param 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 BacktrackingTestLanguagePackage.MODEL:
+ {
+ Model model = (Model)theEObject;
+ T result = caseModel(model);
+ if (result == null) result = defaultCase(theEObject);
+ return result;
+ }
+ case BacktrackingTestLanguagePackage.AB:
+ {
+ Ab ab = (Ab)theEObject;
+ T result = caseAb(ab);
+ if (result == null) result = defaultCase(theEObject);
+ return result;
+ }
+ case BacktrackingTestLanguagePackage.XB:
+ {
+ Xb xb = (Xb)theEObject;
+ T result = caseXb(xb);
+ if (result == null) result = defaultCase(theEObject);
+ return result;
+ }
+ default: return defaultCase(theEObject);
+ }
+ }
+
+ /**
+ * Returns the result of interpreting the object as an instance of 'Model'.
+ *
+ * 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 'Model'.
+ * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject)
+ * @generated
+ */
+ public T caseModel(Model object)
+ {
+ return null;
+ }
+
+ /**
+ * Returns the result of interpreting the object as an instance of 'Ab'.
+ *
+ * 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 'Ab'.
+ * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject)
+ * @generated
+ */
+ public T caseAb(Ab object)
+ {
+ return null;
+ }
+
+ /**
+ * Returns the result of interpreting the object as an instance of 'Xb'.
+ *
+ * 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 'Xb'.
+ * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject)
+ * @generated
+ */
+ public T caseXb(Xb 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;
+ }
+
+} //BacktrackingTestLanguageSwitch
diff --git a/tests/org.eclipse.xtext.tests/src-gen2/org/eclipse/xtext/lexer/parser/antlr/BacktrackingLexerTestLanguageAntlrTokenFileProvider.java b/tests/org.eclipse.xtext.tests/src-gen2/org/eclipse/xtext/lexer/parser/antlr/BacktrackingLexerTestLanguageAntlrTokenFileProvider.java
new file mode 100644
index 000000000..39c065563
--- /dev/null
+++ b/tests/org.eclipse.xtext.tests/src-gen2/org/eclipse/xtext/lexer/parser/antlr/BacktrackingLexerTestLanguageAntlrTokenFileProvider.java
@@ -0,0 +1,16 @@
+/*
+ * generated by Xtext
+ */
+package org.eclipse.xtext.lexer.parser.antlr;
+
+import java.io.InputStream;
+import org.eclipse.xtext.parser.antlr.IAntlrTokenFileProvider;
+
+public class BacktrackingLexerTestLanguageAntlrTokenFileProvider implements IAntlrTokenFileProvider {
+
+ @Override
+ public InputStream getAntlrTokenFile() {
+ ClassLoader classLoader = getClass().getClassLoader();
+ return classLoader.getResourceAsStream("org/eclipse/xtext/lexer/parser/antlr/internal/InternalBacktrackingLexerTestLanguageParser.tokens");
+ }
+}
diff --git a/tests/org.eclipse.xtext.tests/src-gen2/org/eclipse/xtext/lexer/parser/antlr/BacktrackingLexerTestLanguageParser.java b/tests/org.eclipse.xtext.tests/src-gen2/org/eclipse/xtext/lexer/parser/antlr/BacktrackingLexerTestLanguageParser.java
new file mode 100644
index 000000000..547dea619
--- /dev/null
+++ b/tests/org.eclipse.xtext.tests/src-gen2/org/eclipse/xtext/lexer/parser/antlr/BacktrackingLexerTestLanguageParser.java
@@ -0,0 +1,40 @@
+/*
+ * generated by Xtext
+ */
+package org.eclipse.xtext.lexer.parser.antlr;
+
+import com.google.inject.Inject;
+import org.eclipse.xtext.lexer.parser.antlr.internal.InternalBacktrackingLexerTestLanguageParser;
+import org.eclipse.xtext.lexer.services.BacktrackingLexerTestLanguageGrammarAccess;
+import org.eclipse.xtext.parser.antlr.AbstractAntlrParser;
+import org.eclipse.xtext.parser.antlr.XtextTokenStream;
+
+public class BacktrackingLexerTestLanguageParser extends AbstractAntlrParser {
+
+ @Inject
+ private BacktrackingLexerTestLanguageGrammarAccess grammarAccess;
+
+ @Override
+ protected void setInitialHiddenTokens(XtextTokenStream tokenStream) {
+ tokenStream.setInitialHiddenTokens("RULE_WS", "RULE_SL_COMMENT");
+ }
+
+
+ @Override
+ protected InternalBacktrackingLexerTestLanguageParser createParser(XtextTokenStream stream) {
+ return new InternalBacktrackingLexerTestLanguageParser(stream, getGrammarAccess());
+ }
+
+ @Override
+ protected String getDefaultRuleName() {
+ return "Model";
+ }
+
+ public BacktrackingLexerTestLanguageGrammarAccess getGrammarAccess() {
+ return this.grammarAccess;
+ }
+
+ public void setGrammarAccess(BacktrackingLexerTestLanguageGrammarAccess grammarAccess) {
+ this.grammarAccess = grammarAccess;
+ }
+}
diff --git a/tests/org.eclipse.xtext.tests/src-gen2/org/eclipse/xtext/lexer/parser/antlr/internal/DebugInternalBacktrackingLexerTestLanguage.g b/tests/org.eclipse.xtext.tests/src-gen2/org/eclipse/xtext/lexer/parser/antlr/internal/DebugInternalBacktrackingLexerTestLanguage.g
new file mode 100644
index 000000000..1af0a3480
--- /dev/null
+++ b/tests/org.eclipse.xtext.tests/src-gen2/org/eclipse/xtext/lexer/parser/antlr/internal/DebugInternalBacktrackingLexerTestLanguage.g
@@ -0,0 +1,74 @@
+/*
+ * generated by Xtext
+ */
+grammar DebugInternalBacktrackingLexerTestLanguage;
+tokens {
+ Abc;
+ Efg;
+ RULE_CHARA;
+ RULE_CHARB;
+ RULE_CHARX;
+ RULE_YC;
+ RULE_CHARY;
+ RULE_CHARC;
+ RULE_WS;
+ RULE_SL_COMMENT;
+}
+
+// Rule Model
+ruleModel:
+ ruleEnumName
+ *
+ RULE_YC
+ *
+ ruleAb
+ *
+ ruleXb
+ *
+ RULE_CHARY
+ *
+ RULE_CHARA
+ *
+;
+
+// Rule Ab
+ruleAb:
+ RULE_CHARA
+ RULE_CHARB
+;
+
+// Rule Xb
+ruleXb:
+ RULE_CHARX
+ RULE_CHARB
+;
+
+// Rule EnumName
+ruleEnumName:
+ 'Abc'
+ |
+ 'Efg'
+;
+
+fragment RULE_CHARA : FRAGMENT_RULE_CHARA;
+fragment FRAGMENT_RULE_CHARA : 'A';
+
+fragment RULE_CHARB : FRAGMENT_RULE_CHARB;
+fragment FRAGMENT_RULE_CHARB : 'b';
+
+fragment RULE_CHARX : FRAGMENT_RULE_CHARX;
+fragment FRAGMENT_RULE_CHARX : 'X';
+
+fragment RULE_YC : FRAGMENT_RULE_YC;
+fragment FRAGMENT_RULE_YC : RULE_CHARY RULE_CHARC;
+
+fragment RULE_CHARY : FRAGMENT_RULE_CHARY;
+fragment FRAGMENT_RULE_CHARY : 'Y';
+
+fragment RULE_CHARC : 'c';
+
+fragment RULE_WS : FRAGMENT_RULE_WS;
+fragment FRAGMENT_RULE_WS : (' '|'\t'|'\r'|'\n')+;
+
+fragment RULE_SL_COMMENT : FRAGMENT_RULE_SL_COMMENT;
+fragment FRAGMENT_RULE_SL_COMMENT : '//' ~(('\n'|'\r'))* ('\r'? '\n')?;
diff --git a/tests/org.eclipse.xtext.tests/src-gen2/org/eclipse/xtext/lexer/parser/antlr/internal/InternalBacktrackingLexerTestLanguageParser.g b/tests/org.eclipse.xtext.tests/src-gen2/org/eclipse/xtext/lexer/parser/antlr/internal/InternalBacktrackingLexerTestLanguageParser.g
new file mode 100644
index 000000000..fe112e4da
--- /dev/null
+++ b/tests/org.eclipse.xtext.tests/src-gen2/org/eclipse/xtext/lexer/parser/antlr/internal/InternalBacktrackingLexerTestLanguageParser.g
@@ -0,0 +1,329 @@
+/*
+ * generated by Xtext
+ */
+parser grammar InternalBacktrackingLexerTestLanguageParser;
+
+options {
+ tokenVocab=InternalBacktrackingLexerTestLanguageLexer;
+ superClass=AbstractInternalAntlrParser;
+ backtrack=true;
+ memoize=true;
+}
+
+@header {
+package org.eclipse.xtext.lexer.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.emf.common.util.Enumerator;
+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 org.eclipse.xtext.lexer.services.BacktrackingLexerTestLanguageGrammarAccess;
+
+}
+
+@members {
+
+/*
+ This grammar contains a lot of empty actions to work around a bug in ANTLR.
+ Otherwise the ANTLR tool will create synpreds that cannot be compiled in some rare cases.
+*/
+
+ private BacktrackingLexerTestLanguageGrammarAccess grammarAccess;
+
+ public InternalBacktrackingLexerTestLanguageParser(TokenStream input, BacktrackingLexerTestLanguageGrammarAccess grammarAccess) {
+ this(input);
+ this.grammarAccess = grammarAccess;
+ registerRules(grammarAccess.getGrammar());
+ }
+
+ @Override
+ protected String getFirstRuleName() {
+ return "Model";
+ }
+
+ @Override
+ protected BacktrackingLexerTestLanguageGrammarAccess getGrammarAccess() {
+ return grammarAccess;
+ }
+
+}
+
+@rulecatch {
+ catch (RecognitionException re) {
+ recover(input,re);
+ appendSkippedTokens();
+ }
+}
+
+// Entry rule entryRuleModel
+entryRuleModel returns [EObject current=null]:
+ { newCompositeNode(grammarAccess.getModelRule()); }
+ iv_ruleModel=ruleModel
+ { $current=$iv_ruleModel.current; }
+ EOF;
+
+// Rule Model
+ruleModel returns [EObject current=null]
+@init {
+ enterRule();
+}
+@after {
+ leaveRule();
+}:
+ (
+ (
+ (
+ {
+ newCompositeNode(grammarAccess.getModelAccess().getEnumsEnumNameEnumRuleCall_0_0());
+ }
+ lv_enums_0_0=ruleEnumName
+ {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getModelRule());
+ }
+ add(
+ $current,
+ "enums",
+ lv_enums_0_0,
+ "org.eclipse.xtext.lexer.BacktrackingLexerTestLanguage.EnumName");
+ afterParserOrEnumRuleCall();
+ }
+ )
+ )*
+ (
+ (
+ lv_ycs_1_0=RULE_YC
+ {
+ newLeafNode(lv_ycs_1_0, grammarAccess.getModelAccess().getYcsYcTerminalRuleCall_1_0());
+ }
+ {
+ if ($current==null) {
+ $current = createModelElement(grammarAccess.getModelRule());
+ }
+ addWithLastConsumed(
+ $current,
+ "ycs",
+ lv_ycs_1_0,
+ "org.eclipse.xtext.lexer.BacktrackingLexerTestLanguage.Yc");
+ }
+ )
+ )*
+ (
+ (
+ {
+ newCompositeNode(grammarAccess.getModelAccess().getAbsAbParserRuleCall_2_0());
+ }
+ lv_abs_2_0=ruleAb
+ {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getModelRule());
+ }
+ add(
+ $current,
+ "abs",
+ lv_abs_2_0,
+ "org.eclipse.xtext.lexer.BacktrackingLexerTestLanguage.Ab");
+ afterParserOrEnumRuleCall();
+ }
+ )
+ )*
+ (
+ (
+ {
+ newCompositeNode(grammarAccess.getModelAccess().getXbsXbParserRuleCall_3_0());
+ }
+ lv_xbs_3_0=ruleXb
+ {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getModelRule());
+ }
+ add(
+ $current,
+ "xbs",
+ lv_xbs_3_0,
+ "org.eclipse.xtext.lexer.BacktrackingLexerTestLanguage.Xb");
+ afterParserOrEnumRuleCall();
+ }
+ )
+ )*
+ (
+ (
+ lv_ys_4_0=RULE_CHARY
+ {
+ newLeafNode(lv_ys_4_0, grammarAccess.getModelAccess().getYsCharYTerminalRuleCall_4_0());
+ }
+ {
+ if ($current==null) {
+ $current = createModelElement(grammarAccess.getModelRule());
+ }
+ addWithLastConsumed(
+ $current,
+ "ys",
+ lv_ys_4_0,
+ "org.eclipse.xtext.lexer.BacktrackingLexerTestLanguage.CharY");
+ }
+ )
+ )*
+ (
+ (
+ lv_as_5_0=RULE_CHARA
+ {
+ newLeafNode(lv_as_5_0, grammarAccess.getModelAccess().getAsCharATerminalRuleCall_5_0());
+ }
+ {
+ if ($current==null) {
+ $current = createModelElement(grammarAccess.getModelRule());
+ }
+ addWithLastConsumed(
+ $current,
+ "as",
+ lv_as_5_0,
+ "org.eclipse.xtext.lexer.BacktrackingLexerTestLanguage.CharA");
+ }
+ )
+ )*
+ )
+;
+
+// Entry rule entryRuleAb
+entryRuleAb returns [EObject current=null]:
+ { newCompositeNode(grammarAccess.getAbRule()); }
+ iv_ruleAb=ruleAb
+ { $current=$iv_ruleAb.current; }
+ EOF;
+
+// Rule Ab
+ruleAb returns [EObject current=null]
+@init {
+ enterRule();
+}
+@after {
+ leaveRule();
+}:
+ (
+ (
+ (
+ lv_x_0_0=RULE_CHARA
+ {
+ newLeafNode(lv_x_0_0, grammarAccess.getAbAccess().getXCharATerminalRuleCall_0_0());
+ }
+ {
+ if ($current==null) {
+ $current = createModelElement(grammarAccess.getAbRule());
+ }
+ setWithLastConsumed(
+ $current,
+ "x",
+ lv_x_0_0,
+ "org.eclipse.xtext.lexer.BacktrackingLexerTestLanguage.CharA");
+ }
+ )
+ )
+ (
+ (
+ lv_y_1_0=RULE_CHARB
+ {
+ newLeafNode(lv_y_1_0, grammarAccess.getAbAccess().getYCharbTerminalRuleCall_1_0());
+ }
+ {
+ if ($current==null) {
+ $current = createModelElement(grammarAccess.getAbRule());
+ }
+ setWithLastConsumed(
+ $current,
+ "y",
+ lv_y_1_0,
+ "org.eclipse.xtext.lexer.BacktrackingLexerTestLanguage.Charb");
+ }
+ )
+ )
+ )
+;
+
+// Entry rule entryRuleXb
+entryRuleXb returns [EObject current=null]:
+ { newCompositeNode(grammarAccess.getXbRule()); }
+ iv_ruleXb=ruleXb
+ { $current=$iv_ruleXb.current; }
+ EOF;
+
+// Rule Xb
+ruleXb returns [EObject current=null]
+@init {
+ enterRule();
+}
+@after {
+ leaveRule();
+}:
+ (
+ (
+ (
+ lv_x_0_0=RULE_CHARX
+ {
+ newLeafNode(lv_x_0_0, grammarAccess.getXbAccess().getXCharXTerminalRuleCall_0_0());
+ }
+ {
+ if ($current==null) {
+ $current = createModelElement(grammarAccess.getXbRule());
+ }
+ setWithLastConsumed(
+ $current,
+ "x",
+ lv_x_0_0,
+ "org.eclipse.xtext.lexer.BacktrackingLexerTestLanguage.CharX");
+ }
+ )
+ )
+ (
+ (
+ lv_y_1_0=RULE_CHARB
+ {
+ newLeafNode(lv_y_1_0, grammarAccess.getXbAccess().getYCharbTerminalRuleCall_1_0());
+ }
+ {
+ if ($current==null) {
+ $current = createModelElement(grammarAccess.getXbRule());
+ }
+ setWithLastConsumed(
+ $current,
+ "y",
+ lv_y_1_0,
+ "org.eclipse.xtext.lexer.BacktrackingLexerTestLanguage.Charb");
+ }
+ )
+ )
+ )
+;
+
+// Rule EnumName
+ruleEnumName returns [Enumerator current=null]
+@init {
+ enterRule();
+}
+@after {
+ leaveRule();
+}:
+ (
+ (
+ enumLiteral_0=Abc
+ {
+ $current = grammarAccess.getEnumNameAccess().getAbcEnumLiteralDeclaration_0().getEnumLiteral().getInstance();
+ newLeafNode(enumLiteral_0, grammarAccess.getEnumNameAccess().getAbcEnumLiteralDeclaration_0());
+ }
+ )
+ |
+ (
+ enumLiteral_1=Efg
+ {
+ $current = grammarAccess.getEnumNameAccess().getEfgEnumLiteralDeclaration_1().getEnumLiteral().getInstance();
+ newLeafNode(enumLiteral_1, grammarAccess.getEnumNameAccess().getEfgEnumLiteralDeclaration_1());
+ }
+ )
+ )
+;
diff --git a/tests/org.eclipse.xtext.tests/src-gen2/org/eclipse/xtext/lexer/parser/antlr/internal/InternalBacktrackingLexerTestLanguageParser.java b/tests/org.eclipse.xtext.tests/src-gen2/org/eclipse/xtext/lexer/parser/antlr/internal/InternalBacktrackingLexerTestLanguageParser.java
new file mode 100644
index 000000000..9369c0a30
--- /dev/null
+++ b/tests/org.eclipse.xtext.tests/src-gen2/org/eclipse/xtext/lexer/parser/antlr/internal/InternalBacktrackingLexerTestLanguageParser.java
@@ -0,0 +1,894 @@
+package org.eclipse.xtext.lexer.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.emf.common.util.Enumerator;
+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 org.eclipse.xtext.lexer.services.BacktrackingLexerTestLanguageGrammarAccess;
+
+
+
+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 InternalBacktrackingLexerTestLanguageParser extends AbstractInternalAntlrParser {
+ public static final String[] tokenNames = new String[] {
+ "", "", "", "", "Abc", "Efg", "RULE_CHARA", "RULE_CHARB", "RULE_CHARX", "RULE_YC", "RULE_CHARY", "RULE_CHARC", "RULE_WS", "RULE_SL_COMMENT"
+ };
+ public static final int RULE_CHARX=8;
+ public static final int RULE_YC=9;
+ public static final int Efg=5;
+ public static final int RULE_CHARY=10;
+ public static final int Abc=4;
+ public static final int RULE_WS=12;
+ public static final int RULE_CHARA=6;
+ public static final int RULE_SL_COMMENT=13;
+ public static final int EOF=-1;
+ public static final int RULE_CHARB=7;
+ public static final int RULE_CHARC=11;
+
+ // delegates
+ // delegators
+
+
+ public InternalBacktrackingLexerTestLanguageParser(TokenStream input) {
+ this(input, new RecognizerSharedState());
+ }
+ public InternalBacktrackingLexerTestLanguageParser(TokenStream input, RecognizerSharedState state) {
+ super(input, state);
+ this.state.ruleMemo = new HashMap[14+1];
+
+
+ }
+
+
+ public String[] getTokenNames() { return InternalBacktrackingLexerTestLanguageParser.tokenNames; }
+ public String getGrammarFileName() { return "InternalBacktrackingLexerTestLanguageParser.g"; }
+
+
+
+ /*
+ This grammar contains a lot of empty actions to work around a bug in ANTLR.
+ Otherwise the ANTLR tool will create synpreds that cannot be compiled in some rare cases.
+ */
+
+ private BacktrackingLexerTestLanguageGrammarAccess grammarAccess;
+
+ public InternalBacktrackingLexerTestLanguageParser(TokenStream input, BacktrackingLexerTestLanguageGrammarAccess grammarAccess) {
+ this(input);
+ this.grammarAccess = grammarAccess;
+ registerRules(grammarAccess.getGrammar());
+ }
+
+ @Override
+ protected String getFirstRuleName() {
+ return "Model";
+ }
+
+ @Override
+ protected BacktrackingLexerTestLanguageGrammarAccess getGrammarAccess() {
+ return grammarAccess;
+ }
+
+
+
+
+ // $ANTLR start "entryRuleModel"
+ // InternalBacktrackingLexerTestLanguageParser.g:65:1: entryRuleModel returns [EObject current=null] : iv_ruleModel= ruleModel EOF ;
+ public final EObject entryRuleModel() throws RecognitionException {
+ EObject current = null;
+ int entryRuleModel_StartIndex = input.index();
+ EObject iv_ruleModel = null;
+
+
+ try {
+ if ( state.backtracking>0 && alreadyParsedRule(input, 1) ) { return current; }
+ // InternalBacktrackingLexerTestLanguageParser.g:65:46: (iv_ruleModel= ruleModel EOF )
+ // InternalBacktrackingLexerTestLanguageParser.g:66:2: iv_ruleModel= ruleModel EOF
+ {
+ if ( state.backtracking==0 ) {
+ newCompositeNode(grammarAccess.getModelRule());
+ }
+ pushFollow(FollowSets000.FOLLOW_1);
+ iv_ruleModel=ruleModel();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+ current =iv_ruleModel;
+ }
+ match(input,EOF,FollowSets000.FOLLOW_2); if (state.failed) return current;
+
+ }
+
+ }
+
+ catch (RecognitionException re) {
+ recover(input,re);
+ appendSkippedTokens();
+ }
+ finally {
+ if ( state.backtracking>0 ) { memoize(input, 1, entryRuleModel_StartIndex); }
+ }
+ return current;
+ }
+ // $ANTLR end "entryRuleModel"
+
+
+ // $ANTLR start "ruleModel"
+ // InternalBacktrackingLexerTestLanguageParser.g:72:1: ruleModel returns [EObject current=null] : ( ( (lv_enums_0_0= ruleEnumName ) )* ( (lv_ycs_1_0= RULE_YC ) )* ( (lv_abs_2_0= ruleAb ) )* ( (lv_xbs_3_0= ruleXb ) )* ( (lv_ys_4_0= RULE_CHARY ) )* ( (lv_as_5_0= RULE_CHARA ) )* ) ;
+ public final EObject ruleModel() throws RecognitionException {
+ EObject current = null;
+ int ruleModel_StartIndex = input.index();
+ Token lv_ycs_1_0=null;
+ Token lv_ys_4_0=null;
+ Token lv_as_5_0=null;
+ Enumerator lv_enums_0_0 = null;
+
+ EObject lv_abs_2_0 = null;
+
+ EObject lv_xbs_3_0 = null;
+
+
+
+ enterRule();
+
+ try {
+ if ( state.backtracking>0 && alreadyParsedRule(input, 2) ) { return current; }
+ // InternalBacktrackingLexerTestLanguageParser.g:78:2: ( ( ( (lv_enums_0_0= ruleEnumName ) )* ( (lv_ycs_1_0= RULE_YC ) )* ( (lv_abs_2_0= ruleAb ) )* ( (lv_xbs_3_0= ruleXb ) )* ( (lv_ys_4_0= RULE_CHARY ) )* ( (lv_as_5_0= RULE_CHARA ) )* ) )
+ // InternalBacktrackingLexerTestLanguageParser.g:79:2: ( ( (lv_enums_0_0= ruleEnumName ) )* ( (lv_ycs_1_0= RULE_YC ) )* ( (lv_abs_2_0= ruleAb ) )* ( (lv_xbs_3_0= ruleXb ) )* ( (lv_ys_4_0= RULE_CHARY ) )* ( (lv_as_5_0= RULE_CHARA ) )* )
+ {
+ // InternalBacktrackingLexerTestLanguageParser.g:79:2: ( ( (lv_enums_0_0= ruleEnumName ) )* ( (lv_ycs_1_0= RULE_YC ) )* ( (lv_abs_2_0= ruleAb ) )* ( (lv_xbs_3_0= ruleXb ) )* ( (lv_ys_4_0= RULE_CHARY ) )* ( (lv_as_5_0= RULE_CHARA ) )* )
+ // InternalBacktrackingLexerTestLanguageParser.g:80:3: ( (lv_enums_0_0= ruleEnumName ) )* ( (lv_ycs_1_0= RULE_YC ) )* ( (lv_abs_2_0= ruleAb ) )* ( (lv_xbs_3_0= ruleXb ) )* ( (lv_ys_4_0= RULE_CHARY ) )* ( (lv_as_5_0= RULE_CHARA ) )*
+ {
+ // InternalBacktrackingLexerTestLanguageParser.g:80:3: ( (lv_enums_0_0= ruleEnumName ) )*
+ loop1:
+ do {
+ int alt1=2;
+ int LA1_0 = input.LA(1);
+
+ if ( ((LA1_0>=Abc && LA1_0<=Efg)) ) {
+ alt1=1;
+ }
+
+
+ switch (alt1) {
+ case 1 :
+ // InternalBacktrackingLexerTestLanguageParser.g:81:4: (lv_enums_0_0= ruleEnumName )
+ {
+ // InternalBacktrackingLexerTestLanguageParser.g:81:4: (lv_enums_0_0= ruleEnumName )
+ // InternalBacktrackingLexerTestLanguageParser.g:82:5: lv_enums_0_0= ruleEnumName
+ {
+ if ( state.backtracking==0 ) {
+
+ newCompositeNode(grammarAccess.getModelAccess().getEnumsEnumNameEnumRuleCall_0_0());
+
+ }
+ pushFollow(FollowSets000.FOLLOW_3);
+ lv_enums_0_0=ruleEnumName();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ if (current==null) {
+ current = createModelElementForParent(grammarAccess.getModelRule());
+ }
+ add(
+ current,
+ "enums",
+ lv_enums_0_0,
+ "org.eclipse.xtext.lexer.BacktrackingLexerTestLanguage.EnumName");
+ afterParserOrEnumRuleCall();
+
+ }
+
+ }
+
+
+ }
+ break;
+
+ default :
+ break loop1;
+ }
+ } while (true);
+
+ // InternalBacktrackingLexerTestLanguageParser.g:99:3: ( (lv_ycs_1_0= RULE_YC ) )*
+ loop2:
+ do {
+ int alt2=2;
+ int LA2_0 = input.LA(1);
+
+ if ( (LA2_0==RULE_YC) ) {
+ alt2=1;
+ }
+
+
+ switch (alt2) {
+ case 1 :
+ // InternalBacktrackingLexerTestLanguageParser.g:100:4: (lv_ycs_1_0= RULE_YC )
+ {
+ // InternalBacktrackingLexerTestLanguageParser.g:100:4: (lv_ycs_1_0= RULE_YC )
+ // InternalBacktrackingLexerTestLanguageParser.g:101:5: lv_ycs_1_0= RULE_YC
+ {
+ lv_ycs_1_0=(Token)match(input,RULE_YC,FollowSets000.FOLLOW_4); if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ newLeafNode(lv_ycs_1_0, grammarAccess.getModelAccess().getYcsYcTerminalRuleCall_1_0());
+
+ }
+ if ( state.backtracking==0 ) {
+
+ if (current==null) {
+ current = createModelElement(grammarAccess.getModelRule());
+ }
+ addWithLastConsumed(
+ current,
+ "ycs",
+ lv_ycs_1_0,
+ "org.eclipse.xtext.lexer.BacktrackingLexerTestLanguage.Yc");
+
+ }
+
+ }
+
+
+ }
+ break;
+
+ default :
+ break loop2;
+ }
+ } while (true);
+
+ // InternalBacktrackingLexerTestLanguageParser.g:117:3: ( (lv_abs_2_0= ruleAb ) )*
+ loop3:
+ do {
+ int alt3=2;
+ int LA3_0 = input.LA(1);
+
+ if ( (LA3_0==RULE_CHARA) ) {
+ int LA3_2 = input.LA(2);
+
+ if ( (LA3_2==RULE_CHARB) ) {
+ alt3=1;
+ }
+
+
+ }
+
+
+ switch (alt3) {
+ case 1 :
+ // InternalBacktrackingLexerTestLanguageParser.g:118:4: (lv_abs_2_0= ruleAb )
+ {
+ // InternalBacktrackingLexerTestLanguageParser.g:118:4: (lv_abs_2_0= ruleAb )
+ // InternalBacktrackingLexerTestLanguageParser.g:119:5: lv_abs_2_0= ruleAb
+ {
+ if ( state.backtracking==0 ) {
+
+ newCompositeNode(grammarAccess.getModelAccess().getAbsAbParserRuleCall_2_0());
+
+ }
+ pushFollow(FollowSets000.FOLLOW_5);
+ lv_abs_2_0=ruleAb();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ if (current==null) {
+ current = createModelElementForParent(grammarAccess.getModelRule());
+ }
+ add(
+ current,
+ "abs",
+ lv_abs_2_0,
+ "org.eclipse.xtext.lexer.BacktrackingLexerTestLanguage.Ab");
+ afterParserOrEnumRuleCall();
+
+ }
+
+ }
+
+
+ }
+ break;
+
+ default :
+ break loop3;
+ }
+ } while (true);
+
+ // InternalBacktrackingLexerTestLanguageParser.g:136:3: ( (lv_xbs_3_0= ruleXb ) )*
+ loop4:
+ do {
+ int alt4=2;
+ int LA4_0 = input.LA(1);
+
+ if ( (LA4_0==RULE_CHARX) ) {
+ alt4=1;
+ }
+
+
+ switch (alt4) {
+ case 1 :
+ // InternalBacktrackingLexerTestLanguageParser.g:137:4: (lv_xbs_3_0= ruleXb )
+ {
+ // InternalBacktrackingLexerTestLanguageParser.g:137:4: (lv_xbs_3_0= ruleXb )
+ // InternalBacktrackingLexerTestLanguageParser.g:138:5: lv_xbs_3_0= ruleXb
+ {
+ if ( state.backtracking==0 ) {
+
+ newCompositeNode(grammarAccess.getModelAccess().getXbsXbParserRuleCall_3_0());
+
+ }
+ pushFollow(FollowSets000.FOLLOW_5);
+ lv_xbs_3_0=ruleXb();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ if (current==null) {
+ current = createModelElementForParent(grammarAccess.getModelRule());
+ }
+ add(
+ current,
+ "xbs",
+ lv_xbs_3_0,
+ "org.eclipse.xtext.lexer.BacktrackingLexerTestLanguage.Xb");
+ afterParserOrEnumRuleCall();
+
+ }
+
+ }
+
+
+ }
+ break;
+
+ default :
+ break loop4;
+ }
+ } while (true);
+
+ // InternalBacktrackingLexerTestLanguageParser.g:155:3: ( (lv_ys_4_0= RULE_CHARY ) )*
+ loop5:
+ do {
+ int alt5=2;
+ int LA5_0 = input.LA(1);
+
+ if ( (LA5_0==RULE_CHARY) ) {
+ alt5=1;
+ }
+
+
+ switch (alt5) {
+ case 1 :
+ // InternalBacktrackingLexerTestLanguageParser.g:156:4: (lv_ys_4_0= RULE_CHARY )
+ {
+ // InternalBacktrackingLexerTestLanguageParser.g:156:4: (lv_ys_4_0= RULE_CHARY )
+ // InternalBacktrackingLexerTestLanguageParser.g:157:5: lv_ys_4_0= RULE_CHARY
+ {
+ lv_ys_4_0=(Token)match(input,RULE_CHARY,FollowSets000.FOLLOW_6); if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ newLeafNode(lv_ys_4_0, grammarAccess.getModelAccess().getYsCharYTerminalRuleCall_4_0());
+
+ }
+ if ( state.backtracking==0 ) {
+
+ if (current==null) {
+ current = createModelElement(grammarAccess.getModelRule());
+ }
+ addWithLastConsumed(
+ current,
+ "ys",
+ lv_ys_4_0,
+ "org.eclipse.xtext.lexer.BacktrackingLexerTestLanguage.CharY");
+
+ }
+
+ }
+
+
+ }
+ break;
+
+ default :
+ break loop5;
+ }
+ } while (true);
+
+ // InternalBacktrackingLexerTestLanguageParser.g:173:3: ( (lv_as_5_0= RULE_CHARA ) )*
+ loop6:
+ do {
+ int alt6=2;
+ int LA6_0 = input.LA(1);
+
+ if ( (LA6_0==RULE_CHARA) ) {
+ alt6=1;
+ }
+
+
+ switch (alt6) {
+ case 1 :
+ // InternalBacktrackingLexerTestLanguageParser.g:174:4: (lv_as_5_0= RULE_CHARA )
+ {
+ // InternalBacktrackingLexerTestLanguageParser.g:174:4: (lv_as_5_0= RULE_CHARA )
+ // InternalBacktrackingLexerTestLanguageParser.g:175:5: lv_as_5_0= RULE_CHARA
+ {
+ lv_as_5_0=(Token)match(input,RULE_CHARA,FollowSets000.FOLLOW_7); if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ newLeafNode(lv_as_5_0, grammarAccess.getModelAccess().getAsCharATerminalRuleCall_5_0());
+
+ }
+ if ( state.backtracking==0 ) {
+
+ if (current==null) {
+ current = createModelElement(grammarAccess.getModelRule());
+ }
+ addWithLastConsumed(
+ current,
+ "as",
+ lv_as_5_0,
+ "org.eclipse.xtext.lexer.BacktrackingLexerTestLanguage.CharA");
+
+ }
+
+ }
+
+
+ }
+ break;
+
+ default :
+ break loop6;
+ }
+ } while (true);
+
+
+ }
+
+
+ }
+
+ if ( state.backtracking==0 ) {
+
+ leaveRule();
+
+ }
+ }
+
+ catch (RecognitionException re) {
+ recover(input,re);
+ appendSkippedTokens();
+ }
+ finally {
+ if ( state.backtracking>0 ) { memoize(input, 2, ruleModel_StartIndex); }
+ }
+ return current;
+ }
+ // $ANTLR end "ruleModel"
+
+
+ // $ANTLR start "entryRuleAb"
+ // InternalBacktrackingLexerTestLanguageParser.g:195:1: entryRuleAb returns [EObject current=null] : iv_ruleAb= ruleAb EOF ;
+ public final EObject entryRuleAb() throws RecognitionException {
+ EObject current = null;
+ int entryRuleAb_StartIndex = input.index();
+ EObject iv_ruleAb = null;
+
+
+ try {
+ if ( state.backtracking>0 && alreadyParsedRule(input, 3) ) { return current; }
+ // InternalBacktrackingLexerTestLanguageParser.g:195:43: (iv_ruleAb= ruleAb EOF )
+ // InternalBacktrackingLexerTestLanguageParser.g:196:2: iv_ruleAb= ruleAb EOF
+ {
+ if ( state.backtracking==0 ) {
+ newCompositeNode(grammarAccess.getAbRule());
+ }
+ pushFollow(FollowSets000.FOLLOW_1);
+ iv_ruleAb=ruleAb();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+ current =iv_ruleAb;
+ }
+ match(input,EOF,FollowSets000.FOLLOW_2); if (state.failed) return current;
+
+ }
+
+ }
+
+ catch (RecognitionException re) {
+ recover(input,re);
+ appendSkippedTokens();
+ }
+ finally {
+ if ( state.backtracking>0 ) { memoize(input, 3, entryRuleAb_StartIndex); }
+ }
+ return current;
+ }
+ // $ANTLR end "entryRuleAb"
+
+
+ // $ANTLR start "ruleAb"
+ // InternalBacktrackingLexerTestLanguageParser.g:202:1: ruleAb returns [EObject current=null] : ( ( (lv_x_0_0= RULE_CHARA ) ) ( (lv_y_1_0= RULE_CHARB ) ) ) ;
+ public final EObject ruleAb() throws RecognitionException {
+ EObject current = null;
+ int ruleAb_StartIndex = input.index();
+ Token lv_x_0_0=null;
+ Token lv_y_1_0=null;
+
+
+ enterRule();
+
+ try {
+ if ( state.backtracking>0 && alreadyParsedRule(input, 4) ) { return current; }
+ // InternalBacktrackingLexerTestLanguageParser.g:208:2: ( ( ( (lv_x_0_0= RULE_CHARA ) ) ( (lv_y_1_0= RULE_CHARB ) ) ) )
+ // InternalBacktrackingLexerTestLanguageParser.g:209:2: ( ( (lv_x_0_0= RULE_CHARA ) ) ( (lv_y_1_0= RULE_CHARB ) ) )
+ {
+ // InternalBacktrackingLexerTestLanguageParser.g:209:2: ( ( (lv_x_0_0= RULE_CHARA ) ) ( (lv_y_1_0= RULE_CHARB ) ) )
+ // InternalBacktrackingLexerTestLanguageParser.g:210:3: ( (lv_x_0_0= RULE_CHARA ) ) ( (lv_y_1_0= RULE_CHARB ) )
+ {
+ // InternalBacktrackingLexerTestLanguageParser.g:210:3: ( (lv_x_0_0= RULE_CHARA ) )
+ // InternalBacktrackingLexerTestLanguageParser.g:211:4: (lv_x_0_0= RULE_CHARA )
+ {
+ // InternalBacktrackingLexerTestLanguageParser.g:211:4: (lv_x_0_0= RULE_CHARA )
+ // InternalBacktrackingLexerTestLanguageParser.g:212:5: lv_x_0_0= RULE_CHARA
+ {
+ lv_x_0_0=(Token)match(input,RULE_CHARA,FollowSets000.FOLLOW_8); if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ newLeafNode(lv_x_0_0, grammarAccess.getAbAccess().getXCharATerminalRuleCall_0_0());
+
+ }
+ if ( state.backtracking==0 ) {
+
+ if (current==null) {
+ current = createModelElement(grammarAccess.getAbRule());
+ }
+ setWithLastConsumed(
+ current,
+ "x",
+ lv_x_0_0,
+ "org.eclipse.xtext.lexer.BacktrackingLexerTestLanguage.CharA");
+
+ }
+
+ }
+
+
+ }
+
+ // InternalBacktrackingLexerTestLanguageParser.g:228:3: ( (lv_y_1_0= RULE_CHARB ) )
+ // InternalBacktrackingLexerTestLanguageParser.g:229:4: (lv_y_1_0= RULE_CHARB )
+ {
+ // InternalBacktrackingLexerTestLanguageParser.g:229:4: (lv_y_1_0= RULE_CHARB )
+ // InternalBacktrackingLexerTestLanguageParser.g:230:5: lv_y_1_0= RULE_CHARB
+ {
+ lv_y_1_0=(Token)match(input,RULE_CHARB,FollowSets000.FOLLOW_2); if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ newLeafNode(lv_y_1_0, grammarAccess.getAbAccess().getYCharbTerminalRuleCall_1_0());
+
+ }
+ if ( state.backtracking==0 ) {
+
+ if (current==null) {
+ current = createModelElement(grammarAccess.getAbRule());
+ }
+ setWithLastConsumed(
+ current,
+ "y",
+ lv_y_1_0,
+ "org.eclipse.xtext.lexer.BacktrackingLexerTestLanguage.Charb");
+
+ }
+
+ }
+
+
+ }
+
+
+ }
+
+
+ }
+
+ if ( state.backtracking==0 ) {
+
+ leaveRule();
+
+ }
+ }
+
+ catch (RecognitionException re) {
+ recover(input,re);
+ appendSkippedTokens();
+ }
+ finally {
+ if ( state.backtracking>0 ) { memoize(input, 4, ruleAb_StartIndex); }
+ }
+ return current;
+ }
+ // $ANTLR end "ruleAb"
+
+
+ // $ANTLR start "entryRuleXb"
+ // InternalBacktrackingLexerTestLanguageParser.g:250:1: entryRuleXb returns [EObject current=null] : iv_ruleXb= ruleXb EOF ;
+ public final EObject entryRuleXb() throws RecognitionException {
+ EObject current = null;
+ int entryRuleXb_StartIndex = input.index();
+ EObject iv_ruleXb = null;
+
+
+ try {
+ if ( state.backtracking>0 && alreadyParsedRule(input, 5) ) { return current; }
+ // InternalBacktrackingLexerTestLanguageParser.g:250:43: (iv_ruleXb= ruleXb EOF )
+ // InternalBacktrackingLexerTestLanguageParser.g:251:2: iv_ruleXb= ruleXb EOF
+ {
+ if ( state.backtracking==0 ) {
+ newCompositeNode(grammarAccess.getXbRule());
+ }
+ pushFollow(FollowSets000.FOLLOW_1);
+ iv_ruleXb=ruleXb();
+
+ state._fsp--;
+ if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+ current =iv_ruleXb;
+ }
+ match(input,EOF,FollowSets000.FOLLOW_2); if (state.failed) return current;
+
+ }
+
+ }
+
+ catch (RecognitionException re) {
+ recover(input,re);
+ appendSkippedTokens();
+ }
+ finally {
+ if ( state.backtracking>0 ) { memoize(input, 5, entryRuleXb_StartIndex); }
+ }
+ return current;
+ }
+ // $ANTLR end "entryRuleXb"
+
+
+ // $ANTLR start "ruleXb"
+ // InternalBacktrackingLexerTestLanguageParser.g:257:1: ruleXb returns [EObject current=null] : ( ( (lv_x_0_0= RULE_CHARX ) ) ( (lv_y_1_0= RULE_CHARB ) ) ) ;
+ public final EObject ruleXb() throws RecognitionException {
+ EObject current = null;
+ int ruleXb_StartIndex = input.index();
+ Token lv_x_0_0=null;
+ Token lv_y_1_0=null;
+
+
+ enterRule();
+
+ try {
+ if ( state.backtracking>0 && alreadyParsedRule(input, 6) ) { return current; }
+ // InternalBacktrackingLexerTestLanguageParser.g:263:2: ( ( ( (lv_x_0_0= RULE_CHARX ) ) ( (lv_y_1_0= RULE_CHARB ) ) ) )
+ // InternalBacktrackingLexerTestLanguageParser.g:264:2: ( ( (lv_x_0_0= RULE_CHARX ) ) ( (lv_y_1_0= RULE_CHARB ) ) )
+ {
+ // InternalBacktrackingLexerTestLanguageParser.g:264:2: ( ( (lv_x_0_0= RULE_CHARX ) ) ( (lv_y_1_0= RULE_CHARB ) ) )
+ // InternalBacktrackingLexerTestLanguageParser.g:265:3: ( (lv_x_0_0= RULE_CHARX ) ) ( (lv_y_1_0= RULE_CHARB ) )
+ {
+ // InternalBacktrackingLexerTestLanguageParser.g:265:3: ( (lv_x_0_0= RULE_CHARX ) )
+ // InternalBacktrackingLexerTestLanguageParser.g:266:4: (lv_x_0_0= RULE_CHARX )
+ {
+ // InternalBacktrackingLexerTestLanguageParser.g:266:4: (lv_x_0_0= RULE_CHARX )
+ // InternalBacktrackingLexerTestLanguageParser.g:267:5: lv_x_0_0= RULE_CHARX
+ {
+ lv_x_0_0=(Token)match(input,RULE_CHARX,FollowSets000.FOLLOW_8); if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ newLeafNode(lv_x_0_0, grammarAccess.getXbAccess().getXCharXTerminalRuleCall_0_0());
+
+ }
+ if ( state.backtracking==0 ) {
+
+ if (current==null) {
+ current = createModelElement(grammarAccess.getXbRule());
+ }
+ setWithLastConsumed(
+ current,
+ "x",
+ lv_x_0_0,
+ "org.eclipse.xtext.lexer.BacktrackingLexerTestLanguage.CharX");
+
+ }
+
+ }
+
+
+ }
+
+ // InternalBacktrackingLexerTestLanguageParser.g:283:3: ( (lv_y_1_0= RULE_CHARB ) )
+ // InternalBacktrackingLexerTestLanguageParser.g:284:4: (lv_y_1_0= RULE_CHARB )
+ {
+ // InternalBacktrackingLexerTestLanguageParser.g:284:4: (lv_y_1_0= RULE_CHARB )
+ // InternalBacktrackingLexerTestLanguageParser.g:285:5: lv_y_1_0= RULE_CHARB
+ {
+ lv_y_1_0=(Token)match(input,RULE_CHARB,FollowSets000.FOLLOW_2); if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ newLeafNode(lv_y_1_0, grammarAccess.getXbAccess().getYCharbTerminalRuleCall_1_0());
+
+ }
+ if ( state.backtracking==0 ) {
+
+ if (current==null) {
+ current = createModelElement(grammarAccess.getXbRule());
+ }
+ setWithLastConsumed(
+ current,
+ "y",
+ lv_y_1_0,
+ "org.eclipse.xtext.lexer.BacktrackingLexerTestLanguage.Charb");
+
+ }
+
+ }
+
+
+ }
+
+
+ }
+
+
+ }
+
+ if ( state.backtracking==0 ) {
+
+ leaveRule();
+
+ }
+ }
+
+ catch (RecognitionException re) {
+ recover(input,re);
+ appendSkippedTokens();
+ }
+ finally {
+ if ( state.backtracking>0 ) { memoize(input, 6, ruleXb_StartIndex); }
+ }
+ return current;
+ }
+ // $ANTLR end "ruleXb"
+
+
+ // $ANTLR start "ruleEnumName"
+ // InternalBacktrackingLexerTestLanguageParser.g:305:1: ruleEnumName returns [Enumerator current=null] : ( (enumLiteral_0= Abc ) | (enumLiteral_1= Efg ) ) ;
+ public final Enumerator ruleEnumName() throws RecognitionException {
+ Enumerator current = null;
+ int ruleEnumName_StartIndex = input.index();
+ Token enumLiteral_0=null;
+ Token enumLiteral_1=null;
+
+
+ enterRule();
+
+ try {
+ if ( state.backtracking>0 && alreadyParsedRule(input, 7) ) { return current; }
+ // InternalBacktrackingLexerTestLanguageParser.g:311:2: ( ( (enumLiteral_0= Abc ) | (enumLiteral_1= Efg ) ) )
+ // InternalBacktrackingLexerTestLanguageParser.g:312:2: ( (enumLiteral_0= Abc ) | (enumLiteral_1= Efg ) )
+ {
+ // InternalBacktrackingLexerTestLanguageParser.g:312:2: ( (enumLiteral_0= Abc ) | (enumLiteral_1= Efg ) )
+ int alt7=2;
+ int LA7_0 = input.LA(1);
+
+ if ( (LA7_0==Abc) ) {
+ alt7=1;
+ }
+ else if ( (LA7_0==Efg) ) {
+ alt7=2;
+ }
+ else {
+ if (state.backtracking>0) {state.failed=true; return current;}
+ NoViableAltException nvae =
+ new NoViableAltException("", 7, 0, input);
+
+ throw nvae;
+ }
+ switch (alt7) {
+ case 1 :
+ // InternalBacktrackingLexerTestLanguageParser.g:313:3: (enumLiteral_0= Abc )
+ {
+ // InternalBacktrackingLexerTestLanguageParser.g:313:3: (enumLiteral_0= Abc )
+ // InternalBacktrackingLexerTestLanguageParser.g:314:4: enumLiteral_0= Abc
+ {
+ enumLiteral_0=(Token)match(input,Abc,FollowSets000.FOLLOW_2); if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ current = grammarAccess.getEnumNameAccess().getAbcEnumLiteralDeclaration_0().getEnumLiteral().getInstance();
+ newLeafNode(enumLiteral_0, grammarAccess.getEnumNameAccess().getAbcEnumLiteralDeclaration_0());
+
+ }
+
+ }
+
+
+ }
+ break;
+ case 2 :
+ // InternalBacktrackingLexerTestLanguageParser.g:321:3: (enumLiteral_1= Efg )
+ {
+ // InternalBacktrackingLexerTestLanguageParser.g:321:3: (enumLiteral_1= Efg )
+ // InternalBacktrackingLexerTestLanguageParser.g:322:4: enumLiteral_1= Efg
+ {
+ enumLiteral_1=(Token)match(input,Efg,FollowSets000.FOLLOW_2); if (state.failed) return current;
+ if ( state.backtracking==0 ) {
+
+ current = grammarAccess.getEnumNameAccess().getEfgEnumLiteralDeclaration_1().getEnumLiteral().getInstance();
+ newLeafNode(enumLiteral_1, grammarAccess.getEnumNameAccess().getEfgEnumLiteralDeclaration_1());
+
+ }
+
+ }
+
+
+ }
+ break;
+
+ }
+
+
+ }
+
+ if ( state.backtracking==0 ) {
+
+ leaveRule();
+
+ }
+ }
+
+ catch (RecognitionException re) {
+ recover(input,re);
+ appendSkippedTokens();
+ }
+ finally {
+ if ( state.backtracking>0 ) { memoize(input, 7, ruleEnumName_StartIndex); }
+ }
+ return current;
+ }
+ // $ANTLR end "ruleEnumName"
+
+ // Delegated rules
+
+
+
+
+
+ private static class FollowSets000 {
+ public static final BitSet FOLLOW_1 = new BitSet(new long[]{0x0000000000000000L});
+ public static final BitSet FOLLOW_2 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_3 = new BitSet(new long[]{0x0000000000000772L});
+ public static final BitSet FOLLOW_4 = new BitSet(new long[]{0x0000000000000742L});
+ public static final BitSet FOLLOW_5 = new BitSet(new long[]{0x0000000000000542L});
+ public static final BitSet FOLLOW_6 = new BitSet(new long[]{0x0000000000000442L});
+ public static final BitSet FOLLOW_7 = new BitSet(new long[]{0x0000000000000042L});
+ public static final BitSet FOLLOW_8 = new BitSet(new long[]{0x0000000000000080L});
+ }
+
+
+}
\ No newline at end of file
diff --git a/tests/org.eclipse.xtext.tests/src-gen2/org/eclipse/xtext/lexer/parser/antlr/internal/InternalBacktrackingLexerTestLanguageParser.tokens b/tests/org.eclipse.xtext.tests/src-gen2/org/eclipse/xtext/lexer/parser/antlr/internal/InternalBacktrackingLexerTestLanguageParser.tokens
new file mode 100644
index 000000000..3c69f1218
--- /dev/null
+++ b/tests/org.eclipse.xtext.tests/src-gen2/org/eclipse/xtext/lexer/parser/antlr/internal/InternalBacktrackingLexerTestLanguageParser.tokens
@@ -0,0 +1,10 @@
+'Abc'=4
+'Efg'=5
+RULE_CHARA=6
+RULE_CHARB=7
+RULE_CHARC=11
+RULE_CHARX=8
+RULE_CHARY=10
+RULE_SL_COMMENT=13
+RULE_WS=12
+RULE_YC=9
diff --git a/tests/org.eclipse.xtext.tests/src-gen2/org/eclipse/xtext/lexer/parser/antlr/lexer/InternalBacktrackingLexerTestLanguageLexer.g b/tests/org.eclipse.xtext.tests/src-gen2/org/eclipse/xtext/lexer/parser/antlr/lexer/InternalBacktrackingLexerTestLanguageLexer.g
new file mode 100644
index 000000000..08e6a9eec
--- /dev/null
+++ b/tests/org.eclipse.xtext.tests/src-gen2/org/eclipse/xtext/lexer/parser/antlr/lexer/InternalBacktrackingLexerTestLanguageLexer.g
@@ -0,0 +1,70 @@
+/*
+ * generated by Xtext
+ */
+lexer grammar InternalBacktrackingLexerTestLanguageLexer;
+
+options {
+ backtrack=true;
+ memoize=true;
+}
+tokens {
+ Abc;
+ Efg;
+ RULE_CHARA;
+ RULE_CHARB;
+ RULE_CHARX;
+ RULE_YC;
+ RULE_CHARY;
+ RULE_CHARC;
+ RULE_WS;
+ RULE_SL_COMMENT;
+}
+
+@header {
+package org.eclipse.xtext.lexer.parser.antlr.lexer;
+
+// 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;
+}
+SYNTHETIC_ALL_KEYWORDS :
+ (FRAGMENT_Abc)=> FRAGMENT_Abc {$type = Abc; } |
+ (FRAGMENT_Efg)=> FRAGMENT_Efg {$type = Efg; } |
+ (FRAGMENT_RULE_CHARA)=> FRAGMENT_RULE_CHARA {$type = RULE_CHARA; } |
+ (FRAGMENT_RULE_CHARB)=> FRAGMENT_RULE_CHARB {$type = RULE_CHARB; } |
+ (FRAGMENT_RULE_CHARX)=> FRAGMENT_RULE_CHARX {$type = RULE_CHARX; } |
+ (FRAGMENT_RULE_YC)=> FRAGMENT_RULE_YC {$type = RULE_YC; } |
+ (FRAGMENT_RULE_CHARY)=> FRAGMENT_RULE_CHARY {$type = RULE_CHARY; } |
+ (FRAGMENT_RULE_WS)=> FRAGMENT_RULE_WS {$type = RULE_WS; } |
+ (FRAGMENT_RULE_SL_COMMENT)=> FRAGMENT_RULE_SL_COMMENT {$type = RULE_SL_COMMENT; }
+;
+
+fragment FRAGMENT_Abc : 'Abc';
+
+fragment FRAGMENT_Efg : 'Efg';
+
+
+// Rules duplicated to allow inter-rule references
+
+fragment RULE_CHARA : FRAGMENT_RULE_CHARA;
+fragment FRAGMENT_RULE_CHARA : 'A';
+
+fragment RULE_CHARB : FRAGMENT_RULE_CHARB;
+fragment FRAGMENT_RULE_CHARB : 'b';
+
+fragment RULE_CHARX : FRAGMENT_RULE_CHARX;
+fragment FRAGMENT_RULE_CHARX : 'X';
+
+fragment RULE_YC : FRAGMENT_RULE_YC;
+fragment FRAGMENT_RULE_YC : RULE_CHARY RULE_CHARC;
+
+fragment RULE_CHARY : FRAGMENT_RULE_CHARY;
+fragment FRAGMENT_RULE_CHARY : 'Y';
+
+fragment RULE_CHARC : 'c';
+
+fragment RULE_WS : FRAGMENT_RULE_WS;
+fragment FRAGMENT_RULE_WS : (' '|'\t'|'\r'|'\n')+;
+
+fragment RULE_SL_COMMENT : FRAGMENT_RULE_SL_COMMENT;
+fragment FRAGMENT_RULE_SL_COMMENT : '//' ~(('\n'|'\r'))* ('\r'? '\n')?;
diff --git a/tests/org.eclipse.xtext.tests/src-gen2/org/eclipse/xtext/lexer/parser/antlr/lexer/InternalBacktrackingLexerTestLanguageLexer.java b/tests/org.eclipse.xtext.tests/src-gen2/org/eclipse/xtext/lexer/parser/antlr/lexer/InternalBacktrackingLexerTestLanguageLexer.java
new file mode 100644
index 000000000..b9af440be
--- /dev/null
+++ b/tests/org.eclipse.xtext.tests/src-gen2/org/eclipse/xtext/lexer/parser/antlr/lexer/InternalBacktrackingLexerTestLanguageLexer.java
@@ -0,0 +1,967 @@
+package org.eclipse.xtext.lexer.parser.antlr.lexer;
+
+// 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;
+import java.util.Map;
+import java.util.HashMap;
+@SuppressWarnings("all")
+public class InternalBacktrackingLexerTestLanguageLexer extends Lexer {
+ public static final int FRAGMENT_Abc=14;
+ public static final int FRAGMENT_RULE_CHARY=20;
+ public static final int FRAGMENT_RULE_CHARA=16;
+ public static final int FRAGMENT_RULE_CHARX=18;
+ public static final int RULE_CHARY=10;
+ public static final int Abc=4;
+ public static final int EOF=-1;
+ public static final int RULE_SL_COMMENT=13;
+ public static final int FRAGMENT_RULE_YC=19;
+ public static final int FRAGMENT_RULE_CHARB=17;
+ public static final int FRAGMENT_Efg=15;
+ public static final int SYNTHETIC_ALL_KEYWORDS=23;
+ public static final int RULE_CHARX=8;
+ public static final int FRAGMENT_RULE_SL_COMMENT=22;
+ public static final int Efg=5;
+ public static final int RULE_YC=9;
+ public static final int FRAGMENT_RULE_WS=21;
+ public static final int RULE_CHARA=6;
+ public static final int RULE_WS=12;
+ public static final int RULE_CHARB=7;
+ public static final int RULE_CHARC=11;
+
+ // delegates
+ // delegators
+
+ public InternalBacktrackingLexerTestLanguageLexer() {;}
+ public InternalBacktrackingLexerTestLanguageLexer(CharStream input) {
+ this(input, new RecognizerSharedState());
+ }
+ public InternalBacktrackingLexerTestLanguageLexer(CharStream input, RecognizerSharedState state) {
+ super(input,state);
+ state.ruleMemo = new HashMap[37+1];
+
+ }
+ public String getGrammarFileName() { return "InternalBacktrackingLexerTestLanguageLexer.g"; }
+
+ // $ANTLR start "SYNTHETIC_ALL_KEYWORDS"
+ public final void mSYNTHETIC_ALL_KEYWORDS() throws RecognitionException {
+ int SYNTHETIC_ALL_KEYWORDS_StartIndex = input.index();
+ try {
+ int _type = SYNTHETIC_ALL_KEYWORDS;
+ int _channel = DEFAULT_TOKEN_CHANNEL;
+ if ( state.backtracking>0 && alreadyParsedRule(input, 1) ) { return ; }
+ // InternalBacktrackingLexerTestLanguageLexer.g:30:24: ( ( FRAGMENT_Abc )=> FRAGMENT_Abc | ( FRAGMENT_Efg )=> FRAGMENT_Efg | ( FRAGMENT_RULE_CHARA )=> FRAGMENT_RULE_CHARA | ( FRAGMENT_RULE_CHARB )=> FRAGMENT_RULE_CHARB | ( FRAGMENT_RULE_CHARX )=> FRAGMENT_RULE_CHARX | ( FRAGMENT_RULE_YC )=> FRAGMENT_RULE_YC | ( FRAGMENT_RULE_CHARY )=> FRAGMENT_RULE_CHARY | ( FRAGMENT_RULE_WS )=> FRAGMENT_RULE_WS | ( FRAGMENT_RULE_SL_COMMENT )=> FRAGMENT_RULE_SL_COMMENT )
+ int alt1=9;
+ alt1 = dfa1.predict(input);
+ switch (alt1) {
+ case 1 :
+ // InternalBacktrackingLexerTestLanguageLexer.g:31:2: ( FRAGMENT_Abc )=> FRAGMENT_Abc
+ {
+ mFRAGMENT_Abc(); if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ _type = Abc;
+ }
+
+ }
+ break;
+ case 2 :
+ // InternalBacktrackingLexerTestLanguageLexer.g:32:2: ( FRAGMENT_Efg )=> FRAGMENT_Efg
+ {
+ mFRAGMENT_Efg(); if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ _type = Efg;
+ }
+
+ }
+ break;
+ case 3 :
+ // InternalBacktrackingLexerTestLanguageLexer.g:33:2: ( FRAGMENT_RULE_CHARA )=> FRAGMENT_RULE_CHARA
+ {
+ mFRAGMENT_RULE_CHARA(); if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ _type = RULE_CHARA;
+ }
+
+ }
+ break;
+ case 4 :
+ // InternalBacktrackingLexerTestLanguageLexer.g:34:2: ( FRAGMENT_RULE_CHARB )=> FRAGMENT_RULE_CHARB
+ {
+ mFRAGMENT_RULE_CHARB(); if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ _type = RULE_CHARB;
+ }
+
+ }
+ break;
+ case 5 :
+ // InternalBacktrackingLexerTestLanguageLexer.g:35:2: ( FRAGMENT_RULE_CHARX )=> FRAGMENT_RULE_CHARX
+ {
+ mFRAGMENT_RULE_CHARX(); if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ _type = RULE_CHARX;
+ }
+
+ }
+ break;
+ case 6 :
+ // InternalBacktrackingLexerTestLanguageLexer.g:36:2: ( FRAGMENT_RULE_YC )=> FRAGMENT_RULE_YC
+ {
+ mFRAGMENT_RULE_YC(); if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ _type = RULE_YC;
+ }
+
+ }
+ break;
+ case 7 :
+ // InternalBacktrackingLexerTestLanguageLexer.g:37:2: ( FRAGMENT_RULE_CHARY )=> FRAGMENT_RULE_CHARY
+ {
+ mFRAGMENT_RULE_CHARY(); if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ _type = RULE_CHARY;
+ }
+
+ }
+ break;
+ case 8 :
+ // InternalBacktrackingLexerTestLanguageLexer.g:38:2: ( FRAGMENT_RULE_WS )=> FRAGMENT_RULE_WS
+ {
+ mFRAGMENT_RULE_WS(); if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ _type = RULE_WS;
+ }
+
+ }
+ break;
+ case 9 :
+ // InternalBacktrackingLexerTestLanguageLexer.g:39:2: ( FRAGMENT_RULE_SL_COMMENT )=> FRAGMENT_RULE_SL_COMMENT
+ {
+ mFRAGMENT_RULE_SL_COMMENT(); if (state.failed) return ;
+ if ( state.backtracking==0 ) {
+ _type = RULE_SL_COMMENT;
+ }
+
+ }
+ break;
+
+ }
+ state.type = _type;
+ state.channel = _channel;
+ }
+ finally {
+ if ( state.backtracking>0 ) { memoize(input, 1, SYNTHETIC_ALL_KEYWORDS_StartIndex); }
+ }
+ }
+ // $ANTLR end "SYNTHETIC_ALL_KEYWORDS"
+
+ // $ANTLR start "FRAGMENT_Abc"
+ public final void mFRAGMENT_Abc() throws RecognitionException {
+ int FRAGMENT_Abc_StartIndex = input.index();
+ try {
+ if ( state.backtracking>0 && alreadyParsedRule(input, 2) ) { return ; }
+ // InternalBacktrackingLexerTestLanguageLexer.g:42:23: ( 'Abc' )
+ // InternalBacktrackingLexerTestLanguageLexer.g:42:25: 'Abc'
+ {
+ match("Abc"); if (state.failed) return ;
+
+
+ }
+
+ }
+ finally {
+ if ( state.backtracking>0 ) { memoize(input, 2, FRAGMENT_Abc_StartIndex); }
+ }
+ }
+ // $ANTLR end "FRAGMENT_Abc"
+
+ // $ANTLR start "FRAGMENT_Efg"
+ public final void mFRAGMENT_Efg() throws RecognitionException {
+ int FRAGMENT_Efg_StartIndex = input.index();
+ try {
+ if ( state.backtracking>0 && alreadyParsedRule(input, 3) ) { return ; }
+ // InternalBacktrackingLexerTestLanguageLexer.g:44:23: ( 'Efg' )
+ // InternalBacktrackingLexerTestLanguageLexer.g:44:25: 'Efg'
+ {
+ match("Efg"); if (state.failed) return ;
+
+
+ }
+
+ }
+ finally {
+ if ( state.backtracking>0 ) { memoize(input, 3, FRAGMENT_Efg_StartIndex); }
+ }
+ }
+ // $ANTLR end "FRAGMENT_Efg"
+
+ // $ANTLR start "RULE_CHARA"
+ public final void mRULE_CHARA() throws RecognitionException {
+ int RULE_CHARA_StartIndex = input.index();
+ try {
+ if ( state.backtracking>0 && alreadyParsedRule(input, 4) ) { return ; }
+ // InternalBacktrackingLexerTestLanguageLexer.g:49:21: ( FRAGMENT_RULE_CHARA )
+ // InternalBacktrackingLexerTestLanguageLexer.g:49:23: FRAGMENT_RULE_CHARA
+ {
+ mFRAGMENT_RULE_CHARA(); if (state.failed) return ;
+
+ }
+
+ }
+ finally {
+ if ( state.backtracking>0 ) { memoize(input, 4, RULE_CHARA_StartIndex); }
+ }
+ }
+ // $ANTLR end "RULE_CHARA"
+
+ // $ANTLR start "FRAGMENT_RULE_CHARA"
+ public final void mFRAGMENT_RULE_CHARA() throws RecognitionException {
+ int FRAGMENT_RULE_CHARA_StartIndex = input.index();
+ try {
+ if ( state.backtracking>0 && alreadyParsedRule(input, 5) ) { return ; }
+ // InternalBacktrackingLexerTestLanguageLexer.g:50:30: ( 'A' )
+ // InternalBacktrackingLexerTestLanguageLexer.g:50:32: 'A'
+ {
+ match('A'); if (state.failed) return ;
+
+ }
+
+ }
+ finally {
+ if ( state.backtracking>0 ) { memoize(input, 5, FRAGMENT_RULE_CHARA_StartIndex); }
+ }
+ }
+ // $ANTLR end "FRAGMENT_RULE_CHARA"
+
+ // $ANTLR start "RULE_CHARB"
+ public final void mRULE_CHARB() throws RecognitionException {
+ int RULE_CHARB_StartIndex = input.index();
+ try {
+ if ( state.backtracking>0 && alreadyParsedRule(input, 6) ) { return ; }
+ // InternalBacktrackingLexerTestLanguageLexer.g:52:21: ( FRAGMENT_RULE_CHARB )
+ // InternalBacktrackingLexerTestLanguageLexer.g:52:23: FRAGMENT_RULE_CHARB
+ {
+ mFRAGMENT_RULE_CHARB(); if (state.failed) return ;
+
+ }
+
+ }
+ finally {
+ if ( state.backtracking>0 ) { memoize(input, 6, RULE_CHARB_StartIndex); }
+ }
+ }
+ // $ANTLR end "RULE_CHARB"
+
+ // $ANTLR start "FRAGMENT_RULE_CHARB"
+ public final void mFRAGMENT_RULE_CHARB() throws RecognitionException {
+ int FRAGMENT_RULE_CHARB_StartIndex = input.index();
+ try {
+ if ( state.backtracking>0 && alreadyParsedRule(input, 7) ) { return ; }
+ // InternalBacktrackingLexerTestLanguageLexer.g:53:30: ( 'b' )
+ // InternalBacktrackingLexerTestLanguageLexer.g:53:32: 'b'
+ {
+ match('b'); if (state.failed) return ;
+
+ }
+
+ }
+ finally {
+ if ( state.backtracking>0 ) { memoize(input, 7, FRAGMENT_RULE_CHARB_StartIndex); }
+ }
+ }
+ // $ANTLR end "FRAGMENT_RULE_CHARB"
+
+ // $ANTLR start "RULE_CHARX"
+ public final void mRULE_CHARX() throws RecognitionException {
+ int RULE_CHARX_StartIndex = input.index();
+ try {
+ if ( state.backtracking>0 && alreadyParsedRule(input, 8) ) { return ; }
+ // InternalBacktrackingLexerTestLanguageLexer.g:55:21: ( FRAGMENT_RULE_CHARX )
+ // InternalBacktrackingLexerTestLanguageLexer.g:55:23: FRAGMENT_RULE_CHARX
+ {
+ mFRAGMENT_RULE_CHARX(); if (state.failed) return ;
+
+ }
+
+ }
+ finally {
+ if ( state.backtracking>0 ) { memoize(input, 8, RULE_CHARX_StartIndex); }
+ }
+ }
+ // $ANTLR end "RULE_CHARX"
+
+ // $ANTLR start "FRAGMENT_RULE_CHARX"
+ public final void mFRAGMENT_RULE_CHARX() throws RecognitionException {
+ int FRAGMENT_RULE_CHARX_StartIndex = input.index();
+ try {
+ if ( state.backtracking>0 && alreadyParsedRule(input, 9) ) { return ; }
+ // InternalBacktrackingLexerTestLanguageLexer.g:56:30: ( 'X' )
+ // InternalBacktrackingLexerTestLanguageLexer.g:56:32: 'X'
+ {
+ match('X'); if (state.failed) return ;
+
+ }
+
+ }
+ finally {
+ if ( state.backtracking>0 ) { memoize(input, 9, FRAGMENT_RULE_CHARX_StartIndex); }
+ }
+ }
+ // $ANTLR end "FRAGMENT_RULE_CHARX"
+
+ // $ANTLR start "RULE_YC"
+ public final void mRULE_YC() throws RecognitionException {
+ int RULE_YC_StartIndex = input.index();
+ try {
+ if ( state.backtracking>0 && alreadyParsedRule(input, 10) ) { return ; }
+ // InternalBacktrackingLexerTestLanguageLexer.g:58:18: ( FRAGMENT_RULE_YC )
+ // InternalBacktrackingLexerTestLanguageLexer.g:58:20: FRAGMENT_RULE_YC
+ {
+ mFRAGMENT_RULE_YC(); if (state.failed) return ;
+
+ }
+
+ }
+ finally {
+ if ( state.backtracking>0 ) { memoize(input, 10, RULE_YC_StartIndex); }
+ }
+ }
+ // $ANTLR end "RULE_YC"
+
+ // $ANTLR start "FRAGMENT_RULE_YC"
+ public final void mFRAGMENT_RULE_YC() throws RecognitionException {
+ int FRAGMENT_RULE_YC_StartIndex = input.index();
+ try {
+ if ( state.backtracking>0 && alreadyParsedRule(input, 11) ) { return ; }
+ // InternalBacktrackingLexerTestLanguageLexer.g:59:27: ( RULE_CHARY RULE_CHARC )
+ // InternalBacktrackingLexerTestLanguageLexer.g:59:29: RULE_CHARY RULE_CHARC
+ {
+ mRULE_CHARY(); if (state.failed) return ;
+ mRULE_CHARC(); if (state.failed) return ;
+
+ }
+
+ }
+ finally {
+ if ( state.backtracking>0 ) { memoize(input, 11, FRAGMENT_RULE_YC_StartIndex); }
+ }
+ }
+ // $ANTLR end "FRAGMENT_RULE_YC"
+
+ // $ANTLR start "RULE_CHARY"
+ public final void mRULE_CHARY() throws RecognitionException {
+ int RULE_CHARY_StartIndex = input.index();
+ try {
+ if ( state.backtracking>0 && alreadyParsedRule(input, 12) ) { return ; }
+ // InternalBacktrackingLexerTestLanguageLexer.g:61:21: ( FRAGMENT_RULE_CHARY )
+ // InternalBacktrackingLexerTestLanguageLexer.g:61:23: FRAGMENT_RULE_CHARY
+ {
+ mFRAGMENT_RULE_CHARY(); if (state.failed) return ;
+
+ }
+
+ }
+ finally {
+ if ( state.backtracking>0 ) { memoize(input, 12, RULE_CHARY_StartIndex); }
+ }
+ }
+ // $ANTLR end "RULE_CHARY"
+
+ // $ANTLR start "FRAGMENT_RULE_CHARY"
+ public final void mFRAGMENT_RULE_CHARY() throws RecognitionException {
+ int FRAGMENT_RULE_CHARY_StartIndex = input.index();
+ try {
+ if ( state.backtracking>0 && alreadyParsedRule(input, 13) ) { return ; }
+ // InternalBacktrackingLexerTestLanguageLexer.g:62:30: ( 'Y' )
+ // InternalBacktrackingLexerTestLanguageLexer.g:62:32: 'Y'
+ {
+ match('Y'); if (state.failed) return ;
+
+ }
+
+ }
+ finally {
+ if ( state.backtracking>0 ) { memoize(input, 13, FRAGMENT_RULE_CHARY_StartIndex); }
+ }
+ }
+ // $ANTLR end "FRAGMENT_RULE_CHARY"
+
+ // $ANTLR start "RULE_CHARC"
+ public final void mRULE_CHARC() throws RecognitionException {
+ int RULE_CHARC_StartIndex = input.index();
+ try {
+ if ( state.backtracking>0 && alreadyParsedRule(input, 14) ) { return ; }
+ // InternalBacktrackingLexerTestLanguageLexer.g:64:21: ( 'c' )
+ // InternalBacktrackingLexerTestLanguageLexer.g:64:23: 'c'
+ {
+ match('c'); if (state.failed) return ;
+
+ }
+
+ }
+ finally {
+ if ( state.backtracking>0 ) { memoize(input, 14, RULE_CHARC_StartIndex); }
+ }
+ }
+ // $ANTLR end "RULE_CHARC"
+
+ // $ANTLR start "RULE_WS"
+ public final void mRULE_WS() throws RecognitionException {
+ int RULE_WS_StartIndex = input.index();
+ try {
+ if ( state.backtracking>0 && alreadyParsedRule(input, 15) ) { return ; }
+ // InternalBacktrackingLexerTestLanguageLexer.g:66:18: ( FRAGMENT_RULE_WS )
+ // InternalBacktrackingLexerTestLanguageLexer.g:66:20: FRAGMENT_RULE_WS
+ {
+ mFRAGMENT_RULE_WS(); if (state.failed) return ;
+
+ }
+
+ }
+ finally {
+ if ( state.backtracking>0 ) { memoize(input, 15, RULE_WS_StartIndex); }
+ }
+ }
+ // $ANTLR end "RULE_WS"
+
+ // $ANTLR start "FRAGMENT_RULE_WS"
+ public final void mFRAGMENT_RULE_WS() throws RecognitionException {
+ int FRAGMENT_RULE_WS_StartIndex = input.index();
+ try {
+ if ( state.backtracking>0 && alreadyParsedRule(input, 16) ) { return ; }
+ // InternalBacktrackingLexerTestLanguageLexer.g:67:27: ( ( ' ' | '\\t' | '\\r' | '\\n' )+ )
+ // InternalBacktrackingLexerTestLanguageLexer.g:67:29: ( ' ' | '\\t' | '\\r' | '\\n' )+
+ {
+ // InternalBacktrackingLexerTestLanguageLexer.g:67:29: ( ' ' | '\\t' | '\\r' | '\\n' )+
+ int cnt2=0;
+ loop2:
+ do {
+ int alt2=2;
+ int LA2_0 = input.LA(1);
+
+ if ( ((LA2_0>='\t' && LA2_0<='\n')||LA2_0=='\r'||LA2_0==' ') ) {
+ alt2=1;
+ }
+
+
+ switch (alt2) {
+ case 1 :
+ // InternalBacktrackingLexerTestLanguageLexer.g:
+ {
+ if ( (input.LA(1)>='\t' && input.LA(1)<='\n')||input.LA(1)=='\r'||input.LA(1)==' ' ) {
+ input.consume();
+ state.failed=false;
+ }
+ else {
+ if (state.backtracking>0) {state.failed=true; return ;}
+ MismatchedSetException mse = new MismatchedSetException(null,input);
+ recover(mse);
+ throw mse;}
+
+
+ }
+ break;
+
+ default :
+ if ( cnt2 >= 1 ) break loop2;
+ if (state.backtracking>0) {state.failed=true; return ;}
+ EarlyExitException eee =
+ new EarlyExitException(2, input);
+ throw eee;
+ }
+ cnt2++;
+ } while (true);
+
+
+ }
+
+ }
+ finally {
+ if ( state.backtracking>0 ) { memoize(input, 16, FRAGMENT_RULE_WS_StartIndex); }
+ }
+ }
+ // $ANTLR end "FRAGMENT_RULE_WS"
+
+ // $ANTLR start "RULE_SL_COMMENT"
+ public final void mRULE_SL_COMMENT() throws RecognitionException {
+ int RULE_SL_COMMENT_StartIndex = input.index();
+ try {
+ if ( state.backtracking>0 && alreadyParsedRule(input, 17) ) { return ; }
+ // InternalBacktrackingLexerTestLanguageLexer.g:69:26: ( FRAGMENT_RULE_SL_COMMENT )
+ // InternalBacktrackingLexerTestLanguageLexer.g:69:28: FRAGMENT_RULE_SL_COMMENT
+ {
+ mFRAGMENT_RULE_SL_COMMENT(); if (state.failed) return ;
+
+ }
+
+ }
+ finally {
+ if ( state.backtracking>0 ) { memoize(input, 17, RULE_SL_COMMENT_StartIndex); }
+ }
+ }
+ // $ANTLR end "RULE_SL_COMMENT"
+
+ // $ANTLR start "FRAGMENT_RULE_SL_COMMENT"
+ public final void mFRAGMENT_RULE_SL_COMMENT() throws RecognitionException {
+ int FRAGMENT_RULE_SL_COMMENT_StartIndex = input.index();
+ try {
+ if ( state.backtracking>0 && alreadyParsedRule(input, 18) ) { return ; }
+ // InternalBacktrackingLexerTestLanguageLexer.g:70:35: ( '//' (~ ( ( '\\n' | '\\r' ) ) )* ( ( '\\r' )? '\\n' )? )
+ // InternalBacktrackingLexerTestLanguageLexer.g:70:37: '//' (~ ( ( '\\n' | '\\r' ) ) )* ( ( '\\r' )? '\\n' )?
+ {
+ match("//"); if (state.failed) return ;
+
+ // InternalBacktrackingLexerTestLanguageLexer.g:70:42: (~ ( ( '\\n' | '\\r' ) ) )*
+ loop3:
+ do {
+ int alt3=2;
+ int LA3_0 = input.LA(1);
+
+ if ( ((LA3_0>='\u0000' && LA3_0<='\t')||(LA3_0>='\u000B' && LA3_0<='\f')||(LA3_0>='\u000E' && LA3_0<='\uFFFF')) ) {
+ alt3=1;
+ }
+
+
+ switch (alt3) {
+ case 1 :
+ // InternalBacktrackingLexerTestLanguageLexer.g:0:0: ~ ( ( '\\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();
+ state.failed=false;
+ }
+ else {
+ if (state.backtracking>0) {state.failed=true; return ;}
+ MismatchedSetException mse = new MismatchedSetException(null,input);
+ recover(mse);
+ throw mse;}
+
+
+ }
+ break;
+
+ default :
+ break loop3;
+ }
+ } while (true);
+
+ // InternalBacktrackingLexerTestLanguageLexer.g:70:58: ( ( '\\r' )? '\\n' )?
+ int alt5=2;
+ int LA5_0 = input.LA(1);
+
+ if ( (LA5_0=='\n'||LA5_0=='\r') ) {
+ alt5=1;
+ }
+ switch (alt5) {
+ case 1 :
+ // InternalBacktrackingLexerTestLanguageLexer.g:70:59: ( '\\r' )? '\\n'
+ {
+ // InternalBacktrackingLexerTestLanguageLexer.g:70:59: ( '\\r' )?
+ int alt4=2;
+ int LA4_0 = input.LA(1);
+
+ if ( (LA4_0=='\r') ) {
+ alt4=1;
+ }
+ switch (alt4) {
+ case 1 :
+ // InternalBacktrackingLexerTestLanguageLexer.g:0:0: '\\r'
+ {
+ match('\r'); if (state.failed) return ;
+
+ }
+ break;
+
+ }
+
+ match('\n'); if (state.failed) return ;
+
+ }
+ break;
+
+ }
+
+
+ }
+
+ }
+ finally {
+ if ( state.backtracking>0 ) { memoize(input, 18, FRAGMENT_RULE_SL_COMMENT_StartIndex); }
+ }
+ }
+ // $ANTLR end "FRAGMENT_RULE_SL_COMMENT"
+
+ public void mTokens() throws RecognitionException {
+ // InternalBacktrackingLexerTestLanguageLexer.g:1:8: ( SYNTHETIC_ALL_KEYWORDS )
+ // InternalBacktrackingLexerTestLanguageLexer.g:1:10: SYNTHETIC_ALL_KEYWORDS
+ {
+ mSYNTHETIC_ALL_KEYWORDS(); if (state.failed) return ;
+
+ }
+
+
+ }
+
+ // $ANTLR start synpred1_InternalBacktrackingLexerTestLanguageLexer
+ public final void synpred1_InternalBacktrackingLexerTestLanguageLexer_fragment() throws RecognitionException {
+ // InternalBacktrackingLexerTestLanguageLexer.g:31:2: ( FRAGMENT_Abc )
+ // InternalBacktrackingLexerTestLanguageLexer.g:31:3: FRAGMENT_Abc
+ {
+ mFRAGMENT_Abc(); if (state.failed) return ;
+
+ }
+ }
+ // $ANTLR end synpred1_InternalBacktrackingLexerTestLanguageLexer
+
+ // $ANTLR start synpred2_InternalBacktrackingLexerTestLanguageLexer
+ public final void synpred2_InternalBacktrackingLexerTestLanguageLexer_fragment() throws RecognitionException {
+ // InternalBacktrackingLexerTestLanguageLexer.g:32:2: ( FRAGMENT_Efg )
+ // InternalBacktrackingLexerTestLanguageLexer.g:32:3: FRAGMENT_Efg
+ {
+ mFRAGMENT_Efg(); if (state.failed) return ;
+
+ }
+ }
+ // $ANTLR end synpred2_InternalBacktrackingLexerTestLanguageLexer
+
+ // $ANTLR start synpred3_InternalBacktrackingLexerTestLanguageLexer
+ public final void synpred3_InternalBacktrackingLexerTestLanguageLexer_fragment() throws RecognitionException {
+ // InternalBacktrackingLexerTestLanguageLexer.g:33:2: ( FRAGMENT_RULE_CHARA )
+ // InternalBacktrackingLexerTestLanguageLexer.g:33:3: FRAGMENT_RULE_CHARA
+ {
+ mFRAGMENT_RULE_CHARA(); if (state.failed) return ;
+
+ }
+ }
+ // $ANTLR end synpred3_InternalBacktrackingLexerTestLanguageLexer
+
+ // $ANTLR start synpred4_InternalBacktrackingLexerTestLanguageLexer
+ public final void synpred4_InternalBacktrackingLexerTestLanguageLexer_fragment() throws RecognitionException {
+ // InternalBacktrackingLexerTestLanguageLexer.g:34:2: ( FRAGMENT_RULE_CHARB )
+ // InternalBacktrackingLexerTestLanguageLexer.g:34:3: FRAGMENT_RULE_CHARB
+ {
+ mFRAGMENT_RULE_CHARB(); if (state.failed) return ;
+
+ }
+ }
+ // $ANTLR end synpred4_InternalBacktrackingLexerTestLanguageLexer
+
+ // $ANTLR start synpred5_InternalBacktrackingLexerTestLanguageLexer
+ public final void synpred5_InternalBacktrackingLexerTestLanguageLexer_fragment() throws RecognitionException {
+ // InternalBacktrackingLexerTestLanguageLexer.g:35:2: ( FRAGMENT_RULE_CHARX )
+ // InternalBacktrackingLexerTestLanguageLexer.g:35:3: FRAGMENT_RULE_CHARX
+ {
+ mFRAGMENT_RULE_CHARX(); if (state.failed) return ;
+
+ }
+ }
+ // $ANTLR end synpred5_InternalBacktrackingLexerTestLanguageLexer
+
+ // $ANTLR start synpred6_InternalBacktrackingLexerTestLanguageLexer
+ public final void synpred6_InternalBacktrackingLexerTestLanguageLexer_fragment() throws RecognitionException {
+ // InternalBacktrackingLexerTestLanguageLexer.g:36:2: ( FRAGMENT_RULE_YC )
+ // InternalBacktrackingLexerTestLanguageLexer.g:36:3: FRAGMENT_RULE_YC
+ {
+ mFRAGMENT_RULE_YC(); if (state.failed) return ;
+
+ }
+ }
+ // $ANTLR end synpred6_InternalBacktrackingLexerTestLanguageLexer
+
+ // $ANTLR start synpred7_InternalBacktrackingLexerTestLanguageLexer
+ public final void synpred7_InternalBacktrackingLexerTestLanguageLexer_fragment() throws RecognitionException {
+ // InternalBacktrackingLexerTestLanguageLexer.g:37:2: ( FRAGMENT_RULE_CHARY )
+ // InternalBacktrackingLexerTestLanguageLexer.g:37:3: FRAGMENT_RULE_CHARY
+ {
+ mFRAGMENT_RULE_CHARY(); if (state.failed) return ;
+
+ }
+ }
+ // $ANTLR end synpred7_InternalBacktrackingLexerTestLanguageLexer
+
+ // $ANTLR start synpred8_InternalBacktrackingLexerTestLanguageLexer
+ public final void synpred8_InternalBacktrackingLexerTestLanguageLexer_fragment() throws RecognitionException {
+ // InternalBacktrackingLexerTestLanguageLexer.g:38:2: ( FRAGMENT_RULE_WS )
+ // InternalBacktrackingLexerTestLanguageLexer.g:38:3: FRAGMENT_RULE_WS
+ {
+ mFRAGMENT_RULE_WS(); if (state.failed) return ;
+
+ }
+ }
+ // $ANTLR end synpred8_InternalBacktrackingLexerTestLanguageLexer
+
+ // $ANTLR start synpred9_InternalBacktrackingLexerTestLanguageLexer
+ public final void synpred9_InternalBacktrackingLexerTestLanguageLexer_fragment() throws RecognitionException {
+ // InternalBacktrackingLexerTestLanguageLexer.g:39:2: ( FRAGMENT_RULE_SL_COMMENT )
+ // InternalBacktrackingLexerTestLanguageLexer.g:39:3: FRAGMENT_RULE_SL_COMMENT
+ {
+ mFRAGMENT_RULE_SL_COMMENT(); if (state.failed) return ;
+
+ }
+ }
+ // $ANTLR end synpred9_InternalBacktrackingLexerTestLanguageLexer
+
+ public final boolean synpred2_InternalBacktrackingLexerTestLanguageLexer() {
+ state.backtracking++;
+ int start = input.mark();
+ try {
+ synpred2_InternalBacktrackingLexerTestLanguageLexer_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_InternalBacktrackingLexerTestLanguageLexer() {
+ state.backtracking++;
+ int start = input.mark();
+ try {
+ synpred8_InternalBacktrackingLexerTestLanguageLexer_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_InternalBacktrackingLexerTestLanguageLexer() {
+ state.backtracking++;
+ int start = input.mark();
+ try {
+ synpred3_InternalBacktrackingLexerTestLanguageLexer_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_InternalBacktrackingLexerTestLanguageLexer() {
+ state.backtracking++;
+ int start = input.mark();
+ try {
+ synpred7_InternalBacktrackingLexerTestLanguageLexer_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_InternalBacktrackingLexerTestLanguageLexer() {
+ state.backtracking++;
+ int start = input.mark();
+ try {
+ synpred5_InternalBacktrackingLexerTestLanguageLexer_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_InternalBacktrackingLexerTestLanguageLexer() {
+ state.backtracking++;
+ int start = input.mark();
+ try {
+ synpred1_InternalBacktrackingLexerTestLanguageLexer_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_InternalBacktrackingLexerTestLanguageLexer() {
+ state.backtracking++;
+ int start = input.mark();
+ try {
+ synpred9_InternalBacktrackingLexerTestLanguageLexer_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_InternalBacktrackingLexerTestLanguageLexer() {
+ state.backtracking++;
+ int start = input.mark();
+ try {
+ synpred4_InternalBacktrackingLexerTestLanguageLexer_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_InternalBacktrackingLexerTestLanguageLexer() {
+ state.backtracking++;
+ int start = input.mark();
+ try {
+ synpred6_InternalBacktrackingLexerTestLanguageLexer_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 DFA1 dfa1 = new DFA1(this);
+ static final String DFA1_eotS =
+ "\1\uffff\1\11\3\uffff\1\12\6\uffff";
+ static final String DFA1_eofS =
+ "\14\uffff";
+ static final String DFA1_minS =
+ "\1\11\1\142\3\uffff\1\143\6\uffff";
+ static final String DFA1_maxS =
+ "\2\142\3\uffff\1\143\6\uffff";
+ static final String DFA1_acceptS =
+ "\2\uffff\1\2\1\4\1\5\1\uffff\1\10\1\11\1\1\1\3\1\7\1\6";
+ static final String DFA1_specialS =
+ "\1\2\1\1\3\uffff\1\0\6\uffff}>";
+ static final String[] DFA1_transitionS = {
+ "\2\6\2\uffff\1\6\22\uffff\1\6\16\uffff\1\7\21\uffff\1\1\3\uffff\1\2\22\uffff\1\4\1\5\10\uffff\1\3",
+ "\1\10",
+ "",
+ "",
+ "",
+ "\1\13",
+ "",
+ "",
+ "",
+ "",
+ "",
+ ""
+ };
+
+ static final short[] DFA1_eot = DFA.unpackEncodedString(DFA1_eotS);
+ static final short[] DFA1_eof = DFA.unpackEncodedString(DFA1_eofS);
+ static final char[] DFA1_min = DFA.unpackEncodedStringToUnsignedChars(DFA1_minS);
+ static final char[] DFA1_max = DFA.unpackEncodedStringToUnsignedChars(DFA1_maxS);
+ static final short[] DFA1_accept = DFA.unpackEncodedString(DFA1_acceptS);
+ static final short[] DFA1_special = DFA.unpackEncodedString(DFA1_specialS);
+ static final short[][] DFA1_transition;
+
+ static {
+ int numStates = DFA1_transitionS.length;
+ DFA1_transition = new short[numStates][];
+ for (int i=0; i FRAGMENT_Abc | ( FRAGMENT_Efg )=> FRAGMENT_Efg | ( FRAGMENT_RULE_CHARA )=> FRAGMENT_RULE_CHARA | ( FRAGMENT_RULE_CHARB )=> FRAGMENT_RULE_CHARB | ( FRAGMENT_RULE_CHARX )=> FRAGMENT_RULE_CHARX | ( FRAGMENT_RULE_YC )=> FRAGMENT_RULE_YC | ( FRAGMENT_RULE_CHARY )=> FRAGMENT_RULE_CHARY | ( FRAGMENT_RULE_WS )=> FRAGMENT_RULE_WS | ( FRAGMENT_RULE_SL_COMMENT )=> FRAGMENT_RULE_SL_COMMENT );";
+ }
+ public int specialStateTransition(int s, IntStream _input) throws NoViableAltException {
+ IntStream input = _input;
+ int _s = s;
+ switch ( s ) {
+ case 0 :
+ int LA1_5 = input.LA(1);
+
+
+ int index1_5 = input.index();
+ input.rewind();
+ s = -1;
+ if ( (LA1_5=='c') && (synpred6_InternalBacktrackingLexerTestLanguageLexer())) {s = 11;}
+
+ else s = 10;
+
+
+ input.seek(index1_5);
+ if ( s>=0 ) return s;
+ break;
+ case 1 :
+ int LA1_1 = input.LA(1);
+
+
+ int index1_1 = input.index();
+ input.rewind();
+ s = -1;
+ if ( (LA1_1=='b') && (synpred1_InternalBacktrackingLexerTestLanguageLexer())) {s = 8;}
+
+ else s = 9;
+
+
+ input.seek(index1_1);
+ if ( s>=0 ) return s;
+ break;
+ case 2 :
+ int LA1_0 = input.LA(1);
+
+
+ int index1_0 = input.index();
+ input.rewind();
+ s = -1;
+ if ( (LA1_0=='A') ) {s = 1;}
+
+ else if ( (LA1_0=='E') && (synpred2_InternalBacktrackingLexerTestLanguageLexer())) {s = 2;}
+
+ else if ( (LA1_0=='b') && (synpred4_InternalBacktrackingLexerTestLanguageLexer())) {s = 3;}
+
+ else if ( (LA1_0=='X') && (synpred5_InternalBacktrackingLexerTestLanguageLexer())) {s = 4;}
+
+ else if ( (LA1_0=='Y') ) {s = 5;}
+
+ else if ( ((LA1_0>='\t' && LA1_0<='\n')||LA1_0=='\r'||LA1_0==' ') && (synpred8_InternalBacktrackingLexerTestLanguageLexer())) {s = 6;}
+
+ else if ( (LA1_0=='/') && (synpred9_InternalBacktrackingLexerTestLanguageLexer())) {s = 7;}
+
+
+ input.seek(index1_0);
+ if ( s>=0 ) return s;
+ break;
+ }
+ if (state.backtracking>0) {state.failed=true; return -1;}
+ NoViableAltException nvae =
+ new NoViableAltException(getDescription(), 1, _s, input);
+ error(nvae);
+ throw nvae;
+ }
+ }
+
+
+}
\ No newline at end of file
diff --git a/tests/org.eclipse.xtext.tests/src-gen2/org/eclipse/xtext/lexer/parser/antlr/lexer/InternalBacktrackingLexerTestLanguageLexer.tokens b/tests/org.eclipse.xtext.tests/src-gen2/org/eclipse/xtext/lexer/parser/antlr/lexer/InternalBacktrackingLexerTestLanguageLexer.tokens
new file mode 100644
index 000000000..6eebab048
--- /dev/null
+++ b/tests/org.eclipse.xtext.tests/src-gen2/org/eclipse/xtext/lexer/parser/antlr/lexer/InternalBacktrackingLexerTestLanguageLexer.tokens
@@ -0,0 +1,10 @@
+Abc=4
+Efg=5
+RULE_CHARA=6
+RULE_CHARB=7
+RULE_CHARC=11
+RULE_CHARX=8
+RULE_CHARY=10
+RULE_SL_COMMENT=13
+RULE_WS=12
+RULE_YC=9
diff --git a/tests/org.eclipse.xtext.tests/src-gen2/org/eclipse/xtext/lexer/serializer/BacktrackingLexerTestLanguageSemanticSequencer.java b/tests/org.eclipse.xtext.tests/src-gen2/org/eclipse/xtext/lexer/serializer/BacktrackingLexerTestLanguageSemanticSequencer.java
new file mode 100644
index 000000000..cb406964c
--- /dev/null
+++ b/tests/org.eclipse.xtext.tests/src-gen2/org/eclipse/xtext/lexer/serializer/BacktrackingLexerTestLanguageSemanticSequencer.java
@@ -0,0 +1,110 @@
+/*
+ * generated by Xtext
+ */
+package org.eclipse.xtext.lexer.serializer;
+
+import com.google.inject.Inject;
+import java.util.Set;
+import org.eclipse.emf.ecore.EObject;
+import org.eclipse.emf.ecore.EPackage;
+import org.eclipse.xtext.Action;
+import org.eclipse.xtext.Parameter;
+import org.eclipse.xtext.ParserRule;
+import org.eclipse.xtext.lexer.backtrackingTestLanguage.Ab;
+import org.eclipse.xtext.lexer.backtrackingTestLanguage.BacktrackingTestLanguagePackage;
+import org.eclipse.xtext.lexer.backtrackingTestLanguage.Model;
+import org.eclipse.xtext.lexer.backtrackingTestLanguage.Xb;
+import org.eclipse.xtext.lexer.services.BacktrackingLexerTestLanguageGrammarAccess;
+import org.eclipse.xtext.serializer.ISerializationContext;
+import org.eclipse.xtext.serializer.acceptor.SequenceFeeder;
+import org.eclipse.xtext.serializer.sequencer.AbstractDelegatingSemanticSequencer;
+import org.eclipse.xtext.serializer.sequencer.ITransientValueService.ValueTransient;
+
+@SuppressWarnings("all")
+public class BacktrackingLexerTestLanguageSemanticSequencer extends AbstractDelegatingSemanticSequencer {
+
+ @Inject
+ private BacktrackingLexerTestLanguageGrammarAccess grammarAccess;
+
+ @Override
+ public void sequence(ISerializationContext context, EObject semanticObject) {
+ EPackage epackage = semanticObject.eClass().getEPackage();
+ ParserRule rule = context.getParserRule();
+ Action action = context.getAssignedAction();
+ Set parameters = context.getEnabledBooleanParameters();
+ if (epackage == BacktrackingTestLanguagePackage.eINSTANCE)
+ switch (semanticObject.eClass().getClassifierID()) {
+ case BacktrackingTestLanguagePackage.AB:
+ sequence_Ab(context, (Ab) semanticObject);
+ return;
+ case BacktrackingTestLanguagePackage.MODEL:
+ sequence_Model(context, (Model) semanticObject);
+ return;
+ case BacktrackingTestLanguagePackage.XB:
+ sequence_Xb(context, (Xb) semanticObject);
+ return;
+ }
+ if (errorAcceptor != null)
+ errorAcceptor.accept(diagnosticProvider.createInvalidContextOrTypeDiagnostic(semanticObject, context));
+ }
+
+ /**
+ * Contexts:
+ * Ab returns Ab
+ *
+ * Constraint:
+ * (x=CharA y=Charb)
+ */
+ protected void sequence_Ab(ISerializationContext context, Ab semanticObject) {
+ if (errorAcceptor != null) {
+ if (transientValues.isValueTransient(semanticObject, BacktrackingTestLanguagePackage.Literals.AB__X) == ValueTransient.YES)
+ errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, BacktrackingTestLanguagePackage.Literals.AB__X));
+ if (transientValues.isValueTransient(semanticObject, BacktrackingTestLanguagePackage.Literals.AB__Y) == ValueTransient.YES)
+ errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, BacktrackingTestLanguagePackage.Literals.AB__Y));
+ }
+ SequenceFeeder feeder = createSequencerFeeder(context, semanticObject);
+ feeder.accept(grammarAccess.getAbAccess().getXCharATerminalRuleCall_0_0(), semanticObject.getX());
+ feeder.accept(grammarAccess.getAbAccess().getYCharbTerminalRuleCall_1_0(), semanticObject.getY());
+ feeder.finish();
+ }
+
+
+ /**
+ * Contexts:
+ * Model returns Model
+ *
+ * Constraint:
+ * (
+ * (enums+=EnumName+ ycs+=Yc+ abs+=Ab+ xbs+=Xb+ ((ys+=CharY+ as+=CharA+) | as+=CharA+)?) |
+ * (((enums+=EnumName+ abs+=Ab+) | (enums+=EnumName+ ycs+=Yc+ abs+=Ab+) | abs+=Ab+)? ys+=CharY+ as+=CharA+) |
+ * enums+=EnumName+ |
+ * (enums+=EnumName+ (ycs+=Yc+ | (ycs+=Yc+ (abs+=Ab+ | (abs+=Ab+ as+=CharA+))))?)
+ * )?
+ */
+ protected void sequence_Model(ISerializationContext context, Model semanticObject) {
+ genericSequencer.createSequence(context, semanticObject);
+ }
+
+
+ /**
+ * Contexts:
+ * Xb returns Xb
+ *
+ * Constraint:
+ * (x=CharX y=Charb)
+ */
+ protected void sequence_Xb(ISerializationContext context, Xb semanticObject) {
+ if (errorAcceptor != null) {
+ if (transientValues.isValueTransient(semanticObject, BacktrackingTestLanguagePackage.Literals.XB__X) == ValueTransient.YES)
+ errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, BacktrackingTestLanguagePackage.Literals.XB__X));
+ if (transientValues.isValueTransient(semanticObject, BacktrackingTestLanguagePackage.Literals.XB__Y) == ValueTransient.YES)
+ errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, BacktrackingTestLanguagePackage.Literals.XB__Y));
+ }
+ SequenceFeeder feeder = createSequencerFeeder(context, semanticObject);
+ feeder.accept(grammarAccess.getXbAccess().getXCharXTerminalRuleCall_0_0(), semanticObject.getX());
+ feeder.accept(grammarAccess.getXbAccess().getYCharbTerminalRuleCall_1_0(), semanticObject.getY());
+ feeder.finish();
+ }
+
+
+}
diff --git a/tests/org.eclipse.xtext.tests/src-gen2/org/eclipse/xtext/lexer/serializer/BacktrackingLexerTestLanguageSyntacticSequencer.java b/tests/org.eclipse.xtext.tests/src-gen2/org/eclipse/xtext/lexer/serializer/BacktrackingLexerTestLanguageSyntacticSequencer.java
new file mode 100644
index 000000000..c2ef5aad8
--- /dev/null
+++ b/tests/org.eclipse.xtext.tests/src-gen2/org/eclipse/xtext/lexer/serializer/BacktrackingLexerTestLanguageSyntacticSequencer.java
@@ -0,0 +1,43 @@
+/*
+ * generated by Xtext
+ */
+package org.eclipse.xtext.lexer.serializer;
+
+import com.google.inject.Inject;
+import java.util.List;
+import org.eclipse.emf.ecore.EObject;
+import org.eclipse.xtext.IGrammarAccess;
+import org.eclipse.xtext.RuleCall;
+import org.eclipse.xtext.lexer.services.BacktrackingLexerTestLanguageGrammarAccess;
+import org.eclipse.xtext.nodemodel.INode;
+import org.eclipse.xtext.serializer.analysis.GrammarAlias.AbstractElementAlias;
+import org.eclipse.xtext.serializer.analysis.ISyntacticSequencerPDAProvider.ISynTransition;
+import org.eclipse.xtext.serializer.sequencer.AbstractSyntacticSequencer;
+
+@SuppressWarnings("all")
+public class BacktrackingLexerTestLanguageSyntacticSequencer extends AbstractSyntacticSequencer {
+
+ protected BacktrackingLexerTestLanguageGrammarAccess grammarAccess;
+
+ @Inject
+ protected void init(IGrammarAccess access) {
+ grammarAccess = (BacktrackingLexerTestLanguageGrammarAccess) access;
+ }
+
+ @Override
+ protected String getUnassignedRuleCallToken(EObject semanticObject, RuleCall ruleCall, INode node) {
+ return "";
+ }
+
+
+ @Override
+ protected void emitUnassignedTokens(EObject semanticObject, ISynTransition transition, INode fromNode, INode toNode) {
+ if (transition.getAmbiguousSyntaxes().isEmpty()) return;
+ List transitionNodes = collectNodes(fromNode, toNode);
+ for (AbstractElementAlias syntax : transition.getAmbiguousSyntaxes()) {
+ List syntaxNodes = getNodesFor(transitionNodes, syntax);
+ acceptNodes(getLastNavigableState(), syntaxNodes);
+ }
+ }
+
+}
diff --git a/tests/org.eclipse.xtext.tests/src-gen2/org/eclipse/xtext/lexer/services/BacktrackingLexerTestLanguageGrammarAccess.java b/tests/org.eclipse.xtext.tests/src-gen2/org/eclipse/xtext/lexer/services/BacktrackingLexerTestLanguageGrammarAccess.java
new file mode 100644
index 000000000..eea631960
--- /dev/null
+++ b/tests/org.eclipse.xtext.tests/src-gen2/org/eclipse/xtext/lexer/services/BacktrackingLexerTestLanguageGrammarAccess.java
@@ -0,0 +1,321 @@
+/*
+ * generated by Xtext
+ */
+package org.eclipse.xtext.lexer.services;
+
+import com.google.inject.Inject;
+import com.google.inject.Singleton;
+import java.util.List;
+import org.eclipse.xtext.Alternatives;
+import org.eclipse.xtext.Assignment;
+import org.eclipse.xtext.EnumLiteralDeclaration;
+import org.eclipse.xtext.EnumRule;
+import org.eclipse.xtext.Grammar;
+import org.eclipse.xtext.GrammarUtil;
+import org.eclipse.xtext.Group;
+import org.eclipse.xtext.Keyword;
+import org.eclipse.xtext.ParserRule;
+import org.eclipse.xtext.RuleCall;
+import org.eclipse.xtext.TerminalRule;
+import org.eclipse.xtext.service.AbstractElementFinder.AbstractEnumRuleElementFinder;
+import org.eclipse.xtext.service.AbstractElementFinder.AbstractGrammarElementFinder;
+import org.eclipse.xtext.service.GrammarProvider;
+
+@Singleton
+public class BacktrackingLexerTestLanguageGrammarAccess extends AbstractGrammarElementFinder {
+
+ public class ModelElements extends AbstractParserRuleElementFinder {
+ private final ParserRule rule = (ParserRule) GrammarUtil.findRuleForName(getGrammar(), "org.eclipse.xtext.lexer.BacktrackingLexerTestLanguage.Model");
+ private final Group cGroup = (Group)rule.eContents().get(1);
+ private final Assignment cEnumsAssignment_0 = (Assignment)cGroup.eContents().get(0);
+ private final RuleCall cEnumsEnumNameEnumRuleCall_0_0 = (RuleCall)cEnumsAssignment_0.eContents().get(0);
+ private final Assignment cYcsAssignment_1 = (Assignment)cGroup.eContents().get(1);
+ private final RuleCall cYcsYcTerminalRuleCall_1_0 = (RuleCall)cYcsAssignment_1.eContents().get(0);
+ private final Assignment cAbsAssignment_2 = (Assignment)cGroup.eContents().get(2);
+ private final RuleCall cAbsAbParserRuleCall_2_0 = (RuleCall)cAbsAssignment_2.eContents().get(0);
+ private final Assignment cXbsAssignment_3 = (Assignment)cGroup.eContents().get(3);
+ private final RuleCall cXbsXbParserRuleCall_3_0 = (RuleCall)cXbsAssignment_3.eContents().get(0);
+ private final Assignment cYsAssignment_4 = (Assignment)cGroup.eContents().get(4);
+ private final RuleCall cYsCharYTerminalRuleCall_4_0 = (RuleCall)cYsAssignment_4.eContents().get(0);
+ private final Assignment cAsAssignment_5 = (Assignment)cGroup.eContents().get(5);
+ private final RuleCall cAsCharATerminalRuleCall_5_0 = (RuleCall)cAsAssignment_5.eContents().get(0);
+
+ //Model:
+ // enums+=EnumName*
+ // ycs+=Yc*
+ // abs+=Ab*
+ // xbs+=Xb*
+ // ys+=CharY*
+ // ^as+=CharA*;
+ @Override public ParserRule getRule() { return rule; }
+
+ //enums+=EnumName* ycs+=Yc* abs+=Ab* xbs+=Xb* ys+=CharY* ^as+=CharA*
+ public Group getGroup() { return cGroup; }
+
+ //enums+=EnumName*
+ public Assignment getEnumsAssignment_0() { return cEnumsAssignment_0; }
+
+ //EnumName
+ public RuleCall getEnumsEnumNameEnumRuleCall_0_0() { return cEnumsEnumNameEnumRuleCall_0_0; }
+
+ //ycs+=Yc*
+ public Assignment getYcsAssignment_1() { return cYcsAssignment_1; }
+
+ //Yc
+ public RuleCall getYcsYcTerminalRuleCall_1_0() { return cYcsYcTerminalRuleCall_1_0; }
+
+ //abs+=Ab*
+ public Assignment getAbsAssignment_2() { return cAbsAssignment_2; }
+
+ //Ab
+ public RuleCall getAbsAbParserRuleCall_2_0() { return cAbsAbParserRuleCall_2_0; }
+
+ //xbs+=Xb*
+ public Assignment getXbsAssignment_3() { return cXbsAssignment_3; }
+
+ //Xb
+ public RuleCall getXbsXbParserRuleCall_3_0() { return cXbsXbParserRuleCall_3_0; }
+
+ //ys+=CharY*
+ public Assignment getYsAssignment_4() { return cYsAssignment_4; }
+
+ //CharY
+ public RuleCall getYsCharYTerminalRuleCall_4_0() { return cYsCharYTerminalRuleCall_4_0; }
+
+ //^as+=CharA*
+ public Assignment getAsAssignment_5() { return cAsAssignment_5; }
+
+ //CharA
+ public RuleCall getAsCharATerminalRuleCall_5_0() { return cAsCharATerminalRuleCall_5_0; }
+ }
+ public class AbElements extends AbstractParserRuleElementFinder {
+ private final ParserRule rule = (ParserRule) GrammarUtil.findRuleForName(getGrammar(), "org.eclipse.xtext.lexer.BacktrackingLexerTestLanguage.Ab");
+ private final Group cGroup = (Group)rule.eContents().get(1);
+ private final Assignment cXAssignment_0 = (Assignment)cGroup.eContents().get(0);
+ private final RuleCall cXCharATerminalRuleCall_0_0 = (RuleCall)cXAssignment_0.eContents().get(0);
+ private final Assignment cYAssignment_1 = (Assignment)cGroup.eContents().get(1);
+ private final RuleCall cYCharbTerminalRuleCall_1_0 = (RuleCall)cYAssignment_1.eContents().get(0);
+
+ //Ab:
+ // x=CharA y=Charb;
+ @Override public ParserRule getRule() { return rule; }
+
+ //x=CharA y=Charb
+ public Group getGroup() { return cGroup; }
+
+ //x=CharA
+ public Assignment getXAssignment_0() { return cXAssignment_0; }
+
+ //CharA
+ public RuleCall getXCharATerminalRuleCall_0_0() { return cXCharATerminalRuleCall_0_0; }
+
+ //y=Charb
+ public Assignment getYAssignment_1() { return cYAssignment_1; }
+
+ //Charb
+ public RuleCall getYCharbTerminalRuleCall_1_0() { return cYCharbTerminalRuleCall_1_0; }
+ }
+ public class XbElements extends AbstractParserRuleElementFinder {
+ private final ParserRule rule = (ParserRule) GrammarUtil.findRuleForName(getGrammar(), "org.eclipse.xtext.lexer.BacktrackingLexerTestLanguage.Xb");
+ private final Group cGroup = (Group)rule.eContents().get(1);
+ private final Assignment cXAssignment_0 = (Assignment)cGroup.eContents().get(0);
+ private final RuleCall cXCharXTerminalRuleCall_0_0 = (RuleCall)cXAssignment_0.eContents().get(0);
+ private final Assignment cYAssignment_1 = (Assignment)cGroup.eContents().get(1);
+ private final RuleCall cYCharbTerminalRuleCall_1_0 = (RuleCall)cYAssignment_1.eContents().get(0);
+
+ //Xb:
+ // x=CharX y=Charb;
+ @Override public ParserRule getRule() { return rule; }
+
+ //x=CharX y=Charb
+ public Group getGroup() { return cGroup; }
+
+ //x=CharX
+ public Assignment getXAssignment_0() { return cXAssignment_0; }
+
+ //CharX
+ public RuleCall getXCharXTerminalRuleCall_0_0() { return cXCharXTerminalRuleCall_0_0; }
+
+ //y=Charb
+ public Assignment getYAssignment_1() { return cYAssignment_1; }
+
+ //Charb
+ public RuleCall getYCharbTerminalRuleCall_1_0() { return cYCharbTerminalRuleCall_1_0; }
+ }
+
+ public class EnumNameElements extends AbstractEnumRuleElementFinder {
+ private final EnumRule rule = (EnumRule) GrammarUtil.findRuleForName(getGrammar(), "org.eclipse.xtext.lexer.BacktrackingLexerTestLanguage.EnumName");
+ private final Alternatives cAlternatives = (Alternatives)rule.eContents().get(1);
+ private final EnumLiteralDeclaration cAbcEnumLiteralDeclaration_0 = (EnumLiteralDeclaration)cAlternatives.eContents().get(0);
+ private final Keyword cAbcAbcKeyword_0_0 = (Keyword)cAbcEnumLiteralDeclaration_0.eContents().get(0);
+ private final EnumLiteralDeclaration cEfgEnumLiteralDeclaration_1 = (EnumLiteralDeclaration)cAlternatives.eContents().get(1);
+ private final Keyword cEfgEfgKeyword_1_0 = (Keyword)cEfgEnumLiteralDeclaration_1.eContents().get(0);
+
+ //enum EnumName:
+ // abc='Abc' | efg="Efg";
+ public EnumRule getRule() { return rule; }
+
+ //abc='Abc' | efg="Efg"
+ public Alternatives getAlternatives() { return cAlternatives; }
+
+ //abc='Abc'
+ public EnumLiteralDeclaration getAbcEnumLiteralDeclaration_0() { return cAbcEnumLiteralDeclaration_0; }
+
+ //'Abc'
+ public Keyword getAbcAbcKeyword_0_0() { return cAbcAbcKeyword_0_0; }
+
+ //efg="Efg"
+ public EnumLiteralDeclaration getEfgEnumLiteralDeclaration_1() { return cEfgEnumLiteralDeclaration_1; }
+
+ //"Efg"
+ public Keyword getEfgEfgKeyword_1_0() { return cEfgEfgKeyword_1_0; }
+ }
+
+ private final ModelElements pModel;
+ private final AbElements pAb;
+ private final XbElements pXb;
+ private final TerminalRule tCharA;
+ private final TerminalRule tCharb;
+ private final TerminalRule tCharX;
+ private final TerminalRule tYc;
+ private final TerminalRule tCharY;
+ private final TerminalRule tCharC;
+ private final EnumNameElements eEnumName;
+ private final TerminalRule tWS;
+ private final TerminalRule tSL_COMMENT;
+
+ private final Grammar grammar;
+
+ @Inject
+ public BacktrackingLexerTestLanguageGrammarAccess(GrammarProvider grammarProvider) {
+ this.grammar = internalFindGrammar(grammarProvider);
+ this.pModel = new ModelElements();
+ this.pAb = new AbElements();
+ this.pXb = new XbElements();
+ this.tCharA = (TerminalRule) GrammarUtil.findRuleForName(getGrammar(), "org.eclipse.xtext.lexer.BacktrackingLexerTestLanguage.CharA");
+ this.tCharb = (TerminalRule) GrammarUtil.findRuleForName(getGrammar(), "org.eclipse.xtext.lexer.BacktrackingLexerTestLanguage.Charb");
+ this.tCharX = (TerminalRule) GrammarUtil.findRuleForName(getGrammar(), "org.eclipse.xtext.lexer.BacktrackingLexerTestLanguage.CharX");
+ this.tYc = (TerminalRule) GrammarUtil.findRuleForName(getGrammar(), "org.eclipse.xtext.lexer.BacktrackingLexerTestLanguage.Yc");
+ this.tCharY = (TerminalRule) GrammarUtil.findRuleForName(getGrammar(), "org.eclipse.xtext.lexer.BacktrackingLexerTestLanguage.CharY");
+ this.tCharC = (TerminalRule) GrammarUtil.findRuleForName(getGrammar(), "org.eclipse.xtext.lexer.BacktrackingLexerTestLanguage.CharC");
+ this.eEnumName = new EnumNameElements();
+ this.tWS = (TerminalRule) GrammarUtil.findRuleForName(getGrammar(), "org.eclipse.xtext.lexer.BacktrackingLexerTestLanguage.WS");
+ this.tSL_COMMENT = (TerminalRule) GrammarUtil.findRuleForName(getGrammar(), "org.eclipse.xtext.lexer.BacktrackingLexerTestLanguage.SL_COMMENT");
+ }
+
+ protected Grammar internalFindGrammar(GrammarProvider grammarProvider) {
+ Grammar grammar = grammarProvider.getGrammar(this);
+ while (grammar != null) {
+ if ("org.eclipse.xtext.lexer.BacktrackingLexerTestLanguage".equals(grammar.getName())) {
+ return grammar;
+ }
+ List grammars = grammar.getUsedGrammars();
+ if (!grammars.isEmpty()) {
+ grammar = grammars.iterator().next();
+ } else {
+ return null;
+ }
+ }
+ return grammar;
+ }
+
+ @Override
+ public Grammar getGrammar() {
+ return grammar;
+ }
+
+
+
+ //Model:
+ // enums+=EnumName*
+ // ycs+=Yc*
+ // abs+=Ab*
+ // xbs+=Xb*
+ // ys+=CharY*
+ // ^as+=CharA*;
+ public ModelElements getModelAccess() {
+ return pModel;
+ }
+
+ public ParserRule getModelRule() {
+ return getModelAccess().getRule();
+ }
+
+ //Ab:
+ // x=CharA y=Charb;
+ public AbElements getAbAccess() {
+ return pAb;
+ }
+
+ public ParserRule getAbRule() {
+ return getAbAccess().getRule();
+ }
+
+ //Xb:
+ // x=CharX y=Charb;
+ public XbElements getXbAccess() {
+ return pXb;
+ }
+
+ public ParserRule getXbRule() {
+ return getXbAccess().getRule();
+ }
+
+ //terminal CharA:
+ // 'A';
+ public TerminalRule getCharARule() {
+ return tCharA;
+ }
+
+ //terminal Charb:
+ // 'b';
+ public TerminalRule getCharbRule() {
+ return tCharb;
+ }
+
+ //terminal CharX:
+ // 'X';
+ public TerminalRule getCharXRule() {
+ return tCharX;
+ }
+
+ //terminal Yc:
+ // CharY CharC;
+ public TerminalRule getYcRule() {
+ return tYc;
+ }
+
+ //terminal CharY:
+ // 'Y';
+ public TerminalRule getCharYRule() {
+ return tCharY;
+ }
+
+ //terminal CharC:
+ // 'c';
+ public TerminalRule getCharCRule() {
+ return tCharC;
+ }
+
+ //enum EnumName:
+ // abc='Abc' | efg="Efg";
+ public EnumNameElements getEnumNameAccess() {
+ return eEnumName;
+ }
+
+ public EnumRule getEnumNameRule() {
+ return getEnumNameAccess().getRule();
+ }
+
+ //terminal WS:
+ // ' ' | '\t' | '\r' | '\n'+;
+ public TerminalRule getWSRule() {
+ return tWS;
+ }
+
+ //terminal SL_COMMENT:
+ // '//' !('\n' | '\r')* ('\r'? '\n')?;
+ public TerminalRule getSL_COMMENTRule() {
+ return tSL_COMMENT;
+ }
+}