public class LogicalOpAliasesElements extends AbstractParserRuleElementFinder {
    private final ParserRule rule =
        (ParserRule) GrammarUtil.findRuleForName(getGrammar(), "LogicalOpAliases");
    private final Alternatives cAlternatives = (Alternatives) rule.eContents().get(1);
    private final Keyword cOrKeyword_0 = (Keyword) cAlternatives.eContents().get(0);
    private final Keyword cAndKeyword_1 = (Keyword) cAlternatives.eContents().get(1);
    private final Keyword cNotKeyword_2 = (Keyword) cAlternatives.eContents().get(2);

    // LogicalOpAliases:
    //	"or" | "and" | "not";
    public ParserRule getRule() {
      return rule;
    }

    // "or" | "and" | "not"
    public Alternatives getAlternatives() {
      return cAlternatives;
    }

    // "or"
    public Keyword getOrKeyword_0() {
      return cOrKeyword_0;
    }

    // "and"
    public Keyword getAndKeyword_1() {
      return cAndKeyword_1;
    }

    // "not"
    public Keyword getNotKeyword_2() {
      return cNotKeyword_2;
    }
  }
  public class AndElements extends AbstractParserRuleElementFinder {
    private final ParserRule rule = (ParserRule) GrammarUtil.findRuleForName(getGrammar(), "And");
    private final Group cGroup = (Group) rule.eContents().get(1);
    private final Keyword cAmpersandKeyword_0 = (Keyword) cGroup.eContents().get(0);
    private final RuleCall cHoOperandParserRuleCall_1 = (RuleCall) cGroup.eContents().get(1);

    // And:
    //	"&" HoOperand;
    public ParserRule getRule() {
      return rule;
    }

    // "&" HoOperand
    public Group getGroup() {
      return cGroup;
    }

    // "&"
    public Keyword getAmpersandKeyword_0() {
      return cAmpersandKeyword_0;
    }

    // HoOperand
    public RuleCall getHoOperandParserRuleCall_1() {
      return cHoOperandParserRuleCall_1;
    }
  }
  public class Pct_encodedElements extends AbstractParserRuleElementFinder {
    private final ParserRule rule =
        (ParserRule) GrammarUtil.findRuleForName(getGrammar(), "Pct_encoded");
    private final Group cGroup = (Group) rule.eContents().get(1);
    private final Keyword cPercentSignKeyword_0 = (Keyword) cGroup.eContents().get(0);
    private final RuleCall cXDIGITTerminalRuleCall_1 = (RuleCall) cGroup.eContents().get(1);
    private final RuleCall cXDIGITTerminalRuleCall_2 = (RuleCall) cGroup.eContents().get(2);

    // Pct_encoded:
    //	"%" XDIGIT XDIGIT;
    public ParserRule getRule() {
      return rule;
    }

    // "%" XDIGIT XDIGIT
    public Group getGroup() {
      return cGroup;
    }

    // "%"
    public Keyword getPercentSignKeyword_0() {
      return cPercentSignKeyword_0;
    }

    // XDIGIT
    public RuleCall getXDIGITTerminalRuleCall_1() {
      return cXDIGITTerminalRuleCall_1;
    }

    // XDIGIT
    public RuleCall getXDIGITTerminalRuleCall_2() {
      return cXDIGITTerminalRuleCall_2;
    }
  }
  public class StrvalElements extends AbstractParserRuleElementFinder {
    private final ParserRule rule =
        (ParserRule) GrammarUtil.findRuleForName(getGrammar(), "Strval");
    private final Alternatives cAlternatives = (Alternatives) rule.eContents().get(1);
    private final RuleCall cNcharParserRuleCall_0 = (RuleCall) cAlternatives.eContents().get(0);
    private final RuleCall cPct_encodedParserRuleCall_1 =
        (RuleCall) cAlternatives.eContents().get(1);

    // Strval:
    //	(Nchar | Pct_encoded)+;
    public ParserRule getRule() {
      return rule;
    }

    // (Nchar | Pct_encoded)+
    public Alternatives getAlternatives() {
      return cAlternatives;
    }

    // Nchar
    public RuleCall getNcharParserRuleCall_0() {
      return cNcharParserRuleCall_0;
    }

    // Pct_encoded
    public RuleCall getPct_encodedParserRuleCall_1() {
      return cPct_encodedParserRuleCall_1;
    }
  }
  public class Scenario6Elements extends AbstractParserRuleElementFinder {
    private final ParserRule rule =
        (ParserRule)
            GrammarUtil.findRuleForName(
                getGrammar(),
                "org.eclipse.xtext.parser.parameters.TwoParametersTestLanguage.Scenario6");
    private final Assignment cFirstAssignment = (Assignment) rule.eContents().get(1);
    private final RuleCall cFirstIdOrKeyword2ParserRuleCall_0 =
        (RuleCall) cFirstAssignment.eContents().get(0);

    // Scenario6 <A, B Scenario:
    //	first=IdOrKeyword2<A,B,A & B>
    @Override
    public ParserRule getRule() {
      return rule;
    }

    // first=IdOrKeyword2<A,B,A & B>
    public Assignment getFirstAssignment() {
      return cFirstAssignment;
    }

    // IdOrKeyword2<A,B,A & B>
    public RuleCall getFirstIdOrKeyword2ParserRuleCall_0() {
      return cFirstIdOrKeyword2ParserRuleCall_0;
    }
  }
