diff options
Diffstat (limited to 'Application/org.eclipse.viatra.solver.language')
49 files changed, 29204 insertions, 0 deletions
diff --git a/Application/org.eclipse.viatra.solver.language/.classpath b/Application/org.eclipse.viatra.solver.language/.classpath new file mode 100644 index 00000000..9081d4f7 --- /dev/null +++ b/Application/org.eclipse.viatra.solver.language/.classpath | |||
@@ -0,0 +1,9 @@ | |||
1 | <?xml version="1.0" encoding="UTF-8"?> | ||
2 | <classpath> | ||
3 | <classpathentry kind="src" path="src"/> | ||
4 | <classpathentry kind="src" path="src-gen"/> | ||
5 | <classpathentry kind="src" path="xtend-gen"/> | ||
6 | <classpathentry kind="con" path="org.eclipse.jdt.launching.JRE_CONTAINER/org.eclipse.jdt.internal.debug.ui.launcher.StandardVMType/JavaSE-1.8"/> | ||
7 | <classpathentry kind="con" path="org.eclipse.pde.core.requiredPlugins"/> | ||
8 | <classpathentry kind="output" path="bin"/> | ||
9 | </classpath> | ||
diff --git a/Application/org.eclipse.viatra.solver.language/.gitignore b/Application/org.eclipse.viatra.solver.language/.gitignore new file mode 100644 index 00000000..ae3c1726 --- /dev/null +++ b/Application/org.eclipse.viatra.solver.language/.gitignore | |||
@@ -0,0 +1 @@ | |||
/bin/ | |||
diff --git a/Application/org.eclipse.viatra.solver.language/.launch/Generate SolverLanguage (vsc) Language Infrastructure.launch b/Application/org.eclipse.viatra.solver.language/.launch/Generate SolverLanguage (vsc) Language Infrastructure.launch new file mode 100644 index 00000000..84e7be08 --- /dev/null +++ b/Application/org.eclipse.viatra.solver.language/.launch/Generate SolverLanguage (vsc) Language Infrastructure.launch | |||
@@ -0,0 +1,18 @@ | |||
1 | <?xml version="1.0" encoding="UTF-8" standalone="no"?> | ||
2 | <launchConfiguration type="org.eclipse.emf.mwe2.launch.Mwe2LaunchConfigurationType"> | ||
3 | <listAttribute key="org.eclipse.debug.core.MAPPED_RESOURCE_PATHS"> | ||
4 | <listEntry value="/org.eclipse.viatra.solver.language"/> | ||
5 | </listAttribute> | ||
6 | <listAttribute key="org.eclipse.debug.core.MAPPED_RESOURCE_TYPES"> | ||
7 | <listEntry value="4"/> | ||
8 | </listAttribute> | ||
9 | <listAttribute key="org.eclipse.debug.ui.favoriteGroups"> | ||
10 | <listEntry value="org.eclipse.debug.ui.launchGroup.debug"/> | ||
11 | <listEntry value="org.eclipse.debug.ui.launchGroup.run"/> | ||
12 | </listAttribute> | ||
13 | <stringAttribute key="org.eclipse.debug.core.ATTR_REFRESH_SCOPE" value="${working_set:<?xml version="1.0" encoding="UTF-8"?> <resources> <item path="/org.eclipse.viatra.solver.language" type="4"/> <item path="/org.eclipse.viatra.solver.language.ide" type="4"/> <item path="/org.eclipse.viatra.solver.language.ui" type="4"/> <item path="/org.eclipse.viatra.solver.language.tests" type="4"/> <item path="/org.eclipse.viatra.solver.language.ui.tests" type="4"/> <item path="/org.eclipse.viatra.solver.language.tests" type="4"/> <item path="/org.eclipse.viatra.solver.language.ui.tests" type="4"/> ;</resources>}"/> | ||
14 | <stringAttribute key="org.eclipse.jdt.launching.MAIN_TYPE" value="org.eclipse.emf.mwe2.launch.runtime.Mwe2Launcher"/> | ||
15 | <stringAttribute key="org.eclipse.jdt.launching.PROGRAM_ARGUMENTS" value="org.eclipse.viatra.solver.language.GenerateSolverLanguage"/> | ||
16 | <stringAttribute key="org.eclipse.jdt.launching.PROJECT_ATTR" value="org.eclipse.viatra.solver.language"/> | ||
17 | <stringAttribute key="org.eclipse.jdt.launching.VM_ARGUMENTS" value="-Xmx512m"/> | ||
18 | </launchConfiguration> | ||
diff --git a/Application/org.eclipse.viatra.solver.language/.launch/Launch Runtime Eclipse.launch b/Application/org.eclipse.viatra.solver.language/.launch/Launch Runtime Eclipse.launch new file mode 100644 index 00000000..1e189f24 --- /dev/null +++ b/Application/org.eclipse.viatra.solver.language/.launch/Launch Runtime Eclipse.launch | |||
@@ -0,0 +1,35 @@ | |||
1 | <?xml version="1.0" encoding="UTF-8" standalone="no"?> | ||
2 | <launchConfiguration type="org.eclipse.pde.ui.RuntimeWorkbench"> | ||
3 | <booleanAttribute key="append.args" value="true"/> | ||
4 | <booleanAttribute key="askclear" value="true"/> | ||
5 | <booleanAttribute key="automaticAdd" value="true"/> | ||
6 | <booleanAttribute key="automaticValidate" value="false"/> | ||
7 | <stringAttribute key="bad_container_name" value="/org.eclipse.viatra.solver.language/.launch/"/> | ||
8 | <stringAttribute key="bootstrap" value=""/> | ||
9 | <stringAttribute key="checked" value="[NONE]"/> | ||
10 | <booleanAttribute key="clearConfig" value="false"/> | ||
11 | <booleanAttribute key="clearws" value="false"/> | ||
12 | <booleanAttribute key="clearwslog" value="false"/> | ||
13 | <stringAttribute key="configLocation" value="${workspace_loc}/.metadata/.plugins/org.eclipse.pde.core/Launch Runtime Eclipse"/> | ||
14 | <booleanAttribute key="default" value="true"/> | ||
15 | <booleanAttribute key="includeOptional" value="true"/> | ||
16 | <stringAttribute key="location" value="${workspace_loc}/../eclipse-2020-03-runtime"/> | ||
17 | <listAttribute key="org.eclipse.debug.ui.favoriteGroups"> | ||
18 | <listEntry value="org.eclipse.debug.ui.launchGroup.debug"/> | ||
19 | <listEntry value="org.eclipse.debug.ui.launchGroup.run"/> | ||
20 | </listAttribute> | ||
21 | <stringAttribute key="org.eclipse.jdt.launching.JRE_CONTAINER" value="org.eclipse.jdt.launching.JRE_CONTAINER/org.eclipse.jdt.internal.debug.ui.launcher.StandardVMType/JavaSE-1.8"/> | ||
22 | <stringAttribute key="org.eclipse.jdt.launching.PROGRAM_ARGUMENTS" value="-os ${target.os} -ws ${target.ws} -arch ${target.arch} -nl ${target.nl}"/> | ||
23 | <stringAttribute key="org.eclipse.jdt.launching.SOURCE_PATH_PROVIDER" value="org.eclipse.pde.ui.workbenchClasspathProvider"/> | ||
24 | <stringAttribute key="org.eclipse.jdt.launching.VM_ARGUMENTS" value="-Xms40m -Xmx512m"/> | ||
25 | <stringAttribute key="pde.version" value="3.3"/> | ||
26 | <stringAttribute key="product" value="org.eclipse.platform.ide"/> | ||
27 | <booleanAttribute key="show_selected_only" value="false"/> | ||
28 | <stringAttribute key="templateConfig" value="${target_home}/configuration/config.ini"/> | ||
29 | <booleanAttribute key="tracing" value="false"/> | ||
30 | <booleanAttribute key="useCustomFeatures" value="false"/> | ||
31 | <booleanAttribute key="useDefaultConfig" value="true"/> | ||
32 | <booleanAttribute key="useDefaultConfigArea" value="true"/> | ||
33 | <booleanAttribute key="useProduct" value="true"/> | ||
34 | <booleanAttribute key="usefeatures" value="false"/> | ||
35 | </launchConfiguration> | ||
diff --git a/Application/org.eclipse.viatra.solver.language/.project b/Application/org.eclipse.viatra.solver.language/.project new file mode 100644 index 00000000..406b0bc8 --- /dev/null +++ b/Application/org.eclipse.viatra.solver.language/.project | |||
@@ -0,0 +1,34 @@ | |||
1 | <?xml version="1.0" encoding="UTF-8"?> | ||
2 | <projectDescription> | ||
3 | <name>org.eclipse.viatra.solver.language</name> | ||
4 | <comment></comment> | ||
5 | <projects> | ||
6 | </projects> | ||
7 | <buildSpec> | ||
8 | <buildCommand> | ||
9 | <name>org.eclipse.xtext.ui.shared.xtextBuilder</name> | ||
10 | <arguments> | ||
11 | </arguments> | ||
12 | </buildCommand> | ||
13 | <buildCommand> | ||
14 | <name>org.eclipse.jdt.core.javabuilder</name> | ||
15 | <arguments> | ||
16 | </arguments> | ||
17 | </buildCommand> | ||
18 | <buildCommand> | ||
19 | <name>org.eclipse.pde.ManifestBuilder</name> | ||
20 | <arguments> | ||
21 | </arguments> | ||
22 | </buildCommand> | ||
23 | <buildCommand> | ||
24 | <name>org.eclipse.pde.SchemaBuilder</name> | ||
25 | <arguments> | ||
26 | </arguments> | ||
27 | </buildCommand> | ||
28 | </buildSpec> | ||
29 | <natures> | ||
30 | <nature>org.eclipse.xtext.ui.shared.xtextNature</nature> | ||
31 | <nature>org.eclipse.jdt.core.javanature</nature> | ||
32 | <nature>org.eclipse.pde.PluginNature</nature> | ||
33 | </natures> | ||
34 | </projectDescription> | ||
diff --git a/Application/org.eclipse.viatra.solver.language/.settings/org.eclipse.core.resources.prefs b/Application/org.eclipse.viatra.solver.language/.settings/org.eclipse.core.resources.prefs new file mode 100644 index 00000000..4824b802 --- /dev/null +++ b/Application/org.eclipse.viatra.solver.language/.settings/org.eclipse.core.resources.prefs | |||
@@ -0,0 +1,2 @@ | |||
1 | eclipse.preferences.version=1 | ||
2 | encoding/<project>=UTF-8 | ||
diff --git a/Application/org.eclipse.viatra.solver.language/.settings/org.eclipse.jdt.core.prefs b/Application/org.eclipse.viatra.solver.language/.settings/org.eclipse.jdt.core.prefs new file mode 100644 index 00000000..295926d9 --- /dev/null +++ b/Application/org.eclipse.viatra.solver.language/.settings/org.eclipse.jdt.core.prefs | |||
@@ -0,0 +1,7 @@ | |||
1 | eclipse.preferences.version=1 | ||
2 | org.eclipse.jdt.core.compiler.codegen.inlineJsrBytecode=enabled | ||
3 | org.eclipse.jdt.core.compiler.codegen.targetPlatform=1.8 | ||
4 | org.eclipse.jdt.core.compiler.compliance=1.8 | ||
5 | org.eclipse.jdt.core.compiler.problem.assertIdentifier=error | ||
6 | org.eclipse.jdt.core.compiler.problem.enumIdentifier=error | ||
7 | org.eclipse.jdt.core.compiler.source=1.8 | ||
diff --git a/Application/org.eclipse.viatra.solver.language/META-INF/MANIFEST.MF b/Application/org.eclipse.viatra.solver.language/META-INF/MANIFEST.MF new file mode 100644 index 00000000..5ee256a4 --- /dev/null +++ b/Application/org.eclipse.viatra.solver.language/META-INF/MANIFEST.MF | |||
@@ -0,0 +1,29 @@ | |||
1 | Manifest-Version: 1.0 | ||
2 | Automatic-Module-Name: org.eclipse.viatra.solver.language | ||
3 | Bundle-ManifestVersion: 2 | ||
4 | Bundle-Name: org.eclipse.viatra.solver.language | ||
5 | Bundle-Vendor: My Company | ||
6 | Bundle-Version: 1.0.0.qualifier | ||
7 | Bundle-SymbolicName: org.eclipse.viatra.solver.language; singleton:=true | ||
8 | Bundle-ActivationPolicy: lazy | ||
9 | Require-Bundle: org.eclipse.xtext, | ||
10 | org.eclipse.xtext.xbase, | ||
11 | org.eclipse.equinox.common;bundle-version="3.5.0", | ||
12 | org.eclipse.emf.ecore, | ||
13 | org.eclipse.xtext.xbase.lib;bundle-version="2.14.0", | ||
14 | org.eclipse.xtext.util, | ||
15 | org.eclipse.emf.common, | ||
16 | org.eclipse.xtend.lib;bundle-version="2.14.0", | ||
17 | org.antlr.runtime;bundle-version="[3.2.0,3.2.1)", | ||
18 | org.eclipse.viatra.solver.language.model;bundle-version="0.1.0";visibility:=reexport | ||
19 | Bundle-RequiredExecutionEnvironment: JavaSE-1.8 | ||
20 | Export-Package: org.eclipse.viatra.solver.language, | ||
21 | org.eclipse.viatra.solver.language.generator, | ||
22 | org.eclipse.viatra.solver.language.parser.antlr, | ||
23 | org.eclipse.viatra.solver.language.parser.antlr.internal, | ||
24 | org.eclipse.viatra.solver.language.parser.antlr.lexer, | ||
25 | org.eclipse.viatra.solver.language.scoping, | ||
26 | org.eclipse.viatra.solver.language.serializer, | ||
27 | org.eclipse.viatra.solver.language.services, | ||
28 | org.eclipse.viatra.solver.language.validation | ||
29 | Import-Package: org.apache.log4j | ||
diff --git a/Application/org.eclipse.viatra.solver.language/build.properties b/Application/org.eclipse.viatra.solver.language/build.properties new file mode 100644 index 00000000..b1584c24 --- /dev/null +++ b/Application/org.eclipse.viatra.solver.language/build.properties | |||
@@ -0,0 +1,19 @@ | |||
1 | source.. = src/,\ | ||
2 | src-gen/,\ | ||
3 | xtend-gen/ | ||
4 | bin.includes = .,\ | ||
5 | META-INF/,\ | ||
6 | plugin.xml | ||
7 | bin.excludes = **/*.mwe2,\ | ||
8 | **/*.xtend | ||
9 | additional.bundles = org.eclipse.xtext.xbase,\ | ||
10 | org.eclipse.xtext.common.types,\ | ||
11 | org.eclipse.xtext.xtext.generator,\ | ||
12 | org.eclipse.emf.codegen.ecore,\ | ||
13 | org.eclipse.emf.mwe.utils,\ | ||
14 | org.eclipse.emf.mwe2.launch,\ | ||
15 | org.eclipse.emf.mwe2.lib,\ | ||
16 | org.objectweb.asm,\ | ||
17 | org.apache.commons.logging,\ | ||
18 | org.apache.log4j,\ | ||
19 | com.ibm.icu | ||
diff --git a/Application/org.eclipse.viatra.solver.language/plugin.properties b/Application/org.eclipse.viatra.solver.language/plugin.properties new file mode 100644 index 00000000..a81f16eb --- /dev/null +++ b/Application/org.eclipse.viatra.solver.language/plugin.properties | |||
@@ -0,0 +1,4 @@ | |||
1 | # generated by Xtext 2.21.0 | ||
2 | |||
3 | pluginName = org.eclipse.viatra.solver.language | ||
4 | providerName = My Company | ||
diff --git a/Application/org.eclipse.viatra.solver.language/plugin.xml b/Application/org.eclipse.viatra.solver.language/plugin.xml new file mode 100644 index 00000000..c5be3e9b --- /dev/null +++ b/Application/org.eclipse.viatra.solver.language/plugin.xml | |||
@@ -0,0 +1,4 @@ | |||
1 | <?xml version="1.0" encoding="UTF-8"?> | ||
2 | <?eclipse version="3.0"?> | ||
3 | <plugin> | ||
4 | </plugin> | ||
diff --git a/Application/org.eclipse.viatra.solver.language/plugin.xml_gen b/Application/org.eclipse.viatra.solver.language/plugin.xml_gen new file mode 100644 index 00000000..ddd0f613 --- /dev/null +++ b/Application/org.eclipse.viatra.solver.language/plugin.xml_gen | |||
@@ -0,0 +1,10 @@ | |||
1 | <?xml version="1.0" encoding="UTF-8"?> | ||
2 | <?eclipse version="3.0"?> | ||
3 | <plugin> | ||
4 | <extension point="org.eclipse.emf.ecore.generated_package"> | ||
5 | <package | ||
6 | uri = "http://www.eclipse.org/viatra/solver/language/SolverLanguage" | ||
7 | class = "org.eclipse.viatra.solver.language.solverLanguage.SolverLanguagePackage" | ||
8 | genModel = "model/generated/SolverLanguage.genmodel" /> | ||
9 | </extension> | ||
10 | </plugin> | ||
diff --git a/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/AbstractSolverLanguageRuntimeModule.java b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/AbstractSolverLanguageRuntimeModule.java new file mode 100644 index 00000000..a02b3ab2 --- /dev/null +++ b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/AbstractSolverLanguageRuntimeModule.java | |||
@@ -0,0 +1,208 @@ | |||
1 | /* | ||
2 | * generated by Xtext 2.21.0 | ||
3 | */ | ||
4 | package org.eclipse.viatra.solver.language; | ||
5 | |||
6 | import com.google.inject.Binder; | ||
7 | import com.google.inject.Provider; | ||
8 | import com.google.inject.name.Names; | ||
9 | import java.util.Properties; | ||
10 | import org.eclipse.viatra.solver.language.generator.SolverLanguageGenerator; | ||
11 | import org.eclipse.viatra.solver.language.parser.antlr.SolverLanguageAntlrTokenFileProvider; | ||
12 | import org.eclipse.viatra.solver.language.parser.antlr.SolverLanguageParser; | ||
13 | import org.eclipse.viatra.solver.language.parser.antlr.lexer.InternalSolverLanguageLexer; | ||
14 | import org.eclipse.viatra.solver.language.scoping.SolverLanguageScopeProvider; | ||
15 | import org.eclipse.viatra.solver.language.serializer.SolverLanguageSemanticSequencer; | ||
16 | import org.eclipse.viatra.solver.language.serializer.SolverLanguageSyntacticSequencer; | ||
17 | import org.eclipse.viatra.solver.language.services.SolverLanguageGrammarAccess; | ||
18 | import org.eclipse.viatra.solver.language.validation.SolverLanguageConfigurableIssueCodesProvider; | ||
19 | import org.eclipse.viatra.solver.language.validation.SolverLanguageValidator; | ||
20 | import org.eclipse.xtext.Constants; | ||
21 | import org.eclipse.xtext.IGrammarAccess; | ||
22 | import org.eclipse.xtext.generator.IGenerator2; | ||
23 | import org.eclipse.xtext.naming.DefaultDeclarativeQualifiedNameProvider; | ||
24 | import org.eclipse.xtext.naming.IQualifiedNameProvider; | ||
25 | import org.eclipse.xtext.parser.IParser; | ||
26 | import org.eclipse.xtext.parser.ITokenToStringConverter; | ||
27 | import org.eclipse.xtext.parser.antlr.AntlrTokenDefProvider; | ||
28 | import org.eclipse.xtext.parser.antlr.AntlrTokenToStringConverter; | ||
29 | import org.eclipse.xtext.parser.antlr.IAntlrTokenFileProvider; | ||
30 | import org.eclipse.xtext.parser.antlr.ITokenDefProvider; | ||
31 | import org.eclipse.xtext.parser.antlr.IUnorderedGroupHelper; | ||
32 | import org.eclipse.xtext.parser.antlr.Lexer; | ||
33 | import org.eclipse.xtext.parser.antlr.LexerBindings; | ||
34 | import org.eclipse.xtext.parser.antlr.LexerProvider; | ||
35 | import org.eclipse.xtext.parser.antlr.UnorderedGroupHelper; | ||
36 | import org.eclipse.xtext.resource.IContainer; | ||
37 | import org.eclipse.xtext.resource.IResourceDescriptions; | ||
38 | import org.eclipse.xtext.resource.containers.IAllContainersState; | ||
39 | import org.eclipse.xtext.resource.containers.ResourceSetBasedAllContainersStateProvider; | ||
40 | import org.eclipse.xtext.resource.containers.StateBasedContainerManager; | ||
41 | import org.eclipse.xtext.resource.impl.ResourceDescriptionsProvider; | ||
42 | import org.eclipse.xtext.resource.impl.ResourceSetBasedResourceDescriptions; | ||
43 | import org.eclipse.xtext.scoping.IGlobalScopeProvider; | ||
44 | import org.eclipse.xtext.scoping.IScopeProvider; | ||
45 | import org.eclipse.xtext.scoping.IgnoreCaseLinking; | ||
46 | import org.eclipse.xtext.scoping.impl.AbstractDeclarativeScopeProvider; | ||
47 | import org.eclipse.xtext.scoping.impl.DefaultGlobalScopeProvider; | ||
48 | import org.eclipse.xtext.scoping.impl.ImportedNamespaceAwareLocalScopeProvider; | ||
49 | import org.eclipse.xtext.serializer.ISerializer; | ||
50 | import org.eclipse.xtext.serializer.impl.Serializer; | ||
51 | import org.eclipse.xtext.serializer.sequencer.ISemanticSequencer; | ||
52 | import org.eclipse.xtext.serializer.sequencer.ISyntacticSequencer; | ||
53 | import org.eclipse.xtext.service.DefaultRuntimeModule; | ||
54 | import org.eclipse.xtext.service.SingletonBinding; | ||
55 | import org.eclipse.xtext.validation.ConfigurableIssueCodesProvider; | ||
56 | |||
57 | /** | ||
58 | * Manual modifications go to {@link SolverLanguageRuntimeModule}. | ||
59 | */ | ||
60 | @SuppressWarnings("all") | ||
61 | public abstract class AbstractSolverLanguageRuntimeModule extends DefaultRuntimeModule { | ||
62 | |||
63 | protected Properties properties = null; | ||
64 | |||
65 | @Override | ||
66 | public void configure(Binder binder) { | ||
67 | properties = tryBindProperties(binder, "org/eclipse/viatra/solver/language/SolverLanguage.properties"); | ||
68 | super.configure(binder); | ||
69 | } | ||
70 | |||
71 | public void configureLanguageName(Binder binder) { | ||
72 | binder.bind(String.class).annotatedWith(Names.named(Constants.LANGUAGE_NAME)).toInstance("org.eclipse.viatra.solver.language.SolverLanguage"); | ||
73 | } | ||
74 | |||
75 | public void configureFileExtensions(Binder binder) { | ||
76 | if (properties == null || properties.getProperty(Constants.FILE_EXTENSIONS) == null) | ||
77 | binder.bind(String.class).annotatedWith(Names.named(Constants.FILE_EXTENSIONS)).toInstance("vsc"); | ||
78 | } | ||
79 | |||
80 | // contributed by org.eclipse.xtext.xtext.generator.grammarAccess.GrammarAccessFragment2 | ||
81 | public ClassLoader bindClassLoaderToInstance() { | ||
82 | return getClass().getClassLoader(); | ||
83 | } | ||
84 | |||
85 | // contributed by org.eclipse.xtext.xtext.generator.grammarAccess.GrammarAccessFragment2 | ||
86 | public Class<? extends IGrammarAccess> bindIGrammarAccess() { | ||
87 | return SolverLanguageGrammarAccess.class; | ||
88 | } | ||
89 | |||
90 | // contributed by org.eclipse.xtext.xtext.generator.serializer.SerializerFragment2 | ||
91 | public Class<? extends ISemanticSequencer> bindISemanticSequencer() { | ||
92 | return SolverLanguageSemanticSequencer.class; | ||
93 | } | ||
94 | |||
95 | // contributed by org.eclipse.xtext.xtext.generator.serializer.SerializerFragment2 | ||
96 | public Class<? extends ISyntacticSequencer> bindISyntacticSequencer() { | ||
97 | return SolverLanguageSyntacticSequencer.class; | ||
98 | } | ||
99 | |||
100 | // contributed by org.eclipse.xtext.xtext.generator.serializer.SerializerFragment2 | ||
101 | public Class<? extends ISerializer> bindISerializer() { | ||
102 | return Serializer.class; | ||
103 | } | ||
104 | |||
105 | // contributed by org.eclipse.xtext.xtext.generator.parser.antlr.XtextAntlrGeneratorFragment2 | ||
106 | public Class<? extends IParser> bindIParser() { | ||
107 | return SolverLanguageParser.class; | ||
108 | } | ||
109 | |||
110 | // contributed by org.eclipse.xtext.xtext.generator.parser.antlr.XtextAntlrGeneratorFragment2 | ||
111 | public Class<? extends ITokenToStringConverter> bindITokenToStringConverter() { | ||
112 | return AntlrTokenToStringConverter.class; | ||
113 | } | ||
114 | |||
115 | // contributed by org.eclipse.xtext.xtext.generator.parser.antlr.XtextAntlrGeneratorFragment2 | ||
116 | public Class<? extends IAntlrTokenFileProvider> bindIAntlrTokenFileProvider() { | ||
117 | return SolverLanguageAntlrTokenFileProvider.class; | ||
118 | } | ||
119 | |||
120 | // contributed by org.eclipse.xtext.xtext.generator.parser.antlr.XtextAntlrGeneratorFragment2 | ||
121 | public Class<? extends Lexer> bindLexer() { | ||
122 | return InternalSolverLanguageLexer.class; | ||
123 | } | ||
124 | |||
125 | // contributed by org.eclipse.xtext.xtext.generator.parser.antlr.XtextAntlrGeneratorFragment2 | ||
126 | public Class<? extends ITokenDefProvider> bindITokenDefProvider() { | ||
127 | return AntlrTokenDefProvider.class; | ||
128 | } | ||
129 | |||
130 | // contributed by org.eclipse.xtext.xtext.generator.parser.antlr.XtextAntlrGeneratorFragment2 | ||
131 | public Provider<? extends InternalSolverLanguageLexer> provideInternalSolverLanguageLexer() { | ||
132 | return LexerProvider.create(InternalSolverLanguageLexer.class); | ||
133 | } | ||
134 | |||
135 | // contributed by org.eclipse.xtext.xtext.generator.parser.antlr.XtextAntlrGeneratorFragment2 | ||
136 | public void configureRuntimeLexer(Binder binder) { | ||
137 | binder.bind(Lexer.class) | ||
138 | .annotatedWith(Names.named(LexerBindings.RUNTIME)) | ||
139 | .to(InternalSolverLanguageLexer.class); | ||
140 | } | ||
141 | |||
142 | // contributed by org.eclipse.xtext.xtext.generator.parser.antlr.XtextAntlrGeneratorFragment2 | ||
143 | public Class<? extends IUnorderedGroupHelper> bindIUnorderedGroupHelper() { | ||
144 | return UnorderedGroupHelper.class; | ||
145 | } | ||
146 | |||
147 | // contributed by org.eclipse.xtext.xtext.generator.validation.ValidatorFragment2 | ||
148 | @SingletonBinding(eager=true) | ||
149 | public Class<? extends SolverLanguageValidator> bindSolverLanguageValidator() { | ||
150 | return SolverLanguageValidator.class; | ||
151 | } | ||
152 | |||
153 | // contributed by org.eclipse.xtext.xtext.generator.validation.ValidatorFragment2 | ||
154 | public Class<? extends ConfigurableIssueCodesProvider> bindConfigurableIssueCodesProvider() { | ||
155 | return SolverLanguageConfigurableIssueCodesProvider.class; | ||
156 | } | ||
157 | |||
158 | // contributed by org.eclipse.xtext.xtext.generator.scoping.ImportNamespacesScopingFragment2 | ||
159 | public Class<? extends IScopeProvider> bindIScopeProvider() { | ||
160 | return SolverLanguageScopeProvider.class; | ||
161 | } | ||
162 | |||
163 | // contributed by org.eclipse.xtext.xtext.generator.scoping.ImportNamespacesScopingFragment2 | ||
164 | public void configureIScopeProviderDelegate(Binder binder) { | ||
165 | binder.bind(IScopeProvider.class).annotatedWith(Names.named(AbstractDeclarativeScopeProvider.NAMED_DELEGATE)).to(ImportedNamespaceAwareLocalScopeProvider.class); | ||
166 | } | ||
167 | |||
168 | // contributed by org.eclipse.xtext.xtext.generator.scoping.ImportNamespacesScopingFragment2 | ||
169 | public Class<? extends IGlobalScopeProvider> bindIGlobalScopeProvider() { | ||
170 | return DefaultGlobalScopeProvider.class; | ||
171 | } | ||
172 | |||
173 | // contributed by org.eclipse.xtext.xtext.generator.scoping.ImportNamespacesScopingFragment2 | ||
174 | public void configureIgnoreCaseLinking(Binder binder) { | ||
175 | binder.bindConstant().annotatedWith(IgnoreCaseLinking.class).to(false); | ||
176 | } | ||
177 | |||
178 | // contributed by org.eclipse.xtext.xtext.generator.exporting.QualifiedNamesFragment2 | ||
179 | public Class<? extends IQualifiedNameProvider> bindIQualifiedNameProvider() { | ||
180 | return DefaultDeclarativeQualifiedNameProvider.class; | ||
181 | } | ||
182 | |||
183 | // contributed by org.eclipse.xtext.xtext.generator.builder.BuilderIntegrationFragment2 | ||
184 | public Class<? extends IContainer.Manager> bindIContainer$Manager() { | ||
185 | return StateBasedContainerManager.class; | ||
186 | } | ||
187 | |||
188 | // contributed by org.eclipse.xtext.xtext.generator.builder.BuilderIntegrationFragment2 | ||
189 | public Class<? extends IAllContainersState.Provider> bindIAllContainersState$Provider() { | ||
190 | return ResourceSetBasedAllContainersStateProvider.class; | ||
191 | } | ||
192 | |||
193 | // contributed by org.eclipse.xtext.xtext.generator.builder.BuilderIntegrationFragment2 | ||
194 | public void configureIResourceDescriptions(Binder binder) { | ||
195 | binder.bind(IResourceDescriptions.class).to(ResourceSetBasedResourceDescriptions.class); | ||
196 | } | ||
197 | |||
198 | // contributed by org.eclipse.xtext.xtext.generator.builder.BuilderIntegrationFragment2 | ||
199 | public void configureIResourceDescriptionsPersisted(Binder binder) { | ||
200 | binder.bind(IResourceDescriptions.class).annotatedWith(Names.named(ResourceDescriptionsProvider.PERSISTED_DESCRIPTIONS)).to(ResourceSetBasedResourceDescriptions.class); | ||
201 | } | ||
202 | |||
203 | // contributed by org.eclipse.xtext.xtext.generator.generator.GeneratorFragment2 | ||
204 | public Class<? extends IGenerator2> bindIGenerator2() { | ||
205 | return SolverLanguageGenerator.class; | ||
206 | } | ||
207 | |||
208 | } | ||
diff --git a/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/SolverLanguage.xtextbin b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/SolverLanguage.xtextbin new file mode 100644 index 00000000..0fa5d0d7 --- /dev/null +++ b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/SolverLanguage.xtextbin | |||
Binary files differ | |||
diff --git a/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/SolverLanguageStandaloneSetupGenerated.java b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/SolverLanguageStandaloneSetupGenerated.java new file mode 100644 index 00000000..c487738b --- /dev/null +++ b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/SolverLanguageStandaloneSetupGenerated.java | |||
@@ -0,0 +1,37 @@ | |||
1 | /* | ||
2 | * generated by Xtext 2.21.0 | ||
3 | */ | ||
4 | package org.eclipse.viatra.solver.language; | ||
5 | |||
6 | import com.google.inject.Guice; | ||
7 | import com.google.inject.Injector; | ||
8 | import org.eclipse.emf.ecore.resource.Resource; | ||
9 | import org.eclipse.xtext.ISetup; | ||
10 | import org.eclipse.xtext.common.TerminalsStandaloneSetup; | ||
11 | import org.eclipse.xtext.resource.IResourceFactory; | ||
12 | import org.eclipse.xtext.resource.IResourceServiceProvider; | ||
13 | |||
14 | @SuppressWarnings("all") | ||
15 | public class SolverLanguageStandaloneSetupGenerated implements ISetup { | ||
16 | |||
17 | @Override | ||
18 | public Injector createInjectorAndDoEMFRegistration() { | ||
19 | TerminalsStandaloneSetup.doSetup(); | ||
20 | |||
21 | Injector injector = createInjector(); | ||
22 | register(injector); | ||
23 | return injector; | ||
24 | } | ||
25 | |||
26 | public Injector createInjector() { | ||
27 | return Guice.createInjector(new SolverLanguageRuntimeModule()); | ||
28 | } | ||
29 | |||
30 | public void register(Injector injector) { | ||
31 | IResourceFactory resourceFactory = injector.getInstance(IResourceFactory.class); | ||
32 | IResourceServiceProvider serviceProvider = injector.getInstance(IResourceServiceProvider.class); | ||
33 | |||
34 | Resource.Factory.Registry.INSTANCE.getExtensionToFactoryMap().put("vsc", resourceFactory); | ||
35 | IResourceServiceProvider.Registry.INSTANCE.getExtensionToFactoryMap().put("vsc", serviceProvider); | ||
36 | } | ||
37 | } | ||
diff --git a/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/parser/antlr/SolverLanguageAntlrTokenFileProvider.java b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/parser/antlr/SolverLanguageAntlrTokenFileProvider.java new file mode 100644 index 00000000..cfddb988 --- /dev/null +++ b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/parser/antlr/SolverLanguageAntlrTokenFileProvider.java | |||
@@ -0,0 +1,16 @@ | |||
1 | /* | ||
2 | * generated by Xtext 2.21.0 | ||
3 | */ | ||
4 | package org.eclipse.viatra.solver.language.parser.antlr; | ||
5 | |||
6 | import java.io.InputStream; | ||
7 | import org.eclipse.xtext.parser.antlr.IAntlrTokenFileProvider; | ||
8 | |||
9 | public class SolverLanguageAntlrTokenFileProvider implements IAntlrTokenFileProvider { | ||
10 | |||
11 | @Override | ||
12 | public InputStream getAntlrTokenFile() { | ||
13 | ClassLoader classLoader = getClass().getClassLoader(); | ||
14 | return classLoader.getResourceAsStream("org/eclipse/viatra/solver/language/parser/antlr/internal/InternalSolverLanguageParser.tokens"); | ||
15 | } | ||
16 | } | ||
diff --git a/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/parser/antlr/SolverLanguageParser.java b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/parser/antlr/SolverLanguageParser.java new file mode 100644 index 00000000..da897406 --- /dev/null +++ b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/parser/antlr/SolverLanguageParser.java | |||
@@ -0,0 +1,55 @@ | |||
1 | /* | ||
2 | * generated by Xtext 2.21.0 | ||
3 | */ | ||
4 | package org.eclipse.viatra.solver.language.parser.antlr; | ||
5 | |||
6 | import com.google.inject.Inject; | ||
7 | import org.antlr.runtime.CharStream; | ||
8 | import org.antlr.runtime.TokenSource; | ||
9 | import org.eclipse.viatra.solver.language.parser.antlr.internal.InternalSolverLanguageParser; | ||
10 | import org.eclipse.viatra.solver.language.services.SolverLanguageGrammarAccess; | ||
11 | import org.eclipse.xtext.parser.antlr.AbstractAntlrParser; | ||
12 | import org.eclipse.xtext.parser.antlr.XtextTokenStream; | ||
13 | |||
14 | public class SolverLanguageParser extends AbstractAntlrParser { | ||
15 | |||
16 | @Inject | ||
17 | private SolverLanguageGrammarAccess grammarAccess; | ||
18 | |||
19 | @Override | ||
20 | protected void setInitialHiddenTokens(XtextTokenStream tokenStream) { | ||
21 | tokenStream.setInitialHiddenTokens("RULE_WS", "RULE_ML_COMMENT", "RULE_SL_COMMENT"); | ||
22 | } | ||
23 | |||
24 | @Override | ||
25 | protected TokenSource createLexer(CharStream stream) { | ||
26 | return new SolverLanguageTokenSource(super.createLexer(stream)); | ||
27 | } | ||
28 | |||
29 | /** | ||
30 | * Indentation aware languages do not support partial parsing since the lexer is inherently stateful. | ||
31 | * Override and return {@code true} if your terminal splitting is stateless. | ||
32 | */ | ||
33 | @Override | ||
34 | protected boolean isReparseSupported() { | ||
35 | return false; | ||
36 | } | ||
37 | |||
38 | @Override | ||
39 | protected InternalSolverLanguageParser createParser(XtextTokenStream stream) { | ||
40 | return new InternalSolverLanguageParser(stream, getGrammarAccess()); | ||
41 | } | ||
42 | |||
43 | @Override | ||
44 | protected String getDefaultRuleName() { | ||
45 | return "Problem"; | ||
46 | } | ||
47 | |||
48 | public SolverLanguageGrammarAccess getGrammarAccess() { | ||
49 | return this.grammarAccess; | ||
50 | } | ||
51 | |||
52 | public void setGrammarAccess(SolverLanguageGrammarAccess grammarAccess) { | ||
53 | this.grammarAccess = grammarAccess; | ||
54 | } | ||
55 | } | ||
diff --git a/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/parser/antlr/internal/InternalSolverLanguageParser.g b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/parser/antlr/internal/InternalSolverLanguageParser.g new file mode 100644 index 00000000..eb6f05c7 --- /dev/null +++ b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/parser/antlr/internal/InternalSolverLanguageParser.g | |||
@@ -0,0 +1,5089 @@ | |||
1 | /* | ||
2 | * generated by Xtext 2.21.0 | ||
3 | */ | ||
4 | parser grammar InternalSolverLanguageParser; | ||
5 | |||
6 | options { | ||
7 | tokenVocab=InternalSolverLanguageLexer; | ||
8 | superClass=AbstractInternalAntlrParser; | ||
9 | } | ||
10 | |||
11 | @header { | ||
12 | package org.eclipse.viatra.solver.language.parser.antlr.internal; | ||
13 | |||
14 | import org.eclipse.xtext.*; | ||
15 | import org.eclipse.xtext.parser.*; | ||
16 | import org.eclipse.xtext.parser.impl.*; | ||
17 | import org.eclipse.emf.ecore.util.EcoreUtil; | ||
18 | import org.eclipse.emf.ecore.EObject; | ||
19 | import org.eclipse.emf.common.util.Enumerator; | ||
20 | import org.eclipse.xtext.parser.antlr.AbstractInternalAntlrParser; | ||
21 | import org.eclipse.xtext.parser.antlr.XtextTokenStream; | ||
22 | import org.eclipse.xtext.parser.antlr.XtextTokenStream.HiddenTokens; | ||
23 | import org.eclipse.xtext.parser.antlr.AntlrDatatypeRuleToken; | ||
24 | import org.eclipse.viatra.solver.language.services.SolverLanguageGrammarAccess; | ||
25 | |||
26 | } | ||
27 | |||
28 | @members { | ||
29 | |||
30 | private SolverLanguageGrammarAccess grammarAccess; | ||
31 | |||
32 | public InternalSolverLanguageParser(TokenStream input, SolverLanguageGrammarAccess grammarAccess) { | ||
33 | this(input); | ||
34 | this.grammarAccess = grammarAccess; | ||
35 | registerRules(grammarAccess.getGrammar()); | ||
36 | } | ||
37 | |||
38 | @Override | ||
39 | protected String getFirstRuleName() { | ||
40 | return "Problem"; | ||
41 | } | ||
42 | |||
43 | @Override | ||
44 | protected SolverLanguageGrammarAccess getGrammarAccess() { | ||
45 | return grammarAccess; | ||
46 | } | ||
47 | |||
48 | } | ||
49 | |||
50 | @rulecatch { | ||
51 | catch (RecognitionException re) { | ||
52 | recover(input,re); | ||
53 | appendSkippedTokens(); | ||
54 | } | ||
55 | } | ||
56 | |||
57 | // Entry rule entryRuleProblem | ||
58 | entryRuleProblem returns [EObject current=null]: | ||
59 | { newCompositeNode(grammarAccess.getProblemRule()); } | ||
60 | iv_ruleProblem=ruleProblem | ||
61 | { $current=$iv_ruleProblem.current; } | ||
62 | EOF; | ||
63 | |||
64 | // Rule Problem | ||
65 | ruleProblem returns [EObject current=null] | ||
66 | @init { | ||
67 | enterRule(); | ||
68 | } | ||
69 | @after { | ||
70 | leaveRule(); | ||
71 | }: | ||
72 | ( | ||
73 | ( | ||
74 | otherlv_0=Problem | ||
75 | { | ||
76 | newLeafNode(otherlv_0, grammarAccess.getProblemAccess().getProblemKeyword_0_0()); | ||
77 | } | ||
78 | ( | ||
79 | ( | ||
80 | { | ||
81 | newCompositeNode(grammarAccess.getProblemAccess().getNameQualifiedNameParserRuleCall_0_1_0()); | ||
82 | } | ||
83 | lv_name_1_0=ruleQualifiedName | ||
84 | { | ||
85 | if ($current==null) { | ||
86 | $current = createModelElementForParent(grammarAccess.getProblemRule()); | ||
87 | } | ||
88 | set( | ||
89 | $current, | ||
90 | "name", | ||
91 | lv_name_1_0, | ||
92 | "org.eclipse.viatra.solver.language.SolverLanguage.QualifiedName"); | ||
93 | afterParserOrEnumRuleCall(); | ||
94 | } | ||
95 | ) | ||
96 | ) | ||
97 | this_FULL_STOP_2=RULE_FULL_STOP | ||
98 | { | ||
99 | newLeafNode(this_FULL_STOP_2, grammarAccess.getProblemAccess().getFULL_STOPTerminalRuleCall_0_2()); | ||
100 | } | ||
101 | )? | ||
102 | ( | ||
103 | ( | ||
104 | { | ||
105 | newCompositeNode(grammarAccess.getProblemAccess().getImportsImportParserRuleCall_1_0()); | ||
106 | } | ||
107 | lv_imports_3_0=ruleImport | ||
108 | { | ||
109 | if ($current==null) { | ||
110 | $current = createModelElementForParent(grammarAccess.getProblemRule()); | ||
111 | } | ||
112 | add( | ||
113 | $current, | ||
114 | "imports", | ||
115 | lv_imports_3_0, | ||
116 | "org.eclipse.viatra.solver.language.SolverLanguage.Import"); | ||
117 | afterParserOrEnumRuleCall(); | ||
118 | } | ||
119 | ) | ||
120 | )* | ||
121 | ( | ||
122 | ( | ||
123 | { | ||
124 | newCompositeNode(grammarAccess.getProblemAccess().getStatementsStatementParserRuleCall_2_0()); | ||
125 | } | ||
126 | lv_statements_4_0=ruleStatement | ||
127 | { | ||
128 | if ($current==null) { | ||
129 | $current = createModelElementForParent(grammarAccess.getProblemRule()); | ||
130 | } | ||
131 | add( | ||
132 | $current, | ||
133 | "statements", | ||
134 | lv_statements_4_0, | ||
135 | "org.eclipse.viatra.solver.language.SolverLanguage.Statement"); | ||
136 | afterParserOrEnumRuleCall(); | ||
137 | } | ||
138 | ) | ||
139 | )* | ||
140 | ) | ||
141 | ; | ||
142 | |||
143 | // Entry rule entryRuleStatement | ||
144 | entryRuleStatement returns [EObject current=null]: | ||
145 | { newCompositeNode(grammarAccess.getStatementRule()); } | ||
146 | iv_ruleStatement=ruleStatement | ||
147 | { $current=$iv_ruleStatement.current; } | ||
148 | EOF; | ||
149 | |||
150 | // Rule Statement | ||
151 | ruleStatement returns [EObject current=null] | ||
152 | @init { | ||
153 | enterRule(); | ||
154 | } | ||
155 | @after { | ||
156 | leaveRule(); | ||
157 | }: | ||
158 | ( | ||
159 | { | ||
160 | newCompositeNode(grammarAccess.getStatementAccess().getAssertionOrDefinitionParserRuleCall_0()); | ||
161 | } | ||
162 | this_AssertionOrDefinition_0=ruleAssertionOrDefinition | ||
163 | { | ||
164 | $current = $this_AssertionOrDefinition_0.current; | ||
165 | afterParserOrEnumRuleCall(); | ||
166 | } | ||
167 | | | ||
168 | { | ||
169 | newCompositeNode(grammarAccess.getStatementAccess().getPredicateDefinitionParserRuleCall_1()); | ||
170 | } | ||
171 | this_PredicateDefinition_1=rulePredicateDefinition | ||
172 | { | ||
173 | $current = $this_PredicateDefinition_1.current; | ||
174 | afterParserOrEnumRuleCall(); | ||
175 | } | ||
176 | | | ||
177 | { | ||
178 | newCompositeNode(grammarAccess.getStatementAccess().getUnnamedErrorPredicateDefintionParserRuleCall_2()); | ||
179 | } | ||
180 | this_UnnamedErrorPredicateDefintion_2=ruleUnnamedErrorPredicateDefintion | ||
181 | { | ||
182 | $current = $this_UnnamedErrorPredicateDefintion_2.current; | ||
183 | afterParserOrEnumRuleCall(); | ||
184 | } | ||
185 | | | ||
186 | { | ||
187 | newCompositeNode(grammarAccess.getStatementAccess().getDefaultAssertionParserRuleCall_3()); | ||
188 | } | ||
189 | this_DefaultAssertion_3=ruleDefaultAssertion | ||
190 | { | ||
191 | $current = $this_DefaultAssertion_3.current; | ||
192 | afterParserOrEnumRuleCall(); | ||
193 | } | ||
194 | | | ||
195 | { | ||
196 | newCompositeNode(grammarAccess.getStatementAccess().getFunctionDefinitionParserRuleCall_4()); | ||
197 | } | ||
198 | this_FunctionDefinition_4=ruleFunctionDefinition | ||
199 | { | ||
200 | $current = $this_FunctionDefinition_4.current; | ||
201 | afterParserOrEnumRuleCall(); | ||
202 | } | ||
203 | | | ||
204 | { | ||
205 | newCompositeNode(grammarAccess.getStatementAccess().getAttributeParserRuleCall_5()); | ||
206 | } | ||
207 | this_Attribute_5=ruleAttribute | ||
208 | { | ||
209 | $current = $this_Attribute_5.current; | ||
210 | afterParserOrEnumRuleCall(); | ||
211 | } | ||
212 | | | ||
213 | { | ||
214 | newCompositeNode(grammarAccess.getStatementAccess().getExternDeclarationParserRuleCall_6()); | ||
215 | } | ||
216 | this_ExternDeclaration_6=ruleExternDeclaration | ||
217 | { | ||
218 | $current = $this_ExternDeclaration_6.current; | ||
219 | afterParserOrEnumRuleCall(); | ||
220 | } | ||
221 | | | ||
222 | { | ||
223 | newCompositeNode(grammarAccess.getStatementAccess().getScopeDeclarationParserRuleCall_7()); | ||
224 | } | ||
225 | this_ScopeDeclaration_7=ruleScopeDeclaration | ||
226 | { | ||
227 | $current = $this_ScopeDeclaration_7.current; | ||
228 | afterParserOrEnumRuleCall(); | ||
229 | } | ||
230 | | | ||
231 | { | ||
232 | newCompositeNode(grammarAccess.getStatementAccess().getObjectiveDeclarationParserRuleCall_8()); | ||
233 | } | ||
234 | this_ObjectiveDeclaration_8=ruleObjectiveDeclaration | ||
235 | { | ||
236 | $current = $this_ObjectiveDeclaration_8.current; | ||
237 | afterParserOrEnumRuleCall(); | ||
238 | } | ||
239 | | | ||
240 | { | ||
241 | newCompositeNode(grammarAccess.getStatementAccess().getClassDeclarationParserRuleCall_9()); | ||
242 | } | ||
243 | this_ClassDeclaration_9=ruleClassDeclaration | ||
244 | { | ||
245 | $current = $this_ClassDeclaration_9.current; | ||
246 | afterParserOrEnumRuleCall(); | ||
247 | } | ||
248 | | | ||
249 | { | ||
250 | newCompositeNode(grammarAccess.getStatementAccess().getEnumDeclarationParserRuleCall_10()); | ||
251 | } | ||
252 | this_EnumDeclaration_10=ruleEnumDeclaration | ||
253 | { | ||
254 | $current = $this_EnumDeclaration_10.current; | ||
255 | afterParserOrEnumRuleCall(); | ||
256 | } | ||
257 | ) | ||
258 | ; | ||
259 | |||
260 | // Entry rule entryRuleImport | ||
261 | entryRuleImport returns [EObject current=null]: | ||
262 | { newCompositeNode(grammarAccess.getImportRule()); } | ||
263 | iv_ruleImport=ruleImport | ||
264 | { $current=$iv_ruleImport.current; } | ||
265 | EOF; | ||
266 | |||
267 | // Rule Import | ||
268 | ruleImport returns [EObject current=null] | ||
269 | @init { | ||
270 | enterRule(); | ||
271 | } | ||
272 | @after { | ||
273 | leaveRule(); | ||
274 | }: | ||
275 | ( | ||
276 | { | ||
277 | newCompositeNode(grammarAccess.getImportAccess().getUriImportParserRuleCall_0()); | ||
278 | } | ||
279 | this_UriImport_0=ruleUriImport | ||
280 | { | ||
281 | $current = $this_UriImport_0.current; | ||
282 | afterParserOrEnumRuleCall(); | ||
283 | } | ||
284 | | | ||
285 | { | ||
286 | newCompositeNode(grammarAccess.getImportAccess().getNamespaceImportParserRuleCall_1()); | ||
287 | } | ||
288 | this_NamespaceImport_1=ruleNamespaceImport | ||
289 | { | ||
290 | $current = $this_NamespaceImport_1.current; | ||
291 | afterParserOrEnumRuleCall(); | ||
292 | } | ||
293 | ) | ||
294 | ; | ||
295 | |||
296 | // Entry rule entryRuleUriImport | ||
297 | entryRuleUriImport returns [EObject current=null]: | ||
298 | { newCompositeNode(grammarAccess.getUriImportRule()); } | ||
299 | iv_ruleUriImport=ruleUriImport | ||
300 | { $current=$iv_ruleUriImport.current; } | ||
301 | EOF; | ||
302 | |||
303 | // Rule UriImport | ||
304 | ruleUriImport returns [EObject current=null] | ||
305 | @init { | ||
306 | enterRule(); | ||
307 | } | ||
308 | @after { | ||
309 | leaveRule(); | ||
310 | }: | ||
311 | ( | ||
312 | otherlv_0=Import | ||
313 | { | ||
314 | newLeafNode(otherlv_0, grammarAccess.getUriImportAccess().getImportKeyword_0()); | ||
315 | } | ||
316 | ( | ||
317 | ( | ||
318 | lv_uri_1_0=RULE_STRING | ||
319 | { | ||
320 | newLeafNode(lv_uri_1_0, grammarAccess.getUriImportAccess().getUriSTRINGTerminalRuleCall_1_0()); | ||
321 | } | ||
322 | { | ||
323 | if ($current==null) { | ||
324 | $current = createModelElement(grammarAccess.getUriImportRule()); | ||
325 | } | ||
326 | setWithLastConsumed( | ||
327 | $current, | ||
328 | "uri", | ||
329 | lv_uri_1_0, | ||
330 | "org.eclipse.viatra.solver.language.SolverLanguage.STRING"); | ||
331 | } | ||
332 | ) | ||
333 | ) | ||
334 | ( | ||
335 | otherlv_2=As | ||
336 | { | ||
337 | newLeafNode(otherlv_2, grammarAccess.getUriImportAccess().getAsKeyword_2_0()); | ||
338 | } | ||
339 | ( | ||
340 | ( | ||
341 | { | ||
342 | newCompositeNode(grammarAccess.getUriImportAccess().getAliasQualifiedNameParserRuleCall_2_1_0()); | ||
343 | } | ||
344 | lv_alias_3_0=ruleQualifiedName | ||
345 | { | ||
346 | if ($current==null) { | ||
347 | $current = createModelElementForParent(grammarAccess.getUriImportRule()); | ||
348 | } | ||
349 | set( | ||
350 | $current, | ||
351 | "alias", | ||
352 | lv_alias_3_0, | ||
353 | "org.eclipse.viatra.solver.language.SolverLanguage.QualifiedName"); | ||
354 | afterParserOrEnumRuleCall(); | ||
355 | } | ||
356 | ) | ||
357 | ) | ||
358 | ) | ||
359 | this_FULL_STOP_4=RULE_FULL_STOP | ||
360 | { | ||
361 | newLeafNode(this_FULL_STOP_4, grammarAccess.getUriImportAccess().getFULL_STOPTerminalRuleCall_3()); | ||
362 | } | ||
363 | ) | ||
364 | ; | ||
365 | |||
366 | // Entry rule entryRuleNamespaceImport | ||
367 | entryRuleNamespaceImport returns [EObject current=null]: | ||
368 | { newCompositeNode(grammarAccess.getNamespaceImportRule()); } | ||
369 | iv_ruleNamespaceImport=ruleNamespaceImport | ||
370 | { $current=$iv_ruleNamespaceImport.current; } | ||
371 | EOF; | ||
372 | |||
373 | // Rule NamespaceImport | ||
374 | ruleNamespaceImport returns [EObject current=null] | ||
375 | @init { | ||
376 | enterRule(); | ||
377 | } | ||
378 | @after { | ||
379 | leaveRule(); | ||
380 | }: | ||
381 | ( | ||
382 | otherlv_0=Import | ||
383 | { | ||
384 | newLeafNode(otherlv_0, grammarAccess.getNamespaceImportAccess().getImportKeyword_0()); | ||
385 | } | ||
386 | ( | ||
387 | ( | ||
388 | { | ||
389 | newCompositeNode(grammarAccess.getNamespaceImportAccess().getImportedNamespaceQualifiedNameParserRuleCall_1_0()); | ||
390 | } | ||
391 | lv_importedNamespace_1_0=ruleQualifiedName | ||
392 | { | ||
393 | if ($current==null) { | ||
394 | $current = createModelElementForParent(grammarAccess.getNamespaceImportRule()); | ||
395 | } | ||
396 | set( | ||
397 | $current, | ||
398 | "importedNamespace", | ||
399 | lv_importedNamespace_1_0, | ||
400 | "org.eclipse.viatra.solver.language.SolverLanguage.QualifiedName"); | ||
401 | afterParserOrEnumRuleCall(); | ||
402 | } | ||
403 | ) | ||
404 | ) | ||
405 | ( | ||
406 | otherlv_2=As | ||
407 | { | ||
408 | newLeafNode(otherlv_2, grammarAccess.getNamespaceImportAccess().getAsKeyword_2_0()); | ||
409 | } | ||
410 | ( | ||
411 | ( | ||
412 | { | ||
413 | newCompositeNode(grammarAccess.getNamespaceImportAccess().getAliasQualifiedNameParserRuleCall_2_1_0()); | ||
414 | } | ||
415 | lv_alias_3_0=ruleQualifiedName | ||
416 | { | ||
417 | if ($current==null) { | ||
418 | $current = createModelElementForParent(grammarAccess.getNamespaceImportRule()); | ||
419 | } | ||
420 | set( | ||
421 | $current, | ||
422 | "alias", | ||
423 | lv_alias_3_0, | ||
424 | "org.eclipse.viatra.solver.language.SolverLanguage.QualifiedName"); | ||
425 | afterParserOrEnumRuleCall(); | ||
426 | } | ||
427 | ) | ||
428 | ) | ||
429 | ) | ||
430 | this_FULL_STOP_4=RULE_FULL_STOP | ||
431 | { | ||
432 | newLeafNode(this_FULL_STOP_4, grammarAccess.getNamespaceImportAccess().getFULL_STOPTerminalRuleCall_3()); | ||
433 | } | ||
434 | ) | ||
435 | ; | ||
436 | |||
437 | // Entry rule entryRuleAssertionOrDefinition | ||
438 | entryRuleAssertionOrDefinition returns [EObject current=null]: | ||
439 | { newCompositeNode(grammarAccess.getAssertionOrDefinitionRule()); } | ||
440 | iv_ruleAssertionOrDefinition=ruleAssertionOrDefinition | ||
441 | { $current=$iv_ruleAssertionOrDefinition.current; } | ||
442 | EOF; | ||
443 | |||
444 | // Rule AssertionOrDefinition | ||
445 | ruleAssertionOrDefinition returns [EObject current=null] | ||
446 | @init { | ||
447 | enterRule(); | ||
448 | } | ||
449 | @after { | ||
450 | leaveRule(); | ||
451 | }: | ||
452 | ( | ||
453 | { | ||
454 | newCompositeNode(grammarAccess.getAssertionOrDefinitionAccess().getExpressionParserRuleCall_0()); | ||
455 | } | ||
456 | this_Expression_0=ruleExpression | ||
457 | { | ||
458 | $current = $this_Expression_0.current; | ||
459 | afterParserOrEnumRuleCall(); | ||
460 | } | ||
461 | ( | ||
462 | ( | ||
463 | ( | ||
464 | { | ||
465 | $current = forceCreateModelElementAndSet( | ||
466 | grammarAccess.getAssertionOrDefinitionAccess().getAssertionExpressionAction_1_0_0(), | ||
467 | $current); | ||
468 | } | ||
469 | ) | ||
470 | ( | ||
471 | otherlv_2=Colon | ||
472 | { | ||
473 | newLeafNode(otherlv_2, grammarAccess.getAssertionOrDefinitionAccess().getColonKeyword_1_0_1_0()); | ||
474 | } | ||
475 | ( | ||
476 | ( | ||
477 | { | ||
478 | newCompositeNode(grammarAccess.getAssertionOrDefinitionAccess().getRangeExpressionParserRuleCall_1_0_1_1_0()); | ||
479 | } | ||
480 | lv_range_3_0=ruleExpression | ||
481 | { | ||
482 | if ($current==null) { | ||
483 | $current = createModelElementForParent(grammarAccess.getAssertionOrDefinitionRule()); | ||
484 | } | ||
485 | set( | ||
486 | $current, | ||
487 | "range", | ||
488 | lv_range_3_0, | ||
489 | "org.eclipse.viatra.solver.language.SolverLanguage.Expression"); | ||
490 | afterParserOrEnumRuleCall(); | ||
491 | } | ||
492 | ) | ||
493 | ) | ||
494 | )? | ||
495 | ) | ||
496 | | | ||
497 | ( | ||
498 | ( | ||
499 | { | ||
500 | $current = forceCreateModelElementAndSet( | ||
501 | grammarAccess.getAssertionOrDefinitionAccess().getPredicateDefinitionHeadAction_1_1_0(), | ||
502 | $current); | ||
503 | } | ||
504 | ) | ||
505 | otherlv_5=ColonHyphenMinus | ||
506 | { | ||
507 | newLeafNode(otherlv_5, grammarAccess.getAssertionOrDefinitionAccess().getColonHyphenMinusKeyword_1_1_1()); | ||
508 | } | ||
509 | ( | ||
510 | ( | ||
511 | { | ||
512 | newCompositeNode(grammarAccess.getAssertionOrDefinitionAccess().getBodyExpressionParserRuleCall_1_1_2_0()); | ||
513 | } | ||
514 | lv_body_6_0=ruleExpression | ||
515 | { | ||
516 | if ($current==null) { | ||
517 | $current = createModelElementForParent(grammarAccess.getAssertionOrDefinitionRule()); | ||
518 | } | ||
519 | set( | ||
520 | $current, | ||
521 | "body", | ||
522 | lv_body_6_0, | ||
523 | "org.eclipse.viatra.solver.language.SolverLanguage.Expression"); | ||
524 | afterParserOrEnumRuleCall(); | ||
525 | } | ||
526 | ) | ||
527 | ) | ||
528 | ) | ||
529 | | | ||
530 | ( | ||
531 | ( | ||
532 | { | ||
533 | $current = forceCreateModelElementAndSet( | ||
534 | grammarAccess.getAssertionOrDefinitionAccess().getFunctionDefinitionHeadAction_1_2_0(), | ||
535 | $current); | ||
536 | } | ||
537 | ) | ||
538 | otherlv_8=ColonEqualsSign | ||
539 | { | ||
540 | newLeafNode(otherlv_8, grammarAccess.getAssertionOrDefinitionAccess().getColonEqualsSignKeyword_1_2_1()); | ||
541 | } | ||
542 | ( | ||
543 | ( | ||
544 | { | ||
545 | newCompositeNode(grammarAccess.getAssertionOrDefinitionAccess().getBodyExpressionParserRuleCall_1_2_2_0()); | ||
546 | } | ||
547 | lv_body_9_0=ruleExpression | ||
548 | { | ||
549 | if ($current==null) { | ||
550 | $current = createModelElementForParent(grammarAccess.getAssertionOrDefinitionRule()); | ||
551 | } | ||
552 | set( | ||
553 | $current, | ||
554 | "body", | ||
555 | lv_body_9_0, | ||
556 | "org.eclipse.viatra.solver.language.SolverLanguage.Expression"); | ||
557 | afterParserOrEnumRuleCall(); | ||
558 | } | ||
559 | ) | ||
560 | ) | ||
561 | ) | ||
562 | ) | ||
563 | this_FULL_STOP_10=RULE_FULL_STOP | ||
564 | { | ||
565 | newLeafNode(this_FULL_STOP_10, grammarAccess.getAssertionOrDefinitionAccess().getFULL_STOPTerminalRuleCall_2()); | ||
566 | } | ||
567 | ) | ||
568 | ; | ||
569 | |||
570 | // Entry rule entryRulePredicateDefinition | ||
571 | entryRulePredicateDefinition returns [EObject current=null]: | ||
572 | { newCompositeNode(grammarAccess.getPredicateDefinitionRule()); } | ||
573 | iv_rulePredicateDefinition=rulePredicateDefinition | ||
574 | { $current=$iv_rulePredicateDefinition.current; } | ||
575 | EOF; | ||
576 | |||
577 | // Rule PredicateDefinition | ||
578 | rulePredicateDefinition returns [EObject current=null] | ||
579 | @init { | ||
580 | enterRule(); | ||
581 | } | ||
582 | @after { | ||
583 | leaveRule(); | ||
584 | }: | ||
585 | ( | ||
586 | ( | ||
587 | ( | ||
588 | ( | ||
589 | ( | ||
590 | lv_functional_0_0=Functional | ||
591 | { | ||
592 | newLeafNode(lv_functional_0_0, grammarAccess.getPredicateDefinitionAccess().getFunctionalFunctionalKeyword_0_0_0_0()); | ||
593 | } | ||
594 | { | ||
595 | if ($current==null) { | ||
596 | $current = createModelElement(grammarAccess.getPredicateDefinitionRule()); | ||
597 | } | ||
598 | setWithLastConsumed($current, "functional", true, "functional"); | ||
599 | } | ||
600 | ) | ||
601 | ) | ||
602 | ( | ||
603 | ( | ||
604 | lv_error_1_0=Error | ||
605 | { | ||
606 | newLeafNode(lv_error_1_0, grammarAccess.getPredicateDefinitionAccess().getErrorErrorKeyword_0_0_1_0()); | ||
607 | } | ||
608 | { | ||
609 | if ($current==null) { | ||
610 | $current = createModelElement(grammarAccess.getPredicateDefinitionRule()); | ||
611 | } | ||
612 | setWithLastConsumed($current, "error", true, "error"); | ||
613 | } | ||
614 | ) | ||
615 | )? | ||
616 | ) | ||
617 | | | ||
618 | ( | ||
619 | ( | ||
620 | ( | ||
621 | lv_error_2_0=Error | ||
622 | { | ||
623 | newLeafNode(lv_error_2_0, grammarAccess.getPredicateDefinitionAccess().getErrorErrorKeyword_0_1_0_0()); | ||
624 | } | ||
625 | { | ||
626 | if ($current==null) { | ||
627 | $current = createModelElement(grammarAccess.getPredicateDefinitionRule()); | ||
628 | } | ||
629 | setWithLastConsumed($current, "error", true, "error"); | ||
630 | } | ||
631 | ) | ||
632 | ) | ||
633 | ( | ||
634 | ( | ||
635 | lv_functional_3_0=Functional | ||
636 | { | ||
637 | newLeafNode(lv_functional_3_0, grammarAccess.getPredicateDefinitionAccess().getFunctionalFunctionalKeyword_0_1_1_0()); | ||
638 | } | ||
639 | { | ||
640 | if ($current==null) { | ||
641 | $current = createModelElement(grammarAccess.getPredicateDefinitionRule()); | ||
642 | } | ||
643 | setWithLastConsumed($current, "functional", true, "functional"); | ||
644 | } | ||
645 | ) | ||
646 | )? | ||
647 | ) | ||
648 | ) | ||
649 | ( | ||
650 | ( | ||
651 | { | ||
652 | newCompositeNode(grammarAccess.getPredicateDefinitionAccess().getHeadCallParserRuleCall_1_0()); | ||
653 | } | ||
654 | lv_head_4_0=ruleCall | ||
655 | { | ||
656 | if ($current==null) { | ||
657 | $current = createModelElementForParent(grammarAccess.getPredicateDefinitionRule()); | ||
658 | } | ||
659 | set( | ||
660 | $current, | ||
661 | "head", | ||
662 | lv_head_4_0, | ||
663 | "org.eclipse.viatra.solver.language.SolverLanguage.Call"); | ||
664 | afterParserOrEnumRuleCall(); | ||
665 | } | ||
666 | ) | ||
667 | ) | ||
668 | otherlv_5=ColonHyphenMinus | ||
669 | { | ||
670 | newLeafNode(otherlv_5, grammarAccess.getPredicateDefinitionAccess().getColonHyphenMinusKeyword_2()); | ||
671 | } | ||
672 | ( | ||
673 | ( | ||
674 | { | ||
675 | newCompositeNode(grammarAccess.getPredicateDefinitionAccess().getBodyExpressionParserRuleCall_3_0()); | ||
676 | } | ||
677 | lv_body_6_0=ruleExpression | ||
678 | { | ||
679 | if ($current==null) { | ||
680 | $current = createModelElementForParent(grammarAccess.getPredicateDefinitionRule()); | ||
681 | } | ||
682 | set( | ||
683 | $current, | ||
684 | "body", | ||
685 | lv_body_6_0, | ||
686 | "org.eclipse.viatra.solver.language.SolverLanguage.Expression"); | ||
687 | afterParserOrEnumRuleCall(); | ||
688 | } | ||
689 | ) | ||
690 | ) | ||
691 | this_FULL_STOP_7=RULE_FULL_STOP | ||
692 | { | ||
693 | newLeafNode(this_FULL_STOP_7, grammarAccess.getPredicateDefinitionAccess().getFULL_STOPTerminalRuleCall_4()); | ||
694 | } | ||
695 | ) | ||
696 | ; | ||
697 | |||
698 | // Entry rule entryRuleUnnamedErrorPredicateDefintion | ||
699 | entryRuleUnnamedErrorPredicateDefintion returns [EObject current=null]: | ||
700 | { newCompositeNode(grammarAccess.getUnnamedErrorPredicateDefintionRule()); } | ||
701 | iv_ruleUnnamedErrorPredicateDefintion=ruleUnnamedErrorPredicateDefintion | ||
702 | { $current=$iv_ruleUnnamedErrorPredicateDefintion.current; } | ||
703 | EOF; | ||
704 | |||
705 | // Rule UnnamedErrorPredicateDefintion | ||
706 | ruleUnnamedErrorPredicateDefintion returns [EObject current=null] | ||
707 | @init { | ||
708 | enterRule(); | ||
709 | } | ||
710 | @after { | ||
711 | leaveRule(); | ||
712 | }: | ||
713 | ( | ||
714 | otherlv_0=Error | ||
715 | { | ||
716 | newLeafNode(otherlv_0, grammarAccess.getUnnamedErrorPredicateDefintionAccess().getErrorKeyword_0()); | ||
717 | } | ||
718 | ( | ||
719 | ( | ||
720 | { | ||
721 | newCompositeNode(grammarAccess.getUnnamedErrorPredicateDefintionAccess().getArgumentListArgumentListParserRuleCall_1_0()); | ||
722 | } | ||
723 | lv_argumentList_1_0=ruleArgumentList | ||
724 | { | ||
725 | if ($current==null) { | ||
726 | $current = createModelElementForParent(grammarAccess.getUnnamedErrorPredicateDefintionRule()); | ||
727 | } | ||
728 | set( | ||
729 | $current, | ||
730 | "argumentList", | ||
731 | lv_argumentList_1_0, | ||
732 | "org.eclipse.viatra.solver.language.SolverLanguage.ArgumentList"); | ||
733 | afterParserOrEnumRuleCall(); | ||
734 | } | ||
735 | ) | ||
736 | ) | ||
737 | otherlv_2=ColonHyphenMinus | ||
738 | { | ||
739 | newLeafNode(otherlv_2, grammarAccess.getUnnamedErrorPredicateDefintionAccess().getColonHyphenMinusKeyword_2()); | ||
740 | } | ||
741 | ( | ||
742 | ( | ||
743 | { | ||
744 | newCompositeNode(grammarAccess.getUnnamedErrorPredicateDefintionAccess().getBodyExpressionParserRuleCall_3_0()); | ||
745 | } | ||
746 | lv_body_3_0=ruleExpression | ||
747 | { | ||
748 | if ($current==null) { | ||
749 | $current = createModelElementForParent(grammarAccess.getUnnamedErrorPredicateDefintionRule()); | ||
750 | } | ||
751 | set( | ||
752 | $current, | ||
753 | "body", | ||
754 | lv_body_3_0, | ||
755 | "org.eclipse.viatra.solver.language.SolverLanguage.Expression"); | ||
756 | afterParserOrEnumRuleCall(); | ||
757 | } | ||
758 | ) | ||
759 | ) | ||
760 | this_FULL_STOP_4=RULE_FULL_STOP | ||
761 | { | ||
762 | newLeafNode(this_FULL_STOP_4, grammarAccess.getUnnamedErrorPredicateDefintionAccess().getFULL_STOPTerminalRuleCall_4()); | ||
763 | } | ||
764 | ) | ||
765 | ; | ||
766 | |||
767 | // Entry rule entryRuleDefaultAssertion | ||
768 | entryRuleDefaultAssertion returns [EObject current=null]: | ||
769 | { newCompositeNode(grammarAccess.getDefaultAssertionRule()); } | ||
770 | iv_ruleDefaultAssertion=ruleDefaultAssertion | ||
771 | { $current=$iv_ruleDefaultAssertion.current; } | ||
772 | EOF; | ||
773 | |||
774 | // Rule DefaultAssertion | ||
775 | ruleDefaultAssertion returns [EObject current=null] | ||
776 | @init { | ||
777 | enterRule(); | ||
778 | } | ||
779 | @after { | ||
780 | leaveRule(); | ||
781 | }: | ||
782 | ( | ||
783 | otherlv_0=Default | ||
784 | { | ||
785 | newLeafNode(otherlv_0, grammarAccess.getDefaultAssertionAccess().getDefaultKeyword_0()); | ||
786 | } | ||
787 | ( | ||
788 | ( | ||
789 | { | ||
790 | newCompositeNode(grammarAccess.getDefaultAssertionAccess().getExpressionCallParserRuleCall_1_0()); | ||
791 | } | ||
792 | lv_expression_1_0=ruleCall | ||
793 | { | ||
794 | if ($current==null) { | ||
795 | $current = createModelElementForParent(grammarAccess.getDefaultAssertionRule()); | ||
796 | } | ||
797 | set( | ||
798 | $current, | ||
799 | "expression", | ||
800 | lv_expression_1_0, | ||
801 | "org.eclipse.viatra.solver.language.SolverLanguage.Call"); | ||
802 | afterParserOrEnumRuleCall(); | ||
803 | } | ||
804 | ) | ||
805 | ) | ||
806 | ( | ||
807 | otherlv_2=Colon | ||
808 | { | ||
809 | newLeafNode(otherlv_2, grammarAccess.getDefaultAssertionAccess().getColonKeyword_2_0()); | ||
810 | } | ||
811 | ( | ||
812 | ( | ||
813 | { | ||
814 | newCompositeNode(grammarAccess.getDefaultAssertionAccess().getRangeExpressionParserRuleCall_2_1_0()); | ||
815 | } | ||
816 | lv_range_3_0=ruleExpression | ||
817 | { | ||
818 | if ($current==null) { | ||
819 | $current = createModelElementForParent(grammarAccess.getDefaultAssertionRule()); | ||
820 | } | ||
821 | set( | ||
822 | $current, | ||
823 | "range", | ||
824 | lv_range_3_0, | ||
825 | "org.eclipse.viatra.solver.language.SolverLanguage.Expression"); | ||
826 | afterParserOrEnumRuleCall(); | ||
827 | } | ||
828 | ) | ||
829 | ) | ||
830 | )? | ||
831 | this_FULL_STOP_4=RULE_FULL_STOP | ||
832 | { | ||
833 | newLeafNode(this_FULL_STOP_4, grammarAccess.getDefaultAssertionAccess().getFULL_STOPTerminalRuleCall_3()); | ||
834 | } | ||
835 | ) | ||
836 | ; | ||
837 | |||
838 | // Entry rule entryRuleFunctionDefinition | ||
839 | entryRuleFunctionDefinition returns [EObject current=null]: | ||
840 | { newCompositeNode(grammarAccess.getFunctionDefinitionRule()); } | ||
841 | iv_ruleFunctionDefinition=ruleFunctionDefinition | ||
842 | { $current=$iv_ruleFunctionDefinition.current; } | ||
843 | EOF; | ||
844 | |||
845 | // Rule FunctionDefinition | ||
846 | ruleFunctionDefinition returns [EObject current=null] | ||
847 | @init { | ||
848 | enterRule(); | ||
849 | } | ||
850 | @after { | ||
851 | leaveRule(); | ||
852 | }: | ||
853 | ( | ||
854 | ( | ||
855 | ( | ||
856 | { | ||
857 | if ($current==null) { | ||
858 | $current = createModelElement(grammarAccess.getFunctionDefinitionRule()); | ||
859 | } | ||
860 | } | ||
861 | { | ||
862 | newCompositeNode(grammarAccess.getFunctionDefinitionAccess().getResultTypeSymbolCrossReference_0_0()); | ||
863 | } | ||
864 | ruleQualifiedName | ||
865 | { | ||
866 | afterParserOrEnumRuleCall(); | ||
867 | } | ||
868 | ) | ||
869 | ) | ||
870 | ( | ||
871 | ( | ||
872 | { | ||
873 | newCompositeNode(grammarAccess.getFunctionDefinitionAccess().getHeadCallParserRuleCall_1_0()); | ||
874 | } | ||
875 | lv_head_1_0=ruleCall | ||
876 | { | ||
877 | if ($current==null) { | ||
878 | $current = createModelElementForParent(grammarAccess.getFunctionDefinitionRule()); | ||
879 | } | ||
880 | set( | ||
881 | $current, | ||
882 | "head", | ||
883 | lv_head_1_0, | ||
884 | "org.eclipse.viatra.solver.language.SolverLanguage.Call"); | ||
885 | afterParserOrEnumRuleCall(); | ||
886 | } | ||
887 | ) | ||
888 | ) | ||
889 | otherlv_2=ColonEqualsSign | ||
890 | { | ||
891 | newLeafNode(otherlv_2, grammarAccess.getFunctionDefinitionAccess().getColonEqualsSignKeyword_2()); | ||
892 | } | ||
893 | ( | ||
894 | ( | ||
895 | { | ||
896 | newCompositeNode(grammarAccess.getFunctionDefinitionAccess().getBodyExpressionParserRuleCall_3_0()); | ||
897 | } | ||
898 | lv_body_3_0=ruleExpression | ||
899 | { | ||
900 | if ($current==null) { | ||
901 | $current = createModelElementForParent(grammarAccess.getFunctionDefinitionRule()); | ||
902 | } | ||
903 | set( | ||
904 | $current, | ||
905 | "body", | ||
906 | lv_body_3_0, | ||
907 | "org.eclipse.viatra.solver.language.SolverLanguage.Expression"); | ||
908 | afterParserOrEnumRuleCall(); | ||
909 | } | ||
910 | ) | ||
911 | ) | ||
912 | this_FULL_STOP_4=RULE_FULL_STOP | ||
913 | { | ||
914 | newLeafNode(this_FULL_STOP_4, grammarAccess.getFunctionDefinitionAccess().getFULL_STOPTerminalRuleCall_4()); | ||
915 | } | ||
916 | ) | ||
917 | ; | ||
918 | |||
919 | // Entry rule entryRuleTypeReference | ||
920 | entryRuleTypeReference returns [EObject current=null]: | ||
921 | { newCompositeNode(grammarAccess.getTypeReferenceRule()); } | ||
922 | iv_ruleTypeReference=ruleTypeReference | ||
923 | { $current=$iv_ruleTypeReference.current; } | ||
924 | EOF; | ||
925 | |||
926 | // Rule TypeReference | ||
927 | ruleTypeReference returns [EObject current=null] | ||
928 | @init { | ||
929 | enterRule(); | ||
930 | } | ||
931 | @after { | ||
932 | leaveRule(); | ||
933 | }: | ||
934 | ( | ||
935 | ( | ||
936 | ( | ||
937 | { | ||
938 | if ($current==null) { | ||
939 | $current = createModelElement(grammarAccess.getTypeReferenceRule()); | ||
940 | } | ||
941 | } | ||
942 | { | ||
943 | newCompositeNode(grammarAccess.getTypeReferenceAccess().getTypeSymbolCrossReference_0_0()); | ||
944 | } | ||
945 | ruleQualifiedName | ||
946 | { | ||
947 | afterParserOrEnumRuleCall(); | ||
948 | } | ||
949 | ) | ||
950 | ) | ||
951 | ( | ||
952 | ( | ||
953 | lv_forceObjectType_1_0=Object | ||
954 | { | ||
955 | newLeafNode(lv_forceObjectType_1_0, grammarAccess.getTypeReferenceAccess().getForceObjectTypeObjectKeyword_1_0()); | ||
956 | } | ||
957 | { | ||
958 | if ($current==null) { | ||
959 | $current = createModelElement(grammarAccess.getTypeReferenceRule()); | ||
960 | } | ||
961 | setWithLastConsumed($current, "forceObjectType", true, "object"); | ||
962 | } | ||
963 | ) | ||
964 | )? | ||
965 | ) | ||
966 | ; | ||
967 | |||
968 | // Entry rule entryRuleAttribute | ||
969 | entryRuleAttribute returns [EObject current=null]: | ||
970 | { newCompositeNode(grammarAccess.getAttributeRule()); } | ||
971 | iv_ruleAttribute=ruleAttribute | ||
972 | { $current=$iv_ruleAttribute.current; } | ||
973 | EOF; | ||
974 | |||
975 | // Rule Attribute | ||
976 | ruleAttribute returns [EObject current=null] | ||
977 | @init { | ||
978 | enterRule(); | ||
979 | } | ||
980 | @after { | ||
981 | leaveRule(); | ||
982 | }: | ||
983 | ( | ||
984 | ( | ||
985 | ( | ||
986 | { | ||
987 | newCompositeNode(grammarAccess.getAttributeAccess().getKindAttributeKindEnumRuleCall_0_0()); | ||
988 | } | ||
989 | lv_kind_0_0=ruleAttributeKind | ||
990 | { | ||
991 | if ($current==null) { | ||
992 | $current = createModelElementForParent(grammarAccess.getAttributeRule()); | ||
993 | } | ||
994 | set( | ||
995 | $current, | ||
996 | "kind", | ||
997 | lv_kind_0_0, | ||
998 | "org.eclipse.viatra.solver.language.SolverLanguage.AttributeKind"); | ||
999 | afterParserOrEnumRuleCall(); | ||
1000 | } | ||
1001 | ) | ||
1002 | ) | ||
1003 | ( | ||
1004 | ( | ||
1005 | { | ||
1006 | if ($current==null) { | ||
1007 | $current = createModelElement(grammarAccess.getAttributeRule()); | ||
1008 | } | ||
1009 | } | ||
1010 | { | ||
1011 | newCompositeNode(grammarAccess.getAttributeAccess().getTargetSymbolCrossReference_1_0()); | ||
1012 | } | ||
1013 | ruleQualifiedName | ||
1014 | { | ||
1015 | afterParserOrEnumRuleCall(); | ||
1016 | } | ||
1017 | ) | ||
1018 | ) | ||
1019 | this_FULL_STOP_2=RULE_FULL_STOP | ||
1020 | { | ||
1021 | newLeafNode(this_FULL_STOP_2, grammarAccess.getAttributeAccess().getFULL_STOPTerminalRuleCall_2()); | ||
1022 | } | ||
1023 | ) | ||
1024 | ; | ||
1025 | |||
1026 | // Entry rule entryRuleExternDeclaration | ||
1027 | entryRuleExternDeclaration returns [EObject current=null]: | ||
1028 | { newCompositeNode(grammarAccess.getExternDeclarationRule()); } | ||
1029 | iv_ruleExternDeclaration=ruleExternDeclaration | ||
1030 | { $current=$iv_ruleExternDeclaration.current; } | ||
1031 | EOF; | ||
1032 | |||
1033 | // Rule ExternDeclaration | ||
1034 | ruleExternDeclaration returns [EObject current=null] | ||
1035 | @init { | ||
1036 | enterRule(); | ||
1037 | } | ||
1038 | @after { | ||
1039 | leaveRule(); | ||
1040 | }: | ||
1041 | ( | ||
1042 | { | ||
1043 | newCompositeNode(grammarAccess.getExternDeclarationAccess().getExternPredicateDeclarationParserRuleCall_0()); | ||
1044 | } | ||
1045 | this_ExternPredicateDeclaration_0=ruleExternPredicateDeclaration | ||
1046 | { | ||
1047 | $current = $this_ExternPredicateDeclaration_0.current; | ||
1048 | afterParserOrEnumRuleCall(); | ||
1049 | } | ||
1050 | | | ||
1051 | { | ||
1052 | newCompositeNode(grammarAccess.getExternDeclarationAccess().getExternFunctionDeclarationParserRuleCall_1()); | ||
1053 | } | ||
1054 | this_ExternFunctionDeclaration_1=ruleExternFunctionDeclaration | ||
1055 | { | ||
1056 | $current = $this_ExternFunctionDeclaration_1.current; | ||
1057 | afterParserOrEnumRuleCall(); | ||
1058 | } | ||
1059 | | | ||
1060 | { | ||
1061 | newCompositeNode(grammarAccess.getExternDeclarationAccess().getExternAggregationOperatorDeclarationParserRuleCall_2()); | ||
1062 | } | ||
1063 | this_ExternAggregationOperatorDeclaration_2=ruleExternAggregationOperatorDeclaration | ||
1064 | { | ||
1065 | $current = $this_ExternAggregationOperatorDeclaration_2.current; | ||
1066 | afterParserOrEnumRuleCall(); | ||
1067 | } | ||
1068 | | | ||
1069 | { | ||
1070 | newCompositeNode(grammarAccess.getExternDeclarationAccess().getExternDatatypeDeclarationParserRuleCall_3()); | ||
1071 | } | ||
1072 | this_ExternDatatypeDeclaration_3=ruleExternDatatypeDeclaration | ||
1073 | { | ||
1074 | $current = $this_ExternDatatypeDeclaration_3.current; | ||
1075 | afterParserOrEnumRuleCall(); | ||
1076 | } | ||
1077 | ) | ||
1078 | ; | ||
1079 | |||
1080 | // Entry rule entryRuleExternPredicateDeclaration | ||
1081 | entryRuleExternPredicateDeclaration returns [EObject current=null]: | ||
1082 | { newCompositeNode(grammarAccess.getExternPredicateDeclarationRule()); } | ||
1083 | iv_ruleExternPredicateDeclaration=ruleExternPredicateDeclaration | ||
1084 | { $current=$iv_ruleExternPredicateDeclaration.current; } | ||
1085 | EOF; | ||
1086 | |||
1087 | // Rule ExternPredicateDeclaration | ||
1088 | ruleExternPredicateDeclaration returns [EObject current=null] | ||
1089 | @init { | ||
1090 | enterRule(); | ||
1091 | } | ||
1092 | @after { | ||
1093 | leaveRule(); | ||
1094 | }: | ||
1095 | ( | ||
1096 | otherlv_0=Extern | ||
1097 | { | ||
1098 | newLeafNode(otherlv_0, grammarAccess.getExternPredicateDeclarationAccess().getExternKeyword_0()); | ||
1099 | } | ||
1100 | ( | ||
1101 | ( | ||
1102 | { | ||
1103 | getUnorderedGroupHelper().enter(grammarAccess.getExternPredicateDeclarationAccess().getUnorderedGroup_1()); | ||
1104 | } | ||
1105 | ( | ||
1106 | ( | ||
1107 | ( | ||
1108 | {getUnorderedGroupHelper().canSelect(grammarAccess.getExternPredicateDeclarationAccess().getUnorderedGroup_1(), 0)}?=>( | ||
1109 | { | ||
1110 | getUnorderedGroupHelper().select(grammarAccess.getExternPredicateDeclarationAccess().getUnorderedGroup_1(), 0); | ||
1111 | } | ||
1112 | ({true}?=>(( | ||
1113 | lv_functional_2_0=Functional | ||
1114 | { | ||
1115 | newLeafNode(lv_functional_2_0, grammarAccess.getExternPredicateDeclarationAccess().getFunctionalFunctionalKeyword_1_0_0()); | ||
1116 | } | ||
1117 | { | ||
1118 | if ($current==null) { | ||
1119 | $current = createModelElement(grammarAccess.getExternPredicateDeclarationRule()); | ||
1120 | } | ||
1121 | setWithLastConsumed($current, "functional", true, "functional"); | ||
1122 | } | ||
1123 | ) | ||
1124 | )) | ||
1125 | { | ||
1126 | getUnorderedGroupHelper().returnFromSelection(grammarAccess.getExternPredicateDeclarationAccess().getUnorderedGroup_1()); | ||
1127 | } | ||
1128 | ) | ||
1129 | )| | ||
1130 | ( | ||
1131 | {getUnorderedGroupHelper().canSelect(grammarAccess.getExternPredicateDeclarationAccess().getUnorderedGroup_1(), 1)}?=>( | ||
1132 | { | ||
1133 | getUnorderedGroupHelper().select(grammarAccess.getExternPredicateDeclarationAccess().getUnorderedGroup_1(), 1); | ||
1134 | } | ||
1135 | ({true}?=>(( | ||
1136 | lv_error_3_0=Error | ||
1137 | { | ||
1138 | newLeafNode(lv_error_3_0, grammarAccess.getExternPredicateDeclarationAccess().getErrorErrorKeyword_1_1_0()); | ||
1139 | } | ||
1140 | { | ||
1141 | if ($current==null) { | ||
1142 | $current = createModelElement(grammarAccess.getExternPredicateDeclarationRule()); | ||
1143 | } | ||
1144 | setWithLastConsumed($current, "error", true, "error"); | ||
1145 | } | ||
1146 | ) | ||
1147 | )) | ||
1148 | { | ||
1149 | getUnorderedGroupHelper().returnFromSelection(grammarAccess.getExternPredicateDeclarationAccess().getUnorderedGroup_1()); | ||
1150 | } | ||
1151 | ) | ||
1152 | ) | ||
1153 | )* | ||
1154 | ) | ||
1155 | ) | ||
1156 | { | ||
1157 | getUnorderedGroupHelper().leave(grammarAccess.getExternPredicateDeclarationAccess().getUnorderedGroup_1()); | ||
1158 | } | ||
1159 | ) | ||
1160 | ( | ||
1161 | ( | ||
1162 | { | ||
1163 | newCompositeNode(grammarAccess.getExternPredicateDeclarationAccess().getNameQualifiedNameParserRuleCall_2_0()); | ||
1164 | } | ||
1165 | lv_name_4_0=ruleQualifiedName | ||
1166 | { | ||
1167 | if ($current==null) { | ||
1168 | $current = createModelElementForParent(grammarAccess.getExternPredicateDeclarationRule()); | ||
1169 | } | ||
1170 | set( | ||
1171 | $current, | ||
1172 | "name", | ||
1173 | lv_name_4_0, | ||
1174 | "org.eclipse.viatra.solver.language.SolverLanguage.QualifiedName"); | ||
1175 | afterParserOrEnumRuleCall(); | ||
1176 | } | ||
1177 | ) | ||
1178 | ) | ||
1179 | ( | ||
1180 | ( | ||
1181 | { | ||
1182 | newCompositeNode(grammarAccess.getExternPredicateDeclarationAccess().getArgumentListArgumentListParserRuleCall_3_0()); | ||
1183 | } | ||
1184 | lv_argumentList_5_0=ruleArgumentList | ||
1185 | { | ||
1186 | if ($current==null) { | ||
1187 | $current = createModelElementForParent(grammarAccess.getExternPredicateDeclarationRule()); | ||
1188 | } | ||
1189 | set( | ||
1190 | $current, | ||
1191 | "argumentList", | ||
1192 | lv_argumentList_5_0, | ||
1193 | "org.eclipse.viatra.solver.language.SolverLanguage.ArgumentList"); | ||
1194 | afterParserOrEnumRuleCall(); | ||
1195 | } | ||
1196 | ) | ||
1197 | ) | ||
1198 | this_FULL_STOP_6=RULE_FULL_STOP | ||
1199 | { | ||
1200 | newLeafNode(this_FULL_STOP_6, grammarAccess.getExternPredicateDeclarationAccess().getFULL_STOPTerminalRuleCall_4()); | ||
1201 | } | ||
1202 | ) | ||
1203 | ; | ||
1204 | |||
1205 | // Entry rule entryRuleExternFunctionDeclaration | ||
1206 | entryRuleExternFunctionDeclaration returns [EObject current=null]: | ||
1207 | { newCompositeNode(grammarAccess.getExternFunctionDeclarationRule()); } | ||
1208 | iv_ruleExternFunctionDeclaration=ruleExternFunctionDeclaration | ||
1209 | { $current=$iv_ruleExternFunctionDeclaration.current; } | ||
1210 | EOF; | ||
1211 | |||
1212 | // Rule ExternFunctionDeclaration | ||
1213 | ruleExternFunctionDeclaration returns [EObject current=null] | ||
1214 | @init { | ||
1215 | enterRule(); | ||
1216 | } | ||
1217 | @after { | ||
1218 | leaveRule(); | ||
1219 | }: | ||
1220 | ( | ||
1221 | otherlv_0=Extern | ||
1222 | { | ||
1223 | newLeafNode(otherlv_0, grammarAccess.getExternFunctionDeclarationAccess().getExternKeyword_0()); | ||
1224 | } | ||
1225 | ( | ||
1226 | ( | ||
1227 | { | ||
1228 | if ($current==null) { | ||
1229 | $current = createModelElement(grammarAccess.getExternFunctionDeclarationRule()); | ||
1230 | } | ||
1231 | } | ||
1232 | { | ||
1233 | newCompositeNode(grammarAccess.getExternFunctionDeclarationAccess().getResultTypeSymbolCrossReference_1_0()); | ||
1234 | } | ||
1235 | ruleQualifiedName | ||
1236 | { | ||
1237 | afterParserOrEnumRuleCall(); | ||
1238 | } | ||
1239 | ) | ||
1240 | ) | ||
1241 | ( | ||
1242 | ( | ||
1243 | { | ||
1244 | newCompositeNode(grammarAccess.getExternFunctionDeclarationAccess().getNameQualifiedNameParserRuleCall_2_0()); | ||
1245 | } | ||
1246 | lv_name_2_0=ruleQualifiedName | ||
1247 | { | ||
1248 | if ($current==null) { | ||
1249 | $current = createModelElementForParent(grammarAccess.getExternFunctionDeclarationRule()); | ||
1250 | } | ||
1251 | set( | ||
1252 | $current, | ||
1253 | "name", | ||
1254 | lv_name_2_0, | ||
1255 | "org.eclipse.viatra.solver.language.SolverLanguage.QualifiedName"); | ||
1256 | afterParserOrEnumRuleCall(); | ||
1257 | } | ||
1258 | ) | ||
1259 | ) | ||
1260 | ( | ||
1261 | ( | ||
1262 | { | ||
1263 | newCompositeNode(grammarAccess.getExternFunctionDeclarationAccess().getArgumentListArgumentListParserRuleCall_3_0()); | ||
1264 | } | ||
1265 | lv_argumentList_3_0=ruleArgumentList | ||
1266 | { | ||
1267 | if ($current==null) { | ||
1268 | $current = createModelElementForParent(grammarAccess.getExternFunctionDeclarationRule()); | ||
1269 | } | ||
1270 | set( | ||
1271 | $current, | ||
1272 | "argumentList", | ||
1273 | lv_argumentList_3_0, | ||
1274 | "org.eclipse.viatra.solver.language.SolverLanguage.ArgumentList"); | ||
1275 | afterParserOrEnumRuleCall(); | ||
1276 | } | ||
1277 | ) | ||
1278 | ) | ||
1279 | this_FULL_STOP_4=RULE_FULL_STOP | ||
1280 | { | ||
1281 | newLeafNode(this_FULL_STOP_4, grammarAccess.getExternFunctionDeclarationAccess().getFULL_STOPTerminalRuleCall_4()); | ||
1282 | } | ||
1283 | ) | ||
1284 | ; | ||
1285 | |||
1286 | // Entry rule entryRuleExternAggregationOperatorDeclaration | ||
1287 | entryRuleExternAggregationOperatorDeclaration returns [EObject current=null]: | ||
1288 | { newCompositeNode(grammarAccess.getExternAggregationOperatorDeclarationRule()); } | ||
1289 | iv_ruleExternAggregationOperatorDeclaration=ruleExternAggregationOperatorDeclaration | ||
1290 | { $current=$iv_ruleExternAggregationOperatorDeclaration.current; } | ||
1291 | EOF; | ||
1292 | |||
1293 | // Rule ExternAggregationOperatorDeclaration | ||
1294 | ruleExternAggregationOperatorDeclaration returns [EObject current=null] | ||
1295 | @init { | ||
1296 | enterRule(); | ||
1297 | } | ||
1298 | @after { | ||
1299 | leaveRule(); | ||
1300 | }: | ||
1301 | ( | ||
1302 | otherlv_0=Extern | ||
1303 | { | ||
1304 | newLeafNode(otherlv_0, grammarAccess.getExternAggregationOperatorDeclarationAccess().getExternKeyword_0()); | ||
1305 | } | ||
1306 | ( | ||
1307 | ( | ||
1308 | { | ||
1309 | if ($current==null) { | ||
1310 | $current = createModelElement(grammarAccess.getExternAggregationOperatorDeclarationRule()); | ||
1311 | } | ||
1312 | } | ||
1313 | { | ||
1314 | newCompositeNode(grammarAccess.getExternAggregationOperatorDeclarationAccess().getResultTypeSymbolCrossReference_1_0()); | ||
1315 | } | ||
1316 | ruleQualifiedName | ||
1317 | { | ||
1318 | afterParserOrEnumRuleCall(); | ||
1319 | } | ||
1320 | ) | ||
1321 | ) | ||
1322 | ( | ||
1323 | ( | ||
1324 | { | ||
1325 | newCompositeNode(grammarAccess.getExternAggregationOperatorDeclarationAccess().getNameQualifiedNameParserRuleCall_2_0()); | ||
1326 | } | ||
1327 | lv_name_2_0=ruleQualifiedName | ||
1328 | { | ||
1329 | if ($current==null) { | ||
1330 | $current = createModelElementForParent(grammarAccess.getExternAggregationOperatorDeclarationRule()); | ||
1331 | } | ||
1332 | set( | ||
1333 | $current, | ||
1334 | "name", | ||
1335 | lv_name_2_0, | ||
1336 | "org.eclipse.viatra.solver.language.SolverLanguage.QualifiedName"); | ||
1337 | afterParserOrEnumRuleCall(); | ||
1338 | } | ||
1339 | ) | ||
1340 | ) | ||
1341 | otherlv_3=LeftCurlyBracket | ||
1342 | { | ||
1343 | newLeafNode(otherlv_3, grammarAccess.getExternAggregationOperatorDeclarationAccess().getLeftCurlyBracketKeyword_3()); | ||
1344 | } | ||
1345 | ( | ||
1346 | ( | ||
1347 | { | ||
1348 | if ($current==null) { | ||
1349 | $current = createModelElement(grammarAccess.getExternAggregationOperatorDeclarationRule()); | ||
1350 | } | ||
1351 | } | ||
1352 | { | ||
1353 | newCompositeNode(grammarAccess.getExternAggregationOperatorDeclarationAccess().getArgumentTypeSymbolCrossReference_4_0()); | ||
1354 | } | ||
1355 | ruleQualifiedName | ||
1356 | { | ||
1357 | afterParserOrEnumRuleCall(); | ||
1358 | } | ||
1359 | ) | ||
1360 | ) | ||
1361 | otherlv_5=FullStopFullStopFullStop | ||
1362 | { | ||
1363 | newLeafNode(otherlv_5, grammarAccess.getExternAggregationOperatorDeclarationAccess().getFullStopFullStopFullStopKeyword_5()); | ||
1364 | } | ||
1365 | otherlv_6=RightCurlyBracket | ||
1366 | { | ||
1367 | newLeafNode(otherlv_6, grammarAccess.getExternAggregationOperatorDeclarationAccess().getRightCurlyBracketKeyword_6()); | ||
1368 | } | ||
1369 | this_FULL_STOP_7=RULE_FULL_STOP | ||
1370 | { | ||
1371 | newLeafNode(this_FULL_STOP_7, grammarAccess.getExternAggregationOperatorDeclarationAccess().getFULL_STOPTerminalRuleCall_7()); | ||
1372 | } | ||
1373 | ) | ||
1374 | ; | ||
1375 | |||
1376 | // Entry rule entryRuleExternDatatypeDeclaration | ||
1377 | entryRuleExternDatatypeDeclaration returns [EObject current=null]: | ||
1378 | { newCompositeNode(grammarAccess.getExternDatatypeDeclarationRule()); } | ||
1379 | iv_ruleExternDatatypeDeclaration=ruleExternDatatypeDeclaration | ||
1380 | { $current=$iv_ruleExternDatatypeDeclaration.current; } | ||
1381 | EOF; | ||
1382 | |||
1383 | // Rule ExternDatatypeDeclaration | ||
1384 | ruleExternDatatypeDeclaration returns [EObject current=null] | ||
1385 | @init { | ||
1386 | enterRule(); | ||
1387 | } | ||
1388 | @after { | ||
1389 | leaveRule(); | ||
1390 | }: | ||
1391 | ( | ||
1392 | otherlv_0=Extern | ||
1393 | { | ||
1394 | newLeafNode(otherlv_0, grammarAccess.getExternDatatypeDeclarationAccess().getExternKeyword_0()); | ||
1395 | } | ||
1396 | otherlv_1=Datatype | ||
1397 | { | ||
1398 | newLeafNode(otherlv_1, grammarAccess.getExternDatatypeDeclarationAccess().getDatatypeKeyword_1()); | ||
1399 | } | ||
1400 | ( | ||
1401 | ( | ||
1402 | { | ||
1403 | newCompositeNode(grammarAccess.getExternDatatypeDeclarationAccess().getNameQualifiedNameParserRuleCall_2_0()); | ||
1404 | } | ||
1405 | lv_name_2_0=ruleQualifiedName | ||
1406 | { | ||
1407 | if ($current==null) { | ||
1408 | $current = createModelElementForParent(grammarAccess.getExternDatatypeDeclarationRule()); | ||
1409 | } | ||
1410 | set( | ||
1411 | $current, | ||
1412 | "name", | ||
1413 | lv_name_2_0, | ||
1414 | "org.eclipse.viatra.solver.language.SolverLanguage.QualifiedName"); | ||
1415 | afterParserOrEnumRuleCall(); | ||
1416 | } | ||
1417 | ) | ||
1418 | ) | ||
1419 | this_FULL_STOP_3=RULE_FULL_STOP | ||
1420 | { | ||
1421 | newLeafNode(this_FULL_STOP_3, grammarAccess.getExternDatatypeDeclarationAccess().getFULL_STOPTerminalRuleCall_3()); | ||
1422 | } | ||
1423 | ) | ||
1424 | ; | ||
1425 | |||
1426 | // Entry rule entryRuleExpression | ||
1427 | entryRuleExpression returns [EObject current=null]: | ||
1428 | { newCompositeNode(grammarAccess.getExpressionRule()); } | ||
1429 | iv_ruleExpression=ruleExpression | ||
1430 | { $current=$iv_ruleExpression.current; } | ||
1431 | EOF; | ||
1432 | |||
1433 | // Rule Expression | ||
1434 | ruleExpression returns [EObject current=null] | ||
1435 | @init { | ||
1436 | enterRule(); | ||
1437 | } | ||
1438 | @after { | ||
1439 | leaveRule(); | ||
1440 | }: | ||
1441 | ( | ||
1442 | { | ||
1443 | newCompositeNode(grammarAccess.getExpressionAccess().getConditionalExpressionParserRuleCall_0()); | ||
1444 | } | ||
1445 | this_ConditionalExpression_0=ruleConditionalExpression | ||
1446 | { | ||
1447 | $current = $this_ConditionalExpression_0.current; | ||
1448 | afterParserOrEnumRuleCall(); | ||
1449 | } | ||
1450 | | | ||
1451 | { | ||
1452 | newCompositeNode(grammarAccess.getExpressionAccess().getLetExpressionParserRuleCall_1()); | ||
1453 | } | ||
1454 | this_LetExpression_1=ruleLetExpression | ||
1455 | { | ||
1456 | $current = $this_LetExpression_1.current; | ||
1457 | afterParserOrEnumRuleCall(); | ||
1458 | } | ||
1459 | | | ||
1460 | ( | ||
1461 | { | ||
1462 | newCompositeNode(grammarAccess.getExpressionAccess().getDisjunctiveExpressionParserRuleCall_2_0()); | ||
1463 | } | ||
1464 | this_DisjunctiveExpression_2=ruleDisjunctiveExpression | ||
1465 | { | ||
1466 | $current = $this_DisjunctiveExpression_2.current; | ||
1467 | afterParserOrEnumRuleCall(); | ||
1468 | } | ||
1469 | ( | ||
1470 | ( | ||
1471 | { | ||
1472 | $current = forceCreateModelElementAndSet( | ||
1473 | grammarAccess.getExpressionAccess().getForallConditionAction_2_1_0(), | ||
1474 | $current); | ||
1475 | } | ||
1476 | ) | ||
1477 | otherlv_4=EqualsSignGreaterThanSign | ||
1478 | { | ||
1479 | newLeafNode(otherlv_4, grammarAccess.getExpressionAccess().getEqualsSignGreaterThanSignKeyword_2_1_1()); | ||
1480 | } | ||
1481 | ( | ||
1482 | ( | ||
1483 | { | ||
1484 | newCompositeNode(grammarAccess.getExpressionAccess().getBodyDisjunctiveExpressionParserRuleCall_2_1_2_0()); | ||
1485 | } | ||
1486 | lv_body_5_0=ruleDisjunctiveExpression | ||
1487 | { | ||
1488 | if ($current==null) { | ||
1489 | $current = createModelElementForParent(grammarAccess.getExpressionRule()); | ||
1490 | } | ||
1491 | set( | ||
1492 | $current, | ||
1493 | "body", | ||
1494 | lv_body_5_0, | ||
1495 | "org.eclipse.viatra.solver.language.SolverLanguage.DisjunctiveExpression"); | ||
1496 | afterParserOrEnumRuleCall(); | ||
1497 | } | ||
1498 | ) | ||
1499 | ) | ||
1500 | )? | ||
1501 | ) | ||
1502 | ) | ||
1503 | ; | ||
1504 | |||
1505 | // Entry rule entryRuleConditionalExpression | ||
1506 | entryRuleConditionalExpression returns [EObject current=null]: | ||
1507 | { newCompositeNode(grammarAccess.getConditionalExpressionRule()); } | ||
1508 | iv_ruleConditionalExpression=ruleConditionalExpression | ||
1509 | { $current=$iv_ruleConditionalExpression.current; } | ||
1510 | EOF; | ||
1511 | |||
1512 | // Rule ConditionalExpression | ||
1513 | ruleConditionalExpression returns [EObject current=null] | ||
1514 | @init { | ||
1515 | enterRule(); | ||
1516 | } | ||
1517 | @after { | ||
1518 | leaveRule(); | ||
1519 | }: | ||
1520 | ( | ||
1521 | otherlv_0=If | ||
1522 | { | ||
1523 | newLeafNode(otherlv_0, grammarAccess.getConditionalExpressionAccess().getIfKeyword_0()); | ||
1524 | } | ||
1525 | ( | ||
1526 | ( | ||
1527 | { | ||
1528 | newCompositeNode(grammarAccess.getConditionalExpressionAccess().getConditionDisjunctiveExpressionParserRuleCall_1_0()); | ||
1529 | } | ||
1530 | lv_condition_1_0=ruleDisjunctiveExpression | ||
1531 | { | ||
1532 | if ($current==null) { | ||
1533 | $current = createModelElementForParent(grammarAccess.getConditionalExpressionRule()); | ||
1534 | } | ||
1535 | set( | ||
1536 | $current, | ||
1537 | "condition", | ||
1538 | lv_condition_1_0, | ||
1539 | "org.eclipse.viatra.solver.language.SolverLanguage.DisjunctiveExpression"); | ||
1540 | afterParserOrEnumRuleCall(); | ||
1541 | } | ||
1542 | ) | ||
1543 | ) | ||
1544 | otherlv_2=Then | ||
1545 | { | ||
1546 | newLeafNode(otherlv_2, grammarAccess.getConditionalExpressionAccess().getThenKeyword_2()); | ||
1547 | } | ||
1548 | ( | ||
1549 | ( | ||
1550 | { | ||
1551 | newCompositeNode(grammarAccess.getConditionalExpressionAccess().getThenExpressionParserRuleCall_3_0()); | ||
1552 | } | ||
1553 | lv_then_3_0=ruleExpression | ||
1554 | { | ||
1555 | if ($current==null) { | ||
1556 | $current = createModelElementForParent(grammarAccess.getConditionalExpressionRule()); | ||
1557 | } | ||
1558 | set( | ||
1559 | $current, | ||
1560 | "then", | ||
1561 | lv_then_3_0, | ||
1562 | "org.eclipse.viatra.solver.language.SolverLanguage.Expression"); | ||
1563 | afterParserOrEnumRuleCall(); | ||
1564 | } | ||
1565 | ) | ||
1566 | ) | ||
1567 | otherlv_4=Else | ||
1568 | { | ||
1569 | newLeafNode(otherlv_4, grammarAccess.getConditionalExpressionAccess().getElseKeyword_4()); | ||
1570 | } | ||
1571 | ( | ||
1572 | ( | ||
1573 | { | ||
1574 | newCompositeNode(grammarAccess.getConditionalExpressionAccess().getElseExpressionParserRuleCall_5_0()); | ||
1575 | } | ||
1576 | lv_else_5_0=ruleExpression | ||
1577 | { | ||
1578 | if ($current==null) { | ||
1579 | $current = createModelElementForParent(grammarAccess.getConditionalExpressionRule()); | ||
1580 | } | ||
1581 | set( | ||
1582 | $current, | ||
1583 | "else", | ||
1584 | lv_else_5_0, | ||
1585 | "org.eclipse.viatra.solver.language.SolverLanguage.Expression"); | ||
1586 | afterParserOrEnumRuleCall(); | ||
1587 | } | ||
1588 | ) | ||
1589 | ) | ||
1590 | ) | ||
1591 | ; | ||
1592 | |||
1593 | // Entry rule entryRuleLetExpression | ||
1594 | entryRuleLetExpression returns [EObject current=null]: | ||
1595 | { newCompositeNode(grammarAccess.getLetExpressionRule()); } | ||
1596 | iv_ruleLetExpression=ruleLetExpression | ||
1597 | { $current=$iv_ruleLetExpression.current; } | ||
1598 | EOF; | ||
1599 | |||
1600 | // Rule LetExpression | ||
1601 | ruleLetExpression returns [EObject current=null] | ||
1602 | @init { | ||
1603 | enterRule(); | ||
1604 | } | ||
1605 | @after { | ||
1606 | leaveRule(); | ||
1607 | }: | ||
1608 | ( | ||
1609 | otherlv_0=Let | ||
1610 | { | ||
1611 | newLeafNode(otherlv_0, grammarAccess.getLetExpressionAccess().getLetKeyword_0()); | ||
1612 | } | ||
1613 | ( | ||
1614 | ( | ||
1615 | { | ||
1616 | newCompositeNode(grammarAccess.getLetExpressionAccess().getBindingsLetBindingParserRuleCall_1_0()); | ||
1617 | } | ||
1618 | lv_bindings_1_0=ruleLetBinding | ||
1619 | { | ||
1620 | if ($current==null) { | ||
1621 | $current = createModelElementForParent(grammarAccess.getLetExpressionRule()); | ||
1622 | } | ||
1623 | add( | ||
1624 | $current, | ||
1625 | "bindings", | ||
1626 | lv_bindings_1_0, | ||
1627 | "org.eclipse.viatra.solver.language.SolverLanguage.LetBinding"); | ||
1628 | afterParserOrEnumRuleCall(); | ||
1629 | } | ||
1630 | ) | ||
1631 | ) | ||
1632 | ( | ||
1633 | otherlv_2=Comma | ||
1634 | { | ||
1635 | newLeafNode(otherlv_2, grammarAccess.getLetExpressionAccess().getCommaKeyword_2_0()); | ||
1636 | } | ||
1637 | ( | ||
1638 | ( | ||
1639 | { | ||
1640 | newCompositeNode(grammarAccess.getLetExpressionAccess().getBindingsLetBindingParserRuleCall_2_1_0()); | ||
1641 | } | ||
1642 | lv_bindings_3_0=ruleLetBinding | ||
1643 | { | ||
1644 | if ($current==null) { | ||
1645 | $current = createModelElementForParent(grammarAccess.getLetExpressionRule()); | ||
1646 | } | ||
1647 | add( | ||
1648 | $current, | ||
1649 | "bindings", | ||
1650 | lv_bindings_3_0, | ||
1651 | "org.eclipse.viatra.solver.language.SolverLanguage.LetBinding"); | ||
1652 | afterParserOrEnumRuleCall(); | ||
1653 | } | ||
1654 | ) | ||
1655 | ) | ||
1656 | )* | ||
1657 | otherlv_4=In | ||
1658 | { | ||
1659 | newLeafNode(otherlv_4, grammarAccess.getLetExpressionAccess().getInKeyword_3()); | ||
1660 | } | ||
1661 | ( | ||
1662 | ( | ||
1663 | { | ||
1664 | newCompositeNode(grammarAccess.getLetExpressionAccess().getBodyExpressionParserRuleCall_4_0()); | ||
1665 | } | ||
1666 | lv_body_5_0=ruleExpression | ||
1667 | { | ||
1668 | if ($current==null) { | ||
1669 | $current = createModelElementForParent(grammarAccess.getLetExpressionRule()); | ||
1670 | } | ||
1671 | set( | ||
1672 | $current, | ||
1673 | "body", | ||
1674 | lv_body_5_0, | ||
1675 | "org.eclipse.viatra.solver.language.SolverLanguage.Expression"); | ||
1676 | afterParserOrEnumRuleCall(); | ||
1677 | } | ||
1678 | ) | ||
1679 | ) | ||
1680 | ) | ||
1681 | ; | ||
1682 | |||
1683 | // Entry rule entryRuleLetBinding | ||
1684 | entryRuleLetBinding returns [EObject current=null]: | ||
1685 | { newCompositeNode(grammarAccess.getLetBindingRule()); } | ||
1686 | iv_ruleLetBinding=ruleLetBinding | ||
1687 | { $current=$iv_ruleLetBinding.current; } | ||
1688 | EOF; | ||
1689 | |||
1690 | // Rule LetBinding | ||
1691 | ruleLetBinding returns [EObject current=null] | ||
1692 | @init { | ||
1693 | enterRule(); | ||
1694 | } | ||
1695 | @after { | ||
1696 | leaveRule(); | ||
1697 | }: | ||
1698 | ( | ||
1699 | ( | ||
1700 | ( | ||
1701 | { | ||
1702 | if ($current==null) { | ||
1703 | $current = createModelElement(grammarAccess.getLetBindingRule()); | ||
1704 | } | ||
1705 | } | ||
1706 | { | ||
1707 | newCompositeNode(grammarAccess.getLetBindingAccess().getTypeSymbolCrossReference_0_0()); | ||
1708 | } | ||
1709 | ruleQualifiedName | ||
1710 | { | ||
1711 | afterParserOrEnumRuleCall(); | ||
1712 | } | ||
1713 | ) | ||
1714 | )? | ||
1715 | ( | ||
1716 | ( | ||
1717 | lv_name_1_0=RULE_ID | ||
1718 | { | ||
1719 | newLeafNode(lv_name_1_0, grammarAccess.getLetBindingAccess().getNameIDTerminalRuleCall_1_0()); | ||
1720 | } | ||
1721 | { | ||
1722 | if ($current==null) { | ||
1723 | $current = createModelElement(grammarAccess.getLetBindingRule()); | ||
1724 | } | ||
1725 | setWithLastConsumed( | ||
1726 | $current, | ||
1727 | "name", | ||
1728 | lv_name_1_0, | ||
1729 | "org.eclipse.xtext.common.Terminals.ID"); | ||
1730 | } | ||
1731 | ) | ||
1732 | ) | ||
1733 | otherlv_2=EqualsSign | ||
1734 | { | ||
1735 | newLeafNode(otherlv_2, grammarAccess.getLetBindingAccess().getEqualsSignKeyword_2()); | ||
1736 | } | ||
1737 | ( | ||
1738 | ( | ||
1739 | { | ||
1740 | newCompositeNode(grammarAccess.getLetBindingAccess().getValueAdditiveExpressionParserRuleCall_3_0()); | ||
1741 | } | ||
1742 | lv_value_3_0=ruleAdditiveExpression | ||
1743 | { | ||
1744 | if ($current==null) { | ||
1745 | $current = createModelElementForParent(grammarAccess.getLetBindingRule()); | ||
1746 | } | ||
1747 | set( | ||
1748 | $current, | ||
1749 | "value", | ||
1750 | lv_value_3_0, | ||
1751 | "org.eclipse.viatra.solver.language.SolverLanguage.AdditiveExpression"); | ||
1752 | afterParserOrEnumRuleCall(); | ||
1753 | } | ||
1754 | ) | ||
1755 | ) | ||
1756 | ) | ||
1757 | ; | ||
1758 | |||
1759 | // Entry rule entryRuleDisjunctiveExpression | ||
1760 | entryRuleDisjunctiveExpression returns [EObject current=null]: | ||
1761 | { newCompositeNode(grammarAccess.getDisjunctiveExpressionRule()); } | ||
1762 | iv_ruleDisjunctiveExpression=ruleDisjunctiveExpression | ||
1763 | { $current=$iv_ruleDisjunctiveExpression.current; } | ||
1764 | EOF; | ||
1765 | |||
1766 | // Rule DisjunctiveExpression | ||
1767 | ruleDisjunctiveExpression returns [EObject current=null] | ||
1768 | @init { | ||
1769 | enterRule(); | ||
1770 | } | ||
1771 | @after { | ||
1772 | leaveRule(); | ||
1773 | }: | ||
1774 | ( | ||
1775 | { | ||
1776 | newCompositeNode(grammarAccess.getDisjunctiveExpressionAccess().getConjunctiveExpressionParserRuleCall_0()); | ||
1777 | } | ||
1778 | this_ConjunctiveExpression_0=ruleConjunctiveExpression | ||
1779 | { | ||
1780 | $current = $this_ConjunctiveExpression_0.current; | ||
1781 | afterParserOrEnumRuleCall(); | ||
1782 | } | ||
1783 | ( | ||
1784 | ( | ||
1785 | ( | ||
1786 | { | ||
1787 | $current = forceCreateModelElementAndAdd( | ||
1788 | grammarAccess.getDisjunctiveExpressionAccess().getDisjunctionChildrenAction_1_0_0(), | ||
1789 | $current); | ||
1790 | } | ||
1791 | ) | ||
1792 | ( | ||
1793 | otherlv_2=Semicolon | ||
1794 | { | ||
1795 | newLeafNode(otherlv_2, grammarAccess.getDisjunctiveExpressionAccess().getSemicolonKeyword_1_0_1_0()); | ||
1796 | } | ||
1797 | ( | ||
1798 | ( | ||
1799 | { | ||
1800 | newCompositeNode(grammarAccess.getDisjunctiveExpressionAccess().getChildrenConjunctiveExpressionParserRuleCall_1_0_1_1_0()); | ||
1801 | } | ||
1802 | lv_children_3_0=ruleConjunctiveExpression | ||
1803 | { | ||
1804 | if ($current==null) { | ||
1805 | $current = createModelElementForParent(grammarAccess.getDisjunctiveExpressionRule()); | ||
1806 | } | ||
1807 | add( | ||
1808 | $current, | ||
1809 | "children", | ||
1810 | lv_children_3_0, | ||
1811 | "org.eclipse.viatra.solver.language.SolverLanguage.ConjunctiveExpression"); | ||
1812 | afterParserOrEnumRuleCall(); | ||
1813 | } | ||
1814 | ) | ||
1815 | ) | ||
1816 | )+ | ||
1817 | ) | ||
1818 | | | ||
1819 | ( | ||
1820 | ( | ||
1821 | { | ||
1822 | $current = forceCreateModelElementAndSet( | ||
1823 | grammarAccess.getDisjunctiveExpressionAccess().getCaseConditionAction_1_1_0(), | ||
1824 | $current); | ||
1825 | } | ||
1826 | ) | ||
1827 | otherlv_5=HyphenMinusGreaterThanSign | ||
1828 | { | ||
1829 | newLeafNode(otherlv_5, grammarAccess.getDisjunctiveExpressionAccess().getHyphenMinusGreaterThanSignKeyword_1_1_1()); | ||
1830 | } | ||
1831 | ( | ||
1832 | ( | ||
1833 | { | ||
1834 | newCompositeNode(grammarAccess.getDisjunctiveExpressionAccess().getBodyConjunctiveExpressionParserRuleCall_1_1_2_0()); | ||
1835 | } | ||
1836 | lv_body_6_0=ruleConjunctiveExpression | ||
1837 | { | ||
1838 | if ($current==null) { | ||
1839 | $current = createModelElementForParent(grammarAccess.getDisjunctiveExpressionRule()); | ||
1840 | } | ||
1841 | set( | ||
1842 | $current, | ||
1843 | "body", | ||
1844 | lv_body_6_0, | ||
1845 | "org.eclipse.viatra.solver.language.SolverLanguage.ConjunctiveExpression"); | ||
1846 | afterParserOrEnumRuleCall(); | ||
1847 | } | ||
1848 | ) | ||
1849 | ) | ||
1850 | ( | ||
1851 | { | ||
1852 | $current = forceCreateModelElementAndAdd( | ||
1853 | grammarAccess.getDisjunctiveExpressionAccess().getSwitchCasesAction_1_1_3(), | ||
1854 | $current); | ||
1855 | } | ||
1856 | ) | ||
1857 | ( | ||
1858 | otherlv_8=Semicolon | ||
1859 | { | ||
1860 | newLeafNode(otherlv_8, grammarAccess.getDisjunctiveExpressionAccess().getSemicolonKeyword_1_1_4_0()); | ||
1861 | } | ||
1862 | ( | ||
1863 | ( | ||
1864 | { | ||
1865 | newCompositeNode(grammarAccess.getDisjunctiveExpressionAccess().getCasesCaseParserRuleCall_1_1_4_1_0()); | ||
1866 | } | ||
1867 | lv_cases_9_0=ruleCase | ||
1868 | { | ||
1869 | if ($current==null) { | ||
1870 | $current = createModelElementForParent(grammarAccess.getDisjunctiveExpressionRule()); | ||
1871 | } | ||
1872 | add( | ||
1873 | $current, | ||
1874 | "cases", | ||
1875 | lv_cases_9_0, | ||
1876 | "org.eclipse.viatra.solver.language.SolverLanguage.Case"); | ||
1877 | afterParserOrEnumRuleCall(); | ||
1878 | } | ||
1879 | ) | ||
1880 | ) | ||
1881 | )* | ||
1882 | ) | ||
1883 | )? | ||
1884 | ) | ||
1885 | ; | ||
1886 | |||
1887 | // Entry rule entryRuleCase | ||
1888 | entryRuleCase returns [EObject current=null]: | ||
1889 | { newCompositeNode(grammarAccess.getCaseRule()); } | ||
1890 | iv_ruleCase=ruleCase | ||
1891 | { $current=$iv_ruleCase.current; } | ||
1892 | EOF; | ||
1893 | |||
1894 | // Rule Case | ||
1895 | ruleCase returns [EObject current=null] | ||
1896 | @init { | ||
1897 | enterRule(); | ||
1898 | } | ||
1899 | @after { | ||
1900 | leaveRule(); | ||
1901 | }: | ||
1902 | ( | ||
1903 | ( | ||
1904 | ( | ||
1905 | { | ||
1906 | newCompositeNode(grammarAccess.getCaseAccess().getConditionConjunctiveExpressionParserRuleCall_0_0()); | ||
1907 | } | ||
1908 | lv_condition_0_0=ruleConjunctiveExpression | ||
1909 | { | ||
1910 | if ($current==null) { | ||
1911 | $current = createModelElementForParent(grammarAccess.getCaseRule()); | ||
1912 | } | ||
1913 | set( | ||
1914 | $current, | ||
1915 | "condition", | ||
1916 | lv_condition_0_0, | ||
1917 | "org.eclipse.viatra.solver.language.SolverLanguage.ConjunctiveExpression"); | ||
1918 | afterParserOrEnumRuleCall(); | ||
1919 | } | ||
1920 | ) | ||
1921 | ) | ||
1922 | otherlv_1=HyphenMinusGreaterThanSign | ||
1923 | { | ||
1924 | newLeafNode(otherlv_1, grammarAccess.getCaseAccess().getHyphenMinusGreaterThanSignKeyword_1()); | ||
1925 | } | ||
1926 | ( | ||
1927 | ( | ||
1928 | { | ||
1929 | newCompositeNode(grammarAccess.getCaseAccess().getBodyConjunctiveExpressionParserRuleCall_2_0()); | ||
1930 | } | ||
1931 | lv_body_2_0=ruleConjunctiveExpression | ||
1932 | { | ||
1933 | if ($current==null) { | ||
1934 | $current = createModelElementForParent(grammarAccess.getCaseRule()); | ||
1935 | } | ||
1936 | set( | ||
1937 | $current, | ||
1938 | "body", | ||
1939 | lv_body_2_0, | ||
1940 | "org.eclipse.viatra.solver.language.SolverLanguage.ConjunctiveExpression"); | ||
1941 | afterParserOrEnumRuleCall(); | ||
1942 | } | ||
1943 | ) | ||
1944 | ) | ||
1945 | ) | ||
1946 | ; | ||
1947 | |||
1948 | // Entry rule entryRuleConjunctiveExpression | ||
1949 | entryRuleConjunctiveExpression returns [EObject current=null]: | ||
1950 | { newCompositeNode(grammarAccess.getConjunctiveExpressionRule()); } | ||
1951 | iv_ruleConjunctiveExpression=ruleConjunctiveExpression | ||
1952 | { $current=$iv_ruleConjunctiveExpression.current; } | ||
1953 | EOF; | ||
1954 | |||
1955 | // Rule ConjunctiveExpression | ||
1956 | ruleConjunctiveExpression returns [EObject current=null] | ||
1957 | @init { | ||
1958 | enterRule(); | ||
1959 | } | ||
1960 | @after { | ||
1961 | leaveRule(); | ||
1962 | }: | ||
1963 | ( | ||
1964 | { | ||
1965 | newCompositeNode(grammarAccess.getConjunctiveExpressionAccess().getComparisonExpressionParserRuleCall_0()); | ||
1966 | } | ||
1967 | this_ComparisonExpression_0=ruleComparisonExpression | ||
1968 | { | ||
1969 | $current = $this_ComparisonExpression_0.current; | ||
1970 | afterParserOrEnumRuleCall(); | ||
1971 | } | ||
1972 | ( | ||
1973 | ( | ||
1974 | { | ||
1975 | $current = forceCreateModelElementAndAdd( | ||
1976 | grammarAccess.getConjunctiveExpressionAccess().getConjunctionChildrenAction_1_0(), | ||
1977 | $current); | ||
1978 | } | ||
1979 | ) | ||
1980 | ( | ||
1981 | otherlv_2=Comma | ||
1982 | { | ||
1983 | newLeafNode(otherlv_2, grammarAccess.getConjunctiveExpressionAccess().getCommaKeyword_1_1_0()); | ||
1984 | } | ||
1985 | ( | ||
1986 | ( | ||
1987 | { | ||
1988 | newCompositeNode(grammarAccess.getConjunctiveExpressionAccess().getChildrenComparisonExpressionParserRuleCall_1_1_1_0()); | ||
1989 | } | ||
1990 | lv_children_3_0=ruleComparisonExpression | ||
1991 | { | ||
1992 | if ($current==null) { | ||
1993 | $current = createModelElementForParent(grammarAccess.getConjunctiveExpressionRule()); | ||
1994 | } | ||
1995 | add( | ||
1996 | $current, | ||
1997 | "children", | ||
1998 | lv_children_3_0, | ||
1999 | "org.eclipse.viatra.solver.language.SolverLanguage.ComparisonExpression"); | ||
2000 | afterParserOrEnumRuleCall(); | ||
2001 | } | ||
2002 | ) | ||
2003 | ) | ||
2004 | )+ | ||
2005 | )? | ||
2006 | ) | ||
2007 | ; | ||
2008 | |||
2009 | // Entry rule entryRuleComparisonExpression | ||
2010 | entryRuleComparisonExpression returns [EObject current=null]: | ||
2011 | { newCompositeNode(grammarAccess.getComparisonExpressionRule()); } | ||
2012 | iv_ruleComparisonExpression=ruleComparisonExpression | ||
2013 | { $current=$iv_ruleComparisonExpression.current; } | ||
2014 | EOF; | ||
2015 | |||
2016 | // Rule ComparisonExpression | ||
2017 | ruleComparisonExpression returns [EObject current=null] | ||
2018 | @init { | ||
2019 | enterRule(); | ||
2020 | } | ||
2021 | @after { | ||
2022 | leaveRule(); | ||
2023 | }: | ||
2024 | ( | ||
2025 | { | ||
2026 | newCompositeNode(grammarAccess.getComparisonExpressionAccess().getAdditiveExpressionParserRuleCall_0()); | ||
2027 | } | ||
2028 | this_AdditiveExpression_0=ruleAdditiveExpression | ||
2029 | { | ||
2030 | $current = $this_AdditiveExpression_0.current; | ||
2031 | afterParserOrEnumRuleCall(); | ||
2032 | } | ||
2033 | ( | ||
2034 | ( | ||
2035 | { | ||
2036 | $current = forceCreateModelElementAndSet( | ||
2037 | grammarAccess.getComparisonExpressionAccess().getBinaryExpressionLeftAction_1_0(), | ||
2038 | $current); | ||
2039 | } | ||
2040 | ) | ||
2041 | ( | ||
2042 | ( | ||
2043 | { | ||
2044 | newCompositeNode(grammarAccess.getComparisonExpressionAccess().getOpComparisonOperatorEnumRuleCall_1_1_0()); | ||
2045 | } | ||
2046 | lv_op_2_0=ruleComparisonOperator | ||
2047 | { | ||
2048 | if ($current==null) { | ||
2049 | $current = createModelElementForParent(grammarAccess.getComparisonExpressionRule()); | ||
2050 | } | ||
2051 | set( | ||
2052 | $current, | ||
2053 | "op", | ||
2054 | lv_op_2_0, | ||
2055 | "org.eclipse.viatra.solver.language.SolverLanguage.ComparisonOperator"); | ||
2056 | afterParserOrEnumRuleCall(); | ||
2057 | } | ||
2058 | ) | ||
2059 | ) | ||
2060 | ( | ||
2061 | ( | ||
2062 | { | ||
2063 | newCompositeNode(grammarAccess.getComparisonExpressionAccess().getRightAdditiveExpressionParserRuleCall_1_2_0()); | ||
2064 | } | ||
2065 | lv_right_3_0=ruleAdditiveExpression | ||
2066 | { | ||
2067 | if ($current==null) { | ||
2068 | $current = createModelElementForParent(grammarAccess.getComparisonExpressionRule()); | ||
2069 | } | ||
2070 | set( | ||
2071 | $current, | ||
2072 | "right", | ||
2073 | lv_right_3_0, | ||
2074 | "org.eclipse.viatra.solver.language.SolverLanguage.AdditiveExpression"); | ||
2075 | afterParserOrEnumRuleCall(); | ||
2076 | } | ||
2077 | ) | ||
2078 | ) | ||
2079 | )? | ||
2080 | ) | ||
2081 | ; | ||
2082 | |||
2083 | // Entry rule entryRuleAdditiveExpression | ||
2084 | entryRuleAdditiveExpression returns [EObject current=null]: | ||
2085 | { newCompositeNode(grammarAccess.getAdditiveExpressionRule()); } | ||
2086 | iv_ruleAdditiveExpression=ruleAdditiveExpression | ||
2087 | { $current=$iv_ruleAdditiveExpression.current; } | ||
2088 | EOF; | ||
2089 | |||
2090 | // Rule AdditiveExpression | ||
2091 | ruleAdditiveExpression returns [EObject current=null] | ||
2092 | @init { | ||
2093 | enterRule(); | ||
2094 | } | ||
2095 | @after { | ||
2096 | leaveRule(); | ||
2097 | }: | ||
2098 | ( | ||
2099 | { | ||
2100 | newCompositeNode(grammarAccess.getAdditiveExpressionAccess().getMultiplicativeExpressionParserRuleCall_0()); | ||
2101 | } | ||
2102 | this_MultiplicativeExpression_0=ruleMultiplicativeExpression | ||
2103 | { | ||
2104 | $current = $this_MultiplicativeExpression_0.current; | ||
2105 | afterParserOrEnumRuleCall(); | ||
2106 | } | ||
2107 | ( | ||
2108 | ( | ||
2109 | { | ||
2110 | $current = forceCreateModelElementAndSet( | ||
2111 | grammarAccess.getAdditiveExpressionAccess().getBinaryExpressionLeftAction_1_0(), | ||
2112 | $current); | ||
2113 | } | ||
2114 | ) | ||
2115 | ( | ||
2116 | ( | ||
2117 | { | ||
2118 | newCompositeNode(grammarAccess.getAdditiveExpressionAccess().getOpAdditiveBinaryOperatorEnumRuleCall_1_1_0()); | ||
2119 | } | ||
2120 | lv_op_2_0=ruleAdditiveBinaryOperator | ||
2121 | { | ||
2122 | if ($current==null) { | ||
2123 | $current = createModelElementForParent(grammarAccess.getAdditiveExpressionRule()); | ||
2124 | } | ||
2125 | set( | ||
2126 | $current, | ||
2127 | "op", | ||
2128 | lv_op_2_0, | ||
2129 | "org.eclipse.viatra.solver.language.SolverLanguage.AdditiveBinaryOperator"); | ||
2130 | afterParserOrEnumRuleCall(); | ||
2131 | } | ||
2132 | ) | ||
2133 | ) | ||
2134 | ( | ||
2135 | ( | ||
2136 | { | ||
2137 | newCompositeNode(grammarAccess.getAdditiveExpressionAccess().getRightMultiplicativeExpressionParserRuleCall_1_2_0()); | ||
2138 | } | ||
2139 | lv_right_3_0=ruleMultiplicativeExpression | ||
2140 | { | ||
2141 | if ($current==null) { | ||
2142 | $current = createModelElementForParent(grammarAccess.getAdditiveExpressionRule()); | ||
2143 | } | ||
2144 | set( | ||
2145 | $current, | ||
2146 | "right", | ||
2147 | lv_right_3_0, | ||
2148 | "org.eclipse.viatra.solver.language.SolverLanguage.MultiplicativeExpression"); | ||
2149 | afterParserOrEnumRuleCall(); | ||
2150 | } | ||
2151 | ) | ||
2152 | ) | ||
2153 | )* | ||
2154 | ) | ||
2155 | ; | ||
2156 | |||
2157 | // Entry rule entryRuleMultiplicativeExpression | ||
2158 | entryRuleMultiplicativeExpression returns [EObject current=null]: | ||
2159 | { newCompositeNode(grammarAccess.getMultiplicativeExpressionRule()); } | ||
2160 | iv_ruleMultiplicativeExpression=ruleMultiplicativeExpression | ||
2161 | { $current=$iv_ruleMultiplicativeExpression.current; } | ||
2162 | EOF; | ||
2163 | |||
2164 | // Rule MultiplicativeExpression | ||
2165 | ruleMultiplicativeExpression returns [EObject current=null] | ||
2166 | @init { | ||
2167 | enterRule(); | ||
2168 | } | ||
2169 | @after { | ||
2170 | leaveRule(); | ||
2171 | }: | ||
2172 | ( | ||
2173 | { | ||
2174 | newCompositeNode(grammarAccess.getMultiplicativeExpressionAccess().getExponentialExpressionParserRuleCall_0()); | ||
2175 | } | ||
2176 | this_ExponentialExpression_0=ruleExponentialExpression | ||
2177 | { | ||
2178 | $current = $this_ExponentialExpression_0.current; | ||
2179 | afterParserOrEnumRuleCall(); | ||
2180 | } | ||
2181 | ( | ||
2182 | ( | ||
2183 | { | ||
2184 | $current = forceCreateModelElementAndSet( | ||
2185 | grammarAccess.getMultiplicativeExpressionAccess().getBinaryExpressionLeftAction_1_0(), | ||
2186 | $current); | ||
2187 | } | ||
2188 | ) | ||
2189 | ( | ||
2190 | ( | ||
2191 | { | ||
2192 | newCompositeNode(grammarAccess.getMultiplicativeExpressionAccess().getOpMultiplicativeBinaryOperatorEnumRuleCall_1_1_0()); | ||
2193 | } | ||
2194 | lv_op_2_0=ruleMultiplicativeBinaryOperator | ||
2195 | { | ||
2196 | if ($current==null) { | ||
2197 | $current = createModelElementForParent(grammarAccess.getMultiplicativeExpressionRule()); | ||
2198 | } | ||
2199 | set( | ||
2200 | $current, | ||
2201 | "op", | ||
2202 | lv_op_2_0, | ||
2203 | "org.eclipse.viatra.solver.language.SolverLanguage.MultiplicativeBinaryOperator"); | ||
2204 | afterParserOrEnumRuleCall(); | ||
2205 | } | ||
2206 | ) | ||
2207 | ) | ||
2208 | ( | ||
2209 | ( | ||
2210 | { | ||
2211 | newCompositeNode(grammarAccess.getMultiplicativeExpressionAccess().getRightExponentialExpressionParserRuleCall_1_2_0()); | ||
2212 | } | ||
2213 | lv_right_3_0=ruleExponentialExpression | ||
2214 | { | ||
2215 | if ($current==null) { | ||
2216 | $current = createModelElementForParent(grammarAccess.getMultiplicativeExpressionRule()); | ||
2217 | } | ||
2218 | set( | ||
2219 | $current, | ||
2220 | "right", | ||
2221 | lv_right_3_0, | ||
2222 | "org.eclipse.viatra.solver.language.SolverLanguage.ExponentialExpression"); | ||
2223 | afterParserOrEnumRuleCall(); | ||
2224 | } | ||
2225 | ) | ||
2226 | ) | ||
2227 | )* | ||
2228 | ) | ||
2229 | ; | ||
2230 | |||
2231 | // Entry rule entryRuleExponentialExpression | ||
2232 | entryRuleExponentialExpression returns [EObject current=null]: | ||
2233 | { newCompositeNode(grammarAccess.getExponentialExpressionRule()); } | ||
2234 | iv_ruleExponentialExpression=ruleExponentialExpression | ||
2235 | { $current=$iv_ruleExponentialExpression.current; } | ||
2236 | EOF; | ||
2237 | |||
2238 | // Rule ExponentialExpression | ||
2239 | ruleExponentialExpression returns [EObject current=null] | ||
2240 | @init { | ||
2241 | enterRule(); | ||
2242 | } | ||
2243 | @after { | ||
2244 | leaveRule(); | ||
2245 | }: | ||
2246 | ( | ||
2247 | { | ||
2248 | newCompositeNode(grammarAccess.getExponentialExpressionAccess().getCastExpressionParserRuleCall_0()); | ||
2249 | } | ||
2250 | this_CastExpression_0=ruleCastExpression | ||
2251 | { | ||
2252 | $current = $this_CastExpression_0.current; | ||
2253 | afterParserOrEnumRuleCall(); | ||
2254 | } | ||
2255 | ( | ||
2256 | ( | ||
2257 | { | ||
2258 | $current = forceCreateModelElementAndSet( | ||
2259 | grammarAccess.getExponentialExpressionAccess().getBinaryExpressionLeftAction_1_0(), | ||
2260 | $current); | ||
2261 | } | ||
2262 | ) | ||
2263 | ( | ||
2264 | ( | ||
2265 | { | ||
2266 | newCompositeNode(grammarAccess.getExponentialExpressionAccess().getOpExponentialOpEnumRuleCall_1_1_0()); | ||
2267 | } | ||
2268 | lv_op_2_0=ruleExponentialOp | ||
2269 | { | ||
2270 | if ($current==null) { | ||
2271 | $current = createModelElementForParent(grammarAccess.getExponentialExpressionRule()); | ||
2272 | } | ||
2273 | set( | ||
2274 | $current, | ||
2275 | "op", | ||
2276 | lv_op_2_0, | ||
2277 | "org.eclipse.viatra.solver.language.SolverLanguage.ExponentialOp"); | ||
2278 | afterParserOrEnumRuleCall(); | ||
2279 | } | ||
2280 | ) | ||
2281 | ) | ||
2282 | ( | ||
2283 | ( | ||
2284 | { | ||
2285 | newCompositeNode(grammarAccess.getExponentialExpressionAccess().getRightCastExpressionParserRuleCall_1_2_0()); | ||
2286 | } | ||
2287 | lv_right_3_0=ruleCastExpression | ||
2288 | { | ||
2289 | if ($current==null) { | ||
2290 | $current = createModelElementForParent(grammarAccess.getExponentialExpressionRule()); | ||
2291 | } | ||
2292 | set( | ||
2293 | $current, | ||
2294 | "right", | ||
2295 | lv_right_3_0, | ||
2296 | "org.eclipse.viatra.solver.language.SolverLanguage.CastExpression"); | ||
2297 | afterParserOrEnumRuleCall(); | ||
2298 | } | ||
2299 | ) | ||
2300 | ) | ||
2301 | )? | ||
2302 | ) | ||
2303 | ; | ||
2304 | |||
2305 | // Entry rule entryRuleCastExpression | ||
2306 | entryRuleCastExpression returns [EObject current=null]: | ||
2307 | { newCompositeNode(grammarAccess.getCastExpressionRule()); } | ||
2308 | iv_ruleCastExpression=ruleCastExpression | ||
2309 | { $current=$iv_ruleCastExpression.current; } | ||
2310 | EOF; | ||
2311 | |||
2312 | // Rule CastExpression | ||
2313 | ruleCastExpression returns [EObject current=null] | ||
2314 | @init { | ||
2315 | enterRule(); | ||
2316 | } | ||
2317 | @after { | ||
2318 | leaveRule(); | ||
2319 | }: | ||
2320 | ( | ||
2321 | { | ||
2322 | newCompositeNode(grammarAccess.getCastExpressionAccess().getUnaryExpressionParserRuleCall_0()); | ||
2323 | } | ||
2324 | this_UnaryExpression_0=ruleUnaryExpression | ||
2325 | { | ||
2326 | $current = $this_UnaryExpression_0.current; | ||
2327 | afterParserOrEnumRuleCall(); | ||
2328 | } | ||
2329 | ( | ||
2330 | ( | ||
2331 | { | ||
2332 | $current = forceCreateModelElementAndSet( | ||
2333 | grammarAccess.getCastExpressionAccess().getCastExpressionBodyAction_1_0(), | ||
2334 | $current); | ||
2335 | } | ||
2336 | ) | ||
2337 | otherlv_2=As | ||
2338 | { | ||
2339 | newLeafNode(otherlv_2, grammarAccess.getCastExpressionAccess().getAsKeyword_1_1()); | ||
2340 | } | ||
2341 | ( | ||
2342 | ( | ||
2343 | { | ||
2344 | if ($current==null) { | ||
2345 | $current = createModelElement(grammarAccess.getCastExpressionRule()); | ||
2346 | } | ||
2347 | } | ||
2348 | { | ||
2349 | newCompositeNode(grammarAccess.getCastExpressionAccess().getTargetTypeSymbolCrossReference_1_2_0()); | ||
2350 | } | ||
2351 | ruleQualifiedName | ||
2352 | { | ||
2353 | afterParserOrEnumRuleCall(); | ||
2354 | } | ||
2355 | ) | ||
2356 | ) | ||
2357 | )? | ||
2358 | ) | ||
2359 | ; | ||
2360 | |||
2361 | // Entry rule entryRuleUnaryExpression | ||
2362 | entryRuleUnaryExpression returns [EObject current=null]: | ||
2363 | { newCompositeNode(grammarAccess.getUnaryExpressionRule()); } | ||
2364 | iv_ruleUnaryExpression=ruleUnaryExpression | ||
2365 | { $current=$iv_ruleUnaryExpression.current; } | ||
2366 | EOF; | ||
2367 | |||
2368 | // Rule UnaryExpression | ||
2369 | ruleUnaryExpression returns [EObject current=null] | ||
2370 | @init { | ||
2371 | enterRule(); | ||
2372 | } | ||
2373 | @after { | ||
2374 | leaveRule(); | ||
2375 | }: | ||
2376 | ( | ||
2377 | { | ||
2378 | newCompositeNode(grammarAccess.getUnaryExpressionAccess().getBracedAggregateExpressionParserRuleCall_0()); | ||
2379 | } | ||
2380 | this_BracedAggregateExpression_0=ruleBracedAggregateExpression | ||
2381 | { | ||
2382 | $current = $this_BracedAggregateExpression_0.current; | ||
2383 | afterParserOrEnumRuleCall(); | ||
2384 | } | ||
2385 | | | ||
2386 | ( | ||
2387 | ( | ||
2388 | { | ||
2389 | $current = forceCreateModelElement( | ||
2390 | grammarAccess.getUnaryExpressionAccess().getUnaryExpressionAction_1_0(), | ||
2391 | $current); | ||
2392 | } | ||
2393 | ) | ||
2394 | ( | ||
2395 | ( | ||
2396 | { | ||
2397 | newCompositeNode(grammarAccess.getUnaryExpressionAccess().getOpUnaryOperatorEnumRuleCall_1_1_0()); | ||
2398 | } | ||
2399 | lv_op_2_0=ruleUnaryOperator | ||
2400 | { | ||
2401 | if ($current==null) { | ||
2402 | $current = createModelElementForParent(grammarAccess.getUnaryExpressionRule()); | ||
2403 | } | ||
2404 | set( | ||
2405 | $current, | ||
2406 | "op", | ||
2407 | lv_op_2_0, | ||
2408 | "org.eclipse.viatra.solver.language.SolverLanguage.UnaryOperator"); | ||
2409 | afterParserOrEnumRuleCall(); | ||
2410 | } | ||
2411 | ) | ||
2412 | ) | ||
2413 | ( | ||
2414 | ( | ||
2415 | { | ||
2416 | newCompositeNode(grammarAccess.getUnaryExpressionAccess().getBodyBracedAggregateExpressionParserRuleCall_1_2_0()); | ||
2417 | } | ||
2418 | lv_body_3_0=ruleBracedAggregateExpression | ||
2419 | { | ||
2420 | if ($current==null) { | ||
2421 | $current = createModelElementForParent(grammarAccess.getUnaryExpressionRule()); | ||
2422 | } | ||
2423 | set( | ||
2424 | $current, | ||
2425 | "body", | ||
2426 | lv_body_3_0, | ||
2427 | "org.eclipse.viatra.solver.language.SolverLanguage.BracedAggregateExpression"); | ||
2428 | afterParserOrEnumRuleCall(); | ||
2429 | } | ||
2430 | ) | ||
2431 | ) | ||
2432 | ) | ||
2433 | ) | ||
2434 | ; | ||
2435 | |||
2436 | // Entry rule entryRuleBracedAggregateExpression | ||
2437 | entryRuleBracedAggregateExpression returns [EObject current=null]: | ||
2438 | { newCompositeNode(grammarAccess.getBracedAggregateExpressionRule()); } | ||
2439 | iv_ruleBracedAggregateExpression=ruleBracedAggregateExpression | ||
2440 | { $current=$iv_ruleBracedAggregateExpression.current; } | ||
2441 | EOF; | ||
2442 | |||
2443 | // Rule BracedAggregateExpression | ||
2444 | ruleBracedAggregateExpression returns [EObject current=null] | ||
2445 | @init { | ||
2446 | enterRule(); | ||
2447 | } | ||
2448 | @after { | ||
2449 | leaveRule(); | ||
2450 | }: | ||
2451 | ( | ||
2452 | { | ||
2453 | newCompositeNode(grammarAccess.getBracedAggregateExpressionAccess().getAtomicExpressionParserRuleCall_0()); | ||
2454 | } | ||
2455 | this_AtomicExpression_0=ruleAtomicExpression | ||
2456 | { | ||
2457 | $current = $this_AtomicExpression_0.current; | ||
2458 | afterParserOrEnumRuleCall(); | ||
2459 | } | ||
2460 | | | ||
2461 | { | ||
2462 | newCompositeNode(grammarAccess.getBracedAggregateExpressionAccess().getAggregationParserRuleCall_1()); | ||
2463 | } | ||
2464 | this_Aggregation_1=ruleAggregation | ||
2465 | { | ||
2466 | $current = $this_Aggregation_1.current; | ||
2467 | afterParserOrEnumRuleCall(); | ||
2468 | } | ||
2469 | | | ||
2470 | { | ||
2471 | newCompositeNode(grammarAccess.getBracedAggregateExpressionAccess().getCountParserRuleCall_2()); | ||
2472 | } | ||
2473 | this_Count_2=ruleCount | ||
2474 | { | ||
2475 | $current = $this_Count_2.current; | ||
2476 | afterParserOrEnumRuleCall(); | ||
2477 | } | ||
2478 | ) | ||
2479 | ; | ||
2480 | |||
2481 | // Entry rule entryRuleAggregation | ||
2482 | entryRuleAggregation returns [EObject current=null]: | ||
2483 | { newCompositeNode(grammarAccess.getAggregationRule()); } | ||
2484 | iv_ruleAggregation=ruleAggregation | ||
2485 | { $current=$iv_ruleAggregation.current; } | ||
2486 | EOF; | ||
2487 | |||
2488 | // Rule Aggregation | ||
2489 | ruleAggregation returns [EObject current=null] | ||
2490 | @init { | ||
2491 | enterRule(); | ||
2492 | } | ||
2493 | @after { | ||
2494 | leaveRule(); | ||
2495 | }: | ||
2496 | ( | ||
2497 | ( | ||
2498 | ( | ||
2499 | { | ||
2500 | if ($current==null) { | ||
2501 | $current = createModelElement(grammarAccess.getAggregationRule()); | ||
2502 | } | ||
2503 | } | ||
2504 | { | ||
2505 | newCompositeNode(grammarAccess.getAggregationAccess().getOpSymbolCrossReference_0_0()); | ||
2506 | } | ||
2507 | ruleQualifiedName | ||
2508 | { | ||
2509 | afterParserOrEnumRuleCall(); | ||
2510 | } | ||
2511 | ) | ||
2512 | ) | ||
2513 | otherlv_1=LeftCurlyBracket | ||
2514 | { | ||
2515 | newLeafNode(otherlv_1, grammarAccess.getAggregationAccess().getLeftCurlyBracketKeyword_1()); | ||
2516 | } | ||
2517 | ( | ||
2518 | ( | ||
2519 | { | ||
2520 | newCompositeNode(grammarAccess.getAggregationAccess().getValueExpressionParserRuleCall_2_0()); | ||
2521 | } | ||
2522 | lv_value_2_0=ruleExpression | ||
2523 | { | ||
2524 | if ($current==null) { | ||
2525 | $current = createModelElementForParent(grammarAccess.getAggregationRule()); | ||
2526 | } | ||
2527 | set( | ||
2528 | $current, | ||
2529 | "value", | ||
2530 | lv_value_2_0, | ||
2531 | "org.eclipse.viatra.solver.language.SolverLanguage.Expression"); | ||
2532 | afterParserOrEnumRuleCall(); | ||
2533 | } | ||
2534 | ) | ||
2535 | ) | ||
2536 | otherlv_3=VerticalLine | ||
2537 | { | ||
2538 | newLeafNode(otherlv_3, grammarAccess.getAggregationAccess().getVerticalLineKeyword_3()); | ||
2539 | } | ||
2540 | ( | ||
2541 | ( | ||
2542 | { | ||
2543 | newCompositeNode(grammarAccess.getAggregationAccess().getConditionExpressionParserRuleCall_4_0()); | ||
2544 | } | ||
2545 | lv_condition_4_0=ruleExpression | ||
2546 | { | ||
2547 | if ($current==null) { | ||
2548 | $current = createModelElementForParent(grammarAccess.getAggregationRule()); | ||
2549 | } | ||
2550 | set( | ||
2551 | $current, | ||
2552 | "condition", | ||
2553 | lv_condition_4_0, | ||
2554 | "org.eclipse.viatra.solver.language.SolverLanguage.Expression"); | ||
2555 | afterParserOrEnumRuleCall(); | ||
2556 | } | ||
2557 | ) | ||
2558 | ) | ||
2559 | otherlv_5=RightCurlyBracket | ||
2560 | { | ||
2561 | newLeafNode(otherlv_5, grammarAccess.getAggregationAccess().getRightCurlyBracketKeyword_5()); | ||
2562 | } | ||
2563 | ) | ||
2564 | ; | ||
2565 | |||
2566 | // Entry rule entryRuleCount | ||
2567 | entryRuleCount returns [EObject current=null]: | ||
2568 | { newCompositeNode(grammarAccess.getCountRule()); } | ||
2569 | iv_ruleCount=ruleCount | ||
2570 | { $current=$iv_ruleCount.current; } | ||
2571 | EOF; | ||
2572 | |||
2573 | // Rule Count | ||
2574 | ruleCount returns [EObject current=null] | ||
2575 | @init { | ||
2576 | enterRule(); | ||
2577 | } | ||
2578 | @after { | ||
2579 | leaveRule(); | ||
2580 | }: | ||
2581 | ( | ||
2582 | otherlv_0=Count | ||
2583 | { | ||
2584 | newLeafNode(otherlv_0, grammarAccess.getCountAccess().getCountKeyword_0()); | ||
2585 | } | ||
2586 | otherlv_1=LeftCurlyBracket | ||
2587 | { | ||
2588 | newLeafNode(otherlv_1, grammarAccess.getCountAccess().getLeftCurlyBracketKeyword_1()); | ||
2589 | } | ||
2590 | ( | ||
2591 | ( | ||
2592 | { | ||
2593 | newCompositeNode(grammarAccess.getCountAccess().getConditionExpressionParserRuleCall_2_0()); | ||
2594 | } | ||
2595 | lv_condition_2_0=ruleExpression | ||
2596 | { | ||
2597 | if ($current==null) { | ||
2598 | $current = createModelElementForParent(grammarAccess.getCountRule()); | ||
2599 | } | ||
2600 | set( | ||
2601 | $current, | ||
2602 | "condition", | ||
2603 | lv_condition_2_0, | ||
2604 | "org.eclipse.viatra.solver.language.SolverLanguage.Expression"); | ||
2605 | afterParserOrEnumRuleCall(); | ||
2606 | } | ||
2607 | ) | ||
2608 | ) | ||
2609 | otherlv_3=RightCurlyBracket | ||
2610 | { | ||
2611 | newLeafNode(otherlv_3, grammarAccess.getCountAccess().getRightCurlyBracketKeyword_3()); | ||
2612 | } | ||
2613 | ) | ||
2614 | ; | ||
2615 | |||
2616 | // Entry rule entryRuleAtomicExpression | ||
2617 | entryRuleAtomicExpression returns [EObject current=null]: | ||
2618 | { newCompositeNode(grammarAccess.getAtomicExpressionRule()); } | ||
2619 | iv_ruleAtomicExpression=ruleAtomicExpression | ||
2620 | { $current=$iv_ruleAtomicExpression.current; } | ||
2621 | EOF; | ||
2622 | |||
2623 | // Rule AtomicExpression | ||
2624 | ruleAtomicExpression returns [EObject current=null] | ||
2625 | @init { | ||
2626 | enterRule(); | ||
2627 | } | ||
2628 | @after { | ||
2629 | leaveRule(); | ||
2630 | }: | ||
2631 | ( | ||
2632 | { | ||
2633 | newCompositeNode(grammarAccess.getAtomicExpressionAccess().getReferenceParserRuleCall_0()); | ||
2634 | } | ||
2635 | this_Reference_0=ruleReference | ||
2636 | { | ||
2637 | $current = $this_Reference_0.current; | ||
2638 | afterParserOrEnumRuleCall(); | ||
2639 | } | ||
2640 | | | ||
2641 | { | ||
2642 | newCompositeNode(grammarAccess.getAtomicExpressionAccess().getCallParserRuleCall_1()); | ||
2643 | } | ||
2644 | this_Call_1=ruleCall | ||
2645 | { | ||
2646 | $current = $this_Call_1.current; | ||
2647 | afterParserOrEnumRuleCall(); | ||
2648 | } | ||
2649 | | | ||
2650 | { | ||
2651 | newCompositeNode(grammarAccess.getAtomicExpressionAccess().getIntervalParserRuleCall_2()); | ||
2652 | } | ||
2653 | this_Interval_2=ruleInterval | ||
2654 | { | ||
2655 | $current = $this_Interval_2.current; | ||
2656 | afterParserOrEnumRuleCall(); | ||
2657 | } | ||
2658 | | | ||
2659 | { | ||
2660 | newCompositeNode(grammarAccess.getAtomicExpressionAccess().getLiteralParserRuleCall_3()); | ||
2661 | } | ||
2662 | this_Literal_3=ruleLiteral | ||
2663 | { | ||
2664 | $current = $this_Literal_3.current; | ||
2665 | afterParserOrEnumRuleCall(); | ||
2666 | } | ||
2667 | | | ||
2668 | ( | ||
2669 | otherlv_4=LeftParenthesis | ||
2670 | { | ||
2671 | newLeafNode(otherlv_4, grammarAccess.getAtomicExpressionAccess().getLeftParenthesisKeyword_4_0()); | ||
2672 | } | ||
2673 | { | ||
2674 | newCompositeNode(grammarAccess.getAtomicExpressionAccess().getExpressionParserRuleCall_4_1()); | ||
2675 | } | ||
2676 | this_Expression_5=ruleExpression | ||
2677 | { | ||
2678 | $current = $this_Expression_5.current; | ||
2679 | afterParserOrEnumRuleCall(); | ||
2680 | } | ||
2681 | otherlv_6=RightParenthesis | ||
2682 | { | ||
2683 | newLeafNode(otherlv_6, grammarAccess.getAtomicExpressionAccess().getRightParenthesisKeyword_4_2()); | ||
2684 | } | ||
2685 | ) | ||
2686 | ) | ||
2687 | ; | ||
2688 | |||
2689 | // Entry rule entryRuleCall | ||
2690 | entryRuleCall returns [EObject current=null]: | ||
2691 | { newCompositeNode(grammarAccess.getCallRule()); } | ||
2692 | iv_ruleCall=ruleCall | ||
2693 | { $current=$iv_ruleCall.current; } | ||
2694 | EOF; | ||
2695 | |||
2696 | // Rule Call | ||
2697 | ruleCall returns [EObject current=null] | ||
2698 | @init { | ||
2699 | enterRule(); | ||
2700 | } | ||
2701 | @after { | ||
2702 | leaveRule(); | ||
2703 | }: | ||
2704 | ( | ||
2705 | ( | ||
2706 | ( | ||
2707 | { | ||
2708 | newCompositeNode(grammarAccess.getCallAccess().getFunctorReferenceParserRuleCall_0_0()); | ||
2709 | } | ||
2710 | lv_functor_0_0=ruleReference | ||
2711 | { | ||
2712 | if ($current==null) { | ||
2713 | $current = createModelElementForParent(grammarAccess.getCallRule()); | ||
2714 | } | ||
2715 | set( | ||
2716 | $current, | ||
2717 | "functor", | ||
2718 | lv_functor_0_0, | ||
2719 | "org.eclipse.viatra.solver.language.SolverLanguage.Reference"); | ||
2720 | afterParserOrEnumRuleCall(); | ||
2721 | } | ||
2722 | ) | ||
2723 | ) | ||
2724 | ( | ||
2725 | ( | ||
2726 | { | ||
2727 | newCompositeNode(grammarAccess.getCallAccess().getArgumentListArgumentListParserRuleCall_1_0()); | ||
2728 | } | ||
2729 | lv_argumentList_1_0=ruleArgumentList | ||
2730 | { | ||
2731 | if ($current==null) { | ||
2732 | $current = createModelElementForParent(grammarAccess.getCallRule()); | ||
2733 | } | ||
2734 | set( | ||
2735 | $current, | ||
2736 | "argumentList", | ||
2737 | lv_argumentList_1_0, | ||
2738 | "org.eclipse.viatra.solver.language.SolverLanguage.ArgumentList"); | ||
2739 | afterParserOrEnumRuleCall(); | ||
2740 | } | ||
2741 | ) | ||
2742 | ) | ||
2743 | ) | ||
2744 | ; | ||
2745 | |||
2746 | // Entry rule entryRuleArgumentList | ||
2747 | entryRuleArgumentList returns [EObject current=null]: | ||
2748 | { newCompositeNode(grammarAccess.getArgumentListRule()); } | ||
2749 | iv_ruleArgumentList=ruleArgumentList | ||
2750 | { $current=$iv_ruleArgumentList.current; } | ||
2751 | EOF; | ||
2752 | |||
2753 | // Rule ArgumentList | ||
2754 | ruleArgumentList returns [EObject current=null] | ||
2755 | @init { | ||
2756 | enterRule(); | ||
2757 | } | ||
2758 | @after { | ||
2759 | leaveRule(); | ||
2760 | }: | ||
2761 | ( | ||
2762 | ( | ||
2763 | { | ||
2764 | $current = forceCreateModelElement( | ||
2765 | grammarAccess.getArgumentListAccess().getArgumentListAction_0(), | ||
2766 | $current); | ||
2767 | } | ||
2768 | ) | ||
2769 | otherlv_1=LeftParenthesis | ||
2770 | { | ||
2771 | newLeafNode(otherlv_1, grammarAccess.getArgumentListAccess().getLeftParenthesisKeyword_1()); | ||
2772 | } | ||
2773 | ( | ||
2774 | ( | ||
2775 | ( | ||
2776 | { | ||
2777 | newCompositeNode(grammarAccess.getArgumentListAccess().getArgumentsArgumentParserRuleCall_2_0_0()); | ||
2778 | } | ||
2779 | lv_arguments_2_0=ruleArgument | ||
2780 | { | ||
2781 | if ($current==null) { | ||
2782 | $current = createModelElementForParent(grammarAccess.getArgumentListRule()); | ||
2783 | } | ||
2784 | add( | ||
2785 | $current, | ||
2786 | "arguments", | ||
2787 | lv_arguments_2_0, | ||
2788 | "org.eclipse.viatra.solver.language.SolverLanguage.Argument"); | ||
2789 | afterParserOrEnumRuleCall(); | ||
2790 | } | ||
2791 | ) | ||
2792 | ) | ||
2793 | ( | ||
2794 | otherlv_3=Comma | ||
2795 | { | ||
2796 | newLeafNode(otherlv_3, grammarAccess.getArgumentListAccess().getCommaKeyword_2_1_0()); | ||
2797 | } | ||
2798 | ( | ||
2799 | ( | ||
2800 | { | ||
2801 | newCompositeNode(grammarAccess.getArgumentListAccess().getArgumentsArgumentParserRuleCall_2_1_1_0()); | ||
2802 | } | ||
2803 | lv_arguments_4_0=ruleArgument | ||
2804 | { | ||
2805 | if ($current==null) { | ||
2806 | $current = createModelElementForParent(grammarAccess.getArgumentListRule()); | ||
2807 | } | ||
2808 | add( | ||
2809 | $current, | ||
2810 | "arguments", | ||
2811 | lv_arguments_4_0, | ||
2812 | "org.eclipse.viatra.solver.language.SolverLanguage.Argument"); | ||
2813 | afterParserOrEnumRuleCall(); | ||
2814 | } | ||
2815 | ) | ||
2816 | ) | ||
2817 | )* | ||
2818 | )? | ||
2819 | otherlv_5=RightParenthesis | ||
2820 | { | ||
2821 | newLeafNode(otherlv_5, grammarAccess.getArgumentListAccess().getRightParenthesisKeyword_3()); | ||
2822 | } | ||
2823 | ) | ||
2824 | ; | ||
2825 | |||
2826 | // Entry rule entryRuleArgument | ||
2827 | entryRuleArgument returns [EObject current=null]: | ||
2828 | { newCompositeNode(grammarAccess.getArgumentRule()); } | ||
2829 | iv_ruleArgument=ruleArgument | ||
2830 | { $current=$iv_ruleArgument.current; } | ||
2831 | EOF; | ||
2832 | |||
2833 | // Rule Argument | ||
2834 | ruleArgument returns [EObject current=null] | ||
2835 | @init { | ||
2836 | enterRule(); | ||
2837 | } | ||
2838 | @after { | ||
2839 | leaveRule(); | ||
2840 | }: | ||
2841 | ( | ||
2842 | { | ||
2843 | newCompositeNode(grammarAccess.getArgumentAccess().getExpressionArgumentParserRuleCall_0()); | ||
2844 | } | ||
2845 | this_ExpressionArgument_0=ruleExpressionArgument | ||
2846 | { | ||
2847 | $current = $this_ExpressionArgument_0.current; | ||
2848 | afterParserOrEnumRuleCall(); | ||
2849 | } | ||
2850 | | | ||
2851 | { | ||
2852 | newCompositeNode(grammarAccess.getArgumentAccess().getStarArgumentParserRuleCall_1()); | ||
2853 | } | ||
2854 | this_StarArgument_1=ruleStarArgument | ||
2855 | { | ||
2856 | $current = $this_StarArgument_1.current; | ||
2857 | afterParserOrEnumRuleCall(); | ||
2858 | } | ||
2859 | | | ||
2860 | { | ||
2861 | newCompositeNode(grammarAccess.getArgumentAccess().getTypedVariableArgumentParserRuleCall_2()); | ||
2862 | } | ||
2863 | this_TypedVariableArgument_2=ruleTypedVariableArgument | ||
2864 | { | ||
2865 | $current = $this_TypedVariableArgument_2.current; | ||
2866 | afterParserOrEnumRuleCall(); | ||
2867 | } | ||
2868 | | | ||
2869 | { | ||
2870 | newCompositeNode(grammarAccess.getArgumentAccess().getTypedStarArgumentParserRuleCall_3()); | ||
2871 | } | ||
2872 | this_TypedStarArgument_3=ruleTypedStarArgument | ||
2873 | { | ||
2874 | $current = $this_TypedStarArgument_3.current; | ||
2875 | afterParserOrEnumRuleCall(); | ||
2876 | } | ||
2877 | ) | ||
2878 | ; | ||
2879 | |||
2880 | // Entry rule entryRuleExpressionArgument | ||
2881 | entryRuleExpressionArgument returns [EObject current=null]: | ||
2882 | { newCompositeNode(grammarAccess.getExpressionArgumentRule()); } | ||
2883 | iv_ruleExpressionArgument=ruleExpressionArgument | ||
2884 | { $current=$iv_ruleExpressionArgument.current; } | ||
2885 | EOF; | ||
2886 | |||
2887 | // Rule ExpressionArgument | ||
2888 | ruleExpressionArgument returns [EObject current=null] | ||
2889 | @init { | ||
2890 | enterRule(); | ||
2891 | } | ||
2892 | @after { | ||
2893 | leaveRule(); | ||
2894 | }: | ||
2895 | ( | ||
2896 | ( | ||
2897 | { | ||
2898 | newCompositeNode(grammarAccess.getExpressionArgumentAccess().getExpressionComparisonExpressionParserRuleCall_0()); | ||
2899 | } | ||
2900 | lv_expression_0_0=ruleComparisonExpression | ||
2901 | { | ||
2902 | if ($current==null) { | ||
2903 | $current = createModelElementForParent(grammarAccess.getExpressionArgumentRule()); | ||
2904 | } | ||
2905 | set( | ||
2906 | $current, | ||
2907 | "expression", | ||
2908 | lv_expression_0_0, | ||
2909 | "org.eclipse.viatra.solver.language.SolverLanguage.ComparisonExpression"); | ||
2910 | afterParserOrEnumRuleCall(); | ||
2911 | } | ||
2912 | ) | ||
2913 | ) | ||
2914 | ; | ||
2915 | |||
2916 | // Entry rule entryRuleStarArgument | ||
2917 | entryRuleStarArgument returns [EObject current=null]: | ||
2918 | { newCompositeNode(grammarAccess.getStarArgumentRule()); } | ||
2919 | iv_ruleStarArgument=ruleStarArgument | ||
2920 | { $current=$iv_ruleStarArgument.current; } | ||
2921 | EOF; | ||
2922 | |||
2923 | // Rule StarArgument | ||
2924 | ruleStarArgument returns [EObject current=null] | ||
2925 | @init { | ||
2926 | enterRule(); | ||
2927 | } | ||
2928 | @after { | ||
2929 | leaveRule(); | ||
2930 | }: | ||
2931 | ( | ||
2932 | ( | ||
2933 | { | ||
2934 | $current = forceCreateModelElement( | ||
2935 | grammarAccess.getStarArgumentAccess().getStarArgumentAction_0(), | ||
2936 | $current); | ||
2937 | } | ||
2938 | ) | ||
2939 | otherlv_1=Asterisk | ||
2940 | { | ||
2941 | newLeafNode(otherlv_1, grammarAccess.getStarArgumentAccess().getAsteriskKeyword_1()); | ||
2942 | } | ||
2943 | ) | ||
2944 | ; | ||
2945 | |||
2946 | // Entry rule entryRuleTypedVariableArgument | ||
2947 | entryRuleTypedVariableArgument returns [EObject current=null]: | ||
2948 | { newCompositeNode(grammarAccess.getTypedVariableArgumentRule()); } | ||
2949 | iv_ruleTypedVariableArgument=ruleTypedVariableArgument | ||
2950 | { $current=$iv_ruleTypedVariableArgument.current; } | ||
2951 | EOF; | ||
2952 | |||
2953 | // Rule TypedVariableArgument | ||
2954 | ruleTypedVariableArgument returns [EObject current=null] | ||
2955 | @init { | ||
2956 | enterRule(); | ||
2957 | } | ||
2958 | @after { | ||
2959 | leaveRule(); | ||
2960 | }: | ||
2961 | ( | ||
2962 | ( | ||
2963 | ( | ||
2964 | { | ||
2965 | newCompositeNode(grammarAccess.getTypedVariableArgumentAccess().getTypeReferenceTypeReferenceParserRuleCall_0_0()); | ||
2966 | } | ||
2967 | lv_typeReference_0_0=ruleTypeReference | ||
2968 | { | ||
2969 | if ($current==null) { | ||
2970 | $current = createModelElementForParent(grammarAccess.getTypedVariableArgumentRule()); | ||
2971 | } | ||
2972 | set( | ||
2973 | $current, | ||
2974 | "typeReference", | ||
2975 | lv_typeReference_0_0, | ||
2976 | "org.eclipse.viatra.solver.language.SolverLanguage.TypeReference"); | ||
2977 | afterParserOrEnumRuleCall(); | ||
2978 | } | ||
2979 | ) | ||
2980 | ) | ||
2981 | ( | ||
2982 | ( | ||
2983 | lv_name_1_0=RULE_ID | ||
2984 | { | ||
2985 | newLeafNode(lv_name_1_0, grammarAccess.getTypedVariableArgumentAccess().getNameIDTerminalRuleCall_1_0()); | ||
2986 | } | ||
2987 | { | ||
2988 | if ($current==null) { | ||
2989 | $current = createModelElement(grammarAccess.getTypedVariableArgumentRule()); | ||
2990 | } | ||
2991 | setWithLastConsumed( | ||
2992 | $current, | ||
2993 | "name", | ||
2994 | lv_name_1_0, | ||
2995 | "org.eclipse.xtext.common.Terminals.ID"); | ||
2996 | } | ||
2997 | ) | ||
2998 | ) | ||
2999 | ) | ||
3000 | ; | ||
3001 | |||
3002 | // Entry rule entryRuleTypedStarArgument | ||
3003 | entryRuleTypedStarArgument returns [EObject current=null]: | ||
3004 | { newCompositeNode(grammarAccess.getTypedStarArgumentRule()); } | ||
3005 | iv_ruleTypedStarArgument=ruleTypedStarArgument | ||
3006 | { $current=$iv_ruleTypedStarArgument.current; } | ||
3007 | EOF; | ||
3008 | |||
3009 | // Rule TypedStarArgument | ||
3010 | ruleTypedStarArgument returns [EObject current=null] | ||
3011 | @init { | ||
3012 | enterRule(); | ||
3013 | } | ||
3014 | @after { | ||
3015 | leaveRule(); | ||
3016 | }: | ||
3017 | ( | ||
3018 | ( | ||
3019 | ( | ||
3020 | { | ||
3021 | newCompositeNode(grammarAccess.getTypedStarArgumentAccess().getTypeReferenceTypeReferenceParserRuleCall_0_0()); | ||
3022 | } | ||
3023 | lv_typeReference_0_0=ruleTypeReference | ||
3024 | { | ||
3025 | if ($current==null) { | ||
3026 | $current = createModelElementForParent(grammarAccess.getTypedStarArgumentRule()); | ||
3027 | } | ||
3028 | set( | ||
3029 | $current, | ||
3030 | "typeReference", | ||
3031 | lv_typeReference_0_0, | ||
3032 | "org.eclipse.viatra.solver.language.SolverLanguage.TypeReference"); | ||
3033 | afterParserOrEnumRuleCall(); | ||
3034 | } | ||
3035 | ) | ||
3036 | ) | ||
3037 | otherlv_1=Asterisk | ||
3038 | { | ||
3039 | newLeafNode(otherlv_1, grammarAccess.getTypedStarArgumentAccess().getAsteriskKeyword_1()); | ||
3040 | } | ||
3041 | ) | ||
3042 | ; | ||
3043 | |||
3044 | // Entry rule entryRuleReference | ||
3045 | entryRuleReference returns [EObject current=null]: | ||
3046 | { newCompositeNode(grammarAccess.getReferenceRule()); } | ||
3047 | iv_ruleReference=ruleReference | ||
3048 | { $current=$iv_ruleReference.current; } | ||
3049 | EOF; | ||
3050 | |||
3051 | // Rule Reference | ||
3052 | ruleReference returns [EObject current=null] | ||
3053 | @init { | ||
3054 | enterRule(); | ||
3055 | } | ||
3056 | @after { | ||
3057 | leaveRule(); | ||
3058 | }: | ||
3059 | ( | ||
3060 | ( | ||
3061 | ( | ||
3062 | { | ||
3063 | newCompositeNode(grammarAccess.getReferenceAccess().getComponentsPathComponentParserRuleCall_0_0()); | ||
3064 | } | ||
3065 | lv_components_0_0=rulePathComponent | ||
3066 | { | ||
3067 | if ($current==null) { | ||
3068 | $current = createModelElementForParent(grammarAccess.getReferenceRule()); | ||
3069 | } | ||
3070 | add( | ||
3071 | $current, | ||
3072 | "components", | ||
3073 | lv_components_0_0, | ||
3074 | "org.eclipse.viatra.solver.language.SolverLanguage.PathComponent"); | ||
3075 | afterParserOrEnumRuleCall(); | ||
3076 | } | ||
3077 | ) | ||
3078 | ) | ||
3079 | ( | ||
3080 | otherlv_1=FullStop | ||
3081 | { | ||
3082 | newLeafNode(otherlv_1, grammarAccess.getReferenceAccess().getFullStopKeyword_1_0()); | ||
3083 | } | ||
3084 | ( | ||
3085 | ( | ||
3086 | { | ||
3087 | newCompositeNode(grammarAccess.getReferenceAccess().getComponentsPathComponentParserRuleCall_1_1_0()); | ||
3088 | } | ||
3089 | lv_components_2_0=rulePathComponent | ||
3090 | { | ||
3091 | if ($current==null) { | ||
3092 | $current = createModelElementForParent(grammarAccess.getReferenceRule()); | ||
3093 | } | ||
3094 | add( | ||
3095 | $current, | ||
3096 | "components", | ||
3097 | lv_components_2_0, | ||
3098 | "org.eclipse.viatra.solver.language.SolverLanguage.PathComponent"); | ||
3099 | afterParserOrEnumRuleCall(); | ||
3100 | } | ||
3101 | ) | ||
3102 | ) | ||
3103 | )* | ||
3104 | ) | ||
3105 | ; | ||
3106 | |||
3107 | // Entry rule entryRulePathComponent | ||
3108 | entryRulePathComponent returns [EObject current=null]: | ||
3109 | { newCompositeNode(grammarAccess.getPathComponentRule()); } | ||
3110 | iv_rulePathComponent=rulePathComponent | ||
3111 | { $current=$iv_rulePathComponent.current; } | ||
3112 | EOF; | ||
3113 | |||
3114 | // Rule PathComponent | ||
3115 | rulePathComponent returns [EObject current=null] | ||
3116 | @init { | ||
3117 | enterRule(); | ||
3118 | } | ||
3119 | @after { | ||
3120 | leaveRule(); | ||
3121 | }: | ||
3122 | ( | ||
3123 | ( | ||
3124 | ( | ||
3125 | lv_inverse_0_0=Tilde | ||
3126 | { | ||
3127 | newLeafNode(lv_inverse_0_0, grammarAccess.getPathComponentAccess().getInverseTildeKeyword_0_0()); | ||
3128 | } | ||
3129 | { | ||
3130 | if ($current==null) { | ||
3131 | $current = createModelElement(grammarAccess.getPathComponentRule()); | ||
3132 | } | ||
3133 | setWithLastConsumed($current, "inverse", true, "~"); | ||
3134 | } | ||
3135 | ) | ||
3136 | )? | ||
3137 | ( | ||
3138 | ( | ||
3139 | { | ||
3140 | if ($current==null) { | ||
3141 | $current = createModelElement(grammarAccess.getPathComponentRule()); | ||
3142 | } | ||
3143 | } | ||
3144 | { | ||
3145 | newCompositeNode(grammarAccess.getPathComponentAccess().getSymbolSymbolCrossReference_1_0()); | ||
3146 | } | ||
3147 | ruleQualifiedName | ||
3148 | { | ||
3149 | afterParserOrEnumRuleCall(); | ||
3150 | } | ||
3151 | ) | ||
3152 | ) | ||
3153 | ( | ||
3154 | ( | ||
3155 | ( | ||
3156 | lv_transitiveClosure_2_0=RULE_TRANSITIVE_CLOSURE | ||
3157 | { | ||
3158 | newLeafNode(lv_transitiveClosure_2_0, grammarAccess.getPathComponentAccess().getTransitiveClosureTRANSITIVE_CLOSURETerminalRuleCall_2_0_0()); | ||
3159 | } | ||
3160 | { | ||
3161 | if ($current==null) { | ||
3162 | $current = createModelElement(grammarAccess.getPathComponentRule()); | ||
3163 | } | ||
3164 | setWithLastConsumed( | ||
3165 | $current, | ||
3166 | "transitiveClosure", | ||
3167 | true, | ||
3168 | "org.eclipse.viatra.solver.language.SolverLanguage.TRANSITIVE_CLOSURE"); | ||
3169 | } | ||
3170 | ) | ||
3171 | ) | ||
3172 | | | ||
3173 | ( | ||
3174 | ( | ||
3175 | lv_reflexiveTransitiveClosure_3_0=RULE_REFLEXIVE_TRANSITIVE_CLOSURE | ||
3176 | { | ||
3177 | newLeafNode(lv_reflexiveTransitiveClosure_3_0, grammarAccess.getPathComponentAccess().getReflexiveTransitiveClosureREFLEXIVE_TRANSITIVE_CLOSURETerminalRuleCall_2_1_0()); | ||
3178 | } | ||
3179 | { | ||
3180 | if ($current==null) { | ||
3181 | $current = createModelElement(grammarAccess.getPathComponentRule()); | ||
3182 | } | ||
3183 | setWithLastConsumed( | ||
3184 | $current, | ||
3185 | "reflexiveTransitiveClosure", | ||
3186 | true, | ||
3187 | "org.eclipse.viatra.solver.language.SolverLanguage.REFLEXIVE_TRANSITIVE_CLOSURE"); | ||
3188 | } | ||
3189 | ) | ||
3190 | ) | ||
3191 | )? | ||
3192 | ) | ||
3193 | ; | ||
3194 | |||
3195 | // Entry rule entryRuleInterval | ||
3196 | entryRuleInterval returns [EObject current=null]: | ||
3197 | { newCompositeNode(grammarAccess.getIntervalRule()); } | ||
3198 | iv_ruleInterval=ruleInterval | ||
3199 | { $current=$iv_ruleInterval.current; } | ||
3200 | EOF; | ||
3201 | |||
3202 | // Rule Interval | ||
3203 | ruleInterval returns [EObject current=null] | ||
3204 | @init { | ||
3205 | enterRule(); | ||
3206 | } | ||
3207 | @after { | ||
3208 | leaveRule(); | ||
3209 | }: | ||
3210 | ( | ||
3211 | otherlv_0=LeftSquareBracket | ||
3212 | { | ||
3213 | newLeafNode(otherlv_0, grammarAccess.getIntervalAccess().getLeftSquareBracketKeyword_0()); | ||
3214 | } | ||
3215 | ( | ||
3216 | ( | ||
3217 | { | ||
3218 | newCompositeNode(grammarAccess.getIntervalAccess().getLowerBoundAdditiveExpressionParserRuleCall_1_0()); | ||
3219 | } | ||
3220 | lv_lowerBound_1_0=ruleAdditiveExpression | ||
3221 | { | ||
3222 | if ($current==null) { | ||
3223 | $current = createModelElementForParent(grammarAccess.getIntervalRule()); | ||
3224 | } | ||
3225 | set( | ||
3226 | $current, | ||
3227 | "lowerBound", | ||
3228 | lv_lowerBound_1_0, | ||
3229 | "org.eclipse.viatra.solver.language.SolverLanguage.AdditiveExpression"); | ||
3230 | afterParserOrEnumRuleCall(); | ||
3231 | } | ||
3232 | ) | ||
3233 | ) | ||
3234 | otherlv_2=Comma | ||
3235 | { | ||
3236 | newLeafNode(otherlv_2, grammarAccess.getIntervalAccess().getCommaKeyword_2()); | ||
3237 | } | ||
3238 | ( | ||
3239 | ( | ||
3240 | { | ||
3241 | newCompositeNode(grammarAccess.getIntervalAccess().getUpperBoundAdditiveExpressionParserRuleCall_3_0()); | ||
3242 | } | ||
3243 | lv_upperBound_3_0=ruleAdditiveExpression | ||
3244 | { | ||
3245 | if ($current==null) { | ||
3246 | $current = createModelElementForParent(grammarAccess.getIntervalRule()); | ||
3247 | } | ||
3248 | set( | ||
3249 | $current, | ||
3250 | "upperBound", | ||
3251 | lv_upperBound_3_0, | ||
3252 | "org.eclipse.viatra.solver.language.SolverLanguage.AdditiveExpression"); | ||
3253 | afterParserOrEnumRuleCall(); | ||
3254 | } | ||
3255 | ) | ||
3256 | ) | ||
3257 | otherlv_4=RightSquareBracket | ||
3258 | { | ||
3259 | newLeafNode(otherlv_4, grammarAccess.getIntervalAccess().getRightSquareBracketKeyword_4()); | ||
3260 | } | ||
3261 | ) | ||
3262 | ; | ||
3263 | |||
3264 | // Entry rule entryRuleLiteral | ||
3265 | entryRuleLiteral returns [EObject current=null]: | ||
3266 | { newCompositeNode(grammarAccess.getLiteralRule()); } | ||
3267 | iv_ruleLiteral=ruleLiteral | ||
3268 | { $current=$iv_ruleLiteral.current; } | ||
3269 | EOF; | ||
3270 | |||
3271 | // Rule Literal | ||
3272 | ruleLiteral returns [EObject current=null] | ||
3273 | @init { | ||
3274 | enterRule(); | ||
3275 | } | ||
3276 | @after { | ||
3277 | leaveRule(); | ||
3278 | }: | ||
3279 | ( | ||
3280 | { | ||
3281 | newCompositeNode(grammarAccess.getLiteralAccess().getLogicLiteralParserRuleCall_0()); | ||
3282 | } | ||
3283 | this_LogicLiteral_0=ruleLogicLiteral | ||
3284 | { | ||
3285 | $current = $this_LogicLiteral_0.current; | ||
3286 | afterParserOrEnumRuleCall(); | ||
3287 | } | ||
3288 | | | ||
3289 | { | ||
3290 | newCompositeNode(grammarAccess.getLiteralAccess().getIntLiteralParserRuleCall_1()); | ||
3291 | } | ||
3292 | this_IntLiteral_1=ruleIntLiteral | ||
3293 | { | ||
3294 | $current = $this_IntLiteral_1.current; | ||
3295 | afterParserOrEnumRuleCall(); | ||
3296 | } | ||
3297 | | | ||
3298 | { | ||
3299 | newCompositeNode(grammarAccess.getLiteralAccess().getRealLiteralParserRuleCall_2()); | ||
3300 | } | ||
3301 | this_RealLiteral_2=ruleRealLiteral | ||
3302 | { | ||
3303 | $current = $this_RealLiteral_2.current; | ||
3304 | afterParserOrEnumRuleCall(); | ||
3305 | } | ||
3306 | | | ||
3307 | { | ||
3308 | newCompositeNode(grammarAccess.getLiteralAccess().getInfinityLiteralParserRuleCall_3()); | ||
3309 | } | ||
3310 | this_InfinityLiteral_3=ruleInfinityLiteral | ||
3311 | { | ||
3312 | $current = $this_InfinityLiteral_3.current; | ||
3313 | afterParserOrEnumRuleCall(); | ||
3314 | } | ||
3315 | | | ||
3316 | { | ||
3317 | newCompositeNode(grammarAccess.getLiteralAccess().getEmptyLiteralParserRuleCall_4()); | ||
3318 | } | ||
3319 | this_EmptyLiteral_4=ruleEmptyLiteral | ||
3320 | { | ||
3321 | $current = $this_EmptyLiteral_4.current; | ||
3322 | afterParserOrEnumRuleCall(); | ||
3323 | } | ||
3324 | | | ||
3325 | { | ||
3326 | newCompositeNode(grammarAccess.getLiteralAccess().getStringLiteralParserRuleCall_5()); | ||
3327 | } | ||
3328 | this_StringLiteral_5=ruleStringLiteral | ||
3329 | { | ||
3330 | $current = $this_StringLiteral_5.current; | ||
3331 | afterParserOrEnumRuleCall(); | ||
3332 | } | ||
3333 | ) | ||
3334 | ; | ||
3335 | |||
3336 | // Entry rule entryRuleLogicLiteral | ||
3337 | entryRuleLogicLiteral returns [EObject current=null]: | ||
3338 | { newCompositeNode(grammarAccess.getLogicLiteralRule()); } | ||
3339 | iv_ruleLogicLiteral=ruleLogicLiteral | ||
3340 | { $current=$iv_ruleLogicLiteral.current; } | ||
3341 | EOF; | ||
3342 | |||
3343 | // Rule LogicLiteral | ||
3344 | ruleLogicLiteral returns [EObject current=null] | ||
3345 | @init { | ||
3346 | enterRule(); | ||
3347 | } | ||
3348 | @after { | ||
3349 | leaveRule(); | ||
3350 | }: | ||
3351 | ( | ||
3352 | ( | ||
3353 | { | ||
3354 | newCompositeNode(grammarAccess.getLogicLiteralAccess().getValueLogicValueEnumRuleCall_0()); | ||
3355 | } | ||
3356 | lv_value_0_0=ruleLogicValue | ||
3357 | { | ||
3358 | if ($current==null) { | ||
3359 | $current = createModelElementForParent(grammarAccess.getLogicLiteralRule()); | ||
3360 | } | ||
3361 | set( | ||
3362 | $current, | ||
3363 | "value", | ||
3364 | lv_value_0_0, | ||
3365 | "org.eclipse.viatra.solver.language.SolverLanguage.LogicValue"); | ||
3366 | afterParserOrEnumRuleCall(); | ||
3367 | } | ||
3368 | ) | ||
3369 | ) | ||
3370 | ; | ||
3371 | |||
3372 | // Entry rule entryRuleIntLiteral | ||
3373 | entryRuleIntLiteral returns [EObject current=null]: | ||
3374 | { newCompositeNode(grammarAccess.getIntLiteralRule()); } | ||
3375 | iv_ruleIntLiteral=ruleIntLiteral | ||
3376 | { $current=$iv_ruleIntLiteral.current; } | ||
3377 | EOF; | ||
3378 | |||
3379 | // Rule IntLiteral | ||
3380 | ruleIntLiteral returns [EObject current=null] | ||
3381 | @init { | ||
3382 | enterRule(); | ||
3383 | } | ||
3384 | @after { | ||
3385 | leaveRule(); | ||
3386 | }: | ||
3387 | ( | ||
3388 | ( | ||
3389 | lv_value_0_0=RULE_INT | ||
3390 | { | ||
3391 | newLeafNode(lv_value_0_0, grammarAccess.getIntLiteralAccess().getValueINTTerminalRuleCall_0()); | ||
3392 | } | ||
3393 | { | ||
3394 | if ($current==null) { | ||
3395 | $current = createModelElement(grammarAccess.getIntLiteralRule()); | ||
3396 | } | ||
3397 | setWithLastConsumed( | ||
3398 | $current, | ||
3399 | "value", | ||
3400 | lv_value_0_0, | ||
3401 | "org.eclipse.xtext.common.Terminals.INT"); | ||
3402 | } | ||
3403 | ) | ||
3404 | ) | ||
3405 | ; | ||
3406 | |||
3407 | // Entry rule entryRuleRealLiteral | ||
3408 | entryRuleRealLiteral returns [EObject current=null]: | ||
3409 | { newCompositeNode(grammarAccess.getRealLiteralRule()); } | ||
3410 | iv_ruleRealLiteral=ruleRealLiteral | ||
3411 | { $current=$iv_ruleRealLiteral.current; } | ||
3412 | EOF; | ||
3413 | |||
3414 | // Rule RealLiteral | ||
3415 | ruleRealLiteral returns [EObject current=null] | ||
3416 | @init { | ||
3417 | enterRule(); | ||
3418 | } | ||
3419 | @after { | ||
3420 | leaveRule(); | ||
3421 | }: | ||
3422 | ( | ||
3423 | ( | ||
3424 | { | ||
3425 | newCompositeNode(grammarAccess.getRealLiteralAccess().getValueRealParserRuleCall_0()); | ||
3426 | } | ||
3427 | lv_value_0_0=ruleReal | ||
3428 | { | ||
3429 | if ($current==null) { | ||
3430 | $current = createModelElementForParent(grammarAccess.getRealLiteralRule()); | ||
3431 | } | ||
3432 | set( | ||
3433 | $current, | ||
3434 | "value", | ||
3435 | lv_value_0_0, | ||
3436 | "org.eclipse.viatra.solver.language.SolverLanguage.Real"); | ||
3437 | afterParserOrEnumRuleCall(); | ||
3438 | } | ||
3439 | ) | ||
3440 | ) | ||
3441 | ; | ||
3442 | |||
3443 | // Entry rule entryRuleInfinityLiteral | ||
3444 | entryRuleInfinityLiteral returns [EObject current=null]: | ||
3445 | { newCompositeNode(grammarAccess.getInfinityLiteralRule()); } | ||
3446 | iv_ruleInfinityLiteral=ruleInfinityLiteral | ||
3447 | { $current=$iv_ruleInfinityLiteral.current; } | ||
3448 | EOF; | ||
3449 | |||
3450 | // Rule InfinityLiteral | ||
3451 | ruleInfinityLiteral returns [EObject current=null] | ||
3452 | @init { | ||
3453 | enterRule(); | ||
3454 | } | ||
3455 | @after { | ||
3456 | leaveRule(); | ||
3457 | }: | ||
3458 | ( | ||
3459 | ( | ||
3460 | { | ||
3461 | $current = forceCreateModelElement( | ||
3462 | grammarAccess.getInfinityLiteralAccess().getInfinityLiteralAction_0(), | ||
3463 | $current); | ||
3464 | } | ||
3465 | ) | ||
3466 | otherlv_1=Inf | ||
3467 | { | ||
3468 | newLeafNode(otherlv_1, grammarAccess.getInfinityLiteralAccess().getInfKeyword_1()); | ||
3469 | } | ||
3470 | ) | ||
3471 | ; | ||
3472 | |||
3473 | // Entry rule entryRuleEmptyLiteral | ||
3474 | entryRuleEmptyLiteral returns [EObject current=null]: | ||
3475 | { newCompositeNode(grammarAccess.getEmptyLiteralRule()); } | ||
3476 | iv_ruleEmptyLiteral=ruleEmptyLiteral | ||
3477 | { $current=$iv_ruleEmptyLiteral.current; } | ||
3478 | EOF; | ||
3479 | |||
3480 | // Rule EmptyLiteral | ||
3481 | ruleEmptyLiteral returns [EObject current=null] | ||
3482 | @init { | ||
3483 | enterRule(); | ||
3484 | } | ||
3485 | @after { | ||
3486 | leaveRule(); | ||
3487 | }: | ||
3488 | ( | ||
3489 | ( | ||
3490 | { | ||
3491 | $current = forceCreateModelElement( | ||
3492 | grammarAccess.getEmptyLiteralAccess().getEmptyLiteralAction_0(), | ||
3493 | $current); | ||
3494 | } | ||
3495 | ) | ||
3496 | otherlv_1=Empty | ||
3497 | { | ||
3498 | newLeafNode(otherlv_1, grammarAccess.getEmptyLiteralAccess().getEmptyKeyword_1()); | ||
3499 | } | ||
3500 | ) | ||
3501 | ; | ||
3502 | |||
3503 | // Entry rule entryRuleStringLiteral | ||
3504 | entryRuleStringLiteral returns [EObject current=null]: | ||
3505 | { newCompositeNode(grammarAccess.getStringLiteralRule()); } | ||
3506 | iv_ruleStringLiteral=ruleStringLiteral | ||
3507 | { $current=$iv_ruleStringLiteral.current; } | ||
3508 | EOF; | ||
3509 | |||
3510 | // Rule StringLiteral | ||
3511 | ruleStringLiteral returns [EObject current=null] | ||
3512 | @init { | ||
3513 | enterRule(); | ||
3514 | } | ||
3515 | @after { | ||
3516 | leaveRule(); | ||
3517 | }: | ||
3518 | ( | ||
3519 | ( | ||
3520 | lv_value_0_0=RULE_STRING | ||
3521 | { | ||
3522 | newLeafNode(lv_value_0_0, grammarAccess.getStringLiteralAccess().getValueSTRINGTerminalRuleCall_0()); | ||
3523 | } | ||
3524 | { | ||
3525 | if ($current==null) { | ||
3526 | $current = createModelElement(grammarAccess.getStringLiteralRule()); | ||
3527 | } | ||
3528 | setWithLastConsumed( | ||
3529 | $current, | ||
3530 | "value", | ||
3531 | lv_value_0_0, | ||
3532 | "org.eclipse.viatra.solver.language.SolverLanguage.STRING"); | ||
3533 | } | ||
3534 | ) | ||
3535 | ) | ||
3536 | ; | ||
3537 | |||
3538 | // Entry rule entryRuleClassDeclaration | ||
3539 | entryRuleClassDeclaration returns [EObject current=null]: | ||
3540 | { newCompositeNode(grammarAccess.getClassDeclarationRule()); } | ||
3541 | iv_ruleClassDeclaration=ruleClassDeclaration | ||
3542 | { $current=$iv_ruleClassDeclaration.current; } | ||
3543 | EOF; | ||
3544 | |||
3545 | // Rule ClassDeclaration | ||
3546 | ruleClassDeclaration returns [EObject current=null] | ||
3547 | @init { | ||
3548 | enterRule(); | ||
3549 | } | ||
3550 | @after { | ||
3551 | leaveRule(); | ||
3552 | }: | ||
3553 | ( | ||
3554 | ( | ||
3555 | ( | ||
3556 | { | ||
3557 | getUnorderedGroupHelper().enter(grammarAccess.getClassDeclarationAccess().getUnorderedGroup_0()); | ||
3558 | } | ||
3559 | ( | ||
3560 | ( | ||
3561 | ( | ||
3562 | {getUnorderedGroupHelper().canSelect(grammarAccess.getClassDeclarationAccess().getUnorderedGroup_0(), 0)}?=>( | ||
3563 | { | ||
3564 | getUnorderedGroupHelper().select(grammarAccess.getClassDeclarationAccess().getUnorderedGroup_0(), 0); | ||
3565 | } | ||
3566 | ({true}?=>(( | ||
3567 | lv_abstract_1_0=Abstract | ||
3568 | { | ||
3569 | newLeafNode(lv_abstract_1_0, grammarAccess.getClassDeclarationAccess().getAbstractAbstractKeyword_0_0_0()); | ||
3570 | } | ||
3571 | { | ||
3572 | if ($current==null) { | ||
3573 | $current = createModelElement(grammarAccess.getClassDeclarationRule()); | ||
3574 | } | ||
3575 | setWithLastConsumed($current, "abstract", true, "abstract"); | ||
3576 | } | ||
3577 | ) | ||
3578 | )) | ||
3579 | { | ||
3580 | getUnorderedGroupHelper().returnFromSelection(grammarAccess.getClassDeclarationAccess().getUnorderedGroup_0()); | ||
3581 | } | ||
3582 | ) | ||
3583 | )| | ||
3584 | ( | ||
3585 | {getUnorderedGroupHelper().canSelect(grammarAccess.getClassDeclarationAccess().getUnorderedGroup_0(), 1)}?=>( | ||
3586 | { | ||
3587 | getUnorderedGroupHelper().select(grammarAccess.getClassDeclarationAccess().getUnorderedGroup_0(), 1); | ||
3588 | } | ||
3589 | ({true}?=>(( | ||
3590 | lv_root_2_0=Root | ||
3591 | { | ||
3592 | newLeafNode(lv_root_2_0, grammarAccess.getClassDeclarationAccess().getRootRootKeyword_0_1_0()); | ||
3593 | } | ||
3594 | { | ||
3595 | if ($current==null) { | ||
3596 | $current = createModelElement(grammarAccess.getClassDeclarationRule()); | ||
3597 | } | ||
3598 | setWithLastConsumed($current, "root", true, "root"); | ||
3599 | } | ||
3600 | ) | ||
3601 | )) | ||
3602 | { | ||
3603 | getUnorderedGroupHelper().returnFromSelection(grammarAccess.getClassDeclarationAccess().getUnorderedGroup_0()); | ||
3604 | } | ||
3605 | ) | ||
3606 | ) | ||
3607 | )* | ||
3608 | ) | ||
3609 | ) | ||
3610 | { | ||
3611 | getUnorderedGroupHelper().leave(grammarAccess.getClassDeclarationAccess().getUnorderedGroup_0()); | ||
3612 | } | ||
3613 | ) | ||
3614 | otherlv_3=Class | ||
3615 | { | ||
3616 | newLeafNode(otherlv_3, grammarAccess.getClassDeclarationAccess().getClassKeyword_1()); | ||
3617 | } | ||
3618 | ( | ||
3619 | ( | ||
3620 | lv_name_4_0=RULE_ID | ||
3621 | { | ||
3622 | newLeafNode(lv_name_4_0, grammarAccess.getClassDeclarationAccess().getNameIDTerminalRuleCall_2_0()); | ||
3623 | } | ||
3624 | { | ||
3625 | if ($current==null) { | ||
3626 | $current = createModelElement(grammarAccess.getClassDeclarationRule()); | ||
3627 | } | ||
3628 | setWithLastConsumed( | ||
3629 | $current, | ||
3630 | "name", | ||
3631 | lv_name_4_0, | ||
3632 | "org.eclipse.xtext.common.Terminals.ID"); | ||
3633 | } | ||
3634 | ) | ||
3635 | ) | ||
3636 | ( | ||
3637 | otherlv_5=Extends | ||
3638 | { | ||
3639 | newLeafNode(otherlv_5, grammarAccess.getClassDeclarationAccess().getExtendsKeyword_3_0()); | ||
3640 | } | ||
3641 | ( | ||
3642 | ( | ||
3643 | { | ||
3644 | if ($current==null) { | ||
3645 | $current = createModelElement(grammarAccess.getClassDeclarationRule()); | ||
3646 | } | ||
3647 | } | ||
3648 | { | ||
3649 | newCompositeNode(grammarAccess.getClassDeclarationAccess().getSupertypesSymbolCrossReference_3_1_0()); | ||
3650 | } | ||
3651 | ruleQualifiedName | ||
3652 | { | ||
3653 | afterParserOrEnumRuleCall(); | ||
3654 | } | ||
3655 | ) | ||
3656 | ) | ||
3657 | ( | ||
3658 | otherlv_7=Comma | ||
3659 | { | ||
3660 | newLeafNode(otherlv_7, grammarAccess.getClassDeclarationAccess().getCommaKeyword_3_2_0()); | ||
3661 | } | ||
3662 | ( | ||
3663 | ( | ||
3664 | { | ||
3665 | if ($current==null) { | ||
3666 | $current = createModelElement(grammarAccess.getClassDeclarationRule()); | ||
3667 | } | ||
3668 | } | ||
3669 | { | ||
3670 | newCompositeNode(grammarAccess.getClassDeclarationAccess().getSupertypesSymbolCrossReference_3_2_1_0()); | ||
3671 | } | ||
3672 | ruleQualifiedName | ||
3673 | { | ||
3674 | afterParserOrEnumRuleCall(); | ||
3675 | } | ||
3676 | ) | ||
3677 | ) | ||
3678 | )* | ||
3679 | )? | ||
3680 | ( | ||
3681 | ( | ||
3682 | otherlv_9=LeftCurlyBracket | ||
3683 | { | ||
3684 | newLeafNode(otherlv_9, grammarAccess.getClassDeclarationAccess().getLeftCurlyBracketKeyword_4_0_0()); | ||
3685 | } | ||
3686 | ( | ||
3687 | ( | ||
3688 | { | ||
3689 | newCompositeNode(grammarAccess.getClassDeclarationAccess().getFieldsFieldParserRuleCall_4_0_1_0()); | ||
3690 | } | ||
3691 | lv_fields_10_0=ruleField | ||
3692 | { | ||
3693 | if ($current==null) { | ||
3694 | $current = createModelElementForParent(grammarAccess.getClassDeclarationRule()); | ||
3695 | } | ||
3696 | add( | ||
3697 | $current, | ||
3698 | "fields", | ||
3699 | lv_fields_10_0, | ||
3700 | "org.eclipse.viatra.solver.language.SolverLanguage.Field"); | ||
3701 | afterParserOrEnumRuleCall(); | ||
3702 | } | ||
3703 | ) | ||
3704 | )* | ||
3705 | otherlv_11=RightCurlyBracket | ||
3706 | { | ||
3707 | newLeafNode(otherlv_11, grammarAccess.getClassDeclarationAccess().getRightCurlyBracketKeyword_4_0_2()); | ||
3708 | } | ||
3709 | ) | ||
3710 | | | ||
3711 | this_FULL_STOP_12=RULE_FULL_STOP | ||
3712 | { | ||
3713 | newLeafNode(this_FULL_STOP_12, grammarAccess.getClassDeclarationAccess().getFULL_STOPTerminalRuleCall_4_1()); | ||
3714 | } | ||
3715 | ) | ||
3716 | ) | ||
3717 | ; | ||
3718 | |||
3719 | // Entry rule entryRuleField | ||
3720 | entryRuleField returns [EObject current=null]: | ||
3721 | { newCompositeNode(grammarAccess.getFieldRule()); } | ||
3722 | iv_ruleField=ruleField | ||
3723 | { $current=$iv_ruleField.current; } | ||
3724 | EOF; | ||
3725 | |||
3726 | // Rule Field | ||
3727 | ruleField returns [EObject current=null] | ||
3728 | @init { | ||
3729 | enterRule(); | ||
3730 | } | ||
3731 | @after { | ||
3732 | leaveRule(); | ||
3733 | }: | ||
3734 | ( | ||
3735 | ( | ||
3736 | ( | ||
3737 | ( | ||
3738 | lv_containment_0_0=Contains | ||
3739 | { | ||
3740 | newLeafNode(lv_containment_0_0, grammarAccess.getFieldAccess().getContainmentContainsKeyword_0_0_0()); | ||
3741 | } | ||
3742 | { | ||
3743 | if ($current==null) { | ||
3744 | $current = createModelElement(grammarAccess.getFieldRule()); | ||
3745 | } | ||
3746 | setWithLastConsumed($current, "containment", true, "contains"); | ||
3747 | } | ||
3748 | ) | ||
3749 | ) | ||
3750 | | | ||
3751 | ( | ||
3752 | ( | ||
3753 | lv_crossReference_1_0=Refers | ||
3754 | { | ||
3755 | newLeafNode(lv_crossReference_1_0, grammarAccess.getFieldAccess().getCrossReferenceRefersKeyword_0_1_0()); | ||
3756 | } | ||
3757 | { | ||
3758 | if ($current==null) { | ||
3759 | $current = createModelElement(grammarAccess.getFieldRule()); | ||
3760 | } | ||
3761 | setWithLastConsumed($current, "crossReference", true, "refers"); | ||
3762 | } | ||
3763 | ) | ||
3764 | ) | ||
3765 | )? | ||
3766 | ( | ||
3767 | ( | ||
3768 | { | ||
3769 | if ($current==null) { | ||
3770 | $current = createModelElement(grammarAccess.getFieldRule()); | ||
3771 | } | ||
3772 | } | ||
3773 | { | ||
3774 | newCompositeNode(grammarAccess.getFieldAccess().getTypeSymbolCrossReference_1_0()); | ||
3775 | } | ||
3776 | ruleQualifiedName | ||
3777 | { | ||
3778 | afterParserOrEnumRuleCall(); | ||
3779 | } | ||
3780 | ) | ||
3781 | ) | ||
3782 | ( | ||
3783 | ( | ||
3784 | { | ||
3785 | newCompositeNode(grammarAccess.getFieldAccess().getMultiplicityMultiplicityParserRuleCall_2_0()); | ||
3786 | } | ||
3787 | lv_multiplicity_3_0=ruleMultiplicity | ||
3788 | { | ||
3789 | if ($current==null) { | ||
3790 | $current = createModelElementForParent(grammarAccess.getFieldRule()); | ||
3791 | } | ||
3792 | set( | ||
3793 | $current, | ||
3794 | "multiplicity", | ||
3795 | lv_multiplicity_3_0, | ||
3796 | "org.eclipse.viatra.solver.language.SolverLanguage.Multiplicity"); | ||
3797 | afterParserOrEnumRuleCall(); | ||
3798 | } | ||
3799 | ) | ||
3800 | )? | ||
3801 | ( | ||
3802 | ( | ||
3803 | lv_name_4_0=RULE_ID | ||
3804 | { | ||
3805 | newLeafNode(lv_name_4_0, grammarAccess.getFieldAccess().getNameIDTerminalRuleCall_3_0()); | ||
3806 | } | ||
3807 | { | ||
3808 | if ($current==null) { | ||
3809 | $current = createModelElement(grammarAccess.getFieldRule()); | ||
3810 | } | ||
3811 | setWithLastConsumed( | ||
3812 | $current, | ||
3813 | "name", | ||
3814 | lv_name_4_0, | ||
3815 | "org.eclipse.xtext.common.Terminals.ID"); | ||
3816 | } | ||
3817 | ) | ||
3818 | ) | ||
3819 | ( | ||
3820 | otherlv_5=Opposite | ||
3821 | { | ||
3822 | newLeafNode(otherlv_5, grammarAccess.getFieldAccess().getOppositeKeyword_4_0()); | ||
3823 | } | ||
3824 | ( | ||
3825 | ( | ||
3826 | { | ||
3827 | if ($current==null) { | ||
3828 | $current = createModelElement(grammarAccess.getFieldRule()); | ||
3829 | } | ||
3830 | } | ||
3831 | { | ||
3832 | newCompositeNode(grammarAccess.getFieldAccess().getOppositeSymbolCrossReference_4_1_0()); | ||
3833 | } | ||
3834 | ruleQualifiedName | ||
3835 | { | ||
3836 | afterParserOrEnumRuleCall(); | ||
3837 | } | ||
3838 | ) | ||
3839 | ) | ||
3840 | )? | ||
3841 | ( | ||
3842 | otherlv_7=Semicolon | ||
3843 | { | ||
3844 | newLeafNode(otherlv_7, grammarAccess.getFieldAccess().getSemicolonKeyword_5()); | ||
3845 | } | ||
3846 | )? | ||
3847 | ) | ||
3848 | ; | ||
3849 | |||
3850 | // Entry rule entryRuleMultiplicity | ||
3851 | entryRuleMultiplicity returns [EObject current=null]: | ||
3852 | { newCompositeNode(grammarAccess.getMultiplicityRule()); } | ||
3853 | iv_ruleMultiplicity=ruleMultiplicity | ||
3854 | { $current=$iv_ruleMultiplicity.current; } | ||
3855 | EOF; | ||
3856 | |||
3857 | // Rule Multiplicity | ||
3858 | ruleMultiplicity returns [EObject current=null] | ||
3859 | @init { | ||
3860 | enterRule(); | ||
3861 | } | ||
3862 | @after { | ||
3863 | leaveRule(); | ||
3864 | }: | ||
3865 | ( | ||
3866 | { | ||
3867 | newCompositeNode(grammarAccess.getMultiplicityAccess().getUnboundedMultiplicityParserRuleCall_0()); | ||
3868 | } | ||
3869 | this_UnboundedMultiplicity_0=ruleUnboundedMultiplicity | ||
3870 | { | ||
3871 | $current = $this_UnboundedMultiplicity_0.current; | ||
3872 | afterParserOrEnumRuleCall(); | ||
3873 | } | ||
3874 | | | ||
3875 | { | ||
3876 | newCompositeNode(grammarAccess.getMultiplicityAccess().getExactMultiplicityParserRuleCall_1()); | ||
3877 | } | ||
3878 | this_ExactMultiplicity_1=ruleExactMultiplicity | ||
3879 | { | ||
3880 | $current = $this_ExactMultiplicity_1.current; | ||
3881 | afterParserOrEnumRuleCall(); | ||
3882 | } | ||
3883 | | | ||
3884 | { | ||
3885 | newCompositeNode(grammarAccess.getMultiplicityAccess().getBoundedMultiplicityParserRuleCall_2()); | ||
3886 | } | ||
3887 | this_BoundedMultiplicity_2=ruleBoundedMultiplicity | ||
3888 | { | ||
3889 | $current = $this_BoundedMultiplicity_2.current; | ||
3890 | afterParserOrEnumRuleCall(); | ||
3891 | } | ||
3892 | ) | ||
3893 | ; | ||
3894 | |||
3895 | // Entry rule entryRuleUnboundedMultiplicity | ||
3896 | entryRuleUnboundedMultiplicity returns [EObject current=null]: | ||
3897 | { newCompositeNode(grammarAccess.getUnboundedMultiplicityRule()); } | ||
3898 | iv_ruleUnboundedMultiplicity=ruleUnboundedMultiplicity | ||
3899 | { $current=$iv_ruleUnboundedMultiplicity.current; } | ||
3900 | EOF; | ||
3901 | |||
3902 | // Rule UnboundedMultiplicity | ||
3903 | ruleUnboundedMultiplicity returns [EObject current=null] | ||
3904 | @init { | ||
3905 | enterRule(); | ||
3906 | } | ||
3907 | @after { | ||
3908 | leaveRule(); | ||
3909 | }: | ||
3910 | ( | ||
3911 | ( | ||
3912 | { | ||
3913 | $current = forceCreateModelElement( | ||
3914 | grammarAccess.getUnboundedMultiplicityAccess().getUnboundedMultiplicityAction_0(), | ||
3915 | $current); | ||
3916 | } | ||
3917 | ) | ||
3918 | otherlv_1=LeftSquareBracket | ||
3919 | { | ||
3920 | newLeafNode(otherlv_1, grammarAccess.getUnboundedMultiplicityAccess().getLeftSquareBracketKeyword_1()); | ||
3921 | } | ||
3922 | otherlv_2=RightSquareBracket | ||
3923 | { | ||
3924 | newLeafNode(otherlv_2, grammarAccess.getUnboundedMultiplicityAccess().getRightSquareBracketKeyword_2()); | ||
3925 | } | ||
3926 | ) | ||
3927 | ; | ||
3928 | |||
3929 | // Entry rule entryRuleExactMultiplicity | ||
3930 | entryRuleExactMultiplicity returns [EObject current=null]: | ||
3931 | { newCompositeNode(grammarAccess.getExactMultiplicityRule()); } | ||
3932 | iv_ruleExactMultiplicity=ruleExactMultiplicity | ||
3933 | { $current=$iv_ruleExactMultiplicity.current; } | ||
3934 | EOF; | ||
3935 | |||
3936 | // Rule ExactMultiplicity | ||
3937 | ruleExactMultiplicity returns [EObject current=null] | ||
3938 | @init { | ||
3939 | enterRule(); | ||
3940 | } | ||
3941 | @after { | ||
3942 | leaveRule(); | ||
3943 | }: | ||
3944 | ( | ||
3945 | otherlv_0=LeftSquareBracket | ||
3946 | { | ||
3947 | newLeafNode(otherlv_0, grammarAccess.getExactMultiplicityAccess().getLeftSquareBracketKeyword_0()); | ||
3948 | } | ||
3949 | ( | ||
3950 | ( | ||
3951 | { | ||
3952 | newCompositeNode(grammarAccess.getExactMultiplicityAccess().getValueUpperMultiplictyParserRuleCall_1_0()); | ||
3953 | } | ||
3954 | lv_value_1_0=ruleUpperMultiplicty | ||
3955 | { | ||
3956 | if ($current==null) { | ||
3957 | $current = createModelElementForParent(grammarAccess.getExactMultiplicityRule()); | ||
3958 | } | ||
3959 | set( | ||
3960 | $current, | ||
3961 | "value", | ||
3962 | lv_value_1_0, | ||
3963 | "org.eclipse.viatra.solver.language.SolverLanguage.UpperMultiplicty"); | ||
3964 | afterParserOrEnumRuleCall(); | ||
3965 | } | ||
3966 | ) | ||
3967 | ) | ||
3968 | otherlv_2=RightSquareBracket | ||
3969 | { | ||
3970 | newLeafNode(otherlv_2, grammarAccess.getExactMultiplicityAccess().getRightSquareBracketKeyword_2()); | ||
3971 | } | ||
3972 | ) | ||
3973 | ; | ||
3974 | |||
3975 | // Entry rule entryRuleBoundedMultiplicity | ||
3976 | entryRuleBoundedMultiplicity returns [EObject current=null]: | ||
3977 | { newCompositeNode(grammarAccess.getBoundedMultiplicityRule()); } | ||
3978 | iv_ruleBoundedMultiplicity=ruleBoundedMultiplicity | ||
3979 | { $current=$iv_ruleBoundedMultiplicity.current; } | ||
3980 | EOF; | ||
3981 | |||
3982 | // Rule BoundedMultiplicity | ||
3983 | ruleBoundedMultiplicity returns [EObject current=null] | ||
3984 | @init { | ||
3985 | enterRule(); | ||
3986 | } | ||
3987 | @after { | ||
3988 | leaveRule(); | ||
3989 | }: | ||
3990 | ( | ||
3991 | otherlv_0=LeftSquareBracket | ||
3992 | { | ||
3993 | newLeafNode(otherlv_0, grammarAccess.getBoundedMultiplicityAccess().getLeftSquareBracketKeyword_0()); | ||
3994 | } | ||
3995 | ( | ||
3996 | ( | ||
3997 | lv_lowerBound_1_0=RULE_INT | ||
3998 | { | ||
3999 | newLeafNode(lv_lowerBound_1_0, grammarAccess.getBoundedMultiplicityAccess().getLowerBoundINTTerminalRuleCall_1_0()); | ||
4000 | } | ||
4001 | { | ||
4002 | if ($current==null) { | ||
4003 | $current = createModelElement(grammarAccess.getBoundedMultiplicityRule()); | ||
4004 | } | ||
4005 | setWithLastConsumed( | ||
4006 | $current, | ||
4007 | "lowerBound", | ||
4008 | lv_lowerBound_1_0, | ||
4009 | "org.eclipse.xtext.common.Terminals.INT"); | ||
4010 | } | ||
4011 | ) | ||
4012 | ) | ||
4013 | otherlv_2=Comma | ||
4014 | { | ||
4015 | newLeafNode(otherlv_2, grammarAccess.getBoundedMultiplicityAccess().getCommaKeyword_2()); | ||
4016 | } | ||
4017 | ( | ||
4018 | ( | ||
4019 | { | ||
4020 | newCompositeNode(grammarAccess.getBoundedMultiplicityAccess().getUpperBoundUpperMultiplictyParserRuleCall_3_0()); | ||
4021 | } | ||
4022 | lv_upperBound_3_0=ruleUpperMultiplicty | ||
4023 | { | ||
4024 | if ($current==null) { | ||
4025 | $current = createModelElementForParent(grammarAccess.getBoundedMultiplicityRule()); | ||
4026 | } | ||
4027 | set( | ||
4028 | $current, | ||
4029 | "upperBound", | ||
4030 | lv_upperBound_3_0, | ||
4031 | "org.eclipse.viatra.solver.language.SolverLanguage.UpperMultiplicty"); | ||
4032 | afterParserOrEnumRuleCall(); | ||
4033 | } | ||
4034 | ) | ||
4035 | ) | ||
4036 | otherlv_4=RightSquareBracket | ||
4037 | { | ||
4038 | newLeafNode(otherlv_4, grammarAccess.getBoundedMultiplicityAccess().getRightSquareBracketKeyword_4()); | ||
4039 | } | ||
4040 | ) | ||
4041 | ; | ||
4042 | |||
4043 | // Entry rule entryRuleEnumDeclaration | ||
4044 | entryRuleEnumDeclaration returns [EObject current=null]: | ||
4045 | { newCompositeNode(grammarAccess.getEnumDeclarationRule()); } | ||
4046 | iv_ruleEnumDeclaration=ruleEnumDeclaration | ||
4047 | { $current=$iv_ruleEnumDeclaration.current; } | ||
4048 | EOF; | ||
4049 | |||
4050 | // Rule EnumDeclaration | ||
4051 | ruleEnumDeclaration returns [EObject current=null] | ||
4052 | @init { | ||
4053 | enterRule(); | ||
4054 | } | ||
4055 | @after { | ||
4056 | leaveRule(); | ||
4057 | }: | ||
4058 | ( | ||
4059 | otherlv_0=Enum | ||
4060 | { | ||
4061 | newLeafNode(otherlv_0, grammarAccess.getEnumDeclarationAccess().getEnumKeyword_0()); | ||
4062 | } | ||
4063 | ( | ||
4064 | ( | ||
4065 | lv_name_1_0=RULE_ID | ||
4066 | { | ||
4067 | newLeafNode(lv_name_1_0, grammarAccess.getEnumDeclarationAccess().getNameIDTerminalRuleCall_1_0()); | ||
4068 | } | ||
4069 | { | ||
4070 | if ($current==null) { | ||
4071 | $current = createModelElement(grammarAccess.getEnumDeclarationRule()); | ||
4072 | } | ||
4073 | setWithLastConsumed( | ||
4074 | $current, | ||
4075 | "name", | ||
4076 | lv_name_1_0, | ||
4077 | "org.eclipse.xtext.common.Terminals.ID"); | ||
4078 | } | ||
4079 | ) | ||
4080 | ) | ||
4081 | ( | ||
4082 | ( | ||
4083 | otherlv_2=LeftCurlyBracket | ||
4084 | { | ||
4085 | newLeafNode(otherlv_2, grammarAccess.getEnumDeclarationAccess().getLeftCurlyBracketKeyword_2_0_0()); | ||
4086 | } | ||
4087 | ( | ||
4088 | ( | ||
4089 | ( | ||
4090 | { | ||
4091 | newCompositeNode(grammarAccess.getEnumDeclarationAccess().getLiteralsEnumLiteralParserRuleCall_2_0_1_0_0()); | ||
4092 | } | ||
4093 | lv_literals_3_0=ruleEnumLiteral | ||
4094 | { | ||
4095 | if ($current==null) { | ||
4096 | $current = createModelElementForParent(grammarAccess.getEnumDeclarationRule()); | ||
4097 | } | ||
4098 | add( | ||
4099 | $current, | ||
4100 | "literals", | ||
4101 | lv_literals_3_0, | ||
4102 | "org.eclipse.viatra.solver.language.SolverLanguage.EnumLiteral"); | ||
4103 | afterParserOrEnumRuleCall(); | ||
4104 | } | ||
4105 | ) | ||
4106 | ) | ||
4107 | ( | ||
4108 | ( | ||
4109 | otherlv_4=Comma | ||
4110 | { | ||
4111 | newLeafNode(otherlv_4, grammarAccess.getEnumDeclarationAccess().getCommaKeyword_2_0_1_1_0()); | ||
4112 | } | ||
4113 | )? | ||
4114 | ( | ||
4115 | ( | ||
4116 | { | ||
4117 | newCompositeNode(grammarAccess.getEnumDeclarationAccess().getLiteralsEnumLiteralParserRuleCall_2_0_1_1_1_0()); | ||
4118 | } | ||
4119 | lv_literals_5_0=ruleEnumLiteral | ||
4120 | { | ||
4121 | if ($current==null) { | ||
4122 | $current = createModelElementForParent(grammarAccess.getEnumDeclarationRule()); | ||
4123 | } | ||
4124 | add( | ||
4125 | $current, | ||
4126 | "literals", | ||
4127 | lv_literals_5_0, | ||
4128 | "org.eclipse.viatra.solver.language.SolverLanguage.EnumLiteral"); | ||
4129 | afterParserOrEnumRuleCall(); | ||
4130 | } | ||
4131 | ) | ||
4132 | ) | ||
4133 | )* | ||
4134 | )? | ||
4135 | otherlv_6=RightCurlyBracket | ||
4136 | { | ||
4137 | newLeafNode(otherlv_6, grammarAccess.getEnumDeclarationAccess().getRightCurlyBracketKeyword_2_0_2()); | ||
4138 | } | ||
4139 | ) | ||
4140 | | | ||
4141 | this_FULL_STOP_7=RULE_FULL_STOP | ||
4142 | { | ||
4143 | newLeafNode(this_FULL_STOP_7, grammarAccess.getEnumDeclarationAccess().getFULL_STOPTerminalRuleCall_2_1()); | ||
4144 | } | ||
4145 | ) | ||
4146 | ) | ||
4147 | ; | ||
4148 | |||
4149 | // Entry rule entryRuleEnumLiteral | ||
4150 | entryRuleEnumLiteral returns [EObject current=null]: | ||
4151 | { newCompositeNode(grammarAccess.getEnumLiteralRule()); } | ||
4152 | iv_ruleEnumLiteral=ruleEnumLiteral | ||
4153 | { $current=$iv_ruleEnumLiteral.current; } | ||
4154 | EOF; | ||
4155 | |||
4156 | // Rule EnumLiteral | ||
4157 | ruleEnumLiteral returns [EObject current=null] | ||
4158 | @init { | ||
4159 | enterRule(); | ||
4160 | } | ||
4161 | @after { | ||
4162 | leaveRule(); | ||
4163 | }: | ||
4164 | ( | ||
4165 | ( | ||
4166 | lv_name_0_0=RULE_ID | ||
4167 | { | ||
4168 | newLeafNode(lv_name_0_0, grammarAccess.getEnumLiteralAccess().getNameIDTerminalRuleCall_0()); | ||
4169 | } | ||
4170 | { | ||
4171 | if ($current==null) { | ||
4172 | $current = createModelElement(grammarAccess.getEnumLiteralRule()); | ||
4173 | } | ||
4174 | setWithLastConsumed( | ||
4175 | $current, | ||
4176 | "name", | ||
4177 | lv_name_0_0, | ||
4178 | "org.eclipse.xtext.common.Terminals.ID"); | ||
4179 | } | ||
4180 | ) | ||
4181 | ) | ||
4182 | ; | ||
4183 | |||
4184 | // Entry rule entryRuleScopeDeclaration | ||
4185 | entryRuleScopeDeclaration returns [EObject current=null]: | ||
4186 | { newCompositeNode(grammarAccess.getScopeDeclarationRule()); } | ||
4187 | iv_ruleScopeDeclaration=ruleScopeDeclaration | ||
4188 | { $current=$iv_ruleScopeDeclaration.current; } | ||
4189 | EOF; | ||
4190 | |||
4191 | // Rule ScopeDeclaration | ||
4192 | ruleScopeDeclaration returns [EObject current=null] | ||
4193 | @init { | ||
4194 | enterRule(); | ||
4195 | } | ||
4196 | @after { | ||
4197 | leaveRule(); | ||
4198 | }: | ||
4199 | ( | ||
4200 | { | ||
4201 | newCompositeNode(grammarAccess.getScopeDeclarationAccess().getExactScopeParserRuleCall_0()); | ||
4202 | } | ||
4203 | this_ExactScope_0=ruleExactScope | ||
4204 | { | ||
4205 | $current = $this_ExactScope_0.current; | ||
4206 | afterParserOrEnumRuleCall(); | ||
4207 | } | ||
4208 | | | ||
4209 | { | ||
4210 | newCompositeNode(grammarAccess.getScopeDeclarationAccess().getBoundedScopeParserRuleCall_1()); | ||
4211 | } | ||
4212 | this_BoundedScope_1=ruleBoundedScope | ||
4213 | { | ||
4214 | $current = $this_BoundedScope_1.current; | ||
4215 | afterParserOrEnumRuleCall(); | ||
4216 | } | ||
4217 | | | ||
4218 | { | ||
4219 | newCompositeNode(grammarAccess.getScopeDeclarationAccess().getLowerBoundedScopeParserRuleCall_2()); | ||
4220 | } | ||
4221 | this_LowerBoundedScope_2=ruleLowerBoundedScope | ||
4222 | { | ||
4223 | $current = $this_LowerBoundedScope_2.current; | ||
4224 | afterParserOrEnumRuleCall(); | ||
4225 | } | ||
4226 | ) | ||
4227 | ; | ||
4228 | |||
4229 | // Entry rule entryRuleExactScope | ||
4230 | entryRuleExactScope returns [EObject current=null]: | ||
4231 | { newCompositeNode(grammarAccess.getExactScopeRule()); } | ||
4232 | iv_ruleExactScope=ruleExactScope | ||
4233 | { $current=$iv_ruleExactScope.current; } | ||
4234 | EOF; | ||
4235 | |||
4236 | // Rule ExactScope | ||
4237 | ruleExactScope returns [EObject current=null] | ||
4238 | @init { | ||
4239 | enterRule(); | ||
4240 | } | ||
4241 | @after { | ||
4242 | leaveRule(); | ||
4243 | }: | ||
4244 | ( | ||
4245 | otherlv_0=Scope | ||
4246 | { | ||
4247 | newLeafNode(otherlv_0, grammarAccess.getExactScopeAccess().getScopeKeyword_0()); | ||
4248 | } | ||
4249 | ( | ||
4250 | ( | ||
4251 | { | ||
4252 | if ($current==null) { | ||
4253 | $current = createModelElement(grammarAccess.getExactScopeRule()); | ||
4254 | } | ||
4255 | } | ||
4256 | { | ||
4257 | newCompositeNode(grammarAccess.getExactScopeAccess().getTypeSymbolCrossReference_1_0()); | ||
4258 | } | ||
4259 | ruleQualifiedName | ||
4260 | { | ||
4261 | afterParserOrEnumRuleCall(); | ||
4262 | } | ||
4263 | ) | ||
4264 | ) | ||
4265 | otherlv_2=EqualsSignEqualsSign | ||
4266 | { | ||
4267 | newLeafNode(otherlv_2, grammarAccess.getExactScopeAccess().getEqualsSignEqualsSignKeyword_2()); | ||
4268 | } | ||
4269 | ( | ||
4270 | ( | ||
4271 | lv_size_3_0=RULE_INT | ||
4272 | { | ||
4273 | newLeafNode(lv_size_3_0, grammarAccess.getExactScopeAccess().getSizeINTTerminalRuleCall_3_0()); | ||
4274 | } | ||
4275 | { | ||
4276 | if ($current==null) { | ||
4277 | $current = createModelElement(grammarAccess.getExactScopeRule()); | ||
4278 | } | ||
4279 | setWithLastConsumed( | ||
4280 | $current, | ||
4281 | "size", | ||
4282 | lv_size_3_0, | ||
4283 | "org.eclipse.xtext.common.Terminals.INT"); | ||
4284 | } | ||
4285 | ) | ||
4286 | ) | ||
4287 | this_FULL_STOP_4=RULE_FULL_STOP | ||
4288 | { | ||
4289 | newLeafNode(this_FULL_STOP_4, grammarAccess.getExactScopeAccess().getFULL_STOPTerminalRuleCall_4()); | ||
4290 | } | ||
4291 | ) | ||
4292 | ; | ||
4293 | |||
4294 | // Entry rule entryRuleBoundedScope | ||
4295 | entryRuleBoundedScope returns [EObject current=null]: | ||
4296 | { newCompositeNode(grammarAccess.getBoundedScopeRule()); } | ||
4297 | iv_ruleBoundedScope=ruleBoundedScope | ||
4298 | { $current=$iv_ruleBoundedScope.current; } | ||
4299 | EOF; | ||
4300 | |||
4301 | // Rule BoundedScope | ||
4302 | ruleBoundedScope returns [EObject current=null] | ||
4303 | @init { | ||
4304 | enterRule(); | ||
4305 | } | ||
4306 | @after { | ||
4307 | leaveRule(); | ||
4308 | }: | ||
4309 | ( | ||
4310 | otherlv_0=Scope | ||
4311 | { | ||
4312 | newLeafNode(otherlv_0, grammarAccess.getBoundedScopeAccess().getScopeKeyword_0()); | ||
4313 | } | ||
4314 | ( | ||
4315 | ( | ||
4316 | ( | ||
4317 | ( | ||
4318 | ( | ||
4319 | lv_lowerBound_1_0=RULE_INT | ||
4320 | { | ||
4321 | newLeafNode(lv_lowerBound_1_0, grammarAccess.getBoundedScopeAccess().getLowerBoundINTTerminalRuleCall_1_0_0_0_0()); | ||
4322 | } | ||
4323 | { | ||
4324 | if ($current==null) { | ||
4325 | $current = createModelElement(grammarAccess.getBoundedScopeRule()); | ||
4326 | } | ||
4327 | setWithLastConsumed( | ||
4328 | $current, | ||
4329 | "lowerBound", | ||
4330 | lv_lowerBound_1_0, | ||
4331 | "org.eclipse.xtext.common.Terminals.INT"); | ||
4332 | } | ||
4333 | ) | ||
4334 | ) | ||
4335 | otherlv_2=LessThanSignEqualsSign | ||
4336 | { | ||
4337 | newLeafNode(otherlv_2, grammarAccess.getBoundedScopeAccess().getLessThanSignEqualsSignKeyword_1_0_0_1()); | ||
4338 | } | ||
4339 | )? | ||
4340 | ( | ||
4341 | ( | ||
4342 | { | ||
4343 | if ($current==null) { | ||
4344 | $current = createModelElement(grammarAccess.getBoundedScopeRule()); | ||
4345 | } | ||
4346 | } | ||
4347 | { | ||
4348 | newCompositeNode(grammarAccess.getBoundedScopeAccess().getTypeSymbolCrossReference_1_0_1_0()); | ||
4349 | } | ||
4350 | ruleQualifiedName | ||
4351 | { | ||
4352 | afterParserOrEnumRuleCall(); | ||
4353 | } | ||
4354 | ) | ||
4355 | ) | ||
4356 | otherlv_4=LessThanSignEqualsSign | ||
4357 | { | ||
4358 | newLeafNode(otherlv_4, grammarAccess.getBoundedScopeAccess().getLessThanSignEqualsSignKeyword_1_0_2()); | ||
4359 | } | ||
4360 | ( | ||
4361 | ( | ||
4362 | lv_upperBound_5_0=RULE_INT | ||
4363 | { | ||
4364 | newLeafNode(lv_upperBound_5_0, grammarAccess.getBoundedScopeAccess().getUpperBoundINTTerminalRuleCall_1_0_3_0()); | ||
4365 | } | ||
4366 | { | ||
4367 | if ($current==null) { | ||
4368 | $current = createModelElement(grammarAccess.getBoundedScopeRule()); | ||
4369 | } | ||
4370 | setWithLastConsumed( | ||
4371 | $current, | ||
4372 | "upperBound", | ||
4373 | lv_upperBound_5_0, | ||
4374 | "org.eclipse.xtext.common.Terminals.INT"); | ||
4375 | } | ||
4376 | ) | ||
4377 | ) | ||
4378 | ) | ||
4379 | | | ||
4380 | ( | ||
4381 | ( | ||
4382 | ( | ||
4383 | lv_upperBound_6_0=RULE_INT | ||
4384 | { | ||
4385 | newLeafNode(lv_upperBound_6_0, grammarAccess.getBoundedScopeAccess().getUpperBoundINTTerminalRuleCall_1_1_0_0()); | ||
4386 | } | ||
4387 | { | ||
4388 | if ($current==null) { | ||
4389 | $current = createModelElement(grammarAccess.getBoundedScopeRule()); | ||
4390 | } | ||
4391 | setWithLastConsumed( | ||
4392 | $current, | ||
4393 | "upperBound", | ||
4394 | lv_upperBound_6_0, | ||
4395 | "org.eclipse.xtext.common.Terminals.INT"); | ||
4396 | } | ||
4397 | ) | ||
4398 | ) | ||
4399 | otherlv_7=GreaterThanSignEqualsSign | ||
4400 | { | ||
4401 | newLeafNode(otherlv_7, grammarAccess.getBoundedScopeAccess().getGreaterThanSignEqualsSignKeyword_1_1_1()); | ||
4402 | } | ||
4403 | ( | ||
4404 | ( | ||
4405 | { | ||
4406 | if ($current==null) { | ||
4407 | $current = createModelElement(grammarAccess.getBoundedScopeRule()); | ||
4408 | } | ||
4409 | } | ||
4410 | { | ||
4411 | newCompositeNode(grammarAccess.getBoundedScopeAccess().getTypeSymbolCrossReference_1_1_2_0()); | ||
4412 | } | ||
4413 | ruleQualifiedName | ||
4414 | { | ||
4415 | afterParserOrEnumRuleCall(); | ||
4416 | } | ||
4417 | ) | ||
4418 | ) | ||
4419 | ( | ||
4420 | otherlv_9=GreaterThanSignEqualsSign | ||
4421 | { | ||
4422 | newLeafNode(otherlv_9, grammarAccess.getBoundedScopeAccess().getGreaterThanSignEqualsSignKeyword_1_1_3_0()); | ||
4423 | } | ||
4424 | ( | ||
4425 | ( | ||
4426 | lv_lowerBound_10_0=RULE_INT | ||
4427 | { | ||
4428 | newLeafNode(lv_lowerBound_10_0, grammarAccess.getBoundedScopeAccess().getLowerBoundINTTerminalRuleCall_1_1_3_1_0()); | ||
4429 | } | ||
4430 | { | ||
4431 | if ($current==null) { | ||
4432 | $current = createModelElement(grammarAccess.getBoundedScopeRule()); | ||
4433 | } | ||
4434 | setWithLastConsumed( | ||
4435 | $current, | ||
4436 | "lowerBound", | ||
4437 | lv_lowerBound_10_0, | ||
4438 | "org.eclipse.xtext.common.Terminals.INT"); | ||
4439 | } | ||
4440 | ) | ||
4441 | ) | ||
4442 | )? | ||
4443 | ) | ||
4444 | ) | ||
4445 | this_FULL_STOP_11=RULE_FULL_STOP | ||
4446 | { | ||
4447 | newLeafNode(this_FULL_STOP_11, grammarAccess.getBoundedScopeAccess().getFULL_STOPTerminalRuleCall_2()); | ||
4448 | } | ||
4449 | ) | ||
4450 | ; | ||
4451 | |||
4452 | // Entry rule entryRuleLowerBoundedScope | ||
4453 | entryRuleLowerBoundedScope returns [EObject current=null]: | ||
4454 | { newCompositeNode(grammarAccess.getLowerBoundedScopeRule()); } | ||
4455 | iv_ruleLowerBoundedScope=ruleLowerBoundedScope | ||
4456 | { $current=$iv_ruleLowerBoundedScope.current; } | ||
4457 | EOF; | ||
4458 | |||
4459 | // Rule LowerBoundedScope | ||
4460 | ruleLowerBoundedScope returns [EObject current=null] | ||
4461 | @init { | ||
4462 | enterRule(); | ||
4463 | } | ||
4464 | @after { | ||
4465 | leaveRule(); | ||
4466 | }: | ||
4467 | ( | ||
4468 | otherlv_0=Scope | ||
4469 | { | ||
4470 | newLeafNode(otherlv_0, grammarAccess.getLowerBoundedScopeAccess().getScopeKeyword_0()); | ||
4471 | } | ||
4472 | ( | ||
4473 | ( | ||
4474 | ( | ||
4475 | ( | ||
4476 | lv_lowerBound_1_0=RULE_INT | ||
4477 | { | ||
4478 | newLeafNode(lv_lowerBound_1_0, grammarAccess.getLowerBoundedScopeAccess().getLowerBoundINTTerminalRuleCall_1_0_0_0()); | ||
4479 | } | ||
4480 | { | ||
4481 | if ($current==null) { | ||
4482 | $current = createModelElement(grammarAccess.getLowerBoundedScopeRule()); | ||
4483 | } | ||
4484 | setWithLastConsumed( | ||
4485 | $current, | ||
4486 | "lowerBound", | ||
4487 | lv_lowerBound_1_0, | ||
4488 | "org.eclipse.xtext.common.Terminals.INT"); | ||
4489 | } | ||
4490 | ) | ||
4491 | ) | ||
4492 | otherlv_2=LessThanSignEqualsSign | ||
4493 | { | ||
4494 | newLeafNode(otherlv_2, grammarAccess.getLowerBoundedScopeAccess().getLessThanSignEqualsSignKeyword_1_0_1()); | ||
4495 | } | ||
4496 | ( | ||
4497 | ( | ||
4498 | { | ||
4499 | if ($current==null) { | ||
4500 | $current = createModelElement(grammarAccess.getLowerBoundedScopeRule()); | ||
4501 | } | ||
4502 | } | ||
4503 | { | ||
4504 | newCompositeNode(grammarAccess.getLowerBoundedScopeAccess().getTypeSymbolCrossReference_1_0_2_0()); | ||
4505 | } | ||
4506 | ruleQualifiedName | ||
4507 | { | ||
4508 | afterParserOrEnumRuleCall(); | ||
4509 | } | ||
4510 | ) | ||
4511 | ) | ||
4512 | ) | ||
4513 | | | ||
4514 | ( | ||
4515 | ( | ||
4516 | ( | ||
4517 | { | ||
4518 | if ($current==null) { | ||
4519 | $current = createModelElement(grammarAccess.getLowerBoundedScopeRule()); | ||
4520 | } | ||
4521 | } | ||
4522 | { | ||
4523 | newCompositeNode(grammarAccess.getLowerBoundedScopeAccess().getTypeSymbolCrossReference_1_1_0_0()); | ||
4524 | } | ||
4525 | ruleQualifiedName | ||
4526 | { | ||
4527 | afterParserOrEnumRuleCall(); | ||
4528 | } | ||
4529 | ) | ||
4530 | ) | ||
4531 | otherlv_5=GreaterThanSignEqualsSign | ||
4532 | { | ||
4533 | newLeafNode(otherlv_5, grammarAccess.getLowerBoundedScopeAccess().getGreaterThanSignEqualsSignKeyword_1_1_1()); | ||
4534 | } | ||
4535 | ( | ||
4536 | ( | ||
4537 | lv_lowerBound_6_0=RULE_INT | ||
4538 | { | ||
4539 | newLeafNode(lv_lowerBound_6_0, grammarAccess.getLowerBoundedScopeAccess().getLowerBoundINTTerminalRuleCall_1_1_2_0()); | ||
4540 | } | ||
4541 | { | ||
4542 | if ($current==null) { | ||
4543 | $current = createModelElement(grammarAccess.getLowerBoundedScopeRule()); | ||
4544 | } | ||
4545 | setWithLastConsumed( | ||
4546 | $current, | ||
4547 | "lowerBound", | ||
4548 | lv_lowerBound_6_0, | ||
4549 | "org.eclipse.xtext.common.Terminals.INT"); | ||
4550 | } | ||
4551 | ) | ||
4552 | ) | ||
4553 | ) | ||
4554 | ) | ||
4555 | this_FULL_STOP_7=RULE_FULL_STOP | ||
4556 | { | ||
4557 | newLeafNode(this_FULL_STOP_7, grammarAccess.getLowerBoundedScopeAccess().getFULL_STOPTerminalRuleCall_2()); | ||
4558 | } | ||
4559 | ) | ||
4560 | ; | ||
4561 | |||
4562 | // Entry rule entryRuleObjectiveDeclaration | ||
4563 | entryRuleObjectiveDeclaration returns [EObject current=null]: | ||
4564 | { newCompositeNode(grammarAccess.getObjectiveDeclarationRule()); } | ||
4565 | iv_ruleObjectiveDeclaration=ruleObjectiveDeclaration | ||
4566 | { $current=$iv_ruleObjectiveDeclaration.current; } | ||
4567 | EOF; | ||
4568 | |||
4569 | // Rule ObjectiveDeclaration | ||
4570 | ruleObjectiveDeclaration returns [EObject current=null] | ||
4571 | @init { | ||
4572 | enterRule(); | ||
4573 | } | ||
4574 | @after { | ||
4575 | leaveRule(); | ||
4576 | }: | ||
4577 | ( | ||
4578 | ( | ||
4579 | ( | ||
4580 | { | ||
4581 | newCompositeNode(grammarAccess.getObjectiveDeclarationAccess().getKindObjectiveKindEnumRuleCall_0_0()); | ||
4582 | } | ||
4583 | lv_kind_0_0=ruleObjectiveKind | ||
4584 | { | ||
4585 | if ($current==null) { | ||
4586 | $current = createModelElementForParent(grammarAccess.getObjectiveDeclarationRule()); | ||
4587 | } | ||
4588 | set( | ||
4589 | $current, | ||
4590 | "kind", | ||
4591 | lv_kind_0_0, | ||
4592 | "org.eclipse.viatra.solver.language.SolverLanguage.ObjectiveKind"); | ||
4593 | afterParserOrEnumRuleCall(); | ||
4594 | } | ||
4595 | ) | ||
4596 | ) | ||
4597 | ( | ||
4598 | ( | ||
4599 | { | ||
4600 | newCompositeNode(grammarAccess.getObjectiveDeclarationAccess().getObjectiveExpressionParserRuleCall_1_0()); | ||
4601 | } | ||
4602 | lv_objective_1_0=ruleExpression | ||
4603 | { | ||
4604 | if ($current==null) { | ||
4605 | $current = createModelElementForParent(grammarAccess.getObjectiveDeclarationRule()); | ||
4606 | } | ||
4607 | set( | ||
4608 | $current, | ||
4609 | "objective", | ||
4610 | lv_objective_1_0, | ||
4611 | "org.eclipse.viatra.solver.language.SolverLanguage.Expression"); | ||
4612 | afterParserOrEnumRuleCall(); | ||
4613 | } | ||
4614 | ) | ||
4615 | ) | ||
4616 | this_FULL_STOP_2=RULE_FULL_STOP | ||
4617 | { | ||
4618 | newLeafNode(this_FULL_STOP_2, grammarAccess.getObjectiveDeclarationAccess().getFULL_STOPTerminalRuleCall_2()); | ||
4619 | } | ||
4620 | ) | ||
4621 | ; | ||
4622 | |||
4623 | // Entry rule entryRuleUpperMultiplicty | ||
4624 | entryRuleUpperMultiplicty returns [String current=null]: | ||
4625 | { newCompositeNode(grammarAccess.getUpperMultiplictyRule()); } | ||
4626 | iv_ruleUpperMultiplicty=ruleUpperMultiplicty | ||
4627 | { $current=$iv_ruleUpperMultiplicty.current.getText(); } | ||
4628 | EOF; | ||
4629 | |||
4630 | // Rule UpperMultiplicty | ||
4631 | ruleUpperMultiplicty returns [AntlrDatatypeRuleToken current=new AntlrDatatypeRuleToken()] | ||
4632 | @init { | ||
4633 | enterRule(); | ||
4634 | } | ||
4635 | @after { | ||
4636 | leaveRule(); | ||
4637 | }: | ||
4638 | ( | ||
4639 | this_INT_0=RULE_INT | ||
4640 | { | ||
4641 | $current.merge(this_INT_0); | ||
4642 | } | ||
4643 | { | ||
4644 | newLeafNode(this_INT_0, grammarAccess.getUpperMultiplictyAccess().getINTTerminalRuleCall_0()); | ||
4645 | } | ||
4646 | | | ||
4647 | kw=Asterisk | ||
4648 | { | ||
4649 | $current.merge(kw); | ||
4650 | newLeafNode(kw, grammarAccess.getUpperMultiplictyAccess().getAsteriskKeyword_1()); | ||
4651 | } | ||
4652 | ) | ||
4653 | ; | ||
4654 | |||
4655 | // Entry rule entryRuleReal | ||
4656 | entryRuleReal returns [String current=null]@init { | ||
4657 | HiddenTokens myHiddenTokenState = ((XtextTokenStream)input).setHiddenTokens(); | ||
4658 | }: | ||
4659 | { newCompositeNode(grammarAccess.getRealRule()); } | ||
4660 | iv_ruleReal=ruleReal | ||
4661 | { $current=$iv_ruleReal.current.getText(); } | ||
4662 | EOF; | ||
4663 | finally { | ||
4664 | myHiddenTokenState.restore(); | ||
4665 | } | ||
4666 | |||
4667 | // Rule Real | ||
4668 | ruleReal returns [AntlrDatatypeRuleToken current=new AntlrDatatypeRuleToken()] | ||
4669 | @init { | ||
4670 | enterRule(); | ||
4671 | HiddenTokens myHiddenTokenState = ((XtextTokenStream)input).setHiddenTokens(); | ||
4672 | } | ||
4673 | @after { | ||
4674 | leaveRule(); | ||
4675 | }: | ||
4676 | ( | ||
4677 | this_INT_0=RULE_INT | ||
4678 | { | ||
4679 | $current.merge(this_INT_0); | ||
4680 | } | ||
4681 | { | ||
4682 | newLeafNode(this_INT_0, grammarAccess.getRealAccess().getINTTerminalRuleCall_0()); | ||
4683 | } | ||
4684 | kw=FullStop | ||
4685 | { | ||
4686 | $current.merge(kw); | ||
4687 | newLeafNode(kw, grammarAccess.getRealAccess().getFullStopKeyword_1()); | ||
4688 | } | ||
4689 | this_INT_2=RULE_INT | ||
4690 | { | ||
4691 | $current.merge(this_INT_2); | ||
4692 | } | ||
4693 | { | ||
4694 | newLeafNode(this_INT_2, grammarAccess.getRealAccess().getINTTerminalRuleCall_2()); | ||
4695 | } | ||
4696 | ) | ||
4697 | ; | ||
4698 | finally { | ||
4699 | myHiddenTokenState.restore(); | ||
4700 | } | ||
4701 | |||
4702 | // Entry rule entryRuleQualifiedNameSegment | ||
4703 | entryRuleQualifiedNameSegment returns [String current=null]: | ||
4704 | { newCompositeNode(grammarAccess.getQualifiedNameSegmentRule()); } | ||
4705 | iv_ruleQualifiedNameSegment=ruleQualifiedNameSegment | ||
4706 | { $current=$iv_ruleQualifiedNameSegment.current.getText(); } | ||
4707 | EOF; | ||
4708 | |||
4709 | // Rule QualifiedNameSegment | ||
4710 | ruleQualifiedNameSegment returns [AntlrDatatypeRuleToken current=new AntlrDatatypeRuleToken()] | ||
4711 | @init { | ||
4712 | enterRule(); | ||
4713 | } | ||
4714 | @after { | ||
4715 | leaveRule(); | ||
4716 | }: | ||
4717 | ( | ||
4718 | this_ID_0=RULE_ID | ||
4719 | { | ||
4720 | $current.merge(this_ID_0); | ||
4721 | } | ||
4722 | { | ||
4723 | newLeafNode(this_ID_0, grammarAccess.getQualifiedNameSegmentAccess().getIDTerminalRuleCall_0()); | ||
4724 | } | ||
4725 | | | ||
4726 | this_QUOTED_ID_1=RULE_QUOTED_ID | ||
4727 | { | ||
4728 | $current.merge(this_QUOTED_ID_1); | ||
4729 | } | ||
4730 | { | ||
4731 | newLeafNode(this_QUOTED_ID_1, grammarAccess.getQualifiedNameSegmentAccess().getQUOTED_IDTerminalRuleCall_1()); | ||
4732 | } | ||
4733 | | | ||
4734 | kw=Object | ||
4735 | { | ||
4736 | $current.merge(kw); | ||
4737 | newLeafNode(kw, grammarAccess.getQualifiedNameSegmentAccess().getObjectKeyword_2()); | ||
4738 | } | ||
4739 | ) | ||
4740 | ; | ||
4741 | |||
4742 | // Entry rule entryRuleQualifiedName | ||
4743 | entryRuleQualifiedName returns [String current=null]@init { | ||
4744 | HiddenTokens myHiddenTokenState = ((XtextTokenStream)input).setHiddenTokens(); | ||
4745 | }: | ||
4746 | { newCompositeNode(grammarAccess.getQualifiedNameRule()); } | ||
4747 | iv_ruleQualifiedName=ruleQualifiedName | ||
4748 | { $current=$iv_ruleQualifiedName.current.getText(); } | ||
4749 | EOF; | ||
4750 | finally { | ||
4751 | myHiddenTokenState.restore(); | ||
4752 | } | ||
4753 | |||
4754 | // Rule QualifiedName | ||
4755 | ruleQualifiedName returns [AntlrDatatypeRuleToken current=new AntlrDatatypeRuleToken()] | ||
4756 | @init { | ||
4757 | enterRule(); | ||
4758 | HiddenTokens myHiddenTokenState = ((XtextTokenStream)input).setHiddenTokens(); | ||
4759 | } | ||
4760 | @after { | ||
4761 | leaveRule(); | ||
4762 | }: | ||
4763 | ( | ||
4764 | { | ||
4765 | newCompositeNode(grammarAccess.getQualifiedNameAccess().getQualifiedNameSegmentParserRuleCall_0()); | ||
4766 | } | ||
4767 | this_QualifiedNameSegment_0=ruleQualifiedNameSegment | ||
4768 | { | ||
4769 | $current.merge(this_QualifiedNameSegment_0); | ||
4770 | } | ||
4771 | { | ||
4772 | afterParserOrEnumRuleCall(); | ||
4773 | } | ||
4774 | ( | ||
4775 | kw=ColonColon | ||
4776 | { | ||
4777 | $current.merge(kw); | ||
4778 | newLeafNode(kw, grammarAccess.getQualifiedNameAccess().getColonColonKeyword_1_0()); | ||
4779 | } | ||
4780 | { | ||
4781 | newCompositeNode(grammarAccess.getQualifiedNameAccess().getQualifiedNameSegmentParserRuleCall_1_1()); | ||
4782 | } | ||
4783 | this_QualifiedNameSegment_2=ruleQualifiedNameSegment | ||
4784 | { | ||
4785 | $current.merge(this_QualifiedNameSegment_2); | ||
4786 | } | ||
4787 | { | ||
4788 | afterParserOrEnumRuleCall(); | ||
4789 | } | ||
4790 | )* | ||
4791 | ) | ||
4792 | ; | ||
4793 | finally { | ||
4794 | myHiddenTokenState.restore(); | ||
4795 | } | ||
4796 | |||
4797 | // Rule AttributeKind | ||
4798 | ruleAttributeKind returns [Enumerator current=null] | ||
4799 | @init { | ||
4800 | enterRule(); | ||
4801 | } | ||
4802 | @after { | ||
4803 | leaveRule(); | ||
4804 | }: | ||
4805 | ( | ||
4806 | ( | ||
4807 | enumLiteral_0=Functional | ||
4808 | { | ||
4809 | $current = grammarAccess.getAttributeKindAccess().getFUNCTIONALEnumLiteralDeclaration_0().getEnumLiteral().getInstance(); | ||
4810 | newLeafNode(enumLiteral_0, grammarAccess.getAttributeKindAccess().getFUNCTIONALEnumLiteralDeclaration_0()); | ||
4811 | } | ||
4812 | ) | ||
4813 | | | ||
4814 | ( | ||
4815 | enumLiteral_1=Error | ||
4816 | { | ||
4817 | $current = grammarAccess.getAttributeKindAccess().getERROREnumLiteralDeclaration_1().getEnumLiteral().getInstance(); | ||
4818 | newLeafNode(enumLiteral_1, grammarAccess.getAttributeKindAccess().getERROREnumLiteralDeclaration_1()); | ||
4819 | } | ||
4820 | ) | ||
4821 | | | ||
4822 | ( | ||
4823 | enumLiteral_2=Root | ||
4824 | { | ||
4825 | $current = grammarAccess.getAttributeKindAccess().getROOTEnumLiteralDeclaration_2().getEnumLiteral().getInstance(); | ||
4826 | newLeafNode(enumLiteral_2, grammarAccess.getAttributeKindAccess().getROOTEnumLiteralDeclaration_2()); | ||
4827 | } | ||
4828 | ) | ||
4829 | | | ||
4830 | ( | ||
4831 | enumLiteral_3=Containment | ||
4832 | { | ||
4833 | $current = grammarAccess.getAttributeKindAccess().getCONTAINMENTEnumLiteralDeclaration_3().getEnumLiteral().getInstance(); | ||
4834 | newLeafNode(enumLiteral_3, grammarAccess.getAttributeKindAccess().getCONTAINMENTEnumLiteralDeclaration_3()); | ||
4835 | } | ||
4836 | ) | ||
4837 | ) | ||
4838 | ; | ||
4839 | |||
4840 | // Rule ComparisonOperator | ||
4841 | ruleComparisonOperator returns [Enumerator current=null] | ||
4842 | @init { | ||
4843 | enterRule(); | ||
4844 | } | ||
4845 | @after { | ||
4846 | leaveRule(); | ||
4847 | }: | ||
4848 | ( | ||
4849 | ( | ||
4850 | enumLiteral_0=EqualsSignEqualsSign | ||
4851 | { | ||
4852 | $current = grammarAccess.getComparisonOperatorAccess().getEQUALSEnumLiteralDeclaration_0().getEnumLiteral().getInstance(); | ||
4853 | newLeafNode(enumLiteral_0, grammarAccess.getComparisonOperatorAccess().getEQUALSEnumLiteralDeclaration_0()); | ||
4854 | } | ||
4855 | ) | ||
4856 | | | ||
4857 | ( | ||
4858 | enumLiteral_1=ExclamationMarkEqualsSign | ||
4859 | { | ||
4860 | $current = grammarAccess.getComparisonOperatorAccess().getNOT_EQUALSEnumLiteralDeclaration_1().getEnumLiteral().getInstance(); | ||
4861 | newLeafNode(enumLiteral_1, grammarAccess.getComparisonOperatorAccess().getNOT_EQUALSEnumLiteralDeclaration_1()); | ||
4862 | } | ||
4863 | ) | ||
4864 | | | ||
4865 | ( | ||
4866 | enumLiteral_2=LessThanSign | ||
4867 | { | ||
4868 | $current = grammarAccess.getComparisonOperatorAccess().getLESSEnumLiteralDeclaration_2().getEnumLiteral().getInstance(); | ||
4869 | newLeafNode(enumLiteral_2, grammarAccess.getComparisonOperatorAccess().getLESSEnumLiteralDeclaration_2()); | ||
4870 | } | ||
4871 | ) | ||
4872 | | | ||
4873 | ( | ||
4874 | enumLiteral_3=LessThanSignEqualsSign | ||
4875 | { | ||
4876 | $current = grammarAccess.getComparisonOperatorAccess().getLESS_EQUALSEnumLiteralDeclaration_3().getEnumLiteral().getInstance(); | ||
4877 | newLeafNode(enumLiteral_3, grammarAccess.getComparisonOperatorAccess().getLESS_EQUALSEnumLiteralDeclaration_3()); | ||
4878 | } | ||
4879 | ) | ||
4880 | | | ||
4881 | ( | ||
4882 | enumLiteral_4=GreaterThanSign | ||
4883 | { | ||
4884 | $current = grammarAccess.getComparisonOperatorAccess().getGREATEREnumLiteralDeclaration_4().getEnumLiteral().getInstance(); | ||
4885 | newLeafNode(enumLiteral_4, grammarAccess.getComparisonOperatorAccess().getGREATEREnumLiteralDeclaration_4()); | ||
4886 | } | ||
4887 | ) | ||
4888 | | | ||
4889 | ( | ||
4890 | enumLiteral_5=GreaterThanSignEqualsSign | ||
4891 | { | ||
4892 | $current = grammarAccess.getComparisonOperatorAccess().getGREATER_EQUALSEnumLiteralDeclaration_5().getEnumLiteral().getInstance(); | ||
4893 | newLeafNode(enumLiteral_5, grammarAccess.getComparisonOperatorAccess().getGREATER_EQUALSEnumLiteralDeclaration_5()); | ||
4894 | } | ||
4895 | ) | ||
4896 | | | ||
4897 | ( | ||
4898 | enumLiteral_6=In | ||
4899 | { | ||
4900 | $current = grammarAccess.getComparisonOperatorAccess().getINEnumLiteralDeclaration_6().getEnumLiteral().getInstance(); | ||
4901 | newLeafNode(enumLiteral_6, grammarAccess.getComparisonOperatorAccess().getINEnumLiteralDeclaration_6()); | ||
4902 | } | ||
4903 | ) | ||
4904 | ) | ||
4905 | ; | ||
4906 | |||
4907 | // Rule AdditiveBinaryOperator | ||
4908 | ruleAdditiveBinaryOperator returns [Enumerator current=null] | ||
4909 | @init { | ||
4910 | enterRule(); | ||
4911 | } | ||
4912 | @after { | ||
4913 | leaveRule(); | ||
4914 | }: | ||
4915 | ( | ||
4916 | ( | ||
4917 | enumLiteral_0=PlusSign | ||
4918 | { | ||
4919 | $current = grammarAccess.getAdditiveBinaryOperatorAccess().getPLUSEnumLiteralDeclaration_0().getEnumLiteral().getInstance(); | ||
4920 | newLeafNode(enumLiteral_0, grammarAccess.getAdditiveBinaryOperatorAccess().getPLUSEnumLiteralDeclaration_0()); | ||
4921 | } | ||
4922 | ) | ||
4923 | | | ||
4924 | ( | ||
4925 | enumLiteral_1=HyphenMinus | ||
4926 | { | ||
4927 | $current = grammarAccess.getAdditiveBinaryOperatorAccess().getMINUSEnumLiteralDeclaration_1().getEnumLiteral().getInstance(); | ||
4928 | newLeafNode(enumLiteral_1, grammarAccess.getAdditiveBinaryOperatorAccess().getMINUSEnumLiteralDeclaration_1()); | ||
4929 | } | ||
4930 | ) | ||
4931 | ) | ||
4932 | ; | ||
4933 | |||
4934 | // Rule MultiplicativeBinaryOperator | ||
4935 | ruleMultiplicativeBinaryOperator returns [Enumerator current=null] | ||
4936 | @init { | ||
4937 | enterRule(); | ||
4938 | } | ||
4939 | @after { | ||
4940 | leaveRule(); | ||
4941 | }: | ||
4942 | ( | ||
4943 | ( | ||
4944 | enumLiteral_0=Asterisk | ||
4945 | { | ||
4946 | $current = grammarAccess.getMultiplicativeBinaryOperatorAccess().getMULTIPLYEnumLiteralDeclaration_0().getEnumLiteral().getInstance(); | ||
4947 | newLeafNode(enumLiteral_0, grammarAccess.getMultiplicativeBinaryOperatorAccess().getMULTIPLYEnumLiteralDeclaration_0()); | ||
4948 | } | ||
4949 | ) | ||
4950 | | | ||
4951 | ( | ||
4952 | enumLiteral_1=Solidus | ||
4953 | { | ||
4954 | $current = grammarAccess.getMultiplicativeBinaryOperatorAccess().getDIVIDEEnumLiteralDeclaration_1().getEnumLiteral().getInstance(); | ||
4955 | newLeafNode(enumLiteral_1, grammarAccess.getMultiplicativeBinaryOperatorAccess().getDIVIDEEnumLiteralDeclaration_1()); | ||
4956 | } | ||
4957 | ) | ||
4958 | ) | ||
4959 | ; | ||
4960 | |||
4961 | // Rule ExponentialOp | ||
4962 | ruleExponentialOp returns [Enumerator current=null] | ||
4963 | @init { | ||
4964 | enterRule(); | ||
4965 | } | ||
4966 | @after { | ||
4967 | leaveRule(); | ||
4968 | }: | ||
4969 | ( | ||
4970 | enumLiteral_0=CircumflexAccent | ||
4971 | { | ||
4972 | $current = grammarAccess.getExponentialOpAccess().getPOWEnumLiteralDeclaration().getEnumLiteral().getInstance(); | ||
4973 | newLeafNode(enumLiteral_0, grammarAccess.getExponentialOpAccess().getPOWEnumLiteralDeclaration()); | ||
4974 | } | ||
4975 | ) | ||
4976 | ; | ||
4977 | |||
4978 | // Rule UnaryOperator | ||
4979 | ruleUnaryOperator returns [Enumerator current=null] | ||
4980 | @init { | ||
4981 | enterRule(); | ||
4982 | } | ||
4983 | @after { | ||
4984 | leaveRule(); | ||
4985 | }: | ||
4986 | ( | ||
4987 | ( | ||
4988 | enumLiteral_0=ExclamationMark | ||
4989 | { | ||
4990 | $current = grammarAccess.getUnaryOperatorAccess().getNOTEnumLiteralDeclaration_0().getEnumLiteral().getInstance(); | ||
4991 | newLeafNode(enumLiteral_0, grammarAccess.getUnaryOperatorAccess().getNOTEnumLiteralDeclaration_0()); | ||
4992 | } | ||
4993 | ) | ||
4994 | | | ||
4995 | ( | ||
4996 | enumLiteral_1=PlusSign | ||
4997 | { | ||
4998 | $current = grammarAccess.getUnaryOperatorAccess().getPLUSEnumLiteralDeclaration_1().getEnumLiteral().getInstance(); | ||
4999 | newLeafNode(enumLiteral_1, grammarAccess.getUnaryOperatorAccess().getPLUSEnumLiteralDeclaration_1()); | ||
5000 | } | ||
5001 | ) | ||
5002 | | | ||
5003 | ( | ||
5004 | enumLiteral_2=HyphenMinus | ||
5005 | { | ||
5006 | $current = grammarAccess.getUnaryOperatorAccess().getMINUSEnumLiteralDeclaration_2().getEnumLiteral().getInstance(); | ||
5007 | newLeafNode(enumLiteral_2, grammarAccess.getUnaryOperatorAccess().getMINUSEnumLiteralDeclaration_2()); | ||
5008 | } | ||
5009 | ) | ||
5010 | | | ||
5011 | ( | ||
5012 | enumLiteral_3=QuestionMark | ||
5013 | { | ||
5014 | $current = grammarAccess.getUnaryOperatorAccess().getMAYBEEnumLiteralDeclaration_3().getEnumLiteral().getInstance(); | ||
5015 | newLeafNode(enumLiteral_3, grammarAccess.getUnaryOperatorAccess().getMAYBEEnumLiteralDeclaration_3()); | ||
5016 | } | ||
5017 | ) | ||
5018 | ) | ||
5019 | ; | ||
5020 | |||
5021 | // Rule LogicValue | ||
5022 | ruleLogicValue returns [Enumerator current=null] | ||
5023 | @init { | ||
5024 | enterRule(); | ||
5025 | } | ||
5026 | @after { | ||
5027 | leaveRule(); | ||
5028 | }: | ||
5029 | ( | ||
5030 | ( | ||
5031 | enumLiteral_0=True | ||
5032 | { | ||
5033 | $current = grammarAccess.getLogicValueAccess().getTRUEEnumLiteralDeclaration_0().getEnumLiteral().getInstance(); | ||
5034 | newLeafNode(enumLiteral_0, grammarAccess.getLogicValueAccess().getTRUEEnumLiteralDeclaration_0()); | ||
5035 | } | ||
5036 | ) | ||
5037 | | | ||
5038 | ( | ||
5039 | enumLiteral_1=False | ||
5040 | { | ||
5041 | $current = grammarAccess.getLogicValueAccess().getFALSEEnumLiteralDeclaration_1().getEnumLiteral().getInstance(); | ||
5042 | newLeafNode(enumLiteral_1, grammarAccess.getLogicValueAccess().getFALSEEnumLiteralDeclaration_1()); | ||
5043 | } | ||
5044 | ) | ||
5045 | | | ||
5046 | ( | ||
5047 | enumLiteral_2=Unknown | ||
5048 | { | ||
5049 | $current = grammarAccess.getLogicValueAccess().getUNKNOWNEnumLiteralDeclaration_2().getEnumLiteral().getInstance(); | ||
5050 | newLeafNode(enumLiteral_2, grammarAccess.getLogicValueAccess().getUNKNOWNEnumLiteralDeclaration_2()); | ||
5051 | } | ||
5052 | ) | ||
5053 | | | ||
5054 | ( | ||
5055 | enumLiteral_3=Error | ||
5056 | { | ||
5057 | $current = grammarAccess.getLogicValueAccess().getERROREnumLiteralDeclaration_3().getEnumLiteral().getInstance(); | ||
5058 | newLeafNode(enumLiteral_3, grammarAccess.getLogicValueAccess().getERROREnumLiteralDeclaration_3()); | ||
5059 | } | ||
5060 | ) | ||
5061 | ) | ||
5062 | ; | ||
5063 | |||
5064 | // Rule ObjectiveKind | ||
5065 | ruleObjectiveKind returns [Enumerator current=null] | ||
5066 | @init { | ||
5067 | enterRule(); | ||
5068 | } | ||
5069 | @after { | ||
5070 | leaveRule(); | ||
5071 | }: | ||
5072 | ( | ||
5073 | ( | ||
5074 | enumLiteral_0=Minimize | ||
5075 | { | ||
5076 | $current = grammarAccess.getObjectiveKindAccess().getMINIMIZATIONEnumLiteralDeclaration_0().getEnumLiteral().getInstance(); | ||
5077 | newLeafNode(enumLiteral_0, grammarAccess.getObjectiveKindAccess().getMINIMIZATIONEnumLiteralDeclaration_0()); | ||
5078 | } | ||
5079 | ) | ||
5080 | | | ||
5081 | ( | ||
5082 | enumLiteral_1=Maximize | ||
5083 | { | ||
5084 | $current = grammarAccess.getObjectiveKindAccess().getMAXIMIZATIONEnumLiteralDeclaration_1().getEnumLiteral().getInstance(); | ||
5085 | newLeafNode(enumLiteral_1, grammarAccess.getObjectiveKindAccess().getMAXIMIZATIONEnumLiteralDeclaration_1()); | ||
5086 | } | ||
5087 | ) | ||
5088 | ) | ||
5089 | ; | ||
diff --git a/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/parser/antlr/internal/InternalSolverLanguageParser.java b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/parser/antlr/internal/InternalSolverLanguageParser.java new file mode 100644 index 00000000..37223f5c --- /dev/null +++ b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/parser/antlr/internal/InternalSolverLanguageParser.java | |||
@@ -0,0 +1,13577 @@ | |||
1 | package org.eclipse.viatra.solver.language.parser.antlr.internal; | ||
2 | |||
3 | import org.eclipse.xtext.*; | ||
4 | import org.eclipse.xtext.parser.*; | ||
5 | import org.eclipse.xtext.parser.impl.*; | ||
6 | import org.eclipse.emf.ecore.util.EcoreUtil; | ||
7 | import org.eclipse.emf.ecore.EObject; | ||
8 | import org.eclipse.emf.common.util.Enumerator; | ||
9 | import org.eclipse.xtext.parser.antlr.AbstractInternalAntlrParser; | ||
10 | import org.eclipse.xtext.parser.antlr.XtextTokenStream; | ||
11 | import org.eclipse.xtext.parser.antlr.XtextTokenStream.HiddenTokens; | ||
12 | import org.eclipse.xtext.parser.antlr.AntlrDatatypeRuleToken; | ||
13 | import org.eclipse.viatra.solver.language.services.SolverLanguageGrammarAccess; | ||
14 | |||
15 | |||
16 | |||
17 | import org.antlr.runtime.*; | ||
18 | import java.util.Stack; | ||
19 | import java.util.List; | ||
20 | import java.util.ArrayList; | ||
21 | |||
22 | @SuppressWarnings("all") | ||
23 | public class InternalSolverLanguageParser extends AbstractInternalAntlrParser { | ||
24 | public static final String[] tokenNames = new String[] { | ||
25 | "<invalid>", "<EOR>", "<DOWN>", "<UP>", "Containment", "Functional", "Abstract", "Contains", "Datatype", "Maximize", "Minimize", "Opposite", "Default", "Extends", "Problem", "Unknown", "Extern", "Import", "Object", "Refers", "Class", "Count", "Empty", "Error", "False", "Scope", "Else", "Enum", "Root", "Then", "True", "FullStopFullStopFullStop", "Inf", "Let", "ExclamationMarkEqualsSign", "HyphenMinusGreaterThanSign", "ColonHyphenMinus", "ColonColon", "ColonEqualsSign", "LessThanSignEqualsSign", "EqualsSignEqualsSign", "EqualsSignGreaterThanSign", "GreaterThanSignEqualsSign", "As", "If", "In", "ExclamationMark", "LeftParenthesis", "RightParenthesis", "Asterisk", "PlusSign", "Comma", "HyphenMinus", "FullStop", "Solidus", "Colon", "Semicolon", "LessThanSign", "EqualsSign", "GreaterThanSign", "QuestionMark", "LeftSquareBracket", "RightSquareBracket", "CircumflexAccent", "LeftCurlyBracket", "VerticalLine", "RightCurlyBracket", "Tilde", "RULE_STRING", "RULE_QUOTED_ID", "RULE_SL_COMMENT", "RULE_TRANSITIVE_CLOSURE", "RULE_REFLEXIVE_TRANSITIVE_CLOSURE", "RULE_FULL_STOP", "RULE_ID", "RULE_INT", "RULE_ML_COMMENT", "RULE_WS", "RULE_ANY_OTHER" | ||
26 | }; | ||
27 | public static final int Enum=27; | ||
28 | public static final int Import=17; | ||
29 | public static final int EqualsSignGreaterThanSign=41; | ||
30 | public static final int True=30; | ||
31 | public static final int Count=21; | ||
32 | public static final int False=24; | ||
33 | public static final int FullStopFullStopFullStop=31; | ||
34 | public static final int LessThanSign=57; | ||
35 | public static final int Datatype=8; | ||
36 | public static final int LeftParenthesis=47; | ||
37 | public static final int Unknown=15; | ||
38 | public static final int RULE_REFLEXIVE_TRANSITIVE_CLOSURE=72; | ||
39 | public static final int Then=29; | ||
40 | public static final int Extends=13; | ||
41 | public static final int RightSquareBracket=62; | ||
42 | public static final int ExclamationMark=46; | ||
43 | public static final int Opposite=11; | ||
44 | public static final int GreaterThanSign=59; | ||
45 | public static final int Root=28; | ||
46 | public static final int RULE_ID=74; | ||
47 | public static final int RULE_QUOTED_ID=69; | ||
48 | public static final int RightParenthesis=48; | ||
49 | public static final int ColonEqualsSign=38; | ||
50 | public static final int GreaterThanSignEqualsSign=42; | ||
51 | public static final int Functional=5; | ||
52 | public static final int ColonColon=37; | ||
53 | public static final int EqualsSignEqualsSign=40; | ||
54 | public static final int VerticalLine=65; | ||
55 | public static final int PlusSign=50; | ||
56 | public static final int RULE_INT=75; | ||
57 | public static final int Contains=7; | ||
58 | public static final int RULE_ML_COMMENT=76; | ||
59 | public static final int RULE_TRANSITIVE_CLOSURE=71; | ||
60 | public static final int Problem=14; | ||
61 | public static final int Object=18; | ||
62 | public static final int Class=20; | ||
63 | public static final int LeftSquareBracket=61; | ||
64 | public static final int RULE_FULL_STOP=73; | ||
65 | public static final int If=44; | ||
66 | public static final int Refers=19; | ||
67 | public static final int Inf=32; | ||
68 | public static final int In=45; | ||
69 | public static final int RULE_STRING=68; | ||
70 | public static final int Extern=16; | ||
71 | public static final int RULE_SL_COMMENT=70; | ||
72 | public static final int Comma=51; | ||
73 | public static final int EqualsSign=58; | ||
74 | public static final int Empty=22; | ||
75 | public static final int As=43; | ||
76 | public static final int HyphenMinus=52; | ||
77 | public static final int Maximize=9; | ||
78 | public static final int LessThanSignEqualsSign=39; | ||
79 | public static final int Solidus=54; | ||
80 | public static final int Colon=55; | ||
81 | public static final int RightCurlyBracket=66; | ||
82 | public static final int EOF=-1; | ||
83 | public static final int Asterisk=49; | ||
84 | public static final int Containment=4; | ||
85 | public static final int FullStop=53; | ||
86 | public static final int RULE_WS=77; | ||
87 | public static final int Abstract=6; | ||
88 | public static final int Minimize=10; | ||
89 | public static final int LeftCurlyBracket=64; | ||
90 | public static final int Error=23; | ||
91 | public static final int Tilde=67; | ||
92 | public static final int RULE_ANY_OTHER=78; | ||
93 | public static final int Default=12; | ||
94 | public static final int ColonHyphenMinus=36; | ||
95 | public static final int CircumflexAccent=63; | ||
96 | public static final int Semicolon=56; | ||
97 | public static final int Scope=25; | ||
98 | public static final int QuestionMark=60; | ||
99 | public static final int Else=26; | ||
100 | public static final int Let=33; | ||
101 | public static final int ExclamationMarkEqualsSign=34; | ||
102 | public static final int HyphenMinusGreaterThanSign=35; | ||
103 | |||
104 | // delegates | ||
105 | // delegators | ||
106 | |||
107 | |||
108 | public InternalSolverLanguageParser(TokenStream input) { | ||
109 | this(input, new RecognizerSharedState()); | ||
110 | } | ||
111 | public InternalSolverLanguageParser(TokenStream input, RecognizerSharedState state) { | ||
112 | super(input, state); | ||
113 | |||
114 | } | ||
115 | |||
116 | |||
117 | public String[] getTokenNames() { return InternalSolverLanguageParser.tokenNames; } | ||
118 | public String getGrammarFileName() { return "InternalSolverLanguageParser.g"; } | ||
119 | |||
120 | |||
121 | |||
122 | private SolverLanguageGrammarAccess grammarAccess; | ||
123 | |||
124 | public InternalSolverLanguageParser(TokenStream input, SolverLanguageGrammarAccess grammarAccess) { | ||
125 | this(input); | ||
126 | this.grammarAccess = grammarAccess; | ||
127 | registerRules(grammarAccess.getGrammar()); | ||
128 | } | ||
129 | |||
130 | @Override | ||
131 | protected String getFirstRuleName() { | ||
132 | return "Problem"; | ||
133 | } | ||
134 | |||
135 | @Override | ||
136 | protected SolverLanguageGrammarAccess getGrammarAccess() { | ||
137 | return grammarAccess; | ||
138 | } | ||
139 | |||
140 | |||
141 | |||
142 | |||
143 | // $ANTLR start "entryRuleProblem" | ||
144 | // InternalSolverLanguageParser.g:58:1: entryRuleProblem returns [EObject current=null] : iv_ruleProblem= ruleProblem EOF ; | ||
145 | public final EObject entryRuleProblem() throws RecognitionException { | ||
146 | EObject current = null; | ||
147 | |||
148 | EObject iv_ruleProblem = null; | ||
149 | |||
150 | |||
151 | try { | ||
152 | // InternalSolverLanguageParser.g:58:48: (iv_ruleProblem= ruleProblem EOF ) | ||
153 | // InternalSolverLanguageParser.g:59:2: iv_ruleProblem= ruleProblem EOF | ||
154 | { | ||
155 | newCompositeNode(grammarAccess.getProblemRule()); | ||
156 | pushFollow(FOLLOW_1); | ||
157 | iv_ruleProblem=ruleProblem(); | ||
158 | |||
159 | state._fsp--; | ||
160 | |||
161 | current =iv_ruleProblem; | ||
162 | match(input,EOF,FOLLOW_2); | ||
163 | |||
164 | } | ||
165 | |||
166 | } | ||
167 | |||
168 | catch (RecognitionException re) { | ||
169 | recover(input,re); | ||
170 | appendSkippedTokens(); | ||
171 | } | ||
172 | finally { | ||
173 | } | ||
174 | return current; | ||
175 | } | ||
176 | // $ANTLR end "entryRuleProblem" | ||
177 | |||
178 | |||
179 | // $ANTLR start "ruleProblem" | ||
180 | // InternalSolverLanguageParser.g:65:1: ruleProblem returns [EObject current=null] : ( (otherlv_0= Problem ( (lv_name_1_0= ruleQualifiedName ) ) this_FULL_STOP_2= RULE_FULL_STOP )? ( (lv_imports_3_0= ruleImport ) )* ( (lv_statements_4_0= ruleStatement ) )* ) ; | ||
181 | public final EObject ruleProblem() throws RecognitionException { | ||
182 | EObject current = null; | ||
183 | |||
184 | Token otherlv_0=null; | ||
185 | Token this_FULL_STOP_2=null; | ||
186 | AntlrDatatypeRuleToken lv_name_1_0 = null; | ||
187 | |||
188 | EObject lv_imports_3_0 = null; | ||
189 | |||
190 | EObject lv_statements_4_0 = null; | ||
191 | |||
192 | |||
193 | |||
194 | enterRule(); | ||
195 | |||
196 | try { | ||
197 | // InternalSolverLanguageParser.g:71:2: ( ( (otherlv_0= Problem ( (lv_name_1_0= ruleQualifiedName ) ) this_FULL_STOP_2= RULE_FULL_STOP )? ( (lv_imports_3_0= ruleImport ) )* ( (lv_statements_4_0= ruleStatement ) )* ) ) | ||
198 | // InternalSolverLanguageParser.g:72:2: ( (otherlv_0= Problem ( (lv_name_1_0= ruleQualifiedName ) ) this_FULL_STOP_2= RULE_FULL_STOP )? ( (lv_imports_3_0= ruleImport ) )* ( (lv_statements_4_0= ruleStatement ) )* ) | ||
199 | { | ||
200 | // InternalSolverLanguageParser.g:72:2: ( (otherlv_0= Problem ( (lv_name_1_0= ruleQualifiedName ) ) this_FULL_STOP_2= RULE_FULL_STOP )? ( (lv_imports_3_0= ruleImport ) )* ( (lv_statements_4_0= ruleStatement ) )* ) | ||
201 | // InternalSolverLanguageParser.g:73:3: (otherlv_0= Problem ( (lv_name_1_0= ruleQualifiedName ) ) this_FULL_STOP_2= RULE_FULL_STOP )? ( (lv_imports_3_0= ruleImport ) )* ( (lv_statements_4_0= ruleStatement ) )* | ||
202 | { | ||
203 | // InternalSolverLanguageParser.g:73:3: (otherlv_0= Problem ( (lv_name_1_0= ruleQualifiedName ) ) this_FULL_STOP_2= RULE_FULL_STOP )? | ||
204 | int alt1=2; | ||
205 | int LA1_0 = input.LA(1); | ||
206 | |||
207 | if ( (LA1_0==Problem) ) { | ||
208 | alt1=1; | ||
209 | } | ||
210 | switch (alt1) { | ||
211 | case 1 : | ||
212 | // InternalSolverLanguageParser.g:74:4: otherlv_0= Problem ( (lv_name_1_0= ruleQualifiedName ) ) this_FULL_STOP_2= RULE_FULL_STOP | ||
213 | { | ||
214 | otherlv_0=(Token)match(input,Problem,FOLLOW_3); | ||
215 | |||
216 | newLeafNode(otherlv_0, grammarAccess.getProblemAccess().getProblemKeyword_0_0()); | ||
217 | |||
218 | // InternalSolverLanguageParser.g:78:4: ( (lv_name_1_0= ruleQualifiedName ) ) | ||
219 | // InternalSolverLanguageParser.g:79:5: (lv_name_1_0= ruleQualifiedName ) | ||
220 | { | ||
221 | // InternalSolverLanguageParser.g:79:5: (lv_name_1_0= ruleQualifiedName ) | ||
222 | // InternalSolverLanguageParser.g:80:6: lv_name_1_0= ruleQualifiedName | ||
223 | { | ||
224 | |||
225 | newCompositeNode(grammarAccess.getProblemAccess().getNameQualifiedNameParserRuleCall_0_1_0()); | ||
226 | |||
227 | pushFollow(FOLLOW_4); | ||
228 | lv_name_1_0=ruleQualifiedName(); | ||
229 | |||
230 | state._fsp--; | ||
231 | |||
232 | |||
233 | if (current==null) { | ||
234 | current = createModelElementForParent(grammarAccess.getProblemRule()); | ||
235 | } | ||
236 | set( | ||
237 | current, | ||
238 | "name", | ||
239 | lv_name_1_0, | ||
240 | "org.eclipse.viatra.solver.language.SolverLanguage.QualifiedName"); | ||
241 | afterParserOrEnumRuleCall(); | ||
242 | |||
243 | |||
244 | } | ||
245 | |||
246 | |||
247 | } | ||
248 | |||
249 | this_FULL_STOP_2=(Token)match(input,RULE_FULL_STOP,FOLLOW_5); | ||
250 | |||
251 | newLeafNode(this_FULL_STOP_2, grammarAccess.getProblemAccess().getFULL_STOPTerminalRuleCall_0_2()); | ||
252 | |||
253 | |||
254 | } | ||
255 | break; | ||
256 | |||
257 | } | ||
258 | |||
259 | // InternalSolverLanguageParser.g:102:3: ( (lv_imports_3_0= ruleImport ) )* | ||
260 | loop2: | ||
261 | do { | ||
262 | int alt2=2; | ||
263 | int LA2_0 = input.LA(1); | ||
264 | |||
265 | if ( (LA2_0==Import) ) { | ||
266 | alt2=1; | ||
267 | } | ||
268 | |||
269 | |||
270 | switch (alt2) { | ||
271 | case 1 : | ||
272 | // InternalSolverLanguageParser.g:103:4: (lv_imports_3_0= ruleImport ) | ||
273 | { | ||
274 | // InternalSolverLanguageParser.g:103:4: (lv_imports_3_0= ruleImport ) | ||
275 | // InternalSolverLanguageParser.g:104:5: lv_imports_3_0= ruleImport | ||
276 | { | ||
277 | |||
278 | newCompositeNode(grammarAccess.getProblemAccess().getImportsImportParserRuleCall_1_0()); | ||
279 | |||
280 | pushFollow(FOLLOW_5); | ||
281 | lv_imports_3_0=ruleImport(); | ||
282 | |||
283 | state._fsp--; | ||
284 | |||
285 | |||
286 | if (current==null) { | ||
287 | current = createModelElementForParent(grammarAccess.getProblemRule()); | ||
288 | } | ||
289 | add( | ||
290 | current, | ||
291 | "imports", | ||
292 | lv_imports_3_0, | ||
293 | "org.eclipse.viatra.solver.language.SolverLanguage.Import"); | ||
294 | afterParserOrEnumRuleCall(); | ||
295 | |||
296 | |||
297 | } | ||
298 | |||
299 | |||
300 | } | ||
301 | break; | ||
302 | |||
303 | default : | ||
304 | break loop2; | ||
305 | } | ||
306 | } while (true); | ||
307 | |||
308 | // InternalSolverLanguageParser.g:121:3: ( (lv_statements_4_0= ruleStatement ) )* | ||
309 | loop3: | ||
310 | do { | ||
311 | int alt3=2; | ||
312 | int LA3_0 = input.LA(1); | ||
313 | |||
314 | if ( ((LA3_0>=Containment && LA3_0<=Abstract)||(LA3_0>=Maximize && LA3_0<=Minimize)||LA3_0==Default||(LA3_0>=Unknown && LA3_0<=Extern)||LA3_0==Object||(LA3_0>=Class && LA3_0<=Scope)||(LA3_0>=Enum && LA3_0<=Root)||LA3_0==True||(LA3_0>=Inf && LA3_0<=Let)||LA3_0==If||(LA3_0>=ExclamationMark && LA3_0<=LeftParenthesis)||LA3_0==PlusSign||LA3_0==HyphenMinus||(LA3_0>=QuestionMark && LA3_0<=LeftSquareBracket)||(LA3_0>=Tilde && LA3_0<=RULE_QUOTED_ID)||(LA3_0>=RULE_ID && LA3_0<=RULE_INT)) ) { | ||
315 | alt3=1; | ||
316 | } | ||
317 | |||
318 | |||
319 | switch (alt3) { | ||
320 | case 1 : | ||
321 | // InternalSolverLanguageParser.g:122:4: (lv_statements_4_0= ruleStatement ) | ||
322 | { | ||
323 | // InternalSolverLanguageParser.g:122:4: (lv_statements_4_0= ruleStatement ) | ||
324 | // InternalSolverLanguageParser.g:123:5: lv_statements_4_0= ruleStatement | ||
325 | { | ||
326 | |||
327 | newCompositeNode(grammarAccess.getProblemAccess().getStatementsStatementParserRuleCall_2_0()); | ||
328 | |||
329 | pushFollow(FOLLOW_6); | ||
330 | lv_statements_4_0=ruleStatement(); | ||
331 | |||
332 | state._fsp--; | ||
333 | |||
334 | |||
335 | if (current==null) { | ||
336 | current = createModelElementForParent(grammarAccess.getProblemRule()); | ||
337 | } | ||
338 | add( | ||
339 | current, | ||
340 | "statements", | ||
341 | lv_statements_4_0, | ||
342 | "org.eclipse.viatra.solver.language.SolverLanguage.Statement"); | ||
343 | afterParserOrEnumRuleCall(); | ||
344 | |||
345 | |||
346 | } | ||
347 | |||
348 | |||
349 | } | ||
350 | break; | ||
351 | |||
352 | default : | ||
353 | break loop3; | ||
354 | } | ||
355 | } while (true); | ||
356 | |||
357 | |||
358 | } | ||
359 | |||
360 | |||
361 | } | ||
362 | |||
363 | |||
364 | leaveRule(); | ||
365 | |||
366 | } | ||
367 | |||
368 | catch (RecognitionException re) { | ||
369 | recover(input,re); | ||
370 | appendSkippedTokens(); | ||
371 | } | ||
372 | finally { | ||
373 | } | ||
374 | return current; | ||
375 | } | ||
376 | // $ANTLR end "ruleProblem" | ||
377 | |||
378 | |||
379 | // $ANTLR start "entryRuleStatement" | ||
380 | // InternalSolverLanguageParser.g:144:1: entryRuleStatement returns [EObject current=null] : iv_ruleStatement= ruleStatement EOF ; | ||
381 | public final EObject entryRuleStatement() throws RecognitionException { | ||
382 | EObject current = null; | ||
383 | |||
384 | EObject iv_ruleStatement = null; | ||
385 | |||
386 | |||
387 | try { | ||
388 | // InternalSolverLanguageParser.g:144:50: (iv_ruleStatement= ruleStatement EOF ) | ||
389 | // InternalSolverLanguageParser.g:145:2: iv_ruleStatement= ruleStatement EOF | ||
390 | { | ||
391 | newCompositeNode(grammarAccess.getStatementRule()); | ||
392 | pushFollow(FOLLOW_1); | ||
393 | iv_ruleStatement=ruleStatement(); | ||
394 | |||
395 | state._fsp--; | ||
396 | |||
397 | current =iv_ruleStatement; | ||
398 | match(input,EOF,FOLLOW_2); | ||
399 | |||
400 | } | ||
401 | |||
402 | } | ||
403 | |||
404 | catch (RecognitionException re) { | ||
405 | recover(input,re); | ||
406 | appendSkippedTokens(); | ||
407 | } | ||
408 | finally { | ||
409 | } | ||
410 | return current; | ||
411 | } | ||
412 | // $ANTLR end "entryRuleStatement" | ||
413 | |||
414 | |||
415 | // $ANTLR start "ruleStatement" | ||
416 | // InternalSolverLanguageParser.g:151:1: ruleStatement returns [EObject current=null] : (this_AssertionOrDefinition_0= ruleAssertionOrDefinition | this_PredicateDefinition_1= rulePredicateDefinition | this_UnnamedErrorPredicateDefintion_2= ruleUnnamedErrorPredicateDefintion | this_DefaultAssertion_3= ruleDefaultAssertion | this_FunctionDefinition_4= ruleFunctionDefinition | this_Attribute_5= ruleAttribute | this_ExternDeclaration_6= ruleExternDeclaration | this_ScopeDeclaration_7= ruleScopeDeclaration | this_ObjectiveDeclaration_8= ruleObjectiveDeclaration | this_ClassDeclaration_9= ruleClassDeclaration | this_EnumDeclaration_10= ruleEnumDeclaration ) ; | ||
417 | public final EObject ruleStatement() throws RecognitionException { | ||
418 | EObject current = null; | ||
419 | |||
420 | EObject this_AssertionOrDefinition_0 = null; | ||
421 | |||
422 | EObject this_PredicateDefinition_1 = null; | ||
423 | |||
424 | EObject this_UnnamedErrorPredicateDefintion_2 = null; | ||
425 | |||
426 | EObject this_DefaultAssertion_3 = null; | ||
427 | |||
428 | EObject this_FunctionDefinition_4 = null; | ||
429 | |||
430 | EObject this_Attribute_5 = null; | ||
431 | |||
432 | EObject this_ExternDeclaration_6 = null; | ||
433 | |||
434 | EObject this_ScopeDeclaration_7 = null; | ||
435 | |||
436 | EObject this_ObjectiveDeclaration_8 = null; | ||
437 | |||
438 | EObject this_ClassDeclaration_9 = null; | ||
439 | |||
440 | EObject this_EnumDeclaration_10 = null; | ||
441 | |||
442 | |||
443 | |||
444 | enterRule(); | ||
445 | |||
446 | try { | ||
447 | // InternalSolverLanguageParser.g:157:2: ( (this_AssertionOrDefinition_0= ruleAssertionOrDefinition | this_PredicateDefinition_1= rulePredicateDefinition | this_UnnamedErrorPredicateDefintion_2= ruleUnnamedErrorPredicateDefintion | this_DefaultAssertion_3= ruleDefaultAssertion | this_FunctionDefinition_4= ruleFunctionDefinition | this_Attribute_5= ruleAttribute | this_ExternDeclaration_6= ruleExternDeclaration | this_ScopeDeclaration_7= ruleScopeDeclaration | this_ObjectiveDeclaration_8= ruleObjectiveDeclaration | this_ClassDeclaration_9= ruleClassDeclaration | this_EnumDeclaration_10= ruleEnumDeclaration ) ) | ||
448 | // InternalSolverLanguageParser.g:158:2: (this_AssertionOrDefinition_0= ruleAssertionOrDefinition | this_PredicateDefinition_1= rulePredicateDefinition | this_UnnamedErrorPredicateDefintion_2= ruleUnnamedErrorPredicateDefintion | this_DefaultAssertion_3= ruleDefaultAssertion | this_FunctionDefinition_4= ruleFunctionDefinition | this_Attribute_5= ruleAttribute | this_ExternDeclaration_6= ruleExternDeclaration | this_ScopeDeclaration_7= ruleScopeDeclaration | this_ObjectiveDeclaration_8= ruleObjectiveDeclaration | this_ClassDeclaration_9= ruleClassDeclaration | this_EnumDeclaration_10= ruleEnumDeclaration ) | ||
449 | { | ||
450 | // InternalSolverLanguageParser.g:158:2: (this_AssertionOrDefinition_0= ruleAssertionOrDefinition | this_PredicateDefinition_1= rulePredicateDefinition | this_UnnamedErrorPredicateDefintion_2= ruleUnnamedErrorPredicateDefintion | this_DefaultAssertion_3= ruleDefaultAssertion | this_FunctionDefinition_4= ruleFunctionDefinition | this_Attribute_5= ruleAttribute | this_ExternDeclaration_6= ruleExternDeclaration | this_ScopeDeclaration_7= ruleScopeDeclaration | this_ObjectiveDeclaration_8= ruleObjectiveDeclaration | this_ClassDeclaration_9= ruleClassDeclaration | this_EnumDeclaration_10= ruleEnumDeclaration ) | ||
451 | int alt4=11; | ||
452 | alt4 = dfa4.predict(input); | ||
453 | switch (alt4) { | ||
454 | case 1 : | ||
455 | // InternalSolverLanguageParser.g:159:3: this_AssertionOrDefinition_0= ruleAssertionOrDefinition | ||
456 | { | ||
457 | |||
458 | newCompositeNode(grammarAccess.getStatementAccess().getAssertionOrDefinitionParserRuleCall_0()); | ||
459 | |||
460 | pushFollow(FOLLOW_2); | ||
461 | this_AssertionOrDefinition_0=ruleAssertionOrDefinition(); | ||
462 | |||
463 | state._fsp--; | ||
464 | |||
465 | |||
466 | current = this_AssertionOrDefinition_0; | ||
467 | afterParserOrEnumRuleCall(); | ||
468 | |||
469 | |||
470 | } | ||
471 | break; | ||
472 | case 2 : | ||
473 | // InternalSolverLanguageParser.g:168:3: this_PredicateDefinition_1= rulePredicateDefinition | ||
474 | { | ||
475 | |||
476 | newCompositeNode(grammarAccess.getStatementAccess().getPredicateDefinitionParserRuleCall_1()); | ||
477 | |||
478 | pushFollow(FOLLOW_2); | ||
479 | this_PredicateDefinition_1=rulePredicateDefinition(); | ||
480 | |||
481 | state._fsp--; | ||
482 | |||
483 | |||
484 | current = this_PredicateDefinition_1; | ||
485 | afterParserOrEnumRuleCall(); | ||
486 | |||
487 | |||
488 | } | ||
489 | break; | ||
490 | case 3 : | ||
491 | // InternalSolverLanguageParser.g:177:3: this_UnnamedErrorPredicateDefintion_2= ruleUnnamedErrorPredicateDefintion | ||
492 | { | ||
493 | |||
494 | newCompositeNode(grammarAccess.getStatementAccess().getUnnamedErrorPredicateDefintionParserRuleCall_2()); | ||
495 | |||
496 | pushFollow(FOLLOW_2); | ||
497 | this_UnnamedErrorPredicateDefintion_2=ruleUnnamedErrorPredicateDefintion(); | ||
498 | |||
499 | state._fsp--; | ||
500 | |||
501 | |||
502 | current = this_UnnamedErrorPredicateDefintion_2; | ||
503 | afterParserOrEnumRuleCall(); | ||
504 | |||
505 | |||
506 | } | ||
507 | break; | ||
508 | case 4 : | ||
509 | // InternalSolverLanguageParser.g:186:3: this_DefaultAssertion_3= ruleDefaultAssertion | ||
510 | { | ||
511 | |||
512 | newCompositeNode(grammarAccess.getStatementAccess().getDefaultAssertionParserRuleCall_3()); | ||
513 | |||
514 | pushFollow(FOLLOW_2); | ||
515 | this_DefaultAssertion_3=ruleDefaultAssertion(); | ||
516 | |||
517 | state._fsp--; | ||
518 | |||
519 | |||
520 | current = this_DefaultAssertion_3; | ||
521 | afterParserOrEnumRuleCall(); | ||
522 | |||
523 | |||
524 | } | ||
525 | break; | ||
526 | case 5 : | ||
527 | // InternalSolverLanguageParser.g:195:3: this_FunctionDefinition_4= ruleFunctionDefinition | ||
528 | { | ||
529 | |||
530 | newCompositeNode(grammarAccess.getStatementAccess().getFunctionDefinitionParserRuleCall_4()); | ||
531 | |||
532 | pushFollow(FOLLOW_2); | ||
533 | this_FunctionDefinition_4=ruleFunctionDefinition(); | ||
534 | |||
535 | state._fsp--; | ||
536 | |||
537 | |||
538 | current = this_FunctionDefinition_4; | ||
539 | afterParserOrEnumRuleCall(); | ||
540 | |||
541 | |||
542 | } | ||
543 | break; | ||
544 | case 6 : | ||
545 | // InternalSolverLanguageParser.g:204:3: this_Attribute_5= ruleAttribute | ||
546 | { | ||
547 | |||
548 | newCompositeNode(grammarAccess.getStatementAccess().getAttributeParserRuleCall_5()); | ||
549 | |||
550 | pushFollow(FOLLOW_2); | ||
551 | this_Attribute_5=ruleAttribute(); | ||
552 | |||
553 | state._fsp--; | ||
554 | |||
555 | |||
556 | current = this_Attribute_5; | ||
557 | afterParserOrEnumRuleCall(); | ||
558 | |||
559 | |||
560 | } | ||
561 | break; | ||
562 | case 7 : | ||
563 | // InternalSolverLanguageParser.g:213:3: this_ExternDeclaration_6= ruleExternDeclaration | ||
564 | { | ||
565 | |||
566 | newCompositeNode(grammarAccess.getStatementAccess().getExternDeclarationParserRuleCall_6()); | ||
567 | |||
568 | pushFollow(FOLLOW_2); | ||
569 | this_ExternDeclaration_6=ruleExternDeclaration(); | ||
570 | |||
571 | state._fsp--; | ||
572 | |||
573 | |||
574 | current = this_ExternDeclaration_6; | ||
575 | afterParserOrEnumRuleCall(); | ||
576 | |||
577 | |||
578 | } | ||
579 | break; | ||
580 | case 8 : | ||
581 | // InternalSolverLanguageParser.g:222:3: this_ScopeDeclaration_7= ruleScopeDeclaration | ||
582 | { | ||
583 | |||
584 | newCompositeNode(grammarAccess.getStatementAccess().getScopeDeclarationParserRuleCall_7()); | ||
585 | |||
586 | pushFollow(FOLLOW_2); | ||
587 | this_ScopeDeclaration_7=ruleScopeDeclaration(); | ||
588 | |||
589 | state._fsp--; | ||
590 | |||
591 | |||
592 | current = this_ScopeDeclaration_7; | ||
593 | afterParserOrEnumRuleCall(); | ||
594 | |||
595 | |||
596 | } | ||
597 | break; | ||
598 | case 9 : | ||
599 | // InternalSolverLanguageParser.g:231:3: this_ObjectiveDeclaration_8= ruleObjectiveDeclaration | ||
600 | { | ||
601 | |||
602 | newCompositeNode(grammarAccess.getStatementAccess().getObjectiveDeclarationParserRuleCall_8()); | ||
603 | |||
604 | pushFollow(FOLLOW_2); | ||
605 | this_ObjectiveDeclaration_8=ruleObjectiveDeclaration(); | ||
606 | |||
607 | state._fsp--; | ||
608 | |||
609 | |||
610 | current = this_ObjectiveDeclaration_8; | ||
611 | afterParserOrEnumRuleCall(); | ||
612 | |||
613 | |||
614 | } | ||
615 | break; | ||
616 | case 10 : | ||
617 | // InternalSolverLanguageParser.g:240:3: this_ClassDeclaration_9= ruleClassDeclaration | ||
618 | { | ||
619 | |||
620 | newCompositeNode(grammarAccess.getStatementAccess().getClassDeclarationParserRuleCall_9()); | ||
621 | |||
622 | pushFollow(FOLLOW_2); | ||
623 | this_ClassDeclaration_9=ruleClassDeclaration(); | ||
624 | |||
625 | state._fsp--; | ||
626 | |||
627 | |||
628 | current = this_ClassDeclaration_9; | ||
629 | afterParserOrEnumRuleCall(); | ||
630 | |||
631 | |||
632 | } | ||
633 | break; | ||
634 | case 11 : | ||
635 | // InternalSolverLanguageParser.g:249:3: this_EnumDeclaration_10= ruleEnumDeclaration | ||
636 | { | ||
637 | |||
638 | newCompositeNode(grammarAccess.getStatementAccess().getEnumDeclarationParserRuleCall_10()); | ||
639 | |||
640 | pushFollow(FOLLOW_2); | ||
641 | this_EnumDeclaration_10=ruleEnumDeclaration(); | ||
642 | |||
643 | state._fsp--; | ||
644 | |||
645 | |||
646 | current = this_EnumDeclaration_10; | ||
647 | afterParserOrEnumRuleCall(); | ||
648 | |||
649 | |||
650 | } | ||
651 | break; | ||
652 | |||
653 | } | ||
654 | |||
655 | |||
656 | } | ||
657 | |||
658 | |||
659 | leaveRule(); | ||
660 | |||
661 | } | ||
662 | |||
663 | catch (RecognitionException re) { | ||
664 | recover(input,re); | ||
665 | appendSkippedTokens(); | ||
666 | } | ||
667 | finally { | ||
668 | } | ||
669 | return current; | ||
670 | } | ||
671 | // $ANTLR end "ruleStatement" | ||
672 | |||
673 | |||
674 | // $ANTLR start "entryRuleImport" | ||
675 | // InternalSolverLanguageParser.g:261:1: entryRuleImport returns [EObject current=null] : iv_ruleImport= ruleImport EOF ; | ||
676 | public final EObject entryRuleImport() throws RecognitionException { | ||
677 | EObject current = null; | ||
678 | |||
679 | EObject iv_ruleImport = null; | ||
680 | |||
681 | |||
682 | try { | ||
683 | // InternalSolverLanguageParser.g:261:47: (iv_ruleImport= ruleImport EOF ) | ||
684 | // InternalSolverLanguageParser.g:262:2: iv_ruleImport= ruleImport EOF | ||
685 | { | ||
686 | newCompositeNode(grammarAccess.getImportRule()); | ||
687 | pushFollow(FOLLOW_1); | ||
688 | iv_ruleImport=ruleImport(); | ||
689 | |||
690 | state._fsp--; | ||
691 | |||
692 | current =iv_ruleImport; | ||
693 | match(input,EOF,FOLLOW_2); | ||
694 | |||
695 | } | ||
696 | |||
697 | } | ||
698 | |||
699 | catch (RecognitionException re) { | ||
700 | recover(input,re); | ||
701 | appendSkippedTokens(); | ||
702 | } | ||
703 | finally { | ||
704 | } | ||
705 | return current; | ||
706 | } | ||
707 | // $ANTLR end "entryRuleImport" | ||
708 | |||
709 | |||
710 | // $ANTLR start "ruleImport" | ||
711 | // InternalSolverLanguageParser.g:268:1: ruleImport returns [EObject current=null] : (this_UriImport_0= ruleUriImport | this_NamespaceImport_1= ruleNamespaceImport ) ; | ||
712 | public final EObject ruleImport() throws RecognitionException { | ||
713 | EObject current = null; | ||
714 | |||
715 | EObject this_UriImport_0 = null; | ||
716 | |||
717 | EObject this_NamespaceImport_1 = null; | ||
718 | |||
719 | |||
720 | |||
721 | enterRule(); | ||
722 | |||
723 | try { | ||
724 | // InternalSolverLanguageParser.g:274:2: ( (this_UriImport_0= ruleUriImport | this_NamespaceImport_1= ruleNamespaceImport ) ) | ||
725 | // InternalSolverLanguageParser.g:275:2: (this_UriImport_0= ruleUriImport | this_NamespaceImport_1= ruleNamespaceImport ) | ||
726 | { | ||
727 | // InternalSolverLanguageParser.g:275:2: (this_UriImport_0= ruleUriImport | this_NamespaceImport_1= ruleNamespaceImport ) | ||
728 | int alt5=2; | ||
729 | int LA5_0 = input.LA(1); | ||
730 | |||
731 | if ( (LA5_0==Import) ) { | ||
732 | int LA5_1 = input.LA(2); | ||
733 | |||
734 | if ( (LA5_1==RULE_STRING) ) { | ||
735 | alt5=1; | ||
736 | } | ||
737 | else if ( (LA5_1==Object||LA5_1==RULE_QUOTED_ID||LA5_1==RULE_ID) ) { | ||
738 | alt5=2; | ||
739 | } | ||
740 | else { | ||
741 | NoViableAltException nvae = | ||
742 | new NoViableAltException("", 5, 1, input); | ||
743 | |||
744 | throw nvae; | ||
745 | } | ||
746 | } | ||
747 | else { | ||
748 | NoViableAltException nvae = | ||
749 | new NoViableAltException("", 5, 0, input); | ||
750 | |||
751 | throw nvae; | ||
752 | } | ||
753 | switch (alt5) { | ||
754 | case 1 : | ||
755 | // InternalSolverLanguageParser.g:276:3: this_UriImport_0= ruleUriImport | ||
756 | { | ||
757 | |||
758 | newCompositeNode(grammarAccess.getImportAccess().getUriImportParserRuleCall_0()); | ||
759 | |||
760 | pushFollow(FOLLOW_2); | ||
761 | this_UriImport_0=ruleUriImport(); | ||
762 | |||
763 | state._fsp--; | ||
764 | |||
765 | |||
766 | current = this_UriImport_0; | ||
767 | afterParserOrEnumRuleCall(); | ||
768 | |||
769 | |||
770 | } | ||
771 | break; | ||
772 | case 2 : | ||
773 | // InternalSolverLanguageParser.g:285:3: this_NamespaceImport_1= ruleNamespaceImport | ||
774 | { | ||
775 | |||
776 | newCompositeNode(grammarAccess.getImportAccess().getNamespaceImportParserRuleCall_1()); | ||
777 | |||
778 | pushFollow(FOLLOW_2); | ||
779 | this_NamespaceImport_1=ruleNamespaceImport(); | ||
780 | |||
781 | state._fsp--; | ||
782 | |||
783 | |||
784 | current = this_NamespaceImport_1; | ||
785 | afterParserOrEnumRuleCall(); | ||
786 | |||
787 | |||
788 | } | ||
789 | break; | ||
790 | |||
791 | } | ||
792 | |||
793 | |||
794 | } | ||
795 | |||
796 | |||
797 | leaveRule(); | ||
798 | |||
799 | } | ||
800 | |||
801 | catch (RecognitionException re) { | ||
802 | recover(input,re); | ||
803 | appendSkippedTokens(); | ||
804 | } | ||
805 | finally { | ||
806 | } | ||
807 | return current; | ||
808 | } | ||
809 | // $ANTLR end "ruleImport" | ||
810 | |||
811 | |||
812 | // $ANTLR start "entryRuleUriImport" | ||
813 | // InternalSolverLanguageParser.g:297:1: entryRuleUriImport returns [EObject current=null] : iv_ruleUriImport= ruleUriImport EOF ; | ||
814 | public final EObject entryRuleUriImport() throws RecognitionException { | ||
815 | EObject current = null; | ||
816 | |||
817 | EObject iv_ruleUriImport = null; | ||
818 | |||
819 | |||
820 | try { | ||
821 | // InternalSolverLanguageParser.g:297:50: (iv_ruleUriImport= ruleUriImport EOF ) | ||
822 | // InternalSolverLanguageParser.g:298:2: iv_ruleUriImport= ruleUriImport EOF | ||
823 | { | ||
824 | newCompositeNode(grammarAccess.getUriImportRule()); | ||
825 | pushFollow(FOLLOW_1); | ||
826 | iv_ruleUriImport=ruleUriImport(); | ||
827 | |||
828 | state._fsp--; | ||
829 | |||
830 | current =iv_ruleUriImport; | ||
831 | match(input,EOF,FOLLOW_2); | ||
832 | |||
833 | } | ||
834 | |||
835 | } | ||
836 | |||
837 | catch (RecognitionException re) { | ||
838 | recover(input,re); | ||
839 | appendSkippedTokens(); | ||
840 | } | ||
841 | finally { | ||
842 | } | ||
843 | return current; | ||
844 | } | ||
845 | // $ANTLR end "entryRuleUriImport" | ||
846 | |||
847 | |||
848 | // $ANTLR start "ruleUriImport" | ||
849 | // InternalSolverLanguageParser.g:304:1: ruleUriImport returns [EObject current=null] : (otherlv_0= Import ( (lv_uri_1_0= RULE_STRING ) ) (otherlv_2= As ( (lv_alias_3_0= ruleQualifiedName ) ) ) this_FULL_STOP_4= RULE_FULL_STOP ) ; | ||
850 | public final EObject ruleUriImport() throws RecognitionException { | ||
851 | EObject current = null; | ||
852 | |||
853 | Token otherlv_0=null; | ||
854 | Token lv_uri_1_0=null; | ||
855 | Token otherlv_2=null; | ||
856 | Token this_FULL_STOP_4=null; | ||
857 | AntlrDatatypeRuleToken lv_alias_3_0 = null; | ||
858 | |||
859 | |||
860 | |||
861 | enterRule(); | ||
862 | |||
863 | try { | ||
864 | // InternalSolverLanguageParser.g:310:2: ( (otherlv_0= Import ( (lv_uri_1_0= RULE_STRING ) ) (otherlv_2= As ( (lv_alias_3_0= ruleQualifiedName ) ) ) this_FULL_STOP_4= RULE_FULL_STOP ) ) | ||
865 | // InternalSolverLanguageParser.g:311:2: (otherlv_0= Import ( (lv_uri_1_0= RULE_STRING ) ) (otherlv_2= As ( (lv_alias_3_0= ruleQualifiedName ) ) ) this_FULL_STOP_4= RULE_FULL_STOP ) | ||
866 | { | ||
867 | // InternalSolverLanguageParser.g:311:2: (otherlv_0= Import ( (lv_uri_1_0= RULE_STRING ) ) (otherlv_2= As ( (lv_alias_3_0= ruleQualifiedName ) ) ) this_FULL_STOP_4= RULE_FULL_STOP ) | ||
868 | // InternalSolverLanguageParser.g:312:3: otherlv_0= Import ( (lv_uri_1_0= RULE_STRING ) ) (otherlv_2= As ( (lv_alias_3_0= ruleQualifiedName ) ) ) this_FULL_STOP_4= RULE_FULL_STOP | ||
869 | { | ||
870 | otherlv_0=(Token)match(input,Import,FOLLOW_7); | ||
871 | |||
872 | newLeafNode(otherlv_0, grammarAccess.getUriImportAccess().getImportKeyword_0()); | ||
873 | |||
874 | // InternalSolverLanguageParser.g:316:3: ( (lv_uri_1_0= RULE_STRING ) ) | ||
875 | // InternalSolverLanguageParser.g:317:4: (lv_uri_1_0= RULE_STRING ) | ||
876 | { | ||
877 | // InternalSolverLanguageParser.g:317:4: (lv_uri_1_0= RULE_STRING ) | ||
878 | // InternalSolverLanguageParser.g:318:5: lv_uri_1_0= RULE_STRING | ||
879 | { | ||
880 | lv_uri_1_0=(Token)match(input,RULE_STRING,FOLLOW_8); | ||
881 | |||
882 | newLeafNode(lv_uri_1_0, grammarAccess.getUriImportAccess().getUriSTRINGTerminalRuleCall_1_0()); | ||
883 | |||
884 | |||
885 | if (current==null) { | ||
886 | current = createModelElement(grammarAccess.getUriImportRule()); | ||
887 | } | ||
888 | setWithLastConsumed( | ||
889 | current, | ||
890 | "uri", | ||
891 | lv_uri_1_0, | ||
892 | "org.eclipse.viatra.solver.language.SolverLanguage.STRING"); | ||
893 | |||
894 | |||
895 | } | ||
896 | |||
897 | |||
898 | } | ||
899 | |||
900 | // InternalSolverLanguageParser.g:334:3: (otherlv_2= As ( (lv_alias_3_0= ruleQualifiedName ) ) ) | ||
901 | // InternalSolverLanguageParser.g:335:4: otherlv_2= As ( (lv_alias_3_0= ruleQualifiedName ) ) | ||
902 | { | ||
903 | otherlv_2=(Token)match(input,As,FOLLOW_3); | ||
904 | |||
905 | newLeafNode(otherlv_2, grammarAccess.getUriImportAccess().getAsKeyword_2_0()); | ||
906 | |||
907 | // InternalSolverLanguageParser.g:339:4: ( (lv_alias_3_0= ruleQualifiedName ) ) | ||
908 | // InternalSolverLanguageParser.g:340:5: (lv_alias_3_0= ruleQualifiedName ) | ||
909 | { | ||
910 | // InternalSolverLanguageParser.g:340:5: (lv_alias_3_0= ruleQualifiedName ) | ||
911 | // InternalSolverLanguageParser.g:341:6: lv_alias_3_0= ruleQualifiedName | ||
912 | { | ||
913 | |||
914 | newCompositeNode(grammarAccess.getUriImportAccess().getAliasQualifiedNameParserRuleCall_2_1_0()); | ||
915 | |||
916 | pushFollow(FOLLOW_4); | ||
917 | lv_alias_3_0=ruleQualifiedName(); | ||
918 | |||
919 | state._fsp--; | ||
920 | |||
921 | |||
922 | if (current==null) { | ||
923 | current = createModelElementForParent(grammarAccess.getUriImportRule()); | ||
924 | } | ||
925 | set( | ||
926 | current, | ||
927 | "alias", | ||
928 | lv_alias_3_0, | ||
929 | "org.eclipse.viatra.solver.language.SolverLanguage.QualifiedName"); | ||
930 | afterParserOrEnumRuleCall(); | ||
931 | |||
932 | |||
933 | } | ||
934 | |||
935 | |||
936 | } | ||
937 | |||
938 | |||
939 | } | ||
940 | |||
941 | this_FULL_STOP_4=(Token)match(input,RULE_FULL_STOP,FOLLOW_2); | ||
942 | |||
943 | newLeafNode(this_FULL_STOP_4, grammarAccess.getUriImportAccess().getFULL_STOPTerminalRuleCall_3()); | ||
944 | |||
945 | |||
946 | } | ||
947 | |||
948 | |||
949 | } | ||
950 | |||
951 | |||
952 | leaveRule(); | ||
953 | |||
954 | } | ||
955 | |||
956 | catch (RecognitionException re) { | ||
957 | recover(input,re); | ||
958 | appendSkippedTokens(); | ||
959 | } | ||
960 | finally { | ||
961 | } | ||
962 | return current; | ||
963 | } | ||
964 | // $ANTLR end "ruleUriImport" | ||
965 | |||
966 | |||
967 | // $ANTLR start "entryRuleNamespaceImport" | ||
968 | // InternalSolverLanguageParser.g:367:1: entryRuleNamespaceImport returns [EObject current=null] : iv_ruleNamespaceImport= ruleNamespaceImport EOF ; | ||
969 | public final EObject entryRuleNamespaceImport() throws RecognitionException { | ||
970 | EObject current = null; | ||
971 | |||
972 | EObject iv_ruleNamespaceImport = null; | ||
973 | |||
974 | |||
975 | try { | ||
976 | // InternalSolverLanguageParser.g:367:56: (iv_ruleNamespaceImport= ruleNamespaceImport EOF ) | ||
977 | // InternalSolverLanguageParser.g:368:2: iv_ruleNamespaceImport= ruleNamespaceImport EOF | ||
978 | { | ||
979 | newCompositeNode(grammarAccess.getNamespaceImportRule()); | ||
980 | pushFollow(FOLLOW_1); | ||
981 | iv_ruleNamespaceImport=ruleNamespaceImport(); | ||
982 | |||
983 | state._fsp--; | ||
984 | |||
985 | current =iv_ruleNamespaceImport; | ||
986 | match(input,EOF,FOLLOW_2); | ||
987 | |||
988 | } | ||
989 | |||
990 | } | ||
991 | |||
992 | catch (RecognitionException re) { | ||
993 | recover(input,re); | ||
994 | appendSkippedTokens(); | ||
995 | } | ||
996 | finally { | ||
997 | } | ||
998 | return current; | ||
999 | } | ||
1000 | // $ANTLR end "entryRuleNamespaceImport" | ||
1001 | |||
1002 | |||
1003 | // $ANTLR start "ruleNamespaceImport" | ||
1004 | // InternalSolverLanguageParser.g:374:1: ruleNamespaceImport returns [EObject current=null] : (otherlv_0= Import ( (lv_importedNamespace_1_0= ruleQualifiedName ) ) (otherlv_2= As ( (lv_alias_3_0= ruleQualifiedName ) ) ) this_FULL_STOP_4= RULE_FULL_STOP ) ; | ||
1005 | public final EObject ruleNamespaceImport() throws RecognitionException { | ||
1006 | EObject current = null; | ||
1007 | |||
1008 | Token otherlv_0=null; | ||
1009 | Token otherlv_2=null; | ||
1010 | Token this_FULL_STOP_4=null; | ||
1011 | AntlrDatatypeRuleToken lv_importedNamespace_1_0 = null; | ||
1012 | |||
1013 | AntlrDatatypeRuleToken lv_alias_3_0 = null; | ||
1014 | |||
1015 | |||
1016 | |||
1017 | enterRule(); | ||
1018 | |||
1019 | try { | ||
1020 | // InternalSolverLanguageParser.g:380:2: ( (otherlv_0= Import ( (lv_importedNamespace_1_0= ruleQualifiedName ) ) (otherlv_2= As ( (lv_alias_3_0= ruleQualifiedName ) ) ) this_FULL_STOP_4= RULE_FULL_STOP ) ) | ||
1021 | // InternalSolverLanguageParser.g:381:2: (otherlv_0= Import ( (lv_importedNamespace_1_0= ruleQualifiedName ) ) (otherlv_2= As ( (lv_alias_3_0= ruleQualifiedName ) ) ) this_FULL_STOP_4= RULE_FULL_STOP ) | ||
1022 | { | ||
1023 | // InternalSolverLanguageParser.g:381:2: (otherlv_0= Import ( (lv_importedNamespace_1_0= ruleQualifiedName ) ) (otherlv_2= As ( (lv_alias_3_0= ruleQualifiedName ) ) ) this_FULL_STOP_4= RULE_FULL_STOP ) | ||
1024 | // InternalSolverLanguageParser.g:382:3: otherlv_0= Import ( (lv_importedNamespace_1_0= ruleQualifiedName ) ) (otherlv_2= As ( (lv_alias_3_0= ruleQualifiedName ) ) ) this_FULL_STOP_4= RULE_FULL_STOP | ||
1025 | { | ||
1026 | otherlv_0=(Token)match(input,Import,FOLLOW_3); | ||
1027 | |||
1028 | newLeafNode(otherlv_0, grammarAccess.getNamespaceImportAccess().getImportKeyword_0()); | ||
1029 | |||
1030 | // InternalSolverLanguageParser.g:386:3: ( (lv_importedNamespace_1_0= ruleQualifiedName ) ) | ||
1031 | // InternalSolverLanguageParser.g:387:4: (lv_importedNamespace_1_0= ruleQualifiedName ) | ||
1032 | { | ||
1033 | // InternalSolverLanguageParser.g:387:4: (lv_importedNamespace_1_0= ruleQualifiedName ) | ||
1034 | // InternalSolverLanguageParser.g:388:5: lv_importedNamespace_1_0= ruleQualifiedName | ||
1035 | { | ||
1036 | |||
1037 | newCompositeNode(grammarAccess.getNamespaceImportAccess().getImportedNamespaceQualifiedNameParserRuleCall_1_0()); | ||
1038 | |||
1039 | pushFollow(FOLLOW_8); | ||
1040 | lv_importedNamespace_1_0=ruleQualifiedName(); | ||
1041 | |||
1042 | state._fsp--; | ||
1043 | |||
1044 | |||
1045 | if (current==null) { | ||
1046 | current = createModelElementForParent(grammarAccess.getNamespaceImportRule()); | ||
1047 | } | ||
1048 | set( | ||
1049 | current, | ||
1050 | "importedNamespace", | ||
1051 | lv_importedNamespace_1_0, | ||
1052 | "org.eclipse.viatra.solver.language.SolverLanguage.QualifiedName"); | ||
1053 | afterParserOrEnumRuleCall(); | ||
1054 | |||
1055 | |||
1056 | } | ||
1057 | |||
1058 | |||
1059 | } | ||
1060 | |||
1061 | // InternalSolverLanguageParser.g:405:3: (otherlv_2= As ( (lv_alias_3_0= ruleQualifiedName ) ) ) | ||
1062 | // InternalSolverLanguageParser.g:406:4: otherlv_2= As ( (lv_alias_3_0= ruleQualifiedName ) ) | ||
1063 | { | ||
1064 | otherlv_2=(Token)match(input,As,FOLLOW_3); | ||
1065 | |||
1066 | newLeafNode(otherlv_2, grammarAccess.getNamespaceImportAccess().getAsKeyword_2_0()); | ||
1067 | |||
1068 | // InternalSolverLanguageParser.g:410:4: ( (lv_alias_3_0= ruleQualifiedName ) ) | ||
1069 | // InternalSolverLanguageParser.g:411:5: (lv_alias_3_0= ruleQualifiedName ) | ||
1070 | { | ||
1071 | // InternalSolverLanguageParser.g:411:5: (lv_alias_3_0= ruleQualifiedName ) | ||
1072 | // InternalSolverLanguageParser.g:412:6: lv_alias_3_0= ruleQualifiedName | ||
1073 | { | ||
1074 | |||
1075 | newCompositeNode(grammarAccess.getNamespaceImportAccess().getAliasQualifiedNameParserRuleCall_2_1_0()); | ||
1076 | |||
1077 | pushFollow(FOLLOW_4); | ||
1078 | lv_alias_3_0=ruleQualifiedName(); | ||
1079 | |||
1080 | state._fsp--; | ||
1081 | |||
1082 | |||
1083 | if (current==null) { | ||
1084 | current = createModelElementForParent(grammarAccess.getNamespaceImportRule()); | ||
1085 | } | ||
1086 | set( | ||
1087 | current, | ||
1088 | "alias", | ||
1089 | lv_alias_3_0, | ||
1090 | "org.eclipse.viatra.solver.language.SolverLanguage.QualifiedName"); | ||
1091 | afterParserOrEnumRuleCall(); | ||
1092 | |||
1093 | |||
1094 | } | ||
1095 | |||
1096 | |||
1097 | } | ||
1098 | |||
1099 | |||
1100 | } | ||
1101 | |||
1102 | this_FULL_STOP_4=(Token)match(input,RULE_FULL_STOP,FOLLOW_2); | ||
1103 | |||
1104 | newLeafNode(this_FULL_STOP_4, grammarAccess.getNamespaceImportAccess().getFULL_STOPTerminalRuleCall_3()); | ||
1105 | |||
1106 | |||
1107 | } | ||
1108 | |||
1109 | |||
1110 | } | ||
1111 | |||
1112 | |||
1113 | leaveRule(); | ||
1114 | |||
1115 | } | ||
1116 | |||
1117 | catch (RecognitionException re) { | ||
1118 | recover(input,re); | ||
1119 | appendSkippedTokens(); | ||
1120 | } | ||
1121 | finally { | ||
1122 | } | ||
1123 | return current; | ||
1124 | } | ||
1125 | // $ANTLR end "ruleNamespaceImport" | ||
1126 | |||
1127 | |||
1128 | // $ANTLR start "entryRuleAssertionOrDefinition" | ||
1129 | // InternalSolverLanguageParser.g:438:1: entryRuleAssertionOrDefinition returns [EObject current=null] : iv_ruleAssertionOrDefinition= ruleAssertionOrDefinition EOF ; | ||
1130 | public final EObject entryRuleAssertionOrDefinition() throws RecognitionException { | ||
1131 | EObject current = null; | ||
1132 | |||
1133 | EObject iv_ruleAssertionOrDefinition = null; | ||
1134 | |||
1135 | |||
1136 | try { | ||
1137 | // InternalSolverLanguageParser.g:438:62: (iv_ruleAssertionOrDefinition= ruleAssertionOrDefinition EOF ) | ||
1138 | // InternalSolverLanguageParser.g:439:2: iv_ruleAssertionOrDefinition= ruleAssertionOrDefinition EOF | ||
1139 | { | ||
1140 | newCompositeNode(grammarAccess.getAssertionOrDefinitionRule()); | ||
1141 | pushFollow(FOLLOW_1); | ||
1142 | iv_ruleAssertionOrDefinition=ruleAssertionOrDefinition(); | ||
1143 | |||
1144 | state._fsp--; | ||
1145 | |||
1146 | current =iv_ruleAssertionOrDefinition; | ||
1147 | match(input,EOF,FOLLOW_2); | ||
1148 | |||
1149 | } | ||
1150 | |||
1151 | } | ||
1152 | |||
1153 | catch (RecognitionException re) { | ||
1154 | recover(input,re); | ||
1155 | appendSkippedTokens(); | ||
1156 | } | ||
1157 | finally { | ||
1158 | } | ||
1159 | return current; | ||
1160 | } | ||
1161 | // $ANTLR end "entryRuleAssertionOrDefinition" | ||
1162 | |||
1163 | |||
1164 | // $ANTLR start "ruleAssertionOrDefinition" | ||
1165 | // InternalSolverLanguageParser.g:445:1: ruleAssertionOrDefinition returns [EObject current=null] : (this_Expression_0= ruleExpression ( ( () (otherlv_2= Colon ( (lv_range_3_0= ruleExpression ) ) )? ) | ( () otherlv_5= ColonHyphenMinus ( (lv_body_6_0= ruleExpression ) ) ) | ( () otherlv_8= ColonEqualsSign ( (lv_body_9_0= ruleExpression ) ) ) ) this_FULL_STOP_10= RULE_FULL_STOP ) ; | ||
1166 | public final EObject ruleAssertionOrDefinition() throws RecognitionException { | ||
1167 | EObject current = null; | ||
1168 | |||
1169 | Token otherlv_2=null; | ||
1170 | Token otherlv_5=null; | ||
1171 | Token otherlv_8=null; | ||
1172 | Token this_FULL_STOP_10=null; | ||
1173 | EObject this_Expression_0 = null; | ||
1174 | |||
1175 | EObject lv_range_3_0 = null; | ||
1176 | |||
1177 | EObject lv_body_6_0 = null; | ||
1178 | |||
1179 | EObject lv_body_9_0 = null; | ||
1180 | |||
1181 | |||
1182 | |||
1183 | enterRule(); | ||
1184 | |||
1185 | try { | ||
1186 | // InternalSolverLanguageParser.g:451:2: ( (this_Expression_0= ruleExpression ( ( () (otherlv_2= Colon ( (lv_range_3_0= ruleExpression ) ) )? ) | ( () otherlv_5= ColonHyphenMinus ( (lv_body_6_0= ruleExpression ) ) ) | ( () otherlv_8= ColonEqualsSign ( (lv_body_9_0= ruleExpression ) ) ) ) this_FULL_STOP_10= RULE_FULL_STOP ) ) | ||
1187 | // InternalSolverLanguageParser.g:452:2: (this_Expression_0= ruleExpression ( ( () (otherlv_2= Colon ( (lv_range_3_0= ruleExpression ) ) )? ) | ( () otherlv_5= ColonHyphenMinus ( (lv_body_6_0= ruleExpression ) ) ) | ( () otherlv_8= ColonEqualsSign ( (lv_body_9_0= ruleExpression ) ) ) ) this_FULL_STOP_10= RULE_FULL_STOP ) | ||
1188 | { | ||
1189 | // InternalSolverLanguageParser.g:452:2: (this_Expression_0= ruleExpression ( ( () (otherlv_2= Colon ( (lv_range_3_0= ruleExpression ) ) )? ) | ( () otherlv_5= ColonHyphenMinus ( (lv_body_6_0= ruleExpression ) ) ) | ( () otherlv_8= ColonEqualsSign ( (lv_body_9_0= ruleExpression ) ) ) ) this_FULL_STOP_10= RULE_FULL_STOP ) | ||
1190 | // InternalSolverLanguageParser.g:453:3: this_Expression_0= ruleExpression ( ( () (otherlv_2= Colon ( (lv_range_3_0= ruleExpression ) ) )? ) | ( () otherlv_5= ColonHyphenMinus ( (lv_body_6_0= ruleExpression ) ) ) | ( () otherlv_8= ColonEqualsSign ( (lv_body_9_0= ruleExpression ) ) ) ) this_FULL_STOP_10= RULE_FULL_STOP | ||
1191 | { | ||
1192 | |||
1193 | newCompositeNode(grammarAccess.getAssertionOrDefinitionAccess().getExpressionParserRuleCall_0()); | ||
1194 | |||
1195 | pushFollow(FOLLOW_9); | ||
1196 | this_Expression_0=ruleExpression(); | ||
1197 | |||
1198 | state._fsp--; | ||
1199 | |||
1200 | |||
1201 | current = this_Expression_0; | ||
1202 | afterParserOrEnumRuleCall(); | ||
1203 | |||
1204 | // InternalSolverLanguageParser.g:461:3: ( ( () (otherlv_2= Colon ( (lv_range_3_0= ruleExpression ) ) )? ) | ( () otherlv_5= ColonHyphenMinus ( (lv_body_6_0= ruleExpression ) ) ) | ( () otherlv_8= ColonEqualsSign ( (lv_body_9_0= ruleExpression ) ) ) ) | ||
1205 | int alt7=3; | ||
1206 | switch ( input.LA(1) ) { | ||
1207 | case Colon: | ||
1208 | case RULE_FULL_STOP: | ||
1209 | { | ||
1210 | alt7=1; | ||
1211 | } | ||
1212 | break; | ||
1213 | case ColonHyphenMinus: | ||
1214 | { | ||
1215 | alt7=2; | ||
1216 | } | ||
1217 | break; | ||
1218 | case ColonEqualsSign: | ||
1219 | { | ||
1220 | alt7=3; | ||
1221 | } | ||
1222 | break; | ||
1223 | default: | ||
1224 | NoViableAltException nvae = | ||
1225 | new NoViableAltException("", 7, 0, input); | ||
1226 | |||
1227 | throw nvae; | ||
1228 | } | ||
1229 | |||
1230 | switch (alt7) { | ||
1231 | case 1 : | ||
1232 | // InternalSolverLanguageParser.g:462:4: ( () (otherlv_2= Colon ( (lv_range_3_0= ruleExpression ) ) )? ) | ||
1233 | { | ||
1234 | // InternalSolverLanguageParser.g:462:4: ( () (otherlv_2= Colon ( (lv_range_3_0= ruleExpression ) ) )? ) | ||
1235 | // InternalSolverLanguageParser.g:463:5: () (otherlv_2= Colon ( (lv_range_3_0= ruleExpression ) ) )? | ||
1236 | { | ||
1237 | // InternalSolverLanguageParser.g:463:5: () | ||
1238 | // InternalSolverLanguageParser.g:464:6: | ||
1239 | { | ||
1240 | |||
1241 | current = forceCreateModelElementAndSet( | ||
1242 | grammarAccess.getAssertionOrDefinitionAccess().getAssertionExpressionAction_1_0_0(), | ||
1243 | current); | ||
1244 | |||
1245 | |||
1246 | } | ||
1247 | |||
1248 | // InternalSolverLanguageParser.g:470:5: (otherlv_2= Colon ( (lv_range_3_0= ruleExpression ) ) )? | ||
1249 | int alt6=2; | ||
1250 | int LA6_0 = input.LA(1); | ||
1251 | |||
1252 | if ( (LA6_0==Colon) ) { | ||
1253 | alt6=1; | ||
1254 | } | ||
1255 | switch (alt6) { | ||
1256 | case 1 : | ||
1257 | // InternalSolverLanguageParser.g:471:6: otherlv_2= Colon ( (lv_range_3_0= ruleExpression ) ) | ||
1258 | { | ||
1259 | otherlv_2=(Token)match(input,Colon,FOLLOW_10); | ||
1260 | |||
1261 | newLeafNode(otherlv_2, grammarAccess.getAssertionOrDefinitionAccess().getColonKeyword_1_0_1_0()); | ||
1262 | |||
1263 | // InternalSolverLanguageParser.g:475:6: ( (lv_range_3_0= ruleExpression ) ) | ||
1264 | // InternalSolverLanguageParser.g:476:7: (lv_range_3_0= ruleExpression ) | ||
1265 | { | ||
1266 | // InternalSolverLanguageParser.g:476:7: (lv_range_3_0= ruleExpression ) | ||
1267 | // InternalSolverLanguageParser.g:477:8: lv_range_3_0= ruleExpression | ||
1268 | { | ||
1269 | |||
1270 | newCompositeNode(grammarAccess.getAssertionOrDefinitionAccess().getRangeExpressionParserRuleCall_1_0_1_1_0()); | ||
1271 | |||
1272 | pushFollow(FOLLOW_4); | ||
1273 | lv_range_3_0=ruleExpression(); | ||
1274 | |||
1275 | state._fsp--; | ||
1276 | |||
1277 | |||
1278 | if (current==null) { | ||
1279 | current = createModelElementForParent(grammarAccess.getAssertionOrDefinitionRule()); | ||
1280 | } | ||
1281 | set( | ||
1282 | current, | ||
1283 | "range", | ||
1284 | lv_range_3_0, | ||
1285 | "org.eclipse.viatra.solver.language.SolverLanguage.Expression"); | ||
1286 | afterParserOrEnumRuleCall(); | ||
1287 | |||
1288 | |||
1289 | } | ||
1290 | |||
1291 | |||
1292 | } | ||
1293 | |||
1294 | |||
1295 | } | ||
1296 | break; | ||
1297 | |||
1298 | } | ||
1299 | |||
1300 | |||
1301 | } | ||
1302 | |||
1303 | |||
1304 | } | ||
1305 | break; | ||
1306 | case 2 : | ||
1307 | // InternalSolverLanguageParser.g:497:4: ( () otherlv_5= ColonHyphenMinus ( (lv_body_6_0= ruleExpression ) ) ) | ||
1308 | { | ||
1309 | // InternalSolverLanguageParser.g:497:4: ( () otherlv_5= ColonHyphenMinus ( (lv_body_6_0= ruleExpression ) ) ) | ||
1310 | // InternalSolverLanguageParser.g:498:5: () otherlv_5= ColonHyphenMinus ( (lv_body_6_0= ruleExpression ) ) | ||
1311 | { | ||
1312 | // InternalSolverLanguageParser.g:498:5: () | ||
1313 | // InternalSolverLanguageParser.g:499:6: | ||
1314 | { | ||
1315 | |||
1316 | current = forceCreateModelElementAndSet( | ||
1317 | grammarAccess.getAssertionOrDefinitionAccess().getPredicateDefinitionHeadAction_1_1_0(), | ||
1318 | current); | ||
1319 | |||
1320 | |||
1321 | } | ||
1322 | |||
1323 | otherlv_5=(Token)match(input,ColonHyphenMinus,FOLLOW_10); | ||
1324 | |||
1325 | newLeafNode(otherlv_5, grammarAccess.getAssertionOrDefinitionAccess().getColonHyphenMinusKeyword_1_1_1()); | ||
1326 | |||
1327 | // InternalSolverLanguageParser.g:509:5: ( (lv_body_6_0= ruleExpression ) ) | ||
1328 | // InternalSolverLanguageParser.g:510:6: (lv_body_6_0= ruleExpression ) | ||
1329 | { | ||
1330 | // InternalSolverLanguageParser.g:510:6: (lv_body_6_0= ruleExpression ) | ||
1331 | // InternalSolverLanguageParser.g:511:7: lv_body_6_0= ruleExpression | ||
1332 | { | ||
1333 | |||
1334 | newCompositeNode(grammarAccess.getAssertionOrDefinitionAccess().getBodyExpressionParserRuleCall_1_1_2_0()); | ||
1335 | |||
1336 | pushFollow(FOLLOW_4); | ||
1337 | lv_body_6_0=ruleExpression(); | ||
1338 | |||
1339 | state._fsp--; | ||
1340 | |||
1341 | |||
1342 | if (current==null) { | ||
1343 | current = createModelElementForParent(grammarAccess.getAssertionOrDefinitionRule()); | ||
1344 | } | ||
1345 | set( | ||
1346 | current, | ||
1347 | "body", | ||
1348 | lv_body_6_0, | ||
1349 | "org.eclipse.viatra.solver.language.SolverLanguage.Expression"); | ||
1350 | afterParserOrEnumRuleCall(); | ||
1351 | |||
1352 | |||
1353 | } | ||
1354 | |||
1355 | |||
1356 | } | ||
1357 | |||
1358 | |||
1359 | } | ||
1360 | |||
1361 | |||
1362 | } | ||
1363 | break; | ||
1364 | case 3 : | ||
1365 | // InternalSolverLanguageParser.g:530:4: ( () otherlv_8= ColonEqualsSign ( (lv_body_9_0= ruleExpression ) ) ) | ||
1366 | { | ||
1367 | // InternalSolverLanguageParser.g:530:4: ( () otherlv_8= ColonEqualsSign ( (lv_body_9_0= ruleExpression ) ) ) | ||
1368 | // InternalSolverLanguageParser.g:531:5: () otherlv_8= ColonEqualsSign ( (lv_body_9_0= ruleExpression ) ) | ||
1369 | { | ||
1370 | // InternalSolverLanguageParser.g:531:5: () | ||
1371 | // InternalSolverLanguageParser.g:532:6: | ||
1372 | { | ||
1373 | |||
1374 | current = forceCreateModelElementAndSet( | ||
1375 | grammarAccess.getAssertionOrDefinitionAccess().getFunctionDefinitionHeadAction_1_2_0(), | ||
1376 | current); | ||
1377 | |||
1378 | |||
1379 | } | ||
1380 | |||
1381 | otherlv_8=(Token)match(input,ColonEqualsSign,FOLLOW_10); | ||
1382 | |||
1383 | newLeafNode(otherlv_8, grammarAccess.getAssertionOrDefinitionAccess().getColonEqualsSignKeyword_1_2_1()); | ||
1384 | |||
1385 | // InternalSolverLanguageParser.g:542:5: ( (lv_body_9_0= ruleExpression ) ) | ||
1386 | // InternalSolverLanguageParser.g:543:6: (lv_body_9_0= ruleExpression ) | ||
1387 | { | ||
1388 | // InternalSolverLanguageParser.g:543:6: (lv_body_9_0= ruleExpression ) | ||
1389 | // InternalSolverLanguageParser.g:544:7: lv_body_9_0= ruleExpression | ||
1390 | { | ||
1391 | |||
1392 | newCompositeNode(grammarAccess.getAssertionOrDefinitionAccess().getBodyExpressionParserRuleCall_1_2_2_0()); | ||
1393 | |||
1394 | pushFollow(FOLLOW_4); | ||
1395 | lv_body_9_0=ruleExpression(); | ||
1396 | |||
1397 | state._fsp--; | ||
1398 | |||
1399 | |||
1400 | if (current==null) { | ||
1401 | current = createModelElementForParent(grammarAccess.getAssertionOrDefinitionRule()); | ||
1402 | } | ||
1403 | set( | ||
1404 | current, | ||
1405 | "body", | ||
1406 | lv_body_9_0, | ||
1407 | "org.eclipse.viatra.solver.language.SolverLanguage.Expression"); | ||
1408 | afterParserOrEnumRuleCall(); | ||
1409 | |||
1410 | |||
1411 | } | ||
1412 | |||
1413 | |||
1414 | } | ||
1415 | |||
1416 | |||
1417 | } | ||
1418 | |||
1419 | |||
1420 | } | ||
1421 | break; | ||
1422 | |||
1423 | } | ||
1424 | |||
1425 | this_FULL_STOP_10=(Token)match(input,RULE_FULL_STOP,FOLLOW_2); | ||
1426 | |||
1427 | newLeafNode(this_FULL_STOP_10, grammarAccess.getAssertionOrDefinitionAccess().getFULL_STOPTerminalRuleCall_2()); | ||
1428 | |||
1429 | |||
1430 | } | ||
1431 | |||
1432 | |||
1433 | } | ||
1434 | |||
1435 | |||
1436 | leaveRule(); | ||
1437 | |||
1438 | } | ||
1439 | |||
1440 | catch (RecognitionException re) { | ||
1441 | recover(input,re); | ||
1442 | appendSkippedTokens(); | ||
1443 | } | ||
1444 | finally { | ||
1445 | } | ||
1446 | return current; | ||
1447 | } | ||
1448 | // $ANTLR end "ruleAssertionOrDefinition" | ||
1449 | |||
1450 | |||
1451 | // $ANTLR start "entryRulePredicateDefinition" | ||
1452 | // InternalSolverLanguageParser.g:571:1: entryRulePredicateDefinition returns [EObject current=null] : iv_rulePredicateDefinition= rulePredicateDefinition EOF ; | ||
1453 | public final EObject entryRulePredicateDefinition() throws RecognitionException { | ||
1454 | EObject current = null; | ||
1455 | |||
1456 | EObject iv_rulePredicateDefinition = null; | ||
1457 | |||
1458 | |||
1459 | try { | ||
1460 | // InternalSolverLanguageParser.g:571:60: (iv_rulePredicateDefinition= rulePredicateDefinition EOF ) | ||
1461 | // InternalSolverLanguageParser.g:572:2: iv_rulePredicateDefinition= rulePredicateDefinition EOF | ||
1462 | { | ||
1463 | newCompositeNode(grammarAccess.getPredicateDefinitionRule()); | ||
1464 | pushFollow(FOLLOW_1); | ||
1465 | iv_rulePredicateDefinition=rulePredicateDefinition(); | ||
1466 | |||
1467 | state._fsp--; | ||
1468 | |||
1469 | current =iv_rulePredicateDefinition; | ||
1470 | match(input,EOF,FOLLOW_2); | ||
1471 | |||
1472 | } | ||
1473 | |||
1474 | } | ||
1475 | |||
1476 | catch (RecognitionException re) { | ||
1477 | recover(input,re); | ||
1478 | appendSkippedTokens(); | ||
1479 | } | ||
1480 | finally { | ||
1481 | } | ||
1482 | return current; | ||
1483 | } | ||
1484 | // $ANTLR end "entryRulePredicateDefinition" | ||
1485 | |||
1486 | |||
1487 | // $ANTLR start "rulePredicateDefinition" | ||
1488 | // InternalSolverLanguageParser.g:578:1: rulePredicateDefinition returns [EObject current=null] : ( ( ( ( (lv_functional_0_0= Functional ) ) ( (lv_error_1_0= Error ) )? ) | ( ( (lv_error_2_0= Error ) ) ( (lv_functional_3_0= Functional ) )? ) ) ( (lv_head_4_0= ruleCall ) ) otherlv_5= ColonHyphenMinus ( (lv_body_6_0= ruleExpression ) ) this_FULL_STOP_7= RULE_FULL_STOP ) ; | ||
1489 | public final EObject rulePredicateDefinition() throws RecognitionException { | ||
1490 | EObject current = null; | ||
1491 | |||
1492 | Token lv_functional_0_0=null; | ||
1493 | Token lv_error_1_0=null; | ||
1494 | Token lv_error_2_0=null; | ||
1495 | Token lv_functional_3_0=null; | ||
1496 | Token otherlv_5=null; | ||
1497 | Token this_FULL_STOP_7=null; | ||
1498 | EObject lv_head_4_0 = null; | ||
1499 | |||
1500 | EObject lv_body_6_0 = null; | ||
1501 | |||
1502 | |||
1503 | |||
1504 | enterRule(); | ||
1505 | |||
1506 | try { | ||
1507 | // InternalSolverLanguageParser.g:584:2: ( ( ( ( ( (lv_functional_0_0= Functional ) ) ( (lv_error_1_0= Error ) )? ) | ( ( (lv_error_2_0= Error ) ) ( (lv_functional_3_0= Functional ) )? ) ) ( (lv_head_4_0= ruleCall ) ) otherlv_5= ColonHyphenMinus ( (lv_body_6_0= ruleExpression ) ) this_FULL_STOP_7= RULE_FULL_STOP ) ) | ||
1508 | // InternalSolverLanguageParser.g:585:2: ( ( ( ( (lv_functional_0_0= Functional ) ) ( (lv_error_1_0= Error ) )? ) | ( ( (lv_error_2_0= Error ) ) ( (lv_functional_3_0= Functional ) )? ) ) ( (lv_head_4_0= ruleCall ) ) otherlv_5= ColonHyphenMinus ( (lv_body_6_0= ruleExpression ) ) this_FULL_STOP_7= RULE_FULL_STOP ) | ||
1509 | { | ||
1510 | // InternalSolverLanguageParser.g:585:2: ( ( ( ( (lv_functional_0_0= Functional ) ) ( (lv_error_1_0= Error ) )? ) | ( ( (lv_error_2_0= Error ) ) ( (lv_functional_3_0= Functional ) )? ) ) ( (lv_head_4_0= ruleCall ) ) otherlv_5= ColonHyphenMinus ( (lv_body_6_0= ruleExpression ) ) this_FULL_STOP_7= RULE_FULL_STOP ) | ||
1511 | // InternalSolverLanguageParser.g:586:3: ( ( ( (lv_functional_0_0= Functional ) ) ( (lv_error_1_0= Error ) )? ) | ( ( (lv_error_2_0= Error ) ) ( (lv_functional_3_0= Functional ) )? ) ) ( (lv_head_4_0= ruleCall ) ) otherlv_5= ColonHyphenMinus ( (lv_body_6_0= ruleExpression ) ) this_FULL_STOP_7= RULE_FULL_STOP | ||
1512 | { | ||
1513 | // InternalSolverLanguageParser.g:586:3: ( ( ( (lv_functional_0_0= Functional ) ) ( (lv_error_1_0= Error ) )? ) | ( ( (lv_error_2_0= Error ) ) ( (lv_functional_3_0= Functional ) )? ) ) | ||
1514 | int alt10=2; | ||
1515 | int LA10_0 = input.LA(1); | ||
1516 | |||
1517 | if ( (LA10_0==Functional) ) { | ||
1518 | alt10=1; | ||
1519 | } | ||
1520 | else if ( (LA10_0==Error) ) { | ||
1521 | alt10=2; | ||
1522 | } | ||
1523 | else { | ||
1524 | NoViableAltException nvae = | ||
1525 | new NoViableAltException("", 10, 0, input); | ||
1526 | |||
1527 | throw nvae; | ||
1528 | } | ||
1529 | switch (alt10) { | ||
1530 | case 1 : | ||
1531 | // InternalSolverLanguageParser.g:587:4: ( ( (lv_functional_0_0= Functional ) ) ( (lv_error_1_0= Error ) )? ) | ||
1532 | { | ||
1533 | // InternalSolverLanguageParser.g:587:4: ( ( (lv_functional_0_0= Functional ) ) ( (lv_error_1_0= Error ) )? ) | ||
1534 | // InternalSolverLanguageParser.g:588:5: ( (lv_functional_0_0= Functional ) ) ( (lv_error_1_0= Error ) )? | ||
1535 | { | ||
1536 | // InternalSolverLanguageParser.g:588:5: ( (lv_functional_0_0= Functional ) ) | ||
1537 | // InternalSolverLanguageParser.g:589:6: (lv_functional_0_0= Functional ) | ||
1538 | { | ||
1539 | // InternalSolverLanguageParser.g:589:6: (lv_functional_0_0= Functional ) | ||
1540 | // InternalSolverLanguageParser.g:590:7: lv_functional_0_0= Functional | ||
1541 | { | ||
1542 | lv_functional_0_0=(Token)match(input,Functional,FOLLOW_11); | ||
1543 | |||
1544 | newLeafNode(lv_functional_0_0, grammarAccess.getPredicateDefinitionAccess().getFunctionalFunctionalKeyword_0_0_0_0()); | ||
1545 | |||
1546 | |||
1547 | if (current==null) { | ||
1548 | current = createModelElement(grammarAccess.getPredicateDefinitionRule()); | ||
1549 | } | ||
1550 | setWithLastConsumed(current, "functional", true, "functional"); | ||
1551 | |||
1552 | |||
1553 | } | ||
1554 | |||
1555 | |||
1556 | } | ||
1557 | |||
1558 | // InternalSolverLanguageParser.g:602:5: ( (lv_error_1_0= Error ) )? | ||
1559 | int alt8=2; | ||
1560 | int LA8_0 = input.LA(1); | ||
1561 | |||
1562 | if ( (LA8_0==Error) ) { | ||
1563 | alt8=1; | ||
1564 | } | ||
1565 | switch (alt8) { | ||
1566 | case 1 : | ||
1567 | // InternalSolverLanguageParser.g:603:6: (lv_error_1_0= Error ) | ||
1568 | { | ||
1569 | // InternalSolverLanguageParser.g:603:6: (lv_error_1_0= Error ) | ||
1570 | // InternalSolverLanguageParser.g:604:7: lv_error_1_0= Error | ||
1571 | { | ||
1572 | lv_error_1_0=(Token)match(input,Error,FOLLOW_12); | ||
1573 | |||
1574 | newLeafNode(lv_error_1_0, grammarAccess.getPredicateDefinitionAccess().getErrorErrorKeyword_0_0_1_0()); | ||
1575 | |||
1576 | |||
1577 | if (current==null) { | ||
1578 | current = createModelElement(grammarAccess.getPredicateDefinitionRule()); | ||
1579 | } | ||
1580 | setWithLastConsumed(current, "error", true, "error"); | ||
1581 | |||
1582 | |||
1583 | } | ||
1584 | |||
1585 | |||
1586 | } | ||
1587 | break; | ||
1588 | |||
1589 | } | ||
1590 | |||
1591 | |||
1592 | } | ||
1593 | |||
1594 | |||
1595 | } | ||
1596 | break; | ||
1597 | case 2 : | ||
1598 | // InternalSolverLanguageParser.g:618:4: ( ( (lv_error_2_0= Error ) ) ( (lv_functional_3_0= Functional ) )? ) | ||
1599 | { | ||
1600 | // InternalSolverLanguageParser.g:618:4: ( ( (lv_error_2_0= Error ) ) ( (lv_functional_3_0= Functional ) )? ) | ||
1601 | // InternalSolverLanguageParser.g:619:5: ( (lv_error_2_0= Error ) ) ( (lv_functional_3_0= Functional ) )? | ||
1602 | { | ||
1603 | // InternalSolverLanguageParser.g:619:5: ( (lv_error_2_0= Error ) ) | ||
1604 | // InternalSolverLanguageParser.g:620:6: (lv_error_2_0= Error ) | ||
1605 | { | ||
1606 | // InternalSolverLanguageParser.g:620:6: (lv_error_2_0= Error ) | ||
1607 | // InternalSolverLanguageParser.g:621:7: lv_error_2_0= Error | ||
1608 | { | ||
1609 | lv_error_2_0=(Token)match(input,Error,FOLLOW_13); | ||
1610 | |||
1611 | newLeafNode(lv_error_2_0, grammarAccess.getPredicateDefinitionAccess().getErrorErrorKeyword_0_1_0_0()); | ||
1612 | |||
1613 | |||
1614 | if (current==null) { | ||
1615 | current = createModelElement(grammarAccess.getPredicateDefinitionRule()); | ||
1616 | } | ||
1617 | setWithLastConsumed(current, "error", true, "error"); | ||
1618 | |||
1619 | |||
1620 | } | ||
1621 | |||
1622 | |||
1623 | } | ||
1624 | |||
1625 | // InternalSolverLanguageParser.g:633:5: ( (lv_functional_3_0= Functional ) )? | ||
1626 | int alt9=2; | ||
1627 | int LA9_0 = input.LA(1); | ||
1628 | |||
1629 | if ( (LA9_0==Functional) ) { | ||
1630 | alt9=1; | ||
1631 | } | ||
1632 | switch (alt9) { | ||
1633 | case 1 : | ||
1634 | // InternalSolverLanguageParser.g:634:6: (lv_functional_3_0= Functional ) | ||
1635 | { | ||
1636 | // InternalSolverLanguageParser.g:634:6: (lv_functional_3_0= Functional ) | ||
1637 | // InternalSolverLanguageParser.g:635:7: lv_functional_3_0= Functional | ||
1638 | { | ||
1639 | lv_functional_3_0=(Token)match(input,Functional,FOLLOW_12); | ||
1640 | |||
1641 | newLeafNode(lv_functional_3_0, grammarAccess.getPredicateDefinitionAccess().getFunctionalFunctionalKeyword_0_1_1_0()); | ||
1642 | |||
1643 | |||
1644 | if (current==null) { | ||
1645 | current = createModelElement(grammarAccess.getPredicateDefinitionRule()); | ||
1646 | } | ||
1647 | setWithLastConsumed(current, "functional", true, "functional"); | ||
1648 | |||
1649 | |||
1650 | } | ||
1651 | |||
1652 | |||
1653 | } | ||
1654 | break; | ||
1655 | |||
1656 | } | ||
1657 | |||
1658 | |||
1659 | } | ||
1660 | |||
1661 | |||
1662 | } | ||
1663 | break; | ||
1664 | |||
1665 | } | ||
1666 | |||
1667 | // InternalSolverLanguageParser.g:649:3: ( (lv_head_4_0= ruleCall ) ) | ||
1668 | // InternalSolverLanguageParser.g:650:4: (lv_head_4_0= ruleCall ) | ||
1669 | { | ||
1670 | // InternalSolverLanguageParser.g:650:4: (lv_head_4_0= ruleCall ) | ||
1671 | // InternalSolverLanguageParser.g:651:5: lv_head_4_0= ruleCall | ||
1672 | { | ||
1673 | |||
1674 | newCompositeNode(grammarAccess.getPredicateDefinitionAccess().getHeadCallParserRuleCall_1_0()); | ||
1675 | |||
1676 | pushFollow(FOLLOW_14); | ||
1677 | lv_head_4_0=ruleCall(); | ||
1678 | |||
1679 | state._fsp--; | ||
1680 | |||
1681 | |||
1682 | if (current==null) { | ||
1683 | current = createModelElementForParent(grammarAccess.getPredicateDefinitionRule()); | ||
1684 | } | ||
1685 | set( | ||
1686 | current, | ||
1687 | "head", | ||
1688 | lv_head_4_0, | ||
1689 | "org.eclipse.viatra.solver.language.SolverLanguage.Call"); | ||
1690 | afterParserOrEnumRuleCall(); | ||
1691 | |||
1692 | |||
1693 | } | ||
1694 | |||
1695 | |||
1696 | } | ||
1697 | |||
1698 | otherlv_5=(Token)match(input,ColonHyphenMinus,FOLLOW_10); | ||
1699 | |||
1700 | newLeafNode(otherlv_5, grammarAccess.getPredicateDefinitionAccess().getColonHyphenMinusKeyword_2()); | ||
1701 | |||
1702 | // InternalSolverLanguageParser.g:672:3: ( (lv_body_6_0= ruleExpression ) ) | ||
1703 | // InternalSolverLanguageParser.g:673:4: (lv_body_6_0= ruleExpression ) | ||
1704 | { | ||
1705 | // InternalSolverLanguageParser.g:673:4: (lv_body_6_0= ruleExpression ) | ||
1706 | // InternalSolverLanguageParser.g:674:5: lv_body_6_0= ruleExpression | ||
1707 | { | ||
1708 | |||
1709 | newCompositeNode(grammarAccess.getPredicateDefinitionAccess().getBodyExpressionParserRuleCall_3_0()); | ||
1710 | |||
1711 | pushFollow(FOLLOW_4); | ||
1712 | lv_body_6_0=ruleExpression(); | ||
1713 | |||
1714 | state._fsp--; | ||
1715 | |||
1716 | |||
1717 | if (current==null) { | ||
1718 | current = createModelElementForParent(grammarAccess.getPredicateDefinitionRule()); | ||
1719 | } | ||
1720 | set( | ||
1721 | current, | ||
1722 | "body", | ||
1723 | lv_body_6_0, | ||
1724 | "org.eclipse.viatra.solver.language.SolverLanguage.Expression"); | ||
1725 | afterParserOrEnumRuleCall(); | ||
1726 | |||
1727 | |||
1728 | } | ||
1729 | |||
1730 | |||
1731 | } | ||
1732 | |||
1733 | this_FULL_STOP_7=(Token)match(input,RULE_FULL_STOP,FOLLOW_2); | ||
1734 | |||
1735 | newLeafNode(this_FULL_STOP_7, grammarAccess.getPredicateDefinitionAccess().getFULL_STOPTerminalRuleCall_4()); | ||
1736 | |||
1737 | |||
1738 | } | ||
1739 | |||
1740 | |||
1741 | } | ||
1742 | |||
1743 | |||
1744 | leaveRule(); | ||
1745 | |||
1746 | } | ||
1747 | |||
1748 | catch (RecognitionException re) { | ||
1749 | recover(input,re); | ||
1750 | appendSkippedTokens(); | ||
1751 | } | ||
1752 | finally { | ||
1753 | } | ||
1754 | return current; | ||
1755 | } | ||
1756 | // $ANTLR end "rulePredicateDefinition" | ||
1757 | |||
1758 | |||
1759 | // $ANTLR start "entryRuleUnnamedErrorPredicateDefintion" | ||
1760 | // InternalSolverLanguageParser.g:699:1: entryRuleUnnamedErrorPredicateDefintion returns [EObject current=null] : iv_ruleUnnamedErrorPredicateDefintion= ruleUnnamedErrorPredicateDefintion EOF ; | ||
1761 | public final EObject entryRuleUnnamedErrorPredicateDefintion() throws RecognitionException { | ||
1762 | EObject current = null; | ||
1763 | |||
1764 | EObject iv_ruleUnnamedErrorPredicateDefintion = null; | ||
1765 | |||
1766 | |||
1767 | try { | ||
1768 | // InternalSolverLanguageParser.g:699:71: (iv_ruleUnnamedErrorPredicateDefintion= ruleUnnamedErrorPredicateDefintion EOF ) | ||
1769 | // InternalSolverLanguageParser.g:700:2: iv_ruleUnnamedErrorPredicateDefintion= ruleUnnamedErrorPredicateDefintion EOF | ||
1770 | { | ||
1771 | newCompositeNode(grammarAccess.getUnnamedErrorPredicateDefintionRule()); | ||
1772 | pushFollow(FOLLOW_1); | ||
1773 | iv_ruleUnnamedErrorPredicateDefintion=ruleUnnamedErrorPredicateDefintion(); | ||
1774 | |||
1775 | state._fsp--; | ||
1776 | |||
1777 | current =iv_ruleUnnamedErrorPredicateDefintion; | ||
1778 | match(input,EOF,FOLLOW_2); | ||
1779 | |||
1780 | } | ||
1781 | |||
1782 | } | ||
1783 | |||
1784 | catch (RecognitionException re) { | ||
1785 | recover(input,re); | ||
1786 | appendSkippedTokens(); | ||
1787 | } | ||
1788 | finally { | ||
1789 | } | ||
1790 | return current; | ||
1791 | } | ||
1792 | // $ANTLR end "entryRuleUnnamedErrorPredicateDefintion" | ||
1793 | |||
1794 | |||
1795 | // $ANTLR start "ruleUnnamedErrorPredicateDefintion" | ||
1796 | // InternalSolverLanguageParser.g:706:1: ruleUnnamedErrorPredicateDefintion returns [EObject current=null] : (otherlv_0= Error ( (lv_argumentList_1_0= ruleArgumentList ) ) otherlv_2= ColonHyphenMinus ( (lv_body_3_0= ruleExpression ) ) this_FULL_STOP_4= RULE_FULL_STOP ) ; | ||
1797 | public final EObject ruleUnnamedErrorPredicateDefintion() throws RecognitionException { | ||
1798 | EObject current = null; | ||
1799 | |||
1800 | Token otherlv_0=null; | ||
1801 | Token otherlv_2=null; | ||
1802 | Token this_FULL_STOP_4=null; | ||
1803 | EObject lv_argumentList_1_0 = null; | ||
1804 | |||
1805 | EObject lv_body_3_0 = null; | ||
1806 | |||
1807 | |||
1808 | |||
1809 | enterRule(); | ||
1810 | |||
1811 | try { | ||
1812 | // InternalSolverLanguageParser.g:712:2: ( (otherlv_0= Error ( (lv_argumentList_1_0= ruleArgumentList ) ) otherlv_2= ColonHyphenMinus ( (lv_body_3_0= ruleExpression ) ) this_FULL_STOP_4= RULE_FULL_STOP ) ) | ||
1813 | // InternalSolverLanguageParser.g:713:2: (otherlv_0= Error ( (lv_argumentList_1_0= ruleArgumentList ) ) otherlv_2= ColonHyphenMinus ( (lv_body_3_0= ruleExpression ) ) this_FULL_STOP_4= RULE_FULL_STOP ) | ||
1814 | { | ||
1815 | // InternalSolverLanguageParser.g:713:2: (otherlv_0= Error ( (lv_argumentList_1_0= ruleArgumentList ) ) otherlv_2= ColonHyphenMinus ( (lv_body_3_0= ruleExpression ) ) this_FULL_STOP_4= RULE_FULL_STOP ) | ||
1816 | // InternalSolverLanguageParser.g:714:3: otherlv_0= Error ( (lv_argumentList_1_0= ruleArgumentList ) ) otherlv_2= ColonHyphenMinus ( (lv_body_3_0= ruleExpression ) ) this_FULL_STOP_4= RULE_FULL_STOP | ||
1817 | { | ||
1818 | otherlv_0=(Token)match(input,Error,FOLLOW_15); | ||
1819 | |||
1820 | newLeafNode(otherlv_0, grammarAccess.getUnnamedErrorPredicateDefintionAccess().getErrorKeyword_0()); | ||
1821 | |||
1822 | // InternalSolverLanguageParser.g:718:3: ( (lv_argumentList_1_0= ruleArgumentList ) ) | ||
1823 | // InternalSolverLanguageParser.g:719:4: (lv_argumentList_1_0= ruleArgumentList ) | ||
1824 | { | ||
1825 | // InternalSolverLanguageParser.g:719:4: (lv_argumentList_1_0= ruleArgumentList ) | ||
1826 | // InternalSolverLanguageParser.g:720:5: lv_argumentList_1_0= ruleArgumentList | ||
1827 | { | ||
1828 | |||
1829 | newCompositeNode(grammarAccess.getUnnamedErrorPredicateDefintionAccess().getArgumentListArgumentListParserRuleCall_1_0()); | ||
1830 | |||
1831 | pushFollow(FOLLOW_14); | ||
1832 | lv_argumentList_1_0=ruleArgumentList(); | ||
1833 | |||
1834 | state._fsp--; | ||
1835 | |||
1836 | |||
1837 | if (current==null) { | ||
1838 | current = createModelElementForParent(grammarAccess.getUnnamedErrorPredicateDefintionRule()); | ||
1839 | } | ||
1840 | set( | ||
1841 | current, | ||
1842 | "argumentList", | ||
1843 | lv_argumentList_1_0, | ||
1844 | "org.eclipse.viatra.solver.language.SolverLanguage.ArgumentList"); | ||
1845 | afterParserOrEnumRuleCall(); | ||
1846 | |||
1847 | |||
1848 | } | ||
1849 | |||
1850 | |||
1851 | } | ||
1852 | |||
1853 | otherlv_2=(Token)match(input,ColonHyphenMinus,FOLLOW_10); | ||
1854 | |||
1855 | newLeafNode(otherlv_2, grammarAccess.getUnnamedErrorPredicateDefintionAccess().getColonHyphenMinusKeyword_2()); | ||
1856 | |||
1857 | // InternalSolverLanguageParser.g:741:3: ( (lv_body_3_0= ruleExpression ) ) | ||
1858 | // InternalSolverLanguageParser.g:742:4: (lv_body_3_0= ruleExpression ) | ||
1859 | { | ||
1860 | // InternalSolverLanguageParser.g:742:4: (lv_body_3_0= ruleExpression ) | ||
1861 | // InternalSolverLanguageParser.g:743:5: lv_body_3_0= ruleExpression | ||
1862 | { | ||
1863 | |||
1864 | newCompositeNode(grammarAccess.getUnnamedErrorPredicateDefintionAccess().getBodyExpressionParserRuleCall_3_0()); | ||
1865 | |||
1866 | pushFollow(FOLLOW_4); | ||
1867 | lv_body_3_0=ruleExpression(); | ||
1868 | |||
1869 | state._fsp--; | ||
1870 | |||
1871 | |||
1872 | if (current==null) { | ||
1873 | current = createModelElementForParent(grammarAccess.getUnnamedErrorPredicateDefintionRule()); | ||
1874 | } | ||
1875 | set( | ||
1876 | current, | ||
1877 | "body", | ||
1878 | lv_body_3_0, | ||
1879 | "org.eclipse.viatra.solver.language.SolverLanguage.Expression"); | ||
1880 | afterParserOrEnumRuleCall(); | ||
1881 | |||
1882 | |||
1883 | } | ||
1884 | |||
1885 | |||
1886 | } | ||
1887 | |||
1888 | this_FULL_STOP_4=(Token)match(input,RULE_FULL_STOP,FOLLOW_2); | ||
1889 | |||
1890 | newLeafNode(this_FULL_STOP_4, grammarAccess.getUnnamedErrorPredicateDefintionAccess().getFULL_STOPTerminalRuleCall_4()); | ||
1891 | |||
1892 | |||
1893 | } | ||
1894 | |||
1895 | |||
1896 | } | ||
1897 | |||
1898 | |||
1899 | leaveRule(); | ||
1900 | |||
1901 | } | ||
1902 | |||
1903 | catch (RecognitionException re) { | ||
1904 | recover(input,re); | ||
1905 | appendSkippedTokens(); | ||
1906 | } | ||
1907 | finally { | ||
1908 | } | ||
1909 | return current; | ||
1910 | } | ||
1911 | // $ANTLR end "ruleUnnamedErrorPredicateDefintion" | ||
1912 | |||
1913 | |||
1914 | // $ANTLR start "entryRuleDefaultAssertion" | ||
1915 | // InternalSolverLanguageParser.g:768:1: entryRuleDefaultAssertion returns [EObject current=null] : iv_ruleDefaultAssertion= ruleDefaultAssertion EOF ; | ||
1916 | public final EObject entryRuleDefaultAssertion() throws RecognitionException { | ||
1917 | EObject current = null; | ||
1918 | |||
1919 | EObject iv_ruleDefaultAssertion = null; | ||
1920 | |||
1921 | |||
1922 | try { | ||
1923 | // InternalSolverLanguageParser.g:768:57: (iv_ruleDefaultAssertion= ruleDefaultAssertion EOF ) | ||
1924 | // InternalSolverLanguageParser.g:769:2: iv_ruleDefaultAssertion= ruleDefaultAssertion EOF | ||
1925 | { | ||
1926 | newCompositeNode(grammarAccess.getDefaultAssertionRule()); | ||
1927 | pushFollow(FOLLOW_1); | ||
1928 | iv_ruleDefaultAssertion=ruleDefaultAssertion(); | ||
1929 | |||
1930 | state._fsp--; | ||
1931 | |||
1932 | current =iv_ruleDefaultAssertion; | ||
1933 | match(input,EOF,FOLLOW_2); | ||
1934 | |||
1935 | } | ||
1936 | |||
1937 | } | ||
1938 | |||
1939 | catch (RecognitionException re) { | ||
1940 | recover(input,re); | ||
1941 | appendSkippedTokens(); | ||
1942 | } | ||
1943 | finally { | ||
1944 | } | ||
1945 | return current; | ||
1946 | } | ||
1947 | // $ANTLR end "entryRuleDefaultAssertion" | ||
1948 | |||
1949 | |||
1950 | // $ANTLR start "ruleDefaultAssertion" | ||
1951 | // InternalSolverLanguageParser.g:775:1: ruleDefaultAssertion returns [EObject current=null] : (otherlv_0= Default ( (lv_expression_1_0= ruleCall ) ) (otherlv_2= Colon ( (lv_range_3_0= ruleExpression ) ) )? this_FULL_STOP_4= RULE_FULL_STOP ) ; | ||
1952 | public final EObject ruleDefaultAssertion() throws RecognitionException { | ||
1953 | EObject current = null; | ||
1954 | |||
1955 | Token otherlv_0=null; | ||
1956 | Token otherlv_2=null; | ||
1957 | Token this_FULL_STOP_4=null; | ||
1958 | EObject lv_expression_1_0 = null; | ||
1959 | |||
1960 | EObject lv_range_3_0 = null; | ||
1961 | |||
1962 | |||
1963 | |||
1964 | enterRule(); | ||
1965 | |||
1966 | try { | ||
1967 | // InternalSolverLanguageParser.g:781:2: ( (otherlv_0= Default ( (lv_expression_1_0= ruleCall ) ) (otherlv_2= Colon ( (lv_range_3_0= ruleExpression ) ) )? this_FULL_STOP_4= RULE_FULL_STOP ) ) | ||
1968 | // InternalSolverLanguageParser.g:782:2: (otherlv_0= Default ( (lv_expression_1_0= ruleCall ) ) (otherlv_2= Colon ( (lv_range_3_0= ruleExpression ) ) )? this_FULL_STOP_4= RULE_FULL_STOP ) | ||
1969 | { | ||
1970 | // InternalSolverLanguageParser.g:782:2: (otherlv_0= Default ( (lv_expression_1_0= ruleCall ) ) (otherlv_2= Colon ( (lv_range_3_0= ruleExpression ) ) )? this_FULL_STOP_4= RULE_FULL_STOP ) | ||
1971 | // InternalSolverLanguageParser.g:783:3: otherlv_0= Default ( (lv_expression_1_0= ruleCall ) ) (otherlv_2= Colon ( (lv_range_3_0= ruleExpression ) ) )? this_FULL_STOP_4= RULE_FULL_STOP | ||
1972 | { | ||
1973 | otherlv_0=(Token)match(input,Default,FOLLOW_12); | ||
1974 | |||
1975 | newLeafNode(otherlv_0, grammarAccess.getDefaultAssertionAccess().getDefaultKeyword_0()); | ||
1976 | |||
1977 | // InternalSolverLanguageParser.g:787:3: ( (lv_expression_1_0= ruleCall ) ) | ||
1978 | // InternalSolverLanguageParser.g:788:4: (lv_expression_1_0= ruleCall ) | ||
1979 | { | ||
1980 | // InternalSolverLanguageParser.g:788:4: (lv_expression_1_0= ruleCall ) | ||
1981 | // InternalSolverLanguageParser.g:789:5: lv_expression_1_0= ruleCall | ||
1982 | { | ||
1983 | |||
1984 | newCompositeNode(grammarAccess.getDefaultAssertionAccess().getExpressionCallParserRuleCall_1_0()); | ||
1985 | |||
1986 | pushFollow(FOLLOW_16); | ||
1987 | lv_expression_1_0=ruleCall(); | ||
1988 | |||
1989 | state._fsp--; | ||
1990 | |||
1991 | |||
1992 | if (current==null) { | ||
1993 | current = createModelElementForParent(grammarAccess.getDefaultAssertionRule()); | ||
1994 | } | ||
1995 | set( | ||
1996 | current, | ||
1997 | "expression", | ||
1998 | lv_expression_1_0, | ||
1999 | "org.eclipse.viatra.solver.language.SolverLanguage.Call"); | ||
2000 | afterParserOrEnumRuleCall(); | ||
2001 | |||
2002 | |||
2003 | } | ||
2004 | |||
2005 | |||
2006 | } | ||
2007 | |||
2008 | // InternalSolverLanguageParser.g:806:3: (otherlv_2= Colon ( (lv_range_3_0= ruleExpression ) ) )? | ||
2009 | int alt11=2; | ||
2010 | int LA11_0 = input.LA(1); | ||
2011 | |||
2012 | if ( (LA11_0==Colon) ) { | ||
2013 | alt11=1; | ||
2014 | } | ||
2015 | switch (alt11) { | ||
2016 | case 1 : | ||
2017 | // InternalSolverLanguageParser.g:807:4: otherlv_2= Colon ( (lv_range_3_0= ruleExpression ) ) | ||
2018 | { | ||
2019 | otherlv_2=(Token)match(input,Colon,FOLLOW_10); | ||
2020 | |||
2021 | newLeafNode(otherlv_2, grammarAccess.getDefaultAssertionAccess().getColonKeyword_2_0()); | ||
2022 | |||
2023 | // InternalSolverLanguageParser.g:811:4: ( (lv_range_3_0= ruleExpression ) ) | ||
2024 | // InternalSolverLanguageParser.g:812:5: (lv_range_3_0= ruleExpression ) | ||
2025 | { | ||
2026 | // InternalSolverLanguageParser.g:812:5: (lv_range_3_0= ruleExpression ) | ||
2027 | // InternalSolverLanguageParser.g:813:6: lv_range_3_0= ruleExpression | ||
2028 | { | ||
2029 | |||
2030 | newCompositeNode(grammarAccess.getDefaultAssertionAccess().getRangeExpressionParserRuleCall_2_1_0()); | ||
2031 | |||
2032 | pushFollow(FOLLOW_4); | ||
2033 | lv_range_3_0=ruleExpression(); | ||
2034 | |||
2035 | state._fsp--; | ||
2036 | |||
2037 | |||
2038 | if (current==null) { | ||
2039 | current = createModelElementForParent(grammarAccess.getDefaultAssertionRule()); | ||
2040 | } | ||
2041 | set( | ||
2042 | current, | ||
2043 | "range", | ||
2044 | lv_range_3_0, | ||
2045 | "org.eclipse.viatra.solver.language.SolverLanguage.Expression"); | ||
2046 | afterParserOrEnumRuleCall(); | ||
2047 | |||
2048 | |||
2049 | } | ||
2050 | |||
2051 | |||
2052 | } | ||
2053 | |||
2054 | |||
2055 | } | ||
2056 | break; | ||
2057 | |||
2058 | } | ||
2059 | |||
2060 | this_FULL_STOP_4=(Token)match(input,RULE_FULL_STOP,FOLLOW_2); | ||
2061 | |||
2062 | newLeafNode(this_FULL_STOP_4, grammarAccess.getDefaultAssertionAccess().getFULL_STOPTerminalRuleCall_3()); | ||
2063 | |||
2064 | |||
2065 | } | ||
2066 | |||
2067 | |||
2068 | } | ||
2069 | |||
2070 | |||
2071 | leaveRule(); | ||
2072 | |||
2073 | } | ||
2074 | |||
2075 | catch (RecognitionException re) { | ||
2076 | recover(input,re); | ||
2077 | appendSkippedTokens(); | ||
2078 | } | ||
2079 | finally { | ||
2080 | } | ||
2081 | return current; | ||
2082 | } | ||
2083 | // $ANTLR end "ruleDefaultAssertion" | ||
2084 | |||
2085 | |||
2086 | // $ANTLR start "entryRuleFunctionDefinition" | ||
2087 | // InternalSolverLanguageParser.g:839:1: entryRuleFunctionDefinition returns [EObject current=null] : iv_ruleFunctionDefinition= ruleFunctionDefinition EOF ; | ||
2088 | public final EObject entryRuleFunctionDefinition() throws RecognitionException { | ||
2089 | EObject current = null; | ||
2090 | |||
2091 | EObject iv_ruleFunctionDefinition = null; | ||
2092 | |||
2093 | |||
2094 | try { | ||
2095 | // InternalSolverLanguageParser.g:839:59: (iv_ruleFunctionDefinition= ruleFunctionDefinition EOF ) | ||
2096 | // InternalSolverLanguageParser.g:840:2: iv_ruleFunctionDefinition= ruleFunctionDefinition EOF | ||
2097 | { | ||
2098 | newCompositeNode(grammarAccess.getFunctionDefinitionRule()); | ||
2099 | pushFollow(FOLLOW_1); | ||
2100 | iv_ruleFunctionDefinition=ruleFunctionDefinition(); | ||
2101 | |||
2102 | state._fsp--; | ||
2103 | |||
2104 | current =iv_ruleFunctionDefinition; | ||
2105 | match(input,EOF,FOLLOW_2); | ||
2106 | |||
2107 | } | ||
2108 | |||
2109 | } | ||
2110 | |||
2111 | catch (RecognitionException re) { | ||
2112 | recover(input,re); | ||
2113 | appendSkippedTokens(); | ||
2114 | } | ||
2115 | finally { | ||
2116 | } | ||
2117 | return current; | ||
2118 | } | ||
2119 | // $ANTLR end "entryRuleFunctionDefinition" | ||
2120 | |||
2121 | |||
2122 | // $ANTLR start "ruleFunctionDefinition" | ||
2123 | // InternalSolverLanguageParser.g:846:1: ruleFunctionDefinition returns [EObject current=null] : ( ( ( ruleQualifiedName ) ) ( (lv_head_1_0= ruleCall ) ) otherlv_2= ColonEqualsSign ( (lv_body_3_0= ruleExpression ) ) this_FULL_STOP_4= RULE_FULL_STOP ) ; | ||
2124 | public final EObject ruleFunctionDefinition() throws RecognitionException { | ||
2125 | EObject current = null; | ||
2126 | |||
2127 | Token otherlv_2=null; | ||
2128 | Token this_FULL_STOP_4=null; | ||
2129 | EObject lv_head_1_0 = null; | ||
2130 | |||
2131 | EObject lv_body_3_0 = null; | ||
2132 | |||
2133 | |||
2134 | |||
2135 | enterRule(); | ||
2136 | |||
2137 | try { | ||
2138 | // InternalSolverLanguageParser.g:852:2: ( ( ( ( ruleQualifiedName ) ) ( (lv_head_1_0= ruleCall ) ) otherlv_2= ColonEqualsSign ( (lv_body_3_0= ruleExpression ) ) this_FULL_STOP_4= RULE_FULL_STOP ) ) | ||
2139 | // InternalSolverLanguageParser.g:853:2: ( ( ( ruleQualifiedName ) ) ( (lv_head_1_0= ruleCall ) ) otherlv_2= ColonEqualsSign ( (lv_body_3_0= ruleExpression ) ) this_FULL_STOP_4= RULE_FULL_STOP ) | ||
2140 | { | ||
2141 | // InternalSolverLanguageParser.g:853:2: ( ( ( ruleQualifiedName ) ) ( (lv_head_1_0= ruleCall ) ) otherlv_2= ColonEqualsSign ( (lv_body_3_0= ruleExpression ) ) this_FULL_STOP_4= RULE_FULL_STOP ) | ||
2142 | // InternalSolverLanguageParser.g:854:3: ( ( ruleQualifiedName ) ) ( (lv_head_1_0= ruleCall ) ) otherlv_2= ColonEqualsSign ( (lv_body_3_0= ruleExpression ) ) this_FULL_STOP_4= RULE_FULL_STOP | ||
2143 | { | ||
2144 | // InternalSolverLanguageParser.g:854:3: ( ( ruleQualifiedName ) ) | ||
2145 | // InternalSolverLanguageParser.g:855:4: ( ruleQualifiedName ) | ||
2146 | { | ||
2147 | // InternalSolverLanguageParser.g:855:4: ( ruleQualifiedName ) | ||
2148 | // InternalSolverLanguageParser.g:856:5: ruleQualifiedName | ||
2149 | { | ||
2150 | |||
2151 | if (current==null) { | ||
2152 | current = createModelElement(grammarAccess.getFunctionDefinitionRule()); | ||
2153 | } | ||
2154 | |||
2155 | |||
2156 | newCompositeNode(grammarAccess.getFunctionDefinitionAccess().getResultTypeSymbolCrossReference_0_0()); | ||
2157 | |||
2158 | pushFollow(FOLLOW_12); | ||
2159 | ruleQualifiedName(); | ||
2160 | |||
2161 | state._fsp--; | ||
2162 | |||
2163 | |||
2164 | afterParserOrEnumRuleCall(); | ||
2165 | |||
2166 | |||
2167 | } | ||
2168 | |||
2169 | |||
2170 | } | ||
2171 | |||
2172 | // InternalSolverLanguageParser.g:870:3: ( (lv_head_1_0= ruleCall ) ) | ||
2173 | // InternalSolverLanguageParser.g:871:4: (lv_head_1_0= ruleCall ) | ||
2174 | { | ||
2175 | // InternalSolverLanguageParser.g:871:4: (lv_head_1_0= ruleCall ) | ||
2176 | // InternalSolverLanguageParser.g:872:5: lv_head_1_0= ruleCall | ||
2177 | { | ||
2178 | |||
2179 | newCompositeNode(grammarAccess.getFunctionDefinitionAccess().getHeadCallParserRuleCall_1_0()); | ||
2180 | |||
2181 | pushFollow(FOLLOW_17); | ||
2182 | lv_head_1_0=ruleCall(); | ||
2183 | |||
2184 | state._fsp--; | ||
2185 | |||
2186 | |||
2187 | if (current==null) { | ||
2188 | current = createModelElementForParent(grammarAccess.getFunctionDefinitionRule()); | ||
2189 | } | ||
2190 | set( | ||
2191 | current, | ||
2192 | "head", | ||
2193 | lv_head_1_0, | ||
2194 | "org.eclipse.viatra.solver.language.SolverLanguage.Call"); | ||
2195 | afterParserOrEnumRuleCall(); | ||
2196 | |||
2197 | |||
2198 | } | ||
2199 | |||
2200 | |||
2201 | } | ||
2202 | |||
2203 | otherlv_2=(Token)match(input,ColonEqualsSign,FOLLOW_10); | ||
2204 | |||
2205 | newLeafNode(otherlv_2, grammarAccess.getFunctionDefinitionAccess().getColonEqualsSignKeyword_2()); | ||
2206 | |||
2207 | // InternalSolverLanguageParser.g:893:3: ( (lv_body_3_0= ruleExpression ) ) | ||
2208 | // InternalSolverLanguageParser.g:894:4: (lv_body_3_0= ruleExpression ) | ||
2209 | { | ||
2210 | // InternalSolverLanguageParser.g:894:4: (lv_body_3_0= ruleExpression ) | ||
2211 | // InternalSolverLanguageParser.g:895:5: lv_body_3_0= ruleExpression | ||
2212 | { | ||
2213 | |||
2214 | newCompositeNode(grammarAccess.getFunctionDefinitionAccess().getBodyExpressionParserRuleCall_3_0()); | ||
2215 | |||
2216 | pushFollow(FOLLOW_4); | ||
2217 | lv_body_3_0=ruleExpression(); | ||
2218 | |||
2219 | state._fsp--; | ||
2220 | |||
2221 | |||
2222 | if (current==null) { | ||
2223 | current = createModelElementForParent(grammarAccess.getFunctionDefinitionRule()); | ||
2224 | } | ||
2225 | set( | ||
2226 | current, | ||
2227 | "body", | ||
2228 | lv_body_3_0, | ||
2229 | "org.eclipse.viatra.solver.language.SolverLanguage.Expression"); | ||
2230 | afterParserOrEnumRuleCall(); | ||
2231 | |||
2232 | |||
2233 | } | ||
2234 | |||
2235 | |||
2236 | } | ||
2237 | |||
2238 | this_FULL_STOP_4=(Token)match(input,RULE_FULL_STOP,FOLLOW_2); | ||
2239 | |||
2240 | newLeafNode(this_FULL_STOP_4, grammarAccess.getFunctionDefinitionAccess().getFULL_STOPTerminalRuleCall_4()); | ||
2241 | |||
2242 | |||
2243 | } | ||
2244 | |||
2245 | |||
2246 | } | ||
2247 | |||
2248 | |||
2249 | leaveRule(); | ||
2250 | |||
2251 | } | ||
2252 | |||
2253 | catch (RecognitionException re) { | ||
2254 | recover(input,re); | ||
2255 | appendSkippedTokens(); | ||
2256 | } | ||
2257 | finally { | ||
2258 | } | ||
2259 | return current; | ||
2260 | } | ||
2261 | // $ANTLR end "ruleFunctionDefinition" | ||
2262 | |||
2263 | |||
2264 | // $ANTLR start "entryRuleTypeReference" | ||
2265 | // InternalSolverLanguageParser.g:920:1: entryRuleTypeReference returns [EObject current=null] : iv_ruleTypeReference= ruleTypeReference EOF ; | ||
2266 | public final EObject entryRuleTypeReference() throws RecognitionException { | ||
2267 | EObject current = null; | ||
2268 | |||
2269 | EObject iv_ruleTypeReference = null; | ||
2270 | |||
2271 | |||
2272 | try { | ||
2273 | // InternalSolverLanguageParser.g:920:54: (iv_ruleTypeReference= ruleTypeReference EOF ) | ||
2274 | // InternalSolverLanguageParser.g:921:2: iv_ruleTypeReference= ruleTypeReference EOF | ||
2275 | { | ||
2276 | newCompositeNode(grammarAccess.getTypeReferenceRule()); | ||
2277 | pushFollow(FOLLOW_1); | ||
2278 | iv_ruleTypeReference=ruleTypeReference(); | ||
2279 | |||
2280 | state._fsp--; | ||
2281 | |||
2282 | current =iv_ruleTypeReference; | ||
2283 | match(input,EOF,FOLLOW_2); | ||
2284 | |||
2285 | } | ||
2286 | |||
2287 | } | ||
2288 | |||
2289 | catch (RecognitionException re) { | ||
2290 | recover(input,re); | ||
2291 | appendSkippedTokens(); | ||
2292 | } | ||
2293 | finally { | ||
2294 | } | ||
2295 | return current; | ||
2296 | } | ||
2297 | // $ANTLR end "entryRuleTypeReference" | ||
2298 | |||
2299 | |||
2300 | // $ANTLR start "ruleTypeReference" | ||
2301 | // InternalSolverLanguageParser.g:927:1: ruleTypeReference returns [EObject current=null] : ( ( ( ruleQualifiedName ) ) ( (lv_forceObjectType_1_0= Object ) )? ) ; | ||
2302 | public final EObject ruleTypeReference() throws RecognitionException { | ||
2303 | EObject current = null; | ||
2304 | |||
2305 | Token lv_forceObjectType_1_0=null; | ||
2306 | |||
2307 | |||
2308 | enterRule(); | ||
2309 | |||
2310 | try { | ||
2311 | // InternalSolverLanguageParser.g:933:2: ( ( ( ( ruleQualifiedName ) ) ( (lv_forceObjectType_1_0= Object ) )? ) ) | ||
2312 | // InternalSolverLanguageParser.g:934:2: ( ( ( ruleQualifiedName ) ) ( (lv_forceObjectType_1_0= Object ) )? ) | ||
2313 | { | ||
2314 | // InternalSolverLanguageParser.g:934:2: ( ( ( ruleQualifiedName ) ) ( (lv_forceObjectType_1_0= Object ) )? ) | ||
2315 | // InternalSolverLanguageParser.g:935:3: ( ( ruleQualifiedName ) ) ( (lv_forceObjectType_1_0= Object ) )? | ||
2316 | { | ||
2317 | // InternalSolverLanguageParser.g:935:3: ( ( ruleQualifiedName ) ) | ||
2318 | // InternalSolverLanguageParser.g:936:4: ( ruleQualifiedName ) | ||
2319 | { | ||
2320 | // InternalSolverLanguageParser.g:936:4: ( ruleQualifiedName ) | ||
2321 | // InternalSolverLanguageParser.g:937:5: ruleQualifiedName | ||
2322 | { | ||
2323 | |||
2324 | if (current==null) { | ||
2325 | current = createModelElement(grammarAccess.getTypeReferenceRule()); | ||
2326 | } | ||
2327 | |||
2328 | |||
2329 | newCompositeNode(grammarAccess.getTypeReferenceAccess().getTypeSymbolCrossReference_0_0()); | ||
2330 | |||
2331 | pushFollow(FOLLOW_18); | ||
2332 | ruleQualifiedName(); | ||
2333 | |||
2334 | state._fsp--; | ||
2335 | |||
2336 | |||
2337 | afterParserOrEnumRuleCall(); | ||
2338 | |||
2339 | |||
2340 | } | ||
2341 | |||
2342 | |||
2343 | } | ||
2344 | |||
2345 | // InternalSolverLanguageParser.g:951:3: ( (lv_forceObjectType_1_0= Object ) )? | ||
2346 | int alt12=2; | ||
2347 | int LA12_0 = input.LA(1); | ||
2348 | |||
2349 | if ( (LA12_0==Object) ) { | ||
2350 | alt12=1; | ||
2351 | } | ||
2352 | switch (alt12) { | ||
2353 | case 1 : | ||
2354 | // InternalSolverLanguageParser.g:952:4: (lv_forceObjectType_1_0= Object ) | ||
2355 | { | ||
2356 | // InternalSolverLanguageParser.g:952:4: (lv_forceObjectType_1_0= Object ) | ||
2357 | // InternalSolverLanguageParser.g:953:5: lv_forceObjectType_1_0= Object | ||
2358 | { | ||
2359 | lv_forceObjectType_1_0=(Token)match(input,Object,FOLLOW_2); | ||
2360 | |||
2361 | newLeafNode(lv_forceObjectType_1_0, grammarAccess.getTypeReferenceAccess().getForceObjectTypeObjectKeyword_1_0()); | ||
2362 | |||
2363 | |||
2364 | if (current==null) { | ||
2365 | current = createModelElement(grammarAccess.getTypeReferenceRule()); | ||
2366 | } | ||
2367 | setWithLastConsumed(current, "forceObjectType", true, "object"); | ||
2368 | |||
2369 | |||
2370 | } | ||
2371 | |||
2372 | |||
2373 | } | ||
2374 | break; | ||
2375 | |||
2376 | } | ||
2377 | |||
2378 | |||
2379 | } | ||
2380 | |||
2381 | |||
2382 | } | ||
2383 | |||
2384 | |||
2385 | leaveRule(); | ||
2386 | |||
2387 | } | ||
2388 | |||
2389 | catch (RecognitionException re) { | ||
2390 | recover(input,re); | ||
2391 | appendSkippedTokens(); | ||
2392 | } | ||
2393 | finally { | ||
2394 | } | ||
2395 | return current; | ||
2396 | } | ||
2397 | // $ANTLR end "ruleTypeReference" | ||
2398 | |||
2399 | |||
2400 | // $ANTLR start "entryRuleAttribute" | ||
2401 | // InternalSolverLanguageParser.g:969:1: entryRuleAttribute returns [EObject current=null] : iv_ruleAttribute= ruleAttribute EOF ; | ||
2402 | public final EObject entryRuleAttribute() throws RecognitionException { | ||
2403 | EObject current = null; | ||
2404 | |||
2405 | EObject iv_ruleAttribute = null; | ||
2406 | |||
2407 | |||
2408 | try { | ||
2409 | // InternalSolverLanguageParser.g:969:50: (iv_ruleAttribute= ruleAttribute EOF ) | ||
2410 | // InternalSolverLanguageParser.g:970:2: iv_ruleAttribute= ruleAttribute EOF | ||
2411 | { | ||
2412 | newCompositeNode(grammarAccess.getAttributeRule()); | ||
2413 | pushFollow(FOLLOW_1); | ||
2414 | iv_ruleAttribute=ruleAttribute(); | ||
2415 | |||
2416 | state._fsp--; | ||
2417 | |||
2418 | current =iv_ruleAttribute; | ||
2419 | match(input,EOF,FOLLOW_2); | ||
2420 | |||
2421 | } | ||
2422 | |||
2423 | } | ||
2424 | |||
2425 | catch (RecognitionException re) { | ||
2426 | recover(input,re); | ||
2427 | appendSkippedTokens(); | ||
2428 | } | ||
2429 | finally { | ||
2430 | } | ||
2431 | return current; | ||
2432 | } | ||
2433 | // $ANTLR end "entryRuleAttribute" | ||
2434 | |||
2435 | |||
2436 | // $ANTLR start "ruleAttribute" | ||
2437 | // InternalSolverLanguageParser.g:976:1: ruleAttribute returns [EObject current=null] : ( ( (lv_kind_0_0= ruleAttributeKind ) ) ( ( ruleQualifiedName ) ) this_FULL_STOP_2= RULE_FULL_STOP ) ; | ||
2438 | public final EObject ruleAttribute() throws RecognitionException { | ||
2439 | EObject current = null; | ||
2440 | |||
2441 | Token this_FULL_STOP_2=null; | ||
2442 | Enumerator lv_kind_0_0 = null; | ||
2443 | |||
2444 | |||
2445 | |||
2446 | enterRule(); | ||
2447 | |||
2448 | try { | ||
2449 | // InternalSolverLanguageParser.g:982:2: ( ( ( (lv_kind_0_0= ruleAttributeKind ) ) ( ( ruleQualifiedName ) ) this_FULL_STOP_2= RULE_FULL_STOP ) ) | ||
2450 | // InternalSolverLanguageParser.g:983:2: ( ( (lv_kind_0_0= ruleAttributeKind ) ) ( ( ruleQualifiedName ) ) this_FULL_STOP_2= RULE_FULL_STOP ) | ||
2451 | { | ||
2452 | // InternalSolverLanguageParser.g:983:2: ( ( (lv_kind_0_0= ruleAttributeKind ) ) ( ( ruleQualifiedName ) ) this_FULL_STOP_2= RULE_FULL_STOP ) | ||
2453 | // InternalSolverLanguageParser.g:984:3: ( (lv_kind_0_0= ruleAttributeKind ) ) ( ( ruleQualifiedName ) ) this_FULL_STOP_2= RULE_FULL_STOP | ||
2454 | { | ||
2455 | // InternalSolverLanguageParser.g:984:3: ( (lv_kind_0_0= ruleAttributeKind ) ) | ||
2456 | // InternalSolverLanguageParser.g:985:4: (lv_kind_0_0= ruleAttributeKind ) | ||
2457 | { | ||
2458 | // InternalSolverLanguageParser.g:985:4: (lv_kind_0_0= ruleAttributeKind ) | ||
2459 | // InternalSolverLanguageParser.g:986:5: lv_kind_0_0= ruleAttributeKind | ||
2460 | { | ||
2461 | |||
2462 | newCompositeNode(grammarAccess.getAttributeAccess().getKindAttributeKindEnumRuleCall_0_0()); | ||
2463 | |||
2464 | pushFollow(FOLLOW_3); | ||
2465 | lv_kind_0_0=ruleAttributeKind(); | ||
2466 | |||
2467 | state._fsp--; | ||
2468 | |||
2469 | |||
2470 | if (current==null) { | ||
2471 | current = createModelElementForParent(grammarAccess.getAttributeRule()); | ||
2472 | } | ||
2473 | set( | ||
2474 | current, | ||
2475 | "kind", | ||
2476 | lv_kind_0_0, | ||
2477 | "org.eclipse.viatra.solver.language.SolverLanguage.AttributeKind"); | ||
2478 | afterParserOrEnumRuleCall(); | ||
2479 | |||
2480 | |||
2481 | } | ||
2482 | |||
2483 | |||
2484 | } | ||
2485 | |||
2486 | // InternalSolverLanguageParser.g:1003:3: ( ( ruleQualifiedName ) ) | ||
2487 | // InternalSolverLanguageParser.g:1004:4: ( ruleQualifiedName ) | ||
2488 | { | ||
2489 | // InternalSolverLanguageParser.g:1004:4: ( ruleQualifiedName ) | ||
2490 | // InternalSolverLanguageParser.g:1005:5: ruleQualifiedName | ||
2491 | { | ||
2492 | |||
2493 | if (current==null) { | ||
2494 | current = createModelElement(grammarAccess.getAttributeRule()); | ||
2495 | } | ||
2496 | |||
2497 | |||
2498 | newCompositeNode(grammarAccess.getAttributeAccess().getTargetSymbolCrossReference_1_0()); | ||
2499 | |||
2500 | pushFollow(FOLLOW_4); | ||
2501 | ruleQualifiedName(); | ||
2502 | |||
2503 | state._fsp--; | ||
2504 | |||
2505 | |||
2506 | afterParserOrEnumRuleCall(); | ||
2507 | |||
2508 | |||
2509 | } | ||
2510 | |||
2511 | |||
2512 | } | ||
2513 | |||
2514 | this_FULL_STOP_2=(Token)match(input,RULE_FULL_STOP,FOLLOW_2); | ||
2515 | |||
2516 | newLeafNode(this_FULL_STOP_2, grammarAccess.getAttributeAccess().getFULL_STOPTerminalRuleCall_2()); | ||
2517 | |||
2518 | |||
2519 | } | ||
2520 | |||
2521 | |||
2522 | } | ||
2523 | |||
2524 | |||
2525 | leaveRule(); | ||
2526 | |||
2527 | } | ||
2528 | |||
2529 | catch (RecognitionException re) { | ||
2530 | recover(input,re); | ||
2531 | appendSkippedTokens(); | ||
2532 | } | ||
2533 | finally { | ||
2534 | } | ||
2535 | return current; | ||
2536 | } | ||
2537 | // $ANTLR end "ruleAttribute" | ||
2538 | |||
2539 | |||
2540 | // $ANTLR start "entryRuleExternDeclaration" | ||
2541 | // InternalSolverLanguageParser.g:1027:1: entryRuleExternDeclaration returns [EObject current=null] : iv_ruleExternDeclaration= ruleExternDeclaration EOF ; | ||
2542 | public final EObject entryRuleExternDeclaration() throws RecognitionException { | ||
2543 | EObject current = null; | ||
2544 | |||
2545 | EObject iv_ruleExternDeclaration = null; | ||
2546 | |||
2547 | |||
2548 | try { | ||
2549 | // InternalSolverLanguageParser.g:1027:58: (iv_ruleExternDeclaration= ruleExternDeclaration EOF ) | ||
2550 | // InternalSolverLanguageParser.g:1028:2: iv_ruleExternDeclaration= ruleExternDeclaration EOF | ||
2551 | { | ||
2552 | newCompositeNode(grammarAccess.getExternDeclarationRule()); | ||
2553 | pushFollow(FOLLOW_1); | ||
2554 | iv_ruleExternDeclaration=ruleExternDeclaration(); | ||
2555 | |||
2556 | state._fsp--; | ||
2557 | |||
2558 | current =iv_ruleExternDeclaration; | ||
2559 | match(input,EOF,FOLLOW_2); | ||
2560 | |||
2561 | } | ||
2562 | |||
2563 | } | ||
2564 | |||
2565 | catch (RecognitionException re) { | ||
2566 | recover(input,re); | ||
2567 | appendSkippedTokens(); | ||
2568 | } | ||
2569 | finally { | ||
2570 | } | ||
2571 | return current; | ||
2572 | } | ||
2573 | // $ANTLR end "entryRuleExternDeclaration" | ||
2574 | |||
2575 | |||
2576 | // $ANTLR start "ruleExternDeclaration" | ||
2577 | // InternalSolverLanguageParser.g:1034:1: ruleExternDeclaration returns [EObject current=null] : (this_ExternPredicateDeclaration_0= ruleExternPredicateDeclaration | this_ExternFunctionDeclaration_1= ruleExternFunctionDeclaration | this_ExternAggregationOperatorDeclaration_2= ruleExternAggregationOperatorDeclaration | this_ExternDatatypeDeclaration_3= ruleExternDatatypeDeclaration ) ; | ||
2578 | public final EObject ruleExternDeclaration() throws RecognitionException { | ||
2579 | EObject current = null; | ||
2580 | |||
2581 | EObject this_ExternPredicateDeclaration_0 = null; | ||
2582 | |||
2583 | EObject this_ExternFunctionDeclaration_1 = null; | ||
2584 | |||
2585 | EObject this_ExternAggregationOperatorDeclaration_2 = null; | ||
2586 | |||
2587 | EObject this_ExternDatatypeDeclaration_3 = null; | ||
2588 | |||
2589 | |||
2590 | |||
2591 | enterRule(); | ||
2592 | |||
2593 | try { | ||
2594 | // InternalSolverLanguageParser.g:1040:2: ( (this_ExternPredicateDeclaration_0= ruleExternPredicateDeclaration | this_ExternFunctionDeclaration_1= ruleExternFunctionDeclaration | this_ExternAggregationOperatorDeclaration_2= ruleExternAggregationOperatorDeclaration | this_ExternDatatypeDeclaration_3= ruleExternDatatypeDeclaration ) ) | ||
2595 | // InternalSolverLanguageParser.g:1041:2: (this_ExternPredicateDeclaration_0= ruleExternPredicateDeclaration | this_ExternFunctionDeclaration_1= ruleExternFunctionDeclaration | this_ExternAggregationOperatorDeclaration_2= ruleExternAggregationOperatorDeclaration | this_ExternDatatypeDeclaration_3= ruleExternDatatypeDeclaration ) | ||
2596 | { | ||
2597 | // InternalSolverLanguageParser.g:1041:2: (this_ExternPredicateDeclaration_0= ruleExternPredicateDeclaration | this_ExternFunctionDeclaration_1= ruleExternFunctionDeclaration | this_ExternAggregationOperatorDeclaration_2= ruleExternAggregationOperatorDeclaration | this_ExternDatatypeDeclaration_3= ruleExternDatatypeDeclaration ) | ||
2598 | int alt13=4; | ||
2599 | alt13 = dfa13.predict(input); | ||
2600 | switch (alt13) { | ||
2601 | case 1 : | ||
2602 | // InternalSolverLanguageParser.g:1042:3: this_ExternPredicateDeclaration_0= ruleExternPredicateDeclaration | ||
2603 | { | ||
2604 | |||
2605 | newCompositeNode(grammarAccess.getExternDeclarationAccess().getExternPredicateDeclarationParserRuleCall_0()); | ||
2606 | |||
2607 | pushFollow(FOLLOW_2); | ||
2608 | this_ExternPredicateDeclaration_0=ruleExternPredicateDeclaration(); | ||
2609 | |||
2610 | state._fsp--; | ||
2611 | |||
2612 | |||
2613 | current = this_ExternPredicateDeclaration_0; | ||
2614 | afterParserOrEnumRuleCall(); | ||
2615 | |||
2616 | |||
2617 | } | ||
2618 | break; | ||
2619 | case 2 : | ||
2620 | // InternalSolverLanguageParser.g:1051:3: this_ExternFunctionDeclaration_1= ruleExternFunctionDeclaration | ||
2621 | { | ||
2622 | |||
2623 | newCompositeNode(grammarAccess.getExternDeclarationAccess().getExternFunctionDeclarationParserRuleCall_1()); | ||
2624 | |||
2625 | pushFollow(FOLLOW_2); | ||
2626 | this_ExternFunctionDeclaration_1=ruleExternFunctionDeclaration(); | ||
2627 | |||
2628 | state._fsp--; | ||
2629 | |||
2630 | |||
2631 | current = this_ExternFunctionDeclaration_1; | ||
2632 | afterParserOrEnumRuleCall(); | ||
2633 | |||
2634 | |||
2635 | } | ||
2636 | break; | ||
2637 | case 3 : | ||
2638 | // InternalSolverLanguageParser.g:1060:3: this_ExternAggregationOperatorDeclaration_2= ruleExternAggregationOperatorDeclaration | ||
2639 | { | ||
2640 | |||
2641 | newCompositeNode(grammarAccess.getExternDeclarationAccess().getExternAggregationOperatorDeclarationParserRuleCall_2()); | ||
2642 | |||
2643 | pushFollow(FOLLOW_2); | ||
2644 | this_ExternAggregationOperatorDeclaration_2=ruleExternAggregationOperatorDeclaration(); | ||
2645 | |||
2646 | state._fsp--; | ||
2647 | |||
2648 | |||
2649 | current = this_ExternAggregationOperatorDeclaration_2; | ||
2650 | afterParserOrEnumRuleCall(); | ||
2651 | |||
2652 | |||
2653 | } | ||
2654 | break; | ||
2655 | case 4 : | ||
2656 | // InternalSolverLanguageParser.g:1069:3: this_ExternDatatypeDeclaration_3= ruleExternDatatypeDeclaration | ||
2657 | { | ||
2658 | |||
2659 | newCompositeNode(grammarAccess.getExternDeclarationAccess().getExternDatatypeDeclarationParserRuleCall_3()); | ||
2660 | |||
2661 | pushFollow(FOLLOW_2); | ||
2662 | this_ExternDatatypeDeclaration_3=ruleExternDatatypeDeclaration(); | ||
2663 | |||
2664 | state._fsp--; | ||
2665 | |||
2666 | |||
2667 | current = this_ExternDatatypeDeclaration_3; | ||
2668 | afterParserOrEnumRuleCall(); | ||
2669 | |||
2670 | |||
2671 | } | ||
2672 | break; | ||
2673 | |||
2674 | } | ||
2675 | |||
2676 | |||
2677 | } | ||
2678 | |||
2679 | |||
2680 | leaveRule(); | ||
2681 | |||
2682 | } | ||
2683 | |||
2684 | catch (RecognitionException re) { | ||
2685 | recover(input,re); | ||
2686 | appendSkippedTokens(); | ||
2687 | } | ||
2688 | finally { | ||
2689 | } | ||
2690 | return current; | ||
2691 | } | ||
2692 | // $ANTLR end "ruleExternDeclaration" | ||
2693 | |||
2694 | |||
2695 | // $ANTLR start "entryRuleExternPredicateDeclaration" | ||
2696 | // InternalSolverLanguageParser.g:1081:1: entryRuleExternPredicateDeclaration returns [EObject current=null] : iv_ruleExternPredicateDeclaration= ruleExternPredicateDeclaration EOF ; | ||
2697 | public final EObject entryRuleExternPredicateDeclaration() throws RecognitionException { | ||
2698 | EObject current = null; | ||
2699 | |||
2700 | EObject iv_ruleExternPredicateDeclaration = null; | ||
2701 | |||
2702 | |||
2703 | try { | ||
2704 | // InternalSolverLanguageParser.g:1081:67: (iv_ruleExternPredicateDeclaration= ruleExternPredicateDeclaration EOF ) | ||
2705 | // InternalSolverLanguageParser.g:1082:2: iv_ruleExternPredicateDeclaration= ruleExternPredicateDeclaration EOF | ||
2706 | { | ||
2707 | newCompositeNode(grammarAccess.getExternPredicateDeclarationRule()); | ||
2708 | pushFollow(FOLLOW_1); | ||
2709 | iv_ruleExternPredicateDeclaration=ruleExternPredicateDeclaration(); | ||
2710 | |||
2711 | state._fsp--; | ||
2712 | |||
2713 | current =iv_ruleExternPredicateDeclaration; | ||
2714 | match(input,EOF,FOLLOW_2); | ||
2715 | |||
2716 | } | ||
2717 | |||
2718 | } | ||
2719 | |||
2720 | catch (RecognitionException re) { | ||
2721 | recover(input,re); | ||
2722 | appendSkippedTokens(); | ||
2723 | } | ||
2724 | finally { | ||
2725 | } | ||
2726 | return current; | ||
2727 | } | ||
2728 | // $ANTLR end "entryRuleExternPredicateDeclaration" | ||
2729 | |||
2730 | |||
2731 | // $ANTLR start "ruleExternPredicateDeclaration" | ||
2732 | // InternalSolverLanguageParser.g:1088:1: ruleExternPredicateDeclaration returns [EObject current=null] : (otherlv_0= Extern ( ( ( ( ({...}? => ( ({...}? => ( (lv_functional_2_0= Functional ) ) ) ) ) | ({...}? => ( ({...}? => ( (lv_error_3_0= Error ) ) ) ) ) )* ) ) ) ( (lv_name_4_0= ruleQualifiedName ) ) ( (lv_argumentList_5_0= ruleArgumentList ) ) this_FULL_STOP_6= RULE_FULL_STOP ) ; | ||
2733 | public final EObject ruleExternPredicateDeclaration() throws RecognitionException { | ||
2734 | EObject current = null; | ||
2735 | |||
2736 | Token otherlv_0=null; | ||
2737 | Token lv_functional_2_0=null; | ||
2738 | Token lv_error_3_0=null; | ||
2739 | Token this_FULL_STOP_6=null; | ||
2740 | AntlrDatatypeRuleToken lv_name_4_0 = null; | ||
2741 | |||
2742 | EObject lv_argumentList_5_0 = null; | ||
2743 | |||
2744 | |||
2745 | |||
2746 | enterRule(); | ||
2747 | |||
2748 | try { | ||
2749 | // InternalSolverLanguageParser.g:1094:2: ( (otherlv_0= Extern ( ( ( ( ({...}? => ( ({...}? => ( (lv_functional_2_0= Functional ) ) ) ) ) | ({...}? => ( ({...}? => ( (lv_error_3_0= Error ) ) ) ) ) )* ) ) ) ( (lv_name_4_0= ruleQualifiedName ) ) ( (lv_argumentList_5_0= ruleArgumentList ) ) this_FULL_STOP_6= RULE_FULL_STOP ) ) | ||
2750 | // InternalSolverLanguageParser.g:1095:2: (otherlv_0= Extern ( ( ( ( ({...}? => ( ({...}? => ( (lv_functional_2_0= Functional ) ) ) ) ) | ({...}? => ( ({...}? => ( (lv_error_3_0= Error ) ) ) ) ) )* ) ) ) ( (lv_name_4_0= ruleQualifiedName ) ) ( (lv_argumentList_5_0= ruleArgumentList ) ) this_FULL_STOP_6= RULE_FULL_STOP ) | ||
2751 | { | ||
2752 | // InternalSolverLanguageParser.g:1095:2: (otherlv_0= Extern ( ( ( ( ({...}? => ( ({...}? => ( (lv_functional_2_0= Functional ) ) ) ) ) | ({...}? => ( ({...}? => ( (lv_error_3_0= Error ) ) ) ) ) )* ) ) ) ( (lv_name_4_0= ruleQualifiedName ) ) ( (lv_argumentList_5_0= ruleArgumentList ) ) this_FULL_STOP_6= RULE_FULL_STOP ) | ||
2753 | // InternalSolverLanguageParser.g:1096:3: otherlv_0= Extern ( ( ( ( ({...}? => ( ({...}? => ( (lv_functional_2_0= Functional ) ) ) ) ) | ({...}? => ( ({...}? => ( (lv_error_3_0= Error ) ) ) ) ) )* ) ) ) ( (lv_name_4_0= ruleQualifiedName ) ) ( (lv_argumentList_5_0= ruleArgumentList ) ) this_FULL_STOP_6= RULE_FULL_STOP | ||
2754 | { | ||
2755 | otherlv_0=(Token)match(input,Extern,FOLLOW_19); | ||
2756 | |||
2757 | newLeafNode(otherlv_0, grammarAccess.getExternPredicateDeclarationAccess().getExternKeyword_0()); | ||
2758 | |||
2759 | // InternalSolverLanguageParser.g:1100:3: ( ( ( ( ({...}? => ( ({...}? => ( (lv_functional_2_0= Functional ) ) ) ) ) | ({...}? => ( ({...}? => ( (lv_error_3_0= Error ) ) ) ) ) )* ) ) ) | ||
2760 | // InternalSolverLanguageParser.g:1101:4: ( ( ( ({...}? => ( ({...}? => ( (lv_functional_2_0= Functional ) ) ) ) ) | ({...}? => ( ({...}? => ( (lv_error_3_0= Error ) ) ) ) ) )* ) ) | ||
2761 | { | ||
2762 | // InternalSolverLanguageParser.g:1101:4: ( ( ( ({...}? => ( ({...}? => ( (lv_functional_2_0= Functional ) ) ) ) ) | ({...}? => ( ({...}? => ( (lv_error_3_0= Error ) ) ) ) ) )* ) ) | ||
2763 | // InternalSolverLanguageParser.g:1102:5: ( ( ({...}? => ( ({...}? => ( (lv_functional_2_0= Functional ) ) ) ) ) | ({...}? => ( ({...}? => ( (lv_error_3_0= Error ) ) ) ) ) )* ) | ||
2764 | { | ||
2765 | |||
2766 | getUnorderedGroupHelper().enter(grammarAccess.getExternPredicateDeclarationAccess().getUnorderedGroup_1()); | ||
2767 | |||
2768 | // InternalSolverLanguageParser.g:1105:5: ( ( ({...}? => ( ({...}? => ( (lv_functional_2_0= Functional ) ) ) ) ) | ({...}? => ( ({...}? => ( (lv_error_3_0= Error ) ) ) ) ) )* ) | ||
2769 | // InternalSolverLanguageParser.g:1106:6: ( ({...}? => ( ({...}? => ( (lv_functional_2_0= Functional ) ) ) ) ) | ({...}? => ( ({...}? => ( (lv_error_3_0= Error ) ) ) ) ) )* | ||
2770 | { | ||
2771 | // InternalSolverLanguageParser.g:1106:6: ( ({...}? => ( ({...}? => ( (lv_functional_2_0= Functional ) ) ) ) ) | ({...}? => ( ({...}? => ( (lv_error_3_0= Error ) ) ) ) ) )* | ||
2772 | loop14: | ||
2773 | do { | ||
2774 | int alt14=3; | ||
2775 | int LA14_0 = input.LA(1); | ||
2776 | |||
2777 | if ( LA14_0 == Functional && getUnorderedGroupHelper().canSelect(grammarAccess.getExternPredicateDeclarationAccess().getUnorderedGroup_1(), 0) ) { | ||
2778 | alt14=1; | ||
2779 | } | ||
2780 | else if ( LA14_0 == Error && getUnorderedGroupHelper().canSelect(grammarAccess.getExternPredicateDeclarationAccess().getUnorderedGroup_1(), 1) ) { | ||
2781 | alt14=2; | ||
2782 | } | ||
2783 | |||
2784 | |||
2785 | switch (alt14) { | ||
2786 | case 1 : | ||
2787 | // InternalSolverLanguageParser.g:1107:4: ({...}? => ( ({...}? => ( (lv_functional_2_0= Functional ) ) ) ) ) | ||
2788 | { | ||
2789 | // InternalSolverLanguageParser.g:1107:4: ({...}? => ( ({...}? => ( (lv_functional_2_0= Functional ) ) ) ) ) | ||
2790 | // InternalSolverLanguageParser.g:1108:5: {...}? => ( ({...}? => ( (lv_functional_2_0= Functional ) ) ) ) | ||
2791 | { | ||
2792 | if ( ! getUnorderedGroupHelper().canSelect(grammarAccess.getExternPredicateDeclarationAccess().getUnorderedGroup_1(), 0) ) { | ||
2793 | throw new FailedPredicateException(input, "ruleExternPredicateDeclaration", "getUnorderedGroupHelper().canSelect(grammarAccess.getExternPredicateDeclarationAccess().getUnorderedGroup_1(), 0)"); | ||
2794 | } | ||
2795 | // InternalSolverLanguageParser.g:1108:123: ( ({...}? => ( (lv_functional_2_0= Functional ) ) ) ) | ||
2796 | // InternalSolverLanguageParser.g:1109:6: ({...}? => ( (lv_functional_2_0= Functional ) ) ) | ||
2797 | { | ||
2798 | |||
2799 | getUnorderedGroupHelper().select(grammarAccess.getExternPredicateDeclarationAccess().getUnorderedGroup_1(), 0); | ||
2800 | |||
2801 | // InternalSolverLanguageParser.g:1112:9: ({...}? => ( (lv_functional_2_0= Functional ) ) ) | ||
2802 | // InternalSolverLanguageParser.g:1112:10: {...}? => ( (lv_functional_2_0= Functional ) ) | ||
2803 | { | ||
2804 | if ( !((true)) ) { | ||
2805 | throw new FailedPredicateException(input, "ruleExternPredicateDeclaration", "true"); | ||
2806 | } | ||
2807 | // InternalSolverLanguageParser.g:1112:19: ( (lv_functional_2_0= Functional ) ) | ||
2808 | // InternalSolverLanguageParser.g:1112:20: (lv_functional_2_0= Functional ) | ||
2809 | { | ||
2810 | // InternalSolverLanguageParser.g:1112:20: (lv_functional_2_0= Functional ) | ||
2811 | // InternalSolverLanguageParser.g:1113:10: lv_functional_2_0= Functional | ||
2812 | { | ||
2813 | lv_functional_2_0=(Token)match(input,Functional,FOLLOW_19); | ||
2814 | |||
2815 | newLeafNode(lv_functional_2_0, grammarAccess.getExternPredicateDeclarationAccess().getFunctionalFunctionalKeyword_1_0_0()); | ||
2816 | |||
2817 | |||
2818 | if (current==null) { | ||
2819 | current = createModelElement(grammarAccess.getExternPredicateDeclarationRule()); | ||
2820 | } | ||
2821 | setWithLastConsumed(current, "functional", true, "functional"); | ||
2822 | |||
2823 | |||
2824 | } | ||
2825 | |||
2826 | |||
2827 | } | ||
2828 | |||
2829 | |||
2830 | } | ||
2831 | |||
2832 | |||
2833 | getUnorderedGroupHelper().returnFromSelection(grammarAccess.getExternPredicateDeclarationAccess().getUnorderedGroup_1()); | ||
2834 | |||
2835 | |||
2836 | } | ||
2837 | |||
2838 | |||
2839 | } | ||
2840 | |||
2841 | |||
2842 | } | ||
2843 | break; | ||
2844 | case 2 : | ||
2845 | // InternalSolverLanguageParser.g:1130:4: ({...}? => ( ({...}? => ( (lv_error_3_0= Error ) ) ) ) ) | ||
2846 | { | ||
2847 | // InternalSolverLanguageParser.g:1130:4: ({...}? => ( ({...}? => ( (lv_error_3_0= Error ) ) ) ) ) | ||
2848 | // InternalSolverLanguageParser.g:1131:5: {...}? => ( ({...}? => ( (lv_error_3_0= Error ) ) ) ) | ||
2849 | { | ||
2850 | if ( ! getUnorderedGroupHelper().canSelect(grammarAccess.getExternPredicateDeclarationAccess().getUnorderedGroup_1(), 1) ) { | ||
2851 | throw new FailedPredicateException(input, "ruleExternPredicateDeclaration", "getUnorderedGroupHelper().canSelect(grammarAccess.getExternPredicateDeclarationAccess().getUnorderedGroup_1(), 1)"); | ||
2852 | } | ||
2853 | // InternalSolverLanguageParser.g:1131:123: ( ({...}? => ( (lv_error_3_0= Error ) ) ) ) | ||
2854 | // InternalSolverLanguageParser.g:1132:6: ({...}? => ( (lv_error_3_0= Error ) ) ) | ||
2855 | { | ||
2856 | |||
2857 | getUnorderedGroupHelper().select(grammarAccess.getExternPredicateDeclarationAccess().getUnorderedGroup_1(), 1); | ||
2858 | |||
2859 | // InternalSolverLanguageParser.g:1135:9: ({...}? => ( (lv_error_3_0= Error ) ) ) | ||
2860 | // InternalSolverLanguageParser.g:1135:10: {...}? => ( (lv_error_3_0= Error ) ) | ||
2861 | { | ||
2862 | if ( !((true)) ) { | ||
2863 | throw new FailedPredicateException(input, "ruleExternPredicateDeclaration", "true"); | ||
2864 | } | ||
2865 | // InternalSolverLanguageParser.g:1135:19: ( (lv_error_3_0= Error ) ) | ||
2866 | // InternalSolverLanguageParser.g:1135:20: (lv_error_3_0= Error ) | ||
2867 | { | ||
2868 | // InternalSolverLanguageParser.g:1135:20: (lv_error_3_0= Error ) | ||
2869 | // InternalSolverLanguageParser.g:1136:10: lv_error_3_0= Error | ||
2870 | { | ||
2871 | lv_error_3_0=(Token)match(input,Error,FOLLOW_19); | ||
2872 | |||
2873 | newLeafNode(lv_error_3_0, grammarAccess.getExternPredicateDeclarationAccess().getErrorErrorKeyword_1_1_0()); | ||
2874 | |||
2875 | |||
2876 | if (current==null) { | ||
2877 | current = createModelElement(grammarAccess.getExternPredicateDeclarationRule()); | ||
2878 | } | ||
2879 | setWithLastConsumed(current, "error", true, "error"); | ||
2880 | |||
2881 | |||
2882 | } | ||
2883 | |||
2884 | |||
2885 | } | ||
2886 | |||
2887 | |||
2888 | } | ||
2889 | |||
2890 | |||
2891 | getUnorderedGroupHelper().returnFromSelection(grammarAccess.getExternPredicateDeclarationAccess().getUnorderedGroup_1()); | ||
2892 | |||
2893 | |||
2894 | } | ||
2895 | |||
2896 | |||
2897 | } | ||
2898 | |||
2899 | |||
2900 | } | ||
2901 | break; | ||
2902 | |||
2903 | default : | ||
2904 | break loop14; | ||
2905 | } | ||
2906 | } while (true); | ||
2907 | |||
2908 | |||
2909 | } | ||
2910 | |||
2911 | |||
2912 | } | ||
2913 | |||
2914 | |||
2915 | getUnorderedGroupHelper().leave(grammarAccess.getExternPredicateDeclarationAccess().getUnorderedGroup_1()); | ||
2916 | |||
2917 | |||
2918 | } | ||
2919 | |||
2920 | // InternalSolverLanguageParser.g:1160:3: ( (lv_name_4_0= ruleQualifiedName ) ) | ||
2921 | // InternalSolverLanguageParser.g:1161:4: (lv_name_4_0= ruleQualifiedName ) | ||
2922 | { | ||
2923 | // InternalSolverLanguageParser.g:1161:4: (lv_name_4_0= ruleQualifiedName ) | ||
2924 | // InternalSolverLanguageParser.g:1162:5: lv_name_4_0= ruleQualifiedName | ||
2925 | { | ||
2926 | |||
2927 | newCompositeNode(grammarAccess.getExternPredicateDeclarationAccess().getNameQualifiedNameParserRuleCall_2_0()); | ||
2928 | |||
2929 | pushFollow(FOLLOW_15); | ||
2930 | lv_name_4_0=ruleQualifiedName(); | ||
2931 | |||
2932 | state._fsp--; | ||
2933 | |||
2934 | |||
2935 | if (current==null) { | ||
2936 | current = createModelElementForParent(grammarAccess.getExternPredicateDeclarationRule()); | ||
2937 | } | ||
2938 | set( | ||
2939 | current, | ||
2940 | "name", | ||
2941 | lv_name_4_0, | ||
2942 | "org.eclipse.viatra.solver.language.SolverLanguage.QualifiedName"); | ||
2943 | afterParserOrEnumRuleCall(); | ||
2944 | |||
2945 | |||
2946 | } | ||
2947 | |||
2948 | |||
2949 | } | ||
2950 | |||
2951 | // InternalSolverLanguageParser.g:1179:3: ( (lv_argumentList_5_0= ruleArgumentList ) ) | ||
2952 | // InternalSolverLanguageParser.g:1180:4: (lv_argumentList_5_0= ruleArgumentList ) | ||
2953 | { | ||
2954 | // InternalSolverLanguageParser.g:1180:4: (lv_argumentList_5_0= ruleArgumentList ) | ||
2955 | // InternalSolverLanguageParser.g:1181:5: lv_argumentList_5_0= ruleArgumentList | ||
2956 | { | ||
2957 | |||
2958 | newCompositeNode(grammarAccess.getExternPredicateDeclarationAccess().getArgumentListArgumentListParserRuleCall_3_0()); | ||
2959 | |||
2960 | pushFollow(FOLLOW_4); | ||
2961 | lv_argumentList_5_0=ruleArgumentList(); | ||
2962 | |||
2963 | state._fsp--; | ||
2964 | |||
2965 | |||
2966 | if (current==null) { | ||
2967 | current = createModelElementForParent(grammarAccess.getExternPredicateDeclarationRule()); | ||
2968 | } | ||
2969 | set( | ||
2970 | current, | ||
2971 | "argumentList", | ||
2972 | lv_argumentList_5_0, | ||
2973 | "org.eclipse.viatra.solver.language.SolverLanguage.ArgumentList"); | ||
2974 | afterParserOrEnumRuleCall(); | ||
2975 | |||
2976 | |||
2977 | } | ||
2978 | |||
2979 | |||
2980 | } | ||
2981 | |||
2982 | this_FULL_STOP_6=(Token)match(input,RULE_FULL_STOP,FOLLOW_2); | ||
2983 | |||
2984 | newLeafNode(this_FULL_STOP_6, grammarAccess.getExternPredicateDeclarationAccess().getFULL_STOPTerminalRuleCall_4()); | ||
2985 | |||
2986 | |||
2987 | } | ||
2988 | |||
2989 | |||
2990 | } | ||
2991 | |||
2992 | |||
2993 | leaveRule(); | ||
2994 | |||
2995 | } | ||
2996 | |||
2997 | catch (RecognitionException re) { | ||
2998 | recover(input,re); | ||
2999 | appendSkippedTokens(); | ||
3000 | } | ||
3001 | finally { | ||
3002 | } | ||
3003 | return current; | ||
3004 | } | ||
3005 | // $ANTLR end "ruleExternPredicateDeclaration" | ||
3006 | |||
3007 | |||
3008 | // $ANTLR start "entryRuleExternFunctionDeclaration" | ||
3009 | // InternalSolverLanguageParser.g:1206:1: entryRuleExternFunctionDeclaration returns [EObject current=null] : iv_ruleExternFunctionDeclaration= ruleExternFunctionDeclaration EOF ; | ||
3010 | public final EObject entryRuleExternFunctionDeclaration() throws RecognitionException { | ||
3011 | EObject current = null; | ||
3012 | |||
3013 | EObject iv_ruleExternFunctionDeclaration = null; | ||
3014 | |||
3015 | |||
3016 | try { | ||
3017 | // InternalSolverLanguageParser.g:1206:66: (iv_ruleExternFunctionDeclaration= ruleExternFunctionDeclaration EOF ) | ||
3018 | // InternalSolverLanguageParser.g:1207:2: iv_ruleExternFunctionDeclaration= ruleExternFunctionDeclaration EOF | ||
3019 | { | ||
3020 | newCompositeNode(grammarAccess.getExternFunctionDeclarationRule()); | ||
3021 | pushFollow(FOLLOW_1); | ||
3022 | iv_ruleExternFunctionDeclaration=ruleExternFunctionDeclaration(); | ||
3023 | |||
3024 | state._fsp--; | ||
3025 | |||
3026 | current =iv_ruleExternFunctionDeclaration; | ||
3027 | match(input,EOF,FOLLOW_2); | ||
3028 | |||
3029 | } | ||
3030 | |||
3031 | } | ||
3032 | |||
3033 | catch (RecognitionException re) { | ||
3034 | recover(input,re); | ||
3035 | appendSkippedTokens(); | ||
3036 | } | ||
3037 | finally { | ||
3038 | } | ||
3039 | return current; | ||
3040 | } | ||
3041 | // $ANTLR end "entryRuleExternFunctionDeclaration" | ||
3042 | |||
3043 | |||
3044 | // $ANTLR start "ruleExternFunctionDeclaration" | ||
3045 | // InternalSolverLanguageParser.g:1213:1: ruleExternFunctionDeclaration returns [EObject current=null] : (otherlv_0= Extern ( ( ruleQualifiedName ) ) ( (lv_name_2_0= ruleQualifiedName ) ) ( (lv_argumentList_3_0= ruleArgumentList ) ) this_FULL_STOP_4= RULE_FULL_STOP ) ; | ||
3046 | public final EObject ruleExternFunctionDeclaration() throws RecognitionException { | ||
3047 | EObject current = null; | ||
3048 | |||
3049 | Token otherlv_0=null; | ||
3050 | Token this_FULL_STOP_4=null; | ||
3051 | AntlrDatatypeRuleToken lv_name_2_0 = null; | ||
3052 | |||
3053 | EObject lv_argumentList_3_0 = null; | ||
3054 | |||
3055 | |||
3056 | |||
3057 | enterRule(); | ||
3058 | |||
3059 | try { | ||
3060 | // InternalSolverLanguageParser.g:1219:2: ( (otherlv_0= Extern ( ( ruleQualifiedName ) ) ( (lv_name_2_0= ruleQualifiedName ) ) ( (lv_argumentList_3_0= ruleArgumentList ) ) this_FULL_STOP_4= RULE_FULL_STOP ) ) | ||
3061 | // InternalSolverLanguageParser.g:1220:2: (otherlv_0= Extern ( ( ruleQualifiedName ) ) ( (lv_name_2_0= ruleQualifiedName ) ) ( (lv_argumentList_3_0= ruleArgumentList ) ) this_FULL_STOP_4= RULE_FULL_STOP ) | ||
3062 | { | ||
3063 | // InternalSolverLanguageParser.g:1220:2: (otherlv_0= Extern ( ( ruleQualifiedName ) ) ( (lv_name_2_0= ruleQualifiedName ) ) ( (lv_argumentList_3_0= ruleArgumentList ) ) this_FULL_STOP_4= RULE_FULL_STOP ) | ||
3064 | // InternalSolverLanguageParser.g:1221:3: otherlv_0= Extern ( ( ruleQualifiedName ) ) ( (lv_name_2_0= ruleQualifiedName ) ) ( (lv_argumentList_3_0= ruleArgumentList ) ) this_FULL_STOP_4= RULE_FULL_STOP | ||
3065 | { | ||
3066 | otherlv_0=(Token)match(input,Extern,FOLLOW_3); | ||
3067 | |||
3068 | newLeafNode(otherlv_0, grammarAccess.getExternFunctionDeclarationAccess().getExternKeyword_0()); | ||
3069 | |||
3070 | // InternalSolverLanguageParser.g:1225:3: ( ( ruleQualifiedName ) ) | ||
3071 | // InternalSolverLanguageParser.g:1226:4: ( ruleQualifiedName ) | ||
3072 | { | ||
3073 | // InternalSolverLanguageParser.g:1226:4: ( ruleQualifiedName ) | ||
3074 | // InternalSolverLanguageParser.g:1227:5: ruleQualifiedName | ||
3075 | { | ||
3076 | |||
3077 | if (current==null) { | ||
3078 | current = createModelElement(grammarAccess.getExternFunctionDeclarationRule()); | ||
3079 | } | ||
3080 | |||
3081 | |||
3082 | newCompositeNode(grammarAccess.getExternFunctionDeclarationAccess().getResultTypeSymbolCrossReference_1_0()); | ||
3083 | |||
3084 | pushFollow(FOLLOW_3); | ||
3085 | ruleQualifiedName(); | ||
3086 | |||
3087 | state._fsp--; | ||
3088 | |||
3089 | |||
3090 | afterParserOrEnumRuleCall(); | ||
3091 | |||
3092 | |||
3093 | } | ||
3094 | |||
3095 | |||
3096 | } | ||
3097 | |||
3098 | // InternalSolverLanguageParser.g:1241:3: ( (lv_name_2_0= ruleQualifiedName ) ) | ||
3099 | // InternalSolverLanguageParser.g:1242:4: (lv_name_2_0= ruleQualifiedName ) | ||
3100 | { | ||
3101 | // InternalSolverLanguageParser.g:1242:4: (lv_name_2_0= ruleQualifiedName ) | ||
3102 | // InternalSolverLanguageParser.g:1243:5: lv_name_2_0= ruleQualifiedName | ||
3103 | { | ||
3104 | |||
3105 | newCompositeNode(grammarAccess.getExternFunctionDeclarationAccess().getNameQualifiedNameParserRuleCall_2_0()); | ||
3106 | |||
3107 | pushFollow(FOLLOW_15); | ||
3108 | lv_name_2_0=ruleQualifiedName(); | ||
3109 | |||
3110 | state._fsp--; | ||
3111 | |||
3112 | |||
3113 | if (current==null) { | ||
3114 | current = createModelElementForParent(grammarAccess.getExternFunctionDeclarationRule()); | ||
3115 | } | ||
3116 | set( | ||
3117 | current, | ||
3118 | "name", | ||
3119 | lv_name_2_0, | ||
3120 | "org.eclipse.viatra.solver.language.SolverLanguage.QualifiedName"); | ||
3121 | afterParserOrEnumRuleCall(); | ||
3122 | |||
3123 | |||
3124 | } | ||
3125 | |||
3126 | |||
3127 | } | ||
3128 | |||
3129 | // InternalSolverLanguageParser.g:1260:3: ( (lv_argumentList_3_0= ruleArgumentList ) ) | ||
3130 | // InternalSolverLanguageParser.g:1261:4: (lv_argumentList_3_0= ruleArgumentList ) | ||
3131 | { | ||
3132 | // InternalSolverLanguageParser.g:1261:4: (lv_argumentList_3_0= ruleArgumentList ) | ||
3133 | // InternalSolverLanguageParser.g:1262:5: lv_argumentList_3_0= ruleArgumentList | ||
3134 | { | ||
3135 | |||
3136 | newCompositeNode(grammarAccess.getExternFunctionDeclarationAccess().getArgumentListArgumentListParserRuleCall_3_0()); | ||
3137 | |||
3138 | pushFollow(FOLLOW_4); | ||
3139 | lv_argumentList_3_0=ruleArgumentList(); | ||
3140 | |||
3141 | state._fsp--; | ||
3142 | |||
3143 | |||
3144 | if (current==null) { | ||
3145 | current = createModelElementForParent(grammarAccess.getExternFunctionDeclarationRule()); | ||
3146 | } | ||
3147 | set( | ||
3148 | current, | ||
3149 | "argumentList", | ||
3150 | lv_argumentList_3_0, | ||
3151 | "org.eclipse.viatra.solver.language.SolverLanguage.ArgumentList"); | ||
3152 | afterParserOrEnumRuleCall(); | ||
3153 | |||
3154 | |||
3155 | } | ||
3156 | |||
3157 | |||
3158 | } | ||
3159 | |||
3160 | this_FULL_STOP_4=(Token)match(input,RULE_FULL_STOP,FOLLOW_2); | ||
3161 | |||
3162 | newLeafNode(this_FULL_STOP_4, grammarAccess.getExternFunctionDeclarationAccess().getFULL_STOPTerminalRuleCall_4()); | ||
3163 | |||
3164 | |||
3165 | } | ||
3166 | |||
3167 | |||
3168 | } | ||
3169 | |||
3170 | |||
3171 | leaveRule(); | ||
3172 | |||
3173 | } | ||
3174 | |||
3175 | catch (RecognitionException re) { | ||
3176 | recover(input,re); | ||
3177 | appendSkippedTokens(); | ||
3178 | } | ||
3179 | finally { | ||
3180 | } | ||
3181 | return current; | ||
3182 | } | ||
3183 | // $ANTLR end "ruleExternFunctionDeclaration" | ||
3184 | |||
3185 | |||
3186 | // $ANTLR start "entryRuleExternAggregationOperatorDeclaration" | ||
3187 | // InternalSolverLanguageParser.g:1287:1: entryRuleExternAggregationOperatorDeclaration returns [EObject current=null] : iv_ruleExternAggregationOperatorDeclaration= ruleExternAggregationOperatorDeclaration EOF ; | ||
3188 | public final EObject entryRuleExternAggregationOperatorDeclaration() throws RecognitionException { | ||
3189 | EObject current = null; | ||
3190 | |||
3191 | EObject iv_ruleExternAggregationOperatorDeclaration = null; | ||
3192 | |||
3193 | |||
3194 | try { | ||
3195 | // InternalSolverLanguageParser.g:1287:77: (iv_ruleExternAggregationOperatorDeclaration= ruleExternAggregationOperatorDeclaration EOF ) | ||
3196 | // InternalSolverLanguageParser.g:1288:2: iv_ruleExternAggregationOperatorDeclaration= ruleExternAggregationOperatorDeclaration EOF | ||
3197 | { | ||
3198 | newCompositeNode(grammarAccess.getExternAggregationOperatorDeclarationRule()); | ||
3199 | pushFollow(FOLLOW_1); | ||
3200 | iv_ruleExternAggregationOperatorDeclaration=ruleExternAggregationOperatorDeclaration(); | ||
3201 | |||
3202 | state._fsp--; | ||
3203 | |||
3204 | current =iv_ruleExternAggregationOperatorDeclaration; | ||
3205 | match(input,EOF,FOLLOW_2); | ||
3206 | |||
3207 | } | ||
3208 | |||
3209 | } | ||
3210 | |||
3211 | catch (RecognitionException re) { | ||
3212 | recover(input,re); | ||
3213 | appendSkippedTokens(); | ||
3214 | } | ||
3215 | finally { | ||
3216 | } | ||
3217 | return current; | ||
3218 | } | ||
3219 | // $ANTLR end "entryRuleExternAggregationOperatorDeclaration" | ||
3220 | |||
3221 | |||
3222 | // $ANTLR start "ruleExternAggregationOperatorDeclaration" | ||
3223 | // InternalSolverLanguageParser.g:1294:1: ruleExternAggregationOperatorDeclaration returns [EObject current=null] : (otherlv_0= Extern ( ( ruleQualifiedName ) ) ( (lv_name_2_0= ruleQualifiedName ) ) otherlv_3= LeftCurlyBracket ( ( ruleQualifiedName ) ) otherlv_5= FullStopFullStopFullStop otherlv_6= RightCurlyBracket this_FULL_STOP_7= RULE_FULL_STOP ) ; | ||
3224 | public final EObject ruleExternAggregationOperatorDeclaration() throws RecognitionException { | ||
3225 | EObject current = null; | ||
3226 | |||
3227 | Token otherlv_0=null; | ||
3228 | Token otherlv_3=null; | ||
3229 | Token otherlv_5=null; | ||
3230 | Token otherlv_6=null; | ||
3231 | Token this_FULL_STOP_7=null; | ||
3232 | AntlrDatatypeRuleToken lv_name_2_0 = null; | ||
3233 | |||
3234 | |||
3235 | |||
3236 | enterRule(); | ||
3237 | |||
3238 | try { | ||
3239 | // InternalSolverLanguageParser.g:1300:2: ( (otherlv_0= Extern ( ( ruleQualifiedName ) ) ( (lv_name_2_0= ruleQualifiedName ) ) otherlv_3= LeftCurlyBracket ( ( ruleQualifiedName ) ) otherlv_5= FullStopFullStopFullStop otherlv_6= RightCurlyBracket this_FULL_STOP_7= RULE_FULL_STOP ) ) | ||
3240 | // InternalSolverLanguageParser.g:1301:2: (otherlv_0= Extern ( ( ruleQualifiedName ) ) ( (lv_name_2_0= ruleQualifiedName ) ) otherlv_3= LeftCurlyBracket ( ( ruleQualifiedName ) ) otherlv_5= FullStopFullStopFullStop otherlv_6= RightCurlyBracket this_FULL_STOP_7= RULE_FULL_STOP ) | ||
3241 | { | ||
3242 | // InternalSolverLanguageParser.g:1301:2: (otherlv_0= Extern ( ( ruleQualifiedName ) ) ( (lv_name_2_0= ruleQualifiedName ) ) otherlv_3= LeftCurlyBracket ( ( ruleQualifiedName ) ) otherlv_5= FullStopFullStopFullStop otherlv_6= RightCurlyBracket this_FULL_STOP_7= RULE_FULL_STOP ) | ||
3243 | // InternalSolverLanguageParser.g:1302:3: otherlv_0= Extern ( ( ruleQualifiedName ) ) ( (lv_name_2_0= ruleQualifiedName ) ) otherlv_3= LeftCurlyBracket ( ( ruleQualifiedName ) ) otherlv_5= FullStopFullStopFullStop otherlv_6= RightCurlyBracket this_FULL_STOP_7= RULE_FULL_STOP | ||
3244 | { | ||
3245 | otherlv_0=(Token)match(input,Extern,FOLLOW_3); | ||
3246 | |||
3247 | newLeafNode(otherlv_0, grammarAccess.getExternAggregationOperatorDeclarationAccess().getExternKeyword_0()); | ||
3248 | |||
3249 | // InternalSolverLanguageParser.g:1306:3: ( ( ruleQualifiedName ) ) | ||
3250 | // InternalSolverLanguageParser.g:1307:4: ( ruleQualifiedName ) | ||
3251 | { | ||
3252 | // InternalSolverLanguageParser.g:1307:4: ( ruleQualifiedName ) | ||
3253 | // InternalSolverLanguageParser.g:1308:5: ruleQualifiedName | ||
3254 | { | ||
3255 | |||
3256 | if (current==null) { | ||
3257 | current = createModelElement(grammarAccess.getExternAggregationOperatorDeclarationRule()); | ||
3258 | } | ||
3259 | |||
3260 | |||
3261 | newCompositeNode(grammarAccess.getExternAggregationOperatorDeclarationAccess().getResultTypeSymbolCrossReference_1_0()); | ||
3262 | |||
3263 | pushFollow(FOLLOW_3); | ||
3264 | ruleQualifiedName(); | ||
3265 | |||
3266 | state._fsp--; | ||
3267 | |||
3268 | |||
3269 | afterParserOrEnumRuleCall(); | ||
3270 | |||
3271 | |||
3272 | } | ||
3273 | |||
3274 | |||
3275 | } | ||
3276 | |||
3277 | // InternalSolverLanguageParser.g:1322:3: ( (lv_name_2_0= ruleQualifiedName ) ) | ||
3278 | // InternalSolverLanguageParser.g:1323:4: (lv_name_2_0= ruleQualifiedName ) | ||
3279 | { | ||
3280 | // InternalSolverLanguageParser.g:1323:4: (lv_name_2_0= ruleQualifiedName ) | ||
3281 | // InternalSolverLanguageParser.g:1324:5: lv_name_2_0= ruleQualifiedName | ||
3282 | { | ||
3283 | |||
3284 | newCompositeNode(grammarAccess.getExternAggregationOperatorDeclarationAccess().getNameQualifiedNameParserRuleCall_2_0()); | ||
3285 | |||
3286 | pushFollow(FOLLOW_20); | ||
3287 | lv_name_2_0=ruleQualifiedName(); | ||
3288 | |||
3289 | state._fsp--; | ||
3290 | |||
3291 | |||
3292 | if (current==null) { | ||
3293 | current = createModelElementForParent(grammarAccess.getExternAggregationOperatorDeclarationRule()); | ||
3294 | } | ||
3295 | set( | ||
3296 | current, | ||
3297 | "name", | ||
3298 | lv_name_2_0, | ||
3299 | "org.eclipse.viatra.solver.language.SolverLanguage.QualifiedName"); | ||
3300 | afterParserOrEnumRuleCall(); | ||
3301 | |||
3302 | |||
3303 | } | ||
3304 | |||
3305 | |||
3306 | } | ||
3307 | |||
3308 | otherlv_3=(Token)match(input,LeftCurlyBracket,FOLLOW_3); | ||
3309 | |||
3310 | newLeafNode(otherlv_3, grammarAccess.getExternAggregationOperatorDeclarationAccess().getLeftCurlyBracketKeyword_3()); | ||
3311 | |||
3312 | // InternalSolverLanguageParser.g:1345:3: ( ( ruleQualifiedName ) ) | ||
3313 | // InternalSolverLanguageParser.g:1346:4: ( ruleQualifiedName ) | ||
3314 | { | ||
3315 | // InternalSolverLanguageParser.g:1346:4: ( ruleQualifiedName ) | ||
3316 | // InternalSolverLanguageParser.g:1347:5: ruleQualifiedName | ||
3317 | { | ||
3318 | |||
3319 | if (current==null) { | ||
3320 | current = createModelElement(grammarAccess.getExternAggregationOperatorDeclarationRule()); | ||
3321 | } | ||
3322 | |||
3323 | |||
3324 | newCompositeNode(grammarAccess.getExternAggregationOperatorDeclarationAccess().getArgumentTypeSymbolCrossReference_4_0()); | ||
3325 | |||
3326 | pushFollow(FOLLOW_21); | ||
3327 | ruleQualifiedName(); | ||
3328 | |||
3329 | state._fsp--; | ||
3330 | |||
3331 | |||
3332 | afterParserOrEnumRuleCall(); | ||
3333 | |||
3334 | |||
3335 | } | ||
3336 | |||
3337 | |||
3338 | } | ||
3339 | |||
3340 | otherlv_5=(Token)match(input,FullStopFullStopFullStop,FOLLOW_22); | ||
3341 | |||
3342 | newLeafNode(otherlv_5, grammarAccess.getExternAggregationOperatorDeclarationAccess().getFullStopFullStopFullStopKeyword_5()); | ||
3343 | |||
3344 | otherlv_6=(Token)match(input,RightCurlyBracket,FOLLOW_4); | ||
3345 | |||
3346 | newLeafNode(otherlv_6, grammarAccess.getExternAggregationOperatorDeclarationAccess().getRightCurlyBracketKeyword_6()); | ||
3347 | |||
3348 | this_FULL_STOP_7=(Token)match(input,RULE_FULL_STOP,FOLLOW_2); | ||
3349 | |||
3350 | newLeafNode(this_FULL_STOP_7, grammarAccess.getExternAggregationOperatorDeclarationAccess().getFULL_STOPTerminalRuleCall_7()); | ||
3351 | |||
3352 | |||
3353 | } | ||
3354 | |||
3355 | |||
3356 | } | ||
3357 | |||
3358 | |||
3359 | leaveRule(); | ||
3360 | |||
3361 | } | ||
3362 | |||
3363 | catch (RecognitionException re) { | ||
3364 | recover(input,re); | ||
3365 | appendSkippedTokens(); | ||
3366 | } | ||
3367 | finally { | ||
3368 | } | ||
3369 | return current; | ||
3370 | } | ||
3371 | // $ANTLR end "ruleExternAggregationOperatorDeclaration" | ||
3372 | |||
3373 | |||
3374 | // $ANTLR start "entryRuleExternDatatypeDeclaration" | ||
3375 | // InternalSolverLanguageParser.g:1377:1: entryRuleExternDatatypeDeclaration returns [EObject current=null] : iv_ruleExternDatatypeDeclaration= ruleExternDatatypeDeclaration EOF ; | ||
3376 | public final EObject entryRuleExternDatatypeDeclaration() throws RecognitionException { | ||
3377 | EObject current = null; | ||
3378 | |||
3379 | EObject iv_ruleExternDatatypeDeclaration = null; | ||
3380 | |||
3381 | |||
3382 | try { | ||
3383 | // InternalSolverLanguageParser.g:1377:66: (iv_ruleExternDatatypeDeclaration= ruleExternDatatypeDeclaration EOF ) | ||
3384 | // InternalSolverLanguageParser.g:1378:2: iv_ruleExternDatatypeDeclaration= ruleExternDatatypeDeclaration EOF | ||
3385 | { | ||
3386 | newCompositeNode(grammarAccess.getExternDatatypeDeclarationRule()); | ||
3387 | pushFollow(FOLLOW_1); | ||
3388 | iv_ruleExternDatatypeDeclaration=ruleExternDatatypeDeclaration(); | ||
3389 | |||
3390 | state._fsp--; | ||
3391 | |||
3392 | current =iv_ruleExternDatatypeDeclaration; | ||
3393 | match(input,EOF,FOLLOW_2); | ||
3394 | |||
3395 | } | ||
3396 | |||
3397 | } | ||
3398 | |||
3399 | catch (RecognitionException re) { | ||
3400 | recover(input,re); | ||
3401 | appendSkippedTokens(); | ||
3402 | } | ||
3403 | finally { | ||
3404 | } | ||
3405 | return current; | ||
3406 | } | ||
3407 | // $ANTLR end "entryRuleExternDatatypeDeclaration" | ||
3408 | |||
3409 | |||
3410 | // $ANTLR start "ruleExternDatatypeDeclaration" | ||
3411 | // InternalSolverLanguageParser.g:1384:1: ruleExternDatatypeDeclaration returns [EObject current=null] : (otherlv_0= Extern otherlv_1= Datatype ( (lv_name_2_0= ruleQualifiedName ) ) this_FULL_STOP_3= RULE_FULL_STOP ) ; | ||
3412 | public final EObject ruleExternDatatypeDeclaration() throws RecognitionException { | ||
3413 | EObject current = null; | ||
3414 | |||
3415 | Token otherlv_0=null; | ||
3416 | Token otherlv_1=null; | ||
3417 | Token this_FULL_STOP_3=null; | ||
3418 | AntlrDatatypeRuleToken lv_name_2_0 = null; | ||
3419 | |||
3420 | |||
3421 | |||
3422 | enterRule(); | ||
3423 | |||
3424 | try { | ||
3425 | // InternalSolverLanguageParser.g:1390:2: ( (otherlv_0= Extern otherlv_1= Datatype ( (lv_name_2_0= ruleQualifiedName ) ) this_FULL_STOP_3= RULE_FULL_STOP ) ) | ||
3426 | // InternalSolverLanguageParser.g:1391:2: (otherlv_0= Extern otherlv_1= Datatype ( (lv_name_2_0= ruleQualifiedName ) ) this_FULL_STOP_3= RULE_FULL_STOP ) | ||
3427 | { | ||
3428 | // InternalSolverLanguageParser.g:1391:2: (otherlv_0= Extern otherlv_1= Datatype ( (lv_name_2_0= ruleQualifiedName ) ) this_FULL_STOP_3= RULE_FULL_STOP ) | ||
3429 | // InternalSolverLanguageParser.g:1392:3: otherlv_0= Extern otherlv_1= Datatype ( (lv_name_2_0= ruleQualifiedName ) ) this_FULL_STOP_3= RULE_FULL_STOP | ||
3430 | { | ||
3431 | otherlv_0=(Token)match(input,Extern,FOLLOW_23); | ||
3432 | |||
3433 | newLeafNode(otherlv_0, grammarAccess.getExternDatatypeDeclarationAccess().getExternKeyword_0()); | ||
3434 | |||
3435 | otherlv_1=(Token)match(input,Datatype,FOLLOW_3); | ||
3436 | |||
3437 | newLeafNode(otherlv_1, grammarAccess.getExternDatatypeDeclarationAccess().getDatatypeKeyword_1()); | ||
3438 | |||
3439 | // InternalSolverLanguageParser.g:1400:3: ( (lv_name_2_0= ruleQualifiedName ) ) | ||
3440 | // InternalSolverLanguageParser.g:1401:4: (lv_name_2_0= ruleQualifiedName ) | ||
3441 | { | ||
3442 | // InternalSolverLanguageParser.g:1401:4: (lv_name_2_0= ruleQualifiedName ) | ||
3443 | // InternalSolverLanguageParser.g:1402:5: lv_name_2_0= ruleQualifiedName | ||
3444 | { | ||
3445 | |||
3446 | newCompositeNode(grammarAccess.getExternDatatypeDeclarationAccess().getNameQualifiedNameParserRuleCall_2_0()); | ||
3447 | |||
3448 | pushFollow(FOLLOW_4); | ||
3449 | lv_name_2_0=ruleQualifiedName(); | ||
3450 | |||
3451 | state._fsp--; | ||
3452 | |||
3453 | |||
3454 | if (current==null) { | ||
3455 | current = createModelElementForParent(grammarAccess.getExternDatatypeDeclarationRule()); | ||
3456 | } | ||
3457 | set( | ||
3458 | current, | ||
3459 | "name", | ||
3460 | lv_name_2_0, | ||
3461 | "org.eclipse.viatra.solver.language.SolverLanguage.QualifiedName"); | ||
3462 | afterParserOrEnumRuleCall(); | ||
3463 | |||
3464 | |||
3465 | } | ||
3466 | |||
3467 | |||
3468 | } | ||
3469 | |||
3470 | this_FULL_STOP_3=(Token)match(input,RULE_FULL_STOP,FOLLOW_2); | ||
3471 | |||
3472 | newLeafNode(this_FULL_STOP_3, grammarAccess.getExternDatatypeDeclarationAccess().getFULL_STOPTerminalRuleCall_3()); | ||
3473 | |||
3474 | |||
3475 | } | ||
3476 | |||
3477 | |||
3478 | } | ||
3479 | |||
3480 | |||
3481 | leaveRule(); | ||
3482 | |||
3483 | } | ||
3484 | |||
3485 | catch (RecognitionException re) { | ||
3486 | recover(input,re); | ||
3487 | appendSkippedTokens(); | ||
3488 | } | ||
3489 | finally { | ||
3490 | } | ||
3491 | return current; | ||
3492 | } | ||
3493 | // $ANTLR end "ruleExternDatatypeDeclaration" | ||
3494 | |||
3495 | |||
3496 | // $ANTLR start "entryRuleExpression" | ||
3497 | // InternalSolverLanguageParser.g:1427:1: entryRuleExpression returns [EObject current=null] : iv_ruleExpression= ruleExpression EOF ; | ||
3498 | public final EObject entryRuleExpression() throws RecognitionException { | ||
3499 | EObject current = null; | ||
3500 | |||
3501 | EObject iv_ruleExpression = null; | ||
3502 | |||
3503 | |||
3504 | try { | ||
3505 | // InternalSolverLanguageParser.g:1427:51: (iv_ruleExpression= ruleExpression EOF ) | ||
3506 | // InternalSolverLanguageParser.g:1428:2: iv_ruleExpression= ruleExpression EOF | ||
3507 | { | ||
3508 | newCompositeNode(grammarAccess.getExpressionRule()); | ||
3509 | pushFollow(FOLLOW_1); | ||
3510 | iv_ruleExpression=ruleExpression(); | ||
3511 | |||
3512 | state._fsp--; | ||
3513 | |||
3514 | current =iv_ruleExpression; | ||
3515 | match(input,EOF,FOLLOW_2); | ||
3516 | |||
3517 | } | ||
3518 | |||
3519 | } | ||
3520 | |||
3521 | catch (RecognitionException re) { | ||
3522 | recover(input,re); | ||
3523 | appendSkippedTokens(); | ||
3524 | } | ||
3525 | finally { | ||
3526 | } | ||
3527 | return current; | ||
3528 | } | ||
3529 | // $ANTLR end "entryRuleExpression" | ||
3530 | |||
3531 | |||
3532 | // $ANTLR start "ruleExpression" | ||
3533 | // InternalSolverLanguageParser.g:1434:1: ruleExpression returns [EObject current=null] : (this_ConditionalExpression_0= ruleConditionalExpression | this_LetExpression_1= ruleLetExpression | (this_DisjunctiveExpression_2= ruleDisjunctiveExpression ( () otherlv_4= EqualsSignGreaterThanSign ( (lv_body_5_0= ruleDisjunctiveExpression ) ) )? ) ) ; | ||
3534 | public final EObject ruleExpression() throws RecognitionException { | ||
3535 | EObject current = null; | ||
3536 | |||
3537 | Token otherlv_4=null; | ||
3538 | EObject this_ConditionalExpression_0 = null; | ||
3539 | |||
3540 | EObject this_LetExpression_1 = null; | ||
3541 | |||
3542 | EObject this_DisjunctiveExpression_2 = null; | ||
3543 | |||
3544 | EObject lv_body_5_0 = null; | ||
3545 | |||
3546 | |||
3547 | |||
3548 | enterRule(); | ||
3549 | |||
3550 | try { | ||
3551 | // InternalSolverLanguageParser.g:1440:2: ( (this_ConditionalExpression_0= ruleConditionalExpression | this_LetExpression_1= ruleLetExpression | (this_DisjunctiveExpression_2= ruleDisjunctiveExpression ( () otherlv_4= EqualsSignGreaterThanSign ( (lv_body_5_0= ruleDisjunctiveExpression ) ) )? ) ) ) | ||
3552 | // InternalSolverLanguageParser.g:1441:2: (this_ConditionalExpression_0= ruleConditionalExpression | this_LetExpression_1= ruleLetExpression | (this_DisjunctiveExpression_2= ruleDisjunctiveExpression ( () otherlv_4= EqualsSignGreaterThanSign ( (lv_body_5_0= ruleDisjunctiveExpression ) ) )? ) ) | ||
3553 | { | ||
3554 | // InternalSolverLanguageParser.g:1441:2: (this_ConditionalExpression_0= ruleConditionalExpression | this_LetExpression_1= ruleLetExpression | (this_DisjunctiveExpression_2= ruleDisjunctiveExpression ( () otherlv_4= EqualsSignGreaterThanSign ( (lv_body_5_0= ruleDisjunctiveExpression ) ) )? ) ) | ||
3555 | int alt16=3; | ||
3556 | switch ( input.LA(1) ) { | ||
3557 | case If: | ||
3558 | { | ||
3559 | alt16=1; | ||
3560 | } | ||
3561 | break; | ||
3562 | case Let: | ||
3563 | { | ||
3564 | alt16=2; | ||
3565 | } | ||
3566 | break; | ||
3567 | case Unknown: | ||
3568 | case Object: | ||
3569 | case Count: | ||
3570 | case Empty: | ||
3571 | case Error: | ||
3572 | case False: | ||
3573 | case True: | ||
3574 | case Inf: | ||
3575 | case ExclamationMark: | ||
3576 | case LeftParenthesis: | ||
3577 | case PlusSign: | ||
3578 | case HyphenMinus: | ||
3579 | case QuestionMark: | ||
3580 | case LeftSquareBracket: | ||
3581 | case Tilde: | ||
3582 | case RULE_STRING: | ||
3583 | case RULE_QUOTED_ID: | ||
3584 | case RULE_ID: | ||
3585 | case RULE_INT: | ||
3586 | { | ||
3587 | alt16=3; | ||
3588 | } | ||
3589 | break; | ||
3590 | default: | ||
3591 | NoViableAltException nvae = | ||
3592 | new NoViableAltException("", 16, 0, input); | ||
3593 | |||
3594 | throw nvae; | ||
3595 | } | ||
3596 | |||
3597 | switch (alt16) { | ||
3598 | case 1 : | ||
3599 | // InternalSolverLanguageParser.g:1442:3: this_ConditionalExpression_0= ruleConditionalExpression | ||
3600 | { | ||
3601 | |||
3602 | newCompositeNode(grammarAccess.getExpressionAccess().getConditionalExpressionParserRuleCall_0()); | ||
3603 | |||
3604 | pushFollow(FOLLOW_2); | ||
3605 | this_ConditionalExpression_0=ruleConditionalExpression(); | ||
3606 | |||
3607 | state._fsp--; | ||
3608 | |||
3609 | |||
3610 | current = this_ConditionalExpression_0; | ||
3611 | afterParserOrEnumRuleCall(); | ||
3612 | |||
3613 | |||
3614 | } | ||
3615 | break; | ||
3616 | case 2 : | ||
3617 | // InternalSolverLanguageParser.g:1451:3: this_LetExpression_1= ruleLetExpression | ||
3618 | { | ||
3619 | |||
3620 | newCompositeNode(grammarAccess.getExpressionAccess().getLetExpressionParserRuleCall_1()); | ||
3621 | |||
3622 | pushFollow(FOLLOW_2); | ||
3623 | this_LetExpression_1=ruleLetExpression(); | ||
3624 | |||
3625 | state._fsp--; | ||
3626 | |||
3627 | |||
3628 | current = this_LetExpression_1; | ||
3629 | afterParserOrEnumRuleCall(); | ||
3630 | |||
3631 | |||
3632 | } | ||
3633 | break; | ||
3634 | case 3 : | ||
3635 | // InternalSolverLanguageParser.g:1460:3: (this_DisjunctiveExpression_2= ruleDisjunctiveExpression ( () otherlv_4= EqualsSignGreaterThanSign ( (lv_body_5_0= ruleDisjunctiveExpression ) ) )? ) | ||
3636 | { | ||
3637 | // InternalSolverLanguageParser.g:1460:3: (this_DisjunctiveExpression_2= ruleDisjunctiveExpression ( () otherlv_4= EqualsSignGreaterThanSign ( (lv_body_5_0= ruleDisjunctiveExpression ) ) )? ) | ||
3638 | // InternalSolverLanguageParser.g:1461:4: this_DisjunctiveExpression_2= ruleDisjunctiveExpression ( () otherlv_4= EqualsSignGreaterThanSign ( (lv_body_5_0= ruleDisjunctiveExpression ) ) )? | ||
3639 | { | ||
3640 | |||
3641 | newCompositeNode(grammarAccess.getExpressionAccess().getDisjunctiveExpressionParserRuleCall_2_0()); | ||
3642 | |||
3643 | pushFollow(FOLLOW_24); | ||
3644 | this_DisjunctiveExpression_2=ruleDisjunctiveExpression(); | ||
3645 | |||
3646 | state._fsp--; | ||
3647 | |||
3648 | |||
3649 | current = this_DisjunctiveExpression_2; | ||
3650 | afterParserOrEnumRuleCall(); | ||
3651 | |||
3652 | // InternalSolverLanguageParser.g:1469:4: ( () otherlv_4= EqualsSignGreaterThanSign ( (lv_body_5_0= ruleDisjunctiveExpression ) ) )? | ||
3653 | int alt15=2; | ||
3654 | int LA15_0 = input.LA(1); | ||
3655 | |||
3656 | if ( (LA15_0==EqualsSignGreaterThanSign) ) { | ||
3657 | alt15=1; | ||
3658 | } | ||
3659 | switch (alt15) { | ||
3660 | case 1 : | ||
3661 | // InternalSolverLanguageParser.g:1470:5: () otherlv_4= EqualsSignGreaterThanSign ( (lv_body_5_0= ruleDisjunctiveExpression ) ) | ||
3662 | { | ||
3663 | // InternalSolverLanguageParser.g:1470:5: () | ||
3664 | // InternalSolverLanguageParser.g:1471:6: | ||
3665 | { | ||
3666 | |||
3667 | current = forceCreateModelElementAndSet( | ||
3668 | grammarAccess.getExpressionAccess().getForallConditionAction_2_1_0(), | ||
3669 | current); | ||
3670 | |||
3671 | |||
3672 | } | ||
3673 | |||
3674 | otherlv_4=(Token)match(input,EqualsSignGreaterThanSign,FOLLOW_10); | ||
3675 | |||
3676 | newLeafNode(otherlv_4, grammarAccess.getExpressionAccess().getEqualsSignGreaterThanSignKeyword_2_1_1()); | ||
3677 | |||
3678 | // InternalSolverLanguageParser.g:1481:5: ( (lv_body_5_0= ruleDisjunctiveExpression ) ) | ||
3679 | // InternalSolverLanguageParser.g:1482:6: (lv_body_5_0= ruleDisjunctiveExpression ) | ||
3680 | { | ||
3681 | // InternalSolverLanguageParser.g:1482:6: (lv_body_5_0= ruleDisjunctiveExpression ) | ||
3682 | // InternalSolverLanguageParser.g:1483:7: lv_body_5_0= ruleDisjunctiveExpression | ||
3683 | { | ||
3684 | |||
3685 | newCompositeNode(grammarAccess.getExpressionAccess().getBodyDisjunctiveExpressionParserRuleCall_2_1_2_0()); | ||
3686 | |||
3687 | pushFollow(FOLLOW_2); | ||
3688 | lv_body_5_0=ruleDisjunctiveExpression(); | ||
3689 | |||
3690 | state._fsp--; | ||
3691 | |||
3692 | |||
3693 | if (current==null) { | ||
3694 | current = createModelElementForParent(grammarAccess.getExpressionRule()); | ||
3695 | } | ||
3696 | set( | ||
3697 | current, | ||
3698 | "body", | ||
3699 | lv_body_5_0, | ||
3700 | "org.eclipse.viatra.solver.language.SolverLanguage.DisjunctiveExpression"); | ||
3701 | afterParserOrEnumRuleCall(); | ||
3702 | |||
3703 | |||
3704 | } | ||
3705 | |||
3706 | |||
3707 | } | ||
3708 | |||
3709 | |||
3710 | } | ||
3711 | break; | ||
3712 | |||
3713 | } | ||
3714 | |||
3715 | |||
3716 | } | ||
3717 | |||
3718 | |||
3719 | } | ||
3720 | break; | ||
3721 | |||
3722 | } | ||
3723 | |||
3724 | |||
3725 | } | ||
3726 | |||
3727 | |||
3728 | leaveRule(); | ||
3729 | |||
3730 | } | ||
3731 | |||
3732 | catch (RecognitionException re) { | ||
3733 | recover(input,re); | ||
3734 | appendSkippedTokens(); | ||
3735 | } | ||
3736 | finally { | ||
3737 | } | ||
3738 | return current; | ||
3739 | } | ||
3740 | // $ANTLR end "ruleExpression" | ||
3741 | |||
3742 | |||
3743 | // $ANTLR start "entryRuleConditionalExpression" | ||
3744 | // InternalSolverLanguageParser.g:1506:1: entryRuleConditionalExpression returns [EObject current=null] : iv_ruleConditionalExpression= ruleConditionalExpression EOF ; | ||
3745 | public final EObject entryRuleConditionalExpression() throws RecognitionException { | ||
3746 | EObject current = null; | ||
3747 | |||
3748 | EObject iv_ruleConditionalExpression = null; | ||
3749 | |||
3750 | |||
3751 | try { | ||
3752 | // InternalSolverLanguageParser.g:1506:62: (iv_ruleConditionalExpression= ruleConditionalExpression EOF ) | ||
3753 | // InternalSolverLanguageParser.g:1507:2: iv_ruleConditionalExpression= ruleConditionalExpression EOF | ||
3754 | { | ||
3755 | newCompositeNode(grammarAccess.getConditionalExpressionRule()); | ||
3756 | pushFollow(FOLLOW_1); | ||
3757 | iv_ruleConditionalExpression=ruleConditionalExpression(); | ||
3758 | |||
3759 | state._fsp--; | ||
3760 | |||
3761 | current =iv_ruleConditionalExpression; | ||
3762 | match(input,EOF,FOLLOW_2); | ||
3763 | |||
3764 | } | ||
3765 | |||
3766 | } | ||
3767 | |||
3768 | catch (RecognitionException re) { | ||
3769 | recover(input,re); | ||
3770 | appendSkippedTokens(); | ||
3771 | } | ||
3772 | finally { | ||
3773 | } | ||
3774 | return current; | ||
3775 | } | ||
3776 | // $ANTLR end "entryRuleConditionalExpression" | ||
3777 | |||
3778 | |||
3779 | // $ANTLR start "ruleConditionalExpression" | ||
3780 | // InternalSolverLanguageParser.g:1513:1: ruleConditionalExpression returns [EObject current=null] : (otherlv_0= If ( (lv_condition_1_0= ruleDisjunctiveExpression ) ) otherlv_2= Then ( (lv_then_3_0= ruleExpression ) ) otherlv_4= Else ( (lv_else_5_0= ruleExpression ) ) ) ; | ||
3781 | public final EObject ruleConditionalExpression() throws RecognitionException { | ||
3782 | EObject current = null; | ||
3783 | |||
3784 | Token otherlv_0=null; | ||
3785 | Token otherlv_2=null; | ||
3786 | Token otherlv_4=null; | ||
3787 | EObject lv_condition_1_0 = null; | ||
3788 | |||
3789 | EObject lv_then_3_0 = null; | ||
3790 | |||
3791 | EObject lv_else_5_0 = null; | ||
3792 | |||
3793 | |||
3794 | |||
3795 | enterRule(); | ||
3796 | |||
3797 | try { | ||
3798 | // InternalSolverLanguageParser.g:1519:2: ( (otherlv_0= If ( (lv_condition_1_0= ruleDisjunctiveExpression ) ) otherlv_2= Then ( (lv_then_3_0= ruleExpression ) ) otherlv_4= Else ( (lv_else_5_0= ruleExpression ) ) ) ) | ||
3799 | // InternalSolverLanguageParser.g:1520:2: (otherlv_0= If ( (lv_condition_1_0= ruleDisjunctiveExpression ) ) otherlv_2= Then ( (lv_then_3_0= ruleExpression ) ) otherlv_4= Else ( (lv_else_5_0= ruleExpression ) ) ) | ||
3800 | { | ||
3801 | // InternalSolverLanguageParser.g:1520:2: (otherlv_0= If ( (lv_condition_1_0= ruleDisjunctiveExpression ) ) otherlv_2= Then ( (lv_then_3_0= ruleExpression ) ) otherlv_4= Else ( (lv_else_5_0= ruleExpression ) ) ) | ||
3802 | // InternalSolverLanguageParser.g:1521:3: otherlv_0= If ( (lv_condition_1_0= ruleDisjunctiveExpression ) ) otherlv_2= Then ( (lv_then_3_0= ruleExpression ) ) otherlv_4= Else ( (lv_else_5_0= ruleExpression ) ) | ||
3803 | { | ||
3804 | otherlv_0=(Token)match(input,If,FOLLOW_10); | ||
3805 | |||
3806 | newLeafNode(otherlv_0, grammarAccess.getConditionalExpressionAccess().getIfKeyword_0()); | ||
3807 | |||
3808 | // InternalSolverLanguageParser.g:1525:3: ( (lv_condition_1_0= ruleDisjunctiveExpression ) ) | ||
3809 | // InternalSolverLanguageParser.g:1526:4: (lv_condition_1_0= ruleDisjunctiveExpression ) | ||
3810 | { | ||
3811 | // InternalSolverLanguageParser.g:1526:4: (lv_condition_1_0= ruleDisjunctiveExpression ) | ||
3812 | // InternalSolverLanguageParser.g:1527:5: lv_condition_1_0= ruleDisjunctiveExpression | ||
3813 | { | ||
3814 | |||
3815 | newCompositeNode(grammarAccess.getConditionalExpressionAccess().getConditionDisjunctiveExpressionParserRuleCall_1_0()); | ||
3816 | |||
3817 | pushFollow(FOLLOW_25); | ||
3818 | lv_condition_1_0=ruleDisjunctiveExpression(); | ||
3819 | |||
3820 | state._fsp--; | ||
3821 | |||
3822 | |||
3823 | if (current==null) { | ||
3824 | current = createModelElementForParent(grammarAccess.getConditionalExpressionRule()); | ||
3825 | } | ||
3826 | set( | ||
3827 | current, | ||
3828 | "condition", | ||
3829 | lv_condition_1_0, | ||
3830 | "org.eclipse.viatra.solver.language.SolverLanguage.DisjunctiveExpression"); | ||
3831 | afterParserOrEnumRuleCall(); | ||
3832 | |||
3833 | |||
3834 | } | ||
3835 | |||
3836 | |||
3837 | } | ||
3838 | |||
3839 | otherlv_2=(Token)match(input,Then,FOLLOW_10); | ||
3840 | |||
3841 | newLeafNode(otherlv_2, grammarAccess.getConditionalExpressionAccess().getThenKeyword_2()); | ||
3842 | |||
3843 | // InternalSolverLanguageParser.g:1548:3: ( (lv_then_3_0= ruleExpression ) ) | ||
3844 | // InternalSolverLanguageParser.g:1549:4: (lv_then_3_0= ruleExpression ) | ||
3845 | { | ||
3846 | // InternalSolverLanguageParser.g:1549:4: (lv_then_3_0= ruleExpression ) | ||
3847 | // InternalSolverLanguageParser.g:1550:5: lv_then_3_0= ruleExpression | ||
3848 | { | ||
3849 | |||
3850 | newCompositeNode(grammarAccess.getConditionalExpressionAccess().getThenExpressionParserRuleCall_3_0()); | ||
3851 | |||
3852 | pushFollow(FOLLOW_26); | ||
3853 | lv_then_3_0=ruleExpression(); | ||
3854 | |||
3855 | state._fsp--; | ||
3856 | |||
3857 | |||
3858 | if (current==null) { | ||
3859 | current = createModelElementForParent(grammarAccess.getConditionalExpressionRule()); | ||
3860 | } | ||
3861 | set( | ||
3862 | current, | ||
3863 | "then", | ||
3864 | lv_then_3_0, | ||
3865 | "org.eclipse.viatra.solver.language.SolverLanguage.Expression"); | ||
3866 | afterParserOrEnumRuleCall(); | ||
3867 | |||
3868 | |||
3869 | } | ||
3870 | |||
3871 | |||
3872 | } | ||
3873 | |||
3874 | otherlv_4=(Token)match(input,Else,FOLLOW_10); | ||
3875 | |||
3876 | newLeafNode(otherlv_4, grammarAccess.getConditionalExpressionAccess().getElseKeyword_4()); | ||
3877 | |||
3878 | // InternalSolverLanguageParser.g:1571:3: ( (lv_else_5_0= ruleExpression ) ) | ||
3879 | // InternalSolverLanguageParser.g:1572:4: (lv_else_5_0= ruleExpression ) | ||
3880 | { | ||
3881 | // InternalSolverLanguageParser.g:1572:4: (lv_else_5_0= ruleExpression ) | ||
3882 | // InternalSolverLanguageParser.g:1573:5: lv_else_5_0= ruleExpression | ||
3883 | { | ||
3884 | |||
3885 | newCompositeNode(grammarAccess.getConditionalExpressionAccess().getElseExpressionParserRuleCall_5_0()); | ||
3886 | |||
3887 | pushFollow(FOLLOW_2); | ||
3888 | lv_else_5_0=ruleExpression(); | ||
3889 | |||
3890 | state._fsp--; | ||
3891 | |||
3892 | |||
3893 | if (current==null) { | ||
3894 | current = createModelElementForParent(grammarAccess.getConditionalExpressionRule()); | ||
3895 | } | ||
3896 | set( | ||
3897 | current, | ||
3898 | "else", | ||
3899 | lv_else_5_0, | ||
3900 | "org.eclipse.viatra.solver.language.SolverLanguage.Expression"); | ||
3901 | afterParserOrEnumRuleCall(); | ||
3902 | |||
3903 | |||
3904 | } | ||
3905 | |||
3906 | |||
3907 | } | ||
3908 | |||
3909 | |||
3910 | } | ||
3911 | |||
3912 | |||
3913 | } | ||
3914 | |||
3915 | |||
3916 | leaveRule(); | ||
3917 | |||
3918 | } | ||
3919 | |||
3920 | catch (RecognitionException re) { | ||
3921 | recover(input,re); | ||
3922 | appendSkippedTokens(); | ||
3923 | } | ||
3924 | finally { | ||
3925 | } | ||
3926 | return current; | ||
3927 | } | ||
3928 | // $ANTLR end "ruleConditionalExpression" | ||
3929 | |||
3930 | |||
3931 | // $ANTLR start "entryRuleLetExpression" | ||
3932 | // InternalSolverLanguageParser.g:1594:1: entryRuleLetExpression returns [EObject current=null] : iv_ruleLetExpression= ruleLetExpression EOF ; | ||
3933 | public final EObject entryRuleLetExpression() throws RecognitionException { | ||
3934 | EObject current = null; | ||
3935 | |||
3936 | EObject iv_ruleLetExpression = null; | ||
3937 | |||
3938 | |||
3939 | try { | ||
3940 | // InternalSolverLanguageParser.g:1594:54: (iv_ruleLetExpression= ruleLetExpression EOF ) | ||
3941 | // InternalSolverLanguageParser.g:1595:2: iv_ruleLetExpression= ruleLetExpression EOF | ||
3942 | { | ||
3943 | newCompositeNode(grammarAccess.getLetExpressionRule()); | ||
3944 | pushFollow(FOLLOW_1); | ||
3945 | iv_ruleLetExpression=ruleLetExpression(); | ||
3946 | |||
3947 | state._fsp--; | ||
3948 | |||
3949 | current =iv_ruleLetExpression; | ||
3950 | match(input,EOF,FOLLOW_2); | ||
3951 | |||
3952 | } | ||
3953 | |||
3954 | } | ||
3955 | |||
3956 | catch (RecognitionException re) { | ||
3957 | recover(input,re); | ||
3958 | appendSkippedTokens(); | ||
3959 | } | ||
3960 | finally { | ||
3961 | } | ||
3962 | return current; | ||
3963 | } | ||
3964 | // $ANTLR end "entryRuleLetExpression" | ||
3965 | |||
3966 | |||
3967 | // $ANTLR start "ruleLetExpression" | ||
3968 | // InternalSolverLanguageParser.g:1601:1: ruleLetExpression returns [EObject current=null] : (otherlv_0= Let ( (lv_bindings_1_0= ruleLetBinding ) ) (otherlv_2= Comma ( (lv_bindings_3_0= ruleLetBinding ) ) )* otherlv_4= In ( (lv_body_5_0= ruleExpression ) ) ) ; | ||
3969 | public final EObject ruleLetExpression() throws RecognitionException { | ||
3970 | EObject current = null; | ||
3971 | |||
3972 | Token otherlv_0=null; | ||
3973 | Token otherlv_2=null; | ||
3974 | Token otherlv_4=null; | ||
3975 | EObject lv_bindings_1_0 = null; | ||
3976 | |||
3977 | EObject lv_bindings_3_0 = null; | ||
3978 | |||
3979 | EObject lv_body_5_0 = null; | ||
3980 | |||
3981 | |||
3982 | |||
3983 | enterRule(); | ||
3984 | |||
3985 | try { | ||
3986 | // InternalSolverLanguageParser.g:1607:2: ( (otherlv_0= Let ( (lv_bindings_1_0= ruleLetBinding ) ) (otherlv_2= Comma ( (lv_bindings_3_0= ruleLetBinding ) ) )* otherlv_4= In ( (lv_body_5_0= ruleExpression ) ) ) ) | ||
3987 | // InternalSolverLanguageParser.g:1608:2: (otherlv_0= Let ( (lv_bindings_1_0= ruleLetBinding ) ) (otherlv_2= Comma ( (lv_bindings_3_0= ruleLetBinding ) ) )* otherlv_4= In ( (lv_body_5_0= ruleExpression ) ) ) | ||
3988 | { | ||
3989 | // InternalSolverLanguageParser.g:1608:2: (otherlv_0= Let ( (lv_bindings_1_0= ruleLetBinding ) ) (otherlv_2= Comma ( (lv_bindings_3_0= ruleLetBinding ) ) )* otherlv_4= In ( (lv_body_5_0= ruleExpression ) ) ) | ||
3990 | // InternalSolverLanguageParser.g:1609:3: otherlv_0= Let ( (lv_bindings_1_0= ruleLetBinding ) ) (otherlv_2= Comma ( (lv_bindings_3_0= ruleLetBinding ) ) )* otherlv_4= In ( (lv_body_5_0= ruleExpression ) ) | ||
3991 | { | ||
3992 | otherlv_0=(Token)match(input,Let,FOLLOW_3); | ||
3993 | |||
3994 | newLeafNode(otherlv_0, grammarAccess.getLetExpressionAccess().getLetKeyword_0()); | ||
3995 | |||
3996 | // InternalSolverLanguageParser.g:1613:3: ( (lv_bindings_1_0= ruleLetBinding ) ) | ||
3997 | // InternalSolverLanguageParser.g:1614:4: (lv_bindings_1_0= ruleLetBinding ) | ||
3998 | { | ||
3999 | // InternalSolverLanguageParser.g:1614:4: (lv_bindings_1_0= ruleLetBinding ) | ||
4000 | // InternalSolverLanguageParser.g:1615:5: lv_bindings_1_0= ruleLetBinding | ||
4001 | { | ||
4002 | |||
4003 | newCompositeNode(grammarAccess.getLetExpressionAccess().getBindingsLetBindingParserRuleCall_1_0()); | ||
4004 | |||
4005 | pushFollow(FOLLOW_27); | ||
4006 | lv_bindings_1_0=ruleLetBinding(); | ||
4007 | |||
4008 | state._fsp--; | ||
4009 | |||
4010 | |||
4011 | if (current==null) { | ||
4012 | current = createModelElementForParent(grammarAccess.getLetExpressionRule()); | ||
4013 | } | ||
4014 | add( | ||
4015 | current, | ||
4016 | "bindings", | ||
4017 | lv_bindings_1_0, | ||
4018 | "org.eclipse.viatra.solver.language.SolverLanguage.LetBinding"); | ||
4019 | afterParserOrEnumRuleCall(); | ||
4020 | |||
4021 | |||
4022 | } | ||
4023 | |||
4024 | |||
4025 | } | ||
4026 | |||
4027 | // InternalSolverLanguageParser.g:1632:3: (otherlv_2= Comma ( (lv_bindings_3_0= ruleLetBinding ) ) )* | ||
4028 | loop17: | ||
4029 | do { | ||
4030 | int alt17=2; | ||
4031 | int LA17_0 = input.LA(1); | ||
4032 | |||
4033 | if ( (LA17_0==Comma) ) { | ||
4034 | alt17=1; | ||
4035 | } | ||
4036 | |||
4037 | |||
4038 | switch (alt17) { | ||
4039 | case 1 : | ||
4040 | // InternalSolverLanguageParser.g:1633:4: otherlv_2= Comma ( (lv_bindings_3_0= ruleLetBinding ) ) | ||
4041 | { | ||
4042 | otherlv_2=(Token)match(input,Comma,FOLLOW_3); | ||
4043 | |||
4044 | newLeafNode(otherlv_2, grammarAccess.getLetExpressionAccess().getCommaKeyword_2_0()); | ||
4045 | |||
4046 | // InternalSolverLanguageParser.g:1637:4: ( (lv_bindings_3_0= ruleLetBinding ) ) | ||
4047 | // InternalSolverLanguageParser.g:1638:5: (lv_bindings_3_0= ruleLetBinding ) | ||
4048 | { | ||
4049 | // InternalSolverLanguageParser.g:1638:5: (lv_bindings_3_0= ruleLetBinding ) | ||
4050 | // InternalSolverLanguageParser.g:1639:6: lv_bindings_3_0= ruleLetBinding | ||
4051 | { | ||
4052 | |||
4053 | newCompositeNode(grammarAccess.getLetExpressionAccess().getBindingsLetBindingParserRuleCall_2_1_0()); | ||
4054 | |||
4055 | pushFollow(FOLLOW_27); | ||
4056 | lv_bindings_3_0=ruleLetBinding(); | ||
4057 | |||
4058 | state._fsp--; | ||
4059 | |||
4060 | |||
4061 | if (current==null) { | ||
4062 | current = createModelElementForParent(grammarAccess.getLetExpressionRule()); | ||
4063 | } | ||
4064 | add( | ||
4065 | current, | ||
4066 | "bindings", | ||
4067 | lv_bindings_3_0, | ||
4068 | "org.eclipse.viatra.solver.language.SolverLanguage.LetBinding"); | ||
4069 | afterParserOrEnumRuleCall(); | ||
4070 | |||
4071 | |||
4072 | } | ||
4073 | |||
4074 | |||
4075 | } | ||
4076 | |||
4077 | |||
4078 | } | ||
4079 | break; | ||
4080 | |||
4081 | default : | ||
4082 | break loop17; | ||
4083 | } | ||
4084 | } while (true); | ||
4085 | |||
4086 | otherlv_4=(Token)match(input,In,FOLLOW_10); | ||
4087 | |||
4088 | newLeafNode(otherlv_4, grammarAccess.getLetExpressionAccess().getInKeyword_3()); | ||
4089 | |||
4090 | // InternalSolverLanguageParser.g:1661:3: ( (lv_body_5_0= ruleExpression ) ) | ||
4091 | // InternalSolverLanguageParser.g:1662:4: (lv_body_5_0= ruleExpression ) | ||
4092 | { | ||
4093 | // InternalSolverLanguageParser.g:1662:4: (lv_body_5_0= ruleExpression ) | ||
4094 | // InternalSolverLanguageParser.g:1663:5: lv_body_5_0= ruleExpression | ||
4095 | { | ||
4096 | |||
4097 | newCompositeNode(grammarAccess.getLetExpressionAccess().getBodyExpressionParserRuleCall_4_0()); | ||
4098 | |||
4099 | pushFollow(FOLLOW_2); | ||
4100 | lv_body_5_0=ruleExpression(); | ||
4101 | |||
4102 | state._fsp--; | ||
4103 | |||
4104 | |||
4105 | if (current==null) { | ||
4106 | current = createModelElementForParent(grammarAccess.getLetExpressionRule()); | ||
4107 | } | ||
4108 | set( | ||
4109 | current, | ||
4110 | "body", | ||
4111 | lv_body_5_0, | ||
4112 | "org.eclipse.viatra.solver.language.SolverLanguage.Expression"); | ||
4113 | afterParserOrEnumRuleCall(); | ||
4114 | |||
4115 | |||
4116 | } | ||
4117 | |||
4118 | |||
4119 | } | ||
4120 | |||
4121 | |||
4122 | } | ||
4123 | |||
4124 | |||
4125 | } | ||
4126 | |||
4127 | |||
4128 | leaveRule(); | ||
4129 | |||
4130 | } | ||
4131 | |||
4132 | catch (RecognitionException re) { | ||
4133 | recover(input,re); | ||
4134 | appendSkippedTokens(); | ||
4135 | } | ||
4136 | finally { | ||
4137 | } | ||
4138 | return current; | ||
4139 | } | ||
4140 | // $ANTLR end "ruleLetExpression" | ||
4141 | |||
4142 | |||
4143 | // $ANTLR start "entryRuleLetBinding" | ||
4144 | // InternalSolverLanguageParser.g:1684:1: entryRuleLetBinding returns [EObject current=null] : iv_ruleLetBinding= ruleLetBinding EOF ; | ||
4145 | public final EObject entryRuleLetBinding() throws RecognitionException { | ||
4146 | EObject current = null; | ||
4147 | |||
4148 | EObject iv_ruleLetBinding = null; | ||
4149 | |||
4150 | |||
4151 | try { | ||
4152 | // InternalSolverLanguageParser.g:1684:51: (iv_ruleLetBinding= ruleLetBinding EOF ) | ||
4153 | // InternalSolverLanguageParser.g:1685:2: iv_ruleLetBinding= ruleLetBinding EOF | ||
4154 | { | ||
4155 | newCompositeNode(grammarAccess.getLetBindingRule()); | ||
4156 | pushFollow(FOLLOW_1); | ||
4157 | iv_ruleLetBinding=ruleLetBinding(); | ||
4158 | |||
4159 | state._fsp--; | ||
4160 | |||
4161 | current =iv_ruleLetBinding; | ||
4162 | match(input,EOF,FOLLOW_2); | ||
4163 | |||
4164 | } | ||
4165 | |||
4166 | } | ||
4167 | |||
4168 | catch (RecognitionException re) { | ||
4169 | recover(input,re); | ||
4170 | appendSkippedTokens(); | ||
4171 | } | ||
4172 | finally { | ||
4173 | } | ||
4174 | return current; | ||
4175 | } | ||
4176 | // $ANTLR end "entryRuleLetBinding" | ||
4177 | |||
4178 | |||
4179 | // $ANTLR start "ruleLetBinding" | ||
4180 | // InternalSolverLanguageParser.g:1691:1: ruleLetBinding returns [EObject current=null] : ( ( ( ruleQualifiedName ) )? ( (lv_name_1_0= RULE_ID ) ) otherlv_2= EqualsSign ( (lv_value_3_0= ruleAdditiveExpression ) ) ) ; | ||
4181 | public final EObject ruleLetBinding() throws RecognitionException { | ||
4182 | EObject current = null; | ||
4183 | |||
4184 | Token lv_name_1_0=null; | ||
4185 | Token otherlv_2=null; | ||
4186 | EObject lv_value_3_0 = null; | ||
4187 | |||
4188 | |||
4189 | |||
4190 | enterRule(); | ||
4191 | |||
4192 | try { | ||
4193 | // InternalSolverLanguageParser.g:1697:2: ( ( ( ( ruleQualifiedName ) )? ( (lv_name_1_0= RULE_ID ) ) otherlv_2= EqualsSign ( (lv_value_3_0= ruleAdditiveExpression ) ) ) ) | ||
4194 | // InternalSolverLanguageParser.g:1698:2: ( ( ( ruleQualifiedName ) )? ( (lv_name_1_0= RULE_ID ) ) otherlv_2= EqualsSign ( (lv_value_3_0= ruleAdditiveExpression ) ) ) | ||
4195 | { | ||
4196 | // InternalSolverLanguageParser.g:1698:2: ( ( ( ruleQualifiedName ) )? ( (lv_name_1_0= RULE_ID ) ) otherlv_2= EqualsSign ( (lv_value_3_0= ruleAdditiveExpression ) ) ) | ||
4197 | // InternalSolverLanguageParser.g:1699:3: ( ( ruleQualifiedName ) )? ( (lv_name_1_0= RULE_ID ) ) otherlv_2= EqualsSign ( (lv_value_3_0= ruleAdditiveExpression ) ) | ||
4198 | { | ||
4199 | // InternalSolverLanguageParser.g:1699:3: ( ( ruleQualifiedName ) )? | ||
4200 | int alt18=2; | ||
4201 | int LA18_0 = input.LA(1); | ||
4202 | |||
4203 | if ( (LA18_0==RULE_ID) ) { | ||
4204 | int LA18_1 = input.LA(2); | ||
4205 | |||
4206 | if ( (LA18_1==ColonColon||LA18_1==RULE_ID) ) { | ||
4207 | alt18=1; | ||
4208 | } | ||
4209 | } | ||
4210 | else if ( (LA18_0==Object||LA18_0==RULE_QUOTED_ID) ) { | ||
4211 | alt18=1; | ||
4212 | } | ||
4213 | switch (alt18) { | ||
4214 | case 1 : | ||
4215 | // InternalSolverLanguageParser.g:1700:4: ( ruleQualifiedName ) | ||
4216 | { | ||
4217 | // InternalSolverLanguageParser.g:1700:4: ( ruleQualifiedName ) | ||
4218 | // InternalSolverLanguageParser.g:1701:5: ruleQualifiedName | ||
4219 | { | ||
4220 | |||
4221 | if (current==null) { | ||
4222 | current = createModelElement(grammarAccess.getLetBindingRule()); | ||
4223 | } | ||
4224 | |||
4225 | |||
4226 | newCompositeNode(grammarAccess.getLetBindingAccess().getTypeSymbolCrossReference_0_0()); | ||
4227 | |||
4228 | pushFollow(FOLLOW_28); | ||
4229 | ruleQualifiedName(); | ||
4230 | |||
4231 | state._fsp--; | ||
4232 | |||
4233 | |||
4234 | afterParserOrEnumRuleCall(); | ||
4235 | |||
4236 | |||
4237 | } | ||
4238 | |||
4239 | |||
4240 | } | ||
4241 | break; | ||
4242 | |||
4243 | } | ||
4244 | |||
4245 | // InternalSolverLanguageParser.g:1715:3: ( (lv_name_1_0= RULE_ID ) ) | ||
4246 | // InternalSolverLanguageParser.g:1716:4: (lv_name_1_0= RULE_ID ) | ||
4247 | { | ||
4248 | // InternalSolverLanguageParser.g:1716:4: (lv_name_1_0= RULE_ID ) | ||
4249 | // InternalSolverLanguageParser.g:1717:5: lv_name_1_0= RULE_ID | ||
4250 | { | ||
4251 | lv_name_1_0=(Token)match(input,RULE_ID,FOLLOW_29); | ||
4252 | |||
4253 | newLeafNode(lv_name_1_0, grammarAccess.getLetBindingAccess().getNameIDTerminalRuleCall_1_0()); | ||
4254 | |||
4255 | |||
4256 | if (current==null) { | ||
4257 | current = createModelElement(grammarAccess.getLetBindingRule()); | ||
4258 | } | ||
4259 | setWithLastConsumed( | ||
4260 | current, | ||
4261 | "name", | ||
4262 | lv_name_1_0, | ||
4263 | "org.eclipse.xtext.common.Terminals.ID"); | ||
4264 | |||
4265 | |||
4266 | } | ||
4267 | |||
4268 | |||
4269 | } | ||
4270 | |||
4271 | otherlv_2=(Token)match(input,EqualsSign,FOLLOW_10); | ||
4272 | |||
4273 | newLeafNode(otherlv_2, grammarAccess.getLetBindingAccess().getEqualsSignKeyword_2()); | ||
4274 | |||
4275 | // InternalSolverLanguageParser.g:1737:3: ( (lv_value_3_0= ruleAdditiveExpression ) ) | ||
4276 | // InternalSolverLanguageParser.g:1738:4: (lv_value_3_0= ruleAdditiveExpression ) | ||
4277 | { | ||
4278 | // InternalSolverLanguageParser.g:1738:4: (lv_value_3_0= ruleAdditiveExpression ) | ||
4279 | // InternalSolverLanguageParser.g:1739:5: lv_value_3_0= ruleAdditiveExpression | ||
4280 | { | ||
4281 | |||
4282 | newCompositeNode(grammarAccess.getLetBindingAccess().getValueAdditiveExpressionParserRuleCall_3_0()); | ||
4283 | |||
4284 | pushFollow(FOLLOW_2); | ||
4285 | lv_value_3_0=ruleAdditiveExpression(); | ||
4286 | |||
4287 | state._fsp--; | ||
4288 | |||
4289 | |||
4290 | if (current==null) { | ||
4291 | current = createModelElementForParent(grammarAccess.getLetBindingRule()); | ||
4292 | } | ||
4293 | set( | ||
4294 | current, | ||
4295 | "value", | ||
4296 | lv_value_3_0, | ||
4297 | "org.eclipse.viatra.solver.language.SolverLanguage.AdditiveExpression"); | ||
4298 | afterParserOrEnumRuleCall(); | ||
4299 | |||
4300 | |||
4301 | } | ||
4302 | |||
4303 | |||
4304 | } | ||
4305 | |||
4306 | |||
4307 | } | ||
4308 | |||
4309 | |||
4310 | } | ||
4311 | |||
4312 | |||
4313 | leaveRule(); | ||
4314 | |||
4315 | } | ||
4316 | |||
4317 | catch (RecognitionException re) { | ||
4318 | recover(input,re); | ||
4319 | appendSkippedTokens(); | ||
4320 | } | ||
4321 | finally { | ||
4322 | } | ||
4323 | return current; | ||
4324 | } | ||
4325 | // $ANTLR end "ruleLetBinding" | ||
4326 | |||
4327 | |||
4328 | // $ANTLR start "entryRuleDisjunctiveExpression" | ||
4329 | // InternalSolverLanguageParser.g:1760:1: entryRuleDisjunctiveExpression returns [EObject current=null] : iv_ruleDisjunctiveExpression= ruleDisjunctiveExpression EOF ; | ||
4330 | public final EObject entryRuleDisjunctiveExpression() throws RecognitionException { | ||
4331 | EObject current = null; | ||
4332 | |||
4333 | EObject iv_ruleDisjunctiveExpression = null; | ||
4334 | |||
4335 | |||
4336 | try { | ||
4337 | // InternalSolverLanguageParser.g:1760:62: (iv_ruleDisjunctiveExpression= ruleDisjunctiveExpression EOF ) | ||
4338 | // InternalSolverLanguageParser.g:1761:2: iv_ruleDisjunctiveExpression= ruleDisjunctiveExpression EOF | ||
4339 | { | ||
4340 | newCompositeNode(grammarAccess.getDisjunctiveExpressionRule()); | ||
4341 | pushFollow(FOLLOW_1); | ||
4342 | iv_ruleDisjunctiveExpression=ruleDisjunctiveExpression(); | ||
4343 | |||
4344 | state._fsp--; | ||
4345 | |||
4346 | current =iv_ruleDisjunctiveExpression; | ||
4347 | match(input,EOF,FOLLOW_2); | ||
4348 | |||
4349 | } | ||
4350 | |||
4351 | } | ||
4352 | |||
4353 | catch (RecognitionException re) { | ||
4354 | recover(input,re); | ||
4355 | appendSkippedTokens(); | ||
4356 | } | ||
4357 | finally { | ||
4358 | } | ||
4359 | return current; | ||
4360 | } | ||
4361 | // $ANTLR end "entryRuleDisjunctiveExpression" | ||
4362 | |||
4363 | |||
4364 | // $ANTLR start "ruleDisjunctiveExpression" | ||
4365 | // InternalSolverLanguageParser.g:1767:1: ruleDisjunctiveExpression returns [EObject current=null] : (this_ConjunctiveExpression_0= ruleConjunctiveExpression ( ( () (otherlv_2= Semicolon ( (lv_children_3_0= ruleConjunctiveExpression ) ) )+ ) | ( () otherlv_5= HyphenMinusGreaterThanSign ( (lv_body_6_0= ruleConjunctiveExpression ) ) () (otherlv_8= Semicolon ( (lv_cases_9_0= ruleCase ) ) )* ) )? ) ; | ||
4366 | public final EObject ruleDisjunctiveExpression() throws RecognitionException { | ||
4367 | EObject current = null; | ||
4368 | |||
4369 | Token otherlv_2=null; | ||
4370 | Token otherlv_5=null; | ||
4371 | Token otherlv_8=null; | ||
4372 | EObject this_ConjunctiveExpression_0 = null; | ||
4373 | |||
4374 | EObject lv_children_3_0 = null; | ||
4375 | |||
4376 | EObject lv_body_6_0 = null; | ||
4377 | |||
4378 | EObject lv_cases_9_0 = null; | ||
4379 | |||
4380 | |||
4381 | |||
4382 | enterRule(); | ||
4383 | |||
4384 | try { | ||
4385 | // InternalSolverLanguageParser.g:1773:2: ( (this_ConjunctiveExpression_0= ruleConjunctiveExpression ( ( () (otherlv_2= Semicolon ( (lv_children_3_0= ruleConjunctiveExpression ) ) )+ ) | ( () otherlv_5= HyphenMinusGreaterThanSign ( (lv_body_6_0= ruleConjunctiveExpression ) ) () (otherlv_8= Semicolon ( (lv_cases_9_0= ruleCase ) ) )* ) )? ) ) | ||
4386 | // InternalSolverLanguageParser.g:1774:2: (this_ConjunctiveExpression_0= ruleConjunctiveExpression ( ( () (otherlv_2= Semicolon ( (lv_children_3_0= ruleConjunctiveExpression ) ) )+ ) | ( () otherlv_5= HyphenMinusGreaterThanSign ( (lv_body_6_0= ruleConjunctiveExpression ) ) () (otherlv_8= Semicolon ( (lv_cases_9_0= ruleCase ) ) )* ) )? ) | ||
4387 | { | ||
4388 | // InternalSolverLanguageParser.g:1774:2: (this_ConjunctiveExpression_0= ruleConjunctiveExpression ( ( () (otherlv_2= Semicolon ( (lv_children_3_0= ruleConjunctiveExpression ) ) )+ ) | ( () otherlv_5= HyphenMinusGreaterThanSign ( (lv_body_6_0= ruleConjunctiveExpression ) ) () (otherlv_8= Semicolon ( (lv_cases_9_0= ruleCase ) ) )* ) )? ) | ||
4389 | // InternalSolverLanguageParser.g:1775:3: this_ConjunctiveExpression_0= ruleConjunctiveExpression ( ( () (otherlv_2= Semicolon ( (lv_children_3_0= ruleConjunctiveExpression ) ) )+ ) | ( () otherlv_5= HyphenMinusGreaterThanSign ( (lv_body_6_0= ruleConjunctiveExpression ) ) () (otherlv_8= Semicolon ( (lv_cases_9_0= ruleCase ) ) )* ) )? | ||
4390 | { | ||
4391 | |||
4392 | newCompositeNode(grammarAccess.getDisjunctiveExpressionAccess().getConjunctiveExpressionParserRuleCall_0()); | ||
4393 | |||
4394 | pushFollow(FOLLOW_30); | ||
4395 | this_ConjunctiveExpression_0=ruleConjunctiveExpression(); | ||
4396 | |||
4397 | state._fsp--; | ||
4398 | |||
4399 | |||
4400 | current = this_ConjunctiveExpression_0; | ||
4401 | afterParserOrEnumRuleCall(); | ||
4402 | |||
4403 | // InternalSolverLanguageParser.g:1783:3: ( ( () (otherlv_2= Semicolon ( (lv_children_3_0= ruleConjunctiveExpression ) ) )+ ) | ( () otherlv_5= HyphenMinusGreaterThanSign ( (lv_body_6_0= ruleConjunctiveExpression ) ) () (otherlv_8= Semicolon ( (lv_cases_9_0= ruleCase ) ) )* ) )? | ||
4404 | int alt21=3; | ||
4405 | int LA21_0 = input.LA(1); | ||
4406 | |||
4407 | if ( (LA21_0==Semicolon) ) { | ||
4408 | alt21=1; | ||
4409 | } | ||
4410 | else if ( (LA21_0==HyphenMinusGreaterThanSign) ) { | ||
4411 | alt21=2; | ||
4412 | } | ||
4413 | switch (alt21) { | ||
4414 | case 1 : | ||
4415 | // InternalSolverLanguageParser.g:1784:4: ( () (otherlv_2= Semicolon ( (lv_children_3_0= ruleConjunctiveExpression ) ) )+ ) | ||
4416 | { | ||
4417 | // InternalSolverLanguageParser.g:1784:4: ( () (otherlv_2= Semicolon ( (lv_children_3_0= ruleConjunctiveExpression ) ) )+ ) | ||
4418 | // InternalSolverLanguageParser.g:1785:5: () (otherlv_2= Semicolon ( (lv_children_3_0= ruleConjunctiveExpression ) ) )+ | ||
4419 | { | ||
4420 | // InternalSolverLanguageParser.g:1785:5: () | ||
4421 | // InternalSolverLanguageParser.g:1786:6: | ||
4422 | { | ||
4423 | |||
4424 | current = forceCreateModelElementAndAdd( | ||
4425 | grammarAccess.getDisjunctiveExpressionAccess().getDisjunctionChildrenAction_1_0_0(), | ||
4426 | current); | ||
4427 | |||
4428 | |||
4429 | } | ||
4430 | |||
4431 | // InternalSolverLanguageParser.g:1792:5: (otherlv_2= Semicolon ( (lv_children_3_0= ruleConjunctiveExpression ) ) )+ | ||
4432 | int cnt19=0; | ||
4433 | loop19: | ||
4434 | do { | ||
4435 | int alt19=2; | ||
4436 | int LA19_0 = input.LA(1); | ||
4437 | |||
4438 | if ( (LA19_0==Semicolon) ) { | ||
4439 | alt19=1; | ||
4440 | } | ||
4441 | |||
4442 | |||
4443 | switch (alt19) { | ||
4444 | case 1 : | ||
4445 | // InternalSolverLanguageParser.g:1793:6: otherlv_2= Semicolon ( (lv_children_3_0= ruleConjunctiveExpression ) ) | ||
4446 | { | ||
4447 | otherlv_2=(Token)match(input,Semicolon,FOLLOW_10); | ||
4448 | |||
4449 | newLeafNode(otherlv_2, grammarAccess.getDisjunctiveExpressionAccess().getSemicolonKeyword_1_0_1_0()); | ||
4450 | |||
4451 | // InternalSolverLanguageParser.g:1797:6: ( (lv_children_3_0= ruleConjunctiveExpression ) ) | ||
4452 | // InternalSolverLanguageParser.g:1798:7: (lv_children_3_0= ruleConjunctiveExpression ) | ||
4453 | { | ||
4454 | // InternalSolverLanguageParser.g:1798:7: (lv_children_3_0= ruleConjunctiveExpression ) | ||
4455 | // InternalSolverLanguageParser.g:1799:8: lv_children_3_0= ruleConjunctiveExpression | ||
4456 | { | ||
4457 | |||
4458 | newCompositeNode(grammarAccess.getDisjunctiveExpressionAccess().getChildrenConjunctiveExpressionParserRuleCall_1_0_1_1_0()); | ||
4459 | |||
4460 | pushFollow(FOLLOW_31); | ||
4461 | lv_children_3_0=ruleConjunctiveExpression(); | ||
4462 | |||
4463 | state._fsp--; | ||
4464 | |||
4465 | |||
4466 | if (current==null) { | ||
4467 | current = createModelElementForParent(grammarAccess.getDisjunctiveExpressionRule()); | ||
4468 | } | ||
4469 | add( | ||
4470 | current, | ||
4471 | "children", | ||
4472 | lv_children_3_0, | ||
4473 | "org.eclipse.viatra.solver.language.SolverLanguage.ConjunctiveExpression"); | ||
4474 | afterParserOrEnumRuleCall(); | ||
4475 | |||
4476 | |||
4477 | } | ||
4478 | |||
4479 | |||
4480 | } | ||
4481 | |||
4482 | |||
4483 | } | ||
4484 | break; | ||
4485 | |||
4486 | default : | ||
4487 | if ( cnt19 >= 1 ) break loop19; | ||
4488 | EarlyExitException eee = | ||
4489 | new EarlyExitException(19, input); | ||
4490 | throw eee; | ||
4491 | } | ||
4492 | cnt19++; | ||
4493 | } while (true); | ||
4494 | |||
4495 | |||
4496 | } | ||
4497 | |||
4498 | |||
4499 | } | ||
4500 | break; | ||
4501 | case 2 : | ||
4502 | // InternalSolverLanguageParser.g:1819:4: ( () otherlv_5= HyphenMinusGreaterThanSign ( (lv_body_6_0= ruleConjunctiveExpression ) ) () (otherlv_8= Semicolon ( (lv_cases_9_0= ruleCase ) ) )* ) | ||
4503 | { | ||
4504 | // InternalSolverLanguageParser.g:1819:4: ( () otherlv_5= HyphenMinusGreaterThanSign ( (lv_body_6_0= ruleConjunctiveExpression ) ) () (otherlv_8= Semicolon ( (lv_cases_9_0= ruleCase ) ) )* ) | ||
4505 | // InternalSolverLanguageParser.g:1820:5: () otherlv_5= HyphenMinusGreaterThanSign ( (lv_body_6_0= ruleConjunctiveExpression ) ) () (otherlv_8= Semicolon ( (lv_cases_9_0= ruleCase ) ) )* | ||
4506 | { | ||
4507 | // InternalSolverLanguageParser.g:1820:5: () | ||
4508 | // InternalSolverLanguageParser.g:1821:6: | ||
4509 | { | ||
4510 | |||
4511 | current = forceCreateModelElementAndSet( | ||
4512 | grammarAccess.getDisjunctiveExpressionAccess().getCaseConditionAction_1_1_0(), | ||
4513 | current); | ||
4514 | |||
4515 | |||
4516 | } | ||
4517 | |||
4518 | otherlv_5=(Token)match(input,HyphenMinusGreaterThanSign,FOLLOW_10); | ||
4519 | |||
4520 | newLeafNode(otherlv_5, grammarAccess.getDisjunctiveExpressionAccess().getHyphenMinusGreaterThanSignKeyword_1_1_1()); | ||
4521 | |||
4522 | // InternalSolverLanguageParser.g:1831:5: ( (lv_body_6_0= ruleConjunctiveExpression ) ) | ||
4523 | // InternalSolverLanguageParser.g:1832:6: (lv_body_6_0= ruleConjunctiveExpression ) | ||
4524 | { | ||
4525 | // InternalSolverLanguageParser.g:1832:6: (lv_body_6_0= ruleConjunctiveExpression ) | ||
4526 | // InternalSolverLanguageParser.g:1833:7: lv_body_6_0= ruleConjunctiveExpression | ||
4527 | { | ||
4528 | |||
4529 | newCompositeNode(grammarAccess.getDisjunctiveExpressionAccess().getBodyConjunctiveExpressionParserRuleCall_1_1_2_0()); | ||
4530 | |||
4531 | pushFollow(FOLLOW_31); | ||
4532 | lv_body_6_0=ruleConjunctiveExpression(); | ||
4533 | |||
4534 | state._fsp--; | ||
4535 | |||
4536 | |||
4537 | if (current==null) { | ||
4538 | current = createModelElementForParent(grammarAccess.getDisjunctiveExpressionRule()); | ||
4539 | } | ||
4540 | set( | ||
4541 | current, | ||
4542 | "body", | ||
4543 | lv_body_6_0, | ||
4544 | "org.eclipse.viatra.solver.language.SolverLanguage.ConjunctiveExpression"); | ||
4545 | afterParserOrEnumRuleCall(); | ||
4546 | |||
4547 | |||
4548 | } | ||
4549 | |||
4550 | |||
4551 | } | ||
4552 | |||
4553 | // InternalSolverLanguageParser.g:1850:5: () | ||
4554 | // InternalSolverLanguageParser.g:1851:6: | ||
4555 | { | ||
4556 | |||
4557 | current = forceCreateModelElementAndAdd( | ||
4558 | grammarAccess.getDisjunctiveExpressionAccess().getSwitchCasesAction_1_1_3(), | ||
4559 | current); | ||
4560 | |||
4561 | |||
4562 | } | ||
4563 | |||
4564 | // InternalSolverLanguageParser.g:1857:5: (otherlv_8= Semicolon ( (lv_cases_9_0= ruleCase ) ) )* | ||
4565 | loop20: | ||
4566 | do { | ||
4567 | int alt20=2; | ||
4568 | int LA20_0 = input.LA(1); | ||
4569 | |||
4570 | if ( (LA20_0==Semicolon) ) { | ||
4571 | alt20=1; | ||
4572 | } | ||
4573 | |||
4574 | |||
4575 | switch (alt20) { | ||
4576 | case 1 : | ||
4577 | // InternalSolverLanguageParser.g:1858:6: otherlv_8= Semicolon ( (lv_cases_9_0= ruleCase ) ) | ||
4578 | { | ||
4579 | otherlv_8=(Token)match(input,Semicolon,FOLLOW_10); | ||
4580 | |||
4581 | newLeafNode(otherlv_8, grammarAccess.getDisjunctiveExpressionAccess().getSemicolonKeyword_1_1_4_0()); | ||
4582 | |||
4583 | // InternalSolverLanguageParser.g:1862:6: ( (lv_cases_9_0= ruleCase ) ) | ||
4584 | // InternalSolverLanguageParser.g:1863:7: (lv_cases_9_0= ruleCase ) | ||
4585 | { | ||
4586 | // InternalSolverLanguageParser.g:1863:7: (lv_cases_9_0= ruleCase ) | ||
4587 | // InternalSolverLanguageParser.g:1864:8: lv_cases_9_0= ruleCase | ||
4588 | { | ||
4589 | |||
4590 | newCompositeNode(grammarAccess.getDisjunctiveExpressionAccess().getCasesCaseParserRuleCall_1_1_4_1_0()); | ||
4591 | |||
4592 | pushFollow(FOLLOW_31); | ||
4593 | lv_cases_9_0=ruleCase(); | ||
4594 | |||
4595 | state._fsp--; | ||
4596 | |||
4597 | |||
4598 | if (current==null) { | ||
4599 | current = createModelElementForParent(grammarAccess.getDisjunctiveExpressionRule()); | ||
4600 | } | ||
4601 | add( | ||
4602 | current, | ||
4603 | "cases", | ||
4604 | lv_cases_9_0, | ||
4605 | "org.eclipse.viatra.solver.language.SolverLanguage.Case"); | ||
4606 | afterParserOrEnumRuleCall(); | ||
4607 | |||
4608 | |||
4609 | } | ||
4610 | |||
4611 | |||
4612 | } | ||
4613 | |||
4614 | |||
4615 | } | ||
4616 | break; | ||
4617 | |||
4618 | default : | ||
4619 | break loop20; | ||
4620 | } | ||
4621 | } while (true); | ||
4622 | |||
4623 | |||
4624 | } | ||
4625 | |||
4626 | |||
4627 | } | ||
4628 | break; | ||
4629 | |||
4630 | } | ||
4631 | |||
4632 | |||
4633 | } | ||
4634 | |||
4635 | |||
4636 | } | ||
4637 | |||
4638 | |||
4639 | leaveRule(); | ||
4640 | |||
4641 | } | ||
4642 | |||
4643 | catch (RecognitionException re) { | ||
4644 | recover(input,re); | ||
4645 | appendSkippedTokens(); | ||
4646 | } | ||
4647 | finally { | ||
4648 | } | ||
4649 | return current; | ||
4650 | } | ||
4651 | // $ANTLR end "ruleDisjunctiveExpression" | ||
4652 | |||
4653 | |||
4654 | // $ANTLR start "entryRuleCase" | ||
4655 | // InternalSolverLanguageParser.g:1888:1: entryRuleCase returns [EObject current=null] : iv_ruleCase= ruleCase EOF ; | ||
4656 | public final EObject entryRuleCase() throws RecognitionException { | ||
4657 | EObject current = null; | ||
4658 | |||
4659 | EObject iv_ruleCase = null; | ||
4660 | |||
4661 | |||
4662 | try { | ||
4663 | // InternalSolverLanguageParser.g:1888:45: (iv_ruleCase= ruleCase EOF ) | ||
4664 | // InternalSolverLanguageParser.g:1889:2: iv_ruleCase= ruleCase EOF | ||
4665 | { | ||
4666 | newCompositeNode(grammarAccess.getCaseRule()); | ||
4667 | pushFollow(FOLLOW_1); | ||
4668 | iv_ruleCase=ruleCase(); | ||
4669 | |||
4670 | state._fsp--; | ||
4671 | |||
4672 | current =iv_ruleCase; | ||
4673 | match(input,EOF,FOLLOW_2); | ||
4674 | |||
4675 | } | ||
4676 | |||
4677 | } | ||
4678 | |||
4679 | catch (RecognitionException re) { | ||
4680 | recover(input,re); | ||
4681 | appendSkippedTokens(); | ||
4682 | } | ||
4683 | finally { | ||
4684 | } | ||
4685 | return current; | ||
4686 | } | ||
4687 | // $ANTLR end "entryRuleCase" | ||
4688 | |||
4689 | |||
4690 | // $ANTLR start "ruleCase" | ||
4691 | // InternalSolverLanguageParser.g:1895:1: ruleCase returns [EObject current=null] : ( ( (lv_condition_0_0= ruleConjunctiveExpression ) ) otherlv_1= HyphenMinusGreaterThanSign ( (lv_body_2_0= ruleConjunctiveExpression ) ) ) ; | ||
4692 | public final EObject ruleCase() throws RecognitionException { | ||
4693 | EObject current = null; | ||
4694 | |||
4695 | Token otherlv_1=null; | ||
4696 | EObject lv_condition_0_0 = null; | ||
4697 | |||
4698 | EObject lv_body_2_0 = null; | ||
4699 | |||
4700 | |||
4701 | |||
4702 | enterRule(); | ||
4703 | |||
4704 | try { | ||
4705 | // InternalSolverLanguageParser.g:1901:2: ( ( ( (lv_condition_0_0= ruleConjunctiveExpression ) ) otherlv_1= HyphenMinusGreaterThanSign ( (lv_body_2_0= ruleConjunctiveExpression ) ) ) ) | ||
4706 | // InternalSolverLanguageParser.g:1902:2: ( ( (lv_condition_0_0= ruleConjunctiveExpression ) ) otherlv_1= HyphenMinusGreaterThanSign ( (lv_body_2_0= ruleConjunctiveExpression ) ) ) | ||
4707 | { | ||
4708 | // InternalSolverLanguageParser.g:1902:2: ( ( (lv_condition_0_0= ruleConjunctiveExpression ) ) otherlv_1= HyphenMinusGreaterThanSign ( (lv_body_2_0= ruleConjunctiveExpression ) ) ) | ||
4709 | // InternalSolverLanguageParser.g:1903:3: ( (lv_condition_0_0= ruleConjunctiveExpression ) ) otherlv_1= HyphenMinusGreaterThanSign ( (lv_body_2_0= ruleConjunctiveExpression ) ) | ||
4710 | { | ||
4711 | // InternalSolverLanguageParser.g:1903:3: ( (lv_condition_0_0= ruleConjunctiveExpression ) ) | ||
4712 | // InternalSolverLanguageParser.g:1904:4: (lv_condition_0_0= ruleConjunctiveExpression ) | ||
4713 | { | ||
4714 | // InternalSolverLanguageParser.g:1904:4: (lv_condition_0_0= ruleConjunctiveExpression ) | ||
4715 | // InternalSolverLanguageParser.g:1905:5: lv_condition_0_0= ruleConjunctiveExpression | ||
4716 | { | ||
4717 | |||
4718 | newCompositeNode(grammarAccess.getCaseAccess().getConditionConjunctiveExpressionParserRuleCall_0_0()); | ||
4719 | |||
4720 | pushFollow(FOLLOW_32); | ||
4721 | lv_condition_0_0=ruleConjunctiveExpression(); | ||
4722 | |||
4723 | state._fsp--; | ||
4724 | |||
4725 | |||
4726 | if (current==null) { | ||
4727 | current = createModelElementForParent(grammarAccess.getCaseRule()); | ||
4728 | } | ||
4729 | set( | ||
4730 | current, | ||
4731 | "condition", | ||
4732 | lv_condition_0_0, | ||
4733 | "org.eclipse.viatra.solver.language.SolverLanguage.ConjunctiveExpression"); | ||
4734 | afterParserOrEnumRuleCall(); | ||
4735 | |||
4736 | |||
4737 | } | ||
4738 | |||
4739 | |||
4740 | } | ||
4741 | |||
4742 | otherlv_1=(Token)match(input,HyphenMinusGreaterThanSign,FOLLOW_10); | ||
4743 | |||
4744 | newLeafNode(otherlv_1, grammarAccess.getCaseAccess().getHyphenMinusGreaterThanSignKeyword_1()); | ||
4745 | |||
4746 | // InternalSolverLanguageParser.g:1926:3: ( (lv_body_2_0= ruleConjunctiveExpression ) ) | ||
4747 | // InternalSolverLanguageParser.g:1927:4: (lv_body_2_0= ruleConjunctiveExpression ) | ||
4748 | { | ||
4749 | // InternalSolverLanguageParser.g:1927:4: (lv_body_2_0= ruleConjunctiveExpression ) | ||
4750 | // InternalSolverLanguageParser.g:1928:5: lv_body_2_0= ruleConjunctiveExpression | ||
4751 | { | ||
4752 | |||
4753 | newCompositeNode(grammarAccess.getCaseAccess().getBodyConjunctiveExpressionParserRuleCall_2_0()); | ||
4754 | |||
4755 | pushFollow(FOLLOW_2); | ||
4756 | lv_body_2_0=ruleConjunctiveExpression(); | ||
4757 | |||
4758 | state._fsp--; | ||
4759 | |||
4760 | |||
4761 | if (current==null) { | ||
4762 | current = createModelElementForParent(grammarAccess.getCaseRule()); | ||
4763 | } | ||
4764 | set( | ||
4765 | current, | ||
4766 | "body", | ||
4767 | lv_body_2_0, | ||
4768 | "org.eclipse.viatra.solver.language.SolverLanguage.ConjunctiveExpression"); | ||
4769 | afterParserOrEnumRuleCall(); | ||
4770 | |||
4771 | |||
4772 | } | ||
4773 | |||
4774 | |||
4775 | } | ||
4776 | |||
4777 | |||
4778 | } | ||
4779 | |||
4780 | |||
4781 | } | ||
4782 | |||
4783 | |||
4784 | leaveRule(); | ||
4785 | |||
4786 | } | ||
4787 | |||
4788 | catch (RecognitionException re) { | ||
4789 | recover(input,re); | ||
4790 | appendSkippedTokens(); | ||
4791 | } | ||
4792 | finally { | ||
4793 | } | ||
4794 | return current; | ||
4795 | } | ||
4796 | // $ANTLR end "ruleCase" | ||
4797 | |||
4798 | |||
4799 | // $ANTLR start "entryRuleConjunctiveExpression" | ||
4800 | // InternalSolverLanguageParser.g:1949:1: entryRuleConjunctiveExpression returns [EObject current=null] : iv_ruleConjunctiveExpression= ruleConjunctiveExpression EOF ; | ||
4801 | public final EObject entryRuleConjunctiveExpression() throws RecognitionException { | ||
4802 | EObject current = null; | ||
4803 | |||
4804 | EObject iv_ruleConjunctiveExpression = null; | ||
4805 | |||
4806 | |||
4807 | try { | ||
4808 | // InternalSolverLanguageParser.g:1949:62: (iv_ruleConjunctiveExpression= ruleConjunctiveExpression EOF ) | ||
4809 | // InternalSolverLanguageParser.g:1950:2: iv_ruleConjunctiveExpression= ruleConjunctiveExpression EOF | ||
4810 | { | ||
4811 | newCompositeNode(grammarAccess.getConjunctiveExpressionRule()); | ||
4812 | pushFollow(FOLLOW_1); | ||
4813 | iv_ruleConjunctiveExpression=ruleConjunctiveExpression(); | ||
4814 | |||
4815 | state._fsp--; | ||
4816 | |||
4817 | current =iv_ruleConjunctiveExpression; | ||
4818 | match(input,EOF,FOLLOW_2); | ||
4819 | |||
4820 | } | ||
4821 | |||
4822 | } | ||
4823 | |||
4824 | catch (RecognitionException re) { | ||
4825 | recover(input,re); | ||
4826 | appendSkippedTokens(); | ||
4827 | } | ||
4828 | finally { | ||
4829 | } | ||
4830 | return current; | ||
4831 | } | ||
4832 | // $ANTLR end "entryRuleConjunctiveExpression" | ||
4833 | |||
4834 | |||
4835 | // $ANTLR start "ruleConjunctiveExpression" | ||
4836 | // InternalSolverLanguageParser.g:1956:1: ruleConjunctiveExpression returns [EObject current=null] : (this_ComparisonExpression_0= ruleComparisonExpression ( () (otherlv_2= Comma ( (lv_children_3_0= ruleComparisonExpression ) ) )+ )? ) ; | ||
4837 | public final EObject ruleConjunctiveExpression() throws RecognitionException { | ||
4838 | EObject current = null; | ||
4839 | |||
4840 | Token otherlv_2=null; | ||
4841 | EObject this_ComparisonExpression_0 = null; | ||
4842 | |||
4843 | EObject lv_children_3_0 = null; | ||
4844 | |||
4845 | |||
4846 | |||
4847 | enterRule(); | ||
4848 | |||
4849 | try { | ||
4850 | // InternalSolverLanguageParser.g:1962:2: ( (this_ComparisonExpression_0= ruleComparisonExpression ( () (otherlv_2= Comma ( (lv_children_3_0= ruleComparisonExpression ) ) )+ )? ) ) | ||
4851 | // InternalSolverLanguageParser.g:1963:2: (this_ComparisonExpression_0= ruleComparisonExpression ( () (otherlv_2= Comma ( (lv_children_3_0= ruleComparisonExpression ) ) )+ )? ) | ||
4852 | { | ||
4853 | // InternalSolverLanguageParser.g:1963:2: (this_ComparisonExpression_0= ruleComparisonExpression ( () (otherlv_2= Comma ( (lv_children_3_0= ruleComparisonExpression ) ) )+ )? ) | ||
4854 | // InternalSolverLanguageParser.g:1964:3: this_ComparisonExpression_0= ruleComparisonExpression ( () (otherlv_2= Comma ( (lv_children_3_0= ruleComparisonExpression ) ) )+ )? | ||
4855 | { | ||
4856 | |||
4857 | newCompositeNode(grammarAccess.getConjunctiveExpressionAccess().getComparisonExpressionParserRuleCall_0()); | ||
4858 | |||
4859 | pushFollow(FOLLOW_33); | ||
4860 | this_ComparisonExpression_0=ruleComparisonExpression(); | ||
4861 | |||
4862 | state._fsp--; | ||
4863 | |||
4864 | |||
4865 | current = this_ComparisonExpression_0; | ||
4866 | afterParserOrEnumRuleCall(); | ||
4867 | |||
4868 | // InternalSolverLanguageParser.g:1972:3: ( () (otherlv_2= Comma ( (lv_children_3_0= ruleComparisonExpression ) ) )+ )? | ||
4869 | int alt23=2; | ||
4870 | int LA23_0 = input.LA(1); | ||
4871 | |||
4872 | if ( (LA23_0==Comma) ) { | ||
4873 | alt23=1; | ||
4874 | } | ||
4875 | switch (alt23) { | ||
4876 | case 1 : | ||
4877 | // InternalSolverLanguageParser.g:1973:4: () (otherlv_2= Comma ( (lv_children_3_0= ruleComparisonExpression ) ) )+ | ||
4878 | { | ||
4879 | // InternalSolverLanguageParser.g:1973:4: () | ||
4880 | // InternalSolverLanguageParser.g:1974:5: | ||
4881 | { | ||
4882 | |||
4883 | current = forceCreateModelElementAndAdd( | ||
4884 | grammarAccess.getConjunctiveExpressionAccess().getConjunctionChildrenAction_1_0(), | ||
4885 | current); | ||
4886 | |||
4887 | |||
4888 | } | ||
4889 | |||
4890 | // InternalSolverLanguageParser.g:1980:4: (otherlv_2= Comma ( (lv_children_3_0= ruleComparisonExpression ) ) )+ | ||
4891 | int cnt22=0; | ||
4892 | loop22: | ||
4893 | do { | ||
4894 | int alt22=2; | ||
4895 | int LA22_0 = input.LA(1); | ||
4896 | |||
4897 | if ( (LA22_0==Comma) ) { | ||
4898 | alt22=1; | ||
4899 | } | ||
4900 | |||
4901 | |||
4902 | switch (alt22) { | ||
4903 | case 1 : | ||
4904 | // InternalSolverLanguageParser.g:1981:5: otherlv_2= Comma ( (lv_children_3_0= ruleComparisonExpression ) ) | ||
4905 | { | ||
4906 | otherlv_2=(Token)match(input,Comma,FOLLOW_10); | ||
4907 | |||
4908 | newLeafNode(otherlv_2, grammarAccess.getConjunctiveExpressionAccess().getCommaKeyword_1_1_0()); | ||
4909 | |||
4910 | // InternalSolverLanguageParser.g:1985:5: ( (lv_children_3_0= ruleComparisonExpression ) ) | ||
4911 | // InternalSolverLanguageParser.g:1986:6: (lv_children_3_0= ruleComparisonExpression ) | ||
4912 | { | ||
4913 | // InternalSolverLanguageParser.g:1986:6: (lv_children_3_0= ruleComparisonExpression ) | ||
4914 | // InternalSolverLanguageParser.g:1987:7: lv_children_3_0= ruleComparisonExpression | ||
4915 | { | ||
4916 | |||
4917 | newCompositeNode(grammarAccess.getConjunctiveExpressionAccess().getChildrenComparisonExpressionParserRuleCall_1_1_1_0()); | ||
4918 | |||
4919 | pushFollow(FOLLOW_33); | ||
4920 | lv_children_3_0=ruleComparisonExpression(); | ||
4921 | |||
4922 | state._fsp--; | ||
4923 | |||
4924 | |||
4925 | if (current==null) { | ||
4926 | current = createModelElementForParent(grammarAccess.getConjunctiveExpressionRule()); | ||
4927 | } | ||
4928 | add( | ||
4929 | current, | ||
4930 | "children", | ||
4931 | lv_children_3_0, | ||
4932 | "org.eclipse.viatra.solver.language.SolverLanguage.ComparisonExpression"); | ||
4933 | afterParserOrEnumRuleCall(); | ||
4934 | |||
4935 | |||
4936 | } | ||
4937 | |||
4938 | |||
4939 | } | ||
4940 | |||
4941 | |||
4942 | } | ||
4943 | break; | ||
4944 | |||
4945 | default : | ||
4946 | if ( cnt22 >= 1 ) break loop22; | ||
4947 | EarlyExitException eee = | ||
4948 | new EarlyExitException(22, input); | ||
4949 | throw eee; | ||
4950 | } | ||
4951 | cnt22++; | ||
4952 | } while (true); | ||
4953 | |||
4954 | |||
4955 | } | ||
4956 | break; | ||
4957 | |||
4958 | } | ||
4959 | |||
4960 | |||
4961 | } | ||
4962 | |||
4963 | |||
4964 | } | ||
4965 | |||
4966 | |||
4967 | leaveRule(); | ||
4968 | |||
4969 | } | ||
4970 | |||
4971 | catch (RecognitionException re) { | ||
4972 | recover(input,re); | ||
4973 | appendSkippedTokens(); | ||
4974 | } | ||
4975 | finally { | ||
4976 | } | ||
4977 | return current; | ||
4978 | } | ||
4979 | // $ANTLR end "ruleConjunctiveExpression" | ||
4980 | |||
4981 | |||
4982 | // $ANTLR start "entryRuleComparisonExpression" | ||
4983 | // InternalSolverLanguageParser.g:2010:1: entryRuleComparisonExpression returns [EObject current=null] : iv_ruleComparisonExpression= ruleComparisonExpression EOF ; | ||
4984 | public final EObject entryRuleComparisonExpression() throws RecognitionException { | ||
4985 | EObject current = null; | ||
4986 | |||
4987 | EObject iv_ruleComparisonExpression = null; | ||
4988 | |||
4989 | |||
4990 | try { | ||
4991 | // InternalSolverLanguageParser.g:2010:61: (iv_ruleComparisonExpression= ruleComparisonExpression EOF ) | ||
4992 | // InternalSolverLanguageParser.g:2011:2: iv_ruleComparisonExpression= ruleComparisonExpression EOF | ||
4993 | { | ||
4994 | newCompositeNode(grammarAccess.getComparisonExpressionRule()); | ||
4995 | pushFollow(FOLLOW_1); | ||
4996 | iv_ruleComparisonExpression=ruleComparisonExpression(); | ||
4997 | |||
4998 | state._fsp--; | ||
4999 | |||
5000 | current =iv_ruleComparisonExpression; | ||
5001 | match(input,EOF,FOLLOW_2); | ||
5002 | |||
5003 | } | ||
5004 | |||
5005 | } | ||
5006 | |||
5007 | catch (RecognitionException re) { | ||
5008 | recover(input,re); | ||
5009 | appendSkippedTokens(); | ||
5010 | } | ||
5011 | finally { | ||
5012 | } | ||
5013 | return current; | ||
5014 | } | ||
5015 | // $ANTLR end "entryRuleComparisonExpression" | ||
5016 | |||
5017 | |||
5018 | // $ANTLR start "ruleComparisonExpression" | ||
5019 | // InternalSolverLanguageParser.g:2017:1: ruleComparisonExpression returns [EObject current=null] : (this_AdditiveExpression_0= ruleAdditiveExpression ( () ( (lv_op_2_0= ruleComparisonOperator ) ) ( (lv_right_3_0= ruleAdditiveExpression ) ) )? ) ; | ||
5020 | public final EObject ruleComparisonExpression() throws RecognitionException { | ||
5021 | EObject current = null; | ||
5022 | |||
5023 | EObject this_AdditiveExpression_0 = null; | ||
5024 | |||
5025 | Enumerator lv_op_2_0 = null; | ||
5026 | |||
5027 | EObject lv_right_3_0 = null; | ||
5028 | |||
5029 | |||
5030 | |||
5031 | enterRule(); | ||
5032 | |||
5033 | try { | ||
5034 | // InternalSolverLanguageParser.g:2023:2: ( (this_AdditiveExpression_0= ruleAdditiveExpression ( () ( (lv_op_2_0= ruleComparisonOperator ) ) ( (lv_right_3_0= ruleAdditiveExpression ) ) )? ) ) | ||
5035 | // InternalSolverLanguageParser.g:2024:2: (this_AdditiveExpression_0= ruleAdditiveExpression ( () ( (lv_op_2_0= ruleComparisonOperator ) ) ( (lv_right_3_0= ruleAdditiveExpression ) ) )? ) | ||
5036 | { | ||
5037 | // InternalSolverLanguageParser.g:2024:2: (this_AdditiveExpression_0= ruleAdditiveExpression ( () ( (lv_op_2_0= ruleComparisonOperator ) ) ( (lv_right_3_0= ruleAdditiveExpression ) ) )? ) | ||
5038 | // InternalSolverLanguageParser.g:2025:3: this_AdditiveExpression_0= ruleAdditiveExpression ( () ( (lv_op_2_0= ruleComparisonOperator ) ) ( (lv_right_3_0= ruleAdditiveExpression ) ) )? | ||
5039 | { | ||
5040 | |||
5041 | newCompositeNode(grammarAccess.getComparisonExpressionAccess().getAdditiveExpressionParserRuleCall_0()); | ||
5042 | |||
5043 | pushFollow(FOLLOW_34); | ||
5044 | this_AdditiveExpression_0=ruleAdditiveExpression(); | ||
5045 | |||
5046 | state._fsp--; | ||
5047 | |||
5048 | |||
5049 | current = this_AdditiveExpression_0; | ||
5050 | afterParserOrEnumRuleCall(); | ||
5051 | |||
5052 | // InternalSolverLanguageParser.g:2033:3: ( () ( (lv_op_2_0= ruleComparisonOperator ) ) ( (lv_right_3_0= ruleAdditiveExpression ) ) )? | ||
5053 | int alt24=2; | ||
5054 | int LA24_0 = input.LA(1); | ||
5055 | |||
5056 | if ( (LA24_0==ExclamationMarkEqualsSign||(LA24_0>=LessThanSignEqualsSign && LA24_0<=EqualsSignEqualsSign)||LA24_0==GreaterThanSignEqualsSign||LA24_0==In||LA24_0==LessThanSign||LA24_0==GreaterThanSign) ) { | ||
5057 | alt24=1; | ||
5058 | } | ||
5059 | switch (alt24) { | ||
5060 | case 1 : | ||
5061 | // InternalSolverLanguageParser.g:2034:4: () ( (lv_op_2_0= ruleComparisonOperator ) ) ( (lv_right_3_0= ruleAdditiveExpression ) ) | ||
5062 | { | ||
5063 | // InternalSolverLanguageParser.g:2034:4: () | ||
5064 | // InternalSolverLanguageParser.g:2035:5: | ||
5065 | { | ||
5066 | |||
5067 | current = forceCreateModelElementAndSet( | ||
5068 | grammarAccess.getComparisonExpressionAccess().getBinaryExpressionLeftAction_1_0(), | ||
5069 | current); | ||
5070 | |||
5071 | |||
5072 | } | ||
5073 | |||
5074 | // InternalSolverLanguageParser.g:2041:4: ( (lv_op_2_0= ruleComparisonOperator ) ) | ||
5075 | // InternalSolverLanguageParser.g:2042:5: (lv_op_2_0= ruleComparisonOperator ) | ||
5076 | { | ||
5077 | // InternalSolverLanguageParser.g:2042:5: (lv_op_2_0= ruleComparisonOperator ) | ||
5078 | // InternalSolverLanguageParser.g:2043:6: lv_op_2_0= ruleComparisonOperator | ||
5079 | { | ||
5080 | |||
5081 | newCompositeNode(grammarAccess.getComparisonExpressionAccess().getOpComparisonOperatorEnumRuleCall_1_1_0()); | ||
5082 | |||
5083 | pushFollow(FOLLOW_10); | ||
5084 | lv_op_2_0=ruleComparisonOperator(); | ||
5085 | |||
5086 | state._fsp--; | ||
5087 | |||
5088 | |||
5089 | if (current==null) { | ||
5090 | current = createModelElementForParent(grammarAccess.getComparisonExpressionRule()); | ||
5091 | } | ||
5092 | set( | ||
5093 | current, | ||
5094 | "op", | ||
5095 | lv_op_2_0, | ||
5096 | "org.eclipse.viatra.solver.language.SolverLanguage.ComparisonOperator"); | ||
5097 | afterParserOrEnumRuleCall(); | ||
5098 | |||
5099 | |||
5100 | } | ||
5101 | |||
5102 | |||
5103 | } | ||
5104 | |||
5105 | // InternalSolverLanguageParser.g:2060:4: ( (lv_right_3_0= ruleAdditiveExpression ) ) | ||
5106 | // InternalSolverLanguageParser.g:2061:5: (lv_right_3_0= ruleAdditiveExpression ) | ||
5107 | { | ||
5108 | // InternalSolverLanguageParser.g:2061:5: (lv_right_3_0= ruleAdditiveExpression ) | ||
5109 | // InternalSolverLanguageParser.g:2062:6: lv_right_3_0= ruleAdditiveExpression | ||
5110 | { | ||
5111 | |||
5112 | newCompositeNode(grammarAccess.getComparisonExpressionAccess().getRightAdditiveExpressionParserRuleCall_1_2_0()); | ||
5113 | |||
5114 | pushFollow(FOLLOW_2); | ||
5115 | lv_right_3_0=ruleAdditiveExpression(); | ||
5116 | |||
5117 | state._fsp--; | ||
5118 | |||
5119 | |||
5120 | if (current==null) { | ||
5121 | current = createModelElementForParent(grammarAccess.getComparisonExpressionRule()); | ||
5122 | } | ||
5123 | set( | ||
5124 | current, | ||
5125 | "right", | ||
5126 | lv_right_3_0, | ||
5127 | "org.eclipse.viatra.solver.language.SolverLanguage.AdditiveExpression"); | ||
5128 | afterParserOrEnumRuleCall(); | ||
5129 | |||
5130 | |||
5131 | } | ||
5132 | |||
5133 | |||
5134 | } | ||
5135 | |||
5136 | |||
5137 | } | ||
5138 | break; | ||
5139 | |||
5140 | } | ||
5141 | |||
5142 | |||
5143 | } | ||
5144 | |||
5145 | |||
5146 | } | ||
5147 | |||
5148 | |||
5149 | leaveRule(); | ||
5150 | |||
5151 | } | ||
5152 | |||
5153 | catch (RecognitionException re) { | ||
5154 | recover(input,re); | ||
5155 | appendSkippedTokens(); | ||
5156 | } | ||
5157 | finally { | ||
5158 | } | ||
5159 | return current; | ||
5160 | } | ||
5161 | // $ANTLR end "ruleComparisonExpression" | ||
5162 | |||
5163 | |||
5164 | // $ANTLR start "entryRuleAdditiveExpression" | ||
5165 | // InternalSolverLanguageParser.g:2084:1: entryRuleAdditiveExpression returns [EObject current=null] : iv_ruleAdditiveExpression= ruleAdditiveExpression EOF ; | ||
5166 | public final EObject entryRuleAdditiveExpression() throws RecognitionException { | ||
5167 | EObject current = null; | ||
5168 | |||
5169 | EObject iv_ruleAdditiveExpression = null; | ||
5170 | |||
5171 | |||
5172 | try { | ||
5173 | // InternalSolverLanguageParser.g:2084:59: (iv_ruleAdditiveExpression= ruleAdditiveExpression EOF ) | ||
5174 | // InternalSolverLanguageParser.g:2085:2: iv_ruleAdditiveExpression= ruleAdditiveExpression EOF | ||
5175 | { | ||
5176 | newCompositeNode(grammarAccess.getAdditiveExpressionRule()); | ||
5177 | pushFollow(FOLLOW_1); | ||
5178 | iv_ruleAdditiveExpression=ruleAdditiveExpression(); | ||
5179 | |||
5180 | state._fsp--; | ||
5181 | |||
5182 | current =iv_ruleAdditiveExpression; | ||
5183 | match(input,EOF,FOLLOW_2); | ||
5184 | |||
5185 | } | ||
5186 | |||
5187 | } | ||
5188 | |||
5189 | catch (RecognitionException re) { | ||
5190 | recover(input,re); | ||
5191 | appendSkippedTokens(); | ||
5192 | } | ||
5193 | finally { | ||
5194 | } | ||
5195 | return current; | ||
5196 | } | ||
5197 | // $ANTLR end "entryRuleAdditiveExpression" | ||
5198 | |||
5199 | |||
5200 | // $ANTLR start "ruleAdditiveExpression" | ||
5201 | // InternalSolverLanguageParser.g:2091:1: ruleAdditiveExpression returns [EObject current=null] : (this_MultiplicativeExpression_0= ruleMultiplicativeExpression ( () ( (lv_op_2_0= ruleAdditiveBinaryOperator ) ) ( (lv_right_3_0= ruleMultiplicativeExpression ) ) )* ) ; | ||
5202 | public final EObject ruleAdditiveExpression() throws RecognitionException { | ||
5203 | EObject current = null; | ||
5204 | |||
5205 | EObject this_MultiplicativeExpression_0 = null; | ||
5206 | |||
5207 | Enumerator lv_op_2_0 = null; | ||
5208 | |||
5209 | EObject lv_right_3_0 = null; | ||
5210 | |||
5211 | |||
5212 | |||
5213 | enterRule(); | ||
5214 | |||
5215 | try { | ||
5216 | // InternalSolverLanguageParser.g:2097:2: ( (this_MultiplicativeExpression_0= ruleMultiplicativeExpression ( () ( (lv_op_2_0= ruleAdditiveBinaryOperator ) ) ( (lv_right_3_0= ruleMultiplicativeExpression ) ) )* ) ) | ||
5217 | // InternalSolverLanguageParser.g:2098:2: (this_MultiplicativeExpression_0= ruleMultiplicativeExpression ( () ( (lv_op_2_0= ruleAdditiveBinaryOperator ) ) ( (lv_right_3_0= ruleMultiplicativeExpression ) ) )* ) | ||
5218 | { | ||
5219 | // InternalSolverLanguageParser.g:2098:2: (this_MultiplicativeExpression_0= ruleMultiplicativeExpression ( () ( (lv_op_2_0= ruleAdditiveBinaryOperator ) ) ( (lv_right_3_0= ruleMultiplicativeExpression ) ) )* ) | ||
5220 | // InternalSolverLanguageParser.g:2099:3: this_MultiplicativeExpression_0= ruleMultiplicativeExpression ( () ( (lv_op_2_0= ruleAdditiveBinaryOperator ) ) ( (lv_right_3_0= ruleMultiplicativeExpression ) ) )* | ||
5221 | { | ||
5222 | |||
5223 | newCompositeNode(grammarAccess.getAdditiveExpressionAccess().getMultiplicativeExpressionParserRuleCall_0()); | ||
5224 | |||
5225 | pushFollow(FOLLOW_35); | ||
5226 | this_MultiplicativeExpression_0=ruleMultiplicativeExpression(); | ||
5227 | |||
5228 | state._fsp--; | ||
5229 | |||
5230 | |||
5231 | current = this_MultiplicativeExpression_0; | ||
5232 | afterParserOrEnumRuleCall(); | ||
5233 | |||
5234 | // InternalSolverLanguageParser.g:2107:3: ( () ( (lv_op_2_0= ruleAdditiveBinaryOperator ) ) ( (lv_right_3_0= ruleMultiplicativeExpression ) ) )* | ||
5235 | loop25: | ||
5236 | do { | ||
5237 | int alt25=2; | ||
5238 | int LA25_0 = input.LA(1); | ||
5239 | |||
5240 | if ( (LA25_0==PlusSign||LA25_0==HyphenMinus) ) { | ||
5241 | alt25=1; | ||
5242 | } | ||
5243 | |||
5244 | |||
5245 | switch (alt25) { | ||
5246 | case 1 : | ||
5247 | // InternalSolverLanguageParser.g:2108:4: () ( (lv_op_2_0= ruleAdditiveBinaryOperator ) ) ( (lv_right_3_0= ruleMultiplicativeExpression ) ) | ||
5248 | { | ||
5249 | // InternalSolverLanguageParser.g:2108:4: () | ||
5250 | // InternalSolverLanguageParser.g:2109:5: | ||
5251 | { | ||
5252 | |||
5253 | current = forceCreateModelElementAndSet( | ||
5254 | grammarAccess.getAdditiveExpressionAccess().getBinaryExpressionLeftAction_1_0(), | ||
5255 | current); | ||
5256 | |||
5257 | |||
5258 | } | ||
5259 | |||
5260 | // InternalSolverLanguageParser.g:2115:4: ( (lv_op_2_0= ruleAdditiveBinaryOperator ) ) | ||
5261 | // InternalSolverLanguageParser.g:2116:5: (lv_op_2_0= ruleAdditiveBinaryOperator ) | ||
5262 | { | ||
5263 | // InternalSolverLanguageParser.g:2116:5: (lv_op_2_0= ruleAdditiveBinaryOperator ) | ||
5264 | // InternalSolverLanguageParser.g:2117:6: lv_op_2_0= ruleAdditiveBinaryOperator | ||
5265 | { | ||
5266 | |||
5267 | newCompositeNode(grammarAccess.getAdditiveExpressionAccess().getOpAdditiveBinaryOperatorEnumRuleCall_1_1_0()); | ||
5268 | |||
5269 | pushFollow(FOLLOW_10); | ||
5270 | lv_op_2_0=ruleAdditiveBinaryOperator(); | ||
5271 | |||
5272 | state._fsp--; | ||
5273 | |||
5274 | |||
5275 | if (current==null) { | ||
5276 | current = createModelElementForParent(grammarAccess.getAdditiveExpressionRule()); | ||
5277 | } | ||
5278 | set( | ||
5279 | current, | ||
5280 | "op", | ||
5281 | lv_op_2_0, | ||
5282 | "org.eclipse.viatra.solver.language.SolverLanguage.AdditiveBinaryOperator"); | ||
5283 | afterParserOrEnumRuleCall(); | ||
5284 | |||
5285 | |||
5286 | } | ||
5287 | |||
5288 | |||
5289 | } | ||
5290 | |||
5291 | // InternalSolverLanguageParser.g:2134:4: ( (lv_right_3_0= ruleMultiplicativeExpression ) ) | ||
5292 | // InternalSolverLanguageParser.g:2135:5: (lv_right_3_0= ruleMultiplicativeExpression ) | ||
5293 | { | ||
5294 | // InternalSolverLanguageParser.g:2135:5: (lv_right_3_0= ruleMultiplicativeExpression ) | ||
5295 | // InternalSolverLanguageParser.g:2136:6: lv_right_3_0= ruleMultiplicativeExpression | ||
5296 | { | ||
5297 | |||
5298 | newCompositeNode(grammarAccess.getAdditiveExpressionAccess().getRightMultiplicativeExpressionParserRuleCall_1_2_0()); | ||
5299 | |||
5300 | pushFollow(FOLLOW_35); | ||
5301 | lv_right_3_0=ruleMultiplicativeExpression(); | ||
5302 | |||
5303 | state._fsp--; | ||
5304 | |||
5305 | |||
5306 | if (current==null) { | ||
5307 | current = createModelElementForParent(grammarAccess.getAdditiveExpressionRule()); | ||
5308 | } | ||
5309 | set( | ||
5310 | current, | ||
5311 | "right", | ||
5312 | lv_right_3_0, | ||
5313 | "org.eclipse.viatra.solver.language.SolverLanguage.MultiplicativeExpression"); | ||
5314 | afterParserOrEnumRuleCall(); | ||
5315 | |||
5316 | |||
5317 | } | ||
5318 | |||
5319 | |||
5320 | } | ||
5321 | |||
5322 | |||
5323 | } | ||
5324 | break; | ||
5325 | |||
5326 | default : | ||
5327 | break loop25; | ||
5328 | } | ||
5329 | } while (true); | ||
5330 | |||
5331 | |||
5332 | } | ||
5333 | |||
5334 | |||
5335 | } | ||
5336 | |||
5337 | |||
5338 | leaveRule(); | ||
5339 | |||
5340 | } | ||
5341 | |||
5342 | catch (RecognitionException re) { | ||
5343 | recover(input,re); | ||
5344 | appendSkippedTokens(); | ||
5345 | } | ||
5346 | finally { | ||
5347 | } | ||
5348 | return current; | ||
5349 | } | ||
5350 | // $ANTLR end "ruleAdditiveExpression" | ||
5351 | |||
5352 | |||
5353 | // $ANTLR start "entryRuleMultiplicativeExpression" | ||
5354 | // InternalSolverLanguageParser.g:2158:1: entryRuleMultiplicativeExpression returns [EObject current=null] : iv_ruleMultiplicativeExpression= ruleMultiplicativeExpression EOF ; | ||
5355 | public final EObject entryRuleMultiplicativeExpression() throws RecognitionException { | ||
5356 | EObject current = null; | ||
5357 | |||
5358 | EObject iv_ruleMultiplicativeExpression = null; | ||
5359 | |||
5360 | |||
5361 | try { | ||
5362 | // InternalSolverLanguageParser.g:2158:65: (iv_ruleMultiplicativeExpression= ruleMultiplicativeExpression EOF ) | ||
5363 | // InternalSolverLanguageParser.g:2159:2: iv_ruleMultiplicativeExpression= ruleMultiplicativeExpression EOF | ||
5364 | { | ||
5365 | newCompositeNode(grammarAccess.getMultiplicativeExpressionRule()); | ||
5366 | pushFollow(FOLLOW_1); | ||
5367 | iv_ruleMultiplicativeExpression=ruleMultiplicativeExpression(); | ||
5368 | |||
5369 | state._fsp--; | ||
5370 | |||
5371 | current =iv_ruleMultiplicativeExpression; | ||
5372 | match(input,EOF,FOLLOW_2); | ||
5373 | |||
5374 | } | ||
5375 | |||
5376 | } | ||
5377 | |||
5378 | catch (RecognitionException re) { | ||
5379 | recover(input,re); | ||
5380 | appendSkippedTokens(); | ||
5381 | } | ||
5382 | finally { | ||
5383 | } | ||
5384 | return current; | ||
5385 | } | ||
5386 | // $ANTLR end "entryRuleMultiplicativeExpression" | ||
5387 | |||
5388 | |||
5389 | // $ANTLR start "ruleMultiplicativeExpression" | ||
5390 | // InternalSolverLanguageParser.g:2165:1: ruleMultiplicativeExpression returns [EObject current=null] : (this_ExponentialExpression_0= ruleExponentialExpression ( () ( (lv_op_2_0= ruleMultiplicativeBinaryOperator ) ) ( (lv_right_3_0= ruleExponentialExpression ) ) )* ) ; | ||
5391 | public final EObject ruleMultiplicativeExpression() throws RecognitionException { | ||
5392 | EObject current = null; | ||
5393 | |||
5394 | EObject this_ExponentialExpression_0 = null; | ||
5395 | |||
5396 | Enumerator lv_op_2_0 = null; | ||
5397 | |||
5398 | EObject lv_right_3_0 = null; | ||
5399 | |||
5400 | |||
5401 | |||
5402 | enterRule(); | ||
5403 | |||
5404 | try { | ||
5405 | // InternalSolverLanguageParser.g:2171:2: ( (this_ExponentialExpression_0= ruleExponentialExpression ( () ( (lv_op_2_0= ruleMultiplicativeBinaryOperator ) ) ( (lv_right_3_0= ruleExponentialExpression ) ) )* ) ) | ||
5406 | // InternalSolverLanguageParser.g:2172:2: (this_ExponentialExpression_0= ruleExponentialExpression ( () ( (lv_op_2_0= ruleMultiplicativeBinaryOperator ) ) ( (lv_right_3_0= ruleExponentialExpression ) ) )* ) | ||
5407 | { | ||
5408 | // InternalSolverLanguageParser.g:2172:2: (this_ExponentialExpression_0= ruleExponentialExpression ( () ( (lv_op_2_0= ruleMultiplicativeBinaryOperator ) ) ( (lv_right_3_0= ruleExponentialExpression ) ) )* ) | ||
5409 | // InternalSolverLanguageParser.g:2173:3: this_ExponentialExpression_0= ruleExponentialExpression ( () ( (lv_op_2_0= ruleMultiplicativeBinaryOperator ) ) ( (lv_right_3_0= ruleExponentialExpression ) ) )* | ||
5410 | { | ||
5411 | |||
5412 | newCompositeNode(grammarAccess.getMultiplicativeExpressionAccess().getExponentialExpressionParserRuleCall_0()); | ||
5413 | |||
5414 | pushFollow(FOLLOW_36); | ||
5415 | this_ExponentialExpression_0=ruleExponentialExpression(); | ||
5416 | |||
5417 | state._fsp--; | ||
5418 | |||
5419 | |||
5420 | current = this_ExponentialExpression_0; | ||
5421 | afterParserOrEnumRuleCall(); | ||
5422 | |||
5423 | // InternalSolverLanguageParser.g:2181:3: ( () ( (lv_op_2_0= ruleMultiplicativeBinaryOperator ) ) ( (lv_right_3_0= ruleExponentialExpression ) ) )* | ||
5424 | loop26: | ||
5425 | do { | ||
5426 | int alt26=2; | ||
5427 | int LA26_0 = input.LA(1); | ||
5428 | |||
5429 | if ( (LA26_0==Asterisk||LA26_0==Solidus) ) { | ||
5430 | alt26=1; | ||
5431 | } | ||
5432 | |||
5433 | |||
5434 | switch (alt26) { | ||
5435 | case 1 : | ||
5436 | // InternalSolverLanguageParser.g:2182:4: () ( (lv_op_2_0= ruleMultiplicativeBinaryOperator ) ) ( (lv_right_3_0= ruleExponentialExpression ) ) | ||
5437 | { | ||
5438 | // InternalSolverLanguageParser.g:2182:4: () | ||
5439 | // InternalSolverLanguageParser.g:2183:5: | ||
5440 | { | ||
5441 | |||
5442 | current = forceCreateModelElementAndSet( | ||
5443 | grammarAccess.getMultiplicativeExpressionAccess().getBinaryExpressionLeftAction_1_0(), | ||
5444 | current); | ||
5445 | |||
5446 | |||
5447 | } | ||
5448 | |||
5449 | // InternalSolverLanguageParser.g:2189:4: ( (lv_op_2_0= ruleMultiplicativeBinaryOperator ) ) | ||
5450 | // InternalSolverLanguageParser.g:2190:5: (lv_op_2_0= ruleMultiplicativeBinaryOperator ) | ||
5451 | { | ||
5452 | // InternalSolverLanguageParser.g:2190:5: (lv_op_2_0= ruleMultiplicativeBinaryOperator ) | ||
5453 | // InternalSolverLanguageParser.g:2191:6: lv_op_2_0= ruleMultiplicativeBinaryOperator | ||
5454 | { | ||
5455 | |||
5456 | newCompositeNode(grammarAccess.getMultiplicativeExpressionAccess().getOpMultiplicativeBinaryOperatorEnumRuleCall_1_1_0()); | ||
5457 | |||
5458 | pushFollow(FOLLOW_10); | ||
5459 | lv_op_2_0=ruleMultiplicativeBinaryOperator(); | ||
5460 | |||
5461 | state._fsp--; | ||
5462 | |||
5463 | |||
5464 | if (current==null) { | ||
5465 | current = createModelElementForParent(grammarAccess.getMultiplicativeExpressionRule()); | ||
5466 | } | ||
5467 | set( | ||
5468 | current, | ||
5469 | "op", | ||
5470 | lv_op_2_0, | ||
5471 | "org.eclipse.viatra.solver.language.SolverLanguage.MultiplicativeBinaryOperator"); | ||
5472 | afterParserOrEnumRuleCall(); | ||
5473 | |||
5474 | |||
5475 | } | ||
5476 | |||
5477 | |||
5478 | } | ||
5479 | |||
5480 | // InternalSolverLanguageParser.g:2208:4: ( (lv_right_3_0= ruleExponentialExpression ) ) | ||
5481 | // InternalSolverLanguageParser.g:2209:5: (lv_right_3_0= ruleExponentialExpression ) | ||
5482 | { | ||
5483 | // InternalSolverLanguageParser.g:2209:5: (lv_right_3_0= ruleExponentialExpression ) | ||
5484 | // InternalSolverLanguageParser.g:2210:6: lv_right_3_0= ruleExponentialExpression | ||
5485 | { | ||
5486 | |||
5487 | newCompositeNode(grammarAccess.getMultiplicativeExpressionAccess().getRightExponentialExpressionParserRuleCall_1_2_0()); | ||
5488 | |||
5489 | pushFollow(FOLLOW_36); | ||
5490 | lv_right_3_0=ruleExponentialExpression(); | ||
5491 | |||
5492 | state._fsp--; | ||
5493 | |||
5494 | |||
5495 | if (current==null) { | ||
5496 | current = createModelElementForParent(grammarAccess.getMultiplicativeExpressionRule()); | ||
5497 | } | ||
5498 | set( | ||
5499 | current, | ||
5500 | "right", | ||
5501 | lv_right_3_0, | ||
5502 | "org.eclipse.viatra.solver.language.SolverLanguage.ExponentialExpression"); | ||
5503 | afterParserOrEnumRuleCall(); | ||
5504 | |||
5505 | |||
5506 | } | ||
5507 | |||
5508 | |||
5509 | } | ||
5510 | |||
5511 | |||
5512 | } | ||
5513 | break; | ||
5514 | |||
5515 | default : | ||
5516 | break loop26; | ||
5517 | } | ||
5518 | } while (true); | ||
5519 | |||
5520 | |||
5521 | } | ||
5522 | |||
5523 | |||
5524 | } | ||
5525 | |||
5526 | |||
5527 | leaveRule(); | ||
5528 | |||
5529 | } | ||
5530 | |||
5531 | catch (RecognitionException re) { | ||
5532 | recover(input,re); | ||
5533 | appendSkippedTokens(); | ||
5534 | } | ||
5535 | finally { | ||
5536 | } | ||
5537 | return current; | ||
5538 | } | ||
5539 | // $ANTLR end "ruleMultiplicativeExpression" | ||
5540 | |||
5541 | |||
5542 | // $ANTLR start "entryRuleExponentialExpression" | ||
5543 | // InternalSolverLanguageParser.g:2232:1: entryRuleExponentialExpression returns [EObject current=null] : iv_ruleExponentialExpression= ruleExponentialExpression EOF ; | ||
5544 | public final EObject entryRuleExponentialExpression() throws RecognitionException { | ||
5545 | EObject current = null; | ||
5546 | |||
5547 | EObject iv_ruleExponentialExpression = null; | ||
5548 | |||
5549 | |||
5550 | try { | ||
5551 | // InternalSolverLanguageParser.g:2232:62: (iv_ruleExponentialExpression= ruleExponentialExpression EOF ) | ||
5552 | // InternalSolverLanguageParser.g:2233:2: iv_ruleExponentialExpression= ruleExponentialExpression EOF | ||
5553 | { | ||
5554 | newCompositeNode(grammarAccess.getExponentialExpressionRule()); | ||
5555 | pushFollow(FOLLOW_1); | ||
5556 | iv_ruleExponentialExpression=ruleExponentialExpression(); | ||
5557 | |||
5558 | state._fsp--; | ||
5559 | |||
5560 | current =iv_ruleExponentialExpression; | ||
5561 | match(input,EOF,FOLLOW_2); | ||
5562 | |||
5563 | } | ||
5564 | |||
5565 | } | ||
5566 | |||
5567 | catch (RecognitionException re) { | ||
5568 | recover(input,re); | ||
5569 | appendSkippedTokens(); | ||
5570 | } | ||
5571 | finally { | ||
5572 | } | ||
5573 | return current; | ||
5574 | } | ||
5575 | // $ANTLR end "entryRuleExponentialExpression" | ||
5576 | |||
5577 | |||
5578 | // $ANTLR start "ruleExponentialExpression" | ||
5579 | // InternalSolverLanguageParser.g:2239:1: ruleExponentialExpression returns [EObject current=null] : (this_CastExpression_0= ruleCastExpression ( () ( (lv_op_2_0= ruleExponentialOp ) ) ( (lv_right_3_0= ruleCastExpression ) ) )? ) ; | ||
5580 | public final EObject ruleExponentialExpression() throws RecognitionException { | ||
5581 | EObject current = null; | ||
5582 | |||
5583 | EObject this_CastExpression_0 = null; | ||
5584 | |||
5585 | Enumerator lv_op_2_0 = null; | ||
5586 | |||
5587 | EObject lv_right_3_0 = null; | ||
5588 | |||
5589 | |||
5590 | |||
5591 | enterRule(); | ||
5592 | |||
5593 | try { | ||
5594 | // InternalSolverLanguageParser.g:2245:2: ( (this_CastExpression_0= ruleCastExpression ( () ( (lv_op_2_0= ruleExponentialOp ) ) ( (lv_right_3_0= ruleCastExpression ) ) )? ) ) | ||
5595 | // InternalSolverLanguageParser.g:2246:2: (this_CastExpression_0= ruleCastExpression ( () ( (lv_op_2_0= ruleExponentialOp ) ) ( (lv_right_3_0= ruleCastExpression ) ) )? ) | ||
5596 | { | ||
5597 | // InternalSolverLanguageParser.g:2246:2: (this_CastExpression_0= ruleCastExpression ( () ( (lv_op_2_0= ruleExponentialOp ) ) ( (lv_right_3_0= ruleCastExpression ) ) )? ) | ||
5598 | // InternalSolverLanguageParser.g:2247:3: this_CastExpression_0= ruleCastExpression ( () ( (lv_op_2_0= ruleExponentialOp ) ) ( (lv_right_3_0= ruleCastExpression ) ) )? | ||
5599 | { | ||
5600 | |||
5601 | newCompositeNode(grammarAccess.getExponentialExpressionAccess().getCastExpressionParserRuleCall_0()); | ||
5602 | |||
5603 | pushFollow(FOLLOW_37); | ||
5604 | this_CastExpression_0=ruleCastExpression(); | ||
5605 | |||
5606 | state._fsp--; | ||
5607 | |||
5608 | |||
5609 | current = this_CastExpression_0; | ||
5610 | afterParserOrEnumRuleCall(); | ||
5611 | |||
5612 | // InternalSolverLanguageParser.g:2255:3: ( () ( (lv_op_2_0= ruleExponentialOp ) ) ( (lv_right_3_0= ruleCastExpression ) ) )? | ||
5613 | int alt27=2; | ||
5614 | int LA27_0 = input.LA(1); | ||
5615 | |||
5616 | if ( (LA27_0==CircumflexAccent) ) { | ||
5617 | alt27=1; | ||
5618 | } | ||
5619 | switch (alt27) { | ||
5620 | case 1 : | ||
5621 | // InternalSolverLanguageParser.g:2256:4: () ( (lv_op_2_0= ruleExponentialOp ) ) ( (lv_right_3_0= ruleCastExpression ) ) | ||
5622 | { | ||
5623 | // InternalSolverLanguageParser.g:2256:4: () | ||
5624 | // InternalSolverLanguageParser.g:2257:5: | ||
5625 | { | ||
5626 | |||
5627 | current = forceCreateModelElementAndSet( | ||
5628 | grammarAccess.getExponentialExpressionAccess().getBinaryExpressionLeftAction_1_0(), | ||
5629 | current); | ||
5630 | |||
5631 | |||
5632 | } | ||
5633 | |||
5634 | // InternalSolverLanguageParser.g:2263:4: ( (lv_op_2_0= ruleExponentialOp ) ) | ||
5635 | // InternalSolverLanguageParser.g:2264:5: (lv_op_2_0= ruleExponentialOp ) | ||
5636 | { | ||
5637 | // InternalSolverLanguageParser.g:2264:5: (lv_op_2_0= ruleExponentialOp ) | ||
5638 | // InternalSolverLanguageParser.g:2265:6: lv_op_2_0= ruleExponentialOp | ||
5639 | { | ||
5640 | |||
5641 | newCompositeNode(grammarAccess.getExponentialExpressionAccess().getOpExponentialOpEnumRuleCall_1_1_0()); | ||
5642 | |||
5643 | pushFollow(FOLLOW_10); | ||
5644 | lv_op_2_0=ruleExponentialOp(); | ||
5645 | |||
5646 | state._fsp--; | ||
5647 | |||
5648 | |||
5649 | if (current==null) { | ||
5650 | current = createModelElementForParent(grammarAccess.getExponentialExpressionRule()); | ||
5651 | } | ||
5652 | set( | ||
5653 | current, | ||
5654 | "op", | ||
5655 | lv_op_2_0, | ||
5656 | "org.eclipse.viatra.solver.language.SolverLanguage.ExponentialOp"); | ||
5657 | afterParserOrEnumRuleCall(); | ||
5658 | |||
5659 | |||
5660 | } | ||
5661 | |||
5662 | |||
5663 | } | ||
5664 | |||
5665 | // InternalSolverLanguageParser.g:2282:4: ( (lv_right_3_0= ruleCastExpression ) ) | ||
5666 | // InternalSolverLanguageParser.g:2283:5: (lv_right_3_0= ruleCastExpression ) | ||
5667 | { | ||
5668 | // InternalSolverLanguageParser.g:2283:5: (lv_right_3_0= ruleCastExpression ) | ||
5669 | // InternalSolverLanguageParser.g:2284:6: lv_right_3_0= ruleCastExpression | ||
5670 | { | ||
5671 | |||
5672 | newCompositeNode(grammarAccess.getExponentialExpressionAccess().getRightCastExpressionParserRuleCall_1_2_0()); | ||
5673 | |||
5674 | pushFollow(FOLLOW_2); | ||
5675 | lv_right_3_0=ruleCastExpression(); | ||
5676 | |||
5677 | state._fsp--; | ||
5678 | |||
5679 | |||
5680 | if (current==null) { | ||
5681 | current = createModelElementForParent(grammarAccess.getExponentialExpressionRule()); | ||
5682 | } | ||
5683 | set( | ||
5684 | current, | ||
5685 | "right", | ||
5686 | lv_right_3_0, | ||
5687 | "org.eclipse.viatra.solver.language.SolverLanguage.CastExpression"); | ||
5688 | afterParserOrEnumRuleCall(); | ||
5689 | |||
5690 | |||
5691 | } | ||
5692 | |||
5693 | |||
5694 | } | ||
5695 | |||
5696 | |||
5697 | } | ||
5698 | break; | ||
5699 | |||
5700 | } | ||
5701 | |||
5702 | |||
5703 | } | ||
5704 | |||
5705 | |||
5706 | } | ||
5707 | |||
5708 | |||
5709 | leaveRule(); | ||
5710 | |||
5711 | } | ||
5712 | |||
5713 | catch (RecognitionException re) { | ||
5714 | recover(input,re); | ||
5715 | appendSkippedTokens(); | ||
5716 | } | ||
5717 | finally { | ||
5718 | } | ||
5719 | return current; | ||
5720 | } | ||
5721 | // $ANTLR end "ruleExponentialExpression" | ||
5722 | |||
5723 | |||
5724 | // $ANTLR start "entryRuleCastExpression" | ||
5725 | // InternalSolverLanguageParser.g:2306:1: entryRuleCastExpression returns [EObject current=null] : iv_ruleCastExpression= ruleCastExpression EOF ; | ||
5726 | public final EObject entryRuleCastExpression() throws RecognitionException { | ||
5727 | EObject current = null; | ||
5728 | |||
5729 | EObject iv_ruleCastExpression = null; | ||
5730 | |||
5731 | |||
5732 | try { | ||
5733 | // InternalSolverLanguageParser.g:2306:55: (iv_ruleCastExpression= ruleCastExpression EOF ) | ||
5734 | // InternalSolverLanguageParser.g:2307:2: iv_ruleCastExpression= ruleCastExpression EOF | ||
5735 | { | ||
5736 | newCompositeNode(grammarAccess.getCastExpressionRule()); | ||
5737 | pushFollow(FOLLOW_1); | ||
5738 | iv_ruleCastExpression=ruleCastExpression(); | ||
5739 | |||
5740 | state._fsp--; | ||
5741 | |||
5742 | current =iv_ruleCastExpression; | ||
5743 | match(input,EOF,FOLLOW_2); | ||
5744 | |||
5745 | } | ||
5746 | |||
5747 | } | ||
5748 | |||
5749 | catch (RecognitionException re) { | ||
5750 | recover(input,re); | ||
5751 | appendSkippedTokens(); | ||
5752 | } | ||
5753 | finally { | ||
5754 | } | ||
5755 | return current; | ||
5756 | } | ||
5757 | // $ANTLR end "entryRuleCastExpression" | ||
5758 | |||
5759 | |||
5760 | // $ANTLR start "ruleCastExpression" | ||
5761 | // InternalSolverLanguageParser.g:2313:1: ruleCastExpression returns [EObject current=null] : (this_UnaryExpression_0= ruleUnaryExpression ( () otherlv_2= As ( ( ruleQualifiedName ) ) )? ) ; | ||
5762 | public final EObject ruleCastExpression() throws RecognitionException { | ||
5763 | EObject current = null; | ||
5764 | |||
5765 | Token otherlv_2=null; | ||
5766 | EObject this_UnaryExpression_0 = null; | ||
5767 | |||
5768 | |||
5769 | |||
5770 | enterRule(); | ||
5771 | |||
5772 | try { | ||
5773 | // InternalSolverLanguageParser.g:2319:2: ( (this_UnaryExpression_0= ruleUnaryExpression ( () otherlv_2= As ( ( ruleQualifiedName ) ) )? ) ) | ||
5774 | // InternalSolverLanguageParser.g:2320:2: (this_UnaryExpression_0= ruleUnaryExpression ( () otherlv_2= As ( ( ruleQualifiedName ) ) )? ) | ||
5775 | { | ||
5776 | // InternalSolverLanguageParser.g:2320:2: (this_UnaryExpression_0= ruleUnaryExpression ( () otherlv_2= As ( ( ruleQualifiedName ) ) )? ) | ||
5777 | // InternalSolverLanguageParser.g:2321:3: this_UnaryExpression_0= ruleUnaryExpression ( () otherlv_2= As ( ( ruleQualifiedName ) ) )? | ||
5778 | { | ||
5779 | |||
5780 | newCompositeNode(grammarAccess.getCastExpressionAccess().getUnaryExpressionParserRuleCall_0()); | ||
5781 | |||
5782 | pushFollow(FOLLOW_38); | ||
5783 | this_UnaryExpression_0=ruleUnaryExpression(); | ||
5784 | |||
5785 | state._fsp--; | ||
5786 | |||
5787 | |||
5788 | current = this_UnaryExpression_0; | ||
5789 | afterParserOrEnumRuleCall(); | ||
5790 | |||
5791 | // InternalSolverLanguageParser.g:2329:3: ( () otherlv_2= As ( ( ruleQualifiedName ) ) )? | ||
5792 | int alt28=2; | ||
5793 | int LA28_0 = input.LA(1); | ||
5794 | |||
5795 | if ( (LA28_0==As) ) { | ||
5796 | alt28=1; | ||
5797 | } | ||
5798 | switch (alt28) { | ||
5799 | case 1 : | ||
5800 | // InternalSolverLanguageParser.g:2330:4: () otherlv_2= As ( ( ruleQualifiedName ) ) | ||
5801 | { | ||
5802 | // InternalSolverLanguageParser.g:2330:4: () | ||
5803 | // InternalSolverLanguageParser.g:2331:5: | ||
5804 | { | ||
5805 | |||
5806 | current = forceCreateModelElementAndSet( | ||
5807 | grammarAccess.getCastExpressionAccess().getCastExpressionBodyAction_1_0(), | ||
5808 | current); | ||
5809 | |||
5810 | |||
5811 | } | ||
5812 | |||
5813 | otherlv_2=(Token)match(input,As,FOLLOW_3); | ||
5814 | |||
5815 | newLeafNode(otherlv_2, grammarAccess.getCastExpressionAccess().getAsKeyword_1_1()); | ||
5816 | |||
5817 | // InternalSolverLanguageParser.g:2341:4: ( ( ruleQualifiedName ) ) | ||
5818 | // InternalSolverLanguageParser.g:2342:5: ( ruleQualifiedName ) | ||
5819 | { | ||
5820 | // InternalSolverLanguageParser.g:2342:5: ( ruleQualifiedName ) | ||
5821 | // InternalSolverLanguageParser.g:2343:6: ruleQualifiedName | ||
5822 | { | ||
5823 | |||
5824 | if (current==null) { | ||
5825 | current = createModelElement(grammarAccess.getCastExpressionRule()); | ||
5826 | } | ||
5827 | |||
5828 | |||
5829 | newCompositeNode(grammarAccess.getCastExpressionAccess().getTargetTypeSymbolCrossReference_1_2_0()); | ||
5830 | |||
5831 | pushFollow(FOLLOW_2); | ||
5832 | ruleQualifiedName(); | ||
5833 | |||
5834 | state._fsp--; | ||
5835 | |||
5836 | |||
5837 | afterParserOrEnumRuleCall(); | ||
5838 | |||
5839 | |||
5840 | } | ||
5841 | |||
5842 | |||
5843 | } | ||
5844 | |||
5845 | |||
5846 | } | ||
5847 | break; | ||
5848 | |||
5849 | } | ||
5850 | |||
5851 | |||
5852 | } | ||
5853 | |||
5854 | |||
5855 | } | ||
5856 | |||
5857 | |||
5858 | leaveRule(); | ||
5859 | |||
5860 | } | ||
5861 | |||
5862 | catch (RecognitionException re) { | ||
5863 | recover(input,re); | ||
5864 | appendSkippedTokens(); | ||
5865 | } | ||
5866 | finally { | ||
5867 | } | ||
5868 | return current; | ||
5869 | } | ||
5870 | // $ANTLR end "ruleCastExpression" | ||
5871 | |||
5872 | |||
5873 | // $ANTLR start "entryRuleUnaryExpression" | ||
5874 | // InternalSolverLanguageParser.g:2362:1: entryRuleUnaryExpression returns [EObject current=null] : iv_ruleUnaryExpression= ruleUnaryExpression EOF ; | ||
5875 | public final EObject entryRuleUnaryExpression() throws RecognitionException { | ||
5876 | EObject current = null; | ||
5877 | |||
5878 | EObject iv_ruleUnaryExpression = null; | ||
5879 | |||
5880 | |||
5881 | try { | ||
5882 | // InternalSolverLanguageParser.g:2362:56: (iv_ruleUnaryExpression= ruleUnaryExpression EOF ) | ||
5883 | // InternalSolverLanguageParser.g:2363:2: iv_ruleUnaryExpression= ruleUnaryExpression EOF | ||
5884 | { | ||
5885 | newCompositeNode(grammarAccess.getUnaryExpressionRule()); | ||
5886 | pushFollow(FOLLOW_1); | ||
5887 | iv_ruleUnaryExpression=ruleUnaryExpression(); | ||
5888 | |||
5889 | state._fsp--; | ||
5890 | |||
5891 | current =iv_ruleUnaryExpression; | ||
5892 | match(input,EOF,FOLLOW_2); | ||
5893 | |||
5894 | } | ||
5895 | |||
5896 | } | ||
5897 | |||
5898 | catch (RecognitionException re) { | ||
5899 | recover(input,re); | ||
5900 | appendSkippedTokens(); | ||
5901 | } | ||
5902 | finally { | ||
5903 | } | ||
5904 | return current; | ||
5905 | } | ||
5906 | // $ANTLR end "entryRuleUnaryExpression" | ||
5907 | |||
5908 | |||
5909 | // $ANTLR start "ruleUnaryExpression" | ||
5910 | // InternalSolverLanguageParser.g:2369:1: ruleUnaryExpression returns [EObject current=null] : (this_BracedAggregateExpression_0= ruleBracedAggregateExpression | ( () ( (lv_op_2_0= ruleUnaryOperator ) ) ( (lv_body_3_0= ruleBracedAggregateExpression ) ) ) ) ; | ||
5911 | public final EObject ruleUnaryExpression() throws RecognitionException { | ||
5912 | EObject current = null; | ||
5913 | |||
5914 | EObject this_BracedAggregateExpression_0 = null; | ||
5915 | |||
5916 | Enumerator lv_op_2_0 = null; | ||
5917 | |||
5918 | EObject lv_body_3_0 = null; | ||
5919 | |||
5920 | |||
5921 | |||
5922 | enterRule(); | ||
5923 | |||
5924 | try { | ||
5925 | // InternalSolverLanguageParser.g:2375:2: ( (this_BracedAggregateExpression_0= ruleBracedAggregateExpression | ( () ( (lv_op_2_0= ruleUnaryOperator ) ) ( (lv_body_3_0= ruleBracedAggregateExpression ) ) ) ) ) | ||
5926 | // InternalSolverLanguageParser.g:2376:2: (this_BracedAggregateExpression_0= ruleBracedAggregateExpression | ( () ( (lv_op_2_0= ruleUnaryOperator ) ) ( (lv_body_3_0= ruleBracedAggregateExpression ) ) ) ) | ||
5927 | { | ||
5928 | // InternalSolverLanguageParser.g:2376:2: (this_BracedAggregateExpression_0= ruleBracedAggregateExpression | ( () ( (lv_op_2_0= ruleUnaryOperator ) ) ( (lv_body_3_0= ruleBracedAggregateExpression ) ) ) ) | ||
5929 | int alt29=2; | ||
5930 | int LA29_0 = input.LA(1); | ||
5931 | |||
5932 | if ( (LA29_0==Unknown||LA29_0==Object||(LA29_0>=Count && LA29_0<=False)||LA29_0==True||LA29_0==Inf||LA29_0==LeftParenthesis||LA29_0==LeftSquareBracket||(LA29_0>=Tilde && LA29_0<=RULE_QUOTED_ID)||(LA29_0>=RULE_ID && LA29_0<=RULE_INT)) ) { | ||
5933 | alt29=1; | ||
5934 | } | ||
5935 | else if ( (LA29_0==ExclamationMark||LA29_0==PlusSign||LA29_0==HyphenMinus||LA29_0==QuestionMark) ) { | ||
5936 | alt29=2; | ||
5937 | } | ||
5938 | else { | ||
5939 | NoViableAltException nvae = | ||
5940 | new NoViableAltException("", 29, 0, input); | ||
5941 | |||
5942 | throw nvae; | ||
5943 | } | ||
5944 | switch (alt29) { | ||
5945 | case 1 : | ||
5946 | // InternalSolverLanguageParser.g:2377:3: this_BracedAggregateExpression_0= ruleBracedAggregateExpression | ||
5947 | { | ||
5948 | |||
5949 | newCompositeNode(grammarAccess.getUnaryExpressionAccess().getBracedAggregateExpressionParserRuleCall_0()); | ||
5950 | |||
5951 | pushFollow(FOLLOW_2); | ||
5952 | this_BracedAggregateExpression_0=ruleBracedAggregateExpression(); | ||
5953 | |||
5954 | state._fsp--; | ||
5955 | |||
5956 | |||
5957 | current = this_BracedAggregateExpression_0; | ||
5958 | afterParserOrEnumRuleCall(); | ||
5959 | |||
5960 | |||
5961 | } | ||
5962 | break; | ||
5963 | case 2 : | ||
5964 | // InternalSolverLanguageParser.g:2386:3: ( () ( (lv_op_2_0= ruleUnaryOperator ) ) ( (lv_body_3_0= ruleBracedAggregateExpression ) ) ) | ||
5965 | { | ||
5966 | // InternalSolverLanguageParser.g:2386:3: ( () ( (lv_op_2_0= ruleUnaryOperator ) ) ( (lv_body_3_0= ruleBracedAggregateExpression ) ) ) | ||
5967 | // InternalSolverLanguageParser.g:2387:4: () ( (lv_op_2_0= ruleUnaryOperator ) ) ( (lv_body_3_0= ruleBracedAggregateExpression ) ) | ||
5968 | { | ||
5969 | // InternalSolverLanguageParser.g:2387:4: () | ||
5970 | // InternalSolverLanguageParser.g:2388:5: | ||
5971 | { | ||
5972 | |||
5973 | current = forceCreateModelElement( | ||
5974 | grammarAccess.getUnaryExpressionAccess().getUnaryExpressionAction_1_0(), | ||
5975 | current); | ||
5976 | |||
5977 | |||
5978 | } | ||
5979 | |||
5980 | // InternalSolverLanguageParser.g:2394:4: ( (lv_op_2_0= ruleUnaryOperator ) ) | ||
5981 | // InternalSolverLanguageParser.g:2395:5: (lv_op_2_0= ruleUnaryOperator ) | ||
5982 | { | ||
5983 | // InternalSolverLanguageParser.g:2395:5: (lv_op_2_0= ruleUnaryOperator ) | ||
5984 | // InternalSolverLanguageParser.g:2396:6: lv_op_2_0= ruleUnaryOperator | ||
5985 | { | ||
5986 | |||
5987 | newCompositeNode(grammarAccess.getUnaryExpressionAccess().getOpUnaryOperatorEnumRuleCall_1_1_0()); | ||
5988 | |||
5989 | pushFollow(FOLLOW_39); | ||
5990 | lv_op_2_0=ruleUnaryOperator(); | ||
5991 | |||
5992 | state._fsp--; | ||
5993 | |||
5994 | |||
5995 | if (current==null) { | ||
5996 | current = createModelElementForParent(grammarAccess.getUnaryExpressionRule()); | ||
5997 | } | ||
5998 | set( | ||
5999 | current, | ||
6000 | "op", | ||
6001 | lv_op_2_0, | ||
6002 | "org.eclipse.viatra.solver.language.SolverLanguage.UnaryOperator"); | ||
6003 | afterParserOrEnumRuleCall(); | ||
6004 | |||
6005 | |||
6006 | } | ||
6007 | |||
6008 | |||
6009 | } | ||
6010 | |||
6011 | // InternalSolverLanguageParser.g:2413:4: ( (lv_body_3_0= ruleBracedAggregateExpression ) ) | ||
6012 | // InternalSolverLanguageParser.g:2414:5: (lv_body_3_0= ruleBracedAggregateExpression ) | ||
6013 | { | ||
6014 | // InternalSolverLanguageParser.g:2414:5: (lv_body_3_0= ruleBracedAggregateExpression ) | ||
6015 | // InternalSolverLanguageParser.g:2415:6: lv_body_3_0= ruleBracedAggregateExpression | ||
6016 | { | ||
6017 | |||
6018 | newCompositeNode(grammarAccess.getUnaryExpressionAccess().getBodyBracedAggregateExpressionParserRuleCall_1_2_0()); | ||
6019 | |||
6020 | pushFollow(FOLLOW_2); | ||
6021 | lv_body_3_0=ruleBracedAggregateExpression(); | ||
6022 | |||
6023 | state._fsp--; | ||
6024 | |||
6025 | |||
6026 | if (current==null) { | ||
6027 | current = createModelElementForParent(grammarAccess.getUnaryExpressionRule()); | ||
6028 | } | ||
6029 | set( | ||
6030 | current, | ||
6031 | "body", | ||
6032 | lv_body_3_0, | ||
6033 | "org.eclipse.viatra.solver.language.SolverLanguage.BracedAggregateExpression"); | ||
6034 | afterParserOrEnumRuleCall(); | ||
6035 | |||
6036 | |||
6037 | } | ||
6038 | |||
6039 | |||
6040 | } | ||
6041 | |||
6042 | |||
6043 | } | ||
6044 | |||
6045 | |||
6046 | } | ||
6047 | break; | ||
6048 | |||
6049 | } | ||
6050 | |||
6051 | |||
6052 | } | ||
6053 | |||
6054 | |||
6055 | leaveRule(); | ||
6056 | |||
6057 | } | ||
6058 | |||
6059 | catch (RecognitionException re) { | ||
6060 | recover(input,re); | ||
6061 | appendSkippedTokens(); | ||
6062 | } | ||
6063 | finally { | ||
6064 | } | ||
6065 | return current; | ||
6066 | } | ||
6067 | // $ANTLR end "ruleUnaryExpression" | ||
6068 | |||
6069 | |||
6070 | // $ANTLR start "entryRuleBracedAggregateExpression" | ||
6071 | // InternalSolverLanguageParser.g:2437:1: entryRuleBracedAggregateExpression returns [EObject current=null] : iv_ruleBracedAggregateExpression= ruleBracedAggregateExpression EOF ; | ||
6072 | public final EObject entryRuleBracedAggregateExpression() throws RecognitionException { | ||
6073 | EObject current = null; | ||
6074 | |||
6075 | EObject iv_ruleBracedAggregateExpression = null; | ||
6076 | |||
6077 | |||
6078 | try { | ||
6079 | // InternalSolverLanguageParser.g:2437:66: (iv_ruleBracedAggregateExpression= ruleBracedAggregateExpression EOF ) | ||
6080 | // InternalSolverLanguageParser.g:2438:2: iv_ruleBracedAggregateExpression= ruleBracedAggregateExpression EOF | ||
6081 | { | ||
6082 | newCompositeNode(grammarAccess.getBracedAggregateExpressionRule()); | ||
6083 | pushFollow(FOLLOW_1); | ||
6084 | iv_ruleBracedAggregateExpression=ruleBracedAggregateExpression(); | ||
6085 | |||
6086 | state._fsp--; | ||
6087 | |||
6088 | current =iv_ruleBracedAggregateExpression; | ||
6089 | match(input,EOF,FOLLOW_2); | ||
6090 | |||
6091 | } | ||
6092 | |||
6093 | } | ||
6094 | |||
6095 | catch (RecognitionException re) { | ||
6096 | recover(input,re); | ||
6097 | appendSkippedTokens(); | ||
6098 | } | ||
6099 | finally { | ||
6100 | } | ||
6101 | return current; | ||
6102 | } | ||
6103 | // $ANTLR end "entryRuleBracedAggregateExpression" | ||
6104 | |||
6105 | |||
6106 | // $ANTLR start "ruleBracedAggregateExpression" | ||
6107 | // InternalSolverLanguageParser.g:2444:1: ruleBracedAggregateExpression returns [EObject current=null] : (this_AtomicExpression_0= ruleAtomicExpression | this_Aggregation_1= ruleAggregation | this_Count_2= ruleCount ) ; | ||
6108 | public final EObject ruleBracedAggregateExpression() throws RecognitionException { | ||
6109 | EObject current = null; | ||
6110 | |||
6111 | EObject this_AtomicExpression_0 = null; | ||
6112 | |||
6113 | EObject this_Aggregation_1 = null; | ||
6114 | |||
6115 | EObject this_Count_2 = null; | ||
6116 | |||
6117 | |||
6118 | |||
6119 | enterRule(); | ||
6120 | |||
6121 | try { | ||
6122 | // InternalSolverLanguageParser.g:2450:2: ( (this_AtomicExpression_0= ruleAtomicExpression | this_Aggregation_1= ruleAggregation | this_Count_2= ruleCount ) ) | ||
6123 | // InternalSolverLanguageParser.g:2451:2: (this_AtomicExpression_0= ruleAtomicExpression | this_Aggregation_1= ruleAggregation | this_Count_2= ruleCount ) | ||
6124 | { | ||
6125 | // InternalSolverLanguageParser.g:2451:2: (this_AtomicExpression_0= ruleAtomicExpression | this_Aggregation_1= ruleAggregation | this_Count_2= ruleCount ) | ||
6126 | int alt30=3; | ||
6127 | alt30 = dfa30.predict(input); | ||
6128 | switch (alt30) { | ||
6129 | case 1 : | ||
6130 | // InternalSolverLanguageParser.g:2452:3: this_AtomicExpression_0= ruleAtomicExpression | ||
6131 | { | ||
6132 | |||
6133 | newCompositeNode(grammarAccess.getBracedAggregateExpressionAccess().getAtomicExpressionParserRuleCall_0()); | ||
6134 | |||
6135 | pushFollow(FOLLOW_2); | ||
6136 | this_AtomicExpression_0=ruleAtomicExpression(); | ||
6137 | |||
6138 | state._fsp--; | ||
6139 | |||
6140 | |||
6141 | current = this_AtomicExpression_0; | ||
6142 | afterParserOrEnumRuleCall(); | ||
6143 | |||
6144 | |||
6145 | } | ||
6146 | break; | ||
6147 | case 2 : | ||
6148 | // InternalSolverLanguageParser.g:2461:3: this_Aggregation_1= ruleAggregation | ||
6149 | { | ||
6150 | |||
6151 | newCompositeNode(grammarAccess.getBracedAggregateExpressionAccess().getAggregationParserRuleCall_1()); | ||
6152 | |||
6153 | pushFollow(FOLLOW_2); | ||
6154 | this_Aggregation_1=ruleAggregation(); | ||
6155 | |||
6156 | state._fsp--; | ||
6157 | |||
6158 | |||
6159 | current = this_Aggregation_1; | ||
6160 | afterParserOrEnumRuleCall(); | ||
6161 | |||
6162 | |||
6163 | } | ||
6164 | break; | ||
6165 | case 3 : | ||
6166 | // InternalSolverLanguageParser.g:2470:3: this_Count_2= ruleCount | ||
6167 | { | ||
6168 | |||
6169 | newCompositeNode(grammarAccess.getBracedAggregateExpressionAccess().getCountParserRuleCall_2()); | ||
6170 | |||
6171 | pushFollow(FOLLOW_2); | ||
6172 | this_Count_2=ruleCount(); | ||
6173 | |||
6174 | state._fsp--; | ||
6175 | |||
6176 | |||
6177 | current = this_Count_2; | ||
6178 | afterParserOrEnumRuleCall(); | ||
6179 | |||
6180 | |||
6181 | } | ||
6182 | break; | ||
6183 | |||
6184 | } | ||
6185 | |||
6186 | |||
6187 | } | ||
6188 | |||
6189 | |||
6190 | leaveRule(); | ||
6191 | |||
6192 | } | ||
6193 | |||
6194 | catch (RecognitionException re) { | ||
6195 | recover(input,re); | ||
6196 | appendSkippedTokens(); | ||
6197 | } | ||
6198 | finally { | ||
6199 | } | ||
6200 | return current; | ||
6201 | } | ||
6202 | // $ANTLR end "ruleBracedAggregateExpression" | ||
6203 | |||
6204 | |||
6205 | // $ANTLR start "entryRuleAggregation" | ||
6206 | // InternalSolverLanguageParser.g:2482:1: entryRuleAggregation returns [EObject current=null] : iv_ruleAggregation= ruleAggregation EOF ; | ||
6207 | public final EObject entryRuleAggregation() throws RecognitionException { | ||
6208 | EObject current = null; | ||
6209 | |||
6210 | EObject iv_ruleAggregation = null; | ||
6211 | |||
6212 | |||
6213 | try { | ||
6214 | // InternalSolverLanguageParser.g:2482:52: (iv_ruleAggregation= ruleAggregation EOF ) | ||
6215 | // InternalSolverLanguageParser.g:2483:2: iv_ruleAggregation= ruleAggregation EOF | ||
6216 | { | ||
6217 | newCompositeNode(grammarAccess.getAggregationRule()); | ||
6218 | pushFollow(FOLLOW_1); | ||
6219 | iv_ruleAggregation=ruleAggregation(); | ||
6220 | |||
6221 | state._fsp--; | ||
6222 | |||
6223 | current =iv_ruleAggregation; | ||
6224 | match(input,EOF,FOLLOW_2); | ||
6225 | |||
6226 | } | ||
6227 | |||
6228 | } | ||
6229 | |||
6230 | catch (RecognitionException re) { | ||
6231 | recover(input,re); | ||
6232 | appendSkippedTokens(); | ||
6233 | } | ||
6234 | finally { | ||
6235 | } | ||
6236 | return current; | ||
6237 | } | ||
6238 | // $ANTLR end "entryRuleAggregation" | ||
6239 | |||
6240 | |||
6241 | // $ANTLR start "ruleAggregation" | ||
6242 | // InternalSolverLanguageParser.g:2489:1: ruleAggregation returns [EObject current=null] : ( ( ( ruleQualifiedName ) ) otherlv_1= LeftCurlyBracket ( (lv_value_2_0= ruleExpression ) ) otherlv_3= VerticalLine ( (lv_condition_4_0= ruleExpression ) ) otherlv_5= RightCurlyBracket ) ; | ||
6243 | public final EObject ruleAggregation() throws RecognitionException { | ||
6244 | EObject current = null; | ||
6245 | |||
6246 | Token otherlv_1=null; | ||
6247 | Token otherlv_3=null; | ||
6248 | Token otherlv_5=null; | ||
6249 | EObject lv_value_2_0 = null; | ||
6250 | |||
6251 | EObject lv_condition_4_0 = null; | ||
6252 | |||
6253 | |||
6254 | |||
6255 | enterRule(); | ||
6256 | |||
6257 | try { | ||
6258 | // InternalSolverLanguageParser.g:2495:2: ( ( ( ( ruleQualifiedName ) ) otherlv_1= LeftCurlyBracket ( (lv_value_2_0= ruleExpression ) ) otherlv_3= VerticalLine ( (lv_condition_4_0= ruleExpression ) ) otherlv_5= RightCurlyBracket ) ) | ||
6259 | // InternalSolverLanguageParser.g:2496:2: ( ( ( ruleQualifiedName ) ) otherlv_1= LeftCurlyBracket ( (lv_value_2_0= ruleExpression ) ) otherlv_3= VerticalLine ( (lv_condition_4_0= ruleExpression ) ) otherlv_5= RightCurlyBracket ) | ||
6260 | { | ||
6261 | // InternalSolverLanguageParser.g:2496:2: ( ( ( ruleQualifiedName ) ) otherlv_1= LeftCurlyBracket ( (lv_value_2_0= ruleExpression ) ) otherlv_3= VerticalLine ( (lv_condition_4_0= ruleExpression ) ) otherlv_5= RightCurlyBracket ) | ||
6262 | // InternalSolverLanguageParser.g:2497:3: ( ( ruleQualifiedName ) ) otherlv_1= LeftCurlyBracket ( (lv_value_2_0= ruleExpression ) ) otherlv_3= VerticalLine ( (lv_condition_4_0= ruleExpression ) ) otherlv_5= RightCurlyBracket | ||
6263 | { | ||
6264 | // InternalSolverLanguageParser.g:2497:3: ( ( ruleQualifiedName ) ) | ||
6265 | // InternalSolverLanguageParser.g:2498:4: ( ruleQualifiedName ) | ||
6266 | { | ||
6267 | // InternalSolverLanguageParser.g:2498:4: ( ruleQualifiedName ) | ||
6268 | // InternalSolverLanguageParser.g:2499:5: ruleQualifiedName | ||
6269 | { | ||
6270 | |||
6271 | if (current==null) { | ||
6272 | current = createModelElement(grammarAccess.getAggregationRule()); | ||
6273 | } | ||
6274 | |||
6275 | |||
6276 | newCompositeNode(grammarAccess.getAggregationAccess().getOpSymbolCrossReference_0_0()); | ||
6277 | |||
6278 | pushFollow(FOLLOW_20); | ||
6279 | ruleQualifiedName(); | ||
6280 | |||
6281 | state._fsp--; | ||
6282 | |||
6283 | |||
6284 | afterParserOrEnumRuleCall(); | ||
6285 | |||
6286 | |||
6287 | } | ||
6288 | |||
6289 | |||
6290 | } | ||
6291 | |||
6292 | otherlv_1=(Token)match(input,LeftCurlyBracket,FOLLOW_10); | ||
6293 | |||
6294 | newLeafNode(otherlv_1, grammarAccess.getAggregationAccess().getLeftCurlyBracketKeyword_1()); | ||
6295 | |||
6296 | // InternalSolverLanguageParser.g:2517:3: ( (lv_value_2_0= ruleExpression ) ) | ||
6297 | // InternalSolverLanguageParser.g:2518:4: (lv_value_2_0= ruleExpression ) | ||
6298 | { | ||
6299 | // InternalSolverLanguageParser.g:2518:4: (lv_value_2_0= ruleExpression ) | ||
6300 | // InternalSolverLanguageParser.g:2519:5: lv_value_2_0= ruleExpression | ||
6301 | { | ||
6302 | |||
6303 | newCompositeNode(grammarAccess.getAggregationAccess().getValueExpressionParserRuleCall_2_0()); | ||
6304 | |||
6305 | pushFollow(FOLLOW_40); | ||
6306 | lv_value_2_0=ruleExpression(); | ||
6307 | |||
6308 | state._fsp--; | ||
6309 | |||
6310 | |||
6311 | if (current==null) { | ||
6312 | current = createModelElementForParent(grammarAccess.getAggregationRule()); | ||
6313 | } | ||
6314 | set( | ||
6315 | current, | ||
6316 | "value", | ||
6317 | lv_value_2_0, | ||
6318 | "org.eclipse.viatra.solver.language.SolverLanguage.Expression"); | ||
6319 | afterParserOrEnumRuleCall(); | ||
6320 | |||
6321 | |||
6322 | } | ||
6323 | |||
6324 | |||
6325 | } | ||
6326 | |||
6327 | otherlv_3=(Token)match(input,VerticalLine,FOLLOW_10); | ||
6328 | |||
6329 | newLeafNode(otherlv_3, grammarAccess.getAggregationAccess().getVerticalLineKeyword_3()); | ||
6330 | |||
6331 | // InternalSolverLanguageParser.g:2540:3: ( (lv_condition_4_0= ruleExpression ) ) | ||
6332 | // InternalSolverLanguageParser.g:2541:4: (lv_condition_4_0= ruleExpression ) | ||
6333 | { | ||
6334 | // InternalSolverLanguageParser.g:2541:4: (lv_condition_4_0= ruleExpression ) | ||
6335 | // InternalSolverLanguageParser.g:2542:5: lv_condition_4_0= ruleExpression | ||
6336 | { | ||
6337 | |||
6338 | newCompositeNode(grammarAccess.getAggregationAccess().getConditionExpressionParserRuleCall_4_0()); | ||
6339 | |||
6340 | pushFollow(FOLLOW_22); | ||
6341 | lv_condition_4_0=ruleExpression(); | ||
6342 | |||
6343 | state._fsp--; | ||
6344 | |||
6345 | |||
6346 | if (current==null) { | ||
6347 | current = createModelElementForParent(grammarAccess.getAggregationRule()); | ||
6348 | } | ||
6349 | set( | ||
6350 | current, | ||
6351 | "condition", | ||
6352 | lv_condition_4_0, | ||
6353 | "org.eclipse.viatra.solver.language.SolverLanguage.Expression"); | ||
6354 | afterParserOrEnumRuleCall(); | ||
6355 | |||
6356 | |||
6357 | } | ||
6358 | |||
6359 | |||
6360 | } | ||
6361 | |||
6362 | otherlv_5=(Token)match(input,RightCurlyBracket,FOLLOW_2); | ||
6363 | |||
6364 | newLeafNode(otherlv_5, grammarAccess.getAggregationAccess().getRightCurlyBracketKeyword_5()); | ||
6365 | |||
6366 | |||
6367 | } | ||
6368 | |||
6369 | |||
6370 | } | ||
6371 | |||
6372 | |||
6373 | leaveRule(); | ||
6374 | |||
6375 | } | ||
6376 | |||
6377 | catch (RecognitionException re) { | ||
6378 | recover(input,re); | ||
6379 | appendSkippedTokens(); | ||
6380 | } | ||
6381 | finally { | ||
6382 | } | ||
6383 | return current; | ||
6384 | } | ||
6385 | // $ANTLR end "ruleAggregation" | ||
6386 | |||
6387 | |||
6388 | // $ANTLR start "entryRuleCount" | ||
6389 | // InternalSolverLanguageParser.g:2567:1: entryRuleCount returns [EObject current=null] : iv_ruleCount= ruleCount EOF ; | ||
6390 | public final EObject entryRuleCount() throws RecognitionException { | ||
6391 | EObject current = null; | ||
6392 | |||
6393 | EObject iv_ruleCount = null; | ||
6394 | |||
6395 | |||
6396 | try { | ||
6397 | // InternalSolverLanguageParser.g:2567:46: (iv_ruleCount= ruleCount EOF ) | ||
6398 | // InternalSolverLanguageParser.g:2568:2: iv_ruleCount= ruleCount EOF | ||
6399 | { | ||
6400 | newCompositeNode(grammarAccess.getCountRule()); | ||
6401 | pushFollow(FOLLOW_1); | ||
6402 | iv_ruleCount=ruleCount(); | ||
6403 | |||
6404 | state._fsp--; | ||
6405 | |||
6406 | current =iv_ruleCount; | ||
6407 | match(input,EOF,FOLLOW_2); | ||
6408 | |||
6409 | } | ||
6410 | |||
6411 | } | ||
6412 | |||
6413 | catch (RecognitionException re) { | ||
6414 | recover(input,re); | ||
6415 | appendSkippedTokens(); | ||
6416 | } | ||
6417 | finally { | ||
6418 | } | ||
6419 | return current; | ||
6420 | } | ||
6421 | // $ANTLR end "entryRuleCount" | ||
6422 | |||
6423 | |||
6424 | // $ANTLR start "ruleCount" | ||
6425 | // InternalSolverLanguageParser.g:2574:1: ruleCount returns [EObject current=null] : (otherlv_0= Count otherlv_1= LeftCurlyBracket ( (lv_condition_2_0= ruleExpression ) ) otherlv_3= RightCurlyBracket ) ; | ||
6426 | public final EObject ruleCount() throws RecognitionException { | ||
6427 | EObject current = null; | ||
6428 | |||
6429 | Token otherlv_0=null; | ||
6430 | Token otherlv_1=null; | ||
6431 | Token otherlv_3=null; | ||
6432 | EObject lv_condition_2_0 = null; | ||
6433 | |||
6434 | |||
6435 | |||
6436 | enterRule(); | ||
6437 | |||
6438 | try { | ||
6439 | // InternalSolverLanguageParser.g:2580:2: ( (otherlv_0= Count otherlv_1= LeftCurlyBracket ( (lv_condition_2_0= ruleExpression ) ) otherlv_3= RightCurlyBracket ) ) | ||
6440 | // InternalSolverLanguageParser.g:2581:2: (otherlv_0= Count otherlv_1= LeftCurlyBracket ( (lv_condition_2_0= ruleExpression ) ) otherlv_3= RightCurlyBracket ) | ||
6441 | { | ||
6442 | // InternalSolverLanguageParser.g:2581:2: (otherlv_0= Count otherlv_1= LeftCurlyBracket ( (lv_condition_2_0= ruleExpression ) ) otherlv_3= RightCurlyBracket ) | ||
6443 | // InternalSolverLanguageParser.g:2582:3: otherlv_0= Count otherlv_1= LeftCurlyBracket ( (lv_condition_2_0= ruleExpression ) ) otherlv_3= RightCurlyBracket | ||
6444 | { | ||
6445 | otherlv_0=(Token)match(input,Count,FOLLOW_20); | ||
6446 | |||
6447 | newLeafNode(otherlv_0, grammarAccess.getCountAccess().getCountKeyword_0()); | ||
6448 | |||
6449 | otherlv_1=(Token)match(input,LeftCurlyBracket,FOLLOW_10); | ||
6450 | |||
6451 | newLeafNode(otherlv_1, grammarAccess.getCountAccess().getLeftCurlyBracketKeyword_1()); | ||
6452 | |||
6453 | // InternalSolverLanguageParser.g:2590:3: ( (lv_condition_2_0= ruleExpression ) ) | ||
6454 | // InternalSolverLanguageParser.g:2591:4: (lv_condition_2_0= ruleExpression ) | ||
6455 | { | ||
6456 | // InternalSolverLanguageParser.g:2591:4: (lv_condition_2_0= ruleExpression ) | ||
6457 | // InternalSolverLanguageParser.g:2592:5: lv_condition_2_0= ruleExpression | ||
6458 | { | ||
6459 | |||
6460 | newCompositeNode(grammarAccess.getCountAccess().getConditionExpressionParserRuleCall_2_0()); | ||
6461 | |||
6462 | pushFollow(FOLLOW_22); | ||
6463 | lv_condition_2_0=ruleExpression(); | ||
6464 | |||
6465 | state._fsp--; | ||
6466 | |||
6467 | |||
6468 | if (current==null) { | ||
6469 | current = createModelElementForParent(grammarAccess.getCountRule()); | ||
6470 | } | ||
6471 | set( | ||
6472 | current, | ||
6473 | "condition", | ||
6474 | lv_condition_2_0, | ||
6475 | "org.eclipse.viatra.solver.language.SolverLanguage.Expression"); | ||
6476 | afterParserOrEnumRuleCall(); | ||
6477 | |||
6478 | |||
6479 | } | ||
6480 | |||
6481 | |||
6482 | } | ||
6483 | |||
6484 | otherlv_3=(Token)match(input,RightCurlyBracket,FOLLOW_2); | ||
6485 | |||
6486 | newLeafNode(otherlv_3, grammarAccess.getCountAccess().getRightCurlyBracketKeyword_3()); | ||
6487 | |||
6488 | |||
6489 | } | ||
6490 | |||
6491 | |||
6492 | } | ||
6493 | |||
6494 | |||
6495 | leaveRule(); | ||
6496 | |||
6497 | } | ||
6498 | |||
6499 | catch (RecognitionException re) { | ||
6500 | recover(input,re); | ||
6501 | appendSkippedTokens(); | ||
6502 | } | ||
6503 | finally { | ||
6504 | } | ||
6505 | return current; | ||
6506 | } | ||
6507 | // $ANTLR end "ruleCount" | ||
6508 | |||
6509 | |||
6510 | // $ANTLR start "entryRuleAtomicExpression" | ||
6511 | // InternalSolverLanguageParser.g:2617:1: entryRuleAtomicExpression returns [EObject current=null] : iv_ruleAtomicExpression= ruleAtomicExpression EOF ; | ||
6512 | public final EObject entryRuleAtomicExpression() throws RecognitionException { | ||
6513 | EObject current = null; | ||
6514 | |||
6515 | EObject iv_ruleAtomicExpression = null; | ||
6516 | |||
6517 | |||
6518 | try { | ||
6519 | // InternalSolverLanguageParser.g:2617:57: (iv_ruleAtomicExpression= ruleAtomicExpression EOF ) | ||
6520 | // InternalSolverLanguageParser.g:2618:2: iv_ruleAtomicExpression= ruleAtomicExpression EOF | ||
6521 | { | ||
6522 | newCompositeNode(grammarAccess.getAtomicExpressionRule()); | ||
6523 | pushFollow(FOLLOW_1); | ||
6524 | iv_ruleAtomicExpression=ruleAtomicExpression(); | ||
6525 | |||
6526 | state._fsp--; | ||
6527 | |||
6528 | current =iv_ruleAtomicExpression; | ||
6529 | match(input,EOF,FOLLOW_2); | ||
6530 | |||
6531 | } | ||
6532 | |||
6533 | } | ||
6534 | |||
6535 | catch (RecognitionException re) { | ||
6536 | recover(input,re); | ||
6537 | appendSkippedTokens(); | ||
6538 | } | ||
6539 | finally { | ||
6540 | } | ||
6541 | return current; | ||
6542 | } | ||
6543 | // $ANTLR end "entryRuleAtomicExpression" | ||
6544 | |||
6545 | |||
6546 | // $ANTLR start "ruleAtomicExpression" | ||
6547 | // InternalSolverLanguageParser.g:2624:1: ruleAtomicExpression returns [EObject current=null] : (this_Reference_0= ruleReference | this_Call_1= ruleCall | this_Interval_2= ruleInterval | this_Literal_3= ruleLiteral | (otherlv_4= LeftParenthesis this_Expression_5= ruleExpression otherlv_6= RightParenthesis ) ) ; | ||
6548 | public final EObject ruleAtomicExpression() throws RecognitionException { | ||
6549 | EObject current = null; | ||
6550 | |||
6551 | Token otherlv_4=null; | ||
6552 | Token otherlv_6=null; | ||
6553 | EObject this_Reference_0 = null; | ||
6554 | |||
6555 | EObject this_Call_1 = null; | ||
6556 | |||
6557 | EObject this_Interval_2 = null; | ||
6558 | |||
6559 | EObject this_Literal_3 = null; | ||
6560 | |||
6561 | EObject this_Expression_5 = null; | ||
6562 | |||
6563 | |||
6564 | |||
6565 | enterRule(); | ||
6566 | |||
6567 | try { | ||
6568 | // InternalSolverLanguageParser.g:2630:2: ( (this_Reference_0= ruleReference | this_Call_1= ruleCall | this_Interval_2= ruleInterval | this_Literal_3= ruleLiteral | (otherlv_4= LeftParenthesis this_Expression_5= ruleExpression otherlv_6= RightParenthesis ) ) ) | ||
6569 | // InternalSolverLanguageParser.g:2631:2: (this_Reference_0= ruleReference | this_Call_1= ruleCall | this_Interval_2= ruleInterval | this_Literal_3= ruleLiteral | (otherlv_4= LeftParenthesis this_Expression_5= ruleExpression otherlv_6= RightParenthesis ) ) | ||
6570 | { | ||
6571 | // InternalSolverLanguageParser.g:2631:2: (this_Reference_0= ruleReference | this_Call_1= ruleCall | this_Interval_2= ruleInterval | this_Literal_3= ruleLiteral | (otherlv_4= LeftParenthesis this_Expression_5= ruleExpression otherlv_6= RightParenthesis ) ) | ||
6572 | int alt31=5; | ||
6573 | alt31 = dfa31.predict(input); | ||
6574 | switch (alt31) { | ||
6575 | case 1 : | ||
6576 | // InternalSolverLanguageParser.g:2632:3: this_Reference_0= ruleReference | ||
6577 | { | ||
6578 | |||
6579 | newCompositeNode(grammarAccess.getAtomicExpressionAccess().getReferenceParserRuleCall_0()); | ||
6580 | |||
6581 | pushFollow(FOLLOW_2); | ||
6582 | this_Reference_0=ruleReference(); | ||
6583 | |||
6584 | state._fsp--; | ||
6585 | |||
6586 | |||
6587 | current = this_Reference_0; | ||
6588 | afterParserOrEnumRuleCall(); | ||
6589 | |||
6590 | |||
6591 | } | ||
6592 | break; | ||
6593 | case 2 : | ||
6594 | // InternalSolverLanguageParser.g:2641:3: this_Call_1= ruleCall | ||
6595 | { | ||
6596 | |||
6597 | newCompositeNode(grammarAccess.getAtomicExpressionAccess().getCallParserRuleCall_1()); | ||
6598 | |||
6599 | pushFollow(FOLLOW_2); | ||
6600 | this_Call_1=ruleCall(); | ||
6601 | |||
6602 | state._fsp--; | ||
6603 | |||
6604 | |||
6605 | current = this_Call_1; | ||
6606 | afterParserOrEnumRuleCall(); | ||
6607 | |||
6608 | |||
6609 | } | ||
6610 | break; | ||
6611 | case 3 : | ||
6612 | // InternalSolverLanguageParser.g:2650:3: this_Interval_2= ruleInterval | ||
6613 | { | ||
6614 | |||
6615 | newCompositeNode(grammarAccess.getAtomicExpressionAccess().getIntervalParserRuleCall_2()); | ||
6616 | |||
6617 | pushFollow(FOLLOW_2); | ||
6618 | this_Interval_2=ruleInterval(); | ||
6619 | |||
6620 | state._fsp--; | ||
6621 | |||
6622 | |||
6623 | current = this_Interval_2; | ||
6624 | afterParserOrEnumRuleCall(); | ||
6625 | |||
6626 | |||
6627 | } | ||
6628 | break; | ||
6629 | case 4 : | ||
6630 | // InternalSolverLanguageParser.g:2659:3: this_Literal_3= ruleLiteral | ||
6631 | { | ||
6632 | |||
6633 | newCompositeNode(grammarAccess.getAtomicExpressionAccess().getLiteralParserRuleCall_3()); | ||
6634 | |||
6635 | pushFollow(FOLLOW_2); | ||
6636 | this_Literal_3=ruleLiteral(); | ||
6637 | |||
6638 | state._fsp--; | ||
6639 | |||
6640 | |||
6641 | current = this_Literal_3; | ||
6642 | afterParserOrEnumRuleCall(); | ||
6643 | |||
6644 | |||
6645 | } | ||
6646 | break; | ||
6647 | case 5 : | ||
6648 | // InternalSolverLanguageParser.g:2668:3: (otherlv_4= LeftParenthesis this_Expression_5= ruleExpression otherlv_6= RightParenthesis ) | ||
6649 | { | ||
6650 | // InternalSolverLanguageParser.g:2668:3: (otherlv_4= LeftParenthesis this_Expression_5= ruleExpression otherlv_6= RightParenthesis ) | ||
6651 | // InternalSolverLanguageParser.g:2669:4: otherlv_4= LeftParenthesis this_Expression_5= ruleExpression otherlv_6= RightParenthesis | ||
6652 | { | ||
6653 | otherlv_4=(Token)match(input,LeftParenthesis,FOLLOW_10); | ||
6654 | |||
6655 | newLeafNode(otherlv_4, grammarAccess.getAtomicExpressionAccess().getLeftParenthesisKeyword_4_0()); | ||
6656 | |||
6657 | |||
6658 | newCompositeNode(grammarAccess.getAtomicExpressionAccess().getExpressionParserRuleCall_4_1()); | ||
6659 | |||
6660 | pushFollow(FOLLOW_41); | ||
6661 | this_Expression_5=ruleExpression(); | ||
6662 | |||
6663 | state._fsp--; | ||
6664 | |||
6665 | |||
6666 | current = this_Expression_5; | ||
6667 | afterParserOrEnumRuleCall(); | ||
6668 | |||
6669 | otherlv_6=(Token)match(input,RightParenthesis,FOLLOW_2); | ||
6670 | |||
6671 | newLeafNode(otherlv_6, grammarAccess.getAtomicExpressionAccess().getRightParenthesisKeyword_4_2()); | ||
6672 | |||
6673 | |||
6674 | } | ||
6675 | |||
6676 | |||
6677 | } | ||
6678 | break; | ||
6679 | |||
6680 | } | ||
6681 | |||
6682 | |||
6683 | } | ||
6684 | |||
6685 | |||
6686 | leaveRule(); | ||
6687 | |||
6688 | } | ||
6689 | |||
6690 | catch (RecognitionException re) { | ||
6691 | recover(input,re); | ||
6692 | appendSkippedTokens(); | ||
6693 | } | ||
6694 | finally { | ||
6695 | } | ||
6696 | return current; | ||
6697 | } | ||
6698 | // $ANTLR end "ruleAtomicExpression" | ||
6699 | |||
6700 | |||
6701 | // $ANTLR start "entryRuleCall" | ||
6702 | // InternalSolverLanguageParser.g:2690:1: entryRuleCall returns [EObject current=null] : iv_ruleCall= ruleCall EOF ; | ||
6703 | public final EObject entryRuleCall() throws RecognitionException { | ||
6704 | EObject current = null; | ||
6705 | |||
6706 | EObject iv_ruleCall = null; | ||
6707 | |||
6708 | |||
6709 | try { | ||
6710 | // InternalSolverLanguageParser.g:2690:45: (iv_ruleCall= ruleCall EOF ) | ||
6711 | // InternalSolverLanguageParser.g:2691:2: iv_ruleCall= ruleCall EOF | ||
6712 | { | ||
6713 | newCompositeNode(grammarAccess.getCallRule()); | ||
6714 | pushFollow(FOLLOW_1); | ||
6715 | iv_ruleCall=ruleCall(); | ||
6716 | |||
6717 | state._fsp--; | ||
6718 | |||
6719 | current =iv_ruleCall; | ||
6720 | match(input,EOF,FOLLOW_2); | ||
6721 | |||
6722 | } | ||
6723 | |||
6724 | } | ||
6725 | |||
6726 | catch (RecognitionException re) { | ||
6727 | recover(input,re); | ||
6728 | appendSkippedTokens(); | ||
6729 | } | ||
6730 | finally { | ||
6731 | } | ||
6732 | return current; | ||
6733 | } | ||
6734 | // $ANTLR end "entryRuleCall" | ||
6735 | |||
6736 | |||
6737 | // $ANTLR start "ruleCall" | ||
6738 | // InternalSolverLanguageParser.g:2697:1: ruleCall returns [EObject current=null] : ( ( (lv_functor_0_0= ruleReference ) ) ( (lv_argumentList_1_0= ruleArgumentList ) ) ) ; | ||
6739 | public final EObject ruleCall() throws RecognitionException { | ||
6740 | EObject current = null; | ||
6741 | |||
6742 | EObject lv_functor_0_0 = null; | ||
6743 | |||
6744 | EObject lv_argumentList_1_0 = null; | ||
6745 | |||
6746 | |||
6747 | |||
6748 | enterRule(); | ||
6749 | |||
6750 | try { | ||
6751 | // InternalSolverLanguageParser.g:2703:2: ( ( ( (lv_functor_0_0= ruleReference ) ) ( (lv_argumentList_1_0= ruleArgumentList ) ) ) ) | ||
6752 | // InternalSolverLanguageParser.g:2704:2: ( ( (lv_functor_0_0= ruleReference ) ) ( (lv_argumentList_1_0= ruleArgumentList ) ) ) | ||
6753 | { | ||
6754 | // InternalSolverLanguageParser.g:2704:2: ( ( (lv_functor_0_0= ruleReference ) ) ( (lv_argumentList_1_0= ruleArgumentList ) ) ) | ||
6755 | // InternalSolverLanguageParser.g:2705:3: ( (lv_functor_0_0= ruleReference ) ) ( (lv_argumentList_1_0= ruleArgumentList ) ) | ||
6756 | { | ||
6757 | // InternalSolverLanguageParser.g:2705:3: ( (lv_functor_0_0= ruleReference ) ) | ||
6758 | // InternalSolverLanguageParser.g:2706:4: (lv_functor_0_0= ruleReference ) | ||
6759 | { | ||
6760 | // InternalSolverLanguageParser.g:2706:4: (lv_functor_0_0= ruleReference ) | ||
6761 | // InternalSolverLanguageParser.g:2707:5: lv_functor_0_0= ruleReference | ||
6762 | { | ||
6763 | |||
6764 | newCompositeNode(grammarAccess.getCallAccess().getFunctorReferenceParserRuleCall_0_0()); | ||
6765 | |||
6766 | pushFollow(FOLLOW_15); | ||
6767 | lv_functor_0_0=ruleReference(); | ||
6768 | |||
6769 | state._fsp--; | ||
6770 | |||
6771 | |||
6772 | if (current==null) { | ||
6773 | current = createModelElementForParent(grammarAccess.getCallRule()); | ||
6774 | } | ||
6775 | set( | ||
6776 | current, | ||
6777 | "functor", | ||
6778 | lv_functor_0_0, | ||
6779 | "org.eclipse.viatra.solver.language.SolverLanguage.Reference"); | ||
6780 | afterParserOrEnumRuleCall(); | ||
6781 | |||
6782 | |||
6783 | } | ||
6784 | |||
6785 | |||
6786 | } | ||
6787 | |||
6788 | // InternalSolverLanguageParser.g:2724:3: ( (lv_argumentList_1_0= ruleArgumentList ) ) | ||
6789 | // InternalSolverLanguageParser.g:2725:4: (lv_argumentList_1_0= ruleArgumentList ) | ||
6790 | { | ||
6791 | // InternalSolverLanguageParser.g:2725:4: (lv_argumentList_1_0= ruleArgumentList ) | ||
6792 | // InternalSolverLanguageParser.g:2726:5: lv_argumentList_1_0= ruleArgumentList | ||
6793 | { | ||
6794 | |||
6795 | newCompositeNode(grammarAccess.getCallAccess().getArgumentListArgumentListParserRuleCall_1_0()); | ||
6796 | |||
6797 | pushFollow(FOLLOW_2); | ||
6798 | lv_argumentList_1_0=ruleArgumentList(); | ||
6799 | |||
6800 | state._fsp--; | ||
6801 | |||
6802 | |||
6803 | if (current==null) { | ||
6804 | current = createModelElementForParent(grammarAccess.getCallRule()); | ||
6805 | } | ||
6806 | set( | ||
6807 | current, | ||
6808 | "argumentList", | ||
6809 | lv_argumentList_1_0, | ||
6810 | "org.eclipse.viatra.solver.language.SolverLanguage.ArgumentList"); | ||
6811 | afterParserOrEnumRuleCall(); | ||
6812 | |||
6813 | |||
6814 | } | ||
6815 | |||
6816 | |||
6817 | } | ||
6818 | |||
6819 | |||
6820 | } | ||
6821 | |||
6822 | |||
6823 | } | ||
6824 | |||
6825 | |||
6826 | leaveRule(); | ||
6827 | |||
6828 | } | ||
6829 | |||
6830 | catch (RecognitionException re) { | ||
6831 | recover(input,re); | ||
6832 | appendSkippedTokens(); | ||
6833 | } | ||
6834 | finally { | ||
6835 | } | ||
6836 | return current; | ||
6837 | } | ||
6838 | // $ANTLR end "ruleCall" | ||
6839 | |||
6840 | |||
6841 | // $ANTLR start "entryRuleArgumentList" | ||
6842 | // InternalSolverLanguageParser.g:2747:1: entryRuleArgumentList returns [EObject current=null] : iv_ruleArgumentList= ruleArgumentList EOF ; | ||
6843 | public final EObject entryRuleArgumentList() throws RecognitionException { | ||
6844 | EObject current = null; | ||
6845 | |||
6846 | EObject iv_ruleArgumentList = null; | ||
6847 | |||
6848 | |||
6849 | try { | ||
6850 | // InternalSolverLanguageParser.g:2747:53: (iv_ruleArgumentList= ruleArgumentList EOF ) | ||
6851 | // InternalSolverLanguageParser.g:2748:2: iv_ruleArgumentList= ruleArgumentList EOF | ||
6852 | { | ||
6853 | newCompositeNode(grammarAccess.getArgumentListRule()); | ||
6854 | pushFollow(FOLLOW_1); | ||
6855 | iv_ruleArgumentList=ruleArgumentList(); | ||
6856 | |||
6857 | state._fsp--; | ||
6858 | |||
6859 | current =iv_ruleArgumentList; | ||
6860 | match(input,EOF,FOLLOW_2); | ||
6861 | |||
6862 | } | ||
6863 | |||
6864 | } | ||
6865 | |||
6866 | catch (RecognitionException re) { | ||
6867 | recover(input,re); | ||
6868 | appendSkippedTokens(); | ||
6869 | } | ||
6870 | finally { | ||
6871 | } | ||
6872 | return current; | ||
6873 | } | ||
6874 | // $ANTLR end "entryRuleArgumentList" | ||
6875 | |||
6876 | |||
6877 | // $ANTLR start "ruleArgumentList" | ||
6878 | // InternalSolverLanguageParser.g:2754:1: ruleArgumentList returns [EObject current=null] : ( () otherlv_1= LeftParenthesis ( ( (lv_arguments_2_0= ruleArgument ) ) (otherlv_3= Comma ( (lv_arguments_4_0= ruleArgument ) ) )* )? otherlv_5= RightParenthesis ) ; | ||
6879 | public final EObject ruleArgumentList() throws RecognitionException { | ||
6880 | EObject current = null; | ||
6881 | |||
6882 | Token otherlv_1=null; | ||
6883 | Token otherlv_3=null; | ||
6884 | Token otherlv_5=null; | ||
6885 | EObject lv_arguments_2_0 = null; | ||
6886 | |||
6887 | EObject lv_arguments_4_0 = null; | ||
6888 | |||
6889 | |||
6890 | |||
6891 | enterRule(); | ||
6892 | |||
6893 | try { | ||
6894 | // InternalSolverLanguageParser.g:2760:2: ( ( () otherlv_1= LeftParenthesis ( ( (lv_arguments_2_0= ruleArgument ) ) (otherlv_3= Comma ( (lv_arguments_4_0= ruleArgument ) ) )* )? otherlv_5= RightParenthesis ) ) | ||
6895 | // InternalSolverLanguageParser.g:2761:2: ( () otherlv_1= LeftParenthesis ( ( (lv_arguments_2_0= ruleArgument ) ) (otherlv_3= Comma ( (lv_arguments_4_0= ruleArgument ) ) )* )? otherlv_5= RightParenthesis ) | ||
6896 | { | ||
6897 | // InternalSolverLanguageParser.g:2761:2: ( () otherlv_1= LeftParenthesis ( ( (lv_arguments_2_0= ruleArgument ) ) (otherlv_3= Comma ( (lv_arguments_4_0= ruleArgument ) ) )* )? otherlv_5= RightParenthesis ) | ||
6898 | // InternalSolverLanguageParser.g:2762:3: () otherlv_1= LeftParenthesis ( ( (lv_arguments_2_0= ruleArgument ) ) (otherlv_3= Comma ( (lv_arguments_4_0= ruleArgument ) ) )* )? otherlv_5= RightParenthesis | ||
6899 | { | ||
6900 | // InternalSolverLanguageParser.g:2762:3: () | ||
6901 | // InternalSolverLanguageParser.g:2763:4: | ||
6902 | { | ||
6903 | |||
6904 | current = forceCreateModelElement( | ||
6905 | grammarAccess.getArgumentListAccess().getArgumentListAction_0(), | ||
6906 | current); | ||
6907 | |||
6908 | |||
6909 | } | ||
6910 | |||
6911 | otherlv_1=(Token)match(input,LeftParenthesis,FOLLOW_42); | ||
6912 | |||
6913 | newLeafNode(otherlv_1, grammarAccess.getArgumentListAccess().getLeftParenthesisKeyword_1()); | ||
6914 | |||
6915 | // InternalSolverLanguageParser.g:2773:3: ( ( (lv_arguments_2_0= ruleArgument ) ) (otherlv_3= Comma ( (lv_arguments_4_0= ruleArgument ) ) )* )? | ||
6916 | int alt33=2; | ||
6917 | int LA33_0 = input.LA(1); | ||
6918 | |||
6919 | if ( (LA33_0==Unknown||LA33_0==Object||(LA33_0>=Count && LA33_0<=False)||LA33_0==True||LA33_0==Inf||(LA33_0>=ExclamationMark && LA33_0<=LeftParenthesis)||(LA33_0>=Asterisk && LA33_0<=PlusSign)||LA33_0==HyphenMinus||(LA33_0>=QuestionMark && LA33_0<=LeftSquareBracket)||(LA33_0>=Tilde && LA33_0<=RULE_QUOTED_ID)||(LA33_0>=RULE_ID && LA33_0<=RULE_INT)) ) { | ||
6920 | alt33=1; | ||
6921 | } | ||
6922 | switch (alt33) { | ||
6923 | case 1 : | ||
6924 | // InternalSolverLanguageParser.g:2774:4: ( (lv_arguments_2_0= ruleArgument ) ) (otherlv_3= Comma ( (lv_arguments_4_0= ruleArgument ) ) )* | ||
6925 | { | ||
6926 | // InternalSolverLanguageParser.g:2774:4: ( (lv_arguments_2_0= ruleArgument ) ) | ||
6927 | // InternalSolverLanguageParser.g:2775:5: (lv_arguments_2_0= ruleArgument ) | ||
6928 | { | ||
6929 | // InternalSolverLanguageParser.g:2775:5: (lv_arguments_2_0= ruleArgument ) | ||
6930 | // InternalSolverLanguageParser.g:2776:6: lv_arguments_2_0= ruleArgument | ||
6931 | { | ||
6932 | |||
6933 | newCompositeNode(grammarAccess.getArgumentListAccess().getArgumentsArgumentParserRuleCall_2_0_0()); | ||
6934 | |||
6935 | pushFollow(FOLLOW_43); | ||
6936 | lv_arguments_2_0=ruleArgument(); | ||
6937 | |||
6938 | state._fsp--; | ||
6939 | |||
6940 | |||
6941 | if (current==null) { | ||
6942 | current = createModelElementForParent(grammarAccess.getArgumentListRule()); | ||
6943 | } | ||
6944 | add( | ||
6945 | current, | ||
6946 | "arguments", | ||
6947 | lv_arguments_2_0, | ||
6948 | "org.eclipse.viatra.solver.language.SolverLanguage.Argument"); | ||
6949 | afterParserOrEnumRuleCall(); | ||
6950 | |||
6951 | |||
6952 | } | ||
6953 | |||
6954 | |||
6955 | } | ||
6956 | |||
6957 | // InternalSolverLanguageParser.g:2793:4: (otherlv_3= Comma ( (lv_arguments_4_0= ruleArgument ) ) )* | ||
6958 | loop32: | ||
6959 | do { | ||
6960 | int alt32=2; | ||
6961 | int LA32_0 = input.LA(1); | ||
6962 | |||
6963 | if ( (LA32_0==Comma) ) { | ||
6964 | alt32=1; | ||
6965 | } | ||
6966 | |||
6967 | |||
6968 | switch (alt32) { | ||
6969 | case 1 : | ||
6970 | // InternalSolverLanguageParser.g:2794:5: otherlv_3= Comma ( (lv_arguments_4_0= ruleArgument ) ) | ||
6971 | { | ||
6972 | otherlv_3=(Token)match(input,Comma,FOLLOW_44); | ||
6973 | |||
6974 | newLeafNode(otherlv_3, grammarAccess.getArgumentListAccess().getCommaKeyword_2_1_0()); | ||
6975 | |||
6976 | // InternalSolverLanguageParser.g:2798:5: ( (lv_arguments_4_0= ruleArgument ) ) | ||
6977 | // InternalSolverLanguageParser.g:2799:6: (lv_arguments_4_0= ruleArgument ) | ||
6978 | { | ||
6979 | // InternalSolverLanguageParser.g:2799:6: (lv_arguments_4_0= ruleArgument ) | ||
6980 | // InternalSolverLanguageParser.g:2800:7: lv_arguments_4_0= ruleArgument | ||
6981 | { | ||
6982 | |||
6983 | newCompositeNode(grammarAccess.getArgumentListAccess().getArgumentsArgumentParserRuleCall_2_1_1_0()); | ||
6984 | |||
6985 | pushFollow(FOLLOW_43); | ||
6986 | lv_arguments_4_0=ruleArgument(); | ||
6987 | |||
6988 | state._fsp--; | ||
6989 | |||
6990 | |||
6991 | if (current==null) { | ||
6992 | current = createModelElementForParent(grammarAccess.getArgumentListRule()); | ||
6993 | } | ||
6994 | add( | ||
6995 | current, | ||
6996 | "arguments", | ||
6997 | lv_arguments_4_0, | ||
6998 | "org.eclipse.viatra.solver.language.SolverLanguage.Argument"); | ||
6999 | afterParserOrEnumRuleCall(); | ||
7000 | |||
7001 | |||
7002 | } | ||
7003 | |||
7004 | |||
7005 | } | ||
7006 | |||
7007 | |||
7008 | } | ||
7009 | break; | ||
7010 | |||
7011 | default : | ||
7012 | break loop32; | ||
7013 | } | ||
7014 | } while (true); | ||
7015 | |||
7016 | |||
7017 | } | ||
7018 | break; | ||
7019 | |||
7020 | } | ||
7021 | |||
7022 | otherlv_5=(Token)match(input,RightParenthesis,FOLLOW_2); | ||
7023 | |||
7024 | newLeafNode(otherlv_5, grammarAccess.getArgumentListAccess().getRightParenthesisKeyword_3()); | ||
7025 | |||
7026 | |||
7027 | } | ||
7028 | |||
7029 | |||
7030 | } | ||
7031 | |||
7032 | |||
7033 | leaveRule(); | ||
7034 | |||
7035 | } | ||
7036 | |||
7037 | catch (RecognitionException re) { | ||
7038 | recover(input,re); | ||
7039 | appendSkippedTokens(); | ||
7040 | } | ||
7041 | finally { | ||
7042 | } | ||
7043 | return current; | ||
7044 | } | ||
7045 | // $ANTLR end "ruleArgumentList" | ||
7046 | |||
7047 | |||
7048 | // $ANTLR start "entryRuleArgument" | ||
7049 | // InternalSolverLanguageParser.g:2827:1: entryRuleArgument returns [EObject current=null] : iv_ruleArgument= ruleArgument EOF ; | ||
7050 | public final EObject entryRuleArgument() throws RecognitionException { | ||
7051 | EObject current = null; | ||
7052 | |||
7053 | EObject iv_ruleArgument = null; | ||
7054 | |||
7055 | |||
7056 | try { | ||
7057 | // InternalSolverLanguageParser.g:2827:49: (iv_ruleArgument= ruleArgument EOF ) | ||
7058 | // InternalSolverLanguageParser.g:2828:2: iv_ruleArgument= ruleArgument EOF | ||
7059 | { | ||
7060 | newCompositeNode(grammarAccess.getArgumentRule()); | ||
7061 | pushFollow(FOLLOW_1); | ||
7062 | iv_ruleArgument=ruleArgument(); | ||
7063 | |||
7064 | state._fsp--; | ||
7065 | |||
7066 | current =iv_ruleArgument; | ||
7067 | match(input,EOF,FOLLOW_2); | ||
7068 | |||
7069 | } | ||
7070 | |||
7071 | } | ||
7072 | |||
7073 | catch (RecognitionException re) { | ||
7074 | recover(input,re); | ||
7075 | appendSkippedTokens(); | ||
7076 | } | ||
7077 | finally { | ||
7078 | } | ||
7079 | return current; | ||
7080 | } | ||
7081 | // $ANTLR end "entryRuleArgument" | ||
7082 | |||
7083 | |||
7084 | // $ANTLR start "ruleArgument" | ||
7085 | // InternalSolverLanguageParser.g:2834:1: ruleArgument returns [EObject current=null] : (this_ExpressionArgument_0= ruleExpressionArgument | this_StarArgument_1= ruleStarArgument | this_TypedVariableArgument_2= ruleTypedVariableArgument | this_TypedStarArgument_3= ruleTypedStarArgument ) ; | ||
7086 | public final EObject ruleArgument() throws RecognitionException { | ||
7087 | EObject current = null; | ||
7088 | |||
7089 | EObject this_ExpressionArgument_0 = null; | ||
7090 | |||
7091 | EObject this_StarArgument_1 = null; | ||
7092 | |||
7093 | EObject this_TypedVariableArgument_2 = null; | ||
7094 | |||
7095 | EObject this_TypedStarArgument_3 = null; | ||
7096 | |||
7097 | |||
7098 | |||
7099 | enterRule(); | ||
7100 | |||
7101 | try { | ||
7102 | // InternalSolverLanguageParser.g:2840:2: ( (this_ExpressionArgument_0= ruleExpressionArgument | this_StarArgument_1= ruleStarArgument | this_TypedVariableArgument_2= ruleTypedVariableArgument | this_TypedStarArgument_3= ruleTypedStarArgument ) ) | ||
7103 | // InternalSolverLanguageParser.g:2841:2: (this_ExpressionArgument_0= ruleExpressionArgument | this_StarArgument_1= ruleStarArgument | this_TypedVariableArgument_2= ruleTypedVariableArgument | this_TypedStarArgument_3= ruleTypedStarArgument ) | ||
7104 | { | ||
7105 | // InternalSolverLanguageParser.g:2841:2: (this_ExpressionArgument_0= ruleExpressionArgument | this_StarArgument_1= ruleStarArgument | this_TypedVariableArgument_2= ruleTypedVariableArgument | this_TypedStarArgument_3= ruleTypedStarArgument ) | ||
7106 | int alt34=4; | ||
7107 | alt34 = dfa34.predict(input); | ||
7108 | switch (alt34) { | ||
7109 | case 1 : | ||
7110 | // InternalSolverLanguageParser.g:2842:3: this_ExpressionArgument_0= ruleExpressionArgument | ||
7111 | { | ||
7112 | |||
7113 | newCompositeNode(grammarAccess.getArgumentAccess().getExpressionArgumentParserRuleCall_0()); | ||
7114 | |||
7115 | pushFollow(FOLLOW_2); | ||
7116 | this_ExpressionArgument_0=ruleExpressionArgument(); | ||
7117 | |||
7118 | state._fsp--; | ||
7119 | |||
7120 | |||
7121 | current = this_ExpressionArgument_0; | ||
7122 | afterParserOrEnumRuleCall(); | ||
7123 | |||
7124 | |||
7125 | } | ||
7126 | break; | ||
7127 | case 2 : | ||
7128 | // InternalSolverLanguageParser.g:2851:3: this_StarArgument_1= ruleStarArgument | ||
7129 | { | ||
7130 | |||
7131 | newCompositeNode(grammarAccess.getArgumentAccess().getStarArgumentParserRuleCall_1()); | ||
7132 | |||
7133 | pushFollow(FOLLOW_2); | ||
7134 | this_StarArgument_1=ruleStarArgument(); | ||
7135 | |||
7136 | state._fsp--; | ||
7137 | |||
7138 | |||
7139 | current = this_StarArgument_1; | ||
7140 | afterParserOrEnumRuleCall(); | ||
7141 | |||
7142 | |||
7143 | } | ||
7144 | break; | ||
7145 | case 3 : | ||
7146 | // InternalSolverLanguageParser.g:2860:3: this_TypedVariableArgument_2= ruleTypedVariableArgument | ||
7147 | { | ||
7148 | |||
7149 | newCompositeNode(grammarAccess.getArgumentAccess().getTypedVariableArgumentParserRuleCall_2()); | ||
7150 | |||
7151 | pushFollow(FOLLOW_2); | ||
7152 | this_TypedVariableArgument_2=ruleTypedVariableArgument(); | ||
7153 | |||
7154 | state._fsp--; | ||
7155 | |||
7156 | |||
7157 | current = this_TypedVariableArgument_2; | ||
7158 | afterParserOrEnumRuleCall(); | ||
7159 | |||
7160 | |||
7161 | } | ||
7162 | break; | ||
7163 | case 4 : | ||
7164 | // InternalSolverLanguageParser.g:2869:3: this_TypedStarArgument_3= ruleTypedStarArgument | ||
7165 | { | ||
7166 | |||
7167 | newCompositeNode(grammarAccess.getArgumentAccess().getTypedStarArgumentParserRuleCall_3()); | ||
7168 | |||
7169 | pushFollow(FOLLOW_2); | ||
7170 | this_TypedStarArgument_3=ruleTypedStarArgument(); | ||
7171 | |||
7172 | state._fsp--; | ||
7173 | |||
7174 | |||
7175 | current = this_TypedStarArgument_3; | ||
7176 | afterParserOrEnumRuleCall(); | ||
7177 | |||
7178 | |||
7179 | } | ||
7180 | break; | ||
7181 | |||
7182 | } | ||
7183 | |||
7184 | |||
7185 | } | ||
7186 | |||
7187 | |||
7188 | leaveRule(); | ||
7189 | |||
7190 | } | ||
7191 | |||
7192 | catch (RecognitionException re) { | ||
7193 | recover(input,re); | ||
7194 | appendSkippedTokens(); | ||
7195 | } | ||
7196 | finally { | ||
7197 | } | ||
7198 | return current; | ||
7199 | } | ||
7200 | // $ANTLR end "ruleArgument" | ||
7201 | |||
7202 | |||
7203 | // $ANTLR start "entryRuleExpressionArgument" | ||
7204 | // InternalSolverLanguageParser.g:2881:1: entryRuleExpressionArgument returns [EObject current=null] : iv_ruleExpressionArgument= ruleExpressionArgument EOF ; | ||
7205 | public final EObject entryRuleExpressionArgument() throws RecognitionException { | ||
7206 | EObject current = null; | ||
7207 | |||
7208 | EObject iv_ruleExpressionArgument = null; | ||
7209 | |||
7210 | |||
7211 | try { | ||
7212 | // InternalSolverLanguageParser.g:2881:59: (iv_ruleExpressionArgument= ruleExpressionArgument EOF ) | ||
7213 | // InternalSolverLanguageParser.g:2882:2: iv_ruleExpressionArgument= ruleExpressionArgument EOF | ||
7214 | { | ||
7215 | newCompositeNode(grammarAccess.getExpressionArgumentRule()); | ||
7216 | pushFollow(FOLLOW_1); | ||
7217 | iv_ruleExpressionArgument=ruleExpressionArgument(); | ||
7218 | |||
7219 | state._fsp--; | ||
7220 | |||
7221 | current =iv_ruleExpressionArgument; | ||
7222 | match(input,EOF,FOLLOW_2); | ||
7223 | |||
7224 | } | ||
7225 | |||
7226 | } | ||
7227 | |||
7228 | catch (RecognitionException re) { | ||
7229 | recover(input,re); | ||
7230 | appendSkippedTokens(); | ||
7231 | } | ||
7232 | finally { | ||
7233 | } | ||
7234 | return current; | ||
7235 | } | ||
7236 | // $ANTLR end "entryRuleExpressionArgument" | ||
7237 | |||
7238 | |||
7239 | // $ANTLR start "ruleExpressionArgument" | ||
7240 | // InternalSolverLanguageParser.g:2888:1: ruleExpressionArgument returns [EObject current=null] : ( (lv_expression_0_0= ruleComparisonExpression ) ) ; | ||
7241 | public final EObject ruleExpressionArgument() throws RecognitionException { | ||
7242 | EObject current = null; | ||
7243 | |||
7244 | EObject lv_expression_0_0 = null; | ||
7245 | |||
7246 | |||
7247 | |||
7248 | enterRule(); | ||
7249 | |||
7250 | try { | ||
7251 | // InternalSolverLanguageParser.g:2894:2: ( ( (lv_expression_0_0= ruleComparisonExpression ) ) ) | ||
7252 | // InternalSolverLanguageParser.g:2895:2: ( (lv_expression_0_0= ruleComparisonExpression ) ) | ||
7253 | { | ||
7254 | // InternalSolverLanguageParser.g:2895:2: ( (lv_expression_0_0= ruleComparisonExpression ) ) | ||
7255 | // InternalSolverLanguageParser.g:2896:3: (lv_expression_0_0= ruleComparisonExpression ) | ||
7256 | { | ||
7257 | // InternalSolverLanguageParser.g:2896:3: (lv_expression_0_0= ruleComparisonExpression ) | ||
7258 | // InternalSolverLanguageParser.g:2897:4: lv_expression_0_0= ruleComparisonExpression | ||
7259 | { | ||
7260 | |||
7261 | newCompositeNode(grammarAccess.getExpressionArgumentAccess().getExpressionComparisonExpressionParserRuleCall_0()); | ||
7262 | |||
7263 | pushFollow(FOLLOW_2); | ||
7264 | lv_expression_0_0=ruleComparisonExpression(); | ||
7265 | |||
7266 | state._fsp--; | ||
7267 | |||
7268 | |||
7269 | if (current==null) { | ||
7270 | current = createModelElementForParent(grammarAccess.getExpressionArgumentRule()); | ||
7271 | } | ||
7272 | set( | ||
7273 | current, | ||
7274 | "expression", | ||
7275 | lv_expression_0_0, | ||
7276 | "org.eclipse.viatra.solver.language.SolverLanguage.ComparisonExpression"); | ||
7277 | afterParserOrEnumRuleCall(); | ||
7278 | |||
7279 | |||
7280 | } | ||
7281 | |||
7282 | |||
7283 | } | ||
7284 | |||
7285 | |||
7286 | } | ||
7287 | |||
7288 | |||
7289 | leaveRule(); | ||
7290 | |||
7291 | } | ||
7292 | |||
7293 | catch (RecognitionException re) { | ||
7294 | recover(input,re); | ||
7295 | appendSkippedTokens(); | ||
7296 | } | ||
7297 | finally { | ||
7298 | } | ||
7299 | return current; | ||
7300 | } | ||
7301 | // $ANTLR end "ruleExpressionArgument" | ||
7302 | |||
7303 | |||
7304 | // $ANTLR start "entryRuleStarArgument" | ||
7305 | // InternalSolverLanguageParser.g:2917:1: entryRuleStarArgument returns [EObject current=null] : iv_ruleStarArgument= ruleStarArgument EOF ; | ||
7306 | public final EObject entryRuleStarArgument() throws RecognitionException { | ||
7307 | EObject current = null; | ||
7308 | |||
7309 | EObject iv_ruleStarArgument = null; | ||
7310 | |||
7311 | |||
7312 | try { | ||
7313 | // InternalSolverLanguageParser.g:2917:53: (iv_ruleStarArgument= ruleStarArgument EOF ) | ||
7314 | // InternalSolverLanguageParser.g:2918:2: iv_ruleStarArgument= ruleStarArgument EOF | ||
7315 | { | ||
7316 | newCompositeNode(grammarAccess.getStarArgumentRule()); | ||
7317 | pushFollow(FOLLOW_1); | ||
7318 | iv_ruleStarArgument=ruleStarArgument(); | ||
7319 | |||
7320 | state._fsp--; | ||
7321 | |||
7322 | current =iv_ruleStarArgument; | ||
7323 | match(input,EOF,FOLLOW_2); | ||
7324 | |||
7325 | } | ||
7326 | |||
7327 | } | ||
7328 | |||
7329 | catch (RecognitionException re) { | ||
7330 | recover(input,re); | ||
7331 | appendSkippedTokens(); | ||
7332 | } | ||
7333 | finally { | ||
7334 | } | ||
7335 | return current; | ||
7336 | } | ||
7337 | // $ANTLR end "entryRuleStarArgument" | ||
7338 | |||
7339 | |||
7340 | // $ANTLR start "ruleStarArgument" | ||
7341 | // InternalSolverLanguageParser.g:2924:1: ruleStarArgument returns [EObject current=null] : ( () otherlv_1= Asterisk ) ; | ||
7342 | public final EObject ruleStarArgument() throws RecognitionException { | ||
7343 | EObject current = null; | ||
7344 | |||
7345 | Token otherlv_1=null; | ||
7346 | |||
7347 | |||
7348 | enterRule(); | ||
7349 | |||
7350 | try { | ||
7351 | // InternalSolverLanguageParser.g:2930:2: ( ( () otherlv_1= Asterisk ) ) | ||
7352 | // InternalSolverLanguageParser.g:2931:2: ( () otherlv_1= Asterisk ) | ||
7353 | { | ||
7354 | // InternalSolverLanguageParser.g:2931:2: ( () otherlv_1= Asterisk ) | ||
7355 | // InternalSolverLanguageParser.g:2932:3: () otherlv_1= Asterisk | ||
7356 | { | ||
7357 | // InternalSolverLanguageParser.g:2932:3: () | ||
7358 | // InternalSolverLanguageParser.g:2933:4: | ||
7359 | { | ||
7360 | |||
7361 | current = forceCreateModelElement( | ||
7362 | grammarAccess.getStarArgumentAccess().getStarArgumentAction_0(), | ||
7363 | current); | ||
7364 | |||
7365 | |||
7366 | } | ||
7367 | |||
7368 | otherlv_1=(Token)match(input,Asterisk,FOLLOW_2); | ||
7369 | |||
7370 | newLeafNode(otherlv_1, grammarAccess.getStarArgumentAccess().getAsteriskKeyword_1()); | ||
7371 | |||
7372 | |||
7373 | } | ||
7374 | |||
7375 | |||
7376 | } | ||
7377 | |||
7378 | |||
7379 | leaveRule(); | ||
7380 | |||
7381 | } | ||
7382 | |||
7383 | catch (RecognitionException re) { | ||
7384 | recover(input,re); | ||
7385 | appendSkippedTokens(); | ||
7386 | } | ||
7387 | finally { | ||
7388 | } | ||
7389 | return current; | ||
7390 | } | ||
7391 | // $ANTLR end "ruleStarArgument" | ||
7392 | |||
7393 | |||
7394 | // $ANTLR start "entryRuleTypedVariableArgument" | ||
7395 | // InternalSolverLanguageParser.g:2947:1: entryRuleTypedVariableArgument returns [EObject current=null] : iv_ruleTypedVariableArgument= ruleTypedVariableArgument EOF ; | ||
7396 | public final EObject entryRuleTypedVariableArgument() throws RecognitionException { | ||
7397 | EObject current = null; | ||
7398 | |||
7399 | EObject iv_ruleTypedVariableArgument = null; | ||
7400 | |||
7401 | |||
7402 | try { | ||
7403 | // InternalSolverLanguageParser.g:2947:62: (iv_ruleTypedVariableArgument= ruleTypedVariableArgument EOF ) | ||
7404 | // InternalSolverLanguageParser.g:2948:2: iv_ruleTypedVariableArgument= ruleTypedVariableArgument EOF | ||
7405 | { | ||
7406 | newCompositeNode(grammarAccess.getTypedVariableArgumentRule()); | ||
7407 | pushFollow(FOLLOW_1); | ||
7408 | iv_ruleTypedVariableArgument=ruleTypedVariableArgument(); | ||
7409 | |||
7410 | state._fsp--; | ||
7411 | |||
7412 | current =iv_ruleTypedVariableArgument; | ||
7413 | match(input,EOF,FOLLOW_2); | ||
7414 | |||
7415 | } | ||
7416 | |||
7417 | } | ||
7418 | |||
7419 | catch (RecognitionException re) { | ||
7420 | recover(input,re); | ||
7421 | appendSkippedTokens(); | ||
7422 | } | ||
7423 | finally { | ||
7424 | } | ||
7425 | return current; | ||
7426 | } | ||
7427 | // $ANTLR end "entryRuleTypedVariableArgument" | ||
7428 | |||
7429 | |||
7430 | // $ANTLR start "ruleTypedVariableArgument" | ||
7431 | // InternalSolverLanguageParser.g:2954:1: ruleTypedVariableArgument returns [EObject current=null] : ( ( (lv_typeReference_0_0= ruleTypeReference ) ) ( (lv_name_1_0= RULE_ID ) ) ) ; | ||
7432 | public final EObject ruleTypedVariableArgument() throws RecognitionException { | ||
7433 | EObject current = null; | ||
7434 | |||
7435 | Token lv_name_1_0=null; | ||
7436 | EObject lv_typeReference_0_0 = null; | ||
7437 | |||
7438 | |||
7439 | |||
7440 | enterRule(); | ||
7441 | |||
7442 | try { | ||
7443 | // InternalSolverLanguageParser.g:2960:2: ( ( ( (lv_typeReference_0_0= ruleTypeReference ) ) ( (lv_name_1_0= RULE_ID ) ) ) ) | ||
7444 | // InternalSolverLanguageParser.g:2961:2: ( ( (lv_typeReference_0_0= ruleTypeReference ) ) ( (lv_name_1_0= RULE_ID ) ) ) | ||
7445 | { | ||
7446 | // InternalSolverLanguageParser.g:2961:2: ( ( (lv_typeReference_0_0= ruleTypeReference ) ) ( (lv_name_1_0= RULE_ID ) ) ) | ||
7447 | // InternalSolverLanguageParser.g:2962:3: ( (lv_typeReference_0_0= ruleTypeReference ) ) ( (lv_name_1_0= RULE_ID ) ) | ||
7448 | { | ||
7449 | // InternalSolverLanguageParser.g:2962:3: ( (lv_typeReference_0_0= ruleTypeReference ) ) | ||
7450 | // InternalSolverLanguageParser.g:2963:4: (lv_typeReference_0_0= ruleTypeReference ) | ||
7451 | { | ||
7452 | // InternalSolverLanguageParser.g:2963:4: (lv_typeReference_0_0= ruleTypeReference ) | ||
7453 | // InternalSolverLanguageParser.g:2964:5: lv_typeReference_0_0= ruleTypeReference | ||
7454 | { | ||
7455 | |||
7456 | newCompositeNode(grammarAccess.getTypedVariableArgumentAccess().getTypeReferenceTypeReferenceParserRuleCall_0_0()); | ||
7457 | |||
7458 | pushFollow(FOLLOW_28); | ||
7459 | lv_typeReference_0_0=ruleTypeReference(); | ||
7460 | |||
7461 | state._fsp--; | ||
7462 | |||
7463 | |||
7464 | if (current==null) { | ||
7465 | current = createModelElementForParent(grammarAccess.getTypedVariableArgumentRule()); | ||
7466 | } | ||
7467 | set( | ||
7468 | current, | ||
7469 | "typeReference", | ||
7470 | lv_typeReference_0_0, | ||
7471 | "org.eclipse.viatra.solver.language.SolverLanguage.TypeReference"); | ||
7472 | afterParserOrEnumRuleCall(); | ||
7473 | |||
7474 | |||
7475 | } | ||
7476 | |||
7477 | |||
7478 | } | ||
7479 | |||
7480 | // InternalSolverLanguageParser.g:2981:3: ( (lv_name_1_0= RULE_ID ) ) | ||
7481 | // InternalSolverLanguageParser.g:2982:4: (lv_name_1_0= RULE_ID ) | ||
7482 | { | ||
7483 | // InternalSolverLanguageParser.g:2982:4: (lv_name_1_0= RULE_ID ) | ||
7484 | // InternalSolverLanguageParser.g:2983:5: lv_name_1_0= RULE_ID | ||
7485 | { | ||
7486 | lv_name_1_0=(Token)match(input,RULE_ID,FOLLOW_2); | ||
7487 | |||
7488 | newLeafNode(lv_name_1_0, grammarAccess.getTypedVariableArgumentAccess().getNameIDTerminalRuleCall_1_0()); | ||
7489 | |||
7490 | |||
7491 | if (current==null) { | ||
7492 | current = createModelElement(grammarAccess.getTypedVariableArgumentRule()); | ||
7493 | } | ||
7494 | setWithLastConsumed( | ||
7495 | current, | ||
7496 | "name", | ||
7497 | lv_name_1_0, | ||
7498 | "org.eclipse.xtext.common.Terminals.ID"); | ||
7499 | |||
7500 | |||
7501 | } | ||
7502 | |||
7503 | |||
7504 | } | ||
7505 | |||
7506 | |||
7507 | } | ||
7508 | |||
7509 | |||
7510 | } | ||
7511 | |||
7512 | |||
7513 | leaveRule(); | ||
7514 | |||
7515 | } | ||
7516 | |||
7517 | catch (RecognitionException re) { | ||
7518 | recover(input,re); | ||
7519 | appendSkippedTokens(); | ||
7520 | } | ||
7521 | finally { | ||
7522 | } | ||
7523 | return current; | ||
7524 | } | ||
7525 | // $ANTLR end "ruleTypedVariableArgument" | ||
7526 | |||
7527 | |||
7528 | // $ANTLR start "entryRuleTypedStarArgument" | ||
7529 | // InternalSolverLanguageParser.g:3003:1: entryRuleTypedStarArgument returns [EObject current=null] : iv_ruleTypedStarArgument= ruleTypedStarArgument EOF ; | ||
7530 | public final EObject entryRuleTypedStarArgument() throws RecognitionException { | ||
7531 | EObject current = null; | ||
7532 | |||
7533 | EObject iv_ruleTypedStarArgument = null; | ||
7534 | |||
7535 | |||
7536 | try { | ||
7537 | // InternalSolverLanguageParser.g:3003:58: (iv_ruleTypedStarArgument= ruleTypedStarArgument EOF ) | ||
7538 | // InternalSolverLanguageParser.g:3004:2: iv_ruleTypedStarArgument= ruleTypedStarArgument EOF | ||
7539 | { | ||
7540 | newCompositeNode(grammarAccess.getTypedStarArgumentRule()); | ||
7541 | pushFollow(FOLLOW_1); | ||
7542 | iv_ruleTypedStarArgument=ruleTypedStarArgument(); | ||
7543 | |||
7544 | state._fsp--; | ||
7545 | |||
7546 | current =iv_ruleTypedStarArgument; | ||
7547 | match(input,EOF,FOLLOW_2); | ||
7548 | |||
7549 | } | ||
7550 | |||
7551 | } | ||
7552 | |||
7553 | catch (RecognitionException re) { | ||
7554 | recover(input,re); | ||
7555 | appendSkippedTokens(); | ||
7556 | } | ||
7557 | finally { | ||
7558 | } | ||
7559 | return current; | ||
7560 | } | ||
7561 | // $ANTLR end "entryRuleTypedStarArgument" | ||
7562 | |||
7563 | |||
7564 | // $ANTLR start "ruleTypedStarArgument" | ||
7565 | // InternalSolverLanguageParser.g:3010:1: ruleTypedStarArgument returns [EObject current=null] : ( ( (lv_typeReference_0_0= ruleTypeReference ) ) otherlv_1= Asterisk ) ; | ||
7566 | public final EObject ruleTypedStarArgument() throws RecognitionException { | ||
7567 | EObject current = null; | ||
7568 | |||
7569 | Token otherlv_1=null; | ||
7570 | EObject lv_typeReference_0_0 = null; | ||
7571 | |||
7572 | |||
7573 | |||
7574 | enterRule(); | ||
7575 | |||
7576 | try { | ||
7577 | // InternalSolverLanguageParser.g:3016:2: ( ( ( (lv_typeReference_0_0= ruleTypeReference ) ) otherlv_1= Asterisk ) ) | ||
7578 | // InternalSolverLanguageParser.g:3017:2: ( ( (lv_typeReference_0_0= ruleTypeReference ) ) otherlv_1= Asterisk ) | ||
7579 | { | ||
7580 | // InternalSolverLanguageParser.g:3017:2: ( ( (lv_typeReference_0_0= ruleTypeReference ) ) otherlv_1= Asterisk ) | ||
7581 | // InternalSolverLanguageParser.g:3018:3: ( (lv_typeReference_0_0= ruleTypeReference ) ) otherlv_1= Asterisk | ||
7582 | { | ||
7583 | // InternalSolverLanguageParser.g:3018:3: ( (lv_typeReference_0_0= ruleTypeReference ) ) | ||
7584 | // InternalSolverLanguageParser.g:3019:4: (lv_typeReference_0_0= ruleTypeReference ) | ||
7585 | { | ||
7586 | // InternalSolverLanguageParser.g:3019:4: (lv_typeReference_0_0= ruleTypeReference ) | ||
7587 | // InternalSolverLanguageParser.g:3020:5: lv_typeReference_0_0= ruleTypeReference | ||
7588 | { | ||
7589 | |||
7590 | newCompositeNode(grammarAccess.getTypedStarArgumentAccess().getTypeReferenceTypeReferenceParserRuleCall_0_0()); | ||
7591 | |||
7592 | pushFollow(FOLLOW_45); | ||
7593 | lv_typeReference_0_0=ruleTypeReference(); | ||
7594 | |||
7595 | state._fsp--; | ||
7596 | |||
7597 | |||
7598 | if (current==null) { | ||
7599 | current = createModelElementForParent(grammarAccess.getTypedStarArgumentRule()); | ||
7600 | } | ||
7601 | set( | ||
7602 | current, | ||
7603 | "typeReference", | ||
7604 | lv_typeReference_0_0, | ||
7605 | "org.eclipse.viatra.solver.language.SolverLanguage.TypeReference"); | ||
7606 | afterParserOrEnumRuleCall(); | ||
7607 | |||
7608 | |||
7609 | } | ||
7610 | |||
7611 | |||
7612 | } | ||
7613 | |||
7614 | otherlv_1=(Token)match(input,Asterisk,FOLLOW_2); | ||
7615 | |||
7616 | newLeafNode(otherlv_1, grammarAccess.getTypedStarArgumentAccess().getAsteriskKeyword_1()); | ||
7617 | |||
7618 | |||
7619 | } | ||
7620 | |||
7621 | |||
7622 | } | ||
7623 | |||
7624 | |||
7625 | leaveRule(); | ||
7626 | |||
7627 | } | ||
7628 | |||
7629 | catch (RecognitionException re) { | ||
7630 | recover(input,re); | ||
7631 | appendSkippedTokens(); | ||
7632 | } | ||
7633 | finally { | ||
7634 | } | ||
7635 | return current; | ||
7636 | } | ||
7637 | // $ANTLR end "ruleTypedStarArgument" | ||
7638 | |||
7639 | |||
7640 | // $ANTLR start "entryRuleReference" | ||
7641 | // InternalSolverLanguageParser.g:3045:1: entryRuleReference returns [EObject current=null] : iv_ruleReference= ruleReference EOF ; | ||
7642 | public final EObject entryRuleReference() throws RecognitionException { | ||
7643 | EObject current = null; | ||
7644 | |||
7645 | EObject iv_ruleReference = null; | ||
7646 | |||
7647 | |||
7648 | try { | ||
7649 | // InternalSolverLanguageParser.g:3045:50: (iv_ruleReference= ruleReference EOF ) | ||
7650 | // InternalSolverLanguageParser.g:3046:2: iv_ruleReference= ruleReference EOF | ||
7651 | { | ||
7652 | newCompositeNode(grammarAccess.getReferenceRule()); | ||
7653 | pushFollow(FOLLOW_1); | ||
7654 | iv_ruleReference=ruleReference(); | ||
7655 | |||
7656 | state._fsp--; | ||
7657 | |||
7658 | current =iv_ruleReference; | ||
7659 | match(input,EOF,FOLLOW_2); | ||
7660 | |||
7661 | } | ||
7662 | |||
7663 | } | ||
7664 | |||
7665 | catch (RecognitionException re) { | ||
7666 | recover(input,re); | ||
7667 | appendSkippedTokens(); | ||
7668 | } | ||
7669 | finally { | ||
7670 | } | ||
7671 | return current; | ||
7672 | } | ||
7673 | // $ANTLR end "entryRuleReference" | ||
7674 | |||
7675 | |||
7676 | // $ANTLR start "ruleReference" | ||
7677 | // InternalSolverLanguageParser.g:3052:1: ruleReference returns [EObject current=null] : ( ( (lv_components_0_0= rulePathComponent ) ) (otherlv_1= FullStop ( (lv_components_2_0= rulePathComponent ) ) )* ) ; | ||
7678 | public final EObject ruleReference() throws RecognitionException { | ||
7679 | EObject current = null; | ||
7680 | |||
7681 | Token otherlv_1=null; | ||
7682 | EObject lv_components_0_0 = null; | ||
7683 | |||
7684 | EObject lv_components_2_0 = null; | ||
7685 | |||
7686 | |||
7687 | |||
7688 | enterRule(); | ||
7689 | |||
7690 | try { | ||
7691 | // InternalSolverLanguageParser.g:3058:2: ( ( ( (lv_components_0_0= rulePathComponent ) ) (otherlv_1= FullStop ( (lv_components_2_0= rulePathComponent ) ) )* ) ) | ||
7692 | // InternalSolverLanguageParser.g:3059:2: ( ( (lv_components_0_0= rulePathComponent ) ) (otherlv_1= FullStop ( (lv_components_2_0= rulePathComponent ) ) )* ) | ||
7693 | { | ||
7694 | // InternalSolverLanguageParser.g:3059:2: ( ( (lv_components_0_0= rulePathComponent ) ) (otherlv_1= FullStop ( (lv_components_2_0= rulePathComponent ) ) )* ) | ||
7695 | // InternalSolverLanguageParser.g:3060:3: ( (lv_components_0_0= rulePathComponent ) ) (otherlv_1= FullStop ( (lv_components_2_0= rulePathComponent ) ) )* | ||
7696 | { | ||
7697 | // InternalSolverLanguageParser.g:3060:3: ( (lv_components_0_0= rulePathComponent ) ) | ||
7698 | // InternalSolverLanguageParser.g:3061:4: (lv_components_0_0= rulePathComponent ) | ||
7699 | { | ||
7700 | // InternalSolverLanguageParser.g:3061:4: (lv_components_0_0= rulePathComponent ) | ||
7701 | // InternalSolverLanguageParser.g:3062:5: lv_components_0_0= rulePathComponent | ||
7702 | { | ||
7703 | |||
7704 | newCompositeNode(grammarAccess.getReferenceAccess().getComponentsPathComponentParserRuleCall_0_0()); | ||
7705 | |||
7706 | pushFollow(FOLLOW_46); | ||
7707 | lv_components_0_0=rulePathComponent(); | ||
7708 | |||
7709 | state._fsp--; | ||
7710 | |||
7711 | |||
7712 | if (current==null) { | ||
7713 | current = createModelElementForParent(grammarAccess.getReferenceRule()); | ||
7714 | } | ||
7715 | add( | ||
7716 | current, | ||
7717 | "components", | ||
7718 | lv_components_0_0, | ||
7719 | "org.eclipse.viatra.solver.language.SolverLanguage.PathComponent"); | ||
7720 | afterParserOrEnumRuleCall(); | ||
7721 | |||
7722 | |||
7723 | } | ||
7724 | |||
7725 | |||
7726 | } | ||
7727 | |||
7728 | // InternalSolverLanguageParser.g:3079:3: (otherlv_1= FullStop ( (lv_components_2_0= rulePathComponent ) ) )* | ||
7729 | loop35: | ||
7730 | do { | ||
7731 | int alt35=2; | ||
7732 | int LA35_0 = input.LA(1); | ||
7733 | |||
7734 | if ( (LA35_0==FullStop) ) { | ||
7735 | alt35=1; | ||
7736 | } | ||
7737 | |||
7738 | |||
7739 | switch (alt35) { | ||
7740 | case 1 : | ||
7741 | // InternalSolverLanguageParser.g:3080:4: otherlv_1= FullStop ( (lv_components_2_0= rulePathComponent ) ) | ||
7742 | { | ||
7743 | otherlv_1=(Token)match(input,FullStop,FOLLOW_12); | ||
7744 | |||
7745 | newLeafNode(otherlv_1, grammarAccess.getReferenceAccess().getFullStopKeyword_1_0()); | ||
7746 | |||
7747 | // InternalSolverLanguageParser.g:3084:4: ( (lv_components_2_0= rulePathComponent ) ) | ||
7748 | // InternalSolverLanguageParser.g:3085:5: (lv_components_2_0= rulePathComponent ) | ||
7749 | { | ||
7750 | // InternalSolverLanguageParser.g:3085:5: (lv_components_2_0= rulePathComponent ) | ||
7751 | // InternalSolverLanguageParser.g:3086:6: lv_components_2_0= rulePathComponent | ||
7752 | { | ||
7753 | |||
7754 | newCompositeNode(grammarAccess.getReferenceAccess().getComponentsPathComponentParserRuleCall_1_1_0()); | ||
7755 | |||
7756 | pushFollow(FOLLOW_46); | ||
7757 | lv_components_2_0=rulePathComponent(); | ||
7758 | |||
7759 | state._fsp--; | ||
7760 | |||
7761 | |||
7762 | if (current==null) { | ||
7763 | current = createModelElementForParent(grammarAccess.getReferenceRule()); | ||
7764 | } | ||
7765 | add( | ||
7766 | current, | ||
7767 | "components", | ||
7768 | lv_components_2_0, | ||
7769 | "org.eclipse.viatra.solver.language.SolverLanguage.PathComponent"); | ||
7770 | afterParserOrEnumRuleCall(); | ||
7771 | |||
7772 | |||
7773 | } | ||
7774 | |||
7775 | |||
7776 | } | ||
7777 | |||
7778 | |||
7779 | } | ||
7780 | break; | ||
7781 | |||
7782 | default : | ||
7783 | break loop35; | ||
7784 | } | ||
7785 | } while (true); | ||
7786 | |||
7787 | |||
7788 | } | ||
7789 | |||
7790 | |||
7791 | } | ||
7792 | |||
7793 | |||
7794 | leaveRule(); | ||
7795 | |||
7796 | } | ||
7797 | |||
7798 | catch (RecognitionException re) { | ||
7799 | recover(input,re); | ||
7800 | appendSkippedTokens(); | ||
7801 | } | ||
7802 | finally { | ||
7803 | } | ||
7804 | return current; | ||
7805 | } | ||
7806 | // $ANTLR end "ruleReference" | ||
7807 | |||
7808 | |||
7809 | // $ANTLR start "entryRulePathComponent" | ||
7810 | // InternalSolverLanguageParser.g:3108:1: entryRulePathComponent returns [EObject current=null] : iv_rulePathComponent= rulePathComponent EOF ; | ||
7811 | public final EObject entryRulePathComponent() throws RecognitionException { | ||
7812 | EObject current = null; | ||
7813 | |||
7814 | EObject iv_rulePathComponent = null; | ||
7815 | |||
7816 | |||
7817 | try { | ||
7818 | // InternalSolverLanguageParser.g:3108:54: (iv_rulePathComponent= rulePathComponent EOF ) | ||
7819 | // InternalSolverLanguageParser.g:3109:2: iv_rulePathComponent= rulePathComponent EOF | ||
7820 | { | ||
7821 | newCompositeNode(grammarAccess.getPathComponentRule()); | ||
7822 | pushFollow(FOLLOW_1); | ||
7823 | iv_rulePathComponent=rulePathComponent(); | ||
7824 | |||
7825 | state._fsp--; | ||
7826 | |||
7827 | current =iv_rulePathComponent; | ||
7828 | match(input,EOF,FOLLOW_2); | ||
7829 | |||
7830 | } | ||
7831 | |||
7832 | } | ||
7833 | |||
7834 | catch (RecognitionException re) { | ||
7835 | recover(input,re); | ||
7836 | appendSkippedTokens(); | ||
7837 | } | ||
7838 | finally { | ||
7839 | } | ||
7840 | return current; | ||
7841 | } | ||
7842 | // $ANTLR end "entryRulePathComponent" | ||
7843 | |||
7844 | |||
7845 | // $ANTLR start "rulePathComponent" | ||
7846 | // InternalSolverLanguageParser.g:3115:1: rulePathComponent returns [EObject current=null] : ( ( (lv_inverse_0_0= Tilde ) )? ( ( ruleQualifiedName ) ) ( ( (lv_transitiveClosure_2_0= RULE_TRANSITIVE_CLOSURE ) ) | ( (lv_reflexiveTransitiveClosure_3_0= RULE_REFLEXIVE_TRANSITIVE_CLOSURE ) ) )? ) ; | ||
7847 | public final EObject rulePathComponent() throws RecognitionException { | ||
7848 | EObject current = null; | ||
7849 | |||
7850 | Token lv_inverse_0_0=null; | ||
7851 | Token lv_transitiveClosure_2_0=null; | ||
7852 | Token lv_reflexiveTransitiveClosure_3_0=null; | ||
7853 | |||
7854 | |||
7855 | enterRule(); | ||
7856 | |||
7857 | try { | ||
7858 | // InternalSolverLanguageParser.g:3121:2: ( ( ( (lv_inverse_0_0= Tilde ) )? ( ( ruleQualifiedName ) ) ( ( (lv_transitiveClosure_2_0= RULE_TRANSITIVE_CLOSURE ) ) | ( (lv_reflexiveTransitiveClosure_3_0= RULE_REFLEXIVE_TRANSITIVE_CLOSURE ) ) )? ) ) | ||
7859 | // InternalSolverLanguageParser.g:3122:2: ( ( (lv_inverse_0_0= Tilde ) )? ( ( ruleQualifiedName ) ) ( ( (lv_transitiveClosure_2_0= RULE_TRANSITIVE_CLOSURE ) ) | ( (lv_reflexiveTransitiveClosure_3_0= RULE_REFLEXIVE_TRANSITIVE_CLOSURE ) ) )? ) | ||
7860 | { | ||
7861 | // InternalSolverLanguageParser.g:3122:2: ( ( (lv_inverse_0_0= Tilde ) )? ( ( ruleQualifiedName ) ) ( ( (lv_transitiveClosure_2_0= RULE_TRANSITIVE_CLOSURE ) ) | ( (lv_reflexiveTransitiveClosure_3_0= RULE_REFLEXIVE_TRANSITIVE_CLOSURE ) ) )? ) | ||
7862 | // InternalSolverLanguageParser.g:3123:3: ( (lv_inverse_0_0= Tilde ) )? ( ( ruleQualifiedName ) ) ( ( (lv_transitiveClosure_2_0= RULE_TRANSITIVE_CLOSURE ) ) | ( (lv_reflexiveTransitiveClosure_3_0= RULE_REFLEXIVE_TRANSITIVE_CLOSURE ) ) )? | ||
7863 | { | ||
7864 | // InternalSolverLanguageParser.g:3123:3: ( (lv_inverse_0_0= Tilde ) )? | ||
7865 | int alt36=2; | ||
7866 | int LA36_0 = input.LA(1); | ||
7867 | |||
7868 | if ( (LA36_0==Tilde) ) { | ||
7869 | alt36=1; | ||
7870 | } | ||
7871 | switch (alt36) { | ||
7872 | case 1 : | ||
7873 | // InternalSolverLanguageParser.g:3124:4: (lv_inverse_0_0= Tilde ) | ||
7874 | { | ||
7875 | // InternalSolverLanguageParser.g:3124:4: (lv_inverse_0_0= Tilde ) | ||
7876 | // InternalSolverLanguageParser.g:3125:5: lv_inverse_0_0= Tilde | ||
7877 | { | ||
7878 | lv_inverse_0_0=(Token)match(input,Tilde,FOLLOW_3); | ||
7879 | |||
7880 | newLeafNode(lv_inverse_0_0, grammarAccess.getPathComponentAccess().getInverseTildeKeyword_0_0()); | ||
7881 | |||
7882 | |||
7883 | if (current==null) { | ||
7884 | current = createModelElement(grammarAccess.getPathComponentRule()); | ||
7885 | } | ||
7886 | setWithLastConsumed(current, "inverse", true, "~"); | ||
7887 | |||
7888 | |||
7889 | } | ||
7890 | |||
7891 | |||
7892 | } | ||
7893 | break; | ||
7894 | |||
7895 | } | ||
7896 | |||
7897 | // InternalSolverLanguageParser.g:3137:3: ( ( ruleQualifiedName ) ) | ||
7898 | // InternalSolverLanguageParser.g:3138:4: ( ruleQualifiedName ) | ||
7899 | { | ||
7900 | // InternalSolverLanguageParser.g:3138:4: ( ruleQualifiedName ) | ||
7901 | // InternalSolverLanguageParser.g:3139:5: ruleQualifiedName | ||
7902 | { | ||
7903 | |||
7904 | if (current==null) { | ||
7905 | current = createModelElement(grammarAccess.getPathComponentRule()); | ||
7906 | } | ||
7907 | |||
7908 | |||
7909 | newCompositeNode(grammarAccess.getPathComponentAccess().getSymbolSymbolCrossReference_1_0()); | ||
7910 | |||
7911 | pushFollow(FOLLOW_47); | ||
7912 | ruleQualifiedName(); | ||
7913 | |||
7914 | state._fsp--; | ||
7915 | |||
7916 | |||
7917 | afterParserOrEnumRuleCall(); | ||
7918 | |||
7919 | |||
7920 | } | ||
7921 | |||
7922 | |||
7923 | } | ||
7924 | |||
7925 | // InternalSolverLanguageParser.g:3153:3: ( ( (lv_transitiveClosure_2_0= RULE_TRANSITIVE_CLOSURE ) ) | ( (lv_reflexiveTransitiveClosure_3_0= RULE_REFLEXIVE_TRANSITIVE_CLOSURE ) ) )? | ||
7926 | int alt37=3; | ||
7927 | int LA37_0 = input.LA(1); | ||
7928 | |||
7929 | if ( (LA37_0==RULE_TRANSITIVE_CLOSURE) ) { | ||
7930 | alt37=1; | ||
7931 | } | ||
7932 | else if ( (LA37_0==RULE_REFLEXIVE_TRANSITIVE_CLOSURE) ) { | ||
7933 | alt37=2; | ||
7934 | } | ||
7935 | switch (alt37) { | ||
7936 | case 1 : | ||
7937 | // InternalSolverLanguageParser.g:3154:4: ( (lv_transitiveClosure_2_0= RULE_TRANSITIVE_CLOSURE ) ) | ||
7938 | { | ||
7939 | // InternalSolverLanguageParser.g:3154:4: ( (lv_transitiveClosure_2_0= RULE_TRANSITIVE_CLOSURE ) ) | ||
7940 | // InternalSolverLanguageParser.g:3155:5: (lv_transitiveClosure_2_0= RULE_TRANSITIVE_CLOSURE ) | ||
7941 | { | ||
7942 | // InternalSolverLanguageParser.g:3155:5: (lv_transitiveClosure_2_0= RULE_TRANSITIVE_CLOSURE ) | ||
7943 | // InternalSolverLanguageParser.g:3156:6: lv_transitiveClosure_2_0= RULE_TRANSITIVE_CLOSURE | ||
7944 | { | ||
7945 | lv_transitiveClosure_2_0=(Token)match(input,RULE_TRANSITIVE_CLOSURE,FOLLOW_2); | ||
7946 | |||
7947 | newLeafNode(lv_transitiveClosure_2_0, grammarAccess.getPathComponentAccess().getTransitiveClosureTRANSITIVE_CLOSURETerminalRuleCall_2_0_0()); | ||
7948 | |||
7949 | |||
7950 | if (current==null) { | ||
7951 | current = createModelElement(grammarAccess.getPathComponentRule()); | ||
7952 | } | ||
7953 | setWithLastConsumed( | ||
7954 | current, | ||
7955 | "transitiveClosure", | ||
7956 | true, | ||
7957 | "org.eclipse.viatra.solver.language.SolverLanguage.TRANSITIVE_CLOSURE"); | ||
7958 | |||
7959 | |||
7960 | } | ||
7961 | |||
7962 | |||
7963 | } | ||
7964 | |||
7965 | |||
7966 | } | ||
7967 | break; | ||
7968 | case 2 : | ||
7969 | // InternalSolverLanguageParser.g:3173:4: ( (lv_reflexiveTransitiveClosure_3_0= RULE_REFLEXIVE_TRANSITIVE_CLOSURE ) ) | ||
7970 | { | ||
7971 | // InternalSolverLanguageParser.g:3173:4: ( (lv_reflexiveTransitiveClosure_3_0= RULE_REFLEXIVE_TRANSITIVE_CLOSURE ) ) | ||
7972 | // InternalSolverLanguageParser.g:3174:5: (lv_reflexiveTransitiveClosure_3_0= RULE_REFLEXIVE_TRANSITIVE_CLOSURE ) | ||
7973 | { | ||
7974 | // InternalSolverLanguageParser.g:3174:5: (lv_reflexiveTransitiveClosure_3_0= RULE_REFLEXIVE_TRANSITIVE_CLOSURE ) | ||
7975 | // InternalSolverLanguageParser.g:3175:6: lv_reflexiveTransitiveClosure_3_0= RULE_REFLEXIVE_TRANSITIVE_CLOSURE | ||
7976 | { | ||
7977 | lv_reflexiveTransitiveClosure_3_0=(Token)match(input,RULE_REFLEXIVE_TRANSITIVE_CLOSURE,FOLLOW_2); | ||
7978 | |||
7979 | newLeafNode(lv_reflexiveTransitiveClosure_3_0, grammarAccess.getPathComponentAccess().getReflexiveTransitiveClosureREFLEXIVE_TRANSITIVE_CLOSURETerminalRuleCall_2_1_0()); | ||
7980 | |||
7981 | |||
7982 | if (current==null) { | ||
7983 | current = createModelElement(grammarAccess.getPathComponentRule()); | ||
7984 | } | ||
7985 | setWithLastConsumed( | ||
7986 | current, | ||
7987 | "reflexiveTransitiveClosure", | ||
7988 | true, | ||
7989 | "org.eclipse.viatra.solver.language.SolverLanguage.REFLEXIVE_TRANSITIVE_CLOSURE"); | ||
7990 | |||
7991 | |||
7992 | } | ||
7993 | |||
7994 | |||
7995 | } | ||
7996 | |||
7997 | |||
7998 | } | ||
7999 | break; | ||
8000 | |||
8001 | } | ||
8002 | |||
8003 | |||
8004 | } | ||
8005 | |||
8006 | |||
8007 | } | ||
8008 | |||
8009 | |||
8010 | leaveRule(); | ||
8011 | |||
8012 | } | ||
8013 | |||
8014 | catch (RecognitionException re) { | ||
8015 | recover(input,re); | ||
8016 | appendSkippedTokens(); | ||
8017 | } | ||
8018 | finally { | ||
8019 | } | ||
8020 | return current; | ||
8021 | } | ||
8022 | // $ANTLR end "rulePathComponent" | ||
8023 | |||
8024 | |||
8025 | // $ANTLR start "entryRuleInterval" | ||
8026 | // InternalSolverLanguageParser.g:3196:1: entryRuleInterval returns [EObject current=null] : iv_ruleInterval= ruleInterval EOF ; | ||
8027 | public final EObject entryRuleInterval() throws RecognitionException { | ||
8028 | EObject current = null; | ||
8029 | |||
8030 | EObject iv_ruleInterval = null; | ||
8031 | |||
8032 | |||
8033 | try { | ||
8034 | // InternalSolverLanguageParser.g:3196:49: (iv_ruleInterval= ruleInterval EOF ) | ||
8035 | // InternalSolverLanguageParser.g:3197:2: iv_ruleInterval= ruleInterval EOF | ||
8036 | { | ||
8037 | newCompositeNode(grammarAccess.getIntervalRule()); | ||
8038 | pushFollow(FOLLOW_1); | ||
8039 | iv_ruleInterval=ruleInterval(); | ||
8040 | |||
8041 | state._fsp--; | ||
8042 | |||
8043 | current =iv_ruleInterval; | ||
8044 | match(input,EOF,FOLLOW_2); | ||
8045 | |||
8046 | } | ||
8047 | |||
8048 | } | ||
8049 | |||
8050 | catch (RecognitionException re) { | ||
8051 | recover(input,re); | ||
8052 | appendSkippedTokens(); | ||
8053 | } | ||
8054 | finally { | ||
8055 | } | ||
8056 | return current; | ||
8057 | } | ||
8058 | // $ANTLR end "entryRuleInterval" | ||
8059 | |||
8060 | |||
8061 | // $ANTLR start "ruleInterval" | ||
8062 | // InternalSolverLanguageParser.g:3203:1: ruleInterval returns [EObject current=null] : (otherlv_0= LeftSquareBracket ( (lv_lowerBound_1_0= ruleAdditiveExpression ) ) otherlv_2= Comma ( (lv_upperBound_3_0= ruleAdditiveExpression ) ) otherlv_4= RightSquareBracket ) ; | ||
8063 | public final EObject ruleInterval() throws RecognitionException { | ||
8064 | EObject current = null; | ||
8065 | |||
8066 | Token otherlv_0=null; | ||
8067 | Token otherlv_2=null; | ||
8068 | Token otherlv_4=null; | ||
8069 | EObject lv_lowerBound_1_0 = null; | ||
8070 | |||
8071 | EObject lv_upperBound_3_0 = null; | ||
8072 | |||
8073 | |||
8074 | |||
8075 | enterRule(); | ||
8076 | |||
8077 | try { | ||
8078 | // InternalSolverLanguageParser.g:3209:2: ( (otherlv_0= LeftSquareBracket ( (lv_lowerBound_1_0= ruleAdditiveExpression ) ) otherlv_2= Comma ( (lv_upperBound_3_0= ruleAdditiveExpression ) ) otherlv_4= RightSquareBracket ) ) | ||
8079 | // InternalSolverLanguageParser.g:3210:2: (otherlv_0= LeftSquareBracket ( (lv_lowerBound_1_0= ruleAdditiveExpression ) ) otherlv_2= Comma ( (lv_upperBound_3_0= ruleAdditiveExpression ) ) otherlv_4= RightSquareBracket ) | ||
8080 | { | ||
8081 | // InternalSolverLanguageParser.g:3210:2: (otherlv_0= LeftSquareBracket ( (lv_lowerBound_1_0= ruleAdditiveExpression ) ) otherlv_2= Comma ( (lv_upperBound_3_0= ruleAdditiveExpression ) ) otherlv_4= RightSquareBracket ) | ||
8082 | // InternalSolverLanguageParser.g:3211:3: otherlv_0= LeftSquareBracket ( (lv_lowerBound_1_0= ruleAdditiveExpression ) ) otherlv_2= Comma ( (lv_upperBound_3_0= ruleAdditiveExpression ) ) otherlv_4= RightSquareBracket | ||
8083 | { | ||
8084 | otherlv_0=(Token)match(input,LeftSquareBracket,FOLLOW_10); | ||
8085 | |||
8086 | newLeafNode(otherlv_0, grammarAccess.getIntervalAccess().getLeftSquareBracketKeyword_0()); | ||
8087 | |||
8088 | // InternalSolverLanguageParser.g:3215:3: ( (lv_lowerBound_1_0= ruleAdditiveExpression ) ) | ||
8089 | // InternalSolverLanguageParser.g:3216:4: (lv_lowerBound_1_0= ruleAdditiveExpression ) | ||
8090 | { | ||
8091 | // InternalSolverLanguageParser.g:3216:4: (lv_lowerBound_1_0= ruleAdditiveExpression ) | ||
8092 | // InternalSolverLanguageParser.g:3217:5: lv_lowerBound_1_0= ruleAdditiveExpression | ||
8093 | { | ||
8094 | |||
8095 | newCompositeNode(grammarAccess.getIntervalAccess().getLowerBoundAdditiveExpressionParserRuleCall_1_0()); | ||
8096 | |||
8097 | pushFollow(FOLLOW_48); | ||
8098 | lv_lowerBound_1_0=ruleAdditiveExpression(); | ||
8099 | |||
8100 | state._fsp--; | ||
8101 | |||
8102 | |||
8103 | if (current==null) { | ||
8104 | current = createModelElementForParent(grammarAccess.getIntervalRule()); | ||
8105 | } | ||
8106 | set( | ||
8107 | current, | ||
8108 | "lowerBound", | ||
8109 | lv_lowerBound_1_0, | ||
8110 | "org.eclipse.viatra.solver.language.SolverLanguage.AdditiveExpression"); | ||
8111 | afterParserOrEnumRuleCall(); | ||
8112 | |||
8113 | |||
8114 | } | ||
8115 | |||
8116 | |||
8117 | } | ||
8118 | |||
8119 | otherlv_2=(Token)match(input,Comma,FOLLOW_10); | ||
8120 | |||
8121 | newLeafNode(otherlv_2, grammarAccess.getIntervalAccess().getCommaKeyword_2()); | ||
8122 | |||
8123 | // InternalSolverLanguageParser.g:3238:3: ( (lv_upperBound_3_0= ruleAdditiveExpression ) ) | ||
8124 | // InternalSolverLanguageParser.g:3239:4: (lv_upperBound_3_0= ruleAdditiveExpression ) | ||
8125 | { | ||
8126 | // InternalSolverLanguageParser.g:3239:4: (lv_upperBound_3_0= ruleAdditiveExpression ) | ||
8127 | // InternalSolverLanguageParser.g:3240:5: lv_upperBound_3_0= ruleAdditiveExpression | ||
8128 | { | ||
8129 | |||
8130 | newCompositeNode(grammarAccess.getIntervalAccess().getUpperBoundAdditiveExpressionParserRuleCall_3_0()); | ||
8131 | |||
8132 | pushFollow(FOLLOW_49); | ||
8133 | lv_upperBound_3_0=ruleAdditiveExpression(); | ||
8134 | |||
8135 | state._fsp--; | ||
8136 | |||
8137 | |||
8138 | if (current==null) { | ||
8139 | current = createModelElementForParent(grammarAccess.getIntervalRule()); | ||
8140 | } | ||
8141 | set( | ||
8142 | current, | ||
8143 | "upperBound", | ||
8144 | lv_upperBound_3_0, | ||
8145 | "org.eclipse.viatra.solver.language.SolverLanguage.AdditiveExpression"); | ||
8146 | afterParserOrEnumRuleCall(); | ||
8147 | |||
8148 | |||
8149 | } | ||
8150 | |||
8151 | |||
8152 | } | ||
8153 | |||
8154 | otherlv_4=(Token)match(input,RightSquareBracket,FOLLOW_2); | ||
8155 | |||
8156 | newLeafNode(otherlv_4, grammarAccess.getIntervalAccess().getRightSquareBracketKeyword_4()); | ||
8157 | |||
8158 | |||
8159 | } | ||
8160 | |||
8161 | |||
8162 | } | ||
8163 | |||
8164 | |||
8165 | leaveRule(); | ||
8166 | |||
8167 | } | ||
8168 | |||
8169 | catch (RecognitionException re) { | ||
8170 | recover(input,re); | ||
8171 | appendSkippedTokens(); | ||
8172 | } | ||
8173 | finally { | ||
8174 | } | ||
8175 | return current; | ||
8176 | } | ||
8177 | // $ANTLR end "ruleInterval" | ||
8178 | |||
8179 | |||
8180 | // $ANTLR start "entryRuleLiteral" | ||
8181 | // InternalSolverLanguageParser.g:3265:1: entryRuleLiteral returns [EObject current=null] : iv_ruleLiteral= ruleLiteral EOF ; | ||
8182 | public final EObject entryRuleLiteral() throws RecognitionException { | ||
8183 | EObject current = null; | ||
8184 | |||
8185 | EObject iv_ruleLiteral = null; | ||
8186 | |||
8187 | |||
8188 | try { | ||
8189 | // InternalSolverLanguageParser.g:3265:48: (iv_ruleLiteral= ruleLiteral EOF ) | ||
8190 | // InternalSolverLanguageParser.g:3266:2: iv_ruleLiteral= ruleLiteral EOF | ||
8191 | { | ||
8192 | newCompositeNode(grammarAccess.getLiteralRule()); | ||
8193 | pushFollow(FOLLOW_1); | ||
8194 | iv_ruleLiteral=ruleLiteral(); | ||
8195 | |||
8196 | state._fsp--; | ||
8197 | |||
8198 | current =iv_ruleLiteral; | ||
8199 | match(input,EOF,FOLLOW_2); | ||
8200 | |||
8201 | } | ||
8202 | |||
8203 | } | ||
8204 | |||
8205 | catch (RecognitionException re) { | ||
8206 | recover(input,re); | ||
8207 | appendSkippedTokens(); | ||
8208 | } | ||
8209 | finally { | ||
8210 | } | ||
8211 | return current; | ||
8212 | } | ||
8213 | // $ANTLR end "entryRuleLiteral" | ||
8214 | |||
8215 | |||
8216 | // $ANTLR start "ruleLiteral" | ||
8217 | // InternalSolverLanguageParser.g:3272:1: ruleLiteral returns [EObject current=null] : (this_LogicLiteral_0= ruleLogicLiteral | this_IntLiteral_1= ruleIntLiteral | this_RealLiteral_2= ruleRealLiteral | this_InfinityLiteral_3= ruleInfinityLiteral | this_EmptyLiteral_4= ruleEmptyLiteral | this_StringLiteral_5= ruleStringLiteral ) ; | ||
8218 | public final EObject ruleLiteral() throws RecognitionException { | ||
8219 | EObject current = null; | ||
8220 | |||
8221 | EObject this_LogicLiteral_0 = null; | ||
8222 | |||
8223 | EObject this_IntLiteral_1 = null; | ||
8224 | |||
8225 | EObject this_RealLiteral_2 = null; | ||
8226 | |||
8227 | EObject this_InfinityLiteral_3 = null; | ||
8228 | |||
8229 | EObject this_EmptyLiteral_4 = null; | ||
8230 | |||
8231 | EObject this_StringLiteral_5 = null; | ||
8232 | |||
8233 | |||
8234 | |||
8235 | enterRule(); | ||
8236 | |||
8237 | try { | ||
8238 | // InternalSolverLanguageParser.g:3278:2: ( (this_LogicLiteral_0= ruleLogicLiteral | this_IntLiteral_1= ruleIntLiteral | this_RealLiteral_2= ruleRealLiteral | this_InfinityLiteral_3= ruleInfinityLiteral | this_EmptyLiteral_4= ruleEmptyLiteral | this_StringLiteral_5= ruleStringLiteral ) ) | ||
8239 | // InternalSolverLanguageParser.g:3279:2: (this_LogicLiteral_0= ruleLogicLiteral | this_IntLiteral_1= ruleIntLiteral | this_RealLiteral_2= ruleRealLiteral | this_InfinityLiteral_3= ruleInfinityLiteral | this_EmptyLiteral_4= ruleEmptyLiteral | this_StringLiteral_5= ruleStringLiteral ) | ||
8240 | { | ||
8241 | // InternalSolverLanguageParser.g:3279:2: (this_LogicLiteral_0= ruleLogicLiteral | this_IntLiteral_1= ruleIntLiteral | this_RealLiteral_2= ruleRealLiteral | this_InfinityLiteral_3= ruleInfinityLiteral | this_EmptyLiteral_4= ruleEmptyLiteral | this_StringLiteral_5= ruleStringLiteral ) | ||
8242 | int alt38=6; | ||
8243 | switch ( input.LA(1) ) { | ||
8244 | case Unknown: | ||
8245 | case Error: | ||
8246 | case False: | ||
8247 | case True: | ||
8248 | { | ||
8249 | alt38=1; | ||
8250 | } | ||
8251 | break; | ||
8252 | case RULE_INT: | ||
8253 | { | ||
8254 | int LA38_2 = input.LA(2); | ||
8255 | |||
8256 | if ( (LA38_2==EOF||LA38_2==Else||LA38_2==Then||(LA38_2>=ExclamationMarkEqualsSign && LA38_2<=ColonHyphenMinus)||(LA38_2>=ColonEqualsSign && LA38_2<=As)||LA38_2==In||(LA38_2>=RightParenthesis && LA38_2<=HyphenMinus)||(LA38_2>=Solidus && LA38_2<=LessThanSign)||LA38_2==GreaterThanSign||(LA38_2>=RightSquareBracket && LA38_2<=CircumflexAccent)||(LA38_2>=VerticalLine && LA38_2<=RightCurlyBracket)||LA38_2==RULE_FULL_STOP) ) { | ||
8257 | alt38=2; | ||
8258 | } | ||
8259 | else if ( (LA38_2==FullStop) ) { | ||
8260 | alt38=3; | ||
8261 | } | ||
8262 | else { | ||
8263 | NoViableAltException nvae = | ||
8264 | new NoViableAltException("", 38, 2, input); | ||
8265 | |||
8266 | throw nvae; | ||
8267 | } | ||
8268 | } | ||
8269 | break; | ||
8270 | case Inf: | ||
8271 | { | ||
8272 | alt38=4; | ||
8273 | } | ||
8274 | break; | ||
8275 | case Empty: | ||
8276 | { | ||
8277 | alt38=5; | ||
8278 | } | ||
8279 | break; | ||
8280 | case RULE_STRING: | ||
8281 | { | ||
8282 | alt38=6; | ||
8283 | } | ||
8284 | break; | ||
8285 | default: | ||
8286 | NoViableAltException nvae = | ||
8287 | new NoViableAltException("", 38, 0, input); | ||
8288 | |||
8289 | throw nvae; | ||
8290 | } | ||
8291 | |||
8292 | switch (alt38) { | ||
8293 | case 1 : | ||
8294 | // InternalSolverLanguageParser.g:3280:3: this_LogicLiteral_0= ruleLogicLiteral | ||
8295 | { | ||
8296 | |||
8297 | newCompositeNode(grammarAccess.getLiteralAccess().getLogicLiteralParserRuleCall_0()); | ||
8298 | |||
8299 | pushFollow(FOLLOW_2); | ||
8300 | this_LogicLiteral_0=ruleLogicLiteral(); | ||
8301 | |||
8302 | state._fsp--; | ||
8303 | |||
8304 | |||
8305 | current = this_LogicLiteral_0; | ||
8306 | afterParserOrEnumRuleCall(); | ||
8307 | |||
8308 | |||
8309 | } | ||
8310 | break; | ||
8311 | case 2 : | ||
8312 | // InternalSolverLanguageParser.g:3289:3: this_IntLiteral_1= ruleIntLiteral | ||
8313 | { | ||
8314 | |||
8315 | newCompositeNode(grammarAccess.getLiteralAccess().getIntLiteralParserRuleCall_1()); | ||
8316 | |||
8317 | pushFollow(FOLLOW_2); | ||
8318 | this_IntLiteral_1=ruleIntLiteral(); | ||
8319 | |||
8320 | state._fsp--; | ||
8321 | |||
8322 | |||
8323 | current = this_IntLiteral_1; | ||
8324 | afterParserOrEnumRuleCall(); | ||
8325 | |||
8326 | |||
8327 | } | ||
8328 | break; | ||
8329 | case 3 : | ||
8330 | // InternalSolverLanguageParser.g:3298:3: this_RealLiteral_2= ruleRealLiteral | ||
8331 | { | ||
8332 | |||
8333 | newCompositeNode(grammarAccess.getLiteralAccess().getRealLiteralParserRuleCall_2()); | ||
8334 | |||
8335 | pushFollow(FOLLOW_2); | ||
8336 | this_RealLiteral_2=ruleRealLiteral(); | ||
8337 | |||
8338 | state._fsp--; | ||
8339 | |||
8340 | |||
8341 | current = this_RealLiteral_2; | ||
8342 | afterParserOrEnumRuleCall(); | ||
8343 | |||
8344 | |||
8345 | } | ||
8346 | break; | ||
8347 | case 4 : | ||
8348 | // InternalSolverLanguageParser.g:3307:3: this_InfinityLiteral_3= ruleInfinityLiteral | ||
8349 | { | ||
8350 | |||
8351 | newCompositeNode(grammarAccess.getLiteralAccess().getInfinityLiteralParserRuleCall_3()); | ||
8352 | |||
8353 | pushFollow(FOLLOW_2); | ||
8354 | this_InfinityLiteral_3=ruleInfinityLiteral(); | ||
8355 | |||
8356 | state._fsp--; | ||
8357 | |||
8358 | |||
8359 | current = this_InfinityLiteral_3; | ||
8360 | afterParserOrEnumRuleCall(); | ||
8361 | |||
8362 | |||
8363 | } | ||
8364 | break; | ||
8365 | case 5 : | ||
8366 | // InternalSolverLanguageParser.g:3316:3: this_EmptyLiteral_4= ruleEmptyLiteral | ||
8367 | { | ||
8368 | |||
8369 | newCompositeNode(grammarAccess.getLiteralAccess().getEmptyLiteralParserRuleCall_4()); | ||
8370 | |||
8371 | pushFollow(FOLLOW_2); | ||
8372 | this_EmptyLiteral_4=ruleEmptyLiteral(); | ||
8373 | |||
8374 | state._fsp--; | ||
8375 | |||
8376 | |||
8377 | current = this_EmptyLiteral_4; | ||
8378 | afterParserOrEnumRuleCall(); | ||
8379 | |||
8380 | |||
8381 | } | ||
8382 | break; | ||
8383 | case 6 : | ||
8384 | // InternalSolverLanguageParser.g:3325:3: this_StringLiteral_5= ruleStringLiteral | ||
8385 | { | ||
8386 | |||
8387 | newCompositeNode(grammarAccess.getLiteralAccess().getStringLiteralParserRuleCall_5()); | ||
8388 | |||
8389 | pushFollow(FOLLOW_2); | ||
8390 | this_StringLiteral_5=ruleStringLiteral(); | ||
8391 | |||
8392 | state._fsp--; | ||
8393 | |||
8394 | |||
8395 | current = this_StringLiteral_5; | ||
8396 | afterParserOrEnumRuleCall(); | ||
8397 | |||
8398 | |||
8399 | } | ||
8400 | break; | ||
8401 | |||
8402 | } | ||
8403 | |||
8404 | |||
8405 | } | ||
8406 | |||
8407 | |||
8408 | leaveRule(); | ||
8409 | |||
8410 | } | ||
8411 | |||
8412 | catch (RecognitionException re) { | ||
8413 | recover(input,re); | ||
8414 | appendSkippedTokens(); | ||
8415 | } | ||
8416 | finally { | ||
8417 | } | ||
8418 | return current; | ||
8419 | } | ||
8420 | // $ANTLR end "ruleLiteral" | ||
8421 | |||
8422 | |||
8423 | // $ANTLR start "entryRuleLogicLiteral" | ||
8424 | // InternalSolverLanguageParser.g:3337:1: entryRuleLogicLiteral returns [EObject current=null] : iv_ruleLogicLiteral= ruleLogicLiteral EOF ; | ||
8425 | public final EObject entryRuleLogicLiteral() throws RecognitionException { | ||
8426 | EObject current = null; | ||
8427 | |||
8428 | EObject iv_ruleLogicLiteral = null; | ||
8429 | |||
8430 | |||
8431 | try { | ||
8432 | // InternalSolverLanguageParser.g:3337:53: (iv_ruleLogicLiteral= ruleLogicLiteral EOF ) | ||
8433 | // InternalSolverLanguageParser.g:3338:2: iv_ruleLogicLiteral= ruleLogicLiteral EOF | ||
8434 | { | ||
8435 | newCompositeNode(grammarAccess.getLogicLiteralRule()); | ||
8436 | pushFollow(FOLLOW_1); | ||
8437 | iv_ruleLogicLiteral=ruleLogicLiteral(); | ||
8438 | |||
8439 | state._fsp--; | ||
8440 | |||
8441 | current =iv_ruleLogicLiteral; | ||
8442 | match(input,EOF,FOLLOW_2); | ||
8443 | |||
8444 | } | ||
8445 | |||
8446 | } | ||
8447 | |||
8448 | catch (RecognitionException re) { | ||
8449 | recover(input,re); | ||
8450 | appendSkippedTokens(); | ||
8451 | } | ||
8452 | finally { | ||
8453 | } | ||
8454 | return current; | ||
8455 | } | ||
8456 | // $ANTLR end "entryRuleLogicLiteral" | ||
8457 | |||
8458 | |||
8459 | // $ANTLR start "ruleLogicLiteral" | ||
8460 | // InternalSolverLanguageParser.g:3344:1: ruleLogicLiteral returns [EObject current=null] : ( (lv_value_0_0= ruleLogicValue ) ) ; | ||
8461 | public final EObject ruleLogicLiteral() throws RecognitionException { | ||
8462 | EObject current = null; | ||
8463 | |||
8464 | Enumerator lv_value_0_0 = null; | ||
8465 | |||
8466 | |||
8467 | |||
8468 | enterRule(); | ||
8469 | |||
8470 | try { | ||
8471 | // InternalSolverLanguageParser.g:3350:2: ( ( (lv_value_0_0= ruleLogicValue ) ) ) | ||
8472 | // InternalSolverLanguageParser.g:3351:2: ( (lv_value_0_0= ruleLogicValue ) ) | ||
8473 | { | ||
8474 | // InternalSolverLanguageParser.g:3351:2: ( (lv_value_0_0= ruleLogicValue ) ) | ||
8475 | // InternalSolverLanguageParser.g:3352:3: (lv_value_0_0= ruleLogicValue ) | ||
8476 | { | ||
8477 | // InternalSolverLanguageParser.g:3352:3: (lv_value_0_0= ruleLogicValue ) | ||
8478 | // InternalSolverLanguageParser.g:3353:4: lv_value_0_0= ruleLogicValue | ||
8479 | { | ||
8480 | |||
8481 | newCompositeNode(grammarAccess.getLogicLiteralAccess().getValueLogicValueEnumRuleCall_0()); | ||
8482 | |||
8483 | pushFollow(FOLLOW_2); | ||
8484 | lv_value_0_0=ruleLogicValue(); | ||
8485 | |||
8486 | state._fsp--; | ||
8487 | |||
8488 | |||
8489 | if (current==null) { | ||
8490 | current = createModelElementForParent(grammarAccess.getLogicLiteralRule()); | ||
8491 | } | ||
8492 | set( | ||
8493 | current, | ||
8494 | "value", | ||
8495 | lv_value_0_0, | ||
8496 | "org.eclipse.viatra.solver.language.SolverLanguage.LogicValue"); | ||
8497 | afterParserOrEnumRuleCall(); | ||
8498 | |||
8499 | |||
8500 | } | ||
8501 | |||
8502 | |||
8503 | } | ||
8504 | |||
8505 | |||
8506 | } | ||
8507 | |||
8508 | |||
8509 | leaveRule(); | ||
8510 | |||
8511 | } | ||
8512 | |||
8513 | catch (RecognitionException re) { | ||
8514 | recover(input,re); | ||
8515 | appendSkippedTokens(); | ||
8516 | } | ||
8517 | finally { | ||
8518 | } | ||
8519 | return current; | ||
8520 | } | ||
8521 | // $ANTLR end "ruleLogicLiteral" | ||
8522 | |||
8523 | |||
8524 | // $ANTLR start "entryRuleIntLiteral" | ||
8525 | // InternalSolverLanguageParser.g:3373:1: entryRuleIntLiteral returns [EObject current=null] : iv_ruleIntLiteral= ruleIntLiteral EOF ; | ||
8526 | public final EObject entryRuleIntLiteral() throws RecognitionException { | ||
8527 | EObject current = null; | ||
8528 | |||
8529 | EObject iv_ruleIntLiteral = null; | ||
8530 | |||
8531 | |||
8532 | try { | ||
8533 | // InternalSolverLanguageParser.g:3373:51: (iv_ruleIntLiteral= ruleIntLiteral EOF ) | ||
8534 | // InternalSolverLanguageParser.g:3374:2: iv_ruleIntLiteral= ruleIntLiteral EOF | ||
8535 | { | ||
8536 | newCompositeNode(grammarAccess.getIntLiteralRule()); | ||
8537 | pushFollow(FOLLOW_1); | ||
8538 | iv_ruleIntLiteral=ruleIntLiteral(); | ||
8539 | |||
8540 | state._fsp--; | ||
8541 | |||
8542 | current =iv_ruleIntLiteral; | ||
8543 | match(input,EOF,FOLLOW_2); | ||
8544 | |||
8545 | } | ||
8546 | |||
8547 | } | ||
8548 | |||
8549 | catch (RecognitionException re) { | ||
8550 | recover(input,re); | ||
8551 | appendSkippedTokens(); | ||
8552 | } | ||
8553 | finally { | ||
8554 | } | ||
8555 | return current; | ||
8556 | } | ||
8557 | // $ANTLR end "entryRuleIntLiteral" | ||
8558 | |||
8559 | |||
8560 | // $ANTLR start "ruleIntLiteral" | ||
8561 | // InternalSolverLanguageParser.g:3380:1: ruleIntLiteral returns [EObject current=null] : ( (lv_value_0_0= RULE_INT ) ) ; | ||
8562 | public final EObject ruleIntLiteral() throws RecognitionException { | ||
8563 | EObject current = null; | ||
8564 | |||
8565 | Token lv_value_0_0=null; | ||
8566 | |||
8567 | |||
8568 | enterRule(); | ||
8569 | |||
8570 | try { | ||
8571 | // InternalSolverLanguageParser.g:3386:2: ( ( (lv_value_0_0= RULE_INT ) ) ) | ||
8572 | // InternalSolverLanguageParser.g:3387:2: ( (lv_value_0_0= RULE_INT ) ) | ||
8573 | { | ||
8574 | // InternalSolverLanguageParser.g:3387:2: ( (lv_value_0_0= RULE_INT ) ) | ||
8575 | // InternalSolverLanguageParser.g:3388:3: (lv_value_0_0= RULE_INT ) | ||
8576 | { | ||
8577 | // InternalSolverLanguageParser.g:3388:3: (lv_value_0_0= RULE_INT ) | ||
8578 | // InternalSolverLanguageParser.g:3389:4: lv_value_0_0= RULE_INT | ||
8579 | { | ||
8580 | lv_value_0_0=(Token)match(input,RULE_INT,FOLLOW_2); | ||
8581 | |||
8582 | newLeafNode(lv_value_0_0, grammarAccess.getIntLiteralAccess().getValueINTTerminalRuleCall_0()); | ||
8583 | |||
8584 | |||
8585 | if (current==null) { | ||
8586 | current = createModelElement(grammarAccess.getIntLiteralRule()); | ||
8587 | } | ||
8588 | setWithLastConsumed( | ||
8589 | current, | ||
8590 | "value", | ||
8591 | lv_value_0_0, | ||
8592 | "org.eclipse.xtext.common.Terminals.INT"); | ||
8593 | |||
8594 | |||
8595 | } | ||
8596 | |||
8597 | |||
8598 | } | ||
8599 | |||
8600 | |||
8601 | } | ||
8602 | |||
8603 | |||
8604 | leaveRule(); | ||
8605 | |||
8606 | } | ||
8607 | |||
8608 | catch (RecognitionException re) { | ||
8609 | recover(input,re); | ||
8610 | appendSkippedTokens(); | ||
8611 | } | ||
8612 | finally { | ||
8613 | } | ||
8614 | return current; | ||
8615 | } | ||
8616 | // $ANTLR end "ruleIntLiteral" | ||
8617 | |||
8618 | |||
8619 | // $ANTLR start "entryRuleRealLiteral" | ||
8620 | // InternalSolverLanguageParser.g:3408:1: entryRuleRealLiteral returns [EObject current=null] : iv_ruleRealLiteral= ruleRealLiteral EOF ; | ||
8621 | public final EObject entryRuleRealLiteral() throws RecognitionException { | ||
8622 | EObject current = null; | ||
8623 | |||
8624 | EObject iv_ruleRealLiteral = null; | ||
8625 | |||
8626 | |||
8627 | try { | ||
8628 | // InternalSolverLanguageParser.g:3408:52: (iv_ruleRealLiteral= ruleRealLiteral EOF ) | ||
8629 | // InternalSolverLanguageParser.g:3409:2: iv_ruleRealLiteral= ruleRealLiteral EOF | ||
8630 | { | ||
8631 | newCompositeNode(grammarAccess.getRealLiteralRule()); | ||
8632 | pushFollow(FOLLOW_1); | ||
8633 | iv_ruleRealLiteral=ruleRealLiteral(); | ||
8634 | |||
8635 | state._fsp--; | ||
8636 | |||
8637 | current =iv_ruleRealLiteral; | ||
8638 | match(input,EOF,FOLLOW_2); | ||
8639 | |||
8640 | } | ||
8641 | |||
8642 | } | ||
8643 | |||
8644 | catch (RecognitionException re) { | ||
8645 | recover(input,re); | ||
8646 | appendSkippedTokens(); | ||
8647 | } | ||
8648 | finally { | ||
8649 | } | ||
8650 | return current; | ||
8651 | } | ||
8652 | // $ANTLR end "entryRuleRealLiteral" | ||
8653 | |||
8654 | |||
8655 | // $ANTLR start "ruleRealLiteral" | ||
8656 | // InternalSolverLanguageParser.g:3415:1: ruleRealLiteral returns [EObject current=null] : ( (lv_value_0_0= ruleReal ) ) ; | ||
8657 | public final EObject ruleRealLiteral() throws RecognitionException { | ||
8658 | EObject current = null; | ||
8659 | |||
8660 | AntlrDatatypeRuleToken lv_value_0_0 = null; | ||
8661 | |||
8662 | |||
8663 | |||
8664 | enterRule(); | ||
8665 | |||
8666 | try { | ||
8667 | // InternalSolverLanguageParser.g:3421:2: ( ( (lv_value_0_0= ruleReal ) ) ) | ||
8668 | // InternalSolverLanguageParser.g:3422:2: ( (lv_value_0_0= ruleReal ) ) | ||
8669 | { | ||
8670 | // InternalSolverLanguageParser.g:3422:2: ( (lv_value_0_0= ruleReal ) ) | ||
8671 | // InternalSolverLanguageParser.g:3423:3: (lv_value_0_0= ruleReal ) | ||
8672 | { | ||
8673 | // InternalSolverLanguageParser.g:3423:3: (lv_value_0_0= ruleReal ) | ||
8674 | // InternalSolverLanguageParser.g:3424:4: lv_value_0_0= ruleReal | ||
8675 | { | ||
8676 | |||
8677 | newCompositeNode(grammarAccess.getRealLiteralAccess().getValueRealParserRuleCall_0()); | ||
8678 | |||
8679 | pushFollow(FOLLOW_2); | ||
8680 | lv_value_0_0=ruleReal(); | ||
8681 | |||
8682 | state._fsp--; | ||
8683 | |||
8684 | |||
8685 | if (current==null) { | ||
8686 | current = createModelElementForParent(grammarAccess.getRealLiteralRule()); | ||
8687 | } | ||
8688 | set( | ||
8689 | current, | ||
8690 | "value", | ||
8691 | lv_value_0_0, | ||
8692 | "org.eclipse.viatra.solver.language.SolverLanguage.Real"); | ||
8693 | afterParserOrEnumRuleCall(); | ||
8694 | |||
8695 | |||
8696 | } | ||
8697 | |||
8698 | |||
8699 | } | ||
8700 | |||
8701 | |||
8702 | } | ||
8703 | |||
8704 | |||
8705 | leaveRule(); | ||
8706 | |||
8707 | } | ||
8708 | |||
8709 | catch (RecognitionException re) { | ||
8710 | recover(input,re); | ||
8711 | appendSkippedTokens(); | ||
8712 | } | ||
8713 | finally { | ||
8714 | } | ||
8715 | return current; | ||
8716 | } | ||
8717 | // $ANTLR end "ruleRealLiteral" | ||
8718 | |||
8719 | |||
8720 | // $ANTLR start "entryRuleInfinityLiteral" | ||
8721 | // InternalSolverLanguageParser.g:3444:1: entryRuleInfinityLiteral returns [EObject current=null] : iv_ruleInfinityLiteral= ruleInfinityLiteral EOF ; | ||
8722 | public final EObject entryRuleInfinityLiteral() throws RecognitionException { | ||
8723 | EObject current = null; | ||
8724 | |||
8725 | EObject iv_ruleInfinityLiteral = null; | ||
8726 | |||
8727 | |||
8728 | try { | ||
8729 | // InternalSolverLanguageParser.g:3444:56: (iv_ruleInfinityLiteral= ruleInfinityLiteral EOF ) | ||
8730 | // InternalSolverLanguageParser.g:3445:2: iv_ruleInfinityLiteral= ruleInfinityLiteral EOF | ||
8731 | { | ||
8732 | newCompositeNode(grammarAccess.getInfinityLiteralRule()); | ||
8733 | pushFollow(FOLLOW_1); | ||
8734 | iv_ruleInfinityLiteral=ruleInfinityLiteral(); | ||
8735 | |||
8736 | state._fsp--; | ||
8737 | |||
8738 | current =iv_ruleInfinityLiteral; | ||
8739 | match(input,EOF,FOLLOW_2); | ||
8740 | |||
8741 | } | ||
8742 | |||
8743 | } | ||
8744 | |||
8745 | catch (RecognitionException re) { | ||
8746 | recover(input,re); | ||
8747 | appendSkippedTokens(); | ||
8748 | } | ||
8749 | finally { | ||
8750 | } | ||
8751 | return current; | ||
8752 | } | ||
8753 | // $ANTLR end "entryRuleInfinityLiteral" | ||
8754 | |||
8755 | |||
8756 | // $ANTLR start "ruleInfinityLiteral" | ||
8757 | // InternalSolverLanguageParser.g:3451:1: ruleInfinityLiteral returns [EObject current=null] : ( () otherlv_1= Inf ) ; | ||
8758 | public final EObject ruleInfinityLiteral() throws RecognitionException { | ||
8759 | EObject current = null; | ||
8760 | |||
8761 | Token otherlv_1=null; | ||
8762 | |||
8763 | |||
8764 | enterRule(); | ||
8765 | |||
8766 | try { | ||
8767 | // InternalSolverLanguageParser.g:3457:2: ( ( () otherlv_1= Inf ) ) | ||
8768 | // InternalSolverLanguageParser.g:3458:2: ( () otherlv_1= Inf ) | ||
8769 | { | ||
8770 | // InternalSolverLanguageParser.g:3458:2: ( () otherlv_1= Inf ) | ||
8771 | // InternalSolverLanguageParser.g:3459:3: () otherlv_1= Inf | ||
8772 | { | ||
8773 | // InternalSolverLanguageParser.g:3459:3: () | ||
8774 | // InternalSolverLanguageParser.g:3460:4: | ||
8775 | { | ||
8776 | |||
8777 | current = forceCreateModelElement( | ||
8778 | grammarAccess.getInfinityLiteralAccess().getInfinityLiteralAction_0(), | ||
8779 | current); | ||
8780 | |||
8781 | |||
8782 | } | ||
8783 | |||
8784 | otherlv_1=(Token)match(input,Inf,FOLLOW_2); | ||
8785 | |||
8786 | newLeafNode(otherlv_1, grammarAccess.getInfinityLiteralAccess().getInfKeyword_1()); | ||
8787 | |||
8788 | |||
8789 | } | ||
8790 | |||
8791 | |||
8792 | } | ||
8793 | |||
8794 | |||
8795 | leaveRule(); | ||
8796 | |||
8797 | } | ||
8798 | |||
8799 | catch (RecognitionException re) { | ||
8800 | recover(input,re); | ||
8801 | appendSkippedTokens(); | ||
8802 | } | ||
8803 | finally { | ||
8804 | } | ||
8805 | return current; | ||
8806 | } | ||
8807 | // $ANTLR end "ruleInfinityLiteral" | ||
8808 | |||
8809 | |||
8810 | // $ANTLR start "entryRuleEmptyLiteral" | ||
8811 | // InternalSolverLanguageParser.g:3474:1: entryRuleEmptyLiteral returns [EObject current=null] : iv_ruleEmptyLiteral= ruleEmptyLiteral EOF ; | ||
8812 | public final EObject entryRuleEmptyLiteral() throws RecognitionException { | ||
8813 | EObject current = null; | ||
8814 | |||
8815 | EObject iv_ruleEmptyLiteral = null; | ||
8816 | |||
8817 | |||
8818 | try { | ||
8819 | // InternalSolverLanguageParser.g:3474:53: (iv_ruleEmptyLiteral= ruleEmptyLiteral EOF ) | ||
8820 | // InternalSolverLanguageParser.g:3475:2: iv_ruleEmptyLiteral= ruleEmptyLiteral EOF | ||
8821 | { | ||
8822 | newCompositeNode(grammarAccess.getEmptyLiteralRule()); | ||
8823 | pushFollow(FOLLOW_1); | ||
8824 | iv_ruleEmptyLiteral=ruleEmptyLiteral(); | ||
8825 | |||
8826 | state._fsp--; | ||
8827 | |||
8828 | current =iv_ruleEmptyLiteral; | ||
8829 | match(input,EOF,FOLLOW_2); | ||
8830 | |||
8831 | } | ||
8832 | |||
8833 | } | ||
8834 | |||
8835 | catch (RecognitionException re) { | ||
8836 | recover(input,re); | ||
8837 | appendSkippedTokens(); | ||
8838 | } | ||
8839 | finally { | ||
8840 | } | ||
8841 | return current; | ||
8842 | } | ||
8843 | // $ANTLR end "entryRuleEmptyLiteral" | ||
8844 | |||
8845 | |||
8846 | // $ANTLR start "ruleEmptyLiteral" | ||
8847 | // InternalSolverLanguageParser.g:3481:1: ruleEmptyLiteral returns [EObject current=null] : ( () otherlv_1= Empty ) ; | ||
8848 | public final EObject ruleEmptyLiteral() throws RecognitionException { | ||
8849 | EObject current = null; | ||
8850 | |||
8851 | Token otherlv_1=null; | ||
8852 | |||
8853 | |||
8854 | enterRule(); | ||
8855 | |||
8856 | try { | ||
8857 | // InternalSolverLanguageParser.g:3487:2: ( ( () otherlv_1= Empty ) ) | ||
8858 | // InternalSolverLanguageParser.g:3488:2: ( () otherlv_1= Empty ) | ||
8859 | { | ||
8860 | // InternalSolverLanguageParser.g:3488:2: ( () otherlv_1= Empty ) | ||
8861 | // InternalSolverLanguageParser.g:3489:3: () otherlv_1= Empty | ||
8862 | { | ||
8863 | // InternalSolverLanguageParser.g:3489:3: () | ||
8864 | // InternalSolverLanguageParser.g:3490:4: | ||
8865 | { | ||
8866 | |||
8867 | current = forceCreateModelElement( | ||
8868 | grammarAccess.getEmptyLiteralAccess().getEmptyLiteralAction_0(), | ||
8869 | current); | ||
8870 | |||
8871 | |||
8872 | } | ||
8873 | |||
8874 | otherlv_1=(Token)match(input,Empty,FOLLOW_2); | ||
8875 | |||
8876 | newLeafNode(otherlv_1, grammarAccess.getEmptyLiteralAccess().getEmptyKeyword_1()); | ||
8877 | |||
8878 | |||
8879 | } | ||
8880 | |||
8881 | |||
8882 | } | ||
8883 | |||
8884 | |||
8885 | leaveRule(); | ||
8886 | |||
8887 | } | ||
8888 | |||
8889 | catch (RecognitionException re) { | ||
8890 | recover(input,re); | ||
8891 | appendSkippedTokens(); | ||
8892 | } | ||
8893 | finally { | ||
8894 | } | ||
8895 | return current; | ||
8896 | } | ||
8897 | // $ANTLR end "ruleEmptyLiteral" | ||
8898 | |||
8899 | |||
8900 | // $ANTLR start "entryRuleStringLiteral" | ||
8901 | // InternalSolverLanguageParser.g:3504:1: entryRuleStringLiteral returns [EObject current=null] : iv_ruleStringLiteral= ruleStringLiteral EOF ; | ||
8902 | public final EObject entryRuleStringLiteral() throws RecognitionException { | ||
8903 | EObject current = null; | ||
8904 | |||
8905 | EObject iv_ruleStringLiteral = null; | ||
8906 | |||
8907 | |||
8908 | try { | ||
8909 | // InternalSolverLanguageParser.g:3504:54: (iv_ruleStringLiteral= ruleStringLiteral EOF ) | ||
8910 | // InternalSolverLanguageParser.g:3505:2: iv_ruleStringLiteral= ruleStringLiteral EOF | ||
8911 | { | ||
8912 | newCompositeNode(grammarAccess.getStringLiteralRule()); | ||
8913 | pushFollow(FOLLOW_1); | ||
8914 | iv_ruleStringLiteral=ruleStringLiteral(); | ||
8915 | |||
8916 | state._fsp--; | ||
8917 | |||
8918 | current =iv_ruleStringLiteral; | ||
8919 | match(input,EOF,FOLLOW_2); | ||
8920 | |||
8921 | } | ||
8922 | |||
8923 | } | ||
8924 | |||
8925 | catch (RecognitionException re) { | ||
8926 | recover(input,re); | ||
8927 | appendSkippedTokens(); | ||
8928 | } | ||
8929 | finally { | ||
8930 | } | ||
8931 | return current; | ||
8932 | } | ||
8933 | // $ANTLR end "entryRuleStringLiteral" | ||
8934 | |||
8935 | |||
8936 | // $ANTLR start "ruleStringLiteral" | ||
8937 | // InternalSolverLanguageParser.g:3511:1: ruleStringLiteral returns [EObject current=null] : ( (lv_value_0_0= RULE_STRING ) ) ; | ||
8938 | public final EObject ruleStringLiteral() throws RecognitionException { | ||
8939 | EObject current = null; | ||
8940 | |||
8941 | Token lv_value_0_0=null; | ||
8942 | |||
8943 | |||
8944 | enterRule(); | ||
8945 | |||
8946 | try { | ||
8947 | // InternalSolverLanguageParser.g:3517:2: ( ( (lv_value_0_0= RULE_STRING ) ) ) | ||
8948 | // InternalSolverLanguageParser.g:3518:2: ( (lv_value_0_0= RULE_STRING ) ) | ||
8949 | { | ||
8950 | // InternalSolverLanguageParser.g:3518:2: ( (lv_value_0_0= RULE_STRING ) ) | ||
8951 | // InternalSolverLanguageParser.g:3519:3: (lv_value_0_0= RULE_STRING ) | ||
8952 | { | ||
8953 | // InternalSolverLanguageParser.g:3519:3: (lv_value_0_0= RULE_STRING ) | ||
8954 | // InternalSolverLanguageParser.g:3520:4: lv_value_0_0= RULE_STRING | ||
8955 | { | ||
8956 | lv_value_0_0=(Token)match(input,RULE_STRING,FOLLOW_2); | ||
8957 | |||
8958 | newLeafNode(lv_value_0_0, grammarAccess.getStringLiteralAccess().getValueSTRINGTerminalRuleCall_0()); | ||
8959 | |||
8960 | |||
8961 | if (current==null) { | ||
8962 | current = createModelElement(grammarAccess.getStringLiteralRule()); | ||
8963 | } | ||
8964 | setWithLastConsumed( | ||
8965 | current, | ||
8966 | "value", | ||
8967 | lv_value_0_0, | ||
8968 | "org.eclipse.viatra.solver.language.SolverLanguage.STRING"); | ||
8969 | |||
8970 | |||
8971 | } | ||
8972 | |||
8973 | |||
8974 | } | ||
8975 | |||
8976 | |||
8977 | } | ||
8978 | |||
8979 | |||
8980 | leaveRule(); | ||
8981 | |||
8982 | } | ||
8983 | |||
8984 | catch (RecognitionException re) { | ||
8985 | recover(input,re); | ||
8986 | appendSkippedTokens(); | ||
8987 | } | ||
8988 | finally { | ||
8989 | } | ||
8990 | return current; | ||
8991 | } | ||
8992 | // $ANTLR end "ruleStringLiteral" | ||
8993 | |||
8994 | |||
8995 | // $ANTLR start "entryRuleClassDeclaration" | ||
8996 | // InternalSolverLanguageParser.g:3539:1: entryRuleClassDeclaration returns [EObject current=null] : iv_ruleClassDeclaration= ruleClassDeclaration EOF ; | ||
8997 | public final EObject entryRuleClassDeclaration() throws RecognitionException { | ||
8998 | EObject current = null; | ||
8999 | |||
9000 | EObject iv_ruleClassDeclaration = null; | ||
9001 | |||
9002 | |||
9003 | try { | ||
9004 | // InternalSolverLanguageParser.g:3539:57: (iv_ruleClassDeclaration= ruleClassDeclaration EOF ) | ||
9005 | // InternalSolverLanguageParser.g:3540:2: iv_ruleClassDeclaration= ruleClassDeclaration EOF | ||
9006 | { | ||
9007 | newCompositeNode(grammarAccess.getClassDeclarationRule()); | ||
9008 | pushFollow(FOLLOW_1); | ||
9009 | iv_ruleClassDeclaration=ruleClassDeclaration(); | ||
9010 | |||
9011 | state._fsp--; | ||
9012 | |||
9013 | current =iv_ruleClassDeclaration; | ||
9014 | match(input,EOF,FOLLOW_2); | ||
9015 | |||
9016 | } | ||
9017 | |||
9018 | } | ||
9019 | |||
9020 | catch (RecognitionException re) { | ||
9021 | recover(input,re); | ||
9022 | appendSkippedTokens(); | ||
9023 | } | ||
9024 | finally { | ||
9025 | } | ||
9026 | return current; | ||
9027 | } | ||
9028 | // $ANTLR end "entryRuleClassDeclaration" | ||
9029 | |||
9030 | |||
9031 | // $ANTLR start "ruleClassDeclaration" | ||
9032 | // InternalSolverLanguageParser.g:3546:1: ruleClassDeclaration returns [EObject current=null] : ( ( ( ( ( ({...}? => ( ({...}? => ( (lv_abstract_1_0= Abstract ) ) ) ) ) | ({...}? => ( ({...}? => ( (lv_root_2_0= Root ) ) ) ) ) )* ) ) ) otherlv_3= Class ( (lv_name_4_0= RULE_ID ) ) (otherlv_5= Extends ( ( ruleQualifiedName ) ) (otherlv_7= Comma ( ( ruleQualifiedName ) ) )* )? ( (otherlv_9= LeftCurlyBracket ( (lv_fields_10_0= ruleField ) )* otherlv_11= RightCurlyBracket ) | this_FULL_STOP_12= RULE_FULL_STOP ) ) ; | ||
9033 | public final EObject ruleClassDeclaration() throws RecognitionException { | ||
9034 | EObject current = null; | ||
9035 | |||
9036 | Token lv_abstract_1_0=null; | ||
9037 | Token lv_root_2_0=null; | ||
9038 | Token otherlv_3=null; | ||
9039 | Token lv_name_4_0=null; | ||
9040 | Token otherlv_5=null; | ||
9041 | Token otherlv_7=null; | ||
9042 | Token otherlv_9=null; | ||
9043 | Token otherlv_11=null; | ||
9044 | Token this_FULL_STOP_12=null; | ||
9045 | EObject lv_fields_10_0 = null; | ||
9046 | |||
9047 | |||
9048 | |||
9049 | enterRule(); | ||
9050 | |||
9051 | try { | ||
9052 | // InternalSolverLanguageParser.g:3552:2: ( ( ( ( ( ( ({...}? => ( ({...}? => ( (lv_abstract_1_0= Abstract ) ) ) ) ) | ({...}? => ( ({...}? => ( (lv_root_2_0= Root ) ) ) ) ) )* ) ) ) otherlv_3= Class ( (lv_name_4_0= RULE_ID ) ) (otherlv_5= Extends ( ( ruleQualifiedName ) ) (otherlv_7= Comma ( ( ruleQualifiedName ) ) )* )? ( (otherlv_9= LeftCurlyBracket ( (lv_fields_10_0= ruleField ) )* otherlv_11= RightCurlyBracket ) | this_FULL_STOP_12= RULE_FULL_STOP ) ) ) | ||
9053 | // InternalSolverLanguageParser.g:3553:2: ( ( ( ( ( ({...}? => ( ({...}? => ( (lv_abstract_1_0= Abstract ) ) ) ) ) | ({...}? => ( ({...}? => ( (lv_root_2_0= Root ) ) ) ) ) )* ) ) ) otherlv_3= Class ( (lv_name_4_0= RULE_ID ) ) (otherlv_5= Extends ( ( ruleQualifiedName ) ) (otherlv_7= Comma ( ( ruleQualifiedName ) ) )* )? ( (otherlv_9= LeftCurlyBracket ( (lv_fields_10_0= ruleField ) )* otherlv_11= RightCurlyBracket ) | this_FULL_STOP_12= RULE_FULL_STOP ) ) | ||
9054 | { | ||
9055 | // InternalSolverLanguageParser.g:3553:2: ( ( ( ( ( ({...}? => ( ({...}? => ( (lv_abstract_1_0= Abstract ) ) ) ) ) | ({...}? => ( ({...}? => ( (lv_root_2_0= Root ) ) ) ) ) )* ) ) ) otherlv_3= Class ( (lv_name_4_0= RULE_ID ) ) (otherlv_5= Extends ( ( ruleQualifiedName ) ) (otherlv_7= Comma ( ( ruleQualifiedName ) ) )* )? ( (otherlv_9= LeftCurlyBracket ( (lv_fields_10_0= ruleField ) )* otherlv_11= RightCurlyBracket ) | this_FULL_STOP_12= RULE_FULL_STOP ) ) | ||
9056 | // InternalSolverLanguageParser.g:3554:3: ( ( ( ( ({...}? => ( ({...}? => ( (lv_abstract_1_0= Abstract ) ) ) ) ) | ({...}? => ( ({...}? => ( (lv_root_2_0= Root ) ) ) ) ) )* ) ) ) otherlv_3= Class ( (lv_name_4_0= RULE_ID ) ) (otherlv_5= Extends ( ( ruleQualifiedName ) ) (otherlv_7= Comma ( ( ruleQualifiedName ) ) )* )? ( (otherlv_9= LeftCurlyBracket ( (lv_fields_10_0= ruleField ) )* otherlv_11= RightCurlyBracket ) | this_FULL_STOP_12= RULE_FULL_STOP ) | ||
9057 | { | ||
9058 | // InternalSolverLanguageParser.g:3554:3: ( ( ( ( ({...}? => ( ({...}? => ( (lv_abstract_1_0= Abstract ) ) ) ) ) | ({...}? => ( ({...}? => ( (lv_root_2_0= Root ) ) ) ) ) )* ) ) ) | ||
9059 | // InternalSolverLanguageParser.g:3555:4: ( ( ( ({...}? => ( ({...}? => ( (lv_abstract_1_0= Abstract ) ) ) ) ) | ({...}? => ( ({...}? => ( (lv_root_2_0= Root ) ) ) ) ) )* ) ) | ||
9060 | { | ||
9061 | // InternalSolverLanguageParser.g:3555:4: ( ( ( ({...}? => ( ({...}? => ( (lv_abstract_1_0= Abstract ) ) ) ) ) | ({...}? => ( ({...}? => ( (lv_root_2_0= Root ) ) ) ) ) )* ) ) | ||
9062 | // InternalSolverLanguageParser.g:3556:5: ( ( ({...}? => ( ({...}? => ( (lv_abstract_1_0= Abstract ) ) ) ) ) | ({...}? => ( ({...}? => ( (lv_root_2_0= Root ) ) ) ) ) )* ) | ||
9063 | { | ||
9064 | |||
9065 | getUnorderedGroupHelper().enter(grammarAccess.getClassDeclarationAccess().getUnorderedGroup_0()); | ||
9066 | |||
9067 | // InternalSolverLanguageParser.g:3559:5: ( ( ({...}? => ( ({...}? => ( (lv_abstract_1_0= Abstract ) ) ) ) ) | ({...}? => ( ({...}? => ( (lv_root_2_0= Root ) ) ) ) ) )* ) | ||
9068 | // InternalSolverLanguageParser.g:3560:6: ( ({...}? => ( ({...}? => ( (lv_abstract_1_0= Abstract ) ) ) ) ) | ({...}? => ( ({...}? => ( (lv_root_2_0= Root ) ) ) ) ) )* | ||
9069 | { | ||
9070 | // InternalSolverLanguageParser.g:3560:6: ( ({...}? => ( ({...}? => ( (lv_abstract_1_0= Abstract ) ) ) ) ) | ({...}? => ( ({...}? => ( (lv_root_2_0= Root ) ) ) ) ) )* | ||
9071 | loop39: | ||
9072 | do { | ||
9073 | int alt39=3; | ||
9074 | int LA39_0 = input.LA(1); | ||
9075 | |||
9076 | if ( LA39_0 == Abstract && getUnorderedGroupHelper().canSelect(grammarAccess.getClassDeclarationAccess().getUnorderedGroup_0(), 0) ) { | ||
9077 | alt39=1; | ||
9078 | } | ||
9079 | else if ( LA39_0 == Root && getUnorderedGroupHelper().canSelect(grammarAccess.getClassDeclarationAccess().getUnorderedGroup_0(), 1) ) { | ||
9080 | alt39=2; | ||
9081 | } | ||
9082 | |||
9083 | |||
9084 | switch (alt39) { | ||
9085 | case 1 : | ||
9086 | // InternalSolverLanguageParser.g:3561:4: ({...}? => ( ({...}? => ( (lv_abstract_1_0= Abstract ) ) ) ) ) | ||
9087 | { | ||
9088 | // InternalSolverLanguageParser.g:3561:4: ({...}? => ( ({...}? => ( (lv_abstract_1_0= Abstract ) ) ) ) ) | ||
9089 | // InternalSolverLanguageParser.g:3562:5: {...}? => ( ({...}? => ( (lv_abstract_1_0= Abstract ) ) ) ) | ||
9090 | { | ||
9091 | if ( ! getUnorderedGroupHelper().canSelect(grammarAccess.getClassDeclarationAccess().getUnorderedGroup_0(), 0) ) { | ||
9092 | throw new FailedPredicateException(input, "ruleClassDeclaration", "getUnorderedGroupHelper().canSelect(grammarAccess.getClassDeclarationAccess().getUnorderedGroup_0(), 0)"); | ||
9093 | } | ||
9094 | // InternalSolverLanguageParser.g:3562:113: ( ({...}? => ( (lv_abstract_1_0= Abstract ) ) ) ) | ||
9095 | // InternalSolverLanguageParser.g:3563:6: ({...}? => ( (lv_abstract_1_0= Abstract ) ) ) | ||
9096 | { | ||
9097 | |||
9098 | getUnorderedGroupHelper().select(grammarAccess.getClassDeclarationAccess().getUnorderedGroup_0(), 0); | ||
9099 | |||
9100 | // InternalSolverLanguageParser.g:3566:9: ({...}? => ( (lv_abstract_1_0= Abstract ) ) ) | ||
9101 | // InternalSolverLanguageParser.g:3566:10: {...}? => ( (lv_abstract_1_0= Abstract ) ) | ||
9102 | { | ||
9103 | if ( !((true)) ) { | ||
9104 | throw new FailedPredicateException(input, "ruleClassDeclaration", "true"); | ||
9105 | } | ||
9106 | // InternalSolverLanguageParser.g:3566:19: ( (lv_abstract_1_0= Abstract ) ) | ||
9107 | // InternalSolverLanguageParser.g:3566:20: (lv_abstract_1_0= Abstract ) | ||
9108 | { | ||
9109 | // InternalSolverLanguageParser.g:3566:20: (lv_abstract_1_0= Abstract ) | ||
9110 | // InternalSolverLanguageParser.g:3567:10: lv_abstract_1_0= Abstract | ||
9111 | { | ||
9112 | lv_abstract_1_0=(Token)match(input,Abstract,FOLLOW_50); | ||
9113 | |||
9114 | newLeafNode(lv_abstract_1_0, grammarAccess.getClassDeclarationAccess().getAbstractAbstractKeyword_0_0_0()); | ||
9115 | |||
9116 | |||
9117 | if (current==null) { | ||
9118 | current = createModelElement(grammarAccess.getClassDeclarationRule()); | ||
9119 | } | ||
9120 | setWithLastConsumed(current, "abstract", true, "abstract"); | ||
9121 | |||
9122 | |||
9123 | } | ||
9124 | |||
9125 | |||
9126 | } | ||
9127 | |||
9128 | |||
9129 | } | ||
9130 | |||
9131 | |||
9132 | getUnorderedGroupHelper().returnFromSelection(grammarAccess.getClassDeclarationAccess().getUnorderedGroup_0()); | ||
9133 | |||
9134 | |||
9135 | } | ||
9136 | |||
9137 | |||
9138 | } | ||
9139 | |||
9140 | |||
9141 | } | ||
9142 | break; | ||
9143 | case 2 : | ||
9144 | // InternalSolverLanguageParser.g:3584:4: ({...}? => ( ({...}? => ( (lv_root_2_0= Root ) ) ) ) ) | ||
9145 | { | ||
9146 | // InternalSolverLanguageParser.g:3584:4: ({...}? => ( ({...}? => ( (lv_root_2_0= Root ) ) ) ) ) | ||
9147 | // InternalSolverLanguageParser.g:3585:5: {...}? => ( ({...}? => ( (lv_root_2_0= Root ) ) ) ) | ||
9148 | { | ||
9149 | if ( ! getUnorderedGroupHelper().canSelect(grammarAccess.getClassDeclarationAccess().getUnorderedGroup_0(), 1) ) { | ||
9150 | throw new FailedPredicateException(input, "ruleClassDeclaration", "getUnorderedGroupHelper().canSelect(grammarAccess.getClassDeclarationAccess().getUnorderedGroup_0(), 1)"); | ||
9151 | } | ||
9152 | // InternalSolverLanguageParser.g:3585:113: ( ({...}? => ( (lv_root_2_0= Root ) ) ) ) | ||
9153 | // InternalSolverLanguageParser.g:3586:6: ({...}? => ( (lv_root_2_0= Root ) ) ) | ||
9154 | { | ||
9155 | |||
9156 | getUnorderedGroupHelper().select(grammarAccess.getClassDeclarationAccess().getUnorderedGroup_0(), 1); | ||
9157 | |||
9158 | // InternalSolverLanguageParser.g:3589:9: ({...}? => ( (lv_root_2_0= Root ) ) ) | ||
9159 | // InternalSolverLanguageParser.g:3589:10: {...}? => ( (lv_root_2_0= Root ) ) | ||
9160 | { | ||
9161 | if ( !((true)) ) { | ||
9162 | throw new FailedPredicateException(input, "ruleClassDeclaration", "true"); | ||
9163 | } | ||
9164 | // InternalSolverLanguageParser.g:3589:19: ( (lv_root_2_0= Root ) ) | ||
9165 | // InternalSolverLanguageParser.g:3589:20: (lv_root_2_0= Root ) | ||
9166 | { | ||
9167 | // InternalSolverLanguageParser.g:3589:20: (lv_root_2_0= Root ) | ||
9168 | // InternalSolverLanguageParser.g:3590:10: lv_root_2_0= Root | ||
9169 | { | ||
9170 | lv_root_2_0=(Token)match(input,Root,FOLLOW_50); | ||
9171 | |||
9172 | newLeafNode(lv_root_2_0, grammarAccess.getClassDeclarationAccess().getRootRootKeyword_0_1_0()); | ||
9173 | |||
9174 | |||
9175 | if (current==null) { | ||
9176 | current = createModelElement(grammarAccess.getClassDeclarationRule()); | ||
9177 | } | ||
9178 | setWithLastConsumed(current, "root", true, "root"); | ||
9179 | |||
9180 | |||
9181 | } | ||
9182 | |||
9183 | |||
9184 | } | ||
9185 | |||
9186 | |||
9187 | } | ||
9188 | |||
9189 | |||
9190 | getUnorderedGroupHelper().returnFromSelection(grammarAccess.getClassDeclarationAccess().getUnorderedGroup_0()); | ||
9191 | |||
9192 | |||
9193 | } | ||
9194 | |||
9195 | |||
9196 | } | ||
9197 | |||
9198 | |||
9199 | } | ||
9200 | break; | ||
9201 | |||
9202 | default : | ||
9203 | break loop39; | ||
9204 | } | ||
9205 | } while (true); | ||
9206 | |||
9207 | |||
9208 | } | ||
9209 | |||
9210 | |||
9211 | } | ||
9212 | |||
9213 | |||
9214 | getUnorderedGroupHelper().leave(grammarAccess.getClassDeclarationAccess().getUnorderedGroup_0()); | ||
9215 | |||
9216 | |||
9217 | } | ||
9218 | |||
9219 | otherlv_3=(Token)match(input,Class,FOLLOW_28); | ||
9220 | |||
9221 | newLeafNode(otherlv_3, grammarAccess.getClassDeclarationAccess().getClassKeyword_1()); | ||
9222 | |||
9223 | // InternalSolverLanguageParser.g:3618:3: ( (lv_name_4_0= RULE_ID ) ) | ||
9224 | // InternalSolverLanguageParser.g:3619:4: (lv_name_4_0= RULE_ID ) | ||
9225 | { | ||
9226 | // InternalSolverLanguageParser.g:3619:4: (lv_name_4_0= RULE_ID ) | ||
9227 | // InternalSolverLanguageParser.g:3620:5: lv_name_4_0= RULE_ID | ||
9228 | { | ||
9229 | lv_name_4_0=(Token)match(input,RULE_ID,FOLLOW_51); | ||
9230 | |||
9231 | newLeafNode(lv_name_4_0, grammarAccess.getClassDeclarationAccess().getNameIDTerminalRuleCall_2_0()); | ||
9232 | |||
9233 | |||
9234 | if (current==null) { | ||
9235 | current = createModelElement(grammarAccess.getClassDeclarationRule()); | ||
9236 | } | ||
9237 | setWithLastConsumed( | ||
9238 | current, | ||
9239 | "name", | ||
9240 | lv_name_4_0, | ||
9241 | "org.eclipse.xtext.common.Terminals.ID"); | ||
9242 | |||
9243 | |||
9244 | } | ||
9245 | |||
9246 | |||
9247 | } | ||
9248 | |||
9249 | // InternalSolverLanguageParser.g:3636:3: (otherlv_5= Extends ( ( ruleQualifiedName ) ) (otherlv_7= Comma ( ( ruleQualifiedName ) ) )* )? | ||
9250 | int alt41=2; | ||
9251 | int LA41_0 = input.LA(1); | ||
9252 | |||
9253 | if ( (LA41_0==Extends) ) { | ||
9254 | alt41=1; | ||
9255 | } | ||
9256 | switch (alt41) { | ||
9257 | case 1 : | ||
9258 | // InternalSolverLanguageParser.g:3637:4: otherlv_5= Extends ( ( ruleQualifiedName ) ) (otherlv_7= Comma ( ( ruleQualifiedName ) ) )* | ||
9259 | { | ||
9260 | otherlv_5=(Token)match(input,Extends,FOLLOW_3); | ||
9261 | |||
9262 | newLeafNode(otherlv_5, grammarAccess.getClassDeclarationAccess().getExtendsKeyword_3_0()); | ||
9263 | |||
9264 | // InternalSolverLanguageParser.g:3641:4: ( ( ruleQualifiedName ) ) | ||
9265 | // InternalSolverLanguageParser.g:3642:5: ( ruleQualifiedName ) | ||
9266 | { | ||
9267 | // InternalSolverLanguageParser.g:3642:5: ( ruleQualifiedName ) | ||
9268 | // InternalSolverLanguageParser.g:3643:6: ruleQualifiedName | ||
9269 | { | ||
9270 | |||
9271 | if (current==null) { | ||
9272 | current = createModelElement(grammarAccess.getClassDeclarationRule()); | ||
9273 | } | ||
9274 | |||
9275 | |||
9276 | newCompositeNode(grammarAccess.getClassDeclarationAccess().getSupertypesSymbolCrossReference_3_1_0()); | ||
9277 | |||
9278 | pushFollow(FOLLOW_52); | ||
9279 | ruleQualifiedName(); | ||
9280 | |||
9281 | state._fsp--; | ||
9282 | |||
9283 | |||
9284 | afterParserOrEnumRuleCall(); | ||
9285 | |||
9286 | |||
9287 | } | ||
9288 | |||
9289 | |||
9290 | } | ||
9291 | |||
9292 | // InternalSolverLanguageParser.g:3657:4: (otherlv_7= Comma ( ( ruleQualifiedName ) ) )* | ||
9293 | loop40: | ||
9294 | do { | ||
9295 | int alt40=2; | ||
9296 | int LA40_0 = input.LA(1); | ||
9297 | |||
9298 | if ( (LA40_0==Comma) ) { | ||
9299 | alt40=1; | ||
9300 | } | ||
9301 | |||
9302 | |||
9303 | switch (alt40) { | ||
9304 | case 1 : | ||
9305 | // InternalSolverLanguageParser.g:3658:5: otherlv_7= Comma ( ( ruleQualifiedName ) ) | ||
9306 | { | ||
9307 | otherlv_7=(Token)match(input,Comma,FOLLOW_3); | ||
9308 | |||
9309 | newLeafNode(otherlv_7, grammarAccess.getClassDeclarationAccess().getCommaKeyword_3_2_0()); | ||
9310 | |||
9311 | // InternalSolverLanguageParser.g:3662:5: ( ( ruleQualifiedName ) ) | ||
9312 | // InternalSolverLanguageParser.g:3663:6: ( ruleQualifiedName ) | ||
9313 | { | ||
9314 | // InternalSolverLanguageParser.g:3663:6: ( ruleQualifiedName ) | ||
9315 | // InternalSolverLanguageParser.g:3664:7: ruleQualifiedName | ||
9316 | { | ||
9317 | |||
9318 | if (current==null) { | ||
9319 | current = createModelElement(grammarAccess.getClassDeclarationRule()); | ||
9320 | } | ||
9321 | |||
9322 | |||
9323 | newCompositeNode(grammarAccess.getClassDeclarationAccess().getSupertypesSymbolCrossReference_3_2_1_0()); | ||
9324 | |||
9325 | pushFollow(FOLLOW_52); | ||
9326 | ruleQualifiedName(); | ||
9327 | |||
9328 | state._fsp--; | ||
9329 | |||
9330 | |||
9331 | afterParserOrEnumRuleCall(); | ||
9332 | |||
9333 | |||
9334 | } | ||
9335 | |||
9336 | |||
9337 | } | ||
9338 | |||
9339 | |||
9340 | } | ||
9341 | break; | ||
9342 | |||
9343 | default : | ||
9344 | break loop40; | ||
9345 | } | ||
9346 | } while (true); | ||
9347 | |||
9348 | |||
9349 | } | ||
9350 | break; | ||
9351 | |||
9352 | } | ||
9353 | |||
9354 | // InternalSolverLanguageParser.g:3680:3: ( (otherlv_9= LeftCurlyBracket ( (lv_fields_10_0= ruleField ) )* otherlv_11= RightCurlyBracket ) | this_FULL_STOP_12= RULE_FULL_STOP ) | ||
9355 | int alt43=2; | ||
9356 | int LA43_0 = input.LA(1); | ||
9357 | |||
9358 | if ( (LA43_0==LeftCurlyBracket) ) { | ||
9359 | alt43=1; | ||
9360 | } | ||
9361 | else if ( (LA43_0==RULE_FULL_STOP) ) { | ||
9362 | alt43=2; | ||
9363 | } | ||
9364 | else { | ||
9365 | NoViableAltException nvae = | ||
9366 | new NoViableAltException("", 43, 0, input); | ||
9367 | |||
9368 | throw nvae; | ||
9369 | } | ||
9370 | switch (alt43) { | ||
9371 | case 1 : | ||
9372 | // InternalSolverLanguageParser.g:3681:4: (otherlv_9= LeftCurlyBracket ( (lv_fields_10_0= ruleField ) )* otherlv_11= RightCurlyBracket ) | ||
9373 | { | ||
9374 | // InternalSolverLanguageParser.g:3681:4: (otherlv_9= LeftCurlyBracket ( (lv_fields_10_0= ruleField ) )* otherlv_11= RightCurlyBracket ) | ||
9375 | // InternalSolverLanguageParser.g:3682:5: otherlv_9= LeftCurlyBracket ( (lv_fields_10_0= ruleField ) )* otherlv_11= RightCurlyBracket | ||
9376 | { | ||
9377 | otherlv_9=(Token)match(input,LeftCurlyBracket,FOLLOW_53); | ||
9378 | |||
9379 | newLeafNode(otherlv_9, grammarAccess.getClassDeclarationAccess().getLeftCurlyBracketKeyword_4_0_0()); | ||
9380 | |||
9381 | // InternalSolverLanguageParser.g:3686:5: ( (lv_fields_10_0= ruleField ) )* | ||
9382 | loop42: | ||
9383 | do { | ||
9384 | int alt42=2; | ||
9385 | int LA42_0 = input.LA(1); | ||
9386 | |||
9387 | if ( (LA42_0==Contains||(LA42_0>=Object && LA42_0<=Refers)||LA42_0==RULE_QUOTED_ID||LA42_0==RULE_ID) ) { | ||
9388 | alt42=1; | ||
9389 | } | ||
9390 | |||
9391 | |||
9392 | switch (alt42) { | ||
9393 | case 1 : | ||
9394 | // InternalSolverLanguageParser.g:3687:6: (lv_fields_10_0= ruleField ) | ||
9395 | { | ||
9396 | // InternalSolverLanguageParser.g:3687:6: (lv_fields_10_0= ruleField ) | ||
9397 | // InternalSolverLanguageParser.g:3688:7: lv_fields_10_0= ruleField | ||
9398 | { | ||
9399 | |||
9400 | newCompositeNode(grammarAccess.getClassDeclarationAccess().getFieldsFieldParserRuleCall_4_0_1_0()); | ||
9401 | |||
9402 | pushFollow(FOLLOW_53); | ||
9403 | lv_fields_10_0=ruleField(); | ||
9404 | |||
9405 | state._fsp--; | ||
9406 | |||
9407 | |||
9408 | if (current==null) { | ||
9409 | current = createModelElementForParent(grammarAccess.getClassDeclarationRule()); | ||
9410 | } | ||
9411 | add( | ||
9412 | current, | ||
9413 | "fields", | ||
9414 | lv_fields_10_0, | ||
9415 | "org.eclipse.viatra.solver.language.SolverLanguage.Field"); | ||
9416 | afterParserOrEnumRuleCall(); | ||
9417 | |||
9418 | |||
9419 | } | ||
9420 | |||
9421 | |||
9422 | } | ||
9423 | break; | ||
9424 | |||
9425 | default : | ||
9426 | break loop42; | ||
9427 | } | ||
9428 | } while (true); | ||
9429 | |||
9430 | otherlv_11=(Token)match(input,RightCurlyBracket,FOLLOW_2); | ||
9431 | |||
9432 | newLeafNode(otherlv_11, grammarAccess.getClassDeclarationAccess().getRightCurlyBracketKeyword_4_0_2()); | ||
9433 | |||
9434 | |||
9435 | } | ||
9436 | |||
9437 | |||
9438 | } | ||
9439 | break; | ||
9440 | case 2 : | ||
9441 | // InternalSolverLanguageParser.g:3711:4: this_FULL_STOP_12= RULE_FULL_STOP | ||
9442 | { | ||
9443 | this_FULL_STOP_12=(Token)match(input,RULE_FULL_STOP,FOLLOW_2); | ||
9444 | |||
9445 | newLeafNode(this_FULL_STOP_12, grammarAccess.getClassDeclarationAccess().getFULL_STOPTerminalRuleCall_4_1()); | ||
9446 | |||
9447 | |||
9448 | } | ||
9449 | break; | ||
9450 | |||
9451 | } | ||
9452 | |||
9453 | |||
9454 | } | ||
9455 | |||
9456 | |||
9457 | } | ||
9458 | |||
9459 | |||
9460 | leaveRule(); | ||
9461 | |||
9462 | } | ||
9463 | |||
9464 | catch (RecognitionException re) { | ||
9465 | recover(input,re); | ||
9466 | appendSkippedTokens(); | ||
9467 | } | ||
9468 | finally { | ||
9469 | } | ||
9470 | return current; | ||
9471 | } | ||
9472 | // $ANTLR end "ruleClassDeclaration" | ||
9473 | |||
9474 | |||
9475 | // $ANTLR start "entryRuleField" | ||
9476 | // InternalSolverLanguageParser.g:3720:1: entryRuleField returns [EObject current=null] : iv_ruleField= ruleField EOF ; | ||
9477 | public final EObject entryRuleField() throws RecognitionException { | ||
9478 | EObject current = null; | ||
9479 | |||
9480 | EObject iv_ruleField = null; | ||
9481 | |||
9482 | |||
9483 | try { | ||
9484 | // InternalSolverLanguageParser.g:3720:46: (iv_ruleField= ruleField EOF ) | ||
9485 | // InternalSolverLanguageParser.g:3721:2: iv_ruleField= ruleField EOF | ||
9486 | { | ||
9487 | newCompositeNode(grammarAccess.getFieldRule()); | ||
9488 | pushFollow(FOLLOW_1); | ||
9489 | iv_ruleField=ruleField(); | ||
9490 | |||
9491 | state._fsp--; | ||
9492 | |||
9493 | current =iv_ruleField; | ||
9494 | match(input,EOF,FOLLOW_2); | ||
9495 | |||
9496 | } | ||
9497 | |||
9498 | } | ||
9499 | |||
9500 | catch (RecognitionException re) { | ||
9501 | recover(input,re); | ||
9502 | appendSkippedTokens(); | ||
9503 | } | ||
9504 | finally { | ||
9505 | } | ||
9506 | return current; | ||
9507 | } | ||
9508 | // $ANTLR end "entryRuleField" | ||
9509 | |||
9510 | |||
9511 | // $ANTLR start "ruleField" | ||
9512 | // InternalSolverLanguageParser.g:3727:1: ruleField returns [EObject current=null] : ( ( ( (lv_containment_0_0= Contains ) ) | ( (lv_crossReference_1_0= Refers ) ) )? ( ( ruleQualifiedName ) ) ( (lv_multiplicity_3_0= ruleMultiplicity ) )? ( (lv_name_4_0= RULE_ID ) ) (otherlv_5= Opposite ( ( ruleQualifiedName ) ) )? (otherlv_7= Semicolon )? ) ; | ||
9513 | public final EObject ruleField() throws RecognitionException { | ||
9514 | EObject current = null; | ||
9515 | |||
9516 | Token lv_containment_0_0=null; | ||
9517 | Token lv_crossReference_1_0=null; | ||
9518 | Token lv_name_4_0=null; | ||
9519 | Token otherlv_5=null; | ||
9520 | Token otherlv_7=null; | ||
9521 | EObject lv_multiplicity_3_0 = null; | ||
9522 | |||
9523 | |||
9524 | |||
9525 | enterRule(); | ||
9526 | |||
9527 | try { | ||
9528 | // InternalSolverLanguageParser.g:3733:2: ( ( ( ( (lv_containment_0_0= Contains ) ) | ( (lv_crossReference_1_0= Refers ) ) )? ( ( ruleQualifiedName ) ) ( (lv_multiplicity_3_0= ruleMultiplicity ) )? ( (lv_name_4_0= RULE_ID ) ) (otherlv_5= Opposite ( ( ruleQualifiedName ) ) )? (otherlv_7= Semicolon )? ) ) | ||
9529 | // InternalSolverLanguageParser.g:3734:2: ( ( ( (lv_containment_0_0= Contains ) ) | ( (lv_crossReference_1_0= Refers ) ) )? ( ( ruleQualifiedName ) ) ( (lv_multiplicity_3_0= ruleMultiplicity ) )? ( (lv_name_4_0= RULE_ID ) ) (otherlv_5= Opposite ( ( ruleQualifiedName ) ) )? (otherlv_7= Semicolon )? ) | ||
9530 | { | ||
9531 | // InternalSolverLanguageParser.g:3734:2: ( ( ( (lv_containment_0_0= Contains ) ) | ( (lv_crossReference_1_0= Refers ) ) )? ( ( ruleQualifiedName ) ) ( (lv_multiplicity_3_0= ruleMultiplicity ) )? ( (lv_name_4_0= RULE_ID ) ) (otherlv_5= Opposite ( ( ruleQualifiedName ) ) )? (otherlv_7= Semicolon )? ) | ||
9532 | // InternalSolverLanguageParser.g:3735:3: ( ( (lv_containment_0_0= Contains ) ) | ( (lv_crossReference_1_0= Refers ) ) )? ( ( ruleQualifiedName ) ) ( (lv_multiplicity_3_0= ruleMultiplicity ) )? ( (lv_name_4_0= RULE_ID ) ) (otherlv_5= Opposite ( ( ruleQualifiedName ) ) )? (otherlv_7= Semicolon )? | ||
9533 | { | ||
9534 | // InternalSolverLanguageParser.g:3735:3: ( ( (lv_containment_0_0= Contains ) ) | ( (lv_crossReference_1_0= Refers ) ) )? | ||
9535 | int alt44=3; | ||
9536 | int LA44_0 = input.LA(1); | ||
9537 | |||
9538 | if ( (LA44_0==Contains) ) { | ||
9539 | alt44=1; | ||
9540 | } | ||
9541 | else if ( (LA44_0==Refers) ) { | ||
9542 | alt44=2; | ||
9543 | } | ||
9544 | switch (alt44) { | ||
9545 | case 1 : | ||
9546 | // InternalSolverLanguageParser.g:3736:4: ( (lv_containment_0_0= Contains ) ) | ||
9547 | { | ||
9548 | // InternalSolverLanguageParser.g:3736:4: ( (lv_containment_0_0= Contains ) ) | ||
9549 | // InternalSolverLanguageParser.g:3737:5: (lv_containment_0_0= Contains ) | ||
9550 | { | ||
9551 | // InternalSolverLanguageParser.g:3737:5: (lv_containment_0_0= Contains ) | ||
9552 | // InternalSolverLanguageParser.g:3738:6: lv_containment_0_0= Contains | ||
9553 | { | ||
9554 | lv_containment_0_0=(Token)match(input,Contains,FOLLOW_3); | ||
9555 | |||
9556 | newLeafNode(lv_containment_0_0, grammarAccess.getFieldAccess().getContainmentContainsKeyword_0_0_0()); | ||
9557 | |||
9558 | |||
9559 | if (current==null) { | ||
9560 | current = createModelElement(grammarAccess.getFieldRule()); | ||
9561 | } | ||
9562 | setWithLastConsumed(current, "containment", true, "contains"); | ||
9563 | |||
9564 | |||
9565 | } | ||
9566 | |||
9567 | |||
9568 | } | ||
9569 | |||
9570 | |||
9571 | } | ||
9572 | break; | ||
9573 | case 2 : | ||
9574 | // InternalSolverLanguageParser.g:3751:4: ( (lv_crossReference_1_0= Refers ) ) | ||
9575 | { | ||
9576 | // InternalSolverLanguageParser.g:3751:4: ( (lv_crossReference_1_0= Refers ) ) | ||
9577 | // InternalSolverLanguageParser.g:3752:5: (lv_crossReference_1_0= Refers ) | ||
9578 | { | ||
9579 | // InternalSolverLanguageParser.g:3752:5: (lv_crossReference_1_0= Refers ) | ||
9580 | // InternalSolverLanguageParser.g:3753:6: lv_crossReference_1_0= Refers | ||
9581 | { | ||
9582 | lv_crossReference_1_0=(Token)match(input,Refers,FOLLOW_3); | ||
9583 | |||
9584 | newLeafNode(lv_crossReference_1_0, grammarAccess.getFieldAccess().getCrossReferenceRefersKeyword_0_1_0()); | ||
9585 | |||
9586 | |||
9587 | if (current==null) { | ||
9588 | current = createModelElement(grammarAccess.getFieldRule()); | ||
9589 | } | ||
9590 | setWithLastConsumed(current, "crossReference", true, "refers"); | ||
9591 | |||
9592 | |||
9593 | } | ||
9594 | |||
9595 | |||
9596 | } | ||
9597 | |||
9598 | |||
9599 | } | ||
9600 | break; | ||
9601 | |||
9602 | } | ||
9603 | |||
9604 | // InternalSolverLanguageParser.g:3766:3: ( ( ruleQualifiedName ) ) | ||
9605 | // InternalSolverLanguageParser.g:3767:4: ( ruleQualifiedName ) | ||
9606 | { | ||
9607 | // InternalSolverLanguageParser.g:3767:4: ( ruleQualifiedName ) | ||
9608 | // InternalSolverLanguageParser.g:3768:5: ruleQualifiedName | ||
9609 | { | ||
9610 | |||
9611 | if (current==null) { | ||
9612 | current = createModelElement(grammarAccess.getFieldRule()); | ||
9613 | } | ||
9614 | |||
9615 | |||
9616 | newCompositeNode(grammarAccess.getFieldAccess().getTypeSymbolCrossReference_1_0()); | ||
9617 | |||
9618 | pushFollow(FOLLOW_54); | ||
9619 | ruleQualifiedName(); | ||
9620 | |||
9621 | state._fsp--; | ||
9622 | |||
9623 | |||
9624 | afterParserOrEnumRuleCall(); | ||
9625 | |||
9626 | |||
9627 | } | ||
9628 | |||
9629 | |||
9630 | } | ||
9631 | |||
9632 | // InternalSolverLanguageParser.g:3782:3: ( (lv_multiplicity_3_0= ruleMultiplicity ) )? | ||
9633 | int alt45=2; | ||
9634 | int LA45_0 = input.LA(1); | ||
9635 | |||
9636 | if ( (LA45_0==LeftSquareBracket) ) { | ||
9637 | alt45=1; | ||
9638 | } | ||
9639 | switch (alt45) { | ||
9640 | case 1 : | ||
9641 | // InternalSolverLanguageParser.g:3783:4: (lv_multiplicity_3_0= ruleMultiplicity ) | ||
9642 | { | ||
9643 | // InternalSolverLanguageParser.g:3783:4: (lv_multiplicity_3_0= ruleMultiplicity ) | ||
9644 | // InternalSolverLanguageParser.g:3784:5: lv_multiplicity_3_0= ruleMultiplicity | ||
9645 | { | ||
9646 | |||
9647 | newCompositeNode(grammarAccess.getFieldAccess().getMultiplicityMultiplicityParserRuleCall_2_0()); | ||
9648 | |||
9649 | pushFollow(FOLLOW_28); | ||
9650 | lv_multiplicity_3_0=ruleMultiplicity(); | ||
9651 | |||
9652 | state._fsp--; | ||
9653 | |||
9654 | |||
9655 | if (current==null) { | ||
9656 | current = createModelElementForParent(grammarAccess.getFieldRule()); | ||
9657 | } | ||
9658 | set( | ||
9659 | current, | ||
9660 | "multiplicity", | ||
9661 | lv_multiplicity_3_0, | ||
9662 | "org.eclipse.viatra.solver.language.SolverLanguage.Multiplicity"); | ||
9663 | afterParserOrEnumRuleCall(); | ||
9664 | |||
9665 | |||
9666 | } | ||
9667 | |||
9668 | |||
9669 | } | ||
9670 | break; | ||
9671 | |||
9672 | } | ||
9673 | |||
9674 | // InternalSolverLanguageParser.g:3801:3: ( (lv_name_4_0= RULE_ID ) ) | ||
9675 | // InternalSolverLanguageParser.g:3802:4: (lv_name_4_0= RULE_ID ) | ||
9676 | { | ||
9677 | // InternalSolverLanguageParser.g:3802:4: (lv_name_4_0= RULE_ID ) | ||
9678 | // InternalSolverLanguageParser.g:3803:5: lv_name_4_0= RULE_ID | ||
9679 | { | ||
9680 | lv_name_4_0=(Token)match(input,RULE_ID,FOLLOW_55); | ||
9681 | |||
9682 | newLeafNode(lv_name_4_0, grammarAccess.getFieldAccess().getNameIDTerminalRuleCall_3_0()); | ||
9683 | |||
9684 | |||
9685 | if (current==null) { | ||
9686 | current = createModelElement(grammarAccess.getFieldRule()); | ||
9687 | } | ||
9688 | setWithLastConsumed( | ||
9689 | current, | ||
9690 | "name", | ||
9691 | lv_name_4_0, | ||
9692 | "org.eclipse.xtext.common.Terminals.ID"); | ||
9693 | |||
9694 | |||
9695 | } | ||
9696 | |||
9697 | |||
9698 | } | ||
9699 | |||
9700 | // InternalSolverLanguageParser.g:3819:3: (otherlv_5= Opposite ( ( ruleQualifiedName ) ) )? | ||
9701 | int alt46=2; | ||
9702 | int LA46_0 = input.LA(1); | ||
9703 | |||
9704 | if ( (LA46_0==Opposite) ) { | ||
9705 | alt46=1; | ||
9706 | } | ||
9707 | switch (alt46) { | ||
9708 | case 1 : | ||
9709 | // InternalSolverLanguageParser.g:3820:4: otherlv_5= Opposite ( ( ruleQualifiedName ) ) | ||
9710 | { | ||
9711 | otherlv_5=(Token)match(input,Opposite,FOLLOW_3); | ||
9712 | |||
9713 | newLeafNode(otherlv_5, grammarAccess.getFieldAccess().getOppositeKeyword_4_0()); | ||
9714 | |||
9715 | // InternalSolverLanguageParser.g:3824:4: ( ( ruleQualifiedName ) ) | ||
9716 | // InternalSolverLanguageParser.g:3825:5: ( ruleQualifiedName ) | ||
9717 | { | ||
9718 | // InternalSolverLanguageParser.g:3825:5: ( ruleQualifiedName ) | ||
9719 | // InternalSolverLanguageParser.g:3826:6: ruleQualifiedName | ||
9720 | { | ||
9721 | |||
9722 | if (current==null) { | ||
9723 | current = createModelElement(grammarAccess.getFieldRule()); | ||
9724 | } | ||
9725 | |||
9726 | |||
9727 | newCompositeNode(grammarAccess.getFieldAccess().getOppositeSymbolCrossReference_4_1_0()); | ||
9728 | |||
9729 | pushFollow(FOLLOW_31); | ||
9730 | ruleQualifiedName(); | ||
9731 | |||
9732 | state._fsp--; | ||
9733 | |||
9734 | |||
9735 | afterParserOrEnumRuleCall(); | ||
9736 | |||
9737 | |||
9738 | } | ||
9739 | |||
9740 | |||
9741 | } | ||
9742 | |||
9743 | |||
9744 | } | ||
9745 | break; | ||
9746 | |||
9747 | } | ||
9748 | |||
9749 | // InternalSolverLanguageParser.g:3841:3: (otherlv_7= Semicolon )? | ||
9750 | int alt47=2; | ||
9751 | int LA47_0 = input.LA(1); | ||
9752 | |||
9753 | if ( (LA47_0==Semicolon) ) { | ||
9754 | alt47=1; | ||
9755 | } | ||
9756 | switch (alt47) { | ||
9757 | case 1 : | ||
9758 | // InternalSolverLanguageParser.g:3842:4: otherlv_7= Semicolon | ||
9759 | { | ||
9760 | otherlv_7=(Token)match(input,Semicolon,FOLLOW_2); | ||
9761 | |||
9762 | newLeafNode(otherlv_7, grammarAccess.getFieldAccess().getSemicolonKeyword_5()); | ||
9763 | |||
9764 | |||
9765 | } | ||
9766 | break; | ||
9767 | |||
9768 | } | ||
9769 | |||
9770 | |||
9771 | } | ||
9772 | |||
9773 | |||
9774 | } | ||
9775 | |||
9776 | |||
9777 | leaveRule(); | ||
9778 | |||
9779 | } | ||
9780 | |||
9781 | catch (RecognitionException re) { | ||
9782 | recover(input,re); | ||
9783 | appendSkippedTokens(); | ||
9784 | } | ||
9785 | finally { | ||
9786 | } | ||
9787 | return current; | ||
9788 | } | ||
9789 | // $ANTLR end "ruleField" | ||
9790 | |||
9791 | |||
9792 | // $ANTLR start "entryRuleMultiplicity" | ||
9793 | // InternalSolverLanguageParser.g:3851:1: entryRuleMultiplicity returns [EObject current=null] : iv_ruleMultiplicity= ruleMultiplicity EOF ; | ||
9794 | public final EObject entryRuleMultiplicity() throws RecognitionException { | ||
9795 | EObject current = null; | ||
9796 | |||
9797 | EObject iv_ruleMultiplicity = null; | ||
9798 | |||
9799 | |||
9800 | try { | ||
9801 | // InternalSolverLanguageParser.g:3851:53: (iv_ruleMultiplicity= ruleMultiplicity EOF ) | ||
9802 | // InternalSolverLanguageParser.g:3852:2: iv_ruleMultiplicity= ruleMultiplicity EOF | ||
9803 | { | ||
9804 | newCompositeNode(grammarAccess.getMultiplicityRule()); | ||
9805 | pushFollow(FOLLOW_1); | ||
9806 | iv_ruleMultiplicity=ruleMultiplicity(); | ||
9807 | |||
9808 | state._fsp--; | ||
9809 | |||
9810 | current =iv_ruleMultiplicity; | ||
9811 | match(input,EOF,FOLLOW_2); | ||
9812 | |||
9813 | } | ||
9814 | |||
9815 | } | ||
9816 | |||
9817 | catch (RecognitionException re) { | ||
9818 | recover(input,re); | ||
9819 | appendSkippedTokens(); | ||
9820 | } | ||
9821 | finally { | ||
9822 | } | ||
9823 | return current; | ||
9824 | } | ||
9825 | // $ANTLR end "entryRuleMultiplicity" | ||
9826 | |||
9827 | |||
9828 | // $ANTLR start "ruleMultiplicity" | ||
9829 | // InternalSolverLanguageParser.g:3858:1: ruleMultiplicity returns [EObject current=null] : (this_UnboundedMultiplicity_0= ruleUnboundedMultiplicity | this_ExactMultiplicity_1= ruleExactMultiplicity | this_BoundedMultiplicity_2= ruleBoundedMultiplicity ) ; | ||
9830 | public final EObject ruleMultiplicity() throws RecognitionException { | ||
9831 | EObject current = null; | ||
9832 | |||
9833 | EObject this_UnboundedMultiplicity_0 = null; | ||
9834 | |||
9835 | EObject this_ExactMultiplicity_1 = null; | ||
9836 | |||
9837 | EObject this_BoundedMultiplicity_2 = null; | ||
9838 | |||
9839 | |||
9840 | |||
9841 | enterRule(); | ||
9842 | |||
9843 | try { | ||
9844 | // InternalSolverLanguageParser.g:3864:2: ( (this_UnboundedMultiplicity_0= ruleUnboundedMultiplicity | this_ExactMultiplicity_1= ruleExactMultiplicity | this_BoundedMultiplicity_2= ruleBoundedMultiplicity ) ) | ||
9845 | // InternalSolverLanguageParser.g:3865:2: (this_UnboundedMultiplicity_0= ruleUnboundedMultiplicity | this_ExactMultiplicity_1= ruleExactMultiplicity | this_BoundedMultiplicity_2= ruleBoundedMultiplicity ) | ||
9846 | { | ||
9847 | // InternalSolverLanguageParser.g:3865:2: (this_UnboundedMultiplicity_0= ruleUnboundedMultiplicity | this_ExactMultiplicity_1= ruleExactMultiplicity | this_BoundedMultiplicity_2= ruleBoundedMultiplicity ) | ||
9848 | int alt48=3; | ||
9849 | int LA48_0 = input.LA(1); | ||
9850 | |||
9851 | if ( (LA48_0==LeftSquareBracket) ) { | ||
9852 | switch ( input.LA(2) ) { | ||
9853 | case RULE_INT: | ||
9854 | { | ||
9855 | int LA48_2 = input.LA(3); | ||
9856 | |||
9857 | if ( (LA48_2==RightSquareBracket) ) { | ||
9858 | alt48=2; | ||
9859 | } | ||
9860 | else if ( (LA48_2==Comma) ) { | ||
9861 | alt48=3; | ||
9862 | } | ||
9863 | else { | ||
9864 | NoViableAltException nvae = | ||
9865 | new NoViableAltException("", 48, 2, input); | ||
9866 | |||
9867 | throw nvae; | ||
9868 | } | ||
9869 | } | ||
9870 | break; | ||
9871 | case RightSquareBracket: | ||
9872 | { | ||
9873 | alt48=1; | ||
9874 | } | ||
9875 | break; | ||
9876 | case Asterisk: | ||
9877 | { | ||
9878 | alt48=2; | ||
9879 | } | ||
9880 | break; | ||
9881 | default: | ||
9882 | NoViableAltException nvae = | ||
9883 | new NoViableAltException("", 48, 1, input); | ||
9884 | |||
9885 | throw nvae; | ||
9886 | } | ||
9887 | |||
9888 | } | ||
9889 | else { | ||
9890 | NoViableAltException nvae = | ||
9891 | new NoViableAltException("", 48, 0, input); | ||
9892 | |||
9893 | throw nvae; | ||
9894 | } | ||
9895 | switch (alt48) { | ||
9896 | case 1 : | ||
9897 | // InternalSolverLanguageParser.g:3866:3: this_UnboundedMultiplicity_0= ruleUnboundedMultiplicity | ||
9898 | { | ||
9899 | |||
9900 | newCompositeNode(grammarAccess.getMultiplicityAccess().getUnboundedMultiplicityParserRuleCall_0()); | ||
9901 | |||
9902 | pushFollow(FOLLOW_2); | ||
9903 | this_UnboundedMultiplicity_0=ruleUnboundedMultiplicity(); | ||
9904 | |||
9905 | state._fsp--; | ||
9906 | |||
9907 | |||
9908 | current = this_UnboundedMultiplicity_0; | ||
9909 | afterParserOrEnumRuleCall(); | ||
9910 | |||
9911 | |||
9912 | } | ||
9913 | break; | ||
9914 | case 2 : | ||
9915 | // InternalSolverLanguageParser.g:3875:3: this_ExactMultiplicity_1= ruleExactMultiplicity | ||
9916 | { | ||
9917 | |||
9918 | newCompositeNode(grammarAccess.getMultiplicityAccess().getExactMultiplicityParserRuleCall_1()); | ||
9919 | |||
9920 | pushFollow(FOLLOW_2); | ||
9921 | this_ExactMultiplicity_1=ruleExactMultiplicity(); | ||
9922 | |||
9923 | state._fsp--; | ||
9924 | |||
9925 | |||
9926 | current = this_ExactMultiplicity_1; | ||
9927 | afterParserOrEnumRuleCall(); | ||
9928 | |||
9929 | |||
9930 | } | ||
9931 | break; | ||
9932 | case 3 : | ||
9933 | // InternalSolverLanguageParser.g:3884:3: this_BoundedMultiplicity_2= ruleBoundedMultiplicity | ||
9934 | { | ||
9935 | |||
9936 | newCompositeNode(grammarAccess.getMultiplicityAccess().getBoundedMultiplicityParserRuleCall_2()); | ||
9937 | |||
9938 | pushFollow(FOLLOW_2); | ||
9939 | this_BoundedMultiplicity_2=ruleBoundedMultiplicity(); | ||
9940 | |||
9941 | state._fsp--; | ||
9942 | |||
9943 | |||
9944 | current = this_BoundedMultiplicity_2; | ||
9945 | afterParserOrEnumRuleCall(); | ||
9946 | |||
9947 | |||
9948 | } | ||
9949 | break; | ||
9950 | |||
9951 | } | ||
9952 | |||
9953 | |||
9954 | } | ||
9955 | |||
9956 | |||
9957 | leaveRule(); | ||
9958 | |||
9959 | } | ||
9960 | |||
9961 | catch (RecognitionException re) { | ||
9962 | recover(input,re); | ||
9963 | appendSkippedTokens(); | ||
9964 | } | ||
9965 | finally { | ||
9966 | } | ||
9967 | return current; | ||
9968 | } | ||
9969 | // $ANTLR end "ruleMultiplicity" | ||
9970 | |||
9971 | |||
9972 | // $ANTLR start "entryRuleUnboundedMultiplicity" | ||
9973 | // InternalSolverLanguageParser.g:3896:1: entryRuleUnboundedMultiplicity returns [EObject current=null] : iv_ruleUnboundedMultiplicity= ruleUnboundedMultiplicity EOF ; | ||
9974 | public final EObject entryRuleUnboundedMultiplicity() throws RecognitionException { | ||
9975 | EObject current = null; | ||
9976 | |||
9977 | EObject iv_ruleUnboundedMultiplicity = null; | ||
9978 | |||
9979 | |||
9980 | try { | ||
9981 | // InternalSolverLanguageParser.g:3896:62: (iv_ruleUnboundedMultiplicity= ruleUnboundedMultiplicity EOF ) | ||
9982 | // InternalSolverLanguageParser.g:3897:2: iv_ruleUnboundedMultiplicity= ruleUnboundedMultiplicity EOF | ||
9983 | { | ||
9984 | newCompositeNode(grammarAccess.getUnboundedMultiplicityRule()); | ||
9985 | pushFollow(FOLLOW_1); | ||
9986 | iv_ruleUnboundedMultiplicity=ruleUnboundedMultiplicity(); | ||
9987 | |||
9988 | state._fsp--; | ||
9989 | |||
9990 | current =iv_ruleUnboundedMultiplicity; | ||
9991 | match(input,EOF,FOLLOW_2); | ||
9992 | |||
9993 | } | ||
9994 | |||
9995 | } | ||
9996 | |||
9997 | catch (RecognitionException re) { | ||
9998 | recover(input,re); | ||
9999 | appendSkippedTokens(); | ||
10000 | } | ||
10001 | finally { | ||
10002 | } | ||
10003 | return current; | ||
10004 | } | ||
10005 | // $ANTLR end "entryRuleUnboundedMultiplicity" | ||
10006 | |||
10007 | |||
10008 | // $ANTLR start "ruleUnboundedMultiplicity" | ||
10009 | // InternalSolverLanguageParser.g:3903:1: ruleUnboundedMultiplicity returns [EObject current=null] : ( () otherlv_1= LeftSquareBracket otherlv_2= RightSquareBracket ) ; | ||
10010 | public final EObject ruleUnboundedMultiplicity() throws RecognitionException { | ||
10011 | EObject current = null; | ||
10012 | |||
10013 | Token otherlv_1=null; | ||
10014 | Token otherlv_2=null; | ||
10015 | |||
10016 | |||
10017 | enterRule(); | ||
10018 | |||
10019 | try { | ||
10020 | // InternalSolverLanguageParser.g:3909:2: ( ( () otherlv_1= LeftSquareBracket otherlv_2= RightSquareBracket ) ) | ||
10021 | // InternalSolverLanguageParser.g:3910:2: ( () otherlv_1= LeftSquareBracket otherlv_2= RightSquareBracket ) | ||
10022 | { | ||
10023 | // InternalSolverLanguageParser.g:3910:2: ( () otherlv_1= LeftSquareBracket otherlv_2= RightSquareBracket ) | ||
10024 | // InternalSolverLanguageParser.g:3911:3: () otherlv_1= LeftSquareBracket otherlv_2= RightSquareBracket | ||
10025 | { | ||
10026 | // InternalSolverLanguageParser.g:3911:3: () | ||
10027 | // InternalSolverLanguageParser.g:3912:4: | ||
10028 | { | ||
10029 | |||
10030 | current = forceCreateModelElement( | ||
10031 | grammarAccess.getUnboundedMultiplicityAccess().getUnboundedMultiplicityAction_0(), | ||
10032 | current); | ||
10033 | |||
10034 | |||
10035 | } | ||
10036 | |||
10037 | otherlv_1=(Token)match(input,LeftSquareBracket,FOLLOW_49); | ||
10038 | |||
10039 | newLeafNode(otherlv_1, grammarAccess.getUnboundedMultiplicityAccess().getLeftSquareBracketKeyword_1()); | ||
10040 | |||
10041 | otherlv_2=(Token)match(input,RightSquareBracket,FOLLOW_2); | ||
10042 | |||
10043 | newLeafNode(otherlv_2, grammarAccess.getUnboundedMultiplicityAccess().getRightSquareBracketKeyword_2()); | ||
10044 | |||
10045 | |||
10046 | } | ||
10047 | |||
10048 | |||
10049 | } | ||
10050 | |||
10051 | |||
10052 | leaveRule(); | ||
10053 | |||
10054 | } | ||
10055 | |||
10056 | catch (RecognitionException re) { | ||
10057 | recover(input,re); | ||
10058 | appendSkippedTokens(); | ||
10059 | } | ||
10060 | finally { | ||
10061 | } | ||
10062 | return current; | ||
10063 | } | ||
10064 | // $ANTLR end "ruleUnboundedMultiplicity" | ||
10065 | |||
10066 | |||
10067 | // $ANTLR start "entryRuleExactMultiplicity" | ||
10068 | // InternalSolverLanguageParser.g:3930:1: entryRuleExactMultiplicity returns [EObject current=null] : iv_ruleExactMultiplicity= ruleExactMultiplicity EOF ; | ||
10069 | public final EObject entryRuleExactMultiplicity() throws RecognitionException { | ||
10070 | EObject current = null; | ||
10071 | |||
10072 | EObject iv_ruleExactMultiplicity = null; | ||
10073 | |||
10074 | |||
10075 | try { | ||
10076 | // InternalSolverLanguageParser.g:3930:58: (iv_ruleExactMultiplicity= ruleExactMultiplicity EOF ) | ||
10077 | // InternalSolverLanguageParser.g:3931:2: iv_ruleExactMultiplicity= ruleExactMultiplicity EOF | ||
10078 | { | ||
10079 | newCompositeNode(grammarAccess.getExactMultiplicityRule()); | ||
10080 | pushFollow(FOLLOW_1); | ||
10081 | iv_ruleExactMultiplicity=ruleExactMultiplicity(); | ||
10082 | |||
10083 | state._fsp--; | ||
10084 | |||
10085 | current =iv_ruleExactMultiplicity; | ||
10086 | match(input,EOF,FOLLOW_2); | ||
10087 | |||
10088 | } | ||
10089 | |||
10090 | } | ||
10091 | |||
10092 | catch (RecognitionException re) { | ||
10093 | recover(input,re); | ||
10094 | appendSkippedTokens(); | ||
10095 | } | ||
10096 | finally { | ||
10097 | } | ||
10098 | return current; | ||
10099 | } | ||
10100 | // $ANTLR end "entryRuleExactMultiplicity" | ||
10101 | |||
10102 | |||
10103 | // $ANTLR start "ruleExactMultiplicity" | ||
10104 | // InternalSolverLanguageParser.g:3937:1: ruleExactMultiplicity returns [EObject current=null] : (otherlv_0= LeftSquareBracket ( (lv_value_1_0= ruleUpperMultiplicty ) ) otherlv_2= RightSquareBracket ) ; | ||
10105 | public final EObject ruleExactMultiplicity() throws RecognitionException { | ||
10106 | EObject current = null; | ||
10107 | |||
10108 | Token otherlv_0=null; | ||
10109 | Token otherlv_2=null; | ||
10110 | AntlrDatatypeRuleToken lv_value_1_0 = null; | ||
10111 | |||
10112 | |||
10113 | |||
10114 | enterRule(); | ||
10115 | |||
10116 | try { | ||
10117 | // InternalSolverLanguageParser.g:3943:2: ( (otherlv_0= LeftSquareBracket ( (lv_value_1_0= ruleUpperMultiplicty ) ) otherlv_2= RightSquareBracket ) ) | ||
10118 | // InternalSolverLanguageParser.g:3944:2: (otherlv_0= LeftSquareBracket ( (lv_value_1_0= ruleUpperMultiplicty ) ) otherlv_2= RightSquareBracket ) | ||
10119 | { | ||
10120 | // InternalSolverLanguageParser.g:3944:2: (otherlv_0= LeftSquareBracket ( (lv_value_1_0= ruleUpperMultiplicty ) ) otherlv_2= RightSquareBracket ) | ||
10121 | // InternalSolverLanguageParser.g:3945:3: otherlv_0= LeftSquareBracket ( (lv_value_1_0= ruleUpperMultiplicty ) ) otherlv_2= RightSquareBracket | ||
10122 | { | ||
10123 | otherlv_0=(Token)match(input,LeftSquareBracket,FOLLOW_56); | ||
10124 | |||
10125 | newLeafNode(otherlv_0, grammarAccess.getExactMultiplicityAccess().getLeftSquareBracketKeyword_0()); | ||
10126 | |||
10127 | // InternalSolverLanguageParser.g:3949:3: ( (lv_value_1_0= ruleUpperMultiplicty ) ) | ||
10128 | // InternalSolverLanguageParser.g:3950:4: (lv_value_1_0= ruleUpperMultiplicty ) | ||
10129 | { | ||
10130 | // InternalSolverLanguageParser.g:3950:4: (lv_value_1_0= ruleUpperMultiplicty ) | ||
10131 | // InternalSolverLanguageParser.g:3951:5: lv_value_1_0= ruleUpperMultiplicty | ||
10132 | { | ||
10133 | |||
10134 | newCompositeNode(grammarAccess.getExactMultiplicityAccess().getValueUpperMultiplictyParserRuleCall_1_0()); | ||
10135 | |||
10136 | pushFollow(FOLLOW_49); | ||
10137 | lv_value_1_0=ruleUpperMultiplicty(); | ||
10138 | |||
10139 | state._fsp--; | ||
10140 | |||
10141 | |||
10142 | if (current==null) { | ||
10143 | current = createModelElementForParent(grammarAccess.getExactMultiplicityRule()); | ||
10144 | } | ||
10145 | set( | ||
10146 | current, | ||
10147 | "value", | ||
10148 | lv_value_1_0, | ||
10149 | "org.eclipse.viatra.solver.language.SolverLanguage.UpperMultiplicty"); | ||
10150 | afterParserOrEnumRuleCall(); | ||
10151 | |||
10152 | |||
10153 | } | ||
10154 | |||
10155 | |||
10156 | } | ||
10157 | |||
10158 | otherlv_2=(Token)match(input,RightSquareBracket,FOLLOW_2); | ||
10159 | |||
10160 | newLeafNode(otherlv_2, grammarAccess.getExactMultiplicityAccess().getRightSquareBracketKeyword_2()); | ||
10161 | |||
10162 | |||
10163 | } | ||
10164 | |||
10165 | |||
10166 | } | ||
10167 | |||
10168 | |||
10169 | leaveRule(); | ||
10170 | |||
10171 | } | ||
10172 | |||
10173 | catch (RecognitionException re) { | ||
10174 | recover(input,re); | ||
10175 | appendSkippedTokens(); | ||
10176 | } | ||
10177 | finally { | ||
10178 | } | ||
10179 | return current; | ||
10180 | } | ||
10181 | // $ANTLR end "ruleExactMultiplicity" | ||
10182 | |||
10183 | |||
10184 | // $ANTLR start "entryRuleBoundedMultiplicity" | ||
10185 | // InternalSolverLanguageParser.g:3976:1: entryRuleBoundedMultiplicity returns [EObject current=null] : iv_ruleBoundedMultiplicity= ruleBoundedMultiplicity EOF ; | ||
10186 | public final EObject entryRuleBoundedMultiplicity() throws RecognitionException { | ||
10187 | EObject current = null; | ||
10188 | |||
10189 | EObject iv_ruleBoundedMultiplicity = null; | ||
10190 | |||
10191 | |||
10192 | try { | ||
10193 | // InternalSolverLanguageParser.g:3976:60: (iv_ruleBoundedMultiplicity= ruleBoundedMultiplicity EOF ) | ||
10194 | // InternalSolverLanguageParser.g:3977:2: iv_ruleBoundedMultiplicity= ruleBoundedMultiplicity EOF | ||
10195 | { | ||
10196 | newCompositeNode(grammarAccess.getBoundedMultiplicityRule()); | ||
10197 | pushFollow(FOLLOW_1); | ||
10198 | iv_ruleBoundedMultiplicity=ruleBoundedMultiplicity(); | ||
10199 | |||
10200 | state._fsp--; | ||
10201 | |||
10202 | current =iv_ruleBoundedMultiplicity; | ||
10203 | match(input,EOF,FOLLOW_2); | ||
10204 | |||
10205 | } | ||
10206 | |||
10207 | } | ||
10208 | |||
10209 | catch (RecognitionException re) { | ||
10210 | recover(input,re); | ||
10211 | appendSkippedTokens(); | ||
10212 | } | ||
10213 | finally { | ||
10214 | } | ||
10215 | return current; | ||
10216 | } | ||
10217 | // $ANTLR end "entryRuleBoundedMultiplicity" | ||
10218 | |||
10219 | |||
10220 | // $ANTLR start "ruleBoundedMultiplicity" | ||
10221 | // InternalSolverLanguageParser.g:3983:1: ruleBoundedMultiplicity returns [EObject current=null] : (otherlv_0= LeftSquareBracket ( (lv_lowerBound_1_0= RULE_INT ) ) otherlv_2= Comma ( (lv_upperBound_3_0= ruleUpperMultiplicty ) ) otherlv_4= RightSquareBracket ) ; | ||
10222 | public final EObject ruleBoundedMultiplicity() throws RecognitionException { | ||
10223 | EObject current = null; | ||
10224 | |||
10225 | Token otherlv_0=null; | ||
10226 | Token lv_lowerBound_1_0=null; | ||
10227 | Token otherlv_2=null; | ||
10228 | Token otherlv_4=null; | ||
10229 | AntlrDatatypeRuleToken lv_upperBound_3_0 = null; | ||
10230 | |||
10231 | |||
10232 | |||
10233 | enterRule(); | ||
10234 | |||
10235 | try { | ||
10236 | // InternalSolverLanguageParser.g:3989:2: ( (otherlv_0= LeftSquareBracket ( (lv_lowerBound_1_0= RULE_INT ) ) otherlv_2= Comma ( (lv_upperBound_3_0= ruleUpperMultiplicty ) ) otherlv_4= RightSquareBracket ) ) | ||
10237 | // InternalSolverLanguageParser.g:3990:2: (otherlv_0= LeftSquareBracket ( (lv_lowerBound_1_0= RULE_INT ) ) otherlv_2= Comma ( (lv_upperBound_3_0= ruleUpperMultiplicty ) ) otherlv_4= RightSquareBracket ) | ||
10238 | { | ||
10239 | // InternalSolverLanguageParser.g:3990:2: (otherlv_0= LeftSquareBracket ( (lv_lowerBound_1_0= RULE_INT ) ) otherlv_2= Comma ( (lv_upperBound_3_0= ruleUpperMultiplicty ) ) otherlv_4= RightSquareBracket ) | ||
10240 | // InternalSolverLanguageParser.g:3991:3: otherlv_0= LeftSquareBracket ( (lv_lowerBound_1_0= RULE_INT ) ) otherlv_2= Comma ( (lv_upperBound_3_0= ruleUpperMultiplicty ) ) otherlv_4= RightSquareBracket | ||
10241 | { | ||
10242 | otherlv_0=(Token)match(input,LeftSquareBracket,FOLLOW_57); | ||
10243 | |||
10244 | newLeafNode(otherlv_0, grammarAccess.getBoundedMultiplicityAccess().getLeftSquareBracketKeyword_0()); | ||
10245 | |||
10246 | // InternalSolverLanguageParser.g:3995:3: ( (lv_lowerBound_1_0= RULE_INT ) ) | ||
10247 | // InternalSolverLanguageParser.g:3996:4: (lv_lowerBound_1_0= RULE_INT ) | ||
10248 | { | ||
10249 | // InternalSolverLanguageParser.g:3996:4: (lv_lowerBound_1_0= RULE_INT ) | ||
10250 | // InternalSolverLanguageParser.g:3997:5: lv_lowerBound_1_0= RULE_INT | ||
10251 | { | ||
10252 | lv_lowerBound_1_0=(Token)match(input,RULE_INT,FOLLOW_48); | ||
10253 | |||
10254 | newLeafNode(lv_lowerBound_1_0, grammarAccess.getBoundedMultiplicityAccess().getLowerBoundINTTerminalRuleCall_1_0()); | ||
10255 | |||
10256 | |||
10257 | if (current==null) { | ||
10258 | current = createModelElement(grammarAccess.getBoundedMultiplicityRule()); | ||
10259 | } | ||
10260 | setWithLastConsumed( | ||
10261 | current, | ||
10262 | "lowerBound", | ||
10263 | lv_lowerBound_1_0, | ||
10264 | "org.eclipse.xtext.common.Terminals.INT"); | ||
10265 | |||
10266 | |||
10267 | } | ||
10268 | |||
10269 | |||
10270 | } | ||
10271 | |||
10272 | otherlv_2=(Token)match(input,Comma,FOLLOW_56); | ||
10273 | |||
10274 | newLeafNode(otherlv_2, grammarAccess.getBoundedMultiplicityAccess().getCommaKeyword_2()); | ||
10275 | |||
10276 | // InternalSolverLanguageParser.g:4017:3: ( (lv_upperBound_3_0= ruleUpperMultiplicty ) ) | ||
10277 | // InternalSolverLanguageParser.g:4018:4: (lv_upperBound_3_0= ruleUpperMultiplicty ) | ||
10278 | { | ||
10279 | // InternalSolverLanguageParser.g:4018:4: (lv_upperBound_3_0= ruleUpperMultiplicty ) | ||
10280 | // InternalSolverLanguageParser.g:4019:5: lv_upperBound_3_0= ruleUpperMultiplicty | ||
10281 | { | ||
10282 | |||
10283 | newCompositeNode(grammarAccess.getBoundedMultiplicityAccess().getUpperBoundUpperMultiplictyParserRuleCall_3_0()); | ||
10284 | |||
10285 | pushFollow(FOLLOW_49); | ||
10286 | lv_upperBound_3_0=ruleUpperMultiplicty(); | ||
10287 | |||
10288 | state._fsp--; | ||
10289 | |||
10290 | |||
10291 | if (current==null) { | ||
10292 | current = createModelElementForParent(grammarAccess.getBoundedMultiplicityRule()); | ||
10293 | } | ||
10294 | set( | ||
10295 | current, | ||
10296 | "upperBound", | ||
10297 | lv_upperBound_3_0, | ||
10298 | "org.eclipse.viatra.solver.language.SolverLanguage.UpperMultiplicty"); | ||
10299 | afterParserOrEnumRuleCall(); | ||
10300 | |||
10301 | |||
10302 | } | ||
10303 | |||
10304 | |||
10305 | } | ||
10306 | |||
10307 | otherlv_4=(Token)match(input,RightSquareBracket,FOLLOW_2); | ||
10308 | |||
10309 | newLeafNode(otherlv_4, grammarAccess.getBoundedMultiplicityAccess().getRightSquareBracketKeyword_4()); | ||
10310 | |||
10311 | |||
10312 | } | ||
10313 | |||
10314 | |||
10315 | } | ||
10316 | |||
10317 | |||
10318 | leaveRule(); | ||
10319 | |||
10320 | } | ||
10321 | |||
10322 | catch (RecognitionException re) { | ||
10323 | recover(input,re); | ||
10324 | appendSkippedTokens(); | ||
10325 | } | ||
10326 | finally { | ||
10327 | } | ||
10328 | return current; | ||
10329 | } | ||
10330 | // $ANTLR end "ruleBoundedMultiplicity" | ||
10331 | |||
10332 | |||
10333 | // $ANTLR start "entryRuleEnumDeclaration" | ||
10334 | // InternalSolverLanguageParser.g:4044:1: entryRuleEnumDeclaration returns [EObject current=null] : iv_ruleEnumDeclaration= ruleEnumDeclaration EOF ; | ||
10335 | public final EObject entryRuleEnumDeclaration() throws RecognitionException { | ||
10336 | EObject current = null; | ||
10337 | |||
10338 | EObject iv_ruleEnumDeclaration = null; | ||
10339 | |||
10340 | |||
10341 | try { | ||
10342 | // InternalSolverLanguageParser.g:4044:56: (iv_ruleEnumDeclaration= ruleEnumDeclaration EOF ) | ||
10343 | // InternalSolverLanguageParser.g:4045:2: iv_ruleEnumDeclaration= ruleEnumDeclaration EOF | ||
10344 | { | ||
10345 | newCompositeNode(grammarAccess.getEnumDeclarationRule()); | ||
10346 | pushFollow(FOLLOW_1); | ||
10347 | iv_ruleEnumDeclaration=ruleEnumDeclaration(); | ||
10348 | |||
10349 | state._fsp--; | ||
10350 | |||
10351 | current =iv_ruleEnumDeclaration; | ||
10352 | match(input,EOF,FOLLOW_2); | ||
10353 | |||
10354 | } | ||
10355 | |||
10356 | } | ||
10357 | |||
10358 | catch (RecognitionException re) { | ||
10359 | recover(input,re); | ||
10360 | appendSkippedTokens(); | ||
10361 | } | ||
10362 | finally { | ||
10363 | } | ||
10364 | return current; | ||
10365 | } | ||
10366 | // $ANTLR end "entryRuleEnumDeclaration" | ||
10367 | |||
10368 | |||
10369 | // $ANTLR start "ruleEnumDeclaration" | ||
10370 | // InternalSolverLanguageParser.g:4051:1: ruleEnumDeclaration returns [EObject current=null] : (otherlv_0= Enum ( (lv_name_1_0= RULE_ID ) ) ( (otherlv_2= LeftCurlyBracket ( ( (lv_literals_3_0= ruleEnumLiteral ) ) ( (otherlv_4= Comma )? ( (lv_literals_5_0= ruleEnumLiteral ) ) )* )? otherlv_6= RightCurlyBracket ) | this_FULL_STOP_7= RULE_FULL_STOP ) ) ; | ||
10371 | public final EObject ruleEnumDeclaration() throws RecognitionException { | ||
10372 | EObject current = null; | ||
10373 | |||
10374 | Token otherlv_0=null; | ||
10375 | Token lv_name_1_0=null; | ||
10376 | Token otherlv_2=null; | ||
10377 | Token otherlv_4=null; | ||
10378 | Token otherlv_6=null; | ||
10379 | Token this_FULL_STOP_7=null; | ||
10380 | EObject lv_literals_3_0 = null; | ||
10381 | |||
10382 | EObject lv_literals_5_0 = null; | ||
10383 | |||
10384 | |||
10385 | |||
10386 | enterRule(); | ||
10387 | |||
10388 | try { | ||
10389 | // InternalSolverLanguageParser.g:4057:2: ( (otherlv_0= Enum ( (lv_name_1_0= RULE_ID ) ) ( (otherlv_2= LeftCurlyBracket ( ( (lv_literals_3_0= ruleEnumLiteral ) ) ( (otherlv_4= Comma )? ( (lv_literals_5_0= ruleEnumLiteral ) ) )* )? otherlv_6= RightCurlyBracket ) | this_FULL_STOP_7= RULE_FULL_STOP ) ) ) | ||
10390 | // InternalSolverLanguageParser.g:4058:2: (otherlv_0= Enum ( (lv_name_1_0= RULE_ID ) ) ( (otherlv_2= LeftCurlyBracket ( ( (lv_literals_3_0= ruleEnumLiteral ) ) ( (otherlv_4= Comma )? ( (lv_literals_5_0= ruleEnumLiteral ) ) )* )? otherlv_6= RightCurlyBracket ) | this_FULL_STOP_7= RULE_FULL_STOP ) ) | ||
10391 | { | ||
10392 | // InternalSolverLanguageParser.g:4058:2: (otherlv_0= Enum ( (lv_name_1_0= RULE_ID ) ) ( (otherlv_2= LeftCurlyBracket ( ( (lv_literals_3_0= ruleEnumLiteral ) ) ( (otherlv_4= Comma )? ( (lv_literals_5_0= ruleEnumLiteral ) ) )* )? otherlv_6= RightCurlyBracket ) | this_FULL_STOP_7= RULE_FULL_STOP ) ) | ||
10393 | // InternalSolverLanguageParser.g:4059:3: otherlv_0= Enum ( (lv_name_1_0= RULE_ID ) ) ( (otherlv_2= LeftCurlyBracket ( ( (lv_literals_3_0= ruleEnumLiteral ) ) ( (otherlv_4= Comma )? ( (lv_literals_5_0= ruleEnumLiteral ) ) )* )? otherlv_6= RightCurlyBracket ) | this_FULL_STOP_7= RULE_FULL_STOP ) | ||
10394 | { | ||
10395 | otherlv_0=(Token)match(input,Enum,FOLLOW_28); | ||
10396 | |||
10397 | newLeafNode(otherlv_0, grammarAccess.getEnumDeclarationAccess().getEnumKeyword_0()); | ||
10398 | |||
10399 | // InternalSolverLanguageParser.g:4063:3: ( (lv_name_1_0= RULE_ID ) ) | ||
10400 | // InternalSolverLanguageParser.g:4064:4: (lv_name_1_0= RULE_ID ) | ||
10401 | { | ||
10402 | // InternalSolverLanguageParser.g:4064:4: (lv_name_1_0= RULE_ID ) | ||
10403 | // InternalSolverLanguageParser.g:4065:5: lv_name_1_0= RULE_ID | ||
10404 | { | ||
10405 | lv_name_1_0=(Token)match(input,RULE_ID,FOLLOW_58); | ||
10406 | |||
10407 | newLeafNode(lv_name_1_0, grammarAccess.getEnumDeclarationAccess().getNameIDTerminalRuleCall_1_0()); | ||
10408 | |||
10409 | |||
10410 | if (current==null) { | ||
10411 | current = createModelElement(grammarAccess.getEnumDeclarationRule()); | ||
10412 | } | ||
10413 | setWithLastConsumed( | ||
10414 | current, | ||
10415 | "name", | ||
10416 | lv_name_1_0, | ||
10417 | "org.eclipse.xtext.common.Terminals.ID"); | ||
10418 | |||
10419 | |||
10420 | } | ||
10421 | |||
10422 | |||
10423 | } | ||
10424 | |||
10425 | // InternalSolverLanguageParser.g:4081:3: ( (otherlv_2= LeftCurlyBracket ( ( (lv_literals_3_0= ruleEnumLiteral ) ) ( (otherlv_4= Comma )? ( (lv_literals_5_0= ruleEnumLiteral ) ) )* )? otherlv_6= RightCurlyBracket ) | this_FULL_STOP_7= RULE_FULL_STOP ) | ||
10426 | int alt52=2; | ||
10427 | int LA52_0 = input.LA(1); | ||
10428 | |||
10429 | if ( (LA52_0==LeftCurlyBracket) ) { | ||
10430 | alt52=1; | ||
10431 | } | ||
10432 | else if ( (LA52_0==RULE_FULL_STOP) ) { | ||
10433 | alt52=2; | ||
10434 | } | ||
10435 | else { | ||
10436 | NoViableAltException nvae = | ||
10437 | new NoViableAltException("", 52, 0, input); | ||
10438 | |||
10439 | throw nvae; | ||
10440 | } | ||
10441 | switch (alt52) { | ||
10442 | case 1 : | ||
10443 | // InternalSolverLanguageParser.g:4082:4: (otherlv_2= LeftCurlyBracket ( ( (lv_literals_3_0= ruleEnumLiteral ) ) ( (otherlv_4= Comma )? ( (lv_literals_5_0= ruleEnumLiteral ) ) )* )? otherlv_6= RightCurlyBracket ) | ||
10444 | { | ||
10445 | // InternalSolverLanguageParser.g:4082:4: (otherlv_2= LeftCurlyBracket ( ( (lv_literals_3_0= ruleEnumLiteral ) ) ( (otherlv_4= Comma )? ( (lv_literals_5_0= ruleEnumLiteral ) ) )* )? otherlv_6= RightCurlyBracket ) | ||
10446 | // InternalSolverLanguageParser.g:4083:5: otherlv_2= LeftCurlyBracket ( ( (lv_literals_3_0= ruleEnumLiteral ) ) ( (otherlv_4= Comma )? ( (lv_literals_5_0= ruleEnumLiteral ) ) )* )? otherlv_6= RightCurlyBracket | ||
10447 | { | ||
10448 | otherlv_2=(Token)match(input,LeftCurlyBracket,FOLLOW_59); | ||
10449 | |||
10450 | newLeafNode(otherlv_2, grammarAccess.getEnumDeclarationAccess().getLeftCurlyBracketKeyword_2_0_0()); | ||
10451 | |||
10452 | // InternalSolverLanguageParser.g:4087:5: ( ( (lv_literals_3_0= ruleEnumLiteral ) ) ( (otherlv_4= Comma )? ( (lv_literals_5_0= ruleEnumLiteral ) ) )* )? | ||
10453 | int alt51=2; | ||
10454 | int LA51_0 = input.LA(1); | ||
10455 | |||
10456 | if ( (LA51_0==RULE_ID) ) { | ||
10457 | alt51=1; | ||
10458 | } | ||
10459 | switch (alt51) { | ||
10460 | case 1 : | ||
10461 | // InternalSolverLanguageParser.g:4088:6: ( (lv_literals_3_0= ruleEnumLiteral ) ) ( (otherlv_4= Comma )? ( (lv_literals_5_0= ruleEnumLiteral ) ) )* | ||
10462 | { | ||
10463 | // InternalSolverLanguageParser.g:4088:6: ( (lv_literals_3_0= ruleEnumLiteral ) ) | ||
10464 | // InternalSolverLanguageParser.g:4089:7: (lv_literals_3_0= ruleEnumLiteral ) | ||
10465 | { | ||
10466 | // InternalSolverLanguageParser.g:4089:7: (lv_literals_3_0= ruleEnumLiteral ) | ||
10467 | // InternalSolverLanguageParser.g:4090:8: lv_literals_3_0= ruleEnumLiteral | ||
10468 | { | ||
10469 | |||
10470 | newCompositeNode(grammarAccess.getEnumDeclarationAccess().getLiteralsEnumLiteralParserRuleCall_2_0_1_0_0()); | ||
10471 | |||
10472 | pushFollow(FOLLOW_60); | ||
10473 | lv_literals_3_0=ruleEnumLiteral(); | ||
10474 | |||
10475 | state._fsp--; | ||
10476 | |||
10477 | |||
10478 | if (current==null) { | ||
10479 | current = createModelElementForParent(grammarAccess.getEnumDeclarationRule()); | ||
10480 | } | ||
10481 | add( | ||
10482 | current, | ||
10483 | "literals", | ||
10484 | lv_literals_3_0, | ||
10485 | "org.eclipse.viatra.solver.language.SolverLanguage.EnumLiteral"); | ||
10486 | afterParserOrEnumRuleCall(); | ||
10487 | |||
10488 | |||
10489 | } | ||
10490 | |||
10491 | |||
10492 | } | ||
10493 | |||
10494 | // InternalSolverLanguageParser.g:4107:6: ( (otherlv_4= Comma )? ( (lv_literals_5_0= ruleEnumLiteral ) ) )* | ||
10495 | loop50: | ||
10496 | do { | ||
10497 | int alt50=2; | ||
10498 | int LA50_0 = input.LA(1); | ||
10499 | |||
10500 | if ( (LA50_0==Comma||LA50_0==RULE_ID) ) { | ||
10501 | alt50=1; | ||
10502 | } | ||
10503 | |||
10504 | |||
10505 | switch (alt50) { | ||
10506 | case 1 : | ||
10507 | // InternalSolverLanguageParser.g:4108:7: (otherlv_4= Comma )? ( (lv_literals_5_0= ruleEnumLiteral ) ) | ||
10508 | { | ||
10509 | // InternalSolverLanguageParser.g:4108:7: (otherlv_4= Comma )? | ||
10510 | int alt49=2; | ||
10511 | int LA49_0 = input.LA(1); | ||
10512 | |||
10513 | if ( (LA49_0==Comma) ) { | ||
10514 | alt49=1; | ||
10515 | } | ||
10516 | switch (alt49) { | ||
10517 | case 1 : | ||
10518 | // InternalSolverLanguageParser.g:4109:8: otherlv_4= Comma | ||
10519 | { | ||
10520 | otherlv_4=(Token)match(input,Comma,FOLLOW_28); | ||
10521 | |||
10522 | newLeafNode(otherlv_4, grammarAccess.getEnumDeclarationAccess().getCommaKeyword_2_0_1_1_0()); | ||
10523 | |||
10524 | |||
10525 | } | ||
10526 | break; | ||
10527 | |||
10528 | } | ||
10529 | |||
10530 | // InternalSolverLanguageParser.g:4114:7: ( (lv_literals_5_0= ruleEnumLiteral ) ) | ||
10531 | // InternalSolverLanguageParser.g:4115:8: (lv_literals_5_0= ruleEnumLiteral ) | ||
10532 | { | ||
10533 | // InternalSolverLanguageParser.g:4115:8: (lv_literals_5_0= ruleEnumLiteral ) | ||
10534 | // InternalSolverLanguageParser.g:4116:9: lv_literals_5_0= ruleEnumLiteral | ||
10535 | { | ||
10536 | |||
10537 | newCompositeNode(grammarAccess.getEnumDeclarationAccess().getLiteralsEnumLiteralParserRuleCall_2_0_1_1_1_0()); | ||
10538 | |||
10539 | pushFollow(FOLLOW_60); | ||
10540 | lv_literals_5_0=ruleEnumLiteral(); | ||
10541 | |||
10542 | state._fsp--; | ||
10543 | |||
10544 | |||
10545 | if (current==null) { | ||
10546 | current = createModelElementForParent(grammarAccess.getEnumDeclarationRule()); | ||
10547 | } | ||
10548 | add( | ||
10549 | current, | ||
10550 | "literals", | ||
10551 | lv_literals_5_0, | ||
10552 | "org.eclipse.viatra.solver.language.SolverLanguage.EnumLiteral"); | ||
10553 | afterParserOrEnumRuleCall(); | ||
10554 | |||
10555 | |||
10556 | } | ||
10557 | |||
10558 | |||
10559 | } | ||
10560 | |||
10561 | |||
10562 | } | ||
10563 | break; | ||
10564 | |||
10565 | default : | ||
10566 | break loop50; | ||
10567 | } | ||
10568 | } while (true); | ||
10569 | |||
10570 | |||
10571 | } | ||
10572 | break; | ||
10573 | |||
10574 | } | ||
10575 | |||
10576 | otherlv_6=(Token)match(input,RightCurlyBracket,FOLLOW_2); | ||
10577 | |||
10578 | newLeafNode(otherlv_6, grammarAccess.getEnumDeclarationAccess().getRightCurlyBracketKeyword_2_0_2()); | ||
10579 | |||
10580 | |||
10581 | } | ||
10582 | |||
10583 | |||
10584 | } | ||
10585 | break; | ||
10586 | case 2 : | ||
10587 | // InternalSolverLanguageParser.g:4141:4: this_FULL_STOP_7= RULE_FULL_STOP | ||
10588 | { | ||
10589 | this_FULL_STOP_7=(Token)match(input,RULE_FULL_STOP,FOLLOW_2); | ||
10590 | |||
10591 | newLeafNode(this_FULL_STOP_7, grammarAccess.getEnumDeclarationAccess().getFULL_STOPTerminalRuleCall_2_1()); | ||
10592 | |||
10593 | |||
10594 | } | ||
10595 | break; | ||
10596 | |||
10597 | } | ||
10598 | |||
10599 | |||
10600 | } | ||
10601 | |||
10602 | |||
10603 | } | ||
10604 | |||
10605 | |||
10606 | leaveRule(); | ||
10607 | |||
10608 | } | ||
10609 | |||
10610 | catch (RecognitionException re) { | ||
10611 | recover(input,re); | ||
10612 | appendSkippedTokens(); | ||
10613 | } | ||
10614 | finally { | ||
10615 | } | ||
10616 | return current; | ||
10617 | } | ||
10618 | // $ANTLR end "ruleEnumDeclaration" | ||
10619 | |||
10620 | |||
10621 | // $ANTLR start "entryRuleEnumLiteral" | ||
10622 | // InternalSolverLanguageParser.g:4150:1: entryRuleEnumLiteral returns [EObject current=null] : iv_ruleEnumLiteral= ruleEnumLiteral EOF ; | ||
10623 | public final EObject entryRuleEnumLiteral() throws RecognitionException { | ||
10624 | EObject current = null; | ||
10625 | |||
10626 | EObject iv_ruleEnumLiteral = null; | ||
10627 | |||
10628 | |||
10629 | try { | ||
10630 | // InternalSolverLanguageParser.g:4150:52: (iv_ruleEnumLiteral= ruleEnumLiteral EOF ) | ||
10631 | // InternalSolverLanguageParser.g:4151:2: iv_ruleEnumLiteral= ruleEnumLiteral EOF | ||
10632 | { | ||
10633 | newCompositeNode(grammarAccess.getEnumLiteralRule()); | ||
10634 | pushFollow(FOLLOW_1); | ||
10635 | iv_ruleEnumLiteral=ruleEnumLiteral(); | ||
10636 | |||
10637 | state._fsp--; | ||
10638 | |||
10639 | current =iv_ruleEnumLiteral; | ||
10640 | match(input,EOF,FOLLOW_2); | ||
10641 | |||
10642 | } | ||
10643 | |||
10644 | } | ||
10645 | |||
10646 | catch (RecognitionException re) { | ||
10647 | recover(input,re); | ||
10648 | appendSkippedTokens(); | ||
10649 | } | ||
10650 | finally { | ||
10651 | } | ||
10652 | return current; | ||
10653 | } | ||
10654 | // $ANTLR end "entryRuleEnumLiteral" | ||
10655 | |||
10656 | |||
10657 | // $ANTLR start "ruleEnumLiteral" | ||
10658 | // InternalSolverLanguageParser.g:4157:1: ruleEnumLiteral returns [EObject current=null] : ( (lv_name_0_0= RULE_ID ) ) ; | ||
10659 | public final EObject ruleEnumLiteral() throws RecognitionException { | ||
10660 | EObject current = null; | ||
10661 | |||
10662 | Token lv_name_0_0=null; | ||
10663 | |||
10664 | |||
10665 | enterRule(); | ||
10666 | |||
10667 | try { | ||
10668 | // InternalSolverLanguageParser.g:4163:2: ( ( (lv_name_0_0= RULE_ID ) ) ) | ||
10669 | // InternalSolverLanguageParser.g:4164:2: ( (lv_name_0_0= RULE_ID ) ) | ||
10670 | { | ||
10671 | // InternalSolverLanguageParser.g:4164:2: ( (lv_name_0_0= RULE_ID ) ) | ||
10672 | // InternalSolverLanguageParser.g:4165:3: (lv_name_0_0= RULE_ID ) | ||
10673 | { | ||
10674 | // InternalSolverLanguageParser.g:4165:3: (lv_name_0_0= RULE_ID ) | ||
10675 | // InternalSolverLanguageParser.g:4166:4: lv_name_0_0= RULE_ID | ||
10676 | { | ||
10677 | lv_name_0_0=(Token)match(input,RULE_ID,FOLLOW_2); | ||
10678 | |||
10679 | newLeafNode(lv_name_0_0, grammarAccess.getEnumLiteralAccess().getNameIDTerminalRuleCall_0()); | ||
10680 | |||
10681 | |||
10682 | if (current==null) { | ||
10683 | current = createModelElement(grammarAccess.getEnumLiteralRule()); | ||
10684 | } | ||
10685 | setWithLastConsumed( | ||
10686 | current, | ||
10687 | "name", | ||
10688 | lv_name_0_0, | ||
10689 | "org.eclipse.xtext.common.Terminals.ID"); | ||
10690 | |||
10691 | |||
10692 | } | ||
10693 | |||
10694 | |||
10695 | } | ||
10696 | |||
10697 | |||
10698 | } | ||
10699 | |||
10700 | |||
10701 | leaveRule(); | ||
10702 | |||
10703 | } | ||
10704 | |||
10705 | catch (RecognitionException re) { | ||
10706 | recover(input,re); | ||
10707 | appendSkippedTokens(); | ||
10708 | } | ||
10709 | finally { | ||
10710 | } | ||
10711 | return current; | ||
10712 | } | ||
10713 | // $ANTLR end "ruleEnumLiteral" | ||
10714 | |||
10715 | |||
10716 | // $ANTLR start "entryRuleScopeDeclaration" | ||
10717 | // InternalSolverLanguageParser.g:4185:1: entryRuleScopeDeclaration returns [EObject current=null] : iv_ruleScopeDeclaration= ruleScopeDeclaration EOF ; | ||
10718 | public final EObject entryRuleScopeDeclaration() throws RecognitionException { | ||
10719 | EObject current = null; | ||
10720 | |||
10721 | EObject iv_ruleScopeDeclaration = null; | ||
10722 | |||
10723 | |||
10724 | try { | ||
10725 | // InternalSolverLanguageParser.g:4185:57: (iv_ruleScopeDeclaration= ruleScopeDeclaration EOF ) | ||
10726 | // InternalSolverLanguageParser.g:4186:2: iv_ruleScopeDeclaration= ruleScopeDeclaration EOF | ||
10727 | { | ||
10728 | newCompositeNode(grammarAccess.getScopeDeclarationRule()); | ||
10729 | pushFollow(FOLLOW_1); | ||
10730 | iv_ruleScopeDeclaration=ruleScopeDeclaration(); | ||
10731 | |||
10732 | state._fsp--; | ||
10733 | |||
10734 | current =iv_ruleScopeDeclaration; | ||
10735 | match(input,EOF,FOLLOW_2); | ||
10736 | |||
10737 | } | ||
10738 | |||
10739 | } | ||
10740 | |||
10741 | catch (RecognitionException re) { | ||
10742 | recover(input,re); | ||
10743 | appendSkippedTokens(); | ||
10744 | } | ||
10745 | finally { | ||
10746 | } | ||
10747 | return current; | ||
10748 | } | ||
10749 | // $ANTLR end "entryRuleScopeDeclaration" | ||
10750 | |||
10751 | |||
10752 | // $ANTLR start "ruleScopeDeclaration" | ||
10753 | // InternalSolverLanguageParser.g:4192:1: ruleScopeDeclaration returns [EObject current=null] : (this_ExactScope_0= ruleExactScope | this_BoundedScope_1= ruleBoundedScope | this_LowerBoundedScope_2= ruleLowerBoundedScope ) ; | ||
10754 | public final EObject ruleScopeDeclaration() throws RecognitionException { | ||
10755 | EObject current = null; | ||
10756 | |||
10757 | EObject this_ExactScope_0 = null; | ||
10758 | |||
10759 | EObject this_BoundedScope_1 = null; | ||
10760 | |||
10761 | EObject this_LowerBoundedScope_2 = null; | ||
10762 | |||
10763 | |||
10764 | |||
10765 | enterRule(); | ||
10766 | |||
10767 | try { | ||
10768 | // InternalSolverLanguageParser.g:4198:2: ( (this_ExactScope_0= ruleExactScope | this_BoundedScope_1= ruleBoundedScope | this_LowerBoundedScope_2= ruleLowerBoundedScope ) ) | ||
10769 | // InternalSolverLanguageParser.g:4199:2: (this_ExactScope_0= ruleExactScope | this_BoundedScope_1= ruleBoundedScope | this_LowerBoundedScope_2= ruleLowerBoundedScope ) | ||
10770 | { | ||
10771 | // InternalSolverLanguageParser.g:4199:2: (this_ExactScope_0= ruleExactScope | this_BoundedScope_1= ruleBoundedScope | this_LowerBoundedScope_2= ruleLowerBoundedScope ) | ||
10772 | int alt53=3; | ||
10773 | alt53 = dfa53.predict(input); | ||
10774 | switch (alt53) { | ||
10775 | case 1 : | ||
10776 | // InternalSolverLanguageParser.g:4200:3: this_ExactScope_0= ruleExactScope | ||
10777 | { | ||
10778 | |||
10779 | newCompositeNode(grammarAccess.getScopeDeclarationAccess().getExactScopeParserRuleCall_0()); | ||
10780 | |||
10781 | pushFollow(FOLLOW_2); | ||
10782 | this_ExactScope_0=ruleExactScope(); | ||
10783 | |||
10784 | state._fsp--; | ||
10785 | |||
10786 | |||
10787 | current = this_ExactScope_0; | ||
10788 | afterParserOrEnumRuleCall(); | ||
10789 | |||
10790 | |||
10791 | } | ||
10792 | break; | ||
10793 | case 2 : | ||
10794 | // InternalSolverLanguageParser.g:4209:3: this_BoundedScope_1= ruleBoundedScope | ||
10795 | { | ||
10796 | |||
10797 | newCompositeNode(grammarAccess.getScopeDeclarationAccess().getBoundedScopeParserRuleCall_1()); | ||
10798 | |||
10799 | pushFollow(FOLLOW_2); | ||
10800 | this_BoundedScope_1=ruleBoundedScope(); | ||
10801 | |||
10802 | state._fsp--; | ||
10803 | |||
10804 | |||
10805 | current = this_BoundedScope_1; | ||
10806 | afterParserOrEnumRuleCall(); | ||
10807 | |||
10808 | |||
10809 | } | ||
10810 | break; | ||
10811 | case 3 : | ||
10812 | // InternalSolverLanguageParser.g:4218:3: this_LowerBoundedScope_2= ruleLowerBoundedScope | ||
10813 | { | ||
10814 | |||
10815 | newCompositeNode(grammarAccess.getScopeDeclarationAccess().getLowerBoundedScopeParserRuleCall_2()); | ||
10816 | |||
10817 | pushFollow(FOLLOW_2); | ||
10818 | this_LowerBoundedScope_2=ruleLowerBoundedScope(); | ||
10819 | |||
10820 | state._fsp--; | ||
10821 | |||
10822 | |||
10823 | current = this_LowerBoundedScope_2; | ||
10824 | afterParserOrEnumRuleCall(); | ||
10825 | |||
10826 | |||
10827 | } | ||
10828 | break; | ||
10829 | |||
10830 | } | ||
10831 | |||
10832 | |||
10833 | } | ||
10834 | |||
10835 | |||
10836 | leaveRule(); | ||
10837 | |||
10838 | } | ||
10839 | |||
10840 | catch (RecognitionException re) { | ||
10841 | recover(input,re); | ||
10842 | appendSkippedTokens(); | ||
10843 | } | ||
10844 | finally { | ||
10845 | } | ||
10846 | return current; | ||
10847 | } | ||
10848 | // $ANTLR end "ruleScopeDeclaration" | ||
10849 | |||
10850 | |||
10851 | // $ANTLR start "entryRuleExactScope" | ||
10852 | // InternalSolverLanguageParser.g:4230:1: entryRuleExactScope returns [EObject current=null] : iv_ruleExactScope= ruleExactScope EOF ; | ||
10853 | public final EObject entryRuleExactScope() throws RecognitionException { | ||
10854 | EObject current = null; | ||
10855 | |||
10856 | EObject iv_ruleExactScope = null; | ||
10857 | |||
10858 | |||
10859 | try { | ||
10860 | // InternalSolverLanguageParser.g:4230:51: (iv_ruleExactScope= ruleExactScope EOF ) | ||
10861 | // InternalSolverLanguageParser.g:4231:2: iv_ruleExactScope= ruleExactScope EOF | ||
10862 | { | ||
10863 | newCompositeNode(grammarAccess.getExactScopeRule()); | ||
10864 | pushFollow(FOLLOW_1); | ||
10865 | iv_ruleExactScope=ruleExactScope(); | ||
10866 | |||
10867 | state._fsp--; | ||
10868 | |||
10869 | current =iv_ruleExactScope; | ||
10870 | match(input,EOF,FOLLOW_2); | ||
10871 | |||
10872 | } | ||
10873 | |||
10874 | } | ||
10875 | |||
10876 | catch (RecognitionException re) { | ||
10877 | recover(input,re); | ||
10878 | appendSkippedTokens(); | ||
10879 | } | ||
10880 | finally { | ||
10881 | } | ||
10882 | return current; | ||
10883 | } | ||
10884 | // $ANTLR end "entryRuleExactScope" | ||
10885 | |||
10886 | |||
10887 | // $ANTLR start "ruleExactScope" | ||
10888 | // InternalSolverLanguageParser.g:4237:1: ruleExactScope returns [EObject current=null] : (otherlv_0= Scope ( ( ruleQualifiedName ) ) otherlv_2= EqualsSignEqualsSign ( (lv_size_3_0= RULE_INT ) ) this_FULL_STOP_4= RULE_FULL_STOP ) ; | ||
10889 | public final EObject ruleExactScope() throws RecognitionException { | ||
10890 | EObject current = null; | ||
10891 | |||
10892 | Token otherlv_0=null; | ||
10893 | Token otherlv_2=null; | ||
10894 | Token lv_size_3_0=null; | ||
10895 | Token this_FULL_STOP_4=null; | ||
10896 | |||
10897 | |||
10898 | enterRule(); | ||
10899 | |||
10900 | try { | ||
10901 | // InternalSolverLanguageParser.g:4243:2: ( (otherlv_0= Scope ( ( ruleQualifiedName ) ) otherlv_2= EqualsSignEqualsSign ( (lv_size_3_0= RULE_INT ) ) this_FULL_STOP_4= RULE_FULL_STOP ) ) | ||
10902 | // InternalSolverLanguageParser.g:4244:2: (otherlv_0= Scope ( ( ruleQualifiedName ) ) otherlv_2= EqualsSignEqualsSign ( (lv_size_3_0= RULE_INT ) ) this_FULL_STOP_4= RULE_FULL_STOP ) | ||
10903 | { | ||
10904 | // InternalSolverLanguageParser.g:4244:2: (otherlv_0= Scope ( ( ruleQualifiedName ) ) otherlv_2= EqualsSignEqualsSign ( (lv_size_3_0= RULE_INT ) ) this_FULL_STOP_4= RULE_FULL_STOP ) | ||
10905 | // InternalSolverLanguageParser.g:4245:3: otherlv_0= Scope ( ( ruleQualifiedName ) ) otherlv_2= EqualsSignEqualsSign ( (lv_size_3_0= RULE_INT ) ) this_FULL_STOP_4= RULE_FULL_STOP | ||
10906 | { | ||
10907 | otherlv_0=(Token)match(input,Scope,FOLLOW_3); | ||
10908 | |||
10909 | newLeafNode(otherlv_0, grammarAccess.getExactScopeAccess().getScopeKeyword_0()); | ||
10910 | |||
10911 | // InternalSolverLanguageParser.g:4249:3: ( ( ruleQualifiedName ) ) | ||
10912 | // InternalSolverLanguageParser.g:4250:4: ( ruleQualifiedName ) | ||
10913 | { | ||
10914 | // InternalSolverLanguageParser.g:4250:4: ( ruleQualifiedName ) | ||
10915 | // InternalSolverLanguageParser.g:4251:5: ruleQualifiedName | ||
10916 | { | ||
10917 | |||
10918 | if (current==null) { | ||
10919 | current = createModelElement(grammarAccess.getExactScopeRule()); | ||
10920 | } | ||
10921 | |||
10922 | |||
10923 | newCompositeNode(grammarAccess.getExactScopeAccess().getTypeSymbolCrossReference_1_0()); | ||
10924 | |||
10925 | pushFollow(FOLLOW_61); | ||
10926 | ruleQualifiedName(); | ||
10927 | |||
10928 | state._fsp--; | ||
10929 | |||
10930 | |||
10931 | afterParserOrEnumRuleCall(); | ||
10932 | |||
10933 | |||
10934 | } | ||
10935 | |||
10936 | |||
10937 | } | ||
10938 | |||
10939 | otherlv_2=(Token)match(input,EqualsSignEqualsSign,FOLLOW_57); | ||
10940 | |||
10941 | newLeafNode(otherlv_2, grammarAccess.getExactScopeAccess().getEqualsSignEqualsSignKeyword_2()); | ||
10942 | |||
10943 | // InternalSolverLanguageParser.g:4269:3: ( (lv_size_3_0= RULE_INT ) ) | ||
10944 | // InternalSolverLanguageParser.g:4270:4: (lv_size_3_0= RULE_INT ) | ||
10945 | { | ||
10946 | // InternalSolverLanguageParser.g:4270:4: (lv_size_3_0= RULE_INT ) | ||
10947 | // InternalSolverLanguageParser.g:4271:5: lv_size_3_0= RULE_INT | ||
10948 | { | ||
10949 | lv_size_3_0=(Token)match(input,RULE_INT,FOLLOW_4); | ||
10950 | |||
10951 | newLeafNode(lv_size_3_0, grammarAccess.getExactScopeAccess().getSizeINTTerminalRuleCall_3_0()); | ||
10952 | |||
10953 | |||
10954 | if (current==null) { | ||
10955 | current = createModelElement(grammarAccess.getExactScopeRule()); | ||
10956 | } | ||
10957 | setWithLastConsumed( | ||
10958 | current, | ||
10959 | "size", | ||
10960 | lv_size_3_0, | ||
10961 | "org.eclipse.xtext.common.Terminals.INT"); | ||
10962 | |||
10963 | |||
10964 | } | ||
10965 | |||
10966 | |||
10967 | } | ||
10968 | |||
10969 | this_FULL_STOP_4=(Token)match(input,RULE_FULL_STOP,FOLLOW_2); | ||
10970 | |||
10971 | newLeafNode(this_FULL_STOP_4, grammarAccess.getExactScopeAccess().getFULL_STOPTerminalRuleCall_4()); | ||
10972 | |||
10973 | |||
10974 | } | ||
10975 | |||
10976 | |||
10977 | } | ||
10978 | |||
10979 | |||
10980 | leaveRule(); | ||
10981 | |||
10982 | } | ||
10983 | |||
10984 | catch (RecognitionException re) { | ||
10985 | recover(input,re); | ||
10986 | appendSkippedTokens(); | ||
10987 | } | ||
10988 | finally { | ||
10989 | } | ||
10990 | return current; | ||
10991 | } | ||
10992 | // $ANTLR end "ruleExactScope" | ||
10993 | |||
10994 | |||
10995 | // $ANTLR start "entryRuleBoundedScope" | ||
10996 | // InternalSolverLanguageParser.g:4295:1: entryRuleBoundedScope returns [EObject current=null] : iv_ruleBoundedScope= ruleBoundedScope EOF ; | ||
10997 | public final EObject entryRuleBoundedScope() throws RecognitionException { | ||
10998 | EObject current = null; | ||
10999 | |||
11000 | EObject iv_ruleBoundedScope = null; | ||
11001 | |||
11002 | |||
11003 | try { | ||
11004 | // InternalSolverLanguageParser.g:4295:53: (iv_ruleBoundedScope= ruleBoundedScope EOF ) | ||
11005 | // InternalSolverLanguageParser.g:4296:2: iv_ruleBoundedScope= ruleBoundedScope EOF | ||
11006 | { | ||
11007 | newCompositeNode(grammarAccess.getBoundedScopeRule()); | ||
11008 | pushFollow(FOLLOW_1); | ||
11009 | iv_ruleBoundedScope=ruleBoundedScope(); | ||
11010 | |||
11011 | state._fsp--; | ||
11012 | |||
11013 | current =iv_ruleBoundedScope; | ||
11014 | match(input,EOF,FOLLOW_2); | ||
11015 | |||
11016 | } | ||
11017 | |||
11018 | } | ||
11019 | |||
11020 | catch (RecognitionException re) { | ||
11021 | recover(input,re); | ||
11022 | appendSkippedTokens(); | ||
11023 | } | ||
11024 | finally { | ||
11025 | } | ||
11026 | return current; | ||
11027 | } | ||
11028 | // $ANTLR end "entryRuleBoundedScope" | ||
11029 | |||
11030 | |||
11031 | // $ANTLR start "ruleBoundedScope" | ||
11032 | // InternalSolverLanguageParser.g:4302:1: ruleBoundedScope returns [EObject current=null] : (otherlv_0= Scope ( ( ( ( (lv_lowerBound_1_0= RULE_INT ) ) otherlv_2= LessThanSignEqualsSign )? ( ( ruleQualifiedName ) ) otherlv_4= LessThanSignEqualsSign ( (lv_upperBound_5_0= RULE_INT ) ) ) | ( ( (lv_upperBound_6_0= RULE_INT ) ) otherlv_7= GreaterThanSignEqualsSign ( ( ruleQualifiedName ) ) (otherlv_9= GreaterThanSignEqualsSign ( (lv_lowerBound_10_0= RULE_INT ) ) )? ) ) this_FULL_STOP_11= RULE_FULL_STOP ) ; | ||
11033 | public final EObject ruleBoundedScope() throws RecognitionException { | ||
11034 | EObject current = null; | ||
11035 | |||
11036 | Token otherlv_0=null; | ||
11037 | Token lv_lowerBound_1_0=null; | ||
11038 | Token otherlv_2=null; | ||
11039 | Token otherlv_4=null; | ||
11040 | Token lv_upperBound_5_0=null; | ||
11041 | Token lv_upperBound_6_0=null; | ||
11042 | Token otherlv_7=null; | ||
11043 | Token otherlv_9=null; | ||
11044 | Token lv_lowerBound_10_0=null; | ||
11045 | Token this_FULL_STOP_11=null; | ||
11046 | |||
11047 | |||
11048 | enterRule(); | ||
11049 | |||
11050 | try { | ||
11051 | // InternalSolverLanguageParser.g:4308:2: ( (otherlv_0= Scope ( ( ( ( (lv_lowerBound_1_0= RULE_INT ) ) otherlv_2= LessThanSignEqualsSign )? ( ( ruleQualifiedName ) ) otherlv_4= LessThanSignEqualsSign ( (lv_upperBound_5_0= RULE_INT ) ) ) | ( ( (lv_upperBound_6_0= RULE_INT ) ) otherlv_7= GreaterThanSignEqualsSign ( ( ruleQualifiedName ) ) (otherlv_9= GreaterThanSignEqualsSign ( (lv_lowerBound_10_0= RULE_INT ) ) )? ) ) this_FULL_STOP_11= RULE_FULL_STOP ) ) | ||
11052 | // InternalSolverLanguageParser.g:4309:2: (otherlv_0= Scope ( ( ( ( (lv_lowerBound_1_0= RULE_INT ) ) otherlv_2= LessThanSignEqualsSign )? ( ( ruleQualifiedName ) ) otherlv_4= LessThanSignEqualsSign ( (lv_upperBound_5_0= RULE_INT ) ) ) | ( ( (lv_upperBound_6_0= RULE_INT ) ) otherlv_7= GreaterThanSignEqualsSign ( ( ruleQualifiedName ) ) (otherlv_9= GreaterThanSignEqualsSign ( (lv_lowerBound_10_0= RULE_INT ) ) )? ) ) this_FULL_STOP_11= RULE_FULL_STOP ) | ||
11053 | { | ||
11054 | // InternalSolverLanguageParser.g:4309:2: (otherlv_0= Scope ( ( ( ( (lv_lowerBound_1_0= RULE_INT ) ) otherlv_2= LessThanSignEqualsSign )? ( ( ruleQualifiedName ) ) otherlv_4= LessThanSignEqualsSign ( (lv_upperBound_5_0= RULE_INT ) ) ) | ( ( (lv_upperBound_6_0= RULE_INT ) ) otherlv_7= GreaterThanSignEqualsSign ( ( ruleQualifiedName ) ) (otherlv_9= GreaterThanSignEqualsSign ( (lv_lowerBound_10_0= RULE_INT ) ) )? ) ) this_FULL_STOP_11= RULE_FULL_STOP ) | ||
11055 | // InternalSolverLanguageParser.g:4310:3: otherlv_0= Scope ( ( ( ( (lv_lowerBound_1_0= RULE_INT ) ) otherlv_2= LessThanSignEqualsSign )? ( ( ruleQualifiedName ) ) otherlv_4= LessThanSignEqualsSign ( (lv_upperBound_5_0= RULE_INT ) ) ) | ( ( (lv_upperBound_6_0= RULE_INT ) ) otherlv_7= GreaterThanSignEqualsSign ( ( ruleQualifiedName ) ) (otherlv_9= GreaterThanSignEqualsSign ( (lv_lowerBound_10_0= RULE_INT ) ) )? ) ) this_FULL_STOP_11= RULE_FULL_STOP | ||
11056 | { | ||
11057 | otherlv_0=(Token)match(input,Scope,FOLLOW_62); | ||
11058 | |||
11059 | newLeafNode(otherlv_0, grammarAccess.getBoundedScopeAccess().getScopeKeyword_0()); | ||
11060 | |||
11061 | // InternalSolverLanguageParser.g:4314:3: ( ( ( ( (lv_lowerBound_1_0= RULE_INT ) ) otherlv_2= LessThanSignEqualsSign )? ( ( ruleQualifiedName ) ) otherlv_4= LessThanSignEqualsSign ( (lv_upperBound_5_0= RULE_INT ) ) ) | ( ( (lv_upperBound_6_0= RULE_INT ) ) otherlv_7= GreaterThanSignEqualsSign ( ( ruleQualifiedName ) ) (otherlv_9= GreaterThanSignEqualsSign ( (lv_lowerBound_10_0= RULE_INT ) ) )? ) ) | ||
11062 | int alt56=2; | ||
11063 | int LA56_0 = input.LA(1); | ||
11064 | |||
11065 | if ( (LA56_0==RULE_INT) ) { | ||
11066 | int LA56_1 = input.LA(2); | ||
11067 | |||
11068 | if ( (LA56_1==LessThanSignEqualsSign) ) { | ||
11069 | alt56=1; | ||
11070 | } | ||
11071 | else if ( (LA56_1==GreaterThanSignEqualsSign) ) { | ||
11072 | alt56=2; | ||
11073 | } | ||
11074 | else { | ||
11075 | NoViableAltException nvae = | ||
11076 | new NoViableAltException("", 56, 1, input); | ||
11077 | |||
11078 | throw nvae; | ||
11079 | } | ||
11080 | } | ||
11081 | else if ( (LA56_0==Object||LA56_0==RULE_QUOTED_ID||LA56_0==RULE_ID) ) { | ||
11082 | alt56=1; | ||
11083 | } | ||
11084 | else { | ||
11085 | NoViableAltException nvae = | ||
11086 | new NoViableAltException("", 56, 0, input); | ||
11087 | |||
11088 | throw nvae; | ||
11089 | } | ||
11090 | switch (alt56) { | ||
11091 | case 1 : | ||
11092 | // InternalSolverLanguageParser.g:4315:4: ( ( ( (lv_lowerBound_1_0= RULE_INT ) ) otherlv_2= LessThanSignEqualsSign )? ( ( ruleQualifiedName ) ) otherlv_4= LessThanSignEqualsSign ( (lv_upperBound_5_0= RULE_INT ) ) ) | ||
11093 | { | ||
11094 | // InternalSolverLanguageParser.g:4315:4: ( ( ( (lv_lowerBound_1_0= RULE_INT ) ) otherlv_2= LessThanSignEqualsSign )? ( ( ruleQualifiedName ) ) otherlv_4= LessThanSignEqualsSign ( (lv_upperBound_5_0= RULE_INT ) ) ) | ||
11095 | // InternalSolverLanguageParser.g:4316:5: ( ( (lv_lowerBound_1_0= RULE_INT ) ) otherlv_2= LessThanSignEqualsSign )? ( ( ruleQualifiedName ) ) otherlv_4= LessThanSignEqualsSign ( (lv_upperBound_5_0= RULE_INT ) ) | ||
11096 | { | ||
11097 | // InternalSolverLanguageParser.g:4316:5: ( ( (lv_lowerBound_1_0= RULE_INT ) ) otherlv_2= LessThanSignEqualsSign )? | ||
11098 | int alt54=2; | ||
11099 | int LA54_0 = input.LA(1); | ||
11100 | |||
11101 | if ( (LA54_0==RULE_INT) ) { | ||
11102 | alt54=1; | ||
11103 | } | ||
11104 | switch (alt54) { | ||
11105 | case 1 : | ||
11106 | // InternalSolverLanguageParser.g:4317:6: ( (lv_lowerBound_1_0= RULE_INT ) ) otherlv_2= LessThanSignEqualsSign | ||
11107 | { | ||
11108 | // InternalSolverLanguageParser.g:4317:6: ( (lv_lowerBound_1_0= RULE_INT ) ) | ||
11109 | // InternalSolverLanguageParser.g:4318:7: (lv_lowerBound_1_0= RULE_INT ) | ||
11110 | { | ||
11111 | // InternalSolverLanguageParser.g:4318:7: (lv_lowerBound_1_0= RULE_INT ) | ||
11112 | // InternalSolverLanguageParser.g:4319:8: lv_lowerBound_1_0= RULE_INT | ||
11113 | { | ||
11114 | lv_lowerBound_1_0=(Token)match(input,RULE_INT,FOLLOW_63); | ||
11115 | |||
11116 | newLeafNode(lv_lowerBound_1_0, grammarAccess.getBoundedScopeAccess().getLowerBoundINTTerminalRuleCall_1_0_0_0_0()); | ||
11117 | |||
11118 | |||
11119 | if (current==null) { | ||
11120 | current = createModelElement(grammarAccess.getBoundedScopeRule()); | ||
11121 | } | ||
11122 | setWithLastConsumed( | ||
11123 | current, | ||
11124 | "lowerBound", | ||
11125 | lv_lowerBound_1_0, | ||
11126 | "org.eclipse.xtext.common.Terminals.INT"); | ||
11127 | |||
11128 | |||
11129 | } | ||
11130 | |||
11131 | |||
11132 | } | ||
11133 | |||
11134 | otherlv_2=(Token)match(input,LessThanSignEqualsSign,FOLLOW_3); | ||
11135 | |||
11136 | newLeafNode(otherlv_2, grammarAccess.getBoundedScopeAccess().getLessThanSignEqualsSignKeyword_1_0_0_1()); | ||
11137 | |||
11138 | |||
11139 | } | ||
11140 | break; | ||
11141 | |||
11142 | } | ||
11143 | |||
11144 | // InternalSolverLanguageParser.g:4340:5: ( ( ruleQualifiedName ) ) | ||
11145 | // InternalSolverLanguageParser.g:4341:6: ( ruleQualifiedName ) | ||
11146 | { | ||
11147 | // InternalSolverLanguageParser.g:4341:6: ( ruleQualifiedName ) | ||
11148 | // InternalSolverLanguageParser.g:4342:7: ruleQualifiedName | ||
11149 | { | ||
11150 | |||
11151 | if (current==null) { | ||
11152 | current = createModelElement(grammarAccess.getBoundedScopeRule()); | ||
11153 | } | ||
11154 | |||
11155 | |||
11156 | newCompositeNode(grammarAccess.getBoundedScopeAccess().getTypeSymbolCrossReference_1_0_1_0()); | ||
11157 | |||
11158 | pushFollow(FOLLOW_63); | ||
11159 | ruleQualifiedName(); | ||
11160 | |||
11161 | state._fsp--; | ||
11162 | |||
11163 | |||
11164 | afterParserOrEnumRuleCall(); | ||
11165 | |||
11166 | |||
11167 | } | ||
11168 | |||
11169 | |||
11170 | } | ||
11171 | |||
11172 | otherlv_4=(Token)match(input,LessThanSignEqualsSign,FOLLOW_57); | ||
11173 | |||
11174 | newLeafNode(otherlv_4, grammarAccess.getBoundedScopeAccess().getLessThanSignEqualsSignKeyword_1_0_2()); | ||
11175 | |||
11176 | // InternalSolverLanguageParser.g:4360:5: ( (lv_upperBound_5_0= RULE_INT ) ) | ||
11177 | // InternalSolverLanguageParser.g:4361:6: (lv_upperBound_5_0= RULE_INT ) | ||
11178 | { | ||
11179 | // InternalSolverLanguageParser.g:4361:6: (lv_upperBound_5_0= RULE_INT ) | ||
11180 | // InternalSolverLanguageParser.g:4362:7: lv_upperBound_5_0= RULE_INT | ||
11181 | { | ||
11182 | lv_upperBound_5_0=(Token)match(input,RULE_INT,FOLLOW_4); | ||
11183 | |||
11184 | newLeafNode(lv_upperBound_5_0, grammarAccess.getBoundedScopeAccess().getUpperBoundINTTerminalRuleCall_1_0_3_0()); | ||
11185 | |||
11186 | |||
11187 | if (current==null) { | ||
11188 | current = createModelElement(grammarAccess.getBoundedScopeRule()); | ||
11189 | } | ||
11190 | setWithLastConsumed( | ||
11191 | current, | ||
11192 | "upperBound", | ||
11193 | lv_upperBound_5_0, | ||
11194 | "org.eclipse.xtext.common.Terminals.INT"); | ||
11195 | |||
11196 | |||
11197 | } | ||
11198 | |||
11199 | |||
11200 | } | ||
11201 | |||
11202 | |||
11203 | } | ||
11204 | |||
11205 | |||
11206 | } | ||
11207 | break; | ||
11208 | case 2 : | ||
11209 | // InternalSolverLanguageParser.g:4380:4: ( ( (lv_upperBound_6_0= RULE_INT ) ) otherlv_7= GreaterThanSignEqualsSign ( ( ruleQualifiedName ) ) (otherlv_9= GreaterThanSignEqualsSign ( (lv_lowerBound_10_0= RULE_INT ) ) )? ) | ||
11210 | { | ||
11211 | // InternalSolverLanguageParser.g:4380:4: ( ( (lv_upperBound_6_0= RULE_INT ) ) otherlv_7= GreaterThanSignEqualsSign ( ( ruleQualifiedName ) ) (otherlv_9= GreaterThanSignEqualsSign ( (lv_lowerBound_10_0= RULE_INT ) ) )? ) | ||
11212 | // InternalSolverLanguageParser.g:4381:5: ( (lv_upperBound_6_0= RULE_INT ) ) otherlv_7= GreaterThanSignEqualsSign ( ( ruleQualifiedName ) ) (otherlv_9= GreaterThanSignEqualsSign ( (lv_lowerBound_10_0= RULE_INT ) ) )? | ||
11213 | { | ||
11214 | // InternalSolverLanguageParser.g:4381:5: ( (lv_upperBound_6_0= RULE_INT ) ) | ||
11215 | // InternalSolverLanguageParser.g:4382:6: (lv_upperBound_6_0= RULE_INT ) | ||
11216 | { | ||
11217 | // InternalSolverLanguageParser.g:4382:6: (lv_upperBound_6_0= RULE_INT ) | ||
11218 | // InternalSolverLanguageParser.g:4383:7: lv_upperBound_6_0= RULE_INT | ||
11219 | { | ||
11220 | lv_upperBound_6_0=(Token)match(input,RULE_INT,FOLLOW_64); | ||
11221 | |||
11222 | newLeafNode(lv_upperBound_6_0, grammarAccess.getBoundedScopeAccess().getUpperBoundINTTerminalRuleCall_1_1_0_0()); | ||
11223 | |||
11224 | |||
11225 | if (current==null) { | ||
11226 | current = createModelElement(grammarAccess.getBoundedScopeRule()); | ||
11227 | } | ||
11228 | setWithLastConsumed( | ||
11229 | current, | ||
11230 | "upperBound", | ||
11231 | lv_upperBound_6_0, | ||
11232 | "org.eclipse.xtext.common.Terminals.INT"); | ||
11233 | |||
11234 | |||
11235 | } | ||
11236 | |||
11237 | |||
11238 | } | ||
11239 | |||
11240 | otherlv_7=(Token)match(input,GreaterThanSignEqualsSign,FOLLOW_3); | ||
11241 | |||
11242 | newLeafNode(otherlv_7, grammarAccess.getBoundedScopeAccess().getGreaterThanSignEqualsSignKeyword_1_1_1()); | ||
11243 | |||
11244 | // InternalSolverLanguageParser.g:4403:5: ( ( ruleQualifiedName ) ) | ||
11245 | // InternalSolverLanguageParser.g:4404:6: ( ruleQualifiedName ) | ||
11246 | { | ||
11247 | // InternalSolverLanguageParser.g:4404:6: ( ruleQualifiedName ) | ||
11248 | // InternalSolverLanguageParser.g:4405:7: ruleQualifiedName | ||
11249 | { | ||
11250 | |||
11251 | if (current==null) { | ||
11252 | current = createModelElement(grammarAccess.getBoundedScopeRule()); | ||
11253 | } | ||
11254 | |||
11255 | |||
11256 | newCompositeNode(grammarAccess.getBoundedScopeAccess().getTypeSymbolCrossReference_1_1_2_0()); | ||
11257 | |||
11258 | pushFollow(FOLLOW_65); | ||
11259 | ruleQualifiedName(); | ||
11260 | |||
11261 | state._fsp--; | ||
11262 | |||
11263 | |||
11264 | afterParserOrEnumRuleCall(); | ||
11265 | |||
11266 | |||
11267 | } | ||
11268 | |||
11269 | |||
11270 | } | ||
11271 | |||
11272 | // InternalSolverLanguageParser.g:4419:5: (otherlv_9= GreaterThanSignEqualsSign ( (lv_lowerBound_10_0= RULE_INT ) ) )? | ||
11273 | int alt55=2; | ||
11274 | int LA55_0 = input.LA(1); | ||
11275 | |||
11276 | if ( (LA55_0==GreaterThanSignEqualsSign) ) { | ||
11277 | alt55=1; | ||
11278 | } | ||
11279 | switch (alt55) { | ||
11280 | case 1 : | ||
11281 | // InternalSolverLanguageParser.g:4420:6: otherlv_9= GreaterThanSignEqualsSign ( (lv_lowerBound_10_0= RULE_INT ) ) | ||
11282 | { | ||
11283 | otherlv_9=(Token)match(input,GreaterThanSignEqualsSign,FOLLOW_57); | ||
11284 | |||
11285 | newLeafNode(otherlv_9, grammarAccess.getBoundedScopeAccess().getGreaterThanSignEqualsSignKeyword_1_1_3_0()); | ||
11286 | |||
11287 | // InternalSolverLanguageParser.g:4424:6: ( (lv_lowerBound_10_0= RULE_INT ) ) | ||
11288 | // InternalSolverLanguageParser.g:4425:7: (lv_lowerBound_10_0= RULE_INT ) | ||
11289 | { | ||
11290 | // InternalSolverLanguageParser.g:4425:7: (lv_lowerBound_10_0= RULE_INT ) | ||
11291 | // InternalSolverLanguageParser.g:4426:8: lv_lowerBound_10_0= RULE_INT | ||
11292 | { | ||
11293 | lv_lowerBound_10_0=(Token)match(input,RULE_INT,FOLLOW_4); | ||
11294 | |||
11295 | newLeafNode(lv_lowerBound_10_0, grammarAccess.getBoundedScopeAccess().getLowerBoundINTTerminalRuleCall_1_1_3_1_0()); | ||
11296 | |||
11297 | |||
11298 | if (current==null) { | ||
11299 | current = createModelElement(grammarAccess.getBoundedScopeRule()); | ||
11300 | } | ||
11301 | setWithLastConsumed( | ||
11302 | current, | ||
11303 | "lowerBound", | ||
11304 | lv_lowerBound_10_0, | ||
11305 | "org.eclipse.xtext.common.Terminals.INT"); | ||
11306 | |||
11307 | |||
11308 | } | ||
11309 | |||
11310 | |||
11311 | } | ||
11312 | |||
11313 | |||
11314 | } | ||
11315 | break; | ||
11316 | |||
11317 | } | ||
11318 | |||
11319 | |||
11320 | } | ||
11321 | |||
11322 | |||
11323 | } | ||
11324 | break; | ||
11325 | |||
11326 | } | ||
11327 | |||
11328 | this_FULL_STOP_11=(Token)match(input,RULE_FULL_STOP,FOLLOW_2); | ||
11329 | |||
11330 | newLeafNode(this_FULL_STOP_11, grammarAccess.getBoundedScopeAccess().getFULL_STOPTerminalRuleCall_2()); | ||
11331 | |||
11332 | |||
11333 | } | ||
11334 | |||
11335 | |||
11336 | } | ||
11337 | |||
11338 | |||
11339 | leaveRule(); | ||
11340 | |||
11341 | } | ||
11342 | |||
11343 | catch (RecognitionException re) { | ||
11344 | recover(input,re); | ||
11345 | appendSkippedTokens(); | ||
11346 | } | ||
11347 | finally { | ||
11348 | } | ||
11349 | return current; | ||
11350 | } | ||
11351 | // $ANTLR end "ruleBoundedScope" | ||
11352 | |||
11353 | |||
11354 | // $ANTLR start "entryRuleLowerBoundedScope" | ||
11355 | // InternalSolverLanguageParser.g:4453:1: entryRuleLowerBoundedScope returns [EObject current=null] : iv_ruleLowerBoundedScope= ruleLowerBoundedScope EOF ; | ||
11356 | public final EObject entryRuleLowerBoundedScope() throws RecognitionException { | ||
11357 | EObject current = null; | ||
11358 | |||
11359 | EObject iv_ruleLowerBoundedScope = null; | ||
11360 | |||
11361 | |||
11362 | try { | ||
11363 | // InternalSolverLanguageParser.g:4453:58: (iv_ruleLowerBoundedScope= ruleLowerBoundedScope EOF ) | ||
11364 | // InternalSolverLanguageParser.g:4454:2: iv_ruleLowerBoundedScope= ruleLowerBoundedScope EOF | ||
11365 | { | ||
11366 | newCompositeNode(grammarAccess.getLowerBoundedScopeRule()); | ||
11367 | pushFollow(FOLLOW_1); | ||
11368 | iv_ruleLowerBoundedScope=ruleLowerBoundedScope(); | ||
11369 | |||
11370 | state._fsp--; | ||
11371 | |||
11372 | current =iv_ruleLowerBoundedScope; | ||
11373 | match(input,EOF,FOLLOW_2); | ||
11374 | |||
11375 | } | ||
11376 | |||
11377 | } | ||
11378 | |||
11379 | catch (RecognitionException re) { | ||
11380 | recover(input,re); | ||
11381 | appendSkippedTokens(); | ||
11382 | } | ||
11383 | finally { | ||
11384 | } | ||
11385 | return current; | ||
11386 | } | ||
11387 | // $ANTLR end "entryRuleLowerBoundedScope" | ||
11388 | |||
11389 | |||
11390 | // $ANTLR start "ruleLowerBoundedScope" | ||
11391 | // InternalSolverLanguageParser.g:4460:1: ruleLowerBoundedScope returns [EObject current=null] : (otherlv_0= Scope ( ( ( (lv_lowerBound_1_0= RULE_INT ) ) otherlv_2= LessThanSignEqualsSign ( ( ruleQualifiedName ) ) ) | ( ( ( ruleQualifiedName ) ) otherlv_5= GreaterThanSignEqualsSign ( (lv_lowerBound_6_0= RULE_INT ) ) ) ) this_FULL_STOP_7= RULE_FULL_STOP ) ; | ||
11392 | public final EObject ruleLowerBoundedScope() throws RecognitionException { | ||
11393 | EObject current = null; | ||
11394 | |||
11395 | Token otherlv_0=null; | ||
11396 | Token lv_lowerBound_1_0=null; | ||
11397 | Token otherlv_2=null; | ||
11398 | Token otherlv_5=null; | ||
11399 | Token lv_lowerBound_6_0=null; | ||
11400 | Token this_FULL_STOP_7=null; | ||
11401 | |||
11402 | |||
11403 | enterRule(); | ||
11404 | |||
11405 | try { | ||
11406 | // InternalSolverLanguageParser.g:4466:2: ( (otherlv_0= Scope ( ( ( (lv_lowerBound_1_0= RULE_INT ) ) otherlv_2= LessThanSignEqualsSign ( ( ruleQualifiedName ) ) ) | ( ( ( ruleQualifiedName ) ) otherlv_5= GreaterThanSignEqualsSign ( (lv_lowerBound_6_0= RULE_INT ) ) ) ) this_FULL_STOP_7= RULE_FULL_STOP ) ) | ||
11407 | // InternalSolverLanguageParser.g:4467:2: (otherlv_0= Scope ( ( ( (lv_lowerBound_1_0= RULE_INT ) ) otherlv_2= LessThanSignEqualsSign ( ( ruleQualifiedName ) ) ) | ( ( ( ruleQualifiedName ) ) otherlv_5= GreaterThanSignEqualsSign ( (lv_lowerBound_6_0= RULE_INT ) ) ) ) this_FULL_STOP_7= RULE_FULL_STOP ) | ||
11408 | { | ||
11409 | // InternalSolverLanguageParser.g:4467:2: (otherlv_0= Scope ( ( ( (lv_lowerBound_1_0= RULE_INT ) ) otherlv_2= LessThanSignEqualsSign ( ( ruleQualifiedName ) ) ) | ( ( ( ruleQualifiedName ) ) otherlv_5= GreaterThanSignEqualsSign ( (lv_lowerBound_6_0= RULE_INT ) ) ) ) this_FULL_STOP_7= RULE_FULL_STOP ) | ||
11410 | // InternalSolverLanguageParser.g:4468:3: otherlv_0= Scope ( ( ( (lv_lowerBound_1_0= RULE_INT ) ) otherlv_2= LessThanSignEqualsSign ( ( ruleQualifiedName ) ) ) | ( ( ( ruleQualifiedName ) ) otherlv_5= GreaterThanSignEqualsSign ( (lv_lowerBound_6_0= RULE_INT ) ) ) ) this_FULL_STOP_7= RULE_FULL_STOP | ||
11411 | { | ||
11412 | otherlv_0=(Token)match(input,Scope,FOLLOW_62); | ||
11413 | |||
11414 | newLeafNode(otherlv_0, grammarAccess.getLowerBoundedScopeAccess().getScopeKeyword_0()); | ||
11415 | |||
11416 | // InternalSolverLanguageParser.g:4472:3: ( ( ( (lv_lowerBound_1_0= RULE_INT ) ) otherlv_2= LessThanSignEqualsSign ( ( ruleQualifiedName ) ) ) | ( ( ( ruleQualifiedName ) ) otherlv_5= GreaterThanSignEqualsSign ( (lv_lowerBound_6_0= RULE_INT ) ) ) ) | ||
11417 | int alt57=2; | ||
11418 | int LA57_0 = input.LA(1); | ||
11419 | |||
11420 | if ( (LA57_0==RULE_INT) ) { | ||
11421 | alt57=1; | ||
11422 | } | ||
11423 | else if ( (LA57_0==Object||LA57_0==RULE_QUOTED_ID||LA57_0==RULE_ID) ) { | ||
11424 | alt57=2; | ||
11425 | } | ||
11426 | else { | ||
11427 | NoViableAltException nvae = | ||
11428 | new NoViableAltException("", 57, 0, input); | ||
11429 | |||
11430 | throw nvae; | ||
11431 | } | ||
11432 | switch (alt57) { | ||
11433 | case 1 : | ||
11434 | // InternalSolverLanguageParser.g:4473:4: ( ( (lv_lowerBound_1_0= RULE_INT ) ) otherlv_2= LessThanSignEqualsSign ( ( ruleQualifiedName ) ) ) | ||
11435 | { | ||
11436 | // InternalSolverLanguageParser.g:4473:4: ( ( (lv_lowerBound_1_0= RULE_INT ) ) otherlv_2= LessThanSignEqualsSign ( ( ruleQualifiedName ) ) ) | ||
11437 | // InternalSolverLanguageParser.g:4474:5: ( (lv_lowerBound_1_0= RULE_INT ) ) otherlv_2= LessThanSignEqualsSign ( ( ruleQualifiedName ) ) | ||
11438 | { | ||
11439 | // InternalSolverLanguageParser.g:4474:5: ( (lv_lowerBound_1_0= RULE_INT ) ) | ||
11440 | // InternalSolverLanguageParser.g:4475:6: (lv_lowerBound_1_0= RULE_INT ) | ||
11441 | { | ||
11442 | // InternalSolverLanguageParser.g:4475:6: (lv_lowerBound_1_0= RULE_INT ) | ||
11443 | // InternalSolverLanguageParser.g:4476:7: lv_lowerBound_1_0= RULE_INT | ||
11444 | { | ||
11445 | lv_lowerBound_1_0=(Token)match(input,RULE_INT,FOLLOW_63); | ||
11446 | |||
11447 | newLeafNode(lv_lowerBound_1_0, grammarAccess.getLowerBoundedScopeAccess().getLowerBoundINTTerminalRuleCall_1_0_0_0()); | ||
11448 | |||
11449 | |||
11450 | if (current==null) { | ||
11451 | current = createModelElement(grammarAccess.getLowerBoundedScopeRule()); | ||
11452 | } | ||
11453 | setWithLastConsumed( | ||
11454 | current, | ||
11455 | "lowerBound", | ||
11456 | lv_lowerBound_1_0, | ||
11457 | "org.eclipse.xtext.common.Terminals.INT"); | ||
11458 | |||
11459 | |||
11460 | } | ||
11461 | |||
11462 | |||
11463 | } | ||
11464 | |||
11465 | otherlv_2=(Token)match(input,LessThanSignEqualsSign,FOLLOW_3); | ||
11466 | |||
11467 | newLeafNode(otherlv_2, grammarAccess.getLowerBoundedScopeAccess().getLessThanSignEqualsSignKeyword_1_0_1()); | ||
11468 | |||
11469 | // InternalSolverLanguageParser.g:4496:5: ( ( ruleQualifiedName ) ) | ||
11470 | // InternalSolverLanguageParser.g:4497:6: ( ruleQualifiedName ) | ||
11471 | { | ||
11472 | // InternalSolverLanguageParser.g:4497:6: ( ruleQualifiedName ) | ||
11473 | // InternalSolverLanguageParser.g:4498:7: ruleQualifiedName | ||
11474 | { | ||
11475 | |||
11476 | if (current==null) { | ||
11477 | current = createModelElement(grammarAccess.getLowerBoundedScopeRule()); | ||
11478 | } | ||
11479 | |||
11480 | |||
11481 | newCompositeNode(grammarAccess.getLowerBoundedScopeAccess().getTypeSymbolCrossReference_1_0_2_0()); | ||
11482 | |||
11483 | pushFollow(FOLLOW_4); | ||
11484 | ruleQualifiedName(); | ||
11485 | |||
11486 | state._fsp--; | ||
11487 | |||
11488 | |||
11489 | afterParserOrEnumRuleCall(); | ||
11490 | |||
11491 | |||
11492 | } | ||
11493 | |||
11494 | |||
11495 | } | ||
11496 | |||
11497 | |||
11498 | } | ||
11499 | |||
11500 | |||
11501 | } | ||
11502 | break; | ||
11503 | case 2 : | ||
11504 | // InternalSolverLanguageParser.g:4514:4: ( ( ( ruleQualifiedName ) ) otherlv_5= GreaterThanSignEqualsSign ( (lv_lowerBound_6_0= RULE_INT ) ) ) | ||
11505 | { | ||
11506 | // InternalSolverLanguageParser.g:4514:4: ( ( ( ruleQualifiedName ) ) otherlv_5= GreaterThanSignEqualsSign ( (lv_lowerBound_6_0= RULE_INT ) ) ) | ||
11507 | // InternalSolverLanguageParser.g:4515:5: ( ( ruleQualifiedName ) ) otherlv_5= GreaterThanSignEqualsSign ( (lv_lowerBound_6_0= RULE_INT ) ) | ||
11508 | { | ||
11509 | // InternalSolverLanguageParser.g:4515:5: ( ( ruleQualifiedName ) ) | ||
11510 | // InternalSolverLanguageParser.g:4516:6: ( ruleQualifiedName ) | ||
11511 | { | ||
11512 | // InternalSolverLanguageParser.g:4516:6: ( ruleQualifiedName ) | ||
11513 | // InternalSolverLanguageParser.g:4517:7: ruleQualifiedName | ||
11514 | { | ||
11515 | |||
11516 | if (current==null) { | ||
11517 | current = createModelElement(grammarAccess.getLowerBoundedScopeRule()); | ||
11518 | } | ||
11519 | |||
11520 | |||
11521 | newCompositeNode(grammarAccess.getLowerBoundedScopeAccess().getTypeSymbolCrossReference_1_1_0_0()); | ||
11522 | |||
11523 | pushFollow(FOLLOW_64); | ||
11524 | ruleQualifiedName(); | ||
11525 | |||
11526 | state._fsp--; | ||
11527 | |||
11528 | |||
11529 | afterParserOrEnumRuleCall(); | ||
11530 | |||
11531 | |||
11532 | } | ||
11533 | |||
11534 | |||
11535 | } | ||
11536 | |||
11537 | otherlv_5=(Token)match(input,GreaterThanSignEqualsSign,FOLLOW_57); | ||
11538 | |||
11539 | newLeafNode(otherlv_5, grammarAccess.getLowerBoundedScopeAccess().getGreaterThanSignEqualsSignKeyword_1_1_1()); | ||
11540 | |||
11541 | // InternalSolverLanguageParser.g:4535:5: ( (lv_lowerBound_6_0= RULE_INT ) ) | ||
11542 | // InternalSolverLanguageParser.g:4536:6: (lv_lowerBound_6_0= RULE_INT ) | ||
11543 | { | ||
11544 | // InternalSolverLanguageParser.g:4536:6: (lv_lowerBound_6_0= RULE_INT ) | ||
11545 | // InternalSolverLanguageParser.g:4537:7: lv_lowerBound_6_0= RULE_INT | ||
11546 | { | ||
11547 | lv_lowerBound_6_0=(Token)match(input,RULE_INT,FOLLOW_4); | ||
11548 | |||
11549 | newLeafNode(lv_lowerBound_6_0, grammarAccess.getLowerBoundedScopeAccess().getLowerBoundINTTerminalRuleCall_1_1_2_0()); | ||
11550 | |||
11551 | |||
11552 | if (current==null) { | ||
11553 | current = createModelElement(grammarAccess.getLowerBoundedScopeRule()); | ||
11554 | } | ||
11555 | setWithLastConsumed( | ||
11556 | current, | ||
11557 | "lowerBound", | ||
11558 | lv_lowerBound_6_0, | ||
11559 | "org.eclipse.xtext.common.Terminals.INT"); | ||
11560 | |||
11561 | |||
11562 | } | ||
11563 | |||
11564 | |||
11565 | } | ||
11566 | |||
11567 | |||
11568 | } | ||
11569 | |||
11570 | |||
11571 | } | ||
11572 | break; | ||
11573 | |||
11574 | } | ||
11575 | |||
11576 | this_FULL_STOP_7=(Token)match(input,RULE_FULL_STOP,FOLLOW_2); | ||
11577 | |||
11578 | newLeafNode(this_FULL_STOP_7, grammarAccess.getLowerBoundedScopeAccess().getFULL_STOPTerminalRuleCall_2()); | ||
11579 | |||
11580 | |||
11581 | } | ||
11582 | |||
11583 | |||
11584 | } | ||
11585 | |||
11586 | |||
11587 | leaveRule(); | ||
11588 | |||
11589 | } | ||
11590 | |||
11591 | catch (RecognitionException re) { | ||
11592 | recover(input,re); | ||
11593 | appendSkippedTokens(); | ||
11594 | } | ||
11595 | finally { | ||
11596 | } | ||
11597 | return current; | ||
11598 | } | ||
11599 | // $ANTLR end "ruleLowerBoundedScope" | ||
11600 | |||
11601 | |||
11602 | // $ANTLR start "entryRuleObjectiveDeclaration" | ||
11603 | // InternalSolverLanguageParser.g:4563:1: entryRuleObjectiveDeclaration returns [EObject current=null] : iv_ruleObjectiveDeclaration= ruleObjectiveDeclaration EOF ; | ||
11604 | public final EObject entryRuleObjectiveDeclaration() throws RecognitionException { | ||
11605 | EObject current = null; | ||
11606 | |||
11607 | EObject iv_ruleObjectiveDeclaration = null; | ||
11608 | |||
11609 | |||
11610 | try { | ||
11611 | // InternalSolverLanguageParser.g:4563:61: (iv_ruleObjectiveDeclaration= ruleObjectiveDeclaration EOF ) | ||
11612 | // InternalSolverLanguageParser.g:4564:2: iv_ruleObjectiveDeclaration= ruleObjectiveDeclaration EOF | ||
11613 | { | ||
11614 | newCompositeNode(grammarAccess.getObjectiveDeclarationRule()); | ||
11615 | pushFollow(FOLLOW_1); | ||
11616 | iv_ruleObjectiveDeclaration=ruleObjectiveDeclaration(); | ||
11617 | |||
11618 | state._fsp--; | ||
11619 | |||
11620 | current =iv_ruleObjectiveDeclaration; | ||
11621 | match(input,EOF,FOLLOW_2); | ||
11622 | |||
11623 | } | ||
11624 | |||
11625 | } | ||
11626 | |||
11627 | catch (RecognitionException re) { | ||
11628 | recover(input,re); | ||
11629 | appendSkippedTokens(); | ||
11630 | } | ||
11631 | finally { | ||
11632 | } | ||
11633 | return current; | ||
11634 | } | ||
11635 | // $ANTLR end "entryRuleObjectiveDeclaration" | ||
11636 | |||
11637 | |||
11638 | // $ANTLR start "ruleObjectiveDeclaration" | ||
11639 | // InternalSolverLanguageParser.g:4570:1: ruleObjectiveDeclaration returns [EObject current=null] : ( ( (lv_kind_0_0= ruleObjectiveKind ) ) ( (lv_objective_1_0= ruleExpression ) ) this_FULL_STOP_2= RULE_FULL_STOP ) ; | ||
11640 | public final EObject ruleObjectiveDeclaration() throws RecognitionException { | ||
11641 | EObject current = null; | ||
11642 | |||
11643 | Token this_FULL_STOP_2=null; | ||
11644 | Enumerator lv_kind_0_0 = null; | ||
11645 | |||
11646 | EObject lv_objective_1_0 = null; | ||
11647 | |||
11648 | |||
11649 | |||
11650 | enterRule(); | ||
11651 | |||
11652 | try { | ||
11653 | // InternalSolverLanguageParser.g:4576:2: ( ( ( (lv_kind_0_0= ruleObjectiveKind ) ) ( (lv_objective_1_0= ruleExpression ) ) this_FULL_STOP_2= RULE_FULL_STOP ) ) | ||
11654 | // InternalSolverLanguageParser.g:4577:2: ( ( (lv_kind_0_0= ruleObjectiveKind ) ) ( (lv_objective_1_0= ruleExpression ) ) this_FULL_STOP_2= RULE_FULL_STOP ) | ||
11655 | { | ||
11656 | // InternalSolverLanguageParser.g:4577:2: ( ( (lv_kind_0_0= ruleObjectiveKind ) ) ( (lv_objective_1_0= ruleExpression ) ) this_FULL_STOP_2= RULE_FULL_STOP ) | ||
11657 | // InternalSolverLanguageParser.g:4578:3: ( (lv_kind_0_0= ruleObjectiveKind ) ) ( (lv_objective_1_0= ruleExpression ) ) this_FULL_STOP_2= RULE_FULL_STOP | ||
11658 | { | ||
11659 | // InternalSolverLanguageParser.g:4578:3: ( (lv_kind_0_0= ruleObjectiveKind ) ) | ||
11660 | // InternalSolverLanguageParser.g:4579:4: (lv_kind_0_0= ruleObjectiveKind ) | ||
11661 | { | ||
11662 | // InternalSolverLanguageParser.g:4579:4: (lv_kind_0_0= ruleObjectiveKind ) | ||
11663 | // InternalSolverLanguageParser.g:4580:5: lv_kind_0_0= ruleObjectiveKind | ||
11664 | { | ||
11665 | |||
11666 | newCompositeNode(grammarAccess.getObjectiveDeclarationAccess().getKindObjectiveKindEnumRuleCall_0_0()); | ||
11667 | |||
11668 | pushFollow(FOLLOW_10); | ||
11669 | lv_kind_0_0=ruleObjectiveKind(); | ||
11670 | |||
11671 | state._fsp--; | ||
11672 | |||
11673 | |||
11674 | if (current==null) { | ||
11675 | current = createModelElementForParent(grammarAccess.getObjectiveDeclarationRule()); | ||
11676 | } | ||
11677 | set( | ||
11678 | current, | ||
11679 | "kind", | ||
11680 | lv_kind_0_0, | ||
11681 | "org.eclipse.viatra.solver.language.SolverLanguage.ObjectiveKind"); | ||
11682 | afterParserOrEnumRuleCall(); | ||
11683 | |||
11684 | |||
11685 | } | ||
11686 | |||
11687 | |||
11688 | } | ||
11689 | |||
11690 | // InternalSolverLanguageParser.g:4597:3: ( (lv_objective_1_0= ruleExpression ) ) | ||
11691 | // InternalSolverLanguageParser.g:4598:4: (lv_objective_1_0= ruleExpression ) | ||
11692 | { | ||
11693 | // InternalSolverLanguageParser.g:4598:4: (lv_objective_1_0= ruleExpression ) | ||
11694 | // InternalSolverLanguageParser.g:4599:5: lv_objective_1_0= ruleExpression | ||
11695 | { | ||
11696 | |||
11697 | newCompositeNode(grammarAccess.getObjectiveDeclarationAccess().getObjectiveExpressionParserRuleCall_1_0()); | ||
11698 | |||
11699 | pushFollow(FOLLOW_4); | ||
11700 | lv_objective_1_0=ruleExpression(); | ||
11701 | |||
11702 | state._fsp--; | ||
11703 | |||
11704 | |||
11705 | if (current==null) { | ||
11706 | current = createModelElementForParent(grammarAccess.getObjectiveDeclarationRule()); | ||
11707 | } | ||
11708 | set( | ||
11709 | current, | ||
11710 | "objective", | ||
11711 | lv_objective_1_0, | ||
11712 | "org.eclipse.viatra.solver.language.SolverLanguage.Expression"); | ||
11713 | afterParserOrEnumRuleCall(); | ||
11714 | |||
11715 | |||
11716 | } | ||
11717 | |||
11718 | |||
11719 | } | ||
11720 | |||
11721 | this_FULL_STOP_2=(Token)match(input,RULE_FULL_STOP,FOLLOW_2); | ||
11722 | |||
11723 | newLeafNode(this_FULL_STOP_2, grammarAccess.getObjectiveDeclarationAccess().getFULL_STOPTerminalRuleCall_2()); | ||
11724 | |||
11725 | |||
11726 | } | ||
11727 | |||
11728 | |||
11729 | } | ||
11730 | |||
11731 | |||
11732 | leaveRule(); | ||
11733 | |||
11734 | } | ||
11735 | |||
11736 | catch (RecognitionException re) { | ||
11737 | recover(input,re); | ||
11738 | appendSkippedTokens(); | ||
11739 | } | ||
11740 | finally { | ||
11741 | } | ||
11742 | return current; | ||
11743 | } | ||
11744 | // $ANTLR end "ruleObjectiveDeclaration" | ||
11745 | |||
11746 | |||
11747 | // $ANTLR start "entryRuleUpperMultiplicty" | ||
11748 | // InternalSolverLanguageParser.g:4624:1: entryRuleUpperMultiplicty returns [String current=null] : iv_ruleUpperMultiplicty= ruleUpperMultiplicty EOF ; | ||
11749 | public final String entryRuleUpperMultiplicty() throws RecognitionException { | ||
11750 | String current = null; | ||
11751 | |||
11752 | AntlrDatatypeRuleToken iv_ruleUpperMultiplicty = null; | ||
11753 | |||
11754 | |||
11755 | try { | ||
11756 | // InternalSolverLanguageParser.g:4624:56: (iv_ruleUpperMultiplicty= ruleUpperMultiplicty EOF ) | ||
11757 | // InternalSolverLanguageParser.g:4625:2: iv_ruleUpperMultiplicty= ruleUpperMultiplicty EOF | ||
11758 | { | ||
11759 | newCompositeNode(grammarAccess.getUpperMultiplictyRule()); | ||
11760 | pushFollow(FOLLOW_1); | ||
11761 | iv_ruleUpperMultiplicty=ruleUpperMultiplicty(); | ||
11762 | |||
11763 | state._fsp--; | ||
11764 | |||
11765 | current =iv_ruleUpperMultiplicty.getText(); | ||
11766 | match(input,EOF,FOLLOW_2); | ||
11767 | |||
11768 | } | ||
11769 | |||
11770 | } | ||
11771 | |||
11772 | catch (RecognitionException re) { | ||
11773 | recover(input,re); | ||
11774 | appendSkippedTokens(); | ||
11775 | } | ||
11776 | finally { | ||
11777 | } | ||
11778 | return current; | ||
11779 | } | ||
11780 | // $ANTLR end "entryRuleUpperMultiplicty" | ||
11781 | |||
11782 | |||
11783 | // $ANTLR start "ruleUpperMultiplicty" | ||
11784 | // InternalSolverLanguageParser.g:4631:1: ruleUpperMultiplicty returns [AntlrDatatypeRuleToken current=new AntlrDatatypeRuleToken()] : (this_INT_0= RULE_INT | kw= Asterisk ) ; | ||
11785 | public final AntlrDatatypeRuleToken ruleUpperMultiplicty() throws RecognitionException { | ||
11786 | AntlrDatatypeRuleToken current = new AntlrDatatypeRuleToken(); | ||
11787 | |||
11788 | Token this_INT_0=null; | ||
11789 | Token kw=null; | ||
11790 | |||
11791 | |||
11792 | enterRule(); | ||
11793 | |||
11794 | try { | ||
11795 | // InternalSolverLanguageParser.g:4637:2: ( (this_INT_0= RULE_INT | kw= Asterisk ) ) | ||
11796 | // InternalSolverLanguageParser.g:4638:2: (this_INT_0= RULE_INT | kw= Asterisk ) | ||
11797 | { | ||
11798 | // InternalSolverLanguageParser.g:4638:2: (this_INT_0= RULE_INT | kw= Asterisk ) | ||
11799 | int alt58=2; | ||
11800 | int LA58_0 = input.LA(1); | ||
11801 | |||
11802 | if ( (LA58_0==RULE_INT) ) { | ||
11803 | alt58=1; | ||
11804 | } | ||
11805 | else if ( (LA58_0==Asterisk) ) { | ||
11806 | alt58=2; | ||
11807 | } | ||
11808 | else { | ||
11809 | NoViableAltException nvae = | ||
11810 | new NoViableAltException("", 58, 0, input); | ||
11811 | |||
11812 | throw nvae; | ||
11813 | } | ||
11814 | switch (alt58) { | ||
11815 | case 1 : | ||
11816 | // InternalSolverLanguageParser.g:4639:3: this_INT_0= RULE_INT | ||
11817 | { | ||
11818 | this_INT_0=(Token)match(input,RULE_INT,FOLLOW_2); | ||
11819 | |||
11820 | current.merge(this_INT_0); | ||
11821 | |||
11822 | |||
11823 | newLeafNode(this_INT_0, grammarAccess.getUpperMultiplictyAccess().getINTTerminalRuleCall_0()); | ||
11824 | |||
11825 | |||
11826 | } | ||
11827 | break; | ||
11828 | case 2 : | ||
11829 | // InternalSolverLanguageParser.g:4647:3: kw= Asterisk | ||
11830 | { | ||
11831 | kw=(Token)match(input,Asterisk,FOLLOW_2); | ||
11832 | |||
11833 | current.merge(kw); | ||
11834 | newLeafNode(kw, grammarAccess.getUpperMultiplictyAccess().getAsteriskKeyword_1()); | ||
11835 | |||
11836 | |||
11837 | } | ||
11838 | break; | ||
11839 | |||
11840 | } | ||
11841 | |||
11842 | |||
11843 | } | ||
11844 | |||
11845 | |||
11846 | leaveRule(); | ||
11847 | |||
11848 | } | ||
11849 | |||
11850 | catch (RecognitionException re) { | ||
11851 | recover(input,re); | ||
11852 | appendSkippedTokens(); | ||
11853 | } | ||
11854 | finally { | ||
11855 | } | ||
11856 | return current; | ||
11857 | } | ||
11858 | // $ANTLR end "ruleUpperMultiplicty" | ||
11859 | |||
11860 | |||
11861 | // $ANTLR start "entryRuleReal" | ||
11862 | // InternalSolverLanguageParser.g:4656:1: entryRuleReal returns [String current=null] : iv_ruleReal= ruleReal EOF ; | ||
11863 | public final String entryRuleReal() throws RecognitionException { | ||
11864 | String current = null; | ||
11865 | |||
11866 | AntlrDatatypeRuleToken iv_ruleReal = null; | ||
11867 | |||
11868 | |||
11869 | |||
11870 | HiddenTokens myHiddenTokenState = ((XtextTokenStream)input).setHiddenTokens(); | ||
11871 | |||
11872 | try { | ||
11873 | // InternalSolverLanguageParser.g:4658:2: (iv_ruleReal= ruleReal EOF ) | ||
11874 | // InternalSolverLanguageParser.g:4659:2: iv_ruleReal= ruleReal EOF | ||
11875 | { | ||
11876 | newCompositeNode(grammarAccess.getRealRule()); | ||
11877 | pushFollow(FOLLOW_1); | ||
11878 | iv_ruleReal=ruleReal(); | ||
11879 | |||
11880 | state._fsp--; | ||
11881 | |||
11882 | current =iv_ruleReal.getText(); | ||
11883 | match(input,EOF,FOLLOW_2); | ||
11884 | |||
11885 | } | ||
11886 | |||
11887 | } | ||
11888 | |||
11889 | catch (RecognitionException re) { | ||
11890 | recover(input,re); | ||
11891 | appendSkippedTokens(); | ||
11892 | } | ||
11893 | finally { | ||
11894 | |||
11895 | myHiddenTokenState.restore(); | ||
11896 | |||
11897 | } | ||
11898 | return current; | ||
11899 | } | ||
11900 | // $ANTLR end "entryRuleReal" | ||
11901 | |||
11902 | |||
11903 | // $ANTLR start "ruleReal" | ||
11904 | // InternalSolverLanguageParser.g:4668:1: ruleReal returns [AntlrDatatypeRuleToken current=new AntlrDatatypeRuleToken()] : (this_INT_0= RULE_INT kw= FullStop this_INT_2= RULE_INT ) ; | ||
11905 | public final AntlrDatatypeRuleToken ruleReal() throws RecognitionException { | ||
11906 | AntlrDatatypeRuleToken current = new AntlrDatatypeRuleToken(); | ||
11907 | |||
11908 | Token this_INT_0=null; | ||
11909 | Token kw=null; | ||
11910 | Token this_INT_2=null; | ||
11911 | |||
11912 | |||
11913 | enterRule(); | ||
11914 | HiddenTokens myHiddenTokenState = ((XtextTokenStream)input).setHiddenTokens(); | ||
11915 | |||
11916 | try { | ||
11917 | // InternalSolverLanguageParser.g:4675:2: ( (this_INT_0= RULE_INT kw= FullStop this_INT_2= RULE_INT ) ) | ||
11918 | // InternalSolverLanguageParser.g:4676:2: (this_INT_0= RULE_INT kw= FullStop this_INT_2= RULE_INT ) | ||
11919 | { | ||
11920 | // InternalSolverLanguageParser.g:4676:2: (this_INT_0= RULE_INT kw= FullStop this_INT_2= RULE_INT ) | ||
11921 | // InternalSolverLanguageParser.g:4677:3: this_INT_0= RULE_INT kw= FullStop this_INT_2= RULE_INT | ||
11922 | { | ||
11923 | this_INT_0=(Token)match(input,RULE_INT,FOLLOW_66); | ||
11924 | |||
11925 | current.merge(this_INT_0); | ||
11926 | |||
11927 | |||
11928 | newLeafNode(this_INT_0, grammarAccess.getRealAccess().getINTTerminalRuleCall_0()); | ||
11929 | |||
11930 | kw=(Token)match(input,FullStop,FOLLOW_57); | ||
11931 | |||
11932 | current.merge(kw); | ||
11933 | newLeafNode(kw, grammarAccess.getRealAccess().getFullStopKeyword_1()); | ||
11934 | |||
11935 | this_INT_2=(Token)match(input,RULE_INT,FOLLOW_2); | ||
11936 | |||
11937 | current.merge(this_INT_2); | ||
11938 | |||
11939 | |||
11940 | newLeafNode(this_INT_2, grammarAccess.getRealAccess().getINTTerminalRuleCall_2()); | ||
11941 | |||
11942 | |||
11943 | } | ||
11944 | |||
11945 | |||
11946 | } | ||
11947 | |||
11948 | |||
11949 | leaveRule(); | ||
11950 | |||
11951 | } | ||
11952 | |||
11953 | catch (RecognitionException re) { | ||
11954 | recover(input,re); | ||
11955 | appendSkippedTokens(); | ||
11956 | } | ||
11957 | finally { | ||
11958 | |||
11959 | myHiddenTokenState.restore(); | ||
11960 | |||
11961 | } | ||
11962 | return current; | ||
11963 | } | ||
11964 | // $ANTLR end "ruleReal" | ||
11965 | |||
11966 | |||
11967 | // $ANTLR start "entryRuleQualifiedNameSegment" | ||
11968 | // InternalSolverLanguageParser.g:4703:1: entryRuleQualifiedNameSegment returns [String current=null] : iv_ruleQualifiedNameSegment= ruleQualifiedNameSegment EOF ; | ||
11969 | public final String entryRuleQualifiedNameSegment() throws RecognitionException { | ||
11970 | String current = null; | ||
11971 | |||
11972 | AntlrDatatypeRuleToken iv_ruleQualifiedNameSegment = null; | ||
11973 | |||
11974 | |||
11975 | try { | ||
11976 | // InternalSolverLanguageParser.g:4703:60: (iv_ruleQualifiedNameSegment= ruleQualifiedNameSegment EOF ) | ||
11977 | // InternalSolverLanguageParser.g:4704:2: iv_ruleQualifiedNameSegment= ruleQualifiedNameSegment EOF | ||
11978 | { | ||
11979 | newCompositeNode(grammarAccess.getQualifiedNameSegmentRule()); | ||
11980 | pushFollow(FOLLOW_1); | ||
11981 | iv_ruleQualifiedNameSegment=ruleQualifiedNameSegment(); | ||
11982 | |||
11983 | state._fsp--; | ||
11984 | |||
11985 | current =iv_ruleQualifiedNameSegment.getText(); | ||
11986 | match(input,EOF,FOLLOW_2); | ||
11987 | |||
11988 | } | ||
11989 | |||
11990 | } | ||
11991 | |||
11992 | catch (RecognitionException re) { | ||
11993 | recover(input,re); | ||
11994 | appendSkippedTokens(); | ||
11995 | } | ||
11996 | finally { | ||
11997 | } | ||
11998 | return current; | ||
11999 | } | ||
12000 | // $ANTLR end "entryRuleQualifiedNameSegment" | ||
12001 | |||
12002 | |||
12003 | // $ANTLR start "ruleQualifiedNameSegment" | ||
12004 | // InternalSolverLanguageParser.g:4710:1: ruleQualifiedNameSegment returns [AntlrDatatypeRuleToken current=new AntlrDatatypeRuleToken()] : (this_ID_0= RULE_ID | this_QUOTED_ID_1= RULE_QUOTED_ID | kw= Object ) ; | ||
12005 | public final AntlrDatatypeRuleToken ruleQualifiedNameSegment() throws RecognitionException { | ||
12006 | AntlrDatatypeRuleToken current = new AntlrDatatypeRuleToken(); | ||
12007 | |||
12008 | Token this_ID_0=null; | ||
12009 | Token this_QUOTED_ID_1=null; | ||
12010 | Token kw=null; | ||
12011 | |||
12012 | |||
12013 | enterRule(); | ||
12014 | |||
12015 | try { | ||
12016 | // InternalSolverLanguageParser.g:4716:2: ( (this_ID_0= RULE_ID | this_QUOTED_ID_1= RULE_QUOTED_ID | kw= Object ) ) | ||
12017 | // InternalSolverLanguageParser.g:4717:2: (this_ID_0= RULE_ID | this_QUOTED_ID_1= RULE_QUOTED_ID | kw= Object ) | ||
12018 | { | ||
12019 | // InternalSolverLanguageParser.g:4717:2: (this_ID_0= RULE_ID | this_QUOTED_ID_1= RULE_QUOTED_ID | kw= Object ) | ||
12020 | int alt59=3; | ||
12021 | switch ( input.LA(1) ) { | ||
12022 | case RULE_ID: | ||
12023 | { | ||
12024 | alt59=1; | ||
12025 | } | ||
12026 | break; | ||
12027 | case RULE_QUOTED_ID: | ||
12028 | { | ||
12029 | alt59=2; | ||
12030 | } | ||
12031 | break; | ||
12032 | case Object: | ||
12033 | { | ||
12034 | alt59=3; | ||
12035 | } | ||
12036 | break; | ||
12037 | default: | ||
12038 | NoViableAltException nvae = | ||
12039 | new NoViableAltException("", 59, 0, input); | ||
12040 | |||
12041 | throw nvae; | ||
12042 | } | ||
12043 | |||
12044 | switch (alt59) { | ||
12045 | case 1 : | ||
12046 | // InternalSolverLanguageParser.g:4718:3: this_ID_0= RULE_ID | ||
12047 | { | ||
12048 | this_ID_0=(Token)match(input,RULE_ID,FOLLOW_2); | ||
12049 | |||
12050 | current.merge(this_ID_0); | ||
12051 | |||
12052 | |||
12053 | newLeafNode(this_ID_0, grammarAccess.getQualifiedNameSegmentAccess().getIDTerminalRuleCall_0()); | ||
12054 | |||
12055 | |||
12056 | } | ||
12057 | break; | ||
12058 | case 2 : | ||
12059 | // InternalSolverLanguageParser.g:4726:3: this_QUOTED_ID_1= RULE_QUOTED_ID | ||
12060 | { | ||
12061 | this_QUOTED_ID_1=(Token)match(input,RULE_QUOTED_ID,FOLLOW_2); | ||
12062 | |||
12063 | current.merge(this_QUOTED_ID_1); | ||
12064 | |||
12065 | |||
12066 | newLeafNode(this_QUOTED_ID_1, grammarAccess.getQualifiedNameSegmentAccess().getQUOTED_IDTerminalRuleCall_1()); | ||
12067 | |||
12068 | |||
12069 | } | ||
12070 | break; | ||
12071 | case 3 : | ||
12072 | // InternalSolverLanguageParser.g:4734:3: kw= Object | ||
12073 | { | ||
12074 | kw=(Token)match(input,Object,FOLLOW_2); | ||
12075 | |||
12076 | current.merge(kw); | ||
12077 | newLeafNode(kw, grammarAccess.getQualifiedNameSegmentAccess().getObjectKeyword_2()); | ||
12078 | |||
12079 | |||
12080 | } | ||
12081 | break; | ||
12082 | |||
12083 | } | ||
12084 | |||
12085 | |||
12086 | } | ||
12087 | |||
12088 | |||
12089 | leaveRule(); | ||
12090 | |||
12091 | } | ||
12092 | |||
12093 | catch (RecognitionException re) { | ||
12094 | recover(input,re); | ||
12095 | appendSkippedTokens(); | ||
12096 | } | ||
12097 | finally { | ||
12098 | } | ||
12099 | return current; | ||
12100 | } | ||
12101 | // $ANTLR end "ruleQualifiedNameSegment" | ||
12102 | |||
12103 | |||
12104 | // $ANTLR start "entryRuleQualifiedName" | ||
12105 | // InternalSolverLanguageParser.g:4743:1: entryRuleQualifiedName returns [String current=null] : iv_ruleQualifiedName= ruleQualifiedName EOF ; | ||
12106 | public final String entryRuleQualifiedName() throws RecognitionException { | ||
12107 | String current = null; | ||
12108 | |||
12109 | AntlrDatatypeRuleToken iv_ruleQualifiedName = null; | ||
12110 | |||
12111 | |||
12112 | |||
12113 | HiddenTokens myHiddenTokenState = ((XtextTokenStream)input).setHiddenTokens(); | ||
12114 | |||
12115 | try { | ||
12116 | // InternalSolverLanguageParser.g:4745:2: (iv_ruleQualifiedName= ruleQualifiedName EOF ) | ||
12117 | // InternalSolverLanguageParser.g:4746:2: iv_ruleQualifiedName= ruleQualifiedName EOF | ||
12118 | { | ||
12119 | newCompositeNode(grammarAccess.getQualifiedNameRule()); | ||
12120 | pushFollow(FOLLOW_1); | ||
12121 | iv_ruleQualifiedName=ruleQualifiedName(); | ||
12122 | |||
12123 | state._fsp--; | ||
12124 | |||
12125 | current =iv_ruleQualifiedName.getText(); | ||
12126 | match(input,EOF,FOLLOW_2); | ||
12127 | |||
12128 | } | ||
12129 | |||
12130 | } | ||
12131 | |||
12132 | catch (RecognitionException re) { | ||
12133 | recover(input,re); | ||
12134 | appendSkippedTokens(); | ||
12135 | } | ||
12136 | finally { | ||
12137 | |||
12138 | myHiddenTokenState.restore(); | ||
12139 | |||
12140 | } | ||
12141 | return current; | ||
12142 | } | ||
12143 | // $ANTLR end "entryRuleQualifiedName" | ||
12144 | |||
12145 | |||
12146 | // $ANTLR start "ruleQualifiedName" | ||
12147 | // InternalSolverLanguageParser.g:4755:1: ruleQualifiedName returns [AntlrDatatypeRuleToken current=new AntlrDatatypeRuleToken()] : (this_QualifiedNameSegment_0= ruleQualifiedNameSegment (kw= ColonColon this_QualifiedNameSegment_2= ruleQualifiedNameSegment )* ) ; | ||
12148 | public final AntlrDatatypeRuleToken ruleQualifiedName() throws RecognitionException { | ||
12149 | AntlrDatatypeRuleToken current = new AntlrDatatypeRuleToken(); | ||
12150 | |||
12151 | Token kw=null; | ||
12152 | AntlrDatatypeRuleToken this_QualifiedNameSegment_0 = null; | ||
12153 | |||
12154 | AntlrDatatypeRuleToken this_QualifiedNameSegment_2 = null; | ||
12155 | |||
12156 | |||
12157 | |||
12158 | enterRule(); | ||
12159 | HiddenTokens myHiddenTokenState = ((XtextTokenStream)input).setHiddenTokens(); | ||
12160 | |||
12161 | try { | ||
12162 | // InternalSolverLanguageParser.g:4762:2: ( (this_QualifiedNameSegment_0= ruleQualifiedNameSegment (kw= ColonColon this_QualifiedNameSegment_2= ruleQualifiedNameSegment )* ) ) | ||
12163 | // InternalSolverLanguageParser.g:4763:2: (this_QualifiedNameSegment_0= ruleQualifiedNameSegment (kw= ColonColon this_QualifiedNameSegment_2= ruleQualifiedNameSegment )* ) | ||
12164 | { | ||
12165 | // InternalSolverLanguageParser.g:4763:2: (this_QualifiedNameSegment_0= ruleQualifiedNameSegment (kw= ColonColon this_QualifiedNameSegment_2= ruleQualifiedNameSegment )* ) | ||
12166 | // InternalSolverLanguageParser.g:4764:3: this_QualifiedNameSegment_0= ruleQualifiedNameSegment (kw= ColonColon this_QualifiedNameSegment_2= ruleQualifiedNameSegment )* | ||
12167 | { | ||
12168 | |||
12169 | newCompositeNode(grammarAccess.getQualifiedNameAccess().getQualifiedNameSegmentParserRuleCall_0()); | ||
12170 | |||
12171 | pushFollow(FOLLOW_67); | ||
12172 | this_QualifiedNameSegment_0=ruleQualifiedNameSegment(); | ||
12173 | |||
12174 | state._fsp--; | ||
12175 | |||
12176 | |||
12177 | current.merge(this_QualifiedNameSegment_0); | ||
12178 | |||
12179 | |||
12180 | afterParserOrEnumRuleCall(); | ||
12181 | |||
12182 | // InternalSolverLanguageParser.g:4774:3: (kw= ColonColon this_QualifiedNameSegment_2= ruleQualifiedNameSegment )* | ||
12183 | loop60: | ||
12184 | do { | ||
12185 | int alt60=2; | ||
12186 | int LA60_0 = input.LA(1); | ||
12187 | |||
12188 | if ( (LA60_0==ColonColon) ) { | ||
12189 | alt60=1; | ||
12190 | } | ||
12191 | |||
12192 | |||
12193 | switch (alt60) { | ||
12194 | case 1 : | ||
12195 | // InternalSolverLanguageParser.g:4775:4: kw= ColonColon this_QualifiedNameSegment_2= ruleQualifiedNameSegment | ||
12196 | { | ||
12197 | kw=(Token)match(input,ColonColon,FOLLOW_3); | ||
12198 | |||
12199 | current.merge(kw); | ||
12200 | newLeafNode(kw, grammarAccess.getQualifiedNameAccess().getColonColonKeyword_1_0()); | ||
12201 | |||
12202 | |||
12203 | newCompositeNode(grammarAccess.getQualifiedNameAccess().getQualifiedNameSegmentParserRuleCall_1_1()); | ||
12204 | |||
12205 | pushFollow(FOLLOW_67); | ||
12206 | this_QualifiedNameSegment_2=ruleQualifiedNameSegment(); | ||
12207 | |||
12208 | state._fsp--; | ||
12209 | |||
12210 | |||
12211 | current.merge(this_QualifiedNameSegment_2); | ||
12212 | |||
12213 | |||
12214 | afterParserOrEnumRuleCall(); | ||
12215 | |||
12216 | |||
12217 | } | ||
12218 | break; | ||
12219 | |||
12220 | default : | ||
12221 | break loop60; | ||
12222 | } | ||
12223 | } while (true); | ||
12224 | |||
12225 | |||
12226 | } | ||
12227 | |||
12228 | |||
12229 | } | ||
12230 | |||
12231 | |||
12232 | leaveRule(); | ||
12233 | |||
12234 | } | ||
12235 | |||
12236 | catch (RecognitionException re) { | ||
12237 | recover(input,re); | ||
12238 | appendSkippedTokens(); | ||
12239 | } | ||
12240 | finally { | ||
12241 | |||
12242 | myHiddenTokenState.restore(); | ||
12243 | |||
12244 | } | ||
12245 | return current; | ||
12246 | } | ||
12247 | // $ANTLR end "ruleQualifiedName" | ||
12248 | |||
12249 | |||
12250 | // $ANTLR start "ruleAttributeKind" | ||
12251 | // InternalSolverLanguageParser.g:4798:1: ruleAttributeKind returns [Enumerator current=null] : ( (enumLiteral_0= Functional ) | (enumLiteral_1= Error ) | (enumLiteral_2= Root ) | (enumLiteral_3= Containment ) ) ; | ||
12252 | public final Enumerator ruleAttributeKind() throws RecognitionException { | ||
12253 | Enumerator current = null; | ||
12254 | |||
12255 | Token enumLiteral_0=null; | ||
12256 | Token enumLiteral_1=null; | ||
12257 | Token enumLiteral_2=null; | ||
12258 | Token enumLiteral_3=null; | ||
12259 | |||
12260 | |||
12261 | enterRule(); | ||
12262 | |||
12263 | try { | ||
12264 | // InternalSolverLanguageParser.g:4804:2: ( ( (enumLiteral_0= Functional ) | (enumLiteral_1= Error ) | (enumLiteral_2= Root ) | (enumLiteral_3= Containment ) ) ) | ||
12265 | // InternalSolverLanguageParser.g:4805:2: ( (enumLiteral_0= Functional ) | (enumLiteral_1= Error ) | (enumLiteral_2= Root ) | (enumLiteral_3= Containment ) ) | ||
12266 | { | ||
12267 | // InternalSolverLanguageParser.g:4805:2: ( (enumLiteral_0= Functional ) | (enumLiteral_1= Error ) | (enumLiteral_2= Root ) | (enumLiteral_3= Containment ) ) | ||
12268 | int alt61=4; | ||
12269 | switch ( input.LA(1) ) { | ||
12270 | case Functional: | ||
12271 | { | ||
12272 | alt61=1; | ||
12273 | } | ||
12274 | break; | ||
12275 | case Error: | ||
12276 | { | ||
12277 | alt61=2; | ||
12278 | } | ||
12279 | break; | ||
12280 | case Root: | ||
12281 | { | ||
12282 | alt61=3; | ||
12283 | } | ||
12284 | break; | ||
12285 | case Containment: | ||
12286 | { | ||
12287 | alt61=4; | ||
12288 | } | ||
12289 | break; | ||
12290 | default: | ||
12291 | NoViableAltException nvae = | ||
12292 | new NoViableAltException("", 61, 0, input); | ||
12293 | |||
12294 | throw nvae; | ||
12295 | } | ||
12296 | |||
12297 | switch (alt61) { | ||
12298 | case 1 : | ||
12299 | // InternalSolverLanguageParser.g:4806:3: (enumLiteral_0= Functional ) | ||
12300 | { | ||
12301 | // InternalSolverLanguageParser.g:4806:3: (enumLiteral_0= Functional ) | ||
12302 | // InternalSolverLanguageParser.g:4807:4: enumLiteral_0= Functional | ||
12303 | { | ||
12304 | enumLiteral_0=(Token)match(input,Functional,FOLLOW_2); | ||
12305 | |||
12306 | current = grammarAccess.getAttributeKindAccess().getFUNCTIONALEnumLiteralDeclaration_0().getEnumLiteral().getInstance(); | ||
12307 | newLeafNode(enumLiteral_0, grammarAccess.getAttributeKindAccess().getFUNCTIONALEnumLiteralDeclaration_0()); | ||
12308 | |||
12309 | |||
12310 | } | ||
12311 | |||
12312 | |||
12313 | } | ||
12314 | break; | ||
12315 | case 2 : | ||
12316 | // InternalSolverLanguageParser.g:4814:3: (enumLiteral_1= Error ) | ||
12317 | { | ||
12318 | // InternalSolverLanguageParser.g:4814:3: (enumLiteral_1= Error ) | ||
12319 | // InternalSolverLanguageParser.g:4815:4: enumLiteral_1= Error | ||
12320 | { | ||
12321 | enumLiteral_1=(Token)match(input,Error,FOLLOW_2); | ||
12322 | |||
12323 | current = grammarAccess.getAttributeKindAccess().getERROREnumLiteralDeclaration_1().getEnumLiteral().getInstance(); | ||
12324 | newLeafNode(enumLiteral_1, grammarAccess.getAttributeKindAccess().getERROREnumLiteralDeclaration_1()); | ||
12325 | |||
12326 | |||
12327 | } | ||
12328 | |||
12329 | |||
12330 | } | ||
12331 | break; | ||
12332 | case 3 : | ||
12333 | // InternalSolverLanguageParser.g:4822:3: (enumLiteral_2= Root ) | ||
12334 | { | ||
12335 | // InternalSolverLanguageParser.g:4822:3: (enumLiteral_2= Root ) | ||
12336 | // InternalSolverLanguageParser.g:4823:4: enumLiteral_2= Root | ||
12337 | { | ||
12338 | enumLiteral_2=(Token)match(input,Root,FOLLOW_2); | ||
12339 | |||
12340 | current = grammarAccess.getAttributeKindAccess().getROOTEnumLiteralDeclaration_2().getEnumLiteral().getInstance(); | ||
12341 | newLeafNode(enumLiteral_2, grammarAccess.getAttributeKindAccess().getROOTEnumLiteralDeclaration_2()); | ||
12342 | |||
12343 | |||
12344 | } | ||
12345 | |||
12346 | |||
12347 | } | ||
12348 | break; | ||
12349 | case 4 : | ||
12350 | // InternalSolverLanguageParser.g:4830:3: (enumLiteral_3= Containment ) | ||
12351 | { | ||
12352 | // InternalSolverLanguageParser.g:4830:3: (enumLiteral_3= Containment ) | ||
12353 | // InternalSolverLanguageParser.g:4831:4: enumLiteral_3= Containment | ||
12354 | { | ||
12355 | enumLiteral_3=(Token)match(input,Containment,FOLLOW_2); | ||
12356 | |||
12357 | current = grammarAccess.getAttributeKindAccess().getCONTAINMENTEnumLiteralDeclaration_3().getEnumLiteral().getInstance(); | ||
12358 | newLeafNode(enumLiteral_3, grammarAccess.getAttributeKindAccess().getCONTAINMENTEnumLiteralDeclaration_3()); | ||
12359 | |||
12360 | |||
12361 | } | ||
12362 | |||
12363 | |||
12364 | } | ||
12365 | break; | ||
12366 | |||
12367 | } | ||
12368 | |||
12369 | |||
12370 | } | ||
12371 | |||
12372 | |||
12373 | leaveRule(); | ||
12374 | |||
12375 | } | ||
12376 | |||
12377 | catch (RecognitionException re) { | ||
12378 | recover(input,re); | ||
12379 | appendSkippedTokens(); | ||
12380 | } | ||
12381 | finally { | ||
12382 | } | ||
12383 | return current; | ||
12384 | } | ||
12385 | // $ANTLR end "ruleAttributeKind" | ||
12386 | |||
12387 | |||
12388 | // $ANTLR start "ruleComparisonOperator" | ||
12389 | // InternalSolverLanguageParser.g:4841:1: ruleComparisonOperator returns [Enumerator current=null] : ( (enumLiteral_0= EqualsSignEqualsSign ) | (enumLiteral_1= ExclamationMarkEqualsSign ) | (enumLiteral_2= LessThanSign ) | (enumLiteral_3= LessThanSignEqualsSign ) | (enumLiteral_4= GreaterThanSign ) | (enumLiteral_5= GreaterThanSignEqualsSign ) | (enumLiteral_6= In ) ) ; | ||
12390 | public final Enumerator ruleComparisonOperator() throws RecognitionException { | ||
12391 | Enumerator current = null; | ||
12392 | |||
12393 | Token enumLiteral_0=null; | ||
12394 | Token enumLiteral_1=null; | ||
12395 | Token enumLiteral_2=null; | ||
12396 | Token enumLiteral_3=null; | ||
12397 | Token enumLiteral_4=null; | ||
12398 | Token enumLiteral_5=null; | ||
12399 | Token enumLiteral_6=null; | ||
12400 | |||
12401 | |||
12402 | enterRule(); | ||
12403 | |||
12404 | try { | ||
12405 | // InternalSolverLanguageParser.g:4847:2: ( ( (enumLiteral_0= EqualsSignEqualsSign ) | (enumLiteral_1= ExclamationMarkEqualsSign ) | (enumLiteral_2= LessThanSign ) | (enumLiteral_3= LessThanSignEqualsSign ) | (enumLiteral_4= GreaterThanSign ) | (enumLiteral_5= GreaterThanSignEqualsSign ) | (enumLiteral_6= In ) ) ) | ||
12406 | // InternalSolverLanguageParser.g:4848:2: ( (enumLiteral_0= EqualsSignEqualsSign ) | (enumLiteral_1= ExclamationMarkEqualsSign ) | (enumLiteral_2= LessThanSign ) | (enumLiteral_3= LessThanSignEqualsSign ) | (enumLiteral_4= GreaterThanSign ) | (enumLiteral_5= GreaterThanSignEqualsSign ) | (enumLiteral_6= In ) ) | ||
12407 | { | ||
12408 | // InternalSolverLanguageParser.g:4848:2: ( (enumLiteral_0= EqualsSignEqualsSign ) | (enumLiteral_1= ExclamationMarkEqualsSign ) | (enumLiteral_2= LessThanSign ) | (enumLiteral_3= LessThanSignEqualsSign ) | (enumLiteral_4= GreaterThanSign ) | (enumLiteral_5= GreaterThanSignEqualsSign ) | (enumLiteral_6= In ) ) | ||
12409 | int alt62=7; | ||
12410 | switch ( input.LA(1) ) { | ||
12411 | case EqualsSignEqualsSign: | ||
12412 | { | ||
12413 | alt62=1; | ||
12414 | } | ||
12415 | break; | ||
12416 | case ExclamationMarkEqualsSign: | ||
12417 | { | ||
12418 | alt62=2; | ||
12419 | } | ||
12420 | break; | ||
12421 | case LessThanSign: | ||
12422 | { | ||
12423 | alt62=3; | ||
12424 | } | ||
12425 | break; | ||
12426 | case LessThanSignEqualsSign: | ||
12427 | { | ||
12428 | alt62=4; | ||
12429 | } | ||
12430 | break; | ||
12431 | case GreaterThanSign: | ||
12432 | { | ||
12433 | alt62=5; | ||
12434 | } | ||
12435 | break; | ||
12436 | case GreaterThanSignEqualsSign: | ||
12437 | { | ||
12438 | alt62=6; | ||
12439 | } | ||
12440 | break; | ||
12441 | case In: | ||
12442 | { | ||
12443 | alt62=7; | ||
12444 | } | ||
12445 | break; | ||
12446 | default: | ||
12447 | NoViableAltException nvae = | ||
12448 | new NoViableAltException("", 62, 0, input); | ||
12449 | |||
12450 | throw nvae; | ||
12451 | } | ||
12452 | |||
12453 | switch (alt62) { | ||
12454 | case 1 : | ||
12455 | // InternalSolverLanguageParser.g:4849:3: (enumLiteral_0= EqualsSignEqualsSign ) | ||
12456 | { | ||
12457 | // InternalSolverLanguageParser.g:4849:3: (enumLiteral_0= EqualsSignEqualsSign ) | ||
12458 | // InternalSolverLanguageParser.g:4850:4: enumLiteral_0= EqualsSignEqualsSign | ||
12459 | { | ||
12460 | enumLiteral_0=(Token)match(input,EqualsSignEqualsSign,FOLLOW_2); | ||
12461 | |||
12462 | current = grammarAccess.getComparisonOperatorAccess().getEQUALSEnumLiteralDeclaration_0().getEnumLiteral().getInstance(); | ||
12463 | newLeafNode(enumLiteral_0, grammarAccess.getComparisonOperatorAccess().getEQUALSEnumLiteralDeclaration_0()); | ||
12464 | |||
12465 | |||
12466 | } | ||
12467 | |||
12468 | |||
12469 | } | ||
12470 | break; | ||
12471 | case 2 : | ||
12472 | // InternalSolverLanguageParser.g:4857:3: (enumLiteral_1= ExclamationMarkEqualsSign ) | ||
12473 | { | ||
12474 | // InternalSolverLanguageParser.g:4857:3: (enumLiteral_1= ExclamationMarkEqualsSign ) | ||
12475 | // InternalSolverLanguageParser.g:4858:4: enumLiteral_1= ExclamationMarkEqualsSign | ||
12476 | { | ||
12477 | enumLiteral_1=(Token)match(input,ExclamationMarkEqualsSign,FOLLOW_2); | ||
12478 | |||
12479 | current = grammarAccess.getComparisonOperatorAccess().getNOT_EQUALSEnumLiteralDeclaration_1().getEnumLiteral().getInstance(); | ||
12480 | newLeafNode(enumLiteral_1, grammarAccess.getComparisonOperatorAccess().getNOT_EQUALSEnumLiteralDeclaration_1()); | ||
12481 | |||
12482 | |||
12483 | } | ||
12484 | |||
12485 | |||
12486 | } | ||
12487 | break; | ||
12488 | case 3 : | ||
12489 | // InternalSolverLanguageParser.g:4865:3: (enumLiteral_2= LessThanSign ) | ||
12490 | { | ||
12491 | // InternalSolverLanguageParser.g:4865:3: (enumLiteral_2= LessThanSign ) | ||
12492 | // InternalSolverLanguageParser.g:4866:4: enumLiteral_2= LessThanSign | ||
12493 | { | ||
12494 | enumLiteral_2=(Token)match(input,LessThanSign,FOLLOW_2); | ||
12495 | |||
12496 | current = grammarAccess.getComparisonOperatorAccess().getLESSEnumLiteralDeclaration_2().getEnumLiteral().getInstance(); | ||
12497 | newLeafNode(enumLiteral_2, grammarAccess.getComparisonOperatorAccess().getLESSEnumLiteralDeclaration_2()); | ||
12498 | |||
12499 | |||
12500 | } | ||
12501 | |||
12502 | |||
12503 | } | ||
12504 | break; | ||
12505 | case 4 : | ||
12506 | // InternalSolverLanguageParser.g:4873:3: (enumLiteral_3= LessThanSignEqualsSign ) | ||
12507 | { | ||
12508 | // InternalSolverLanguageParser.g:4873:3: (enumLiteral_3= LessThanSignEqualsSign ) | ||
12509 | // InternalSolverLanguageParser.g:4874:4: enumLiteral_3= LessThanSignEqualsSign | ||
12510 | { | ||
12511 | enumLiteral_3=(Token)match(input,LessThanSignEqualsSign,FOLLOW_2); | ||
12512 | |||
12513 | current = grammarAccess.getComparisonOperatorAccess().getLESS_EQUALSEnumLiteralDeclaration_3().getEnumLiteral().getInstance(); | ||
12514 | newLeafNode(enumLiteral_3, grammarAccess.getComparisonOperatorAccess().getLESS_EQUALSEnumLiteralDeclaration_3()); | ||
12515 | |||
12516 | |||
12517 | } | ||
12518 | |||
12519 | |||
12520 | } | ||
12521 | break; | ||
12522 | case 5 : | ||
12523 | // InternalSolverLanguageParser.g:4881:3: (enumLiteral_4= GreaterThanSign ) | ||
12524 | { | ||
12525 | // InternalSolverLanguageParser.g:4881:3: (enumLiteral_4= GreaterThanSign ) | ||
12526 | // InternalSolverLanguageParser.g:4882:4: enumLiteral_4= GreaterThanSign | ||
12527 | { | ||
12528 | enumLiteral_4=(Token)match(input,GreaterThanSign,FOLLOW_2); | ||
12529 | |||
12530 | current = grammarAccess.getComparisonOperatorAccess().getGREATEREnumLiteralDeclaration_4().getEnumLiteral().getInstance(); | ||
12531 | newLeafNode(enumLiteral_4, grammarAccess.getComparisonOperatorAccess().getGREATEREnumLiteralDeclaration_4()); | ||
12532 | |||
12533 | |||
12534 | } | ||
12535 | |||
12536 | |||
12537 | } | ||
12538 | break; | ||
12539 | case 6 : | ||
12540 | // InternalSolverLanguageParser.g:4889:3: (enumLiteral_5= GreaterThanSignEqualsSign ) | ||
12541 | { | ||
12542 | // InternalSolverLanguageParser.g:4889:3: (enumLiteral_5= GreaterThanSignEqualsSign ) | ||
12543 | // InternalSolverLanguageParser.g:4890:4: enumLiteral_5= GreaterThanSignEqualsSign | ||
12544 | { | ||
12545 | enumLiteral_5=(Token)match(input,GreaterThanSignEqualsSign,FOLLOW_2); | ||
12546 | |||
12547 | current = grammarAccess.getComparisonOperatorAccess().getGREATER_EQUALSEnumLiteralDeclaration_5().getEnumLiteral().getInstance(); | ||
12548 | newLeafNode(enumLiteral_5, grammarAccess.getComparisonOperatorAccess().getGREATER_EQUALSEnumLiteralDeclaration_5()); | ||
12549 | |||
12550 | |||
12551 | } | ||
12552 | |||
12553 | |||
12554 | } | ||
12555 | break; | ||
12556 | case 7 : | ||
12557 | // InternalSolverLanguageParser.g:4897:3: (enumLiteral_6= In ) | ||
12558 | { | ||
12559 | // InternalSolverLanguageParser.g:4897:3: (enumLiteral_6= In ) | ||
12560 | // InternalSolverLanguageParser.g:4898:4: enumLiteral_6= In | ||
12561 | { | ||
12562 | enumLiteral_6=(Token)match(input,In,FOLLOW_2); | ||
12563 | |||
12564 | current = grammarAccess.getComparisonOperatorAccess().getINEnumLiteralDeclaration_6().getEnumLiteral().getInstance(); | ||
12565 | newLeafNode(enumLiteral_6, grammarAccess.getComparisonOperatorAccess().getINEnumLiteralDeclaration_6()); | ||
12566 | |||
12567 | |||
12568 | } | ||
12569 | |||
12570 | |||
12571 | } | ||
12572 | break; | ||
12573 | |||
12574 | } | ||
12575 | |||
12576 | |||
12577 | } | ||
12578 | |||
12579 | |||
12580 | leaveRule(); | ||
12581 | |||
12582 | } | ||
12583 | |||
12584 | catch (RecognitionException re) { | ||
12585 | recover(input,re); | ||
12586 | appendSkippedTokens(); | ||
12587 | } | ||
12588 | finally { | ||
12589 | } | ||
12590 | return current; | ||
12591 | } | ||
12592 | // $ANTLR end "ruleComparisonOperator" | ||
12593 | |||
12594 | |||
12595 | // $ANTLR start "ruleAdditiveBinaryOperator" | ||
12596 | // InternalSolverLanguageParser.g:4908:1: ruleAdditiveBinaryOperator returns [Enumerator current=null] : ( (enumLiteral_0= PlusSign ) | (enumLiteral_1= HyphenMinus ) ) ; | ||
12597 | public final Enumerator ruleAdditiveBinaryOperator() throws RecognitionException { | ||
12598 | Enumerator current = null; | ||
12599 | |||
12600 | Token enumLiteral_0=null; | ||
12601 | Token enumLiteral_1=null; | ||
12602 | |||
12603 | |||
12604 | enterRule(); | ||
12605 | |||
12606 | try { | ||
12607 | // InternalSolverLanguageParser.g:4914:2: ( ( (enumLiteral_0= PlusSign ) | (enumLiteral_1= HyphenMinus ) ) ) | ||
12608 | // InternalSolverLanguageParser.g:4915:2: ( (enumLiteral_0= PlusSign ) | (enumLiteral_1= HyphenMinus ) ) | ||
12609 | { | ||
12610 | // InternalSolverLanguageParser.g:4915:2: ( (enumLiteral_0= PlusSign ) | (enumLiteral_1= HyphenMinus ) ) | ||
12611 | int alt63=2; | ||
12612 | int LA63_0 = input.LA(1); | ||
12613 | |||
12614 | if ( (LA63_0==PlusSign) ) { | ||
12615 | alt63=1; | ||
12616 | } | ||
12617 | else if ( (LA63_0==HyphenMinus) ) { | ||
12618 | alt63=2; | ||
12619 | } | ||
12620 | else { | ||
12621 | NoViableAltException nvae = | ||
12622 | new NoViableAltException("", 63, 0, input); | ||
12623 | |||
12624 | throw nvae; | ||
12625 | } | ||
12626 | switch (alt63) { | ||
12627 | case 1 : | ||
12628 | // InternalSolverLanguageParser.g:4916:3: (enumLiteral_0= PlusSign ) | ||
12629 | { | ||
12630 | // InternalSolverLanguageParser.g:4916:3: (enumLiteral_0= PlusSign ) | ||
12631 | // InternalSolverLanguageParser.g:4917:4: enumLiteral_0= PlusSign | ||
12632 | { | ||
12633 | enumLiteral_0=(Token)match(input,PlusSign,FOLLOW_2); | ||
12634 | |||
12635 | current = grammarAccess.getAdditiveBinaryOperatorAccess().getPLUSEnumLiteralDeclaration_0().getEnumLiteral().getInstance(); | ||
12636 | newLeafNode(enumLiteral_0, grammarAccess.getAdditiveBinaryOperatorAccess().getPLUSEnumLiteralDeclaration_0()); | ||
12637 | |||
12638 | |||
12639 | } | ||
12640 | |||
12641 | |||
12642 | } | ||
12643 | break; | ||
12644 | case 2 : | ||
12645 | // InternalSolverLanguageParser.g:4924:3: (enumLiteral_1= HyphenMinus ) | ||
12646 | { | ||
12647 | // InternalSolverLanguageParser.g:4924:3: (enumLiteral_1= HyphenMinus ) | ||
12648 | // InternalSolverLanguageParser.g:4925:4: enumLiteral_1= HyphenMinus | ||
12649 | { | ||
12650 | enumLiteral_1=(Token)match(input,HyphenMinus,FOLLOW_2); | ||
12651 | |||
12652 | current = grammarAccess.getAdditiveBinaryOperatorAccess().getMINUSEnumLiteralDeclaration_1().getEnumLiteral().getInstance(); | ||
12653 | newLeafNode(enumLiteral_1, grammarAccess.getAdditiveBinaryOperatorAccess().getMINUSEnumLiteralDeclaration_1()); | ||
12654 | |||
12655 | |||
12656 | } | ||
12657 | |||
12658 | |||
12659 | } | ||
12660 | break; | ||
12661 | |||
12662 | } | ||
12663 | |||
12664 | |||
12665 | } | ||
12666 | |||
12667 | |||
12668 | leaveRule(); | ||
12669 | |||
12670 | } | ||
12671 | |||
12672 | catch (RecognitionException re) { | ||
12673 | recover(input,re); | ||
12674 | appendSkippedTokens(); | ||
12675 | } | ||
12676 | finally { | ||
12677 | } | ||
12678 | return current; | ||
12679 | } | ||
12680 | // $ANTLR end "ruleAdditiveBinaryOperator" | ||
12681 | |||
12682 | |||
12683 | // $ANTLR start "ruleMultiplicativeBinaryOperator" | ||
12684 | // InternalSolverLanguageParser.g:4935:1: ruleMultiplicativeBinaryOperator returns [Enumerator current=null] : ( (enumLiteral_0= Asterisk ) | (enumLiteral_1= Solidus ) ) ; | ||
12685 | public final Enumerator ruleMultiplicativeBinaryOperator() throws RecognitionException { | ||
12686 | Enumerator current = null; | ||
12687 | |||
12688 | Token enumLiteral_0=null; | ||
12689 | Token enumLiteral_1=null; | ||
12690 | |||
12691 | |||
12692 | enterRule(); | ||
12693 | |||
12694 | try { | ||
12695 | // InternalSolverLanguageParser.g:4941:2: ( ( (enumLiteral_0= Asterisk ) | (enumLiteral_1= Solidus ) ) ) | ||
12696 | // InternalSolverLanguageParser.g:4942:2: ( (enumLiteral_0= Asterisk ) | (enumLiteral_1= Solidus ) ) | ||
12697 | { | ||
12698 | // InternalSolverLanguageParser.g:4942:2: ( (enumLiteral_0= Asterisk ) | (enumLiteral_1= Solidus ) ) | ||
12699 | int alt64=2; | ||
12700 | int LA64_0 = input.LA(1); | ||
12701 | |||
12702 | if ( (LA64_0==Asterisk) ) { | ||
12703 | alt64=1; | ||
12704 | } | ||
12705 | else if ( (LA64_0==Solidus) ) { | ||
12706 | alt64=2; | ||
12707 | } | ||
12708 | else { | ||
12709 | NoViableAltException nvae = | ||
12710 | new NoViableAltException("", 64, 0, input); | ||
12711 | |||
12712 | throw nvae; | ||
12713 | } | ||
12714 | switch (alt64) { | ||
12715 | case 1 : | ||
12716 | // InternalSolverLanguageParser.g:4943:3: (enumLiteral_0= Asterisk ) | ||
12717 | { | ||
12718 | // InternalSolverLanguageParser.g:4943:3: (enumLiteral_0= Asterisk ) | ||
12719 | // InternalSolverLanguageParser.g:4944:4: enumLiteral_0= Asterisk | ||
12720 | { | ||
12721 | enumLiteral_0=(Token)match(input,Asterisk,FOLLOW_2); | ||
12722 | |||
12723 | current = grammarAccess.getMultiplicativeBinaryOperatorAccess().getMULTIPLYEnumLiteralDeclaration_0().getEnumLiteral().getInstance(); | ||
12724 | newLeafNode(enumLiteral_0, grammarAccess.getMultiplicativeBinaryOperatorAccess().getMULTIPLYEnumLiteralDeclaration_0()); | ||
12725 | |||
12726 | |||
12727 | } | ||
12728 | |||
12729 | |||
12730 | } | ||
12731 | break; | ||
12732 | case 2 : | ||
12733 | // InternalSolverLanguageParser.g:4951:3: (enumLiteral_1= Solidus ) | ||
12734 | { | ||
12735 | // InternalSolverLanguageParser.g:4951:3: (enumLiteral_1= Solidus ) | ||
12736 | // InternalSolverLanguageParser.g:4952:4: enumLiteral_1= Solidus | ||
12737 | { | ||
12738 | enumLiteral_1=(Token)match(input,Solidus,FOLLOW_2); | ||
12739 | |||
12740 | current = grammarAccess.getMultiplicativeBinaryOperatorAccess().getDIVIDEEnumLiteralDeclaration_1().getEnumLiteral().getInstance(); | ||
12741 | newLeafNode(enumLiteral_1, grammarAccess.getMultiplicativeBinaryOperatorAccess().getDIVIDEEnumLiteralDeclaration_1()); | ||
12742 | |||
12743 | |||
12744 | } | ||
12745 | |||
12746 | |||
12747 | } | ||
12748 | break; | ||
12749 | |||
12750 | } | ||
12751 | |||
12752 | |||
12753 | } | ||
12754 | |||
12755 | |||
12756 | leaveRule(); | ||
12757 | |||
12758 | } | ||
12759 | |||
12760 | catch (RecognitionException re) { | ||
12761 | recover(input,re); | ||
12762 | appendSkippedTokens(); | ||
12763 | } | ||
12764 | finally { | ||
12765 | } | ||
12766 | return current; | ||
12767 | } | ||
12768 | // $ANTLR end "ruleMultiplicativeBinaryOperator" | ||
12769 | |||
12770 | |||
12771 | // $ANTLR start "ruleExponentialOp" | ||
12772 | // InternalSolverLanguageParser.g:4962:1: ruleExponentialOp returns [Enumerator current=null] : (enumLiteral_0= CircumflexAccent ) ; | ||
12773 | public final Enumerator ruleExponentialOp() throws RecognitionException { | ||
12774 | Enumerator current = null; | ||
12775 | |||
12776 | Token enumLiteral_0=null; | ||
12777 | |||
12778 | |||
12779 | enterRule(); | ||
12780 | |||
12781 | try { | ||
12782 | // InternalSolverLanguageParser.g:4968:2: ( (enumLiteral_0= CircumflexAccent ) ) | ||
12783 | // InternalSolverLanguageParser.g:4969:2: (enumLiteral_0= CircumflexAccent ) | ||
12784 | { | ||
12785 | // InternalSolverLanguageParser.g:4969:2: (enumLiteral_0= CircumflexAccent ) | ||
12786 | // InternalSolverLanguageParser.g:4970:3: enumLiteral_0= CircumflexAccent | ||
12787 | { | ||
12788 | enumLiteral_0=(Token)match(input,CircumflexAccent,FOLLOW_2); | ||
12789 | |||
12790 | current = grammarAccess.getExponentialOpAccess().getPOWEnumLiteralDeclaration().getEnumLiteral().getInstance(); | ||
12791 | newLeafNode(enumLiteral_0, grammarAccess.getExponentialOpAccess().getPOWEnumLiteralDeclaration()); | ||
12792 | |||
12793 | |||
12794 | } | ||
12795 | |||
12796 | |||
12797 | } | ||
12798 | |||
12799 | |||
12800 | leaveRule(); | ||
12801 | |||
12802 | } | ||
12803 | |||
12804 | catch (RecognitionException re) { | ||
12805 | recover(input,re); | ||
12806 | appendSkippedTokens(); | ||
12807 | } | ||
12808 | finally { | ||
12809 | } | ||
12810 | return current; | ||
12811 | } | ||
12812 | // $ANTLR end "ruleExponentialOp" | ||
12813 | |||
12814 | |||
12815 | // $ANTLR start "ruleUnaryOperator" | ||
12816 | // InternalSolverLanguageParser.g:4979:1: ruleUnaryOperator returns [Enumerator current=null] : ( (enumLiteral_0= ExclamationMark ) | (enumLiteral_1= PlusSign ) | (enumLiteral_2= HyphenMinus ) | (enumLiteral_3= QuestionMark ) ) ; | ||
12817 | public final Enumerator ruleUnaryOperator() throws RecognitionException { | ||
12818 | Enumerator current = null; | ||
12819 | |||
12820 | Token enumLiteral_0=null; | ||
12821 | Token enumLiteral_1=null; | ||
12822 | Token enumLiteral_2=null; | ||
12823 | Token enumLiteral_3=null; | ||
12824 | |||
12825 | |||
12826 | enterRule(); | ||
12827 | |||
12828 | try { | ||
12829 | // InternalSolverLanguageParser.g:4985:2: ( ( (enumLiteral_0= ExclamationMark ) | (enumLiteral_1= PlusSign ) | (enumLiteral_2= HyphenMinus ) | (enumLiteral_3= QuestionMark ) ) ) | ||
12830 | // InternalSolverLanguageParser.g:4986:2: ( (enumLiteral_0= ExclamationMark ) | (enumLiteral_1= PlusSign ) | (enumLiteral_2= HyphenMinus ) | (enumLiteral_3= QuestionMark ) ) | ||
12831 | { | ||
12832 | // InternalSolverLanguageParser.g:4986:2: ( (enumLiteral_0= ExclamationMark ) | (enumLiteral_1= PlusSign ) | (enumLiteral_2= HyphenMinus ) | (enumLiteral_3= QuestionMark ) ) | ||
12833 | int alt65=4; | ||
12834 | switch ( input.LA(1) ) { | ||
12835 | case ExclamationMark: | ||
12836 | { | ||
12837 | alt65=1; | ||
12838 | } | ||
12839 | break; | ||
12840 | case PlusSign: | ||
12841 | { | ||
12842 | alt65=2; | ||
12843 | } | ||
12844 | break; | ||
12845 | case HyphenMinus: | ||
12846 | { | ||
12847 | alt65=3; | ||
12848 | } | ||
12849 | break; | ||
12850 | case QuestionMark: | ||
12851 | { | ||
12852 | alt65=4; | ||
12853 | } | ||
12854 | break; | ||
12855 | default: | ||
12856 | NoViableAltException nvae = | ||
12857 | new NoViableAltException("", 65, 0, input); | ||
12858 | |||
12859 | throw nvae; | ||
12860 | } | ||
12861 | |||
12862 | switch (alt65) { | ||
12863 | case 1 : | ||
12864 | // InternalSolverLanguageParser.g:4987:3: (enumLiteral_0= ExclamationMark ) | ||
12865 | { | ||
12866 | // InternalSolverLanguageParser.g:4987:3: (enumLiteral_0= ExclamationMark ) | ||
12867 | // InternalSolverLanguageParser.g:4988:4: enumLiteral_0= ExclamationMark | ||
12868 | { | ||
12869 | enumLiteral_0=(Token)match(input,ExclamationMark,FOLLOW_2); | ||
12870 | |||
12871 | current = grammarAccess.getUnaryOperatorAccess().getNOTEnumLiteralDeclaration_0().getEnumLiteral().getInstance(); | ||
12872 | newLeafNode(enumLiteral_0, grammarAccess.getUnaryOperatorAccess().getNOTEnumLiteralDeclaration_0()); | ||
12873 | |||
12874 | |||
12875 | } | ||
12876 | |||
12877 | |||
12878 | } | ||
12879 | break; | ||
12880 | case 2 : | ||
12881 | // InternalSolverLanguageParser.g:4995:3: (enumLiteral_1= PlusSign ) | ||
12882 | { | ||
12883 | // InternalSolverLanguageParser.g:4995:3: (enumLiteral_1= PlusSign ) | ||
12884 | // InternalSolverLanguageParser.g:4996:4: enumLiteral_1= PlusSign | ||
12885 | { | ||
12886 | enumLiteral_1=(Token)match(input,PlusSign,FOLLOW_2); | ||
12887 | |||
12888 | current = grammarAccess.getUnaryOperatorAccess().getPLUSEnumLiteralDeclaration_1().getEnumLiteral().getInstance(); | ||
12889 | newLeafNode(enumLiteral_1, grammarAccess.getUnaryOperatorAccess().getPLUSEnumLiteralDeclaration_1()); | ||
12890 | |||
12891 | |||
12892 | } | ||
12893 | |||
12894 | |||
12895 | } | ||
12896 | break; | ||
12897 | case 3 : | ||
12898 | // InternalSolverLanguageParser.g:5003:3: (enumLiteral_2= HyphenMinus ) | ||
12899 | { | ||
12900 | // InternalSolverLanguageParser.g:5003:3: (enumLiteral_2= HyphenMinus ) | ||
12901 | // InternalSolverLanguageParser.g:5004:4: enumLiteral_2= HyphenMinus | ||
12902 | { | ||
12903 | enumLiteral_2=(Token)match(input,HyphenMinus,FOLLOW_2); | ||
12904 | |||
12905 | current = grammarAccess.getUnaryOperatorAccess().getMINUSEnumLiteralDeclaration_2().getEnumLiteral().getInstance(); | ||
12906 | newLeafNode(enumLiteral_2, grammarAccess.getUnaryOperatorAccess().getMINUSEnumLiteralDeclaration_2()); | ||
12907 | |||
12908 | |||
12909 | } | ||
12910 | |||
12911 | |||
12912 | } | ||
12913 | break; | ||
12914 | case 4 : | ||
12915 | // InternalSolverLanguageParser.g:5011:3: (enumLiteral_3= QuestionMark ) | ||
12916 | { | ||
12917 | // InternalSolverLanguageParser.g:5011:3: (enumLiteral_3= QuestionMark ) | ||
12918 | // InternalSolverLanguageParser.g:5012:4: enumLiteral_3= QuestionMark | ||
12919 | { | ||
12920 | enumLiteral_3=(Token)match(input,QuestionMark,FOLLOW_2); | ||
12921 | |||
12922 | current = grammarAccess.getUnaryOperatorAccess().getMAYBEEnumLiteralDeclaration_3().getEnumLiteral().getInstance(); | ||
12923 | newLeafNode(enumLiteral_3, grammarAccess.getUnaryOperatorAccess().getMAYBEEnumLiteralDeclaration_3()); | ||
12924 | |||
12925 | |||
12926 | } | ||
12927 | |||
12928 | |||
12929 | } | ||
12930 | break; | ||
12931 | |||
12932 | } | ||
12933 | |||
12934 | |||
12935 | } | ||
12936 | |||
12937 | |||
12938 | leaveRule(); | ||
12939 | |||
12940 | } | ||
12941 | |||
12942 | catch (RecognitionException re) { | ||
12943 | recover(input,re); | ||
12944 | appendSkippedTokens(); | ||
12945 | } | ||
12946 | finally { | ||
12947 | } | ||
12948 | return current; | ||
12949 | } | ||
12950 | // $ANTLR end "ruleUnaryOperator" | ||
12951 | |||
12952 | |||
12953 | // $ANTLR start "ruleLogicValue" | ||
12954 | // InternalSolverLanguageParser.g:5022:1: ruleLogicValue returns [Enumerator current=null] : ( (enumLiteral_0= True ) | (enumLiteral_1= False ) | (enumLiteral_2= Unknown ) | (enumLiteral_3= Error ) ) ; | ||
12955 | public final Enumerator ruleLogicValue() throws RecognitionException { | ||
12956 | Enumerator current = null; | ||
12957 | |||
12958 | Token enumLiteral_0=null; | ||
12959 | Token enumLiteral_1=null; | ||
12960 | Token enumLiteral_2=null; | ||
12961 | Token enumLiteral_3=null; | ||
12962 | |||
12963 | |||
12964 | enterRule(); | ||
12965 | |||
12966 | try { | ||
12967 | // InternalSolverLanguageParser.g:5028:2: ( ( (enumLiteral_0= True ) | (enumLiteral_1= False ) | (enumLiteral_2= Unknown ) | (enumLiteral_3= Error ) ) ) | ||
12968 | // InternalSolverLanguageParser.g:5029:2: ( (enumLiteral_0= True ) | (enumLiteral_1= False ) | (enumLiteral_2= Unknown ) | (enumLiteral_3= Error ) ) | ||
12969 | { | ||
12970 | // InternalSolverLanguageParser.g:5029:2: ( (enumLiteral_0= True ) | (enumLiteral_1= False ) | (enumLiteral_2= Unknown ) | (enumLiteral_3= Error ) ) | ||
12971 | int alt66=4; | ||
12972 | switch ( input.LA(1) ) { | ||
12973 | case True: | ||
12974 | { | ||
12975 | alt66=1; | ||
12976 | } | ||
12977 | break; | ||
12978 | case False: | ||
12979 | { | ||
12980 | alt66=2; | ||
12981 | } | ||
12982 | break; | ||
12983 | case Unknown: | ||
12984 | { | ||
12985 | alt66=3; | ||
12986 | } | ||
12987 | break; | ||
12988 | case Error: | ||
12989 | { | ||
12990 | alt66=4; | ||
12991 | } | ||
12992 | break; | ||
12993 | default: | ||
12994 | NoViableAltException nvae = | ||
12995 | new NoViableAltException("", 66, 0, input); | ||
12996 | |||
12997 | throw nvae; | ||
12998 | } | ||
12999 | |||
13000 | switch (alt66) { | ||
13001 | case 1 : | ||
13002 | // InternalSolverLanguageParser.g:5030:3: (enumLiteral_0= True ) | ||
13003 | { | ||
13004 | // InternalSolverLanguageParser.g:5030:3: (enumLiteral_0= True ) | ||
13005 | // InternalSolverLanguageParser.g:5031:4: enumLiteral_0= True | ||
13006 | { | ||
13007 | enumLiteral_0=(Token)match(input,True,FOLLOW_2); | ||
13008 | |||
13009 | current = grammarAccess.getLogicValueAccess().getTRUEEnumLiteralDeclaration_0().getEnumLiteral().getInstance(); | ||
13010 | newLeafNode(enumLiteral_0, grammarAccess.getLogicValueAccess().getTRUEEnumLiteralDeclaration_0()); | ||
13011 | |||
13012 | |||
13013 | } | ||
13014 | |||
13015 | |||
13016 | } | ||
13017 | break; | ||
13018 | case 2 : | ||
13019 | // InternalSolverLanguageParser.g:5038:3: (enumLiteral_1= False ) | ||
13020 | { | ||
13021 | // InternalSolverLanguageParser.g:5038:3: (enumLiteral_1= False ) | ||
13022 | // InternalSolverLanguageParser.g:5039:4: enumLiteral_1= False | ||
13023 | { | ||
13024 | enumLiteral_1=(Token)match(input,False,FOLLOW_2); | ||
13025 | |||
13026 | current = grammarAccess.getLogicValueAccess().getFALSEEnumLiteralDeclaration_1().getEnumLiteral().getInstance(); | ||
13027 | newLeafNode(enumLiteral_1, grammarAccess.getLogicValueAccess().getFALSEEnumLiteralDeclaration_1()); | ||
13028 | |||
13029 | |||
13030 | } | ||
13031 | |||
13032 | |||
13033 | } | ||
13034 | break; | ||
13035 | case 3 : | ||
13036 | // InternalSolverLanguageParser.g:5046:3: (enumLiteral_2= Unknown ) | ||
13037 | { | ||
13038 | // InternalSolverLanguageParser.g:5046:3: (enumLiteral_2= Unknown ) | ||
13039 | // InternalSolverLanguageParser.g:5047:4: enumLiteral_2= Unknown | ||
13040 | { | ||
13041 | enumLiteral_2=(Token)match(input,Unknown,FOLLOW_2); | ||
13042 | |||
13043 | current = grammarAccess.getLogicValueAccess().getUNKNOWNEnumLiteralDeclaration_2().getEnumLiteral().getInstance(); | ||
13044 | newLeafNode(enumLiteral_2, grammarAccess.getLogicValueAccess().getUNKNOWNEnumLiteralDeclaration_2()); | ||
13045 | |||
13046 | |||
13047 | } | ||
13048 | |||
13049 | |||
13050 | } | ||
13051 | break; | ||
13052 | case 4 : | ||
13053 | // InternalSolverLanguageParser.g:5054:3: (enumLiteral_3= Error ) | ||
13054 | { | ||
13055 | // InternalSolverLanguageParser.g:5054:3: (enumLiteral_3= Error ) | ||
13056 | // InternalSolverLanguageParser.g:5055:4: enumLiteral_3= Error | ||
13057 | { | ||
13058 | enumLiteral_3=(Token)match(input,Error,FOLLOW_2); | ||
13059 | |||
13060 | current = grammarAccess.getLogicValueAccess().getERROREnumLiteralDeclaration_3().getEnumLiteral().getInstance(); | ||
13061 | newLeafNode(enumLiteral_3, grammarAccess.getLogicValueAccess().getERROREnumLiteralDeclaration_3()); | ||
13062 | |||
13063 | |||
13064 | } | ||
13065 | |||
13066 | |||
13067 | } | ||
13068 | break; | ||
13069 | |||
13070 | } | ||
13071 | |||
13072 | |||
13073 | } | ||
13074 | |||
13075 | |||
13076 | leaveRule(); | ||
13077 | |||
13078 | } | ||
13079 | |||
13080 | catch (RecognitionException re) { | ||
13081 | recover(input,re); | ||
13082 | appendSkippedTokens(); | ||
13083 | } | ||
13084 | finally { | ||
13085 | } | ||
13086 | return current; | ||
13087 | } | ||
13088 | // $ANTLR end "ruleLogicValue" | ||
13089 | |||
13090 | |||
13091 | // $ANTLR start "ruleObjectiveKind" | ||
13092 | // InternalSolverLanguageParser.g:5065:1: ruleObjectiveKind returns [Enumerator current=null] : ( (enumLiteral_0= Minimize ) | (enumLiteral_1= Maximize ) ) ; | ||
13093 | public final Enumerator ruleObjectiveKind() throws RecognitionException { | ||
13094 | Enumerator current = null; | ||
13095 | |||
13096 | Token enumLiteral_0=null; | ||
13097 | Token enumLiteral_1=null; | ||
13098 | |||
13099 | |||
13100 | enterRule(); | ||
13101 | |||
13102 | try { | ||
13103 | // InternalSolverLanguageParser.g:5071:2: ( ( (enumLiteral_0= Minimize ) | (enumLiteral_1= Maximize ) ) ) | ||
13104 | // InternalSolverLanguageParser.g:5072:2: ( (enumLiteral_0= Minimize ) | (enumLiteral_1= Maximize ) ) | ||
13105 | { | ||
13106 | // InternalSolverLanguageParser.g:5072:2: ( (enumLiteral_0= Minimize ) | (enumLiteral_1= Maximize ) ) | ||
13107 | int alt67=2; | ||
13108 | int LA67_0 = input.LA(1); | ||
13109 | |||
13110 | if ( (LA67_0==Minimize) ) { | ||
13111 | alt67=1; | ||
13112 | } | ||
13113 | else if ( (LA67_0==Maximize) ) { | ||
13114 | alt67=2; | ||
13115 | } | ||
13116 | else { | ||
13117 | NoViableAltException nvae = | ||
13118 | new NoViableAltException("", 67, 0, input); | ||
13119 | |||
13120 | throw nvae; | ||
13121 | } | ||
13122 | switch (alt67) { | ||
13123 | case 1 : | ||
13124 | // InternalSolverLanguageParser.g:5073:3: (enumLiteral_0= Minimize ) | ||
13125 | { | ||
13126 | // InternalSolverLanguageParser.g:5073:3: (enumLiteral_0= Minimize ) | ||
13127 | // InternalSolverLanguageParser.g:5074:4: enumLiteral_0= Minimize | ||
13128 | { | ||
13129 | enumLiteral_0=(Token)match(input,Minimize,FOLLOW_2); | ||
13130 | |||
13131 | current = grammarAccess.getObjectiveKindAccess().getMINIMIZATIONEnumLiteralDeclaration_0().getEnumLiteral().getInstance(); | ||
13132 | newLeafNode(enumLiteral_0, grammarAccess.getObjectiveKindAccess().getMINIMIZATIONEnumLiteralDeclaration_0()); | ||
13133 | |||
13134 | |||
13135 | } | ||
13136 | |||
13137 | |||
13138 | } | ||
13139 | break; | ||
13140 | case 2 : | ||
13141 | // InternalSolverLanguageParser.g:5081:3: (enumLiteral_1= Maximize ) | ||
13142 | { | ||
13143 | // InternalSolverLanguageParser.g:5081:3: (enumLiteral_1= Maximize ) | ||
13144 | // InternalSolverLanguageParser.g:5082:4: enumLiteral_1= Maximize | ||
13145 | { | ||
13146 | enumLiteral_1=(Token)match(input,Maximize,FOLLOW_2); | ||
13147 | |||
13148 | current = grammarAccess.getObjectiveKindAccess().getMAXIMIZATIONEnumLiteralDeclaration_1().getEnumLiteral().getInstance(); | ||
13149 | newLeafNode(enumLiteral_1, grammarAccess.getObjectiveKindAccess().getMAXIMIZATIONEnumLiteralDeclaration_1()); | ||
13150 | |||
13151 | |||
13152 | } | ||
13153 | |||
13154 | |||
13155 | } | ||
13156 | break; | ||
13157 | |||
13158 | } | ||
13159 | |||
13160 | |||
13161 | } | ||
13162 | |||
13163 | |||
13164 | leaveRule(); | ||
13165 | |||
13166 | } | ||
13167 | |||
13168 | catch (RecognitionException re) { | ||
13169 | recover(input,re); | ||
13170 | appendSkippedTokens(); | ||
13171 | } | ||
13172 | finally { | ||
13173 | } | ||
13174 | return current; | ||
13175 | } | ||
13176 | // $ANTLR end "ruleObjectiveKind" | ||
13177 | |||
13178 | // Delegated rules | ||
13179 | |||
13180 | |||
13181 | protected DFA4 dfa4 = new DFA4(this); | ||
13182 | protected DFA13 dfa13 = new DFA13(this); | ||
13183 | protected DFA30 dfa30 = new DFA30(this); | ||
13184 | protected DFA31 dfa31 = new DFA31(this); | ||
13185 | protected DFA34 dfa34 = new DFA34(this); | ||
13186 | protected DFA53 dfa53 = new DFA53(this); | ||
13187 | static final String dfa_1s = "\35\uffff"; | ||
13188 | static final String dfa_2s = "\1\4\1\uffff\3\22\1\5\1\22\1\uffff\1\6\6\uffff\1\22\2\uffff\3\45\1\uffff\4\22\3\45"; | ||
13189 | static final String dfa_3s = "\1\113\1\uffff\5\112\1\uffff\1\112\6\uffff\1\112\2\uffff\3\111\1\uffff\4\112\3\111"; | ||
13190 | static final String dfa_4s = "\1\uffff\1\1\5\uffff\1\4\1\uffff\1\6\1\7\1\10\1\11\1\12\1\13\1\uffff\1\5\1\2\3\uffff\1\3\7\uffff"; | ||
13191 | static final String dfa_5s = "\35\uffff}>"; | ||
13192 | static final String[] dfa_6s = { | ||
13193 | "\1\11\1\6\1\15\2\uffff\2\14\1\uffff\1\7\2\uffff\1\1\1\12\1\uffff\1\4\1\uffff\1\15\2\1\1\5\1\1\1\13\1\uffff\1\16\1\10\1\uffff\1\1\1\uffff\2\1\12\uffff\1\1\1\uffff\2\1\2\uffff\1\1\1\uffff\1\1\7\uffff\2\1\5\uffff\2\1\1\3\4\uffff\1\2\1\1", | ||
13194 | "", | ||
13195 | "\1\20\17\uffff\3\1\1\17\6\1\1\uffff\1\1\1\uffff\1\1\1\uffff\11\1\1\uffff\1\1\3\uffff\2\1\2\uffff\1\20\1\uffff\1\20\1\uffff\3\1\1\20", | ||
13196 | "\1\20\17\uffff\3\1\1\17\6\1\1\uffff\1\1\1\uffff\1\1\1\uffff\11\1\1\uffff\1\1\3\uffff\2\1\2\uffff\1\20\1\uffff\1\20\1\uffff\3\1\1\20", | ||
13197 | "\1\20\17\uffff\3\1\1\17\6\1\1\uffff\1\1\1\uffff\1\1\1\uffff\11\1\1\uffff\1\1\3\uffff\2\1\2\uffff\1\20\1\uffff\1\20\1\uffff\3\1\1\20", | ||
13198 | "\1\21\14\uffff\1\24\17\uffff\3\1\1\uffff\6\1\1\uffff\1\1\1\uffff\1\25\1\uffff\4\1\1\uffff\4\1\1\uffff\1\1\3\uffff\1\1\3\uffff\1\21\1\uffff\1\23\3\uffff\1\1\1\22", | ||
13199 | "\1\24\4\uffff\1\21\53\uffff\1\21\1\uffff\1\23\4\uffff\1\22", | ||
13200 | "", | ||
13201 | "\1\15\13\uffff\1\11\1\uffff\1\15\7\uffff\1\15\50\uffff\1\11\4\uffff\1\11", | ||
13202 | "", | ||
13203 | "", | ||
13204 | "", | ||
13205 | "", | ||
13206 | "", | ||
13207 | "", | ||
13208 | "\1\30\62\uffff\1\27\4\uffff\1\26", | ||
13209 | "", | ||
13210 | "", | ||
13211 | "\1\31\11\uffff\1\21\5\uffff\1\21\21\uffff\2\21\1\11", | ||
13212 | "\1\31\11\uffff\1\21\5\uffff\1\21\21\uffff\2\21\1\11", | ||
13213 | "\1\31\11\uffff\1\21\5\uffff\1\21\21\uffff\2\21\1\11", | ||
13214 | "", | ||
13215 | "\1\20\17\uffff\3\1\1\17\6\1\1\uffff\1\1\1\uffff\1\1\1\uffff\11\1\1\uffff\1\1\3\uffff\2\1\2\uffff\1\20\1\uffff\1\20\1\uffff\3\1\1\20", | ||
13216 | "\1\20\17\uffff\3\1\1\17\6\1\1\uffff\1\1\1\uffff\1\1\1\uffff\11\1\1\uffff\1\1\3\uffff\2\1\2\uffff\1\20\1\uffff\1\20\1\uffff\3\1\1\20", | ||
13217 | "\1\20\17\uffff\3\1\1\17\6\1\1\uffff\1\1\1\uffff\1\1\1\uffff\11\1\1\uffff\1\1\3\uffff\2\1\2\uffff\1\20\1\uffff\1\20\1\uffff\3\1\1\20", | ||
13218 | "\1\34\62\uffff\1\33\4\uffff\1\32", | ||
13219 | "\1\31\11\uffff\1\21\5\uffff\1\21\21\uffff\2\21\1\11", | ||
13220 | "\1\31\11\uffff\1\21\5\uffff\1\21\21\uffff\2\21\1\11", | ||
13221 | "\1\31\11\uffff\1\21\5\uffff\1\21\21\uffff\2\21\1\11" | ||
13222 | }; | ||
13223 | |||
13224 | static final short[] dfa_1 = DFA.unpackEncodedString(dfa_1s); | ||
13225 | static final char[] dfa_2 = DFA.unpackEncodedStringToUnsignedChars(dfa_2s); | ||
13226 | static final char[] dfa_3 = DFA.unpackEncodedStringToUnsignedChars(dfa_3s); | ||
13227 | static final short[] dfa_4 = DFA.unpackEncodedString(dfa_4s); | ||
13228 | static final short[] dfa_5 = DFA.unpackEncodedString(dfa_5s); | ||
13229 | static final short[][] dfa_6 = unpackEncodedStringArray(dfa_6s); | ||
13230 | |||
13231 | class DFA4 extends DFA { | ||
13232 | |||
13233 | public DFA4(BaseRecognizer recognizer) { | ||
13234 | this.recognizer = recognizer; | ||
13235 | this.decisionNumber = 4; | ||
13236 | this.eot = dfa_1; | ||
13237 | this.eof = dfa_1; | ||
13238 | this.min = dfa_2; | ||
13239 | this.max = dfa_3; | ||
13240 | this.accept = dfa_4; | ||
13241 | this.special = dfa_5; | ||
13242 | this.transition = dfa_6; | ||
13243 | } | ||
13244 | public String getDescription() { | ||
13245 | return "158:2: (this_AssertionOrDefinition_0= ruleAssertionOrDefinition | this_PredicateDefinition_1= rulePredicateDefinition | this_UnnamedErrorPredicateDefintion_2= ruleUnnamedErrorPredicateDefintion | this_DefaultAssertion_3= ruleDefaultAssertion | this_FunctionDefinition_4= ruleFunctionDefinition | this_Attribute_5= ruleAttribute | this_ExternDeclaration_6= ruleExternDeclaration | this_ScopeDeclaration_7= ruleScopeDeclaration | this_ObjectiveDeclaration_8= ruleObjectiveDeclaration | this_ClassDeclaration_9= ruleClassDeclaration | this_EnumDeclaration_10= ruleEnumDeclaration )"; | ||
13246 | } | ||
13247 | } | ||
13248 | static final String dfa_7s = "\24\uffff"; | ||
13249 | static final String dfa_8s = "\1\20\1\5\2\uffff\4\22\3\45\4\22\2\uffff\3\45"; | ||
13250 | static final String dfa_9s = "\1\20\1\112\2\uffff\4\112\3\100\4\112\2\uffff\3\100"; | ||
13251 | static final String dfa_10s = "\2\uffff\1\4\1\1\13\uffff\1\3\1\2\3\uffff"; | ||
13252 | static final String dfa_11s = "\24\uffff}>"; | ||
13253 | static final String[] dfa_12s = { | ||
13254 | "\1\1", | ||
13255 | "\1\3\2\uffff\1\2\11\uffff\1\6\4\uffff\1\3\55\uffff\1\5\4\uffff\1\4", | ||
13256 | "", | ||
13257 | "", | ||
13258 | "\1\12\22\uffff\1\7\11\uffff\1\3\25\uffff\1\11\4\uffff\1\10", | ||
13259 | "\1\12\22\uffff\1\7\11\uffff\1\3\25\uffff\1\11\4\uffff\1\10", | ||
13260 | "\1\12\22\uffff\1\7\11\uffff\1\3\25\uffff\1\11\4\uffff\1\10", | ||
13261 | "\1\15\62\uffff\1\14\4\uffff\1\13", | ||
13262 | "\1\16\11\uffff\1\20\20\uffff\1\17", | ||
13263 | "\1\16\11\uffff\1\20\20\uffff\1\17", | ||
13264 | "\1\16\11\uffff\1\20\20\uffff\1\17", | ||
13265 | "\1\12\22\uffff\1\7\11\uffff\1\3\25\uffff\1\11\4\uffff\1\10", | ||
13266 | "\1\12\22\uffff\1\7\11\uffff\1\3\25\uffff\1\11\4\uffff\1\10", | ||
13267 | "\1\12\22\uffff\1\7\11\uffff\1\3\25\uffff\1\11\4\uffff\1\10", | ||
13268 | "\1\23\62\uffff\1\22\4\uffff\1\21", | ||
13269 | "", | ||
13270 | "", | ||
13271 | "\1\16\11\uffff\1\20\20\uffff\1\17", | ||
13272 | "\1\16\11\uffff\1\20\20\uffff\1\17", | ||
13273 | "\1\16\11\uffff\1\20\20\uffff\1\17" | ||
13274 | }; | ||
13275 | |||
13276 | static final short[] dfa_7 = DFA.unpackEncodedString(dfa_7s); | ||
13277 | static final char[] dfa_8 = DFA.unpackEncodedStringToUnsignedChars(dfa_8s); | ||
13278 | static final char[] dfa_9 = DFA.unpackEncodedStringToUnsignedChars(dfa_9s); | ||
13279 | static final short[] dfa_10 = DFA.unpackEncodedString(dfa_10s); | ||
13280 | static final short[] dfa_11 = DFA.unpackEncodedString(dfa_11s); | ||
13281 | static final short[][] dfa_12 = unpackEncodedStringArray(dfa_12s); | ||
13282 | |||
13283 | class DFA13 extends DFA { | ||
13284 | |||
13285 | public DFA13(BaseRecognizer recognizer) { | ||
13286 | this.recognizer = recognizer; | ||
13287 | this.decisionNumber = 13; | ||
13288 | this.eot = dfa_7; | ||
13289 | this.eof = dfa_7; | ||
13290 | this.min = dfa_8; | ||
13291 | this.max = dfa_9; | ||
13292 | this.accept = dfa_10; | ||
13293 | this.special = dfa_11; | ||
13294 | this.transition = dfa_12; | ||
13295 | } | ||
13296 | public String getDescription() { | ||
13297 | return "1041:2: (this_ExternPredicateDeclaration_0= ruleExternPredicateDeclaration | this_ExternFunctionDeclaration_1= ruleExternFunctionDeclaration | this_ExternAggregationOperatorDeclaration_2= ruleExternAggregationOperatorDeclaration | this_ExternDatatypeDeclaration_3= ruleExternDatatypeDeclaration )"; | ||
13298 | } | ||
13299 | } | ||
13300 | static final String dfa_13s = "\13\uffff"; | ||
13301 | static final String dfa_14s = "\2\uffff\3\1\3\uffff\3\1"; | ||
13302 | static final String dfa_15s = "\1\17\1\uffff\3\32\1\uffff\1\22\1\uffff\3\32"; | ||
13303 | static final String dfa_16s = "\1\113\1\uffff\3\111\1\uffff\1\112\1\uffff\3\111"; | ||
13304 | static final String dfa_17s = "\1\uffff\1\1\3\uffff\1\3\1\uffff\1\2\3\uffff"; | ||
13305 | static final String dfa_18s = "\13\uffff}>"; | ||
13306 | static final String[] dfa_19s = { | ||
13307 | "\1\1\2\uffff\1\4\2\uffff\1\5\3\1\5\uffff\1\1\1\uffff\1\1\16\uffff\1\1\15\uffff\1\1\5\uffff\2\1\1\3\4\uffff\1\2\1\1", | ||
13308 | "", | ||
13309 | "\1\1\2\uffff\1\1\4\uffff\3\1\1\6\6\1\1\uffff\1\1\1\uffff\13\1\1\uffff\1\1\2\uffff\2\1\1\7\2\1\4\uffff\3\1", | ||
13310 | "\1\1\2\uffff\1\1\4\uffff\3\1\1\6\6\1\1\uffff\1\1\1\uffff\13\1\1\uffff\1\1\2\uffff\2\1\1\7\2\1\4\uffff\3\1", | ||
13311 | "\1\1\2\uffff\1\1\4\uffff\3\1\1\6\6\1\1\uffff\1\1\1\uffff\13\1\1\uffff\1\1\2\uffff\2\1\1\7\2\1\4\uffff\3\1", | ||
13312 | "", | ||
13313 | "\1\12\62\uffff\1\11\4\uffff\1\10", | ||
13314 | "", | ||
13315 | "\1\1\2\uffff\1\1\4\uffff\3\1\1\6\6\1\1\uffff\1\1\1\uffff\13\1\1\uffff\1\1\2\uffff\2\1\1\7\2\1\4\uffff\3\1", | ||
13316 | "\1\1\2\uffff\1\1\4\uffff\3\1\1\6\6\1\1\uffff\1\1\1\uffff\13\1\1\uffff\1\1\2\uffff\2\1\1\7\2\1\4\uffff\3\1", | ||
13317 | "\1\1\2\uffff\1\1\4\uffff\3\1\1\6\6\1\1\uffff\1\1\1\uffff\13\1\1\uffff\1\1\2\uffff\2\1\1\7\2\1\4\uffff\3\1" | ||
13318 | }; | ||
13319 | |||
13320 | static final short[] dfa_13 = DFA.unpackEncodedString(dfa_13s); | ||
13321 | static final short[] dfa_14 = DFA.unpackEncodedString(dfa_14s); | ||
13322 | static final char[] dfa_15 = DFA.unpackEncodedStringToUnsignedChars(dfa_15s); | ||
13323 | static final char[] dfa_16 = DFA.unpackEncodedStringToUnsignedChars(dfa_16s); | ||
13324 | static final short[] dfa_17 = DFA.unpackEncodedString(dfa_17s); | ||
13325 | static final short[] dfa_18 = DFA.unpackEncodedString(dfa_18s); | ||
13326 | static final short[][] dfa_19 = unpackEncodedStringArray(dfa_19s); | ||
13327 | |||
13328 | class DFA30 extends DFA { | ||
13329 | |||
13330 | public DFA30(BaseRecognizer recognizer) { | ||
13331 | this.recognizer = recognizer; | ||
13332 | this.decisionNumber = 30; | ||
13333 | this.eot = dfa_13; | ||
13334 | this.eof = dfa_14; | ||
13335 | this.min = dfa_15; | ||
13336 | this.max = dfa_16; | ||
13337 | this.accept = dfa_17; | ||
13338 | this.special = dfa_18; | ||
13339 | this.transition = dfa_19; | ||
13340 | } | ||
13341 | public String getDescription() { | ||
13342 | return "2451:2: (this_AtomicExpression_0= ruleAtomicExpression | this_Aggregation_1= ruleAggregation | this_Count_2= ruleCount )"; | ||
13343 | } | ||
13344 | } | ||
13345 | static final String dfa_20s = "\33\uffff"; | ||
13346 | static final String dfa_21s = "\2\uffff\3\14\4\uffff\2\14\3\uffff\3\14\1\uffff\3\14\1\uffff\5\14"; | ||
13347 | static final String dfa_22s = "\1\17\1\22\3\32\3\uffff\1\22\2\32\1\22\2\uffff\3\32\1\22\3\32\1\22\5\32"; | ||
13348 | static final String dfa_23s = "\1\113\1\112\3\111\3\uffff\1\112\2\111\1\112\2\uffff\3\111\1\112\3\111\1\112\5\111"; | ||
13349 | static final String dfa_24s = "\5\uffff\1\3\1\4\1\5\4\uffff\1\1\1\2\15\uffff"; | ||
13350 | static final String dfa_25s = "\33\uffff}>"; | ||
13351 | static final String[] dfa_26s = { | ||
13352 | "\1\6\2\uffff\1\4\3\uffff\3\6\5\uffff\1\6\1\uffff\1\6\16\uffff\1\7\15\uffff\1\5\5\uffff\1\1\1\6\1\3\4\uffff\1\2\1\6", | ||
13353 | "\1\4\62\uffff\1\3\4\uffff\1\2", | ||
13354 | "\1\14\2\uffff\1\14\4\uffff\3\14\1\10\6\14\1\uffff\1\14\1\uffff\1\15\5\14\1\13\4\14\1\uffff\1\14\2\uffff\2\14\1\uffff\2\14\4\uffff\1\11\1\12\1\14", | ||
13355 | "\1\14\2\uffff\1\14\4\uffff\3\14\1\10\6\14\1\uffff\1\14\1\uffff\1\15\5\14\1\13\4\14\1\uffff\1\14\2\uffff\2\14\1\uffff\2\14\4\uffff\1\11\1\12\1\14", | ||
13356 | "\1\14\2\uffff\1\14\4\uffff\3\14\1\10\6\14\1\uffff\1\14\1\uffff\1\15\5\14\1\13\4\14\1\uffff\1\14\2\uffff\2\14\1\uffff\2\14\4\uffff\1\11\1\12\1\14", | ||
13357 | "", | ||
13358 | "", | ||
13359 | "", | ||
13360 | "\1\20\62\uffff\1\17\4\uffff\1\16", | ||
13361 | "\1\14\2\uffff\1\14\4\uffff\3\14\1\uffff\6\14\1\uffff\1\14\1\uffff\1\15\5\14\1\13\4\14\1\uffff\1\14\2\uffff\2\14\1\uffff\2\14\6\uffff\1\14", | ||
13362 | "\1\14\2\uffff\1\14\4\uffff\3\14\1\uffff\6\14\1\uffff\1\14\1\uffff\1\15\5\14\1\13\4\14\1\uffff\1\14\2\uffff\2\14\1\uffff\2\14\6\uffff\1\14", | ||
13363 | "\1\24\60\uffff\1\21\1\uffff\1\23\4\uffff\1\22", | ||
13364 | "", | ||
13365 | "", | ||
13366 | "\1\14\2\uffff\1\14\4\uffff\3\14\1\10\6\14\1\uffff\1\14\1\uffff\1\15\5\14\1\13\4\14\1\uffff\1\14\2\uffff\2\14\1\uffff\2\14\4\uffff\1\11\1\12\1\14", | ||
13367 | "\1\14\2\uffff\1\14\4\uffff\3\14\1\10\6\14\1\uffff\1\14\1\uffff\1\15\5\14\1\13\4\14\1\uffff\1\14\2\uffff\2\14\1\uffff\2\14\4\uffff\1\11\1\12\1\14", | ||
13368 | "\1\14\2\uffff\1\14\4\uffff\3\14\1\10\6\14\1\uffff\1\14\1\uffff\1\15\5\14\1\13\4\14\1\uffff\1\14\2\uffff\2\14\1\uffff\2\14\4\uffff\1\11\1\12\1\14", | ||
13369 | "\1\24\62\uffff\1\23\4\uffff\1\22", | ||
13370 | "\1\14\2\uffff\1\14\4\uffff\3\14\1\25\6\14\1\uffff\1\14\1\uffff\1\15\5\14\1\13\4\14\1\uffff\1\14\2\uffff\2\14\1\uffff\2\14\4\uffff\1\26\1\27\1\14", | ||
13371 | "\1\14\2\uffff\1\14\4\uffff\3\14\1\25\6\14\1\uffff\1\14\1\uffff\1\15\5\14\1\13\4\14\1\uffff\1\14\2\uffff\2\14\1\uffff\2\14\4\uffff\1\26\1\27\1\14", | ||
13372 | "\1\14\2\uffff\1\14\4\uffff\3\14\1\25\6\14\1\uffff\1\14\1\uffff\1\15\5\14\1\13\4\14\1\uffff\1\14\2\uffff\2\14\1\uffff\2\14\4\uffff\1\26\1\27\1\14", | ||
13373 | "\1\32\62\uffff\1\31\4\uffff\1\30", | ||
13374 | "\1\14\2\uffff\1\14\4\uffff\3\14\1\uffff\6\14\1\uffff\1\14\1\uffff\1\15\5\14\1\13\4\14\1\uffff\1\14\2\uffff\2\14\1\uffff\2\14\6\uffff\1\14", | ||
13375 | "\1\14\2\uffff\1\14\4\uffff\3\14\1\uffff\6\14\1\uffff\1\14\1\uffff\1\15\5\14\1\13\4\14\1\uffff\1\14\2\uffff\2\14\1\uffff\2\14\6\uffff\1\14", | ||
13376 | "\1\14\2\uffff\1\14\4\uffff\3\14\1\25\6\14\1\uffff\1\14\1\uffff\1\15\5\14\1\13\4\14\1\uffff\1\14\2\uffff\2\14\1\uffff\2\14\4\uffff\1\26\1\27\1\14", | ||
13377 | "\1\14\2\uffff\1\14\4\uffff\3\14\1\25\6\14\1\uffff\1\14\1\uffff\1\15\5\14\1\13\4\14\1\uffff\1\14\2\uffff\2\14\1\uffff\2\14\4\uffff\1\26\1\27\1\14", | ||
13378 | "\1\14\2\uffff\1\14\4\uffff\3\14\1\25\6\14\1\uffff\1\14\1\uffff\1\15\5\14\1\13\4\14\1\uffff\1\14\2\uffff\2\14\1\uffff\2\14\4\uffff\1\26\1\27\1\14" | ||
13379 | }; | ||
13380 | |||
13381 | static final short[] dfa_20 = DFA.unpackEncodedString(dfa_20s); | ||
13382 | static final short[] dfa_21 = DFA.unpackEncodedString(dfa_21s); | ||
13383 | static final char[] dfa_22 = DFA.unpackEncodedStringToUnsignedChars(dfa_22s); | ||
13384 | static final char[] dfa_23 = DFA.unpackEncodedStringToUnsignedChars(dfa_23s); | ||
13385 | static final short[] dfa_24 = DFA.unpackEncodedString(dfa_24s); | ||
13386 | static final short[] dfa_25 = DFA.unpackEncodedString(dfa_25s); | ||
13387 | static final short[][] dfa_26 = unpackEncodedStringArray(dfa_26s); | ||
13388 | |||
13389 | class DFA31 extends DFA { | ||
13390 | |||
13391 | public DFA31(BaseRecognizer recognizer) { | ||
13392 | this.recognizer = recognizer; | ||
13393 | this.decisionNumber = 31; | ||
13394 | this.eot = dfa_20; | ||
13395 | this.eof = dfa_21; | ||
13396 | this.min = dfa_22; | ||
13397 | this.max = dfa_23; | ||
13398 | this.accept = dfa_24; | ||
13399 | this.special = dfa_25; | ||
13400 | this.transition = dfa_26; | ||
13401 | } | ||
13402 | public String getDescription() { | ||
13403 | return "2631:2: (this_Reference_0= ruleReference | this_Call_1= ruleCall | this_Interval_2= ruleInterval | this_Literal_3= ruleLiteral | (otherlv_4= LeftParenthesis this_Expression_5= ruleExpression otherlv_6= RightParenthesis ) )"; | ||
13404 | } | ||
13405 | } | ||
13406 | static final String dfa_27s = "\16\uffff"; | ||
13407 | static final String dfa_28s = "\2\uffff\3\1\2\uffff\1\15\2\uffff\3\1\1\uffff"; | ||
13408 | static final String dfa_29s = "\1\17\1\uffff\3\22\1\uffff\1\22\1\17\1\61\1\uffff\3\22\1\uffff"; | ||
13409 | static final String dfa_30s = "\1\113\1\uffff\3\112\1\uffff\1\112\1\113\1\112\1\uffff\3\112\1\uffff"; | ||
13410 | static final String dfa_31s = "\1\uffff\1\1\3\uffff\1\2\3\uffff\1\3\3\uffff\1\4"; | ||
13411 | static final String dfa_32s = "\16\uffff}>"; | ||
13412 | static final String[] dfa_33s = { | ||
13413 | "\1\1\2\uffff\1\4\2\uffff\4\1\5\uffff\1\1\1\uffff\1\1\15\uffff\2\1\1\uffff\1\5\1\1\1\uffff\1\1\7\uffff\2\1\5\uffff\2\1\1\3\4\uffff\1\2\1\1", | ||
13414 | "", | ||
13415 | "\1\10\17\uffff\1\1\2\uffff\1\6\1\uffff\2\1\1\uffff\2\1\1\uffff\1\1\1\uffff\2\1\1\7\5\1\2\uffff\1\1\1\uffff\1\1\3\uffff\2\1\6\uffff\2\1\1\uffff\1\11", | ||
13416 | "\1\10\17\uffff\1\1\2\uffff\1\6\1\uffff\2\1\1\uffff\2\1\1\uffff\1\1\1\uffff\2\1\1\7\5\1\2\uffff\1\1\1\uffff\1\1\3\uffff\2\1\6\uffff\2\1\1\uffff\1\11", | ||
13417 | "\1\10\17\uffff\1\1\2\uffff\1\6\1\uffff\2\1\1\uffff\2\1\1\uffff\1\1\1\uffff\2\1\1\7\5\1\2\uffff\1\1\1\uffff\1\1\3\uffff\2\1\6\uffff\2\1\1\uffff\1\11", | ||
13418 | "", | ||
13419 | "\1\14\62\uffff\1\13\4\uffff\1\12", | ||
13420 | "\1\1\2\uffff\1\1\2\uffff\4\1\5\uffff\1\1\1\uffff\1\1\15\uffff\2\1\1\15\1\uffff\1\1\1\15\1\1\7\uffff\2\1\5\uffff\3\1\4\uffff\2\1", | ||
13421 | "\1\15\30\uffff\1\11", | ||
13422 | "", | ||
13423 | "\1\10\17\uffff\1\1\2\uffff\1\6\1\uffff\2\1\1\uffff\2\1\1\uffff\1\1\1\uffff\2\1\1\7\5\1\2\uffff\1\1\1\uffff\1\1\3\uffff\2\1\6\uffff\2\1\1\uffff\1\11", | ||
13424 | "\1\10\17\uffff\1\1\2\uffff\1\6\1\uffff\2\1\1\uffff\2\1\1\uffff\1\1\1\uffff\2\1\1\7\5\1\2\uffff\1\1\1\uffff\1\1\3\uffff\2\1\6\uffff\2\1\1\uffff\1\11", | ||
13425 | "\1\10\17\uffff\1\1\2\uffff\1\6\1\uffff\2\1\1\uffff\2\1\1\uffff\1\1\1\uffff\2\1\1\7\5\1\2\uffff\1\1\1\uffff\1\1\3\uffff\2\1\6\uffff\2\1\1\uffff\1\11", | ||
13426 | "" | ||
13427 | }; | ||
13428 | |||
13429 | static final short[] dfa_27 = DFA.unpackEncodedString(dfa_27s); | ||
13430 | static final short[] dfa_28 = DFA.unpackEncodedString(dfa_28s); | ||
13431 | static final char[] dfa_29 = DFA.unpackEncodedStringToUnsignedChars(dfa_29s); | ||
13432 | static final char[] dfa_30 = DFA.unpackEncodedStringToUnsignedChars(dfa_30s); | ||
13433 | static final short[] dfa_31 = DFA.unpackEncodedString(dfa_31s); | ||
13434 | static final short[] dfa_32 = DFA.unpackEncodedString(dfa_32s); | ||
13435 | static final short[][] dfa_33 = unpackEncodedStringArray(dfa_33s); | ||
13436 | |||
13437 | class DFA34 extends DFA { | ||
13438 | |||
13439 | public DFA34(BaseRecognizer recognizer) { | ||
13440 | this.recognizer = recognizer; | ||
13441 | this.decisionNumber = 34; | ||
13442 | this.eot = dfa_27; | ||
13443 | this.eof = dfa_28; | ||
13444 | this.min = dfa_29; | ||
13445 | this.max = dfa_30; | ||
13446 | this.accept = dfa_31; | ||
13447 | this.special = dfa_32; | ||
13448 | this.transition = dfa_33; | ||
13449 | } | ||
13450 | public String getDescription() { | ||
13451 | return "2841:2: (this_ExpressionArgument_0= ruleExpressionArgument | this_StarArgument_1= ruleStarArgument | this_TypedVariableArgument_2= ruleTypedVariableArgument | this_TypedStarArgument_3= ruleTypedStarArgument )"; | ||
13452 | } | ||
13453 | } | ||
13454 | static final String dfa_34s = "\25\uffff"; | ||
13455 | static final String dfa_35s = "\1\31\1\22\1\47\3\45\1\22\1\uffff\1\22\2\uffff\6\45\1\22\3\45"; | ||
13456 | static final String dfa_36s = "\1\31\1\113\4\52\1\112\1\uffff\1\112\2\uffff\3\111\3\52\1\112\3\111"; | ||
13457 | static final String dfa_37s = "\7\uffff\1\2\1\uffff\1\1\1\3\12\uffff"; | ||
13458 | static final String dfa_38s = "\25\uffff}>"; | ||
13459 | static final String[] dfa_39s = { | ||
13460 | "\1\1", | ||
13461 | "\1\5\62\uffff\1\4\4\uffff\1\3\1\2", | ||
13462 | "\1\6\2\uffff\1\7", | ||
13463 | "\1\10\1\uffff\1\7\1\11\1\uffff\1\12", | ||
13464 | "\1\10\1\uffff\1\7\1\11\1\uffff\1\12", | ||
13465 | "\1\10\1\uffff\1\7\1\11\1\uffff\1\12", | ||
13466 | "\1\15\62\uffff\1\14\4\uffff\1\13", | ||
13467 | "", | ||
13468 | "\1\20\62\uffff\1\17\4\uffff\1\16", | ||
13469 | "", | ||
13470 | "", | ||
13471 | "\1\21\1\uffff\1\7\41\uffff\1\12", | ||
13472 | "\1\21\1\uffff\1\7\41\uffff\1\12", | ||
13473 | "\1\21\1\uffff\1\7\41\uffff\1\12", | ||
13474 | "\1\10\1\uffff\1\7\1\11\1\uffff\1\12", | ||
13475 | "\1\10\1\uffff\1\7\1\11\1\uffff\1\12", | ||
13476 | "\1\10\1\uffff\1\7\1\11\1\uffff\1\12", | ||
13477 | "\1\24\62\uffff\1\23\4\uffff\1\22", | ||
13478 | "\1\21\1\uffff\1\7\41\uffff\1\12", | ||
13479 | "\1\21\1\uffff\1\7\41\uffff\1\12", | ||
13480 | "\1\21\1\uffff\1\7\41\uffff\1\12" | ||
13481 | }; | ||
13482 | |||
13483 | static final short[] dfa_34 = DFA.unpackEncodedString(dfa_34s); | ||
13484 | static final char[] dfa_35 = DFA.unpackEncodedStringToUnsignedChars(dfa_35s); | ||
13485 | static final char[] dfa_36 = DFA.unpackEncodedStringToUnsignedChars(dfa_36s); | ||
13486 | static final short[] dfa_37 = DFA.unpackEncodedString(dfa_37s); | ||
13487 | static final short[] dfa_38 = DFA.unpackEncodedString(dfa_38s); | ||
13488 | static final short[][] dfa_39 = unpackEncodedStringArray(dfa_39s); | ||
13489 | |||
13490 | class DFA53 extends DFA { | ||
13491 | |||
13492 | public DFA53(BaseRecognizer recognizer) { | ||
13493 | this.recognizer = recognizer; | ||
13494 | this.decisionNumber = 53; | ||
13495 | this.eot = dfa_34; | ||
13496 | this.eof = dfa_34; | ||
13497 | this.min = dfa_35; | ||
13498 | this.max = dfa_36; | ||
13499 | this.accept = dfa_37; | ||
13500 | this.special = dfa_38; | ||
13501 | this.transition = dfa_39; | ||
13502 | } | ||
13503 | public String getDescription() { | ||
13504 | return "4199:2: (this_ExactScope_0= ruleExactScope | this_BoundedScope_1= ruleBoundedScope | this_LowerBoundedScope_2= ruleLowerBoundedScope )"; | ||
13505 | } | ||
13506 | } | ||
13507 | |||
13508 | |||
13509 | public static final BitSet FOLLOW_1 = new BitSet(new long[]{0x0000000000000000L}); | ||
13510 | public static final BitSet FOLLOW_2 = new BitSet(new long[]{0x0000000000000002L}); | ||
13511 | public static final BitSet FOLLOW_3 = new BitSet(new long[]{0x0000000000040000L,0x0000000000000420L}); | ||
13512 | public static final BitSet FOLLOW_4 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000200L}); | ||
13513 | public static final BitSet FOLLOW_5 = new BitSet(new long[]{0x3014D0035BF79672L,0x0000000000000C38L}); | ||
13514 | public static final BitSet FOLLOW_6 = new BitSet(new long[]{0x3014D0035BF59672L,0x0000000000000C38L}); | ||
13515 | public static final BitSet FOLLOW_7 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000010L}); | ||
13516 | public static final BitSet FOLLOW_8 = new BitSet(new long[]{0x0000080000000000L}); | ||
13517 | public static final BitSet FOLLOW_9 = new BitSet(new long[]{0x0080005000000000L,0x0000000000000200L}); | ||
13518 | public static final BitSet FOLLOW_10 = new BitSet(new long[]{0x3014D00341E48000L,0x0000000000000C38L}); | ||
13519 | public static final BitSet FOLLOW_11 = new BitSet(new long[]{0x0000000000840000L,0x0000000000000428L}); | ||
13520 | public static final BitSet FOLLOW_12 = new BitSet(new long[]{0x0000000000040000L,0x0000000000000428L}); | ||
13521 | public static final BitSet FOLLOW_13 = new BitSet(new long[]{0x0000000000040020L,0x0000000000000428L}); | ||
13522 | public static final BitSet FOLLOW_14 = new BitSet(new long[]{0x0000001000000000L}); | ||
13523 | public static final BitSet FOLLOW_15 = new BitSet(new long[]{0x0000800000000000L}); | ||
13524 | public static final BitSet FOLLOW_16 = new BitSet(new long[]{0x0080000000000000L,0x0000000000000200L}); | ||
13525 | public static final BitSet FOLLOW_17 = new BitSet(new long[]{0x0000004000000000L}); | ||
13526 | public static final BitSet FOLLOW_18 = new BitSet(new long[]{0x0000000000040002L}); | ||
13527 | public static final BitSet FOLLOW_19 = new BitSet(new long[]{0x0000000000840020L,0x0000000000000420L}); | ||
13528 | public static final BitSet FOLLOW_20 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000001L}); | ||
13529 | public static final BitSet FOLLOW_21 = new BitSet(new long[]{0x0000000080000000L}); | ||
13530 | public static final BitSet FOLLOW_22 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000004L}); | ||
13531 | public static final BitSet FOLLOW_23 = new BitSet(new long[]{0x0000000000000100L}); | ||
13532 | public static final BitSet FOLLOW_24 = new BitSet(new long[]{0x0000020000000002L}); | ||
13533 | public static final BitSet FOLLOW_25 = new BitSet(new long[]{0x0000000020000000L}); | ||
13534 | public static final BitSet FOLLOW_26 = new BitSet(new long[]{0x0000000004000000L}); | ||
13535 | public static final BitSet FOLLOW_27 = new BitSet(new long[]{0x0008200000000000L}); | ||
13536 | public static final BitSet FOLLOW_28 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000400L}); | ||
13537 | public static final BitSet FOLLOW_29 = new BitSet(new long[]{0x0400000000000000L}); | ||
13538 | public static final BitSet FOLLOW_30 = new BitSet(new long[]{0x0100000800000002L}); | ||
13539 | public static final BitSet FOLLOW_31 = new BitSet(new long[]{0x0100000000000002L}); | ||
13540 | public static final BitSet FOLLOW_32 = new BitSet(new long[]{0x0000000800000000L}); | ||
13541 | public static final BitSet FOLLOW_33 = new BitSet(new long[]{0x0008000000000002L}); | ||
13542 | public static final BitSet FOLLOW_34 = new BitSet(new long[]{0x0A00258400000002L}); | ||
13543 | public static final BitSet FOLLOW_35 = new BitSet(new long[]{0x0014000000000002L}); | ||
13544 | public static final BitSet FOLLOW_36 = new BitSet(new long[]{0x0042000000000002L}); | ||
13545 | public static final BitSet FOLLOW_37 = new BitSet(new long[]{0x8000000000000002L}); | ||
13546 | public static final BitSet FOLLOW_38 = new BitSet(new long[]{0x0000080000000002L}); | ||
13547 | public static final BitSet FOLLOW_39 = new BitSet(new long[]{0x2000800141E48000L,0x0000000000000C38L}); | ||
13548 | public static final BitSet FOLLOW_40 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000002L}); | ||
13549 | public static final BitSet FOLLOW_41 = new BitSet(new long[]{0x0001000000000000L}); | ||
13550 | public static final BitSet FOLLOW_42 = new BitSet(new long[]{0x3017D00341E48000L,0x0000000000000C38L}); | ||
13551 | public static final BitSet FOLLOW_43 = new BitSet(new long[]{0x0009000000000000L}); | ||
13552 | public static final BitSet FOLLOW_44 = new BitSet(new long[]{0x3016D00341E48000L,0x0000000000000C38L}); | ||
13553 | public static final BitSet FOLLOW_45 = new BitSet(new long[]{0x0002000000000000L}); | ||
13554 | public static final BitSet FOLLOW_46 = new BitSet(new long[]{0x0020000000000002L}); | ||
13555 | public static final BitSet FOLLOW_47 = new BitSet(new long[]{0x0000000000000002L,0x0000000000000180L}); | ||
13556 | public static final BitSet FOLLOW_48 = new BitSet(new long[]{0x0008000000000000L}); | ||
13557 | public static final BitSet FOLLOW_49 = new BitSet(new long[]{0x4000000000000000L}); | ||
13558 | public static final BitSet FOLLOW_50 = new BitSet(new long[]{0x0000000010100040L}); | ||
13559 | public static final BitSet FOLLOW_51 = new BitSet(new long[]{0x0000000000002000L,0x0000000000000201L}); | ||
13560 | public static final BitSet FOLLOW_52 = new BitSet(new long[]{0x0008000000000000L,0x0000000000000201L}); | ||
13561 | public static final BitSet FOLLOW_53 = new BitSet(new long[]{0x00000000000C0080L,0x0000000000000424L}); | ||
13562 | public static final BitSet FOLLOW_54 = new BitSet(new long[]{0x2000000000000000L,0x0000000000000400L}); | ||
13563 | public static final BitSet FOLLOW_55 = new BitSet(new long[]{0x0100000000000802L}); | ||
13564 | public static final BitSet FOLLOW_56 = new BitSet(new long[]{0x0002000000000000L,0x0000000000000800L}); | ||
13565 | public static final BitSet FOLLOW_57 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000800L}); | ||
13566 | public static final BitSet FOLLOW_58 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000201L}); | ||
13567 | public static final BitSet FOLLOW_59 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000404L}); | ||
13568 | public static final BitSet FOLLOW_60 = new BitSet(new long[]{0x0008000000000000L,0x0000000000000404L}); | ||
13569 | public static final BitSet FOLLOW_61 = new BitSet(new long[]{0x0000010000000000L}); | ||
13570 | public static final BitSet FOLLOW_62 = new BitSet(new long[]{0x0000000000040000L,0x0000000000000C20L}); | ||
13571 | public static final BitSet FOLLOW_63 = new BitSet(new long[]{0x0000008000000000L}); | ||
13572 | public static final BitSet FOLLOW_64 = new BitSet(new long[]{0x0000040000000000L}); | ||
13573 | public static final BitSet FOLLOW_65 = new BitSet(new long[]{0x0000040000000000L,0x0000000000000200L}); | ||
13574 | public static final BitSet FOLLOW_66 = new BitSet(new long[]{0x0020000000000000L}); | ||
13575 | public static final BitSet FOLLOW_67 = new BitSet(new long[]{0x0000002000000002L}); | ||
13576 | |||
13577 | } | ||
diff --git a/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/parser/antlr/internal/InternalSolverLanguageParser.tokens b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/parser/antlr/internal/InternalSolverLanguageParser.tokens new file mode 100644 index 00000000..591c0e60 --- /dev/null +++ b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/parser/antlr/internal/InternalSolverLanguageParser.tokens | |||
@@ -0,0 +1,75 @@ | |||
1 | '!'=46 | ||
2 | '!='=34 | ||
3 | '('=47 | ||
4 | ')'=48 | ||
5 | '*'=49 | ||
6 | '+'=50 | ||
7 | ','=51 | ||
8 | '-'=52 | ||
9 | '->'=35 | ||
10 | '.'=53 | ||
11 | '...'=31 | ||
12 | '/'=54 | ||
13 | ':'=55 | ||
14 | ':-'=36 | ||
15 | '::'=37 | ||
16 | ':='=38 | ||
17 | ';'=56 | ||
18 | '<'=57 | ||
19 | '<='=39 | ||
20 | '='=58 | ||
21 | '=='=40 | ||
22 | '=>'=41 | ||
23 | '>'=59 | ||
24 | '>='=42 | ||
25 | '?'=60 | ||
26 | '['=61 | ||
27 | ']'=62 | ||
28 | '^'=63 | ||
29 | 'abstract'=6 | ||
30 | 'as'=43 | ||
31 | 'class'=20 | ||
32 | 'containment'=4 | ||
33 | 'contains'=7 | ||
34 | 'count'=21 | ||
35 | 'datatype'=8 | ||
36 | 'default'=12 | ||
37 | 'else'=26 | ||
38 | 'empty'=22 | ||
39 | 'enum'=27 | ||
40 | 'error'=23 | ||
41 | 'extends'=13 | ||
42 | 'extern'=16 | ||
43 | 'false'=24 | ||
44 | 'functional'=5 | ||
45 | 'if'=44 | ||
46 | 'import'=17 | ||
47 | 'in'=45 | ||
48 | 'inf'=32 | ||
49 | 'let'=33 | ||
50 | 'maximize'=9 | ||
51 | 'minimize'=10 | ||
52 | 'object'=18 | ||
53 | 'opposite'=11 | ||
54 | 'problem'=14 | ||
55 | 'refers'=19 | ||
56 | 'root'=28 | ||
57 | 'scope'=25 | ||
58 | 'then'=29 | ||
59 | 'true'=30 | ||
60 | 'unknown'=15 | ||
61 | '{'=64 | ||
62 | '|'=65 | ||
63 | '}'=66 | ||
64 | '~'=67 | ||
65 | RULE_ANY_OTHER=78 | ||
66 | RULE_FULL_STOP=73 | ||
67 | RULE_ID=74 | ||
68 | RULE_INT=75 | ||
69 | RULE_ML_COMMENT=76 | ||
70 | RULE_QUOTED_ID=69 | ||
71 | RULE_REFLEXIVE_TRANSITIVE_CLOSURE=72 | ||
72 | RULE_SL_COMMENT=70 | ||
73 | RULE_STRING=68 | ||
74 | RULE_TRANSITIVE_CLOSURE=71 | ||
75 | RULE_WS=77 | ||
diff --git a/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/parser/antlr/lexer/InternalSolverLanguageLexer.g b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/parser/antlr/lexer/InternalSolverLanguageLexer.g new file mode 100644 index 00000000..074932ca --- /dev/null +++ b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/parser/antlr/lexer/InternalSolverLanguageLexer.g | |||
@@ -0,0 +1,162 @@ | |||
1 | /* | ||
2 | * generated by Xtext 2.21.0 | ||
3 | */ | ||
4 | lexer grammar InternalSolverLanguageLexer; | ||
5 | |||
6 | @header { | ||
7 | package org.eclipse.viatra.solver.language.parser.antlr.lexer; | ||
8 | |||
9 | // Hack: Use our own Lexer superclass by means of import. | ||
10 | // Currently there is no other way to specify the superclass for the lexer. | ||
11 | import org.eclipse.xtext.parser.antlr.Lexer; | ||
12 | } | ||
13 | |||
14 | Containment : 'containment'; | ||
15 | |||
16 | Functional : 'functional'; | ||
17 | |||
18 | Abstract : 'abstract'; | ||
19 | |||
20 | Contains : 'contains'; | ||
21 | |||
22 | Datatype : 'datatype'; | ||
23 | |||
24 | Maximize : 'maximize'; | ||
25 | |||
26 | Minimize : 'minimize'; | ||
27 | |||
28 | Opposite : 'opposite'; | ||
29 | |||
30 | Default : 'default'; | ||
31 | |||
32 | Extends : 'extends'; | ||
33 | |||
34 | Problem : 'problem'; | ||
35 | |||
36 | Unknown : 'unknown'; | ||
37 | |||
38 | Extern : 'extern'; | ||
39 | |||
40 | Import : 'import'; | ||
41 | |||
42 | Object : 'object'; | ||
43 | |||
44 | Refers : 'refers'; | ||
45 | |||
46 | Class : 'class'; | ||
47 | |||
48 | Count : 'count'; | ||
49 | |||
50 | Empty : 'empty'; | ||
51 | |||
52 | Error : 'error'; | ||
53 | |||
54 | False : 'false'; | ||
55 | |||
56 | Scope : 'scope'; | ||
57 | |||
58 | Else : 'else'; | ||
59 | |||
60 | Enum : 'enum'; | ||
61 | |||
62 | Root : 'root'; | ||
63 | |||
64 | Then : 'then'; | ||
65 | |||
66 | True : 'true'; | ||
67 | |||
68 | FullStopFullStopFullStop : '...'; | ||
69 | |||
70 | Inf : 'inf'; | ||
71 | |||
72 | Let : 'let'; | ||
73 | |||
74 | ExclamationMarkEqualsSign : '!='; | ||
75 | |||
76 | HyphenMinusGreaterThanSign : '->'; | ||
77 | |||
78 | ColonHyphenMinus : ':-'; | ||
79 | |||
80 | ColonColon : '::'; | ||
81 | |||
82 | ColonEqualsSign : ':='; | ||
83 | |||
84 | LessThanSignEqualsSign : '<='; | ||
85 | |||
86 | EqualsSignEqualsSign : '=='; | ||
87 | |||
88 | EqualsSignGreaterThanSign : '=>'; | ||
89 | |||
90 | GreaterThanSignEqualsSign : '>='; | ||
91 | |||
92 | As : 'as'; | ||
93 | |||
94 | If : 'if'; | ||
95 | |||
96 | In : 'in'; | ||
97 | |||
98 | ExclamationMark : '!'; | ||
99 | |||
100 | LeftParenthesis : '('; | ||
101 | |||
102 | RightParenthesis : ')'; | ||
103 | |||
104 | Asterisk : '*'; | ||
105 | |||
106 | PlusSign : '+'; | ||
107 | |||
108 | Comma : ','; | ||
109 | |||
110 | HyphenMinus : '-'; | ||
111 | |||
112 | FullStop : '.'; | ||
113 | |||
114 | Solidus : '/'; | ||
115 | |||
116 | Colon : ':'; | ||
117 | |||
118 | Semicolon : ';'; | ||
119 | |||
120 | LessThanSign : '<'; | ||
121 | |||
122 | EqualsSign : '='; | ||
123 | |||
124 | GreaterThanSign : '>'; | ||
125 | |||
126 | QuestionMark : '?'; | ||
127 | |||
128 | LeftSquareBracket : '['; | ||
129 | |||
130 | RightSquareBracket : ']'; | ||
131 | |||
132 | CircumflexAccent : '^'; | ||
133 | |||
134 | LeftCurlyBracket : '{'; | ||
135 | |||
136 | VerticalLine : '|'; | ||
137 | |||
138 | RightCurlyBracket : '}'; | ||
139 | |||
140 | Tilde : '~'; | ||
141 | |||
142 | RULE_STRING : '"' ('\\' .|~(('\\'|'"')))* '"'; | ||
143 | |||
144 | RULE_QUOTED_ID : '\'' ('\\' .|~(('\\'|'\'')))* '\''; | ||
145 | |||
146 | RULE_SL_COMMENT : ('%'|'//') ~(('\n'|'\r'))* ('\r'? '\n')?; | ||
147 | |||
148 | fragment RULE_TRANSITIVE_CLOSURE : ; | ||
149 | |||
150 | fragment RULE_REFLEXIVE_TRANSITIVE_CLOSURE : ; | ||
151 | |||
152 | fragment RULE_FULL_STOP : ; | ||
153 | |||
154 | RULE_ID : '^'? ('a'..'z'|'A'..'Z'|'_') ('a'..'z'|'A'..'Z'|'_'|'0'..'9')*; | ||
155 | |||
156 | RULE_INT : ('0'..'9')+; | ||
157 | |||
158 | RULE_ML_COMMENT : '/*' ( options {greedy=false;} : . )*'*/'; | ||
159 | |||
160 | RULE_WS : (' '|'\t'|'\r'|'\n')+; | ||
161 | |||
162 | RULE_ANY_OTHER : .; | ||
diff --git a/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/parser/antlr/lexer/InternalSolverLanguageLexer.java b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/parser/antlr/lexer/InternalSolverLanguageLexer.java new file mode 100644 index 00000000..4281bac0 --- /dev/null +++ b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/parser/antlr/lexer/InternalSolverLanguageLexer.java | |||
@@ -0,0 +1,2930 @@ | |||
1 | package org.eclipse.viatra.solver.language.parser.antlr.lexer; | ||
2 | |||
3 | // Hack: Use our own Lexer superclass by means of import. | ||
4 | // Currently there is no other way to specify the superclass for the lexer. | ||
5 | import org.eclipse.xtext.parser.antlr.Lexer; | ||
6 | |||
7 | |||
8 | import org.antlr.runtime.*; | ||
9 | import java.util.Stack; | ||
10 | import java.util.List; | ||
11 | import java.util.ArrayList; | ||
12 | |||
13 | @SuppressWarnings("all") | ||
14 | public class InternalSolverLanguageLexer extends Lexer { | ||
15 | public static final int Enum=27; | ||
16 | public static final int Import=17; | ||
17 | public static final int EqualsSignGreaterThanSign=41; | ||
18 | public static final int True=30; | ||
19 | public static final int Count=21; | ||
20 | public static final int False=24; | ||
21 | public static final int FullStopFullStopFullStop=31; | ||
22 | public static final int LessThanSign=57; | ||
23 | public static final int Datatype=8; | ||
24 | public static final int LeftParenthesis=47; | ||
25 | public static final int Unknown=15; | ||
26 | public static final int RULE_REFLEXIVE_TRANSITIVE_CLOSURE=72; | ||
27 | public static final int Then=29; | ||
28 | public static final int Extends=13; | ||
29 | public static final int RightSquareBracket=62; | ||
30 | public static final int ExclamationMark=46; | ||
31 | public static final int Opposite=11; | ||
32 | public static final int GreaterThanSign=59; | ||
33 | public static final int Root=28; | ||
34 | public static final int RULE_ID=74; | ||
35 | public static final int RULE_QUOTED_ID=69; | ||
36 | public static final int RightParenthesis=48; | ||
37 | public static final int ColonEqualsSign=38; | ||
38 | public static final int GreaterThanSignEqualsSign=42; | ||
39 | public static final int Functional=5; | ||
40 | public static final int ColonColon=37; | ||
41 | public static final int EqualsSignEqualsSign=40; | ||
42 | public static final int VerticalLine=65; | ||
43 | public static final int PlusSign=50; | ||
44 | public static final int RULE_INT=75; | ||
45 | public static final int Contains=7; | ||
46 | public static final int RULE_ML_COMMENT=76; | ||
47 | public static final int RULE_TRANSITIVE_CLOSURE=71; | ||
48 | public static final int Problem=14; | ||
49 | public static final int Object=18; | ||
50 | public static final int Class=20; | ||
51 | public static final int LeftSquareBracket=61; | ||
52 | public static final int RULE_FULL_STOP=73; | ||
53 | public static final int If=44; | ||
54 | public static final int Refers=19; | ||
55 | public static final int Inf=32; | ||
56 | public static final int In=45; | ||
57 | public static final int RULE_STRING=68; | ||
58 | public static final int Extern=16; | ||
59 | public static final int RULE_SL_COMMENT=70; | ||
60 | public static final int Comma=51; | ||
61 | public static final int EqualsSign=58; | ||
62 | public static final int Empty=22; | ||
63 | public static final int As=43; | ||
64 | public static final int HyphenMinus=52; | ||
65 | public static final int Maximize=9; | ||
66 | public static final int LessThanSignEqualsSign=39; | ||
67 | public static final int Solidus=54; | ||
68 | public static final int Colon=55; | ||
69 | public static final int RightCurlyBracket=66; | ||
70 | public static final int EOF=-1; | ||
71 | public static final int Asterisk=49; | ||
72 | public static final int Containment=4; | ||
73 | public static final int FullStop=53; | ||
74 | public static final int RULE_WS=77; | ||
75 | public static final int Abstract=6; | ||
76 | public static final int Minimize=10; | ||
77 | public static final int LeftCurlyBracket=64; | ||
78 | public static final int Error=23; | ||
79 | public static final int Tilde=67; | ||
80 | public static final int RULE_ANY_OTHER=78; | ||
81 | public static final int Default=12; | ||
82 | public static final int ColonHyphenMinus=36; | ||
83 | public static final int CircumflexAccent=63; | ||
84 | public static final int Semicolon=56; | ||
85 | public static final int Scope=25; | ||
86 | public static final int QuestionMark=60; | ||
87 | public static final int Else=26; | ||
88 | public static final int Let=33; | ||
89 | public static final int ExclamationMarkEqualsSign=34; | ||
90 | public static final int HyphenMinusGreaterThanSign=35; | ||
91 | |||
92 | // delegates | ||
93 | // delegators | ||
94 | |||
95 | public InternalSolverLanguageLexer() {;} | ||
96 | public InternalSolverLanguageLexer(CharStream input) { | ||
97 | this(input, new RecognizerSharedState()); | ||
98 | } | ||
99 | public InternalSolverLanguageLexer(CharStream input, RecognizerSharedState state) { | ||
100 | super(input,state); | ||
101 | |||
102 | } | ||
103 | public String getGrammarFileName() { return "InternalSolverLanguageLexer.g"; } | ||
104 | |||
105 | // $ANTLR start "Containment" | ||
106 | public final void mContainment() throws RecognitionException { | ||
107 | try { | ||
108 | int _type = Containment; | ||
109 | int _channel = DEFAULT_TOKEN_CHANNEL; | ||
110 | // InternalSolverLanguageLexer.g:14:13: ( 'containment' ) | ||
111 | // InternalSolverLanguageLexer.g:14:15: 'containment' | ||
112 | { | ||
113 | match("containment"); | ||
114 | |||
115 | |||
116 | } | ||
117 | |||
118 | state.type = _type; | ||
119 | state.channel = _channel; | ||
120 | } | ||
121 | finally { | ||
122 | } | ||
123 | } | ||
124 | // $ANTLR end "Containment" | ||
125 | |||
126 | // $ANTLR start "Functional" | ||
127 | public final void mFunctional() throws RecognitionException { | ||
128 | try { | ||
129 | int _type = Functional; | ||
130 | int _channel = DEFAULT_TOKEN_CHANNEL; | ||
131 | // InternalSolverLanguageLexer.g:16:12: ( 'functional' ) | ||
132 | // InternalSolverLanguageLexer.g:16:14: 'functional' | ||
133 | { | ||
134 | match("functional"); | ||
135 | |||
136 | |||
137 | } | ||
138 | |||
139 | state.type = _type; | ||
140 | state.channel = _channel; | ||
141 | } | ||
142 | finally { | ||
143 | } | ||
144 | } | ||
145 | // $ANTLR end "Functional" | ||
146 | |||
147 | // $ANTLR start "Abstract" | ||
148 | public final void mAbstract() throws RecognitionException { | ||
149 | try { | ||
150 | int _type = Abstract; | ||
151 | int _channel = DEFAULT_TOKEN_CHANNEL; | ||
152 | // InternalSolverLanguageLexer.g:18:10: ( 'abstract' ) | ||
153 | // InternalSolverLanguageLexer.g:18:12: 'abstract' | ||
154 | { | ||
155 | match("abstract"); | ||
156 | |||
157 | |||
158 | } | ||
159 | |||
160 | state.type = _type; | ||
161 | state.channel = _channel; | ||
162 | } | ||
163 | finally { | ||
164 | } | ||
165 | } | ||
166 | // $ANTLR end "Abstract" | ||
167 | |||
168 | // $ANTLR start "Contains" | ||
169 | public final void mContains() throws RecognitionException { | ||
170 | try { | ||
171 | int _type = Contains; | ||
172 | int _channel = DEFAULT_TOKEN_CHANNEL; | ||
173 | // InternalSolverLanguageLexer.g:20:10: ( 'contains' ) | ||
174 | // InternalSolverLanguageLexer.g:20:12: 'contains' | ||
175 | { | ||
176 | match("contains"); | ||
177 | |||
178 | |||
179 | } | ||
180 | |||
181 | state.type = _type; | ||
182 | state.channel = _channel; | ||
183 | } | ||
184 | finally { | ||
185 | } | ||
186 | } | ||
187 | // $ANTLR end "Contains" | ||
188 | |||
189 | // $ANTLR start "Datatype" | ||
190 | public final void mDatatype() throws RecognitionException { | ||
191 | try { | ||
192 | int _type = Datatype; | ||
193 | int _channel = DEFAULT_TOKEN_CHANNEL; | ||
194 | // InternalSolverLanguageLexer.g:22:10: ( 'datatype' ) | ||
195 | // InternalSolverLanguageLexer.g:22:12: 'datatype' | ||
196 | { | ||
197 | match("datatype"); | ||
198 | |||
199 | |||
200 | } | ||
201 | |||
202 | state.type = _type; | ||
203 | state.channel = _channel; | ||
204 | } | ||
205 | finally { | ||
206 | } | ||
207 | } | ||
208 | // $ANTLR end "Datatype" | ||
209 | |||
210 | // $ANTLR start "Maximize" | ||
211 | public final void mMaximize() throws RecognitionException { | ||
212 | try { | ||
213 | int _type = Maximize; | ||
214 | int _channel = DEFAULT_TOKEN_CHANNEL; | ||
215 | // InternalSolverLanguageLexer.g:24:10: ( 'maximize' ) | ||
216 | // InternalSolverLanguageLexer.g:24:12: 'maximize' | ||
217 | { | ||
218 | match("maximize"); | ||
219 | |||
220 | |||
221 | } | ||
222 | |||
223 | state.type = _type; | ||
224 | state.channel = _channel; | ||
225 | } | ||
226 | finally { | ||
227 | } | ||
228 | } | ||
229 | // $ANTLR end "Maximize" | ||
230 | |||
231 | // $ANTLR start "Minimize" | ||
232 | public final void mMinimize() throws RecognitionException { | ||
233 | try { | ||
234 | int _type = Minimize; | ||
235 | int _channel = DEFAULT_TOKEN_CHANNEL; | ||
236 | // InternalSolverLanguageLexer.g:26:10: ( 'minimize' ) | ||
237 | // InternalSolverLanguageLexer.g:26:12: 'minimize' | ||
238 | { | ||
239 | match("minimize"); | ||
240 | |||
241 | |||
242 | } | ||
243 | |||
244 | state.type = _type; | ||
245 | state.channel = _channel; | ||
246 | } | ||
247 | finally { | ||
248 | } | ||
249 | } | ||
250 | // $ANTLR end "Minimize" | ||
251 | |||
252 | // $ANTLR start "Opposite" | ||
253 | public final void mOpposite() throws RecognitionException { | ||
254 | try { | ||
255 | int _type = Opposite; | ||
256 | int _channel = DEFAULT_TOKEN_CHANNEL; | ||
257 | // InternalSolverLanguageLexer.g:28:10: ( 'opposite' ) | ||
258 | // InternalSolverLanguageLexer.g:28:12: 'opposite' | ||
259 | { | ||
260 | match("opposite"); | ||
261 | |||
262 | |||
263 | } | ||
264 | |||
265 | state.type = _type; | ||
266 | state.channel = _channel; | ||
267 | } | ||
268 | finally { | ||
269 | } | ||
270 | } | ||
271 | // $ANTLR end "Opposite" | ||
272 | |||
273 | // $ANTLR start "Default" | ||
274 | public final void mDefault() throws RecognitionException { | ||
275 | try { | ||
276 | int _type = Default; | ||
277 | int _channel = DEFAULT_TOKEN_CHANNEL; | ||
278 | // InternalSolverLanguageLexer.g:30:9: ( 'default' ) | ||
279 | // InternalSolverLanguageLexer.g:30:11: 'default' | ||
280 | { | ||
281 | match("default"); | ||
282 | |||
283 | |||
284 | } | ||
285 | |||
286 | state.type = _type; | ||
287 | state.channel = _channel; | ||
288 | } | ||
289 | finally { | ||
290 | } | ||
291 | } | ||
292 | // $ANTLR end "Default" | ||
293 | |||
294 | // $ANTLR start "Extends" | ||
295 | public final void mExtends() throws RecognitionException { | ||
296 | try { | ||
297 | int _type = Extends; | ||
298 | int _channel = DEFAULT_TOKEN_CHANNEL; | ||
299 | // InternalSolverLanguageLexer.g:32:9: ( 'extends' ) | ||
300 | // InternalSolverLanguageLexer.g:32:11: 'extends' | ||
301 | { | ||
302 | match("extends"); | ||
303 | |||
304 | |||
305 | } | ||
306 | |||
307 | state.type = _type; | ||
308 | state.channel = _channel; | ||
309 | } | ||
310 | finally { | ||
311 | } | ||
312 | } | ||
313 | // $ANTLR end "Extends" | ||
314 | |||
315 | // $ANTLR start "Problem" | ||
316 | public final void mProblem() throws RecognitionException { | ||
317 | try { | ||
318 | int _type = Problem; | ||
319 | int _channel = DEFAULT_TOKEN_CHANNEL; | ||
320 | // InternalSolverLanguageLexer.g:34:9: ( 'problem' ) | ||
321 | // InternalSolverLanguageLexer.g:34:11: 'problem' | ||
322 | { | ||
323 | match("problem"); | ||
324 | |||
325 | |||
326 | } | ||
327 | |||
328 | state.type = _type; | ||
329 | state.channel = _channel; | ||
330 | } | ||
331 | finally { | ||
332 | } | ||
333 | } | ||
334 | // $ANTLR end "Problem" | ||
335 | |||
336 | // $ANTLR start "Unknown" | ||
337 | public final void mUnknown() throws RecognitionException { | ||
338 | try { | ||
339 | int _type = Unknown; | ||
340 | int _channel = DEFAULT_TOKEN_CHANNEL; | ||
341 | // InternalSolverLanguageLexer.g:36:9: ( 'unknown' ) | ||
342 | // InternalSolverLanguageLexer.g:36:11: 'unknown' | ||
343 | { | ||
344 | match("unknown"); | ||
345 | |||
346 | |||
347 | } | ||
348 | |||
349 | state.type = _type; | ||
350 | state.channel = _channel; | ||
351 | } | ||
352 | finally { | ||
353 | } | ||
354 | } | ||
355 | // $ANTLR end "Unknown" | ||
356 | |||
357 | // $ANTLR start "Extern" | ||
358 | public final void mExtern() throws RecognitionException { | ||
359 | try { | ||
360 | int _type = Extern; | ||
361 | int _channel = DEFAULT_TOKEN_CHANNEL; | ||
362 | // InternalSolverLanguageLexer.g:38:8: ( 'extern' ) | ||
363 | // InternalSolverLanguageLexer.g:38:10: 'extern' | ||
364 | { | ||
365 | match("extern"); | ||
366 | |||
367 | |||
368 | } | ||
369 | |||
370 | state.type = _type; | ||
371 | state.channel = _channel; | ||
372 | } | ||
373 | finally { | ||
374 | } | ||
375 | } | ||
376 | // $ANTLR end "Extern" | ||
377 | |||
378 | // $ANTLR start "Import" | ||
379 | public final void mImport() throws RecognitionException { | ||
380 | try { | ||
381 | int _type = Import; | ||
382 | int _channel = DEFAULT_TOKEN_CHANNEL; | ||
383 | // InternalSolverLanguageLexer.g:40:8: ( 'import' ) | ||
384 | // InternalSolverLanguageLexer.g:40:10: 'import' | ||
385 | { | ||
386 | match("import"); | ||
387 | |||
388 | |||
389 | } | ||
390 | |||
391 | state.type = _type; | ||
392 | state.channel = _channel; | ||
393 | } | ||
394 | finally { | ||
395 | } | ||
396 | } | ||
397 | // $ANTLR end "Import" | ||
398 | |||
399 | // $ANTLR start "Object" | ||
400 | public final void mObject() throws RecognitionException { | ||
401 | try { | ||
402 | int _type = Object; | ||
403 | int _channel = DEFAULT_TOKEN_CHANNEL; | ||
404 | // InternalSolverLanguageLexer.g:42:8: ( 'object' ) | ||
405 | // InternalSolverLanguageLexer.g:42:10: 'object' | ||
406 | { | ||
407 | match("object"); | ||
408 | |||
409 | |||
410 | } | ||
411 | |||
412 | state.type = _type; | ||
413 | state.channel = _channel; | ||
414 | } | ||
415 | finally { | ||
416 | } | ||
417 | } | ||
418 | // $ANTLR end "Object" | ||
419 | |||
420 | // $ANTLR start "Refers" | ||
421 | public final void mRefers() throws RecognitionException { | ||
422 | try { | ||
423 | int _type = Refers; | ||
424 | int _channel = DEFAULT_TOKEN_CHANNEL; | ||
425 | // InternalSolverLanguageLexer.g:44:8: ( 'refers' ) | ||
426 | // InternalSolverLanguageLexer.g:44:10: 'refers' | ||
427 | { | ||
428 | match("refers"); | ||
429 | |||
430 | |||
431 | } | ||
432 | |||
433 | state.type = _type; | ||
434 | state.channel = _channel; | ||
435 | } | ||
436 | finally { | ||
437 | } | ||
438 | } | ||
439 | // $ANTLR end "Refers" | ||
440 | |||
441 | // $ANTLR start "Class" | ||
442 | public final void mClass() throws RecognitionException { | ||
443 | try { | ||
444 | int _type = Class; | ||
445 | int _channel = DEFAULT_TOKEN_CHANNEL; | ||
446 | // InternalSolverLanguageLexer.g:46:7: ( 'class' ) | ||
447 | // InternalSolverLanguageLexer.g:46:9: 'class' | ||
448 | { | ||
449 | match("class"); | ||
450 | |||
451 | |||
452 | } | ||
453 | |||
454 | state.type = _type; | ||
455 | state.channel = _channel; | ||
456 | } | ||
457 | finally { | ||
458 | } | ||
459 | } | ||
460 | // $ANTLR end "Class" | ||
461 | |||
462 | // $ANTLR start "Count" | ||
463 | public final void mCount() throws RecognitionException { | ||
464 | try { | ||
465 | int _type = Count; | ||
466 | int _channel = DEFAULT_TOKEN_CHANNEL; | ||
467 | // InternalSolverLanguageLexer.g:48:7: ( 'count' ) | ||
468 | // InternalSolverLanguageLexer.g:48:9: 'count' | ||
469 | { | ||
470 | match("count"); | ||
471 | |||
472 | |||
473 | } | ||
474 | |||
475 | state.type = _type; | ||
476 | state.channel = _channel; | ||
477 | } | ||
478 | finally { | ||
479 | } | ||
480 | } | ||
481 | // $ANTLR end "Count" | ||
482 | |||
483 | // $ANTLR start "Empty" | ||
484 | public final void mEmpty() throws RecognitionException { | ||
485 | try { | ||
486 | int _type = Empty; | ||
487 | int _channel = DEFAULT_TOKEN_CHANNEL; | ||
488 | // InternalSolverLanguageLexer.g:50:7: ( 'empty' ) | ||
489 | // InternalSolverLanguageLexer.g:50:9: 'empty' | ||
490 | { | ||
491 | match("empty"); | ||
492 | |||
493 | |||
494 | } | ||
495 | |||
496 | state.type = _type; | ||
497 | state.channel = _channel; | ||
498 | } | ||
499 | finally { | ||
500 | } | ||
501 | } | ||
502 | // $ANTLR end "Empty" | ||
503 | |||
504 | // $ANTLR start "Error" | ||
505 | public final void mError() throws RecognitionException { | ||
506 | try { | ||
507 | int _type = Error; | ||
508 | int _channel = DEFAULT_TOKEN_CHANNEL; | ||
509 | // InternalSolverLanguageLexer.g:52:7: ( 'error' ) | ||
510 | // InternalSolverLanguageLexer.g:52:9: 'error' | ||
511 | { | ||
512 | match("error"); | ||
513 | |||
514 | |||
515 | } | ||
516 | |||
517 | state.type = _type; | ||
518 | state.channel = _channel; | ||
519 | } | ||
520 | finally { | ||
521 | } | ||
522 | } | ||
523 | // $ANTLR end "Error" | ||
524 | |||
525 | // $ANTLR start "False" | ||
526 | public final void mFalse() throws RecognitionException { | ||
527 | try { | ||
528 | int _type = False; | ||
529 | int _channel = DEFAULT_TOKEN_CHANNEL; | ||
530 | // InternalSolverLanguageLexer.g:54:7: ( 'false' ) | ||
531 | // InternalSolverLanguageLexer.g:54:9: 'false' | ||
532 | { | ||
533 | match("false"); | ||
534 | |||
535 | |||
536 | } | ||
537 | |||
538 | state.type = _type; | ||
539 | state.channel = _channel; | ||
540 | } | ||
541 | finally { | ||
542 | } | ||
543 | } | ||
544 | // $ANTLR end "False" | ||
545 | |||
546 | // $ANTLR start "Scope" | ||
547 | public final void mScope() throws RecognitionException { | ||
548 | try { | ||
549 | int _type = Scope; | ||
550 | int _channel = DEFAULT_TOKEN_CHANNEL; | ||
551 | // InternalSolverLanguageLexer.g:56:7: ( 'scope' ) | ||
552 | // InternalSolverLanguageLexer.g:56:9: 'scope' | ||
553 | { | ||
554 | match("scope"); | ||
555 | |||
556 | |||
557 | } | ||
558 | |||
559 | state.type = _type; | ||
560 | state.channel = _channel; | ||
561 | } | ||
562 | finally { | ||
563 | } | ||
564 | } | ||
565 | // $ANTLR end "Scope" | ||
566 | |||
567 | // $ANTLR start "Else" | ||
568 | public final void mElse() throws RecognitionException { | ||
569 | try { | ||
570 | int _type = Else; | ||
571 | int _channel = DEFAULT_TOKEN_CHANNEL; | ||
572 | // InternalSolverLanguageLexer.g:58:6: ( 'else' ) | ||
573 | // InternalSolverLanguageLexer.g:58:8: 'else' | ||
574 | { | ||
575 | match("else"); | ||
576 | |||
577 | |||
578 | } | ||
579 | |||
580 | state.type = _type; | ||
581 | state.channel = _channel; | ||
582 | } | ||
583 | finally { | ||
584 | } | ||
585 | } | ||
586 | // $ANTLR end "Else" | ||
587 | |||
588 | // $ANTLR start "Enum" | ||
589 | public final void mEnum() throws RecognitionException { | ||
590 | try { | ||
591 | int _type = Enum; | ||
592 | int _channel = DEFAULT_TOKEN_CHANNEL; | ||
593 | // InternalSolverLanguageLexer.g:60:6: ( 'enum' ) | ||
594 | // InternalSolverLanguageLexer.g:60:8: 'enum' | ||
595 | { | ||
596 | match("enum"); | ||
597 | |||
598 | |||
599 | } | ||
600 | |||
601 | state.type = _type; | ||
602 | state.channel = _channel; | ||
603 | } | ||
604 | finally { | ||
605 | } | ||
606 | } | ||
607 | // $ANTLR end "Enum" | ||
608 | |||
609 | // $ANTLR start "Root" | ||
610 | public final void mRoot() throws RecognitionException { | ||
611 | try { | ||
612 | int _type = Root; | ||
613 | int _channel = DEFAULT_TOKEN_CHANNEL; | ||
614 | // InternalSolverLanguageLexer.g:62:6: ( 'root' ) | ||
615 | // InternalSolverLanguageLexer.g:62:8: 'root' | ||
616 | { | ||
617 | match("root"); | ||
618 | |||
619 | |||
620 | } | ||
621 | |||
622 | state.type = _type; | ||
623 | state.channel = _channel; | ||
624 | } | ||
625 | finally { | ||
626 | } | ||
627 | } | ||
628 | // $ANTLR end "Root" | ||
629 | |||
630 | // $ANTLR start "Then" | ||
631 | public final void mThen() throws RecognitionException { | ||
632 | try { | ||
633 | int _type = Then; | ||
634 | int _channel = DEFAULT_TOKEN_CHANNEL; | ||
635 | // InternalSolverLanguageLexer.g:64:6: ( 'then' ) | ||
636 | // InternalSolverLanguageLexer.g:64:8: 'then' | ||
637 | { | ||
638 | match("then"); | ||
639 | |||
640 | |||
641 | } | ||
642 | |||
643 | state.type = _type; | ||
644 | state.channel = _channel; | ||
645 | } | ||
646 | finally { | ||
647 | } | ||
648 | } | ||
649 | // $ANTLR end "Then" | ||
650 | |||
651 | // $ANTLR start "True" | ||
652 | public final void mTrue() throws RecognitionException { | ||
653 | try { | ||
654 | int _type = True; | ||
655 | int _channel = DEFAULT_TOKEN_CHANNEL; | ||
656 | // InternalSolverLanguageLexer.g:66:6: ( 'true' ) | ||
657 | // InternalSolverLanguageLexer.g:66:8: 'true' | ||
658 | { | ||
659 | match("true"); | ||
660 | |||
661 | |||
662 | } | ||
663 | |||
664 | state.type = _type; | ||
665 | state.channel = _channel; | ||
666 | } | ||
667 | finally { | ||
668 | } | ||
669 | } | ||
670 | // $ANTLR end "True" | ||
671 | |||
672 | // $ANTLR start "FullStopFullStopFullStop" | ||
673 | public final void mFullStopFullStopFullStop() throws RecognitionException { | ||
674 | try { | ||
675 | int _type = FullStopFullStopFullStop; | ||
676 | int _channel = DEFAULT_TOKEN_CHANNEL; | ||
677 | // InternalSolverLanguageLexer.g:68:26: ( '...' ) | ||
678 | // InternalSolverLanguageLexer.g:68:28: '...' | ||
679 | { | ||
680 | match("..."); | ||
681 | |||
682 | |||
683 | } | ||
684 | |||
685 | state.type = _type; | ||
686 | state.channel = _channel; | ||
687 | } | ||
688 | finally { | ||
689 | } | ||
690 | } | ||
691 | // $ANTLR end "FullStopFullStopFullStop" | ||
692 | |||
693 | // $ANTLR start "Inf" | ||
694 | public final void mInf() throws RecognitionException { | ||
695 | try { | ||
696 | int _type = Inf; | ||
697 | int _channel = DEFAULT_TOKEN_CHANNEL; | ||
698 | // InternalSolverLanguageLexer.g:70:5: ( 'inf' ) | ||
699 | // InternalSolverLanguageLexer.g:70:7: 'inf' | ||
700 | { | ||
701 | match("inf"); | ||
702 | |||
703 | |||
704 | } | ||
705 | |||
706 | state.type = _type; | ||
707 | state.channel = _channel; | ||
708 | } | ||
709 | finally { | ||
710 | } | ||
711 | } | ||
712 | // $ANTLR end "Inf" | ||
713 | |||
714 | // $ANTLR start "Let" | ||
715 | public final void mLet() throws RecognitionException { | ||
716 | try { | ||
717 | int _type = Let; | ||
718 | int _channel = DEFAULT_TOKEN_CHANNEL; | ||
719 | // InternalSolverLanguageLexer.g:72:5: ( 'let' ) | ||
720 | // InternalSolverLanguageLexer.g:72:7: 'let' | ||
721 | { | ||
722 | match("let"); | ||
723 | |||
724 | |||
725 | } | ||
726 | |||
727 | state.type = _type; | ||
728 | state.channel = _channel; | ||
729 | } | ||
730 | finally { | ||
731 | } | ||
732 | } | ||
733 | // $ANTLR end "Let" | ||
734 | |||
735 | // $ANTLR start "ExclamationMarkEqualsSign" | ||
736 | public final void mExclamationMarkEqualsSign() throws RecognitionException { | ||
737 | try { | ||
738 | int _type = ExclamationMarkEqualsSign; | ||
739 | int _channel = DEFAULT_TOKEN_CHANNEL; | ||
740 | // InternalSolverLanguageLexer.g:74:27: ( '!=' ) | ||
741 | // InternalSolverLanguageLexer.g:74:29: '!=' | ||
742 | { | ||
743 | match("!="); | ||
744 | |||
745 | |||
746 | } | ||
747 | |||
748 | state.type = _type; | ||
749 | state.channel = _channel; | ||
750 | } | ||
751 | finally { | ||
752 | } | ||
753 | } | ||
754 | // $ANTLR end "ExclamationMarkEqualsSign" | ||
755 | |||
756 | // $ANTLR start "HyphenMinusGreaterThanSign" | ||
757 | public final void mHyphenMinusGreaterThanSign() throws RecognitionException { | ||
758 | try { | ||
759 | int _type = HyphenMinusGreaterThanSign; | ||
760 | int _channel = DEFAULT_TOKEN_CHANNEL; | ||
761 | // InternalSolverLanguageLexer.g:76:28: ( '->' ) | ||
762 | // InternalSolverLanguageLexer.g:76:30: '->' | ||
763 | { | ||
764 | match("->"); | ||
765 | |||
766 | |||
767 | } | ||
768 | |||
769 | state.type = _type; | ||
770 | state.channel = _channel; | ||
771 | } | ||
772 | finally { | ||
773 | } | ||
774 | } | ||
775 | // $ANTLR end "HyphenMinusGreaterThanSign" | ||
776 | |||
777 | // $ANTLR start "ColonHyphenMinus" | ||
778 | public final void mColonHyphenMinus() throws RecognitionException { | ||
779 | try { | ||
780 | int _type = ColonHyphenMinus; | ||
781 | int _channel = DEFAULT_TOKEN_CHANNEL; | ||
782 | // InternalSolverLanguageLexer.g:78:18: ( ':-' ) | ||
783 | // InternalSolverLanguageLexer.g:78:20: ':-' | ||
784 | { | ||
785 | match(":-"); | ||
786 | |||
787 | |||
788 | } | ||
789 | |||
790 | state.type = _type; | ||
791 | state.channel = _channel; | ||
792 | } | ||
793 | finally { | ||
794 | } | ||
795 | } | ||
796 | // $ANTLR end "ColonHyphenMinus" | ||
797 | |||
798 | // $ANTLR start "ColonColon" | ||
799 | public final void mColonColon() throws RecognitionException { | ||
800 | try { | ||
801 | int _type = ColonColon; | ||
802 | int _channel = DEFAULT_TOKEN_CHANNEL; | ||
803 | // InternalSolverLanguageLexer.g:80:12: ( '::' ) | ||
804 | // InternalSolverLanguageLexer.g:80:14: '::' | ||
805 | { | ||
806 | match("::"); | ||
807 | |||
808 | |||
809 | } | ||
810 | |||
811 | state.type = _type; | ||
812 | state.channel = _channel; | ||
813 | } | ||
814 | finally { | ||
815 | } | ||
816 | } | ||
817 | // $ANTLR end "ColonColon" | ||
818 | |||
819 | // $ANTLR start "ColonEqualsSign" | ||
820 | public final void mColonEqualsSign() throws RecognitionException { | ||
821 | try { | ||
822 | int _type = ColonEqualsSign; | ||
823 | int _channel = DEFAULT_TOKEN_CHANNEL; | ||
824 | // InternalSolverLanguageLexer.g:82:17: ( ':=' ) | ||
825 | // InternalSolverLanguageLexer.g:82:19: ':=' | ||
826 | { | ||
827 | match(":="); | ||
828 | |||
829 | |||
830 | } | ||
831 | |||
832 | state.type = _type; | ||
833 | state.channel = _channel; | ||
834 | } | ||
835 | finally { | ||
836 | } | ||
837 | } | ||
838 | // $ANTLR end "ColonEqualsSign" | ||
839 | |||
840 | // $ANTLR start "LessThanSignEqualsSign" | ||
841 | public final void mLessThanSignEqualsSign() throws RecognitionException { | ||
842 | try { | ||
843 | int _type = LessThanSignEqualsSign; | ||
844 | int _channel = DEFAULT_TOKEN_CHANNEL; | ||
845 | // InternalSolverLanguageLexer.g:84:24: ( '<=' ) | ||
846 | // InternalSolverLanguageLexer.g:84:26: '<=' | ||
847 | { | ||
848 | match("<="); | ||
849 | |||
850 | |||
851 | } | ||
852 | |||
853 | state.type = _type; | ||
854 | state.channel = _channel; | ||
855 | } | ||
856 | finally { | ||
857 | } | ||
858 | } | ||
859 | // $ANTLR end "LessThanSignEqualsSign" | ||
860 | |||
861 | // $ANTLR start "EqualsSignEqualsSign" | ||
862 | public final void mEqualsSignEqualsSign() throws RecognitionException { | ||
863 | try { | ||
864 | int _type = EqualsSignEqualsSign; | ||
865 | int _channel = DEFAULT_TOKEN_CHANNEL; | ||
866 | // InternalSolverLanguageLexer.g:86:22: ( '==' ) | ||
867 | // InternalSolverLanguageLexer.g:86:24: '==' | ||
868 | { | ||
869 | match("=="); | ||
870 | |||
871 | |||
872 | } | ||
873 | |||
874 | state.type = _type; | ||
875 | state.channel = _channel; | ||
876 | } | ||
877 | finally { | ||
878 | } | ||
879 | } | ||
880 | // $ANTLR end "EqualsSignEqualsSign" | ||
881 | |||
882 | // $ANTLR start "EqualsSignGreaterThanSign" | ||
883 | public final void mEqualsSignGreaterThanSign() throws RecognitionException { | ||
884 | try { | ||
885 | int _type = EqualsSignGreaterThanSign; | ||
886 | int _channel = DEFAULT_TOKEN_CHANNEL; | ||
887 | // InternalSolverLanguageLexer.g:88:27: ( '=>' ) | ||
888 | // InternalSolverLanguageLexer.g:88:29: '=>' | ||
889 | { | ||
890 | match("=>"); | ||
891 | |||
892 | |||
893 | } | ||
894 | |||
895 | state.type = _type; | ||
896 | state.channel = _channel; | ||
897 | } | ||
898 | finally { | ||
899 | } | ||
900 | } | ||
901 | // $ANTLR end "EqualsSignGreaterThanSign" | ||
902 | |||
903 | // $ANTLR start "GreaterThanSignEqualsSign" | ||
904 | public final void mGreaterThanSignEqualsSign() throws RecognitionException { | ||
905 | try { | ||
906 | int _type = GreaterThanSignEqualsSign; | ||
907 | int _channel = DEFAULT_TOKEN_CHANNEL; | ||
908 | // InternalSolverLanguageLexer.g:90:27: ( '>=' ) | ||
909 | // InternalSolverLanguageLexer.g:90:29: '>=' | ||
910 | { | ||
911 | match(">="); | ||
912 | |||
913 | |||
914 | } | ||
915 | |||
916 | state.type = _type; | ||
917 | state.channel = _channel; | ||
918 | } | ||
919 | finally { | ||
920 | } | ||
921 | } | ||
922 | // $ANTLR end "GreaterThanSignEqualsSign" | ||
923 | |||
924 | // $ANTLR start "As" | ||
925 | public final void mAs() throws RecognitionException { | ||
926 | try { | ||
927 | int _type = As; | ||
928 | int _channel = DEFAULT_TOKEN_CHANNEL; | ||
929 | // InternalSolverLanguageLexer.g:92:4: ( 'as' ) | ||
930 | // InternalSolverLanguageLexer.g:92:6: 'as' | ||
931 | { | ||
932 | match("as"); | ||
933 | |||
934 | |||
935 | } | ||
936 | |||
937 | state.type = _type; | ||
938 | state.channel = _channel; | ||
939 | } | ||
940 | finally { | ||
941 | } | ||
942 | } | ||
943 | // $ANTLR end "As" | ||
944 | |||
945 | // $ANTLR start "If" | ||
946 | public final void mIf() throws RecognitionException { | ||
947 | try { | ||
948 | int _type = If; | ||
949 | int _channel = DEFAULT_TOKEN_CHANNEL; | ||
950 | // InternalSolverLanguageLexer.g:94:4: ( 'if' ) | ||
951 | // InternalSolverLanguageLexer.g:94:6: 'if' | ||
952 | { | ||
953 | match("if"); | ||
954 | |||
955 | |||
956 | } | ||
957 | |||
958 | state.type = _type; | ||
959 | state.channel = _channel; | ||
960 | } | ||
961 | finally { | ||
962 | } | ||
963 | } | ||
964 | // $ANTLR end "If" | ||
965 | |||
966 | // $ANTLR start "In" | ||
967 | public final void mIn() throws RecognitionException { | ||
968 | try { | ||
969 | int _type = In; | ||
970 | int _channel = DEFAULT_TOKEN_CHANNEL; | ||
971 | // InternalSolverLanguageLexer.g:96:4: ( 'in' ) | ||
972 | // InternalSolverLanguageLexer.g:96:6: 'in' | ||
973 | { | ||
974 | match("in"); | ||
975 | |||
976 | |||
977 | } | ||
978 | |||
979 | state.type = _type; | ||
980 | state.channel = _channel; | ||
981 | } | ||
982 | finally { | ||
983 | } | ||
984 | } | ||
985 | // $ANTLR end "In" | ||
986 | |||
987 | // $ANTLR start "ExclamationMark" | ||
988 | public final void mExclamationMark() throws RecognitionException { | ||
989 | try { | ||
990 | int _type = ExclamationMark; | ||
991 | int _channel = DEFAULT_TOKEN_CHANNEL; | ||
992 | // InternalSolverLanguageLexer.g:98:17: ( '!' ) | ||
993 | // InternalSolverLanguageLexer.g:98:19: '!' | ||
994 | { | ||
995 | match('!'); | ||
996 | |||
997 | } | ||
998 | |||
999 | state.type = _type; | ||
1000 | state.channel = _channel; | ||
1001 | } | ||
1002 | finally { | ||
1003 | } | ||
1004 | } | ||
1005 | // $ANTLR end "ExclamationMark" | ||
1006 | |||
1007 | // $ANTLR start "LeftParenthesis" | ||
1008 | public final void mLeftParenthesis() throws RecognitionException { | ||
1009 | try { | ||
1010 | int _type = LeftParenthesis; | ||
1011 | int _channel = DEFAULT_TOKEN_CHANNEL; | ||
1012 | // InternalSolverLanguageLexer.g:100:17: ( '(' ) | ||
1013 | // InternalSolverLanguageLexer.g:100:19: '(' | ||
1014 | { | ||
1015 | match('('); | ||
1016 | |||
1017 | } | ||
1018 | |||
1019 | state.type = _type; | ||
1020 | state.channel = _channel; | ||
1021 | } | ||
1022 | finally { | ||
1023 | } | ||
1024 | } | ||
1025 | // $ANTLR end "LeftParenthesis" | ||
1026 | |||
1027 | // $ANTLR start "RightParenthesis" | ||
1028 | public final void mRightParenthesis() throws RecognitionException { | ||
1029 | try { | ||
1030 | int _type = RightParenthesis; | ||
1031 | int _channel = DEFAULT_TOKEN_CHANNEL; | ||
1032 | // InternalSolverLanguageLexer.g:102:18: ( ')' ) | ||
1033 | // InternalSolverLanguageLexer.g:102:20: ')' | ||
1034 | { | ||
1035 | match(')'); | ||
1036 | |||
1037 | } | ||
1038 | |||
1039 | state.type = _type; | ||
1040 | state.channel = _channel; | ||
1041 | } | ||
1042 | finally { | ||
1043 | } | ||
1044 | } | ||
1045 | // $ANTLR end "RightParenthesis" | ||
1046 | |||
1047 | // $ANTLR start "Asterisk" | ||
1048 | public final void mAsterisk() throws RecognitionException { | ||
1049 | try { | ||
1050 | int _type = Asterisk; | ||
1051 | int _channel = DEFAULT_TOKEN_CHANNEL; | ||
1052 | // InternalSolverLanguageLexer.g:104:10: ( '*' ) | ||
1053 | // InternalSolverLanguageLexer.g:104:12: '*' | ||
1054 | { | ||
1055 | match('*'); | ||
1056 | |||
1057 | } | ||
1058 | |||
1059 | state.type = _type; | ||
1060 | state.channel = _channel; | ||
1061 | } | ||
1062 | finally { | ||
1063 | } | ||
1064 | } | ||
1065 | // $ANTLR end "Asterisk" | ||
1066 | |||
1067 | // $ANTLR start "PlusSign" | ||
1068 | public final void mPlusSign() throws RecognitionException { | ||
1069 | try { | ||
1070 | int _type = PlusSign; | ||
1071 | int _channel = DEFAULT_TOKEN_CHANNEL; | ||
1072 | // InternalSolverLanguageLexer.g:106:10: ( '+' ) | ||
1073 | // InternalSolverLanguageLexer.g:106:12: '+' | ||
1074 | { | ||
1075 | match('+'); | ||
1076 | |||
1077 | } | ||
1078 | |||
1079 | state.type = _type; | ||
1080 | state.channel = _channel; | ||
1081 | } | ||
1082 | finally { | ||
1083 | } | ||
1084 | } | ||
1085 | // $ANTLR end "PlusSign" | ||
1086 | |||
1087 | // $ANTLR start "Comma" | ||
1088 | public final void mComma() throws RecognitionException { | ||
1089 | try { | ||
1090 | int _type = Comma; | ||
1091 | int _channel = DEFAULT_TOKEN_CHANNEL; | ||
1092 | // InternalSolverLanguageLexer.g:108:7: ( ',' ) | ||
1093 | // InternalSolverLanguageLexer.g:108:9: ',' | ||
1094 | { | ||
1095 | match(','); | ||
1096 | |||
1097 | } | ||
1098 | |||
1099 | state.type = _type; | ||
1100 | state.channel = _channel; | ||
1101 | } | ||
1102 | finally { | ||
1103 | } | ||
1104 | } | ||
1105 | // $ANTLR end "Comma" | ||
1106 | |||
1107 | // $ANTLR start "HyphenMinus" | ||
1108 | public final void mHyphenMinus() throws RecognitionException { | ||
1109 | try { | ||
1110 | int _type = HyphenMinus; | ||
1111 | int _channel = DEFAULT_TOKEN_CHANNEL; | ||
1112 | // InternalSolverLanguageLexer.g:110:13: ( '-' ) | ||
1113 | // InternalSolverLanguageLexer.g:110:15: '-' | ||
1114 | { | ||
1115 | match('-'); | ||
1116 | |||
1117 | } | ||
1118 | |||
1119 | state.type = _type; | ||
1120 | state.channel = _channel; | ||
1121 | } | ||
1122 | finally { | ||
1123 | } | ||
1124 | } | ||
1125 | // $ANTLR end "HyphenMinus" | ||
1126 | |||
1127 | // $ANTLR start "FullStop" | ||
1128 | public final void mFullStop() throws RecognitionException { | ||
1129 | try { | ||
1130 | int _type = FullStop; | ||
1131 | int _channel = DEFAULT_TOKEN_CHANNEL; | ||
1132 | // InternalSolverLanguageLexer.g:112:10: ( '.' ) | ||
1133 | // InternalSolverLanguageLexer.g:112:12: '.' | ||
1134 | { | ||
1135 | match('.'); | ||
1136 | |||
1137 | } | ||
1138 | |||
1139 | state.type = _type; | ||
1140 | state.channel = _channel; | ||
1141 | } | ||
1142 | finally { | ||
1143 | } | ||
1144 | } | ||
1145 | // $ANTLR end "FullStop" | ||
1146 | |||
1147 | // $ANTLR start "Solidus" | ||
1148 | public final void mSolidus() throws RecognitionException { | ||
1149 | try { | ||
1150 | int _type = Solidus; | ||
1151 | int _channel = DEFAULT_TOKEN_CHANNEL; | ||
1152 | // InternalSolverLanguageLexer.g:114:9: ( '/' ) | ||
1153 | // InternalSolverLanguageLexer.g:114:11: '/' | ||
1154 | { | ||
1155 | match('/'); | ||
1156 | |||
1157 | } | ||
1158 | |||
1159 | state.type = _type; | ||
1160 | state.channel = _channel; | ||
1161 | } | ||
1162 | finally { | ||
1163 | } | ||
1164 | } | ||
1165 | // $ANTLR end "Solidus" | ||
1166 | |||
1167 | // $ANTLR start "Colon" | ||
1168 | public final void mColon() throws RecognitionException { | ||
1169 | try { | ||
1170 | int _type = Colon; | ||
1171 | int _channel = DEFAULT_TOKEN_CHANNEL; | ||
1172 | // InternalSolverLanguageLexer.g:116:7: ( ':' ) | ||
1173 | // InternalSolverLanguageLexer.g:116:9: ':' | ||
1174 | { | ||
1175 | match(':'); | ||
1176 | |||
1177 | } | ||
1178 | |||
1179 | state.type = _type; | ||
1180 | state.channel = _channel; | ||
1181 | } | ||
1182 | finally { | ||
1183 | } | ||
1184 | } | ||
1185 | // $ANTLR end "Colon" | ||
1186 | |||
1187 | // $ANTLR start "Semicolon" | ||
1188 | public final void mSemicolon() throws RecognitionException { | ||
1189 | try { | ||
1190 | int _type = Semicolon; | ||
1191 | int _channel = DEFAULT_TOKEN_CHANNEL; | ||
1192 | // InternalSolverLanguageLexer.g:118:11: ( ';' ) | ||
1193 | // InternalSolverLanguageLexer.g:118:13: ';' | ||
1194 | { | ||
1195 | match(';'); | ||
1196 | |||
1197 | } | ||
1198 | |||
1199 | state.type = _type; | ||
1200 | state.channel = _channel; | ||
1201 | } | ||
1202 | finally { | ||
1203 | } | ||
1204 | } | ||
1205 | // $ANTLR end "Semicolon" | ||
1206 | |||
1207 | // $ANTLR start "LessThanSign" | ||
1208 | public final void mLessThanSign() throws RecognitionException { | ||
1209 | try { | ||
1210 | int _type = LessThanSign; | ||
1211 | int _channel = DEFAULT_TOKEN_CHANNEL; | ||
1212 | // InternalSolverLanguageLexer.g:120:14: ( '<' ) | ||
1213 | // InternalSolverLanguageLexer.g:120:16: '<' | ||
1214 | { | ||
1215 | match('<'); | ||
1216 | |||
1217 | } | ||
1218 | |||
1219 | state.type = _type; | ||
1220 | state.channel = _channel; | ||
1221 | } | ||
1222 | finally { | ||
1223 | } | ||
1224 | } | ||
1225 | // $ANTLR end "LessThanSign" | ||
1226 | |||
1227 | // $ANTLR start "EqualsSign" | ||
1228 | public final void mEqualsSign() throws RecognitionException { | ||
1229 | try { | ||
1230 | int _type = EqualsSign; | ||
1231 | int _channel = DEFAULT_TOKEN_CHANNEL; | ||
1232 | // InternalSolverLanguageLexer.g:122:12: ( '=' ) | ||
1233 | // InternalSolverLanguageLexer.g:122:14: '=' | ||
1234 | { | ||
1235 | match('='); | ||
1236 | |||
1237 | } | ||
1238 | |||
1239 | state.type = _type; | ||
1240 | state.channel = _channel; | ||
1241 | } | ||
1242 | finally { | ||
1243 | } | ||
1244 | } | ||
1245 | // $ANTLR end "EqualsSign" | ||
1246 | |||
1247 | // $ANTLR start "GreaterThanSign" | ||
1248 | public final void mGreaterThanSign() throws RecognitionException { | ||
1249 | try { | ||
1250 | int _type = GreaterThanSign; | ||
1251 | int _channel = DEFAULT_TOKEN_CHANNEL; | ||
1252 | // InternalSolverLanguageLexer.g:124:17: ( '>' ) | ||
1253 | // InternalSolverLanguageLexer.g:124:19: '>' | ||
1254 | { | ||
1255 | match('>'); | ||
1256 | |||
1257 | } | ||
1258 | |||
1259 | state.type = _type; | ||
1260 | state.channel = _channel; | ||
1261 | } | ||
1262 | finally { | ||
1263 | } | ||
1264 | } | ||
1265 | // $ANTLR end "GreaterThanSign" | ||
1266 | |||
1267 | // $ANTLR start "QuestionMark" | ||
1268 | public final void mQuestionMark() throws RecognitionException { | ||
1269 | try { | ||
1270 | int _type = QuestionMark; | ||
1271 | int _channel = DEFAULT_TOKEN_CHANNEL; | ||
1272 | // InternalSolverLanguageLexer.g:126:14: ( '?' ) | ||
1273 | // InternalSolverLanguageLexer.g:126:16: '?' | ||
1274 | { | ||
1275 | match('?'); | ||
1276 | |||
1277 | } | ||
1278 | |||
1279 | state.type = _type; | ||
1280 | state.channel = _channel; | ||
1281 | } | ||
1282 | finally { | ||
1283 | } | ||
1284 | } | ||
1285 | // $ANTLR end "QuestionMark" | ||
1286 | |||
1287 | // $ANTLR start "LeftSquareBracket" | ||
1288 | public final void mLeftSquareBracket() throws RecognitionException { | ||
1289 | try { | ||
1290 | int _type = LeftSquareBracket; | ||
1291 | int _channel = DEFAULT_TOKEN_CHANNEL; | ||
1292 | // InternalSolverLanguageLexer.g:128:19: ( '[' ) | ||
1293 | // InternalSolverLanguageLexer.g:128:21: '[' | ||
1294 | { | ||
1295 | match('['); | ||
1296 | |||
1297 | } | ||
1298 | |||
1299 | state.type = _type; | ||
1300 | state.channel = _channel; | ||
1301 | } | ||
1302 | finally { | ||
1303 | } | ||
1304 | } | ||
1305 | // $ANTLR end "LeftSquareBracket" | ||
1306 | |||
1307 | // $ANTLR start "RightSquareBracket" | ||
1308 | public final void mRightSquareBracket() throws RecognitionException { | ||
1309 | try { | ||
1310 | int _type = RightSquareBracket; | ||
1311 | int _channel = DEFAULT_TOKEN_CHANNEL; | ||
1312 | // InternalSolverLanguageLexer.g:130:20: ( ']' ) | ||
1313 | // InternalSolverLanguageLexer.g:130:22: ']' | ||
1314 | { | ||
1315 | match(']'); | ||
1316 | |||
1317 | } | ||
1318 | |||
1319 | state.type = _type; | ||
1320 | state.channel = _channel; | ||
1321 | } | ||
1322 | finally { | ||
1323 | } | ||
1324 | } | ||
1325 | // $ANTLR end "RightSquareBracket" | ||
1326 | |||
1327 | // $ANTLR start "CircumflexAccent" | ||
1328 | public final void mCircumflexAccent() throws RecognitionException { | ||
1329 | try { | ||
1330 | int _type = CircumflexAccent; | ||
1331 | int _channel = DEFAULT_TOKEN_CHANNEL; | ||
1332 | // InternalSolverLanguageLexer.g:132:18: ( '^' ) | ||
1333 | // InternalSolverLanguageLexer.g:132:20: '^' | ||
1334 | { | ||
1335 | match('^'); | ||
1336 | |||
1337 | } | ||
1338 | |||
1339 | state.type = _type; | ||
1340 | state.channel = _channel; | ||
1341 | } | ||
1342 | finally { | ||
1343 | } | ||
1344 | } | ||
1345 | // $ANTLR end "CircumflexAccent" | ||
1346 | |||
1347 | // $ANTLR start "LeftCurlyBracket" | ||
1348 | public final void mLeftCurlyBracket() throws RecognitionException { | ||
1349 | try { | ||
1350 | int _type = LeftCurlyBracket; | ||
1351 | int _channel = DEFAULT_TOKEN_CHANNEL; | ||
1352 | // InternalSolverLanguageLexer.g:134:18: ( '{' ) | ||
1353 | // InternalSolverLanguageLexer.g:134:20: '{' | ||
1354 | { | ||
1355 | match('{'); | ||
1356 | |||
1357 | } | ||
1358 | |||
1359 | state.type = _type; | ||
1360 | state.channel = _channel; | ||
1361 | } | ||
1362 | finally { | ||
1363 | } | ||
1364 | } | ||
1365 | // $ANTLR end "LeftCurlyBracket" | ||
1366 | |||
1367 | // $ANTLR start "VerticalLine" | ||
1368 | public final void mVerticalLine() throws RecognitionException { | ||
1369 | try { | ||
1370 | int _type = VerticalLine; | ||
1371 | int _channel = DEFAULT_TOKEN_CHANNEL; | ||
1372 | // InternalSolverLanguageLexer.g:136:14: ( '|' ) | ||
1373 | // InternalSolverLanguageLexer.g:136:16: '|' | ||
1374 | { | ||
1375 | match('|'); | ||
1376 | |||
1377 | } | ||
1378 | |||
1379 | state.type = _type; | ||
1380 | state.channel = _channel; | ||
1381 | } | ||
1382 | finally { | ||
1383 | } | ||
1384 | } | ||
1385 | // $ANTLR end "VerticalLine" | ||
1386 | |||
1387 | // $ANTLR start "RightCurlyBracket" | ||
1388 | public final void mRightCurlyBracket() throws RecognitionException { | ||
1389 | try { | ||
1390 | int _type = RightCurlyBracket; | ||
1391 | int _channel = DEFAULT_TOKEN_CHANNEL; | ||
1392 | // InternalSolverLanguageLexer.g:138:19: ( '}' ) | ||
1393 | // InternalSolverLanguageLexer.g:138:21: '}' | ||
1394 | { | ||
1395 | match('}'); | ||
1396 | |||
1397 | } | ||
1398 | |||
1399 | state.type = _type; | ||
1400 | state.channel = _channel; | ||
1401 | } | ||
1402 | finally { | ||
1403 | } | ||
1404 | } | ||
1405 | // $ANTLR end "RightCurlyBracket" | ||
1406 | |||
1407 | // $ANTLR start "Tilde" | ||
1408 | public final void mTilde() throws RecognitionException { | ||
1409 | try { | ||
1410 | int _type = Tilde; | ||
1411 | int _channel = DEFAULT_TOKEN_CHANNEL; | ||
1412 | // InternalSolverLanguageLexer.g:140:7: ( '~' ) | ||
1413 | // InternalSolverLanguageLexer.g:140:9: '~' | ||
1414 | { | ||
1415 | match('~'); | ||
1416 | |||
1417 | } | ||
1418 | |||
1419 | state.type = _type; | ||
1420 | state.channel = _channel; | ||
1421 | } | ||
1422 | finally { | ||
1423 | } | ||
1424 | } | ||
1425 | // $ANTLR end "Tilde" | ||
1426 | |||
1427 | // $ANTLR start "RULE_STRING" | ||
1428 | public final void mRULE_STRING() throws RecognitionException { | ||
1429 | try { | ||
1430 | int _type = RULE_STRING; | ||
1431 | int _channel = DEFAULT_TOKEN_CHANNEL; | ||
1432 | // InternalSolverLanguageLexer.g:142:13: ( '\"' ( '\\\\' . | ~ ( ( '\\\\' | '\"' ) ) )* '\"' ) | ||
1433 | // InternalSolverLanguageLexer.g:142:15: '\"' ( '\\\\' . | ~ ( ( '\\\\' | '\"' ) ) )* '\"' | ||
1434 | { | ||
1435 | match('\"'); | ||
1436 | // InternalSolverLanguageLexer.g:142:19: ( '\\\\' . | ~ ( ( '\\\\' | '\"' ) ) )* | ||
1437 | loop1: | ||
1438 | do { | ||
1439 | int alt1=3; | ||
1440 | int LA1_0 = input.LA(1); | ||
1441 | |||
1442 | if ( (LA1_0=='\\') ) { | ||
1443 | alt1=1; | ||
1444 | } | ||
1445 | else if ( ((LA1_0>='\u0000' && LA1_0<='!')||(LA1_0>='#' && LA1_0<='[')||(LA1_0>=']' && LA1_0<='\uFFFF')) ) { | ||
1446 | alt1=2; | ||
1447 | } | ||
1448 | |||
1449 | |||
1450 | switch (alt1) { | ||
1451 | case 1 : | ||
1452 | // InternalSolverLanguageLexer.g:142:20: '\\\\' . | ||
1453 | { | ||
1454 | match('\\'); | ||
1455 | matchAny(); | ||
1456 | |||
1457 | } | ||
1458 | break; | ||
1459 | case 2 : | ||
1460 | // InternalSolverLanguageLexer.g:142:27: ~ ( ( '\\\\' | '\"' ) ) | ||
1461 | { | ||
1462 | if ( (input.LA(1)>='\u0000' && input.LA(1)<='!')||(input.LA(1)>='#' && input.LA(1)<='[')||(input.LA(1)>=']' && input.LA(1)<='\uFFFF') ) { | ||
1463 | input.consume(); | ||
1464 | |||
1465 | } | ||
1466 | else { | ||
1467 | MismatchedSetException mse = new MismatchedSetException(null,input); | ||
1468 | recover(mse); | ||
1469 | throw mse;} | ||
1470 | |||
1471 | |||
1472 | } | ||
1473 | break; | ||
1474 | |||
1475 | default : | ||
1476 | break loop1; | ||
1477 | } | ||
1478 | } while (true); | ||
1479 | |||
1480 | match('\"'); | ||
1481 | |||
1482 | } | ||
1483 | |||
1484 | state.type = _type; | ||
1485 | state.channel = _channel; | ||
1486 | } | ||
1487 | finally { | ||
1488 | } | ||
1489 | } | ||
1490 | // $ANTLR end "RULE_STRING" | ||
1491 | |||
1492 | // $ANTLR start "RULE_QUOTED_ID" | ||
1493 | public final void mRULE_QUOTED_ID() throws RecognitionException { | ||
1494 | try { | ||
1495 | int _type = RULE_QUOTED_ID; | ||
1496 | int _channel = DEFAULT_TOKEN_CHANNEL; | ||
1497 | // InternalSolverLanguageLexer.g:144:16: ( '\\'' ( '\\\\' . | ~ ( ( '\\\\' | '\\'' ) ) )* '\\'' ) | ||
1498 | // InternalSolverLanguageLexer.g:144:18: '\\'' ( '\\\\' . | ~ ( ( '\\\\' | '\\'' ) ) )* '\\'' | ||
1499 | { | ||
1500 | match('\''); | ||
1501 | // InternalSolverLanguageLexer.g:144:23: ( '\\\\' . | ~ ( ( '\\\\' | '\\'' ) ) )* | ||
1502 | loop2: | ||
1503 | do { | ||
1504 | int alt2=3; | ||
1505 | int LA2_0 = input.LA(1); | ||
1506 | |||
1507 | if ( (LA2_0=='\\') ) { | ||
1508 | alt2=1; | ||
1509 | } | ||
1510 | else if ( ((LA2_0>='\u0000' && LA2_0<='&')||(LA2_0>='(' && LA2_0<='[')||(LA2_0>=']' && LA2_0<='\uFFFF')) ) { | ||
1511 | alt2=2; | ||
1512 | } | ||
1513 | |||
1514 | |||
1515 | switch (alt2) { | ||
1516 | case 1 : | ||
1517 | // InternalSolverLanguageLexer.g:144:24: '\\\\' . | ||
1518 | { | ||
1519 | match('\\'); | ||
1520 | matchAny(); | ||
1521 | |||
1522 | } | ||
1523 | break; | ||
1524 | case 2 : | ||
1525 | // InternalSolverLanguageLexer.g:144:31: ~ ( ( '\\\\' | '\\'' ) ) | ||
1526 | { | ||
1527 | if ( (input.LA(1)>='\u0000' && input.LA(1)<='&')||(input.LA(1)>='(' && input.LA(1)<='[')||(input.LA(1)>=']' && input.LA(1)<='\uFFFF') ) { | ||
1528 | input.consume(); | ||
1529 | |||
1530 | } | ||
1531 | else { | ||
1532 | MismatchedSetException mse = new MismatchedSetException(null,input); | ||
1533 | recover(mse); | ||
1534 | throw mse;} | ||
1535 | |||
1536 | |||
1537 | } | ||
1538 | break; | ||
1539 | |||
1540 | default : | ||
1541 | break loop2; | ||
1542 | } | ||
1543 | } while (true); | ||
1544 | |||
1545 | match('\''); | ||
1546 | |||
1547 | } | ||
1548 | |||
1549 | state.type = _type; | ||
1550 | state.channel = _channel; | ||
1551 | } | ||
1552 | finally { | ||
1553 | } | ||
1554 | } | ||
1555 | // $ANTLR end "RULE_QUOTED_ID" | ||
1556 | |||
1557 | // $ANTLR start "RULE_SL_COMMENT" | ||
1558 | public final void mRULE_SL_COMMENT() throws RecognitionException { | ||
1559 | try { | ||
1560 | int _type = RULE_SL_COMMENT; | ||
1561 | int _channel = DEFAULT_TOKEN_CHANNEL; | ||
1562 | // InternalSolverLanguageLexer.g:146:17: ( ( '%' | '//' ) (~ ( ( '\\n' | '\\r' ) ) )* ( ( '\\r' )? '\\n' )? ) | ||
1563 | // InternalSolverLanguageLexer.g:146:19: ( '%' | '//' ) (~ ( ( '\\n' | '\\r' ) ) )* ( ( '\\r' )? '\\n' )? | ||
1564 | { | ||
1565 | // InternalSolverLanguageLexer.g:146:19: ( '%' | '//' ) | ||
1566 | int alt3=2; | ||
1567 | int LA3_0 = input.LA(1); | ||
1568 | |||
1569 | if ( (LA3_0=='%') ) { | ||
1570 | alt3=1; | ||
1571 | } | ||
1572 | else if ( (LA3_0=='/') ) { | ||
1573 | alt3=2; | ||
1574 | } | ||
1575 | else { | ||
1576 | NoViableAltException nvae = | ||
1577 | new NoViableAltException("", 3, 0, input); | ||
1578 | |||
1579 | throw nvae; | ||
1580 | } | ||
1581 | switch (alt3) { | ||
1582 | case 1 : | ||
1583 | // InternalSolverLanguageLexer.g:146:20: '%' | ||
1584 | { | ||
1585 | match('%'); | ||
1586 | |||
1587 | } | ||
1588 | break; | ||
1589 | case 2 : | ||
1590 | // InternalSolverLanguageLexer.g:146:24: '//' | ||
1591 | { | ||
1592 | match("//"); | ||
1593 | |||
1594 | |||
1595 | } | ||
1596 | break; | ||
1597 | |||
1598 | } | ||
1599 | |||
1600 | // InternalSolverLanguageLexer.g:146:30: (~ ( ( '\\n' | '\\r' ) ) )* | ||
1601 | loop4: | ||
1602 | do { | ||
1603 | int alt4=2; | ||
1604 | int LA4_0 = input.LA(1); | ||
1605 | |||
1606 | if ( ((LA4_0>='\u0000' && LA4_0<='\t')||(LA4_0>='\u000B' && LA4_0<='\f')||(LA4_0>='\u000E' && LA4_0<='\uFFFF')) ) { | ||
1607 | alt4=1; | ||
1608 | } | ||
1609 | |||
1610 | |||
1611 | switch (alt4) { | ||
1612 | case 1 : | ||
1613 | // InternalSolverLanguageLexer.g:146:30: ~ ( ( '\\n' | '\\r' ) ) | ||
1614 | { | ||
1615 | 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') ) { | ||
1616 | input.consume(); | ||
1617 | |||
1618 | } | ||
1619 | else { | ||
1620 | MismatchedSetException mse = new MismatchedSetException(null,input); | ||
1621 | recover(mse); | ||
1622 | throw mse;} | ||
1623 | |||
1624 | |||
1625 | } | ||
1626 | break; | ||
1627 | |||
1628 | default : | ||
1629 | break loop4; | ||
1630 | } | ||
1631 | } while (true); | ||
1632 | |||
1633 | // InternalSolverLanguageLexer.g:146:46: ( ( '\\r' )? '\\n' )? | ||
1634 | int alt6=2; | ||
1635 | int LA6_0 = input.LA(1); | ||
1636 | |||
1637 | if ( (LA6_0=='\n'||LA6_0=='\r') ) { | ||
1638 | alt6=1; | ||
1639 | } | ||
1640 | switch (alt6) { | ||
1641 | case 1 : | ||
1642 | // InternalSolverLanguageLexer.g:146:47: ( '\\r' )? '\\n' | ||
1643 | { | ||
1644 | // InternalSolverLanguageLexer.g:146:47: ( '\\r' )? | ||
1645 | int alt5=2; | ||
1646 | int LA5_0 = input.LA(1); | ||
1647 | |||
1648 | if ( (LA5_0=='\r') ) { | ||
1649 | alt5=1; | ||
1650 | } | ||
1651 | switch (alt5) { | ||
1652 | case 1 : | ||
1653 | // InternalSolverLanguageLexer.g:146:47: '\\r' | ||
1654 | { | ||
1655 | match('\r'); | ||
1656 | |||
1657 | } | ||
1658 | break; | ||
1659 | |||
1660 | } | ||
1661 | |||
1662 | match('\n'); | ||
1663 | |||
1664 | } | ||
1665 | break; | ||
1666 | |||
1667 | } | ||
1668 | |||
1669 | |||
1670 | } | ||
1671 | |||
1672 | state.type = _type; | ||
1673 | state.channel = _channel; | ||
1674 | } | ||
1675 | finally { | ||
1676 | } | ||
1677 | } | ||
1678 | // $ANTLR end "RULE_SL_COMMENT" | ||
1679 | |||
1680 | // $ANTLR start "RULE_TRANSITIVE_CLOSURE" | ||
1681 | public final void mRULE_TRANSITIVE_CLOSURE() throws RecognitionException { | ||
1682 | try { | ||
1683 | // InternalSolverLanguageLexer.g:148:34: () | ||
1684 | // InternalSolverLanguageLexer.g:148:36: | ||
1685 | { | ||
1686 | } | ||
1687 | |||
1688 | } | ||
1689 | finally { | ||
1690 | } | ||
1691 | } | ||
1692 | // $ANTLR end "RULE_TRANSITIVE_CLOSURE" | ||
1693 | |||
1694 | // $ANTLR start "RULE_REFLEXIVE_TRANSITIVE_CLOSURE" | ||
1695 | public final void mRULE_REFLEXIVE_TRANSITIVE_CLOSURE() throws RecognitionException { | ||
1696 | try { | ||
1697 | // InternalSolverLanguageLexer.g:150:44: () | ||
1698 | // InternalSolverLanguageLexer.g:150:46: | ||
1699 | { | ||
1700 | } | ||
1701 | |||
1702 | } | ||
1703 | finally { | ||
1704 | } | ||
1705 | } | ||
1706 | // $ANTLR end "RULE_REFLEXIVE_TRANSITIVE_CLOSURE" | ||
1707 | |||
1708 | // $ANTLR start "RULE_FULL_STOP" | ||
1709 | public final void mRULE_FULL_STOP() throws RecognitionException { | ||
1710 | try { | ||
1711 | // InternalSolverLanguageLexer.g:152:25: () | ||
1712 | // InternalSolverLanguageLexer.g:152:27: | ||
1713 | { | ||
1714 | } | ||
1715 | |||
1716 | } | ||
1717 | finally { | ||
1718 | } | ||
1719 | } | ||
1720 | // $ANTLR end "RULE_FULL_STOP" | ||
1721 | |||
1722 | // $ANTLR start "RULE_ID" | ||
1723 | public final void mRULE_ID() throws RecognitionException { | ||
1724 | try { | ||
1725 | int _type = RULE_ID; | ||
1726 | int _channel = DEFAULT_TOKEN_CHANNEL; | ||
1727 | // InternalSolverLanguageLexer.g:154:9: ( ( '^' )? ( 'a' .. 'z' | 'A' .. 'Z' | '_' ) ( 'a' .. 'z' | 'A' .. 'Z' | '_' | '0' .. '9' )* ) | ||
1728 | // InternalSolverLanguageLexer.g:154:11: ( '^' )? ( 'a' .. 'z' | 'A' .. 'Z' | '_' ) ( 'a' .. 'z' | 'A' .. 'Z' | '_' | '0' .. '9' )* | ||
1729 | { | ||
1730 | // InternalSolverLanguageLexer.g:154:11: ( '^' )? | ||
1731 | int alt7=2; | ||
1732 | int LA7_0 = input.LA(1); | ||
1733 | |||
1734 | if ( (LA7_0=='^') ) { | ||
1735 | alt7=1; | ||
1736 | } | ||
1737 | switch (alt7) { | ||
1738 | case 1 : | ||
1739 | // InternalSolverLanguageLexer.g:154:11: '^' | ||
1740 | { | ||
1741 | match('^'); | ||
1742 | |||
1743 | } | ||
1744 | break; | ||
1745 | |||
1746 | } | ||
1747 | |||
1748 | if ( (input.LA(1)>='A' && input.LA(1)<='Z')||input.LA(1)=='_'||(input.LA(1)>='a' && input.LA(1)<='z') ) { | ||
1749 | input.consume(); | ||
1750 | |||
1751 | } | ||
1752 | else { | ||
1753 | MismatchedSetException mse = new MismatchedSetException(null,input); | ||
1754 | recover(mse); | ||
1755 | throw mse;} | ||
1756 | |||
1757 | // InternalSolverLanguageLexer.g:154:40: ( 'a' .. 'z' | 'A' .. 'Z' | '_' | '0' .. '9' )* | ||
1758 | loop8: | ||
1759 | do { | ||
1760 | int alt8=2; | ||
1761 | int LA8_0 = input.LA(1); | ||
1762 | |||
1763 | if ( ((LA8_0>='0' && LA8_0<='9')||(LA8_0>='A' && LA8_0<='Z')||LA8_0=='_'||(LA8_0>='a' && LA8_0<='z')) ) { | ||
1764 | alt8=1; | ||
1765 | } | ||
1766 | |||
1767 | |||
1768 | switch (alt8) { | ||
1769 | case 1 : | ||
1770 | // InternalSolverLanguageLexer.g: | ||
1771 | { | ||
1772 | 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') ) { | ||
1773 | input.consume(); | ||
1774 | |||
1775 | } | ||
1776 | else { | ||
1777 | MismatchedSetException mse = new MismatchedSetException(null,input); | ||
1778 | recover(mse); | ||
1779 | throw mse;} | ||
1780 | |||
1781 | |||
1782 | } | ||
1783 | break; | ||
1784 | |||
1785 | default : | ||
1786 | break loop8; | ||
1787 | } | ||
1788 | } while (true); | ||
1789 | |||
1790 | |||
1791 | } | ||
1792 | |||
1793 | state.type = _type; | ||
1794 | state.channel = _channel; | ||
1795 | } | ||
1796 | finally { | ||
1797 | } | ||
1798 | } | ||
1799 | // $ANTLR end "RULE_ID" | ||
1800 | |||
1801 | // $ANTLR start "RULE_INT" | ||
1802 | public final void mRULE_INT() throws RecognitionException { | ||
1803 | try { | ||
1804 | int _type = RULE_INT; | ||
1805 | int _channel = DEFAULT_TOKEN_CHANNEL; | ||
1806 | // InternalSolverLanguageLexer.g:156:10: ( ( '0' .. '9' )+ ) | ||
1807 | // InternalSolverLanguageLexer.g:156:12: ( '0' .. '9' )+ | ||
1808 | { | ||
1809 | // InternalSolverLanguageLexer.g:156:12: ( '0' .. '9' )+ | ||
1810 | int cnt9=0; | ||
1811 | loop9: | ||
1812 | do { | ||
1813 | int alt9=2; | ||
1814 | int LA9_0 = input.LA(1); | ||
1815 | |||
1816 | if ( ((LA9_0>='0' && LA9_0<='9')) ) { | ||
1817 | alt9=1; | ||
1818 | } | ||
1819 | |||
1820 | |||
1821 | switch (alt9) { | ||
1822 | case 1 : | ||
1823 | // InternalSolverLanguageLexer.g:156:13: '0' .. '9' | ||
1824 | { | ||
1825 | matchRange('0','9'); | ||
1826 | |||
1827 | } | ||
1828 | break; | ||
1829 | |||
1830 | default : | ||
1831 | if ( cnt9 >= 1 ) break loop9; | ||
1832 | EarlyExitException eee = | ||
1833 | new EarlyExitException(9, input); | ||
1834 | throw eee; | ||
1835 | } | ||
1836 | cnt9++; | ||
1837 | } while (true); | ||
1838 | |||
1839 | |||
1840 | } | ||
1841 | |||
1842 | state.type = _type; | ||
1843 | state.channel = _channel; | ||
1844 | } | ||
1845 | finally { | ||
1846 | } | ||
1847 | } | ||
1848 | // $ANTLR end "RULE_INT" | ||
1849 | |||
1850 | // $ANTLR start "RULE_ML_COMMENT" | ||
1851 | public final void mRULE_ML_COMMENT() throws RecognitionException { | ||
1852 | try { | ||
1853 | int _type = RULE_ML_COMMENT; | ||
1854 | int _channel = DEFAULT_TOKEN_CHANNEL; | ||
1855 | // InternalSolverLanguageLexer.g:158:17: ( '/*' ( options {greedy=false; } : . )* '*/' ) | ||
1856 | // InternalSolverLanguageLexer.g:158:19: '/*' ( options {greedy=false; } : . )* '*/' | ||
1857 | { | ||
1858 | match("/*"); | ||
1859 | |||
1860 | // InternalSolverLanguageLexer.g:158:24: ( options {greedy=false; } : . )* | ||
1861 | loop10: | ||
1862 | do { | ||
1863 | int alt10=2; | ||
1864 | int LA10_0 = input.LA(1); | ||
1865 | |||
1866 | if ( (LA10_0=='*') ) { | ||
1867 | int LA10_1 = input.LA(2); | ||
1868 | |||
1869 | if ( (LA10_1=='/') ) { | ||
1870 | alt10=2; | ||
1871 | } | ||
1872 | else if ( ((LA10_1>='\u0000' && LA10_1<='.')||(LA10_1>='0' && LA10_1<='\uFFFF')) ) { | ||
1873 | alt10=1; | ||
1874 | } | ||
1875 | |||
1876 | |||
1877 | } | ||
1878 | else if ( ((LA10_0>='\u0000' && LA10_0<=')')||(LA10_0>='+' && LA10_0<='\uFFFF')) ) { | ||
1879 | alt10=1; | ||
1880 | } | ||
1881 | |||
1882 | |||
1883 | switch (alt10) { | ||
1884 | case 1 : | ||
1885 | // InternalSolverLanguageLexer.g:158:52: . | ||
1886 | { | ||
1887 | matchAny(); | ||
1888 | |||
1889 | } | ||
1890 | break; | ||
1891 | |||
1892 | default : | ||
1893 | break loop10; | ||
1894 | } | ||
1895 | } while (true); | ||
1896 | |||
1897 | match("*/"); | ||
1898 | |||
1899 | |||
1900 | } | ||
1901 | |||
1902 | state.type = _type; | ||
1903 | state.channel = _channel; | ||
1904 | } | ||
1905 | finally { | ||
1906 | } | ||
1907 | } | ||
1908 | // $ANTLR end "RULE_ML_COMMENT" | ||
1909 | |||
1910 | // $ANTLR start "RULE_WS" | ||
1911 | public final void mRULE_WS() throws RecognitionException { | ||
1912 | try { | ||
1913 | int _type = RULE_WS; | ||
1914 | int _channel = DEFAULT_TOKEN_CHANNEL; | ||
1915 | // InternalSolverLanguageLexer.g:160:9: ( ( ' ' | '\\t' | '\\r' | '\\n' )+ ) | ||
1916 | // InternalSolverLanguageLexer.g:160:11: ( ' ' | '\\t' | '\\r' | '\\n' )+ | ||
1917 | { | ||
1918 | // InternalSolverLanguageLexer.g:160:11: ( ' ' | '\\t' | '\\r' | '\\n' )+ | ||
1919 | int cnt11=0; | ||
1920 | loop11: | ||
1921 | do { | ||
1922 | int alt11=2; | ||
1923 | int LA11_0 = input.LA(1); | ||
1924 | |||
1925 | if ( ((LA11_0>='\t' && LA11_0<='\n')||LA11_0=='\r'||LA11_0==' ') ) { | ||
1926 | alt11=1; | ||
1927 | } | ||
1928 | |||
1929 | |||
1930 | switch (alt11) { | ||
1931 | case 1 : | ||
1932 | // InternalSolverLanguageLexer.g: | ||
1933 | { | ||
1934 | if ( (input.LA(1)>='\t' && input.LA(1)<='\n')||input.LA(1)=='\r'||input.LA(1)==' ' ) { | ||
1935 | input.consume(); | ||
1936 | |||
1937 | } | ||
1938 | else { | ||
1939 | MismatchedSetException mse = new MismatchedSetException(null,input); | ||
1940 | recover(mse); | ||
1941 | throw mse;} | ||
1942 | |||
1943 | |||
1944 | } | ||
1945 | break; | ||
1946 | |||
1947 | default : | ||
1948 | if ( cnt11 >= 1 ) break loop11; | ||
1949 | EarlyExitException eee = | ||
1950 | new EarlyExitException(11, input); | ||
1951 | throw eee; | ||
1952 | } | ||
1953 | cnt11++; | ||
1954 | } while (true); | ||
1955 | |||
1956 | |||
1957 | } | ||
1958 | |||
1959 | state.type = _type; | ||
1960 | state.channel = _channel; | ||
1961 | } | ||
1962 | finally { | ||
1963 | } | ||
1964 | } | ||
1965 | // $ANTLR end "RULE_WS" | ||
1966 | |||
1967 | // $ANTLR start "RULE_ANY_OTHER" | ||
1968 | public final void mRULE_ANY_OTHER() throws RecognitionException { | ||
1969 | try { | ||
1970 | int _type = RULE_ANY_OTHER; | ||
1971 | int _channel = DEFAULT_TOKEN_CHANNEL; | ||
1972 | // InternalSolverLanguageLexer.g:162:16: ( . ) | ||
1973 | // InternalSolverLanguageLexer.g:162:18: . | ||
1974 | { | ||
1975 | matchAny(); | ||
1976 | |||
1977 | } | ||
1978 | |||
1979 | state.type = _type; | ||
1980 | state.channel = _channel; | ||
1981 | } | ||
1982 | finally { | ||
1983 | } | ||
1984 | } | ||
1985 | // $ANTLR end "RULE_ANY_OTHER" | ||
1986 | |||
1987 | public void mTokens() throws RecognitionException { | ||
1988 | // InternalSolverLanguageLexer.g:1:8: ( Containment | Functional | Abstract | Contains | Datatype | Maximize | Minimize | Opposite | Default | Extends | Problem | Unknown | Extern | Import | Object | Refers | Class | Count | Empty | Error | False | Scope | Else | Enum | Root | Then | True | FullStopFullStopFullStop | Inf | Let | ExclamationMarkEqualsSign | HyphenMinusGreaterThanSign | ColonHyphenMinus | ColonColon | ColonEqualsSign | LessThanSignEqualsSign | EqualsSignEqualsSign | EqualsSignGreaterThanSign | GreaterThanSignEqualsSign | As | If | In | ExclamationMark | LeftParenthesis | RightParenthesis | Asterisk | PlusSign | Comma | HyphenMinus | FullStop | Solidus | Colon | Semicolon | LessThanSign | EqualsSign | GreaterThanSign | QuestionMark | LeftSquareBracket | RightSquareBracket | CircumflexAccent | LeftCurlyBracket | VerticalLine | RightCurlyBracket | Tilde | RULE_STRING | RULE_QUOTED_ID | RULE_SL_COMMENT | RULE_ID | RULE_INT | RULE_ML_COMMENT | RULE_WS | RULE_ANY_OTHER ) | ||
1989 | int alt12=72; | ||
1990 | alt12 = dfa12.predict(input); | ||
1991 | switch (alt12) { | ||
1992 | case 1 : | ||
1993 | // InternalSolverLanguageLexer.g:1:10: Containment | ||
1994 | { | ||
1995 | mContainment(); | ||
1996 | |||
1997 | } | ||
1998 | break; | ||
1999 | case 2 : | ||
2000 | // InternalSolverLanguageLexer.g:1:22: Functional | ||
2001 | { | ||
2002 | mFunctional(); | ||
2003 | |||
2004 | } | ||
2005 | break; | ||
2006 | case 3 : | ||
2007 | // InternalSolverLanguageLexer.g:1:33: Abstract | ||
2008 | { | ||
2009 | mAbstract(); | ||
2010 | |||
2011 | } | ||
2012 | break; | ||
2013 | case 4 : | ||
2014 | // InternalSolverLanguageLexer.g:1:42: Contains | ||
2015 | { | ||
2016 | mContains(); | ||
2017 | |||
2018 | } | ||
2019 | break; | ||
2020 | case 5 : | ||
2021 | // InternalSolverLanguageLexer.g:1:51: Datatype | ||
2022 | { | ||
2023 | mDatatype(); | ||
2024 | |||
2025 | } | ||
2026 | break; | ||
2027 | case 6 : | ||
2028 | // InternalSolverLanguageLexer.g:1:60: Maximize | ||
2029 | { | ||
2030 | mMaximize(); | ||
2031 | |||
2032 | } | ||
2033 | break; | ||
2034 | case 7 : | ||
2035 | // InternalSolverLanguageLexer.g:1:69: Minimize | ||
2036 | { | ||
2037 | mMinimize(); | ||
2038 | |||
2039 | } | ||
2040 | break; | ||
2041 | case 8 : | ||
2042 | // InternalSolverLanguageLexer.g:1:78: Opposite | ||
2043 | { | ||
2044 | mOpposite(); | ||
2045 | |||
2046 | } | ||
2047 | break; | ||
2048 | case 9 : | ||
2049 | // InternalSolverLanguageLexer.g:1:87: Default | ||
2050 | { | ||
2051 | mDefault(); | ||
2052 | |||
2053 | } | ||
2054 | break; | ||
2055 | case 10 : | ||
2056 | // InternalSolverLanguageLexer.g:1:95: Extends | ||
2057 | { | ||
2058 | mExtends(); | ||
2059 | |||
2060 | } | ||
2061 | break; | ||
2062 | case 11 : | ||
2063 | // InternalSolverLanguageLexer.g:1:103: Problem | ||
2064 | { | ||
2065 | mProblem(); | ||
2066 | |||
2067 | } | ||
2068 | break; | ||
2069 | case 12 : | ||
2070 | // InternalSolverLanguageLexer.g:1:111: Unknown | ||
2071 | { | ||
2072 | mUnknown(); | ||
2073 | |||
2074 | } | ||
2075 | break; | ||
2076 | case 13 : | ||
2077 | // InternalSolverLanguageLexer.g:1:119: Extern | ||
2078 | { | ||
2079 | mExtern(); | ||
2080 | |||
2081 | } | ||
2082 | break; | ||
2083 | case 14 : | ||
2084 | // InternalSolverLanguageLexer.g:1:126: Import | ||
2085 | { | ||
2086 | mImport(); | ||
2087 | |||
2088 | } | ||
2089 | break; | ||
2090 | case 15 : | ||
2091 | // InternalSolverLanguageLexer.g:1:133: Object | ||
2092 | { | ||
2093 | mObject(); | ||
2094 | |||
2095 | } | ||
2096 | break; | ||
2097 | case 16 : | ||
2098 | // InternalSolverLanguageLexer.g:1:140: Refers | ||
2099 | { | ||
2100 | mRefers(); | ||
2101 | |||
2102 | } | ||
2103 | break; | ||
2104 | case 17 : | ||
2105 | // InternalSolverLanguageLexer.g:1:147: Class | ||
2106 | { | ||
2107 | mClass(); | ||
2108 | |||
2109 | } | ||
2110 | break; | ||
2111 | case 18 : | ||
2112 | // InternalSolverLanguageLexer.g:1:153: Count | ||
2113 | { | ||
2114 | mCount(); | ||
2115 | |||
2116 | } | ||
2117 | break; | ||
2118 | case 19 : | ||
2119 | // InternalSolverLanguageLexer.g:1:159: Empty | ||
2120 | { | ||
2121 | mEmpty(); | ||
2122 | |||
2123 | } | ||
2124 | break; | ||
2125 | case 20 : | ||
2126 | // InternalSolverLanguageLexer.g:1:165: Error | ||
2127 | { | ||
2128 | mError(); | ||
2129 | |||
2130 | } | ||
2131 | break; | ||
2132 | case 21 : | ||
2133 | // InternalSolverLanguageLexer.g:1:171: False | ||
2134 | { | ||
2135 | mFalse(); | ||
2136 | |||
2137 | } | ||
2138 | break; | ||
2139 | case 22 : | ||
2140 | // InternalSolverLanguageLexer.g:1:177: Scope | ||
2141 | { | ||
2142 | mScope(); | ||
2143 | |||
2144 | } | ||
2145 | break; | ||
2146 | case 23 : | ||
2147 | // InternalSolverLanguageLexer.g:1:183: Else | ||
2148 | { | ||
2149 | mElse(); | ||
2150 | |||
2151 | } | ||
2152 | break; | ||
2153 | case 24 : | ||
2154 | // InternalSolverLanguageLexer.g:1:188: Enum | ||
2155 | { | ||
2156 | mEnum(); | ||
2157 | |||
2158 | } | ||
2159 | break; | ||
2160 | case 25 : | ||
2161 | // InternalSolverLanguageLexer.g:1:193: Root | ||
2162 | { | ||
2163 | mRoot(); | ||
2164 | |||
2165 | } | ||
2166 | break; | ||
2167 | case 26 : | ||
2168 | // InternalSolverLanguageLexer.g:1:198: Then | ||
2169 | { | ||
2170 | mThen(); | ||
2171 | |||
2172 | } | ||
2173 | break; | ||
2174 | case 27 : | ||
2175 | // InternalSolverLanguageLexer.g:1:203: True | ||
2176 | { | ||
2177 | mTrue(); | ||
2178 | |||
2179 | } | ||
2180 | break; | ||
2181 | case 28 : | ||
2182 | // InternalSolverLanguageLexer.g:1:208: FullStopFullStopFullStop | ||
2183 | { | ||
2184 | mFullStopFullStopFullStop(); | ||
2185 | |||
2186 | } | ||
2187 | break; | ||
2188 | case 29 : | ||
2189 | // InternalSolverLanguageLexer.g:1:233: Inf | ||
2190 | { | ||
2191 | mInf(); | ||
2192 | |||
2193 | } | ||
2194 | break; | ||
2195 | case 30 : | ||
2196 | // InternalSolverLanguageLexer.g:1:237: Let | ||
2197 | { | ||
2198 | mLet(); | ||
2199 | |||
2200 | } | ||
2201 | break; | ||
2202 | case 31 : | ||
2203 | // InternalSolverLanguageLexer.g:1:241: ExclamationMarkEqualsSign | ||
2204 | { | ||
2205 | mExclamationMarkEqualsSign(); | ||
2206 | |||
2207 | } | ||
2208 | break; | ||
2209 | case 32 : | ||
2210 | // InternalSolverLanguageLexer.g:1:267: HyphenMinusGreaterThanSign | ||
2211 | { | ||
2212 | mHyphenMinusGreaterThanSign(); | ||
2213 | |||
2214 | } | ||
2215 | break; | ||
2216 | case 33 : | ||
2217 | // InternalSolverLanguageLexer.g:1:294: ColonHyphenMinus | ||
2218 | { | ||
2219 | mColonHyphenMinus(); | ||
2220 | |||
2221 | } | ||
2222 | break; | ||
2223 | case 34 : | ||
2224 | // InternalSolverLanguageLexer.g:1:311: ColonColon | ||
2225 | { | ||
2226 | mColonColon(); | ||
2227 | |||
2228 | } | ||
2229 | break; | ||
2230 | case 35 : | ||
2231 | // InternalSolverLanguageLexer.g:1:322: ColonEqualsSign | ||
2232 | { | ||
2233 | mColonEqualsSign(); | ||
2234 | |||
2235 | } | ||
2236 | break; | ||
2237 | case 36 : | ||
2238 | // InternalSolverLanguageLexer.g:1:338: LessThanSignEqualsSign | ||
2239 | { | ||
2240 | mLessThanSignEqualsSign(); | ||
2241 | |||
2242 | } | ||
2243 | break; | ||
2244 | case 37 : | ||
2245 | // InternalSolverLanguageLexer.g:1:361: EqualsSignEqualsSign | ||
2246 | { | ||
2247 | mEqualsSignEqualsSign(); | ||
2248 | |||
2249 | } | ||
2250 | break; | ||
2251 | case 38 : | ||
2252 | // InternalSolverLanguageLexer.g:1:382: EqualsSignGreaterThanSign | ||
2253 | { | ||
2254 | mEqualsSignGreaterThanSign(); | ||
2255 | |||
2256 | } | ||
2257 | break; | ||
2258 | case 39 : | ||
2259 | // InternalSolverLanguageLexer.g:1:408: GreaterThanSignEqualsSign | ||
2260 | { | ||
2261 | mGreaterThanSignEqualsSign(); | ||
2262 | |||
2263 | } | ||
2264 | break; | ||
2265 | case 40 : | ||
2266 | // InternalSolverLanguageLexer.g:1:434: As | ||
2267 | { | ||
2268 | mAs(); | ||
2269 | |||
2270 | } | ||
2271 | break; | ||
2272 | case 41 : | ||
2273 | // InternalSolverLanguageLexer.g:1:437: If | ||
2274 | { | ||
2275 | mIf(); | ||
2276 | |||
2277 | } | ||
2278 | break; | ||
2279 | case 42 : | ||
2280 | // InternalSolverLanguageLexer.g:1:440: In | ||
2281 | { | ||
2282 | mIn(); | ||
2283 | |||
2284 | } | ||
2285 | break; | ||
2286 | case 43 : | ||
2287 | // InternalSolverLanguageLexer.g:1:443: ExclamationMark | ||
2288 | { | ||
2289 | mExclamationMark(); | ||
2290 | |||
2291 | } | ||
2292 | break; | ||
2293 | case 44 : | ||
2294 | // InternalSolverLanguageLexer.g:1:459: LeftParenthesis | ||
2295 | { | ||
2296 | mLeftParenthesis(); | ||
2297 | |||
2298 | } | ||
2299 | break; | ||
2300 | case 45 : | ||
2301 | // InternalSolverLanguageLexer.g:1:475: RightParenthesis | ||
2302 | { | ||
2303 | mRightParenthesis(); | ||
2304 | |||
2305 | } | ||
2306 | break; | ||
2307 | case 46 : | ||
2308 | // InternalSolverLanguageLexer.g:1:492: Asterisk | ||
2309 | { | ||
2310 | mAsterisk(); | ||
2311 | |||
2312 | } | ||
2313 | break; | ||
2314 | case 47 : | ||
2315 | // InternalSolverLanguageLexer.g:1:501: PlusSign | ||
2316 | { | ||
2317 | mPlusSign(); | ||
2318 | |||
2319 | } | ||
2320 | break; | ||
2321 | case 48 : | ||
2322 | // InternalSolverLanguageLexer.g:1:510: Comma | ||
2323 | { | ||
2324 | mComma(); | ||
2325 | |||
2326 | } | ||
2327 | break; | ||
2328 | case 49 : | ||
2329 | // InternalSolverLanguageLexer.g:1:516: HyphenMinus | ||
2330 | { | ||
2331 | mHyphenMinus(); | ||
2332 | |||
2333 | } | ||
2334 | break; | ||
2335 | case 50 : | ||
2336 | // InternalSolverLanguageLexer.g:1:528: FullStop | ||
2337 | { | ||
2338 | mFullStop(); | ||
2339 | |||
2340 | } | ||
2341 | break; | ||
2342 | case 51 : | ||
2343 | // InternalSolverLanguageLexer.g:1:537: Solidus | ||
2344 | { | ||
2345 | mSolidus(); | ||
2346 | |||
2347 | } | ||
2348 | break; | ||
2349 | case 52 : | ||
2350 | // InternalSolverLanguageLexer.g:1:545: Colon | ||
2351 | { | ||
2352 | mColon(); | ||
2353 | |||
2354 | } | ||
2355 | break; | ||
2356 | case 53 : | ||
2357 | // InternalSolverLanguageLexer.g:1:551: Semicolon | ||
2358 | { | ||
2359 | mSemicolon(); | ||
2360 | |||
2361 | } | ||
2362 | break; | ||
2363 | case 54 : | ||
2364 | // InternalSolverLanguageLexer.g:1:561: LessThanSign | ||
2365 | { | ||
2366 | mLessThanSign(); | ||
2367 | |||
2368 | } | ||
2369 | break; | ||
2370 | case 55 : | ||
2371 | // InternalSolverLanguageLexer.g:1:574: EqualsSign | ||
2372 | { | ||
2373 | mEqualsSign(); | ||
2374 | |||
2375 | } | ||
2376 | break; | ||
2377 | case 56 : | ||
2378 | // InternalSolverLanguageLexer.g:1:585: GreaterThanSign | ||
2379 | { | ||
2380 | mGreaterThanSign(); | ||
2381 | |||
2382 | } | ||
2383 | break; | ||
2384 | case 57 : | ||
2385 | // InternalSolverLanguageLexer.g:1:601: QuestionMark | ||
2386 | { | ||
2387 | mQuestionMark(); | ||
2388 | |||
2389 | } | ||
2390 | break; | ||
2391 | case 58 : | ||
2392 | // InternalSolverLanguageLexer.g:1:614: LeftSquareBracket | ||
2393 | { | ||
2394 | mLeftSquareBracket(); | ||
2395 | |||
2396 | } | ||
2397 | break; | ||
2398 | case 59 : | ||
2399 | // InternalSolverLanguageLexer.g:1:632: RightSquareBracket | ||
2400 | { | ||
2401 | mRightSquareBracket(); | ||
2402 | |||
2403 | } | ||
2404 | break; | ||
2405 | case 60 : | ||
2406 | // InternalSolverLanguageLexer.g:1:651: CircumflexAccent | ||
2407 | { | ||
2408 | mCircumflexAccent(); | ||
2409 | |||
2410 | } | ||
2411 | break; | ||
2412 | case 61 : | ||
2413 | // InternalSolverLanguageLexer.g:1:668: LeftCurlyBracket | ||
2414 | { | ||
2415 | mLeftCurlyBracket(); | ||
2416 | |||
2417 | } | ||
2418 | break; | ||
2419 | case 62 : | ||
2420 | // InternalSolverLanguageLexer.g:1:685: VerticalLine | ||
2421 | { | ||
2422 | mVerticalLine(); | ||
2423 | |||
2424 | } | ||
2425 | break; | ||
2426 | case 63 : | ||
2427 | // InternalSolverLanguageLexer.g:1:698: RightCurlyBracket | ||
2428 | { | ||
2429 | mRightCurlyBracket(); | ||
2430 | |||
2431 | } | ||
2432 | break; | ||
2433 | case 64 : | ||
2434 | // InternalSolverLanguageLexer.g:1:716: Tilde | ||
2435 | { | ||
2436 | mTilde(); | ||
2437 | |||
2438 | } | ||
2439 | break; | ||
2440 | case 65 : | ||
2441 | // InternalSolverLanguageLexer.g:1:722: RULE_STRING | ||
2442 | { | ||
2443 | mRULE_STRING(); | ||
2444 | |||
2445 | } | ||
2446 | break; | ||
2447 | case 66 : | ||
2448 | // InternalSolverLanguageLexer.g:1:734: RULE_QUOTED_ID | ||
2449 | { | ||
2450 | mRULE_QUOTED_ID(); | ||
2451 | |||
2452 | } | ||
2453 | break; | ||
2454 | case 67 : | ||
2455 | // InternalSolverLanguageLexer.g:1:749: RULE_SL_COMMENT | ||
2456 | { | ||
2457 | mRULE_SL_COMMENT(); | ||
2458 | |||
2459 | } | ||
2460 | break; | ||
2461 | case 68 : | ||
2462 | // InternalSolverLanguageLexer.g:1:765: RULE_ID | ||
2463 | { | ||
2464 | mRULE_ID(); | ||
2465 | |||
2466 | } | ||
2467 | break; | ||
2468 | case 69 : | ||
2469 | // InternalSolverLanguageLexer.g:1:773: RULE_INT | ||
2470 | { | ||
2471 | mRULE_INT(); | ||
2472 | |||
2473 | } | ||
2474 | break; | ||
2475 | case 70 : | ||
2476 | // InternalSolverLanguageLexer.g:1:782: RULE_ML_COMMENT | ||
2477 | { | ||
2478 | mRULE_ML_COMMENT(); | ||
2479 | |||
2480 | } | ||
2481 | break; | ||
2482 | case 71 : | ||
2483 | // InternalSolverLanguageLexer.g:1:798: RULE_WS | ||
2484 | { | ||
2485 | mRULE_WS(); | ||
2486 | |||
2487 | } | ||
2488 | break; | ||
2489 | case 72 : | ||
2490 | // InternalSolverLanguageLexer.g:1:806: RULE_ANY_OTHER | ||
2491 | { | ||
2492 | mRULE_ANY_OTHER(); | ||
2493 | |||
2494 | } | ||
2495 | break; | ||
2496 | |||
2497 | } | ||
2498 | |||
2499 | } | ||
2500 | |||
2501 | |||
2502 | protected DFA12 dfa12 = new DFA12(this); | ||
2503 | static final String DFA12_eotS = | ||
2504 | "\1\uffff\15\56\1\111\1\56\1\114\1\116\1\122\1\124\1\127\1\131\5\uffff\1\141\4\uffff\1\146\4\uffff\2\53\5\uffff\2\56\1\uffff\3\56\1\165\16\56\1\u0085\1\u0086\5\56\2\uffff\1\56\44\uffff\6\56\1\uffff\16\56\1\u00a1\2\uffff\5\56\1\u00a7\17\56\1\u00b8\1\u00b9\3\56\1\uffff\1\56\1\u00be\1\56\1\u00c0\1\u00c1\1\uffff\1\56\1\u00c3\1\u00c4\1\56\1\u00c6\11\56\1\u00d0\1\u00d1\2\uffff\4\56\1\uffff\1\u00d6\2\uffff\1\56\2\uffff\1\56\1\uffff\6\56\1\u00df\1\56\1\u00e1\2\uffff\2\56\1\u00e4\1\u00e5\1\uffff\4\56\1\u00eb\3\56\1\uffff\1\u00ef\1\uffff\1\u00f0\1\u00f1\2\uffff\1\56\1\u00f3\1\56\1\u00f5\1\u00f6\1\uffff\1\u00f7\1\u00f8\1\u00f9\3\uffff\1\56\1\uffff\1\56\5\uffff\1\56\1\u00fd\1\u00fe\2\uffff"; | ||
2505 | static final String DFA12_eofS = | ||
2506 | "\u00ff\uffff"; | ||
2507 | static final String DFA12_minS = | ||
2508 | "\1\0\1\154\1\141\1\142\2\141\1\142\1\154\1\162\1\156\1\146\1\145\1\143\1\150\1\56\1\145\1\75\1\76\1\55\3\75\5\uffff\1\52\4\uffff\1\101\4\uffff\2\0\5\uffff\1\156\1\141\1\uffff\1\156\1\154\1\163\1\60\1\164\1\146\1\170\1\156\1\160\1\152\1\164\1\160\1\162\1\163\1\165\1\157\1\153\1\160\2\60\1\146\2\157\1\145\1\165\2\uffff\1\164\44\uffff\1\164\1\156\1\163\1\143\1\163\1\164\1\uffff\2\141\2\151\1\157\2\145\1\164\1\157\1\145\1\155\1\142\1\156\1\157\1\60\2\uffff\1\145\1\164\1\160\1\156\1\145\1\60\1\141\1\164\1\163\1\164\1\145\1\162\1\164\1\165\2\155\1\163\1\143\1\156\1\171\1\162\2\60\1\154\1\157\1\162\1\uffff\1\162\1\60\1\145\2\60\1\uffff\1\151\2\60\1\151\1\60\1\141\1\171\1\154\3\151\1\164\1\144\1\156\2\60\2\uffff\1\145\1\167\1\164\1\163\1\uffff\1\60\2\uffff\1\156\2\uffff\1\157\1\uffff\1\143\1\160\1\164\2\172\1\164\1\60\1\163\1\60\2\uffff\1\155\1\156\2\60\1\uffff\1\155\1\156\1\164\1\145\1\60\3\145\1\uffff\1\60\1\uffff\2\60\2\uffff\1\145\1\60\1\141\2\60\1\uffff\3\60\3\uffff\1\156\1\uffff\1\154\5\uffff\1\164\2\60\2\uffff"; | ||
2509 | static final String DFA12_maxS = | ||
2510 | "\1\uffff\1\157\1\165\1\163\1\145\1\151\1\160\1\170\1\162\2\156\1\157\1\143\1\162\1\56\1\145\1\75\1\76\2\75\1\76\1\75\5\uffff\1\57\4\uffff\1\172\4\uffff\2\uffff\5\uffff\1\165\1\141\1\uffff\1\156\1\154\1\163\1\172\1\164\1\146\1\170\1\156\1\160\1\152\1\164\1\160\1\162\1\163\1\165\1\157\1\153\1\160\2\172\1\146\2\157\1\145\1\165\2\uffff\1\164\44\uffff\1\164\1\156\1\163\1\143\1\163\1\164\1\uffff\2\141\2\151\1\157\2\145\1\164\1\157\1\145\1\155\1\142\1\156\1\157\1\172\2\uffff\1\145\1\164\1\160\1\156\1\145\1\172\1\141\1\164\1\163\1\164\1\145\1\162\1\164\1\165\2\155\1\163\1\143\1\162\1\171\1\162\2\172\1\154\1\157\1\162\1\uffff\1\162\1\172\1\145\2\172\1\uffff\1\151\2\172\1\151\1\172\1\141\1\171\1\154\3\151\1\164\1\144\1\156\2\172\2\uffff\1\145\1\167\1\164\1\163\1\uffff\1\172\2\uffff\1\156\2\uffff\1\157\1\uffff\1\143\1\160\1\164\2\172\1\164\1\172\1\163\1\172\2\uffff\1\155\1\156\2\172\1\uffff\1\163\1\156\1\164\1\145\1\172\3\145\1\uffff\1\172\1\uffff\2\172\2\uffff\1\145\1\172\1\141\2\172\1\uffff\3\172\3\uffff\1\156\1\uffff\1\154\5\uffff\1\164\2\172\2\uffff"; | ||
2511 | static final String DFA12_acceptS = | ||
2512 | "\26\uffff\1\54\1\55\1\56\1\57\1\60\1\uffff\1\65\1\71\1\72\1\73\1\uffff\1\75\1\76\1\77\1\100\2\uffff\1\103\1\104\1\105\1\107\1\110\2\uffff\1\104\31\uffff\1\34\1\62\1\uffff\1\37\1\53\1\40\1\61\1\41\1\42\1\43\1\64\1\44\1\66\1\45\1\46\1\67\1\47\1\70\1\54\1\55\1\56\1\57\1\60\1\103\1\106\1\63\1\65\1\71\1\72\1\73\1\74\1\75\1\76\1\77\1\100\1\101\1\102\1\105\1\107\6\uffff\1\50\17\uffff\1\52\1\51\32\uffff\1\35\5\uffff\1\36\20\uffff\1\27\1\30\4\uffff\1\31\1\uffff\1\32\1\33\1\uffff\1\22\1\21\1\uffff\1\25\11\uffff\1\23\1\24\4\uffff\1\26\10\uffff\1\17\1\uffff\1\15\2\uffff\1\16\1\20\5\uffff\1\11\3\uffff\1\12\1\13\1\14\1\uffff\1\4\1\uffff\1\3\1\5\1\6\1\7\1\10\3\uffff\1\2\1\1"; | ||
2513 | static final String DFA12_specialS = | ||
2514 | "\1\1\44\uffff\1\0\1\2\u00d8\uffff}>"; | ||
2515 | static final String[] DFA12_transitionS = { | ||
2516 | "\11\53\2\52\2\53\1\52\22\53\1\52\1\20\1\45\2\53\1\47\1\53\1\46\1\26\1\27\1\30\1\31\1\32\1\21\1\16\1\33\12\51\1\22\1\34\1\23\1\24\1\25\1\35\1\53\32\50\1\36\1\53\1\37\1\40\1\50\1\53\1\3\1\50\1\1\1\4\1\7\1\2\2\50\1\12\2\50\1\17\1\5\1\50\1\6\1\10\1\50\1\13\1\14\1\15\1\11\5\50\1\41\1\42\1\43\1\44\uff81\53", | ||
2517 | "\1\55\2\uffff\1\54", | ||
2518 | "\1\60\23\uffff\1\57", | ||
2519 | "\1\61\20\uffff\1\62", | ||
2520 | "\1\63\3\uffff\1\64", | ||
2521 | "\1\65\7\uffff\1\66", | ||
2522 | "\1\70\15\uffff\1\67", | ||
2523 | "\1\74\1\72\1\75\3\uffff\1\73\5\uffff\1\71", | ||
2524 | "\1\76", | ||
2525 | "\1\77", | ||
2526 | "\1\102\6\uffff\1\100\1\101", | ||
2527 | "\1\103\11\uffff\1\104", | ||
2528 | "\1\105", | ||
2529 | "\1\106\11\uffff\1\107", | ||
2530 | "\1\110", | ||
2531 | "\1\112", | ||
2532 | "\1\113", | ||
2533 | "\1\115", | ||
2534 | "\1\117\14\uffff\1\120\2\uffff\1\121", | ||
2535 | "\1\123", | ||
2536 | "\1\125\1\126", | ||
2537 | "\1\130", | ||
2538 | "", | ||
2539 | "", | ||
2540 | "", | ||
2541 | "", | ||
2542 | "", | ||
2543 | "\1\140\4\uffff\1\137", | ||
2544 | "", | ||
2545 | "", | ||
2546 | "", | ||
2547 | "", | ||
2548 | "\32\56\4\uffff\1\56\1\uffff\32\56", | ||
2549 | "", | ||
2550 | "", | ||
2551 | "", | ||
2552 | "", | ||
2553 | "\0\153", | ||
2554 | "\0\154", | ||
2555 | "", | ||
2556 | "", | ||
2557 | "", | ||
2558 | "", | ||
2559 | "", | ||
2560 | "\1\157\6\uffff\1\160", | ||
2561 | "\1\161", | ||
2562 | "", | ||
2563 | "\1\162", | ||
2564 | "\1\163", | ||
2565 | "\1\164", | ||
2566 | "\12\56\7\uffff\32\56\4\uffff\1\56\1\uffff\32\56", | ||
2567 | "\1\166", | ||
2568 | "\1\167", | ||
2569 | "\1\170", | ||
2570 | "\1\171", | ||
2571 | "\1\172", | ||
2572 | "\1\173", | ||
2573 | "\1\174", | ||
2574 | "\1\175", | ||
2575 | "\1\176", | ||
2576 | "\1\177", | ||
2577 | "\1\u0080", | ||
2578 | "\1\u0081", | ||
2579 | "\1\u0082", | ||
2580 | "\1\u0083", | ||
2581 | "\12\56\7\uffff\32\56\4\uffff\1\56\1\uffff\5\56\1\u0084\24\56", | ||
2582 | "\12\56\7\uffff\32\56\4\uffff\1\56\1\uffff\32\56", | ||
2583 | "\1\u0087", | ||
2584 | "\1\u0088", | ||
2585 | "\1\u0089", | ||
2586 | "\1\u008a", | ||
2587 | "\1\u008b", | ||
2588 | "", | ||
2589 | "", | ||
2590 | "\1\u008c", | ||
2591 | "", | ||
2592 | "", | ||
2593 | "", | ||
2594 | "", | ||
2595 | "", | ||
2596 | "", | ||
2597 | "", | ||
2598 | "", | ||
2599 | "", | ||
2600 | "", | ||
2601 | "", | ||
2602 | "", | ||
2603 | "", | ||
2604 | "", | ||
2605 | "", | ||
2606 | "", | ||
2607 | "", | ||
2608 | "", | ||
2609 | "", | ||
2610 | "", | ||
2611 | "", | ||
2612 | "", | ||
2613 | "", | ||
2614 | "", | ||
2615 | "", | ||
2616 | "", | ||
2617 | "", | ||
2618 | "", | ||
2619 | "", | ||
2620 | "", | ||
2621 | "", | ||
2622 | "", | ||
2623 | "", | ||
2624 | "", | ||
2625 | "", | ||
2626 | "", | ||
2627 | "\1\u008d", | ||
2628 | "\1\u008e", | ||
2629 | "\1\u008f", | ||
2630 | "\1\u0090", | ||
2631 | "\1\u0091", | ||
2632 | "\1\u0092", | ||
2633 | "", | ||
2634 | "\1\u0093", | ||
2635 | "\1\u0094", | ||
2636 | "\1\u0095", | ||
2637 | "\1\u0096", | ||
2638 | "\1\u0097", | ||
2639 | "\1\u0098", | ||
2640 | "\1\u0099", | ||
2641 | "\1\u009a", | ||
2642 | "\1\u009b", | ||
2643 | "\1\u009c", | ||
2644 | "\1\u009d", | ||
2645 | "\1\u009e", | ||
2646 | "\1\u009f", | ||
2647 | "\1\u00a0", | ||
2648 | "\12\56\7\uffff\32\56\4\uffff\1\56\1\uffff\32\56", | ||
2649 | "", | ||
2650 | "", | ||
2651 | "\1\u00a2", | ||
2652 | "\1\u00a3", | ||
2653 | "\1\u00a4", | ||
2654 | "\1\u00a5", | ||
2655 | "\1\u00a6", | ||
2656 | "\12\56\7\uffff\32\56\4\uffff\1\56\1\uffff\32\56", | ||
2657 | "\1\u00a8", | ||
2658 | "\1\u00a9", | ||
2659 | "\1\u00aa", | ||
2660 | "\1\u00ab", | ||
2661 | "\1\u00ac", | ||
2662 | "\1\u00ad", | ||
2663 | "\1\u00ae", | ||
2664 | "\1\u00af", | ||
2665 | "\1\u00b0", | ||
2666 | "\1\u00b1", | ||
2667 | "\1\u00b2", | ||
2668 | "\1\u00b3", | ||
2669 | "\1\u00b4\3\uffff\1\u00b5", | ||
2670 | "\1\u00b6", | ||
2671 | "\1\u00b7", | ||
2672 | "\12\56\7\uffff\32\56\4\uffff\1\56\1\uffff\32\56", | ||
2673 | "\12\56\7\uffff\32\56\4\uffff\1\56\1\uffff\32\56", | ||
2674 | "\1\u00ba", | ||
2675 | "\1\u00bb", | ||
2676 | "\1\u00bc", | ||
2677 | "", | ||
2678 | "\1\u00bd", | ||
2679 | "\12\56\7\uffff\32\56\4\uffff\1\56\1\uffff\32\56", | ||
2680 | "\1\u00bf", | ||
2681 | "\12\56\7\uffff\32\56\4\uffff\1\56\1\uffff\32\56", | ||
2682 | "\12\56\7\uffff\32\56\4\uffff\1\56\1\uffff\32\56", | ||
2683 | "", | ||
2684 | "\1\u00c2", | ||
2685 | "\12\56\7\uffff\32\56\4\uffff\1\56\1\uffff\32\56", | ||
2686 | "\12\56\7\uffff\32\56\4\uffff\1\56\1\uffff\32\56", | ||
2687 | "\1\u00c5", | ||
2688 | "\12\56\7\uffff\32\56\4\uffff\1\56\1\uffff\32\56", | ||
2689 | "\1\u00c7", | ||
2690 | "\1\u00c8", | ||
2691 | "\1\u00c9", | ||
2692 | "\1\u00ca", | ||
2693 | "\1\u00cb", | ||
2694 | "\1\u00cc", | ||
2695 | "\1\u00cd", | ||
2696 | "\1\u00ce", | ||
2697 | "\1\u00cf", | ||
2698 | "\12\56\7\uffff\32\56\4\uffff\1\56\1\uffff\32\56", | ||
2699 | "\12\56\7\uffff\32\56\4\uffff\1\56\1\uffff\32\56", | ||
2700 | "", | ||
2701 | "", | ||
2702 | "\1\u00d2", | ||
2703 | "\1\u00d3", | ||
2704 | "\1\u00d4", | ||
2705 | "\1\u00d5", | ||
2706 | "", | ||
2707 | "\12\56\7\uffff\32\56\4\uffff\1\56\1\uffff\32\56", | ||
2708 | "", | ||
2709 | "", | ||
2710 | "\1\u00d7", | ||
2711 | "", | ||
2712 | "", | ||
2713 | "\1\u00d8", | ||
2714 | "", | ||
2715 | "\1\u00d9", | ||
2716 | "\1\u00da", | ||
2717 | "\1\u00db", | ||
2718 | "\1\u00dc", | ||
2719 | "\1\u00dd", | ||
2720 | "\1\u00de", | ||
2721 | "\12\56\7\uffff\32\56\4\uffff\1\56\1\uffff\32\56", | ||
2722 | "\1\u00e0", | ||
2723 | "\12\56\7\uffff\32\56\4\uffff\1\56\1\uffff\32\56", | ||
2724 | "", | ||
2725 | "", | ||
2726 | "\1\u00e2", | ||
2727 | "\1\u00e3", | ||
2728 | "\12\56\7\uffff\32\56\4\uffff\1\56\1\uffff\32\56", | ||
2729 | "\12\56\7\uffff\32\56\4\uffff\1\56\1\uffff\32\56", | ||
2730 | "", | ||
2731 | "\1\u00e6\5\uffff\1\u00e7", | ||
2732 | "\1\u00e8", | ||
2733 | "\1\u00e9", | ||
2734 | "\1\u00ea", | ||
2735 | "\12\56\7\uffff\32\56\4\uffff\1\56\1\uffff\32\56", | ||
2736 | "\1\u00ec", | ||
2737 | "\1\u00ed", | ||
2738 | "\1\u00ee", | ||
2739 | "", | ||
2740 | "\12\56\7\uffff\32\56\4\uffff\1\56\1\uffff\32\56", | ||
2741 | "", | ||
2742 | "\12\56\7\uffff\32\56\4\uffff\1\56\1\uffff\32\56", | ||
2743 | "\12\56\7\uffff\32\56\4\uffff\1\56\1\uffff\32\56", | ||
2744 | "", | ||
2745 | "", | ||
2746 | "\1\u00f2", | ||
2747 | "\12\56\7\uffff\32\56\4\uffff\1\56\1\uffff\32\56", | ||
2748 | "\1\u00f4", | ||
2749 | "\12\56\7\uffff\32\56\4\uffff\1\56\1\uffff\32\56", | ||
2750 | "\12\56\7\uffff\32\56\4\uffff\1\56\1\uffff\32\56", | ||
2751 | "", | ||
2752 | "\12\56\7\uffff\32\56\4\uffff\1\56\1\uffff\32\56", | ||
2753 | "\12\56\7\uffff\32\56\4\uffff\1\56\1\uffff\32\56", | ||
2754 | "\12\56\7\uffff\32\56\4\uffff\1\56\1\uffff\32\56", | ||
2755 | "", | ||
2756 | "", | ||
2757 | "", | ||
2758 | "\1\u00fa", | ||
2759 | "", | ||
2760 | "\1\u00fb", | ||
2761 | "", | ||
2762 | "", | ||
2763 | "", | ||
2764 | "", | ||
2765 | "", | ||
2766 | "\1\u00fc", | ||
2767 | "\12\56\7\uffff\32\56\4\uffff\1\56\1\uffff\32\56", | ||
2768 | "\12\56\7\uffff\32\56\4\uffff\1\56\1\uffff\32\56", | ||
2769 | "", | ||
2770 | "" | ||
2771 | }; | ||
2772 | |||
2773 | static final short[] DFA12_eot = DFA.unpackEncodedString(DFA12_eotS); | ||
2774 | static final short[] DFA12_eof = DFA.unpackEncodedString(DFA12_eofS); | ||
2775 | static final char[] DFA12_min = DFA.unpackEncodedStringToUnsignedChars(DFA12_minS); | ||
2776 | static final char[] DFA12_max = DFA.unpackEncodedStringToUnsignedChars(DFA12_maxS); | ||
2777 | static final short[] DFA12_accept = DFA.unpackEncodedString(DFA12_acceptS); | ||
2778 | static final short[] DFA12_special = DFA.unpackEncodedString(DFA12_specialS); | ||
2779 | static final short[][] DFA12_transition; | ||
2780 | |||
2781 | static { | ||
2782 | int numStates = DFA12_transitionS.length; | ||
2783 | DFA12_transition = new short[numStates][]; | ||
2784 | for (int i=0; i<numStates; i++) { | ||
2785 | DFA12_transition[i] = DFA.unpackEncodedString(DFA12_transitionS[i]); | ||
2786 | } | ||
2787 | } | ||
2788 | |||
2789 | class DFA12 extends DFA { | ||
2790 | |||
2791 | public DFA12(BaseRecognizer recognizer) { | ||
2792 | this.recognizer = recognizer; | ||
2793 | this.decisionNumber = 12; | ||
2794 | this.eot = DFA12_eot; | ||
2795 | this.eof = DFA12_eof; | ||
2796 | this.min = DFA12_min; | ||
2797 | this.max = DFA12_max; | ||
2798 | this.accept = DFA12_accept; | ||
2799 | this.special = DFA12_special; | ||
2800 | this.transition = DFA12_transition; | ||
2801 | } | ||
2802 | public String getDescription() { | ||
2803 | return "1:1: Tokens : ( Containment | Functional | Abstract | Contains | Datatype | Maximize | Minimize | Opposite | Default | Extends | Problem | Unknown | Extern | Import | Object | Refers | Class | Count | Empty | Error | False | Scope | Else | Enum | Root | Then | True | FullStopFullStopFullStop | Inf | Let | ExclamationMarkEqualsSign | HyphenMinusGreaterThanSign | ColonHyphenMinus | ColonColon | ColonEqualsSign | LessThanSignEqualsSign | EqualsSignEqualsSign | EqualsSignGreaterThanSign | GreaterThanSignEqualsSign | As | If | In | ExclamationMark | LeftParenthesis | RightParenthesis | Asterisk | PlusSign | Comma | HyphenMinus | FullStop | Solidus | Colon | Semicolon | LessThanSign | EqualsSign | GreaterThanSign | QuestionMark | LeftSquareBracket | RightSquareBracket | CircumflexAccent | LeftCurlyBracket | VerticalLine | RightCurlyBracket | Tilde | RULE_STRING | RULE_QUOTED_ID | RULE_SL_COMMENT | RULE_ID | RULE_INT | RULE_ML_COMMENT | RULE_WS | RULE_ANY_OTHER );"; | ||
2804 | } | ||
2805 | public int specialStateTransition(int s, IntStream _input) throws NoViableAltException { | ||
2806 | IntStream input = _input; | ||
2807 | int _s = s; | ||
2808 | switch ( s ) { | ||
2809 | case 0 : | ||
2810 | int LA12_37 = input.LA(1); | ||
2811 | |||
2812 | s = -1; | ||
2813 | if ( ((LA12_37>='\u0000' && LA12_37<='\uFFFF')) ) {s = 107;} | ||
2814 | |||
2815 | else s = 43; | ||
2816 | |||
2817 | if ( s>=0 ) return s; | ||
2818 | break; | ||
2819 | case 1 : | ||
2820 | int LA12_0 = input.LA(1); | ||
2821 | |||
2822 | s = -1; | ||
2823 | if ( (LA12_0=='c') ) {s = 1;} | ||
2824 | |||
2825 | else if ( (LA12_0=='f') ) {s = 2;} | ||
2826 | |||
2827 | else if ( (LA12_0=='a') ) {s = 3;} | ||
2828 | |||
2829 | else if ( (LA12_0=='d') ) {s = 4;} | ||
2830 | |||
2831 | else if ( (LA12_0=='m') ) {s = 5;} | ||
2832 | |||
2833 | else if ( (LA12_0=='o') ) {s = 6;} | ||
2834 | |||
2835 | else if ( (LA12_0=='e') ) {s = 7;} | ||
2836 | |||
2837 | else if ( (LA12_0=='p') ) {s = 8;} | ||
2838 | |||
2839 | else if ( (LA12_0=='u') ) {s = 9;} | ||
2840 | |||
2841 | else if ( (LA12_0=='i') ) {s = 10;} | ||
2842 | |||
2843 | else if ( (LA12_0=='r') ) {s = 11;} | ||
2844 | |||
2845 | else if ( (LA12_0=='s') ) {s = 12;} | ||
2846 | |||
2847 | else if ( (LA12_0=='t') ) {s = 13;} | ||
2848 | |||
2849 | else if ( (LA12_0=='.') ) {s = 14;} | ||
2850 | |||
2851 | else if ( (LA12_0=='l') ) {s = 15;} | ||
2852 | |||
2853 | else if ( (LA12_0=='!') ) {s = 16;} | ||
2854 | |||
2855 | else if ( (LA12_0=='-') ) {s = 17;} | ||
2856 | |||
2857 | else if ( (LA12_0==':') ) {s = 18;} | ||
2858 | |||
2859 | else if ( (LA12_0=='<') ) {s = 19;} | ||
2860 | |||
2861 | else if ( (LA12_0=='=') ) {s = 20;} | ||
2862 | |||
2863 | else if ( (LA12_0=='>') ) {s = 21;} | ||
2864 | |||
2865 | else if ( (LA12_0=='(') ) {s = 22;} | ||
2866 | |||
2867 | else if ( (LA12_0==')') ) {s = 23;} | ||
2868 | |||
2869 | else if ( (LA12_0=='*') ) {s = 24;} | ||
2870 | |||
2871 | else if ( (LA12_0=='+') ) {s = 25;} | ||
2872 | |||
2873 | else if ( (LA12_0==',') ) {s = 26;} | ||
2874 | |||
2875 | else if ( (LA12_0=='/') ) {s = 27;} | ||
2876 | |||
2877 | else if ( (LA12_0==';') ) {s = 28;} | ||
2878 | |||
2879 | else if ( (LA12_0=='?') ) {s = 29;} | ||
2880 | |||
2881 | else if ( (LA12_0=='[') ) {s = 30;} | ||
2882 | |||
2883 | else if ( (LA12_0==']') ) {s = 31;} | ||
2884 | |||
2885 | else if ( (LA12_0=='^') ) {s = 32;} | ||
2886 | |||
2887 | else if ( (LA12_0=='{') ) {s = 33;} | ||
2888 | |||
2889 | else if ( (LA12_0=='|') ) {s = 34;} | ||
2890 | |||
2891 | else if ( (LA12_0=='}') ) {s = 35;} | ||
2892 | |||
2893 | else if ( (LA12_0=='~') ) {s = 36;} | ||
2894 | |||
2895 | else if ( (LA12_0=='\"') ) {s = 37;} | ||
2896 | |||
2897 | else if ( (LA12_0=='\'') ) {s = 38;} | ||
2898 | |||
2899 | else if ( (LA12_0=='%') ) {s = 39;} | ||
2900 | |||
2901 | else if ( ((LA12_0>='A' && LA12_0<='Z')||LA12_0=='_'||LA12_0=='b'||(LA12_0>='g' && LA12_0<='h')||(LA12_0>='j' && LA12_0<='k')||LA12_0=='n'||LA12_0=='q'||(LA12_0>='v' && LA12_0<='z')) ) {s = 40;} | ||
2902 | |||
2903 | else if ( ((LA12_0>='0' && LA12_0<='9')) ) {s = 41;} | ||
2904 | |||
2905 | else if ( ((LA12_0>='\t' && LA12_0<='\n')||LA12_0=='\r'||LA12_0==' ') ) {s = 42;} | ||
2906 | |||
2907 | else if ( ((LA12_0>='\u0000' && LA12_0<='\b')||(LA12_0>='\u000B' && LA12_0<='\f')||(LA12_0>='\u000E' && LA12_0<='\u001F')||(LA12_0>='#' && LA12_0<='$')||LA12_0=='&'||LA12_0=='@'||LA12_0=='\\'||LA12_0=='`'||(LA12_0>='\u007F' && LA12_0<='\uFFFF')) ) {s = 43;} | ||
2908 | |||
2909 | if ( s>=0 ) return s; | ||
2910 | break; | ||
2911 | case 2 : | ||
2912 | int LA12_38 = input.LA(1); | ||
2913 | |||
2914 | s = -1; | ||
2915 | if ( ((LA12_38>='\u0000' && LA12_38<='\uFFFF')) ) {s = 108;} | ||
2916 | |||
2917 | else s = 43; | ||
2918 | |||
2919 | if ( s>=0 ) return s; | ||
2920 | break; | ||
2921 | } | ||
2922 | NoViableAltException nvae = | ||
2923 | new NoViableAltException(getDescription(), 12, _s, input); | ||
2924 | error(nvae); | ||
2925 | throw nvae; | ||
2926 | } | ||
2927 | } | ||
2928 | |||
2929 | |||
2930 | } \ No newline at end of file | ||
diff --git a/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/parser/antlr/lexer/InternalSolverLanguageLexer.tokens b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/parser/antlr/lexer/InternalSolverLanguageLexer.tokens new file mode 100644 index 00000000..f6269b97 --- /dev/null +++ b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/parser/antlr/lexer/InternalSolverLanguageLexer.tokens | |||
@@ -0,0 +1,75 @@ | |||
1 | Abstract=6 | ||
2 | As=43 | ||
3 | Asterisk=49 | ||
4 | CircumflexAccent=63 | ||
5 | Class=20 | ||
6 | Colon=55 | ||
7 | ColonColon=37 | ||
8 | ColonEqualsSign=38 | ||
9 | ColonHyphenMinus=36 | ||
10 | Comma=51 | ||
11 | Containment=4 | ||
12 | Contains=7 | ||
13 | Count=21 | ||
14 | Datatype=8 | ||
15 | Default=12 | ||
16 | Else=26 | ||
17 | Empty=22 | ||
18 | Enum=27 | ||
19 | EqualsSign=58 | ||
20 | EqualsSignEqualsSign=40 | ||
21 | EqualsSignGreaterThanSign=41 | ||
22 | Error=23 | ||
23 | ExclamationMark=46 | ||
24 | ExclamationMarkEqualsSign=34 | ||
25 | Extends=13 | ||
26 | Extern=16 | ||
27 | False=24 | ||
28 | FullStop=53 | ||
29 | FullStopFullStopFullStop=31 | ||
30 | Functional=5 | ||
31 | GreaterThanSign=59 | ||
32 | GreaterThanSignEqualsSign=42 | ||
33 | HyphenMinus=52 | ||
34 | HyphenMinusGreaterThanSign=35 | ||
35 | If=44 | ||
36 | Import=17 | ||
37 | In=45 | ||
38 | Inf=32 | ||
39 | LeftCurlyBracket=64 | ||
40 | LeftParenthesis=47 | ||
41 | LeftSquareBracket=61 | ||
42 | LessThanSign=57 | ||
43 | LessThanSignEqualsSign=39 | ||
44 | Let=33 | ||
45 | Maximize=9 | ||
46 | Minimize=10 | ||
47 | Object=18 | ||
48 | Opposite=11 | ||
49 | PlusSign=50 | ||
50 | Problem=14 | ||
51 | QuestionMark=60 | ||
52 | RULE_ANY_OTHER=78 | ||
53 | RULE_FULL_STOP=73 | ||
54 | RULE_ID=74 | ||
55 | RULE_INT=75 | ||
56 | RULE_ML_COMMENT=76 | ||
57 | RULE_QUOTED_ID=69 | ||
58 | RULE_REFLEXIVE_TRANSITIVE_CLOSURE=72 | ||
59 | RULE_SL_COMMENT=70 | ||
60 | RULE_STRING=68 | ||
61 | RULE_TRANSITIVE_CLOSURE=71 | ||
62 | RULE_WS=77 | ||
63 | Refers=19 | ||
64 | RightCurlyBracket=66 | ||
65 | RightParenthesis=48 | ||
66 | RightSquareBracket=62 | ||
67 | Root=28 | ||
68 | Scope=25 | ||
69 | Semicolon=56 | ||
70 | Solidus=54 | ||
71 | Then=29 | ||
72 | Tilde=67 | ||
73 | True=30 | ||
74 | Unknown=15 | ||
75 | VerticalLine=65 | ||
diff --git a/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/scoping/AbstractSolverLanguageScopeProvider.java b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/scoping/AbstractSolverLanguageScopeProvider.java new file mode 100644 index 00000000..fabd22c7 --- /dev/null +++ b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/scoping/AbstractSolverLanguageScopeProvider.java | |||
@@ -0,0 +1,9 @@ | |||
1 | /* | ||
2 | * generated by Xtext 2.21.0 | ||
3 | */ | ||
4 | package org.eclipse.viatra.solver.language.scoping; | ||
5 | |||
6 | import org.eclipse.xtext.scoping.impl.DelegatingScopeProvider; | ||
7 | |||
8 | public abstract class AbstractSolverLanguageScopeProvider extends DelegatingScopeProvider { | ||
9 | } | ||
diff --git a/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/serializer/SolverLanguageSemanticSequencer.java b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/serializer/SolverLanguageSemanticSequencer.java new file mode 100644 index 00000000..49326024 --- /dev/null +++ b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/serializer/SolverLanguageSemanticSequencer.java | |||
@@ -0,0 +1,1756 @@ | |||
1 | /* | ||
2 | * generated by Xtext 2.21.0 | ||
3 | */ | ||
4 | package org.eclipse.viatra.solver.language.serializer; | ||
5 | |||
6 | import com.google.inject.Inject; | ||
7 | import java.util.Set; | ||
8 | import org.eclipse.emf.ecore.EObject; | ||
9 | import org.eclipse.emf.ecore.EPackage; | ||
10 | import org.eclipse.viatra.solver.language.services.SolverLanguageGrammarAccess; | ||
11 | import org.eclipse.viatra.solver.language.solverLanguage.Aggregation; | ||
12 | import org.eclipse.viatra.solver.language.solverLanguage.ArgumentList; | ||
13 | import org.eclipse.viatra.solver.language.solverLanguage.Assertion; | ||
14 | import org.eclipse.viatra.solver.language.solverLanguage.Attribute; | ||
15 | import org.eclipse.viatra.solver.language.solverLanguage.BinaryExpression; | ||
16 | import org.eclipse.viatra.solver.language.solverLanguage.BoundedMultiplicity; | ||
17 | import org.eclipse.viatra.solver.language.solverLanguage.BoundedScope; | ||
18 | import org.eclipse.viatra.solver.language.solverLanguage.Call; | ||
19 | import org.eclipse.viatra.solver.language.solverLanguage.Case; | ||
20 | import org.eclipse.viatra.solver.language.solverLanguage.CastExpression; | ||
21 | import org.eclipse.viatra.solver.language.solverLanguage.ClassDeclaration; | ||
22 | import org.eclipse.viatra.solver.language.solverLanguage.ConditionalExpression; | ||
23 | import org.eclipse.viatra.solver.language.solverLanguage.Conjunction; | ||
24 | import org.eclipse.viatra.solver.language.solverLanguage.Count; | ||
25 | import org.eclipse.viatra.solver.language.solverLanguage.DefaultAssertion; | ||
26 | import org.eclipse.viatra.solver.language.solverLanguage.Disjunction; | ||
27 | import org.eclipse.viatra.solver.language.solverLanguage.EmptyLiteral; | ||
28 | import org.eclipse.viatra.solver.language.solverLanguage.EnumDeclaration; | ||
29 | import org.eclipse.viatra.solver.language.solverLanguage.EnumLiteral; | ||
30 | import org.eclipse.viatra.solver.language.solverLanguage.ExactMultiplicity; | ||
31 | import org.eclipse.viatra.solver.language.solverLanguage.ExactScope; | ||
32 | import org.eclipse.viatra.solver.language.solverLanguage.ExpressionArgument; | ||
33 | import org.eclipse.viatra.solver.language.solverLanguage.ExternAggregationOperatorDeclaration; | ||
34 | import org.eclipse.viatra.solver.language.solverLanguage.ExternDatatypeDeclaration; | ||
35 | import org.eclipse.viatra.solver.language.solverLanguage.ExternFunctionDeclaration; | ||
36 | import org.eclipse.viatra.solver.language.solverLanguage.ExternPredicateDeclaration; | ||
37 | import org.eclipse.viatra.solver.language.solverLanguage.Field; | ||
38 | import org.eclipse.viatra.solver.language.solverLanguage.Forall; | ||
39 | import org.eclipse.viatra.solver.language.solverLanguage.FunctionDefinition; | ||
40 | import org.eclipse.viatra.solver.language.solverLanguage.InfinityLiteral; | ||
41 | import org.eclipse.viatra.solver.language.solverLanguage.IntLiteral; | ||
42 | import org.eclipse.viatra.solver.language.solverLanguage.Interval; | ||
43 | import org.eclipse.viatra.solver.language.solverLanguage.LetBinding; | ||
44 | import org.eclipse.viatra.solver.language.solverLanguage.LetExpression; | ||
45 | import org.eclipse.viatra.solver.language.solverLanguage.LogicLiteral; | ||
46 | import org.eclipse.viatra.solver.language.solverLanguage.LowerBoundedScope; | ||
47 | import org.eclipse.viatra.solver.language.solverLanguage.NamespaceImport; | ||
48 | import org.eclipse.viatra.solver.language.solverLanguage.ObjectiveDeclaration; | ||
49 | import org.eclipse.viatra.solver.language.solverLanguage.PathComponent; | ||
50 | import org.eclipse.viatra.solver.language.solverLanguage.PredicateDefinition; | ||
51 | import org.eclipse.viatra.solver.language.solverLanguage.Problem; | ||
52 | import org.eclipse.viatra.solver.language.solverLanguage.RealLiteral; | ||
53 | import org.eclipse.viatra.solver.language.solverLanguage.Reference; | ||
54 | import org.eclipse.viatra.solver.language.solverLanguage.SolverLanguagePackage; | ||
55 | import org.eclipse.viatra.solver.language.solverLanguage.StarArgument; | ||
56 | import org.eclipse.viatra.solver.language.solverLanguage.StringLiteral; | ||
57 | import org.eclipse.viatra.solver.language.solverLanguage.Switch; | ||
58 | import org.eclipse.viatra.solver.language.solverLanguage.TypeReference; | ||
59 | import org.eclipse.viatra.solver.language.solverLanguage.TypedStarArgument; | ||
60 | import org.eclipse.viatra.solver.language.solverLanguage.TypedVariableArgument; | ||
61 | import org.eclipse.viatra.solver.language.solverLanguage.UnaryExpression; | ||
62 | import org.eclipse.viatra.solver.language.solverLanguage.UnboundedMultiplicity; | ||
63 | import org.eclipse.viatra.solver.language.solverLanguage.UnnamedErrorPredicateDefintion; | ||
64 | import org.eclipse.viatra.solver.language.solverLanguage.UriImport; | ||
65 | import org.eclipse.xtext.Action; | ||
66 | import org.eclipse.xtext.Parameter; | ||
67 | import org.eclipse.xtext.ParserRule; | ||
68 | import org.eclipse.xtext.serializer.ISerializationContext; | ||
69 | import org.eclipse.xtext.serializer.acceptor.SequenceFeeder; | ||
70 | import org.eclipse.xtext.serializer.sequencer.AbstractDelegatingSemanticSequencer; | ||
71 | import org.eclipse.xtext.serializer.sequencer.ITransientValueService.ValueTransient; | ||
72 | |||
73 | @SuppressWarnings("all") | ||
74 | public class SolverLanguageSemanticSequencer extends AbstractDelegatingSemanticSequencer { | ||
75 | |||
76 | @Inject | ||
77 | private SolverLanguageGrammarAccess grammarAccess; | ||
78 | |||
79 | @Override | ||
80 | public void sequence(ISerializationContext context, EObject semanticObject) { | ||
81 | EPackage epackage = semanticObject.eClass().getEPackage(); | ||
82 | ParserRule rule = context.getParserRule(); | ||
83 | Action action = context.getAssignedAction(); | ||
84 | Set<Parameter> parameters = context.getEnabledBooleanParameters(); | ||
85 | if (epackage == SolverLanguagePackage.eINSTANCE) | ||
86 | switch (semanticObject.eClass().getClassifierID()) { | ||
87 | case SolverLanguagePackage.AGGREGATION: | ||
88 | sequence_Aggregation(context, (Aggregation) semanticObject); | ||
89 | return; | ||
90 | case SolverLanguagePackage.ARGUMENT_LIST: | ||
91 | sequence_ArgumentList(context, (ArgumentList) semanticObject); | ||
92 | return; | ||
93 | case SolverLanguagePackage.ASSERTION: | ||
94 | sequence_AssertionOrDefinition(context, (Assertion) semanticObject); | ||
95 | return; | ||
96 | case SolverLanguagePackage.ATTRIBUTE: | ||
97 | sequence_Attribute(context, (Attribute) semanticObject); | ||
98 | return; | ||
99 | case SolverLanguagePackage.BINARY_EXPRESSION: | ||
100 | sequence_AdditiveExpression_ComparisonExpression_ExponentialExpression_MultiplicativeExpression(context, (BinaryExpression) semanticObject); | ||
101 | return; | ||
102 | case SolverLanguagePackage.BOUNDED_MULTIPLICITY: | ||
103 | sequence_BoundedMultiplicity(context, (BoundedMultiplicity) semanticObject); | ||
104 | return; | ||
105 | case SolverLanguagePackage.BOUNDED_SCOPE: | ||
106 | sequence_BoundedScope(context, (BoundedScope) semanticObject); | ||
107 | return; | ||
108 | case SolverLanguagePackage.CALL: | ||
109 | sequence_Call(context, (Call) semanticObject); | ||
110 | return; | ||
111 | case SolverLanguagePackage.CASE: | ||
112 | if (rule == grammarAccess.getCaseRule()) { | ||
113 | sequence_Case(context, (Case) semanticObject); | ||
114 | return; | ||
115 | } | ||
116 | else if (action == grammarAccess.getDisjunctiveExpressionAccess().getSwitchCasesAction_1_1_3()) { | ||
117 | sequence_DisjunctiveExpression_Switch_1_1_3(context, (Case) semanticObject); | ||
118 | return; | ||
119 | } | ||
120 | else break; | ||
121 | case SolverLanguagePackage.CAST_EXPRESSION: | ||
122 | sequence_CastExpression(context, (CastExpression) semanticObject); | ||
123 | return; | ||
124 | case SolverLanguagePackage.CLASS_DECLARATION: | ||
125 | sequence_ClassDeclaration(context, (ClassDeclaration) semanticObject); | ||
126 | return; | ||
127 | case SolverLanguagePackage.CONDITIONAL_EXPRESSION: | ||
128 | sequence_ConditionalExpression(context, (ConditionalExpression) semanticObject); | ||
129 | return; | ||
130 | case SolverLanguagePackage.CONJUNCTION: | ||
131 | sequence_ConjunctiveExpression(context, (Conjunction) semanticObject); | ||
132 | return; | ||
133 | case SolverLanguagePackage.COUNT: | ||
134 | sequence_Count(context, (Count) semanticObject); | ||
135 | return; | ||
136 | case SolverLanguagePackage.DEFAULT_ASSERTION: | ||
137 | sequence_DefaultAssertion(context, (DefaultAssertion) semanticObject); | ||
138 | return; | ||
139 | case SolverLanguagePackage.DISJUNCTION: | ||
140 | sequence_DisjunctiveExpression(context, (Disjunction) semanticObject); | ||
141 | return; | ||
142 | case SolverLanguagePackage.EMPTY_LITERAL: | ||
143 | sequence_EmptyLiteral(context, (EmptyLiteral) semanticObject); | ||
144 | return; | ||
145 | case SolverLanguagePackage.ENUM_DECLARATION: | ||
146 | sequence_EnumDeclaration(context, (EnumDeclaration) semanticObject); | ||
147 | return; | ||
148 | case SolverLanguagePackage.ENUM_LITERAL: | ||
149 | sequence_EnumLiteral(context, (EnumLiteral) semanticObject); | ||
150 | return; | ||
151 | case SolverLanguagePackage.EXACT_MULTIPLICITY: | ||
152 | sequence_ExactMultiplicity(context, (ExactMultiplicity) semanticObject); | ||
153 | return; | ||
154 | case SolverLanguagePackage.EXACT_SCOPE: | ||
155 | sequence_ExactScope(context, (ExactScope) semanticObject); | ||
156 | return; | ||
157 | case SolverLanguagePackage.EXPRESSION_ARGUMENT: | ||
158 | sequence_ExpressionArgument(context, (ExpressionArgument) semanticObject); | ||
159 | return; | ||
160 | case SolverLanguagePackage.EXTERN_AGGREGATION_OPERATOR_DECLARATION: | ||
161 | sequence_ExternAggregationOperatorDeclaration(context, (ExternAggregationOperatorDeclaration) semanticObject); | ||
162 | return; | ||
163 | case SolverLanguagePackage.EXTERN_DATATYPE_DECLARATION: | ||
164 | sequence_ExternDatatypeDeclaration(context, (ExternDatatypeDeclaration) semanticObject); | ||
165 | return; | ||
166 | case SolverLanguagePackage.EXTERN_FUNCTION_DECLARATION: | ||
167 | sequence_ExternFunctionDeclaration(context, (ExternFunctionDeclaration) semanticObject); | ||
168 | return; | ||
169 | case SolverLanguagePackage.EXTERN_PREDICATE_DECLARATION: | ||
170 | sequence_ExternPredicateDeclaration(context, (ExternPredicateDeclaration) semanticObject); | ||
171 | return; | ||
172 | case SolverLanguagePackage.FIELD: | ||
173 | sequence_Field(context, (Field) semanticObject); | ||
174 | return; | ||
175 | case SolverLanguagePackage.FORALL: | ||
176 | sequence_Expression(context, (Forall) semanticObject); | ||
177 | return; | ||
178 | case SolverLanguagePackage.FUNCTION_DEFINITION: | ||
179 | if (rule == grammarAccess.getAssertionOrDefinitionRule()) { | ||
180 | sequence_AssertionOrDefinition(context, (FunctionDefinition) semanticObject); | ||
181 | return; | ||
182 | } | ||
183 | else if (rule == grammarAccess.getStatementRule()) { | ||
184 | sequence_AssertionOrDefinition_FunctionDefinition(context, (FunctionDefinition) semanticObject); | ||
185 | return; | ||
186 | } | ||
187 | else if (rule == grammarAccess.getFunctionDefinitionRule()) { | ||
188 | sequence_FunctionDefinition(context, (FunctionDefinition) semanticObject); | ||
189 | return; | ||
190 | } | ||
191 | else break; | ||
192 | case SolverLanguagePackage.INFINITY_LITERAL: | ||
193 | sequence_InfinityLiteral(context, (InfinityLiteral) semanticObject); | ||
194 | return; | ||
195 | case SolverLanguagePackage.INT_LITERAL: | ||
196 | sequence_IntLiteral(context, (IntLiteral) semanticObject); | ||
197 | return; | ||
198 | case SolverLanguagePackage.INTERVAL: | ||
199 | sequence_Interval(context, (Interval) semanticObject); | ||
200 | return; | ||
201 | case SolverLanguagePackage.LET_BINDING: | ||
202 | sequence_LetBinding(context, (LetBinding) semanticObject); | ||
203 | return; | ||
204 | case SolverLanguagePackage.LET_EXPRESSION: | ||
205 | sequence_LetExpression(context, (LetExpression) semanticObject); | ||
206 | return; | ||
207 | case SolverLanguagePackage.LOGIC_LITERAL: | ||
208 | sequence_LogicLiteral(context, (LogicLiteral) semanticObject); | ||
209 | return; | ||
210 | case SolverLanguagePackage.LOWER_BOUNDED_SCOPE: | ||
211 | sequence_LowerBoundedScope(context, (LowerBoundedScope) semanticObject); | ||
212 | return; | ||
213 | case SolverLanguagePackage.NAMESPACE_IMPORT: | ||
214 | sequence_NamespaceImport(context, (NamespaceImport) semanticObject); | ||
215 | return; | ||
216 | case SolverLanguagePackage.OBJECTIVE_DECLARATION: | ||
217 | sequence_ObjectiveDeclaration(context, (ObjectiveDeclaration) semanticObject); | ||
218 | return; | ||
219 | case SolverLanguagePackage.PATH_COMPONENT: | ||
220 | sequence_PathComponent(context, (PathComponent) semanticObject); | ||
221 | return; | ||
222 | case SolverLanguagePackage.PREDICATE_DEFINITION: | ||
223 | if (rule == grammarAccess.getAssertionOrDefinitionRule()) { | ||
224 | sequence_AssertionOrDefinition(context, (PredicateDefinition) semanticObject); | ||
225 | return; | ||
226 | } | ||
227 | else if (rule == grammarAccess.getStatementRule()) { | ||
228 | sequence_AssertionOrDefinition_PredicateDefinition(context, (PredicateDefinition) semanticObject); | ||
229 | return; | ||
230 | } | ||
231 | else if (rule == grammarAccess.getPredicateDefinitionRule()) { | ||
232 | sequence_PredicateDefinition(context, (PredicateDefinition) semanticObject); | ||
233 | return; | ||
234 | } | ||
235 | else break; | ||
236 | case SolverLanguagePackage.PROBLEM: | ||
237 | sequence_Problem(context, (Problem) semanticObject); | ||
238 | return; | ||
239 | case SolverLanguagePackage.REAL_LITERAL: | ||
240 | sequence_RealLiteral(context, (RealLiteral) semanticObject); | ||
241 | return; | ||
242 | case SolverLanguagePackage.REFERENCE: | ||
243 | sequence_Reference(context, (Reference) semanticObject); | ||
244 | return; | ||
245 | case SolverLanguagePackage.STAR_ARGUMENT: | ||
246 | sequence_StarArgument(context, (StarArgument) semanticObject); | ||
247 | return; | ||
248 | case SolverLanguagePackage.STRING_LITERAL: | ||
249 | sequence_StringLiteral(context, (StringLiteral) semanticObject); | ||
250 | return; | ||
251 | case SolverLanguagePackage.SWITCH: | ||
252 | sequence_DisjunctiveExpression(context, (Switch) semanticObject); | ||
253 | return; | ||
254 | case SolverLanguagePackage.TYPE_REFERENCE: | ||
255 | sequence_TypeReference(context, (TypeReference) semanticObject); | ||
256 | return; | ||
257 | case SolverLanguagePackage.TYPED_STAR_ARGUMENT: | ||
258 | sequence_TypedStarArgument(context, (TypedStarArgument) semanticObject); | ||
259 | return; | ||
260 | case SolverLanguagePackage.TYPED_VARIABLE_ARGUMENT: | ||
261 | sequence_TypedVariableArgument(context, (TypedVariableArgument) semanticObject); | ||
262 | return; | ||
263 | case SolverLanguagePackage.UNARY_EXPRESSION: | ||
264 | sequence_UnaryExpression(context, (UnaryExpression) semanticObject); | ||
265 | return; | ||
266 | case SolverLanguagePackage.UNBOUNDED_MULTIPLICITY: | ||
267 | sequence_UnboundedMultiplicity(context, (UnboundedMultiplicity) semanticObject); | ||
268 | return; | ||
269 | case SolverLanguagePackage.UNNAMED_ERROR_PREDICATE_DEFINTION: | ||
270 | sequence_UnnamedErrorPredicateDefintion(context, (UnnamedErrorPredicateDefintion) semanticObject); | ||
271 | return; | ||
272 | case SolverLanguagePackage.URI_IMPORT: | ||
273 | sequence_UriImport(context, (UriImport) semanticObject); | ||
274 | return; | ||
275 | } | ||
276 | if (errorAcceptor != null) | ||
277 | errorAcceptor.accept(diagnosticProvider.createInvalidContextOrTypeDiagnostic(semanticObject, context)); | ||
278 | } | ||
279 | |||
280 | /** | ||
281 | * Contexts: | ||
282 | * AssertionOrDefinition.Assertion_1_0_0 returns BinaryExpression | ||
283 | * AssertionOrDefinition.PredicateDefinition_1_1_0 returns BinaryExpression | ||
284 | * AssertionOrDefinition.FunctionDefinition_1_2_0 returns BinaryExpression | ||
285 | * Expression returns BinaryExpression | ||
286 | * Expression.Forall_2_1_0 returns BinaryExpression | ||
287 | * DisjunctiveExpression returns BinaryExpression | ||
288 | * DisjunctiveExpression.Disjunction_1_0_0 returns BinaryExpression | ||
289 | * DisjunctiveExpression.Case_1_1_0 returns BinaryExpression | ||
290 | * ConjunctiveExpression returns BinaryExpression | ||
291 | * ConjunctiveExpression.Conjunction_1_0 returns BinaryExpression | ||
292 | * ComparisonExpression returns BinaryExpression | ||
293 | * ComparisonExpression.BinaryExpression_1_0 returns BinaryExpression | ||
294 | * AdditiveExpression returns BinaryExpression | ||
295 | * AdditiveExpression.BinaryExpression_1_0 returns BinaryExpression | ||
296 | * MultiplicativeExpression returns BinaryExpression | ||
297 | * MultiplicativeExpression.BinaryExpression_1_0 returns BinaryExpression | ||
298 | * ExponentialExpression returns BinaryExpression | ||
299 | * ExponentialExpression.BinaryExpression_1_0 returns BinaryExpression | ||
300 | * CastExpression returns BinaryExpression | ||
301 | * CastExpression.CastExpression_1_0 returns BinaryExpression | ||
302 | * UnaryExpression returns BinaryExpression | ||
303 | * BracedAggregateExpression returns BinaryExpression | ||
304 | * AtomicExpression returns BinaryExpression | ||
305 | * | ||
306 | * Constraint: | ||
307 | * ( | ||
308 | * (left=ComparisonExpression_BinaryExpression_1_0 op=ComparisonOperator right=AdditiveExpression) | | ||
309 | * (left=AdditiveExpression_BinaryExpression_1_0 op=AdditiveBinaryOperator right=MultiplicativeExpression) | | ||
310 | * (left=MultiplicativeExpression_BinaryExpression_1_0 op=MultiplicativeBinaryOperator right=ExponentialExpression) | | ||
311 | * (left=ExponentialExpression_BinaryExpression_1_0 op=ExponentialOp right=CastExpression) | ||
312 | * ) | ||
313 | */ | ||
314 | protected void sequence_AdditiveExpression_ComparisonExpression_ExponentialExpression_MultiplicativeExpression(ISerializationContext context, BinaryExpression semanticObject) { | ||
315 | genericSequencer.createSequence(context, semanticObject); | ||
316 | } | ||
317 | |||
318 | |||
319 | /** | ||
320 | * Contexts: | ||
321 | * AssertionOrDefinition.Assertion_1_0_0 returns Aggregation | ||
322 | * AssertionOrDefinition.PredicateDefinition_1_1_0 returns Aggregation | ||
323 | * AssertionOrDefinition.FunctionDefinition_1_2_0 returns Aggregation | ||
324 | * Expression returns Aggregation | ||
325 | * Expression.Forall_2_1_0 returns Aggregation | ||
326 | * DisjunctiveExpression returns Aggregation | ||
327 | * DisjunctiveExpression.Disjunction_1_0_0 returns Aggregation | ||
328 | * DisjunctiveExpression.Case_1_1_0 returns Aggregation | ||
329 | * ConjunctiveExpression returns Aggregation | ||
330 | * ConjunctiveExpression.Conjunction_1_0 returns Aggregation | ||
331 | * ComparisonExpression returns Aggregation | ||
332 | * ComparisonExpression.BinaryExpression_1_0 returns Aggregation | ||
333 | * AdditiveExpression returns Aggregation | ||
334 | * AdditiveExpression.BinaryExpression_1_0 returns Aggregation | ||
335 | * MultiplicativeExpression returns Aggregation | ||
336 | * MultiplicativeExpression.BinaryExpression_1_0 returns Aggregation | ||
337 | * ExponentialExpression returns Aggregation | ||
338 | * ExponentialExpression.BinaryExpression_1_0 returns Aggregation | ||
339 | * CastExpression returns Aggregation | ||
340 | * CastExpression.CastExpression_1_0 returns Aggregation | ||
341 | * UnaryExpression returns Aggregation | ||
342 | * BracedAggregateExpression returns Aggregation | ||
343 | * Aggregation returns Aggregation | ||
344 | * AtomicExpression returns Aggregation | ||
345 | * | ||
346 | * Constraint: | ||
347 | * (op=[Symbol|QualifiedName] value=Expression condition=Expression) | ||
348 | */ | ||
349 | protected void sequence_Aggregation(ISerializationContext context, Aggregation semanticObject) { | ||
350 | if (errorAcceptor != null) { | ||
351 | if (transientValues.isValueTransient(semanticObject, SolverLanguagePackage.Literals.AGGREGATION__OP) == ValueTransient.YES) | ||
352 | errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, SolverLanguagePackage.Literals.AGGREGATION__OP)); | ||
353 | if (transientValues.isValueTransient(semanticObject, SolverLanguagePackage.Literals.AGGREGATION__VALUE) == ValueTransient.YES) | ||
354 | errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, SolverLanguagePackage.Literals.AGGREGATION__VALUE)); | ||
355 | if (transientValues.isValueTransient(semanticObject, SolverLanguagePackage.Literals.AGGREGATE_EXPRESSION__CONDITION) == ValueTransient.YES) | ||
356 | errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, SolverLanguagePackage.Literals.AGGREGATE_EXPRESSION__CONDITION)); | ||
357 | } | ||
358 | SequenceFeeder feeder = createSequencerFeeder(context, semanticObject); | ||
359 | feeder.accept(grammarAccess.getAggregationAccess().getOpSymbolQualifiedNameParserRuleCall_0_0_1(), semanticObject.eGet(SolverLanguagePackage.Literals.AGGREGATION__OP, false)); | ||
360 | feeder.accept(grammarAccess.getAggregationAccess().getValueExpressionParserRuleCall_2_0(), semanticObject.getValue()); | ||
361 | feeder.accept(grammarAccess.getAggregationAccess().getConditionExpressionParserRuleCall_4_0(), semanticObject.getCondition()); | ||
362 | feeder.finish(); | ||
363 | } | ||
364 | |||
365 | |||
366 | /** | ||
367 | * Contexts: | ||
368 | * ArgumentList returns ArgumentList | ||
369 | * | ||
370 | * Constraint: | ||
371 | * (arguments+=Argument arguments+=Argument*)? | ||
372 | */ | ||
373 | protected void sequence_ArgumentList(ISerializationContext context, ArgumentList semanticObject) { | ||
374 | genericSequencer.createSequence(context, semanticObject); | ||
375 | } | ||
376 | |||
377 | |||
378 | /** | ||
379 | * Contexts: | ||
380 | * Statement returns Assertion | ||
381 | * AssertionOrDefinition returns Assertion | ||
382 | * | ||
383 | * Constraint: | ||
384 | * (expression=AssertionOrDefinition_Assertion_1_0_0 range=Expression?) | ||
385 | */ | ||
386 | protected void sequence_AssertionOrDefinition(ISerializationContext context, Assertion semanticObject) { | ||
387 | genericSequencer.createSequence(context, semanticObject); | ||
388 | } | ||
389 | |||
390 | |||
391 | /** | ||
392 | * Contexts: | ||
393 | * AssertionOrDefinition returns FunctionDefinition | ||
394 | * | ||
395 | * Constraint: | ||
396 | * (head=AssertionOrDefinition_FunctionDefinition_1_2_0 body=Expression) | ||
397 | */ | ||
398 | protected void sequence_AssertionOrDefinition(ISerializationContext context, FunctionDefinition semanticObject) { | ||
399 | if (errorAcceptor != null) { | ||
400 | if (transientValues.isValueTransient(semanticObject, SolverLanguagePackage.Literals.FUNCTOR_DEFINITON__HEAD) == ValueTransient.YES) | ||
401 | errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, SolverLanguagePackage.Literals.FUNCTOR_DEFINITON__HEAD)); | ||
402 | if (transientValues.isValueTransient(semanticObject, SolverLanguagePackage.Literals.FUNCTOR_DEFINITON__BODY) == ValueTransient.YES) | ||
403 | errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, SolverLanguagePackage.Literals.FUNCTOR_DEFINITON__BODY)); | ||
404 | } | ||
405 | SequenceFeeder feeder = createSequencerFeeder(context, semanticObject); | ||
406 | feeder.accept(grammarAccess.getAssertionOrDefinitionAccess().getFunctionDefinitionHeadAction_1_2_0(), semanticObject.getHead()); | ||
407 | feeder.accept(grammarAccess.getAssertionOrDefinitionAccess().getBodyExpressionParserRuleCall_1_2_2_0(), semanticObject.getBody()); | ||
408 | feeder.finish(); | ||
409 | } | ||
410 | |||
411 | |||
412 | /** | ||
413 | * Contexts: | ||
414 | * Statement returns FunctionDefinition | ||
415 | * | ||
416 | * Constraint: | ||
417 | * ((head=AssertionOrDefinition_FunctionDefinition_1_2_0 body=Expression) | (resultType=[Symbol|QualifiedName] head=Call body=Expression)) | ||
418 | */ | ||
419 | protected void sequence_AssertionOrDefinition_FunctionDefinition(ISerializationContext context, FunctionDefinition semanticObject) { | ||
420 | genericSequencer.createSequence(context, semanticObject); | ||
421 | } | ||
422 | |||
423 | |||
424 | /** | ||
425 | * Contexts: | ||
426 | * AssertionOrDefinition returns PredicateDefinition | ||
427 | * | ||
428 | * Constraint: | ||
429 | * (head=AssertionOrDefinition_PredicateDefinition_1_1_0 body=Expression) | ||
430 | */ | ||
431 | protected void sequence_AssertionOrDefinition(ISerializationContext context, PredicateDefinition semanticObject) { | ||
432 | if (errorAcceptor != null) { | ||
433 | if (transientValues.isValueTransient(semanticObject, SolverLanguagePackage.Literals.FUNCTOR_DEFINITON__HEAD) == ValueTransient.YES) | ||
434 | errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, SolverLanguagePackage.Literals.FUNCTOR_DEFINITON__HEAD)); | ||
435 | if (transientValues.isValueTransient(semanticObject, SolverLanguagePackage.Literals.FUNCTOR_DEFINITON__BODY) == ValueTransient.YES) | ||
436 | errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, SolverLanguagePackage.Literals.FUNCTOR_DEFINITON__BODY)); | ||
437 | } | ||
438 | SequenceFeeder feeder = createSequencerFeeder(context, semanticObject); | ||
439 | feeder.accept(grammarAccess.getAssertionOrDefinitionAccess().getPredicateDefinitionHeadAction_1_1_0(), semanticObject.getHead()); | ||
440 | feeder.accept(grammarAccess.getAssertionOrDefinitionAccess().getBodyExpressionParserRuleCall_1_1_2_0(), semanticObject.getBody()); | ||
441 | feeder.finish(); | ||
442 | } | ||
443 | |||
444 | |||
445 | /** | ||
446 | * Contexts: | ||
447 | * Statement returns PredicateDefinition | ||
448 | * | ||
449 | * Constraint: | ||
450 | * ( | ||
451 | * (head=AssertionOrDefinition_PredicateDefinition_1_1_0 body=Expression) | | ||
452 | * (((functional?='functional' error?='error'?) | (error?='error' functional?='functional'?)) head=Call body=Expression) | ||
453 | * ) | ||
454 | */ | ||
455 | protected void sequence_AssertionOrDefinition_PredicateDefinition(ISerializationContext context, PredicateDefinition semanticObject) { | ||
456 | genericSequencer.createSequence(context, semanticObject); | ||
457 | } | ||
458 | |||
459 | |||
460 | /** | ||
461 | * Contexts: | ||
462 | * Statement returns Attribute | ||
463 | * Attribute returns Attribute | ||
464 | * | ||
465 | * Constraint: | ||
466 | * (kind=AttributeKind target=[Symbol|QualifiedName]) | ||
467 | */ | ||
468 | protected void sequence_Attribute(ISerializationContext context, Attribute semanticObject) { | ||
469 | if (errorAcceptor != null) { | ||
470 | if (transientValues.isValueTransient(semanticObject, SolverLanguagePackage.Literals.ATTRIBUTE__KIND) == ValueTransient.YES) | ||
471 | errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, SolverLanguagePackage.Literals.ATTRIBUTE__KIND)); | ||
472 | if (transientValues.isValueTransient(semanticObject, SolverLanguagePackage.Literals.ATTRIBUTE__TARGET) == ValueTransient.YES) | ||
473 | errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, SolverLanguagePackage.Literals.ATTRIBUTE__TARGET)); | ||
474 | } | ||
475 | SequenceFeeder feeder = createSequencerFeeder(context, semanticObject); | ||
476 | feeder.accept(grammarAccess.getAttributeAccess().getKindAttributeKindEnumRuleCall_0_0(), semanticObject.getKind()); | ||
477 | feeder.accept(grammarAccess.getAttributeAccess().getTargetSymbolQualifiedNameParserRuleCall_1_0_1(), semanticObject.eGet(SolverLanguagePackage.Literals.ATTRIBUTE__TARGET, false)); | ||
478 | feeder.finish(); | ||
479 | } | ||
480 | |||
481 | |||
482 | /** | ||
483 | * Contexts: | ||
484 | * Multiplicity returns BoundedMultiplicity | ||
485 | * BoundedMultiplicity returns BoundedMultiplicity | ||
486 | * | ||
487 | * Constraint: | ||
488 | * (lowerBound=INT upperBound=UpperMultiplicty) | ||
489 | */ | ||
490 | protected void sequence_BoundedMultiplicity(ISerializationContext context, BoundedMultiplicity semanticObject) { | ||
491 | if (errorAcceptor != null) { | ||
492 | if (transientValues.isValueTransient(semanticObject, SolverLanguagePackage.Literals.BOUNDED_MULTIPLICITY__LOWER_BOUND) == ValueTransient.YES) | ||
493 | errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, SolverLanguagePackage.Literals.BOUNDED_MULTIPLICITY__LOWER_BOUND)); | ||
494 | if (transientValues.isValueTransient(semanticObject, SolverLanguagePackage.Literals.BOUNDED_MULTIPLICITY__UPPER_BOUND) == ValueTransient.YES) | ||
495 | errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, SolverLanguagePackage.Literals.BOUNDED_MULTIPLICITY__UPPER_BOUND)); | ||
496 | } | ||
497 | SequenceFeeder feeder = createSequencerFeeder(context, semanticObject); | ||
498 | feeder.accept(grammarAccess.getBoundedMultiplicityAccess().getLowerBoundINTTerminalRuleCall_1_0(), semanticObject.getLowerBound()); | ||
499 | feeder.accept(grammarAccess.getBoundedMultiplicityAccess().getUpperBoundUpperMultiplictyParserRuleCall_3_0(), semanticObject.getUpperBound()); | ||
500 | feeder.finish(); | ||
501 | } | ||
502 | |||
503 | |||
504 | /** | ||
505 | * Contexts: | ||
506 | * Statement returns BoundedScope | ||
507 | * ScopeDeclaration returns BoundedScope | ||
508 | * BoundedScope returns BoundedScope | ||
509 | * | ||
510 | * Constraint: | ||
511 | * ((lowerBound=INT? type=[Symbol|QualifiedName] upperBound=INT) | (upperBound=INT type=[Symbol|QualifiedName] lowerBound=INT?)) | ||
512 | */ | ||
513 | protected void sequence_BoundedScope(ISerializationContext context, BoundedScope semanticObject) { | ||
514 | genericSequencer.createSequence(context, semanticObject); | ||
515 | } | ||
516 | |||
517 | |||
518 | /** | ||
519 | * Contexts: | ||
520 | * AssertionOrDefinition.Assertion_1_0_0 returns Call | ||
521 | * AssertionOrDefinition.PredicateDefinition_1_1_0 returns Call | ||
522 | * AssertionOrDefinition.FunctionDefinition_1_2_0 returns Call | ||
523 | * Expression returns Call | ||
524 | * Expression.Forall_2_1_0 returns Call | ||
525 | * DisjunctiveExpression returns Call | ||
526 | * DisjunctiveExpression.Disjunction_1_0_0 returns Call | ||
527 | * DisjunctiveExpression.Case_1_1_0 returns Call | ||
528 | * ConjunctiveExpression returns Call | ||
529 | * ConjunctiveExpression.Conjunction_1_0 returns Call | ||
530 | * ComparisonExpression returns Call | ||
531 | * ComparisonExpression.BinaryExpression_1_0 returns Call | ||
532 | * AdditiveExpression returns Call | ||
533 | * AdditiveExpression.BinaryExpression_1_0 returns Call | ||
534 | * MultiplicativeExpression returns Call | ||
535 | * MultiplicativeExpression.BinaryExpression_1_0 returns Call | ||
536 | * ExponentialExpression returns Call | ||
537 | * ExponentialExpression.BinaryExpression_1_0 returns Call | ||
538 | * CastExpression returns Call | ||
539 | * CastExpression.CastExpression_1_0 returns Call | ||
540 | * UnaryExpression returns Call | ||
541 | * BracedAggregateExpression returns Call | ||
542 | * AtomicExpression returns Call | ||
543 | * Call returns Call | ||
544 | * | ||
545 | * Constraint: | ||
546 | * (functor=Reference argumentList=ArgumentList) | ||
547 | */ | ||
548 | protected void sequence_Call(ISerializationContext context, Call semanticObject) { | ||
549 | if (errorAcceptor != null) { | ||
550 | if (transientValues.isValueTransient(semanticObject, SolverLanguagePackage.Literals.CALL__FUNCTOR) == ValueTransient.YES) | ||
551 | errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, SolverLanguagePackage.Literals.CALL__FUNCTOR)); | ||
552 | if (transientValues.isValueTransient(semanticObject, SolverLanguagePackage.Literals.CALL__ARGUMENT_LIST) == ValueTransient.YES) | ||
553 | errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, SolverLanguagePackage.Literals.CALL__ARGUMENT_LIST)); | ||
554 | } | ||
555 | SequenceFeeder feeder = createSequencerFeeder(context, semanticObject); | ||
556 | feeder.accept(grammarAccess.getCallAccess().getFunctorReferenceParserRuleCall_0_0(), semanticObject.getFunctor()); | ||
557 | feeder.accept(grammarAccess.getCallAccess().getArgumentListArgumentListParserRuleCall_1_0(), semanticObject.getArgumentList()); | ||
558 | feeder.finish(); | ||
559 | } | ||
560 | |||
561 | |||
562 | /** | ||
563 | * Contexts: | ||
564 | * Case returns Case | ||
565 | * | ||
566 | * Constraint: | ||
567 | * (condition=ConjunctiveExpression body=ConjunctiveExpression) | ||
568 | */ | ||
569 | protected void sequence_Case(ISerializationContext context, Case semanticObject) { | ||
570 | if (errorAcceptor != null) { | ||
571 | if (transientValues.isValueTransient(semanticObject, SolverLanguagePackage.Literals.CASE__CONDITION) == ValueTransient.YES) | ||
572 | errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, SolverLanguagePackage.Literals.CASE__CONDITION)); | ||
573 | if (transientValues.isValueTransient(semanticObject, SolverLanguagePackage.Literals.CASE__BODY) == ValueTransient.YES) | ||
574 | errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, SolverLanguagePackage.Literals.CASE__BODY)); | ||
575 | } | ||
576 | SequenceFeeder feeder = createSequencerFeeder(context, semanticObject); | ||
577 | feeder.accept(grammarAccess.getCaseAccess().getConditionConjunctiveExpressionParserRuleCall_0_0(), semanticObject.getCondition()); | ||
578 | feeder.accept(grammarAccess.getCaseAccess().getBodyConjunctiveExpressionParserRuleCall_2_0(), semanticObject.getBody()); | ||
579 | feeder.finish(); | ||
580 | } | ||
581 | |||
582 | |||
583 | /** | ||
584 | * Contexts: | ||
585 | * AssertionOrDefinition.Assertion_1_0_0 returns CastExpression | ||
586 | * AssertionOrDefinition.PredicateDefinition_1_1_0 returns CastExpression | ||
587 | * AssertionOrDefinition.FunctionDefinition_1_2_0 returns CastExpression | ||
588 | * Expression returns CastExpression | ||
589 | * Expression.Forall_2_1_0 returns CastExpression | ||
590 | * DisjunctiveExpression returns CastExpression | ||
591 | * DisjunctiveExpression.Disjunction_1_0_0 returns CastExpression | ||
592 | * DisjunctiveExpression.Case_1_1_0 returns CastExpression | ||
593 | * ConjunctiveExpression returns CastExpression | ||
594 | * ConjunctiveExpression.Conjunction_1_0 returns CastExpression | ||
595 | * ComparisonExpression returns CastExpression | ||
596 | * ComparisonExpression.BinaryExpression_1_0 returns CastExpression | ||
597 | * AdditiveExpression returns CastExpression | ||
598 | * AdditiveExpression.BinaryExpression_1_0 returns CastExpression | ||
599 | * MultiplicativeExpression returns CastExpression | ||
600 | * MultiplicativeExpression.BinaryExpression_1_0 returns CastExpression | ||
601 | * ExponentialExpression returns CastExpression | ||
602 | * ExponentialExpression.BinaryExpression_1_0 returns CastExpression | ||
603 | * CastExpression returns CastExpression | ||
604 | * CastExpression.CastExpression_1_0 returns CastExpression | ||
605 | * UnaryExpression returns CastExpression | ||
606 | * BracedAggregateExpression returns CastExpression | ||
607 | * AtomicExpression returns CastExpression | ||
608 | * | ||
609 | * Constraint: | ||
610 | * (body=CastExpression_CastExpression_1_0 targetType=[Symbol|QualifiedName]) | ||
611 | */ | ||
612 | protected void sequence_CastExpression(ISerializationContext context, CastExpression semanticObject) { | ||
613 | if (errorAcceptor != null) { | ||
614 | if (transientValues.isValueTransient(semanticObject, SolverLanguagePackage.Literals.CAST_EXPRESSION__BODY) == ValueTransient.YES) | ||
615 | errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, SolverLanguagePackage.Literals.CAST_EXPRESSION__BODY)); | ||
616 | if (transientValues.isValueTransient(semanticObject, SolverLanguagePackage.Literals.CAST_EXPRESSION__TARGET_TYPE) == ValueTransient.YES) | ||
617 | errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, SolverLanguagePackage.Literals.CAST_EXPRESSION__TARGET_TYPE)); | ||
618 | } | ||
619 | SequenceFeeder feeder = createSequencerFeeder(context, semanticObject); | ||
620 | feeder.accept(grammarAccess.getCastExpressionAccess().getCastExpressionBodyAction_1_0(), semanticObject.getBody()); | ||
621 | feeder.accept(grammarAccess.getCastExpressionAccess().getTargetTypeSymbolQualifiedNameParserRuleCall_1_2_0_1(), semanticObject.eGet(SolverLanguagePackage.Literals.CAST_EXPRESSION__TARGET_TYPE, false)); | ||
622 | feeder.finish(); | ||
623 | } | ||
624 | |||
625 | |||
626 | /** | ||
627 | * Contexts: | ||
628 | * Statement returns ClassDeclaration | ||
629 | * ClassDeclaration returns ClassDeclaration | ||
630 | * | ||
631 | * Constraint: | ||
632 | * ((abstract?='abstract' | root?='root')* name=ID (supertypes+=[Symbol|QualifiedName] supertypes+=[Symbol|QualifiedName]*)? fields+=Field*) | ||
633 | */ | ||
634 | protected void sequence_ClassDeclaration(ISerializationContext context, ClassDeclaration semanticObject) { | ||
635 | genericSequencer.createSequence(context, semanticObject); | ||
636 | } | ||
637 | |||
638 | |||
639 | /** | ||
640 | * Contexts: | ||
641 | * AssertionOrDefinition.Assertion_1_0_0 returns ConditionalExpression | ||
642 | * AssertionOrDefinition.PredicateDefinition_1_1_0 returns ConditionalExpression | ||
643 | * AssertionOrDefinition.FunctionDefinition_1_2_0 returns ConditionalExpression | ||
644 | * Expression returns ConditionalExpression | ||
645 | * Expression.Forall_2_1_0 returns ConditionalExpression | ||
646 | * ConditionalExpression returns ConditionalExpression | ||
647 | * DisjunctiveExpression returns ConditionalExpression | ||
648 | * DisjunctiveExpression.Disjunction_1_0_0 returns ConditionalExpression | ||
649 | * DisjunctiveExpression.Case_1_1_0 returns ConditionalExpression | ||
650 | * ConjunctiveExpression returns ConditionalExpression | ||
651 | * ConjunctiveExpression.Conjunction_1_0 returns ConditionalExpression | ||
652 | * ComparisonExpression returns ConditionalExpression | ||
653 | * ComparisonExpression.BinaryExpression_1_0 returns ConditionalExpression | ||
654 | * AdditiveExpression returns ConditionalExpression | ||
655 | * AdditiveExpression.BinaryExpression_1_0 returns ConditionalExpression | ||
656 | * MultiplicativeExpression returns ConditionalExpression | ||
657 | * MultiplicativeExpression.BinaryExpression_1_0 returns ConditionalExpression | ||
658 | * ExponentialExpression returns ConditionalExpression | ||
659 | * ExponentialExpression.BinaryExpression_1_0 returns ConditionalExpression | ||
660 | * CastExpression returns ConditionalExpression | ||
661 | * CastExpression.CastExpression_1_0 returns ConditionalExpression | ||
662 | * UnaryExpression returns ConditionalExpression | ||
663 | * BracedAggregateExpression returns ConditionalExpression | ||
664 | * AtomicExpression returns ConditionalExpression | ||
665 | * | ||
666 | * Constraint: | ||
667 | * (condition=DisjunctiveExpression then=Expression else=Expression) | ||
668 | */ | ||
669 | protected void sequence_ConditionalExpression(ISerializationContext context, ConditionalExpression semanticObject) { | ||
670 | if (errorAcceptor != null) { | ||
671 | if (transientValues.isValueTransient(semanticObject, SolverLanguagePackage.Literals.CONDITIONAL_EXPRESSION__CONDITION) == ValueTransient.YES) | ||
672 | errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, SolverLanguagePackage.Literals.CONDITIONAL_EXPRESSION__CONDITION)); | ||
673 | if (transientValues.isValueTransient(semanticObject, SolverLanguagePackage.Literals.CONDITIONAL_EXPRESSION__THEN) == ValueTransient.YES) | ||
674 | errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, SolverLanguagePackage.Literals.CONDITIONAL_EXPRESSION__THEN)); | ||
675 | if (transientValues.isValueTransient(semanticObject, SolverLanguagePackage.Literals.CONDITIONAL_EXPRESSION__ELSE) == ValueTransient.YES) | ||
676 | errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, SolverLanguagePackage.Literals.CONDITIONAL_EXPRESSION__ELSE)); | ||
677 | } | ||
678 | SequenceFeeder feeder = createSequencerFeeder(context, semanticObject); | ||
679 | feeder.accept(grammarAccess.getConditionalExpressionAccess().getConditionDisjunctiveExpressionParserRuleCall_1_0(), semanticObject.getCondition()); | ||
680 | feeder.accept(grammarAccess.getConditionalExpressionAccess().getThenExpressionParserRuleCall_3_0(), semanticObject.getThen()); | ||
681 | feeder.accept(grammarAccess.getConditionalExpressionAccess().getElseExpressionParserRuleCall_5_0(), semanticObject.getElse()); | ||
682 | feeder.finish(); | ||
683 | } | ||
684 | |||
685 | |||
686 | /** | ||
687 | * Contexts: | ||
688 | * AssertionOrDefinition.Assertion_1_0_0 returns Conjunction | ||
689 | * AssertionOrDefinition.PredicateDefinition_1_1_0 returns Conjunction | ||
690 | * AssertionOrDefinition.FunctionDefinition_1_2_0 returns Conjunction | ||
691 | * Expression returns Conjunction | ||
692 | * Expression.Forall_2_1_0 returns Conjunction | ||
693 | * DisjunctiveExpression returns Conjunction | ||
694 | * DisjunctiveExpression.Disjunction_1_0_0 returns Conjunction | ||
695 | * DisjunctiveExpression.Case_1_1_0 returns Conjunction | ||
696 | * ConjunctiveExpression returns Conjunction | ||
697 | * ConjunctiveExpression.Conjunction_1_0 returns Conjunction | ||
698 | * ComparisonExpression returns Conjunction | ||
699 | * ComparisonExpression.BinaryExpression_1_0 returns Conjunction | ||
700 | * AdditiveExpression returns Conjunction | ||
701 | * AdditiveExpression.BinaryExpression_1_0 returns Conjunction | ||
702 | * MultiplicativeExpression returns Conjunction | ||
703 | * MultiplicativeExpression.BinaryExpression_1_0 returns Conjunction | ||
704 | * ExponentialExpression returns Conjunction | ||
705 | * ExponentialExpression.BinaryExpression_1_0 returns Conjunction | ||
706 | * CastExpression returns Conjunction | ||
707 | * CastExpression.CastExpression_1_0 returns Conjunction | ||
708 | * UnaryExpression returns Conjunction | ||
709 | * BracedAggregateExpression returns Conjunction | ||
710 | * AtomicExpression returns Conjunction | ||
711 | * | ||
712 | * Constraint: | ||
713 | * (children+=ConjunctiveExpression_Conjunction_1_0 children+=ComparisonExpression+) | ||
714 | */ | ||
715 | protected void sequence_ConjunctiveExpression(ISerializationContext context, Conjunction semanticObject) { | ||
716 | genericSequencer.createSequence(context, semanticObject); | ||
717 | } | ||
718 | |||
719 | |||
720 | /** | ||
721 | * Contexts: | ||
722 | * AssertionOrDefinition.Assertion_1_0_0 returns Count | ||
723 | * AssertionOrDefinition.PredicateDefinition_1_1_0 returns Count | ||
724 | * AssertionOrDefinition.FunctionDefinition_1_2_0 returns Count | ||
725 | * Expression returns Count | ||
726 | * Expression.Forall_2_1_0 returns Count | ||
727 | * DisjunctiveExpression returns Count | ||
728 | * DisjunctiveExpression.Disjunction_1_0_0 returns Count | ||
729 | * DisjunctiveExpression.Case_1_1_0 returns Count | ||
730 | * ConjunctiveExpression returns Count | ||
731 | * ConjunctiveExpression.Conjunction_1_0 returns Count | ||
732 | * ComparisonExpression returns Count | ||
733 | * ComparisonExpression.BinaryExpression_1_0 returns Count | ||
734 | * AdditiveExpression returns Count | ||
735 | * AdditiveExpression.BinaryExpression_1_0 returns Count | ||
736 | * MultiplicativeExpression returns Count | ||
737 | * MultiplicativeExpression.BinaryExpression_1_0 returns Count | ||
738 | * ExponentialExpression returns Count | ||
739 | * ExponentialExpression.BinaryExpression_1_0 returns Count | ||
740 | * CastExpression returns Count | ||
741 | * CastExpression.CastExpression_1_0 returns Count | ||
742 | * UnaryExpression returns Count | ||
743 | * BracedAggregateExpression returns Count | ||
744 | * Count returns Count | ||
745 | * AtomicExpression returns Count | ||
746 | * | ||
747 | * Constraint: | ||
748 | * condition=Expression | ||
749 | */ | ||
750 | protected void sequence_Count(ISerializationContext context, Count semanticObject) { | ||
751 | if (errorAcceptor != null) { | ||
752 | if (transientValues.isValueTransient(semanticObject, SolverLanguagePackage.Literals.AGGREGATE_EXPRESSION__CONDITION) == ValueTransient.YES) | ||
753 | errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, SolverLanguagePackage.Literals.AGGREGATE_EXPRESSION__CONDITION)); | ||
754 | } | ||
755 | SequenceFeeder feeder = createSequencerFeeder(context, semanticObject); | ||
756 | feeder.accept(grammarAccess.getCountAccess().getConditionExpressionParserRuleCall_2_0(), semanticObject.getCondition()); | ||
757 | feeder.finish(); | ||
758 | } | ||
759 | |||
760 | |||
761 | /** | ||
762 | * Contexts: | ||
763 | * Statement returns DefaultAssertion | ||
764 | * DefaultAssertion returns DefaultAssertion | ||
765 | * | ||
766 | * Constraint: | ||
767 | * (expression=Call range=Expression?) | ||
768 | */ | ||
769 | protected void sequence_DefaultAssertion(ISerializationContext context, DefaultAssertion semanticObject) { | ||
770 | genericSequencer.createSequence(context, semanticObject); | ||
771 | } | ||
772 | |||
773 | |||
774 | /** | ||
775 | * Contexts: | ||
776 | * AssertionOrDefinition.Assertion_1_0_0 returns Disjunction | ||
777 | * AssertionOrDefinition.PredicateDefinition_1_1_0 returns Disjunction | ||
778 | * AssertionOrDefinition.FunctionDefinition_1_2_0 returns Disjunction | ||
779 | * Expression returns Disjunction | ||
780 | * Expression.Forall_2_1_0 returns Disjunction | ||
781 | * DisjunctiveExpression returns Disjunction | ||
782 | * DisjunctiveExpression.Disjunction_1_0_0 returns Disjunction | ||
783 | * DisjunctiveExpression.Case_1_1_0 returns Disjunction | ||
784 | * ConjunctiveExpression returns Disjunction | ||
785 | * ConjunctiveExpression.Conjunction_1_0 returns Disjunction | ||
786 | * ComparisonExpression returns Disjunction | ||
787 | * ComparisonExpression.BinaryExpression_1_0 returns Disjunction | ||
788 | * AdditiveExpression returns Disjunction | ||
789 | * AdditiveExpression.BinaryExpression_1_0 returns Disjunction | ||
790 | * MultiplicativeExpression returns Disjunction | ||
791 | * MultiplicativeExpression.BinaryExpression_1_0 returns Disjunction | ||
792 | * ExponentialExpression returns Disjunction | ||
793 | * ExponentialExpression.BinaryExpression_1_0 returns Disjunction | ||
794 | * CastExpression returns Disjunction | ||
795 | * CastExpression.CastExpression_1_0 returns Disjunction | ||
796 | * UnaryExpression returns Disjunction | ||
797 | * BracedAggregateExpression returns Disjunction | ||
798 | * AtomicExpression returns Disjunction | ||
799 | * | ||
800 | * Constraint: | ||
801 | * (children+=DisjunctiveExpression_Disjunction_1_0_0 children+=ConjunctiveExpression+) | ||
802 | */ | ||
803 | protected void sequence_DisjunctiveExpression(ISerializationContext context, Disjunction semanticObject) { | ||
804 | genericSequencer.createSequence(context, semanticObject); | ||
805 | } | ||
806 | |||
807 | |||
808 | /** | ||
809 | * Contexts: | ||
810 | * AssertionOrDefinition.Assertion_1_0_0 returns Switch | ||
811 | * AssertionOrDefinition.PredicateDefinition_1_1_0 returns Switch | ||
812 | * AssertionOrDefinition.FunctionDefinition_1_2_0 returns Switch | ||
813 | * Expression returns Switch | ||
814 | * Expression.Forall_2_1_0 returns Switch | ||
815 | * DisjunctiveExpression returns Switch | ||
816 | * DisjunctiveExpression.Disjunction_1_0_0 returns Switch | ||
817 | * DisjunctiveExpression.Case_1_1_0 returns Switch | ||
818 | * ConjunctiveExpression returns Switch | ||
819 | * ConjunctiveExpression.Conjunction_1_0 returns Switch | ||
820 | * ComparisonExpression returns Switch | ||
821 | * ComparisonExpression.BinaryExpression_1_0 returns Switch | ||
822 | * AdditiveExpression returns Switch | ||
823 | * AdditiveExpression.BinaryExpression_1_0 returns Switch | ||
824 | * MultiplicativeExpression returns Switch | ||
825 | * MultiplicativeExpression.BinaryExpression_1_0 returns Switch | ||
826 | * ExponentialExpression returns Switch | ||
827 | * ExponentialExpression.BinaryExpression_1_0 returns Switch | ||
828 | * CastExpression returns Switch | ||
829 | * CastExpression.CastExpression_1_0 returns Switch | ||
830 | * UnaryExpression returns Switch | ||
831 | * BracedAggregateExpression returns Switch | ||
832 | * AtomicExpression returns Switch | ||
833 | * | ||
834 | * Constraint: | ||
835 | * (cases+=DisjunctiveExpression_Switch_1_1_3 cases+=Case*) | ||
836 | */ | ||
837 | protected void sequence_DisjunctiveExpression(ISerializationContext context, Switch semanticObject) { | ||
838 | genericSequencer.createSequence(context, semanticObject); | ||
839 | } | ||
840 | |||
841 | |||
842 | /** | ||
843 | * Contexts: | ||
844 | * DisjunctiveExpression.Switch_1_1_3 returns Case | ||
845 | * | ||
846 | * Constraint: | ||
847 | * (condition=DisjunctiveExpression_Case_1_1_0 body=ConjunctiveExpression) | ||
848 | */ | ||
849 | protected void sequence_DisjunctiveExpression_Switch_1_1_3(ISerializationContext context, Case semanticObject) { | ||
850 | if (errorAcceptor != null) { | ||
851 | if (transientValues.isValueTransient(semanticObject, SolverLanguagePackage.Literals.CASE__CONDITION) == ValueTransient.YES) | ||
852 | errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, SolverLanguagePackage.Literals.CASE__CONDITION)); | ||
853 | if (transientValues.isValueTransient(semanticObject, SolverLanguagePackage.Literals.CASE__BODY) == ValueTransient.YES) | ||
854 | errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, SolverLanguagePackage.Literals.CASE__BODY)); | ||
855 | } | ||
856 | SequenceFeeder feeder = createSequencerFeeder(context, semanticObject); | ||
857 | feeder.accept(grammarAccess.getDisjunctiveExpressionAccess().getCaseConditionAction_1_1_0(), semanticObject.getCondition()); | ||
858 | feeder.accept(grammarAccess.getDisjunctiveExpressionAccess().getBodyConjunctiveExpressionParserRuleCall_1_1_2_0(), semanticObject.getBody()); | ||
859 | feeder.finish(); | ||
860 | } | ||
861 | |||
862 | |||
863 | /** | ||
864 | * Contexts: | ||
865 | * AssertionOrDefinition.Assertion_1_0_0 returns EmptyLiteral | ||
866 | * AssertionOrDefinition.PredicateDefinition_1_1_0 returns EmptyLiteral | ||
867 | * AssertionOrDefinition.FunctionDefinition_1_2_0 returns EmptyLiteral | ||
868 | * Expression returns EmptyLiteral | ||
869 | * Expression.Forall_2_1_0 returns EmptyLiteral | ||
870 | * DisjunctiveExpression returns EmptyLiteral | ||
871 | * DisjunctiveExpression.Disjunction_1_0_0 returns EmptyLiteral | ||
872 | * DisjunctiveExpression.Case_1_1_0 returns EmptyLiteral | ||
873 | * ConjunctiveExpression returns EmptyLiteral | ||
874 | * ConjunctiveExpression.Conjunction_1_0 returns EmptyLiteral | ||
875 | * ComparisonExpression returns EmptyLiteral | ||
876 | * ComparisonExpression.BinaryExpression_1_0 returns EmptyLiteral | ||
877 | * AdditiveExpression returns EmptyLiteral | ||
878 | * AdditiveExpression.BinaryExpression_1_0 returns EmptyLiteral | ||
879 | * MultiplicativeExpression returns EmptyLiteral | ||
880 | * MultiplicativeExpression.BinaryExpression_1_0 returns EmptyLiteral | ||
881 | * ExponentialExpression returns EmptyLiteral | ||
882 | * ExponentialExpression.BinaryExpression_1_0 returns EmptyLiteral | ||
883 | * CastExpression returns EmptyLiteral | ||
884 | * CastExpression.CastExpression_1_0 returns EmptyLiteral | ||
885 | * UnaryExpression returns EmptyLiteral | ||
886 | * BracedAggregateExpression returns EmptyLiteral | ||
887 | * AtomicExpression returns EmptyLiteral | ||
888 | * Literal returns EmptyLiteral | ||
889 | * EmptyLiteral returns EmptyLiteral | ||
890 | * | ||
891 | * Constraint: | ||
892 | * {EmptyLiteral} | ||
893 | */ | ||
894 | protected void sequence_EmptyLiteral(ISerializationContext context, EmptyLiteral semanticObject) { | ||
895 | genericSequencer.createSequence(context, semanticObject); | ||
896 | } | ||
897 | |||
898 | |||
899 | /** | ||
900 | * Contexts: | ||
901 | * Statement returns EnumDeclaration | ||
902 | * EnumDeclaration returns EnumDeclaration | ||
903 | * | ||
904 | * Constraint: | ||
905 | * (name=ID (literals+=EnumLiteral literals+=EnumLiteral*)?) | ||
906 | */ | ||
907 | protected void sequence_EnumDeclaration(ISerializationContext context, EnumDeclaration semanticObject) { | ||
908 | genericSequencer.createSequence(context, semanticObject); | ||
909 | } | ||
910 | |||
911 | |||
912 | /** | ||
913 | * Contexts: | ||
914 | * EnumLiteral returns EnumLiteral | ||
915 | * | ||
916 | * Constraint: | ||
917 | * name=ID | ||
918 | */ | ||
919 | protected void sequence_EnumLiteral(ISerializationContext context, EnumLiteral semanticObject) { | ||
920 | if (errorAcceptor != null) { | ||
921 | if (transientValues.isValueTransient(semanticObject, SolverLanguagePackage.Literals.ENUM_LITERAL__NAME) == ValueTransient.YES) | ||
922 | errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, SolverLanguagePackage.Literals.ENUM_LITERAL__NAME)); | ||
923 | } | ||
924 | SequenceFeeder feeder = createSequencerFeeder(context, semanticObject); | ||
925 | feeder.accept(grammarAccess.getEnumLiteralAccess().getNameIDTerminalRuleCall_0(), semanticObject.getName()); | ||
926 | feeder.finish(); | ||
927 | } | ||
928 | |||
929 | |||
930 | /** | ||
931 | * Contexts: | ||
932 | * Multiplicity returns ExactMultiplicity | ||
933 | * ExactMultiplicity returns ExactMultiplicity | ||
934 | * | ||
935 | * Constraint: | ||
936 | * value=UpperMultiplicty | ||
937 | */ | ||
938 | protected void sequence_ExactMultiplicity(ISerializationContext context, ExactMultiplicity semanticObject) { | ||
939 | if (errorAcceptor != null) { | ||
940 | if (transientValues.isValueTransient(semanticObject, SolverLanguagePackage.Literals.EXACT_MULTIPLICITY__VALUE) == ValueTransient.YES) | ||
941 | errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, SolverLanguagePackage.Literals.EXACT_MULTIPLICITY__VALUE)); | ||
942 | } | ||
943 | SequenceFeeder feeder = createSequencerFeeder(context, semanticObject); | ||
944 | feeder.accept(grammarAccess.getExactMultiplicityAccess().getValueUpperMultiplictyParserRuleCall_1_0(), semanticObject.getValue()); | ||
945 | feeder.finish(); | ||
946 | } | ||
947 | |||
948 | |||
949 | /** | ||
950 | * Contexts: | ||
951 | * Statement returns ExactScope | ||
952 | * ScopeDeclaration returns ExactScope | ||
953 | * ExactScope returns ExactScope | ||
954 | * | ||
955 | * Constraint: | ||
956 | * (type=[Symbol|QualifiedName] size=INT) | ||
957 | */ | ||
958 | protected void sequence_ExactScope(ISerializationContext context, ExactScope semanticObject) { | ||
959 | if (errorAcceptor != null) { | ||
960 | if (transientValues.isValueTransient(semanticObject, SolverLanguagePackage.Literals.SCOPE_DECLARATION__TYPE) == ValueTransient.YES) | ||
961 | errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, SolverLanguagePackage.Literals.SCOPE_DECLARATION__TYPE)); | ||
962 | if (transientValues.isValueTransient(semanticObject, SolverLanguagePackage.Literals.EXACT_SCOPE__SIZE) == ValueTransient.YES) | ||
963 | errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, SolverLanguagePackage.Literals.EXACT_SCOPE__SIZE)); | ||
964 | } | ||
965 | SequenceFeeder feeder = createSequencerFeeder(context, semanticObject); | ||
966 | feeder.accept(grammarAccess.getExactScopeAccess().getTypeSymbolQualifiedNameParserRuleCall_1_0_1(), semanticObject.eGet(SolverLanguagePackage.Literals.SCOPE_DECLARATION__TYPE, false)); | ||
967 | feeder.accept(grammarAccess.getExactScopeAccess().getSizeINTTerminalRuleCall_3_0(), semanticObject.getSize()); | ||
968 | feeder.finish(); | ||
969 | } | ||
970 | |||
971 | |||
972 | /** | ||
973 | * Contexts: | ||
974 | * Argument returns ExpressionArgument | ||
975 | * ExpressionArgument returns ExpressionArgument | ||
976 | * | ||
977 | * Constraint: | ||
978 | * expression=ComparisonExpression | ||
979 | */ | ||
980 | protected void sequence_ExpressionArgument(ISerializationContext context, ExpressionArgument semanticObject) { | ||
981 | if (errorAcceptor != null) { | ||
982 | if (transientValues.isValueTransient(semanticObject, SolverLanguagePackage.Literals.EXPRESSION_ARGUMENT__EXPRESSION) == ValueTransient.YES) | ||
983 | errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, SolverLanguagePackage.Literals.EXPRESSION_ARGUMENT__EXPRESSION)); | ||
984 | } | ||
985 | SequenceFeeder feeder = createSequencerFeeder(context, semanticObject); | ||
986 | feeder.accept(grammarAccess.getExpressionArgumentAccess().getExpressionComparisonExpressionParserRuleCall_0(), semanticObject.getExpression()); | ||
987 | feeder.finish(); | ||
988 | } | ||
989 | |||
990 | |||
991 | /** | ||
992 | * Contexts: | ||
993 | * AssertionOrDefinition.Assertion_1_0_0 returns Forall | ||
994 | * AssertionOrDefinition.PredicateDefinition_1_1_0 returns Forall | ||
995 | * AssertionOrDefinition.FunctionDefinition_1_2_0 returns Forall | ||
996 | * Expression returns Forall | ||
997 | * Expression.Forall_2_1_0 returns Forall | ||
998 | * DisjunctiveExpression returns Forall | ||
999 | * DisjunctiveExpression.Disjunction_1_0_0 returns Forall | ||
1000 | * DisjunctiveExpression.Case_1_1_0 returns Forall | ||
1001 | * ConjunctiveExpression returns Forall | ||
1002 | * ConjunctiveExpression.Conjunction_1_0 returns Forall | ||
1003 | * ComparisonExpression returns Forall | ||
1004 | * ComparisonExpression.BinaryExpression_1_0 returns Forall | ||
1005 | * AdditiveExpression returns Forall | ||
1006 | * AdditiveExpression.BinaryExpression_1_0 returns Forall | ||
1007 | * MultiplicativeExpression returns Forall | ||
1008 | * MultiplicativeExpression.BinaryExpression_1_0 returns Forall | ||
1009 | * ExponentialExpression returns Forall | ||
1010 | * ExponentialExpression.BinaryExpression_1_0 returns Forall | ||
1011 | * CastExpression returns Forall | ||
1012 | * CastExpression.CastExpression_1_0 returns Forall | ||
1013 | * UnaryExpression returns Forall | ||
1014 | * BracedAggregateExpression returns Forall | ||
1015 | * AtomicExpression returns Forall | ||
1016 | * | ||
1017 | * Constraint: | ||
1018 | * (condition=Expression_Forall_2_1_0 body=DisjunctiveExpression) | ||
1019 | */ | ||
1020 | protected void sequence_Expression(ISerializationContext context, Forall semanticObject) { | ||
1021 | if (errorAcceptor != null) { | ||
1022 | if (transientValues.isValueTransient(semanticObject, SolverLanguagePackage.Literals.AGGREGATE_EXPRESSION__CONDITION) == ValueTransient.YES) | ||
1023 | errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, SolverLanguagePackage.Literals.AGGREGATE_EXPRESSION__CONDITION)); | ||
1024 | if (transientValues.isValueTransient(semanticObject, SolverLanguagePackage.Literals.FORALL__BODY) == ValueTransient.YES) | ||
1025 | errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, SolverLanguagePackage.Literals.FORALL__BODY)); | ||
1026 | } | ||
1027 | SequenceFeeder feeder = createSequencerFeeder(context, semanticObject); | ||
1028 | feeder.accept(grammarAccess.getExpressionAccess().getForallConditionAction_2_1_0(), semanticObject.getCondition()); | ||
1029 | feeder.accept(grammarAccess.getExpressionAccess().getBodyDisjunctiveExpressionParserRuleCall_2_1_2_0(), semanticObject.getBody()); | ||
1030 | feeder.finish(); | ||
1031 | } | ||
1032 | |||
1033 | |||
1034 | /** | ||
1035 | * Contexts: | ||
1036 | * Statement returns ExternAggregationOperatorDeclaration | ||
1037 | * ExternDeclaration returns ExternAggregationOperatorDeclaration | ||
1038 | * ExternAggregationOperatorDeclaration returns ExternAggregationOperatorDeclaration | ||
1039 | * | ||
1040 | * Constraint: | ||
1041 | * (resultType=[Symbol|QualifiedName] name=QualifiedName argumentType=[Symbol|QualifiedName]) | ||
1042 | */ | ||
1043 | protected void sequence_ExternAggregationOperatorDeclaration(ISerializationContext context, ExternAggregationOperatorDeclaration semanticObject) { | ||
1044 | if (errorAcceptor != null) { | ||
1045 | if (transientValues.isValueTransient(semanticObject, SolverLanguagePackage.Literals.EXTERN_AGGREGATION_OPERATOR_DECLARATION__RESULT_TYPE) == ValueTransient.YES) | ||
1046 | errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, SolverLanguagePackage.Literals.EXTERN_AGGREGATION_OPERATOR_DECLARATION__RESULT_TYPE)); | ||
1047 | if (transientValues.isValueTransient(semanticObject, SolverLanguagePackage.Literals.EXTERN_DECLARATION__NAME) == ValueTransient.YES) | ||
1048 | errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, SolverLanguagePackage.Literals.EXTERN_DECLARATION__NAME)); | ||
1049 | if (transientValues.isValueTransient(semanticObject, SolverLanguagePackage.Literals.EXTERN_AGGREGATION_OPERATOR_DECLARATION__ARGUMENT_TYPE) == ValueTransient.YES) | ||
1050 | errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, SolverLanguagePackage.Literals.EXTERN_AGGREGATION_OPERATOR_DECLARATION__ARGUMENT_TYPE)); | ||
1051 | } | ||
1052 | SequenceFeeder feeder = createSequencerFeeder(context, semanticObject); | ||
1053 | feeder.accept(grammarAccess.getExternAggregationOperatorDeclarationAccess().getResultTypeSymbolQualifiedNameParserRuleCall_1_0_1(), semanticObject.eGet(SolverLanguagePackage.Literals.EXTERN_AGGREGATION_OPERATOR_DECLARATION__RESULT_TYPE, false)); | ||
1054 | feeder.accept(grammarAccess.getExternAggregationOperatorDeclarationAccess().getNameQualifiedNameParserRuleCall_2_0(), semanticObject.getName()); | ||
1055 | feeder.accept(grammarAccess.getExternAggregationOperatorDeclarationAccess().getArgumentTypeSymbolQualifiedNameParserRuleCall_4_0_1(), semanticObject.eGet(SolverLanguagePackage.Literals.EXTERN_AGGREGATION_OPERATOR_DECLARATION__ARGUMENT_TYPE, false)); | ||
1056 | feeder.finish(); | ||
1057 | } | ||
1058 | |||
1059 | |||
1060 | /** | ||
1061 | * Contexts: | ||
1062 | * Statement returns ExternDatatypeDeclaration | ||
1063 | * ExternDeclaration returns ExternDatatypeDeclaration | ||
1064 | * ExternDatatypeDeclaration returns ExternDatatypeDeclaration | ||
1065 | * | ||
1066 | * Constraint: | ||
1067 | * name=QualifiedName | ||
1068 | */ | ||
1069 | protected void sequence_ExternDatatypeDeclaration(ISerializationContext context, ExternDatatypeDeclaration semanticObject) { | ||
1070 | if (errorAcceptor != null) { | ||
1071 | if (transientValues.isValueTransient(semanticObject, SolverLanguagePackage.Literals.EXTERN_DECLARATION__NAME) == ValueTransient.YES) | ||
1072 | errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, SolverLanguagePackage.Literals.EXTERN_DECLARATION__NAME)); | ||
1073 | } | ||
1074 | SequenceFeeder feeder = createSequencerFeeder(context, semanticObject); | ||
1075 | feeder.accept(grammarAccess.getExternDatatypeDeclarationAccess().getNameQualifiedNameParserRuleCall_2_0(), semanticObject.getName()); | ||
1076 | feeder.finish(); | ||
1077 | } | ||
1078 | |||
1079 | |||
1080 | /** | ||
1081 | * Contexts: | ||
1082 | * Statement returns ExternFunctionDeclaration | ||
1083 | * ExternDeclaration returns ExternFunctionDeclaration | ||
1084 | * ExternFunctionDeclaration returns ExternFunctionDeclaration | ||
1085 | * | ||
1086 | * Constraint: | ||
1087 | * (resultType=[Symbol|QualifiedName] name=QualifiedName argumentList=ArgumentList) | ||
1088 | */ | ||
1089 | protected void sequence_ExternFunctionDeclaration(ISerializationContext context, ExternFunctionDeclaration semanticObject) { | ||
1090 | if (errorAcceptor != null) { | ||
1091 | if (transientValues.isValueTransient(semanticObject, SolverLanguagePackage.Literals.EXTERN_FUNCTION_DECLARATION__RESULT_TYPE) == ValueTransient.YES) | ||
1092 | errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, SolverLanguagePackage.Literals.EXTERN_FUNCTION_DECLARATION__RESULT_TYPE)); | ||
1093 | if (transientValues.isValueTransient(semanticObject, SolverLanguagePackage.Literals.EXTERN_DECLARATION__NAME) == ValueTransient.YES) | ||
1094 | errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, SolverLanguagePackage.Literals.EXTERN_DECLARATION__NAME)); | ||
1095 | if (transientValues.isValueTransient(semanticObject, SolverLanguagePackage.Literals.EXTERN_FUNCTOR_DECLARATION__ARGUMENT_LIST) == ValueTransient.YES) | ||
1096 | errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, SolverLanguagePackage.Literals.EXTERN_FUNCTOR_DECLARATION__ARGUMENT_LIST)); | ||
1097 | } | ||
1098 | SequenceFeeder feeder = createSequencerFeeder(context, semanticObject); | ||
1099 | feeder.accept(grammarAccess.getExternFunctionDeclarationAccess().getResultTypeSymbolQualifiedNameParserRuleCall_1_0_1(), semanticObject.eGet(SolverLanguagePackage.Literals.EXTERN_FUNCTION_DECLARATION__RESULT_TYPE, false)); | ||
1100 | feeder.accept(grammarAccess.getExternFunctionDeclarationAccess().getNameQualifiedNameParserRuleCall_2_0(), semanticObject.getName()); | ||
1101 | feeder.accept(grammarAccess.getExternFunctionDeclarationAccess().getArgumentListArgumentListParserRuleCall_3_0(), semanticObject.getArgumentList()); | ||
1102 | feeder.finish(); | ||
1103 | } | ||
1104 | |||
1105 | |||
1106 | /** | ||
1107 | * Contexts: | ||
1108 | * Statement returns ExternPredicateDeclaration | ||
1109 | * ExternDeclaration returns ExternPredicateDeclaration | ||
1110 | * ExternPredicateDeclaration returns ExternPredicateDeclaration | ||
1111 | * | ||
1112 | * Constraint: | ||
1113 | * ((functional?='functional' | error?='error')* name=QualifiedName argumentList=ArgumentList) | ||
1114 | */ | ||
1115 | protected void sequence_ExternPredicateDeclaration(ISerializationContext context, ExternPredicateDeclaration semanticObject) { | ||
1116 | genericSequencer.createSequence(context, semanticObject); | ||
1117 | } | ||
1118 | |||
1119 | |||
1120 | /** | ||
1121 | * Contexts: | ||
1122 | * Field returns Field | ||
1123 | * | ||
1124 | * Constraint: | ||
1125 | * ( | ||
1126 | * (containment?='contains' | crossReference?='refers')? | ||
1127 | * type=[Symbol|QualifiedName] | ||
1128 | * multiplicity=Multiplicity? | ||
1129 | * name=ID | ||
1130 | * opposite=[Symbol|QualifiedName]? | ||
1131 | * ) | ||
1132 | */ | ||
1133 | protected void sequence_Field(ISerializationContext context, Field semanticObject) { | ||
1134 | genericSequencer.createSequence(context, semanticObject); | ||
1135 | } | ||
1136 | |||
1137 | |||
1138 | /** | ||
1139 | * Contexts: | ||
1140 | * FunctionDefinition returns FunctionDefinition | ||
1141 | * | ||
1142 | * Constraint: | ||
1143 | * (resultType=[Symbol|QualifiedName] head=Call body=Expression) | ||
1144 | */ | ||
1145 | protected void sequence_FunctionDefinition(ISerializationContext context, FunctionDefinition semanticObject) { | ||
1146 | if (errorAcceptor != null) { | ||
1147 | if (transientValues.isValueTransient(semanticObject, SolverLanguagePackage.Literals.FUNCTION_DEFINITION__RESULT_TYPE) == ValueTransient.YES) | ||
1148 | errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, SolverLanguagePackage.Literals.FUNCTION_DEFINITION__RESULT_TYPE)); | ||
1149 | if (transientValues.isValueTransient(semanticObject, SolverLanguagePackage.Literals.FUNCTOR_DEFINITON__HEAD) == ValueTransient.YES) | ||
1150 | errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, SolverLanguagePackage.Literals.FUNCTOR_DEFINITON__HEAD)); | ||
1151 | if (transientValues.isValueTransient(semanticObject, SolverLanguagePackage.Literals.FUNCTOR_DEFINITON__BODY) == ValueTransient.YES) | ||
1152 | errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, SolverLanguagePackage.Literals.FUNCTOR_DEFINITON__BODY)); | ||
1153 | } | ||
1154 | SequenceFeeder feeder = createSequencerFeeder(context, semanticObject); | ||
1155 | feeder.accept(grammarAccess.getFunctionDefinitionAccess().getResultTypeSymbolQualifiedNameParserRuleCall_0_0_1(), semanticObject.eGet(SolverLanguagePackage.Literals.FUNCTION_DEFINITION__RESULT_TYPE, false)); | ||
1156 | feeder.accept(grammarAccess.getFunctionDefinitionAccess().getHeadCallParserRuleCall_1_0(), semanticObject.getHead()); | ||
1157 | feeder.accept(grammarAccess.getFunctionDefinitionAccess().getBodyExpressionParserRuleCall_3_0(), semanticObject.getBody()); | ||
1158 | feeder.finish(); | ||
1159 | } | ||
1160 | |||
1161 | |||
1162 | /** | ||
1163 | * Contexts: | ||
1164 | * AssertionOrDefinition.Assertion_1_0_0 returns InfinityLiteral | ||
1165 | * AssertionOrDefinition.PredicateDefinition_1_1_0 returns InfinityLiteral | ||
1166 | * AssertionOrDefinition.FunctionDefinition_1_2_0 returns InfinityLiteral | ||
1167 | * Expression returns InfinityLiteral | ||
1168 | * Expression.Forall_2_1_0 returns InfinityLiteral | ||
1169 | * DisjunctiveExpression returns InfinityLiteral | ||
1170 | * DisjunctiveExpression.Disjunction_1_0_0 returns InfinityLiteral | ||
1171 | * DisjunctiveExpression.Case_1_1_0 returns InfinityLiteral | ||
1172 | * ConjunctiveExpression returns InfinityLiteral | ||
1173 | * ConjunctiveExpression.Conjunction_1_0 returns InfinityLiteral | ||
1174 | * ComparisonExpression returns InfinityLiteral | ||
1175 | * ComparisonExpression.BinaryExpression_1_0 returns InfinityLiteral | ||
1176 | * AdditiveExpression returns InfinityLiteral | ||
1177 | * AdditiveExpression.BinaryExpression_1_0 returns InfinityLiteral | ||
1178 | * MultiplicativeExpression returns InfinityLiteral | ||
1179 | * MultiplicativeExpression.BinaryExpression_1_0 returns InfinityLiteral | ||
1180 | * ExponentialExpression returns InfinityLiteral | ||
1181 | * ExponentialExpression.BinaryExpression_1_0 returns InfinityLiteral | ||
1182 | * CastExpression returns InfinityLiteral | ||
1183 | * CastExpression.CastExpression_1_0 returns InfinityLiteral | ||
1184 | * UnaryExpression returns InfinityLiteral | ||
1185 | * BracedAggregateExpression returns InfinityLiteral | ||
1186 | * AtomicExpression returns InfinityLiteral | ||
1187 | * Literal returns InfinityLiteral | ||
1188 | * InfinityLiteral returns InfinityLiteral | ||
1189 | * | ||
1190 | * Constraint: | ||
1191 | * {InfinityLiteral} | ||
1192 | */ | ||
1193 | protected void sequence_InfinityLiteral(ISerializationContext context, InfinityLiteral semanticObject) { | ||
1194 | genericSequencer.createSequence(context, semanticObject); | ||
1195 | } | ||
1196 | |||
1197 | |||
1198 | /** | ||
1199 | * Contexts: | ||
1200 | * AssertionOrDefinition.Assertion_1_0_0 returns IntLiteral | ||
1201 | * AssertionOrDefinition.PredicateDefinition_1_1_0 returns IntLiteral | ||
1202 | * AssertionOrDefinition.FunctionDefinition_1_2_0 returns IntLiteral | ||
1203 | * Expression returns IntLiteral | ||
1204 | * Expression.Forall_2_1_0 returns IntLiteral | ||
1205 | * DisjunctiveExpression returns IntLiteral | ||
1206 | * DisjunctiveExpression.Disjunction_1_0_0 returns IntLiteral | ||
1207 | * DisjunctiveExpression.Case_1_1_0 returns IntLiteral | ||
1208 | * ConjunctiveExpression returns IntLiteral | ||
1209 | * ConjunctiveExpression.Conjunction_1_0 returns IntLiteral | ||
1210 | * ComparisonExpression returns IntLiteral | ||
1211 | * ComparisonExpression.BinaryExpression_1_0 returns IntLiteral | ||
1212 | * AdditiveExpression returns IntLiteral | ||
1213 | * AdditiveExpression.BinaryExpression_1_0 returns IntLiteral | ||
1214 | * MultiplicativeExpression returns IntLiteral | ||
1215 | * MultiplicativeExpression.BinaryExpression_1_0 returns IntLiteral | ||
1216 | * ExponentialExpression returns IntLiteral | ||
1217 | * ExponentialExpression.BinaryExpression_1_0 returns IntLiteral | ||
1218 | * CastExpression returns IntLiteral | ||
1219 | * CastExpression.CastExpression_1_0 returns IntLiteral | ||
1220 | * UnaryExpression returns IntLiteral | ||
1221 | * BracedAggregateExpression returns IntLiteral | ||
1222 | * AtomicExpression returns IntLiteral | ||
1223 | * Literal returns IntLiteral | ||
1224 | * IntLiteral returns IntLiteral | ||
1225 | * | ||
1226 | * Constraint: | ||
1227 | * value=INT | ||
1228 | */ | ||
1229 | protected void sequence_IntLiteral(ISerializationContext context, IntLiteral semanticObject) { | ||
1230 | if (errorAcceptor != null) { | ||
1231 | if (transientValues.isValueTransient(semanticObject, SolverLanguagePackage.Literals.INT_LITERAL__VALUE) == ValueTransient.YES) | ||
1232 | errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, SolverLanguagePackage.Literals.INT_LITERAL__VALUE)); | ||
1233 | } | ||
1234 | SequenceFeeder feeder = createSequencerFeeder(context, semanticObject); | ||
1235 | feeder.accept(grammarAccess.getIntLiteralAccess().getValueINTTerminalRuleCall_0(), semanticObject.getValue()); | ||
1236 | feeder.finish(); | ||
1237 | } | ||
1238 | |||
1239 | |||
1240 | /** | ||
1241 | * Contexts: | ||
1242 | * AssertionOrDefinition.Assertion_1_0_0 returns Interval | ||
1243 | * AssertionOrDefinition.PredicateDefinition_1_1_0 returns Interval | ||
1244 | * AssertionOrDefinition.FunctionDefinition_1_2_0 returns Interval | ||
1245 | * Expression returns Interval | ||
1246 | * Expression.Forall_2_1_0 returns Interval | ||
1247 | * DisjunctiveExpression returns Interval | ||
1248 | * DisjunctiveExpression.Disjunction_1_0_0 returns Interval | ||
1249 | * DisjunctiveExpression.Case_1_1_0 returns Interval | ||
1250 | * ConjunctiveExpression returns Interval | ||
1251 | * ConjunctiveExpression.Conjunction_1_0 returns Interval | ||
1252 | * ComparisonExpression returns Interval | ||
1253 | * ComparisonExpression.BinaryExpression_1_0 returns Interval | ||
1254 | * AdditiveExpression returns Interval | ||
1255 | * AdditiveExpression.BinaryExpression_1_0 returns Interval | ||
1256 | * MultiplicativeExpression returns Interval | ||
1257 | * MultiplicativeExpression.BinaryExpression_1_0 returns Interval | ||
1258 | * ExponentialExpression returns Interval | ||
1259 | * ExponentialExpression.BinaryExpression_1_0 returns Interval | ||
1260 | * CastExpression returns Interval | ||
1261 | * CastExpression.CastExpression_1_0 returns Interval | ||
1262 | * UnaryExpression returns Interval | ||
1263 | * BracedAggregateExpression returns Interval | ||
1264 | * AtomicExpression returns Interval | ||
1265 | * Interval returns Interval | ||
1266 | * | ||
1267 | * Constraint: | ||
1268 | * (lowerBound=AdditiveExpression upperBound=AdditiveExpression) | ||
1269 | */ | ||
1270 | protected void sequence_Interval(ISerializationContext context, Interval semanticObject) { | ||
1271 | if (errorAcceptor != null) { | ||
1272 | if (transientValues.isValueTransient(semanticObject, SolverLanguagePackage.Literals.INTERVAL__LOWER_BOUND) == ValueTransient.YES) | ||
1273 | errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, SolverLanguagePackage.Literals.INTERVAL__LOWER_BOUND)); | ||
1274 | if (transientValues.isValueTransient(semanticObject, SolverLanguagePackage.Literals.INTERVAL__UPPER_BOUND) == ValueTransient.YES) | ||
1275 | errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, SolverLanguagePackage.Literals.INTERVAL__UPPER_BOUND)); | ||
1276 | } | ||
1277 | SequenceFeeder feeder = createSequencerFeeder(context, semanticObject); | ||
1278 | feeder.accept(grammarAccess.getIntervalAccess().getLowerBoundAdditiveExpressionParserRuleCall_1_0(), semanticObject.getLowerBound()); | ||
1279 | feeder.accept(grammarAccess.getIntervalAccess().getUpperBoundAdditiveExpressionParserRuleCall_3_0(), semanticObject.getUpperBound()); | ||
1280 | feeder.finish(); | ||
1281 | } | ||
1282 | |||
1283 | |||
1284 | /** | ||
1285 | * Contexts: | ||
1286 | * LetBinding returns LetBinding | ||
1287 | * | ||
1288 | * Constraint: | ||
1289 | * (type=[Symbol|QualifiedName]? name=ID value=AdditiveExpression) | ||
1290 | */ | ||
1291 | protected void sequence_LetBinding(ISerializationContext context, LetBinding semanticObject) { | ||
1292 | genericSequencer.createSequence(context, semanticObject); | ||
1293 | } | ||
1294 | |||
1295 | |||
1296 | /** | ||
1297 | * Contexts: | ||
1298 | * AssertionOrDefinition.Assertion_1_0_0 returns LetExpression | ||
1299 | * AssertionOrDefinition.PredicateDefinition_1_1_0 returns LetExpression | ||
1300 | * AssertionOrDefinition.FunctionDefinition_1_2_0 returns LetExpression | ||
1301 | * Expression returns LetExpression | ||
1302 | * Expression.Forall_2_1_0 returns LetExpression | ||
1303 | * LetExpression returns LetExpression | ||
1304 | * DisjunctiveExpression returns LetExpression | ||
1305 | * DisjunctiveExpression.Disjunction_1_0_0 returns LetExpression | ||
1306 | * DisjunctiveExpression.Case_1_1_0 returns LetExpression | ||
1307 | * ConjunctiveExpression returns LetExpression | ||
1308 | * ConjunctiveExpression.Conjunction_1_0 returns LetExpression | ||
1309 | * ComparisonExpression returns LetExpression | ||
1310 | * ComparisonExpression.BinaryExpression_1_0 returns LetExpression | ||
1311 | * AdditiveExpression returns LetExpression | ||
1312 | * AdditiveExpression.BinaryExpression_1_0 returns LetExpression | ||
1313 | * MultiplicativeExpression returns LetExpression | ||
1314 | * MultiplicativeExpression.BinaryExpression_1_0 returns LetExpression | ||
1315 | * ExponentialExpression returns LetExpression | ||
1316 | * ExponentialExpression.BinaryExpression_1_0 returns LetExpression | ||
1317 | * CastExpression returns LetExpression | ||
1318 | * CastExpression.CastExpression_1_0 returns LetExpression | ||
1319 | * UnaryExpression returns LetExpression | ||
1320 | * BracedAggregateExpression returns LetExpression | ||
1321 | * AtomicExpression returns LetExpression | ||
1322 | * | ||
1323 | * Constraint: | ||
1324 | * (bindings+=LetBinding bindings+=LetBinding* body=Expression) | ||
1325 | */ | ||
1326 | protected void sequence_LetExpression(ISerializationContext context, LetExpression semanticObject) { | ||
1327 | genericSequencer.createSequence(context, semanticObject); | ||
1328 | } | ||
1329 | |||
1330 | |||
1331 | /** | ||
1332 | * Contexts: | ||
1333 | * AssertionOrDefinition.Assertion_1_0_0 returns LogicLiteral | ||
1334 | * AssertionOrDefinition.PredicateDefinition_1_1_0 returns LogicLiteral | ||
1335 | * AssertionOrDefinition.FunctionDefinition_1_2_0 returns LogicLiteral | ||
1336 | * Expression returns LogicLiteral | ||
1337 | * Expression.Forall_2_1_0 returns LogicLiteral | ||
1338 | * DisjunctiveExpression returns LogicLiteral | ||
1339 | * DisjunctiveExpression.Disjunction_1_0_0 returns LogicLiteral | ||
1340 | * DisjunctiveExpression.Case_1_1_0 returns LogicLiteral | ||
1341 | * ConjunctiveExpression returns LogicLiteral | ||
1342 | * ConjunctiveExpression.Conjunction_1_0 returns LogicLiteral | ||
1343 | * ComparisonExpression returns LogicLiteral | ||
1344 | * ComparisonExpression.BinaryExpression_1_0 returns LogicLiteral | ||
1345 | * AdditiveExpression returns LogicLiteral | ||
1346 | * AdditiveExpression.BinaryExpression_1_0 returns LogicLiteral | ||
1347 | * MultiplicativeExpression returns LogicLiteral | ||
1348 | * MultiplicativeExpression.BinaryExpression_1_0 returns LogicLiteral | ||
1349 | * ExponentialExpression returns LogicLiteral | ||
1350 | * ExponentialExpression.BinaryExpression_1_0 returns LogicLiteral | ||
1351 | * CastExpression returns LogicLiteral | ||
1352 | * CastExpression.CastExpression_1_0 returns LogicLiteral | ||
1353 | * UnaryExpression returns LogicLiteral | ||
1354 | * BracedAggregateExpression returns LogicLiteral | ||
1355 | * AtomicExpression returns LogicLiteral | ||
1356 | * Literal returns LogicLiteral | ||
1357 | * LogicLiteral returns LogicLiteral | ||
1358 | * | ||
1359 | * Constraint: | ||
1360 | * value=LogicValue | ||
1361 | */ | ||
1362 | protected void sequence_LogicLiteral(ISerializationContext context, LogicLiteral semanticObject) { | ||
1363 | if (errorAcceptor != null) { | ||
1364 | if (transientValues.isValueTransient(semanticObject, SolverLanguagePackage.Literals.LOGIC_LITERAL__VALUE) == ValueTransient.YES) | ||
1365 | errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, SolverLanguagePackage.Literals.LOGIC_LITERAL__VALUE)); | ||
1366 | } | ||
1367 | SequenceFeeder feeder = createSequencerFeeder(context, semanticObject); | ||
1368 | feeder.accept(grammarAccess.getLogicLiteralAccess().getValueLogicValueEnumRuleCall_0(), semanticObject.getValue()); | ||
1369 | feeder.finish(); | ||
1370 | } | ||
1371 | |||
1372 | |||
1373 | /** | ||
1374 | * Contexts: | ||
1375 | * Statement returns LowerBoundedScope | ||
1376 | * ScopeDeclaration returns LowerBoundedScope | ||
1377 | * LowerBoundedScope returns LowerBoundedScope | ||
1378 | * | ||
1379 | * Constraint: | ||
1380 | * ((lowerBound=INT type=[Symbol|QualifiedName]) | (type=[Symbol|QualifiedName] lowerBound=INT)) | ||
1381 | */ | ||
1382 | protected void sequence_LowerBoundedScope(ISerializationContext context, LowerBoundedScope semanticObject) { | ||
1383 | genericSequencer.createSequence(context, semanticObject); | ||
1384 | } | ||
1385 | |||
1386 | |||
1387 | /** | ||
1388 | * Contexts: | ||
1389 | * Import returns NamespaceImport | ||
1390 | * NamespaceImport returns NamespaceImport | ||
1391 | * | ||
1392 | * Constraint: | ||
1393 | * (importedNamespace=QualifiedName alias=QualifiedName) | ||
1394 | */ | ||
1395 | protected void sequence_NamespaceImport(ISerializationContext context, NamespaceImport semanticObject) { | ||
1396 | if (errorAcceptor != null) { | ||
1397 | if (transientValues.isValueTransient(semanticObject, SolverLanguagePackage.Literals.NAMESPACE_IMPORT__IMPORTED_NAMESPACE) == ValueTransient.YES) | ||
1398 | errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, SolverLanguagePackage.Literals.NAMESPACE_IMPORT__IMPORTED_NAMESPACE)); | ||
1399 | if (transientValues.isValueTransient(semanticObject, SolverLanguagePackage.Literals.IMPORT__ALIAS) == ValueTransient.YES) | ||
1400 | errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, SolverLanguagePackage.Literals.IMPORT__ALIAS)); | ||
1401 | } | ||
1402 | SequenceFeeder feeder = createSequencerFeeder(context, semanticObject); | ||
1403 | feeder.accept(grammarAccess.getNamespaceImportAccess().getImportedNamespaceQualifiedNameParserRuleCall_1_0(), semanticObject.getImportedNamespace()); | ||
1404 | feeder.accept(grammarAccess.getNamespaceImportAccess().getAliasQualifiedNameParserRuleCall_2_1_0(), semanticObject.getAlias()); | ||
1405 | feeder.finish(); | ||
1406 | } | ||
1407 | |||
1408 | |||
1409 | /** | ||
1410 | * Contexts: | ||
1411 | * Statement returns ObjectiveDeclaration | ||
1412 | * ObjectiveDeclaration returns ObjectiveDeclaration | ||
1413 | * | ||
1414 | * Constraint: | ||
1415 | * (kind=ObjectiveKind objective=Expression) | ||
1416 | */ | ||
1417 | protected void sequence_ObjectiveDeclaration(ISerializationContext context, ObjectiveDeclaration semanticObject) { | ||
1418 | if (errorAcceptor != null) { | ||
1419 | if (transientValues.isValueTransient(semanticObject, SolverLanguagePackage.Literals.OBJECTIVE_DECLARATION__KIND) == ValueTransient.YES) | ||
1420 | errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, SolverLanguagePackage.Literals.OBJECTIVE_DECLARATION__KIND)); | ||
1421 | if (transientValues.isValueTransient(semanticObject, SolverLanguagePackage.Literals.OBJECTIVE_DECLARATION__OBJECTIVE) == ValueTransient.YES) | ||
1422 | errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, SolverLanguagePackage.Literals.OBJECTIVE_DECLARATION__OBJECTIVE)); | ||
1423 | } | ||
1424 | SequenceFeeder feeder = createSequencerFeeder(context, semanticObject); | ||
1425 | feeder.accept(grammarAccess.getObjectiveDeclarationAccess().getKindObjectiveKindEnumRuleCall_0_0(), semanticObject.getKind()); | ||
1426 | feeder.accept(grammarAccess.getObjectiveDeclarationAccess().getObjectiveExpressionParserRuleCall_1_0(), semanticObject.getObjective()); | ||
1427 | feeder.finish(); | ||
1428 | } | ||
1429 | |||
1430 | |||
1431 | /** | ||
1432 | * Contexts: | ||
1433 | * PathComponent returns PathComponent | ||
1434 | * | ||
1435 | * Constraint: | ||
1436 | * ( | ||
1437 | * inverse?='~'? | ||
1438 | * symbol=[Symbol|QualifiedName] | ||
1439 | * (transitiveClosure?=TRANSITIVE_CLOSURE | reflexiveTransitiveClosure?=REFLEXIVE_TRANSITIVE_CLOSURE)? | ||
1440 | * ) | ||
1441 | */ | ||
1442 | protected void sequence_PathComponent(ISerializationContext context, PathComponent semanticObject) { | ||
1443 | genericSequencer.createSequence(context, semanticObject); | ||
1444 | } | ||
1445 | |||
1446 | |||
1447 | /** | ||
1448 | * Contexts: | ||
1449 | * PredicateDefinition returns PredicateDefinition | ||
1450 | * | ||
1451 | * Constraint: | ||
1452 | * (((functional?='functional' error?='error'?) | (error?='error' functional?='functional'?)) head=Call body=Expression) | ||
1453 | */ | ||
1454 | protected void sequence_PredicateDefinition(ISerializationContext context, PredicateDefinition semanticObject) { | ||
1455 | genericSequencer.createSequence(context, semanticObject); | ||
1456 | } | ||
1457 | |||
1458 | |||
1459 | /** | ||
1460 | * Contexts: | ||
1461 | * Problem returns Problem | ||
1462 | * | ||
1463 | * Constraint: | ||
1464 | * ((name=QualifiedName? imports+=Import+ statements+=Statement+) | (name=QualifiedName? statements+=Statement+) | statements+=Statement+)? | ||
1465 | */ | ||
1466 | protected void sequence_Problem(ISerializationContext context, Problem semanticObject) { | ||
1467 | genericSequencer.createSequence(context, semanticObject); | ||
1468 | } | ||
1469 | |||
1470 | |||
1471 | /** | ||
1472 | * Contexts: | ||
1473 | * AssertionOrDefinition.Assertion_1_0_0 returns RealLiteral | ||
1474 | * AssertionOrDefinition.PredicateDefinition_1_1_0 returns RealLiteral | ||
1475 | * AssertionOrDefinition.FunctionDefinition_1_2_0 returns RealLiteral | ||
1476 | * Expression returns RealLiteral | ||
1477 | * Expression.Forall_2_1_0 returns RealLiteral | ||
1478 | * DisjunctiveExpression returns RealLiteral | ||
1479 | * DisjunctiveExpression.Disjunction_1_0_0 returns RealLiteral | ||
1480 | * DisjunctiveExpression.Case_1_1_0 returns RealLiteral | ||
1481 | * ConjunctiveExpression returns RealLiteral | ||
1482 | * ConjunctiveExpression.Conjunction_1_0 returns RealLiteral | ||
1483 | * ComparisonExpression returns RealLiteral | ||
1484 | * ComparisonExpression.BinaryExpression_1_0 returns RealLiteral | ||
1485 | * AdditiveExpression returns RealLiteral | ||
1486 | * AdditiveExpression.BinaryExpression_1_0 returns RealLiteral | ||
1487 | * MultiplicativeExpression returns RealLiteral | ||
1488 | * MultiplicativeExpression.BinaryExpression_1_0 returns RealLiteral | ||
1489 | * ExponentialExpression returns RealLiteral | ||
1490 | * ExponentialExpression.BinaryExpression_1_0 returns RealLiteral | ||
1491 | * CastExpression returns RealLiteral | ||
1492 | * CastExpression.CastExpression_1_0 returns RealLiteral | ||
1493 | * UnaryExpression returns RealLiteral | ||
1494 | * BracedAggregateExpression returns RealLiteral | ||
1495 | * AtomicExpression returns RealLiteral | ||
1496 | * Literal returns RealLiteral | ||
1497 | * RealLiteral returns RealLiteral | ||
1498 | * | ||
1499 | * Constraint: | ||
1500 | * value=Real | ||
1501 | */ | ||
1502 | protected void sequence_RealLiteral(ISerializationContext context, RealLiteral semanticObject) { | ||
1503 | if (errorAcceptor != null) { | ||
1504 | if (transientValues.isValueTransient(semanticObject, SolverLanguagePackage.Literals.REAL_LITERAL__VALUE) == ValueTransient.YES) | ||
1505 | errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, SolverLanguagePackage.Literals.REAL_LITERAL__VALUE)); | ||
1506 | } | ||
1507 | SequenceFeeder feeder = createSequencerFeeder(context, semanticObject); | ||
1508 | feeder.accept(grammarAccess.getRealLiteralAccess().getValueRealParserRuleCall_0(), semanticObject.getValue()); | ||
1509 | feeder.finish(); | ||
1510 | } | ||
1511 | |||
1512 | |||
1513 | /** | ||
1514 | * Contexts: | ||
1515 | * AssertionOrDefinition.Assertion_1_0_0 returns Reference | ||
1516 | * AssertionOrDefinition.PredicateDefinition_1_1_0 returns Reference | ||
1517 | * AssertionOrDefinition.FunctionDefinition_1_2_0 returns Reference | ||
1518 | * Expression returns Reference | ||
1519 | * Expression.Forall_2_1_0 returns Reference | ||
1520 | * DisjunctiveExpression returns Reference | ||
1521 | * DisjunctiveExpression.Disjunction_1_0_0 returns Reference | ||
1522 | * DisjunctiveExpression.Case_1_1_0 returns Reference | ||
1523 | * ConjunctiveExpression returns Reference | ||
1524 | * ConjunctiveExpression.Conjunction_1_0 returns Reference | ||
1525 | * ComparisonExpression returns Reference | ||
1526 | * ComparisonExpression.BinaryExpression_1_0 returns Reference | ||
1527 | * AdditiveExpression returns Reference | ||
1528 | * AdditiveExpression.BinaryExpression_1_0 returns Reference | ||
1529 | * MultiplicativeExpression returns Reference | ||
1530 | * MultiplicativeExpression.BinaryExpression_1_0 returns Reference | ||
1531 | * ExponentialExpression returns Reference | ||
1532 | * ExponentialExpression.BinaryExpression_1_0 returns Reference | ||
1533 | * CastExpression returns Reference | ||
1534 | * CastExpression.CastExpression_1_0 returns Reference | ||
1535 | * UnaryExpression returns Reference | ||
1536 | * BracedAggregateExpression returns Reference | ||
1537 | * AtomicExpression returns Reference | ||
1538 | * Reference returns Reference | ||
1539 | * | ||
1540 | * Constraint: | ||
1541 | * (components+=PathComponent components+=PathComponent*) | ||
1542 | */ | ||
1543 | protected void sequence_Reference(ISerializationContext context, Reference semanticObject) { | ||
1544 | genericSequencer.createSequence(context, semanticObject); | ||
1545 | } | ||
1546 | |||
1547 | |||
1548 | /** | ||
1549 | * Contexts: | ||
1550 | * Argument returns StarArgument | ||
1551 | * StarArgument returns StarArgument | ||
1552 | * | ||
1553 | * Constraint: | ||
1554 | * {StarArgument} | ||
1555 | */ | ||
1556 | protected void sequence_StarArgument(ISerializationContext context, StarArgument semanticObject) { | ||
1557 | genericSequencer.createSequence(context, semanticObject); | ||
1558 | } | ||
1559 | |||
1560 | |||
1561 | /** | ||
1562 | * Contexts: | ||
1563 | * AssertionOrDefinition.Assertion_1_0_0 returns StringLiteral | ||
1564 | * AssertionOrDefinition.PredicateDefinition_1_1_0 returns StringLiteral | ||
1565 | * AssertionOrDefinition.FunctionDefinition_1_2_0 returns StringLiteral | ||
1566 | * Expression returns StringLiteral | ||
1567 | * Expression.Forall_2_1_0 returns StringLiteral | ||
1568 | * DisjunctiveExpression returns StringLiteral | ||
1569 | * DisjunctiveExpression.Disjunction_1_0_0 returns StringLiteral | ||
1570 | * DisjunctiveExpression.Case_1_1_0 returns StringLiteral | ||
1571 | * ConjunctiveExpression returns StringLiteral | ||
1572 | * ConjunctiveExpression.Conjunction_1_0 returns StringLiteral | ||
1573 | * ComparisonExpression returns StringLiteral | ||
1574 | * ComparisonExpression.BinaryExpression_1_0 returns StringLiteral | ||
1575 | * AdditiveExpression returns StringLiteral | ||
1576 | * AdditiveExpression.BinaryExpression_1_0 returns StringLiteral | ||
1577 | * MultiplicativeExpression returns StringLiteral | ||
1578 | * MultiplicativeExpression.BinaryExpression_1_0 returns StringLiteral | ||
1579 | * ExponentialExpression returns StringLiteral | ||
1580 | * ExponentialExpression.BinaryExpression_1_0 returns StringLiteral | ||
1581 | * CastExpression returns StringLiteral | ||
1582 | * CastExpression.CastExpression_1_0 returns StringLiteral | ||
1583 | * UnaryExpression returns StringLiteral | ||
1584 | * BracedAggregateExpression returns StringLiteral | ||
1585 | * AtomicExpression returns StringLiteral | ||
1586 | * Literal returns StringLiteral | ||
1587 | * StringLiteral returns StringLiteral | ||
1588 | * | ||
1589 | * Constraint: | ||
1590 | * value=STRING | ||
1591 | */ | ||
1592 | protected void sequence_StringLiteral(ISerializationContext context, StringLiteral semanticObject) { | ||
1593 | if (errorAcceptor != null) { | ||
1594 | if (transientValues.isValueTransient(semanticObject, SolverLanguagePackage.Literals.STRING_LITERAL__VALUE) == ValueTransient.YES) | ||
1595 | errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, SolverLanguagePackage.Literals.STRING_LITERAL__VALUE)); | ||
1596 | } | ||
1597 | SequenceFeeder feeder = createSequencerFeeder(context, semanticObject); | ||
1598 | feeder.accept(grammarAccess.getStringLiteralAccess().getValueSTRINGTerminalRuleCall_0(), semanticObject.getValue()); | ||
1599 | feeder.finish(); | ||
1600 | } | ||
1601 | |||
1602 | |||
1603 | /** | ||
1604 | * Contexts: | ||
1605 | * TypeReference returns TypeReference | ||
1606 | * | ||
1607 | * Constraint: | ||
1608 | * (type=[Symbol|QualifiedName] forceObjectType?='object'?) | ||
1609 | */ | ||
1610 | protected void sequence_TypeReference(ISerializationContext context, TypeReference semanticObject) { | ||
1611 | genericSequencer.createSequence(context, semanticObject); | ||
1612 | } | ||
1613 | |||
1614 | |||
1615 | /** | ||
1616 | * Contexts: | ||
1617 | * Argument returns TypedStarArgument | ||
1618 | * TypedStarArgument returns TypedStarArgument | ||
1619 | * | ||
1620 | * Constraint: | ||
1621 | * typeReference=TypeReference | ||
1622 | */ | ||
1623 | protected void sequence_TypedStarArgument(ISerializationContext context, TypedStarArgument semanticObject) { | ||
1624 | if (errorAcceptor != null) { | ||
1625 | if (transientValues.isValueTransient(semanticObject, SolverLanguagePackage.Literals.TYPED_ARGUMENT__TYPE_REFERENCE) == ValueTransient.YES) | ||
1626 | errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, SolverLanguagePackage.Literals.TYPED_ARGUMENT__TYPE_REFERENCE)); | ||
1627 | } | ||
1628 | SequenceFeeder feeder = createSequencerFeeder(context, semanticObject); | ||
1629 | feeder.accept(grammarAccess.getTypedStarArgumentAccess().getTypeReferenceTypeReferenceParserRuleCall_0_0(), semanticObject.getTypeReference()); | ||
1630 | feeder.finish(); | ||
1631 | } | ||
1632 | |||
1633 | |||
1634 | /** | ||
1635 | * Contexts: | ||
1636 | * Argument returns TypedVariableArgument | ||
1637 | * TypedVariableArgument returns TypedVariableArgument | ||
1638 | * | ||
1639 | * Constraint: | ||
1640 | * (typeReference=TypeReference name=ID) | ||
1641 | */ | ||
1642 | protected void sequence_TypedVariableArgument(ISerializationContext context, TypedVariableArgument semanticObject) { | ||
1643 | if (errorAcceptor != null) { | ||
1644 | if (transientValues.isValueTransient(semanticObject, SolverLanguagePackage.Literals.TYPED_ARGUMENT__TYPE_REFERENCE) == ValueTransient.YES) | ||
1645 | errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, SolverLanguagePackage.Literals.TYPED_ARGUMENT__TYPE_REFERENCE)); | ||
1646 | if (transientValues.isValueTransient(semanticObject, SolverLanguagePackage.Literals.TYPED_VARIABLE_ARGUMENT__NAME) == ValueTransient.YES) | ||
1647 | errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, SolverLanguagePackage.Literals.TYPED_VARIABLE_ARGUMENT__NAME)); | ||
1648 | } | ||
1649 | SequenceFeeder feeder = createSequencerFeeder(context, semanticObject); | ||
1650 | feeder.accept(grammarAccess.getTypedVariableArgumentAccess().getTypeReferenceTypeReferenceParserRuleCall_0_0(), semanticObject.getTypeReference()); | ||
1651 | feeder.accept(grammarAccess.getTypedVariableArgumentAccess().getNameIDTerminalRuleCall_1_0(), semanticObject.getName()); | ||
1652 | feeder.finish(); | ||
1653 | } | ||
1654 | |||
1655 | |||
1656 | /** | ||
1657 | * Contexts: | ||
1658 | * AssertionOrDefinition.Assertion_1_0_0 returns UnaryExpression | ||
1659 | * AssertionOrDefinition.PredicateDefinition_1_1_0 returns UnaryExpression | ||
1660 | * AssertionOrDefinition.FunctionDefinition_1_2_0 returns UnaryExpression | ||
1661 | * Expression returns UnaryExpression | ||
1662 | * Expression.Forall_2_1_0 returns UnaryExpression | ||
1663 | * DisjunctiveExpression returns UnaryExpression | ||
1664 | * DisjunctiveExpression.Disjunction_1_0_0 returns UnaryExpression | ||
1665 | * DisjunctiveExpression.Case_1_1_0 returns UnaryExpression | ||
1666 | * ConjunctiveExpression returns UnaryExpression | ||
1667 | * ConjunctiveExpression.Conjunction_1_0 returns UnaryExpression | ||
1668 | * ComparisonExpression returns UnaryExpression | ||
1669 | * ComparisonExpression.BinaryExpression_1_0 returns UnaryExpression | ||
1670 | * AdditiveExpression returns UnaryExpression | ||
1671 | * AdditiveExpression.BinaryExpression_1_0 returns UnaryExpression | ||
1672 | * MultiplicativeExpression returns UnaryExpression | ||
1673 | * MultiplicativeExpression.BinaryExpression_1_0 returns UnaryExpression | ||
1674 | * ExponentialExpression returns UnaryExpression | ||
1675 | * ExponentialExpression.BinaryExpression_1_0 returns UnaryExpression | ||
1676 | * CastExpression returns UnaryExpression | ||
1677 | * CastExpression.CastExpression_1_0 returns UnaryExpression | ||
1678 | * UnaryExpression returns UnaryExpression | ||
1679 | * BracedAggregateExpression returns UnaryExpression | ||
1680 | * AtomicExpression returns UnaryExpression | ||
1681 | * | ||
1682 | * Constraint: | ||
1683 | * (op=UnaryOperator body=BracedAggregateExpression) | ||
1684 | */ | ||
1685 | protected void sequence_UnaryExpression(ISerializationContext context, UnaryExpression semanticObject) { | ||
1686 | if (errorAcceptor != null) { | ||
1687 | if (transientValues.isValueTransient(semanticObject, SolverLanguagePackage.Literals.UNARY_EXPRESSION__OP) == ValueTransient.YES) | ||
1688 | errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, SolverLanguagePackage.Literals.UNARY_EXPRESSION__OP)); | ||
1689 | if (transientValues.isValueTransient(semanticObject, SolverLanguagePackage.Literals.UNARY_EXPRESSION__BODY) == ValueTransient.YES) | ||
1690 | errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, SolverLanguagePackage.Literals.UNARY_EXPRESSION__BODY)); | ||
1691 | } | ||
1692 | SequenceFeeder feeder = createSequencerFeeder(context, semanticObject); | ||
1693 | feeder.accept(grammarAccess.getUnaryExpressionAccess().getOpUnaryOperatorEnumRuleCall_1_1_0(), semanticObject.getOp()); | ||
1694 | feeder.accept(grammarAccess.getUnaryExpressionAccess().getBodyBracedAggregateExpressionParserRuleCall_1_2_0(), semanticObject.getBody()); | ||
1695 | feeder.finish(); | ||
1696 | } | ||
1697 | |||
1698 | |||
1699 | /** | ||
1700 | * Contexts: | ||
1701 | * Multiplicity returns UnboundedMultiplicity | ||
1702 | * UnboundedMultiplicity returns UnboundedMultiplicity | ||
1703 | * | ||
1704 | * Constraint: | ||
1705 | * {UnboundedMultiplicity} | ||
1706 | */ | ||
1707 | protected void sequence_UnboundedMultiplicity(ISerializationContext context, UnboundedMultiplicity semanticObject) { | ||
1708 | genericSequencer.createSequence(context, semanticObject); | ||
1709 | } | ||
1710 | |||
1711 | |||
1712 | /** | ||
1713 | * Contexts: | ||
1714 | * Statement returns UnnamedErrorPredicateDefintion | ||
1715 | * UnnamedErrorPredicateDefintion returns UnnamedErrorPredicateDefintion | ||
1716 | * | ||
1717 | * Constraint: | ||
1718 | * (argumentList=ArgumentList body=Expression) | ||
1719 | */ | ||
1720 | protected void sequence_UnnamedErrorPredicateDefintion(ISerializationContext context, UnnamedErrorPredicateDefintion semanticObject) { | ||
1721 | if (errorAcceptor != null) { | ||
1722 | if (transientValues.isValueTransient(semanticObject, SolverLanguagePackage.Literals.UNNAMED_ERROR_PREDICATE_DEFINTION__ARGUMENT_LIST) == ValueTransient.YES) | ||
1723 | errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, SolverLanguagePackage.Literals.UNNAMED_ERROR_PREDICATE_DEFINTION__ARGUMENT_LIST)); | ||
1724 | if (transientValues.isValueTransient(semanticObject, SolverLanguagePackage.Literals.UNNAMED_ERROR_PREDICATE_DEFINTION__BODY) == ValueTransient.YES) | ||
1725 | errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, SolverLanguagePackage.Literals.UNNAMED_ERROR_PREDICATE_DEFINTION__BODY)); | ||
1726 | } | ||
1727 | SequenceFeeder feeder = createSequencerFeeder(context, semanticObject); | ||
1728 | feeder.accept(grammarAccess.getUnnamedErrorPredicateDefintionAccess().getArgumentListArgumentListParserRuleCall_1_0(), semanticObject.getArgumentList()); | ||
1729 | feeder.accept(grammarAccess.getUnnamedErrorPredicateDefintionAccess().getBodyExpressionParserRuleCall_3_0(), semanticObject.getBody()); | ||
1730 | feeder.finish(); | ||
1731 | } | ||
1732 | |||
1733 | |||
1734 | /** | ||
1735 | * Contexts: | ||
1736 | * Import returns UriImport | ||
1737 | * UriImport returns UriImport | ||
1738 | * | ||
1739 | * Constraint: | ||
1740 | * (uri=STRING alias=QualifiedName) | ||
1741 | */ | ||
1742 | protected void sequence_UriImport(ISerializationContext context, UriImport semanticObject) { | ||
1743 | if (errorAcceptor != null) { | ||
1744 | if (transientValues.isValueTransient(semanticObject, SolverLanguagePackage.Literals.URI_IMPORT__URI) == ValueTransient.YES) | ||
1745 | errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, SolverLanguagePackage.Literals.URI_IMPORT__URI)); | ||
1746 | if (transientValues.isValueTransient(semanticObject, SolverLanguagePackage.Literals.IMPORT__ALIAS) == ValueTransient.YES) | ||
1747 | errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, SolverLanguagePackage.Literals.IMPORT__ALIAS)); | ||
1748 | } | ||
1749 | SequenceFeeder feeder = createSequencerFeeder(context, semanticObject); | ||
1750 | feeder.accept(grammarAccess.getUriImportAccess().getUriSTRINGTerminalRuleCall_1_0(), semanticObject.getUri()); | ||
1751 | feeder.accept(grammarAccess.getUriImportAccess().getAliasQualifiedNameParserRuleCall_2_1_0(), semanticObject.getAlias()); | ||
1752 | feeder.finish(); | ||
1753 | } | ||
1754 | |||
1755 | |||
1756 | } | ||
diff --git a/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/serializer/SolverLanguageSyntacticSequencer.java b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/serializer/SolverLanguageSyntacticSequencer.java new file mode 100644 index 00000000..2f9ea8a3 --- /dev/null +++ b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/serializer/SolverLanguageSyntacticSequencer.java | |||
@@ -0,0 +1,191 @@ | |||
1 | /* | ||
2 | * generated by Xtext 2.21.0 | ||
3 | */ | ||
4 | package org.eclipse.viatra.solver.language.serializer; | ||
5 | |||
6 | import com.google.inject.Inject; | ||
7 | import java.util.List; | ||
8 | import org.eclipse.emf.ecore.EObject; | ||
9 | import org.eclipse.viatra.solver.language.services.SolverLanguageGrammarAccess; | ||
10 | import org.eclipse.xtext.IGrammarAccess; | ||
11 | import org.eclipse.xtext.RuleCall; | ||
12 | import org.eclipse.xtext.nodemodel.INode; | ||
13 | import org.eclipse.xtext.serializer.analysis.GrammarAlias.AbstractElementAlias; | ||
14 | import org.eclipse.xtext.serializer.analysis.GrammarAlias.AlternativeAlias; | ||
15 | import org.eclipse.xtext.serializer.analysis.GrammarAlias.GroupAlias; | ||
16 | import org.eclipse.xtext.serializer.analysis.GrammarAlias.TokenAlias; | ||
17 | import org.eclipse.xtext.serializer.analysis.ISyntacticSequencerPDAProvider.ISynNavigable; | ||
18 | import org.eclipse.xtext.serializer.analysis.ISyntacticSequencerPDAProvider.ISynTransition; | ||
19 | import org.eclipse.xtext.serializer.sequencer.AbstractSyntacticSequencer; | ||
20 | |||
21 | @SuppressWarnings("all") | ||
22 | public class SolverLanguageSyntacticSequencer extends AbstractSyntacticSequencer { | ||
23 | |||
24 | protected SolverLanguageGrammarAccess grammarAccess; | ||
25 | protected AbstractElementAlias match_AtomicExpression_LeftParenthesisKeyword_4_0_a; | ||
26 | protected AbstractElementAlias match_AtomicExpression_LeftParenthesisKeyword_4_0_p; | ||
27 | protected AbstractElementAlias match_ClassDeclaration_FULL_STOPTerminalRuleCall_4_1_or___LeftCurlyBracketKeyword_4_0_0_RightCurlyBracketKeyword_4_0_2__; | ||
28 | protected AbstractElementAlias match_EnumDeclaration_CommaKeyword_2_0_1_1_0_q; | ||
29 | protected AbstractElementAlias match_EnumDeclaration_FULL_STOPTerminalRuleCall_2_1_or___LeftCurlyBracketKeyword_2_0_0_RightCurlyBracketKeyword_2_0_2__; | ||
30 | protected AbstractElementAlias match_Field_SemicolonKeyword_5_q; | ||
31 | |||
32 | @Inject | ||
33 | protected void init(IGrammarAccess access) { | ||
34 | grammarAccess = (SolverLanguageGrammarAccess) access; | ||
35 | match_AtomicExpression_LeftParenthesisKeyword_4_0_a = new TokenAlias(true, true, grammarAccess.getAtomicExpressionAccess().getLeftParenthesisKeyword_4_0()); | ||
36 | match_AtomicExpression_LeftParenthesisKeyword_4_0_p = new TokenAlias(true, false, grammarAccess.getAtomicExpressionAccess().getLeftParenthesisKeyword_4_0()); | ||
37 | match_ClassDeclaration_FULL_STOPTerminalRuleCall_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().getFULL_STOPTerminalRuleCall_4_1())); | ||
38 | match_EnumDeclaration_CommaKeyword_2_0_1_1_0_q = new TokenAlias(false, true, grammarAccess.getEnumDeclarationAccess().getCommaKeyword_2_0_1_1_0()); | ||
39 | match_EnumDeclaration_FULL_STOPTerminalRuleCall_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().getFULL_STOPTerminalRuleCall_2_1())); | ||
40 | match_Field_SemicolonKeyword_5_q = new TokenAlias(false, true, grammarAccess.getFieldAccess().getSemicolonKeyword_5()); | ||
41 | } | ||
42 | |||
43 | @Override | ||
44 | protected String getUnassignedRuleCallToken(EObject semanticObject, RuleCall ruleCall, INode node) { | ||
45 | if (ruleCall.getRule() == grammarAccess.getFULL_STOPRule()) | ||
46 | return getFULL_STOPToken(semanticObject, ruleCall, node); | ||
47 | else if (ruleCall.getRule() == grammarAccess.getREFLEXIVE_TRANSITIVE_CLOSURERule()) | ||
48 | return getREFLEXIVE_TRANSITIVE_CLOSUREToken(semanticObject, ruleCall, node); | ||
49 | else if (ruleCall.getRule() == grammarAccess.getTRANSITIVE_CLOSURERule()) | ||
50 | return getTRANSITIVE_CLOSUREToken(semanticObject, ruleCall, node); | ||
51 | return ""; | ||
52 | } | ||
53 | |||
54 | /** | ||
55 | * Synthetic terminal rule. The concrete syntax is to be specified by clients. | ||
56 | * Defaults to the empty string. | ||
57 | */ | ||
58 | protected String getFULL_STOPToken(EObject semanticObject, RuleCall ruleCall, INode node) { return ""; } | ||
59 | |||
60 | /** | ||
61 | * Synthetic terminal rule. The concrete syntax is to be specified by clients. | ||
62 | * Defaults to the empty string. | ||
63 | */ | ||
64 | protected String getREFLEXIVE_TRANSITIVE_CLOSUREToken(EObject semanticObject, RuleCall ruleCall, INode node) { return ""; } | ||
65 | |||
66 | /** | ||
67 | * Synthetic terminal rule. The concrete syntax is to be specified by clients. | ||
68 | * Defaults to the empty string. | ||
69 | */ | ||
70 | protected String getTRANSITIVE_CLOSUREToken(EObject semanticObject, RuleCall ruleCall, INode node) { return ""; } | ||
71 | |||
72 | @Override | ||
73 | protected void emitUnassignedTokens(EObject semanticObject, ISynTransition transition, INode fromNode, INode toNode) { | ||
74 | if (transition.getAmbiguousSyntaxes().isEmpty()) return; | ||
75 | List<INode> transitionNodes = collectNodes(fromNode, toNode); | ||
76 | for (AbstractElementAlias syntax : transition.getAmbiguousSyntaxes()) { | ||
77 | List<INode> syntaxNodes = getNodesFor(transitionNodes, syntax); | ||
78 | if (match_AtomicExpression_LeftParenthesisKeyword_4_0_a.equals(syntax)) | ||
79 | emit_AtomicExpression_LeftParenthesisKeyword_4_0_a(semanticObject, getLastNavigableState(), syntaxNodes); | ||
80 | else if (match_AtomicExpression_LeftParenthesisKeyword_4_0_p.equals(syntax)) | ||
81 | emit_AtomicExpression_LeftParenthesisKeyword_4_0_p(semanticObject, getLastNavigableState(), syntaxNodes); | ||
82 | else if (match_ClassDeclaration_FULL_STOPTerminalRuleCall_4_1_or___LeftCurlyBracketKeyword_4_0_0_RightCurlyBracketKeyword_4_0_2__.equals(syntax)) | ||
83 | emit_ClassDeclaration_FULL_STOPTerminalRuleCall_4_1_or___LeftCurlyBracketKeyword_4_0_0_RightCurlyBracketKeyword_4_0_2__(semanticObject, getLastNavigableState(), syntaxNodes); | ||
84 | else if (match_EnumDeclaration_CommaKeyword_2_0_1_1_0_q.equals(syntax)) | ||
85 | emit_EnumDeclaration_CommaKeyword_2_0_1_1_0_q(semanticObject, getLastNavigableState(), syntaxNodes); | ||
86 | else if (match_EnumDeclaration_FULL_STOPTerminalRuleCall_2_1_or___LeftCurlyBracketKeyword_2_0_0_RightCurlyBracketKeyword_2_0_2__.equals(syntax)) | ||
87 | emit_EnumDeclaration_FULL_STOPTerminalRuleCall_2_1_or___LeftCurlyBracketKeyword_2_0_0_RightCurlyBracketKeyword_2_0_2__(semanticObject, getLastNavigableState(), syntaxNodes); | ||
88 | else if (match_Field_SemicolonKeyword_5_q.equals(syntax)) | ||
89 | emit_Field_SemicolonKeyword_5_q(semanticObject, getLastNavigableState(), syntaxNodes); | ||
90 | else acceptNodes(getLastNavigableState(), syntaxNodes); | ||
91 | } | ||
92 | } | ||
93 | |||
94 | /** | ||
95 | * Ambiguous syntax: | ||
96 | * '('* | ||
97 | * | ||
98 | * This ambiguous syntax occurs at: | ||
99 | * (rule start) (ambiguity) '[' lowerBound=AdditiveExpression | ||
100 | * (rule start) (ambiguity) 'count' '{' condition=Expression | ||
101 | * (rule start) (ambiguity) 'empty' (rule start) | ||
102 | * (rule start) (ambiguity) 'if' condition=DisjunctiveExpression | ||
103 | * (rule start) (ambiguity) 'inf' (rule start) | ||
104 | * (rule start) (ambiguity) 'let' bindings+=LetBinding | ||
105 | * (rule start) (ambiguity) components+=PathComponent | ||
106 | * (rule start) (ambiguity) functor=Reference | ||
107 | * (rule start) (ambiguity) op=UnaryOperator | ||
108 | * (rule start) (ambiguity) op=[Symbol|QualifiedName] | ||
109 | * (rule start) (ambiguity) value=INT | ||
110 | * (rule start) (ambiguity) value=LogicValue | ||
111 | * (rule start) (ambiguity) value=Real | ||
112 | * (rule start) (ambiguity) value=STRING | ||
113 | * (rule start) (ambiguity) {BinaryExpression.left=} | ||
114 | * (rule start) (ambiguity) {CastExpression.body=} | ||
115 | * (rule start) (ambiguity) {Conjunction.children+=} | ||
116 | * (rule start) (ambiguity) {Disjunction.children+=} | ||
117 | * (rule start) (ambiguity) {Forall.condition=} | ||
118 | * (rule start) (ambiguity) {Switch.cases+=} | ||
119 | */ | ||
120 | protected void emit_AtomicExpression_LeftParenthesisKeyword_4_0_a(EObject semanticObject, ISynNavigable transition, List<INode> nodes) { | ||
121 | acceptNodes(transition, nodes); | ||
122 | } | ||
123 | |||
124 | /** | ||
125 | * Ambiguous syntax: | ||
126 | * '('+ | ||
127 | * | ||
128 | * This ambiguous syntax occurs at: | ||
129 | * (rule start) (ambiguity) 'count' '{' condition=Expression | ||
130 | * (rule start) (ambiguity) 'if' condition=DisjunctiveExpression | ||
131 | * (rule start) (ambiguity) 'let' bindings+=LetBinding | ||
132 | * (rule start) (ambiguity) op=UnaryOperator | ||
133 | * (rule start) (ambiguity) op=[Symbol|QualifiedName] | ||
134 | * (rule start) (ambiguity) {BinaryExpression.left=} | ||
135 | * (rule start) (ambiguity) {CastExpression.body=} | ||
136 | * (rule start) (ambiguity) {Conjunction.children+=} | ||
137 | * (rule start) (ambiguity) {Disjunction.children+=} | ||
138 | * (rule start) (ambiguity) {Forall.condition=} | ||
139 | * (rule start) (ambiguity) {Switch.cases+=} | ||
140 | */ | ||
141 | protected void emit_AtomicExpression_LeftParenthesisKeyword_4_0_p(EObject semanticObject, ISynNavigable transition, List<INode> nodes) { | ||
142 | acceptNodes(transition, nodes); | ||
143 | } | ||
144 | |||
145 | /** | ||
146 | * Ambiguous syntax: | ||
147 | * ('{' '}') | FULL_STOP | ||
148 | * | ||
149 | * This ambiguous syntax occurs at: | ||
150 | * name=ID (ambiguity) (rule end) | ||
151 | * supertypes+=[Symbol|QualifiedName] (ambiguity) (rule end) | ||
152 | */ | ||
153 | protected void emit_ClassDeclaration_FULL_STOPTerminalRuleCall_4_1_or___LeftCurlyBracketKeyword_4_0_0_RightCurlyBracketKeyword_4_0_2__(EObject semanticObject, ISynNavigable transition, List<INode> nodes) { | ||
154 | acceptNodes(transition, nodes); | ||
155 | } | ||
156 | |||
157 | /** | ||
158 | * Ambiguous syntax: | ||
159 | * ','? | ||
160 | * | ||
161 | * This ambiguous syntax occurs at: | ||
162 | * literals+=EnumLiteral (ambiguity) literals+=EnumLiteral | ||
163 | */ | ||
164 | protected void emit_EnumDeclaration_CommaKeyword_2_0_1_1_0_q(EObject semanticObject, ISynNavigable transition, List<INode> nodes) { | ||
165 | acceptNodes(transition, nodes); | ||
166 | } | ||
167 | |||
168 | /** | ||
169 | * Ambiguous syntax: | ||
170 | * ('{' '}') | FULL_STOP | ||
171 | * | ||
172 | * This ambiguous syntax occurs at: | ||
173 | * name=ID (ambiguity) (rule end) | ||
174 | */ | ||
175 | protected void emit_EnumDeclaration_FULL_STOPTerminalRuleCall_2_1_or___LeftCurlyBracketKeyword_2_0_0_RightCurlyBracketKeyword_2_0_2__(EObject semanticObject, ISynNavigable transition, List<INode> nodes) { | ||
176 | acceptNodes(transition, nodes); | ||
177 | } | ||
178 | |||
179 | /** | ||
180 | * Ambiguous syntax: | ||
181 | * ';'? | ||
182 | * | ||
183 | * This ambiguous syntax occurs at: | ||
184 | * name=ID (ambiguity) (rule end) | ||
185 | * opposite=[Symbol|QualifiedName] (ambiguity) (rule end) | ||
186 | */ | ||
187 | protected void emit_Field_SemicolonKeyword_5_q(EObject semanticObject, ISynNavigable transition, List<INode> nodes) { | ||
188 | acceptNodes(transition, nodes); | ||
189 | } | ||
190 | |||
191 | } | ||
diff --git a/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/services/SolverLanguageGrammarAccess.java b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/services/SolverLanguageGrammarAccess.java new file mode 100644 index 00000000..a70729d4 --- /dev/null +++ b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/services/SolverLanguageGrammarAccess.java | |||
@@ -0,0 +1,4129 @@ | |||
1 | /* | ||
2 | * generated by Xtext 2.21.0 | ||
3 | */ | ||
4 | package org.eclipse.viatra.solver.language.services; | ||
5 | |||
6 | import com.google.inject.Inject; | ||
7 | import com.google.inject.Singleton; | ||
8 | import java.util.List; | ||
9 | import org.eclipse.xtext.Action; | ||
10 | import org.eclipse.xtext.Alternatives; | ||
11 | import org.eclipse.xtext.Assignment; | ||
12 | import org.eclipse.xtext.CrossReference; | ||
13 | import org.eclipse.xtext.EnumLiteralDeclaration; | ||
14 | import org.eclipse.xtext.EnumRule; | ||
15 | import org.eclipse.xtext.Grammar; | ||
16 | import org.eclipse.xtext.GrammarUtil; | ||
17 | import org.eclipse.xtext.Group; | ||
18 | import org.eclipse.xtext.Keyword; | ||
19 | import org.eclipse.xtext.ParserRule; | ||
20 | import org.eclipse.xtext.RuleCall; | ||
21 | import org.eclipse.xtext.TerminalRule; | ||
22 | import org.eclipse.xtext.UnorderedGroup; | ||
23 | import org.eclipse.xtext.common.services.TerminalsGrammarAccess; | ||
24 | import org.eclipse.xtext.service.AbstractElementFinder.AbstractEnumRuleElementFinder; | ||
25 | import org.eclipse.xtext.service.AbstractElementFinder.AbstractGrammarElementFinder; | ||
26 | import org.eclipse.xtext.service.GrammarProvider; | ||
27 | |||
28 | @Singleton | ||
29 | public class SolverLanguageGrammarAccess extends AbstractGrammarElementFinder { | ||
30 | |||
31 | public class ProblemElements extends AbstractParserRuleElementFinder { | ||
32 | private final ParserRule rule = (ParserRule) GrammarUtil.findRuleForName(getGrammar(), "org.eclipse.viatra.solver.language.SolverLanguage.Problem"); | ||
33 | private final Group cGroup = (Group)rule.eContents().get(1); | ||
34 | private final Group cGroup_0 = (Group)cGroup.eContents().get(0); | ||
35 | private final Keyword cProblemKeyword_0_0 = (Keyword)cGroup_0.eContents().get(0); | ||
36 | private final Assignment cNameAssignment_0_1 = (Assignment)cGroup_0.eContents().get(1); | ||
37 | private final RuleCall cNameQualifiedNameParserRuleCall_0_1_0 = (RuleCall)cNameAssignment_0_1.eContents().get(0); | ||
38 | private final RuleCall cFULL_STOPTerminalRuleCall_0_2 = (RuleCall)cGroup_0.eContents().get(2); | ||
39 | private final Assignment cImportsAssignment_1 = (Assignment)cGroup.eContents().get(1); | ||
40 | private final RuleCall cImportsImportParserRuleCall_1_0 = (RuleCall)cImportsAssignment_1.eContents().get(0); | ||
41 | private final Assignment cStatementsAssignment_2 = (Assignment)cGroup.eContents().get(2); | ||
42 | private final RuleCall cStatementsStatementParserRuleCall_2_0 = (RuleCall)cStatementsAssignment_2.eContents().get(0); | ||
43 | |||
44 | //Problem: | ||
45 | // ("problem" name=QualifiedName FULL_STOP)? | ||
46 | // imports+=Import* | ||
47 | // statements+=Statement*; | ||
48 | @Override public ParserRule getRule() { return rule; } | ||
49 | |||
50 | //("problem" name=QualifiedName FULL_STOP)? imports+=Import* statements+=Statement* | ||
51 | public Group getGroup() { return cGroup; } | ||
52 | |||
53 | //("problem" name=QualifiedName FULL_STOP)? | ||
54 | public Group getGroup_0() { return cGroup_0; } | ||
55 | |||
56 | //"problem" | ||
57 | public Keyword getProblemKeyword_0_0() { return cProblemKeyword_0_0; } | ||
58 | |||
59 | //name=QualifiedName | ||
60 | public Assignment getNameAssignment_0_1() { return cNameAssignment_0_1; } | ||
61 | |||
62 | //QualifiedName | ||
63 | public RuleCall getNameQualifiedNameParserRuleCall_0_1_0() { return cNameQualifiedNameParserRuleCall_0_1_0; } | ||
64 | |||
65 | //FULL_STOP | ||
66 | public RuleCall getFULL_STOPTerminalRuleCall_0_2() { return cFULL_STOPTerminalRuleCall_0_2; } | ||
67 | |||
68 | //imports+=Import* | ||
69 | public Assignment getImportsAssignment_1() { return cImportsAssignment_1; } | ||
70 | |||
71 | //Import | ||
72 | public RuleCall getImportsImportParserRuleCall_1_0() { return cImportsImportParserRuleCall_1_0; } | ||
73 | |||
74 | //statements+=Statement* | ||
75 | public Assignment getStatementsAssignment_2() { return cStatementsAssignment_2; } | ||
76 | |||
77 | //Statement | ||
78 | public RuleCall getStatementsStatementParserRuleCall_2_0() { return cStatementsStatementParserRuleCall_2_0; } | ||
79 | } | ||
80 | public class StatementElements extends AbstractParserRuleElementFinder { | ||
81 | private final ParserRule rule = (ParserRule) GrammarUtil.findRuleForName(getGrammar(), "org.eclipse.viatra.solver.language.SolverLanguage.Statement"); | ||
82 | private final Alternatives cAlternatives = (Alternatives)rule.eContents().get(1); | ||
83 | private final RuleCall cAssertionOrDefinitionParserRuleCall_0 = (RuleCall)cAlternatives.eContents().get(0); | ||
84 | private final RuleCall cPredicateDefinitionParserRuleCall_1 = (RuleCall)cAlternatives.eContents().get(1); | ||
85 | private final RuleCall cUnnamedErrorPredicateDefintionParserRuleCall_2 = (RuleCall)cAlternatives.eContents().get(2); | ||
86 | private final RuleCall cDefaultAssertionParserRuleCall_3 = (RuleCall)cAlternatives.eContents().get(3); | ||
87 | private final RuleCall cFunctionDefinitionParserRuleCall_4 = (RuleCall)cAlternatives.eContents().get(4); | ||
88 | private final RuleCall cAttributeParserRuleCall_5 = (RuleCall)cAlternatives.eContents().get(5); | ||
89 | private final RuleCall cExternDeclarationParserRuleCall_6 = (RuleCall)cAlternatives.eContents().get(6); | ||
90 | private final RuleCall cScopeDeclarationParserRuleCall_7 = (RuleCall)cAlternatives.eContents().get(7); | ||
91 | private final RuleCall cObjectiveDeclarationParserRuleCall_8 = (RuleCall)cAlternatives.eContents().get(8); | ||
92 | private final RuleCall cClassDeclarationParserRuleCall_9 = (RuleCall)cAlternatives.eContents().get(9); | ||
93 | private final RuleCall cEnumDeclarationParserRuleCall_10 = (RuleCall)cAlternatives.eContents().get(10); | ||
94 | |||
95 | //Statement: | ||
96 | // AssertionOrDefinition | PredicateDefinition | UnnamedErrorPredicateDefintion | DefaultAssertion | FunctionDefinition | ||
97 | // | Attribute | ExternDeclaration | ScopeDeclaration | ObjectiveDeclaration | ClassDeclaration | EnumDeclaration; | ||
98 | @Override public ParserRule getRule() { return rule; } | ||
99 | |||
100 | //AssertionOrDefinition | PredicateDefinition | UnnamedErrorPredicateDefintion | DefaultAssertion | FunctionDefinition | | ||
101 | //Attribute | ExternDeclaration | ScopeDeclaration | ObjectiveDeclaration | ClassDeclaration | EnumDeclaration | ||
102 | public Alternatives getAlternatives() { return cAlternatives; } | ||
103 | |||
104 | //AssertionOrDefinition | ||
105 | public RuleCall getAssertionOrDefinitionParserRuleCall_0() { return cAssertionOrDefinitionParserRuleCall_0; } | ||
106 | |||
107 | //PredicateDefinition | ||
108 | public RuleCall getPredicateDefinitionParserRuleCall_1() { return cPredicateDefinitionParserRuleCall_1; } | ||
109 | |||
110 | //UnnamedErrorPredicateDefintion | ||
111 | public RuleCall getUnnamedErrorPredicateDefintionParserRuleCall_2() { return cUnnamedErrorPredicateDefintionParserRuleCall_2; } | ||
112 | |||
113 | //DefaultAssertion | ||
114 | public RuleCall getDefaultAssertionParserRuleCall_3() { return cDefaultAssertionParserRuleCall_3; } | ||
115 | |||
116 | //FunctionDefinition | ||
117 | public RuleCall getFunctionDefinitionParserRuleCall_4() { return cFunctionDefinitionParserRuleCall_4; } | ||
118 | |||
119 | //Attribute | ||
120 | public RuleCall getAttributeParserRuleCall_5() { return cAttributeParserRuleCall_5; } | ||
121 | |||
122 | //ExternDeclaration | ||
123 | public RuleCall getExternDeclarationParserRuleCall_6() { return cExternDeclarationParserRuleCall_6; } | ||
124 | |||
125 | //ScopeDeclaration | ||
126 | public RuleCall getScopeDeclarationParserRuleCall_7() { return cScopeDeclarationParserRuleCall_7; } | ||
127 | |||
128 | //ObjectiveDeclaration | ||
129 | public RuleCall getObjectiveDeclarationParserRuleCall_8() { return cObjectiveDeclarationParserRuleCall_8; } | ||
130 | |||
131 | //ClassDeclaration | ||
132 | public RuleCall getClassDeclarationParserRuleCall_9() { return cClassDeclarationParserRuleCall_9; } | ||
133 | |||
134 | //EnumDeclaration | ||
135 | public RuleCall getEnumDeclarationParserRuleCall_10() { return cEnumDeclarationParserRuleCall_10; } | ||
136 | } | ||
137 | public class ImportElements extends AbstractParserRuleElementFinder { | ||
138 | private final ParserRule rule = (ParserRule) GrammarUtil.findRuleForName(getGrammar(), "org.eclipse.viatra.solver.language.SolverLanguage.Import"); | ||
139 | private final Alternatives cAlternatives = (Alternatives)rule.eContents().get(1); | ||
140 | private final RuleCall cUriImportParserRuleCall_0 = (RuleCall)cAlternatives.eContents().get(0); | ||
141 | private final RuleCall cNamespaceImportParserRuleCall_1 = (RuleCall)cAlternatives.eContents().get(1); | ||
142 | |||
143 | //Import: | ||
144 | // UriImport | NamespaceImport; | ||
145 | @Override public ParserRule getRule() { return rule; } | ||
146 | |||
147 | //UriImport | NamespaceImport | ||
148 | public Alternatives getAlternatives() { return cAlternatives; } | ||
149 | |||
150 | //UriImport | ||
151 | public RuleCall getUriImportParserRuleCall_0() { return cUriImportParserRuleCall_0; } | ||
152 | |||
153 | //NamespaceImport | ||
154 | public RuleCall getNamespaceImportParserRuleCall_1() { return cNamespaceImportParserRuleCall_1; } | ||
155 | } | ||
156 | public class UriImportElements extends AbstractParserRuleElementFinder { | ||
157 | private final ParserRule rule = (ParserRule) GrammarUtil.findRuleForName(getGrammar(), "org.eclipse.viatra.solver.language.SolverLanguage.UriImport"); | ||
158 | private final Group cGroup = (Group)rule.eContents().get(1); | ||
159 | private final Keyword cImportKeyword_0 = (Keyword)cGroup.eContents().get(0); | ||
160 | private final Assignment cUriAssignment_1 = (Assignment)cGroup.eContents().get(1); | ||
161 | private final RuleCall cUriSTRINGTerminalRuleCall_1_0 = (RuleCall)cUriAssignment_1.eContents().get(0); | ||
162 | private final Group cGroup_2 = (Group)cGroup.eContents().get(2); | ||
163 | private final Keyword cAsKeyword_2_0 = (Keyword)cGroup_2.eContents().get(0); | ||
164 | private final Assignment cAliasAssignment_2_1 = (Assignment)cGroup_2.eContents().get(1); | ||
165 | private final RuleCall cAliasQualifiedNameParserRuleCall_2_1_0 = (RuleCall)cAliasAssignment_2_1.eContents().get(0); | ||
166 | private final RuleCall cFULL_STOPTerminalRuleCall_3 = (RuleCall)cGroup.eContents().get(3); | ||
167 | |||
168 | //UriImport: | ||
169 | // "import" uri=STRING ("as" alias=QualifiedName) FULL_STOP; | ||
170 | @Override public ParserRule getRule() { return rule; } | ||
171 | |||
172 | //"import" uri=STRING ("as" alias=QualifiedName) FULL_STOP | ||
173 | public Group getGroup() { return cGroup; } | ||
174 | |||
175 | //"import" | ||
176 | public Keyword getImportKeyword_0() { return cImportKeyword_0; } | ||
177 | |||
178 | //uri=STRING | ||
179 | public Assignment getUriAssignment_1() { return cUriAssignment_1; } | ||
180 | |||
181 | //STRING | ||
182 | public RuleCall getUriSTRINGTerminalRuleCall_1_0() { return cUriSTRINGTerminalRuleCall_1_0; } | ||
183 | |||
184 | //("as" alias=QualifiedName) | ||
185 | public Group getGroup_2() { return cGroup_2; } | ||
186 | |||
187 | //"as" | ||
188 | public Keyword getAsKeyword_2_0() { return cAsKeyword_2_0; } | ||
189 | |||
190 | //alias=QualifiedName | ||
191 | public Assignment getAliasAssignment_2_1() { return cAliasAssignment_2_1; } | ||
192 | |||
193 | //QualifiedName | ||
194 | public RuleCall getAliasQualifiedNameParserRuleCall_2_1_0() { return cAliasQualifiedNameParserRuleCall_2_1_0; } | ||
195 | |||
196 | //FULL_STOP | ||
197 | public RuleCall getFULL_STOPTerminalRuleCall_3() { return cFULL_STOPTerminalRuleCall_3; } | ||
198 | } | ||
199 | public class NamespaceImportElements extends AbstractParserRuleElementFinder { | ||
200 | private final ParserRule rule = (ParserRule) GrammarUtil.findRuleForName(getGrammar(), "org.eclipse.viatra.solver.language.SolverLanguage.NamespaceImport"); | ||
201 | private final Group cGroup = (Group)rule.eContents().get(1); | ||
202 | private final Keyword cImportKeyword_0 = (Keyword)cGroup.eContents().get(0); | ||
203 | private final Assignment cImportedNamespaceAssignment_1 = (Assignment)cGroup.eContents().get(1); | ||
204 | private final RuleCall cImportedNamespaceQualifiedNameParserRuleCall_1_0 = (RuleCall)cImportedNamespaceAssignment_1.eContents().get(0); | ||
205 | private final Group cGroup_2 = (Group)cGroup.eContents().get(2); | ||
206 | private final Keyword cAsKeyword_2_0 = (Keyword)cGroup_2.eContents().get(0); | ||
207 | private final Assignment cAliasAssignment_2_1 = (Assignment)cGroup_2.eContents().get(1); | ||
208 | private final RuleCall cAliasQualifiedNameParserRuleCall_2_1_0 = (RuleCall)cAliasAssignment_2_1.eContents().get(0); | ||
209 | private final RuleCall cFULL_STOPTerminalRuleCall_3 = (RuleCall)cGroup.eContents().get(3); | ||
210 | |||
211 | //NamespaceImport: | ||
212 | // "import" importedNamespace=QualifiedName ("as" alias=QualifiedName) FULL_STOP; | ||
213 | @Override public ParserRule getRule() { return rule; } | ||
214 | |||
215 | //"import" importedNamespace=QualifiedName ("as" alias=QualifiedName) FULL_STOP | ||
216 | public Group getGroup() { return cGroup; } | ||
217 | |||
218 | //"import" | ||
219 | public Keyword getImportKeyword_0() { return cImportKeyword_0; } | ||
220 | |||
221 | //importedNamespace=QualifiedName | ||
222 | public Assignment getImportedNamespaceAssignment_1() { return cImportedNamespaceAssignment_1; } | ||
223 | |||
224 | //QualifiedName | ||
225 | public RuleCall getImportedNamespaceQualifiedNameParserRuleCall_1_0() { return cImportedNamespaceQualifiedNameParserRuleCall_1_0; } | ||
226 | |||
227 | //("as" alias=QualifiedName) | ||
228 | public Group getGroup_2() { return cGroup_2; } | ||
229 | |||
230 | //"as" | ||
231 | public Keyword getAsKeyword_2_0() { return cAsKeyword_2_0; } | ||
232 | |||
233 | //alias=QualifiedName | ||
234 | public Assignment getAliasAssignment_2_1() { return cAliasAssignment_2_1; } | ||
235 | |||
236 | //QualifiedName | ||
237 | public RuleCall getAliasQualifiedNameParserRuleCall_2_1_0() { return cAliasQualifiedNameParserRuleCall_2_1_0; } | ||
238 | |||
239 | //FULL_STOP | ||
240 | public RuleCall getFULL_STOPTerminalRuleCall_3() { return cFULL_STOPTerminalRuleCall_3; } | ||
241 | } | ||
242 | public class AssertionOrDefinitionElements extends AbstractParserRuleElementFinder { | ||
243 | private final ParserRule rule = (ParserRule) GrammarUtil.findRuleForName(getGrammar(), "org.eclipse.viatra.solver.language.SolverLanguage.AssertionOrDefinition"); | ||
244 | private final Group cGroup = (Group)rule.eContents().get(1); | ||
245 | private final RuleCall cExpressionParserRuleCall_0 = (RuleCall)cGroup.eContents().get(0); | ||
246 | private final Alternatives cAlternatives_1 = (Alternatives)cGroup.eContents().get(1); | ||
247 | private final Group cGroup_1_0 = (Group)cAlternatives_1.eContents().get(0); | ||
248 | private final Action cAssertionExpressionAction_1_0_0 = (Action)cGroup_1_0.eContents().get(0); | ||
249 | private final Group cGroup_1_0_1 = (Group)cGroup_1_0.eContents().get(1); | ||
250 | private final Keyword cColonKeyword_1_0_1_0 = (Keyword)cGroup_1_0_1.eContents().get(0); | ||
251 | private final Assignment cRangeAssignment_1_0_1_1 = (Assignment)cGroup_1_0_1.eContents().get(1); | ||
252 | private final RuleCall cRangeExpressionParserRuleCall_1_0_1_1_0 = (RuleCall)cRangeAssignment_1_0_1_1.eContents().get(0); | ||
253 | private final Group cGroup_1_1 = (Group)cAlternatives_1.eContents().get(1); | ||
254 | private final Action cPredicateDefinitionHeadAction_1_1_0 = (Action)cGroup_1_1.eContents().get(0); | ||
255 | private final Keyword cColonHyphenMinusKeyword_1_1_1 = (Keyword)cGroup_1_1.eContents().get(1); | ||
256 | private final Assignment cBodyAssignment_1_1_2 = (Assignment)cGroup_1_1.eContents().get(2); | ||
257 | private final RuleCall cBodyExpressionParserRuleCall_1_1_2_0 = (RuleCall)cBodyAssignment_1_1_2.eContents().get(0); | ||
258 | private final Group cGroup_1_2 = (Group)cAlternatives_1.eContents().get(2); | ||
259 | private final Action cFunctionDefinitionHeadAction_1_2_0 = (Action)cGroup_1_2.eContents().get(0); | ||
260 | private final Keyword cColonEqualsSignKeyword_1_2_1 = (Keyword)cGroup_1_2.eContents().get(1); | ||
261 | private final Assignment cBodyAssignment_1_2_2 = (Assignment)cGroup_1_2.eContents().get(2); | ||
262 | private final RuleCall cBodyExpressionParserRuleCall_1_2_2_0 = (RuleCall)cBodyAssignment_1_2_2.eContents().get(0); | ||
263 | private final RuleCall cFULL_STOPTerminalRuleCall_2 = (RuleCall)cGroup.eContents().get(2); | ||
264 | |||
265 | //AssertionOrDefinition Statement: | ||
266 | // Expression ({Assertion.expression=current} (":" range=Expression)? | {PredicateDefinition.head=current} ":-" | ||
267 | // body=Expression | {FunctionDefinition.head=current} ":=" body=Expression) FULL_STOP; | ||
268 | @Override public ParserRule getRule() { return rule; } | ||
269 | |||
270 | //Expression ({Assertion.expression=current} (":" range=Expression)? | {PredicateDefinition.head=current} ":-" | ||
271 | //body=Expression | {FunctionDefinition.head=current} ":=" body=Expression) FULL_STOP | ||
272 | public Group getGroup() { return cGroup; } | ||
273 | |||
274 | //Expression | ||
275 | public RuleCall getExpressionParserRuleCall_0() { return cExpressionParserRuleCall_0; } | ||
276 | |||
277 | //({Assertion.expression=current} (":" range=Expression)? | {PredicateDefinition.head=current} ":-" body=Expression | | ||
278 | //{FunctionDefinition.head=current} ":=" body=Expression) | ||
279 | public Alternatives getAlternatives_1() { return cAlternatives_1; } | ||
280 | |||
281 | //{Assertion.expression=current} (":" range=Expression)? | ||
282 | public Group getGroup_1_0() { return cGroup_1_0; } | ||
283 | |||
284 | //{Assertion.expression=current} | ||
285 | public Action getAssertionExpressionAction_1_0_0() { return cAssertionExpressionAction_1_0_0; } | ||
286 | |||
287 | //(":" range=Expression)? | ||
288 | public Group getGroup_1_0_1() { return cGroup_1_0_1; } | ||
289 | |||
290 | //":" | ||
291 | public Keyword getColonKeyword_1_0_1_0() { return cColonKeyword_1_0_1_0; } | ||
292 | |||
293 | //range=Expression | ||
294 | public Assignment getRangeAssignment_1_0_1_1() { return cRangeAssignment_1_0_1_1; } | ||
295 | |||
296 | //Expression | ||
297 | public RuleCall getRangeExpressionParserRuleCall_1_0_1_1_0() { return cRangeExpressionParserRuleCall_1_0_1_1_0; } | ||
298 | |||
299 | //{PredicateDefinition.head=current} ":-" body=Expression | ||
300 | public Group getGroup_1_1() { return cGroup_1_1; } | ||
301 | |||
302 | //{PredicateDefinition.head=current} | ||
303 | public Action getPredicateDefinitionHeadAction_1_1_0() { return cPredicateDefinitionHeadAction_1_1_0; } | ||
304 | |||
305 | //":-" | ||
306 | public Keyword getColonHyphenMinusKeyword_1_1_1() { return cColonHyphenMinusKeyword_1_1_1; } | ||
307 | |||
308 | //body=Expression | ||
309 | public Assignment getBodyAssignment_1_1_2() { return cBodyAssignment_1_1_2; } | ||
310 | |||
311 | //Expression | ||
312 | public RuleCall getBodyExpressionParserRuleCall_1_1_2_0() { return cBodyExpressionParserRuleCall_1_1_2_0; } | ||
313 | |||
314 | //{FunctionDefinition.head=current} ":=" body=Expression | ||
315 | public Group getGroup_1_2() { return cGroup_1_2; } | ||
316 | |||
317 | //{FunctionDefinition.head=current} | ||
318 | public Action getFunctionDefinitionHeadAction_1_2_0() { return cFunctionDefinitionHeadAction_1_2_0; } | ||
319 | |||
320 | //":=" | ||
321 | public Keyword getColonEqualsSignKeyword_1_2_1() { return cColonEqualsSignKeyword_1_2_1; } | ||
322 | |||
323 | //body=Expression | ||
324 | public Assignment getBodyAssignment_1_2_2() { return cBodyAssignment_1_2_2; } | ||
325 | |||
326 | //Expression | ||
327 | public RuleCall getBodyExpressionParserRuleCall_1_2_2_0() { return cBodyExpressionParserRuleCall_1_2_2_0; } | ||
328 | |||
329 | //FULL_STOP | ||
330 | public RuleCall getFULL_STOPTerminalRuleCall_2() { return cFULL_STOPTerminalRuleCall_2; } | ||
331 | } | ||
332 | public class PredicateDefinitionElements extends AbstractParserRuleElementFinder { | ||
333 | private final ParserRule rule = (ParserRule) GrammarUtil.findRuleForName(getGrammar(), "org.eclipse.viatra.solver.language.SolverLanguage.PredicateDefinition"); | ||
334 | private final Group cGroup = (Group)rule.eContents().get(1); | ||
335 | private final Alternatives cAlternatives_0 = (Alternatives)cGroup.eContents().get(0); | ||
336 | private final Group cGroup_0_0 = (Group)cAlternatives_0.eContents().get(0); | ||
337 | private final Assignment cFunctionalAssignment_0_0_0 = (Assignment)cGroup_0_0.eContents().get(0); | ||
338 | private final Keyword cFunctionalFunctionalKeyword_0_0_0_0 = (Keyword)cFunctionalAssignment_0_0_0.eContents().get(0); | ||
339 | private final Assignment cErrorAssignment_0_0_1 = (Assignment)cGroup_0_0.eContents().get(1); | ||
340 | private final Keyword cErrorErrorKeyword_0_0_1_0 = (Keyword)cErrorAssignment_0_0_1.eContents().get(0); | ||
341 | private final Group cGroup_0_1 = (Group)cAlternatives_0.eContents().get(1); | ||
342 | private final Assignment cErrorAssignment_0_1_0 = (Assignment)cGroup_0_1.eContents().get(0); | ||
343 | private final Keyword cErrorErrorKeyword_0_1_0_0 = (Keyword)cErrorAssignment_0_1_0.eContents().get(0); | ||
344 | private final Assignment cFunctionalAssignment_0_1_1 = (Assignment)cGroup_0_1.eContents().get(1); | ||
345 | private final Keyword cFunctionalFunctionalKeyword_0_1_1_0 = (Keyword)cFunctionalAssignment_0_1_1.eContents().get(0); | ||
346 | private final Assignment cHeadAssignment_1 = (Assignment)cGroup.eContents().get(1); | ||
347 | private final RuleCall cHeadCallParserRuleCall_1_0 = (RuleCall)cHeadAssignment_1.eContents().get(0); | ||
348 | private final Keyword cColonHyphenMinusKeyword_2 = (Keyword)cGroup.eContents().get(2); | ||
349 | private final Assignment cBodyAssignment_3 = (Assignment)cGroup.eContents().get(3); | ||
350 | private final RuleCall cBodyExpressionParserRuleCall_3_0 = (RuleCall)cBodyAssignment_3.eContents().get(0); | ||
351 | private final RuleCall cFULL_STOPTerminalRuleCall_4 = (RuleCall)cGroup.eContents().get(4); | ||
352 | |||
353 | //PredicateDefinition: | ||
354 | // (functional?="functional" error?="error"? | error?="error" functional?="functional"?) head=Call ":-" body=Expression | ||
355 | // FULL_STOP; | ||
356 | @Override public ParserRule getRule() { return rule; } | ||
357 | |||
358 | //(functional?="functional" error?="error"? | error?="error" functional?="functional"?) head=Call ":-" body=Expression | ||
359 | //FULL_STOP | ||
360 | public Group getGroup() { return cGroup; } | ||
361 | |||
362 | //(functional?="functional" error?="error"? | error?="error" functional?="functional"?) | ||
363 | public Alternatives getAlternatives_0() { return cAlternatives_0; } | ||
364 | |||
365 | //functional?="functional" error?="error"? | ||
366 | public Group getGroup_0_0() { return cGroup_0_0; } | ||
367 | |||
368 | //functional?="functional" | ||
369 | public Assignment getFunctionalAssignment_0_0_0() { return cFunctionalAssignment_0_0_0; } | ||
370 | |||
371 | //"functional" | ||
372 | public Keyword getFunctionalFunctionalKeyword_0_0_0_0() { return cFunctionalFunctionalKeyword_0_0_0_0; } | ||
373 | |||
374 | //error?="error"? | ||
375 | public Assignment getErrorAssignment_0_0_1() { return cErrorAssignment_0_0_1; } | ||
376 | |||
377 | //"error" | ||
378 | public Keyword getErrorErrorKeyword_0_0_1_0() { return cErrorErrorKeyword_0_0_1_0; } | ||
379 | |||
380 | //error?="error" functional?="functional"? | ||
381 | public Group getGroup_0_1() { return cGroup_0_1; } | ||
382 | |||
383 | //error?="error" | ||
384 | public Assignment getErrorAssignment_0_1_0() { return cErrorAssignment_0_1_0; } | ||
385 | |||
386 | //"error" | ||
387 | public Keyword getErrorErrorKeyword_0_1_0_0() { return cErrorErrorKeyword_0_1_0_0; } | ||
388 | |||
389 | //functional?="functional"? | ||
390 | public Assignment getFunctionalAssignment_0_1_1() { return cFunctionalAssignment_0_1_1; } | ||
391 | |||
392 | //"functional" | ||
393 | public Keyword getFunctionalFunctionalKeyword_0_1_1_0() { return cFunctionalFunctionalKeyword_0_1_1_0; } | ||
394 | |||
395 | //head=Call | ||
396 | public Assignment getHeadAssignment_1() { return cHeadAssignment_1; } | ||
397 | |||
398 | //Call | ||
399 | public RuleCall getHeadCallParserRuleCall_1_0() { return cHeadCallParserRuleCall_1_0; } | ||
400 | |||
401 | //":-" | ||
402 | public Keyword getColonHyphenMinusKeyword_2() { return cColonHyphenMinusKeyword_2; } | ||
403 | |||
404 | //body=Expression | ||
405 | public Assignment getBodyAssignment_3() { return cBodyAssignment_3; } | ||
406 | |||
407 | //Expression | ||
408 | public RuleCall getBodyExpressionParserRuleCall_3_0() { return cBodyExpressionParserRuleCall_3_0; } | ||
409 | |||
410 | //FULL_STOP | ||
411 | public RuleCall getFULL_STOPTerminalRuleCall_4() { return cFULL_STOPTerminalRuleCall_4; } | ||
412 | } | ||
413 | public class UnnamedErrorPredicateDefintionElements extends AbstractParserRuleElementFinder { | ||
414 | private final ParserRule rule = (ParserRule) GrammarUtil.findRuleForName(getGrammar(), "org.eclipse.viatra.solver.language.SolverLanguage.UnnamedErrorPredicateDefintion"); | ||
415 | private final Group cGroup = (Group)rule.eContents().get(1); | ||
416 | private final Keyword cErrorKeyword_0 = (Keyword)cGroup.eContents().get(0); | ||
417 | private final Assignment cArgumentListAssignment_1 = (Assignment)cGroup.eContents().get(1); | ||
418 | private final RuleCall cArgumentListArgumentListParserRuleCall_1_0 = (RuleCall)cArgumentListAssignment_1.eContents().get(0); | ||
419 | private final Keyword cColonHyphenMinusKeyword_2 = (Keyword)cGroup.eContents().get(2); | ||
420 | private final Assignment cBodyAssignment_3 = (Assignment)cGroup.eContents().get(3); | ||
421 | private final RuleCall cBodyExpressionParserRuleCall_3_0 = (RuleCall)cBodyAssignment_3.eContents().get(0); | ||
422 | private final RuleCall cFULL_STOPTerminalRuleCall_4 = (RuleCall)cGroup.eContents().get(4); | ||
423 | |||
424 | //UnnamedErrorPredicateDefintion: | ||
425 | // "error" argumentList=ArgumentList ":-" body=Expression FULL_STOP; | ||
426 | @Override public ParserRule getRule() { return rule; } | ||
427 | |||
428 | //"error" argumentList=ArgumentList ":-" body=Expression FULL_STOP | ||
429 | public Group getGroup() { return cGroup; } | ||
430 | |||
431 | //"error" | ||
432 | public Keyword getErrorKeyword_0() { return cErrorKeyword_0; } | ||
433 | |||
434 | //argumentList=ArgumentList | ||
435 | public Assignment getArgumentListAssignment_1() { return cArgumentListAssignment_1; } | ||
436 | |||
437 | //ArgumentList | ||
438 | public RuleCall getArgumentListArgumentListParserRuleCall_1_0() { return cArgumentListArgumentListParserRuleCall_1_0; } | ||
439 | |||
440 | //":-" | ||
441 | public Keyword getColonHyphenMinusKeyword_2() { return cColonHyphenMinusKeyword_2; } | ||
442 | |||
443 | //body=Expression | ||
444 | public Assignment getBodyAssignment_3() { return cBodyAssignment_3; } | ||
445 | |||
446 | //Expression | ||
447 | public RuleCall getBodyExpressionParserRuleCall_3_0() { return cBodyExpressionParserRuleCall_3_0; } | ||
448 | |||
449 | //FULL_STOP | ||
450 | public RuleCall getFULL_STOPTerminalRuleCall_4() { return cFULL_STOPTerminalRuleCall_4; } | ||
451 | } | ||
452 | public class DefaultAssertionElements extends AbstractParserRuleElementFinder { | ||
453 | private final ParserRule rule = (ParserRule) GrammarUtil.findRuleForName(getGrammar(), "org.eclipse.viatra.solver.language.SolverLanguage.DefaultAssertion"); | ||
454 | private final Group cGroup = (Group)rule.eContents().get(1); | ||
455 | private final Keyword cDefaultKeyword_0 = (Keyword)cGroup.eContents().get(0); | ||
456 | private final Assignment cExpressionAssignment_1 = (Assignment)cGroup.eContents().get(1); | ||
457 | private final RuleCall cExpressionCallParserRuleCall_1_0 = (RuleCall)cExpressionAssignment_1.eContents().get(0); | ||
458 | private final Group cGroup_2 = (Group)cGroup.eContents().get(2); | ||
459 | private final Keyword cColonKeyword_2_0 = (Keyword)cGroup_2.eContents().get(0); | ||
460 | private final Assignment cRangeAssignment_2_1 = (Assignment)cGroup_2.eContents().get(1); | ||
461 | private final RuleCall cRangeExpressionParserRuleCall_2_1_0 = (RuleCall)cRangeAssignment_2_1.eContents().get(0); | ||
462 | private final RuleCall cFULL_STOPTerminalRuleCall_3 = (RuleCall)cGroup.eContents().get(3); | ||
463 | |||
464 | //DefaultAssertion: | ||
465 | // "default" expression=Call (":" range=Expression)? FULL_STOP; | ||
466 | @Override public ParserRule getRule() { return rule; } | ||
467 | |||
468 | //"default" expression=Call (":" range=Expression)? FULL_STOP | ||
469 | public Group getGroup() { return cGroup; } | ||
470 | |||
471 | //"default" | ||
472 | public Keyword getDefaultKeyword_0() { return cDefaultKeyword_0; } | ||
473 | |||
474 | //expression=Call | ||
475 | public Assignment getExpressionAssignment_1() { return cExpressionAssignment_1; } | ||
476 | |||
477 | //Call | ||
478 | public RuleCall getExpressionCallParserRuleCall_1_0() { return cExpressionCallParserRuleCall_1_0; } | ||
479 | |||
480 | //(":" range=Expression)? | ||
481 | public Group getGroup_2() { return cGroup_2; } | ||
482 | |||
483 | //":" | ||
484 | public Keyword getColonKeyword_2_0() { return cColonKeyword_2_0; } | ||
485 | |||
486 | //range=Expression | ||
487 | public Assignment getRangeAssignment_2_1() { return cRangeAssignment_2_1; } | ||
488 | |||
489 | //Expression | ||
490 | public RuleCall getRangeExpressionParserRuleCall_2_1_0() { return cRangeExpressionParserRuleCall_2_1_0; } | ||
491 | |||
492 | //FULL_STOP | ||
493 | public RuleCall getFULL_STOPTerminalRuleCall_3() { return cFULL_STOPTerminalRuleCall_3; } | ||
494 | } | ||
495 | public class FunctionDefinitionElements extends AbstractParserRuleElementFinder { | ||
496 | private final ParserRule rule = (ParserRule) GrammarUtil.findRuleForName(getGrammar(), "org.eclipse.viatra.solver.language.SolverLanguage.FunctionDefinition"); | ||
497 | private final Group cGroup = (Group)rule.eContents().get(1); | ||
498 | private final Assignment cResultTypeAssignment_0 = (Assignment)cGroup.eContents().get(0); | ||
499 | private final CrossReference cResultTypeSymbolCrossReference_0_0 = (CrossReference)cResultTypeAssignment_0.eContents().get(0); | ||
500 | private final RuleCall cResultTypeSymbolQualifiedNameParserRuleCall_0_0_1 = (RuleCall)cResultTypeSymbolCrossReference_0_0.eContents().get(1); | ||
501 | private final Assignment cHeadAssignment_1 = (Assignment)cGroup.eContents().get(1); | ||
502 | private final RuleCall cHeadCallParserRuleCall_1_0 = (RuleCall)cHeadAssignment_1.eContents().get(0); | ||
503 | private final Keyword cColonEqualsSignKeyword_2 = (Keyword)cGroup.eContents().get(2); | ||
504 | private final Assignment cBodyAssignment_3 = (Assignment)cGroup.eContents().get(3); | ||
505 | private final RuleCall cBodyExpressionParserRuleCall_3_0 = (RuleCall)cBodyAssignment_3.eContents().get(0); | ||
506 | private final RuleCall cFULL_STOPTerminalRuleCall_4 = (RuleCall)cGroup.eContents().get(4); | ||
507 | |||
508 | //FunctionDefinition: | ||
509 | // resultType=[Symbol|QualifiedName] head=Call ":=" body=Expression FULL_STOP; | ||
510 | @Override public ParserRule getRule() { return rule; } | ||
511 | |||
512 | //resultType=[Symbol|QualifiedName] head=Call ":=" body=Expression FULL_STOP | ||
513 | public Group getGroup() { return cGroup; } | ||
514 | |||
515 | //resultType=[Symbol|QualifiedName] | ||
516 | public Assignment getResultTypeAssignment_0() { return cResultTypeAssignment_0; } | ||
517 | |||
518 | //[Symbol|QualifiedName] | ||
519 | public CrossReference getResultTypeSymbolCrossReference_0_0() { return cResultTypeSymbolCrossReference_0_0; } | ||
520 | |||
521 | //QualifiedName | ||
522 | public RuleCall getResultTypeSymbolQualifiedNameParserRuleCall_0_0_1() { return cResultTypeSymbolQualifiedNameParserRuleCall_0_0_1; } | ||
523 | |||
524 | //head=Call | ||
525 | public Assignment getHeadAssignment_1() { return cHeadAssignment_1; } | ||
526 | |||
527 | //Call | ||
528 | public RuleCall getHeadCallParserRuleCall_1_0() { return cHeadCallParserRuleCall_1_0; } | ||
529 | |||
530 | //":=" | ||
531 | public Keyword getColonEqualsSignKeyword_2() { return cColonEqualsSignKeyword_2; } | ||
532 | |||
533 | //body=Expression | ||
534 | public Assignment getBodyAssignment_3() { return cBodyAssignment_3; } | ||
535 | |||
536 | //Expression | ||
537 | public RuleCall getBodyExpressionParserRuleCall_3_0() { return cBodyExpressionParserRuleCall_3_0; } | ||
538 | |||
539 | //FULL_STOP | ||
540 | public RuleCall getFULL_STOPTerminalRuleCall_4() { return cFULL_STOPTerminalRuleCall_4; } | ||
541 | } | ||
542 | public class TypeReferenceElements extends AbstractParserRuleElementFinder { | ||
543 | private final ParserRule rule = (ParserRule) GrammarUtil.findRuleForName(getGrammar(), "org.eclipse.viatra.solver.language.SolverLanguage.TypeReference"); | ||
544 | private final Group cGroup = (Group)rule.eContents().get(1); | ||
545 | private final Assignment cTypeAssignment_0 = (Assignment)cGroup.eContents().get(0); | ||
546 | private final CrossReference cTypeSymbolCrossReference_0_0 = (CrossReference)cTypeAssignment_0.eContents().get(0); | ||
547 | private final RuleCall cTypeSymbolQualifiedNameParserRuleCall_0_0_1 = (RuleCall)cTypeSymbolCrossReference_0_0.eContents().get(1); | ||
548 | private final Assignment cForceObjectTypeAssignment_1 = (Assignment)cGroup.eContents().get(1); | ||
549 | private final Keyword cForceObjectTypeObjectKeyword_1_0 = (Keyword)cForceObjectTypeAssignment_1.eContents().get(0); | ||
550 | |||
551 | //TypeReference: | ||
552 | // type=[Symbol|QualifiedName] forceObjectType?="object"?; | ||
553 | @Override public ParserRule getRule() { return rule; } | ||
554 | |||
555 | //type=[Symbol|QualifiedName] forceObjectType?="object"? | ||
556 | public Group getGroup() { return cGroup; } | ||
557 | |||
558 | //type=[Symbol|QualifiedName] | ||
559 | public Assignment getTypeAssignment_0() { return cTypeAssignment_0; } | ||
560 | |||
561 | //[Symbol|QualifiedName] | ||
562 | public CrossReference getTypeSymbolCrossReference_0_0() { return cTypeSymbolCrossReference_0_0; } | ||
563 | |||
564 | //QualifiedName | ||
565 | public RuleCall getTypeSymbolQualifiedNameParserRuleCall_0_0_1() { return cTypeSymbolQualifiedNameParserRuleCall_0_0_1; } | ||
566 | |||
567 | //forceObjectType?="object"? | ||
568 | public Assignment getForceObjectTypeAssignment_1() { return cForceObjectTypeAssignment_1; } | ||
569 | |||
570 | //"object" | ||
571 | public Keyword getForceObjectTypeObjectKeyword_1_0() { return cForceObjectTypeObjectKeyword_1_0; } | ||
572 | } | ||
573 | public class AttributeElements extends AbstractParserRuleElementFinder { | ||
574 | private final ParserRule rule = (ParserRule) GrammarUtil.findRuleForName(getGrammar(), "org.eclipse.viatra.solver.language.SolverLanguage.Attribute"); | ||
575 | private final Group cGroup = (Group)rule.eContents().get(1); | ||
576 | private final Assignment cKindAssignment_0 = (Assignment)cGroup.eContents().get(0); | ||
577 | private final RuleCall cKindAttributeKindEnumRuleCall_0_0 = (RuleCall)cKindAssignment_0.eContents().get(0); | ||
578 | private final Assignment cTargetAssignment_1 = (Assignment)cGroup.eContents().get(1); | ||
579 | private final CrossReference cTargetSymbolCrossReference_1_0 = (CrossReference)cTargetAssignment_1.eContents().get(0); | ||
580 | private final RuleCall cTargetSymbolQualifiedNameParserRuleCall_1_0_1 = (RuleCall)cTargetSymbolCrossReference_1_0.eContents().get(1); | ||
581 | private final RuleCall cFULL_STOPTerminalRuleCall_2 = (RuleCall)cGroup.eContents().get(2); | ||
582 | |||
583 | //Attribute: | ||
584 | // kind=AttributeKind target=[Symbol|QualifiedName] FULL_STOP; | ||
585 | @Override public ParserRule getRule() { return rule; } | ||
586 | |||
587 | //kind=AttributeKind target=[Symbol|QualifiedName] FULL_STOP | ||
588 | public Group getGroup() { return cGroup; } | ||
589 | |||
590 | //kind=AttributeKind | ||
591 | public Assignment getKindAssignment_0() { return cKindAssignment_0; } | ||
592 | |||
593 | //AttributeKind | ||
594 | public RuleCall getKindAttributeKindEnumRuleCall_0_0() { return cKindAttributeKindEnumRuleCall_0_0; } | ||
595 | |||
596 | //target=[Symbol|QualifiedName] | ||
597 | public Assignment getTargetAssignment_1() { return cTargetAssignment_1; } | ||
598 | |||
599 | //[Symbol|QualifiedName] | ||
600 | public CrossReference getTargetSymbolCrossReference_1_0() { return cTargetSymbolCrossReference_1_0; } | ||
601 | |||
602 | //QualifiedName | ||
603 | public RuleCall getTargetSymbolQualifiedNameParserRuleCall_1_0_1() { return cTargetSymbolQualifiedNameParserRuleCall_1_0_1; } | ||
604 | |||
605 | //FULL_STOP | ||
606 | public RuleCall getFULL_STOPTerminalRuleCall_2() { return cFULL_STOPTerminalRuleCall_2; } | ||
607 | } | ||
608 | public class ExternDeclarationElements extends AbstractParserRuleElementFinder { | ||
609 | private final ParserRule rule = (ParserRule) GrammarUtil.findRuleForName(getGrammar(), "org.eclipse.viatra.solver.language.SolverLanguage.ExternDeclaration"); | ||
610 | private final Alternatives cAlternatives = (Alternatives)rule.eContents().get(1); | ||
611 | private final RuleCall cExternPredicateDeclarationParserRuleCall_0 = (RuleCall)cAlternatives.eContents().get(0); | ||
612 | private final RuleCall cExternFunctionDeclarationParserRuleCall_1 = (RuleCall)cAlternatives.eContents().get(1); | ||
613 | private final RuleCall cExternAggregationOperatorDeclarationParserRuleCall_2 = (RuleCall)cAlternatives.eContents().get(2); | ||
614 | private final RuleCall cExternDatatypeDeclarationParserRuleCall_3 = (RuleCall)cAlternatives.eContents().get(3); | ||
615 | |||
616 | //ExternDeclaration: | ||
617 | // ExternPredicateDeclaration | ExternFunctionDeclaration | ExternAggregationOperatorDeclaration | | ||
618 | // ExternDatatypeDeclaration; | ||
619 | @Override public ParserRule getRule() { return rule; } | ||
620 | |||
621 | //ExternPredicateDeclaration | ExternFunctionDeclaration | ExternAggregationOperatorDeclaration | | ||
622 | //ExternDatatypeDeclaration | ||
623 | public Alternatives getAlternatives() { return cAlternatives; } | ||
624 | |||
625 | //ExternPredicateDeclaration | ||
626 | public RuleCall getExternPredicateDeclarationParserRuleCall_0() { return cExternPredicateDeclarationParserRuleCall_0; } | ||
627 | |||
628 | //ExternFunctionDeclaration | ||
629 | public RuleCall getExternFunctionDeclarationParserRuleCall_1() { return cExternFunctionDeclarationParserRuleCall_1; } | ||
630 | |||
631 | //ExternAggregationOperatorDeclaration | ||
632 | public RuleCall getExternAggregationOperatorDeclarationParserRuleCall_2() { return cExternAggregationOperatorDeclarationParserRuleCall_2; } | ||
633 | |||
634 | //ExternDatatypeDeclaration | ||
635 | public RuleCall getExternDatatypeDeclarationParserRuleCall_3() { return cExternDatatypeDeclarationParserRuleCall_3; } | ||
636 | } | ||
637 | public class ExternPredicateDeclarationElements extends AbstractParserRuleElementFinder { | ||
638 | private final ParserRule rule = (ParserRule) GrammarUtil.findRuleForName(getGrammar(), "org.eclipse.viatra.solver.language.SolverLanguage.ExternPredicateDeclaration"); | ||
639 | private final Group cGroup = (Group)rule.eContents().get(1); | ||
640 | private final Keyword cExternKeyword_0 = (Keyword)cGroup.eContents().get(0); | ||
641 | private final UnorderedGroup cUnorderedGroup_1 = (UnorderedGroup)cGroup.eContents().get(1); | ||
642 | private final Assignment cFunctionalAssignment_1_0 = (Assignment)cUnorderedGroup_1.eContents().get(0); | ||
643 | private final Keyword cFunctionalFunctionalKeyword_1_0_0 = (Keyword)cFunctionalAssignment_1_0.eContents().get(0); | ||
644 | private final Assignment cErrorAssignment_1_1 = (Assignment)cUnorderedGroup_1.eContents().get(1); | ||
645 | private final Keyword cErrorErrorKeyword_1_1_0 = (Keyword)cErrorAssignment_1_1.eContents().get(0); | ||
646 | private final Assignment cNameAssignment_2 = (Assignment)cGroup.eContents().get(2); | ||
647 | private final RuleCall cNameQualifiedNameParserRuleCall_2_0 = (RuleCall)cNameAssignment_2.eContents().get(0); | ||
648 | private final Assignment cArgumentListAssignment_3 = (Assignment)cGroup.eContents().get(3); | ||
649 | private final RuleCall cArgumentListArgumentListParserRuleCall_3_0 = (RuleCall)cArgumentListAssignment_3.eContents().get(0); | ||
650 | private final RuleCall cFULL_STOPTerminalRuleCall_4 = (RuleCall)cGroup.eContents().get(4); | ||
651 | |||
652 | //ExternPredicateDeclaration: | ||
653 | // "extern" (functional?="functional"? & error?="error"?) name=QualifiedName argumentList=ArgumentList FULL_STOP; | ||
654 | @Override public ParserRule getRule() { return rule; } | ||
655 | |||
656 | //"extern" (functional?="functional"? & error?="error"?) name=QualifiedName argumentList=ArgumentList FULL_STOP | ||
657 | public Group getGroup() { return cGroup; } | ||
658 | |||
659 | //"extern" | ||
660 | public Keyword getExternKeyword_0() { return cExternKeyword_0; } | ||
661 | |||
662 | //(functional?="functional"? & error?="error"?) | ||
663 | public UnorderedGroup getUnorderedGroup_1() { return cUnorderedGroup_1; } | ||
664 | |||
665 | //functional?="functional"? | ||
666 | public Assignment getFunctionalAssignment_1_0() { return cFunctionalAssignment_1_0; } | ||
667 | |||
668 | //"functional" | ||
669 | public Keyword getFunctionalFunctionalKeyword_1_0_0() { return cFunctionalFunctionalKeyword_1_0_0; } | ||
670 | |||
671 | //error?="error"? | ||
672 | public Assignment getErrorAssignment_1_1() { return cErrorAssignment_1_1; } | ||
673 | |||
674 | //"error" | ||
675 | public Keyword getErrorErrorKeyword_1_1_0() { return cErrorErrorKeyword_1_1_0; } | ||
676 | |||
677 | //name=QualifiedName | ||
678 | public Assignment getNameAssignment_2() { return cNameAssignment_2; } | ||
679 | |||
680 | //QualifiedName | ||
681 | public RuleCall getNameQualifiedNameParserRuleCall_2_0() { return cNameQualifiedNameParserRuleCall_2_0; } | ||
682 | |||
683 | //argumentList=ArgumentList | ||
684 | public Assignment getArgumentListAssignment_3() { return cArgumentListAssignment_3; } | ||
685 | |||
686 | //ArgumentList | ||
687 | public RuleCall getArgumentListArgumentListParserRuleCall_3_0() { return cArgumentListArgumentListParserRuleCall_3_0; } | ||
688 | |||
689 | //FULL_STOP | ||
690 | public RuleCall getFULL_STOPTerminalRuleCall_4() { return cFULL_STOPTerminalRuleCall_4; } | ||
691 | } | ||
692 | public class ExternFunctionDeclarationElements extends AbstractParserRuleElementFinder { | ||
693 | private final ParserRule rule = (ParserRule) GrammarUtil.findRuleForName(getGrammar(), "org.eclipse.viatra.solver.language.SolverLanguage.ExternFunctionDeclaration"); | ||
694 | private final Group cGroup = (Group)rule.eContents().get(1); | ||
695 | private final Keyword cExternKeyword_0 = (Keyword)cGroup.eContents().get(0); | ||
696 | private final Assignment cResultTypeAssignment_1 = (Assignment)cGroup.eContents().get(1); | ||
697 | private final CrossReference cResultTypeSymbolCrossReference_1_0 = (CrossReference)cResultTypeAssignment_1.eContents().get(0); | ||
698 | private final RuleCall cResultTypeSymbolQualifiedNameParserRuleCall_1_0_1 = (RuleCall)cResultTypeSymbolCrossReference_1_0.eContents().get(1); | ||
699 | private final Assignment cNameAssignment_2 = (Assignment)cGroup.eContents().get(2); | ||
700 | private final RuleCall cNameQualifiedNameParserRuleCall_2_0 = (RuleCall)cNameAssignment_2.eContents().get(0); | ||
701 | private final Assignment cArgumentListAssignment_3 = (Assignment)cGroup.eContents().get(3); | ||
702 | private final RuleCall cArgumentListArgumentListParserRuleCall_3_0 = (RuleCall)cArgumentListAssignment_3.eContents().get(0); | ||
703 | private final RuleCall cFULL_STOPTerminalRuleCall_4 = (RuleCall)cGroup.eContents().get(4); | ||
704 | |||
705 | //ExternFunctionDeclaration: | ||
706 | // "extern" resultType=[Symbol|QualifiedName] name=QualifiedName argumentList=ArgumentList FULL_STOP; | ||
707 | @Override public ParserRule getRule() { return rule; } | ||
708 | |||
709 | //"extern" resultType=[Symbol|QualifiedName] name=QualifiedName argumentList=ArgumentList FULL_STOP | ||
710 | public Group getGroup() { return cGroup; } | ||
711 | |||
712 | //"extern" | ||
713 | public Keyword getExternKeyword_0() { return cExternKeyword_0; } | ||
714 | |||
715 | //resultType=[Symbol|QualifiedName] | ||
716 | public Assignment getResultTypeAssignment_1() { return cResultTypeAssignment_1; } | ||
717 | |||
718 | //[Symbol|QualifiedName] | ||
719 | public CrossReference getResultTypeSymbolCrossReference_1_0() { return cResultTypeSymbolCrossReference_1_0; } | ||
720 | |||
721 | //QualifiedName | ||
722 | public RuleCall getResultTypeSymbolQualifiedNameParserRuleCall_1_0_1() { return cResultTypeSymbolQualifiedNameParserRuleCall_1_0_1; } | ||
723 | |||
724 | //name=QualifiedName | ||
725 | public Assignment getNameAssignment_2() { return cNameAssignment_2; } | ||
726 | |||
727 | //QualifiedName | ||
728 | public RuleCall getNameQualifiedNameParserRuleCall_2_0() { return cNameQualifiedNameParserRuleCall_2_0; } | ||
729 | |||
730 | //argumentList=ArgumentList | ||
731 | public Assignment getArgumentListAssignment_3() { return cArgumentListAssignment_3; } | ||
732 | |||
733 | //ArgumentList | ||
734 | public RuleCall getArgumentListArgumentListParserRuleCall_3_0() { return cArgumentListArgumentListParserRuleCall_3_0; } | ||
735 | |||
736 | //FULL_STOP | ||
737 | public RuleCall getFULL_STOPTerminalRuleCall_4() { return cFULL_STOPTerminalRuleCall_4; } | ||
738 | } | ||
739 | public class ExternAggregationOperatorDeclarationElements extends AbstractParserRuleElementFinder { | ||
740 | private final ParserRule rule = (ParserRule) GrammarUtil.findRuleForName(getGrammar(), "org.eclipse.viatra.solver.language.SolverLanguage.ExternAggregationOperatorDeclaration"); | ||
741 | private final Group cGroup = (Group)rule.eContents().get(1); | ||
742 | private final Keyword cExternKeyword_0 = (Keyword)cGroup.eContents().get(0); | ||
743 | private final Assignment cResultTypeAssignment_1 = (Assignment)cGroup.eContents().get(1); | ||
744 | private final CrossReference cResultTypeSymbolCrossReference_1_0 = (CrossReference)cResultTypeAssignment_1.eContents().get(0); | ||
745 | private final RuleCall cResultTypeSymbolQualifiedNameParserRuleCall_1_0_1 = (RuleCall)cResultTypeSymbolCrossReference_1_0.eContents().get(1); | ||
746 | private final Assignment cNameAssignment_2 = (Assignment)cGroup.eContents().get(2); | ||
747 | private final RuleCall cNameQualifiedNameParserRuleCall_2_0 = (RuleCall)cNameAssignment_2.eContents().get(0); | ||
748 | private final Keyword cLeftCurlyBracketKeyword_3 = (Keyword)cGroup.eContents().get(3); | ||
749 | private final Assignment cArgumentTypeAssignment_4 = (Assignment)cGroup.eContents().get(4); | ||
750 | private final CrossReference cArgumentTypeSymbolCrossReference_4_0 = (CrossReference)cArgumentTypeAssignment_4.eContents().get(0); | ||
751 | private final RuleCall cArgumentTypeSymbolQualifiedNameParserRuleCall_4_0_1 = (RuleCall)cArgumentTypeSymbolCrossReference_4_0.eContents().get(1); | ||
752 | private final Keyword cFullStopFullStopFullStopKeyword_5 = (Keyword)cGroup.eContents().get(5); | ||
753 | private final Keyword cRightCurlyBracketKeyword_6 = (Keyword)cGroup.eContents().get(6); | ||
754 | private final RuleCall cFULL_STOPTerminalRuleCall_7 = (RuleCall)cGroup.eContents().get(7); | ||
755 | |||
756 | //ExternAggregationOperatorDeclaration: | ||
757 | // "extern" resultType=[Symbol|QualifiedName] name=QualifiedName "{" argumentType=[Symbol|QualifiedName] "..." "}" | ||
758 | // FULL_STOP; | ||
759 | @Override public ParserRule getRule() { return rule; } | ||
760 | |||
761 | //"extern" resultType=[Symbol|QualifiedName] name=QualifiedName "{" argumentType=[Symbol|QualifiedName] "..." "}" | ||
762 | //FULL_STOP | ||
763 | public Group getGroup() { return cGroup; } | ||
764 | |||
765 | //"extern" | ||
766 | public Keyword getExternKeyword_0() { return cExternKeyword_0; } | ||
767 | |||
768 | //resultType=[Symbol|QualifiedName] | ||
769 | public Assignment getResultTypeAssignment_1() { return cResultTypeAssignment_1; } | ||
770 | |||
771 | //[Symbol|QualifiedName] | ||
772 | public CrossReference getResultTypeSymbolCrossReference_1_0() { return cResultTypeSymbolCrossReference_1_0; } | ||
773 | |||
774 | //QualifiedName | ||
775 | public RuleCall getResultTypeSymbolQualifiedNameParserRuleCall_1_0_1() { return cResultTypeSymbolQualifiedNameParserRuleCall_1_0_1; } | ||
776 | |||
777 | //name=QualifiedName | ||
778 | public Assignment getNameAssignment_2() { return cNameAssignment_2; } | ||
779 | |||
780 | //QualifiedName | ||
781 | public RuleCall getNameQualifiedNameParserRuleCall_2_0() { return cNameQualifiedNameParserRuleCall_2_0; } | ||
782 | |||
783 | //"{" | ||
784 | public Keyword getLeftCurlyBracketKeyword_3() { return cLeftCurlyBracketKeyword_3; } | ||
785 | |||
786 | //argumentType=[Symbol|QualifiedName] | ||
787 | public Assignment getArgumentTypeAssignment_4() { return cArgumentTypeAssignment_4; } | ||
788 | |||
789 | //[Symbol|QualifiedName] | ||
790 | public CrossReference getArgumentTypeSymbolCrossReference_4_0() { return cArgumentTypeSymbolCrossReference_4_0; } | ||
791 | |||
792 | //QualifiedName | ||
793 | public RuleCall getArgumentTypeSymbolQualifiedNameParserRuleCall_4_0_1() { return cArgumentTypeSymbolQualifiedNameParserRuleCall_4_0_1; } | ||
794 | |||
795 | //"..." | ||
796 | public Keyword getFullStopFullStopFullStopKeyword_5() { return cFullStopFullStopFullStopKeyword_5; } | ||
797 | |||
798 | //"}" | ||
799 | public Keyword getRightCurlyBracketKeyword_6() { return cRightCurlyBracketKeyword_6; } | ||
800 | |||
801 | //FULL_STOP | ||
802 | public RuleCall getFULL_STOPTerminalRuleCall_7() { return cFULL_STOPTerminalRuleCall_7; } | ||
803 | } | ||
804 | public class ExternDatatypeDeclarationElements extends AbstractParserRuleElementFinder { | ||
805 | private final ParserRule rule = (ParserRule) GrammarUtil.findRuleForName(getGrammar(), "org.eclipse.viatra.solver.language.SolverLanguage.ExternDatatypeDeclaration"); | ||
806 | private final Group cGroup = (Group)rule.eContents().get(1); | ||
807 | private final Keyword cExternKeyword_0 = (Keyword)cGroup.eContents().get(0); | ||
808 | private final Keyword cDatatypeKeyword_1 = (Keyword)cGroup.eContents().get(1); | ||
809 | private final Assignment cNameAssignment_2 = (Assignment)cGroup.eContents().get(2); | ||
810 | private final RuleCall cNameQualifiedNameParserRuleCall_2_0 = (RuleCall)cNameAssignment_2.eContents().get(0); | ||
811 | private final RuleCall cFULL_STOPTerminalRuleCall_3 = (RuleCall)cGroup.eContents().get(3); | ||
812 | |||
813 | //ExternDatatypeDeclaration: | ||
814 | // "extern" "datatype" name=QualifiedName FULL_STOP; | ||
815 | @Override public ParserRule getRule() { return rule; } | ||
816 | |||
817 | //"extern" "datatype" name=QualifiedName FULL_STOP | ||
818 | public Group getGroup() { return cGroup; } | ||
819 | |||
820 | //"extern" | ||
821 | public Keyword getExternKeyword_0() { return cExternKeyword_0; } | ||
822 | |||
823 | //"datatype" | ||
824 | public Keyword getDatatypeKeyword_1() { return cDatatypeKeyword_1; } | ||
825 | |||
826 | //name=QualifiedName | ||
827 | public Assignment getNameAssignment_2() { return cNameAssignment_2; } | ||
828 | |||
829 | //QualifiedName | ||
830 | public RuleCall getNameQualifiedNameParserRuleCall_2_0() { return cNameQualifiedNameParserRuleCall_2_0; } | ||
831 | |||
832 | //FULL_STOP | ||
833 | public RuleCall getFULL_STOPTerminalRuleCall_3() { return cFULL_STOPTerminalRuleCall_3; } | ||
834 | } | ||
835 | public class ExpressionElements extends AbstractParserRuleElementFinder { | ||
836 | private final ParserRule rule = (ParserRule) GrammarUtil.findRuleForName(getGrammar(), "org.eclipse.viatra.solver.language.SolverLanguage.Expression"); | ||
837 | private final Alternatives cAlternatives = (Alternatives)rule.eContents().get(1); | ||
838 | private final RuleCall cConditionalExpressionParserRuleCall_0 = (RuleCall)cAlternatives.eContents().get(0); | ||
839 | private final RuleCall cLetExpressionParserRuleCall_1 = (RuleCall)cAlternatives.eContents().get(1); | ||
840 | private final Group cGroup_2 = (Group)cAlternatives.eContents().get(2); | ||
841 | private final RuleCall cDisjunctiveExpressionParserRuleCall_2_0 = (RuleCall)cGroup_2.eContents().get(0); | ||
842 | private final Group cGroup_2_1 = (Group)cGroup_2.eContents().get(1); | ||
843 | private final Action cForallConditionAction_2_1_0 = (Action)cGroup_2_1.eContents().get(0); | ||
844 | private final Keyword cEqualsSignGreaterThanSignKeyword_2_1_1 = (Keyword)cGroup_2_1.eContents().get(1); | ||
845 | private final Assignment cBodyAssignment_2_1_2 = (Assignment)cGroup_2_1.eContents().get(2); | ||
846 | private final RuleCall cBodyDisjunctiveExpressionParserRuleCall_2_1_2_0 = (RuleCall)cBodyAssignment_2_1_2.eContents().get(0); | ||
847 | |||
848 | //Expression: | ||
849 | // ConditionalExpression | LetExpression | DisjunctiveExpression ({Forall.condition=current} "=>" | ||
850 | // body=DisjunctiveExpression)?; | ||
851 | @Override public ParserRule getRule() { return rule; } | ||
852 | |||
853 | //ConditionalExpression | LetExpression | DisjunctiveExpression ({Forall.condition=current} "=>" | ||
854 | //body=DisjunctiveExpression)? | ||
855 | public Alternatives getAlternatives() { return cAlternatives; } | ||
856 | |||
857 | //ConditionalExpression | ||
858 | public RuleCall getConditionalExpressionParserRuleCall_0() { return cConditionalExpressionParserRuleCall_0; } | ||
859 | |||
860 | //LetExpression | ||
861 | public RuleCall getLetExpressionParserRuleCall_1() { return cLetExpressionParserRuleCall_1; } | ||
862 | |||
863 | //DisjunctiveExpression ({Forall.condition=current} "=>" body=DisjunctiveExpression)? | ||
864 | public Group getGroup_2() { return cGroup_2; } | ||
865 | |||
866 | //DisjunctiveExpression | ||
867 | public RuleCall getDisjunctiveExpressionParserRuleCall_2_0() { return cDisjunctiveExpressionParserRuleCall_2_0; } | ||
868 | |||
869 | //({Forall.condition=current} "=>" body=DisjunctiveExpression)? | ||
870 | public Group getGroup_2_1() { return cGroup_2_1; } | ||
871 | |||
872 | //{Forall.condition=current} | ||
873 | public Action getForallConditionAction_2_1_0() { return cForallConditionAction_2_1_0; } | ||
874 | |||
875 | //"=>" | ||
876 | public Keyword getEqualsSignGreaterThanSignKeyword_2_1_1() { return cEqualsSignGreaterThanSignKeyword_2_1_1; } | ||
877 | |||
878 | //body=DisjunctiveExpression | ||
879 | public Assignment getBodyAssignment_2_1_2() { return cBodyAssignment_2_1_2; } | ||
880 | |||
881 | //DisjunctiveExpression | ||
882 | public RuleCall getBodyDisjunctiveExpressionParserRuleCall_2_1_2_0() { return cBodyDisjunctiveExpressionParserRuleCall_2_1_2_0; } | ||
883 | } | ||
884 | public class ConditionalExpressionElements extends AbstractParserRuleElementFinder { | ||
885 | private final ParserRule rule = (ParserRule) GrammarUtil.findRuleForName(getGrammar(), "org.eclipse.viatra.solver.language.SolverLanguage.ConditionalExpression"); | ||
886 | private final Group cGroup = (Group)rule.eContents().get(1); | ||
887 | private final Keyword cIfKeyword_0 = (Keyword)cGroup.eContents().get(0); | ||
888 | private final Assignment cConditionAssignment_1 = (Assignment)cGroup.eContents().get(1); | ||
889 | private final RuleCall cConditionDisjunctiveExpressionParserRuleCall_1_0 = (RuleCall)cConditionAssignment_1.eContents().get(0); | ||
890 | private final Keyword cThenKeyword_2 = (Keyword)cGroup.eContents().get(2); | ||
891 | private final Assignment cThenAssignment_3 = (Assignment)cGroup.eContents().get(3); | ||
892 | private final RuleCall cThenExpressionParserRuleCall_3_0 = (RuleCall)cThenAssignment_3.eContents().get(0); | ||
893 | private final Keyword cElseKeyword_4 = (Keyword)cGroup.eContents().get(4); | ||
894 | private final Assignment cElseAssignment_5 = (Assignment)cGroup.eContents().get(5); | ||
895 | private final RuleCall cElseExpressionParserRuleCall_5_0 = (RuleCall)cElseAssignment_5.eContents().get(0); | ||
896 | |||
897 | //ConditionalExpression: | ||
898 | // "if" condition=DisjunctiveExpression "then" then=Expression "else" else=Expression; | ||
899 | @Override public ParserRule getRule() { return rule; } | ||
900 | |||
901 | //"if" condition=DisjunctiveExpression "then" then=Expression "else" else=Expression | ||
902 | public Group getGroup() { return cGroup; } | ||
903 | |||
904 | //"if" | ||
905 | public Keyword getIfKeyword_0() { return cIfKeyword_0; } | ||
906 | |||
907 | //condition=DisjunctiveExpression | ||
908 | public Assignment getConditionAssignment_1() { return cConditionAssignment_1; } | ||
909 | |||
910 | //DisjunctiveExpression | ||
911 | public RuleCall getConditionDisjunctiveExpressionParserRuleCall_1_0() { return cConditionDisjunctiveExpressionParserRuleCall_1_0; } | ||
912 | |||
913 | //"then" | ||
914 | public Keyword getThenKeyword_2() { return cThenKeyword_2; } | ||
915 | |||
916 | //then=Expression | ||
917 | public Assignment getThenAssignment_3() { return cThenAssignment_3; } | ||
918 | |||
919 | //Expression | ||
920 | public RuleCall getThenExpressionParserRuleCall_3_0() { return cThenExpressionParserRuleCall_3_0; } | ||
921 | |||
922 | //"else" | ||
923 | public Keyword getElseKeyword_4() { return cElseKeyword_4; } | ||
924 | |||
925 | //else=Expression | ||
926 | public Assignment getElseAssignment_5() { return cElseAssignment_5; } | ||
927 | |||
928 | //Expression | ||
929 | public RuleCall getElseExpressionParserRuleCall_5_0() { return cElseExpressionParserRuleCall_5_0; } | ||
930 | } | ||
931 | public class LetExpressionElements extends AbstractParserRuleElementFinder { | ||
932 | private final ParserRule rule = (ParserRule) GrammarUtil.findRuleForName(getGrammar(), "org.eclipse.viatra.solver.language.SolverLanguage.LetExpression"); | ||
933 | private final Group cGroup = (Group)rule.eContents().get(1); | ||
934 | private final Keyword cLetKeyword_0 = (Keyword)cGroup.eContents().get(0); | ||
935 | private final Assignment cBindingsAssignment_1 = (Assignment)cGroup.eContents().get(1); | ||
936 | private final RuleCall cBindingsLetBindingParserRuleCall_1_0 = (RuleCall)cBindingsAssignment_1.eContents().get(0); | ||
937 | private final Group cGroup_2 = (Group)cGroup.eContents().get(2); | ||
938 | private final Keyword cCommaKeyword_2_0 = (Keyword)cGroup_2.eContents().get(0); | ||
939 | private final Assignment cBindingsAssignment_2_1 = (Assignment)cGroup_2.eContents().get(1); | ||
940 | private final RuleCall cBindingsLetBindingParserRuleCall_2_1_0 = (RuleCall)cBindingsAssignment_2_1.eContents().get(0); | ||
941 | private final Keyword cInKeyword_3 = (Keyword)cGroup.eContents().get(3); | ||
942 | private final Assignment cBodyAssignment_4 = (Assignment)cGroup.eContents().get(4); | ||
943 | private final RuleCall cBodyExpressionParserRuleCall_4_0 = (RuleCall)cBodyAssignment_4.eContents().get(0); | ||
944 | |||
945 | //LetExpression: | ||
946 | // "let" bindings+=LetBinding ("," bindings+=LetBinding)* "in" body=Expression; | ||
947 | @Override public ParserRule getRule() { return rule; } | ||
948 | |||
949 | //"let" bindings+=LetBinding ("," bindings+=LetBinding)* "in" body=Expression | ||
950 | public Group getGroup() { return cGroup; } | ||
951 | |||
952 | //"let" | ||
953 | public Keyword getLetKeyword_0() { return cLetKeyword_0; } | ||
954 | |||
955 | //bindings+=LetBinding | ||
956 | public Assignment getBindingsAssignment_1() { return cBindingsAssignment_1; } | ||
957 | |||
958 | //LetBinding | ||
959 | public RuleCall getBindingsLetBindingParserRuleCall_1_0() { return cBindingsLetBindingParserRuleCall_1_0; } | ||
960 | |||
961 | //("," bindings+=LetBinding)* | ||
962 | public Group getGroup_2() { return cGroup_2; } | ||
963 | |||
964 | //"," | ||
965 | public Keyword getCommaKeyword_2_0() { return cCommaKeyword_2_0; } | ||
966 | |||
967 | //bindings+=LetBinding | ||
968 | public Assignment getBindingsAssignment_2_1() { return cBindingsAssignment_2_1; } | ||
969 | |||
970 | //LetBinding | ||
971 | public RuleCall getBindingsLetBindingParserRuleCall_2_1_0() { return cBindingsLetBindingParserRuleCall_2_1_0; } | ||
972 | |||
973 | //"in" | ||
974 | public Keyword getInKeyword_3() { return cInKeyword_3; } | ||
975 | |||
976 | //body=Expression | ||
977 | public Assignment getBodyAssignment_4() { return cBodyAssignment_4; } | ||
978 | |||
979 | //Expression | ||
980 | public RuleCall getBodyExpressionParserRuleCall_4_0() { return cBodyExpressionParserRuleCall_4_0; } | ||
981 | } | ||
982 | public class LetBindingElements extends AbstractParserRuleElementFinder { | ||
983 | private final ParserRule rule = (ParserRule) GrammarUtil.findRuleForName(getGrammar(), "org.eclipse.viatra.solver.language.SolverLanguage.LetBinding"); | ||
984 | private final Group cGroup = (Group)rule.eContents().get(1); | ||
985 | private final Assignment cTypeAssignment_0 = (Assignment)cGroup.eContents().get(0); | ||
986 | private final CrossReference cTypeSymbolCrossReference_0_0 = (CrossReference)cTypeAssignment_0.eContents().get(0); | ||
987 | private final RuleCall cTypeSymbolQualifiedNameParserRuleCall_0_0_1 = (RuleCall)cTypeSymbolCrossReference_0_0.eContents().get(1); | ||
988 | private final Assignment cNameAssignment_1 = (Assignment)cGroup.eContents().get(1); | ||
989 | private final RuleCall cNameIDTerminalRuleCall_1_0 = (RuleCall)cNameAssignment_1.eContents().get(0); | ||
990 | private final Keyword cEqualsSignKeyword_2 = (Keyword)cGroup.eContents().get(2); | ||
991 | private final Assignment cValueAssignment_3 = (Assignment)cGroup.eContents().get(3); | ||
992 | private final RuleCall cValueAdditiveExpressionParserRuleCall_3_0 = (RuleCall)cValueAssignment_3.eContents().get(0); | ||
993 | |||
994 | //LetBinding: | ||
995 | // type=[Symbol|QualifiedName]? name=ID "=" value=AdditiveExpression; | ||
996 | @Override public ParserRule getRule() { return rule; } | ||
997 | |||
998 | //type=[Symbol|QualifiedName]? name=ID "=" value=AdditiveExpression | ||
999 | public Group getGroup() { return cGroup; } | ||
1000 | |||
1001 | //type=[Symbol|QualifiedName]? | ||
1002 | public Assignment getTypeAssignment_0() { return cTypeAssignment_0; } | ||
1003 | |||
1004 | //[Symbol|QualifiedName] | ||
1005 | public CrossReference getTypeSymbolCrossReference_0_0() { return cTypeSymbolCrossReference_0_0; } | ||
1006 | |||
1007 | //QualifiedName | ||
1008 | public RuleCall getTypeSymbolQualifiedNameParserRuleCall_0_0_1() { return cTypeSymbolQualifiedNameParserRuleCall_0_0_1; } | ||
1009 | |||
1010 | //name=ID | ||
1011 | public Assignment getNameAssignment_1() { return cNameAssignment_1; } | ||
1012 | |||
1013 | //ID | ||
1014 | public RuleCall getNameIDTerminalRuleCall_1_0() { return cNameIDTerminalRuleCall_1_0; } | ||
1015 | |||
1016 | //"=" | ||
1017 | public Keyword getEqualsSignKeyword_2() { return cEqualsSignKeyword_2; } | ||
1018 | |||
1019 | //value=AdditiveExpression | ||
1020 | public Assignment getValueAssignment_3() { return cValueAssignment_3; } | ||
1021 | |||
1022 | //AdditiveExpression | ||
1023 | public RuleCall getValueAdditiveExpressionParserRuleCall_3_0() { return cValueAdditiveExpressionParserRuleCall_3_0; } | ||
1024 | } | ||
1025 | public class DisjunctiveExpressionElements extends AbstractParserRuleElementFinder { | ||
1026 | private final ParserRule rule = (ParserRule) GrammarUtil.findRuleForName(getGrammar(), "org.eclipse.viatra.solver.language.SolverLanguage.DisjunctiveExpression"); | ||
1027 | private final Group cGroup = (Group)rule.eContents().get(1); | ||
1028 | private final RuleCall cConjunctiveExpressionParserRuleCall_0 = (RuleCall)cGroup.eContents().get(0); | ||
1029 | private final Alternatives cAlternatives_1 = (Alternatives)cGroup.eContents().get(1); | ||
1030 | private final Group cGroup_1_0 = (Group)cAlternatives_1.eContents().get(0); | ||
1031 | private final Action cDisjunctionChildrenAction_1_0_0 = (Action)cGroup_1_0.eContents().get(0); | ||
1032 | private final Group cGroup_1_0_1 = (Group)cGroup_1_0.eContents().get(1); | ||
1033 | private final Keyword cSemicolonKeyword_1_0_1_0 = (Keyword)cGroup_1_0_1.eContents().get(0); | ||
1034 | private final Assignment cChildrenAssignment_1_0_1_1 = (Assignment)cGroup_1_0_1.eContents().get(1); | ||
1035 | private final RuleCall cChildrenConjunctiveExpressionParserRuleCall_1_0_1_1_0 = (RuleCall)cChildrenAssignment_1_0_1_1.eContents().get(0); | ||
1036 | private final Group cGroup_1_1 = (Group)cAlternatives_1.eContents().get(1); | ||
1037 | private final Action cCaseConditionAction_1_1_0 = (Action)cGroup_1_1.eContents().get(0); | ||
1038 | private final Keyword cHyphenMinusGreaterThanSignKeyword_1_1_1 = (Keyword)cGroup_1_1.eContents().get(1); | ||
1039 | private final Assignment cBodyAssignment_1_1_2 = (Assignment)cGroup_1_1.eContents().get(2); | ||
1040 | private final RuleCall cBodyConjunctiveExpressionParserRuleCall_1_1_2_0 = (RuleCall)cBodyAssignment_1_1_2.eContents().get(0); | ||
1041 | private final Action cSwitchCasesAction_1_1_3 = (Action)cGroup_1_1.eContents().get(3); | ||
1042 | private final Group cGroup_1_1_4 = (Group)cGroup_1_1.eContents().get(4); | ||
1043 | private final Keyword cSemicolonKeyword_1_1_4_0 = (Keyword)cGroup_1_1_4.eContents().get(0); | ||
1044 | private final Assignment cCasesAssignment_1_1_4_1 = (Assignment)cGroup_1_1_4.eContents().get(1); | ||
1045 | private final RuleCall cCasesCaseParserRuleCall_1_1_4_1_0 = (RuleCall)cCasesAssignment_1_1_4_1.eContents().get(0); | ||
1046 | |||
1047 | //DisjunctiveExpression Expression: | ||
1048 | // ConjunctiveExpression ({Disjunction.children+=current} (";" children+=ConjunctiveExpression)+ | | ||
1049 | // {Case.condition=current} "->" body=ConjunctiveExpression {Switch.cases+=current} (";" cases+=Case)*)?; | ||
1050 | @Override public ParserRule getRule() { return rule; } | ||
1051 | |||
1052 | //ConjunctiveExpression ({Disjunction.children+=current} (";" children+=ConjunctiveExpression)+ | {Case.condition=current} | ||
1053 | //"->" body=ConjunctiveExpression {Switch.cases+=current} (";" cases+=Case)*)? | ||
1054 | public Group getGroup() { return cGroup; } | ||
1055 | |||
1056 | //ConjunctiveExpression | ||
1057 | public RuleCall getConjunctiveExpressionParserRuleCall_0() { return cConjunctiveExpressionParserRuleCall_0; } | ||
1058 | |||
1059 | //({Disjunction.children+=current} (";" children+=ConjunctiveExpression)+ | {Case.condition=current} "->" | ||
1060 | //body=ConjunctiveExpression {Switch.cases+=current} (";" cases+=Case)*)? | ||
1061 | public Alternatives getAlternatives_1() { return cAlternatives_1; } | ||
1062 | |||
1063 | //{Disjunction.children+=current} (";" children+=ConjunctiveExpression)+ | ||
1064 | public Group getGroup_1_0() { return cGroup_1_0; } | ||
1065 | |||
1066 | //{Disjunction.children+=current} | ||
1067 | public Action getDisjunctionChildrenAction_1_0_0() { return cDisjunctionChildrenAction_1_0_0; } | ||
1068 | |||
1069 | //(";" children+=ConjunctiveExpression)+ | ||
1070 | public Group getGroup_1_0_1() { return cGroup_1_0_1; } | ||
1071 | |||
1072 | //";" | ||
1073 | public Keyword getSemicolonKeyword_1_0_1_0() { return cSemicolonKeyword_1_0_1_0; } | ||
1074 | |||
1075 | //children+=ConjunctiveExpression | ||
1076 | public Assignment getChildrenAssignment_1_0_1_1() { return cChildrenAssignment_1_0_1_1; } | ||
1077 | |||
1078 | //ConjunctiveExpression | ||
1079 | public RuleCall getChildrenConjunctiveExpressionParserRuleCall_1_0_1_1_0() { return cChildrenConjunctiveExpressionParserRuleCall_1_0_1_1_0; } | ||
1080 | |||
1081 | //{Case.condition=current} "->" body=ConjunctiveExpression {Switch.cases+=current} (";" cases+=Case)* | ||
1082 | public Group getGroup_1_1() { return cGroup_1_1; } | ||
1083 | |||
1084 | //{Case.condition=current} | ||
1085 | public Action getCaseConditionAction_1_1_0() { return cCaseConditionAction_1_1_0; } | ||
1086 | |||
1087 | //"->" | ||
1088 | public Keyword getHyphenMinusGreaterThanSignKeyword_1_1_1() { return cHyphenMinusGreaterThanSignKeyword_1_1_1; } | ||
1089 | |||
1090 | //body=ConjunctiveExpression | ||
1091 | public Assignment getBodyAssignment_1_1_2() { return cBodyAssignment_1_1_2; } | ||
1092 | |||
1093 | //ConjunctiveExpression | ||
1094 | public RuleCall getBodyConjunctiveExpressionParserRuleCall_1_1_2_0() { return cBodyConjunctiveExpressionParserRuleCall_1_1_2_0; } | ||
1095 | |||
1096 | //{Switch.cases+=current} | ||
1097 | public Action getSwitchCasesAction_1_1_3() { return cSwitchCasesAction_1_1_3; } | ||
1098 | |||
1099 | //(";" cases+=Case)* | ||
1100 | public Group getGroup_1_1_4() { return cGroup_1_1_4; } | ||
1101 | |||
1102 | //";" | ||
1103 | public Keyword getSemicolonKeyword_1_1_4_0() { return cSemicolonKeyword_1_1_4_0; } | ||
1104 | |||
1105 | //cases+=Case | ||
1106 | public Assignment getCasesAssignment_1_1_4_1() { return cCasesAssignment_1_1_4_1; } | ||
1107 | |||
1108 | //Case | ||
1109 | public RuleCall getCasesCaseParserRuleCall_1_1_4_1_0() { return cCasesCaseParserRuleCall_1_1_4_1_0; } | ||
1110 | } | ||
1111 | public class CaseElements extends AbstractParserRuleElementFinder { | ||
1112 | private final ParserRule rule = (ParserRule) GrammarUtil.findRuleForName(getGrammar(), "org.eclipse.viatra.solver.language.SolverLanguage.Case"); | ||
1113 | private final Group cGroup = (Group)rule.eContents().get(1); | ||
1114 | private final Assignment cConditionAssignment_0 = (Assignment)cGroup.eContents().get(0); | ||
1115 | private final RuleCall cConditionConjunctiveExpressionParserRuleCall_0_0 = (RuleCall)cConditionAssignment_0.eContents().get(0); | ||
1116 | private final Keyword cHyphenMinusGreaterThanSignKeyword_1 = (Keyword)cGroup.eContents().get(1); | ||
1117 | private final Assignment cBodyAssignment_2 = (Assignment)cGroup.eContents().get(2); | ||
1118 | private final RuleCall cBodyConjunctiveExpressionParserRuleCall_2_0 = (RuleCall)cBodyAssignment_2.eContents().get(0); | ||
1119 | |||
1120 | //Case: | ||
1121 | // condition=ConjunctiveExpression "->" body=ConjunctiveExpression; | ||
1122 | @Override public ParserRule getRule() { return rule; } | ||
1123 | |||
1124 | //condition=ConjunctiveExpression "->" body=ConjunctiveExpression | ||
1125 | public Group getGroup() { return cGroup; } | ||
1126 | |||
1127 | //condition=ConjunctiveExpression | ||
1128 | public Assignment getConditionAssignment_0() { return cConditionAssignment_0; } | ||
1129 | |||
1130 | //ConjunctiveExpression | ||
1131 | public RuleCall getConditionConjunctiveExpressionParserRuleCall_0_0() { return cConditionConjunctiveExpressionParserRuleCall_0_0; } | ||
1132 | |||
1133 | //"->" | ||
1134 | public Keyword getHyphenMinusGreaterThanSignKeyword_1() { return cHyphenMinusGreaterThanSignKeyword_1; } | ||
1135 | |||
1136 | //body=ConjunctiveExpression | ||
1137 | public Assignment getBodyAssignment_2() { return cBodyAssignment_2; } | ||
1138 | |||
1139 | //ConjunctiveExpression | ||
1140 | public RuleCall getBodyConjunctiveExpressionParserRuleCall_2_0() { return cBodyConjunctiveExpressionParserRuleCall_2_0; } | ||
1141 | } | ||
1142 | public class ConjunctiveExpressionElements extends AbstractParserRuleElementFinder { | ||
1143 | private final ParserRule rule = (ParserRule) GrammarUtil.findRuleForName(getGrammar(), "org.eclipse.viatra.solver.language.SolverLanguage.ConjunctiveExpression"); | ||
1144 | private final Group cGroup = (Group)rule.eContents().get(1); | ||
1145 | private final RuleCall cComparisonExpressionParserRuleCall_0 = (RuleCall)cGroup.eContents().get(0); | ||
1146 | private final Group cGroup_1 = (Group)cGroup.eContents().get(1); | ||
1147 | private final Action cConjunctionChildrenAction_1_0 = (Action)cGroup_1.eContents().get(0); | ||
1148 | private final Group cGroup_1_1 = (Group)cGroup_1.eContents().get(1); | ||
1149 | private final Keyword cCommaKeyword_1_1_0 = (Keyword)cGroup_1_1.eContents().get(0); | ||
1150 | private final Assignment cChildrenAssignment_1_1_1 = (Assignment)cGroup_1_1.eContents().get(1); | ||
1151 | private final RuleCall cChildrenComparisonExpressionParserRuleCall_1_1_1_0 = (RuleCall)cChildrenAssignment_1_1_1.eContents().get(0); | ||
1152 | |||
1153 | //ConjunctiveExpression Expression: | ||
1154 | // ComparisonExpression ({Conjunction.children+=current} ("," children+=ComparisonExpression)+)?; | ||
1155 | @Override public ParserRule getRule() { return rule; } | ||
1156 | |||
1157 | //ComparisonExpression ({Conjunction.children+=current} ("," children+=ComparisonExpression)+)? | ||
1158 | public Group getGroup() { return cGroup; } | ||
1159 | |||
1160 | //ComparisonExpression | ||
1161 | public RuleCall getComparisonExpressionParserRuleCall_0() { return cComparisonExpressionParserRuleCall_0; } | ||
1162 | |||
1163 | //({Conjunction.children+=current} ("," children+=ComparisonExpression)+)? | ||
1164 | public Group getGroup_1() { return cGroup_1; } | ||
1165 | |||
1166 | //{Conjunction.children+=current} | ||
1167 | public Action getConjunctionChildrenAction_1_0() { return cConjunctionChildrenAction_1_0; } | ||
1168 | |||
1169 | //("," children+=ComparisonExpression)+ | ||
1170 | public Group getGroup_1_1() { return cGroup_1_1; } | ||
1171 | |||
1172 | //"," | ||
1173 | public Keyword getCommaKeyword_1_1_0() { return cCommaKeyword_1_1_0; } | ||
1174 | |||
1175 | //children+=ComparisonExpression | ||
1176 | public Assignment getChildrenAssignment_1_1_1() { return cChildrenAssignment_1_1_1; } | ||
1177 | |||
1178 | //ComparisonExpression | ||
1179 | public RuleCall getChildrenComparisonExpressionParserRuleCall_1_1_1_0() { return cChildrenComparisonExpressionParserRuleCall_1_1_1_0; } | ||
1180 | } | ||
1181 | public class ComparisonExpressionElements extends AbstractParserRuleElementFinder { | ||
1182 | private final ParserRule rule = (ParserRule) GrammarUtil.findRuleForName(getGrammar(), "org.eclipse.viatra.solver.language.SolverLanguage.ComparisonExpression"); | ||
1183 | private final Group cGroup = (Group)rule.eContents().get(1); | ||
1184 | private final RuleCall cAdditiveExpressionParserRuleCall_0 = (RuleCall)cGroup.eContents().get(0); | ||
1185 | private final Group cGroup_1 = (Group)cGroup.eContents().get(1); | ||
1186 | private final Action cBinaryExpressionLeftAction_1_0 = (Action)cGroup_1.eContents().get(0); | ||
1187 | private final Assignment cOpAssignment_1_1 = (Assignment)cGroup_1.eContents().get(1); | ||
1188 | private final RuleCall cOpComparisonOperatorEnumRuleCall_1_1_0 = (RuleCall)cOpAssignment_1_1.eContents().get(0); | ||
1189 | private final Assignment cRightAssignment_1_2 = (Assignment)cGroup_1.eContents().get(2); | ||
1190 | private final RuleCall cRightAdditiveExpressionParserRuleCall_1_2_0 = (RuleCall)cRightAssignment_1_2.eContents().get(0); | ||
1191 | |||
1192 | //ComparisonExpression Expression: | ||
1193 | // AdditiveExpression ({BinaryExpression.left=current} op=ComparisonOperator right=AdditiveExpression)?; | ||
1194 | @Override public ParserRule getRule() { return rule; } | ||
1195 | |||
1196 | //AdditiveExpression ({BinaryExpression.left=current} op=ComparisonOperator right=AdditiveExpression)? | ||
1197 | public Group getGroup() { return cGroup; } | ||
1198 | |||
1199 | //AdditiveExpression | ||
1200 | public RuleCall getAdditiveExpressionParserRuleCall_0() { return cAdditiveExpressionParserRuleCall_0; } | ||
1201 | |||
1202 | //({BinaryExpression.left=current} op=ComparisonOperator right=AdditiveExpression)? | ||
1203 | public Group getGroup_1() { return cGroup_1; } | ||
1204 | |||
1205 | //{BinaryExpression.left=current} | ||
1206 | public Action getBinaryExpressionLeftAction_1_0() { return cBinaryExpressionLeftAction_1_0; } | ||
1207 | |||
1208 | //op=ComparisonOperator | ||
1209 | public Assignment getOpAssignment_1_1() { return cOpAssignment_1_1; } | ||
1210 | |||
1211 | //ComparisonOperator | ||
1212 | public RuleCall getOpComparisonOperatorEnumRuleCall_1_1_0() { return cOpComparisonOperatorEnumRuleCall_1_1_0; } | ||
1213 | |||
1214 | //right=AdditiveExpression | ||
1215 | public Assignment getRightAssignment_1_2() { return cRightAssignment_1_2; } | ||
1216 | |||
1217 | //AdditiveExpression | ||
1218 | public RuleCall getRightAdditiveExpressionParserRuleCall_1_2_0() { return cRightAdditiveExpressionParserRuleCall_1_2_0; } | ||
1219 | } | ||
1220 | public class AdditiveExpressionElements extends AbstractParserRuleElementFinder { | ||
1221 | private final ParserRule rule = (ParserRule) GrammarUtil.findRuleForName(getGrammar(), "org.eclipse.viatra.solver.language.SolverLanguage.AdditiveExpression"); | ||
1222 | private final Group cGroup = (Group)rule.eContents().get(1); | ||
1223 | private final RuleCall cMultiplicativeExpressionParserRuleCall_0 = (RuleCall)cGroup.eContents().get(0); | ||
1224 | private final Group cGroup_1 = (Group)cGroup.eContents().get(1); | ||
1225 | private final Action cBinaryExpressionLeftAction_1_0 = (Action)cGroup_1.eContents().get(0); | ||
1226 | private final Assignment cOpAssignment_1_1 = (Assignment)cGroup_1.eContents().get(1); | ||
1227 | private final RuleCall cOpAdditiveBinaryOperatorEnumRuleCall_1_1_0 = (RuleCall)cOpAssignment_1_1.eContents().get(0); | ||
1228 | private final Assignment cRightAssignment_1_2 = (Assignment)cGroup_1.eContents().get(2); | ||
1229 | private final RuleCall cRightMultiplicativeExpressionParserRuleCall_1_2_0 = (RuleCall)cRightAssignment_1_2.eContents().get(0); | ||
1230 | |||
1231 | //AdditiveExpression Expression: | ||
1232 | // MultiplicativeExpression ({BinaryExpression.left=current} op=AdditiveBinaryOperator right=MultiplicativeExpression)*; | ||
1233 | @Override public ParserRule getRule() { return rule; } | ||
1234 | |||
1235 | //MultiplicativeExpression ({BinaryExpression.left=current} op=AdditiveBinaryOperator right=MultiplicativeExpression)* | ||
1236 | public Group getGroup() { return cGroup; } | ||
1237 | |||
1238 | //MultiplicativeExpression | ||
1239 | public RuleCall getMultiplicativeExpressionParserRuleCall_0() { return cMultiplicativeExpressionParserRuleCall_0; } | ||
1240 | |||
1241 | //({BinaryExpression.left=current} op=AdditiveBinaryOperator right=MultiplicativeExpression)* | ||
1242 | public Group getGroup_1() { return cGroup_1; } | ||
1243 | |||
1244 | //{BinaryExpression.left=current} | ||
1245 | public Action getBinaryExpressionLeftAction_1_0() { return cBinaryExpressionLeftAction_1_0; } | ||
1246 | |||
1247 | //op=AdditiveBinaryOperator | ||
1248 | public Assignment getOpAssignment_1_1() { return cOpAssignment_1_1; } | ||
1249 | |||
1250 | //AdditiveBinaryOperator | ||
1251 | public RuleCall getOpAdditiveBinaryOperatorEnumRuleCall_1_1_0() { return cOpAdditiveBinaryOperatorEnumRuleCall_1_1_0; } | ||
1252 | |||
1253 | //right=MultiplicativeExpression | ||
1254 | public Assignment getRightAssignment_1_2() { return cRightAssignment_1_2; } | ||
1255 | |||
1256 | //MultiplicativeExpression | ||
1257 | public RuleCall getRightMultiplicativeExpressionParserRuleCall_1_2_0() { return cRightMultiplicativeExpressionParserRuleCall_1_2_0; } | ||
1258 | } | ||
1259 | public class MultiplicativeExpressionElements extends AbstractParserRuleElementFinder { | ||
1260 | private final ParserRule rule = (ParserRule) GrammarUtil.findRuleForName(getGrammar(), "org.eclipse.viatra.solver.language.SolverLanguage.MultiplicativeExpression"); | ||
1261 | private final Group cGroup = (Group)rule.eContents().get(1); | ||
1262 | private final RuleCall cExponentialExpressionParserRuleCall_0 = (RuleCall)cGroup.eContents().get(0); | ||
1263 | private final Group cGroup_1 = (Group)cGroup.eContents().get(1); | ||
1264 | private final Action cBinaryExpressionLeftAction_1_0 = (Action)cGroup_1.eContents().get(0); | ||
1265 | private final Assignment cOpAssignment_1_1 = (Assignment)cGroup_1.eContents().get(1); | ||
1266 | private final RuleCall cOpMultiplicativeBinaryOperatorEnumRuleCall_1_1_0 = (RuleCall)cOpAssignment_1_1.eContents().get(0); | ||
1267 | private final Assignment cRightAssignment_1_2 = (Assignment)cGroup_1.eContents().get(2); | ||
1268 | private final RuleCall cRightExponentialExpressionParserRuleCall_1_2_0 = (RuleCall)cRightAssignment_1_2.eContents().get(0); | ||
1269 | |||
1270 | //MultiplicativeExpression Expression: | ||
1271 | // ExponentialExpression ({BinaryExpression.left=current} op=MultiplicativeBinaryOperator right=ExponentialExpression)*; | ||
1272 | @Override public ParserRule getRule() { return rule; } | ||
1273 | |||
1274 | //ExponentialExpression ({BinaryExpression.left=current} op=MultiplicativeBinaryOperator right=ExponentialExpression)* | ||
1275 | public Group getGroup() { return cGroup; } | ||
1276 | |||
1277 | //ExponentialExpression | ||
1278 | public RuleCall getExponentialExpressionParserRuleCall_0() { return cExponentialExpressionParserRuleCall_0; } | ||
1279 | |||
1280 | //({BinaryExpression.left=current} op=MultiplicativeBinaryOperator right=ExponentialExpression)* | ||
1281 | public Group getGroup_1() { return cGroup_1; } | ||
1282 | |||
1283 | //{BinaryExpression.left=current} | ||
1284 | public Action getBinaryExpressionLeftAction_1_0() { return cBinaryExpressionLeftAction_1_0; } | ||
1285 | |||
1286 | //op=MultiplicativeBinaryOperator | ||
1287 | public Assignment getOpAssignment_1_1() { return cOpAssignment_1_1; } | ||
1288 | |||
1289 | //MultiplicativeBinaryOperator | ||
1290 | public RuleCall getOpMultiplicativeBinaryOperatorEnumRuleCall_1_1_0() { return cOpMultiplicativeBinaryOperatorEnumRuleCall_1_1_0; } | ||
1291 | |||
1292 | //right=ExponentialExpression | ||
1293 | public Assignment getRightAssignment_1_2() { return cRightAssignment_1_2; } | ||
1294 | |||
1295 | //ExponentialExpression | ||
1296 | public RuleCall getRightExponentialExpressionParserRuleCall_1_2_0() { return cRightExponentialExpressionParserRuleCall_1_2_0; } | ||
1297 | } | ||
1298 | public class ExponentialExpressionElements extends AbstractParserRuleElementFinder { | ||
1299 | private final ParserRule rule = (ParserRule) GrammarUtil.findRuleForName(getGrammar(), "org.eclipse.viatra.solver.language.SolverLanguage.ExponentialExpression"); | ||
1300 | private final Group cGroup = (Group)rule.eContents().get(1); | ||
1301 | private final RuleCall cCastExpressionParserRuleCall_0 = (RuleCall)cGroup.eContents().get(0); | ||
1302 | private final Group cGroup_1 = (Group)cGroup.eContents().get(1); | ||
1303 | private final Action cBinaryExpressionLeftAction_1_0 = (Action)cGroup_1.eContents().get(0); | ||
1304 | private final Assignment cOpAssignment_1_1 = (Assignment)cGroup_1.eContents().get(1); | ||
1305 | private final RuleCall cOpExponentialOpEnumRuleCall_1_1_0 = (RuleCall)cOpAssignment_1_1.eContents().get(0); | ||
1306 | private final Assignment cRightAssignment_1_2 = (Assignment)cGroup_1.eContents().get(2); | ||
1307 | private final RuleCall cRightCastExpressionParserRuleCall_1_2_0 = (RuleCall)cRightAssignment_1_2.eContents().get(0); | ||
1308 | |||
1309 | //ExponentialExpression Expression: | ||
1310 | // CastExpression ({BinaryExpression.left=current} op=ExponentialOp right=CastExpression)?; | ||
1311 | @Override public ParserRule getRule() { return rule; } | ||
1312 | |||
1313 | //CastExpression ({BinaryExpression.left=current} op=ExponentialOp right=CastExpression)? | ||
1314 | public Group getGroup() { return cGroup; } | ||
1315 | |||
1316 | //CastExpression | ||
1317 | public RuleCall getCastExpressionParserRuleCall_0() { return cCastExpressionParserRuleCall_0; } | ||
1318 | |||
1319 | //({BinaryExpression.left=current} op=ExponentialOp right=CastExpression)? | ||
1320 | public Group getGroup_1() { return cGroup_1; } | ||
1321 | |||
1322 | //{BinaryExpression.left=current} | ||
1323 | public Action getBinaryExpressionLeftAction_1_0() { return cBinaryExpressionLeftAction_1_0; } | ||
1324 | |||
1325 | //op=ExponentialOp | ||
1326 | public Assignment getOpAssignment_1_1() { return cOpAssignment_1_1; } | ||
1327 | |||
1328 | //ExponentialOp | ||
1329 | public RuleCall getOpExponentialOpEnumRuleCall_1_1_0() { return cOpExponentialOpEnumRuleCall_1_1_0; } | ||
1330 | |||
1331 | //right=CastExpression | ||
1332 | public Assignment getRightAssignment_1_2() { return cRightAssignment_1_2; } | ||
1333 | |||
1334 | //CastExpression | ||
1335 | public RuleCall getRightCastExpressionParserRuleCall_1_2_0() { return cRightCastExpressionParserRuleCall_1_2_0; } | ||
1336 | } | ||
1337 | public class CastExpressionElements extends AbstractParserRuleElementFinder { | ||
1338 | private final ParserRule rule = (ParserRule) GrammarUtil.findRuleForName(getGrammar(), "org.eclipse.viatra.solver.language.SolverLanguage.CastExpression"); | ||
1339 | private final Group cGroup = (Group)rule.eContents().get(1); | ||
1340 | private final RuleCall cUnaryExpressionParserRuleCall_0 = (RuleCall)cGroup.eContents().get(0); | ||
1341 | private final Group cGroup_1 = (Group)cGroup.eContents().get(1); | ||
1342 | private final Action cCastExpressionBodyAction_1_0 = (Action)cGroup_1.eContents().get(0); | ||
1343 | private final Keyword cAsKeyword_1_1 = (Keyword)cGroup_1.eContents().get(1); | ||
1344 | private final Assignment cTargetTypeAssignment_1_2 = (Assignment)cGroup_1.eContents().get(2); | ||
1345 | private final CrossReference cTargetTypeSymbolCrossReference_1_2_0 = (CrossReference)cTargetTypeAssignment_1_2.eContents().get(0); | ||
1346 | private final RuleCall cTargetTypeSymbolQualifiedNameParserRuleCall_1_2_0_1 = (RuleCall)cTargetTypeSymbolCrossReference_1_2_0.eContents().get(1); | ||
1347 | |||
1348 | //CastExpression Expression: | ||
1349 | // UnaryExpression ({CastExpression.body=current} "as" targetType=[Symbol|QualifiedName])?; | ||
1350 | @Override public ParserRule getRule() { return rule; } | ||
1351 | |||
1352 | //UnaryExpression ({CastExpression.body=current} "as" targetType=[Symbol|QualifiedName])? | ||
1353 | public Group getGroup() { return cGroup; } | ||
1354 | |||
1355 | //UnaryExpression | ||
1356 | public RuleCall getUnaryExpressionParserRuleCall_0() { return cUnaryExpressionParserRuleCall_0; } | ||
1357 | |||
1358 | //({CastExpression.body=current} "as" targetType=[Symbol|QualifiedName])? | ||
1359 | public Group getGroup_1() { return cGroup_1; } | ||
1360 | |||
1361 | //{CastExpression.body=current} | ||
1362 | public Action getCastExpressionBodyAction_1_0() { return cCastExpressionBodyAction_1_0; } | ||
1363 | |||
1364 | //"as" | ||
1365 | public Keyword getAsKeyword_1_1() { return cAsKeyword_1_1; } | ||
1366 | |||
1367 | //targetType=[Symbol|QualifiedName] | ||
1368 | public Assignment getTargetTypeAssignment_1_2() { return cTargetTypeAssignment_1_2; } | ||
1369 | |||
1370 | //[Symbol|QualifiedName] | ||
1371 | public CrossReference getTargetTypeSymbolCrossReference_1_2_0() { return cTargetTypeSymbolCrossReference_1_2_0; } | ||
1372 | |||
1373 | //QualifiedName | ||
1374 | public RuleCall getTargetTypeSymbolQualifiedNameParserRuleCall_1_2_0_1() { return cTargetTypeSymbolQualifiedNameParserRuleCall_1_2_0_1; } | ||
1375 | } | ||
1376 | public class UnaryExpressionElements extends AbstractParserRuleElementFinder { | ||
1377 | private final ParserRule rule = (ParserRule) GrammarUtil.findRuleForName(getGrammar(), "org.eclipse.viatra.solver.language.SolverLanguage.UnaryExpression"); | ||
1378 | private final Alternatives cAlternatives = (Alternatives)rule.eContents().get(1); | ||
1379 | private final RuleCall cBracedAggregateExpressionParserRuleCall_0 = (RuleCall)cAlternatives.eContents().get(0); | ||
1380 | private final Group cGroup_1 = (Group)cAlternatives.eContents().get(1); | ||
1381 | private final Action cUnaryExpressionAction_1_0 = (Action)cGroup_1.eContents().get(0); | ||
1382 | private final Assignment cOpAssignment_1_1 = (Assignment)cGroup_1.eContents().get(1); | ||
1383 | private final RuleCall cOpUnaryOperatorEnumRuleCall_1_1_0 = (RuleCall)cOpAssignment_1_1.eContents().get(0); | ||
1384 | private final Assignment cBodyAssignment_1_2 = (Assignment)cGroup_1.eContents().get(2); | ||
1385 | private final RuleCall cBodyBracedAggregateExpressionParserRuleCall_1_2_0 = (RuleCall)cBodyAssignment_1_2.eContents().get(0); | ||
1386 | |||
1387 | //UnaryExpression Expression: | ||
1388 | // BracedAggregateExpression | {UnaryExpression} op=UnaryOperator body=BracedAggregateExpression; | ||
1389 | @Override public ParserRule getRule() { return rule; } | ||
1390 | |||
1391 | //BracedAggregateExpression | {UnaryExpression} op=UnaryOperator body=BracedAggregateExpression | ||
1392 | public Alternatives getAlternatives() { return cAlternatives; } | ||
1393 | |||
1394 | //BracedAggregateExpression | ||
1395 | public RuleCall getBracedAggregateExpressionParserRuleCall_0() { return cBracedAggregateExpressionParserRuleCall_0; } | ||
1396 | |||
1397 | //{UnaryExpression} op=UnaryOperator body=BracedAggregateExpression | ||
1398 | public Group getGroup_1() { return cGroup_1; } | ||
1399 | |||
1400 | //{UnaryExpression} | ||
1401 | public Action getUnaryExpressionAction_1_0() { return cUnaryExpressionAction_1_0; } | ||
1402 | |||
1403 | //op=UnaryOperator | ||
1404 | public Assignment getOpAssignment_1_1() { return cOpAssignment_1_1; } | ||
1405 | |||
1406 | //UnaryOperator | ||
1407 | public RuleCall getOpUnaryOperatorEnumRuleCall_1_1_0() { return cOpUnaryOperatorEnumRuleCall_1_1_0; } | ||
1408 | |||
1409 | //body=BracedAggregateExpression | ||
1410 | public Assignment getBodyAssignment_1_2() { return cBodyAssignment_1_2; } | ||
1411 | |||
1412 | //BracedAggregateExpression | ||
1413 | public RuleCall getBodyBracedAggregateExpressionParserRuleCall_1_2_0() { return cBodyBracedAggregateExpressionParserRuleCall_1_2_0; } | ||
1414 | } | ||
1415 | public class BracedAggregateExpressionElements extends AbstractParserRuleElementFinder { | ||
1416 | private final ParserRule rule = (ParserRule) GrammarUtil.findRuleForName(getGrammar(), "org.eclipse.viatra.solver.language.SolverLanguage.BracedAggregateExpression"); | ||
1417 | private final Alternatives cAlternatives = (Alternatives)rule.eContents().get(1); | ||
1418 | private final RuleCall cAtomicExpressionParserRuleCall_0 = (RuleCall)cAlternatives.eContents().get(0); | ||
1419 | private final RuleCall cAggregationParserRuleCall_1 = (RuleCall)cAlternatives.eContents().get(1); | ||
1420 | private final RuleCall cCountParserRuleCall_2 = (RuleCall)cAlternatives.eContents().get(2); | ||
1421 | |||
1422 | //BracedAggregateExpression Expression: | ||
1423 | // AtomicExpression | Aggregation | Count; | ||
1424 | @Override public ParserRule getRule() { return rule; } | ||
1425 | |||
1426 | //AtomicExpression | Aggregation | Count | ||
1427 | public Alternatives getAlternatives() { return cAlternatives; } | ||
1428 | |||
1429 | //AtomicExpression | ||
1430 | public RuleCall getAtomicExpressionParserRuleCall_0() { return cAtomicExpressionParserRuleCall_0; } | ||
1431 | |||
1432 | //Aggregation | ||
1433 | public RuleCall getAggregationParserRuleCall_1() { return cAggregationParserRuleCall_1; } | ||
1434 | |||
1435 | //Count | ||
1436 | public RuleCall getCountParserRuleCall_2() { return cCountParserRuleCall_2; } | ||
1437 | } | ||
1438 | public class AggregationElements extends AbstractParserRuleElementFinder { | ||
1439 | private final ParserRule rule = (ParserRule) GrammarUtil.findRuleForName(getGrammar(), "org.eclipse.viatra.solver.language.SolverLanguage.Aggregation"); | ||
1440 | private final Group cGroup = (Group)rule.eContents().get(1); | ||
1441 | private final Assignment cOpAssignment_0 = (Assignment)cGroup.eContents().get(0); | ||
1442 | private final CrossReference cOpSymbolCrossReference_0_0 = (CrossReference)cOpAssignment_0.eContents().get(0); | ||
1443 | private final RuleCall cOpSymbolQualifiedNameParserRuleCall_0_0_1 = (RuleCall)cOpSymbolCrossReference_0_0.eContents().get(1); | ||
1444 | private final Keyword cLeftCurlyBracketKeyword_1 = (Keyword)cGroup.eContents().get(1); | ||
1445 | private final Assignment cValueAssignment_2 = (Assignment)cGroup.eContents().get(2); | ||
1446 | private final RuleCall cValueExpressionParserRuleCall_2_0 = (RuleCall)cValueAssignment_2.eContents().get(0); | ||
1447 | private final Keyword cVerticalLineKeyword_3 = (Keyword)cGroup.eContents().get(3); | ||
1448 | private final Assignment cConditionAssignment_4 = (Assignment)cGroup.eContents().get(4); | ||
1449 | private final RuleCall cConditionExpressionParserRuleCall_4_0 = (RuleCall)cConditionAssignment_4.eContents().get(0); | ||
1450 | private final Keyword cRightCurlyBracketKeyword_5 = (Keyword)cGroup.eContents().get(5); | ||
1451 | |||
1452 | //Aggregation: | ||
1453 | // op=[Symbol|QualifiedName] "{" value=Expression "|" condition=Expression "}"; | ||
1454 | @Override public ParserRule getRule() { return rule; } | ||
1455 | |||
1456 | //op=[Symbol|QualifiedName] "{" value=Expression "|" condition=Expression "}" | ||
1457 | public Group getGroup() { return cGroup; } | ||
1458 | |||
1459 | //op=[Symbol|QualifiedName] | ||
1460 | public Assignment getOpAssignment_0() { return cOpAssignment_0; } | ||
1461 | |||
1462 | //[Symbol|QualifiedName] | ||
1463 | public CrossReference getOpSymbolCrossReference_0_0() { return cOpSymbolCrossReference_0_0; } | ||
1464 | |||
1465 | //QualifiedName | ||
1466 | public RuleCall getOpSymbolQualifiedNameParserRuleCall_0_0_1() { return cOpSymbolQualifiedNameParserRuleCall_0_0_1; } | ||
1467 | |||
1468 | //"{" | ||
1469 | public Keyword getLeftCurlyBracketKeyword_1() { return cLeftCurlyBracketKeyword_1; } | ||
1470 | |||
1471 | //value=Expression | ||
1472 | public Assignment getValueAssignment_2() { return cValueAssignment_2; } | ||
1473 | |||
1474 | //Expression | ||
1475 | public RuleCall getValueExpressionParserRuleCall_2_0() { return cValueExpressionParserRuleCall_2_0; } | ||
1476 | |||
1477 | //"|" | ||
1478 | public Keyword getVerticalLineKeyword_3() { return cVerticalLineKeyword_3; } | ||
1479 | |||
1480 | //condition=Expression | ||
1481 | public Assignment getConditionAssignment_4() { return cConditionAssignment_4; } | ||
1482 | |||
1483 | //Expression | ||
1484 | public RuleCall getConditionExpressionParserRuleCall_4_0() { return cConditionExpressionParserRuleCall_4_0; } | ||
1485 | |||
1486 | //"}" | ||
1487 | public Keyword getRightCurlyBracketKeyword_5() { return cRightCurlyBracketKeyword_5; } | ||
1488 | } | ||
1489 | public class CountElements extends AbstractParserRuleElementFinder { | ||
1490 | private final ParserRule rule = (ParserRule) GrammarUtil.findRuleForName(getGrammar(), "org.eclipse.viatra.solver.language.SolverLanguage.Count"); | ||
1491 | private final Group cGroup = (Group)rule.eContents().get(1); | ||
1492 | private final Keyword cCountKeyword_0 = (Keyword)cGroup.eContents().get(0); | ||
1493 | private final Keyword cLeftCurlyBracketKeyword_1 = (Keyword)cGroup.eContents().get(1); | ||
1494 | private final Assignment cConditionAssignment_2 = (Assignment)cGroup.eContents().get(2); | ||
1495 | private final RuleCall cConditionExpressionParserRuleCall_2_0 = (RuleCall)cConditionAssignment_2.eContents().get(0); | ||
1496 | private final Keyword cRightCurlyBracketKeyword_3 = (Keyword)cGroup.eContents().get(3); | ||
1497 | |||
1498 | //Count: | ||
1499 | // "count" "{" condition=Expression "}"; | ||
1500 | @Override public ParserRule getRule() { return rule; } | ||
1501 | |||
1502 | //"count" "{" condition=Expression "}" | ||
1503 | public Group getGroup() { return cGroup; } | ||
1504 | |||
1505 | //"count" | ||
1506 | public Keyword getCountKeyword_0() { return cCountKeyword_0; } | ||
1507 | |||
1508 | //"{" | ||
1509 | public Keyword getLeftCurlyBracketKeyword_1() { return cLeftCurlyBracketKeyword_1; } | ||
1510 | |||
1511 | //condition=Expression | ||
1512 | public Assignment getConditionAssignment_2() { return cConditionAssignment_2; } | ||
1513 | |||
1514 | //Expression | ||
1515 | public RuleCall getConditionExpressionParserRuleCall_2_0() { return cConditionExpressionParserRuleCall_2_0; } | ||
1516 | |||
1517 | //"}" | ||
1518 | public Keyword getRightCurlyBracketKeyword_3() { return cRightCurlyBracketKeyword_3; } | ||
1519 | } | ||
1520 | public class AtomicExpressionElements extends AbstractParserRuleElementFinder { | ||
1521 | private final ParserRule rule = (ParserRule) GrammarUtil.findRuleForName(getGrammar(), "org.eclipse.viatra.solver.language.SolverLanguage.AtomicExpression"); | ||
1522 | private final Alternatives cAlternatives = (Alternatives)rule.eContents().get(1); | ||
1523 | private final RuleCall cReferenceParserRuleCall_0 = (RuleCall)cAlternatives.eContents().get(0); | ||
1524 | private final RuleCall cCallParserRuleCall_1 = (RuleCall)cAlternatives.eContents().get(1); | ||
1525 | private final RuleCall cIntervalParserRuleCall_2 = (RuleCall)cAlternatives.eContents().get(2); | ||
1526 | private final RuleCall cLiteralParserRuleCall_3 = (RuleCall)cAlternatives.eContents().get(3); | ||
1527 | private final Group cGroup_4 = (Group)cAlternatives.eContents().get(4); | ||
1528 | private final Keyword cLeftParenthesisKeyword_4_0 = (Keyword)cGroup_4.eContents().get(0); | ||
1529 | private final RuleCall cExpressionParserRuleCall_4_1 = (RuleCall)cGroup_4.eContents().get(1); | ||
1530 | private final Keyword cRightParenthesisKeyword_4_2 = (Keyword)cGroup_4.eContents().get(2); | ||
1531 | |||
1532 | //AtomicExpression Expression: | ||
1533 | // Reference | Call | Interval | Literal | "(" Expression ")"; | ||
1534 | @Override public ParserRule getRule() { return rule; } | ||
1535 | |||
1536 | //Reference | Call | Interval | Literal | "(" Expression ")" | ||
1537 | public Alternatives getAlternatives() { return cAlternatives; } | ||
1538 | |||
1539 | //Reference | ||
1540 | public RuleCall getReferenceParserRuleCall_0() { return cReferenceParserRuleCall_0; } | ||
1541 | |||
1542 | //Call | ||
1543 | public RuleCall getCallParserRuleCall_1() { return cCallParserRuleCall_1; } | ||
1544 | |||
1545 | //Interval | ||
1546 | public RuleCall getIntervalParserRuleCall_2() { return cIntervalParserRuleCall_2; } | ||
1547 | |||
1548 | //Literal | ||
1549 | public RuleCall getLiteralParserRuleCall_3() { return cLiteralParserRuleCall_3; } | ||
1550 | |||
1551 | //"(" Expression ")" | ||
1552 | public Group getGroup_4() { return cGroup_4; } | ||
1553 | |||
1554 | //"(" | ||
1555 | public Keyword getLeftParenthesisKeyword_4_0() { return cLeftParenthesisKeyword_4_0; } | ||
1556 | |||
1557 | //Expression | ||
1558 | public RuleCall getExpressionParserRuleCall_4_1() { return cExpressionParserRuleCall_4_1; } | ||
1559 | |||
1560 | //")" | ||
1561 | public Keyword getRightParenthesisKeyword_4_2() { return cRightParenthesisKeyword_4_2; } | ||
1562 | } | ||
1563 | public class CallElements extends AbstractParserRuleElementFinder { | ||
1564 | private final ParserRule rule = (ParserRule) GrammarUtil.findRuleForName(getGrammar(), "org.eclipse.viatra.solver.language.SolverLanguage.Call"); | ||
1565 | private final Group cGroup = (Group)rule.eContents().get(1); | ||
1566 | private final Assignment cFunctorAssignment_0 = (Assignment)cGroup.eContents().get(0); | ||
1567 | private final RuleCall cFunctorReferenceParserRuleCall_0_0 = (RuleCall)cFunctorAssignment_0.eContents().get(0); | ||
1568 | private final Assignment cArgumentListAssignment_1 = (Assignment)cGroup.eContents().get(1); | ||
1569 | private final RuleCall cArgumentListArgumentListParserRuleCall_1_0 = (RuleCall)cArgumentListAssignment_1.eContents().get(0); | ||
1570 | |||
1571 | //Call: | ||
1572 | // functor=Reference argumentList=ArgumentList; | ||
1573 | @Override public ParserRule getRule() { return rule; } | ||
1574 | |||
1575 | //functor=Reference argumentList=ArgumentList | ||
1576 | public Group getGroup() { return cGroup; } | ||
1577 | |||
1578 | //functor=Reference | ||
1579 | public Assignment getFunctorAssignment_0() { return cFunctorAssignment_0; } | ||
1580 | |||
1581 | //Reference | ||
1582 | public RuleCall getFunctorReferenceParserRuleCall_0_0() { return cFunctorReferenceParserRuleCall_0_0; } | ||
1583 | |||
1584 | //argumentList=ArgumentList | ||
1585 | public Assignment getArgumentListAssignment_1() { return cArgumentListAssignment_1; } | ||
1586 | |||
1587 | //ArgumentList | ||
1588 | public RuleCall getArgumentListArgumentListParserRuleCall_1_0() { return cArgumentListArgumentListParserRuleCall_1_0; } | ||
1589 | } | ||
1590 | public class ArgumentListElements extends AbstractParserRuleElementFinder { | ||
1591 | private final ParserRule rule = (ParserRule) GrammarUtil.findRuleForName(getGrammar(), "org.eclipse.viatra.solver.language.SolverLanguage.ArgumentList"); | ||
1592 | private final Group cGroup = (Group)rule.eContents().get(1); | ||
1593 | private final Action cArgumentListAction_0 = (Action)cGroup.eContents().get(0); | ||
1594 | private final Keyword cLeftParenthesisKeyword_1 = (Keyword)cGroup.eContents().get(1); | ||
1595 | private final Group cGroup_2 = (Group)cGroup.eContents().get(2); | ||
1596 | private final Assignment cArgumentsAssignment_2_0 = (Assignment)cGroup_2.eContents().get(0); | ||
1597 | private final RuleCall cArgumentsArgumentParserRuleCall_2_0_0 = (RuleCall)cArgumentsAssignment_2_0.eContents().get(0); | ||
1598 | private final Group cGroup_2_1 = (Group)cGroup_2.eContents().get(1); | ||
1599 | private final Keyword cCommaKeyword_2_1_0 = (Keyword)cGroup_2_1.eContents().get(0); | ||
1600 | private final Assignment cArgumentsAssignment_2_1_1 = (Assignment)cGroup_2_1.eContents().get(1); | ||
1601 | private final RuleCall cArgumentsArgumentParserRuleCall_2_1_1_0 = (RuleCall)cArgumentsAssignment_2_1_1.eContents().get(0); | ||
1602 | private final Keyword cRightParenthesisKeyword_3 = (Keyword)cGroup.eContents().get(3); | ||
1603 | |||
1604 | //ArgumentList: | ||
1605 | // {ArgumentList} "(" (arguments+=Argument ("," arguments+=Argument)*)? ")"; | ||
1606 | @Override public ParserRule getRule() { return rule; } | ||
1607 | |||
1608 | //{ArgumentList} "(" (arguments+=Argument ("," arguments+=Argument)*)? ")" | ||
1609 | public Group getGroup() { return cGroup; } | ||
1610 | |||
1611 | //{ArgumentList} | ||
1612 | public Action getArgumentListAction_0() { return cArgumentListAction_0; } | ||
1613 | |||
1614 | //"(" | ||
1615 | public Keyword getLeftParenthesisKeyword_1() { return cLeftParenthesisKeyword_1; } | ||
1616 | |||
1617 | //(arguments+=Argument ("," arguments+=Argument)*)? | ||
1618 | public Group getGroup_2() { return cGroup_2; } | ||
1619 | |||
1620 | //arguments+=Argument | ||
1621 | public Assignment getArgumentsAssignment_2_0() { return cArgumentsAssignment_2_0; } | ||
1622 | |||
1623 | //Argument | ||
1624 | public RuleCall getArgumentsArgumentParserRuleCall_2_0_0() { return cArgumentsArgumentParserRuleCall_2_0_0; } | ||
1625 | |||
1626 | //("," arguments+=Argument)* | ||
1627 | public Group getGroup_2_1() { return cGroup_2_1; } | ||
1628 | |||
1629 | //"," | ||
1630 | public Keyword getCommaKeyword_2_1_0() { return cCommaKeyword_2_1_0; } | ||
1631 | |||
1632 | //arguments+=Argument | ||
1633 | public Assignment getArgumentsAssignment_2_1_1() { return cArgumentsAssignment_2_1_1; } | ||
1634 | |||
1635 | //Argument | ||
1636 | public RuleCall getArgumentsArgumentParserRuleCall_2_1_1_0() { return cArgumentsArgumentParserRuleCall_2_1_1_0; } | ||
1637 | |||
1638 | //")" | ||
1639 | public Keyword getRightParenthesisKeyword_3() { return cRightParenthesisKeyword_3; } | ||
1640 | } | ||
1641 | public class ArgumentElements extends AbstractParserRuleElementFinder { | ||
1642 | private final ParserRule rule = (ParserRule) GrammarUtil.findRuleForName(getGrammar(), "org.eclipse.viatra.solver.language.SolverLanguage.Argument"); | ||
1643 | private final Alternatives cAlternatives = (Alternatives)rule.eContents().get(1); | ||
1644 | private final RuleCall cExpressionArgumentParserRuleCall_0 = (RuleCall)cAlternatives.eContents().get(0); | ||
1645 | private final RuleCall cStarArgumentParserRuleCall_1 = (RuleCall)cAlternatives.eContents().get(1); | ||
1646 | private final RuleCall cTypedVariableArgumentParserRuleCall_2 = (RuleCall)cAlternatives.eContents().get(2); | ||
1647 | private final RuleCall cTypedStarArgumentParserRuleCall_3 = (RuleCall)cAlternatives.eContents().get(3); | ||
1648 | |||
1649 | //Argument: | ||
1650 | // ExpressionArgument | StarArgument | TypedVariableArgument | TypedStarArgument; | ||
1651 | @Override public ParserRule getRule() { return rule; } | ||
1652 | |||
1653 | //ExpressionArgument | StarArgument | TypedVariableArgument | TypedStarArgument | ||
1654 | public Alternatives getAlternatives() { return cAlternatives; } | ||
1655 | |||
1656 | //ExpressionArgument | ||
1657 | public RuleCall getExpressionArgumentParserRuleCall_0() { return cExpressionArgumentParserRuleCall_0; } | ||
1658 | |||
1659 | //StarArgument | ||
1660 | public RuleCall getStarArgumentParserRuleCall_1() { return cStarArgumentParserRuleCall_1; } | ||
1661 | |||
1662 | //TypedVariableArgument | ||
1663 | public RuleCall getTypedVariableArgumentParserRuleCall_2() { return cTypedVariableArgumentParserRuleCall_2; } | ||
1664 | |||
1665 | //TypedStarArgument | ||
1666 | public RuleCall getTypedStarArgumentParserRuleCall_3() { return cTypedStarArgumentParserRuleCall_3; } | ||
1667 | } | ||
1668 | public class ExpressionArgumentElements extends AbstractParserRuleElementFinder { | ||
1669 | private final ParserRule rule = (ParserRule) GrammarUtil.findRuleForName(getGrammar(), "org.eclipse.viatra.solver.language.SolverLanguage.ExpressionArgument"); | ||
1670 | private final Assignment cExpressionAssignment = (Assignment)rule.eContents().get(1); | ||
1671 | private final RuleCall cExpressionComparisonExpressionParserRuleCall_0 = (RuleCall)cExpressionAssignment.eContents().get(0); | ||
1672 | |||
1673 | //ExpressionArgument: | ||
1674 | // expression=ComparisonExpression; | ||
1675 | @Override public ParserRule getRule() { return rule; } | ||
1676 | |||
1677 | //expression=ComparisonExpression | ||
1678 | public Assignment getExpressionAssignment() { return cExpressionAssignment; } | ||
1679 | |||
1680 | //ComparisonExpression | ||
1681 | public RuleCall getExpressionComparisonExpressionParserRuleCall_0() { return cExpressionComparisonExpressionParserRuleCall_0; } | ||
1682 | } | ||
1683 | public class StarArgumentElements extends AbstractParserRuleElementFinder { | ||
1684 | private final ParserRule rule = (ParserRule) GrammarUtil.findRuleForName(getGrammar(), "org.eclipse.viatra.solver.language.SolverLanguage.StarArgument"); | ||
1685 | private final Group cGroup = (Group)rule.eContents().get(1); | ||
1686 | private final Action cStarArgumentAction_0 = (Action)cGroup.eContents().get(0); | ||
1687 | private final Keyword cAsteriskKeyword_1 = (Keyword)cGroup.eContents().get(1); | ||
1688 | |||
1689 | //StarArgument: | ||
1690 | // {StarArgument} "*"; | ||
1691 | @Override public ParserRule getRule() { return rule; } | ||
1692 | |||
1693 | //{StarArgument} "*" | ||
1694 | public Group getGroup() { return cGroup; } | ||
1695 | |||
1696 | //{StarArgument} | ||
1697 | public Action getStarArgumentAction_0() { return cStarArgumentAction_0; } | ||
1698 | |||
1699 | //"*" | ||
1700 | public Keyword getAsteriskKeyword_1() { return cAsteriskKeyword_1; } | ||
1701 | } | ||
1702 | public class TypedVariableArgumentElements extends AbstractParserRuleElementFinder { | ||
1703 | private final ParserRule rule = (ParserRule) GrammarUtil.findRuleForName(getGrammar(), "org.eclipse.viatra.solver.language.SolverLanguage.TypedVariableArgument"); | ||
1704 | private final Group cGroup = (Group)rule.eContents().get(1); | ||
1705 | private final Assignment cTypeReferenceAssignment_0 = (Assignment)cGroup.eContents().get(0); | ||
1706 | private final RuleCall cTypeReferenceTypeReferenceParserRuleCall_0_0 = (RuleCall)cTypeReferenceAssignment_0.eContents().get(0); | ||
1707 | private final Assignment cNameAssignment_1 = (Assignment)cGroup.eContents().get(1); | ||
1708 | private final RuleCall cNameIDTerminalRuleCall_1_0 = (RuleCall)cNameAssignment_1.eContents().get(0); | ||
1709 | |||
1710 | //TypedVariableArgument: | ||
1711 | // typeReference=TypeReference name=ID; | ||
1712 | @Override public ParserRule getRule() { return rule; } | ||
1713 | |||
1714 | //typeReference=TypeReference name=ID | ||
1715 | public Group getGroup() { return cGroup; } | ||
1716 | |||
1717 | //typeReference=TypeReference | ||
1718 | public Assignment getTypeReferenceAssignment_0() { return cTypeReferenceAssignment_0; } | ||
1719 | |||
1720 | //TypeReference | ||
1721 | public RuleCall getTypeReferenceTypeReferenceParserRuleCall_0_0() { return cTypeReferenceTypeReferenceParserRuleCall_0_0; } | ||
1722 | |||
1723 | //name=ID | ||
1724 | public Assignment getNameAssignment_1() { return cNameAssignment_1; } | ||
1725 | |||
1726 | //ID | ||
1727 | public RuleCall getNameIDTerminalRuleCall_1_0() { return cNameIDTerminalRuleCall_1_0; } | ||
1728 | } | ||
1729 | public class TypedStarArgumentElements extends AbstractParserRuleElementFinder { | ||
1730 | private final ParserRule rule = (ParserRule) GrammarUtil.findRuleForName(getGrammar(), "org.eclipse.viatra.solver.language.SolverLanguage.TypedStarArgument"); | ||
1731 | private final Group cGroup = (Group)rule.eContents().get(1); | ||
1732 | private final Assignment cTypeReferenceAssignment_0 = (Assignment)cGroup.eContents().get(0); | ||
1733 | private final RuleCall cTypeReferenceTypeReferenceParserRuleCall_0_0 = (RuleCall)cTypeReferenceAssignment_0.eContents().get(0); | ||
1734 | private final Keyword cAsteriskKeyword_1 = (Keyword)cGroup.eContents().get(1); | ||
1735 | |||
1736 | //TypedStarArgument: | ||
1737 | // typeReference=TypeReference "*"; | ||
1738 | @Override public ParserRule getRule() { return rule; } | ||
1739 | |||
1740 | //typeReference=TypeReference "*" | ||
1741 | public Group getGroup() { return cGroup; } | ||
1742 | |||
1743 | //typeReference=TypeReference | ||
1744 | public Assignment getTypeReferenceAssignment_0() { return cTypeReferenceAssignment_0; } | ||
1745 | |||
1746 | //TypeReference | ||
1747 | public RuleCall getTypeReferenceTypeReferenceParserRuleCall_0_0() { return cTypeReferenceTypeReferenceParserRuleCall_0_0; } | ||
1748 | |||
1749 | //"*" | ||
1750 | public Keyword getAsteriskKeyword_1() { return cAsteriskKeyword_1; } | ||
1751 | } | ||
1752 | public class ReferenceElements extends AbstractParserRuleElementFinder { | ||
1753 | private final ParserRule rule = (ParserRule) GrammarUtil.findRuleForName(getGrammar(), "org.eclipse.viatra.solver.language.SolverLanguage.Reference"); | ||
1754 | private final Group cGroup = (Group)rule.eContents().get(1); | ||
1755 | private final Assignment cComponentsAssignment_0 = (Assignment)cGroup.eContents().get(0); | ||
1756 | private final RuleCall cComponentsPathComponentParserRuleCall_0_0 = (RuleCall)cComponentsAssignment_0.eContents().get(0); | ||
1757 | private final Group cGroup_1 = (Group)cGroup.eContents().get(1); | ||
1758 | private final Keyword cFullStopKeyword_1_0 = (Keyword)cGroup_1.eContents().get(0); | ||
1759 | private final Assignment cComponentsAssignment_1_1 = (Assignment)cGroup_1.eContents().get(1); | ||
1760 | private final RuleCall cComponentsPathComponentParserRuleCall_1_1_0 = (RuleCall)cComponentsAssignment_1_1.eContents().get(0); | ||
1761 | |||
1762 | //Reference: | ||
1763 | // components+=PathComponent ("." components+=PathComponent)*; | ||
1764 | @Override public ParserRule getRule() { return rule; } | ||
1765 | |||
1766 | //components+=PathComponent ("." components+=PathComponent)* | ||
1767 | public Group getGroup() { return cGroup; } | ||
1768 | |||
1769 | //components+=PathComponent | ||
1770 | public Assignment getComponentsAssignment_0() { return cComponentsAssignment_0; } | ||
1771 | |||
1772 | //PathComponent | ||
1773 | public RuleCall getComponentsPathComponentParserRuleCall_0_0() { return cComponentsPathComponentParserRuleCall_0_0; } | ||
1774 | |||
1775 | //("." components+=PathComponent)* | ||
1776 | public Group getGroup_1() { return cGroup_1; } | ||
1777 | |||
1778 | //"." | ||
1779 | public Keyword getFullStopKeyword_1_0() { return cFullStopKeyword_1_0; } | ||
1780 | |||
1781 | //components+=PathComponent | ||
1782 | public Assignment getComponentsAssignment_1_1() { return cComponentsAssignment_1_1; } | ||
1783 | |||
1784 | //PathComponent | ||
1785 | public RuleCall getComponentsPathComponentParserRuleCall_1_1_0() { return cComponentsPathComponentParserRuleCall_1_1_0; } | ||
1786 | } | ||
1787 | public class PathComponentElements extends AbstractParserRuleElementFinder { | ||
1788 | private final ParserRule rule = (ParserRule) GrammarUtil.findRuleForName(getGrammar(), "org.eclipse.viatra.solver.language.SolverLanguage.PathComponent"); | ||
1789 | private final Group cGroup = (Group)rule.eContents().get(1); | ||
1790 | private final Assignment cInverseAssignment_0 = (Assignment)cGroup.eContents().get(0); | ||
1791 | private final Keyword cInverseTildeKeyword_0_0 = (Keyword)cInverseAssignment_0.eContents().get(0); | ||
1792 | private final Assignment cSymbolAssignment_1 = (Assignment)cGroup.eContents().get(1); | ||
1793 | private final CrossReference cSymbolSymbolCrossReference_1_0 = (CrossReference)cSymbolAssignment_1.eContents().get(0); | ||
1794 | private final RuleCall cSymbolSymbolQualifiedNameParserRuleCall_1_0_1 = (RuleCall)cSymbolSymbolCrossReference_1_0.eContents().get(1); | ||
1795 | private final Alternatives cAlternatives_2 = (Alternatives)cGroup.eContents().get(2); | ||
1796 | private final Assignment cTransitiveClosureAssignment_2_0 = (Assignment)cAlternatives_2.eContents().get(0); | ||
1797 | private final RuleCall cTransitiveClosureTRANSITIVE_CLOSURETerminalRuleCall_2_0_0 = (RuleCall)cTransitiveClosureAssignment_2_0.eContents().get(0); | ||
1798 | private final Assignment cReflexiveTransitiveClosureAssignment_2_1 = (Assignment)cAlternatives_2.eContents().get(1); | ||
1799 | private final RuleCall cReflexiveTransitiveClosureREFLEXIVE_TRANSITIVE_CLOSURETerminalRuleCall_2_1_0 = (RuleCall)cReflexiveTransitiveClosureAssignment_2_1.eContents().get(0); | ||
1800 | |||
1801 | //PathComponent: | ||
1802 | // inverse?="~"? symbol=[Symbol|QualifiedName] (transitiveClosure?=TRANSITIVE_CLOSURE | | ||
1803 | // reflexiveTransitiveClosure?=REFLEXIVE_TRANSITIVE_CLOSURE)?; | ||
1804 | @Override public ParserRule getRule() { return rule; } | ||
1805 | |||
1806 | //inverse?="~"? symbol=[Symbol|QualifiedName] (transitiveClosure?=TRANSITIVE_CLOSURE | | ||
1807 | //reflexiveTransitiveClosure?=REFLEXIVE_TRANSITIVE_CLOSURE)? | ||
1808 | public Group getGroup() { return cGroup; } | ||
1809 | |||
1810 | //inverse?="~"? | ||
1811 | public Assignment getInverseAssignment_0() { return cInverseAssignment_0; } | ||
1812 | |||
1813 | //"~" | ||
1814 | public Keyword getInverseTildeKeyword_0_0() { return cInverseTildeKeyword_0_0; } | ||
1815 | |||
1816 | //symbol=[Symbol|QualifiedName] | ||
1817 | public Assignment getSymbolAssignment_1() { return cSymbolAssignment_1; } | ||
1818 | |||
1819 | //[Symbol|QualifiedName] | ||
1820 | public CrossReference getSymbolSymbolCrossReference_1_0() { return cSymbolSymbolCrossReference_1_0; } | ||
1821 | |||
1822 | //QualifiedName | ||
1823 | public RuleCall getSymbolSymbolQualifiedNameParserRuleCall_1_0_1() { return cSymbolSymbolQualifiedNameParserRuleCall_1_0_1; } | ||
1824 | |||
1825 | //(transitiveClosure?=TRANSITIVE_CLOSURE | reflexiveTransitiveClosure?=REFLEXIVE_TRANSITIVE_CLOSURE)? | ||
1826 | public Alternatives getAlternatives_2() { return cAlternatives_2; } | ||
1827 | |||
1828 | //transitiveClosure?=TRANSITIVE_CLOSURE | ||
1829 | public Assignment getTransitiveClosureAssignment_2_0() { return cTransitiveClosureAssignment_2_0; } | ||
1830 | |||
1831 | //TRANSITIVE_CLOSURE | ||
1832 | public RuleCall getTransitiveClosureTRANSITIVE_CLOSURETerminalRuleCall_2_0_0() { return cTransitiveClosureTRANSITIVE_CLOSURETerminalRuleCall_2_0_0; } | ||
1833 | |||
1834 | //reflexiveTransitiveClosure?=REFLEXIVE_TRANSITIVE_CLOSURE | ||
1835 | public Assignment getReflexiveTransitiveClosureAssignment_2_1() { return cReflexiveTransitiveClosureAssignment_2_1; } | ||
1836 | |||
1837 | //REFLEXIVE_TRANSITIVE_CLOSURE | ||
1838 | public RuleCall getReflexiveTransitiveClosureREFLEXIVE_TRANSITIVE_CLOSURETerminalRuleCall_2_1_0() { return cReflexiveTransitiveClosureREFLEXIVE_TRANSITIVE_CLOSURETerminalRuleCall_2_1_0; } | ||
1839 | } | ||
1840 | public class IntervalElements extends AbstractParserRuleElementFinder { | ||
1841 | private final ParserRule rule = (ParserRule) GrammarUtil.findRuleForName(getGrammar(), "org.eclipse.viatra.solver.language.SolverLanguage.Interval"); | ||
1842 | private final Group cGroup = (Group)rule.eContents().get(1); | ||
1843 | private final Keyword cLeftSquareBracketKeyword_0 = (Keyword)cGroup.eContents().get(0); | ||
1844 | private final Assignment cLowerBoundAssignment_1 = (Assignment)cGroup.eContents().get(1); | ||
1845 | private final RuleCall cLowerBoundAdditiveExpressionParserRuleCall_1_0 = (RuleCall)cLowerBoundAssignment_1.eContents().get(0); | ||
1846 | private final Keyword cCommaKeyword_2 = (Keyword)cGroup.eContents().get(2); | ||
1847 | private final Assignment cUpperBoundAssignment_3 = (Assignment)cGroup.eContents().get(3); | ||
1848 | private final RuleCall cUpperBoundAdditiveExpressionParserRuleCall_3_0 = (RuleCall)cUpperBoundAssignment_3.eContents().get(0); | ||
1849 | private final Keyword cRightSquareBracketKeyword_4 = (Keyword)cGroup.eContents().get(4); | ||
1850 | |||
1851 | //Interval: | ||
1852 | // "[" lowerBound=AdditiveExpression "," upperBound=AdditiveExpression "]"; | ||
1853 | @Override public ParserRule getRule() { return rule; } | ||
1854 | |||
1855 | //"[" lowerBound=AdditiveExpression "," upperBound=AdditiveExpression "]" | ||
1856 | public Group getGroup() { return cGroup; } | ||
1857 | |||
1858 | //"[" | ||
1859 | public Keyword getLeftSquareBracketKeyword_0() { return cLeftSquareBracketKeyword_0; } | ||
1860 | |||
1861 | //lowerBound=AdditiveExpression | ||
1862 | public Assignment getLowerBoundAssignment_1() { return cLowerBoundAssignment_1; } | ||
1863 | |||
1864 | //AdditiveExpression | ||
1865 | public RuleCall getLowerBoundAdditiveExpressionParserRuleCall_1_0() { return cLowerBoundAdditiveExpressionParserRuleCall_1_0; } | ||
1866 | |||
1867 | //"," | ||
1868 | public Keyword getCommaKeyword_2() { return cCommaKeyword_2; } | ||
1869 | |||
1870 | //upperBound=AdditiveExpression | ||
1871 | public Assignment getUpperBoundAssignment_3() { return cUpperBoundAssignment_3; } | ||
1872 | |||
1873 | //AdditiveExpression | ||
1874 | public RuleCall getUpperBoundAdditiveExpressionParserRuleCall_3_0() { return cUpperBoundAdditiveExpressionParserRuleCall_3_0; } | ||
1875 | |||
1876 | //"]" | ||
1877 | public Keyword getRightSquareBracketKeyword_4() { return cRightSquareBracketKeyword_4; } | ||
1878 | } | ||
1879 | public class LiteralElements extends AbstractParserRuleElementFinder { | ||
1880 | private final ParserRule rule = (ParserRule) GrammarUtil.findRuleForName(getGrammar(), "org.eclipse.viatra.solver.language.SolverLanguage.Literal"); | ||
1881 | private final Alternatives cAlternatives = (Alternatives)rule.eContents().get(1); | ||
1882 | private final RuleCall cLogicLiteralParserRuleCall_0 = (RuleCall)cAlternatives.eContents().get(0); | ||
1883 | private final RuleCall cIntLiteralParserRuleCall_1 = (RuleCall)cAlternatives.eContents().get(1); | ||
1884 | private final RuleCall cRealLiteralParserRuleCall_2 = (RuleCall)cAlternatives.eContents().get(2); | ||
1885 | private final RuleCall cInfinityLiteralParserRuleCall_3 = (RuleCall)cAlternatives.eContents().get(3); | ||
1886 | private final RuleCall cEmptyLiteralParserRuleCall_4 = (RuleCall)cAlternatives.eContents().get(4); | ||
1887 | private final RuleCall cStringLiteralParserRuleCall_5 = (RuleCall)cAlternatives.eContents().get(5); | ||
1888 | |||
1889 | //Literal: | ||
1890 | // LogicLiteral | IntLiteral | RealLiteral | InfinityLiteral | EmptyLiteral | StringLiteral; | ||
1891 | @Override public ParserRule getRule() { return rule; } | ||
1892 | |||
1893 | //LogicLiteral | IntLiteral | RealLiteral | InfinityLiteral | EmptyLiteral | StringLiteral | ||
1894 | public Alternatives getAlternatives() { return cAlternatives; } | ||
1895 | |||
1896 | //LogicLiteral | ||
1897 | public RuleCall getLogicLiteralParserRuleCall_0() { return cLogicLiteralParserRuleCall_0; } | ||
1898 | |||
1899 | //IntLiteral | ||
1900 | public RuleCall getIntLiteralParserRuleCall_1() { return cIntLiteralParserRuleCall_1; } | ||
1901 | |||
1902 | //RealLiteral | ||
1903 | public RuleCall getRealLiteralParserRuleCall_2() { return cRealLiteralParserRuleCall_2; } | ||
1904 | |||
1905 | //InfinityLiteral | ||
1906 | public RuleCall getInfinityLiteralParserRuleCall_3() { return cInfinityLiteralParserRuleCall_3; } | ||
1907 | |||
1908 | //EmptyLiteral | ||
1909 | public RuleCall getEmptyLiteralParserRuleCall_4() { return cEmptyLiteralParserRuleCall_4; } | ||
1910 | |||
1911 | //StringLiteral | ||
1912 | public RuleCall getStringLiteralParserRuleCall_5() { return cStringLiteralParserRuleCall_5; } | ||
1913 | } | ||
1914 | public class LogicLiteralElements extends AbstractParserRuleElementFinder { | ||
1915 | private final ParserRule rule = (ParserRule) GrammarUtil.findRuleForName(getGrammar(), "org.eclipse.viatra.solver.language.SolverLanguage.LogicLiteral"); | ||
1916 | private final Assignment cValueAssignment = (Assignment)rule.eContents().get(1); | ||
1917 | private final RuleCall cValueLogicValueEnumRuleCall_0 = (RuleCall)cValueAssignment.eContents().get(0); | ||
1918 | |||
1919 | //LogicLiteral: | ||
1920 | // value=LogicValue; | ||
1921 | @Override public ParserRule getRule() { return rule; } | ||
1922 | |||
1923 | //value=LogicValue | ||
1924 | public Assignment getValueAssignment() { return cValueAssignment; } | ||
1925 | |||
1926 | //LogicValue | ||
1927 | public RuleCall getValueLogicValueEnumRuleCall_0() { return cValueLogicValueEnumRuleCall_0; } | ||
1928 | } | ||
1929 | public class IntLiteralElements extends AbstractParserRuleElementFinder { | ||
1930 | private final ParserRule rule = (ParserRule) GrammarUtil.findRuleForName(getGrammar(), "org.eclipse.viatra.solver.language.SolverLanguage.IntLiteral"); | ||
1931 | private final Assignment cValueAssignment = (Assignment)rule.eContents().get(1); | ||
1932 | private final RuleCall cValueINTTerminalRuleCall_0 = (RuleCall)cValueAssignment.eContents().get(0); | ||
1933 | |||
1934 | //IntLiteral: | ||
1935 | // value=INT; | ||
1936 | @Override public ParserRule getRule() { return rule; } | ||
1937 | |||
1938 | //value=INT | ||
1939 | public Assignment getValueAssignment() { return cValueAssignment; } | ||
1940 | |||
1941 | //INT | ||
1942 | public RuleCall getValueINTTerminalRuleCall_0() { return cValueINTTerminalRuleCall_0; } | ||
1943 | } | ||
1944 | public class RealLiteralElements extends AbstractParserRuleElementFinder { | ||
1945 | private final ParserRule rule = (ParserRule) GrammarUtil.findRuleForName(getGrammar(), "org.eclipse.viatra.solver.language.SolverLanguage.RealLiteral"); | ||
1946 | private final Assignment cValueAssignment = (Assignment)rule.eContents().get(1); | ||
1947 | private final RuleCall cValueRealParserRuleCall_0 = (RuleCall)cValueAssignment.eContents().get(0); | ||
1948 | |||
1949 | //RealLiteral: | ||
1950 | // value=Real; | ||
1951 | @Override public ParserRule getRule() { return rule; } | ||
1952 | |||
1953 | //value=Real | ||
1954 | public Assignment getValueAssignment() { return cValueAssignment; } | ||
1955 | |||
1956 | //Real | ||
1957 | public RuleCall getValueRealParserRuleCall_0() { return cValueRealParserRuleCall_0; } | ||
1958 | } | ||
1959 | public class InfinityLiteralElements extends AbstractParserRuleElementFinder { | ||
1960 | private final ParserRule rule = (ParserRule) GrammarUtil.findRuleForName(getGrammar(), "org.eclipse.viatra.solver.language.SolverLanguage.InfinityLiteral"); | ||
1961 | private final Group cGroup = (Group)rule.eContents().get(1); | ||
1962 | private final Action cInfinityLiteralAction_0 = (Action)cGroup.eContents().get(0); | ||
1963 | private final Keyword cInfKeyword_1 = (Keyword)cGroup.eContents().get(1); | ||
1964 | |||
1965 | //InfinityLiteral: | ||
1966 | // {InfinityLiteral} "inf"; | ||
1967 | @Override public ParserRule getRule() { return rule; } | ||
1968 | |||
1969 | //{InfinityLiteral} "inf" | ||
1970 | public Group getGroup() { return cGroup; } | ||
1971 | |||
1972 | //{InfinityLiteral} | ||
1973 | public Action getInfinityLiteralAction_0() { return cInfinityLiteralAction_0; } | ||
1974 | |||
1975 | //"inf" | ||
1976 | public Keyword getInfKeyword_1() { return cInfKeyword_1; } | ||
1977 | } | ||
1978 | public class EmptyLiteralElements extends AbstractParserRuleElementFinder { | ||
1979 | private final ParserRule rule = (ParserRule) GrammarUtil.findRuleForName(getGrammar(), "org.eclipse.viatra.solver.language.SolverLanguage.EmptyLiteral"); | ||
1980 | private final Group cGroup = (Group)rule.eContents().get(1); | ||
1981 | private final Action cEmptyLiteralAction_0 = (Action)cGroup.eContents().get(0); | ||
1982 | private final Keyword cEmptyKeyword_1 = (Keyword)cGroup.eContents().get(1); | ||
1983 | |||
1984 | //EmptyLiteral: | ||
1985 | // {EmptyLiteral} "empty"; | ||
1986 | @Override public ParserRule getRule() { return rule; } | ||
1987 | |||
1988 | //{EmptyLiteral} "empty" | ||
1989 | public Group getGroup() { return cGroup; } | ||
1990 | |||
1991 | //{EmptyLiteral} | ||
1992 | public Action getEmptyLiteralAction_0() { return cEmptyLiteralAction_0; } | ||
1993 | |||
1994 | //"empty" | ||
1995 | public Keyword getEmptyKeyword_1() { return cEmptyKeyword_1; } | ||
1996 | } | ||
1997 | public class StringLiteralElements extends AbstractParserRuleElementFinder { | ||
1998 | private final ParserRule rule = (ParserRule) GrammarUtil.findRuleForName(getGrammar(), "org.eclipse.viatra.solver.language.SolverLanguage.StringLiteral"); | ||
1999 | private final Assignment cValueAssignment = (Assignment)rule.eContents().get(1); | ||
2000 | private final RuleCall cValueSTRINGTerminalRuleCall_0 = (RuleCall)cValueAssignment.eContents().get(0); | ||
2001 | |||
2002 | //StringLiteral: | ||
2003 | // value=STRING; | ||
2004 | @Override public ParserRule getRule() { return rule; } | ||
2005 | |||
2006 | //value=STRING | ||
2007 | public Assignment getValueAssignment() { return cValueAssignment; } | ||
2008 | |||
2009 | //STRING | ||
2010 | public RuleCall getValueSTRINGTerminalRuleCall_0() { return cValueSTRINGTerminalRuleCall_0; } | ||
2011 | } | ||
2012 | public class ClassDeclarationElements extends AbstractParserRuleElementFinder { | ||
2013 | private final ParserRule rule = (ParserRule) GrammarUtil.findRuleForName(getGrammar(), "org.eclipse.viatra.solver.language.SolverLanguage.ClassDeclaration"); | ||
2014 | private final Group cGroup = (Group)rule.eContents().get(1); | ||
2015 | private final UnorderedGroup cUnorderedGroup_0 = (UnorderedGroup)cGroup.eContents().get(0); | ||
2016 | private final Assignment cAbstractAssignment_0_0 = (Assignment)cUnorderedGroup_0.eContents().get(0); | ||
2017 | private final Keyword cAbstractAbstractKeyword_0_0_0 = (Keyword)cAbstractAssignment_0_0.eContents().get(0); | ||
2018 | private final Assignment cRootAssignment_0_1 = (Assignment)cUnorderedGroup_0.eContents().get(1); | ||
2019 | private final Keyword cRootRootKeyword_0_1_0 = (Keyword)cRootAssignment_0_1.eContents().get(0); | ||
2020 | private final Keyword cClassKeyword_1 = (Keyword)cGroup.eContents().get(1); | ||
2021 | private final Assignment cNameAssignment_2 = (Assignment)cGroup.eContents().get(2); | ||
2022 | private final RuleCall cNameIDTerminalRuleCall_2_0 = (RuleCall)cNameAssignment_2.eContents().get(0); | ||
2023 | private final Group cGroup_3 = (Group)cGroup.eContents().get(3); | ||
2024 | private final Keyword cExtendsKeyword_3_0 = (Keyword)cGroup_3.eContents().get(0); | ||
2025 | private final Assignment cSupertypesAssignment_3_1 = (Assignment)cGroup_3.eContents().get(1); | ||
2026 | private final CrossReference cSupertypesSymbolCrossReference_3_1_0 = (CrossReference)cSupertypesAssignment_3_1.eContents().get(0); | ||
2027 | private final RuleCall cSupertypesSymbolQualifiedNameParserRuleCall_3_1_0_1 = (RuleCall)cSupertypesSymbolCrossReference_3_1_0.eContents().get(1); | ||
2028 | private final Group cGroup_3_2 = (Group)cGroup_3.eContents().get(2); | ||
2029 | private final Keyword cCommaKeyword_3_2_0 = (Keyword)cGroup_3_2.eContents().get(0); | ||
2030 | private final Assignment cSupertypesAssignment_3_2_1 = (Assignment)cGroup_3_2.eContents().get(1); | ||
2031 | private final CrossReference cSupertypesSymbolCrossReference_3_2_1_0 = (CrossReference)cSupertypesAssignment_3_2_1.eContents().get(0); | ||
2032 | private final RuleCall cSupertypesSymbolQualifiedNameParserRuleCall_3_2_1_0_1 = (RuleCall)cSupertypesSymbolCrossReference_3_2_1_0.eContents().get(1); | ||
2033 | private final Alternatives cAlternatives_4 = (Alternatives)cGroup.eContents().get(4); | ||
2034 | private final Group cGroup_4_0 = (Group)cAlternatives_4.eContents().get(0); | ||
2035 | private final Keyword cLeftCurlyBracketKeyword_4_0_0 = (Keyword)cGroup_4_0.eContents().get(0); | ||
2036 | private final Assignment cFieldsAssignment_4_0_1 = (Assignment)cGroup_4_0.eContents().get(1); | ||
2037 | private final RuleCall cFieldsFieldParserRuleCall_4_0_1_0 = (RuleCall)cFieldsAssignment_4_0_1.eContents().get(0); | ||
2038 | private final Keyword cRightCurlyBracketKeyword_4_0_2 = (Keyword)cGroup_4_0.eContents().get(2); | ||
2039 | private final RuleCall cFULL_STOPTerminalRuleCall_4_1 = (RuleCall)cAlternatives_4.eContents().get(1); | ||
2040 | |||
2041 | //ClassDeclaration: | ||
2042 | // (abstract?="abstract"? & root?="root"?) "class" name=ID ("extends" supertypes+=[Symbol|QualifiedName] ("," | ||
2043 | // supertypes+=[Symbol|QualifiedName])*)? ("{" fields+=Field* "}" | FULL_STOP); | ||
2044 | @Override public ParserRule getRule() { return rule; } | ||
2045 | |||
2046 | //(abstract?="abstract"? & root?="root"?) "class" name=ID ("extends" supertypes+=[Symbol|QualifiedName] ("," | ||
2047 | //supertypes+=[Symbol|QualifiedName])*)? ("{" fields+=Field* "}" | FULL_STOP) | ||
2048 | public Group getGroup() { return cGroup; } | ||
2049 | |||
2050 | //(abstract?="abstract"? & root?="root"?) | ||
2051 | public UnorderedGroup getUnorderedGroup_0() { return cUnorderedGroup_0; } | ||
2052 | |||
2053 | //abstract?="abstract"? | ||
2054 | public Assignment getAbstractAssignment_0_0() { return cAbstractAssignment_0_0; } | ||
2055 | |||
2056 | //"abstract" | ||
2057 | public Keyword getAbstractAbstractKeyword_0_0_0() { return cAbstractAbstractKeyword_0_0_0; } | ||
2058 | |||
2059 | //root?="root"? | ||
2060 | public Assignment getRootAssignment_0_1() { return cRootAssignment_0_1; } | ||
2061 | |||
2062 | //"root" | ||
2063 | public Keyword getRootRootKeyword_0_1_0() { return cRootRootKeyword_0_1_0; } | ||
2064 | |||
2065 | //"class" | ||
2066 | public Keyword getClassKeyword_1() { return cClassKeyword_1; } | ||
2067 | |||
2068 | //name=ID | ||
2069 | public Assignment getNameAssignment_2() { return cNameAssignment_2; } | ||
2070 | |||
2071 | //ID | ||
2072 | public RuleCall getNameIDTerminalRuleCall_2_0() { return cNameIDTerminalRuleCall_2_0; } | ||
2073 | |||
2074 | //("extends" supertypes+=[Symbol|QualifiedName] ("," supertypes+=[Symbol|QualifiedName])*)? | ||
2075 | public Group getGroup_3() { return cGroup_3; } | ||
2076 | |||
2077 | //"extends" | ||
2078 | public Keyword getExtendsKeyword_3_0() { return cExtendsKeyword_3_0; } | ||
2079 | |||
2080 | //supertypes+=[Symbol|QualifiedName] | ||
2081 | public Assignment getSupertypesAssignment_3_1() { return cSupertypesAssignment_3_1; } | ||
2082 | |||
2083 | //[Symbol|QualifiedName] | ||
2084 | public CrossReference getSupertypesSymbolCrossReference_3_1_0() { return cSupertypesSymbolCrossReference_3_1_0; } | ||
2085 | |||
2086 | //QualifiedName | ||
2087 | public RuleCall getSupertypesSymbolQualifiedNameParserRuleCall_3_1_0_1() { return cSupertypesSymbolQualifiedNameParserRuleCall_3_1_0_1; } | ||
2088 | |||
2089 | //("," supertypes+=[Symbol|QualifiedName])* | ||
2090 | public Group getGroup_3_2() { return cGroup_3_2; } | ||
2091 | |||
2092 | //"," | ||
2093 | public Keyword getCommaKeyword_3_2_0() { return cCommaKeyword_3_2_0; } | ||
2094 | |||
2095 | //supertypes+=[Symbol|QualifiedName] | ||
2096 | public Assignment getSupertypesAssignment_3_2_1() { return cSupertypesAssignment_3_2_1; } | ||
2097 | |||
2098 | //[Symbol|QualifiedName] | ||
2099 | public CrossReference getSupertypesSymbolCrossReference_3_2_1_0() { return cSupertypesSymbolCrossReference_3_2_1_0; } | ||
2100 | |||
2101 | //QualifiedName | ||
2102 | public RuleCall getSupertypesSymbolQualifiedNameParserRuleCall_3_2_1_0_1() { return cSupertypesSymbolQualifiedNameParserRuleCall_3_2_1_0_1; } | ||
2103 | |||
2104 | //("{" fields+=Field* "}" | FULL_STOP) | ||
2105 | public Alternatives getAlternatives_4() { return cAlternatives_4; } | ||
2106 | |||
2107 | //"{" fields+=Field* "}" | ||
2108 | public Group getGroup_4_0() { return cGroup_4_0; } | ||
2109 | |||
2110 | //"{" | ||
2111 | public Keyword getLeftCurlyBracketKeyword_4_0_0() { return cLeftCurlyBracketKeyword_4_0_0; } | ||
2112 | |||
2113 | //fields+=Field* | ||
2114 | public Assignment getFieldsAssignment_4_0_1() { return cFieldsAssignment_4_0_1; } | ||
2115 | |||
2116 | //Field | ||
2117 | public RuleCall getFieldsFieldParserRuleCall_4_0_1_0() { return cFieldsFieldParserRuleCall_4_0_1_0; } | ||
2118 | |||
2119 | //"}" | ||
2120 | public Keyword getRightCurlyBracketKeyword_4_0_2() { return cRightCurlyBracketKeyword_4_0_2; } | ||
2121 | |||
2122 | //FULL_STOP | ||
2123 | public RuleCall getFULL_STOPTerminalRuleCall_4_1() { return cFULL_STOPTerminalRuleCall_4_1; } | ||
2124 | } | ||
2125 | public class FieldElements extends AbstractParserRuleElementFinder { | ||
2126 | private final ParserRule rule = (ParserRule) GrammarUtil.findRuleForName(getGrammar(), "org.eclipse.viatra.solver.language.SolverLanguage.Field"); | ||
2127 | private final Group cGroup = (Group)rule.eContents().get(1); | ||
2128 | private final Alternatives cAlternatives_0 = (Alternatives)cGroup.eContents().get(0); | ||
2129 | private final Assignment cContainmentAssignment_0_0 = (Assignment)cAlternatives_0.eContents().get(0); | ||
2130 | private final Keyword cContainmentContainsKeyword_0_0_0 = (Keyword)cContainmentAssignment_0_0.eContents().get(0); | ||
2131 | private final Assignment cCrossReferenceAssignment_0_1 = (Assignment)cAlternatives_0.eContents().get(1); | ||
2132 | private final Keyword cCrossReferenceRefersKeyword_0_1_0 = (Keyword)cCrossReferenceAssignment_0_1.eContents().get(0); | ||
2133 | private final Assignment cTypeAssignment_1 = (Assignment)cGroup.eContents().get(1); | ||
2134 | private final CrossReference cTypeSymbolCrossReference_1_0 = (CrossReference)cTypeAssignment_1.eContents().get(0); | ||
2135 | private final RuleCall cTypeSymbolQualifiedNameParserRuleCall_1_0_1 = (RuleCall)cTypeSymbolCrossReference_1_0.eContents().get(1); | ||
2136 | private final Assignment cMultiplicityAssignment_2 = (Assignment)cGroup.eContents().get(2); | ||
2137 | private final RuleCall cMultiplicityMultiplicityParserRuleCall_2_0 = (RuleCall)cMultiplicityAssignment_2.eContents().get(0); | ||
2138 | private final Assignment cNameAssignment_3 = (Assignment)cGroup.eContents().get(3); | ||
2139 | private final RuleCall cNameIDTerminalRuleCall_3_0 = (RuleCall)cNameAssignment_3.eContents().get(0); | ||
2140 | private final Group cGroup_4 = (Group)cGroup.eContents().get(4); | ||
2141 | private final Keyword cOppositeKeyword_4_0 = (Keyword)cGroup_4.eContents().get(0); | ||
2142 | private final Assignment cOppositeAssignment_4_1 = (Assignment)cGroup_4.eContents().get(1); | ||
2143 | private final CrossReference cOppositeSymbolCrossReference_4_1_0 = (CrossReference)cOppositeAssignment_4_1.eContents().get(0); | ||
2144 | private final RuleCall cOppositeSymbolQualifiedNameParserRuleCall_4_1_0_1 = (RuleCall)cOppositeSymbolCrossReference_4_1_0.eContents().get(1); | ||
2145 | private final Keyword cSemicolonKeyword_5 = (Keyword)cGroup.eContents().get(5); | ||
2146 | |||
2147 | //Field: | ||
2148 | // (containment?="contains" | crossReference?="refers")? type=[Symbol|QualifiedName] multiplicity=Multiplicity? | ||
2149 | // name=ID ("opposite" opposite=[Symbol|QualifiedName])? ";"?; | ||
2150 | @Override public ParserRule getRule() { return rule; } | ||
2151 | |||
2152 | //(containment?="contains" | crossReference?="refers")? type=[Symbol|QualifiedName] multiplicity=Multiplicity? name=ID | ||
2153 | //("opposite" opposite=[Symbol|QualifiedName])? ";"? | ||
2154 | public Group getGroup() { return cGroup; } | ||
2155 | |||
2156 | //(containment?="contains" | crossReference?="refers")? | ||
2157 | public Alternatives getAlternatives_0() { return cAlternatives_0; } | ||
2158 | |||
2159 | //containment?="contains" | ||
2160 | public Assignment getContainmentAssignment_0_0() { return cContainmentAssignment_0_0; } | ||
2161 | |||
2162 | //"contains" | ||
2163 | public Keyword getContainmentContainsKeyword_0_0_0() { return cContainmentContainsKeyword_0_0_0; } | ||
2164 | |||
2165 | //crossReference?="refers" | ||
2166 | public Assignment getCrossReferenceAssignment_0_1() { return cCrossReferenceAssignment_0_1; } | ||
2167 | |||
2168 | //"refers" | ||
2169 | public Keyword getCrossReferenceRefersKeyword_0_1_0() { return cCrossReferenceRefersKeyword_0_1_0; } | ||
2170 | |||
2171 | //type=[Symbol|QualifiedName] | ||
2172 | public Assignment getTypeAssignment_1() { return cTypeAssignment_1; } | ||
2173 | |||
2174 | //[Symbol|QualifiedName] | ||
2175 | public CrossReference getTypeSymbolCrossReference_1_0() { return cTypeSymbolCrossReference_1_0; } | ||
2176 | |||
2177 | //QualifiedName | ||
2178 | public RuleCall getTypeSymbolQualifiedNameParserRuleCall_1_0_1() { return cTypeSymbolQualifiedNameParserRuleCall_1_0_1; } | ||
2179 | |||
2180 | //multiplicity=Multiplicity? | ||
2181 | public Assignment getMultiplicityAssignment_2() { return cMultiplicityAssignment_2; } | ||
2182 | |||
2183 | //Multiplicity | ||
2184 | public RuleCall getMultiplicityMultiplicityParserRuleCall_2_0() { return cMultiplicityMultiplicityParserRuleCall_2_0; } | ||
2185 | |||
2186 | //name=ID | ||
2187 | public Assignment getNameAssignment_3() { return cNameAssignment_3; } | ||
2188 | |||
2189 | //ID | ||
2190 | public RuleCall getNameIDTerminalRuleCall_3_0() { return cNameIDTerminalRuleCall_3_0; } | ||
2191 | |||
2192 | //("opposite" opposite=[Symbol|QualifiedName])? | ||
2193 | public Group getGroup_4() { return cGroup_4; } | ||
2194 | |||
2195 | //"opposite" | ||
2196 | public Keyword getOppositeKeyword_4_0() { return cOppositeKeyword_4_0; } | ||
2197 | |||
2198 | //opposite=[Symbol|QualifiedName] | ||
2199 | public Assignment getOppositeAssignment_4_1() { return cOppositeAssignment_4_1; } | ||
2200 | |||
2201 | //[Symbol|QualifiedName] | ||
2202 | public CrossReference getOppositeSymbolCrossReference_4_1_0() { return cOppositeSymbolCrossReference_4_1_0; } | ||
2203 | |||
2204 | //QualifiedName | ||
2205 | public RuleCall getOppositeSymbolQualifiedNameParserRuleCall_4_1_0_1() { return cOppositeSymbolQualifiedNameParserRuleCall_4_1_0_1; } | ||
2206 | |||
2207 | //";"? | ||
2208 | public Keyword getSemicolonKeyword_5() { return cSemicolonKeyword_5; } | ||
2209 | } | ||
2210 | public class MultiplicityElements extends AbstractParserRuleElementFinder { | ||
2211 | private final ParserRule rule = (ParserRule) GrammarUtil.findRuleForName(getGrammar(), "org.eclipse.viatra.solver.language.SolverLanguage.Multiplicity"); | ||
2212 | private final Alternatives cAlternatives = (Alternatives)rule.eContents().get(1); | ||
2213 | private final RuleCall cUnboundedMultiplicityParserRuleCall_0 = (RuleCall)cAlternatives.eContents().get(0); | ||
2214 | private final RuleCall cExactMultiplicityParserRuleCall_1 = (RuleCall)cAlternatives.eContents().get(1); | ||
2215 | private final RuleCall cBoundedMultiplicityParserRuleCall_2 = (RuleCall)cAlternatives.eContents().get(2); | ||
2216 | |||
2217 | //Multiplicity: | ||
2218 | // UnboundedMultiplicity | ExactMultiplicity | BoundedMultiplicity; | ||
2219 | @Override public ParserRule getRule() { return rule; } | ||
2220 | |||
2221 | //UnboundedMultiplicity | ExactMultiplicity | BoundedMultiplicity | ||
2222 | public Alternatives getAlternatives() { return cAlternatives; } | ||
2223 | |||
2224 | //UnboundedMultiplicity | ||
2225 | public RuleCall getUnboundedMultiplicityParserRuleCall_0() { return cUnboundedMultiplicityParserRuleCall_0; } | ||
2226 | |||
2227 | //ExactMultiplicity | ||
2228 | public RuleCall getExactMultiplicityParserRuleCall_1() { return cExactMultiplicityParserRuleCall_1; } | ||
2229 | |||
2230 | //BoundedMultiplicity | ||
2231 | public RuleCall getBoundedMultiplicityParserRuleCall_2() { return cBoundedMultiplicityParserRuleCall_2; } | ||
2232 | } | ||
2233 | public class UnboundedMultiplicityElements extends AbstractParserRuleElementFinder { | ||
2234 | private final ParserRule rule = (ParserRule) GrammarUtil.findRuleForName(getGrammar(), "org.eclipse.viatra.solver.language.SolverLanguage.UnboundedMultiplicity"); | ||
2235 | private final Group cGroup = (Group)rule.eContents().get(1); | ||
2236 | private final Action cUnboundedMultiplicityAction_0 = (Action)cGroup.eContents().get(0); | ||
2237 | private final Keyword cLeftSquareBracketKeyword_1 = (Keyword)cGroup.eContents().get(1); | ||
2238 | private final Keyword cRightSquareBracketKeyword_2 = (Keyword)cGroup.eContents().get(2); | ||
2239 | |||
2240 | //UnboundedMultiplicity: | ||
2241 | // {UnboundedMultiplicity} "[" "]"; | ||
2242 | @Override public ParserRule getRule() { return rule; } | ||
2243 | |||
2244 | //{UnboundedMultiplicity} "[" "]" | ||
2245 | public Group getGroup() { return cGroup; } | ||
2246 | |||
2247 | //{UnboundedMultiplicity} | ||
2248 | public Action getUnboundedMultiplicityAction_0() { return cUnboundedMultiplicityAction_0; } | ||
2249 | |||
2250 | //"[" | ||
2251 | public Keyword getLeftSquareBracketKeyword_1() { return cLeftSquareBracketKeyword_1; } | ||
2252 | |||
2253 | //"]" | ||
2254 | public Keyword getRightSquareBracketKeyword_2() { return cRightSquareBracketKeyword_2; } | ||
2255 | } | ||
2256 | public class ExactMultiplicityElements extends AbstractParserRuleElementFinder { | ||
2257 | private final ParserRule rule = (ParserRule) GrammarUtil.findRuleForName(getGrammar(), "org.eclipse.viatra.solver.language.SolverLanguage.ExactMultiplicity"); | ||
2258 | private final Group cGroup = (Group)rule.eContents().get(1); | ||
2259 | private final Keyword cLeftSquareBracketKeyword_0 = (Keyword)cGroup.eContents().get(0); | ||
2260 | private final Assignment cValueAssignment_1 = (Assignment)cGroup.eContents().get(1); | ||
2261 | private final RuleCall cValueUpperMultiplictyParserRuleCall_1_0 = (RuleCall)cValueAssignment_1.eContents().get(0); | ||
2262 | private final Keyword cRightSquareBracketKeyword_2 = (Keyword)cGroup.eContents().get(2); | ||
2263 | |||
2264 | //ExactMultiplicity: | ||
2265 | // "[" value=UpperMultiplicty "]"; | ||
2266 | @Override public ParserRule getRule() { return rule; } | ||
2267 | |||
2268 | //"[" value=UpperMultiplicty "]" | ||
2269 | public Group getGroup() { return cGroup; } | ||
2270 | |||
2271 | //"[" | ||
2272 | public Keyword getLeftSquareBracketKeyword_0() { return cLeftSquareBracketKeyword_0; } | ||
2273 | |||
2274 | //value=UpperMultiplicty | ||
2275 | public Assignment getValueAssignment_1() { return cValueAssignment_1; } | ||
2276 | |||
2277 | //UpperMultiplicty | ||
2278 | public RuleCall getValueUpperMultiplictyParserRuleCall_1_0() { return cValueUpperMultiplictyParserRuleCall_1_0; } | ||
2279 | |||
2280 | //"]" | ||
2281 | public Keyword getRightSquareBracketKeyword_2() { return cRightSquareBracketKeyword_2; } | ||
2282 | } | ||
2283 | public class BoundedMultiplicityElements extends AbstractParserRuleElementFinder { | ||
2284 | private final ParserRule rule = (ParserRule) GrammarUtil.findRuleForName(getGrammar(), "org.eclipse.viatra.solver.language.SolverLanguage.BoundedMultiplicity"); | ||
2285 | private final Group cGroup = (Group)rule.eContents().get(1); | ||
2286 | private final Keyword cLeftSquareBracketKeyword_0 = (Keyword)cGroup.eContents().get(0); | ||
2287 | private final Assignment cLowerBoundAssignment_1 = (Assignment)cGroup.eContents().get(1); | ||
2288 | private final RuleCall cLowerBoundINTTerminalRuleCall_1_0 = (RuleCall)cLowerBoundAssignment_1.eContents().get(0); | ||
2289 | private final Keyword cCommaKeyword_2 = (Keyword)cGroup.eContents().get(2); | ||
2290 | private final Assignment cUpperBoundAssignment_3 = (Assignment)cGroup.eContents().get(3); | ||
2291 | private final RuleCall cUpperBoundUpperMultiplictyParserRuleCall_3_0 = (RuleCall)cUpperBoundAssignment_3.eContents().get(0); | ||
2292 | private final Keyword cRightSquareBracketKeyword_4 = (Keyword)cGroup.eContents().get(4); | ||
2293 | |||
2294 | //BoundedMultiplicity: | ||
2295 | // "[" lowerBound=INT "," upperBound=UpperMultiplicty "]"; | ||
2296 | @Override public ParserRule getRule() { return rule; } | ||
2297 | |||
2298 | //"[" lowerBound=INT "," upperBound=UpperMultiplicty "]" | ||
2299 | public Group getGroup() { return cGroup; } | ||
2300 | |||
2301 | //"[" | ||
2302 | public Keyword getLeftSquareBracketKeyword_0() { return cLeftSquareBracketKeyword_0; } | ||
2303 | |||
2304 | //lowerBound=INT | ||
2305 | public Assignment getLowerBoundAssignment_1() { return cLowerBoundAssignment_1; } | ||
2306 | |||
2307 | //INT | ||
2308 | public RuleCall getLowerBoundINTTerminalRuleCall_1_0() { return cLowerBoundINTTerminalRuleCall_1_0; } | ||
2309 | |||
2310 | //"," | ||
2311 | public Keyword getCommaKeyword_2() { return cCommaKeyword_2; } | ||
2312 | |||
2313 | //upperBound=UpperMultiplicty | ||
2314 | public Assignment getUpperBoundAssignment_3() { return cUpperBoundAssignment_3; } | ||
2315 | |||
2316 | //UpperMultiplicty | ||
2317 | public RuleCall getUpperBoundUpperMultiplictyParserRuleCall_3_0() { return cUpperBoundUpperMultiplictyParserRuleCall_3_0; } | ||
2318 | |||
2319 | //"]" | ||
2320 | public Keyword getRightSquareBracketKeyword_4() { return cRightSquareBracketKeyword_4; } | ||
2321 | } | ||
2322 | public class EnumDeclarationElements extends AbstractParserRuleElementFinder { | ||
2323 | private final ParserRule rule = (ParserRule) GrammarUtil.findRuleForName(getGrammar(), "org.eclipse.viatra.solver.language.SolverLanguage.EnumDeclaration"); | ||
2324 | private final Group cGroup = (Group)rule.eContents().get(1); | ||
2325 | private final Keyword cEnumKeyword_0 = (Keyword)cGroup.eContents().get(0); | ||
2326 | private final Assignment cNameAssignment_1 = (Assignment)cGroup.eContents().get(1); | ||
2327 | private final RuleCall cNameIDTerminalRuleCall_1_0 = (RuleCall)cNameAssignment_1.eContents().get(0); | ||
2328 | private final Alternatives cAlternatives_2 = (Alternatives)cGroup.eContents().get(2); | ||
2329 | private final Group cGroup_2_0 = (Group)cAlternatives_2.eContents().get(0); | ||
2330 | private final Keyword cLeftCurlyBracketKeyword_2_0_0 = (Keyword)cGroup_2_0.eContents().get(0); | ||
2331 | private final Group cGroup_2_0_1 = (Group)cGroup_2_0.eContents().get(1); | ||
2332 | private final Assignment cLiteralsAssignment_2_0_1_0 = (Assignment)cGroup_2_0_1.eContents().get(0); | ||
2333 | private final RuleCall cLiteralsEnumLiteralParserRuleCall_2_0_1_0_0 = (RuleCall)cLiteralsAssignment_2_0_1_0.eContents().get(0); | ||
2334 | private final Group cGroup_2_0_1_1 = (Group)cGroup_2_0_1.eContents().get(1); | ||
2335 | private final Keyword cCommaKeyword_2_0_1_1_0 = (Keyword)cGroup_2_0_1_1.eContents().get(0); | ||
2336 | private final Assignment cLiteralsAssignment_2_0_1_1_1 = (Assignment)cGroup_2_0_1_1.eContents().get(1); | ||
2337 | private final RuleCall cLiteralsEnumLiteralParserRuleCall_2_0_1_1_1_0 = (RuleCall)cLiteralsAssignment_2_0_1_1_1.eContents().get(0); | ||
2338 | private final Keyword cRightCurlyBracketKeyword_2_0_2 = (Keyword)cGroup_2_0.eContents().get(2); | ||
2339 | private final RuleCall cFULL_STOPTerminalRuleCall_2_1 = (RuleCall)cAlternatives_2.eContents().get(1); | ||
2340 | |||
2341 | //EnumDeclaration: | ||
2342 | // "enum" name=ID ("{" (literals+=EnumLiteral (","? literals+=EnumLiteral)*)? "}" | FULL_STOP); | ||
2343 | @Override public ParserRule getRule() { return rule; } | ||
2344 | |||
2345 | //"enum" name=ID ("{" (literals+=EnumLiteral (","? literals+=EnumLiteral)*)? "}" | FULL_STOP) | ||
2346 | public Group getGroup() { return cGroup; } | ||
2347 | |||
2348 | //"enum" | ||
2349 | public Keyword getEnumKeyword_0() { return cEnumKeyword_0; } | ||
2350 | |||
2351 | //name=ID | ||
2352 | public Assignment getNameAssignment_1() { return cNameAssignment_1; } | ||
2353 | |||
2354 | //ID | ||
2355 | public RuleCall getNameIDTerminalRuleCall_1_0() { return cNameIDTerminalRuleCall_1_0; } | ||
2356 | |||
2357 | //("{" (literals+=EnumLiteral (","? literals+=EnumLiteral)*)? "}" | FULL_STOP) | ||
2358 | public Alternatives getAlternatives_2() { return cAlternatives_2; } | ||
2359 | |||
2360 | //"{" (literals+=EnumLiteral (","? literals+=EnumLiteral)*)? "}" | ||
2361 | public Group getGroup_2_0() { return cGroup_2_0; } | ||
2362 | |||
2363 | //"{" | ||
2364 | public Keyword getLeftCurlyBracketKeyword_2_0_0() { return cLeftCurlyBracketKeyword_2_0_0; } | ||
2365 | |||
2366 | //(literals+=EnumLiteral (","? literals+=EnumLiteral)*)? | ||
2367 | public Group getGroup_2_0_1() { return cGroup_2_0_1; } | ||
2368 | |||
2369 | //literals+=EnumLiteral | ||
2370 | public Assignment getLiteralsAssignment_2_0_1_0() { return cLiteralsAssignment_2_0_1_0; } | ||
2371 | |||
2372 | //EnumLiteral | ||
2373 | public RuleCall getLiteralsEnumLiteralParserRuleCall_2_0_1_0_0() { return cLiteralsEnumLiteralParserRuleCall_2_0_1_0_0; } | ||
2374 | |||
2375 | //(","? literals+=EnumLiteral)* | ||
2376 | public Group getGroup_2_0_1_1() { return cGroup_2_0_1_1; } | ||
2377 | |||
2378 | //","? | ||
2379 | public Keyword getCommaKeyword_2_0_1_1_0() { return cCommaKeyword_2_0_1_1_0; } | ||
2380 | |||
2381 | //literals+=EnumLiteral | ||
2382 | public Assignment getLiteralsAssignment_2_0_1_1_1() { return cLiteralsAssignment_2_0_1_1_1; } | ||
2383 | |||
2384 | //EnumLiteral | ||
2385 | public RuleCall getLiteralsEnumLiteralParserRuleCall_2_0_1_1_1_0() { return cLiteralsEnumLiteralParserRuleCall_2_0_1_1_1_0; } | ||
2386 | |||
2387 | //"}" | ||
2388 | public Keyword getRightCurlyBracketKeyword_2_0_2() { return cRightCurlyBracketKeyword_2_0_2; } | ||
2389 | |||
2390 | //FULL_STOP | ||
2391 | public RuleCall getFULL_STOPTerminalRuleCall_2_1() { return cFULL_STOPTerminalRuleCall_2_1; } | ||
2392 | } | ||
2393 | public class EnumLiteralElements extends AbstractParserRuleElementFinder { | ||
2394 | private final ParserRule rule = (ParserRule) GrammarUtil.findRuleForName(getGrammar(), "org.eclipse.viatra.solver.language.SolverLanguage.EnumLiteral"); | ||
2395 | private final Assignment cNameAssignment = (Assignment)rule.eContents().get(1); | ||
2396 | private final RuleCall cNameIDTerminalRuleCall_0 = (RuleCall)cNameAssignment.eContents().get(0); | ||
2397 | |||
2398 | //EnumLiteral: | ||
2399 | // name=ID; | ||
2400 | @Override public ParserRule getRule() { return rule; } | ||
2401 | |||
2402 | //name=ID | ||
2403 | public Assignment getNameAssignment() { return cNameAssignment; } | ||
2404 | |||
2405 | //ID | ||
2406 | public RuleCall getNameIDTerminalRuleCall_0() { return cNameIDTerminalRuleCall_0; } | ||
2407 | } | ||
2408 | public class ScopeDeclarationElements extends AbstractParserRuleElementFinder { | ||
2409 | private final ParserRule rule = (ParserRule) GrammarUtil.findRuleForName(getGrammar(), "org.eclipse.viatra.solver.language.SolverLanguage.ScopeDeclaration"); | ||
2410 | private final Alternatives cAlternatives = (Alternatives)rule.eContents().get(1); | ||
2411 | private final RuleCall cExactScopeParserRuleCall_0 = (RuleCall)cAlternatives.eContents().get(0); | ||
2412 | private final RuleCall cBoundedScopeParserRuleCall_1 = (RuleCall)cAlternatives.eContents().get(1); | ||
2413 | private final RuleCall cLowerBoundedScopeParserRuleCall_2 = (RuleCall)cAlternatives.eContents().get(2); | ||
2414 | |||
2415 | //ScopeDeclaration: | ||
2416 | // ExactScope | BoundedScope | LowerBoundedScope; | ||
2417 | @Override public ParserRule getRule() { return rule; } | ||
2418 | |||
2419 | //ExactScope | BoundedScope | LowerBoundedScope | ||
2420 | public Alternatives getAlternatives() { return cAlternatives; } | ||
2421 | |||
2422 | //ExactScope | ||
2423 | public RuleCall getExactScopeParserRuleCall_0() { return cExactScopeParserRuleCall_0; } | ||
2424 | |||
2425 | //BoundedScope | ||
2426 | public RuleCall getBoundedScopeParserRuleCall_1() { return cBoundedScopeParserRuleCall_1; } | ||
2427 | |||
2428 | //LowerBoundedScope | ||
2429 | public RuleCall getLowerBoundedScopeParserRuleCall_2() { return cLowerBoundedScopeParserRuleCall_2; } | ||
2430 | } | ||
2431 | public class ExactScopeElements extends AbstractParserRuleElementFinder { | ||
2432 | private final ParserRule rule = (ParserRule) GrammarUtil.findRuleForName(getGrammar(), "org.eclipse.viatra.solver.language.SolverLanguage.ExactScope"); | ||
2433 | private final Group cGroup = (Group)rule.eContents().get(1); | ||
2434 | private final Keyword cScopeKeyword_0 = (Keyword)cGroup.eContents().get(0); | ||
2435 | private final Assignment cTypeAssignment_1 = (Assignment)cGroup.eContents().get(1); | ||
2436 | private final CrossReference cTypeSymbolCrossReference_1_0 = (CrossReference)cTypeAssignment_1.eContents().get(0); | ||
2437 | private final RuleCall cTypeSymbolQualifiedNameParserRuleCall_1_0_1 = (RuleCall)cTypeSymbolCrossReference_1_0.eContents().get(1); | ||
2438 | private final Keyword cEqualsSignEqualsSignKeyword_2 = (Keyword)cGroup.eContents().get(2); | ||
2439 | private final Assignment cSizeAssignment_3 = (Assignment)cGroup.eContents().get(3); | ||
2440 | private final RuleCall cSizeINTTerminalRuleCall_3_0 = (RuleCall)cSizeAssignment_3.eContents().get(0); | ||
2441 | private final RuleCall cFULL_STOPTerminalRuleCall_4 = (RuleCall)cGroup.eContents().get(4); | ||
2442 | |||
2443 | //ExactScope: | ||
2444 | // "scope" type=[Symbol|QualifiedName] "==" size=INT FULL_STOP; | ||
2445 | @Override public ParserRule getRule() { return rule; } | ||
2446 | |||
2447 | //"scope" type=[Symbol|QualifiedName] "==" size=INT FULL_STOP | ||
2448 | public Group getGroup() { return cGroup; } | ||
2449 | |||
2450 | //"scope" | ||
2451 | public Keyword getScopeKeyword_0() { return cScopeKeyword_0; } | ||
2452 | |||
2453 | //type=[Symbol|QualifiedName] | ||
2454 | public Assignment getTypeAssignment_1() { return cTypeAssignment_1; } | ||
2455 | |||
2456 | //[Symbol|QualifiedName] | ||
2457 | public CrossReference getTypeSymbolCrossReference_1_0() { return cTypeSymbolCrossReference_1_0; } | ||
2458 | |||
2459 | //QualifiedName | ||
2460 | public RuleCall getTypeSymbolQualifiedNameParserRuleCall_1_0_1() { return cTypeSymbolQualifiedNameParserRuleCall_1_0_1; } | ||
2461 | |||
2462 | //"==" | ||
2463 | public Keyword getEqualsSignEqualsSignKeyword_2() { return cEqualsSignEqualsSignKeyword_2; } | ||
2464 | |||
2465 | //size=INT | ||
2466 | public Assignment getSizeAssignment_3() { return cSizeAssignment_3; } | ||
2467 | |||
2468 | //INT | ||
2469 | public RuleCall getSizeINTTerminalRuleCall_3_0() { return cSizeINTTerminalRuleCall_3_0; } | ||
2470 | |||
2471 | //FULL_STOP | ||
2472 | public RuleCall getFULL_STOPTerminalRuleCall_4() { return cFULL_STOPTerminalRuleCall_4; } | ||
2473 | } | ||
2474 | public class BoundedScopeElements extends AbstractParserRuleElementFinder { | ||
2475 | private final ParserRule rule = (ParserRule) GrammarUtil.findRuleForName(getGrammar(), "org.eclipse.viatra.solver.language.SolverLanguage.BoundedScope"); | ||
2476 | private final Group cGroup = (Group)rule.eContents().get(1); | ||
2477 | private final Keyword cScopeKeyword_0 = (Keyword)cGroup.eContents().get(0); | ||
2478 | private final Alternatives cAlternatives_1 = (Alternatives)cGroup.eContents().get(1); | ||
2479 | private final Group cGroup_1_0 = (Group)cAlternatives_1.eContents().get(0); | ||
2480 | private final Group cGroup_1_0_0 = (Group)cGroup_1_0.eContents().get(0); | ||
2481 | private final Assignment cLowerBoundAssignment_1_0_0_0 = (Assignment)cGroup_1_0_0.eContents().get(0); | ||
2482 | private final RuleCall cLowerBoundINTTerminalRuleCall_1_0_0_0_0 = (RuleCall)cLowerBoundAssignment_1_0_0_0.eContents().get(0); | ||
2483 | private final Keyword cLessThanSignEqualsSignKeyword_1_0_0_1 = (Keyword)cGroup_1_0_0.eContents().get(1); | ||
2484 | private final Assignment cTypeAssignment_1_0_1 = (Assignment)cGroup_1_0.eContents().get(1); | ||
2485 | private final CrossReference cTypeSymbolCrossReference_1_0_1_0 = (CrossReference)cTypeAssignment_1_0_1.eContents().get(0); | ||
2486 | private final RuleCall cTypeSymbolQualifiedNameParserRuleCall_1_0_1_0_1 = (RuleCall)cTypeSymbolCrossReference_1_0_1_0.eContents().get(1); | ||
2487 | private final Keyword cLessThanSignEqualsSignKeyword_1_0_2 = (Keyword)cGroup_1_0.eContents().get(2); | ||
2488 | private final Assignment cUpperBoundAssignment_1_0_3 = (Assignment)cGroup_1_0.eContents().get(3); | ||
2489 | private final RuleCall cUpperBoundINTTerminalRuleCall_1_0_3_0 = (RuleCall)cUpperBoundAssignment_1_0_3.eContents().get(0); | ||
2490 | private final Group cGroup_1_1 = (Group)cAlternatives_1.eContents().get(1); | ||
2491 | private final Assignment cUpperBoundAssignment_1_1_0 = (Assignment)cGroup_1_1.eContents().get(0); | ||
2492 | private final RuleCall cUpperBoundINTTerminalRuleCall_1_1_0_0 = (RuleCall)cUpperBoundAssignment_1_1_0.eContents().get(0); | ||
2493 | private final Keyword cGreaterThanSignEqualsSignKeyword_1_1_1 = (Keyword)cGroup_1_1.eContents().get(1); | ||
2494 | private final Assignment cTypeAssignment_1_1_2 = (Assignment)cGroup_1_1.eContents().get(2); | ||
2495 | private final CrossReference cTypeSymbolCrossReference_1_1_2_0 = (CrossReference)cTypeAssignment_1_1_2.eContents().get(0); | ||
2496 | private final RuleCall cTypeSymbolQualifiedNameParserRuleCall_1_1_2_0_1 = (RuleCall)cTypeSymbolCrossReference_1_1_2_0.eContents().get(1); | ||
2497 | private final Group cGroup_1_1_3 = (Group)cGroup_1_1.eContents().get(3); | ||
2498 | private final Keyword cGreaterThanSignEqualsSignKeyword_1_1_3_0 = (Keyword)cGroup_1_1_3.eContents().get(0); | ||
2499 | private final Assignment cLowerBoundAssignment_1_1_3_1 = (Assignment)cGroup_1_1_3.eContents().get(1); | ||
2500 | private final RuleCall cLowerBoundINTTerminalRuleCall_1_1_3_1_0 = (RuleCall)cLowerBoundAssignment_1_1_3_1.eContents().get(0); | ||
2501 | private final RuleCall cFULL_STOPTerminalRuleCall_2 = (RuleCall)cGroup.eContents().get(2); | ||
2502 | |||
2503 | //BoundedScope: | ||
2504 | // "scope" ((lowerBound=INT "<=")? type=[Symbol|QualifiedName] "<=" upperBound=INT | upperBound=INT ">=" | ||
2505 | // type=[Symbol|QualifiedName] (">=" lowerBound=INT)?) FULL_STOP; | ||
2506 | @Override public ParserRule getRule() { return rule; } | ||
2507 | |||
2508 | //"scope" ((lowerBound=INT "<=")? type=[Symbol|QualifiedName] "<=" upperBound=INT | upperBound=INT ">=" | ||
2509 | //type=[Symbol|QualifiedName] (">=" lowerBound=INT)?) FULL_STOP | ||
2510 | public Group getGroup() { return cGroup; } | ||
2511 | |||
2512 | //"scope" | ||
2513 | public Keyword getScopeKeyword_0() { return cScopeKeyword_0; } | ||
2514 | |||
2515 | //((lowerBound=INT "<=")? type=[Symbol|QualifiedName] "<=" upperBound=INT | upperBound=INT ">=" | ||
2516 | //type=[Symbol|QualifiedName] (">=" lowerBound=INT)?) | ||
2517 | public Alternatives getAlternatives_1() { return cAlternatives_1; } | ||
2518 | |||
2519 | //(lowerBound=INT "<=")? type=[Symbol|QualifiedName] "<=" upperBound=INT | ||
2520 | public Group getGroup_1_0() { return cGroup_1_0; } | ||
2521 | |||
2522 | //(lowerBound=INT "<=")? | ||
2523 | public Group getGroup_1_0_0() { return cGroup_1_0_0; } | ||
2524 | |||
2525 | //lowerBound=INT | ||
2526 | public Assignment getLowerBoundAssignment_1_0_0_0() { return cLowerBoundAssignment_1_0_0_0; } | ||
2527 | |||
2528 | //INT | ||
2529 | public RuleCall getLowerBoundINTTerminalRuleCall_1_0_0_0_0() { return cLowerBoundINTTerminalRuleCall_1_0_0_0_0; } | ||
2530 | |||
2531 | //"<=" | ||
2532 | public Keyword getLessThanSignEqualsSignKeyword_1_0_0_1() { return cLessThanSignEqualsSignKeyword_1_0_0_1; } | ||
2533 | |||
2534 | //type=[Symbol|QualifiedName] | ||
2535 | public Assignment getTypeAssignment_1_0_1() { return cTypeAssignment_1_0_1; } | ||
2536 | |||
2537 | //[Symbol|QualifiedName] | ||
2538 | public CrossReference getTypeSymbolCrossReference_1_0_1_0() { return cTypeSymbolCrossReference_1_0_1_0; } | ||
2539 | |||
2540 | //QualifiedName | ||
2541 | public RuleCall getTypeSymbolQualifiedNameParserRuleCall_1_0_1_0_1() { return cTypeSymbolQualifiedNameParserRuleCall_1_0_1_0_1; } | ||
2542 | |||
2543 | //"<=" | ||
2544 | public Keyword getLessThanSignEqualsSignKeyword_1_0_2() { return cLessThanSignEqualsSignKeyword_1_0_2; } | ||
2545 | |||
2546 | //upperBound=INT | ||
2547 | public Assignment getUpperBoundAssignment_1_0_3() { return cUpperBoundAssignment_1_0_3; } | ||
2548 | |||
2549 | //INT | ||
2550 | public RuleCall getUpperBoundINTTerminalRuleCall_1_0_3_0() { return cUpperBoundINTTerminalRuleCall_1_0_3_0; } | ||
2551 | |||
2552 | //upperBound=INT ">=" type=[Symbol|QualifiedName] (">=" lowerBound=INT)? | ||
2553 | public Group getGroup_1_1() { return cGroup_1_1; } | ||
2554 | |||
2555 | //upperBound=INT | ||
2556 | public Assignment getUpperBoundAssignment_1_1_0() { return cUpperBoundAssignment_1_1_0; } | ||
2557 | |||
2558 | //INT | ||
2559 | public RuleCall getUpperBoundINTTerminalRuleCall_1_1_0_0() { return cUpperBoundINTTerminalRuleCall_1_1_0_0; } | ||
2560 | |||
2561 | //">=" | ||
2562 | public Keyword getGreaterThanSignEqualsSignKeyword_1_1_1() { return cGreaterThanSignEqualsSignKeyword_1_1_1; } | ||
2563 | |||
2564 | //type=[Symbol|QualifiedName] | ||
2565 | public Assignment getTypeAssignment_1_1_2() { return cTypeAssignment_1_1_2; } | ||
2566 | |||
2567 | //[Symbol|QualifiedName] | ||
2568 | public CrossReference getTypeSymbolCrossReference_1_1_2_0() { return cTypeSymbolCrossReference_1_1_2_0; } | ||
2569 | |||
2570 | //QualifiedName | ||
2571 | public RuleCall getTypeSymbolQualifiedNameParserRuleCall_1_1_2_0_1() { return cTypeSymbolQualifiedNameParserRuleCall_1_1_2_0_1; } | ||
2572 | |||
2573 | //(">=" lowerBound=INT)? | ||
2574 | public Group getGroup_1_1_3() { return cGroup_1_1_3; } | ||
2575 | |||
2576 | //">=" | ||
2577 | public Keyword getGreaterThanSignEqualsSignKeyword_1_1_3_0() { return cGreaterThanSignEqualsSignKeyword_1_1_3_0; } | ||
2578 | |||
2579 | //lowerBound=INT | ||
2580 | public Assignment getLowerBoundAssignment_1_1_3_1() { return cLowerBoundAssignment_1_1_3_1; } | ||
2581 | |||
2582 | //INT | ||
2583 | public RuleCall getLowerBoundINTTerminalRuleCall_1_1_3_1_0() { return cLowerBoundINTTerminalRuleCall_1_1_3_1_0; } | ||
2584 | |||
2585 | //FULL_STOP | ||
2586 | public RuleCall getFULL_STOPTerminalRuleCall_2() { return cFULL_STOPTerminalRuleCall_2; } | ||
2587 | } | ||
2588 | public class LowerBoundedScopeElements extends AbstractParserRuleElementFinder { | ||
2589 | private final ParserRule rule = (ParserRule) GrammarUtil.findRuleForName(getGrammar(), "org.eclipse.viatra.solver.language.SolverLanguage.LowerBoundedScope"); | ||
2590 | private final Group cGroup = (Group)rule.eContents().get(1); | ||
2591 | private final Keyword cScopeKeyword_0 = (Keyword)cGroup.eContents().get(0); | ||
2592 | private final Alternatives cAlternatives_1 = (Alternatives)cGroup.eContents().get(1); | ||
2593 | private final Group cGroup_1_0 = (Group)cAlternatives_1.eContents().get(0); | ||
2594 | private final Assignment cLowerBoundAssignment_1_0_0 = (Assignment)cGroup_1_0.eContents().get(0); | ||
2595 | private final RuleCall cLowerBoundINTTerminalRuleCall_1_0_0_0 = (RuleCall)cLowerBoundAssignment_1_0_0.eContents().get(0); | ||
2596 | private final Keyword cLessThanSignEqualsSignKeyword_1_0_1 = (Keyword)cGroup_1_0.eContents().get(1); | ||
2597 | private final Assignment cTypeAssignment_1_0_2 = (Assignment)cGroup_1_0.eContents().get(2); | ||
2598 | private final CrossReference cTypeSymbolCrossReference_1_0_2_0 = (CrossReference)cTypeAssignment_1_0_2.eContents().get(0); | ||
2599 | private final RuleCall cTypeSymbolQualifiedNameParserRuleCall_1_0_2_0_1 = (RuleCall)cTypeSymbolCrossReference_1_0_2_0.eContents().get(1); | ||
2600 | private final Group cGroup_1_1 = (Group)cAlternatives_1.eContents().get(1); | ||
2601 | private final Assignment cTypeAssignment_1_1_0 = (Assignment)cGroup_1_1.eContents().get(0); | ||
2602 | private final CrossReference cTypeSymbolCrossReference_1_1_0_0 = (CrossReference)cTypeAssignment_1_1_0.eContents().get(0); | ||
2603 | private final RuleCall cTypeSymbolQualifiedNameParserRuleCall_1_1_0_0_1 = (RuleCall)cTypeSymbolCrossReference_1_1_0_0.eContents().get(1); | ||
2604 | private final Keyword cGreaterThanSignEqualsSignKeyword_1_1_1 = (Keyword)cGroup_1_1.eContents().get(1); | ||
2605 | private final Assignment cLowerBoundAssignment_1_1_2 = (Assignment)cGroup_1_1.eContents().get(2); | ||
2606 | private final RuleCall cLowerBoundINTTerminalRuleCall_1_1_2_0 = (RuleCall)cLowerBoundAssignment_1_1_2.eContents().get(0); | ||
2607 | private final RuleCall cFULL_STOPTerminalRuleCall_2 = (RuleCall)cGroup.eContents().get(2); | ||
2608 | |||
2609 | //LowerBoundedScope: | ||
2610 | // "scope" (lowerBound=INT "<=" type=[Symbol|QualifiedName] | type=[Symbol|QualifiedName] ">=" lowerBound=INT) | ||
2611 | // FULL_STOP; | ||
2612 | @Override public ParserRule getRule() { return rule; } | ||
2613 | |||
2614 | //"scope" (lowerBound=INT "<=" type=[Symbol|QualifiedName] | type=[Symbol|QualifiedName] ">=" lowerBound=INT) FULL_STOP | ||
2615 | public Group getGroup() { return cGroup; } | ||
2616 | |||
2617 | //"scope" | ||
2618 | public Keyword getScopeKeyword_0() { return cScopeKeyword_0; } | ||
2619 | |||
2620 | //(lowerBound=INT "<=" type=[Symbol|QualifiedName] | type=[Symbol|QualifiedName] ">=" lowerBound=INT) | ||
2621 | public Alternatives getAlternatives_1() { return cAlternatives_1; } | ||
2622 | |||
2623 | //lowerBound=INT "<=" type=[Symbol|QualifiedName] | ||
2624 | public Group getGroup_1_0() { return cGroup_1_0; } | ||
2625 | |||
2626 | //lowerBound=INT | ||
2627 | public Assignment getLowerBoundAssignment_1_0_0() { return cLowerBoundAssignment_1_0_0; } | ||
2628 | |||
2629 | //INT | ||
2630 | public RuleCall getLowerBoundINTTerminalRuleCall_1_0_0_0() { return cLowerBoundINTTerminalRuleCall_1_0_0_0; } | ||
2631 | |||
2632 | //"<=" | ||
2633 | public Keyword getLessThanSignEqualsSignKeyword_1_0_1() { return cLessThanSignEqualsSignKeyword_1_0_1; } | ||
2634 | |||
2635 | //type=[Symbol|QualifiedName] | ||
2636 | public Assignment getTypeAssignment_1_0_2() { return cTypeAssignment_1_0_2; } | ||
2637 | |||
2638 | //[Symbol|QualifiedName] | ||
2639 | public CrossReference getTypeSymbolCrossReference_1_0_2_0() { return cTypeSymbolCrossReference_1_0_2_0; } | ||
2640 | |||
2641 | //QualifiedName | ||
2642 | public RuleCall getTypeSymbolQualifiedNameParserRuleCall_1_0_2_0_1() { return cTypeSymbolQualifiedNameParserRuleCall_1_0_2_0_1; } | ||
2643 | |||
2644 | //type=[Symbol|QualifiedName] ">=" lowerBound=INT | ||
2645 | public Group getGroup_1_1() { return cGroup_1_1; } | ||
2646 | |||
2647 | //type=[Symbol|QualifiedName] | ||
2648 | public Assignment getTypeAssignment_1_1_0() { return cTypeAssignment_1_1_0; } | ||
2649 | |||
2650 | //[Symbol|QualifiedName] | ||
2651 | public CrossReference getTypeSymbolCrossReference_1_1_0_0() { return cTypeSymbolCrossReference_1_1_0_0; } | ||
2652 | |||
2653 | //QualifiedName | ||
2654 | public RuleCall getTypeSymbolQualifiedNameParserRuleCall_1_1_0_0_1() { return cTypeSymbolQualifiedNameParserRuleCall_1_1_0_0_1; } | ||
2655 | |||
2656 | //">=" | ||
2657 | public Keyword getGreaterThanSignEqualsSignKeyword_1_1_1() { return cGreaterThanSignEqualsSignKeyword_1_1_1; } | ||
2658 | |||
2659 | //lowerBound=INT | ||
2660 | public Assignment getLowerBoundAssignment_1_1_2() { return cLowerBoundAssignment_1_1_2; } | ||
2661 | |||
2662 | //INT | ||
2663 | public RuleCall getLowerBoundINTTerminalRuleCall_1_1_2_0() { return cLowerBoundINTTerminalRuleCall_1_1_2_0; } | ||
2664 | |||
2665 | //FULL_STOP | ||
2666 | public RuleCall getFULL_STOPTerminalRuleCall_2() { return cFULL_STOPTerminalRuleCall_2; } | ||
2667 | } | ||
2668 | public class ObjectiveDeclarationElements extends AbstractParserRuleElementFinder { | ||
2669 | private final ParserRule rule = (ParserRule) GrammarUtil.findRuleForName(getGrammar(), "org.eclipse.viatra.solver.language.SolverLanguage.ObjectiveDeclaration"); | ||
2670 | private final Group cGroup = (Group)rule.eContents().get(1); | ||
2671 | private final Assignment cKindAssignment_0 = (Assignment)cGroup.eContents().get(0); | ||
2672 | private final RuleCall cKindObjectiveKindEnumRuleCall_0_0 = (RuleCall)cKindAssignment_0.eContents().get(0); | ||
2673 | private final Assignment cObjectiveAssignment_1 = (Assignment)cGroup.eContents().get(1); | ||
2674 | private final RuleCall cObjectiveExpressionParserRuleCall_1_0 = (RuleCall)cObjectiveAssignment_1.eContents().get(0); | ||
2675 | private final RuleCall cFULL_STOPTerminalRuleCall_2 = (RuleCall)cGroup.eContents().get(2); | ||
2676 | |||
2677 | //ObjectiveDeclaration: | ||
2678 | // kind=ObjectiveKind objective=Expression FULL_STOP; | ||
2679 | @Override public ParserRule getRule() { return rule; } | ||
2680 | |||
2681 | //kind=ObjectiveKind objective=Expression FULL_STOP | ||
2682 | public Group getGroup() { return cGroup; } | ||
2683 | |||
2684 | //kind=ObjectiveKind | ||
2685 | public Assignment getKindAssignment_0() { return cKindAssignment_0; } | ||
2686 | |||
2687 | //ObjectiveKind | ||
2688 | public RuleCall getKindObjectiveKindEnumRuleCall_0_0() { return cKindObjectiveKindEnumRuleCall_0_0; } | ||
2689 | |||
2690 | //objective=Expression | ||
2691 | public Assignment getObjectiveAssignment_1() { return cObjectiveAssignment_1; } | ||
2692 | |||
2693 | //Expression | ||
2694 | public RuleCall getObjectiveExpressionParserRuleCall_1_0() { return cObjectiveExpressionParserRuleCall_1_0; } | ||
2695 | |||
2696 | //FULL_STOP | ||
2697 | public RuleCall getFULL_STOPTerminalRuleCall_2() { return cFULL_STOPTerminalRuleCall_2; } | ||
2698 | } | ||
2699 | public class UpperMultiplictyElements extends AbstractParserRuleElementFinder { | ||
2700 | private final ParserRule rule = (ParserRule) GrammarUtil.findRuleForName(getGrammar(), "org.eclipse.viatra.solver.language.SolverLanguage.UpperMultiplicty"); | ||
2701 | private final Alternatives cAlternatives = (Alternatives)rule.eContents().get(1); | ||
2702 | private final RuleCall cINTTerminalRuleCall_0 = (RuleCall)cAlternatives.eContents().get(0); | ||
2703 | private final Keyword cAsteriskKeyword_1 = (Keyword)cAlternatives.eContents().get(1); | ||
2704 | |||
2705 | //UpperMultiplicty ecore::EInt: | ||
2706 | // INT | "*"; | ||
2707 | @Override public ParserRule getRule() { return rule; } | ||
2708 | |||
2709 | //INT | "*" | ||
2710 | public Alternatives getAlternatives() { return cAlternatives; } | ||
2711 | |||
2712 | //INT | ||
2713 | public RuleCall getINTTerminalRuleCall_0() { return cINTTerminalRuleCall_0; } | ||
2714 | |||
2715 | //"*" | ||
2716 | public Keyword getAsteriskKeyword_1() { return cAsteriskKeyword_1; } | ||
2717 | } | ||
2718 | public class RealElements extends AbstractParserRuleElementFinder { | ||
2719 | private final ParserRule rule = (ParserRule) GrammarUtil.findRuleForName(getGrammar(), "org.eclipse.viatra.solver.language.SolverLanguage.Real"); | ||
2720 | private final Group cGroup = (Group)rule.eContents().get(1); | ||
2721 | private final RuleCall cINTTerminalRuleCall_0 = (RuleCall)cGroup.eContents().get(0); | ||
2722 | private final Keyword cFullStopKeyword_1 = (Keyword)cGroup.eContents().get(1); | ||
2723 | private final RuleCall cINTTerminalRuleCall_2 = (RuleCall)cGroup.eContents().get(2); | ||
2724 | |||
2725 | //Real ecore::EBigDecimal hidden(): | ||
2726 | // INT "." INT; | ||
2727 | @Override public ParserRule getRule() { return rule; } | ||
2728 | |||
2729 | //INT "." INT | ||
2730 | public Group getGroup() { return cGroup; } | ||
2731 | |||
2732 | //INT | ||
2733 | public RuleCall getINTTerminalRuleCall_0() { return cINTTerminalRuleCall_0; } | ||
2734 | |||
2735 | //"." | ||
2736 | public Keyword getFullStopKeyword_1() { return cFullStopKeyword_1; } | ||
2737 | |||
2738 | //INT | ||
2739 | public RuleCall getINTTerminalRuleCall_2() { return cINTTerminalRuleCall_2; } | ||
2740 | } | ||
2741 | public class QualifiedNameSegmentElements extends AbstractParserRuleElementFinder { | ||
2742 | private final ParserRule rule = (ParserRule) GrammarUtil.findRuleForName(getGrammar(), "org.eclipse.viatra.solver.language.SolverLanguage.QualifiedNameSegment"); | ||
2743 | private final Alternatives cAlternatives = (Alternatives)rule.eContents().get(1); | ||
2744 | private final RuleCall cIDTerminalRuleCall_0 = (RuleCall)cAlternatives.eContents().get(0); | ||
2745 | private final RuleCall cQUOTED_IDTerminalRuleCall_1 = (RuleCall)cAlternatives.eContents().get(1); | ||
2746 | private final Keyword cObjectKeyword_2 = (Keyword)cAlternatives.eContents().get(2); | ||
2747 | |||
2748 | //QualifiedNameSegment: | ||
2749 | // ID | QUOTED_ID | "object"; | ||
2750 | @Override public ParserRule getRule() { return rule; } | ||
2751 | |||
2752 | //ID | QUOTED_ID | "object" | ||
2753 | public Alternatives getAlternatives() { return cAlternatives; } | ||
2754 | |||
2755 | //ID | ||
2756 | public RuleCall getIDTerminalRuleCall_0() { return cIDTerminalRuleCall_0; } | ||
2757 | |||
2758 | //QUOTED_ID | ||
2759 | public RuleCall getQUOTED_IDTerminalRuleCall_1() { return cQUOTED_IDTerminalRuleCall_1; } | ||
2760 | |||
2761 | //"object" | ||
2762 | public Keyword getObjectKeyword_2() { return cObjectKeyword_2; } | ||
2763 | } | ||
2764 | public class QualifiedNameElements extends AbstractParserRuleElementFinder { | ||
2765 | private final ParserRule rule = (ParserRule) GrammarUtil.findRuleForName(getGrammar(), "org.eclipse.viatra.solver.language.SolverLanguage.QualifiedName"); | ||
2766 | private final Group cGroup = (Group)rule.eContents().get(1); | ||
2767 | private final RuleCall cQualifiedNameSegmentParserRuleCall_0 = (RuleCall)cGroup.eContents().get(0); | ||
2768 | private final Group cGroup_1 = (Group)cGroup.eContents().get(1); | ||
2769 | private final Keyword cColonColonKeyword_1_0 = (Keyword)cGroup_1.eContents().get(0); | ||
2770 | private final RuleCall cQualifiedNameSegmentParserRuleCall_1_1 = (RuleCall)cGroup_1.eContents().get(1); | ||
2771 | |||
2772 | //QualifiedName hidden(): | ||
2773 | // QualifiedNameSegment ("::" QualifiedNameSegment)*; | ||
2774 | @Override public ParserRule getRule() { return rule; } | ||
2775 | |||
2776 | //QualifiedNameSegment ("::" QualifiedNameSegment)* | ||
2777 | public Group getGroup() { return cGroup; } | ||
2778 | |||
2779 | //QualifiedNameSegment | ||
2780 | public RuleCall getQualifiedNameSegmentParserRuleCall_0() { return cQualifiedNameSegmentParserRuleCall_0; } | ||
2781 | |||
2782 | //("::" QualifiedNameSegment)* | ||
2783 | public Group getGroup_1() { return cGroup_1; } | ||
2784 | |||
2785 | //"::" | ||
2786 | public Keyword getColonColonKeyword_1_0() { return cColonColonKeyword_1_0; } | ||
2787 | |||
2788 | //QualifiedNameSegment | ||
2789 | public RuleCall getQualifiedNameSegmentParserRuleCall_1_1() { return cQualifiedNameSegmentParserRuleCall_1_1; } | ||
2790 | } | ||
2791 | |||
2792 | public class AttributeKindElements extends AbstractEnumRuleElementFinder { | ||
2793 | private final EnumRule rule = (EnumRule) GrammarUtil.findRuleForName(getGrammar(), "org.eclipse.viatra.solver.language.SolverLanguage.AttributeKind"); | ||
2794 | private final Alternatives cAlternatives = (Alternatives)rule.eContents().get(1); | ||
2795 | private final EnumLiteralDeclaration cFUNCTIONALEnumLiteralDeclaration_0 = (EnumLiteralDeclaration)cAlternatives.eContents().get(0); | ||
2796 | private final Keyword cFUNCTIONALFunctionalKeyword_0_0 = (Keyword)cFUNCTIONALEnumLiteralDeclaration_0.eContents().get(0); | ||
2797 | private final EnumLiteralDeclaration cERROREnumLiteralDeclaration_1 = (EnumLiteralDeclaration)cAlternatives.eContents().get(1); | ||
2798 | private final Keyword cERRORErrorKeyword_1_0 = (Keyword)cERROREnumLiteralDeclaration_1.eContents().get(0); | ||
2799 | private final EnumLiteralDeclaration cROOTEnumLiteralDeclaration_2 = (EnumLiteralDeclaration)cAlternatives.eContents().get(2); | ||
2800 | private final Keyword cROOTRootKeyword_2_0 = (Keyword)cROOTEnumLiteralDeclaration_2.eContents().get(0); | ||
2801 | private final EnumLiteralDeclaration cCONTAINMENTEnumLiteralDeclaration_3 = (EnumLiteralDeclaration)cAlternatives.eContents().get(3); | ||
2802 | private final Keyword cCONTAINMENTContainmentKeyword_3_0 = (Keyword)cCONTAINMENTEnumLiteralDeclaration_3.eContents().get(0); | ||
2803 | |||
2804 | //enum AttributeKind: | ||
2805 | // FUNCTIONAL="functional" | ERROR="error" | ROOT="root" | CONTAINMENT="containment"; | ||
2806 | public EnumRule getRule() { return rule; } | ||
2807 | |||
2808 | //FUNCTIONAL="functional" | ERROR="error" | ROOT="root" | CONTAINMENT="containment" | ||
2809 | public Alternatives getAlternatives() { return cAlternatives; } | ||
2810 | |||
2811 | //FUNCTIONAL="functional" | ||
2812 | public EnumLiteralDeclaration getFUNCTIONALEnumLiteralDeclaration_0() { return cFUNCTIONALEnumLiteralDeclaration_0; } | ||
2813 | |||
2814 | //"functional" | ||
2815 | public Keyword getFUNCTIONALFunctionalKeyword_0_0() { return cFUNCTIONALFunctionalKeyword_0_0; } | ||
2816 | |||
2817 | //ERROR="error" | ||
2818 | public EnumLiteralDeclaration getERROREnumLiteralDeclaration_1() { return cERROREnumLiteralDeclaration_1; } | ||
2819 | |||
2820 | //"error" | ||
2821 | public Keyword getERRORErrorKeyword_1_0() { return cERRORErrorKeyword_1_0; } | ||
2822 | |||
2823 | //ROOT="root" | ||
2824 | public EnumLiteralDeclaration getROOTEnumLiteralDeclaration_2() { return cROOTEnumLiteralDeclaration_2; } | ||
2825 | |||
2826 | //"root" | ||
2827 | public Keyword getROOTRootKeyword_2_0() { return cROOTRootKeyword_2_0; } | ||
2828 | |||
2829 | //CONTAINMENT="containment" | ||
2830 | public EnumLiteralDeclaration getCONTAINMENTEnumLiteralDeclaration_3() { return cCONTAINMENTEnumLiteralDeclaration_3; } | ||
2831 | |||
2832 | //"containment" | ||
2833 | public Keyword getCONTAINMENTContainmentKeyword_3_0() { return cCONTAINMENTContainmentKeyword_3_0; } | ||
2834 | } | ||
2835 | public class ComparisonOperatorElements extends AbstractEnumRuleElementFinder { | ||
2836 | private final EnumRule rule = (EnumRule) GrammarUtil.findRuleForName(getGrammar(), "org.eclipse.viatra.solver.language.SolverLanguage.ComparisonOperator"); | ||
2837 | private final Alternatives cAlternatives = (Alternatives)rule.eContents().get(1); | ||
2838 | private final EnumLiteralDeclaration cEQUALSEnumLiteralDeclaration_0 = (EnumLiteralDeclaration)cAlternatives.eContents().get(0); | ||
2839 | private final Keyword cEQUALSEqualsSignEqualsSignKeyword_0_0 = (Keyword)cEQUALSEnumLiteralDeclaration_0.eContents().get(0); | ||
2840 | private final EnumLiteralDeclaration cNOT_EQUALSEnumLiteralDeclaration_1 = (EnumLiteralDeclaration)cAlternatives.eContents().get(1); | ||
2841 | private final Keyword cNOT_EQUALSExclamationMarkEqualsSignKeyword_1_0 = (Keyword)cNOT_EQUALSEnumLiteralDeclaration_1.eContents().get(0); | ||
2842 | private final EnumLiteralDeclaration cLESSEnumLiteralDeclaration_2 = (EnumLiteralDeclaration)cAlternatives.eContents().get(2); | ||
2843 | private final Keyword cLESSLessThanSignKeyword_2_0 = (Keyword)cLESSEnumLiteralDeclaration_2.eContents().get(0); | ||
2844 | private final EnumLiteralDeclaration cLESS_EQUALSEnumLiteralDeclaration_3 = (EnumLiteralDeclaration)cAlternatives.eContents().get(3); | ||
2845 | private final Keyword cLESS_EQUALSLessThanSignEqualsSignKeyword_3_0 = (Keyword)cLESS_EQUALSEnumLiteralDeclaration_3.eContents().get(0); | ||
2846 | private final EnumLiteralDeclaration cGREATEREnumLiteralDeclaration_4 = (EnumLiteralDeclaration)cAlternatives.eContents().get(4); | ||
2847 | private final Keyword cGREATERGreaterThanSignKeyword_4_0 = (Keyword)cGREATEREnumLiteralDeclaration_4.eContents().get(0); | ||
2848 | private final EnumLiteralDeclaration cGREATER_EQUALSEnumLiteralDeclaration_5 = (EnumLiteralDeclaration)cAlternatives.eContents().get(5); | ||
2849 | private final Keyword cGREATER_EQUALSGreaterThanSignEqualsSignKeyword_5_0 = (Keyword)cGREATER_EQUALSEnumLiteralDeclaration_5.eContents().get(0); | ||
2850 | private final EnumLiteralDeclaration cINEnumLiteralDeclaration_6 = (EnumLiteralDeclaration)cAlternatives.eContents().get(6); | ||
2851 | private final Keyword cINInKeyword_6_0 = (Keyword)cINEnumLiteralDeclaration_6.eContents().get(0); | ||
2852 | |||
2853 | //enum ComparisonOperator returns BinaryOperator: | ||
2854 | // EQUALS="==" | NOT_EQUALS="!=" | LESS="<" | LESS_EQUALS="<=" | GREATER=">" | GREATER_EQUALS=">=" | IN="in"; | ||
2855 | public EnumRule getRule() { return rule; } | ||
2856 | |||
2857 | //EQUALS="==" | NOT_EQUALS="!=" | LESS="<" | LESS_EQUALS="<=" | GREATER=">" | GREATER_EQUALS=">=" | IN="in" | ||
2858 | public Alternatives getAlternatives() { return cAlternatives; } | ||
2859 | |||
2860 | //EQUALS="==" | ||
2861 | public EnumLiteralDeclaration getEQUALSEnumLiteralDeclaration_0() { return cEQUALSEnumLiteralDeclaration_0; } | ||
2862 | |||
2863 | //"==" | ||
2864 | public Keyword getEQUALSEqualsSignEqualsSignKeyword_0_0() { return cEQUALSEqualsSignEqualsSignKeyword_0_0; } | ||
2865 | |||
2866 | //NOT_EQUALS="!=" | ||
2867 | public EnumLiteralDeclaration getNOT_EQUALSEnumLiteralDeclaration_1() { return cNOT_EQUALSEnumLiteralDeclaration_1; } | ||
2868 | |||
2869 | //"!=" | ||
2870 | public Keyword getNOT_EQUALSExclamationMarkEqualsSignKeyword_1_0() { return cNOT_EQUALSExclamationMarkEqualsSignKeyword_1_0; } | ||
2871 | |||
2872 | //LESS="<" | ||
2873 | public EnumLiteralDeclaration getLESSEnumLiteralDeclaration_2() { return cLESSEnumLiteralDeclaration_2; } | ||
2874 | |||
2875 | //"<" | ||
2876 | public Keyword getLESSLessThanSignKeyword_2_0() { return cLESSLessThanSignKeyword_2_0; } | ||
2877 | |||
2878 | //LESS_EQUALS="<=" | ||
2879 | public EnumLiteralDeclaration getLESS_EQUALSEnumLiteralDeclaration_3() { return cLESS_EQUALSEnumLiteralDeclaration_3; } | ||
2880 | |||
2881 | //"<=" | ||
2882 | public Keyword getLESS_EQUALSLessThanSignEqualsSignKeyword_3_0() { return cLESS_EQUALSLessThanSignEqualsSignKeyword_3_0; } | ||
2883 | |||
2884 | //GREATER=">" | ||
2885 | public EnumLiteralDeclaration getGREATEREnumLiteralDeclaration_4() { return cGREATEREnumLiteralDeclaration_4; } | ||
2886 | |||
2887 | //">" | ||
2888 | public Keyword getGREATERGreaterThanSignKeyword_4_0() { return cGREATERGreaterThanSignKeyword_4_0; } | ||
2889 | |||
2890 | //GREATER_EQUALS=">=" | ||
2891 | public EnumLiteralDeclaration getGREATER_EQUALSEnumLiteralDeclaration_5() { return cGREATER_EQUALSEnumLiteralDeclaration_5; } | ||
2892 | |||
2893 | //">=" | ||
2894 | public Keyword getGREATER_EQUALSGreaterThanSignEqualsSignKeyword_5_0() { return cGREATER_EQUALSGreaterThanSignEqualsSignKeyword_5_0; } | ||
2895 | |||
2896 | //IN="in" | ||
2897 | public EnumLiteralDeclaration getINEnumLiteralDeclaration_6() { return cINEnumLiteralDeclaration_6; } | ||
2898 | |||
2899 | //"in" | ||
2900 | public Keyword getINInKeyword_6_0() { return cINInKeyword_6_0; } | ||
2901 | } | ||
2902 | public class AdditiveBinaryOperatorElements extends AbstractEnumRuleElementFinder { | ||
2903 | private final EnumRule rule = (EnumRule) GrammarUtil.findRuleForName(getGrammar(), "org.eclipse.viatra.solver.language.SolverLanguage.AdditiveBinaryOperator"); | ||
2904 | private final Alternatives cAlternatives = (Alternatives)rule.eContents().get(1); | ||
2905 | private final EnumLiteralDeclaration cPLUSEnumLiteralDeclaration_0 = (EnumLiteralDeclaration)cAlternatives.eContents().get(0); | ||
2906 | private final Keyword cPLUSPlusSignKeyword_0_0 = (Keyword)cPLUSEnumLiteralDeclaration_0.eContents().get(0); | ||
2907 | private final EnumLiteralDeclaration cMINUSEnumLiteralDeclaration_1 = (EnumLiteralDeclaration)cAlternatives.eContents().get(1); | ||
2908 | private final Keyword cMINUSHyphenMinusKeyword_1_0 = (Keyword)cMINUSEnumLiteralDeclaration_1.eContents().get(0); | ||
2909 | |||
2910 | //enum AdditiveBinaryOperator returns BinaryOperator: | ||
2911 | // PLUS="+" | MINUS="-"; | ||
2912 | public EnumRule getRule() { return rule; } | ||
2913 | |||
2914 | //PLUS="+" | MINUS="-" | ||
2915 | public Alternatives getAlternatives() { return cAlternatives; } | ||
2916 | |||
2917 | //PLUS="+" | ||
2918 | public EnumLiteralDeclaration getPLUSEnumLiteralDeclaration_0() { return cPLUSEnumLiteralDeclaration_0; } | ||
2919 | |||
2920 | //"+" | ||
2921 | public Keyword getPLUSPlusSignKeyword_0_0() { return cPLUSPlusSignKeyword_0_0; } | ||
2922 | |||
2923 | //MINUS="-" | ||
2924 | public EnumLiteralDeclaration getMINUSEnumLiteralDeclaration_1() { return cMINUSEnumLiteralDeclaration_1; } | ||
2925 | |||
2926 | //"-" | ||
2927 | public Keyword getMINUSHyphenMinusKeyword_1_0() { return cMINUSHyphenMinusKeyword_1_0; } | ||
2928 | } | ||
2929 | public class MultiplicativeBinaryOperatorElements extends AbstractEnumRuleElementFinder { | ||
2930 | private final EnumRule rule = (EnumRule) GrammarUtil.findRuleForName(getGrammar(), "org.eclipse.viatra.solver.language.SolverLanguage.MultiplicativeBinaryOperator"); | ||
2931 | private final Alternatives cAlternatives = (Alternatives)rule.eContents().get(1); | ||
2932 | private final EnumLiteralDeclaration cMULTIPLYEnumLiteralDeclaration_0 = (EnumLiteralDeclaration)cAlternatives.eContents().get(0); | ||
2933 | private final Keyword cMULTIPLYAsteriskKeyword_0_0 = (Keyword)cMULTIPLYEnumLiteralDeclaration_0.eContents().get(0); | ||
2934 | private final EnumLiteralDeclaration cDIVIDEEnumLiteralDeclaration_1 = (EnumLiteralDeclaration)cAlternatives.eContents().get(1); | ||
2935 | private final Keyword cDIVIDESolidusKeyword_1_0 = (Keyword)cDIVIDEEnumLiteralDeclaration_1.eContents().get(0); | ||
2936 | |||
2937 | //enum MultiplicativeBinaryOperator returns BinaryOperator: | ||
2938 | // MULTIPLY="*" | DIVIDE="/"; | ||
2939 | public EnumRule getRule() { return rule; } | ||
2940 | |||
2941 | //MULTIPLY="*" | DIVIDE="/" | ||
2942 | public Alternatives getAlternatives() { return cAlternatives; } | ||
2943 | |||
2944 | //MULTIPLY="*" | ||
2945 | public EnumLiteralDeclaration getMULTIPLYEnumLiteralDeclaration_0() { return cMULTIPLYEnumLiteralDeclaration_0; } | ||
2946 | |||
2947 | //"*" | ||
2948 | public Keyword getMULTIPLYAsteriskKeyword_0_0() { return cMULTIPLYAsteriskKeyword_0_0; } | ||
2949 | |||
2950 | //DIVIDE="/" | ||
2951 | public EnumLiteralDeclaration getDIVIDEEnumLiteralDeclaration_1() { return cDIVIDEEnumLiteralDeclaration_1; } | ||
2952 | |||
2953 | //"/" | ||
2954 | public Keyword getDIVIDESolidusKeyword_1_0() { return cDIVIDESolidusKeyword_1_0; } | ||
2955 | } | ||
2956 | public class ExponentialOpElements extends AbstractEnumRuleElementFinder { | ||
2957 | private final EnumRule rule = (EnumRule) GrammarUtil.findRuleForName(getGrammar(), "org.eclipse.viatra.solver.language.SolverLanguage.ExponentialOp"); | ||
2958 | private final EnumLiteralDeclaration cPOWEnumLiteralDeclaration = (EnumLiteralDeclaration)rule.eContents().get(1); | ||
2959 | private final Keyword cPOWCircumflexAccentKeyword_0 = (Keyword)cPOWEnumLiteralDeclaration.eContents().get(0); | ||
2960 | |||
2961 | //enum ExponentialOp returns BinaryOperator: | ||
2962 | // POW="^"; | ||
2963 | public EnumRule getRule() { return rule; } | ||
2964 | |||
2965 | //POW="^" | ||
2966 | public EnumLiteralDeclaration getPOWEnumLiteralDeclaration() { return cPOWEnumLiteralDeclaration; } | ||
2967 | |||
2968 | //"^" | ||
2969 | public Keyword getPOWCircumflexAccentKeyword_0() { return cPOWCircumflexAccentKeyword_0; } | ||
2970 | } | ||
2971 | public class UnaryOperatorElements extends AbstractEnumRuleElementFinder { | ||
2972 | private final EnumRule rule = (EnumRule) GrammarUtil.findRuleForName(getGrammar(), "org.eclipse.viatra.solver.language.SolverLanguage.UnaryOperator"); | ||
2973 | private final Alternatives cAlternatives = (Alternatives)rule.eContents().get(1); | ||
2974 | private final EnumLiteralDeclaration cNOTEnumLiteralDeclaration_0 = (EnumLiteralDeclaration)cAlternatives.eContents().get(0); | ||
2975 | private final Keyword cNOTExclamationMarkKeyword_0_0 = (Keyword)cNOTEnumLiteralDeclaration_0.eContents().get(0); | ||
2976 | private final EnumLiteralDeclaration cPLUSEnumLiteralDeclaration_1 = (EnumLiteralDeclaration)cAlternatives.eContents().get(1); | ||
2977 | private final Keyword cPLUSPlusSignKeyword_1_0 = (Keyword)cPLUSEnumLiteralDeclaration_1.eContents().get(0); | ||
2978 | private final EnumLiteralDeclaration cMINUSEnumLiteralDeclaration_2 = (EnumLiteralDeclaration)cAlternatives.eContents().get(2); | ||
2979 | private final Keyword cMINUSHyphenMinusKeyword_2_0 = (Keyword)cMINUSEnumLiteralDeclaration_2.eContents().get(0); | ||
2980 | private final EnumLiteralDeclaration cMAYBEEnumLiteralDeclaration_3 = (EnumLiteralDeclaration)cAlternatives.eContents().get(3); | ||
2981 | private final Keyword cMAYBEQuestionMarkKeyword_3_0 = (Keyword)cMAYBEEnumLiteralDeclaration_3.eContents().get(0); | ||
2982 | |||
2983 | //enum UnaryOperator: | ||
2984 | // NOT="!" | PLUS="+" | MINUS="-" | MAYBE="?"; | ||
2985 | public EnumRule getRule() { return rule; } | ||
2986 | |||
2987 | //NOT="!" | PLUS="+" | MINUS="-" | MAYBE="?" | ||
2988 | public Alternatives getAlternatives() { return cAlternatives; } | ||
2989 | |||
2990 | //NOT="!" | ||
2991 | public EnumLiteralDeclaration getNOTEnumLiteralDeclaration_0() { return cNOTEnumLiteralDeclaration_0; } | ||
2992 | |||
2993 | //"!" | ||
2994 | public Keyword getNOTExclamationMarkKeyword_0_0() { return cNOTExclamationMarkKeyword_0_0; } | ||
2995 | |||
2996 | //PLUS="+" | ||
2997 | public EnumLiteralDeclaration getPLUSEnumLiteralDeclaration_1() { return cPLUSEnumLiteralDeclaration_1; } | ||
2998 | |||
2999 | //"+" | ||
3000 | public Keyword getPLUSPlusSignKeyword_1_0() { return cPLUSPlusSignKeyword_1_0; } | ||
3001 | |||
3002 | //MINUS="-" | ||
3003 | public EnumLiteralDeclaration getMINUSEnumLiteralDeclaration_2() { return cMINUSEnumLiteralDeclaration_2; } | ||
3004 | |||
3005 | //"-" | ||
3006 | public Keyword getMINUSHyphenMinusKeyword_2_0() { return cMINUSHyphenMinusKeyword_2_0; } | ||
3007 | |||
3008 | //MAYBE="?" | ||
3009 | public EnumLiteralDeclaration getMAYBEEnumLiteralDeclaration_3() { return cMAYBEEnumLiteralDeclaration_3; } | ||
3010 | |||
3011 | //"?" | ||
3012 | public Keyword getMAYBEQuestionMarkKeyword_3_0() { return cMAYBEQuestionMarkKeyword_3_0; } | ||
3013 | } | ||
3014 | public class LogicValueElements extends AbstractEnumRuleElementFinder { | ||
3015 | private final EnumRule rule = (EnumRule) GrammarUtil.findRuleForName(getGrammar(), "org.eclipse.viatra.solver.language.SolverLanguage.LogicValue"); | ||
3016 | private final Alternatives cAlternatives = (Alternatives)rule.eContents().get(1); | ||
3017 | private final EnumLiteralDeclaration cTRUEEnumLiteralDeclaration_0 = (EnumLiteralDeclaration)cAlternatives.eContents().get(0); | ||
3018 | private final Keyword cTRUETrueKeyword_0_0 = (Keyword)cTRUEEnumLiteralDeclaration_0.eContents().get(0); | ||
3019 | private final EnumLiteralDeclaration cFALSEEnumLiteralDeclaration_1 = (EnumLiteralDeclaration)cAlternatives.eContents().get(1); | ||
3020 | private final Keyword cFALSEFalseKeyword_1_0 = (Keyword)cFALSEEnumLiteralDeclaration_1.eContents().get(0); | ||
3021 | private final EnumLiteralDeclaration cUNKNOWNEnumLiteralDeclaration_2 = (EnumLiteralDeclaration)cAlternatives.eContents().get(2); | ||
3022 | private final Keyword cUNKNOWNUnknownKeyword_2_0 = (Keyword)cUNKNOWNEnumLiteralDeclaration_2.eContents().get(0); | ||
3023 | private final EnumLiteralDeclaration cERROREnumLiteralDeclaration_3 = (EnumLiteralDeclaration)cAlternatives.eContents().get(3); | ||
3024 | private final Keyword cERRORErrorKeyword_3_0 = (Keyword)cERROREnumLiteralDeclaration_3.eContents().get(0); | ||
3025 | |||
3026 | //enum LogicValue: | ||
3027 | // TRUE="true" | FALSE="false" | UNKNOWN="unknown" | ERROR="error"; | ||
3028 | public EnumRule getRule() { return rule; } | ||
3029 | |||
3030 | //TRUE="true" | FALSE="false" | UNKNOWN="unknown" | ERROR="error" | ||
3031 | public Alternatives getAlternatives() { return cAlternatives; } | ||
3032 | |||
3033 | //TRUE="true" | ||
3034 | public EnumLiteralDeclaration getTRUEEnumLiteralDeclaration_0() { return cTRUEEnumLiteralDeclaration_0; } | ||
3035 | |||
3036 | //"true" | ||
3037 | public Keyword getTRUETrueKeyword_0_0() { return cTRUETrueKeyword_0_0; } | ||
3038 | |||
3039 | //FALSE="false" | ||
3040 | public EnumLiteralDeclaration getFALSEEnumLiteralDeclaration_1() { return cFALSEEnumLiteralDeclaration_1; } | ||
3041 | |||
3042 | //"false" | ||
3043 | public Keyword getFALSEFalseKeyword_1_0() { return cFALSEFalseKeyword_1_0; } | ||
3044 | |||
3045 | //UNKNOWN="unknown" | ||
3046 | public EnumLiteralDeclaration getUNKNOWNEnumLiteralDeclaration_2() { return cUNKNOWNEnumLiteralDeclaration_2; } | ||
3047 | |||
3048 | //"unknown" | ||
3049 | public Keyword getUNKNOWNUnknownKeyword_2_0() { return cUNKNOWNUnknownKeyword_2_0; } | ||
3050 | |||
3051 | //ERROR="error" | ||
3052 | public EnumLiteralDeclaration getERROREnumLiteralDeclaration_3() { return cERROREnumLiteralDeclaration_3; } | ||
3053 | |||
3054 | //"error" | ||
3055 | public Keyword getERRORErrorKeyword_3_0() { return cERRORErrorKeyword_3_0; } | ||
3056 | } | ||
3057 | public class ObjectiveKindElements extends AbstractEnumRuleElementFinder { | ||
3058 | private final EnumRule rule = (EnumRule) GrammarUtil.findRuleForName(getGrammar(), "org.eclipse.viatra.solver.language.SolverLanguage.ObjectiveKind"); | ||
3059 | private final Alternatives cAlternatives = (Alternatives)rule.eContents().get(1); | ||
3060 | private final EnumLiteralDeclaration cMINIMIZATIONEnumLiteralDeclaration_0 = (EnumLiteralDeclaration)cAlternatives.eContents().get(0); | ||
3061 | private final Keyword cMINIMIZATIONMinimizeKeyword_0_0 = (Keyword)cMINIMIZATIONEnumLiteralDeclaration_0.eContents().get(0); | ||
3062 | private final EnumLiteralDeclaration cMAXIMIZATIONEnumLiteralDeclaration_1 = (EnumLiteralDeclaration)cAlternatives.eContents().get(1); | ||
3063 | private final Keyword cMAXIMIZATIONMaximizeKeyword_1_0 = (Keyword)cMAXIMIZATIONEnumLiteralDeclaration_1.eContents().get(0); | ||
3064 | |||
3065 | //enum ObjectiveKind: | ||
3066 | // MINIMIZATION="minimize" | MAXIMIZATION="maximize"; | ||
3067 | public EnumRule getRule() { return rule; } | ||
3068 | |||
3069 | //MINIMIZATION="minimize" | MAXIMIZATION="maximize" | ||
3070 | public Alternatives getAlternatives() { return cAlternatives; } | ||
3071 | |||
3072 | //MINIMIZATION="minimize" | ||
3073 | public EnumLiteralDeclaration getMINIMIZATIONEnumLiteralDeclaration_0() { return cMINIMIZATIONEnumLiteralDeclaration_0; } | ||
3074 | |||
3075 | //"minimize" | ||
3076 | public Keyword getMINIMIZATIONMinimizeKeyword_0_0() { return cMINIMIZATIONMinimizeKeyword_0_0; } | ||
3077 | |||
3078 | //MAXIMIZATION="maximize" | ||
3079 | public EnumLiteralDeclaration getMAXIMIZATIONEnumLiteralDeclaration_1() { return cMAXIMIZATIONEnumLiteralDeclaration_1; } | ||
3080 | |||
3081 | //"maximize" | ||
3082 | public Keyword getMAXIMIZATIONMaximizeKeyword_1_0() { return cMAXIMIZATIONMaximizeKeyword_1_0; } | ||
3083 | } | ||
3084 | |||
3085 | private final ProblemElements pProblem; | ||
3086 | private final StatementElements pStatement; | ||
3087 | private final ImportElements pImport; | ||
3088 | private final UriImportElements pUriImport; | ||
3089 | private final NamespaceImportElements pNamespaceImport; | ||
3090 | private final AssertionOrDefinitionElements pAssertionOrDefinition; | ||
3091 | private final PredicateDefinitionElements pPredicateDefinition; | ||
3092 | private final UnnamedErrorPredicateDefintionElements pUnnamedErrorPredicateDefintion; | ||
3093 | private final DefaultAssertionElements pDefaultAssertion; | ||
3094 | private final FunctionDefinitionElements pFunctionDefinition; | ||
3095 | private final TypeReferenceElements pTypeReference; | ||
3096 | private final AttributeKindElements eAttributeKind; | ||
3097 | private final AttributeElements pAttribute; | ||
3098 | private final ExternDeclarationElements pExternDeclaration; | ||
3099 | private final ExternPredicateDeclarationElements pExternPredicateDeclaration; | ||
3100 | private final ExternFunctionDeclarationElements pExternFunctionDeclaration; | ||
3101 | private final ExternAggregationOperatorDeclarationElements pExternAggregationOperatorDeclaration; | ||
3102 | private final ExternDatatypeDeclarationElements pExternDatatypeDeclaration; | ||
3103 | private final ExpressionElements pExpression; | ||
3104 | private final ConditionalExpressionElements pConditionalExpression; | ||
3105 | private final LetExpressionElements pLetExpression; | ||
3106 | private final LetBindingElements pLetBinding; | ||
3107 | private final DisjunctiveExpressionElements pDisjunctiveExpression; | ||
3108 | private final CaseElements pCase; | ||
3109 | private final ConjunctiveExpressionElements pConjunctiveExpression; | ||
3110 | private final ComparisonOperatorElements eComparisonOperator; | ||
3111 | private final ComparisonExpressionElements pComparisonExpression; | ||
3112 | private final AdditiveBinaryOperatorElements eAdditiveBinaryOperator; | ||
3113 | private final AdditiveExpressionElements pAdditiveExpression; | ||
3114 | private final MultiplicativeBinaryOperatorElements eMultiplicativeBinaryOperator; | ||
3115 | private final MultiplicativeExpressionElements pMultiplicativeExpression; | ||
3116 | private final ExponentialOpElements eExponentialOp; | ||
3117 | private final ExponentialExpressionElements pExponentialExpression; | ||
3118 | private final CastExpressionElements pCastExpression; | ||
3119 | private final UnaryOperatorElements eUnaryOperator; | ||
3120 | private final UnaryExpressionElements pUnaryExpression; | ||
3121 | private final BracedAggregateExpressionElements pBracedAggregateExpression; | ||
3122 | private final AggregationElements pAggregation; | ||
3123 | private final CountElements pCount; | ||
3124 | private final AtomicExpressionElements pAtomicExpression; | ||
3125 | private final CallElements pCall; | ||
3126 | private final ArgumentListElements pArgumentList; | ||
3127 | private final ArgumentElements pArgument; | ||
3128 | private final ExpressionArgumentElements pExpressionArgument; | ||
3129 | private final StarArgumentElements pStarArgument; | ||
3130 | private final TypedVariableArgumentElements pTypedVariableArgument; | ||
3131 | private final TypedStarArgumentElements pTypedStarArgument; | ||
3132 | private final ReferenceElements pReference; | ||
3133 | private final PathComponentElements pPathComponent; | ||
3134 | private final IntervalElements pInterval; | ||
3135 | private final LiteralElements pLiteral; | ||
3136 | private final LogicValueElements eLogicValue; | ||
3137 | private final LogicLiteralElements pLogicLiteral; | ||
3138 | private final IntLiteralElements pIntLiteral; | ||
3139 | private final RealLiteralElements pRealLiteral; | ||
3140 | private final InfinityLiteralElements pInfinityLiteral; | ||
3141 | private final EmptyLiteralElements pEmptyLiteral; | ||
3142 | private final StringLiteralElements pStringLiteral; | ||
3143 | private final ClassDeclarationElements pClassDeclaration; | ||
3144 | private final FieldElements pField; | ||
3145 | private final MultiplicityElements pMultiplicity; | ||
3146 | private final UnboundedMultiplicityElements pUnboundedMultiplicity; | ||
3147 | private final ExactMultiplicityElements pExactMultiplicity; | ||
3148 | private final BoundedMultiplicityElements pBoundedMultiplicity; | ||
3149 | private final EnumDeclarationElements pEnumDeclaration; | ||
3150 | private final EnumLiteralElements pEnumLiteral; | ||
3151 | private final ScopeDeclarationElements pScopeDeclaration; | ||
3152 | private final ExactScopeElements pExactScope; | ||
3153 | private final BoundedScopeElements pBoundedScope; | ||
3154 | private final LowerBoundedScopeElements pLowerBoundedScope; | ||
3155 | private final ObjectiveKindElements eObjectiveKind; | ||
3156 | private final ObjectiveDeclarationElements pObjectiveDeclaration; | ||
3157 | private final UpperMultiplictyElements pUpperMultiplicty; | ||
3158 | private final RealElements pReal; | ||
3159 | private final QualifiedNameSegmentElements pQualifiedNameSegment; | ||
3160 | private final QualifiedNameElements pQualifiedName; | ||
3161 | private final TerminalRule tSTRING; | ||
3162 | private final TerminalRule tQUOTED_ID; | ||
3163 | private final TerminalRule tSL_COMMENT; | ||
3164 | private final TerminalRule tTRANSITIVE_CLOSURE; | ||
3165 | private final TerminalRule tREFLEXIVE_TRANSITIVE_CLOSURE; | ||
3166 | private final TerminalRule tFULL_STOP; | ||
3167 | |||
3168 | private final Grammar grammar; | ||
3169 | |||
3170 | private final TerminalsGrammarAccess gaTerminals; | ||
3171 | |||
3172 | @Inject | ||
3173 | public SolverLanguageGrammarAccess(GrammarProvider grammarProvider, | ||
3174 | TerminalsGrammarAccess gaTerminals) { | ||
3175 | this.grammar = internalFindGrammar(grammarProvider); | ||
3176 | this.gaTerminals = gaTerminals; | ||
3177 | this.pProblem = new ProblemElements(); | ||
3178 | this.pStatement = new StatementElements(); | ||
3179 | this.pImport = new ImportElements(); | ||
3180 | this.pUriImport = new UriImportElements(); | ||
3181 | this.pNamespaceImport = new NamespaceImportElements(); | ||
3182 | this.pAssertionOrDefinition = new AssertionOrDefinitionElements(); | ||
3183 | this.pPredicateDefinition = new PredicateDefinitionElements(); | ||
3184 | this.pUnnamedErrorPredicateDefintion = new UnnamedErrorPredicateDefintionElements(); | ||
3185 | this.pDefaultAssertion = new DefaultAssertionElements(); | ||
3186 | this.pFunctionDefinition = new FunctionDefinitionElements(); | ||
3187 | this.pTypeReference = new TypeReferenceElements(); | ||
3188 | this.eAttributeKind = new AttributeKindElements(); | ||
3189 | this.pAttribute = new AttributeElements(); | ||
3190 | this.pExternDeclaration = new ExternDeclarationElements(); | ||
3191 | this.pExternPredicateDeclaration = new ExternPredicateDeclarationElements(); | ||
3192 | this.pExternFunctionDeclaration = new ExternFunctionDeclarationElements(); | ||
3193 | this.pExternAggregationOperatorDeclaration = new ExternAggregationOperatorDeclarationElements(); | ||
3194 | this.pExternDatatypeDeclaration = new ExternDatatypeDeclarationElements(); | ||
3195 | this.pExpression = new ExpressionElements(); | ||
3196 | this.pConditionalExpression = new ConditionalExpressionElements(); | ||
3197 | this.pLetExpression = new LetExpressionElements(); | ||
3198 | this.pLetBinding = new LetBindingElements(); | ||
3199 | this.pDisjunctiveExpression = new DisjunctiveExpressionElements(); | ||
3200 | this.pCase = new CaseElements(); | ||
3201 | this.pConjunctiveExpression = new ConjunctiveExpressionElements(); | ||
3202 | this.eComparisonOperator = new ComparisonOperatorElements(); | ||
3203 | this.pComparisonExpression = new ComparisonExpressionElements(); | ||
3204 | this.eAdditiveBinaryOperator = new AdditiveBinaryOperatorElements(); | ||
3205 | this.pAdditiveExpression = new AdditiveExpressionElements(); | ||
3206 | this.eMultiplicativeBinaryOperator = new MultiplicativeBinaryOperatorElements(); | ||
3207 | this.pMultiplicativeExpression = new MultiplicativeExpressionElements(); | ||
3208 | this.eExponentialOp = new ExponentialOpElements(); | ||
3209 | this.pExponentialExpression = new ExponentialExpressionElements(); | ||
3210 | this.pCastExpression = new CastExpressionElements(); | ||
3211 | this.eUnaryOperator = new UnaryOperatorElements(); | ||
3212 | this.pUnaryExpression = new UnaryExpressionElements(); | ||
3213 | this.pBracedAggregateExpression = new BracedAggregateExpressionElements(); | ||
3214 | this.pAggregation = new AggregationElements(); | ||
3215 | this.pCount = new CountElements(); | ||
3216 | this.pAtomicExpression = new AtomicExpressionElements(); | ||
3217 | this.pCall = new CallElements(); | ||
3218 | this.pArgumentList = new ArgumentListElements(); | ||
3219 | this.pArgument = new ArgumentElements(); | ||
3220 | this.pExpressionArgument = new ExpressionArgumentElements(); | ||
3221 | this.pStarArgument = new StarArgumentElements(); | ||
3222 | this.pTypedVariableArgument = new TypedVariableArgumentElements(); | ||
3223 | this.pTypedStarArgument = new TypedStarArgumentElements(); | ||
3224 | this.pReference = new ReferenceElements(); | ||
3225 | this.pPathComponent = new PathComponentElements(); | ||
3226 | this.pInterval = new IntervalElements(); | ||
3227 | this.pLiteral = new LiteralElements(); | ||
3228 | this.eLogicValue = new LogicValueElements(); | ||
3229 | this.pLogicLiteral = new LogicLiteralElements(); | ||
3230 | this.pIntLiteral = new IntLiteralElements(); | ||
3231 | this.pRealLiteral = new RealLiteralElements(); | ||
3232 | this.pInfinityLiteral = new InfinityLiteralElements(); | ||
3233 | this.pEmptyLiteral = new EmptyLiteralElements(); | ||
3234 | this.pStringLiteral = new StringLiteralElements(); | ||
3235 | this.pClassDeclaration = new ClassDeclarationElements(); | ||
3236 | this.pField = new FieldElements(); | ||
3237 | this.pMultiplicity = new MultiplicityElements(); | ||
3238 | this.pUnboundedMultiplicity = new UnboundedMultiplicityElements(); | ||
3239 | this.pExactMultiplicity = new ExactMultiplicityElements(); | ||
3240 | this.pBoundedMultiplicity = new BoundedMultiplicityElements(); | ||
3241 | this.pEnumDeclaration = new EnumDeclarationElements(); | ||
3242 | this.pEnumLiteral = new EnumLiteralElements(); | ||
3243 | this.pScopeDeclaration = new ScopeDeclarationElements(); | ||
3244 | this.pExactScope = new ExactScopeElements(); | ||
3245 | this.pBoundedScope = new BoundedScopeElements(); | ||
3246 | this.pLowerBoundedScope = new LowerBoundedScopeElements(); | ||
3247 | this.eObjectiveKind = new ObjectiveKindElements(); | ||
3248 | this.pObjectiveDeclaration = new ObjectiveDeclarationElements(); | ||
3249 | this.pUpperMultiplicty = new UpperMultiplictyElements(); | ||
3250 | this.pReal = new RealElements(); | ||
3251 | this.pQualifiedNameSegment = new QualifiedNameSegmentElements(); | ||
3252 | this.pQualifiedName = new QualifiedNameElements(); | ||
3253 | this.tSTRING = (TerminalRule) GrammarUtil.findRuleForName(getGrammar(), "org.eclipse.viatra.solver.language.SolverLanguage.STRING"); | ||
3254 | this.tQUOTED_ID = (TerminalRule) GrammarUtil.findRuleForName(getGrammar(), "org.eclipse.viatra.solver.language.SolverLanguage.QUOTED_ID"); | ||
3255 | this.tSL_COMMENT = (TerminalRule) GrammarUtil.findRuleForName(getGrammar(), "org.eclipse.viatra.solver.language.SolverLanguage.SL_COMMENT"); | ||
3256 | this.tTRANSITIVE_CLOSURE = (TerminalRule) GrammarUtil.findRuleForName(getGrammar(), "org.eclipse.viatra.solver.language.SolverLanguage.TRANSITIVE_CLOSURE"); | ||
3257 | this.tREFLEXIVE_TRANSITIVE_CLOSURE = (TerminalRule) GrammarUtil.findRuleForName(getGrammar(), "org.eclipse.viatra.solver.language.SolverLanguage.REFLEXIVE_TRANSITIVE_CLOSURE"); | ||
3258 | this.tFULL_STOP = (TerminalRule) GrammarUtil.findRuleForName(getGrammar(), "org.eclipse.viatra.solver.language.SolverLanguage.FULL_STOP"); | ||
3259 | } | ||
3260 | |||
3261 | protected Grammar internalFindGrammar(GrammarProvider grammarProvider) { | ||
3262 | Grammar grammar = grammarProvider.getGrammar(this); | ||
3263 | while (grammar != null) { | ||
3264 | if ("org.eclipse.viatra.solver.language.SolverLanguage".equals(grammar.getName())) { | ||
3265 | return grammar; | ||
3266 | } | ||
3267 | List<Grammar> grammars = grammar.getUsedGrammars(); | ||
3268 | if (!grammars.isEmpty()) { | ||
3269 | grammar = grammars.iterator().next(); | ||
3270 | } else { | ||
3271 | return null; | ||
3272 | } | ||
3273 | } | ||
3274 | return grammar; | ||
3275 | } | ||
3276 | |||
3277 | @Override | ||
3278 | public Grammar getGrammar() { | ||
3279 | return grammar; | ||
3280 | } | ||
3281 | |||
3282 | |||
3283 | public TerminalsGrammarAccess getTerminalsGrammarAccess() { | ||
3284 | return gaTerminals; | ||
3285 | } | ||
3286 | |||
3287 | |||
3288 | //Problem: | ||
3289 | // ("problem" name=QualifiedName FULL_STOP)? | ||
3290 | // imports+=Import* | ||
3291 | // statements+=Statement*; | ||
3292 | public ProblemElements getProblemAccess() { | ||
3293 | return pProblem; | ||
3294 | } | ||
3295 | |||
3296 | public ParserRule getProblemRule() { | ||
3297 | return getProblemAccess().getRule(); | ||
3298 | } | ||
3299 | |||
3300 | //Statement: | ||
3301 | // AssertionOrDefinition | PredicateDefinition | UnnamedErrorPredicateDefintion | DefaultAssertion | FunctionDefinition | ||
3302 | // | Attribute | ExternDeclaration | ScopeDeclaration | ObjectiveDeclaration | ClassDeclaration | EnumDeclaration; | ||
3303 | public StatementElements getStatementAccess() { | ||
3304 | return pStatement; | ||
3305 | } | ||
3306 | |||
3307 | public ParserRule getStatementRule() { | ||
3308 | return getStatementAccess().getRule(); | ||
3309 | } | ||
3310 | |||
3311 | //Import: | ||
3312 | // UriImport | NamespaceImport; | ||
3313 | public ImportElements getImportAccess() { | ||
3314 | return pImport; | ||
3315 | } | ||
3316 | |||
3317 | public ParserRule getImportRule() { | ||
3318 | return getImportAccess().getRule(); | ||
3319 | } | ||
3320 | |||
3321 | //UriImport: | ||
3322 | // "import" uri=STRING ("as" alias=QualifiedName) FULL_STOP; | ||
3323 | public UriImportElements getUriImportAccess() { | ||
3324 | return pUriImport; | ||
3325 | } | ||
3326 | |||
3327 | public ParserRule getUriImportRule() { | ||
3328 | return getUriImportAccess().getRule(); | ||
3329 | } | ||
3330 | |||
3331 | //NamespaceImport: | ||
3332 | // "import" importedNamespace=QualifiedName ("as" alias=QualifiedName) FULL_STOP; | ||
3333 | public NamespaceImportElements getNamespaceImportAccess() { | ||
3334 | return pNamespaceImport; | ||
3335 | } | ||
3336 | |||
3337 | public ParserRule getNamespaceImportRule() { | ||
3338 | return getNamespaceImportAccess().getRule(); | ||
3339 | } | ||
3340 | |||
3341 | //AssertionOrDefinition Statement: | ||
3342 | // Expression ({Assertion.expression=current} (":" range=Expression)? | {PredicateDefinition.head=current} ":-" | ||
3343 | // body=Expression | {FunctionDefinition.head=current} ":=" body=Expression) FULL_STOP; | ||
3344 | public AssertionOrDefinitionElements getAssertionOrDefinitionAccess() { | ||
3345 | return pAssertionOrDefinition; | ||
3346 | } | ||
3347 | |||
3348 | public ParserRule getAssertionOrDefinitionRule() { | ||
3349 | return getAssertionOrDefinitionAccess().getRule(); | ||
3350 | } | ||
3351 | |||
3352 | //PredicateDefinition: | ||
3353 | // (functional?="functional" error?="error"? | error?="error" functional?="functional"?) head=Call ":-" body=Expression | ||
3354 | // FULL_STOP; | ||
3355 | public PredicateDefinitionElements getPredicateDefinitionAccess() { | ||
3356 | return pPredicateDefinition; | ||
3357 | } | ||
3358 | |||
3359 | public ParserRule getPredicateDefinitionRule() { | ||
3360 | return getPredicateDefinitionAccess().getRule(); | ||
3361 | } | ||
3362 | |||
3363 | //UnnamedErrorPredicateDefintion: | ||
3364 | // "error" argumentList=ArgumentList ":-" body=Expression FULL_STOP; | ||
3365 | public UnnamedErrorPredicateDefintionElements getUnnamedErrorPredicateDefintionAccess() { | ||
3366 | return pUnnamedErrorPredicateDefintion; | ||
3367 | } | ||
3368 | |||
3369 | public ParserRule getUnnamedErrorPredicateDefintionRule() { | ||
3370 | return getUnnamedErrorPredicateDefintionAccess().getRule(); | ||
3371 | } | ||
3372 | |||
3373 | //DefaultAssertion: | ||
3374 | // "default" expression=Call (":" range=Expression)? FULL_STOP; | ||
3375 | public DefaultAssertionElements getDefaultAssertionAccess() { | ||
3376 | return pDefaultAssertion; | ||
3377 | } | ||
3378 | |||
3379 | public ParserRule getDefaultAssertionRule() { | ||
3380 | return getDefaultAssertionAccess().getRule(); | ||
3381 | } | ||
3382 | |||
3383 | //FunctionDefinition: | ||
3384 | // resultType=[Symbol|QualifiedName] head=Call ":=" body=Expression FULL_STOP; | ||
3385 | public FunctionDefinitionElements getFunctionDefinitionAccess() { | ||
3386 | return pFunctionDefinition; | ||
3387 | } | ||
3388 | |||
3389 | public ParserRule getFunctionDefinitionRule() { | ||
3390 | return getFunctionDefinitionAccess().getRule(); | ||
3391 | } | ||
3392 | |||
3393 | //TypeReference: | ||
3394 | // type=[Symbol|QualifiedName] forceObjectType?="object"?; | ||
3395 | public TypeReferenceElements getTypeReferenceAccess() { | ||
3396 | return pTypeReference; | ||
3397 | } | ||
3398 | |||
3399 | public ParserRule getTypeReferenceRule() { | ||
3400 | return getTypeReferenceAccess().getRule(); | ||
3401 | } | ||
3402 | |||
3403 | //enum AttributeKind: | ||
3404 | // FUNCTIONAL="functional" | ERROR="error" | ROOT="root" | CONTAINMENT="containment"; | ||
3405 | public AttributeKindElements getAttributeKindAccess() { | ||
3406 | return eAttributeKind; | ||
3407 | } | ||
3408 | |||
3409 | public EnumRule getAttributeKindRule() { | ||
3410 | return getAttributeKindAccess().getRule(); | ||
3411 | } | ||
3412 | |||
3413 | //Attribute: | ||
3414 | // kind=AttributeKind target=[Symbol|QualifiedName] FULL_STOP; | ||
3415 | public AttributeElements getAttributeAccess() { | ||
3416 | return pAttribute; | ||
3417 | } | ||
3418 | |||
3419 | public ParserRule getAttributeRule() { | ||
3420 | return getAttributeAccess().getRule(); | ||
3421 | } | ||
3422 | |||
3423 | //ExternDeclaration: | ||
3424 | // ExternPredicateDeclaration | ExternFunctionDeclaration | ExternAggregationOperatorDeclaration | | ||
3425 | // ExternDatatypeDeclaration; | ||
3426 | public ExternDeclarationElements getExternDeclarationAccess() { | ||
3427 | return pExternDeclaration; | ||
3428 | } | ||
3429 | |||
3430 | public ParserRule getExternDeclarationRule() { | ||
3431 | return getExternDeclarationAccess().getRule(); | ||
3432 | } | ||
3433 | |||
3434 | //ExternPredicateDeclaration: | ||
3435 | // "extern" (functional?="functional"? & error?="error"?) name=QualifiedName argumentList=ArgumentList FULL_STOP; | ||
3436 | public ExternPredicateDeclarationElements getExternPredicateDeclarationAccess() { | ||
3437 | return pExternPredicateDeclaration; | ||
3438 | } | ||
3439 | |||
3440 | public ParserRule getExternPredicateDeclarationRule() { | ||
3441 | return getExternPredicateDeclarationAccess().getRule(); | ||
3442 | } | ||
3443 | |||
3444 | //ExternFunctionDeclaration: | ||
3445 | // "extern" resultType=[Symbol|QualifiedName] name=QualifiedName argumentList=ArgumentList FULL_STOP; | ||
3446 | public ExternFunctionDeclarationElements getExternFunctionDeclarationAccess() { | ||
3447 | return pExternFunctionDeclaration; | ||
3448 | } | ||
3449 | |||
3450 | public ParserRule getExternFunctionDeclarationRule() { | ||
3451 | return getExternFunctionDeclarationAccess().getRule(); | ||
3452 | } | ||
3453 | |||
3454 | //ExternAggregationOperatorDeclaration: | ||
3455 | // "extern" resultType=[Symbol|QualifiedName] name=QualifiedName "{" argumentType=[Symbol|QualifiedName] "..." "}" | ||
3456 | // FULL_STOP; | ||
3457 | public ExternAggregationOperatorDeclarationElements getExternAggregationOperatorDeclarationAccess() { | ||
3458 | return pExternAggregationOperatorDeclaration; | ||
3459 | } | ||
3460 | |||
3461 | public ParserRule getExternAggregationOperatorDeclarationRule() { | ||
3462 | return getExternAggregationOperatorDeclarationAccess().getRule(); | ||
3463 | } | ||
3464 | |||
3465 | //ExternDatatypeDeclaration: | ||
3466 | // "extern" "datatype" name=QualifiedName FULL_STOP; | ||
3467 | public ExternDatatypeDeclarationElements getExternDatatypeDeclarationAccess() { | ||
3468 | return pExternDatatypeDeclaration; | ||
3469 | } | ||
3470 | |||
3471 | public ParserRule getExternDatatypeDeclarationRule() { | ||
3472 | return getExternDatatypeDeclarationAccess().getRule(); | ||
3473 | } | ||
3474 | |||
3475 | //Expression: | ||
3476 | // ConditionalExpression | LetExpression | DisjunctiveExpression ({Forall.condition=current} "=>" | ||
3477 | // body=DisjunctiveExpression)?; | ||
3478 | public ExpressionElements getExpressionAccess() { | ||
3479 | return pExpression; | ||
3480 | } | ||
3481 | |||
3482 | public ParserRule getExpressionRule() { | ||
3483 | return getExpressionAccess().getRule(); | ||
3484 | } | ||
3485 | |||
3486 | //ConditionalExpression: | ||
3487 | // "if" condition=DisjunctiveExpression "then" then=Expression "else" else=Expression; | ||
3488 | public ConditionalExpressionElements getConditionalExpressionAccess() { | ||
3489 | return pConditionalExpression; | ||
3490 | } | ||
3491 | |||
3492 | public ParserRule getConditionalExpressionRule() { | ||
3493 | return getConditionalExpressionAccess().getRule(); | ||
3494 | } | ||
3495 | |||
3496 | //LetExpression: | ||
3497 | // "let" bindings+=LetBinding ("," bindings+=LetBinding)* "in" body=Expression; | ||
3498 | public LetExpressionElements getLetExpressionAccess() { | ||
3499 | return pLetExpression; | ||
3500 | } | ||
3501 | |||
3502 | public ParserRule getLetExpressionRule() { | ||
3503 | return getLetExpressionAccess().getRule(); | ||
3504 | } | ||
3505 | |||
3506 | //LetBinding: | ||
3507 | // type=[Symbol|QualifiedName]? name=ID "=" value=AdditiveExpression; | ||
3508 | public LetBindingElements getLetBindingAccess() { | ||
3509 | return pLetBinding; | ||
3510 | } | ||
3511 | |||
3512 | public ParserRule getLetBindingRule() { | ||
3513 | return getLetBindingAccess().getRule(); | ||
3514 | } | ||
3515 | |||
3516 | //DisjunctiveExpression Expression: | ||
3517 | // ConjunctiveExpression ({Disjunction.children+=current} (";" children+=ConjunctiveExpression)+ | | ||
3518 | // {Case.condition=current} "->" body=ConjunctiveExpression {Switch.cases+=current} (";" cases+=Case)*)?; | ||
3519 | public DisjunctiveExpressionElements getDisjunctiveExpressionAccess() { | ||
3520 | return pDisjunctiveExpression; | ||
3521 | } | ||
3522 | |||
3523 | public ParserRule getDisjunctiveExpressionRule() { | ||
3524 | return getDisjunctiveExpressionAccess().getRule(); | ||
3525 | } | ||
3526 | |||
3527 | //Case: | ||
3528 | // condition=ConjunctiveExpression "->" body=ConjunctiveExpression; | ||
3529 | public CaseElements getCaseAccess() { | ||
3530 | return pCase; | ||
3531 | } | ||
3532 | |||
3533 | public ParserRule getCaseRule() { | ||
3534 | return getCaseAccess().getRule(); | ||
3535 | } | ||
3536 | |||
3537 | //ConjunctiveExpression Expression: | ||
3538 | // ComparisonExpression ({Conjunction.children+=current} ("," children+=ComparisonExpression)+)?; | ||
3539 | public ConjunctiveExpressionElements getConjunctiveExpressionAccess() { | ||
3540 | return pConjunctiveExpression; | ||
3541 | } | ||
3542 | |||
3543 | public ParserRule getConjunctiveExpressionRule() { | ||
3544 | return getConjunctiveExpressionAccess().getRule(); | ||
3545 | } | ||
3546 | |||
3547 | //enum ComparisonOperator returns BinaryOperator: | ||
3548 | // EQUALS="==" | NOT_EQUALS="!=" | LESS="<" | LESS_EQUALS="<=" | GREATER=">" | GREATER_EQUALS=">=" | IN="in"; | ||
3549 | public ComparisonOperatorElements getComparisonOperatorAccess() { | ||
3550 | return eComparisonOperator; | ||
3551 | } | ||
3552 | |||
3553 | public EnumRule getComparisonOperatorRule() { | ||
3554 | return getComparisonOperatorAccess().getRule(); | ||
3555 | } | ||
3556 | |||
3557 | //ComparisonExpression Expression: | ||
3558 | // AdditiveExpression ({BinaryExpression.left=current} op=ComparisonOperator right=AdditiveExpression)?; | ||
3559 | public ComparisonExpressionElements getComparisonExpressionAccess() { | ||
3560 | return pComparisonExpression; | ||
3561 | } | ||
3562 | |||
3563 | public ParserRule getComparisonExpressionRule() { | ||
3564 | return getComparisonExpressionAccess().getRule(); | ||
3565 | } | ||
3566 | |||
3567 | //enum AdditiveBinaryOperator returns BinaryOperator: | ||
3568 | // PLUS="+" | MINUS="-"; | ||
3569 | public AdditiveBinaryOperatorElements getAdditiveBinaryOperatorAccess() { | ||
3570 | return eAdditiveBinaryOperator; | ||
3571 | } | ||
3572 | |||
3573 | public EnumRule getAdditiveBinaryOperatorRule() { | ||
3574 | return getAdditiveBinaryOperatorAccess().getRule(); | ||
3575 | } | ||
3576 | |||
3577 | //AdditiveExpression Expression: | ||
3578 | // MultiplicativeExpression ({BinaryExpression.left=current} op=AdditiveBinaryOperator right=MultiplicativeExpression)*; | ||
3579 | public AdditiveExpressionElements getAdditiveExpressionAccess() { | ||
3580 | return pAdditiveExpression; | ||
3581 | } | ||
3582 | |||
3583 | public ParserRule getAdditiveExpressionRule() { | ||
3584 | return getAdditiveExpressionAccess().getRule(); | ||
3585 | } | ||
3586 | |||
3587 | //enum MultiplicativeBinaryOperator returns BinaryOperator: | ||
3588 | // MULTIPLY="*" | DIVIDE="/"; | ||
3589 | public MultiplicativeBinaryOperatorElements getMultiplicativeBinaryOperatorAccess() { | ||
3590 | return eMultiplicativeBinaryOperator; | ||
3591 | } | ||
3592 | |||
3593 | public EnumRule getMultiplicativeBinaryOperatorRule() { | ||
3594 | return getMultiplicativeBinaryOperatorAccess().getRule(); | ||
3595 | } | ||
3596 | |||
3597 | //MultiplicativeExpression Expression: | ||
3598 | // ExponentialExpression ({BinaryExpression.left=current} op=MultiplicativeBinaryOperator right=ExponentialExpression)*; | ||
3599 | public MultiplicativeExpressionElements getMultiplicativeExpressionAccess() { | ||
3600 | return pMultiplicativeExpression; | ||
3601 | } | ||
3602 | |||
3603 | public ParserRule getMultiplicativeExpressionRule() { | ||
3604 | return getMultiplicativeExpressionAccess().getRule(); | ||
3605 | } | ||
3606 | |||
3607 | //enum ExponentialOp returns BinaryOperator: | ||
3608 | // POW="^"; | ||
3609 | public ExponentialOpElements getExponentialOpAccess() { | ||
3610 | return eExponentialOp; | ||
3611 | } | ||
3612 | |||
3613 | public EnumRule getExponentialOpRule() { | ||
3614 | return getExponentialOpAccess().getRule(); | ||
3615 | } | ||
3616 | |||
3617 | //ExponentialExpression Expression: | ||
3618 | // CastExpression ({BinaryExpression.left=current} op=ExponentialOp right=CastExpression)?; | ||
3619 | public ExponentialExpressionElements getExponentialExpressionAccess() { | ||
3620 | return pExponentialExpression; | ||
3621 | } | ||
3622 | |||
3623 | public ParserRule getExponentialExpressionRule() { | ||
3624 | return getExponentialExpressionAccess().getRule(); | ||
3625 | } | ||
3626 | |||
3627 | //CastExpression Expression: | ||
3628 | // UnaryExpression ({CastExpression.body=current} "as" targetType=[Symbol|QualifiedName])?; | ||
3629 | public CastExpressionElements getCastExpressionAccess() { | ||
3630 | return pCastExpression; | ||
3631 | } | ||
3632 | |||
3633 | public ParserRule getCastExpressionRule() { | ||
3634 | return getCastExpressionAccess().getRule(); | ||
3635 | } | ||
3636 | |||
3637 | //enum UnaryOperator: | ||
3638 | // NOT="!" | PLUS="+" | MINUS="-" | MAYBE="?"; | ||
3639 | public UnaryOperatorElements getUnaryOperatorAccess() { | ||
3640 | return eUnaryOperator; | ||
3641 | } | ||
3642 | |||
3643 | public EnumRule getUnaryOperatorRule() { | ||
3644 | return getUnaryOperatorAccess().getRule(); | ||
3645 | } | ||
3646 | |||
3647 | //UnaryExpression Expression: | ||
3648 | // BracedAggregateExpression | {UnaryExpression} op=UnaryOperator body=BracedAggregateExpression; | ||
3649 | public UnaryExpressionElements getUnaryExpressionAccess() { | ||
3650 | return pUnaryExpression; | ||
3651 | } | ||
3652 | |||
3653 | public ParserRule getUnaryExpressionRule() { | ||
3654 | return getUnaryExpressionAccess().getRule(); | ||
3655 | } | ||
3656 | |||
3657 | //BracedAggregateExpression Expression: | ||
3658 | // AtomicExpression | Aggregation | Count; | ||
3659 | public BracedAggregateExpressionElements getBracedAggregateExpressionAccess() { | ||
3660 | return pBracedAggregateExpression; | ||
3661 | } | ||
3662 | |||
3663 | public ParserRule getBracedAggregateExpressionRule() { | ||
3664 | return getBracedAggregateExpressionAccess().getRule(); | ||
3665 | } | ||
3666 | |||
3667 | //Aggregation: | ||
3668 | // op=[Symbol|QualifiedName] "{" value=Expression "|" condition=Expression "}"; | ||
3669 | public AggregationElements getAggregationAccess() { | ||
3670 | return pAggregation; | ||
3671 | } | ||
3672 | |||
3673 | public ParserRule getAggregationRule() { | ||
3674 | return getAggregationAccess().getRule(); | ||
3675 | } | ||
3676 | |||
3677 | //Count: | ||
3678 | // "count" "{" condition=Expression "}"; | ||
3679 | public CountElements getCountAccess() { | ||
3680 | return pCount; | ||
3681 | } | ||
3682 | |||
3683 | public ParserRule getCountRule() { | ||
3684 | return getCountAccess().getRule(); | ||
3685 | } | ||
3686 | |||
3687 | //AtomicExpression Expression: | ||
3688 | // Reference | Call | Interval | Literal | "(" Expression ")"; | ||
3689 | public AtomicExpressionElements getAtomicExpressionAccess() { | ||
3690 | return pAtomicExpression; | ||
3691 | } | ||
3692 | |||
3693 | public ParserRule getAtomicExpressionRule() { | ||
3694 | return getAtomicExpressionAccess().getRule(); | ||
3695 | } | ||
3696 | |||
3697 | //Call: | ||
3698 | // functor=Reference argumentList=ArgumentList; | ||
3699 | public CallElements getCallAccess() { | ||
3700 | return pCall; | ||
3701 | } | ||
3702 | |||
3703 | public ParserRule getCallRule() { | ||
3704 | return getCallAccess().getRule(); | ||
3705 | } | ||
3706 | |||
3707 | //ArgumentList: | ||
3708 | // {ArgumentList} "(" (arguments+=Argument ("," arguments+=Argument)*)? ")"; | ||
3709 | public ArgumentListElements getArgumentListAccess() { | ||
3710 | return pArgumentList; | ||
3711 | } | ||
3712 | |||
3713 | public ParserRule getArgumentListRule() { | ||
3714 | return getArgumentListAccess().getRule(); | ||
3715 | } | ||
3716 | |||
3717 | //Argument: | ||
3718 | // ExpressionArgument | StarArgument | TypedVariableArgument | TypedStarArgument; | ||
3719 | public ArgumentElements getArgumentAccess() { | ||
3720 | return pArgument; | ||
3721 | } | ||
3722 | |||
3723 | public ParserRule getArgumentRule() { | ||
3724 | return getArgumentAccess().getRule(); | ||
3725 | } | ||
3726 | |||
3727 | //ExpressionArgument: | ||
3728 | // expression=ComparisonExpression; | ||
3729 | public ExpressionArgumentElements getExpressionArgumentAccess() { | ||
3730 | return pExpressionArgument; | ||
3731 | } | ||
3732 | |||
3733 | public ParserRule getExpressionArgumentRule() { | ||
3734 | return getExpressionArgumentAccess().getRule(); | ||
3735 | } | ||
3736 | |||
3737 | //StarArgument: | ||
3738 | // {StarArgument} "*"; | ||
3739 | public StarArgumentElements getStarArgumentAccess() { | ||
3740 | return pStarArgument; | ||
3741 | } | ||
3742 | |||
3743 | public ParserRule getStarArgumentRule() { | ||
3744 | return getStarArgumentAccess().getRule(); | ||
3745 | } | ||
3746 | |||
3747 | //TypedVariableArgument: | ||
3748 | // typeReference=TypeReference name=ID; | ||
3749 | public TypedVariableArgumentElements getTypedVariableArgumentAccess() { | ||
3750 | return pTypedVariableArgument; | ||
3751 | } | ||
3752 | |||
3753 | public ParserRule getTypedVariableArgumentRule() { | ||
3754 | return getTypedVariableArgumentAccess().getRule(); | ||
3755 | } | ||
3756 | |||
3757 | //TypedStarArgument: | ||
3758 | // typeReference=TypeReference "*"; | ||
3759 | public TypedStarArgumentElements getTypedStarArgumentAccess() { | ||
3760 | return pTypedStarArgument; | ||
3761 | } | ||
3762 | |||
3763 | public ParserRule getTypedStarArgumentRule() { | ||
3764 | return getTypedStarArgumentAccess().getRule(); | ||
3765 | } | ||
3766 | |||
3767 | //Reference: | ||
3768 | // components+=PathComponent ("." components+=PathComponent)*; | ||
3769 | public ReferenceElements getReferenceAccess() { | ||
3770 | return pReference; | ||
3771 | } | ||
3772 | |||
3773 | public ParserRule getReferenceRule() { | ||
3774 | return getReferenceAccess().getRule(); | ||
3775 | } | ||
3776 | |||
3777 | //PathComponent: | ||
3778 | // inverse?="~"? symbol=[Symbol|QualifiedName] (transitiveClosure?=TRANSITIVE_CLOSURE | | ||
3779 | // reflexiveTransitiveClosure?=REFLEXIVE_TRANSITIVE_CLOSURE)?; | ||
3780 | public PathComponentElements getPathComponentAccess() { | ||
3781 | return pPathComponent; | ||
3782 | } | ||
3783 | |||
3784 | public ParserRule getPathComponentRule() { | ||
3785 | return getPathComponentAccess().getRule(); | ||
3786 | } | ||
3787 | |||
3788 | //Interval: | ||
3789 | // "[" lowerBound=AdditiveExpression "," upperBound=AdditiveExpression "]"; | ||
3790 | public IntervalElements getIntervalAccess() { | ||
3791 | return pInterval; | ||
3792 | } | ||
3793 | |||
3794 | public ParserRule getIntervalRule() { | ||
3795 | return getIntervalAccess().getRule(); | ||
3796 | } | ||
3797 | |||
3798 | //Literal: | ||
3799 | // LogicLiteral | IntLiteral | RealLiteral | InfinityLiteral | EmptyLiteral | StringLiteral; | ||
3800 | public LiteralElements getLiteralAccess() { | ||
3801 | return pLiteral; | ||
3802 | } | ||
3803 | |||
3804 | public ParserRule getLiteralRule() { | ||
3805 | return getLiteralAccess().getRule(); | ||
3806 | } | ||
3807 | |||
3808 | //enum LogicValue: | ||
3809 | // TRUE="true" | FALSE="false" | UNKNOWN="unknown" | ERROR="error"; | ||
3810 | public LogicValueElements getLogicValueAccess() { | ||
3811 | return eLogicValue; | ||
3812 | } | ||
3813 | |||
3814 | public EnumRule getLogicValueRule() { | ||
3815 | return getLogicValueAccess().getRule(); | ||
3816 | } | ||
3817 | |||
3818 | //LogicLiteral: | ||
3819 | // value=LogicValue; | ||
3820 | public LogicLiteralElements getLogicLiteralAccess() { | ||
3821 | return pLogicLiteral; | ||
3822 | } | ||
3823 | |||
3824 | public ParserRule getLogicLiteralRule() { | ||
3825 | return getLogicLiteralAccess().getRule(); | ||
3826 | } | ||
3827 | |||
3828 | //IntLiteral: | ||
3829 | // value=INT; | ||
3830 | public IntLiteralElements getIntLiteralAccess() { | ||
3831 | return pIntLiteral; | ||
3832 | } | ||
3833 | |||
3834 | public ParserRule getIntLiteralRule() { | ||
3835 | return getIntLiteralAccess().getRule(); | ||
3836 | } | ||
3837 | |||
3838 | //RealLiteral: | ||
3839 | // value=Real; | ||
3840 | public RealLiteralElements getRealLiteralAccess() { | ||
3841 | return pRealLiteral; | ||
3842 | } | ||
3843 | |||
3844 | public ParserRule getRealLiteralRule() { | ||
3845 | return getRealLiteralAccess().getRule(); | ||
3846 | } | ||
3847 | |||
3848 | //InfinityLiteral: | ||
3849 | // {InfinityLiteral} "inf"; | ||
3850 | public InfinityLiteralElements getInfinityLiteralAccess() { | ||
3851 | return pInfinityLiteral; | ||
3852 | } | ||
3853 | |||
3854 | public ParserRule getInfinityLiteralRule() { | ||
3855 | return getInfinityLiteralAccess().getRule(); | ||
3856 | } | ||
3857 | |||
3858 | //EmptyLiteral: | ||
3859 | // {EmptyLiteral} "empty"; | ||
3860 | public EmptyLiteralElements getEmptyLiteralAccess() { | ||
3861 | return pEmptyLiteral; | ||
3862 | } | ||
3863 | |||
3864 | public ParserRule getEmptyLiteralRule() { | ||
3865 | return getEmptyLiteralAccess().getRule(); | ||
3866 | } | ||
3867 | |||
3868 | //StringLiteral: | ||
3869 | // value=STRING; | ||
3870 | public StringLiteralElements getStringLiteralAccess() { | ||
3871 | return pStringLiteral; | ||
3872 | } | ||
3873 | |||
3874 | public ParserRule getStringLiteralRule() { | ||
3875 | return getStringLiteralAccess().getRule(); | ||
3876 | } | ||
3877 | |||
3878 | //ClassDeclaration: | ||
3879 | // (abstract?="abstract"? & root?="root"?) "class" name=ID ("extends" supertypes+=[Symbol|QualifiedName] ("," | ||
3880 | // supertypes+=[Symbol|QualifiedName])*)? ("{" fields+=Field* "}" | FULL_STOP); | ||
3881 | public ClassDeclarationElements getClassDeclarationAccess() { | ||
3882 | return pClassDeclaration; | ||
3883 | } | ||
3884 | |||
3885 | public ParserRule getClassDeclarationRule() { | ||
3886 | return getClassDeclarationAccess().getRule(); | ||
3887 | } | ||
3888 | |||
3889 | //Field: | ||
3890 | // (containment?="contains" | crossReference?="refers")? type=[Symbol|QualifiedName] multiplicity=Multiplicity? | ||
3891 | // name=ID ("opposite" opposite=[Symbol|QualifiedName])? ";"?; | ||
3892 | public FieldElements getFieldAccess() { | ||
3893 | return pField; | ||
3894 | } | ||
3895 | |||
3896 | public ParserRule getFieldRule() { | ||
3897 | return getFieldAccess().getRule(); | ||
3898 | } | ||
3899 | |||
3900 | //Multiplicity: | ||
3901 | // UnboundedMultiplicity | ExactMultiplicity | BoundedMultiplicity; | ||
3902 | public MultiplicityElements getMultiplicityAccess() { | ||
3903 | return pMultiplicity; | ||
3904 | } | ||
3905 | |||
3906 | public ParserRule getMultiplicityRule() { | ||
3907 | return getMultiplicityAccess().getRule(); | ||
3908 | } | ||
3909 | |||
3910 | //UnboundedMultiplicity: | ||
3911 | // {UnboundedMultiplicity} "[" "]"; | ||
3912 | public UnboundedMultiplicityElements getUnboundedMultiplicityAccess() { | ||
3913 | return pUnboundedMultiplicity; | ||
3914 | } | ||
3915 | |||
3916 | public ParserRule getUnboundedMultiplicityRule() { | ||
3917 | return getUnboundedMultiplicityAccess().getRule(); | ||
3918 | } | ||
3919 | |||
3920 | //ExactMultiplicity: | ||
3921 | // "[" value=UpperMultiplicty "]"; | ||
3922 | public ExactMultiplicityElements getExactMultiplicityAccess() { | ||
3923 | return pExactMultiplicity; | ||
3924 | } | ||
3925 | |||
3926 | public ParserRule getExactMultiplicityRule() { | ||
3927 | return getExactMultiplicityAccess().getRule(); | ||
3928 | } | ||
3929 | |||
3930 | //BoundedMultiplicity: | ||
3931 | // "[" lowerBound=INT "," upperBound=UpperMultiplicty "]"; | ||
3932 | public BoundedMultiplicityElements getBoundedMultiplicityAccess() { | ||
3933 | return pBoundedMultiplicity; | ||
3934 | } | ||
3935 | |||
3936 | public ParserRule getBoundedMultiplicityRule() { | ||
3937 | return getBoundedMultiplicityAccess().getRule(); | ||
3938 | } | ||
3939 | |||
3940 | //EnumDeclaration: | ||
3941 | // "enum" name=ID ("{" (literals+=EnumLiteral (","? literals+=EnumLiteral)*)? "}" | FULL_STOP); | ||
3942 | public EnumDeclarationElements getEnumDeclarationAccess() { | ||
3943 | return pEnumDeclaration; | ||
3944 | } | ||
3945 | |||
3946 | public ParserRule getEnumDeclarationRule() { | ||
3947 | return getEnumDeclarationAccess().getRule(); | ||
3948 | } | ||
3949 | |||
3950 | //EnumLiteral: | ||
3951 | // name=ID; | ||
3952 | public EnumLiteralElements getEnumLiteralAccess() { | ||
3953 | return pEnumLiteral; | ||
3954 | } | ||
3955 | |||
3956 | public ParserRule getEnumLiteralRule() { | ||
3957 | return getEnumLiteralAccess().getRule(); | ||
3958 | } | ||
3959 | |||
3960 | //ScopeDeclaration: | ||
3961 | // ExactScope | BoundedScope | LowerBoundedScope; | ||
3962 | public ScopeDeclarationElements getScopeDeclarationAccess() { | ||
3963 | return pScopeDeclaration; | ||
3964 | } | ||
3965 | |||
3966 | public ParserRule getScopeDeclarationRule() { | ||
3967 | return getScopeDeclarationAccess().getRule(); | ||
3968 | } | ||
3969 | |||
3970 | //ExactScope: | ||
3971 | // "scope" type=[Symbol|QualifiedName] "==" size=INT FULL_STOP; | ||
3972 | public ExactScopeElements getExactScopeAccess() { | ||
3973 | return pExactScope; | ||
3974 | } | ||
3975 | |||
3976 | public ParserRule getExactScopeRule() { | ||
3977 | return getExactScopeAccess().getRule(); | ||
3978 | } | ||
3979 | |||
3980 | //BoundedScope: | ||
3981 | // "scope" ((lowerBound=INT "<=")? type=[Symbol|QualifiedName] "<=" upperBound=INT | upperBound=INT ">=" | ||
3982 | // type=[Symbol|QualifiedName] (">=" lowerBound=INT)?) FULL_STOP; | ||
3983 | public BoundedScopeElements getBoundedScopeAccess() { | ||
3984 | return pBoundedScope; | ||
3985 | } | ||
3986 | |||
3987 | public ParserRule getBoundedScopeRule() { | ||
3988 | return getBoundedScopeAccess().getRule(); | ||
3989 | } | ||
3990 | |||
3991 | //LowerBoundedScope: | ||
3992 | // "scope" (lowerBound=INT "<=" type=[Symbol|QualifiedName] | type=[Symbol|QualifiedName] ">=" lowerBound=INT) | ||
3993 | // FULL_STOP; | ||
3994 | public LowerBoundedScopeElements getLowerBoundedScopeAccess() { | ||
3995 | return pLowerBoundedScope; | ||
3996 | } | ||
3997 | |||
3998 | public ParserRule getLowerBoundedScopeRule() { | ||
3999 | return getLowerBoundedScopeAccess().getRule(); | ||
4000 | } | ||
4001 | |||
4002 | //enum ObjectiveKind: | ||
4003 | // MINIMIZATION="minimize" | MAXIMIZATION="maximize"; | ||
4004 | public ObjectiveKindElements getObjectiveKindAccess() { | ||
4005 | return eObjectiveKind; | ||
4006 | } | ||
4007 | |||
4008 | public EnumRule getObjectiveKindRule() { | ||
4009 | return getObjectiveKindAccess().getRule(); | ||
4010 | } | ||
4011 | |||
4012 | //ObjectiveDeclaration: | ||
4013 | // kind=ObjectiveKind objective=Expression FULL_STOP; | ||
4014 | public ObjectiveDeclarationElements getObjectiveDeclarationAccess() { | ||
4015 | return pObjectiveDeclaration; | ||
4016 | } | ||
4017 | |||
4018 | public ParserRule getObjectiveDeclarationRule() { | ||
4019 | return getObjectiveDeclarationAccess().getRule(); | ||
4020 | } | ||
4021 | |||
4022 | //UpperMultiplicty ecore::EInt: | ||
4023 | // INT | "*"; | ||
4024 | public UpperMultiplictyElements getUpperMultiplictyAccess() { | ||
4025 | return pUpperMultiplicty; | ||
4026 | } | ||
4027 | |||
4028 | public ParserRule getUpperMultiplictyRule() { | ||
4029 | return getUpperMultiplictyAccess().getRule(); | ||
4030 | } | ||
4031 | |||
4032 | //Real ecore::EBigDecimal hidden(): | ||
4033 | // INT "." INT; | ||
4034 | public RealElements getRealAccess() { | ||
4035 | return pReal; | ||
4036 | } | ||
4037 | |||
4038 | public ParserRule getRealRule() { | ||
4039 | return getRealAccess().getRule(); | ||
4040 | } | ||
4041 | |||
4042 | //QualifiedNameSegment: | ||
4043 | // ID | QUOTED_ID | "object"; | ||
4044 | public QualifiedNameSegmentElements getQualifiedNameSegmentAccess() { | ||
4045 | return pQualifiedNameSegment; | ||
4046 | } | ||
4047 | |||
4048 | public ParserRule getQualifiedNameSegmentRule() { | ||
4049 | return getQualifiedNameSegmentAccess().getRule(); | ||
4050 | } | ||
4051 | |||
4052 | //QualifiedName hidden(): | ||
4053 | // QualifiedNameSegment ("::" QualifiedNameSegment)*; | ||
4054 | public QualifiedNameElements getQualifiedNameAccess() { | ||
4055 | return pQualifiedName; | ||
4056 | } | ||
4057 | |||
4058 | public ParserRule getQualifiedNameRule() { | ||
4059 | return getQualifiedNameAccess().getRule(); | ||
4060 | } | ||
4061 | |||
4062 | //@Override | ||
4063 | //terminal STRING: | ||
4064 | // '"' ('\\' . | !('\\' | '"'))* '"'; | ||
4065 | public TerminalRule getSTRINGRule() { | ||
4066 | return tSTRING; | ||
4067 | } | ||
4068 | |||
4069 | //terminal QUOTED_ID: | ||
4070 | // '\'' ('\\' . | !('\\' | '\''))* '\''; | ||
4071 | public TerminalRule getQUOTED_IDRule() { | ||
4072 | return tQUOTED_ID; | ||
4073 | } | ||
4074 | |||
4075 | //@Override | ||
4076 | //terminal SL_COMMENT: | ||
4077 | // ('%' | '//') !('\n' | '\r')* ('\r'? '\n')?; | ||
4078 | public TerminalRule getSL_COMMENTRule() { | ||
4079 | return tSL_COMMENT; | ||
4080 | } | ||
4081 | |||
4082 | //terminal TRANSITIVE_CLOSURE: | ||
4083 | // "synthetic:TRANSITIVE_CLOSURE"; | ||
4084 | public TerminalRule getTRANSITIVE_CLOSURERule() { | ||
4085 | return tTRANSITIVE_CLOSURE; | ||
4086 | } | ||
4087 | |||
4088 | //terminal REFLEXIVE_TRANSITIVE_CLOSURE: | ||
4089 | // "synthetic:REFLEXIVE_TRANSITIVE_CLOSURE"; | ||
4090 | public TerminalRule getREFLEXIVE_TRANSITIVE_CLOSURERule() { | ||
4091 | return tREFLEXIVE_TRANSITIVE_CLOSURE; | ||
4092 | } | ||
4093 | |||
4094 | //terminal FULL_STOP: | ||
4095 | // "synthetic:FULL_STOP"; | ||
4096 | public TerminalRule getFULL_STOPRule() { | ||
4097 | return tFULL_STOP; | ||
4098 | } | ||
4099 | |||
4100 | //terminal ID: | ||
4101 | // '^'? ('a'..'z' | 'A'..'Z' | '_') ('a'..'z' | 'A'..'Z' | '_' | '0'..'9')*; | ||
4102 | public TerminalRule getIDRule() { | ||
4103 | return gaTerminals.getIDRule(); | ||
4104 | } | ||
4105 | |||
4106 | //terminal INT returns ecore::EInt: | ||
4107 | // '0'..'9'+; | ||
4108 | public TerminalRule getINTRule() { | ||
4109 | return gaTerminals.getINTRule(); | ||
4110 | } | ||
4111 | |||
4112 | //terminal ML_COMMENT: | ||
4113 | // '/*'->'*/'; | ||
4114 | public TerminalRule getML_COMMENTRule() { | ||
4115 | return gaTerminals.getML_COMMENTRule(); | ||
4116 | } | ||
4117 | |||
4118 | //terminal WS: | ||
4119 | // ' ' | '\t' | '\r' | '\n'+; | ||
4120 | public TerminalRule getWSRule() { | ||
4121 | return gaTerminals.getWSRule(); | ||
4122 | } | ||
4123 | |||
4124 | //terminal ANY_OTHER: | ||
4125 | // .; | ||
4126 | public TerminalRule getANY_OTHERRule() { | ||
4127 | return gaTerminals.getANY_OTHERRule(); | ||
4128 | } | ||
4129 | } | ||
diff --git a/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/validation/AbstractSolverLanguageValidator.java b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/validation/AbstractSolverLanguageValidator.java new file mode 100644 index 00000000..1bcc7538 --- /dev/null +++ b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/validation/AbstractSolverLanguageValidator.java | |||
@@ -0,0 +1,19 @@ | |||
1 | /* | ||
2 | * generated by Xtext 2.21.0 | ||
3 | */ | ||
4 | package org.eclipse.viatra.solver.language.validation; | ||
5 | |||
6 | import java.util.ArrayList; | ||
7 | import java.util.List; | ||
8 | import org.eclipse.emf.ecore.EPackage; | ||
9 | import org.eclipse.xtext.validation.AbstractDeclarativeValidator; | ||
10 | |||
11 | public abstract class AbstractSolverLanguageValidator extends AbstractDeclarativeValidator { | ||
12 | |||
13 | @Override | ||
14 | protected List<EPackage> getEPackages() { | ||
15 | List<EPackage> result = new ArrayList<EPackage>(); | ||
16 | result.add(EPackage.Registry.INSTANCE.getEPackage("http://www.eclipse.org/viatra/solver/language/SolverLanguage")); | ||
17 | return result; | ||
18 | } | ||
19 | } | ||
diff --git a/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/validation/SolverLanguageConfigurableIssueCodesProvider.java b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/validation/SolverLanguageConfigurableIssueCodesProvider.java new file mode 100644 index 00000000..a229cb60 --- /dev/null +++ b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/validation/SolverLanguageConfigurableIssueCodesProvider.java | |||
@@ -0,0 +1,22 @@ | |||
1 | /* | ||
2 | * generated by Xtext 2.21.0 | ||
3 | */ | ||
4 | package org.eclipse.viatra.solver.language.validation; | ||
5 | |||
6 | import org.eclipse.xtext.preferences.PreferenceKey; | ||
7 | import org.eclipse.xtext.util.IAcceptor; | ||
8 | import org.eclipse.xtext.validation.ConfigurableIssueCodesProvider; | ||
9 | import org.eclipse.xtext.validation.SeverityConverter; | ||
10 | |||
11 | @SuppressWarnings("restriction") | ||
12 | public class SolverLanguageConfigurableIssueCodesProvider extends ConfigurableIssueCodesProvider { | ||
13 | protected static final String ISSUE_CODE_PREFIX = "org.eclipse.viatra.solver.language."; | ||
14 | |||
15 | public static final String DEPRECATED_MODEL_PART = ISSUE_CODE_PREFIX + "deprecatedModelPart"; | ||
16 | |||
17 | @Override | ||
18 | protected void initialize(IAcceptor<PreferenceKey> acceptor) { | ||
19 | super.initialize(acceptor); | ||
20 | acceptor.accept(create(DEPRECATED_MODEL_PART, SeverityConverter.SEVERITY_WARNING)); | ||
21 | } | ||
22 | } | ||
diff --git a/Application/org.eclipse.viatra.solver.language/src/org/eclipse/viatra/solver/language/GenerateSolverLanguage.mwe2 b/Application/org.eclipse.viatra.solver.language/src/org/eclipse/viatra/solver/language/GenerateSolverLanguage.mwe2 new file mode 100644 index 00000000..644e681d --- /dev/null +++ b/Application/org.eclipse.viatra.solver.language/src/org/eclipse/viatra/solver/language/GenerateSolverLanguage.mwe2 | |||
@@ -0,0 +1,50 @@ | |||
1 | module org.eclipse.viatra.solver.language.GenerateSolverLanguage | ||
2 | |||
3 | import org.eclipse.xtext.xtext.generator.* | ||
4 | import org.eclipse.xtext.xtext.generator.model.project.* | ||
5 | |||
6 | var rootPath = ".." | ||
7 | |||
8 | Workflow { | ||
9 | |||
10 | component = XtextGenerator { | ||
11 | configuration = { | ||
12 | project = StandardProjectConfig { | ||
13 | baseName = "org.eclipse.viatra.solver.language" | ||
14 | rootPath = rootPath | ||
15 | runtimeTest = { | ||
16 | enabled = true | ||
17 | } | ||
18 | eclipsePlugin = { | ||
19 | enabled = true | ||
20 | } | ||
21 | eclipsePluginTest = { | ||
22 | enabled = true | ||
23 | } | ||
24 | createEclipseMetaData = true | ||
25 | } | ||
26 | code = { | ||
27 | encoding = "UTF-8" | ||
28 | lineDelimiter = "\r\n" | ||
29 | fileHeader = "/*\n * generated by Xtext \${version}\n */" | ||
30 | } | ||
31 | } | ||
32 | language = StandardLanguage { | ||
33 | name = "org.eclipse.viatra.solver.language.SolverLanguage" | ||
34 | fileExtensions = "vsc" | ||
35 | referencedResource = "platform:/resource/org.eclipse.viatra.solver.language.model/model/model.genmodel" | ||
36 | |||
37 | serializer = { | ||
38 | generateStub = false | ||
39 | } | ||
40 | validator = { | ||
41 | // composedCheck = "org.eclipse.xtext.validation.NamesAreUniqueValidator" | ||
42 | // Generates checks for @Deprecated grammar annotations, an IssueProvider and a corresponding PropertyPage | ||
43 | generateDeprecationValidation = true | ||
44 | } | ||
45 | junitSupport = { | ||
46 | junitVersion = "5" | ||
47 | } | ||
48 | } | ||
49 | } | ||
50 | } | ||
diff --git a/Application/org.eclipse.viatra.solver.language/src/org/eclipse/viatra/solver/language/SolverLanguage.xtext b/Application/org.eclipse.viatra.solver.language/src/org/eclipse/viatra/solver/language/SolverLanguage.xtext new file mode 100644 index 00000000..51115da0 --- /dev/null +++ b/Application/org.eclipse.viatra.solver.language/src/org/eclipse/viatra/solver/language/SolverLanguage.xtext | |||
@@ -0,0 +1,274 @@ | |||
1 | grammar org.eclipse.viatra.solver.language.SolverLanguage with org.eclipse.xtext.common.Terminals | ||
2 | import "http://www.eclipse.org/emf/2002/Ecore" as ecore | ||
3 | import "http://www.eclipse.org/viatra/solver/language/SolverLanguage" | ||
4 | |||
5 | Problem: | ||
6 | ("problem" name=QualifiedName FULL_STOP)? | ||
7 | imports+=Import* | ||
8 | statements+=Statement*; | ||
9 | |||
10 | Statement: | ||
11 | ( | ||
12 | AssertionOrDefinition | PredicateDefinition | UnnamedErrorPredicateDefintion | DefaultAssertion | | ||
13 | FunctionDefinition | Attribute | ExternDeclaration | ScopeDeclaration | ObjectiveDeclaration | | ||
14 | ClassDeclaration | EnumDeclaration | ||
15 | ); | ||
16 | |||
17 | Import: | ||
18 | UriImport | NamespaceImport; | ||
19 | |||
20 | UriImport: | ||
21 | "import" uri=STRING ("as" alias=QualifiedName) FULL_STOP; | ||
22 | |||
23 | NamespaceImport: | ||
24 | "import" importedNamespace=QualifiedName ("as" alias=QualifiedName) FULL_STOP; | ||
25 | |||
26 | AssertionOrDefinition returns Statement: | ||
27 | Expression ( | ||
28 | {Assertion.expression=current} (":" range=Expression)? | | ||
29 | {PredicateDefinition.head=current} ":-" body=Expression | | ||
30 | {FunctionDefinition.head=current} ":=" body=Expression | ||
31 | ) FULL_STOP; | ||
32 | |||
33 | PredicateDefinition: | ||
34 | (functional?="functional" error?="error"? | error?="error" functional?="functional"?) head=Call ":-" body=Expression FULL_STOP; | ||
35 | |||
36 | UnnamedErrorPredicateDefintion: | ||
37 | "error" argumentList=ArgumentList ":-" body=Expression FULL_STOP; | ||
38 | |||
39 | DefaultAssertion: | ||
40 | "default" expression=Call (":" range=Expression)? FULL_STOP; | ||
41 | |||
42 | FunctionDefinition: | ||
43 | resultType=[Symbol|QualifiedName] head=Call ":=" body=Expression FULL_STOP; | ||
44 | |||
45 | TypeReference: | ||
46 | type=[Symbol|QualifiedName] forceObjectType?="object"?; | ||
47 | |||
48 | enum AttributeKind: | ||
49 | FUNCTIONAL="functional" | ERROR="error" | ROOT="root" | CONTAINMENT="containment"; | ||
50 | |||
51 | Attribute: | ||
52 | kind=AttributeKind target=[Symbol|QualifiedName] FULL_STOP; | ||
53 | |||
54 | ExternDeclaration: | ||
55 | ExternPredicateDeclaration | ExternFunctionDeclaration | ExternAggregationOperatorDeclaration | ExternDatatypeDeclaration; | ||
56 | |||
57 | ExternPredicateDeclaration: | ||
58 | "extern" (functional?="functional"? & error?="error"?) name=QualifiedName argumentList=ArgumentList FULL_STOP; | ||
59 | |||
60 | ExternFunctionDeclaration: | ||
61 | "extern" resultType=[Symbol|QualifiedName] name=QualifiedName argumentList=ArgumentList FULL_STOP; | ||
62 | |||
63 | ExternAggregationOperatorDeclaration: | ||
64 | "extern" resultType=[Symbol|QualifiedName] name=QualifiedName "{" argumentType=[Symbol|QualifiedName] "..." "}" FULL_STOP; | ||
65 | |||
66 | ExternDatatypeDeclaration: | ||
67 | "extern" "datatype" name=QualifiedName FULL_STOP; | ||
68 | |||
69 | Expression: | ||
70 | ConditionalExpression | LetExpression | DisjunctiveExpression ({Forall.condition=current} "=>" body=DisjunctiveExpression)?; | ||
71 | |||
72 | ConditionalExpression: | ||
73 | "if" condition=DisjunctiveExpression "then" then=Expression "else" else=Expression; | ||
74 | |||
75 | LetExpression: | ||
76 | "let" bindings+=LetBinding ("," bindings+=LetBinding)* "in" body=Expression; | ||
77 | |||
78 | LetBinding: | ||
79 | type=[Symbol|QualifiedName]? name=ID "=" value=AdditiveExpression; | ||
80 | |||
81 | DisjunctiveExpression returns Expression: | ||
82 | ConjunctiveExpression ( | ||
83 | {Disjunction.children+=current} (";" children+=ConjunctiveExpression)+ | | ||
84 | {Case.condition=current} "->" body=ConjunctiveExpression {Switch.cases+=current} (";" cases+=Case)* | ||
85 | )?; | ||
86 | |||
87 | Case: | ||
88 | condition=ConjunctiveExpression "->" body=ConjunctiveExpression; | ||
89 | |||
90 | ConjunctiveExpression returns Expression: | ||
91 | ComparisonExpression ({Conjunction.children+=current} ("," children+=ComparisonExpression)+)?; | ||
92 | |||
93 | enum ComparisonOperator returns BinaryOperator: | ||
94 | EQUALS="==" | NOT_EQUALS="!=" | LESS="<" | LESS_EQUALS="<=" | GREATER=">" | GREATER_EQUALS=">=" | IN="in"; | ||
95 | |||
96 | ComparisonExpression returns Expression: | ||
97 | AdditiveExpression ({BinaryExpression.left=current} op=ComparisonOperator right=AdditiveExpression)?; | ||
98 | |||
99 | enum AdditiveBinaryOperator returns BinaryOperator: | ||
100 | PLUS="+" | MINUS="-"; | ||
101 | |||
102 | AdditiveExpression returns Expression: | ||
103 | MultiplicativeExpression ({BinaryExpression.left=current} op=AdditiveBinaryOperator right=MultiplicativeExpression)*; | ||
104 | |||
105 | enum MultiplicativeBinaryOperator returns BinaryOperator: | ||
106 | MULTIPLY="*" | DIVIDE="/"; | ||
107 | |||
108 | MultiplicativeExpression returns Expression: | ||
109 | ExponentialExpression ({BinaryExpression.left=current} op=MultiplicativeBinaryOperator right=ExponentialExpression)*; | ||
110 | |||
111 | enum ExponentialOp returns BinaryOperator: | ||
112 | POW="^"; | ||
113 | |||
114 | ExponentialExpression returns Expression: | ||
115 | CastExpression ({BinaryExpression.left=current} op=ExponentialOp right=CastExpression)?; | ||
116 | |||
117 | CastExpression returns Expression: | ||
118 | UnaryExpression ({CastExpression.body=current} "as" targetType=[Symbol|QualifiedName])?; | ||
119 | |||
120 | enum UnaryOperator: | ||
121 | NOT="!" | PLUS="+" | MINUS="-" | MAYBE="?"; | ||
122 | |||
123 | UnaryExpression returns Expression: | ||
124 | BracedAggregateExpression | {UnaryExpression} op=UnaryOperator body=BracedAggregateExpression; | ||
125 | |||
126 | BracedAggregateExpression returns Expression: | ||
127 | AtomicExpression | Aggregation | Count ; | ||
128 | |||
129 | Aggregation: | ||
130 | op=[Symbol|QualifiedName] "{" value=Expression "|" condition=Expression "}"; | ||
131 | |||
132 | Count: | ||
133 | "count" "{" condition=Expression "}"; | ||
134 | |||
135 | AtomicExpression returns Expression: | ||
136 | Reference | Call | Interval | Literal | "(" Expression ")"; | ||
137 | |||
138 | Call: | ||
139 | functor=Reference argumentList=ArgumentList; | ||
140 | |||
141 | ArgumentList: | ||
142 | {ArgumentList} "(" (arguments+=Argument ("," arguments+=Argument)*)? ")"; | ||
143 | |||
144 | Argument: | ||
145 | ExpressionArgument | StarArgument | TypedVariableArgument | TypedStarArgument; | ||
146 | |||
147 | ExpressionArgument: | ||
148 | expression=ComparisonExpression; | ||
149 | |||
150 | StarArgument: | ||
151 | {StarArgument} "*"; | ||
152 | |||
153 | TypedVariableArgument: | ||
154 | typeReference=TypeReference name=ID; | ||
155 | |||
156 | TypedStarArgument: | ||
157 | typeReference=TypeReference "*"; | ||
158 | |||
159 | Reference: | ||
160 | components+=PathComponent ("." components+=PathComponent)*; | ||
161 | |||
162 | PathComponent: | ||
163 | inverse?="~"? symbol=[Symbol|QualifiedName] | ||
164 | (transitiveClosure?=TRANSITIVE_CLOSURE | reflexiveTransitiveClosure?=REFLEXIVE_TRANSITIVE_CLOSURE)?; | ||
165 | |||
166 | Interval: | ||
167 | "[" lowerBound=AdditiveExpression "," upperBound=AdditiveExpression "]"; | ||
168 | |||
169 | Literal: | ||
170 | LogicLiteral | IntLiteral | RealLiteral | InfinityLiteral | EmptyLiteral | StringLiteral; | ||
171 | |||
172 | enum LogicValue: | ||
173 | TRUE="true" | FALSE="false" | UNKNOWN="unknown" | ERROR="error"; | ||
174 | |||
175 | LogicLiteral: | ||
176 | value=LogicValue; | ||
177 | |||
178 | IntLiteral: | ||
179 | value=INT; | ||
180 | |||
181 | RealLiteral: | ||
182 | value=Real; | ||
183 | |||
184 | InfinityLiteral: | ||
185 | {InfinityLiteral} "inf"; | ||
186 | |||
187 | EmptyLiteral: | ||
188 | {EmptyLiteral} "empty"; | ||
189 | |||
190 | StringLiteral: | ||
191 | value=STRING; | ||
192 | |||
193 | ClassDeclaration: | ||
194 | (abstract?="abstract"? & root?="root"?) "class" name=ID ("extends" supertypes+=[Symbol|QualifiedName] ("," supertypes+=[Symbol|QualifiedName])*)? | ||
195 | ("{" fields+=Field* "}" | FULL_STOP); | ||
196 | |||
197 | Field: | ||
198 | (containment?="contains" | crossReference?="refers")? type=[Symbol|QualifiedName] multiplicity=Multiplicity? | ||
199 | name=ID ("opposite" opposite=[Symbol|QualifiedName])? ";"?; | ||
200 | |||
201 | Multiplicity: | ||
202 | UnboundedMultiplicity | ExactMultiplicity | BoundedMultiplicity; | ||
203 | |||
204 | UnboundedMultiplicity: | ||
205 | {UnboundedMultiplicity} "[" "]"; | ||
206 | |||
207 | ExactMultiplicity: | ||
208 | "[" value=UpperMultiplicty "]"; | ||
209 | |||
210 | BoundedMultiplicity: | ||
211 | "[" lowerBound=INT "," upperBound=UpperMultiplicty "]"; | ||
212 | |||
213 | EnumDeclaration: | ||
214 | "enum" name=ID ("{" (literals+=EnumLiteral (","? literals+=EnumLiteral)*)? "}" | FULL_STOP); | ||
215 | |||
216 | EnumLiteral: | ||
217 | name=ID; | ||
218 | |||
219 | ScopeDeclaration: | ||
220 | ExactScope | BoundedScope | LowerBoundedScope; | ||
221 | |||
222 | ExactScope: | ||
223 | "scope" type=[Symbol|QualifiedName] "==" size=INT FULL_STOP; | ||
224 | |||
225 | BoundedScope: | ||
226 | "scope" ( | ||
227 | (lowerBound=INT "<=")? type=[Symbol|QualifiedName] "<=" upperBound=INT | | ||
228 | upperBound=INT ">=" type=[Symbol|QualifiedName] (">=" lowerBound=INT)? | ||
229 | ) FULL_STOP; | ||
230 | |||
231 | LowerBoundedScope: | ||
232 | "scope" ( | ||
233 | lowerBound=INT "<=" type=[Symbol|QualifiedName] | | ||
234 | type=[Symbol|QualifiedName] ">=" lowerBound=INT | ||
235 | ) FULL_STOP; | ||
236 | |||
237 | enum ObjectiveKind: | ||
238 | MINIMIZATION="minimize" | MAXIMIZATION="maximize"; | ||
239 | |||
240 | ObjectiveDeclaration: | ||
241 | kind=ObjectiveKind objective=Expression FULL_STOP; | ||
242 | |||
243 | UpperMultiplicty returns ecore::EInt: | ||
244 | INT | "*"; | ||
245 | |||
246 | Real returns ecore::EBigDecimal hidden(): | ||
247 | INT "." INT; | ||
248 | |||
249 | QualifiedNameSegment: | ||
250 | ID | QUOTED_ID | "object"; | ||
251 | |||
252 | QualifiedName hidden(): | ||
253 | QualifiedNameSegment ("::" QualifiedNameSegment)*; | ||
254 | |||
255 | @Override | ||
256 | terminal STRING returns ecore::EString: | ||
257 | '"' ( '\\' . /* 'b'|'t'|'n'|'f'|'r'|'u'|'"'|"'"|'\\' */ | !('\\'|'"') )* '"'; | ||
258 | |||
259 | terminal QUOTED_ID: | ||
260 | '\'' ( '\\' . /* 'b'|'t'|'n'|'f'|'r'|'u'|'"'|"'"|'\\' */ | !('\\'|'\'') )* '\''; | ||
261 | |||
262 | @Override | ||
263 | terminal SL_COMMENT: | ||
264 | ('%' | '//') !('\n'|'\r')* ('\r'? '\n')?; | ||
265 | |||
266 | terminal TRANSITIVE_CLOSURE: | ||
267 | "synthetic:TRANSITIVE_CLOSURE"; | ||
268 | |||
269 | terminal REFLEXIVE_TRANSITIVE_CLOSURE: | ||
270 | "synthetic:REFLEXIVE_TRANSITIVE_CLOSURE"; | ||
271 | |||
272 | terminal FULL_STOP: | ||
273 | "synthetic:FULL_STOP"; | ||
274 | |||
diff --git a/Application/org.eclipse.viatra.solver.language/src/org/eclipse/viatra/solver/language/SolverLanguageRuntimeModule.xtend b/Application/org.eclipse.viatra.solver.language/src/org/eclipse/viatra/solver/language/SolverLanguageRuntimeModule.xtend new file mode 100644 index 00000000..e882626b --- /dev/null +++ b/Application/org.eclipse.viatra.solver.language/src/org/eclipse/viatra/solver/language/SolverLanguageRuntimeModule.xtend | |||
@@ -0,0 +1,23 @@ | |||
1 | /* | ||
2 | * generated by Xtext 2.18.0.M3 | ||
3 | */ | ||
4 | package org.eclipse.viatra.solver.language | ||
5 | |||
6 | import org.eclipse.viatra.solver.language.parser.antlr.SolverLanguageTokenDefInjectingParser | ||
7 | import org.eclipse.viatra.solver.language.serializer.SolverLanguageSyntheticTokenSyntacticSequencer | ||
8 | |||
9 | /** | ||
10 | * Use this class to register components to be used at runtime / without the Equinox extension registry. | ||
11 | */ | ||
12 | class SolverLanguageRuntimeModule extends AbstractSolverLanguageRuntimeModule { | ||
13 | |||
14 | override bindIParser() { | ||
15 | SolverLanguageTokenDefInjectingParser | ||
16 | } | ||
17 | |||
18 | |||
19 | override bindISyntacticSequencer() { | ||
20 | SolverLanguageSyntheticTokenSyntacticSequencer | ||
21 | } | ||
22 | |||
23 | } | ||
diff --git a/Application/org.eclipse.viatra.solver.language/src/org/eclipse/viatra/solver/language/SolverLanguageStandaloneSetup.xtend b/Application/org.eclipse.viatra.solver.language/src/org/eclipse/viatra/solver/language/SolverLanguageStandaloneSetup.xtend new file mode 100644 index 00000000..1ce7b1d8 --- /dev/null +++ b/Application/org.eclipse.viatra.solver.language/src/org/eclipse/viatra/solver/language/SolverLanguageStandaloneSetup.xtend | |||
@@ -0,0 +1,15 @@ | |||
1 | /* | ||
2 | * generated by Xtext 2.18.0.M3 | ||
3 | */ | ||
4 | package org.eclipse.viatra.solver.language | ||
5 | |||
6 | |||
7 | /** | ||
8 | * Initialization support for running Xtext languages without Equinox extension registry. | ||
9 | */ | ||
10 | class SolverLanguageStandaloneSetup extends SolverLanguageStandaloneSetupGenerated { | ||
11 | |||
12 | def static void doSetup() { | ||
13 | new SolverLanguageStandaloneSetup().createInjectorAndDoEMFRegistration() | ||
14 | } | ||
15 | } | ||
diff --git a/Application/org.eclipse.viatra.solver.language/src/org/eclipse/viatra/solver/language/generator/SolverLanguageGenerator.xtend b/Application/org.eclipse.viatra.solver.language/src/org/eclipse/viatra/solver/language/generator/SolverLanguageGenerator.xtend new file mode 100644 index 00000000..0b8620e9 --- /dev/null +++ b/Application/org.eclipse.viatra.solver.language/src/org/eclipse/viatra/solver/language/generator/SolverLanguageGenerator.xtend | |||
@@ -0,0 +1,25 @@ | |||
1 | /* | ||
2 | * generated by Xtext 2.18.0.M3 | ||
3 | */ | ||
4 | package org.eclipse.viatra.solver.language.generator | ||
5 | |||
6 | import org.eclipse.emf.ecore.resource.Resource | ||
7 | import org.eclipse.xtext.generator.AbstractGenerator | ||
8 | import org.eclipse.xtext.generator.IFileSystemAccess2 | ||
9 | import org.eclipse.xtext.generator.IGeneratorContext | ||
10 | |||
11 | /** | ||
12 | * Generates code from your model files on save. | ||
13 | * | ||
14 | * See https://www.eclipse.org/Xtext/documentation/303_runtime_concepts.html#code-generation | ||
15 | */ | ||
16 | class SolverLanguageGenerator extends AbstractGenerator { | ||
17 | |||
18 | override void doGenerate(Resource resource, IFileSystemAccess2 fsa, IGeneratorContext context) { | ||
19 | // fsa.generateFile('greetings.txt', 'People to greet: ' + | ||
20 | // resource.allContents | ||
21 | // .filter(Greeting) | ||
22 | // .map[name] | ||
23 | // .join(', ')) | ||
24 | } | ||
25 | } | ||
diff --git a/Application/org.eclipse.viatra.solver.language/src/org/eclipse/viatra/solver/language/parser/antlr/SolverLanguageTokenDefInjectingParser.xtend b/Application/org.eclipse.viatra.solver.language/src/org/eclipse/viatra/solver/language/parser/antlr/SolverLanguageTokenDefInjectingParser.xtend new file mode 100644 index 00000000..87efd2b3 --- /dev/null +++ b/Application/org.eclipse.viatra.solver.language/src/org/eclipse/viatra/solver/language/parser/antlr/SolverLanguageTokenDefInjectingParser.xtend | |||
@@ -0,0 +1,16 @@ | |||
1 | package org.eclipse.viatra.solver.language.parser.antlr | ||
2 | |||
3 | import com.google.inject.Inject | ||
4 | import org.antlr.runtime.CharStream | ||
5 | import org.eclipse.xtext.parser.antlr.ITokenDefProvider | ||
6 | |||
7 | class SolverLanguageTokenDefInjectingParser extends SolverLanguageParser { | ||
8 | @Inject ITokenDefProvider tokenDefProvider | ||
9 | |||
10 | override protected createLexer(CharStream stream) { | ||
11 | val tokenSource = super.createLexer(stream) as SolverLanguageTokenSource | ||
12 | tokenSource.initializeTokenDefsFrom(tokenDefProvider) | ||
13 | tokenSource | ||
14 | } | ||
15 | |||
16 | } | ||
diff --git a/Application/org.eclipse.viatra.solver.language/src/org/eclipse/viatra/solver/language/parser/antlr/SolverLanguageTokenSource.java b/Application/org.eclipse.viatra.solver.language/src/org/eclipse/viatra/solver/language/parser/antlr/SolverLanguageTokenSource.java new file mode 100644 index 00000000..70e7e492 --- /dev/null +++ b/Application/org.eclipse.viatra.solver.language/src/org/eclipse/viatra/solver/language/parser/antlr/SolverLanguageTokenSource.java | |||
@@ -0,0 +1,145 @@ | |||
1 | /* | ||
2 | * generated by Xtext 2.21.0 | ||
3 | */ | ||
4 | package org.eclipse.viatra.solver.language.parser.antlr; | ||
5 | |||
6 | import static org.eclipse.viatra.solver.language.parser.antlr.internal.InternalSolverLanguageParser.RULE_FULL_STOP; | ||
7 | import static org.eclipse.viatra.solver.language.parser.antlr.internal.InternalSolverLanguageParser.RULE_ID; | ||
8 | import static org.eclipse.viatra.solver.language.parser.antlr.internal.InternalSolverLanguageParser.RULE_INT; | ||
9 | import static org.eclipse.viatra.solver.language.parser.antlr.internal.InternalSolverLanguageParser.RULE_ML_COMMENT; | ||
10 | import static org.eclipse.viatra.solver.language.parser.antlr.internal.InternalSolverLanguageParser.RULE_QUOTED_ID; | ||
11 | import static org.eclipse.viatra.solver.language.parser.antlr.internal.InternalSolverLanguageParser.RULE_REFLEXIVE_TRANSITIVE_CLOSURE; | ||
12 | import static org.eclipse.viatra.solver.language.parser.antlr.internal.InternalSolverLanguageParser.RULE_SL_COMMENT; | ||
13 | import static org.eclipse.viatra.solver.language.parser.antlr.internal.InternalSolverLanguageParser.RULE_TRANSITIVE_CLOSURE; | ||
14 | import static org.eclipse.viatra.solver.language.parser.antlr.internal.InternalSolverLanguageParser.RULE_WS; | ||
15 | |||
16 | import java.util.Map; | ||
17 | |||
18 | import org.antlr.runtime.Token; | ||
19 | import org.antlr.runtime.TokenSource; | ||
20 | import org.eclipse.xtext.parser.antlr.ITokenDefProvider; | ||
21 | import org.eclipse.xtext.parser.antlr.TokenAcceptor; | ||
22 | |||
23 | public class SolverLanguageTokenSource implements TokenSource { | ||
24 | private TokenSource delegate; | ||
25 | |||
26 | private final TokenAcceptor acceptor = new TokenAcceptor(); | ||
27 | |||
28 | private int lastTokenId = -1; | ||
29 | private int plusTokenId = -1; | ||
30 | private int starTokenId = -1; | ||
31 | private int dotTokenId = -1; | ||
32 | private int tildeTokenId = -1; | ||
33 | private int openParenTokenId = -1; | ||
34 | |||
35 | public SolverLanguageTokenSource(TokenSource delegate) { | ||
36 | this.delegate = delegate; | ||
37 | } | ||
38 | |||
39 | @Override | ||
40 | public String getSourceName() { | ||
41 | return "[SolverLanguageSyntheticTokenTokenSource] " + delegate.getSourceName(); | ||
42 | } | ||
43 | |||
44 | @Override | ||
45 | public Token nextToken() { | ||
46 | Token token; | ||
47 | if (acceptor.hasNext()) { | ||
48 | token = acceptor.next(); | ||
49 | } else { | ||
50 | token = delegate.nextToken(); | ||
51 | } | ||
52 | postProcessToken(token); | ||
53 | lastTokenId = token.getType(); | ||
54 | return token; | ||
55 | } | ||
56 | |||
57 | protected void postProcessToken(Token token) { | ||
58 | int type = token.getType(); | ||
59 | if (type == plusTokenId) { | ||
60 | if (isTransitiveClosureInReferenceContext()) { | ||
61 | token.setType(RULE_TRANSITIVE_CLOSURE); | ||
62 | } | ||
63 | } else if (type == starTokenId) { | ||
64 | if (isTransitiveClosureInReferenceContext()) { | ||
65 | token.setType(RULE_REFLEXIVE_TRANSITIVE_CLOSURE); | ||
66 | } | ||
67 | } else if (type == dotTokenId) { | ||
68 | if (isFullStopContext()) { | ||
69 | token.setType(RULE_FULL_STOP); | ||
70 | } | ||
71 | } | ||
72 | } | ||
73 | |||
74 | private boolean isIdFragment(int tokenId) { | ||
75 | return tokenId == RULE_ID || tokenId == RULE_QUOTED_ID; | ||
76 | } | ||
77 | |||
78 | private boolean isTransitiveClosureInReferenceContext() { | ||
79 | int nextVisibleTokenId = peekUntilVisible().getType(); | ||
80 | return isIdFragment(lastTokenId) | ||
81 | && (nextVisibleTokenId == dotTokenId || nextVisibleTokenId == openParenTokenId); | ||
82 | } | ||
83 | |||
84 | private boolean isFullStopContext() { | ||
85 | int nextTokenId = peekToken().getType(); | ||
86 | boolean inReference = isIdFragment(lastTokenId) && (isIdFragment(nextTokenId) || nextTokenId == tildeTokenId); | ||
87 | boolean inReal = lastTokenId == RULE_INT && nextTokenId == RULE_INT; | ||
88 | return !(inReference || inReal); | ||
89 | } | ||
90 | |||
91 | protected Token peekUntilVisible() { | ||
92 | Token followingToken = null; | ||
93 | do { | ||
94 | followingToken = peekToken(); | ||
95 | } while (isHidden(followingToken.getType())); | ||
96 | return followingToken; | ||
97 | } | ||
98 | |||
99 | protected Token peekToken() { | ||
100 | Token followingToken = delegate.nextToken(); | ||
101 | acceptor.accept(followingToken); | ||
102 | return followingToken; | ||
103 | } | ||
104 | |||
105 | protected boolean isHidden(int tokenType) { | ||
106 | return tokenType == RULE_WS || tokenType == RULE_SL_COMMENT || tokenType == RULE_ML_COMMENT; | ||
107 | } | ||
108 | |||
109 | public void initializeTokenDefsFrom(ITokenDefProvider provider) { | ||
110 | for (Map.Entry<Integer, String> entry : provider.getTokenDefMap().entrySet()) { | ||
111 | switch (entry.getValue()) { | ||
112 | case "'+'": | ||
113 | plusTokenId = entry.getKey(); | ||
114 | break; | ||
115 | case "'*'": | ||
116 | starTokenId = entry.getKey(); | ||
117 | break; | ||
118 | case "'.'": | ||
119 | dotTokenId = entry.getKey(); | ||
120 | break; | ||
121 | case "'~'": | ||
122 | tildeTokenId = entry.getKey(); | ||
123 | break; | ||
124 | case "'('": | ||
125 | openParenTokenId = entry.getKey(); | ||
126 | break; | ||
127 | } | ||
128 | } | ||
129 | if (plusTokenId == -1) { | ||
130 | throw new IllegalStateException("Token '+' was not found"); | ||
131 | } | ||
132 | if (starTokenId == -1) { | ||
133 | throw new IllegalStateException("Token '*' was not found"); | ||
134 | } | ||
135 | if (dotTokenId == -1) { | ||
136 | throw new IllegalStateException("Token '.' was not found"); | ||
137 | } | ||
138 | if (tildeTokenId == -1) { | ||
139 | throw new IllegalStateException("Token '~' was not found"); | ||
140 | } | ||
141 | if (openParenTokenId == -1) { | ||
142 | throw new IllegalStateException("Token '(' was not found"); | ||
143 | } | ||
144 | } | ||
145 | } | ||
diff --git a/Application/org.eclipse.viatra.solver.language/src/org/eclipse/viatra/solver/language/scoping/SolverLanguageScopeProvider.xtend b/Application/org.eclipse.viatra.solver.language/src/org/eclipse/viatra/solver/language/scoping/SolverLanguageScopeProvider.xtend new file mode 100644 index 00000000..6b92897c --- /dev/null +++ b/Application/org.eclipse.viatra.solver.language/src/org/eclipse/viatra/solver/language/scoping/SolverLanguageScopeProvider.xtend | |||
@@ -0,0 +1,15 @@ | |||
1 | /* | ||
2 | * generated by Xtext 2.18.0.M3 | ||
3 | */ | ||
4 | package org.eclipse.viatra.solver.language.scoping | ||
5 | |||
6 | |||
7 | /** | ||
8 | * This class contains custom scoping description. | ||
9 | * | ||
10 | * See https://www.eclipse.org/Xtext/documentation/303_runtime_concepts.html#scoping | ||
11 | * on how and when to use it. | ||
12 | */ | ||
13 | class SolverLanguageScopeProvider extends AbstractSolverLanguageScopeProvider { | ||
14 | |||
15 | } | ||
diff --git a/Application/org.eclipse.viatra.solver.language/src/org/eclipse/viatra/solver/language/serializer/SolverLanguageSyntheticTokenSyntacticSequencer.xtend b/Application/org.eclipse.viatra.solver.language/src/org/eclipse/viatra/solver/language/serializer/SolverLanguageSyntheticTokenSyntacticSequencer.xtend new file mode 100644 index 00000000..587ea27b --- /dev/null +++ b/Application/org.eclipse.viatra.solver.language/src/org/eclipse/viatra/solver/language/serializer/SolverLanguageSyntheticTokenSyntacticSequencer.xtend | |||
@@ -0,0 +1,21 @@ | |||
1 | package org.eclipse.viatra.solver.language.serializer | ||
2 | |||
3 | import org.eclipse.emf.ecore.EObject | ||
4 | import org.eclipse.xtext.RuleCall | ||
5 | import org.eclipse.xtext.nodemodel.INode | ||
6 | |||
7 | class SolverLanguageSyntheticTokenSyntacticSequencer extends SolverLanguageSyntacticSequencer { | ||
8 | |||
9 | override protected getTRANSITIVE_CLOSUREToken(EObject semanticObject, RuleCall ruleCall, INode node) { | ||
10 | "+" | ||
11 | } | ||
12 | |||
13 | override protected getREFLEXIVE_TRANSITIVE_CLOSUREToken(EObject semanticObject, RuleCall ruleCall, INode node) { | ||
14 | "*" | ||
15 | } | ||
16 | |||
17 | override protected getFULL_STOPToken(EObject semanticObject, RuleCall ruleCall, INode node) { | ||
18 | "." | ||
19 | } | ||
20 | |||
21 | } \ No newline at end of file | ||
diff --git a/Application/org.eclipse.viatra.solver.language/src/org/eclipse/viatra/solver/language/validation/SolverLanguageValidator.xtend b/Application/org.eclipse.viatra.solver.language/src/org/eclipse/viatra/solver/language/validation/SolverLanguageValidator.xtend new file mode 100644 index 00000000..6701d465 --- /dev/null +++ b/Application/org.eclipse.viatra.solver.language/src/org/eclipse/viatra/solver/language/validation/SolverLanguageValidator.xtend | |||
@@ -0,0 +1,25 @@ | |||
1 | /* | ||
2 | * generated by Xtext 2.21.0 | ||
3 | */ | ||
4 | package org.eclipse.viatra.solver.language.validation | ||
5 | |||
6 | |||
7 | /** | ||
8 | * This class contains custom validation rules. | ||
9 | * | ||
10 | * See https://www.eclipse.org/Xtext/documentation/303_runtime_concepts.html#validation | ||
11 | */ | ||
12 | class SolverLanguageValidator extends AbstractSolverLanguageValidator { | ||
13 | |||
14 | // public static val INVALID_NAME = 'invalidName' | ||
15 | // | ||
16 | // @Check | ||
17 | // def checkGreetingStartsWithCapital(Greeting greeting) { | ||
18 | // if (!Character.isUpperCase(greeting.name.charAt(0))) { | ||
19 | // warning('Name should start with a capital', | ||
20 | // SolverLanguagePackage.Literals.GREETING__NAME, | ||
21 | // INVALID_NAME) | ||
22 | // } | ||
23 | // } | ||
24 | |||
25 | } | ||
diff --git a/Application/org.eclipse.viatra.solver.language/xtend-gen/org/eclipse/viatra/solver/language/.gitignore b/Application/org.eclipse.viatra.solver.language/xtend-gen/org/eclipse/viatra/solver/language/.gitignore new file mode 100644 index 00000000..82298938 --- /dev/null +++ b/Application/org.eclipse.viatra.solver.language/xtend-gen/org/eclipse/viatra/solver/language/.gitignore | |||
@@ -0,0 +1,6 @@ | |||
1 | /.SolverLanguageRuntimeModule.java._trace | ||
2 | /.SolverLanguageRuntimeModule.xtendbin | ||
3 | /.SolverLanguageStandaloneSetup.java._trace | ||
4 | /.SolverLanguageStandaloneSetup.xtendbin | ||
5 | /SolverLanguageRuntimeModule.java | ||
6 | /SolverLanguageStandaloneSetup.java | ||
diff --git a/Application/org.eclipse.viatra.solver.language/xtend-gen/org/eclipse/viatra/solver/language/generator/.gitignore b/Application/org.eclipse.viatra.solver.language/xtend-gen/org/eclipse/viatra/solver/language/generator/.gitignore new file mode 100644 index 00000000..a9345b80 --- /dev/null +++ b/Application/org.eclipse.viatra.solver.language/xtend-gen/org/eclipse/viatra/solver/language/generator/.gitignore | |||
@@ -0,0 +1,3 @@ | |||
1 | /.SolverLanguageGenerator.java._trace | ||
2 | /.SolverLanguageGenerator.xtendbin | ||
3 | /SolverLanguageGenerator.java | ||
diff --git a/Application/org.eclipse.viatra.solver.language/xtend-gen/org/eclipse/viatra/solver/language/parser/antlr/.SolverLanguageTokenDefInjectingParser.xtendbin b/Application/org.eclipse.viatra.solver.language/xtend-gen/org/eclipse/viatra/solver/language/parser/antlr/.SolverLanguageTokenDefInjectingParser.xtendbin new file mode 100644 index 00000000..24f61d80 --- /dev/null +++ b/Application/org.eclipse.viatra.solver.language/xtend-gen/org/eclipse/viatra/solver/language/parser/antlr/.SolverLanguageTokenDefInjectingParser.xtendbin | |||
Binary files differ | |||
diff --git a/Application/org.eclipse.viatra.solver.language/xtend-gen/org/eclipse/viatra/solver/language/parser/antlr/.gitignore b/Application/org.eclipse.viatra.solver.language/xtend-gen/org/eclipse/viatra/solver/language/parser/antlr/.gitignore new file mode 100644 index 00000000..9cf14147 --- /dev/null +++ b/Application/org.eclipse.viatra.solver.language/xtend-gen/org/eclipse/viatra/solver/language/parser/antlr/.gitignore | |||
@@ -0,0 +1,7 @@ | |||
1 | /.SolverLangaugeSyntheticTokenParser.java._trace | ||
2 | /.SolverLanguageSyntheticTokenTokenSource.java._trace | ||
3 | /.LastTokenState.java._trace | ||
4 | /.SolverLangusgeSyntheticTokenParser.java._trace | ||
5 | /.SolverLanguageSyntheticTokenParser.java._trace | ||
6 | /.SolverLanguageTokenSource.java._trace | ||
7 | /.SolverLanguageTokenDefInjectingParser.java._trace | ||
diff --git a/Application/org.eclipse.viatra.solver.language/xtend-gen/org/eclipse/viatra/solver/language/parser/antlr/SolverLanguageTokenDefInjectingParser.java b/Application/org.eclipse.viatra.solver.language/xtend-gen/org/eclipse/viatra/solver/language/parser/antlr/SolverLanguageTokenDefInjectingParser.java new file mode 100644 index 00000000..12c92733 --- /dev/null +++ b/Application/org.eclipse.viatra.solver.language/xtend-gen/org/eclipse/viatra/solver/language/parser/antlr/SolverLanguageTokenDefInjectingParser.java | |||
@@ -0,0 +1,26 @@ | |||
1 | package org.eclipse.viatra.solver.language.parser.antlr; | ||
2 | |||
3 | import com.google.inject.Inject; | ||
4 | import org.antlr.runtime.CharStream; | ||
5 | import org.antlr.runtime.TokenSource; | ||
6 | import org.eclipse.viatra.solver.language.parser.antlr.SolverLanguageParser; | ||
7 | import org.eclipse.viatra.solver.language.parser.antlr.SolverLanguageTokenSource; | ||
8 | import org.eclipse.xtext.parser.antlr.ITokenDefProvider; | ||
9 | |||
10 | @SuppressWarnings("all") | ||
11 | public class SolverLanguageTokenDefInjectingParser extends SolverLanguageParser { | ||
12 | @Inject | ||
13 | private ITokenDefProvider tokenDefProvider; | ||
14 | |||
15 | @Override | ||
16 | protected TokenSource createLexer(final CharStream stream) { | ||
17 | SolverLanguageTokenSource _xblockexpression = null; | ||
18 | { | ||
19 | TokenSource _createLexer = super.createLexer(stream); | ||
20 | final SolverLanguageTokenSource tokenSource = ((SolverLanguageTokenSource) _createLexer); | ||
21 | tokenSource.initializeTokenDefsFrom(this.tokenDefProvider); | ||
22 | _xblockexpression = tokenSource; | ||
23 | } | ||
24 | return _xblockexpression; | ||
25 | } | ||
26 | } | ||
diff --git a/Application/org.eclipse.viatra.solver.language/xtend-gen/org/eclipse/viatra/solver/language/scoping/.gitignore b/Application/org.eclipse.viatra.solver.language/xtend-gen/org/eclipse/viatra/solver/language/scoping/.gitignore new file mode 100644 index 00000000..16497231 --- /dev/null +++ b/Application/org.eclipse.viatra.solver.language/xtend-gen/org/eclipse/viatra/solver/language/scoping/.gitignore | |||
@@ -0,0 +1,3 @@ | |||
1 | /.SolverLanguageScopeProvider.java._trace | ||
2 | /.SolverLanguageScopeProvider.xtendbin | ||
3 | /SolverLanguageScopeProvider.java | ||
diff --git a/Application/org.eclipse.viatra.solver.language/xtend-gen/org/eclipse/viatra/solver/language/serializer/.SolverLanguageSyntheticTokenSyntacticSequencer.xtendbin b/Application/org.eclipse.viatra.solver.language/xtend-gen/org/eclipse/viatra/solver/language/serializer/.SolverLanguageSyntheticTokenSyntacticSequencer.xtendbin new file mode 100644 index 00000000..eae3bd77 --- /dev/null +++ b/Application/org.eclipse.viatra.solver.language/xtend-gen/org/eclipse/viatra/solver/language/serializer/.SolverLanguageSyntheticTokenSyntacticSequencer.xtendbin | |||
Binary files differ | |||
diff --git a/Application/org.eclipse.viatra.solver.language/xtend-gen/org/eclipse/viatra/solver/language/serializer/.gitignore b/Application/org.eclipse.viatra.solver.language/xtend-gen/org/eclipse/viatra/solver/language/serializer/.gitignore new file mode 100644 index 00000000..b8132d70 --- /dev/null +++ b/Application/org.eclipse.viatra.solver.language/xtend-gen/org/eclipse/viatra/solver/language/serializer/.gitignore | |||
@@ -0,0 +1 @@ | |||
/.SolverLanguageSyntheticTokenSyntacticSequencer.java._trace | |||
diff --git a/Application/org.eclipse.viatra.solver.language/xtend-gen/org/eclipse/viatra/solver/language/serializer/SolverLanguageSyntheticTokenSyntacticSequencer.java b/Application/org.eclipse.viatra.solver.language/xtend-gen/org/eclipse/viatra/solver/language/serializer/SolverLanguageSyntheticTokenSyntacticSequencer.java new file mode 100644 index 00000000..af761a86 --- /dev/null +++ b/Application/org.eclipse.viatra.solver.language/xtend-gen/org/eclipse/viatra/solver/language/serializer/SolverLanguageSyntheticTokenSyntacticSequencer.java | |||
@@ -0,0 +1,24 @@ | |||
1 | package org.eclipse.viatra.solver.language.serializer; | ||
2 | |||
3 | import org.eclipse.emf.ecore.EObject; | ||
4 | import org.eclipse.viatra.solver.language.serializer.SolverLanguageSyntacticSequencer; | ||
5 | import org.eclipse.xtext.RuleCall; | ||
6 | import org.eclipse.xtext.nodemodel.INode; | ||
7 | |||
8 | @SuppressWarnings("all") | ||
9 | public class SolverLanguageSyntheticTokenSyntacticSequencer extends SolverLanguageSyntacticSequencer { | ||
10 | @Override | ||
11 | protected String getTRANSITIVE_CLOSUREToken(final EObject semanticObject, final RuleCall ruleCall, final INode node) { | ||
12 | return "+"; | ||
13 | } | ||
14 | |||
15 | @Override | ||
16 | protected String getREFLEXIVE_TRANSITIVE_CLOSUREToken(final EObject semanticObject, final RuleCall ruleCall, final INode node) { | ||
17 | return "*"; | ||
18 | } | ||
19 | |||
20 | @Override | ||
21 | protected String getFULL_STOPToken(final EObject semanticObject, final RuleCall ruleCall, final INode node) { | ||
22 | return "."; | ||
23 | } | ||
24 | } | ||
diff --git a/Application/org.eclipse.viatra.solver.language/xtend-gen/org/eclipse/viatra/solver/language/validation/.gitignore b/Application/org.eclipse.viatra.solver.language/xtend-gen/org/eclipse/viatra/solver/language/validation/.gitignore new file mode 100644 index 00000000..565d4b27 --- /dev/null +++ b/Application/org.eclipse.viatra.solver.language/xtend-gen/org/eclipse/viatra/solver/language/validation/.gitignore | |||
@@ -0,0 +1,3 @@ | |||
1 | /.SolverLanguageValidator.java._trace | ||
2 | /.SolverLanguageValidator.xtendbin | ||
3 | /SolverLanguageValidator.java | ||