| /** |
| * Copyright (c) 2011, 2015 - Lunifera GmbH (Gross Enzersdorf), Loetz GmbH&Co.KG (Heidelberg) |
| * All rights reserved. This program and the accompanying materials |
| * are made available under the terms of the Eclipse Public License v1.0 |
| * which accompanies this distribution, and is available at |
| * http://www.eclipse.org/legal/epl-v10.html |
| * |
| * Contributors: |
| * Florian Pirchner - Initial implementation |
| */ |
| package org.eclipse.osbp.dsl.datatype.xtext.services; |
| |
| import com.google.inject.Singleton; |
| import com.google.inject.Inject; |
| |
| import java.util.List; |
| |
| import org.eclipse.xtext.*; |
| import org.eclipse.xtext.service.GrammarProvider; |
| import org.eclipse.xtext.service.AbstractElementFinder.*; |
| |
| import org.eclipse.osbp.dsl.common.xtext.services.CommonGrammarGrammarAccess; |
| import org.eclipse.xtext.xbase.annotations.services.XbaseWithAnnotationsGrammarAccess; |
| import org.eclipse.xtext.xbase.services.XbaseGrammarAccess; |
| import org.eclipse.xtext.xbase.services.XtypeGrammarAccess; |
| |
| @Singleton |
| public class DatatypeGrammarGrammarAccess extends AbstractGrammarElementFinder { |
| |
| |
| public class LCommonModelElements extends AbstractParserRuleElementFinder { |
| private final ParserRule rule = (ParserRule) GrammarUtil.findRuleForName(getGrammar(), "LCommonModel"); |
| private final Assignment cPackagesAssignment = (Assignment)rule.eContents().get(1); |
| private final RuleCall cPackagesTypedPackageParserRuleCall_0 = (RuleCall)cPackagesAssignment.eContents().get(0); |
| |
| //LCommonModel returns types::LCommonModel: |
| // packages+=TypedPackage*; |
| public ParserRule getRule() { return rule; } |
| |
| //packages+=TypedPackage* |
| public Assignment getPackagesAssignment() { return cPackagesAssignment; } |
| |
| //TypedPackage |
| public RuleCall getPackagesTypedPackageParserRuleCall_0() { return cPackagesTypedPackageParserRuleCall_0; } |
| } |
| |
| public class TypedPackageElements extends AbstractParserRuleElementFinder { |
| private final ParserRule rule = (ParserRule) GrammarUtil.findRuleForName(getGrammar(), "TypedPackage"); |
| private final Group cGroup = (Group)rule.eContents().get(1); |
| private final Action cLTypedPackageAction_0 = (Action)cGroup.eContents().get(0); |
| private final Keyword cPackageKeyword_1 = (Keyword)cGroup.eContents().get(1); |
| private final Assignment cNameAssignment_2 = (Assignment)cGroup.eContents().get(2); |
| private final RuleCall cNameQualifiedNameParserRuleCall_2_0 = (RuleCall)cNameAssignment_2.eContents().get(0); |
| private final Group cGroup_3 = (Group)cGroup.eContents().get(3); |
| private final Keyword cLeftCurlyBracketKeyword_3_0 = (Keyword)cGroup_3.eContents().get(0); |
| private final Assignment cImportsAssignment_3_1 = (Assignment)cGroup_3.eContents().get(1); |
| private final RuleCall cImportsImportParserRuleCall_3_1_0 = (RuleCall)cImportsAssignment_3_1.eContents().get(0); |
| private final Assignment cTypesAssignment_3_2 = (Assignment)cGroup_3.eContents().get(2); |
| private final RuleCall cTypesScalarTypeParserRuleCall_3_2_0 = (RuleCall)cTypesAssignment_3_2.eContents().get(0); |
| private final Keyword cRightCurlyBracketKeyword_3_3 = (Keyword)cGroup_3.eContents().get(3); |
| |
| //TypedPackage returns types::LTypedPackage: |
| // {types::LTypedPackage} "package" name=QualifiedName ("{" imports+=Import* types+=ScalarType* "}")?; |
| public ParserRule getRule() { return rule; } |
| |
| //{types::LTypedPackage} "package" name=QualifiedName ("{" imports+=Import* types+=ScalarType* "}")? |
| public Group getGroup() { return cGroup; } |
| |
| //{types::LTypedPackage} |
| public Action getLTypedPackageAction_0() { return cLTypedPackageAction_0; } |
| |
| //"package" |
| public Keyword getPackageKeyword_1() { return cPackageKeyword_1; } |
| |
| //name=QualifiedName |
| public Assignment getNameAssignment_2() { return cNameAssignment_2; } |
| |
| //QualifiedName |
| public RuleCall getNameQualifiedNameParserRuleCall_2_0() { return cNameQualifiedNameParserRuleCall_2_0; } |
| |
| //("{" imports+=Import* types+=ScalarType* "}")? |
| public Group getGroup_3() { return cGroup_3; } |
| |
| //"{" |
| public Keyword getLeftCurlyBracketKeyword_3_0() { return cLeftCurlyBracketKeyword_3_0; } |
| |
| //imports+=Import* |
| public Assignment getImportsAssignment_3_1() { return cImportsAssignment_3_1; } |
| |
| //Import |
| public RuleCall getImportsImportParserRuleCall_3_1_0() { return cImportsImportParserRuleCall_3_1_0; } |
| |
| //types+=ScalarType* |
| public Assignment getTypesAssignment_3_2() { return cTypesAssignment_3_2; } |
| |
| //ScalarType |
| public RuleCall getTypesScalarTypeParserRuleCall_3_2_0() { return cTypesScalarTypeParserRuleCall_3_2_0; } |
| |
| //"}" |
| public Keyword getRightCurlyBracketKeyword_3_3() { return cRightCurlyBracketKeyword_3_3; } |
| } |
| |
| |
| private final LCommonModelElements pLCommonModel; |
| private final TypedPackageElements pTypedPackage; |
| |
| private final Grammar grammar; |
| |
| private final CommonGrammarGrammarAccess gaCommonGrammar; |
| |
| @Inject |
| public DatatypeGrammarGrammarAccess(GrammarProvider grammarProvider, |
| CommonGrammarGrammarAccess gaCommonGrammar) { |
| this.grammar = internalFindGrammar(grammarProvider); |
| this.gaCommonGrammar = gaCommonGrammar; |
| this.pLCommonModel = new LCommonModelElements(); |
| this.pTypedPackage = new TypedPackageElements(); |
| } |
| |
| protected Grammar internalFindGrammar(GrammarProvider grammarProvider) { |
| Grammar grammar = grammarProvider.getGrammar(this); |
| while (grammar != null) { |
| if ("org.eclipse.osbp.dsl.datatype.xtext.DatatypeGrammar".equals(grammar.getName())) { |
| return grammar; |
| } |
| List<Grammar> grammars = grammar.getUsedGrammars(); |
| if (!grammars.isEmpty()) { |
| grammar = grammars.iterator().next(); |
| } else { |
| return null; |
| } |
| } |
| return grammar; |
| } |
| |
| |
| public Grammar getGrammar() { |
| return grammar; |
| } |
| |
| |
| public CommonGrammarGrammarAccess getCommonGrammarGrammarAccess() { |
| return gaCommonGrammar; |
| } |
| |
| |
| //LCommonModel returns types::LCommonModel: |
| // packages+=TypedPackage*; |
| public LCommonModelElements getLCommonModelAccess() { |
| return pLCommonModel; |
| } |
| |
| public ParserRule getLCommonModelRule() { |
| return getLCommonModelAccess().getRule(); |
| } |
| |
| //TypedPackage returns types::LTypedPackage: |
| // {types::LTypedPackage} "package" name=QualifiedName ("{" imports+=Import* types+=ScalarType* "}")?; |
| public TypedPackageElements getTypedPackageAccess() { |
| return pTypedPackage; |
| } |
| |
| public ParserRule getTypedPackageRule() { |
| return getTypedPackageAccess().getRule(); |
| } |
| |
| //Type returns types::LType: |
| // ScalarType | Class; |
| public CommonGrammarGrammarAccess.TypeElements getTypeAccess() { |
| return gaCommonGrammar.getTypeAccess(); |
| } |
| |
| public ParserRule getTypeRule() { |
| return getTypeAccess().getRule(); |
| } |
| |
| /// ** |
| // * Needs to be overridden by sub grammar |
| // * / Class returns types::LClass: |
| // {types::LClass} annotations+=AnnotationDef* {types::LClass.annotationInfo=current} "class"; |
| public CommonGrammarGrammarAccess.ClassElements getClassAccess() { |
| return gaCommonGrammar.getClassAccess(); |
| } |
| |
| public ParserRule getClassRule() { |
| return getClassAccess().getRule(); |
| } |
| |
| //Import returns types::LImport: |
| // "import" importedNamespace=LQualifiedNameWithWildCard ";"; |
| public CommonGrammarGrammarAccess.ImportElements getImportAccess() { |
| return gaCommonGrammar.getImportAccess(); |
| } |
| |
| public ParserRule getImportRule() { |
| return getImportAccess().getRule(); |
| } |
| |
| //DataType returns types::LDataType: |
| // "datatype" name=ValidIDWithKeywords ("jvmType" jvmTypeReference=JvmTypeReference asPrimitive?="as primitive"? |
| // constraints+=DataTypeConstraint* ("properties" "(" properties+=KeyAndValue (", " properties+=KeyAndValue)* ")")? | |
| // date?="dateType" dateType=DateType constraints+=DateConstraint* ("properties" "(" properties+=KeyAndValue (", " |
| // properties+=KeyAndValue)* ")")? | asBlob?="as blob" constraints+=BlobTypeConstraint* ("properties" "(" |
| // properties+=KeyAndValue (", " properties+=KeyAndValue)* ")")?) ";"?; |
| public CommonGrammarGrammarAccess.DataTypeElements getDataTypeAccess() { |
| return gaCommonGrammar.getDataTypeAccess(); |
| } |
| |
| public ParserRule getDataTypeRule() { |
| return getDataTypeAccess().getRule(); |
| } |
| |
| //AllConstraints returns types::LDatatypeConstraint: |
| // DtCAssertFalse | DtCAssertTrue | DtCDecimalMax | DtCDecimalMin | DtCDigits | DtCNumericMax | DtCNumericMin | |
| // DtCNotNull | DtCNull | DtCRegEx | DtCSize | DtCFuture | DtCPast; |
| public CommonGrammarGrammarAccess.AllConstraintsElements getAllConstraintsAccess() { |
| return gaCommonGrammar.getAllConstraintsAccess(); |
| } |
| |
| public ParserRule getAllConstraintsRule() { |
| return getAllConstraintsAccess().getRule(); |
| } |
| |
| //DataTypeConstraint returns types::LDatatypeConstraint: |
| // DtCAssertFalse | DtCAssertTrue | DtCDecimalMax | DtCDecimalMin | DtCDigits | DtCNumericMax | DtCNumericMin | |
| // DtCNotNull | DtCNull | DtCRegEx | DtCSize; |
| public CommonGrammarGrammarAccess.DataTypeConstraintElements getDataTypeConstraintAccess() { |
| return gaCommonGrammar.getDataTypeConstraintAccess(); |
| } |
| |
| public ParserRule getDataTypeConstraintRule() { |
| return getDataTypeConstraintAccess().getRule(); |
| } |
| |
| //DateConstraint returns types::LDatatypeConstraint: |
| // DtCFuture | DtCPast | DtCNotNull | DtCNull; |
| public CommonGrammarGrammarAccess.DateConstraintElements getDateConstraintAccess() { |
| return gaCommonGrammar.getDateConstraintAccess(); |
| } |
| |
| public ParserRule getDateConstraintRule() { |
| return getDateConstraintAccess().getRule(); |
| } |
| |
| //BlobTypeConstraint returns types::LDatatypeConstraint: |
| // DtCNotNull | DtCNull; |
| public CommonGrammarGrammarAccess.BlobTypeConstraintElements getBlobTypeConstraintAccess() { |
| return gaCommonGrammar.getBlobTypeConstraintAccess(); |
| } |
| |
| public ParserRule getBlobTypeConstraintRule() { |
| return getBlobTypeConstraintAccess().getRule(); |
| } |
| |
| //enum ConstraintSeverity returns types::LConstraintSeverity: |
| // INFO="info" | WARNING="warn" | ERROR="error"; |
| public CommonGrammarGrammarAccess.ConstraintSeverityElements getConstraintSeverityAccess() { |
| return gaCommonGrammar.getConstraintSeverityAccess(); |
| } |
| |
| public EnumRule getConstraintSeverityRule() { |
| return getConstraintSeverityAccess().getRule(); |
| } |
| |
| //DtCAssertFalse returns types::LDtCAssertFalse: |
| // {types::LDtCAssertFalse} "isFalse" ("[" ("msgCode" "=" msgCode=QualifiedName)? & ("msgI18nKey" "=" |
| // msgI18nKey=QualifiedName)? & ("severity" "=" severity=ConstraintSeverity)? "]")?; |
| public CommonGrammarGrammarAccess.DtCAssertFalseElements getDtCAssertFalseAccess() { |
| return gaCommonGrammar.getDtCAssertFalseAccess(); |
| } |
| |
| public ParserRule getDtCAssertFalseRule() { |
| return getDtCAssertFalseAccess().getRule(); |
| } |
| |
| //DtCAssertTrue returns types::LDtCAssertTrue: |
| // {types::LDtCAssertTrue} "isTrue" ("[" ("msgCode" "=" msgCode=QualifiedName)? & ("msgI18nKey" "=" |
| // msgI18nKey=QualifiedName)? & ("severity" "=" severity=ConstraintSeverity)? "]")?; |
| public CommonGrammarGrammarAccess.DtCAssertTrueElements getDtCAssertTrueAccess() { |
| return gaCommonGrammar.getDtCAssertTrueAccess(); |
| } |
| |
| public ParserRule getDtCAssertTrueRule() { |
| return getDtCAssertTrueAccess().getRule(); |
| } |
| |
| //DtCDecimalMax returns types::LDtCDecimalMax: |
| // {types::LDtCDecimalMax} "maxDecimal" "(" max=LDecimal ("[" ("msgCode" "=" msgCode=QualifiedName)? & ("msgI18nKey" "=" |
| // msgI18nKey=QualifiedName)? & ("severity" "=" severity=ConstraintSeverity)? "]")? ")"; |
| public CommonGrammarGrammarAccess.DtCDecimalMaxElements getDtCDecimalMaxAccess() { |
| return gaCommonGrammar.getDtCDecimalMaxAccess(); |
| } |
| |
| public ParserRule getDtCDecimalMaxRule() { |
| return getDtCDecimalMaxAccess().getRule(); |
| } |
| |
| //DtCDecimalMin returns types::LDtCDecimalMin: |
| // {types::LDtCDecimalMin} "minDecimal" "(" min=LDecimal ("[" ("msgCode" "=" msgCode=QualifiedName)? & ("msgI18nKey" "=" |
| // msgI18nKey=QualifiedName)? & ("severity" "=" severity=ConstraintSeverity)? "]")? ")"; |
| public CommonGrammarGrammarAccess.DtCDecimalMinElements getDtCDecimalMinAccess() { |
| return gaCommonGrammar.getDtCDecimalMinAccess(); |
| } |
| |
| public ParserRule getDtCDecimalMinRule() { |
| return getDtCDecimalMinAccess().getRule(); |
| } |
| |
| //DtCDigits returns types::LDtCDigits: |
| // {types::LDtCDigits} "digits" "(" intDigits=INT ", " fractionDigits=INT ("[" ("msgCode" "=" msgCode=QualifiedName)? & |
| // ("msgI18nKey" "=" msgI18nKey=QualifiedName)? & ("severity" "=" severity=ConstraintSeverity)? "]")? ")"; |
| public CommonGrammarGrammarAccess.DtCDigitsElements getDtCDigitsAccess() { |
| return gaCommonGrammar.getDtCDigitsAccess(); |
| } |
| |
| public ParserRule getDtCDigitsRule() { |
| return getDtCDigitsAccess().getRule(); |
| } |
| |
| //DtCFuture returns types::LDtCFuture: |
| // {types::LDtCFuture} "isFuture" ("[" ("msgCode" "=" msgCode=QualifiedName)? & ("msgI18nKey" "=" |
| // msgI18nKey=QualifiedName)? & ("severity" "=" severity=ConstraintSeverity)? "]")?; |
| public CommonGrammarGrammarAccess.DtCFutureElements getDtCFutureAccess() { |
| return gaCommonGrammar.getDtCFutureAccess(); |
| } |
| |
| public ParserRule getDtCFutureRule() { |
| return getDtCFutureAccess().getRule(); |
| } |
| |
| //DtCPast returns types::LDtCPast: |
| // {types::LDtCPast} "isPast" ("[" ("msgCode" "=" msgCode=QualifiedName)? & ("msgI18nKey" "=" msgI18nKey=QualifiedName)? |
| // & ("severity" "=" severity=ConstraintSeverity)? "]")?; |
| public CommonGrammarGrammarAccess.DtCPastElements getDtCPastAccess() { |
| return gaCommonGrammar.getDtCPastAccess(); |
| } |
| |
| public ParserRule getDtCPastRule() { |
| return getDtCPastAccess().getRule(); |
| } |
| |
| //DtCNumericMax returns types::LDtCNumericMax: |
| // {types::LDtCNumericMax} "maxNumber" "(" max=LInt ("[" ("msgCode" "=" msgCode=QualifiedName)? & ("msgI18nKey" "=" |
| // msgI18nKey=QualifiedName)? & ("severity" "=" severity=ConstraintSeverity)? "]")? ")"; |
| public CommonGrammarGrammarAccess.DtCNumericMaxElements getDtCNumericMaxAccess() { |
| return gaCommonGrammar.getDtCNumericMaxAccess(); |
| } |
| |
| public ParserRule getDtCNumericMaxRule() { |
| return getDtCNumericMaxAccess().getRule(); |
| } |
| |
| //DtCNumericMin returns types::LDtCNumericMin: |
| // {types::LDtCNumericMin} "minNumber" "(" min=LInt ("[" ("msgCode" "=" msgCode=QualifiedName)? & ("msgI18nKey" "=" |
| // msgI18nKey=QualifiedName)? & ("severity" "=" severity=ConstraintSeverity)? "]")? ")"; |
| public CommonGrammarGrammarAccess.DtCNumericMinElements getDtCNumericMinAccess() { |
| return gaCommonGrammar.getDtCNumericMinAccess(); |
| } |
| |
| public ParserRule getDtCNumericMinRule() { |
| return getDtCNumericMinAccess().getRule(); |
| } |
| |
| //DtCNotNull returns types::LDtCNotNull: |
| // {types::LDtCNotNull} "isNotNull" ("[" ("msgCode" "=" msgCode=QualifiedName)? & ("msgI18nKey" "=" |
| // msgI18nKey=QualifiedName)? & ("severity" "=" severity=ConstraintSeverity)? "]")?; |
| public CommonGrammarGrammarAccess.DtCNotNullElements getDtCNotNullAccess() { |
| return gaCommonGrammar.getDtCNotNullAccess(); |
| } |
| |
| public ParserRule getDtCNotNullRule() { |
| return getDtCNotNullAccess().getRule(); |
| } |
| |
| //DtCNull returns types::LDtCNull: |
| // {types::LDtCNull} "isNull" ("[" ("msgCode" "=" msgCode=QualifiedName)? & ("msgI18nKey" "=" msgI18nKey=QualifiedName)? |
| // & ("severity" "=" severity=ConstraintSeverity)? "]")?; |
| public CommonGrammarGrammarAccess.DtCNullElements getDtCNullAccess() { |
| return gaCommonGrammar.getDtCNullAccess(); |
| } |
| |
| public ParserRule getDtCNullRule() { |
| return getDtCNullAccess().getRule(); |
| } |
| |
| //DtCRegEx returns types::LDtCRegEx: |
| // {types::LDtCRegEx} "regex" "(" pattern=STRING ("[" ("msgCode" "=" msgCode=QualifiedName)? & ("msgI18nKey" "=" |
| // msgI18nKey=QualifiedName)? & ("severity" "=" severity=ConstraintSeverity)? "]")? ")"; |
| public CommonGrammarGrammarAccess.DtCRegExElements getDtCRegExAccess() { |
| return gaCommonGrammar.getDtCRegExAccess(); |
| } |
| |
| public ParserRule getDtCRegExRule() { |
| return getDtCRegExAccess().getRule(); |
| } |
| |
| //DtCSize returns types::LDtCSize: |
| // {types::LDtCSize} "minMaxSize" "(" min=INT ", " max=INT ("[" ("msgCode" "=" msgCode=QualifiedName)? & ("msgI18nKey" |
| // "=" msgI18nKey=QualifiedName)? & ("severity" "=" severity=ConstraintSeverity)? "]")? ")"; |
| public CommonGrammarGrammarAccess.DtCSizeElements getDtCSizeAccess() { |
| return gaCommonGrammar.getDtCSizeAccess(); |
| } |
| |
| public ParserRule getDtCSizeRule() { |
| return getDtCSizeAccess().getRule(); |
| } |
| |
| //enum DateType returns types::LDateType: |
| // DATE="date" | TIME="time" | TIMESTAMP="timestamp"; |
| public CommonGrammarGrammarAccess.DateTypeElements getDateTypeAccess() { |
| return gaCommonGrammar.getDateTypeAccess(); |
| } |
| |
| public EnumRule getDateTypeRule() { |
| return getDateTypeAccess().getRule(); |
| } |
| |
| //ScalarType returns types::LScalarType: |
| // DataType | Enum; |
| public CommonGrammarGrammarAccess.ScalarTypeElements getScalarTypeAccess() { |
| return gaCommonGrammar.getScalarTypeAccess(); |
| } |
| |
| public ParserRule getScalarTypeRule() { |
| return getScalarTypeAccess().getRule(); |
| } |
| |
| //Modifier returns types::LModifier: |
| // final?="final"? & static?="static"? & visibility=LVisibility; |
| public CommonGrammarGrammarAccess.ModifierElements getModifierAccess() { |
| return gaCommonGrammar.getModifierAccess(); |
| } |
| |
| public ParserRule getModifierRule() { |
| return getModifierAccess().getRule(); |
| } |
| |
| //Enum returns types::LEnum: |
| // "enum" name=ID "{" literals+=EnumLiteral (", " literals+=EnumLiteral)* "}"; |
| public CommonGrammarGrammarAccess.EnumElements getEnumAccess() { |
| return gaCommonGrammar.getEnumAccess(); |
| } |
| |
| public ParserRule getEnumRule() { |
| return getEnumAccess().getRule(); |
| } |
| |
| //EnumLiteral returns types::LEnumLiteral: |
| // name=ID ("(" default?="asDefault"? & null?="forNull"? ")" ("=" value=INT)?)?; |
| public CommonGrammarGrammarAccess.EnumLiteralElements getEnumLiteralAccess() { |
| return gaCommonGrammar.getEnumLiteralAccess(); |
| } |
| |
| public ParserRule getEnumLiteralRule() { |
| return getEnumLiteralAccess().getRule(); |
| } |
| |
| //AnnotationDef returns types::LAnnotationDef: |
| // => (annotation=XAnnotation); |
| public CommonGrammarGrammarAccess.AnnotationDefElements getAnnotationDefAccess() { |
| return gaCommonGrammar.getAnnotationDefAccess(); |
| } |
| |
| public ParserRule getAnnotationDefRule() { |
| return getAnnotationDefAccess().getRule(); |
| } |
| |
| //enum LVisibility returns types::LVisibility: |
| // PACKAGE="package" | PRIVATE="private" | PROTECTED="protected" | PUBLIC="public"; |
| public CommonGrammarGrammarAccess.LVisibilityElements getLVisibilityAccess() { |
| return gaCommonGrammar.getLVisibilityAccess(); |
| } |
| |
| public EnumRule getLVisibilityRule() { |
| return getLVisibilityAccess().getRule(); |
| } |
| |
| //ResultFilters returns types::LResultFilters: |
| // {types::LResultFilters} "constraints" "{" resultFilters+=ResultFilter* "}"; |
| public CommonGrammarGrammarAccess.ResultFiltersElements getResultFiltersAccess() { |
| return gaCommonGrammar.getResultFiltersAccess(); |
| } |
| |
| public ParserRule getResultFiltersRule() { |
| return getResultFiltersAccess().getRule(); |
| } |
| |
| //ResultFilter returns types::LResultFilter: |
| // AttributeMatchingConstraint; |
| public CommonGrammarGrammarAccess.ResultFilterElements getResultFilterAccess() { |
| return gaCommonGrammar.getResultFilterAccess(); |
| } |
| |
| public ParserRule getResultFilterRule() { |
| return getResultFilterAccess().getRule(); |
| } |
| |
| //AttributeMatchingConstraint returns types::LAttributeMatchingConstraint: |
| // attribute=[types::LAttribute] comparatorType=LComparatorType (matchingValue=STRING | => |
| // matchingLiteral=[types::LEnumLiteral]) ";"; |
| public CommonGrammarGrammarAccess.AttributeMatchingConstraintElements getAttributeMatchingConstraintAccess() { |
| return gaCommonGrammar.getAttributeMatchingConstraintAccess(); |
| } |
| |
| public ParserRule getAttributeMatchingConstraintRule() { |
| return getAttributeMatchingConstraintAccess().getRule(); |
| } |
| |
| //KeyAndValue returns types::LKeyAndValue: |
| // "key" "=" key=STRING "value" "=" value=STRING; |
| public CommonGrammarGrammarAccess.KeyAndValueElements getKeyAndValueAccess() { |
| return gaCommonGrammar.getKeyAndValueAccess(); |
| } |
| |
| public ParserRule getKeyAndValueRule() { |
| return getKeyAndValueAccess().getRule(); |
| } |
| |
| //enum LComparatorType returns types::LComparatorType: |
| // EQUALS="==" | GREATER=">" | LOWER="<" | GREATER_EQ=">=" | LOWER_EQ="<=" | NOT_EQ="<>"; |
| public CommonGrammarGrammarAccess.LComparatorTypeElements getLComparatorTypeAccess() { |
| return gaCommonGrammar.getLComparatorTypeAccess(); |
| } |
| |
| public EnumRule getLComparatorTypeRule() { |
| return getLComparatorTypeAccess().getRule(); |
| } |
| |
| //LQualifiedNameWithWildCard: |
| // QualifiedName ("." "*")?; |
| public CommonGrammarGrammarAccess.LQualifiedNameWithWildCardElements getLQualifiedNameWithWildCardAccess() { |
| return gaCommonGrammar.getLQualifiedNameWithWildCardAccess(); |
| } |
| |
| public ParserRule getLQualifiedNameWithWildCardRule() { |
| return getLQualifiedNameWithWildCardAccess().getRule(); |
| } |
| |
| //LFQN: |
| // ID ("." ID)*; |
| public CommonGrammarGrammarAccess.LFQNElements getLFQNAccess() { |
| return gaCommonGrammar.getLFQNAccess(); |
| } |
| |
| public ParserRule getLFQNRule() { |
| return getLFQNAccess().getRule(); |
| } |
| |
| //TYPE_CROSS_REFERENCE: |
| // ID; |
| public CommonGrammarGrammarAccess.TYPE_CROSS_REFERENCEElements getTYPE_CROSS_REFERENCEAccess() { |
| return gaCommonGrammar.getTYPE_CROSS_REFERENCEAccess(); |
| } |
| |
| public ParserRule getTYPE_CROSS_REFERENCERule() { |
| return getTYPE_CROSS_REFERENCEAccess().getRule(); |
| } |
| |
| //ValidIDWithKeywords: |
| // "cachable" | "id" | "uuid" | "transient" | "version" | "derived" "collection" | "refers" | "settings" | "lazy" | |
| // "notnull" | "dto" | "date" | "mapto" | "ref" | "cascade" | "var" | ID; |
| public CommonGrammarGrammarAccess.ValidIDWithKeywordsElements getValidIDWithKeywordsAccess() { |
| return gaCommonGrammar.getValidIDWithKeywordsAccess(); |
| } |
| |
| public ParserRule getValidIDWithKeywordsRule() { |
| return getValidIDWithKeywordsAccess().getRule(); |
| } |
| |
| //ValidLFQNWithKeywords: |
| // ValidIDWithKeywords ("." ValidIDWithKeywords)*; |
| public CommonGrammarGrammarAccess.ValidLFQNWithKeywordsElements getValidLFQNWithKeywordsAccess() { |
| return gaCommonGrammar.getValidLFQNWithKeywordsAccess(); |
| } |
| |
| public ParserRule getValidLFQNWithKeywordsRule() { |
| return getValidLFQNWithKeywordsAccess().getRule(); |
| } |
| |
| //Multiplicity returns types::LMultiplicity: |
| // "[" lower=LowerBound (".." upper=UpperBound)? "]"; |
| public CommonGrammarGrammarAccess.MultiplicityElements getMultiplicityAccess() { |
| return gaCommonGrammar.getMultiplicityAccess(); |
| } |
| |
| public ParserRule getMultiplicityRule() { |
| return getMultiplicityAccess().getRule(); |
| } |
| |
| //enum LowerBound returns types::LLowerBound: |
| // MANY="*" | ZERO="0" | OPTIONAL="?" | ATLEASTONE="+" | ONE="1"; |
| public CommonGrammarGrammarAccess.LowerBoundElements getLowerBoundAccess() { |
| return gaCommonGrammar.getLowerBoundAccess(); |
| } |
| |
| public EnumRule getLowerBoundRule() { |
| return getLowerBoundAccess().getRule(); |
| } |
| |
| //enum UpperBound returns types::LUpperBound: |
| // MANY="*" | ONE="1"; |
| public CommonGrammarGrammarAccess.UpperBoundElements getUpperBoundAccess() { |
| return gaCommonGrammar.getUpperBoundAccess(); |
| } |
| |
| public EnumRule getUpperBoundRule() { |
| return getUpperBoundAccess().getRule(); |
| } |
| |
| //LInt returns ecore::EInt: |
| // ("+" | "-")? INT; |
| public CommonGrammarGrammarAccess.LIntElements getLIntAccess() { |
| return gaCommonGrammar.getLIntAccess(); |
| } |
| |
| public ParserRule getLIntRule() { |
| return getLIntAccess().getRule(); |
| } |
| |
| //LDecimal returns ecore::EFloat: |
| // LInt ("." INT)?; |
| public CommonGrammarGrammarAccess.LDecimalElements getLDecimalAccess() { |
| return gaCommonGrammar.getLDecimalAccess(); |
| } |
| |
| public ParserRule getLDecimalRule() { |
| return getLDecimalAccess().getRule(); |
| } |
| |
| //XAnnotation: |
| // {XAnnotation} "@" annotationType=[types::JvmAnnotationType|QualifiedName] ("(" |
| // (elementValuePairs+=XAnnotationElementValuePair ("," elementValuePairs+=XAnnotationElementValuePair)* | |
| // value=XAnnotationElementValueOrCommaList)? ")")?; |
| public XbaseWithAnnotationsGrammarAccess.XAnnotationElements getXAnnotationAccess() { |
| return gaCommonGrammar.getXAnnotationAccess(); |
| } |
| |
| public ParserRule getXAnnotationRule() { |
| return getXAnnotationAccess().getRule(); |
| } |
| |
| //XAnnotationElementValuePair: |
| // => (element=[types::JvmOperation|ValidID] "=") value=XAnnotationElementValue; |
| public XbaseWithAnnotationsGrammarAccess.XAnnotationElementValuePairElements getXAnnotationElementValuePairAccess() { |
| return gaCommonGrammar.getXAnnotationElementValuePairAccess(); |
| } |
| |
| public ParserRule getXAnnotationElementValuePairRule() { |
| return getXAnnotationElementValuePairAccess().getRule(); |
| } |
| |
| //XAnnotationElementValueOrCommaList returns xbase::XExpression: |
| // => ({xbase::XListLiteral} "#" "[") (elements+=XAnnotationOrExpression ("," elements+=XAnnotationOrExpression)*)? "]" | |
| // XAnnotationOrExpression ({xbase::XListLiteral.elements+=current} ("," elements+=XAnnotationOrExpression)+)?; |
| public XbaseWithAnnotationsGrammarAccess.XAnnotationElementValueOrCommaListElements getXAnnotationElementValueOrCommaListAccess() { |
| return gaCommonGrammar.getXAnnotationElementValueOrCommaListAccess(); |
| } |
| |
| public ParserRule getXAnnotationElementValueOrCommaListRule() { |
| return getXAnnotationElementValueOrCommaListAccess().getRule(); |
| } |
| |
| //XAnnotationElementValue returns xbase::XExpression: |
| // => ({xbase::XListLiteral} "#" "[") (elements+=XAnnotationOrExpression ("," elements+=XAnnotationOrExpression)*)? "]" | |
| // XAnnotationOrExpression; |
| public XbaseWithAnnotationsGrammarAccess.XAnnotationElementValueElements getXAnnotationElementValueAccess() { |
| return gaCommonGrammar.getXAnnotationElementValueAccess(); |
| } |
| |
| public ParserRule getXAnnotationElementValueRule() { |
| return getXAnnotationElementValueAccess().getRule(); |
| } |
| |
| //XAnnotationOrExpression returns xbase::XExpression: |
| // XAnnotation | XExpression; |
| public XbaseWithAnnotationsGrammarAccess.XAnnotationOrExpressionElements getXAnnotationOrExpressionAccess() { |
| return gaCommonGrammar.getXAnnotationOrExpressionAccess(); |
| } |
| |
| public ParserRule getXAnnotationOrExpressionRule() { |
| return getXAnnotationOrExpressionAccess().getRule(); |
| } |
| |
| //XExpression: |
| // XAssignment; |
| public XbaseGrammarAccess.XExpressionElements getXExpressionAccess() { |
| return gaCommonGrammar.getXExpressionAccess(); |
| } |
| |
| public ParserRule getXExpressionRule() { |
| return getXExpressionAccess().getRule(); |
| } |
| |
| //XAssignment returns XExpression: |
| // {XAssignment} feature=[types::JvmIdentifiableElement|FeatureCallID] OpSingleAssign value=XAssignment | XOrExpression |
| // (=> ({XBinaryOperation.leftOperand=current} feature=[types::JvmIdentifiableElement|OpMultiAssign]) |
| // rightOperand=XAssignment)?; |
| public XbaseGrammarAccess.XAssignmentElements getXAssignmentAccess() { |
| return gaCommonGrammar.getXAssignmentAccess(); |
| } |
| |
| public ParserRule getXAssignmentRule() { |
| return getXAssignmentAccess().getRule(); |
| } |
| |
| //OpSingleAssign: |
| // "="; |
| public XbaseGrammarAccess.OpSingleAssignElements getOpSingleAssignAccess() { |
| return gaCommonGrammar.getOpSingleAssignAccess(); |
| } |
| |
| public ParserRule getOpSingleAssignRule() { |
| return getOpSingleAssignAccess().getRule(); |
| } |
| |
| //OpMultiAssign: |
| // "+=" | "-=" | "*=" | "/=" | "%=" | "<" "<" "=" | ">" ">"? ">="; |
| public XbaseGrammarAccess.OpMultiAssignElements getOpMultiAssignAccess() { |
| return gaCommonGrammar.getOpMultiAssignAccess(); |
| } |
| |
| public ParserRule getOpMultiAssignRule() { |
| return getOpMultiAssignAccess().getRule(); |
| } |
| |
| //XOrExpression returns XExpression: |
| // XAndExpression (=> ({XBinaryOperation.leftOperand=current} feature=[types::JvmIdentifiableElement|OpOr]) |
| // rightOperand=XAndExpression)*; |
| public XbaseGrammarAccess.XOrExpressionElements getXOrExpressionAccess() { |
| return gaCommonGrammar.getXOrExpressionAccess(); |
| } |
| |
| public ParserRule getXOrExpressionRule() { |
| return getXOrExpressionAccess().getRule(); |
| } |
| |
| //OpOr: |
| // "||"; |
| public XbaseGrammarAccess.OpOrElements getOpOrAccess() { |
| return gaCommonGrammar.getOpOrAccess(); |
| } |
| |
| public ParserRule getOpOrRule() { |
| return getOpOrAccess().getRule(); |
| } |
| |
| //XAndExpression returns XExpression: |
| // XEqualityExpression (=> ({XBinaryOperation.leftOperand=current} feature=[types::JvmIdentifiableElement|OpAnd]) |
| // rightOperand=XEqualityExpression)*; |
| public XbaseGrammarAccess.XAndExpressionElements getXAndExpressionAccess() { |
| return gaCommonGrammar.getXAndExpressionAccess(); |
| } |
| |
| public ParserRule getXAndExpressionRule() { |
| return getXAndExpressionAccess().getRule(); |
| } |
| |
| //OpAnd: |
| // "&&"; |
| public XbaseGrammarAccess.OpAndElements getOpAndAccess() { |
| return gaCommonGrammar.getOpAndAccess(); |
| } |
| |
| public ParserRule getOpAndRule() { |
| return getOpAndAccess().getRule(); |
| } |
| |
| //XEqualityExpression returns XExpression: |
| // XRelationalExpression (=> ({XBinaryOperation.leftOperand=current} feature=[types::JvmIdentifiableElement|OpEquality]) |
| // rightOperand=XRelationalExpression)*; |
| public XbaseGrammarAccess.XEqualityExpressionElements getXEqualityExpressionAccess() { |
| return gaCommonGrammar.getXEqualityExpressionAccess(); |
| } |
| |
| public ParserRule getXEqualityExpressionRule() { |
| return getXEqualityExpressionAccess().getRule(); |
| } |
| |
| //OpEquality: |
| // "==" | "!=" | "===" | "!=="; |
| public XbaseGrammarAccess.OpEqualityElements getOpEqualityAccess() { |
| return gaCommonGrammar.getOpEqualityAccess(); |
| } |
| |
| public ParserRule getOpEqualityRule() { |
| return getOpEqualityAccess().getRule(); |
| } |
| |
| //XRelationalExpression returns XExpression: |
| // XOtherOperatorExpression (=> ({XInstanceOfExpression.expression=current} "instanceof") type=JvmTypeReference | => |
| // ({XBinaryOperation.leftOperand=current} feature=[types::JvmIdentifiableElement|OpCompare]) |
| // rightOperand=XOtherOperatorExpression)*; |
| public XbaseGrammarAccess.XRelationalExpressionElements getXRelationalExpressionAccess() { |
| return gaCommonGrammar.getXRelationalExpressionAccess(); |
| } |
| |
| public ParserRule getXRelationalExpressionRule() { |
| return getXRelationalExpressionAccess().getRule(); |
| } |
| |
| //OpCompare: |
| // ">=" | "<" "=" | ">" | "<"; |
| public XbaseGrammarAccess.OpCompareElements getOpCompareAccess() { |
| return gaCommonGrammar.getOpCompareAccess(); |
| } |
| |
| public ParserRule getOpCompareRule() { |
| return getOpCompareAccess().getRule(); |
| } |
| |
| //XOtherOperatorExpression returns XExpression: |
| // XAdditiveExpression (=> ({XBinaryOperation.leftOperand=current} feature=[types::JvmIdentifiableElement|OpOther]) |
| // rightOperand=XAdditiveExpression)*; |
| public XbaseGrammarAccess.XOtherOperatorExpressionElements getXOtherOperatorExpressionAccess() { |
| return gaCommonGrammar.getXOtherOperatorExpressionAccess(); |
| } |
| |
| public ParserRule getXOtherOperatorExpressionRule() { |
| return getXOtherOperatorExpressionAccess().getRule(); |
| } |
| |
| //OpOther: |
| // "->" | "..<" | ">" ".." | ".." | "=>" | ">" (=> (">" ">") | ">") | "<" (=> ("<" "<") | "<" | "=>") | "<>" | "?:"; |
| public XbaseGrammarAccess.OpOtherElements getOpOtherAccess() { |
| return gaCommonGrammar.getOpOtherAccess(); |
| } |
| |
| public ParserRule getOpOtherRule() { |
| return getOpOtherAccess().getRule(); |
| } |
| |
| //XAdditiveExpression returns XExpression: |
| // XMultiplicativeExpression (=> ({XBinaryOperation.leftOperand=current} feature=[types::JvmIdentifiableElement|OpAdd]) |
| // rightOperand=XMultiplicativeExpression)*; |
| public XbaseGrammarAccess.XAdditiveExpressionElements getXAdditiveExpressionAccess() { |
| return gaCommonGrammar.getXAdditiveExpressionAccess(); |
| } |
| |
| public ParserRule getXAdditiveExpressionRule() { |
| return getXAdditiveExpressionAccess().getRule(); |
| } |
| |
| //OpAdd: |
| // "+" | "-"; |
| public XbaseGrammarAccess.OpAddElements getOpAddAccess() { |
| return gaCommonGrammar.getOpAddAccess(); |
| } |
| |
| public ParserRule getOpAddRule() { |
| return getOpAddAccess().getRule(); |
| } |
| |
| //XMultiplicativeExpression returns XExpression: |
| // XUnaryOperation (=> ({XBinaryOperation.leftOperand=current} feature=[types::JvmIdentifiableElement|OpMulti]) |
| // rightOperand=XUnaryOperation)*; |
| public XbaseGrammarAccess.XMultiplicativeExpressionElements getXMultiplicativeExpressionAccess() { |
| return gaCommonGrammar.getXMultiplicativeExpressionAccess(); |
| } |
| |
| public ParserRule getXMultiplicativeExpressionRule() { |
| return getXMultiplicativeExpressionAccess().getRule(); |
| } |
| |
| //OpMulti: |
| // "*" | "**" | "/" | "%"; |
| public XbaseGrammarAccess.OpMultiElements getOpMultiAccess() { |
| return gaCommonGrammar.getOpMultiAccess(); |
| } |
| |
| public ParserRule getOpMultiRule() { |
| return getOpMultiAccess().getRule(); |
| } |
| |
| //XUnaryOperation returns XExpression: |
| // {XUnaryOperation} feature=[types::JvmIdentifiableElement|OpUnary] operand=XUnaryOperation | XCastedExpression; |
| public XbaseGrammarAccess.XUnaryOperationElements getXUnaryOperationAccess() { |
| return gaCommonGrammar.getXUnaryOperationAccess(); |
| } |
| |
| public ParserRule getXUnaryOperationRule() { |
| return getXUnaryOperationAccess().getRule(); |
| } |
| |
| //OpUnary: |
| // "!" | "-" | "+"; |
| public XbaseGrammarAccess.OpUnaryElements getOpUnaryAccess() { |
| return gaCommonGrammar.getOpUnaryAccess(); |
| } |
| |
| public ParserRule getOpUnaryRule() { |
| return getOpUnaryAccess().getRule(); |
| } |
| |
| //XCastedExpression returns XExpression: |
| // XPostfixOperation (=> ({XCastedExpression.target=current} "as") type=JvmTypeReference)*; |
| public XbaseGrammarAccess.XCastedExpressionElements getXCastedExpressionAccess() { |
| return gaCommonGrammar.getXCastedExpressionAccess(); |
| } |
| |
| public ParserRule getXCastedExpressionRule() { |
| return getXCastedExpressionAccess().getRule(); |
| } |
| |
| //XPostfixOperation returns XExpression: |
| // XMemberFeatureCall => ({XPostfixOperation.operand=current} feature=[types::JvmIdentifiableElement|OpPostfix])?; |
| public XbaseGrammarAccess.XPostfixOperationElements getXPostfixOperationAccess() { |
| return gaCommonGrammar.getXPostfixOperationAccess(); |
| } |
| |
| public ParserRule getXPostfixOperationRule() { |
| return getXPostfixOperationAccess().getRule(); |
| } |
| |
| //OpPostfix: |
| // "++" | "--"; |
| public XbaseGrammarAccess.OpPostfixElements getOpPostfixAccess() { |
| return gaCommonGrammar.getOpPostfixAccess(); |
| } |
| |
| public ParserRule getOpPostfixRule() { |
| return getOpPostfixAccess().getRule(); |
| } |
| |
| //XMemberFeatureCall returns XExpression: |
| // XPrimaryExpression (=> ({XAssignment.assignable=current} ("." | explicitStatic?="::") |
| // feature=[types::JvmIdentifiableElement|FeatureCallID] OpSingleAssign) value=XAssignment | => |
| // ({XMemberFeatureCall.memberCallTarget=current} ("." | nullSafe?="?." | explicitStatic?="::")) ("<" |
| // typeArguments+=JvmArgumentTypeReference ("," typeArguments+=JvmArgumentTypeReference)* ">")? |
| // feature=[types::JvmIdentifiableElement|IdOrSuper] (=> explicitOperationCall?="(" (memberCallArguments+=XShortClosure | |
| // memberCallArguments+=XExpression ("," memberCallArguments+=XExpression)*)? ")")? memberCallArguments+=XClosure?)*; |
| public XbaseGrammarAccess.XMemberFeatureCallElements getXMemberFeatureCallAccess() { |
| return gaCommonGrammar.getXMemberFeatureCallAccess(); |
| } |
| |
| public ParserRule getXMemberFeatureCallRule() { |
| return getXMemberFeatureCallAccess().getRule(); |
| } |
| |
| //XPrimaryExpression returns XExpression: |
| // XConstructorCall | XBlockExpression | XSwitchExpression | XSynchronizedExpression | XFeatureCall | XLiteral | |
| // XIfExpression | XForLoopExpression | XBasicForLoopExpression | XWhileExpression | XDoWhileExpression | |
| // XThrowExpression | XReturnExpression | XTryCatchFinallyExpression | XParenthesizedExpression; |
| public XbaseGrammarAccess.XPrimaryExpressionElements getXPrimaryExpressionAccess() { |
| return gaCommonGrammar.getXPrimaryExpressionAccess(); |
| } |
| |
| public ParserRule getXPrimaryExpressionRule() { |
| return getXPrimaryExpressionAccess().getRule(); |
| } |
| |
| //XLiteral returns XExpression: |
| // XCollectionLiteral | XClosure | XBooleanLiteral | XNumberLiteral | XNullLiteral | XStringLiteral | XTypeLiteral; |
| public XbaseGrammarAccess.XLiteralElements getXLiteralAccess() { |
| return gaCommonGrammar.getXLiteralAccess(); |
| } |
| |
| public ParserRule getXLiteralRule() { |
| return getXLiteralAccess().getRule(); |
| } |
| |
| //XCollectionLiteral: |
| // XSetLiteral | XListLiteral; |
| public XbaseGrammarAccess.XCollectionLiteralElements getXCollectionLiteralAccess() { |
| return gaCommonGrammar.getXCollectionLiteralAccess(); |
| } |
| |
| public ParserRule getXCollectionLiteralRule() { |
| return getXCollectionLiteralAccess().getRule(); |
| } |
| |
| //XSetLiteral: |
| // {XSetLiteral} "#" "{" (elements+=XExpression ("," elements+=XExpression)*)? "}"; |
| public XbaseGrammarAccess.XSetLiteralElements getXSetLiteralAccess() { |
| return gaCommonGrammar.getXSetLiteralAccess(); |
| } |
| |
| public ParserRule getXSetLiteralRule() { |
| return getXSetLiteralAccess().getRule(); |
| } |
| |
| //XListLiteral: |
| // {XListLiteral} "#" "[" (elements+=XExpression ("," elements+=XExpression)*)? "]"; |
| public XbaseGrammarAccess.XListLiteralElements getXListLiteralAccess() { |
| return gaCommonGrammar.getXListLiteralAccess(); |
| } |
| |
| public ParserRule getXListLiteralRule() { |
| return getXListLiteralAccess().getRule(); |
| } |
| |
| //XClosure returns XExpression: |
| // => ({XClosure} "[") => ((declaredFormalParameters+=JvmFormalParameter ("," |
| // declaredFormalParameters+=JvmFormalParameter)*)? explicitSyntax?="|")? expression=XExpressionInClosure "]"; |
| public XbaseGrammarAccess.XClosureElements getXClosureAccess() { |
| return gaCommonGrammar.getXClosureAccess(); |
| } |
| |
| public ParserRule getXClosureRule() { |
| return getXClosureAccess().getRule(); |
| } |
| |
| //XExpressionInClosure returns XExpression: |
| // {XBlockExpression} (expressions+=XExpressionOrVarDeclaration ";"?)*; |
| public XbaseGrammarAccess.XExpressionInClosureElements getXExpressionInClosureAccess() { |
| return gaCommonGrammar.getXExpressionInClosureAccess(); |
| } |
| |
| public ParserRule getXExpressionInClosureRule() { |
| return getXExpressionInClosureAccess().getRule(); |
| } |
| |
| //XShortClosure returns XExpression: |
| // => ({XClosure} (declaredFormalParameters+=JvmFormalParameter ("," declaredFormalParameters+=JvmFormalParameter)*)? |
| // explicitSyntax?="|") expression=XExpression; |
| public XbaseGrammarAccess.XShortClosureElements getXShortClosureAccess() { |
| return gaCommonGrammar.getXShortClosureAccess(); |
| } |
| |
| public ParserRule getXShortClosureRule() { |
| return getXShortClosureAccess().getRule(); |
| } |
| |
| //XParenthesizedExpression returns XExpression: |
| // "(" XExpression ")"; |
| public XbaseGrammarAccess.XParenthesizedExpressionElements getXParenthesizedExpressionAccess() { |
| return gaCommonGrammar.getXParenthesizedExpressionAccess(); |
| } |
| |
| public ParserRule getXParenthesizedExpressionRule() { |
| return getXParenthesizedExpressionAccess().getRule(); |
| } |
| |
| //XIfExpression returns XExpression: |
| // {XIfExpression} "if" "(" if=XExpression ")" then=XExpression ("else" else=XExpression)?; |
| public XbaseGrammarAccess.XIfExpressionElements getXIfExpressionAccess() { |
| return gaCommonGrammar.getXIfExpressionAccess(); |
| } |
| |
| public ParserRule getXIfExpressionRule() { |
| return getXIfExpressionAccess().getRule(); |
| } |
| |
| //XSwitchExpression returns XExpression: |
| // {XSwitchExpression} "switch" (=> ("(" declaredParam=JvmFormalParameter ":") switch=XExpression ")" | => |
| // (declaredParam=JvmFormalParameter ":")? switch=XExpression) "{" cases+=XCasePart* ("default" ":" default=XExpression)? |
| // "}"; |
| public XbaseGrammarAccess.XSwitchExpressionElements getXSwitchExpressionAccess() { |
| return gaCommonGrammar.getXSwitchExpressionAccess(); |
| } |
| |
| public ParserRule getXSwitchExpressionRule() { |
| return getXSwitchExpressionAccess().getRule(); |
| } |
| |
| //XCasePart: |
| // {XCasePart} typeGuard=JvmTypeReference? ("case" case=XExpression)? (":" then=XExpression | fallThrough?=","); |
| public XbaseGrammarAccess.XCasePartElements getXCasePartAccess() { |
| return gaCommonGrammar.getXCasePartAccess(); |
| } |
| |
| public ParserRule getXCasePartRule() { |
| return getXCasePartAccess().getRule(); |
| } |
| |
| //XForLoopExpression returns XExpression: |
| // => ({XForLoopExpression} "for" "(" declaredParam=JvmFormalParameter ":") forExpression=XExpression ")" |
| // eachExpression=XExpression; |
| public XbaseGrammarAccess.XForLoopExpressionElements getXForLoopExpressionAccess() { |
| return gaCommonGrammar.getXForLoopExpressionAccess(); |
| } |
| |
| public ParserRule getXForLoopExpressionRule() { |
| return getXForLoopExpressionAccess().getRule(); |
| } |
| |
| //XBasicForLoopExpression returns XExpression: |
| // {XBasicForLoopExpression} "for" "(" (initExpressions+=XExpressionOrVarDeclaration ("," |
| // initExpressions+=XExpressionOrVarDeclaration)*)? ";" expression=XExpression? ";" (updateExpressions+=XExpression ("," |
| // updateExpressions+=XExpression)*)? ")" eachExpression=XExpression; |
| public XbaseGrammarAccess.XBasicForLoopExpressionElements getXBasicForLoopExpressionAccess() { |
| return gaCommonGrammar.getXBasicForLoopExpressionAccess(); |
| } |
| |
| public ParserRule getXBasicForLoopExpressionRule() { |
| return getXBasicForLoopExpressionAccess().getRule(); |
| } |
| |
| //XWhileExpression returns XExpression: |
| // {XWhileExpression} "while" "(" predicate=XExpression ")" body=XExpression; |
| public XbaseGrammarAccess.XWhileExpressionElements getXWhileExpressionAccess() { |
| return gaCommonGrammar.getXWhileExpressionAccess(); |
| } |
| |
| public ParserRule getXWhileExpressionRule() { |
| return getXWhileExpressionAccess().getRule(); |
| } |
| |
| //XDoWhileExpression returns XExpression: |
| // {XDoWhileExpression} "do" body=XExpression "while" "(" predicate=XExpression ")"; |
| public XbaseGrammarAccess.XDoWhileExpressionElements getXDoWhileExpressionAccess() { |
| return gaCommonGrammar.getXDoWhileExpressionAccess(); |
| } |
| |
| public ParserRule getXDoWhileExpressionRule() { |
| return getXDoWhileExpressionAccess().getRule(); |
| } |
| |
| //XBlockExpression returns XExpression: |
| // {XBlockExpression} "{" (expressions+=XExpressionOrVarDeclaration ";"?)* "}"; |
| public XbaseGrammarAccess.XBlockExpressionElements getXBlockExpressionAccess() { |
| return gaCommonGrammar.getXBlockExpressionAccess(); |
| } |
| |
| public ParserRule getXBlockExpressionRule() { |
| return getXBlockExpressionAccess().getRule(); |
| } |
| |
| //XExpressionOrVarDeclaration returns XExpression: |
| // XVariableDeclaration | XExpression; |
| public XbaseGrammarAccess.XExpressionOrVarDeclarationElements getXExpressionOrVarDeclarationAccess() { |
| return gaCommonGrammar.getXExpressionOrVarDeclarationAccess(); |
| } |
| |
| public ParserRule getXExpressionOrVarDeclarationRule() { |
| return getXExpressionOrVarDeclarationAccess().getRule(); |
| } |
| |
| //XVariableDeclaration returns XExpression: |
| // {XVariableDeclaration} (writeable?="var" | "val") (=> (type=JvmTypeReference name=ValidID) | name=ValidID) ("=" |
| // right=XExpression)?; |
| public XbaseGrammarAccess.XVariableDeclarationElements getXVariableDeclarationAccess() { |
| return gaCommonGrammar.getXVariableDeclarationAccess(); |
| } |
| |
| public ParserRule getXVariableDeclarationRule() { |
| return getXVariableDeclarationAccess().getRule(); |
| } |
| |
| //JvmFormalParameter returns types::JvmFormalParameter: |
| // parameterType=JvmTypeReference? name=ValidID; |
| public XbaseGrammarAccess.JvmFormalParameterElements getJvmFormalParameterAccess() { |
| return gaCommonGrammar.getJvmFormalParameterAccess(); |
| } |
| |
| public ParserRule getJvmFormalParameterRule() { |
| return getJvmFormalParameterAccess().getRule(); |
| } |
| |
| //FullJvmFormalParameter returns types::JvmFormalParameter: |
| // parameterType=JvmTypeReference name=ValidID; |
| public XbaseGrammarAccess.FullJvmFormalParameterElements getFullJvmFormalParameterAccess() { |
| return gaCommonGrammar.getFullJvmFormalParameterAccess(); |
| } |
| |
| public ParserRule getFullJvmFormalParameterRule() { |
| return getFullJvmFormalParameterAccess().getRule(); |
| } |
| |
| //XFeatureCall returns XExpression: |
| // {XFeatureCall} ("<" typeArguments+=JvmArgumentTypeReference ("," typeArguments+=JvmArgumentTypeReference)* ">")? |
| // feature=[types::JvmIdentifiableElement|IdOrSuper] (=> explicitOperationCall?="(" (featureCallArguments+=XShortClosure |
| // | featureCallArguments+=XExpression ("," featureCallArguments+=XExpression)*)? ")")? featureCallArguments+=XClosure?; |
| public XbaseGrammarAccess.XFeatureCallElements getXFeatureCallAccess() { |
| return gaCommonGrammar.getXFeatureCallAccess(); |
| } |
| |
| public ParserRule getXFeatureCallRule() { |
| return getXFeatureCallAccess().getRule(); |
| } |
| |
| //FeatureCallID: |
| // ValidID | "extends" | "static" | "import" | "extension"; |
| public XbaseGrammarAccess.FeatureCallIDElements getFeatureCallIDAccess() { |
| return gaCommonGrammar.getFeatureCallIDAccess(); |
| } |
| |
| public ParserRule getFeatureCallIDRule() { |
| return getFeatureCallIDAccess().getRule(); |
| } |
| |
| //IdOrSuper: |
| // FeatureCallID | "super"; |
| public XbaseGrammarAccess.IdOrSuperElements getIdOrSuperAccess() { |
| return gaCommonGrammar.getIdOrSuperAccess(); |
| } |
| |
| public ParserRule getIdOrSuperRule() { |
| return getIdOrSuperAccess().getRule(); |
| } |
| |
| //XConstructorCall returns XExpression: |
| // {XConstructorCall} "new" constructor=[types::JvmConstructor|QualifiedName] ("<" |
| // typeArguments+=JvmArgumentTypeReference ("," typeArguments+=JvmArgumentTypeReference)* ">")? (=> |
| // explicitConstructorCall?="(" (arguments+=XShortClosure | arguments+=XExpression ("," arguments+=XExpression)*)? ")")? |
| // arguments+=XClosure?; |
| public XbaseGrammarAccess.XConstructorCallElements getXConstructorCallAccess() { |
| return gaCommonGrammar.getXConstructorCallAccess(); |
| } |
| |
| public ParserRule getXConstructorCallRule() { |
| return getXConstructorCallAccess().getRule(); |
| } |
| |
| //XBooleanLiteral returns XExpression: |
| // {XBooleanLiteral} ("false" | isTrue?="true"); |
| public XbaseGrammarAccess.XBooleanLiteralElements getXBooleanLiteralAccess() { |
| return gaCommonGrammar.getXBooleanLiteralAccess(); |
| } |
| |
| public ParserRule getXBooleanLiteralRule() { |
| return getXBooleanLiteralAccess().getRule(); |
| } |
| |
| //XNullLiteral returns XExpression: |
| // {XNullLiteral} "null"; |
| public XbaseGrammarAccess.XNullLiteralElements getXNullLiteralAccess() { |
| return gaCommonGrammar.getXNullLiteralAccess(); |
| } |
| |
| public ParserRule getXNullLiteralRule() { |
| return getXNullLiteralAccess().getRule(); |
| } |
| |
| //XNumberLiteral returns XExpression: |
| // {XNumberLiteral} value=Number; |
| public XbaseGrammarAccess.XNumberLiteralElements getXNumberLiteralAccess() { |
| return gaCommonGrammar.getXNumberLiteralAccess(); |
| } |
| |
| public ParserRule getXNumberLiteralRule() { |
| return getXNumberLiteralAccess().getRule(); |
| } |
| |
| //XStringLiteral returns XExpression: |
| // {XStringLiteral} value=STRING; |
| public XbaseGrammarAccess.XStringLiteralElements getXStringLiteralAccess() { |
| return gaCommonGrammar.getXStringLiteralAccess(); |
| } |
| |
| public ParserRule getXStringLiteralRule() { |
| return getXStringLiteralAccess().getRule(); |
| } |
| |
| //XTypeLiteral returns XExpression: |
| // {XTypeLiteral} "typeof" "(" type=[types::JvmType|QualifiedName] arrayDimensions+=ArrayBrackets* ")"; |
| public XbaseGrammarAccess.XTypeLiteralElements getXTypeLiteralAccess() { |
| return gaCommonGrammar.getXTypeLiteralAccess(); |
| } |
| |
| public ParserRule getXTypeLiteralRule() { |
| return getXTypeLiteralAccess().getRule(); |
| } |
| |
| //XThrowExpression returns XExpression: |
| // {XThrowExpression} "throw" expression=XExpression; |
| public XbaseGrammarAccess.XThrowExpressionElements getXThrowExpressionAccess() { |
| return gaCommonGrammar.getXThrowExpressionAccess(); |
| } |
| |
| public ParserRule getXThrowExpressionRule() { |
| return getXThrowExpressionAccess().getRule(); |
| } |
| |
| //XReturnExpression returns XExpression: |
| // {XReturnExpression} "return" -> expression=XExpression?; |
| public XbaseGrammarAccess.XReturnExpressionElements getXReturnExpressionAccess() { |
| return gaCommonGrammar.getXReturnExpressionAccess(); |
| } |
| |
| public ParserRule getXReturnExpressionRule() { |
| return getXReturnExpressionAccess().getRule(); |
| } |
| |
| //XTryCatchFinallyExpression returns XExpression: |
| // {XTryCatchFinallyExpression} "try" expression=XExpression (catchClauses+=XCatchClause+ ("finally" |
| // finallyExpression=XExpression)? | "finally" finallyExpression=XExpression); |
| public XbaseGrammarAccess.XTryCatchFinallyExpressionElements getXTryCatchFinallyExpressionAccess() { |
| return gaCommonGrammar.getXTryCatchFinallyExpressionAccess(); |
| } |
| |
| public ParserRule getXTryCatchFinallyExpressionRule() { |
| return getXTryCatchFinallyExpressionAccess().getRule(); |
| } |
| |
| //XSynchronizedExpression returns XExpression: |
| // => ({XSynchronizedExpression} "synchronized" "(") param=XExpression ")" expression=XExpression; |
| public XbaseGrammarAccess.XSynchronizedExpressionElements getXSynchronizedExpressionAccess() { |
| return gaCommonGrammar.getXSynchronizedExpressionAccess(); |
| } |
| |
| public ParserRule getXSynchronizedExpressionRule() { |
| return getXSynchronizedExpressionAccess().getRule(); |
| } |
| |
| //XCatchClause: |
| // "catch" "(" declaredParam=FullJvmFormalParameter ")" expression=XExpression; |
| public XbaseGrammarAccess.XCatchClauseElements getXCatchClauseAccess() { |
| return gaCommonGrammar.getXCatchClauseAccess(); |
| } |
| |
| public ParserRule getXCatchClauseRule() { |
| return getXCatchClauseAccess().getRule(); |
| } |
| |
| //QualifiedName: |
| // ValidID ("." ValidID)*; |
| public XbaseGrammarAccess.QualifiedNameElements getQualifiedNameAccess() { |
| return gaCommonGrammar.getQualifiedNameAccess(); |
| } |
| |
| public ParserRule getQualifiedNameRule() { |
| return getQualifiedNameAccess().getRule(); |
| } |
| |
| //Number hidden(): |
| // HEX | (INT | DECIMAL) ("." (INT | DECIMAL))?; |
| public XbaseGrammarAccess.NumberElements getNumberAccess() { |
| return gaCommonGrammar.getNumberAccess(); |
| } |
| |
| public ParserRule getNumberRule() { |
| return getNumberAccess().getRule(); |
| } |
| |
| /// ** |
| // * Dummy rule, for "better" downwards compatibility, since GrammarAccess generates non-static inner classes, |
| // * which makes downstream grammars break on classloading, when a rule is removed. |
| // * / StaticQualifier: |
| // (ValidID "::")+; |
| public XbaseGrammarAccess.StaticQualifierElements getStaticQualifierAccess() { |
| return gaCommonGrammar.getStaticQualifierAccess(); |
| } |
| |
| public ParserRule getStaticQualifierRule() { |
| return getStaticQualifierAccess().getRule(); |
| } |
| |
| //terminal HEX: |
| // ("0x" | "0X") ("0".."9" | "a".."f" | "A".."F" | "_")+ ("#" (("b" | "B") ("i" | "I") | ("l" | "L")))?; |
| public TerminalRule getHEXRule() { |
| return gaCommonGrammar.getHEXRule(); |
| } |
| |
| //terminal INT returns ecore::EInt: |
| // "0".."9" ("0".."9" | "_")*; |
| public TerminalRule getINTRule() { |
| return gaCommonGrammar.getINTRule(); |
| } |
| |
| //terminal DECIMAL: |
| // INT (("e" | "E") ("+" | "-")? INT)? (("b" | "B") ("i" | "I" | "d" | "D") | ("l" | "L" | "d" | "D" | "f" | "F"))?; |
| public TerminalRule getDECIMALRule() { |
| return gaCommonGrammar.getDECIMALRule(); |
| } |
| |
| //JvmTypeReference: |
| // JvmParameterizedTypeReference => ({JvmGenericArrayTypeReference.componentType=current} ArrayBrackets)* | |
| // XFunctionTypeRef; |
| public XtypeGrammarAccess.JvmTypeReferenceElements getJvmTypeReferenceAccess() { |
| return gaCommonGrammar.getJvmTypeReferenceAccess(); |
| } |
| |
| public ParserRule getJvmTypeReferenceRule() { |
| return getJvmTypeReferenceAccess().getRule(); |
| } |
| |
| //ArrayBrackets: |
| // "[" "]"; |
| public XtypeGrammarAccess.ArrayBracketsElements getArrayBracketsAccess() { |
| return gaCommonGrammar.getArrayBracketsAccess(); |
| } |
| |
| public ParserRule getArrayBracketsRule() { |
| return getArrayBracketsAccess().getRule(); |
| } |
| |
| //XFunctionTypeRef: |
| // ("(" (paramTypes+=JvmTypeReference ("," paramTypes+=JvmTypeReference)*)? ")")? "=>" returnType=JvmTypeReference; |
| public XtypeGrammarAccess.XFunctionTypeRefElements getXFunctionTypeRefAccess() { |
| return gaCommonGrammar.getXFunctionTypeRefAccess(); |
| } |
| |
| public ParserRule getXFunctionTypeRefRule() { |
| return getXFunctionTypeRefAccess().getRule(); |
| } |
| |
| //JvmParameterizedTypeReference: |
| // type=[JvmType|QualifiedName] ("<" arguments+=JvmArgumentTypeReference ("," arguments+=JvmArgumentTypeReference)* ">" |
| // (=> ({JvmInnerTypeReference.outer=current} ".") type=[JvmType|ValidID] ("<" arguments+=JvmArgumentTypeReference ("," |
| // arguments+=JvmArgumentTypeReference)* ">")?)*)?; |
| public XtypeGrammarAccess.JvmParameterizedTypeReferenceElements getJvmParameterizedTypeReferenceAccess() { |
| return gaCommonGrammar.getJvmParameterizedTypeReferenceAccess(); |
| } |
| |
| public ParserRule getJvmParameterizedTypeReferenceRule() { |
| return getJvmParameterizedTypeReferenceAccess().getRule(); |
| } |
| |
| //JvmArgumentTypeReference returns JvmTypeReference: |
| // JvmTypeReference | JvmWildcardTypeReference; |
| public XtypeGrammarAccess.JvmArgumentTypeReferenceElements getJvmArgumentTypeReferenceAccess() { |
| return gaCommonGrammar.getJvmArgumentTypeReferenceAccess(); |
| } |
| |
| public ParserRule getJvmArgumentTypeReferenceRule() { |
| return getJvmArgumentTypeReferenceAccess().getRule(); |
| } |
| |
| //JvmWildcardTypeReference: |
| // {JvmWildcardTypeReference} "?" (constraints+=JvmUpperBound constraints+=JvmUpperBoundAnded* | |
| // constraints+=JvmLowerBound constraints+=JvmLowerBoundAnded*)?; |
| public XtypeGrammarAccess.JvmWildcardTypeReferenceElements getJvmWildcardTypeReferenceAccess() { |
| return gaCommonGrammar.getJvmWildcardTypeReferenceAccess(); |
| } |
| |
| public ParserRule getJvmWildcardTypeReferenceRule() { |
| return getJvmWildcardTypeReferenceAccess().getRule(); |
| } |
| |
| //JvmUpperBound: |
| // "extends" typeReference=JvmTypeReference; |
| public XtypeGrammarAccess.JvmUpperBoundElements getJvmUpperBoundAccess() { |
| return gaCommonGrammar.getJvmUpperBoundAccess(); |
| } |
| |
| public ParserRule getJvmUpperBoundRule() { |
| return getJvmUpperBoundAccess().getRule(); |
| } |
| |
| //JvmUpperBoundAnded returns JvmUpperBound: |
| // "&" typeReference=JvmTypeReference; |
| public XtypeGrammarAccess.JvmUpperBoundAndedElements getJvmUpperBoundAndedAccess() { |
| return gaCommonGrammar.getJvmUpperBoundAndedAccess(); |
| } |
| |
| public ParserRule getJvmUpperBoundAndedRule() { |
| return getJvmUpperBoundAndedAccess().getRule(); |
| } |
| |
| //JvmLowerBound: |
| // "super" typeReference=JvmTypeReference; |
| public XtypeGrammarAccess.JvmLowerBoundElements getJvmLowerBoundAccess() { |
| return gaCommonGrammar.getJvmLowerBoundAccess(); |
| } |
| |
| public ParserRule getJvmLowerBoundRule() { |
| return getJvmLowerBoundAccess().getRule(); |
| } |
| |
| //JvmLowerBoundAnded returns JvmLowerBound: |
| // "&" typeReference=JvmTypeReference; |
| public XtypeGrammarAccess.JvmLowerBoundAndedElements getJvmLowerBoundAndedAccess() { |
| return gaCommonGrammar.getJvmLowerBoundAndedAccess(); |
| } |
| |
| public ParserRule getJvmLowerBoundAndedRule() { |
| return getJvmLowerBoundAndedAccess().getRule(); |
| } |
| |
| //JvmTypeParameter: |
| // name=ValidID (constraints+=JvmUpperBound constraints+=JvmUpperBoundAnded*)?; |
| public XtypeGrammarAccess.JvmTypeParameterElements getJvmTypeParameterAccess() { |
| return gaCommonGrammar.getJvmTypeParameterAccess(); |
| } |
| |
| public ParserRule getJvmTypeParameterRule() { |
| return getJvmTypeParameterAccess().getRule(); |
| } |
| |
| //QualifiedNameWithWildcard: |
| // QualifiedName "." "*"; |
| public XtypeGrammarAccess.QualifiedNameWithWildcardElements getQualifiedNameWithWildcardAccess() { |
| return gaCommonGrammar.getQualifiedNameWithWildcardAccess(); |
| } |
| |
| public ParserRule getQualifiedNameWithWildcardRule() { |
| return getQualifiedNameWithWildcardAccess().getRule(); |
| } |
| |
| //ValidID: |
| // ID; |
| public XtypeGrammarAccess.ValidIDElements getValidIDAccess() { |
| return gaCommonGrammar.getValidIDAccess(); |
| } |
| |
| public ParserRule getValidIDRule() { |
| return getValidIDAccess().getRule(); |
| } |
| |
| //XImportSection: |
| // importDeclarations+=XImportDeclaration+; |
| public XtypeGrammarAccess.XImportSectionElements getXImportSectionAccess() { |
| return gaCommonGrammar.getXImportSectionAccess(); |
| } |
| |
| public ParserRule getXImportSectionRule() { |
| return getXImportSectionAccess().getRule(); |
| } |
| |
| //XImportDeclaration: |
| // "import" (static?="static" extension?="extension"? importedType=[JvmDeclaredType|QualifiedNameInStaticImport] |
| // (wildcard?="*" | memberName=ValidID) | importedType=[JvmDeclaredType|QualifiedName] | |
| // importedNamespace=QualifiedNameWithWildcard) ";"?; |
| public XtypeGrammarAccess.XImportDeclarationElements getXImportDeclarationAccess() { |
| return gaCommonGrammar.getXImportDeclarationAccess(); |
| } |
| |
| public ParserRule getXImportDeclarationRule() { |
| return getXImportDeclarationAccess().getRule(); |
| } |
| |
| //QualifiedNameInStaticImport: |
| // (ValidID ".")+; |
| public XtypeGrammarAccess.QualifiedNameInStaticImportElements getQualifiedNameInStaticImportAccess() { |
| return gaCommonGrammar.getQualifiedNameInStaticImportAccess(); |
| } |
| |
| public ParserRule getQualifiedNameInStaticImportRule() { |
| return getQualifiedNameInStaticImportAccess().getRule(); |
| } |
| |
| //terminal ID: |
| // "^"? ("a".."z" | "A".."Z" | "$" | "_") ("a".."z" | "A".."Z" | "$" | "_" | "0".."9")*; |
| public TerminalRule getIDRule() { |
| return gaCommonGrammar.getIDRule(); |
| } |
| |
| //terminal STRING: |
| // "\"" ("\\" . / * ('b'|'t'|'n'|'f'|'r'|'u'|'"'|"'"|'\\') * / | !("\\" | "\""))* "\""? | "\'" ("\\" . |
| // / * ('b'|'t'|'n'|'f'|'r'|'u'|'"'|"'"|'\\') * / | !("\\" | "\'"))* "\'"?; |
| public TerminalRule getSTRINGRule() { |
| return gaCommonGrammar.getSTRINGRule(); |
| } |
| |
| //terminal ML_COMMENT: |
| // "/ *"->"* /"; |
| public TerminalRule getML_COMMENTRule() { |
| return gaCommonGrammar.getML_COMMENTRule(); |
| } |
| |
| //terminal SL_COMMENT: |
| // "//" !("\n" | "\r")* ("\r"? "\n")?; |
| public TerminalRule getSL_COMMENTRule() { |
| return gaCommonGrammar.getSL_COMMENTRule(); |
| } |
| |
| //terminal WS: |
| // (" " | "\t" | "\r" | "\n")+; |
| public TerminalRule getWSRule() { |
| return gaCommonGrammar.getWSRule(); |
| } |
| |
| //terminal ANY_OTHER: |
| // .; |
| public TerminalRule getANY_OTHERRule() { |
| return gaCommonGrammar.getANY_OTHERRule(); |
| } |
| } |