Exemplo n.º 6
0
  public class EStringElements extends AbstractParserRuleElementFinder {
    private final ParserRule rule =
        (ParserRule) GrammarUtil.findRuleForName(getGrammar(), "EString");
    private final Alternatives cAlternatives = (Alternatives) rule.eContents().get(1);
    private final RuleCall cSTRINGTerminalRuleCall_0 = (RuleCall) cAlternatives.eContents().get(0);
    private final RuleCall cIDTerminalRuleCall_1 = (RuleCall) cAlternatives.eContents().get(1);

    // EString returns ecore::EString:
    //	STRING | ID;
    @Override
    public ParserRule getRule() {
      return rule;
    }

    // STRING | ID
    public Alternatives getAlternatives() {
      return cAlternatives;
    }

    // STRING
    public RuleCall getSTRINGTerminalRuleCall_0() {
      return cSTRINGTerminalRuleCall_0;
    }

    // ID
    public RuleCall getIDTerminalRuleCall_1() {
      return cIDTerminalRuleCall_1;
    }
  }
  public class PrefixedDelegateElements extends AbstractParserRuleElementFinder {
    private final ParserRule rule =
        (ParserRule) GrammarUtil.findRuleForName(getGrammar(), "PrefixedDelegate");
    private final Group cGroup = (Group) rule.eContents().get(1);
    private final Keyword cPrefixKeyword_0 = (Keyword) cGroup.eContents().get(0);
    private final RuleCall cDelegateParserRuleCall_1 = (RuleCall) cGroup.eContents().get(1);

    // PrefixedDelegate:
    //	"prefix" Delegate;
    @Override
    public ParserRule getRule() {
      return rule;
    }

    // "prefix" Delegate
    public Group getGroup() {
      return cGroup;
    }

    // "prefix"
    public Keyword getPrefixKeyword_0() {
      return cPrefixKeyword_0;
    }

    // Delegate
    public RuleCall getDelegateParserRuleCall_1() {
      return cDelegateParserRuleCall_1;
    }
  }
  public class ParenthesizedElements extends AbstractParserRuleElementFinder {
    private final ParserRule rule =
        (ParserRule) GrammarUtil.findRuleForName(getGrammar(), "Parenthesized");
    private final Group cGroup = (Group) rule.eContents().get(1);
    private final Keyword cLeftParenthesisKeyword_0 = (Keyword) cGroup.eContents().get(0);
    private final RuleCall cExpressionParserRuleCall_1 = (RuleCall) cGroup.eContents().get(1);
    private final Keyword cRightParenthesisKeyword_2 = (Keyword) cGroup.eContents().get(2);

    // Parenthesized returns Expression:
    //	"(" Expression ")";
    @Override
    public ParserRule getRule() {
      return rule;
    }

    // "(" Expression ")"
    public Group getGroup() {
      return cGroup;
    }

    // "("
    public Keyword getLeftParenthesisKeyword_0() {
      return cLeftParenthesisKeyword_0;
    }

    // Expression
    public RuleCall getExpressionParserRuleCall_1() {
      return cExpressionParserRuleCall_1;
    }

    // ")"
    public Keyword getRightParenthesisKeyword_2() {
      return cRightParenthesisKeyword_2;
    }
  }
  public class UnassignedElements extends AbstractParserRuleElementFinder {
    private final ParserRule rule =
        (ParserRule) GrammarUtil.findRuleForName(getGrammar(), "Unassigned");
    private final Group cGroup = (Group) rule.eContents().get(1);
    private final Keyword cDigitThreeKeyword_0 = (Keyword) cGroup.eContents().get(0);
    private final RuleCall cDelegateParserRuleCall_1 = (RuleCall) cGroup.eContents().get(1);

    // Unassigned:
    //	"3" Delegate;
    @Override
    public ParserRule getRule() {
      return rule;
    }

    // "3" Delegate
    public Group getGroup() {
      return cGroup;
    }

    // "3"
    public Keyword getDigitThreeKeyword_0() {
      return cDigitThreeKeyword_0;
    }

    // Delegate
    public RuleCall getDelegateParserRuleCall_1() {
      return cDelegateParserRuleCall_1;
    }
  }
  public class CompositeTypeEntryElements extends AbstractParserRuleElementFinder {
    private final ParserRule rule =
        (ParserRule) GrammarUtil.findRuleForName(getGrammar(), "CompositeTypeEntry");
    private final Assignment cDataTypeAssignment = (Assignment) rule.eContents().get(1);
    private final CrossReference cDataTypeTypeCrossReference_0 =
        (CrossReference) cDataTypeAssignment.eContents().get(0);
    private final RuleCall cDataTypeTypeTypeIdParserRuleCall_0_1 =
        (RuleCall) cDataTypeTypeCrossReference_0.eContents().get(1);

    // CompositeTypeEntry:
    //	dataType=[Type|TypeId];
    public ParserRule getRule() {
      return rule;
    }

    // dataType=[Type|TypeId]
    public Assignment getDataTypeAssignment() {
      return cDataTypeAssignment;
    }

    // [Type|TypeId]
    public CrossReference getDataTypeTypeCrossReference_0() {
      return cDataTypeTypeCrossReference_0;
    }

    // TypeId
    public RuleCall getDataTypeTypeTypeIdParserRuleCall_0_1() {
      return cDataTypeTypeTypeIdParserRuleCall_0_1;
    }
  }
  public class CompositeTypeElements extends AbstractParserRuleElementFinder {
    private final ParserRule rule =
        (ParserRule) GrammarUtil.findRuleForName(getGrammar(), "CompositeType");
    private final Group cGroup = (Group) rule.eContents().get(1);
    private final Keyword cCompositeKeyword_0 = (Keyword) cGroup.eContents().get(0);
    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 cBaseKeyword_2 = (Keyword) cGroup.eContents().get(2);
    private final Assignment cBaseTypeAssignment_3 = (Assignment) cGroup.eContents().get(3);
    private final RuleCall cBaseTypeCompositeTypeEntryParserRuleCall_3_0 =
        (RuleCall) cBaseTypeAssignment_3.eContents().get(0);
    private final Keyword cSemicolonKeyword_4 = (Keyword) cGroup.eContents().get(4);

    // CompositeType:
    //	"Composite" name=ID "base" baseType=CompositeTypeEntry ";";
    public ParserRule getRule() {
      return rule;
    }

    // "Composite" name=ID "base" baseType=CompositeTypeEntry ";"
    public Group getGroup() {
      return cGroup;
    }

    // "Composite"
    public Keyword getCompositeKeyword_0() {
      return cCompositeKeyword_0;
    }

    // name=ID
    public Assignment getNameAssignment_1() {
      return cNameAssignment_1;
    }

    // ID
    public RuleCall getNameIDTerminalRuleCall_1_0() {
      return cNameIDTerminalRuleCall_1_0;
    }

    // "base"
    public Keyword getBaseKeyword_2() {
      return cBaseKeyword_2;
    }

    // baseType=CompositeTypeEntry
    public Assignment getBaseTypeAssignment_3() {
      return cBaseTypeAssignment_3;
    }

    // CompositeTypeEntry
    public RuleCall getBaseTypeCompositeTypeEntryParserRuleCall_3_0() {
      return cBaseTypeCompositeTypeEntryParserRuleCall_3_0;
    }

    // ";"
    public Keyword getSemicolonKeyword_4() {
      return cSemicolonKeyword_4;
    }
  }
  public class FunctionsTblElements extends AbstractParserRuleElementFinder {
    private final ParserRule rule =
        (ParserRule) GrammarUtil.findRuleForName(getGrammar(), "FunctionsTbl");
    private final Alternatives cAlternatives = (Alternatives) rule.eContents().get(1);
    private final Keyword cIsnullKeyword_0 = (Keyword) cAlternatives.eContents().get(0);
    private final Keyword cInKeyword_1 = (Keyword) cAlternatives.eContents().get(1);
    private final Keyword cOutKeyword_2 = (Keyword) cAlternatives.eContents().get(2);

    // FunctionsTbl:
    //	"isnull" | "in" | "out";
    public ParserRule getRule() {
      return rule;
    }

    // "isnull" | "in" | "out"
    public Alternatives getAlternatives() {
      return cAlternatives;
    }

    // "isnull"
    public Keyword getIsnullKeyword_0() {
      return cIsnullKeyword_0;
    }

    // "in"
    public Keyword getInKeyword_1() {
      return cInKeyword_1;
    }

    // "out"
    public Keyword getOutKeyword_2() {
      return cOutKeyword_2;
    }
  }
