From 07719e927f9d398765e661c84fd8778cefb39083 Mon Sep 17 00:00:00 2001 From: Kristóf Marussy Date: Sun, 27 Jun 2021 14:22:40 +0200 Subject: Simplify project layout --- language/.classpath | 62 + language/.gitignore | 1 + ...roblem (problem) Language Infrastructure.launch | 14 + language/.project | 29 + .../.settings/org.eclipse.core.resources.prefs | 2 + language/build.gradle | 43 + .../viatra/solver/language/GenerateProblem.mwe2 | 59 + .../eclipse/viatra/solver/language/Problem.xtext | 116 + .../solver/language/ProblemRuntimeModule.java | 80 + .../solver/language/ProblemStandaloneSetup.java | 26 + .../viatra/solver/language/ProblemUtil.java | 98 + .../conversion/ProblemValueConverterService.java | 17 + .../conversion/UpperBoundValueConverter.java | 35 + .../language/generator/ProblemGenerator.xtend | 25 + .../naming/ProblemQualifiedNameConverter.java | 15 + .../resource/ProblemDerivedStateComputer.java | 299 ++ .../resource/ProblemLocationInFileProvider.java | 32 + .../ProblemResourceDescriptionStrategy.java | 89 + .../scoping/ProblemGlobalScopeProvider.java | 25 + .../scoping/ProblemLocalScopeProvider.java | 40 + .../language/scoping/ProblemScopeProvider.java | 83 + .../language/validation/ProblemValidator.java | 25 + .../eclipse/viatra/solver/language/builtin.problem | 17 + .../language/AbstractProblemRuntimeModule.java | 201 + .../viatra/solver/language/Problem.xtextbin | Bin 0 -> 6159 bytes .../language/ProblemStandaloneSetupGenerated.java | 37 + .../antlr/ProblemAntlrTokenFileProvider.java | 16 + .../language/parser/antlr/ProblemParser.java | 40 + .../parser/antlr/internal/InternalProblem.g | 1909 +++++++ .../parser/antlr/internal/InternalProblem.tokens | 72 + .../antlr/internal/InternalProblemLexer.java | 1797 +++++++ .../antlr/internal/InternalProblemParser.java | 5296 ++++++++++++++++++++ .../scoping/AbstractProblemScopeProvider.java | 9 + .../serializer/ProblemSemanticSequencer.java | 369 ++ .../serializer/ProblemSyntacticSequencer.java | 139 + .../language/services/ProblemGrammarAccess.java | 1706 +++++++ .../validation/AbstractProblemValidator.java | 19 + .../ProblemConfigurableIssueCodesProvider.java | 22 + .../solver/language/tests/ProblemParsingTest.xtend | 30 + .../language/tests/ProblemInjectorProvider.java | 69 + 40 files changed, 12963 insertions(+) create mode 100644 language/.classpath create mode 100644 language/.gitignore create mode 100644 language/.launch/Generate Problem (problem) Language Infrastructure.launch create mode 100644 language/.project create mode 100644 language/.settings/org.eclipse.core.resources.prefs create mode 100644 language/build.gradle create mode 100644 language/src/main/java/org/eclipse/viatra/solver/language/GenerateProblem.mwe2 create mode 100644 language/src/main/java/org/eclipse/viatra/solver/language/Problem.xtext create mode 100644 language/src/main/java/org/eclipse/viatra/solver/language/ProblemRuntimeModule.java create mode 100644 language/src/main/java/org/eclipse/viatra/solver/language/ProblemStandaloneSetup.java create mode 100644 language/src/main/java/org/eclipse/viatra/solver/language/ProblemUtil.java create mode 100644 language/src/main/java/org/eclipse/viatra/solver/language/conversion/ProblemValueConverterService.java create mode 100644 language/src/main/java/org/eclipse/viatra/solver/language/conversion/UpperBoundValueConverter.java create mode 100644 language/src/main/java/org/eclipse/viatra/solver/language/generator/ProblemGenerator.xtend create mode 100644 language/src/main/java/org/eclipse/viatra/solver/language/naming/ProblemQualifiedNameConverter.java create mode 100644 language/src/main/java/org/eclipse/viatra/solver/language/resource/ProblemDerivedStateComputer.java create mode 100644 language/src/main/java/org/eclipse/viatra/solver/language/resource/ProblemLocationInFileProvider.java create mode 100644 language/src/main/java/org/eclipse/viatra/solver/language/resource/ProblemResourceDescriptionStrategy.java create mode 100644 language/src/main/java/org/eclipse/viatra/solver/language/scoping/ProblemGlobalScopeProvider.java create mode 100644 language/src/main/java/org/eclipse/viatra/solver/language/scoping/ProblemLocalScopeProvider.java create mode 100644 language/src/main/java/org/eclipse/viatra/solver/language/scoping/ProblemScopeProvider.java create mode 100644 language/src/main/java/org/eclipse/viatra/solver/language/validation/ProblemValidator.java create mode 100644 language/src/main/resources/org/eclipse/viatra/solver/language/builtin.problem create mode 100644 language/src/main/xtext-gen/org/eclipse/viatra/solver/language/AbstractProblemRuntimeModule.java create mode 100644 language/src/main/xtext-gen/org/eclipse/viatra/solver/language/Problem.xtextbin create mode 100644 language/src/main/xtext-gen/org/eclipse/viatra/solver/language/ProblemStandaloneSetupGenerated.java create mode 100644 language/src/main/xtext-gen/org/eclipse/viatra/solver/language/parser/antlr/ProblemAntlrTokenFileProvider.java create mode 100644 language/src/main/xtext-gen/org/eclipse/viatra/solver/language/parser/antlr/ProblemParser.java create mode 100644 language/src/main/xtext-gen/org/eclipse/viatra/solver/language/parser/antlr/internal/InternalProblem.g create mode 100644 language/src/main/xtext-gen/org/eclipse/viatra/solver/language/parser/antlr/internal/InternalProblem.tokens create mode 100644 language/src/main/xtext-gen/org/eclipse/viatra/solver/language/parser/antlr/internal/InternalProblemLexer.java create mode 100644 language/src/main/xtext-gen/org/eclipse/viatra/solver/language/parser/antlr/internal/InternalProblemParser.java create mode 100644 language/src/main/xtext-gen/org/eclipse/viatra/solver/language/scoping/AbstractProblemScopeProvider.java create mode 100644 language/src/main/xtext-gen/org/eclipse/viatra/solver/language/serializer/ProblemSemanticSequencer.java create mode 100644 language/src/main/xtext-gen/org/eclipse/viatra/solver/language/serializer/ProblemSyntacticSequencer.java create mode 100644 language/src/main/xtext-gen/org/eclipse/viatra/solver/language/services/ProblemGrammarAccess.java create mode 100644 language/src/main/xtext-gen/org/eclipse/viatra/solver/language/validation/AbstractProblemValidator.java create mode 100644 language/src/main/xtext-gen/org/eclipse/viatra/solver/language/validation/ProblemConfigurableIssueCodesProvider.java create mode 100644 language/src/test/java/org/eclipse/viatra/solver/language/tests/ProblemParsingTest.xtend create mode 100644 language/src/test/xtext-gen/org/eclipse/viatra/solver/language/tests/ProblemInjectorProvider.java (limited to 'language') diff --git a/language/.classpath b/language/.classpath new file mode 100644 index 00000000..058cfd22 --- /dev/null +++ b/language/.classpath @@ -0,0 +1,62 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/language/.gitignore b/language/.gitignore new file mode 100644 index 00000000..84c048a7 --- /dev/null +++ b/language/.gitignore @@ -0,0 +1 @@ +/build/ diff --git a/language/.launch/Generate Problem (problem) Language Infrastructure.launch b/language/.launch/Generate Problem (problem) Language Infrastructure.launch new file mode 100644 index 00000000..042ecc17 --- /dev/null +++ b/language/.launch/Generate Problem (problem) Language Infrastructure.launch @@ -0,0 +1,14 @@ + + + + + + + + + + + + + + diff --git a/language/.project b/language/.project new file mode 100644 index 00000000..c2d3df18 --- /dev/null +++ b/language/.project @@ -0,0 +1,29 @@ + + + language + + + + + + org.eclipse.jdt.core.javabuilder + + + + + org.eclipse.xtext.ui.shared.xtextBuilder + + + + + org.eclipse.buildship.core.gradleprojectbuilder + + + + + + org.eclipse.buildship.core.gradleprojectnature + org.eclipse.xtext.ui.shared.xtextNature + org.eclipse.jdt.core.javanature + + diff --git a/language/.settings/org.eclipse.core.resources.prefs b/language/.settings/org.eclipse.core.resources.prefs new file mode 100644 index 00000000..99f26c02 --- /dev/null +++ b/language/.settings/org.eclipse.core.resources.prefs @@ -0,0 +1,2 @@ +eclipse.preferences.version=1 +encoding/=UTF-8 diff --git a/language/build.gradle b/language/build.gradle new file mode 100644 index 00000000..f32a60e1 --- /dev/null +++ b/language/build.gradle @@ -0,0 +1,43 @@ +dependencies { + testCompile 'org.junit.jupiter:junit-jupiter-api' + testRuntime 'org.junit.jupiter:junit-jupiter-engine' + testCompile "org.eclipse.xtext:org.eclipse.xtext.testing:${xtextVersion}" + testCompile "org.eclipse.xtext:org.eclipse.xtext.xbase.testing:${xtextVersion}" + compile "org.eclipse.xtext:org.eclipse.xtext:${xtextVersion}" + compile "org.eclipse.xtext:org.eclipse.xtext.xbase:${xtextVersion}" + compile 'org.eclipse.emf:org.eclipse.emf.ecore' + compile project(':language-model') +} + +configurations { + mwe2 { + extendsFrom compile + } +} + +dependencies { + mwe2 'org.eclipse.emf:org.eclipse.emf.mwe2.launch' + mwe2 "org.eclipse.xtext:org.eclipse.xtext.common.types:${xtextVersion}" + mwe2 "org.eclipse.xtext:org.eclipse.xtext.xtext.generator:${xtextVersion}" + mwe2 'org.eclipse.xtext:xtext-antlr-generator' +} + +task generateXtextLanguage(type: JavaExec) { + main = 'org.eclipse.emf.mwe2.launch.runtime.Mwe2Launcher' + classpath = configurations.mwe2 + inputs.file "src/main/java/org/eclipse/viatra/solver/language/GenerateProblem.mwe2" + inputs.file "src/main/java/org/eclipse/viatra/solver/language/Problem.xtext" + outputs.dir "src/main/xtext-gen" + args += "src/main/java/org/eclipse/viatra/solver/language/GenerateProblem.mwe2" + args += "-p" + args += "rootPath=/${projectDir}/.." +} + +test { + useJUnitPlatform() +} + +generateXtext.dependsOn(generateXtextLanguage) +clean.dependsOn(cleanGenerateXtextLanguage) + +eclipse.classpath.plusConfigurations += [configurations.mwe2] diff --git a/language/src/main/java/org/eclipse/viatra/solver/language/GenerateProblem.mwe2 b/language/src/main/java/org/eclipse/viatra/solver/language/GenerateProblem.mwe2 new file mode 100644 index 00000000..76563e2c --- /dev/null +++ b/language/src/main/java/org/eclipse/viatra/solver/language/GenerateProblem.mwe2 @@ -0,0 +1,59 @@ +module org.eclipse.viatra.solver.language.GenerateProblem + +import org.eclipse.xtext.xtext.generator.* +import org.eclipse.xtext.xtext.generator.model.project.* + +var rootPath = ".." + +Workflow { + component = XtextGenerator { + configuration = { + project = StandardProjectConfig { + baseName = "language" + rootPath = rootPath + runtimeTest = { + enabled = true + } + genericIde = { + name = "language-ide" + } + web = { + enabled = true + name = "language-web" + } + mavenLayout = true + } + code = { + encoding = "UTF-8" + lineDelimiter = "\n" + fileHeader = "/*\n * generated by Xtext \${version}\n */" + preferXtendStubs = false + } + } + + language = StandardLanguage { + name = "org.eclipse.viatra.solver.language.Problem" + fileExtensions = "problem" + referencedResource = "platform:/resource/language-model/model/problem.genmodel" + + serializer = { + generateStub = false + } + validator = { + // composedCheck = "org.eclipse.xtext.validation.NamesAreUniqueValidator" + // Generates checks for @Deprecated grammar annotations, an IssueProvider and a corresponding PropertyPage + generateDeprecationValidation = true + } + generator = { + generateXtendStub = true + } + junitSupport = { + junitVersion = "5" + } + webSupport = { + framework = "CodeMirror" + suppressPattern = "string_singleQuote" + } + } + } +} diff --git a/language/src/main/java/org/eclipse/viatra/solver/language/Problem.xtext b/language/src/main/java/org/eclipse/viatra/solver/language/Problem.xtext new file mode 100644 index 00000000..5f8b35f3 --- /dev/null +++ b/language/src/main/java/org/eclipse/viatra/solver/language/Problem.xtext @@ -0,0 +1,116 @@ +grammar org.eclipse.viatra.solver.language.Problem with org.eclipse.xtext.common.Terminals + +import "http://www.eclipse.org/emf/2002/Ecore" as ecore +import "http://www.eclipse.org/viatra/solver/language/model/Problem" + +Problem: + ("problem" name=Identifier ".")? + statements+=Statement*; + +Statement: + ClassDeclaration | EnumDeclaration | PredicateDefinition | Assertion | ScopeDeclaration; + +ClassDeclaration: + abstract?="abstract"? "class" + name=Identifier + ("extends" superTypes+=[Relation|QualifiedName] ("," superTypes+=[Relation|QualifiedName])*)? + ("{" (referenceDeclarations+=ReferenceDeclaration ";"?)* "}" | "."); + +EnumDeclaration: + "enum" + name=Identifier + ("{" (literals+=EnumLiteral ("," literals+=EnumLiteral)* ("," | ";")?)? "}" | "."); + +EnumLiteral returns Node: + name=QuotedOrUnquotedId; + +ReferenceDeclaration: + (containment?="contains" | "refers")? + referenceType=[Relation|QualifiedName] + ("[" multiplicity=Multiplicity "]")? + name=Identifier + ("opposite" opposite=[ReferenceDeclaration|QualifiedName])?; + +PredicateDefinition: + (error?="error" "pred"? | "pred") + name=Identifier + "(" (parameters+=Parameter ("," parameters+=Parameter)*)? ")" + (":-" bodies+=Conjunction (";" bodies+=Conjunction)*)? + "."; + +Parameter: + parameterType=[Relation|QualifiedName]? name=Identifier; + +Conjunction: + literals+=Literal ("," literals+=Literal)*; + +Literal: + Atom | NegativeLiteral; + +NegativeLiteral: + "!" atom=Atom; + +Atom: + relation=[Relation|QualifiedName] + transitiveClosure?="+"? + "(" (arguments+=Argument ("," arguments+=Argument)*)? ")"; + +Argument: + variableOrNode=[VariableOrNode|QualifiedName]; + +Assertion: + (relation=[Relation|QualifiedName] + "(" (arguments+=[Node|QualifiedName] ("," arguments+=[Node|QualifiedName])*)? ")" + ":" value=LogicValue | + value=ShortLogicValue? + relation=[Relation|QualifiedName] + "(" (arguments+=[Node|QualifiedName] ("," arguments+=[Node|QualifiedName])*)? ")") + "."; + +enum LogicValue: + TRUE="true" | FALSE="false" | UNKNOWN="unknown"; + +enum ShortLogicValue returns LogicValue: + FALSE="!" | UNKNOWN="?"; + +ScopeDeclaration: + "scope" typeScopes+=TypeScope ("," typeScopes+=TypeScope)* "."; + +TypeScope: + targetType=[ClassDeclaration] + (increment?="+=" | "=") + multiplicity=DefiniteMultiplicity; + +Multiplicity: + UnboundedMultiplicity | DefiniteMultiplicity; + +DefiniteMultiplicity returns Multiplicity: + RangeMultiplicity | ExactMultiplicity; + +UnboundedMultiplicity: + {UnboundedMultiplicity}; + +RangeMultiplicity: + lowerBound=INT ".." upperBound=UpperBound; + +ExactMultiplicity: + exactValue=INT; + +UpperBound returns ecore::EInt: + INT | "*"; + +QuotedOrUnquotedId: + QUOTED_ID | Identifier; + +QualifiedName: + QUOTED_ID | Identifier (":" Identifier)* (":" QUOTED_ID)?; + +Identifier: + ID | "true" | "false"; + +@Override +terminal STRING: + '"' ('\\' . /* 'b'|'t'|'n'|'f'|'r'|'u'|'"'|"'"|'\\' */ | !('\\' | '"'))* '"'; + +terminal QUOTED_ID: + "'" ('\\' . /* 'b'|'t'|'n'|'f'|'r'|'u'|'"'|"'"|'\\' */ | !('\\' | "'"))* "'"; diff --git a/language/src/main/java/org/eclipse/viatra/solver/language/ProblemRuntimeModule.java b/language/src/main/java/org/eclipse/viatra/solver/language/ProblemRuntimeModule.java new file mode 100644 index 00000000..eb9ddd77 --- /dev/null +++ b/language/src/main/java/org/eclipse/viatra/solver/language/ProblemRuntimeModule.java @@ -0,0 +1,80 @@ +/* + * generated by Xtext 2.25.0 + */ +package org.eclipse.viatra.solver.language; + +import org.eclipse.viatra.solver.language.conversion.ProblemValueConverterService; +import org.eclipse.viatra.solver.language.naming.ProblemQualifiedNameConverter; +import org.eclipse.viatra.solver.language.resource.ProblemDerivedStateComputer; +import org.eclipse.viatra.solver.language.resource.ProblemLocationInFileProvider; +import org.eclipse.viatra.solver.language.resource.ProblemResourceDescriptionStrategy; +import org.eclipse.viatra.solver.language.scoping.ProblemGlobalScopeProvider; +import org.eclipse.viatra.solver.language.scoping.ProblemLocalScopeProvider; +import org.eclipse.xtext.conversion.IValueConverterService; +import org.eclipse.xtext.naming.IQualifiedNameConverter; +import org.eclipse.xtext.resource.DerivedStateAwareResource; +import org.eclipse.xtext.resource.DerivedStateAwareResourceDescriptionManager; +import org.eclipse.xtext.resource.IDefaultResourceDescriptionStrategy; +import org.eclipse.xtext.resource.IDerivedStateComputer; +import org.eclipse.xtext.resource.ILocationInFileProvider; +import org.eclipse.xtext.resource.IResourceDescription; +import org.eclipse.xtext.resource.XtextResource; +import org.eclipse.xtext.scoping.IGlobalScopeProvider; +import org.eclipse.xtext.scoping.IScopeProvider; +import org.eclipse.xtext.scoping.impl.AbstractDeclarativeScopeProvider; +import org.eclipse.xtext.validation.IResourceValidator; +import org.eclipse.xtext.xbase.annotations.validation.DerivedStateAwareResourceValidator; + +import com.google.inject.Binder; +import com.google.inject.name.Names; + +/** + * Use this class to register components to be used at runtime / without the + * Equinox extension registry. + */ +public class ProblemRuntimeModule extends AbstractProblemRuntimeModule { + public Class bindIQualifiedNameConverter() { + return ProblemQualifiedNameConverter.class; + } + + public Class bindIDefaultResourceDescriptionStrategy() { + return ProblemResourceDescriptionStrategy.class; + } + + @Override + public Class bindIValueConverterService() { + return ProblemValueConverterService.class; + } + + @Override + public Class bindIGlobalScopeProvider() { + return ProblemGlobalScopeProvider.class; + } + + @Override + public void configureIScopeProviderDelegate(Binder binder) { + binder.bind(IScopeProvider.class).annotatedWith(Names.named(AbstractDeclarativeScopeProvider.NAMED_DELEGATE)) + .to(ProblemLocalScopeProvider.class); + } + + @Override + public Class bindXtextResource() { + return DerivedStateAwareResource.class; + } + + public Class bindIResourceDescription$Manager() { + return DerivedStateAwareResourceDescriptionManager.class; + } + + public Class bindIResourceValidator() { + return DerivedStateAwareResourceValidator.class; + } + + public Class bindIDerivedStateComputer() { + return ProblemDerivedStateComputer.class; + } + + public Class bindILocationInFileProvider() { + return ProblemLocationInFileProvider.class; + } +} diff --git a/language/src/main/java/org/eclipse/viatra/solver/language/ProblemStandaloneSetup.java b/language/src/main/java/org/eclipse/viatra/solver/language/ProblemStandaloneSetup.java new file mode 100644 index 00000000..5652f859 --- /dev/null +++ b/language/src/main/java/org/eclipse/viatra/solver/language/ProblemStandaloneSetup.java @@ -0,0 +1,26 @@ +/* + * generated by Xtext 2.25.0 + */ +package org.eclipse.viatra.solver.language; + +import org.eclipse.emf.ecore.EPackage; +import org.eclipse.viatra.solver.language.model.problem.ProblemPackage; + +import com.google.inject.Injector; + +/** + * Initialization support for running Xtext languages without Equinox extension registry. + */ +public class ProblemStandaloneSetup extends ProblemStandaloneSetupGenerated { + + public static void doSetup() { + new ProblemStandaloneSetup().createInjectorAndDoEMFRegistration(); + } + + @Override + public Injector createInjectorAndDoEMFRegistration() { + if (!EPackage.Registry.INSTANCE.containsKey(ProblemPackage.eNS_URI)) + EPackage.Registry.INSTANCE.put(ProblemPackage.eNS_URI, ProblemPackage.eINSTANCE); + return super.createInjectorAndDoEMFRegistration(); + } +} diff --git a/language/src/main/java/org/eclipse/viatra/solver/language/ProblemUtil.java b/language/src/main/java/org/eclipse/viatra/solver/language/ProblemUtil.java new file mode 100644 index 00000000..09f062f5 --- /dev/null +++ b/language/src/main/java/org/eclipse/viatra/solver/language/ProblemUtil.java @@ -0,0 +1,98 @@ +package org.eclipse.viatra.solver.language; + +import java.util.ArrayDeque; +import java.util.Collection; +import java.util.Deque; +import java.util.HashSet; +import java.util.Optional; +import java.util.Set; + +import org.eclipse.emf.ecore.EObject; +import org.eclipse.emf.ecore.resource.Resource; +import org.eclipse.viatra.solver.language.model.problem.ClassDeclaration; +import org.eclipse.viatra.solver.language.model.problem.Node; +import org.eclipse.viatra.solver.language.model.problem.Problem; +import org.eclipse.viatra.solver.language.model.problem.ProblemPackage; +import org.eclipse.viatra.solver.language.model.problem.ReferenceDeclaration; +import org.eclipse.viatra.solver.language.model.problem.Relation; +import org.eclipse.viatra.solver.language.model.problem.Variable; +import org.eclipse.viatra.solver.language.scoping.ProblemGlobalScopeProvider; + +import com.google.common.collect.ImmutableList; +import com.google.inject.Singleton; + +@Singleton +public final class ProblemUtil { + private ProblemUtil() { + throw new IllegalStateException("This is a static utility class and should not be instantiated directly"); + } + + public static final String SINGLETON_VARIABLE_PREFIX = "_"; + + public static final String ENUM_NODE_NAME_QUOTE = "'"; + + public static final String NODE_CLASS_NAME = "node"; + + public static boolean isSingletonVariableName(String name) { + return name != null && name.startsWith(SINGLETON_VARIABLE_PREFIX); + } + + public static boolean isSingletonVariable(Variable variable) { + return variable.eContainingFeature() == ProblemPackage.Literals.ARGUMENT__SINGLETON_VARIABLE; + } + + public static boolean isEnumLiteral(Node node) { + return node.eContainingFeature() == ProblemPackage.Literals.ENUM_DECLARATION__LITERALS; + } + + public static boolean isEnumNode(Node node) { + String name = node.getName(); + boolean isNameQuoted = name != null && name.startsWith(ENUM_NODE_NAME_QUOTE) + && name.endsWith(ENUM_NODE_NAME_QUOTE); + return isNameQuoted || isEnumLiteral(node); + } + + public static boolean isNewNode(Node node) { + return node.eContainingFeature() == ProblemPackage.Literals.CLASS_DECLARATION__NEW_NODE; + } + + public static Optional getBuiltInLibrary(EObject context) { + return Optional.ofNullable(context.eResource()).map(Resource::getResourceSet) + .map(resourceSet -> resourceSet.getResource(ProblemGlobalScopeProvider.BULTIN_LIBRARY_URI, true)) + .map(Resource::getContents).filter(contents -> !contents.isEmpty()).map(contents -> contents.get(0)) + .filter(Problem.class::isInstance).map(Problem.class::cast); + } + + public static Optional getNodeClassDeclaration(EObject context) { + return getBuiltInLibrary(context).flatMap(problem -> problem.getStatements().stream() + .filter(ClassDeclaration.class::isInstance).map(ClassDeclaration.class::cast) + .filter(declaration -> NODE_CLASS_NAME.equals(declaration.getName())).findFirst()); + } + + public static Collection getSuperclassesAndSelf(ClassDeclaration classDeclaration) { + Set found = new HashSet<>(); + getNodeClassDeclaration(classDeclaration).ifPresent(found::add); + Deque queue = new ArrayDeque<>(); + queue.addLast(classDeclaration); + while (!queue.isEmpty()) { + ClassDeclaration current = queue.removeFirst(); + if (!found.contains(current)) { + found.add(current); + for (Relation superType : current.getSuperTypes()) { + if (superType instanceof ClassDeclaration) { + queue.addLast((ClassDeclaration) superType); + } + } + } + } + return found; + } + + public static Collection getAllReferenceDeclarations(ClassDeclaration classDeclaration) { + ImmutableList.Builder builder = ImmutableList.builder(); + for (ClassDeclaration superclass : getSuperclassesAndSelf(classDeclaration)) { + builder.addAll(superclass.getReferenceDeclarations()); + } + return builder.build(); + } +} diff --git a/language/src/main/java/org/eclipse/viatra/solver/language/conversion/ProblemValueConverterService.java b/language/src/main/java/org/eclipse/viatra/solver/language/conversion/ProblemValueConverterService.java new file mode 100644 index 00000000..4f5fd069 --- /dev/null +++ b/language/src/main/java/org/eclipse/viatra/solver/language/conversion/ProblemValueConverterService.java @@ -0,0 +1,17 @@ +package org.eclipse.viatra.solver.language.conversion; + +import org.eclipse.xtext.common.services.DefaultTerminalConverters; +import org.eclipse.xtext.conversion.IValueConverter; +import org.eclipse.xtext.conversion.ValueConverter; + +import com.google.inject.Inject; + +public class ProblemValueConverterService extends DefaultTerminalConverters { + @Inject + private UpperBoundValueConverter upperBoundValueConverter; + + @ValueConverter(rule = "UpperBound") + public IValueConverter UpperBound() { + return upperBoundValueConverter; + } +} diff --git a/language/src/main/java/org/eclipse/viatra/solver/language/conversion/UpperBoundValueConverter.java b/language/src/main/java/org/eclipse/viatra/solver/language/conversion/UpperBoundValueConverter.java new file mode 100644 index 00000000..3111b69b --- /dev/null +++ b/language/src/main/java/org/eclipse/viatra/solver/language/conversion/UpperBoundValueConverter.java @@ -0,0 +1,35 @@ +package org.eclipse.viatra.solver.language.conversion; + +import org.eclipse.xtext.conversion.ValueConverterException; +import org.eclipse.xtext.conversion.impl.AbstractValueConverter; +import org.eclipse.xtext.conversion.impl.INTValueConverter; +import org.eclipse.xtext.nodemodel.INode; + +import com.google.inject.Inject; +import com.google.inject.Singleton; + +@Singleton +public class UpperBoundValueConverter extends AbstractValueConverter { + public static final String INFINITY = "*"; + + @Inject + private INTValueConverter intValueConverter; + + @Override + public Integer toValue(String string, INode node) throws ValueConverterException { + if (INFINITY.equals(string)) { + return -1; + } else { + return intValueConverter.toValue(string, node); + } + } + + @Override + public String toString(Integer value) throws ValueConverterException { + if (value < 0) { + return INFINITY; + } else { + return intValueConverter.toString(value); + } + } +} diff --git a/language/src/main/java/org/eclipse/viatra/solver/language/generator/ProblemGenerator.xtend b/language/src/main/java/org/eclipse/viatra/solver/language/generator/ProblemGenerator.xtend new file mode 100644 index 00000000..0930f244 --- /dev/null +++ b/language/src/main/java/org/eclipse/viatra/solver/language/generator/ProblemGenerator.xtend @@ -0,0 +1,25 @@ +/* + * generated by Xtext 2.25.0 + */ +package org.eclipse.viatra.solver.language.generator + +import org.eclipse.emf.ecore.resource.Resource +import org.eclipse.xtext.generator.AbstractGenerator +import org.eclipse.xtext.generator.IFileSystemAccess2 +import org.eclipse.xtext.generator.IGeneratorContext + +/** + * Generates code from your model files on save. + * + * See https://www.eclipse.org/Xtext/documentation/303_runtime_concepts.html#code-generation + */ +class ProblemGenerator extends AbstractGenerator { + + override void doGenerate(Resource resource, IFileSystemAccess2 fsa, IGeneratorContext context) { +// fsa.generateFile('greetings.txt', 'People to greet: ' + +// resource.allContents +// .filter(Greeting) +// .map[name] +// .join(', ')) + } +} diff --git a/language/src/main/java/org/eclipse/viatra/solver/language/naming/ProblemQualifiedNameConverter.java b/language/src/main/java/org/eclipse/viatra/solver/language/naming/ProblemQualifiedNameConverter.java new file mode 100644 index 00000000..3cee31f3 --- /dev/null +++ b/language/src/main/java/org/eclipse/viatra/solver/language/naming/ProblemQualifiedNameConverter.java @@ -0,0 +1,15 @@ +package org.eclipse.viatra.solver.language.naming; + +import org.eclipse.xtext.naming.IQualifiedNameConverter; + +import com.google.inject.Singleton; + +@Singleton +public class ProblemQualifiedNameConverter extends IQualifiedNameConverter.DefaultImpl { + public static final String DELIMITER = ":"; + + @Override + public String getDelimiter() { + return DELIMITER; + } +} diff --git a/language/src/main/java/org/eclipse/viatra/solver/language/resource/ProblemDerivedStateComputer.java b/language/src/main/java/org/eclipse/viatra/solver/language/resource/ProblemDerivedStateComputer.java new file mode 100644 index 00000000..b885ce0e --- /dev/null +++ b/language/src/main/java/org/eclipse/viatra/solver/language/resource/ProblemDerivedStateComputer.java @@ -0,0 +1,299 @@ +package org.eclipse.viatra.solver.language.resource; + +import java.util.HashSet; +import java.util.List; +import java.util.Set; +import java.util.function.Predicate; +import java.util.regex.Pattern; + +import org.eclipse.emf.ecore.EObject; +import org.eclipse.emf.ecore.EStructuralFeature; +import org.eclipse.viatra.solver.language.ProblemUtil; +import org.eclipse.viatra.solver.language.model.problem.Argument; +import org.eclipse.viatra.solver.language.model.problem.Assertion; +import org.eclipse.viatra.solver.language.model.problem.Atom; +import org.eclipse.viatra.solver.language.model.problem.ClassDeclaration; +import org.eclipse.viatra.solver.language.model.problem.Conjunction; +import org.eclipse.viatra.solver.language.model.problem.ExistentialQuantifier; +import org.eclipse.viatra.solver.language.model.problem.ImplicitVariable; +import org.eclipse.viatra.solver.language.model.problem.Literal; +import org.eclipse.viatra.solver.language.model.problem.NegativeLiteral; +import org.eclipse.viatra.solver.language.model.problem.Node; +import org.eclipse.viatra.solver.language.model.problem.Parameter; +import org.eclipse.viatra.solver.language.model.problem.PredicateDefinition; +import org.eclipse.viatra.solver.language.model.problem.Problem; +import org.eclipse.viatra.solver.language.model.problem.ProblemFactory; +import org.eclipse.viatra.solver.language.model.problem.ProblemPackage; +import org.eclipse.viatra.solver.language.model.problem.Statement; +import org.eclipse.xtext.linking.impl.LinkingHelper; +import org.eclipse.xtext.naming.IQualifiedNameConverter; +import org.eclipse.xtext.naming.QualifiedName; +import org.eclipse.xtext.nodemodel.INode; +import org.eclipse.xtext.nodemodel.util.NodeModelUtils; +import org.eclipse.xtext.resource.DerivedStateAwareResource; +import org.eclipse.xtext.resource.IDerivedStateComputer; +import org.eclipse.xtext.scoping.IScope; +import org.eclipse.xtext.scoping.IScopeProvider; +import org.eclipse.xtext.scoping.impl.AbstractDeclarativeScopeProvider; + +import com.google.inject.Inject; +import com.google.inject.Singleton; +import com.google.inject.name.Named; + +@Singleton +public class ProblemDerivedStateComputer implements IDerivedStateComputer { + public static final String NEW_NODE = "new"; + + private static final Pattern ID_REGEX = Pattern.compile("[_a-zA-Z][_0-9a-zA-Z]*"); + + private static final Pattern QUOTED_ID_REGEX = Pattern.compile("'(\\\\.|[^\\'])*'"); + + @Inject + private LinkingHelper linkingHelper; + + @Inject + private IQualifiedNameConverter qualifiedNameConverter; + + @Inject + @Named(AbstractDeclarativeScopeProvider.NAMED_DELEGATE) + private IScopeProvider scopeProvider; + + @Override + public void installDerivedState(DerivedStateAwareResource resource, boolean preLinkingPhase) { + for (EObject object : resource.getContents()) { + if (object instanceof Problem) { + installDerivedProblemState((Problem) object, preLinkingPhase); + } + } + } + + protected void installDerivedProblemState(Problem problem, boolean preLinkingPhase) { + installNewNodes(problem); + if (!preLinkingPhase) { + installDerivedNodes(problem); + for (Statement statement : problem.getStatements()) { + if (statement instanceof PredicateDefinition) { + PredicateDefinition definition = (PredicateDefinition) statement; + installDerivedPredicateDefinitionState(definition); + } + } + } + } + + protected void installNewNodes(Problem problem) { + for (Statement statement : problem.getStatements()) { + if (statement instanceof ClassDeclaration) { + ClassDeclaration declaration = (ClassDeclaration) statement; + if (!declaration.isAbstract()) { + Node newNode = createNode(NEW_NODE); + declaration.setNewNode(newNode); + } + } + } + } + + protected void installDerivedNodes(Problem problem) { + IScope nodeScope = scopeProvider.getScope(problem, ProblemPackage.Literals.ASSERTION__ARGUMENTS); + Set nodeNames = new HashSet<>(); + for (Statement statement : problem.getStatements()) { + if (statement instanceof Assertion) { + addNodeNames(nodeNames, nodeScope, statement, ProblemPackage.Literals.ASSERTION__ARGUMENTS, + ProblemDerivedStateComputer::validNodeName); + } else if (statement instanceof PredicateDefinition) { + PredicateDefinition predicateDefinition = (PredicateDefinition) statement; + for (Conjunction body : predicateDefinition.getBodies()) { + for (Literal literal : body.getLiterals()) { + Atom atom = null; + if (literal instanceof Atom) { + atom = (Atom) literal; + } else if (literal instanceof NegativeLiteral) { + NegativeLiteral negativeLiteral = (NegativeLiteral) literal; + atom = negativeLiteral.getAtom(); + } + if (atom == null) { + continue; + } + for (Argument argument : atom.getArguments()) { + addNodeNames(nodeNames, nodeScope, argument, + ProblemPackage.Literals.ARGUMENT__VARIABLE_OR_NODE, + ProblemDerivedStateComputer::validQuotedId); + } + } + } + } + } + List grapNodes = problem.getNodes(); + for (String nodeName : nodeNames) { + Node graphNode = createNode(nodeName); + grapNodes.add(graphNode); + } + } + + private void addNodeNames(Set nodeNames, IScope nodeScope, EObject eObject, EStructuralFeature feature, + Predicate condition) { + List nodes = NodeModelUtils.findNodesForFeature(eObject, feature); + for (INode node : nodes) { + String nodeName = linkingHelper.getCrossRefNodeAsString(node, true); + if (!condition.test(nodeName)) { + continue; + } + QualifiedName qualifiedName = qualifiedNameConverter.toQualifiedName(nodeName); + if (!nodeNames.contains(nodeName) && nodeScope.getSingleElement(qualifiedName) == null) { + nodeNames.add(nodeName); + } + } + } + + protected Node createNode(String name) { + Node node = ProblemFactory.eINSTANCE.createNode(); + node.setName(name); + return node; + } + + protected void installDerivedPredicateDefinitionState(PredicateDefinition definition) { + Set parameterNames = new HashSet<>(); + for (Parameter parameter : definition.getParameters()) { + String name = parameter.getName(); + if (name != null) { + parameterNames.add(name); + } + } + for (Conjunction body : definition.getBodies()) { + installDeriveConjunctionState(body, parameterNames); + } + } + + protected void installDeriveConjunctionState(Conjunction conjunction, Set knownVariables) { + Set newVariables = new HashSet<>(); + for (Literal literal : conjunction.getLiterals()) { + if (literal instanceof Atom) { + Atom atom = (Atom) literal; + createSigletonVariablesAndCollectVariables(atom, knownVariables, newVariables); + } + } + createVariables(conjunction, newVariables); + newVariables.addAll(knownVariables); + for (Literal literal : conjunction.getLiterals()) { + if (literal instanceof NegativeLiteral) { + NegativeLiteral negativeLiteral = (NegativeLiteral) literal; + installDeriveNegativeLiteralState(negativeLiteral, newVariables); + } + } + } + + protected void installDeriveNegativeLiteralState(NegativeLiteral negativeLiteral, Set knownVariables) { + Set newVariables = new HashSet<>(); + createSigletonVariablesAndCollectVariables(negativeLiteral.getAtom(), knownVariables, newVariables); + createVariables(negativeLiteral, newVariables); + } + + protected void createSigletonVariablesAndCollectVariables(Atom atom, Set knownVariables, + Set newVariables) { + IScope scope = scopeProvider.getScope(atom, ProblemPackage.Literals.ARGUMENT__VARIABLE_OR_NODE); + List nodes = NodeModelUtils.findNodesForFeature(atom, ProblemPackage.Literals.ATOM__ARGUMENTS); + int nodesSize = nodes.size(); + List arguments = atom.getArguments(); + int argumentsSize = arguments.size(); + for (int i = 0; i < nodesSize; i++) { + INode node = nodes.get(i); + String variableName = linkingHelper.getCrossRefNodeAsString(node, true); + if (!validId(variableName)) { + continue; + } + QualifiedName qualifiedName = qualifiedNameConverter.toQualifiedName(variableName); + if (scope.getSingleElement(qualifiedName) != null) { + continue; + } + if (ProblemUtil.isSingletonVariableName(variableName)) { + if (i < argumentsSize) { + createSingletonVariable(arguments.get(i), variableName); + } + continue; + } + if (!knownVariables.contains(variableName)) { + newVariables.add(variableName); + } + } + } + + protected void createVariables(ExistentialQuantifier quantifier, Set newVariables) { + for (String variableName : newVariables) { + createVariable(quantifier, variableName); + } + } + + protected void createVariable(ExistentialQuantifier quantifier, String variableName) { + if (validId(variableName)) { + ImplicitVariable variable = createNamedVariable(variableName); + quantifier.getImplicitVariables().add(variable); + } + } + + protected void createSingletonVariable(Argument argument, String variableName) { + if (validId(variableName)) { + ImplicitVariable variable = createNamedVariable(variableName); + argument.setSingletonVariable(variable); + } + } + + protected ImplicitVariable createNamedVariable(String variableName) { + ImplicitVariable variable = ProblemFactory.eINSTANCE.createImplicitVariable(); + variable.setName(variableName); + return variable; + } + + @Override + public void discardDerivedState(DerivedStateAwareResource resource) { + for (EObject object : resource.getContents()) { + if (object instanceof Problem) { + discardDerivedProblemState((Problem) object); + } + } + } + + protected void discardDerivedProblemState(Problem problem) { + problem.getNodes().clear(); + for (Statement statement : problem.getStatements()) { + if (statement instanceof ClassDeclaration) { + ClassDeclaration classDeclaration = (ClassDeclaration) statement; + classDeclaration.setNewNode(null); + } else if (statement instanceof PredicateDefinition) { + PredicateDefinition definition = (PredicateDefinition) statement; + for (Conjunction body : definition.getBodies()) { + body.getImplicitVariables().clear(); + for (Literal literal : body.getLiterals()) { + if (literal instanceof Atom) { + discardDerivedAtomState((Atom) literal); + } + if (literal instanceof NegativeLiteral) { + NegativeLiteral negativeLiteral = (NegativeLiteral) literal; + negativeLiteral.getImplicitVariables().clear(); + discardDerivedAtomState(negativeLiteral.getAtom()); + } + } + } + } + } + } + + protected void discardDerivedAtomState(Atom atom) { + if (atom == null) { + return; + } + for (Argument argument : atom.getArguments()) { + argument.setSingletonVariable(null); + } + } + + protected static boolean validId(String name) { + return name != null && ID_REGEX.matcher(name).matches(); + } + + protected static boolean validQuotedId(String name) { + return name != null && QUOTED_ID_REGEX.matcher(name).matches(); + } + + protected static boolean validNodeName(String name) { + return validId(name) || validQuotedId(name); + } +} diff --git a/language/src/main/java/org/eclipse/viatra/solver/language/resource/ProblemLocationInFileProvider.java b/language/src/main/java/org/eclipse/viatra/solver/language/resource/ProblemLocationInFileProvider.java new file mode 100644 index 00000000..94dbdfee --- /dev/null +++ b/language/src/main/java/org/eclipse/viatra/solver/language/resource/ProblemLocationInFileProvider.java @@ -0,0 +1,32 @@ +package org.eclipse.viatra.solver.language.resource; + +import org.eclipse.emf.ecore.EObject; +import org.eclipse.viatra.solver.language.ProblemUtil; +import org.eclipse.viatra.solver.language.model.problem.ImplicitVariable; +import org.eclipse.viatra.solver.language.model.problem.Node; +import org.eclipse.xtext.resource.DefaultLocationInFileProvider; +import org.eclipse.xtext.util.ITextRegion; + +public class ProblemLocationInFileProvider extends DefaultLocationInFileProvider { + @Override + protected ITextRegion doGetTextRegion(EObject obj, RegionDescription query) { + if (obj instanceof Node) { + return getNodeTextRegion((Node) obj, query); + } + if (obj instanceof ImplicitVariable) { + return ITextRegion.EMPTY_REGION; + } + return super.doGetTextRegion(obj, query); + } + + protected ITextRegion getNodeTextRegion(Node node, RegionDescription query) { + if (ProblemUtil.isEnumLiteral(node)) { + return super.doGetTextRegion(node, query); + } + if (ProblemUtil.isNewNode(node)) { + EObject container = node.eContainer(); + return doGetTextRegion(container, query); + } + return ITextRegion.EMPTY_REGION; + } +} diff --git a/language/src/main/java/org/eclipse/viatra/solver/language/resource/ProblemResourceDescriptionStrategy.java b/language/src/main/java/org/eclipse/viatra/solver/language/resource/ProblemResourceDescriptionStrategy.java new file mode 100644 index 00000000..edb25a1c --- /dev/null +++ b/language/src/main/java/org/eclipse/viatra/solver/language/resource/ProblemResourceDescriptionStrategy.java @@ -0,0 +1,89 @@ +package org.eclipse.viatra.solver.language.resource; + +import org.eclipse.emf.ecore.EObject; +import org.eclipse.viatra.solver.language.ProblemUtil; +import org.eclipse.viatra.solver.language.model.problem.NamedElement; +import org.eclipse.viatra.solver.language.model.problem.Node; +import org.eclipse.viatra.solver.language.model.problem.Problem; +import org.eclipse.viatra.solver.language.model.problem.Variable; +import org.eclipse.xtext.EcoreUtil2; +import org.eclipse.xtext.naming.IQualifiedNameConverter; +import org.eclipse.xtext.naming.QualifiedName; +import org.eclipse.xtext.resource.EObjectDescription; +import org.eclipse.xtext.resource.IEObjectDescription; +import org.eclipse.xtext.resource.impl.DefaultResourceDescriptionStrategy; +import org.eclipse.xtext.util.IAcceptor; + +import com.google.inject.Inject; +import com.google.inject.Singleton; + +@Singleton +public class ProblemResourceDescriptionStrategy extends DefaultResourceDescriptionStrategy { + @Inject + private IQualifiedNameConverter qualifiedNameConverter; + + @Override + public boolean createEObjectDescriptions(EObject eObject, IAcceptor acceptor) { + if (eObject instanceof Variable) { + return false; + } + if (eObject instanceof NamedElement) { + NamedElement namedElement = (NamedElement) eObject; + String name = namedElement.getName(); + if (name == null || name.isEmpty()) { + return true; + } + Problem problem = EcoreUtil2.getContainerOfType(namedElement, Problem.class); + QualifiedName problemQualifiedName = null; + if (problem != null) { + String problemName = problem.getName(); + if (problemName != null && !problemName.isEmpty()) { + problemQualifiedName = qualifiedNameConverter.toQualifiedName(problemName); + } + } + QualifiedName qualifiedName = qualifiedNameConverter.toQualifiedName(namedElement.getName()); + boolean nameExported; + if (shouldExportSimpleName(namedElement)) { + acceptEObjectDescription(namedElement, problemQualifiedName, qualifiedName, acceptor); + nameExported = true; + } else { + nameExported = false; + } + EObject parent = namedElement.eContainer(); + while (parent != null && parent != problem) { + if (parent instanceof NamedElement) { + NamedElement namedParent = (NamedElement) parent; + String parentName = namedParent.getName(); + if (parentName != null || !name.isEmpty()) { + QualifiedName parentQualifiedName = qualifiedNameConverter.toQualifiedName(parentName); + qualifiedName = parentQualifiedName.append(qualifiedName); + if (shouldExportSimpleName(parent)) { + acceptEObjectDescription(namedElement, problemQualifiedName, qualifiedName, acceptor); + nameExported = true; + } else { + nameExported = false; + } + } + } + parent = parent.eContainer(); + } + if (!nameExported) { + acceptEObjectDescription(namedElement, problemQualifiedName, qualifiedName, acceptor); + } + } + return true; + } + + protected boolean shouldExportSimpleName(EObject eObject) { + if (eObject instanceof Node) { + return !ProblemUtil.isNewNode((Node) eObject); + } + return true; + } + + private void acceptEObjectDescription(EObject eObject, QualifiedName prefix, QualifiedName qualifiedName, + IAcceptor acceptor) { + QualifiedName qualifiedNameWithPrefix = prefix == null ? qualifiedName : prefix.append(qualifiedName); + acceptor.accept(EObjectDescription.create(qualifiedNameWithPrefix, eObject)); + } +} diff --git a/language/src/main/java/org/eclipse/viatra/solver/language/scoping/ProblemGlobalScopeProvider.java b/language/src/main/java/org/eclipse/viatra/solver/language/scoping/ProblemGlobalScopeProvider.java new file mode 100644 index 00000000..05da277a --- /dev/null +++ b/language/src/main/java/org/eclipse/viatra/solver/language/scoping/ProblemGlobalScopeProvider.java @@ -0,0 +1,25 @@ +package org.eclipse.viatra.solver.language.scoping; + +import java.util.LinkedHashSet; + +import org.eclipse.emf.common.util.URI; +import org.eclipse.emf.ecore.resource.Resource; +import org.eclipse.xtext.scoping.impl.ImportUriGlobalScopeProvider; + +public class ProblemGlobalScopeProvider extends ImportUriGlobalScopeProvider { + public static final String BUILTIN_LIBRARY_NAME = "builtin"; + + public static final URI BULTIN_LIBRARY_URI = getLibraryUri(BUILTIN_LIBRARY_NAME); + + @Override + protected LinkedHashSet getImportedUris(Resource resource) { + LinkedHashSet importedUris = new LinkedHashSet<>(); + importedUris.add(BULTIN_LIBRARY_URI); + return importedUris; + } + + private static URI getLibraryUri(String libraryName) { + return URI.createURI(ProblemGlobalScopeProvider.class.getClassLoader() + .getResource("org/eclipse/viatra/solver/language/" + libraryName + ".problem").toString()); + } +} diff --git a/language/src/main/java/org/eclipse/viatra/solver/language/scoping/ProblemLocalScopeProvider.java b/language/src/main/java/org/eclipse/viatra/solver/language/scoping/ProblemLocalScopeProvider.java new file mode 100644 index 00000000..e832bb09 --- /dev/null +++ b/language/src/main/java/org/eclipse/viatra/solver/language/scoping/ProblemLocalScopeProvider.java @@ -0,0 +1,40 @@ +package org.eclipse.viatra.solver.language.scoping; + +import java.util.List; + +import org.eclipse.emf.ecore.EObject; +import org.eclipse.emf.ecore.resource.Resource; +import org.eclipse.xtext.naming.QualifiedName; +import org.eclipse.xtext.resource.IResourceDescriptions; +import org.eclipse.xtext.resource.IResourceDescriptionsProvider; +import org.eclipse.xtext.resource.ISelectable; +import org.eclipse.xtext.scoping.impl.ImportNormalizer; +import org.eclipse.xtext.scoping.impl.ImportedNamespaceAwareLocalScopeProvider; + +import com.google.inject.Inject; + +public class ProblemLocalScopeProvider extends ImportedNamespaceAwareLocalScopeProvider { + private static final QualifiedName BUILTIN_LIBRARY_QUALIFIED_NAME = QualifiedName + .create(ProblemGlobalScopeProvider.BUILTIN_LIBRARY_NAME); + + @Inject + private IResourceDescriptionsProvider resourceDescriptionsProvider; + + @Override + protected List getImplicitImports(boolean ignoreCase) { + return List.of(doCreateImportNormalizer(BUILTIN_LIBRARY_QUALIFIED_NAME, true, ignoreCase)); + } + + @Override + protected List getImportedNamespaceResolvers(EObject context, boolean ignoreCase) { + return List.of(); + } + + @Override + protected ISelectable internalGetAllDescriptions(Resource resource) { + // Force the use of ProblemResourceDescriptionStrategy to include all QualifiedNames of objects. + IResourceDescriptions resourceDescriptions = resourceDescriptionsProvider + .getResourceDescriptions(resource.getResourceSet()); + return resourceDescriptions.getResourceDescription(resource.getURI()); + } +} diff --git a/language/src/main/java/org/eclipse/viatra/solver/language/scoping/ProblemScopeProvider.java b/language/src/main/java/org/eclipse/viatra/solver/language/scoping/ProblemScopeProvider.java new file mode 100644 index 00000000..fc4034ae --- /dev/null +++ b/language/src/main/java/org/eclipse/viatra/solver/language/scoping/ProblemScopeProvider.java @@ -0,0 +1,83 @@ +/* + * generated by Xtext 2.25.0 + */ +package org.eclipse.viatra.solver.language.scoping; + +import java.util.ArrayList; +import java.util.Collection; +import java.util.List; + +import org.eclipse.emf.ecore.EObject; +import org.eclipse.emf.ecore.EReference; +import org.eclipse.viatra.solver.language.ProblemUtil; +import org.eclipse.viatra.solver.language.model.problem.Argument; +import org.eclipse.viatra.solver.language.model.problem.ClassDeclaration; +import org.eclipse.viatra.solver.language.model.problem.ExistentialQuantifier; +import org.eclipse.viatra.solver.language.model.problem.PredicateDefinition; +import org.eclipse.viatra.solver.language.model.problem.ProblemPackage; +import org.eclipse.viatra.solver.language.model.problem.ReferenceDeclaration; +import org.eclipse.viatra.solver.language.model.problem.Relation; +import org.eclipse.viatra.solver.language.model.problem.Variable; +import org.eclipse.xtext.EcoreUtil2; +import org.eclipse.xtext.scoping.IScope; +import org.eclipse.xtext.scoping.Scopes; + +/** + * This class contains custom scoping description. + * + * See + * https://www.eclipse.org/Xtext/documentation/303_runtime_concepts.html#scoping + * on how and when to use it. + */ +public class ProblemScopeProvider extends AbstractProblemScopeProvider { + + @Override + public IScope getScope(EObject context, EReference reference) { + IScope scope = super.getScope(context, reference); + if (reference == ProblemPackage.Literals.ARGUMENT__VARIABLE_OR_NODE) { + return getVariableScope(context, scope); + } else if (reference == ProblemPackage.Literals.REFERENCE_DECLARATION__OPPOSITE) { + return getOppositeScope(context, scope); + } + return scope; + } + + protected IScope getVariableScope(EObject context, IScope delegateScope) { + List variables = new ArrayList<>(); + EObject currentContext = context; + if (context instanceof Argument) { + Argument argument = (Argument) context; + Variable singletonVariable = argument.getSingletonVariable(); + if (singletonVariable != null) { + variables.add(singletonVariable); + } + } + while (currentContext != null && !(currentContext instanceof PredicateDefinition)) { + if (currentContext instanceof ExistentialQuantifier) { + ExistentialQuantifier quantifier = (ExistentialQuantifier) currentContext; + variables.addAll(quantifier.getImplicitVariables()); + } + currentContext = currentContext.eContainer(); + } + if (currentContext instanceof PredicateDefinition) { + PredicateDefinition definition = (PredicateDefinition) currentContext; + variables.addAll(definition.getParameters()); + } + return Scopes.scopeFor(variables, delegateScope); + } + + protected IScope getOppositeScope(EObject context, IScope delegateScope) { + ReferenceDeclaration referenceDeclaration = EcoreUtil2.getContainerOfType(context, ReferenceDeclaration.class); + if (referenceDeclaration == null) { + return delegateScope; + } + Relation relation = referenceDeclaration.getReferenceType(); + if (!(relation instanceof ClassDeclaration)) { + return delegateScope; + } + ClassDeclaration classDeclaration = (ClassDeclaration) relation; + Collection referenceDeclarations = ProblemUtil + .getAllReferenceDeclarations(classDeclaration); + return Scopes.scopeFor(referenceDeclarations, delegateScope); + } +} diff --git a/language/src/main/java/org/eclipse/viatra/solver/language/validation/ProblemValidator.java b/language/src/main/java/org/eclipse/viatra/solver/language/validation/ProblemValidator.java new file mode 100644 index 00000000..2b17e222 --- /dev/null +++ b/language/src/main/java/org/eclipse/viatra/solver/language/validation/ProblemValidator.java @@ -0,0 +1,25 @@ +/* + * generated by Xtext 2.25.0 + */ +package org.eclipse.viatra.solver.language.validation; + + +/** + * This class contains custom validation rules. + * + * See https://www.eclipse.org/Xtext/documentation/303_runtime_concepts.html#validation + */ +public class ProblemValidator extends AbstractProblemValidator { + +// public static final String INVALID_NAME = "invalidName"; +// +// @Check +// public void checkGreetingStartsWithCapital(Greeting greeting) { +// if (!Character.isUpperCase(greeting.getName().charAt(0))) { +// warning("Name should start with a capital", +// ProblemPackage.Literals.GREETING__NAME, +// INVALID_NAME); +// } +// } + +} diff --git a/language/src/main/resources/org/eclipse/viatra/solver/language/builtin.problem b/language/src/main/resources/org/eclipse/viatra/solver/language/builtin.problem new file mode 100644 index 00000000..13398ce8 --- /dev/null +++ b/language/src/main/resources/org/eclipse/viatra/solver/language/builtin.problem @@ -0,0 +1,17 @@ +problem builtin. + +abstract class node { + node[] equals opposite equals +} + +pred exists(node node). + +enum bool { + true, false +} + +class double. + +class int extends double. + +class string. diff --git a/language/src/main/xtext-gen/org/eclipse/viatra/solver/language/AbstractProblemRuntimeModule.java b/language/src/main/xtext-gen/org/eclipse/viatra/solver/language/AbstractProblemRuntimeModule.java new file mode 100644 index 00000000..642b465b --- /dev/null +++ b/language/src/main/xtext-gen/org/eclipse/viatra/solver/language/AbstractProblemRuntimeModule.java @@ -0,0 +1,201 @@ +/* + * generated by Xtext 2.26.0.M1 + */ +package org.eclipse.viatra.solver.language; + +import com.google.inject.Binder; +import com.google.inject.Provider; +import com.google.inject.name.Names; +import java.util.Properties; +import org.eclipse.viatra.solver.language.generator.ProblemGenerator; +import org.eclipse.viatra.solver.language.parser.antlr.ProblemAntlrTokenFileProvider; +import org.eclipse.viatra.solver.language.parser.antlr.ProblemParser; +import org.eclipse.viatra.solver.language.parser.antlr.internal.InternalProblemLexer; +import org.eclipse.viatra.solver.language.scoping.ProblemScopeProvider; +import org.eclipse.viatra.solver.language.serializer.ProblemSemanticSequencer; +import org.eclipse.viatra.solver.language.serializer.ProblemSyntacticSequencer; +import org.eclipse.viatra.solver.language.services.ProblemGrammarAccess; +import org.eclipse.viatra.solver.language.validation.ProblemConfigurableIssueCodesProvider; +import org.eclipse.viatra.solver.language.validation.ProblemValidator; +import org.eclipse.xtext.Constants; +import org.eclipse.xtext.IGrammarAccess; +import org.eclipse.xtext.generator.IGenerator2; +import org.eclipse.xtext.naming.DefaultDeclarativeQualifiedNameProvider; +import org.eclipse.xtext.naming.IQualifiedNameProvider; +import org.eclipse.xtext.parser.IParser; +import org.eclipse.xtext.parser.ITokenToStringConverter; +import org.eclipse.xtext.parser.antlr.AntlrTokenDefProvider; +import org.eclipse.xtext.parser.antlr.AntlrTokenToStringConverter; +import org.eclipse.xtext.parser.antlr.IAntlrTokenFileProvider; +import org.eclipse.xtext.parser.antlr.ITokenDefProvider; +import org.eclipse.xtext.parser.antlr.Lexer; +import org.eclipse.xtext.parser.antlr.LexerBindings; +import org.eclipse.xtext.parser.antlr.LexerProvider; +import org.eclipse.xtext.resource.IContainer; +import org.eclipse.xtext.resource.IResourceDescriptions; +import org.eclipse.xtext.resource.containers.IAllContainersState; +import org.eclipse.xtext.resource.containers.ResourceSetBasedAllContainersStateProvider; +import org.eclipse.xtext.resource.containers.StateBasedContainerManager; +import org.eclipse.xtext.resource.impl.ResourceDescriptionsProvider; +import org.eclipse.xtext.resource.impl.ResourceSetBasedResourceDescriptions; +import org.eclipse.xtext.scoping.IGlobalScopeProvider; +import org.eclipse.xtext.scoping.IScopeProvider; +import org.eclipse.xtext.scoping.IgnoreCaseLinking; +import org.eclipse.xtext.scoping.impl.AbstractDeclarativeScopeProvider; +import org.eclipse.xtext.scoping.impl.DefaultGlobalScopeProvider; +import org.eclipse.xtext.scoping.impl.ImportedNamespaceAwareLocalScopeProvider; +import org.eclipse.xtext.serializer.ISerializer; +import org.eclipse.xtext.serializer.impl.Serializer; +import org.eclipse.xtext.serializer.sequencer.ISemanticSequencer; +import org.eclipse.xtext.serializer.sequencer.ISyntacticSequencer; +import org.eclipse.xtext.service.DefaultRuntimeModule; +import org.eclipse.xtext.service.SingletonBinding; +import org.eclipse.xtext.validation.ConfigurableIssueCodesProvider; + +/** + * Manual modifications go to {@link ProblemRuntimeModule}. + */ +@SuppressWarnings("all") +public abstract class AbstractProblemRuntimeModule extends DefaultRuntimeModule { + + protected Properties properties = null; + + @Override + public void configure(Binder binder) { + properties = tryBindProperties(binder, "org/eclipse/viatra/solver/language/Problem.properties"); + super.configure(binder); + } + + public void configureLanguageName(Binder binder) { + binder.bind(String.class).annotatedWith(Names.named(Constants.LANGUAGE_NAME)).toInstance("org.eclipse.viatra.solver.language.Problem"); + } + + public void configureFileExtensions(Binder binder) { + if (properties == null || properties.getProperty(Constants.FILE_EXTENSIONS) == null) + binder.bind(String.class).annotatedWith(Names.named(Constants.FILE_EXTENSIONS)).toInstance("problem"); + } + + // contributed by org.eclipse.xtext.xtext.generator.grammarAccess.GrammarAccessFragment2 + public ClassLoader bindClassLoaderToInstance() { + return getClass().getClassLoader(); + } + + // contributed by org.eclipse.xtext.xtext.generator.grammarAccess.GrammarAccessFragment2 + public Class bindIGrammarAccess() { + return ProblemGrammarAccess.class; + } + + // contributed by org.eclipse.xtext.xtext.generator.serializer.SerializerFragment2 + public Class bindISemanticSequencer() { + return ProblemSemanticSequencer.class; + } + + // contributed by org.eclipse.xtext.xtext.generator.serializer.SerializerFragment2 + public Class bindISyntacticSequencer() { + return ProblemSyntacticSequencer.class; + } + + // contributed by org.eclipse.xtext.xtext.generator.serializer.SerializerFragment2 + public Class bindISerializer() { + return Serializer.class; + } + + // contributed by org.eclipse.xtext.xtext.generator.parser.antlr.XtextAntlrGeneratorFragment2 + public Class bindIParser() { + return ProblemParser.class; + } + + // contributed by org.eclipse.xtext.xtext.generator.parser.antlr.XtextAntlrGeneratorFragment2 + public Class bindITokenToStringConverter() { + return AntlrTokenToStringConverter.class; + } + + // contributed by org.eclipse.xtext.xtext.generator.parser.antlr.XtextAntlrGeneratorFragment2 + public Class bindIAntlrTokenFileProvider() { + return ProblemAntlrTokenFileProvider.class; + } + + // contributed by org.eclipse.xtext.xtext.generator.parser.antlr.XtextAntlrGeneratorFragment2 + public Class bindLexer() { + return InternalProblemLexer.class; + } + + // contributed by org.eclipse.xtext.xtext.generator.parser.antlr.XtextAntlrGeneratorFragment2 + public Class bindITokenDefProvider() { + return AntlrTokenDefProvider.class; + } + + // contributed by org.eclipse.xtext.xtext.generator.parser.antlr.XtextAntlrGeneratorFragment2 + public Provider provideInternalProblemLexer() { + return LexerProvider.create(InternalProblemLexer.class); + } + + // contributed by org.eclipse.xtext.xtext.generator.parser.antlr.XtextAntlrGeneratorFragment2 + public void configureRuntimeLexer(Binder binder) { + binder.bind(Lexer.class) + .annotatedWith(Names.named(LexerBindings.RUNTIME)) + .to(InternalProblemLexer.class); + } + + // contributed by org.eclipse.xtext.xtext.generator.validation.ValidatorFragment2 + @SingletonBinding(eager=true) + public Class bindProblemValidator() { + return ProblemValidator.class; + } + + // contributed by org.eclipse.xtext.xtext.generator.validation.ValidatorFragment2 + public Class bindConfigurableIssueCodesProvider() { + return ProblemConfigurableIssueCodesProvider.class; + } + + // contributed by org.eclipse.xtext.xtext.generator.scoping.ImportNamespacesScopingFragment2 + public Class bindIScopeProvider() { + return ProblemScopeProvider.class; + } + + // contributed by org.eclipse.xtext.xtext.generator.scoping.ImportNamespacesScopingFragment2 + public void configureIScopeProviderDelegate(Binder binder) { + binder.bind(IScopeProvider.class).annotatedWith(Names.named(AbstractDeclarativeScopeProvider.NAMED_DELEGATE)).to(ImportedNamespaceAwareLocalScopeProvider.class); + } + + // contributed by org.eclipse.xtext.xtext.generator.scoping.ImportNamespacesScopingFragment2 + public Class bindIGlobalScopeProvider() { + return DefaultGlobalScopeProvider.class; + } + + // contributed by org.eclipse.xtext.xtext.generator.scoping.ImportNamespacesScopingFragment2 + public void configureIgnoreCaseLinking(Binder binder) { + binder.bindConstant().annotatedWith(IgnoreCaseLinking.class).to(false); + } + + // contributed by org.eclipse.xtext.xtext.generator.exporting.QualifiedNamesFragment2 + public Class bindIQualifiedNameProvider() { + return DefaultDeclarativeQualifiedNameProvider.class; + } + + // contributed by org.eclipse.xtext.xtext.generator.builder.BuilderIntegrationFragment2 + public Class bindIContainer$Manager() { + return StateBasedContainerManager.class; + } + + // contributed by org.eclipse.xtext.xtext.generator.builder.BuilderIntegrationFragment2 + public Class bindIAllContainersState$Provider() { + return ResourceSetBasedAllContainersStateProvider.class; + } + + // contributed by org.eclipse.xtext.xtext.generator.builder.BuilderIntegrationFragment2 + public void configureIResourceDescriptions(Binder binder) { + binder.bind(IResourceDescriptions.class).to(ResourceSetBasedResourceDescriptions.class); + } + + // contributed by org.eclipse.xtext.xtext.generator.builder.BuilderIntegrationFragment2 + public void configureIResourceDescriptionsPersisted(Binder binder) { + binder.bind(IResourceDescriptions.class).annotatedWith(Names.named(ResourceDescriptionsProvider.PERSISTED_DESCRIPTIONS)).to(ResourceSetBasedResourceDescriptions.class); + } + + // contributed by org.eclipse.xtext.xtext.generator.generator.GeneratorFragment2 + public Class bindIGenerator2() { + return ProblemGenerator.class; + } + +} diff --git a/language/src/main/xtext-gen/org/eclipse/viatra/solver/language/Problem.xtextbin b/language/src/main/xtext-gen/org/eclipse/viatra/solver/language/Problem.xtextbin new file mode 100644 index 00000000..cabf6537 Binary files /dev/null and b/language/src/main/xtext-gen/org/eclipse/viatra/solver/language/Problem.xtextbin differ diff --git a/language/src/main/xtext-gen/org/eclipse/viatra/solver/language/ProblemStandaloneSetupGenerated.java b/language/src/main/xtext-gen/org/eclipse/viatra/solver/language/ProblemStandaloneSetupGenerated.java new file mode 100644 index 00000000..0366f9cd --- /dev/null +++ b/language/src/main/xtext-gen/org/eclipse/viatra/solver/language/ProblemStandaloneSetupGenerated.java @@ -0,0 +1,37 @@ +/* + * generated by Xtext 2.26.0.M1 + */ +package org.eclipse.viatra.solver.language; + +import com.google.inject.Guice; +import com.google.inject.Injector; +import org.eclipse.emf.ecore.resource.Resource; +import org.eclipse.xtext.ISetup; +import org.eclipse.xtext.common.TerminalsStandaloneSetup; +import org.eclipse.xtext.resource.IResourceFactory; +import org.eclipse.xtext.resource.IResourceServiceProvider; + +@SuppressWarnings("all") +public class ProblemStandaloneSetupGenerated implements ISetup { + + @Override + public Injector createInjectorAndDoEMFRegistration() { + TerminalsStandaloneSetup.doSetup(); + + Injector injector = createInjector(); + register(injector); + return injector; + } + + public Injector createInjector() { + return Guice.createInjector(new ProblemRuntimeModule()); + } + + public void register(Injector injector) { + IResourceFactory resourceFactory = injector.getInstance(IResourceFactory.class); + IResourceServiceProvider serviceProvider = injector.getInstance(IResourceServiceProvider.class); + + Resource.Factory.Registry.INSTANCE.getExtensionToFactoryMap().put("problem", resourceFactory); + IResourceServiceProvider.Registry.INSTANCE.getExtensionToFactoryMap().put("problem", serviceProvider); + } +} diff --git a/language/src/main/xtext-gen/org/eclipse/viatra/solver/language/parser/antlr/ProblemAntlrTokenFileProvider.java b/language/src/main/xtext-gen/org/eclipse/viatra/solver/language/parser/antlr/ProblemAntlrTokenFileProvider.java new file mode 100644 index 00000000..b7ecf3f6 --- /dev/null +++ b/language/src/main/xtext-gen/org/eclipse/viatra/solver/language/parser/antlr/ProblemAntlrTokenFileProvider.java @@ -0,0 +1,16 @@ +/* + * generated by Xtext 2.26.0.M1 + */ +package org.eclipse.viatra.solver.language.parser.antlr; + +import java.io.InputStream; +import org.eclipse.xtext.parser.antlr.IAntlrTokenFileProvider; + +public class ProblemAntlrTokenFileProvider implements IAntlrTokenFileProvider { + + @Override + public InputStream getAntlrTokenFile() { + ClassLoader classLoader = getClass().getClassLoader(); + return classLoader.getResourceAsStream("org/eclipse/viatra/solver/language/parser/antlr/internal/InternalProblem.tokens"); + } +} diff --git a/language/src/main/xtext-gen/org/eclipse/viatra/solver/language/parser/antlr/ProblemParser.java b/language/src/main/xtext-gen/org/eclipse/viatra/solver/language/parser/antlr/ProblemParser.java new file mode 100644 index 00000000..3af86cab --- /dev/null +++ b/language/src/main/xtext-gen/org/eclipse/viatra/solver/language/parser/antlr/ProblemParser.java @@ -0,0 +1,40 @@ +/* + * generated by Xtext 2.26.0.M1 + */ +package org.eclipse.viatra.solver.language.parser.antlr; + +import com.google.inject.Inject; +import org.eclipse.viatra.solver.language.parser.antlr.internal.InternalProblemParser; +import org.eclipse.viatra.solver.language.services.ProblemGrammarAccess; +import org.eclipse.xtext.parser.antlr.AbstractAntlrParser; +import org.eclipse.xtext.parser.antlr.XtextTokenStream; + +public class ProblemParser extends AbstractAntlrParser { + + @Inject + private ProblemGrammarAccess grammarAccess; + + @Override + protected void setInitialHiddenTokens(XtextTokenStream tokenStream) { + tokenStream.setInitialHiddenTokens("RULE_WS", "RULE_ML_COMMENT", "RULE_SL_COMMENT"); + } + + + @Override + protected InternalProblemParser createParser(XtextTokenStream stream) { + return new InternalProblemParser(stream, getGrammarAccess()); + } + + @Override + protected String getDefaultRuleName() { + return "Problem"; + } + + public ProblemGrammarAccess getGrammarAccess() { + return this.grammarAccess; + } + + public void setGrammarAccess(ProblemGrammarAccess grammarAccess) { + this.grammarAccess = grammarAccess; + } +} diff --git a/language/src/main/xtext-gen/org/eclipse/viatra/solver/language/parser/antlr/internal/InternalProblem.g b/language/src/main/xtext-gen/org/eclipse/viatra/solver/language/parser/antlr/internal/InternalProblem.g new file mode 100644 index 00000000..64db0417 --- /dev/null +++ b/language/src/main/xtext-gen/org/eclipse/viatra/solver/language/parser/antlr/internal/InternalProblem.g @@ -0,0 +1,1909 @@ +/* + * generated by Xtext 2.26.0.M1 + */ +grammar InternalProblem; + +options { + superClass=AbstractInternalAntlrParser; +} + +@lexer::header { +package org.eclipse.viatra.solver.language.parser.antlr.internal; + +// Hack: Use our own Lexer superclass by means of import. +// Currently there is no other way to specify the superclass for the lexer. +import org.eclipse.xtext.parser.antlr.Lexer; +} + +@parser::header { +package org.eclipse.viatra.solver.language.parser.antlr.internal; + +import org.eclipse.xtext.*; +import org.eclipse.xtext.parser.*; +import org.eclipse.xtext.parser.impl.*; +import org.eclipse.emf.ecore.util.EcoreUtil; +import org.eclipse.emf.ecore.EObject; +import org.eclipse.emf.common.util.Enumerator; +import org.eclipse.xtext.parser.antlr.AbstractInternalAntlrParser; +import org.eclipse.xtext.parser.antlr.XtextTokenStream; +import org.eclipse.xtext.parser.antlr.XtextTokenStream.HiddenTokens; +import org.eclipse.xtext.parser.antlr.AntlrDatatypeRuleToken; +import org.eclipse.viatra.solver.language.services.ProblemGrammarAccess; + +} + +@parser::members { + + private ProblemGrammarAccess grammarAccess; + + public InternalProblemParser(TokenStream input, ProblemGrammarAccess grammarAccess) { + this(input); + this.grammarAccess = grammarAccess; + registerRules(grammarAccess.getGrammar()); + } + + @Override + protected String getFirstRuleName() { + return "Problem"; + } + + @Override + protected ProblemGrammarAccess getGrammarAccess() { + return grammarAccess; + } + +} + +@rulecatch { + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } +} + +// Entry rule entryRuleProblem +entryRuleProblem returns [EObject current=null]: + { newCompositeNode(grammarAccess.getProblemRule()); } + iv_ruleProblem=ruleProblem + { $current=$iv_ruleProblem.current; } + EOF; + +// Rule Problem +ruleProblem returns [EObject current=null] +@init { + enterRule(); +} +@after { + leaveRule(); +}: + ( + ( + otherlv_0='problem' + { + newLeafNode(otherlv_0, grammarAccess.getProblemAccess().getProblemKeyword_0_0()); + } + ( + ( + { + newCompositeNode(grammarAccess.getProblemAccess().getNameIdentifierParserRuleCall_0_1_0()); + } + lv_name_1_0=ruleIdentifier + { + if ($current==null) { + $current = createModelElementForParent(grammarAccess.getProblemRule()); + } + set( + $current, + "name", + lv_name_1_0, + "org.eclipse.viatra.solver.language.Problem.Identifier"); + afterParserOrEnumRuleCall(); + } + ) + ) + otherlv_2='.' + { + newLeafNode(otherlv_2, grammarAccess.getProblemAccess().getFullStopKeyword_0_2()); + } + )? + ( + ( + { + newCompositeNode(grammarAccess.getProblemAccess().getStatementsStatementParserRuleCall_1_0()); + } + lv_statements_3_0=ruleStatement + { + if ($current==null) { + $current = createModelElementForParent(grammarAccess.getProblemRule()); + } + add( + $current, + "statements", + lv_statements_3_0, + "org.eclipse.viatra.solver.language.Problem.Statement"); + afterParserOrEnumRuleCall(); + } + ) + )* + ) +; + +// Entry rule entryRuleStatement +entryRuleStatement returns [EObject current=null]: + { newCompositeNode(grammarAccess.getStatementRule()); } + iv_ruleStatement=ruleStatement + { $current=$iv_ruleStatement.current; } + EOF; + +// Rule Statement +ruleStatement returns [EObject current=null] +@init { + enterRule(); +} +@after { + leaveRule(); +}: + ( + { + newCompositeNode(grammarAccess.getStatementAccess().getClassDeclarationParserRuleCall_0()); + } + this_ClassDeclaration_0=ruleClassDeclaration + { + $current = $this_ClassDeclaration_0.current; + afterParserOrEnumRuleCall(); + } + | + { + newCompositeNode(grammarAccess.getStatementAccess().getEnumDeclarationParserRuleCall_1()); + } + this_EnumDeclaration_1=ruleEnumDeclaration + { + $current = $this_EnumDeclaration_1.current; + afterParserOrEnumRuleCall(); + } + | + { + newCompositeNode(grammarAccess.getStatementAccess().getPredicateDefinitionParserRuleCall_2()); + } + this_PredicateDefinition_2=rulePredicateDefinition + { + $current = $this_PredicateDefinition_2.current; + afterParserOrEnumRuleCall(); + } + | + { + newCompositeNode(grammarAccess.getStatementAccess().getAssertionParserRuleCall_3()); + } + this_Assertion_3=ruleAssertion + { + $current = $this_Assertion_3.current; + afterParserOrEnumRuleCall(); + } + | + { + newCompositeNode(grammarAccess.getStatementAccess().getScopeDeclarationParserRuleCall_4()); + } + this_ScopeDeclaration_4=ruleScopeDeclaration + { + $current = $this_ScopeDeclaration_4.current; + afterParserOrEnumRuleCall(); + } + ) +; + +// Entry rule entryRuleClassDeclaration +entryRuleClassDeclaration returns [EObject current=null]: + { newCompositeNode(grammarAccess.getClassDeclarationRule()); } + iv_ruleClassDeclaration=ruleClassDeclaration + { $current=$iv_ruleClassDeclaration.current; } + EOF; + +// Rule ClassDeclaration +ruleClassDeclaration returns [EObject current=null] +@init { + enterRule(); +} +@after { + leaveRule(); +}: + ( + ( + ( + lv_abstract_0_0='abstract' + { + newLeafNode(lv_abstract_0_0, grammarAccess.getClassDeclarationAccess().getAbstractAbstractKeyword_0_0()); + } + { + if ($current==null) { + $current = createModelElement(grammarAccess.getClassDeclarationRule()); + } + setWithLastConsumed($current, "abstract", lv_abstract_0_0 != null, "abstract"); + } + ) + )? + otherlv_1='class' + { + newLeafNode(otherlv_1, grammarAccess.getClassDeclarationAccess().getClassKeyword_1()); + } + ( + ( + { + newCompositeNode(grammarAccess.getClassDeclarationAccess().getNameIdentifierParserRuleCall_2_0()); + } + lv_name_2_0=ruleIdentifier + { + if ($current==null) { + $current = createModelElementForParent(grammarAccess.getClassDeclarationRule()); + } + set( + $current, + "name", + lv_name_2_0, + "org.eclipse.viatra.solver.language.Problem.Identifier"); + afterParserOrEnumRuleCall(); + } + ) + ) + ( + otherlv_3='extends' + { + newLeafNode(otherlv_3, grammarAccess.getClassDeclarationAccess().getExtendsKeyword_3_0()); + } + ( + ( + { + if ($current==null) { + $current = createModelElement(grammarAccess.getClassDeclarationRule()); + } + } + { + newCompositeNode(grammarAccess.getClassDeclarationAccess().getSuperTypesRelationCrossReference_3_1_0()); + } + ruleQualifiedName + { + afterParserOrEnumRuleCall(); + } + ) + ) + ( + otherlv_5=',' + { + newLeafNode(otherlv_5, grammarAccess.getClassDeclarationAccess().getCommaKeyword_3_2_0()); + } + ( + ( + { + if ($current==null) { + $current = createModelElement(grammarAccess.getClassDeclarationRule()); + } + } + { + newCompositeNode(grammarAccess.getClassDeclarationAccess().getSuperTypesRelationCrossReference_3_2_1_0()); + } + ruleQualifiedName + { + afterParserOrEnumRuleCall(); + } + ) + ) + )* + )? + ( + ( + otherlv_7='{' + { + newLeafNode(otherlv_7, grammarAccess.getClassDeclarationAccess().getLeftCurlyBracketKeyword_4_0_0()); + } + ( + ( + ( + { + newCompositeNode(grammarAccess.getClassDeclarationAccess().getReferenceDeclarationsReferenceDeclarationParserRuleCall_4_0_1_0_0()); + } + lv_referenceDeclarations_8_0=ruleReferenceDeclaration + { + if ($current==null) { + $current = createModelElementForParent(grammarAccess.getClassDeclarationRule()); + } + add( + $current, + "referenceDeclarations", + lv_referenceDeclarations_8_0, + "org.eclipse.viatra.solver.language.Problem.ReferenceDeclaration"); + afterParserOrEnumRuleCall(); + } + ) + ) + ( + otherlv_9=';' + { + newLeafNode(otherlv_9, grammarAccess.getClassDeclarationAccess().getSemicolonKeyword_4_0_1_1()); + } + )? + )* + otherlv_10='}' + { + newLeafNode(otherlv_10, grammarAccess.getClassDeclarationAccess().getRightCurlyBracketKeyword_4_0_2()); + } + ) + | + otherlv_11='.' + { + newLeafNode(otherlv_11, grammarAccess.getClassDeclarationAccess().getFullStopKeyword_4_1()); + } + ) + ) +; + +// Entry rule entryRuleEnumDeclaration +entryRuleEnumDeclaration returns [EObject current=null]: + { newCompositeNode(grammarAccess.getEnumDeclarationRule()); } + iv_ruleEnumDeclaration=ruleEnumDeclaration + { $current=$iv_ruleEnumDeclaration.current; } + EOF; + +// Rule EnumDeclaration +ruleEnumDeclaration returns [EObject current=null] +@init { + enterRule(); +} +@after { + leaveRule(); +}: + ( + otherlv_0='enum' + { + newLeafNode(otherlv_0, grammarAccess.getEnumDeclarationAccess().getEnumKeyword_0()); + } + ( + ( + { + newCompositeNode(grammarAccess.getEnumDeclarationAccess().getNameIdentifierParserRuleCall_1_0()); + } + lv_name_1_0=ruleIdentifier + { + if ($current==null) { + $current = createModelElementForParent(grammarAccess.getEnumDeclarationRule()); + } + set( + $current, + "name", + lv_name_1_0, + "org.eclipse.viatra.solver.language.Problem.Identifier"); + afterParserOrEnumRuleCall(); + } + ) + ) + ( + ( + otherlv_2='{' + { + newLeafNode(otherlv_2, grammarAccess.getEnumDeclarationAccess().getLeftCurlyBracketKeyword_2_0_0()); + } + ( + ( + ( + { + newCompositeNode(grammarAccess.getEnumDeclarationAccess().getLiteralsEnumLiteralParserRuleCall_2_0_1_0_0()); + } + lv_literals_3_0=ruleEnumLiteral + { + if ($current==null) { + $current = createModelElementForParent(grammarAccess.getEnumDeclarationRule()); + } + add( + $current, + "literals", + lv_literals_3_0, + "org.eclipse.viatra.solver.language.Problem.EnumLiteral"); + afterParserOrEnumRuleCall(); + } + ) + ) + ( + otherlv_4=',' + { + newLeafNode(otherlv_4, grammarAccess.getEnumDeclarationAccess().getCommaKeyword_2_0_1_1_0()); + } + ( + ( + { + newCompositeNode(grammarAccess.getEnumDeclarationAccess().getLiteralsEnumLiteralParserRuleCall_2_0_1_1_1_0()); + } + lv_literals_5_0=ruleEnumLiteral + { + if ($current==null) { + $current = createModelElementForParent(grammarAccess.getEnumDeclarationRule()); + } + add( + $current, + "literals", + lv_literals_5_0, + "org.eclipse.viatra.solver.language.Problem.EnumLiteral"); + afterParserOrEnumRuleCall(); + } + ) + ) + )* + ( + otherlv_6=',' + { + newLeafNode(otherlv_6, grammarAccess.getEnumDeclarationAccess().getCommaKeyword_2_0_1_2_0()); + } + | + otherlv_7=';' + { + newLeafNode(otherlv_7, grammarAccess.getEnumDeclarationAccess().getSemicolonKeyword_2_0_1_2_1()); + } + )? + )? + otherlv_8='}' + { + newLeafNode(otherlv_8, grammarAccess.getEnumDeclarationAccess().getRightCurlyBracketKeyword_2_0_2()); + } + ) + | + otherlv_9='.' + { + newLeafNode(otherlv_9, grammarAccess.getEnumDeclarationAccess().getFullStopKeyword_2_1()); + } + ) + ) +; + +// Entry rule entryRuleEnumLiteral +entryRuleEnumLiteral returns [EObject current=null]: + { newCompositeNode(grammarAccess.getEnumLiteralRule()); } + iv_ruleEnumLiteral=ruleEnumLiteral + { $current=$iv_ruleEnumLiteral.current; } + EOF; + +// Rule EnumLiteral +ruleEnumLiteral returns [EObject current=null] +@init { + enterRule(); +} +@after { + leaveRule(); +}: + ( + ( + { + newCompositeNode(grammarAccess.getEnumLiteralAccess().getNameQuotedOrUnquotedIdParserRuleCall_0()); + } + lv_name_0_0=ruleQuotedOrUnquotedId + { + if ($current==null) { + $current = createModelElementForParent(grammarAccess.getEnumLiteralRule()); + } + set( + $current, + "name", + lv_name_0_0, + "org.eclipse.viatra.solver.language.Problem.QuotedOrUnquotedId"); + afterParserOrEnumRuleCall(); + } + ) + ) +; + +// Entry rule entryRuleReferenceDeclaration +entryRuleReferenceDeclaration returns [EObject current=null]: + { newCompositeNode(grammarAccess.getReferenceDeclarationRule()); } + iv_ruleReferenceDeclaration=ruleReferenceDeclaration + { $current=$iv_ruleReferenceDeclaration.current; } + EOF; + +// Rule ReferenceDeclaration +ruleReferenceDeclaration returns [EObject current=null] +@init { + enterRule(); +} +@after { + leaveRule(); +}: + ( + ( + ( + ( + lv_containment_0_0='contains' + { + newLeafNode(lv_containment_0_0, grammarAccess.getReferenceDeclarationAccess().getContainmentContainsKeyword_0_0_0()); + } + { + if ($current==null) { + $current = createModelElement(grammarAccess.getReferenceDeclarationRule()); + } + setWithLastConsumed($current, "containment", lv_containment_0_0 != null, "contains"); + } + ) + ) + | + otherlv_1='refers' + { + newLeafNode(otherlv_1, grammarAccess.getReferenceDeclarationAccess().getRefersKeyword_0_1()); + } + )? + ( + ( + { + if ($current==null) { + $current = createModelElement(grammarAccess.getReferenceDeclarationRule()); + } + } + { + newCompositeNode(grammarAccess.getReferenceDeclarationAccess().getReferenceTypeRelationCrossReference_1_0()); + } + ruleQualifiedName + { + afterParserOrEnumRuleCall(); + } + ) + ) + ( + otherlv_3='[' + { + newLeafNode(otherlv_3, grammarAccess.getReferenceDeclarationAccess().getLeftSquareBracketKeyword_2_0()); + } + ( + ( + { + newCompositeNode(grammarAccess.getReferenceDeclarationAccess().getMultiplicityMultiplicityParserRuleCall_2_1_0()); + } + lv_multiplicity_4_0=ruleMultiplicity + { + if ($current==null) { + $current = createModelElementForParent(grammarAccess.getReferenceDeclarationRule()); + } + set( + $current, + "multiplicity", + lv_multiplicity_4_0, + "org.eclipse.viatra.solver.language.Problem.Multiplicity"); + afterParserOrEnumRuleCall(); + } + ) + ) + otherlv_5=']' + { + newLeafNode(otherlv_5, grammarAccess.getReferenceDeclarationAccess().getRightSquareBracketKeyword_2_2()); + } + )? + ( + ( + { + newCompositeNode(grammarAccess.getReferenceDeclarationAccess().getNameIdentifierParserRuleCall_3_0()); + } + lv_name_6_0=ruleIdentifier + { + if ($current==null) { + $current = createModelElementForParent(grammarAccess.getReferenceDeclarationRule()); + } + set( + $current, + "name", + lv_name_6_0, + "org.eclipse.viatra.solver.language.Problem.Identifier"); + afterParserOrEnumRuleCall(); + } + ) + ) + ( + otherlv_7='opposite' + { + newLeafNode(otherlv_7, grammarAccess.getReferenceDeclarationAccess().getOppositeKeyword_4_0()); + } + ( + ( + { + if ($current==null) { + $current = createModelElement(grammarAccess.getReferenceDeclarationRule()); + } + } + { + newCompositeNode(grammarAccess.getReferenceDeclarationAccess().getOppositeReferenceDeclarationCrossReference_4_1_0()); + } + ruleQualifiedName + { + afterParserOrEnumRuleCall(); + } + ) + ) + )? + ) +; + +// Entry rule entryRulePredicateDefinition +entryRulePredicateDefinition returns [EObject current=null]: + { newCompositeNode(grammarAccess.getPredicateDefinitionRule()); } + iv_rulePredicateDefinition=rulePredicateDefinition + { $current=$iv_rulePredicateDefinition.current; } + EOF; + +// Rule PredicateDefinition +rulePredicateDefinition returns [EObject current=null] +@init { + enterRule(); +} +@after { + leaveRule(); +}: + ( + ( + ( + ( + ( + lv_error_0_0='error' + { + newLeafNode(lv_error_0_0, grammarAccess.getPredicateDefinitionAccess().getErrorErrorKeyword_0_0_0_0()); + } + { + if ($current==null) { + $current = createModelElement(grammarAccess.getPredicateDefinitionRule()); + } + setWithLastConsumed($current, "error", lv_error_0_0 != null, "error"); + } + ) + ) + ( + otherlv_1='pred' + { + newLeafNode(otherlv_1, grammarAccess.getPredicateDefinitionAccess().getPredKeyword_0_0_1()); + } + )? + ) + | + otherlv_2='pred' + { + newLeafNode(otherlv_2, grammarAccess.getPredicateDefinitionAccess().getPredKeyword_0_1()); + } + ) + ( + ( + { + newCompositeNode(grammarAccess.getPredicateDefinitionAccess().getNameIdentifierParserRuleCall_1_0()); + } + lv_name_3_0=ruleIdentifier + { + if ($current==null) { + $current = createModelElementForParent(grammarAccess.getPredicateDefinitionRule()); + } + set( + $current, + "name", + lv_name_3_0, + "org.eclipse.viatra.solver.language.Problem.Identifier"); + afterParserOrEnumRuleCall(); + } + ) + ) + otherlv_4='(' + { + newLeafNode(otherlv_4, grammarAccess.getPredicateDefinitionAccess().getLeftParenthesisKeyword_2()); + } + ( + ( + ( + { + newCompositeNode(grammarAccess.getPredicateDefinitionAccess().getParametersParameterParserRuleCall_3_0_0()); + } + lv_parameters_5_0=ruleParameter + { + if ($current==null) { + $current = createModelElementForParent(grammarAccess.getPredicateDefinitionRule()); + } + add( + $current, + "parameters", + lv_parameters_5_0, + "org.eclipse.viatra.solver.language.Problem.Parameter"); + afterParserOrEnumRuleCall(); + } + ) + ) + ( + otherlv_6=',' + { + newLeafNode(otherlv_6, grammarAccess.getPredicateDefinitionAccess().getCommaKeyword_3_1_0()); + } + ( + ( + { + newCompositeNode(grammarAccess.getPredicateDefinitionAccess().getParametersParameterParserRuleCall_3_1_1_0()); + } + lv_parameters_7_0=ruleParameter + { + if ($current==null) { + $current = createModelElementForParent(grammarAccess.getPredicateDefinitionRule()); + } + add( + $current, + "parameters", + lv_parameters_7_0, + "org.eclipse.viatra.solver.language.Problem.Parameter"); + afterParserOrEnumRuleCall(); + } + ) + ) + )* + )? + otherlv_8=')' + { + newLeafNode(otherlv_8, grammarAccess.getPredicateDefinitionAccess().getRightParenthesisKeyword_4()); + } + ( + otherlv_9=':-' + { + newLeafNode(otherlv_9, grammarAccess.getPredicateDefinitionAccess().getColonHyphenMinusKeyword_5_0()); + } + ( + ( + { + newCompositeNode(grammarAccess.getPredicateDefinitionAccess().getBodiesConjunctionParserRuleCall_5_1_0()); + } + lv_bodies_10_0=ruleConjunction + { + if ($current==null) { + $current = createModelElementForParent(grammarAccess.getPredicateDefinitionRule()); + } + add( + $current, + "bodies", + lv_bodies_10_0, + "org.eclipse.viatra.solver.language.Problem.Conjunction"); + afterParserOrEnumRuleCall(); + } + ) + ) + ( + otherlv_11=';' + { + newLeafNode(otherlv_11, grammarAccess.getPredicateDefinitionAccess().getSemicolonKeyword_5_2_0()); + } + ( + ( + { + newCompositeNode(grammarAccess.getPredicateDefinitionAccess().getBodiesConjunctionParserRuleCall_5_2_1_0()); + } + lv_bodies_12_0=ruleConjunction + { + if ($current==null) { + $current = createModelElementForParent(grammarAccess.getPredicateDefinitionRule()); + } + add( + $current, + "bodies", + lv_bodies_12_0, + "org.eclipse.viatra.solver.language.Problem.Conjunction"); + afterParserOrEnumRuleCall(); + } + ) + ) + )* + )? + otherlv_13='.' + { + newLeafNode(otherlv_13, grammarAccess.getPredicateDefinitionAccess().getFullStopKeyword_6()); + } + ) +; + +// Entry rule entryRuleParameter +entryRuleParameter returns [EObject current=null]: + { newCompositeNode(grammarAccess.getParameterRule()); } + iv_ruleParameter=ruleParameter + { $current=$iv_ruleParameter.current; } + EOF; + +// Rule Parameter +ruleParameter returns [EObject current=null] +@init { + enterRule(); +} +@after { + leaveRule(); +}: + ( + ( + ( + { + if ($current==null) { + $current = createModelElement(grammarAccess.getParameterRule()); + } + } + { + newCompositeNode(grammarAccess.getParameterAccess().getParameterTypeRelationCrossReference_0_0()); + } + ruleQualifiedName + { + afterParserOrEnumRuleCall(); + } + ) + )? + ( + ( + { + newCompositeNode(grammarAccess.getParameterAccess().getNameIdentifierParserRuleCall_1_0()); + } + lv_name_1_0=ruleIdentifier + { + if ($current==null) { + $current = createModelElementForParent(grammarAccess.getParameterRule()); + } + set( + $current, + "name", + lv_name_1_0, + "org.eclipse.viatra.solver.language.Problem.Identifier"); + afterParserOrEnumRuleCall(); + } + ) + ) + ) +; + +// Entry rule entryRuleConjunction +entryRuleConjunction returns [EObject current=null]: + { newCompositeNode(grammarAccess.getConjunctionRule()); } + iv_ruleConjunction=ruleConjunction + { $current=$iv_ruleConjunction.current; } + EOF; + +// Rule Conjunction +ruleConjunction returns [EObject current=null] +@init { + enterRule(); +} +@after { + leaveRule(); +}: + ( + ( + ( + { + newCompositeNode(grammarAccess.getConjunctionAccess().getLiteralsLiteralParserRuleCall_0_0()); + } + lv_literals_0_0=ruleLiteral + { + if ($current==null) { + $current = createModelElementForParent(grammarAccess.getConjunctionRule()); + } + add( + $current, + "literals", + lv_literals_0_0, + "org.eclipse.viatra.solver.language.Problem.Literal"); + afterParserOrEnumRuleCall(); + } + ) + ) + ( + otherlv_1=',' + { + newLeafNode(otherlv_1, grammarAccess.getConjunctionAccess().getCommaKeyword_1_0()); + } + ( + ( + { + newCompositeNode(grammarAccess.getConjunctionAccess().getLiteralsLiteralParserRuleCall_1_1_0()); + } + lv_literals_2_0=ruleLiteral + { + if ($current==null) { + $current = createModelElementForParent(grammarAccess.getConjunctionRule()); + } + add( + $current, + "literals", + lv_literals_2_0, + "org.eclipse.viatra.solver.language.Problem.Literal"); + afterParserOrEnumRuleCall(); + } + ) + ) + )* + ) +; + +// Entry rule entryRuleLiteral +entryRuleLiteral returns [EObject current=null]: + { newCompositeNode(grammarAccess.getLiteralRule()); } + iv_ruleLiteral=ruleLiteral + { $current=$iv_ruleLiteral.current; } + EOF; + +// Rule Literal +ruleLiteral returns [EObject current=null] +@init { + enterRule(); +} +@after { + leaveRule(); +}: + ( + { + newCompositeNode(grammarAccess.getLiteralAccess().getAtomParserRuleCall_0()); + } + this_Atom_0=ruleAtom + { + $current = $this_Atom_0.current; + afterParserOrEnumRuleCall(); + } + | + { + newCompositeNode(grammarAccess.getLiteralAccess().getNegativeLiteralParserRuleCall_1()); + } + this_NegativeLiteral_1=ruleNegativeLiteral + { + $current = $this_NegativeLiteral_1.current; + afterParserOrEnumRuleCall(); + } + ) +; + +// Entry rule entryRuleNegativeLiteral +entryRuleNegativeLiteral returns [EObject current=null]: + { newCompositeNode(grammarAccess.getNegativeLiteralRule()); } + iv_ruleNegativeLiteral=ruleNegativeLiteral + { $current=$iv_ruleNegativeLiteral.current; } + EOF; + +// Rule NegativeLiteral +ruleNegativeLiteral returns [EObject current=null] +@init { + enterRule(); +} +@after { + leaveRule(); +}: + ( + otherlv_0='!' + { + newLeafNode(otherlv_0, grammarAccess.getNegativeLiteralAccess().getExclamationMarkKeyword_0()); + } + ( + ( + { + newCompositeNode(grammarAccess.getNegativeLiteralAccess().getAtomAtomParserRuleCall_1_0()); + } + lv_atom_1_0=ruleAtom + { + if ($current==null) { + $current = createModelElementForParent(grammarAccess.getNegativeLiteralRule()); + } + set( + $current, + "atom", + lv_atom_1_0, + "org.eclipse.viatra.solver.language.Problem.Atom"); + afterParserOrEnumRuleCall(); + } + ) + ) + ) +; + +// Entry rule entryRuleAtom +entryRuleAtom returns [EObject current=null]: + { newCompositeNode(grammarAccess.getAtomRule()); } + iv_ruleAtom=ruleAtom + { $current=$iv_ruleAtom.current; } + EOF; + +// Rule Atom +ruleAtom returns [EObject current=null] +@init { + enterRule(); +} +@after { + leaveRule(); +}: + ( + ( + ( + { + if ($current==null) { + $current = createModelElement(grammarAccess.getAtomRule()); + } + } + { + newCompositeNode(grammarAccess.getAtomAccess().getRelationRelationCrossReference_0_0()); + } + ruleQualifiedName + { + afterParserOrEnumRuleCall(); + } + ) + ) + ( + ( + lv_transitiveClosure_1_0='+' + { + newLeafNode(lv_transitiveClosure_1_0, grammarAccess.getAtomAccess().getTransitiveClosurePlusSignKeyword_1_0()); + } + { + if ($current==null) { + $current = createModelElement(grammarAccess.getAtomRule()); + } + setWithLastConsumed($current, "transitiveClosure", lv_transitiveClosure_1_0 != null, "+"); + } + ) + )? + otherlv_2='(' + { + newLeafNode(otherlv_2, grammarAccess.getAtomAccess().getLeftParenthesisKeyword_2()); + } + ( + ( + ( + { + newCompositeNode(grammarAccess.getAtomAccess().getArgumentsArgumentParserRuleCall_3_0_0()); + } + lv_arguments_3_0=ruleArgument + { + if ($current==null) { + $current = createModelElementForParent(grammarAccess.getAtomRule()); + } + add( + $current, + "arguments", + lv_arguments_3_0, + "org.eclipse.viatra.solver.language.Problem.Argument"); + afterParserOrEnumRuleCall(); + } + ) + ) + ( + otherlv_4=',' + { + newLeafNode(otherlv_4, grammarAccess.getAtomAccess().getCommaKeyword_3_1_0()); + } + ( + ( + { + newCompositeNode(grammarAccess.getAtomAccess().getArgumentsArgumentParserRuleCall_3_1_1_0()); + } + lv_arguments_5_0=ruleArgument + { + if ($current==null) { + $current = createModelElementForParent(grammarAccess.getAtomRule()); + } + add( + $current, + "arguments", + lv_arguments_5_0, + "org.eclipse.viatra.solver.language.Problem.Argument"); + afterParserOrEnumRuleCall(); + } + ) + ) + )* + )? + otherlv_6=')' + { + newLeafNode(otherlv_6, grammarAccess.getAtomAccess().getRightParenthesisKeyword_4()); + } + ) +; + +// Entry rule entryRuleArgument +entryRuleArgument returns [EObject current=null]: + { newCompositeNode(grammarAccess.getArgumentRule()); } + iv_ruleArgument=ruleArgument + { $current=$iv_ruleArgument.current; } + EOF; + +// Rule Argument +ruleArgument returns [EObject current=null] +@init { + enterRule(); +} +@after { + leaveRule(); +}: + ( + ( + { + if ($current==null) { + $current = createModelElement(grammarAccess.getArgumentRule()); + } + } + { + newCompositeNode(grammarAccess.getArgumentAccess().getVariableOrNodeVariableOrNodeCrossReference_0()); + } + ruleQualifiedName + { + afterParserOrEnumRuleCall(); + } + ) + ) +; + +// Entry rule entryRuleAssertion +entryRuleAssertion returns [EObject current=null]: + { newCompositeNode(grammarAccess.getAssertionRule()); } + iv_ruleAssertion=ruleAssertion + { $current=$iv_ruleAssertion.current; } + EOF; + +// Rule Assertion +ruleAssertion returns [EObject current=null] +@init { + enterRule(); +} +@after { + leaveRule(); +}: + ( + ( + ( + ( + ( + { + if ($current==null) { + $current = createModelElement(grammarAccess.getAssertionRule()); + } + } + { + newCompositeNode(grammarAccess.getAssertionAccess().getRelationRelationCrossReference_0_0_0_0()); + } + ruleQualifiedName + { + afterParserOrEnumRuleCall(); + } + ) + ) + otherlv_1='(' + { + newLeafNode(otherlv_1, grammarAccess.getAssertionAccess().getLeftParenthesisKeyword_0_0_1()); + } + ( + ( + ( + { + if ($current==null) { + $current = createModelElement(grammarAccess.getAssertionRule()); + } + } + { + newCompositeNode(grammarAccess.getAssertionAccess().getArgumentsNodeCrossReference_0_0_2_0_0()); + } + ruleQualifiedName + { + afterParserOrEnumRuleCall(); + } + ) + ) + ( + otherlv_3=',' + { + newLeafNode(otherlv_3, grammarAccess.getAssertionAccess().getCommaKeyword_0_0_2_1_0()); + } + ( + ( + { + if ($current==null) { + $current = createModelElement(grammarAccess.getAssertionRule()); + } + } + { + newCompositeNode(grammarAccess.getAssertionAccess().getArgumentsNodeCrossReference_0_0_2_1_1_0()); + } + ruleQualifiedName + { + afterParserOrEnumRuleCall(); + } + ) + ) + )* + )? + otherlv_5=')' + { + newLeafNode(otherlv_5, grammarAccess.getAssertionAccess().getRightParenthesisKeyword_0_0_3()); + } + otherlv_6=':' + { + newLeafNode(otherlv_6, grammarAccess.getAssertionAccess().getColonKeyword_0_0_4()); + } + ( + ( + { + newCompositeNode(grammarAccess.getAssertionAccess().getValueLogicValueEnumRuleCall_0_0_5_0()); + } + lv_value_7_0=ruleLogicValue + { + if ($current==null) { + $current = createModelElementForParent(grammarAccess.getAssertionRule()); + } + set( + $current, + "value", + lv_value_7_0, + "org.eclipse.viatra.solver.language.Problem.LogicValue"); + afterParserOrEnumRuleCall(); + } + ) + ) + ) + | + ( + ( + ( + { + newCompositeNode(grammarAccess.getAssertionAccess().getValueShortLogicValueEnumRuleCall_0_1_0_0()); + } + lv_value_8_0=ruleShortLogicValue + { + if ($current==null) { + $current = createModelElementForParent(grammarAccess.getAssertionRule()); + } + set( + $current, + "value", + lv_value_8_0, + "org.eclipse.viatra.solver.language.Problem.ShortLogicValue"); + afterParserOrEnumRuleCall(); + } + ) + )? + ( + ( + { + if ($current==null) { + $current = createModelElement(grammarAccess.getAssertionRule()); + } + } + { + newCompositeNode(grammarAccess.getAssertionAccess().getRelationRelationCrossReference_0_1_1_0()); + } + ruleQualifiedName + { + afterParserOrEnumRuleCall(); + } + ) + ) + otherlv_10='(' + { + newLeafNode(otherlv_10, grammarAccess.getAssertionAccess().getLeftParenthesisKeyword_0_1_2()); + } + ( + ( + ( + { + if ($current==null) { + $current = createModelElement(grammarAccess.getAssertionRule()); + } + } + { + newCompositeNode(grammarAccess.getAssertionAccess().getArgumentsNodeCrossReference_0_1_3_0_0()); + } + ruleQualifiedName + { + afterParserOrEnumRuleCall(); + } + ) + ) + ( + otherlv_12=',' + { + newLeafNode(otherlv_12, grammarAccess.getAssertionAccess().getCommaKeyword_0_1_3_1_0()); + } + ( + ( + { + if ($current==null) { + $current = createModelElement(grammarAccess.getAssertionRule()); + } + } + { + newCompositeNode(grammarAccess.getAssertionAccess().getArgumentsNodeCrossReference_0_1_3_1_1_0()); + } + ruleQualifiedName + { + afterParserOrEnumRuleCall(); + } + ) + ) + )* + )? + otherlv_14=')' + { + newLeafNode(otherlv_14, grammarAccess.getAssertionAccess().getRightParenthesisKeyword_0_1_4()); + } + ) + ) + otherlv_15='.' + { + newLeafNode(otherlv_15, grammarAccess.getAssertionAccess().getFullStopKeyword_1()); + } + ) +; + +// Entry rule entryRuleScopeDeclaration +entryRuleScopeDeclaration returns [EObject current=null]: + { newCompositeNode(grammarAccess.getScopeDeclarationRule()); } + iv_ruleScopeDeclaration=ruleScopeDeclaration + { $current=$iv_ruleScopeDeclaration.current; } + EOF; + +// Rule ScopeDeclaration +ruleScopeDeclaration returns [EObject current=null] +@init { + enterRule(); +} +@after { + leaveRule(); +}: + ( + otherlv_0='scope' + { + newLeafNode(otherlv_0, grammarAccess.getScopeDeclarationAccess().getScopeKeyword_0()); + } + ( + ( + { + newCompositeNode(grammarAccess.getScopeDeclarationAccess().getTypeScopesTypeScopeParserRuleCall_1_0()); + } + lv_typeScopes_1_0=ruleTypeScope + { + if ($current==null) { + $current = createModelElementForParent(grammarAccess.getScopeDeclarationRule()); + } + add( + $current, + "typeScopes", + lv_typeScopes_1_0, + "org.eclipse.viatra.solver.language.Problem.TypeScope"); + afterParserOrEnumRuleCall(); + } + ) + ) + ( + otherlv_2=',' + { + newLeafNode(otherlv_2, grammarAccess.getScopeDeclarationAccess().getCommaKeyword_2_0()); + } + ( + ( + { + newCompositeNode(grammarAccess.getScopeDeclarationAccess().getTypeScopesTypeScopeParserRuleCall_2_1_0()); + } + lv_typeScopes_3_0=ruleTypeScope + { + if ($current==null) { + $current = createModelElementForParent(grammarAccess.getScopeDeclarationRule()); + } + add( + $current, + "typeScopes", + lv_typeScopes_3_0, + "org.eclipse.viatra.solver.language.Problem.TypeScope"); + afterParserOrEnumRuleCall(); + } + ) + ) + )* + otherlv_4='.' + { + newLeafNode(otherlv_4, grammarAccess.getScopeDeclarationAccess().getFullStopKeyword_3()); + } + ) +; + +// Entry rule entryRuleTypeScope +entryRuleTypeScope returns [EObject current=null]: + { newCompositeNode(grammarAccess.getTypeScopeRule()); } + iv_ruleTypeScope=ruleTypeScope + { $current=$iv_ruleTypeScope.current; } + EOF; + +// Rule TypeScope +ruleTypeScope returns [EObject current=null] +@init { + enterRule(); +} +@after { + leaveRule(); +}: + ( + ( + ( + { + if ($current==null) { + $current = createModelElement(grammarAccess.getTypeScopeRule()); + } + } + otherlv_0=RULE_ID + { + newLeafNode(otherlv_0, grammarAccess.getTypeScopeAccess().getTargetTypeClassDeclarationCrossReference_0_0()); + } + ) + ) + ( + ( + ( + lv_increment_1_0='+=' + { + newLeafNode(lv_increment_1_0, grammarAccess.getTypeScopeAccess().getIncrementPlusSignEqualsSignKeyword_1_0_0()); + } + { + if ($current==null) { + $current = createModelElement(grammarAccess.getTypeScopeRule()); + } + setWithLastConsumed($current, "increment", lv_increment_1_0 != null, "+="); + } + ) + ) + | + otherlv_2='=' + { + newLeafNode(otherlv_2, grammarAccess.getTypeScopeAccess().getEqualsSignKeyword_1_1()); + } + ) + ( + ( + { + newCompositeNode(grammarAccess.getTypeScopeAccess().getMultiplicityDefiniteMultiplicityParserRuleCall_2_0()); + } + lv_multiplicity_3_0=ruleDefiniteMultiplicity + { + if ($current==null) { + $current = createModelElementForParent(grammarAccess.getTypeScopeRule()); + } + set( + $current, + "multiplicity", + lv_multiplicity_3_0, + "org.eclipse.viatra.solver.language.Problem.DefiniteMultiplicity"); + afterParserOrEnumRuleCall(); + } + ) + ) + ) +; + +// Entry rule entryRuleMultiplicity +entryRuleMultiplicity returns [EObject current=null]: + { newCompositeNode(grammarAccess.getMultiplicityRule()); } + iv_ruleMultiplicity=ruleMultiplicity + { $current=$iv_ruleMultiplicity.current; } + EOF; + +// Rule Multiplicity +ruleMultiplicity returns [EObject current=null] +@init { + enterRule(); +} +@after { + leaveRule(); +}: + ( + { + newCompositeNode(grammarAccess.getMultiplicityAccess().getUnboundedMultiplicityParserRuleCall_0()); + } + this_UnboundedMultiplicity_0=ruleUnboundedMultiplicity + { + $current = $this_UnboundedMultiplicity_0.current; + afterParserOrEnumRuleCall(); + } + | + { + newCompositeNode(grammarAccess.getMultiplicityAccess().getDefiniteMultiplicityParserRuleCall_1()); + } + this_DefiniteMultiplicity_1=ruleDefiniteMultiplicity + { + $current = $this_DefiniteMultiplicity_1.current; + afterParserOrEnumRuleCall(); + } + ) +; + +// Entry rule entryRuleDefiniteMultiplicity +entryRuleDefiniteMultiplicity returns [EObject current=null]: + { newCompositeNode(grammarAccess.getDefiniteMultiplicityRule()); } + iv_ruleDefiniteMultiplicity=ruleDefiniteMultiplicity + { $current=$iv_ruleDefiniteMultiplicity.current; } + EOF; + +// Rule DefiniteMultiplicity +ruleDefiniteMultiplicity returns [EObject current=null] +@init { + enterRule(); +} +@after { + leaveRule(); +}: + ( + { + newCompositeNode(grammarAccess.getDefiniteMultiplicityAccess().getRangeMultiplicityParserRuleCall_0()); + } + this_RangeMultiplicity_0=ruleRangeMultiplicity + { + $current = $this_RangeMultiplicity_0.current; + afterParserOrEnumRuleCall(); + } + | + { + newCompositeNode(grammarAccess.getDefiniteMultiplicityAccess().getExactMultiplicityParserRuleCall_1()); + } + this_ExactMultiplicity_1=ruleExactMultiplicity + { + $current = $this_ExactMultiplicity_1.current; + afterParserOrEnumRuleCall(); + } + ) +; + +// Entry rule entryRuleUnboundedMultiplicity +entryRuleUnboundedMultiplicity returns [EObject current=null]: + { newCompositeNode(grammarAccess.getUnboundedMultiplicityRule()); } + iv_ruleUnboundedMultiplicity=ruleUnboundedMultiplicity + { $current=$iv_ruleUnboundedMultiplicity.current; } + EOF; + +// Rule UnboundedMultiplicity +ruleUnboundedMultiplicity returns [EObject current=null] +@init { + enterRule(); +} +@after { + leaveRule(); +}: + ( + { + $current = forceCreateModelElement( + grammarAccess.getUnboundedMultiplicityAccess().getUnboundedMultiplicityAction(), + $current); + } + ) +; + +// Entry rule entryRuleRangeMultiplicity +entryRuleRangeMultiplicity returns [EObject current=null]: + { newCompositeNode(grammarAccess.getRangeMultiplicityRule()); } + iv_ruleRangeMultiplicity=ruleRangeMultiplicity + { $current=$iv_ruleRangeMultiplicity.current; } + EOF; + +// Rule RangeMultiplicity +ruleRangeMultiplicity returns [EObject current=null] +@init { + enterRule(); +} +@after { + leaveRule(); +}: + ( + ( + ( + lv_lowerBound_0_0=RULE_INT + { + newLeafNode(lv_lowerBound_0_0, grammarAccess.getRangeMultiplicityAccess().getLowerBoundINTTerminalRuleCall_0_0()); + } + { + if ($current==null) { + $current = createModelElement(grammarAccess.getRangeMultiplicityRule()); + } + setWithLastConsumed( + $current, + "lowerBound", + lv_lowerBound_0_0, + "org.eclipse.xtext.common.Terminals.INT"); + } + ) + ) + otherlv_1='..' + { + newLeafNode(otherlv_1, grammarAccess.getRangeMultiplicityAccess().getFullStopFullStopKeyword_1()); + } + ( + ( + { + newCompositeNode(grammarAccess.getRangeMultiplicityAccess().getUpperBoundUpperBoundParserRuleCall_2_0()); + } + lv_upperBound_2_0=ruleUpperBound + { + if ($current==null) { + $current = createModelElementForParent(grammarAccess.getRangeMultiplicityRule()); + } + set( + $current, + "upperBound", + lv_upperBound_2_0, + "org.eclipse.viatra.solver.language.Problem.UpperBound"); + afterParserOrEnumRuleCall(); + } + ) + ) + ) +; + +// Entry rule entryRuleExactMultiplicity +entryRuleExactMultiplicity returns [EObject current=null]: + { newCompositeNode(grammarAccess.getExactMultiplicityRule()); } + iv_ruleExactMultiplicity=ruleExactMultiplicity + { $current=$iv_ruleExactMultiplicity.current; } + EOF; + +// Rule ExactMultiplicity +ruleExactMultiplicity returns [EObject current=null] +@init { + enterRule(); +} +@after { + leaveRule(); +}: + ( + ( + lv_exactValue_0_0=RULE_INT + { + newLeafNode(lv_exactValue_0_0, grammarAccess.getExactMultiplicityAccess().getExactValueINTTerminalRuleCall_0()); + } + { + if ($current==null) { + $current = createModelElement(grammarAccess.getExactMultiplicityRule()); + } + setWithLastConsumed( + $current, + "exactValue", + lv_exactValue_0_0, + "org.eclipse.xtext.common.Terminals.INT"); + } + ) + ) +; + +// Entry rule entryRuleUpperBound +entryRuleUpperBound returns [String current=null]: + { newCompositeNode(grammarAccess.getUpperBoundRule()); } + iv_ruleUpperBound=ruleUpperBound + { $current=$iv_ruleUpperBound.current.getText(); } + EOF; + +// Rule UpperBound +ruleUpperBound returns [AntlrDatatypeRuleToken current=new AntlrDatatypeRuleToken()] +@init { + enterRule(); +} +@after { + leaveRule(); +}: + ( + this_INT_0=RULE_INT + { + $current.merge(this_INT_0); + } + { + newLeafNode(this_INT_0, grammarAccess.getUpperBoundAccess().getINTTerminalRuleCall_0()); + } + | + kw='*' + { + $current.merge(kw); + newLeafNode(kw, grammarAccess.getUpperBoundAccess().getAsteriskKeyword_1()); + } + ) +; + +// Entry rule entryRuleQuotedOrUnquotedId +entryRuleQuotedOrUnquotedId returns [String current=null]: + { newCompositeNode(grammarAccess.getQuotedOrUnquotedIdRule()); } + iv_ruleQuotedOrUnquotedId=ruleQuotedOrUnquotedId + { $current=$iv_ruleQuotedOrUnquotedId.current.getText(); } + EOF; + +// Rule QuotedOrUnquotedId +ruleQuotedOrUnquotedId returns [AntlrDatatypeRuleToken current=new AntlrDatatypeRuleToken()] +@init { + enterRule(); +} +@after { + leaveRule(); +}: + ( + this_QUOTED_ID_0=RULE_QUOTED_ID + { + $current.merge(this_QUOTED_ID_0); + } + { + newLeafNode(this_QUOTED_ID_0, grammarAccess.getQuotedOrUnquotedIdAccess().getQUOTED_IDTerminalRuleCall_0()); + } + | + { + newCompositeNode(grammarAccess.getQuotedOrUnquotedIdAccess().getIdentifierParserRuleCall_1()); + } + this_Identifier_1=ruleIdentifier + { + $current.merge(this_Identifier_1); + } + { + afterParserOrEnumRuleCall(); + } + ) +; + +// Entry rule entryRuleQualifiedName +entryRuleQualifiedName returns [String current=null]: + { newCompositeNode(grammarAccess.getQualifiedNameRule()); } + iv_ruleQualifiedName=ruleQualifiedName + { $current=$iv_ruleQualifiedName.current.getText(); } + EOF; + +// Rule QualifiedName +ruleQualifiedName returns [AntlrDatatypeRuleToken current=new AntlrDatatypeRuleToken()] +@init { + enterRule(); +} +@after { + leaveRule(); +}: + ( + this_QUOTED_ID_0=RULE_QUOTED_ID + { + $current.merge(this_QUOTED_ID_0); + } + { + newLeafNode(this_QUOTED_ID_0, grammarAccess.getQualifiedNameAccess().getQUOTED_IDTerminalRuleCall_0()); + } + | + ( + { + newCompositeNode(grammarAccess.getQualifiedNameAccess().getIdentifierParserRuleCall_1_0()); + } + this_Identifier_1=ruleIdentifier + { + $current.merge(this_Identifier_1); + } + { + afterParserOrEnumRuleCall(); + } + ( + kw=':' + { + $current.merge(kw); + newLeafNode(kw, grammarAccess.getQualifiedNameAccess().getColonKeyword_1_1_0()); + } + { + newCompositeNode(grammarAccess.getQualifiedNameAccess().getIdentifierParserRuleCall_1_1_1()); + } + this_Identifier_3=ruleIdentifier + { + $current.merge(this_Identifier_3); + } + { + afterParserOrEnumRuleCall(); + } + )* + ( + kw=':' + { + $current.merge(kw); + newLeafNode(kw, grammarAccess.getQualifiedNameAccess().getColonKeyword_1_2_0()); + } + this_QUOTED_ID_5=RULE_QUOTED_ID + { + $current.merge(this_QUOTED_ID_5); + } + { + newLeafNode(this_QUOTED_ID_5, grammarAccess.getQualifiedNameAccess().getQUOTED_IDTerminalRuleCall_1_2_1()); + } + )? + ) + ) +; + +// Entry rule entryRuleIdentifier +entryRuleIdentifier returns [String current=null]: + { newCompositeNode(grammarAccess.getIdentifierRule()); } + iv_ruleIdentifier=ruleIdentifier + { $current=$iv_ruleIdentifier.current.getText(); } + EOF; + +// Rule Identifier +ruleIdentifier returns [AntlrDatatypeRuleToken current=new AntlrDatatypeRuleToken()] +@init { + enterRule(); +} +@after { + leaveRule(); +}: + ( + this_ID_0=RULE_ID + { + $current.merge(this_ID_0); + } + { + newLeafNode(this_ID_0, grammarAccess.getIdentifierAccess().getIDTerminalRuleCall_0()); + } + | + kw='true' + { + $current.merge(kw); + newLeafNode(kw, grammarAccess.getIdentifierAccess().getTrueKeyword_1()); + } + | + kw='false' + { + $current.merge(kw); + newLeafNode(kw, grammarAccess.getIdentifierAccess().getFalseKeyword_2()); + } + ) +; + +// Rule LogicValue +ruleLogicValue returns [Enumerator current=null] +@init { + enterRule(); +} +@after { + leaveRule(); +}: + ( + ( + enumLiteral_0='true' + { + $current = grammarAccess.getLogicValueAccess().getTRUEEnumLiteralDeclaration_0().getEnumLiteral().getInstance(); + newLeafNode(enumLiteral_0, grammarAccess.getLogicValueAccess().getTRUEEnumLiteralDeclaration_0()); + } + ) + | + ( + enumLiteral_1='false' + { + $current = grammarAccess.getLogicValueAccess().getFALSEEnumLiteralDeclaration_1().getEnumLiteral().getInstance(); + newLeafNode(enumLiteral_1, grammarAccess.getLogicValueAccess().getFALSEEnumLiteralDeclaration_1()); + } + ) + | + ( + enumLiteral_2='unknown' + { + $current = grammarAccess.getLogicValueAccess().getUNKNOWNEnumLiteralDeclaration_2().getEnumLiteral().getInstance(); + newLeafNode(enumLiteral_2, grammarAccess.getLogicValueAccess().getUNKNOWNEnumLiteralDeclaration_2()); + } + ) + ) +; + +// Rule ShortLogicValue +ruleShortLogicValue returns [Enumerator current=null] +@init { + enterRule(); +} +@after { + leaveRule(); +}: + ( + ( + enumLiteral_0='!' + { + $current = grammarAccess.getShortLogicValueAccess().getFALSEEnumLiteralDeclaration_0().getEnumLiteral().getInstance(); + newLeafNode(enumLiteral_0, grammarAccess.getShortLogicValueAccess().getFALSEEnumLiteralDeclaration_0()); + } + ) + | + ( + enumLiteral_1='?' + { + $current = grammarAccess.getShortLogicValueAccess().getUNKNOWNEnumLiteralDeclaration_1().getEnumLiteral().getInstance(); + newLeafNode(enumLiteral_1, grammarAccess.getShortLogicValueAccess().getUNKNOWNEnumLiteralDeclaration_1()); + } + ) + ) +; + +RULE_STRING : '"' ('\\' .|~(('\\'|'"')))* '"'; + +RULE_QUOTED_ID : '\'' ('\\' .|~(('\\'|'\'')))* '\''; + +RULE_ID : '^'? ('a'..'z'|'A'..'Z'|'_') ('a'..'z'|'A'..'Z'|'_'|'0'..'9')*; + +RULE_INT : ('0'..'9')+; + +RULE_ML_COMMENT : '/*' ( options {greedy=false;} : . )*'*/'; + +RULE_SL_COMMENT : '//' ~(('\n'|'\r'))* ('\r'? '\n')?; + +RULE_WS : (' '|'\t'|'\r'|'\n')+; + +RULE_ANY_OTHER : .; diff --git a/language/src/main/xtext-gen/org/eclipse/viatra/solver/language/parser/antlr/internal/InternalProblem.tokens b/language/src/main/xtext-gen/org/eclipse/viatra/solver/language/parser/antlr/internal/InternalProblem.tokens new file mode 100644 index 00000000..e968ac14 --- /dev/null +++ b/language/src/main/xtext-gen/org/eclipse/viatra/solver/language/parser/antlr/internal/InternalProblem.tokens @@ -0,0 +1,72 @@ +'!'=32 +'('=29 +')'=30 +'*'=39 +'+'=33 +'+='=36 +','=17 +'.'=13 +'..'=38 +':'=34 +':-'=31 +';'=19 +'='=37 +'?'=43 +'['=24 +']'=25 +'abstract'=14 +'class'=15 +'contains'=22 +'enum'=21 +'error'=27 +'extends'=16 +'false'=41 +'opposite'=26 +'pred'=28 +'problem'=12 +'refers'=23 +'scope'=35 +'true'=40 +'unknown'=42 +'{'=18 +'}'=20 +RULE_ANY_OTHER=11 +RULE_ID=4 +RULE_INT=5 +RULE_ML_COMMENT=8 +RULE_QUOTED_ID=6 +RULE_SL_COMMENT=9 +RULE_STRING=7 +RULE_WS=10 +T__12=12 +T__13=13 +T__14=14 +T__15=15 +T__16=16 +T__17=17 +T__18=18 +T__19=19 +T__20=20 +T__21=21 +T__22=22 +T__23=23 +T__24=24 +T__25=25 +T__26=26 +T__27=27 +T__28=28 +T__29=29 +T__30=30 +T__31=31 +T__32=32 +T__33=33 +T__34=34 +T__35=35 +T__36=36 +T__37=37 +T__38=38 +T__39=39 +T__40=40 +T__41=41 +T__42=42 +T__43=43 diff --git a/language/src/main/xtext-gen/org/eclipse/viatra/solver/language/parser/antlr/internal/InternalProblemLexer.java b/language/src/main/xtext-gen/org/eclipse/viatra/solver/language/parser/antlr/internal/InternalProblemLexer.java new file mode 100644 index 00000000..1fd1e166 --- /dev/null +++ b/language/src/main/xtext-gen/org/eclipse/viatra/solver/language/parser/antlr/internal/InternalProblemLexer.java @@ -0,0 +1,1797 @@ +package org.eclipse.viatra.solver.language.parser.antlr.internal; + +// Hack: Use our own Lexer superclass by means of import. +// Currently there is no other way to specify the superclass for the lexer. +import org.eclipse.xtext.parser.antlr.Lexer; + + +import org.antlr.runtime.*; +import java.util.Stack; +import java.util.List; +import java.util.ArrayList; + +@SuppressWarnings("all") +public class InternalProblemLexer extends Lexer { + public static final int T__19=19; + public static final int T__15=15; + public static final int T__16=16; + public static final int T__17=17; + public static final int T__18=18; + public static final int T__12=12; + public static final int T__13=13; + public static final int T__14=14; + public static final int RULE_ID=4; + public static final int RULE_QUOTED_ID=6; + public static final int T__26=26; + public static final int T__27=27; + public static final int T__28=28; + public static final int RULE_INT=5; + public static final int T__29=29; + public static final int T__22=22; + public static final int RULE_ML_COMMENT=8; + public static final int T__23=23; + public static final int T__24=24; + public static final int T__25=25; + public static final int T__20=20; + public static final int T__21=21; + public static final int RULE_STRING=7; + public static final int RULE_SL_COMMENT=9; + public static final int T__37=37; + public static final int T__38=38; + public static final int T__39=39; + public static final int T__33=33; + public static final int T__34=34; + public static final int T__35=35; + public static final int T__36=36; + public static final int EOF=-1; + public static final int T__30=30; + public static final int T__31=31; + public static final int T__32=32; + public static final int RULE_WS=10; + public static final int RULE_ANY_OTHER=11; + public static final int T__40=40; + public static final int T__41=41; + public static final int T__42=42; + public static final int T__43=43; + + // delegates + // delegators + + public InternalProblemLexer() {;} + public InternalProblemLexer(CharStream input) { + this(input, new RecognizerSharedState()); + } + public InternalProblemLexer(CharStream input, RecognizerSharedState state) { + super(input,state); + + } + public String getGrammarFileName() { return "InternalProblem.g"; } + + // $ANTLR start "T__12" + public final void mT__12() throws RecognitionException { + try { + int _type = T__12; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalProblem.g:11:7: ( 'problem' ) + // InternalProblem.g:11:9: 'problem' + { + match("problem"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "T__12" + + // $ANTLR start "T__13" + public final void mT__13() throws RecognitionException { + try { + int _type = T__13; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalProblem.g:12:7: ( '.' ) + // InternalProblem.g:12:9: '.' + { + match('.'); + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "T__13" + + // $ANTLR start "T__14" + public final void mT__14() throws RecognitionException { + try { + int _type = T__14; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalProblem.g:13:7: ( 'abstract' ) + // InternalProblem.g:13:9: 'abstract' + { + match("abstract"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "T__14" + + // $ANTLR start "T__15" + public final void mT__15() throws RecognitionException { + try { + int _type = T__15; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalProblem.g:14:7: ( 'class' ) + // InternalProblem.g:14:9: 'class' + { + match("class"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "T__15" + + // $ANTLR start "T__16" + public final void mT__16() throws RecognitionException { + try { + int _type = T__16; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalProblem.g:15:7: ( 'extends' ) + // InternalProblem.g:15:9: 'extends' + { + match("extends"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "T__16" + + // $ANTLR start "T__17" + public final void mT__17() throws RecognitionException { + try { + int _type = T__17; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalProblem.g:16:7: ( ',' ) + // InternalProblem.g:16:9: ',' + { + match(','); + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "T__17" + + // $ANTLR start "T__18" + public final void mT__18() throws RecognitionException { + try { + int _type = T__18; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalProblem.g:17:7: ( '{' ) + // InternalProblem.g:17:9: '{' + { + match('{'); + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "T__18" + + // $ANTLR start "T__19" + public final void mT__19() throws RecognitionException { + try { + int _type = T__19; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalProblem.g:18:7: ( ';' ) + // InternalProblem.g:18:9: ';' + { + match(';'); + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "T__19" + + // $ANTLR start "T__20" + public final void mT__20() throws RecognitionException { + try { + int _type = T__20; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalProblem.g:19:7: ( '}' ) + // InternalProblem.g:19:9: '}' + { + match('}'); + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "T__20" + + // $ANTLR start "T__21" + public final void mT__21() throws RecognitionException { + try { + int _type = T__21; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalProblem.g:20:7: ( 'enum' ) + // InternalProblem.g:20:9: 'enum' + { + match("enum"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "T__21" + + // $ANTLR start "T__22" + public final void mT__22() throws RecognitionException { + try { + int _type = T__22; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalProblem.g:21:7: ( 'contains' ) + // InternalProblem.g:21:9: 'contains' + { + match("contains"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "T__22" + + // $ANTLR start "T__23" + public final void mT__23() throws RecognitionException { + try { + int _type = T__23; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalProblem.g:22:7: ( 'refers' ) + // InternalProblem.g:22:9: 'refers' + { + match("refers"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "T__23" + + // $ANTLR start "T__24" + public final void mT__24() throws RecognitionException { + try { + int _type = T__24; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalProblem.g:23:7: ( '[' ) + // InternalProblem.g:23:9: '[' + { + match('['); + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "T__24" + + // $ANTLR start "T__25" + public final void mT__25() throws RecognitionException { + try { + int _type = T__25; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalProblem.g:24:7: ( ']' ) + // InternalProblem.g:24:9: ']' + { + match(']'); + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "T__25" + + // $ANTLR start "T__26" + public final void mT__26() throws RecognitionException { + try { + int _type = T__26; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalProblem.g:25:7: ( 'opposite' ) + // InternalProblem.g:25:9: 'opposite' + { + match("opposite"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "T__26" + + // $ANTLR start "T__27" + public final void mT__27() throws RecognitionException { + try { + int _type = T__27; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalProblem.g:26:7: ( 'error' ) + // InternalProblem.g:26:9: 'error' + { + match("error"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "T__27" + + // $ANTLR start "T__28" + public final void mT__28() throws RecognitionException { + try { + int _type = T__28; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalProblem.g:27:7: ( 'pred' ) + // InternalProblem.g:27:9: 'pred' + { + match("pred"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "T__28" + + // $ANTLR start "T__29" + public final void mT__29() throws RecognitionException { + try { + int _type = T__29; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalProblem.g:28:7: ( '(' ) + // InternalProblem.g:28:9: '(' + { + match('('); + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "T__29" + + // $ANTLR start "T__30" + public final void mT__30() throws RecognitionException { + try { + int _type = T__30; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalProblem.g:29:7: ( ')' ) + // InternalProblem.g:29:9: ')' + { + match(')'); + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "T__30" + + // $ANTLR start "T__31" + public final void mT__31() throws RecognitionException { + try { + int _type = T__31; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalProblem.g:30:7: ( ':-' ) + // InternalProblem.g:30:9: ':-' + { + match(":-"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "T__31" + + // $ANTLR start "T__32" + public final void mT__32() throws RecognitionException { + try { + int _type = T__32; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalProblem.g:31:7: ( '!' ) + // InternalProblem.g:31:9: '!' + { + match('!'); + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "T__32" + + // $ANTLR start "T__33" + public final void mT__33() throws RecognitionException { + try { + int _type = T__33; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalProblem.g:32:7: ( '+' ) + // InternalProblem.g:32:9: '+' + { + match('+'); + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "T__33" + + // $ANTLR start "T__34" + public final void mT__34() throws RecognitionException { + try { + int _type = T__34; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalProblem.g:33:7: ( ':' ) + // InternalProblem.g:33:9: ':' + { + match(':'); + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "T__34" + + // $ANTLR start "T__35" + public final void mT__35() throws RecognitionException { + try { + int _type = T__35; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalProblem.g:34:7: ( 'scope' ) + // InternalProblem.g:34:9: 'scope' + { + match("scope"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "T__35" + + // $ANTLR start "T__36" + public final void mT__36() throws RecognitionException { + try { + int _type = T__36; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalProblem.g:35:7: ( '+=' ) + // InternalProblem.g:35:9: '+=' + { + match("+="); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "T__36" + + // $ANTLR start "T__37" + public final void mT__37() throws RecognitionException { + try { + int _type = T__37; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalProblem.g:36:7: ( '=' ) + // InternalProblem.g:36:9: '=' + { + match('='); + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "T__37" + + // $ANTLR start "T__38" + public final void mT__38() throws RecognitionException { + try { + int _type = T__38; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalProblem.g:37:7: ( '..' ) + // InternalProblem.g:37:9: '..' + { + match(".."); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "T__38" + + // $ANTLR start "T__39" + public final void mT__39() throws RecognitionException { + try { + int _type = T__39; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalProblem.g:38:7: ( '*' ) + // InternalProblem.g:38:9: '*' + { + match('*'); + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "T__39" + + // $ANTLR start "T__40" + public final void mT__40() throws RecognitionException { + try { + int _type = T__40; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalProblem.g:39:7: ( 'true' ) + // InternalProblem.g:39:9: 'true' + { + match("true"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "T__40" + + // $ANTLR start "T__41" + public final void mT__41() throws RecognitionException { + try { + int _type = T__41; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalProblem.g:40:7: ( 'false' ) + // InternalProblem.g:40:9: 'false' + { + match("false"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "T__41" + + // $ANTLR start "T__42" + public final void mT__42() throws RecognitionException { + try { + int _type = T__42; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalProblem.g:41:7: ( 'unknown' ) + // InternalProblem.g:41:9: 'unknown' + { + match("unknown"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "T__42" + + // $ANTLR start "T__43" + public final void mT__43() throws RecognitionException { + try { + int _type = T__43; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalProblem.g:42:7: ( '?' ) + // InternalProblem.g:42:9: '?' + { + match('?'); + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "T__43" + + // $ANTLR start "RULE_STRING" + public final void mRULE_STRING() throws RecognitionException { + try { + int _type = RULE_STRING; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalProblem.g:1895:13: ( '\"' ( '\\\\' . | ~ ( ( '\\\\' | '\"' ) ) )* '\"' ) + // InternalProblem.g:1895:15: '\"' ( '\\\\' . | ~ ( ( '\\\\' | '\"' ) ) )* '\"' + { + match('\"'); + // InternalProblem.g:1895:19: ( '\\\\' . | ~ ( ( '\\\\' | '\"' ) ) )* + loop1: + do { + int alt1=3; + int LA1_0 = input.LA(1); + + if ( (LA1_0=='\\') ) { + alt1=1; + } + else if ( ((LA1_0>='\u0000' && LA1_0<='!')||(LA1_0>='#' && LA1_0<='[')||(LA1_0>=']' && LA1_0<='\uFFFF')) ) { + alt1=2; + } + + + switch (alt1) { + case 1 : + // InternalProblem.g:1895:20: '\\\\' . + { + match('\\'); + matchAny(); + + } + break; + case 2 : + // InternalProblem.g:1895:27: ~ ( ( '\\\\' | '\"' ) ) + { + if ( (input.LA(1)>='\u0000' && input.LA(1)<='!')||(input.LA(1)>='#' && input.LA(1)<='[')||(input.LA(1)>=']' && input.LA(1)<='\uFFFF') ) { + input.consume(); + + } + else { + MismatchedSetException mse = new MismatchedSetException(null,input); + recover(mse); + throw mse;} + + + } + break; + + default : + break loop1; + } + } while (true); + + match('\"'); + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "RULE_STRING" + + // $ANTLR start "RULE_QUOTED_ID" + public final void mRULE_QUOTED_ID() throws RecognitionException { + try { + int _type = RULE_QUOTED_ID; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalProblem.g:1897:16: ( '\\'' ( '\\\\' . | ~ ( ( '\\\\' | '\\'' ) ) )* '\\'' ) + // InternalProblem.g:1897:18: '\\'' ( '\\\\' . | ~ ( ( '\\\\' | '\\'' ) ) )* '\\'' + { + match('\''); + // InternalProblem.g:1897:23: ( '\\\\' . | ~ ( ( '\\\\' | '\\'' ) ) )* + loop2: + do { + int alt2=3; + int LA2_0 = input.LA(1); + + if ( (LA2_0=='\\') ) { + alt2=1; + } + else if ( ((LA2_0>='\u0000' && LA2_0<='&')||(LA2_0>='(' && LA2_0<='[')||(LA2_0>=']' && LA2_0<='\uFFFF')) ) { + alt2=2; + } + + + switch (alt2) { + case 1 : + // InternalProblem.g:1897:24: '\\\\' . + { + match('\\'); + matchAny(); + + } + break; + case 2 : + // InternalProblem.g:1897:31: ~ ( ( '\\\\' | '\\'' ) ) + { + if ( (input.LA(1)>='\u0000' && input.LA(1)<='&')||(input.LA(1)>='(' && input.LA(1)<='[')||(input.LA(1)>=']' && input.LA(1)<='\uFFFF') ) { + input.consume(); + + } + else { + MismatchedSetException mse = new MismatchedSetException(null,input); + recover(mse); + throw mse;} + + + } + break; + + default : + break loop2; + } + } while (true); + + match('\''); + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "RULE_QUOTED_ID" + + // $ANTLR start "RULE_ID" + public final void mRULE_ID() throws RecognitionException { + try { + int _type = RULE_ID; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalProblem.g:1899:9: ( ( '^' )? ( 'a' .. 'z' | 'A' .. 'Z' | '_' ) ( 'a' .. 'z' | 'A' .. 'Z' | '_' | '0' .. '9' )* ) + // InternalProblem.g:1899:11: ( '^' )? ( 'a' .. 'z' | 'A' .. 'Z' | '_' ) ( 'a' .. 'z' | 'A' .. 'Z' | '_' | '0' .. '9' )* + { + // InternalProblem.g:1899:11: ( '^' )? + int alt3=2; + int LA3_0 = input.LA(1); + + if ( (LA3_0=='^') ) { + alt3=1; + } + switch (alt3) { + case 1 : + // InternalProblem.g:1899:11: '^' + { + match('^'); + + } + break; + + } + + if ( (input.LA(1)>='A' && input.LA(1)<='Z')||input.LA(1)=='_'||(input.LA(1)>='a' && input.LA(1)<='z') ) { + input.consume(); + + } + else { + MismatchedSetException mse = new MismatchedSetException(null,input); + recover(mse); + throw mse;} + + // InternalProblem.g:1899:40: ( 'a' .. 'z' | 'A' .. 'Z' | '_' | '0' .. '9' )* + loop4: + do { + int alt4=2; + int LA4_0 = input.LA(1); + + if ( ((LA4_0>='0' && LA4_0<='9')||(LA4_0>='A' && LA4_0<='Z')||LA4_0=='_'||(LA4_0>='a' && LA4_0<='z')) ) { + alt4=1; + } + + + switch (alt4) { + case 1 : + // InternalProblem.g: + { + if ( (input.LA(1)>='0' && input.LA(1)<='9')||(input.LA(1)>='A' && input.LA(1)<='Z')||input.LA(1)=='_'||(input.LA(1)>='a' && input.LA(1)<='z') ) { + input.consume(); + + } + else { + MismatchedSetException mse = new MismatchedSetException(null,input); + recover(mse); + throw mse;} + + + } + break; + + default : + break loop4; + } + } while (true); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "RULE_ID" + + // $ANTLR start "RULE_INT" + public final void mRULE_INT() throws RecognitionException { + try { + int _type = RULE_INT; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalProblem.g:1901:10: ( ( '0' .. '9' )+ ) + // InternalProblem.g:1901:12: ( '0' .. '9' )+ + { + // InternalProblem.g:1901:12: ( '0' .. '9' )+ + int cnt5=0; + loop5: + do { + int alt5=2; + int LA5_0 = input.LA(1); + + if ( ((LA5_0>='0' && LA5_0<='9')) ) { + alt5=1; + } + + + switch (alt5) { + case 1 : + // InternalProblem.g:1901:13: '0' .. '9' + { + matchRange('0','9'); + + } + break; + + default : + if ( cnt5 >= 1 ) break loop5; + EarlyExitException eee = + new EarlyExitException(5, input); + throw eee; + } + cnt5++; + } while (true); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "RULE_INT" + + // $ANTLR start "RULE_ML_COMMENT" + public final void mRULE_ML_COMMENT() throws RecognitionException { + try { + int _type = RULE_ML_COMMENT; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalProblem.g:1903:17: ( '/*' ( options {greedy=false; } : . )* '*/' ) + // InternalProblem.g:1903:19: '/*' ( options {greedy=false; } : . )* '*/' + { + match("/*"); + + // InternalProblem.g:1903:24: ( options {greedy=false; } : . )* + loop6: + do { + int alt6=2; + int LA6_0 = input.LA(1); + + if ( (LA6_0=='*') ) { + int LA6_1 = input.LA(2); + + if ( (LA6_1=='/') ) { + alt6=2; + } + else if ( ((LA6_1>='\u0000' && LA6_1<='.')||(LA6_1>='0' && LA6_1<='\uFFFF')) ) { + alt6=1; + } + + + } + else if ( ((LA6_0>='\u0000' && LA6_0<=')')||(LA6_0>='+' && LA6_0<='\uFFFF')) ) { + alt6=1; + } + + + switch (alt6) { + case 1 : + // InternalProblem.g:1903:52: . + { + matchAny(); + + } + break; + + default : + break loop6; + } + } while (true); + + match("*/"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "RULE_ML_COMMENT" + + // $ANTLR start "RULE_SL_COMMENT" + public final void mRULE_SL_COMMENT() throws RecognitionException { + try { + int _type = RULE_SL_COMMENT; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalProblem.g:1905:17: ( '//' (~ ( ( '\\n' | '\\r' ) ) )* ( ( '\\r' )? '\\n' )? ) + // InternalProblem.g:1905:19: '//' (~ ( ( '\\n' | '\\r' ) ) )* ( ( '\\r' )? '\\n' )? + { + match("//"); + + // InternalProblem.g:1905:24: (~ ( ( '\\n' | '\\r' ) ) )* + loop7: + do { + int alt7=2; + int LA7_0 = input.LA(1); + + if ( ((LA7_0>='\u0000' && LA7_0<='\t')||(LA7_0>='\u000B' && LA7_0<='\f')||(LA7_0>='\u000E' && LA7_0<='\uFFFF')) ) { + alt7=1; + } + + + switch (alt7) { + case 1 : + // InternalProblem.g:1905:24: ~ ( ( '\\n' | '\\r' ) ) + { + if ( (input.LA(1)>='\u0000' && input.LA(1)<='\t')||(input.LA(1)>='\u000B' && input.LA(1)<='\f')||(input.LA(1)>='\u000E' && input.LA(1)<='\uFFFF') ) { + input.consume(); + + } + else { + MismatchedSetException mse = new MismatchedSetException(null,input); + recover(mse); + throw mse;} + + + } + break; + + default : + break loop7; + } + } while (true); + + // InternalProblem.g:1905:40: ( ( '\\r' )? '\\n' )? + int alt9=2; + int LA9_0 = input.LA(1); + + if ( (LA9_0=='\n'||LA9_0=='\r') ) { + alt9=1; + } + switch (alt9) { + case 1 : + // InternalProblem.g:1905:41: ( '\\r' )? '\\n' + { + // InternalProblem.g:1905:41: ( '\\r' )? + int alt8=2; + int LA8_0 = input.LA(1); + + if ( (LA8_0=='\r') ) { + alt8=1; + } + switch (alt8) { + case 1 : + // InternalProblem.g:1905:41: '\\r' + { + match('\r'); + + } + break; + + } + + match('\n'); + + } + break; + + } + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "RULE_SL_COMMENT" + + // $ANTLR start "RULE_WS" + public final void mRULE_WS() throws RecognitionException { + try { + int _type = RULE_WS; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalProblem.g:1907:9: ( ( ' ' | '\\t' | '\\r' | '\\n' )+ ) + // InternalProblem.g:1907:11: ( ' ' | '\\t' | '\\r' | '\\n' )+ + { + // InternalProblem.g:1907:11: ( ' ' | '\\t' | '\\r' | '\\n' )+ + int cnt10=0; + loop10: + do { + int alt10=2; + int LA10_0 = input.LA(1); + + if ( ((LA10_0>='\t' && LA10_0<='\n')||LA10_0=='\r'||LA10_0==' ') ) { + alt10=1; + } + + + switch (alt10) { + case 1 : + // InternalProblem.g: + { + if ( (input.LA(1)>='\t' && input.LA(1)<='\n')||input.LA(1)=='\r'||input.LA(1)==' ' ) { + input.consume(); + + } + else { + MismatchedSetException mse = new MismatchedSetException(null,input); + recover(mse); + throw mse;} + + + } + break; + + default : + if ( cnt10 >= 1 ) break loop10; + EarlyExitException eee = + new EarlyExitException(10, input); + throw eee; + } + cnt10++; + } while (true); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "RULE_WS" + + // $ANTLR start "RULE_ANY_OTHER" + public final void mRULE_ANY_OTHER() throws RecognitionException { + try { + int _type = RULE_ANY_OTHER; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalProblem.g:1909:16: ( . ) + // InternalProblem.g:1909:18: . + { + matchAny(); + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "RULE_ANY_OTHER" + + public void mTokens() throws RecognitionException { + // InternalProblem.g:1:8: ( T__12 | T__13 | T__14 | T__15 | T__16 | T__17 | T__18 | T__19 | T__20 | T__21 | T__22 | T__23 | T__24 | T__25 | T__26 | T__27 | T__28 | T__29 | T__30 | T__31 | T__32 | T__33 | T__34 | T__35 | T__36 | T__37 | T__38 | T__39 | T__40 | T__41 | T__42 | T__43 | RULE_STRING | RULE_QUOTED_ID | RULE_ID | RULE_INT | RULE_ML_COMMENT | RULE_SL_COMMENT | RULE_WS | RULE_ANY_OTHER ) + int alt11=40; + alt11 = dfa11.predict(input); + switch (alt11) { + case 1 : + // InternalProblem.g:1:10: T__12 + { + mT__12(); + + } + break; + case 2 : + // InternalProblem.g:1:16: T__13 + { + mT__13(); + + } + break; + case 3 : + // InternalProblem.g:1:22: T__14 + { + mT__14(); + + } + break; + case 4 : + // InternalProblem.g:1:28: T__15 + { + mT__15(); + + } + break; + case 5 : + // InternalProblem.g:1:34: T__16 + { + mT__16(); + + } + break; + case 6 : + // InternalProblem.g:1:40: T__17 + { + mT__17(); + + } + break; + case 7 : + // InternalProblem.g:1:46: T__18 + { + mT__18(); + + } + break; + case 8 : + // InternalProblem.g:1:52: T__19 + { + mT__19(); + + } + break; + case 9 : + // InternalProblem.g:1:58: T__20 + { + mT__20(); + + } + break; + case 10 : + // InternalProblem.g:1:64: T__21 + { + mT__21(); + + } + break; + case 11 : + // InternalProblem.g:1:70: T__22 + { + mT__22(); + + } + break; + case 12 : + // InternalProblem.g:1:76: T__23 + { + mT__23(); + + } + break; + case 13 : + // InternalProblem.g:1:82: T__24 + { + mT__24(); + + } + break; + case 14 : + // InternalProblem.g:1:88: T__25 + { + mT__25(); + + } + break; + case 15 : + // InternalProblem.g:1:94: T__26 + { + mT__26(); + + } + break; + case 16 : + // InternalProblem.g:1:100: T__27 + { + mT__27(); + + } + break; + case 17 : + // InternalProblem.g:1:106: T__28 + { + mT__28(); + + } + break; + case 18 : + // InternalProblem.g:1:112: T__29 + { + mT__29(); + + } + break; + case 19 : + // InternalProblem.g:1:118: T__30 + { + mT__30(); + + } + break; + case 20 : + // InternalProblem.g:1:124: T__31 + { + mT__31(); + + } + break; + case 21 : + // InternalProblem.g:1:130: T__32 + { + mT__32(); + + } + break; + case 22 : + // InternalProblem.g:1:136: T__33 + { + mT__33(); + + } + break; + case 23 : + // InternalProblem.g:1:142: T__34 + { + mT__34(); + + } + break; + case 24 : + // InternalProblem.g:1:148: T__35 + { + mT__35(); + + } + break; + case 25 : + // InternalProblem.g:1:154: T__36 + { + mT__36(); + + } + break; + case 26 : + // InternalProblem.g:1:160: T__37 + { + mT__37(); + + } + break; + case 27 : + // InternalProblem.g:1:166: T__38 + { + mT__38(); + + } + break; + case 28 : + // InternalProblem.g:1:172: T__39 + { + mT__39(); + + } + break; + case 29 : + // InternalProblem.g:1:178: T__40 + { + mT__40(); + + } + break; + case 30 : + // InternalProblem.g:1:184: T__41 + { + mT__41(); + + } + break; + case 31 : + // InternalProblem.g:1:190: T__42 + { + mT__42(); + + } + break; + case 32 : + // InternalProblem.g:1:196: T__43 + { + mT__43(); + + } + break; + case 33 : + // InternalProblem.g:1:202: RULE_STRING + { + mRULE_STRING(); + + } + break; + case 34 : + // InternalProblem.g:1:214: RULE_QUOTED_ID + { + mRULE_QUOTED_ID(); + + } + break; + case 35 : + // InternalProblem.g:1:229: RULE_ID + { + mRULE_ID(); + + } + break; + case 36 : + // InternalProblem.g:1:237: RULE_INT + { + mRULE_INT(); + + } + break; + case 37 : + // InternalProblem.g:1:246: RULE_ML_COMMENT + { + mRULE_ML_COMMENT(); + + } + break; + case 38 : + // InternalProblem.g:1:262: RULE_SL_COMMENT + { + mRULE_SL_COMMENT(); + + } + break; + case 39 : + // InternalProblem.g:1:278: RULE_WS + { + mRULE_WS(); + + } + break; + case 40 : + // InternalProblem.g:1:286: RULE_ANY_OTHER + { + mRULE_ANY_OTHER(); + + } + break; + + } + + } + + + protected DFA11 dfa11 = new DFA11(this); + static final String DFA11_eotS = + "\1\uffff\1\43\1\45\3\43\4\uffff\1\43\2\uffff\1\43\2\uffff\1\67\1\uffff\1\72\1\43\2\uffff\3\43\1\uffff\3\41\2\uffff\1\41\2\uffff\1\43\3\uffff\6\43\4\uffff\1\43\2\uffff\1\43\7\uffff\1\43\2\uffff\3\43\7\uffff\17\43\1\145\4\43\1\152\4\43\1\157\3\43\1\uffff\1\43\1\164\2\43\1\uffff\1\167\2\43\1\172\1\uffff\1\173\3\43\1\uffff\2\43\1\uffff\1\u0081\1\43\2\uffff\1\43\1\u0084\2\43\1\u0087\1\uffff\1\43\1\u0089\1\uffff\1\u008a\1\u008b\1\uffff\1\u008c\4\uffff"; + static final String DFA11_eofS = + "\u008d\uffff"; + static final String DFA11_minS = + "\1\0\1\162\1\56\1\142\1\154\1\156\4\uffff\1\145\2\uffff\1\160\2\uffff\1\55\1\uffff\1\75\1\143\2\uffff\1\162\1\141\1\156\1\uffff\2\0\1\101\2\uffff\1\52\2\uffff\1\145\3\uffff\1\163\1\141\1\156\1\164\1\165\1\162\4\uffff\1\146\2\uffff\1\160\7\uffff\1\157\2\uffff\1\165\1\154\1\153\7\uffff\1\142\1\144\1\164\1\163\1\164\1\145\1\155\1\157\1\145\1\157\1\160\1\145\1\163\1\156\1\154\1\60\1\162\1\163\1\141\1\156\1\60\2\162\1\163\1\145\1\60\1\145\1\157\1\145\1\uffff\1\141\1\60\1\151\1\144\1\uffff\1\60\1\163\1\151\1\60\1\uffff\1\60\1\167\1\155\1\143\1\uffff\1\156\1\163\1\uffff\1\60\1\164\2\uffff\1\156\1\60\1\164\1\163\1\60\1\uffff\1\145\1\60\1\uffff\2\60\1\uffff\1\60\4\uffff"; + static final String DFA11_maxS = + "\1\uffff\1\162\1\56\1\142\1\157\1\170\4\uffff\1\145\2\uffff\1\160\2\uffff\1\55\1\uffff\1\75\1\143\2\uffff\1\162\1\141\1\156\1\uffff\2\uffff\1\172\2\uffff\1\57\2\uffff\1\157\3\uffff\1\163\1\141\1\156\1\164\1\165\1\162\4\uffff\1\146\2\uffff\1\160\7\uffff\1\157\2\uffff\1\165\1\154\1\153\7\uffff\1\142\1\144\1\164\1\163\1\164\1\145\1\155\1\157\1\145\1\157\1\160\1\145\1\163\1\156\1\154\1\172\1\162\1\163\1\141\1\156\1\172\2\162\1\163\1\145\1\172\1\145\1\157\1\145\1\uffff\1\141\1\172\1\151\1\144\1\uffff\1\172\1\163\1\151\1\172\1\uffff\1\172\1\167\1\155\1\143\1\uffff\1\156\1\163\1\uffff\1\172\1\164\2\uffff\1\156\1\172\1\164\1\163\1\172\1\uffff\1\145\1\172\1\uffff\2\172\1\uffff\1\172\4\uffff"; + static final String DFA11_acceptS = + "\6\uffff\1\6\1\7\1\10\1\11\1\uffff\1\15\1\16\1\uffff\1\22\1\23\1\uffff\1\25\2\uffff\1\32\1\34\3\uffff\1\40\3\uffff\1\43\1\44\1\uffff\1\47\1\50\1\uffff\1\43\1\33\1\2\6\uffff\1\6\1\7\1\10\1\11\1\uffff\1\15\1\16\1\uffff\1\22\1\23\1\24\1\27\1\25\1\31\1\26\1\uffff\1\32\1\34\3\uffff\1\40\1\41\1\42\1\44\1\45\1\46\1\47\35\uffff\1\21\4\uffff\1\12\4\uffff\1\35\4\uffff\1\4\2\uffff\1\20\2\uffff\1\30\1\36\5\uffff\1\14\2\uffff\1\1\2\uffff\1\5\1\uffff\1\37\1\3\1\13\1\17"; + static final String DFA11_specialS = + "\1\2\31\uffff\1\1\1\0\161\uffff}>"; + static final String[] DFA11_transitionS = { + "\11\41\2\40\2\41\1\40\22\41\1\40\1\21\1\32\4\41\1\33\1\16\1\17\1\25\1\22\1\6\1\41\1\2\1\37\12\36\1\20\1\10\1\41\1\24\1\41\1\31\1\41\32\35\1\13\1\41\1\14\1\34\1\35\1\41\1\3\1\35\1\4\1\35\1\5\1\27\10\35\1\15\1\1\1\35\1\12\1\23\1\26\1\30\5\35\1\7\1\41\1\11\uff82\41", + "\1\42", + "\1\44", + "\1\46", + "\1\47\2\uffff\1\50", + "\1\52\3\uffff\1\53\5\uffff\1\51", + "", + "", + "", + "", + "\1\60", + "", + "", + "\1\63", + "", + "", + "\1\66", + "", + "\1\71", + "\1\73", + "", + "", + "\1\76", + "\1\77", + "\1\100", + "", + "\0\102", + "\0\103", + "\32\43\4\uffff\1\43\1\uffff\32\43", + "", + "", + "\1\105\4\uffff\1\106", + "", + "", + "\1\111\11\uffff\1\110", + "", + "", + "", + "\1\112", + "\1\113", + "\1\114", + "\1\115", + "\1\116", + "\1\117", + "", + "", + "", + "", + "\1\120", + "", + "", + "\1\121", + "", + "", + "", + "", + "", + "", + "", + "\1\122", + "", + "", + "\1\123", + "\1\124", + "\1\125", + "", + "", + "", + "", + "", + "", + "", + "\1\126", + "\1\127", + "\1\130", + "\1\131", + "\1\132", + "\1\133", + "\1\134", + "\1\135", + "\1\136", + "\1\137", + "\1\140", + "\1\141", + "\1\142", + "\1\143", + "\1\144", + "\12\43\7\uffff\32\43\4\uffff\1\43\1\uffff\32\43", + "\1\146", + "\1\147", + "\1\150", + "\1\151", + "\12\43\7\uffff\32\43\4\uffff\1\43\1\uffff\32\43", + "\1\153", + "\1\154", + "\1\155", + "\1\156", + "\12\43\7\uffff\32\43\4\uffff\1\43\1\uffff\32\43", + "\1\160", + "\1\161", + "\1\162", + "", + "\1\163", + "\12\43\7\uffff\32\43\4\uffff\1\43\1\uffff\32\43", + "\1\165", + "\1\166", + "", + "\12\43\7\uffff\32\43\4\uffff\1\43\1\uffff\32\43", + "\1\170", + "\1\171", + "\12\43\7\uffff\32\43\4\uffff\1\43\1\uffff\32\43", + "", + "\12\43\7\uffff\32\43\4\uffff\1\43\1\uffff\32\43", + "\1\174", + "\1\175", + "\1\176", + "", + "\1\177", + "\1\u0080", + "", + "\12\43\7\uffff\32\43\4\uffff\1\43\1\uffff\32\43", + "\1\u0082", + "", + "", + "\1\u0083", + "\12\43\7\uffff\32\43\4\uffff\1\43\1\uffff\32\43", + "\1\u0085", + "\1\u0086", + "\12\43\7\uffff\32\43\4\uffff\1\43\1\uffff\32\43", + "", + "\1\u0088", + "\12\43\7\uffff\32\43\4\uffff\1\43\1\uffff\32\43", + "", + "\12\43\7\uffff\32\43\4\uffff\1\43\1\uffff\32\43", + "\12\43\7\uffff\32\43\4\uffff\1\43\1\uffff\32\43", + "", + "\12\43\7\uffff\32\43\4\uffff\1\43\1\uffff\32\43", + "", + "", + "", + "" + }; + + static final short[] DFA11_eot = DFA.unpackEncodedString(DFA11_eotS); + static final short[] DFA11_eof = DFA.unpackEncodedString(DFA11_eofS); + static final char[] DFA11_min = DFA.unpackEncodedStringToUnsignedChars(DFA11_minS); + static final char[] DFA11_max = DFA.unpackEncodedStringToUnsignedChars(DFA11_maxS); + static final short[] DFA11_accept = DFA.unpackEncodedString(DFA11_acceptS); + static final short[] DFA11_special = DFA.unpackEncodedString(DFA11_specialS); + static final short[][] DFA11_transition; + + static { + int numStates = DFA11_transitionS.length; + DFA11_transition = new short[numStates][]; + for (int i=0; i='\u0000' && LA11_27<='\uFFFF')) ) {s = 67;} + + else s = 33; + + if ( s>=0 ) return s; + break; + case 1 : + int LA11_26 = input.LA(1); + + s = -1; + if ( ((LA11_26>='\u0000' && LA11_26<='\uFFFF')) ) {s = 66;} + + else s = 33; + + if ( s>=0 ) return s; + break; + case 2 : + int LA11_0 = input.LA(1); + + s = -1; + if ( (LA11_0=='p') ) {s = 1;} + + else if ( (LA11_0=='.') ) {s = 2;} + + else if ( (LA11_0=='a') ) {s = 3;} + + else if ( (LA11_0=='c') ) {s = 4;} + + else if ( (LA11_0=='e') ) {s = 5;} + + else if ( (LA11_0==',') ) {s = 6;} + + else if ( (LA11_0=='{') ) {s = 7;} + + else if ( (LA11_0==';') ) {s = 8;} + + else if ( (LA11_0=='}') ) {s = 9;} + + else if ( (LA11_0=='r') ) {s = 10;} + + else if ( (LA11_0=='[') ) {s = 11;} + + else if ( (LA11_0==']') ) {s = 12;} + + else if ( (LA11_0=='o') ) {s = 13;} + + else if ( (LA11_0=='(') ) {s = 14;} + + else if ( (LA11_0==')') ) {s = 15;} + + else if ( (LA11_0==':') ) {s = 16;} + + else if ( (LA11_0=='!') ) {s = 17;} + + else if ( (LA11_0=='+') ) {s = 18;} + + else if ( (LA11_0=='s') ) {s = 19;} + + else if ( (LA11_0=='=') ) {s = 20;} + + else if ( (LA11_0=='*') ) {s = 21;} + + else if ( (LA11_0=='t') ) {s = 22;} + + else if ( (LA11_0=='f') ) {s = 23;} + + else if ( (LA11_0=='u') ) {s = 24;} + + else if ( (LA11_0=='?') ) {s = 25;} + + else if ( (LA11_0=='\"') ) {s = 26;} + + else if ( (LA11_0=='\'') ) {s = 27;} + + else if ( (LA11_0=='^') ) {s = 28;} + + else if ( ((LA11_0>='A' && LA11_0<='Z')||LA11_0=='_'||LA11_0=='b'||LA11_0=='d'||(LA11_0>='g' && LA11_0<='n')||LA11_0=='q'||(LA11_0>='v' && LA11_0<='z')) ) {s = 29;} + + else if ( ((LA11_0>='0' && LA11_0<='9')) ) {s = 30;} + + else if ( (LA11_0=='/') ) {s = 31;} + + else if ( ((LA11_0>='\t' && LA11_0<='\n')||LA11_0=='\r'||LA11_0==' ') ) {s = 32;} + + else if ( ((LA11_0>='\u0000' && LA11_0<='\b')||(LA11_0>='\u000B' && LA11_0<='\f')||(LA11_0>='\u000E' && LA11_0<='\u001F')||(LA11_0>='#' && LA11_0<='&')||LA11_0=='-'||LA11_0=='<'||LA11_0=='>'||LA11_0=='@'||LA11_0=='\\'||LA11_0=='`'||LA11_0=='|'||(LA11_0>='~' && LA11_0<='\uFFFF')) ) {s = 33;} + + if ( s>=0 ) return s; + break; + } + NoViableAltException nvae = + new NoViableAltException(getDescription(), 11, _s, input); + error(nvae); + throw nvae; + } + } + + +} \ No newline at end of file diff --git a/language/src/main/xtext-gen/org/eclipse/viatra/solver/language/parser/antlr/internal/InternalProblemParser.java b/language/src/main/xtext-gen/org/eclipse/viatra/solver/language/parser/antlr/internal/InternalProblemParser.java new file mode 100644 index 00000000..28b54551 --- /dev/null +++ b/language/src/main/xtext-gen/org/eclipse/viatra/solver/language/parser/antlr/internal/InternalProblemParser.java @@ -0,0 +1,5296 @@ +package org.eclipse.viatra.solver.language.parser.antlr.internal; + +import org.eclipse.xtext.*; +import org.eclipse.xtext.parser.*; +import org.eclipse.xtext.parser.impl.*; +import org.eclipse.emf.ecore.util.EcoreUtil; +import org.eclipse.emf.ecore.EObject; +import org.eclipse.emf.common.util.Enumerator; +import org.eclipse.xtext.parser.antlr.AbstractInternalAntlrParser; +import org.eclipse.xtext.parser.antlr.XtextTokenStream; +import org.eclipse.xtext.parser.antlr.XtextTokenStream.HiddenTokens; +import org.eclipse.xtext.parser.antlr.AntlrDatatypeRuleToken; +import org.eclipse.viatra.solver.language.services.ProblemGrammarAccess; + + + +import org.antlr.runtime.*; +import java.util.Stack; +import java.util.List; +import java.util.ArrayList; + +@SuppressWarnings("all") +public class InternalProblemParser extends AbstractInternalAntlrParser { + public static final String[] tokenNames = new String[] { + "", "", "", "", "RULE_ID", "RULE_INT", "RULE_QUOTED_ID", "RULE_STRING", "RULE_ML_COMMENT", "RULE_SL_COMMENT", "RULE_WS", "RULE_ANY_OTHER", "'problem'", "'.'", "'abstract'", "'class'", "'extends'", "','", "'{'", "';'", "'}'", "'enum'", "'contains'", "'refers'", "'['", "']'", "'opposite'", "'error'", "'pred'", "'('", "')'", "':-'", "'!'", "'+'", "':'", "'scope'", "'+='", "'='", "'..'", "'*'", "'true'", "'false'", "'unknown'", "'?'" + }; + public static final int T__19=19; + public static final int T__15=15; + public static final int T__16=16; + public static final int T__17=17; + public static final int T__18=18; + public static final int T__12=12; + public static final int T__13=13; + public static final int T__14=14; + public static final int RULE_ID=4; + public static final int RULE_QUOTED_ID=6; + public static final int T__26=26; + public static final int T__27=27; + public static final int T__28=28; + public static final int RULE_INT=5; + public static final int T__29=29; + public static final int T__22=22; + public static final int RULE_ML_COMMENT=8; + public static final int T__23=23; + public static final int T__24=24; + public static final int T__25=25; + public static final int T__20=20; + public static final int T__21=21; + public static final int RULE_STRING=7; + public static final int RULE_SL_COMMENT=9; + public static final int T__37=37; + public static final int T__38=38; + public static final int T__39=39; + public static final int T__33=33; + public static final int T__34=34; + public static final int T__35=35; + public static final int T__36=36; + public static final int EOF=-1; + public static final int T__30=30; + public static final int T__31=31; + public static final int T__32=32; + public static final int RULE_WS=10; + public static final int RULE_ANY_OTHER=11; + public static final int T__40=40; + public static final int T__41=41; + public static final int T__42=42; + public static final int T__43=43; + + // delegates + // delegators + + + public InternalProblemParser(TokenStream input) { + this(input, new RecognizerSharedState()); + } + public InternalProblemParser(TokenStream input, RecognizerSharedState state) { + super(input, state); + + } + + + public String[] getTokenNames() { return InternalProblemParser.tokenNames; } + public String getGrammarFileName() { return "InternalProblem.g"; } + + + + private ProblemGrammarAccess grammarAccess; + + public InternalProblemParser(TokenStream input, ProblemGrammarAccess grammarAccess) { + this(input); + this.grammarAccess = grammarAccess; + registerRules(grammarAccess.getGrammar()); + } + + @Override + protected String getFirstRuleName() { + return "Problem"; + } + + @Override + protected ProblemGrammarAccess getGrammarAccess() { + return grammarAccess; + } + + + + + // $ANTLR start "entryRuleProblem" + // InternalProblem.g:65:1: entryRuleProblem returns [EObject current=null] : iv_ruleProblem= ruleProblem EOF ; + public final EObject entryRuleProblem() throws RecognitionException { + EObject current = null; + + EObject iv_ruleProblem = null; + + + try { + // InternalProblem.g:65:48: (iv_ruleProblem= ruleProblem EOF ) + // InternalProblem.g:66:2: iv_ruleProblem= ruleProblem EOF + { + newCompositeNode(grammarAccess.getProblemRule()); + pushFollow(FOLLOW_1); + iv_ruleProblem=ruleProblem(); + + state._fsp--; + + current =iv_ruleProblem; + match(input,EOF,FOLLOW_2); + + } + + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "entryRuleProblem" + + + // $ANTLR start "ruleProblem" + // InternalProblem.g:72:1: ruleProblem returns [EObject current=null] : ( (otherlv_0= 'problem' ( (lv_name_1_0= ruleIdentifier ) ) otherlv_2= '.' )? ( (lv_statements_3_0= ruleStatement ) )* ) ; + public final EObject ruleProblem() throws RecognitionException { + EObject current = null; + + Token otherlv_0=null; + Token otherlv_2=null; + AntlrDatatypeRuleToken lv_name_1_0 = null; + + EObject lv_statements_3_0 = null; + + + + enterRule(); + + try { + // InternalProblem.g:78:2: ( ( (otherlv_0= 'problem' ( (lv_name_1_0= ruleIdentifier ) ) otherlv_2= '.' )? ( (lv_statements_3_0= ruleStatement ) )* ) ) + // InternalProblem.g:79:2: ( (otherlv_0= 'problem' ( (lv_name_1_0= ruleIdentifier ) ) otherlv_2= '.' )? ( (lv_statements_3_0= ruleStatement ) )* ) + { + // InternalProblem.g:79:2: ( (otherlv_0= 'problem' ( (lv_name_1_0= ruleIdentifier ) ) otherlv_2= '.' )? ( (lv_statements_3_0= ruleStatement ) )* ) + // InternalProblem.g:80:3: (otherlv_0= 'problem' ( (lv_name_1_0= ruleIdentifier ) ) otherlv_2= '.' )? ( (lv_statements_3_0= ruleStatement ) )* + { + // InternalProblem.g:80:3: (otherlv_0= 'problem' ( (lv_name_1_0= ruleIdentifier ) ) otherlv_2= '.' )? + int alt1=2; + int LA1_0 = input.LA(1); + + if ( (LA1_0==12) ) { + alt1=1; + } + switch (alt1) { + case 1 : + // InternalProblem.g:81:4: otherlv_0= 'problem' ( (lv_name_1_0= ruleIdentifier ) ) otherlv_2= '.' + { + otherlv_0=(Token)match(input,12,FOLLOW_3); + + newLeafNode(otherlv_0, grammarAccess.getProblemAccess().getProblemKeyword_0_0()); + + // InternalProblem.g:85:4: ( (lv_name_1_0= ruleIdentifier ) ) + // InternalProblem.g:86:5: (lv_name_1_0= ruleIdentifier ) + { + // InternalProblem.g:86:5: (lv_name_1_0= ruleIdentifier ) + // InternalProblem.g:87:6: lv_name_1_0= ruleIdentifier + { + + newCompositeNode(grammarAccess.getProblemAccess().getNameIdentifierParserRuleCall_0_1_0()); + + pushFollow(FOLLOW_4); + lv_name_1_0=ruleIdentifier(); + + state._fsp--; + + + if (current==null) { + current = createModelElementForParent(grammarAccess.getProblemRule()); + } + set( + current, + "name", + lv_name_1_0, + "org.eclipse.viatra.solver.language.Problem.Identifier"); + afterParserOrEnumRuleCall(); + + + } + + + } + + otherlv_2=(Token)match(input,13,FOLLOW_5); + + newLeafNode(otherlv_2, grammarAccess.getProblemAccess().getFullStopKeyword_0_2()); + + + } + break; + + } + + // InternalProblem.g:109:3: ( (lv_statements_3_0= ruleStatement ) )* + loop2: + do { + int alt2=2; + int LA2_0 = input.LA(1); + + if ( (LA2_0==RULE_ID||LA2_0==RULE_QUOTED_ID||(LA2_0>=14 && LA2_0<=15)||LA2_0==21||(LA2_0>=27 && LA2_0<=28)||LA2_0==32||LA2_0==35||(LA2_0>=40 && LA2_0<=41)||LA2_0==43) ) { + alt2=1; + } + + + switch (alt2) { + case 1 : + // InternalProblem.g:110:4: (lv_statements_3_0= ruleStatement ) + { + // InternalProblem.g:110:4: (lv_statements_3_0= ruleStatement ) + // InternalProblem.g:111:5: lv_statements_3_0= ruleStatement + { + + newCompositeNode(grammarAccess.getProblemAccess().getStatementsStatementParserRuleCall_1_0()); + + pushFollow(FOLLOW_5); + lv_statements_3_0=ruleStatement(); + + state._fsp--; + + + if (current==null) { + current = createModelElementForParent(grammarAccess.getProblemRule()); + } + add( + current, + "statements", + lv_statements_3_0, + "org.eclipse.viatra.solver.language.Problem.Statement"); + afterParserOrEnumRuleCall(); + + + } + + + } + break; + + default : + break loop2; + } + } while (true); + + + } + + + } + + + leaveRule(); + + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "ruleProblem" + + + // $ANTLR start "entryRuleStatement" + // InternalProblem.g:132:1: entryRuleStatement returns [EObject current=null] : iv_ruleStatement= ruleStatement EOF ; + public final EObject entryRuleStatement() throws RecognitionException { + EObject current = null; + + EObject iv_ruleStatement = null; + + + try { + // InternalProblem.g:132:50: (iv_ruleStatement= ruleStatement EOF ) + // InternalProblem.g:133:2: iv_ruleStatement= ruleStatement EOF + { + newCompositeNode(grammarAccess.getStatementRule()); + pushFollow(FOLLOW_1); + iv_ruleStatement=ruleStatement(); + + state._fsp--; + + current =iv_ruleStatement; + match(input,EOF,FOLLOW_2); + + } + + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "entryRuleStatement" + + + // $ANTLR start "ruleStatement" + // InternalProblem.g:139:1: ruleStatement returns [EObject current=null] : (this_ClassDeclaration_0= ruleClassDeclaration | this_EnumDeclaration_1= ruleEnumDeclaration | this_PredicateDefinition_2= rulePredicateDefinition | this_Assertion_3= ruleAssertion | this_ScopeDeclaration_4= ruleScopeDeclaration ) ; + public final EObject ruleStatement() throws RecognitionException { + EObject current = null; + + EObject this_ClassDeclaration_0 = null; + + EObject this_EnumDeclaration_1 = null; + + EObject this_PredicateDefinition_2 = null; + + EObject this_Assertion_3 = null; + + EObject this_ScopeDeclaration_4 = null; + + + + enterRule(); + + try { + // InternalProblem.g:145:2: ( (this_ClassDeclaration_0= ruleClassDeclaration | this_EnumDeclaration_1= ruleEnumDeclaration | this_PredicateDefinition_2= rulePredicateDefinition | this_Assertion_3= ruleAssertion | this_ScopeDeclaration_4= ruleScopeDeclaration ) ) + // InternalProblem.g:146:2: (this_ClassDeclaration_0= ruleClassDeclaration | this_EnumDeclaration_1= ruleEnumDeclaration | this_PredicateDefinition_2= rulePredicateDefinition | this_Assertion_3= ruleAssertion | this_ScopeDeclaration_4= ruleScopeDeclaration ) + { + // InternalProblem.g:146:2: (this_ClassDeclaration_0= ruleClassDeclaration | this_EnumDeclaration_1= ruleEnumDeclaration | this_PredicateDefinition_2= rulePredicateDefinition | this_Assertion_3= ruleAssertion | this_ScopeDeclaration_4= ruleScopeDeclaration ) + int alt3=5; + switch ( input.LA(1) ) { + case 14: + case 15: + { + alt3=1; + } + break; + case 21: + { + alt3=2; + } + break; + case 27: + case 28: + { + alt3=3; + } + break; + case RULE_ID: + case RULE_QUOTED_ID: + case 32: + case 40: + case 41: + case 43: + { + alt3=4; + } + break; + case 35: + { + alt3=5; + } + break; + default: + NoViableAltException nvae = + new NoViableAltException("", 3, 0, input); + + throw nvae; + } + + switch (alt3) { + case 1 : + // InternalProblem.g:147:3: this_ClassDeclaration_0= ruleClassDeclaration + { + + newCompositeNode(grammarAccess.getStatementAccess().getClassDeclarationParserRuleCall_0()); + + pushFollow(FOLLOW_2); + this_ClassDeclaration_0=ruleClassDeclaration(); + + state._fsp--; + + + current = this_ClassDeclaration_0; + afterParserOrEnumRuleCall(); + + + } + break; + case 2 : + // InternalProblem.g:156:3: this_EnumDeclaration_1= ruleEnumDeclaration + { + + newCompositeNode(grammarAccess.getStatementAccess().getEnumDeclarationParserRuleCall_1()); + + pushFollow(FOLLOW_2); + this_EnumDeclaration_1=ruleEnumDeclaration(); + + state._fsp--; + + + current = this_EnumDeclaration_1; + afterParserOrEnumRuleCall(); + + + } + break; + case 3 : + // InternalProblem.g:165:3: this_PredicateDefinition_2= rulePredicateDefinition + { + + newCompositeNode(grammarAccess.getStatementAccess().getPredicateDefinitionParserRuleCall_2()); + + pushFollow(FOLLOW_2); + this_PredicateDefinition_2=rulePredicateDefinition(); + + state._fsp--; + + + current = this_PredicateDefinition_2; + afterParserOrEnumRuleCall(); + + + } + break; + case 4 : + // InternalProblem.g:174:3: this_Assertion_3= ruleAssertion + { + + newCompositeNode(grammarAccess.getStatementAccess().getAssertionParserRuleCall_3()); + + pushFollow(FOLLOW_2); + this_Assertion_3=ruleAssertion(); + + state._fsp--; + + + current = this_Assertion_3; + afterParserOrEnumRuleCall(); + + + } + break; + case 5 : + // InternalProblem.g:183:3: this_ScopeDeclaration_4= ruleScopeDeclaration + { + + newCompositeNode(grammarAccess.getStatementAccess().getScopeDeclarationParserRuleCall_4()); + + pushFollow(FOLLOW_2); + this_ScopeDeclaration_4=ruleScopeDeclaration(); + + state._fsp--; + + + current = this_ScopeDeclaration_4; + afterParserOrEnumRuleCall(); + + + } + break; + + } + + + } + + + leaveRule(); + + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "ruleStatement" + + + // $ANTLR start "entryRuleClassDeclaration" + // InternalProblem.g:195:1: entryRuleClassDeclaration returns [EObject current=null] : iv_ruleClassDeclaration= ruleClassDeclaration EOF ; + public final EObject entryRuleClassDeclaration() throws RecognitionException { + EObject current = null; + + EObject iv_ruleClassDeclaration = null; + + + try { + // InternalProblem.g:195:57: (iv_ruleClassDeclaration= ruleClassDeclaration EOF ) + // InternalProblem.g:196:2: iv_ruleClassDeclaration= ruleClassDeclaration EOF + { + newCompositeNode(grammarAccess.getClassDeclarationRule()); + pushFollow(FOLLOW_1); + iv_ruleClassDeclaration=ruleClassDeclaration(); + + state._fsp--; + + current =iv_ruleClassDeclaration; + match(input,EOF,FOLLOW_2); + + } + + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "entryRuleClassDeclaration" + + + // $ANTLR start "ruleClassDeclaration" + // InternalProblem.g:202:1: ruleClassDeclaration returns [EObject current=null] : ( ( (lv_abstract_0_0= 'abstract' ) )? otherlv_1= 'class' ( (lv_name_2_0= ruleIdentifier ) ) (otherlv_3= 'extends' ( ( ruleQualifiedName ) ) (otherlv_5= ',' ( ( ruleQualifiedName ) ) )* )? ( (otherlv_7= '{' ( ( (lv_referenceDeclarations_8_0= ruleReferenceDeclaration ) ) (otherlv_9= ';' )? )* otherlv_10= '}' ) | otherlv_11= '.' ) ) ; + public final EObject ruleClassDeclaration() throws RecognitionException { + EObject current = null; + + Token lv_abstract_0_0=null; + Token otherlv_1=null; + Token otherlv_3=null; + Token otherlv_5=null; + Token otherlv_7=null; + Token otherlv_9=null; + Token otherlv_10=null; + Token otherlv_11=null; + AntlrDatatypeRuleToken lv_name_2_0 = null; + + EObject lv_referenceDeclarations_8_0 = null; + + + + enterRule(); + + try { + // InternalProblem.g:208:2: ( ( ( (lv_abstract_0_0= 'abstract' ) )? otherlv_1= 'class' ( (lv_name_2_0= ruleIdentifier ) ) (otherlv_3= 'extends' ( ( ruleQualifiedName ) ) (otherlv_5= ',' ( ( ruleQualifiedName ) ) )* )? ( (otherlv_7= '{' ( ( (lv_referenceDeclarations_8_0= ruleReferenceDeclaration ) ) (otherlv_9= ';' )? )* otherlv_10= '}' ) | otherlv_11= '.' ) ) ) + // InternalProblem.g:209:2: ( ( (lv_abstract_0_0= 'abstract' ) )? otherlv_1= 'class' ( (lv_name_2_0= ruleIdentifier ) ) (otherlv_3= 'extends' ( ( ruleQualifiedName ) ) (otherlv_5= ',' ( ( ruleQualifiedName ) ) )* )? ( (otherlv_7= '{' ( ( (lv_referenceDeclarations_8_0= ruleReferenceDeclaration ) ) (otherlv_9= ';' )? )* otherlv_10= '}' ) | otherlv_11= '.' ) ) + { + // InternalProblem.g:209:2: ( ( (lv_abstract_0_0= 'abstract' ) )? otherlv_1= 'class' ( (lv_name_2_0= ruleIdentifier ) ) (otherlv_3= 'extends' ( ( ruleQualifiedName ) ) (otherlv_5= ',' ( ( ruleQualifiedName ) ) )* )? ( (otherlv_7= '{' ( ( (lv_referenceDeclarations_8_0= ruleReferenceDeclaration ) ) (otherlv_9= ';' )? )* otherlv_10= '}' ) | otherlv_11= '.' ) ) + // InternalProblem.g:210:3: ( (lv_abstract_0_0= 'abstract' ) )? otherlv_1= 'class' ( (lv_name_2_0= ruleIdentifier ) ) (otherlv_3= 'extends' ( ( ruleQualifiedName ) ) (otherlv_5= ',' ( ( ruleQualifiedName ) ) )* )? ( (otherlv_7= '{' ( ( (lv_referenceDeclarations_8_0= ruleReferenceDeclaration ) ) (otherlv_9= ';' )? )* otherlv_10= '}' ) | otherlv_11= '.' ) + { + // InternalProblem.g:210:3: ( (lv_abstract_0_0= 'abstract' ) )? + int alt4=2; + int LA4_0 = input.LA(1); + + if ( (LA4_0==14) ) { + alt4=1; + } + switch (alt4) { + case 1 : + // InternalProblem.g:211:4: (lv_abstract_0_0= 'abstract' ) + { + // InternalProblem.g:211:4: (lv_abstract_0_0= 'abstract' ) + // InternalProblem.g:212:5: lv_abstract_0_0= 'abstract' + { + lv_abstract_0_0=(Token)match(input,14,FOLLOW_6); + + newLeafNode(lv_abstract_0_0, grammarAccess.getClassDeclarationAccess().getAbstractAbstractKeyword_0_0()); + + + if (current==null) { + current = createModelElement(grammarAccess.getClassDeclarationRule()); + } + setWithLastConsumed(current, "abstract", lv_abstract_0_0 != null, "abstract"); + + + } + + + } + break; + + } + + otherlv_1=(Token)match(input,15,FOLLOW_3); + + newLeafNode(otherlv_1, grammarAccess.getClassDeclarationAccess().getClassKeyword_1()); + + // InternalProblem.g:228:3: ( (lv_name_2_0= ruleIdentifier ) ) + // InternalProblem.g:229:4: (lv_name_2_0= ruleIdentifier ) + { + // InternalProblem.g:229:4: (lv_name_2_0= ruleIdentifier ) + // InternalProblem.g:230:5: lv_name_2_0= ruleIdentifier + { + + newCompositeNode(grammarAccess.getClassDeclarationAccess().getNameIdentifierParserRuleCall_2_0()); + + pushFollow(FOLLOW_7); + lv_name_2_0=ruleIdentifier(); + + state._fsp--; + + + if (current==null) { + current = createModelElementForParent(grammarAccess.getClassDeclarationRule()); + } + set( + current, + "name", + lv_name_2_0, + "org.eclipse.viatra.solver.language.Problem.Identifier"); + afterParserOrEnumRuleCall(); + + + } + + + } + + // InternalProblem.g:247:3: (otherlv_3= 'extends' ( ( ruleQualifiedName ) ) (otherlv_5= ',' ( ( ruleQualifiedName ) ) )* )? + int alt6=2; + int LA6_0 = input.LA(1); + + if ( (LA6_0==16) ) { + alt6=1; + } + switch (alt6) { + case 1 : + // InternalProblem.g:248:4: otherlv_3= 'extends' ( ( ruleQualifiedName ) ) (otherlv_5= ',' ( ( ruleQualifiedName ) ) )* + { + otherlv_3=(Token)match(input,16,FOLLOW_8); + + newLeafNode(otherlv_3, grammarAccess.getClassDeclarationAccess().getExtendsKeyword_3_0()); + + // InternalProblem.g:252:4: ( ( ruleQualifiedName ) ) + // InternalProblem.g:253:5: ( ruleQualifiedName ) + { + // InternalProblem.g:253:5: ( ruleQualifiedName ) + // InternalProblem.g:254:6: ruleQualifiedName + { + + if (current==null) { + current = createModelElement(grammarAccess.getClassDeclarationRule()); + } + + + newCompositeNode(grammarAccess.getClassDeclarationAccess().getSuperTypesRelationCrossReference_3_1_0()); + + pushFollow(FOLLOW_9); + ruleQualifiedName(); + + state._fsp--; + + + afterParserOrEnumRuleCall(); + + + } + + + } + + // InternalProblem.g:268:4: (otherlv_5= ',' ( ( ruleQualifiedName ) ) )* + loop5: + do { + int alt5=2; + int LA5_0 = input.LA(1); + + if ( (LA5_0==17) ) { + alt5=1; + } + + + switch (alt5) { + case 1 : + // InternalProblem.g:269:5: otherlv_5= ',' ( ( ruleQualifiedName ) ) + { + otherlv_5=(Token)match(input,17,FOLLOW_8); + + newLeafNode(otherlv_5, grammarAccess.getClassDeclarationAccess().getCommaKeyword_3_2_0()); + + // InternalProblem.g:273:5: ( ( ruleQualifiedName ) ) + // InternalProblem.g:274:6: ( ruleQualifiedName ) + { + // InternalProblem.g:274:6: ( ruleQualifiedName ) + // InternalProblem.g:275:7: ruleQualifiedName + { + + if (current==null) { + current = createModelElement(grammarAccess.getClassDeclarationRule()); + } + + + newCompositeNode(grammarAccess.getClassDeclarationAccess().getSuperTypesRelationCrossReference_3_2_1_0()); + + pushFollow(FOLLOW_9); + ruleQualifiedName(); + + state._fsp--; + + + afterParserOrEnumRuleCall(); + + + } + + + } + + + } + break; + + default : + break loop5; + } + } while (true); + + + } + break; + + } + + // InternalProblem.g:291:3: ( (otherlv_7= '{' ( ( (lv_referenceDeclarations_8_0= ruleReferenceDeclaration ) ) (otherlv_9= ';' )? )* otherlv_10= '}' ) | otherlv_11= '.' ) + int alt9=2; + int LA9_0 = input.LA(1); + + if ( (LA9_0==18) ) { + alt9=1; + } + else if ( (LA9_0==13) ) { + alt9=2; + } + else { + NoViableAltException nvae = + new NoViableAltException("", 9, 0, input); + + throw nvae; + } + switch (alt9) { + case 1 : + // InternalProblem.g:292:4: (otherlv_7= '{' ( ( (lv_referenceDeclarations_8_0= ruleReferenceDeclaration ) ) (otherlv_9= ';' )? )* otherlv_10= '}' ) + { + // InternalProblem.g:292:4: (otherlv_7= '{' ( ( (lv_referenceDeclarations_8_0= ruleReferenceDeclaration ) ) (otherlv_9= ';' )? )* otherlv_10= '}' ) + // InternalProblem.g:293:5: otherlv_7= '{' ( ( (lv_referenceDeclarations_8_0= ruleReferenceDeclaration ) ) (otherlv_9= ';' )? )* otherlv_10= '}' + { + otherlv_7=(Token)match(input,18,FOLLOW_10); + + newLeafNode(otherlv_7, grammarAccess.getClassDeclarationAccess().getLeftCurlyBracketKeyword_4_0_0()); + + // InternalProblem.g:297:5: ( ( (lv_referenceDeclarations_8_0= ruleReferenceDeclaration ) ) (otherlv_9= ';' )? )* + loop8: + do { + int alt8=2; + int LA8_0 = input.LA(1); + + if ( (LA8_0==RULE_ID||LA8_0==RULE_QUOTED_ID||(LA8_0>=22 && LA8_0<=23)||(LA8_0>=40 && LA8_0<=41)) ) { + alt8=1; + } + + + switch (alt8) { + case 1 : + // InternalProblem.g:298:6: ( (lv_referenceDeclarations_8_0= ruleReferenceDeclaration ) ) (otherlv_9= ';' )? + { + // InternalProblem.g:298:6: ( (lv_referenceDeclarations_8_0= ruleReferenceDeclaration ) ) + // InternalProblem.g:299:7: (lv_referenceDeclarations_8_0= ruleReferenceDeclaration ) + { + // InternalProblem.g:299:7: (lv_referenceDeclarations_8_0= ruleReferenceDeclaration ) + // InternalProblem.g:300:8: lv_referenceDeclarations_8_0= ruleReferenceDeclaration + { + + newCompositeNode(grammarAccess.getClassDeclarationAccess().getReferenceDeclarationsReferenceDeclarationParserRuleCall_4_0_1_0_0()); + + pushFollow(FOLLOW_11); + lv_referenceDeclarations_8_0=ruleReferenceDeclaration(); + + state._fsp--; + + + if (current==null) { + current = createModelElementForParent(grammarAccess.getClassDeclarationRule()); + } + add( + current, + "referenceDeclarations", + lv_referenceDeclarations_8_0, + "org.eclipse.viatra.solver.language.Problem.ReferenceDeclaration"); + afterParserOrEnumRuleCall(); + + + } + + + } + + // InternalProblem.g:317:6: (otherlv_9= ';' )? + int alt7=2; + int LA7_0 = input.LA(1); + + if ( (LA7_0==19) ) { + alt7=1; + } + switch (alt7) { + case 1 : + // InternalProblem.g:318:7: otherlv_9= ';' + { + otherlv_9=(Token)match(input,19,FOLLOW_10); + + newLeafNode(otherlv_9, grammarAccess.getClassDeclarationAccess().getSemicolonKeyword_4_0_1_1()); + + + } + break; + + } + + + } + break; + + default : + break loop8; + } + } while (true); + + otherlv_10=(Token)match(input,20,FOLLOW_2); + + newLeafNode(otherlv_10, grammarAccess.getClassDeclarationAccess().getRightCurlyBracketKeyword_4_0_2()); + + + } + + + } + break; + case 2 : + // InternalProblem.g:330:4: otherlv_11= '.' + { + otherlv_11=(Token)match(input,13,FOLLOW_2); + + newLeafNode(otherlv_11, grammarAccess.getClassDeclarationAccess().getFullStopKeyword_4_1()); + + + } + break; + + } + + + } + + + } + + + leaveRule(); + + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "ruleClassDeclaration" + + + // $ANTLR start "entryRuleEnumDeclaration" + // InternalProblem.g:339:1: entryRuleEnumDeclaration returns [EObject current=null] : iv_ruleEnumDeclaration= ruleEnumDeclaration EOF ; + public final EObject entryRuleEnumDeclaration() throws RecognitionException { + EObject current = null; + + EObject iv_ruleEnumDeclaration = null; + + + try { + // InternalProblem.g:339:56: (iv_ruleEnumDeclaration= ruleEnumDeclaration EOF ) + // InternalProblem.g:340:2: iv_ruleEnumDeclaration= ruleEnumDeclaration EOF + { + newCompositeNode(grammarAccess.getEnumDeclarationRule()); + pushFollow(FOLLOW_1); + iv_ruleEnumDeclaration=ruleEnumDeclaration(); + + state._fsp--; + + current =iv_ruleEnumDeclaration; + match(input,EOF,FOLLOW_2); + + } + + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "entryRuleEnumDeclaration" + + + // $ANTLR start "ruleEnumDeclaration" + // InternalProblem.g:346:1: ruleEnumDeclaration returns [EObject current=null] : (otherlv_0= 'enum' ( (lv_name_1_0= ruleIdentifier ) ) ( (otherlv_2= '{' ( ( (lv_literals_3_0= ruleEnumLiteral ) ) (otherlv_4= ',' ( (lv_literals_5_0= ruleEnumLiteral ) ) )* (otherlv_6= ',' | otherlv_7= ';' )? )? otherlv_8= '}' ) | otherlv_9= '.' ) ) ; + public final EObject ruleEnumDeclaration() throws RecognitionException { + EObject current = null; + + Token otherlv_0=null; + Token otherlv_2=null; + Token otherlv_4=null; + Token otherlv_6=null; + Token otherlv_7=null; + Token otherlv_8=null; + Token otherlv_9=null; + AntlrDatatypeRuleToken lv_name_1_0 = null; + + EObject lv_literals_3_0 = null; + + EObject lv_literals_5_0 = null; + + + + enterRule(); + + try { + // InternalProblem.g:352:2: ( (otherlv_0= 'enum' ( (lv_name_1_0= ruleIdentifier ) ) ( (otherlv_2= '{' ( ( (lv_literals_3_0= ruleEnumLiteral ) ) (otherlv_4= ',' ( (lv_literals_5_0= ruleEnumLiteral ) ) )* (otherlv_6= ',' | otherlv_7= ';' )? )? otherlv_8= '}' ) | otherlv_9= '.' ) ) ) + // InternalProblem.g:353:2: (otherlv_0= 'enum' ( (lv_name_1_0= ruleIdentifier ) ) ( (otherlv_2= '{' ( ( (lv_literals_3_0= ruleEnumLiteral ) ) (otherlv_4= ',' ( (lv_literals_5_0= ruleEnumLiteral ) ) )* (otherlv_6= ',' | otherlv_7= ';' )? )? otherlv_8= '}' ) | otherlv_9= '.' ) ) + { + // InternalProblem.g:353:2: (otherlv_0= 'enum' ( (lv_name_1_0= ruleIdentifier ) ) ( (otherlv_2= '{' ( ( (lv_literals_3_0= ruleEnumLiteral ) ) (otherlv_4= ',' ( (lv_literals_5_0= ruleEnumLiteral ) ) )* (otherlv_6= ',' | otherlv_7= ';' )? )? otherlv_8= '}' ) | otherlv_9= '.' ) ) + // InternalProblem.g:354:3: otherlv_0= 'enum' ( (lv_name_1_0= ruleIdentifier ) ) ( (otherlv_2= '{' ( ( (lv_literals_3_0= ruleEnumLiteral ) ) (otherlv_4= ',' ( (lv_literals_5_0= ruleEnumLiteral ) ) )* (otherlv_6= ',' | otherlv_7= ';' )? )? otherlv_8= '}' ) | otherlv_9= '.' ) + { + otherlv_0=(Token)match(input,21,FOLLOW_3); + + newLeafNode(otherlv_0, grammarAccess.getEnumDeclarationAccess().getEnumKeyword_0()); + + // InternalProblem.g:358:3: ( (lv_name_1_0= ruleIdentifier ) ) + // InternalProblem.g:359:4: (lv_name_1_0= ruleIdentifier ) + { + // InternalProblem.g:359:4: (lv_name_1_0= ruleIdentifier ) + // InternalProblem.g:360:5: lv_name_1_0= ruleIdentifier + { + + newCompositeNode(grammarAccess.getEnumDeclarationAccess().getNameIdentifierParserRuleCall_1_0()); + + pushFollow(FOLLOW_12); + lv_name_1_0=ruleIdentifier(); + + state._fsp--; + + + if (current==null) { + current = createModelElementForParent(grammarAccess.getEnumDeclarationRule()); + } + set( + current, + "name", + lv_name_1_0, + "org.eclipse.viatra.solver.language.Problem.Identifier"); + afterParserOrEnumRuleCall(); + + + } + + + } + + // InternalProblem.g:377:3: ( (otherlv_2= '{' ( ( (lv_literals_3_0= ruleEnumLiteral ) ) (otherlv_4= ',' ( (lv_literals_5_0= ruleEnumLiteral ) ) )* (otherlv_6= ',' | otherlv_7= ';' )? )? otherlv_8= '}' ) | otherlv_9= '.' ) + int alt13=2; + int LA13_0 = input.LA(1); + + if ( (LA13_0==18) ) { + alt13=1; + } + else if ( (LA13_0==13) ) { + alt13=2; + } + else { + NoViableAltException nvae = + new NoViableAltException("", 13, 0, input); + + throw nvae; + } + switch (alt13) { + case 1 : + // InternalProblem.g:378:4: (otherlv_2= '{' ( ( (lv_literals_3_0= ruleEnumLiteral ) ) (otherlv_4= ',' ( (lv_literals_5_0= ruleEnumLiteral ) ) )* (otherlv_6= ',' | otherlv_7= ';' )? )? otherlv_8= '}' ) + { + // InternalProblem.g:378:4: (otherlv_2= '{' ( ( (lv_literals_3_0= ruleEnumLiteral ) ) (otherlv_4= ',' ( (lv_literals_5_0= ruleEnumLiteral ) ) )* (otherlv_6= ',' | otherlv_7= ';' )? )? otherlv_8= '}' ) + // InternalProblem.g:379:5: otherlv_2= '{' ( ( (lv_literals_3_0= ruleEnumLiteral ) ) (otherlv_4= ',' ( (lv_literals_5_0= ruleEnumLiteral ) ) )* (otherlv_6= ',' | otherlv_7= ';' )? )? otherlv_8= '}' + { + otherlv_2=(Token)match(input,18,FOLLOW_13); + + newLeafNode(otherlv_2, grammarAccess.getEnumDeclarationAccess().getLeftCurlyBracketKeyword_2_0_0()); + + // InternalProblem.g:383:5: ( ( (lv_literals_3_0= ruleEnumLiteral ) ) (otherlv_4= ',' ( (lv_literals_5_0= ruleEnumLiteral ) ) )* (otherlv_6= ',' | otherlv_7= ';' )? )? + int alt12=2; + int LA12_0 = input.LA(1); + + if ( (LA12_0==RULE_ID||LA12_0==RULE_QUOTED_ID||(LA12_0>=40 && LA12_0<=41)) ) { + alt12=1; + } + switch (alt12) { + case 1 : + // InternalProblem.g:384:6: ( (lv_literals_3_0= ruleEnumLiteral ) ) (otherlv_4= ',' ( (lv_literals_5_0= ruleEnumLiteral ) ) )* (otherlv_6= ',' | otherlv_7= ';' )? + { + // InternalProblem.g:384:6: ( (lv_literals_3_0= ruleEnumLiteral ) ) + // InternalProblem.g:385:7: (lv_literals_3_0= ruleEnumLiteral ) + { + // InternalProblem.g:385:7: (lv_literals_3_0= ruleEnumLiteral ) + // InternalProblem.g:386:8: lv_literals_3_0= ruleEnumLiteral + { + + newCompositeNode(grammarAccess.getEnumDeclarationAccess().getLiteralsEnumLiteralParserRuleCall_2_0_1_0_0()); + + pushFollow(FOLLOW_14); + lv_literals_3_0=ruleEnumLiteral(); + + state._fsp--; + + + if (current==null) { + current = createModelElementForParent(grammarAccess.getEnumDeclarationRule()); + } + add( + current, + "literals", + lv_literals_3_0, + "org.eclipse.viatra.solver.language.Problem.EnumLiteral"); + afterParserOrEnumRuleCall(); + + + } + + + } + + // InternalProblem.g:403:6: (otherlv_4= ',' ( (lv_literals_5_0= ruleEnumLiteral ) ) )* + loop10: + do { + int alt10=2; + int LA10_0 = input.LA(1); + + if ( (LA10_0==17) ) { + int LA10_1 = input.LA(2); + + if ( (LA10_1==RULE_ID||LA10_1==RULE_QUOTED_ID||(LA10_1>=40 && LA10_1<=41)) ) { + alt10=1; + } + + + } + + + switch (alt10) { + case 1 : + // InternalProblem.g:404:7: otherlv_4= ',' ( (lv_literals_5_0= ruleEnumLiteral ) ) + { + otherlv_4=(Token)match(input,17,FOLLOW_8); + + newLeafNode(otherlv_4, grammarAccess.getEnumDeclarationAccess().getCommaKeyword_2_0_1_1_0()); + + // InternalProblem.g:408:7: ( (lv_literals_5_0= ruleEnumLiteral ) ) + // InternalProblem.g:409:8: (lv_literals_5_0= ruleEnumLiteral ) + { + // InternalProblem.g:409:8: (lv_literals_5_0= ruleEnumLiteral ) + // InternalProblem.g:410:9: lv_literals_5_0= ruleEnumLiteral + { + + newCompositeNode(grammarAccess.getEnumDeclarationAccess().getLiteralsEnumLiteralParserRuleCall_2_0_1_1_1_0()); + + pushFollow(FOLLOW_14); + lv_literals_5_0=ruleEnumLiteral(); + + state._fsp--; + + + if (current==null) { + current = createModelElementForParent(grammarAccess.getEnumDeclarationRule()); + } + add( + current, + "literals", + lv_literals_5_0, + "org.eclipse.viatra.solver.language.Problem.EnumLiteral"); + afterParserOrEnumRuleCall(); + + + } + + + } + + + } + break; + + default : + break loop10; + } + } while (true); + + // InternalProblem.g:428:6: (otherlv_6= ',' | otherlv_7= ';' )? + int alt11=3; + int LA11_0 = input.LA(1); + + if ( (LA11_0==17) ) { + alt11=1; + } + else if ( (LA11_0==19) ) { + alt11=2; + } + switch (alt11) { + case 1 : + // InternalProblem.g:429:7: otherlv_6= ',' + { + otherlv_6=(Token)match(input,17,FOLLOW_15); + + newLeafNode(otherlv_6, grammarAccess.getEnumDeclarationAccess().getCommaKeyword_2_0_1_2_0()); + + + } + break; + case 2 : + // InternalProblem.g:434:7: otherlv_7= ';' + { + otherlv_7=(Token)match(input,19,FOLLOW_15); + + newLeafNode(otherlv_7, grammarAccess.getEnumDeclarationAccess().getSemicolonKeyword_2_0_1_2_1()); + + + } + break; + + } + + + } + break; + + } + + otherlv_8=(Token)match(input,20,FOLLOW_2); + + newLeafNode(otherlv_8, grammarAccess.getEnumDeclarationAccess().getRightCurlyBracketKeyword_2_0_2()); + + + } + + + } + break; + case 2 : + // InternalProblem.g:446:4: otherlv_9= '.' + { + otherlv_9=(Token)match(input,13,FOLLOW_2); + + newLeafNode(otherlv_9, grammarAccess.getEnumDeclarationAccess().getFullStopKeyword_2_1()); + + + } + break; + + } + + + } + + + } + + + leaveRule(); + + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "ruleEnumDeclaration" + + + // $ANTLR start "entryRuleEnumLiteral" + // InternalProblem.g:455:1: entryRuleEnumLiteral returns [EObject current=null] : iv_ruleEnumLiteral= ruleEnumLiteral EOF ; + public final EObject entryRuleEnumLiteral() throws RecognitionException { + EObject current = null; + + EObject iv_ruleEnumLiteral = null; + + + try { + // InternalProblem.g:455:52: (iv_ruleEnumLiteral= ruleEnumLiteral EOF ) + // InternalProblem.g:456:2: iv_ruleEnumLiteral= ruleEnumLiteral EOF + { + newCompositeNode(grammarAccess.getEnumLiteralRule()); + pushFollow(FOLLOW_1); + iv_ruleEnumLiteral=ruleEnumLiteral(); + + state._fsp--; + + current =iv_ruleEnumLiteral; + match(input,EOF,FOLLOW_2); + + } + + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "entryRuleEnumLiteral" + + + // $ANTLR start "ruleEnumLiteral" + // InternalProblem.g:462:1: ruleEnumLiteral returns [EObject current=null] : ( (lv_name_0_0= ruleQuotedOrUnquotedId ) ) ; + public final EObject ruleEnumLiteral() throws RecognitionException { + EObject current = null; + + AntlrDatatypeRuleToken lv_name_0_0 = null; + + + + enterRule(); + + try { + // InternalProblem.g:468:2: ( ( (lv_name_0_0= ruleQuotedOrUnquotedId ) ) ) + // InternalProblem.g:469:2: ( (lv_name_0_0= ruleQuotedOrUnquotedId ) ) + { + // InternalProblem.g:469:2: ( (lv_name_0_0= ruleQuotedOrUnquotedId ) ) + // InternalProblem.g:470:3: (lv_name_0_0= ruleQuotedOrUnquotedId ) + { + // InternalProblem.g:470:3: (lv_name_0_0= ruleQuotedOrUnquotedId ) + // InternalProblem.g:471:4: lv_name_0_0= ruleQuotedOrUnquotedId + { + + newCompositeNode(grammarAccess.getEnumLiteralAccess().getNameQuotedOrUnquotedIdParserRuleCall_0()); + + pushFollow(FOLLOW_2); + lv_name_0_0=ruleQuotedOrUnquotedId(); + + state._fsp--; + + + if (current==null) { + current = createModelElementForParent(grammarAccess.getEnumLiteralRule()); + } + set( + current, + "name", + lv_name_0_0, + "org.eclipse.viatra.solver.language.Problem.QuotedOrUnquotedId"); + afterParserOrEnumRuleCall(); + + + } + + + } + + + } + + + leaveRule(); + + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "ruleEnumLiteral" + + + // $ANTLR start "entryRuleReferenceDeclaration" + // InternalProblem.g:491:1: entryRuleReferenceDeclaration returns [EObject current=null] : iv_ruleReferenceDeclaration= ruleReferenceDeclaration EOF ; + public final EObject entryRuleReferenceDeclaration() throws RecognitionException { + EObject current = null; + + EObject iv_ruleReferenceDeclaration = null; + + + try { + // InternalProblem.g:491:61: (iv_ruleReferenceDeclaration= ruleReferenceDeclaration EOF ) + // InternalProblem.g:492:2: iv_ruleReferenceDeclaration= ruleReferenceDeclaration EOF + { + newCompositeNode(grammarAccess.getReferenceDeclarationRule()); + pushFollow(FOLLOW_1); + iv_ruleReferenceDeclaration=ruleReferenceDeclaration(); + + state._fsp--; + + current =iv_ruleReferenceDeclaration; + match(input,EOF,FOLLOW_2); + + } + + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "entryRuleReferenceDeclaration" + + + // $ANTLR start "ruleReferenceDeclaration" + // InternalProblem.g:498:1: ruleReferenceDeclaration returns [EObject current=null] : ( ( ( (lv_containment_0_0= 'contains' ) ) | otherlv_1= 'refers' )? ( ( ruleQualifiedName ) ) (otherlv_3= '[' ( (lv_multiplicity_4_0= ruleMultiplicity ) ) otherlv_5= ']' )? ( (lv_name_6_0= ruleIdentifier ) ) (otherlv_7= 'opposite' ( ( ruleQualifiedName ) ) )? ) ; + public final EObject ruleReferenceDeclaration() throws RecognitionException { + EObject current = null; + + Token lv_containment_0_0=null; + Token otherlv_1=null; + Token otherlv_3=null; + Token otherlv_5=null; + Token otherlv_7=null; + EObject lv_multiplicity_4_0 = null; + + AntlrDatatypeRuleToken lv_name_6_0 = null; + + + + enterRule(); + + try { + // InternalProblem.g:504:2: ( ( ( ( (lv_containment_0_0= 'contains' ) ) | otherlv_1= 'refers' )? ( ( ruleQualifiedName ) ) (otherlv_3= '[' ( (lv_multiplicity_4_0= ruleMultiplicity ) ) otherlv_5= ']' )? ( (lv_name_6_0= ruleIdentifier ) ) (otherlv_7= 'opposite' ( ( ruleQualifiedName ) ) )? ) ) + // InternalProblem.g:505:2: ( ( ( (lv_containment_0_0= 'contains' ) ) | otherlv_1= 'refers' )? ( ( ruleQualifiedName ) ) (otherlv_3= '[' ( (lv_multiplicity_4_0= ruleMultiplicity ) ) otherlv_5= ']' )? ( (lv_name_6_0= ruleIdentifier ) ) (otherlv_7= 'opposite' ( ( ruleQualifiedName ) ) )? ) + { + // InternalProblem.g:505:2: ( ( ( (lv_containment_0_0= 'contains' ) ) | otherlv_1= 'refers' )? ( ( ruleQualifiedName ) ) (otherlv_3= '[' ( (lv_multiplicity_4_0= ruleMultiplicity ) ) otherlv_5= ']' )? ( (lv_name_6_0= ruleIdentifier ) ) (otherlv_7= 'opposite' ( ( ruleQualifiedName ) ) )? ) + // InternalProblem.g:506:3: ( ( (lv_containment_0_0= 'contains' ) ) | otherlv_1= 'refers' )? ( ( ruleQualifiedName ) ) (otherlv_3= '[' ( (lv_multiplicity_4_0= ruleMultiplicity ) ) otherlv_5= ']' )? ( (lv_name_6_0= ruleIdentifier ) ) (otherlv_7= 'opposite' ( ( ruleQualifiedName ) ) )? + { + // InternalProblem.g:506:3: ( ( (lv_containment_0_0= 'contains' ) ) | otherlv_1= 'refers' )? + int alt14=3; + int LA14_0 = input.LA(1); + + if ( (LA14_0==22) ) { + alt14=1; + } + else if ( (LA14_0==23) ) { + alt14=2; + } + switch (alt14) { + case 1 : + // InternalProblem.g:507:4: ( (lv_containment_0_0= 'contains' ) ) + { + // InternalProblem.g:507:4: ( (lv_containment_0_0= 'contains' ) ) + // InternalProblem.g:508:5: (lv_containment_0_0= 'contains' ) + { + // InternalProblem.g:508:5: (lv_containment_0_0= 'contains' ) + // InternalProblem.g:509:6: lv_containment_0_0= 'contains' + { + lv_containment_0_0=(Token)match(input,22,FOLLOW_8); + + newLeafNode(lv_containment_0_0, grammarAccess.getReferenceDeclarationAccess().getContainmentContainsKeyword_0_0_0()); + + + if (current==null) { + current = createModelElement(grammarAccess.getReferenceDeclarationRule()); + } + setWithLastConsumed(current, "containment", lv_containment_0_0 != null, "contains"); + + + } + + + } + + + } + break; + case 2 : + // InternalProblem.g:522:4: otherlv_1= 'refers' + { + otherlv_1=(Token)match(input,23,FOLLOW_8); + + newLeafNode(otherlv_1, grammarAccess.getReferenceDeclarationAccess().getRefersKeyword_0_1()); + + + } + break; + + } + + // InternalProblem.g:527:3: ( ( ruleQualifiedName ) ) + // InternalProblem.g:528:4: ( ruleQualifiedName ) + { + // InternalProblem.g:528:4: ( ruleQualifiedName ) + // InternalProblem.g:529:5: ruleQualifiedName + { + + if (current==null) { + current = createModelElement(grammarAccess.getReferenceDeclarationRule()); + } + + + newCompositeNode(grammarAccess.getReferenceDeclarationAccess().getReferenceTypeRelationCrossReference_1_0()); + + pushFollow(FOLLOW_16); + ruleQualifiedName(); + + state._fsp--; + + + afterParserOrEnumRuleCall(); + + + } + + + } + + // InternalProblem.g:543:3: (otherlv_3= '[' ( (lv_multiplicity_4_0= ruleMultiplicity ) ) otherlv_5= ']' )? + int alt15=2; + int LA15_0 = input.LA(1); + + if ( (LA15_0==24) ) { + alt15=1; + } + switch (alt15) { + case 1 : + // InternalProblem.g:544:4: otherlv_3= '[' ( (lv_multiplicity_4_0= ruleMultiplicity ) ) otherlv_5= ']' + { + otherlv_3=(Token)match(input,24,FOLLOW_17); + + newLeafNode(otherlv_3, grammarAccess.getReferenceDeclarationAccess().getLeftSquareBracketKeyword_2_0()); + + // InternalProblem.g:548:4: ( (lv_multiplicity_4_0= ruleMultiplicity ) ) + // InternalProblem.g:549:5: (lv_multiplicity_4_0= ruleMultiplicity ) + { + // InternalProblem.g:549:5: (lv_multiplicity_4_0= ruleMultiplicity ) + // InternalProblem.g:550:6: lv_multiplicity_4_0= ruleMultiplicity + { + + newCompositeNode(grammarAccess.getReferenceDeclarationAccess().getMultiplicityMultiplicityParserRuleCall_2_1_0()); + + pushFollow(FOLLOW_18); + lv_multiplicity_4_0=ruleMultiplicity(); + + state._fsp--; + + + if (current==null) { + current = createModelElementForParent(grammarAccess.getReferenceDeclarationRule()); + } + set( + current, + "multiplicity", + lv_multiplicity_4_0, + "org.eclipse.viatra.solver.language.Problem.Multiplicity"); + afterParserOrEnumRuleCall(); + + + } + + + } + + otherlv_5=(Token)match(input,25,FOLLOW_3); + + newLeafNode(otherlv_5, grammarAccess.getReferenceDeclarationAccess().getRightSquareBracketKeyword_2_2()); + + + } + break; + + } + + // InternalProblem.g:572:3: ( (lv_name_6_0= ruleIdentifier ) ) + // InternalProblem.g:573:4: (lv_name_6_0= ruleIdentifier ) + { + // InternalProblem.g:573:4: (lv_name_6_0= ruleIdentifier ) + // InternalProblem.g:574:5: lv_name_6_0= ruleIdentifier + { + + newCompositeNode(grammarAccess.getReferenceDeclarationAccess().getNameIdentifierParserRuleCall_3_0()); + + pushFollow(FOLLOW_19); + lv_name_6_0=ruleIdentifier(); + + state._fsp--; + + + if (current==null) { + current = createModelElementForParent(grammarAccess.getReferenceDeclarationRule()); + } + set( + current, + "name", + lv_name_6_0, + "org.eclipse.viatra.solver.language.Problem.Identifier"); + afterParserOrEnumRuleCall(); + + + } + + + } + + // InternalProblem.g:591:3: (otherlv_7= 'opposite' ( ( ruleQualifiedName ) ) )? + int alt16=2; + int LA16_0 = input.LA(1); + + if ( (LA16_0==26) ) { + alt16=1; + } + switch (alt16) { + case 1 : + // InternalProblem.g:592:4: otherlv_7= 'opposite' ( ( ruleQualifiedName ) ) + { + otherlv_7=(Token)match(input,26,FOLLOW_8); + + newLeafNode(otherlv_7, grammarAccess.getReferenceDeclarationAccess().getOppositeKeyword_4_0()); + + // InternalProblem.g:596:4: ( ( ruleQualifiedName ) ) + // InternalProblem.g:597:5: ( ruleQualifiedName ) + { + // InternalProblem.g:597:5: ( ruleQualifiedName ) + // InternalProblem.g:598:6: ruleQualifiedName + { + + if (current==null) { + current = createModelElement(grammarAccess.getReferenceDeclarationRule()); + } + + + newCompositeNode(grammarAccess.getReferenceDeclarationAccess().getOppositeReferenceDeclarationCrossReference_4_1_0()); + + pushFollow(FOLLOW_2); + ruleQualifiedName(); + + state._fsp--; + + + afterParserOrEnumRuleCall(); + + + } + + + } + + + } + break; + + } + + + } + + + } + + + leaveRule(); + + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "ruleReferenceDeclaration" + + + // $ANTLR start "entryRulePredicateDefinition" + // InternalProblem.g:617:1: entryRulePredicateDefinition returns [EObject current=null] : iv_rulePredicateDefinition= rulePredicateDefinition EOF ; + public final EObject entryRulePredicateDefinition() throws RecognitionException { + EObject current = null; + + EObject iv_rulePredicateDefinition = null; + + + try { + // InternalProblem.g:617:60: (iv_rulePredicateDefinition= rulePredicateDefinition EOF ) + // InternalProblem.g:618:2: iv_rulePredicateDefinition= rulePredicateDefinition EOF + { + newCompositeNode(grammarAccess.getPredicateDefinitionRule()); + pushFollow(FOLLOW_1); + iv_rulePredicateDefinition=rulePredicateDefinition(); + + state._fsp--; + + current =iv_rulePredicateDefinition; + match(input,EOF,FOLLOW_2); + + } + + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "entryRulePredicateDefinition" + + + // $ANTLR start "rulePredicateDefinition" + // InternalProblem.g:624:1: rulePredicateDefinition returns [EObject current=null] : ( ( ( ( (lv_error_0_0= 'error' ) ) (otherlv_1= 'pred' )? ) | otherlv_2= 'pred' ) ( (lv_name_3_0= ruleIdentifier ) ) otherlv_4= '(' ( ( (lv_parameters_5_0= ruleParameter ) ) (otherlv_6= ',' ( (lv_parameters_7_0= ruleParameter ) ) )* )? otherlv_8= ')' (otherlv_9= ':-' ( (lv_bodies_10_0= ruleConjunction ) ) (otherlv_11= ';' ( (lv_bodies_12_0= ruleConjunction ) ) )* )? otherlv_13= '.' ) ; + public final EObject rulePredicateDefinition() throws RecognitionException { + EObject current = null; + + Token lv_error_0_0=null; + Token otherlv_1=null; + Token otherlv_2=null; + Token otherlv_4=null; + Token otherlv_6=null; + Token otherlv_8=null; + Token otherlv_9=null; + Token otherlv_11=null; + Token otherlv_13=null; + AntlrDatatypeRuleToken lv_name_3_0 = null; + + EObject lv_parameters_5_0 = null; + + EObject lv_parameters_7_0 = null; + + EObject lv_bodies_10_0 = null; + + EObject lv_bodies_12_0 = null; + + + + enterRule(); + + try { + // InternalProblem.g:630:2: ( ( ( ( ( (lv_error_0_0= 'error' ) ) (otherlv_1= 'pred' )? ) | otherlv_2= 'pred' ) ( (lv_name_3_0= ruleIdentifier ) ) otherlv_4= '(' ( ( (lv_parameters_5_0= ruleParameter ) ) (otherlv_6= ',' ( (lv_parameters_7_0= ruleParameter ) ) )* )? otherlv_8= ')' (otherlv_9= ':-' ( (lv_bodies_10_0= ruleConjunction ) ) (otherlv_11= ';' ( (lv_bodies_12_0= ruleConjunction ) ) )* )? otherlv_13= '.' ) ) + // InternalProblem.g:631:2: ( ( ( ( (lv_error_0_0= 'error' ) ) (otherlv_1= 'pred' )? ) | otherlv_2= 'pred' ) ( (lv_name_3_0= ruleIdentifier ) ) otherlv_4= '(' ( ( (lv_parameters_5_0= ruleParameter ) ) (otherlv_6= ',' ( (lv_parameters_7_0= ruleParameter ) ) )* )? otherlv_8= ')' (otherlv_9= ':-' ( (lv_bodies_10_0= ruleConjunction ) ) (otherlv_11= ';' ( (lv_bodies_12_0= ruleConjunction ) ) )* )? otherlv_13= '.' ) + { + // InternalProblem.g:631:2: ( ( ( ( (lv_error_0_0= 'error' ) ) (otherlv_1= 'pred' )? ) | otherlv_2= 'pred' ) ( (lv_name_3_0= ruleIdentifier ) ) otherlv_4= '(' ( ( (lv_parameters_5_0= ruleParameter ) ) (otherlv_6= ',' ( (lv_parameters_7_0= ruleParameter ) ) )* )? otherlv_8= ')' (otherlv_9= ':-' ( (lv_bodies_10_0= ruleConjunction ) ) (otherlv_11= ';' ( (lv_bodies_12_0= ruleConjunction ) ) )* )? otherlv_13= '.' ) + // InternalProblem.g:632:3: ( ( ( (lv_error_0_0= 'error' ) ) (otherlv_1= 'pred' )? ) | otherlv_2= 'pred' ) ( (lv_name_3_0= ruleIdentifier ) ) otherlv_4= '(' ( ( (lv_parameters_5_0= ruleParameter ) ) (otherlv_6= ',' ( (lv_parameters_7_0= ruleParameter ) ) )* )? otherlv_8= ')' (otherlv_9= ':-' ( (lv_bodies_10_0= ruleConjunction ) ) (otherlv_11= ';' ( (lv_bodies_12_0= ruleConjunction ) ) )* )? otherlv_13= '.' + { + // InternalProblem.g:632:3: ( ( ( (lv_error_0_0= 'error' ) ) (otherlv_1= 'pred' )? ) | otherlv_2= 'pred' ) + int alt18=2; + int LA18_0 = input.LA(1); + + if ( (LA18_0==27) ) { + alt18=1; + } + else if ( (LA18_0==28) ) { + alt18=2; + } + else { + NoViableAltException nvae = + new NoViableAltException("", 18, 0, input); + + throw nvae; + } + switch (alt18) { + case 1 : + // InternalProblem.g:633:4: ( ( (lv_error_0_0= 'error' ) ) (otherlv_1= 'pred' )? ) + { + // InternalProblem.g:633:4: ( ( (lv_error_0_0= 'error' ) ) (otherlv_1= 'pred' )? ) + // InternalProblem.g:634:5: ( (lv_error_0_0= 'error' ) ) (otherlv_1= 'pred' )? + { + // InternalProblem.g:634:5: ( (lv_error_0_0= 'error' ) ) + // InternalProblem.g:635:6: (lv_error_0_0= 'error' ) + { + // InternalProblem.g:635:6: (lv_error_0_0= 'error' ) + // InternalProblem.g:636:7: lv_error_0_0= 'error' + { + lv_error_0_0=(Token)match(input,27,FOLLOW_20); + + newLeafNode(lv_error_0_0, grammarAccess.getPredicateDefinitionAccess().getErrorErrorKeyword_0_0_0_0()); + + + if (current==null) { + current = createModelElement(grammarAccess.getPredicateDefinitionRule()); + } + setWithLastConsumed(current, "error", lv_error_0_0 != null, "error"); + + + } + + + } + + // InternalProblem.g:648:5: (otherlv_1= 'pred' )? + int alt17=2; + int LA17_0 = input.LA(1); + + if ( (LA17_0==28) ) { + alt17=1; + } + switch (alt17) { + case 1 : + // InternalProblem.g:649:6: otherlv_1= 'pred' + { + otherlv_1=(Token)match(input,28,FOLLOW_3); + + newLeafNode(otherlv_1, grammarAccess.getPredicateDefinitionAccess().getPredKeyword_0_0_1()); + + + } + break; + + } + + + } + + + } + break; + case 2 : + // InternalProblem.g:656:4: otherlv_2= 'pred' + { + otherlv_2=(Token)match(input,28,FOLLOW_3); + + newLeafNode(otherlv_2, grammarAccess.getPredicateDefinitionAccess().getPredKeyword_0_1()); + + + } + break; + + } + + // InternalProblem.g:661:3: ( (lv_name_3_0= ruleIdentifier ) ) + // InternalProblem.g:662:4: (lv_name_3_0= ruleIdentifier ) + { + // InternalProblem.g:662:4: (lv_name_3_0= ruleIdentifier ) + // InternalProblem.g:663:5: lv_name_3_0= ruleIdentifier + { + + newCompositeNode(grammarAccess.getPredicateDefinitionAccess().getNameIdentifierParserRuleCall_1_0()); + + pushFollow(FOLLOW_21); + lv_name_3_0=ruleIdentifier(); + + state._fsp--; + + + if (current==null) { + current = createModelElementForParent(grammarAccess.getPredicateDefinitionRule()); + } + set( + current, + "name", + lv_name_3_0, + "org.eclipse.viatra.solver.language.Problem.Identifier"); + afterParserOrEnumRuleCall(); + + + } + + + } + + otherlv_4=(Token)match(input,29,FOLLOW_22); + + newLeafNode(otherlv_4, grammarAccess.getPredicateDefinitionAccess().getLeftParenthesisKeyword_2()); + + // InternalProblem.g:684:3: ( ( (lv_parameters_5_0= ruleParameter ) ) (otherlv_6= ',' ( (lv_parameters_7_0= ruleParameter ) ) )* )? + int alt20=2; + int LA20_0 = input.LA(1); + + if ( (LA20_0==RULE_ID||LA20_0==RULE_QUOTED_ID||(LA20_0>=40 && LA20_0<=41)) ) { + alt20=1; + } + switch (alt20) { + case 1 : + // InternalProblem.g:685:4: ( (lv_parameters_5_0= ruleParameter ) ) (otherlv_6= ',' ( (lv_parameters_7_0= ruleParameter ) ) )* + { + // InternalProblem.g:685:4: ( (lv_parameters_5_0= ruleParameter ) ) + // InternalProblem.g:686:5: (lv_parameters_5_0= ruleParameter ) + { + // InternalProblem.g:686:5: (lv_parameters_5_0= ruleParameter ) + // InternalProblem.g:687:6: lv_parameters_5_0= ruleParameter + { + + newCompositeNode(grammarAccess.getPredicateDefinitionAccess().getParametersParameterParserRuleCall_3_0_0()); + + pushFollow(FOLLOW_23); + lv_parameters_5_0=ruleParameter(); + + state._fsp--; + + + if (current==null) { + current = createModelElementForParent(grammarAccess.getPredicateDefinitionRule()); + } + add( + current, + "parameters", + lv_parameters_5_0, + "org.eclipse.viatra.solver.language.Problem.Parameter"); + afterParserOrEnumRuleCall(); + + + } + + + } + + // InternalProblem.g:704:4: (otherlv_6= ',' ( (lv_parameters_7_0= ruleParameter ) ) )* + loop19: + do { + int alt19=2; + int LA19_0 = input.LA(1); + + if ( (LA19_0==17) ) { + alt19=1; + } + + + switch (alt19) { + case 1 : + // InternalProblem.g:705:5: otherlv_6= ',' ( (lv_parameters_7_0= ruleParameter ) ) + { + otherlv_6=(Token)match(input,17,FOLLOW_8); + + newLeafNode(otherlv_6, grammarAccess.getPredicateDefinitionAccess().getCommaKeyword_3_1_0()); + + // InternalProblem.g:709:5: ( (lv_parameters_7_0= ruleParameter ) ) + // InternalProblem.g:710:6: (lv_parameters_7_0= ruleParameter ) + { + // InternalProblem.g:710:6: (lv_parameters_7_0= ruleParameter ) + // InternalProblem.g:711:7: lv_parameters_7_0= ruleParameter + { + + newCompositeNode(grammarAccess.getPredicateDefinitionAccess().getParametersParameterParserRuleCall_3_1_1_0()); + + pushFollow(FOLLOW_23); + lv_parameters_7_0=ruleParameter(); + + state._fsp--; + + + if (current==null) { + current = createModelElementForParent(grammarAccess.getPredicateDefinitionRule()); + } + add( + current, + "parameters", + lv_parameters_7_0, + "org.eclipse.viatra.solver.language.Problem.Parameter"); + afterParserOrEnumRuleCall(); + + + } + + + } + + + } + break; + + default : + break loop19; + } + } while (true); + + + } + break; + + } + + otherlv_8=(Token)match(input,30,FOLLOW_24); + + newLeafNode(otherlv_8, grammarAccess.getPredicateDefinitionAccess().getRightParenthesisKeyword_4()); + + // InternalProblem.g:734:3: (otherlv_9= ':-' ( (lv_bodies_10_0= ruleConjunction ) ) (otherlv_11= ';' ( (lv_bodies_12_0= ruleConjunction ) ) )* )? + int alt22=2; + int LA22_0 = input.LA(1); + + if ( (LA22_0==31) ) { + alt22=1; + } + switch (alt22) { + case 1 : + // InternalProblem.g:735:4: otherlv_9= ':-' ( (lv_bodies_10_0= ruleConjunction ) ) (otherlv_11= ';' ( (lv_bodies_12_0= ruleConjunction ) ) )* + { + otherlv_9=(Token)match(input,31,FOLLOW_25); + + newLeafNode(otherlv_9, grammarAccess.getPredicateDefinitionAccess().getColonHyphenMinusKeyword_5_0()); + + // InternalProblem.g:739:4: ( (lv_bodies_10_0= ruleConjunction ) ) + // InternalProblem.g:740:5: (lv_bodies_10_0= ruleConjunction ) + { + // InternalProblem.g:740:5: (lv_bodies_10_0= ruleConjunction ) + // InternalProblem.g:741:6: lv_bodies_10_0= ruleConjunction + { + + newCompositeNode(grammarAccess.getPredicateDefinitionAccess().getBodiesConjunctionParserRuleCall_5_1_0()); + + pushFollow(FOLLOW_26); + lv_bodies_10_0=ruleConjunction(); + + state._fsp--; + + + if (current==null) { + current = createModelElementForParent(grammarAccess.getPredicateDefinitionRule()); + } + add( + current, + "bodies", + lv_bodies_10_0, + "org.eclipse.viatra.solver.language.Problem.Conjunction"); + afterParserOrEnumRuleCall(); + + + } + + + } + + // InternalProblem.g:758:4: (otherlv_11= ';' ( (lv_bodies_12_0= ruleConjunction ) ) )* + loop21: + do { + int alt21=2; + int LA21_0 = input.LA(1); + + if ( (LA21_0==19) ) { + alt21=1; + } + + + switch (alt21) { + case 1 : + // InternalProblem.g:759:5: otherlv_11= ';' ( (lv_bodies_12_0= ruleConjunction ) ) + { + otherlv_11=(Token)match(input,19,FOLLOW_25); + + newLeafNode(otherlv_11, grammarAccess.getPredicateDefinitionAccess().getSemicolonKeyword_5_2_0()); + + // InternalProblem.g:763:5: ( (lv_bodies_12_0= ruleConjunction ) ) + // InternalProblem.g:764:6: (lv_bodies_12_0= ruleConjunction ) + { + // InternalProblem.g:764:6: (lv_bodies_12_0= ruleConjunction ) + // InternalProblem.g:765:7: lv_bodies_12_0= ruleConjunction + { + + newCompositeNode(grammarAccess.getPredicateDefinitionAccess().getBodiesConjunctionParserRuleCall_5_2_1_0()); + + pushFollow(FOLLOW_26); + lv_bodies_12_0=ruleConjunction(); + + state._fsp--; + + + if (current==null) { + current = createModelElementForParent(grammarAccess.getPredicateDefinitionRule()); + } + add( + current, + "bodies", + lv_bodies_12_0, + "org.eclipse.viatra.solver.language.Problem.Conjunction"); + afterParserOrEnumRuleCall(); + + + } + + + } + + + } + break; + + default : + break loop21; + } + } while (true); + + + } + break; + + } + + otherlv_13=(Token)match(input,13,FOLLOW_2); + + newLeafNode(otherlv_13, grammarAccess.getPredicateDefinitionAccess().getFullStopKeyword_6()); + + + } + + + } + + + leaveRule(); + + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "rulePredicateDefinition" + + + // $ANTLR start "entryRuleParameter" + // InternalProblem.g:792:1: entryRuleParameter returns [EObject current=null] : iv_ruleParameter= ruleParameter EOF ; + public final EObject entryRuleParameter() throws RecognitionException { + EObject current = null; + + EObject iv_ruleParameter = null; + + + try { + // InternalProblem.g:792:50: (iv_ruleParameter= ruleParameter EOF ) + // InternalProblem.g:793:2: iv_ruleParameter= ruleParameter EOF + { + newCompositeNode(grammarAccess.getParameterRule()); + pushFollow(FOLLOW_1); + iv_ruleParameter=ruleParameter(); + + state._fsp--; + + current =iv_ruleParameter; + match(input,EOF,FOLLOW_2); + + } + + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "entryRuleParameter" + + + // $ANTLR start "ruleParameter" + // InternalProblem.g:799:1: ruleParameter returns [EObject current=null] : ( ( ( ruleQualifiedName ) )? ( (lv_name_1_0= ruleIdentifier ) ) ) ; + public final EObject ruleParameter() throws RecognitionException { + EObject current = null; + + AntlrDatatypeRuleToken lv_name_1_0 = null; + + + + enterRule(); + + try { + // InternalProblem.g:805:2: ( ( ( ( ruleQualifiedName ) )? ( (lv_name_1_0= ruleIdentifier ) ) ) ) + // InternalProblem.g:806:2: ( ( ( ruleQualifiedName ) )? ( (lv_name_1_0= ruleIdentifier ) ) ) + { + // InternalProblem.g:806:2: ( ( ( ruleQualifiedName ) )? ( (lv_name_1_0= ruleIdentifier ) ) ) + // InternalProblem.g:807:3: ( ( ruleQualifiedName ) )? ( (lv_name_1_0= ruleIdentifier ) ) + { + // InternalProblem.g:807:3: ( ( ruleQualifiedName ) )? + int alt23=2; + switch ( input.LA(1) ) { + case RULE_QUOTED_ID: + { + alt23=1; + } + break; + case RULE_ID: + { + int LA23_2 = input.LA(2); + + if ( (LA23_2==RULE_ID||LA23_2==34||(LA23_2>=40 && LA23_2<=41)) ) { + alt23=1; + } + } + break; + case 40: + { + int LA23_3 = input.LA(2); + + if ( (LA23_3==RULE_ID||LA23_3==34||(LA23_3>=40 && LA23_3<=41)) ) { + alt23=1; + } + } + break; + case 41: + { + int LA23_4 = input.LA(2); + + if ( (LA23_4==RULE_ID||LA23_4==34||(LA23_4>=40 && LA23_4<=41)) ) { + alt23=1; + } + } + break; + } + + switch (alt23) { + case 1 : + // InternalProblem.g:808:4: ( ruleQualifiedName ) + { + // InternalProblem.g:808:4: ( ruleQualifiedName ) + // InternalProblem.g:809:5: ruleQualifiedName + { + + if (current==null) { + current = createModelElement(grammarAccess.getParameterRule()); + } + + + newCompositeNode(grammarAccess.getParameterAccess().getParameterTypeRelationCrossReference_0_0()); + + pushFollow(FOLLOW_3); + ruleQualifiedName(); + + state._fsp--; + + + afterParserOrEnumRuleCall(); + + + } + + + } + break; + + } + + // InternalProblem.g:823:3: ( (lv_name_1_0= ruleIdentifier ) ) + // InternalProblem.g:824:4: (lv_name_1_0= ruleIdentifier ) + { + // InternalProblem.g:824:4: (lv_name_1_0= ruleIdentifier ) + // InternalProblem.g:825:5: lv_name_1_0= ruleIdentifier + { + + newCompositeNode(grammarAccess.getParameterAccess().getNameIdentifierParserRuleCall_1_0()); + + pushFollow(FOLLOW_2); + lv_name_1_0=ruleIdentifier(); + + state._fsp--; + + + if (current==null) { + current = createModelElementForParent(grammarAccess.getParameterRule()); + } + set( + current, + "name", + lv_name_1_0, + "org.eclipse.viatra.solver.language.Problem.Identifier"); + afterParserOrEnumRuleCall(); + + + } + + + } + + + } + + + } + + + leaveRule(); + + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "ruleParameter" + + + // $ANTLR start "entryRuleConjunction" + // InternalProblem.g:846:1: entryRuleConjunction returns [EObject current=null] : iv_ruleConjunction= ruleConjunction EOF ; + public final EObject entryRuleConjunction() throws RecognitionException { + EObject current = null; + + EObject iv_ruleConjunction = null; + + + try { + // InternalProblem.g:846:52: (iv_ruleConjunction= ruleConjunction EOF ) + // InternalProblem.g:847:2: iv_ruleConjunction= ruleConjunction EOF + { + newCompositeNode(grammarAccess.getConjunctionRule()); + pushFollow(FOLLOW_1); + iv_ruleConjunction=ruleConjunction(); + + state._fsp--; + + current =iv_ruleConjunction; + match(input,EOF,FOLLOW_2); + + } + + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "entryRuleConjunction" + + + // $ANTLR start "ruleConjunction" + // InternalProblem.g:853:1: ruleConjunction returns [EObject current=null] : ( ( (lv_literals_0_0= ruleLiteral ) ) (otherlv_1= ',' ( (lv_literals_2_0= ruleLiteral ) ) )* ) ; + public final EObject ruleConjunction() throws RecognitionException { + EObject current = null; + + Token otherlv_1=null; + EObject lv_literals_0_0 = null; + + EObject lv_literals_2_0 = null; + + + + enterRule(); + + try { + // InternalProblem.g:859:2: ( ( ( (lv_literals_0_0= ruleLiteral ) ) (otherlv_1= ',' ( (lv_literals_2_0= ruleLiteral ) ) )* ) ) + // InternalProblem.g:860:2: ( ( (lv_literals_0_0= ruleLiteral ) ) (otherlv_1= ',' ( (lv_literals_2_0= ruleLiteral ) ) )* ) + { + // InternalProblem.g:860:2: ( ( (lv_literals_0_0= ruleLiteral ) ) (otherlv_1= ',' ( (lv_literals_2_0= ruleLiteral ) ) )* ) + // InternalProblem.g:861:3: ( (lv_literals_0_0= ruleLiteral ) ) (otherlv_1= ',' ( (lv_literals_2_0= ruleLiteral ) ) )* + { + // InternalProblem.g:861:3: ( (lv_literals_0_0= ruleLiteral ) ) + // InternalProblem.g:862:4: (lv_literals_0_0= ruleLiteral ) + { + // InternalProblem.g:862:4: (lv_literals_0_0= ruleLiteral ) + // InternalProblem.g:863:5: lv_literals_0_0= ruleLiteral + { + + newCompositeNode(grammarAccess.getConjunctionAccess().getLiteralsLiteralParserRuleCall_0_0()); + + pushFollow(FOLLOW_27); + lv_literals_0_0=ruleLiteral(); + + state._fsp--; + + + if (current==null) { + current = createModelElementForParent(grammarAccess.getConjunctionRule()); + } + add( + current, + "literals", + lv_literals_0_0, + "org.eclipse.viatra.solver.language.Problem.Literal"); + afterParserOrEnumRuleCall(); + + + } + + + } + + // InternalProblem.g:880:3: (otherlv_1= ',' ( (lv_literals_2_0= ruleLiteral ) ) )* + loop24: + do { + int alt24=2; + int LA24_0 = input.LA(1); + + if ( (LA24_0==17) ) { + alt24=1; + } + + + switch (alt24) { + case 1 : + // InternalProblem.g:881:4: otherlv_1= ',' ( (lv_literals_2_0= ruleLiteral ) ) + { + otherlv_1=(Token)match(input,17,FOLLOW_25); + + newLeafNode(otherlv_1, grammarAccess.getConjunctionAccess().getCommaKeyword_1_0()); + + // InternalProblem.g:885:4: ( (lv_literals_2_0= ruleLiteral ) ) + // InternalProblem.g:886:5: (lv_literals_2_0= ruleLiteral ) + { + // InternalProblem.g:886:5: (lv_literals_2_0= ruleLiteral ) + // InternalProblem.g:887:6: lv_literals_2_0= ruleLiteral + { + + newCompositeNode(grammarAccess.getConjunctionAccess().getLiteralsLiteralParserRuleCall_1_1_0()); + + pushFollow(FOLLOW_27); + lv_literals_2_0=ruleLiteral(); + + state._fsp--; + + + if (current==null) { + current = createModelElementForParent(grammarAccess.getConjunctionRule()); + } + add( + current, + "literals", + lv_literals_2_0, + "org.eclipse.viatra.solver.language.Problem.Literal"); + afterParserOrEnumRuleCall(); + + + } + + + } + + + } + break; + + default : + break loop24; + } + } while (true); + + + } + + + } + + + leaveRule(); + + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "ruleConjunction" + + + // $ANTLR start "entryRuleLiteral" + // InternalProblem.g:909:1: entryRuleLiteral returns [EObject current=null] : iv_ruleLiteral= ruleLiteral EOF ; + public final EObject entryRuleLiteral() throws RecognitionException { + EObject current = null; + + EObject iv_ruleLiteral = null; + + + try { + // InternalProblem.g:909:48: (iv_ruleLiteral= ruleLiteral EOF ) + // InternalProblem.g:910:2: iv_ruleLiteral= ruleLiteral EOF + { + newCompositeNode(grammarAccess.getLiteralRule()); + pushFollow(FOLLOW_1); + iv_ruleLiteral=ruleLiteral(); + + state._fsp--; + + current =iv_ruleLiteral; + match(input,EOF,FOLLOW_2); + + } + + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "entryRuleLiteral" + + + // $ANTLR start "ruleLiteral" + // InternalProblem.g:916:1: ruleLiteral returns [EObject current=null] : (this_Atom_0= ruleAtom | this_NegativeLiteral_1= ruleNegativeLiteral ) ; + public final EObject ruleLiteral() throws RecognitionException { + EObject current = null; + + EObject this_Atom_0 = null; + + EObject this_NegativeLiteral_1 = null; + + + + enterRule(); + + try { + // InternalProblem.g:922:2: ( (this_Atom_0= ruleAtom | this_NegativeLiteral_1= ruleNegativeLiteral ) ) + // InternalProblem.g:923:2: (this_Atom_0= ruleAtom | this_NegativeLiteral_1= ruleNegativeLiteral ) + { + // InternalProblem.g:923:2: (this_Atom_0= ruleAtom | this_NegativeLiteral_1= ruleNegativeLiteral ) + int alt25=2; + int LA25_0 = input.LA(1); + + if ( (LA25_0==RULE_ID||LA25_0==RULE_QUOTED_ID||(LA25_0>=40 && LA25_0<=41)) ) { + alt25=1; + } + else if ( (LA25_0==32) ) { + alt25=2; + } + else { + NoViableAltException nvae = + new NoViableAltException("", 25, 0, input); + + throw nvae; + } + switch (alt25) { + case 1 : + // InternalProblem.g:924:3: this_Atom_0= ruleAtom + { + + newCompositeNode(grammarAccess.getLiteralAccess().getAtomParserRuleCall_0()); + + pushFollow(FOLLOW_2); + this_Atom_0=ruleAtom(); + + state._fsp--; + + + current = this_Atom_0; + afterParserOrEnumRuleCall(); + + + } + break; + case 2 : + // InternalProblem.g:933:3: this_NegativeLiteral_1= ruleNegativeLiteral + { + + newCompositeNode(grammarAccess.getLiteralAccess().getNegativeLiteralParserRuleCall_1()); + + pushFollow(FOLLOW_2); + this_NegativeLiteral_1=ruleNegativeLiteral(); + + state._fsp--; + + + current = this_NegativeLiteral_1; + afterParserOrEnumRuleCall(); + + + } + break; + + } + + + } + + + leaveRule(); + + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "ruleLiteral" + + + // $ANTLR start "entryRuleNegativeLiteral" + // InternalProblem.g:945:1: entryRuleNegativeLiteral returns [EObject current=null] : iv_ruleNegativeLiteral= ruleNegativeLiteral EOF ; + public final EObject entryRuleNegativeLiteral() throws RecognitionException { + EObject current = null; + + EObject iv_ruleNegativeLiteral = null; + + + try { + // InternalProblem.g:945:56: (iv_ruleNegativeLiteral= ruleNegativeLiteral EOF ) + // InternalProblem.g:946:2: iv_ruleNegativeLiteral= ruleNegativeLiteral EOF + { + newCompositeNode(grammarAccess.getNegativeLiteralRule()); + pushFollow(FOLLOW_1); + iv_ruleNegativeLiteral=ruleNegativeLiteral(); + + state._fsp--; + + current =iv_ruleNegativeLiteral; + match(input,EOF,FOLLOW_2); + + } + + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "entryRuleNegativeLiteral" + + + // $ANTLR start "ruleNegativeLiteral" + // InternalProblem.g:952:1: ruleNegativeLiteral returns [EObject current=null] : (otherlv_0= '!' ( (lv_atom_1_0= ruleAtom ) ) ) ; + public final EObject ruleNegativeLiteral() throws RecognitionException { + EObject current = null; + + Token otherlv_0=null; + EObject lv_atom_1_0 = null; + + + + enterRule(); + + try { + // InternalProblem.g:958:2: ( (otherlv_0= '!' ( (lv_atom_1_0= ruleAtom ) ) ) ) + // InternalProblem.g:959:2: (otherlv_0= '!' ( (lv_atom_1_0= ruleAtom ) ) ) + { + // InternalProblem.g:959:2: (otherlv_0= '!' ( (lv_atom_1_0= ruleAtom ) ) ) + // InternalProblem.g:960:3: otherlv_0= '!' ( (lv_atom_1_0= ruleAtom ) ) + { + otherlv_0=(Token)match(input,32,FOLLOW_8); + + newLeafNode(otherlv_0, grammarAccess.getNegativeLiteralAccess().getExclamationMarkKeyword_0()); + + // InternalProblem.g:964:3: ( (lv_atom_1_0= ruleAtom ) ) + // InternalProblem.g:965:4: (lv_atom_1_0= ruleAtom ) + { + // InternalProblem.g:965:4: (lv_atom_1_0= ruleAtom ) + // InternalProblem.g:966:5: lv_atom_1_0= ruleAtom + { + + newCompositeNode(grammarAccess.getNegativeLiteralAccess().getAtomAtomParserRuleCall_1_0()); + + pushFollow(FOLLOW_2); + lv_atom_1_0=ruleAtom(); + + state._fsp--; + + + if (current==null) { + current = createModelElementForParent(grammarAccess.getNegativeLiteralRule()); + } + set( + current, + "atom", + lv_atom_1_0, + "org.eclipse.viatra.solver.language.Problem.Atom"); + afterParserOrEnumRuleCall(); + + + } + + + } + + + } + + + } + + + leaveRule(); + + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "ruleNegativeLiteral" + + + // $ANTLR start "entryRuleAtom" + // InternalProblem.g:987:1: entryRuleAtom returns [EObject current=null] : iv_ruleAtom= ruleAtom EOF ; + public final EObject entryRuleAtom() throws RecognitionException { + EObject current = null; + + EObject iv_ruleAtom = null; + + + try { + // InternalProblem.g:987:45: (iv_ruleAtom= ruleAtom EOF ) + // InternalProblem.g:988:2: iv_ruleAtom= ruleAtom EOF + { + newCompositeNode(grammarAccess.getAtomRule()); + pushFollow(FOLLOW_1); + iv_ruleAtom=ruleAtom(); + + state._fsp--; + + current =iv_ruleAtom; + match(input,EOF,FOLLOW_2); + + } + + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "entryRuleAtom" + + + // $ANTLR start "ruleAtom" + // InternalProblem.g:994:1: ruleAtom returns [EObject current=null] : ( ( ( ruleQualifiedName ) ) ( (lv_transitiveClosure_1_0= '+' ) )? otherlv_2= '(' ( ( (lv_arguments_3_0= ruleArgument ) ) (otherlv_4= ',' ( (lv_arguments_5_0= ruleArgument ) ) )* )? otherlv_6= ')' ) ; + public final EObject ruleAtom() throws RecognitionException { + EObject current = null; + + Token lv_transitiveClosure_1_0=null; + Token otherlv_2=null; + Token otherlv_4=null; + Token otherlv_6=null; + EObject lv_arguments_3_0 = null; + + EObject lv_arguments_5_0 = null; + + + + enterRule(); + + try { + // InternalProblem.g:1000:2: ( ( ( ( ruleQualifiedName ) ) ( (lv_transitiveClosure_1_0= '+' ) )? otherlv_2= '(' ( ( (lv_arguments_3_0= ruleArgument ) ) (otherlv_4= ',' ( (lv_arguments_5_0= ruleArgument ) ) )* )? otherlv_6= ')' ) ) + // InternalProblem.g:1001:2: ( ( ( ruleQualifiedName ) ) ( (lv_transitiveClosure_1_0= '+' ) )? otherlv_2= '(' ( ( (lv_arguments_3_0= ruleArgument ) ) (otherlv_4= ',' ( (lv_arguments_5_0= ruleArgument ) ) )* )? otherlv_6= ')' ) + { + // InternalProblem.g:1001:2: ( ( ( ruleQualifiedName ) ) ( (lv_transitiveClosure_1_0= '+' ) )? otherlv_2= '(' ( ( (lv_arguments_3_0= ruleArgument ) ) (otherlv_4= ',' ( (lv_arguments_5_0= ruleArgument ) ) )* )? otherlv_6= ')' ) + // InternalProblem.g:1002:3: ( ( ruleQualifiedName ) ) ( (lv_transitiveClosure_1_0= '+' ) )? otherlv_2= '(' ( ( (lv_arguments_3_0= ruleArgument ) ) (otherlv_4= ',' ( (lv_arguments_5_0= ruleArgument ) ) )* )? otherlv_6= ')' + { + // InternalProblem.g:1002:3: ( ( ruleQualifiedName ) ) + // InternalProblem.g:1003:4: ( ruleQualifiedName ) + { + // InternalProblem.g:1003:4: ( ruleQualifiedName ) + // InternalProblem.g:1004:5: ruleQualifiedName + { + + if (current==null) { + current = createModelElement(grammarAccess.getAtomRule()); + } + + + newCompositeNode(grammarAccess.getAtomAccess().getRelationRelationCrossReference_0_0()); + + pushFollow(FOLLOW_28); + ruleQualifiedName(); + + state._fsp--; + + + afterParserOrEnumRuleCall(); + + + } + + + } + + // InternalProblem.g:1018:3: ( (lv_transitiveClosure_1_0= '+' ) )? + int alt26=2; + int LA26_0 = input.LA(1); + + if ( (LA26_0==33) ) { + alt26=1; + } + switch (alt26) { + case 1 : + // InternalProblem.g:1019:4: (lv_transitiveClosure_1_0= '+' ) + { + // InternalProblem.g:1019:4: (lv_transitiveClosure_1_0= '+' ) + // InternalProblem.g:1020:5: lv_transitiveClosure_1_0= '+' + { + lv_transitiveClosure_1_0=(Token)match(input,33,FOLLOW_21); + + newLeafNode(lv_transitiveClosure_1_0, grammarAccess.getAtomAccess().getTransitiveClosurePlusSignKeyword_1_0()); + + + if (current==null) { + current = createModelElement(grammarAccess.getAtomRule()); + } + setWithLastConsumed(current, "transitiveClosure", lv_transitiveClosure_1_0 != null, "+"); + + + } + + + } + break; + + } + + otherlv_2=(Token)match(input,29,FOLLOW_22); + + newLeafNode(otherlv_2, grammarAccess.getAtomAccess().getLeftParenthesisKeyword_2()); + + // InternalProblem.g:1036:3: ( ( (lv_arguments_3_0= ruleArgument ) ) (otherlv_4= ',' ( (lv_arguments_5_0= ruleArgument ) ) )* )? + int alt28=2; + int LA28_0 = input.LA(1); + + if ( (LA28_0==RULE_ID||LA28_0==RULE_QUOTED_ID||(LA28_0>=40 && LA28_0<=41)) ) { + alt28=1; + } + switch (alt28) { + case 1 : + // InternalProblem.g:1037:4: ( (lv_arguments_3_0= ruleArgument ) ) (otherlv_4= ',' ( (lv_arguments_5_0= ruleArgument ) ) )* + { + // InternalProblem.g:1037:4: ( (lv_arguments_3_0= ruleArgument ) ) + // InternalProblem.g:1038:5: (lv_arguments_3_0= ruleArgument ) + { + // InternalProblem.g:1038:5: (lv_arguments_3_0= ruleArgument ) + // InternalProblem.g:1039:6: lv_arguments_3_0= ruleArgument + { + + newCompositeNode(grammarAccess.getAtomAccess().getArgumentsArgumentParserRuleCall_3_0_0()); + + pushFollow(FOLLOW_23); + lv_arguments_3_0=ruleArgument(); + + state._fsp--; + + + if (current==null) { + current = createModelElementForParent(grammarAccess.getAtomRule()); + } + add( + current, + "arguments", + lv_arguments_3_0, + "org.eclipse.viatra.solver.language.Problem.Argument"); + afterParserOrEnumRuleCall(); + + + } + + + } + + // InternalProblem.g:1056:4: (otherlv_4= ',' ( (lv_arguments_5_0= ruleArgument ) ) )* + loop27: + do { + int alt27=2; + int LA27_0 = input.LA(1); + + if ( (LA27_0==17) ) { + alt27=1; + } + + + switch (alt27) { + case 1 : + // InternalProblem.g:1057:5: otherlv_4= ',' ( (lv_arguments_5_0= ruleArgument ) ) + { + otherlv_4=(Token)match(input,17,FOLLOW_8); + + newLeafNode(otherlv_4, grammarAccess.getAtomAccess().getCommaKeyword_3_1_0()); + + // InternalProblem.g:1061:5: ( (lv_arguments_5_0= ruleArgument ) ) + // InternalProblem.g:1062:6: (lv_arguments_5_0= ruleArgument ) + { + // InternalProblem.g:1062:6: (lv_arguments_5_0= ruleArgument ) + // InternalProblem.g:1063:7: lv_arguments_5_0= ruleArgument + { + + newCompositeNode(grammarAccess.getAtomAccess().getArgumentsArgumentParserRuleCall_3_1_1_0()); + + pushFollow(FOLLOW_23); + lv_arguments_5_0=ruleArgument(); + + state._fsp--; + + + if (current==null) { + current = createModelElementForParent(grammarAccess.getAtomRule()); + } + add( + current, + "arguments", + lv_arguments_5_0, + "org.eclipse.viatra.solver.language.Problem.Argument"); + afterParserOrEnumRuleCall(); + + + } + + + } + + + } + break; + + default : + break loop27; + } + } while (true); + + + } + break; + + } + + otherlv_6=(Token)match(input,30,FOLLOW_2); + + newLeafNode(otherlv_6, grammarAccess.getAtomAccess().getRightParenthesisKeyword_4()); + + + } + + + } + + + leaveRule(); + + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "ruleAtom" + + + // $ANTLR start "entryRuleArgument" + // InternalProblem.g:1090:1: entryRuleArgument returns [EObject current=null] : iv_ruleArgument= ruleArgument EOF ; + public final EObject entryRuleArgument() throws RecognitionException { + EObject current = null; + + EObject iv_ruleArgument = null; + + + try { + // InternalProblem.g:1090:49: (iv_ruleArgument= ruleArgument EOF ) + // InternalProblem.g:1091:2: iv_ruleArgument= ruleArgument EOF + { + newCompositeNode(grammarAccess.getArgumentRule()); + pushFollow(FOLLOW_1); + iv_ruleArgument=ruleArgument(); + + state._fsp--; + + current =iv_ruleArgument; + match(input,EOF,FOLLOW_2); + + } + + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "entryRuleArgument" + + + // $ANTLR start "ruleArgument" + // InternalProblem.g:1097:1: ruleArgument returns [EObject current=null] : ( ( ruleQualifiedName ) ) ; + public final EObject ruleArgument() throws RecognitionException { + EObject current = null; + + + enterRule(); + + try { + // InternalProblem.g:1103:2: ( ( ( ruleQualifiedName ) ) ) + // InternalProblem.g:1104:2: ( ( ruleQualifiedName ) ) + { + // InternalProblem.g:1104:2: ( ( ruleQualifiedName ) ) + // InternalProblem.g:1105:3: ( ruleQualifiedName ) + { + // InternalProblem.g:1105:3: ( ruleQualifiedName ) + // InternalProblem.g:1106:4: ruleQualifiedName + { + + if (current==null) { + current = createModelElement(grammarAccess.getArgumentRule()); + } + + + newCompositeNode(grammarAccess.getArgumentAccess().getVariableOrNodeVariableOrNodeCrossReference_0()); + + pushFollow(FOLLOW_2); + ruleQualifiedName(); + + state._fsp--; + + + afterParserOrEnumRuleCall(); + + + } + + + } + + + } + + + leaveRule(); + + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "ruleArgument" + + + // $ANTLR start "entryRuleAssertion" + // InternalProblem.g:1123:1: entryRuleAssertion returns [EObject current=null] : iv_ruleAssertion= ruleAssertion EOF ; + public final EObject entryRuleAssertion() throws RecognitionException { + EObject current = null; + + EObject iv_ruleAssertion = null; + + + try { + // InternalProblem.g:1123:50: (iv_ruleAssertion= ruleAssertion EOF ) + // InternalProblem.g:1124:2: iv_ruleAssertion= ruleAssertion EOF + { + newCompositeNode(grammarAccess.getAssertionRule()); + pushFollow(FOLLOW_1); + iv_ruleAssertion=ruleAssertion(); + + state._fsp--; + + current =iv_ruleAssertion; + match(input,EOF,FOLLOW_2); + + } + + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "entryRuleAssertion" + + + // $ANTLR start "ruleAssertion" + // InternalProblem.g:1130:1: ruleAssertion returns [EObject current=null] : ( ( ( ( ( ruleQualifiedName ) ) otherlv_1= '(' ( ( ( ruleQualifiedName ) ) (otherlv_3= ',' ( ( ruleQualifiedName ) ) )* )? otherlv_5= ')' otherlv_6= ':' ( (lv_value_7_0= ruleLogicValue ) ) ) | ( ( (lv_value_8_0= ruleShortLogicValue ) )? ( ( ruleQualifiedName ) ) otherlv_10= '(' ( ( ( ruleQualifiedName ) ) (otherlv_12= ',' ( ( ruleQualifiedName ) ) )* )? otherlv_14= ')' ) ) otherlv_15= '.' ) ; + public final EObject ruleAssertion() throws RecognitionException { + EObject current = null; + + Token otherlv_1=null; + Token otherlv_3=null; + Token otherlv_5=null; + Token otherlv_6=null; + Token otherlv_10=null; + Token otherlv_12=null; + Token otherlv_14=null; + Token otherlv_15=null; + Enumerator lv_value_7_0 = null; + + Enumerator lv_value_8_0 = null; + + + + enterRule(); + + try { + // InternalProblem.g:1136:2: ( ( ( ( ( ( ruleQualifiedName ) ) otherlv_1= '(' ( ( ( ruleQualifiedName ) ) (otherlv_3= ',' ( ( ruleQualifiedName ) ) )* )? otherlv_5= ')' otherlv_6= ':' ( (lv_value_7_0= ruleLogicValue ) ) ) | ( ( (lv_value_8_0= ruleShortLogicValue ) )? ( ( ruleQualifiedName ) ) otherlv_10= '(' ( ( ( ruleQualifiedName ) ) (otherlv_12= ',' ( ( ruleQualifiedName ) ) )* )? otherlv_14= ')' ) ) otherlv_15= '.' ) ) + // InternalProblem.g:1137:2: ( ( ( ( ( ruleQualifiedName ) ) otherlv_1= '(' ( ( ( ruleQualifiedName ) ) (otherlv_3= ',' ( ( ruleQualifiedName ) ) )* )? otherlv_5= ')' otherlv_6= ':' ( (lv_value_7_0= ruleLogicValue ) ) ) | ( ( (lv_value_8_0= ruleShortLogicValue ) )? ( ( ruleQualifiedName ) ) otherlv_10= '(' ( ( ( ruleQualifiedName ) ) (otherlv_12= ',' ( ( ruleQualifiedName ) ) )* )? otherlv_14= ')' ) ) otherlv_15= '.' ) + { + // InternalProblem.g:1137:2: ( ( ( ( ( ruleQualifiedName ) ) otherlv_1= '(' ( ( ( ruleQualifiedName ) ) (otherlv_3= ',' ( ( ruleQualifiedName ) ) )* )? otherlv_5= ')' otherlv_6= ':' ( (lv_value_7_0= ruleLogicValue ) ) ) | ( ( (lv_value_8_0= ruleShortLogicValue ) )? ( ( ruleQualifiedName ) ) otherlv_10= '(' ( ( ( ruleQualifiedName ) ) (otherlv_12= ',' ( ( ruleQualifiedName ) ) )* )? otherlv_14= ')' ) ) otherlv_15= '.' ) + // InternalProblem.g:1138:3: ( ( ( ( ruleQualifiedName ) ) otherlv_1= '(' ( ( ( ruleQualifiedName ) ) (otherlv_3= ',' ( ( ruleQualifiedName ) ) )* )? otherlv_5= ')' otherlv_6= ':' ( (lv_value_7_0= ruleLogicValue ) ) ) | ( ( (lv_value_8_0= ruleShortLogicValue ) )? ( ( ruleQualifiedName ) ) otherlv_10= '(' ( ( ( ruleQualifiedName ) ) (otherlv_12= ',' ( ( ruleQualifiedName ) ) )* )? otherlv_14= ')' ) ) otherlv_15= '.' + { + // InternalProblem.g:1138:3: ( ( ( ( ruleQualifiedName ) ) otherlv_1= '(' ( ( ( ruleQualifiedName ) ) (otherlv_3= ',' ( ( ruleQualifiedName ) ) )* )? otherlv_5= ')' otherlv_6= ':' ( (lv_value_7_0= ruleLogicValue ) ) ) | ( ( (lv_value_8_0= ruleShortLogicValue ) )? ( ( ruleQualifiedName ) ) otherlv_10= '(' ( ( ( ruleQualifiedName ) ) (otherlv_12= ',' ( ( ruleQualifiedName ) ) )* )? otherlv_14= ')' ) ) + int alt34=2; + alt34 = dfa34.predict(input); + switch (alt34) { + case 1 : + // InternalProblem.g:1139:4: ( ( ( ruleQualifiedName ) ) otherlv_1= '(' ( ( ( ruleQualifiedName ) ) (otherlv_3= ',' ( ( ruleQualifiedName ) ) )* )? otherlv_5= ')' otherlv_6= ':' ( (lv_value_7_0= ruleLogicValue ) ) ) + { + // InternalProblem.g:1139:4: ( ( ( ruleQualifiedName ) ) otherlv_1= '(' ( ( ( ruleQualifiedName ) ) (otherlv_3= ',' ( ( ruleQualifiedName ) ) )* )? otherlv_5= ')' otherlv_6= ':' ( (lv_value_7_0= ruleLogicValue ) ) ) + // InternalProblem.g:1140:5: ( ( ruleQualifiedName ) ) otherlv_1= '(' ( ( ( ruleQualifiedName ) ) (otherlv_3= ',' ( ( ruleQualifiedName ) ) )* )? otherlv_5= ')' otherlv_6= ':' ( (lv_value_7_0= ruleLogicValue ) ) + { + // InternalProblem.g:1140:5: ( ( ruleQualifiedName ) ) + // InternalProblem.g:1141:6: ( ruleQualifiedName ) + { + // InternalProblem.g:1141:6: ( ruleQualifiedName ) + // InternalProblem.g:1142:7: ruleQualifiedName + { + + if (current==null) { + current = createModelElement(grammarAccess.getAssertionRule()); + } + + + newCompositeNode(grammarAccess.getAssertionAccess().getRelationRelationCrossReference_0_0_0_0()); + + pushFollow(FOLLOW_21); + ruleQualifiedName(); + + state._fsp--; + + + afterParserOrEnumRuleCall(); + + + } + + + } + + otherlv_1=(Token)match(input,29,FOLLOW_22); + + newLeafNode(otherlv_1, grammarAccess.getAssertionAccess().getLeftParenthesisKeyword_0_0_1()); + + // InternalProblem.g:1160:5: ( ( ( ruleQualifiedName ) ) (otherlv_3= ',' ( ( ruleQualifiedName ) ) )* )? + int alt30=2; + int LA30_0 = input.LA(1); + + if ( (LA30_0==RULE_ID||LA30_0==RULE_QUOTED_ID||(LA30_0>=40 && LA30_0<=41)) ) { + alt30=1; + } + switch (alt30) { + case 1 : + // InternalProblem.g:1161:6: ( ( ruleQualifiedName ) ) (otherlv_3= ',' ( ( ruleQualifiedName ) ) )* + { + // InternalProblem.g:1161:6: ( ( ruleQualifiedName ) ) + // InternalProblem.g:1162:7: ( ruleQualifiedName ) + { + // InternalProblem.g:1162:7: ( ruleQualifiedName ) + // InternalProblem.g:1163:8: ruleQualifiedName + { + + if (current==null) { + current = createModelElement(grammarAccess.getAssertionRule()); + } + + + newCompositeNode(grammarAccess.getAssertionAccess().getArgumentsNodeCrossReference_0_0_2_0_0()); + + pushFollow(FOLLOW_23); + ruleQualifiedName(); + + state._fsp--; + + + afterParserOrEnumRuleCall(); + + + } + + + } + + // InternalProblem.g:1177:6: (otherlv_3= ',' ( ( ruleQualifiedName ) ) )* + loop29: + do { + int alt29=2; + int LA29_0 = input.LA(1); + + if ( (LA29_0==17) ) { + alt29=1; + } + + + switch (alt29) { + case 1 : + // InternalProblem.g:1178:7: otherlv_3= ',' ( ( ruleQualifiedName ) ) + { + otherlv_3=(Token)match(input,17,FOLLOW_8); + + newLeafNode(otherlv_3, grammarAccess.getAssertionAccess().getCommaKeyword_0_0_2_1_0()); + + // InternalProblem.g:1182:7: ( ( ruleQualifiedName ) ) + // InternalProblem.g:1183:8: ( ruleQualifiedName ) + { + // InternalProblem.g:1183:8: ( ruleQualifiedName ) + // InternalProblem.g:1184:9: ruleQualifiedName + { + + if (current==null) { + current = createModelElement(grammarAccess.getAssertionRule()); + } + + + newCompositeNode(grammarAccess.getAssertionAccess().getArgumentsNodeCrossReference_0_0_2_1_1_0()); + + pushFollow(FOLLOW_23); + ruleQualifiedName(); + + state._fsp--; + + + afterParserOrEnumRuleCall(); + + + } + + + } + + + } + break; + + default : + break loop29; + } + } while (true); + + + } + break; + + } + + otherlv_5=(Token)match(input,30,FOLLOW_29); + + newLeafNode(otherlv_5, grammarAccess.getAssertionAccess().getRightParenthesisKeyword_0_0_3()); + + otherlv_6=(Token)match(input,34,FOLLOW_30); + + newLeafNode(otherlv_6, grammarAccess.getAssertionAccess().getColonKeyword_0_0_4()); + + // InternalProblem.g:1208:5: ( (lv_value_7_0= ruleLogicValue ) ) + // InternalProblem.g:1209:6: (lv_value_7_0= ruleLogicValue ) + { + // InternalProblem.g:1209:6: (lv_value_7_0= ruleLogicValue ) + // InternalProblem.g:1210:7: lv_value_7_0= ruleLogicValue + { + + newCompositeNode(grammarAccess.getAssertionAccess().getValueLogicValueEnumRuleCall_0_0_5_0()); + + pushFollow(FOLLOW_4); + lv_value_7_0=ruleLogicValue(); + + state._fsp--; + + + if (current==null) { + current = createModelElementForParent(grammarAccess.getAssertionRule()); + } + set( + current, + "value", + lv_value_7_0, + "org.eclipse.viatra.solver.language.Problem.LogicValue"); + afterParserOrEnumRuleCall(); + + + } + + + } + + + } + + + } + break; + case 2 : + // InternalProblem.g:1229:4: ( ( (lv_value_8_0= ruleShortLogicValue ) )? ( ( ruleQualifiedName ) ) otherlv_10= '(' ( ( ( ruleQualifiedName ) ) (otherlv_12= ',' ( ( ruleQualifiedName ) ) )* )? otherlv_14= ')' ) + { + // InternalProblem.g:1229:4: ( ( (lv_value_8_0= ruleShortLogicValue ) )? ( ( ruleQualifiedName ) ) otherlv_10= '(' ( ( ( ruleQualifiedName ) ) (otherlv_12= ',' ( ( ruleQualifiedName ) ) )* )? otherlv_14= ')' ) + // InternalProblem.g:1230:5: ( (lv_value_8_0= ruleShortLogicValue ) )? ( ( ruleQualifiedName ) ) otherlv_10= '(' ( ( ( ruleQualifiedName ) ) (otherlv_12= ',' ( ( ruleQualifiedName ) ) )* )? otherlv_14= ')' + { + // InternalProblem.g:1230:5: ( (lv_value_8_0= ruleShortLogicValue ) )? + int alt31=2; + int LA31_0 = input.LA(1); + + if ( (LA31_0==32||LA31_0==43) ) { + alt31=1; + } + switch (alt31) { + case 1 : + // InternalProblem.g:1231:6: (lv_value_8_0= ruleShortLogicValue ) + { + // InternalProblem.g:1231:6: (lv_value_8_0= ruleShortLogicValue ) + // InternalProblem.g:1232:7: lv_value_8_0= ruleShortLogicValue + { + + newCompositeNode(grammarAccess.getAssertionAccess().getValueShortLogicValueEnumRuleCall_0_1_0_0()); + + pushFollow(FOLLOW_8); + lv_value_8_0=ruleShortLogicValue(); + + state._fsp--; + + + if (current==null) { + current = createModelElementForParent(grammarAccess.getAssertionRule()); + } + set( + current, + "value", + lv_value_8_0, + "org.eclipse.viatra.solver.language.Problem.ShortLogicValue"); + afterParserOrEnumRuleCall(); + + + } + + + } + break; + + } + + // InternalProblem.g:1249:5: ( ( ruleQualifiedName ) ) + // InternalProblem.g:1250:6: ( ruleQualifiedName ) + { + // InternalProblem.g:1250:6: ( ruleQualifiedName ) + // InternalProblem.g:1251:7: ruleQualifiedName + { + + if (current==null) { + current = createModelElement(grammarAccess.getAssertionRule()); + } + + + newCompositeNode(grammarAccess.getAssertionAccess().getRelationRelationCrossReference_0_1_1_0()); + + pushFollow(FOLLOW_21); + ruleQualifiedName(); + + state._fsp--; + + + afterParserOrEnumRuleCall(); + + + } + + + } + + otherlv_10=(Token)match(input,29,FOLLOW_22); + + newLeafNode(otherlv_10, grammarAccess.getAssertionAccess().getLeftParenthesisKeyword_0_1_2()); + + // InternalProblem.g:1269:5: ( ( ( ruleQualifiedName ) ) (otherlv_12= ',' ( ( ruleQualifiedName ) ) )* )? + int alt33=2; + int LA33_0 = input.LA(1); + + if ( (LA33_0==RULE_ID||LA33_0==RULE_QUOTED_ID||(LA33_0>=40 && LA33_0<=41)) ) { + alt33=1; + } + switch (alt33) { + case 1 : + // InternalProblem.g:1270:6: ( ( ruleQualifiedName ) ) (otherlv_12= ',' ( ( ruleQualifiedName ) ) )* + { + // InternalProblem.g:1270:6: ( ( ruleQualifiedName ) ) + // InternalProblem.g:1271:7: ( ruleQualifiedName ) + { + // InternalProblem.g:1271:7: ( ruleQualifiedName ) + // InternalProblem.g:1272:8: ruleQualifiedName + { + + if (current==null) { + current = createModelElement(grammarAccess.getAssertionRule()); + } + + + newCompositeNode(grammarAccess.getAssertionAccess().getArgumentsNodeCrossReference_0_1_3_0_0()); + + pushFollow(FOLLOW_23); + ruleQualifiedName(); + + state._fsp--; + + + afterParserOrEnumRuleCall(); + + + } + + + } + + // InternalProblem.g:1286:6: (otherlv_12= ',' ( ( ruleQualifiedName ) ) )* + loop32: + do { + int alt32=2; + int LA32_0 = input.LA(1); + + if ( (LA32_0==17) ) { + alt32=1; + } + + + switch (alt32) { + case 1 : + // InternalProblem.g:1287:7: otherlv_12= ',' ( ( ruleQualifiedName ) ) + { + otherlv_12=(Token)match(input,17,FOLLOW_8); + + newLeafNode(otherlv_12, grammarAccess.getAssertionAccess().getCommaKeyword_0_1_3_1_0()); + + // InternalProblem.g:1291:7: ( ( ruleQualifiedName ) ) + // InternalProblem.g:1292:8: ( ruleQualifiedName ) + { + // InternalProblem.g:1292:8: ( ruleQualifiedName ) + // InternalProblem.g:1293:9: ruleQualifiedName + { + + if (current==null) { + current = createModelElement(grammarAccess.getAssertionRule()); + } + + + newCompositeNode(grammarAccess.getAssertionAccess().getArgumentsNodeCrossReference_0_1_3_1_1_0()); + + pushFollow(FOLLOW_23); + ruleQualifiedName(); + + state._fsp--; + + + afterParserOrEnumRuleCall(); + + + } + + + } + + + } + break; + + default : + break loop32; + } + } while (true); + + + } + break; + + } + + otherlv_14=(Token)match(input,30,FOLLOW_4); + + newLeafNode(otherlv_14, grammarAccess.getAssertionAccess().getRightParenthesisKeyword_0_1_4()); + + + } + + + } + break; + + } + + otherlv_15=(Token)match(input,13,FOLLOW_2); + + newLeafNode(otherlv_15, grammarAccess.getAssertionAccess().getFullStopKeyword_1()); + + + } + + + } + + + leaveRule(); + + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "ruleAssertion" + + + // $ANTLR start "entryRuleScopeDeclaration" + // InternalProblem.g:1323:1: entryRuleScopeDeclaration returns [EObject current=null] : iv_ruleScopeDeclaration= ruleScopeDeclaration EOF ; + public final EObject entryRuleScopeDeclaration() throws RecognitionException { + EObject current = null; + + EObject iv_ruleScopeDeclaration = null; + + + try { + // InternalProblem.g:1323:57: (iv_ruleScopeDeclaration= ruleScopeDeclaration EOF ) + // InternalProblem.g:1324:2: iv_ruleScopeDeclaration= ruleScopeDeclaration EOF + { + newCompositeNode(grammarAccess.getScopeDeclarationRule()); + pushFollow(FOLLOW_1); + iv_ruleScopeDeclaration=ruleScopeDeclaration(); + + state._fsp--; + + current =iv_ruleScopeDeclaration; + match(input,EOF,FOLLOW_2); + + } + + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "entryRuleScopeDeclaration" + + + // $ANTLR start "ruleScopeDeclaration" + // InternalProblem.g:1330:1: ruleScopeDeclaration returns [EObject current=null] : (otherlv_0= 'scope' ( (lv_typeScopes_1_0= ruleTypeScope ) ) (otherlv_2= ',' ( (lv_typeScopes_3_0= ruleTypeScope ) ) )* otherlv_4= '.' ) ; + public final EObject ruleScopeDeclaration() throws RecognitionException { + EObject current = null; + + Token otherlv_0=null; + Token otherlv_2=null; + Token otherlv_4=null; + EObject lv_typeScopes_1_0 = null; + + EObject lv_typeScopes_3_0 = null; + + + + enterRule(); + + try { + // InternalProblem.g:1336:2: ( (otherlv_0= 'scope' ( (lv_typeScopes_1_0= ruleTypeScope ) ) (otherlv_2= ',' ( (lv_typeScopes_3_0= ruleTypeScope ) ) )* otherlv_4= '.' ) ) + // InternalProblem.g:1337:2: (otherlv_0= 'scope' ( (lv_typeScopes_1_0= ruleTypeScope ) ) (otherlv_2= ',' ( (lv_typeScopes_3_0= ruleTypeScope ) ) )* otherlv_4= '.' ) + { + // InternalProblem.g:1337:2: (otherlv_0= 'scope' ( (lv_typeScopes_1_0= ruleTypeScope ) ) (otherlv_2= ',' ( (lv_typeScopes_3_0= ruleTypeScope ) ) )* otherlv_4= '.' ) + // InternalProblem.g:1338:3: otherlv_0= 'scope' ( (lv_typeScopes_1_0= ruleTypeScope ) ) (otherlv_2= ',' ( (lv_typeScopes_3_0= ruleTypeScope ) ) )* otherlv_4= '.' + { + otherlv_0=(Token)match(input,35,FOLLOW_31); + + newLeafNode(otherlv_0, grammarAccess.getScopeDeclarationAccess().getScopeKeyword_0()); + + // InternalProblem.g:1342:3: ( (lv_typeScopes_1_0= ruleTypeScope ) ) + // InternalProblem.g:1343:4: (lv_typeScopes_1_0= ruleTypeScope ) + { + // InternalProblem.g:1343:4: (lv_typeScopes_1_0= ruleTypeScope ) + // InternalProblem.g:1344:5: lv_typeScopes_1_0= ruleTypeScope + { + + newCompositeNode(grammarAccess.getScopeDeclarationAccess().getTypeScopesTypeScopeParserRuleCall_1_0()); + + pushFollow(FOLLOW_32); + lv_typeScopes_1_0=ruleTypeScope(); + + state._fsp--; + + + if (current==null) { + current = createModelElementForParent(grammarAccess.getScopeDeclarationRule()); + } + add( + current, + "typeScopes", + lv_typeScopes_1_0, + "org.eclipse.viatra.solver.language.Problem.TypeScope"); + afterParserOrEnumRuleCall(); + + + } + + + } + + // InternalProblem.g:1361:3: (otherlv_2= ',' ( (lv_typeScopes_3_0= ruleTypeScope ) ) )* + loop35: + do { + int alt35=2; + int LA35_0 = input.LA(1); + + if ( (LA35_0==17) ) { + alt35=1; + } + + + switch (alt35) { + case 1 : + // InternalProblem.g:1362:4: otherlv_2= ',' ( (lv_typeScopes_3_0= ruleTypeScope ) ) + { + otherlv_2=(Token)match(input,17,FOLLOW_31); + + newLeafNode(otherlv_2, grammarAccess.getScopeDeclarationAccess().getCommaKeyword_2_0()); + + // InternalProblem.g:1366:4: ( (lv_typeScopes_3_0= ruleTypeScope ) ) + // InternalProblem.g:1367:5: (lv_typeScopes_3_0= ruleTypeScope ) + { + // InternalProblem.g:1367:5: (lv_typeScopes_3_0= ruleTypeScope ) + // InternalProblem.g:1368:6: lv_typeScopes_3_0= ruleTypeScope + { + + newCompositeNode(grammarAccess.getScopeDeclarationAccess().getTypeScopesTypeScopeParserRuleCall_2_1_0()); + + pushFollow(FOLLOW_32); + lv_typeScopes_3_0=ruleTypeScope(); + + state._fsp--; + + + if (current==null) { + current = createModelElementForParent(grammarAccess.getScopeDeclarationRule()); + } + add( + current, + "typeScopes", + lv_typeScopes_3_0, + "org.eclipse.viatra.solver.language.Problem.TypeScope"); + afterParserOrEnumRuleCall(); + + + } + + + } + + + } + break; + + default : + break loop35; + } + } while (true); + + otherlv_4=(Token)match(input,13,FOLLOW_2); + + newLeafNode(otherlv_4, grammarAccess.getScopeDeclarationAccess().getFullStopKeyword_3()); + + + } + + + } + + + leaveRule(); + + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "ruleScopeDeclaration" + + + // $ANTLR start "entryRuleTypeScope" + // InternalProblem.g:1394:1: entryRuleTypeScope returns [EObject current=null] : iv_ruleTypeScope= ruleTypeScope EOF ; + public final EObject entryRuleTypeScope() throws RecognitionException { + EObject current = null; + + EObject iv_ruleTypeScope = null; + + + try { + // InternalProblem.g:1394:50: (iv_ruleTypeScope= ruleTypeScope EOF ) + // InternalProblem.g:1395:2: iv_ruleTypeScope= ruleTypeScope EOF + { + newCompositeNode(grammarAccess.getTypeScopeRule()); + pushFollow(FOLLOW_1); + iv_ruleTypeScope=ruleTypeScope(); + + state._fsp--; + + current =iv_ruleTypeScope; + match(input,EOF,FOLLOW_2); + + } + + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "entryRuleTypeScope" + + + // $ANTLR start "ruleTypeScope" + // InternalProblem.g:1401:1: ruleTypeScope returns [EObject current=null] : ( ( (otherlv_0= RULE_ID ) ) ( ( (lv_increment_1_0= '+=' ) ) | otherlv_2= '=' ) ( (lv_multiplicity_3_0= ruleDefiniteMultiplicity ) ) ) ; + public final EObject ruleTypeScope() throws RecognitionException { + EObject current = null; + + Token otherlv_0=null; + Token lv_increment_1_0=null; + Token otherlv_2=null; + EObject lv_multiplicity_3_0 = null; + + + + enterRule(); + + try { + // InternalProblem.g:1407:2: ( ( ( (otherlv_0= RULE_ID ) ) ( ( (lv_increment_1_0= '+=' ) ) | otherlv_2= '=' ) ( (lv_multiplicity_3_0= ruleDefiniteMultiplicity ) ) ) ) + // InternalProblem.g:1408:2: ( ( (otherlv_0= RULE_ID ) ) ( ( (lv_increment_1_0= '+=' ) ) | otherlv_2= '=' ) ( (lv_multiplicity_3_0= ruleDefiniteMultiplicity ) ) ) + { + // InternalProblem.g:1408:2: ( ( (otherlv_0= RULE_ID ) ) ( ( (lv_increment_1_0= '+=' ) ) | otherlv_2= '=' ) ( (lv_multiplicity_3_0= ruleDefiniteMultiplicity ) ) ) + // InternalProblem.g:1409:3: ( (otherlv_0= RULE_ID ) ) ( ( (lv_increment_1_0= '+=' ) ) | otherlv_2= '=' ) ( (lv_multiplicity_3_0= ruleDefiniteMultiplicity ) ) + { + // InternalProblem.g:1409:3: ( (otherlv_0= RULE_ID ) ) + // InternalProblem.g:1410:4: (otherlv_0= RULE_ID ) + { + // InternalProblem.g:1410:4: (otherlv_0= RULE_ID ) + // InternalProblem.g:1411:5: otherlv_0= RULE_ID + { + + if (current==null) { + current = createModelElement(grammarAccess.getTypeScopeRule()); + } + + otherlv_0=(Token)match(input,RULE_ID,FOLLOW_33); + + newLeafNode(otherlv_0, grammarAccess.getTypeScopeAccess().getTargetTypeClassDeclarationCrossReference_0_0()); + + + } + + + } + + // InternalProblem.g:1422:3: ( ( (lv_increment_1_0= '+=' ) ) | otherlv_2= '=' ) + int alt36=2; + int LA36_0 = input.LA(1); + + if ( (LA36_0==36) ) { + alt36=1; + } + else if ( (LA36_0==37) ) { + alt36=2; + } + else { + NoViableAltException nvae = + new NoViableAltException("", 36, 0, input); + + throw nvae; + } + switch (alt36) { + case 1 : + // InternalProblem.g:1423:4: ( (lv_increment_1_0= '+=' ) ) + { + // InternalProblem.g:1423:4: ( (lv_increment_1_0= '+=' ) ) + // InternalProblem.g:1424:5: (lv_increment_1_0= '+=' ) + { + // InternalProblem.g:1424:5: (lv_increment_1_0= '+=' ) + // InternalProblem.g:1425:6: lv_increment_1_0= '+=' + { + lv_increment_1_0=(Token)match(input,36,FOLLOW_17); + + newLeafNode(lv_increment_1_0, grammarAccess.getTypeScopeAccess().getIncrementPlusSignEqualsSignKeyword_1_0_0()); + + + if (current==null) { + current = createModelElement(grammarAccess.getTypeScopeRule()); + } + setWithLastConsumed(current, "increment", lv_increment_1_0 != null, "+="); + + + } + + + } + + + } + break; + case 2 : + // InternalProblem.g:1438:4: otherlv_2= '=' + { + otherlv_2=(Token)match(input,37,FOLLOW_17); + + newLeafNode(otherlv_2, grammarAccess.getTypeScopeAccess().getEqualsSignKeyword_1_1()); + + + } + break; + + } + + // InternalProblem.g:1443:3: ( (lv_multiplicity_3_0= ruleDefiniteMultiplicity ) ) + // InternalProblem.g:1444:4: (lv_multiplicity_3_0= ruleDefiniteMultiplicity ) + { + // InternalProblem.g:1444:4: (lv_multiplicity_3_0= ruleDefiniteMultiplicity ) + // InternalProblem.g:1445:5: lv_multiplicity_3_0= ruleDefiniteMultiplicity + { + + newCompositeNode(grammarAccess.getTypeScopeAccess().getMultiplicityDefiniteMultiplicityParserRuleCall_2_0()); + + pushFollow(FOLLOW_2); + lv_multiplicity_3_0=ruleDefiniteMultiplicity(); + + state._fsp--; + + + if (current==null) { + current = createModelElementForParent(grammarAccess.getTypeScopeRule()); + } + set( + current, + "multiplicity", + lv_multiplicity_3_0, + "org.eclipse.viatra.solver.language.Problem.DefiniteMultiplicity"); + afterParserOrEnumRuleCall(); + + + } + + + } + + + } + + + } + + + leaveRule(); + + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "ruleTypeScope" + + + // $ANTLR start "entryRuleMultiplicity" + // InternalProblem.g:1466:1: entryRuleMultiplicity returns [EObject current=null] : iv_ruleMultiplicity= ruleMultiplicity EOF ; + public final EObject entryRuleMultiplicity() throws RecognitionException { + EObject current = null; + + EObject iv_ruleMultiplicity = null; + + + try { + // InternalProblem.g:1466:53: (iv_ruleMultiplicity= ruleMultiplicity EOF ) + // InternalProblem.g:1467:2: iv_ruleMultiplicity= ruleMultiplicity EOF + { + newCompositeNode(grammarAccess.getMultiplicityRule()); + pushFollow(FOLLOW_1); + iv_ruleMultiplicity=ruleMultiplicity(); + + state._fsp--; + + current =iv_ruleMultiplicity; + match(input,EOF,FOLLOW_2); + + } + + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "entryRuleMultiplicity" + + + // $ANTLR start "ruleMultiplicity" + // InternalProblem.g:1473:1: ruleMultiplicity returns [EObject current=null] : (this_UnboundedMultiplicity_0= ruleUnboundedMultiplicity | this_DefiniteMultiplicity_1= ruleDefiniteMultiplicity ) ; + public final EObject ruleMultiplicity() throws RecognitionException { + EObject current = null; + + EObject this_UnboundedMultiplicity_0 = null; + + EObject this_DefiniteMultiplicity_1 = null; + + + + enterRule(); + + try { + // InternalProblem.g:1479:2: ( (this_UnboundedMultiplicity_0= ruleUnboundedMultiplicity | this_DefiniteMultiplicity_1= ruleDefiniteMultiplicity ) ) + // InternalProblem.g:1480:2: (this_UnboundedMultiplicity_0= ruleUnboundedMultiplicity | this_DefiniteMultiplicity_1= ruleDefiniteMultiplicity ) + { + // InternalProblem.g:1480:2: (this_UnboundedMultiplicity_0= ruleUnboundedMultiplicity | this_DefiniteMultiplicity_1= ruleDefiniteMultiplicity ) + int alt37=2; + int LA37_0 = input.LA(1); + + if ( (LA37_0==EOF||LA37_0==25) ) { + alt37=1; + } + else if ( (LA37_0==RULE_INT) ) { + alt37=2; + } + else { + NoViableAltException nvae = + new NoViableAltException("", 37, 0, input); + + throw nvae; + } + switch (alt37) { + case 1 : + // InternalProblem.g:1481:3: this_UnboundedMultiplicity_0= ruleUnboundedMultiplicity + { + + newCompositeNode(grammarAccess.getMultiplicityAccess().getUnboundedMultiplicityParserRuleCall_0()); + + pushFollow(FOLLOW_2); + this_UnboundedMultiplicity_0=ruleUnboundedMultiplicity(); + + state._fsp--; + + + current = this_UnboundedMultiplicity_0; + afterParserOrEnumRuleCall(); + + + } + break; + case 2 : + // InternalProblem.g:1490:3: this_DefiniteMultiplicity_1= ruleDefiniteMultiplicity + { + + newCompositeNode(grammarAccess.getMultiplicityAccess().getDefiniteMultiplicityParserRuleCall_1()); + + pushFollow(FOLLOW_2); + this_DefiniteMultiplicity_1=ruleDefiniteMultiplicity(); + + state._fsp--; + + + current = this_DefiniteMultiplicity_1; + afterParserOrEnumRuleCall(); + + + } + break; + + } + + + } + + + leaveRule(); + + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "ruleMultiplicity" + + + // $ANTLR start "entryRuleDefiniteMultiplicity" + // InternalProblem.g:1502:1: entryRuleDefiniteMultiplicity returns [EObject current=null] : iv_ruleDefiniteMultiplicity= ruleDefiniteMultiplicity EOF ; + public final EObject entryRuleDefiniteMultiplicity() throws RecognitionException { + EObject current = null; + + EObject iv_ruleDefiniteMultiplicity = null; + + + try { + // InternalProblem.g:1502:61: (iv_ruleDefiniteMultiplicity= ruleDefiniteMultiplicity EOF ) + // InternalProblem.g:1503:2: iv_ruleDefiniteMultiplicity= ruleDefiniteMultiplicity EOF + { + newCompositeNode(grammarAccess.getDefiniteMultiplicityRule()); + pushFollow(FOLLOW_1); + iv_ruleDefiniteMultiplicity=ruleDefiniteMultiplicity(); + + state._fsp--; + + current =iv_ruleDefiniteMultiplicity; + match(input,EOF,FOLLOW_2); + + } + + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "entryRuleDefiniteMultiplicity" + + + // $ANTLR start "ruleDefiniteMultiplicity" + // InternalProblem.g:1509:1: ruleDefiniteMultiplicity returns [EObject current=null] : (this_RangeMultiplicity_0= ruleRangeMultiplicity | this_ExactMultiplicity_1= ruleExactMultiplicity ) ; + public final EObject ruleDefiniteMultiplicity() throws RecognitionException { + EObject current = null; + + EObject this_RangeMultiplicity_0 = null; + + EObject this_ExactMultiplicity_1 = null; + + + + enterRule(); + + try { + // InternalProblem.g:1515:2: ( (this_RangeMultiplicity_0= ruleRangeMultiplicity | this_ExactMultiplicity_1= ruleExactMultiplicity ) ) + // InternalProblem.g:1516:2: (this_RangeMultiplicity_0= ruleRangeMultiplicity | this_ExactMultiplicity_1= ruleExactMultiplicity ) + { + // InternalProblem.g:1516:2: (this_RangeMultiplicity_0= ruleRangeMultiplicity | this_ExactMultiplicity_1= ruleExactMultiplicity ) + int alt38=2; + int LA38_0 = input.LA(1); + + if ( (LA38_0==RULE_INT) ) { + int LA38_1 = input.LA(2); + + if ( (LA38_1==38) ) { + alt38=1; + } + else if ( (LA38_1==EOF||LA38_1==13||LA38_1==17||LA38_1==25) ) { + alt38=2; + } + else { + NoViableAltException nvae = + new NoViableAltException("", 38, 1, input); + + throw nvae; + } + } + else { + NoViableAltException nvae = + new NoViableAltException("", 38, 0, input); + + throw nvae; + } + switch (alt38) { + case 1 : + // InternalProblem.g:1517:3: this_RangeMultiplicity_0= ruleRangeMultiplicity + { + + newCompositeNode(grammarAccess.getDefiniteMultiplicityAccess().getRangeMultiplicityParserRuleCall_0()); + + pushFollow(FOLLOW_2); + this_RangeMultiplicity_0=ruleRangeMultiplicity(); + + state._fsp--; + + + current = this_RangeMultiplicity_0; + afterParserOrEnumRuleCall(); + + + } + break; + case 2 : + // InternalProblem.g:1526:3: this_ExactMultiplicity_1= ruleExactMultiplicity + { + + newCompositeNode(grammarAccess.getDefiniteMultiplicityAccess().getExactMultiplicityParserRuleCall_1()); + + pushFollow(FOLLOW_2); + this_ExactMultiplicity_1=ruleExactMultiplicity(); + + state._fsp--; + + + current = this_ExactMultiplicity_1; + afterParserOrEnumRuleCall(); + + + } + break; + + } + + + } + + + leaveRule(); + + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "ruleDefiniteMultiplicity" + + + // $ANTLR start "entryRuleUnboundedMultiplicity" + // InternalProblem.g:1538:1: entryRuleUnboundedMultiplicity returns [EObject current=null] : iv_ruleUnboundedMultiplicity= ruleUnboundedMultiplicity EOF ; + public final EObject entryRuleUnboundedMultiplicity() throws RecognitionException { + EObject current = null; + + EObject iv_ruleUnboundedMultiplicity = null; + + + try { + // InternalProblem.g:1538:62: (iv_ruleUnboundedMultiplicity= ruleUnboundedMultiplicity EOF ) + // InternalProblem.g:1539:2: iv_ruleUnboundedMultiplicity= ruleUnboundedMultiplicity EOF + { + newCompositeNode(grammarAccess.getUnboundedMultiplicityRule()); + pushFollow(FOLLOW_1); + iv_ruleUnboundedMultiplicity=ruleUnboundedMultiplicity(); + + state._fsp--; + + current =iv_ruleUnboundedMultiplicity; + match(input,EOF,FOLLOW_2); + + } + + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "entryRuleUnboundedMultiplicity" + + + // $ANTLR start "ruleUnboundedMultiplicity" + // InternalProblem.g:1545:1: ruleUnboundedMultiplicity returns [EObject current=null] : () ; + public final EObject ruleUnboundedMultiplicity() throws RecognitionException { + EObject current = null; + + + enterRule(); + + try { + // InternalProblem.g:1551:2: ( () ) + // InternalProblem.g:1552:2: () + { + // InternalProblem.g:1552:2: () + // InternalProblem.g:1553:3: + { + + current = forceCreateModelElement( + grammarAccess.getUnboundedMultiplicityAccess().getUnboundedMultiplicityAction(), + current); + + + } + + + } + + + leaveRule(); + + } + finally { + } + return current; + } + // $ANTLR end "ruleUnboundedMultiplicity" + + + // $ANTLR start "entryRuleRangeMultiplicity" + // InternalProblem.g:1562:1: entryRuleRangeMultiplicity returns [EObject current=null] : iv_ruleRangeMultiplicity= ruleRangeMultiplicity EOF ; + public final EObject entryRuleRangeMultiplicity() throws RecognitionException { + EObject current = null; + + EObject iv_ruleRangeMultiplicity = null; + + + try { + // InternalProblem.g:1562:58: (iv_ruleRangeMultiplicity= ruleRangeMultiplicity EOF ) + // InternalProblem.g:1563:2: iv_ruleRangeMultiplicity= ruleRangeMultiplicity EOF + { + newCompositeNode(grammarAccess.getRangeMultiplicityRule()); + pushFollow(FOLLOW_1); + iv_ruleRangeMultiplicity=ruleRangeMultiplicity(); + + state._fsp--; + + current =iv_ruleRangeMultiplicity; + match(input,EOF,FOLLOW_2); + + } + + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "entryRuleRangeMultiplicity" + + + // $ANTLR start "ruleRangeMultiplicity" + // InternalProblem.g:1569:1: ruleRangeMultiplicity returns [EObject current=null] : ( ( (lv_lowerBound_0_0= RULE_INT ) ) otherlv_1= '..' ( (lv_upperBound_2_0= ruleUpperBound ) ) ) ; + public final EObject ruleRangeMultiplicity() throws RecognitionException { + EObject current = null; + + Token lv_lowerBound_0_0=null; + Token otherlv_1=null; + AntlrDatatypeRuleToken lv_upperBound_2_0 = null; + + + + enterRule(); + + try { + // InternalProblem.g:1575:2: ( ( ( (lv_lowerBound_0_0= RULE_INT ) ) otherlv_1= '..' ( (lv_upperBound_2_0= ruleUpperBound ) ) ) ) + // InternalProblem.g:1576:2: ( ( (lv_lowerBound_0_0= RULE_INT ) ) otherlv_1= '..' ( (lv_upperBound_2_0= ruleUpperBound ) ) ) + { + // InternalProblem.g:1576:2: ( ( (lv_lowerBound_0_0= RULE_INT ) ) otherlv_1= '..' ( (lv_upperBound_2_0= ruleUpperBound ) ) ) + // InternalProblem.g:1577:3: ( (lv_lowerBound_0_0= RULE_INT ) ) otherlv_1= '..' ( (lv_upperBound_2_0= ruleUpperBound ) ) + { + // InternalProblem.g:1577:3: ( (lv_lowerBound_0_0= RULE_INT ) ) + // InternalProblem.g:1578:4: (lv_lowerBound_0_0= RULE_INT ) + { + // InternalProblem.g:1578:4: (lv_lowerBound_0_0= RULE_INT ) + // InternalProblem.g:1579:5: lv_lowerBound_0_0= RULE_INT + { + lv_lowerBound_0_0=(Token)match(input,RULE_INT,FOLLOW_34); + + newLeafNode(lv_lowerBound_0_0, grammarAccess.getRangeMultiplicityAccess().getLowerBoundINTTerminalRuleCall_0_0()); + + + if (current==null) { + current = createModelElement(grammarAccess.getRangeMultiplicityRule()); + } + setWithLastConsumed( + current, + "lowerBound", + lv_lowerBound_0_0, + "org.eclipse.xtext.common.Terminals.INT"); + + + } + + + } + + otherlv_1=(Token)match(input,38,FOLLOW_35); + + newLeafNode(otherlv_1, grammarAccess.getRangeMultiplicityAccess().getFullStopFullStopKeyword_1()); + + // InternalProblem.g:1599:3: ( (lv_upperBound_2_0= ruleUpperBound ) ) + // InternalProblem.g:1600:4: (lv_upperBound_2_0= ruleUpperBound ) + { + // InternalProblem.g:1600:4: (lv_upperBound_2_0= ruleUpperBound ) + // InternalProblem.g:1601:5: lv_upperBound_2_0= ruleUpperBound + { + + newCompositeNode(grammarAccess.getRangeMultiplicityAccess().getUpperBoundUpperBoundParserRuleCall_2_0()); + + pushFollow(FOLLOW_2); + lv_upperBound_2_0=ruleUpperBound(); + + state._fsp--; + + + if (current==null) { + current = createModelElementForParent(grammarAccess.getRangeMultiplicityRule()); + } + set( + current, + "upperBound", + lv_upperBound_2_0, + "org.eclipse.viatra.solver.language.Problem.UpperBound"); + afterParserOrEnumRuleCall(); + + + } + + + } + + + } + + + } + + + leaveRule(); + + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "ruleRangeMultiplicity" + + + // $ANTLR start "entryRuleExactMultiplicity" + // InternalProblem.g:1622:1: entryRuleExactMultiplicity returns [EObject current=null] : iv_ruleExactMultiplicity= ruleExactMultiplicity EOF ; + public final EObject entryRuleExactMultiplicity() throws RecognitionException { + EObject current = null; + + EObject iv_ruleExactMultiplicity = null; + + + try { + // InternalProblem.g:1622:58: (iv_ruleExactMultiplicity= ruleExactMultiplicity EOF ) + // InternalProblem.g:1623:2: iv_ruleExactMultiplicity= ruleExactMultiplicity EOF + { + newCompositeNode(grammarAccess.getExactMultiplicityRule()); + pushFollow(FOLLOW_1); + iv_ruleExactMultiplicity=ruleExactMultiplicity(); + + state._fsp--; + + current =iv_ruleExactMultiplicity; + match(input,EOF,FOLLOW_2); + + } + + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "entryRuleExactMultiplicity" + + + // $ANTLR start "ruleExactMultiplicity" + // InternalProblem.g:1629:1: ruleExactMultiplicity returns [EObject current=null] : ( (lv_exactValue_0_0= RULE_INT ) ) ; + public final EObject ruleExactMultiplicity() throws RecognitionException { + EObject current = null; + + Token lv_exactValue_0_0=null; + + + enterRule(); + + try { + // InternalProblem.g:1635:2: ( ( (lv_exactValue_0_0= RULE_INT ) ) ) + // InternalProblem.g:1636:2: ( (lv_exactValue_0_0= RULE_INT ) ) + { + // InternalProblem.g:1636:2: ( (lv_exactValue_0_0= RULE_INT ) ) + // InternalProblem.g:1637:3: (lv_exactValue_0_0= RULE_INT ) + { + // InternalProblem.g:1637:3: (lv_exactValue_0_0= RULE_INT ) + // InternalProblem.g:1638:4: lv_exactValue_0_0= RULE_INT + { + lv_exactValue_0_0=(Token)match(input,RULE_INT,FOLLOW_2); + + newLeafNode(lv_exactValue_0_0, grammarAccess.getExactMultiplicityAccess().getExactValueINTTerminalRuleCall_0()); + + + if (current==null) { + current = createModelElement(grammarAccess.getExactMultiplicityRule()); + } + setWithLastConsumed( + current, + "exactValue", + lv_exactValue_0_0, + "org.eclipse.xtext.common.Terminals.INT"); + + + } + + + } + + + } + + + leaveRule(); + + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "ruleExactMultiplicity" + + + // $ANTLR start "entryRuleUpperBound" + // InternalProblem.g:1657:1: entryRuleUpperBound returns [String current=null] : iv_ruleUpperBound= ruleUpperBound EOF ; + public final String entryRuleUpperBound() throws RecognitionException { + String current = null; + + AntlrDatatypeRuleToken iv_ruleUpperBound = null; + + + try { + // InternalProblem.g:1657:50: (iv_ruleUpperBound= ruleUpperBound EOF ) + // InternalProblem.g:1658:2: iv_ruleUpperBound= ruleUpperBound EOF + { + newCompositeNode(grammarAccess.getUpperBoundRule()); + pushFollow(FOLLOW_1); + iv_ruleUpperBound=ruleUpperBound(); + + state._fsp--; + + current =iv_ruleUpperBound.getText(); + match(input,EOF,FOLLOW_2); + + } + + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "entryRuleUpperBound" + + + // $ANTLR start "ruleUpperBound" + // InternalProblem.g:1664:1: ruleUpperBound returns [AntlrDatatypeRuleToken current=new AntlrDatatypeRuleToken()] : (this_INT_0= RULE_INT | kw= '*' ) ; + public final AntlrDatatypeRuleToken ruleUpperBound() throws RecognitionException { + AntlrDatatypeRuleToken current = new AntlrDatatypeRuleToken(); + + Token this_INT_0=null; + Token kw=null; + + + enterRule(); + + try { + // InternalProblem.g:1670:2: ( (this_INT_0= RULE_INT | kw= '*' ) ) + // InternalProblem.g:1671:2: (this_INT_0= RULE_INT | kw= '*' ) + { + // InternalProblem.g:1671:2: (this_INT_0= RULE_INT | kw= '*' ) + int alt39=2; + int LA39_0 = input.LA(1); + + if ( (LA39_0==RULE_INT) ) { + alt39=1; + } + else if ( (LA39_0==39) ) { + alt39=2; + } + else { + NoViableAltException nvae = + new NoViableAltException("", 39, 0, input); + + throw nvae; + } + switch (alt39) { + case 1 : + // InternalProblem.g:1672:3: this_INT_0= RULE_INT + { + this_INT_0=(Token)match(input,RULE_INT,FOLLOW_2); + + current.merge(this_INT_0); + + + newLeafNode(this_INT_0, grammarAccess.getUpperBoundAccess().getINTTerminalRuleCall_0()); + + + } + break; + case 2 : + // InternalProblem.g:1680:3: kw= '*' + { + kw=(Token)match(input,39,FOLLOW_2); + + current.merge(kw); + newLeafNode(kw, grammarAccess.getUpperBoundAccess().getAsteriskKeyword_1()); + + + } + break; + + } + + + } + + + leaveRule(); + + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "ruleUpperBound" + + + // $ANTLR start "entryRuleQuotedOrUnquotedId" + // InternalProblem.g:1689:1: entryRuleQuotedOrUnquotedId returns [String current=null] : iv_ruleQuotedOrUnquotedId= ruleQuotedOrUnquotedId EOF ; + public final String entryRuleQuotedOrUnquotedId() throws RecognitionException { + String current = null; + + AntlrDatatypeRuleToken iv_ruleQuotedOrUnquotedId = null; + + + try { + // InternalProblem.g:1689:58: (iv_ruleQuotedOrUnquotedId= ruleQuotedOrUnquotedId EOF ) + // InternalProblem.g:1690:2: iv_ruleQuotedOrUnquotedId= ruleQuotedOrUnquotedId EOF + { + newCompositeNode(grammarAccess.getQuotedOrUnquotedIdRule()); + pushFollow(FOLLOW_1); + iv_ruleQuotedOrUnquotedId=ruleQuotedOrUnquotedId(); + + state._fsp--; + + current =iv_ruleQuotedOrUnquotedId.getText(); + match(input,EOF,FOLLOW_2); + + } + + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "entryRuleQuotedOrUnquotedId" + + + // $ANTLR start "ruleQuotedOrUnquotedId" + // InternalProblem.g:1696:1: ruleQuotedOrUnquotedId returns [AntlrDatatypeRuleToken current=new AntlrDatatypeRuleToken()] : (this_QUOTED_ID_0= RULE_QUOTED_ID | this_Identifier_1= ruleIdentifier ) ; + public final AntlrDatatypeRuleToken ruleQuotedOrUnquotedId() throws RecognitionException { + AntlrDatatypeRuleToken current = new AntlrDatatypeRuleToken(); + + Token this_QUOTED_ID_0=null; + AntlrDatatypeRuleToken this_Identifier_1 = null; + + + + enterRule(); + + try { + // InternalProblem.g:1702:2: ( (this_QUOTED_ID_0= RULE_QUOTED_ID | this_Identifier_1= ruleIdentifier ) ) + // InternalProblem.g:1703:2: (this_QUOTED_ID_0= RULE_QUOTED_ID | this_Identifier_1= ruleIdentifier ) + { + // InternalProblem.g:1703:2: (this_QUOTED_ID_0= RULE_QUOTED_ID | this_Identifier_1= ruleIdentifier ) + int alt40=2; + int LA40_0 = input.LA(1); + + if ( (LA40_0==RULE_QUOTED_ID) ) { + alt40=1; + } + else if ( (LA40_0==RULE_ID||(LA40_0>=40 && LA40_0<=41)) ) { + alt40=2; + } + else { + NoViableAltException nvae = + new NoViableAltException("", 40, 0, input); + + throw nvae; + } + switch (alt40) { + case 1 : + // InternalProblem.g:1704:3: this_QUOTED_ID_0= RULE_QUOTED_ID + { + this_QUOTED_ID_0=(Token)match(input,RULE_QUOTED_ID,FOLLOW_2); + + current.merge(this_QUOTED_ID_0); + + + newLeafNode(this_QUOTED_ID_0, grammarAccess.getQuotedOrUnquotedIdAccess().getQUOTED_IDTerminalRuleCall_0()); + + + } + break; + case 2 : + // InternalProblem.g:1712:3: this_Identifier_1= ruleIdentifier + { + + newCompositeNode(grammarAccess.getQuotedOrUnquotedIdAccess().getIdentifierParserRuleCall_1()); + + pushFollow(FOLLOW_2); + this_Identifier_1=ruleIdentifier(); + + state._fsp--; + + + current.merge(this_Identifier_1); + + + afterParserOrEnumRuleCall(); + + + } + break; + + } + + + } + + + leaveRule(); + + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "ruleQuotedOrUnquotedId" + + + // $ANTLR start "entryRuleQualifiedName" + // InternalProblem.g:1726:1: entryRuleQualifiedName returns [String current=null] : iv_ruleQualifiedName= ruleQualifiedName EOF ; + public final String entryRuleQualifiedName() throws RecognitionException { + String current = null; + + AntlrDatatypeRuleToken iv_ruleQualifiedName = null; + + + try { + // InternalProblem.g:1726:53: (iv_ruleQualifiedName= ruleQualifiedName EOF ) + // InternalProblem.g:1727:2: iv_ruleQualifiedName= ruleQualifiedName EOF + { + newCompositeNode(grammarAccess.getQualifiedNameRule()); + pushFollow(FOLLOW_1); + iv_ruleQualifiedName=ruleQualifiedName(); + + state._fsp--; + + current =iv_ruleQualifiedName.getText(); + match(input,EOF,FOLLOW_2); + + } + + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "entryRuleQualifiedName" + + + // $ANTLR start "ruleQualifiedName" + // InternalProblem.g:1733:1: ruleQualifiedName returns [AntlrDatatypeRuleToken current=new AntlrDatatypeRuleToken()] : (this_QUOTED_ID_0= RULE_QUOTED_ID | (this_Identifier_1= ruleIdentifier (kw= ':' this_Identifier_3= ruleIdentifier )* (kw= ':' this_QUOTED_ID_5= RULE_QUOTED_ID )? ) ) ; + public final AntlrDatatypeRuleToken ruleQualifiedName() throws RecognitionException { + AntlrDatatypeRuleToken current = new AntlrDatatypeRuleToken(); + + Token this_QUOTED_ID_0=null; + Token kw=null; + Token this_QUOTED_ID_5=null; + AntlrDatatypeRuleToken this_Identifier_1 = null; + + AntlrDatatypeRuleToken this_Identifier_3 = null; + + + + enterRule(); + + try { + // InternalProblem.g:1739:2: ( (this_QUOTED_ID_0= RULE_QUOTED_ID | (this_Identifier_1= ruleIdentifier (kw= ':' this_Identifier_3= ruleIdentifier )* (kw= ':' this_QUOTED_ID_5= RULE_QUOTED_ID )? ) ) ) + // InternalProblem.g:1740:2: (this_QUOTED_ID_0= RULE_QUOTED_ID | (this_Identifier_1= ruleIdentifier (kw= ':' this_Identifier_3= ruleIdentifier )* (kw= ':' this_QUOTED_ID_5= RULE_QUOTED_ID )? ) ) + { + // InternalProblem.g:1740:2: (this_QUOTED_ID_0= RULE_QUOTED_ID | (this_Identifier_1= ruleIdentifier (kw= ':' this_Identifier_3= ruleIdentifier )* (kw= ':' this_QUOTED_ID_5= RULE_QUOTED_ID )? ) ) + int alt43=2; + int LA43_0 = input.LA(1); + + if ( (LA43_0==RULE_QUOTED_ID) ) { + alt43=1; + } + else if ( (LA43_0==RULE_ID||(LA43_0>=40 && LA43_0<=41)) ) { + alt43=2; + } + else { + NoViableAltException nvae = + new NoViableAltException("", 43, 0, input); + + throw nvae; + } + switch (alt43) { + case 1 : + // InternalProblem.g:1741:3: this_QUOTED_ID_0= RULE_QUOTED_ID + { + this_QUOTED_ID_0=(Token)match(input,RULE_QUOTED_ID,FOLLOW_2); + + current.merge(this_QUOTED_ID_0); + + + newLeafNode(this_QUOTED_ID_0, grammarAccess.getQualifiedNameAccess().getQUOTED_IDTerminalRuleCall_0()); + + + } + break; + case 2 : + // InternalProblem.g:1749:3: (this_Identifier_1= ruleIdentifier (kw= ':' this_Identifier_3= ruleIdentifier )* (kw= ':' this_QUOTED_ID_5= RULE_QUOTED_ID )? ) + { + // InternalProblem.g:1749:3: (this_Identifier_1= ruleIdentifier (kw= ':' this_Identifier_3= ruleIdentifier )* (kw= ':' this_QUOTED_ID_5= RULE_QUOTED_ID )? ) + // InternalProblem.g:1750:4: this_Identifier_1= ruleIdentifier (kw= ':' this_Identifier_3= ruleIdentifier )* (kw= ':' this_QUOTED_ID_5= RULE_QUOTED_ID )? + { + + newCompositeNode(grammarAccess.getQualifiedNameAccess().getIdentifierParserRuleCall_1_0()); + + pushFollow(FOLLOW_36); + this_Identifier_1=ruleIdentifier(); + + state._fsp--; + + + current.merge(this_Identifier_1); + + + afterParserOrEnumRuleCall(); + + // InternalProblem.g:1760:4: (kw= ':' this_Identifier_3= ruleIdentifier )* + loop41: + do { + int alt41=2; + int LA41_0 = input.LA(1); + + if ( (LA41_0==34) ) { + int LA41_1 = input.LA(2); + + if ( (LA41_1==RULE_ID||(LA41_1>=40 && LA41_1<=41)) ) { + alt41=1; + } + + + } + + + switch (alt41) { + case 1 : + // InternalProblem.g:1761:5: kw= ':' this_Identifier_3= ruleIdentifier + { + kw=(Token)match(input,34,FOLLOW_3); + + current.merge(kw); + newLeafNode(kw, grammarAccess.getQualifiedNameAccess().getColonKeyword_1_1_0()); + + + newCompositeNode(grammarAccess.getQualifiedNameAccess().getIdentifierParserRuleCall_1_1_1()); + + pushFollow(FOLLOW_36); + this_Identifier_3=ruleIdentifier(); + + state._fsp--; + + + current.merge(this_Identifier_3); + + + afterParserOrEnumRuleCall(); + + + } + break; + + default : + break loop41; + } + } while (true); + + // InternalProblem.g:1777:4: (kw= ':' this_QUOTED_ID_5= RULE_QUOTED_ID )? + int alt42=2; + int LA42_0 = input.LA(1); + + if ( (LA42_0==34) ) { + alt42=1; + } + switch (alt42) { + case 1 : + // InternalProblem.g:1778:5: kw= ':' this_QUOTED_ID_5= RULE_QUOTED_ID + { + kw=(Token)match(input,34,FOLLOW_37); + + current.merge(kw); + newLeafNode(kw, grammarAccess.getQualifiedNameAccess().getColonKeyword_1_2_0()); + + this_QUOTED_ID_5=(Token)match(input,RULE_QUOTED_ID,FOLLOW_2); + + current.merge(this_QUOTED_ID_5); + + + newLeafNode(this_QUOTED_ID_5, grammarAccess.getQualifiedNameAccess().getQUOTED_IDTerminalRuleCall_1_2_1()); + + + } + break; + + } + + + } + + + } + break; + + } + + + } + + + leaveRule(); + + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "ruleQualifiedName" + + + // $ANTLR start "entryRuleIdentifier" + // InternalProblem.g:1796:1: entryRuleIdentifier returns [String current=null] : iv_ruleIdentifier= ruleIdentifier EOF ; + public final String entryRuleIdentifier() throws RecognitionException { + String current = null; + + AntlrDatatypeRuleToken iv_ruleIdentifier = null; + + + try { + // InternalProblem.g:1796:50: (iv_ruleIdentifier= ruleIdentifier EOF ) + // InternalProblem.g:1797:2: iv_ruleIdentifier= ruleIdentifier EOF + { + newCompositeNode(grammarAccess.getIdentifierRule()); + pushFollow(FOLLOW_1); + iv_ruleIdentifier=ruleIdentifier(); + + state._fsp--; + + current =iv_ruleIdentifier.getText(); + match(input,EOF,FOLLOW_2); + + } + + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "entryRuleIdentifier" + + + // $ANTLR start "ruleIdentifier" + // InternalProblem.g:1803:1: ruleIdentifier returns [AntlrDatatypeRuleToken current=new AntlrDatatypeRuleToken()] : (this_ID_0= RULE_ID | kw= 'true' | kw= 'false' ) ; + public final AntlrDatatypeRuleToken ruleIdentifier() throws RecognitionException { + AntlrDatatypeRuleToken current = new AntlrDatatypeRuleToken(); + + Token this_ID_0=null; + Token kw=null; + + + enterRule(); + + try { + // InternalProblem.g:1809:2: ( (this_ID_0= RULE_ID | kw= 'true' | kw= 'false' ) ) + // InternalProblem.g:1810:2: (this_ID_0= RULE_ID | kw= 'true' | kw= 'false' ) + { + // InternalProblem.g:1810:2: (this_ID_0= RULE_ID | kw= 'true' | kw= 'false' ) + int alt44=3; + switch ( input.LA(1) ) { + case RULE_ID: + { + alt44=1; + } + break; + case 40: + { + alt44=2; + } + break; + case 41: + { + alt44=3; + } + break; + default: + NoViableAltException nvae = + new NoViableAltException("", 44, 0, input); + + throw nvae; + } + + switch (alt44) { + case 1 : + // InternalProblem.g:1811:3: this_ID_0= RULE_ID + { + this_ID_0=(Token)match(input,RULE_ID,FOLLOW_2); + + current.merge(this_ID_0); + + + newLeafNode(this_ID_0, grammarAccess.getIdentifierAccess().getIDTerminalRuleCall_0()); + + + } + break; + case 2 : + // InternalProblem.g:1819:3: kw= 'true' + { + kw=(Token)match(input,40,FOLLOW_2); + + current.merge(kw); + newLeafNode(kw, grammarAccess.getIdentifierAccess().getTrueKeyword_1()); + + + } + break; + case 3 : + // InternalProblem.g:1825:3: kw= 'false' + { + kw=(Token)match(input,41,FOLLOW_2); + + current.merge(kw); + newLeafNode(kw, grammarAccess.getIdentifierAccess().getFalseKeyword_2()); + + + } + break; + + } + + + } + + + leaveRule(); + + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "ruleIdentifier" + + + // $ANTLR start "ruleLogicValue" + // InternalProblem.g:1834:1: ruleLogicValue returns [Enumerator current=null] : ( (enumLiteral_0= 'true' ) | (enumLiteral_1= 'false' ) | (enumLiteral_2= 'unknown' ) ) ; + public final Enumerator ruleLogicValue() throws RecognitionException { + Enumerator current = null; + + Token enumLiteral_0=null; + Token enumLiteral_1=null; + Token enumLiteral_2=null; + + + enterRule(); + + try { + // InternalProblem.g:1840:2: ( ( (enumLiteral_0= 'true' ) | (enumLiteral_1= 'false' ) | (enumLiteral_2= 'unknown' ) ) ) + // InternalProblem.g:1841:2: ( (enumLiteral_0= 'true' ) | (enumLiteral_1= 'false' ) | (enumLiteral_2= 'unknown' ) ) + { + // InternalProblem.g:1841:2: ( (enumLiteral_0= 'true' ) | (enumLiteral_1= 'false' ) | (enumLiteral_2= 'unknown' ) ) + int alt45=3; + switch ( input.LA(1) ) { + case 40: + { + alt45=1; + } + break; + case 41: + { + alt45=2; + } + break; + case 42: + { + alt45=3; + } + break; + default: + NoViableAltException nvae = + new NoViableAltException("", 45, 0, input); + + throw nvae; + } + + switch (alt45) { + case 1 : + // InternalProblem.g:1842:3: (enumLiteral_0= 'true' ) + { + // InternalProblem.g:1842:3: (enumLiteral_0= 'true' ) + // InternalProblem.g:1843:4: enumLiteral_0= 'true' + { + enumLiteral_0=(Token)match(input,40,FOLLOW_2); + + current = grammarAccess.getLogicValueAccess().getTRUEEnumLiteralDeclaration_0().getEnumLiteral().getInstance(); + newLeafNode(enumLiteral_0, grammarAccess.getLogicValueAccess().getTRUEEnumLiteralDeclaration_0()); + + + } + + + } + break; + case 2 : + // InternalProblem.g:1850:3: (enumLiteral_1= 'false' ) + { + // InternalProblem.g:1850:3: (enumLiteral_1= 'false' ) + // InternalProblem.g:1851:4: enumLiteral_1= 'false' + { + enumLiteral_1=(Token)match(input,41,FOLLOW_2); + + current = grammarAccess.getLogicValueAccess().getFALSEEnumLiteralDeclaration_1().getEnumLiteral().getInstance(); + newLeafNode(enumLiteral_1, grammarAccess.getLogicValueAccess().getFALSEEnumLiteralDeclaration_1()); + + + } + + + } + break; + case 3 : + // InternalProblem.g:1858:3: (enumLiteral_2= 'unknown' ) + { + // InternalProblem.g:1858:3: (enumLiteral_2= 'unknown' ) + // InternalProblem.g:1859:4: enumLiteral_2= 'unknown' + { + enumLiteral_2=(Token)match(input,42,FOLLOW_2); + + current = grammarAccess.getLogicValueAccess().getUNKNOWNEnumLiteralDeclaration_2().getEnumLiteral().getInstance(); + newLeafNode(enumLiteral_2, grammarAccess.getLogicValueAccess().getUNKNOWNEnumLiteralDeclaration_2()); + + + } + + + } + break; + + } + + + } + + + leaveRule(); + + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "ruleLogicValue" + + + // $ANTLR start "ruleShortLogicValue" + // InternalProblem.g:1869:1: ruleShortLogicValue returns [Enumerator current=null] : ( (enumLiteral_0= '!' ) | (enumLiteral_1= '?' ) ) ; + public final Enumerator ruleShortLogicValue() throws RecognitionException { + Enumerator current = null; + + Token enumLiteral_0=null; + Token enumLiteral_1=null; + + + enterRule(); + + try { + // InternalProblem.g:1875:2: ( ( (enumLiteral_0= '!' ) | (enumLiteral_1= '?' ) ) ) + // InternalProblem.g:1876:2: ( (enumLiteral_0= '!' ) | (enumLiteral_1= '?' ) ) + { + // InternalProblem.g:1876:2: ( (enumLiteral_0= '!' ) | (enumLiteral_1= '?' ) ) + int alt46=2; + int LA46_0 = input.LA(1); + + if ( (LA46_0==32) ) { + alt46=1; + } + else if ( (LA46_0==43) ) { + alt46=2; + } + else { + NoViableAltException nvae = + new NoViableAltException("", 46, 0, input); + + throw nvae; + } + switch (alt46) { + case 1 : + // InternalProblem.g:1877:3: (enumLiteral_0= '!' ) + { + // InternalProblem.g:1877:3: (enumLiteral_0= '!' ) + // InternalProblem.g:1878:4: enumLiteral_0= '!' + { + enumLiteral_0=(Token)match(input,32,FOLLOW_2); + + current = grammarAccess.getShortLogicValueAccess().getFALSEEnumLiteralDeclaration_0().getEnumLiteral().getInstance(); + newLeafNode(enumLiteral_0, grammarAccess.getShortLogicValueAccess().getFALSEEnumLiteralDeclaration_0()); + + + } + + + } + break; + case 2 : + // InternalProblem.g:1885:3: (enumLiteral_1= '?' ) + { + // InternalProblem.g:1885:3: (enumLiteral_1= '?' ) + // InternalProblem.g:1886:4: enumLiteral_1= '?' + { + enumLiteral_1=(Token)match(input,43,FOLLOW_2); + + current = grammarAccess.getShortLogicValueAccess().getUNKNOWNEnumLiteralDeclaration_1().getEnumLiteral().getInstance(); + newLeafNode(enumLiteral_1, grammarAccess.getShortLogicValueAccess().getUNKNOWNEnumLiteralDeclaration_1()); + + + } + + + } + break; + + } + + + } + + + leaveRule(); + + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "ruleShortLogicValue" + + // Delegated rules + + + protected DFA34 dfa34 = new DFA34(this); + static final String dfa_1s = "\41\uffff"; + static final String dfa_2s = "\1\4\4\35\1\uffff\2\4\4\21\1\15\4\35\2\4\1\uffff\10\21\1\4\4\21"; + static final String dfa_3s = "\1\53\1\35\3\42\1\uffff\2\51\1\36\7\42\1\35\2\51\1\uffff\1\36\6\42\1\36\1\51\3\42\1\36"; + static final String dfa_4s = "\5\uffff\1\2\15\uffff\1\1\15\uffff"; + static final String dfa_5s = "\41\uffff}>"; + static final String[] dfa_6s = { + "\1\2\1\uffff\1\1\31\uffff\1\5\7\uffff\1\3\1\4\1\uffff\1\5", + "\1\6", + "\1\6\4\uffff\1\7", + "\1\6\4\uffff\1\7", + "\1\6\4\uffff\1\7", + "", + "\1\11\1\uffff\1\10\27\uffff\1\14\11\uffff\1\12\1\13", + "\1\15\1\uffff\1\20\41\uffff\1\16\1\17", + "\1\21\14\uffff\1\14", + "\1\21\14\uffff\1\14\3\uffff\1\22", + "\1\21\14\uffff\1\14\3\uffff\1\22", + "\1\21\14\uffff\1\14\3\uffff\1\22", + "\1\5\24\uffff\1\23", + "\1\6\4\uffff\1\7", + "\1\6\4\uffff\1\7", + "\1\6\4\uffff\1\7", + "\1\6", + "\1\25\1\uffff\1\24\41\uffff\1\26\1\27", + "\1\30\1\uffff\1\33\41\uffff\1\31\1\32", + "", + "\1\21\14\uffff\1\14", + "\1\21\14\uffff\1\14\3\uffff\1\34", + "\1\21\14\uffff\1\14\3\uffff\1\34", + "\1\21\14\uffff\1\14\3\uffff\1\34", + "\1\21\14\uffff\1\14\3\uffff\1\22", + "\1\21\14\uffff\1\14\3\uffff\1\22", + "\1\21\14\uffff\1\14\3\uffff\1\22", + "\1\21\14\uffff\1\14", + "\1\35\1\uffff\1\40\41\uffff\1\36\1\37", + "\1\21\14\uffff\1\14\3\uffff\1\34", + "\1\21\14\uffff\1\14\3\uffff\1\34", + "\1\21\14\uffff\1\14\3\uffff\1\34", + "\1\21\14\uffff\1\14" + }; + + static final short[] dfa_1 = DFA.unpackEncodedString(dfa_1s); + static final char[] dfa_2 = DFA.unpackEncodedStringToUnsignedChars(dfa_2s); + static final char[] dfa_3 = DFA.unpackEncodedStringToUnsignedChars(dfa_3s); + static final short[] dfa_4 = DFA.unpackEncodedString(dfa_4s); + static final short[] dfa_5 = DFA.unpackEncodedString(dfa_5s); + static final short[][] dfa_6 = unpackEncodedStringArray(dfa_6s); + + class DFA34 extends DFA { + + public DFA34(BaseRecognizer recognizer) { + this.recognizer = recognizer; + this.decisionNumber = 34; + this.eot = dfa_1; + this.eof = dfa_1; + this.min = dfa_2; + this.max = dfa_3; + this.accept = dfa_4; + this.special = dfa_5; + this.transition = dfa_6; + } + public String getDescription() { + return "1138:3: ( ( ( ( ruleQualifiedName ) ) otherlv_1= '(' ( ( ( ruleQualifiedName ) ) (otherlv_3= ',' ( ( ruleQualifiedName ) ) )* )? otherlv_5= ')' otherlv_6= ':' ( (lv_value_7_0= ruleLogicValue ) ) ) | ( ( (lv_value_8_0= ruleShortLogicValue ) )? ( ( ruleQualifiedName ) ) otherlv_10= '(' ( ( ( ruleQualifiedName ) ) (otherlv_12= ',' ( ( ruleQualifiedName ) ) )* )? otherlv_14= ')' ) )"; + } + } + + + public static final BitSet FOLLOW_1 = new BitSet(new long[]{0x0000000000000000L}); + public static final BitSet FOLLOW_2 = new BitSet(new long[]{0x0000000000000002L}); + public static final BitSet FOLLOW_3 = new BitSet(new long[]{0x0000030000000010L}); + public static final BitSet FOLLOW_4 = new BitSet(new long[]{0x0000000000002000L}); + public static final BitSet FOLLOW_5 = new BitSet(new long[]{0x00000B091820C052L}); + public static final BitSet FOLLOW_6 = new BitSet(new long[]{0x0000000000008000L}); + public static final BitSet FOLLOW_7 = new BitSet(new long[]{0x0000000000052000L}); + public static final BitSet FOLLOW_8 = new BitSet(new long[]{0x0000030000000050L}); + public static final BitSet FOLLOW_9 = new BitSet(new long[]{0x0000000000062000L}); + public static final BitSet FOLLOW_10 = new BitSet(new long[]{0x0000030000D00050L}); + public static final BitSet FOLLOW_11 = new BitSet(new long[]{0x0000030000D80050L}); + public static final BitSet FOLLOW_12 = new BitSet(new long[]{0x0000000000042000L}); + public static final BitSet FOLLOW_13 = new BitSet(new long[]{0x0000030000100050L}); + public static final BitSet FOLLOW_14 = new BitSet(new long[]{0x00000000001A0000L}); + public static final BitSet FOLLOW_15 = new BitSet(new long[]{0x0000000000100000L}); + public static final BitSet FOLLOW_16 = new BitSet(new long[]{0x0000030001000010L}); + public static final BitSet FOLLOW_17 = new BitSet(new long[]{0x0000000000000020L}); + public static final BitSet FOLLOW_18 = new BitSet(new long[]{0x0000000002000000L}); + public static final BitSet FOLLOW_19 = new BitSet(new long[]{0x0000000004000002L}); + public static final BitSet FOLLOW_20 = new BitSet(new long[]{0x0000030010000010L}); + public static final BitSet FOLLOW_21 = new BitSet(new long[]{0x0000000020000000L}); + public static final BitSet FOLLOW_22 = new BitSet(new long[]{0x0000030040000050L}); + public static final BitSet FOLLOW_23 = new BitSet(new long[]{0x0000000040020000L}); + public static final BitSet FOLLOW_24 = new BitSet(new long[]{0x0000000080002000L}); + public static final BitSet FOLLOW_25 = new BitSet(new long[]{0x0000030100000050L}); + public static final BitSet FOLLOW_26 = new BitSet(new long[]{0x0000000000082000L}); + public static final BitSet FOLLOW_27 = new BitSet(new long[]{0x0000000000020002L}); + public static final BitSet FOLLOW_28 = new BitSet(new long[]{0x0000000220000000L}); + public static final BitSet FOLLOW_29 = new BitSet(new long[]{0x0000000400000000L}); + public static final BitSet FOLLOW_30 = new BitSet(new long[]{0x0000070000000000L}); + public static final BitSet FOLLOW_31 = new BitSet(new long[]{0x0000000000000010L}); + public static final BitSet FOLLOW_32 = new BitSet(new long[]{0x0000000000022000L}); + public static final BitSet FOLLOW_33 = new BitSet(new long[]{0x0000003000000000L}); + public static final BitSet FOLLOW_34 = new BitSet(new long[]{0x0000004000000000L}); + public static final BitSet FOLLOW_35 = new BitSet(new long[]{0x0000008000000020L}); + public static final BitSet FOLLOW_36 = new BitSet(new long[]{0x0000000400000002L}); + public static final BitSet FOLLOW_37 = new BitSet(new long[]{0x0000000000000040L}); + +} \ No newline at end of file diff --git a/language/src/main/xtext-gen/org/eclipse/viatra/solver/language/scoping/AbstractProblemScopeProvider.java b/language/src/main/xtext-gen/org/eclipse/viatra/solver/language/scoping/AbstractProblemScopeProvider.java new file mode 100644 index 00000000..5b024d47 --- /dev/null +++ b/language/src/main/xtext-gen/org/eclipse/viatra/solver/language/scoping/AbstractProblemScopeProvider.java @@ -0,0 +1,9 @@ +/* + * generated by Xtext 2.26.0.M1 + */ +package org.eclipse.viatra.solver.language.scoping; + +import org.eclipse.xtext.scoping.impl.DelegatingScopeProvider; + +public abstract class AbstractProblemScopeProvider extends DelegatingScopeProvider { +} diff --git a/language/src/main/xtext-gen/org/eclipse/viatra/solver/language/serializer/ProblemSemanticSequencer.java b/language/src/main/xtext-gen/org/eclipse/viatra/solver/language/serializer/ProblemSemanticSequencer.java new file mode 100644 index 00000000..cb44c31f --- /dev/null +++ b/language/src/main/xtext-gen/org/eclipse/viatra/solver/language/serializer/ProblemSemanticSequencer.java @@ -0,0 +1,369 @@ +/* + * generated by Xtext 2.26.0.M1 + */ +package org.eclipse.viatra.solver.language.serializer; + +import com.google.inject.Inject; +import java.util.Set; +import org.eclipse.emf.ecore.EObject; +import org.eclipse.emf.ecore.EPackage; +import org.eclipse.viatra.solver.language.model.problem.Argument; +import org.eclipse.viatra.solver.language.model.problem.Assertion; +import org.eclipse.viatra.solver.language.model.problem.Atom; +import org.eclipse.viatra.solver.language.model.problem.ClassDeclaration; +import org.eclipse.viatra.solver.language.model.problem.Conjunction; +import org.eclipse.viatra.solver.language.model.problem.EnumDeclaration; +import org.eclipse.viatra.solver.language.model.problem.ExactMultiplicity; +import org.eclipse.viatra.solver.language.model.problem.NegativeLiteral; +import org.eclipse.viatra.solver.language.model.problem.Node; +import org.eclipse.viatra.solver.language.model.problem.PredicateDefinition; +import org.eclipse.viatra.solver.language.model.problem.Problem; +import org.eclipse.viatra.solver.language.model.problem.ProblemPackage; +import org.eclipse.viatra.solver.language.model.problem.RangeMultiplicity; +import org.eclipse.viatra.solver.language.model.problem.ReferenceDeclaration; +import org.eclipse.viatra.solver.language.model.problem.ScopeDeclaration; +import org.eclipse.viatra.solver.language.model.problem.TypeScope; +import org.eclipse.viatra.solver.language.model.problem.UnboundedMultiplicity; +import org.eclipse.viatra.solver.language.services.ProblemGrammarAccess; +import org.eclipse.xtext.Action; +import org.eclipse.xtext.Parameter; +import org.eclipse.xtext.ParserRule; +import org.eclipse.xtext.serializer.ISerializationContext; +import org.eclipse.xtext.serializer.acceptor.SequenceFeeder; +import org.eclipse.xtext.serializer.sequencer.AbstractDelegatingSemanticSequencer; +import org.eclipse.xtext.serializer.sequencer.ITransientValueService.ValueTransient; + +@SuppressWarnings("all") +public class ProblemSemanticSequencer extends AbstractDelegatingSemanticSequencer { + + @Inject + private ProblemGrammarAccess grammarAccess; + + @Override + public void sequence(ISerializationContext context, EObject semanticObject) { + EPackage epackage = semanticObject.eClass().getEPackage(); + ParserRule rule = context.getParserRule(); + Action action = context.getAssignedAction(); + Set parameters = context.getEnabledBooleanParameters(); + if (epackage == ProblemPackage.eINSTANCE) + switch (semanticObject.eClass().getClassifierID()) { + case ProblemPackage.ARGUMENT: + sequence_Argument(context, (Argument) semanticObject); + return; + case ProblemPackage.ASSERTION: + sequence_Assertion(context, (Assertion) semanticObject); + return; + case ProblemPackage.ATOM: + sequence_Atom(context, (Atom) semanticObject); + return; + case ProblemPackage.CLASS_DECLARATION: + sequence_ClassDeclaration(context, (ClassDeclaration) semanticObject); + return; + case ProblemPackage.CONJUNCTION: + sequence_Conjunction(context, (Conjunction) semanticObject); + return; + case ProblemPackage.ENUM_DECLARATION: + sequence_EnumDeclaration(context, (EnumDeclaration) semanticObject); + return; + case ProblemPackage.EXACT_MULTIPLICITY: + sequence_ExactMultiplicity(context, (ExactMultiplicity) semanticObject); + return; + case ProblemPackage.NEGATIVE_LITERAL: + sequence_NegativeLiteral(context, (NegativeLiteral) semanticObject); + return; + case ProblemPackage.NODE: + sequence_EnumLiteral(context, (Node) semanticObject); + return; + case ProblemPackage.PARAMETER: + sequence_Parameter(context, (org.eclipse.viatra.solver.language.model.problem.Parameter) semanticObject); + return; + case ProblemPackage.PREDICATE_DEFINITION: + sequence_PredicateDefinition(context, (PredicateDefinition) semanticObject); + return; + case ProblemPackage.PROBLEM: + sequence_Problem(context, (Problem) semanticObject); + return; + case ProblemPackage.RANGE_MULTIPLICITY: + sequence_RangeMultiplicity(context, (RangeMultiplicity) semanticObject); + return; + case ProblemPackage.REFERENCE_DECLARATION: + sequence_ReferenceDeclaration(context, (ReferenceDeclaration) semanticObject); + return; + case ProblemPackage.SCOPE_DECLARATION: + sequence_ScopeDeclaration(context, (ScopeDeclaration) semanticObject); + return; + case ProblemPackage.TYPE_SCOPE: + sequence_TypeScope(context, (TypeScope) semanticObject); + return; + case ProblemPackage.UNBOUNDED_MULTIPLICITY: + sequence_UnboundedMultiplicity(context, (UnboundedMultiplicity) semanticObject); + return; + } + if (errorAcceptor != null) + errorAcceptor.accept(diagnosticProvider.createInvalidContextOrTypeDiagnostic(semanticObject, context)); + } + + /** + * Contexts: + * Argument returns Argument + * + * Constraint: + * variableOrNode=[VariableOrNode|QualifiedName] + */ + protected void sequence_Argument(ISerializationContext context, Argument semanticObject) { + if (errorAcceptor != null) { + if (transientValues.isValueTransient(semanticObject, ProblemPackage.Literals.ARGUMENT__VARIABLE_OR_NODE) == ValueTransient.YES) + errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, ProblemPackage.Literals.ARGUMENT__VARIABLE_OR_NODE)); + } + SequenceFeeder feeder = createSequencerFeeder(context, semanticObject); + feeder.accept(grammarAccess.getArgumentAccess().getVariableOrNodeVariableOrNodeQualifiedNameParserRuleCall_0_1(), semanticObject.eGet(ProblemPackage.Literals.ARGUMENT__VARIABLE_OR_NODE, false)); + feeder.finish(); + } + + + /** + * Contexts: + * Statement returns Assertion + * Assertion returns Assertion + * + * Constraint: + * ( + * (relation=[Relation|QualifiedName] (arguments+=[Node|QualifiedName] arguments+=[Node|QualifiedName]*)? value=LogicValue) | + * (value=ShortLogicValue? relation=[Relation|QualifiedName] (arguments+=[Node|QualifiedName] arguments+=[Node|QualifiedName]*)?) + * ) + */ + protected void sequence_Assertion(ISerializationContext context, Assertion semanticObject) { + genericSequencer.createSequence(context, semanticObject); + } + + + /** + * Contexts: + * Literal returns Atom + * Atom returns Atom + * + * Constraint: + * (relation=[Relation|QualifiedName] transitiveClosure?='+'? (arguments+=Argument arguments+=Argument*)?) + */ + protected void sequence_Atom(ISerializationContext context, Atom semanticObject) { + genericSequencer.createSequence(context, semanticObject); + } + + + /** + * Contexts: + * Statement returns ClassDeclaration + * ClassDeclaration returns ClassDeclaration + * + * Constraint: + * ( + * abstract?='abstract'? + * name=Identifier + * (superTypes+=[Relation|QualifiedName] superTypes+=[Relation|QualifiedName]*)? + * referenceDeclarations+=ReferenceDeclaration* + * ) + */ + protected void sequence_ClassDeclaration(ISerializationContext context, ClassDeclaration semanticObject) { + genericSequencer.createSequence(context, semanticObject); + } + + + /** + * Contexts: + * Conjunction returns Conjunction + * + * Constraint: + * (literals+=Literal literals+=Literal*) + */ + protected void sequence_Conjunction(ISerializationContext context, Conjunction semanticObject) { + genericSequencer.createSequence(context, semanticObject); + } + + + /** + * Contexts: + * Statement returns EnumDeclaration + * EnumDeclaration returns EnumDeclaration + * + * Constraint: + * (name=Identifier (literals+=EnumLiteral literals+=EnumLiteral*)?) + */ + protected void sequence_EnumDeclaration(ISerializationContext context, EnumDeclaration semanticObject) { + genericSequencer.createSequence(context, semanticObject); + } + + + /** + * Contexts: + * EnumLiteral returns Node + * + * Constraint: + * name=QuotedOrUnquotedId + */ + protected void sequence_EnumLiteral(ISerializationContext context, Node semanticObject) { + if (errorAcceptor != null) { + if (transientValues.isValueTransient(semanticObject, ProblemPackage.Literals.NAMED_ELEMENT__NAME) == ValueTransient.YES) + errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, ProblemPackage.Literals.NAMED_ELEMENT__NAME)); + } + SequenceFeeder feeder = createSequencerFeeder(context, semanticObject); + feeder.accept(grammarAccess.getEnumLiteralAccess().getNameQuotedOrUnquotedIdParserRuleCall_0(), semanticObject.getName()); + feeder.finish(); + } + + + /** + * Contexts: + * Multiplicity returns ExactMultiplicity + * DefiniteMultiplicity returns ExactMultiplicity + * ExactMultiplicity returns ExactMultiplicity + * + * Constraint: + * exactValue=INT + */ + protected void sequence_ExactMultiplicity(ISerializationContext context, ExactMultiplicity semanticObject) { + if (errorAcceptor != null) { + if (transientValues.isValueTransient(semanticObject, ProblemPackage.Literals.EXACT_MULTIPLICITY__EXACT_VALUE) == ValueTransient.YES) + errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, ProblemPackage.Literals.EXACT_MULTIPLICITY__EXACT_VALUE)); + } + SequenceFeeder feeder = createSequencerFeeder(context, semanticObject); + feeder.accept(grammarAccess.getExactMultiplicityAccess().getExactValueINTTerminalRuleCall_0(), semanticObject.getExactValue()); + feeder.finish(); + } + + + /** + * Contexts: + * Literal returns NegativeLiteral + * NegativeLiteral returns NegativeLiteral + * + * Constraint: + * atom=Atom + */ + protected void sequence_NegativeLiteral(ISerializationContext context, NegativeLiteral semanticObject) { + if (errorAcceptor != null) { + if (transientValues.isValueTransient(semanticObject, ProblemPackage.Literals.NEGATIVE_LITERAL__ATOM) == ValueTransient.YES) + errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, ProblemPackage.Literals.NEGATIVE_LITERAL__ATOM)); + } + SequenceFeeder feeder = createSequencerFeeder(context, semanticObject); + feeder.accept(grammarAccess.getNegativeLiteralAccess().getAtomAtomParserRuleCall_1_0(), semanticObject.getAtom()); + feeder.finish(); + } + + + /** + * Contexts: + * Parameter returns Parameter + * + * Constraint: + * (parameterType=[Relation|QualifiedName]? name=Identifier) + */ + protected void sequence_Parameter(ISerializationContext context, org.eclipse.viatra.solver.language.model.problem.Parameter semanticObject) { + genericSequencer.createSequence(context, semanticObject); + } + + + /** + * Contexts: + * Statement returns PredicateDefinition + * PredicateDefinition returns PredicateDefinition + * + * Constraint: + * (error?='error'? name=Identifier (parameters+=Parameter parameters+=Parameter*)? (bodies+=Conjunction bodies+=Conjunction*)?) + */ + protected void sequence_PredicateDefinition(ISerializationContext context, PredicateDefinition semanticObject) { + genericSequencer.createSequence(context, semanticObject); + } + + + /** + * Contexts: + * Problem returns Problem + * + * Constraint: + * ((name=Identifier statements+=Statement+) | statements+=Statement+)? + */ + protected void sequence_Problem(ISerializationContext context, Problem semanticObject) { + genericSequencer.createSequence(context, semanticObject); + } + + + /** + * Contexts: + * Multiplicity returns RangeMultiplicity + * DefiniteMultiplicity returns RangeMultiplicity + * RangeMultiplicity returns RangeMultiplicity + * + * Constraint: + * (lowerBound=INT upperBound=UpperBound) + */ + protected void sequence_RangeMultiplicity(ISerializationContext context, RangeMultiplicity semanticObject) { + if (errorAcceptor != null) { + if (transientValues.isValueTransient(semanticObject, ProblemPackage.Literals.RANGE_MULTIPLICITY__LOWER_BOUND) == ValueTransient.YES) + errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, ProblemPackage.Literals.RANGE_MULTIPLICITY__LOWER_BOUND)); + if (transientValues.isValueTransient(semanticObject, ProblemPackage.Literals.RANGE_MULTIPLICITY__UPPER_BOUND) == ValueTransient.YES) + errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, ProblemPackage.Literals.RANGE_MULTIPLICITY__UPPER_BOUND)); + } + SequenceFeeder feeder = createSequencerFeeder(context, semanticObject); + feeder.accept(grammarAccess.getRangeMultiplicityAccess().getLowerBoundINTTerminalRuleCall_0_0(), semanticObject.getLowerBound()); + feeder.accept(grammarAccess.getRangeMultiplicityAccess().getUpperBoundUpperBoundParserRuleCall_2_0(), semanticObject.getUpperBound()); + feeder.finish(); + } + + + /** + * Contexts: + * ReferenceDeclaration returns ReferenceDeclaration + * + * Constraint: + * ( + * containment?='contains'? + * referenceType=[Relation|QualifiedName] + * multiplicity=Multiplicity? + * name=Identifier + * opposite=[ReferenceDeclaration|QualifiedName]? + * ) + */ + protected void sequence_ReferenceDeclaration(ISerializationContext context, ReferenceDeclaration semanticObject) { + genericSequencer.createSequence(context, semanticObject); + } + + + /** + * Contexts: + * Statement returns ScopeDeclaration + * ScopeDeclaration returns ScopeDeclaration + * + * Constraint: + * (typeScopes+=TypeScope typeScopes+=TypeScope*) + */ + protected void sequence_ScopeDeclaration(ISerializationContext context, ScopeDeclaration semanticObject) { + genericSequencer.createSequence(context, semanticObject); + } + + + /** + * Contexts: + * TypeScope returns TypeScope + * + * Constraint: + * (targetType=[ClassDeclaration|ID] increment?='+='? multiplicity=DefiniteMultiplicity) + */ + protected void sequence_TypeScope(ISerializationContext context, TypeScope semanticObject) { + genericSequencer.createSequence(context, semanticObject); + } + + + /** + * Contexts: + * Multiplicity returns UnboundedMultiplicity + * UnboundedMultiplicity returns UnboundedMultiplicity + * + * Constraint: + * {UnboundedMultiplicity} + */ + protected void sequence_UnboundedMultiplicity(ISerializationContext context, UnboundedMultiplicity semanticObject) { + genericSequencer.createSequence(context, semanticObject); + } + + +} diff --git a/language/src/main/xtext-gen/org/eclipse/viatra/solver/language/serializer/ProblemSyntacticSequencer.java b/language/src/main/xtext-gen/org/eclipse/viatra/solver/language/serializer/ProblemSyntacticSequencer.java new file mode 100644 index 00000000..3f0a3f05 --- /dev/null +++ b/language/src/main/xtext-gen/org/eclipse/viatra/solver/language/serializer/ProblemSyntacticSequencer.java @@ -0,0 +1,139 @@ +/* + * generated by Xtext 2.26.0.M1 + */ +package org.eclipse.viatra.solver.language.serializer; + +import com.google.inject.Inject; +import java.util.List; +import org.eclipse.emf.ecore.EObject; +import org.eclipse.viatra.solver.language.services.ProblemGrammarAccess; +import org.eclipse.xtext.IGrammarAccess; +import org.eclipse.xtext.RuleCall; +import org.eclipse.xtext.nodemodel.INode; +import org.eclipse.xtext.serializer.analysis.GrammarAlias.AbstractElementAlias; +import org.eclipse.xtext.serializer.analysis.GrammarAlias.AlternativeAlias; +import org.eclipse.xtext.serializer.analysis.GrammarAlias.GroupAlias; +import org.eclipse.xtext.serializer.analysis.GrammarAlias.TokenAlias; +import org.eclipse.xtext.serializer.analysis.ISyntacticSequencerPDAProvider.ISynNavigable; +import org.eclipse.xtext.serializer.analysis.ISyntacticSequencerPDAProvider.ISynTransition; +import org.eclipse.xtext.serializer.sequencer.AbstractSyntacticSequencer; + +@SuppressWarnings("all") +public class ProblemSyntacticSequencer extends AbstractSyntacticSequencer { + + protected ProblemGrammarAccess grammarAccess; + protected AbstractElementAlias match_ClassDeclaration_FullStopKeyword_4_1_or___LeftCurlyBracketKeyword_4_0_0_RightCurlyBracketKeyword_4_0_2__; + protected AbstractElementAlias match_ClassDeclaration_SemicolonKeyword_4_0_1_1_q; + protected AbstractElementAlias match_EnumDeclaration_FullStopKeyword_2_1_or___LeftCurlyBracketKeyword_2_0_0_RightCurlyBracketKeyword_2_0_2__; + protected AbstractElementAlias match_EnumDeclaration___CommaKeyword_2_0_1_2_0_or_SemicolonKeyword_2_0_1_2_1__q; + protected AbstractElementAlias match_PredicateDefinition_PredKeyword_0_0_1_q; + protected AbstractElementAlias match_ReferenceDeclaration_RefersKeyword_0_1_q; + + @Inject + protected void init(IGrammarAccess access) { + grammarAccess = (ProblemGrammarAccess) access; + match_ClassDeclaration_FullStopKeyword_4_1_or___LeftCurlyBracketKeyword_4_0_0_RightCurlyBracketKeyword_4_0_2__ = new AlternativeAlias(false, false, new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getClassDeclarationAccess().getLeftCurlyBracketKeyword_4_0_0()), new TokenAlias(false, false, grammarAccess.getClassDeclarationAccess().getRightCurlyBracketKeyword_4_0_2())), new TokenAlias(false, false, grammarAccess.getClassDeclarationAccess().getFullStopKeyword_4_1())); + match_ClassDeclaration_SemicolonKeyword_4_0_1_1_q = new TokenAlias(false, true, grammarAccess.getClassDeclarationAccess().getSemicolonKeyword_4_0_1_1()); + match_EnumDeclaration_FullStopKeyword_2_1_or___LeftCurlyBracketKeyword_2_0_0_RightCurlyBracketKeyword_2_0_2__ = new AlternativeAlias(false, false, new GroupAlias(false, false, new TokenAlias(false, false, grammarAccess.getEnumDeclarationAccess().getLeftCurlyBracketKeyword_2_0_0()), new TokenAlias(false, false, grammarAccess.getEnumDeclarationAccess().getRightCurlyBracketKeyword_2_0_2())), new TokenAlias(false, false, grammarAccess.getEnumDeclarationAccess().getFullStopKeyword_2_1())); + match_EnumDeclaration___CommaKeyword_2_0_1_2_0_or_SemicolonKeyword_2_0_1_2_1__q = new AlternativeAlias(false, true, new TokenAlias(false, false, grammarAccess.getEnumDeclarationAccess().getCommaKeyword_2_0_1_2_0()), new TokenAlias(false, false, grammarAccess.getEnumDeclarationAccess().getSemicolonKeyword_2_0_1_2_1())); + match_PredicateDefinition_PredKeyword_0_0_1_q = new TokenAlias(false, true, grammarAccess.getPredicateDefinitionAccess().getPredKeyword_0_0_1()); + match_ReferenceDeclaration_RefersKeyword_0_1_q = new TokenAlias(false, true, grammarAccess.getReferenceDeclarationAccess().getRefersKeyword_0_1()); + } + + @Override + protected String getUnassignedRuleCallToken(EObject semanticObject, RuleCall ruleCall, INode node) { + return ""; + } + + + @Override + protected void emitUnassignedTokens(EObject semanticObject, ISynTransition transition, INode fromNode, INode toNode) { + if (transition.getAmbiguousSyntaxes().isEmpty()) return; + List transitionNodes = collectNodes(fromNode, toNode); + for (AbstractElementAlias syntax : transition.getAmbiguousSyntaxes()) { + List syntaxNodes = getNodesFor(transitionNodes, syntax); + if (match_ClassDeclaration_FullStopKeyword_4_1_or___LeftCurlyBracketKeyword_4_0_0_RightCurlyBracketKeyword_4_0_2__.equals(syntax)) + emit_ClassDeclaration_FullStopKeyword_4_1_or___LeftCurlyBracketKeyword_4_0_0_RightCurlyBracketKeyword_4_0_2__(semanticObject, getLastNavigableState(), syntaxNodes); + else if (match_ClassDeclaration_SemicolonKeyword_4_0_1_1_q.equals(syntax)) + emit_ClassDeclaration_SemicolonKeyword_4_0_1_1_q(semanticObject, getLastNavigableState(), syntaxNodes); + else if (match_EnumDeclaration_FullStopKeyword_2_1_or___LeftCurlyBracketKeyword_2_0_0_RightCurlyBracketKeyword_2_0_2__.equals(syntax)) + emit_EnumDeclaration_FullStopKeyword_2_1_or___LeftCurlyBracketKeyword_2_0_0_RightCurlyBracketKeyword_2_0_2__(semanticObject, getLastNavigableState(), syntaxNodes); + else if (match_EnumDeclaration___CommaKeyword_2_0_1_2_0_or_SemicolonKeyword_2_0_1_2_1__q.equals(syntax)) + emit_EnumDeclaration___CommaKeyword_2_0_1_2_0_or_SemicolonKeyword_2_0_1_2_1__q(semanticObject, getLastNavigableState(), syntaxNodes); + else if (match_PredicateDefinition_PredKeyword_0_0_1_q.equals(syntax)) + emit_PredicateDefinition_PredKeyword_0_0_1_q(semanticObject, getLastNavigableState(), syntaxNodes); + else if (match_ReferenceDeclaration_RefersKeyword_0_1_q.equals(syntax)) + emit_ReferenceDeclaration_RefersKeyword_0_1_q(semanticObject, getLastNavigableState(), syntaxNodes); + else acceptNodes(getLastNavigableState(), syntaxNodes); + } + } + + /** + * Ambiguous syntax: + * ('{' '}') | '.' + * + * This ambiguous syntax occurs at: + * name=Identifier (ambiguity) (rule end) + * superTypes+=[Relation|QualifiedName] (ambiguity) (rule end) + */ + protected void emit_ClassDeclaration_FullStopKeyword_4_1_or___LeftCurlyBracketKeyword_4_0_0_RightCurlyBracketKeyword_4_0_2__(EObject semanticObject, ISynNavigable transition, List nodes) { + acceptNodes(transition, nodes); + } + + /** + * Ambiguous syntax: + * ';'? + * + * This ambiguous syntax occurs at: + * referenceDeclarations+=ReferenceDeclaration (ambiguity) '}' (rule end) + * referenceDeclarations+=ReferenceDeclaration (ambiguity) referenceDeclarations+=ReferenceDeclaration + */ + protected void emit_ClassDeclaration_SemicolonKeyword_4_0_1_1_q(EObject semanticObject, ISynNavigable transition, List nodes) { + acceptNodes(transition, nodes); + } + + /** + * Ambiguous syntax: + * ('{' '}') | '.' + * + * This ambiguous syntax occurs at: + * name=Identifier (ambiguity) (rule end) + */ + protected void emit_EnumDeclaration_FullStopKeyword_2_1_or___LeftCurlyBracketKeyword_2_0_0_RightCurlyBracketKeyword_2_0_2__(EObject semanticObject, ISynNavigable transition, List nodes) { + acceptNodes(transition, nodes); + } + + /** + * Ambiguous syntax: + * (',' | ';')? + * + * This ambiguous syntax occurs at: + * literals+=EnumLiteral (ambiguity) '}' (rule end) + */ + protected void emit_EnumDeclaration___CommaKeyword_2_0_1_2_0_or_SemicolonKeyword_2_0_1_2_1__q(EObject semanticObject, ISynNavigable transition, List nodes) { + acceptNodes(transition, nodes); + } + + /** + * Ambiguous syntax: + * 'pred'? + * + * This ambiguous syntax occurs at: + * error?='error' (ambiguity) name=Identifier + */ + protected void emit_PredicateDefinition_PredKeyword_0_0_1_q(EObject semanticObject, ISynNavigable transition, List nodes) { + acceptNodes(transition, nodes); + } + + /** + * Ambiguous syntax: + * 'refers'? + * + * This ambiguous syntax occurs at: + * (rule start) (ambiguity) referenceType=[Relation|QualifiedName] + */ + protected void emit_ReferenceDeclaration_RefersKeyword_0_1_q(EObject semanticObject, ISynNavigable transition, List nodes) { + acceptNodes(transition, nodes); + } + +} diff --git a/language/src/main/xtext-gen/org/eclipse/viatra/solver/language/services/ProblemGrammarAccess.java b/language/src/main/xtext-gen/org/eclipse/viatra/solver/language/services/ProblemGrammarAccess.java new file mode 100644 index 00000000..4368036b --- /dev/null +++ b/language/src/main/xtext-gen/org/eclipse/viatra/solver/language/services/ProblemGrammarAccess.java @@ -0,0 +1,1706 @@ +/* + * generated by Xtext 2.26.0.M1 + */ +package org.eclipse.viatra.solver.language.services; + +import com.google.inject.Inject; +import com.google.inject.Singleton; +import java.util.List; +import org.eclipse.xtext.Action; +import org.eclipse.xtext.Alternatives; +import org.eclipse.xtext.Assignment; +import org.eclipse.xtext.CrossReference; +import org.eclipse.xtext.EnumLiteralDeclaration; +import org.eclipse.xtext.EnumRule; +import org.eclipse.xtext.Grammar; +import org.eclipse.xtext.GrammarUtil; +import org.eclipse.xtext.Group; +import org.eclipse.xtext.Keyword; +import org.eclipse.xtext.ParserRule; +import org.eclipse.xtext.RuleCall; +import org.eclipse.xtext.TerminalRule; +import org.eclipse.xtext.common.services.TerminalsGrammarAccess; +import org.eclipse.xtext.service.AbstractElementFinder; +import org.eclipse.xtext.service.GrammarProvider; + +@Singleton +public class ProblemGrammarAccess extends AbstractElementFinder.AbstractGrammarElementFinder { + + public class ProblemElements extends AbstractParserRuleElementFinder { + private final ParserRule rule = (ParserRule) GrammarUtil.findRuleForName(getGrammar(), "org.eclipse.viatra.solver.language.Problem.Problem"); + private final Group cGroup = (Group)rule.eContents().get(1); + private final Group cGroup_0 = (Group)cGroup.eContents().get(0); + private final Keyword cProblemKeyword_0_0 = (Keyword)cGroup_0.eContents().get(0); + private final Assignment cNameAssignment_0_1 = (Assignment)cGroup_0.eContents().get(1); + private final RuleCall cNameIdentifierParserRuleCall_0_1_0 = (RuleCall)cNameAssignment_0_1.eContents().get(0); + private final Keyword cFullStopKeyword_0_2 = (Keyword)cGroup_0.eContents().get(2); + private final Assignment cStatementsAssignment_1 = (Assignment)cGroup.eContents().get(1); + private final RuleCall cStatementsStatementParserRuleCall_1_0 = (RuleCall)cStatementsAssignment_1.eContents().get(0); + + //Problem: + // ("problem" name=Identifier ".")? + // statements+=Statement*; + @Override public ParserRule getRule() { return rule; } + + //("problem" name=Identifier ".")? + //statements+=Statement* + public Group getGroup() { return cGroup; } + + //("problem" name=Identifier ".")? + public Group getGroup_0() { return cGroup_0; } + + //"problem" + public Keyword getProblemKeyword_0_0() { return cProblemKeyword_0_0; } + + //name=Identifier + public Assignment getNameAssignment_0_1() { return cNameAssignment_0_1; } + + //Identifier + public RuleCall getNameIdentifierParserRuleCall_0_1_0() { return cNameIdentifierParserRuleCall_0_1_0; } + + //"." + public Keyword getFullStopKeyword_0_2() { return cFullStopKeyword_0_2; } + + //statements+=Statement* + public Assignment getStatementsAssignment_1() { return cStatementsAssignment_1; } + + //Statement + public RuleCall getStatementsStatementParserRuleCall_1_0() { return cStatementsStatementParserRuleCall_1_0; } + } + public class StatementElements extends AbstractParserRuleElementFinder { + private final ParserRule rule = (ParserRule) GrammarUtil.findRuleForName(getGrammar(), "org.eclipse.viatra.solver.language.Problem.Statement"); + private final Alternatives cAlternatives = (Alternatives)rule.eContents().get(1); + private final RuleCall cClassDeclarationParserRuleCall_0 = (RuleCall)cAlternatives.eContents().get(0); + private final RuleCall cEnumDeclarationParserRuleCall_1 = (RuleCall)cAlternatives.eContents().get(1); + private final RuleCall cPredicateDefinitionParserRuleCall_2 = (RuleCall)cAlternatives.eContents().get(2); + private final RuleCall cAssertionParserRuleCall_3 = (RuleCall)cAlternatives.eContents().get(3); + private final RuleCall cScopeDeclarationParserRuleCall_4 = (RuleCall)cAlternatives.eContents().get(4); + + //Statement: + // ClassDeclaration | EnumDeclaration | PredicateDefinition | Assertion | ScopeDeclaration; + @Override public ParserRule getRule() { return rule; } + + //ClassDeclaration | EnumDeclaration | PredicateDefinition | Assertion | ScopeDeclaration + public Alternatives getAlternatives() { return cAlternatives; } + + //ClassDeclaration + public RuleCall getClassDeclarationParserRuleCall_0() { return cClassDeclarationParserRuleCall_0; } + + //EnumDeclaration + public RuleCall getEnumDeclarationParserRuleCall_1() { return cEnumDeclarationParserRuleCall_1; } + + //PredicateDefinition + public RuleCall getPredicateDefinitionParserRuleCall_2() { return cPredicateDefinitionParserRuleCall_2; } + + //Assertion + public RuleCall getAssertionParserRuleCall_3() { return cAssertionParserRuleCall_3; } + + //ScopeDeclaration + public RuleCall getScopeDeclarationParserRuleCall_4() { return cScopeDeclarationParserRuleCall_4; } + } + public class ClassDeclarationElements extends AbstractParserRuleElementFinder { + private final ParserRule rule = (ParserRule) GrammarUtil.findRuleForName(getGrammar(), "org.eclipse.viatra.solver.language.Problem.ClassDeclaration"); + private final Group cGroup = (Group)rule.eContents().get(1); + private final Assignment cAbstractAssignment_0 = (Assignment)cGroup.eContents().get(0); + private final Keyword cAbstractAbstractKeyword_0_0 = (Keyword)cAbstractAssignment_0.eContents().get(0); + private final Keyword cClassKeyword_1 = (Keyword)cGroup.eContents().get(1); + private final Assignment cNameAssignment_2 = (Assignment)cGroup.eContents().get(2); + private final RuleCall cNameIdentifierParserRuleCall_2_0 = (RuleCall)cNameAssignment_2.eContents().get(0); + private final Group cGroup_3 = (Group)cGroup.eContents().get(3); + private final Keyword cExtendsKeyword_3_0 = (Keyword)cGroup_3.eContents().get(0); + private final Assignment cSuperTypesAssignment_3_1 = (Assignment)cGroup_3.eContents().get(1); + private final CrossReference cSuperTypesRelationCrossReference_3_1_0 = (CrossReference)cSuperTypesAssignment_3_1.eContents().get(0); + private final RuleCall cSuperTypesRelationQualifiedNameParserRuleCall_3_1_0_1 = (RuleCall)cSuperTypesRelationCrossReference_3_1_0.eContents().get(1); + private final Group cGroup_3_2 = (Group)cGroup_3.eContents().get(2); + private final Keyword cCommaKeyword_3_2_0 = (Keyword)cGroup_3_2.eContents().get(0); + private final Assignment cSuperTypesAssignment_3_2_1 = (Assignment)cGroup_3_2.eContents().get(1); + private final CrossReference cSuperTypesRelationCrossReference_3_2_1_0 = (CrossReference)cSuperTypesAssignment_3_2_1.eContents().get(0); + private final RuleCall cSuperTypesRelationQualifiedNameParserRuleCall_3_2_1_0_1 = (RuleCall)cSuperTypesRelationCrossReference_3_2_1_0.eContents().get(1); + private final Alternatives cAlternatives_4 = (Alternatives)cGroup.eContents().get(4); + private final Group cGroup_4_0 = (Group)cAlternatives_4.eContents().get(0); + private final Keyword cLeftCurlyBracketKeyword_4_0_0 = (Keyword)cGroup_4_0.eContents().get(0); + private final Group cGroup_4_0_1 = (Group)cGroup_4_0.eContents().get(1); + private final Assignment cReferenceDeclarationsAssignment_4_0_1_0 = (Assignment)cGroup_4_0_1.eContents().get(0); + private final RuleCall cReferenceDeclarationsReferenceDeclarationParserRuleCall_4_0_1_0_0 = (RuleCall)cReferenceDeclarationsAssignment_4_0_1_0.eContents().get(0); + private final Keyword cSemicolonKeyword_4_0_1_1 = (Keyword)cGroup_4_0_1.eContents().get(1); + private final Keyword cRightCurlyBracketKeyword_4_0_2 = (Keyword)cGroup_4_0.eContents().get(2); + private final Keyword cFullStopKeyword_4_1 = (Keyword)cAlternatives_4.eContents().get(1); + + //ClassDeclaration: + // abstract?="abstract"? "class" + // name=Identifier + // ("extends" superTypes+=[Relation|QualifiedName] ("," superTypes+=[Relation|QualifiedName])*)? + // ("{" (referenceDeclarations+=ReferenceDeclaration ";"?)* "}" | "."); + @Override public ParserRule getRule() { return rule; } + + //abstract?="abstract"? "class" + //name=Identifier + //("extends" superTypes+=[Relation|QualifiedName] ("," superTypes+=[Relation|QualifiedName])*)? + //("{" (referenceDeclarations+=ReferenceDeclaration ";"?)* "}" | ".") + public Group getGroup() { return cGroup; } + + //abstract?="abstract"? + public Assignment getAbstractAssignment_0() { return cAbstractAssignment_0; } + + //"abstract" + public Keyword getAbstractAbstractKeyword_0_0() { return cAbstractAbstractKeyword_0_0; } + + //"class" + public Keyword getClassKeyword_1() { return cClassKeyword_1; } + + //name=Identifier + public Assignment getNameAssignment_2() { return cNameAssignment_2; } + + //Identifier + public RuleCall getNameIdentifierParserRuleCall_2_0() { return cNameIdentifierParserRuleCall_2_0; } + + //("extends" superTypes+=[Relation|QualifiedName] ("," superTypes+=[Relation|QualifiedName])*)? + public Group getGroup_3() { return cGroup_3; } + + //"extends" + public Keyword getExtendsKeyword_3_0() { return cExtendsKeyword_3_0; } + + //superTypes+=[Relation|QualifiedName] + public Assignment getSuperTypesAssignment_3_1() { return cSuperTypesAssignment_3_1; } + + //[Relation|QualifiedName] + public CrossReference getSuperTypesRelationCrossReference_3_1_0() { return cSuperTypesRelationCrossReference_3_1_0; } + + //QualifiedName + public RuleCall getSuperTypesRelationQualifiedNameParserRuleCall_3_1_0_1() { return cSuperTypesRelationQualifiedNameParserRuleCall_3_1_0_1; } + + //("," superTypes+=[Relation|QualifiedName])* + public Group getGroup_3_2() { return cGroup_3_2; } + + //"," + public Keyword getCommaKeyword_3_2_0() { return cCommaKeyword_3_2_0; } + + //superTypes+=[Relation|QualifiedName] + public Assignment getSuperTypesAssignment_3_2_1() { return cSuperTypesAssignment_3_2_1; } + + //[Relation|QualifiedName] + public CrossReference getSuperTypesRelationCrossReference_3_2_1_0() { return cSuperTypesRelationCrossReference_3_2_1_0; } + + //QualifiedName + public RuleCall getSuperTypesRelationQualifiedNameParserRuleCall_3_2_1_0_1() { return cSuperTypesRelationQualifiedNameParserRuleCall_3_2_1_0_1; } + + //("{" (referenceDeclarations+=ReferenceDeclaration ";"?)* "}" | ".") + public Alternatives getAlternatives_4() { return cAlternatives_4; } + + //"{" (referenceDeclarations+=ReferenceDeclaration ";"?)* "}" + public Group getGroup_4_0() { return cGroup_4_0; } + + //"{" + public Keyword getLeftCurlyBracketKeyword_4_0_0() { return cLeftCurlyBracketKeyword_4_0_0; } + + //(referenceDeclarations+=ReferenceDeclaration ";"?)* + public Group getGroup_4_0_1() { return cGroup_4_0_1; } + + //referenceDeclarations+=ReferenceDeclaration + public Assignment getReferenceDeclarationsAssignment_4_0_1_0() { return cReferenceDeclarationsAssignment_4_0_1_0; } + + //ReferenceDeclaration + public RuleCall getReferenceDeclarationsReferenceDeclarationParserRuleCall_4_0_1_0_0() { return cReferenceDeclarationsReferenceDeclarationParserRuleCall_4_0_1_0_0; } + + //";"? + public Keyword getSemicolonKeyword_4_0_1_1() { return cSemicolonKeyword_4_0_1_1; } + + //"}" + public Keyword getRightCurlyBracketKeyword_4_0_2() { return cRightCurlyBracketKeyword_4_0_2; } + + //"." + public Keyword getFullStopKeyword_4_1() { return cFullStopKeyword_4_1; } + } + public class EnumDeclarationElements extends AbstractParserRuleElementFinder { + private final ParserRule rule = (ParserRule) GrammarUtil.findRuleForName(getGrammar(), "org.eclipse.viatra.solver.language.Problem.EnumDeclaration"); + private final Group cGroup = (Group)rule.eContents().get(1); + private final Keyword cEnumKeyword_0 = (Keyword)cGroup.eContents().get(0); + private final Assignment cNameAssignment_1 = (Assignment)cGroup.eContents().get(1); + private final RuleCall cNameIdentifierParserRuleCall_1_0 = (RuleCall)cNameAssignment_1.eContents().get(0); + private final Alternatives cAlternatives_2 = (Alternatives)cGroup.eContents().get(2); + private final Group cGroup_2_0 = (Group)cAlternatives_2.eContents().get(0); + private final Keyword cLeftCurlyBracketKeyword_2_0_0 = (Keyword)cGroup_2_0.eContents().get(0); + private final Group cGroup_2_0_1 = (Group)cGroup_2_0.eContents().get(1); + private final Assignment cLiteralsAssignment_2_0_1_0 = (Assignment)cGroup_2_0_1.eContents().get(0); + private final RuleCall cLiteralsEnumLiteralParserRuleCall_2_0_1_0_0 = (RuleCall)cLiteralsAssignment_2_0_1_0.eContents().get(0); + private final Group cGroup_2_0_1_1 = (Group)cGroup_2_0_1.eContents().get(1); + private final Keyword cCommaKeyword_2_0_1_1_0 = (Keyword)cGroup_2_0_1_1.eContents().get(0); + private final Assignment cLiteralsAssignment_2_0_1_1_1 = (Assignment)cGroup_2_0_1_1.eContents().get(1); + private final RuleCall cLiteralsEnumLiteralParserRuleCall_2_0_1_1_1_0 = (RuleCall)cLiteralsAssignment_2_0_1_1_1.eContents().get(0); + private final Alternatives cAlternatives_2_0_1_2 = (Alternatives)cGroup_2_0_1.eContents().get(2); + private final Keyword cCommaKeyword_2_0_1_2_0 = (Keyword)cAlternatives_2_0_1_2.eContents().get(0); + private final Keyword cSemicolonKeyword_2_0_1_2_1 = (Keyword)cAlternatives_2_0_1_2.eContents().get(1); + private final Keyword cRightCurlyBracketKeyword_2_0_2 = (Keyword)cGroup_2_0.eContents().get(2); + private final Keyword cFullStopKeyword_2_1 = (Keyword)cAlternatives_2.eContents().get(1); + + //EnumDeclaration: + // "enum" + // name=Identifier + // ("{" (literals+=EnumLiteral ("," literals+=EnumLiteral)* ("," | ";")?)? "}" | "."); + @Override public ParserRule getRule() { return rule; } + + //"enum" + //name=Identifier + //("{" (literals+=EnumLiteral ("," literals+=EnumLiteral)* ("," | ";")?)? "}" | ".") + public Group getGroup() { return cGroup; } + + //"enum" + public Keyword getEnumKeyword_0() { return cEnumKeyword_0; } + + //name=Identifier + public Assignment getNameAssignment_1() { return cNameAssignment_1; } + + //Identifier + public RuleCall getNameIdentifierParserRuleCall_1_0() { return cNameIdentifierParserRuleCall_1_0; } + + //("{" (literals+=EnumLiteral ("," literals+=EnumLiteral)* ("," | ";")?)? "}" | ".") + public Alternatives getAlternatives_2() { return cAlternatives_2; } + + //"{" (literals+=EnumLiteral ("," literals+=EnumLiteral)* ("," | ";")?)? "}" + public Group getGroup_2_0() { return cGroup_2_0; } + + //"{" + public Keyword getLeftCurlyBracketKeyword_2_0_0() { return cLeftCurlyBracketKeyword_2_0_0; } + + //(literals+=EnumLiteral ("," literals+=EnumLiteral)* ("," | ";")?)? + public Group getGroup_2_0_1() { return cGroup_2_0_1; } + + //literals+=EnumLiteral + public Assignment getLiteralsAssignment_2_0_1_0() { return cLiteralsAssignment_2_0_1_0; } + + //EnumLiteral + public RuleCall getLiteralsEnumLiteralParserRuleCall_2_0_1_0_0() { return cLiteralsEnumLiteralParserRuleCall_2_0_1_0_0; } + + //("," literals+=EnumLiteral)* + public Group getGroup_2_0_1_1() { return cGroup_2_0_1_1; } + + //"," + public Keyword getCommaKeyword_2_0_1_1_0() { return cCommaKeyword_2_0_1_1_0; } + + //literals+=EnumLiteral + public Assignment getLiteralsAssignment_2_0_1_1_1() { return cLiteralsAssignment_2_0_1_1_1; } + + //EnumLiteral + public RuleCall getLiteralsEnumLiteralParserRuleCall_2_0_1_1_1_0() { return cLiteralsEnumLiteralParserRuleCall_2_0_1_1_1_0; } + + //("," | ";")? + public Alternatives getAlternatives_2_0_1_2() { return cAlternatives_2_0_1_2; } + + //"," + public Keyword getCommaKeyword_2_0_1_2_0() { return cCommaKeyword_2_0_1_2_0; } + + //";" + public Keyword getSemicolonKeyword_2_0_1_2_1() { return cSemicolonKeyword_2_0_1_2_1; } + + //"}" + public Keyword getRightCurlyBracketKeyword_2_0_2() { return cRightCurlyBracketKeyword_2_0_2; } + + //"." + public Keyword getFullStopKeyword_2_1() { return cFullStopKeyword_2_1; } + } + public class EnumLiteralElements extends AbstractParserRuleElementFinder { + private final ParserRule rule = (ParserRule) GrammarUtil.findRuleForName(getGrammar(), "org.eclipse.viatra.solver.language.Problem.EnumLiteral"); + private final Assignment cNameAssignment = (Assignment)rule.eContents().get(1); + private final RuleCall cNameQuotedOrUnquotedIdParserRuleCall_0 = (RuleCall)cNameAssignment.eContents().get(0); + + //EnumLiteral returns Node: + // name=QuotedOrUnquotedId; + @Override public ParserRule getRule() { return rule; } + + //name=QuotedOrUnquotedId + public Assignment getNameAssignment() { return cNameAssignment; } + + //QuotedOrUnquotedId + public RuleCall getNameQuotedOrUnquotedIdParserRuleCall_0() { return cNameQuotedOrUnquotedIdParserRuleCall_0; } + } + public class ReferenceDeclarationElements extends AbstractParserRuleElementFinder { + private final ParserRule rule = (ParserRule) GrammarUtil.findRuleForName(getGrammar(), "org.eclipse.viatra.solver.language.Problem.ReferenceDeclaration"); + private final Group cGroup = (Group)rule.eContents().get(1); + private final Alternatives cAlternatives_0 = (Alternatives)cGroup.eContents().get(0); + private final Assignment cContainmentAssignment_0_0 = (Assignment)cAlternatives_0.eContents().get(0); + private final Keyword cContainmentContainsKeyword_0_0_0 = (Keyword)cContainmentAssignment_0_0.eContents().get(0); + private final Keyword cRefersKeyword_0_1 = (Keyword)cAlternatives_0.eContents().get(1); + private final Assignment cReferenceTypeAssignment_1 = (Assignment)cGroup.eContents().get(1); + private final CrossReference cReferenceTypeRelationCrossReference_1_0 = (CrossReference)cReferenceTypeAssignment_1.eContents().get(0); + private final RuleCall cReferenceTypeRelationQualifiedNameParserRuleCall_1_0_1 = (RuleCall)cReferenceTypeRelationCrossReference_1_0.eContents().get(1); + private final Group cGroup_2 = (Group)cGroup.eContents().get(2); + private final Keyword cLeftSquareBracketKeyword_2_0 = (Keyword)cGroup_2.eContents().get(0); + private final Assignment cMultiplicityAssignment_2_1 = (Assignment)cGroup_2.eContents().get(1); + private final RuleCall cMultiplicityMultiplicityParserRuleCall_2_1_0 = (RuleCall)cMultiplicityAssignment_2_1.eContents().get(0); + private final Keyword cRightSquareBracketKeyword_2_2 = (Keyword)cGroup_2.eContents().get(2); + private final Assignment cNameAssignment_3 = (Assignment)cGroup.eContents().get(3); + private final RuleCall cNameIdentifierParserRuleCall_3_0 = (RuleCall)cNameAssignment_3.eContents().get(0); + private final Group cGroup_4 = (Group)cGroup.eContents().get(4); + private final Keyword cOppositeKeyword_4_0 = (Keyword)cGroup_4.eContents().get(0); + private final Assignment cOppositeAssignment_4_1 = (Assignment)cGroup_4.eContents().get(1); + private final CrossReference cOppositeReferenceDeclarationCrossReference_4_1_0 = (CrossReference)cOppositeAssignment_4_1.eContents().get(0); + private final RuleCall cOppositeReferenceDeclarationQualifiedNameParserRuleCall_4_1_0_1 = (RuleCall)cOppositeReferenceDeclarationCrossReference_4_1_0.eContents().get(1); + + //ReferenceDeclaration: + // (containment?="contains" | "refers")? + // referenceType=[Relation|QualifiedName] + // ("[" multiplicity=Multiplicity "]")? + // name=Identifier + // ("opposite" opposite=[ReferenceDeclaration|QualifiedName])?; + @Override public ParserRule getRule() { return rule; } + + //(containment?="contains" | "refers")? + //referenceType=[Relation|QualifiedName] + //("[" multiplicity=Multiplicity "]")? + //name=Identifier + //("opposite" opposite=[ReferenceDeclaration|QualifiedName])? + public Group getGroup() { return cGroup; } + + //(containment?="contains" | "refers")? + public Alternatives getAlternatives_0() { return cAlternatives_0; } + + //containment?="contains" + public Assignment getContainmentAssignment_0_0() { return cContainmentAssignment_0_0; } + + //"contains" + public Keyword getContainmentContainsKeyword_0_0_0() { return cContainmentContainsKeyword_0_0_0; } + + //"refers" + public Keyword getRefersKeyword_0_1() { return cRefersKeyword_0_1; } + + //referenceType=[Relation|QualifiedName] + public Assignment getReferenceTypeAssignment_1() { return cReferenceTypeAssignment_1; } + + //[Relation|QualifiedName] + public CrossReference getReferenceTypeRelationCrossReference_1_0() { return cReferenceTypeRelationCrossReference_1_0; } + + //QualifiedName + public RuleCall getReferenceTypeRelationQualifiedNameParserRuleCall_1_0_1() { return cReferenceTypeRelationQualifiedNameParserRuleCall_1_0_1; } + + //("[" multiplicity=Multiplicity "]")? + public Group getGroup_2() { return cGroup_2; } + + //"[" + public Keyword getLeftSquareBracketKeyword_2_0() { return cLeftSquareBracketKeyword_2_0; } + + //multiplicity=Multiplicity + public Assignment getMultiplicityAssignment_2_1() { return cMultiplicityAssignment_2_1; } + + //Multiplicity + public RuleCall getMultiplicityMultiplicityParserRuleCall_2_1_0() { return cMultiplicityMultiplicityParserRuleCall_2_1_0; } + + //"]" + public Keyword getRightSquareBracketKeyword_2_2() { return cRightSquareBracketKeyword_2_2; } + + //name=Identifier + public Assignment getNameAssignment_3() { return cNameAssignment_3; } + + //Identifier + public RuleCall getNameIdentifierParserRuleCall_3_0() { return cNameIdentifierParserRuleCall_3_0; } + + //("opposite" opposite=[ReferenceDeclaration|QualifiedName])? + public Group getGroup_4() { return cGroup_4; } + + //"opposite" + public Keyword getOppositeKeyword_4_0() { return cOppositeKeyword_4_0; } + + //opposite=[ReferenceDeclaration|QualifiedName] + public Assignment getOppositeAssignment_4_1() { return cOppositeAssignment_4_1; } + + //[ReferenceDeclaration|QualifiedName] + public CrossReference getOppositeReferenceDeclarationCrossReference_4_1_0() { return cOppositeReferenceDeclarationCrossReference_4_1_0; } + + //QualifiedName + public RuleCall getOppositeReferenceDeclarationQualifiedNameParserRuleCall_4_1_0_1() { return cOppositeReferenceDeclarationQualifiedNameParserRuleCall_4_1_0_1; } + } + public class PredicateDefinitionElements extends AbstractParserRuleElementFinder { + private final ParserRule rule = (ParserRule) GrammarUtil.findRuleForName(getGrammar(), "org.eclipse.viatra.solver.language.Problem.PredicateDefinition"); + private final Group cGroup = (Group)rule.eContents().get(1); + private final Alternatives cAlternatives_0 = (Alternatives)cGroup.eContents().get(0); + private final Group cGroup_0_0 = (Group)cAlternatives_0.eContents().get(0); + private final Assignment cErrorAssignment_0_0_0 = (Assignment)cGroup_0_0.eContents().get(0); + private final Keyword cErrorErrorKeyword_0_0_0_0 = (Keyword)cErrorAssignment_0_0_0.eContents().get(0); + private final Keyword cPredKeyword_0_0_1 = (Keyword)cGroup_0_0.eContents().get(1); + private final Keyword cPredKeyword_0_1 = (Keyword)cAlternatives_0.eContents().get(1); + private final Assignment cNameAssignment_1 = (Assignment)cGroup.eContents().get(1); + private final RuleCall cNameIdentifierParserRuleCall_1_0 = (RuleCall)cNameAssignment_1.eContents().get(0); + private final Keyword cLeftParenthesisKeyword_2 = (Keyword)cGroup.eContents().get(2); + private final Group cGroup_3 = (Group)cGroup.eContents().get(3); + private final Assignment cParametersAssignment_3_0 = (Assignment)cGroup_3.eContents().get(0); + private final RuleCall cParametersParameterParserRuleCall_3_0_0 = (RuleCall)cParametersAssignment_3_0.eContents().get(0); + private final Group cGroup_3_1 = (Group)cGroup_3.eContents().get(1); + private final Keyword cCommaKeyword_3_1_0 = (Keyword)cGroup_3_1.eContents().get(0); + private final Assignment cParametersAssignment_3_1_1 = (Assignment)cGroup_3_1.eContents().get(1); + private final RuleCall cParametersParameterParserRuleCall_3_1_1_0 = (RuleCall)cParametersAssignment_3_1_1.eContents().get(0); + private final Keyword cRightParenthesisKeyword_4 = (Keyword)cGroup.eContents().get(4); + private final Group cGroup_5 = (Group)cGroup.eContents().get(5); + private final Keyword cColonHyphenMinusKeyword_5_0 = (Keyword)cGroup_5.eContents().get(0); + private final Assignment cBodiesAssignment_5_1 = (Assignment)cGroup_5.eContents().get(1); + private final RuleCall cBodiesConjunctionParserRuleCall_5_1_0 = (RuleCall)cBodiesAssignment_5_1.eContents().get(0); + private final Group cGroup_5_2 = (Group)cGroup_5.eContents().get(2); + private final Keyword cSemicolonKeyword_5_2_0 = (Keyword)cGroup_5_2.eContents().get(0); + private final Assignment cBodiesAssignment_5_2_1 = (Assignment)cGroup_5_2.eContents().get(1); + private final RuleCall cBodiesConjunctionParserRuleCall_5_2_1_0 = (RuleCall)cBodiesAssignment_5_2_1.eContents().get(0); + private final Keyword cFullStopKeyword_6 = (Keyword)cGroup.eContents().get(6); + + //PredicateDefinition: + // (error?="error" "pred"? | "pred") + // name=Identifier + // "(" (parameters+=Parameter ("," parameters+=Parameter)*)? ")" + // (":-" bodies+=Conjunction (";" bodies+=Conjunction)*)? + // "."; + @Override public ParserRule getRule() { return rule; } + + //(error?="error" "pred"? | "pred") + //name=Identifier + //"(" (parameters+=Parameter ("," parameters+=Parameter)*)? ")" + //(":-" bodies+=Conjunction (";" bodies+=Conjunction)*)? + //"." + public Group getGroup() { return cGroup; } + + //(error?="error" "pred"? | "pred") + public Alternatives getAlternatives_0() { return cAlternatives_0; } + + //error?="error" "pred"? + public Group getGroup_0_0() { return cGroup_0_0; } + + //error?="error" + public Assignment getErrorAssignment_0_0_0() { return cErrorAssignment_0_0_0; } + + //"error" + public Keyword getErrorErrorKeyword_0_0_0_0() { return cErrorErrorKeyword_0_0_0_0; } + + //"pred"? + public Keyword getPredKeyword_0_0_1() { return cPredKeyword_0_0_1; } + + //"pred" + public Keyword getPredKeyword_0_1() { return cPredKeyword_0_1; } + + //name=Identifier + public Assignment getNameAssignment_1() { return cNameAssignment_1; } + + //Identifier + public RuleCall getNameIdentifierParserRuleCall_1_0() { return cNameIdentifierParserRuleCall_1_0; } + + //"(" + public Keyword getLeftParenthesisKeyword_2() { return cLeftParenthesisKeyword_2; } + + //(parameters+=Parameter ("," parameters+=Parameter)*)? + public Group getGroup_3() { return cGroup_3; } + + //parameters+=Parameter + public Assignment getParametersAssignment_3_0() { return cParametersAssignment_3_0; } + + //Parameter + public RuleCall getParametersParameterParserRuleCall_3_0_0() { return cParametersParameterParserRuleCall_3_0_0; } + + //("," parameters+=Parameter)* + public Group getGroup_3_1() { return cGroup_3_1; } + + //"," + public Keyword getCommaKeyword_3_1_0() { return cCommaKeyword_3_1_0; } + + //parameters+=Parameter + public Assignment getParametersAssignment_3_1_1() { return cParametersAssignment_3_1_1; } + + //Parameter + public RuleCall getParametersParameterParserRuleCall_3_1_1_0() { return cParametersParameterParserRuleCall_3_1_1_0; } + + //")" + public Keyword getRightParenthesisKeyword_4() { return cRightParenthesisKeyword_4; } + + //(":-" bodies+=Conjunction (";" bodies+=Conjunction)*)? + public Group getGroup_5() { return cGroup_5; } + + //":-" + public Keyword getColonHyphenMinusKeyword_5_0() { return cColonHyphenMinusKeyword_5_0; } + + //bodies+=Conjunction + public Assignment getBodiesAssignment_5_1() { return cBodiesAssignment_5_1; } + + //Conjunction + public RuleCall getBodiesConjunctionParserRuleCall_5_1_0() { return cBodiesConjunctionParserRuleCall_5_1_0; } + + //(";" bodies+=Conjunction)* + public Group getGroup_5_2() { return cGroup_5_2; } + + //";" + public Keyword getSemicolonKeyword_5_2_0() { return cSemicolonKeyword_5_2_0; } + + //bodies+=Conjunction + public Assignment getBodiesAssignment_5_2_1() { return cBodiesAssignment_5_2_1; } + + //Conjunction + public RuleCall getBodiesConjunctionParserRuleCall_5_2_1_0() { return cBodiesConjunctionParserRuleCall_5_2_1_0; } + + //"." + public Keyword getFullStopKeyword_6() { return cFullStopKeyword_6; } + } + public class ParameterElements extends AbstractParserRuleElementFinder { + private final ParserRule rule = (ParserRule) GrammarUtil.findRuleForName(getGrammar(), "org.eclipse.viatra.solver.language.Problem.Parameter"); + private final Group cGroup = (Group)rule.eContents().get(1); + private final Assignment cParameterTypeAssignment_0 = (Assignment)cGroup.eContents().get(0); + private final CrossReference cParameterTypeRelationCrossReference_0_0 = (CrossReference)cParameterTypeAssignment_0.eContents().get(0); + private final RuleCall cParameterTypeRelationQualifiedNameParserRuleCall_0_0_1 = (RuleCall)cParameterTypeRelationCrossReference_0_0.eContents().get(1); + private final Assignment cNameAssignment_1 = (Assignment)cGroup.eContents().get(1); + private final RuleCall cNameIdentifierParserRuleCall_1_0 = (RuleCall)cNameAssignment_1.eContents().get(0); + + //Parameter: + // parameterType=[Relation|QualifiedName]? name=Identifier; + @Override public ParserRule getRule() { return rule; } + + //parameterType=[Relation|QualifiedName]? name=Identifier + public Group getGroup() { return cGroup; } + + //parameterType=[Relation|QualifiedName]? + public Assignment getParameterTypeAssignment_0() { return cParameterTypeAssignment_0; } + + //[Relation|QualifiedName] + public CrossReference getParameterTypeRelationCrossReference_0_0() { return cParameterTypeRelationCrossReference_0_0; } + + //QualifiedName + public RuleCall getParameterTypeRelationQualifiedNameParserRuleCall_0_0_1() { return cParameterTypeRelationQualifiedNameParserRuleCall_0_0_1; } + + //name=Identifier + public Assignment getNameAssignment_1() { return cNameAssignment_1; } + + //Identifier + public RuleCall getNameIdentifierParserRuleCall_1_0() { return cNameIdentifierParserRuleCall_1_0; } + } + public class ConjunctionElements extends AbstractParserRuleElementFinder { + private final ParserRule rule = (ParserRule) GrammarUtil.findRuleForName(getGrammar(), "org.eclipse.viatra.solver.language.Problem.Conjunction"); + private final Group cGroup = (Group)rule.eContents().get(1); + private final Assignment cLiteralsAssignment_0 = (Assignment)cGroup.eContents().get(0); + private final RuleCall cLiteralsLiteralParserRuleCall_0_0 = (RuleCall)cLiteralsAssignment_0.eContents().get(0); + private final Group cGroup_1 = (Group)cGroup.eContents().get(1); + private final Keyword cCommaKeyword_1_0 = (Keyword)cGroup_1.eContents().get(0); + private final Assignment cLiteralsAssignment_1_1 = (Assignment)cGroup_1.eContents().get(1); + private final RuleCall cLiteralsLiteralParserRuleCall_1_1_0 = (RuleCall)cLiteralsAssignment_1_1.eContents().get(0); + + //Conjunction: + // literals+=Literal ("," literals+=Literal)*; + @Override public ParserRule getRule() { return rule; } + + //literals+=Literal ("," literals+=Literal)* + public Group getGroup() { return cGroup; } + + //literals+=Literal + public Assignment getLiteralsAssignment_0() { return cLiteralsAssignment_0; } + + //Literal + public RuleCall getLiteralsLiteralParserRuleCall_0_0() { return cLiteralsLiteralParserRuleCall_0_0; } + + //("," literals+=Literal)* + public Group getGroup_1() { return cGroup_1; } + + //"," + public Keyword getCommaKeyword_1_0() { return cCommaKeyword_1_0; } + + //literals+=Literal + public Assignment getLiteralsAssignment_1_1() { return cLiteralsAssignment_1_1; } + + //Literal + public RuleCall getLiteralsLiteralParserRuleCall_1_1_0() { return cLiteralsLiteralParserRuleCall_1_1_0; } + } + public class LiteralElements extends AbstractParserRuleElementFinder { + private final ParserRule rule = (ParserRule) GrammarUtil.findRuleForName(getGrammar(), "org.eclipse.viatra.solver.language.Problem.Literal"); + private final Alternatives cAlternatives = (Alternatives)rule.eContents().get(1); + private final RuleCall cAtomParserRuleCall_0 = (RuleCall)cAlternatives.eContents().get(0); + private final RuleCall cNegativeLiteralParserRuleCall_1 = (RuleCall)cAlternatives.eContents().get(1); + + //Literal: + // Atom | NegativeLiteral; + @Override public ParserRule getRule() { return rule; } + + //Atom | NegativeLiteral + public Alternatives getAlternatives() { return cAlternatives; } + + //Atom + public RuleCall getAtomParserRuleCall_0() { return cAtomParserRuleCall_0; } + + //NegativeLiteral + public RuleCall getNegativeLiteralParserRuleCall_1() { return cNegativeLiteralParserRuleCall_1; } + } + public class NegativeLiteralElements extends AbstractParserRuleElementFinder { + private final ParserRule rule = (ParserRule) GrammarUtil.findRuleForName(getGrammar(), "org.eclipse.viatra.solver.language.Problem.NegativeLiteral"); + private final Group cGroup = (Group)rule.eContents().get(1); + private final Keyword cExclamationMarkKeyword_0 = (Keyword)cGroup.eContents().get(0); + private final Assignment cAtomAssignment_1 = (Assignment)cGroup.eContents().get(1); + private final RuleCall cAtomAtomParserRuleCall_1_0 = (RuleCall)cAtomAssignment_1.eContents().get(0); + + //NegativeLiteral: + // "!" atom=Atom; + @Override public ParserRule getRule() { return rule; } + + //"!" atom=Atom + public Group getGroup() { return cGroup; } + + //"!" + public Keyword getExclamationMarkKeyword_0() { return cExclamationMarkKeyword_0; } + + //atom=Atom + public Assignment getAtomAssignment_1() { return cAtomAssignment_1; } + + //Atom + public RuleCall getAtomAtomParserRuleCall_1_0() { return cAtomAtomParserRuleCall_1_0; } + } + public class AtomElements extends AbstractParserRuleElementFinder { + private final ParserRule rule = (ParserRule) GrammarUtil.findRuleForName(getGrammar(), "org.eclipse.viatra.solver.language.Problem.Atom"); + private final Group cGroup = (Group)rule.eContents().get(1); + private final Assignment cRelationAssignment_0 = (Assignment)cGroup.eContents().get(0); + private final CrossReference cRelationRelationCrossReference_0_0 = (CrossReference)cRelationAssignment_0.eContents().get(0); + private final RuleCall cRelationRelationQualifiedNameParserRuleCall_0_0_1 = (RuleCall)cRelationRelationCrossReference_0_0.eContents().get(1); + private final Assignment cTransitiveClosureAssignment_1 = (Assignment)cGroup.eContents().get(1); + private final Keyword cTransitiveClosurePlusSignKeyword_1_0 = (Keyword)cTransitiveClosureAssignment_1.eContents().get(0); + private final Keyword cLeftParenthesisKeyword_2 = (Keyword)cGroup.eContents().get(2); + private final Group cGroup_3 = (Group)cGroup.eContents().get(3); + private final Assignment cArgumentsAssignment_3_0 = (Assignment)cGroup_3.eContents().get(0); + private final RuleCall cArgumentsArgumentParserRuleCall_3_0_0 = (RuleCall)cArgumentsAssignment_3_0.eContents().get(0); + private final Group cGroup_3_1 = (Group)cGroup_3.eContents().get(1); + private final Keyword cCommaKeyword_3_1_0 = (Keyword)cGroup_3_1.eContents().get(0); + private final Assignment cArgumentsAssignment_3_1_1 = (Assignment)cGroup_3_1.eContents().get(1); + private final RuleCall cArgumentsArgumentParserRuleCall_3_1_1_0 = (RuleCall)cArgumentsAssignment_3_1_1.eContents().get(0); + private final Keyword cRightParenthesisKeyword_4 = (Keyword)cGroup.eContents().get(4); + + //Atom: + // relation=[Relation|QualifiedName] + // transitiveClosure?="+"? + // "(" (arguments+=Argument ("," arguments+=Argument)*)? ")"; + @Override public ParserRule getRule() { return rule; } + + //relation=[Relation|QualifiedName] + //transitiveClosure?="+"? + //"(" (arguments+=Argument ("," arguments+=Argument)*)? ")" + public Group getGroup() { return cGroup; } + + //relation=[Relation|QualifiedName] + public Assignment getRelationAssignment_0() { return cRelationAssignment_0; } + + //[Relation|QualifiedName] + public CrossReference getRelationRelationCrossReference_0_0() { return cRelationRelationCrossReference_0_0; } + + //QualifiedName + public RuleCall getRelationRelationQualifiedNameParserRuleCall_0_0_1() { return cRelationRelationQualifiedNameParserRuleCall_0_0_1; } + + //transitiveClosure?="+"? + public Assignment getTransitiveClosureAssignment_1() { return cTransitiveClosureAssignment_1; } + + //"+" + public Keyword getTransitiveClosurePlusSignKeyword_1_0() { return cTransitiveClosurePlusSignKeyword_1_0; } + + //"(" + public Keyword getLeftParenthesisKeyword_2() { return cLeftParenthesisKeyword_2; } + + //(arguments+=Argument ("," arguments+=Argument)*)? + public Group getGroup_3() { return cGroup_3; } + + //arguments+=Argument + public Assignment getArgumentsAssignment_3_0() { return cArgumentsAssignment_3_0; } + + //Argument + public RuleCall getArgumentsArgumentParserRuleCall_3_0_0() { return cArgumentsArgumentParserRuleCall_3_0_0; } + + //("," arguments+=Argument)* + public Group getGroup_3_1() { return cGroup_3_1; } + + //"," + public Keyword getCommaKeyword_3_1_0() { return cCommaKeyword_3_1_0; } + + //arguments+=Argument + public Assignment getArgumentsAssignment_3_1_1() { return cArgumentsAssignment_3_1_1; } + + //Argument + public RuleCall getArgumentsArgumentParserRuleCall_3_1_1_0() { return cArgumentsArgumentParserRuleCall_3_1_1_0; } + + //")" + public Keyword getRightParenthesisKeyword_4() { return cRightParenthesisKeyword_4; } + } + public class ArgumentElements extends AbstractParserRuleElementFinder { + private final ParserRule rule = (ParserRule) GrammarUtil.findRuleForName(getGrammar(), "org.eclipse.viatra.solver.language.Problem.Argument"); + private final Assignment cVariableOrNodeAssignment = (Assignment)rule.eContents().get(1); + private final CrossReference cVariableOrNodeVariableOrNodeCrossReference_0 = (CrossReference)cVariableOrNodeAssignment.eContents().get(0); + private final RuleCall cVariableOrNodeVariableOrNodeQualifiedNameParserRuleCall_0_1 = (RuleCall)cVariableOrNodeVariableOrNodeCrossReference_0.eContents().get(1); + + //Argument: + // variableOrNode=[VariableOrNode|QualifiedName]; + @Override public ParserRule getRule() { return rule; } + + //variableOrNode=[VariableOrNode|QualifiedName] + public Assignment getVariableOrNodeAssignment() { return cVariableOrNodeAssignment; } + + //[VariableOrNode|QualifiedName] + public CrossReference getVariableOrNodeVariableOrNodeCrossReference_0() { return cVariableOrNodeVariableOrNodeCrossReference_0; } + + //QualifiedName + public RuleCall getVariableOrNodeVariableOrNodeQualifiedNameParserRuleCall_0_1() { return cVariableOrNodeVariableOrNodeQualifiedNameParserRuleCall_0_1; } + } + public class AssertionElements extends AbstractParserRuleElementFinder { + private final ParserRule rule = (ParserRule) GrammarUtil.findRuleForName(getGrammar(), "org.eclipse.viatra.solver.language.Problem.Assertion"); + private final Group cGroup = (Group)rule.eContents().get(1); + private final Alternatives cAlternatives_0 = (Alternatives)cGroup.eContents().get(0); + private final Group cGroup_0_0 = (Group)cAlternatives_0.eContents().get(0); + private final Assignment cRelationAssignment_0_0_0 = (Assignment)cGroup_0_0.eContents().get(0); + private final CrossReference cRelationRelationCrossReference_0_0_0_0 = (CrossReference)cRelationAssignment_0_0_0.eContents().get(0); + private final RuleCall cRelationRelationQualifiedNameParserRuleCall_0_0_0_0_1 = (RuleCall)cRelationRelationCrossReference_0_0_0_0.eContents().get(1); + private final Keyword cLeftParenthesisKeyword_0_0_1 = (Keyword)cGroup_0_0.eContents().get(1); + private final Group cGroup_0_0_2 = (Group)cGroup_0_0.eContents().get(2); + private final Assignment cArgumentsAssignment_0_0_2_0 = (Assignment)cGroup_0_0_2.eContents().get(0); + private final CrossReference cArgumentsNodeCrossReference_0_0_2_0_0 = (CrossReference)cArgumentsAssignment_0_0_2_0.eContents().get(0); + private final RuleCall cArgumentsNodeQualifiedNameParserRuleCall_0_0_2_0_0_1 = (RuleCall)cArgumentsNodeCrossReference_0_0_2_0_0.eContents().get(1); + private final Group cGroup_0_0_2_1 = (Group)cGroup_0_0_2.eContents().get(1); + private final Keyword cCommaKeyword_0_0_2_1_0 = (Keyword)cGroup_0_0_2_1.eContents().get(0); + private final Assignment cArgumentsAssignment_0_0_2_1_1 = (Assignment)cGroup_0_0_2_1.eContents().get(1); + private final CrossReference cArgumentsNodeCrossReference_0_0_2_1_1_0 = (CrossReference)cArgumentsAssignment_0_0_2_1_1.eContents().get(0); + private final RuleCall cArgumentsNodeQualifiedNameParserRuleCall_0_0_2_1_1_0_1 = (RuleCall)cArgumentsNodeCrossReference_0_0_2_1_1_0.eContents().get(1); + private final Keyword cRightParenthesisKeyword_0_0_3 = (Keyword)cGroup_0_0.eContents().get(3); + private final Keyword cColonKeyword_0_0_4 = (Keyword)cGroup_0_0.eContents().get(4); + private final Assignment cValueAssignment_0_0_5 = (Assignment)cGroup_0_0.eContents().get(5); + private final RuleCall cValueLogicValueEnumRuleCall_0_0_5_0 = (RuleCall)cValueAssignment_0_0_5.eContents().get(0); + private final Group cGroup_0_1 = (Group)cAlternatives_0.eContents().get(1); + private final Assignment cValueAssignment_0_1_0 = (Assignment)cGroup_0_1.eContents().get(0); + private final RuleCall cValueShortLogicValueEnumRuleCall_0_1_0_0 = (RuleCall)cValueAssignment_0_1_0.eContents().get(0); + private final Assignment cRelationAssignment_0_1_1 = (Assignment)cGroup_0_1.eContents().get(1); + private final CrossReference cRelationRelationCrossReference_0_1_1_0 = (CrossReference)cRelationAssignment_0_1_1.eContents().get(0); + private final RuleCall cRelationRelationQualifiedNameParserRuleCall_0_1_1_0_1 = (RuleCall)cRelationRelationCrossReference_0_1_1_0.eContents().get(1); + private final Keyword cLeftParenthesisKeyword_0_1_2 = (Keyword)cGroup_0_1.eContents().get(2); + private final Group cGroup_0_1_3 = (Group)cGroup_0_1.eContents().get(3); + private final Assignment cArgumentsAssignment_0_1_3_0 = (Assignment)cGroup_0_1_3.eContents().get(0); + private final CrossReference cArgumentsNodeCrossReference_0_1_3_0_0 = (CrossReference)cArgumentsAssignment_0_1_3_0.eContents().get(0); + private final RuleCall cArgumentsNodeQualifiedNameParserRuleCall_0_1_3_0_0_1 = (RuleCall)cArgumentsNodeCrossReference_0_1_3_0_0.eContents().get(1); + private final Group cGroup_0_1_3_1 = (Group)cGroup_0_1_3.eContents().get(1); + private final Keyword cCommaKeyword_0_1_3_1_0 = (Keyword)cGroup_0_1_3_1.eContents().get(0); + private final Assignment cArgumentsAssignment_0_1_3_1_1 = (Assignment)cGroup_0_1_3_1.eContents().get(1); + private final CrossReference cArgumentsNodeCrossReference_0_1_3_1_1_0 = (CrossReference)cArgumentsAssignment_0_1_3_1_1.eContents().get(0); + private final RuleCall cArgumentsNodeQualifiedNameParserRuleCall_0_1_3_1_1_0_1 = (RuleCall)cArgumentsNodeCrossReference_0_1_3_1_1_0.eContents().get(1); + private final Keyword cRightParenthesisKeyword_0_1_4 = (Keyword)cGroup_0_1.eContents().get(4); + private final Keyword cFullStopKeyword_1 = (Keyword)cGroup.eContents().get(1); + + //Assertion: + // (relation=[Relation|QualifiedName] + // "(" (arguments+=[Node|QualifiedName] ("," arguments+=[Node|QualifiedName])*)? ")" + // ":" value=LogicValue | + // value=ShortLogicValue? + // relation=[Relation|QualifiedName] + // "(" (arguments+=[Node|QualifiedName] ("," arguments+=[Node|QualifiedName])*)? ")") + // "."; + @Override public ParserRule getRule() { return rule; } + + //(relation=[Relation|QualifiedName] + //"(" (arguments+=[Node|QualifiedName] ("," arguments+=[Node|QualifiedName])*)? ")" + //":" value=LogicValue | + //value=ShortLogicValue? + //relation=[Relation|QualifiedName] + //"(" (arguments+=[Node|QualifiedName] ("," arguments+=[Node|QualifiedName])*)? ")") + //"." + public Group getGroup() { return cGroup; } + + //(relation=[Relation|QualifiedName] + //"(" (arguments+=[Node|QualifiedName] ("," arguments+=[Node|QualifiedName])*)? ")" + //":" value=LogicValue | + //value=ShortLogicValue? + //relation=[Relation|QualifiedName] + //"(" (arguments+=[Node|QualifiedName] ("," arguments+=[Node|QualifiedName])*)? ")") + public Alternatives getAlternatives_0() { return cAlternatives_0; } + + //relation=[Relation|QualifiedName] + // "(" (arguments+=[Node|QualifiedName] ("," arguments+=[Node|QualifiedName])*)? ")" + // ":" value=LogicValue + public Group getGroup_0_0() { return cGroup_0_0; } + + //relation=[Relation|QualifiedName] + public Assignment getRelationAssignment_0_0_0() { return cRelationAssignment_0_0_0; } + + //[Relation|QualifiedName] + public CrossReference getRelationRelationCrossReference_0_0_0_0() { return cRelationRelationCrossReference_0_0_0_0; } + + //QualifiedName + public RuleCall getRelationRelationQualifiedNameParserRuleCall_0_0_0_0_1() { return cRelationRelationQualifiedNameParserRuleCall_0_0_0_0_1; } + + //"(" + public Keyword getLeftParenthesisKeyword_0_0_1() { return cLeftParenthesisKeyword_0_0_1; } + + //(arguments+=[Node|QualifiedName] ("," arguments+=[Node|QualifiedName])*)? + public Group getGroup_0_0_2() { return cGroup_0_0_2; } + + //arguments+=[Node|QualifiedName] + public Assignment getArgumentsAssignment_0_0_2_0() { return cArgumentsAssignment_0_0_2_0; } + + //[Node|QualifiedName] + public CrossReference getArgumentsNodeCrossReference_0_0_2_0_0() { return cArgumentsNodeCrossReference_0_0_2_0_0; } + + //QualifiedName + public RuleCall getArgumentsNodeQualifiedNameParserRuleCall_0_0_2_0_0_1() { return cArgumentsNodeQualifiedNameParserRuleCall_0_0_2_0_0_1; } + + //("," arguments+=[Node|QualifiedName])* + public Group getGroup_0_0_2_1() { return cGroup_0_0_2_1; } + + //"," + public Keyword getCommaKeyword_0_0_2_1_0() { return cCommaKeyword_0_0_2_1_0; } + + //arguments+=[Node|QualifiedName] + public Assignment getArgumentsAssignment_0_0_2_1_1() { return cArgumentsAssignment_0_0_2_1_1; } + + //[Node|QualifiedName] + public CrossReference getArgumentsNodeCrossReference_0_0_2_1_1_0() { return cArgumentsNodeCrossReference_0_0_2_1_1_0; } + + //QualifiedName + public RuleCall getArgumentsNodeQualifiedNameParserRuleCall_0_0_2_1_1_0_1() { return cArgumentsNodeQualifiedNameParserRuleCall_0_0_2_1_1_0_1; } + + //")" + public Keyword getRightParenthesisKeyword_0_0_3() { return cRightParenthesisKeyword_0_0_3; } + + //":" + public Keyword getColonKeyword_0_0_4() { return cColonKeyword_0_0_4; } + + //value=LogicValue + public Assignment getValueAssignment_0_0_5() { return cValueAssignment_0_0_5; } + + //LogicValue + public RuleCall getValueLogicValueEnumRuleCall_0_0_5_0() { return cValueLogicValueEnumRuleCall_0_0_5_0; } + + //value=ShortLogicValue? + //relation=[Relation|QualifiedName] + //"(" (arguments+=[Node|QualifiedName] ("," arguments+=[Node|QualifiedName])*)? ")" + public Group getGroup_0_1() { return cGroup_0_1; } + + //value=ShortLogicValue? + public Assignment getValueAssignment_0_1_0() { return cValueAssignment_0_1_0; } + + //ShortLogicValue + public RuleCall getValueShortLogicValueEnumRuleCall_0_1_0_0() { return cValueShortLogicValueEnumRuleCall_0_1_0_0; } + + //relation=[Relation|QualifiedName] + public Assignment getRelationAssignment_0_1_1() { return cRelationAssignment_0_1_1; } + + //[Relation|QualifiedName] + public CrossReference getRelationRelationCrossReference_0_1_1_0() { return cRelationRelationCrossReference_0_1_1_0; } + + //QualifiedName + public RuleCall getRelationRelationQualifiedNameParserRuleCall_0_1_1_0_1() { return cRelationRelationQualifiedNameParserRuleCall_0_1_1_0_1; } + + //"(" + public Keyword getLeftParenthesisKeyword_0_1_2() { return cLeftParenthesisKeyword_0_1_2; } + + //(arguments+=[Node|QualifiedName] ("," arguments+=[Node|QualifiedName])*)? + public Group getGroup_0_1_3() { return cGroup_0_1_3; } + + //arguments+=[Node|QualifiedName] + public Assignment getArgumentsAssignment_0_1_3_0() { return cArgumentsAssignment_0_1_3_0; } + + //[Node|QualifiedName] + public CrossReference getArgumentsNodeCrossReference_0_1_3_0_0() { return cArgumentsNodeCrossReference_0_1_3_0_0; } + + //QualifiedName + public RuleCall getArgumentsNodeQualifiedNameParserRuleCall_0_1_3_0_0_1() { return cArgumentsNodeQualifiedNameParserRuleCall_0_1_3_0_0_1; } + + //("," arguments+=[Node|QualifiedName])* + public Group getGroup_0_1_3_1() { return cGroup_0_1_3_1; } + + //"," + public Keyword getCommaKeyword_0_1_3_1_0() { return cCommaKeyword_0_1_3_1_0; } + + //arguments+=[Node|QualifiedName] + public Assignment getArgumentsAssignment_0_1_3_1_1() { return cArgumentsAssignment_0_1_3_1_1; } + + //[Node|QualifiedName] + public CrossReference getArgumentsNodeCrossReference_0_1_3_1_1_0() { return cArgumentsNodeCrossReference_0_1_3_1_1_0; } + + //QualifiedName + public RuleCall getArgumentsNodeQualifiedNameParserRuleCall_0_1_3_1_1_0_1() { return cArgumentsNodeQualifiedNameParserRuleCall_0_1_3_1_1_0_1; } + + //")" + public Keyword getRightParenthesisKeyword_0_1_4() { return cRightParenthesisKeyword_0_1_4; } + + //"." + public Keyword getFullStopKeyword_1() { return cFullStopKeyword_1; } + } + public class ScopeDeclarationElements extends AbstractParserRuleElementFinder { + private final ParserRule rule = (ParserRule) GrammarUtil.findRuleForName(getGrammar(), "org.eclipse.viatra.solver.language.Problem.ScopeDeclaration"); + private final Group cGroup = (Group)rule.eContents().get(1); + private final Keyword cScopeKeyword_0 = (Keyword)cGroup.eContents().get(0); + private final Assignment cTypeScopesAssignment_1 = (Assignment)cGroup.eContents().get(1); + private final RuleCall cTypeScopesTypeScopeParserRuleCall_1_0 = (RuleCall)cTypeScopesAssignment_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 cTypeScopesAssignment_2_1 = (Assignment)cGroup_2.eContents().get(1); + private final RuleCall cTypeScopesTypeScopeParserRuleCall_2_1_0 = (RuleCall)cTypeScopesAssignment_2_1.eContents().get(0); + private final Keyword cFullStopKeyword_3 = (Keyword)cGroup.eContents().get(3); + + //ScopeDeclaration: + // "scope" typeScopes+=TypeScope ("," typeScopes+=TypeScope)* "."; + @Override public ParserRule getRule() { return rule; } + + //"scope" typeScopes+=TypeScope ("," typeScopes+=TypeScope)* "." + public Group getGroup() { return cGroup; } + + //"scope" + public Keyword getScopeKeyword_0() { return cScopeKeyword_0; } + + //typeScopes+=TypeScope + public Assignment getTypeScopesAssignment_1() { return cTypeScopesAssignment_1; } + + //TypeScope + public RuleCall getTypeScopesTypeScopeParserRuleCall_1_0() { return cTypeScopesTypeScopeParserRuleCall_1_0; } + + //("," typeScopes+=TypeScope)* + public Group getGroup_2() { return cGroup_2; } + + //"," + public Keyword getCommaKeyword_2_0() { return cCommaKeyword_2_0; } + + //typeScopes+=TypeScope + public Assignment getTypeScopesAssignment_2_1() { return cTypeScopesAssignment_2_1; } + + //TypeScope + public RuleCall getTypeScopesTypeScopeParserRuleCall_2_1_0() { return cTypeScopesTypeScopeParserRuleCall_2_1_0; } + + //"." + public Keyword getFullStopKeyword_3() { return cFullStopKeyword_3; } + } + public class TypeScopeElements extends AbstractParserRuleElementFinder { + private final ParserRule rule = (ParserRule) GrammarUtil.findRuleForName(getGrammar(), "org.eclipse.viatra.solver.language.Problem.TypeScope"); + private final Group cGroup = (Group)rule.eContents().get(1); + private final Assignment cTargetTypeAssignment_0 = (Assignment)cGroup.eContents().get(0); + private final CrossReference cTargetTypeClassDeclarationCrossReference_0_0 = (CrossReference)cTargetTypeAssignment_0.eContents().get(0); + private final RuleCall cTargetTypeClassDeclarationIDTerminalRuleCall_0_0_1 = (RuleCall)cTargetTypeClassDeclarationCrossReference_0_0.eContents().get(1); + private final Alternatives cAlternatives_1 = (Alternatives)cGroup.eContents().get(1); + private final Assignment cIncrementAssignment_1_0 = (Assignment)cAlternatives_1.eContents().get(0); + private final Keyword cIncrementPlusSignEqualsSignKeyword_1_0_0 = (Keyword)cIncrementAssignment_1_0.eContents().get(0); + private final Keyword cEqualsSignKeyword_1_1 = (Keyword)cAlternatives_1.eContents().get(1); + private final Assignment cMultiplicityAssignment_2 = (Assignment)cGroup.eContents().get(2); + private final RuleCall cMultiplicityDefiniteMultiplicityParserRuleCall_2_0 = (RuleCall)cMultiplicityAssignment_2.eContents().get(0); + + //TypeScope: + // targetType=[ClassDeclaration] + // (increment?="+=" | "=") + // multiplicity=DefiniteMultiplicity; + @Override public ParserRule getRule() { return rule; } + + //targetType=[ClassDeclaration] + //(increment?="+=" | "=") + //multiplicity=DefiniteMultiplicity + public Group getGroup() { return cGroup; } + + //targetType=[ClassDeclaration] + public Assignment getTargetTypeAssignment_0() { return cTargetTypeAssignment_0; } + + //[ClassDeclaration] + public CrossReference getTargetTypeClassDeclarationCrossReference_0_0() { return cTargetTypeClassDeclarationCrossReference_0_0; } + + //ID + public RuleCall getTargetTypeClassDeclarationIDTerminalRuleCall_0_0_1() { return cTargetTypeClassDeclarationIDTerminalRuleCall_0_0_1; } + + //(increment?="+=" | "=") + public Alternatives getAlternatives_1() { return cAlternatives_1; } + + //increment?="+=" + public Assignment getIncrementAssignment_1_0() { return cIncrementAssignment_1_0; } + + //"+=" + public Keyword getIncrementPlusSignEqualsSignKeyword_1_0_0() { return cIncrementPlusSignEqualsSignKeyword_1_0_0; } + + //"=" + public Keyword getEqualsSignKeyword_1_1() { return cEqualsSignKeyword_1_1; } + + //multiplicity=DefiniteMultiplicity + public Assignment getMultiplicityAssignment_2() { return cMultiplicityAssignment_2; } + + //DefiniteMultiplicity + public RuleCall getMultiplicityDefiniteMultiplicityParserRuleCall_2_0() { return cMultiplicityDefiniteMultiplicityParserRuleCall_2_0; } + } + public class MultiplicityElements extends AbstractParserRuleElementFinder { + private final ParserRule rule = (ParserRule) GrammarUtil.findRuleForName(getGrammar(), "org.eclipse.viatra.solver.language.Problem.Multiplicity"); + private final Alternatives cAlternatives = (Alternatives)rule.eContents().get(1); + private final RuleCall cUnboundedMultiplicityParserRuleCall_0 = (RuleCall)cAlternatives.eContents().get(0); + private final RuleCall cDefiniteMultiplicityParserRuleCall_1 = (RuleCall)cAlternatives.eContents().get(1); + + //Multiplicity: + // UnboundedMultiplicity | DefiniteMultiplicity; + @Override public ParserRule getRule() { return rule; } + + //UnboundedMultiplicity | DefiniteMultiplicity + public Alternatives getAlternatives() { return cAlternatives; } + + //UnboundedMultiplicity + public RuleCall getUnboundedMultiplicityParserRuleCall_0() { return cUnboundedMultiplicityParserRuleCall_0; } + + //DefiniteMultiplicity + public RuleCall getDefiniteMultiplicityParserRuleCall_1() { return cDefiniteMultiplicityParserRuleCall_1; } + } + public class DefiniteMultiplicityElements extends AbstractParserRuleElementFinder { + private final ParserRule rule = (ParserRule) GrammarUtil.findRuleForName(getGrammar(), "org.eclipse.viatra.solver.language.Problem.DefiniteMultiplicity"); + private final Alternatives cAlternatives = (Alternatives)rule.eContents().get(1); + private final RuleCall cRangeMultiplicityParserRuleCall_0 = (RuleCall)cAlternatives.eContents().get(0); + private final RuleCall cExactMultiplicityParserRuleCall_1 = (RuleCall)cAlternatives.eContents().get(1); + + //DefiniteMultiplicity returns Multiplicity: + // RangeMultiplicity | ExactMultiplicity; + @Override public ParserRule getRule() { return rule; } + + //RangeMultiplicity | ExactMultiplicity + public Alternatives getAlternatives() { return cAlternatives; } + + //RangeMultiplicity + public RuleCall getRangeMultiplicityParserRuleCall_0() { return cRangeMultiplicityParserRuleCall_0; } + + //ExactMultiplicity + public RuleCall getExactMultiplicityParserRuleCall_1() { return cExactMultiplicityParserRuleCall_1; } + } + public class UnboundedMultiplicityElements extends AbstractParserRuleElementFinder { + private final ParserRule rule = (ParserRule) GrammarUtil.findRuleForName(getGrammar(), "org.eclipse.viatra.solver.language.Problem.UnboundedMultiplicity"); + private final Action cUnboundedMultiplicityAction = (Action)rule.eContents().get(1); + + //UnboundedMultiplicity: + // {UnboundedMultiplicity}; + @Override public ParserRule getRule() { return rule; } + + //{UnboundedMultiplicity} + public Action getUnboundedMultiplicityAction() { return cUnboundedMultiplicityAction; } + } + public class RangeMultiplicityElements extends AbstractParserRuleElementFinder { + private final ParserRule rule = (ParserRule) GrammarUtil.findRuleForName(getGrammar(), "org.eclipse.viatra.solver.language.Problem.RangeMultiplicity"); + private final Group cGroup = (Group)rule.eContents().get(1); + private final Assignment cLowerBoundAssignment_0 = (Assignment)cGroup.eContents().get(0); + private final RuleCall cLowerBoundINTTerminalRuleCall_0_0 = (RuleCall)cLowerBoundAssignment_0.eContents().get(0); + private final Keyword cFullStopFullStopKeyword_1 = (Keyword)cGroup.eContents().get(1); + private final Assignment cUpperBoundAssignment_2 = (Assignment)cGroup.eContents().get(2); + private final RuleCall cUpperBoundUpperBoundParserRuleCall_2_0 = (RuleCall)cUpperBoundAssignment_2.eContents().get(0); + + //RangeMultiplicity: + // lowerBound=INT ".." upperBound=UpperBound; + @Override public ParserRule getRule() { return rule; } + + //lowerBound=INT ".." upperBound=UpperBound + public Group getGroup() { return cGroup; } + + //lowerBound=INT + public Assignment getLowerBoundAssignment_0() { return cLowerBoundAssignment_0; } + + //INT + public RuleCall getLowerBoundINTTerminalRuleCall_0_0() { return cLowerBoundINTTerminalRuleCall_0_0; } + + //".." + public Keyword getFullStopFullStopKeyword_1() { return cFullStopFullStopKeyword_1; } + + //upperBound=UpperBound + public Assignment getUpperBoundAssignment_2() { return cUpperBoundAssignment_2; } + + //UpperBound + public RuleCall getUpperBoundUpperBoundParserRuleCall_2_0() { return cUpperBoundUpperBoundParserRuleCall_2_0; } + } + public class ExactMultiplicityElements extends AbstractParserRuleElementFinder { + private final ParserRule rule = (ParserRule) GrammarUtil.findRuleForName(getGrammar(), "org.eclipse.viatra.solver.language.Problem.ExactMultiplicity"); + private final Assignment cExactValueAssignment = (Assignment)rule.eContents().get(1); + private final RuleCall cExactValueINTTerminalRuleCall_0 = (RuleCall)cExactValueAssignment.eContents().get(0); + + //ExactMultiplicity: + // exactValue=INT; + @Override public ParserRule getRule() { return rule; } + + //exactValue=INT + public Assignment getExactValueAssignment() { return cExactValueAssignment; } + + //INT + public RuleCall getExactValueINTTerminalRuleCall_0() { return cExactValueINTTerminalRuleCall_0; } + } + public class UpperBoundElements extends AbstractParserRuleElementFinder { + private final ParserRule rule = (ParserRule) GrammarUtil.findRuleForName(getGrammar(), "org.eclipse.viatra.solver.language.Problem.UpperBound"); + private final Alternatives cAlternatives = (Alternatives)rule.eContents().get(1); + private final RuleCall cINTTerminalRuleCall_0 = (RuleCall)cAlternatives.eContents().get(0); + private final Keyword cAsteriskKeyword_1 = (Keyword)cAlternatives.eContents().get(1); + + //UpperBound returns ecore::EInt: + // INT | "*"; + @Override public ParserRule getRule() { return rule; } + + //INT | "*" + public Alternatives getAlternatives() { return cAlternatives; } + + //INT + public RuleCall getINTTerminalRuleCall_0() { return cINTTerminalRuleCall_0; } + + //"*" + public Keyword getAsteriskKeyword_1() { return cAsteriskKeyword_1; } + } + public class QuotedOrUnquotedIdElements extends AbstractParserRuleElementFinder { + private final ParserRule rule = (ParserRule) GrammarUtil.findRuleForName(getGrammar(), "org.eclipse.viatra.solver.language.Problem.QuotedOrUnquotedId"); + private final Alternatives cAlternatives = (Alternatives)rule.eContents().get(1); + private final RuleCall cQUOTED_IDTerminalRuleCall_0 = (RuleCall)cAlternatives.eContents().get(0); + private final RuleCall cIdentifierParserRuleCall_1 = (RuleCall)cAlternatives.eContents().get(1); + + //QuotedOrUnquotedId: + // QUOTED_ID | Identifier; + @Override public ParserRule getRule() { return rule; } + + //QUOTED_ID | Identifier + public Alternatives getAlternatives() { return cAlternatives; } + + //QUOTED_ID + public RuleCall getQUOTED_IDTerminalRuleCall_0() { return cQUOTED_IDTerminalRuleCall_0; } + + //Identifier + public RuleCall getIdentifierParserRuleCall_1() { return cIdentifierParserRuleCall_1; } + } + public class QualifiedNameElements extends AbstractParserRuleElementFinder { + private final ParserRule rule = (ParserRule) GrammarUtil.findRuleForName(getGrammar(), "org.eclipse.viatra.solver.language.Problem.QualifiedName"); + private final Alternatives cAlternatives = (Alternatives)rule.eContents().get(1); + private final RuleCall cQUOTED_IDTerminalRuleCall_0 = (RuleCall)cAlternatives.eContents().get(0); + private final Group cGroup_1 = (Group)cAlternatives.eContents().get(1); + private final RuleCall cIdentifierParserRuleCall_1_0 = (RuleCall)cGroup_1.eContents().get(0); + private final Group cGroup_1_1 = (Group)cGroup_1.eContents().get(1); + private final Keyword cColonKeyword_1_1_0 = (Keyword)cGroup_1_1.eContents().get(0); + private final RuleCall cIdentifierParserRuleCall_1_1_1 = (RuleCall)cGroup_1_1.eContents().get(1); + private final Group cGroup_1_2 = (Group)cGroup_1.eContents().get(2); + private final Keyword cColonKeyword_1_2_0 = (Keyword)cGroup_1_2.eContents().get(0); + private final RuleCall cQUOTED_IDTerminalRuleCall_1_2_1 = (RuleCall)cGroup_1_2.eContents().get(1); + + //QualifiedName: + // QUOTED_ID | Identifier (":" Identifier)* (":" QUOTED_ID)?; + @Override public ParserRule getRule() { return rule; } + + //QUOTED_ID | Identifier (":" Identifier)* (":" QUOTED_ID)? + public Alternatives getAlternatives() { return cAlternatives; } + + //QUOTED_ID + public RuleCall getQUOTED_IDTerminalRuleCall_0() { return cQUOTED_IDTerminalRuleCall_0; } + + //Identifier (":" Identifier)* (":" QUOTED_ID)? + public Group getGroup_1() { return cGroup_1; } + + //Identifier + public RuleCall getIdentifierParserRuleCall_1_0() { return cIdentifierParserRuleCall_1_0; } + + //(":" Identifier)* + public Group getGroup_1_1() { return cGroup_1_1; } + + //":" + public Keyword getColonKeyword_1_1_0() { return cColonKeyword_1_1_0; } + + //Identifier + public RuleCall getIdentifierParserRuleCall_1_1_1() { return cIdentifierParserRuleCall_1_1_1; } + + //(":" QUOTED_ID)? + public Group getGroup_1_2() { return cGroup_1_2; } + + //":" + public Keyword getColonKeyword_1_2_0() { return cColonKeyword_1_2_0; } + + //QUOTED_ID + public RuleCall getQUOTED_IDTerminalRuleCall_1_2_1() { return cQUOTED_IDTerminalRuleCall_1_2_1; } + } + public class IdentifierElements extends AbstractParserRuleElementFinder { + private final ParserRule rule = (ParserRule) GrammarUtil.findRuleForName(getGrammar(), "org.eclipse.viatra.solver.language.Problem.Identifier"); + private final Alternatives cAlternatives = (Alternatives)rule.eContents().get(1); + private final RuleCall cIDTerminalRuleCall_0 = (RuleCall)cAlternatives.eContents().get(0); + private final Keyword cTrueKeyword_1 = (Keyword)cAlternatives.eContents().get(1); + private final Keyword cFalseKeyword_2 = (Keyword)cAlternatives.eContents().get(2); + + //Identifier: + // ID | "true" | "false"; + @Override public ParserRule getRule() { return rule; } + + //ID | "true" | "false" + public Alternatives getAlternatives() { return cAlternatives; } + + //ID + public RuleCall getIDTerminalRuleCall_0() { return cIDTerminalRuleCall_0; } + + //"true" + public Keyword getTrueKeyword_1() { return cTrueKeyword_1; } + + //"false" + public Keyword getFalseKeyword_2() { return cFalseKeyword_2; } + } + + public class LogicValueElements extends AbstractElementFinder.AbstractEnumRuleElementFinder { + private final EnumRule rule = (EnumRule) GrammarUtil.findRuleForName(getGrammar(), "org.eclipse.viatra.solver.language.Problem.LogicValue"); + private final Alternatives cAlternatives = (Alternatives)rule.eContents().get(1); + private final EnumLiteralDeclaration cTRUEEnumLiteralDeclaration_0 = (EnumLiteralDeclaration)cAlternatives.eContents().get(0); + private final Keyword cTRUETrueKeyword_0_0 = (Keyword)cTRUEEnumLiteralDeclaration_0.eContents().get(0); + private final EnumLiteralDeclaration cFALSEEnumLiteralDeclaration_1 = (EnumLiteralDeclaration)cAlternatives.eContents().get(1); + private final Keyword cFALSEFalseKeyword_1_0 = (Keyword)cFALSEEnumLiteralDeclaration_1.eContents().get(0); + private final EnumLiteralDeclaration cUNKNOWNEnumLiteralDeclaration_2 = (EnumLiteralDeclaration)cAlternatives.eContents().get(2); + private final Keyword cUNKNOWNUnknownKeyword_2_0 = (Keyword)cUNKNOWNEnumLiteralDeclaration_2.eContents().get(0); + + //enum LogicValue: + // TRUE="true" | FALSE="false" | UNKNOWN="unknown"; + public EnumRule getRule() { return rule; } + + //TRUE="true" | FALSE="false" | UNKNOWN="unknown" + public Alternatives getAlternatives() { return cAlternatives; } + + //TRUE="true" + public EnumLiteralDeclaration getTRUEEnumLiteralDeclaration_0() { return cTRUEEnumLiteralDeclaration_0; } + + //"true" + public Keyword getTRUETrueKeyword_0_0() { return cTRUETrueKeyword_0_0; } + + //FALSE="false" + public EnumLiteralDeclaration getFALSEEnumLiteralDeclaration_1() { return cFALSEEnumLiteralDeclaration_1; } + + //"false" + public Keyword getFALSEFalseKeyword_1_0() { return cFALSEFalseKeyword_1_0; } + + //UNKNOWN="unknown" + public EnumLiteralDeclaration getUNKNOWNEnumLiteralDeclaration_2() { return cUNKNOWNEnumLiteralDeclaration_2; } + + //"unknown" + public Keyword getUNKNOWNUnknownKeyword_2_0() { return cUNKNOWNUnknownKeyword_2_0; } + } + public class ShortLogicValueElements extends AbstractElementFinder.AbstractEnumRuleElementFinder { + private final EnumRule rule = (EnumRule) GrammarUtil.findRuleForName(getGrammar(), "org.eclipse.viatra.solver.language.Problem.ShortLogicValue"); + private final Alternatives cAlternatives = (Alternatives)rule.eContents().get(1); + private final EnumLiteralDeclaration cFALSEEnumLiteralDeclaration_0 = (EnumLiteralDeclaration)cAlternatives.eContents().get(0); + private final Keyword cFALSEExclamationMarkKeyword_0_0 = (Keyword)cFALSEEnumLiteralDeclaration_0.eContents().get(0); + private final EnumLiteralDeclaration cUNKNOWNEnumLiteralDeclaration_1 = (EnumLiteralDeclaration)cAlternatives.eContents().get(1); + private final Keyword cUNKNOWNQuestionMarkKeyword_1_0 = (Keyword)cUNKNOWNEnumLiteralDeclaration_1.eContents().get(0); + + //enum ShortLogicValue returns LogicValue: + // FALSE="!" | UNKNOWN="?"; + public EnumRule getRule() { return rule; } + + //FALSE="!" | UNKNOWN="?" + public Alternatives getAlternatives() { return cAlternatives; } + + //FALSE="!" + public EnumLiteralDeclaration getFALSEEnumLiteralDeclaration_0() { return cFALSEEnumLiteralDeclaration_0; } + + //"!" + public Keyword getFALSEExclamationMarkKeyword_0_0() { return cFALSEExclamationMarkKeyword_0_0; } + + //UNKNOWN="?" + public EnumLiteralDeclaration getUNKNOWNEnumLiteralDeclaration_1() { return cUNKNOWNEnumLiteralDeclaration_1; } + + //"?" + public Keyword getUNKNOWNQuestionMarkKeyword_1_0() { return cUNKNOWNQuestionMarkKeyword_1_0; } + } + + private final ProblemElements pProblem; + private final StatementElements pStatement; + private final ClassDeclarationElements pClassDeclaration; + private final EnumDeclarationElements pEnumDeclaration; + private final EnumLiteralElements pEnumLiteral; + private final ReferenceDeclarationElements pReferenceDeclaration; + private final PredicateDefinitionElements pPredicateDefinition; + private final ParameterElements pParameter; + private final ConjunctionElements pConjunction; + private final LiteralElements pLiteral; + private final NegativeLiteralElements pNegativeLiteral; + private final AtomElements pAtom; + private final ArgumentElements pArgument; + private final AssertionElements pAssertion; + private final LogicValueElements eLogicValue; + private final ShortLogicValueElements eShortLogicValue; + private final ScopeDeclarationElements pScopeDeclaration; + private final TypeScopeElements pTypeScope; + private final MultiplicityElements pMultiplicity; + private final DefiniteMultiplicityElements pDefiniteMultiplicity; + private final UnboundedMultiplicityElements pUnboundedMultiplicity; + private final RangeMultiplicityElements pRangeMultiplicity; + private final ExactMultiplicityElements pExactMultiplicity; + private final UpperBoundElements pUpperBound; + private final QuotedOrUnquotedIdElements pQuotedOrUnquotedId; + private final QualifiedNameElements pQualifiedName; + private final IdentifierElements pIdentifier; + private final TerminalRule tSTRING; + private final TerminalRule tQUOTED_ID; + + private final Grammar grammar; + + private final TerminalsGrammarAccess gaTerminals; + + @Inject + public ProblemGrammarAccess(GrammarProvider grammarProvider, + TerminalsGrammarAccess gaTerminals) { + this.grammar = internalFindGrammar(grammarProvider); + this.gaTerminals = gaTerminals; + this.pProblem = new ProblemElements(); + this.pStatement = new StatementElements(); + this.pClassDeclaration = new ClassDeclarationElements(); + this.pEnumDeclaration = new EnumDeclarationElements(); + this.pEnumLiteral = new EnumLiteralElements(); + this.pReferenceDeclaration = new ReferenceDeclarationElements(); + this.pPredicateDefinition = new PredicateDefinitionElements(); + this.pParameter = new ParameterElements(); + this.pConjunction = new ConjunctionElements(); + this.pLiteral = new LiteralElements(); + this.pNegativeLiteral = new NegativeLiteralElements(); + this.pAtom = new AtomElements(); + this.pArgument = new ArgumentElements(); + this.pAssertion = new AssertionElements(); + this.eLogicValue = new LogicValueElements(); + this.eShortLogicValue = new ShortLogicValueElements(); + this.pScopeDeclaration = new ScopeDeclarationElements(); + this.pTypeScope = new TypeScopeElements(); + this.pMultiplicity = new MultiplicityElements(); + this.pDefiniteMultiplicity = new DefiniteMultiplicityElements(); + this.pUnboundedMultiplicity = new UnboundedMultiplicityElements(); + this.pRangeMultiplicity = new RangeMultiplicityElements(); + this.pExactMultiplicity = new ExactMultiplicityElements(); + this.pUpperBound = new UpperBoundElements(); + this.pQuotedOrUnquotedId = new QuotedOrUnquotedIdElements(); + this.pQualifiedName = new QualifiedNameElements(); + this.pIdentifier = new IdentifierElements(); + this.tSTRING = (TerminalRule) GrammarUtil.findRuleForName(getGrammar(), "org.eclipse.viatra.solver.language.Problem.STRING"); + this.tQUOTED_ID = (TerminalRule) GrammarUtil.findRuleForName(getGrammar(), "org.eclipse.viatra.solver.language.Problem.QUOTED_ID"); + } + + protected Grammar internalFindGrammar(GrammarProvider grammarProvider) { + Grammar grammar = grammarProvider.getGrammar(this); + while (grammar != null) { + if ("org.eclipse.viatra.solver.language.Problem".equals(grammar.getName())) { + return grammar; + } + List grammars = grammar.getUsedGrammars(); + if (!grammars.isEmpty()) { + grammar = grammars.iterator().next(); + } else { + return null; + } + } + return grammar; + } + + @Override + public Grammar getGrammar() { + return grammar; + } + + + public TerminalsGrammarAccess getTerminalsGrammarAccess() { + return gaTerminals; + } + + + //Problem: + // ("problem" name=Identifier ".")? + // statements+=Statement*; + public ProblemElements getProblemAccess() { + return pProblem; + } + + public ParserRule getProblemRule() { + return getProblemAccess().getRule(); + } + + //Statement: + // ClassDeclaration | EnumDeclaration | PredicateDefinition | Assertion | ScopeDeclaration; + public StatementElements getStatementAccess() { + return pStatement; + } + + public ParserRule getStatementRule() { + return getStatementAccess().getRule(); + } + + //ClassDeclaration: + // abstract?="abstract"? "class" + // name=Identifier + // ("extends" superTypes+=[Relation|QualifiedName] ("," superTypes+=[Relation|QualifiedName])*)? + // ("{" (referenceDeclarations+=ReferenceDeclaration ";"?)* "}" | "."); + public ClassDeclarationElements getClassDeclarationAccess() { + return pClassDeclaration; + } + + public ParserRule getClassDeclarationRule() { + return getClassDeclarationAccess().getRule(); + } + + //EnumDeclaration: + // "enum" + // name=Identifier + // ("{" (literals+=EnumLiteral ("," literals+=EnumLiteral)* ("," | ";")?)? "}" | "."); + public EnumDeclarationElements getEnumDeclarationAccess() { + return pEnumDeclaration; + } + + public ParserRule getEnumDeclarationRule() { + return getEnumDeclarationAccess().getRule(); + } + + //EnumLiteral returns Node: + // name=QuotedOrUnquotedId; + public EnumLiteralElements getEnumLiteralAccess() { + return pEnumLiteral; + } + + public ParserRule getEnumLiteralRule() { + return getEnumLiteralAccess().getRule(); + } + + //ReferenceDeclaration: + // (containment?="contains" | "refers")? + // referenceType=[Relation|QualifiedName] + // ("[" multiplicity=Multiplicity "]")? + // name=Identifier + // ("opposite" opposite=[ReferenceDeclaration|QualifiedName])?; + public ReferenceDeclarationElements getReferenceDeclarationAccess() { + return pReferenceDeclaration; + } + + public ParserRule getReferenceDeclarationRule() { + return getReferenceDeclarationAccess().getRule(); + } + + //PredicateDefinition: + // (error?="error" "pred"? | "pred") + // name=Identifier + // "(" (parameters+=Parameter ("," parameters+=Parameter)*)? ")" + // (":-" bodies+=Conjunction (";" bodies+=Conjunction)*)? + // "."; + public PredicateDefinitionElements getPredicateDefinitionAccess() { + return pPredicateDefinition; + } + + public ParserRule getPredicateDefinitionRule() { + return getPredicateDefinitionAccess().getRule(); + } + + //Parameter: + // parameterType=[Relation|QualifiedName]? name=Identifier; + public ParameterElements getParameterAccess() { + return pParameter; + } + + public ParserRule getParameterRule() { + return getParameterAccess().getRule(); + } + + //Conjunction: + // literals+=Literal ("," literals+=Literal)*; + public ConjunctionElements getConjunctionAccess() { + return pConjunction; + } + + public ParserRule getConjunctionRule() { + return getConjunctionAccess().getRule(); + } + + //Literal: + // Atom | NegativeLiteral; + public LiteralElements getLiteralAccess() { + return pLiteral; + } + + public ParserRule getLiteralRule() { + return getLiteralAccess().getRule(); + } + + //NegativeLiteral: + // "!" atom=Atom; + public NegativeLiteralElements getNegativeLiteralAccess() { + return pNegativeLiteral; + } + + public ParserRule getNegativeLiteralRule() { + return getNegativeLiteralAccess().getRule(); + } + + //Atom: + // relation=[Relation|QualifiedName] + // transitiveClosure?="+"? + // "(" (arguments+=Argument ("," arguments+=Argument)*)? ")"; + public AtomElements getAtomAccess() { + return pAtom; + } + + public ParserRule getAtomRule() { + return getAtomAccess().getRule(); + } + + //Argument: + // variableOrNode=[VariableOrNode|QualifiedName]; + public ArgumentElements getArgumentAccess() { + return pArgument; + } + + public ParserRule getArgumentRule() { + return getArgumentAccess().getRule(); + } + + //Assertion: + // (relation=[Relation|QualifiedName] + // "(" (arguments+=[Node|QualifiedName] ("," arguments+=[Node|QualifiedName])*)? ")" + // ":" value=LogicValue | + // value=ShortLogicValue? + // relation=[Relation|QualifiedName] + // "(" (arguments+=[Node|QualifiedName] ("," arguments+=[Node|QualifiedName])*)? ")") + // "."; + public AssertionElements getAssertionAccess() { + return pAssertion; + } + + public ParserRule getAssertionRule() { + return getAssertionAccess().getRule(); + } + + //enum LogicValue: + // TRUE="true" | FALSE="false" | UNKNOWN="unknown"; + public LogicValueElements getLogicValueAccess() { + return eLogicValue; + } + + public EnumRule getLogicValueRule() { + return getLogicValueAccess().getRule(); + } + + //enum ShortLogicValue returns LogicValue: + // FALSE="!" | UNKNOWN="?"; + public ShortLogicValueElements getShortLogicValueAccess() { + return eShortLogicValue; + } + + public EnumRule getShortLogicValueRule() { + return getShortLogicValueAccess().getRule(); + } + + //ScopeDeclaration: + // "scope" typeScopes+=TypeScope ("," typeScopes+=TypeScope)* "."; + public ScopeDeclarationElements getScopeDeclarationAccess() { + return pScopeDeclaration; + } + + public ParserRule getScopeDeclarationRule() { + return getScopeDeclarationAccess().getRule(); + } + + //TypeScope: + // targetType=[ClassDeclaration] + // (increment?="+=" | "=") + // multiplicity=DefiniteMultiplicity; + public TypeScopeElements getTypeScopeAccess() { + return pTypeScope; + } + + public ParserRule getTypeScopeRule() { + return getTypeScopeAccess().getRule(); + } + + //Multiplicity: + // UnboundedMultiplicity | DefiniteMultiplicity; + public MultiplicityElements getMultiplicityAccess() { + return pMultiplicity; + } + + public ParserRule getMultiplicityRule() { + return getMultiplicityAccess().getRule(); + } + + //DefiniteMultiplicity returns Multiplicity: + // RangeMultiplicity | ExactMultiplicity; + public DefiniteMultiplicityElements getDefiniteMultiplicityAccess() { + return pDefiniteMultiplicity; + } + + public ParserRule getDefiniteMultiplicityRule() { + return getDefiniteMultiplicityAccess().getRule(); + } + + //UnboundedMultiplicity: + // {UnboundedMultiplicity}; + public UnboundedMultiplicityElements getUnboundedMultiplicityAccess() { + return pUnboundedMultiplicity; + } + + public ParserRule getUnboundedMultiplicityRule() { + return getUnboundedMultiplicityAccess().getRule(); + } + + //RangeMultiplicity: + // lowerBound=INT ".." upperBound=UpperBound; + public RangeMultiplicityElements getRangeMultiplicityAccess() { + return pRangeMultiplicity; + } + + public ParserRule getRangeMultiplicityRule() { + return getRangeMultiplicityAccess().getRule(); + } + + //ExactMultiplicity: + // exactValue=INT; + public ExactMultiplicityElements getExactMultiplicityAccess() { + return pExactMultiplicity; + } + + public ParserRule getExactMultiplicityRule() { + return getExactMultiplicityAccess().getRule(); + } + + //UpperBound returns ecore::EInt: + // INT | "*"; + public UpperBoundElements getUpperBoundAccess() { + return pUpperBound; + } + + public ParserRule getUpperBoundRule() { + return getUpperBoundAccess().getRule(); + } + + //QuotedOrUnquotedId: + // QUOTED_ID | Identifier; + public QuotedOrUnquotedIdElements getQuotedOrUnquotedIdAccess() { + return pQuotedOrUnquotedId; + } + + public ParserRule getQuotedOrUnquotedIdRule() { + return getQuotedOrUnquotedIdAccess().getRule(); + } + + //QualifiedName: + // QUOTED_ID | Identifier (":" Identifier)* (":" QUOTED_ID)?; + public QualifiedNameElements getQualifiedNameAccess() { + return pQualifiedName; + } + + public ParserRule getQualifiedNameRule() { + return getQualifiedNameAccess().getRule(); + } + + //Identifier: + // ID | "true" | "false"; + public IdentifierElements getIdentifierAccess() { + return pIdentifier; + } + + public ParserRule getIdentifierRule() { + return getIdentifierAccess().getRule(); + } + + //@Override + //terminal STRING: + // '"' ('\\' . /* 'b'|'t'|'n'|'f'|'r'|'u'|'"'|"'"|'\\' */ | !('\\' | '"'))* '"'; + public TerminalRule getSTRINGRule() { + return tSTRING; + } + + //terminal QUOTED_ID: + // "'" ('\\' . /* 'b'|'t'|'n'|'f'|'r'|'u'|'"'|"'"|'\\' */ | !('\\' | "'"))* "'"; + public TerminalRule getQUOTED_IDRule() { + return tQUOTED_ID; + } + + //terminal ID: '^'?('a'..'z'|'A'..'Z'|'_') ('a'..'z'|'A'..'Z'|'_'|'0'..'9')*; + public TerminalRule getIDRule() { + return gaTerminals.getIDRule(); + } + + //terminal INT returns ecore::EInt: ('0'..'9')+; + public TerminalRule getINTRule() { + return gaTerminals.getINTRule(); + } + + //terminal ML_COMMENT : '/*' -> '*/'; + public TerminalRule getML_COMMENTRule() { + return gaTerminals.getML_COMMENTRule(); + } + + //terminal SL_COMMENT : '//' !('\n'|'\r')* ('\r'? '\n')?; + public TerminalRule getSL_COMMENTRule() { + return gaTerminals.getSL_COMMENTRule(); + } + + //terminal WS : (' '|'\t'|'\r'|'\n')+; + public TerminalRule getWSRule() { + return gaTerminals.getWSRule(); + } + + //terminal ANY_OTHER: .; + public TerminalRule getANY_OTHERRule() { + return gaTerminals.getANY_OTHERRule(); + } +} diff --git a/language/src/main/xtext-gen/org/eclipse/viatra/solver/language/validation/AbstractProblemValidator.java b/language/src/main/xtext-gen/org/eclipse/viatra/solver/language/validation/AbstractProblemValidator.java new file mode 100644 index 00000000..9cd73e1e --- /dev/null +++ b/language/src/main/xtext-gen/org/eclipse/viatra/solver/language/validation/AbstractProblemValidator.java @@ -0,0 +1,19 @@ +/* + * generated by Xtext 2.26.0.M1 + */ +package org.eclipse.viatra.solver.language.validation; + +import java.util.ArrayList; +import java.util.List; +import org.eclipse.emf.ecore.EPackage; +import org.eclipse.xtext.validation.AbstractDeclarativeValidator; + +public abstract class AbstractProblemValidator extends AbstractDeclarativeValidator { + + @Override + protected List getEPackages() { + List result = new ArrayList(); + result.add(EPackage.Registry.INSTANCE.getEPackage("http://www.eclipse.org/viatra/solver/language/model/Problem")); + return result; + } +} diff --git a/language/src/main/xtext-gen/org/eclipse/viatra/solver/language/validation/ProblemConfigurableIssueCodesProvider.java b/language/src/main/xtext-gen/org/eclipse/viatra/solver/language/validation/ProblemConfigurableIssueCodesProvider.java new file mode 100644 index 00000000..f5a0d87d --- /dev/null +++ b/language/src/main/xtext-gen/org/eclipse/viatra/solver/language/validation/ProblemConfigurableIssueCodesProvider.java @@ -0,0 +1,22 @@ +/* + * generated by Xtext 2.26.0.M1 + */ +package org.eclipse.viatra.solver.language.validation; + +import org.eclipse.xtext.preferences.PreferenceKey; +import org.eclipse.xtext.util.IAcceptor; +import org.eclipse.xtext.validation.ConfigurableIssueCodesProvider; +import org.eclipse.xtext.validation.SeverityConverter; + +@SuppressWarnings("restriction") +public class ProblemConfigurableIssueCodesProvider extends ConfigurableIssueCodesProvider { + protected static final String ISSUE_CODE_PREFIX = "org.eclipse.viatra.solver.language."; + + public static final String DEPRECATED_MODEL_PART = ISSUE_CODE_PREFIX + "deprecatedModelPart"; + + @Override + protected void initialize(IAcceptor acceptor) { + super.initialize(acceptor); + acceptor.accept(create(DEPRECATED_MODEL_PART, SeverityConverter.SEVERITY_WARNING)); + } +} diff --git a/language/src/test/java/org/eclipse/viatra/solver/language/tests/ProblemParsingTest.xtend b/language/src/test/java/org/eclipse/viatra/solver/language/tests/ProblemParsingTest.xtend new file mode 100644 index 00000000..b007cf8b --- /dev/null +++ b/language/src/test/java/org/eclipse/viatra/solver/language/tests/ProblemParsingTest.xtend @@ -0,0 +1,30 @@ +/* + * generated by Xtext 2.25.0 + */ +package org.eclipse.viatra.solver.language.tests + +import com.google.inject.Inject +import org.eclipse.viatra.solver.language.model.problem.Problem +import org.eclipse.xtext.testing.InjectWith +import org.eclipse.xtext.testing.extensions.InjectionExtension +import org.eclipse.xtext.testing.util.ParseHelper +import org.junit.jupiter.api.Assertions +import org.junit.jupiter.api.Test +import org.junit.jupiter.api.^extension.ExtendWith + +@ExtendWith(InjectionExtension) +@InjectWith(ProblemInjectorProvider) +class ProblemParsingTest { + @Inject + ParseHelper parseHelper + + @Test + def void loadModel() { + val result = parseHelper.parse(''' + Hello Xtext! + ''') + Assertions.assertNotNull(result) + val errors = result.eResource.errors + Assertions.assertTrue(errors.isEmpty, '''Unexpected errors: «errors.join(", ")»''') + } +} diff --git a/language/src/test/xtext-gen/org/eclipse/viatra/solver/language/tests/ProblemInjectorProvider.java b/language/src/test/xtext-gen/org/eclipse/viatra/solver/language/tests/ProblemInjectorProvider.java new file mode 100644 index 00000000..7d0ef1bb --- /dev/null +++ b/language/src/test/xtext-gen/org/eclipse/viatra/solver/language/tests/ProblemInjectorProvider.java @@ -0,0 +1,69 @@ +/* + * generated by Xtext 2.26.0.M1 + */ +package org.eclipse.viatra.solver.language.tests; + +import com.google.inject.Guice; +import com.google.inject.Injector; +import org.eclipse.viatra.solver.language.ProblemRuntimeModule; +import org.eclipse.viatra.solver.language.ProblemStandaloneSetup; +import org.eclipse.xtext.testing.GlobalRegistries; +import org.eclipse.xtext.testing.GlobalRegistries.GlobalStateMemento; +import org.eclipse.xtext.testing.IInjectorProvider; +import org.eclipse.xtext.testing.IRegistryConfigurator; + +public class ProblemInjectorProvider implements IInjectorProvider, IRegistryConfigurator { + + protected GlobalStateMemento stateBeforeInjectorCreation; + protected GlobalStateMemento stateAfterInjectorCreation; + protected Injector injector; + + static { + GlobalRegistries.initializeDefaults(); + } + + @Override + public Injector getInjector() { + if (injector == null) { + this.injector = internalCreateInjector(); + stateAfterInjectorCreation = GlobalRegistries.makeCopyOfGlobalState(); + } + return injector; + } + + protected Injector internalCreateInjector() { + return new ProblemStandaloneSetup() { + @Override + public Injector createInjector() { + return Guice.createInjector(createRuntimeModule()); + } + }.createInjectorAndDoEMFRegistration(); + } + + protected ProblemRuntimeModule createRuntimeModule() { + // make it work also with Maven/Tycho and OSGI + // see https://bugs.eclipse.org/bugs/show_bug.cgi?id=493672 + return new ProblemRuntimeModule() { + @Override + public ClassLoader bindClassLoaderToInstance() { + return ProblemInjectorProvider.class + .getClassLoader(); + } + }; + } + + @Override + public void restoreRegistry() { + stateBeforeInjectorCreation.restoreGlobalState(); + stateBeforeInjectorCreation = null; + } + + @Override + public void setupRegistry() { + stateBeforeInjectorCreation = GlobalRegistries.makeCopyOfGlobalState(); + if (injector == null) { + getInjector(); + } + stateAfterInjectorCreation.restoreGlobalState(); + } +} -- cgit v1.2.3-70-g09d2