(SingleDefinition.class, this, EbnfPackage.DEFINITION_LIST__SINGLE_DEFINITION);
+ }
+ return singleDefinition;
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ @Override
+ public NotificationChain eInverseRemove(InternalEObject otherEnd, int featureID, NotificationChain msgs)
+ {
+ switch (featureID)
+ {
+ case EbnfPackage.DEFINITION_LIST__SINGLE_DEFINITION:
+ return ((InternalEList)getSingleDefinition()).basicRemove(otherEnd, msgs);
+ }
+ return super.eInverseRemove(otherEnd, featureID, msgs);
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ @Override
+ public Object eGet(int featureID, boolean resolve, boolean coreType)
+ {
+ switch (featureID)
+ {
+ case EbnfPackage.DEFINITION_LIST__SINGLE_DEFINITION:
+ return getSingleDefinition();
+ }
+ return super.eGet(featureID, resolve, coreType);
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ @SuppressWarnings("unchecked")
+ @Override
+ public void eSet(int featureID, Object newValue)
+ {
+ switch (featureID)
+ {
+ case EbnfPackage.DEFINITION_LIST__SINGLE_DEFINITION:
+ getSingleDefinition().clear();
+ getSingleDefinition().addAll((Collection)newValue);
+ return;
+ }
+ super.eSet(featureID, newValue);
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ @Override
+ public void eUnset(int featureID)
+ {
+ switch (featureID)
+ {
+ case EbnfPackage.DEFINITION_LIST__SINGLE_DEFINITION:
+ getSingleDefinition().clear();
+ return;
+ }
+ super.eUnset(featureID);
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ @Override
+ public boolean eIsSet(int featureID)
+ {
+ switch (featureID)
+ {
+ case EbnfPackage.DEFINITION_LIST__SINGLE_DEFINITION:
+ return singleDefinition != null && !singleDefinition.isEmpty();
+ }
+ return super.eIsSet(featureID);
+ }
+
+} //DefinitionListImpl
Index: /v2/trunk/de.ugoe.cs.swe.bnftools.ebnf/src-gen/de/ugoe/cs/swe/bnftools/ebnf/impl/DeltaEntryImpl.java
===================================================================
--- /v2/trunk/de.ugoe.cs.swe.bnftools.ebnf/src-gen/de/ugoe/cs/swe/bnftools/ebnf/impl/DeltaEntryImpl.java (revision 61)
+++ /v2/trunk/de.ugoe.cs.swe.bnftools.ebnf/src-gen/de/ugoe/cs/swe/bnftools/ebnf/impl/DeltaEntryImpl.java (revision 61)
@@ -0,0 +1,338 @@
+/**
+ */
+package de.ugoe.cs.swe.bnftools.ebnf.impl;
+
+import de.ugoe.cs.swe.bnftools.ebnf.DeltaEntry;
+import de.ugoe.cs.swe.bnftools.ebnf.EbnfPackage;
+import de.ugoe.cs.swe.bnftools.ebnf.ExtRule;
+import de.ugoe.cs.swe.bnftools.ebnf.Rule;
+import de.ugoe.cs.swe.bnftools.ebnf.SectionHeading;
+
+import org.eclipse.emf.common.notify.Notification;
+import org.eclipse.emf.common.notify.NotificationChain;
+
+import org.eclipse.emf.ecore.EClass;
+import org.eclipse.emf.ecore.InternalEObject;
+
+import org.eclipse.emf.ecore.impl.ENotificationImpl;
+import org.eclipse.emf.ecore.impl.MinimalEObjectImpl;
+
+/**
+ *
+ * An implementation of the model object 'Delta Entry'.
+ *
+ *
+ * The following features are implemented:
+ *
+ * - {@link de.ugoe.cs.swe.bnftools.ebnf.impl.DeltaEntryImpl#getRule Rule}
+ * - {@link de.ugoe.cs.swe.bnftools.ebnf.impl.DeltaEntryImpl#getSectionheader Sectionheader}
+ * - {@link de.ugoe.cs.swe.bnftools.ebnf.impl.DeltaEntryImpl#getExtRule Ext Rule}
+ *
+ *
+ *
+ * @generated
+ */
+public class DeltaEntryImpl extends MinimalEObjectImpl.Container implements DeltaEntry
+{
+ /**
+ * The cached value of the '{@link #getRule() Rule}' containment reference.
+ *
+ *
+ * @see #getRule()
+ * @generated
+ * @ordered
+ */
+ protected Rule rule;
+
+ /**
+ * The cached value of the '{@link #getSectionheader() Sectionheader}' containment reference.
+ *
+ *
+ * @see #getSectionheader()
+ * @generated
+ * @ordered
+ */
+ protected SectionHeading sectionheader;
+
+ /**
+ * The cached value of the '{@link #getExtRule() Ext Rule}' containment reference.
+ *
+ *
+ * @see #getExtRule()
+ * @generated
+ * @ordered
+ */
+ protected ExtRule extRule;
+
+ /**
+ *
+ *
+ * @generated
+ */
+ protected DeltaEntryImpl()
+ {
+ super();
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ @Override
+ protected EClass eStaticClass()
+ {
+ return EbnfPackage.Literals.DELTA_ENTRY;
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ public Rule getRule()
+ {
+ return rule;
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ public NotificationChain basicSetRule(Rule newRule, NotificationChain msgs)
+ {
+ Rule oldRule = rule;
+ rule = newRule;
+ if (eNotificationRequired())
+ {
+ ENotificationImpl notification = new ENotificationImpl(this, Notification.SET, EbnfPackage.DELTA_ENTRY__RULE, oldRule, newRule);
+ if (msgs == null) msgs = notification; else msgs.add(notification);
+ }
+ return msgs;
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ public void setRule(Rule newRule)
+ {
+ if (newRule != rule)
+ {
+ NotificationChain msgs = null;
+ if (rule != null)
+ msgs = ((InternalEObject)rule).eInverseRemove(this, EOPPOSITE_FEATURE_BASE - EbnfPackage.DELTA_ENTRY__RULE, null, msgs);
+ if (newRule != null)
+ msgs = ((InternalEObject)newRule).eInverseAdd(this, EOPPOSITE_FEATURE_BASE - EbnfPackage.DELTA_ENTRY__RULE, null, msgs);
+ msgs = basicSetRule(newRule, msgs);
+ if (msgs != null) msgs.dispatch();
+ }
+ else if (eNotificationRequired())
+ eNotify(new ENotificationImpl(this, Notification.SET, EbnfPackage.DELTA_ENTRY__RULE, newRule, newRule));
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ public SectionHeading getSectionheader()
+ {
+ return sectionheader;
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ public NotificationChain basicSetSectionheader(SectionHeading newSectionheader, NotificationChain msgs)
+ {
+ SectionHeading oldSectionheader = sectionheader;
+ sectionheader = newSectionheader;
+ if (eNotificationRequired())
+ {
+ ENotificationImpl notification = new ENotificationImpl(this, Notification.SET, EbnfPackage.DELTA_ENTRY__SECTIONHEADER, oldSectionheader, newSectionheader);
+ if (msgs == null) msgs = notification; else msgs.add(notification);
+ }
+ return msgs;
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ public void setSectionheader(SectionHeading newSectionheader)
+ {
+ if (newSectionheader != sectionheader)
+ {
+ NotificationChain msgs = null;
+ if (sectionheader != null)
+ msgs = ((InternalEObject)sectionheader).eInverseRemove(this, EOPPOSITE_FEATURE_BASE - EbnfPackage.DELTA_ENTRY__SECTIONHEADER, null, msgs);
+ if (newSectionheader != null)
+ msgs = ((InternalEObject)newSectionheader).eInverseAdd(this, EOPPOSITE_FEATURE_BASE - EbnfPackage.DELTA_ENTRY__SECTIONHEADER, null, msgs);
+ msgs = basicSetSectionheader(newSectionheader, msgs);
+ if (msgs != null) msgs.dispatch();
+ }
+ else if (eNotificationRequired())
+ eNotify(new ENotificationImpl(this, Notification.SET, EbnfPackage.DELTA_ENTRY__SECTIONHEADER, newSectionheader, newSectionheader));
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ public ExtRule getExtRule()
+ {
+ return extRule;
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ public NotificationChain basicSetExtRule(ExtRule newExtRule, NotificationChain msgs)
+ {
+ ExtRule oldExtRule = extRule;
+ extRule = newExtRule;
+ if (eNotificationRequired())
+ {
+ ENotificationImpl notification = new ENotificationImpl(this, Notification.SET, EbnfPackage.DELTA_ENTRY__EXT_RULE, oldExtRule, newExtRule);
+ if (msgs == null) msgs = notification; else msgs.add(notification);
+ }
+ return msgs;
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ public void setExtRule(ExtRule newExtRule)
+ {
+ if (newExtRule != extRule)
+ {
+ NotificationChain msgs = null;
+ if (extRule != null)
+ msgs = ((InternalEObject)extRule).eInverseRemove(this, EOPPOSITE_FEATURE_BASE - EbnfPackage.DELTA_ENTRY__EXT_RULE, null, msgs);
+ if (newExtRule != null)
+ msgs = ((InternalEObject)newExtRule).eInverseAdd(this, EOPPOSITE_FEATURE_BASE - EbnfPackage.DELTA_ENTRY__EXT_RULE, null, msgs);
+ msgs = basicSetExtRule(newExtRule, msgs);
+ if (msgs != null) msgs.dispatch();
+ }
+ else if (eNotificationRequired())
+ eNotify(new ENotificationImpl(this, Notification.SET, EbnfPackage.DELTA_ENTRY__EXT_RULE, newExtRule, newExtRule));
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ @Override
+ public NotificationChain eInverseRemove(InternalEObject otherEnd, int featureID, NotificationChain msgs)
+ {
+ switch (featureID)
+ {
+ case EbnfPackage.DELTA_ENTRY__RULE:
+ return basicSetRule(null, msgs);
+ case EbnfPackage.DELTA_ENTRY__SECTIONHEADER:
+ return basicSetSectionheader(null, msgs);
+ case EbnfPackage.DELTA_ENTRY__EXT_RULE:
+ return basicSetExtRule(null, msgs);
+ }
+ return super.eInverseRemove(otherEnd, featureID, msgs);
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ @Override
+ public Object eGet(int featureID, boolean resolve, boolean coreType)
+ {
+ switch (featureID)
+ {
+ case EbnfPackage.DELTA_ENTRY__RULE:
+ return getRule();
+ case EbnfPackage.DELTA_ENTRY__SECTIONHEADER:
+ return getSectionheader();
+ case EbnfPackage.DELTA_ENTRY__EXT_RULE:
+ return getExtRule();
+ }
+ return super.eGet(featureID, resolve, coreType);
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ @Override
+ public void eSet(int featureID, Object newValue)
+ {
+ switch (featureID)
+ {
+ case EbnfPackage.DELTA_ENTRY__RULE:
+ setRule((Rule)newValue);
+ return;
+ case EbnfPackage.DELTA_ENTRY__SECTIONHEADER:
+ setSectionheader((SectionHeading)newValue);
+ return;
+ case EbnfPackage.DELTA_ENTRY__EXT_RULE:
+ setExtRule((ExtRule)newValue);
+ return;
+ }
+ super.eSet(featureID, newValue);
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ @Override
+ public void eUnset(int featureID)
+ {
+ switch (featureID)
+ {
+ case EbnfPackage.DELTA_ENTRY__RULE:
+ setRule((Rule)null);
+ return;
+ case EbnfPackage.DELTA_ENTRY__SECTIONHEADER:
+ setSectionheader((SectionHeading)null);
+ return;
+ case EbnfPackage.DELTA_ENTRY__EXT_RULE:
+ setExtRule((ExtRule)null);
+ return;
+ }
+ super.eUnset(featureID);
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ @Override
+ public boolean eIsSet(int featureID)
+ {
+ switch (featureID)
+ {
+ case EbnfPackage.DELTA_ENTRY__RULE:
+ return rule != null;
+ case EbnfPackage.DELTA_ENTRY__SECTIONHEADER:
+ return sectionheader != null;
+ case EbnfPackage.DELTA_ENTRY__EXT_RULE:
+ return extRule != null;
+ }
+ return super.eIsSet(featureID);
+ }
+
+} //DeltaEntryImpl
Index: /v2/trunk/de.ugoe.cs.swe.bnftools.ebnf/src-gen/de/ugoe/cs/swe/bnftools/ebnf/impl/EbnfFactoryImpl.java
===================================================================
--- /v2/trunk/de.ugoe.cs.swe.bnftools.ebnf/src-gen/de/ugoe/cs/swe/bnftools/ebnf/impl/EbnfFactoryImpl.java (revision 61)
+++ /v2/trunk/de.ugoe.cs.swe.bnftools.ebnf/src-gen/de/ugoe/cs/swe/bnftools/ebnf/impl/EbnfFactoryImpl.java (revision 61)
@@ -0,0 +1,358 @@
+/**
+ */
+package de.ugoe.cs.swe.bnftools.ebnf.impl;
+
+import de.ugoe.cs.swe.bnftools.ebnf.*;
+
+import org.eclipse.emf.ecore.EClass;
+import org.eclipse.emf.ecore.EObject;
+import org.eclipse.emf.ecore.EPackage;
+
+import org.eclipse.emf.ecore.impl.EFactoryImpl;
+
+import org.eclipse.emf.ecore.plugin.EcorePlugin;
+
+/**
+ *
+ * An implementation of the model Factory.
+ *
+ * @generated
+ */
+public class EbnfFactoryImpl extends EFactoryImpl implements EbnfFactory
+{
+ /**
+ * Creates the default factory implementation.
+ *
+ *
+ * @generated
+ */
+ public static EbnfFactory init()
+ {
+ try
+ {
+ EbnfFactory theEbnfFactory = (EbnfFactory)EPackage.Registry.INSTANCE.getEFactory(EbnfPackage.eNS_URI);
+ if (theEbnfFactory != null)
+ {
+ return theEbnfFactory;
+ }
+ }
+ catch (Exception exception)
+ {
+ EcorePlugin.INSTANCE.log(exception);
+ }
+ return new EbnfFactoryImpl();
+ }
+
+ /**
+ * Creates an instance of the factory.
+ *
+ *
+ * @generated
+ */
+ public EbnfFactoryImpl()
+ {
+ super();
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ @Override
+ public EObject create(EClass eClass)
+ {
+ switch (eClass.getClassifierID())
+ {
+ case EbnfPackage.ETSI_BNF: return createEtsiBnf();
+ case EbnfPackage.IMPORT_SECTION: return createImportSection();
+ case EbnfPackage.BNF_ENTRY: return createBnfEntry();
+ case EbnfPackage.DELTA_ENTRY: return createDeltaEntry();
+ case EbnfPackage.MERGE_ENTRY: return createMergeEntry();
+ case EbnfPackage.SECTION_HEADING: return createSectionHeading();
+ case EbnfPackage.IMPORT: return createImport();
+ case EbnfPackage.RULE: return createRule();
+ case EbnfPackage.EXT_RULE: return createExtRule();
+ case EbnfPackage.MERGE_RULE: return createMergeRule();
+ case EbnfPackage.GLOBAL_COMBINATOR: return createGlobalCombinator();
+ case EbnfPackage.RULE_COMBINATOR: return createRuleCombinator();
+ case EbnfPackage.HOOK_COMBINATOR: return createHookCombinator();
+ case EbnfPackage.DEFINITION_LIST: return createDefinitionList();
+ case EbnfPackage.SINGLE_DEFINITION: return createSingleDefinition();
+ case EbnfPackage.TERM: return createTerm();
+ case EbnfPackage.ATOM: return createAtom();
+ case EbnfPackage.RULE_REFERENCE: return createRuleReference();
+ case EbnfPackage.STRING_RULE: return createStringRule();
+ case EbnfPackage.GROUPED_SEQUENCE: return createGroupedSequence();
+ case EbnfPackage.OPTIONAL_SEQUENCE: return createOptionalSequence();
+ case EbnfPackage.REPEATED_SEQUENCE: return createRepeatedSequence();
+ default:
+ throw new IllegalArgumentException("The class '" + eClass.getName() + "' is not a valid classifier");
+ }
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ public EtsiBnf createEtsiBnf()
+ {
+ EtsiBnfImpl etsiBnf = new EtsiBnfImpl();
+ return etsiBnf;
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ public ImportSection createImportSection()
+ {
+ ImportSectionImpl importSection = new ImportSectionImpl();
+ return importSection;
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ public BnfEntry createBnfEntry()
+ {
+ BnfEntryImpl bnfEntry = new BnfEntryImpl();
+ return bnfEntry;
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ public DeltaEntry createDeltaEntry()
+ {
+ DeltaEntryImpl deltaEntry = new DeltaEntryImpl();
+ return deltaEntry;
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ public MergeEntry createMergeEntry()
+ {
+ MergeEntryImpl mergeEntry = new MergeEntryImpl();
+ return mergeEntry;
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ public SectionHeading createSectionHeading()
+ {
+ SectionHeadingImpl sectionHeading = new SectionHeadingImpl();
+ return sectionHeading;
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ public Import createImport()
+ {
+ ImportImpl import_ = new ImportImpl();
+ return import_;
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ public Rule createRule()
+ {
+ RuleImpl rule = new RuleImpl();
+ return rule;
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ public ExtRule createExtRule()
+ {
+ ExtRuleImpl extRule = new ExtRuleImpl();
+ return extRule;
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ public MergeRule createMergeRule()
+ {
+ MergeRuleImpl mergeRule = new MergeRuleImpl();
+ return mergeRule;
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ public GlobalCombinator createGlobalCombinator()
+ {
+ GlobalCombinatorImpl globalCombinator = new GlobalCombinatorImpl();
+ return globalCombinator;
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ public RuleCombinator createRuleCombinator()
+ {
+ RuleCombinatorImpl ruleCombinator = new RuleCombinatorImpl();
+ return ruleCombinator;
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ public HookCombinator createHookCombinator()
+ {
+ HookCombinatorImpl hookCombinator = new HookCombinatorImpl();
+ return hookCombinator;
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ public DefinitionList createDefinitionList()
+ {
+ DefinitionListImpl definitionList = new DefinitionListImpl();
+ return definitionList;
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ public SingleDefinition createSingleDefinition()
+ {
+ SingleDefinitionImpl singleDefinition = new SingleDefinitionImpl();
+ return singleDefinition;
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ public Term createTerm()
+ {
+ TermImpl term = new TermImpl();
+ return term;
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ public Atom createAtom()
+ {
+ AtomImpl atom = new AtomImpl();
+ return atom;
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ public RuleReference createRuleReference()
+ {
+ RuleReferenceImpl ruleReference = new RuleReferenceImpl();
+ return ruleReference;
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ public StringRule createStringRule()
+ {
+ StringRuleImpl stringRule = new StringRuleImpl();
+ return stringRule;
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ public GroupedSequence createGroupedSequence()
+ {
+ GroupedSequenceImpl groupedSequence = new GroupedSequenceImpl();
+ return groupedSequence;
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ public OptionalSequence createOptionalSequence()
+ {
+ OptionalSequenceImpl optionalSequence = new OptionalSequenceImpl();
+ return optionalSequence;
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ public RepeatedSequence createRepeatedSequence()
+ {
+ RepeatedSequenceImpl repeatedSequence = new RepeatedSequenceImpl();
+ return repeatedSequence;
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ public EbnfPackage getEbnfPackage()
+ {
+ return (EbnfPackage)getEPackage();
+ }
+
+ /**
+ *
+ *
+ * @deprecated
+ * @generated
+ */
+ @Deprecated
+ public static EbnfPackage getPackage()
+ {
+ return EbnfPackage.eINSTANCE;
+ }
+
+} //EbnfFactoryImpl
Index: /v2/trunk/de.ugoe.cs.swe.bnftools.ebnf/src-gen/de/ugoe/cs/swe/bnftools/ebnf/impl/EbnfPackageImpl.java
===================================================================
--- /v2/trunk/de.ugoe.cs.swe.bnftools.ebnf/src-gen/de/ugoe/cs/swe/bnftools/ebnf/impl/EbnfPackageImpl.java (revision 61)
+++ /v2/trunk/de.ugoe.cs.swe.bnftools.ebnf/src-gen/de/ugoe/cs/swe/bnftools/ebnf/impl/EbnfPackageImpl.java (revision 61)
@@ -0,0 +1,1215 @@
+/**
+ */
+package de.ugoe.cs.swe.bnftools.ebnf.impl;
+
+import de.ugoe.cs.swe.bnftools.ebnf.Atom;
+import de.ugoe.cs.swe.bnftools.ebnf.BnfEntry;
+import de.ugoe.cs.swe.bnftools.ebnf.DefinitionList;
+import de.ugoe.cs.swe.bnftools.ebnf.DeltaEntry;
+import de.ugoe.cs.swe.bnftools.ebnf.EbnfFactory;
+import de.ugoe.cs.swe.bnftools.ebnf.EbnfPackage;
+import de.ugoe.cs.swe.bnftools.ebnf.EtsiBnf;
+import de.ugoe.cs.swe.bnftools.ebnf.ExtRule;
+import de.ugoe.cs.swe.bnftools.ebnf.GlobalCombinator;
+import de.ugoe.cs.swe.bnftools.ebnf.GroupedSequence;
+import de.ugoe.cs.swe.bnftools.ebnf.HookCombinator;
+import de.ugoe.cs.swe.bnftools.ebnf.Import;
+import de.ugoe.cs.swe.bnftools.ebnf.ImportSection;
+import de.ugoe.cs.swe.bnftools.ebnf.MergeEntry;
+import de.ugoe.cs.swe.bnftools.ebnf.MergeRule;
+import de.ugoe.cs.swe.bnftools.ebnf.OptionalSequence;
+import de.ugoe.cs.swe.bnftools.ebnf.RepeatedSequence;
+import de.ugoe.cs.swe.bnftools.ebnf.Rule;
+import de.ugoe.cs.swe.bnftools.ebnf.RuleCombinator;
+import de.ugoe.cs.swe.bnftools.ebnf.RuleReference;
+import de.ugoe.cs.swe.bnftools.ebnf.SectionHeading;
+import de.ugoe.cs.swe.bnftools.ebnf.SingleDefinition;
+import de.ugoe.cs.swe.bnftools.ebnf.StringRule;
+import de.ugoe.cs.swe.bnftools.ebnf.Term;
+
+import org.eclipse.emf.ecore.EAttribute;
+import org.eclipse.emf.ecore.EClass;
+import org.eclipse.emf.ecore.EPackage;
+import org.eclipse.emf.ecore.EReference;
+
+import org.eclipse.emf.ecore.impl.EPackageImpl;
+
+/**
+ *
+ * An implementation of the model Package.
+ *
+ * @generated
+ */
+public class EbnfPackageImpl extends EPackageImpl implements EbnfPackage
+{
+ /**
+ *
+ *
+ * @generated
+ */
+ private EClass etsiBnfEClass = null;
+
+ /**
+ *
+ *
+ * @generated
+ */
+ private EClass importSectionEClass = null;
+
+ /**
+ *
+ *
+ * @generated
+ */
+ private EClass bnfEntryEClass = null;
+
+ /**
+ *
+ *
+ * @generated
+ */
+ private EClass deltaEntryEClass = null;
+
+ /**
+ *
+ *
+ * @generated
+ */
+ private EClass mergeEntryEClass = null;
+
+ /**
+ *
+ *
+ * @generated
+ */
+ private EClass sectionHeadingEClass = null;
+
+ /**
+ *
+ *
+ * @generated
+ */
+ private EClass importEClass = null;
+
+ /**
+ *
+ *
+ * @generated
+ */
+ private EClass ruleEClass = null;
+
+ /**
+ *
+ *
+ * @generated
+ */
+ private EClass extRuleEClass = null;
+
+ /**
+ *
+ *
+ * @generated
+ */
+ private EClass mergeRuleEClass = null;
+
+ /**
+ *
+ *
+ * @generated
+ */
+ private EClass globalCombinatorEClass = null;
+
+ /**
+ *
+ *
+ * @generated
+ */
+ private EClass ruleCombinatorEClass = null;
+
+ /**
+ *
+ *
+ * @generated
+ */
+ private EClass hookCombinatorEClass = null;
+
+ /**
+ *
+ *
+ * @generated
+ */
+ private EClass definitionListEClass = null;
+
+ /**
+ *
+ *
+ * @generated
+ */
+ private EClass singleDefinitionEClass = null;
+
+ /**
+ *
+ *
+ * @generated
+ */
+ private EClass termEClass = null;
+
+ /**
+ *
+ *
+ * @generated
+ */
+ private EClass atomEClass = null;
+
+ /**
+ *
+ *
+ * @generated
+ */
+ private EClass ruleReferenceEClass = null;
+
+ /**
+ *
+ *
+ * @generated
+ */
+ private EClass stringRuleEClass = null;
+
+ /**
+ *
+ *
+ * @generated
+ */
+ private EClass groupedSequenceEClass = null;
+
+ /**
+ *
+ *
+ * @generated
+ */
+ private EClass optionalSequenceEClass = null;
+
+ /**
+ *
+ *
+ * @generated
+ */
+ private EClass repeatedSequenceEClass = 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 de.ugoe.cs.swe.bnftools.ebnf.EbnfPackage#eNS_URI
+ * @see #init()
+ * @generated
+ */
+ private EbnfPackageImpl()
+ {
+ super(eNS_URI, EbnfFactory.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 EbnfPackage#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 EbnfPackage init()
+ {
+ if (isInited) return (EbnfPackage)EPackage.Registry.INSTANCE.getEPackage(EbnfPackage.eNS_URI);
+
+ // Obtain or create and register package
+ EbnfPackageImpl theEbnfPackage = (EbnfPackageImpl)(EPackage.Registry.INSTANCE.get(eNS_URI) instanceof EbnfPackageImpl ? EPackage.Registry.INSTANCE.get(eNS_URI) : new EbnfPackageImpl());
+
+ isInited = true;
+
+ // Create package meta-data objects
+ theEbnfPackage.createPackageContents();
+
+ // Initialize created meta-data
+ theEbnfPackage.initializePackageContents();
+
+ // Mark meta-data to indicate it can't be changed
+ theEbnfPackage.freeze();
+
+
+ // Update the registry and return the package
+ EPackage.Registry.INSTANCE.put(EbnfPackage.eNS_URI, theEbnfPackage);
+ return theEbnfPackage;
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ public EClass getEtsiBnf()
+ {
+ return etsiBnfEClass;
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ public EAttribute getEtsiBnf_Name()
+ {
+ return (EAttribute)etsiBnfEClass.getEStructuralFeatures().get(0);
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ public EAttribute getEtsiBnf_Type()
+ {
+ return (EAttribute)etsiBnfEClass.getEStructuralFeatures().get(1);
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ public EReference getEtsiBnf_ImportSection()
+ {
+ return (EReference)etsiBnfEClass.getEStructuralFeatures().get(2);
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ public EReference getEtsiBnf_BnfEntry()
+ {
+ return (EReference)etsiBnfEClass.getEStructuralFeatures().get(3);
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ public EReference getEtsiBnf_DeltaEntry()
+ {
+ return (EReference)etsiBnfEClass.getEStructuralFeatures().get(4);
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ public EReference getEtsiBnf_MergeEntry()
+ {
+ return (EReference)etsiBnfEClass.getEStructuralFeatures().get(5);
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ public EClass getImportSection()
+ {
+ return importSectionEClass;
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ public EReference getImportSection_Imports()
+ {
+ return (EReference)importSectionEClass.getEStructuralFeatures().get(0);
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ public EClass getBnfEntry()
+ {
+ return bnfEntryEClass;
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ public EReference getBnfEntry_Sectionheader()
+ {
+ return (EReference)bnfEntryEClass.getEStructuralFeatures().get(0);
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ public EReference getBnfEntry_Rule()
+ {
+ return (EReference)bnfEntryEClass.getEStructuralFeatures().get(1);
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ public EClass getDeltaEntry()
+ {
+ return deltaEntryEClass;
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ public EReference getDeltaEntry_Rule()
+ {
+ return (EReference)deltaEntryEClass.getEStructuralFeatures().get(0);
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ public EReference getDeltaEntry_Sectionheader()
+ {
+ return (EReference)deltaEntryEClass.getEStructuralFeatures().get(1);
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ public EReference getDeltaEntry_ExtRule()
+ {
+ return (EReference)deltaEntryEClass.getEStructuralFeatures().get(2);
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ public EClass getMergeEntry()
+ {
+ return mergeEntryEClass;
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ public EReference getMergeEntry_Sectionheader()
+ {
+ return (EReference)mergeEntryEClass.getEStructuralFeatures().get(0);
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ public EReference getMergeEntry_MergeRule()
+ {
+ return (EReference)mergeEntryEClass.getEStructuralFeatures().get(1);
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ public EClass getSectionHeading()
+ {
+ return sectionHeadingEClass;
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ public EAttribute getSectionHeading_SectionHeader()
+ {
+ return (EAttribute)sectionHeadingEClass.getEStructuralFeatures().get(0);
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ public EClass getImport()
+ {
+ return importEClass;
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ public EAttribute getImport_ImportURI()
+ {
+ return (EAttribute)importEClass.getEStructuralFeatures().get(0);
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ public EAttribute getImport_GrammarType()
+ {
+ return (EAttribute)importEClass.getEStructuralFeatures().get(1);
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ public EAttribute getImport_Label()
+ {
+ return (EAttribute)importEClass.getEStructuralFeatures().get(2);
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ public EClass getRule()
+ {
+ return ruleEClass;
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ public EAttribute getRule_Rulenumber()
+ {
+ return (EAttribute)ruleEClass.getEStructuralFeatures().get(0);
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ public EAttribute getRule_Rulevariant()
+ {
+ return (EAttribute)ruleEClass.getEStructuralFeatures().get(1);
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ public EAttribute getRule_Name()
+ {
+ return (EAttribute)ruleEClass.getEStructuralFeatures().get(2);
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ public EReference getRule_DefinitionList()
+ {
+ return (EReference)ruleEClass.getEStructuralFeatures().get(3);
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ public EClass getExtRule()
+ {
+ return extRuleEClass;
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ public EAttribute getExtRule_Rulenumber()
+ {
+ return (EAttribute)extRuleEClass.getEStructuralFeatures().get(0);
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ public EAttribute getExtRule_Rulevariant()
+ {
+ return (EAttribute)extRuleEClass.getEStructuralFeatures().get(1);
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ public EAttribute getExtRule_Name()
+ {
+ return (EAttribute)extRuleEClass.getEStructuralFeatures().get(2);
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ public EAttribute getExtRule_Ruleext()
+ {
+ return (EAttribute)extRuleEClass.getEStructuralFeatures().get(3);
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ public EReference getExtRule_Elements()
+ {
+ return (EReference)extRuleEClass.getEStructuralFeatures().get(4);
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ public EClass getMergeRule()
+ {
+ return mergeRuleEClass;
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ public EAttribute getMergeRule_Logic()
+ {
+ return (EAttribute)mergeRuleEClass.getEStructuralFeatures().get(0);
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ public EClass getGlobalCombinator()
+ {
+ return globalCombinatorEClass;
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ public EClass getRuleCombinator()
+ {
+ return ruleCombinatorEClass;
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ public EAttribute getRuleCombinator_Name()
+ {
+ return (EAttribute)ruleCombinatorEClass.getEStructuralFeatures().get(0);
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ public EAttribute getRuleCombinator_LABEL()
+ {
+ return (EAttribute)ruleCombinatorEClass.getEStructuralFeatures().get(1);
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ public EClass getHookCombinator()
+ {
+ return hookCombinatorEClass;
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ public EAttribute getHookCombinator_Name()
+ {
+ return (EAttribute)hookCombinatorEClass.getEStructuralFeatures().get(0);
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ public EAttribute getHookCombinator_Ruleext()
+ {
+ return (EAttribute)hookCombinatorEClass.getEStructuralFeatures().get(1);
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ public EAttribute getHookCombinator_LABEL()
+ {
+ return (EAttribute)hookCombinatorEClass.getEStructuralFeatures().get(2);
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ public EClass getDefinitionList()
+ {
+ return definitionListEClass;
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ public EReference getDefinitionList_SingleDefinition()
+ {
+ return (EReference)definitionListEClass.getEStructuralFeatures().get(0);
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ public EClass getSingleDefinition()
+ {
+ return singleDefinitionEClass;
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ public EReference getSingleDefinition_Terms()
+ {
+ return (EReference)singleDefinitionEClass.getEStructuralFeatures().get(0);
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ public EClass getTerm()
+ {
+ return termEClass;
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ public EReference getTerm_TermAtom()
+ {
+ return (EReference)termEClass.getEStructuralFeatures().get(0);
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ public EReference getTerm_TermGroupedSequence()
+ {
+ return (EReference)termEClass.getEStructuralFeatures().get(1);
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ public EReference getTerm_TermOptionalSequence()
+ {
+ return (EReference)termEClass.getEStructuralFeatures().get(2);
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ public EReference getTerm_TermRepeatedSequence()
+ {
+ return (EReference)termEClass.getEStructuralFeatures().get(3);
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ public EClass getAtom()
+ {
+ return atomEClass;
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ public EReference getAtom_AtomStringRule()
+ {
+ return (EReference)atomEClass.getEStructuralFeatures().get(0);
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ public EReference getAtom_AtomRuleReference()
+ {
+ return (EReference)atomEClass.getEStructuralFeatures().get(1);
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ public EClass getRuleReference()
+ {
+ return ruleReferenceEClass;
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ public EReference getRuleReference_Ruleref()
+ {
+ return (EReference)ruleReferenceEClass.getEStructuralFeatures().get(0);
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ public EClass getStringRule()
+ {
+ return stringRuleEClass;
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ public EAttribute getStringRule_Literal()
+ {
+ return (EAttribute)stringRuleEClass.getEStructuralFeatures().get(0);
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ public EAttribute getStringRule_Colon()
+ {
+ return (EAttribute)stringRuleEClass.getEStructuralFeatures().get(1);
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ public EClass getGroupedSequence()
+ {
+ return groupedSequenceEClass;
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ public EReference getGroupedSequence_DefinitionList()
+ {
+ return (EReference)groupedSequenceEClass.getEStructuralFeatures().get(0);
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ public EClass getOptionalSequence()
+ {
+ return optionalSequenceEClass;
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ public EReference getOptionalSequence_DefinitionList()
+ {
+ return (EReference)optionalSequenceEClass.getEStructuralFeatures().get(0);
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ public EClass getRepeatedSequence()
+ {
+ return repeatedSequenceEClass;
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ public EReference getRepeatedSequence_Definitions()
+ {
+ return (EReference)repeatedSequenceEClass.getEStructuralFeatures().get(0);
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ public EAttribute getRepeatedSequence_Morethanonce()
+ {
+ return (EAttribute)repeatedSequenceEClass.getEStructuralFeatures().get(1);
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ public EbnfFactory getEbnfFactory()
+ {
+ return (EbnfFactory)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
+ etsiBnfEClass = createEClass(ETSI_BNF);
+ createEAttribute(etsiBnfEClass, ETSI_BNF__NAME);
+ createEAttribute(etsiBnfEClass, ETSI_BNF__TYPE);
+ createEReference(etsiBnfEClass, ETSI_BNF__IMPORT_SECTION);
+ createEReference(etsiBnfEClass, ETSI_BNF__BNF_ENTRY);
+ createEReference(etsiBnfEClass, ETSI_BNF__DELTA_ENTRY);
+ createEReference(etsiBnfEClass, ETSI_BNF__MERGE_ENTRY);
+
+ importSectionEClass = createEClass(IMPORT_SECTION);
+ createEReference(importSectionEClass, IMPORT_SECTION__IMPORTS);
+
+ bnfEntryEClass = createEClass(BNF_ENTRY);
+ createEReference(bnfEntryEClass, BNF_ENTRY__SECTIONHEADER);
+ createEReference(bnfEntryEClass, BNF_ENTRY__RULE);
+
+ deltaEntryEClass = createEClass(DELTA_ENTRY);
+ createEReference(deltaEntryEClass, DELTA_ENTRY__RULE);
+ createEReference(deltaEntryEClass, DELTA_ENTRY__SECTIONHEADER);
+ createEReference(deltaEntryEClass, DELTA_ENTRY__EXT_RULE);
+
+ mergeEntryEClass = createEClass(MERGE_ENTRY);
+ createEReference(mergeEntryEClass, MERGE_ENTRY__SECTIONHEADER);
+ createEReference(mergeEntryEClass, MERGE_ENTRY__MERGE_RULE);
+
+ sectionHeadingEClass = createEClass(SECTION_HEADING);
+ createEAttribute(sectionHeadingEClass, SECTION_HEADING__SECTION_HEADER);
+
+ importEClass = createEClass(IMPORT);
+ createEAttribute(importEClass, IMPORT__IMPORT_URI);
+ createEAttribute(importEClass, IMPORT__GRAMMAR_TYPE);
+ createEAttribute(importEClass, IMPORT__LABEL);
+
+ ruleEClass = createEClass(RULE);
+ createEAttribute(ruleEClass, RULE__RULENUMBER);
+ createEAttribute(ruleEClass, RULE__RULEVARIANT);
+ createEAttribute(ruleEClass, RULE__NAME);
+ createEReference(ruleEClass, RULE__DEFINITION_LIST);
+
+ extRuleEClass = createEClass(EXT_RULE);
+ createEAttribute(extRuleEClass, EXT_RULE__RULENUMBER);
+ createEAttribute(extRuleEClass, EXT_RULE__RULEVARIANT);
+ createEAttribute(extRuleEClass, EXT_RULE__NAME);
+ createEAttribute(extRuleEClass, EXT_RULE__RULEEXT);
+ createEReference(extRuleEClass, EXT_RULE__ELEMENTS);
+
+ mergeRuleEClass = createEClass(MERGE_RULE);
+ createEAttribute(mergeRuleEClass, MERGE_RULE__LOGIC);
+
+ globalCombinatorEClass = createEClass(GLOBAL_COMBINATOR);
+
+ ruleCombinatorEClass = createEClass(RULE_COMBINATOR);
+ createEAttribute(ruleCombinatorEClass, RULE_COMBINATOR__NAME);
+ createEAttribute(ruleCombinatorEClass, RULE_COMBINATOR__LABEL);
+
+ hookCombinatorEClass = createEClass(HOOK_COMBINATOR);
+ createEAttribute(hookCombinatorEClass, HOOK_COMBINATOR__NAME);
+ createEAttribute(hookCombinatorEClass, HOOK_COMBINATOR__RULEEXT);
+ createEAttribute(hookCombinatorEClass, HOOK_COMBINATOR__LABEL);
+
+ definitionListEClass = createEClass(DEFINITION_LIST);
+ createEReference(definitionListEClass, DEFINITION_LIST__SINGLE_DEFINITION);
+
+ singleDefinitionEClass = createEClass(SINGLE_DEFINITION);
+ createEReference(singleDefinitionEClass, SINGLE_DEFINITION__TERMS);
+
+ termEClass = createEClass(TERM);
+ createEReference(termEClass, TERM__TERM_ATOM);
+ createEReference(termEClass, TERM__TERM_GROUPED_SEQUENCE);
+ createEReference(termEClass, TERM__TERM_OPTIONAL_SEQUENCE);
+ createEReference(termEClass, TERM__TERM_REPEATED_SEQUENCE);
+
+ atomEClass = createEClass(ATOM);
+ createEReference(atomEClass, ATOM__ATOM_STRING_RULE);
+ createEReference(atomEClass, ATOM__ATOM_RULE_REFERENCE);
+
+ ruleReferenceEClass = createEClass(RULE_REFERENCE);
+ createEReference(ruleReferenceEClass, RULE_REFERENCE__RULEREF);
+
+ stringRuleEClass = createEClass(STRING_RULE);
+ createEAttribute(stringRuleEClass, STRING_RULE__LITERAL);
+ createEAttribute(stringRuleEClass, STRING_RULE__COLON);
+
+ groupedSequenceEClass = createEClass(GROUPED_SEQUENCE);
+ createEReference(groupedSequenceEClass, GROUPED_SEQUENCE__DEFINITION_LIST);
+
+ optionalSequenceEClass = createEClass(OPTIONAL_SEQUENCE);
+ createEReference(optionalSequenceEClass, OPTIONAL_SEQUENCE__DEFINITION_LIST);
+
+ repeatedSequenceEClass = createEClass(REPEATED_SEQUENCE);
+ createEReference(repeatedSequenceEClass, REPEATED_SEQUENCE__DEFINITIONS);
+ createEAttribute(repeatedSequenceEClass, REPEATED_SEQUENCE__MORETHANONCE);
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ private boolean isInitialized = false;
+
+ /**
+ * Complete the initialization of the package and its meta-model. This
+ * method is guarded to have no affect on any invocation but its first.
+ *
+ *
+ * @generated
+ */
+ public void initializePackageContents()
+ {
+ if (isInitialized) return;
+ isInitialized = true;
+
+ // Initialize package
+ setName(eNAME);
+ setNsPrefix(eNS_PREFIX);
+ setNsURI(eNS_URI);
+
+ // Create type parameters
+
+ // Set bounds for type parameters
+
+ // Add supertypes to classes
+ globalCombinatorEClass.getESuperTypes().add(this.getMergeRule());
+ ruleCombinatorEClass.getESuperTypes().add(this.getMergeRule());
+ hookCombinatorEClass.getESuperTypes().add(this.getMergeRule());
+
+ // Initialize classes and features; add operations and parameters
+ initEClass(etsiBnfEClass, EtsiBnf.class, "EtsiBnf", !IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS);
+ initEAttribute(getEtsiBnf_Name(), ecorePackage.getEString(), "name", null, 0, 1, EtsiBnf.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_UNSETTABLE, !IS_ID, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
+ initEAttribute(getEtsiBnf_Type(), ecorePackage.getEString(), "type", null, 0, 1, EtsiBnf.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_UNSETTABLE, !IS_ID, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
+ initEReference(getEtsiBnf_ImportSection(), this.getImportSection(), null, "importSection", null, 0, 1, EtsiBnf.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
+ initEReference(getEtsiBnf_BnfEntry(), this.getBnfEntry(), null, "bnfEntry", null, 0, -1, EtsiBnf.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
+ initEReference(getEtsiBnf_DeltaEntry(), this.getDeltaEntry(), null, "deltaEntry", null, 0, -1, EtsiBnf.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
+ initEReference(getEtsiBnf_MergeEntry(), this.getMergeEntry(), null, "mergeEntry", null, 0, -1, EtsiBnf.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
+
+ initEClass(importSectionEClass, ImportSection.class, "ImportSection", !IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS);
+ initEReference(getImportSection_Imports(), this.getImport(), null, "imports", null, 0, -1, ImportSection.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
+
+ initEClass(bnfEntryEClass, BnfEntry.class, "BnfEntry", !IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS);
+ initEReference(getBnfEntry_Sectionheader(), this.getSectionHeading(), null, "sectionheader", null, 0, 1, BnfEntry.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
+ initEReference(getBnfEntry_Rule(), this.getRule(), null, "rule", null, 0, 1, BnfEntry.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
+
+ initEClass(deltaEntryEClass, DeltaEntry.class, "DeltaEntry", !IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS);
+ initEReference(getDeltaEntry_Rule(), this.getRule(), null, "rule", null, 0, 1, DeltaEntry.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
+ initEReference(getDeltaEntry_Sectionheader(), this.getSectionHeading(), null, "sectionheader", null, 0, 1, DeltaEntry.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
+ initEReference(getDeltaEntry_ExtRule(), this.getExtRule(), null, "extRule", null, 0, 1, DeltaEntry.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
+
+ initEClass(mergeEntryEClass, MergeEntry.class, "MergeEntry", !IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS);
+ initEReference(getMergeEntry_Sectionheader(), this.getSectionHeading(), null, "sectionheader", null, 0, 1, MergeEntry.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
+ initEReference(getMergeEntry_MergeRule(), this.getMergeRule(), null, "mergeRule", null, 0, 1, MergeEntry.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
+
+ initEClass(sectionHeadingEClass, SectionHeading.class, "SectionHeading", !IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS);
+ initEAttribute(getSectionHeading_SectionHeader(), ecorePackage.getEString(), "sectionHeader", null, 0, 1, SectionHeading.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_UNSETTABLE, !IS_ID, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
+
+ initEClass(importEClass, Import.class, "Import", !IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS);
+ initEAttribute(getImport_ImportURI(), ecorePackage.getEString(), "importURI", null, 0, 1, Import.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_UNSETTABLE, !IS_ID, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
+ initEAttribute(getImport_GrammarType(), ecorePackage.getEString(), "grammarType", null, 0, 1, Import.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_UNSETTABLE, !IS_ID, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
+ initEAttribute(getImport_Label(), ecorePackage.getEString(), "label", null, 0, 1, Import.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_UNSETTABLE, !IS_ID, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
+
+ initEClass(ruleEClass, Rule.class, "Rule", !IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS);
+ initEAttribute(getRule_Rulenumber(), ecorePackage.getEInt(), "rulenumber", null, 0, 1, Rule.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_UNSETTABLE, !IS_ID, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
+ initEAttribute(getRule_Rulevariant(), ecorePackage.getEString(), "rulevariant", null, 0, 1, Rule.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_UNSETTABLE, !IS_ID, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
+ initEAttribute(getRule_Name(), ecorePackage.getEString(), "name", null, 0, 1, Rule.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_UNSETTABLE, !IS_ID, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
+ initEReference(getRule_DefinitionList(), this.getDefinitionList(), null, "definitionList", null, 0, 1, Rule.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
+
+ initEClass(extRuleEClass, ExtRule.class, "ExtRule", !IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS);
+ initEAttribute(getExtRule_Rulenumber(), ecorePackage.getEInt(), "rulenumber", null, 0, 1, ExtRule.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_UNSETTABLE, !IS_ID, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
+ initEAttribute(getExtRule_Rulevariant(), ecorePackage.getEString(), "rulevariant", null, 0, 1, ExtRule.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_UNSETTABLE, !IS_ID, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
+ initEAttribute(getExtRule_Name(), ecorePackage.getEString(), "name", null, 0, 1, ExtRule.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_UNSETTABLE, !IS_ID, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
+ initEAttribute(getExtRule_Ruleext(), ecorePackage.getEInt(), "ruleext", null, 0, 1, ExtRule.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_UNSETTABLE, !IS_ID, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
+ initEReference(getExtRule_Elements(), this.getAtom(), null, "elements", null, 0, -1, ExtRule.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
+
+ initEClass(mergeRuleEClass, MergeRule.class, "MergeRule", !IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS);
+ initEAttribute(getMergeRule_Logic(), ecorePackage.getEString(), "logic", null, 0, 1, MergeRule.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_UNSETTABLE, !IS_ID, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
+
+ initEClass(globalCombinatorEClass, GlobalCombinator.class, "GlobalCombinator", !IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS);
+
+ initEClass(ruleCombinatorEClass, RuleCombinator.class, "RuleCombinator", !IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS);
+ initEAttribute(getRuleCombinator_Name(), ecorePackage.getEString(), "name", null, 0, 1, RuleCombinator.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_UNSETTABLE, !IS_ID, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
+ initEAttribute(getRuleCombinator_LABEL(), ecorePackage.getEString(), "LABEL", null, 0, -1, RuleCombinator.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_UNSETTABLE, !IS_ID, !IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
+
+ initEClass(hookCombinatorEClass, HookCombinator.class, "HookCombinator", !IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS);
+ initEAttribute(getHookCombinator_Name(), ecorePackage.getEString(), "name", null, 0, 1, HookCombinator.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_UNSETTABLE, !IS_ID, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
+ initEAttribute(getHookCombinator_Ruleext(), ecorePackage.getEInt(), "ruleext", null, 0, 1, HookCombinator.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_UNSETTABLE, !IS_ID, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
+ initEAttribute(getHookCombinator_LABEL(), ecorePackage.getEString(), "LABEL", null, 0, -1, HookCombinator.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_UNSETTABLE, !IS_ID, !IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
+
+ initEClass(definitionListEClass, DefinitionList.class, "DefinitionList", !IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS);
+ initEReference(getDefinitionList_SingleDefinition(), this.getSingleDefinition(), null, "singleDefinition", null, 0, -1, DefinitionList.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
+
+ initEClass(singleDefinitionEClass, SingleDefinition.class, "SingleDefinition", !IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS);
+ initEReference(getSingleDefinition_Terms(), this.getTerm(), null, "terms", null, 0, -1, SingleDefinition.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
+
+ initEClass(termEClass, Term.class, "Term", !IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS);
+ initEReference(getTerm_TermAtom(), this.getAtom(), null, "termAtom", null, 0, 1, Term.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
+ initEReference(getTerm_TermGroupedSequence(), this.getGroupedSequence(), null, "termGroupedSequence", null, 0, 1, Term.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
+ initEReference(getTerm_TermOptionalSequence(), this.getOptionalSequence(), null, "termOptionalSequence", null, 0, 1, Term.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
+ initEReference(getTerm_TermRepeatedSequence(), this.getRepeatedSequence(), null, "termRepeatedSequence", null, 0, 1, Term.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
+
+ initEClass(atomEClass, Atom.class, "Atom", !IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS);
+ initEReference(getAtom_AtomStringRule(), this.getStringRule(), null, "atomStringRule", null, 0, 1, Atom.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
+ initEReference(getAtom_AtomRuleReference(), this.getRuleReference(), null, "atomRuleReference", null, 0, 1, Atom.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
+
+ initEClass(ruleReferenceEClass, RuleReference.class, "RuleReference", !IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS);
+ initEReference(getRuleReference_Ruleref(), this.getRule(), null, "ruleref", null, 0, 1, RuleReference.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_COMPOSITE, IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
+
+ initEClass(stringRuleEClass, StringRule.class, "StringRule", !IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS);
+ initEAttribute(getStringRule_Literal(), ecorePackage.getEString(), "literal", null, 0, 1, StringRule.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_UNSETTABLE, !IS_ID, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
+ initEAttribute(getStringRule_Colon(), ecorePackage.getEString(), "colon", null, 0, 1, StringRule.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_UNSETTABLE, !IS_ID, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
+
+ initEClass(groupedSequenceEClass, GroupedSequence.class, "GroupedSequence", !IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS);
+ initEReference(getGroupedSequence_DefinitionList(), this.getDefinitionList(), null, "definitionList", null, 0, -1, GroupedSequence.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
+
+ initEClass(optionalSequenceEClass, OptionalSequence.class, "OptionalSequence", !IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS);
+ initEReference(getOptionalSequence_DefinitionList(), this.getDefinitionList(), null, "definitionList", null, 0, -1, OptionalSequence.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
+
+ initEClass(repeatedSequenceEClass, RepeatedSequence.class, "RepeatedSequence", !IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS);
+ initEReference(getRepeatedSequence_Definitions(), this.getDefinitionList(), null, "definitions", null, 0, -1, RepeatedSequence.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
+ initEAttribute(getRepeatedSequence_Morethanonce(), ecorePackage.getEBoolean(), "morethanonce", null, 0, 1, RepeatedSequence.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_UNSETTABLE, !IS_ID, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
+
+ // Create resource
+ createResource(eNS_URI);
+ }
+
+} //EbnfPackageImpl
Index: /v2/trunk/de.ugoe.cs.swe.bnftools.ebnf/src-gen/de/ugoe/cs/swe/bnftools/ebnf/impl/EtsiBnfImpl.java
===================================================================
--- /v2/trunk/de.ugoe.cs.swe.bnftools.ebnf/src-gen/de/ugoe/cs/swe/bnftools/ebnf/impl/EtsiBnfImpl.java (revision 61)
+++ /v2/trunk/de.ugoe.cs.swe.bnftools.ebnf/src-gen/de/ugoe/cs/swe/bnftools/ebnf/impl/EtsiBnfImpl.java (revision 61)
@@ -0,0 +1,446 @@
+/**
+ */
+package de.ugoe.cs.swe.bnftools.ebnf.impl;
+
+import de.ugoe.cs.swe.bnftools.ebnf.BnfEntry;
+import de.ugoe.cs.swe.bnftools.ebnf.DeltaEntry;
+import de.ugoe.cs.swe.bnftools.ebnf.EbnfPackage;
+import de.ugoe.cs.swe.bnftools.ebnf.EtsiBnf;
+import de.ugoe.cs.swe.bnftools.ebnf.ImportSection;
+import de.ugoe.cs.swe.bnftools.ebnf.MergeEntry;
+
+import java.util.Collection;
+
+import org.eclipse.emf.common.notify.Notification;
+import org.eclipse.emf.common.notify.NotificationChain;
+
+import org.eclipse.emf.common.util.EList;
+
+import org.eclipse.emf.ecore.EClass;
+import org.eclipse.emf.ecore.InternalEObject;
+
+import org.eclipse.emf.ecore.impl.ENotificationImpl;
+import org.eclipse.emf.ecore.impl.MinimalEObjectImpl;
+
+import org.eclipse.emf.ecore.util.EObjectContainmentEList;
+import org.eclipse.emf.ecore.util.InternalEList;
+
+/**
+ *
+ * An implementation of the model object 'Etsi Bnf'.
+ *
+ *
+ * The following features are implemented:
+ *
+ * - {@link de.ugoe.cs.swe.bnftools.ebnf.impl.EtsiBnfImpl#getName Name}
+ * - {@link de.ugoe.cs.swe.bnftools.ebnf.impl.EtsiBnfImpl#getType Type}
+ * - {@link de.ugoe.cs.swe.bnftools.ebnf.impl.EtsiBnfImpl#getImportSection Import Section}
+ * - {@link de.ugoe.cs.swe.bnftools.ebnf.impl.EtsiBnfImpl#getBnfEntry Bnf Entry}
+ * - {@link de.ugoe.cs.swe.bnftools.ebnf.impl.EtsiBnfImpl#getDeltaEntry Delta Entry}
+ * - {@link de.ugoe.cs.swe.bnftools.ebnf.impl.EtsiBnfImpl#getMergeEntry Merge Entry}
+ *
+ *
+ *
+ * @generated
+ */
+public class EtsiBnfImpl extends MinimalEObjectImpl.Container implements EtsiBnf
+{
+ /**
+ * The default value of the '{@link #getName() Name}' attribute.
+ *
+ *
+ * @see #getName()
+ * @generated
+ * @ordered
+ */
+ protected static final String NAME_EDEFAULT = null;
+
+ /**
+ * The cached value of the '{@link #getName() Name}' attribute.
+ *
+ *
+ * @see #getName()
+ * @generated
+ * @ordered
+ */
+ protected String name = NAME_EDEFAULT;
+
+ /**
+ * The default value of the '{@link #getType() Type}' attribute.
+ *
+ *
+ * @see #getType()
+ * @generated
+ * @ordered
+ */
+ protected static final String TYPE_EDEFAULT = null;
+
+ /**
+ * The cached value of the '{@link #getType() Type}' attribute.
+ *
+ *
+ * @see #getType()
+ * @generated
+ * @ordered
+ */
+ protected String type = TYPE_EDEFAULT;
+
+ /**
+ * The cached value of the '{@link #getImportSection() Import Section}' containment reference.
+ *
+ *
+ * @see #getImportSection()
+ * @generated
+ * @ordered
+ */
+ protected ImportSection importSection;
+
+ /**
+ * The cached value of the '{@link #getBnfEntry() Bnf Entry}' containment reference list.
+ *
+ *
+ * @see #getBnfEntry()
+ * @generated
+ * @ordered
+ */
+ protected EList bnfEntry;
+
+ /**
+ * The cached value of the '{@link #getDeltaEntry() Delta Entry}' containment reference list.
+ *
+ *
+ * @see #getDeltaEntry()
+ * @generated
+ * @ordered
+ */
+ protected EList deltaEntry;
+
+ /**
+ * The cached value of the '{@link #getMergeEntry() Merge Entry}' containment reference list.
+ *
+ *
+ * @see #getMergeEntry()
+ * @generated
+ * @ordered
+ */
+ protected EList mergeEntry;
+
+ /**
+ *
+ *
+ * @generated
+ */
+ protected EtsiBnfImpl()
+ {
+ super();
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ @Override
+ protected EClass eStaticClass()
+ {
+ return EbnfPackage.Literals.ETSI_BNF;
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ public String getName()
+ {
+ return name;
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ public void setName(String newName)
+ {
+ String oldName = name;
+ name = newName;
+ if (eNotificationRequired())
+ eNotify(new ENotificationImpl(this, Notification.SET, EbnfPackage.ETSI_BNF__NAME, oldName, name));
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ public String getType()
+ {
+ return type;
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ public void setType(String newType)
+ {
+ String oldType = type;
+ type = newType;
+ if (eNotificationRequired())
+ eNotify(new ENotificationImpl(this, Notification.SET, EbnfPackage.ETSI_BNF__TYPE, oldType, type));
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ public ImportSection getImportSection()
+ {
+ return importSection;
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ public NotificationChain basicSetImportSection(ImportSection newImportSection, NotificationChain msgs)
+ {
+ ImportSection oldImportSection = importSection;
+ importSection = newImportSection;
+ if (eNotificationRequired())
+ {
+ ENotificationImpl notification = new ENotificationImpl(this, Notification.SET, EbnfPackage.ETSI_BNF__IMPORT_SECTION, oldImportSection, newImportSection);
+ if (msgs == null) msgs = notification; else msgs.add(notification);
+ }
+ return msgs;
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ public void setImportSection(ImportSection newImportSection)
+ {
+ if (newImportSection != importSection)
+ {
+ NotificationChain msgs = null;
+ if (importSection != null)
+ msgs = ((InternalEObject)importSection).eInverseRemove(this, EOPPOSITE_FEATURE_BASE - EbnfPackage.ETSI_BNF__IMPORT_SECTION, null, msgs);
+ if (newImportSection != null)
+ msgs = ((InternalEObject)newImportSection).eInverseAdd(this, EOPPOSITE_FEATURE_BASE - EbnfPackage.ETSI_BNF__IMPORT_SECTION, null, msgs);
+ msgs = basicSetImportSection(newImportSection, msgs);
+ if (msgs != null) msgs.dispatch();
+ }
+ else if (eNotificationRequired())
+ eNotify(new ENotificationImpl(this, Notification.SET, EbnfPackage.ETSI_BNF__IMPORT_SECTION, newImportSection, newImportSection));
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ public EList getBnfEntry()
+ {
+ if (bnfEntry == null)
+ {
+ bnfEntry = new EObjectContainmentEList(BnfEntry.class, this, EbnfPackage.ETSI_BNF__BNF_ENTRY);
+ }
+ return bnfEntry;
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ public EList getDeltaEntry()
+ {
+ if (deltaEntry == null)
+ {
+ deltaEntry = new EObjectContainmentEList(DeltaEntry.class, this, EbnfPackage.ETSI_BNF__DELTA_ENTRY);
+ }
+ return deltaEntry;
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ public EList getMergeEntry()
+ {
+ if (mergeEntry == null)
+ {
+ mergeEntry = new EObjectContainmentEList(MergeEntry.class, this, EbnfPackage.ETSI_BNF__MERGE_ENTRY);
+ }
+ return mergeEntry;
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ @Override
+ public NotificationChain eInverseRemove(InternalEObject otherEnd, int featureID, NotificationChain msgs)
+ {
+ switch (featureID)
+ {
+ case EbnfPackage.ETSI_BNF__IMPORT_SECTION:
+ return basicSetImportSection(null, msgs);
+ case EbnfPackage.ETSI_BNF__BNF_ENTRY:
+ return ((InternalEList)getBnfEntry()).basicRemove(otherEnd, msgs);
+ case EbnfPackage.ETSI_BNF__DELTA_ENTRY:
+ return ((InternalEList)getDeltaEntry()).basicRemove(otherEnd, msgs);
+ case EbnfPackage.ETSI_BNF__MERGE_ENTRY:
+ return ((InternalEList)getMergeEntry()).basicRemove(otherEnd, msgs);
+ }
+ return super.eInverseRemove(otherEnd, featureID, msgs);
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ @Override
+ public Object eGet(int featureID, boolean resolve, boolean coreType)
+ {
+ switch (featureID)
+ {
+ case EbnfPackage.ETSI_BNF__NAME:
+ return getName();
+ case EbnfPackage.ETSI_BNF__TYPE:
+ return getType();
+ case EbnfPackage.ETSI_BNF__IMPORT_SECTION:
+ return getImportSection();
+ case EbnfPackage.ETSI_BNF__BNF_ENTRY:
+ return getBnfEntry();
+ case EbnfPackage.ETSI_BNF__DELTA_ENTRY:
+ return getDeltaEntry();
+ case EbnfPackage.ETSI_BNF__MERGE_ENTRY:
+ return getMergeEntry();
+ }
+ return super.eGet(featureID, resolve, coreType);
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ @SuppressWarnings("unchecked")
+ @Override
+ public void eSet(int featureID, Object newValue)
+ {
+ switch (featureID)
+ {
+ case EbnfPackage.ETSI_BNF__NAME:
+ setName((String)newValue);
+ return;
+ case EbnfPackage.ETSI_BNF__TYPE:
+ setType((String)newValue);
+ return;
+ case EbnfPackage.ETSI_BNF__IMPORT_SECTION:
+ setImportSection((ImportSection)newValue);
+ return;
+ case EbnfPackage.ETSI_BNF__BNF_ENTRY:
+ getBnfEntry().clear();
+ getBnfEntry().addAll((Collection)newValue);
+ return;
+ case EbnfPackage.ETSI_BNF__DELTA_ENTRY:
+ getDeltaEntry().clear();
+ getDeltaEntry().addAll((Collection)newValue);
+ return;
+ case EbnfPackage.ETSI_BNF__MERGE_ENTRY:
+ getMergeEntry().clear();
+ getMergeEntry().addAll((Collection)newValue);
+ return;
+ }
+ super.eSet(featureID, newValue);
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ @Override
+ public void eUnset(int featureID)
+ {
+ switch (featureID)
+ {
+ case EbnfPackage.ETSI_BNF__NAME:
+ setName(NAME_EDEFAULT);
+ return;
+ case EbnfPackage.ETSI_BNF__TYPE:
+ setType(TYPE_EDEFAULT);
+ return;
+ case EbnfPackage.ETSI_BNF__IMPORT_SECTION:
+ setImportSection((ImportSection)null);
+ return;
+ case EbnfPackage.ETSI_BNF__BNF_ENTRY:
+ getBnfEntry().clear();
+ return;
+ case EbnfPackage.ETSI_BNF__DELTA_ENTRY:
+ getDeltaEntry().clear();
+ return;
+ case EbnfPackage.ETSI_BNF__MERGE_ENTRY:
+ getMergeEntry().clear();
+ return;
+ }
+ super.eUnset(featureID);
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ @Override
+ public boolean eIsSet(int featureID)
+ {
+ switch (featureID)
+ {
+ case EbnfPackage.ETSI_BNF__NAME:
+ return NAME_EDEFAULT == null ? name != null : !NAME_EDEFAULT.equals(name);
+ case EbnfPackage.ETSI_BNF__TYPE:
+ return TYPE_EDEFAULT == null ? type != null : !TYPE_EDEFAULT.equals(type);
+ case EbnfPackage.ETSI_BNF__IMPORT_SECTION:
+ return importSection != null;
+ case EbnfPackage.ETSI_BNF__BNF_ENTRY:
+ return bnfEntry != null && !bnfEntry.isEmpty();
+ case EbnfPackage.ETSI_BNF__DELTA_ENTRY:
+ return deltaEntry != null && !deltaEntry.isEmpty();
+ case EbnfPackage.ETSI_BNF__MERGE_ENTRY:
+ return mergeEntry != null && !mergeEntry.isEmpty();
+ }
+ return super.eIsSet(featureID);
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ @Override
+ public String toString()
+ {
+ if (eIsProxy()) return super.toString();
+
+ StringBuffer result = new StringBuffer(super.toString());
+ result.append(" (name: ");
+ result.append(name);
+ result.append(", type: ");
+ result.append(type);
+ result.append(')');
+ return result.toString();
+ }
+
+} //EtsiBnfImpl
Index: /v2/trunk/de.ugoe.cs.swe.bnftools.ebnf/src-gen/de/ugoe/cs/swe/bnftools/ebnf/impl/ExtRuleImpl.java
===================================================================
--- /v2/trunk/de.ugoe.cs.swe.bnftools.ebnf/src-gen/de/ugoe/cs/swe/bnftools/ebnf/impl/ExtRuleImpl.java (revision 61)
+++ /v2/trunk/de.ugoe.cs.swe.bnftools.ebnf/src-gen/de/ugoe/cs/swe/bnftools/ebnf/impl/ExtRuleImpl.java (revision 61)
@@ -0,0 +1,408 @@
+/**
+ */
+package de.ugoe.cs.swe.bnftools.ebnf.impl;
+
+import de.ugoe.cs.swe.bnftools.ebnf.Atom;
+import de.ugoe.cs.swe.bnftools.ebnf.EbnfPackage;
+import de.ugoe.cs.swe.bnftools.ebnf.ExtRule;
+
+import java.util.Collection;
+
+import org.eclipse.emf.common.notify.Notification;
+import org.eclipse.emf.common.notify.NotificationChain;
+
+import org.eclipse.emf.common.util.EList;
+
+import org.eclipse.emf.ecore.EClass;
+import org.eclipse.emf.ecore.InternalEObject;
+
+import org.eclipse.emf.ecore.impl.ENotificationImpl;
+import org.eclipse.emf.ecore.impl.MinimalEObjectImpl;
+
+import org.eclipse.emf.ecore.util.EObjectContainmentEList;
+import org.eclipse.emf.ecore.util.InternalEList;
+
+/**
+ *
+ * An implementation of the model object 'Ext Rule'.
+ *
+ *
+ * The following features are implemented:
+ *
+ * - {@link de.ugoe.cs.swe.bnftools.ebnf.impl.ExtRuleImpl#getRulenumber Rulenumber}
+ * - {@link de.ugoe.cs.swe.bnftools.ebnf.impl.ExtRuleImpl#getRulevariant Rulevariant}
+ * - {@link de.ugoe.cs.swe.bnftools.ebnf.impl.ExtRuleImpl#getName Name}
+ * - {@link de.ugoe.cs.swe.bnftools.ebnf.impl.ExtRuleImpl#getRuleext Ruleext}
+ * - {@link de.ugoe.cs.swe.bnftools.ebnf.impl.ExtRuleImpl#getElements Elements}
+ *
+ *
+ *
+ * @generated
+ */
+public class ExtRuleImpl extends MinimalEObjectImpl.Container implements ExtRule
+{
+ /**
+ * The default value of the '{@link #getRulenumber() Rulenumber}' attribute.
+ *
+ *
+ * @see #getRulenumber()
+ * @generated
+ * @ordered
+ */
+ protected static final int RULENUMBER_EDEFAULT = 0;
+
+ /**
+ * The cached value of the '{@link #getRulenumber() Rulenumber}' attribute.
+ *
+ *
+ * @see #getRulenumber()
+ * @generated
+ * @ordered
+ */
+ protected int rulenumber = RULENUMBER_EDEFAULT;
+
+ /**
+ * The default value of the '{@link #getRulevariant() Rulevariant}' attribute.
+ *
+ *
+ * @see #getRulevariant()
+ * @generated
+ * @ordered
+ */
+ protected static final String RULEVARIANT_EDEFAULT = null;
+
+ /**
+ * The cached value of the '{@link #getRulevariant() Rulevariant}' attribute.
+ *
+ *
+ * @see #getRulevariant()
+ * @generated
+ * @ordered
+ */
+ protected String rulevariant = RULEVARIANT_EDEFAULT;
+
+ /**
+ * The default value of the '{@link #getName() Name}' attribute.
+ *
+ *
+ * @see #getName()
+ * @generated
+ * @ordered
+ */
+ protected static final String NAME_EDEFAULT = null;
+
+ /**
+ * The cached value of the '{@link #getName() Name}' attribute.
+ *
+ *
+ * @see #getName()
+ * @generated
+ * @ordered
+ */
+ protected String name = NAME_EDEFAULT;
+
+ /**
+ * The default value of the '{@link #getRuleext() Ruleext}' attribute.
+ *
+ *
+ * @see #getRuleext()
+ * @generated
+ * @ordered
+ */
+ protected static final int RULEEXT_EDEFAULT = 0;
+
+ /**
+ * The cached value of the '{@link #getRuleext() Ruleext}' attribute.
+ *
+ *
+ * @see #getRuleext()
+ * @generated
+ * @ordered
+ */
+ protected int ruleext = RULEEXT_EDEFAULT;
+
+ /**
+ * The cached value of the '{@link #getElements() Elements}' containment reference list.
+ *
+ *
+ * @see #getElements()
+ * @generated
+ * @ordered
+ */
+ protected EList elements;
+
+ /**
+ *
+ *
+ * @generated
+ */
+ protected ExtRuleImpl()
+ {
+ super();
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ @Override
+ protected EClass eStaticClass()
+ {
+ return EbnfPackage.Literals.EXT_RULE;
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ public int getRulenumber()
+ {
+ return rulenumber;
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ public void setRulenumber(int newRulenumber)
+ {
+ int oldRulenumber = rulenumber;
+ rulenumber = newRulenumber;
+ if (eNotificationRequired())
+ eNotify(new ENotificationImpl(this, Notification.SET, EbnfPackage.EXT_RULE__RULENUMBER, oldRulenumber, rulenumber));
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ public String getRulevariant()
+ {
+ return rulevariant;
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ public void setRulevariant(String newRulevariant)
+ {
+ String oldRulevariant = rulevariant;
+ rulevariant = newRulevariant;
+ if (eNotificationRequired())
+ eNotify(new ENotificationImpl(this, Notification.SET, EbnfPackage.EXT_RULE__RULEVARIANT, oldRulevariant, rulevariant));
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ public String getName()
+ {
+ return name;
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ public void setName(String newName)
+ {
+ String oldName = name;
+ name = newName;
+ if (eNotificationRequired())
+ eNotify(new ENotificationImpl(this, Notification.SET, EbnfPackage.EXT_RULE__NAME, oldName, name));
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ public int getRuleext()
+ {
+ return ruleext;
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ public void setRuleext(int newRuleext)
+ {
+ int oldRuleext = ruleext;
+ ruleext = newRuleext;
+ if (eNotificationRequired())
+ eNotify(new ENotificationImpl(this, Notification.SET, EbnfPackage.EXT_RULE__RULEEXT, oldRuleext, ruleext));
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ public EList getElements()
+ {
+ if (elements == null)
+ {
+ elements = new EObjectContainmentEList(Atom.class, this, EbnfPackage.EXT_RULE__ELEMENTS);
+ }
+ return elements;
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ @Override
+ public NotificationChain eInverseRemove(InternalEObject otherEnd, int featureID, NotificationChain msgs)
+ {
+ switch (featureID)
+ {
+ case EbnfPackage.EXT_RULE__ELEMENTS:
+ return ((InternalEList)getElements()).basicRemove(otherEnd, msgs);
+ }
+ return super.eInverseRemove(otherEnd, featureID, msgs);
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ @Override
+ public Object eGet(int featureID, boolean resolve, boolean coreType)
+ {
+ switch (featureID)
+ {
+ case EbnfPackage.EXT_RULE__RULENUMBER:
+ return getRulenumber();
+ case EbnfPackage.EXT_RULE__RULEVARIANT:
+ return getRulevariant();
+ case EbnfPackage.EXT_RULE__NAME:
+ return getName();
+ case EbnfPackage.EXT_RULE__RULEEXT:
+ return getRuleext();
+ case EbnfPackage.EXT_RULE__ELEMENTS:
+ return getElements();
+ }
+ return super.eGet(featureID, resolve, coreType);
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ @SuppressWarnings("unchecked")
+ @Override
+ public void eSet(int featureID, Object newValue)
+ {
+ switch (featureID)
+ {
+ case EbnfPackage.EXT_RULE__RULENUMBER:
+ setRulenumber((Integer)newValue);
+ return;
+ case EbnfPackage.EXT_RULE__RULEVARIANT:
+ setRulevariant((String)newValue);
+ return;
+ case EbnfPackage.EXT_RULE__NAME:
+ setName((String)newValue);
+ return;
+ case EbnfPackage.EXT_RULE__RULEEXT:
+ setRuleext((Integer)newValue);
+ return;
+ case EbnfPackage.EXT_RULE__ELEMENTS:
+ getElements().clear();
+ getElements().addAll((Collection)newValue);
+ return;
+ }
+ super.eSet(featureID, newValue);
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ @Override
+ public void eUnset(int featureID)
+ {
+ switch (featureID)
+ {
+ case EbnfPackage.EXT_RULE__RULENUMBER:
+ setRulenumber(RULENUMBER_EDEFAULT);
+ return;
+ case EbnfPackage.EXT_RULE__RULEVARIANT:
+ setRulevariant(RULEVARIANT_EDEFAULT);
+ return;
+ case EbnfPackage.EXT_RULE__NAME:
+ setName(NAME_EDEFAULT);
+ return;
+ case EbnfPackage.EXT_RULE__RULEEXT:
+ setRuleext(RULEEXT_EDEFAULT);
+ return;
+ case EbnfPackage.EXT_RULE__ELEMENTS:
+ getElements().clear();
+ return;
+ }
+ super.eUnset(featureID);
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ @Override
+ public boolean eIsSet(int featureID)
+ {
+ switch (featureID)
+ {
+ case EbnfPackage.EXT_RULE__RULENUMBER:
+ return rulenumber != RULENUMBER_EDEFAULT;
+ case EbnfPackage.EXT_RULE__RULEVARIANT:
+ return RULEVARIANT_EDEFAULT == null ? rulevariant != null : !RULEVARIANT_EDEFAULT.equals(rulevariant);
+ case EbnfPackage.EXT_RULE__NAME:
+ return NAME_EDEFAULT == null ? name != null : !NAME_EDEFAULT.equals(name);
+ case EbnfPackage.EXT_RULE__RULEEXT:
+ return ruleext != RULEEXT_EDEFAULT;
+ case EbnfPackage.EXT_RULE__ELEMENTS:
+ return elements != null && !elements.isEmpty();
+ }
+ return super.eIsSet(featureID);
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ @Override
+ public String toString()
+ {
+ if (eIsProxy()) return super.toString();
+
+ StringBuffer result = new StringBuffer(super.toString());
+ result.append(" (rulenumber: ");
+ result.append(rulenumber);
+ result.append(", rulevariant: ");
+ result.append(rulevariant);
+ result.append(", name: ");
+ result.append(name);
+ result.append(", ruleext: ");
+ result.append(ruleext);
+ result.append(')');
+ return result.toString();
+ }
+
+} //ExtRuleImpl
Index: /v2/trunk/de.ugoe.cs.swe.bnftools.ebnf/src-gen/de/ugoe/cs/swe/bnftools/ebnf/impl/GlobalCombinatorImpl.java
===================================================================
--- /v2/trunk/de.ugoe.cs.swe.bnftools.ebnf/src-gen/de/ugoe/cs/swe/bnftools/ebnf/impl/GlobalCombinatorImpl.java (revision 61)
+++ /v2/trunk/de.ugoe.cs.swe.bnftools.ebnf/src-gen/de/ugoe/cs/swe/bnftools/ebnf/impl/GlobalCombinatorImpl.java (revision 61)
@@ -0,0 +1,42 @@
+/**
+ */
+package de.ugoe.cs.swe.bnftools.ebnf.impl;
+
+import de.ugoe.cs.swe.bnftools.ebnf.EbnfPackage;
+import de.ugoe.cs.swe.bnftools.ebnf.GlobalCombinator;
+
+import org.eclipse.emf.ecore.EClass;
+
+/**
+ *
+ * An implementation of the model object 'Global Combinator'.
+ *
+ *
+ *
+ *
+ * @generated
+ */
+public class GlobalCombinatorImpl extends MergeRuleImpl implements GlobalCombinator
+{
+ /**
+ *
+ *
+ * @generated
+ */
+ protected GlobalCombinatorImpl()
+ {
+ super();
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ @Override
+ protected EClass eStaticClass()
+ {
+ return EbnfPackage.Literals.GLOBAL_COMBINATOR;
+ }
+
+} //GlobalCombinatorImpl
Index: /v2/trunk/de.ugoe.cs.swe.bnftools.ebnf/src-gen/de/ugoe/cs/swe/bnftools/ebnf/impl/GroupedSequenceImpl.java
===================================================================
--- /v2/trunk/de.ugoe.cs.swe.bnftools.ebnf/src-gen/de/ugoe/cs/swe/bnftools/ebnf/impl/GroupedSequenceImpl.java (revision 61)
+++ /v2/trunk/de.ugoe.cs.swe.bnftools.ebnf/src-gen/de/ugoe/cs/swe/bnftools/ebnf/impl/GroupedSequenceImpl.java (revision 61)
@@ -0,0 +1,167 @@
+/**
+ */
+package de.ugoe.cs.swe.bnftools.ebnf.impl;
+
+import de.ugoe.cs.swe.bnftools.ebnf.DefinitionList;
+import de.ugoe.cs.swe.bnftools.ebnf.EbnfPackage;
+import de.ugoe.cs.swe.bnftools.ebnf.GroupedSequence;
+
+import java.util.Collection;
+
+import org.eclipse.emf.common.notify.NotificationChain;
+
+import org.eclipse.emf.common.util.EList;
+
+import org.eclipse.emf.ecore.EClass;
+import org.eclipse.emf.ecore.InternalEObject;
+
+import org.eclipse.emf.ecore.impl.MinimalEObjectImpl;
+
+import org.eclipse.emf.ecore.util.EObjectContainmentEList;
+import org.eclipse.emf.ecore.util.InternalEList;
+
+/**
+ *
+ * An implementation of the model object 'Grouped Sequence'.
+ *
+ *
+ * The following features are implemented:
+ *
+ * - {@link de.ugoe.cs.swe.bnftools.ebnf.impl.GroupedSequenceImpl#getDefinitionList Definition List}
+ *
+ *
+ *
+ * @generated
+ */
+public class GroupedSequenceImpl extends MinimalEObjectImpl.Container implements GroupedSequence
+{
+ /**
+ * The cached value of the '{@link #getDefinitionList() Definition List}' containment reference list.
+ *
+ *
+ * @see #getDefinitionList()
+ * @generated
+ * @ordered
+ */
+ protected EList definitionList;
+
+ /**
+ *
+ *
+ * @generated
+ */
+ protected GroupedSequenceImpl()
+ {
+ super();
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ @Override
+ protected EClass eStaticClass()
+ {
+ return EbnfPackage.Literals.GROUPED_SEQUENCE;
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ public EList getDefinitionList()
+ {
+ if (definitionList == null)
+ {
+ definitionList = new EObjectContainmentEList(DefinitionList.class, this, EbnfPackage.GROUPED_SEQUENCE__DEFINITION_LIST);
+ }
+ return definitionList;
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ @Override
+ public NotificationChain eInverseRemove(InternalEObject otherEnd, int featureID, NotificationChain msgs)
+ {
+ switch (featureID)
+ {
+ case EbnfPackage.GROUPED_SEQUENCE__DEFINITION_LIST:
+ return ((InternalEList)getDefinitionList()).basicRemove(otherEnd, msgs);
+ }
+ return super.eInverseRemove(otherEnd, featureID, msgs);
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ @Override
+ public Object eGet(int featureID, boolean resolve, boolean coreType)
+ {
+ switch (featureID)
+ {
+ case EbnfPackage.GROUPED_SEQUENCE__DEFINITION_LIST:
+ return getDefinitionList();
+ }
+ return super.eGet(featureID, resolve, coreType);
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ @SuppressWarnings("unchecked")
+ @Override
+ public void eSet(int featureID, Object newValue)
+ {
+ switch (featureID)
+ {
+ case EbnfPackage.GROUPED_SEQUENCE__DEFINITION_LIST:
+ getDefinitionList().clear();
+ getDefinitionList().addAll((Collection)newValue);
+ return;
+ }
+ super.eSet(featureID, newValue);
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ @Override
+ public void eUnset(int featureID)
+ {
+ switch (featureID)
+ {
+ case EbnfPackage.GROUPED_SEQUENCE__DEFINITION_LIST:
+ getDefinitionList().clear();
+ return;
+ }
+ super.eUnset(featureID);
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ @Override
+ public boolean eIsSet(int featureID)
+ {
+ switch (featureID)
+ {
+ case EbnfPackage.GROUPED_SEQUENCE__DEFINITION_LIST:
+ return definitionList != null && !definitionList.isEmpty();
+ }
+ return super.eIsSet(featureID);
+ }
+
+} //GroupedSequenceImpl
Index: /v2/trunk/de.ugoe.cs.swe.bnftools.ebnf/src-gen/de/ugoe/cs/swe/bnftools/ebnf/impl/HookCombinatorImpl.java
===================================================================
--- /v2/trunk/de.ugoe.cs.swe.bnftools.ebnf/src-gen/de/ugoe/cs/swe/bnftools/ebnf/impl/HookCombinatorImpl.java (revision 61)
+++ /v2/trunk/de.ugoe.cs.swe.bnftools.ebnf/src-gen/de/ugoe/cs/swe/bnftools/ebnf/impl/HookCombinatorImpl.java (revision 61)
@@ -0,0 +1,277 @@
+/**
+ */
+package de.ugoe.cs.swe.bnftools.ebnf.impl;
+
+import de.ugoe.cs.swe.bnftools.ebnf.EbnfPackage;
+import de.ugoe.cs.swe.bnftools.ebnf.HookCombinator;
+
+import java.util.Collection;
+
+import org.eclipse.emf.common.notify.Notification;
+
+import org.eclipse.emf.common.util.EList;
+
+import org.eclipse.emf.ecore.EClass;
+
+import org.eclipse.emf.ecore.impl.ENotificationImpl;
+
+import org.eclipse.emf.ecore.util.EDataTypeEList;
+
+/**
+ *
+ * An implementation of the model object 'Hook Combinator'.
+ *
+ *
+ * The following features are implemented:
+ *
+ * - {@link de.ugoe.cs.swe.bnftools.ebnf.impl.HookCombinatorImpl#getName Name}
+ * - {@link de.ugoe.cs.swe.bnftools.ebnf.impl.HookCombinatorImpl#getRuleext Ruleext}
+ * - {@link de.ugoe.cs.swe.bnftools.ebnf.impl.HookCombinatorImpl#getLABEL LABEL}
+ *
+ *
+ *
+ * @generated
+ */
+public class HookCombinatorImpl extends MergeRuleImpl implements HookCombinator
+{
+ /**
+ * The default value of the '{@link #getName() Name}' attribute.
+ *
+ *
+ * @see #getName()
+ * @generated
+ * @ordered
+ */
+ protected static final String NAME_EDEFAULT = null;
+
+ /**
+ * The cached value of the '{@link #getName() Name}' attribute.
+ *
+ *
+ * @see #getName()
+ * @generated
+ * @ordered
+ */
+ protected String name = NAME_EDEFAULT;
+
+ /**
+ * The default value of the '{@link #getRuleext() Ruleext}' attribute.
+ *
+ *
+ * @see #getRuleext()
+ * @generated
+ * @ordered
+ */
+ protected static final int RULEEXT_EDEFAULT = 0;
+
+ /**
+ * The cached value of the '{@link #getRuleext() Ruleext}' attribute.
+ *
+ *
+ * @see #getRuleext()
+ * @generated
+ * @ordered
+ */
+ protected int ruleext = RULEEXT_EDEFAULT;
+
+ /**
+ * The cached value of the '{@link #getLABEL() LABEL}' attribute list.
+ *
+ *
+ * @see #getLABEL()
+ * @generated
+ * @ordered
+ */
+ protected EList label;
+
+ /**
+ *
+ *
+ * @generated
+ */
+ protected HookCombinatorImpl()
+ {
+ super();
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ @Override
+ protected EClass eStaticClass()
+ {
+ return EbnfPackage.Literals.HOOK_COMBINATOR;
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ public String getName()
+ {
+ return name;
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ public void setName(String newName)
+ {
+ String oldName = name;
+ name = newName;
+ if (eNotificationRequired())
+ eNotify(new ENotificationImpl(this, Notification.SET, EbnfPackage.HOOK_COMBINATOR__NAME, oldName, name));
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ public int getRuleext()
+ {
+ return ruleext;
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ public void setRuleext(int newRuleext)
+ {
+ int oldRuleext = ruleext;
+ ruleext = newRuleext;
+ if (eNotificationRequired())
+ eNotify(new ENotificationImpl(this, Notification.SET, EbnfPackage.HOOK_COMBINATOR__RULEEXT, oldRuleext, ruleext));
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ public EList getLABEL()
+ {
+ if (label == null)
+ {
+ label = new EDataTypeEList(String.class, this, EbnfPackage.HOOK_COMBINATOR__LABEL);
+ }
+ return label;
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ @Override
+ public Object eGet(int featureID, boolean resolve, boolean coreType)
+ {
+ switch (featureID)
+ {
+ case EbnfPackage.HOOK_COMBINATOR__NAME:
+ return getName();
+ case EbnfPackage.HOOK_COMBINATOR__RULEEXT:
+ return getRuleext();
+ case EbnfPackage.HOOK_COMBINATOR__LABEL:
+ return getLABEL();
+ }
+ return super.eGet(featureID, resolve, coreType);
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ @SuppressWarnings("unchecked")
+ @Override
+ public void eSet(int featureID, Object newValue)
+ {
+ switch (featureID)
+ {
+ case EbnfPackage.HOOK_COMBINATOR__NAME:
+ setName((String)newValue);
+ return;
+ case EbnfPackage.HOOK_COMBINATOR__RULEEXT:
+ setRuleext((Integer)newValue);
+ return;
+ case EbnfPackage.HOOK_COMBINATOR__LABEL:
+ getLABEL().clear();
+ getLABEL().addAll((Collection)newValue);
+ return;
+ }
+ super.eSet(featureID, newValue);
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ @Override
+ public void eUnset(int featureID)
+ {
+ switch (featureID)
+ {
+ case EbnfPackage.HOOK_COMBINATOR__NAME:
+ setName(NAME_EDEFAULT);
+ return;
+ case EbnfPackage.HOOK_COMBINATOR__RULEEXT:
+ setRuleext(RULEEXT_EDEFAULT);
+ return;
+ case EbnfPackage.HOOK_COMBINATOR__LABEL:
+ getLABEL().clear();
+ return;
+ }
+ super.eUnset(featureID);
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ @Override
+ public boolean eIsSet(int featureID)
+ {
+ switch (featureID)
+ {
+ case EbnfPackage.HOOK_COMBINATOR__NAME:
+ return NAME_EDEFAULT == null ? name != null : !NAME_EDEFAULT.equals(name);
+ case EbnfPackage.HOOK_COMBINATOR__RULEEXT:
+ return ruleext != RULEEXT_EDEFAULT;
+ case EbnfPackage.HOOK_COMBINATOR__LABEL:
+ return label != null && !label.isEmpty();
+ }
+ return super.eIsSet(featureID);
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ @Override
+ public String toString()
+ {
+ if (eIsProxy()) return super.toString();
+
+ StringBuffer result = new StringBuffer(super.toString());
+ result.append(" (name: ");
+ result.append(name);
+ result.append(", ruleext: ");
+ result.append(ruleext);
+ result.append(", LABEL: ");
+ result.append(label);
+ result.append(')');
+ return result.toString();
+ }
+
+} //HookCombinatorImpl
Index: /v2/trunk/de.ugoe.cs.swe.bnftools.ebnf/src-gen/de/ugoe/cs/swe/bnftools/ebnf/impl/ImportImpl.java
===================================================================
--- /v2/trunk/de.ugoe.cs.swe.bnftools.ebnf/src-gen/de/ugoe/cs/swe/bnftools/ebnf/impl/ImportImpl.java (revision 61)
+++ /v2/trunk/de.ugoe.cs.swe.bnftools.ebnf/src-gen/de/ugoe/cs/swe/bnftools/ebnf/impl/ImportImpl.java (revision 61)
@@ -0,0 +1,289 @@
+/**
+ */
+package de.ugoe.cs.swe.bnftools.ebnf.impl;
+
+import de.ugoe.cs.swe.bnftools.ebnf.EbnfPackage;
+import de.ugoe.cs.swe.bnftools.ebnf.Import;
+
+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;
+
+/**
+ *
+ * An implementation of the model object 'Import'.
+ *
+ *
+ * The following features are implemented:
+ *
+ * - {@link de.ugoe.cs.swe.bnftools.ebnf.impl.ImportImpl#getImportURI Import URI}
+ * - {@link de.ugoe.cs.swe.bnftools.ebnf.impl.ImportImpl#getGrammarType Grammar Type}
+ * - {@link de.ugoe.cs.swe.bnftools.ebnf.impl.ImportImpl#getLabel Label}
+ *
+ *
+ *
+ * @generated
+ */
+public class ImportImpl extends MinimalEObjectImpl.Container implements Import
+{
+ /**
+ * The default value of the '{@link #getImportURI() Import URI}' attribute.
+ *
+ *
+ * @see #getImportURI()
+ * @generated
+ * @ordered
+ */
+ protected static final String IMPORT_URI_EDEFAULT = null;
+
+ /**
+ * The cached value of the '{@link #getImportURI() Import URI}' attribute.
+ *
+ *
+ * @see #getImportURI()
+ * @generated
+ * @ordered
+ */
+ protected String importURI = IMPORT_URI_EDEFAULT;
+
+ /**
+ * The default value of the '{@link #getGrammarType() Grammar Type}' attribute.
+ *
+ *
+ * @see #getGrammarType()
+ * @generated
+ * @ordered
+ */
+ protected static final String GRAMMAR_TYPE_EDEFAULT = null;
+
+ /**
+ * The cached value of the '{@link #getGrammarType() Grammar Type}' attribute.
+ *
+ *
+ * @see #getGrammarType()
+ * @generated
+ * @ordered
+ */
+ protected String grammarType = GRAMMAR_TYPE_EDEFAULT;
+
+ /**
+ * The default value of the '{@link #getLabel() Label}' attribute.
+ *
+ *
+ * @see #getLabel()
+ * @generated
+ * @ordered
+ */
+ protected static final String LABEL_EDEFAULT = null;
+
+ /**
+ * The cached value of the '{@link #getLabel() Label}' attribute.
+ *
+ *
+ * @see #getLabel()
+ * @generated
+ * @ordered
+ */
+ protected String label = LABEL_EDEFAULT;
+
+ /**
+ *
+ *
+ * @generated
+ */
+ protected ImportImpl()
+ {
+ super();
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ @Override
+ protected EClass eStaticClass()
+ {
+ return EbnfPackage.Literals.IMPORT;
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ public String getImportURI()
+ {
+ return importURI;
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ public void setImportURI(String newImportURI)
+ {
+ String oldImportURI = importURI;
+ importURI = newImportURI;
+ if (eNotificationRequired())
+ eNotify(new ENotificationImpl(this, Notification.SET, EbnfPackage.IMPORT__IMPORT_URI, oldImportURI, importURI));
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ public String getGrammarType()
+ {
+ return grammarType;
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ public void setGrammarType(String newGrammarType)
+ {
+ String oldGrammarType = grammarType;
+ grammarType = newGrammarType;
+ if (eNotificationRequired())
+ eNotify(new ENotificationImpl(this, Notification.SET, EbnfPackage.IMPORT__GRAMMAR_TYPE, oldGrammarType, grammarType));
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ public String getLabel()
+ {
+ return label;
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ public void setLabel(String newLabel)
+ {
+ String oldLabel = label;
+ label = newLabel;
+ if (eNotificationRequired())
+ eNotify(new ENotificationImpl(this, Notification.SET, EbnfPackage.IMPORT__LABEL, oldLabel, label));
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ @Override
+ public Object eGet(int featureID, boolean resolve, boolean coreType)
+ {
+ switch (featureID)
+ {
+ case EbnfPackage.IMPORT__IMPORT_URI:
+ return getImportURI();
+ case EbnfPackage.IMPORT__GRAMMAR_TYPE:
+ return getGrammarType();
+ case EbnfPackage.IMPORT__LABEL:
+ return getLabel();
+ }
+ return super.eGet(featureID, resolve, coreType);
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ @Override
+ public void eSet(int featureID, Object newValue)
+ {
+ switch (featureID)
+ {
+ case EbnfPackage.IMPORT__IMPORT_URI:
+ setImportURI((String)newValue);
+ return;
+ case EbnfPackage.IMPORT__GRAMMAR_TYPE:
+ setGrammarType((String)newValue);
+ return;
+ case EbnfPackage.IMPORT__LABEL:
+ setLabel((String)newValue);
+ return;
+ }
+ super.eSet(featureID, newValue);
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ @Override
+ public void eUnset(int featureID)
+ {
+ switch (featureID)
+ {
+ case EbnfPackage.IMPORT__IMPORT_URI:
+ setImportURI(IMPORT_URI_EDEFAULT);
+ return;
+ case EbnfPackage.IMPORT__GRAMMAR_TYPE:
+ setGrammarType(GRAMMAR_TYPE_EDEFAULT);
+ return;
+ case EbnfPackage.IMPORT__LABEL:
+ setLabel(LABEL_EDEFAULT);
+ return;
+ }
+ super.eUnset(featureID);
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ @Override
+ public boolean eIsSet(int featureID)
+ {
+ switch (featureID)
+ {
+ case EbnfPackage.IMPORT__IMPORT_URI:
+ return IMPORT_URI_EDEFAULT == null ? importURI != null : !IMPORT_URI_EDEFAULT.equals(importURI);
+ case EbnfPackage.IMPORT__GRAMMAR_TYPE:
+ return GRAMMAR_TYPE_EDEFAULT == null ? grammarType != null : !GRAMMAR_TYPE_EDEFAULT.equals(grammarType);
+ case EbnfPackage.IMPORT__LABEL:
+ return LABEL_EDEFAULT == null ? label != null : !LABEL_EDEFAULT.equals(label);
+ }
+ return super.eIsSet(featureID);
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ @Override
+ public String toString()
+ {
+ if (eIsProxy()) return super.toString();
+
+ StringBuffer result = new StringBuffer(super.toString());
+ result.append(" (importURI: ");
+ result.append(importURI);
+ result.append(", grammarType: ");
+ result.append(grammarType);
+ result.append(", label: ");
+ result.append(label);
+ result.append(')');
+ return result.toString();
+ }
+
+} //ImportImpl
Index: /v2/trunk/de.ugoe.cs.swe.bnftools.ebnf/src-gen/de/ugoe/cs/swe/bnftools/ebnf/impl/ImportSectionImpl.java
===================================================================
--- /v2/trunk/de.ugoe.cs.swe.bnftools.ebnf/src-gen/de/ugoe/cs/swe/bnftools/ebnf/impl/ImportSectionImpl.java (revision 61)
+++ /v2/trunk/de.ugoe.cs.swe.bnftools.ebnf/src-gen/de/ugoe/cs/swe/bnftools/ebnf/impl/ImportSectionImpl.java (revision 61)
@@ -0,0 +1,167 @@
+/**
+ */
+package de.ugoe.cs.swe.bnftools.ebnf.impl;
+
+import de.ugoe.cs.swe.bnftools.ebnf.EbnfPackage;
+import de.ugoe.cs.swe.bnftools.ebnf.Import;
+import de.ugoe.cs.swe.bnftools.ebnf.ImportSection;
+
+import java.util.Collection;
+
+import org.eclipse.emf.common.notify.NotificationChain;
+
+import org.eclipse.emf.common.util.EList;
+
+import org.eclipse.emf.ecore.EClass;
+import org.eclipse.emf.ecore.InternalEObject;
+
+import org.eclipse.emf.ecore.impl.MinimalEObjectImpl;
+
+import org.eclipse.emf.ecore.util.EObjectContainmentEList;
+import org.eclipse.emf.ecore.util.InternalEList;
+
+/**
+ *
+ * An implementation of the model object 'Import Section'.
+ *
+ *
+ * The following features are implemented:
+ *
+ * - {@link de.ugoe.cs.swe.bnftools.ebnf.impl.ImportSectionImpl#getImports Imports}
+ *
+ *
+ *
+ * @generated
+ */
+public class ImportSectionImpl extends MinimalEObjectImpl.Container implements ImportSection
+{
+ /**
+ * The cached value of the '{@link #getImports() Imports}' containment reference list.
+ *
+ *
+ * @see #getImports()
+ * @generated
+ * @ordered
+ */
+ protected EList imports;
+
+ /**
+ *
+ *
+ * @generated
+ */
+ protected ImportSectionImpl()
+ {
+ super();
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ @Override
+ protected EClass eStaticClass()
+ {
+ return EbnfPackage.Literals.IMPORT_SECTION;
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ public EList getImports()
+ {
+ if (imports == null)
+ {
+ imports = new EObjectContainmentEList(Import.class, this, EbnfPackage.IMPORT_SECTION__IMPORTS);
+ }
+ return imports;
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ @Override
+ public NotificationChain eInverseRemove(InternalEObject otherEnd, int featureID, NotificationChain msgs)
+ {
+ switch (featureID)
+ {
+ case EbnfPackage.IMPORT_SECTION__IMPORTS:
+ return ((InternalEList)getImports()).basicRemove(otherEnd, msgs);
+ }
+ return super.eInverseRemove(otherEnd, featureID, msgs);
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ @Override
+ public Object eGet(int featureID, boolean resolve, boolean coreType)
+ {
+ switch (featureID)
+ {
+ case EbnfPackage.IMPORT_SECTION__IMPORTS:
+ return getImports();
+ }
+ return super.eGet(featureID, resolve, coreType);
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ @SuppressWarnings("unchecked")
+ @Override
+ public void eSet(int featureID, Object newValue)
+ {
+ switch (featureID)
+ {
+ case EbnfPackage.IMPORT_SECTION__IMPORTS:
+ getImports().clear();
+ getImports().addAll((Collection)newValue);
+ return;
+ }
+ super.eSet(featureID, newValue);
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ @Override
+ public void eUnset(int featureID)
+ {
+ switch (featureID)
+ {
+ case EbnfPackage.IMPORT_SECTION__IMPORTS:
+ getImports().clear();
+ return;
+ }
+ super.eUnset(featureID);
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ @Override
+ public boolean eIsSet(int featureID)
+ {
+ switch (featureID)
+ {
+ case EbnfPackage.IMPORT_SECTION__IMPORTS:
+ return imports != null && !imports.isEmpty();
+ }
+ return super.eIsSet(featureID);
+ }
+
+} //ImportSectionImpl
Index: /v2/trunk/de.ugoe.cs.swe.bnftools.ebnf/src-gen/de/ugoe/cs/swe/bnftools/ebnf/impl/MergeEntryImpl.java
===================================================================
--- /v2/trunk/de.ugoe.cs.swe.bnftools.ebnf/src-gen/de/ugoe/cs/swe/bnftools/ebnf/impl/MergeEntryImpl.java (revision 61)
+++ /v2/trunk/de.ugoe.cs.swe.bnftools.ebnf/src-gen/de/ugoe/cs/swe/bnftools/ebnf/impl/MergeEntryImpl.java (revision 61)
@@ -0,0 +1,266 @@
+/**
+ */
+package de.ugoe.cs.swe.bnftools.ebnf.impl;
+
+import de.ugoe.cs.swe.bnftools.ebnf.EbnfPackage;
+import de.ugoe.cs.swe.bnftools.ebnf.MergeEntry;
+import de.ugoe.cs.swe.bnftools.ebnf.MergeRule;
+import de.ugoe.cs.swe.bnftools.ebnf.SectionHeading;
+
+import org.eclipse.emf.common.notify.Notification;
+import org.eclipse.emf.common.notify.NotificationChain;
+
+import org.eclipse.emf.ecore.EClass;
+import org.eclipse.emf.ecore.InternalEObject;
+
+import org.eclipse.emf.ecore.impl.ENotificationImpl;
+import org.eclipse.emf.ecore.impl.MinimalEObjectImpl;
+
+/**
+ *
+ * An implementation of the model object 'Merge Entry'.
+ *
+ *
+ * The following features are implemented:
+ *
+ * - {@link de.ugoe.cs.swe.bnftools.ebnf.impl.MergeEntryImpl#getSectionheader Sectionheader}
+ * - {@link de.ugoe.cs.swe.bnftools.ebnf.impl.MergeEntryImpl#getMergeRule Merge Rule}
+ *
+ *
+ *
+ * @generated
+ */
+public class MergeEntryImpl extends MinimalEObjectImpl.Container implements MergeEntry
+{
+ /**
+ * The cached value of the '{@link #getSectionheader() Sectionheader}' containment reference.
+ *
+ *
+ * @see #getSectionheader()
+ * @generated
+ * @ordered
+ */
+ protected SectionHeading sectionheader;
+
+ /**
+ * The cached value of the '{@link #getMergeRule() Merge Rule}' containment reference.
+ *
+ *
+ * @see #getMergeRule()
+ * @generated
+ * @ordered
+ */
+ protected MergeRule mergeRule;
+
+ /**
+ *
+ *
+ * @generated
+ */
+ protected MergeEntryImpl()
+ {
+ super();
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ @Override
+ protected EClass eStaticClass()
+ {
+ return EbnfPackage.Literals.MERGE_ENTRY;
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ public SectionHeading getSectionheader()
+ {
+ return sectionheader;
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ public NotificationChain basicSetSectionheader(SectionHeading newSectionheader, NotificationChain msgs)
+ {
+ SectionHeading oldSectionheader = sectionheader;
+ sectionheader = newSectionheader;
+ if (eNotificationRequired())
+ {
+ ENotificationImpl notification = new ENotificationImpl(this, Notification.SET, EbnfPackage.MERGE_ENTRY__SECTIONHEADER, oldSectionheader, newSectionheader);
+ if (msgs == null) msgs = notification; else msgs.add(notification);
+ }
+ return msgs;
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ public void setSectionheader(SectionHeading newSectionheader)
+ {
+ if (newSectionheader != sectionheader)
+ {
+ NotificationChain msgs = null;
+ if (sectionheader != null)
+ msgs = ((InternalEObject)sectionheader).eInverseRemove(this, EOPPOSITE_FEATURE_BASE - EbnfPackage.MERGE_ENTRY__SECTIONHEADER, null, msgs);
+ if (newSectionheader != null)
+ msgs = ((InternalEObject)newSectionheader).eInverseAdd(this, EOPPOSITE_FEATURE_BASE - EbnfPackage.MERGE_ENTRY__SECTIONHEADER, null, msgs);
+ msgs = basicSetSectionheader(newSectionheader, msgs);
+ if (msgs != null) msgs.dispatch();
+ }
+ else if (eNotificationRequired())
+ eNotify(new ENotificationImpl(this, Notification.SET, EbnfPackage.MERGE_ENTRY__SECTIONHEADER, newSectionheader, newSectionheader));
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ public MergeRule getMergeRule()
+ {
+ return mergeRule;
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ public NotificationChain basicSetMergeRule(MergeRule newMergeRule, NotificationChain msgs)
+ {
+ MergeRule oldMergeRule = mergeRule;
+ mergeRule = newMergeRule;
+ if (eNotificationRequired())
+ {
+ ENotificationImpl notification = new ENotificationImpl(this, Notification.SET, EbnfPackage.MERGE_ENTRY__MERGE_RULE, oldMergeRule, newMergeRule);
+ if (msgs == null) msgs = notification; else msgs.add(notification);
+ }
+ return msgs;
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ public void setMergeRule(MergeRule newMergeRule)
+ {
+ if (newMergeRule != mergeRule)
+ {
+ NotificationChain msgs = null;
+ if (mergeRule != null)
+ msgs = ((InternalEObject)mergeRule).eInverseRemove(this, EOPPOSITE_FEATURE_BASE - EbnfPackage.MERGE_ENTRY__MERGE_RULE, null, msgs);
+ if (newMergeRule != null)
+ msgs = ((InternalEObject)newMergeRule).eInverseAdd(this, EOPPOSITE_FEATURE_BASE - EbnfPackage.MERGE_ENTRY__MERGE_RULE, null, msgs);
+ msgs = basicSetMergeRule(newMergeRule, msgs);
+ if (msgs != null) msgs.dispatch();
+ }
+ else if (eNotificationRequired())
+ eNotify(new ENotificationImpl(this, Notification.SET, EbnfPackage.MERGE_ENTRY__MERGE_RULE, newMergeRule, newMergeRule));
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ @Override
+ public NotificationChain eInverseRemove(InternalEObject otherEnd, int featureID, NotificationChain msgs)
+ {
+ switch (featureID)
+ {
+ case EbnfPackage.MERGE_ENTRY__SECTIONHEADER:
+ return basicSetSectionheader(null, msgs);
+ case EbnfPackage.MERGE_ENTRY__MERGE_RULE:
+ return basicSetMergeRule(null, msgs);
+ }
+ return super.eInverseRemove(otherEnd, featureID, msgs);
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ @Override
+ public Object eGet(int featureID, boolean resolve, boolean coreType)
+ {
+ switch (featureID)
+ {
+ case EbnfPackage.MERGE_ENTRY__SECTIONHEADER:
+ return getSectionheader();
+ case EbnfPackage.MERGE_ENTRY__MERGE_RULE:
+ return getMergeRule();
+ }
+ return super.eGet(featureID, resolve, coreType);
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ @Override
+ public void eSet(int featureID, Object newValue)
+ {
+ switch (featureID)
+ {
+ case EbnfPackage.MERGE_ENTRY__SECTIONHEADER:
+ setSectionheader((SectionHeading)newValue);
+ return;
+ case EbnfPackage.MERGE_ENTRY__MERGE_RULE:
+ setMergeRule((MergeRule)newValue);
+ return;
+ }
+ super.eSet(featureID, newValue);
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ @Override
+ public void eUnset(int featureID)
+ {
+ switch (featureID)
+ {
+ case EbnfPackage.MERGE_ENTRY__SECTIONHEADER:
+ setSectionheader((SectionHeading)null);
+ return;
+ case EbnfPackage.MERGE_ENTRY__MERGE_RULE:
+ setMergeRule((MergeRule)null);
+ return;
+ }
+ super.eUnset(featureID);
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ @Override
+ public boolean eIsSet(int featureID)
+ {
+ switch (featureID)
+ {
+ case EbnfPackage.MERGE_ENTRY__SECTIONHEADER:
+ return sectionheader != null;
+ case EbnfPackage.MERGE_ENTRY__MERGE_RULE:
+ return mergeRule != null;
+ }
+ return super.eIsSet(featureID);
+ }
+
+} //MergeEntryImpl
Index: /v2/trunk/de.ugoe.cs.swe.bnftools.ebnf/src-gen/de/ugoe/cs/swe/bnftools/ebnf/impl/MergeRuleImpl.java
===================================================================
--- /v2/trunk/de.ugoe.cs.swe.bnftools.ebnf/src-gen/de/ugoe/cs/swe/bnftools/ebnf/impl/MergeRuleImpl.java (revision 61)
+++ /v2/trunk/de.ugoe.cs.swe.bnftools.ebnf/src-gen/de/ugoe/cs/swe/bnftools/ebnf/impl/MergeRuleImpl.java (revision 61)
@@ -0,0 +1,177 @@
+/**
+ */
+package de.ugoe.cs.swe.bnftools.ebnf.impl;
+
+import de.ugoe.cs.swe.bnftools.ebnf.EbnfPackage;
+import de.ugoe.cs.swe.bnftools.ebnf.MergeRule;
+
+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;
+
+/**
+ *
+ * An implementation of the model object 'Merge Rule'.
+ *
+ *
+ * The following features are implemented:
+ *
+ * - {@link de.ugoe.cs.swe.bnftools.ebnf.impl.MergeRuleImpl#getLogic Logic}
+ *
+ *
+ *
+ * @generated
+ */
+public class MergeRuleImpl extends MinimalEObjectImpl.Container implements MergeRule
+{
+ /**
+ * The default value of the '{@link #getLogic() Logic}' attribute.
+ *
+ *
+ * @see #getLogic()
+ * @generated
+ * @ordered
+ */
+ protected static final String LOGIC_EDEFAULT = null;
+
+ /**
+ * The cached value of the '{@link #getLogic() Logic}' attribute.
+ *
+ *
+ * @see #getLogic()
+ * @generated
+ * @ordered
+ */
+ protected String logic = LOGIC_EDEFAULT;
+
+ /**
+ *
+ *
+ * @generated
+ */
+ protected MergeRuleImpl()
+ {
+ super();
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ @Override
+ protected EClass eStaticClass()
+ {
+ return EbnfPackage.Literals.MERGE_RULE;
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ public String getLogic()
+ {
+ return logic;
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ public void setLogic(String newLogic)
+ {
+ String oldLogic = logic;
+ logic = newLogic;
+ if (eNotificationRequired())
+ eNotify(new ENotificationImpl(this, Notification.SET, EbnfPackage.MERGE_RULE__LOGIC, oldLogic, logic));
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ @Override
+ public Object eGet(int featureID, boolean resolve, boolean coreType)
+ {
+ switch (featureID)
+ {
+ case EbnfPackage.MERGE_RULE__LOGIC:
+ return getLogic();
+ }
+ return super.eGet(featureID, resolve, coreType);
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ @Override
+ public void eSet(int featureID, Object newValue)
+ {
+ switch (featureID)
+ {
+ case EbnfPackage.MERGE_RULE__LOGIC:
+ setLogic((String)newValue);
+ return;
+ }
+ super.eSet(featureID, newValue);
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ @Override
+ public void eUnset(int featureID)
+ {
+ switch (featureID)
+ {
+ case EbnfPackage.MERGE_RULE__LOGIC:
+ setLogic(LOGIC_EDEFAULT);
+ return;
+ }
+ super.eUnset(featureID);
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ @Override
+ public boolean eIsSet(int featureID)
+ {
+ switch (featureID)
+ {
+ case EbnfPackage.MERGE_RULE__LOGIC:
+ return LOGIC_EDEFAULT == null ? logic != null : !LOGIC_EDEFAULT.equals(logic);
+ }
+ return super.eIsSet(featureID);
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ @Override
+ public String toString()
+ {
+ if (eIsProxy()) return super.toString();
+
+ StringBuffer result = new StringBuffer(super.toString());
+ result.append(" (logic: ");
+ result.append(logic);
+ result.append(')');
+ return result.toString();
+ }
+
+} //MergeRuleImpl
Index: /v2/trunk/de.ugoe.cs.swe.bnftools.ebnf/src-gen/de/ugoe/cs/swe/bnftools/ebnf/impl/OptionalSequenceImpl.java
===================================================================
--- /v2/trunk/de.ugoe.cs.swe.bnftools.ebnf/src-gen/de/ugoe/cs/swe/bnftools/ebnf/impl/OptionalSequenceImpl.java (revision 61)
+++ /v2/trunk/de.ugoe.cs.swe.bnftools.ebnf/src-gen/de/ugoe/cs/swe/bnftools/ebnf/impl/OptionalSequenceImpl.java (revision 61)
@@ -0,0 +1,167 @@
+/**
+ */
+package de.ugoe.cs.swe.bnftools.ebnf.impl;
+
+import de.ugoe.cs.swe.bnftools.ebnf.DefinitionList;
+import de.ugoe.cs.swe.bnftools.ebnf.EbnfPackage;
+import de.ugoe.cs.swe.bnftools.ebnf.OptionalSequence;
+
+import java.util.Collection;
+
+import org.eclipse.emf.common.notify.NotificationChain;
+
+import org.eclipse.emf.common.util.EList;
+
+import org.eclipse.emf.ecore.EClass;
+import org.eclipse.emf.ecore.InternalEObject;
+
+import org.eclipse.emf.ecore.impl.MinimalEObjectImpl;
+
+import org.eclipse.emf.ecore.util.EObjectContainmentEList;
+import org.eclipse.emf.ecore.util.InternalEList;
+
+/**
+ *
+ * An implementation of the model object 'Optional Sequence'.
+ *
+ *
+ * The following features are implemented:
+ *
+ * - {@link de.ugoe.cs.swe.bnftools.ebnf.impl.OptionalSequenceImpl#getDefinitionList Definition List}
+ *
+ *
+ *
+ * @generated
+ */
+public class OptionalSequenceImpl extends MinimalEObjectImpl.Container implements OptionalSequence
+{
+ /**
+ * The cached value of the '{@link #getDefinitionList() Definition List}' containment reference list.
+ *
+ *
+ * @see #getDefinitionList()
+ * @generated
+ * @ordered
+ */
+ protected EList definitionList;
+
+ /**
+ *
+ *
+ * @generated
+ */
+ protected OptionalSequenceImpl()
+ {
+ super();
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ @Override
+ protected EClass eStaticClass()
+ {
+ return EbnfPackage.Literals.OPTIONAL_SEQUENCE;
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ public EList getDefinitionList()
+ {
+ if (definitionList == null)
+ {
+ definitionList = new EObjectContainmentEList(DefinitionList.class, this, EbnfPackage.OPTIONAL_SEQUENCE__DEFINITION_LIST);
+ }
+ return definitionList;
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ @Override
+ public NotificationChain eInverseRemove(InternalEObject otherEnd, int featureID, NotificationChain msgs)
+ {
+ switch (featureID)
+ {
+ case EbnfPackage.OPTIONAL_SEQUENCE__DEFINITION_LIST:
+ return ((InternalEList)getDefinitionList()).basicRemove(otherEnd, msgs);
+ }
+ return super.eInverseRemove(otherEnd, featureID, msgs);
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ @Override
+ public Object eGet(int featureID, boolean resolve, boolean coreType)
+ {
+ switch (featureID)
+ {
+ case EbnfPackage.OPTIONAL_SEQUENCE__DEFINITION_LIST:
+ return getDefinitionList();
+ }
+ return super.eGet(featureID, resolve, coreType);
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ @SuppressWarnings("unchecked")
+ @Override
+ public void eSet(int featureID, Object newValue)
+ {
+ switch (featureID)
+ {
+ case EbnfPackage.OPTIONAL_SEQUENCE__DEFINITION_LIST:
+ getDefinitionList().clear();
+ getDefinitionList().addAll((Collection)newValue);
+ return;
+ }
+ super.eSet(featureID, newValue);
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ @Override
+ public void eUnset(int featureID)
+ {
+ switch (featureID)
+ {
+ case EbnfPackage.OPTIONAL_SEQUENCE__DEFINITION_LIST:
+ getDefinitionList().clear();
+ return;
+ }
+ super.eUnset(featureID);
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ @Override
+ public boolean eIsSet(int featureID)
+ {
+ switch (featureID)
+ {
+ case EbnfPackage.OPTIONAL_SEQUENCE__DEFINITION_LIST:
+ return definitionList != null && !definitionList.isEmpty();
+ }
+ return super.eIsSet(featureID);
+ }
+
+} //OptionalSequenceImpl
Index: /v2/trunk/de.ugoe.cs.swe.bnftools.ebnf/src-gen/de/ugoe/cs/swe/bnftools/ebnf/impl/RepeatedSequenceImpl.java
===================================================================
--- /v2/trunk/de.ugoe.cs.swe.bnftools.ebnf/src-gen/de/ugoe/cs/swe/bnftools/ebnf/impl/RepeatedSequenceImpl.java (revision 61)
+++ /v2/trunk/de.ugoe.cs.swe.bnftools.ebnf/src-gen/de/ugoe/cs/swe/bnftools/ebnf/impl/RepeatedSequenceImpl.java (revision 61)
@@ -0,0 +1,240 @@
+/**
+ */
+package de.ugoe.cs.swe.bnftools.ebnf.impl;
+
+import de.ugoe.cs.swe.bnftools.ebnf.DefinitionList;
+import de.ugoe.cs.swe.bnftools.ebnf.EbnfPackage;
+import de.ugoe.cs.swe.bnftools.ebnf.RepeatedSequence;
+
+import java.util.Collection;
+
+import org.eclipse.emf.common.notify.Notification;
+import org.eclipse.emf.common.notify.NotificationChain;
+
+import org.eclipse.emf.common.util.EList;
+
+import org.eclipse.emf.ecore.EClass;
+import org.eclipse.emf.ecore.InternalEObject;
+
+import org.eclipse.emf.ecore.impl.ENotificationImpl;
+import org.eclipse.emf.ecore.impl.MinimalEObjectImpl;
+
+import org.eclipse.emf.ecore.util.EObjectContainmentEList;
+import org.eclipse.emf.ecore.util.InternalEList;
+
+/**
+ *
+ * An implementation of the model object 'Repeated Sequence'.
+ *
+ *
+ * The following features are implemented:
+ *
+ * - {@link de.ugoe.cs.swe.bnftools.ebnf.impl.RepeatedSequenceImpl#getDefinitions Definitions}
+ * - {@link de.ugoe.cs.swe.bnftools.ebnf.impl.RepeatedSequenceImpl#isMorethanonce Morethanonce}
+ *
+ *
+ *
+ * @generated
+ */
+public class RepeatedSequenceImpl extends MinimalEObjectImpl.Container implements RepeatedSequence
+{
+ /**
+ * The cached value of the '{@link #getDefinitions() Definitions}' containment reference list.
+ *
+ *
+ * @see #getDefinitions()
+ * @generated
+ * @ordered
+ */
+ protected EList definitions;
+
+ /**
+ * The default value of the '{@link #isMorethanonce() Morethanonce}' attribute.
+ *
+ *
+ * @see #isMorethanonce()
+ * @generated
+ * @ordered
+ */
+ protected static final boolean MORETHANONCE_EDEFAULT = false;
+
+ /**
+ * The cached value of the '{@link #isMorethanonce() Morethanonce}' attribute.
+ *
+ *
+ * @see #isMorethanonce()
+ * @generated
+ * @ordered
+ */
+ protected boolean morethanonce = MORETHANONCE_EDEFAULT;
+
+ /**
+ *
+ *
+ * @generated
+ */
+ protected RepeatedSequenceImpl()
+ {
+ super();
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ @Override
+ protected EClass eStaticClass()
+ {
+ return EbnfPackage.Literals.REPEATED_SEQUENCE;
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ public EList getDefinitions()
+ {
+ if (definitions == null)
+ {
+ definitions = new EObjectContainmentEList(DefinitionList.class, this, EbnfPackage.REPEATED_SEQUENCE__DEFINITIONS);
+ }
+ return definitions;
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ public boolean isMorethanonce()
+ {
+ return morethanonce;
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ public void setMorethanonce(boolean newMorethanonce)
+ {
+ boolean oldMorethanonce = morethanonce;
+ morethanonce = newMorethanonce;
+ if (eNotificationRequired())
+ eNotify(new ENotificationImpl(this, Notification.SET, EbnfPackage.REPEATED_SEQUENCE__MORETHANONCE, oldMorethanonce, morethanonce));
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ @Override
+ public NotificationChain eInverseRemove(InternalEObject otherEnd, int featureID, NotificationChain msgs)
+ {
+ switch (featureID)
+ {
+ case EbnfPackage.REPEATED_SEQUENCE__DEFINITIONS:
+ return ((InternalEList)getDefinitions()).basicRemove(otherEnd, msgs);
+ }
+ return super.eInverseRemove(otherEnd, featureID, msgs);
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ @Override
+ public Object eGet(int featureID, boolean resolve, boolean coreType)
+ {
+ switch (featureID)
+ {
+ case EbnfPackage.REPEATED_SEQUENCE__DEFINITIONS:
+ return getDefinitions();
+ case EbnfPackage.REPEATED_SEQUENCE__MORETHANONCE:
+ return isMorethanonce();
+ }
+ return super.eGet(featureID, resolve, coreType);
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ @SuppressWarnings("unchecked")
+ @Override
+ public void eSet(int featureID, Object newValue)
+ {
+ switch (featureID)
+ {
+ case EbnfPackage.REPEATED_SEQUENCE__DEFINITIONS:
+ getDefinitions().clear();
+ getDefinitions().addAll((Collection)newValue);
+ return;
+ case EbnfPackage.REPEATED_SEQUENCE__MORETHANONCE:
+ setMorethanonce((Boolean)newValue);
+ return;
+ }
+ super.eSet(featureID, newValue);
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ @Override
+ public void eUnset(int featureID)
+ {
+ switch (featureID)
+ {
+ case EbnfPackage.REPEATED_SEQUENCE__DEFINITIONS:
+ getDefinitions().clear();
+ return;
+ case EbnfPackage.REPEATED_SEQUENCE__MORETHANONCE:
+ setMorethanonce(MORETHANONCE_EDEFAULT);
+ return;
+ }
+ super.eUnset(featureID);
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ @Override
+ public boolean eIsSet(int featureID)
+ {
+ switch (featureID)
+ {
+ case EbnfPackage.REPEATED_SEQUENCE__DEFINITIONS:
+ return definitions != null && !definitions.isEmpty();
+ case EbnfPackage.REPEATED_SEQUENCE__MORETHANONCE:
+ return morethanonce != MORETHANONCE_EDEFAULT;
+ }
+ return super.eIsSet(featureID);
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ @Override
+ public String toString()
+ {
+ if (eIsProxy()) return super.toString();
+
+ StringBuffer result = new StringBuffer(super.toString());
+ result.append(" (morethanonce: ");
+ result.append(morethanonce);
+ result.append(')');
+ return result.toString();
+ }
+
+} //RepeatedSequenceImpl
Index: /v2/trunk/de.ugoe.cs.swe.bnftools.ebnf/src-gen/de/ugoe/cs/swe/bnftools/ebnf/impl/RuleCombinatorImpl.java
===================================================================
--- /v2/trunk/de.ugoe.cs.swe.bnftools.ebnf/src-gen/de/ugoe/cs/swe/bnftools/ebnf/impl/RuleCombinatorImpl.java (revision 61)
+++ /v2/trunk/de.ugoe.cs.swe.bnftools.ebnf/src-gen/de/ugoe/cs/swe/bnftools/ebnf/impl/RuleCombinatorImpl.java (revision 61)
@@ -0,0 +1,221 @@
+/**
+ */
+package de.ugoe.cs.swe.bnftools.ebnf.impl;
+
+import de.ugoe.cs.swe.bnftools.ebnf.EbnfPackage;
+import de.ugoe.cs.swe.bnftools.ebnf.RuleCombinator;
+
+import java.util.Collection;
+
+import org.eclipse.emf.common.notify.Notification;
+
+import org.eclipse.emf.common.util.EList;
+
+import org.eclipse.emf.ecore.EClass;
+
+import org.eclipse.emf.ecore.impl.ENotificationImpl;
+
+import org.eclipse.emf.ecore.util.EDataTypeEList;
+
+/**
+ *
+ * An implementation of the model object 'Rule Combinator'.
+ *
+ *
+ * The following features are implemented:
+ *
+ * - {@link de.ugoe.cs.swe.bnftools.ebnf.impl.RuleCombinatorImpl#getName Name}
+ * - {@link de.ugoe.cs.swe.bnftools.ebnf.impl.RuleCombinatorImpl#getLABEL LABEL}
+ *
+ *
+ *
+ * @generated
+ */
+public class RuleCombinatorImpl extends MergeRuleImpl implements RuleCombinator
+{
+ /**
+ * The default value of the '{@link #getName() Name}' attribute.
+ *
+ *
+ * @see #getName()
+ * @generated
+ * @ordered
+ */
+ protected static final String NAME_EDEFAULT = null;
+
+ /**
+ * The cached value of the '{@link #getName() Name}' attribute.
+ *
+ *
+ * @see #getName()
+ * @generated
+ * @ordered
+ */
+ protected String name = NAME_EDEFAULT;
+
+ /**
+ * The cached value of the '{@link #getLABEL() LABEL}' attribute list.
+ *
+ *
+ * @see #getLABEL()
+ * @generated
+ * @ordered
+ */
+ protected EList label;
+
+ /**
+ *
+ *
+ * @generated
+ */
+ protected RuleCombinatorImpl()
+ {
+ super();
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ @Override
+ protected EClass eStaticClass()
+ {
+ return EbnfPackage.Literals.RULE_COMBINATOR;
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ public String getName()
+ {
+ return name;
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ public void setName(String newName)
+ {
+ String oldName = name;
+ name = newName;
+ if (eNotificationRequired())
+ eNotify(new ENotificationImpl(this, Notification.SET, EbnfPackage.RULE_COMBINATOR__NAME, oldName, name));
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ public EList getLABEL()
+ {
+ if (label == null)
+ {
+ label = new EDataTypeEList(String.class, this, EbnfPackage.RULE_COMBINATOR__LABEL);
+ }
+ return label;
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ @Override
+ public Object eGet(int featureID, boolean resolve, boolean coreType)
+ {
+ switch (featureID)
+ {
+ case EbnfPackage.RULE_COMBINATOR__NAME:
+ return getName();
+ case EbnfPackage.RULE_COMBINATOR__LABEL:
+ return getLABEL();
+ }
+ return super.eGet(featureID, resolve, coreType);
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ @SuppressWarnings("unchecked")
+ @Override
+ public void eSet(int featureID, Object newValue)
+ {
+ switch (featureID)
+ {
+ case EbnfPackage.RULE_COMBINATOR__NAME:
+ setName((String)newValue);
+ return;
+ case EbnfPackage.RULE_COMBINATOR__LABEL:
+ getLABEL().clear();
+ getLABEL().addAll((Collection)newValue);
+ return;
+ }
+ super.eSet(featureID, newValue);
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ @Override
+ public void eUnset(int featureID)
+ {
+ switch (featureID)
+ {
+ case EbnfPackage.RULE_COMBINATOR__NAME:
+ setName(NAME_EDEFAULT);
+ return;
+ case EbnfPackage.RULE_COMBINATOR__LABEL:
+ getLABEL().clear();
+ return;
+ }
+ super.eUnset(featureID);
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ @Override
+ public boolean eIsSet(int featureID)
+ {
+ switch (featureID)
+ {
+ case EbnfPackage.RULE_COMBINATOR__NAME:
+ return NAME_EDEFAULT == null ? name != null : !NAME_EDEFAULT.equals(name);
+ case EbnfPackage.RULE_COMBINATOR__LABEL:
+ return label != null && !label.isEmpty();
+ }
+ return super.eIsSet(featureID);
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ @Override
+ public String toString()
+ {
+ if (eIsProxy()) return super.toString();
+
+ StringBuffer result = new StringBuffer(super.toString());
+ result.append(" (name: ");
+ result.append(name);
+ result.append(", LABEL: ");
+ result.append(label);
+ result.append(')');
+ return result.toString();
+ }
+
+} //RuleCombinatorImpl
Index: /v2/trunk/de.ugoe.cs.swe.bnftools.ebnf/src-gen/de/ugoe/cs/swe/bnftools/ebnf/impl/RuleImpl.java
===================================================================
--- /v2/trunk/de.ugoe.cs.swe.bnftools.ebnf/src-gen/de/ugoe/cs/swe/bnftools/ebnf/impl/RuleImpl.java (revision 61)
+++ /v2/trunk/de.ugoe.cs.swe.bnftools.ebnf/src-gen/de/ugoe/cs/swe/bnftools/ebnf/impl/RuleImpl.java (revision 61)
@@ -0,0 +1,377 @@
+/**
+ */
+package de.ugoe.cs.swe.bnftools.ebnf.impl;
+
+import de.ugoe.cs.swe.bnftools.ebnf.DefinitionList;
+import de.ugoe.cs.swe.bnftools.ebnf.EbnfPackage;
+import de.ugoe.cs.swe.bnftools.ebnf.Rule;
+
+import org.eclipse.emf.common.notify.Notification;
+import org.eclipse.emf.common.notify.NotificationChain;
+
+import org.eclipse.emf.ecore.EClass;
+import org.eclipse.emf.ecore.InternalEObject;
+
+import org.eclipse.emf.ecore.impl.ENotificationImpl;
+import org.eclipse.emf.ecore.impl.MinimalEObjectImpl;
+
+/**
+ *
+ * An implementation of the model object 'Rule'.
+ *
+ *
+ * The following features are implemented:
+ *
+ * - {@link de.ugoe.cs.swe.bnftools.ebnf.impl.RuleImpl#getRulenumber Rulenumber}
+ * - {@link de.ugoe.cs.swe.bnftools.ebnf.impl.RuleImpl#getRulevariant Rulevariant}
+ * - {@link de.ugoe.cs.swe.bnftools.ebnf.impl.RuleImpl#getName Name}
+ * - {@link de.ugoe.cs.swe.bnftools.ebnf.impl.RuleImpl#getDefinitionList Definition List}
+ *
+ *
+ *
+ * @generated
+ */
+public class RuleImpl extends MinimalEObjectImpl.Container implements Rule
+{
+ /**
+ * The default value of the '{@link #getRulenumber() Rulenumber}' attribute.
+ *
+ *
+ * @see #getRulenumber()
+ * @generated
+ * @ordered
+ */
+ protected static final int RULENUMBER_EDEFAULT = 0;
+
+ /**
+ * The cached value of the '{@link #getRulenumber() Rulenumber}' attribute.
+ *
+ *
+ * @see #getRulenumber()
+ * @generated
+ * @ordered
+ */
+ protected int rulenumber = RULENUMBER_EDEFAULT;
+
+ /**
+ * The default value of the '{@link #getRulevariant() Rulevariant}' attribute.
+ *
+ *
+ * @see #getRulevariant()
+ * @generated
+ * @ordered
+ */
+ protected static final String RULEVARIANT_EDEFAULT = null;
+
+ /**
+ * The cached value of the '{@link #getRulevariant() Rulevariant}' attribute.
+ *
+ *
+ * @see #getRulevariant()
+ * @generated
+ * @ordered
+ */
+ protected String rulevariant = RULEVARIANT_EDEFAULT;
+
+ /**
+ * The default value of the '{@link #getName() Name}' attribute.
+ *
+ *
+ * @see #getName()
+ * @generated
+ * @ordered
+ */
+ protected static final String NAME_EDEFAULT = null;
+
+ /**
+ * The cached value of the '{@link #getName() Name}' attribute.
+ *
+ *
+ * @see #getName()
+ * @generated
+ * @ordered
+ */
+ protected String name = NAME_EDEFAULT;
+
+ /**
+ * The cached value of the '{@link #getDefinitionList() Definition List}' containment reference.
+ *
+ *
+ * @see #getDefinitionList()
+ * @generated
+ * @ordered
+ */
+ protected DefinitionList definitionList;
+
+ /**
+ *
+ *
+ * @generated
+ */
+ protected RuleImpl()
+ {
+ super();
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ @Override
+ protected EClass eStaticClass()
+ {
+ return EbnfPackage.Literals.RULE;
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ public int getRulenumber()
+ {
+ return rulenumber;
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ public void setRulenumber(int newRulenumber)
+ {
+ int oldRulenumber = rulenumber;
+ rulenumber = newRulenumber;
+ if (eNotificationRequired())
+ eNotify(new ENotificationImpl(this, Notification.SET, EbnfPackage.RULE__RULENUMBER, oldRulenumber, rulenumber));
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ public String getRulevariant()
+ {
+ return rulevariant;
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ public void setRulevariant(String newRulevariant)
+ {
+ String oldRulevariant = rulevariant;
+ rulevariant = newRulevariant;
+ if (eNotificationRequired())
+ eNotify(new ENotificationImpl(this, Notification.SET, EbnfPackage.RULE__RULEVARIANT, oldRulevariant, rulevariant));
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ public String getName()
+ {
+ return name;
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ public void setName(String newName)
+ {
+ String oldName = name;
+ name = newName;
+ if (eNotificationRequired())
+ eNotify(new ENotificationImpl(this, Notification.SET, EbnfPackage.RULE__NAME, oldName, name));
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ public DefinitionList getDefinitionList()
+ {
+ return definitionList;
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ public NotificationChain basicSetDefinitionList(DefinitionList newDefinitionList, NotificationChain msgs)
+ {
+ DefinitionList oldDefinitionList = definitionList;
+ definitionList = newDefinitionList;
+ if (eNotificationRequired())
+ {
+ ENotificationImpl notification = new ENotificationImpl(this, Notification.SET, EbnfPackage.RULE__DEFINITION_LIST, oldDefinitionList, newDefinitionList);
+ if (msgs == null) msgs = notification; else msgs.add(notification);
+ }
+ return msgs;
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ public void setDefinitionList(DefinitionList newDefinitionList)
+ {
+ if (newDefinitionList != definitionList)
+ {
+ NotificationChain msgs = null;
+ if (definitionList != null)
+ msgs = ((InternalEObject)definitionList).eInverseRemove(this, EOPPOSITE_FEATURE_BASE - EbnfPackage.RULE__DEFINITION_LIST, null, msgs);
+ if (newDefinitionList != null)
+ msgs = ((InternalEObject)newDefinitionList).eInverseAdd(this, EOPPOSITE_FEATURE_BASE - EbnfPackage.RULE__DEFINITION_LIST, null, msgs);
+ msgs = basicSetDefinitionList(newDefinitionList, msgs);
+ if (msgs != null) msgs.dispatch();
+ }
+ else if (eNotificationRequired())
+ eNotify(new ENotificationImpl(this, Notification.SET, EbnfPackage.RULE__DEFINITION_LIST, newDefinitionList, newDefinitionList));
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ @Override
+ public NotificationChain eInverseRemove(InternalEObject otherEnd, int featureID, NotificationChain msgs)
+ {
+ switch (featureID)
+ {
+ case EbnfPackage.RULE__DEFINITION_LIST:
+ return basicSetDefinitionList(null, msgs);
+ }
+ return super.eInverseRemove(otherEnd, featureID, msgs);
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ @Override
+ public Object eGet(int featureID, boolean resolve, boolean coreType)
+ {
+ switch (featureID)
+ {
+ case EbnfPackage.RULE__RULENUMBER:
+ return getRulenumber();
+ case EbnfPackage.RULE__RULEVARIANT:
+ return getRulevariant();
+ case EbnfPackage.RULE__NAME:
+ return getName();
+ case EbnfPackage.RULE__DEFINITION_LIST:
+ return getDefinitionList();
+ }
+ return super.eGet(featureID, resolve, coreType);
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ @Override
+ public void eSet(int featureID, Object newValue)
+ {
+ switch (featureID)
+ {
+ case EbnfPackage.RULE__RULENUMBER:
+ setRulenumber((Integer)newValue);
+ return;
+ case EbnfPackage.RULE__RULEVARIANT:
+ setRulevariant((String)newValue);
+ return;
+ case EbnfPackage.RULE__NAME:
+ setName((String)newValue);
+ return;
+ case EbnfPackage.RULE__DEFINITION_LIST:
+ setDefinitionList((DefinitionList)newValue);
+ return;
+ }
+ super.eSet(featureID, newValue);
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ @Override
+ public void eUnset(int featureID)
+ {
+ switch (featureID)
+ {
+ case EbnfPackage.RULE__RULENUMBER:
+ setRulenumber(RULENUMBER_EDEFAULT);
+ return;
+ case EbnfPackage.RULE__RULEVARIANT:
+ setRulevariant(RULEVARIANT_EDEFAULT);
+ return;
+ case EbnfPackage.RULE__NAME:
+ setName(NAME_EDEFAULT);
+ return;
+ case EbnfPackage.RULE__DEFINITION_LIST:
+ setDefinitionList((DefinitionList)null);
+ return;
+ }
+ super.eUnset(featureID);
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ @Override
+ public boolean eIsSet(int featureID)
+ {
+ switch (featureID)
+ {
+ case EbnfPackage.RULE__RULENUMBER:
+ return rulenumber != RULENUMBER_EDEFAULT;
+ case EbnfPackage.RULE__RULEVARIANT:
+ return RULEVARIANT_EDEFAULT == null ? rulevariant != null : !RULEVARIANT_EDEFAULT.equals(rulevariant);
+ case EbnfPackage.RULE__NAME:
+ return NAME_EDEFAULT == null ? name != null : !NAME_EDEFAULT.equals(name);
+ case EbnfPackage.RULE__DEFINITION_LIST:
+ return definitionList != null;
+ }
+ return super.eIsSet(featureID);
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ @Override
+ public String toString()
+ {
+ if (eIsProxy()) return super.toString();
+
+ StringBuffer result = new StringBuffer(super.toString());
+ result.append(" (rulenumber: ");
+ result.append(rulenumber);
+ result.append(", rulevariant: ");
+ result.append(rulevariant);
+ result.append(", name: ");
+ result.append(name);
+ result.append(')');
+ return result.toString();
+ }
+
+} //RuleImpl
Index: /v2/trunk/de.ugoe.cs.swe.bnftools.ebnf/src-gen/de/ugoe/cs/swe/bnftools/ebnf/impl/RuleReferenceImpl.java
===================================================================
--- /v2/trunk/de.ugoe.cs.swe.bnftools.ebnf/src-gen/de/ugoe/cs/swe/bnftools/ebnf/impl/RuleReferenceImpl.java (revision 61)
+++ /v2/trunk/de.ugoe.cs.swe.bnftools.ebnf/src-gen/de/ugoe/cs/swe/bnftools/ebnf/impl/RuleReferenceImpl.java (revision 61)
@@ -0,0 +1,173 @@
+/**
+ */
+package de.ugoe.cs.swe.bnftools.ebnf.impl;
+
+import de.ugoe.cs.swe.bnftools.ebnf.EbnfPackage;
+import de.ugoe.cs.swe.bnftools.ebnf.Rule;
+import de.ugoe.cs.swe.bnftools.ebnf.RuleReference;
+
+import org.eclipse.emf.common.notify.Notification;
+
+import org.eclipse.emf.ecore.EClass;
+import org.eclipse.emf.ecore.InternalEObject;
+
+import org.eclipse.emf.ecore.impl.ENotificationImpl;
+import org.eclipse.emf.ecore.impl.MinimalEObjectImpl;
+
+/**
+ *
+ * An implementation of the model object 'Rule Reference'.
+ *
+ *
+ * The following features are implemented:
+ *
+ * - {@link de.ugoe.cs.swe.bnftools.ebnf.impl.RuleReferenceImpl#getRuleref Ruleref}
+ *
+ *
+ *
+ * @generated
+ */
+public class RuleReferenceImpl extends MinimalEObjectImpl.Container implements RuleReference
+{
+ /**
+ * The cached value of the '{@link #getRuleref() Ruleref}' reference.
+ *
+ *
+ * @see #getRuleref()
+ * @generated
+ * @ordered
+ */
+ protected Rule ruleref;
+
+ /**
+ *
+ *
+ * @generated
+ */
+ protected RuleReferenceImpl()
+ {
+ super();
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ @Override
+ protected EClass eStaticClass()
+ {
+ return EbnfPackage.Literals.RULE_REFERENCE;
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ public Rule getRuleref()
+ {
+ if (ruleref != null && ruleref.eIsProxy())
+ {
+ InternalEObject oldRuleref = (InternalEObject)ruleref;
+ ruleref = (Rule)eResolveProxy(oldRuleref);
+ if (ruleref != oldRuleref)
+ {
+ if (eNotificationRequired())
+ eNotify(new ENotificationImpl(this, Notification.RESOLVE, EbnfPackage.RULE_REFERENCE__RULEREF, oldRuleref, ruleref));
+ }
+ }
+ return ruleref;
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ public Rule basicGetRuleref()
+ {
+ return ruleref;
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ public void setRuleref(Rule newRuleref)
+ {
+ Rule oldRuleref = ruleref;
+ ruleref = newRuleref;
+ if (eNotificationRequired())
+ eNotify(new ENotificationImpl(this, Notification.SET, EbnfPackage.RULE_REFERENCE__RULEREF, oldRuleref, ruleref));
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ @Override
+ public Object eGet(int featureID, boolean resolve, boolean coreType)
+ {
+ switch (featureID)
+ {
+ case EbnfPackage.RULE_REFERENCE__RULEREF:
+ if (resolve) return getRuleref();
+ return basicGetRuleref();
+ }
+ return super.eGet(featureID, resolve, coreType);
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ @Override
+ public void eSet(int featureID, Object newValue)
+ {
+ switch (featureID)
+ {
+ case EbnfPackage.RULE_REFERENCE__RULEREF:
+ setRuleref((Rule)newValue);
+ return;
+ }
+ super.eSet(featureID, newValue);
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ @Override
+ public void eUnset(int featureID)
+ {
+ switch (featureID)
+ {
+ case EbnfPackage.RULE_REFERENCE__RULEREF:
+ setRuleref((Rule)null);
+ return;
+ }
+ super.eUnset(featureID);
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ @Override
+ public boolean eIsSet(int featureID)
+ {
+ switch (featureID)
+ {
+ case EbnfPackage.RULE_REFERENCE__RULEREF:
+ return ruleref != null;
+ }
+ return super.eIsSet(featureID);
+ }
+
+} //RuleReferenceImpl
Index: /v2/trunk/de.ugoe.cs.swe.bnftools.ebnf/src-gen/de/ugoe/cs/swe/bnftools/ebnf/impl/SectionHeadingImpl.java
===================================================================
--- /v2/trunk/de.ugoe.cs.swe.bnftools.ebnf/src-gen/de/ugoe/cs/swe/bnftools/ebnf/impl/SectionHeadingImpl.java (revision 61)
+++ /v2/trunk/de.ugoe.cs.swe.bnftools.ebnf/src-gen/de/ugoe/cs/swe/bnftools/ebnf/impl/SectionHeadingImpl.java (revision 61)
@@ -0,0 +1,177 @@
+/**
+ */
+package de.ugoe.cs.swe.bnftools.ebnf.impl;
+
+import de.ugoe.cs.swe.bnftools.ebnf.EbnfPackage;
+import de.ugoe.cs.swe.bnftools.ebnf.SectionHeading;
+
+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;
+
+/**
+ *
+ * An implementation of the model object 'Section Heading'.
+ *
+ *
+ * The following features are implemented:
+ *
+ * - {@link de.ugoe.cs.swe.bnftools.ebnf.impl.SectionHeadingImpl#getSectionHeader Section Header}
+ *
+ *
+ *
+ * @generated
+ */
+public class SectionHeadingImpl extends MinimalEObjectImpl.Container implements SectionHeading
+{
+ /**
+ * The default value of the '{@link #getSectionHeader() Section Header}' attribute.
+ *
+ *
+ * @see #getSectionHeader()
+ * @generated
+ * @ordered
+ */
+ protected static final String SECTION_HEADER_EDEFAULT = null;
+
+ /**
+ * The cached value of the '{@link #getSectionHeader() Section Header}' attribute.
+ *
+ *
+ * @see #getSectionHeader()
+ * @generated
+ * @ordered
+ */
+ protected String sectionHeader = SECTION_HEADER_EDEFAULT;
+
+ /**
+ *
+ *
+ * @generated
+ */
+ protected SectionHeadingImpl()
+ {
+ super();
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ @Override
+ protected EClass eStaticClass()
+ {
+ return EbnfPackage.Literals.SECTION_HEADING;
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ public String getSectionHeader()
+ {
+ return sectionHeader;
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ public void setSectionHeader(String newSectionHeader)
+ {
+ String oldSectionHeader = sectionHeader;
+ sectionHeader = newSectionHeader;
+ if (eNotificationRequired())
+ eNotify(new ENotificationImpl(this, Notification.SET, EbnfPackage.SECTION_HEADING__SECTION_HEADER, oldSectionHeader, sectionHeader));
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ @Override
+ public Object eGet(int featureID, boolean resolve, boolean coreType)
+ {
+ switch (featureID)
+ {
+ case EbnfPackage.SECTION_HEADING__SECTION_HEADER:
+ return getSectionHeader();
+ }
+ return super.eGet(featureID, resolve, coreType);
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ @Override
+ public void eSet(int featureID, Object newValue)
+ {
+ switch (featureID)
+ {
+ case EbnfPackage.SECTION_HEADING__SECTION_HEADER:
+ setSectionHeader((String)newValue);
+ return;
+ }
+ super.eSet(featureID, newValue);
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ @Override
+ public void eUnset(int featureID)
+ {
+ switch (featureID)
+ {
+ case EbnfPackage.SECTION_HEADING__SECTION_HEADER:
+ setSectionHeader(SECTION_HEADER_EDEFAULT);
+ return;
+ }
+ super.eUnset(featureID);
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ @Override
+ public boolean eIsSet(int featureID)
+ {
+ switch (featureID)
+ {
+ case EbnfPackage.SECTION_HEADING__SECTION_HEADER:
+ return SECTION_HEADER_EDEFAULT == null ? sectionHeader != null : !SECTION_HEADER_EDEFAULT.equals(sectionHeader);
+ }
+ return super.eIsSet(featureID);
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ @Override
+ public String toString()
+ {
+ if (eIsProxy()) return super.toString();
+
+ StringBuffer result = new StringBuffer(super.toString());
+ result.append(" (sectionHeader: ");
+ result.append(sectionHeader);
+ result.append(')');
+ return result.toString();
+ }
+
+} //SectionHeadingImpl
Index: /v2/trunk/de.ugoe.cs.swe.bnftools.ebnf/src-gen/de/ugoe/cs/swe/bnftools/ebnf/impl/SingleDefinitionImpl.java
===================================================================
--- /v2/trunk/de.ugoe.cs.swe.bnftools.ebnf/src-gen/de/ugoe/cs/swe/bnftools/ebnf/impl/SingleDefinitionImpl.java (revision 61)
+++ /v2/trunk/de.ugoe.cs.swe.bnftools.ebnf/src-gen/de/ugoe/cs/swe/bnftools/ebnf/impl/SingleDefinitionImpl.java (revision 61)
@@ -0,0 +1,167 @@
+/**
+ */
+package de.ugoe.cs.swe.bnftools.ebnf.impl;
+
+import de.ugoe.cs.swe.bnftools.ebnf.EbnfPackage;
+import de.ugoe.cs.swe.bnftools.ebnf.SingleDefinition;
+import de.ugoe.cs.swe.bnftools.ebnf.Term;
+
+import java.util.Collection;
+
+import org.eclipse.emf.common.notify.NotificationChain;
+
+import org.eclipse.emf.common.util.EList;
+
+import org.eclipse.emf.ecore.EClass;
+import org.eclipse.emf.ecore.InternalEObject;
+
+import org.eclipse.emf.ecore.impl.MinimalEObjectImpl;
+
+import org.eclipse.emf.ecore.util.EObjectContainmentEList;
+import org.eclipse.emf.ecore.util.InternalEList;
+
+/**
+ *
+ * An implementation of the model object 'Single Definition'.
+ *
+ *
+ * The following features are implemented:
+ *
+ * - {@link de.ugoe.cs.swe.bnftools.ebnf.impl.SingleDefinitionImpl#getTerms Terms}
+ *
+ *
+ *
+ * @generated
+ */
+public class SingleDefinitionImpl extends MinimalEObjectImpl.Container implements SingleDefinition
+{
+ /**
+ * The cached value of the '{@link #getTerms() Terms}' containment reference list.
+ *
+ *
+ * @see #getTerms()
+ * @generated
+ * @ordered
+ */
+ protected EList terms;
+
+ /**
+ *
+ *
+ * @generated
+ */
+ protected SingleDefinitionImpl()
+ {
+ super();
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ @Override
+ protected EClass eStaticClass()
+ {
+ return EbnfPackage.Literals.SINGLE_DEFINITION;
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ public EList getTerms()
+ {
+ if (terms == null)
+ {
+ terms = new EObjectContainmentEList(Term.class, this, EbnfPackage.SINGLE_DEFINITION__TERMS);
+ }
+ return terms;
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ @Override
+ public NotificationChain eInverseRemove(InternalEObject otherEnd, int featureID, NotificationChain msgs)
+ {
+ switch (featureID)
+ {
+ case EbnfPackage.SINGLE_DEFINITION__TERMS:
+ return ((InternalEList)getTerms()).basicRemove(otherEnd, msgs);
+ }
+ return super.eInverseRemove(otherEnd, featureID, msgs);
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ @Override
+ public Object eGet(int featureID, boolean resolve, boolean coreType)
+ {
+ switch (featureID)
+ {
+ case EbnfPackage.SINGLE_DEFINITION__TERMS:
+ return getTerms();
+ }
+ return super.eGet(featureID, resolve, coreType);
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ @SuppressWarnings("unchecked")
+ @Override
+ public void eSet(int featureID, Object newValue)
+ {
+ switch (featureID)
+ {
+ case EbnfPackage.SINGLE_DEFINITION__TERMS:
+ getTerms().clear();
+ getTerms().addAll((Collection)newValue);
+ return;
+ }
+ super.eSet(featureID, newValue);
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ @Override
+ public void eUnset(int featureID)
+ {
+ switch (featureID)
+ {
+ case EbnfPackage.SINGLE_DEFINITION__TERMS:
+ getTerms().clear();
+ return;
+ }
+ super.eUnset(featureID);
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ @Override
+ public boolean eIsSet(int featureID)
+ {
+ switch (featureID)
+ {
+ case EbnfPackage.SINGLE_DEFINITION__TERMS:
+ return terms != null && !terms.isEmpty();
+ }
+ return super.eIsSet(featureID);
+ }
+
+} //SingleDefinitionImpl
Index: /v2/trunk/de.ugoe.cs.swe.bnftools.ebnf/src-gen/de/ugoe/cs/swe/bnftools/ebnf/impl/StringRuleImpl.java
===================================================================
--- /v2/trunk/de.ugoe.cs.swe.bnftools.ebnf/src-gen/de/ugoe/cs/swe/bnftools/ebnf/impl/StringRuleImpl.java (revision 61)
+++ /v2/trunk/de.ugoe.cs.swe.bnftools.ebnf/src-gen/de/ugoe/cs/swe/bnftools/ebnf/impl/StringRuleImpl.java (revision 61)
@@ -0,0 +1,233 @@
+/**
+ */
+package de.ugoe.cs.swe.bnftools.ebnf.impl;
+
+import de.ugoe.cs.swe.bnftools.ebnf.EbnfPackage;
+import de.ugoe.cs.swe.bnftools.ebnf.StringRule;
+
+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;
+
+/**
+ *
+ * An implementation of the model object 'String Rule'.
+ *
+ *
+ * The following features are implemented:
+ *
+ * - {@link de.ugoe.cs.swe.bnftools.ebnf.impl.StringRuleImpl#getLiteral Literal}
+ * - {@link de.ugoe.cs.swe.bnftools.ebnf.impl.StringRuleImpl#getColon Colon}
+ *
+ *
+ *
+ * @generated
+ */
+public class StringRuleImpl extends MinimalEObjectImpl.Container implements StringRule
+{
+ /**
+ * The default value of the '{@link #getLiteral() Literal}' attribute.
+ *
+ *
+ * @see #getLiteral()
+ * @generated
+ * @ordered
+ */
+ protected static final String LITERAL_EDEFAULT = null;
+
+ /**
+ * The cached value of the '{@link #getLiteral() Literal}' attribute.
+ *
+ *
+ * @see #getLiteral()
+ * @generated
+ * @ordered
+ */
+ protected String literal = LITERAL_EDEFAULT;
+
+ /**
+ * The default value of the '{@link #getColon() Colon}' attribute.
+ *
+ *
+ * @see #getColon()
+ * @generated
+ * @ordered
+ */
+ protected static final String COLON_EDEFAULT = null;
+
+ /**
+ * The cached value of the '{@link #getColon() Colon}' attribute.
+ *
+ *
+ * @see #getColon()
+ * @generated
+ * @ordered
+ */
+ protected String colon = COLON_EDEFAULT;
+
+ /**
+ *
+ *
+ * @generated
+ */
+ protected StringRuleImpl()
+ {
+ super();
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ @Override
+ protected EClass eStaticClass()
+ {
+ return EbnfPackage.Literals.STRING_RULE;
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ public String getLiteral()
+ {
+ return literal;
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ public void setLiteral(String newLiteral)
+ {
+ String oldLiteral = literal;
+ literal = newLiteral;
+ if (eNotificationRequired())
+ eNotify(new ENotificationImpl(this, Notification.SET, EbnfPackage.STRING_RULE__LITERAL, oldLiteral, literal));
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ public String getColon()
+ {
+ return colon;
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ public void setColon(String newColon)
+ {
+ String oldColon = colon;
+ colon = newColon;
+ if (eNotificationRequired())
+ eNotify(new ENotificationImpl(this, Notification.SET, EbnfPackage.STRING_RULE__COLON, oldColon, colon));
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ @Override
+ public Object eGet(int featureID, boolean resolve, boolean coreType)
+ {
+ switch (featureID)
+ {
+ case EbnfPackage.STRING_RULE__LITERAL:
+ return getLiteral();
+ case EbnfPackage.STRING_RULE__COLON:
+ return getColon();
+ }
+ return super.eGet(featureID, resolve, coreType);
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ @Override
+ public void eSet(int featureID, Object newValue)
+ {
+ switch (featureID)
+ {
+ case EbnfPackage.STRING_RULE__LITERAL:
+ setLiteral((String)newValue);
+ return;
+ case EbnfPackage.STRING_RULE__COLON:
+ setColon((String)newValue);
+ return;
+ }
+ super.eSet(featureID, newValue);
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ @Override
+ public void eUnset(int featureID)
+ {
+ switch (featureID)
+ {
+ case EbnfPackage.STRING_RULE__LITERAL:
+ setLiteral(LITERAL_EDEFAULT);
+ return;
+ case EbnfPackage.STRING_RULE__COLON:
+ setColon(COLON_EDEFAULT);
+ return;
+ }
+ super.eUnset(featureID);
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ @Override
+ public boolean eIsSet(int featureID)
+ {
+ switch (featureID)
+ {
+ case EbnfPackage.STRING_RULE__LITERAL:
+ return LITERAL_EDEFAULT == null ? literal != null : !LITERAL_EDEFAULT.equals(literal);
+ case EbnfPackage.STRING_RULE__COLON:
+ return COLON_EDEFAULT == null ? colon != null : !COLON_EDEFAULT.equals(colon);
+ }
+ return super.eIsSet(featureID);
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ @Override
+ public String toString()
+ {
+ if (eIsProxy()) return super.toString();
+
+ StringBuffer result = new StringBuffer(super.toString());
+ result.append(" (literal: ");
+ result.append(literal);
+ result.append(", colon: ");
+ result.append(colon);
+ result.append(')');
+ return result.toString();
+ }
+
+} //StringRuleImpl
Index: /v2/trunk/de.ugoe.cs.swe.bnftools.ebnf/src-gen/de/ugoe/cs/swe/bnftools/ebnf/impl/TermImpl.java
===================================================================
--- /v2/trunk/de.ugoe.cs.swe.bnftools.ebnf/src-gen/de/ugoe/cs/swe/bnftools/ebnf/impl/TermImpl.java (revision 61)
+++ /v2/trunk/de.ugoe.cs.swe.bnftools.ebnf/src-gen/de/ugoe/cs/swe/bnftools/ebnf/impl/TermImpl.java (revision 61)
@@ -0,0 +1,410 @@
+/**
+ */
+package de.ugoe.cs.swe.bnftools.ebnf.impl;
+
+import de.ugoe.cs.swe.bnftools.ebnf.Atom;
+import de.ugoe.cs.swe.bnftools.ebnf.EbnfPackage;
+import de.ugoe.cs.swe.bnftools.ebnf.GroupedSequence;
+import de.ugoe.cs.swe.bnftools.ebnf.OptionalSequence;
+import de.ugoe.cs.swe.bnftools.ebnf.RepeatedSequence;
+import de.ugoe.cs.swe.bnftools.ebnf.Term;
+
+import org.eclipse.emf.common.notify.Notification;
+import org.eclipse.emf.common.notify.NotificationChain;
+
+import org.eclipse.emf.ecore.EClass;
+import org.eclipse.emf.ecore.InternalEObject;
+
+import org.eclipse.emf.ecore.impl.ENotificationImpl;
+import org.eclipse.emf.ecore.impl.MinimalEObjectImpl;
+
+/**
+ *
+ * An implementation of the model object 'Term'.
+ *
+ *
+ * The following features are implemented:
+ *
+ * - {@link de.ugoe.cs.swe.bnftools.ebnf.impl.TermImpl#getTermAtom Term Atom}
+ * - {@link de.ugoe.cs.swe.bnftools.ebnf.impl.TermImpl#getTermGroupedSequence Term Grouped Sequence}
+ * - {@link de.ugoe.cs.swe.bnftools.ebnf.impl.TermImpl#getTermOptionalSequence Term Optional Sequence}
+ * - {@link de.ugoe.cs.swe.bnftools.ebnf.impl.TermImpl#getTermRepeatedSequence Term Repeated Sequence}
+ *
+ *
+ *
+ * @generated
+ */
+public class TermImpl extends MinimalEObjectImpl.Container implements Term
+{
+ /**
+ * The cached value of the '{@link #getTermAtom() Term Atom}' containment reference.
+ *
+ *
+ * @see #getTermAtom()
+ * @generated
+ * @ordered
+ */
+ protected Atom termAtom;
+
+ /**
+ * The cached value of the '{@link #getTermGroupedSequence() Term Grouped Sequence}' containment reference.
+ *
+ *
+ * @see #getTermGroupedSequence()
+ * @generated
+ * @ordered
+ */
+ protected GroupedSequence termGroupedSequence;
+
+ /**
+ * The cached value of the '{@link #getTermOptionalSequence() Term Optional Sequence}' containment reference.
+ *
+ *
+ * @see #getTermOptionalSequence()
+ * @generated
+ * @ordered
+ */
+ protected OptionalSequence termOptionalSequence;
+
+ /**
+ * The cached value of the '{@link #getTermRepeatedSequence() Term Repeated Sequence}' containment reference.
+ *
+ *
+ * @see #getTermRepeatedSequence()
+ * @generated
+ * @ordered
+ */
+ protected RepeatedSequence termRepeatedSequence;
+
+ /**
+ *
+ *
+ * @generated
+ */
+ protected TermImpl()
+ {
+ super();
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ @Override
+ protected EClass eStaticClass()
+ {
+ return EbnfPackage.Literals.TERM;
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ public Atom getTermAtom()
+ {
+ return termAtom;
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ public NotificationChain basicSetTermAtom(Atom newTermAtom, NotificationChain msgs)
+ {
+ Atom oldTermAtom = termAtom;
+ termAtom = newTermAtom;
+ if (eNotificationRequired())
+ {
+ ENotificationImpl notification = new ENotificationImpl(this, Notification.SET, EbnfPackage.TERM__TERM_ATOM, oldTermAtom, newTermAtom);
+ if (msgs == null) msgs = notification; else msgs.add(notification);
+ }
+ return msgs;
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ public void setTermAtom(Atom newTermAtom)
+ {
+ if (newTermAtom != termAtom)
+ {
+ NotificationChain msgs = null;
+ if (termAtom != null)
+ msgs = ((InternalEObject)termAtom).eInverseRemove(this, EOPPOSITE_FEATURE_BASE - EbnfPackage.TERM__TERM_ATOM, null, msgs);
+ if (newTermAtom != null)
+ msgs = ((InternalEObject)newTermAtom).eInverseAdd(this, EOPPOSITE_FEATURE_BASE - EbnfPackage.TERM__TERM_ATOM, null, msgs);
+ msgs = basicSetTermAtom(newTermAtom, msgs);
+ if (msgs != null) msgs.dispatch();
+ }
+ else if (eNotificationRequired())
+ eNotify(new ENotificationImpl(this, Notification.SET, EbnfPackage.TERM__TERM_ATOM, newTermAtom, newTermAtom));
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ public GroupedSequence getTermGroupedSequence()
+ {
+ return termGroupedSequence;
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ public NotificationChain basicSetTermGroupedSequence(GroupedSequence newTermGroupedSequence, NotificationChain msgs)
+ {
+ GroupedSequence oldTermGroupedSequence = termGroupedSequence;
+ termGroupedSequence = newTermGroupedSequence;
+ if (eNotificationRequired())
+ {
+ ENotificationImpl notification = new ENotificationImpl(this, Notification.SET, EbnfPackage.TERM__TERM_GROUPED_SEQUENCE, oldTermGroupedSequence, newTermGroupedSequence);
+ if (msgs == null) msgs = notification; else msgs.add(notification);
+ }
+ return msgs;
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ public void setTermGroupedSequence(GroupedSequence newTermGroupedSequence)
+ {
+ if (newTermGroupedSequence != termGroupedSequence)
+ {
+ NotificationChain msgs = null;
+ if (termGroupedSequence != null)
+ msgs = ((InternalEObject)termGroupedSequence).eInverseRemove(this, EOPPOSITE_FEATURE_BASE - EbnfPackage.TERM__TERM_GROUPED_SEQUENCE, null, msgs);
+ if (newTermGroupedSequence != null)
+ msgs = ((InternalEObject)newTermGroupedSequence).eInverseAdd(this, EOPPOSITE_FEATURE_BASE - EbnfPackage.TERM__TERM_GROUPED_SEQUENCE, null, msgs);
+ msgs = basicSetTermGroupedSequence(newTermGroupedSequence, msgs);
+ if (msgs != null) msgs.dispatch();
+ }
+ else if (eNotificationRequired())
+ eNotify(new ENotificationImpl(this, Notification.SET, EbnfPackage.TERM__TERM_GROUPED_SEQUENCE, newTermGroupedSequence, newTermGroupedSequence));
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ public OptionalSequence getTermOptionalSequence()
+ {
+ return termOptionalSequence;
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ public NotificationChain basicSetTermOptionalSequence(OptionalSequence newTermOptionalSequence, NotificationChain msgs)
+ {
+ OptionalSequence oldTermOptionalSequence = termOptionalSequence;
+ termOptionalSequence = newTermOptionalSequence;
+ if (eNotificationRequired())
+ {
+ ENotificationImpl notification = new ENotificationImpl(this, Notification.SET, EbnfPackage.TERM__TERM_OPTIONAL_SEQUENCE, oldTermOptionalSequence, newTermOptionalSequence);
+ if (msgs == null) msgs = notification; else msgs.add(notification);
+ }
+ return msgs;
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ public void setTermOptionalSequence(OptionalSequence newTermOptionalSequence)
+ {
+ if (newTermOptionalSequence != termOptionalSequence)
+ {
+ NotificationChain msgs = null;
+ if (termOptionalSequence != null)
+ msgs = ((InternalEObject)termOptionalSequence).eInverseRemove(this, EOPPOSITE_FEATURE_BASE - EbnfPackage.TERM__TERM_OPTIONAL_SEQUENCE, null, msgs);
+ if (newTermOptionalSequence != null)
+ msgs = ((InternalEObject)newTermOptionalSequence).eInverseAdd(this, EOPPOSITE_FEATURE_BASE - EbnfPackage.TERM__TERM_OPTIONAL_SEQUENCE, null, msgs);
+ msgs = basicSetTermOptionalSequence(newTermOptionalSequence, msgs);
+ if (msgs != null) msgs.dispatch();
+ }
+ else if (eNotificationRequired())
+ eNotify(new ENotificationImpl(this, Notification.SET, EbnfPackage.TERM__TERM_OPTIONAL_SEQUENCE, newTermOptionalSequence, newTermOptionalSequence));
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ public RepeatedSequence getTermRepeatedSequence()
+ {
+ return termRepeatedSequence;
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ public NotificationChain basicSetTermRepeatedSequence(RepeatedSequence newTermRepeatedSequence, NotificationChain msgs)
+ {
+ RepeatedSequence oldTermRepeatedSequence = termRepeatedSequence;
+ termRepeatedSequence = newTermRepeatedSequence;
+ if (eNotificationRequired())
+ {
+ ENotificationImpl notification = new ENotificationImpl(this, Notification.SET, EbnfPackage.TERM__TERM_REPEATED_SEQUENCE, oldTermRepeatedSequence, newTermRepeatedSequence);
+ if (msgs == null) msgs = notification; else msgs.add(notification);
+ }
+ return msgs;
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ public void setTermRepeatedSequence(RepeatedSequence newTermRepeatedSequence)
+ {
+ if (newTermRepeatedSequence != termRepeatedSequence)
+ {
+ NotificationChain msgs = null;
+ if (termRepeatedSequence != null)
+ msgs = ((InternalEObject)termRepeatedSequence).eInverseRemove(this, EOPPOSITE_FEATURE_BASE - EbnfPackage.TERM__TERM_REPEATED_SEQUENCE, null, msgs);
+ if (newTermRepeatedSequence != null)
+ msgs = ((InternalEObject)newTermRepeatedSequence).eInverseAdd(this, EOPPOSITE_FEATURE_BASE - EbnfPackage.TERM__TERM_REPEATED_SEQUENCE, null, msgs);
+ msgs = basicSetTermRepeatedSequence(newTermRepeatedSequence, msgs);
+ if (msgs != null) msgs.dispatch();
+ }
+ else if (eNotificationRequired())
+ eNotify(new ENotificationImpl(this, Notification.SET, EbnfPackage.TERM__TERM_REPEATED_SEQUENCE, newTermRepeatedSequence, newTermRepeatedSequence));
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ @Override
+ public NotificationChain eInverseRemove(InternalEObject otherEnd, int featureID, NotificationChain msgs)
+ {
+ switch (featureID)
+ {
+ case EbnfPackage.TERM__TERM_ATOM:
+ return basicSetTermAtom(null, msgs);
+ case EbnfPackage.TERM__TERM_GROUPED_SEQUENCE:
+ return basicSetTermGroupedSequence(null, msgs);
+ case EbnfPackage.TERM__TERM_OPTIONAL_SEQUENCE:
+ return basicSetTermOptionalSequence(null, msgs);
+ case EbnfPackage.TERM__TERM_REPEATED_SEQUENCE:
+ return basicSetTermRepeatedSequence(null, msgs);
+ }
+ return super.eInverseRemove(otherEnd, featureID, msgs);
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ @Override
+ public Object eGet(int featureID, boolean resolve, boolean coreType)
+ {
+ switch (featureID)
+ {
+ case EbnfPackage.TERM__TERM_ATOM:
+ return getTermAtom();
+ case EbnfPackage.TERM__TERM_GROUPED_SEQUENCE:
+ return getTermGroupedSequence();
+ case EbnfPackage.TERM__TERM_OPTIONAL_SEQUENCE:
+ return getTermOptionalSequence();
+ case EbnfPackage.TERM__TERM_REPEATED_SEQUENCE:
+ return getTermRepeatedSequence();
+ }
+ return super.eGet(featureID, resolve, coreType);
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ @Override
+ public void eSet(int featureID, Object newValue)
+ {
+ switch (featureID)
+ {
+ case EbnfPackage.TERM__TERM_ATOM:
+ setTermAtom((Atom)newValue);
+ return;
+ case EbnfPackage.TERM__TERM_GROUPED_SEQUENCE:
+ setTermGroupedSequence((GroupedSequence)newValue);
+ return;
+ case EbnfPackage.TERM__TERM_OPTIONAL_SEQUENCE:
+ setTermOptionalSequence((OptionalSequence)newValue);
+ return;
+ case EbnfPackage.TERM__TERM_REPEATED_SEQUENCE:
+ setTermRepeatedSequence((RepeatedSequence)newValue);
+ return;
+ }
+ super.eSet(featureID, newValue);
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ @Override
+ public void eUnset(int featureID)
+ {
+ switch (featureID)
+ {
+ case EbnfPackage.TERM__TERM_ATOM:
+ setTermAtom((Atom)null);
+ return;
+ case EbnfPackage.TERM__TERM_GROUPED_SEQUENCE:
+ setTermGroupedSequence((GroupedSequence)null);
+ return;
+ case EbnfPackage.TERM__TERM_OPTIONAL_SEQUENCE:
+ setTermOptionalSequence((OptionalSequence)null);
+ return;
+ case EbnfPackage.TERM__TERM_REPEATED_SEQUENCE:
+ setTermRepeatedSequence((RepeatedSequence)null);
+ return;
+ }
+ super.eUnset(featureID);
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ @Override
+ public boolean eIsSet(int featureID)
+ {
+ switch (featureID)
+ {
+ case EbnfPackage.TERM__TERM_ATOM:
+ return termAtom != null;
+ case EbnfPackage.TERM__TERM_GROUPED_SEQUENCE:
+ return termGroupedSequence != null;
+ case EbnfPackage.TERM__TERM_OPTIONAL_SEQUENCE:
+ return termOptionalSequence != null;
+ case EbnfPackage.TERM__TERM_REPEATED_SEQUENCE:
+ return termRepeatedSequence != null;
+ }
+ return super.eIsSet(featureID);
+ }
+
+} //TermImpl
Index: /v2/trunk/de.ugoe.cs.swe.bnftools.ebnf/src-gen/de/ugoe/cs/swe/bnftools/ebnf/util/EbnfAdapterFactory.java
===================================================================
--- /v2/trunk/de.ugoe.cs.swe.bnftools.ebnf/src-gen/de/ugoe/cs/swe/bnftools/ebnf/util/EbnfAdapterFactory.java (revision 61)
+++ /v2/trunk/de.ugoe.cs.swe.bnftools.ebnf/src-gen/de/ugoe/cs/swe/bnftools/ebnf/util/EbnfAdapterFactory.java (revision 61)
@@ -0,0 +1,552 @@
+/**
+ */
+package de.ugoe.cs.swe.bnftools.ebnf.util;
+
+import de.ugoe.cs.swe.bnftools.ebnf.*;
+
+import org.eclipse.emf.common.notify.Adapter;
+import org.eclipse.emf.common.notify.Notifier;
+
+import org.eclipse.emf.common.notify.impl.AdapterFactoryImpl;
+
+import org.eclipse.emf.ecore.EObject;
+
+/**
+ *
+ * The Adapter Factory for the model.
+ * It provides an adapter createXXX method for each class of the model.
+ *
+ * @see de.ugoe.cs.swe.bnftools.ebnf.EbnfPackage
+ * @generated
+ */
+public class EbnfAdapterFactory extends AdapterFactoryImpl
+{
+ /**
+ * The cached model package.
+ *
+ *
+ * @generated
+ */
+ protected static EbnfPackage modelPackage;
+
+ /**
+ * Creates an instance of the adapter factory.
+ *
+ *
+ * @generated
+ */
+ public EbnfAdapterFactory()
+ {
+ if (modelPackage == null)
+ {
+ modelPackage = EbnfPackage.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 EbnfSwitch modelSwitch =
+ new EbnfSwitch()
+ {
+ @Override
+ public Adapter caseEtsiBnf(EtsiBnf object)
+ {
+ return createEtsiBnfAdapter();
+ }
+ @Override
+ public Adapter caseImportSection(ImportSection object)
+ {
+ return createImportSectionAdapter();
+ }
+ @Override
+ public Adapter caseBnfEntry(BnfEntry object)
+ {
+ return createBnfEntryAdapter();
+ }
+ @Override
+ public Adapter caseDeltaEntry(DeltaEntry object)
+ {
+ return createDeltaEntryAdapter();
+ }
+ @Override
+ public Adapter caseMergeEntry(MergeEntry object)
+ {
+ return createMergeEntryAdapter();
+ }
+ @Override
+ public Adapter caseSectionHeading(SectionHeading object)
+ {
+ return createSectionHeadingAdapter();
+ }
+ @Override
+ public Adapter caseImport(Import object)
+ {
+ return createImportAdapter();
+ }
+ @Override
+ public Adapter caseRule(Rule object)
+ {
+ return createRuleAdapter();
+ }
+ @Override
+ public Adapter caseExtRule(ExtRule object)
+ {
+ return createExtRuleAdapter();
+ }
+ @Override
+ public Adapter caseMergeRule(MergeRule object)
+ {
+ return createMergeRuleAdapter();
+ }
+ @Override
+ public Adapter caseGlobalCombinator(GlobalCombinator object)
+ {
+ return createGlobalCombinatorAdapter();
+ }
+ @Override
+ public Adapter caseRuleCombinator(RuleCombinator object)
+ {
+ return createRuleCombinatorAdapter();
+ }
+ @Override
+ public Adapter caseHookCombinator(HookCombinator object)
+ {
+ return createHookCombinatorAdapter();
+ }
+ @Override
+ public Adapter caseDefinitionList(DefinitionList object)
+ {
+ return createDefinitionListAdapter();
+ }
+ @Override
+ public Adapter caseSingleDefinition(SingleDefinition object)
+ {
+ return createSingleDefinitionAdapter();
+ }
+ @Override
+ public Adapter caseTerm(Term object)
+ {
+ return createTermAdapter();
+ }
+ @Override
+ public Adapter caseAtom(Atom object)
+ {
+ return createAtomAdapter();
+ }
+ @Override
+ public Adapter caseRuleReference(RuleReference object)
+ {
+ return createRuleReferenceAdapter();
+ }
+ @Override
+ public Adapter caseStringRule(StringRule object)
+ {
+ return createStringRuleAdapter();
+ }
+ @Override
+ public Adapter caseGroupedSequence(GroupedSequence object)
+ {
+ return createGroupedSequenceAdapter();
+ }
+ @Override
+ public Adapter caseOptionalSequence(OptionalSequence object)
+ {
+ return createOptionalSequenceAdapter();
+ }
+ @Override
+ public Adapter caseRepeatedSequence(RepeatedSequence object)
+ {
+ return createRepeatedSequenceAdapter();
+ }
+ @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 de.ugoe.cs.swe.bnftools.ebnf.EtsiBnf Etsi Bnf}'.
+ *
+ * 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 de.ugoe.cs.swe.bnftools.ebnf.EtsiBnf
+ * @generated
+ */
+ public Adapter createEtsiBnfAdapter()
+ {
+ return null;
+ }
+
+ /**
+ * Creates a new adapter for an object of class '{@link de.ugoe.cs.swe.bnftools.ebnf.ImportSection Import Section}'.
+ *
+ * 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 de.ugoe.cs.swe.bnftools.ebnf.ImportSection
+ * @generated
+ */
+ public Adapter createImportSectionAdapter()
+ {
+ return null;
+ }
+
+ /**
+ * Creates a new adapter for an object of class '{@link de.ugoe.cs.swe.bnftools.ebnf.BnfEntry Bnf Entry}'.
+ *
+ * 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 de.ugoe.cs.swe.bnftools.ebnf.BnfEntry
+ * @generated
+ */
+ public Adapter createBnfEntryAdapter()
+ {
+ return null;
+ }
+
+ /**
+ * Creates a new adapter for an object of class '{@link de.ugoe.cs.swe.bnftools.ebnf.DeltaEntry Delta Entry}'.
+ *
+ * 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 de.ugoe.cs.swe.bnftools.ebnf.DeltaEntry
+ * @generated
+ */
+ public Adapter createDeltaEntryAdapter()
+ {
+ return null;
+ }
+
+ /**
+ * Creates a new adapter for an object of class '{@link de.ugoe.cs.swe.bnftools.ebnf.MergeEntry Merge Entry}'.
+ *
+ * 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 de.ugoe.cs.swe.bnftools.ebnf.MergeEntry
+ * @generated
+ */
+ public Adapter createMergeEntryAdapter()
+ {
+ return null;
+ }
+
+ /**
+ * Creates a new adapter for an object of class '{@link de.ugoe.cs.swe.bnftools.ebnf.SectionHeading Section Heading}'.
+ *
+ * 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 de.ugoe.cs.swe.bnftools.ebnf.SectionHeading
+ * @generated
+ */
+ public Adapter createSectionHeadingAdapter()
+ {
+ return null;
+ }
+
+ /**
+ * Creates a new adapter for an object of class '{@link de.ugoe.cs.swe.bnftools.ebnf.Import Import}'.
+ *
+ * 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 de.ugoe.cs.swe.bnftools.ebnf.Import
+ * @generated
+ */
+ public Adapter createImportAdapter()
+ {
+ return null;
+ }
+
+ /**
+ * Creates a new adapter for an object of class '{@link de.ugoe.cs.swe.bnftools.ebnf.Rule Rule}'.
+ *
+ * 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 de.ugoe.cs.swe.bnftools.ebnf.Rule
+ * @generated
+ */
+ public Adapter createRuleAdapter()
+ {
+ return null;
+ }
+
+ /**
+ * Creates a new adapter for an object of class '{@link de.ugoe.cs.swe.bnftools.ebnf.ExtRule Ext Rule}'.
+ *
+ * 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 de.ugoe.cs.swe.bnftools.ebnf.ExtRule
+ * @generated
+ */
+ public Adapter createExtRuleAdapter()
+ {
+ return null;
+ }
+
+ /**
+ * Creates a new adapter for an object of class '{@link de.ugoe.cs.swe.bnftools.ebnf.MergeRule Merge Rule}'.
+ *
+ * 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 de.ugoe.cs.swe.bnftools.ebnf.MergeRule
+ * @generated
+ */
+ public Adapter createMergeRuleAdapter()
+ {
+ return null;
+ }
+
+ /**
+ * Creates a new adapter for an object of class '{@link de.ugoe.cs.swe.bnftools.ebnf.GlobalCombinator Global Combinator}'.
+ *
+ * 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 de.ugoe.cs.swe.bnftools.ebnf.GlobalCombinator
+ * @generated
+ */
+ public Adapter createGlobalCombinatorAdapter()
+ {
+ return null;
+ }
+
+ /**
+ * Creates a new adapter for an object of class '{@link de.ugoe.cs.swe.bnftools.ebnf.RuleCombinator Rule Combinator}'.
+ *
+ * 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 de.ugoe.cs.swe.bnftools.ebnf.RuleCombinator
+ * @generated
+ */
+ public Adapter createRuleCombinatorAdapter()
+ {
+ return null;
+ }
+
+ /**
+ * Creates a new adapter for an object of class '{@link de.ugoe.cs.swe.bnftools.ebnf.HookCombinator Hook Combinator}'.
+ *
+ * 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 de.ugoe.cs.swe.bnftools.ebnf.HookCombinator
+ * @generated
+ */
+ public Adapter createHookCombinatorAdapter()
+ {
+ return null;
+ }
+
+ /**
+ * Creates a new adapter for an object of class '{@link de.ugoe.cs.swe.bnftools.ebnf.DefinitionList Definition List}'.
+ *
+ * This default implementation returns null so that we can easily ignore cases;
+ * it's useful to ignore a case when inheritance will catch all the cases anyway.
+ *
+ * @return the new adapter.
+ * @see de.ugoe.cs.swe.bnftools.ebnf.DefinitionList
+ * @generated
+ */
+ public Adapter createDefinitionListAdapter()
+ {
+ return null;
+ }
+
+ /**
+ * Creates a new adapter for an object of class '{@link de.ugoe.cs.swe.bnftools.ebnf.SingleDefinition Single Definition}'.
+ *
+ * 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 de.ugoe.cs.swe.bnftools.ebnf.SingleDefinition
+ * @generated
+ */
+ public Adapter createSingleDefinitionAdapter()
+ {
+ return null;
+ }
+
+ /**
+ * Creates a new adapter for an object of class '{@link de.ugoe.cs.swe.bnftools.ebnf.Term Term}'.
+ *
+ * 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 de.ugoe.cs.swe.bnftools.ebnf.Term
+ * @generated
+ */
+ public Adapter createTermAdapter()
+ {
+ return null;
+ }
+
+ /**
+ * Creates a new adapter for an object of class '{@link de.ugoe.cs.swe.bnftools.ebnf.Atom Atom}'.
+ *
+ * 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 de.ugoe.cs.swe.bnftools.ebnf.Atom
+ * @generated
+ */
+ public Adapter createAtomAdapter()
+ {
+ return null;
+ }
+
+ /**
+ * Creates a new adapter for an object of class '{@link de.ugoe.cs.swe.bnftools.ebnf.RuleReference Rule Reference}'.
+ *
+ * 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 de.ugoe.cs.swe.bnftools.ebnf.RuleReference
+ * @generated
+ */
+ public Adapter createRuleReferenceAdapter()
+ {
+ return null;
+ }
+
+ /**
+ * Creates a new adapter for an object of class '{@link de.ugoe.cs.swe.bnftools.ebnf.StringRule String Rule}'.
+ *
+ * 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 de.ugoe.cs.swe.bnftools.ebnf.StringRule
+ * @generated
+ */
+ public Adapter createStringRuleAdapter()
+ {
+ return null;
+ }
+
+ /**
+ * Creates a new adapter for an object of class '{@link de.ugoe.cs.swe.bnftools.ebnf.GroupedSequence Grouped Sequence}'.
+ *
+ * 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 de.ugoe.cs.swe.bnftools.ebnf.GroupedSequence
+ * @generated
+ */
+ public Adapter createGroupedSequenceAdapter()
+ {
+ return null;
+ }
+
+ /**
+ * Creates a new adapter for an object of class '{@link de.ugoe.cs.swe.bnftools.ebnf.OptionalSequence Optional Sequence}'.
+ *
+ * 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 de.ugoe.cs.swe.bnftools.ebnf.OptionalSequence
+ * @generated
+ */
+ public Adapter createOptionalSequenceAdapter()
+ {
+ return null;
+ }
+
+ /**
+ * Creates a new adapter for an object of class '{@link de.ugoe.cs.swe.bnftools.ebnf.RepeatedSequence Repeated Sequence}'.
+ *
+ * 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 de.ugoe.cs.swe.bnftools.ebnf.RepeatedSequence
+ * @generated
+ */
+ public Adapter createRepeatedSequenceAdapter()
+ {
+ 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;
+ }
+
+} //EbnfAdapterFactory
Index: /v2/trunk/de.ugoe.cs.swe.bnftools.ebnf/src-gen/de/ugoe/cs/swe/bnftools/ebnf/util/EbnfSwitch.java
===================================================================
--- /v2/trunk/de.ugoe.cs.swe.bnftools.ebnf/src-gen/de/ugoe/cs/swe/bnftools/ebnf/util/EbnfSwitch.java (revision 61)
+++ /v2/trunk/de.ugoe.cs.swe.bnftools.ebnf/src-gen/de/ugoe/cs/swe/bnftools/ebnf/util/EbnfSwitch.java (revision 61)
@@ -0,0 +1,605 @@
+/**
+ */
+package de.ugoe.cs.swe.bnftools.ebnf.util;
+
+import de.ugoe.cs.swe.bnftools.ebnf.*;
+
+import org.eclipse.emf.ecore.EObject;
+import org.eclipse.emf.ecore.EPackage;
+
+import org.eclipse.emf.ecore.util.Switch;
+
+/**
+ *
+ * The Switch for the model's inheritance hierarchy.
+ * It supports the call {@link #doSwitch(EObject) doSwitch(object)}
+ * to invoke the caseXXX method for each class of the model,
+ * starting with the actual class of the object
+ * and proceeding up the inheritance hierarchy
+ * until a non-null result is returned,
+ * which is the result of the switch.
+ *
+ * @see de.ugoe.cs.swe.bnftools.ebnf.EbnfPackage
+ * @generated
+ */
+public class EbnfSwitch extends Switch
+{
+ /**
+ * The cached model package
+ *
+ *
+ * @generated
+ */
+ protected static EbnfPackage modelPackage;
+
+ /**
+ * Creates an instance of the switch.
+ *
+ *
+ * @generated
+ */
+ public EbnfSwitch()
+ {
+ if (modelPackage == null)
+ {
+ modelPackage = EbnfPackage.eINSTANCE;
+ }
+ }
+
+ /**
+ * Checks whether this is a switch for the given package.
+ *
+ *
+ * @parameter ePackage the package in question.
+ * @return whether this is a switch for the given package.
+ * @generated
+ */
+ @Override
+ protected boolean isSwitchFor(EPackage ePackage)
+ {
+ return ePackage == modelPackage;
+ }
+
+ /**
+ * Calls caseXXX for each class of the model until one returns a non null result; it yields that result.
+ *
+ *
+ * @return the first non-null result returned by a caseXXX call.
+ * @generated
+ */
+ @Override
+ protected T doSwitch(int classifierID, EObject theEObject)
+ {
+ switch (classifierID)
+ {
+ case EbnfPackage.ETSI_BNF:
+ {
+ EtsiBnf etsiBnf = (EtsiBnf)theEObject;
+ T result = caseEtsiBnf(etsiBnf);
+ if (result == null) result = defaultCase(theEObject);
+ return result;
+ }
+ case EbnfPackage.IMPORT_SECTION:
+ {
+ ImportSection importSection = (ImportSection)theEObject;
+ T result = caseImportSection(importSection);
+ if (result == null) result = defaultCase(theEObject);
+ return result;
+ }
+ case EbnfPackage.BNF_ENTRY:
+ {
+ BnfEntry bnfEntry = (BnfEntry)theEObject;
+ T result = caseBnfEntry(bnfEntry);
+ if (result == null) result = defaultCase(theEObject);
+ return result;
+ }
+ case EbnfPackage.DELTA_ENTRY:
+ {
+ DeltaEntry deltaEntry = (DeltaEntry)theEObject;
+ T result = caseDeltaEntry(deltaEntry);
+ if (result == null) result = defaultCase(theEObject);
+ return result;
+ }
+ case EbnfPackage.MERGE_ENTRY:
+ {
+ MergeEntry mergeEntry = (MergeEntry)theEObject;
+ T result = caseMergeEntry(mergeEntry);
+ if (result == null) result = defaultCase(theEObject);
+ return result;
+ }
+ case EbnfPackage.SECTION_HEADING:
+ {
+ SectionHeading sectionHeading = (SectionHeading)theEObject;
+ T result = caseSectionHeading(sectionHeading);
+ if (result == null) result = defaultCase(theEObject);
+ return result;
+ }
+ case EbnfPackage.IMPORT:
+ {
+ Import import_ = (Import)theEObject;
+ T result = caseImport(import_);
+ if (result == null) result = defaultCase(theEObject);
+ return result;
+ }
+ case EbnfPackage.RULE:
+ {
+ Rule rule = (Rule)theEObject;
+ T result = caseRule(rule);
+ if (result == null) result = defaultCase(theEObject);
+ return result;
+ }
+ case EbnfPackage.EXT_RULE:
+ {
+ ExtRule extRule = (ExtRule)theEObject;
+ T result = caseExtRule(extRule);
+ if (result == null) result = defaultCase(theEObject);
+ return result;
+ }
+ case EbnfPackage.MERGE_RULE:
+ {
+ MergeRule mergeRule = (MergeRule)theEObject;
+ T result = caseMergeRule(mergeRule);
+ if (result == null) result = defaultCase(theEObject);
+ return result;
+ }
+ case EbnfPackage.GLOBAL_COMBINATOR:
+ {
+ GlobalCombinator globalCombinator = (GlobalCombinator)theEObject;
+ T result = caseGlobalCombinator(globalCombinator);
+ if (result == null) result = caseMergeRule(globalCombinator);
+ if (result == null) result = defaultCase(theEObject);
+ return result;
+ }
+ case EbnfPackage.RULE_COMBINATOR:
+ {
+ RuleCombinator ruleCombinator = (RuleCombinator)theEObject;
+ T result = caseRuleCombinator(ruleCombinator);
+ if (result == null) result = caseMergeRule(ruleCombinator);
+ if (result == null) result = defaultCase(theEObject);
+ return result;
+ }
+ case EbnfPackage.HOOK_COMBINATOR:
+ {
+ HookCombinator hookCombinator = (HookCombinator)theEObject;
+ T result = caseHookCombinator(hookCombinator);
+ if (result == null) result = caseMergeRule(hookCombinator);
+ if (result == null) result = defaultCase(theEObject);
+ return result;
+ }
+ case EbnfPackage.DEFINITION_LIST:
+ {
+ DefinitionList definitionList = (DefinitionList)theEObject;
+ T result = caseDefinitionList(definitionList);
+ if (result == null) result = defaultCase(theEObject);
+ return result;
+ }
+ case EbnfPackage.SINGLE_DEFINITION:
+ {
+ SingleDefinition singleDefinition = (SingleDefinition)theEObject;
+ T result = caseSingleDefinition(singleDefinition);
+ if (result == null) result = defaultCase(theEObject);
+ return result;
+ }
+ case EbnfPackage.TERM:
+ {
+ Term term = (Term)theEObject;
+ T result = caseTerm(term);
+ if (result == null) result = defaultCase(theEObject);
+ return result;
+ }
+ case EbnfPackage.ATOM:
+ {
+ Atom atom = (Atom)theEObject;
+ T result = caseAtom(atom);
+ if (result == null) result = defaultCase(theEObject);
+ return result;
+ }
+ case EbnfPackage.RULE_REFERENCE:
+ {
+ RuleReference ruleReference = (RuleReference)theEObject;
+ T result = caseRuleReference(ruleReference);
+ if (result == null) result = defaultCase(theEObject);
+ return result;
+ }
+ case EbnfPackage.STRING_RULE:
+ {
+ StringRule stringRule = (StringRule)theEObject;
+ T result = caseStringRule(stringRule);
+ if (result == null) result = defaultCase(theEObject);
+ return result;
+ }
+ case EbnfPackage.GROUPED_SEQUENCE:
+ {
+ GroupedSequence groupedSequence = (GroupedSequence)theEObject;
+ T result = caseGroupedSequence(groupedSequence);
+ if (result == null) result = defaultCase(theEObject);
+ return result;
+ }
+ case EbnfPackage.OPTIONAL_SEQUENCE:
+ {
+ OptionalSequence optionalSequence = (OptionalSequence)theEObject;
+ T result = caseOptionalSequence(optionalSequence);
+ if (result == null) result = defaultCase(theEObject);
+ return result;
+ }
+ case EbnfPackage.REPEATED_SEQUENCE:
+ {
+ RepeatedSequence repeatedSequence = (RepeatedSequence)theEObject;
+ T result = caseRepeatedSequence(repeatedSequence);
+ if (result == null) result = defaultCase(theEObject);
+ return result;
+ }
+ default: return defaultCase(theEObject);
+ }
+ }
+
+ /**
+ * Returns the result of interpreting the object as an instance of 'Etsi Bnf'.
+ *
+ * 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 'Etsi Bnf'.
+ * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject)
+ * @generated
+ */
+ public T caseEtsiBnf(EtsiBnf object)
+ {
+ return null;
+ }
+
+ /**
+ * Returns the result of interpreting the object as an instance of 'Import Section'.
+ *
+ * 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 'Import Section'.
+ * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject)
+ * @generated
+ */
+ public T caseImportSection(ImportSection object)
+ {
+ return null;
+ }
+
+ /**
+ * Returns the result of interpreting the object as an instance of 'Bnf Entry'.
+ *
+ * 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 'Bnf Entry'.
+ * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject)
+ * @generated
+ */
+ public T caseBnfEntry(BnfEntry object)
+ {
+ return null;
+ }
+
+ /**
+ * Returns the result of interpreting the object as an instance of 'Delta Entry'.
+ *
+ * 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 'Delta Entry'.
+ * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject)
+ * @generated
+ */
+ public T caseDeltaEntry(DeltaEntry object)
+ {
+ return null;
+ }
+
+ /**
+ * Returns the result of interpreting the object as an instance of 'Merge Entry'.
+ *
+ * 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 'Merge Entry'.
+ * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject)
+ * @generated
+ */
+ public T caseMergeEntry(MergeEntry object)
+ {
+ return null;
+ }
+
+ /**
+ * Returns the result of interpreting the object as an instance of 'Section Heading'.
+ *
+ * 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 'Section Heading'.
+ * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject)
+ * @generated
+ */
+ public T caseSectionHeading(SectionHeading object)
+ {
+ return null;
+ }
+
+ /**
+ * Returns the result of interpreting the object as an instance of 'Import'.
+ *
+ * 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 'Import'.
+ * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject)
+ * @generated
+ */
+ public T caseImport(Import object)
+ {
+ return null;
+ }
+
+ /**
+ * Returns the result of interpreting the object as an instance of 'Rule'.
+ *
+ * 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 'Rule'.
+ * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject)
+ * @generated
+ */
+ public T caseRule(Rule object)
+ {
+ return null;
+ }
+
+ /**
+ * Returns the result of interpreting the object as an instance of 'Ext Rule'.
+ *
+ * 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 'Ext Rule'.
+ * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject)
+ * @generated
+ */
+ public T caseExtRule(ExtRule object)
+ {
+ return null;
+ }
+
+ /**
+ * Returns the result of interpreting the object as an instance of 'Merge Rule'.
+ *
+ * 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 'Merge Rule'.
+ * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject)
+ * @generated
+ */
+ public T caseMergeRule(MergeRule object)
+ {
+ return null;
+ }
+
+ /**
+ * Returns the result of interpreting the object as an instance of 'Global Combinator'.
+ *
+ * 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 'Global Combinator'.
+ * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject)
+ * @generated
+ */
+ public T caseGlobalCombinator(GlobalCombinator object)
+ {
+ return null;
+ }
+
+ /**
+ * Returns the result of interpreting the object as an instance of 'Rule Combinator'.
+ *
+ * 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 'Rule Combinator'.
+ * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject)
+ * @generated
+ */
+ public T caseRuleCombinator(RuleCombinator object)
+ {
+ return null;
+ }
+
+ /**
+ * Returns the result of interpreting the object as an instance of 'Hook Combinator'.
+ *
+ * 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 'Hook Combinator'.
+ * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject)
+ * @generated
+ */
+ public T caseHookCombinator(HookCombinator object)
+ {
+ return null;
+ }
+
+ /**
+ * Returns the result of interpreting the object as an instance of 'Definition List'.
+ *
+ * This implementation returns null;
+ * returning a non-null result will terminate the switch.
+ *
+ * @param object the target of the switch.
+ * @return the result of interpreting the object as an instance of 'Definition List'.
+ * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject)
+ * @generated
+ */
+ public T caseDefinitionList(DefinitionList object)
+ {
+ return null;
+ }
+
+ /**
+ * Returns the result of interpreting the object as an instance of 'Single Definition'.
+ *
+ * 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 'Single Definition'.
+ * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject)
+ * @generated
+ */
+ public T caseSingleDefinition(SingleDefinition object)
+ {
+ return null;
+ }
+
+ /**
+ * Returns the result of interpreting the object as an instance of 'Term'.
+ *
+ * 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 'Term'.
+ * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject)
+ * @generated
+ */
+ public T caseTerm(Term object)
+ {
+ return null;
+ }
+
+ /**
+ * Returns the result of interpreting the object as an instance of 'Atom'.
+ *
+ * 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 'Atom'.
+ * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject)
+ * @generated
+ */
+ public T caseAtom(Atom object)
+ {
+ return null;
+ }
+
+ /**
+ * Returns the result of interpreting the object as an instance of 'Rule Reference'.
+ *
+ * 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 'Rule Reference'.
+ * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject)
+ * @generated
+ */
+ public T caseRuleReference(RuleReference object)
+ {
+ return null;
+ }
+
+ /**
+ * Returns the result of interpreting the object as an instance of 'String Rule'.
+ *
+ * This implementation returns null;
+ * returning a non-null result will terminate the switch.
+ *
+ * @param object the target of the switch.
+ * @return the result of interpreting the object as an instance of 'String Rule'.
+ * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject)
+ * @generated
+ */
+ public T caseStringRule(StringRule object)
+ {
+ return null;
+ }
+
+ /**
+ * Returns the result of interpreting the object as an instance of 'Grouped Sequence'.
+ *
+ * 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 'Grouped Sequence'.
+ * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject)
+ * @generated
+ */
+ public T caseGroupedSequence(GroupedSequence object)
+ {
+ return null;
+ }
+
+ /**
+ * Returns the result of interpreting the object as an instance of 'Optional Sequence'.
+ *
+ * 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 'Optional Sequence'.
+ * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject)
+ * @generated
+ */
+ public T caseOptionalSequence(OptionalSequence object)
+ {
+ return null;
+ }
+
+ /**
+ * Returns the result of interpreting the object as an instance of 'Repeated Sequence'.
+ *
+ * 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 'Repeated Sequence'.
+ * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject)
+ * @generated
+ */
+ public T caseRepeatedSequence(RepeatedSequence 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;
+ }
+
+} //EbnfSwitch
Index: /v2/trunk/de.ugoe.cs.swe.bnftools.ebnf/src-gen/de/ugoe/cs/swe/bnftools/parser/antlr/EbnfAntlrTokenFileProvider.java
===================================================================
--- /v2/trunk/de.ugoe.cs.swe.bnftools.ebnf/src-gen/de/ugoe/cs/swe/bnftools/parser/antlr/EbnfAntlrTokenFileProvider.java (revision 61)
+++ /v2/trunk/de.ugoe.cs.swe.bnftools.ebnf/src-gen/de/ugoe/cs/swe/bnftools/parser/antlr/EbnfAntlrTokenFileProvider.java (revision 61)
@@ -0,0 +1,15 @@
+/*
+* generated by Xtext
+*/
+package de.ugoe.cs.swe.bnftools.parser.antlr;
+
+import java.io.InputStream;
+import org.eclipse.xtext.parser.antlr.IAntlrTokenFileProvider;
+
+public class EbnfAntlrTokenFileProvider implements IAntlrTokenFileProvider {
+
+ public InputStream getAntlrTokenFile() {
+ ClassLoader classLoader = getClass().getClassLoader();
+ return classLoader.getResourceAsStream("de/ugoe/cs/swe/bnftools/parser/antlr/internal/InternalEbnf.tokens");
+ }
+}
Index: /v2/trunk/de.ugoe.cs.swe.bnftools.ebnf/src-gen/de/ugoe/cs/swe/bnftools/parser/antlr/EbnfParser.java
===================================================================
--- /v2/trunk/de.ugoe.cs.swe.bnftools.ebnf/src-gen/de/ugoe/cs/swe/bnftools/parser/antlr/EbnfParser.java (revision 61)
+++ /v2/trunk/de.ugoe.cs.swe.bnftools.ebnf/src-gen/de/ugoe/cs/swe/bnftools/parser/antlr/EbnfParser.java (revision 61)
@@ -0,0 +1,39 @@
+/*
+* generated by Xtext
+*/
+package de.ugoe.cs.swe.bnftools.parser.antlr;
+
+import com.google.inject.Inject;
+
+import org.eclipse.xtext.parser.antlr.XtextTokenStream;
+import de.ugoe.cs.swe.bnftools.services.EbnfGrammarAccess;
+
+public class EbnfParser extends org.eclipse.xtext.parser.antlr.AbstractAntlrParser {
+
+ @Inject
+ private EbnfGrammarAccess grammarAccess;
+
+ @Override
+ protected void setInitialHiddenTokens(XtextTokenStream tokenStream) {
+ tokenStream.setInitialHiddenTokens("RULE_WS", "RULE_ML_COMMENT", "RULE_SL_COMMENT");
+ }
+
+ @Override
+ protected de.ugoe.cs.swe.bnftools.parser.antlr.internal.InternalEbnfParser createParser(XtextTokenStream stream) {
+ return new de.ugoe.cs.swe.bnftools.parser.antlr.internal.InternalEbnfParser(stream, getGrammarAccess());
+ }
+
+ @Override
+ protected String getDefaultRuleName() {
+ return "EtsiBnf";
+ }
+
+ public EbnfGrammarAccess getGrammarAccess() {
+ return this.grammarAccess;
+ }
+
+ public void setGrammarAccess(EbnfGrammarAccess grammarAccess) {
+ this.grammarAccess = grammarAccess;
+ }
+
+}
Index: /v2/trunk/de.ugoe.cs.swe.bnftools.ebnf/src-gen/de/ugoe/cs/swe/bnftools/parser/antlr/internal/InternalEbnf.g
===================================================================
--- /v2/trunk/de.ugoe.cs.swe.bnftools.ebnf/src-gen/de/ugoe/cs/swe/bnftools/parser/antlr/internal/InternalEbnf.g (revision 61)
+++ /v2/trunk/de.ugoe.cs.swe.bnftools.ebnf/src-gen/de/ugoe/cs/swe/bnftools/parser/antlr/internal/InternalEbnf.g (revision 61)
@@ -0,0 +1,1791 @@
+/*
+* generated by Xtext
+*/
+grammar InternalEbnf;
+
+options {
+ superClass=AbstractInternalAntlrParser;
+
+}
+
+@lexer::header {
+package de.ugoe.cs.swe.bnftools.parser.antlr.internal;
+
+// Hack: Use our own Lexer superclass by means of import.
+// Currently there is no other way to specify the superclass for the lexer.
+import org.eclipse.xtext.parser.antlr.Lexer;
+}
+
+@parser::header {
+package de.ugoe.cs.swe.bnftools.parser.antlr.internal;
+
+import org.eclipse.xtext.*;
+import org.eclipse.xtext.parser.*;
+import org.eclipse.xtext.parser.impl.*;
+import org.eclipse.emf.ecore.util.EcoreUtil;
+import org.eclipse.emf.ecore.EObject;
+import org.eclipse.xtext.parser.antlr.AbstractInternalAntlrParser;
+import org.eclipse.xtext.parser.antlr.XtextTokenStream;
+import org.eclipse.xtext.parser.antlr.XtextTokenStream.HiddenTokens;
+import org.eclipse.xtext.parser.antlr.AntlrDatatypeRuleToken;
+import de.ugoe.cs.swe.bnftools.services.EbnfGrammarAccess;
+
+}
+
+@parser::members {
+
+ private EbnfGrammarAccess grammarAccess;
+
+ public InternalEbnfParser(TokenStream input, EbnfGrammarAccess grammarAccess) {
+ this(input);
+ this.grammarAccess = grammarAccess;
+ registerRules(grammarAccess.getGrammar());
+ }
+
+ @Override
+ protected String getFirstRuleName() {
+ return "EtsiBnf";
+ }
+
+ @Override
+ protected EbnfGrammarAccess getGrammarAccess() {
+ return grammarAccess;
+ }
+}
+
+@rulecatch {
+ catch (RecognitionException re) {
+ recover(input,re);
+ appendSkippedTokens();
+ }
+}
+
+
+
+
+// Entry rule entryRuleEtsiBnf
+entryRuleEtsiBnf returns [EObject current=null]
+ :
+ { newCompositeNode(grammarAccess.getEtsiBnfRule()); }
+ iv_ruleEtsiBnf=ruleEtsiBnf
+ { $current=$iv_ruleEtsiBnf.current; }
+ EOF
+;
+
+// Rule EtsiBnf
+ruleEtsiBnf returns [EObject current=null]
+ @init { enterRule();
+ }
+ @after { leaveRule(); }:
+(( otherlv_0='grammar'
+ {
+ newLeafNode(otherlv_0, grammarAccess.getEtsiBnfAccess().getGrammarKeyword_0_0());
+ }
+(
+(
+ lv_name_1_0=RULE_ID
+ {
+ newLeafNode(lv_name_1_0, grammarAccess.getEtsiBnfAccess().getNameIDTerminalRuleCall_0_1_0());
+ }
+ {
+ if ($current==null) {
+ $current = createModelElement(grammarAccess.getEtsiBnfRule());
+ }
+ setWithLastConsumed(
+ $current,
+ "name",
+ lv_name_1_0,
+ "ID");
+ }
+
+)
+)((
+(
+ lv_type_2_0= '/bnf'
+ {
+ newLeafNode(lv_type_2_0, grammarAccess.getEtsiBnfAccess().getTypeBnfKeyword_0_2_0_0());
+ }
+
+ {
+ if ($current==null) {
+ $current = createModelElement(grammarAccess.getEtsiBnfRule());
+ }
+ setWithLastConsumed($current, "type", lv_type_2_0, "/bnf");
+ }
+
+)
+)? otherlv_3=';'
+ {
+ newLeafNode(otherlv_3, grammarAccess.getEtsiBnfAccess().getSemicolonKeyword_0_2_1());
+ }
+(
+(
+ {
+ newCompositeNode(grammarAccess.getEtsiBnfAccess().getImportSectionImportSectionParserRuleCall_0_2_2_0());
+ }
+ lv_importSection_4_0=ruleImportSection {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getEtsiBnfRule());
+ }
+ set(
+ $current,
+ "importSection",
+ lv_importSection_4_0,
+ "ImportSection");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+)?(
+(
+ {
+ newCompositeNode(grammarAccess.getEtsiBnfAccess().getBnfEntryBnfEntryParserRuleCall_0_2_3_0());
+ }
+ lv_bnfEntry_5_0=ruleBnfEntry {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getEtsiBnfRule());
+ }
+ add(
+ $current,
+ "bnfEntry",
+ lv_bnfEntry_5_0,
+ "BnfEntry");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+)+))
+ |((
+(
+ lv_type_6_0= '/delta'
+ {
+ newLeafNode(lv_type_6_0, grammarAccess.getEtsiBnfAccess().getTypeDeltaKeyword_1_0_0());
+ }
+
+ {
+ if ($current==null) {
+ $current = createModelElement(grammarAccess.getEtsiBnfRule());
+ }
+ setWithLastConsumed($current, "type", lv_type_6_0, "/delta");
+ }
+
+)
+) otherlv_7=';'
+ {
+ newLeafNode(otherlv_7, grammarAccess.getEtsiBnfAccess().getSemicolonKeyword_1_1());
+ }
+(
+(
+ {
+ newCompositeNode(grammarAccess.getEtsiBnfAccess().getImportSectionImportSectionParserRuleCall_1_2_0());
+ }
+ lv_importSection_8_0=ruleImportSection {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getEtsiBnfRule());
+ }
+ set(
+ $current,
+ "importSection",
+ lv_importSection_8_0,
+ "ImportSection");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+)?(
+(
+ {
+ newCompositeNode(grammarAccess.getEtsiBnfAccess().getDeltaEntryDeltaEntryParserRuleCall_1_3_0());
+ }
+ lv_deltaEntry_9_0=ruleDeltaEntry {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getEtsiBnfRule());
+ }
+ add(
+ $current,
+ "deltaEntry",
+ lv_deltaEntry_9_0,
+ "DeltaEntry");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+)*)
+ |((
+(
+ lv_type_10_0= '/merge'
+ {
+ newLeafNode(lv_type_10_0, grammarAccess.getEtsiBnfAccess().getTypeMergeKeyword_2_0_0());
+ }
+
+ {
+ if ($current==null) {
+ $current = createModelElement(grammarAccess.getEtsiBnfRule());
+ }
+ setWithLastConsumed($current, "type", lv_type_10_0, "/merge");
+ }
+
+)
+) otherlv_11=';'
+ {
+ newLeafNode(otherlv_11, grammarAccess.getEtsiBnfAccess().getSemicolonKeyword_2_1());
+ }
+(
+(
+ {
+ newCompositeNode(grammarAccess.getEtsiBnfAccess().getImportSectionImportSectionParserRuleCall_2_2_0());
+ }
+ lv_importSection_12_0=ruleImportSection {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getEtsiBnfRule());
+ }
+ set(
+ $current,
+ "importSection",
+ lv_importSection_12_0,
+ "ImportSection");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+)?(
+(
+ {
+ newCompositeNode(grammarAccess.getEtsiBnfAccess().getMergeEntryMergeEntryParserRuleCall_2_3_0());
+ }
+ lv_mergeEntry_13_0=ruleMergeEntry {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getEtsiBnfRule());
+ }
+ add(
+ $current,
+ "mergeEntry",
+ lv_mergeEntry_13_0,
+ "MergeEntry");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+)*))
+;
+
+
+
+
+
+// Entry rule entryRuleImportSection
+entryRuleImportSection returns [EObject current=null]
+ :
+ { newCompositeNode(grammarAccess.getImportSectionRule()); }
+ iv_ruleImportSection=ruleImportSection
+ { $current=$iv_ruleImportSection.current; }
+ EOF
+;
+
+// Rule ImportSection
+ruleImportSection returns [EObject current=null]
+ @init { enterRule();
+ }
+ @after { leaveRule(); }:
+(
+(
+ {
+ newCompositeNode(grammarAccess.getImportSectionAccess().getImportsImportParserRuleCall_0());
+ }
+ lv_imports_0_0=ruleImport {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getImportSectionRule());
+ }
+ add(
+ $current,
+ "imports",
+ lv_imports_0_0,
+ "Import");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+)+
+;
+
+
+
+
+
+// Entry rule entryRuleBnfEntry
+entryRuleBnfEntry returns [EObject current=null]
+ :
+ { newCompositeNode(grammarAccess.getBnfEntryRule()); }
+ iv_ruleBnfEntry=ruleBnfEntry
+ { $current=$iv_ruleBnfEntry.current; }
+ EOF
+;
+
+// Rule BnfEntry
+ruleBnfEntry returns [EObject current=null]
+ @init { enterRule();
+ }
+ @after { leaveRule(); }:
+((
+(
+ {
+ newCompositeNode(grammarAccess.getBnfEntryAccess().getSectionheaderSectionHeadingParserRuleCall_0_0());
+ }
+ lv_sectionheader_0_0=ruleSectionHeading {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getBnfEntryRule());
+ }
+ set(
+ $current,
+ "sectionheader",
+ lv_sectionheader_0_0,
+ "SectionHeading");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+)
+ |(
+(
+ {
+ newCompositeNode(grammarAccess.getBnfEntryAccess().getRuleRuleParserRuleCall_1_0());
+ }
+ lv_rule_1_0=ruleRule {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getBnfEntryRule());
+ }
+ set(
+ $current,
+ "rule",
+ lv_rule_1_0,
+ "Rule");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+))
+;
+
+
+
+
+
+// Entry rule entryRuleDeltaEntry
+entryRuleDeltaEntry returns [EObject current=null]
+ :
+ { newCompositeNode(grammarAccess.getDeltaEntryRule()); }
+ iv_ruleDeltaEntry=ruleDeltaEntry
+ { $current=$iv_ruleDeltaEntry.current; }
+ EOF
+;
+
+// Rule DeltaEntry
+ruleDeltaEntry returns [EObject current=null]
+ @init { enterRule();
+ }
+ @after { leaveRule(); }:
+((
+(
+ {
+ newCompositeNode(grammarAccess.getDeltaEntryAccess().getRuleRuleParserRuleCall_0_0());
+ }
+ lv_rule_0_0=ruleRule {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getDeltaEntryRule());
+ }
+ set(
+ $current,
+ "rule",
+ lv_rule_0_0,
+ "Rule");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+)
+ |(
+(
+ {
+ newCompositeNode(grammarAccess.getDeltaEntryAccess().getSectionheaderSectionHeadingParserRuleCall_1_0());
+ }
+ lv_sectionheader_1_0=ruleSectionHeading {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getDeltaEntryRule());
+ }
+ set(
+ $current,
+ "sectionheader",
+ lv_sectionheader_1_0,
+ "SectionHeading");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+)
+ |(
+(
+ {
+ newCompositeNode(grammarAccess.getDeltaEntryAccess().getExtRuleExtRuleParserRuleCall_2_0());
+ }
+ lv_extRule_2_0=ruleExtRule {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getDeltaEntryRule());
+ }
+ set(
+ $current,
+ "extRule",
+ lv_extRule_2_0,
+ "ExtRule");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+))
+;
+
+
+
+
+
+// Entry rule entryRuleMergeEntry
+entryRuleMergeEntry returns [EObject current=null]
+ :
+ { newCompositeNode(grammarAccess.getMergeEntryRule()); }
+ iv_ruleMergeEntry=ruleMergeEntry
+ { $current=$iv_ruleMergeEntry.current; }
+ EOF
+;
+
+// Rule MergeEntry
+ruleMergeEntry returns [EObject current=null]
+ @init { enterRule();
+ }
+ @after { leaveRule(); }:
+((
+(
+ {
+ newCompositeNode(grammarAccess.getMergeEntryAccess().getSectionheaderSectionHeadingParserRuleCall_0_0());
+ }
+ lv_sectionheader_0_0=ruleSectionHeading {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getMergeEntryRule());
+ }
+ set(
+ $current,
+ "sectionheader",
+ lv_sectionheader_0_0,
+ "SectionHeading");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+)
+ |(
+(
+ {
+ newCompositeNode(grammarAccess.getMergeEntryAccess().getMergeRuleMergeRuleParserRuleCall_1_0());
+ }
+ lv_mergeRule_1_0=ruleMergeRule {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getMergeEntryRule());
+ }
+ set(
+ $current,
+ "mergeRule",
+ lv_mergeRule_1_0,
+ "MergeRule");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+))
+;
+
+
+
+
+
+// Entry rule entryRuleSectionHeading
+entryRuleSectionHeading returns [EObject current=null]
+ :
+ { newCompositeNode(grammarAccess.getSectionHeadingRule()); }
+ iv_ruleSectionHeading=ruleSectionHeading
+ { $current=$iv_ruleSectionHeading.current; }
+ EOF
+;
+
+// Rule SectionHeading
+ruleSectionHeading returns [EObject current=null]
+ @init { enterRule();
+ }
+ @after { leaveRule(); }:
+((
+ {
+ $current = forceCreateModelElement(
+ grammarAccess.getSectionHeadingAccess().getSectionHeadingAction_0(),
+ $current);
+ }
+)(
+(
+ lv_sectionHeader_1_0=RULE_SECTIONHEADER
+ {
+ newLeafNode(lv_sectionHeader_1_0, grammarAccess.getSectionHeadingAccess().getSectionHeaderSECTIONHEADERTerminalRuleCall_1_0());
+ }
+ {
+ if ($current==null) {
+ $current = createModelElement(grammarAccess.getSectionHeadingRule());
+ }
+ setWithLastConsumed(
+ $current,
+ "sectionHeader",
+ lv_sectionHeader_1_0,
+ "SECTIONHEADER");
+ }
+
+)
+))
+;
+
+
+
+
+
+// Entry rule entryRuleImport
+entryRuleImport returns [EObject current=null]
+ :
+ { newCompositeNode(grammarAccess.getImportRule()); }
+ iv_ruleImport=ruleImport
+ { $current=$iv_ruleImport.current; }
+ EOF
+;
+
+// Rule Import
+ruleImport returns [EObject current=null]
+ @init { enterRule();
+ }
+ @after { leaveRule(); }:
+( otherlv_0='import'
+ {
+ newLeafNode(otherlv_0, grammarAccess.getImportAccess().getImportKeyword_0());
+ }
+(
+(
+ lv_importURI_1_0=RULE_STRING
+ {
+ newLeafNode(lv_importURI_1_0, grammarAccess.getImportAccess().getImportURISTRINGTerminalRuleCall_1_0());
+ }
+ {
+ if ($current==null) {
+ $current = createModelElement(grammarAccess.getImportRule());
+ }
+ setWithLastConsumed(
+ $current,
+ "importURI",
+ lv_importURI_1_0,
+ "STRING");
+ }
+
+)
+)( otherlv_2='/'
+ {
+ newLeafNode(otherlv_2, grammarAccess.getImportAccess().getSolidusKeyword_2_0());
+ }
+((
+(
+ lv_grammarType_3_0= 'core'
+ {
+ newLeafNode(lv_grammarType_3_0, grammarAccess.getImportAccess().getGrammarTypeCoreKeyword_2_1_0_0());
+ }
+
+ {
+ if ($current==null) {
+ $current = createModelElement(grammarAccess.getImportRule());
+ }
+ setWithLastConsumed($current, "grammarType", lv_grammarType_3_0, "core");
+ }
+
+)
+)
+ |(
+(
+ lv_grammarType_4_0= 'package'
+ {
+ newLeafNode(lv_grammarType_4_0, grammarAccess.getImportAccess().getGrammarTypePackageKeyword_2_1_1_0());
+ }
+
+ {
+ if ($current==null) {
+ $current = createModelElement(grammarAccess.getImportRule());
+ }
+ setWithLastConsumed($current, "grammarType", lv_grammarType_4_0, "package");
+ }
+
+)
+)
+ |(
+(
+ lv_grammarType_5_0= 'update'
+ {
+ newLeafNode(lv_grammarType_5_0, grammarAccess.getImportAccess().getGrammarTypeUpdateKeyword_2_1_2_0());
+ }
+
+ {
+ if ($current==null) {
+ $current = createModelElement(grammarAccess.getImportRule());
+ }
+ setWithLastConsumed($current, "grammarType", lv_grammarType_5_0, "update");
+ }
+
+)
+)))?( otherlv_6='label:'
+ {
+ newLeafNode(otherlv_6, grammarAccess.getImportAccess().getLabelKeyword_3_0());
+ }
+(
+(
+ lv_label_7_0=RULE_ID
+ {
+ newLeafNode(lv_label_7_0, grammarAccess.getImportAccess().getLabelIDTerminalRuleCall_3_1_0());
+ }
+ {
+ if ($current==null) {
+ $current = createModelElement(grammarAccess.getImportRule());
+ }
+ setWithLastConsumed(
+ $current,
+ "label",
+ lv_label_7_0,
+ "ID");
+ }
+
+)
+))? otherlv_8=';'
+ {
+ newLeafNode(otherlv_8, grammarAccess.getImportAccess().getSemicolonKeyword_4());
+ }
+)
+;
+
+
+
+
+
+// Entry rule entryRuleRule
+entryRuleRule returns [EObject current=null]
+ :
+ { newCompositeNode(grammarAccess.getRuleRule()); }
+ iv_ruleRule=ruleRule
+ { $current=$iv_ruleRule.current; }
+ EOF
+;
+
+// Rule Rule
+ruleRule returns [EObject current=null]
+ @init { enterRule();
+ }
+ @after { leaveRule(); }:
+(((
+(
+ lv_rulenumber_0_0=RULE_INT
+ {
+ newLeafNode(lv_rulenumber_0_0, grammarAccess.getRuleAccess().getRulenumberINTTerminalRuleCall_0_0_0());
+ }
+ {
+ if ($current==null) {
+ $current = createModelElement(grammarAccess.getRuleRule());
+ }
+ setWithLastConsumed(
+ $current,
+ "rulenumber",
+ lv_rulenumber_0_0,
+ "INT");
+ }
+
+)
+)(
+(
+ lv_rulevariant_1_0=RULE_ID
+ {
+ newLeafNode(lv_rulevariant_1_0, grammarAccess.getRuleAccess().getRulevariantIDTerminalRuleCall_0_1_0());
+ }
+ {
+ if ($current==null) {
+ $current = createModelElement(grammarAccess.getRuleRule());
+ }
+ setWithLastConsumed(
+ $current,
+ "rulevariant",
+ lv_rulevariant_1_0,
+ "ID");
+ }
+
+)
+)? otherlv_2='.'
+ {
+ newLeafNode(otherlv_2, grammarAccess.getRuleAccess().getFullStopKeyword_0_2());
+ }
+)?(
+(
+ lv_name_3_0=RULE_ID
+ {
+ newLeafNode(lv_name_3_0, grammarAccess.getRuleAccess().getNameIDTerminalRuleCall_1_0());
+ }
+ {
+ if ($current==null) {
+ $current = createModelElement(grammarAccess.getRuleRule());
+ }
+ setWithLastConsumed(
+ $current,
+ "name",
+ lv_name_3_0,
+ "ID");
+ }
+
+)
+) otherlv_4='::='
+ {
+ newLeafNode(otherlv_4, grammarAccess.getRuleAccess().getColonColonEqualsSignKeyword_2());
+ }
+(
+(
+ {
+ newCompositeNode(grammarAccess.getRuleAccess().getDefinitionListDefinitionListParserRuleCall_3_0());
+ }
+ lv_definitionList_5_0=ruleDefinitionList {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getRuleRule());
+ }
+ set(
+ $current,
+ "definitionList",
+ lv_definitionList_5_0,
+ "DefinitionList");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+)?( otherlv_6=';'
+ {
+ newLeafNode(otherlv_6, grammarAccess.getRuleAccess().getSemicolonKeyword_4());
+ }
+)?)
+;
+
+
+
+
+
+// Entry rule entryRuleExtRule
+entryRuleExtRule returns [EObject current=null]
+ :
+ { newCompositeNode(grammarAccess.getExtRuleRule()); }
+ iv_ruleExtRule=ruleExtRule
+ { $current=$iv_ruleExtRule.current; }
+ EOF
+;
+
+// Rule ExtRule
+ruleExtRule returns [EObject current=null]
+ @init { enterRule();
+ }
+ @after { leaveRule(); }:
+(((
+(
+ lv_rulenumber_0_0=RULE_INT
+ {
+ newLeafNode(lv_rulenumber_0_0, grammarAccess.getExtRuleAccess().getRulenumberINTTerminalRuleCall_0_0_0());
+ }
+ {
+ if ($current==null) {
+ $current = createModelElement(grammarAccess.getExtRuleRule());
+ }
+ setWithLastConsumed(
+ $current,
+ "rulenumber",
+ lv_rulenumber_0_0,
+ "INT");
+ }
+
+)
+)(
+(
+ lv_rulevariant_1_0=RULE_ID
+ {
+ newLeafNode(lv_rulevariant_1_0, grammarAccess.getExtRuleAccess().getRulevariantIDTerminalRuleCall_0_1_0());
+ }
+ {
+ if ($current==null) {
+ $current = createModelElement(grammarAccess.getExtRuleRule());
+ }
+ setWithLastConsumed(
+ $current,
+ "rulevariant",
+ lv_rulevariant_1_0,
+ "ID");
+ }
+
+)
+)? otherlv_2='.'
+ {
+ newLeafNode(otherlv_2, grammarAccess.getExtRuleAccess().getFullStopKeyword_0_2());
+ }
+)?(
+(
+ lv_name_3_0=RULE_ID
+ {
+ newLeafNode(lv_name_3_0, grammarAccess.getExtRuleAccess().getNameIDTerminalRuleCall_1_0());
+ }
+ {
+ if ($current==null) {
+ $current = createModelElement(grammarAccess.getExtRuleRule());
+ }
+ setWithLastConsumed(
+ $current,
+ "name",
+ lv_name_3_0,
+ "ID");
+ }
+
+)
+)( otherlv_4='('
+ {
+ newLeafNode(otherlv_4, grammarAccess.getExtRuleAccess().getLeftParenthesisKeyword_2_0());
+ }
+(
+(
+ lv_ruleext_5_0=RULE_INT
+ {
+ newLeafNode(lv_ruleext_5_0, grammarAccess.getExtRuleAccess().getRuleextINTTerminalRuleCall_2_1_0());
+ }
+ {
+ if ($current==null) {
+ $current = createModelElement(grammarAccess.getExtRuleRule());
+ }
+ setWithLastConsumed(
+ $current,
+ "ruleext",
+ lv_ruleext_5_0,
+ "INT");
+ }
+
+)
+) otherlv_6=')'
+ {
+ newLeafNode(otherlv_6, grammarAccess.getExtRuleAccess().getRightParenthesisKeyword_2_2());
+ }
+) otherlv_7='<-'
+ {
+ newLeafNode(otherlv_7, grammarAccess.getExtRuleAccess().getLessThanSignHyphenMinusKeyword_3());
+ }
+((
+(
+ {
+ newCompositeNode(grammarAccess.getExtRuleAccess().getElementsAtomParserRuleCall_4_0_0());
+ }
+ lv_elements_8_0=ruleAtom {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getExtRuleRule());
+ }
+ add(
+ $current,
+ "elements",
+ lv_elements_8_0,
+ "Atom");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+)
+ | otherlv_9=')'
+ {
+ newLeafNode(otherlv_9, grammarAccess.getExtRuleAccess().getRightParenthesisKeyword_4_1());
+ }
+
+ | otherlv_10=']'
+ {
+ newLeafNode(otherlv_10, grammarAccess.getExtRuleAccess().getRightSquareBracketKeyword_4_2());
+ }
+
+ | otherlv_11='}'
+ {
+ newLeafNode(otherlv_11, grammarAccess.getExtRuleAccess().getRightCurlyBracketKeyword_4_3());
+ }
+
+ | otherlv_12='|'
+ {
+ newLeafNode(otherlv_12, grammarAccess.getExtRuleAccess().getVerticalLineKeyword_4_4());
+ }
+
+ | otherlv_13='('
+ {
+ newLeafNode(otherlv_13, grammarAccess.getExtRuleAccess().getLeftParenthesisKeyword_4_5());
+ }
+
+ | otherlv_14='['
+ {
+ newLeafNode(otherlv_14, grammarAccess.getExtRuleAccess().getLeftSquareBracketKeyword_4_6());
+ }
+
+ | otherlv_15='{'
+ {
+ newLeafNode(otherlv_15, grammarAccess.getExtRuleAccess().getLeftCurlyBracketKeyword_4_7());
+ }
+
+ | otherlv_16='*'
+ {
+ newLeafNode(otherlv_16, grammarAccess.getExtRuleAccess().getAsteriskKeyword_4_8());
+ }
+
+ | otherlv_17='+'
+ {
+ newLeafNode(otherlv_17, grammarAccess.getExtRuleAccess().getPlusSignKeyword_4_9());
+ }
+)*( otherlv_18=';'
+ {
+ newLeafNode(otherlv_18, grammarAccess.getExtRuleAccess().getSemicolonKeyword_5());
+ }
+)?)
+;
+
+
+
+
+
+// Entry rule entryRuleMergeRule
+entryRuleMergeRule returns [EObject current=null]
+ :
+ { newCompositeNode(grammarAccess.getMergeRuleRule()); }
+ iv_ruleMergeRule=ruleMergeRule
+ { $current=$iv_ruleMergeRule.current; }
+ EOF
+;
+
+// Rule MergeRule
+ruleMergeRule returns [EObject current=null]
+ @init { enterRule();
+ }
+ @after { leaveRule(); }:
+(
+ {
+ newCompositeNode(grammarAccess.getMergeRuleAccess().getGlobalCombinatorParserRuleCall_0());
+ }
+ this_GlobalCombinator_0=ruleGlobalCombinator
+ {
+ $current = $this_GlobalCombinator_0.current;
+ afterParserOrEnumRuleCall();
+ }
+
+ |
+ {
+ newCompositeNode(grammarAccess.getMergeRuleAccess().getRuleCombinatorParserRuleCall_1());
+ }
+ this_RuleCombinator_1=ruleRuleCombinator
+ {
+ $current = $this_RuleCombinator_1.current;
+ afterParserOrEnumRuleCall();
+ }
+
+ |
+ {
+ newCompositeNode(grammarAccess.getMergeRuleAccess().getHookCombinatorParserRuleCall_2());
+ }
+ this_HookCombinator_2=ruleHookCombinator
+ {
+ $current = $this_HookCombinator_2.current;
+ afterParserOrEnumRuleCall();
+ }
+)
+;
+
+
+
+
+
+// Entry rule entryRuleGlobalCombinator
+entryRuleGlobalCombinator returns [EObject current=null]
+ :
+ { newCompositeNode(grammarAccess.getGlobalCombinatorRule()); }
+ iv_ruleGlobalCombinator=ruleGlobalCombinator
+ { $current=$iv_ruleGlobalCombinator.current; }
+ EOF
+;
+
+// Rule GlobalCombinator
+ruleGlobalCombinator returns [EObject current=null]
+ @init { enterRule();
+ }
+ @after { leaveRule(); }:
+(( otherlv_0='global'
+ {
+ newLeafNode(otherlv_0, grammarAccess.getGlobalCombinatorAccess().getGlobalKeyword_0_0());
+ }
+ otherlv_1='combinator:'
+ {
+ newLeafNode(otherlv_1, grammarAccess.getGlobalCombinatorAccess().getCombinatorKeyword_0_1());
+ }
+)(
+(
+ lv_logic_2_0=RULE_LOGIC
+ {
+ newLeafNode(lv_logic_2_0, grammarAccess.getGlobalCombinatorAccess().getLogicLOGICTerminalRuleCall_1_0());
+ }
+ {
+ if ($current==null) {
+ $current = createModelElement(grammarAccess.getGlobalCombinatorRule());
+ }
+ setWithLastConsumed(
+ $current,
+ "logic",
+ lv_logic_2_0,
+ "LOGIC");
+ }
+
+)
+)( otherlv_3=';'
+ {
+ newLeafNode(otherlv_3, grammarAccess.getGlobalCombinatorAccess().getSemicolonKeyword_2());
+ }
+)?)
+;
+
+
+
+
+
+// Entry rule entryRuleRuleCombinator
+entryRuleRuleCombinator returns [EObject current=null]
+ :
+ { newCompositeNode(grammarAccess.getRuleCombinatorRule()); }
+ iv_ruleRuleCombinator=ruleRuleCombinator
+ { $current=$iv_ruleRuleCombinator.current; }
+ EOF
+;
+
+// Rule RuleCombinator
+ruleRuleCombinator returns [EObject current=null]
+ @init { enterRule();
+ }
+ @after { leaveRule(); }:
+(( otherlv_0='rule'
+ {
+ newLeafNode(otherlv_0, grammarAccess.getRuleCombinatorAccess().getRuleKeyword_0_0());
+ }
+ otherlv_1='combinator:'
+ {
+ newLeafNode(otherlv_1, grammarAccess.getRuleCombinatorAccess().getCombinatorKeyword_0_1());
+ }
+(
+(
+ lv_name_2_0=RULE_ID
+ {
+ newLeafNode(lv_name_2_0, grammarAccess.getRuleCombinatorAccess().getNameIDTerminalRuleCall_0_2_0());
+ }
+ {
+ if ($current==null) {
+ $current = createModelElement(grammarAccess.getRuleCombinatorRule());
+ }
+ setWithLastConsumed(
+ $current,
+ "name",
+ lv_name_2_0,
+ "ID");
+ }
+
+)
+))(
+(
+ lv_logic_3_0=RULE_LOGIC
+ {
+ newLeafNode(lv_logic_3_0, grammarAccess.getRuleCombinatorAccess().getLogicLOGICTerminalRuleCall_1_0());
+ }
+ {
+ if ($current==null) {
+ $current = createModelElement(grammarAccess.getRuleCombinatorRule());
+ }
+ setWithLastConsumed(
+ $current,
+ "logic",
+ lv_logic_3_0,
+ "LOGIC");
+ }
+
+)
+)( otherlv_4='('
+ {
+ newLeafNode(otherlv_4, grammarAccess.getRuleCombinatorAccess().getLeftParenthesisKeyword_2_0());
+ }
+(
+(
+ lv_LABEL_5_0=RULE_STRING
+ {
+ newLeafNode(lv_LABEL_5_0, grammarAccess.getRuleCombinatorAccess().getLABELSTRINGTerminalRuleCall_2_1_0());
+ }
+ {
+ if ($current==null) {
+ $current = createModelElement(grammarAccess.getRuleCombinatorRule());
+ }
+ addWithLastConsumed(
+ $current,
+ "LABEL",
+ lv_LABEL_5_0,
+ "STRING");
+ }
+
+)
+) otherlv_6=')'
+ {
+ newLeafNode(otherlv_6, grammarAccess.getRuleCombinatorAccess().getRightParenthesisKeyword_2_2());
+ }
+)*( otherlv_7=';'
+ {
+ newLeafNode(otherlv_7, grammarAccess.getRuleCombinatorAccess().getSemicolonKeyword_3());
+ }
+)?)
+;
+
+
+
+
+
+// Entry rule entryRuleHookCombinator
+entryRuleHookCombinator returns [EObject current=null]
+ :
+ { newCompositeNode(grammarAccess.getHookCombinatorRule()); }
+ iv_ruleHookCombinator=ruleHookCombinator
+ { $current=$iv_ruleHookCombinator.current; }
+ EOF
+;
+
+// Rule HookCombinator
+ruleHookCombinator returns [EObject current=null]
+ @init { enterRule();
+ }
+ @after { leaveRule(); }:
+( otherlv_0='hook'
+ {
+ newLeafNode(otherlv_0, grammarAccess.getHookCombinatorAccess().getHookKeyword_0());
+ }
+ otherlv_1='combinator:'
+ {
+ newLeafNode(otherlv_1, grammarAccess.getHookCombinatorAccess().getCombinatorKeyword_1());
+ }
+(
+(
+ lv_name_2_0=RULE_ID
+ {
+ newLeafNode(lv_name_2_0, grammarAccess.getHookCombinatorAccess().getNameIDTerminalRuleCall_2_0());
+ }
+ {
+ if ($current==null) {
+ $current = createModelElement(grammarAccess.getHookCombinatorRule());
+ }
+ setWithLastConsumed(
+ $current,
+ "name",
+ lv_name_2_0,
+ "ID");
+ }
+
+)
+) otherlv_3='('
+ {
+ newLeafNode(otherlv_3, grammarAccess.getHookCombinatorAccess().getLeftParenthesisKeyword_3());
+ }
+(
+(
+ lv_ruleext_4_0=RULE_INT
+ {
+ newLeafNode(lv_ruleext_4_0, grammarAccess.getHookCombinatorAccess().getRuleextINTTerminalRuleCall_4_0());
+ }
+ {
+ if ($current==null) {
+ $current = createModelElement(grammarAccess.getHookCombinatorRule());
+ }
+ setWithLastConsumed(
+ $current,
+ "ruleext",
+ lv_ruleext_4_0,
+ "INT");
+ }
+
+)
+) otherlv_5=')'
+ {
+ newLeafNode(otherlv_5, grammarAccess.getHookCombinatorAccess().getRightParenthesisKeyword_5());
+ }
+(
+(
+ lv_logic_6_0=RULE_LOGIC
+ {
+ newLeafNode(lv_logic_6_0, grammarAccess.getHookCombinatorAccess().getLogicLOGICTerminalRuleCall_6_0());
+ }
+ {
+ if ($current==null) {
+ $current = createModelElement(grammarAccess.getHookCombinatorRule());
+ }
+ setWithLastConsumed(
+ $current,
+ "logic",
+ lv_logic_6_0,
+ "LOGIC");
+ }
+
+)
+)?( otherlv_7='('
+ {
+ newLeafNode(otherlv_7, grammarAccess.getHookCombinatorAccess().getLeftParenthesisKeyword_7_0());
+ }
+(
+(
+ lv_LABEL_8_0=RULE_STRING
+ {
+ newLeafNode(lv_LABEL_8_0, grammarAccess.getHookCombinatorAccess().getLABELSTRINGTerminalRuleCall_7_1_0());
+ }
+ {
+ if ($current==null) {
+ $current = createModelElement(grammarAccess.getHookCombinatorRule());
+ }
+ addWithLastConsumed(
+ $current,
+ "LABEL",
+ lv_LABEL_8_0,
+ "STRING");
+ }
+
+)
+) otherlv_9=')'
+ {
+ newLeafNode(otherlv_9, grammarAccess.getHookCombinatorAccess().getRightParenthesisKeyword_7_2());
+ }
+)+( otherlv_10=';'
+ {
+ newLeafNode(otherlv_10, grammarAccess.getHookCombinatorAccess().getSemicolonKeyword_8());
+ }
+)?)
+;
+
+
+
+
+
+// Entry rule entryRuleDefinitionList
+entryRuleDefinitionList returns [EObject current=null]
+ :
+ { newCompositeNode(grammarAccess.getDefinitionListRule()); }
+ iv_ruleDefinitionList=ruleDefinitionList
+ { $current=$iv_ruleDefinitionList.current; }
+ EOF
+;
+
+// Rule DefinitionList
+ruleDefinitionList returns [EObject current=null]
+ @init { enterRule();
+ }
+ @after { leaveRule(); }:
+((
+(
+ {
+ newCompositeNode(grammarAccess.getDefinitionListAccess().getSingleDefinitionSingleDefinitionParserRuleCall_0_0());
+ }
+ lv_singleDefinition_0_0=ruleSingleDefinition {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getDefinitionListRule());
+ }
+ add(
+ $current,
+ "singleDefinition",
+ lv_singleDefinition_0_0,
+ "SingleDefinition");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+)( otherlv_1='|'
+ {
+ newLeafNode(otherlv_1, grammarAccess.getDefinitionListAccess().getVerticalLineKeyword_1_0());
+ }
+(
+(
+ {
+ newCompositeNode(grammarAccess.getDefinitionListAccess().getSingleDefinitionSingleDefinitionParserRuleCall_1_1_0());
+ }
+ lv_singleDefinition_2_0=ruleSingleDefinition {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getDefinitionListRule());
+ }
+ add(
+ $current,
+ "singleDefinition",
+ lv_singleDefinition_2_0,
+ "SingleDefinition");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+))*)
+;
+
+
+
+
+
+// Entry rule entryRuleSingleDefinition
+entryRuleSingleDefinition returns [EObject current=null]
+ :
+ { newCompositeNode(grammarAccess.getSingleDefinitionRule()); }
+ iv_ruleSingleDefinition=ruleSingleDefinition
+ { $current=$iv_ruleSingleDefinition.current; }
+ EOF
+;
+
+// Rule SingleDefinition
+ruleSingleDefinition returns [EObject current=null]
+ @init { enterRule();
+ }
+ @after { leaveRule(); }:
+(
+(
+ {
+ newCompositeNode(grammarAccess.getSingleDefinitionAccess().getTermsTermParserRuleCall_0());
+ }
+ lv_terms_0_0=ruleTerm {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getSingleDefinitionRule());
+ }
+ add(
+ $current,
+ "terms",
+ lv_terms_0_0,
+ "Term");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+)+
+;
+
+
+
+
+
+// Entry rule entryRuleTerm
+entryRuleTerm returns [EObject current=null]
+ :
+ { newCompositeNode(grammarAccess.getTermRule()); }
+ iv_ruleTerm=ruleTerm
+ { $current=$iv_ruleTerm.current; }
+ EOF
+;
+
+// Rule Term
+ruleTerm returns [EObject current=null]
+ @init { enterRule();
+ }
+ @after { leaveRule(); }:
+((
+(
+ {
+ newCompositeNode(grammarAccess.getTermAccess().getTermAtomAtomParserRuleCall_0_0());
+ }
+ lv_termAtom_0_0=ruleAtom {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getTermRule());
+ }
+ set(
+ $current,
+ "termAtom",
+ lv_termAtom_0_0,
+ "Atom");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+)
+ |(
+(
+ {
+ newCompositeNode(grammarAccess.getTermAccess().getTermGroupedSequenceGroupedSequenceParserRuleCall_1_0());
+ }
+ lv_termGroupedSequence_1_0=ruleGroupedSequence {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getTermRule());
+ }
+ set(
+ $current,
+ "termGroupedSequence",
+ lv_termGroupedSequence_1_0,
+ "GroupedSequence");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+)
+ |(
+(
+ {
+ newCompositeNode(grammarAccess.getTermAccess().getTermOptionalSequenceOptionalSequenceParserRuleCall_2_0());
+ }
+ lv_termOptionalSequence_2_0=ruleOptionalSequence {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getTermRule());
+ }
+ set(
+ $current,
+ "termOptionalSequence",
+ lv_termOptionalSequence_2_0,
+ "OptionalSequence");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+)
+ |(
+(
+ {
+ newCompositeNode(grammarAccess.getTermAccess().getTermRepeatedSequenceRepeatedSequenceParserRuleCall_3_0());
+ }
+ lv_termRepeatedSequence_3_0=ruleRepeatedSequence {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getTermRule());
+ }
+ set(
+ $current,
+ "termRepeatedSequence",
+ lv_termRepeatedSequence_3_0,
+ "RepeatedSequence");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+))
+;
+
+
+
+
+
+// Entry rule entryRuleAtom
+entryRuleAtom returns [EObject current=null]
+ :
+ { newCompositeNode(grammarAccess.getAtomRule()); }
+ iv_ruleAtom=ruleAtom
+ { $current=$iv_ruleAtom.current; }
+ EOF
+;
+
+// Rule Atom
+ruleAtom returns [EObject current=null]
+ @init { enterRule();
+ }
+ @after { leaveRule(); }:
+((
+(
+ {
+ newCompositeNode(grammarAccess.getAtomAccess().getAtomStringRuleStringRuleParserRuleCall_0_0());
+ }
+ lv_atomStringRule_0_0=ruleStringRule {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getAtomRule());
+ }
+ set(
+ $current,
+ "atomStringRule",
+ lv_atomStringRule_0_0,
+ "StringRule");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+)
+ |(
+(
+ {
+ newCompositeNode(grammarAccess.getAtomAccess().getAtomRuleReferenceRuleReferenceParserRuleCall_1_0());
+ }
+ lv_atomRuleReference_1_0=ruleRuleReference {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getAtomRule());
+ }
+ set(
+ $current,
+ "atomRuleReference",
+ lv_atomRuleReference_1_0,
+ "RuleReference");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+))
+;
+
+
+
+
+
+// Entry rule entryRuleRuleReference
+entryRuleRuleReference returns [EObject current=null]
+ :
+ { newCompositeNode(grammarAccess.getRuleReferenceRule()); }
+ iv_ruleRuleReference=ruleRuleReference
+ { $current=$iv_ruleRuleReference.current; }
+ EOF
+;
+
+// Rule RuleReference
+ruleRuleReference returns [EObject current=null]
+ @init { enterRule();
+ }
+ @after { leaveRule(); }:
+(
+(
+ {
+ if ($current==null) {
+ $current = createModelElement(grammarAccess.getRuleReferenceRule());
+ }
+ }
+ otherlv_0=RULE_ID
+ {
+ newLeafNode(otherlv_0, grammarAccess.getRuleReferenceAccess().getRulerefRuleCrossReference_0());
+ }
+
+)
+)
+;
+
+
+
+
+
+// Entry rule entryRuleStringRule
+entryRuleStringRule returns [EObject current=null]
+ :
+ { newCompositeNode(grammarAccess.getStringRuleRule()); }
+ iv_ruleStringRule=ruleStringRule
+ { $current=$iv_ruleStringRule.current; }
+ EOF
+;
+
+// Rule StringRule
+ruleStringRule returns [EObject current=null]
+ @init { enterRule();
+ }
+ @after { leaveRule(); }:
+((
+(
+ lv_literal_0_0=RULE_STRING
+ {
+ newLeafNode(lv_literal_0_0, grammarAccess.getStringRuleAccess().getLiteralSTRINGTerminalRuleCall_0_0());
+ }
+ {
+ if ($current==null) {
+ $current = createModelElement(grammarAccess.getStringRuleRule());
+ }
+ setWithLastConsumed(
+ $current,
+ "literal",
+ lv_literal_0_0,
+ "STRING");
+ }
+
+)
+)
+ |(
+(
+ lv_colon_1_0=RULE_COLON
+ {
+ newLeafNode(lv_colon_1_0, grammarAccess.getStringRuleAccess().getColonCOLONTerminalRuleCall_1_0());
+ }
+ {
+ if ($current==null) {
+ $current = createModelElement(grammarAccess.getStringRuleRule());
+ }
+ setWithLastConsumed(
+ $current,
+ "colon",
+ lv_colon_1_0,
+ "COLON");
+ }
+
+)
+))
+;
+
+
+
+
+
+// Entry rule entryRuleGroupedSequence
+entryRuleGroupedSequence returns [EObject current=null]
+ :
+ { newCompositeNode(grammarAccess.getGroupedSequenceRule()); }
+ iv_ruleGroupedSequence=ruleGroupedSequence
+ { $current=$iv_ruleGroupedSequence.current; }
+ EOF
+;
+
+// Rule GroupedSequence
+ruleGroupedSequence returns [EObject current=null]
+ @init { enterRule();
+ }
+ @after { leaveRule(); }:
+( otherlv_0='('
+ {
+ newLeafNode(otherlv_0, grammarAccess.getGroupedSequenceAccess().getLeftParenthesisKeyword_0());
+ }
+(
+(
+ {
+ newCompositeNode(grammarAccess.getGroupedSequenceAccess().getDefinitionListDefinitionListParserRuleCall_1_0());
+ }
+ lv_definitionList_1_0=ruleDefinitionList {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getGroupedSequenceRule());
+ }
+ add(
+ $current,
+ "definitionList",
+ lv_definitionList_1_0,
+ "DefinitionList");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+) otherlv_2=')'
+ {
+ newLeafNode(otherlv_2, grammarAccess.getGroupedSequenceAccess().getRightParenthesisKeyword_2());
+ }
+)
+;
+
+
+
+
+
+// Entry rule entryRuleOptionalSequence
+entryRuleOptionalSequence returns [EObject current=null]
+ :
+ { newCompositeNode(grammarAccess.getOptionalSequenceRule()); }
+ iv_ruleOptionalSequence=ruleOptionalSequence
+ { $current=$iv_ruleOptionalSequence.current; }
+ EOF
+;
+
+// Rule OptionalSequence
+ruleOptionalSequence returns [EObject current=null]
+ @init { enterRule();
+ }
+ @after { leaveRule(); }:
+( otherlv_0='['
+ {
+ newLeafNode(otherlv_0, grammarAccess.getOptionalSequenceAccess().getLeftSquareBracketKeyword_0());
+ }
+(
+(
+ {
+ newCompositeNode(grammarAccess.getOptionalSequenceAccess().getDefinitionListDefinitionListParserRuleCall_1_0());
+ }
+ lv_definitionList_1_0=ruleDefinitionList {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getOptionalSequenceRule());
+ }
+ add(
+ $current,
+ "definitionList",
+ lv_definitionList_1_0,
+ "DefinitionList");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+) otherlv_2=']'
+ {
+ newLeafNode(otherlv_2, grammarAccess.getOptionalSequenceAccess().getRightSquareBracketKeyword_2());
+ }
+)
+;
+
+
+
+
+
+// Entry rule entryRuleRepeatedSequence
+entryRuleRepeatedSequence returns [EObject current=null]
+ :
+ { newCompositeNode(grammarAccess.getRepeatedSequenceRule()); }
+ iv_ruleRepeatedSequence=ruleRepeatedSequence
+ { $current=$iv_ruleRepeatedSequence.current; }
+ EOF
+;
+
+// Rule RepeatedSequence
+ruleRepeatedSequence returns [EObject current=null]
+ @init { enterRule();
+ }
+ @after { leaveRule(); }:
+( otherlv_0='{'
+ {
+ newLeafNode(otherlv_0, grammarAccess.getRepeatedSequenceAccess().getLeftCurlyBracketKeyword_0());
+ }
+(
+(
+ {
+ newCompositeNode(grammarAccess.getRepeatedSequenceAccess().getDefinitionsDefinitionListParserRuleCall_1_0());
+ }
+ lv_definitions_1_0=ruleDefinitionList {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getRepeatedSequenceRule());
+ }
+ add(
+ $current,
+ "definitions",
+ lv_definitions_1_0,
+ "DefinitionList");
+ afterParserOrEnumRuleCall();
+ }
+
+)
+) otherlv_2='}'
+ {
+ newLeafNode(otherlv_2, grammarAccess.getRepeatedSequenceAccess().getRightCurlyBracketKeyword_2());
+ }
+(
+(
+ lv_morethanonce_3_0= '+'
+ {
+ newLeafNode(lv_morethanonce_3_0, grammarAccess.getRepeatedSequenceAccess().getMorethanoncePlusSignKeyword_3_0());
+ }
+
+ {
+ if ($current==null) {
+ $current = createModelElement(grammarAccess.getRepeatedSequenceRule());
+ }
+ setWithLastConsumed($current, "morethanonce", true, "+");
+ }
+
+)
+)?)
+;
+
+
+
+
+
+RULE_ID : ('a'..'z'|'A'..'Z'|'_') ('a'..'z'|'A'..'Z'|'0'..'9'|'_')*;
+
+RULE_INT : ('0'..'9')+;
+
+RULE_WS : (' '|'\t'|'\r'? '\n')+;
+
+RULE_COLON : '"' '"' '"';
+
+RULE_STRING : ('"' ~('"')* '"'|'\'' ~('\'')* '\'');
+
+RULE_SECTIONHEADER : ('a'..'z'|'A'..'Z') ('.'|'0'..'9')+ (' '|'\t') ~(('\n'|'\r'))* '\r'? '\n';
+
+RULE_SL_COMMENT : '//' ~(('\n'|'\r'))* ('\r'? '\n')?;
+
+RULE_ML_COMMENT : '/*' ( options {greedy=false;} : . )*'*/';
+
+RULE_LOGIC : ('/and'|'/or'|'/andr'|'/orr'|'/any'|'/together');
+
+
Index: /v2/trunk/de.ugoe.cs.swe.bnftools.ebnf/src-gen/de/ugoe/cs/swe/bnftools/parser/antlr/internal/InternalEbnf.tokens
===================================================================
--- /v2/trunk/de.ugoe.cs.swe.bnftools.ebnf/src-gen/de/ugoe/cs/swe/bnftools/parser/antlr/internal/InternalEbnf.tokens (revision 61)
+++ /v2/trunk/de.ugoe.cs.swe.bnftools.ebnf/src-gen/de/ugoe/cs/swe/bnftools/parser/antlr/internal/InternalEbnf.tokens (revision 61)
@@ -0,0 +1,63 @@
+RULE_ID=4
+RULE_SECTIONHEADER=5
+T__29=29
+T__28=28
+T__27=27
+T__26=26
+T__25=25
+T__24=24
+T__23=23
+T__22=22
+T__21=21
+T__20=20
+RULE_SL_COMMENT=11
+RULE_ML_COMMENT=12
+T__30=30
+T__19=19
+RULE_COLON=9
+T__31=31
+RULE_STRING=6
+T__32=32
+T__33=33
+T__16=16
+T__34=34
+T__15=15
+T__35=35
+T__18=18
+T__36=36
+T__17=17
+RULE_LOGIC=8
+T__37=37
+T__38=38
+T__39=39
+T__14=14
+T__13=13
+RULE_INT=7
+RULE_WS=10
+'update'=22
+'|'=31
+'::='=25
+'/'=19
+';'=15
+'grammar'=13
+'global'=36
+'core'=20
+'+'=35
+'.'=24
+')'=27
+'import'=18
+'hook'=39
+'<-'=28
+'}'=30
+'rule'=38
+'/delta'=16
+'/merge'=17
+'/bnf'=14
+'{'=33
+'package'=21
+'label:'=23
+'combinator:'=37
+'('=26
+'['=32
+'*'=34
+']'=29
Index: /v2/trunk/de.ugoe.cs.swe.bnftools.ebnf/src-gen/de/ugoe/cs/swe/bnftools/parser/antlr/internal/InternalEbnfLexer.java
===================================================================
--- /v2/trunk/de.ugoe.cs.swe.bnftools.ebnf/src-gen/de/ugoe/cs/swe/bnftools/parser/antlr/internal/InternalEbnfLexer.java (revision 61)
+++ /v2/trunk/de.ugoe.cs.swe.bnftools.ebnf/src-gen/de/ugoe/cs/swe/bnftools/parser/antlr/internal/InternalEbnfLexer.java (revision 61)
@@ -0,0 +1,1837 @@
+package de.ugoe.cs.swe.bnftools.parser.antlr.internal;
+
+// Hack: Use our own Lexer superclass by means of import.
+// Currently there is no other way to specify the superclass for the lexer.
+import org.eclipse.xtext.parser.antlr.Lexer;
+
+
+import org.antlr.runtime.*;
+import java.util.Stack;
+import java.util.List;
+import java.util.ArrayList;
+
+@SuppressWarnings("all")
+public class InternalEbnfLexer extends Lexer {
+ public static final int RULE_ID=4;
+ public static final int RULE_SECTIONHEADER=5;
+ public static final int T__29=29;
+ public static final int T__28=28;
+ public static final int T__27=27;
+ public static final int T__26=26;
+ public static final int T__25=25;
+ public static final int T__24=24;
+ public static final int T__23=23;
+ public static final int T__22=22;
+ public static final int T__21=21;
+ public static final int T__20=20;
+ public static final int EOF=-1;
+ public static final int RULE_SL_COMMENT=11;
+ public static final int RULE_ML_COMMENT=12;
+ public static final int T__19=19;
+ public static final int T__30=30;
+ public static final int T__31=31;
+ public static final int RULE_COLON=9;
+ public static final int T__32=32;
+ public static final int RULE_STRING=6;
+ public static final int T__16=16;
+ public static final int T__33=33;
+ public static final int T__15=15;
+ public static final int T__34=34;
+ public static final int T__18=18;
+ public static final int T__35=35;
+ public static final int T__17=17;
+ public static final int T__36=36;
+ public static final int T__37=37;
+ public static final int RULE_LOGIC=8;
+ public static final int T__38=38;
+ public static final int T__14=14;
+ public static final int T__39=39;
+ public static final int T__13=13;
+ public static final int RULE_INT=7;
+ public static final int RULE_WS=10;
+
+ // delegates
+ // delegators
+
+ public InternalEbnfLexer() {;}
+ public InternalEbnfLexer(CharStream input) {
+ this(input, new RecognizerSharedState());
+ }
+ public InternalEbnfLexer(CharStream input, RecognizerSharedState state) {
+ super(input,state);
+
+ }
+ public String getGrammarFileName() { return "../de.ugoe.cs.swe.bnftools.ebnf/src-gen/de/ugoe/cs/swe/bnftools/parser/antlr/internal/InternalEbnf.g"; }
+
+ // $ANTLR start "T__13"
+ public final void mT__13() throws RecognitionException {
+ try {
+ int _type = T__13;
+ int _channel = DEFAULT_TOKEN_CHANNEL;
+ // ../de.ugoe.cs.swe.bnftools.ebnf/src-gen/de/ugoe/cs/swe/bnftools/parser/antlr/internal/InternalEbnf.g:11:7: ( 'grammar' )
+ // ../de.ugoe.cs.swe.bnftools.ebnf/src-gen/de/ugoe/cs/swe/bnftools/parser/antlr/internal/InternalEbnf.g:11:9: 'grammar'
+ {
+ match("grammar");
+
+
+ }
+
+ state.type = _type;
+ state.channel = _channel;
+ }
+ finally {
+ }
+ }
+ // $ANTLR end "T__13"
+
+ // $ANTLR start "T__14"
+ public final void mT__14() throws RecognitionException {
+ try {
+ int _type = T__14;
+ int _channel = DEFAULT_TOKEN_CHANNEL;
+ // ../de.ugoe.cs.swe.bnftools.ebnf/src-gen/de/ugoe/cs/swe/bnftools/parser/antlr/internal/InternalEbnf.g:12:7: ( '/bnf' )
+ // ../de.ugoe.cs.swe.bnftools.ebnf/src-gen/de/ugoe/cs/swe/bnftools/parser/antlr/internal/InternalEbnf.g:12:9: '/bnf'
+ {
+ match("/bnf");
+
+
+ }
+
+ state.type = _type;
+ state.channel = _channel;
+ }
+ finally {
+ }
+ }
+ // $ANTLR end "T__14"
+
+ // $ANTLR start "T__15"
+ public final void mT__15() throws RecognitionException {
+ try {
+ int _type = T__15;
+ int _channel = DEFAULT_TOKEN_CHANNEL;
+ // ../de.ugoe.cs.swe.bnftools.ebnf/src-gen/de/ugoe/cs/swe/bnftools/parser/antlr/internal/InternalEbnf.g:13:7: ( ';' )
+ // ../de.ugoe.cs.swe.bnftools.ebnf/src-gen/de/ugoe/cs/swe/bnftools/parser/antlr/internal/InternalEbnf.g:13:9: ';'
+ {
+ match(';');
+
+ }
+
+ state.type = _type;
+ state.channel = _channel;
+ }
+ finally {
+ }
+ }
+ // $ANTLR end "T__15"
+
+ // $ANTLR start "T__16"
+ public final void mT__16() throws RecognitionException {
+ try {
+ int _type = T__16;
+ int _channel = DEFAULT_TOKEN_CHANNEL;
+ // ../de.ugoe.cs.swe.bnftools.ebnf/src-gen/de/ugoe/cs/swe/bnftools/parser/antlr/internal/InternalEbnf.g:14:7: ( '/delta' )
+ // ../de.ugoe.cs.swe.bnftools.ebnf/src-gen/de/ugoe/cs/swe/bnftools/parser/antlr/internal/InternalEbnf.g:14:9: '/delta'
+ {
+ match("/delta");
+
+
+ }
+
+ state.type = _type;
+ state.channel = _channel;
+ }
+ finally {
+ }
+ }
+ // $ANTLR end "T__16"
+
+ // $ANTLR start "T__17"
+ public final void mT__17() throws RecognitionException {
+ try {
+ int _type = T__17;
+ int _channel = DEFAULT_TOKEN_CHANNEL;
+ // ../de.ugoe.cs.swe.bnftools.ebnf/src-gen/de/ugoe/cs/swe/bnftools/parser/antlr/internal/InternalEbnf.g:15:7: ( '/merge' )
+ // ../de.ugoe.cs.swe.bnftools.ebnf/src-gen/de/ugoe/cs/swe/bnftools/parser/antlr/internal/InternalEbnf.g:15:9: '/merge'
+ {
+ match("/merge");
+
+
+ }
+
+ state.type = _type;
+ state.channel = _channel;
+ }
+ finally {
+ }
+ }
+ // $ANTLR end "T__17"
+
+ // $ANTLR start "T__18"
+ public final void mT__18() throws RecognitionException {
+ try {
+ int _type = T__18;
+ int _channel = DEFAULT_TOKEN_CHANNEL;
+ // ../de.ugoe.cs.swe.bnftools.ebnf/src-gen/de/ugoe/cs/swe/bnftools/parser/antlr/internal/InternalEbnf.g:16:7: ( 'import' )
+ // ../de.ugoe.cs.swe.bnftools.ebnf/src-gen/de/ugoe/cs/swe/bnftools/parser/antlr/internal/InternalEbnf.g:16:9: 'import'
+ {
+ match("import");
+
+
+ }
+
+ state.type = _type;
+ state.channel = _channel;
+ }
+ finally {
+ }
+ }
+ // $ANTLR end "T__18"
+
+ // $ANTLR start "T__19"
+ public final void mT__19() throws RecognitionException {
+ try {
+ int _type = T__19;
+ int _channel = DEFAULT_TOKEN_CHANNEL;
+ // ../de.ugoe.cs.swe.bnftools.ebnf/src-gen/de/ugoe/cs/swe/bnftools/parser/antlr/internal/InternalEbnf.g:17:7: ( '/' )
+ // ../de.ugoe.cs.swe.bnftools.ebnf/src-gen/de/ugoe/cs/swe/bnftools/parser/antlr/internal/InternalEbnf.g:17:9: '/'
+ {
+ match('/');
+
+ }
+
+ state.type = _type;
+ state.channel = _channel;
+ }
+ finally {
+ }
+ }
+ // $ANTLR end "T__19"
+
+ // $ANTLR start "T__20"
+ public final void mT__20() throws RecognitionException {
+ try {
+ int _type = T__20;
+ int _channel = DEFAULT_TOKEN_CHANNEL;
+ // ../de.ugoe.cs.swe.bnftools.ebnf/src-gen/de/ugoe/cs/swe/bnftools/parser/antlr/internal/InternalEbnf.g:18:7: ( 'core' )
+ // ../de.ugoe.cs.swe.bnftools.ebnf/src-gen/de/ugoe/cs/swe/bnftools/parser/antlr/internal/InternalEbnf.g:18:9: 'core'
+ {
+ match("core");
+
+
+ }
+
+ state.type = _type;
+ state.channel = _channel;
+ }
+ finally {
+ }
+ }
+ // $ANTLR end "T__20"
+
+ // $ANTLR start "T__21"
+ public final void mT__21() throws RecognitionException {
+ try {
+ int _type = T__21;
+ int _channel = DEFAULT_TOKEN_CHANNEL;
+ // ../de.ugoe.cs.swe.bnftools.ebnf/src-gen/de/ugoe/cs/swe/bnftools/parser/antlr/internal/InternalEbnf.g:19:7: ( 'package' )
+ // ../de.ugoe.cs.swe.bnftools.ebnf/src-gen/de/ugoe/cs/swe/bnftools/parser/antlr/internal/InternalEbnf.g:19:9: 'package'
+ {
+ match("package");
+
+
+ }
+
+ state.type = _type;
+ state.channel = _channel;
+ }
+ finally {
+ }
+ }
+ // $ANTLR end "T__21"
+
+ // $ANTLR start "T__22"
+ public final void mT__22() throws RecognitionException {
+ try {
+ int _type = T__22;
+ int _channel = DEFAULT_TOKEN_CHANNEL;
+ // ../de.ugoe.cs.swe.bnftools.ebnf/src-gen/de/ugoe/cs/swe/bnftools/parser/antlr/internal/InternalEbnf.g:20:7: ( 'update' )
+ // ../de.ugoe.cs.swe.bnftools.ebnf/src-gen/de/ugoe/cs/swe/bnftools/parser/antlr/internal/InternalEbnf.g:20:9: 'update'
+ {
+ match("update");
+
+
+ }
+
+ state.type = _type;
+ state.channel = _channel;
+ }
+ finally {
+ }
+ }
+ // $ANTLR end "T__22"
+
+ // $ANTLR start "T__23"
+ public final void mT__23() throws RecognitionException {
+ try {
+ int _type = T__23;
+ int _channel = DEFAULT_TOKEN_CHANNEL;
+ // ../de.ugoe.cs.swe.bnftools.ebnf/src-gen/de/ugoe/cs/swe/bnftools/parser/antlr/internal/InternalEbnf.g:21:7: ( 'label:' )
+ // ../de.ugoe.cs.swe.bnftools.ebnf/src-gen/de/ugoe/cs/swe/bnftools/parser/antlr/internal/InternalEbnf.g:21:9: 'label:'
+ {
+ match("label:");
+
+
+ }
+
+ state.type = _type;
+ state.channel = _channel;
+ }
+ finally {
+ }
+ }
+ // $ANTLR end "T__23"
+
+ // $ANTLR start "T__24"
+ public final void mT__24() throws RecognitionException {
+ try {
+ int _type = T__24;
+ int _channel = DEFAULT_TOKEN_CHANNEL;
+ // ../de.ugoe.cs.swe.bnftools.ebnf/src-gen/de/ugoe/cs/swe/bnftools/parser/antlr/internal/InternalEbnf.g:22:7: ( '.' )
+ // ../de.ugoe.cs.swe.bnftools.ebnf/src-gen/de/ugoe/cs/swe/bnftools/parser/antlr/internal/InternalEbnf.g:22:9: '.'
+ {
+ match('.');
+
+ }
+
+ state.type = _type;
+ state.channel = _channel;
+ }
+ finally {
+ }
+ }
+ // $ANTLR end "T__24"
+
+ // $ANTLR start "T__25"
+ public final void mT__25() throws RecognitionException {
+ try {
+ int _type = T__25;
+ int _channel = DEFAULT_TOKEN_CHANNEL;
+ // ../de.ugoe.cs.swe.bnftools.ebnf/src-gen/de/ugoe/cs/swe/bnftools/parser/antlr/internal/InternalEbnf.g:23:7: ( '::=' )
+ // ../de.ugoe.cs.swe.bnftools.ebnf/src-gen/de/ugoe/cs/swe/bnftools/parser/antlr/internal/InternalEbnf.g:23:9: '::='
+ {
+ match("::=");
+
+
+ }
+
+ state.type = _type;
+ state.channel = _channel;
+ }
+ finally {
+ }
+ }
+ // $ANTLR end "T__25"
+
+ // $ANTLR start "T__26"
+ public final void mT__26() throws RecognitionException {
+ try {
+ int _type = T__26;
+ int _channel = DEFAULT_TOKEN_CHANNEL;
+ // ../de.ugoe.cs.swe.bnftools.ebnf/src-gen/de/ugoe/cs/swe/bnftools/parser/antlr/internal/InternalEbnf.g:24:7: ( '(' )
+ // ../de.ugoe.cs.swe.bnftools.ebnf/src-gen/de/ugoe/cs/swe/bnftools/parser/antlr/internal/InternalEbnf.g:24:9: '('
+ {
+ match('(');
+
+ }
+
+ state.type = _type;
+ state.channel = _channel;
+ }
+ finally {
+ }
+ }
+ // $ANTLR end "T__26"
+
+ // $ANTLR start "T__27"
+ public final void mT__27() throws RecognitionException {
+ try {
+ int _type = T__27;
+ int _channel = DEFAULT_TOKEN_CHANNEL;
+ // ../de.ugoe.cs.swe.bnftools.ebnf/src-gen/de/ugoe/cs/swe/bnftools/parser/antlr/internal/InternalEbnf.g:25:7: ( ')' )
+ // ../de.ugoe.cs.swe.bnftools.ebnf/src-gen/de/ugoe/cs/swe/bnftools/parser/antlr/internal/InternalEbnf.g:25:9: ')'
+ {
+ match(')');
+
+ }
+
+ state.type = _type;
+ state.channel = _channel;
+ }
+ finally {
+ }
+ }
+ // $ANTLR end "T__27"
+
+ // $ANTLR start "T__28"
+ public final void mT__28() throws RecognitionException {
+ try {
+ int _type = T__28;
+ int _channel = DEFAULT_TOKEN_CHANNEL;
+ // ../de.ugoe.cs.swe.bnftools.ebnf/src-gen/de/ugoe/cs/swe/bnftools/parser/antlr/internal/InternalEbnf.g:26:7: ( '<-' )
+ // ../de.ugoe.cs.swe.bnftools.ebnf/src-gen/de/ugoe/cs/swe/bnftools/parser/antlr/internal/InternalEbnf.g:26:9: '<-'
+ {
+ match("<-");
+
+
+ }
+
+ state.type = _type;
+ state.channel = _channel;
+ }
+ finally {
+ }
+ }
+ // $ANTLR end "T__28"
+
+ // $ANTLR start "T__29"
+ public final void mT__29() throws RecognitionException {
+ try {
+ int _type = T__29;
+ int _channel = DEFAULT_TOKEN_CHANNEL;
+ // ../de.ugoe.cs.swe.bnftools.ebnf/src-gen/de/ugoe/cs/swe/bnftools/parser/antlr/internal/InternalEbnf.g:27:7: ( ']' )
+ // ../de.ugoe.cs.swe.bnftools.ebnf/src-gen/de/ugoe/cs/swe/bnftools/parser/antlr/internal/InternalEbnf.g:27:9: ']'
+ {
+ match(']');
+
+ }
+
+ state.type = _type;
+ state.channel = _channel;
+ }
+ finally {
+ }
+ }
+ // $ANTLR end "T__29"
+
+ // $ANTLR start "T__30"
+ public final void mT__30() throws RecognitionException {
+ try {
+ int _type = T__30;
+ int _channel = DEFAULT_TOKEN_CHANNEL;
+ // ../de.ugoe.cs.swe.bnftools.ebnf/src-gen/de/ugoe/cs/swe/bnftools/parser/antlr/internal/InternalEbnf.g:28:7: ( '}' )
+ // ../de.ugoe.cs.swe.bnftools.ebnf/src-gen/de/ugoe/cs/swe/bnftools/parser/antlr/internal/InternalEbnf.g:28:9: '}'
+ {
+ match('}');
+
+ }
+
+ state.type = _type;
+ state.channel = _channel;
+ }
+ finally {
+ }
+ }
+ // $ANTLR end "T__30"
+
+ // $ANTLR start "T__31"
+ public final void mT__31() throws RecognitionException {
+ try {
+ int _type = T__31;
+ int _channel = DEFAULT_TOKEN_CHANNEL;
+ // ../de.ugoe.cs.swe.bnftools.ebnf/src-gen/de/ugoe/cs/swe/bnftools/parser/antlr/internal/InternalEbnf.g:29:7: ( '|' )
+ // ../de.ugoe.cs.swe.bnftools.ebnf/src-gen/de/ugoe/cs/swe/bnftools/parser/antlr/internal/InternalEbnf.g:29:9: '|'
+ {
+ match('|');
+
+ }
+
+ state.type = _type;
+ state.channel = _channel;
+ }
+ finally {
+ }
+ }
+ // $ANTLR end "T__31"
+
+ // $ANTLR start "T__32"
+ public final void mT__32() throws RecognitionException {
+ try {
+ int _type = T__32;
+ int _channel = DEFAULT_TOKEN_CHANNEL;
+ // ../de.ugoe.cs.swe.bnftools.ebnf/src-gen/de/ugoe/cs/swe/bnftools/parser/antlr/internal/InternalEbnf.g:30:7: ( '[' )
+ // ../de.ugoe.cs.swe.bnftools.ebnf/src-gen/de/ugoe/cs/swe/bnftools/parser/antlr/internal/InternalEbnf.g:30:9: '['
+ {
+ match('[');
+
+ }
+
+ state.type = _type;
+ state.channel = _channel;
+ }
+ finally {
+ }
+ }
+ // $ANTLR end "T__32"
+
+ // $ANTLR start "T__33"
+ public final void mT__33() throws RecognitionException {
+ try {
+ int _type = T__33;
+ int _channel = DEFAULT_TOKEN_CHANNEL;
+ // ../de.ugoe.cs.swe.bnftools.ebnf/src-gen/de/ugoe/cs/swe/bnftools/parser/antlr/internal/InternalEbnf.g:31:7: ( '{' )
+ // ../de.ugoe.cs.swe.bnftools.ebnf/src-gen/de/ugoe/cs/swe/bnftools/parser/antlr/internal/InternalEbnf.g:31:9: '{'
+ {
+ match('{');
+
+ }
+
+ state.type = _type;
+ state.channel = _channel;
+ }
+ finally {
+ }
+ }
+ // $ANTLR end "T__33"
+
+ // $ANTLR start "T__34"
+ public final void mT__34() throws RecognitionException {
+ try {
+ int _type = T__34;
+ int _channel = DEFAULT_TOKEN_CHANNEL;
+ // ../de.ugoe.cs.swe.bnftools.ebnf/src-gen/de/ugoe/cs/swe/bnftools/parser/antlr/internal/InternalEbnf.g:32:7: ( '*' )
+ // ../de.ugoe.cs.swe.bnftools.ebnf/src-gen/de/ugoe/cs/swe/bnftools/parser/antlr/internal/InternalEbnf.g:32:9: '*'
+ {
+ match('*');
+
+ }
+
+ state.type = _type;
+ state.channel = _channel;
+ }
+ finally {
+ }
+ }
+ // $ANTLR end "T__34"
+
+ // $ANTLR start "T__35"
+ public final void mT__35() throws RecognitionException {
+ try {
+ int _type = T__35;
+ int _channel = DEFAULT_TOKEN_CHANNEL;
+ // ../de.ugoe.cs.swe.bnftools.ebnf/src-gen/de/ugoe/cs/swe/bnftools/parser/antlr/internal/InternalEbnf.g:33:7: ( '+' )
+ // ../de.ugoe.cs.swe.bnftools.ebnf/src-gen/de/ugoe/cs/swe/bnftools/parser/antlr/internal/InternalEbnf.g:33:9: '+'
+ {
+ match('+');
+
+ }
+
+ state.type = _type;
+ state.channel = _channel;
+ }
+ finally {
+ }
+ }
+ // $ANTLR end "T__35"
+
+ // $ANTLR start "T__36"
+ public final void mT__36() throws RecognitionException {
+ try {
+ int _type = T__36;
+ int _channel = DEFAULT_TOKEN_CHANNEL;
+ // ../de.ugoe.cs.swe.bnftools.ebnf/src-gen/de/ugoe/cs/swe/bnftools/parser/antlr/internal/InternalEbnf.g:34:7: ( 'global' )
+ // ../de.ugoe.cs.swe.bnftools.ebnf/src-gen/de/ugoe/cs/swe/bnftools/parser/antlr/internal/InternalEbnf.g:34:9: 'global'
+ {
+ match("global");
+
+
+ }
+
+ state.type = _type;
+ state.channel = _channel;
+ }
+ finally {
+ }
+ }
+ // $ANTLR end "T__36"
+
+ // $ANTLR start "T__37"
+ public final void mT__37() throws RecognitionException {
+ try {
+ int _type = T__37;
+ int _channel = DEFAULT_TOKEN_CHANNEL;
+ // ../de.ugoe.cs.swe.bnftools.ebnf/src-gen/de/ugoe/cs/swe/bnftools/parser/antlr/internal/InternalEbnf.g:35:7: ( 'combinator:' )
+ // ../de.ugoe.cs.swe.bnftools.ebnf/src-gen/de/ugoe/cs/swe/bnftools/parser/antlr/internal/InternalEbnf.g:35:9: 'combinator:'
+ {
+ match("combinator:");
+
+
+ }
+
+ state.type = _type;
+ state.channel = _channel;
+ }
+ finally {
+ }
+ }
+ // $ANTLR end "T__37"
+
+ // $ANTLR start "T__38"
+ public final void mT__38() throws RecognitionException {
+ try {
+ int _type = T__38;
+ int _channel = DEFAULT_TOKEN_CHANNEL;
+ // ../de.ugoe.cs.swe.bnftools.ebnf/src-gen/de/ugoe/cs/swe/bnftools/parser/antlr/internal/InternalEbnf.g:36:7: ( 'rule' )
+ // ../de.ugoe.cs.swe.bnftools.ebnf/src-gen/de/ugoe/cs/swe/bnftools/parser/antlr/internal/InternalEbnf.g:36:9: 'rule'
+ {
+ match("rule");
+
+
+ }
+
+ state.type = _type;
+ state.channel = _channel;
+ }
+ finally {
+ }
+ }
+ // $ANTLR end "T__38"
+
+ // $ANTLR start "T__39"
+ public final void mT__39() throws RecognitionException {
+ try {
+ int _type = T__39;
+ int _channel = DEFAULT_TOKEN_CHANNEL;
+ // ../de.ugoe.cs.swe.bnftools.ebnf/src-gen/de/ugoe/cs/swe/bnftools/parser/antlr/internal/InternalEbnf.g:37:7: ( 'hook' )
+ // ../de.ugoe.cs.swe.bnftools.ebnf/src-gen/de/ugoe/cs/swe/bnftools/parser/antlr/internal/InternalEbnf.g:37:9: 'hook'
+ {
+ match("hook");
+
+
+ }
+
+ state.type = _type;
+ state.channel = _channel;
+ }
+ finally {
+ }
+ }
+ // $ANTLR end "T__39"
+
+ // $ANTLR start "RULE_ID"
+ public final void mRULE_ID() throws RecognitionException {
+ try {
+ int _type = RULE_ID;
+ int _channel = DEFAULT_TOKEN_CHANNEL;
+ // ../de.ugoe.cs.swe.bnftools.ebnf/src-gen/de/ugoe/cs/swe/bnftools/parser/antlr/internal/InternalEbnf.g:1773:9: ( ( 'a' .. 'z' | 'A' .. 'Z' | '_' ) ( 'a' .. 'z' | 'A' .. 'Z' | '0' .. '9' | '_' )* )
+ // ../de.ugoe.cs.swe.bnftools.ebnf/src-gen/de/ugoe/cs/swe/bnftools/parser/antlr/internal/InternalEbnf.g:1773:11: ( 'a' .. 'z' | 'A' .. 'Z' | '_' ) ( 'a' .. 'z' | 'A' .. 'Z' | '0' .. '9' | '_' )*
+ {
+ if ( (input.LA(1)>='A' && input.LA(1)<='Z')||input.LA(1)=='_'||(input.LA(1)>='a' && input.LA(1)<='z') ) {
+ input.consume();
+
+ }
+ else {
+ MismatchedSetException mse = new MismatchedSetException(null,input);
+ recover(mse);
+ throw mse;}
+
+ // ../de.ugoe.cs.swe.bnftools.ebnf/src-gen/de/ugoe/cs/swe/bnftools/parser/antlr/internal/InternalEbnf.g:1773:35: ( 'a' .. 'z' | 'A' .. 'Z' | '0' .. '9' | '_' )*
+ loop1:
+ do {
+ int alt1=2;
+ int LA1_0 = input.LA(1);
+
+ if ( ((LA1_0>='0' && LA1_0<='9')||(LA1_0>='A' && LA1_0<='Z')||LA1_0=='_'||(LA1_0>='a' && LA1_0<='z')) ) {
+ alt1=1;
+ }
+
+
+ switch (alt1) {
+ case 1 :
+ // ../de.ugoe.cs.swe.bnftools.ebnf/src-gen/de/ugoe/cs/swe/bnftools/parser/antlr/internal/InternalEbnf.g:
+ {
+ if ( (input.LA(1)>='0' && input.LA(1)<='9')||(input.LA(1)>='A' && input.LA(1)<='Z')||input.LA(1)=='_'||(input.LA(1)>='a' && input.LA(1)<='z') ) {
+ input.consume();
+
+ }
+ else {
+ MismatchedSetException mse = new MismatchedSetException(null,input);
+ recover(mse);
+ throw mse;}
+
+
+ }
+ break;
+
+ default :
+ break loop1;
+ }
+ } while (true);
+
+
+ }
+
+ state.type = _type;
+ state.channel = _channel;
+ }
+ finally {
+ }
+ }
+ // $ANTLR end "RULE_ID"
+
+ // $ANTLR start "RULE_INT"
+ public final void mRULE_INT() throws RecognitionException {
+ try {
+ int _type = RULE_INT;
+ int _channel = DEFAULT_TOKEN_CHANNEL;
+ // ../de.ugoe.cs.swe.bnftools.ebnf/src-gen/de/ugoe/cs/swe/bnftools/parser/antlr/internal/InternalEbnf.g:1775:10: ( ( '0' .. '9' )+ )
+ // ../de.ugoe.cs.swe.bnftools.ebnf/src-gen/de/ugoe/cs/swe/bnftools/parser/antlr/internal/InternalEbnf.g:1775:12: ( '0' .. '9' )+
+ {
+ // ../de.ugoe.cs.swe.bnftools.ebnf/src-gen/de/ugoe/cs/swe/bnftools/parser/antlr/internal/InternalEbnf.g:1775:12: ( '0' .. '9' )+
+ int cnt2=0;
+ loop2:
+ do {
+ int alt2=2;
+ int LA2_0 = input.LA(1);
+
+ if ( ((LA2_0>='0' && LA2_0<='9')) ) {
+ alt2=1;
+ }
+
+
+ switch (alt2) {
+ case 1 :
+ // ../de.ugoe.cs.swe.bnftools.ebnf/src-gen/de/ugoe/cs/swe/bnftools/parser/antlr/internal/InternalEbnf.g:1775:13: '0' .. '9'
+ {
+ matchRange('0','9');
+
+ }
+ break;
+
+ default :
+ if ( cnt2 >= 1 ) break loop2;
+ EarlyExitException eee =
+ new EarlyExitException(2, input);
+ throw eee;
+ }
+ cnt2++;
+ } while (true);
+
+
+ }
+
+ state.type = _type;
+ state.channel = _channel;
+ }
+ finally {
+ }
+ }
+ // $ANTLR end "RULE_INT"
+
+ // $ANTLR start "RULE_WS"
+ public final void mRULE_WS() throws RecognitionException {
+ try {
+ int _type = RULE_WS;
+ int _channel = DEFAULT_TOKEN_CHANNEL;
+ // ../de.ugoe.cs.swe.bnftools.ebnf/src-gen/de/ugoe/cs/swe/bnftools/parser/antlr/internal/InternalEbnf.g:1777:9: ( ( ' ' | '\\t' | ( '\\r' )? '\\n' )+ )
+ // ../de.ugoe.cs.swe.bnftools.ebnf/src-gen/de/ugoe/cs/swe/bnftools/parser/antlr/internal/InternalEbnf.g:1777:11: ( ' ' | '\\t' | ( '\\r' )? '\\n' )+
+ {
+ // ../de.ugoe.cs.swe.bnftools.ebnf/src-gen/de/ugoe/cs/swe/bnftools/parser/antlr/internal/InternalEbnf.g:1777:11: ( ' ' | '\\t' | ( '\\r' )? '\\n' )+
+ int cnt4=0;
+ loop4:
+ do {
+ int alt4=4;
+ switch ( input.LA(1) ) {
+ case ' ':
+ {
+ alt4=1;
+ }
+ break;
+ case '\t':
+ {
+ alt4=2;
+ }
+ break;
+ case '\n':
+ case '\r':
+ {
+ alt4=3;
+ }
+ break;
+
+ }
+
+ switch (alt4) {
+ case 1 :
+ // ../de.ugoe.cs.swe.bnftools.ebnf/src-gen/de/ugoe/cs/swe/bnftools/parser/antlr/internal/InternalEbnf.g:1777:12: ' '
+ {
+ match(' ');
+
+ }
+ break;
+ case 2 :
+ // ../de.ugoe.cs.swe.bnftools.ebnf/src-gen/de/ugoe/cs/swe/bnftools/parser/antlr/internal/InternalEbnf.g:1777:16: '\\t'
+ {
+ match('\t');
+
+ }
+ break;
+ case 3 :
+ // ../de.ugoe.cs.swe.bnftools.ebnf/src-gen/de/ugoe/cs/swe/bnftools/parser/antlr/internal/InternalEbnf.g:1777:21: ( '\\r' )? '\\n'
+ {
+ // ../de.ugoe.cs.swe.bnftools.ebnf/src-gen/de/ugoe/cs/swe/bnftools/parser/antlr/internal/InternalEbnf.g:1777:21: ( '\\r' )?
+ int alt3=2;
+ int LA3_0 = input.LA(1);
+
+ if ( (LA3_0=='\r') ) {
+ alt3=1;
+ }
+ switch (alt3) {
+ case 1 :
+ // ../de.ugoe.cs.swe.bnftools.ebnf/src-gen/de/ugoe/cs/swe/bnftools/parser/antlr/internal/InternalEbnf.g:1777:21: '\\r'
+ {
+ match('\r');
+
+ }
+ break;
+
+ }
+
+ match('\n');
+
+ }
+ break;
+
+ default :
+ if ( cnt4 >= 1 ) break loop4;
+ EarlyExitException eee =
+ new EarlyExitException(4, input);
+ throw eee;
+ }
+ cnt4++;
+ } while (true);
+
+
+ }
+
+ state.type = _type;
+ state.channel = _channel;
+ }
+ finally {
+ }
+ }
+ // $ANTLR end "RULE_WS"
+
+ // $ANTLR start "RULE_COLON"
+ public final void mRULE_COLON() throws RecognitionException {
+ try {
+ int _type = RULE_COLON;
+ int _channel = DEFAULT_TOKEN_CHANNEL;
+ // ../de.ugoe.cs.swe.bnftools.ebnf/src-gen/de/ugoe/cs/swe/bnftools/parser/antlr/internal/InternalEbnf.g:1779:12: ( '\"' '\"' '\"' )
+ // ../de.ugoe.cs.swe.bnftools.ebnf/src-gen/de/ugoe/cs/swe/bnftools/parser/antlr/internal/InternalEbnf.g:1779:14: '\"' '\"' '\"'
+ {
+ match('\"');
+ match('\"');
+ match('\"');
+
+ }
+
+ state.type = _type;
+ state.channel = _channel;
+ }
+ finally {
+ }
+ }
+ // $ANTLR end "RULE_COLON"
+
+ // $ANTLR start "RULE_STRING"
+ public final void mRULE_STRING() throws RecognitionException {
+ try {
+ int _type = RULE_STRING;
+ int _channel = DEFAULT_TOKEN_CHANNEL;
+ // ../de.ugoe.cs.swe.bnftools.ebnf/src-gen/de/ugoe/cs/swe/bnftools/parser/antlr/internal/InternalEbnf.g:1781:13: ( ( '\"' (~ ( '\"' ) )* '\"' | '\\'' (~ ( '\\'' ) )* '\\'' ) )
+ // ../de.ugoe.cs.swe.bnftools.ebnf/src-gen/de/ugoe/cs/swe/bnftools/parser/antlr/internal/InternalEbnf.g:1781:15: ( '\"' (~ ( '\"' ) )* '\"' | '\\'' (~ ( '\\'' ) )* '\\'' )
+ {
+ // ../de.ugoe.cs.swe.bnftools.ebnf/src-gen/de/ugoe/cs/swe/bnftools/parser/antlr/internal/InternalEbnf.g:1781:15: ( '\"' (~ ( '\"' ) )* '\"' | '\\'' (~ ( '\\'' ) )* '\\'' )
+ int alt7=2;
+ int LA7_0 = input.LA(1);
+
+ if ( (LA7_0=='\"') ) {
+ alt7=1;
+ }
+ else if ( (LA7_0=='\'') ) {
+ alt7=2;
+ }
+ else {
+ NoViableAltException nvae =
+ new NoViableAltException("", 7, 0, input);
+
+ throw nvae;
+ }
+ switch (alt7) {
+ case 1 :
+ // ../de.ugoe.cs.swe.bnftools.ebnf/src-gen/de/ugoe/cs/swe/bnftools/parser/antlr/internal/InternalEbnf.g:1781:16: '\"' (~ ( '\"' ) )* '\"'
+ {
+ match('\"');
+ // ../de.ugoe.cs.swe.bnftools.ebnf/src-gen/de/ugoe/cs/swe/bnftools/parser/antlr/internal/InternalEbnf.g:1781:20: (~ ( '\"' ) )*
+ loop5:
+ do {
+ int alt5=2;
+ int LA5_0 = input.LA(1);
+
+ if ( ((LA5_0>='\u0000' && LA5_0<='!')||(LA5_0>='#' && LA5_0<='\uFFFF')) ) {
+ alt5=1;
+ }
+
+
+ switch (alt5) {
+ case 1 :
+ // ../de.ugoe.cs.swe.bnftools.ebnf/src-gen/de/ugoe/cs/swe/bnftools/parser/antlr/internal/InternalEbnf.g:1781:20: ~ ( '\"' )
+ {
+ if ( (input.LA(1)>='\u0000' && input.LA(1)<='!')||(input.LA(1)>='#' && input.LA(1)<='\uFFFF') ) {
+ input.consume();
+
+ }
+ else {
+ MismatchedSetException mse = new MismatchedSetException(null,input);
+ recover(mse);
+ throw mse;}
+
+
+ }
+ break;
+
+ default :
+ break loop5;
+ }
+ } while (true);
+
+ match('\"');
+
+ }
+ break;
+ case 2 :
+ // ../de.ugoe.cs.swe.bnftools.ebnf/src-gen/de/ugoe/cs/swe/bnftools/parser/antlr/internal/InternalEbnf.g:1781:32: '\\'' (~ ( '\\'' ) )* '\\''
+ {
+ match('\'');
+ // ../de.ugoe.cs.swe.bnftools.ebnf/src-gen/de/ugoe/cs/swe/bnftools/parser/antlr/internal/InternalEbnf.g:1781:37: (~ ( '\\'' ) )*
+ loop6:
+ do {
+ int alt6=2;
+ int LA6_0 = input.LA(1);
+
+ if ( ((LA6_0>='\u0000' && LA6_0<='&')||(LA6_0>='(' && LA6_0<='\uFFFF')) ) {
+ alt6=1;
+ }
+
+
+ switch (alt6) {
+ case 1 :
+ // ../de.ugoe.cs.swe.bnftools.ebnf/src-gen/de/ugoe/cs/swe/bnftools/parser/antlr/internal/InternalEbnf.g:1781:37: ~ ( '\\'' )
+ {
+ if ( (input.LA(1)>='\u0000' && input.LA(1)<='&')||(input.LA(1)>='(' && input.LA(1)<='\uFFFF') ) {
+ input.consume();
+
+ }
+ else {
+ MismatchedSetException mse = new MismatchedSetException(null,input);
+ recover(mse);
+ throw mse;}
+
+
+ }
+ break;
+
+ default :
+ break loop6;
+ }
+ } while (true);
+
+ match('\'');
+
+ }
+ break;
+
+ }
+
+
+ }
+
+ state.type = _type;
+ state.channel = _channel;
+ }
+ finally {
+ }
+ }
+ // $ANTLR end "RULE_STRING"
+
+ // $ANTLR start "RULE_SECTIONHEADER"
+ public final void mRULE_SECTIONHEADER() throws RecognitionException {
+ try {
+ int _type = RULE_SECTIONHEADER;
+ int _channel = DEFAULT_TOKEN_CHANNEL;
+ // ../de.ugoe.cs.swe.bnftools.ebnf/src-gen/de/ugoe/cs/swe/bnftools/parser/antlr/internal/InternalEbnf.g:1783:20: ( ( 'a' .. 'z' | 'A' .. 'Z' ) ( '.' | '0' .. '9' )+ ( ' ' | '\\t' ) (~ ( ( '\\n' | '\\r' ) ) )* ( '\\r' )? '\\n' )
+ // ../de.ugoe.cs.swe.bnftools.ebnf/src-gen/de/ugoe/cs/swe/bnftools/parser/antlr/internal/InternalEbnf.g:1783:22: ( 'a' .. 'z' | 'A' .. 'Z' ) ( '.' | '0' .. '9' )+ ( ' ' | '\\t' ) (~ ( ( '\\n' | '\\r' ) ) )* ( '\\r' )? '\\n'
+ {
+ if ( (input.LA(1)>='A' && input.LA(1)<='Z')||(input.LA(1)>='a' && input.LA(1)<='z') ) {
+ input.consume();
+
+ }
+ else {
+ MismatchedSetException mse = new MismatchedSetException(null,input);
+ recover(mse);
+ throw mse;}
+
+ // ../de.ugoe.cs.swe.bnftools.ebnf/src-gen/de/ugoe/cs/swe/bnftools/parser/antlr/internal/InternalEbnf.g:1783:42: ( '.' | '0' .. '9' )+
+ int cnt8=0;
+ loop8:
+ do {
+ int alt8=2;
+ int LA8_0 = input.LA(1);
+
+ if ( (LA8_0=='.'||(LA8_0>='0' && LA8_0<='9')) ) {
+ alt8=1;
+ }
+
+
+ switch (alt8) {
+ case 1 :
+ // ../de.ugoe.cs.swe.bnftools.ebnf/src-gen/de/ugoe/cs/swe/bnftools/parser/antlr/internal/InternalEbnf.g:
+ {
+ if ( input.LA(1)=='.'||(input.LA(1)>='0' && input.LA(1)<='9') ) {
+ input.consume();
+
+ }
+ else {
+ MismatchedSetException mse = new MismatchedSetException(null,input);
+ recover(mse);
+ throw mse;}
+
+
+ }
+ break;
+
+ default :
+ if ( cnt8 >= 1 ) break loop8;
+ EarlyExitException eee =
+ new EarlyExitException(8, input);
+ throw eee;
+ }
+ cnt8++;
+ } while (true);
+
+ if ( input.LA(1)=='\t'||input.LA(1)==' ' ) {
+ input.consume();
+
+ }
+ else {
+ MismatchedSetException mse = new MismatchedSetException(null,input);
+ recover(mse);
+ throw mse;}
+
+ // ../de.ugoe.cs.swe.bnftools.ebnf/src-gen/de/ugoe/cs/swe/bnftools/parser/antlr/internal/InternalEbnf.g:1783:69: (~ ( ( '\\n' | '\\r' ) ) )*
+ loop9:
+ do {
+ int alt9=2;
+ int LA9_0 = input.LA(1);
+
+ if ( ((LA9_0>='\u0000' && LA9_0<='\t')||(LA9_0>='\u000B' && LA9_0<='\f')||(LA9_0>='\u000E' && LA9_0<='\uFFFF')) ) {
+ alt9=1;
+ }
+
+
+ switch (alt9) {
+ case 1 :
+ // ../de.ugoe.cs.swe.bnftools.ebnf/src-gen/de/ugoe/cs/swe/bnftools/parser/antlr/internal/InternalEbnf.g:1783:69: ~ ( ( '\\n' | '\\r' ) )
+ {
+ if ( (input.LA(1)>='\u0000' && input.LA(1)<='\t')||(input.LA(1)>='\u000B' && input.LA(1)<='\f')||(input.LA(1)>='\u000E' && input.LA(1)<='\uFFFF') ) {
+ input.consume();
+
+ }
+ else {
+ MismatchedSetException mse = new MismatchedSetException(null,input);
+ recover(mse);
+ throw mse;}
+
+
+ }
+ break;
+
+ default :
+ break loop9;
+ }
+ } while (true);
+
+ // ../de.ugoe.cs.swe.bnftools.ebnf/src-gen/de/ugoe/cs/swe/bnftools/parser/antlr/internal/InternalEbnf.g:1783:85: ( '\\r' )?
+ int alt10=2;
+ int LA10_0 = input.LA(1);
+
+ if ( (LA10_0=='\r') ) {
+ alt10=1;
+ }
+ switch (alt10) {
+ case 1 :
+ // ../de.ugoe.cs.swe.bnftools.ebnf/src-gen/de/ugoe/cs/swe/bnftools/parser/antlr/internal/InternalEbnf.g:1783:85: '\\r'
+ {
+ match('\r');
+
+ }
+ break;
+
+ }
+
+ match('\n');
+
+ }
+
+ state.type = _type;
+ state.channel = _channel;
+ }
+ finally {
+ }
+ }
+ // $ANTLR end "RULE_SECTIONHEADER"
+
+ // $ANTLR start "RULE_SL_COMMENT"
+ public final void mRULE_SL_COMMENT() throws RecognitionException {
+ try {
+ int _type = RULE_SL_COMMENT;
+ int _channel = DEFAULT_TOKEN_CHANNEL;
+ // ../de.ugoe.cs.swe.bnftools.ebnf/src-gen/de/ugoe/cs/swe/bnftools/parser/antlr/internal/InternalEbnf.g:1785:17: ( '//' (~ ( ( '\\n' | '\\r' ) ) )* ( ( '\\r' )? '\\n' )? )
+ // ../de.ugoe.cs.swe.bnftools.ebnf/src-gen/de/ugoe/cs/swe/bnftools/parser/antlr/internal/InternalEbnf.g:1785:19: '//' (~ ( ( '\\n' | '\\r' ) ) )* ( ( '\\r' )? '\\n' )?
+ {
+ match("//");
+
+ // ../de.ugoe.cs.swe.bnftools.ebnf/src-gen/de/ugoe/cs/swe/bnftools/parser/antlr/internal/InternalEbnf.g:1785:24: (~ ( ( '\\n' | '\\r' ) ) )*
+ loop11:
+ do {
+ int alt11=2;
+ int LA11_0 = input.LA(1);
+
+ if ( ((LA11_0>='\u0000' && LA11_0<='\t')||(LA11_0>='\u000B' && LA11_0<='\f')||(LA11_0>='\u000E' && LA11_0<='\uFFFF')) ) {
+ alt11=1;
+ }
+
+
+ switch (alt11) {
+ case 1 :
+ // ../de.ugoe.cs.swe.bnftools.ebnf/src-gen/de/ugoe/cs/swe/bnftools/parser/antlr/internal/InternalEbnf.g:1785:24: ~ ( ( '\\n' | '\\r' ) )
+ {
+ if ( (input.LA(1)>='\u0000' && input.LA(1)<='\t')||(input.LA(1)>='\u000B' && input.LA(1)<='\f')||(input.LA(1)>='\u000E' && input.LA(1)<='\uFFFF') ) {
+ input.consume();
+
+ }
+ else {
+ MismatchedSetException mse = new MismatchedSetException(null,input);
+ recover(mse);
+ throw mse;}
+
+
+ }
+ break;
+
+ default :
+ break loop11;
+ }
+ } while (true);
+
+ // ../de.ugoe.cs.swe.bnftools.ebnf/src-gen/de/ugoe/cs/swe/bnftools/parser/antlr/internal/InternalEbnf.g:1785:40: ( ( '\\r' )? '\\n' )?
+ int alt13=2;
+ int LA13_0 = input.LA(1);
+
+ if ( (LA13_0=='\n'||LA13_0=='\r') ) {
+ alt13=1;
+ }
+ switch (alt13) {
+ case 1 :
+ // ../de.ugoe.cs.swe.bnftools.ebnf/src-gen/de/ugoe/cs/swe/bnftools/parser/antlr/internal/InternalEbnf.g:1785:41: ( '\\r' )? '\\n'
+ {
+ // ../de.ugoe.cs.swe.bnftools.ebnf/src-gen/de/ugoe/cs/swe/bnftools/parser/antlr/internal/InternalEbnf.g:1785:41: ( '\\r' )?
+ int alt12=2;
+ int LA12_0 = input.LA(1);
+
+ if ( (LA12_0=='\r') ) {
+ alt12=1;
+ }
+ switch (alt12) {
+ case 1 :
+ // ../de.ugoe.cs.swe.bnftools.ebnf/src-gen/de/ugoe/cs/swe/bnftools/parser/antlr/internal/InternalEbnf.g:1785:41: '\\r'
+ {
+ match('\r');
+
+ }
+ break;
+
+ }
+
+ match('\n');
+
+ }
+ break;
+
+ }
+
+
+ }
+
+ state.type = _type;
+ state.channel = _channel;
+ }
+ finally {
+ }
+ }
+ // $ANTLR end "RULE_SL_COMMENT"
+
+ // $ANTLR start "RULE_ML_COMMENT"
+ public final void mRULE_ML_COMMENT() throws RecognitionException {
+ try {
+ int _type = RULE_ML_COMMENT;
+ int _channel = DEFAULT_TOKEN_CHANNEL;
+ // ../de.ugoe.cs.swe.bnftools.ebnf/src-gen/de/ugoe/cs/swe/bnftools/parser/antlr/internal/InternalEbnf.g:1787:17: ( '/*' ( options {greedy=false; } : . )* '*/' )
+ // ../de.ugoe.cs.swe.bnftools.ebnf/src-gen/de/ugoe/cs/swe/bnftools/parser/antlr/internal/InternalEbnf.g:1787:19: '/*' ( options {greedy=false; } : . )* '*/'
+ {
+ match("/*");
+
+ // ../de.ugoe.cs.swe.bnftools.ebnf/src-gen/de/ugoe/cs/swe/bnftools/parser/antlr/internal/InternalEbnf.g:1787:24: ( options {greedy=false; } : . )*
+ loop14:
+ do {
+ int alt14=2;
+ int LA14_0 = input.LA(1);
+
+ if ( (LA14_0=='*') ) {
+ int LA14_1 = input.LA(2);
+
+ if ( (LA14_1=='/') ) {
+ alt14=2;
+ }
+ else if ( ((LA14_1>='\u0000' && LA14_1<='.')||(LA14_1>='0' && LA14_1<='\uFFFF')) ) {
+ alt14=1;
+ }
+
+
+ }
+ else if ( ((LA14_0>='\u0000' && LA14_0<=')')||(LA14_0>='+' && LA14_0<='\uFFFF')) ) {
+ alt14=1;
+ }
+
+
+ switch (alt14) {
+ case 1 :
+ // ../de.ugoe.cs.swe.bnftools.ebnf/src-gen/de/ugoe/cs/swe/bnftools/parser/antlr/internal/InternalEbnf.g:1787:52: .
+ {
+ matchAny();
+
+ }
+ break;
+
+ default :
+ break loop14;
+ }
+ } while (true);
+
+ match("*/");
+
+
+ }
+
+ state.type = _type;
+ state.channel = _channel;
+ }
+ finally {
+ }
+ }
+ // $ANTLR end "RULE_ML_COMMENT"
+
+ // $ANTLR start "RULE_LOGIC"
+ public final void mRULE_LOGIC() throws RecognitionException {
+ try {
+ int _type = RULE_LOGIC;
+ int _channel = DEFAULT_TOKEN_CHANNEL;
+ // ../de.ugoe.cs.swe.bnftools.ebnf/src-gen/de/ugoe/cs/swe/bnftools/parser/antlr/internal/InternalEbnf.g:1789:12: ( ( '/and' | '/or' | '/andr' | '/orr' | '/any' | '/together' ) )
+ // ../de.ugoe.cs.swe.bnftools.ebnf/src-gen/de/ugoe/cs/swe/bnftools/parser/antlr/internal/InternalEbnf.g:1789:14: ( '/and' | '/or' | '/andr' | '/orr' | '/any' | '/together' )
+ {
+ // ../de.ugoe.cs.swe.bnftools.ebnf/src-gen/de/ugoe/cs/swe/bnftools/parser/antlr/internal/InternalEbnf.g:1789:14: ( '/and' | '/or' | '/andr' | '/orr' | '/any' | '/together' )
+ int alt15=6;
+ alt15 = dfa15.predict(input);
+ switch (alt15) {
+ case 1 :
+ // ../de.ugoe.cs.swe.bnftools.ebnf/src-gen/de/ugoe/cs/swe/bnftools/parser/antlr/internal/InternalEbnf.g:1789:15: '/and'
+ {
+ match("/and");
+
+
+ }
+ break;
+ case 2 :
+ // ../de.ugoe.cs.swe.bnftools.ebnf/src-gen/de/ugoe/cs/swe/bnftools/parser/antlr/internal/InternalEbnf.g:1789:22: '/or'
+ {
+ match("/or");
+
+
+ }
+ break;
+ case 3 :
+ // ../de.ugoe.cs.swe.bnftools.ebnf/src-gen/de/ugoe/cs/swe/bnftools/parser/antlr/internal/InternalEbnf.g:1789:28: '/andr'
+ {
+ match("/andr");
+
+
+ }
+ break;
+ case 4 :
+ // ../de.ugoe.cs.swe.bnftools.ebnf/src-gen/de/ugoe/cs/swe/bnftools/parser/antlr/internal/InternalEbnf.g:1789:36: '/orr'
+ {
+ match("/orr");
+
+
+ }
+ break;
+ case 5 :
+ // ../de.ugoe.cs.swe.bnftools.ebnf/src-gen/de/ugoe/cs/swe/bnftools/parser/antlr/internal/InternalEbnf.g:1789:43: '/any'
+ {
+ match("/any");
+
+
+ }
+ break;
+ case 6 :
+ // ../de.ugoe.cs.swe.bnftools.ebnf/src-gen/de/ugoe/cs/swe/bnftools/parser/antlr/internal/InternalEbnf.g:1789:50: '/together'
+ {
+ match("/together");
+
+
+ }
+ break;
+
+ }
+
+
+ }
+
+ state.type = _type;
+ state.channel = _channel;
+ }
+ finally {
+ }
+ }
+ // $ANTLR end "RULE_LOGIC"
+
+ public void mTokens() throws RecognitionException {
+ // ../de.ugoe.cs.swe.bnftools.ebnf/src-gen/de/ugoe/cs/swe/bnftools/parser/antlr/internal/InternalEbnf.g:1:8: ( T__13 | T__14 | T__15 | T__16 | T__17 | T__18 | T__19 | T__20 | T__21 | T__22 | T__23 | T__24 | T__25 | T__26 | T__27 | T__28 | T__29 | T__30 | T__31 | T__32 | T__33 | T__34 | T__35 | T__36 | T__37 | T__38 | T__39 | RULE_ID | RULE_INT | RULE_WS | RULE_COLON | RULE_STRING | RULE_SECTIONHEADER | RULE_SL_COMMENT | RULE_ML_COMMENT | RULE_LOGIC )
+ int alt16=36;
+ alt16 = dfa16.predict(input);
+ switch (alt16) {
+ case 1 :
+ // ../de.ugoe.cs.swe.bnftools.ebnf/src-gen/de/ugoe/cs/swe/bnftools/parser/antlr/internal/InternalEbnf.g:1:10: T__13
+ {
+ mT__13();
+
+ }
+ break;
+ case 2 :
+ // ../de.ugoe.cs.swe.bnftools.ebnf/src-gen/de/ugoe/cs/swe/bnftools/parser/antlr/internal/InternalEbnf.g:1:16: T__14
+ {
+ mT__14();
+
+ }
+ break;
+ case 3 :
+ // ../de.ugoe.cs.swe.bnftools.ebnf/src-gen/de/ugoe/cs/swe/bnftools/parser/antlr/internal/InternalEbnf.g:1:22: T__15
+ {
+ mT__15();
+
+ }
+ break;
+ case 4 :
+ // ../de.ugoe.cs.swe.bnftools.ebnf/src-gen/de/ugoe/cs/swe/bnftools/parser/antlr/internal/InternalEbnf.g:1:28: T__16
+ {
+ mT__16();
+
+ }
+ break;
+ case 5 :
+ // ../de.ugoe.cs.swe.bnftools.ebnf/src-gen/de/ugoe/cs/swe/bnftools/parser/antlr/internal/InternalEbnf.g:1:34: T__17
+ {
+ mT__17();
+
+ }
+ break;
+ case 6 :
+ // ../de.ugoe.cs.swe.bnftools.ebnf/src-gen/de/ugoe/cs/swe/bnftools/parser/antlr/internal/InternalEbnf.g:1:40: T__18
+ {
+ mT__18();
+
+ }
+ break;
+ case 7 :
+ // ../de.ugoe.cs.swe.bnftools.ebnf/src-gen/de/ugoe/cs/swe/bnftools/parser/antlr/internal/InternalEbnf.g:1:46: T__19
+ {
+ mT__19();
+
+ }
+ break;
+ case 8 :
+ // ../de.ugoe.cs.swe.bnftools.ebnf/src-gen/de/ugoe/cs/swe/bnftools/parser/antlr/internal/InternalEbnf.g:1:52: T__20
+ {
+ mT__20();
+
+ }
+ break;
+ case 9 :
+ // ../de.ugoe.cs.swe.bnftools.ebnf/src-gen/de/ugoe/cs/swe/bnftools/parser/antlr/internal/InternalEbnf.g:1:58: T__21
+ {
+ mT__21();
+
+ }
+ break;
+ case 10 :
+ // ../de.ugoe.cs.swe.bnftools.ebnf/src-gen/de/ugoe/cs/swe/bnftools/parser/antlr/internal/InternalEbnf.g:1:64: T__22
+ {
+ mT__22();
+
+ }
+ break;
+ case 11 :
+ // ../de.ugoe.cs.swe.bnftools.ebnf/src-gen/de/ugoe/cs/swe/bnftools/parser/antlr/internal/InternalEbnf.g:1:70: T__23
+ {
+ mT__23();
+
+ }
+ break;
+ case 12 :
+ // ../de.ugoe.cs.swe.bnftools.ebnf/src-gen/de/ugoe/cs/swe/bnftools/parser/antlr/internal/InternalEbnf.g:1:76: T__24
+ {
+ mT__24();
+
+ }
+ break;
+ case 13 :
+ // ../de.ugoe.cs.swe.bnftools.ebnf/src-gen/de/ugoe/cs/swe/bnftools/parser/antlr/internal/InternalEbnf.g:1:82: T__25
+ {
+ mT__25();
+
+ }
+ break;
+ case 14 :
+ // ../de.ugoe.cs.swe.bnftools.ebnf/src-gen/de/ugoe/cs/swe/bnftools/parser/antlr/internal/InternalEbnf.g:1:88: T__26
+ {
+ mT__26();
+
+ }
+ break;
+ case 15 :
+ // ../de.ugoe.cs.swe.bnftools.ebnf/src-gen/de/ugoe/cs/swe/bnftools/parser/antlr/internal/InternalEbnf.g:1:94: T__27
+ {
+ mT__27();
+
+ }
+ break;
+ case 16 :
+ // ../de.ugoe.cs.swe.bnftools.ebnf/src-gen/de/ugoe/cs/swe/bnftools/parser/antlr/internal/InternalEbnf.g:1:100: T__28
+ {
+ mT__28();
+
+ }
+ break;
+ case 17 :
+ // ../de.ugoe.cs.swe.bnftools.ebnf/src-gen/de/ugoe/cs/swe/bnftools/parser/antlr/internal/InternalEbnf.g:1:106: T__29
+ {
+ mT__29();
+
+ }
+ break;
+ case 18 :
+ // ../de.ugoe.cs.swe.bnftools.ebnf/src-gen/de/ugoe/cs/swe/bnftools/parser/antlr/internal/InternalEbnf.g:1:112: T__30
+ {
+ mT__30();
+
+ }
+ break;
+ case 19 :
+ // ../de.ugoe.cs.swe.bnftools.ebnf/src-gen/de/ugoe/cs/swe/bnftools/parser/antlr/internal/InternalEbnf.g:1:118: T__31
+ {
+ mT__31();
+
+ }
+ break;
+ case 20 :
+ // ../de.ugoe.cs.swe.bnftools.ebnf/src-gen/de/ugoe/cs/swe/bnftools/parser/antlr/internal/InternalEbnf.g:1:124: T__32
+ {
+ mT__32();
+
+ }
+ break;
+ case 21 :
+ // ../de.ugoe.cs.swe.bnftools.ebnf/src-gen/de/ugoe/cs/swe/bnftools/parser/antlr/internal/InternalEbnf.g:1:130: T__33
+ {
+ mT__33();
+
+ }
+ break;
+ case 22 :
+ // ../de.ugoe.cs.swe.bnftools.ebnf/src-gen/de/ugoe/cs/swe/bnftools/parser/antlr/internal/InternalEbnf.g:1:136: T__34
+ {
+ mT__34();
+
+ }
+ break;
+ case 23 :
+ // ../de.ugoe.cs.swe.bnftools.ebnf/src-gen/de/ugoe/cs/swe/bnftools/parser/antlr/internal/InternalEbnf.g:1:142: T__35
+ {
+ mT__35();
+
+ }
+ break;
+ case 24 :
+ // ../de.ugoe.cs.swe.bnftools.ebnf/src-gen/de/ugoe/cs/swe/bnftools/parser/antlr/internal/InternalEbnf.g:1:148: T__36
+ {
+ mT__36();
+
+ }
+ break;
+ case 25 :
+ // ../de.ugoe.cs.swe.bnftools.ebnf/src-gen/de/ugoe/cs/swe/bnftools/parser/antlr/internal/InternalEbnf.g:1:154: T__37
+ {
+ mT__37();
+
+ }
+ break;
+ case 26 :
+ // ../de.ugoe.cs.swe.bnftools.ebnf/src-gen/de/ugoe/cs/swe/bnftools/parser/antlr/internal/InternalEbnf.g:1:160: T__38
+ {
+ mT__38();
+
+ }
+ break;
+ case 27 :
+ // ../de.ugoe.cs.swe.bnftools.ebnf/src-gen/de/ugoe/cs/swe/bnftools/parser/antlr/internal/InternalEbnf.g:1:166: T__39
+ {
+ mT__39();
+
+ }
+ break;
+ case 28 :
+ // ../de.ugoe.cs.swe.bnftools.ebnf/src-gen/de/ugoe/cs/swe/bnftools/parser/antlr/internal/InternalEbnf.g:1:172: RULE_ID
+ {
+ mRULE_ID();
+
+ }
+ break;
+ case 29 :
+ // ../de.ugoe.cs.swe.bnftools.ebnf/src-gen/de/ugoe/cs/swe/bnftools/parser/antlr/internal/InternalEbnf.g:1:180: RULE_INT
+ {
+ mRULE_INT();
+
+ }
+ break;
+ case 30 :
+ // ../de.ugoe.cs.swe.bnftools.ebnf/src-gen/de/ugoe/cs/swe/bnftools/parser/antlr/internal/InternalEbnf.g:1:189: RULE_WS
+ {
+ mRULE_WS();
+
+ }
+ break;
+ case 31 :
+ // ../de.ugoe.cs.swe.bnftools.ebnf/src-gen/de/ugoe/cs/swe/bnftools/parser/antlr/internal/InternalEbnf.g:1:197: RULE_COLON
+ {
+ mRULE_COLON();
+
+ }
+ break;
+ case 32 :
+ // ../de.ugoe.cs.swe.bnftools.ebnf/src-gen/de/ugoe/cs/swe/bnftools/parser/antlr/internal/InternalEbnf.g:1:208: RULE_STRING
+ {
+ mRULE_STRING();
+
+ }
+ break;
+ case 33 :
+ // ../de.ugoe.cs.swe.bnftools.ebnf/src-gen/de/ugoe/cs/swe/bnftools/parser/antlr/internal/InternalEbnf.g:1:220: RULE_SECTIONHEADER
+ {
+ mRULE_SECTIONHEADER();
+
+ }
+ break;
+ case 34 :
+ // ../de.ugoe.cs.swe.bnftools.ebnf/src-gen/de/ugoe/cs/swe/bnftools/parser/antlr/internal/InternalEbnf.g:1:239: RULE_SL_COMMENT
+ {
+ mRULE_SL_COMMENT();
+
+ }
+ break;
+ case 35 :
+ // ../de.ugoe.cs.swe.bnftools.ebnf/src-gen/de/ugoe/cs/swe/bnftools/parser/antlr/internal/InternalEbnf.g:1:255: RULE_ML_COMMENT
+ {
+ mRULE_ML_COMMENT();
+
+ }
+ break;
+ case 36 :
+ // ../de.ugoe.cs.swe.bnftools.ebnf/src-gen/de/ugoe/cs/swe/bnftools/parser/antlr/internal/InternalEbnf.g:1:271: RULE_LOGIC
+ {
+ mRULE_LOGIC();
+
+ }
+ break;
+
+ }
+
+ }
+
+
+ protected DFA15 dfa15 = new DFA15(this);
+ protected DFA16 dfa16 = new DFA16(this);
+ static final String DFA15_eotS =
+ "\6\uffff\1\12\1\14\5\uffff";
+ static final String DFA15_eofS =
+ "\15\uffff";
+ static final String DFA15_minS =
+ "\1\57\1\141\1\156\1\162\1\uffff\1\144\2\162\5\uffff";
+ static final String DFA15_maxS =
+ "\1\57\1\164\1\156\1\162\1\uffff\1\171\2\162\5\uffff";
+ static final String DFA15_acceptS =
+ "\4\uffff\1\6\3\uffff\1\5\1\4\1\2\1\3\1\1";
+ static final String DFA15_specialS =
+ "\15\uffff}>";
+ static final String[] DFA15_transitionS = {
+ "\1\1",
+ "\1\2\15\uffff\1\3\4\uffff\1\4",
+ "\1\5",
+ "\1\6",
+ "",
+ "\1\7\24\uffff\1\10",
+ "\1\11",
+ "\1\13",
+ "",
+ "",
+ "",
+ "",
+ ""
+ };
+
+ static final short[] DFA15_eot = DFA.unpackEncodedString(DFA15_eotS);
+ static final short[] DFA15_eof = DFA.unpackEncodedString(DFA15_eofS);
+ static final char[] DFA15_min = DFA.unpackEncodedStringToUnsignedChars(DFA15_minS);
+ static final char[] DFA15_max = DFA.unpackEncodedStringToUnsignedChars(DFA15_maxS);
+ static final short[] DFA15_accept = DFA.unpackEncodedString(DFA15_acceptS);
+ static final short[] DFA15_special = DFA.unpackEncodedString(DFA15_specialS);
+ static final short[][] DFA15_transition;
+
+ static {
+ int numStates = DFA15_transitionS.length;
+ DFA15_transition = new short[numStates][];
+ for (int i=0; i";
+ static final String[] DFA16_transitionS = {
+ "\2\31\2\uffff\1\31\22\uffff\1\31\1\uffff\1\32\4\uffff\1\33"+
+ "\1\13\1\14\1\23\1\24\2\uffff\1\11\1\2\12\30\1\12\1\3\1\15\4"+
+ "\uffff\32\27\1\21\1\uffff\1\16\1\uffff\1\34\1\uffff\2\27\1\5"+
+ "\3\27\1\1\1\26\1\4\2\27\1\10\3\27\1\6\1\27\1\25\2\27\1\7\5\27"+
+ "\1\22\1\20\1\17",
+ "\1\40\1\uffff\12\37\62\uffff\1\36\5\uffff\1\35",
+ "\1\45\4\uffff\1\44\61\uffff\1\46\1\41\1\uffff\1\42\10\uffff"+
+ "\1\43\1\uffff\1\46\4\uffff\1\46",
+ "",
+ "\1\40\1\uffff\12\37\63\uffff\1\50",
+ "\1\40\1\uffff\12\37\65\uffff\1\51",
+ "\1\40\1\uffff\12\37\47\uffff\1\52",
+ "\1\40\1\uffff\12\37\66\uffff\1\53",
+ "\1\40\1\uffff\12\37\47\uffff\1\54",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "\1\40\1\uffff\12\37\73\uffff\1\55",
+ "\1\40\1\uffff\12\37\65\uffff\1\56",
+ "\1\40\1\uffff\12\37",
+ "",
+ "",
+ "\42\33\1\57\uffdd\33",
+ "",
+ "",
+ "\1\60",
+ "\1\61",
+ "\1\40\26\uffff\1\40\15\uffff\1\40\1\uffff\12\37",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "\1\62",
+ "\1\64\4\uffff\1\63",
+ "\1\65",
+ "\1\66",
+ "\1\67",
+ "\1\70",
+ "\1\71",
+ "\1\72",
+ "\1\73",
+ "\1\74",
+ "\1\75",
+ "\1\76",
+ "\1\77",
+ "\1\100",
+ "\1\101",
+ "\1\102",
+ "\1\103",
+ "\1\104",
+ "",
+ "\1\105",
+ "\1\106",
+ "\1\107",
+ "\12\34\7\uffff\32\34\4\uffff\1\34\1\uffff\32\34",
+ "\1\111",
+ "\1\112",
+ "\1\113",
+ "\1\114",
+ "\12\34\7\uffff\32\34\4\uffff\1\34\1\uffff\32\34",
+ "\12\34\7\uffff\32\34\4\uffff\1\34\1\uffff\32\34",
+ "\1\117",
+ "\1\120",
+ "\1\121",
+ "",
+ "\1\122",
+ "\1\123",
+ "\1\124",
+ "\1\125",
+ "",
+ "",
+ "\1\126",
+ "\12\34\7\uffff\32\34\4\uffff\1\34\1\uffff\32\34",
+ "\12\34\7\uffff\32\34\4\uffff\1\34\1\uffff\32\34",
+ "\1\131",
+ "\1\132",
+ "\12\34\7\uffff\32\34\4\uffff\1\34\1\uffff\32\34",
+ "",
+ "\12\34\7\uffff\32\34\4\uffff\1\34\1\uffff\32\34",
+ "",
+ "",
+ "\1\135",
+ "\12\34\7\uffff\32\34\4\uffff\1\34\1\uffff\32\34",
+ "",
+ "",
+ "\1\137",
+ "",
+ "\1\140",
+ "\1\141",
+ ""
+ };
+
+ static final short[] DFA16_eot = DFA.unpackEncodedString(DFA16_eotS);
+ static final short[] DFA16_eof = DFA.unpackEncodedString(DFA16_eofS);
+ static final char[] DFA16_min = DFA.unpackEncodedStringToUnsignedChars(DFA16_minS);
+ static final char[] DFA16_max = DFA.unpackEncodedStringToUnsignedChars(DFA16_maxS);
+ static final short[] DFA16_accept = DFA.unpackEncodedString(DFA16_acceptS);
+ static final short[] DFA16_special = DFA.unpackEncodedString(DFA16_specialS);
+ static final short[][] DFA16_transition;
+
+ static {
+ int numStates = DFA16_transitionS.length;
+ DFA16_transition = new short[numStates][];
+ for (int i=0; i='\u0000' && LA16_26<='!')||(LA16_26>='#' && LA16_26<='\uFFFF')) ) {s = 27;}
+
+ if ( s>=0 ) return s;
+ break;
+ }
+ NoViableAltException nvae =
+ new NoViableAltException(getDescription(), 16, _s, input);
+ error(nvae);
+ throw nvae;
+ }
+ }
+
+
+}
Index: /v2/trunk/de.ugoe.cs.swe.bnftools.ebnf/src-gen/de/ugoe/cs/swe/bnftools/parser/antlr/internal/InternalEbnfParser.java
===================================================================
--- /v2/trunk/de.ugoe.cs.swe.bnftools.ebnf/src-gen/de/ugoe/cs/swe/bnftools/parser/antlr/internal/InternalEbnfParser.java (revision 61)
+++ /v2/trunk/de.ugoe.cs.swe.bnftools.ebnf/src-gen/de/ugoe/cs/swe/bnftools/parser/antlr/internal/InternalEbnfParser.java (revision 61)
@@ -0,0 +1,4821 @@
+package de.ugoe.cs.swe.bnftools.parser.antlr.internal;
+
+import org.eclipse.xtext.*;
+import org.eclipse.xtext.parser.*;
+import org.eclipse.xtext.parser.impl.*;
+import org.eclipse.emf.ecore.util.EcoreUtil;
+import org.eclipse.emf.ecore.EObject;
+import org.eclipse.xtext.parser.antlr.AbstractInternalAntlrParser;
+import org.eclipse.xtext.parser.antlr.XtextTokenStream;
+import org.eclipse.xtext.parser.antlr.XtextTokenStream.HiddenTokens;
+import org.eclipse.xtext.parser.antlr.AntlrDatatypeRuleToken;
+import de.ugoe.cs.swe.bnftools.services.EbnfGrammarAccess;
+
+
+
+import org.antlr.runtime.*;
+import java.util.Stack;
+import java.util.List;
+import java.util.ArrayList;
+
+@SuppressWarnings("all")
+public class InternalEbnfParser extends AbstractInternalAntlrParser {
+ public static final String[] tokenNames = new String[] {
+ "", "", "", "", "RULE_ID", "RULE_SECTIONHEADER", "RULE_STRING", "RULE_INT", "RULE_LOGIC", "RULE_COLON", "RULE_WS", "RULE_SL_COMMENT", "RULE_ML_COMMENT", "'grammar'", "'/bnf'", "';'", "'/delta'", "'/merge'", "'import'", "'/'", "'core'", "'package'", "'update'", "'label:'", "'.'", "'::='", "'('", "')'", "'<-'", "']'", "'}'", "'|'", "'['", "'{'", "'*'", "'+'", "'global'", "'combinator:'", "'rule'", "'hook'"
+ };
+ public static final int RULE_ID=4;
+ public static final int RULE_SECTIONHEADER=5;
+ public static final int T__29=29;
+ public static final int T__28=28;
+ public static final int T__27=27;
+ public static final int T__26=26;
+ public static final int T__25=25;
+ public static final int T__24=24;
+ public static final int T__23=23;
+ public static final int T__22=22;
+ public static final int T__21=21;
+ public static final int T__20=20;
+ public static final int RULE_SL_COMMENT=11;
+ public static final int EOF=-1;
+ public static final int RULE_ML_COMMENT=12;
+ public static final int T__30=30;
+ public static final int T__19=19;
+ public static final int RULE_COLON=9;
+ public static final int T__31=31;
+ public static final int RULE_STRING=6;
+ public static final int T__32=32;
+ public static final int T__33=33;
+ public static final int T__16=16;
+ public static final int T__34=34;
+ public static final int T__15=15;
+ public static final int T__35=35;
+ public static final int T__18=18;
+ public static final int T__36=36;
+ public static final int T__17=17;
+ public static final int RULE_LOGIC=8;
+ public static final int T__37=37;
+ public static final int T__38=38;
+ public static final int T__39=39;
+ public static final int T__14=14;
+ public static final int T__13=13;
+ public static final int RULE_INT=7;
+ public static final int RULE_WS=10;
+
+ // delegates
+ // delegators
+
+
+ public InternalEbnfParser(TokenStream input) {
+ this(input, new RecognizerSharedState());
+ }
+ public InternalEbnfParser(TokenStream input, RecognizerSharedState state) {
+ super(input, state);
+
+ }
+
+
+ public String[] getTokenNames() { return InternalEbnfParser.tokenNames; }
+ public String getGrammarFileName() { return "../de.ugoe.cs.swe.bnftools.ebnf/src-gen/de/ugoe/cs/swe/bnftools/parser/antlr/internal/InternalEbnf.g"; }
+
+
+
+ private EbnfGrammarAccess grammarAccess;
+
+ public InternalEbnfParser(TokenStream input, EbnfGrammarAccess grammarAccess) {
+ this(input);
+ this.grammarAccess = grammarAccess;
+ registerRules(grammarAccess.getGrammar());
+ }
+
+ @Override
+ protected String getFirstRuleName() {
+ return "EtsiBnf";
+ }
+
+ @Override
+ protected EbnfGrammarAccess getGrammarAccess() {
+ return grammarAccess;
+ }
+
+
+
+ // $ANTLR start "entryRuleEtsiBnf"
+ // ../de.ugoe.cs.swe.bnftools.ebnf/src-gen/de/ugoe/cs/swe/bnftools/parser/antlr/internal/InternalEbnf.g:67:1: entryRuleEtsiBnf returns [EObject current=null] : iv_ruleEtsiBnf= ruleEtsiBnf EOF ;
+ public final EObject entryRuleEtsiBnf() throws RecognitionException {
+ EObject current = null;
+
+ EObject iv_ruleEtsiBnf = null;
+
+
+ try {
+ // ../de.ugoe.cs.swe.bnftools.ebnf/src-gen/de/ugoe/cs/swe/bnftools/parser/antlr/internal/InternalEbnf.g:68:2: (iv_ruleEtsiBnf= ruleEtsiBnf EOF )
+ // ../de.ugoe.cs.swe.bnftools.ebnf/src-gen/de/ugoe/cs/swe/bnftools/parser/antlr/internal/InternalEbnf.g:69:2: iv_ruleEtsiBnf= ruleEtsiBnf EOF
+ {
+ newCompositeNode(grammarAccess.getEtsiBnfRule());
+ pushFollow(FOLLOW_ruleEtsiBnf_in_entryRuleEtsiBnf75);
+ iv_ruleEtsiBnf=ruleEtsiBnf();
+
+ state._fsp--;
+
+ current =iv_ruleEtsiBnf;
+ match(input,EOF,FOLLOW_EOF_in_entryRuleEtsiBnf85);
+
+ }
+
+ }
+
+ catch (RecognitionException re) {
+ recover(input,re);
+ appendSkippedTokens();
+ }
+ finally {
+ }
+ return current;
+ }
+ // $ANTLR end "entryRuleEtsiBnf"
+
+
+ // $ANTLR start "ruleEtsiBnf"
+ // ../de.ugoe.cs.swe.bnftools.ebnf/src-gen/de/ugoe/cs/swe/bnftools/parser/antlr/internal/InternalEbnf.g:76:1: ruleEtsiBnf returns [EObject current=null] : ( (otherlv_0= 'grammar' ( (lv_name_1_0= RULE_ID ) ) ( ( (lv_type_2_0= '/bnf' ) )? otherlv_3= ';' ( (lv_importSection_4_0= ruleImportSection ) )? ( (lv_bnfEntry_5_0= ruleBnfEntry ) )+ ) ) | ( ( (lv_type_6_0= '/delta' ) ) otherlv_7= ';' ( (lv_importSection_8_0= ruleImportSection ) )? ( (lv_deltaEntry_9_0= ruleDeltaEntry ) )* ) | ( ( (lv_type_10_0= '/merge' ) ) otherlv_11= ';' ( (lv_importSection_12_0= ruleImportSection ) )? ( (lv_mergeEntry_13_0= ruleMergeEntry ) )* ) ) ;
+ public final EObject ruleEtsiBnf() throws RecognitionException {
+ EObject current = null;
+
+ Token otherlv_0=null;
+ Token lv_name_1_0=null;
+ Token lv_type_2_0=null;
+ Token otherlv_3=null;
+ Token lv_type_6_0=null;
+ Token otherlv_7=null;
+ Token lv_type_10_0=null;
+ Token otherlv_11=null;
+ EObject lv_importSection_4_0 = null;
+
+ EObject lv_bnfEntry_5_0 = null;
+
+ EObject lv_importSection_8_0 = null;
+
+ EObject lv_deltaEntry_9_0 = null;
+
+ EObject lv_importSection_12_0 = null;
+
+ EObject lv_mergeEntry_13_0 = null;
+
+
+ enterRule();
+
+ try {
+ // ../de.ugoe.cs.swe.bnftools.ebnf/src-gen/de/ugoe/cs/swe/bnftools/parser/antlr/internal/InternalEbnf.g:79:28: ( ( (otherlv_0= 'grammar' ( (lv_name_1_0= RULE_ID ) ) ( ( (lv_type_2_0= '/bnf' ) )? otherlv_3= ';' ( (lv_importSection_4_0= ruleImportSection ) )? ( (lv_bnfEntry_5_0= ruleBnfEntry ) )+ ) ) | ( ( (lv_type_6_0= '/delta' ) ) otherlv_7= ';' ( (lv_importSection_8_0= ruleImportSection ) )? ( (lv_deltaEntry_9_0= ruleDeltaEntry ) )* ) | ( ( (lv_type_10_0= '/merge' ) ) otherlv_11= ';' ( (lv_importSection_12_0= ruleImportSection ) )? ( (lv_mergeEntry_13_0= ruleMergeEntry ) )* ) ) )
+ // ../de.ugoe.cs.swe.bnftools.ebnf/src-gen/de/ugoe/cs/swe/bnftools/parser/antlr/internal/InternalEbnf.g:80:1: ( (otherlv_0= 'grammar' ( (lv_name_1_0= RULE_ID ) ) ( ( (lv_type_2_0= '/bnf' ) )? otherlv_3= ';' ( (lv_importSection_4_0= ruleImportSection ) )? ( (lv_bnfEntry_5_0= ruleBnfEntry ) )+ ) ) | ( ( (lv_type_6_0= '/delta' ) ) otherlv_7= ';' ( (lv_importSection_8_0= ruleImportSection ) )? ( (lv_deltaEntry_9_0= ruleDeltaEntry ) )* ) | ( ( (lv_type_10_0= '/merge' ) ) otherlv_11= ';' ( (lv_importSection_12_0= ruleImportSection ) )? ( (lv_mergeEntry_13_0= ruleMergeEntry ) )* ) )
+ {
+ // ../de.ugoe.cs.swe.bnftools.ebnf/src-gen/de/ugoe/cs/swe/bnftools/parser/antlr/internal/InternalEbnf.g:80:1: ( (otherlv_0= 'grammar' ( (lv_name_1_0= RULE_ID ) ) ( ( (lv_type_2_0= '/bnf' ) )? otherlv_3= ';' ( (lv_importSection_4_0= ruleImportSection ) )? ( (lv_bnfEntry_5_0= ruleBnfEntry ) )+ ) ) | ( ( (lv_type_6_0= '/delta' ) ) otherlv_7= ';' ( (lv_importSection_8_0= ruleImportSection ) )? ( (lv_deltaEntry_9_0= ruleDeltaEntry ) )* ) | ( ( (lv_type_10_0= '/merge' ) ) otherlv_11= ';' ( (lv_importSection_12_0= ruleImportSection ) )? ( (lv_mergeEntry_13_0= ruleMergeEntry ) )* ) )
+ int alt8=3;
+ switch ( input.LA(1) ) {
+ case 13:
+ {
+ alt8=1;
+ }
+ break;
+ case 16:
+ {
+ alt8=2;
+ }
+ break;
+ case 17:
+ {
+ alt8=3;
+ }
+ break;
+ default:
+ NoViableAltException nvae =
+ new NoViableAltException("", 8, 0, input);
+
+ throw nvae;
+ }
+
+ switch (alt8) {
+ case 1 :
+ // ../de.ugoe.cs.swe.bnftools.ebnf/src-gen/de/ugoe/cs/swe/bnftools/parser/antlr/internal/InternalEbnf.g:80:2: (otherlv_0= 'grammar' ( (lv_name_1_0= RULE_ID ) ) ( ( (lv_type_2_0= '/bnf' ) )? otherlv_3= ';' ( (lv_importSection_4_0= ruleImportSection ) )? ( (lv_bnfEntry_5_0= ruleBnfEntry ) )+ ) )
+ {
+ // ../de.ugoe.cs.swe.bnftools.ebnf/src-gen/de/ugoe/cs/swe/bnftools/parser/antlr/internal/InternalEbnf.g:80:2: (otherlv_0= 'grammar' ( (lv_name_1_0= RULE_ID ) ) ( ( (lv_type_2_0= '/bnf' ) )? otherlv_3= ';' ( (lv_importSection_4_0= ruleImportSection ) )? ( (lv_bnfEntry_5_0= ruleBnfEntry ) )+ ) )
+ // ../de.ugoe.cs.swe.bnftools.ebnf/src-gen/de/ugoe/cs/swe/bnftools/parser/antlr/internal/InternalEbnf.g:80:4: otherlv_0= 'grammar' ( (lv_name_1_0= RULE_ID ) ) ( ( (lv_type_2_0= '/bnf' ) )? otherlv_3= ';' ( (lv_importSection_4_0= ruleImportSection ) )? ( (lv_bnfEntry_5_0= ruleBnfEntry ) )+ )
+ {
+ otherlv_0=(Token)match(input,13,FOLLOW_13_in_ruleEtsiBnf123);
+
+ newLeafNode(otherlv_0, grammarAccess.getEtsiBnfAccess().getGrammarKeyword_0_0());
+
+ // ../de.ugoe.cs.swe.bnftools.ebnf/src-gen/de/ugoe/cs/swe/bnftools/parser/antlr/internal/InternalEbnf.g:84:1: ( (lv_name_1_0= RULE_ID ) )
+ // ../de.ugoe.cs.swe.bnftools.ebnf/src-gen/de/ugoe/cs/swe/bnftools/parser/antlr/internal/InternalEbnf.g:85:1: (lv_name_1_0= RULE_ID )
+ {
+ // ../de.ugoe.cs.swe.bnftools.ebnf/src-gen/de/ugoe/cs/swe/bnftools/parser/antlr/internal/InternalEbnf.g:85:1: (lv_name_1_0= RULE_ID )
+ // ../de.ugoe.cs.swe.bnftools.ebnf/src-gen/de/ugoe/cs/swe/bnftools/parser/antlr/internal/InternalEbnf.g:86:3: lv_name_1_0= RULE_ID
+ {
+ lv_name_1_0=(Token)match(input,RULE_ID,FOLLOW_RULE_ID_in_ruleEtsiBnf140);
+
+ newLeafNode(lv_name_1_0, grammarAccess.getEtsiBnfAccess().getNameIDTerminalRuleCall_0_1_0());
+
+
+ if (current==null) {
+ current = createModelElement(grammarAccess.getEtsiBnfRule());
+ }
+ setWithLastConsumed(
+ current,
+ "name",
+ lv_name_1_0,
+ "ID");
+
+
+ }
+
+
+ }
+
+ // ../de.ugoe.cs.swe.bnftools.ebnf/src-gen/de/ugoe/cs/swe/bnftools/parser/antlr/internal/InternalEbnf.g:102:2: ( ( (lv_type_2_0= '/bnf' ) )? otherlv_3= ';' ( (lv_importSection_4_0= ruleImportSection ) )? ( (lv_bnfEntry_5_0= ruleBnfEntry ) )+ )
+ // ../de.ugoe.cs.swe.bnftools.ebnf/src-gen/de/ugoe/cs/swe/bnftools/parser/antlr/internal/InternalEbnf.g:102:3: ( (lv_type_2_0= '/bnf' ) )? otherlv_3= ';' ( (lv_importSection_4_0= ruleImportSection ) )? ( (lv_bnfEntry_5_0= ruleBnfEntry ) )+
+ {
+ // ../de.ugoe.cs.swe.bnftools.ebnf/src-gen/de/ugoe/cs/swe/bnftools/parser/antlr/internal/InternalEbnf.g:102:3: ( (lv_type_2_0= '/bnf' ) )?
+ int alt1=2;
+ int LA1_0 = input.LA(1);
+
+ if ( (LA1_0==14) ) {
+ alt1=1;
+ }
+ switch (alt1) {
+ case 1 :
+ // ../de.ugoe.cs.swe.bnftools.ebnf/src-gen/de/ugoe/cs/swe/bnftools/parser/antlr/internal/InternalEbnf.g:103:1: (lv_type_2_0= '/bnf' )
+ {
+ // ../de.ugoe.cs.swe.bnftools.ebnf/src-gen/de/ugoe/cs/swe/bnftools/parser/antlr/internal/InternalEbnf.g:103:1: (lv_type_2_0= '/bnf' )
+ // ../de.ugoe.cs.swe.bnftools.ebnf/src-gen/de/ugoe/cs/swe/bnftools/parser/antlr/internal/InternalEbnf.g:104:3: lv_type_2_0= '/bnf'
+ {
+ lv_type_2_0=(Token)match(input,14,FOLLOW_14_in_ruleEtsiBnf164);
+
+ newLeafNode(lv_type_2_0, grammarAccess.getEtsiBnfAccess().getTypeBnfKeyword_0_2_0_0());
+
+
+ if (current==null) {
+ current = createModelElement(grammarAccess.getEtsiBnfRule());
+ }
+ setWithLastConsumed(current, "type", lv_type_2_0, "/bnf");
+
+
+ }
+
+
+ }
+ break;
+
+ }
+
+ otherlv_3=(Token)match(input,15,FOLLOW_15_in_ruleEtsiBnf190);
+
+ newLeafNode(otherlv_3, grammarAccess.getEtsiBnfAccess().getSemicolonKeyword_0_2_1());
+
+ // ../de.ugoe.cs.swe.bnftools.ebnf/src-gen/de/ugoe/cs/swe/bnftools/parser/antlr/internal/InternalEbnf.g:121:1: ( (lv_importSection_4_0= ruleImportSection ) )?
+ int alt2=2;
+ int LA2_0 = input.LA(1);
+
+ if ( (LA2_0==18) ) {
+ alt2=1;
+ }
+ switch (alt2) {
+ case 1 :
+ // ../de.ugoe.cs.swe.bnftools.ebnf/src-gen/de/ugoe/cs/swe/bnftools/parser/antlr/internal/InternalEbnf.g:122:1: (lv_importSection_4_0= ruleImportSection )
+ {
+ // ../de.ugoe.cs.swe.bnftools.ebnf/src-gen/de/ugoe/cs/swe/bnftools/parser/antlr/internal/InternalEbnf.g:122:1: (lv_importSection_4_0= ruleImportSection )
+ // ../de.ugoe.cs.swe.bnftools.ebnf/src-gen/de/ugoe/cs/swe/bnftools/parser/antlr/internal/InternalEbnf.g:123:3: lv_importSection_4_0= ruleImportSection
+ {
+
+ newCompositeNode(grammarAccess.getEtsiBnfAccess().getImportSectionImportSectionParserRuleCall_0_2_2_0());
+
+ pushFollow(FOLLOW_ruleImportSection_in_ruleEtsiBnf211);
+ lv_importSection_4_0=ruleImportSection();
+
+ state._fsp--;
+
+
+ if (current==null) {
+ current = createModelElementForParent(grammarAccess.getEtsiBnfRule());
+ }
+ set(
+ current,
+ "importSection",
+ lv_importSection_4_0,
+ "ImportSection");
+ afterParserOrEnumRuleCall();
+
+
+ }
+
+
+ }
+ break;
+
+ }
+
+ // ../de.ugoe.cs.swe.bnftools.ebnf/src-gen/de/ugoe/cs/swe/bnftools/parser/antlr/internal/InternalEbnf.g:139:3: ( (lv_bnfEntry_5_0= ruleBnfEntry ) )+
+ int cnt3=0;
+ loop3:
+ do {
+ int alt3=2;
+ int LA3_0 = input.LA(1);
+
+ if ( ((LA3_0>=RULE_ID && LA3_0<=RULE_SECTIONHEADER)||LA3_0==RULE_INT) ) {
+ alt3=1;
+ }
+
+
+ switch (alt3) {
+ case 1 :
+ // ../de.ugoe.cs.swe.bnftools.ebnf/src-gen/de/ugoe/cs/swe/bnftools/parser/antlr/internal/InternalEbnf.g:140:1: (lv_bnfEntry_5_0= ruleBnfEntry )
+ {
+ // ../de.ugoe.cs.swe.bnftools.ebnf/src-gen/de/ugoe/cs/swe/bnftools/parser/antlr/internal/InternalEbnf.g:140:1: (lv_bnfEntry_5_0= ruleBnfEntry )
+ // ../de.ugoe.cs.swe.bnftools.ebnf/src-gen/de/ugoe/cs/swe/bnftools/parser/antlr/internal/InternalEbnf.g:141:3: lv_bnfEntry_5_0= ruleBnfEntry
+ {
+
+ newCompositeNode(grammarAccess.getEtsiBnfAccess().getBnfEntryBnfEntryParserRuleCall_0_2_3_0());
+
+ pushFollow(FOLLOW_ruleBnfEntry_in_ruleEtsiBnf233);
+ lv_bnfEntry_5_0=ruleBnfEntry();
+
+ state._fsp--;
+
+
+ if (current==null) {
+ current = createModelElementForParent(grammarAccess.getEtsiBnfRule());
+ }
+ add(
+ current,
+ "bnfEntry",
+ lv_bnfEntry_5_0,
+ "BnfEntry");
+ afterParserOrEnumRuleCall();
+
+
+ }
+
+
+ }
+ break;
+
+ default :
+ if ( cnt3 >= 1 ) break loop3;
+ EarlyExitException eee =
+ new EarlyExitException(3, input);
+ throw eee;
+ }
+ cnt3++;
+ } while (true);
+
+
+ }
+
+
+ }
+
+
+ }
+ break;
+ case 2 :
+ // ../de.ugoe.cs.swe.bnftools.ebnf/src-gen/de/ugoe/cs/swe/bnftools/parser/antlr/internal/InternalEbnf.g:158:6: ( ( (lv_type_6_0= '/delta' ) ) otherlv_7= ';' ( (lv_importSection_8_0= ruleImportSection ) )? ( (lv_deltaEntry_9_0= ruleDeltaEntry ) )* )
+ {
+ // ../de.ugoe.cs.swe.bnftools.ebnf/src-gen/de/ugoe/cs/swe/bnftools/parser/antlr/internal/InternalEbnf.g:158:6: ( ( (lv_type_6_0= '/delta' ) ) otherlv_7= ';' ( (lv_importSection_8_0= ruleImportSection ) )? ( (lv_deltaEntry_9_0= ruleDeltaEntry ) )* )
+ // ../de.ugoe.cs.swe.bnftools.ebnf/src-gen/de/ugoe/cs/swe/bnftools/parser/antlr/internal/InternalEbnf.g:158:7: ( (lv_type_6_0= '/delta' ) ) otherlv_7= ';' ( (lv_importSection_8_0= ruleImportSection ) )? ( (lv_deltaEntry_9_0= ruleDeltaEntry ) )*
+ {
+ // ../de.ugoe.cs.swe.bnftools.ebnf/src-gen/de/ugoe/cs/swe/bnftools/parser/antlr/internal/InternalEbnf.g:158:7: ( (lv_type_6_0= '/delta' ) )
+ // ../de.ugoe.cs.swe.bnftools.ebnf/src-gen/de/ugoe/cs/swe/bnftools/parser/antlr/internal/InternalEbnf.g:159:1: (lv_type_6_0= '/delta' )
+ {
+ // ../de.ugoe.cs.swe.bnftools.ebnf/src-gen/de/ugoe/cs/swe/bnftools/parser/antlr/internal/InternalEbnf.g:159:1: (lv_type_6_0= '/delta' )
+ // ../de.ugoe.cs.swe.bnftools.ebnf/src-gen/de/ugoe/cs/swe/bnftools/parser/antlr/internal/InternalEbnf.g:160:3: lv_type_6_0= '/delta'
+ {
+ lv_type_6_0=(Token)match(input,16,FOLLOW_16_in_ruleEtsiBnf261);
+
+ newLeafNode(lv_type_6_0, grammarAccess.getEtsiBnfAccess().getTypeDeltaKeyword_1_0_0());
+
+
+ if (current==null) {
+ current = createModelElement(grammarAccess.getEtsiBnfRule());
+ }
+ setWithLastConsumed(current, "type", lv_type_6_0, "/delta");
+
+
+ }
+
+
+ }
+
+ otherlv_7=(Token)match(input,15,FOLLOW_15_in_ruleEtsiBnf286);
+
+ newLeafNode(otherlv_7, grammarAccess.getEtsiBnfAccess().getSemicolonKeyword_1_1());
+
+ // ../de.ugoe.cs.swe.bnftools.ebnf/src-gen/de/ugoe/cs/swe/bnftools/parser/antlr/internal/InternalEbnf.g:177:1: ( (lv_importSection_8_0= ruleImportSection ) )?
+ int alt4=2;
+ int LA4_0 = input.LA(1);
+
+ if ( (LA4_0==18) ) {
+ alt4=1;
+ }
+ switch (alt4) {
+ case 1 :
+ // ../de.ugoe.cs.swe.bnftools.ebnf/src-gen/de/ugoe/cs/swe/bnftools/parser/antlr/internal/InternalEbnf.g:178:1: (lv_importSection_8_0= ruleImportSection )
+ {
+ // ../de.ugoe.cs.swe.bnftools.ebnf/src-gen/de/ugoe/cs/swe/bnftools/parser/antlr/internal/InternalEbnf.g:178:1: (lv_importSection_8_0= ruleImportSection )
+ // ../de.ugoe.cs.swe.bnftools.ebnf/src-gen/de/ugoe/cs/swe/bnftools/parser/antlr/internal/InternalEbnf.g:179:3: lv_importSection_8_0= ruleImportSection
+ {
+
+ newCompositeNode(grammarAccess.getEtsiBnfAccess().getImportSectionImportSectionParserRuleCall_1_2_0());
+
+ pushFollow(FOLLOW_ruleImportSection_in_ruleEtsiBnf307);
+ lv_importSection_8_0=ruleImportSection();
+
+ state._fsp--;
+
+
+ if (current==null) {
+ current = createModelElementForParent(grammarAccess.getEtsiBnfRule());
+ }
+ set(
+ current,
+ "importSection",
+ lv_importSection_8_0,
+ "ImportSection");
+ afterParserOrEnumRuleCall();
+
+
+ }
+
+
+ }
+ break;
+
+ }
+
+ // ../de.ugoe.cs.swe.bnftools.ebnf/src-gen/de/ugoe/cs/swe/bnftools/parser/antlr/internal/InternalEbnf.g:195:3: ( (lv_deltaEntry_9_0= ruleDeltaEntry ) )*
+ loop5:
+ do {
+ int alt5=2;
+ int LA5_0 = input.LA(1);
+
+ if ( ((LA5_0>=RULE_ID && LA5_0<=RULE_SECTIONHEADER)||LA5_0==RULE_INT) ) {
+ alt5=1;
+ }
+
+
+ switch (alt5) {
+ case 1 :
+ // ../de.ugoe.cs.swe.bnftools.ebnf/src-gen/de/ugoe/cs/swe/bnftools/parser/antlr/internal/InternalEbnf.g:196:1: (lv_deltaEntry_9_0= ruleDeltaEntry )
+ {
+ // ../de.ugoe.cs.swe.bnftools.ebnf/src-gen/de/ugoe/cs/swe/bnftools/parser/antlr/internal/InternalEbnf.g:196:1: (lv_deltaEntry_9_0= ruleDeltaEntry )
+ // ../de.ugoe.cs.swe.bnftools.ebnf/src-gen/de/ugoe/cs/swe/bnftools/parser/antlr/internal/InternalEbnf.g:197:3: lv_deltaEntry_9_0= ruleDeltaEntry
+ {
+
+ newCompositeNode(grammarAccess.getEtsiBnfAccess().getDeltaEntryDeltaEntryParserRuleCall_1_3_0());
+
+ pushFollow(FOLLOW_ruleDeltaEntry_in_ruleEtsiBnf329);
+ lv_deltaEntry_9_0=ruleDeltaEntry();
+
+ state._fsp--;
+
+
+ if (current==null) {
+ current = createModelElementForParent(grammarAccess.getEtsiBnfRule());
+ }
+ add(
+ current,
+ "deltaEntry",
+ lv_deltaEntry_9_0,
+ "DeltaEntry");
+ afterParserOrEnumRuleCall();
+
+
+ }
+
+
+ }
+ break;
+
+ default :
+ break loop5;
+ }
+ } while (true);
+
+
+ }
+
+
+ }
+ break;
+ case 3 :
+ // ../de.ugoe.cs.swe.bnftools.ebnf/src-gen/de/ugoe/cs/swe/bnftools/parser/antlr/internal/InternalEbnf.g:214:6: ( ( (lv_type_10_0= '/merge' ) ) otherlv_11= ';' ( (lv_importSection_12_0= ruleImportSection ) )? ( (lv_mergeEntry_13_0= ruleMergeEntry ) )* )
+ {
+ // ../de.ugoe.cs.swe.bnftools.ebnf/src-gen/de/ugoe/cs/swe/bnftools/parser/antlr/internal/InternalEbnf.g:214:6: ( ( (lv_type_10_0= '/merge' ) ) otherlv_11= ';' ( (lv_importSection_12_0= ruleImportSection ) )? ( (lv_mergeEntry_13_0= ruleMergeEntry ) )* )
+ // ../de.ugoe.cs.swe.bnftools.ebnf/src-gen/de/ugoe/cs/swe/bnftools/parser/antlr/internal/InternalEbnf.g:214:7: ( (lv_type_10_0= '/merge' ) ) otherlv_11= ';' ( (lv_importSection_12_0= ruleImportSection ) )? ( (lv_mergeEntry_13_0= ruleMergeEntry ) )*
+ {
+ // ../de.ugoe.cs.swe.bnftools.ebnf/src-gen/de/ugoe/cs/swe/bnftools/parser/antlr/internal/InternalEbnf.g:214:7: ( (lv_type_10_0= '/merge' ) )
+ // ../de.ugoe.cs.swe.bnftools.ebnf/src-gen/de/ugoe/cs/swe/bnftools/parser/antlr/internal/InternalEbnf.g:215:1: (lv_type_10_0= '/merge' )
+ {
+ // ../de.ugoe.cs.swe.bnftools.ebnf/src-gen/de/ugoe/cs/swe/bnftools/parser/antlr/internal/InternalEbnf.g:215:1: (lv_type_10_0= '/merge' )
+ // ../de.ugoe.cs.swe.bnftools.ebnf/src-gen/de/ugoe/cs/swe/bnftools/parser/antlr/internal/InternalEbnf.g:216:3: lv_type_10_0= '/merge'
+ {
+ lv_type_10_0=(Token)match(input,17,FOLLOW_17_in_ruleEtsiBnf356);
+
+ newLeafNode(lv_type_10_0, grammarAccess.getEtsiBnfAccess().getTypeMergeKeyword_2_0_0());
+
+
+ if (current==null) {
+ current = createModelElement(grammarAccess.getEtsiBnfRule());
+ }
+ setWithLastConsumed(current, "type", lv_type_10_0, "/merge");
+
+
+ }
+
+
+ }
+
+ otherlv_11=(Token)match(input,15,FOLLOW_15_in_ruleEtsiBnf381);
+
+ newLeafNode(otherlv_11, grammarAccess.getEtsiBnfAccess().getSemicolonKeyword_2_1());
+
+ // ../de.ugoe.cs.swe.bnftools.ebnf/src-gen/de/ugoe/cs/swe/bnftools/parser/antlr/internal/InternalEbnf.g:233:1: ( (lv_importSection_12_0= ruleImportSection ) )?
+ int alt6=2;
+ int LA6_0 = input.LA(1);
+
+ if ( (LA6_0==18) ) {
+ alt6=1;
+ }
+ switch (alt6) {
+ case 1 :
+ // ../de.ugoe.cs.swe.bnftools.ebnf/src-gen/de/ugoe/cs/swe/bnftools/parser/antlr/internal/InternalEbnf.g:234:1: (lv_importSection_12_0= ruleImportSection )
+ {
+ // ../de.ugoe.cs.swe.bnftools.ebnf/src-gen/de/ugoe/cs/swe/bnftools/parser/antlr/internal/InternalEbnf.g:234:1: (lv_importSection_12_0= ruleImportSection )
+ // ../de.ugoe.cs.swe.bnftools.ebnf/src-gen/de/ugoe/cs/swe/bnftools/parser/antlr/internal/InternalEbnf.g:235:3: lv_importSection_12_0= ruleImportSection
+ {
+
+ newCompositeNode(grammarAccess.getEtsiBnfAccess().getImportSectionImportSectionParserRuleCall_2_2_0());
+
+ pushFollow(FOLLOW_ruleImportSection_in_ruleEtsiBnf402);
+ lv_importSection_12_0=ruleImportSection();
+
+ state._fsp--;
+
+
+ if (current==null) {
+ current = createModelElementForParent(grammarAccess.getEtsiBnfRule());
+ }
+ set(
+ current,
+ "importSection",
+ lv_importSection_12_0,
+ "ImportSection");
+ afterParserOrEnumRuleCall();
+
+
+ }
+
+
+ }
+ break;
+
+ }
+
+ // ../de.ugoe.cs.swe.bnftools.ebnf/src-gen/de/ugoe/cs/swe/bnftools/parser/antlr/internal/InternalEbnf.g:251:3: ( (lv_mergeEntry_13_0= ruleMergeEntry ) )*
+ loop7:
+ do {
+ int alt7=2;
+ int LA7_0 = input.LA(1);
+
+ if ( (LA7_0==RULE_SECTIONHEADER||LA7_0==36||(LA7_0>=38 && LA7_0<=39)) ) {
+ alt7=1;
+ }
+
+
+ switch (alt7) {
+ case 1 :
+ // ../de.ugoe.cs.swe.bnftools.ebnf/src-gen/de/ugoe/cs/swe/bnftools/parser/antlr/internal/InternalEbnf.g:252:1: (lv_mergeEntry_13_0= ruleMergeEntry )
+ {
+ // ../de.ugoe.cs.swe.bnftools.ebnf/src-gen/de/ugoe/cs/swe/bnftools/parser/antlr/internal/InternalEbnf.g:252:1: (lv_mergeEntry_13_0= ruleMergeEntry )
+ // ../de.ugoe.cs.swe.bnftools.ebnf/src-gen/de/ugoe/cs/swe/bnftools/parser/antlr/internal/InternalEbnf.g:253:3: lv_mergeEntry_13_0= ruleMergeEntry
+ {
+
+ newCompositeNode(grammarAccess.getEtsiBnfAccess().getMergeEntryMergeEntryParserRuleCall_2_3_0());
+
+ pushFollow(FOLLOW_ruleMergeEntry_in_ruleEtsiBnf424);
+ lv_mergeEntry_13_0=ruleMergeEntry();
+
+ state._fsp--;
+
+
+ if (current==null) {
+ current = createModelElementForParent(grammarAccess.getEtsiBnfRule());
+ }
+ add(
+ current,
+ "mergeEntry",
+ lv_mergeEntry_13_0,
+ "MergeEntry");
+ afterParserOrEnumRuleCall();
+
+
+ }
+
+
+ }
+ break;
+
+ default :
+ break loop7;
+ }
+ } while (true);
+
+
+ }
+
+
+ }
+ break;
+
+ }
+
+
+ }
+
+ leaveRule();
+ }
+
+ catch (RecognitionException re) {
+ recover(input,re);
+ appendSkippedTokens();
+ }
+ finally {
+ }
+ return current;
+ }
+ // $ANTLR end "ruleEtsiBnf"
+
+
+ // $ANTLR start "entryRuleImportSection"
+ // ../de.ugoe.cs.swe.bnftools.ebnf/src-gen/de/ugoe/cs/swe/bnftools/parser/antlr/internal/InternalEbnf.g:277:1: entryRuleImportSection returns [EObject current=null] : iv_ruleImportSection= ruleImportSection EOF ;
+ public final EObject entryRuleImportSection() throws RecognitionException {
+ EObject current = null;
+
+ EObject iv_ruleImportSection = null;
+
+
+ try {
+ // ../de.ugoe.cs.swe.bnftools.ebnf/src-gen/de/ugoe/cs/swe/bnftools/parser/antlr/internal/InternalEbnf.g:278:2: (iv_ruleImportSection= ruleImportSection EOF )
+ // ../de.ugoe.cs.swe.bnftools.ebnf/src-gen/de/ugoe/cs/swe/bnftools/parser/antlr/internal/InternalEbnf.g:279:2: iv_ruleImportSection= ruleImportSection EOF
+ {
+ newCompositeNode(grammarAccess.getImportSectionRule());
+ pushFollow(FOLLOW_ruleImportSection_in_entryRuleImportSection462);
+ iv_ruleImportSection=ruleImportSection();
+
+ state._fsp--;
+
+ current =iv_ruleImportSection;
+ match(input,EOF,FOLLOW_EOF_in_entryRuleImportSection472);
+
+ }
+
+ }
+
+ catch (RecognitionException re) {
+ recover(input,re);
+ appendSkippedTokens();
+ }
+ finally {
+ }
+ return current;
+ }
+ // $ANTLR end "entryRuleImportSection"
+
+
+ // $ANTLR start "ruleImportSection"
+ // ../de.ugoe.cs.swe.bnftools.ebnf/src-gen/de/ugoe/cs/swe/bnftools/parser/antlr/internal/InternalEbnf.g:286:1: ruleImportSection returns [EObject current=null] : ( (lv_imports_0_0= ruleImport ) )+ ;
+ public final EObject ruleImportSection() throws RecognitionException {
+ EObject current = null;
+
+ EObject lv_imports_0_0 = null;
+
+
+ enterRule();
+
+ try {
+ // ../de.ugoe.cs.swe.bnftools.ebnf/src-gen/de/ugoe/cs/swe/bnftools/parser/antlr/internal/InternalEbnf.g:289:28: ( ( (lv_imports_0_0= ruleImport ) )+ )
+ // ../de.ugoe.cs.swe.bnftools.ebnf/src-gen/de/ugoe/cs/swe/bnftools/parser/antlr/internal/InternalEbnf.g:290:1: ( (lv_imports_0_0= ruleImport ) )+
+ {
+ // ../de.ugoe.cs.swe.bnftools.ebnf/src-gen/de/ugoe/cs/swe/bnftools/parser/antlr/internal/InternalEbnf.g:290:1: ( (lv_imports_0_0= ruleImport ) )+
+ int cnt9=0;
+ loop9:
+ do {
+ int alt9=2;
+ int LA9_0 = input.LA(1);
+
+ if ( (LA9_0==18) ) {
+ alt9=1;
+ }
+
+
+ switch (alt9) {
+ case 1 :
+ // ../de.ugoe.cs.swe.bnftools.ebnf/src-gen/de/ugoe/cs/swe/bnftools/parser/antlr/internal/InternalEbnf.g:291:1: (lv_imports_0_0= ruleImport )
+ {
+ // ../de.ugoe.cs.swe.bnftools.ebnf/src-gen/de/ugoe/cs/swe/bnftools/parser/antlr/internal/InternalEbnf.g:291:1: (lv_imports_0_0= ruleImport )
+ // ../de.ugoe.cs.swe.bnftools.ebnf/src-gen/de/ugoe/cs/swe/bnftools/parser/antlr/internal/InternalEbnf.g:292:3: lv_imports_0_0= ruleImport
+ {
+
+ newCompositeNode(grammarAccess.getImportSectionAccess().getImportsImportParserRuleCall_0());
+
+ pushFollow(FOLLOW_ruleImport_in_ruleImportSection517);
+ lv_imports_0_0=ruleImport();
+
+ state._fsp--;
+
+
+ if (current==null) {
+ current = createModelElementForParent(grammarAccess.getImportSectionRule());
+ }
+ add(
+ current,
+ "imports",
+ lv_imports_0_0,
+ "Import");
+ afterParserOrEnumRuleCall();
+
+
+ }
+
+
+ }
+ break;
+
+ default :
+ if ( cnt9 >= 1 ) break loop9;
+ EarlyExitException eee =
+ new EarlyExitException(9, input);
+ throw eee;
+ }
+ cnt9++;
+ } while (true);
+
+
+ }
+
+ leaveRule();
+ }
+
+ catch (RecognitionException re) {
+ recover(input,re);
+ appendSkippedTokens();
+ }
+ finally {
+ }
+ return current;
+ }
+ // $ANTLR end "ruleImportSection"
+
+
+ // $ANTLR start "entryRuleBnfEntry"
+ // ../de.ugoe.cs.swe.bnftools.ebnf/src-gen/de/ugoe/cs/swe/bnftools/parser/antlr/internal/InternalEbnf.g:316:1: entryRuleBnfEntry returns [EObject current=null] : iv_ruleBnfEntry= ruleBnfEntry EOF ;
+ public final EObject entryRuleBnfEntry() throws RecognitionException {
+ EObject current = null;
+
+ EObject iv_ruleBnfEntry = null;
+
+
+ try {
+ // ../de.ugoe.cs.swe.bnftools.ebnf/src-gen/de/ugoe/cs/swe/bnftools/parser/antlr/internal/InternalEbnf.g:317:2: (iv_ruleBnfEntry= ruleBnfEntry EOF )
+ // ../de.ugoe.cs.swe.bnftools.ebnf/src-gen/de/ugoe/cs/swe/bnftools/parser/antlr/internal/InternalEbnf.g:318:2: iv_ruleBnfEntry= ruleBnfEntry EOF
+ {
+ newCompositeNode(grammarAccess.getBnfEntryRule());
+ pushFollow(FOLLOW_ruleBnfEntry_in_entryRuleBnfEntry553);
+ iv_ruleBnfEntry=ruleBnfEntry();
+
+ state._fsp--;
+
+ current =iv_ruleBnfEntry;
+ match(input,EOF,FOLLOW_EOF_in_entryRuleBnfEntry563);
+
+ }
+
+ }
+
+ catch (RecognitionException re) {
+ recover(input,re);
+ appendSkippedTokens();
+ }
+ finally {
+ }
+ return current;
+ }
+ // $ANTLR end "entryRuleBnfEntry"
+
+
+ // $ANTLR start "ruleBnfEntry"
+ // ../de.ugoe.cs.swe.bnftools.ebnf/src-gen/de/ugoe/cs/swe/bnftools/parser/antlr/internal/InternalEbnf.g:325:1: ruleBnfEntry returns [EObject current=null] : ( ( (lv_sectionheader_0_0= ruleSectionHeading ) ) | ( (lv_rule_1_0= ruleRule ) ) ) ;
+ public final EObject ruleBnfEntry() throws RecognitionException {
+ EObject current = null;
+
+ EObject lv_sectionheader_0_0 = null;
+
+ EObject lv_rule_1_0 = null;
+
+
+ enterRule();
+
+ try {
+ // ../de.ugoe.cs.swe.bnftools.ebnf/src-gen/de/ugoe/cs/swe/bnftools/parser/antlr/internal/InternalEbnf.g:328:28: ( ( ( (lv_sectionheader_0_0= ruleSectionHeading ) ) | ( (lv_rule_1_0= ruleRule ) ) ) )
+ // ../de.ugoe.cs.swe.bnftools.ebnf/src-gen/de/ugoe/cs/swe/bnftools/parser/antlr/internal/InternalEbnf.g:329:1: ( ( (lv_sectionheader_0_0= ruleSectionHeading ) ) | ( (lv_rule_1_0= ruleRule ) ) )
+ {
+ // ../de.ugoe.cs.swe.bnftools.ebnf/src-gen/de/ugoe/cs/swe/bnftools/parser/antlr/internal/InternalEbnf.g:329:1: ( ( (lv_sectionheader_0_0= ruleSectionHeading ) ) | ( (lv_rule_1_0= ruleRule ) ) )
+ int alt10=2;
+ int LA10_0 = input.LA(1);
+
+ if ( (LA10_0==RULE_SECTIONHEADER) ) {
+ alt10=1;
+ }
+ else if ( (LA10_0==RULE_ID||LA10_0==RULE_INT) ) {
+ alt10=2;
+ }
+ else {
+ NoViableAltException nvae =
+ new NoViableAltException("", 10, 0, input);
+
+ throw nvae;
+ }
+ switch (alt10) {
+ case 1 :
+ // ../de.ugoe.cs.swe.bnftools.ebnf/src-gen/de/ugoe/cs/swe/bnftools/parser/antlr/internal/InternalEbnf.g:329:2: ( (lv_sectionheader_0_0= ruleSectionHeading ) )
+ {
+ // ../de.ugoe.cs.swe.bnftools.ebnf/src-gen/de/ugoe/cs/swe/bnftools/parser/antlr/internal/InternalEbnf.g:329:2: ( (lv_sectionheader_0_0= ruleSectionHeading ) )
+ // ../de.ugoe.cs.swe.bnftools.ebnf/src-gen/de/ugoe/cs/swe/bnftools/parser/antlr/internal/InternalEbnf.g:330:1: (lv_sectionheader_0_0= ruleSectionHeading )
+ {
+ // ../de.ugoe.cs.swe.bnftools.ebnf/src-gen/de/ugoe/cs/swe/bnftools/parser/antlr/internal/InternalEbnf.g:330:1: (lv_sectionheader_0_0= ruleSectionHeading )
+ // ../de.ugoe.cs.swe.bnftools.ebnf/src-gen/de/ugoe/cs/swe/bnftools/parser/antlr/internal/InternalEbnf.g:331:3: lv_sectionheader_0_0= ruleSectionHeading
+ {
+
+ newCompositeNode(grammarAccess.getBnfEntryAccess().getSectionheaderSectionHeadingParserRuleCall_0_0());
+
+ pushFollow(FOLLOW_ruleSectionHeading_in_ruleBnfEntry609);
+ lv_sectionheader_0_0=ruleSectionHeading();
+
+ state._fsp--;
+
+
+ if (current==null) {
+ current = createModelElementForParent(grammarAccess.getBnfEntryRule());
+ }
+ set(
+ current,
+ "sectionheader",
+ lv_sectionheader_0_0,
+ "SectionHeading");
+ afterParserOrEnumRuleCall();
+
+
+ }
+
+
+ }
+
+
+ }
+ break;
+ case 2 :
+ // ../de.ugoe.cs.swe.bnftools.ebnf/src-gen/de/ugoe/cs/swe/bnftools/parser/antlr/internal/InternalEbnf.g:348:6: ( (lv_rule_1_0= ruleRule ) )
+ {
+ // ../de.ugoe.cs.swe.bnftools.ebnf/src-gen/de/ugoe/cs/swe/bnftools/parser/antlr/internal/InternalEbnf.g:348:6: ( (lv_rule_1_0= ruleRule ) )
+ // ../de.ugoe.cs.swe.bnftools.ebnf/src-gen/de/ugoe/cs/swe/bnftools/parser/antlr/internal/InternalEbnf.g:349:1: (lv_rule_1_0= ruleRule )
+ {
+ // ../de.ugoe.cs.swe.bnftools.ebnf/src-gen/de/ugoe/cs/swe/bnftools/parser/antlr/internal/InternalEbnf.g:349:1: (lv_rule_1_0= ruleRule )
+ // ../de.ugoe.cs.swe.bnftools.ebnf/src-gen/de/ugoe/cs/swe/bnftools/parser/antlr/internal/InternalEbnf.g:350:3: lv_rule_1_0= ruleRule
+ {
+
+ newCompositeNode(grammarAccess.getBnfEntryAccess().getRuleRuleParserRuleCall_1_0());
+
+ pushFollow(FOLLOW_ruleRule_in_ruleBnfEntry636);
+ lv_rule_1_0=ruleRule();
+
+ state._fsp--;
+
+
+ if (current==null) {
+ current = createModelElementForParent(grammarAccess.getBnfEntryRule());
+ }
+ set(
+ current,
+ "rule",
+ lv_rule_1_0,
+ "Rule");
+ afterParserOrEnumRuleCall();
+
+
+ }
+
+
+ }
+
+
+ }
+ break;
+
+ }
+
+
+ }
+
+ leaveRule();
+ }
+
+ catch (RecognitionException re) {
+ recover(input,re);
+ appendSkippedTokens();
+ }
+ finally {
+ }
+ return current;
+ }
+ // $ANTLR end "ruleBnfEntry"
+
+
+ // $ANTLR start "entryRuleDeltaEntry"
+ // ../de.ugoe.cs.swe.bnftools.ebnf/src-gen/de/ugoe/cs/swe/bnftools/parser/antlr/internal/InternalEbnf.g:374:1: entryRuleDeltaEntry returns [EObject current=null] : iv_ruleDeltaEntry= ruleDeltaEntry EOF ;
+ public final EObject entryRuleDeltaEntry() throws RecognitionException {
+ EObject current = null;
+
+ EObject iv_ruleDeltaEntry = null;
+
+
+ try {
+ // ../de.ugoe.cs.swe.bnftools.ebnf/src-gen/de/ugoe/cs/swe/bnftools/parser/antlr/internal/InternalEbnf.g:375:2: (iv_ruleDeltaEntry= ruleDeltaEntry EOF )
+ // ../de.ugoe.cs.swe.bnftools.ebnf/src-gen/de/ugoe/cs/swe/bnftools/parser/antlr/internal/InternalEbnf.g:376:2: iv_ruleDeltaEntry= ruleDeltaEntry EOF
+ {
+ newCompositeNode(grammarAccess.getDeltaEntryRule());
+ pushFollow(FOLLOW_ruleDeltaEntry_in_entryRuleDeltaEntry672);
+ iv_ruleDeltaEntry=ruleDeltaEntry();
+
+ state._fsp--;
+
+ current =iv_ruleDeltaEntry;
+ match(input,EOF,FOLLOW_EOF_in_entryRuleDeltaEntry682);
+
+ }
+
+ }
+
+ catch (RecognitionException re) {
+ recover(input,re);
+ appendSkippedTokens();
+ }
+ finally {
+ }
+ return current;
+ }
+ // $ANTLR end "entryRuleDeltaEntry"
+
+
+ // $ANTLR start "ruleDeltaEntry"
+ // ../de.ugoe.cs.swe.bnftools.ebnf/src-gen/de/ugoe/cs/swe/bnftools/parser/antlr/internal/InternalEbnf.g:383:1: ruleDeltaEntry returns [EObject current=null] : ( ( (lv_rule_0_0= ruleRule ) ) | ( (lv_sectionheader_1_0= ruleSectionHeading ) ) | ( (lv_extRule_2_0= ruleExtRule ) ) ) ;
+ public final EObject ruleDeltaEntry() throws RecognitionException {
+ EObject current = null;
+
+ EObject lv_rule_0_0 = null;
+
+ EObject lv_sectionheader_1_0 = null;
+
+ EObject lv_extRule_2_0 = null;
+
+
+ enterRule();
+
+ try {
+ // ../de.ugoe.cs.swe.bnftools.ebnf/src-gen/de/ugoe/cs/swe/bnftools/parser/antlr/internal/InternalEbnf.g:386:28: ( ( ( (lv_rule_0_0= ruleRule ) ) | ( (lv_sectionheader_1_0= ruleSectionHeading ) ) | ( (lv_extRule_2_0= ruleExtRule ) ) ) )
+ // ../de.ugoe.cs.swe.bnftools.ebnf/src-gen/de/ugoe/cs/swe/bnftools/parser/antlr/internal/InternalEbnf.g:387:1: ( ( (lv_rule_0_0= ruleRule ) ) | ( (lv_sectionheader_1_0= ruleSectionHeading ) ) | ( (lv_extRule_2_0= ruleExtRule ) ) )
+ {
+ // ../de.ugoe.cs.swe.bnftools.ebnf/src-gen/de/ugoe/cs/swe/bnftools/parser/antlr/internal/InternalEbnf.g:387:1: ( ( (lv_rule_0_0= ruleRule ) ) | ( (lv_sectionheader_1_0= ruleSectionHeading ) ) | ( (lv_extRule_2_0= ruleExtRule ) ) )
+ int alt11=3;
+ switch ( input.LA(1) ) {
+ case RULE_INT:
+ {
+ int LA11_1 = input.LA(2);
+
+ if ( (LA11_1==RULE_ID) ) {
+ int LA11_4 = input.LA(3);
+
+ if ( (LA11_4==24) ) {
+ int LA11_5 = input.LA(4);
+
+ if ( (LA11_5==RULE_ID) ) {
+ int LA11_2 = input.LA(5);
+
+ if ( (LA11_2==25) ) {
+ alt11=1;
+ }
+ else if ( (LA11_2==26) ) {
+ alt11=3;
+ }
+ else {
+ NoViableAltException nvae =
+ new NoViableAltException("", 11, 2, input);
+
+ throw nvae;
+ }
+ }
+ else {
+ NoViableAltException nvae =
+ new NoViableAltException("", 11, 5, input);
+
+ throw nvae;
+ }
+ }
+ else {
+ NoViableAltException nvae =
+ new NoViableAltException("", 11, 4, input);
+
+ throw nvae;
+ }
+ }
+ else if ( (LA11_1==24) ) {
+ int LA11_5 = input.LA(3);
+
+ if ( (LA11_5==RULE_ID) ) {
+ int LA11_2 = input.LA(4);
+
+ if ( (LA11_2==25) ) {
+ alt11=1;
+ }
+ else if ( (LA11_2==26) ) {
+ alt11=3;
+ }
+ else {
+ NoViableAltException nvae =
+ new NoViableAltException("", 11, 2, input);
+
+ throw nvae;
+ }
+ }
+ else {
+ NoViableAltException nvae =
+ new NoViableAltException("", 11, 5, input);
+
+ throw nvae;
+ }
+ }
+ else {
+ NoViableAltException nvae =
+ new NoViableAltException("", 11, 1, input);
+
+ throw nvae;
+ }
+ }
+ break;
+ case RULE_ID:
+ {
+ int LA11_2 = input.LA(2);
+
+ if ( (LA11_2==25) ) {
+ alt11=1;
+ }
+ else if ( (LA11_2==26) ) {
+ alt11=3;
+ }
+ else {
+ NoViableAltException nvae =
+ new NoViableAltException("", 11, 2, input);
+
+ throw nvae;
+ }
+ }
+ break;
+ case RULE_SECTIONHEADER:
+ {
+ alt11=2;
+ }
+ break;
+ default:
+ NoViableAltException nvae =
+ new NoViableAltException("", 11, 0, input);
+
+ throw nvae;
+ }
+
+ switch (alt11) {
+ case 1 :
+ // ../de.ugoe.cs.swe.bnftools.ebnf/src-gen/de/ugoe/cs/swe/bnftools/parser/antlr/internal/InternalEbnf.g:387:2: ( (lv_rule_0_0= ruleRule ) )
+ {
+ // ../de.ugoe.cs.swe.bnftools.ebnf/src-gen/de/ugoe/cs/swe/bnftools/parser/antlr/internal/InternalEbnf.g:387:2: ( (lv_rule_0_0= ruleRule ) )
+ // ../de.ugoe.cs.swe.bnftools.ebnf/src-gen/de/ugoe/cs/swe/bnftools/parser/antlr/internal/InternalEbnf.g:388:1: (lv_rule_0_0= ruleRule )
+ {
+ // ../de.ugoe.cs.swe.bnftools.ebnf/src-gen/de/ugoe/cs/swe/bnftools/parser/antlr/internal/InternalEbnf.g:388:1: (lv_rule_0_0= ruleRule )
+ // ../de.ugoe.cs.swe.bnftools.ebnf/src-gen/de/ugoe/cs/swe/bnftools/parser/antlr/internal/InternalEbnf.g:389:3: lv_rule_0_0= ruleRule
+ {
+
+ newCompositeNode(grammarAccess.getDeltaEntryAccess().getRuleRuleParserRuleCall_0_0());
+
+ pushFollow(FOLLOW_ruleRule_in_ruleDeltaEntry728);
+ lv_rule_0_0=ruleRule();
+
+ state._fsp--;
+
+
+ if (current==null) {
+ current = createModelElementForParent(grammarAccess.getDeltaEntryRule());
+ }
+ set(
+ current,
+ "rule",
+ lv_rule_0_0,
+ "Rule");
+ afterParserOrEnumRuleCall();
+
+
+ }
+
+
+ }
+
+
+ }
+ break;
+ case 2 :
+ // ../de.ugoe.cs.swe.bnftools.ebnf/src-gen/de/ugoe/cs/swe/bnftools/parser/antlr/internal/InternalEbnf.g:406:6: ( (lv_sectionheader_1_0= ruleSectionHeading ) )
+ {
+ // ../de.ugoe.cs.swe.bnftools.ebnf/src-gen/de/ugoe/cs/swe/bnftools/parser/antlr/internal/InternalEbnf.g:406:6: ( (lv_sectionheader_1_0= ruleSectionHeading ) )
+ // ../de.ugoe.cs.swe.bnftools.ebnf/src-gen/de/ugoe/cs/swe/bnftools/parser/antlr/internal/InternalEbnf.g:407:1: (lv_sectionheader_1_0= ruleSectionHeading )
+ {
+ // ../de.ugoe.cs.swe.bnftools.ebnf/src-gen/de/ugoe/cs/swe/bnftools/parser/antlr/internal/InternalEbnf.g:407:1: (lv_sectionheader_1_0= ruleSectionHeading )
+ // ../de.ugoe.cs.swe.bnftools.ebnf/src-gen/de/ugoe/cs/swe/bnftools/parser/antlr/internal/InternalEbnf.g:408:3: lv_sectionheader_1_0= ruleSectionHeading
+ {
+
+ newCompositeNode(grammarAccess.getDeltaEntryAccess().getSectionheaderSectionHeadingParserRuleCall_1_0());
+
+ pushFollow(FOLLOW_ruleSectionHeading_in_ruleDeltaEntry755);
+ lv_sectionheader_1_0=ruleSectionHeading();
+
+ state._fsp--;
+
+
+ if (current==null) {
+ current = createModelElementForParent(grammarAccess.getDeltaEntryRule());
+ }
+ set(
+ current,
+ "sectionheader",
+ lv_sectionheader_1_0,
+ "SectionHeading");
+ afterParserOrEnumRuleCall();
+
+
+ }
+
+
+ }
+
+
+ }
+ break;
+ case 3 :
+ // ../de.ugoe.cs.swe.bnftools.ebnf/src-gen/de/ugoe/cs/swe/bnftools/parser/antlr/internal/InternalEbnf.g:425:6: ( (lv_extRule_2_0= ruleExtRule ) )
+ {
+ // ../de.ugoe.cs.swe.bnftools.ebnf/src-gen/de/ugoe/cs/swe/bnftools/parser/antlr/internal/InternalEbnf.g:425:6: ( (lv_extRule_2_0= ruleExtRule ) )
+ // ../de.ugoe.cs.swe.bnftools.ebnf/src-gen/de/ugoe/cs/swe/bnftools/parser/antlr/internal/InternalEbnf.g:426:1: (lv_extRule_2_0= ruleExtRule )
+ {
+ // ../de.ugoe.cs.swe.bnftools.ebnf/src-gen/de/ugoe/cs/swe/bnftools/parser/antlr/internal/InternalEbnf.g:426:1: (lv_extRule_2_0= ruleExtRule )
+ // ../de.ugoe.cs.swe.bnftools.ebnf/src-gen/de/ugoe/cs/swe/bnftools/parser/antlr/internal/InternalEbnf.g:427:3: lv_extRule_2_0= ruleExtRule
+ {
+
+ newCompositeNode(grammarAccess.getDeltaEntryAccess().getExtRuleExtRuleParserRuleCall_2_0());
+
+ pushFollow(FOLLOW_ruleExtRule_in_ruleDeltaEntry782);
+ lv_extRule_2_0=ruleExtRule();
+
+ state._fsp--;
+
+
+ if (current==null) {
+ current = createModelElementForParent(grammarAccess.getDeltaEntryRule());
+ }
+ set(
+ current,
+ "extRule",
+ lv_extRule_2_0,
+ "ExtRule");
+ afterParserOrEnumRuleCall();
+
+
+ }
+
+
+ }
+
+
+ }
+ break;
+
+ }
+
+
+ }
+
+ leaveRule();
+ }
+
+ catch (RecognitionException re) {
+ recover(input,re);
+ appendSkippedTokens();
+ }
+ finally {
+ }
+ return current;
+ }
+ // $ANTLR end "ruleDeltaEntry"
+
+
+ // $ANTLR start "entryRuleMergeEntry"
+ // ../de.ugoe.cs.swe.bnftools.ebnf/src-gen/de/ugoe/cs/swe/bnftools/parser/antlr/internal/InternalEbnf.g:451:1: entryRuleMergeEntry returns [EObject current=null] : iv_ruleMergeEntry= ruleMergeEntry EOF ;
+ public final EObject entryRuleMergeEntry() throws RecognitionException {
+ EObject current = null;
+
+ EObject iv_ruleMergeEntry = null;
+
+
+ try {
+ // ../de.ugoe.cs.swe.bnftools.ebnf/src-gen/de/ugoe/cs/swe/bnftools/parser/antlr/internal/InternalEbnf.g:452:2: (iv_ruleMergeEntry= ruleMergeEntry EOF )
+ // ../de.ugoe.cs.swe.bnftools.ebnf/src-gen/de/ugoe/cs/swe/bnftools/parser/antlr/internal/InternalEbnf.g:453:2: iv_ruleMergeEntry= ruleMergeEntry EOF
+ {
+ newCompositeNode(grammarAccess.getMergeEntryRule());
+ pushFollow(FOLLOW_ruleMergeEntry_in_entryRuleMergeEntry818);
+ iv_ruleMergeEntry=ruleMergeEntry();
+
+ state._fsp--;
+
+ current =iv_ruleMergeEntry;
+ match(input,EOF,FOLLOW_EOF_in_entryRuleMergeEntry828);
+
+ }
+
+ }
+
+ catch (RecognitionException re) {
+ recover(input,re);
+ appendSkippedTokens();
+ }
+ finally {
+ }
+ return current;
+ }
+ // $ANTLR end "entryRuleMergeEntry"
+
+
+ // $ANTLR start "ruleMergeEntry"
+ // ../de.ugoe.cs.swe.bnftools.ebnf/src-gen/de/ugoe/cs/swe/bnftools/parser/antlr/internal/InternalEbnf.g:460:1: ruleMergeEntry returns [EObject current=null] : ( ( (lv_sectionheader_0_0= ruleSectionHeading ) ) | ( (lv_mergeRule_1_0= ruleMergeRule ) ) ) ;
+ public final EObject ruleMergeEntry() throws RecognitionException {
+ EObject current = null;
+
+ EObject lv_sectionheader_0_0 = null;
+
+ EObject lv_mergeRule_1_0 = null;
+
+
+ enterRule();
+
+ try {
+ // ../de.ugoe.cs.swe.bnftools.ebnf/src-gen/de/ugoe/cs/swe/bnftools/parser/antlr/internal/InternalEbnf.g:463:28: ( ( ( (lv_sectionheader_0_0= ruleSectionHeading ) ) | ( (lv_mergeRule_1_0= ruleMergeRule ) ) ) )
+ // ../de.ugoe.cs.swe.bnftools.ebnf/src-gen/de/ugoe/cs/swe/bnftools/parser/antlr/internal/InternalEbnf.g:464:1: ( ( (lv_sectionheader_0_0= ruleSectionHeading ) ) | ( (lv_mergeRule_1_0= ruleMergeRule ) ) )
+ {
+ // ../de.ugoe.cs.swe.bnftools.ebnf/src-gen/de/ugoe/cs/swe/bnftools/parser/antlr/internal/InternalEbnf.g:464:1: ( ( (lv_sectionheader_0_0= ruleSectionHeading ) ) | ( (lv_mergeRule_1_0= ruleMergeRule ) ) )
+ int alt12=2;
+ int LA12_0 = input.LA(1);
+
+ if ( (LA12_0==RULE_SECTIONHEADER) ) {
+ alt12=1;
+ }
+ else if ( (LA12_0==36||(LA12_0>=38 && LA12_0<=39)) ) {
+ alt12=2;
+ }
+ else {
+ NoViableAltException nvae =
+ new NoViableAltException("", 12, 0, input);
+
+ throw nvae;
+ }
+ switch (alt12) {
+ case 1 :
+ // ../de.ugoe.cs.swe.bnftools.ebnf/src-gen/de/ugoe/cs/swe/bnftools/parser/antlr/internal/InternalEbnf.g:464:2: ( (lv_sectionheader_0_0= ruleSectionHeading ) )
+ {
+ // ../de.ugoe.cs.swe.bnftools.ebnf/src-gen/de/ugoe/cs/swe/bnftools/parser/antlr/internal/InternalEbnf.g:464:2: ( (lv_sectionheader_0_0= ruleSectionHeading ) )
+ // ../de.ugoe.cs.swe.bnftools.ebnf/src-gen/de/ugoe/cs/swe/bnftools/parser/antlr/internal/InternalEbnf.g:465:1: (lv_sectionheader_0_0= ruleSectionHeading )
+ {
+ // ../de.ugoe.cs.swe.bnftools.ebnf/src-gen/de/ugoe/cs/swe/bnftools/parser/antlr/internal/InternalEbnf.g:465:1: (lv_sectionheader_0_0= ruleSectionHeading )
+ // ../de.ugoe.cs.swe.bnftools.ebnf/src-gen/de/ugoe/cs/swe/bnftools/parser/antlr/internal/InternalEbnf.g:466:3: lv_sectionheader_0_0= ruleSectionHeading
+ {
+
+ newCompositeNode(grammarAccess.getMergeEntryAccess().getSectionheaderSectionHeadingParserRuleCall_0_0());
+
+ pushFollow(FOLLOW_ruleSectionHeading_in_ruleMergeEntry874);
+ lv_sectionheader_0_0=ruleSectionHeading();
+
+ state._fsp--;
+
+
+ if (current==null) {
+ current = createModelElementForParent(grammarAccess.getMergeEntryRule());
+ }
+ set(
+ current,
+ "sectionheader",
+ lv_sectionheader_0_0,
+ "SectionHeading");
+ afterParserOrEnumRuleCall();
+
+
+ }
+
+
+ }
+
+
+ }
+ break;
+ case 2 :
+ // ../de.ugoe.cs.swe.bnftools.ebnf/src-gen/de/ugoe/cs/swe/bnftools/parser/antlr/internal/InternalEbnf.g:483:6: ( (lv_mergeRule_1_0= ruleMergeRule ) )
+ {
+ // ../de.ugoe.cs.swe.bnftools.ebnf/src-gen/de/ugoe/cs/swe/bnftools/parser/antlr/internal/InternalEbnf.g:483:6: ( (lv_mergeRule_1_0= ruleMergeRule ) )
+ // ../de.ugoe.cs.swe.bnftools.ebnf/src-gen/de/ugoe/cs/swe/bnftools/parser/antlr/internal/InternalEbnf.g:484:1: (lv_mergeRule_1_0= ruleMergeRule )
+ {
+ // ../de.ugoe.cs.swe.bnftools.ebnf/src-gen/de/ugoe/cs/swe/bnftools/parser/antlr/internal/InternalEbnf.g:484:1: (lv_mergeRule_1_0= ruleMergeRule )
+ // ../de.ugoe.cs.swe.bnftools.ebnf/src-gen/de/ugoe/cs/swe/bnftools/parser/antlr/internal/InternalEbnf.g:485:3: lv_mergeRule_1_0= ruleMergeRule
+ {
+
+ newCompositeNode(grammarAccess.getMergeEntryAccess().getMergeRuleMergeRuleParserRuleCall_1_0());
+
+ pushFollow(FOLLOW_ruleMergeRule_in_ruleMergeEntry901);
+ lv_mergeRule_1_0=ruleMergeRule();
+
+ state._fsp--;
+
+
+ if (current==null) {
+ current = createModelElementForParent(grammarAccess.getMergeEntryRule());
+ }
+ set(
+ current,
+ "mergeRule",
+ lv_mergeRule_1_0,
+ "MergeRule");
+ afterParserOrEnumRuleCall();
+
+
+ }
+
+
+ }
+
+
+ }
+ break;
+
+ }
+
+
+ }
+
+ leaveRule();
+ }
+
+ catch (RecognitionException re) {
+ recover(input,re);
+ appendSkippedTokens();
+ }
+ finally {
+ }
+ return current;
+ }
+ // $ANTLR end "ruleMergeEntry"
+
+
+ // $ANTLR start "entryRuleSectionHeading"
+ // ../de.ugoe.cs.swe.bnftools.ebnf/src-gen/de/ugoe/cs/swe/bnftools/parser/antlr/internal/InternalEbnf.g:509:1: entryRuleSectionHeading returns [EObject current=null] : iv_ruleSectionHeading= ruleSectionHeading EOF ;
+ public final EObject entryRuleSectionHeading() throws RecognitionException {
+ EObject current = null;
+
+ EObject iv_ruleSectionHeading = null;
+
+
+ try {
+ // ../de.ugoe.cs.swe.bnftools.ebnf/src-gen/de/ugoe/cs/swe/bnftools/parser/antlr/internal/InternalEbnf.g:510:2: (iv_ruleSectionHeading= ruleSectionHeading EOF )
+ // ../de.ugoe.cs.swe.bnftools.ebnf/src-gen/de/ugoe/cs/swe/bnftools/parser/antlr/internal/InternalEbnf.g:511:2: iv_ruleSectionHeading= ruleSectionHeading EOF
+ {
+ newCompositeNode(grammarAccess.getSectionHeadingRule());
+ pushFollow(FOLLOW_ruleSectionHeading_in_entryRuleSectionHeading937);
+ iv_ruleSectionHeading=ruleSectionHeading();
+
+ state._fsp--;
+
+ current =iv_ruleSectionHeading;
+ match(input,EOF,FOLLOW_EOF_in_entryRuleSectionHeading947);
+
+ }
+
+ }
+
+ catch (RecognitionException re) {
+ recover(input,re);
+ appendSkippedTokens();
+ }
+ finally {
+ }
+ return current;
+ }
+ // $ANTLR end "entryRuleSectionHeading"
+
+
+ // $ANTLR start "ruleSectionHeading"
+ // ../de.ugoe.cs.swe.bnftools.ebnf/src-gen/de/ugoe/cs/swe/bnftools/parser/antlr/internal/InternalEbnf.g:518:1: ruleSectionHeading returns [EObject current=null] : ( () ( (lv_sectionHeader_1_0= RULE_SECTIONHEADER ) ) ) ;
+ public final EObject ruleSectionHeading() throws RecognitionException {
+ EObject current = null;
+
+ Token lv_sectionHeader_1_0=null;
+
+ enterRule();
+
+ try {
+ // ../de.ugoe.cs.swe.bnftools.ebnf/src-gen/de/ugoe/cs/swe/bnftools/parser/antlr/internal/InternalEbnf.g:521:28: ( ( () ( (lv_sectionHeader_1_0= RULE_SECTIONHEADER ) ) ) )
+ // ../de.ugoe.cs.swe.bnftools.ebnf/src-gen/de/ugoe/cs/swe/bnftools/parser/antlr/internal/InternalEbnf.g:522:1: ( () ( (lv_sectionHeader_1_0= RULE_SECTIONHEADER ) ) )
+ {
+ // ../de.ugoe.cs.swe.bnftools.ebnf/src-gen/de/ugoe/cs/swe/bnftools/parser/antlr/internal/InternalEbnf.g:522:1: ( () ( (lv_sectionHeader_1_0= RULE_SECTIONHEADER ) ) )
+ // ../de.ugoe.cs.swe.bnftools.ebnf/src-gen/de/ugoe/cs/swe/bnftools/parser/antlr/internal/InternalEbnf.g:522:2: () ( (lv_sectionHeader_1_0= RULE_SECTIONHEADER ) )
+ {
+ // ../de.ugoe.cs.swe.bnftools.ebnf/src-gen/de/ugoe/cs/swe/bnftools/parser/antlr/internal/InternalEbnf.g:522:2: ()
+ // ../de.ugoe.cs.swe.bnftools.ebnf/src-gen/de/ugoe/cs/swe/bnftools/parser/antlr/internal/InternalEbnf.g:523:5:
+ {
+
+ current = forceCreateModelElement(
+ grammarAccess.getSectionHeadingAccess().getSectionHeadingAction_0(),
+ current);
+
+
+ }
+
+ // ../de.ugoe.cs.swe.bnftools.ebnf/src-gen/de/ugoe/cs/swe/bnftools/parser/antlr/internal/InternalEbnf.g:528:2: ( (lv_sectionHeader_1_0= RULE_SECTIONHEADER ) )
+ // ../de.ugoe.cs.swe.bnftools.ebnf/src-gen/de/ugoe/cs/swe/bnftools/parser/antlr/internal/InternalEbnf.g:529:1: (lv_sectionHeader_1_0= RULE_SECTIONHEADER )
+ {
+ // ../de.ugoe.cs.swe.bnftools.ebnf/src-gen/de/ugoe/cs/swe/bnftools/parser/antlr/internal/InternalEbnf.g:529:1: (lv_sectionHeader_1_0= RULE_SECTIONHEADER )
+ // ../de.ugoe.cs.swe.bnftools.ebnf/src-gen/de/ugoe/cs/swe/bnftools/parser/antlr/internal/InternalEbnf.g:530:3: lv_sectionHeader_1_0= RULE_SECTIONHEADER
+ {
+ lv_sectionHeader_1_0=(Token)match(input,RULE_SECTIONHEADER,FOLLOW_RULE_SECTIONHEADER_in_ruleSectionHeading998);
+
+ newLeafNode(lv_sectionHeader_1_0, grammarAccess.getSectionHeadingAccess().getSectionHeaderSECTIONHEADERTerminalRuleCall_1_0());
+
+
+ if (current==null) {
+ current = createModelElement(grammarAccess.getSectionHeadingRule());
+ }
+ setWithLastConsumed(
+ current,
+ "sectionHeader",
+ lv_sectionHeader_1_0,
+ "SECTIONHEADER");
+
+
+ }
+
+
+ }
+
+
+ }
+
+
+ }
+
+ leaveRule();
+ }
+
+ catch (RecognitionException re) {
+ recover(input,re);
+ appendSkippedTokens();
+ }
+ finally {
+ }
+ return current;
+ }
+ // $ANTLR end "ruleSectionHeading"
+
+
+ // $ANTLR start "entryRuleImport"
+ // ../de.ugoe.cs.swe.bnftools.ebnf/src-gen/de/ugoe/cs/swe/bnftools/parser/antlr/internal/InternalEbnf.g:554:1: entryRuleImport returns [EObject current=null] : iv_ruleImport= ruleImport EOF ;
+ public final EObject entryRuleImport() throws RecognitionException {
+ EObject current = null;
+
+ EObject iv_ruleImport = null;
+
+
+ try {
+ // ../de.ugoe.cs.swe.bnftools.ebnf/src-gen/de/ugoe/cs/swe/bnftools/parser/antlr/internal/InternalEbnf.g:555:2: (iv_ruleImport= ruleImport EOF )
+ // ../de.ugoe.cs.swe.bnftools.ebnf/src-gen/de/ugoe/cs/swe/bnftools/parser/antlr/internal/InternalEbnf.g:556:2: iv_ruleImport= ruleImport EOF
+ {
+ newCompositeNode(grammarAccess.getImportRule());
+ pushFollow(FOLLOW_ruleImport_in_entryRuleImport1039);
+ iv_ruleImport=ruleImport();
+
+ state._fsp--;
+
+ current =iv_ruleImport;
+ match(input,EOF,FOLLOW_EOF_in_entryRuleImport1049);
+
+ }
+
+ }
+
+ catch (RecognitionException re) {
+ recover(input,re);
+ appendSkippedTokens();
+ }
+ finally {
+ }
+ return current;
+ }
+ // $ANTLR end "entryRuleImport"
+
+
+ // $ANTLR start "ruleImport"
+ // ../de.ugoe.cs.swe.bnftools.ebnf/src-gen/de/ugoe/cs/swe/bnftools/parser/antlr/internal/InternalEbnf.g:563:1: ruleImport returns [EObject current=null] : (otherlv_0= 'import' ( (lv_importURI_1_0= RULE_STRING ) ) (otherlv_2= '/' ( ( (lv_grammarType_3_0= 'core' ) ) | ( (lv_grammarType_4_0= 'package' ) ) | ( (lv_grammarType_5_0= 'update' ) ) ) )? (otherlv_6= 'label:' ( (lv_label_7_0= RULE_ID ) ) )? otherlv_8= ';' ) ;
+ public final EObject ruleImport() throws RecognitionException {
+ EObject current = null;
+
+ Token otherlv_0=null;
+ Token lv_importURI_1_0=null;
+ Token otherlv_2=null;
+ Token lv_grammarType_3_0=null;
+ Token lv_grammarType_4_0=null;
+ Token lv_grammarType_5_0=null;
+ Token otherlv_6=null;
+ Token lv_label_7_0=null;
+ Token otherlv_8=null;
+
+ enterRule();
+
+ try {
+ // ../de.ugoe.cs.swe.bnftools.ebnf/src-gen/de/ugoe/cs/swe/bnftools/parser/antlr/internal/InternalEbnf.g:566:28: ( (otherlv_0= 'import' ( (lv_importURI_1_0= RULE_STRING ) ) (otherlv_2= '/' ( ( (lv_grammarType_3_0= 'core' ) ) | ( (lv_grammarType_4_0= 'package' ) ) | ( (lv_grammarType_5_0= 'update' ) ) ) )? (otherlv_6= 'label:' ( (lv_label_7_0= RULE_ID ) ) )? otherlv_8= ';' ) )
+ // ../de.ugoe.cs.swe.bnftools.ebnf/src-gen/de/ugoe/cs/swe/bnftools/parser/antlr/internal/InternalEbnf.g:567:1: (otherlv_0= 'import' ( (lv_importURI_1_0= RULE_STRING ) ) (otherlv_2= '/' ( ( (lv_grammarType_3_0= 'core' ) ) | ( (lv_grammarType_4_0= 'package' ) ) | ( (lv_grammarType_5_0= 'update' ) ) ) )? (otherlv_6= 'label:' ( (lv_label_7_0= RULE_ID ) ) )? otherlv_8= ';' )
+ {
+ // ../de.ugoe.cs.swe.bnftools.ebnf/src-gen/de/ugoe/cs/swe/bnftools/parser/antlr/internal/InternalEbnf.g:567:1: (otherlv_0= 'import' ( (lv_importURI_1_0= RULE_STRING ) ) (otherlv_2= '/' ( ( (lv_grammarType_3_0= 'core' ) ) | ( (lv_grammarType_4_0= 'package' ) ) | ( (lv_grammarType_5_0= 'update' ) ) ) )? (otherlv_6= 'label:' ( (lv_label_7_0= RULE_ID ) ) )? otherlv_8= ';' )
+ // ../de.ugoe.cs.swe.bnftools.ebnf/src-gen/de/ugoe/cs/swe/bnftools/parser/antlr/internal/InternalEbnf.g:567:3: otherlv_0= 'import' ( (lv_importURI_1_0= RULE_STRING ) ) (otherlv_2= '/' ( ( (lv_grammarType_3_0= 'core' ) ) | ( (lv_grammarType_4_0= 'package' ) ) | ( (lv_grammarType_5_0= 'update' ) ) ) )? (otherlv_6= 'label:' ( (lv_label_7_0= RULE_ID ) ) )? otherlv_8= ';'
+ {
+ otherlv_0=(Token)match(input,18,FOLLOW_18_in_ruleImport1086);
+
+ newLeafNode(otherlv_0, grammarAccess.getImportAccess().getImportKeyword_0());
+
+ // ../de.ugoe.cs.swe.bnftools.ebnf/src-gen/de/ugoe/cs/swe/bnftools/parser/antlr/internal/InternalEbnf.g:571:1: ( (lv_importURI_1_0= RULE_STRING ) )
+ // ../de.ugoe.cs.swe.bnftools.ebnf/src-gen/de/ugoe/cs/swe/bnftools/parser/antlr/internal/InternalEbnf.g:572:1: (lv_importURI_1_0= RULE_STRING )
+ {
+ // ../de.ugoe.cs.swe.bnftools.ebnf/src-gen/de/ugoe/cs/swe/bnftools/parser/antlr/internal/InternalEbnf.g:572:1: (lv_importURI_1_0= RULE_STRING )
+ // ../de.ugoe.cs.swe.bnftools.ebnf/src-gen/de/ugoe/cs/swe/bnftools/parser/antlr/internal/InternalEbnf.g:573:3: lv_importURI_1_0= RULE_STRING
+ {
+ lv_importURI_1_0=(Token)match(input,RULE_STRING,FOLLOW_RULE_STRING_in_ruleImport1103);
+
+ newLeafNode(lv_importURI_1_0, grammarAccess.getImportAccess().getImportURISTRINGTerminalRuleCall_1_0());
+
+
+ if (current==null) {
+ current = createModelElement(grammarAccess.getImportRule());
+ }
+ setWithLastConsumed(
+ current,
+ "importURI",
+ lv_importURI_1_0,
+ "STRING");
+
+
+ }
+
+
+ }
+
+ // ../de.ugoe.cs.swe.bnftools.ebnf/src-gen/de/ugoe/cs/swe/bnftools/parser/antlr/internal/InternalEbnf.g:589:2: (otherlv_2= '/' ( ( (lv_grammarType_3_0= 'core' ) ) | ( (lv_grammarType_4_0= 'package' ) ) | ( (lv_grammarType_5_0= 'update' ) ) ) )?
+ int alt14=2;
+ int LA14_0 = input.LA(1);
+
+ if ( (LA14_0==19) ) {
+ alt14=1;
+ }
+ switch (alt14) {
+ case 1 :
+ // ../de.ugoe.cs.swe.bnftools.ebnf/src-gen/de/ugoe/cs/swe/bnftools/parser/antlr/internal/InternalEbnf.g:589:4: otherlv_2= '/' ( ( (lv_grammarType_3_0= 'core' ) ) | ( (lv_grammarType_4_0= 'package' ) ) | ( (lv_grammarType_5_0= 'update' ) ) )
+ {
+ otherlv_2=(Token)match(input,19,FOLLOW_19_in_ruleImport1121);
+
+ newLeafNode(otherlv_2, grammarAccess.getImportAccess().getSolidusKeyword_2_0());
+
+ // ../de.ugoe.cs.swe.bnftools.ebnf/src-gen/de/ugoe/cs/swe/bnftools/parser/antlr/internal/InternalEbnf.g:593:1: ( ( (lv_grammarType_3_0= 'core' ) ) | ( (lv_grammarType_4_0= 'package' ) ) | ( (lv_grammarType_5_0= 'update' ) ) )
+ int alt13=3;
+ switch ( input.LA(1) ) {
+ case 20:
+ {
+ alt13=1;
+ }
+ break;
+ case 21:
+ {
+ alt13=2;
+ }
+ break;
+ case 22:
+ {
+ alt13=3;
+ }
+ break;
+ default:
+ NoViableAltException nvae =
+ new NoViableAltException("", 13, 0, input);
+
+ throw nvae;
+ }
+
+ switch (alt13) {
+ case 1 :
+ // ../de.ugoe.cs.swe.bnftools.ebnf/src-gen/de/ugoe/cs/swe/bnftools/parser/antlr/internal/InternalEbnf.g:593:2: ( (lv_grammarType_3_0= 'core' ) )
+ {
+ // ../de.ugoe.cs.swe.bnftools.ebnf/src-gen/de/ugoe/cs/swe/bnftools/parser/antlr/internal/InternalEbnf.g:593:2: ( (lv_grammarType_3_0= 'core' ) )
+ // ../de.ugoe.cs.swe.bnftools.ebnf/src-gen/de/ugoe/cs/swe/bnftools/parser/antlr/internal/InternalEbnf.g:594:1: (lv_grammarType_3_0= 'core' )
+ {
+ // ../de.ugoe.cs.swe.bnftools.ebnf/src-gen/de/ugoe/cs/swe/bnftools/parser/antlr/internal/InternalEbnf.g:594:1: (lv_grammarType_3_0= 'core' )
+ // ../de.ugoe.cs.swe.bnftools.ebnf/src-gen/de/ugoe/cs/swe/bnftools/parser/antlr/internal/InternalEbnf.g:595:3: lv_grammarType_3_0= 'core'
+ {
+ lv_grammarType_3_0=(Token)match(input,20,FOLLOW_20_in_ruleImport1140);
+
+ newLeafNode(lv_grammarType_3_0, grammarAccess.getImportAccess().getGrammarTypeCoreKeyword_2_1_0_0());
+
+
+ if (current==null) {
+ current = createModelElement(grammarAccess.getImportRule());
+ }
+ setWithLastConsumed(current, "grammarType", lv_grammarType_3_0, "core");
+
+
+ }
+
+
+ }
+
+
+ }
+ break;
+ case 2 :
+ // ../de.ugoe.cs.swe.bnftools.ebnf/src-gen/de/ugoe/cs/swe/bnftools/parser/antlr/internal/InternalEbnf.g:609:6: ( (lv_grammarType_4_0= 'package' ) )
+ {
+ // ../de.ugoe.cs.swe.bnftools.ebnf/src-gen/de/ugoe/cs/swe/bnftools/parser/antlr/internal/InternalEbnf.g:609:6: ( (lv_grammarType_4_0= 'package' ) )
+ // ../de.ugoe.cs.swe.bnftools.ebnf/src-gen/de/ugoe/cs/swe/bnftools/parser/antlr/internal/InternalEbnf.g:610:1: (lv_grammarType_4_0= 'package' )
+ {
+ // ../de.ugoe.cs.swe.bnftools.ebnf/src-gen/de/ugoe/cs/swe/bnftools/parser/antlr/internal/InternalEbnf.g:610:1: (lv_grammarType_4_0= 'package' )
+ // ../de.ugoe.cs.swe.bnftools.ebnf/src-gen/de/ugoe/cs/swe/bnftools/parser/antlr/internal/InternalEbnf.g:611:3: lv_grammarType_4_0= 'package'
+ {
+ lv_grammarType_4_0=(Token)match(input,21,FOLLOW_21_in_ruleImport1177);
+
+ newLeafNode(lv_grammarType_4_0, grammarAccess.getImportAccess().getGrammarTypePackageKeyword_2_1_1_0());
+
+
+ if (current==null) {
+ current = createModelElement(grammarAccess.getImportRule());
+ }
+ setWithLastConsumed(current, "grammarType", lv_grammarType_4_0, "package");
+
+
+ }
+
+
+ }
+
+
+ }
+ break;
+ case 3 :
+ // ../de.ugoe.cs.swe.bnftools.ebnf/src-gen/de/ugoe/cs/swe/bnftools/parser/antlr/internal/InternalEbnf.g:625:6: ( (lv_grammarType_5_0= 'update' ) )
+ {
+ // ../de.ugoe.cs.swe.bnftools.ebnf/src-gen/de/ugoe/cs/swe/bnftools/parser/antlr/internal/InternalEbnf.g:625:6: ( (lv_grammarType_5_0= 'update' ) )
+ // ../de.ugoe.cs.swe.bnftools.ebnf/src-gen/de/ugoe/cs/swe/bnftools/parser/antlr/internal/InternalEbnf.g:626:1: (lv_grammarType_5_0= 'update' )
+ {
+ // ../de.ugoe.cs.swe.bnftools.ebnf/src-gen/de/ugoe/cs/swe/bnftools/parser/antlr/internal/InternalEbnf.g:626:1: (lv_grammarType_5_0= 'update' )
+ // ../de.ugoe.cs.swe.bnftools.ebnf/src-gen/de/ugoe/cs/swe/bnftools/parser/antlr/internal/InternalEbnf.g:627:3: lv_grammarType_5_0= 'update'
+ {
+ lv_grammarType_5_0=(Token)match(input,22,FOLLOW_22_in_ruleImport1214);
+
+ newLeafNode(lv_grammarType_5_0, grammarAccess.getImportAccess().getGrammarTypeUpdateKeyword_2_1_2_0());
+
+
+ if (current==null) {
+ current = createModelElement(grammarAccess.getImportRule());
+ }
+ setWithLastConsumed(current, "grammarType", lv_grammarType_5_0, "update");
+
+
+ }
+
+
+ }
+
+
+ }
+ break;
+
+ }
+
+
+ }
+ break;
+
+ }
+
+ // ../de.ugoe.cs.swe.bnftools.ebnf/src-gen/de/ugoe/cs/swe/bnftools/parser/antlr/internal/InternalEbnf.g:640:5: (otherlv_6= 'label:' ( (lv_label_7_0= RULE_ID ) ) )?
+ int alt15=2;
+ int LA15_0 = input.LA(1);
+
+ if ( (LA15_0==23) ) {
+ alt15=1;
+ }
+ switch (alt15) {
+ case 1 :
+ // ../de.ugoe.cs.swe.bnftools.ebnf/src-gen/de/ugoe/cs/swe/bnftools/parser/antlr/internal/InternalEbnf.g:640:7: otherlv_6= 'label:' ( (lv_label_7_0= RULE_ID ) )
+ {
+ otherlv_6=(Token)match(input,23,FOLLOW_23_in_ruleImport1243);
+
+ newLeafNode(otherlv_6, grammarAccess.getImportAccess().getLabelKeyword_3_0());
+
+ // ../de.ugoe.cs.swe.bnftools.ebnf/src-gen/de/ugoe/cs/swe/bnftools/parser/antlr/internal/InternalEbnf.g:644:1: ( (lv_label_7_0= RULE_ID ) )
+ // ../de.ugoe.cs.swe.bnftools.ebnf/src-gen/de/ugoe/cs/swe/bnftools/parser/antlr/internal/InternalEbnf.g:645:1: (lv_label_7_0= RULE_ID )
+ {
+ // ../de.ugoe.cs.swe.bnftools.ebnf/src-gen/de/ugoe/cs/swe/bnftools/parser/antlr/internal/InternalEbnf.g:645:1: (lv_label_7_0= RULE_ID )
+ // ../de.ugoe.cs.swe.bnftools.ebnf/src-gen/de/ugoe/cs/swe/bnftools/parser/antlr/internal/InternalEbnf.g:646:3: lv_label_7_0= RULE_ID
+ {
+ lv_label_7_0=(Token)match(input,RULE_ID,FOLLOW_RULE_ID_in_ruleImport1260);
+
+ newLeafNode(lv_label_7_0, grammarAccess.getImportAccess().getLabelIDTerminalRuleCall_3_1_0());
+
+
+ if (current==null) {
+ current = createModelElement(grammarAccess.getImportRule());
+ }
+ setWithLastConsumed(
+ current,
+ "label",
+ lv_label_7_0,
+ "ID");
+
+
+ }
+
+
+ }
+
+
+ }
+ break;
+
+ }
+
+ otherlv_8=(Token)match(input,15,FOLLOW_15_in_ruleImport1279);
+
+ newLeafNode(otherlv_8, grammarAccess.getImportAccess().getSemicolonKeyword_4());
+
+
+ }
+
+
+ }
+
+ leaveRule();
+ }
+
+ catch (RecognitionException re) {
+ recover(input,re);
+ appendSkippedTokens();
+ }
+ finally {
+ }
+ return current;
+ }
+ // $ANTLR end "ruleImport"
+
+
+ // $ANTLR start "entryRuleRule"
+ // ../de.ugoe.cs.swe.bnftools.ebnf/src-gen/de/ugoe/cs/swe/bnftools/parser/antlr/internal/InternalEbnf.g:674:1: entryRuleRule returns [EObject current=null] : iv_ruleRule= ruleRule EOF ;
+ public final EObject entryRuleRule() throws RecognitionException {
+ EObject current = null;
+
+ EObject iv_ruleRule = null;
+
+
+ try {
+ // ../de.ugoe.cs.swe.bnftools.ebnf/src-gen/de/ugoe/cs/swe/bnftools/parser/antlr/internal/InternalEbnf.g:675:2: (iv_ruleRule= ruleRule EOF )
+ // ../de.ugoe.cs.swe.bnftools.ebnf/src-gen/de/ugoe/cs/swe/bnftools/parser/antlr/internal/InternalEbnf.g:676:2: iv_ruleRule= ruleRule EOF
+ {
+ newCompositeNode(grammarAccess.getRuleRule());
+ pushFollow(FOLLOW_ruleRule_in_entryRuleRule1315);
+ iv_ruleRule=ruleRule();
+
+ state._fsp--;
+
+ current =iv_ruleRule;
+ match(input,EOF,FOLLOW_EOF_in_entryRuleRule1325);
+
+ }
+
+ }
+
+ catch (RecognitionException re) {
+ recover(input,re);
+ appendSkippedTokens();
+ }
+ finally {
+ }
+ return current;
+ }
+ // $ANTLR end "entryRuleRule"
+
+
+ // $ANTLR start "ruleRule"
+ // ../de.ugoe.cs.swe.bnftools.ebnf/src-gen/de/ugoe/cs/swe/bnftools/parser/antlr/internal/InternalEbnf.g:683:1: ruleRule returns [EObject current=null] : ( ( ( (lv_rulenumber_0_0= RULE_INT ) ) ( (lv_rulevariant_1_0= RULE_ID ) )? otherlv_2= '.' )? ( (lv_name_3_0= RULE_ID ) ) otherlv_4= '::=' ( (lv_definitionList_5_0= ruleDefinitionList ) )? (otherlv_6= ';' )? ) ;
+ public final EObject ruleRule() throws RecognitionException {
+ EObject current = null;
+
+ Token lv_rulenumber_0_0=null;
+ Token lv_rulevariant_1_0=null;
+ Token otherlv_2=null;
+ Token lv_name_3_0=null;
+ Token otherlv_4=null;
+ Token otherlv_6=null;
+ EObject lv_definitionList_5_0 = null;
+
+
+ enterRule();
+
+ try {
+ // ../de.ugoe.cs.swe.bnftools.ebnf/src-gen/de/ugoe/cs/swe/bnftools/parser/antlr/internal/InternalEbnf.g:686:28: ( ( ( ( (lv_rulenumber_0_0= RULE_INT ) ) ( (lv_rulevariant_1_0= RULE_ID ) )? otherlv_2= '.' )? ( (lv_name_3_0= RULE_ID ) ) otherlv_4= '::=' ( (lv_definitionList_5_0= ruleDefinitionList ) )? (otherlv_6= ';' )? ) )
+ // ../de.ugoe.cs.swe.bnftools.ebnf/src-gen/de/ugoe/cs/swe/bnftools/parser/antlr/internal/InternalEbnf.g:687:1: ( ( ( (lv_rulenumber_0_0= RULE_INT ) ) ( (lv_rulevariant_1_0= RULE_ID ) )? otherlv_2= '.' )? ( (lv_name_3_0= RULE_ID ) ) otherlv_4= '::=' ( (lv_definitionList_5_0= ruleDefinitionList ) )? (otherlv_6= ';' )? )
+ {
+ // ../de.ugoe.cs.swe.bnftools.ebnf/src-gen/de/ugoe/cs/swe/bnftools/parser/antlr/internal/InternalEbnf.g:687:1: ( ( ( (lv_rulenumber_0_0= RULE_INT ) ) ( (lv_rulevariant_1_0= RULE_ID ) )? otherlv_2= '.' )? ( (lv_name_3_0= RULE_ID ) ) otherlv_4= '::=' ( (lv_definitionList_5_0= ruleDefinitionList ) )? (otherlv_6= ';' )? )
+ // ../de.ugoe.cs.swe.bnftools.ebnf/src-gen/de/ugoe/cs/swe/bnftools/parser/antlr/internal/InternalEbnf.g:687:2: ( ( (lv_rulenumber_0_0= RULE_INT ) ) ( (lv_rulevariant_1_0= RULE_ID ) )? otherlv_2= '.' )? ( (lv_name_3_0= RULE_ID ) ) otherlv_4= '::=' ( (lv_definitionList_5_0= ruleDefinitionList ) )? (otherlv_6= ';' )?
+ {
+ // ../de.ugoe.cs.swe.bnftools.ebnf/src-gen/de/ugoe/cs/swe/bnftools/parser/antlr/internal/InternalEbnf.g:687:2: ( ( (lv_rulenumber_0_0= RULE_INT ) ) ( (lv_rulevariant_1_0= RULE_ID ) )? otherlv_2= '.' )?
+ int alt17=2;
+ int LA17_0 = input.LA(1);
+
+ if ( (LA17_0==RULE_INT) ) {
+ alt17=1;
+ }
+ switch (alt17) {
+ case 1 :
+ // ../de.ugoe.cs.swe.bnftools.ebnf/src-gen/de/ugoe/cs/swe/bnftools/parser/antlr/internal/InternalEbnf.g:687:3: ( (lv_rulenumber_0_0= RULE_INT ) ) ( (lv_rulevariant_1_0= RULE_ID ) )? otherlv_2= '.'
+ {
+ // ../de.ugoe.cs.swe.bnftools.ebnf/src-gen/de/ugoe/cs/swe/bnftools/parser/antlr/internal/InternalEbnf.g:687:3: ( (lv_rulenumber_0_0= RULE_INT ) )
+ // ../de.ugoe.cs.swe.bnftools.ebnf/src-gen/de/ugoe/cs/swe/bnftools/parser/antlr/internal/InternalEbnf.g:688:1: (lv_rulenumber_0_0= RULE_INT )
+ {
+ // ../de.ugoe.cs.swe.bnftools.ebnf/src-gen/de/ugoe/cs/swe/bnftools/parser/antlr/internal/InternalEbnf.g:688:1: (lv_rulenumber_0_0= RULE_INT )
+ // ../de.ugoe.cs.swe.bnftools.ebnf/src-gen/de/ugoe/cs/swe/bnftools/parser/antlr/internal/InternalEbnf.g:689:3: lv_rulenumber_0_0= RULE_INT
+ {
+ lv_rulenumber_0_0=(Token)match(input,RULE_INT,FOLLOW_RULE_INT_in_ruleRule1368);
+
+ newLeafNode(lv_rulenumber_0_0, grammarAccess.getRuleAccess().getRulenumberINTTerminalRuleCall_0_0_0());
+
+
+ if (current==null) {
+ current = createModelElement(grammarAccess.getRuleRule());
+ }
+ setWithLastConsumed(
+ current,
+ "rulenumber",
+ lv_rulenumber_0_0,
+ "INT");
+
+
+ }
+
+
+ }
+
+ // ../de.ugoe.cs.swe.bnftools.ebnf/src-gen/de/ugoe/cs/swe/bnftools/parser/antlr/internal/InternalEbnf.g:705:2: ( (lv_rulevariant_1_0= RULE_ID ) )?
+ int alt16=2;
+ int LA16_0 = input.LA(1);
+
+ if ( (LA16_0==RULE_ID) ) {
+ alt16=1;
+ }
+ switch (alt16) {
+ case 1 :
+ // ../de.ugoe.cs.swe.bnftools.ebnf/src-gen/de/ugoe/cs/swe/bnftools/parser/antlr/internal/InternalEbnf.g:706:1: (lv_rulevariant_1_0= RULE_ID )
+ {
+ // ../de.ugoe.cs.swe.bnftools.ebnf/src-gen/de/ugoe/cs/swe/bnftools/parser/antlr/internal/InternalEbnf.g:706:1: (lv_rulevariant_1_0= RULE_ID )
+ // ../de.ugoe.cs.swe.bnftools.ebnf/src-gen/de/ugoe/cs/swe/bnftools/parser/antlr/internal/InternalEbnf.g:707:3: lv_rulevariant_1_0= RULE_ID
+ {
+ lv_rulevariant_1_0=(Token)match(input,RULE_ID,FOLLOW_RULE_ID_in_ruleRule1390);
+
+ newLeafNode(lv_rulevariant_1_0, grammarAccess.getRuleAccess().getRulevariantIDTerminalRuleCall_0_1_0());
+
+
+ if (current==null) {
+ current = createModelElement(grammarAccess.getRuleRule());
+ }
+ setWithLastConsumed(
+ current,
+ "rulevariant",
+ lv_rulevariant_1_0,
+ "ID");
+
+
+ }
+
+
+ }
+ break;
+
+ }
+
+ otherlv_2=(Token)match(input,24,FOLLOW_24_in_ruleRule1408);
+
+ newLeafNode(otherlv_2, grammarAccess.getRuleAccess().getFullStopKeyword_0_2());
+
+
+ }
+ break;
+
+ }
+
+ // ../de.ugoe.cs.swe.bnftools.ebnf/src-gen/de/ugoe/cs/swe/bnftools/parser/antlr/internal/InternalEbnf.g:727:3: ( (lv_name_3_0= RULE_ID ) )
+ // ../de.ugoe.cs.swe.bnftools.ebnf/src-gen/de/ugoe/cs/swe/bnftools/parser/antlr/internal/InternalEbnf.g:728:1: (lv_name_3_0= RULE_ID )
+ {
+ // ../de.ugoe.cs.swe.bnftools.ebnf/src-gen/de/ugoe/cs/swe/bnftools/parser/antlr/internal/InternalEbnf.g:728:1: (lv_name_3_0= RULE_ID )
+ // ../de.ugoe.cs.swe.bnftools.ebnf/src-gen/de/ugoe/cs/swe/bnftools/parser/antlr/internal/InternalEbnf.g:729:3: lv_name_3_0= RULE_ID
+ {
+ lv_name_3_0=(Token)match(input,RULE_ID,FOLLOW_RULE_ID_in_ruleRule1427);
+
+ newLeafNode(lv_name_3_0, grammarAccess.getRuleAccess().getNameIDTerminalRuleCall_1_0());
+
+
+ if (current==null) {
+ current = createModelElement(grammarAccess.getRuleRule());
+ }
+ setWithLastConsumed(
+ current,
+ "name",
+ lv_name_3_0,
+ "ID");
+
+
+ }
+
+
+ }
+
+ otherlv_4=(Token)match(input,25,FOLLOW_25_in_ruleRule1444);
+
+ newLeafNode(otherlv_4, grammarAccess.getRuleAccess().getColonColonEqualsSignKeyword_2());
+
+ // ../de.ugoe.cs.swe.bnftools.ebnf/src-gen/de/ugoe/cs/swe/bnftools/parser/antlr/internal/InternalEbnf.g:749:1: ( (lv_definitionList_5_0= ruleDefinitionList ) )?
+ int alt18=2;
+ int LA18_0 = input.LA(1);
+
+ if ( (LA18_0==RULE_STRING||LA18_0==RULE_COLON||LA18_0==26||(LA18_0>=32 && LA18_0<=33)) ) {
+ alt18=1;
+ }
+ else if ( (LA18_0==RULE_ID) ) {
+ int LA18_2 = input.LA(2);
+
+ if ( (LA18_2==26) ) {
+ int LA18_4 = input.LA(3);
+
+ if ( (LA18_4==RULE_ID||LA18_4==RULE_STRING||LA18_4==RULE_COLON||LA18_4==26||(LA18_4>=32 && LA18_4<=33)) ) {
+ alt18=1;
+ }
+ }
+ else if ( (LA18_2==EOF||(LA18_2>=RULE_ID && LA18_2<=RULE_INT)||LA18_2==RULE_COLON||LA18_2==15||(LA18_2>=31 && LA18_2<=33)) ) {
+ alt18=1;
+ }
+ }
+ switch (alt18) {
+ case 1 :
+ // ../de.ugoe.cs.swe.bnftools.ebnf/src-gen/de/ugoe/cs/swe/bnftools/parser/antlr/internal/InternalEbnf.g:750:1: (lv_definitionList_5_0= ruleDefinitionList )
+ {
+ // ../de.ugoe.cs.swe.bnftools.ebnf/src-gen/de/ugoe/cs/swe/bnftools/parser/antlr/internal/InternalEbnf.g:750:1: (lv_definitionList_5_0= ruleDefinitionList )
+ // ../de.ugoe.cs.swe.bnftools.ebnf/src-gen/de/ugoe/cs/swe/bnftools/parser/antlr/internal/InternalEbnf.g:751:3: lv_definitionList_5_0= ruleDefinitionList
+ {
+
+ newCompositeNode(grammarAccess.getRuleAccess().getDefinitionListDefinitionListParserRuleCall_3_0());
+
+ pushFollow(FOLLOW_ruleDefinitionList_in_ruleRule1465);
+ lv_definitionList_5_0=ruleDefinitionList();
+
+ state._fsp--;
+
+
+ if (current==null) {
+ current = createModelElementForParent(grammarAccess.getRuleRule());
+ }
+ set(
+ current,
+ "definitionList",
+ lv_definitionList_5_0,
+ "DefinitionList");
+ afterParserOrEnumRuleCall();
+
+
+ }
+
+
+ }
+ break;
+
+ }
+
+ // ../de.ugoe.cs.swe.bnftools.ebnf/src-gen/de/ugoe/cs/swe/bnftools/parser/antlr/internal/InternalEbnf.g:767:3: (otherlv_6= ';' )?
+ int alt19=2;
+ int LA19_0 = input.LA(1);
+
+ if ( (LA19_0==15) ) {
+ alt19=1;
+ }
+ switch (alt19) {
+ case 1 :
+ // ../de.ugoe.cs.swe.bnftools.ebnf/src-gen/de/ugoe/cs/swe/bnftools/parser/antlr/internal/InternalEbnf.g:767:5: otherlv_6= ';'
+ {
+ otherlv_6=(Token)match(input,15,FOLLOW_15_in_ruleRule1479);
+
+ newLeafNode(otherlv_6, grammarAccess.getRuleAccess().getSemicolonKeyword_4());
+
+
+ }
+ break;
+
+ }
+
+
+ }
+
+
+ }
+
+ leaveRule();
+ }
+
+ catch (RecognitionException re) {
+ recover(input,re);
+ appendSkippedTokens();
+ }
+ finally {
+ }
+ return current;
+ }
+ // $ANTLR end "ruleRule"
+
+
+ // $ANTLR start "entryRuleExtRule"
+ // ../de.ugoe.cs.swe.bnftools.ebnf/src-gen/de/ugoe/cs/swe/bnftools/parser/antlr/internal/InternalEbnf.g:779:1: entryRuleExtRule returns [EObject current=null] : iv_ruleExtRule= ruleExtRule EOF ;
+ public final EObject entryRuleExtRule() throws RecognitionException {
+ EObject current = null;
+
+ EObject iv_ruleExtRule = null;
+
+
+ try {
+ // ../de.ugoe.cs.swe.bnftools.ebnf/src-gen/de/ugoe/cs/swe/bnftools/parser/antlr/internal/InternalEbnf.g:780:2: (iv_ruleExtRule= ruleExtRule EOF )
+ // ../de.ugoe.cs.swe.bnftools.ebnf/src-gen/de/ugoe/cs/swe/bnftools/parser/antlr/internal/InternalEbnf.g:781:2: iv_ruleExtRule= ruleExtRule EOF
+ {
+ newCompositeNode(grammarAccess.getExtRuleRule());
+ pushFollow(FOLLOW_ruleExtRule_in_entryRuleExtRule1517);
+ iv_ruleExtRule=ruleExtRule();
+
+ state._fsp--;
+
+ current =iv_ruleExtRule;
+ match(input,EOF,FOLLOW_EOF_in_entryRuleExtRule1527);
+
+ }
+
+ }
+
+ catch (RecognitionException re) {
+ recover(input,re);
+ appendSkippedTokens();
+ }
+ finally {
+ }
+ return current;
+ }
+ // $ANTLR end "entryRuleExtRule"
+
+
+ // $ANTLR start "ruleExtRule"
+ // ../de.ugoe.cs.swe.bnftools.ebnf/src-gen/de/ugoe/cs/swe/bnftools/parser/antlr/internal/InternalEbnf.g:788:1: ruleExtRule returns [EObject current=null] : ( ( ( (lv_rulenumber_0_0= RULE_INT ) ) ( (lv_rulevariant_1_0= RULE_ID ) )? otherlv_2= '.' )? ( (lv_name_3_0= RULE_ID ) ) (otherlv_4= '(' ( (lv_ruleext_5_0= RULE_INT ) ) otherlv_6= ')' ) otherlv_7= '<-' ( ( (lv_elements_8_0= ruleAtom ) ) | otherlv_9= ')' | otherlv_10= ']' | otherlv_11= '}' | otherlv_12= '|' | otherlv_13= '(' | otherlv_14= '[' | otherlv_15= '{' | otherlv_16= '*' | otherlv_17= '+' )* (otherlv_18= ';' )? ) ;
+ public final EObject ruleExtRule() throws RecognitionException {
+ EObject current = null;
+
+ Token lv_rulenumber_0_0=null;
+ Token lv_rulevariant_1_0=null;
+ Token otherlv_2=null;
+ Token lv_name_3_0=null;
+ Token otherlv_4=null;
+ Token lv_ruleext_5_0=null;
+ Token otherlv_6=null;
+ Token otherlv_7=null;
+ Token otherlv_9=null;
+ Token otherlv_10=null;
+ Token otherlv_11=null;
+ Token otherlv_12=null;
+ Token otherlv_13=null;
+ Token otherlv_14=null;
+ Token otherlv_15=null;
+ Token otherlv_16=null;
+ Token otherlv_17=null;
+ Token otherlv_18=null;
+ EObject lv_elements_8_0 = null;
+
+
+ enterRule();
+
+ try {
+ // ../de.ugoe.cs.swe.bnftools.ebnf/src-gen/de/ugoe/cs/swe/bnftools/parser/antlr/internal/InternalEbnf.g:791:28: ( ( ( ( (lv_rulenumber_0_0= RULE_INT ) ) ( (lv_rulevariant_1_0= RULE_ID ) )? otherlv_2= '.' )? ( (lv_name_3_0= RULE_ID ) ) (otherlv_4= '(' ( (lv_ruleext_5_0= RULE_INT ) ) otherlv_6= ')' ) otherlv_7= '<-' ( ( (lv_elements_8_0= ruleAtom ) ) | otherlv_9= ')' | otherlv_10= ']' | otherlv_11= '}' | otherlv_12= '|' | otherlv_13= '(' | otherlv_14= '[' | otherlv_15= '{' | otherlv_16= '*' | otherlv_17= '+' )* (otherlv_18= ';' )? ) )
+ // ../de.ugoe.cs.swe.bnftools.ebnf/src-gen/de/ugoe/cs/swe/bnftools/parser/antlr/internal/InternalEbnf.g:792:1: ( ( ( (lv_rulenumber_0_0= RULE_INT ) ) ( (lv_rulevariant_1_0= RULE_ID ) )? otherlv_2= '.' )? ( (lv_name_3_0= RULE_ID ) ) (otherlv_4= '(' ( (lv_ruleext_5_0= RULE_INT ) ) otherlv_6= ')' ) otherlv_7= '<-' ( ( (lv_elements_8_0= ruleAtom ) ) | otherlv_9= ')' | otherlv_10= ']' | otherlv_11= '}' | otherlv_12= '|' | otherlv_13= '(' | otherlv_14= '[' | otherlv_15= '{' | otherlv_16= '*' | otherlv_17= '+' )* (otherlv_18= ';' )? )
+ {
+ // ../de.ugoe.cs.swe.bnftools.ebnf/src-gen/de/ugoe/cs/swe/bnftools/parser/antlr/internal/InternalEbnf.g:792:1: ( ( ( (lv_rulenumber_0_0= RULE_INT ) ) ( (lv_rulevariant_1_0= RULE_ID ) )? otherlv_2= '.' )? ( (lv_name_3_0= RULE_ID ) ) (otherlv_4= '(' ( (lv_ruleext_5_0= RULE_INT ) ) otherlv_6= ')' ) otherlv_7= '<-' ( ( (lv_elements_8_0= ruleAtom ) ) | otherlv_9= ')' | otherlv_10= ']' | otherlv_11= '}' | otherlv_12= '|' | otherlv_13= '(' | otherlv_14= '[' | otherlv_15= '{' | otherlv_16= '*' | otherlv_17= '+' )* (otherlv_18= ';' )? )
+ // ../de.ugoe.cs.swe.bnftools.ebnf/src-gen/de/ugoe/cs/swe/bnftools/parser/antlr/internal/InternalEbnf.g:792:2: ( ( (lv_rulenumber_0_0= RULE_INT ) ) ( (lv_rulevariant_1_0= RULE_ID ) )? otherlv_2= '.' )? ( (lv_name_3_0= RULE_ID ) ) (otherlv_4= '(' ( (lv_ruleext_5_0= RULE_INT ) ) otherlv_6= ')' ) otherlv_7= '<-' ( ( (lv_elements_8_0= ruleAtom ) ) | otherlv_9= ')' | otherlv_10= ']' | otherlv_11= '}' | otherlv_12= '|' | otherlv_13= '(' | otherlv_14= '[' | otherlv_15= '{' | otherlv_16= '*' | otherlv_17= '+' )* (otherlv_18= ';' )?
+ {
+ // ../de.ugoe.cs.swe.bnftools.ebnf/src-gen/de/ugoe/cs/swe/bnftools/parser/antlr/internal/InternalEbnf.g:792:2: ( ( (lv_rulenumber_0_0= RULE_INT ) ) ( (lv_rulevariant_1_0= RULE_ID ) )? otherlv_2= '.' )?
+ int alt21=2;
+ int LA21_0 = input.LA(1);
+
+ if ( (LA21_0==RULE_INT) ) {
+ alt21=1;
+ }
+ switch (alt21) {
+ case 1 :
+ // ../de.ugoe.cs.swe.bnftools.ebnf/src-gen/de/ugoe/cs/swe/bnftools/parser/antlr/internal/InternalEbnf.g:792:3: ( (lv_rulenumber_0_0= RULE_INT ) ) ( (lv_rulevariant_1_0= RULE_ID ) )? otherlv_2= '.'
+ {
+ // ../de.ugoe.cs.swe.bnftools.ebnf/src-gen/de/ugoe/cs/swe/bnftools/parser/antlr/internal/InternalEbnf.g:792:3: ( (lv_rulenumber_0_0= RULE_INT ) )
+ // ../de.ugoe.cs.swe.bnftools.ebnf/src-gen/de/ugoe/cs/swe/bnftools/parser/antlr/internal/InternalEbnf.g:793:1: (lv_rulenumber_0_0= RULE_INT )
+ {
+ // ../de.ugoe.cs.swe.bnftools.ebnf/src-gen/de/ugoe/cs/swe/bnftools/parser/antlr/internal/InternalEbnf.g:793:1: (lv_rulenumber_0_0= RULE_INT )
+ // ../de.ugoe.cs.swe.bnftools.ebnf/src-gen/de/ugoe/cs/swe/bnftools/parser/antlr/internal/InternalEbnf.g:794:3: lv_rulenumber_0_0= RULE_INT
+ {
+ lv_rulenumber_0_0=(Token)match(input,RULE_INT,FOLLOW_RULE_INT_in_ruleExtRule1570);
+
+ newLeafNode(lv_rulenumber_0_0, grammarAccess.getExtRuleAccess().getRulenumberINTTerminalRuleCall_0_0_0());
+
+
+ if (current==null) {
+ current = createModelElement(grammarAccess.getExtRuleRule());
+ }
+ setWithLastConsumed(
+ current,
+ "rulenumber",
+ lv_rulenumber_0_0,
+ "INT");
+
+
+ }
+
+
+ }
+
+ // ../de.ugoe.cs.swe.bnftools.ebnf/src-gen/de/ugoe/cs/swe/bnftools/parser/antlr/internal/InternalEbnf.g:810:2: ( (lv_rulevariant_1_0= RULE_ID ) )?
+ int alt20=2;
+ int LA20_0 = input.LA(1);
+
+ if ( (LA20_0==RULE_ID) ) {
+ alt20=1;
+ }
+ switch (alt20) {
+ case 1 :
+ // ../de.ugoe.cs.swe.bnftools.ebnf/src-gen/de/ugoe/cs/swe/bnftools/parser/antlr/internal/InternalEbnf.g:811:1: (lv_rulevariant_1_0= RULE_ID )
+ {
+ // ../de.ugoe.cs.swe.bnftools.ebnf/src-gen/de/ugoe/cs/swe/bnftools/parser/antlr/internal/InternalEbnf.g:811:1: (lv_rulevariant_1_0= RULE_ID )
+ // ../de.ugoe.cs.swe.bnftools.ebnf/src-gen/de/ugoe/cs/swe/bnftools/parser/antlr/internal/InternalEbnf.g:812:3: lv_rulevariant_1_0= RULE_ID
+ {
+ lv_rulevariant_1_0=(Token)match(input,RULE_ID,FOLLOW_RULE_ID_in_ruleExtRule1592);
+
+ newLeafNode(lv_rulevariant_1_0, grammarAccess.getExtRuleAccess().getRulevariantIDTerminalRuleCall_0_1_0());
+
+
+ if (current==null) {
+ current = createModelElement(grammarAccess.getExtRuleRule());
+ }
+ setWithLastConsumed(
+ current,
+ "rulevariant",
+ lv_rulevariant_1_0,
+ "ID");
+
+
+ }
+
+
+ }
+ break;
+
+ }
+
+ otherlv_2=(Token)match(input,24,FOLLOW_24_in_ruleExtRule1610);
+
+ newLeafNode(otherlv_2, grammarAccess.getExtRuleAccess().getFullStopKeyword_0_2());
+
+
+ }
+ break;
+
+ }
+
+ // ../de.ugoe.cs.swe.bnftools.ebnf/src-gen/de/ugoe/cs/swe/bnftools/parser/antlr/internal/InternalEbnf.g:832:3: ( (lv_name_3_0= RULE_ID ) )
+ // ../de.ugoe.cs.swe.bnftools.ebnf/src-gen/de/ugoe/cs/swe/bnftools/parser/antlr/internal/InternalEbnf.g:833:1: (lv_name_3_0= RULE_ID )
+ {
+ // ../de.ugoe.cs.swe.bnftools.ebnf/src-gen/de/ugoe/cs/swe/bnftools/parser/antlr/internal/InternalEbnf.g:833:1: (lv_name_3_0= RULE_ID )
+ // ../de.ugoe.cs.swe.bnftools.ebnf/src-gen/de/ugoe/cs/swe/bnftools/parser/antlr/internal/InternalEbnf.g:834:3: lv_name_3_0= RULE_ID
+ {
+ lv_name_3_0=(Token)match(input,RULE_ID,FOLLOW_RULE_ID_in_ruleExtRule1629);
+
+ newLeafNode(lv_name_3_0, grammarAccess.getExtRuleAccess().getNameIDTerminalRuleCall_1_0());
+
+
+ if (current==null) {
+ current = createModelElement(grammarAccess.getExtRuleRule());
+ }
+ setWithLastConsumed(
+ current,
+ "name",
+ lv_name_3_0,
+ "ID");
+
+
+ }
+
+
+ }
+
+ // ../de.ugoe.cs.swe.bnftools.ebnf/src-gen/de/ugoe/cs/swe/bnftools/parser/antlr/internal/InternalEbnf.g:850:2: (otherlv_4= '(' ( (lv_ruleext_5_0= RULE_INT ) ) otherlv_6= ')' )
+ // ../de.ugoe.cs.swe.bnftools.ebnf/src-gen/de/ugoe/cs/swe/bnftools/parser/antlr/internal/InternalEbnf.g:850:4: otherlv_4= '(' ( (lv_ruleext_5_0= RULE_INT ) ) otherlv_6= ')'
+ {
+ otherlv_4=(Token)match(input,26,FOLLOW_26_in_ruleExtRule1647);
+
+ newLeafNode(otherlv_4, grammarAccess.getExtRuleAccess().getLeftParenthesisKeyword_2_0());
+
+ // ../de.ugoe.cs.swe.bnftools.ebnf/src-gen/de/ugoe/cs/swe/bnftools/parser/antlr/internal/InternalEbnf.g:854:1: ( (lv_ruleext_5_0= RULE_INT ) )
+ // ../de.ugoe.cs.swe.bnftools.ebnf/src-gen/de/ugoe/cs/swe/bnftools/parser/antlr/internal/InternalEbnf.g:855:1: (lv_ruleext_5_0= RULE_INT )
+ {
+ // ../de.ugoe.cs.swe.bnftools.ebnf/src-gen/de/ugoe/cs/swe/bnftools/parser/antlr/internal/InternalEbnf.g:855:1: (lv_ruleext_5_0= RULE_INT )
+ // ../de.ugoe.cs.swe.bnftools.ebnf/src-gen/de/ugoe/cs/swe/bnftools/parser/antlr/internal/InternalEbnf.g:856:3: lv_ruleext_5_0= RULE_INT
+ {
+ lv_ruleext_5_0=(Token)match(input,RULE_INT,FOLLOW_RULE_INT_in_ruleExtRule1664);
+
+ newLeafNode(lv_ruleext_5_0, grammarAccess.getExtRuleAccess().getRuleextINTTerminalRuleCall_2_1_0());
+
+
+ if (current==null) {
+ current = createModelElement(grammarAccess.getExtRuleRule());
+ }
+ setWithLastConsumed(
+ current,
+ "ruleext",
+ lv_ruleext_5_0,
+ "INT");
+
+
+ }
+
+
+ }
+
+ otherlv_6=(Token)match(input,27,FOLLOW_27_in_ruleExtRule1681);
+
+ newLeafNode(otherlv_6, grammarAccess.getExtRuleAccess().getRightParenthesisKeyword_2_2());
+
+
+ }
+
+ otherlv_7=(Token)match(input,28,FOLLOW_28_in_ruleExtRule1694);
+
+ newLeafNode(otherlv_7, grammarAccess.getExtRuleAccess().getLessThanSignHyphenMinusKeyword_3());
+
+ // ../de.ugoe.cs.swe.bnftools.ebnf/src-gen/de/ugoe/cs/swe/bnftools/parser/antlr/internal/InternalEbnf.g:880:1: ( ( (lv_elements_8_0= ruleAtom ) ) | otherlv_9= ')' | otherlv_10= ']' | otherlv_11= '}' | otherlv_12= '|' | otherlv_13= '(' | otherlv_14= '[' | otherlv_15= '{' | otherlv_16= '*' | otherlv_17= '+' )*
+ loop22:
+ do {
+ int alt22=11;
+ alt22 = dfa22.predict(input);
+ switch (alt22) {
+ case 1 :
+ // ../de.ugoe.cs.swe.bnftools.ebnf/src-gen/de/ugoe/cs/swe/bnftools/parser/antlr/internal/InternalEbnf.g:880:2: ( (lv_elements_8_0= ruleAtom ) )
+ {
+ // ../de.ugoe.cs.swe.bnftools.ebnf/src-gen/de/ugoe/cs/swe/bnftools/parser/antlr/internal/InternalEbnf.g:880:2: ( (lv_elements_8_0= ruleAtom ) )
+ // ../de.ugoe.cs.swe.bnftools.ebnf/src-gen/de/ugoe/cs/swe/bnftools/parser/antlr/internal/InternalEbnf.g:881:1: (lv_elements_8_0= ruleAtom )
+ {
+ // ../de.ugoe.cs.swe.bnftools.ebnf/src-gen/de/ugoe/cs/swe/bnftools/parser/antlr/internal/InternalEbnf.g:881:1: (lv_elements_8_0= ruleAtom )
+ // ../de.ugoe.cs.swe.bnftools.ebnf/src-gen/de/ugoe/cs/swe/bnftools/parser/antlr/internal/InternalEbnf.g:882:3: lv_elements_8_0= ruleAtom
+ {
+
+ newCompositeNode(grammarAccess.getExtRuleAccess().getElementsAtomParserRuleCall_4_0_0());
+
+ pushFollow(FOLLOW_ruleAtom_in_ruleExtRule1716);
+ lv_elements_8_0=ruleAtom();
+
+ state._fsp--;
+
+
+ if (current==null) {
+ current = createModelElementForParent(grammarAccess.getExtRuleRule());
+ }
+ add(
+ current,
+ "elements",
+ lv_elements_8_0,
+ "Atom");
+ afterParserOrEnumRuleCall();
+
+
+ }
+
+
+ }
+
+
+ }
+ break;
+ case 2 :
+ // ../de.ugoe.cs.swe.bnftools.ebnf/src-gen/de/ugoe/cs/swe/bnftools/parser/antlr/internal/InternalEbnf.g:899:7: otherlv_9= ')'
+ {
+ otherlv_9=(Token)match(input,27,FOLLOW_27_in_ruleExtRule1734);
+
+ newLeafNode(otherlv_9, grammarAccess.getExtRuleAccess().getRightParenthesisKeyword_4_1());
+
+
+ }
+ break;
+ case 3 :
+ // ../de.ugoe.cs.swe.bnftools.ebnf/src-gen/de/ugoe/cs/swe/bnftools/parser/antlr/internal/InternalEbnf.g:904:7: otherlv_10= ']'
+ {
+ otherlv_10=(Token)match(input,29,FOLLOW_29_in_ruleExtRule1752);
+
+ newLeafNode(otherlv_10, grammarAccess.getExtRuleAccess().getRightSquareBracketKeyword_4_2());
+
+
+ }
+ break;
+ case 4 :
+ // ../de.ugoe.cs.swe.bnftools.ebnf/src-gen/de/ugoe/cs/swe/bnftools/parser/antlr/internal/InternalEbnf.g:909:7: otherlv_11= '}'
+ {
+ otherlv_11=(Token)match(input,30,FOLLOW_30_in_ruleExtRule1770);
+
+ newLeafNode(otherlv_11, grammarAccess.getExtRuleAccess().getRightCurlyBracketKeyword_4_3());
+
+
+ }
+ break;
+ case 5 :
+ // ../de.ugoe.cs.swe.bnftools.ebnf/src-gen/de/ugoe/cs/swe/bnftools/parser/antlr/internal/InternalEbnf.g:914:7: otherlv_12= '|'
+ {
+ otherlv_12=(Token)match(input,31,FOLLOW_31_in_ruleExtRule1788);
+
+ newLeafNode(otherlv_12, grammarAccess.getExtRuleAccess().getVerticalLineKeyword_4_4());
+
+
+ }
+ break;
+ case 6 :
+ // ../de.ugoe.cs.swe.bnftools.ebnf/src-gen/de/ugoe/cs/swe/bnftools/parser/antlr/internal/InternalEbnf.g:919:7: otherlv_13= '('
+ {
+ otherlv_13=(Token)match(input,26,FOLLOW_26_in_ruleExtRule1806);
+
+ newLeafNode(otherlv_13, grammarAccess.getExtRuleAccess().getLeftParenthesisKeyword_4_5());
+
+
+ }
+ break;
+ case 7 :
+ // ../de.ugoe.cs.swe.bnftools.ebnf/src-gen/de/ugoe/cs/swe/bnftools/parser/antlr/internal/InternalEbnf.g:924:7: otherlv_14= '['
+ {
+ otherlv_14=(Token)match(input,32,FOLLOW_32_in_ruleExtRule1824);
+
+ newLeafNode(otherlv_14, grammarAccess.getExtRuleAccess().getLeftSquareBracketKeyword_4_6());
+
+
+ }
+ break;
+ case 8 :
+ // ../de.ugoe.cs.swe.bnftools.ebnf/src-gen/de/ugoe/cs/swe/bnftools/parser/antlr/internal/InternalEbnf.g:929:7: otherlv_15= '{'
+ {
+ otherlv_15=(Token)match(input,33,FOLLOW_33_in_ruleExtRule1842);
+
+ newLeafNode(otherlv_15, grammarAccess.getExtRuleAccess().getLeftCurlyBracketKeyword_4_7());
+
+
+ }
+ break;
+ case 9 :
+ // ../de.ugoe.cs.swe.bnftools.ebnf/src-gen/de/ugoe/cs/swe/bnftools/parser/antlr/internal/InternalEbnf.g:934:7: otherlv_16= '*'
+ {
+ otherlv_16=(Token)match(input,34,FOLLOW_34_in_ruleExtRule1860);
+
+ newLeafNode(otherlv_16, grammarAccess.getExtRuleAccess().getAsteriskKeyword_4_8());
+
+
+ }
+ break;
+ case 10 :
+ // ../de.ugoe.cs.swe.bnftools.ebnf/src-gen/de/ugoe/cs/swe/bnftools/parser/antlr/internal/InternalEbnf.g:939:7: otherlv_17= '+'
+ {
+ otherlv_17=(Token)match(input,35,FOLLOW_35_in_ruleExtRule1878);
+
+ newLeafNode(otherlv_17, grammarAccess.getExtRuleAccess().getPlusSignKeyword_4_9());
+
+
+ }
+ break;
+
+ default :
+ break loop22;
+ }
+ } while (true);
+
+ // ../de.ugoe.cs.swe.bnftools.ebnf/src-gen/de/ugoe/cs/swe/bnftools/parser/antlr/internal/InternalEbnf.g:943:3: (otherlv_18= ';' )?
+ int alt23=2;
+ int LA23_0 = input.LA(1);
+
+ if ( (LA23_0==15) ) {
+ alt23=1;
+ }
+ switch (alt23) {
+ case 1 :
+ // ../de.ugoe.cs.swe.bnftools.ebnf/src-gen/de/ugoe/cs/swe/bnftools/parser/antlr/internal/InternalEbnf.g:943:5: otherlv_18= ';'
+ {
+ otherlv_18=(Token)match(input,15,FOLLOW_15_in_ruleExtRule1893);
+
+ newLeafNode(otherlv_18, grammarAccess.getExtRuleAccess().getSemicolonKeyword_5());
+
+
+ }
+ break;
+
+ }
+
+
+ }
+
+
+ }
+
+ leaveRule();
+ }
+
+ catch (RecognitionException re) {
+ recover(input,re);
+ appendSkippedTokens();
+ }
+ finally {
+ }
+ return current;
+ }
+ // $ANTLR end "ruleExtRule"
+
+
+ // $ANTLR start "entryRuleMergeRule"
+ // ../de.ugoe.cs.swe.bnftools.ebnf/src-gen/de/ugoe/cs/swe/bnftools/parser/antlr/internal/InternalEbnf.g:955:1: entryRuleMergeRule returns [EObject current=null] : iv_ruleMergeRule= ruleMergeRule EOF ;
+ public final EObject entryRuleMergeRule() throws RecognitionException {
+ EObject current = null;
+
+ EObject iv_ruleMergeRule = null;
+
+
+ try {
+ // ../de.ugoe.cs.swe.bnftools.ebnf/src-gen/de/ugoe/cs/swe/bnftools/parser/antlr/internal/InternalEbnf.g:956:2: (iv_ruleMergeRule= ruleMergeRule EOF )
+ // ../de.ugoe.cs.swe.bnftools.ebnf/src-gen/de/ugoe/cs/swe/bnftools/parser/antlr/internal/InternalEbnf.g:957:2: iv_ruleMergeRule= ruleMergeRule EOF
+ {
+ newCompositeNode(grammarAccess.getMergeRuleRule());
+ pushFollow(FOLLOW_ruleMergeRule_in_entryRuleMergeRule1931);
+ iv_ruleMergeRule=ruleMergeRule();
+
+ state._fsp--;
+
+ current =iv_ruleMergeRule;
+ match(input,EOF,FOLLOW_EOF_in_entryRuleMergeRule1941);
+
+ }
+
+ }
+
+ catch (RecognitionException re) {
+ recover(input,re);
+ appendSkippedTokens();
+ }
+ finally {
+ }
+ return current;
+ }
+ // $ANTLR end "entryRuleMergeRule"
+
+
+ // $ANTLR start "ruleMergeRule"
+ // ../de.ugoe.cs.swe.bnftools.ebnf/src-gen/de/ugoe/cs/swe/bnftools/parser/antlr/internal/InternalEbnf.g:964:1: ruleMergeRule returns [EObject current=null] : (this_GlobalCombinator_0= ruleGlobalCombinator | this_RuleCombinator_1= ruleRuleCombinator | this_HookCombinator_2= ruleHookCombinator ) ;
+ public final EObject ruleMergeRule() throws RecognitionException {
+ EObject current = null;
+
+ EObject this_GlobalCombinator_0 = null;
+
+ EObject this_RuleCombinator_1 = null;
+
+ EObject this_HookCombinator_2 = null;
+
+
+ enterRule();
+
+ try {
+ // ../de.ugoe.cs.swe.bnftools.ebnf/src-gen/de/ugoe/cs/swe/bnftools/parser/antlr/internal/InternalEbnf.g:967:28: ( (this_GlobalCombinator_0= ruleGlobalCombinator | this_RuleCombinator_1= ruleRuleCombinator | this_HookCombinator_2= ruleHookCombinator ) )
+ // ../de.ugoe.cs.swe.bnftools.ebnf/src-gen/de/ugoe/cs/swe/bnftools/parser/antlr/internal/InternalEbnf.g:968:1: (this_GlobalCombinator_0= ruleGlobalCombinator | this_RuleCombinator_1= ruleRuleCombinator | this_HookCombinator_2= ruleHookCombinator )
+ {
+ // ../de.ugoe.cs.swe.bnftools.ebnf/src-gen/de/ugoe/cs/swe/bnftools/parser/antlr/internal/InternalEbnf.g:968:1: (this_GlobalCombinator_0= ruleGlobalCombinator | this_RuleCombinator_1= ruleRuleCombinator | this_HookCombinator_2= ruleHookCombinator )
+ int alt24=3;
+ switch ( input.LA(1) ) {
+ case 36:
+ {
+ alt24=1;
+ }
+ break;
+ case 38:
+ {
+ alt24=2;
+ }
+ break;
+ case 39:
+ {
+ alt24=3;
+ }
+ break;
+ default:
+ NoViableAltException nvae =
+ new NoViableAltException("", 24, 0, input);
+
+ throw nvae;
+ }
+
+ switch (alt24) {
+ case 1 :
+ // ../de.ugoe.cs.swe.bnftools.ebnf/src-gen/de/ugoe/cs/swe/bnftools/parser/antlr/internal/InternalEbnf.g:969:5: this_GlobalCombinator_0= ruleGlobalCombinator
+ {
+
+ newCompositeNode(grammarAccess.getMergeRuleAccess().getGlobalCombinatorParserRuleCall_0());
+
+ pushFollow(FOLLOW_ruleGlobalCombinator_in_ruleMergeRule1988);
+ this_GlobalCombinator_0=ruleGlobalCombinator();
+
+ state._fsp--;
+
+
+ current = this_GlobalCombinator_0;
+ afterParserOrEnumRuleCall();
+
+
+ }
+ break;
+ case 2 :
+ // ../de.ugoe.cs.swe.bnftools.ebnf/src-gen/de/ugoe/cs/swe/bnftools/parser/antlr/internal/InternalEbnf.g:979:5: this_RuleCombinator_1= ruleRuleCombinator
+ {
+
+ newCompositeNode(grammarAccess.getMergeRuleAccess().getRuleCombinatorParserRuleCall_1());
+
+ pushFollow(FOLLOW_ruleRuleCombinator_in_ruleMergeRule2015);
+ this_RuleCombinator_1=ruleRuleCombinator();
+
+ state._fsp--;
+
+
+ current = this_RuleCombinator_1;
+ afterParserOrEnumRuleCall();
+
+
+ }
+ break;
+ case 3 :
+ // ../de.ugoe.cs.swe.bnftools.ebnf/src-gen/de/ugoe/cs/swe/bnftools/parser/antlr/internal/InternalEbnf.g:989:5: this_HookCombinator_2= ruleHookCombinator
+ {
+
+ newCompositeNode(grammarAccess.getMergeRuleAccess().getHookCombinatorParserRuleCall_2());
+
+ pushFollow(FOLLOW_ruleHookCombinator_in_ruleMergeRule2042);
+ this_HookCombinator_2=ruleHookCombinator();
+
+ state._fsp--;
+
+
+ current = this_HookCombinator_2;
+ afterParserOrEnumRuleCall();
+
+
+ }
+ break;
+
+ }
+
+
+ }
+
+ leaveRule();
+ }
+
+ catch (RecognitionException re) {
+ recover(input,re);
+ appendSkippedTokens();
+ }
+ finally {
+ }
+ return current;
+ }
+ // $ANTLR end "ruleMergeRule"
+
+
+ // $ANTLR start "entryRuleGlobalCombinator"
+ // ../de.ugoe.cs.swe.bnftools.ebnf/src-gen/de/ugoe/cs/swe/bnftools/parser/antlr/internal/InternalEbnf.g:1005:1: entryRuleGlobalCombinator returns [EObject current=null] : iv_ruleGlobalCombinator= ruleGlobalCombinator EOF ;
+ public final EObject entryRuleGlobalCombinator() throws RecognitionException {
+ EObject current = null;
+
+ EObject iv_ruleGlobalCombinator = null;
+
+
+ try {
+ // ../de.ugoe.cs.swe.bnftools.ebnf/src-gen/de/ugoe/cs/swe/bnftools/parser/antlr/internal/InternalEbnf.g:1006:2: (iv_ruleGlobalCombinator= ruleGlobalCombinator EOF )
+ // ../de.ugoe.cs.swe.bnftools.ebnf/src-gen/de/ugoe/cs/swe/bnftools/parser/antlr/internal/InternalEbnf.g:1007:2: iv_ruleGlobalCombinator= ruleGlobalCombinator EOF
+ {
+ newCompositeNode(grammarAccess.getGlobalCombinatorRule());
+ pushFollow(FOLLOW_ruleGlobalCombinator_in_entryRuleGlobalCombinator2077);
+ iv_ruleGlobalCombinator=ruleGlobalCombinator();
+
+ state._fsp--;
+
+ current =iv_ruleGlobalCombinator;
+ match(input,EOF,FOLLOW_EOF_in_entryRuleGlobalCombinator2087);
+
+ }
+
+ }
+
+ catch (RecognitionException re) {
+ recover(input,re);
+ appendSkippedTokens();
+ }
+ finally {
+ }
+ return current;
+ }
+ // $ANTLR end "entryRuleGlobalCombinator"
+
+
+ // $ANTLR start "ruleGlobalCombinator"
+ // ../de.ugoe.cs.swe.bnftools.ebnf/src-gen/de/ugoe/cs/swe/bnftools/parser/antlr/internal/InternalEbnf.g:1014:1: ruleGlobalCombinator returns [EObject current=null] : ( (otherlv_0= 'global' otherlv_1= 'combinator:' ) ( (lv_logic_2_0= RULE_LOGIC ) ) (otherlv_3= ';' )? ) ;
+ public final EObject ruleGlobalCombinator() throws RecognitionException {
+ EObject current = null;
+
+ Token otherlv_0=null;
+ Token otherlv_1=null;
+ Token lv_logic_2_0=null;
+ Token otherlv_3=null;
+
+ enterRule();
+
+ try {
+ // ../de.ugoe.cs.swe.bnftools.ebnf/src-gen/de/ugoe/cs/swe/bnftools/parser/antlr/internal/InternalEbnf.g:1017:28: ( ( (otherlv_0= 'global' otherlv_1= 'combinator:' ) ( (lv_logic_2_0= RULE_LOGIC ) ) (otherlv_3= ';' )? ) )
+ // ../de.ugoe.cs.swe.bnftools.ebnf/src-gen/de/ugoe/cs/swe/bnftools/parser/antlr/internal/InternalEbnf.g:1018:1: ( (otherlv_0= 'global' otherlv_1= 'combinator:' ) ( (lv_logic_2_0= RULE_LOGIC ) ) (otherlv_3= ';' )? )
+ {
+ // ../de.ugoe.cs.swe.bnftools.ebnf/src-gen/de/ugoe/cs/swe/bnftools/parser/antlr/internal/InternalEbnf.g:1018:1: ( (otherlv_0= 'global' otherlv_1= 'combinator:' ) ( (lv_logic_2_0= RULE_LOGIC ) ) (otherlv_3= ';' )? )
+ // ../de.ugoe.cs.swe.bnftools.ebnf/src-gen/de/ugoe/cs/swe/bnftools/parser/antlr/internal/InternalEbnf.g:1018:2: (otherlv_0= 'global' otherlv_1= 'combinator:' ) ( (lv_logic_2_0= RULE_LOGIC ) ) (otherlv_3= ';' )?
+ {
+ // ../de.ugoe.cs.swe.bnftools.ebnf/src-gen/de/ugoe/cs/swe/bnftools/parser/antlr/internal/InternalEbnf.g:1018:2: (otherlv_0= 'global' otherlv_1= 'combinator:' )
+ // ../de.ugoe.cs.swe.bnftools.ebnf/src-gen/de/ugoe/cs/swe/bnftools/parser/antlr/internal/InternalEbnf.g:1018:4: otherlv_0= 'global' otherlv_1= 'combinator:'
+ {
+ otherlv_0=(Token)match(input,36,FOLLOW_36_in_ruleGlobalCombinator2125);
+
+ newLeafNode(otherlv_0, grammarAccess.getGlobalCombinatorAccess().getGlobalKeyword_0_0());
+
+ otherlv_1=(Token)match(input,37,FOLLOW_37_in_ruleGlobalCombinator2137);
+
+ newLeafNode(otherlv_1, grammarAccess.getGlobalCombinatorAccess().getCombinatorKeyword_0_1());
+
+
+ }
+
+ // ../de.ugoe.cs.swe.bnftools.ebnf/src-gen/de/ugoe/cs/swe/bnftools/parser/antlr/internal/InternalEbnf.g:1026:2: ( (lv_logic_2_0= RULE_LOGIC ) )
+ // ../de.ugoe.cs.swe.bnftools.ebnf/src-gen/de/ugoe/cs/swe/bnftools/parser/antlr/internal/InternalEbnf.g:1027:1: (lv_logic_2_0= RULE_LOGIC )
+ {
+ // ../de.ugoe.cs.swe.bnftools.ebnf/src-gen/de/ugoe/cs/swe/bnftools/parser/antlr/internal/InternalEbnf.g:1027:1: (lv_logic_2_0= RULE_LOGIC )
+ // ../de.ugoe.cs.swe.bnftools.ebnf/src-gen/de/ugoe/cs/swe/bnftools/parser/antlr/internal/InternalEbnf.g:1028:3: lv_logic_2_0= RULE_LOGIC
+ {
+ lv_logic_2_0=(Token)match(input,RULE_LOGIC,FOLLOW_RULE_LOGIC_in_ruleGlobalCombinator2155);
+
+ newLeafNode(lv_logic_2_0, grammarAccess.getGlobalCombinatorAccess().getLogicLOGICTerminalRuleCall_1_0());
+
+
+ if (current==null) {
+ current = createModelElement(grammarAccess.getGlobalCombinatorRule());
+ }
+ setWithLastConsumed(
+ current,
+ "logic",
+ lv_logic_2_0,
+ "LOGIC");
+
+
+ }
+
+
+ }
+
+ // ../de.ugoe.cs.swe.bnftools.ebnf/src-gen/de/ugoe/cs/swe/bnftools/parser/antlr/internal/InternalEbnf.g:1044:2: (otherlv_3= ';' )?
+ int alt25=2;
+ int LA25_0 = input.LA(1);
+
+ if ( (LA25_0==15) ) {
+ alt25=1;
+ }
+ switch (alt25) {
+ case 1 :
+ // ../de.ugoe.cs.swe.bnftools.ebnf/src-gen/de/ugoe/cs/swe/bnftools/parser/antlr/internal/InternalEbnf.g:1044:4: otherlv_3= ';'
+ {
+ otherlv_3=(Token)match(input,15,FOLLOW_15_in_ruleGlobalCombinator2173);
+
+ newLeafNode(otherlv_3, grammarAccess.getGlobalCombinatorAccess().getSemicolonKeyword_2());
+
+
+ }
+ break;
+
+ }
+
+
+ }
+
+
+ }
+
+ leaveRule();
+ }
+
+ catch (RecognitionException re) {
+ recover(input,re);
+ appendSkippedTokens();
+ }
+ finally {
+ }
+ return current;
+ }
+ // $ANTLR end "ruleGlobalCombinator"
+
+
+ // $ANTLR start "entryRuleRuleCombinator"
+ // ../de.ugoe.cs.swe.bnftools.ebnf/src-gen/de/ugoe/cs/swe/bnftools/parser/antlr/internal/InternalEbnf.g:1056:1: entryRuleRuleCombinator returns [EObject current=null] : iv_ruleRuleCombinator= ruleRuleCombinator EOF ;
+ public final EObject entryRuleRuleCombinator() throws RecognitionException {
+ EObject current = null;
+
+ EObject iv_ruleRuleCombinator = null;
+
+
+ try {
+ // ../de.ugoe.cs.swe.bnftools.ebnf/src-gen/de/ugoe/cs/swe/bnftools/parser/antlr/internal/InternalEbnf.g:1057:2: (iv_ruleRuleCombinator= ruleRuleCombinator EOF )
+ // ../de.ugoe.cs.swe.bnftools.ebnf/src-gen/de/ugoe/cs/swe/bnftools/parser/antlr/internal/InternalEbnf.g:1058:2: iv_ruleRuleCombinator= ruleRuleCombinator EOF
+ {
+ newCompositeNode(grammarAccess.getRuleCombinatorRule());
+ pushFollow(FOLLOW_ruleRuleCombinator_in_entryRuleRuleCombinator2211);
+ iv_ruleRuleCombinator=ruleRuleCombinator();
+
+ state._fsp--;
+
+ current =iv_ruleRuleCombinator;
+ match(input,EOF,FOLLOW_EOF_in_entryRuleRuleCombinator2221);
+
+ }
+
+ }
+
+ catch (RecognitionException re) {
+ recover(input,re);
+ appendSkippedTokens();
+ }
+ finally {
+ }
+ return current;
+ }
+ // $ANTLR end "entryRuleRuleCombinator"
+
+
+ // $ANTLR start "ruleRuleCombinator"
+ // ../de.ugoe.cs.swe.bnftools.ebnf/src-gen/de/ugoe/cs/swe/bnftools/parser/antlr/internal/InternalEbnf.g:1065:1: ruleRuleCombinator returns [EObject current=null] : ( (otherlv_0= 'rule' otherlv_1= 'combinator:' ( (lv_name_2_0= RULE_ID ) ) ) ( (lv_logic_3_0= RULE_LOGIC ) ) (otherlv_4= '(' ( (lv_LABEL_5_0= RULE_STRING ) ) otherlv_6= ')' )* (otherlv_7= ';' )? ) ;
+ public final EObject ruleRuleCombinator() throws RecognitionException {
+ EObject current = null;
+
+ Token otherlv_0=null;
+ Token otherlv_1=null;
+ Token lv_name_2_0=null;
+ Token lv_logic_3_0=null;
+ Token otherlv_4=null;
+ Token lv_LABEL_5_0=null;
+ Token otherlv_6=null;
+ Token otherlv_7=null;
+
+ enterRule();
+
+ try {
+ // ../de.ugoe.cs.swe.bnftools.ebnf/src-gen/de/ugoe/cs/swe/bnftools/parser/antlr/internal/InternalEbnf.g:1068:28: ( ( (otherlv_0= 'rule' otherlv_1= 'combinator:' ( (lv_name_2_0= RULE_ID ) ) ) ( (lv_logic_3_0= RULE_LOGIC ) ) (otherlv_4= '(' ( (lv_LABEL_5_0= RULE_STRING ) ) otherlv_6= ')' )* (otherlv_7= ';' )? ) )
+ // ../de.ugoe.cs.swe.bnftools.ebnf/src-gen/de/ugoe/cs/swe/bnftools/parser/antlr/internal/InternalEbnf.g:1069:1: ( (otherlv_0= 'rule' otherlv_1= 'combinator:' ( (lv_name_2_0= RULE_ID ) ) ) ( (lv_logic_3_0= RULE_LOGIC ) ) (otherlv_4= '(' ( (lv_LABEL_5_0= RULE_STRING ) ) otherlv_6= ')' )* (otherlv_7= ';' )? )
+ {
+ // ../de.ugoe.cs.swe.bnftools.ebnf/src-gen/de/ugoe/cs/swe/bnftools/parser/antlr/internal/InternalEbnf.g:1069:1: ( (otherlv_0= 'rule' otherlv_1= 'combinator:' ( (lv_name_2_0= RULE_ID ) ) ) ( (lv_logic_3_0= RULE_LOGIC ) ) (otherlv_4= '(' ( (lv_LABEL_5_0= RULE_STRING ) ) otherlv_6= ')' )* (otherlv_7= ';' )? )
+ // ../de.ugoe.cs.swe.bnftools.ebnf/src-gen/de/ugoe/cs/swe/bnftools/parser/antlr/internal/InternalEbnf.g:1069:2: (otherlv_0= 'rule' otherlv_1= 'combinator:' ( (lv_name_2_0= RULE_ID ) ) ) ( (lv_logic_3_0= RULE_LOGIC ) ) (otherlv_4= '(' ( (lv_LABEL_5_0= RULE_STRING ) ) otherlv_6= ')' )* (otherlv_7= ';' )?
+ {
+ // ../de.ugoe.cs.swe.bnftools.ebnf/src-gen/de/ugoe/cs/swe/bnftools/parser/antlr/internal/InternalEbnf.g:1069:2: (otherlv_0= 'rule' otherlv_1= 'combinator:' ( (lv_name_2_0= RULE_ID ) ) )
+ // ../de.ugoe.cs.swe.bnftools.ebnf/src-gen/de/ugoe/cs/swe/bnftools/parser/antlr/internal/InternalEbnf.g:1069:4: otherlv_0= 'rule' otherlv_1= 'combinator:' ( (lv_name_2_0= RULE_ID ) )
+ {
+ otherlv_0=(Token)match(input,38,FOLLOW_38_in_ruleRuleCombinator2259);
+
+ newLeafNode(otherlv_0, grammarAccess.getRuleCombinatorAccess().getRuleKeyword_0_0());
+
+ otherlv_1=(Token)match(input,37,FOLLOW_37_in_ruleRuleCombinator2271);
+
+ newLeafNode(otherlv_1, grammarAccess.getRuleCombinatorAccess().getCombinatorKeyword_0_1());
+
+ // ../de.ugoe.cs.swe.bnftools.ebnf/src-gen/de/ugoe/cs/swe/bnftools/parser/antlr/internal/InternalEbnf.g:1077:1: ( (lv_name_2_0= RULE_ID ) )
+ // ../de.ugoe.cs.swe.bnftools.ebnf/src-gen/de/ugoe/cs/swe/bnftools/parser/antlr/internal/InternalEbnf.g:1078:1: (lv_name_2_0= RULE_ID )
+ {
+ // ../de.ugoe.cs.swe.bnftools.ebnf/src-gen/de/ugoe/cs/swe/bnftools/parser/antlr/internal/InternalEbnf.g:1078:1: (lv_name_2_0= RULE_ID )
+ // ../de.ugoe.cs.swe.bnftools.ebnf/src-gen/de/ugoe/cs/swe/bnftools/parser/antlr/internal/InternalEbnf.g:1079:3: lv_name_2_0= RULE_ID
+ {
+ lv_name_2_0=(Token)match(input,RULE_ID,FOLLOW_RULE_ID_in_ruleRuleCombinator2288);
+
+ newLeafNode(lv_name_2_0, grammarAccess.getRuleCombinatorAccess().getNameIDTerminalRuleCall_0_2_0());
+
+
+ if (current==null) {
+ current = createModelElement(grammarAccess.getRuleCombinatorRule());
+ }
+ setWithLastConsumed(
+ current,
+ "name",
+ lv_name_2_0,
+ "ID");
+
+
+ }
+
+
+ }
+
+
+ }
+
+ // ../de.ugoe.cs.swe.bnftools.ebnf/src-gen/de/ugoe/cs/swe/bnftools/parser/antlr/internal/InternalEbnf.g:1095:3: ( (lv_logic_3_0= RULE_LOGIC ) )
+ // ../de.ugoe.cs.swe.bnftools.ebnf/src-gen/de/ugoe/cs/swe/bnftools/parser/antlr/internal/InternalEbnf.g:1096:1: (lv_logic_3_0= RULE_LOGIC )
+ {
+ // ../de.ugoe.cs.swe.bnftools.ebnf/src-gen/de/ugoe/cs/swe/bnftools/parser/antlr/internal/InternalEbnf.g:1096:1: (lv_logic_3_0= RULE_LOGIC )
+ // ../de.ugoe.cs.swe.bnftools.ebnf/src-gen/de/ugoe/cs/swe/bnftools/parser/antlr/internal/InternalEbnf.g:1097:3: lv_logic_3_0= RULE_LOGIC
+ {
+ lv_logic_3_0=(Token)match(input,RULE_LOGIC,FOLLOW_RULE_LOGIC_in_ruleRuleCombinator2311);
+
+ newLeafNode(lv_logic_3_0, grammarAccess.getRuleCombinatorAccess().getLogicLOGICTerminalRuleCall_1_0());
+
+
+ if (current==null) {
+ current = createModelElement(grammarAccess.getRuleCombinatorRule());
+ }
+ setWithLastConsumed(
+ current,
+ "logic",
+ lv_logic_3_0,
+ "LOGIC");
+
+
+ }
+
+
+ }
+
+ // ../de.ugoe.cs.swe.bnftools.ebnf/src-gen/de/ugoe/cs/swe/bnftools/parser/antlr/internal/InternalEbnf.g:1113:2: (otherlv_4= '(' ( (lv_LABEL_5_0= RULE_STRING ) ) otherlv_6= ')' )*
+ loop26:
+ do {
+ int alt26=2;
+ int LA26_0 = input.LA(1);
+
+ if ( (LA26_0==26) ) {
+ alt26=1;
+ }
+
+
+ switch (alt26) {
+ case 1 :
+ // ../de.ugoe.cs.swe.bnftools.ebnf/src-gen/de/ugoe/cs/swe/bnftools/parser/antlr/internal/InternalEbnf.g:1113:4: otherlv_4= '(' ( (lv_LABEL_5_0= RULE_STRING ) ) otherlv_6= ')'
+ {
+ otherlv_4=(Token)match(input,26,FOLLOW_26_in_ruleRuleCombinator2329);
+
+ newLeafNode(otherlv_4, grammarAccess.getRuleCombinatorAccess().getLeftParenthesisKeyword_2_0());
+
+ // ../de.ugoe.cs.swe.bnftools.ebnf/src-gen/de/ugoe/cs/swe/bnftools/parser/antlr/internal/InternalEbnf.g:1117:1: ( (lv_LABEL_5_0= RULE_STRING ) )
+ // ../de.ugoe.cs.swe.bnftools.ebnf/src-gen/de/ugoe/cs/swe/bnftools/parser/antlr/internal/InternalEbnf.g:1118:1: (lv_LABEL_5_0= RULE_STRING )
+ {
+ // ../de.ugoe.cs.swe.bnftools.ebnf/src-gen/de/ugoe/cs/swe/bnftools/parser/antlr/internal/InternalEbnf.g:1118:1: (lv_LABEL_5_0= RULE_STRING )
+ // ../de.ugoe.cs.swe.bnftools.ebnf/src-gen/de/ugoe/cs/swe/bnftools/parser/antlr/internal/InternalEbnf.g:1119:3: lv_LABEL_5_0= RULE_STRING
+ {
+ lv_LABEL_5_0=(Token)match(input,RULE_STRING,FOLLOW_RULE_STRING_in_ruleRuleCombinator2346);
+
+ newLeafNode(lv_LABEL_5_0, grammarAccess.getRuleCombinatorAccess().getLABELSTRINGTerminalRuleCall_2_1_0());
+
+
+ if (current==null) {
+ current = createModelElement(grammarAccess.getRuleCombinatorRule());
+ }
+ addWithLastConsumed(
+ current,
+ "LABEL",
+ lv_LABEL_5_0,
+ "STRING");
+
+
+ }
+
+
+ }
+
+ otherlv_6=(Token)match(input,27,FOLLOW_27_in_ruleRuleCombinator2363);
+
+ newLeafNode(otherlv_6, grammarAccess.getRuleCombinatorAccess().getRightParenthesisKeyword_2_2());
+
+
+ }
+ break;
+
+ default :
+ break loop26;
+ }
+ } while (true);
+
+ // ../de.ugoe.cs.swe.bnftools.ebnf/src-gen/de/ugoe/cs/swe/bnftools/parser/antlr/internal/InternalEbnf.g:1139:3: (otherlv_7= ';' )?
+ int alt27=2;
+ int LA27_0 = input.LA(1);
+
+ if ( (LA27_0==15) ) {
+ alt27=1;
+ }
+ switch (alt27) {
+ case 1 :
+ // ../de.ugoe.cs.swe.bnftools.ebnf/src-gen/de/ugoe/cs/swe/bnftools/parser/antlr/internal/InternalEbnf.g:1139:5: otherlv_7= ';'
+ {
+ otherlv_7=(Token)match(input,15,FOLLOW_15_in_ruleRuleCombinator2378);
+
+ newLeafNode(otherlv_7, grammarAccess.getRuleCombinatorAccess().getSemicolonKeyword_3());
+
+
+ }
+ break;
+
+ }
+
+
+ }
+
+
+ }
+
+ leaveRule();
+ }
+
+ catch (RecognitionException re) {
+ recover(input,re);
+ appendSkippedTokens();
+ }
+ finally {
+ }
+ return current;
+ }
+ // $ANTLR end "ruleRuleCombinator"
+
+
+ // $ANTLR start "entryRuleHookCombinator"
+ // ../de.ugoe.cs.swe.bnftools.ebnf/src-gen/de/ugoe/cs/swe/bnftools/parser/antlr/internal/InternalEbnf.g:1151:1: entryRuleHookCombinator returns [EObject current=null] : iv_ruleHookCombinator= ruleHookCombinator EOF ;
+ public final EObject entryRuleHookCombinator() throws RecognitionException {
+ EObject current = null;
+
+ EObject iv_ruleHookCombinator = null;
+
+
+ try {
+ // ../de.ugoe.cs.swe.bnftools.ebnf/src-gen/de/ugoe/cs/swe/bnftools/parser/antlr/internal/InternalEbnf.g:1152:2: (iv_ruleHookCombinator= ruleHookCombinator EOF )
+ // ../de.ugoe.cs.swe.bnftools.ebnf/src-gen/de/ugoe/cs/swe/bnftools/parser/antlr/internal/InternalEbnf.g:1153:2: iv_ruleHookCombinator= ruleHookCombinator EOF
+ {
+ newCompositeNode(grammarAccess.getHookCombinatorRule());
+ pushFollow(FOLLOW_ruleHookCombinator_in_entryRuleHookCombinator2416);
+ iv_ruleHookCombinator=ruleHookCombinator();
+
+ state._fsp--;
+
+ current =iv_ruleHookCombinator;
+ match(input,EOF,FOLLOW_EOF_in_entryRuleHookCombinator2426);
+
+ }
+
+ }
+
+ catch (RecognitionException re) {
+ recover(input,re);
+ appendSkippedTokens();
+ }
+ finally {
+ }
+ return current;
+ }
+ // $ANTLR end "entryRuleHookCombinator"
+
+
+ // $ANTLR start "ruleHookCombinator"
+ // ../de.ugoe.cs.swe.bnftools.ebnf/src-gen/de/ugoe/cs/swe/bnftools/parser/antlr/internal/InternalEbnf.g:1160:1: ruleHookCombinator returns [EObject current=null] : (otherlv_0= 'hook' otherlv_1= 'combinator:' ( (lv_name_2_0= RULE_ID ) ) otherlv_3= '(' ( (lv_ruleext_4_0= RULE_INT ) ) otherlv_5= ')' ( (lv_logic_6_0= RULE_LOGIC ) )? (otherlv_7= '(' ( (lv_LABEL_8_0= RULE_STRING ) ) otherlv_9= ')' )+ (otherlv_10= ';' )? ) ;
+ public final EObject ruleHookCombinator() throws RecognitionException {
+ EObject current = null;
+
+ Token otherlv_0=null;
+ Token otherlv_1=null;
+ Token lv_name_2_0=null;
+ Token otherlv_3=null;
+ Token lv_ruleext_4_0=null;
+ Token otherlv_5=null;
+ Token lv_logic_6_0=null;
+ Token otherlv_7=null;
+ Token lv_LABEL_8_0=null;
+ Token otherlv_9=null;
+ Token otherlv_10=null;
+
+ enterRule();
+
+ try {
+ // ../de.ugoe.cs.swe.bnftools.ebnf/src-gen/de/ugoe/cs/swe/bnftools/parser/antlr/internal/InternalEbnf.g:1163:28: ( (otherlv_0= 'hook' otherlv_1= 'combinator:' ( (lv_name_2_0= RULE_ID ) ) otherlv_3= '(' ( (lv_ruleext_4_0= RULE_INT ) ) otherlv_5= ')' ( (lv_logic_6_0= RULE_LOGIC ) )? (otherlv_7= '(' ( (lv_LABEL_8_0= RULE_STRING ) ) otherlv_9= ')' )+ (otherlv_10= ';' )? ) )
+ // ../de.ugoe.cs.swe.bnftools.ebnf/src-gen/de/ugoe/cs/swe/bnftools/parser/antlr/internal/InternalEbnf.g:1164:1: (otherlv_0= 'hook' otherlv_1= 'combinator:' ( (lv_name_2_0= RULE_ID ) ) otherlv_3= '(' ( (lv_ruleext_4_0= RULE_INT ) ) otherlv_5= ')' ( (lv_logic_6_0= RULE_LOGIC ) )? (otherlv_7= '(' ( (lv_LABEL_8_0= RULE_STRING ) ) otherlv_9= ')' )+ (otherlv_10= ';' )? )
+ {
+ // ../de.ugoe.cs.swe.bnftools.ebnf/src-gen/de/ugoe/cs/swe/bnftools/parser/antlr/internal/InternalEbnf.g:1164:1: (otherlv_0= 'hook' otherlv_1= 'combinator:' ( (lv_name_2_0= RULE_ID ) ) otherlv_3= '(' ( (lv_ruleext_4_0= RULE_INT ) ) otherlv_5= ')' ( (lv_logic_6_0= RULE_LOGIC ) )? (otherlv_7= '(' ( (lv_LABEL_8_0= RULE_STRING ) ) otherlv_9= ')' )+ (otherlv_10= ';' )? )
+ // ../de.ugoe.cs.swe.bnftools.ebnf/src-gen/de/ugoe/cs/swe/bnftools/parser/antlr/internal/InternalEbnf.g:1164:3: otherlv_0= 'hook' otherlv_1= 'combinator:' ( (lv_name_2_0= RULE_ID ) ) otherlv_3= '(' ( (lv_ruleext_4_0= RULE_INT ) ) otherlv_5= ')' ( (lv_logic_6_0= RULE_LOGIC ) )? (otherlv_7= '(' ( (lv_LABEL_8_0= RULE_STRING ) ) otherlv_9= ')' )+ (otherlv_10= ';' )?
+ {
+ otherlv_0=(Token)match(input,39,FOLLOW_39_in_ruleHookCombinator2463);
+
+ newLeafNode(otherlv_0, grammarAccess.getHookCombinatorAccess().getHookKeyword_0());
+
+ otherlv_1=(Token)match(input,37,FOLLOW_37_in_ruleHookCombinator2475);
+
+ newLeafNode(otherlv_1, grammarAccess.getHookCombinatorAccess().getCombinatorKeyword_1());
+
+ // ../de.ugoe.cs.swe.bnftools.ebnf/src-gen/de/ugoe/cs/swe/bnftools/parser/antlr/internal/InternalEbnf.g:1172:1: ( (lv_name_2_0= RULE_ID ) )
+ // ../de.ugoe.cs.swe.bnftools.ebnf/src-gen/de/ugoe/cs/swe/bnftools/parser/antlr/internal/InternalEbnf.g:1173:1: (lv_name_2_0= RULE_ID )
+ {
+ // ../de.ugoe.cs.swe.bnftools.ebnf/src-gen/de/ugoe/cs/swe/bnftools/parser/antlr/internal/InternalEbnf.g:1173:1: (lv_name_2_0= RULE_ID )
+ // ../de.ugoe.cs.swe.bnftools.ebnf/src-gen/de/ugoe/cs/swe/bnftools/parser/antlr/internal/InternalEbnf.g:1174:3: lv_name_2_0= RULE_ID
+ {
+ lv_name_2_0=(Token)match(input,RULE_ID,FOLLOW_RULE_ID_in_ruleHookCombinator2492);
+
+ newLeafNode(lv_name_2_0, grammarAccess.getHookCombinatorAccess().getNameIDTerminalRuleCall_2_0());
+
+
+ if (current==null) {
+ current = createModelElement(grammarAccess.getHookCombinatorRule());
+ }
+ setWithLastConsumed(
+ current,
+ "name",
+ lv_name_2_0,
+ "ID");
+
+
+ }
+
+
+ }
+
+ otherlv_3=(Token)match(input,26,FOLLOW_26_in_ruleHookCombinator2509);
+
+ newLeafNode(otherlv_3, grammarAccess.getHookCombinatorAccess().getLeftParenthesisKeyword_3());
+
+ // ../de.ugoe.cs.swe.bnftools.ebnf/src-gen/de/ugoe/cs/swe/bnftools/parser/antlr/internal/InternalEbnf.g:1194:1: ( (lv_ruleext_4_0= RULE_INT ) )
+ // ../de.ugoe.cs.swe.bnftools.ebnf/src-gen/de/ugoe/cs/swe/bnftools/parser/antlr/internal/InternalEbnf.g:1195:1: (lv_ruleext_4_0= RULE_INT )
+ {
+ // ../de.ugoe.cs.swe.bnftools.ebnf/src-gen/de/ugoe/cs/swe/bnftools/parser/antlr/internal/InternalEbnf.g:1195:1: (lv_ruleext_4_0= RULE_INT )
+ // ../de.ugoe.cs.swe.bnftools.ebnf/src-gen/de/ugoe/cs/swe/bnftools/parser/antlr/internal/InternalEbnf.g:1196:3: lv_ruleext_4_0= RULE_INT
+ {
+ lv_ruleext_4_0=(Token)match(input,RULE_INT,FOLLOW_RULE_INT_in_ruleHookCombinator2526);
+
+ newLeafNode(lv_ruleext_4_0, grammarAccess.getHookCombinatorAccess().getRuleextINTTerminalRuleCall_4_0());
+
+
+ if (current==null) {
+ current = createModelElement(grammarAccess.getHookCombinatorRule());
+ }
+ setWithLastConsumed(
+ current,
+ "ruleext",
+ lv_ruleext_4_0,
+ "INT");
+
+
+ }
+
+
+ }
+
+ otherlv_5=(Token)match(input,27,FOLLOW_27_in_ruleHookCombinator2543);
+
+ newLeafNode(otherlv_5, grammarAccess.getHookCombinatorAccess().getRightParenthesisKeyword_5());
+
+ // ../de.ugoe.cs.swe.bnftools.ebnf/src-gen/de/ugoe/cs/swe/bnftools/parser/antlr/internal/InternalEbnf.g:1216:1: ( (lv_logic_6_0= RULE_LOGIC ) )?
+ int alt28=2;
+ int LA28_0 = input.LA(1);
+
+ if ( (LA28_0==RULE_LOGIC) ) {
+ alt28=1;
+ }
+ switch (alt28) {
+ case 1 :
+ // ../de.ugoe.cs.swe.bnftools.ebnf/src-gen/de/ugoe/cs/swe/bnftools/parser/antlr/internal/InternalEbnf.g:1217:1: (lv_logic_6_0= RULE_LOGIC )
+ {
+ // ../de.ugoe.cs.swe.bnftools.ebnf/src-gen/de/ugoe/cs/swe/bnftools/parser/antlr/internal/InternalEbnf.g:1217:1: (lv_logic_6_0= RULE_LOGIC )
+ // ../de.ugoe.cs.swe.bnftools.ebnf/src-gen/de/ugoe/cs/swe/bnftools/parser/antlr/internal/InternalEbnf.g:1218:3: lv_logic_6_0= RULE_LOGIC
+ {
+ lv_logic_6_0=(Token)match(input,RULE_LOGIC,FOLLOW_RULE_LOGIC_in_ruleHookCombinator2560);
+
+ newLeafNode(lv_logic_6_0, grammarAccess.getHookCombinatorAccess().getLogicLOGICTerminalRuleCall_6_0());
+
+
+ if (current==null) {
+ current = createModelElement(grammarAccess.getHookCombinatorRule());
+ }
+ setWithLastConsumed(
+ current,
+ "logic",
+ lv_logic_6_0,
+ "LOGIC");
+
+
+ }
+
+
+ }
+ break;
+
+ }
+
+ // ../de.ugoe.cs.swe.bnftools.ebnf/src-gen/de/ugoe/cs/swe/bnftools/parser/antlr/internal/InternalEbnf.g:1234:3: (otherlv_7= '(' ( (lv_LABEL_8_0= RULE_STRING ) ) otherlv_9= ')' )+
+ int cnt29=0;
+ loop29:
+ do {
+ int alt29=2;
+ int LA29_0 = input.LA(1);
+
+ if ( (LA29_0==26) ) {
+ alt29=1;
+ }
+
+
+ switch (alt29) {
+ case 1 :
+ // ../de.ugoe.cs.swe.bnftools.ebnf/src-gen/de/ugoe/cs/swe/bnftools/parser/antlr/internal/InternalEbnf.g:1234:5: otherlv_7= '(' ( (lv_LABEL_8_0= RULE_STRING ) ) otherlv_9= ')'
+ {
+ otherlv_7=(Token)match(input,26,FOLLOW_26_in_ruleHookCombinator2579);
+
+ newLeafNode(otherlv_7, grammarAccess.getHookCombinatorAccess().getLeftParenthesisKeyword_7_0());
+
+ // ../de.ugoe.cs.swe.bnftools.ebnf/src-gen/de/ugoe/cs/swe/bnftools/parser/antlr/internal/InternalEbnf.g:1238:1: ( (lv_LABEL_8_0= RULE_STRING ) )
+ // ../de.ugoe.cs.swe.bnftools.ebnf/src-gen/de/ugoe/cs/swe/bnftools/parser/antlr/internal/InternalEbnf.g:1239:1: (lv_LABEL_8_0= RULE_STRING )
+ {
+ // ../de.ugoe.cs.swe.bnftools.ebnf/src-gen/de/ugoe/cs/swe/bnftools/parser/antlr/internal/InternalEbnf.g:1239:1: (lv_LABEL_8_0= RULE_STRING )
+ // ../de.ugoe.cs.swe.bnftools.ebnf/src-gen/de/ugoe/cs/swe/bnftools/parser/antlr/internal/InternalEbnf.g:1240:3: lv_LABEL_8_0= RULE_STRING
+ {
+ lv_LABEL_8_0=(Token)match(input,RULE_STRING,FOLLOW_RULE_STRING_in_ruleHookCombinator2596);
+
+ newLeafNode(lv_LABEL_8_0, grammarAccess.getHookCombinatorAccess().getLABELSTRINGTerminalRuleCall_7_1_0());
+
+
+ if (current==null) {
+ current = createModelElement(grammarAccess.getHookCombinatorRule());
+ }
+ addWithLastConsumed(
+ current,
+ "LABEL",
+ lv_LABEL_8_0,
+ "STRING");
+
+
+ }
+
+
+ }
+
+ otherlv_9=(Token)match(input,27,FOLLOW_27_in_ruleHookCombinator2613);
+
+ newLeafNode(otherlv_9, grammarAccess.getHookCombinatorAccess().getRightParenthesisKeyword_7_2());
+
+
+ }
+ break;
+
+ default :
+ if ( cnt29 >= 1 ) break loop29;
+ EarlyExitException eee =
+ new EarlyExitException(29, input);
+ throw eee;
+ }
+ cnt29++;
+ } while (true);
+
+ // ../de.ugoe.cs.swe.bnftools.ebnf/src-gen/de/ugoe/cs/swe/bnftools/parser/antlr/internal/InternalEbnf.g:1260:3: (otherlv_10= ';' )?
+ int alt30=2;
+ int LA30_0 = input.LA(1);
+
+ if ( (LA30_0==15) ) {
+ alt30=1;
+ }
+ switch (alt30) {
+ case 1 :
+ // ../de.ugoe.cs.swe.bnftools.ebnf/src-gen/de/ugoe/cs/swe/bnftools/parser/antlr/internal/InternalEbnf.g:1260:5: otherlv_10= ';'
+ {
+ otherlv_10=(Token)match(input,15,FOLLOW_15_in_ruleHookCombinator2628);
+
+ newLeafNode(otherlv_10, grammarAccess.getHookCombinatorAccess().getSemicolonKeyword_8());
+
+
+ }
+ break;
+
+ }
+
+
+ }
+
+
+ }
+
+ leaveRule();
+ }
+
+ catch (RecognitionException re) {
+ recover(input,re);
+ appendSkippedTokens();
+ }
+ finally {
+ }
+ return current;
+ }
+ // $ANTLR end "ruleHookCombinator"
+
+
+ // $ANTLR start "entryRuleDefinitionList"
+ // ../de.ugoe.cs.swe.bnftools.ebnf/src-gen/de/ugoe/cs/swe/bnftools/parser/antlr/internal/InternalEbnf.g:1272:1: entryRuleDefinitionList returns [EObject current=null] : iv_ruleDefinitionList= ruleDefinitionList EOF ;
+ public final EObject entryRuleDefinitionList() throws RecognitionException {
+ EObject current = null;
+
+ EObject iv_ruleDefinitionList = null;
+
+
+ try {
+ // ../de.ugoe.cs.swe.bnftools.ebnf/src-gen/de/ugoe/cs/swe/bnftools/parser/antlr/internal/InternalEbnf.g:1273:2: (iv_ruleDefinitionList= ruleDefinitionList EOF )
+ // ../de.ugoe.cs.swe.bnftools.ebnf/src-gen/de/ugoe/cs/swe/bnftools/parser/antlr/internal/InternalEbnf.g:1274:2: iv_ruleDefinitionList= ruleDefinitionList EOF
+ {
+ newCompositeNode(grammarAccess.getDefinitionListRule());
+ pushFollow(FOLLOW_ruleDefinitionList_in_entryRuleDefinitionList2666);
+ iv_ruleDefinitionList=ruleDefinitionList();
+
+ state._fsp--;
+
+ current =iv_ruleDefinitionList;
+ match(input,EOF,FOLLOW_EOF_in_entryRuleDefinitionList2676);
+
+ }
+
+ }
+
+ catch (RecognitionException re) {
+ recover(input,re);
+ appendSkippedTokens();
+ }
+ finally {
+ }
+ return current;
+ }
+ // $ANTLR end "entryRuleDefinitionList"
+
+
+ // $ANTLR start "ruleDefinitionList"
+ // ../de.ugoe.cs.swe.bnftools.ebnf/src-gen/de/ugoe/cs/swe/bnftools/parser/antlr/internal/InternalEbnf.g:1281:1: ruleDefinitionList returns [EObject current=null] : ( ( (lv_singleDefinition_0_0= ruleSingleDefinition ) ) (otherlv_1= '|' ( (lv_singleDefinition_2_0= ruleSingleDefinition ) ) )* ) ;
+ public final EObject ruleDefinitionList() throws RecognitionException {
+ EObject current = null;
+
+ Token otherlv_1=null;
+ EObject lv_singleDefinition_0_0 = null;
+
+ EObject lv_singleDefinition_2_0 = null;
+
+
+ enterRule();
+
+ try {
+ // ../de.ugoe.cs.swe.bnftools.ebnf/src-gen/de/ugoe/cs/swe/bnftools/parser/antlr/internal/InternalEbnf.g:1284:28: ( ( ( (lv_singleDefinition_0_0= ruleSingleDefinition ) ) (otherlv_1= '|' ( (lv_singleDefinition_2_0= ruleSingleDefinition ) ) )* ) )
+ // ../de.ugoe.cs.swe.bnftools.ebnf/src-gen/de/ugoe/cs/swe/bnftools/parser/antlr/internal/InternalEbnf.g:1285:1: ( ( (lv_singleDefinition_0_0= ruleSingleDefinition ) ) (otherlv_1= '|' ( (lv_singleDefinition_2_0= ruleSingleDefinition ) ) )* )
+ {
+ // ../de.ugoe.cs.swe.bnftools.ebnf/src-gen/de/ugoe/cs/swe/bnftools/parser/antlr/internal/InternalEbnf.g:1285:1: ( ( (lv_singleDefinition_0_0= ruleSingleDefinition ) ) (otherlv_1= '|' ( (lv_singleDefinition_2_0= ruleSingleDefinition ) ) )* )
+ // ../de.ugoe.cs.swe.bnftools.ebnf/src-gen/de/ugoe/cs/swe/bnftools/parser/antlr/internal/InternalEbnf.g:1285:2: ( (lv_singleDefinition_0_0= ruleSingleDefinition ) ) (otherlv_1= '|' ( (lv_singleDefinition_2_0= ruleSingleDefinition ) ) )*
+ {
+ // ../de.ugoe.cs.swe.bnftools.ebnf/src-gen/de/ugoe/cs/swe/bnftools/parser/antlr/internal/InternalEbnf.g:1285:2: ( (lv_singleDefinition_0_0= ruleSingleDefinition ) )
+ // ../de.ugoe.cs.swe.bnftools.ebnf/src-gen/de/ugoe/cs/swe/bnftools/parser/antlr/internal/InternalEbnf.g:1286:1: (lv_singleDefinition_0_0= ruleSingleDefinition )
+ {
+ // ../de.ugoe.cs.swe.bnftools.ebnf/src-gen/de/ugoe/cs/swe/bnftools/parser/antlr/internal/InternalEbnf.g:1286:1: (lv_singleDefinition_0_0= ruleSingleDefinition )
+ // ../de.ugoe.cs.swe.bnftools.ebnf/src-gen/de/ugoe/cs/swe/bnftools/parser/antlr/internal/InternalEbnf.g:1287:3: lv_singleDefinition_0_0= ruleSingleDefinition
+ {
+
+ newCompositeNode(grammarAccess.getDefinitionListAccess().getSingleDefinitionSingleDefinitionParserRuleCall_0_0());
+
+ pushFollow(FOLLOW_ruleSingleDefinition_in_ruleDefinitionList2722);
+ lv_singleDefinition_0_0=ruleSingleDefinition();
+
+ state._fsp--;
+
+
+ if (current==null) {
+ current = createModelElementForParent(grammarAccess.getDefinitionListRule());
+ }
+ add(
+ current,
+ "singleDefinition",
+ lv_singleDefinition_0_0,
+ "SingleDefinition");
+ afterParserOrEnumRuleCall();
+
+
+ }
+
+
+ }
+
+ // ../de.ugoe.cs.swe.bnftools.ebnf/src-gen/de/ugoe/cs/swe/bnftools/parser/antlr/internal/InternalEbnf.g:1303:2: (otherlv_1= '|' ( (lv_singleDefinition_2_0= ruleSingleDefinition ) ) )*
+ loop31:
+ do {
+ int alt31=2;
+ int LA31_0 = input.LA(1);
+
+ if ( (LA31_0==31) ) {
+ alt31=1;
+ }
+
+
+ switch (alt31) {
+ case 1 :
+ // ../de.ugoe.cs.swe.bnftools.ebnf/src-gen/de/ugoe/cs/swe/bnftools/parser/antlr/internal/InternalEbnf.g:1303:4: otherlv_1= '|' ( (lv_singleDefinition_2_0= ruleSingleDefinition ) )
+ {
+ otherlv_1=(Token)match(input,31,FOLLOW_31_in_ruleDefinitionList2735);
+
+ newLeafNode(otherlv_1, grammarAccess.getDefinitionListAccess().getVerticalLineKeyword_1_0());
+
+ // ../de.ugoe.cs.swe.bnftools.ebnf/src-gen/de/ugoe/cs/swe/bnftools/parser/antlr/internal/InternalEbnf.g:1307:1: ( (lv_singleDefinition_2_0= ruleSingleDefinition ) )
+ // ../de.ugoe.cs.swe.bnftools.ebnf/src-gen/de/ugoe/cs/swe/bnftools/parser/antlr/internal/InternalEbnf.g:1308:1: (lv_singleDefinition_2_0= ruleSingleDefinition )
+ {
+ // ../de.ugoe.cs.swe.bnftools.ebnf/src-gen/de/ugoe/cs/swe/bnftools/parser/antlr/internal/InternalEbnf.g:1308:1: (lv_singleDefinition_2_0= ruleSingleDefinition )
+ // ../de.ugoe.cs.swe.bnftools.ebnf/src-gen/de/ugoe/cs/swe/bnftools/parser/antlr/internal/InternalEbnf.g:1309:3: lv_singleDefinition_2_0= ruleSingleDefinition
+ {
+
+ newCompositeNode(grammarAccess.getDefinitionListAccess().getSingleDefinitionSingleDefinitionParserRuleCall_1_1_0());
+
+ pushFollow(FOLLOW_ruleSingleDefinition_in_ruleDefinitionList2756);
+ lv_singleDefinition_2_0=ruleSingleDefinition();
+
+ state._fsp--;
+
+
+ if (current==null) {
+ current = createModelElementForParent(grammarAccess.getDefinitionListRule());
+ }
+ add(
+ current,
+ "singleDefinition",
+ lv_singleDefinition_2_0,
+ "SingleDefinition");
+ afterParserOrEnumRuleCall();
+
+
+ }
+
+
+ }
+
+
+ }
+ break;
+
+ default :
+ break loop31;
+ }
+ } while (true);
+
+
+ }
+
+
+ }
+
+ leaveRule();
+ }
+
+ catch (RecognitionException re) {
+ recover(input,re);
+ appendSkippedTokens();
+ }
+ finally {
+ }
+ return current;
+ }
+ // $ANTLR end "ruleDefinitionList"
+
+
+ // $ANTLR start "entryRuleSingleDefinition"
+ // ../de.ugoe.cs.swe.bnftools.ebnf/src-gen/de/ugoe/cs/swe/bnftools/parser/antlr/internal/InternalEbnf.g:1333:1: entryRuleSingleDefinition returns [EObject current=null] : iv_ruleSingleDefinition= ruleSingleDefinition EOF ;
+ public final EObject entryRuleSingleDefinition() throws RecognitionException {
+ EObject current = null;
+
+ EObject iv_ruleSingleDefinition = null;
+
+
+ try {
+ // ../de.ugoe.cs.swe.bnftools.ebnf/src-gen/de/ugoe/cs/swe/bnftools/parser/antlr/internal/InternalEbnf.g:1334:2: (iv_ruleSingleDefinition= ruleSingleDefinition EOF )
+ // ../de.ugoe.cs.swe.bnftools.ebnf/src-gen/de/ugoe/cs/swe/bnftools/parser/antlr/internal/InternalEbnf.g:1335:2: iv_ruleSingleDefinition= ruleSingleDefinition EOF
+ {
+ newCompositeNode(grammarAccess.getSingleDefinitionRule());
+ pushFollow(FOLLOW_ruleSingleDefinition_in_entryRuleSingleDefinition2794);
+ iv_ruleSingleDefinition=ruleSingleDefinition();
+
+ state._fsp--;
+
+ current =iv_ruleSingleDefinition;
+ match(input,EOF,FOLLOW_EOF_in_entryRuleSingleDefinition2804);
+
+ }
+
+ }
+
+ catch (RecognitionException re) {
+ recover(input,re);
+ appendSkippedTokens();
+ }
+ finally {
+ }
+ return current;
+ }
+ // $ANTLR end "entryRuleSingleDefinition"
+
+
+ // $ANTLR start "ruleSingleDefinition"
+ // ../de.ugoe.cs.swe.bnftools.ebnf/src-gen/de/ugoe/cs/swe/bnftools/parser/antlr/internal/InternalEbnf.g:1342:1: ruleSingleDefinition returns [EObject current=null] : ( (lv_terms_0_0= ruleTerm ) )+ ;
+ public final EObject ruleSingleDefinition() throws RecognitionException {
+ EObject current = null;
+
+ EObject lv_terms_0_0 = null;
+
+
+ enterRule();
+
+ try {
+ // ../de.ugoe.cs.swe.bnftools.ebnf/src-gen/de/ugoe/cs/swe/bnftools/parser/antlr/internal/InternalEbnf.g:1345:28: ( ( (lv_terms_0_0= ruleTerm ) )+ )
+ // ../de.ugoe.cs.swe.bnftools.ebnf/src-gen/de/ugoe/cs/swe/bnftools/parser/antlr/internal/InternalEbnf.g:1346:1: ( (lv_terms_0_0= ruleTerm ) )+
+ {
+ // ../de.ugoe.cs.swe.bnftools.ebnf/src-gen/de/ugoe/cs/swe/bnftools/parser/antlr/internal/InternalEbnf.g:1346:1: ( (lv_terms_0_0= ruleTerm ) )+
+ int cnt32=0;
+ loop32:
+ do {
+ int alt32=2;
+ int LA32_0 = input.LA(1);
+
+ if ( (LA32_0==RULE_ID) ) {
+ int LA32_2 = input.LA(2);
+
+ if ( (LA32_2==EOF||(LA32_2>=RULE_ID && LA32_2<=RULE_INT)||LA32_2==RULE_COLON||LA32_2==15||LA32_2==27||(LA32_2>=29 && LA32_2<=33)) ) {
+ alt32=1;
+ }
+ else if ( (LA32_2==26) ) {
+ int LA32_4 = input.LA(3);
+
+ if ( (LA32_4==RULE_ID||LA32_4==RULE_STRING||LA32_4==RULE_COLON||LA32_4==26||(LA32_4>=32 && LA32_4<=33)) ) {
+ alt32=1;
+ }
+
+
+ }
+
+
+ }
+ else if ( (LA32_0==RULE_STRING||LA32_0==RULE_COLON||LA32_0==26||(LA32_0>=32 && LA32_0<=33)) ) {
+ alt32=1;
+ }
+
+
+ switch (alt32) {
+ case 1 :
+ // ../de.ugoe.cs.swe.bnftools.ebnf/src-gen/de/ugoe/cs/swe/bnftools/parser/antlr/internal/InternalEbnf.g:1347:1: (lv_terms_0_0= ruleTerm )
+ {
+ // ../de.ugoe.cs.swe.bnftools.ebnf/src-gen/de/ugoe/cs/swe/bnftools/parser/antlr/internal/InternalEbnf.g:1347:1: (lv_terms_0_0= ruleTerm )
+ // ../de.ugoe.cs.swe.bnftools.ebnf/src-gen/de/ugoe/cs/swe/bnftools/parser/antlr/internal/InternalEbnf.g:1348:3: lv_terms_0_0= ruleTerm
+ {
+
+ newCompositeNode(grammarAccess.getSingleDefinitionAccess().getTermsTermParserRuleCall_0());
+
+ pushFollow(FOLLOW_ruleTerm_in_ruleSingleDefinition2849);
+ lv_terms_0_0=ruleTerm();
+
+ state._fsp--;
+
+
+ if (current==null) {
+ current = createModelElementForParent(grammarAccess.getSingleDefinitionRule());
+ }
+ add(
+ current,
+ "terms",
+ lv_terms_0_0,
+ "Term");
+ afterParserOrEnumRuleCall();
+
+
+ }
+
+
+ }
+ break;
+
+ default :
+ if ( cnt32 >= 1 ) break loop32;
+ EarlyExitException eee =
+ new EarlyExitException(32, input);
+ throw eee;
+ }
+ cnt32++;
+ } while (true);
+
+
+ }
+
+ leaveRule();
+ }
+
+ catch (RecognitionException re) {
+ recover(input,re);
+ appendSkippedTokens();
+ }
+ finally {
+ }
+ return current;
+ }
+ // $ANTLR end "ruleSingleDefinition"
+
+
+ // $ANTLR start "entryRuleTerm"
+ // ../de.ugoe.cs.swe.bnftools.ebnf/src-gen/de/ugoe/cs/swe/bnftools/parser/antlr/internal/InternalEbnf.g:1372:1: entryRuleTerm returns [EObject current=null] : iv_ruleTerm= ruleTerm EOF ;
+ public final EObject entryRuleTerm() throws RecognitionException {
+ EObject current = null;
+
+ EObject iv_ruleTerm = null;
+
+
+ try {
+ // ../de.ugoe.cs.swe.bnftools.ebnf/src-gen/de/ugoe/cs/swe/bnftools/parser/antlr/internal/InternalEbnf.g:1373:2: (iv_ruleTerm= ruleTerm EOF )
+ // ../de.ugoe.cs.swe.bnftools.ebnf/src-gen/de/ugoe/cs/swe/bnftools/parser/antlr/internal/InternalEbnf.g:1374:2: iv_ruleTerm= ruleTerm EOF
+ {
+ newCompositeNode(grammarAccess.getTermRule());
+ pushFollow(FOLLOW_ruleTerm_in_entryRuleTerm2885);
+ iv_ruleTerm=ruleTerm();
+
+ state._fsp--;
+
+ current =iv_ruleTerm;
+ match(input,EOF,FOLLOW_EOF_in_entryRuleTerm2895);
+
+ }
+
+ }
+
+ catch (RecognitionException re) {
+ recover(input,re);
+ appendSkippedTokens();
+ }
+ finally {
+ }
+ return current;
+ }
+ // $ANTLR end "entryRuleTerm"
+
+
+ // $ANTLR start "ruleTerm"
+ // ../de.ugoe.cs.swe.bnftools.ebnf/src-gen/de/ugoe/cs/swe/bnftools/parser/antlr/internal/InternalEbnf.g:1381:1: ruleTerm returns [EObject current=null] : ( ( (lv_termAtom_0_0= ruleAtom ) ) | ( (lv_termGroupedSequence_1_0= ruleGroupedSequence ) ) | ( (lv_termOptionalSequence_2_0= ruleOptionalSequence ) ) | ( (lv_termRepeatedSequence_3_0= ruleRepeatedSequence ) ) ) ;
+ public final EObject ruleTerm() throws RecognitionException {
+ EObject current = null;
+
+ EObject lv_termAtom_0_0 = null;
+
+ EObject lv_termGroupedSequence_1_0 = null;
+
+ EObject lv_termOptionalSequence_2_0 = null;
+
+ EObject lv_termRepeatedSequence_3_0 = null;
+
+
+ enterRule();
+
+ try {
+ // ../de.ugoe.cs.swe.bnftools.ebnf/src-gen/de/ugoe/cs/swe/bnftools/parser/antlr/internal/InternalEbnf.g:1384:28: ( ( ( (lv_termAtom_0_0= ruleAtom ) ) | ( (lv_termGroupedSequence_1_0= ruleGroupedSequence ) ) | ( (lv_termOptionalSequence_2_0= ruleOptionalSequence ) ) | ( (lv_termRepeatedSequence_3_0= ruleRepeatedSequence ) ) ) )
+ // ../de.ugoe.cs.swe.bnftools.ebnf/src-gen/de/ugoe/cs/swe/bnftools/parser/antlr/internal/InternalEbnf.g:1385:1: ( ( (lv_termAtom_0_0= ruleAtom ) ) | ( (lv_termGroupedSequence_1_0= ruleGroupedSequence ) ) | ( (lv_termOptionalSequence_2_0= ruleOptionalSequence ) ) | ( (lv_termRepeatedSequence_3_0= ruleRepeatedSequence ) ) )
+ {
+ // ../de.ugoe.cs.swe.bnftools.ebnf/src-gen/de/ugoe/cs/swe/bnftools/parser/antlr/internal/InternalEbnf.g:1385:1: ( ( (lv_termAtom_0_0= ruleAtom ) ) | ( (lv_termGroupedSequence_1_0= ruleGroupedSequence ) ) | ( (lv_termOptionalSequence_2_0= ruleOptionalSequence ) ) | ( (lv_termRepeatedSequence_3_0= ruleRepeatedSequence ) ) )
+ int alt33=4;
+ switch ( input.LA(1) ) {
+ case RULE_ID:
+ case RULE_STRING:
+ case RULE_COLON:
+ {
+ alt33=1;
+ }
+ break;
+ case 26:
+ {
+ alt33=2;
+ }
+ break;
+ case 32:
+ {
+ alt33=3;
+ }
+ break;
+ case 33:
+ {
+ alt33=4;
+ }
+ break;
+ default:
+ NoViableAltException nvae =
+ new NoViableAltException("", 33, 0, input);
+
+ throw nvae;
+ }
+
+ switch (alt33) {
+ case 1 :
+ // ../de.ugoe.cs.swe.bnftools.ebnf/src-gen/de/ugoe/cs/swe/bnftools/parser/antlr/internal/InternalEbnf.g:1385:2: ( (lv_termAtom_0_0= ruleAtom ) )
+ {
+ // ../de.ugoe.cs.swe.bnftools.ebnf/src-gen/de/ugoe/cs/swe/bnftools/parser/antlr/internal/InternalEbnf.g:1385:2: ( (lv_termAtom_0_0= ruleAtom ) )
+ // ../de.ugoe.cs.swe.bnftools.ebnf/src-gen/de/ugoe/cs/swe/bnftools/parser/antlr/internal/InternalEbnf.g:1386:1: (lv_termAtom_0_0= ruleAtom )
+ {
+ // ../de.ugoe.cs.swe.bnftools.ebnf/src-gen/de/ugoe/cs/swe/bnftools/parser/antlr/internal/InternalEbnf.g:1386:1: (lv_termAtom_0_0= ruleAtom )
+ // ../de.ugoe.cs.swe.bnftools.ebnf/src-gen/de/ugoe/cs/swe/bnftools/parser/antlr/internal/InternalEbnf.g:1387:3: lv_termAtom_0_0= ruleAtom
+ {
+
+ newCompositeNode(grammarAccess.getTermAccess().getTermAtomAtomParserRuleCall_0_0());
+
+ pushFollow(FOLLOW_ruleAtom_in_ruleTerm2941);
+ lv_termAtom_0_0=ruleAtom();
+
+ state._fsp--;
+
+
+ if (current==null) {
+ current = createModelElementForParent(grammarAccess.getTermRule());
+ }
+ set(
+ current,
+ "termAtom",
+ lv_termAtom_0_0,
+ "Atom");
+ afterParserOrEnumRuleCall();
+
+
+ }
+
+
+ }
+
+
+ }
+ break;
+ case 2 :
+ // ../de.ugoe.cs.swe.bnftools.ebnf/src-gen/de/ugoe/cs/swe/bnftools/parser/antlr/internal/InternalEbnf.g:1404:6: ( (lv_termGroupedSequence_1_0= ruleGroupedSequence ) )
+ {
+ // ../de.ugoe.cs.swe.bnftools.ebnf/src-gen/de/ugoe/cs/swe/bnftools/parser/antlr/internal/InternalEbnf.g:1404:6: ( (lv_termGroupedSequence_1_0= ruleGroupedSequence ) )
+ // ../de.ugoe.cs.swe.bnftools.ebnf/src-gen/de/ugoe/cs/swe/bnftools/parser/antlr/internal/InternalEbnf.g:1405:1: (lv_termGroupedSequence_1_0= ruleGroupedSequence )
+ {
+ // ../de.ugoe.cs.swe.bnftools.ebnf/src-gen/de/ugoe/cs/swe/bnftools/parser/antlr/internal/InternalEbnf.g:1405:1: (lv_termGroupedSequence_1_0= ruleGroupedSequence )
+ // ../de.ugoe.cs.swe.bnftools.ebnf/src-gen/de/ugoe/cs/swe/bnftools/parser/antlr/internal/InternalEbnf.g:1406:3: lv_termGroupedSequence_1_0= ruleGroupedSequence
+ {
+
+ newCompositeNode(grammarAccess.getTermAccess().getTermGroupedSequenceGroupedSequenceParserRuleCall_1_0());
+
+ pushFollow(FOLLOW_ruleGroupedSequence_in_ruleTerm2968);
+ lv_termGroupedSequence_1_0=ruleGroupedSequence();
+
+ state._fsp--;
+
+
+ if (current==null) {
+ current = createModelElementForParent(grammarAccess.getTermRule());
+ }
+ set(
+ current,
+ "termGroupedSequence",
+ lv_termGroupedSequence_1_0,
+ "GroupedSequence");
+ afterParserOrEnumRuleCall();
+
+
+ }
+
+
+ }
+
+
+ }
+ break;
+ case 3 :
+ // ../de.ugoe.cs.swe.bnftools.ebnf/src-gen/de/ugoe/cs/swe/bnftools/parser/antlr/internal/InternalEbnf.g:1423:6: ( (lv_termOptionalSequence_2_0= ruleOptionalSequence ) )
+ {
+ // ../de.ugoe.cs.swe.bnftools.ebnf/src-gen/de/ugoe/cs/swe/bnftools/parser/antlr/internal/InternalEbnf.g:1423:6: ( (lv_termOptionalSequence_2_0= ruleOptionalSequence ) )
+ // ../de.ugoe.cs.swe.bnftools.ebnf/src-gen/de/ugoe/cs/swe/bnftools/parser/antlr/internal/InternalEbnf.g:1424:1: (lv_termOptionalSequence_2_0= ruleOptionalSequence )
+ {
+ // ../de.ugoe.cs.swe.bnftools.ebnf/src-gen/de/ugoe/cs/swe/bnftools/parser/antlr/internal/InternalEbnf.g:1424:1: (lv_termOptionalSequence_2_0= ruleOptionalSequence )
+ // ../de.ugoe.cs.swe.bnftools.ebnf/src-gen/de/ugoe/cs/swe/bnftools/parser/antlr/internal/InternalEbnf.g:1425:3: lv_termOptionalSequence_2_0= ruleOptionalSequence
+ {
+
+ newCompositeNode(grammarAccess.getTermAccess().getTermOptionalSequenceOptionalSequenceParserRuleCall_2_0());
+
+ pushFollow(FOLLOW_ruleOptionalSequence_in_ruleTerm2995);
+ lv_termOptionalSequence_2_0=ruleOptionalSequence();
+
+ state._fsp--;
+
+
+ if (current==null) {
+ current = createModelElementForParent(grammarAccess.getTermRule());
+ }
+ set(
+ current,
+ "termOptionalSequence",
+ lv_termOptionalSequence_2_0,
+ "OptionalSequence");
+ afterParserOrEnumRuleCall();
+
+
+ }
+
+
+ }
+
+
+ }
+ break;
+ case 4 :
+ // ../de.ugoe.cs.swe.bnftools.ebnf/src-gen/de/ugoe/cs/swe/bnftools/parser/antlr/internal/InternalEbnf.g:1442:6: ( (lv_termRepeatedSequence_3_0= ruleRepeatedSequence ) )
+ {
+ // ../de.ugoe.cs.swe.bnftools.ebnf/src-gen/de/ugoe/cs/swe/bnftools/parser/antlr/internal/InternalEbnf.g:1442:6: ( (lv_termRepeatedSequence_3_0= ruleRepeatedSequence ) )
+ // ../de.ugoe.cs.swe.bnftools.ebnf/src-gen/de/ugoe/cs/swe/bnftools/parser/antlr/internal/InternalEbnf.g:1443:1: (lv_termRepeatedSequence_3_0= ruleRepeatedSequence )
+ {
+ // ../de.ugoe.cs.swe.bnftools.ebnf/src-gen/de/ugoe/cs/swe/bnftools/parser/antlr/internal/InternalEbnf.g:1443:1: (lv_termRepeatedSequence_3_0= ruleRepeatedSequence )
+ // ../de.ugoe.cs.swe.bnftools.ebnf/src-gen/de/ugoe/cs/swe/bnftools/parser/antlr/internal/InternalEbnf.g:1444:3: lv_termRepeatedSequence_3_0= ruleRepeatedSequence
+ {
+
+ newCompositeNode(grammarAccess.getTermAccess().getTermRepeatedSequenceRepeatedSequenceParserRuleCall_3_0());
+
+ pushFollow(FOLLOW_ruleRepeatedSequence_in_ruleTerm3022);
+ lv_termRepeatedSequence_3_0=ruleRepeatedSequence();
+
+ state._fsp--;
+
+
+ if (current==null) {
+ current = createModelElementForParent(grammarAccess.getTermRule());
+ }
+ set(
+ current,
+ "termRepeatedSequence",
+ lv_termRepeatedSequence_3_0,
+ "RepeatedSequence");
+ afterParserOrEnumRuleCall();
+
+
+ }
+
+
+ }
+
+
+ }
+ break;
+
+ }
+
+
+ }
+
+ leaveRule();
+ }
+
+ catch (RecognitionException re) {
+ recover(input,re);
+ appendSkippedTokens();
+ }
+ finally {
+ }
+ return current;
+ }
+ // $ANTLR end "ruleTerm"
+
+
+ // $ANTLR start "entryRuleAtom"
+ // ../de.ugoe.cs.swe.bnftools.ebnf/src-gen/de/ugoe/cs/swe/bnftools/parser/antlr/internal/InternalEbnf.g:1468:1: entryRuleAtom returns [EObject current=null] : iv_ruleAtom= ruleAtom EOF ;
+ public final EObject entryRuleAtom() throws RecognitionException {
+ EObject current = null;
+
+ EObject iv_ruleAtom = null;
+
+
+ try {
+ // ../de.ugoe.cs.swe.bnftools.ebnf/src-gen/de/ugoe/cs/swe/bnftools/parser/antlr/internal/InternalEbnf.g:1469:2: (iv_ruleAtom= ruleAtom EOF )
+ // ../de.ugoe.cs.swe.bnftools.ebnf/src-gen/de/ugoe/cs/swe/bnftools/parser/antlr/internal/InternalEbnf.g:1470:2: iv_ruleAtom= ruleAtom EOF
+ {
+ newCompositeNode(grammarAccess.getAtomRule());
+ pushFollow(FOLLOW_ruleAtom_in_entryRuleAtom3058);
+ iv_ruleAtom=ruleAtom();
+
+ state._fsp--;
+
+ current =iv_ruleAtom;
+ match(input,EOF,FOLLOW_EOF_in_entryRuleAtom3068);
+
+ }
+
+ }
+
+ catch (RecognitionException re) {
+ recover(input,re);
+ appendSkippedTokens();
+ }
+ finally {
+ }
+ return current;
+ }
+ // $ANTLR end "entryRuleAtom"
+
+
+ // $ANTLR start "ruleAtom"
+ // ../de.ugoe.cs.swe.bnftools.ebnf/src-gen/de/ugoe/cs/swe/bnftools/parser/antlr/internal/InternalEbnf.g:1477:1: ruleAtom returns [EObject current=null] : ( ( (lv_atomStringRule_0_0= ruleStringRule ) ) | ( (lv_atomRuleReference_1_0= ruleRuleReference ) ) ) ;
+ public final EObject ruleAtom() throws RecognitionException {
+ EObject current = null;
+
+ EObject lv_atomStringRule_0_0 = null;
+
+ EObject lv_atomRuleReference_1_0 = null;
+
+
+ enterRule();
+
+ try {
+ // ../de.ugoe.cs.swe.bnftools.ebnf/src-gen/de/ugoe/cs/swe/bnftools/parser/antlr/internal/InternalEbnf.g:1480:28: ( ( ( (lv_atomStringRule_0_0= ruleStringRule ) ) | ( (lv_atomRuleReference_1_0= ruleRuleReference ) ) ) )
+ // ../de.ugoe.cs.swe.bnftools.ebnf/src-gen/de/ugoe/cs/swe/bnftools/parser/antlr/internal/InternalEbnf.g:1481:1: ( ( (lv_atomStringRule_0_0= ruleStringRule ) ) | ( (lv_atomRuleReference_1_0= ruleRuleReference ) ) )
+ {
+ // ../de.ugoe.cs.swe.bnftools.ebnf/src-gen/de/ugoe/cs/swe/bnftools/parser/antlr/internal/InternalEbnf.g:1481:1: ( ( (lv_atomStringRule_0_0= ruleStringRule ) ) | ( (lv_atomRuleReference_1_0= ruleRuleReference ) ) )
+ int alt34=2;
+ int LA34_0 = input.LA(1);
+
+ if ( (LA34_0==RULE_STRING||LA34_0==RULE_COLON) ) {
+ alt34=1;
+ }
+ else if ( (LA34_0==RULE_ID) ) {
+ alt34=2;
+ }
+ else {
+ NoViableAltException nvae =
+ new NoViableAltException("", 34, 0, input);
+
+ throw nvae;
+ }
+ switch (alt34) {
+ case 1 :
+ // ../de.ugoe.cs.swe.bnftools.ebnf/src-gen/de/ugoe/cs/swe/bnftools/parser/antlr/internal/InternalEbnf.g:1481:2: ( (lv_atomStringRule_0_0= ruleStringRule ) )
+ {
+ // ../de.ugoe.cs.swe.bnftools.ebnf/src-gen/de/ugoe/cs/swe/bnftools/parser/antlr/internal/InternalEbnf.g:1481:2: ( (lv_atomStringRule_0_0= ruleStringRule ) )
+ // ../de.ugoe.cs.swe.bnftools.ebnf/src-gen/de/ugoe/cs/swe/bnftools/parser/antlr/internal/InternalEbnf.g:1482:1: (lv_atomStringRule_0_0= ruleStringRule )
+ {
+ // ../de.ugoe.cs.swe.bnftools.ebnf/src-gen/de/ugoe/cs/swe/bnftools/parser/antlr/internal/InternalEbnf.g:1482:1: (lv_atomStringRule_0_0= ruleStringRule )
+ // ../de.ugoe.cs.swe.bnftools.ebnf/src-gen/de/ugoe/cs/swe/bnftools/parser/antlr/internal/InternalEbnf.g:1483:3: lv_atomStringRule_0_0= ruleStringRule
+ {
+
+ newCompositeNode(grammarAccess.getAtomAccess().getAtomStringRuleStringRuleParserRuleCall_0_0());
+
+ pushFollow(FOLLOW_ruleStringRule_in_ruleAtom3114);
+ lv_atomStringRule_0_0=ruleStringRule();
+
+ state._fsp--;
+
+
+ if (current==null) {
+ current = createModelElementForParent(grammarAccess.getAtomRule());
+ }
+ set(
+ current,
+ "atomStringRule",
+ lv_atomStringRule_0_0,
+ "StringRule");
+ afterParserOrEnumRuleCall();
+
+
+ }
+
+
+ }
+
+
+ }
+ break;
+ case 2 :
+ // ../de.ugoe.cs.swe.bnftools.ebnf/src-gen/de/ugoe/cs/swe/bnftools/parser/antlr/internal/InternalEbnf.g:1500:6: ( (lv_atomRuleReference_1_0= ruleRuleReference ) )
+ {
+ // ../de.ugoe.cs.swe.bnftools.ebnf/src-gen/de/ugoe/cs/swe/bnftools/parser/antlr/internal/InternalEbnf.g:1500:6: ( (lv_atomRuleReference_1_0= ruleRuleReference ) )
+ // ../de.ugoe.cs.swe.bnftools.ebnf/src-gen/de/ugoe/cs/swe/bnftools/parser/antlr/internal/InternalEbnf.g:1501:1: (lv_atomRuleReference_1_0= ruleRuleReference )
+ {
+ // ../de.ugoe.cs.swe.bnftools.ebnf/src-gen/de/ugoe/cs/swe/bnftools/parser/antlr/internal/InternalEbnf.g:1501:1: (lv_atomRuleReference_1_0= ruleRuleReference )
+ // ../de.ugoe.cs.swe.bnftools.ebnf/src-gen/de/ugoe/cs/swe/bnftools/parser/antlr/internal/InternalEbnf.g:1502:3: lv_atomRuleReference_1_0= ruleRuleReference
+ {
+
+ newCompositeNode(grammarAccess.getAtomAccess().getAtomRuleReferenceRuleReferenceParserRuleCall_1_0());
+
+ pushFollow(FOLLOW_ruleRuleReference_in_ruleAtom3141);
+ lv_atomRuleReference_1_0=ruleRuleReference();
+
+ state._fsp--;
+
+
+ if (current==null) {
+ current = createModelElementForParent(grammarAccess.getAtomRule());
+ }
+ set(
+ current,
+ "atomRuleReference",
+ lv_atomRuleReference_1_0,
+ "RuleReference");
+ afterParserOrEnumRuleCall();
+
+
+ }
+
+
+ }
+
+
+ }
+ break;
+
+ }
+
+
+ }
+
+ leaveRule();
+ }
+
+ catch (RecognitionException re) {
+ recover(input,re);
+ appendSkippedTokens();
+ }
+ finally {
+ }
+ return current;
+ }
+ // $ANTLR end "ruleAtom"
+
+
+ // $ANTLR start "entryRuleRuleReference"
+ // ../de.ugoe.cs.swe.bnftools.ebnf/src-gen/de/ugoe/cs/swe/bnftools/parser/antlr/internal/InternalEbnf.g:1526:1: entryRuleRuleReference returns [EObject current=null] : iv_ruleRuleReference= ruleRuleReference EOF ;
+ public final EObject entryRuleRuleReference() throws RecognitionException {
+ EObject current = null;
+
+ EObject iv_ruleRuleReference = null;
+
+
+ try {
+ // ../de.ugoe.cs.swe.bnftools.ebnf/src-gen/de/ugoe/cs/swe/bnftools/parser/antlr/internal/InternalEbnf.g:1527:2: (iv_ruleRuleReference= ruleRuleReference EOF )
+ // ../de.ugoe.cs.swe.bnftools.ebnf/src-gen/de/ugoe/cs/swe/bnftools/parser/antlr/internal/InternalEbnf.g:1528:2: iv_ruleRuleReference= ruleRuleReference EOF
+ {
+ newCompositeNode(grammarAccess.getRuleReferenceRule());
+ pushFollow(FOLLOW_ruleRuleReference_in_entryRuleRuleReference3177);
+ iv_ruleRuleReference=ruleRuleReference();
+
+ state._fsp--;
+
+ current =iv_ruleRuleReference;
+ match(input,EOF,FOLLOW_EOF_in_entryRuleRuleReference3187);
+
+ }
+
+ }
+
+ catch (RecognitionException re) {
+ recover(input,re);
+ appendSkippedTokens();
+ }
+ finally {
+ }
+ return current;
+ }
+ // $ANTLR end "entryRuleRuleReference"
+
+
+ // $ANTLR start "ruleRuleReference"
+ // ../de.ugoe.cs.swe.bnftools.ebnf/src-gen/de/ugoe/cs/swe/bnftools/parser/antlr/internal/InternalEbnf.g:1535:1: ruleRuleReference returns [EObject current=null] : ( (otherlv_0= RULE_ID ) ) ;
+ public final EObject ruleRuleReference() throws RecognitionException {
+ EObject current = null;
+
+ Token otherlv_0=null;
+
+ enterRule();
+
+ try {
+ // ../de.ugoe.cs.swe.bnftools.ebnf/src-gen/de/ugoe/cs/swe/bnftools/parser/antlr/internal/InternalEbnf.g:1538:28: ( ( (otherlv_0= RULE_ID ) ) )
+ // ../de.ugoe.cs.swe.bnftools.ebnf/src-gen/de/ugoe/cs/swe/bnftools/parser/antlr/internal/InternalEbnf.g:1539:1: ( (otherlv_0= RULE_ID ) )
+ {
+ // ../de.ugoe.cs.swe.bnftools.ebnf/src-gen/de/ugoe/cs/swe/bnftools/parser/antlr/internal/InternalEbnf.g:1539:1: ( (otherlv_0= RULE_ID ) )
+ // ../de.ugoe.cs.swe.bnftools.ebnf/src-gen/de/ugoe/cs/swe/bnftools/parser/antlr/internal/InternalEbnf.g:1540:1: (otherlv_0= RULE_ID )
+ {
+ // ../de.ugoe.cs.swe.bnftools.ebnf/src-gen/de/ugoe/cs/swe/bnftools/parser/antlr/internal/InternalEbnf.g:1540:1: (otherlv_0= RULE_ID )
+ // ../de.ugoe.cs.swe.bnftools.ebnf/src-gen/de/ugoe/cs/swe/bnftools/parser/antlr/internal/InternalEbnf.g:1541:3: otherlv_0= RULE_ID
+ {
+
+ if (current==null) {
+ current = createModelElement(grammarAccess.getRuleReferenceRule());
+ }
+
+ otherlv_0=(Token)match(input,RULE_ID,FOLLOW_RULE_ID_in_ruleRuleReference3231);
+
+ newLeafNode(otherlv_0, grammarAccess.getRuleReferenceAccess().getRulerefRuleCrossReference_0());
+
+
+ }
+
+
+ }
+
+
+ }
+
+ leaveRule();
+ }
+
+ catch (RecognitionException re) {
+ recover(input,re);
+ appendSkippedTokens();
+ }
+ finally {
+ }
+ return current;
+ }
+ // $ANTLR end "ruleRuleReference"
+
+
+ // $ANTLR start "entryRuleStringRule"
+ // ../de.ugoe.cs.swe.bnftools.ebnf/src-gen/de/ugoe/cs/swe/bnftools/parser/antlr/internal/InternalEbnf.g:1560:1: entryRuleStringRule returns [EObject current=null] : iv_ruleStringRule= ruleStringRule EOF ;
+ public final EObject entryRuleStringRule() throws RecognitionException {
+ EObject current = null;
+
+ EObject iv_ruleStringRule = null;
+
+
+ try {
+ // ../de.ugoe.cs.swe.bnftools.ebnf/src-gen/de/ugoe/cs/swe/bnftools/parser/antlr/internal/InternalEbnf.g:1561:2: (iv_ruleStringRule= ruleStringRule EOF )
+ // ../de.ugoe.cs.swe.bnftools.ebnf/src-gen/de/ugoe/cs/swe/bnftools/parser/antlr/internal/InternalEbnf.g:1562:2: iv_ruleStringRule= ruleStringRule EOF
+ {
+ newCompositeNode(grammarAccess.getStringRuleRule());
+ pushFollow(FOLLOW_ruleStringRule_in_entryRuleStringRule3266);
+ iv_ruleStringRule=ruleStringRule();
+
+ state._fsp--;
+
+ current =iv_ruleStringRule;
+ match(input,EOF,FOLLOW_EOF_in_entryRuleStringRule3276);
+
+ }
+
+ }
+
+ catch (RecognitionException re) {
+ recover(input,re);
+ appendSkippedTokens();
+ }
+ finally {
+ }
+ return current;
+ }
+ // $ANTLR end "entryRuleStringRule"
+
+
+ // $ANTLR start "ruleStringRule"
+ // ../de.ugoe.cs.swe.bnftools.ebnf/src-gen/de/ugoe/cs/swe/bnftools/parser/antlr/internal/InternalEbnf.g:1569:1: ruleStringRule returns [EObject current=null] : ( ( (lv_literal_0_0= RULE_STRING ) ) | ( (lv_colon_1_0= RULE_COLON ) ) ) ;
+ public final EObject ruleStringRule() throws RecognitionException {
+ EObject current = null;
+
+ Token lv_literal_0_0=null;
+ Token lv_colon_1_0=null;
+
+ enterRule();
+
+ try {
+ // ../de.ugoe.cs.swe.bnftools.ebnf/src-gen/de/ugoe/cs/swe/bnftools/parser/antlr/internal/InternalEbnf.g:1572:28: ( ( ( (lv_literal_0_0= RULE_STRING ) ) | ( (lv_colon_1_0= RULE_COLON ) ) ) )
+ // ../de.ugoe.cs.swe.bnftools.ebnf/src-gen/de/ugoe/cs/swe/bnftools/parser/antlr/internal/InternalEbnf.g:1573:1: ( ( (lv_literal_0_0= RULE_STRING ) ) | ( (lv_colon_1_0= RULE_COLON ) ) )
+ {
+ // ../de.ugoe.cs.swe.bnftools.ebnf/src-gen/de/ugoe/cs/swe/bnftools/parser/antlr/internal/InternalEbnf.g:1573:1: ( ( (lv_literal_0_0= RULE_STRING ) ) | ( (lv_colon_1_0= RULE_COLON ) ) )
+ int alt35=2;
+ int LA35_0 = input.LA(1);
+
+ if ( (LA35_0==RULE_STRING) ) {
+ alt35=1;
+ }
+ else if ( (LA35_0==RULE_COLON) ) {
+ alt35=2;
+ }
+ else {
+ NoViableAltException nvae =
+ new NoViableAltException("", 35, 0, input);
+
+ throw nvae;
+ }
+ switch (alt35) {
+ case 1 :
+ // ../de.ugoe.cs.swe.bnftools.ebnf/src-gen/de/ugoe/cs/swe/bnftools/parser/antlr/internal/InternalEbnf.g:1573:2: ( (lv_literal_0_0= RULE_STRING ) )
+ {
+ // ../de.ugoe.cs.swe.bnftools.ebnf/src-gen/de/ugoe/cs/swe/bnftools/parser/antlr/internal/InternalEbnf.g:1573:2: ( (lv_literal_0_0= RULE_STRING ) )
+ // ../de.ugoe.cs.swe.bnftools.ebnf/src-gen/de/ugoe/cs/swe/bnftools/parser/antlr/internal/InternalEbnf.g:1574:1: (lv_literal_0_0= RULE_STRING )
+ {
+ // ../de.ugoe.cs.swe.bnftools.ebnf/src-gen/de/ugoe/cs/swe/bnftools/parser/antlr/internal/InternalEbnf.g:1574:1: (lv_literal_0_0= RULE_STRING )
+ // ../de.ugoe.cs.swe.bnftools.ebnf/src-gen/de/ugoe/cs/swe/bnftools/parser/antlr/internal/InternalEbnf.g:1575:3: lv_literal_0_0= RULE_STRING
+ {
+ lv_literal_0_0=(Token)match(input,RULE_STRING,FOLLOW_RULE_STRING_in_ruleStringRule3318);
+
+ newLeafNode(lv_literal_0_0, grammarAccess.getStringRuleAccess().getLiteralSTRINGTerminalRuleCall_0_0());
+
+
+ if (current==null) {
+ current = createModelElement(grammarAccess.getStringRuleRule());
+ }
+ setWithLastConsumed(
+ current,
+ "literal",
+ lv_literal_0_0,
+ "STRING");
+
+
+ }
+
+
+ }
+
+
+ }
+ break;
+ case 2 :
+ // ../de.ugoe.cs.swe.bnftools.ebnf/src-gen/de/ugoe/cs/swe/bnftools/parser/antlr/internal/InternalEbnf.g:1592:6: ( (lv_colon_1_0= RULE_COLON ) )
+ {
+ // ../de.ugoe.cs.swe.bnftools.ebnf/src-gen/de/ugoe/cs/swe/bnftools/parser/antlr/internal/InternalEbnf.g:1592:6: ( (lv_colon_1_0= RULE_COLON ) )
+ // ../de.ugoe.cs.swe.bnftools.ebnf/src-gen/de/ugoe/cs/swe/bnftools/parser/antlr/internal/InternalEbnf.g:1593:1: (lv_colon_1_0= RULE_COLON )
+ {
+ // ../de.ugoe.cs.swe.bnftools.ebnf/src-gen/de/ugoe/cs/swe/bnftools/parser/antlr/internal/InternalEbnf.g:1593:1: (lv_colon_1_0= RULE_COLON )
+ // ../de.ugoe.cs.swe.bnftools.ebnf/src-gen/de/ugoe/cs/swe/bnftools/parser/antlr/internal/InternalEbnf.g:1594:3: lv_colon_1_0= RULE_COLON
+ {
+ lv_colon_1_0=(Token)match(input,RULE_COLON,FOLLOW_RULE_COLON_in_ruleStringRule3346);
+
+ newLeafNode(lv_colon_1_0, grammarAccess.getStringRuleAccess().getColonCOLONTerminalRuleCall_1_0());
+
+
+ if (current==null) {
+ current = createModelElement(grammarAccess.getStringRuleRule());
+ }
+ setWithLastConsumed(
+ current,
+ "colon",
+ lv_colon_1_0,
+ "COLON");
+
+
+ }
+
+
+ }
+
+
+ }
+ break;
+
+ }
+
+
+ }
+
+ leaveRule();
+ }
+
+ catch (RecognitionException re) {
+ recover(input,re);
+ appendSkippedTokens();
+ }
+ finally {
+ }
+ return current;
+ }
+ // $ANTLR end "ruleStringRule"
+
+
+ // $ANTLR start "entryRuleGroupedSequence"
+ // ../de.ugoe.cs.swe.bnftools.ebnf/src-gen/de/ugoe/cs/swe/bnftools/parser/antlr/internal/InternalEbnf.g:1618:1: entryRuleGroupedSequence returns [EObject current=null] : iv_ruleGroupedSequence= ruleGroupedSequence EOF ;
+ public final EObject entryRuleGroupedSequence() throws RecognitionException {
+ EObject current = null;
+
+ EObject iv_ruleGroupedSequence = null;
+
+
+ try {
+ // ../de.ugoe.cs.swe.bnftools.ebnf/src-gen/de/ugoe/cs/swe/bnftools/parser/antlr/internal/InternalEbnf.g:1619:2: (iv_ruleGroupedSequence= ruleGroupedSequence EOF )
+ // ../de.ugoe.cs.swe.bnftools.ebnf/src-gen/de/ugoe/cs/swe/bnftools/parser/antlr/internal/InternalEbnf.g:1620:2: iv_ruleGroupedSequence= ruleGroupedSequence EOF
+ {
+ newCompositeNode(grammarAccess.getGroupedSequenceRule());
+ pushFollow(FOLLOW_ruleGroupedSequence_in_entryRuleGroupedSequence3387);
+ iv_ruleGroupedSequence=ruleGroupedSequence();
+
+ state._fsp--;
+
+ current =iv_ruleGroupedSequence;
+ match(input,EOF,FOLLOW_EOF_in_entryRuleGroupedSequence3397);
+
+ }
+
+ }
+
+ catch (RecognitionException re) {
+ recover(input,re);
+ appendSkippedTokens();
+ }
+ finally {
+ }
+ return current;
+ }
+ // $ANTLR end "entryRuleGroupedSequence"
+
+
+ // $ANTLR start "ruleGroupedSequence"
+ // ../de.ugoe.cs.swe.bnftools.ebnf/src-gen/de/ugoe/cs/swe/bnftools/parser/antlr/internal/InternalEbnf.g:1627:1: ruleGroupedSequence returns [EObject current=null] : (otherlv_0= '(' ( (lv_definitionList_1_0= ruleDefinitionList ) ) otherlv_2= ')' ) ;
+ public final EObject ruleGroupedSequence() throws RecognitionException {
+ EObject current = null;
+
+ Token otherlv_0=null;
+ Token otherlv_2=null;
+ EObject lv_definitionList_1_0 = null;
+
+
+ enterRule();
+
+ try {
+ // ../de.ugoe.cs.swe.bnftools.ebnf/src-gen/de/ugoe/cs/swe/bnftools/parser/antlr/internal/InternalEbnf.g:1630:28: ( (otherlv_0= '(' ( (lv_definitionList_1_0= ruleDefinitionList ) ) otherlv_2= ')' ) )
+ // ../de.ugoe.cs.swe.bnftools.ebnf/src-gen/de/ugoe/cs/swe/bnftools/parser/antlr/internal/InternalEbnf.g:1631:1: (otherlv_0= '(' ( (lv_definitionList_1_0= ruleDefinitionList ) ) otherlv_2= ')' )
+ {
+ // ../de.ugoe.cs.swe.bnftools.ebnf/src-gen/de/ugoe/cs/swe/bnftools/parser/antlr/internal/InternalEbnf.g:1631:1: (otherlv_0= '(' ( (lv_definitionList_1_0= ruleDefinitionList ) ) otherlv_2= ')' )
+ // ../de.ugoe.cs.swe.bnftools.ebnf/src-gen/de/ugoe/cs/swe/bnftools/parser/antlr/internal/InternalEbnf.g:1631:3: otherlv_0= '(' ( (lv_definitionList_1_0= ruleDefinitionList ) ) otherlv_2= ')'
+ {
+ otherlv_0=(Token)match(input,26,FOLLOW_26_in_ruleGroupedSequence3434);
+
+ newLeafNode(otherlv_0, grammarAccess.getGroupedSequenceAccess().getLeftParenthesisKeyword_0());
+
+ // ../de.ugoe.cs.swe.bnftools.ebnf/src-gen/de/ugoe/cs/swe/bnftools/parser/antlr/internal/InternalEbnf.g:1635:1: ( (lv_definitionList_1_0= ruleDefinitionList ) )
+ // ../de.ugoe.cs.swe.bnftools.ebnf/src-gen/de/ugoe/cs/swe/bnftools/parser/antlr/internal/InternalEbnf.g:1636:1: (lv_definitionList_1_0= ruleDefinitionList )
+ {
+ // ../de.ugoe.cs.swe.bnftools.ebnf/src-gen/de/ugoe/cs/swe/bnftools/parser/antlr/internal/InternalEbnf.g:1636:1: (lv_definitionList_1_0= ruleDefinitionList )
+ // ../de.ugoe.cs.swe.bnftools.ebnf/src-gen/de/ugoe/cs/swe/bnftools/parser/antlr/internal/InternalEbnf.g:1637:3: lv_definitionList_1_0= ruleDefinitionList
+ {
+
+ newCompositeNode(grammarAccess.getGroupedSequenceAccess().getDefinitionListDefinitionListParserRuleCall_1_0());
+
+ pushFollow(FOLLOW_ruleDefinitionList_in_ruleGroupedSequence3455);
+ lv_definitionList_1_0=ruleDefinitionList();
+
+ state._fsp--;
+
+
+ if (current==null) {
+ current = createModelElementForParent(grammarAccess.getGroupedSequenceRule());
+ }
+ add(
+ current,
+ "definitionList",
+ lv_definitionList_1_0,
+ "DefinitionList");
+ afterParserOrEnumRuleCall();
+
+
+ }
+
+
+ }
+
+ otherlv_2=(Token)match(input,27,FOLLOW_27_in_ruleGroupedSequence3467);
+
+ newLeafNode(otherlv_2, grammarAccess.getGroupedSequenceAccess().getRightParenthesisKeyword_2());
+
+
+ }
+
+
+ }
+
+ leaveRule();
+ }
+
+ catch (RecognitionException re) {
+ recover(input,re);
+ appendSkippedTokens();
+ }
+ finally {
+ }
+ return current;
+ }
+ // $ANTLR end "ruleGroupedSequence"
+
+
+ // $ANTLR start "entryRuleOptionalSequence"
+ // ../de.ugoe.cs.swe.bnftools.ebnf/src-gen/de/ugoe/cs/swe/bnftools/parser/antlr/internal/InternalEbnf.g:1665:1: entryRuleOptionalSequence returns [EObject current=null] : iv_ruleOptionalSequence= ruleOptionalSequence EOF ;
+ public final EObject entryRuleOptionalSequence() throws RecognitionException {
+ EObject current = null;
+
+ EObject iv_ruleOptionalSequence = null;
+
+
+ try {
+ // ../de.ugoe.cs.swe.bnftools.ebnf/src-gen/de/ugoe/cs/swe/bnftools/parser/antlr/internal/InternalEbnf.g:1666:2: (iv_ruleOptionalSequence= ruleOptionalSequence EOF )
+ // ../de.ugoe.cs.swe.bnftools.ebnf/src-gen/de/ugoe/cs/swe/bnftools/parser/antlr/internal/InternalEbnf.g:1667:2: iv_ruleOptionalSequence= ruleOptionalSequence EOF
+ {
+ newCompositeNode(grammarAccess.getOptionalSequenceRule());
+ pushFollow(FOLLOW_ruleOptionalSequence_in_entryRuleOptionalSequence3503);
+ iv_ruleOptionalSequence=ruleOptionalSequence();
+
+ state._fsp--;
+
+ current =iv_ruleOptionalSequence;
+ match(input,EOF,FOLLOW_EOF_in_entryRuleOptionalSequence3513);
+
+ }
+
+ }
+
+ catch (RecognitionException re) {
+ recover(input,re);
+ appendSkippedTokens();
+ }
+ finally {
+ }
+ return current;
+ }
+ // $ANTLR end "entryRuleOptionalSequence"
+
+
+ // $ANTLR start "ruleOptionalSequence"
+ // ../de.ugoe.cs.swe.bnftools.ebnf/src-gen/de/ugoe/cs/swe/bnftools/parser/antlr/internal/InternalEbnf.g:1674:1: ruleOptionalSequence returns [EObject current=null] : (otherlv_0= '[' ( (lv_definitionList_1_0= ruleDefinitionList ) ) otherlv_2= ']' ) ;
+ public final EObject ruleOptionalSequence() throws RecognitionException {
+ EObject current = null;
+
+ Token otherlv_0=null;
+ Token otherlv_2=null;
+ EObject lv_definitionList_1_0 = null;
+
+
+ enterRule();
+
+ try {
+ // ../de.ugoe.cs.swe.bnftools.ebnf/src-gen/de/ugoe/cs/swe/bnftools/parser/antlr/internal/InternalEbnf.g:1677:28: ( (otherlv_0= '[' ( (lv_definitionList_1_0= ruleDefinitionList ) ) otherlv_2= ']' ) )
+ // ../de.ugoe.cs.swe.bnftools.ebnf/src-gen/de/ugoe/cs/swe/bnftools/parser/antlr/internal/InternalEbnf.g:1678:1: (otherlv_0= '[' ( (lv_definitionList_1_0= ruleDefinitionList ) ) otherlv_2= ']' )
+ {
+ // ../de.ugoe.cs.swe.bnftools.ebnf/src-gen/de/ugoe/cs/swe/bnftools/parser/antlr/internal/InternalEbnf.g:1678:1: (otherlv_0= '[' ( (lv_definitionList_1_0= ruleDefinitionList ) ) otherlv_2= ']' )
+ // ../de.ugoe.cs.swe.bnftools.ebnf/src-gen/de/ugoe/cs/swe/bnftools/parser/antlr/internal/InternalEbnf.g:1678:3: otherlv_0= '[' ( (lv_definitionList_1_0= ruleDefinitionList ) ) otherlv_2= ']'
+ {
+ otherlv_0=(Token)match(input,32,FOLLOW_32_in_ruleOptionalSequence3550);
+
+ newLeafNode(otherlv_0, grammarAccess.getOptionalSequenceAccess().getLeftSquareBracketKeyword_0());
+
+ // ../de.ugoe.cs.swe.bnftools.ebnf/src-gen/de/ugoe/cs/swe/bnftools/parser/antlr/internal/InternalEbnf.g:1682:1: ( (lv_definitionList_1_0= ruleDefinitionList ) )
+ // ../de.ugoe.cs.swe.bnftools.ebnf/src-gen/de/ugoe/cs/swe/bnftools/parser/antlr/internal/InternalEbnf.g:1683:1: (lv_definitionList_1_0= ruleDefinitionList )
+ {
+ // ../de.ugoe.cs.swe.bnftools.ebnf/src-gen/de/ugoe/cs/swe/bnftools/parser/antlr/internal/InternalEbnf.g:1683:1: (lv_definitionList_1_0= ruleDefinitionList )
+ // ../de.ugoe.cs.swe.bnftools.ebnf/src-gen/de/ugoe/cs/swe/bnftools/parser/antlr/internal/InternalEbnf.g:1684:3: lv_definitionList_1_0= ruleDefinitionList
+ {
+
+ newCompositeNode(grammarAccess.getOptionalSequenceAccess().getDefinitionListDefinitionListParserRuleCall_1_0());
+
+ pushFollow(FOLLOW_ruleDefinitionList_in_ruleOptionalSequence3571);
+ lv_definitionList_1_0=ruleDefinitionList();
+
+ state._fsp--;
+
+
+ if (current==null) {
+ current = createModelElementForParent(grammarAccess.getOptionalSequenceRule());
+ }
+ add(
+ current,
+ "definitionList",
+ lv_definitionList_1_0,
+ "DefinitionList");
+ afterParserOrEnumRuleCall();
+
+
+ }
+
+
+ }
+
+ otherlv_2=(Token)match(input,29,FOLLOW_29_in_ruleOptionalSequence3583);
+
+ newLeafNode(otherlv_2, grammarAccess.getOptionalSequenceAccess().getRightSquareBracketKeyword_2());
+
+
+ }
+
+
+ }
+
+ leaveRule();
+ }
+
+ catch (RecognitionException re) {
+ recover(input,re);
+ appendSkippedTokens();
+ }
+ finally {
+ }
+ return current;
+ }
+ // $ANTLR end "ruleOptionalSequence"
+
+
+ // $ANTLR start "entryRuleRepeatedSequence"
+ // ../de.ugoe.cs.swe.bnftools.ebnf/src-gen/de/ugoe/cs/swe/bnftools/parser/antlr/internal/InternalEbnf.g:1712:1: entryRuleRepeatedSequence returns [EObject current=null] : iv_ruleRepeatedSequence= ruleRepeatedSequence EOF ;
+ public final EObject entryRuleRepeatedSequence() throws RecognitionException {
+ EObject current = null;
+
+ EObject iv_ruleRepeatedSequence = null;
+
+
+ try {
+ // ../de.ugoe.cs.swe.bnftools.ebnf/src-gen/de/ugoe/cs/swe/bnftools/parser/antlr/internal/InternalEbnf.g:1713:2: (iv_ruleRepeatedSequence= ruleRepeatedSequence EOF )
+ // ../de.ugoe.cs.swe.bnftools.ebnf/src-gen/de/ugoe/cs/swe/bnftools/parser/antlr/internal/InternalEbnf.g:1714:2: iv_ruleRepeatedSequence= ruleRepeatedSequence EOF
+ {
+ newCompositeNode(grammarAccess.getRepeatedSequenceRule());
+ pushFollow(FOLLOW_ruleRepeatedSequence_in_entryRuleRepeatedSequence3619);
+ iv_ruleRepeatedSequence=ruleRepeatedSequence();
+
+ state._fsp--;
+
+ current =iv_ruleRepeatedSequence;
+ match(input,EOF,FOLLOW_EOF_in_entryRuleRepeatedSequence3629);
+
+ }
+
+ }
+
+ catch (RecognitionException re) {
+ recover(input,re);
+ appendSkippedTokens();
+ }
+ finally {
+ }
+ return current;
+ }
+ // $ANTLR end "entryRuleRepeatedSequence"
+
+
+ // $ANTLR start "ruleRepeatedSequence"
+ // ../de.ugoe.cs.swe.bnftools.ebnf/src-gen/de/ugoe/cs/swe/bnftools/parser/antlr/internal/InternalEbnf.g:1721:1: ruleRepeatedSequence returns [EObject current=null] : (otherlv_0= '{' ( (lv_definitions_1_0= ruleDefinitionList ) ) otherlv_2= '}' ( (lv_morethanonce_3_0= '+' ) )? ) ;
+ public final EObject ruleRepeatedSequence() throws RecognitionException {
+ EObject current = null;
+
+ Token otherlv_0=null;
+ Token otherlv_2=null;
+ Token lv_morethanonce_3_0=null;
+ EObject lv_definitions_1_0 = null;
+
+
+ enterRule();
+
+ try {
+ // ../de.ugoe.cs.swe.bnftools.ebnf/src-gen/de/ugoe/cs/swe/bnftools/parser/antlr/internal/InternalEbnf.g:1724:28: ( (otherlv_0= '{' ( (lv_definitions_1_0= ruleDefinitionList ) ) otherlv_2= '}' ( (lv_morethanonce_3_0= '+' ) )? ) )
+ // ../de.ugoe.cs.swe.bnftools.ebnf/src-gen/de/ugoe/cs/swe/bnftools/parser/antlr/internal/InternalEbnf.g:1725:1: (otherlv_0= '{' ( (lv_definitions_1_0= ruleDefinitionList ) ) otherlv_2= '}' ( (lv_morethanonce_3_0= '+' ) )? )
+ {
+ // ../de.ugoe.cs.swe.bnftools.ebnf/src-gen/de/ugoe/cs/swe/bnftools/parser/antlr/internal/InternalEbnf.g:1725:1: (otherlv_0= '{' ( (lv_definitions_1_0= ruleDefinitionList ) ) otherlv_2= '}' ( (lv_morethanonce_3_0= '+' ) )? )
+ // ../de.ugoe.cs.swe.bnftools.ebnf/src-gen/de/ugoe/cs/swe/bnftools/parser/antlr/internal/InternalEbnf.g:1725:3: otherlv_0= '{' ( (lv_definitions_1_0= ruleDefinitionList ) ) otherlv_2= '}' ( (lv_morethanonce_3_0= '+' ) )?
+ {
+ otherlv_0=(Token)match(input,33,FOLLOW_33_in_ruleRepeatedSequence3666);
+
+ newLeafNode(otherlv_0, grammarAccess.getRepeatedSequenceAccess().getLeftCurlyBracketKeyword_0());
+
+ // ../de.ugoe.cs.swe.bnftools.ebnf/src-gen/de/ugoe/cs/swe/bnftools/parser/antlr/internal/InternalEbnf.g:1729:1: ( (lv_definitions_1_0= ruleDefinitionList ) )
+ // ../de.ugoe.cs.swe.bnftools.ebnf/src-gen/de/ugoe/cs/swe/bnftools/parser/antlr/internal/InternalEbnf.g:1730:1: (lv_definitions_1_0= ruleDefinitionList )
+ {
+ // ../de.ugoe.cs.swe.bnftools.ebnf/src-gen/de/ugoe/cs/swe/bnftools/parser/antlr/internal/InternalEbnf.g:1730:1: (lv_definitions_1_0= ruleDefinitionList )
+ // ../de.ugoe.cs.swe.bnftools.ebnf/src-gen/de/ugoe/cs/swe/bnftools/parser/antlr/internal/InternalEbnf.g:1731:3: lv_definitions_1_0= ruleDefinitionList
+ {
+
+ newCompositeNode(grammarAccess.getRepeatedSequenceAccess().getDefinitionsDefinitionListParserRuleCall_1_0());
+
+ pushFollow(FOLLOW_ruleDefinitionList_in_ruleRepeatedSequence3687);
+ lv_definitions_1_0=ruleDefinitionList();
+
+ state._fsp--;
+
+
+ if (current==null) {
+ current = createModelElementForParent(grammarAccess.getRepeatedSequenceRule());
+ }
+ add(
+ current,
+ "definitions",
+ lv_definitions_1_0,
+ "DefinitionList");
+ afterParserOrEnumRuleCall();
+
+
+ }
+
+
+ }
+
+ otherlv_2=(Token)match(input,30,FOLLOW_30_in_ruleRepeatedSequence3699);
+
+ newLeafNode(otherlv_2, grammarAccess.getRepeatedSequenceAccess().getRightCurlyBracketKeyword_2());
+
+ // ../de.ugoe.cs.swe.bnftools.ebnf/src-gen/de/ugoe/cs/swe/bnftools/parser/antlr/internal/InternalEbnf.g:1751:1: ( (lv_morethanonce_3_0= '+' ) )?
+ int alt36=2;
+ int LA36_0 = input.LA(1);
+
+ if ( (LA36_0==35) ) {
+ alt36=1;
+ }
+ switch (alt36) {
+ case 1 :
+ // ../de.ugoe.cs.swe.bnftools.ebnf/src-gen/de/ugoe/cs/swe/bnftools/parser/antlr/internal/InternalEbnf.g:1752:1: (lv_morethanonce_3_0= '+' )
+ {
+ // ../de.ugoe.cs.swe.bnftools.ebnf/src-gen/de/ugoe/cs/swe/bnftools/parser/antlr/internal/InternalEbnf.g:1752:1: (lv_morethanonce_3_0= '+' )
+ // ../de.ugoe.cs.swe.bnftools.ebnf/src-gen/de/ugoe/cs/swe/bnftools/parser/antlr/internal/InternalEbnf.g:1753:3: lv_morethanonce_3_0= '+'
+ {
+ lv_morethanonce_3_0=(Token)match(input,35,FOLLOW_35_in_ruleRepeatedSequence3717);
+
+ newLeafNode(lv_morethanonce_3_0, grammarAccess.getRepeatedSequenceAccess().getMorethanoncePlusSignKeyword_3_0());
+
+
+ if (current==null) {
+ current = createModelElement(grammarAccess.getRepeatedSequenceRule());
+ }
+ setWithLastConsumed(current, "morethanonce", true, "+");
+
+
+ }
+
+
+ }
+ break;
+
+ }
+
+
+ }
+
+
+ }
+
+ leaveRule();
+ }
+
+ catch (RecognitionException re) {
+ recover(input,re);
+ appendSkippedTokens();
+ }
+ finally {
+ }
+ return current;
+ }
+ // $ANTLR end "ruleRepeatedSequence"
+
+ // Delegated rules
+
+
+ protected DFA22 dfa22 = new DFA22(this);
+ static final String DFA22_eotS =
+ "\17\uffff";
+ static final String DFA22_eofS =
+ "\1\1\1\uffff\1\3\12\uffff\1\3\1\uffff";
+ static final String DFA22_minS =
+ "\1\4\1\uffff\1\4\12\uffff\2\4";
+ static final String DFA22_maxS =
+ "\1\43\1\uffff\1\43\12\uffff\1\43\1\33";
+ static final String DFA22_acceptS =
+ "\1\uffff\1\13\1\uffff\1\1\1\2\1\3\1\4\1\5\1\6\1\7\1\10\1\11\1\12"+
+ "\2\uffff";
+ static final String DFA22_specialS =
+ "\17\uffff}>";
+ static final String[] DFA22_transitionS = {
+ "\1\2\1\1\1\3\1\1\1\uffff\1\3\5\uffff\1\1\12\uffff\1\10\1\4"+
+ "\1\uffff\1\5\1\6\1\7\1\11\1\12\1\13\1\14",
+ "",
+ "\4\3\1\uffff\1\3\5\uffff\1\3\11\uffff\1\1\1\15\1\3\1\uffff"+
+ "\7\3",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "\3\3\1\16\1\uffff\1\3\5\uffff\1\3\12\uffff\2\3\1\uffff\7\3",
+ "\1\3\23\uffff\1\3\2\uffff\1\1"
+ };
+
+ static final short[] DFA22_eot = DFA.unpackEncodedString(DFA22_eotS);
+ static final short[] DFA22_eof = DFA.unpackEncodedString(DFA22_eofS);
+ static final char[] DFA22_min = DFA.unpackEncodedStringToUnsignedChars(DFA22_minS);
+ static final char[] DFA22_max = DFA.unpackEncodedStringToUnsignedChars(DFA22_maxS);
+ static final short[] DFA22_accept = DFA.unpackEncodedString(DFA22_acceptS);
+ static final short[] DFA22_special = DFA.unpackEncodedString(DFA22_specialS);
+ static final short[][] DFA22_transition;
+
+ static {
+ int numStates = DFA22_transitionS.length;
+ DFA22_transition = new short[numStates][];
+ for (int i=0; i transitionNodes = collectNodes(fromNode, toNode);
+ for (AbstractElementAlias syntax : transition.getAmbiguousSyntaxes()) {
+ List syntaxNodes = getNodesFor(transitionNodes, syntax);
+ if(match_ExtRule_SemicolonKeyword_5_q.equals(syntax))
+ emit_ExtRule_SemicolonKeyword_5_q(semanticObject, getLastNavigableState(), syntaxNodes);
+ else if(match_ExtRule___AsteriskKeyword_4_8_or_LeftCurlyBracketKeyword_4_7_or_LeftParenthesisKeyword_4_5_or_LeftSquareBracketKeyword_4_6_or_PlusSignKeyword_4_9_or_RightCurlyBracketKeyword_4_3_or_RightParenthesisKeyword_4_1_or_RightSquareBracketKeyword_4_2_or_VerticalLineKeyword_4_4__a.equals(syntax))
+ emit_ExtRule___AsteriskKeyword_4_8_or_LeftCurlyBracketKeyword_4_7_or_LeftParenthesisKeyword_4_5_or_LeftSquareBracketKeyword_4_6_or_PlusSignKeyword_4_9_or_RightCurlyBracketKeyword_4_3_or_RightParenthesisKeyword_4_1_or_RightSquareBracketKeyword_4_2_or_VerticalLineKeyword_4_4__a(semanticObject, getLastNavigableState(), syntaxNodes);
+ else if(match_GlobalCombinator_SemicolonKeyword_2_q.equals(syntax))
+ emit_GlobalCombinator_SemicolonKeyword_2_q(semanticObject, getLastNavigableState(), syntaxNodes);
+ else if(match_HookCombinator_SemicolonKeyword_8_q.equals(syntax))
+ emit_HookCombinator_SemicolonKeyword_8_q(semanticObject, getLastNavigableState(), syntaxNodes);
+ else if(match_RuleCombinator_SemicolonKeyword_3_q.equals(syntax))
+ emit_RuleCombinator_SemicolonKeyword_3_q(semanticObject, getLastNavigableState(), syntaxNodes);
+ else if(match_Rule_SemicolonKeyword_4_q.equals(syntax))
+ emit_Rule_SemicolonKeyword_4_q(semanticObject, getLastNavigableState(), syntaxNodes);
+ else acceptNodes(getLastNavigableState(), syntaxNodes);
+ }
+ }
+
+ /**
+ * Syntax:
+ * ';'?
+ */
+ protected void emit_ExtRule_SemicolonKeyword_5_q(EObject semanticObject, ISynNavigable transition, List nodes) {
+ acceptNodes(transition, nodes);
+ }
+
+ /**
+ * Syntax:
+ * (
+ '{' |
+ '}' |
+ '|' |
+ '+' |
+ '*' |
+ '[' |
+ ']' |
+ '(' |
+ ')'
+ )*
+ */
+ protected void emit_ExtRule___AsteriskKeyword_4_8_or_LeftCurlyBracketKeyword_4_7_or_LeftParenthesisKeyword_4_5_or_LeftSquareBracketKeyword_4_6_or_PlusSignKeyword_4_9_or_RightCurlyBracketKeyword_4_3_or_RightParenthesisKeyword_4_1_or_RightSquareBracketKeyword_4_2_or_VerticalLineKeyword_4_4__a(EObject semanticObject, ISynNavigable transition, List nodes) {
+ acceptNodes(transition, nodes);
+ }
+
+ /**
+ * Syntax:
+ * ';'?
+ */
+ protected void emit_GlobalCombinator_SemicolonKeyword_2_q(EObject semanticObject, ISynNavigable transition, List nodes) {
+ acceptNodes(transition, nodes);
+ }
+
+ /**
+ * Syntax:
+ * ';'?
+ */
+ protected void emit_HookCombinator_SemicolonKeyword_8_q(EObject semanticObject, ISynNavigable transition, List nodes) {
+ acceptNodes(transition, nodes);
+ }
+
+ /**
+ * Syntax:
+ * ';'?
+ */
+ protected void emit_RuleCombinator_SemicolonKeyword_3_q(EObject semanticObject, ISynNavigable transition, List nodes) {
+ acceptNodes(transition, nodes);
+ }
+
+ /**
+ * Syntax:
+ * ';'?
+ */
+ protected void emit_Rule_SemicolonKeyword_4_q(EObject semanticObject, ISynNavigable transition, List nodes) {
+ acceptNodes(transition, nodes);
+ }
+
+}
Index: /v2/trunk/de.ugoe.cs.swe.bnftools.ebnf/src-gen/de/ugoe/cs/swe/bnftools/services/EbnfGrammarAccess.java
===================================================================
--- /v2/trunk/de.ugoe.cs.swe.bnftools.ebnf/src-gen/de/ugoe/cs/swe/bnftools/services/EbnfGrammarAccess.java (revision 61)
+++ /v2/trunk/de.ugoe.cs.swe.bnftools.ebnf/src-gen/de/ugoe/cs/swe/bnftools/services/EbnfGrammarAccess.java (revision 61)
@@ -0,0 +1,1361 @@
+/*
+* generated by Xtext
+*/
+package de.ugoe.cs.swe.bnftools.services;
+
+import com.google.inject.Singleton;
+import com.google.inject.Inject;
+
+import java.util.List;
+
+import org.eclipse.xtext.*;
+import org.eclipse.xtext.service.GrammarProvider;
+import org.eclipse.xtext.service.AbstractElementFinder.*;
+
+
+@Singleton
+public class EbnfGrammarAccess extends AbstractGrammarElementFinder {
+
+
+ public class EtsiBnfElements extends AbstractParserRuleElementFinder {
+ private final ParserRule rule = (ParserRule) GrammarUtil.findRuleForName(getGrammar(), "EtsiBnf");
+ private final Alternatives cAlternatives = (Alternatives)rule.eContents().get(1);
+ private final Group cGroup_0 = (Group)cAlternatives.eContents().get(0);
+ private final Keyword cGrammarKeyword_0_0 = (Keyword)cGroup_0.eContents().get(0);
+ private final Assignment cNameAssignment_0_1 = (Assignment)cGroup_0.eContents().get(1);
+ private final RuleCall cNameIDTerminalRuleCall_0_1_0 = (RuleCall)cNameAssignment_0_1.eContents().get(0);
+ private final Group cGroup_0_2 = (Group)cGroup_0.eContents().get(2);
+ private final Assignment cTypeAssignment_0_2_0 = (Assignment)cGroup_0_2.eContents().get(0);
+ private final Keyword cTypeBnfKeyword_0_2_0_0 = (Keyword)cTypeAssignment_0_2_0.eContents().get(0);
+ private final Keyword cSemicolonKeyword_0_2_1 = (Keyword)cGroup_0_2.eContents().get(1);
+ private final Assignment cImportSectionAssignment_0_2_2 = (Assignment)cGroup_0_2.eContents().get(2);
+ private final RuleCall cImportSectionImportSectionParserRuleCall_0_2_2_0 = (RuleCall)cImportSectionAssignment_0_2_2.eContents().get(0);
+ private final Assignment cBnfEntryAssignment_0_2_3 = (Assignment)cGroup_0_2.eContents().get(3);
+ private final RuleCall cBnfEntryBnfEntryParserRuleCall_0_2_3_0 = (RuleCall)cBnfEntryAssignment_0_2_3.eContents().get(0);
+ private final Group cGroup_1 = (Group)cAlternatives.eContents().get(1);
+ private final Assignment cTypeAssignment_1_0 = (Assignment)cGroup_1.eContents().get(0);
+ private final Keyword cTypeDeltaKeyword_1_0_0 = (Keyword)cTypeAssignment_1_0.eContents().get(0);
+ private final Keyword cSemicolonKeyword_1_1 = (Keyword)cGroup_1.eContents().get(1);
+ private final Assignment cImportSectionAssignment_1_2 = (Assignment)cGroup_1.eContents().get(2);
+ private final RuleCall cImportSectionImportSectionParserRuleCall_1_2_0 = (RuleCall)cImportSectionAssignment_1_2.eContents().get(0);
+ private final Assignment cDeltaEntryAssignment_1_3 = (Assignment)cGroup_1.eContents().get(3);
+ private final RuleCall cDeltaEntryDeltaEntryParserRuleCall_1_3_0 = (RuleCall)cDeltaEntryAssignment_1_3.eContents().get(0);
+ private final Group cGroup_2 = (Group)cAlternatives.eContents().get(2);
+ private final Assignment cTypeAssignment_2_0 = (Assignment)cGroup_2.eContents().get(0);
+ private final Keyword cTypeMergeKeyword_2_0_0 = (Keyword)cTypeAssignment_2_0.eContents().get(0);
+ private final Keyword cSemicolonKeyword_2_1 = (Keyword)cGroup_2.eContents().get(1);
+ private final Assignment cImportSectionAssignment_2_2 = (Assignment)cGroup_2.eContents().get(2);
+ private final RuleCall cImportSectionImportSectionParserRuleCall_2_2_0 = (RuleCall)cImportSectionAssignment_2_2.eContents().get(0);
+ private final Assignment cMergeEntryAssignment_2_3 = (Assignment)cGroup_2.eContents().get(3);
+ private final RuleCall cMergeEntryMergeEntryParserRuleCall_2_3_0 = (RuleCall)cMergeEntryAssignment_2_3.eContents().get(0);
+
+ //// -----------------------------------------------------------------------------------------------
+ //// Parser Rules
+ //// -----------------------------------------------------------------------------------------------
+ //EtsiBnf:
+ // "grammar" name=ID (type="/bnf"? ";" importSection=ImportSection? bnfEntry+=BnfEntry+) | type="/delta" ";"
+ // importSection=ImportSection? deltaEntry+=DeltaEntry* | type="/merge" ";" importSection=ImportSection?
+ // mergeEntry+=MergeEntry*;
+ public ParserRule getRule() { return rule; }
+
+ //"grammar" name=ID (type="/bnf"? ";" importSection=ImportSection? bnfEntry+=BnfEntry+) | type="/delta" ";"
+ //importSection=ImportSection? deltaEntry+=DeltaEntry* | type="/merge" ";" importSection=ImportSection?
+ //mergeEntry+=MergeEntry*
+ public Alternatives getAlternatives() { return cAlternatives; }
+
+ //"grammar" name=ID (type="/bnf"? ";" importSection=ImportSection? bnfEntry+=BnfEntry+)
+ public Group getGroup_0() { return cGroup_0; }
+
+ //"grammar"
+ public Keyword getGrammarKeyword_0_0() { return cGrammarKeyword_0_0; }
+
+ //name=ID
+ public Assignment getNameAssignment_0_1() { return cNameAssignment_0_1; }
+
+ //ID
+ public RuleCall getNameIDTerminalRuleCall_0_1_0() { return cNameIDTerminalRuleCall_0_1_0; }
+
+ //type="/bnf"? ";" importSection=ImportSection? bnfEntry+=BnfEntry+
+ public Group getGroup_0_2() { return cGroup_0_2; }
+
+ //type="/bnf"?
+ public Assignment getTypeAssignment_0_2_0() { return cTypeAssignment_0_2_0; }
+
+ //"/bnf"
+ public Keyword getTypeBnfKeyword_0_2_0_0() { return cTypeBnfKeyword_0_2_0_0; }
+
+ //";"
+ public Keyword getSemicolonKeyword_0_2_1() { return cSemicolonKeyword_0_2_1; }
+
+ //importSection=ImportSection?
+ public Assignment getImportSectionAssignment_0_2_2() { return cImportSectionAssignment_0_2_2; }
+
+ //ImportSection
+ public RuleCall getImportSectionImportSectionParserRuleCall_0_2_2_0() { return cImportSectionImportSectionParserRuleCall_0_2_2_0; }
+
+ //bnfEntry+=BnfEntry+
+ public Assignment getBnfEntryAssignment_0_2_3() { return cBnfEntryAssignment_0_2_3; }
+
+ //BnfEntry
+ public RuleCall getBnfEntryBnfEntryParserRuleCall_0_2_3_0() { return cBnfEntryBnfEntryParserRuleCall_0_2_3_0; }
+
+ //type="/delta" ";" importSection=ImportSection? deltaEntry+=DeltaEntry*
+ public Group getGroup_1() { return cGroup_1; }
+
+ //type="/delta"
+ public Assignment getTypeAssignment_1_0() { return cTypeAssignment_1_0; }
+
+ //"/delta"
+ public Keyword getTypeDeltaKeyword_1_0_0() { return cTypeDeltaKeyword_1_0_0; }
+
+ //";"
+ public Keyword getSemicolonKeyword_1_1() { return cSemicolonKeyword_1_1; }
+
+ //importSection=ImportSection?
+ public Assignment getImportSectionAssignment_1_2() { return cImportSectionAssignment_1_2; }
+
+ //ImportSection
+ public RuleCall getImportSectionImportSectionParserRuleCall_1_2_0() { return cImportSectionImportSectionParserRuleCall_1_2_0; }
+
+ //deltaEntry+=DeltaEntry*
+ public Assignment getDeltaEntryAssignment_1_3() { return cDeltaEntryAssignment_1_3; }
+
+ //DeltaEntry
+ public RuleCall getDeltaEntryDeltaEntryParserRuleCall_1_3_0() { return cDeltaEntryDeltaEntryParserRuleCall_1_3_0; }
+
+ //type="/merge" ";" importSection=ImportSection? mergeEntry+=MergeEntry*
+ public Group getGroup_2() { return cGroup_2; }
+
+ //type="/merge"
+ public Assignment getTypeAssignment_2_0() { return cTypeAssignment_2_0; }
+
+ //"/merge"
+ public Keyword getTypeMergeKeyword_2_0_0() { return cTypeMergeKeyword_2_0_0; }
+
+ //";"
+ public Keyword getSemicolonKeyword_2_1() { return cSemicolonKeyword_2_1; }
+
+ //importSection=ImportSection?
+ public Assignment getImportSectionAssignment_2_2() { return cImportSectionAssignment_2_2; }
+
+ //ImportSection
+ public RuleCall getImportSectionImportSectionParserRuleCall_2_2_0() { return cImportSectionImportSectionParserRuleCall_2_2_0; }
+
+ //mergeEntry+=MergeEntry*
+ public Assignment getMergeEntryAssignment_2_3() { return cMergeEntryAssignment_2_3; }
+
+ //MergeEntry
+ public RuleCall getMergeEntryMergeEntryParserRuleCall_2_3_0() { return cMergeEntryMergeEntryParserRuleCall_2_3_0; }
+ }
+
+ public class ImportSectionElements extends AbstractParserRuleElementFinder {
+ private final ParserRule rule = (ParserRule) GrammarUtil.findRuleForName(getGrammar(), "ImportSection");
+ private final Assignment cImportsAssignment = (Assignment)rule.eContents().get(1);
+ private final RuleCall cImportsImportParserRuleCall_0 = (RuleCall)cImportsAssignment.eContents().get(0);
+
+ //ImportSection:
+ // imports+=Import+;
+ public ParserRule getRule() { return rule; }
+
+ //imports+=Import+
+ public Assignment getImportsAssignment() { return cImportsAssignment; }
+
+ //Import
+ public RuleCall getImportsImportParserRuleCall_0() { return cImportsImportParserRuleCall_0; }
+ }
+
+ public class BnfEntryElements extends AbstractParserRuleElementFinder {
+ private final ParserRule rule = (ParserRule) GrammarUtil.findRuleForName(getGrammar(), "BnfEntry");
+ private final Alternatives cAlternatives = (Alternatives)rule.eContents().get(1);
+ private final Assignment cSectionheaderAssignment_0 = (Assignment)cAlternatives.eContents().get(0);
+ private final RuleCall cSectionheaderSectionHeadingParserRuleCall_0_0 = (RuleCall)cSectionheaderAssignment_0.eContents().get(0);
+ private final Assignment cRuleAssignment_1 = (Assignment)cAlternatives.eContents().get(1);
+ private final RuleCall cRuleRuleParserRuleCall_1_0 = (RuleCall)cRuleAssignment_1.eContents().get(0);
+
+ //BnfEntry:
+ // sectionheader=SectionHeading | rule=Rule;
+ public ParserRule getRule() { return rule; }
+
+ //sectionheader=SectionHeading | rule=Rule
+ public Alternatives getAlternatives() { return cAlternatives; }
+
+ //sectionheader=SectionHeading
+ public Assignment getSectionheaderAssignment_0() { return cSectionheaderAssignment_0; }
+
+ //SectionHeading
+ public RuleCall getSectionheaderSectionHeadingParserRuleCall_0_0() { return cSectionheaderSectionHeadingParserRuleCall_0_0; }
+
+ //rule=Rule
+ public Assignment getRuleAssignment_1() { return cRuleAssignment_1; }
+
+ //Rule
+ public RuleCall getRuleRuleParserRuleCall_1_0() { return cRuleRuleParserRuleCall_1_0; }
+ }
+
+ public class DeltaEntryElements extends AbstractParserRuleElementFinder {
+ private final ParserRule rule = (ParserRule) GrammarUtil.findRuleForName(getGrammar(), "DeltaEntry");
+ private final Alternatives cAlternatives = (Alternatives)rule.eContents().get(1);
+ private final Assignment cRuleAssignment_0 = (Assignment)cAlternatives.eContents().get(0);
+ private final RuleCall cRuleRuleParserRuleCall_0_0 = (RuleCall)cRuleAssignment_0.eContents().get(0);
+ private final Assignment cSectionheaderAssignment_1 = (Assignment)cAlternatives.eContents().get(1);
+ private final RuleCall cSectionheaderSectionHeadingParserRuleCall_1_0 = (RuleCall)cSectionheaderAssignment_1.eContents().get(0);
+ private final Assignment cExtRuleAssignment_2 = (Assignment)cAlternatives.eContents().get(2);
+ private final RuleCall cExtRuleExtRuleParserRuleCall_2_0 = (RuleCall)cExtRuleAssignment_2.eContents().get(0);
+
+ //DeltaEntry:
+ // rule=Rule | sectionheader=SectionHeading | extRule=ExtRule;
+ public ParserRule getRule() { return rule; }
+
+ //rule=Rule | sectionheader=SectionHeading | extRule=ExtRule
+ public Alternatives getAlternatives() { return cAlternatives; }
+
+ //rule=Rule
+ public Assignment getRuleAssignment_0() { return cRuleAssignment_0; }
+
+ //Rule
+ public RuleCall getRuleRuleParserRuleCall_0_0() { return cRuleRuleParserRuleCall_0_0; }
+
+ //sectionheader=SectionHeading
+ public Assignment getSectionheaderAssignment_1() { return cSectionheaderAssignment_1; }
+
+ //SectionHeading
+ public RuleCall getSectionheaderSectionHeadingParserRuleCall_1_0() { return cSectionheaderSectionHeadingParserRuleCall_1_0; }
+
+ //extRule=ExtRule
+ public Assignment getExtRuleAssignment_2() { return cExtRuleAssignment_2; }
+
+ //ExtRule
+ public RuleCall getExtRuleExtRuleParserRuleCall_2_0() { return cExtRuleExtRuleParserRuleCall_2_0; }
+ }
+
+ public class MergeEntryElements extends AbstractParserRuleElementFinder {
+ private final ParserRule rule = (ParserRule) GrammarUtil.findRuleForName(getGrammar(), "MergeEntry");
+ private final Alternatives cAlternatives = (Alternatives)rule.eContents().get(1);
+ private final Assignment cSectionheaderAssignment_0 = (Assignment)cAlternatives.eContents().get(0);
+ private final RuleCall cSectionheaderSectionHeadingParserRuleCall_0_0 = (RuleCall)cSectionheaderAssignment_0.eContents().get(0);
+ private final Assignment cMergeRuleAssignment_1 = (Assignment)cAlternatives.eContents().get(1);
+ private final RuleCall cMergeRuleMergeRuleParserRuleCall_1_0 = (RuleCall)cMergeRuleAssignment_1.eContents().get(0);
+
+ //MergeEntry:
+ // sectionheader=SectionHeading | mergeRule=MergeRule;
+ public ParserRule getRule() { return rule; }
+
+ //sectionheader=SectionHeading | mergeRule=MergeRule
+ public Alternatives getAlternatives() { return cAlternatives; }
+
+ //sectionheader=SectionHeading
+ public Assignment getSectionheaderAssignment_0() { return cSectionheaderAssignment_0; }
+
+ //SectionHeading
+ public RuleCall getSectionheaderSectionHeadingParserRuleCall_0_0() { return cSectionheaderSectionHeadingParserRuleCall_0_0; }
+
+ //mergeRule=MergeRule
+ public Assignment getMergeRuleAssignment_1() { return cMergeRuleAssignment_1; }
+
+ //MergeRule
+ public RuleCall getMergeRuleMergeRuleParserRuleCall_1_0() { return cMergeRuleMergeRuleParserRuleCall_1_0; }
+ }
+
+ public class SectionHeadingElements extends AbstractParserRuleElementFinder {
+ private final ParserRule rule = (ParserRule) GrammarUtil.findRuleForName(getGrammar(), "SectionHeading");
+ private final Group cGroup = (Group)rule.eContents().get(1);
+ private final Action cSectionHeadingAction_0 = (Action)cGroup.eContents().get(0);
+ private final Assignment cSectionHeaderAssignment_1 = (Assignment)cGroup.eContents().get(1);
+ private final RuleCall cSectionHeaderSECTIONHEADERTerminalRuleCall_1_0 = (RuleCall)cSectionHeaderAssignment_1.eContents().get(0);
+
+ //SectionHeading:
+ // {SectionHeading} sectionHeader=SECTIONHEADER;
+ public ParserRule getRule() { return rule; }
+
+ //{SectionHeading} sectionHeader=SECTIONHEADER
+ public Group getGroup() { return cGroup; }
+
+ //{SectionHeading}
+ public Action getSectionHeadingAction_0() { return cSectionHeadingAction_0; }
+
+ //sectionHeader=SECTIONHEADER
+ public Assignment getSectionHeaderAssignment_1() { return cSectionHeaderAssignment_1; }
+
+ //SECTIONHEADER
+ public RuleCall getSectionHeaderSECTIONHEADERTerminalRuleCall_1_0() { return cSectionHeaderSECTIONHEADERTerminalRuleCall_1_0; }
+ }
+
+ public class ImportElements extends AbstractParserRuleElementFinder {
+ private final ParserRule rule = (ParserRule) GrammarUtil.findRuleForName(getGrammar(), "Import");
+ private final Group cGroup = (Group)rule.eContents().get(1);
+ private final Keyword cImportKeyword_0 = (Keyword)cGroup.eContents().get(0);
+ private final Assignment cImportURIAssignment_1 = (Assignment)cGroup.eContents().get(1);
+ private final RuleCall cImportURISTRINGTerminalRuleCall_1_0 = (RuleCall)cImportURIAssignment_1.eContents().get(0);
+ private final Group cGroup_2 = (Group)cGroup.eContents().get(2);
+ private final Keyword cSolidusKeyword_2_0 = (Keyword)cGroup_2.eContents().get(0);
+ private final Alternatives cAlternatives_2_1 = (Alternatives)cGroup_2.eContents().get(1);
+ private final Assignment cGrammarTypeAssignment_2_1_0 = (Assignment)cAlternatives_2_1.eContents().get(0);
+ private final Keyword cGrammarTypeCoreKeyword_2_1_0_0 = (Keyword)cGrammarTypeAssignment_2_1_0.eContents().get(0);
+ private final Assignment cGrammarTypeAssignment_2_1_1 = (Assignment)cAlternatives_2_1.eContents().get(1);
+ private final Keyword cGrammarTypePackageKeyword_2_1_1_0 = (Keyword)cGrammarTypeAssignment_2_1_1.eContents().get(0);
+ private final Assignment cGrammarTypeAssignment_2_1_2 = (Assignment)cAlternatives_2_1.eContents().get(2);
+ private final Keyword cGrammarTypeUpdateKeyword_2_1_2_0 = (Keyword)cGrammarTypeAssignment_2_1_2.eContents().get(0);
+ private final Group cGroup_3 = (Group)cGroup.eContents().get(3);
+ private final Keyword cLabelKeyword_3_0 = (Keyword)cGroup_3.eContents().get(0);
+ private final Assignment cLabelAssignment_3_1 = (Assignment)cGroup_3.eContents().get(1);
+ private final RuleCall cLabelIDTerminalRuleCall_3_1_0 = (RuleCall)cLabelAssignment_3_1.eContents().get(0);
+ private final Keyword cSemicolonKeyword_4 = (Keyword)cGroup.eContents().get(4);
+
+ //Import:
+ // "import" importURI=STRING ("/" (grammarType="core" | grammarType="package" | grammarType="update"))? ("label:"
+ // label=ID)? ";";
+ public ParserRule getRule() { return rule; }
+
+ //"import" importURI=STRING ("/" (grammarType="core" | grammarType="package" | grammarType="update"))? ("label:"
+ //label=ID)? ";"
+ public Group getGroup() { return cGroup; }
+
+ //"import"
+ public Keyword getImportKeyword_0() { return cImportKeyword_0; }
+
+ //importURI=STRING
+ public Assignment getImportURIAssignment_1() { return cImportURIAssignment_1; }
+
+ //STRING
+ public RuleCall getImportURISTRINGTerminalRuleCall_1_0() { return cImportURISTRINGTerminalRuleCall_1_0; }
+
+ //("/" (grammarType="core" | grammarType="package" | grammarType="update"))?
+ public Group getGroup_2() { return cGroup_2; }
+
+ //"/"
+ public Keyword getSolidusKeyword_2_0() { return cSolidusKeyword_2_0; }
+
+ //grammarType="core" | grammarType="package" | grammarType="update"
+ public Alternatives getAlternatives_2_1() { return cAlternatives_2_1; }
+
+ //grammarType="core"
+ public Assignment getGrammarTypeAssignment_2_1_0() { return cGrammarTypeAssignment_2_1_0; }
+
+ //"core"
+ public Keyword getGrammarTypeCoreKeyword_2_1_0_0() { return cGrammarTypeCoreKeyword_2_1_0_0; }
+
+ //grammarType="package"
+ public Assignment getGrammarTypeAssignment_2_1_1() { return cGrammarTypeAssignment_2_1_1; }
+
+ //"package"
+ public Keyword getGrammarTypePackageKeyword_2_1_1_0() { return cGrammarTypePackageKeyword_2_1_1_0; }
+
+ //grammarType="update"
+ public Assignment getGrammarTypeAssignment_2_1_2() { return cGrammarTypeAssignment_2_1_2; }
+
+ //"update"
+ public Keyword getGrammarTypeUpdateKeyword_2_1_2_0() { return cGrammarTypeUpdateKeyword_2_1_2_0; }
+
+ //("label:" label=ID)?
+ public Group getGroup_3() { return cGroup_3; }
+
+ //"label:"
+ public Keyword getLabelKeyword_3_0() { return cLabelKeyword_3_0; }
+
+ //label=ID
+ public Assignment getLabelAssignment_3_1() { return cLabelAssignment_3_1; }
+
+ //ID
+ public RuleCall getLabelIDTerminalRuleCall_3_1_0() { return cLabelIDTerminalRuleCall_3_1_0; }
+
+ //";"
+ public Keyword getSemicolonKeyword_4() { return cSemicolonKeyword_4; }
+ }
+
+ public class RuleElements extends AbstractParserRuleElementFinder {
+ private final ParserRule rule = (ParserRule) GrammarUtil.findRuleForName(getGrammar(), "Rule");
+ private final Group cGroup = (Group)rule.eContents().get(1);
+ private final Group cGroup_0 = (Group)cGroup.eContents().get(0);
+ private final Assignment cRulenumberAssignment_0_0 = (Assignment)cGroup_0.eContents().get(0);
+ private final RuleCall cRulenumberINTTerminalRuleCall_0_0_0 = (RuleCall)cRulenumberAssignment_0_0.eContents().get(0);
+ private final Assignment cRulevariantAssignment_0_1 = (Assignment)cGroup_0.eContents().get(1);
+ private final RuleCall cRulevariantIDTerminalRuleCall_0_1_0 = (RuleCall)cRulevariantAssignment_0_1.eContents().get(0);
+ private final Keyword cFullStopKeyword_0_2 = (Keyword)cGroup_0.eContents().get(2);
+ private final Assignment cNameAssignment_1 = (Assignment)cGroup.eContents().get(1);
+ private final RuleCall cNameIDTerminalRuleCall_1_0 = (RuleCall)cNameAssignment_1.eContents().get(0);
+ private final Keyword cColonColonEqualsSignKeyword_2 = (Keyword)cGroup.eContents().get(2);
+ private final Assignment cDefinitionListAssignment_3 = (Assignment)cGroup.eContents().get(3);
+ private final RuleCall cDefinitionListDefinitionListParserRuleCall_3_0 = (RuleCall)cDefinitionListAssignment_3.eContents().get(0);
+ private final Keyword cSemicolonKeyword_4 = (Keyword)cGroup.eContents().get(4);
+
+ //Rule:
+ // (rulenumber=INT rulevariant=ID? ".")? name=ID "::=" definitionList=DefinitionList? ";"?;
+ public ParserRule getRule() { return rule; }
+
+ //(rulenumber=INT rulevariant=ID? ".")? name=ID "::=" definitionList=DefinitionList? ";"?
+ public Group getGroup() { return cGroup; }
+
+ //(rulenumber=INT rulevariant=ID? ".")?
+ public Group getGroup_0() { return cGroup_0; }
+
+ //rulenumber=INT
+ public Assignment getRulenumberAssignment_0_0() { return cRulenumberAssignment_0_0; }
+
+ //INT
+ public RuleCall getRulenumberINTTerminalRuleCall_0_0_0() { return cRulenumberINTTerminalRuleCall_0_0_0; }
+
+ //rulevariant=ID?
+ public Assignment getRulevariantAssignment_0_1() { return cRulevariantAssignment_0_1; }
+
+ //ID
+ public RuleCall getRulevariantIDTerminalRuleCall_0_1_0() { return cRulevariantIDTerminalRuleCall_0_1_0; }
+
+ //"."
+ public Keyword getFullStopKeyword_0_2() { return cFullStopKeyword_0_2; }
+
+ //name=ID
+ public Assignment getNameAssignment_1() { return cNameAssignment_1; }
+
+ //ID
+ public RuleCall getNameIDTerminalRuleCall_1_0() { return cNameIDTerminalRuleCall_1_0; }
+
+ //"::="
+ public Keyword getColonColonEqualsSignKeyword_2() { return cColonColonEqualsSignKeyword_2; }
+
+ //definitionList=DefinitionList?
+ public Assignment getDefinitionListAssignment_3() { return cDefinitionListAssignment_3; }
+
+ //DefinitionList
+ public RuleCall getDefinitionListDefinitionListParserRuleCall_3_0() { return cDefinitionListDefinitionListParserRuleCall_3_0; }
+
+ //";"?
+ public Keyword getSemicolonKeyword_4() { return cSemicolonKeyword_4; }
+ }
+
+ public class ExtRuleElements extends AbstractParserRuleElementFinder {
+ private final ParserRule rule = (ParserRule) GrammarUtil.findRuleForName(getGrammar(), "ExtRule");
+ private final Group cGroup = (Group)rule.eContents().get(1);
+ private final Group cGroup_0 = (Group)cGroup.eContents().get(0);
+ private final Assignment cRulenumberAssignment_0_0 = (Assignment)cGroup_0.eContents().get(0);
+ private final RuleCall cRulenumberINTTerminalRuleCall_0_0_0 = (RuleCall)cRulenumberAssignment_0_0.eContents().get(0);
+ private final Assignment cRulevariantAssignment_0_1 = (Assignment)cGroup_0.eContents().get(1);
+ private final RuleCall cRulevariantIDTerminalRuleCall_0_1_0 = (RuleCall)cRulevariantAssignment_0_1.eContents().get(0);
+ private final Keyword cFullStopKeyword_0_2 = (Keyword)cGroup_0.eContents().get(2);
+ private final Assignment cNameAssignment_1 = (Assignment)cGroup.eContents().get(1);
+ private final RuleCall cNameIDTerminalRuleCall_1_0 = (RuleCall)cNameAssignment_1.eContents().get(0);
+ private final Group cGroup_2 = (Group)cGroup.eContents().get(2);
+ private final Keyword cLeftParenthesisKeyword_2_0 = (Keyword)cGroup_2.eContents().get(0);
+ private final Assignment cRuleextAssignment_2_1 = (Assignment)cGroup_2.eContents().get(1);
+ private final RuleCall cRuleextINTTerminalRuleCall_2_1_0 = (RuleCall)cRuleextAssignment_2_1.eContents().get(0);
+ private final Keyword cRightParenthesisKeyword_2_2 = (Keyword)cGroup_2.eContents().get(2);
+ private final Keyword cLessThanSignHyphenMinusKeyword_3 = (Keyword)cGroup.eContents().get(3);
+ private final Alternatives cAlternatives_4 = (Alternatives)cGroup.eContents().get(4);
+ private final Assignment cElementsAssignment_4_0 = (Assignment)cAlternatives_4.eContents().get(0);
+ private final RuleCall cElementsAtomParserRuleCall_4_0_0 = (RuleCall)cElementsAssignment_4_0.eContents().get(0);
+ private final Keyword cRightParenthesisKeyword_4_1 = (Keyword)cAlternatives_4.eContents().get(1);
+ private final Keyword cRightSquareBracketKeyword_4_2 = (Keyword)cAlternatives_4.eContents().get(2);
+ private final Keyword cRightCurlyBracketKeyword_4_3 = (Keyword)cAlternatives_4.eContents().get(3);
+ private final Keyword cVerticalLineKeyword_4_4 = (Keyword)cAlternatives_4.eContents().get(4);
+ private final Keyword cLeftParenthesisKeyword_4_5 = (Keyword)cAlternatives_4.eContents().get(5);
+ private final Keyword cLeftSquareBracketKeyword_4_6 = (Keyword)cAlternatives_4.eContents().get(6);
+ private final Keyword cLeftCurlyBracketKeyword_4_7 = (Keyword)cAlternatives_4.eContents().get(7);
+ private final Keyword cAsteriskKeyword_4_8 = (Keyword)cAlternatives_4.eContents().get(8);
+ private final Keyword cPlusSignKeyword_4_9 = (Keyword)cAlternatives_4.eContents().get(9);
+ private final Keyword cSemicolonKeyword_5 = (Keyword)cGroup.eContents().get(5);
+
+ //ExtRule:
+ // (rulenumber=INT rulevariant=ID? ".")? name=ID ("(" ruleext=INT ")") "<-" (elements+=Atom | ")" | "]" | "}" | "|" |
+ // "(" | "[" | "{" | "*" | "+")* ";"?;
+ public ParserRule getRule() { return rule; }
+
+ //(rulenumber=INT rulevariant=ID? ".")? name=ID ("(" ruleext=INT ")") "<-" (elements+=Atom | ")" | "]" | "}" | "|" | "(" |
+ //"[" | "{" | "*" | "+")* ";"?
+ public Group getGroup() { return cGroup; }
+
+ //(rulenumber=INT rulevariant=ID? ".")?
+ public Group getGroup_0() { return cGroup_0; }
+
+ //rulenumber=INT
+ public Assignment getRulenumberAssignment_0_0() { return cRulenumberAssignment_0_0; }
+
+ //INT
+ public RuleCall getRulenumberINTTerminalRuleCall_0_0_0() { return cRulenumberINTTerminalRuleCall_0_0_0; }
+
+ //rulevariant=ID?
+ public Assignment getRulevariantAssignment_0_1() { return cRulevariantAssignment_0_1; }
+
+ //ID
+ public RuleCall getRulevariantIDTerminalRuleCall_0_1_0() { return cRulevariantIDTerminalRuleCall_0_1_0; }
+
+ //"."
+ public Keyword getFullStopKeyword_0_2() { return cFullStopKeyword_0_2; }
+
+ //name=ID
+ public Assignment getNameAssignment_1() { return cNameAssignment_1; }
+
+ //ID
+ public RuleCall getNameIDTerminalRuleCall_1_0() { return cNameIDTerminalRuleCall_1_0; }
+
+ //"(" ruleext=INT ")"
+ public Group getGroup_2() { return cGroup_2; }
+
+ //"("
+ public Keyword getLeftParenthesisKeyword_2_0() { return cLeftParenthesisKeyword_2_0; }
+
+ //ruleext=INT
+ public Assignment getRuleextAssignment_2_1() { return cRuleextAssignment_2_1; }
+
+ //INT
+ public RuleCall getRuleextINTTerminalRuleCall_2_1_0() { return cRuleextINTTerminalRuleCall_2_1_0; }
+
+ //")"
+ public Keyword getRightParenthesisKeyword_2_2() { return cRightParenthesisKeyword_2_2; }
+
+ //"<-"
+ public Keyword getLessThanSignHyphenMinusKeyword_3() { return cLessThanSignHyphenMinusKeyword_3; }
+
+ //(elements+=Atom | ")" | "]" | "}" | "|" | "(" | "[" | "{" | "*" | "+")*
+ public Alternatives getAlternatives_4() { return cAlternatives_4; }
+
+ //elements+=Atom
+ public Assignment getElementsAssignment_4_0() { return cElementsAssignment_4_0; }
+
+ //Atom
+ public RuleCall getElementsAtomParserRuleCall_4_0_0() { return cElementsAtomParserRuleCall_4_0_0; }
+
+ //")"
+ public Keyword getRightParenthesisKeyword_4_1() { return cRightParenthesisKeyword_4_1; }
+
+ //"]"
+ public Keyword getRightSquareBracketKeyword_4_2() { return cRightSquareBracketKeyword_4_2; }
+
+ //"}"
+ public Keyword getRightCurlyBracketKeyword_4_3() { return cRightCurlyBracketKeyword_4_3; }
+
+ //"|"
+ public Keyword getVerticalLineKeyword_4_4() { return cVerticalLineKeyword_4_4; }
+
+ //"("
+ public Keyword getLeftParenthesisKeyword_4_5() { return cLeftParenthesisKeyword_4_5; }
+
+ //"["
+ public Keyword getLeftSquareBracketKeyword_4_6() { return cLeftSquareBracketKeyword_4_6; }
+
+ //"{"
+ public Keyword getLeftCurlyBracketKeyword_4_7() { return cLeftCurlyBracketKeyword_4_7; }
+
+ //"*"
+ public Keyword getAsteriskKeyword_4_8() { return cAsteriskKeyword_4_8; }
+
+ //"+"
+ public Keyword getPlusSignKeyword_4_9() { return cPlusSignKeyword_4_9; }
+
+ //";"?
+ public Keyword getSemicolonKeyword_5() { return cSemicolonKeyword_5; }
+ }
+
+ public class MergeRuleElements extends AbstractParserRuleElementFinder {
+ private final ParserRule rule = (ParserRule) GrammarUtil.findRuleForName(getGrammar(), "MergeRule");
+ private final Alternatives cAlternatives = (Alternatives)rule.eContents().get(1);
+ private final RuleCall cGlobalCombinatorParserRuleCall_0 = (RuleCall)cAlternatives.eContents().get(0);
+ private final RuleCall cRuleCombinatorParserRuleCall_1 = (RuleCall)cAlternatives.eContents().get(1);
+ private final RuleCall cHookCombinatorParserRuleCall_2 = (RuleCall)cAlternatives.eContents().get(2);
+
+ //MergeRule:
+ // GlobalCombinator | RuleCombinator | HookCombinator;
+ public ParserRule getRule() { return rule; }
+
+ //GlobalCombinator | RuleCombinator | HookCombinator
+ public Alternatives getAlternatives() { return cAlternatives; }
+
+ //GlobalCombinator
+ public RuleCall getGlobalCombinatorParserRuleCall_0() { return cGlobalCombinatorParserRuleCall_0; }
+
+ //RuleCombinator
+ public RuleCall getRuleCombinatorParserRuleCall_1() { return cRuleCombinatorParserRuleCall_1; }
+
+ //HookCombinator
+ public RuleCall getHookCombinatorParserRuleCall_2() { return cHookCombinatorParserRuleCall_2; }
+ }
+
+ public class GlobalCombinatorElements extends AbstractParserRuleElementFinder {
+ private final ParserRule rule = (ParserRule) GrammarUtil.findRuleForName(getGrammar(), "GlobalCombinator");
+ private final Group cGroup = (Group)rule.eContents().get(1);
+ private final Group cGroup_0 = (Group)cGroup.eContents().get(0);
+ private final Keyword cGlobalKeyword_0_0 = (Keyword)cGroup_0.eContents().get(0);
+ private final Keyword cCombinatorKeyword_0_1 = (Keyword)cGroup_0.eContents().get(1);
+ private final Assignment cLogicAssignment_1 = (Assignment)cGroup.eContents().get(1);
+ private final RuleCall cLogicLOGICTerminalRuleCall_1_0 = (RuleCall)cLogicAssignment_1.eContents().get(0);
+ private final Keyword cSemicolonKeyword_2 = (Keyword)cGroup.eContents().get(2);
+
+ //GlobalCombinator:
+ // ("global" "combinator:") logic=LOGIC ";"?;
+ public ParserRule getRule() { return rule; }
+
+ //("global" "combinator:") logic=LOGIC ";"?
+ public Group getGroup() { return cGroup; }
+
+ //"global" "combinator:"
+ public Group getGroup_0() { return cGroup_0; }
+
+ //"global"
+ public Keyword getGlobalKeyword_0_0() { return cGlobalKeyword_0_0; }
+
+ //"combinator:"
+ public Keyword getCombinatorKeyword_0_1() { return cCombinatorKeyword_0_1; }
+
+ //logic=LOGIC
+ public Assignment getLogicAssignment_1() { return cLogicAssignment_1; }
+
+ //LOGIC
+ public RuleCall getLogicLOGICTerminalRuleCall_1_0() { return cLogicLOGICTerminalRuleCall_1_0; }
+
+ //";"?
+ public Keyword getSemicolonKeyword_2() { return cSemicolonKeyword_2; }
+ }
+
+ public class RuleCombinatorElements extends AbstractParserRuleElementFinder {
+ private final ParserRule rule = (ParserRule) GrammarUtil.findRuleForName(getGrammar(), "RuleCombinator");
+ private final Group cGroup = (Group)rule.eContents().get(1);
+ private final Group cGroup_0 = (Group)cGroup.eContents().get(0);
+ private final Keyword cRuleKeyword_0_0 = (Keyword)cGroup_0.eContents().get(0);
+ private final Keyword cCombinatorKeyword_0_1 = (Keyword)cGroup_0.eContents().get(1);
+ private final Assignment cNameAssignment_0_2 = (Assignment)cGroup_0.eContents().get(2);
+ private final RuleCall cNameIDTerminalRuleCall_0_2_0 = (RuleCall)cNameAssignment_0_2.eContents().get(0);
+ private final Assignment cLogicAssignment_1 = (Assignment)cGroup.eContents().get(1);
+ private final RuleCall cLogicLOGICTerminalRuleCall_1_0 = (RuleCall)cLogicAssignment_1.eContents().get(0);
+ private final Group cGroup_2 = (Group)cGroup.eContents().get(2);
+ private final Keyword cLeftParenthesisKeyword_2_0 = (Keyword)cGroup_2.eContents().get(0);
+ private final Assignment cLABELAssignment_2_1 = (Assignment)cGroup_2.eContents().get(1);
+ private final RuleCall cLABELSTRINGTerminalRuleCall_2_1_0 = (RuleCall)cLABELAssignment_2_1.eContents().get(0);
+ private final Keyword cRightParenthesisKeyword_2_2 = (Keyword)cGroup_2.eContents().get(2);
+ private final Keyword cSemicolonKeyword_3 = (Keyword)cGroup.eContents().get(3);
+
+ //RuleCombinator:
+ // ("rule" "combinator:" name=ID) logic=LOGIC ("(" LABEL+=STRING ")")* ";"?;
+ public ParserRule getRule() { return rule; }
+
+ //("rule" "combinator:" name=ID) logic=LOGIC ("(" LABEL+=STRING ")")* ";"?
+ public Group getGroup() { return cGroup; }
+
+ //"rule" "combinator:" name=ID
+ public Group getGroup_0() { return cGroup_0; }
+
+ //"rule"
+ public Keyword getRuleKeyword_0_0() { return cRuleKeyword_0_0; }
+
+ //"combinator:"
+ public Keyword getCombinatorKeyword_0_1() { return cCombinatorKeyword_0_1; }
+
+ //name=ID
+ public Assignment getNameAssignment_0_2() { return cNameAssignment_0_2; }
+
+ //ID
+ public RuleCall getNameIDTerminalRuleCall_0_2_0() { return cNameIDTerminalRuleCall_0_2_0; }
+
+ //logic=LOGIC
+ public Assignment getLogicAssignment_1() { return cLogicAssignment_1; }
+
+ //LOGIC
+ public RuleCall getLogicLOGICTerminalRuleCall_1_0() { return cLogicLOGICTerminalRuleCall_1_0; }
+
+ //("(" LABEL+=STRING ")")*
+ public Group getGroup_2() { return cGroup_2; }
+
+ //"("
+ public Keyword getLeftParenthesisKeyword_2_0() { return cLeftParenthesisKeyword_2_0; }
+
+ //LABEL+=STRING
+ public Assignment getLABELAssignment_2_1() { return cLABELAssignment_2_1; }
+
+ //STRING
+ public RuleCall getLABELSTRINGTerminalRuleCall_2_1_0() { return cLABELSTRINGTerminalRuleCall_2_1_0; }
+
+ //")"
+ public Keyword getRightParenthesisKeyword_2_2() { return cRightParenthesisKeyword_2_2; }
+
+ //";"?
+ public Keyword getSemicolonKeyword_3() { return cSemicolonKeyword_3; }
+ }
+
+ public class HookCombinatorElements extends AbstractParserRuleElementFinder {
+ private final ParserRule rule = (ParserRule) GrammarUtil.findRuleForName(getGrammar(), "HookCombinator");
+ private final Group cGroup = (Group)rule.eContents().get(1);
+ private final Keyword cHookKeyword_0 = (Keyword)cGroup.eContents().get(0);
+ private final Keyword cCombinatorKeyword_1 = (Keyword)cGroup.eContents().get(1);
+ private final Assignment cNameAssignment_2 = (Assignment)cGroup.eContents().get(2);
+ private final RuleCall cNameIDTerminalRuleCall_2_0 = (RuleCall)cNameAssignment_2.eContents().get(0);
+ private final Keyword cLeftParenthesisKeyword_3 = (Keyword)cGroup.eContents().get(3);
+ private final Assignment cRuleextAssignment_4 = (Assignment)cGroup.eContents().get(4);
+ private final RuleCall cRuleextINTTerminalRuleCall_4_0 = (RuleCall)cRuleextAssignment_4.eContents().get(0);
+ private final Keyword cRightParenthesisKeyword_5 = (Keyword)cGroup.eContents().get(5);
+ private final Assignment cLogicAssignment_6 = (Assignment)cGroup.eContents().get(6);
+ private final RuleCall cLogicLOGICTerminalRuleCall_6_0 = (RuleCall)cLogicAssignment_6.eContents().get(0);
+ private final Group cGroup_7 = (Group)cGroup.eContents().get(7);
+ private final Keyword cLeftParenthesisKeyword_7_0 = (Keyword)cGroup_7.eContents().get(0);
+ private final Assignment cLABELAssignment_7_1 = (Assignment)cGroup_7.eContents().get(1);
+ private final RuleCall cLABELSTRINGTerminalRuleCall_7_1_0 = (RuleCall)cLABELAssignment_7_1.eContents().get(0);
+ private final Keyword cRightParenthesisKeyword_7_2 = (Keyword)cGroup_7.eContents().get(2);
+ private final Keyword cSemicolonKeyword_8 = (Keyword)cGroup.eContents().get(8);
+
+ //HookCombinator:
+ // "hook" "combinator:" name=ID "(" ruleext=INT ")" logic=LOGIC? ("(" LABEL+=STRING ")")+ ";"?;
+ public ParserRule getRule() { return rule; }
+
+ //"hook" "combinator:" name=ID "(" ruleext=INT ")" logic=LOGIC? ("(" LABEL+=STRING ")")+ ";"?
+ public Group getGroup() { return cGroup; }
+
+ //"hook"
+ public Keyword getHookKeyword_0() { return cHookKeyword_0; }
+
+ //"combinator:"
+ public Keyword getCombinatorKeyword_1() { return cCombinatorKeyword_1; }
+
+ //name=ID
+ public Assignment getNameAssignment_2() { return cNameAssignment_2; }
+
+ //ID
+ public RuleCall getNameIDTerminalRuleCall_2_0() { return cNameIDTerminalRuleCall_2_0; }
+
+ //"("
+ public Keyword getLeftParenthesisKeyword_3() { return cLeftParenthesisKeyword_3; }
+
+ //ruleext=INT
+ public Assignment getRuleextAssignment_4() { return cRuleextAssignment_4; }
+
+ //INT
+ public RuleCall getRuleextINTTerminalRuleCall_4_0() { return cRuleextINTTerminalRuleCall_4_0; }
+
+ //")"
+ public Keyword getRightParenthesisKeyword_5() { return cRightParenthesisKeyword_5; }
+
+ //logic=LOGIC?
+ public Assignment getLogicAssignment_6() { return cLogicAssignment_6; }
+
+ //LOGIC
+ public RuleCall getLogicLOGICTerminalRuleCall_6_0() { return cLogicLOGICTerminalRuleCall_6_0; }
+
+ //("(" LABEL+=STRING ")")+
+ public Group getGroup_7() { return cGroup_7; }
+
+ //"("
+ public Keyword getLeftParenthesisKeyword_7_0() { return cLeftParenthesisKeyword_7_0; }
+
+ //LABEL+=STRING
+ public Assignment getLABELAssignment_7_1() { return cLABELAssignment_7_1; }
+
+ //STRING
+ public RuleCall getLABELSTRINGTerminalRuleCall_7_1_0() { return cLABELSTRINGTerminalRuleCall_7_1_0; }
+
+ //")"
+ public Keyword getRightParenthesisKeyword_7_2() { return cRightParenthesisKeyword_7_2; }
+
+ //";"?
+ public Keyword getSemicolonKeyword_8() { return cSemicolonKeyword_8; }
+ }
+
+ public class DefinitionListElements extends AbstractParserRuleElementFinder {
+ private final ParserRule rule = (ParserRule) GrammarUtil.findRuleForName(getGrammar(), "DefinitionList");
+ private final Group cGroup = (Group)rule.eContents().get(1);
+ private final Assignment cSingleDefinitionAssignment_0 = (Assignment)cGroup.eContents().get(0);
+ private final RuleCall cSingleDefinitionSingleDefinitionParserRuleCall_0_0 = (RuleCall)cSingleDefinitionAssignment_0.eContents().get(0);
+ private final Group cGroup_1 = (Group)cGroup.eContents().get(1);
+ private final Keyword cVerticalLineKeyword_1_0 = (Keyword)cGroup_1.eContents().get(0);
+ private final Assignment cSingleDefinitionAssignment_1_1 = (Assignment)cGroup_1.eContents().get(1);
+ private final RuleCall cSingleDefinitionSingleDefinitionParserRuleCall_1_1_0 = (RuleCall)cSingleDefinitionAssignment_1_1.eContents().get(0);
+
+ //DefinitionList:
+ // singleDefinition+=SingleDefinition ("|" singleDefinition+=SingleDefinition)*;
+ public ParserRule getRule() { return rule; }
+
+ //singleDefinition+=SingleDefinition ("|" singleDefinition+=SingleDefinition)*
+ public Group getGroup() { return cGroup; }
+
+ //singleDefinition+=SingleDefinition
+ public Assignment getSingleDefinitionAssignment_0() { return cSingleDefinitionAssignment_0; }
+
+ //SingleDefinition
+ public RuleCall getSingleDefinitionSingleDefinitionParserRuleCall_0_0() { return cSingleDefinitionSingleDefinitionParserRuleCall_0_0; }
+
+ //("|" singleDefinition+=SingleDefinition)*
+ public Group getGroup_1() { return cGroup_1; }
+
+ //"|"
+ public Keyword getVerticalLineKeyword_1_0() { return cVerticalLineKeyword_1_0; }
+
+ //singleDefinition+=SingleDefinition
+ public Assignment getSingleDefinitionAssignment_1_1() { return cSingleDefinitionAssignment_1_1; }
+
+ //SingleDefinition
+ public RuleCall getSingleDefinitionSingleDefinitionParserRuleCall_1_1_0() { return cSingleDefinitionSingleDefinitionParserRuleCall_1_1_0; }
+ }
+
+ public class SingleDefinitionElements extends AbstractParserRuleElementFinder {
+ private final ParserRule rule = (ParserRule) GrammarUtil.findRuleForName(getGrammar(), "SingleDefinition");
+ private final Assignment cTermsAssignment = (Assignment)rule.eContents().get(1);
+ private final RuleCall cTermsTermParserRuleCall_0 = (RuleCall)cTermsAssignment.eContents().get(0);
+
+ //SingleDefinition:
+ // terms+=Term+;
+ public ParserRule getRule() { return rule; }
+
+ //terms+=Term+
+ public Assignment getTermsAssignment() { return cTermsAssignment; }
+
+ //Term
+ public RuleCall getTermsTermParserRuleCall_0() { return cTermsTermParserRuleCall_0; }
+ }
+
+ public class TermElements extends AbstractParserRuleElementFinder {
+ private final ParserRule rule = (ParserRule) GrammarUtil.findRuleForName(getGrammar(), "Term");
+ private final Alternatives cAlternatives = (Alternatives)rule.eContents().get(1);
+ private final Assignment cTermAtomAssignment_0 = (Assignment)cAlternatives.eContents().get(0);
+ private final RuleCall cTermAtomAtomParserRuleCall_0_0 = (RuleCall)cTermAtomAssignment_0.eContents().get(0);
+ private final Assignment cTermGroupedSequenceAssignment_1 = (Assignment)cAlternatives.eContents().get(1);
+ private final RuleCall cTermGroupedSequenceGroupedSequenceParserRuleCall_1_0 = (RuleCall)cTermGroupedSequenceAssignment_1.eContents().get(0);
+ private final Assignment cTermOptionalSequenceAssignment_2 = (Assignment)cAlternatives.eContents().get(2);
+ private final RuleCall cTermOptionalSequenceOptionalSequenceParserRuleCall_2_0 = (RuleCall)cTermOptionalSequenceAssignment_2.eContents().get(0);
+ private final Assignment cTermRepeatedSequenceAssignment_3 = (Assignment)cAlternatives.eContents().get(3);
+ private final RuleCall cTermRepeatedSequenceRepeatedSequenceParserRuleCall_3_0 = (RuleCall)cTermRepeatedSequenceAssignment_3.eContents().get(0);
+
+ //Term:
+ // termAtom=Atom | termGroupedSequence=GroupedSequence | termOptionalSequence=OptionalSequence |
+ // termRepeatedSequence=RepeatedSequence;
+ public ParserRule getRule() { return rule; }
+
+ //termAtom=Atom | termGroupedSequence=GroupedSequence | termOptionalSequence=OptionalSequence |
+ //termRepeatedSequence=RepeatedSequence
+ public Alternatives getAlternatives() { return cAlternatives; }
+
+ //termAtom=Atom
+ public Assignment getTermAtomAssignment_0() { return cTermAtomAssignment_0; }
+
+ //Atom
+ public RuleCall getTermAtomAtomParserRuleCall_0_0() { return cTermAtomAtomParserRuleCall_0_0; }
+
+ //termGroupedSequence=GroupedSequence
+ public Assignment getTermGroupedSequenceAssignment_1() { return cTermGroupedSequenceAssignment_1; }
+
+ //GroupedSequence
+ public RuleCall getTermGroupedSequenceGroupedSequenceParserRuleCall_1_0() { return cTermGroupedSequenceGroupedSequenceParserRuleCall_1_0; }
+
+ //termOptionalSequence=OptionalSequence
+ public Assignment getTermOptionalSequenceAssignment_2() { return cTermOptionalSequenceAssignment_2; }
+
+ //OptionalSequence
+ public RuleCall getTermOptionalSequenceOptionalSequenceParserRuleCall_2_0() { return cTermOptionalSequenceOptionalSequenceParserRuleCall_2_0; }
+
+ //termRepeatedSequence=RepeatedSequence
+ public Assignment getTermRepeatedSequenceAssignment_3() { return cTermRepeatedSequenceAssignment_3; }
+
+ //RepeatedSequence
+ public RuleCall getTermRepeatedSequenceRepeatedSequenceParserRuleCall_3_0() { return cTermRepeatedSequenceRepeatedSequenceParserRuleCall_3_0; }
+ }
+
+ public class AtomElements extends AbstractParserRuleElementFinder {
+ private final ParserRule rule = (ParserRule) GrammarUtil.findRuleForName(getGrammar(), "Atom");
+ private final Alternatives cAlternatives = (Alternatives)rule.eContents().get(1);
+ private final Assignment cAtomStringRuleAssignment_0 = (Assignment)cAlternatives.eContents().get(0);
+ private final RuleCall cAtomStringRuleStringRuleParserRuleCall_0_0 = (RuleCall)cAtomStringRuleAssignment_0.eContents().get(0);
+ private final Assignment cAtomRuleReferenceAssignment_1 = (Assignment)cAlternatives.eContents().get(1);
+ private final RuleCall cAtomRuleReferenceRuleReferenceParserRuleCall_1_0 = (RuleCall)cAtomRuleReferenceAssignment_1.eContents().get(0);
+
+ //Atom:
+ // atomStringRule=StringRule | atomRuleReference=RuleReference;
+ public ParserRule getRule() { return rule; }
+
+ //atomStringRule=StringRule | atomRuleReference=RuleReference
+ public Alternatives getAlternatives() { return cAlternatives; }
+
+ //atomStringRule=StringRule
+ public Assignment getAtomStringRuleAssignment_0() { return cAtomStringRuleAssignment_0; }
+
+ //StringRule
+ public RuleCall getAtomStringRuleStringRuleParserRuleCall_0_0() { return cAtomStringRuleStringRuleParserRuleCall_0_0; }
+
+ //atomRuleReference=RuleReference
+ public Assignment getAtomRuleReferenceAssignment_1() { return cAtomRuleReferenceAssignment_1; }
+
+ //RuleReference
+ public RuleCall getAtomRuleReferenceRuleReferenceParserRuleCall_1_0() { return cAtomRuleReferenceRuleReferenceParserRuleCall_1_0; }
+ }
+
+ public class RuleReferenceElements extends AbstractParserRuleElementFinder {
+ private final ParserRule rule = (ParserRule) GrammarUtil.findRuleForName(getGrammar(), "RuleReference");
+ private final Assignment cRulerefAssignment = (Assignment)rule.eContents().get(1);
+ private final CrossReference cRulerefRuleCrossReference_0 = (CrossReference)cRulerefAssignment.eContents().get(0);
+ private final RuleCall cRulerefRuleIDTerminalRuleCall_0_1 = (RuleCall)cRulerefRuleCrossReference_0.eContents().get(1);
+
+ //RuleReference:
+ // ruleref=[Rule];
+ public ParserRule getRule() { return rule; }
+
+ //ruleref=[Rule]
+ public Assignment getRulerefAssignment() { return cRulerefAssignment; }
+
+ //[Rule]
+ public CrossReference getRulerefRuleCrossReference_0() { return cRulerefRuleCrossReference_0; }
+
+ //ID
+ public RuleCall getRulerefRuleIDTerminalRuleCall_0_1() { return cRulerefRuleIDTerminalRuleCall_0_1; }
+ }
+
+ public class StringRuleElements extends AbstractParserRuleElementFinder {
+ private final ParserRule rule = (ParserRule) GrammarUtil.findRuleForName(getGrammar(), "StringRule");
+ private final Alternatives cAlternatives = (Alternatives)rule.eContents().get(1);
+ private final Assignment cLiteralAssignment_0 = (Assignment)cAlternatives.eContents().get(0);
+ private final RuleCall cLiteralSTRINGTerminalRuleCall_0_0 = (RuleCall)cLiteralAssignment_0.eContents().get(0);
+ private final Assignment cColonAssignment_1 = (Assignment)cAlternatives.eContents().get(1);
+ private final RuleCall cColonCOLONTerminalRuleCall_1_0 = (RuleCall)cColonAssignment_1.eContents().get(0);
+
+ //StringRule:
+ // literal=STRING | colon=COLON;
+ public ParserRule getRule() { return rule; }
+
+ //literal=STRING | colon=COLON
+ public Alternatives getAlternatives() { return cAlternatives; }
+
+ //literal=STRING
+ public Assignment getLiteralAssignment_0() { return cLiteralAssignment_0; }
+
+ //STRING
+ public RuleCall getLiteralSTRINGTerminalRuleCall_0_0() { return cLiteralSTRINGTerminalRuleCall_0_0; }
+
+ //colon=COLON
+ public Assignment getColonAssignment_1() { return cColonAssignment_1; }
+
+ //COLON
+ public RuleCall getColonCOLONTerminalRuleCall_1_0() { return cColonCOLONTerminalRuleCall_1_0; }
+ }
+
+ public class GroupedSequenceElements extends AbstractParserRuleElementFinder {
+ private final ParserRule rule = (ParserRule) GrammarUtil.findRuleForName(getGrammar(), "GroupedSequence");
+ private final Group cGroup = (Group)rule.eContents().get(1);
+ private final Keyword cLeftParenthesisKeyword_0 = (Keyword)cGroup.eContents().get(0);
+ private final Assignment cDefinitionListAssignment_1 = (Assignment)cGroup.eContents().get(1);
+ private final RuleCall cDefinitionListDefinitionListParserRuleCall_1_0 = (RuleCall)cDefinitionListAssignment_1.eContents().get(0);
+ private final Keyword cRightParenthesisKeyword_2 = (Keyword)cGroup.eContents().get(2);
+
+ //GroupedSequence:
+ // "(" definitionList+=DefinitionList ")";
+ public ParserRule getRule() { return rule; }
+
+ //"(" definitionList+=DefinitionList ")"
+ public Group getGroup() { return cGroup; }
+
+ //"("
+ public Keyword getLeftParenthesisKeyword_0() { return cLeftParenthesisKeyword_0; }
+
+ //definitionList+=DefinitionList
+ public Assignment getDefinitionListAssignment_1() { return cDefinitionListAssignment_1; }
+
+ //DefinitionList
+ public RuleCall getDefinitionListDefinitionListParserRuleCall_1_0() { return cDefinitionListDefinitionListParserRuleCall_1_0; }
+
+ //")"
+ public Keyword getRightParenthesisKeyword_2() { return cRightParenthesisKeyword_2; }
+ }
+
+ public class OptionalSequenceElements extends AbstractParserRuleElementFinder {
+ private final ParserRule rule = (ParserRule) GrammarUtil.findRuleForName(getGrammar(), "OptionalSequence");
+ private final Group cGroup = (Group)rule.eContents().get(1);
+ private final Keyword cLeftSquareBracketKeyword_0 = (Keyword)cGroup.eContents().get(0);
+ private final Assignment cDefinitionListAssignment_1 = (Assignment)cGroup.eContents().get(1);
+ private final RuleCall cDefinitionListDefinitionListParserRuleCall_1_0 = (RuleCall)cDefinitionListAssignment_1.eContents().get(0);
+ private final Keyword cRightSquareBracketKeyword_2 = (Keyword)cGroup.eContents().get(2);
+
+ //OptionalSequence:
+ // "[" definitionList+=DefinitionList "]";
+ public ParserRule getRule() { return rule; }
+
+ //"[" definitionList+=DefinitionList "]"
+ public Group getGroup() { return cGroup; }
+
+ //"["
+ public Keyword getLeftSquareBracketKeyword_0() { return cLeftSquareBracketKeyword_0; }
+
+ //definitionList+=DefinitionList
+ public Assignment getDefinitionListAssignment_1() { return cDefinitionListAssignment_1; }
+
+ //DefinitionList
+ public RuleCall getDefinitionListDefinitionListParserRuleCall_1_0() { return cDefinitionListDefinitionListParserRuleCall_1_0; }
+
+ //"]"
+ public Keyword getRightSquareBracketKeyword_2() { return cRightSquareBracketKeyword_2; }
+ }
+
+ public class RepeatedSequenceElements extends AbstractParserRuleElementFinder {
+ private final ParserRule rule = (ParserRule) GrammarUtil.findRuleForName(getGrammar(), "RepeatedSequence");
+ private final Group cGroup = (Group)rule.eContents().get(1);
+ private final Keyword cLeftCurlyBracketKeyword_0 = (Keyword)cGroup.eContents().get(0);
+ private final Assignment cDefinitionsAssignment_1 = (Assignment)cGroup.eContents().get(1);
+ private final RuleCall cDefinitionsDefinitionListParserRuleCall_1_0 = (RuleCall)cDefinitionsAssignment_1.eContents().get(0);
+ private final Keyword cRightCurlyBracketKeyword_2 = (Keyword)cGroup.eContents().get(2);
+ private final Assignment cMorethanonceAssignment_3 = (Assignment)cGroup.eContents().get(3);
+ private final Keyword cMorethanoncePlusSignKeyword_3_0 = (Keyword)cMorethanonceAssignment_3.eContents().get(0);
+
+ //RepeatedSequence:
+ // "{" definitions+=DefinitionList "}" morethanonce?="+"?;
+ public ParserRule getRule() { return rule; }
+
+ //"{" definitions+=DefinitionList "}" morethanonce?="+"?
+ public Group getGroup() { return cGroup; }
+
+ //"{"
+ public Keyword getLeftCurlyBracketKeyword_0() { return cLeftCurlyBracketKeyword_0; }
+
+ //definitions+=DefinitionList
+ public Assignment getDefinitionsAssignment_1() { return cDefinitionsAssignment_1; }
+
+ //DefinitionList
+ public RuleCall getDefinitionsDefinitionListParserRuleCall_1_0() { return cDefinitionsDefinitionListParserRuleCall_1_0; }
+
+ //"}"
+ public Keyword getRightCurlyBracketKeyword_2() { return cRightCurlyBracketKeyword_2; }
+
+ //morethanonce?="+"?
+ public Assignment getMorethanonceAssignment_3() { return cMorethanonceAssignment_3; }
+
+ //"+"
+ public Keyword getMorethanoncePlusSignKeyword_3_0() { return cMorethanoncePlusSignKeyword_3_0; }
+ }
+
+
+ private EtsiBnfElements pEtsiBnf;
+ private ImportSectionElements pImportSection;
+ private BnfEntryElements pBnfEntry;
+ private DeltaEntryElements pDeltaEntry;
+ private MergeEntryElements pMergeEntry;
+ private SectionHeadingElements pSectionHeading;
+ private ImportElements pImport;
+ private RuleElements pRule;
+ private ExtRuleElements pExtRule;
+ private MergeRuleElements pMergeRule;
+ private GlobalCombinatorElements pGlobalCombinator;
+ private RuleCombinatorElements pRuleCombinator;
+ private HookCombinatorElements pHookCombinator;
+ private DefinitionListElements pDefinitionList;
+ private SingleDefinitionElements pSingleDefinition;
+ private TermElements pTerm;
+ private AtomElements pAtom;
+ private RuleReferenceElements pRuleReference;
+ private StringRuleElements pStringRule;
+ private GroupedSequenceElements pGroupedSequence;
+ private OptionalSequenceElements pOptionalSequence;
+ private RepeatedSequenceElements pRepeatedSequence;
+ private TerminalRule tID;
+ private TerminalRule tINT;
+ private TerminalRule tWS;
+ private TerminalRule tCOLON;
+ private TerminalRule tSTRING;
+ private TerminalRule tSECTIONHEADER;
+ private TerminalRule tSL_COMMENT;
+ private TerminalRule tML_COMMENT;
+ private TerminalRule tLOGIC;
+
+ private final Grammar grammar;
+
+ @Inject
+ public EbnfGrammarAccess(GrammarProvider grammarProvider) {
+ this.grammar = internalFindGrammar(grammarProvider);
+ }
+
+ protected Grammar internalFindGrammar(GrammarProvider grammarProvider) {
+ Grammar grammar = grammarProvider.getGrammar(this);
+ while (grammar != null) {
+ if ("de.ugoe.cs.swe.bnftools.Ebnf".equals(grammar.getName())) {
+ return grammar;
+ }
+ List grammars = grammar.getUsedGrammars();
+ if (!grammars.isEmpty()) {
+ grammar = grammars.iterator().next();
+ } else {
+ return null;
+ }
+ }
+ return grammar;
+ }
+
+
+ public Grammar getGrammar() {
+ return grammar;
+ }
+
+
+
+ //// -----------------------------------------------------------------------------------------------
+ //// Parser Rules
+ //// -----------------------------------------------------------------------------------------------
+ //EtsiBnf:
+ // "grammar" name=ID (type="/bnf"? ";" importSection=ImportSection? bnfEntry+=BnfEntry+) | type="/delta" ";"
+ // importSection=ImportSection? deltaEntry+=DeltaEntry* | type="/merge" ";" importSection=ImportSection?
+ // mergeEntry+=MergeEntry*;
+ public EtsiBnfElements getEtsiBnfAccess() {
+ return (pEtsiBnf != null) ? pEtsiBnf : (pEtsiBnf = new EtsiBnfElements());
+ }
+
+ public ParserRule getEtsiBnfRule() {
+ return getEtsiBnfAccess().getRule();
+ }
+
+ //ImportSection:
+ // imports+=Import+;
+ public ImportSectionElements getImportSectionAccess() {
+ return (pImportSection != null) ? pImportSection : (pImportSection = new ImportSectionElements());
+ }
+
+ public ParserRule getImportSectionRule() {
+ return getImportSectionAccess().getRule();
+ }
+
+ //BnfEntry:
+ // sectionheader=SectionHeading | rule=Rule;
+ public BnfEntryElements getBnfEntryAccess() {
+ return (pBnfEntry != null) ? pBnfEntry : (pBnfEntry = new BnfEntryElements());
+ }
+
+ public ParserRule getBnfEntryRule() {
+ return getBnfEntryAccess().getRule();
+ }
+
+ //DeltaEntry:
+ // rule=Rule | sectionheader=SectionHeading | extRule=ExtRule;
+ public DeltaEntryElements getDeltaEntryAccess() {
+ return (pDeltaEntry != null) ? pDeltaEntry : (pDeltaEntry = new DeltaEntryElements());
+ }
+
+ public ParserRule getDeltaEntryRule() {
+ return getDeltaEntryAccess().getRule();
+ }
+
+ //MergeEntry:
+ // sectionheader=SectionHeading | mergeRule=MergeRule;
+ public MergeEntryElements getMergeEntryAccess() {
+ return (pMergeEntry != null) ? pMergeEntry : (pMergeEntry = new MergeEntryElements());
+ }
+
+ public ParserRule getMergeEntryRule() {
+ return getMergeEntryAccess().getRule();
+ }
+
+ //SectionHeading:
+ // {SectionHeading} sectionHeader=SECTIONHEADER;
+ public SectionHeadingElements getSectionHeadingAccess() {
+ return (pSectionHeading != null) ? pSectionHeading : (pSectionHeading = new SectionHeadingElements());
+ }
+
+ public ParserRule getSectionHeadingRule() {
+ return getSectionHeadingAccess().getRule();
+ }
+
+ //Import:
+ // "import" importURI=STRING ("/" (grammarType="core" | grammarType="package" | grammarType="update"))? ("label:"
+ // label=ID)? ";";
+ public ImportElements getImportAccess() {
+ return (pImport != null) ? pImport : (pImport = new ImportElements());
+ }
+
+ public ParserRule getImportRule() {
+ return getImportAccess().getRule();
+ }
+
+ //Rule:
+ // (rulenumber=INT rulevariant=ID? ".")? name=ID "::=" definitionList=DefinitionList? ";"?;
+ public RuleElements getRuleAccess() {
+ return (pRule != null) ? pRule : (pRule = new RuleElements());
+ }
+
+ public ParserRule getRuleRule() {
+ return getRuleAccess().getRule();
+ }
+
+ //ExtRule:
+ // (rulenumber=INT rulevariant=ID? ".")? name=ID ("(" ruleext=INT ")") "<-" (elements+=Atom | ")" | "]" | "}" | "|" |
+ // "(" | "[" | "{" | "*" | "+")* ";"?;
+ public ExtRuleElements getExtRuleAccess() {
+ return (pExtRule != null) ? pExtRule : (pExtRule = new ExtRuleElements());
+ }
+
+ public ParserRule getExtRuleRule() {
+ return getExtRuleAccess().getRule();
+ }
+
+ //MergeRule:
+ // GlobalCombinator | RuleCombinator | HookCombinator;
+ public MergeRuleElements getMergeRuleAccess() {
+ return (pMergeRule != null) ? pMergeRule : (pMergeRule = new MergeRuleElements());
+ }
+
+ public ParserRule getMergeRuleRule() {
+ return getMergeRuleAccess().getRule();
+ }
+
+ //GlobalCombinator:
+ // ("global" "combinator:") logic=LOGIC ";"?;
+ public GlobalCombinatorElements getGlobalCombinatorAccess() {
+ return (pGlobalCombinator != null) ? pGlobalCombinator : (pGlobalCombinator = new GlobalCombinatorElements());
+ }
+
+ public ParserRule getGlobalCombinatorRule() {
+ return getGlobalCombinatorAccess().getRule();
+ }
+
+ //RuleCombinator:
+ // ("rule" "combinator:" name=ID) logic=LOGIC ("(" LABEL+=STRING ")")* ";"?;
+ public RuleCombinatorElements getRuleCombinatorAccess() {
+ return (pRuleCombinator != null) ? pRuleCombinator : (pRuleCombinator = new RuleCombinatorElements());
+ }
+
+ public ParserRule getRuleCombinatorRule() {
+ return getRuleCombinatorAccess().getRule();
+ }
+
+ //HookCombinator:
+ // "hook" "combinator:" name=ID "(" ruleext=INT ")" logic=LOGIC? ("(" LABEL+=STRING ")")+ ";"?;
+ public HookCombinatorElements getHookCombinatorAccess() {
+ return (pHookCombinator != null) ? pHookCombinator : (pHookCombinator = new HookCombinatorElements());
+ }
+
+ public ParserRule getHookCombinatorRule() {
+ return getHookCombinatorAccess().getRule();
+ }
+
+ //DefinitionList:
+ // singleDefinition+=SingleDefinition ("|" singleDefinition+=SingleDefinition)*;
+ public DefinitionListElements getDefinitionListAccess() {
+ return (pDefinitionList != null) ? pDefinitionList : (pDefinitionList = new DefinitionListElements());
+ }
+
+ public ParserRule getDefinitionListRule() {
+ return getDefinitionListAccess().getRule();
+ }
+
+ //SingleDefinition:
+ // terms+=Term+;
+ public SingleDefinitionElements getSingleDefinitionAccess() {
+ return (pSingleDefinition != null) ? pSingleDefinition : (pSingleDefinition = new SingleDefinitionElements());
+ }
+
+ public ParserRule getSingleDefinitionRule() {
+ return getSingleDefinitionAccess().getRule();
+ }
+
+ //Term:
+ // termAtom=Atom | termGroupedSequence=GroupedSequence | termOptionalSequence=OptionalSequence |
+ // termRepeatedSequence=RepeatedSequence;
+ public TermElements getTermAccess() {
+ return (pTerm != null) ? pTerm : (pTerm = new TermElements());
+ }
+
+ public ParserRule getTermRule() {
+ return getTermAccess().getRule();
+ }
+
+ //Atom:
+ // atomStringRule=StringRule | atomRuleReference=RuleReference;
+ public AtomElements getAtomAccess() {
+ return (pAtom != null) ? pAtom : (pAtom = new AtomElements());
+ }
+
+ public ParserRule getAtomRule() {
+ return getAtomAccess().getRule();
+ }
+
+ //RuleReference:
+ // ruleref=[Rule];
+ public RuleReferenceElements getRuleReferenceAccess() {
+ return (pRuleReference != null) ? pRuleReference : (pRuleReference = new RuleReferenceElements());
+ }
+
+ public ParserRule getRuleReferenceRule() {
+ return getRuleReferenceAccess().getRule();
+ }
+
+ //StringRule:
+ // literal=STRING | colon=COLON;
+ public StringRuleElements getStringRuleAccess() {
+ return (pStringRule != null) ? pStringRule : (pStringRule = new StringRuleElements());
+ }
+
+ public ParserRule getStringRuleRule() {
+ return getStringRuleAccess().getRule();
+ }
+
+ //GroupedSequence:
+ // "(" definitionList+=DefinitionList ")";
+ public GroupedSequenceElements getGroupedSequenceAccess() {
+ return (pGroupedSequence != null) ? pGroupedSequence : (pGroupedSequence = new GroupedSequenceElements());
+ }
+
+ public ParserRule getGroupedSequenceRule() {
+ return getGroupedSequenceAccess().getRule();
+ }
+
+ //OptionalSequence:
+ // "[" definitionList+=DefinitionList "]";
+ public OptionalSequenceElements getOptionalSequenceAccess() {
+ return (pOptionalSequence != null) ? pOptionalSequence : (pOptionalSequence = new OptionalSequenceElements());
+ }
+
+ public ParserRule getOptionalSequenceRule() {
+ return getOptionalSequenceAccess().getRule();
+ }
+
+ //RepeatedSequence:
+ // "{" definitions+=DefinitionList "}" morethanonce?="+"?;
+ public RepeatedSequenceElements getRepeatedSequenceAccess() {
+ return (pRepeatedSequence != null) ? pRepeatedSequence : (pRepeatedSequence = new RepeatedSequenceElements());
+ }
+
+ public ParserRule getRepeatedSequenceRule() {
+ return getRepeatedSequenceAccess().getRule();
+ }
+
+ //// -----------------------------------------------------------------------------------------------
+ //// Lexer Rules
+ //// -----------------------------------------------------------------------------------------------
+ //terminal ID:
+ // ("a".."z" | "A".."Z" | "_") ("a".."z" | "A".."Z" | "0".."9" | "_")*;
+ public TerminalRule getIDRule() {
+ return (tID != null) ? tID : (tID = (TerminalRule) GrammarUtil.findRuleForName(getGrammar(), "ID"));
+ }
+
+ //terminal INT returns ecore::EInt:
+ // "0".."9"+;
+ public TerminalRule getINTRule() {
+ return (tINT != null) ? tINT : (tINT = (TerminalRule) GrammarUtil.findRuleForName(getGrammar(), "INT"));
+ }
+
+ //terminal WS:
+ // (" " | "\t" | "\r"? "\n")+;
+ public TerminalRule getWSRule() {
+ return (tWS != null) ? tWS : (tWS = (TerminalRule) GrammarUtil.findRuleForName(getGrammar(), "WS"));
+ }
+
+ //terminal COLON:
+ // "\"" "\"" "\"";
+ public TerminalRule getCOLONRule() {
+ return (tCOLON != null) ? tCOLON : (tCOLON = (TerminalRule) GrammarUtil.findRuleForName(getGrammar(), "COLON"));
+ }
+
+ //terminal STRING:
+ // "\"" !"\""* "\"" | "\'" !"\'"* "\'";
+ public TerminalRule getSTRINGRule() {
+ return (tSTRING != null) ? tSTRING : (tSTRING = (TerminalRule) GrammarUtil.findRuleForName(getGrammar(), "STRING"));
+ }
+
+ //terminal SECTIONHEADER:
+ // ("a".."z" | "A".."Z") ("." | "0".."9")+ (" " | "\t") !("\n" | "\r")* "\r"? "\n";
+ public TerminalRule getSECTIONHEADERRule() {
+ return (tSECTIONHEADER != null) ? tSECTIONHEADER : (tSECTIONHEADER = (TerminalRule) GrammarUtil.findRuleForName(getGrammar(), "SECTIONHEADER"));
+ }
+
+ //terminal SL_COMMENT:
+ // "//" !("\n" | "\r")* ("\r"? "\n")?;
+ public TerminalRule getSL_COMMENTRule() {
+ return (tSL_COMMENT != null) ? tSL_COMMENT : (tSL_COMMENT = (TerminalRule) GrammarUtil.findRuleForName(getGrammar(), "SL_COMMENT"));
+ }
+
+ //terminal ML_COMMENT:
+ // "/ *"->"* /";
+ public TerminalRule getML_COMMENTRule() {
+ return (tML_COMMENT != null) ? tML_COMMENT : (tML_COMMENT = (TerminalRule) GrammarUtil.findRuleForName(getGrammar(), "ML_COMMENT"));
+ }
+
+ ////TODO: a more intuitive notation
+ //terminal LOGIC:
+ // "/and" | "/or" | "/andr" | "/orr" | "/any" | "/together";
+ public TerminalRule getLOGICRule() {
+ return (tLOGIC != null) ? tLOGIC : (tLOGIC = (TerminalRule) GrammarUtil.findRuleForName(getGrammar(), "LOGIC"));
+ }
+}
Index: /v2/trunk/de.ugoe.cs.swe.bnftools.ebnf/src-gen/de/ugoe/cs/swe/bnftools/validation/AbstractEbnfValidator.java
===================================================================
--- /v2/trunk/de.ugoe.cs.swe.bnftools.ebnf/src-gen/de/ugoe/cs/swe/bnftools/validation/AbstractEbnfValidator.java (revision 61)
+++ /v2/trunk/de.ugoe.cs.swe.bnftools.ebnf/src-gen/de/ugoe/cs/swe/bnftools/validation/AbstractEbnfValidator.java (revision 61)
@@ -0,0 +1,18 @@
+/*
+ * generated by Xtext
+ */
+package de.ugoe.cs.swe.bnftools.validation;
+
+import java.util.ArrayList;
+import java.util.List;
+import org.eclipse.emf.ecore.EPackage;
+
+public class AbstractEbnfValidator extends org.eclipse.xtext.validation.AbstractDeclarativeValidator {
+
+ @Override
+ protected List getEPackages() {
+ List result = new ArrayList();
+ result.add(de.ugoe.cs.swe.bnftools.ebnf.EbnfPackage.eINSTANCE);
+ return result;
+ }
+}
Index: /v2/trunk/de.ugoe.cs.swe.bnftools.ebnf/src/de/ugoe/cs/swe/bnftools/EBNF.xtext
===================================================================
--- /v2/trunk/de.ugoe.cs.swe.bnftools.ebnf/src/de/ugoe/cs/swe/bnftools/EBNF.xtext (revision 61)
+++ /v2/trunk/de.ugoe.cs.swe.bnftools.ebnf/src/de/ugoe/cs/swe/bnftools/EBNF.xtext (revision 61)
@@ -0,0 +1,137 @@
+grammar de.ugoe.cs.swe.bnftools.Ebnf hidden(WS, ML_COMMENT, SL_COMMENT)
+
+import "http://www.eclipse.org/emf/2002/Ecore" as ecore
+
+generate ebnf "http://www.ugoe.de/cs/swe/bnftools/Ebnf"
+
+// -----------------------------------------------------------------------------------------------
+// Parser Rules
+// -----------------------------------------------------------------------------------------------
+EtsiBnf:
+ 'grammar' name=ID
+ ( type='/bnf'? ';'
+ (importSection=ImportSection)?
+ (bnfEntry+=BnfEntry)+
+ )
+ |
+ ( type='/delta' ';'
+ (importSection=ImportSection)?
+ (deltaEntry+=DeltaEntry)*
+ )
+ |
+ ( type='/merge' ';'
+ (importSection=ImportSection)?
+ (mergeEntry+=MergeEntry)*
+ )
+;
+
+ImportSection:
+ (imports+=Import)+
+;
+
+BnfEntry:
+ sectionheader=SectionHeading | rule=Rule
+;
+
+DeltaEntry:
+ rule=Rule | sectionheader=SectionHeading | extRule=ExtRule
+;
+
+MergeEntry:
+ sectionheader=SectionHeading | mergeRule=MergeRule
+;
+
+SectionHeading:
+ {SectionHeading}
+ sectionHeader=SECTIONHEADER
+;
+
+
+Import :
+ 'import' importURI=STRING
+ ('/' (grammarType='core' | grammarType='package' | grammarType='update'))?
+ ('label:' label=ID)? ';'
+;
+
+Rule:
+ (rulenumber=INT (rulevariant=ID)? '.')? name=ID '::=' (definitionList=DefinitionList)? ';'?
+;
+
+ExtRule:
+ (rulenumber=INT (rulevariant=ID)? '.')? name=ID ('(' ruleext=INT ')') '<-'
+ (elements+=Atom | ')' | ']' | '}' | '|' | '(' | '[' | '{' | '*' | '+')* ';'?
+;
+
+MergeRule:
+ GlobalCombinator
+ | RuleCombinator
+ | HookCombinator
+;
+
+GlobalCombinator:
+('global' 'combinator:') logic=LOGIC ';'?
+;
+
+RuleCombinator:
+('rule' 'combinator:' name=ID ) logic=LOGIC ('(' LABEL+=STRING ')')* ';'?
+;
+
+HookCombinator:
+'hook' 'combinator:' name=ID '(' ruleext=INT ')' (logic=LOGIC)? ('(' LABEL+=STRING ')')+ ';'?
+;
+
+DefinitionList:
+ singleDefinition+=SingleDefinition ('|' singleDefinition+=SingleDefinition)*
+;
+
+SingleDefinition:
+ (terms+=Term)+
+;
+
+Term:
+ termAtom=Atom
+ | termGroupedSequence=GroupedSequence
+ | termOptionalSequence=OptionalSequence
+ | termRepeatedSequence=RepeatedSequence
+;
+
+Atom:
+ atomStringRule=StringRule
+ | atomRuleReference=RuleReference
+;
+
+RuleReference:
+ ruleref=[Rule]
+;
+
+StringRule:
+ literal=STRING
+ | colon=COLON
+;
+
+GroupedSequence:
+ '(' definitionList+=DefinitionList ')'
+;
+
+OptionalSequence:
+ '[' definitionList+=DefinitionList ']'
+;
+
+RepeatedSequence:
+ '{' definitions+=DefinitionList '}' morethanonce?='+'?
+;
+
+// -----------------------------------------------------------------------------------------------
+// Lexer Rules
+// -----------------------------------------------------------------------------------------------
+
+terminal ID : ('a'..'z'|'A'..'Z'|'_') ('a'..'z'|'A'..'Z'|'0'..'9'|'_')* ;
+terminal INT returns ecore::EInt: ('0'..'9')+;
+terminal WS : (' '|'\t'|'\r'? '\n')+;
+terminal COLON : '"' '"' '"';
+terminal STRING : '"' !('"')* '"' | "'" !("'")*"'";
+terminal SECTIONHEADER: ('a'..'z'|'A'..'Z') ('.'|('0'..'9'))+ (' '|'\t') !('\n'|'\r')* '\r'? '\n';
+terminal SL_COMMENT : '//' !('\n'|'\r')* ('\r'? '\n')?;
+terminal ML_COMMENT : '/*' -> '*/';
+//TODO: a more intuitive notation
+terminal LOGIC : '/and' | '/or' | '/andr' | '/orr' | '/any' | '/together' ;
Index: /v2/trunk/de.ugoe.cs.swe.bnftools.ebnf/src/de/ugoe/cs/swe/bnftools/EbnfRuntimeModule.java
===================================================================
--- /v2/trunk/de.ugoe.cs.swe.bnftools.ebnf/src/de/ugoe/cs/swe/bnftools/EbnfRuntimeModule.java (revision 61)
+++ /v2/trunk/de.ugoe.cs.swe.bnftools.ebnf/src/de/ugoe/cs/swe/bnftools/EbnfRuntimeModule.java (revision 61)
@@ -0,0 +1,11 @@
+/*
+ * generated by Xtext
+ */
+package de.ugoe.cs.swe.bnftools;
+
+/**
+ * Use this class to register components to be used at runtime / without the Equinox extension registry.
+ */
+public class EbnfRuntimeModule extends de.ugoe.cs.swe.bnftools.AbstractEbnfRuntimeModule {
+
+}
Index: /v2/trunk/de.ugoe.cs.swe.bnftools.ebnf/src/de/ugoe/cs/swe/bnftools/EbnfStandaloneSetup.java
===================================================================
--- /v2/trunk/de.ugoe.cs.swe.bnftools.ebnf/src/de/ugoe/cs/swe/bnftools/EbnfStandaloneSetup.java (revision 61)
+++ /v2/trunk/de.ugoe.cs.swe.bnftools.ebnf/src/de/ugoe/cs/swe/bnftools/EbnfStandaloneSetup.java (revision 61)
@@ -0,0 +1,16 @@
+/*
+* generated by Xtext
+*/
+package de.ugoe.cs.swe.bnftools;
+
+/**
+ * Initialization support for running Xtext languages
+ * without equinox extension registry
+ */
+public class EbnfStandaloneSetup extends EbnfStandaloneSetupGenerated{
+
+ public static void doSetup() {
+ new EbnfStandaloneSetup().createInjectorAndDoEMFRegistration();
+ }
+}
+
Index: /v2/trunk/de.ugoe.cs.swe.bnftools.ebnf/src/de/ugoe/cs/swe/bnftools/GenerateEBNF.mwe2
===================================================================
--- /v2/trunk/de.ugoe.cs.swe.bnftools.ebnf/src/de/ugoe/cs/swe/bnftools/GenerateEBNF.mwe2 (revision 61)
+++ /v2/trunk/de.ugoe.cs.swe.bnftools.ebnf/src/de/ugoe/cs/swe/bnftools/GenerateEBNF.mwe2 (revision 61)
@@ -0,0 +1,130 @@
+module de.ugoe.cs.swe.bnftools.GenerateEBNF
+
+import org.eclipse.emf.mwe.utils.*
+import org.eclipse.xtext.generator.*
+import org.eclipse.xtext.ui.generator.*
+
+var grammarURI = "classpath:/de/ugoe/cs/swe/bnftools/EBNF.xtext"
+var fileExtensions = "bnf"
+var projectName = "de.ugoe.cs.swe.bnftools.ebnf"
+var runtimeProject = "../${projectName}"
+var generateXtendStub = true
+var encoding = "UTF-8"
+
+Workflow {
+ bean = StandaloneSetup {
+ scanClassPath = true
+ platformUri = "${runtimeProject}/.."
+ // The following two lines can be removed, if Xbase is not used.
+ registerGeneratedEPackage = "org.eclipse.xtext.xbase.XbasePackage"
+ registerGenModelFile = "platform:/resource/org.eclipse.xtext.xbase/model/Xbase.genmodel"
+ }
+
+ component = DirectoryCleaner {
+ directory = "${runtimeProject}/src-gen"
+ }
+
+ component = DirectoryCleaner {
+ directory = "${runtimeProject}/model"
+ }
+
+ component = DirectoryCleaner {
+ directory = "${runtimeProject}.ui/src-gen"
+ }
+
+ component = DirectoryCleaner {
+ directory = "${runtimeProject}.tests/src-gen"
+ }
+
+ component = Generator {
+ pathRtProject = runtimeProject
+ pathUiProject = "${runtimeProject}.ui"
+ pathTestProject = "${runtimeProject}.tests"
+ projectNameRt = projectName
+ projectNameUi = "${projectName}.ui"
+ encoding = encoding
+ language = auto-inject {
+ uri = grammarURI
+
+ // Java API to access grammar elements (required by several other fragments)
+ fragment = grammarAccess.GrammarAccessFragment auto-inject {}
+
+ // generates Java API for the generated EPackages
+ fragment = ecore.EMFGeneratorFragment auto-inject {}
+
+ // the old serialization component
+ // fragment = parseTreeConstructor.ParseTreeConstructorFragment auto-inject {}
+
+ // serializer 2.0
+ fragment = serializer.SerializerFragment auto-inject {
+ generateStub = false
+ }
+
+ // a custom ResourceFactory for use with EMF
+ fragment = resourceFactory.ResourceFactoryFragment auto-inject {}
+
+ // The antlr parser generator fragment.
+ fragment = parser.antlr.XtextAntlrGeneratorFragment auto-inject {
+ // options = {
+ // backtrack = true
+ // }
+ }
+
+ // Xtend-based API for validation
+ fragment = validation.ValidatorFragment auto-inject {
+ // composedCheck = "org.eclipse.xtext.validation.ImportUriValidator"
+ // composedCheck = "org.eclipse.xtext.validation.NamesAreUniqueValidator"
+ }
+
+ // old scoping and exporting API
+ // fragment = scoping.ImportURIScopingFragment auto-inject {}
+ // fragment = exporting.SimpleNamesFragment auto-inject {}
+
+ // scoping and exporting API
+ fragment = scoping.ImportNamespacesScopingFragment auto-inject {}
+ fragment = exporting.QualifiedNamesFragment auto-inject {}
+ fragment = builder.BuilderIntegrationFragment auto-inject {}
+
+ // generator API
+ fragment = generator.GeneratorFragment auto-inject {}
+
+ // formatter API
+ fragment = formatting.FormatterFragment auto-inject {}
+
+ // labeling API
+ fragment = labeling.LabelProviderFragment auto-inject {}
+
+ // outline API
+ fragment = outline.OutlineTreeProviderFragment auto-inject {}
+ fragment = outline.QuickOutlineFragment auto-inject {}
+
+ // quickfix API
+ fragment = quickfix.QuickfixProviderFragment auto-inject {}
+
+ // content assist API
+ fragment = contentAssist.ContentAssistFragment auto-inject {}
+
+ // generates a more lightweight Antlr parser and lexer tailored for content assist
+ fragment = parser.antlr.XtextAntlrUiGeneratorFragment auto-inject {}
+
+ // generates junit test support classes into Generator#pathTestProject
+ fragment = junit.Junit4Fragment auto-inject {}
+
+ // rename refactoring
+ fragment = refactoring.RefactorElementNameFragment auto-inject {}
+
+ // provides the necessary bindings for java types integration
+ fragment = types.TypesGeneratorFragment auto-inject {}
+
+ // generates the required bindings only if the grammar inherits from Xbase
+ fragment = xbase.XbaseGeneratorFragment auto-inject {}
+
+ // provides a preference page for template proposals
+ fragment = templates.CodetemplatesGeneratorFragment auto-inject {}
+
+ // provides a compare view
+ fragment = compare.CompareFragment auto-inject {}
+ }
+ }
+}
+
Index: /v2/trunk/de.ugoe.cs.swe.bnftools.ebnf/src/de/ugoe/cs/swe/bnftools/formatting/EbnfFormatter.xtend
===================================================================
--- /v2/trunk/de.ugoe.cs.swe.bnftools.ebnf/src/de/ugoe/cs/swe/bnftools/formatting/EbnfFormatter.xtend (revision 61)
+++ /v2/trunk/de.ugoe.cs.swe.bnftools.ebnf/src/de/ugoe/cs/swe/bnftools/formatting/EbnfFormatter.xtend (revision 61)
@@ -0,0 +1,41 @@
+/*
+ * generated by Xtext
+ */
+package de.ugoe.cs.swe.bnftools.formatting
+
+import com.google.inject.Inject
+import de.ugoe.cs.swe.bnftools.services.EbnfGrammarAccess
+import org.eclipse.xtext.Keyword
+import org.eclipse.xtext.formatting.impl.AbstractDeclarativeFormatter
+import org.eclipse.xtext.formatting.impl.FormattingConfig
+
+/**
+ * This class contains custom formatting description.
+ *
+ * see : http://www.eclipse.org/Xtext/documentation.html#formatting
+ * on how and when to use it
+ *
+ * Also see {@link org.eclipse.xtext.xtext.XtextFormattingTokenSerializer} as an example
+ */
+class EbnfFormatter extends AbstractDeclarativeFormatter {
+
+ @Inject extension EbnfGrammarAccess
+
+ override protected void configureFormatting(FormattingConfig c) {
+
+ // They will add and preserve newlines around comments
+ c.setLinewrap(0, 1, 2).before(SL_COMMENTRule)
+ c.setLinewrap(0, 1, 2).before(ML_COMMENTRule)
+ c.setLinewrap(0, 1, 1).after(ML_COMMENTRule)
+
+
+ var EbnfGrammarAccess f = getGrammarAccess as EbnfGrammarAccess;
+ c.setLinewrap.before(f.ruleRule);
+ c.setLinewrap.before(f.importRule);
+// //c.setLinewrap.after(f.);
+// for (Keyword bar : f.findKeywords("|")) {
+// c.setSpace("\n\t\t").before(bar);
+// }
+
+ }
+}
Index: /v2/trunk/de.ugoe.cs.swe.bnftools.ebnf/src/de/ugoe/cs/swe/bnftools/generator/EbnfGenerator.xtend
===================================================================
--- /v2/trunk/de.ugoe.cs.swe.bnftools.ebnf/src/de/ugoe/cs/swe/bnftools/generator/EbnfGenerator.xtend (revision 61)
+++ /v2/trunk/de.ugoe.cs.swe.bnftools.ebnf/src/de/ugoe/cs/swe/bnftools/generator/EbnfGenerator.xtend (revision 61)
@@ -0,0 +1,87 @@
+/*
+ * generated by Xtext
+ */
+package de.ugoe.cs.swe.bnftools.generator
+
+import org.eclipse.emf.ecore.resource.Resource
+import org.eclipse.xtext.generator.IGenerator
+import org.eclipse.xtext.generator.IFileSystemAccess
+import de.ugoe.cs.swe.bnftools.ebnf.EtsiBnf
+import de.ugoe.cs.swe.bnftools.ebnf.BnfEntry
+import de.ugoe.cs.swe.bnftools.ebnf.Rule
+import de.ugoe.cs.swe.bnftools.ebnf.DefinitionList
+import de.ugoe.cs.swe.bnftools.ebnf.SingleDefinition
+import de.ugoe.cs.swe.bnftools.ebnf.Term
+import de.ugoe.cs.swe.bnftools.ebnf.GroupedSequence
+import de.ugoe.cs.swe.bnftools.ebnf.Atom
+import de.ugoe.cs.swe.bnftools.ebnf.RepeatedSequence
+import de.ugoe.cs.swe.bnftools.ebnf.OptionalSequence
+import de.ugoe.cs.swe.bnftools.ebnf.RuleReference
+import de.ugoe.cs.swe.bnftools.ebnf.StringRule
+
+/**
+ * Generates code from your model files on save.
+ *
+ * see http://www.eclipse.org/Xtext/documentation.html#TutorialCodeGeneration
+ */
+class EbnfGenerator implements IGenerator {
+ //generation of the file
+ override void doGenerate(Resource resource, IFileSystemAccess fsa) {
+ for (e : resource.allContents.toIterable.filter(EtsiBnf)) {
+ if (e.bnfEntry.size!=0) {
+ fsa.generateFile(e.name + ".fo", e.compile)
+ }
+ }
+ }
+
+ // compile the different entities of the Bnf-----------------------------------------------------------------------------
+ def compile(EtsiBnf bnf)
+ '''
+
+
+
+
+
+
+
+
+
+
+
+
+ «FOR bnfentry:bnf.bnfEntry»
+ «bnfentry.compile»
+ «ENDFOR»
+
+
+ '''
+
+ def compile(BnfEntry bnfEntry)'''
+ «IF bnfEntry.rule!= null»
+ «bnfEntry.rule.compile»
+ «ENDIF»
+ '''
+
+ def compile(Rule rule)'''«rule.name» ::= «rule.definitionList.compile»'''
+
+ def compile(DefinitionList dList)'''«FOR sDef:dList.singleDefinition»«sDef.compile»«IF !sDef.equals(dList.singleDefinition.last)» | «ENDIF»«ENDFOR»'''
+
+ def compile(SingleDefinition sDefinition)'''«FOR term:sDefinition.terms»«term.compile»«ENDFOR»'''
+
+ def compile(Term term)'''«IF term.termAtom!=null»«term.termAtom.compile»«ENDIF»«IF term.termOptionalSequence!=null»«term.termOptionalSequence.compile»«ENDIF»«IF term.termRepeatedSequence!=null»«term.termRepeatedSequence.compile»«ENDIF»«IF term.termGroupedSequence!=null»«term.termGroupedSequence.compile»«ENDIF»'''
+
+ def compile(GroupedSequence gSequ)'''«FOR d :gSequ.definitionList»«d.compile»«ENDFOR»'''
+
+ def compile(RepeatedSequence rSequ)'''{«FOR d:rSequ.definitions»«d.compile»«ENDFOR»}«IF rSequ.morethanonce»+«ENDIF»'''
+
+ def compile(OptionalSequence oSequ)'''(«FOR d:oSequ.definitionList»«d.compile»«ENDFOR»)'''
+
+ def compile(Atom atom)'''
+ «IF atom.atomRuleReference!= null»«atom.atomRuleReference.compile»«ENDIF»«IF atom.atomStringRule!= null»«atom.atomStringRule.compile»«ENDIF»'''
+
+ def compile(RuleReference rRef)'''«rRef.ruleref.name»'''
+
+ def compile(StringRule sRule)'''«IF sRule.colon!=null»«sRule.colon»«ENDIF»«IF sRule.literal!=null»«sRule.literal»«ENDIF»'''
+
+
+}
Index: /v2/trunk/de.ugoe.cs.swe.bnftools.ebnf/src/de/ugoe/cs/swe/bnftools/scoping/EbnfScopeProvider.xtend
===================================================================
--- /v2/trunk/de.ugoe.cs.swe.bnftools.ebnf/src/de/ugoe/cs/swe/bnftools/scoping/EbnfScopeProvider.xtend (revision 61)
+++ /v2/trunk/de.ugoe.cs.swe.bnftools.ebnf/src/de/ugoe/cs/swe/bnftools/scoping/EbnfScopeProvider.xtend (revision 61)
@@ -0,0 +1,15 @@
+/*
+ * generated by Xtext
+ */
+package de.ugoe.cs.swe.bnftools.scoping
+
+/**
+ * This class contains custom scoping description.
+ *
+ * see : http://www.eclipse.org/Xtext/documentation.html#scoping
+ * on how and when to use it
+ *
+ */
+class EbnfScopeProvider extends org.eclipse.xtext.scoping.impl.AbstractDeclarativeScopeProvider {
+
+}
Index: /v2/trunk/de.ugoe.cs.swe.bnftools.ebnf/src/de/ugoe/cs/swe/bnftools/validation/DuplicateEntry.java
===================================================================
--- /v2/trunk/de.ugoe.cs.swe.bnftools.ebnf/src/de/ugoe/cs/swe/bnftools/validation/DuplicateEntry.java (revision 61)
+++ /v2/trunk/de.ugoe.cs.swe.bnftools.ebnf/src/de/ugoe/cs/swe/bnftools/validation/DuplicateEntry.java (revision 61)
@@ -0,0 +1,37 @@
+package de.ugoe.cs.swe.bnftools.validation;
+
+import java.util.ArrayList;
+import java.util.List;
+
+import de.ugoe.cs.swe.bnftools.ebnf.Rule;
+
+public class DuplicateEntry {
+ String snippet;
+ List rules = new ArrayList();
+
+ public String getSnippet() {
+ return snippet;
+ }
+
+ public void setSnippet(String snippet) {
+ this.snippet = snippet;
+ }
+
+ public List getRules() {
+ return rules;
+ }
+
+ public void setRules(List rule) {
+ this.rules = rule;
+ }
+
+ public void addRule(Rule r) {
+ if (!rules.contains(r))
+ rules.add(r);
+ }
+
+ public int getMatchCount() {
+ return rules.size();
+ }
+
+}
Index: /v2/trunk/de.ugoe.cs.swe.bnftools.ebnf/src/de/ugoe/cs/swe/bnftools/validation/EbnfAnalysisUtils.java
===================================================================
--- /v2/trunk/de.ugoe.cs.swe.bnftools.ebnf/src/de/ugoe/cs/swe/bnftools/validation/EbnfAnalysisUtils.java (revision 61)
+++ /v2/trunk/de.ugoe.cs.swe.bnftools.ebnf/src/de/ugoe/cs/swe/bnftools/validation/EbnfAnalysisUtils.java (revision 61)
@@ -0,0 +1,85 @@
+package de.ugoe.cs.swe.bnftools.validation;
+
+import java.util.ArrayList;
+import java.util.List;
+
+import org.eclipse.xtext.EcoreUtil2;
+import de.ugoe.cs.swe.bnftools.ebnf.Atom;
+import de.ugoe.cs.swe.bnftools.ebnf.DefinitionList;
+import de.ugoe.cs.swe.bnftools.ebnf.EtsiBnf;
+import de.ugoe.cs.swe.bnftools.ebnf.Rule;
+import de.ugoe.cs.swe.bnftools.ebnf.RuleReference;
+import de.ugoe.cs.swe.bnftools.ebnf.SingleDefinition;
+import de.ugoe.cs.swe.bnftools.ebnf.Term;
+
+public class EbnfAnalysisUtils {
+
+ //----------------------------------------------------------------------------------------------------
+
+ static public boolean isPassthroughRule(Rule rule) {
+ DefinitionList definitionList = rule.getDefinitionList();
+ if (definitionList == null)
+ return false;
+
+ if (rule.getDefinitionList().getSingleDefinition().size() == 1) {
+ SingleDefinition element = rule.getDefinitionList().getSingleDefinition().get(0);
+ if (element.getTerms().size() == 1) {
+ Term first = element.getTerms().get(0);
+ if (first.getTermAtom() != null) {
+ Atom atom = (Atom) first.getTermAtom();
+ if (atom.getAtomRuleReference() != null)
+ return true;
+ }
+ }
+ }
+
+ return false;
+ }
+
+
+
+ //----------------------------------------------------------------------------------------------------
+
+ static public boolean isTokenRule(Rule rule) {
+ DefinitionList definitionList = rule.getDefinitionList();
+ if (definitionList == null)
+ return false;
+
+ if (rule.getDefinitionList().getSingleDefinition().size() == 1) {
+ SingleDefinition element = rule.getDefinitionList().getSingleDefinition().get(0);
+ if (element.getTerms().size() == 1) {
+ Term first = element.getTerms().get(0);
+ Atom atom = first.getTermAtom();
+ if (atom != null && atom.getAtomStringRule() != null) {
+ return true;
+ }
+ }
+ }
+
+ return false;
+ }
+
+
+
+ //----------------------------------------------------------------------------------------------------
+
+ static public List findReferences(Rule rule) {
+ List ruleReferences = new ArrayList();
+ EtsiBnf bnf = (EtsiBnf) rule.eContainer().eContainer();
+
+ List rules = EcoreUtil2.getAllContentsOfType(bnf, RuleReference.class);
+ for (RuleReference r : rules) {
+ if(r.getRuleref().getName().equals(rule.getName())){
+ ruleReferences.add(r);
+ }
+ }
+
+ return ruleReferences;
+ }
+
+ //----------------------------------------------------------------------------------------------------
+ public static List getAllRules(EtsiBnf bnf){
+ List rules = EcoreUtil2.getAllContentsOfType(bnf, Rule.class);
+ return rules;
+ }
+}
Index: /v2/trunk/de.ugoe.cs.swe.bnftools.ebnf/src/de/ugoe/cs/swe/bnftools/validation/EbnfValidator.xtend
===================================================================
--- /v2/trunk/de.ugoe.cs.swe.bnftools.ebnf/src/de/ugoe/cs/swe/bnftools/validation/EbnfValidator.xtend (revision 61)
+++ /v2/trunk/de.ugoe.cs.swe.bnftools.ebnf/src/de/ugoe/cs/swe/bnftools/validation/EbnfValidator.xtend (revision 61)
@@ -0,0 +1,196 @@
+/*
+ * generated by Xtext
+ */
+package de.ugoe.cs.swe.bnftools.validation
+
+import de.ugoe.cs.swe.bnftools.ebnf.EbnfPackage
+import java.util.List
+import org.eclipse.xtext.validation.Check
+import de.ugoe.cs.swe.bnftools.ebnf.Rule
+import org.eclipse.xtext.nodemodel.util.NodeModelUtils
+import org.eclipse.xtext.nodemodel.ICompositeNode
+import de.ugoe.cs.swe.bnftools.ebnf.EtsiBnf
+import de.ugoe.cs.swe.bnftools.ebnf.RuleReference
+import de.ugoe.cs.swe.bnftools.ebnf.DefinitionList
+import de.ugoe.cs.swe.bnftools.ebnf.SingleDefinition
+//import java.util.HashMap
+//import java.util.Set
+//import java.util.HashSet
+
+//import org.eclipse.xtext.validation.Check
+/**
+ * Custom validation rules.
+ *
+ * see http://www.eclipse.org/Xtext/documentation.html#validation
+ */
+class EbnfValidator extends AbstractEbnfValidator {
+
+ static final String ruleReferencedOneDescription = "The rule is only referenced by one other rule";
+ static final String passthroughRuleDescription = "The rule is a passthrough rule";
+ static final String unreferencedPassthroughRuleDescription = "The rule is an unreferenced passthrough rule";
+ static final String unusedRuleDescription = "The rule is not referenced anywhere";
+ static final String equalAlternativeDescription = "The rule contains equal alternatives";
+ static final String duplicateRulesDescription = "The rule is a duplicate";
+ // static final String duplicateSubRulesDescription = "A part the of rule is a duplicate";
+ static final String nonUniqueNameDescription = "The rule has the same Name as the Rule in Line ";
+
+ // ----------------------------------------------------------------------------------------------------
+ /* Checks if a rule is only referenced by one other Rule, e.g.:
+ * a ::= b
+ * b ::= "foo"
+ */
+ @Check
+ def void checkReferencedOnlyOnce(Rule rule) {
+
+ if (EbnfAnalysisUtils.isTokenRule(rule))
+ return;
+
+ var List references = EbnfAnalysisUtils.findReferences(rule);
+
+ if (references.size() == 1 && rule.rulenumber != 1) {
+ warning(ruleReferencedOneDescription, EbnfPackage$Literals::RULE__NAME);
+ }
+ }
+
+ // ----------------------------------------------------------------------------------------------------
+ /*Checks if a a rule has the same definition as another rule e.g.:
+ * a ::= "test"
+ * b ::= "test"
+ * (Problem: does not check if there is a permutation)
+ */
+ @Check
+ def void checkDuplicateRules(Rule rule) {
+
+ //load bnf
+ var EtsiBnf etsiBnf = rule.eContainer().eContainer() as EtsiBnf;
+
+ // find the rule in the parsetree
+ var ICompositeNode definitionList = NodeModelUtils.findActualNodeFor(rule.getDefinitionList());
+
+ //get the definitionList as formatted string
+ var String rightHandSideText = definitionList.text.trim().replaceAll("[ \t\n\r]", "");
+
+ //get All Rules
+ var List allRules = EbnfAnalysisUtils.getAllRules(etsiBnf);
+
+ // run through all Rules
+ for (currentRule : allRules) {
+ if (currentRule != rule) {
+ var ICompositeNode currentRuleDefinitionList = NodeModelUtils.findActualNodeFor(
+ currentRule.getDefinitionList());
+ var String currentRuleRightHandSideText = currentRuleDefinitionList.text.trim().replaceAll("[ \t\n\r]",
+ "");
+
+ if (currentRuleRightHandSideText.equals(rightHandSideText)) {
+ var String description = duplicateRulesDescription + " with rule \"" + currentRule.getName() +
+ "\" (Line " + NodeModelUtils.findActualNodeFor(currentRule).getStartLine() + ")";
+ warning(description, EbnfPackage$Literals::RULE__NAME);
+ }
+ }
+ }
+ }
+
+ // ----------------------------------------------------------------------------------------------------
+ /*Checks if a Rule got the same Name as another Rule, e.g.:
+ * a ::= "foo"
+ * a ::= "bar"
+ */
+ @Check
+ def void checkNameIsUnique(Rule rule) {
+ val EtsiBnf bnf = rule.eContainer.eContainer as EtsiBnf;
+ for (r : EbnfAnalysisUtils.getAllRules(bnf)) {
+ if (rule.name.equals(r.name)) {
+ if (!r.equals(rule)) {
+ error(nonUniqueNameDescription + NodeModelUtils.findActualNodeFor(r).startLine,
+ EbnfPackage$Literals::RULE__NAME)
+
+ }
+ }
+ }
+ }
+
+ // ----------------------------------------------------------------------------------------------------
+ /*Checks if a Rule, except for the #1 is not referenced, e.g.:
+ * a::= b
+ * b::="foo"
+ * c ::= "bar"
+ */
+ @Check
+ def void checkUnusedRule(Rule rule) {
+
+ var List references = EbnfAnalysisUtils.findReferences(rule);
+
+ if ((references.size() == 0) && (rule.getRulenumber() != 1))
+ warning(unusedRuleDescription, EbnfPackage$Literals::RULE__NAME);
+ }
+
+ // ----------------------------------------------------------------------------------------------------
+ /*Checks if a rule got two equal alternatives, e.g.:
+ * a ::= b | "foo" | b
+ *(Problem:ignores whitespaces in literals)
+ */
+ @Check
+ def void checkEqualAlternative(Rule rule) {
+
+ var DefinitionList definitionList = rule.definitionList;
+
+ var List singleDefinitions = definitionList.singleDefinition;
+
+ for (sDef1 : singleDefinitions) {
+ for (sDef2 : singleDefinitions) {
+ if (!sDef1.equals(sDef2)) {
+ var String d1 = NodeModelUtils.findActualNodeFor(sDef1).text.trim.replaceAll("[ \t\n\r]", "");
+ var String d2 = NodeModelUtils.findActualNodeFor(sDef2).text.trim.replaceAll("[ \t\n\r]", "");
+
+ if (d1.equals(d2))
+ warning(equalAlternativeDescription, EbnfPackage$Literals::RULE__NAME,equalAlternativeDescription);
+ }
+ }
+ }
+
+ }
+
+ // ----------------------------------------------------------------------------------------------------
+ /* Checks if a rule gets just passed through, e.g.:
+ * a ::= b | "literal"
+ * b ::= c
+ * c ::= "foo.bar"
+ */
+ @Check
+ def void checkPassthroughRule(Rule rule) {
+
+ var List references = EbnfAnalysisUtils.findReferences(rule);
+
+ if (EbnfAnalysisUtils.isPassthroughRule(rule)) {
+ if (references.size() == 0) {
+ warning(unreferencedPassthroughRuleDescription, EbnfPackage$Literals::RULE__NAME);
+ } else {
+ warning(passthroughRuleDescription, EbnfPackage$Literals::RULE__NAME,passthroughRuleDescription);
+ }
+ }
+ }
+
+
+ // ----------------------------------------------------------------------------------------------------
+ /* Checks if a subrule is used more then once, e.g.:
+ * a ::= (a b) e
+ * b ::= (a b) d
+ * _____
+ * (Not working, under construction)
+ */
+// @Check
+// def void checkSubruleDuplicates(EtsiBnf bnf){
+// var HashMap dupesMap = new HashMap();
+// var Set taggedEntries = new HashSet();
+//
+// var List allRules = EbnfAnalysisUtils.getAllRules(bnf);
+//
+// for(rule: allRules){
+// var List subrules = rule.definitionList.singleDefinition
+// for(subrule:subrules){
+// var String subruleText = NodeModelUtils.findActualNodeFor(subrule).text.trim.replaceAll("[ \t\n\r]", "");
+//
+// }
+// }
+// }
+}
Index: /v2/trunk/de.ugoe.cs.swe.bnftools.ebnf/src/de/ugoe/cs/swe/bnftools/validation/RuleDuplication.java
===================================================================
--- /v2/trunk/de.ugoe.cs.swe.bnftools.ebnf/src/de/ugoe/cs/swe/bnftools/validation/RuleDuplication.java (revision 61)
+++ /v2/trunk/de.ugoe.cs.swe.bnftools.ebnf/src/de/ugoe/cs/swe/bnftools/validation/RuleDuplication.java (revision 61)
@@ -0,0 +1,52 @@
+package de.ugoe.cs.swe.bnftools.validation;
+
+import java.util.ArrayList;
+import java.util.List;
+
+public class RuleDuplication {
+ List dupes = new ArrayList();
+
+ public List getDupes() {
+ return dupes;
+ }
+
+ public void setDupes(List dupes) {
+ this.dupes = dupes;
+ }
+
+ public void addDupe(DuplicateEntry dupe) {
+ dupes.add(dupe);
+ }
+
+ public List getFilteredDupes() {
+ ArrayList dupesFiltered = new ArrayList();
+
+ dupesFiltered.addAll(dupes);
+
+ boolean change = true;
+ while (change) {
+ change = false;
+ for (int i=0; i < dupesFiltered.size(); i++) {
+ for (int j=0; j < dupesFiltered.size(); j++) {
+ DuplicateEntry dupeA = dupesFiltered.get(i);
+ DuplicateEntry dupeB = dupesFiltered.get(j);
+
+ if (dupeA.getSnippet().contains(dupeB.getSnippet()) && !dupeA.getSnippet().equals(dupeB.getSnippet())) {
+ dupesFiltered.remove(j);
+ change = true;
+ } else if (dupeB.getSnippet().contains(dupeA.getSnippet()) && !dupeB.getSnippet().equals(dupeA.getSnippet())) {
+ dupesFiltered.remove(i);
+ change = true;
+ }
+ if (change)
+ break;
+ }
+ if (change)
+ break;
+ }
+ }
+
+ return dupesFiltered;
+ }
+
+}
Index: /v2/trunk/de.ugoe.cs.swe.bnftools.ebnf/xtend-gen/de/ugoe/cs/swe/bnftools/formatting/EbnfFormatter.java
===================================================================
--- /v2/trunk/de.ugoe.cs.swe.bnftools.ebnf/xtend-gen/de/ugoe/cs/swe/bnftools/formatting/EbnfFormatter.java (revision 61)
+++ /v2/trunk/de.ugoe.cs.swe.bnftools.ebnf/xtend-gen/de/ugoe/cs/swe/bnftools/formatting/EbnfFormatter.java (revision 61)
@@ -0,0 +1,48 @@
+/**
+ * generated by Xtext
+ */
+package de.ugoe.cs.swe.bnftools.formatting;
+
+import com.google.inject.Inject;
+import de.ugoe.cs.swe.bnftools.services.EbnfGrammarAccess;
+import org.eclipse.xtext.IGrammarAccess;
+import org.eclipse.xtext.ParserRule;
+import org.eclipse.xtext.TerminalRule;
+import org.eclipse.xtext.formatting.impl.AbstractDeclarativeFormatter;
+import org.eclipse.xtext.formatting.impl.FormattingConfig;
+import org.eclipse.xtext.xbase.lib.Extension;
+
+/**
+ * This class contains custom formatting description.
+ *
+ * see : http://www.eclipse.org/Xtext/documentation.html#formatting
+ * on how and when to use it
+ *
+ * Also see {@link org.eclipse.xtext.xtext.XtextFormattingTokenSerializer} as an example
+ */
+@SuppressWarnings("all")
+public class EbnfFormatter extends AbstractDeclarativeFormatter {
+ @Inject
+ @Extension
+ private EbnfGrammarAccess _ebnfGrammarAccess;
+
+ protected void configureFormatting(final FormattingConfig c) {
+ FormattingConfig.LinewrapLocator _setLinewrap = c.setLinewrap(0, 1, 2);
+ TerminalRule _sL_COMMENTRule = this._ebnfGrammarAccess.getSL_COMMENTRule();
+ _setLinewrap.before(_sL_COMMENTRule);
+ FormattingConfig.LinewrapLocator _setLinewrap_1 = c.setLinewrap(0, 1, 2);
+ TerminalRule _mL_COMMENTRule = this._ebnfGrammarAccess.getML_COMMENTRule();
+ _setLinewrap_1.before(_mL_COMMENTRule);
+ FormattingConfig.LinewrapLocator _setLinewrap_2 = c.setLinewrap(0, 1, 1);
+ TerminalRule _mL_COMMENTRule_1 = this._ebnfGrammarAccess.getML_COMMENTRule();
+ _setLinewrap_2.after(_mL_COMMENTRule_1);
+ IGrammarAccess _grammarAccess = this.getGrammarAccess();
+ EbnfGrammarAccess f = ((EbnfGrammarAccess) _grammarAccess);
+ FormattingConfig.LinewrapLocator _setLinewrap_3 = c.setLinewrap();
+ ParserRule _ruleRule = f.getRuleRule();
+ _setLinewrap_3.before(_ruleRule);
+ FormattingConfig.LinewrapLocator _setLinewrap_4 = c.setLinewrap();
+ ParserRule _importRule = f.getImportRule();
+ _setLinewrap_4.before(_importRule);
+ }
+}
Index: /v2/trunk/de.ugoe.cs.swe.bnftools.ebnf/xtend-gen/de/ugoe/cs/swe/bnftools/generator/EbnfGenerator.java
===================================================================
--- /v2/trunk/de.ugoe.cs.swe.bnftools.ebnf/xtend-gen/de/ugoe/cs/swe/bnftools/generator/EbnfGenerator.java (revision 61)
+++ /v2/trunk/de.ugoe.cs.swe.bnftools.ebnf/xtend-gen/de/ugoe/cs/swe/bnftools/generator/EbnfGenerator.java (revision 61)
@@ -0,0 +1,312 @@
+/**
+ * generated by Xtext
+ */
+package de.ugoe.cs.swe.bnftools.generator;
+
+import com.google.common.base.Objects;
+import com.google.common.collect.Iterables;
+import de.ugoe.cs.swe.bnftools.ebnf.Atom;
+import de.ugoe.cs.swe.bnftools.ebnf.BnfEntry;
+import de.ugoe.cs.swe.bnftools.ebnf.DefinitionList;
+import de.ugoe.cs.swe.bnftools.ebnf.EtsiBnf;
+import de.ugoe.cs.swe.bnftools.ebnf.GroupedSequence;
+import de.ugoe.cs.swe.bnftools.ebnf.OptionalSequence;
+import de.ugoe.cs.swe.bnftools.ebnf.RepeatedSequence;
+import de.ugoe.cs.swe.bnftools.ebnf.Rule;
+import de.ugoe.cs.swe.bnftools.ebnf.RuleReference;
+import de.ugoe.cs.swe.bnftools.ebnf.SingleDefinition;
+import de.ugoe.cs.swe.bnftools.ebnf.StringRule;
+import de.ugoe.cs.swe.bnftools.ebnf.Term;
+import org.eclipse.emf.common.util.EList;
+import org.eclipse.emf.common.util.TreeIterator;
+import org.eclipse.emf.ecore.EObject;
+import org.eclipse.emf.ecore.resource.Resource;
+import org.eclipse.xtend2.lib.StringConcatenation;
+import org.eclipse.xtext.generator.IFileSystemAccess;
+import org.eclipse.xtext.generator.IGenerator;
+import org.eclipse.xtext.xbase.lib.IterableExtensions;
+import org.eclipse.xtext.xbase.lib.IteratorExtensions;
+
+/**
+ * Generates code from your model files on save.
+ *
+ * see http://www.eclipse.org/Xtext/documentation.html#TutorialCodeGeneration
+ */
+@SuppressWarnings("all")
+public class EbnfGenerator implements IGenerator {
+ public void doGenerate(final Resource resource, final IFileSystemAccess fsa) {
+ TreeIterator _allContents = resource.getAllContents();
+ Iterable _iterable = IteratorExtensions.toIterable(_allContents);
+ Iterable _filter = Iterables.filter(_iterable, EtsiBnf.class);
+ for (final EtsiBnf e : _filter) {
+ EList _bnfEntry = e.getBnfEntry();
+ int _size = _bnfEntry.size();
+ boolean _notEquals = (_size != 0);
+ if (_notEquals) {
+ String _name = e.getName();
+ String _plus = (_name + ".fo");
+ CharSequence _compile = this.compile(e);
+ fsa.generateFile(_plus, _compile);
+ }
+ }
+ }
+
+ public CharSequence compile(final EtsiBnf bnf) {
+ StringConcatenation _builder = new StringConcatenation();
+ _builder.append("");
+ _builder.newLine();
+ _builder.append("");
+ _builder.newLine();
+ _builder.append("");
+ _builder.newLine();
+ _builder.newLine();
+ _builder.append("\t");
+ _builder.append("");
+ _builder.newLine();
+ _builder.append(" \t\t");
+ _builder.append("");
+ _builder.newLine();
+ _builder.append(" \t\t");
+ _builder.append("");
+ _builder.newLine();
+ _builder.append(" \t");
+ _builder.append("");
+ _builder.newLine();
+ _builder.append("\t");
+ _builder.append("");
+ _builder.newLine();
+ _builder.newLine();
+ _builder.append("\t");
+ _builder.append("");
+ _builder.newLine();
+ _builder.append("\t\t");
+ _builder.append("");
+ _builder.newLine();
+ {
+ EList _bnfEntry = bnf.getBnfEntry();
+ for(final BnfEntry bnfentry : _bnfEntry) {
+ _builder.append("\t\t\t");
+ CharSequence _compile = this.compile(bnfentry);
+ _builder.append(_compile, "\t\t\t");
+ _builder.newLineIfNotEmpty();
+ }
+ }
+ _builder.append("\t\t");
+ _builder.append("");
+ _builder.newLine();
+ _builder.append("\t");
+ _builder.append("");
+ _builder.newLine();
+ _builder.append("");
+ return _builder;
+ }
+
+ public CharSequence compile(final BnfEntry bnfEntry) {
+ StringConcatenation _builder = new StringConcatenation();
+ {
+ Rule _rule = bnfEntry.getRule();
+ boolean _notEquals = (!Objects.equal(_rule, null));
+ if (_notEquals) {
+ Rule _rule_1 = bnfEntry.getRule();
+ CharSequence _compile = this.compile(_rule_1);
+ _builder.append(_compile, "");
+ _builder.newLineIfNotEmpty();
+ }
+ }
+ return _builder;
+ }
+
+ public CharSequence compile(final Rule rule) {
+ StringConcatenation _builder = new StringConcatenation();
+ _builder.append("");
+ String _name_1 = rule.getName();
+ _builder.append(_name_1, "");
+ _builder.append("\t::=\t");
+ DefinitionList _definitionList = rule.getDefinitionList();
+ CharSequence _compile = this.compile(_definitionList);
+ _builder.append(_compile, "");
+ _builder.append("");
+ return _builder;
+ }
+
+ public CharSequence compile(final DefinitionList dList) {
+ StringConcatenation _builder = new StringConcatenation();
+ {
+ EList _singleDefinition = dList.getSingleDefinition();
+ for(final SingleDefinition sDef : _singleDefinition) {
+ CharSequence _compile = this.compile(sDef);
+ _builder.append(_compile, "");
+ {
+ EList _singleDefinition_1 = dList.getSingleDefinition();
+ SingleDefinition _last = IterableExtensions.last(_singleDefinition_1);
+ boolean _equals = sDef.equals(_last);
+ boolean _not = (!_equals);
+ if (_not) {
+ _builder.append(" | ");
+ }
+ }
+ }
+ }
+ return _builder;
+ }
+
+ public CharSequence compile(final SingleDefinition sDefinition) {
+ StringConcatenation _builder = new StringConcatenation();
+ {
+ EList _terms = sDefinition.getTerms();
+ for(final Term term : _terms) {
+ CharSequence _compile = this.compile(term);
+ _builder.append(_compile, "");
+ }
+ }
+ return _builder;
+ }
+
+ public CharSequence compile(final Term term) {
+ StringConcatenation _builder = new StringConcatenation();
+ {
+ Atom _termAtom = term.getTermAtom();
+ boolean _notEquals = (!Objects.equal(_termAtom, null));
+ if (_notEquals) {
+ Atom _termAtom_1 = term.getTermAtom();
+ CharSequence _compile = this.compile(_termAtom_1);
+ _builder.append(_compile, "");
+ }
+ }
+ {
+ OptionalSequence _termOptionalSequence = term.getTermOptionalSequence();
+ boolean _notEquals_1 = (!Objects.equal(_termOptionalSequence, null));
+ if (_notEquals_1) {
+ OptionalSequence _termOptionalSequence_1 = term.getTermOptionalSequence();
+ CharSequence _compile_1 = this.compile(_termOptionalSequence_1);
+ _builder.append(_compile_1, "");
+ }
+ }
+ {
+ RepeatedSequence _termRepeatedSequence = term.getTermRepeatedSequence();
+ boolean _notEquals_2 = (!Objects.equal(_termRepeatedSequence, null));
+ if (_notEquals_2) {
+ RepeatedSequence _termRepeatedSequence_1 = term.getTermRepeatedSequence();
+ CharSequence _compile_2 = this.compile(_termRepeatedSequence_1);
+ _builder.append(_compile_2, "");
+ }
+ }
+ {
+ GroupedSequence _termGroupedSequence = term.getTermGroupedSequence();
+ boolean _notEquals_3 = (!Objects.equal(_termGroupedSequence, null));
+ if (_notEquals_3) {
+ GroupedSequence _termGroupedSequence_1 = term.getTermGroupedSequence();
+ CharSequence _compile_3 = this.compile(_termGroupedSequence_1);
+ _builder.append(_compile_3, "");
+ }
+ }
+ return _builder;
+ }
+
+ public CharSequence compile(final GroupedSequence gSequ) {
+ StringConcatenation _builder = new StringConcatenation();
+ {
+ EList _definitionList = gSequ.getDefinitionList();
+ for(final DefinitionList d : _definitionList) {
+ Object _compile = this.compile(d);
+ _builder.append(_compile, "");
+ }
+ }
+ return _builder;
+ }
+
+ public CharSequence compile(final RepeatedSequence rSequ) {
+ StringConcatenation _builder = new StringConcatenation();
+ _builder.append("{");
+ {
+ EList _definitions = rSequ.getDefinitions();
+ for(final DefinitionList d : _definitions) {
+ Object _compile = this.compile(d);
+ _builder.append(_compile, "");
+ }
+ }
+ _builder.append("}");
+ {
+ boolean _isMorethanonce = rSequ.isMorethanonce();
+ if (_isMorethanonce) {
+ _builder.append("+");
+ }
+ }
+ return _builder;
+ }
+
+ public CharSequence compile(final OptionalSequence oSequ) {
+ StringConcatenation _builder = new StringConcatenation();
+ _builder.append("(");
+ {
+ EList _definitionList = oSequ.getDefinitionList();
+ for(final DefinitionList d : _definitionList) {
+ Object _compile = this.compile(d);
+ _builder.append(_compile, "");
+ }
+ }
+ _builder.append(")");
+ return _builder;
+ }
+
+ public CharSequence compile(final Atom atom) {
+ StringConcatenation _builder = new StringConcatenation();
+ {
+ RuleReference _atomRuleReference = atom.getAtomRuleReference();
+ boolean _notEquals = (!Objects.equal(_atomRuleReference, null));
+ if (_notEquals) {
+ RuleReference _atomRuleReference_1 = atom.getAtomRuleReference();
+ CharSequence _compile = this.compile(_atomRuleReference_1);
+ _builder.append(_compile, "");
+ }
+ }
+ {
+ StringRule _atomStringRule = atom.getAtomStringRule();
+ boolean _notEquals_1 = (!Objects.equal(_atomStringRule, null));
+ if (_notEquals_1) {
+ StringRule _atomStringRule_1 = atom.getAtomStringRule();
+ CharSequence _compile_1 = this.compile(_atomStringRule_1);
+ _builder.append(_compile_1, "");
+ }
+ }
+ return _builder;
+ }
+
+ public CharSequence compile(final RuleReference rRef) {
+ StringConcatenation _builder = new StringConcatenation();
+ _builder.append("");
+ Rule _ruleref_1 = rRef.getRuleref();
+ String _name_1 = _ruleref_1.getName();
+ _builder.append(_name_1, "");
+ _builder.append("");
+ return _builder;
+ }
+
+ public CharSequence compile(final StringRule sRule) {
+ StringConcatenation _builder = new StringConcatenation();
+ {
+ String _colon = sRule.getColon();
+ boolean _notEquals = (!Objects.equal(_colon, null));
+ if (_notEquals) {
+ String _colon_1 = sRule.getColon();
+ _builder.append(_colon_1, "");
+ }
+ }
+ {
+ String _literal = sRule.getLiteral();
+ boolean _notEquals_1 = (!Objects.equal(_literal, null));
+ if (_notEquals_1) {
+ String _literal_1 = sRule.getLiteral();
+ _builder.append(_literal_1, "");
+ }
+ }
+ return _builder;
+ }
+}
Index: /v2/trunk/de.ugoe.cs.swe.bnftools.ebnf/xtend-gen/de/ugoe/cs/swe/bnftools/scoping/EbnfScopeProvider.java
===================================================================
--- /v2/trunk/de.ugoe.cs.swe.bnftools.ebnf/xtend-gen/de/ugoe/cs/swe/bnftools/scoping/EbnfScopeProvider.java (revision 61)
+++ /v2/trunk/de.ugoe.cs.swe.bnftools.ebnf/xtend-gen/de/ugoe/cs/swe/bnftools/scoping/EbnfScopeProvider.java (revision 61)
@@ -0,0 +1,16 @@
+/**
+ * generated by Xtext
+ */
+package de.ugoe.cs.swe.bnftools.scoping;
+
+import org.eclipse.xtext.scoping.impl.AbstractDeclarativeScopeProvider;
+
+/**
+ * This class contains custom scoping description.
+ *
+ * see : http://www.eclipse.org/Xtext/documentation.html#scoping
+ * on how and when to use it
+ */
+@SuppressWarnings("all")
+public class EbnfScopeProvider extends AbstractDeclarativeScopeProvider {
+}
Index: /v2/trunk/de.ugoe.cs.swe.bnftools.ebnf/xtend-gen/de/ugoe/cs/swe/bnftools/validation/EbnfValidator.java
===================================================================
--- /v2/trunk/de.ugoe.cs.swe.bnftools.ebnf/xtend-gen/de/ugoe/cs/swe/bnftools/validation/EbnfValidator.java (revision 61)
+++ /v2/trunk/de.ugoe.cs.swe.bnftools.ebnf/xtend-gen/de/ugoe/cs/swe/bnftools/validation/EbnfValidator.java (revision 61)
@@ -0,0 +1,215 @@
+/**
+ * generated by Xtext
+ */
+package de.ugoe.cs.swe.bnftools.validation;
+
+import com.google.common.base.Objects;
+import de.ugoe.cs.swe.bnftools.ebnf.DefinitionList;
+import de.ugoe.cs.swe.bnftools.ebnf.EbnfPackage;
+import de.ugoe.cs.swe.bnftools.ebnf.EtsiBnf;
+import de.ugoe.cs.swe.bnftools.ebnf.Rule;
+import de.ugoe.cs.swe.bnftools.ebnf.RuleReference;
+import de.ugoe.cs.swe.bnftools.ebnf.SingleDefinition;
+import de.ugoe.cs.swe.bnftools.validation.AbstractEbnfValidator;
+import de.ugoe.cs.swe.bnftools.validation.EbnfAnalysisUtils;
+import java.util.List;
+import org.eclipse.emf.ecore.EObject;
+import org.eclipse.xtext.nodemodel.ICompositeNode;
+import org.eclipse.xtext.nodemodel.util.NodeModelUtils;
+import org.eclipse.xtext.validation.Check;
+
+/**
+ * Custom validation rules.
+ *
+ * see http://www.eclipse.org/Xtext/documentation.html#validation
+ */
+@SuppressWarnings("all")
+public class EbnfValidator extends AbstractEbnfValidator {
+ private final static String ruleReferencedOneDescription = "The rule is only referenced by one other rule";
+
+ private final static String passthroughRuleDescription = "The rule is a passthrough rule";
+
+ private final static String unreferencedPassthroughRuleDescription = "The rule is an unreferenced passthrough rule";
+
+ private final static String unusedRuleDescription = "The rule is not referenced anywhere";
+
+ private final static String equalAlternativeDescription = "The rule contains equal alternatives";
+
+ private final static String duplicateRulesDescription = "The rule is a duplicate";
+
+ private final static String nonUniqueNameDescription = "The rule has the same Name as the Rule in Line ";
+
+ /**
+ * Checks if a rule is only referenced by one other Rule, e.g.:
+ * a ::= b
+ * b ::= "foo"
+ */
+ @Check
+ public void checkReferencedOnlyOnce(final Rule rule) {
+ boolean _isTokenRule = EbnfAnalysisUtils.isTokenRule(rule);
+ if (_isTokenRule) {
+ return;
+ }
+ List references = EbnfAnalysisUtils.findReferences(rule);
+ boolean _and = false;
+ int _size = references.size();
+ boolean _equals = (_size == 1);
+ if (!_equals) {
+ _and = false;
+ } else {
+ int _rulenumber = rule.getRulenumber();
+ boolean _notEquals = (_rulenumber != 1);
+ _and = _notEquals;
+ }
+ if (_and) {
+ this.warning(EbnfValidator.ruleReferencedOneDescription, EbnfPackage.Literals.RULE__NAME);
+ }
+ }
+
+ /**
+ * Checks if a a rule has the same definition as another rule e.g.:
+ * a ::= "test"
+ * b ::= "test"
+ * (Problem: does not check if there is a permutation)
+ */
+ @Check
+ public void checkDuplicateRules(final Rule rule) {
+ EObject _eContainer = rule.eContainer();
+ EObject _eContainer_1 = _eContainer.eContainer();
+ EtsiBnf etsiBnf = ((EtsiBnf) _eContainer_1);
+ DefinitionList _definitionList = rule.getDefinitionList();
+ ICompositeNode definitionList = NodeModelUtils.findActualNodeFor(_definitionList);
+ String _text = definitionList.getText();
+ String _trim = _text.trim();
+ String rightHandSideText = _trim.replaceAll("[ \t\n\r]", "");
+ List allRules = EbnfAnalysisUtils.getAllRules(etsiBnf);
+ for (final Rule currentRule : allRules) {
+ boolean _notEquals = (!Objects.equal(currentRule, rule));
+ if (_notEquals) {
+ DefinitionList _definitionList_1 = currentRule.getDefinitionList();
+ ICompositeNode currentRuleDefinitionList = NodeModelUtils.findActualNodeFor(_definitionList_1);
+ String _text_1 = currentRuleDefinitionList.getText();
+ String _trim_1 = _text_1.trim();
+ String currentRuleRightHandSideText = _trim_1.replaceAll("[ \t\n\r]",
+ "");
+ boolean _equals = currentRuleRightHandSideText.equals(rightHandSideText);
+ if (_equals) {
+ String _name = currentRule.getName();
+ String _plus = ((EbnfValidator.duplicateRulesDescription + " with rule \"") + _name);
+ String _plus_1 = (_plus +
+ "\" (Line ");
+ ICompositeNode _findActualNodeFor = NodeModelUtils.findActualNodeFor(currentRule);
+ int _startLine = _findActualNodeFor.getStartLine();
+ String _plus_2 = (_plus_1 + Integer.valueOf(_startLine));
+ String description = (_plus_2 + ")");
+ this.warning(description, EbnfPackage.Literals.RULE__NAME);
+ }
+ }
+ }
+ }
+
+ /**
+ * Checks if a Rule got the same Name as another Rule, e.g.:
+ * a ::= "foo"
+ * a ::= "bar"
+ */
+ @Check
+ public void checkNameIsUnique(final Rule rule) {
+ EObject _eContainer = rule.eContainer();
+ EObject _eContainer_1 = _eContainer.eContainer();
+ final EtsiBnf bnf = ((EtsiBnf) _eContainer_1);
+ List _allRules = EbnfAnalysisUtils.getAllRules(bnf);
+ for (final Rule r : _allRules) {
+ String _name = rule.getName();
+ String _name_1 = r.getName();
+ boolean _equals = _name.equals(_name_1);
+ if (_equals) {
+ boolean _equals_1 = r.equals(rule);
+ boolean _not = (!_equals_1);
+ if (_not) {
+ ICompositeNode _findActualNodeFor = NodeModelUtils.findActualNodeFor(r);
+ int _startLine = _findActualNodeFor.getStartLine();
+ String _plus = (EbnfValidator.nonUniqueNameDescription + Integer.valueOf(_startLine));
+ this.error(_plus,
+ EbnfPackage.Literals.RULE__NAME);
+ }
+ }
+ }
+ }
+
+ /**
+ * Checks if a Rule, except for the #1 is not referenced, e.g.:
+ * a::= b
+ * b::="foo"
+ * c ::= "bar"
+ */
+ @Check
+ public void checkUnusedRule(final Rule rule) {
+ List references = EbnfAnalysisUtils.findReferences(rule);
+ boolean _and = false;
+ int _size = references.size();
+ boolean _equals = (_size == 0);
+ if (!_equals) {
+ _and = false;
+ } else {
+ int _rulenumber = rule.getRulenumber();
+ boolean _notEquals = (_rulenumber != 1);
+ _and = _notEquals;
+ }
+ if (_and) {
+ this.warning(EbnfValidator.unusedRuleDescription, EbnfPackage.Literals.RULE__NAME);
+ }
+ }
+
+ /**
+ * Checks if a rule got two equal alternatives, e.g.:
+ * a ::= b | "foo" | b
+ * (Problem:ignores whitespaces in literals)
+ */
+ @Check
+ public void checkEqualAlternative(final Rule rule) {
+ DefinitionList definitionList = rule.getDefinitionList();
+ List singleDefinitions = definitionList.getSingleDefinition();
+ for (final SingleDefinition sDef1 : singleDefinitions) {
+ for (final SingleDefinition sDef2 : singleDefinitions) {
+ boolean _equals = sDef1.equals(sDef2);
+ boolean _not = (!_equals);
+ if (_not) {
+ ICompositeNode _findActualNodeFor = NodeModelUtils.findActualNodeFor(sDef1);
+ String _text = _findActualNodeFor.getText();
+ String _trim = _text.trim();
+ String d1 = _trim.replaceAll("[ \t\n\r]", "");
+ ICompositeNode _findActualNodeFor_1 = NodeModelUtils.findActualNodeFor(sDef2);
+ String _text_1 = _findActualNodeFor_1.getText();
+ String _trim_1 = _text_1.trim();
+ String d2 = _trim_1.replaceAll("[ \t\n\r]", "");
+ boolean _equals_1 = d1.equals(d2);
+ if (_equals_1) {
+ this.warning(EbnfValidator.equalAlternativeDescription, EbnfPackage.Literals.RULE__NAME, EbnfValidator.equalAlternativeDescription);
+ }
+ }
+ }
+ }
+ }
+
+ /**
+ * Checks if a rule gets just passed through, e.g.:
+ * a ::= b | "literal"
+ * b ::= c
+ * c ::= "foo.bar"
+ */
+ @Check
+ public void checkPassthroughRule(final Rule rule) {
+ List references = EbnfAnalysisUtils.findReferences(rule);
+ boolean _isPassthroughRule = EbnfAnalysisUtils.isPassthroughRule(rule);
+ if (_isPassthroughRule) {
+ int _size = references.size();
+ boolean _equals = (_size == 0);
+ if (_equals) {
+ this.warning(EbnfValidator.unreferencedPassthroughRuleDescription, EbnfPackage.Literals.RULE__NAME);
+ } else {
+ this.warning(EbnfValidator.passthroughRuleDescription, EbnfPackage.Literals.RULE__NAME, EbnfValidator.passthroughRuleDescription);
+ }
+ }
+ }
+}