Exemplo n.º 13
0
  public class FileElements extends AbstractParserRuleElementFinder {
    private final ParserRule rule =
        (ParserRule)
            GrammarUtil.findRuleForName(
                getGrammar(), "org.eclipse.xtext.idea.sdomain.SDomain.File");
    private final Assignment cElementsAssignment = (Assignment) rule.eContents().get(1);
    private final RuleCall cElementsElementParserRuleCall_0 =
        (RuleCall) cElementsAssignment.eContents().get(0);

    // File:
    //	elements+=Element*;
    @Override
    public ParserRule getRule() {
      return rule;
    }

    // elements+=Element*
    public Assignment getElementsAssignment() {
      return cElementsAssignment;
    }

    // Element
    public RuleCall getElementsElementParserRuleCall_0() {
      return cElementsElementParserRuleCall_0;
    }
  }
Exemplo n.º 14
0
  public class ATypeElements extends AbstractParserRuleElementFinder {
    private final ParserRule rule = (ParserRule) GrammarUtil.findRuleForName(getGrammar(), "AType");
    private final Group cGroup = (Group) rule.eContents().get(1);
    private final Keyword cFooKeyword_0 = (Keyword) cGroup.eContents().get(0);
    private final Action cATypeAction_1 = (Action) cGroup.eContents().get(1);

    // AType returns root::AType:
    //	"foo" {root::AType};
    public ParserRule getRule() {
      return rule;
    }

    // "foo" {root::AType}
    public Group getGroup() {
      return cGroup;
    }

    // "foo"
    public Keyword getFooKeyword_0() {
      return cFooKeyword_0;
    }

    // {root::AType}
    public Action getATypeAction_1() {
      return cATypeAction_1;
    }
  }
Exemplo n.º 15
0
  public class NumberElements extends AbstractParserRuleElementFinder {
    private final ParserRule rule =
        (ParserRule) GrammarUtil.findRuleForName(getGrammar(), "Number");
    private final Alternatives cAlternatives = (Alternatives) rule.eContents().get(1);
    private final RuleCall cFLOATTerminalRuleCall_0 = (RuleCall) cAlternatives.eContents().get(0);
    private final RuleCall cINTTerminalRuleCall_1 = (RuleCall) cAlternatives.eContents().get(1);

    // Number:
    //	FLOAT | INT;
    public ParserRule getRule() {
      return rule;
    }

    // FLOAT | INT
    public Alternatives getAlternatives() {
      return cAlternatives;
    }

    // FLOAT
    public RuleCall getFLOATTerminalRuleCall_0() {
      return cFLOATTerminalRuleCall_0;
    }

    // INT
    public RuleCall getINTTerminalRuleCall_1() {
      return cINTTerminalRuleCall_1;
    }
  }
Exemplo n.º 16
0
  public class AnotherTypeElements extends AbstractParserRuleElementFinder {
    private final ParserRule rule =
        (ParserRule) GrammarUtil.findRuleForName(getGrammar(), "AnotherType");
    private final Group cGroup = (Group) rule.eContents().get(1);
    private final Keyword cBarKeyword_0 = (Keyword) cGroup.eContents().get(0);
    private final Action cAnotherTypeAction_1 = (Action) cGroup.eContents().get(1);

    // AnotherType returns sub::AnotherType:
    //	"bar" {sub::AnotherType};
    public ParserRule getRule() {
      return rule;
    }

    // "bar" {sub::AnotherType}
    public Group getGroup() {
      return cGroup;
    }

    // "bar"
    public Keyword getBarKeyword_0() {
      return cBarKeyword_0;
    }

    // {sub::AnotherType}
    public Action getAnotherTypeAction_1() {
      return cAnotherTypeAction_1;
    }
  }
Exemplo n.º 17
0
  public class TypeElements extends AbstractParserRuleElementFinder {
    private final ParserRule rule = (ParserRule) GrammarUtil.findRuleForName(getGrammar(), "Type");
    private final Alternatives cAlternatives = (Alternatives) rule.eContents().get(1);
    private final RuleCall cATypeParserRuleCall_0 = (RuleCall) cAlternatives.eContents().get(0);
    private final RuleCall cAnotherTypeParserRuleCall_1 =
        (RuleCall) cAlternatives.eContents().get(1);

    // Type returns root::AType:
    //	AType | AnotherType;
    public ParserRule getRule() {
      return rule;
    }

    // AType | AnotherType
    public Alternatives getAlternatives() {
      return cAlternatives;
    }

    // AType
    public RuleCall getATypeParserRuleCall_0() {
      return cATypeParserRuleCall_0;
    }

    // AnotherType
    public RuleCall getAnotherTypeParserRuleCall_1() {
      return cAnotherTypeParserRuleCall_1;
    }
  }
  public class CompositeTypeEntryElements extends AbstractParserRuleElementFinder {
    private final ParserRule rule =
        (ParserRule)
            GrammarUtil.findRuleForName(
                getGrammar(),
                "org.eclipse.xtext.ui.tests.editor.contentassist.DatatypeRuleTestLanguage.CompositeTypeEntry");
    private final Assignment cDataTypeAssignment = (Assignment) rule.eContents().get(1);
    private final CrossReference cDataTypeTypeCrossReference_0 =
        (CrossReference) cDataTypeAssignment.eContents().get(0);
    private final RuleCall cDataTypeTypeTypeIdParserRuleCall_0_1 =
        (RuleCall) cDataTypeTypeCrossReference_0.eContents().get(1);

    // CompositeTypeEntry:
    //	dataType=[Type|TypeId];
    @Override
    public ParserRule getRule() {
      return rule;
    }

    // dataType=[Type|TypeId]
    public Assignment getDataTypeAssignment() {
      return cDataTypeAssignment;
    }

    // [Type|TypeId]
    public CrossReference getDataTypeTypeCrossReference_0() {
      return cDataTypeTypeCrossReference_0;
    }

    // TypeId
    public RuleCall getDataTypeTypeTypeIdParserRuleCall_0_1() {
      return cDataTypeTypeTypeIdParserRuleCall_0_1;
    }
  }
  public class TypeElements extends AbstractParserRuleElementFinder {
    private final ParserRule rule =
        (ParserRule)
            GrammarUtil.findRuleForName(
                getGrammar(),
                "org.eclipse.xtext.ui.tests.editor.contentassist.DatatypeRuleTestLanguage.Type");
    private final Alternatives cAlternatives = (Alternatives) rule.eContents().get(1);
    private final RuleCall cSimpleTypeParserRuleCall_0 =
        (RuleCall) cAlternatives.eContents().get(0);
    private final RuleCall cCompositeTypeParserRuleCall_1 =
        (RuleCall) cAlternatives.eContents().get(1);

    // Type:
    //	SimpleType | CompositeType;
    @Override
    public ParserRule getRule() {
      return rule;
    }

    // SimpleType | CompositeType
    public Alternatives getAlternatives() {
      return cAlternatives;
    }

    // SimpleType
    public RuleCall getSimpleTypeParserRuleCall_0() {
      return cSimpleTypeParserRuleCall_0;
    }

    // CompositeType
    public RuleCall getCompositeTypeParserRuleCall_1() {
      return cCompositeTypeParserRuleCall_1;
    }
  }
Exemplo n.º 20
0
  public class AbstractCallOverridenParserRuleElements extends AbstractParserRuleElementFinder {
    private final ParserRule rule =
        (ParserRule) GrammarUtil.findRuleForName(getGrammar(), "AbstractCallOverridenParserRule");
    private final Group cGroup = (Group) rule.eContents().get(1);
    private final Keyword cOverridemodelKeyword_0 = (Keyword) cGroup.eContents().get(0);
    private final Assignment cElementsAssignment_1 = (Assignment) cGroup.eContents().get(1);
    private final RuleCall cElementsOverridableParserRuleParserRuleCall_1_0 =
        (RuleCall) cElementsAssignment_1.eContents().get(0);

    // AbstractCallOverridenParserRule returns mm::AModel:
    //	"overridemodel" elements+=OverridableParserRule*;
    public ParserRule getRule() {
      return rule;
    }

    // "overridemodel" elements+=OverridableParserRule*
    public Group getGroup() {
      return cGroup;
    }

    // "overridemodel"
    public Keyword getOverridemodelKeyword_0() {
      return cOverridemodelKeyword_0;
    }

    // elements+=OverridableParserRule*
    public Assignment getElementsAssignment_1() {
      return cElementsAssignment_1;
    }

    // OverridableParserRule
    public RuleCall getElementsOverridableParserRuleParserRuleCall_1_0() {
      return cElementsOverridableParserRuleParserRuleCall_1_0;
    }
  }
Exemplo n.º 21
0
  public class OverridableParserRuleElements extends AbstractParserRuleElementFinder {
    private final ParserRule rule =
        (ParserRule) GrammarUtil.findRuleForName(getGrammar(), "OverridableParserRule");
    private final Group cGroup = (Group) rule.eContents().get(1);
    private final Keyword cElementKeyword_0 = (Keyword) cGroup.eContents().get(0);
    private final Assignment cNameAssignment_1 = (Assignment) cGroup.eContents().get(1);
    private final RuleCall cNameIDTerminalRuleCall_1_0 =
        (RuleCall) cNameAssignment_1.eContents().get(0);

    // OverridableParserRule returns mm::AType:
    //	"element" name=ID;
    public ParserRule getRule() {
      return rule;
    }

    // "element" name=ID
    public Group getGroup() {
      return cGroup;
    }

    // "element"
    public Keyword getElementKeyword_0() {
      return cElementKeyword_0;
    }

    // name=ID
    public Assignment getNameAssignment_1() {
      return cNameAssignment_1;
    }

    // ID
    public RuleCall getNameIDTerminalRuleCall_1_0() {
      return cNameIDTerminalRuleCall_1_0;
    }
  }
  public class EnumerationElements extends AbstractParserRuleElementFinder {
    private final ParserRule rule =
        (ParserRule) GrammarUtil.findRuleForName(getGrammar(), "Enumeration");
    private final Group cGroup = (Group) rule.eContents().get(1);
    private final Keyword cEnumKeyword_0 = (Keyword) cGroup.eContents().get(0);
    private final Assignment cValAssignment_1 = (Assignment) cGroup.eContents().get(1);
    private final RuleCall cValEnum1EnumRuleCall_1_0 =
        (RuleCall) cValAssignment_1.eContents().get(0);
    private final Group cGroup_2 = (Group) cGroup.eContents().get(2);
    private final Keyword cCommaKeyword_2_0 = (Keyword) cGroup_2.eContents().get(0);
    private final Assignment cValAssignment_2_1 = (Assignment) cGroup_2.eContents().get(1);
    private final RuleCall cValEnum1EnumRuleCall_2_1_0 =
        (RuleCall) cValAssignment_2_1.eContents().get(0);

    // Enumeration:
    //	"enum" val+=Enum1+ ("," val+=Enum1)*;
    public ParserRule getRule() {
      return rule;
    }

    // "enum" val+=Enum1+ ("," val+=Enum1)*
    public Group getGroup() {
      return cGroup;
    }

    // "enum"
    public Keyword getEnumKeyword_0() {
      return cEnumKeyword_0;
    }

    // val+=Enum1+
    public Assignment getValAssignment_1() {
      return cValAssignment_1;
    }

    // Enum1
    public RuleCall getValEnum1EnumRuleCall_1_0() {
      return cValEnum1EnumRuleCall_1_0;
    }

    // ("," val+=Enum1)*
    public Group getGroup_2() {
      return cGroup_2;
    }

    // ","
    public Keyword getCommaKeyword_2_0() {
      return cCommaKeyword_2_0;
    }

    // val+=Enum1
    public Assignment getValAssignment_2_1() {
      return cValAssignment_2_1;
    }

    // Enum1
    public RuleCall getValEnum1EnumRuleCall_2_1_0() {
      return cValEnum1EnumRuleCall_2_1_0;
    }
  }
  public class SuppressedHiddenSubElements extends AbstractParserRuleElementFinder {
    private final ParserRule rule =
        (ParserRule) GrammarUtil.findRuleForName(getGrammar(), "SuppressedHiddenSub");
    private final Alternatives cAlternatives = (Alternatives) rule.eContents().get(1);
    private final RuleCall cSuppressedHiddenSubSubParserRuleCall_0 =
        (RuleCall) cAlternatives.eContents().get(0);
    private final RuleCall cSuppressedHiddenSubIDParserRuleCall_1 =
        (RuleCall) cAlternatives.eContents().get(1);

    // SuppressedHiddenSub:
    //	SuppressedHiddenSubSub | SuppressedHiddenSubID;
    public ParserRule getRule() {
      return rule;
    }

    // SuppressedHiddenSubSub | SuppressedHiddenSubID
    public Alternatives getAlternatives() {
      return cAlternatives;
    }

    // SuppressedHiddenSubSub
    public RuleCall getSuppressedHiddenSubSubParserRuleCall_0() {
      return cSuppressedHiddenSubSubParserRuleCall_0;
    }

    // SuppressedHiddenSubID
    public RuleCall getSuppressedHiddenSubIDParserRuleCall_1() {
      return cSuppressedHiddenSubIDParserRuleCall_1;
    }
  }
  public class SpaceElements extends AbstractParserRuleElementFinder {
    private final ParserRule rule = (ParserRule) GrammarUtil.findRuleForName(getGrammar(), "Space");
    private final Group cGroup = (Group) rule.eContents().get(1);
    private final Keyword cSpaceKeyword_0 = (Keyword) cGroup.eContents().get(0);
    private final Assignment cValAssignment_1 = (Assignment) cGroup.eContents().get(1);
    private final RuleCall cValIDTerminalRuleCall_1_0 =
        (RuleCall) cValAssignment_1.eContents().get(0);

    // Space:
    //	"space" val=ID;
    public ParserRule getRule() {
      return rule;
    }

    // "space" val=ID
    public Group getGroup() {
      return cGroup;
    }

    // "space"
    public Keyword getSpaceKeyword_0() {
      return cSpaceKeyword_0;
    }

    // val=ID
    public Assignment getValAssignment_1() {
      return cValAssignment_1;
    }

    // ID
    public RuleCall getValIDTerminalRuleCall_1_0() {
      return cValIDTerminalRuleCall_1_0;
    }
  }
  public class FqnObjElements extends AbstractParserRuleElementFinder {
    private final ParserRule rule =
        (ParserRule) GrammarUtil.findRuleForName(getGrammar(), "FqnObj");
    private final Group cGroup = (Group) rule.eContents().get(1);
    private final Keyword cFqnKeyword_0 = (Keyword) cGroup.eContents().get(0);
    private final Assignment cNameAssignment_1 = (Assignment) cGroup.eContents().get(1);
    private final RuleCall cNameFQNParserRuleCall_1_0 =
        (RuleCall) cNameAssignment_1.eContents().get(0);

    // FqnObj:
    //	"fqn" name=FQN;
    public ParserRule getRule() {
      return rule;
    }

    // "fqn" name=FQN
    public Group getGroup() {
      return cGroup;
    }

    // "fqn"
    public Keyword getFqnKeyword_0() {
      return cFqnKeyword_0;
    }

    // name=FQN
    public Assignment getNameAssignment_1() {
      return cNameAssignment_1;
    }

    // FQN
    public RuleCall getNameFQNParserRuleCall_1_0() {
      return cNameFQNParserRuleCall_1_0;
    }
  }
 public void testMetamodel() throws Exception {
   AbstractRule rule =
       GrammarUtil.findRuleForName(getGrammarAccess().getGrammar(), "OverridableParserRule2");
   assertNotNull("rule", rule);
   TypeRef ref = rule.getType();
   assertNotNull("ref", ref);
   final EClass clazz = (EClass) ref.getClassifier();
   assertNotNull("class", clazz);
   assertEquals("AType2", clazz.getName());
   assertEquals(2, clazz.getESuperTypes().size());
   Set<String> expectedNames =
       new HashSet<String>(Arrays.asList(new String[] {"AType", "RootRule"}));
   Iterator<String> iter =
       Iterables.transform(
               clazz.getESuperTypes(),
               new Function<EClass, String>() {
                 public String apply(EClass param) {
                   return param.getName();
                 }
               })
           .iterator();
   while (iter.hasNext()) {
     String name = iter.next();
     assertTrue("name = '" + name + "'", expectedNames.remove(name));
   }
   assertTrue(expectedNames.toString(), expectedNames.isEmpty());
 }
Exemplo n.º 27
0
  public class QualifiedNameWithWildCardElements extends AbstractParserRuleElementFinder {
    private final ParserRule rule =
        (ParserRule)
            GrammarUtil.findRuleForName(
                getGrammar(), "org.eclipse.xtext.idea.sdomain.SDomain.QualifiedNameWithWildCard");
    private final Group cGroup = (Group) rule.eContents().get(1);
    private final RuleCall cQualifiedNameParserRuleCall_0 = (RuleCall) cGroup.eContents().get(0);
    private final Keyword cFullStopAsteriskKeyword_1 = (Keyword) cGroup.eContents().get(1);

    // QualifiedNameWithWildCard:
    //	QualifiedName '.*'?;
    @Override
    public ParserRule getRule() {
      return rule;
    }

    // QualifiedName '.*'?
    public Group getGroup() {
      return cGroup;
    }

    // QualifiedName
    public RuleCall getQualifiedNameParserRuleCall_0() {
      return cQualifiedNameParserRuleCall_0;
    }

    // '.*'?
    public Keyword getFullStopAsteriskKeyword_1() {
      return cFullStopAsteriskKeyword_1;
    }
  }
Exemplo n.º 28
0
  public class TypeElements extends AbstractParserRuleElementFinder {
    private final ParserRule rule =
        (ParserRule)
            GrammarUtil.findRuleForName(
                getGrammar(), "org.eclipse.xtext.idea.sdomain.SDomain.Type");
    private final Alternatives cAlternatives = (Alternatives) rule.eContents().get(1);
    private final RuleCall cEntityParserRuleCall_0 = (RuleCall) cAlternatives.eContents().get(0);
    private final RuleCall cDatatypeParserRuleCall_1 = (RuleCall) cAlternatives.eContents().get(1);

    // Type:
    //	Entity | Datatype;
    @Override
    public ParserRule getRule() {
      return rule;
    }

    // Entity | Datatype
    public Alternatives getAlternatives() {
      return cAlternatives;
    }

    // Entity
    public RuleCall getEntityParserRuleCall_0() {
      return cEntityParserRuleCall_0;
    }

    // Datatype
    public RuleCall getDatatypeParserRuleCall_1() {
      return cDatatypeParserRuleCall_1;
    }
  }
  public class UnassignedActionElements extends AbstractParserRuleElementFinder {
    private final ParserRule rule =
        (ParserRule) GrammarUtil.findRuleForName(getGrammar(), "UnassignedAction");
    private final Group cGroup = (Group) rule.eContents().get(1);
    private final Action cUnassignedActionAction_0 = (Action) cGroup.eContents().get(0);
    private final Keyword cEnabledKeyword_1 = (Keyword) cGroup.eContents().get(1);

    // UnassignedAction:
    //	{UnassignedAction} "enabled";
    @Override
    public ParserRule getRule() {
      return rule;
    }

    // {UnassignedAction} "enabled"
    public Group getGroup() {
      return cGroup;
    }

    // {UnassignedAction}
    public Action getUnassignedActionAction_0() {
      return cUnassignedActionAction_0;
    }

    // "enabled"
    public Keyword getEnabledKeyword_1() {
      return cEnabledKeyword_1;
    }
  }
Exemplo n.º 30
0
  public class NamespaceElements extends AbstractParserRuleElementFinder {
    private final ParserRule rule =
        (ParserRule)
            GrammarUtil.findRuleForName(
                getGrammar(), "org.eclipse.xtext.idea.sdomain.SDomain.Namespace");
    private final Group cGroup = (Group) rule.eContents().get(1);
    private final Assignment cNameAssignment_0 = (Assignment) cGroup.eContents().get(0);
    private final RuleCall cNameQualifiedNameParserRuleCall_0_0 =
        (RuleCall) cNameAssignment_0.eContents().get(0);
    private final Keyword cLeftCurlyBracketKeyword_1 = (Keyword) cGroup.eContents().get(1);
    private final Assignment cElementsAssignment_2 = (Assignment) cGroup.eContents().get(2);
    private final RuleCall cElementsElementParserRuleCall_2_0 =
        (RuleCall) cElementsAssignment_2.eContents().get(0);
    private final Keyword cRightCurlyBracketKeyword_3 = (Keyword) cGroup.eContents().get(3);

    // Namespace:
    //	name=QualifiedName '{'
    //	elements+=Element*
    //	'}';
    @Override
    public ParserRule getRule() {
      return rule;
    }

    // name=QualifiedName '{' elements+=Element* '}'
    public Group getGroup() {
      return cGroup;
    }

    // name=QualifiedName
    public Assignment getNameAssignment_0() {
      return cNameAssignment_0;
    }

    // QualifiedName
    public RuleCall getNameQualifiedNameParserRuleCall_0_0() {
      return cNameQualifiedNameParserRuleCall_0_0;
    }

    // '{'
    public Keyword getLeftCurlyBracketKeyword_1() {
      return cLeftCurlyBracketKeyword_1;
    }

    // elements+=Element*
    public Assignment getElementsAssignment_2() {
      return cElementsAssignment_2;
    }

    // Element
    public RuleCall getElementsElementParserRuleCall_2_0() {
      return cElementsElementParserRuleCall_2_0;
    }

    // '}'
    public Keyword getRightCurlyBracketKeyword_3() {
      return cRightCurlyBracketKeyword_3;
    }
  }