diff options
author | 2019-10-25 04:15:39 -0400 | |
---|---|---|
committer | 2020-06-07 19:43:49 -0400 | |
commit | 32a4f3392a7d0c44439c0c9b960ef1cfb5e3cc2f (patch) | |
tree | 0e67f50df5b4d9a42f0075e1e19be988eae59bf9 /Solvers/Alloy-Solver2/hu.bme.mit.inf.dslreasoner.alloy.language.ui/src-gen/hu/bme/mit/inf/dslreasoner | |
parent | mid-measurement push (diff) | |
download | VIATRA-Generator-32a4f3392a7d0c44439c0c9b960ef1cfb5e3cc2f.tar.gz VIATRA-Generator-32a4f3392a7d0c44439c0c9b960ef1cfb5e3cc2f.tar.zst VIATRA-Generator-32a4f3392a7d0c44439c0c9b960ef1cfb5e3cc2f.zip |
VAMPIRE: post-submission push
Diffstat (limited to 'Solvers/Alloy-Solver2/hu.bme.mit.inf.dslreasoner.alloy.language.ui/src-gen/hu/bme/mit/inf/dslreasoner')
10 files changed, 43875 insertions, 0 deletions
diff --git a/Solvers/Alloy-Solver2/hu.bme.mit.inf.dslreasoner.alloy.language.ui/src-gen/hu/bme/mit/inf/dslreasoner/ui/AbstractAlloyLanguageUiModule.java b/Solvers/Alloy-Solver2/hu.bme.mit.inf.dslreasoner.alloy.language.ui/src-gen/hu/bme/mit/inf/dslreasoner/ui/AbstractAlloyLanguageUiModule.java new file mode 100644 index 00000000..80a1c7ff --- /dev/null +++ b/Solvers/Alloy-Solver2/hu.bme.mit.inf.dslreasoner.alloy.language.ui/src-gen/hu/bme/mit/inf/dslreasoner/ui/AbstractAlloyLanguageUiModule.java | |||
@@ -0,0 +1,201 @@ | |||
1 | |||
2 | /* | ||
3 | * generated by Xtext | ||
4 | */ | ||
5 | package hu.bme.mit.inf.dslreasoner.ui; | ||
6 | |||
7 | import org.eclipse.ui.plugin.AbstractUIPlugin; | ||
8 | |||
9 | /** | ||
10 | * Manual modifications go to {hu.bme.mit.inf.dslreasoner.ui.AlloyLanguageUiModule} | ||
11 | */ | ||
12 | @SuppressWarnings("all") | ||
13 | public abstract class AbstractAlloyLanguageUiModule extends org.eclipse.xtext.common.types.ui.DefaultCommonTypesUiModule { | ||
14 | |||
15 | public AbstractAlloyLanguageUiModule(AbstractUIPlugin plugin) { | ||
16 | super(plugin); | ||
17 | } | ||
18 | |||
19 | |||
20 | // contributed by org.eclipse.xtext.ui.generator.ImplicitUiFragment | ||
21 | public com.google.inject.Provider<org.eclipse.xtext.resource.containers.IAllContainersState> provideIAllContainersState() { | ||
22 | return org.eclipse.xtext.ui.shared.Access.getJavaProjectsState(); | ||
23 | } | ||
24 | |||
25 | // contributed by org.eclipse.xtext.generator.parser.antlr.XtextAntlrGeneratorFragment | ||
26 | public Class<? extends org.eclipse.xtext.ui.editor.contentassist.IProposalConflictHelper> bindIProposalConflictHelper() { | ||
27 | return org.eclipse.xtext.ui.editor.contentassist.antlr.AntlrProposalConflictHelper.class; | ||
28 | } | ||
29 | |||
30 | // contributed by org.eclipse.xtext.generator.parser.antlr.XtextAntlrGeneratorFragment | ||
31 | public void configureHighlightingLexer(com.google.inject.Binder binder) { | ||
32 | binder.bind(org.eclipse.xtext.parser.antlr.Lexer.class).annotatedWith(com.google.inject.name.Names.named(org.eclipse.xtext.ui.LexerUIBindings.HIGHLIGHTING)).to(hu.bme.mit.inf.dslreasoner.parser.antlr.internal.InternalAlloyLanguageLexer.class); | ||
33 | } | ||
34 | |||
35 | // contributed by org.eclipse.xtext.generator.parser.antlr.XtextAntlrGeneratorFragment | ||
36 | public void configureHighlightingTokenDefProvider(com.google.inject.Binder binder) { | ||
37 | binder.bind(org.eclipse.xtext.parser.antlr.ITokenDefProvider.class).annotatedWith(com.google.inject.name.Names.named(org.eclipse.xtext.ui.LexerUIBindings.HIGHLIGHTING)).to(org.eclipse.xtext.parser.antlr.AntlrTokenDefProvider.class); | ||
38 | } | ||
39 | |||
40 | // contributed by org.eclipse.xtext.generator.exporting.QualifiedNamesFragment | ||
41 | public Class<? extends org.eclipse.xtext.ui.refactoring.IDependentElementsCalculator> bindIDependentElementsCalculator() { | ||
42 | return org.eclipse.xtext.ui.refactoring.impl.DefaultDependentElementsCalculator.class; | ||
43 | } | ||
44 | |||
45 | // contributed by org.eclipse.xtext.generator.builder.BuilderIntegrationFragment | ||
46 | public void configureIResourceDescriptionsBuilderScope(com.google.inject.Binder binder) { | ||
47 | binder.bind(org.eclipse.xtext.resource.IResourceDescriptions.class).annotatedWith(com.google.inject.name.Names.named(org.eclipse.xtext.resource.impl.ResourceDescriptionsProvider.NAMED_BUILDER_SCOPE)).to(org.eclipse.xtext.builder.clustering.CurrentDescriptions.ResourceSetAware.class); | ||
48 | } | ||
49 | |||
50 | // contributed by org.eclipse.xtext.generator.builder.BuilderIntegrationFragment | ||
51 | public Class<? extends org.eclipse.xtext.ui.editor.IXtextEditorCallback> bindIXtextEditorCallback() { | ||
52 | return org.eclipse.xtext.builder.nature.NatureAddingEditorCallback.class; | ||
53 | } | ||
54 | |||
55 | // contributed by org.eclipse.xtext.generator.builder.BuilderIntegrationFragment | ||
56 | public Class<? extends org.eclipse.xtext.generator.IContextualOutputConfigurationProvider> bindIContextualOutputConfigurationProvider() { | ||
57 | return org.eclipse.xtext.builder.EclipseOutputConfigurationProvider.class; | ||
58 | } | ||
59 | |||
60 | // contributed by org.eclipse.xtext.generator.builder.BuilderIntegrationFragment | ||
61 | public void configureIResourceDescriptionsPersisted(com.google.inject.Binder binder) { | ||
62 | binder.bind(org.eclipse.xtext.resource.IResourceDescriptions.class).annotatedWith(com.google.inject.name.Names.named(org.eclipse.xtext.resource.impl.ResourceDescriptionsProvider.PERSISTED_DESCRIPTIONS)).to(org.eclipse.xtext.builder.builderState.IBuilderState.class); | ||
63 | } | ||
64 | |||
65 | // contributed by org.eclipse.xtext.generator.builder.BuilderIntegrationFragment | ||
66 | public Class<? extends org.eclipse.xtext.ui.editor.DocumentBasedDirtyResource> bindDocumentBasedDirtyResource() { | ||
67 | return org.eclipse.xtext.builder.impl.PersistentDataAwareDirtyResource.class; | ||
68 | } | ||
69 | |||
70 | // contributed by org.eclipse.xtext.generator.generator.GeneratorFragment | ||
71 | public Class<? extends org.eclipse.xtext.builder.IXtextBuilderParticipant> bindIXtextBuilderParticipant() { | ||
72 | return org.eclipse.xtext.builder.BuilderParticipant.class; | ||
73 | } | ||
74 | |||
75 | // contributed by org.eclipse.xtext.generator.generator.GeneratorFragment | ||
76 | public org.eclipse.core.resources.IWorkspaceRoot bindIWorkspaceRootToInstance() { | ||
77 | return org.eclipse.core.resources.ResourcesPlugin.getWorkspace().getRoot(); | ||
78 | } | ||
79 | |||
80 | // contributed by org.eclipse.xtext.generator.generator.GeneratorFragment | ||
81 | public void configureBuilderPreferenceStoreInitializer(com.google.inject.Binder binder) { | ||
82 | binder.bind(org.eclipse.xtext.ui.editor.preferences.IPreferenceStoreInitializer.class).annotatedWith(com.google.inject.name.Names.named("builderPreferenceInitializer")).to(org.eclipse.xtext.builder.preferences.BuilderPreferenceAccess.Initializer.class); | ||
83 | } | ||
84 | |||
85 | // contributed by org.eclipse.xtext.ui.generator.labeling.LabelProviderFragment | ||
86 | public Class<? extends org.eclipse.jface.viewers.ILabelProvider> bindILabelProvider() { | ||
87 | return hu.bme.mit.inf.dslreasoner.ui.labeling.AlloyLanguageLabelProvider.class; | ||
88 | } | ||
89 | |||
90 | // contributed by org.eclipse.xtext.ui.generator.labeling.LabelProviderFragment | ||
91 | public void configureResourceUIServiceLabelProvider(com.google.inject.Binder binder) { | ||
92 | binder.bind(org.eclipse.jface.viewers.ILabelProvider.class).annotatedWith(org.eclipse.xtext.ui.resource.ResourceServiceDescriptionLabelProvider.class).to(hu.bme.mit.inf.dslreasoner.ui.labeling.AlloyLanguageDescriptionLabelProvider.class); | ||
93 | } | ||
94 | |||
95 | // contributed by org.eclipse.xtext.ui.generator.outline.OutlineTreeProviderFragment | ||
96 | public Class<? extends org.eclipse.xtext.ui.editor.outline.IOutlineTreeProvider> bindIOutlineTreeProvider() { | ||
97 | return hu.bme.mit.inf.dslreasoner.ui.outline.AlloyLanguageOutlineTreeProvider.class; | ||
98 | } | ||
99 | |||
100 | // contributed by org.eclipse.xtext.ui.generator.outline.OutlineTreeProviderFragment | ||
101 | public Class<? extends org.eclipse.xtext.ui.editor.outline.impl.IOutlineTreeStructureProvider> bindIOutlineTreeStructureProvider() { | ||
102 | return hu.bme.mit.inf.dslreasoner.ui.outline.AlloyLanguageOutlineTreeProvider.class; | ||
103 | } | ||
104 | |||
105 | // contributed by org.eclipse.xtext.ui.generator.quickfix.QuickfixProviderFragment | ||
106 | public Class<? extends org.eclipse.xtext.ui.editor.quickfix.IssueResolutionProvider> bindIssueResolutionProvider() { | ||
107 | return hu.bme.mit.inf.dslreasoner.ui.quickfix.AlloyLanguageQuickfixProvider.class; | ||
108 | } | ||
109 | |||
110 | // contributed by org.eclipse.xtext.ui.generator.contentAssist.ContentAssistFragment | ||
111 | public Class<? extends org.eclipse.xtext.ui.editor.contentassist.IContentProposalProvider> bindIContentProposalProvider() { | ||
112 | return hu.bme.mit.inf.dslreasoner.ui.contentassist.AlloyLanguageProposalProvider.class; | ||
113 | } | ||
114 | |||
115 | // contributed by org.eclipse.xtext.generator.parser.antlr.XtextAntlrUiGeneratorFragment | ||
116 | public Class<? extends org.eclipse.xtext.ui.editor.contentassist.ContentAssistContext.Factory> bindContentAssistContext$Factory() { | ||
117 | return org.eclipse.xtext.ui.editor.contentassist.antlr.ParserBasedContentAssistContextFactory.class; | ||
118 | } | ||
119 | |||
120 | // contributed by org.eclipse.xtext.generator.parser.antlr.XtextAntlrUiGeneratorFragment | ||
121 | public Class<? extends org.eclipse.xtext.ui.editor.contentassist.antlr.IContentAssistParser> bindIContentAssistParser() { | ||
122 | return hu.bme.mit.inf.dslreasoner.ui.contentassist.antlr.AlloyLanguageParser.class; | ||
123 | } | ||
124 | |||
125 | // contributed by org.eclipse.xtext.generator.parser.antlr.XtextAntlrUiGeneratorFragment | ||
126 | public void configureContentAssistLexerProvider(com.google.inject.Binder binder) { | ||
127 | binder.bind(hu.bme.mit.inf.dslreasoner.ui.contentassist.antlr.internal.InternalAlloyLanguageLexer.class).toProvider(org.eclipse.xtext.parser.antlr.LexerProvider.create(hu.bme.mit.inf.dslreasoner.ui.contentassist.antlr.internal.InternalAlloyLanguageLexer.class)); | ||
128 | } | ||
129 | |||
130 | // contributed by org.eclipse.xtext.generator.parser.antlr.XtextAntlrUiGeneratorFragment | ||
131 | public void configureContentAssistLexer(com.google.inject.Binder binder) { | ||
132 | binder.bind(org.eclipse.xtext.ui.editor.contentassist.antlr.internal.Lexer.class).annotatedWith(com.google.inject.name.Names.named(org.eclipse.xtext.ui.LexerUIBindings.CONTENT_ASSIST)).to(hu.bme.mit.inf.dslreasoner.ui.contentassist.antlr.internal.InternalAlloyLanguageLexer.class); | ||
133 | } | ||
134 | |||
135 | // contributed by org.eclipse.xtext.ui.generator.refactoring.RefactorElementNameFragment | ||
136 | public Class<? extends org.eclipse.xtext.ui.refactoring.IRenameStrategy> bindIRenameStrategy() { | ||
137 | return org.eclipse.xtext.ui.refactoring.impl.DefaultRenameStrategy.class; | ||
138 | } | ||
139 | |||
140 | // contributed by org.eclipse.xtext.ui.generator.refactoring.RefactorElementNameFragment | ||
141 | public Class<? extends org.eclipse.xtext.ui.refactoring.IReferenceUpdater> bindIReferenceUpdater() { | ||
142 | return org.eclipse.xtext.ui.refactoring.impl.DefaultReferenceUpdater.class; | ||
143 | } | ||
144 | |||
145 | // contributed by org.eclipse.xtext.ui.generator.refactoring.RefactorElementNameFragment | ||
146 | public void configureIPreferenceStoreInitializer(com.google.inject.Binder binder) { | ||
147 | binder.bind(org.eclipse.xtext.ui.editor.preferences.IPreferenceStoreInitializer.class).annotatedWith(com.google.inject.name.Names.named("RefactoringPreferences")).to(org.eclipse.xtext.ui.refactoring.ui.RefactoringPreferences.Initializer.class); | ||
148 | } | ||
149 | |||
150 | // contributed by org.eclipse.xtext.ui.generator.refactoring.RefactorElementNameFragment | ||
151 | public Class<? extends org.eclipse.xtext.ui.refactoring.IRenameRefactoringProvider> bindIRenameRefactoringProvider() { | ||
152 | return org.eclipse.xtext.ui.refactoring.impl.DefaultRenameRefactoringProvider.class; | ||
153 | } | ||
154 | |||
155 | // contributed by org.eclipse.xtext.ui.generator.refactoring.RefactorElementNameFragment | ||
156 | public Class<? extends org.eclipse.xtext.ui.refactoring.ui.IRenameSupport.Factory> bindIRenameSupport$Factory() { | ||
157 | return org.eclipse.xtext.ui.refactoring.ui.DefaultRenameSupport.Factory.class; | ||
158 | } | ||
159 | |||
160 | // contributed by org.eclipse.xtext.generator.types.TypesGeneratorFragment | ||
161 | public Class<? extends org.eclipse.xtext.ui.editor.contentassist.PrefixMatcher> bindPrefixMatcher() { | ||
162 | return org.eclipse.xtext.ui.editor.contentassist.FQNPrefixMatcher.class; | ||
163 | } | ||
164 | |||
165 | // contributed by org.eclipse.xtext.ui.generator.templates.CodetemplatesGeneratorFragment | ||
166 | public com.google.inject.Provider<org.eclipse.xtext.ui.codetemplates.ui.preferences.TemplatesLanguageConfiguration> provideTemplatesLanguageConfiguration() { | ||
167 | return org.eclipse.xtext.ui.codetemplates.ui.AccessibleCodetemplatesActivator.getTemplatesLanguageConfigurationProvider(); | ||
168 | } | ||
169 | |||
170 | // contributed by org.eclipse.xtext.ui.generator.templates.CodetemplatesGeneratorFragment | ||
171 | public com.google.inject.Provider<org.eclipse.xtext.ui.codetemplates.ui.registry.LanguageRegistry> provideLanguageRegistry() { | ||
172 | return org.eclipse.xtext.ui.codetemplates.ui.AccessibleCodetemplatesActivator.getLanguageRegistry(); | ||
173 | } | ||
174 | |||
175 | // contributed by org.eclipse.xtext.ui.generator.templates.CodetemplatesGeneratorFragment | ||
176 | @org.eclipse.xtext.service.SingletonBinding(eager=true) public Class<? extends org.eclipse.xtext.ui.codetemplates.ui.registry.LanguageRegistrar> bindLanguageRegistrar() { | ||
177 | return org.eclipse.xtext.ui.codetemplates.ui.registry.LanguageRegistrar.class; | ||
178 | } | ||
179 | |||
180 | // contributed by org.eclipse.xtext.ui.generator.templates.CodetemplatesGeneratorFragment | ||
181 | public Class<? extends org.eclipse.xtext.ui.editor.templates.XtextTemplatePreferencePage> bindXtextTemplatePreferencePage() { | ||
182 | return org.eclipse.xtext.ui.codetemplates.ui.preferences.AdvancedTemplatesPreferencePage.class; | ||
183 | } | ||
184 | |||
185 | // contributed by org.eclipse.xtext.ui.generator.templates.CodetemplatesGeneratorFragment | ||
186 | public Class<? extends org.eclipse.xtext.ui.codetemplates.ui.partialEditing.IPartialContentAssistParser> bindIPartialContentAssistParser() { | ||
187 | return hu.bme.mit.inf.dslreasoner.ui.contentassist.antlr.PartialAlloyLanguageContentAssistParser.class; | ||
188 | } | ||
189 | |||
190 | // contributed by org.eclipse.xtext.ui.generator.compare.CompareFragment | ||
191 | public Class<? extends org.eclipse.compare.IViewerCreator> bindIViewerCreator() { | ||
192 | return org.eclipse.xtext.ui.compare.DefaultViewerCreator.class; | ||
193 | } | ||
194 | |||
195 | // contributed by org.eclipse.xtext.ui.generator.compare.CompareFragment | ||
196 | public void configureCompareViewerTitle(com.google.inject.Binder binder) { | ||
197 | binder.bind(String.class).annotatedWith(com.google.inject.name.Names.named(org.eclipse.xtext.ui.UIBindings.COMPARE_VIEWER_TITLE)).toInstance("AlloyLanguage Compare"); | ||
198 | } | ||
199 | |||
200 | |||
201 | } | ||
diff --git a/Solvers/Alloy-Solver2/hu.bme.mit.inf.dslreasoner.alloy.language.ui/src-gen/hu/bme/mit/inf/dslreasoner/ui/AlloyLanguageExecutableExtensionFactory.java b/Solvers/Alloy-Solver2/hu.bme.mit.inf.dslreasoner.alloy.language.ui/src-gen/hu/bme/mit/inf/dslreasoner/ui/AlloyLanguageExecutableExtensionFactory.java new file mode 100644 index 00000000..c62a1aa1 --- /dev/null +++ b/Solvers/Alloy-Solver2/hu.bme.mit.inf.dslreasoner.alloy.language.ui/src-gen/hu/bme/mit/inf/dslreasoner/ui/AlloyLanguageExecutableExtensionFactory.java | |||
@@ -0,0 +1,29 @@ | |||
1 | /* | ||
2 | * generated by Xtext | ||
3 | */ | ||
4 | package hu.bme.mit.inf.dslreasoner.ui; | ||
5 | |||
6 | import org.eclipse.xtext.ui.guice.AbstractGuiceAwareExecutableExtensionFactory; | ||
7 | import org.osgi.framework.Bundle; | ||
8 | |||
9 | import com.google.inject.Injector; | ||
10 | |||
11 | import hu.bme.mit.inf.dslreasoner.ui.internal.AlloyLanguageActivator; | ||
12 | |||
13 | /** | ||
14 | * This class was generated. Customizations should only happen in a newly | ||
15 | * introduced subclass. | ||
16 | */ | ||
17 | public class AlloyLanguageExecutableExtensionFactory extends AbstractGuiceAwareExecutableExtensionFactory { | ||
18 | |||
19 | @Override | ||
20 | protected Bundle getBundle() { | ||
21 | return AlloyLanguageActivator.getInstance().getBundle(); | ||
22 | } | ||
23 | |||
24 | @Override | ||
25 | protected Injector getInjector() { | ||
26 | return AlloyLanguageActivator.getInstance().getInjector(AlloyLanguageActivator.HU_BME_MIT_INF_DSLREASONER_ALLOYLANGUAGE); | ||
27 | } | ||
28 | |||
29 | } | ||
diff --git a/Solvers/Alloy-Solver2/hu.bme.mit.inf.dslreasoner.alloy.language.ui/src-gen/hu/bme/mit/inf/dslreasoner/ui/contentassist/AbstractAlloyLanguageProposalProvider.java b/Solvers/Alloy-Solver2/hu.bme.mit.inf.dslreasoner.alloy.language.ui/src-gen/hu/bme/mit/inf/dslreasoner/ui/contentassist/AbstractAlloyLanguageProposalProvider.java new file mode 100644 index 00000000..17b08a58 --- /dev/null +++ b/Solvers/Alloy-Solver2/hu.bme.mit.inf.dslreasoner.alloy.language.ui/src-gen/hu/bme/mit/inf/dslreasoner/ui/contentassist/AbstractAlloyLanguageProposalProvider.java | |||
@@ -0,0 +1,326 @@ | |||
1 | /* | ||
2 | * generated by Xtext | ||
3 | */ | ||
4 | package hu.bme.mit.inf.dslreasoner.ui.contentassist; | ||
5 | |||
6 | import org.eclipse.emf.ecore.EObject; | ||
7 | import org.eclipse.xtext.*; | ||
8 | import org.eclipse.xtext.ui.editor.contentassist.ICompletionProposalAcceptor; | ||
9 | import org.eclipse.xtext.ui.editor.contentassist.ContentAssistContext; | ||
10 | |||
11 | /** | ||
12 | * Represents a generated, default implementation of superclass {@link org.eclipse.xtext.common.ui.contentassist.TerminalsProposalProvider}. | ||
13 | * Methods are dynamically dispatched on the first parameter, i.e., you can override them | ||
14 | * with a more concrete subtype. | ||
15 | */ | ||
16 | @SuppressWarnings("all") | ||
17 | public class AbstractAlloyLanguageProposalProvider extends org.eclipse.xtext.common.ui.contentassist.TerminalsProposalProvider { | ||
18 | |||
19 | public void completeALSDocument_EnumDeclarations(EObject model, Assignment assignment, ContentAssistContext context, ICompletionProposalAcceptor acceptor) { | ||
20 | completeRuleCall(((RuleCall)assignment.getTerminal()), context, acceptor); | ||
21 | } | ||
22 | public void completeALSDocument_SignatureBodies(EObject model, Assignment assignment, ContentAssistContext context, ICompletionProposalAcceptor acceptor) { | ||
23 | completeRuleCall(((RuleCall)assignment.getTerminal()), context, acceptor); | ||
24 | } | ||
25 | public void completeALSDocument_FunctionDefinitions(EObject model, Assignment assignment, ContentAssistContext context, ICompletionProposalAcceptor acceptor) { | ||
26 | completeRuleCall(((RuleCall)assignment.getTerminal()), context, acceptor); | ||
27 | } | ||
28 | public void completeALSDocument_RelationDefinitions(EObject model, Assignment assignment, ContentAssistContext context, ICompletionProposalAcceptor acceptor) { | ||
29 | completeRuleCall(((RuleCall)assignment.getTerminal()), context, acceptor); | ||
30 | } | ||
31 | public void completeALSDocument_FactDeclarations(EObject model, Assignment assignment, ContentAssistContext context, ICompletionProposalAcceptor acceptor) { | ||
32 | completeRuleCall(((RuleCall)assignment.getTerminal()), context, acceptor); | ||
33 | } | ||
34 | public void completeALSDocument_RunCommand(EObject model, Assignment assignment, ContentAssistContext context, ICompletionProposalAcceptor acceptor) { | ||
35 | completeRuleCall(((RuleCall)assignment.getTerminal()), context, acceptor); | ||
36 | } | ||
37 | public void completeALSEnumDeclaration_Name(EObject model, Assignment assignment, ContentAssistContext context, ICompletionProposalAcceptor acceptor) { | ||
38 | completeRuleCall(((RuleCall)assignment.getTerminal()), context, acceptor); | ||
39 | } | ||
40 | public void completeALSEnumDeclaration_Literal(EObject model, Assignment assignment, ContentAssistContext context, ICompletionProposalAcceptor acceptor) { | ||
41 | completeRuleCall(((RuleCall)assignment.getTerminal()), context, acceptor); | ||
42 | } | ||
43 | public void completeALSEnumLiteral_Name(EObject model, Assignment assignment, ContentAssistContext context, ICompletionProposalAcceptor acceptor) { | ||
44 | completeRuleCall(((RuleCall)assignment.getTerminal()), context, acceptor); | ||
45 | } | ||
46 | public void completeALSSignatureDeclaration_Name(EObject model, Assignment assignment, ContentAssistContext context, ICompletionProposalAcceptor acceptor) { | ||
47 | completeRuleCall(((RuleCall)assignment.getTerminal()), context, acceptor); | ||
48 | } | ||
49 | public void completeALSSignatureBody_Multiplicity(EObject model, Assignment assignment, ContentAssistContext context, ICompletionProposalAcceptor acceptor) { | ||
50 | completeRuleCall(((RuleCall)assignment.getTerminal()), context, acceptor); | ||
51 | } | ||
52 | public void completeALSSignatureBody_Abstract(EObject model, Assignment assignment, ContentAssistContext context, ICompletionProposalAcceptor acceptor) { | ||
53 | // subclasses may override | ||
54 | } | ||
55 | public void completeALSSignatureBody_Declarations(EObject model, Assignment assignment, ContentAssistContext context, ICompletionProposalAcceptor acceptor) { | ||
56 | completeRuleCall(((RuleCall)assignment.getTerminal()), context, acceptor); | ||
57 | } | ||
58 | public void completeALSSignatureBody_Supertype(EObject model, Assignment assignment, ContentAssistContext context, ICompletionProposalAcceptor acceptor) { | ||
59 | lookupCrossReference(((CrossReference)assignment.getTerminal()), context, acceptor); | ||
60 | } | ||
61 | public void completeALSSignatureBody_Superset(EObject model, Assignment assignment, ContentAssistContext context, ICompletionProposalAcceptor acceptor) { | ||
62 | lookupCrossReference(((CrossReference)assignment.getTerminal()), context, acceptor); | ||
63 | } | ||
64 | public void completeALSSignatureBody_Fields(EObject model, Assignment assignment, ContentAssistContext context, ICompletionProposalAcceptor acceptor) { | ||
65 | completeRuleCall(((RuleCall)assignment.getTerminal()), context, acceptor); | ||
66 | } | ||
67 | public void completeALSFieldDeclaration_Name(EObject model, Assignment assignment, ContentAssistContext context, ICompletionProposalAcceptor acceptor) { | ||
68 | completeRuleCall(((RuleCall)assignment.getTerminal()), context, acceptor); | ||
69 | } | ||
70 | public void completeALSFieldDeclaration_Multiplicity(EObject model, Assignment assignment, ContentAssistContext context, ICompletionProposalAcceptor acceptor) { | ||
71 | completeRuleCall(((RuleCall)assignment.getTerminal()), context, acceptor); | ||
72 | } | ||
73 | public void completeALSFieldDeclaration_Type(EObject model, Assignment assignment, ContentAssistContext context, ICompletionProposalAcceptor acceptor) { | ||
74 | completeRuleCall(((RuleCall)assignment.getTerminal()), context, acceptor); | ||
75 | } | ||
76 | public void completeALSFunctionDefinition_Name(EObject model, Assignment assignment, ContentAssistContext context, ICompletionProposalAcceptor acceptor) { | ||
77 | completeRuleCall(((RuleCall)assignment.getTerminal()), context, acceptor); | ||
78 | } | ||
79 | public void completeALSFunctionDefinition_Variables(EObject model, Assignment assignment, ContentAssistContext context, ICompletionProposalAcceptor acceptor) { | ||
80 | completeRuleCall(((RuleCall)assignment.getTerminal()), context, acceptor); | ||
81 | } | ||
82 | public void completeALSFunctionDefinition_Type(EObject model, Assignment assignment, ContentAssistContext context, ICompletionProposalAcceptor acceptor) { | ||
83 | completeRuleCall(((RuleCall)assignment.getTerminal()), context, acceptor); | ||
84 | } | ||
85 | public void completeALSFunctionDefinition_Value(EObject model, Assignment assignment, ContentAssistContext context, ICompletionProposalAcceptor acceptor) { | ||
86 | completeRuleCall(((RuleCall)assignment.getTerminal()), context, acceptor); | ||
87 | } | ||
88 | public void completeALSRelationDefinition_Name(EObject model, Assignment assignment, ContentAssistContext context, ICompletionProposalAcceptor acceptor) { | ||
89 | completeRuleCall(((RuleCall)assignment.getTerminal()), context, acceptor); | ||
90 | } | ||
91 | public void completeALSRelationDefinition_Variables(EObject model, Assignment assignment, ContentAssistContext context, ICompletionProposalAcceptor acceptor) { | ||
92 | completeRuleCall(((RuleCall)assignment.getTerminal()), context, acceptor); | ||
93 | } | ||
94 | public void completeALSRelationDefinition_Value(EObject model, Assignment assignment, ContentAssistContext context, ICompletionProposalAcceptor acceptor) { | ||
95 | completeRuleCall(((RuleCall)assignment.getTerminal()), context, acceptor); | ||
96 | } | ||
97 | public void completeALSFactDeclaration_Name(EObject model, Assignment assignment, ContentAssistContext context, ICompletionProposalAcceptor acceptor) { | ||
98 | completeRuleCall(((RuleCall)assignment.getTerminal()), context, acceptor); | ||
99 | } | ||
100 | public void completeALSFactDeclaration_Term(EObject model, Assignment assignment, ContentAssistContext context, ICompletionProposalAcceptor acceptor) { | ||
101 | completeRuleCall(((RuleCall)assignment.getTerminal()), context, acceptor); | ||
102 | } | ||
103 | public void completeALSQuantified_Type(EObject model, Assignment assignment, ContentAssistContext context, ICompletionProposalAcceptor acceptor) { | ||
104 | completeRuleCall(((RuleCall)assignment.getTerminal()), context, acceptor); | ||
105 | } | ||
106 | public void completeALSQuantified_Disj(EObject model, Assignment assignment, ContentAssistContext context, ICompletionProposalAcceptor acceptor) { | ||
107 | // subclasses may override | ||
108 | } | ||
109 | public void completeALSQuantified_Variables(EObject model, Assignment assignment, ContentAssistContext context, ICompletionProposalAcceptor acceptor) { | ||
110 | completeRuleCall(((RuleCall)assignment.getTerminal()), context, acceptor); | ||
111 | } | ||
112 | public void completeALSQuantified_Expression(EObject model, Assignment assignment, ContentAssistContext context, ICompletionProposalAcceptor acceptor) { | ||
113 | completeRuleCall(((RuleCall)assignment.getTerminal()), context, acceptor); | ||
114 | } | ||
115 | public void completeALSOr_RightOperand(EObject model, Assignment assignment, ContentAssistContext context, ICompletionProposalAcceptor acceptor) { | ||
116 | completeRuleCall(((RuleCall)assignment.getTerminal()), context, acceptor); | ||
117 | } | ||
118 | public void completeALSIff_RightOperand(EObject model, Assignment assignment, ContentAssistContext context, ICompletionProposalAcceptor acceptor) { | ||
119 | completeRuleCall(((RuleCall)assignment.getTerminal()), context, acceptor); | ||
120 | } | ||
121 | public void completeALSImpl_RightOperand(EObject model, Assignment assignment, ContentAssistContext context, ICompletionProposalAcceptor acceptor) { | ||
122 | completeRuleCall(((RuleCall)assignment.getTerminal()), context, acceptor); | ||
123 | } | ||
124 | public void completeALSImpl_ElseOperand(EObject model, Assignment assignment, ContentAssistContext context, ICompletionProposalAcceptor acceptor) { | ||
125 | completeRuleCall(((RuleCall)assignment.getTerminal()), context, acceptor); | ||
126 | } | ||
127 | public void completeALSAnd_RightOperand(EObject model, Assignment assignment, ContentAssistContext context, ICompletionProposalAcceptor acceptor) { | ||
128 | completeRuleCall(((RuleCall)assignment.getTerminal()), context, acceptor); | ||
129 | } | ||
130 | public void completeALSComparison_RightOperand(EObject model, Assignment assignment, ContentAssistContext context, ICompletionProposalAcceptor acceptor) { | ||
131 | completeRuleCall(((RuleCall)assignment.getTerminal()), context, acceptor); | ||
132 | } | ||
133 | public void completeALSOverride_RightOperand(EObject model, Assignment assignment, ContentAssistContext context, ICompletionProposalAcceptor acceptor) { | ||
134 | completeRuleCall(((RuleCall)assignment.getTerminal()), context, acceptor); | ||
135 | } | ||
136 | public void completeALSRangeRestrictionRight_Filter(EObject model, Assignment assignment, ContentAssistContext context, ICompletionProposalAcceptor acceptor) { | ||
137 | completeRuleCall(((RuleCall)assignment.getTerminal()), context, acceptor); | ||
138 | } | ||
139 | public void completeALSRangeRestrictionLeft_Relation(EObject model, Assignment assignment, ContentAssistContext context, ICompletionProposalAcceptor acceptor) { | ||
140 | completeRuleCall(((RuleCall)assignment.getTerminal()), context, acceptor); | ||
141 | } | ||
142 | public void completeALSJoin_RightOperand(EObject model, Assignment assignment, ContentAssistContext context, ICompletionProposalAcceptor acceptor) { | ||
143 | completeRuleCall(((RuleCall)assignment.getTerminal()), context, acceptor); | ||
144 | } | ||
145 | public void completeALSMinus_RightOperand(EObject model, Assignment assignment, ContentAssistContext context, ICompletionProposalAcceptor acceptor) { | ||
146 | completeRuleCall(((RuleCall)assignment.getTerminal()), context, acceptor); | ||
147 | } | ||
148 | public void completeALSPlus_RightOperand(EObject model, Assignment assignment, ContentAssistContext context, ICompletionProposalAcceptor acceptor) { | ||
149 | completeRuleCall(((RuleCall)assignment.getTerminal()), context, acceptor); | ||
150 | } | ||
151 | public void completeALSIntersection_RightOperand(EObject model, Assignment assignment, ContentAssistContext context, ICompletionProposalAcceptor acceptor) { | ||
152 | completeRuleCall(((RuleCall)assignment.getTerminal()), context, acceptor); | ||
153 | } | ||
154 | public void completeALSDirectProduct_LeftMultiplicit(EObject model, Assignment assignment, ContentAssistContext context, ICompletionProposalAcceptor acceptor) { | ||
155 | completeRuleCall(((RuleCall)assignment.getTerminal()), context, acceptor); | ||
156 | } | ||
157 | public void completeALSDirectProduct_RightMultiplicit(EObject model, Assignment assignment, ContentAssistContext context, ICompletionProposalAcceptor acceptor) { | ||
158 | completeRuleCall(((RuleCall)assignment.getTerminal()), context, acceptor); | ||
159 | } | ||
160 | public void completeALSDirectProduct_RightOperand(EObject model, Assignment assignment, ContentAssistContext context, ICompletionProposalAcceptor acceptor) { | ||
161 | completeRuleCall(((RuleCall)assignment.getTerminal()), context, acceptor); | ||
162 | } | ||
163 | public void completeALSPreficed_Operand(EObject model, Assignment assignment, ContentAssistContext context, ICompletionProposalAcceptor acceptor) { | ||
164 | completeRuleCall(((RuleCall)assignment.getTerminal()), context, acceptor); | ||
165 | } | ||
166 | public void completeALSPreficed_Variables(EObject model, Assignment assignment, ContentAssistContext context, ICompletionProposalAcceptor acceptor) { | ||
167 | completeRuleCall(((RuleCall)assignment.getTerminal()), context, acceptor); | ||
168 | } | ||
169 | public void completeALSPreficed_Expression(EObject model, Assignment assignment, ContentAssistContext context, ICompletionProposalAcceptor acceptor) { | ||
170 | completeRuleCall(((RuleCall)assignment.getTerminal()), context, acceptor); | ||
171 | } | ||
172 | public void completeALSPreficed_ReferredDefinition(EObject model, Assignment assignment, ContentAssistContext context, ICompletionProposalAcceptor acceptor) { | ||
173 | lookupCrossReference(((CrossReference)assignment.getTerminal()), context, acceptor); | ||
174 | } | ||
175 | public void completeALSPreficed_ReferredNumericOperator(EObject model, Assignment assignment, ContentAssistContext context, ICompletionProposalAcceptor acceptor) { | ||
176 | completeRuleCall(((RuleCall)assignment.getTerminal()), context, acceptor); | ||
177 | } | ||
178 | public void completeALSPreficed_Params(EObject model, Assignment assignment, ContentAssistContext context, ICompletionProposalAcceptor acceptor) { | ||
179 | completeRuleCall(((RuleCall)assignment.getTerminal()), context, acceptor); | ||
180 | } | ||
181 | public void completeALSVariableDeclaration_Name(EObject model, Assignment assignment, ContentAssistContext context, ICompletionProposalAcceptor acceptor) { | ||
182 | completeRuleCall(((RuleCall)assignment.getTerminal()), context, acceptor); | ||
183 | } | ||
184 | public void completeALSVariableDeclaration_Range(EObject model, Assignment assignment, ContentAssistContext context, ICompletionProposalAcceptor acceptor) { | ||
185 | completeRuleCall(((RuleCall)assignment.getTerminal()), context, acceptor); | ||
186 | } | ||
187 | public void completeALSBasicRelationTerm_Referred(EObject model, Assignment assignment, ContentAssistContext context, ICompletionProposalAcceptor acceptor) { | ||
188 | lookupCrossReference(((CrossReference)assignment.getTerminal()), context, acceptor); | ||
189 | } | ||
190 | public void completeALSBasicRelationTerm_Value(EObject model, Assignment assignment, ContentAssistContext context, ICompletionProposalAcceptor acceptor) { | ||
191 | completeRuleCall(((RuleCall)assignment.getTerminal()), context, acceptor); | ||
192 | } | ||
193 | public void completeALSRunCommand_TypeScopes(EObject model, Assignment assignment, ContentAssistContext context, ICompletionProposalAcceptor acceptor) { | ||
194 | completeRuleCall(((RuleCall)assignment.getTerminal()), context, acceptor); | ||
195 | } | ||
196 | public void completeALSSigScope_Exactly(EObject model, Assignment assignment, ContentAssistContext context, ICompletionProposalAcceptor acceptor) { | ||
197 | // subclasses may override | ||
198 | } | ||
199 | public void completeALSSigScope_Number(EObject model, Assignment assignment, ContentAssistContext context, ICompletionProposalAcceptor acceptor) { | ||
200 | completeRuleCall(((RuleCall)assignment.getTerminal()), context, acceptor); | ||
201 | } | ||
202 | public void completeALSSigScope_Type(EObject model, Assignment assignment, ContentAssistContext context, ICompletionProposalAcceptor acceptor) { | ||
203 | lookupCrossReference(((CrossReference)assignment.getTerminal()), context, acceptor); | ||
204 | } | ||
205 | public void completeALSIntScope_Number(EObject model, Assignment assignment, ContentAssistContext context, ICompletionProposalAcceptor acceptor) { | ||
206 | completeRuleCall(((RuleCall)assignment.getTerminal()), context, acceptor); | ||
207 | } | ||
208 | public void completeALSStringScope_Number(EObject model, Assignment assignment, ContentAssistContext context, ICompletionProposalAcceptor acceptor) { | ||
209 | completeRuleCall(((RuleCall)assignment.getTerminal()), context, acceptor); | ||
210 | } | ||
211 | |||
212 | public void complete_ALSDocument(EObject model, RuleCall ruleCall, ContentAssistContext context, ICompletionProposalAcceptor acceptor) { | ||
213 | // subclasses may override | ||
214 | } | ||
215 | public void complete_ALSID(EObject model, RuleCall ruleCall, ContentAssistContext context, ICompletionProposalAcceptor acceptor) { | ||
216 | // subclasses may override | ||
217 | } | ||
218 | public void complete_ALSMultiplicity(EObject model, RuleCall ruleCall, ContentAssistContext context, ICompletionProposalAcceptor acceptor) { | ||
219 | // subclasses may override | ||
220 | } | ||
221 | public void complete_ALSRelationDeclaration(EObject model, RuleCall ruleCall, ContentAssistContext context, ICompletionProposalAcceptor acceptor) { | ||
222 | // subclasses may override | ||
223 | } | ||
224 | public void complete_ALSTypeDeclaration(EObject model, RuleCall ruleCall, ContentAssistContext context, ICompletionProposalAcceptor acceptor) { | ||
225 | // subclasses may override | ||
226 | } | ||
227 | public void complete_ALSEnumDeclaration(EObject model, RuleCall ruleCall, ContentAssistContext context, ICompletionProposalAcceptor acceptor) { | ||
228 | // subclasses may override | ||
229 | } | ||
230 | public void complete_ALSEnumLiteral(EObject model, RuleCall ruleCall, ContentAssistContext context, ICompletionProposalAcceptor acceptor) { | ||
231 | // subclasses may override | ||
232 | } | ||
233 | public void complete_ALSSignatureDeclaration(EObject model, RuleCall ruleCall, ContentAssistContext context, ICompletionProposalAcceptor acceptor) { | ||
234 | // subclasses may override | ||
235 | } | ||
236 | public void complete_ALSSignatureBody(EObject model, RuleCall ruleCall, ContentAssistContext context, ICompletionProposalAcceptor acceptor) { | ||
237 | // subclasses may override | ||
238 | } | ||
239 | public void complete_ALSFieldDeclaration(EObject model, RuleCall ruleCall, ContentAssistContext context, ICompletionProposalAcceptor acceptor) { | ||
240 | // subclasses may override | ||
241 | } | ||
242 | public void complete_ALSDefinition(EObject model, RuleCall ruleCall, ContentAssistContext context, ICompletionProposalAcceptor acceptor) { | ||
243 | // subclasses may override | ||
244 | } | ||
245 | public void complete_ALSFunctionDefinition(EObject model, RuleCall ruleCall, ContentAssistContext context, ICompletionProposalAcceptor acceptor) { | ||
246 | // subclasses may override | ||
247 | } | ||
248 | public void complete_ALSRelationDefinition(EObject model, RuleCall ruleCall, ContentAssistContext context, ICompletionProposalAcceptor acceptor) { | ||
249 | // subclasses may override | ||
250 | } | ||
251 | public void complete_ALSFactDeclaration(EObject model, RuleCall ruleCall, ContentAssistContext context, ICompletionProposalAcceptor acceptor) { | ||
252 | // subclasses may override | ||
253 | } | ||
254 | public void complete_ALSTerm(EObject model, RuleCall ruleCall, ContentAssistContext context, ICompletionProposalAcceptor acceptor) { | ||
255 | // subclasses may override | ||
256 | } | ||
257 | public void complete_ALSQuantified(EObject model, RuleCall ruleCall, ContentAssistContext context, ICompletionProposalAcceptor acceptor) { | ||
258 | // subclasses may override | ||
259 | } | ||
260 | public void complete_ALSOr(EObject model, RuleCall ruleCall, ContentAssistContext context, ICompletionProposalAcceptor acceptor) { | ||
261 | // subclasses may override | ||
262 | } | ||
263 | public void complete_ALSIff(EObject model, RuleCall ruleCall, ContentAssistContext context, ICompletionProposalAcceptor acceptor) { | ||
264 | // subclasses may override | ||
265 | } | ||
266 | public void complete_ALSImpl(EObject model, RuleCall ruleCall, ContentAssistContext context, ICompletionProposalAcceptor acceptor) { | ||
267 | // subclasses may override | ||
268 | } | ||
269 | public void complete_ALSAnd(EObject model, RuleCall ruleCall, ContentAssistContext context, ICompletionProposalAcceptor acceptor) { | ||
270 | // subclasses may override | ||
271 | } | ||
272 | public void complete_ALSComparison(EObject model, RuleCall ruleCall, ContentAssistContext context, ICompletionProposalAcceptor acceptor) { | ||
273 | // subclasses may override | ||
274 | } | ||
275 | public void complete_ALSOverride(EObject model, RuleCall ruleCall, ContentAssistContext context, ICompletionProposalAcceptor acceptor) { | ||
276 | // subclasses may override | ||
277 | } | ||
278 | public void complete_ALSRangeRestrictionRight(EObject model, RuleCall ruleCall, ContentAssistContext context, ICompletionProposalAcceptor acceptor) { | ||
279 | // subclasses may override | ||
280 | } | ||
281 | public void complete_ALSRangeRestrictionLeft(EObject model, RuleCall ruleCall, ContentAssistContext context, ICompletionProposalAcceptor acceptor) { | ||
282 | // subclasses may override | ||
283 | } | ||
284 | public void complete_ALSJoin(EObject model, RuleCall ruleCall, ContentAssistContext context, ICompletionProposalAcceptor acceptor) { | ||
285 | // subclasses may override | ||
286 | } | ||
287 | public void complete_ALSMinus(EObject model, RuleCall ruleCall, ContentAssistContext context, ICompletionProposalAcceptor acceptor) { | ||
288 | // subclasses may override | ||
289 | } | ||
290 | public void complete_ALSPlus(EObject model, RuleCall ruleCall, ContentAssistContext context, ICompletionProposalAcceptor acceptor) { | ||
291 | // subclasses may override | ||
292 | } | ||
293 | public void complete_ALSIntersection(EObject model, RuleCall ruleCall, ContentAssistContext context, ICompletionProposalAcceptor acceptor) { | ||
294 | // subclasses may override | ||
295 | } | ||
296 | public void complete_ALSDirectProduct(EObject model, RuleCall ruleCall, ContentAssistContext context, ICompletionProposalAcceptor acceptor) { | ||
297 | // subclasses may override | ||
298 | } | ||
299 | public void complete_ALSPreficed(EObject model, RuleCall ruleCall, ContentAssistContext context, ICompletionProposalAcceptor acceptor) { | ||
300 | // subclasses may override | ||
301 | } | ||
302 | public void complete_ALSNumericOperator(EObject model, RuleCall ruleCall, ContentAssistContext context, ICompletionProposalAcceptor acceptor) { | ||
303 | // subclasses may override | ||
304 | } | ||
305 | public void complete_ALSVariableDeclaration(EObject model, RuleCall ruleCall, ContentAssistContext context, ICompletionProposalAcceptor acceptor) { | ||
306 | // subclasses may override | ||
307 | } | ||
308 | public void complete_ALSBasicRelationTerm(EObject model, RuleCall ruleCall, ContentAssistContext context, ICompletionProposalAcceptor acceptor) { | ||
309 | // subclasses may override | ||
310 | } | ||
311 | public void complete_ALSRunCommand(EObject model, RuleCall ruleCall, ContentAssistContext context, ICompletionProposalAcceptor acceptor) { | ||
312 | // subclasses may override | ||
313 | } | ||
314 | public void complete_ALSTypeScope(EObject model, RuleCall ruleCall, ContentAssistContext context, ICompletionProposalAcceptor acceptor) { | ||
315 | // subclasses may override | ||
316 | } | ||
317 | public void complete_ALSSigScope(EObject model, RuleCall ruleCall, ContentAssistContext context, ICompletionProposalAcceptor acceptor) { | ||
318 | // subclasses may override | ||
319 | } | ||
320 | public void complete_ALSIntScope(EObject model, RuleCall ruleCall, ContentAssistContext context, ICompletionProposalAcceptor acceptor) { | ||
321 | // subclasses may override | ||
322 | } | ||
323 | public void complete_ALSStringScope(EObject model, RuleCall ruleCall, ContentAssistContext context, ICompletionProposalAcceptor acceptor) { | ||
324 | // subclasses may override | ||
325 | } | ||
326 | } | ||
diff --git a/Solvers/Alloy-Solver2/hu.bme.mit.inf.dslreasoner.alloy.language.ui/src-gen/hu/bme/mit/inf/dslreasoner/ui/contentassist/antlr/AlloyLanguageParser.java b/Solvers/Alloy-Solver2/hu.bme.mit.inf.dslreasoner.alloy.language.ui/src-gen/hu/bme/mit/inf/dslreasoner/ui/contentassist/antlr/AlloyLanguageParser.java new file mode 100644 index 00000000..76a5f4b1 --- /dev/null +++ b/Solvers/Alloy-Solver2/hu.bme.mit.inf.dslreasoner.alloy.language.ui/src-gen/hu/bme/mit/inf/dslreasoner/ui/contentassist/antlr/AlloyLanguageParser.java | |||
@@ -0,0 +1,247 @@ | |||
1 | /* | ||
2 | * generated by Xtext | ||
3 | */ | ||
4 | package hu.bme.mit.inf.dslreasoner.ui.contentassist.antlr; | ||
5 | |||
6 | import java.util.Collection; | ||
7 | import java.util.Map; | ||
8 | import java.util.HashMap; | ||
9 | |||
10 | import org.antlr.runtime.RecognitionException; | ||
11 | import org.eclipse.xtext.AbstractElement; | ||
12 | import org.eclipse.xtext.ui.editor.contentassist.antlr.AbstractContentAssistParser; | ||
13 | import org.eclipse.xtext.ui.editor.contentassist.antlr.FollowElement; | ||
14 | import org.eclipse.xtext.ui.editor.contentassist.antlr.internal.AbstractInternalContentAssistParser; | ||
15 | |||
16 | import com.google.inject.Inject; | ||
17 | |||
18 | import hu.bme.mit.inf.dslreasoner.services.AlloyLanguageGrammarAccess; | ||
19 | |||
20 | public class AlloyLanguageParser extends AbstractContentAssistParser { | ||
21 | |||
22 | @Inject | ||
23 | private AlloyLanguageGrammarAccess grammarAccess; | ||
24 | |||
25 | private Map<AbstractElement, String> nameMappings; | ||
26 | |||
27 | @Override | ||
28 | protected hu.bme.mit.inf.dslreasoner.ui.contentassist.antlr.internal.InternalAlloyLanguageParser createParser() { | ||
29 | hu.bme.mit.inf.dslreasoner.ui.contentassist.antlr.internal.InternalAlloyLanguageParser result = new hu.bme.mit.inf.dslreasoner.ui.contentassist.antlr.internal.InternalAlloyLanguageParser(null); | ||
30 | result.setGrammarAccess(grammarAccess); | ||
31 | return result; | ||
32 | } | ||
33 | |||
34 | @Override | ||
35 | protected String getRuleName(AbstractElement element) { | ||
36 | if (nameMappings == null) { | ||
37 | nameMappings = new HashMap<AbstractElement, String>() { | ||
38 | private static final long serialVersionUID = 1L; | ||
39 | { | ||
40 | put(grammarAccess.getALSDocumentAccess().getAlternatives_0(), "rule__ALSDocument__Alternatives_0"); | ||
41 | put(grammarAccess.getALSRelationDeclarationAccess().getAlternatives(), "rule__ALSRelationDeclaration__Alternatives"); | ||
42 | put(grammarAccess.getALSTypeDeclarationAccess().getAlternatives(), "rule__ALSTypeDeclaration__Alternatives"); | ||
43 | put(grammarAccess.getALSSignatureBodyAccess().getAlternatives_4(), "rule__ALSSignatureBody__Alternatives_4"); | ||
44 | put(grammarAccess.getALSDefinitionAccess().getAlternatives(), "rule__ALSDefinition__Alternatives"); | ||
45 | put(grammarAccess.getALSQuantifiedAccess().getAlternatives(), "rule__ALSQuantified__Alternatives"); | ||
46 | put(grammarAccess.getALSOrAccess().getAlternatives_1_1(), "rule__ALSOr__Alternatives_1_1"); | ||
47 | put(grammarAccess.getALSIffAccess().getAlternatives_1_1(), "rule__ALSIff__Alternatives_1_1"); | ||
48 | put(grammarAccess.getALSImplAccess().getAlternatives_1_1(), "rule__ALSImpl__Alternatives_1_1"); | ||
49 | put(grammarAccess.getALSAndAccess().getAlternatives_1_1(), "rule__ALSAnd__Alternatives_1_1"); | ||
50 | put(grammarAccess.getALSComparisonAccess().getAlternatives_1_0(), "rule__ALSComparison__Alternatives_1_0"); | ||
51 | put(grammarAccess.getALSPreficedAccess().getAlternatives(), "rule__ALSPreficed__Alternatives"); | ||
52 | put(grammarAccess.getALSPreficedAccess().getAlternatives_0_1_0(), "rule__ALSPreficed__Alternatives_0_1_0"); | ||
53 | put(grammarAccess.getALSPreficedAccess().getAlternatives_7_1(), "rule__ALSPreficed__Alternatives_7_1"); | ||
54 | put(grammarAccess.getALSBasicRelationTermAccess().getAlternatives(), "rule__ALSBasicRelationTerm__Alternatives"); | ||
55 | put(grammarAccess.getALSTypeScopeAccess().getAlternatives(), "rule__ALSTypeScope__Alternatives"); | ||
56 | put(grammarAccess.getALSMultiplicityAccess().getAlternatives(), "rule__ALSMultiplicity__Alternatives"); | ||
57 | put(grammarAccess.getALSNumericOperatorAccess().getAlternatives(), "rule__ALSNumericOperator__Alternatives"); | ||
58 | put(grammarAccess.getALSDocumentAccess().getGroup(), "rule__ALSDocument__Group__0"); | ||
59 | put(grammarAccess.getALSEnumDeclarationAccess().getGroup(), "rule__ALSEnumDeclaration__Group__0"); | ||
60 | put(grammarAccess.getALSEnumDeclarationAccess().getGroup_4(), "rule__ALSEnumDeclaration__Group_4__0"); | ||
61 | put(grammarAccess.getALSSignatureBodyAccess().getGroup(), "rule__ALSSignatureBody__Group__0"); | ||
62 | put(grammarAccess.getALSSignatureBodyAccess().getGroup_3(), "rule__ALSSignatureBody__Group_3__0"); | ||
63 | put(grammarAccess.getALSSignatureBodyAccess().getGroup_4_0(), "rule__ALSSignatureBody__Group_4_0__0"); | ||
64 | put(grammarAccess.getALSSignatureBodyAccess().getGroup_4_1(), "rule__ALSSignatureBody__Group_4_1__0"); | ||
65 | put(grammarAccess.getALSSignatureBodyAccess().getGroup_4_1_2(), "rule__ALSSignatureBody__Group_4_1_2__0"); | ||
66 | put(grammarAccess.getALSSignatureBodyAccess().getGroup_6(), "rule__ALSSignatureBody__Group_6__0"); | ||
67 | put(grammarAccess.getALSSignatureBodyAccess().getGroup_6_1(), "rule__ALSSignatureBody__Group_6_1__0"); | ||
68 | put(grammarAccess.getALSFieldDeclarationAccess().getGroup(), "rule__ALSFieldDeclaration__Group__0"); | ||
69 | put(grammarAccess.getALSFunctionDefinitionAccess().getGroup(), "rule__ALSFunctionDefinition__Group__0"); | ||
70 | put(grammarAccess.getALSFunctionDefinitionAccess().getGroup_4(), "rule__ALSFunctionDefinition__Group_4__0"); | ||
71 | put(grammarAccess.getALSRelationDefinitionAccess().getGroup(), "rule__ALSRelationDefinition__Group__0"); | ||
72 | put(grammarAccess.getALSRelationDefinitionAccess().getGroup_4(), "rule__ALSRelationDefinition__Group_4__0"); | ||
73 | put(grammarAccess.getALSFactDeclarationAccess().getGroup(), "rule__ALSFactDeclaration__Group__0"); | ||
74 | put(grammarAccess.getALSQuantifiedAccess().getGroup_0(), "rule__ALSQuantified__Group_0__0"); | ||
75 | put(grammarAccess.getALSQuantifiedAccess().getGroup_0_4(), "rule__ALSQuantified__Group_0_4__0"); | ||
76 | put(grammarAccess.getALSOrAccess().getGroup(), "rule__ALSOr__Group__0"); | ||
77 | put(grammarAccess.getALSOrAccess().getGroup_1(), "rule__ALSOr__Group_1__0"); | ||
78 | put(grammarAccess.getALSIffAccess().getGroup(), "rule__ALSIff__Group__0"); | ||
79 | put(grammarAccess.getALSIffAccess().getGroup_1(), "rule__ALSIff__Group_1__0"); | ||
80 | put(grammarAccess.getALSImplAccess().getGroup(), "rule__ALSImpl__Group__0"); | ||
81 | put(grammarAccess.getALSImplAccess().getGroup_1(), "rule__ALSImpl__Group_1__0"); | ||
82 | put(grammarAccess.getALSImplAccess().getGroup_1_3(), "rule__ALSImpl__Group_1_3__0"); | ||
83 | put(grammarAccess.getALSAndAccess().getGroup(), "rule__ALSAnd__Group__0"); | ||
84 | put(grammarAccess.getALSAndAccess().getGroup_1(), "rule__ALSAnd__Group_1__0"); | ||
85 | put(grammarAccess.getALSComparisonAccess().getGroup(), "rule__ALSComparison__Group__0"); | ||
86 | put(grammarAccess.getALSComparisonAccess().getGroup_1(), "rule__ALSComparison__Group_1__0"); | ||
87 | put(grammarAccess.getALSComparisonAccess().getGroup_1_0_0(), "rule__ALSComparison__Group_1_0_0__0"); | ||
88 | put(grammarAccess.getALSComparisonAccess().getGroup_1_0_1(), "rule__ALSComparison__Group_1_0_1__0"); | ||
89 | put(grammarAccess.getALSComparisonAccess().getGroup_1_0_2(), "rule__ALSComparison__Group_1_0_2__0"); | ||
90 | put(grammarAccess.getALSComparisonAccess().getGroup_1_0_3(), "rule__ALSComparison__Group_1_0_3__0"); | ||
91 | put(grammarAccess.getALSComparisonAccess().getGroup_1_0_4(), "rule__ALSComparison__Group_1_0_4__0"); | ||
92 | put(grammarAccess.getALSComparisonAccess().getGroup_1_0_5(), "rule__ALSComparison__Group_1_0_5__0"); | ||
93 | put(grammarAccess.getALSComparisonAccess().getGroup_1_0_6(), "rule__ALSComparison__Group_1_0_6__0"); | ||
94 | put(grammarAccess.getALSOverrideAccess().getGroup(), "rule__ALSOverride__Group__0"); | ||
95 | put(grammarAccess.getALSOverrideAccess().getGroup_1(), "rule__ALSOverride__Group_1__0"); | ||
96 | put(grammarAccess.getALSRangeRestrictionRightAccess().getGroup(), "rule__ALSRangeRestrictionRight__Group__0"); | ||
97 | put(grammarAccess.getALSRangeRestrictionRightAccess().getGroup_1(), "rule__ALSRangeRestrictionRight__Group_1__0"); | ||
98 | put(grammarAccess.getALSRangeRestrictionLeftAccess().getGroup(), "rule__ALSRangeRestrictionLeft__Group__0"); | ||
99 | put(grammarAccess.getALSRangeRestrictionLeftAccess().getGroup_1(), "rule__ALSRangeRestrictionLeft__Group_1__0"); | ||
100 | put(grammarAccess.getALSJoinAccess().getGroup(), "rule__ALSJoin__Group__0"); | ||
101 | put(grammarAccess.getALSJoinAccess().getGroup_1(), "rule__ALSJoin__Group_1__0"); | ||
102 | put(grammarAccess.getALSMinusAccess().getGroup(), "rule__ALSMinus__Group__0"); | ||
103 | put(grammarAccess.getALSMinusAccess().getGroup_1(), "rule__ALSMinus__Group_1__0"); | ||
104 | put(grammarAccess.getALSPlusAccess().getGroup(), "rule__ALSPlus__Group__0"); | ||
105 | put(grammarAccess.getALSPlusAccess().getGroup_1(), "rule__ALSPlus__Group_1__0"); | ||
106 | put(grammarAccess.getALSIntersectionAccess().getGroup(), "rule__ALSIntersection__Group__0"); | ||
107 | put(grammarAccess.getALSIntersectionAccess().getGroup_1(), "rule__ALSIntersection__Group_1__0"); | ||
108 | put(grammarAccess.getALSDirectProductAccess().getGroup(), "rule__ALSDirectProduct__Group__0"); | ||
109 | put(grammarAccess.getALSDirectProductAccess().getGroup_1(), "rule__ALSDirectProduct__Group_1__0"); | ||
110 | put(grammarAccess.getALSPreficedAccess().getGroup_0(), "rule__ALSPreficed__Group_0__0"); | ||
111 | put(grammarAccess.getALSPreficedAccess().getGroup_0_1(), "rule__ALSPreficed__Group_0_1__0"); | ||
112 | put(grammarAccess.getALSPreficedAccess().getGroup_1(), "rule__ALSPreficed__Group_1__0"); | ||
113 | put(grammarAccess.getALSPreficedAccess().getGroup_2(), "rule__ALSPreficed__Group_2__0"); | ||
114 | put(grammarAccess.getALSPreficedAccess().getGroup_3(), "rule__ALSPreficed__Group_3__0"); | ||
115 | put(grammarAccess.getALSPreficedAccess().getGroup_4(), "rule__ALSPreficed__Group_4__0"); | ||
116 | put(grammarAccess.getALSPreficedAccess().getGroup_5(), "rule__ALSPreficed__Group_5__0"); | ||
117 | put(grammarAccess.getALSPreficedAccess().getGroup_6(), "rule__ALSPreficed__Group_6__0"); | ||
118 | put(grammarAccess.getALSPreficedAccess().getGroup_6_3(), "rule__ALSPreficed__Group_6_3__0"); | ||
119 | put(grammarAccess.getALSPreficedAccess().getGroup_7(), "rule__ALSPreficed__Group_7__0"); | ||
120 | put(grammarAccess.getALSPreficedAccess().getGroup_7_4(), "rule__ALSPreficed__Group_7_4__0"); | ||
121 | put(grammarAccess.getALSVariableDeclarationAccess().getGroup(), "rule__ALSVariableDeclaration__Group__0"); | ||
122 | put(grammarAccess.getALSBasicRelationTermAccess().getGroup_0(), "rule__ALSBasicRelationTerm__Group_0__0"); | ||
123 | put(grammarAccess.getALSBasicRelationTermAccess().getGroup_1(), "rule__ALSBasicRelationTerm__Group_1__0"); | ||
124 | put(grammarAccess.getALSBasicRelationTermAccess().getGroup_2(), "rule__ALSBasicRelationTerm__Group_2__0"); | ||
125 | put(grammarAccess.getALSBasicRelationTermAccess().getGroup_3(), "rule__ALSBasicRelationTerm__Group_3__0"); | ||
126 | put(grammarAccess.getALSBasicRelationTermAccess().getGroup_4(), "rule__ALSBasicRelationTerm__Group_4__0"); | ||
127 | put(grammarAccess.getALSBasicRelationTermAccess().getGroup_5(), "rule__ALSBasicRelationTerm__Group_5__0"); | ||
128 | put(grammarAccess.getALSBasicRelationTermAccess().getGroup_6(), "rule__ALSBasicRelationTerm__Group_6__0"); | ||
129 | put(grammarAccess.getALSBasicRelationTermAccess().getGroup_7(), "rule__ALSBasicRelationTerm__Group_7__0"); | ||
130 | put(grammarAccess.getALSBasicRelationTermAccess().getGroup_8(), "rule__ALSBasicRelationTerm__Group_8__0"); | ||
131 | put(grammarAccess.getALSRunCommandAccess().getGroup(), "rule__ALSRunCommand__Group__0"); | ||
132 | put(grammarAccess.getALSRunCommandAccess().getGroup_4(), "rule__ALSRunCommand__Group_4__0"); | ||
133 | put(grammarAccess.getALSRunCommandAccess().getGroup_4_2(), "rule__ALSRunCommand__Group_4_2__0"); | ||
134 | put(grammarAccess.getALSSigScopeAccess().getGroup(), "rule__ALSSigScope__Group__0"); | ||
135 | put(grammarAccess.getALSIntScopeAccess().getGroup(), "rule__ALSIntScope__Group__0"); | ||
136 | put(grammarAccess.getALSStringScopeAccess().getGroup(), "rule__ALSStringScope__Group__0"); | ||
137 | put(grammarAccess.getALSDocumentAccess().getEnumDeclarationsAssignment_0_0(), "rule__ALSDocument__EnumDeclarationsAssignment_0_0"); | ||
138 | put(grammarAccess.getALSDocumentAccess().getSignatureBodiesAssignment_0_1(), "rule__ALSDocument__SignatureBodiesAssignment_0_1"); | ||
139 | put(grammarAccess.getALSDocumentAccess().getFunctionDefinitionsAssignment_0_2(), "rule__ALSDocument__FunctionDefinitionsAssignment_0_2"); | ||
140 | put(grammarAccess.getALSDocumentAccess().getRelationDefinitionsAssignment_0_3(), "rule__ALSDocument__RelationDefinitionsAssignment_0_3"); | ||
141 | put(grammarAccess.getALSDocumentAccess().getFactDeclarationsAssignment_0_4(), "rule__ALSDocument__FactDeclarationsAssignment_0_4"); | ||
142 | put(grammarAccess.getALSDocumentAccess().getRunCommandAssignment_1(), "rule__ALSDocument__RunCommandAssignment_1"); | ||
143 | put(grammarAccess.getALSEnumDeclarationAccess().getNameAssignment_1(), "rule__ALSEnumDeclaration__NameAssignment_1"); | ||
144 | put(grammarAccess.getALSEnumDeclarationAccess().getLiteralAssignment_3(), "rule__ALSEnumDeclaration__LiteralAssignment_3"); | ||
145 | put(grammarAccess.getALSEnumDeclarationAccess().getLiteralAssignment_4_1(), "rule__ALSEnumDeclaration__LiteralAssignment_4_1"); | ||
146 | put(grammarAccess.getALSEnumLiteralAccess().getNameAssignment(), "rule__ALSEnumLiteral__NameAssignment"); | ||
147 | put(grammarAccess.getALSSignatureDeclarationAccess().getNameAssignment(), "rule__ALSSignatureDeclaration__NameAssignment"); | ||
148 | put(grammarAccess.getALSSignatureBodyAccess().getMultiplicityAssignment_0_0(), "rule__ALSSignatureBody__MultiplicityAssignment_0_0"); | ||
149 | put(grammarAccess.getALSSignatureBodyAccess().getAbstractAssignment_0_1(), "rule__ALSSignatureBody__AbstractAssignment_0_1"); | ||
150 | put(grammarAccess.getALSSignatureBodyAccess().getDeclarationsAssignment_2(), "rule__ALSSignatureBody__DeclarationsAssignment_2"); | ||
151 | put(grammarAccess.getALSSignatureBodyAccess().getDeclarationsAssignment_3_1(), "rule__ALSSignatureBody__DeclarationsAssignment_3_1"); | ||
152 | put(grammarAccess.getALSSignatureBodyAccess().getSupertypeAssignment_4_0_1(), "rule__ALSSignatureBody__SupertypeAssignment_4_0_1"); | ||
153 | put(grammarAccess.getALSSignatureBodyAccess().getSupersetAssignment_4_1_1(), "rule__ALSSignatureBody__SupersetAssignment_4_1_1"); | ||
154 | put(grammarAccess.getALSSignatureBodyAccess().getSupersetAssignment_4_1_2_1(), "rule__ALSSignatureBody__SupersetAssignment_4_1_2_1"); | ||
155 | put(grammarAccess.getALSSignatureBodyAccess().getFieldsAssignment_6_0(), "rule__ALSSignatureBody__FieldsAssignment_6_0"); | ||
156 | put(grammarAccess.getALSSignatureBodyAccess().getFieldsAssignment_6_1_1(), "rule__ALSSignatureBody__FieldsAssignment_6_1_1"); | ||
157 | put(grammarAccess.getALSFieldDeclarationAccess().getNameAssignment_0(), "rule__ALSFieldDeclaration__NameAssignment_0"); | ||
158 | put(grammarAccess.getALSFieldDeclarationAccess().getMultiplicityAssignment_2(), "rule__ALSFieldDeclaration__MultiplicityAssignment_2"); | ||
159 | put(grammarAccess.getALSFieldDeclarationAccess().getTypeAssignment_3(), "rule__ALSFieldDeclaration__TypeAssignment_3"); | ||
160 | put(grammarAccess.getALSFunctionDefinitionAccess().getNameAssignment_1(), "rule__ALSFunctionDefinition__NameAssignment_1"); | ||
161 | put(grammarAccess.getALSFunctionDefinitionAccess().getVariablesAssignment_3(), "rule__ALSFunctionDefinition__VariablesAssignment_3"); | ||
162 | put(grammarAccess.getALSFunctionDefinitionAccess().getVariablesAssignment_4_1(), "rule__ALSFunctionDefinition__VariablesAssignment_4_1"); | ||
163 | put(grammarAccess.getALSFunctionDefinitionAccess().getTypeAssignment_7(), "rule__ALSFunctionDefinition__TypeAssignment_7"); | ||
164 | put(grammarAccess.getALSFunctionDefinitionAccess().getValueAssignment_9(), "rule__ALSFunctionDefinition__ValueAssignment_9"); | ||
165 | put(grammarAccess.getALSRelationDefinitionAccess().getNameAssignment_1(), "rule__ALSRelationDefinition__NameAssignment_1"); | ||
166 | put(grammarAccess.getALSRelationDefinitionAccess().getVariablesAssignment_3(), "rule__ALSRelationDefinition__VariablesAssignment_3"); | ||
167 | put(grammarAccess.getALSRelationDefinitionAccess().getVariablesAssignment_4_1(), "rule__ALSRelationDefinition__VariablesAssignment_4_1"); | ||
168 | put(grammarAccess.getALSRelationDefinitionAccess().getValueAssignment_7(), "rule__ALSRelationDefinition__ValueAssignment_7"); | ||
169 | put(grammarAccess.getALSFactDeclarationAccess().getNameAssignment_2(), "rule__ALSFactDeclaration__NameAssignment_2"); | ||
170 | put(grammarAccess.getALSFactDeclarationAccess().getTermAssignment_4(), "rule__ALSFactDeclaration__TermAssignment_4"); | ||
171 | put(grammarAccess.getALSQuantifiedAccess().getTypeAssignment_0_1(), "rule__ALSQuantified__TypeAssignment_0_1"); | ||
172 | put(grammarAccess.getALSQuantifiedAccess().getDisjAssignment_0_2(), "rule__ALSQuantified__DisjAssignment_0_2"); | ||
173 | put(grammarAccess.getALSQuantifiedAccess().getVariablesAssignment_0_3(), "rule__ALSQuantified__VariablesAssignment_0_3"); | ||
174 | put(grammarAccess.getALSQuantifiedAccess().getVariablesAssignment_0_4_1(), "rule__ALSQuantified__VariablesAssignment_0_4_1"); | ||
175 | put(grammarAccess.getALSQuantifiedAccess().getExpressionAssignment_0_6(), "rule__ALSQuantified__ExpressionAssignment_0_6"); | ||
176 | put(grammarAccess.getALSOrAccess().getRightOperandAssignment_1_2(), "rule__ALSOr__RightOperandAssignment_1_2"); | ||
177 | put(grammarAccess.getALSIffAccess().getRightOperandAssignment_1_2(), "rule__ALSIff__RightOperandAssignment_1_2"); | ||
178 | put(grammarAccess.getALSImplAccess().getRightOperandAssignment_1_2(), "rule__ALSImpl__RightOperandAssignment_1_2"); | ||
179 | put(grammarAccess.getALSImplAccess().getElseOperandAssignment_1_3_1(), "rule__ALSImpl__ElseOperandAssignment_1_3_1"); | ||
180 | put(grammarAccess.getALSAndAccess().getRightOperandAssignment_1_2(), "rule__ALSAnd__RightOperandAssignment_1_2"); | ||
181 | put(grammarAccess.getALSComparisonAccess().getRightOperandAssignment_1_1(), "rule__ALSComparison__RightOperandAssignment_1_1"); | ||
182 | put(grammarAccess.getALSOverrideAccess().getRightOperandAssignment_1_2(), "rule__ALSOverride__RightOperandAssignment_1_2"); | ||
183 | put(grammarAccess.getALSRangeRestrictionRightAccess().getFilterAssignment_1_2(), "rule__ALSRangeRestrictionRight__FilterAssignment_1_2"); | ||
184 | put(grammarAccess.getALSRangeRestrictionLeftAccess().getRelationAssignment_1_2(), "rule__ALSRangeRestrictionLeft__RelationAssignment_1_2"); | ||
185 | put(grammarAccess.getALSJoinAccess().getRightOperandAssignment_1_2(), "rule__ALSJoin__RightOperandAssignment_1_2"); | ||
186 | put(grammarAccess.getALSMinusAccess().getRightOperandAssignment_1_2(), "rule__ALSMinus__RightOperandAssignment_1_2"); | ||
187 | put(grammarAccess.getALSPlusAccess().getRightOperandAssignment_1_2(), "rule__ALSPlus__RightOperandAssignment_1_2"); | ||
188 | put(grammarAccess.getALSIntersectionAccess().getRightOperandAssignment_1_2(), "rule__ALSIntersection__RightOperandAssignment_1_2"); | ||
189 | put(grammarAccess.getALSDirectProductAccess().getLeftMultiplicitAssignment_1_1(), "rule__ALSDirectProduct__LeftMultiplicitAssignment_1_1"); | ||
190 | put(grammarAccess.getALSDirectProductAccess().getRightMultiplicitAssignment_1_3(), "rule__ALSDirectProduct__RightMultiplicitAssignment_1_3"); | ||
191 | put(grammarAccess.getALSDirectProductAccess().getRightOperandAssignment_1_4(), "rule__ALSDirectProduct__RightOperandAssignment_1_4"); | ||
192 | put(grammarAccess.getALSPreficedAccess().getOperandAssignment_0_2(), "rule__ALSPreficed__OperandAssignment_0_2"); | ||
193 | put(grammarAccess.getALSPreficedAccess().getOperandAssignment_1_2(), "rule__ALSPreficed__OperandAssignment_1_2"); | ||
194 | put(grammarAccess.getALSPreficedAccess().getOperandAssignment_2_2(), "rule__ALSPreficed__OperandAssignment_2_2"); | ||
195 | put(grammarAccess.getALSPreficedAccess().getOperandAssignment_3_2(), "rule__ALSPreficed__OperandAssignment_3_2"); | ||
196 | put(grammarAccess.getALSPreficedAccess().getOperandAssignment_4_2(), "rule__ALSPreficed__OperandAssignment_4_2"); | ||
197 | put(grammarAccess.getALSPreficedAccess().getOperandAssignment_5_2(), "rule__ALSPreficed__OperandAssignment_5_2"); | ||
198 | put(grammarAccess.getALSPreficedAccess().getVariablesAssignment_6_2(), "rule__ALSPreficed__VariablesAssignment_6_2"); | ||
199 | put(grammarAccess.getALSPreficedAccess().getVariablesAssignment_6_3_1(), "rule__ALSPreficed__VariablesAssignment_6_3_1"); | ||
200 | put(grammarAccess.getALSPreficedAccess().getExpressionAssignment_6_5(), "rule__ALSPreficed__ExpressionAssignment_6_5"); | ||
201 | put(grammarAccess.getALSPreficedAccess().getReferredDefinitionAssignment_7_1_0(), "rule__ALSPreficed__ReferredDefinitionAssignment_7_1_0"); | ||
202 | put(grammarAccess.getALSPreficedAccess().getReferredNumericOperatorAssignment_7_1_1(), "rule__ALSPreficed__ReferredNumericOperatorAssignment_7_1_1"); | ||
203 | put(grammarAccess.getALSPreficedAccess().getParamsAssignment_7_3(), "rule__ALSPreficed__ParamsAssignment_7_3"); | ||
204 | put(grammarAccess.getALSPreficedAccess().getParamsAssignment_7_4_1(), "rule__ALSPreficed__ParamsAssignment_7_4_1"); | ||
205 | put(grammarAccess.getALSVariableDeclarationAccess().getNameAssignment_0(), "rule__ALSVariableDeclaration__NameAssignment_0"); | ||
206 | put(grammarAccess.getALSVariableDeclarationAccess().getRangeAssignment_2(), "rule__ALSVariableDeclaration__RangeAssignment_2"); | ||
207 | put(grammarAccess.getALSBasicRelationTermAccess().getReferredAssignment_5_1(), "rule__ALSBasicRelationTerm__ReferredAssignment_5_1"); | ||
208 | put(grammarAccess.getALSBasicRelationTermAccess().getValueAssignment_6_1(), "rule__ALSBasicRelationTerm__ValueAssignment_6_1"); | ||
209 | put(grammarAccess.getALSBasicRelationTermAccess().getValueAssignment_7_1(), "rule__ALSBasicRelationTerm__ValueAssignment_7_1"); | ||
210 | put(grammarAccess.getALSRunCommandAccess().getTypeScopesAssignment_4_1(), "rule__ALSRunCommand__TypeScopesAssignment_4_1"); | ||
211 | put(grammarAccess.getALSRunCommandAccess().getTypeScopesAssignment_4_2_1(), "rule__ALSRunCommand__TypeScopesAssignment_4_2_1"); | ||
212 | put(grammarAccess.getALSSigScopeAccess().getExactlyAssignment_0(), "rule__ALSSigScope__ExactlyAssignment_0"); | ||
213 | put(grammarAccess.getALSSigScopeAccess().getNumberAssignment_1(), "rule__ALSSigScope__NumberAssignment_1"); | ||
214 | put(grammarAccess.getALSSigScopeAccess().getTypeAssignment_2(), "rule__ALSSigScope__TypeAssignment_2"); | ||
215 | put(grammarAccess.getALSIntScopeAccess().getNumberAssignment_0(), "rule__ALSIntScope__NumberAssignment_0"); | ||
216 | put(grammarAccess.getALSStringScopeAccess().getNumberAssignment_1(), "rule__ALSStringScope__NumberAssignment_1"); | ||
217 | put(grammarAccess.getALSSignatureBodyAccess().getUnorderedGroup_0(), "rule__ALSSignatureBody__UnorderedGroup_0"); | ||
218 | } | ||
219 | }; | ||
220 | } | ||
221 | return nameMappings.get(element); | ||
222 | } | ||
223 | |||
224 | @Override | ||
225 | protected Collection<FollowElement> getFollowElements(AbstractInternalContentAssistParser parser) { | ||
226 | try { | ||
227 | hu.bme.mit.inf.dslreasoner.ui.contentassist.antlr.internal.InternalAlloyLanguageParser typedParser = (hu.bme.mit.inf.dslreasoner.ui.contentassist.antlr.internal.InternalAlloyLanguageParser) parser; | ||
228 | typedParser.entryRuleALSDocument(); | ||
229 | return typedParser.getFollowElements(); | ||
230 | } catch(RecognitionException ex) { | ||
231 | throw new RuntimeException(ex); | ||
232 | } | ||
233 | } | ||
234 | |||
235 | @Override | ||
236 | protected String[] getInitialHiddenTokens() { | ||
237 | return new String[] { "RULE_WS", "RULE_ML_COMMENT", "RULE_SL_COMMENT" }; | ||
238 | } | ||
239 | |||
240 | public AlloyLanguageGrammarAccess getGrammarAccess() { | ||
241 | return this.grammarAccess; | ||
242 | } | ||
243 | |||
244 | public void setGrammarAccess(AlloyLanguageGrammarAccess grammarAccess) { | ||
245 | this.grammarAccess = grammarAccess; | ||
246 | } | ||
247 | } | ||
diff --git a/Solvers/Alloy-Solver2/hu.bme.mit.inf.dslreasoner.alloy.language.ui/src-gen/hu/bme/mit/inf/dslreasoner/ui/contentassist/antlr/PartialAlloyLanguageContentAssistParser.java b/Solvers/Alloy-Solver2/hu.bme.mit.inf.dslreasoner.alloy.language.ui/src-gen/hu/bme/mit/inf/dslreasoner/ui/contentassist/antlr/PartialAlloyLanguageContentAssistParser.java new file mode 100644 index 00000000..a0c9d257 --- /dev/null +++ b/Solvers/Alloy-Solver2/hu.bme.mit.inf.dslreasoner.alloy.language.ui/src-gen/hu/bme/mit/inf/dslreasoner/ui/contentassist/antlr/PartialAlloyLanguageContentAssistParser.java | |||
@@ -0,0 +1,38 @@ | |||
1 | /* | ||
2 | * generated by Xtext | ||
3 | */ | ||
4 | package hu.bme.mit.inf.dslreasoner.ui.contentassist.antlr; | ||
5 | |||
6 | import java.util.Collection; | ||
7 | import java.util.Collections; | ||
8 | |||
9 | import org.eclipse.xtext.AbstractRule; | ||
10 | import org.eclipse.xtext.ui.codetemplates.ui.partialEditing.IPartialContentAssistParser; | ||
11 | import org.eclipse.xtext.ui.editor.contentassist.antlr.FollowElement; | ||
12 | import org.eclipse.xtext.ui.editor.contentassist.antlr.internal.AbstractInternalContentAssistParser; | ||
13 | import org.eclipse.xtext.util.PolymorphicDispatcher; | ||
14 | |||
15 | /* | ||
16 | * Template CodetemplatesGeneratorFragment.xpt | ||
17 | */ | ||
18 | public class PartialAlloyLanguageContentAssistParser extends AlloyLanguageParser implements IPartialContentAssistParser { | ||
19 | |||
20 | private AbstractRule rule; | ||
21 | |||
22 | @Override | ||
23 | public void initializeFor(AbstractRule rule) { | ||
24 | this.rule = rule; | ||
25 | } | ||
26 | |||
27 | @Override | ||
28 | protected Collection<FollowElement> getFollowElements(AbstractInternalContentAssistParser parser) { | ||
29 | if (rule == null || rule.eIsProxy()) | ||
30 | return Collections.emptyList(); | ||
31 | String methodName = "entryRule" + rule.getName(); | ||
32 | PolymorphicDispatcher<Collection<FollowElement>> dispatcher = | ||
33 | new PolymorphicDispatcher<Collection<FollowElement>>(methodName, 0, 0, Collections.singletonList(parser)); | ||
34 | dispatcher.invoke(); | ||
35 | return parser.getFollowElements(); | ||
36 | } | ||
37 | |||
38 | } | ||
diff --git a/Solvers/Alloy-Solver2/hu.bme.mit.inf.dslreasoner.alloy.language.ui/src-gen/hu/bme/mit/inf/dslreasoner/ui/contentassist/antlr/internal/InternalAlloyLanguage.g b/Solvers/Alloy-Solver2/hu.bme.mit.inf.dslreasoner.alloy.language.ui/src-gen/hu/bme/mit/inf/dslreasoner/ui/contentassist/antlr/internal/InternalAlloyLanguage.g new file mode 100644 index 00000000..b374de9a --- /dev/null +++ b/Solvers/Alloy-Solver2/hu.bme.mit.inf.dslreasoner.alloy.language.ui/src-gen/hu/bme/mit/inf/dslreasoner/ui/contentassist/antlr/internal/InternalAlloyLanguage.g | |||
@@ -0,0 +1,10392 @@ | |||
1 | /* | ||
2 | * generated by Xtext | ||
3 | */ | ||
4 | grammar InternalAlloyLanguage; | ||
5 | |||
6 | options { | ||
7 | superClass=AbstractInternalContentAssistParser; | ||
8 | backtrack=true; | ||
9 | |||
10 | } | ||
11 | |||
12 | @lexer::header { | ||
13 | package hu.bme.mit.inf.dslreasoner.ui.contentassist.antlr.internal; | ||
14 | |||
15 | // Hack: Use our own Lexer superclass by means of import. | ||
16 | // Currently there is no other way to specify the superclass for the lexer. | ||
17 | import org.eclipse.xtext.ui.editor.contentassist.antlr.internal.Lexer; | ||
18 | } | ||
19 | |||
20 | @parser::header { | ||
21 | package hu.bme.mit.inf.dslreasoner.ui.contentassist.antlr.internal; | ||
22 | |||
23 | import java.io.InputStream; | ||
24 | import org.eclipse.xtext.*; | ||
25 | import org.eclipse.xtext.parser.*; | ||
26 | import org.eclipse.xtext.parser.impl.*; | ||
27 | import org.eclipse.emf.ecore.util.EcoreUtil; | ||
28 | import org.eclipse.emf.ecore.EObject; | ||
29 | import org.eclipse.xtext.parser.antlr.XtextTokenStream; | ||
30 | import org.eclipse.xtext.parser.antlr.XtextTokenStream.HiddenTokens; | ||
31 | import org.eclipse.xtext.ui.editor.contentassist.antlr.internal.AbstractInternalContentAssistParser; | ||
32 | import org.eclipse.xtext.ui.editor.contentassist.antlr.internal.DFA; | ||
33 | import hu.bme.mit.inf.dslreasoner.services.AlloyLanguageGrammarAccess; | ||
34 | |||
35 | } | ||
36 | |||
37 | @parser::members { | ||
38 | |||
39 | private AlloyLanguageGrammarAccess grammarAccess; | ||
40 | |||
41 | public void setGrammarAccess(AlloyLanguageGrammarAccess grammarAccess) { | ||
42 | this.grammarAccess = grammarAccess; | ||
43 | } | ||
44 | |||
45 | @Override | ||
46 | protected Grammar getGrammar() { | ||
47 | return grammarAccess.getGrammar(); | ||
48 | } | ||
49 | |||
50 | @Override | ||
51 | protected String getValueForTokenName(String tokenName) { | ||
52 | return tokenName; | ||
53 | } | ||
54 | |||
55 | } | ||
56 | |||
57 | |||
58 | |||
59 | |||
60 | // Entry rule entryRuleALSDocument | ||
61 | entryRuleALSDocument | ||
62 | : | ||
63 | { before(grammarAccess.getALSDocumentRule()); } | ||
64 | ruleALSDocument | ||
65 | { after(grammarAccess.getALSDocumentRule()); } | ||
66 | EOF | ||
67 | ; | ||
68 | |||
69 | // Rule ALSDocument | ||
70 | ruleALSDocument | ||
71 | @init { | ||
72 | int stackSize = keepStackSize(); | ||
73 | } | ||
74 | : | ||
75 | ( | ||
76 | { before(grammarAccess.getALSDocumentAccess().getGroup()); } | ||
77 | (rule__ALSDocument__Group__0) | ||
78 | { after(grammarAccess.getALSDocumentAccess().getGroup()); } | ||
79 | ) | ||
80 | |||
81 | ; | ||
82 | finally { | ||
83 | restoreStackSize(stackSize); | ||
84 | } | ||
85 | |||
86 | |||
87 | |||
88 | // Entry rule entryRuleALSID | ||
89 | entryRuleALSID | ||
90 | : | ||
91 | { before(grammarAccess.getALSIDRule()); } | ||
92 | ruleALSID | ||
93 | { after(grammarAccess.getALSIDRule()); } | ||
94 | EOF | ||
95 | ; | ||
96 | |||
97 | // Rule ALSID | ||
98 | ruleALSID | ||
99 | @init { | ||
100 | int stackSize = keepStackSize(); | ||
101 | } | ||
102 | : | ||
103 | ( | ||
104 | { before(grammarAccess.getALSIDAccess().getIDTerminalRuleCall()); } | ||
105 | RULE_ID | ||
106 | { after(grammarAccess.getALSIDAccess().getIDTerminalRuleCall()); } | ||
107 | ) | ||
108 | |||
109 | ; | ||
110 | finally { | ||
111 | restoreStackSize(stackSize); | ||
112 | } | ||
113 | |||
114 | |||
115 | |||
116 | |||
117 | |||
118 | // Entry rule entryRuleALSTypeDeclaration | ||
119 | entryRuleALSTypeDeclaration | ||
120 | : | ||
121 | { before(grammarAccess.getALSTypeDeclarationRule()); } | ||
122 | ruleALSTypeDeclaration | ||
123 | { after(grammarAccess.getALSTypeDeclarationRule()); } | ||
124 | EOF | ||
125 | ; | ||
126 | |||
127 | // Rule ALSTypeDeclaration | ||
128 | ruleALSTypeDeclaration | ||
129 | @init { | ||
130 | int stackSize = keepStackSize(); | ||
131 | } | ||
132 | : | ||
133 | ( | ||
134 | { before(grammarAccess.getALSTypeDeclarationAccess().getAlternatives()); } | ||
135 | (rule__ALSTypeDeclaration__Alternatives) | ||
136 | { after(grammarAccess.getALSTypeDeclarationAccess().getAlternatives()); } | ||
137 | ) | ||
138 | |||
139 | ; | ||
140 | finally { | ||
141 | restoreStackSize(stackSize); | ||
142 | } | ||
143 | |||
144 | |||
145 | |||
146 | // Entry rule entryRuleALSEnumDeclaration | ||
147 | entryRuleALSEnumDeclaration | ||
148 | : | ||
149 | { before(grammarAccess.getALSEnumDeclarationRule()); } | ||
150 | ruleALSEnumDeclaration | ||
151 | { after(grammarAccess.getALSEnumDeclarationRule()); } | ||
152 | EOF | ||
153 | ; | ||
154 | |||
155 | // Rule ALSEnumDeclaration | ||
156 | ruleALSEnumDeclaration | ||
157 | @init { | ||
158 | int stackSize = keepStackSize(); | ||
159 | } | ||
160 | : | ||
161 | ( | ||
162 | { before(grammarAccess.getALSEnumDeclarationAccess().getGroup()); } | ||
163 | (rule__ALSEnumDeclaration__Group__0) | ||
164 | { after(grammarAccess.getALSEnumDeclarationAccess().getGroup()); } | ||
165 | ) | ||
166 | |||
167 | ; | ||
168 | finally { | ||
169 | restoreStackSize(stackSize); | ||
170 | } | ||
171 | |||
172 | |||
173 | |||
174 | // Entry rule entryRuleALSEnumLiteral | ||
175 | entryRuleALSEnumLiteral | ||
176 | : | ||
177 | { before(grammarAccess.getALSEnumLiteralRule()); } | ||
178 | ruleALSEnumLiteral | ||
179 | { after(grammarAccess.getALSEnumLiteralRule()); } | ||
180 | EOF | ||
181 | ; | ||
182 | |||
183 | // Rule ALSEnumLiteral | ||
184 | ruleALSEnumLiteral | ||
185 | @init { | ||
186 | int stackSize = keepStackSize(); | ||
187 | } | ||
188 | : | ||
189 | ( | ||
190 | { before(grammarAccess.getALSEnumLiteralAccess().getNameAssignment()); } | ||
191 | (rule__ALSEnumLiteral__NameAssignment) | ||
192 | { after(grammarAccess.getALSEnumLiteralAccess().getNameAssignment()); } | ||
193 | ) | ||
194 | |||
195 | ; | ||
196 | finally { | ||
197 | restoreStackSize(stackSize); | ||
198 | } | ||
199 | |||
200 | |||
201 | |||
202 | // Entry rule entryRuleALSSignatureDeclaration | ||
203 | entryRuleALSSignatureDeclaration | ||
204 | : | ||
205 | { before(grammarAccess.getALSSignatureDeclarationRule()); } | ||
206 | ruleALSSignatureDeclaration | ||
207 | { after(grammarAccess.getALSSignatureDeclarationRule()); } | ||
208 | EOF | ||
209 | ; | ||
210 | |||
211 | // Rule ALSSignatureDeclaration | ||
212 | ruleALSSignatureDeclaration | ||
213 | @init { | ||
214 | int stackSize = keepStackSize(); | ||
215 | } | ||
216 | : | ||
217 | ( | ||
218 | { before(grammarAccess.getALSSignatureDeclarationAccess().getNameAssignment()); } | ||
219 | (rule__ALSSignatureDeclaration__NameAssignment) | ||
220 | { after(grammarAccess.getALSSignatureDeclarationAccess().getNameAssignment()); } | ||
221 | ) | ||
222 | |||
223 | ; | ||
224 | finally { | ||
225 | restoreStackSize(stackSize); | ||
226 | } | ||
227 | |||
228 | |||
229 | |||
230 | // Entry rule entryRuleALSSignatureBody | ||
231 | entryRuleALSSignatureBody | ||
232 | : | ||
233 | { before(grammarAccess.getALSSignatureBodyRule()); } | ||
234 | ruleALSSignatureBody | ||
235 | { after(grammarAccess.getALSSignatureBodyRule()); } | ||
236 | EOF | ||
237 | ; | ||
238 | |||
239 | // Rule ALSSignatureBody | ||
240 | ruleALSSignatureBody | ||
241 | @init { | ||
242 | int stackSize = keepStackSize(); | ||
243 | } | ||
244 | : | ||
245 | ( | ||
246 | { before(grammarAccess.getALSSignatureBodyAccess().getGroup()); } | ||
247 | (rule__ALSSignatureBody__Group__0) | ||
248 | { after(grammarAccess.getALSSignatureBodyAccess().getGroup()); } | ||
249 | ) | ||
250 | |||
251 | ; | ||
252 | finally { | ||
253 | restoreStackSize(stackSize); | ||
254 | } | ||
255 | |||
256 | |||
257 | |||
258 | // Entry rule entryRuleALSFieldDeclaration | ||
259 | entryRuleALSFieldDeclaration | ||
260 | : | ||
261 | { before(grammarAccess.getALSFieldDeclarationRule()); } | ||
262 | ruleALSFieldDeclaration | ||
263 | { after(grammarAccess.getALSFieldDeclarationRule()); } | ||
264 | EOF | ||
265 | ; | ||
266 | |||
267 | // Rule ALSFieldDeclaration | ||
268 | ruleALSFieldDeclaration | ||
269 | @init { | ||
270 | int stackSize = keepStackSize(); | ||
271 | } | ||
272 | : | ||
273 | ( | ||
274 | { before(grammarAccess.getALSFieldDeclarationAccess().getGroup()); } | ||
275 | (rule__ALSFieldDeclaration__Group__0) | ||
276 | { after(grammarAccess.getALSFieldDeclarationAccess().getGroup()); } | ||
277 | ) | ||
278 | |||
279 | ; | ||
280 | finally { | ||
281 | restoreStackSize(stackSize); | ||
282 | } | ||
283 | |||
284 | |||
285 | |||
286 | |||
287 | |||
288 | // Entry rule entryRuleALSFunctionDefinition | ||
289 | entryRuleALSFunctionDefinition | ||
290 | : | ||
291 | { before(grammarAccess.getALSFunctionDefinitionRule()); } | ||
292 | ruleALSFunctionDefinition | ||
293 | { after(grammarAccess.getALSFunctionDefinitionRule()); } | ||
294 | EOF | ||
295 | ; | ||
296 | |||
297 | // Rule ALSFunctionDefinition | ||
298 | ruleALSFunctionDefinition | ||
299 | @init { | ||
300 | int stackSize = keepStackSize(); | ||
301 | } | ||
302 | : | ||
303 | ( | ||
304 | { before(grammarAccess.getALSFunctionDefinitionAccess().getGroup()); } | ||
305 | (rule__ALSFunctionDefinition__Group__0) | ||
306 | { after(grammarAccess.getALSFunctionDefinitionAccess().getGroup()); } | ||
307 | ) | ||
308 | |||
309 | ; | ||
310 | finally { | ||
311 | restoreStackSize(stackSize); | ||
312 | } | ||
313 | |||
314 | |||
315 | |||
316 | // Entry rule entryRuleALSRelationDefinition | ||
317 | entryRuleALSRelationDefinition | ||
318 | : | ||
319 | { before(grammarAccess.getALSRelationDefinitionRule()); } | ||
320 | ruleALSRelationDefinition | ||
321 | { after(grammarAccess.getALSRelationDefinitionRule()); } | ||
322 | EOF | ||
323 | ; | ||
324 | |||
325 | // Rule ALSRelationDefinition | ||
326 | ruleALSRelationDefinition | ||
327 | @init { | ||
328 | int stackSize = keepStackSize(); | ||
329 | } | ||
330 | : | ||
331 | ( | ||
332 | { before(grammarAccess.getALSRelationDefinitionAccess().getGroup()); } | ||
333 | (rule__ALSRelationDefinition__Group__0) | ||
334 | { after(grammarAccess.getALSRelationDefinitionAccess().getGroup()); } | ||
335 | ) | ||
336 | |||
337 | ; | ||
338 | finally { | ||
339 | restoreStackSize(stackSize); | ||
340 | } | ||
341 | |||
342 | |||
343 | |||
344 | // Entry rule entryRuleALSFactDeclaration | ||
345 | entryRuleALSFactDeclaration | ||
346 | : | ||
347 | { before(grammarAccess.getALSFactDeclarationRule()); } | ||
348 | ruleALSFactDeclaration | ||
349 | { after(grammarAccess.getALSFactDeclarationRule()); } | ||
350 | EOF | ||
351 | ; | ||
352 | |||
353 | // Rule ALSFactDeclaration | ||
354 | ruleALSFactDeclaration | ||
355 | @init { | ||
356 | int stackSize = keepStackSize(); | ||
357 | } | ||
358 | : | ||
359 | ( | ||
360 | { before(grammarAccess.getALSFactDeclarationAccess().getGroup()); } | ||
361 | (rule__ALSFactDeclaration__Group__0) | ||
362 | { after(grammarAccess.getALSFactDeclarationAccess().getGroup()); } | ||
363 | ) | ||
364 | |||
365 | ; | ||
366 | finally { | ||
367 | restoreStackSize(stackSize); | ||
368 | } | ||
369 | |||
370 | |||
371 | |||
372 | // Entry rule entryRuleALSTerm | ||
373 | entryRuleALSTerm | ||
374 | : | ||
375 | { before(grammarAccess.getALSTermRule()); } | ||
376 | ruleALSTerm | ||
377 | { after(grammarAccess.getALSTermRule()); } | ||
378 | EOF | ||
379 | ; | ||
380 | |||
381 | // Rule ALSTerm | ||
382 | ruleALSTerm | ||
383 | @init { | ||
384 | int stackSize = keepStackSize(); | ||
385 | } | ||
386 | : | ||
387 | ( | ||
388 | { before(grammarAccess.getALSTermAccess().getALSQuantifiedParserRuleCall()); } | ||
389 | ruleALSQuantified | ||
390 | { after(grammarAccess.getALSTermAccess().getALSQuantifiedParserRuleCall()); } | ||
391 | ) | ||
392 | |||
393 | ; | ||
394 | finally { | ||
395 | restoreStackSize(stackSize); | ||
396 | } | ||
397 | |||
398 | |||
399 | |||
400 | // Entry rule entryRuleALSQuantified | ||
401 | entryRuleALSQuantified | ||
402 | : | ||
403 | { before(grammarAccess.getALSQuantifiedRule()); } | ||
404 | ruleALSQuantified | ||
405 | { after(grammarAccess.getALSQuantifiedRule()); } | ||
406 | EOF | ||
407 | ; | ||
408 | |||
409 | // Rule ALSQuantified | ||
410 | ruleALSQuantified | ||
411 | @init { | ||
412 | int stackSize = keepStackSize(); | ||
413 | } | ||
414 | : | ||
415 | ( | ||
416 | { before(grammarAccess.getALSQuantifiedAccess().getAlternatives()); } | ||
417 | (rule__ALSQuantified__Alternatives) | ||
418 | { after(grammarAccess.getALSQuantifiedAccess().getAlternatives()); } | ||
419 | ) | ||
420 | |||
421 | ; | ||
422 | finally { | ||
423 | restoreStackSize(stackSize); | ||
424 | } | ||
425 | |||
426 | |||
427 | |||
428 | // Entry rule entryRuleALSOr | ||
429 | entryRuleALSOr | ||
430 | : | ||
431 | { before(grammarAccess.getALSOrRule()); } | ||
432 | ruleALSOr | ||
433 | { after(grammarAccess.getALSOrRule()); } | ||
434 | EOF | ||
435 | ; | ||
436 | |||
437 | // Rule ALSOr | ||
438 | ruleALSOr | ||
439 | @init { | ||
440 | int stackSize = keepStackSize(); | ||
441 | } | ||
442 | : | ||
443 | ( | ||
444 | { before(grammarAccess.getALSOrAccess().getGroup()); } | ||
445 | (rule__ALSOr__Group__0) | ||
446 | { after(grammarAccess.getALSOrAccess().getGroup()); } | ||
447 | ) | ||
448 | |||
449 | ; | ||
450 | finally { | ||
451 | restoreStackSize(stackSize); | ||
452 | } | ||
453 | |||
454 | |||
455 | |||
456 | // Entry rule entryRuleALSIff | ||
457 | entryRuleALSIff | ||
458 | : | ||
459 | { before(grammarAccess.getALSIffRule()); } | ||
460 | ruleALSIff | ||
461 | { after(grammarAccess.getALSIffRule()); } | ||
462 | EOF | ||
463 | ; | ||
464 | |||
465 | // Rule ALSIff | ||
466 | ruleALSIff | ||
467 | @init { | ||
468 | int stackSize = keepStackSize(); | ||
469 | } | ||
470 | : | ||
471 | ( | ||
472 | { before(grammarAccess.getALSIffAccess().getGroup()); } | ||
473 | (rule__ALSIff__Group__0) | ||
474 | { after(grammarAccess.getALSIffAccess().getGroup()); } | ||
475 | ) | ||
476 | |||
477 | ; | ||
478 | finally { | ||
479 | restoreStackSize(stackSize); | ||
480 | } | ||
481 | |||
482 | |||
483 | |||
484 | // Entry rule entryRuleALSImpl | ||
485 | entryRuleALSImpl | ||
486 | : | ||
487 | { before(grammarAccess.getALSImplRule()); } | ||
488 | ruleALSImpl | ||
489 | { after(grammarAccess.getALSImplRule()); } | ||
490 | EOF | ||
491 | ; | ||
492 | |||
493 | // Rule ALSImpl | ||
494 | ruleALSImpl | ||
495 | @init { | ||
496 | int stackSize = keepStackSize(); | ||
497 | } | ||
498 | : | ||
499 | ( | ||
500 | { before(grammarAccess.getALSImplAccess().getGroup()); } | ||
501 | (rule__ALSImpl__Group__0) | ||
502 | { after(grammarAccess.getALSImplAccess().getGroup()); } | ||
503 | ) | ||
504 | |||
505 | ; | ||
506 | finally { | ||
507 | restoreStackSize(stackSize); | ||
508 | } | ||
509 | |||
510 | |||
511 | |||
512 | // Entry rule entryRuleALSAnd | ||
513 | entryRuleALSAnd | ||
514 | : | ||
515 | { before(grammarAccess.getALSAndRule()); } | ||
516 | ruleALSAnd | ||
517 | { after(grammarAccess.getALSAndRule()); } | ||
518 | EOF | ||
519 | ; | ||
520 | |||
521 | // Rule ALSAnd | ||
522 | ruleALSAnd | ||
523 | @init { | ||
524 | int stackSize = keepStackSize(); | ||
525 | } | ||
526 | : | ||
527 | ( | ||
528 | { before(grammarAccess.getALSAndAccess().getGroup()); } | ||
529 | (rule__ALSAnd__Group__0) | ||
530 | { after(grammarAccess.getALSAndAccess().getGroup()); } | ||
531 | ) | ||
532 | |||
533 | ; | ||
534 | finally { | ||
535 | restoreStackSize(stackSize); | ||
536 | } | ||
537 | |||
538 | |||
539 | |||
540 | // Entry rule entryRuleALSComparison | ||
541 | entryRuleALSComparison | ||
542 | : | ||
543 | { before(grammarAccess.getALSComparisonRule()); } | ||
544 | ruleALSComparison | ||
545 | { after(grammarAccess.getALSComparisonRule()); } | ||
546 | EOF | ||
547 | ; | ||
548 | |||
549 | // Rule ALSComparison | ||
550 | ruleALSComparison | ||
551 | @init { | ||
552 | int stackSize = keepStackSize(); | ||
553 | } | ||
554 | : | ||
555 | ( | ||
556 | { before(grammarAccess.getALSComparisonAccess().getGroup()); } | ||
557 | (rule__ALSComparison__Group__0) | ||
558 | { after(grammarAccess.getALSComparisonAccess().getGroup()); } | ||
559 | ) | ||
560 | |||
561 | ; | ||
562 | finally { | ||
563 | restoreStackSize(stackSize); | ||
564 | } | ||
565 | |||
566 | |||
567 | |||
568 | // Entry rule entryRuleALSOverride | ||
569 | entryRuleALSOverride | ||
570 | : | ||
571 | { before(grammarAccess.getALSOverrideRule()); } | ||
572 | ruleALSOverride | ||
573 | { after(grammarAccess.getALSOverrideRule()); } | ||
574 | EOF | ||
575 | ; | ||
576 | |||
577 | // Rule ALSOverride | ||
578 | ruleALSOverride | ||
579 | @init { | ||
580 | int stackSize = keepStackSize(); | ||
581 | } | ||
582 | : | ||
583 | ( | ||
584 | { before(grammarAccess.getALSOverrideAccess().getGroup()); } | ||
585 | (rule__ALSOverride__Group__0) | ||
586 | { after(grammarAccess.getALSOverrideAccess().getGroup()); } | ||
587 | ) | ||
588 | |||
589 | ; | ||
590 | finally { | ||
591 | restoreStackSize(stackSize); | ||
592 | } | ||
593 | |||
594 | |||
595 | |||
596 | // Entry rule entryRuleALSRangeRestrictionRight | ||
597 | entryRuleALSRangeRestrictionRight | ||
598 | : | ||
599 | { before(grammarAccess.getALSRangeRestrictionRightRule()); } | ||
600 | ruleALSRangeRestrictionRight | ||
601 | { after(grammarAccess.getALSRangeRestrictionRightRule()); } | ||
602 | EOF | ||
603 | ; | ||
604 | |||
605 | // Rule ALSRangeRestrictionRight | ||
606 | ruleALSRangeRestrictionRight | ||
607 | @init { | ||
608 | int stackSize = keepStackSize(); | ||
609 | } | ||
610 | : | ||
611 | ( | ||
612 | { before(grammarAccess.getALSRangeRestrictionRightAccess().getGroup()); } | ||
613 | (rule__ALSRangeRestrictionRight__Group__0) | ||
614 | { after(grammarAccess.getALSRangeRestrictionRightAccess().getGroup()); } | ||
615 | ) | ||
616 | |||
617 | ; | ||
618 | finally { | ||
619 | restoreStackSize(stackSize); | ||
620 | } | ||
621 | |||
622 | |||
623 | |||
624 | // Entry rule entryRuleALSRangeRestrictionLeft | ||
625 | entryRuleALSRangeRestrictionLeft | ||
626 | : | ||
627 | { before(grammarAccess.getALSRangeRestrictionLeftRule()); } | ||
628 | ruleALSRangeRestrictionLeft | ||
629 | { after(grammarAccess.getALSRangeRestrictionLeftRule()); } | ||
630 | EOF | ||
631 | ; | ||
632 | |||
633 | // Rule ALSRangeRestrictionLeft | ||
634 | ruleALSRangeRestrictionLeft | ||
635 | @init { | ||
636 | int stackSize = keepStackSize(); | ||
637 | } | ||
638 | : | ||
639 | ( | ||
640 | { before(grammarAccess.getALSRangeRestrictionLeftAccess().getGroup()); } | ||
641 | (rule__ALSRangeRestrictionLeft__Group__0) | ||
642 | { after(grammarAccess.getALSRangeRestrictionLeftAccess().getGroup()); } | ||
643 | ) | ||
644 | |||
645 | ; | ||
646 | finally { | ||
647 | restoreStackSize(stackSize); | ||
648 | } | ||
649 | |||
650 | |||
651 | |||
652 | // Entry rule entryRuleALSJoin | ||
653 | entryRuleALSJoin | ||
654 | : | ||
655 | { before(grammarAccess.getALSJoinRule()); } | ||
656 | ruleALSJoin | ||
657 | { after(grammarAccess.getALSJoinRule()); } | ||
658 | EOF | ||
659 | ; | ||
660 | |||
661 | // Rule ALSJoin | ||
662 | ruleALSJoin | ||
663 | @init { | ||
664 | int stackSize = keepStackSize(); | ||
665 | } | ||
666 | : | ||
667 | ( | ||
668 | { before(grammarAccess.getALSJoinAccess().getGroup()); } | ||
669 | (rule__ALSJoin__Group__0) | ||
670 | { after(grammarAccess.getALSJoinAccess().getGroup()); } | ||
671 | ) | ||
672 | |||
673 | ; | ||
674 | finally { | ||
675 | restoreStackSize(stackSize); | ||
676 | } | ||
677 | |||
678 | |||
679 | |||
680 | // Entry rule entryRuleALSMinus | ||
681 | entryRuleALSMinus | ||
682 | : | ||
683 | { before(grammarAccess.getALSMinusRule()); } | ||
684 | ruleALSMinus | ||
685 | { after(grammarAccess.getALSMinusRule()); } | ||
686 | EOF | ||
687 | ; | ||
688 | |||
689 | // Rule ALSMinus | ||
690 | ruleALSMinus | ||
691 | @init { | ||
692 | int stackSize = keepStackSize(); | ||
693 | } | ||
694 | : | ||
695 | ( | ||
696 | { before(grammarAccess.getALSMinusAccess().getGroup()); } | ||
697 | (rule__ALSMinus__Group__0) | ||
698 | { after(grammarAccess.getALSMinusAccess().getGroup()); } | ||
699 | ) | ||
700 | |||
701 | ; | ||
702 | finally { | ||
703 | restoreStackSize(stackSize); | ||
704 | } | ||
705 | |||
706 | |||
707 | |||
708 | // Entry rule entryRuleALSPlus | ||
709 | entryRuleALSPlus | ||
710 | : | ||
711 | { before(grammarAccess.getALSPlusRule()); } | ||
712 | ruleALSPlus | ||
713 | { after(grammarAccess.getALSPlusRule()); } | ||
714 | EOF | ||
715 | ; | ||
716 | |||
717 | // Rule ALSPlus | ||
718 | ruleALSPlus | ||
719 | @init { | ||
720 | int stackSize = keepStackSize(); | ||
721 | } | ||
722 | : | ||
723 | ( | ||
724 | { before(grammarAccess.getALSPlusAccess().getGroup()); } | ||
725 | (rule__ALSPlus__Group__0) | ||
726 | { after(grammarAccess.getALSPlusAccess().getGroup()); } | ||
727 | ) | ||
728 | |||
729 | ; | ||
730 | finally { | ||
731 | restoreStackSize(stackSize); | ||
732 | } | ||
733 | |||
734 | |||
735 | |||
736 | // Entry rule entryRuleALSIntersection | ||
737 | entryRuleALSIntersection | ||
738 | : | ||
739 | { before(grammarAccess.getALSIntersectionRule()); } | ||
740 | ruleALSIntersection | ||
741 | { after(grammarAccess.getALSIntersectionRule()); } | ||
742 | EOF | ||
743 | ; | ||
744 | |||
745 | // Rule ALSIntersection | ||
746 | ruleALSIntersection | ||
747 | @init { | ||
748 | int stackSize = keepStackSize(); | ||
749 | } | ||
750 | : | ||
751 | ( | ||
752 | { before(grammarAccess.getALSIntersectionAccess().getGroup()); } | ||
753 | (rule__ALSIntersection__Group__0) | ||
754 | { after(grammarAccess.getALSIntersectionAccess().getGroup()); } | ||
755 | ) | ||
756 | |||
757 | ; | ||
758 | finally { | ||
759 | restoreStackSize(stackSize); | ||
760 | } | ||
761 | |||
762 | |||
763 | |||
764 | // Entry rule entryRuleALSDirectProduct | ||
765 | entryRuleALSDirectProduct | ||
766 | : | ||
767 | { before(grammarAccess.getALSDirectProductRule()); } | ||
768 | ruleALSDirectProduct | ||
769 | { after(grammarAccess.getALSDirectProductRule()); } | ||
770 | EOF | ||
771 | ; | ||
772 | |||
773 | // Rule ALSDirectProduct | ||
774 | ruleALSDirectProduct | ||
775 | @init { | ||
776 | int stackSize = keepStackSize(); | ||
777 | } | ||
778 | : | ||
779 | ( | ||
780 | { before(grammarAccess.getALSDirectProductAccess().getGroup()); } | ||
781 | (rule__ALSDirectProduct__Group__0) | ||
782 | { after(grammarAccess.getALSDirectProductAccess().getGroup()); } | ||
783 | ) | ||
784 | |||
785 | ; | ||
786 | finally { | ||
787 | restoreStackSize(stackSize); | ||
788 | } | ||
789 | |||
790 | |||
791 | |||
792 | // Entry rule entryRuleALSPreficed | ||
793 | entryRuleALSPreficed | ||
794 | : | ||
795 | { before(grammarAccess.getALSPreficedRule()); } | ||
796 | ruleALSPreficed | ||
797 | { after(grammarAccess.getALSPreficedRule()); } | ||
798 | EOF | ||
799 | ; | ||
800 | |||
801 | // Rule ALSPreficed | ||
802 | ruleALSPreficed | ||
803 | @init { | ||
804 | int stackSize = keepStackSize(); | ||
805 | } | ||
806 | : | ||
807 | ( | ||
808 | { before(grammarAccess.getALSPreficedAccess().getAlternatives()); } | ||
809 | (rule__ALSPreficed__Alternatives) | ||
810 | { after(grammarAccess.getALSPreficedAccess().getAlternatives()); } | ||
811 | ) | ||
812 | |||
813 | ; | ||
814 | finally { | ||
815 | restoreStackSize(stackSize); | ||
816 | } | ||
817 | |||
818 | |||
819 | |||
820 | // Entry rule entryRuleALSVariableDeclaration | ||
821 | entryRuleALSVariableDeclaration | ||
822 | : | ||
823 | { before(grammarAccess.getALSVariableDeclarationRule()); } | ||
824 | ruleALSVariableDeclaration | ||
825 | { after(grammarAccess.getALSVariableDeclarationRule()); } | ||
826 | EOF | ||
827 | ; | ||
828 | |||
829 | // Rule ALSVariableDeclaration | ||
830 | ruleALSVariableDeclaration | ||
831 | @init { | ||
832 | int stackSize = keepStackSize(); | ||
833 | } | ||
834 | : | ||
835 | ( | ||
836 | { before(grammarAccess.getALSVariableDeclarationAccess().getGroup()); } | ||
837 | (rule__ALSVariableDeclaration__Group__0) | ||
838 | { after(grammarAccess.getALSVariableDeclarationAccess().getGroup()); } | ||
839 | ) | ||
840 | |||
841 | ; | ||
842 | finally { | ||
843 | restoreStackSize(stackSize); | ||
844 | } | ||
845 | |||
846 | |||
847 | |||
848 | // Entry rule entryRuleALSBasicRelationTerm | ||
849 | entryRuleALSBasicRelationTerm | ||
850 | : | ||
851 | { before(grammarAccess.getALSBasicRelationTermRule()); } | ||
852 | ruleALSBasicRelationTerm | ||
853 | { after(grammarAccess.getALSBasicRelationTermRule()); } | ||
854 | EOF | ||
855 | ; | ||
856 | |||
857 | // Rule ALSBasicRelationTerm | ||
858 | ruleALSBasicRelationTerm | ||
859 | @init { | ||
860 | int stackSize = keepStackSize(); | ||
861 | } | ||
862 | : | ||
863 | ( | ||
864 | { before(grammarAccess.getALSBasicRelationTermAccess().getAlternatives()); } | ||
865 | (rule__ALSBasicRelationTerm__Alternatives) | ||
866 | { after(grammarAccess.getALSBasicRelationTermAccess().getAlternatives()); } | ||
867 | ) | ||
868 | |||
869 | ; | ||
870 | finally { | ||
871 | restoreStackSize(stackSize); | ||
872 | } | ||
873 | |||
874 | |||
875 | |||
876 | // Entry rule entryRuleALSRunCommand | ||
877 | entryRuleALSRunCommand | ||
878 | : | ||
879 | { before(grammarAccess.getALSRunCommandRule()); } | ||
880 | ruleALSRunCommand | ||
881 | { after(grammarAccess.getALSRunCommandRule()); } | ||
882 | EOF | ||
883 | ; | ||
884 | |||
885 | // Rule ALSRunCommand | ||
886 | ruleALSRunCommand | ||
887 | @init { | ||
888 | int stackSize = keepStackSize(); | ||
889 | } | ||
890 | : | ||
891 | ( | ||
892 | { before(grammarAccess.getALSRunCommandAccess().getGroup()); } | ||
893 | (rule__ALSRunCommand__Group__0) | ||
894 | { after(grammarAccess.getALSRunCommandAccess().getGroup()); } | ||
895 | ) | ||
896 | |||
897 | ; | ||
898 | finally { | ||
899 | restoreStackSize(stackSize); | ||
900 | } | ||
901 | |||
902 | |||
903 | |||
904 | // Entry rule entryRuleALSTypeScope | ||
905 | entryRuleALSTypeScope | ||
906 | : | ||
907 | { before(grammarAccess.getALSTypeScopeRule()); } | ||
908 | ruleALSTypeScope | ||
909 | { after(grammarAccess.getALSTypeScopeRule()); } | ||
910 | EOF | ||
911 | ; | ||
912 | |||
913 | // Rule ALSTypeScope | ||
914 | ruleALSTypeScope | ||
915 | @init { | ||
916 | int stackSize = keepStackSize(); | ||
917 | } | ||
918 | : | ||
919 | ( | ||
920 | { before(grammarAccess.getALSTypeScopeAccess().getAlternatives()); } | ||
921 | (rule__ALSTypeScope__Alternatives) | ||
922 | { after(grammarAccess.getALSTypeScopeAccess().getAlternatives()); } | ||
923 | ) | ||
924 | |||
925 | ; | ||
926 | finally { | ||
927 | restoreStackSize(stackSize); | ||
928 | } | ||
929 | |||
930 | |||
931 | |||
932 | // Entry rule entryRuleALSSigScope | ||
933 | entryRuleALSSigScope | ||
934 | : | ||
935 | { before(grammarAccess.getALSSigScopeRule()); } | ||
936 | ruleALSSigScope | ||
937 | { after(grammarAccess.getALSSigScopeRule()); } | ||
938 | EOF | ||
939 | ; | ||
940 | |||
941 | // Rule ALSSigScope | ||
942 | ruleALSSigScope | ||
943 | @init { | ||
944 | int stackSize = keepStackSize(); | ||
945 | } | ||
946 | : | ||
947 | ( | ||
948 | { before(grammarAccess.getALSSigScopeAccess().getGroup()); } | ||
949 | (rule__ALSSigScope__Group__0) | ||
950 | { after(grammarAccess.getALSSigScopeAccess().getGroup()); } | ||
951 | ) | ||
952 | |||
953 | ; | ||
954 | finally { | ||
955 | restoreStackSize(stackSize); | ||
956 | } | ||
957 | |||
958 | |||
959 | |||
960 | // Entry rule entryRuleALSIntScope | ||
961 | entryRuleALSIntScope | ||
962 | : | ||
963 | { before(grammarAccess.getALSIntScopeRule()); } | ||
964 | ruleALSIntScope | ||
965 | { after(grammarAccess.getALSIntScopeRule()); } | ||
966 | EOF | ||
967 | ; | ||
968 | |||
969 | // Rule ALSIntScope | ||
970 | ruleALSIntScope | ||
971 | @init { | ||
972 | int stackSize = keepStackSize(); | ||
973 | } | ||
974 | : | ||
975 | ( | ||
976 | { before(grammarAccess.getALSIntScopeAccess().getGroup()); } | ||
977 | (rule__ALSIntScope__Group__0) | ||
978 | { after(grammarAccess.getALSIntScopeAccess().getGroup()); } | ||
979 | ) | ||
980 | |||
981 | ; | ||
982 | finally { | ||
983 | restoreStackSize(stackSize); | ||
984 | } | ||
985 | |||
986 | |||
987 | |||
988 | // Entry rule entryRuleALSStringScope | ||
989 | entryRuleALSStringScope | ||
990 | : | ||
991 | { before(grammarAccess.getALSStringScopeRule()); } | ||
992 | ruleALSStringScope | ||
993 | { after(grammarAccess.getALSStringScopeRule()); } | ||
994 | EOF | ||
995 | ; | ||
996 | |||
997 | // Rule ALSStringScope | ||
998 | ruleALSStringScope | ||
999 | @init { | ||
1000 | int stackSize = keepStackSize(); | ||
1001 | } | ||
1002 | : | ||
1003 | ( | ||
1004 | { before(grammarAccess.getALSStringScopeAccess().getGroup()); } | ||
1005 | (rule__ALSStringScope__Group__0) | ||
1006 | { after(grammarAccess.getALSStringScopeAccess().getGroup()); } | ||
1007 | ) | ||
1008 | |||
1009 | ; | ||
1010 | finally { | ||
1011 | restoreStackSize(stackSize); | ||
1012 | } | ||
1013 | |||
1014 | |||
1015 | |||
1016 | |||
1017 | // Rule ALSMultiplicity | ||
1018 | ruleALSMultiplicity | ||
1019 | @init { | ||
1020 | int stackSize = keepStackSize(); | ||
1021 | } | ||
1022 | : | ||
1023 | ( | ||
1024 | { before(grammarAccess.getALSMultiplicityAccess().getAlternatives()); } | ||
1025 | (rule__ALSMultiplicity__Alternatives) | ||
1026 | { after(grammarAccess.getALSMultiplicityAccess().getAlternatives()); } | ||
1027 | ) | ||
1028 | |||
1029 | ; | ||
1030 | finally { | ||
1031 | restoreStackSize(stackSize); | ||
1032 | } | ||
1033 | |||
1034 | |||
1035 | |||
1036 | // Rule ALSNumericOperator | ||
1037 | ruleALSNumericOperator | ||
1038 | @init { | ||
1039 | int stackSize = keepStackSize(); | ||
1040 | } | ||
1041 | : | ||
1042 | ( | ||
1043 | { before(grammarAccess.getALSNumericOperatorAccess().getAlternatives()); } | ||
1044 | (rule__ALSNumericOperator__Alternatives) | ||
1045 | { after(grammarAccess.getALSNumericOperatorAccess().getAlternatives()); } | ||
1046 | ) | ||
1047 | |||
1048 | ; | ||
1049 | finally { | ||
1050 | restoreStackSize(stackSize); | ||
1051 | } | ||
1052 | |||
1053 | |||
1054 | |||
1055 | rule__ALSDocument__Alternatives_0 | ||
1056 | @init { | ||
1057 | int stackSize = keepStackSize(); | ||
1058 | } | ||
1059 | : | ||
1060 | ( | ||
1061 | { before(grammarAccess.getALSDocumentAccess().getEnumDeclarationsAssignment_0_0()); } | ||
1062 | (rule__ALSDocument__EnumDeclarationsAssignment_0_0) | ||
1063 | { after(grammarAccess.getALSDocumentAccess().getEnumDeclarationsAssignment_0_0()); } | ||
1064 | ) | ||
1065 | |||
1066 | |( | ||
1067 | { before(grammarAccess.getALSDocumentAccess().getSignatureBodiesAssignment_0_1()); } | ||
1068 | (rule__ALSDocument__SignatureBodiesAssignment_0_1) | ||
1069 | { after(grammarAccess.getALSDocumentAccess().getSignatureBodiesAssignment_0_1()); } | ||
1070 | ) | ||
1071 | |||
1072 | |( | ||
1073 | { before(grammarAccess.getALSDocumentAccess().getFunctionDefinitionsAssignment_0_2()); } | ||
1074 | (rule__ALSDocument__FunctionDefinitionsAssignment_0_2) | ||
1075 | { after(grammarAccess.getALSDocumentAccess().getFunctionDefinitionsAssignment_0_2()); } | ||
1076 | ) | ||
1077 | |||
1078 | |( | ||
1079 | { before(grammarAccess.getALSDocumentAccess().getRelationDefinitionsAssignment_0_3()); } | ||
1080 | (rule__ALSDocument__RelationDefinitionsAssignment_0_3) | ||
1081 | { after(grammarAccess.getALSDocumentAccess().getRelationDefinitionsAssignment_0_3()); } | ||
1082 | ) | ||
1083 | |||
1084 | |( | ||
1085 | { before(grammarAccess.getALSDocumentAccess().getFactDeclarationsAssignment_0_4()); } | ||
1086 | (rule__ALSDocument__FactDeclarationsAssignment_0_4) | ||
1087 | { after(grammarAccess.getALSDocumentAccess().getFactDeclarationsAssignment_0_4()); } | ||
1088 | ) | ||
1089 | |||
1090 | ; | ||
1091 | finally { | ||
1092 | restoreStackSize(stackSize); | ||
1093 | } | ||
1094 | |||
1095 | |||
1096 | rule__ALSTypeDeclaration__Alternatives | ||
1097 | @init { | ||
1098 | int stackSize = keepStackSize(); | ||
1099 | } | ||
1100 | : | ||
1101 | ( | ||
1102 | { before(grammarAccess.getALSTypeDeclarationAccess().getALSEnumDeclarationParserRuleCall_0()); } | ||
1103 | ruleALSEnumDeclaration | ||
1104 | { after(grammarAccess.getALSTypeDeclarationAccess().getALSEnumDeclarationParserRuleCall_0()); } | ||
1105 | ) | ||
1106 | |||
1107 | |( | ||
1108 | { before(grammarAccess.getALSTypeDeclarationAccess().getALSSignatureDeclarationParserRuleCall_1()); } | ||
1109 | ruleALSSignatureDeclaration | ||
1110 | { after(grammarAccess.getALSTypeDeclarationAccess().getALSSignatureDeclarationParserRuleCall_1()); } | ||
1111 | ) | ||
1112 | |||
1113 | ; | ||
1114 | finally { | ||
1115 | restoreStackSize(stackSize); | ||
1116 | } | ||
1117 | |||
1118 | rule__ALSSignatureBody__Alternatives_4 | ||
1119 | @init { | ||
1120 | int stackSize = keepStackSize(); | ||
1121 | } | ||
1122 | : | ||
1123 | ( | ||
1124 | { before(grammarAccess.getALSSignatureBodyAccess().getGroup_4_0()); } | ||
1125 | (rule__ALSSignatureBody__Group_4_0__0) | ||
1126 | { after(grammarAccess.getALSSignatureBodyAccess().getGroup_4_0()); } | ||
1127 | ) | ||
1128 | |||
1129 | |( | ||
1130 | { before(grammarAccess.getALSSignatureBodyAccess().getGroup_4_1()); } | ||
1131 | (rule__ALSSignatureBody__Group_4_1__0) | ||
1132 | { after(grammarAccess.getALSSignatureBodyAccess().getGroup_4_1()); } | ||
1133 | ) | ||
1134 | |||
1135 | ; | ||
1136 | finally { | ||
1137 | restoreStackSize(stackSize); | ||
1138 | } | ||
1139 | |||
1140 | |||
1141 | rule__ALSQuantified__Alternatives | ||
1142 | @init { | ||
1143 | int stackSize = keepStackSize(); | ||
1144 | } | ||
1145 | : | ||
1146 | ( | ||
1147 | { before(grammarAccess.getALSQuantifiedAccess().getGroup_0()); } | ||
1148 | (rule__ALSQuantified__Group_0__0) | ||
1149 | { after(grammarAccess.getALSQuantifiedAccess().getGroup_0()); } | ||
1150 | ) | ||
1151 | |||
1152 | |( | ||
1153 | { before(grammarAccess.getALSQuantifiedAccess().getALSOrParserRuleCall_1()); } | ||
1154 | ruleALSOr | ||
1155 | { after(grammarAccess.getALSQuantifiedAccess().getALSOrParserRuleCall_1()); } | ||
1156 | ) | ||
1157 | |||
1158 | ; | ||
1159 | finally { | ||
1160 | restoreStackSize(stackSize); | ||
1161 | } | ||
1162 | |||
1163 | rule__ALSOr__Alternatives_1_1 | ||
1164 | @init { | ||
1165 | int stackSize = keepStackSize(); | ||
1166 | } | ||
1167 | : | ||
1168 | ( | ||
1169 | { before(grammarAccess.getALSOrAccess().getVerticalLineVerticalLineKeyword_1_1_0()); } | ||
1170 | |||
1171 | '||' | ||
1172 | |||
1173 | { after(grammarAccess.getALSOrAccess().getVerticalLineVerticalLineKeyword_1_1_0()); } | ||
1174 | ) | ||
1175 | |||
1176 | |( | ||
1177 | { before(grammarAccess.getALSOrAccess().getOrKeyword_1_1_1()); } | ||
1178 | |||
1179 | 'or' | ||
1180 | |||
1181 | { after(grammarAccess.getALSOrAccess().getOrKeyword_1_1_1()); } | ||
1182 | ) | ||
1183 | |||
1184 | ; | ||
1185 | finally { | ||
1186 | restoreStackSize(stackSize); | ||
1187 | } | ||
1188 | |||
1189 | rule__ALSIff__Alternatives_1_1 | ||
1190 | @init { | ||
1191 | int stackSize = keepStackSize(); | ||
1192 | } | ||
1193 | : | ||
1194 | ( | ||
1195 | { before(grammarAccess.getALSIffAccess().getLessThanSignEqualsSignGreaterThanSignKeyword_1_1_0()); } | ||
1196 | |||
1197 | '<=>' | ||
1198 | |||
1199 | { after(grammarAccess.getALSIffAccess().getLessThanSignEqualsSignGreaterThanSignKeyword_1_1_0()); } | ||
1200 | ) | ||
1201 | |||
1202 | |( | ||
1203 | { before(grammarAccess.getALSIffAccess().getIffKeyword_1_1_1()); } | ||
1204 | |||
1205 | 'iff' | ||
1206 | |||
1207 | { after(grammarAccess.getALSIffAccess().getIffKeyword_1_1_1()); } | ||
1208 | ) | ||
1209 | |||
1210 | ; | ||
1211 | finally { | ||
1212 | restoreStackSize(stackSize); | ||
1213 | } | ||
1214 | |||
1215 | rule__ALSImpl__Alternatives_1_1 | ||
1216 | @init { | ||
1217 | int stackSize = keepStackSize(); | ||
1218 | } | ||
1219 | : | ||
1220 | ( | ||
1221 | { before(grammarAccess.getALSImplAccess().getEqualsSignGreaterThanSignKeyword_1_1_0()); } | ||
1222 | |||
1223 | '=>' | ||
1224 | |||
1225 | { after(grammarAccess.getALSImplAccess().getEqualsSignGreaterThanSignKeyword_1_1_0()); } | ||
1226 | ) | ||
1227 | |||
1228 | |( | ||
1229 | { before(grammarAccess.getALSImplAccess().getImpliesKeyword_1_1_1()); } | ||
1230 | |||
1231 | 'implies' | ||
1232 | |||
1233 | { after(grammarAccess.getALSImplAccess().getImpliesKeyword_1_1_1()); } | ||
1234 | ) | ||
1235 | |||
1236 | ; | ||
1237 | finally { | ||
1238 | restoreStackSize(stackSize); | ||
1239 | } | ||
1240 | |||
1241 | rule__ALSAnd__Alternatives_1_1 | ||
1242 | @init { | ||
1243 | int stackSize = keepStackSize(); | ||
1244 | } | ||
1245 | : | ||
1246 | ( | ||
1247 | { before(grammarAccess.getALSAndAccess().getAmpersandAmpersandKeyword_1_1_0()); } | ||
1248 | |||
1249 | '&&' | ||
1250 | |||
1251 | { after(grammarAccess.getALSAndAccess().getAmpersandAmpersandKeyword_1_1_0()); } | ||
1252 | ) | ||
1253 | |||
1254 | |( | ||
1255 | { before(grammarAccess.getALSAndAccess().getAndKeyword_1_1_1()); } | ||
1256 | |||
1257 | 'and' | ||
1258 | |||
1259 | { after(grammarAccess.getALSAndAccess().getAndKeyword_1_1_1()); } | ||
1260 | ) | ||
1261 | |||
1262 | ; | ||
1263 | finally { | ||
1264 | restoreStackSize(stackSize); | ||
1265 | } | ||
1266 | |||
1267 | rule__ALSComparison__Alternatives_1_0 | ||
1268 | @init { | ||
1269 | int stackSize = keepStackSize(); | ||
1270 | } | ||
1271 | : | ||
1272 | ( | ||
1273 | { before(grammarAccess.getALSComparisonAccess().getGroup_1_0_0()); } | ||
1274 | (rule__ALSComparison__Group_1_0_0__0) | ||
1275 | { after(grammarAccess.getALSComparisonAccess().getGroup_1_0_0()); } | ||
1276 | ) | ||
1277 | |||
1278 | |( | ||
1279 | { before(grammarAccess.getALSComparisonAccess().getGroup_1_0_1()); } | ||
1280 | (rule__ALSComparison__Group_1_0_1__0) | ||
1281 | { after(grammarAccess.getALSComparisonAccess().getGroup_1_0_1()); } | ||
1282 | ) | ||
1283 | |||
1284 | |( | ||
1285 | { before(grammarAccess.getALSComparisonAccess().getGroup_1_0_2()); } | ||
1286 | (rule__ALSComparison__Group_1_0_2__0) | ||
1287 | { after(grammarAccess.getALSComparisonAccess().getGroup_1_0_2()); } | ||
1288 | ) | ||
1289 | |||
1290 | |( | ||
1291 | { before(grammarAccess.getALSComparisonAccess().getGroup_1_0_3()); } | ||
1292 | (rule__ALSComparison__Group_1_0_3__0) | ||
1293 | { after(grammarAccess.getALSComparisonAccess().getGroup_1_0_3()); } | ||
1294 | ) | ||
1295 | |||
1296 | |( | ||
1297 | { before(grammarAccess.getALSComparisonAccess().getGroup_1_0_4()); } | ||
1298 | (rule__ALSComparison__Group_1_0_4__0) | ||
1299 | { after(grammarAccess.getALSComparisonAccess().getGroup_1_0_4()); } | ||
1300 | ) | ||
1301 | |||
1302 | |( | ||
1303 | { before(grammarAccess.getALSComparisonAccess().getGroup_1_0_5()); } | ||
1304 | (rule__ALSComparison__Group_1_0_5__0) | ||
1305 | { after(grammarAccess.getALSComparisonAccess().getGroup_1_0_5()); } | ||
1306 | ) | ||
1307 | |||
1308 | |( | ||
1309 | { before(grammarAccess.getALSComparisonAccess().getGroup_1_0_6()); } | ||
1310 | (rule__ALSComparison__Group_1_0_6__0) | ||
1311 | { after(grammarAccess.getALSComparisonAccess().getGroup_1_0_6()); } | ||
1312 | ) | ||
1313 | |||
1314 | ; | ||
1315 | finally { | ||
1316 | restoreStackSize(stackSize); | ||
1317 | } | ||
1318 | |||
1319 | rule__ALSPreficed__Alternatives | ||
1320 | @init { | ||
1321 | int stackSize = keepStackSize(); | ||
1322 | } | ||
1323 | : | ||
1324 | ( | ||
1325 | { before(grammarAccess.getALSPreficedAccess().getGroup_0()); } | ||
1326 | (rule__ALSPreficed__Group_0__0) | ||
1327 | { after(grammarAccess.getALSPreficedAccess().getGroup_0()); } | ||
1328 | ) | ||
1329 | |||
1330 | |( | ||
1331 | { before(grammarAccess.getALSPreficedAccess().getGroup_1()); } | ||
1332 | (rule__ALSPreficed__Group_1__0) | ||
1333 | { after(grammarAccess.getALSPreficedAccess().getGroup_1()); } | ||
1334 | ) | ||
1335 | |||
1336 | |( | ||
1337 | { before(grammarAccess.getALSPreficedAccess().getGroup_2()); } | ||
1338 | (rule__ALSPreficed__Group_2__0) | ||
1339 | { after(grammarAccess.getALSPreficedAccess().getGroup_2()); } | ||
1340 | ) | ||
1341 | |||
1342 | |( | ||
1343 | { before(grammarAccess.getALSPreficedAccess().getGroup_3()); } | ||
1344 | (rule__ALSPreficed__Group_3__0) | ||
1345 | { after(grammarAccess.getALSPreficedAccess().getGroup_3()); } | ||
1346 | ) | ||
1347 | |||
1348 | |( | ||
1349 | { before(grammarAccess.getALSPreficedAccess().getGroup_4()); } | ||
1350 | (rule__ALSPreficed__Group_4__0) | ||
1351 | { after(grammarAccess.getALSPreficedAccess().getGroup_4()); } | ||
1352 | ) | ||
1353 | |||
1354 | |( | ||
1355 | { before(grammarAccess.getALSPreficedAccess().getGroup_5()); } | ||
1356 | (rule__ALSPreficed__Group_5__0) | ||
1357 | { after(grammarAccess.getALSPreficedAccess().getGroup_5()); } | ||
1358 | ) | ||
1359 | |||
1360 | |( | ||
1361 | { before(grammarAccess.getALSPreficedAccess().getGroup_6()); } | ||
1362 | (rule__ALSPreficed__Group_6__0) | ||
1363 | { after(grammarAccess.getALSPreficedAccess().getGroup_6()); } | ||
1364 | ) | ||
1365 | |||
1366 | |( | ||
1367 | { before(grammarAccess.getALSPreficedAccess().getGroup_7()); } | ||
1368 | (rule__ALSPreficed__Group_7__0) | ||
1369 | { after(grammarAccess.getALSPreficedAccess().getGroup_7()); } | ||
1370 | ) | ||
1371 | |||
1372 | |( | ||
1373 | { before(grammarAccess.getALSPreficedAccess().getALSBasicRelationTermParserRuleCall_8()); } | ||
1374 | ruleALSBasicRelationTerm | ||
1375 | { after(grammarAccess.getALSPreficedAccess().getALSBasicRelationTermParserRuleCall_8()); } | ||
1376 | ) | ||
1377 | |||
1378 | ; | ||
1379 | finally { | ||
1380 | restoreStackSize(stackSize); | ||
1381 | } | ||
1382 | |||
1383 | rule__ALSPreficed__Alternatives_0_1_0 | ||
1384 | @init { | ||
1385 | int stackSize = keepStackSize(); | ||
1386 | } | ||
1387 | : | ||
1388 | ( | ||
1389 | { before(grammarAccess.getALSPreficedAccess().getExclamationMarkKeyword_0_1_0_0()); } | ||
1390 | |||
1391 | '!' | ||
1392 | |||
1393 | { after(grammarAccess.getALSPreficedAccess().getExclamationMarkKeyword_0_1_0_0()); } | ||
1394 | ) | ||
1395 | |||
1396 | |( | ||
1397 | { before(grammarAccess.getALSPreficedAccess().getNotKeyword_0_1_0_1()); } | ||
1398 | |||
1399 | 'not' | ||
1400 | |||
1401 | { after(grammarAccess.getALSPreficedAccess().getNotKeyword_0_1_0_1()); } | ||
1402 | ) | ||
1403 | |||
1404 | ; | ||
1405 | finally { | ||
1406 | restoreStackSize(stackSize); | ||
1407 | } | ||
1408 | |||
1409 | rule__ALSPreficed__Alternatives_7_1 | ||
1410 | @init { | ||
1411 | int stackSize = keepStackSize(); | ||
1412 | } | ||
1413 | : | ||
1414 | ( | ||
1415 | { before(grammarAccess.getALSPreficedAccess().getReferredDefinitionAssignment_7_1_0()); } | ||
1416 | (rule__ALSPreficed__ReferredDefinitionAssignment_7_1_0) | ||
1417 | { after(grammarAccess.getALSPreficedAccess().getReferredDefinitionAssignment_7_1_0()); } | ||
1418 | ) | ||
1419 | |||
1420 | |( | ||
1421 | { before(grammarAccess.getALSPreficedAccess().getReferredNumericOperatorAssignment_7_1_1()); } | ||
1422 | (rule__ALSPreficed__ReferredNumericOperatorAssignment_7_1_1) | ||
1423 | { after(grammarAccess.getALSPreficedAccess().getReferredNumericOperatorAssignment_7_1_1()); } | ||
1424 | ) | ||
1425 | |||
1426 | ; | ||
1427 | finally { | ||
1428 | restoreStackSize(stackSize); | ||
1429 | } | ||
1430 | |||
1431 | rule__ALSBasicRelationTerm__Alternatives | ||
1432 | @init { | ||
1433 | int stackSize = keepStackSize(); | ||
1434 | } | ||
1435 | : | ||
1436 | ( | ||
1437 | { before(grammarAccess.getALSBasicRelationTermAccess().getGroup_0()); } | ||
1438 | (rule__ALSBasicRelationTerm__Group_0__0) | ||
1439 | { after(grammarAccess.getALSBasicRelationTermAccess().getGroup_0()); } | ||
1440 | ) | ||
1441 | |||
1442 | |( | ||
1443 | { before(grammarAccess.getALSBasicRelationTermAccess().getGroup_1()); } | ||
1444 | (rule__ALSBasicRelationTerm__Group_1__0) | ||
1445 | { after(grammarAccess.getALSBasicRelationTermAccess().getGroup_1()); } | ||
1446 | ) | ||
1447 | |||
1448 | |( | ||
1449 | { before(grammarAccess.getALSBasicRelationTermAccess().getGroup_2()); } | ||
1450 | (rule__ALSBasicRelationTerm__Group_2__0) | ||
1451 | { after(grammarAccess.getALSBasicRelationTermAccess().getGroup_2()); } | ||
1452 | ) | ||
1453 | |||
1454 | |( | ||
1455 | { before(grammarAccess.getALSBasicRelationTermAccess().getGroup_3()); } | ||
1456 | (rule__ALSBasicRelationTerm__Group_3__0) | ||
1457 | { after(grammarAccess.getALSBasicRelationTermAccess().getGroup_3()); } | ||
1458 | ) | ||
1459 | |||
1460 | |( | ||
1461 | { before(grammarAccess.getALSBasicRelationTermAccess().getGroup_4()); } | ||
1462 | (rule__ALSBasicRelationTerm__Group_4__0) | ||
1463 | { after(grammarAccess.getALSBasicRelationTermAccess().getGroup_4()); } | ||
1464 | ) | ||
1465 | |||
1466 | |( | ||
1467 | { before(grammarAccess.getALSBasicRelationTermAccess().getGroup_5()); } | ||
1468 | (rule__ALSBasicRelationTerm__Group_5__0) | ||
1469 | { after(grammarAccess.getALSBasicRelationTermAccess().getGroup_5()); } | ||
1470 | ) | ||
1471 | |||
1472 | |( | ||
1473 | { before(grammarAccess.getALSBasicRelationTermAccess().getGroup_6()); } | ||
1474 | (rule__ALSBasicRelationTerm__Group_6__0) | ||
1475 | { after(grammarAccess.getALSBasicRelationTermAccess().getGroup_6()); } | ||
1476 | ) | ||
1477 | |||
1478 | |( | ||
1479 | { before(grammarAccess.getALSBasicRelationTermAccess().getGroup_7()); } | ||
1480 | (rule__ALSBasicRelationTerm__Group_7__0) | ||
1481 | { after(grammarAccess.getALSBasicRelationTermAccess().getGroup_7()); } | ||
1482 | ) | ||
1483 | |||
1484 | |( | ||
1485 | { before(grammarAccess.getALSBasicRelationTermAccess().getGroup_8()); } | ||
1486 | (rule__ALSBasicRelationTerm__Group_8__0) | ||
1487 | { after(grammarAccess.getALSBasicRelationTermAccess().getGroup_8()); } | ||
1488 | ) | ||
1489 | |||
1490 | ; | ||
1491 | finally { | ||
1492 | restoreStackSize(stackSize); | ||
1493 | } | ||
1494 | |||
1495 | rule__ALSTypeScope__Alternatives | ||
1496 | @init { | ||
1497 | int stackSize = keepStackSize(); | ||
1498 | } | ||
1499 | : | ||
1500 | ( | ||
1501 | { before(grammarAccess.getALSTypeScopeAccess().getALSSigScopeParserRuleCall_0()); } | ||
1502 | ruleALSSigScope | ||
1503 | { after(grammarAccess.getALSTypeScopeAccess().getALSSigScopeParserRuleCall_0()); } | ||
1504 | ) | ||
1505 | |||
1506 | |( | ||
1507 | { before(grammarAccess.getALSTypeScopeAccess().getALSIntScopeParserRuleCall_1()); } | ||
1508 | ruleALSIntScope | ||
1509 | { after(grammarAccess.getALSTypeScopeAccess().getALSIntScopeParserRuleCall_1()); } | ||
1510 | ) | ||
1511 | |||
1512 | |( | ||
1513 | { before(grammarAccess.getALSTypeScopeAccess().getALSStringScopeParserRuleCall_2()); } | ||
1514 | ruleALSStringScope | ||
1515 | { after(grammarAccess.getALSTypeScopeAccess().getALSStringScopeParserRuleCall_2()); } | ||
1516 | ) | ||
1517 | |||
1518 | ; | ||
1519 | finally { | ||
1520 | restoreStackSize(stackSize); | ||
1521 | } | ||
1522 | |||
1523 | rule__ALSMultiplicity__Alternatives | ||
1524 | @init { | ||
1525 | int stackSize = keepStackSize(); | ||
1526 | } | ||
1527 | : | ||
1528 | ( | ||
1529 | { before(grammarAccess.getALSMultiplicityAccess().getAllEnumLiteralDeclaration_0()); } | ||
1530 | ( 'all' | ||
1531 | ) | ||
1532 | { after(grammarAccess.getALSMultiplicityAccess().getAllEnumLiteralDeclaration_0()); } | ||
1533 | ) | ||
1534 | |||
1535 | |( | ||
1536 | { before(grammarAccess.getALSMultiplicityAccess().getNoEnumLiteralDeclaration_1()); } | ||
1537 | ( 'no' | ||
1538 | ) | ||
1539 | { after(grammarAccess.getALSMultiplicityAccess().getNoEnumLiteralDeclaration_1()); } | ||
1540 | ) | ||
1541 | |||
1542 | |( | ||
1543 | { before(grammarAccess.getALSMultiplicityAccess().getSomeEnumLiteralDeclaration_2()); } | ||
1544 | ( 'some' | ||
1545 | ) | ||
1546 | { after(grammarAccess.getALSMultiplicityAccess().getSomeEnumLiteralDeclaration_2()); } | ||
1547 | ) | ||
1548 | |||
1549 | |( | ||
1550 | { before(grammarAccess.getALSMultiplicityAccess().getLoneEnumLiteralDeclaration_3()); } | ||
1551 | ( 'lone' | ||
1552 | ) | ||
1553 | { after(grammarAccess.getALSMultiplicityAccess().getLoneEnumLiteralDeclaration_3()); } | ||
1554 | ) | ||
1555 | |||
1556 | |( | ||
1557 | { before(grammarAccess.getALSMultiplicityAccess().getOneEnumLiteralDeclaration_4()); } | ||
1558 | ( 'one' | ||
1559 | ) | ||
1560 | { after(grammarAccess.getALSMultiplicityAccess().getOneEnumLiteralDeclaration_4()); } | ||
1561 | ) | ||
1562 | |||
1563 | |( | ||
1564 | { before(grammarAccess.getALSMultiplicityAccess().getSetEnumLiteralDeclaration_5()); } | ||
1565 | ( 'set' | ||
1566 | ) | ||
1567 | { after(grammarAccess.getALSMultiplicityAccess().getSetEnumLiteralDeclaration_5()); } | ||
1568 | ) | ||
1569 | |||
1570 | ; | ||
1571 | finally { | ||
1572 | restoreStackSize(stackSize); | ||
1573 | } | ||
1574 | |||
1575 | rule__ALSNumericOperator__Alternatives | ||
1576 | @init { | ||
1577 | int stackSize = keepStackSize(); | ||
1578 | } | ||
1579 | : | ||
1580 | ( | ||
1581 | { before(grammarAccess.getALSNumericOperatorAccess().getPlusEnumLiteralDeclaration_0()); } | ||
1582 | ( 'plus' | ||
1583 | ) | ||
1584 | { after(grammarAccess.getALSNumericOperatorAccess().getPlusEnumLiteralDeclaration_0()); } | ||
1585 | ) | ||
1586 | |||
1587 | |( | ||
1588 | { before(grammarAccess.getALSNumericOperatorAccess().getSubEnumLiteralDeclaration_1()); } | ||
1589 | ( 'sub' | ||
1590 | ) | ||
1591 | { after(grammarAccess.getALSNumericOperatorAccess().getSubEnumLiteralDeclaration_1()); } | ||
1592 | ) | ||
1593 | |||
1594 | |( | ||
1595 | { before(grammarAccess.getALSNumericOperatorAccess().getMulEnumLiteralDeclaration_2()); } | ||
1596 | ( 'mul' | ||
1597 | ) | ||
1598 | { after(grammarAccess.getALSNumericOperatorAccess().getMulEnumLiteralDeclaration_2()); } | ||
1599 | ) | ||
1600 | |||
1601 | |( | ||
1602 | { before(grammarAccess.getALSNumericOperatorAccess().getRemEnumLiteralDeclaration_3()); } | ||
1603 | ( 'rem' | ||
1604 | ) | ||
1605 | { after(grammarAccess.getALSNumericOperatorAccess().getRemEnumLiteralDeclaration_3()); } | ||
1606 | ) | ||
1607 | |||
1608 | |( | ||
1609 | { before(grammarAccess.getALSNumericOperatorAccess().getDivEnumLiteralDeclaration_4()); } | ||
1610 | ( 'div' | ||
1611 | ) | ||
1612 | { after(grammarAccess.getALSNumericOperatorAccess().getDivEnumLiteralDeclaration_4()); } | ||
1613 | ) | ||
1614 | |||
1615 | ; | ||
1616 | finally { | ||
1617 | restoreStackSize(stackSize); | ||
1618 | } | ||
1619 | |||
1620 | |||
1621 | |||
1622 | rule__ALSDocument__Group__0 | ||
1623 | @init { | ||
1624 | int stackSize = keepStackSize(); | ||
1625 | } | ||
1626 | : | ||
1627 | rule__ALSDocument__Group__0__Impl | ||
1628 | rule__ALSDocument__Group__1 | ||
1629 | ; | ||
1630 | finally { | ||
1631 | restoreStackSize(stackSize); | ||
1632 | } | ||
1633 | |||
1634 | rule__ALSDocument__Group__0__Impl | ||
1635 | @init { | ||
1636 | int stackSize = keepStackSize(); | ||
1637 | } | ||
1638 | : | ||
1639 | ( | ||
1640 | ( | ||
1641 | { before(grammarAccess.getALSDocumentAccess().getAlternatives_0()); } | ||
1642 | (rule__ALSDocument__Alternatives_0) | ||
1643 | { after(grammarAccess.getALSDocumentAccess().getAlternatives_0()); } | ||
1644 | ) | ||
1645 | ( | ||
1646 | { before(grammarAccess.getALSDocumentAccess().getAlternatives_0()); } | ||
1647 | (rule__ALSDocument__Alternatives_0)* | ||
1648 | { after(grammarAccess.getALSDocumentAccess().getAlternatives_0()); } | ||
1649 | ) | ||
1650 | ) | ||
1651 | |||
1652 | ; | ||
1653 | finally { | ||
1654 | restoreStackSize(stackSize); | ||
1655 | } | ||
1656 | |||
1657 | |||
1658 | rule__ALSDocument__Group__1 | ||
1659 | @init { | ||
1660 | int stackSize = keepStackSize(); | ||
1661 | } | ||
1662 | : | ||
1663 | rule__ALSDocument__Group__1__Impl | ||
1664 | ; | ||
1665 | finally { | ||
1666 | restoreStackSize(stackSize); | ||
1667 | } | ||
1668 | |||
1669 | rule__ALSDocument__Group__1__Impl | ||
1670 | @init { | ||
1671 | int stackSize = keepStackSize(); | ||
1672 | } | ||
1673 | : | ||
1674 | ( | ||
1675 | { before(grammarAccess.getALSDocumentAccess().getRunCommandAssignment_1()); } | ||
1676 | (rule__ALSDocument__RunCommandAssignment_1) | ||
1677 | { after(grammarAccess.getALSDocumentAccess().getRunCommandAssignment_1()); } | ||
1678 | ) | ||
1679 | |||
1680 | ; | ||
1681 | finally { | ||
1682 | restoreStackSize(stackSize); | ||
1683 | } | ||
1684 | |||
1685 | |||
1686 | |||
1687 | |||
1688 | |||
1689 | |||
1690 | rule__ALSEnumDeclaration__Group__0 | ||
1691 | @init { | ||
1692 | int stackSize = keepStackSize(); | ||
1693 | } | ||
1694 | : | ||
1695 | rule__ALSEnumDeclaration__Group__0__Impl | ||
1696 | rule__ALSEnumDeclaration__Group__1 | ||
1697 | ; | ||
1698 | finally { | ||
1699 | restoreStackSize(stackSize); | ||
1700 | } | ||
1701 | |||
1702 | rule__ALSEnumDeclaration__Group__0__Impl | ||
1703 | @init { | ||
1704 | int stackSize = keepStackSize(); | ||
1705 | } | ||
1706 | : | ||
1707 | ( | ||
1708 | { before(grammarAccess.getALSEnumDeclarationAccess().getEnumKeyword_0()); } | ||
1709 | |||
1710 | 'enum' | ||
1711 | |||
1712 | { after(grammarAccess.getALSEnumDeclarationAccess().getEnumKeyword_0()); } | ||
1713 | ) | ||
1714 | |||
1715 | ; | ||
1716 | finally { | ||
1717 | restoreStackSize(stackSize); | ||
1718 | } | ||
1719 | |||
1720 | |||
1721 | rule__ALSEnumDeclaration__Group__1 | ||
1722 | @init { | ||
1723 | int stackSize = keepStackSize(); | ||
1724 | } | ||
1725 | : | ||
1726 | rule__ALSEnumDeclaration__Group__1__Impl | ||
1727 | rule__ALSEnumDeclaration__Group__2 | ||
1728 | ; | ||
1729 | finally { | ||
1730 | restoreStackSize(stackSize); | ||
1731 | } | ||
1732 | |||
1733 | rule__ALSEnumDeclaration__Group__1__Impl | ||
1734 | @init { | ||
1735 | int stackSize = keepStackSize(); | ||
1736 | } | ||
1737 | : | ||
1738 | ( | ||
1739 | { before(grammarAccess.getALSEnumDeclarationAccess().getNameAssignment_1()); } | ||
1740 | (rule__ALSEnumDeclaration__NameAssignment_1) | ||
1741 | { after(grammarAccess.getALSEnumDeclarationAccess().getNameAssignment_1()); } | ||
1742 | ) | ||
1743 | |||
1744 | ; | ||
1745 | finally { | ||
1746 | restoreStackSize(stackSize); | ||
1747 | } | ||
1748 | |||
1749 | |||
1750 | rule__ALSEnumDeclaration__Group__2 | ||
1751 | @init { | ||
1752 | int stackSize = keepStackSize(); | ||
1753 | } | ||
1754 | : | ||
1755 | rule__ALSEnumDeclaration__Group__2__Impl | ||
1756 | rule__ALSEnumDeclaration__Group__3 | ||
1757 | ; | ||
1758 | finally { | ||
1759 | restoreStackSize(stackSize); | ||
1760 | } | ||
1761 | |||
1762 | rule__ALSEnumDeclaration__Group__2__Impl | ||
1763 | @init { | ||
1764 | int stackSize = keepStackSize(); | ||
1765 | } | ||
1766 | : | ||
1767 | ( | ||
1768 | { before(grammarAccess.getALSEnumDeclarationAccess().getLeftCurlyBracketKeyword_2()); } | ||
1769 | |||
1770 | '{' | ||
1771 | |||
1772 | { after(grammarAccess.getALSEnumDeclarationAccess().getLeftCurlyBracketKeyword_2()); } | ||
1773 | ) | ||
1774 | |||
1775 | ; | ||
1776 | finally { | ||
1777 | restoreStackSize(stackSize); | ||
1778 | } | ||
1779 | |||
1780 | |||
1781 | rule__ALSEnumDeclaration__Group__3 | ||
1782 | @init { | ||
1783 | int stackSize = keepStackSize(); | ||
1784 | } | ||
1785 | : | ||
1786 | rule__ALSEnumDeclaration__Group__3__Impl | ||
1787 | rule__ALSEnumDeclaration__Group__4 | ||
1788 | ; | ||
1789 | finally { | ||
1790 | restoreStackSize(stackSize); | ||
1791 | } | ||
1792 | |||
1793 | rule__ALSEnumDeclaration__Group__3__Impl | ||
1794 | @init { | ||
1795 | int stackSize = keepStackSize(); | ||
1796 | } | ||
1797 | : | ||
1798 | ( | ||
1799 | { before(grammarAccess.getALSEnumDeclarationAccess().getLiteralAssignment_3()); } | ||
1800 | (rule__ALSEnumDeclaration__LiteralAssignment_3) | ||
1801 | { after(grammarAccess.getALSEnumDeclarationAccess().getLiteralAssignment_3()); } | ||
1802 | ) | ||
1803 | |||
1804 | ; | ||
1805 | finally { | ||
1806 | restoreStackSize(stackSize); | ||
1807 | } | ||
1808 | |||
1809 | |||
1810 | rule__ALSEnumDeclaration__Group__4 | ||
1811 | @init { | ||
1812 | int stackSize = keepStackSize(); | ||
1813 | } | ||
1814 | : | ||
1815 | rule__ALSEnumDeclaration__Group__4__Impl | ||
1816 | rule__ALSEnumDeclaration__Group__5 | ||
1817 | ; | ||
1818 | finally { | ||
1819 | restoreStackSize(stackSize); | ||
1820 | } | ||
1821 | |||
1822 | rule__ALSEnumDeclaration__Group__4__Impl | ||
1823 | @init { | ||
1824 | int stackSize = keepStackSize(); | ||
1825 | } | ||
1826 | : | ||
1827 | ( | ||
1828 | { before(grammarAccess.getALSEnumDeclarationAccess().getGroup_4()); } | ||
1829 | (rule__ALSEnumDeclaration__Group_4__0)* | ||
1830 | { after(grammarAccess.getALSEnumDeclarationAccess().getGroup_4()); } | ||
1831 | ) | ||
1832 | |||
1833 | ; | ||
1834 | finally { | ||
1835 | restoreStackSize(stackSize); | ||
1836 | } | ||
1837 | |||
1838 | |||
1839 | rule__ALSEnumDeclaration__Group__5 | ||
1840 | @init { | ||
1841 | int stackSize = keepStackSize(); | ||
1842 | } | ||
1843 | : | ||
1844 | rule__ALSEnumDeclaration__Group__5__Impl | ||
1845 | ; | ||
1846 | finally { | ||
1847 | restoreStackSize(stackSize); | ||
1848 | } | ||
1849 | |||
1850 | rule__ALSEnumDeclaration__Group__5__Impl | ||
1851 | @init { | ||
1852 | int stackSize = keepStackSize(); | ||
1853 | } | ||
1854 | : | ||
1855 | ( | ||
1856 | { before(grammarAccess.getALSEnumDeclarationAccess().getRightCurlyBracketKeyword_5()); } | ||
1857 | |||
1858 | '}' | ||
1859 | |||
1860 | { after(grammarAccess.getALSEnumDeclarationAccess().getRightCurlyBracketKeyword_5()); } | ||
1861 | ) | ||
1862 | |||
1863 | ; | ||
1864 | finally { | ||
1865 | restoreStackSize(stackSize); | ||
1866 | } | ||
1867 | |||
1868 | |||
1869 | |||
1870 | |||
1871 | |||
1872 | |||
1873 | |||
1874 | |||
1875 | |||
1876 | |||
1877 | |||
1878 | |||
1879 | |||
1880 | |||
1881 | rule__ALSEnumDeclaration__Group_4__0 | ||
1882 | @init { | ||
1883 | int stackSize = keepStackSize(); | ||
1884 | } | ||
1885 | : | ||
1886 | rule__ALSEnumDeclaration__Group_4__0__Impl | ||
1887 | rule__ALSEnumDeclaration__Group_4__1 | ||
1888 | ; | ||
1889 | finally { | ||
1890 | restoreStackSize(stackSize); | ||
1891 | } | ||
1892 | |||
1893 | rule__ALSEnumDeclaration__Group_4__0__Impl | ||
1894 | @init { | ||
1895 | int stackSize = keepStackSize(); | ||
1896 | } | ||
1897 | : | ||
1898 | ( | ||
1899 | { before(grammarAccess.getALSEnumDeclarationAccess().getCommaKeyword_4_0()); } | ||
1900 | |||
1901 | ',' | ||
1902 | |||
1903 | { after(grammarAccess.getALSEnumDeclarationAccess().getCommaKeyword_4_0()); } | ||
1904 | ) | ||
1905 | |||
1906 | ; | ||
1907 | finally { | ||
1908 | restoreStackSize(stackSize); | ||
1909 | } | ||
1910 | |||
1911 | |||
1912 | rule__ALSEnumDeclaration__Group_4__1 | ||
1913 | @init { | ||
1914 | int stackSize = keepStackSize(); | ||
1915 | } | ||
1916 | : | ||
1917 | rule__ALSEnumDeclaration__Group_4__1__Impl | ||
1918 | ; | ||
1919 | finally { | ||
1920 | restoreStackSize(stackSize); | ||
1921 | } | ||
1922 | |||
1923 | rule__ALSEnumDeclaration__Group_4__1__Impl | ||
1924 | @init { | ||
1925 | int stackSize = keepStackSize(); | ||
1926 | } | ||
1927 | : | ||
1928 | ( | ||
1929 | { before(grammarAccess.getALSEnumDeclarationAccess().getLiteralAssignment_4_1()); } | ||
1930 | (rule__ALSEnumDeclaration__LiteralAssignment_4_1) | ||
1931 | { after(grammarAccess.getALSEnumDeclarationAccess().getLiteralAssignment_4_1()); } | ||
1932 | ) | ||
1933 | |||
1934 | ; | ||
1935 | finally { | ||
1936 | restoreStackSize(stackSize); | ||
1937 | } | ||
1938 | |||
1939 | |||
1940 | |||
1941 | |||
1942 | |||
1943 | |||
1944 | rule__ALSSignatureBody__Group__0 | ||
1945 | @init { | ||
1946 | int stackSize = keepStackSize(); | ||
1947 | } | ||
1948 | : | ||
1949 | rule__ALSSignatureBody__Group__0__Impl | ||
1950 | rule__ALSSignatureBody__Group__1 | ||
1951 | ; | ||
1952 | finally { | ||
1953 | restoreStackSize(stackSize); | ||
1954 | } | ||
1955 | |||
1956 | rule__ALSSignatureBody__Group__0__Impl | ||
1957 | @init { | ||
1958 | int stackSize = keepStackSize(); | ||
1959 | } | ||
1960 | : | ||
1961 | ( | ||
1962 | { before(grammarAccess.getALSSignatureBodyAccess().getUnorderedGroup_0()); } | ||
1963 | (rule__ALSSignatureBody__UnorderedGroup_0) | ||
1964 | { after(grammarAccess.getALSSignatureBodyAccess().getUnorderedGroup_0()); } | ||
1965 | ) | ||
1966 | |||
1967 | ; | ||
1968 | finally { | ||
1969 | restoreStackSize(stackSize); | ||
1970 | } | ||
1971 | |||
1972 | |||
1973 | rule__ALSSignatureBody__Group__1 | ||
1974 | @init { | ||
1975 | int stackSize = keepStackSize(); | ||
1976 | } | ||
1977 | : | ||
1978 | rule__ALSSignatureBody__Group__1__Impl | ||
1979 | rule__ALSSignatureBody__Group__2 | ||
1980 | ; | ||
1981 | finally { | ||
1982 | restoreStackSize(stackSize); | ||
1983 | } | ||
1984 | |||
1985 | rule__ALSSignatureBody__Group__1__Impl | ||
1986 | @init { | ||
1987 | int stackSize = keepStackSize(); | ||
1988 | } | ||
1989 | : | ||
1990 | ( | ||
1991 | { before(grammarAccess.getALSSignatureBodyAccess().getSigKeyword_1()); } | ||
1992 | |||
1993 | 'sig' | ||
1994 | |||
1995 | { after(grammarAccess.getALSSignatureBodyAccess().getSigKeyword_1()); } | ||
1996 | ) | ||
1997 | |||
1998 | ; | ||
1999 | finally { | ||
2000 | restoreStackSize(stackSize); | ||
2001 | } | ||
2002 | |||
2003 | |||
2004 | rule__ALSSignatureBody__Group__2 | ||
2005 | @init { | ||
2006 | int stackSize = keepStackSize(); | ||
2007 | } | ||
2008 | : | ||
2009 | rule__ALSSignatureBody__Group__2__Impl | ||
2010 | rule__ALSSignatureBody__Group__3 | ||
2011 | ; | ||
2012 | finally { | ||
2013 | restoreStackSize(stackSize); | ||
2014 | } | ||
2015 | |||
2016 | rule__ALSSignatureBody__Group__2__Impl | ||
2017 | @init { | ||
2018 | int stackSize = keepStackSize(); | ||
2019 | } | ||
2020 | : | ||
2021 | ( | ||
2022 | { before(grammarAccess.getALSSignatureBodyAccess().getDeclarationsAssignment_2()); } | ||
2023 | (rule__ALSSignatureBody__DeclarationsAssignment_2) | ||
2024 | { after(grammarAccess.getALSSignatureBodyAccess().getDeclarationsAssignment_2()); } | ||
2025 | ) | ||
2026 | |||
2027 | ; | ||
2028 | finally { | ||
2029 | restoreStackSize(stackSize); | ||
2030 | } | ||
2031 | |||
2032 | |||
2033 | rule__ALSSignatureBody__Group__3 | ||
2034 | @init { | ||
2035 | int stackSize = keepStackSize(); | ||
2036 | } | ||
2037 | : | ||
2038 | rule__ALSSignatureBody__Group__3__Impl | ||
2039 | rule__ALSSignatureBody__Group__4 | ||
2040 | ; | ||
2041 | finally { | ||
2042 | restoreStackSize(stackSize); | ||
2043 | } | ||
2044 | |||
2045 | rule__ALSSignatureBody__Group__3__Impl | ||
2046 | @init { | ||
2047 | int stackSize = keepStackSize(); | ||
2048 | } | ||
2049 | : | ||
2050 | ( | ||
2051 | { before(grammarAccess.getALSSignatureBodyAccess().getGroup_3()); } | ||
2052 | (rule__ALSSignatureBody__Group_3__0)* | ||
2053 | { after(grammarAccess.getALSSignatureBodyAccess().getGroup_3()); } | ||
2054 | ) | ||
2055 | |||
2056 | ; | ||
2057 | finally { | ||
2058 | restoreStackSize(stackSize); | ||
2059 | } | ||
2060 | |||
2061 | |||
2062 | rule__ALSSignatureBody__Group__4 | ||
2063 | @init { | ||
2064 | int stackSize = keepStackSize(); | ||
2065 | } | ||
2066 | : | ||
2067 | rule__ALSSignatureBody__Group__4__Impl | ||
2068 | rule__ALSSignatureBody__Group__5 | ||
2069 | ; | ||
2070 | finally { | ||
2071 | restoreStackSize(stackSize); | ||
2072 | } | ||
2073 | |||
2074 | rule__ALSSignatureBody__Group__4__Impl | ||
2075 | @init { | ||
2076 | int stackSize = keepStackSize(); | ||
2077 | } | ||
2078 | : | ||
2079 | ( | ||
2080 | { before(grammarAccess.getALSSignatureBodyAccess().getAlternatives_4()); } | ||
2081 | (rule__ALSSignatureBody__Alternatives_4)? | ||
2082 | { after(grammarAccess.getALSSignatureBodyAccess().getAlternatives_4()); } | ||
2083 | ) | ||
2084 | |||
2085 | ; | ||
2086 | finally { | ||
2087 | restoreStackSize(stackSize); | ||
2088 | } | ||
2089 | |||
2090 | |||
2091 | rule__ALSSignatureBody__Group__5 | ||
2092 | @init { | ||
2093 | int stackSize = keepStackSize(); | ||
2094 | } | ||
2095 | : | ||
2096 | rule__ALSSignatureBody__Group__5__Impl | ||
2097 | rule__ALSSignatureBody__Group__6 | ||
2098 | ; | ||
2099 | finally { | ||
2100 | restoreStackSize(stackSize); | ||
2101 | } | ||
2102 | |||
2103 | rule__ALSSignatureBody__Group__5__Impl | ||
2104 | @init { | ||
2105 | int stackSize = keepStackSize(); | ||
2106 | } | ||
2107 | : | ||
2108 | ( | ||
2109 | { before(grammarAccess.getALSSignatureBodyAccess().getLeftCurlyBracketKeyword_5()); } | ||
2110 | |||
2111 | '{' | ||
2112 | |||
2113 | { after(grammarAccess.getALSSignatureBodyAccess().getLeftCurlyBracketKeyword_5()); } | ||
2114 | ) | ||
2115 | |||
2116 | ; | ||
2117 | finally { | ||
2118 | restoreStackSize(stackSize); | ||
2119 | } | ||
2120 | |||
2121 | |||
2122 | rule__ALSSignatureBody__Group__6 | ||
2123 | @init { | ||
2124 | int stackSize = keepStackSize(); | ||
2125 | } | ||
2126 | : | ||
2127 | rule__ALSSignatureBody__Group__6__Impl | ||
2128 | rule__ALSSignatureBody__Group__7 | ||
2129 | ; | ||
2130 | finally { | ||
2131 | restoreStackSize(stackSize); | ||
2132 | } | ||
2133 | |||
2134 | rule__ALSSignatureBody__Group__6__Impl | ||
2135 | @init { | ||
2136 | int stackSize = keepStackSize(); | ||
2137 | } | ||
2138 | : | ||
2139 | ( | ||
2140 | { before(grammarAccess.getALSSignatureBodyAccess().getGroup_6()); } | ||
2141 | (rule__ALSSignatureBody__Group_6__0)? | ||
2142 | { after(grammarAccess.getALSSignatureBodyAccess().getGroup_6()); } | ||
2143 | ) | ||
2144 | |||
2145 | ; | ||
2146 | finally { | ||
2147 | restoreStackSize(stackSize); | ||
2148 | } | ||
2149 | |||
2150 | |||
2151 | rule__ALSSignatureBody__Group__7 | ||
2152 | @init { | ||
2153 | int stackSize = keepStackSize(); | ||
2154 | } | ||
2155 | : | ||
2156 | rule__ALSSignatureBody__Group__7__Impl | ||
2157 | ; | ||
2158 | finally { | ||
2159 | restoreStackSize(stackSize); | ||
2160 | } | ||
2161 | |||
2162 | rule__ALSSignatureBody__Group__7__Impl | ||
2163 | @init { | ||
2164 | int stackSize = keepStackSize(); | ||
2165 | } | ||
2166 | : | ||
2167 | ( | ||
2168 | { before(grammarAccess.getALSSignatureBodyAccess().getRightCurlyBracketKeyword_7()); } | ||
2169 | |||
2170 | '}' | ||
2171 | |||
2172 | { after(grammarAccess.getALSSignatureBodyAccess().getRightCurlyBracketKeyword_7()); } | ||
2173 | ) | ||
2174 | |||
2175 | ; | ||
2176 | finally { | ||
2177 | restoreStackSize(stackSize); | ||
2178 | } | ||
2179 | |||
2180 | |||
2181 | |||
2182 | |||
2183 | |||
2184 | |||
2185 | |||
2186 | |||
2187 | |||
2188 | |||
2189 | |||
2190 | |||
2191 | |||
2192 | |||
2193 | |||
2194 | |||
2195 | |||
2196 | |||
2197 | rule__ALSSignatureBody__Group_3__0 | ||
2198 | @init { | ||
2199 | int stackSize = keepStackSize(); | ||
2200 | } | ||
2201 | : | ||
2202 | rule__ALSSignatureBody__Group_3__0__Impl | ||
2203 | rule__ALSSignatureBody__Group_3__1 | ||
2204 | ; | ||
2205 | finally { | ||
2206 | restoreStackSize(stackSize); | ||
2207 | } | ||
2208 | |||
2209 | rule__ALSSignatureBody__Group_3__0__Impl | ||
2210 | @init { | ||
2211 | int stackSize = keepStackSize(); | ||
2212 | } | ||
2213 | : | ||
2214 | ( | ||
2215 | { before(grammarAccess.getALSSignatureBodyAccess().getCommaKeyword_3_0()); } | ||
2216 | |||
2217 | ',' | ||
2218 | |||
2219 | { after(grammarAccess.getALSSignatureBodyAccess().getCommaKeyword_3_0()); } | ||
2220 | ) | ||
2221 | |||
2222 | ; | ||
2223 | finally { | ||
2224 | restoreStackSize(stackSize); | ||
2225 | } | ||
2226 | |||
2227 | |||
2228 | rule__ALSSignatureBody__Group_3__1 | ||
2229 | @init { | ||
2230 | int stackSize = keepStackSize(); | ||
2231 | } | ||
2232 | : | ||
2233 | rule__ALSSignatureBody__Group_3__1__Impl | ||
2234 | ; | ||
2235 | finally { | ||
2236 | restoreStackSize(stackSize); | ||
2237 | } | ||
2238 | |||
2239 | rule__ALSSignatureBody__Group_3__1__Impl | ||
2240 | @init { | ||
2241 | int stackSize = keepStackSize(); | ||
2242 | } | ||
2243 | : | ||
2244 | ( | ||
2245 | { before(grammarAccess.getALSSignatureBodyAccess().getDeclarationsAssignment_3_1()); } | ||
2246 | (rule__ALSSignatureBody__DeclarationsAssignment_3_1) | ||
2247 | { after(grammarAccess.getALSSignatureBodyAccess().getDeclarationsAssignment_3_1()); } | ||
2248 | ) | ||
2249 | |||
2250 | ; | ||
2251 | finally { | ||
2252 | restoreStackSize(stackSize); | ||
2253 | } | ||
2254 | |||
2255 | |||
2256 | |||
2257 | |||
2258 | |||
2259 | |||
2260 | rule__ALSSignatureBody__Group_4_0__0 | ||
2261 | @init { | ||
2262 | int stackSize = keepStackSize(); | ||
2263 | } | ||
2264 | : | ||
2265 | rule__ALSSignatureBody__Group_4_0__0__Impl | ||
2266 | rule__ALSSignatureBody__Group_4_0__1 | ||
2267 | ; | ||
2268 | finally { | ||
2269 | restoreStackSize(stackSize); | ||
2270 | } | ||
2271 | |||
2272 | rule__ALSSignatureBody__Group_4_0__0__Impl | ||
2273 | @init { | ||
2274 | int stackSize = keepStackSize(); | ||
2275 | } | ||
2276 | : | ||
2277 | ( | ||
2278 | { before(grammarAccess.getALSSignatureBodyAccess().getExtendsKeyword_4_0_0()); } | ||
2279 | |||
2280 | 'extends' | ||
2281 | |||
2282 | { after(grammarAccess.getALSSignatureBodyAccess().getExtendsKeyword_4_0_0()); } | ||
2283 | ) | ||
2284 | |||
2285 | ; | ||
2286 | finally { | ||
2287 | restoreStackSize(stackSize); | ||
2288 | } | ||
2289 | |||
2290 | |||
2291 | rule__ALSSignatureBody__Group_4_0__1 | ||
2292 | @init { | ||
2293 | int stackSize = keepStackSize(); | ||
2294 | } | ||
2295 | : | ||
2296 | rule__ALSSignatureBody__Group_4_0__1__Impl | ||
2297 | ; | ||
2298 | finally { | ||
2299 | restoreStackSize(stackSize); | ||
2300 | } | ||
2301 | |||
2302 | rule__ALSSignatureBody__Group_4_0__1__Impl | ||
2303 | @init { | ||
2304 | int stackSize = keepStackSize(); | ||
2305 | } | ||
2306 | : | ||
2307 | ( | ||
2308 | { before(grammarAccess.getALSSignatureBodyAccess().getSupertypeAssignment_4_0_1()); } | ||
2309 | (rule__ALSSignatureBody__SupertypeAssignment_4_0_1) | ||
2310 | { after(grammarAccess.getALSSignatureBodyAccess().getSupertypeAssignment_4_0_1()); } | ||
2311 | ) | ||
2312 | |||
2313 | ; | ||
2314 | finally { | ||
2315 | restoreStackSize(stackSize); | ||
2316 | } | ||
2317 | |||
2318 | |||
2319 | |||
2320 | |||
2321 | |||
2322 | |||
2323 | rule__ALSSignatureBody__Group_4_1__0 | ||
2324 | @init { | ||
2325 | int stackSize = keepStackSize(); | ||
2326 | } | ||
2327 | : | ||
2328 | rule__ALSSignatureBody__Group_4_1__0__Impl | ||
2329 | rule__ALSSignatureBody__Group_4_1__1 | ||
2330 | ; | ||
2331 | finally { | ||
2332 | restoreStackSize(stackSize); | ||
2333 | } | ||
2334 | |||
2335 | rule__ALSSignatureBody__Group_4_1__0__Impl | ||
2336 | @init { | ||
2337 | int stackSize = keepStackSize(); | ||
2338 | } | ||
2339 | : | ||
2340 | ( | ||
2341 | { before(grammarAccess.getALSSignatureBodyAccess().getInKeyword_4_1_0()); } | ||
2342 | |||
2343 | 'in' | ||
2344 | |||
2345 | { after(grammarAccess.getALSSignatureBodyAccess().getInKeyword_4_1_0()); } | ||
2346 | ) | ||
2347 | |||
2348 | ; | ||
2349 | finally { | ||
2350 | restoreStackSize(stackSize); | ||
2351 | } | ||
2352 | |||
2353 | |||
2354 | rule__ALSSignatureBody__Group_4_1__1 | ||
2355 | @init { | ||
2356 | int stackSize = keepStackSize(); | ||
2357 | } | ||
2358 | : | ||
2359 | rule__ALSSignatureBody__Group_4_1__1__Impl | ||
2360 | rule__ALSSignatureBody__Group_4_1__2 | ||
2361 | ; | ||
2362 | finally { | ||
2363 | restoreStackSize(stackSize); | ||
2364 | } | ||
2365 | |||
2366 | rule__ALSSignatureBody__Group_4_1__1__Impl | ||
2367 | @init { | ||
2368 | int stackSize = keepStackSize(); | ||
2369 | } | ||
2370 | : | ||
2371 | ( | ||
2372 | { before(grammarAccess.getALSSignatureBodyAccess().getSupersetAssignment_4_1_1()); } | ||
2373 | (rule__ALSSignatureBody__SupersetAssignment_4_1_1) | ||
2374 | { after(grammarAccess.getALSSignatureBodyAccess().getSupersetAssignment_4_1_1()); } | ||
2375 | ) | ||
2376 | |||
2377 | ; | ||
2378 | finally { | ||
2379 | restoreStackSize(stackSize); | ||
2380 | } | ||
2381 | |||
2382 | |||
2383 | rule__ALSSignatureBody__Group_4_1__2 | ||
2384 | @init { | ||
2385 | int stackSize = keepStackSize(); | ||
2386 | } | ||
2387 | : | ||
2388 | rule__ALSSignatureBody__Group_4_1__2__Impl | ||
2389 | ; | ||
2390 | finally { | ||
2391 | restoreStackSize(stackSize); | ||
2392 | } | ||
2393 | |||
2394 | rule__ALSSignatureBody__Group_4_1__2__Impl | ||
2395 | @init { | ||
2396 | int stackSize = keepStackSize(); | ||
2397 | } | ||
2398 | : | ||
2399 | ( | ||
2400 | { before(grammarAccess.getALSSignatureBodyAccess().getGroup_4_1_2()); } | ||
2401 | (rule__ALSSignatureBody__Group_4_1_2__0)* | ||
2402 | { after(grammarAccess.getALSSignatureBodyAccess().getGroup_4_1_2()); } | ||
2403 | ) | ||
2404 | |||
2405 | ; | ||
2406 | finally { | ||
2407 | restoreStackSize(stackSize); | ||
2408 | } | ||
2409 | |||
2410 | |||
2411 | |||
2412 | |||
2413 | |||
2414 | |||
2415 | |||
2416 | |||
2417 | rule__ALSSignatureBody__Group_4_1_2__0 | ||
2418 | @init { | ||
2419 | int stackSize = keepStackSize(); | ||
2420 | } | ||
2421 | : | ||
2422 | rule__ALSSignatureBody__Group_4_1_2__0__Impl | ||
2423 | rule__ALSSignatureBody__Group_4_1_2__1 | ||
2424 | ; | ||
2425 | finally { | ||
2426 | restoreStackSize(stackSize); | ||
2427 | } | ||
2428 | |||
2429 | rule__ALSSignatureBody__Group_4_1_2__0__Impl | ||
2430 | @init { | ||
2431 | int stackSize = keepStackSize(); | ||
2432 | } | ||
2433 | : | ||
2434 | ( | ||
2435 | { before(grammarAccess.getALSSignatureBodyAccess().getPlusSignKeyword_4_1_2_0()); } | ||
2436 | |||
2437 | '+' | ||
2438 | |||
2439 | { after(grammarAccess.getALSSignatureBodyAccess().getPlusSignKeyword_4_1_2_0()); } | ||
2440 | ) | ||
2441 | |||
2442 | ; | ||
2443 | finally { | ||
2444 | restoreStackSize(stackSize); | ||
2445 | } | ||
2446 | |||
2447 | |||
2448 | rule__ALSSignatureBody__Group_4_1_2__1 | ||
2449 | @init { | ||
2450 | int stackSize = keepStackSize(); | ||
2451 | } | ||
2452 | : | ||
2453 | rule__ALSSignatureBody__Group_4_1_2__1__Impl | ||
2454 | ; | ||
2455 | finally { | ||
2456 | restoreStackSize(stackSize); | ||
2457 | } | ||
2458 | |||
2459 | rule__ALSSignatureBody__Group_4_1_2__1__Impl | ||
2460 | @init { | ||
2461 | int stackSize = keepStackSize(); | ||
2462 | } | ||
2463 | : | ||
2464 | ( | ||
2465 | { before(grammarAccess.getALSSignatureBodyAccess().getSupersetAssignment_4_1_2_1()); } | ||
2466 | (rule__ALSSignatureBody__SupersetAssignment_4_1_2_1) | ||
2467 | { after(grammarAccess.getALSSignatureBodyAccess().getSupersetAssignment_4_1_2_1()); } | ||
2468 | ) | ||
2469 | |||
2470 | ; | ||
2471 | finally { | ||
2472 | restoreStackSize(stackSize); | ||
2473 | } | ||
2474 | |||
2475 | |||
2476 | |||
2477 | |||
2478 | |||
2479 | |||
2480 | rule__ALSSignatureBody__Group_6__0 | ||
2481 | @init { | ||
2482 | int stackSize = keepStackSize(); | ||
2483 | } | ||
2484 | : | ||
2485 | rule__ALSSignatureBody__Group_6__0__Impl | ||
2486 | rule__ALSSignatureBody__Group_6__1 | ||
2487 | ; | ||
2488 | finally { | ||
2489 | restoreStackSize(stackSize); | ||
2490 | } | ||
2491 | |||
2492 | rule__ALSSignatureBody__Group_6__0__Impl | ||
2493 | @init { | ||
2494 | int stackSize = keepStackSize(); | ||
2495 | } | ||
2496 | : | ||
2497 | ( | ||
2498 | { before(grammarAccess.getALSSignatureBodyAccess().getFieldsAssignment_6_0()); } | ||
2499 | (rule__ALSSignatureBody__FieldsAssignment_6_0) | ||
2500 | { after(grammarAccess.getALSSignatureBodyAccess().getFieldsAssignment_6_0()); } | ||
2501 | ) | ||
2502 | |||
2503 | ; | ||
2504 | finally { | ||
2505 | restoreStackSize(stackSize); | ||
2506 | } | ||
2507 | |||
2508 | |||
2509 | rule__ALSSignatureBody__Group_6__1 | ||
2510 | @init { | ||
2511 | int stackSize = keepStackSize(); | ||
2512 | } | ||
2513 | : | ||
2514 | rule__ALSSignatureBody__Group_6__1__Impl | ||
2515 | ; | ||
2516 | finally { | ||
2517 | restoreStackSize(stackSize); | ||
2518 | } | ||
2519 | |||
2520 | rule__ALSSignatureBody__Group_6__1__Impl | ||
2521 | @init { | ||
2522 | int stackSize = keepStackSize(); | ||
2523 | } | ||
2524 | : | ||
2525 | ( | ||
2526 | { before(grammarAccess.getALSSignatureBodyAccess().getGroup_6_1()); } | ||
2527 | (rule__ALSSignatureBody__Group_6_1__0)* | ||
2528 | { after(grammarAccess.getALSSignatureBodyAccess().getGroup_6_1()); } | ||
2529 | ) | ||
2530 | |||
2531 | ; | ||
2532 | finally { | ||
2533 | restoreStackSize(stackSize); | ||
2534 | } | ||
2535 | |||
2536 | |||
2537 | |||
2538 | |||
2539 | |||
2540 | |||
2541 | rule__ALSSignatureBody__Group_6_1__0 | ||
2542 | @init { | ||
2543 | int stackSize = keepStackSize(); | ||
2544 | } | ||
2545 | : | ||
2546 | rule__ALSSignatureBody__Group_6_1__0__Impl | ||
2547 | rule__ALSSignatureBody__Group_6_1__1 | ||
2548 | ; | ||
2549 | finally { | ||
2550 | restoreStackSize(stackSize); | ||
2551 | } | ||
2552 | |||
2553 | rule__ALSSignatureBody__Group_6_1__0__Impl | ||
2554 | @init { | ||
2555 | int stackSize = keepStackSize(); | ||
2556 | } | ||
2557 | : | ||
2558 | ( | ||
2559 | { before(grammarAccess.getALSSignatureBodyAccess().getCommaKeyword_6_1_0()); } | ||
2560 | |||
2561 | ',' | ||
2562 | |||
2563 | { after(grammarAccess.getALSSignatureBodyAccess().getCommaKeyword_6_1_0()); } | ||
2564 | ) | ||
2565 | |||
2566 | ; | ||
2567 | finally { | ||
2568 | restoreStackSize(stackSize); | ||
2569 | } | ||
2570 | |||
2571 | |||
2572 | rule__ALSSignatureBody__Group_6_1__1 | ||
2573 | @init { | ||
2574 | int stackSize = keepStackSize(); | ||
2575 | } | ||
2576 | : | ||
2577 | rule__ALSSignatureBody__Group_6_1__1__Impl | ||
2578 | ; | ||
2579 | finally { | ||
2580 | restoreStackSize(stackSize); | ||
2581 | } | ||
2582 | |||
2583 | rule__ALSSignatureBody__Group_6_1__1__Impl | ||
2584 | @init { | ||
2585 | int stackSize = keepStackSize(); | ||
2586 | } | ||
2587 | : | ||
2588 | ( | ||
2589 | { before(grammarAccess.getALSSignatureBodyAccess().getFieldsAssignment_6_1_1()); } | ||
2590 | (rule__ALSSignatureBody__FieldsAssignment_6_1_1) | ||
2591 | { after(grammarAccess.getALSSignatureBodyAccess().getFieldsAssignment_6_1_1()); } | ||
2592 | ) | ||
2593 | |||
2594 | ; | ||
2595 | finally { | ||
2596 | restoreStackSize(stackSize); | ||
2597 | } | ||
2598 | |||
2599 | |||
2600 | |||
2601 | |||
2602 | |||
2603 | |||
2604 | rule__ALSFieldDeclaration__Group__0 | ||
2605 | @init { | ||
2606 | int stackSize = keepStackSize(); | ||
2607 | } | ||
2608 | : | ||
2609 | rule__ALSFieldDeclaration__Group__0__Impl | ||
2610 | rule__ALSFieldDeclaration__Group__1 | ||
2611 | ; | ||
2612 | finally { | ||
2613 | restoreStackSize(stackSize); | ||
2614 | } | ||
2615 | |||
2616 | rule__ALSFieldDeclaration__Group__0__Impl | ||
2617 | @init { | ||
2618 | int stackSize = keepStackSize(); | ||
2619 | } | ||
2620 | : | ||
2621 | ( | ||
2622 | { before(grammarAccess.getALSFieldDeclarationAccess().getNameAssignment_0()); } | ||
2623 | (rule__ALSFieldDeclaration__NameAssignment_0) | ||
2624 | { after(grammarAccess.getALSFieldDeclarationAccess().getNameAssignment_0()); } | ||
2625 | ) | ||
2626 | |||
2627 | ; | ||
2628 | finally { | ||
2629 | restoreStackSize(stackSize); | ||
2630 | } | ||
2631 | |||
2632 | |||
2633 | rule__ALSFieldDeclaration__Group__1 | ||
2634 | @init { | ||
2635 | int stackSize = keepStackSize(); | ||
2636 | } | ||
2637 | : | ||
2638 | rule__ALSFieldDeclaration__Group__1__Impl | ||
2639 | rule__ALSFieldDeclaration__Group__2 | ||
2640 | ; | ||
2641 | finally { | ||
2642 | restoreStackSize(stackSize); | ||
2643 | } | ||
2644 | |||
2645 | rule__ALSFieldDeclaration__Group__1__Impl | ||
2646 | @init { | ||
2647 | int stackSize = keepStackSize(); | ||
2648 | } | ||
2649 | : | ||
2650 | ( | ||
2651 | { before(grammarAccess.getALSFieldDeclarationAccess().getColonKeyword_1()); } | ||
2652 | |||
2653 | ':' | ||
2654 | |||
2655 | { after(grammarAccess.getALSFieldDeclarationAccess().getColonKeyword_1()); } | ||
2656 | ) | ||
2657 | |||
2658 | ; | ||
2659 | finally { | ||
2660 | restoreStackSize(stackSize); | ||
2661 | } | ||
2662 | |||
2663 | |||
2664 | rule__ALSFieldDeclaration__Group__2 | ||
2665 | @init { | ||
2666 | int stackSize = keepStackSize(); | ||
2667 | } | ||
2668 | : | ||
2669 | rule__ALSFieldDeclaration__Group__2__Impl | ||
2670 | rule__ALSFieldDeclaration__Group__3 | ||
2671 | ; | ||
2672 | finally { | ||
2673 | restoreStackSize(stackSize); | ||
2674 | } | ||
2675 | |||
2676 | rule__ALSFieldDeclaration__Group__2__Impl | ||
2677 | @init { | ||
2678 | int stackSize = keepStackSize(); | ||
2679 | } | ||
2680 | : | ||
2681 | ( | ||
2682 | { before(grammarAccess.getALSFieldDeclarationAccess().getMultiplicityAssignment_2()); } | ||
2683 | (rule__ALSFieldDeclaration__MultiplicityAssignment_2)? | ||
2684 | { after(grammarAccess.getALSFieldDeclarationAccess().getMultiplicityAssignment_2()); } | ||
2685 | ) | ||
2686 | |||
2687 | ; | ||
2688 | finally { | ||
2689 | restoreStackSize(stackSize); | ||
2690 | } | ||
2691 | |||
2692 | |||
2693 | rule__ALSFieldDeclaration__Group__3 | ||
2694 | @init { | ||
2695 | int stackSize = keepStackSize(); | ||
2696 | } | ||
2697 | : | ||
2698 | rule__ALSFieldDeclaration__Group__3__Impl | ||
2699 | ; | ||
2700 | finally { | ||
2701 | restoreStackSize(stackSize); | ||
2702 | } | ||
2703 | |||
2704 | rule__ALSFieldDeclaration__Group__3__Impl | ||
2705 | @init { | ||
2706 | int stackSize = keepStackSize(); | ||
2707 | } | ||
2708 | : | ||
2709 | ( | ||
2710 | { before(grammarAccess.getALSFieldDeclarationAccess().getTypeAssignment_3()); } | ||
2711 | (rule__ALSFieldDeclaration__TypeAssignment_3) | ||
2712 | { after(grammarAccess.getALSFieldDeclarationAccess().getTypeAssignment_3()); } | ||
2713 | ) | ||
2714 | |||
2715 | ; | ||
2716 | finally { | ||
2717 | restoreStackSize(stackSize); | ||
2718 | } | ||
2719 | |||
2720 | |||
2721 | |||
2722 | |||
2723 | |||
2724 | |||
2725 | |||
2726 | |||
2727 | |||
2728 | |||
2729 | rule__ALSFunctionDefinition__Group__0 | ||
2730 | @init { | ||
2731 | int stackSize = keepStackSize(); | ||
2732 | } | ||
2733 | : | ||
2734 | rule__ALSFunctionDefinition__Group__0__Impl | ||
2735 | rule__ALSFunctionDefinition__Group__1 | ||
2736 | ; | ||
2737 | finally { | ||
2738 | restoreStackSize(stackSize); | ||
2739 | } | ||
2740 | |||
2741 | rule__ALSFunctionDefinition__Group__0__Impl | ||
2742 | @init { | ||
2743 | int stackSize = keepStackSize(); | ||
2744 | } | ||
2745 | : | ||
2746 | ( | ||
2747 | { before(grammarAccess.getALSFunctionDefinitionAccess().getFunKeyword_0()); } | ||
2748 | |||
2749 | 'fun' | ||
2750 | |||
2751 | { after(grammarAccess.getALSFunctionDefinitionAccess().getFunKeyword_0()); } | ||
2752 | ) | ||
2753 | |||
2754 | ; | ||
2755 | finally { | ||
2756 | restoreStackSize(stackSize); | ||
2757 | } | ||
2758 | |||
2759 | |||
2760 | rule__ALSFunctionDefinition__Group__1 | ||
2761 | @init { | ||
2762 | int stackSize = keepStackSize(); | ||
2763 | } | ||
2764 | : | ||
2765 | rule__ALSFunctionDefinition__Group__1__Impl | ||
2766 | rule__ALSFunctionDefinition__Group__2 | ||
2767 | ; | ||
2768 | finally { | ||
2769 | restoreStackSize(stackSize); | ||
2770 | } | ||
2771 | |||
2772 | rule__ALSFunctionDefinition__Group__1__Impl | ||
2773 | @init { | ||
2774 | int stackSize = keepStackSize(); | ||
2775 | } | ||
2776 | : | ||
2777 | ( | ||
2778 | { before(grammarAccess.getALSFunctionDefinitionAccess().getNameAssignment_1()); } | ||
2779 | (rule__ALSFunctionDefinition__NameAssignment_1) | ||
2780 | { after(grammarAccess.getALSFunctionDefinitionAccess().getNameAssignment_1()); } | ||
2781 | ) | ||
2782 | |||
2783 | ; | ||
2784 | finally { | ||
2785 | restoreStackSize(stackSize); | ||
2786 | } | ||
2787 | |||
2788 | |||
2789 | rule__ALSFunctionDefinition__Group__2 | ||
2790 | @init { | ||
2791 | int stackSize = keepStackSize(); | ||
2792 | } | ||
2793 | : | ||
2794 | rule__ALSFunctionDefinition__Group__2__Impl | ||
2795 | rule__ALSFunctionDefinition__Group__3 | ||
2796 | ; | ||
2797 | finally { | ||
2798 | restoreStackSize(stackSize); | ||
2799 | } | ||
2800 | |||
2801 | rule__ALSFunctionDefinition__Group__2__Impl | ||
2802 | @init { | ||
2803 | int stackSize = keepStackSize(); | ||
2804 | } | ||
2805 | : | ||
2806 | ( | ||
2807 | { before(grammarAccess.getALSFunctionDefinitionAccess().getLeftSquareBracketKeyword_2()); } | ||
2808 | |||
2809 | '[' | ||
2810 | |||
2811 | { after(grammarAccess.getALSFunctionDefinitionAccess().getLeftSquareBracketKeyword_2()); } | ||
2812 | ) | ||
2813 | |||
2814 | ; | ||
2815 | finally { | ||
2816 | restoreStackSize(stackSize); | ||
2817 | } | ||
2818 | |||
2819 | |||
2820 | rule__ALSFunctionDefinition__Group__3 | ||
2821 | @init { | ||
2822 | int stackSize = keepStackSize(); | ||
2823 | } | ||
2824 | : | ||
2825 | rule__ALSFunctionDefinition__Group__3__Impl | ||
2826 | rule__ALSFunctionDefinition__Group__4 | ||
2827 | ; | ||
2828 | finally { | ||
2829 | restoreStackSize(stackSize); | ||
2830 | } | ||
2831 | |||
2832 | rule__ALSFunctionDefinition__Group__3__Impl | ||
2833 | @init { | ||
2834 | int stackSize = keepStackSize(); | ||
2835 | } | ||
2836 | : | ||
2837 | ( | ||
2838 | { before(grammarAccess.getALSFunctionDefinitionAccess().getVariablesAssignment_3()); } | ||
2839 | (rule__ALSFunctionDefinition__VariablesAssignment_3) | ||
2840 | { after(grammarAccess.getALSFunctionDefinitionAccess().getVariablesAssignment_3()); } | ||
2841 | ) | ||
2842 | |||
2843 | ; | ||
2844 | finally { | ||
2845 | restoreStackSize(stackSize); | ||
2846 | } | ||
2847 | |||
2848 | |||
2849 | rule__ALSFunctionDefinition__Group__4 | ||
2850 | @init { | ||
2851 | int stackSize = keepStackSize(); | ||
2852 | } | ||
2853 | : | ||
2854 | rule__ALSFunctionDefinition__Group__4__Impl | ||
2855 | rule__ALSFunctionDefinition__Group__5 | ||
2856 | ; | ||
2857 | finally { | ||
2858 | restoreStackSize(stackSize); | ||
2859 | } | ||
2860 | |||
2861 | rule__ALSFunctionDefinition__Group__4__Impl | ||
2862 | @init { | ||
2863 | int stackSize = keepStackSize(); | ||
2864 | } | ||
2865 | : | ||
2866 | ( | ||
2867 | { before(grammarAccess.getALSFunctionDefinitionAccess().getGroup_4()); } | ||
2868 | (rule__ALSFunctionDefinition__Group_4__0)* | ||
2869 | { after(grammarAccess.getALSFunctionDefinitionAccess().getGroup_4()); } | ||
2870 | ) | ||
2871 | |||
2872 | ; | ||
2873 | finally { | ||
2874 | restoreStackSize(stackSize); | ||
2875 | } | ||
2876 | |||
2877 | |||
2878 | rule__ALSFunctionDefinition__Group__5 | ||
2879 | @init { | ||
2880 | int stackSize = keepStackSize(); | ||
2881 | } | ||
2882 | : | ||
2883 | rule__ALSFunctionDefinition__Group__5__Impl | ||
2884 | rule__ALSFunctionDefinition__Group__6 | ||
2885 | ; | ||
2886 | finally { | ||
2887 | restoreStackSize(stackSize); | ||
2888 | } | ||
2889 | |||
2890 | rule__ALSFunctionDefinition__Group__5__Impl | ||
2891 | @init { | ||
2892 | int stackSize = keepStackSize(); | ||
2893 | } | ||
2894 | : | ||
2895 | ( | ||
2896 | { before(grammarAccess.getALSFunctionDefinitionAccess().getRightSquareBracketKeyword_5()); } | ||
2897 | |||
2898 | ']' | ||
2899 | |||
2900 | { after(grammarAccess.getALSFunctionDefinitionAccess().getRightSquareBracketKeyword_5()); } | ||
2901 | ) | ||
2902 | |||
2903 | ; | ||
2904 | finally { | ||
2905 | restoreStackSize(stackSize); | ||
2906 | } | ||
2907 | |||
2908 | |||
2909 | rule__ALSFunctionDefinition__Group__6 | ||
2910 | @init { | ||
2911 | int stackSize = keepStackSize(); | ||
2912 | } | ||
2913 | : | ||
2914 | rule__ALSFunctionDefinition__Group__6__Impl | ||
2915 | rule__ALSFunctionDefinition__Group__7 | ||
2916 | ; | ||
2917 | finally { | ||
2918 | restoreStackSize(stackSize); | ||
2919 | } | ||
2920 | |||
2921 | rule__ALSFunctionDefinition__Group__6__Impl | ||
2922 | @init { | ||
2923 | int stackSize = keepStackSize(); | ||
2924 | } | ||
2925 | : | ||
2926 | ( | ||
2927 | { before(grammarAccess.getALSFunctionDefinitionAccess().getColonKeyword_6()); } | ||
2928 | |||
2929 | ':' | ||
2930 | |||
2931 | { after(grammarAccess.getALSFunctionDefinitionAccess().getColonKeyword_6()); } | ||
2932 | ) | ||
2933 | |||
2934 | ; | ||
2935 | finally { | ||
2936 | restoreStackSize(stackSize); | ||
2937 | } | ||
2938 | |||
2939 | |||
2940 | rule__ALSFunctionDefinition__Group__7 | ||
2941 | @init { | ||
2942 | int stackSize = keepStackSize(); | ||
2943 | } | ||
2944 | : | ||
2945 | rule__ALSFunctionDefinition__Group__7__Impl | ||
2946 | rule__ALSFunctionDefinition__Group__8 | ||
2947 | ; | ||
2948 | finally { | ||
2949 | restoreStackSize(stackSize); | ||
2950 | } | ||
2951 | |||
2952 | rule__ALSFunctionDefinition__Group__7__Impl | ||
2953 | @init { | ||
2954 | int stackSize = keepStackSize(); | ||
2955 | } | ||
2956 | : | ||
2957 | ( | ||
2958 | { before(grammarAccess.getALSFunctionDefinitionAccess().getTypeAssignment_7()); } | ||
2959 | (rule__ALSFunctionDefinition__TypeAssignment_7) | ||
2960 | { after(grammarAccess.getALSFunctionDefinitionAccess().getTypeAssignment_7()); } | ||
2961 | ) | ||
2962 | |||
2963 | ; | ||
2964 | finally { | ||
2965 | restoreStackSize(stackSize); | ||
2966 | } | ||
2967 | |||
2968 | |||
2969 | rule__ALSFunctionDefinition__Group__8 | ||
2970 | @init { | ||
2971 | int stackSize = keepStackSize(); | ||
2972 | } | ||
2973 | : | ||
2974 | rule__ALSFunctionDefinition__Group__8__Impl | ||
2975 | rule__ALSFunctionDefinition__Group__9 | ||
2976 | ; | ||
2977 | finally { | ||
2978 | restoreStackSize(stackSize); | ||
2979 | } | ||
2980 | |||
2981 | rule__ALSFunctionDefinition__Group__8__Impl | ||
2982 | @init { | ||
2983 | int stackSize = keepStackSize(); | ||
2984 | } | ||
2985 | : | ||
2986 | ( | ||
2987 | { before(grammarAccess.getALSFunctionDefinitionAccess().getLeftCurlyBracketKeyword_8()); } | ||
2988 | |||
2989 | '{' | ||
2990 | |||
2991 | { after(grammarAccess.getALSFunctionDefinitionAccess().getLeftCurlyBracketKeyword_8()); } | ||
2992 | ) | ||
2993 | |||
2994 | ; | ||
2995 | finally { | ||
2996 | restoreStackSize(stackSize); | ||
2997 | } | ||
2998 | |||
2999 | |||
3000 | rule__ALSFunctionDefinition__Group__9 | ||
3001 | @init { | ||
3002 | int stackSize = keepStackSize(); | ||
3003 | } | ||
3004 | : | ||
3005 | rule__ALSFunctionDefinition__Group__9__Impl | ||
3006 | rule__ALSFunctionDefinition__Group__10 | ||
3007 | ; | ||
3008 | finally { | ||
3009 | restoreStackSize(stackSize); | ||
3010 | } | ||
3011 | |||
3012 | rule__ALSFunctionDefinition__Group__9__Impl | ||
3013 | @init { | ||
3014 | int stackSize = keepStackSize(); | ||
3015 | } | ||
3016 | : | ||
3017 | ( | ||
3018 | { before(grammarAccess.getALSFunctionDefinitionAccess().getValueAssignment_9()); } | ||
3019 | (rule__ALSFunctionDefinition__ValueAssignment_9) | ||
3020 | { after(grammarAccess.getALSFunctionDefinitionAccess().getValueAssignment_9()); } | ||
3021 | ) | ||
3022 | |||
3023 | ; | ||
3024 | finally { | ||
3025 | restoreStackSize(stackSize); | ||
3026 | } | ||
3027 | |||
3028 | |||
3029 | rule__ALSFunctionDefinition__Group__10 | ||
3030 | @init { | ||
3031 | int stackSize = keepStackSize(); | ||
3032 | } | ||
3033 | : | ||
3034 | rule__ALSFunctionDefinition__Group__10__Impl | ||
3035 | ; | ||
3036 | finally { | ||
3037 | restoreStackSize(stackSize); | ||
3038 | } | ||
3039 | |||
3040 | rule__ALSFunctionDefinition__Group__10__Impl | ||
3041 | @init { | ||
3042 | int stackSize = keepStackSize(); | ||
3043 | } | ||
3044 | : | ||
3045 | ( | ||
3046 | { before(grammarAccess.getALSFunctionDefinitionAccess().getRightCurlyBracketKeyword_10()); } | ||
3047 | |||
3048 | '}' | ||
3049 | |||
3050 | { after(grammarAccess.getALSFunctionDefinitionAccess().getRightCurlyBracketKeyword_10()); } | ||
3051 | ) | ||
3052 | |||
3053 | ; | ||
3054 | finally { | ||
3055 | restoreStackSize(stackSize); | ||
3056 | } | ||
3057 | |||
3058 | |||
3059 | |||
3060 | |||
3061 | |||
3062 | |||
3063 | |||
3064 | |||
3065 | |||
3066 | |||
3067 | |||
3068 | |||
3069 | |||
3070 | |||
3071 | |||
3072 | |||
3073 | |||
3074 | |||
3075 | |||
3076 | |||
3077 | |||
3078 | |||
3079 | |||
3080 | |||
3081 | rule__ALSFunctionDefinition__Group_4__0 | ||
3082 | @init { | ||
3083 | int stackSize = keepStackSize(); | ||
3084 | } | ||
3085 | : | ||
3086 | rule__ALSFunctionDefinition__Group_4__0__Impl | ||
3087 | rule__ALSFunctionDefinition__Group_4__1 | ||
3088 | ; | ||
3089 | finally { | ||
3090 | restoreStackSize(stackSize); | ||
3091 | } | ||
3092 | |||
3093 | rule__ALSFunctionDefinition__Group_4__0__Impl | ||
3094 | @init { | ||
3095 | int stackSize = keepStackSize(); | ||
3096 | } | ||
3097 | : | ||
3098 | ( | ||
3099 | { before(grammarAccess.getALSFunctionDefinitionAccess().getCommaKeyword_4_0()); } | ||
3100 | |||
3101 | ',' | ||
3102 | |||
3103 | { after(grammarAccess.getALSFunctionDefinitionAccess().getCommaKeyword_4_0()); } | ||
3104 | ) | ||
3105 | |||
3106 | ; | ||
3107 | finally { | ||
3108 | restoreStackSize(stackSize); | ||
3109 | } | ||
3110 | |||
3111 | |||
3112 | rule__ALSFunctionDefinition__Group_4__1 | ||
3113 | @init { | ||
3114 | int stackSize = keepStackSize(); | ||
3115 | } | ||
3116 | : | ||
3117 | rule__ALSFunctionDefinition__Group_4__1__Impl | ||
3118 | ; | ||
3119 | finally { | ||
3120 | restoreStackSize(stackSize); | ||
3121 | } | ||
3122 | |||
3123 | rule__ALSFunctionDefinition__Group_4__1__Impl | ||
3124 | @init { | ||
3125 | int stackSize = keepStackSize(); | ||
3126 | } | ||
3127 | : | ||
3128 | ( | ||
3129 | { before(grammarAccess.getALSFunctionDefinitionAccess().getVariablesAssignment_4_1()); } | ||
3130 | (rule__ALSFunctionDefinition__VariablesAssignment_4_1) | ||
3131 | { after(grammarAccess.getALSFunctionDefinitionAccess().getVariablesAssignment_4_1()); } | ||
3132 | ) | ||
3133 | |||
3134 | ; | ||
3135 | finally { | ||
3136 | restoreStackSize(stackSize); | ||
3137 | } | ||
3138 | |||
3139 | |||
3140 | |||
3141 | |||
3142 | |||
3143 | |||
3144 | rule__ALSRelationDefinition__Group__0 | ||
3145 | @init { | ||
3146 | int stackSize = keepStackSize(); | ||
3147 | } | ||
3148 | : | ||
3149 | rule__ALSRelationDefinition__Group__0__Impl | ||
3150 | rule__ALSRelationDefinition__Group__1 | ||
3151 | ; | ||
3152 | finally { | ||
3153 | restoreStackSize(stackSize); | ||
3154 | } | ||
3155 | |||
3156 | rule__ALSRelationDefinition__Group__0__Impl | ||
3157 | @init { | ||
3158 | int stackSize = keepStackSize(); | ||
3159 | } | ||
3160 | : | ||
3161 | ( | ||
3162 | { before(grammarAccess.getALSRelationDefinitionAccess().getPredKeyword_0()); } | ||
3163 | |||
3164 | 'pred' | ||
3165 | |||
3166 | { after(grammarAccess.getALSRelationDefinitionAccess().getPredKeyword_0()); } | ||
3167 | ) | ||
3168 | |||
3169 | ; | ||
3170 | finally { | ||
3171 | restoreStackSize(stackSize); | ||
3172 | } | ||
3173 | |||
3174 | |||
3175 | rule__ALSRelationDefinition__Group__1 | ||
3176 | @init { | ||
3177 | int stackSize = keepStackSize(); | ||
3178 | } | ||
3179 | : | ||
3180 | rule__ALSRelationDefinition__Group__1__Impl | ||
3181 | rule__ALSRelationDefinition__Group__2 | ||
3182 | ; | ||
3183 | finally { | ||
3184 | restoreStackSize(stackSize); | ||
3185 | } | ||
3186 | |||
3187 | rule__ALSRelationDefinition__Group__1__Impl | ||
3188 | @init { | ||
3189 | int stackSize = keepStackSize(); | ||
3190 | } | ||
3191 | : | ||
3192 | ( | ||
3193 | { before(grammarAccess.getALSRelationDefinitionAccess().getNameAssignment_1()); } | ||
3194 | (rule__ALSRelationDefinition__NameAssignment_1) | ||
3195 | { after(grammarAccess.getALSRelationDefinitionAccess().getNameAssignment_1()); } | ||
3196 | ) | ||
3197 | |||
3198 | ; | ||
3199 | finally { | ||
3200 | restoreStackSize(stackSize); | ||
3201 | } | ||
3202 | |||
3203 | |||
3204 | rule__ALSRelationDefinition__Group__2 | ||
3205 | @init { | ||
3206 | int stackSize = keepStackSize(); | ||
3207 | } | ||
3208 | : | ||
3209 | rule__ALSRelationDefinition__Group__2__Impl | ||
3210 | rule__ALSRelationDefinition__Group__3 | ||
3211 | ; | ||
3212 | finally { | ||
3213 | restoreStackSize(stackSize); | ||
3214 | } | ||
3215 | |||
3216 | rule__ALSRelationDefinition__Group__2__Impl | ||
3217 | @init { | ||
3218 | int stackSize = keepStackSize(); | ||
3219 | } | ||
3220 | : | ||
3221 | ( | ||
3222 | { before(grammarAccess.getALSRelationDefinitionAccess().getLeftSquareBracketKeyword_2()); } | ||
3223 | |||
3224 | '[' | ||
3225 | |||
3226 | { after(grammarAccess.getALSRelationDefinitionAccess().getLeftSquareBracketKeyword_2()); } | ||
3227 | ) | ||
3228 | |||
3229 | ; | ||
3230 | finally { | ||
3231 | restoreStackSize(stackSize); | ||
3232 | } | ||
3233 | |||
3234 | |||
3235 | rule__ALSRelationDefinition__Group__3 | ||
3236 | @init { | ||
3237 | int stackSize = keepStackSize(); | ||
3238 | } | ||
3239 | : | ||
3240 | rule__ALSRelationDefinition__Group__3__Impl | ||
3241 | rule__ALSRelationDefinition__Group__4 | ||
3242 | ; | ||
3243 | finally { | ||
3244 | restoreStackSize(stackSize); | ||
3245 | } | ||
3246 | |||
3247 | rule__ALSRelationDefinition__Group__3__Impl | ||
3248 | @init { | ||
3249 | int stackSize = keepStackSize(); | ||
3250 | } | ||
3251 | : | ||
3252 | ( | ||
3253 | { before(grammarAccess.getALSRelationDefinitionAccess().getVariablesAssignment_3()); } | ||
3254 | (rule__ALSRelationDefinition__VariablesAssignment_3) | ||
3255 | { after(grammarAccess.getALSRelationDefinitionAccess().getVariablesAssignment_3()); } | ||
3256 | ) | ||
3257 | |||
3258 | ; | ||
3259 | finally { | ||
3260 | restoreStackSize(stackSize); | ||
3261 | } | ||
3262 | |||
3263 | |||
3264 | rule__ALSRelationDefinition__Group__4 | ||
3265 | @init { | ||
3266 | int stackSize = keepStackSize(); | ||
3267 | } | ||
3268 | : | ||
3269 | rule__ALSRelationDefinition__Group__4__Impl | ||
3270 | rule__ALSRelationDefinition__Group__5 | ||
3271 | ; | ||
3272 | finally { | ||
3273 | restoreStackSize(stackSize); | ||
3274 | } | ||
3275 | |||
3276 | rule__ALSRelationDefinition__Group__4__Impl | ||
3277 | @init { | ||
3278 | int stackSize = keepStackSize(); | ||
3279 | } | ||
3280 | : | ||
3281 | ( | ||
3282 | { before(grammarAccess.getALSRelationDefinitionAccess().getGroup_4()); } | ||
3283 | (rule__ALSRelationDefinition__Group_4__0)* | ||
3284 | { after(grammarAccess.getALSRelationDefinitionAccess().getGroup_4()); } | ||
3285 | ) | ||
3286 | |||
3287 | ; | ||
3288 | finally { | ||
3289 | restoreStackSize(stackSize); | ||
3290 | } | ||
3291 | |||
3292 | |||
3293 | rule__ALSRelationDefinition__Group__5 | ||
3294 | @init { | ||
3295 | int stackSize = keepStackSize(); | ||
3296 | } | ||
3297 | : | ||
3298 | rule__ALSRelationDefinition__Group__5__Impl | ||
3299 | rule__ALSRelationDefinition__Group__6 | ||
3300 | ; | ||
3301 | finally { | ||
3302 | restoreStackSize(stackSize); | ||
3303 | } | ||
3304 | |||
3305 | rule__ALSRelationDefinition__Group__5__Impl | ||
3306 | @init { | ||
3307 | int stackSize = keepStackSize(); | ||
3308 | } | ||
3309 | : | ||
3310 | ( | ||
3311 | { before(grammarAccess.getALSRelationDefinitionAccess().getRightSquareBracketKeyword_5()); } | ||
3312 | |||
3313 | ']' | ||
3314 | |||
3315 | { after(grammarAccess.getALSRelationDefinitionAccess().getRightSquareBracketKeyword_5()); } | ||
3316 | ) | ||
3317 | |||
3318 | ; | ||
3319 | finally { | ||
3320 | restoreStackSize(stackSize); | ||
3321 | } | ||
3322 | |||
3323 | |||
3324 | rule__ALSRelationDefinition__Group__6 | ||
3325 | @init { | ||
3326 | int stackSize = keepStackSize(); | ||
3327 | } | ||
3328 | : | ||
3329 | rule__ALSRelationDefinition__Group__6__Impl | ||
3330 | rule__ALSRelationDefinition__Group__7 | ||
3331 | ; | ||
3332 | finally { | ||
3333 | restoreStackSize(stackSize); | ||
3334 | } | ||
3335 | |||
3336 | rule__ALSRelationDefinition__Group__6__Impl | ||
3337 | @init { | ||
3338 | int stackSize = keepStackSize(); | ||
3339 | } | ||
3340 | : | ||
3341 | ( | ||
3342 | { before(grammarAccess.getALSRelationDefinitionAccess().getLeftCurlyBracketKeyword_6()); } | ||
3343 | |||
3344 | '{' | ||
3345 | |||
3346 | { after(grammarAccess.getALSRelationDefinitionAccess().getLeftCurlyBracketKeyword_6()); } | ||
3347 | ) | ||
3348 | |||
3349 | ; | ||
3350 | finally { | ||
3351 | restoreStackSize(stackSize); | ||
3352 | } | ||
3353 | |||
3354 | |||
3355 | rule__ALSRelationDefinition__Group__7 | ||
3356 | @init { | ||
3357 | int stackSize = keepStackSize(); | ||
3358 | } | ||
3359 | : | ||
3360 | rule__ALSRelationDefinition__Group__7__Impl | ||
3361 | rule__ALSRelationDefinition__Group__8 | ||
3362 | ; | ||
3363 | finally { | ||
3364 | restoreStackSize(stackSize); | ||
3365 | } | ||
3366 | |||
3367 | rule__ALSRelationDefinition__Group__7__Impl | ||
3368 | @init { | ||
3369 | int stackSize = keepStackSize(); | ||
3370 | } | ||
3371 | : | ||
3372 | ( | ||
3373 | { before(grammarAccess.getALSRelationDefinitionAccess().getValueAssignment_7()); } | ||
3374 | (rule__ALSRelationDefinition__ValueAssignment_7) | ||
3375 | { after(grammarAccess.getALSRelationDefinitionAccess().getValueAssignment_7()); } | ||
3376 | ) | ||
3377 | |||
3378 | ; | ||
3379 | finally { | ||
3380 | restoreStackSize(stackSize); | ||
3381 | } | ||
3382 | |||
3383 | |||
3384 | rule__ALSRelationDefinition__Group__8 | ||
3385 | @init { | ||
3386 | int stackSize = keepStackSize(); | ||
3387 | } | ||
3388 | : | ||
3389 | rule__ALSRelationDefinition__Group__8__Impl | ||
3390 | ; | ||
3391 | finally { | ||
3392 | restoreStackSize(stackSize); | ||
3393 | } | ||
3394 | |||
3395 | rule__ALSRelationDefinition__Group__8__Impl | ||
3396 | @init { | ||
3397 | int stackSize = keepStackSize(); | ||
3398 | } | ||
3399 | : | ||
3400 | ( | ||
3401 | { before(grammarAccess.getALSRelationDefinitionAccess().getRightCurlyBracketKeyword_8()); } | ||
3402 | |||
3403 | '}' | ||
3404 | |||
3405 | { after(grammarAccess.getALSRelationDefinitionAccess().getRightCurlyBracketKeyword_8()); } | ||
3406 | ) | ||
3407 | |||
3408 | ; | ||
3409 | finally { | ||
3410 | restoreStackSize(stackSize); | ||
3411 | } | ||
3412 | |||
3413 | |||
3414 | |||
3415 | |||
3416 | |||
3417 | |||
3418 | |||
3419 | |||
3420 | |||
3421 | |||
3422 | |||
3423 | |||
3424 | |||
3425 | |||
3426 | |||
3427 | |||
3428 | |||
3429 | |||
3430 | |||
3431 | |||
3432 | rule__ALSRelationDefinition__Group_4__0 | ||
3433 | @init { | ||
3434 | int stackSize = keepStackSize(); | ||
3435 | } | ||
3436 | : | ||
3437 | rule__ALSRelationDefinition__Group_4__0__Impl | ||
3438 | rule__ALSRelationDefinition__Group_4__1 | ||
3439 | ; | ||
3440 | finally { | ||
3441 | restoreStackSize(stackSize); | ||
3442 | } | ||
3443 | |||
3444 | rule__ALSRelationDefinition__Group_4__0__Impl | ||
3445 | @init { | ||
3446 | int stackSize = keepStackSize(); | ||
3447 | } | ||
3448 | : | ||
3449 | ( | ||
3450 | { before(grammarAccess.getALSRelationDefinitionAccess().getCommaKeyword_4_0()); } | ||
3451 | |||
3452 | ',' | ||
3453 | |||
3454 | { after(grammarAccess.getALSRelationDefinitionAccess().getCommaKeyword_4_0()); } | ||
3455 | ) | ||
3456 | |||
3457 | ; | ||
3458 | finally { | ||
3459 | restoreStackSize(stackSize); | ||
3460 | } | ||
3461 | |||
3462 | |||
3463 | rule__ALSRelationDefinition__Group_4__1 | ||
3464 | @init { | ||
3465 | int stackSize = keepStackSize(); | ||
3466 | } | ||
3467 | : | ||
3468 | rule__ALSRelationDefinition__Group_4__1__Impl | ||
3469 | ; | ||
3470 | finally { | ||
3471 | restoreStackSize(stackSize); | ||
3472 | } | ||
3473 | |||
3474 | rule__ALSRelationDefinition__Group_4__1__Impl | ||
3475 | @init { | ||
3476 | int stackSize = keepStackSize(); | ||
3477 | } | ||
3478 | : | ||
3479 | ( | ||
3480 | { before(grammarAccess.getALSRelationDefinitionAccess().getVariablesAssignment_4_1()); } | ||
3481 | (rule__ALSRelationDefinition__VariablesAssignment_4_1) | ||
3482 | { after(grammarAccess.getALSRelationDefinitionAccess().getVariablesAssignment_4_1()); } | ||
3483 | ) | ||
3484 | |||
3485 | ; | ||
3486 | finally { | ||
3487 | restoreStackSize(stackSize); | ||
3488 | } | ||
3489 | |||
3490 | |||
3491 | |||
3492 | |||
3493 | |||
3494 | |||
3495 | rule__ALSFactDeclaration__Group__0 | ||
3496 | @init { | ||
3497 | int stackSize = keepStackSize(); | ||
3498 | } | ||
3499 | : | ||
3500 | rule__ALSFactDeclaration__Group__0__Impl | ||
3501 | rule__ALSFactDeclaration__Group__1 | ||
3502 | ; | ||
3503 | finally { | ||
3504 | restoreStackSize(stackSize); | ||
3505 | } | ||
3506 | |||
3507 | rule__ALSFactDeclaration__Group__0__Impl | ||
3508 | @init { | ||
3509 | int stackSize = keepStackSize(); | ||
3510 | } | ||
3511 | : | ||
3512 | ( | ||
3513 | { before(grammarAccess.getALSFactDeclarationAccess().getALSFactDeclarationAction_0()); } | ||
3514 | ( | ||
3515 | |||
3516 | ) | ||
3517 | { after(grammarAccess.getALSFactDeclarationAccess().getALSFactDeclarationAction_0()); } | ||
3518 | ) | ||
3519 | |||
3520 | ; | ||
3521 | finally { | ||
3522 | restoreStackSize(stackSize); | ||
3523 | } | ||
3524 | |||
3525 | |||
3526 | rule__ALSFactDeclaration__Group__1 | ||
3527 | @init { | ||
3528 | int stackSize = keepStackSize(); | ||
3529 | } | ||
3530 | : | ||
3531 | rule__ALSFactDeclaration__Group__1__Impl | ||
3532 | rule__ALSFactDeclaration__Group__2 | ||
3533 | ; | ||
3534 | finally { | ||
3535 | restoreStackSize(stackSize); | ||
3536 | } | ||
3537 | |||
3538 | rule__ALSFactDeclaration__Group__1__Impl | ||
3539 | @init { | ||
3540 | int stackSize = keepStackSize(); | ||
3541 | } | ||
3542 | : | ||
3543 | ( | ||
3544 | { before(grammarAccess.getALSFactDeclarationAccess().getFactKeyword_1()); } | ||
3545 | |||
3546 | 'fact' | ||
3547 | |||
3548 | { after(grammarAccess.getALSFactDeclarationAccess().getFactKeyword_1()); } | ||
3549 | ) | ||
3550 | |||
3551 | ; | ||
3552 | finally { | ||
3553 | restoreStackSize(stackSize); | ||
3554 | } | ||
3555 | |||
3556 | |||
3557 | rule__ALSFactDeclaration__Group__2 | ||
3558 | @init { | ||
3559 | int stackSize = keepStackSize(); | ||
3560 | } | ||
3561 | : | ||
3562 | rule__ALSFactDeclaration__Group__2__Impl | ||
3563 | rule__ALSFactDeclaration__Group__3 | ||
3564 | ; | ||
3565 | finally { | ||
3566 | restoreStackSize(stackSize); | ||
3567 | } | ||
3568 | |||
3569 | rule__ALSFactDeclaration__Group__2__Impl | ||
3570 | @init { | ||
3571 | int stackSize = keepStackSize(); | ||
3572 | } | ||
3573 | : | ||
3574 | ( | ||
3575 | { before(grammarAccess.getALSFactDeclarationAccess().getNameAssignment_2()); } | ||
3576 | (rule__ALSFactDeclaration__NameAssignment_2)? | ||
3577 | { after(grammarAccess.getALSFactDeclarationAccess().getNameAssignment_2()); } | ||
3578 | ) | ||
3579 | |||
3580 | ; | ||
3581 | finally { | ||
3582 | restoreStackSize(stackSize); | ||
3583 | } | ||
3584 | |||
3585 | |||
3586 | rule__ALSFactDeclaration__Group__3 | ||
3587 | @init { | ||
3588 | int stackSize = keepStackSize(); | ||
3589 | } | ||
3590 | : | ||
3591 | rule__ALSFactDeclaration__Group__3__Impl | ||
3592 | rule__ALSFactDeclaration__Group__4 | ||
3593 | ; | ||
3594 | finally { | ||
3595 | restoreStackSize(stackSize); | ||
3596 | } | ||
3597 | |||
3598 | rule__ALSFactDeclaration__Group__3__Impl | ||
3599 | @init { | ||
3600 | int stackSize = keepStackSize(); | ||
3601 | } | ||
3602 | : | ||
3603 | ( | ||
3604 | { before(grammarAccess.getALSFactDeclarationAccess().getLeftCurlyBracketKeyword_3()); } | ||
3605 | |||
3606 | '{' | ||
3607 | |||
3608 | { after(grammarAccess.getALSFactDeclarationAccess().getLeftCurlyBracketKeyword_3()); } | ||
3609 | ) | ||
3610 | |||
3611 | ; | ||
3612 | finally { | ||
3613 | restoreStackSize(stackSize); | ||
3614 | } | ||
3615 | |||
3616 | |||
3617 | rule__ALSFactDeclaration__Group__4 | ||
3618 | @init { | ||
3619 | int stackSize = keepStackSize(); | ||
3620 | } | ||
3621 | : | ||
3622 | rule__ALSFactDeclaration__Group__4__Impl | ||
3623 | rule__ALSFactDeclaration__Group__5 | ||
3624 | ; | ||
3625 | finally { | ||
3626 | restoreStackSize(stackSize); | ||
3627 | } | ||
3628 | |||
3629 | rule__ALSFactDeclaration__Group__4__Impl | ||
3630 | @init { | ||
3631 | int stackSize = keepStackSize(); | ||
3632 | } | ||
3633 | : | ||
3634 | ( | ||
3635 | { before(grammarAccess.getALSFactDeclarationAccess().getTermAssignment_4()); } | ||
3636 | (rule__ALSFactDeclaration__TermAssignment_4) | ||
3637 | { after(grammarAccess.getALSFactDeclarationAccess().getTermAssignment_4()); } | ||
3638 | ) | ||
3639 | |||
3640 | ; | ||
3641 | finally { | ||
3642 | restoreStackSize(stackSize); | ||
3643 | } | ||
3644 | |||
3645 | |||
3646 | rule__ALSFactDeclaration__Group__5 | ||
3647 | @init { | ||
3648 | int stackSize = keepStackSize(); | ||
3649 | } | ||
3650 | : | ||
3651 | rule__ALSFactDeclaration__Group__5__Impl | ||
3652 | ; | ||
3653 | finally { | ||
3654 | restoreStackSize(stackSize); | ||
3655 | } | ||
3656 | |||
3657 | rule__ALSFactDeclaration__Group__5__Impl | ||
3658 | @init { | ||
3659 | int stackSize = keepStackSize(); | ||
3660 | } | ||
3661 | : | ||
3662 | ( | ||
3663 | { before(grammarAccess.getALSFactDeclarationAccess().getRightCurlyBracketKeyword_5()); } | ||
3664 | |||
3665 | '}' | ||
3666 | |||
3667 | { after(grammarAccess.getALSFactDeclarationAccess().getRightCurlyBracketKeyword_5()); } | ||
3668 | ) | ||
3669 | |||
3670 | ; | ||
3671 | finally { | ||
3672 | restoreStackSize(stackSize); | ||
3673 | } | ||
3674 | |||
3675 | |||
3676 | |||
3677 | |||
3678 | |||
3679 | |||
3680 | |||
3681 | |||
3682 | |||
3683 | |||
3684 | |||
3685 | |||
3686 | |||
3687 | |||
3688 | rule__ALSQuantified__Group_0__0 | ||
3689 | @init { | ||
3690 | int stackSize = keepStackSize(); | ||
3691 | } | ||
3692 | : | ||
3693 | rule__ALSQuantified__Group_0__0__Impl | ||
3694 | rule__ALSQuantified__Group_0__1 | ||
3695 | ; | ||
3696 | finally { | ||
3697 | restoreStackSize(stackSize); | ||
3698 | } | ||
3699 | |||
3700 | rule__ALSQuantified__Group_0__0__Impl | ||
3701 | @init { | ||
3702 | int stackSize = keepStackSize(); | ||
3703 | } | ||
3704 | : | ||
3705 | ( | ||
3706 | { before(grammarAccess.getALSQuantifiedAccess().getALSQuantifiedExAction_0_0()); } | ||
3707 | ( | ||
3708 | |||
3709 | ) | ||
3710 | { after(grammarAccess.getALSQuantifiedAccess().getALSQuantifiedExAction_0_0()); } | ||
3711 | ) | ||
3712 | |||
3713 | ; | ||
3714 | finally { | ||
3715 | restoreStackSize(stackSize); | ||
3716 | } | ||
3717 | |||
3718 | |||
3719 | rule__ALSQuantified__Group_0__1 | ||
3720 | @init { | ||
3721 | int stackSize = keepStackSize(); | ||
3722 | } | ||
3723 | : | ||
3724 | rule__ALSQuantified__Group_0__1__Impl | ||
3725 | rule__ALSQuantified__Group_0__2 | ||
3726 | ; | ||
3727 | finally { | ||
3728 | restoreStackSize(stackSize); | ||
3729 | } | ||
3730 | |||
3731 | rule__ALSQuantified__Group_0__1__Impl | ||
3732 | @init { | ||
3733 | int stackSize = keepStackSize(); | ||
3734 | } | ||
3735 | : | ||
3736 | ( | ||
3737 | { before(grammarAccess.getALSQuantifiedAccess().getTypeAssignment_0_1()); } | ||
3738 | (rule__ALSQuantified__TypeAssignment_0_1) | ||
3739 | { after(grammarAccess.getALSQuantifiedAccess().getTypeAssignment_0_1()); } | ||
3740 | ) | ||
3741 | |||
3742 | ; | ||
3743 | finally { | ||
3744 | restoreStackSize(stackSize); | ||
3745 | } | ||
3746 | |||
3747 | |||
3748 | rule__ALSQuantified__Group_0__2 | ||
3749 | @init { | ||
3750 | int stackSize = keepStackSize(); | ||
3751 | } | ||
3752 | : | ||
3753 | rule__ALSQuantified__Group_0__2__Impl | ||
3754 | rule__ALSQuantified__Group_0__3 | ||
3755 | ; | ||
3756 | finally { | ||
3757 | restoreStackSize(stackSize); | ||
3758 | } | ||
3759 | |||
3760 | rule__ALSQuantified__Group_0__2__Impl | ||
3761 | @init { | ||
3762 | int stackSize = keepStackSize(); | ||
3763 | } | ||
3764 | : | ||
3765 | ( | ||
3766 | { before(grammarAccess.getALSQuantifiedAccess().getDisjAssignment_0_2()); } | ||
3767 | (rule__ALSQuantified__DisjAssignment_0_2)? | ||
3768 | { after(grammarAccess.getALSQuantifiedAccess().getDisjAssignment_0_2()); } | ||
3769 | ) | ||
3770 | |||
3771 | ; | ||
3772 | finally { | ||
3773 | restoreStackSize(stackSize); | ||
3774 | } | ||
3775 | |||
3776 | |||
3777 | rule__ALSQuantified__Group_0__3 | ||
3778 | @init { | ||
3779 | int stackSize = keepStackSize(); | ||
3780 | } | ||
3781 | : | ||
3782 | rule__ALSQuantified__Group_0__3__Impl | ||
3783 | rule__ALSQuantified__Group_0__4 | ||
3784 | ; | ||
3785 | finally { | ||
3786 | restoreStackSize(stackSize); | ||
3787 | } | ||
3788 | |||
3789 | rule__ALSQuantified__Group_0__3__Impl | ||
3790 | @init { | ||
3791 | int stackSize = keepStackSize(); | ||
3792 | } | ||
3793 | : | ||
3794 | ( | ||
3795 | { before(grammarAccess.getALSQuantifiedAccess().getVariablesAssignment_0_3()); } | ||
3796 | (rule__ALSQuantified__VariablesAssignment_0_3) | ||
3797 | { after(grammarAccess.getALSQuantifiedAccess().getVariablesAssignment_0_3()); } | ||
3798 | ) | ||
3799 | |||
3800 | ; | ||
3801 | finally { | ||
3802 | restoreStackSize(stackSize); | ||
3803 | } | ||
3804 | |||
3805 | |||
3806 | rule__ALSQuantified__Group_0__4 | ||
3807 | @init { | ||
3808 | int stackSize = keepStackSize(); | ||
3809 | } | ||
3810 | : | ||
3811 | rule__ALSQuantified__Group_0__4__Impl | ||
3812 | rule__ALSQuantified__Group_0__5 | ||
3813 | ; | ||
3814 | finally { | ||
3815 | restoreStackSize(stackSize); | ||
3816 | } | ||
3817 | |||
3818 | rule__ALSQuantified__Group_0__4__Impl | ||
3819 | @init { | ||
3820 | int stackSize = keepStackSize(); | ||
3821 | } | ||
3822 | : | ||
3823 | ( | ||
3824 | { before(grammarAccess.getALSQuantifiedAccess().getGroup_0_4()); } | ||
3825 | (rule__ALSQuantified__Group_0_4__0)* | ||
3826 | { after(grammarAccess.getALSQuantifiedAccess().getGroup_0_4()); } | ||
3827 | ) | ||
3828 | |||
3829 | ; | ||
3830 | finally { | ||
3831 | restoreStackSize(stackSize); | ||
3832 | } | ||
3833 | |||
3834 | |||
3835 | rule__ALSQuantified__Group_0__5 | ||
3836 | @init { | ||
3837 | int stackSize = keepStackSize(); | ||
3838 | } | ||
3839 | : | ||
3840 | rule__ALSQuantified__Group_0__5__Impl | ||
3841 | rule__ALSQuantified__Group_0__6 | ||
3842 | ; | ||
3843 | finally { | ||
3844 | restoreStackSize(stackSize); | ||
3845 | } | ||
3846 | |||
3847 | rule__ALSQuantified__Group_0__5__Impl | ||
3848 | @init { | ||
3849 | int stackSize = keepStackSize(); | ||
3850 | } | ||
3851 | : | ||
3852 | ( | ||
3853 | { before(grammarAccess.getALSQuantifiedAccess().getLeftCurlyBracketKeyword_0_5()); } | ||
3854 | |||
3855 | '{' | ||
3856 | |||
3857 | { after(grammarAccess.getALSQuantifiedAccess().getLeftCurlyBracketKeyword_0_5()); } | ||
3858 | ) | ||
3859 | |||
3860 | ; | ||
3861 | finally { | ||
3862 | restoreStackSize(stackSize); | ||
3863 | } | ||
3864 | |||
3865 | |||
3866 | rule__ALSQuantified__Group_0__6 | ||
3867 | @init { | ||
3868 | int stackSize = keepStackSize(); | ||
3869 | } | ||
3870 | : | ||
3871 | rule__ALSQuantified__Group_0__6__Impl | ||
3872 | rule__ALSQuantified__Group_0__7 | ||
3873 | ; | ||
3874 | finally { | ||
3875 | restoreStackSize(stackSize); | ||
3876 | } | ||
3877 | |||
3878 | rule__ALSQuantified__Group_0__6__Impl | ||
3879 | @init { | ||
3880 | int stackSize = keepStackSize(); | ||
3881 | } | ||
3882 | : | ||
3883 | ( | ||
3884 | { before(grammarAccess.getALSQuantifiedAccess().getExpressionAssignment_0_6()); } | ||
3885 | (rule__ALSQuantified__ExpressionAssignment_0_6) | ||
3886 | { after(grammarAccess.getALSQuantifiedAccess().getExpressionAssignment_0_6()); } | ||
3887 | ) | ||
3888 | |||
3889 | ; | ||
3890 | finally { | ||
3891 | restoreStackSize(stackSize); | ||
3892 | } | ||
3893 | |||
3894 | |||
3895 | rule__ALSQuantified__Group_0__7 | ||
3896 | @init { | ||
3897 | int stackSize = keepStackSize(); | ||
3898 | } | ||
3899 | : | ||
3900 | rule__ALSQuantified__Group_0__7__Impl | ||
3901 | ; | ||
3902 | finally { | ||
3903 | restoreStackSize(stackSize); | ||
3904 | } | ||
3905 | |||
3906 | rule__ALSQuantified__Group_0__7__Impl | ||
3907 | @init { | ||
3908 | int stackSize = keepStackSize(); | ||
3909 | } | ||
3910 | : | ||
3911 | ( | ||
3912 | { before(grammarAccess.getALSQuantifiedAccess().getRightCurlyBracketKeyword_0_7()); } | ||
3913 | |||
3914 | '}' | ||
3915 | |||
3916 | { after(grammarAccess.getALSQuantifiedAccess().getRightCurlyBracketKeyword_0_7()); } | ||
3917 | ) | ||
3918 | |||
3919 | ; | ||
3920 | finally { | ||
3921 | restoreStackSize(stackSize); | ||
3922 | } | ||
3923 | |||
3924 | |||
3925 | |||
3926 | |||
3927 | |||
3928 | |||
3929 | |||
3930 | |||
3931 | |||
3932 | |||
3933 | |||
3934 | |||
3935 | |||
3936 | |||
3937 | |||
3938 | |||
3939 | |||
3940 | |||
3941 | rule__ALSQuantified__Group_0_4__0 | ||
3942 | @init { | ||
3943 | int stackSize = keepStackSize(); | ||
3944 | } | ||
3945 | : | ||
3946 | rule__ALSQuantified__Group_0_4__0__Impl | ||
3947 | rule__ALSQuantified__Group_0_4__1 | ||
3948 | ; | ||
3949 | finally { | ||
3950 | restoreStackSize(stackSize); | ||
3951 | } | ||
3952 | |||
3953 | rule__ALSQuantified__Group_0_4__0__Impl | ||
3954 | @init { | ||
3955 | int stackSize = keepStackSize(); | ||
3956 | } | ||
3957 | : | ||
3958 | ( | ||
3959 | { before(grammarAccess.getALSQuantifiedAccess().getCommaKeyword_0_4_0()); } | ||
3960 | |||
3961 | ',' | ||
3962 | |||
3963 | { after(grammarAccess.getALSQuantifiedAccess().getCommaKeyword_0_4_0()); } | ||
3964 | ) | ||
3965 | |||
3966 | ; | ||
3967 | finally { | ||
3968 | restoreStackSize(stackSize); | ||
3969 | } | ||
3970 | |||
3971 | |||
3972 | rule__ALSQuantified__Group_0_4__1 | ||
3973 | @init { | ||
3974 | int stackSize = keepStackSize(); | ||
3975 | } | ||
3976 | : | ||
3977 | rule__ALSQuantified__Group_0_4__1__Impl | ||
3978 | ; | ||
3979 | finally { | ||
3980 | restoreStackSize(stackSize); | ||
3981 | } | ||
3982 | |||
3983 | rule__ALSQuantified__Group_0_4__1__Impl | ||
3984 | @init { | ||
3985 | int stackSize = keepStackSize(); | ||
3986 | } | ||
3987 | : | ||
3988 | ( | ||
3989 | { before(grammarAccess.getALSQuantifiedAccess().getVariablesAssignment_0_4_1()); } | ||
3990 | (rule__ALSQuantified__VariablesAssignment_0_4_1) | ||
3991 | { after(grammarAccess.getALSQuantifiedAccess().getVariablesAssignment_0_4_1()); } | ||
3992 | ) | ||
3993 | |||
3994 | ; | ||
3995 | finally { | ||
3996 | restoreStackSize(stackSize); | ||
3997 | } | ||
3998 | |||
3999 | |||
4000 | |||
4001 | |||
4002 | |||
4003 | |||
4004 | rule__ALSOr__Group__0 | ||
4005 | @init { | ||
4006 | int stackSize = keepStackSize(); | ||
4007 | } | ||
4008 | : | ||
4009 | rule__ALSOr__Group__0__Impl | ||
4010 | rule__ALSOr__Group__1 | ||
4011 | ; | ||
4012 | finally { | ||
4013 | restoreStackSize(stackSize); | ||
4014 | } | ||
4015 | |||
4016 | rule__ALSOr__Group__0__Impl | ||
4017 | @init { | ||
4018 | int stackSize = keepStackSize(); | ||
4019 | } | ||
4020 | : | ||
4021 | ( | ||
4022 | { before(grammarAccess.getALSOrAccess().getALSIffParserRuleCall_0()); } | ||
4023 | ruleALSIff | ||
4024 | { after(grammarAccess.getALSOrAccess().getALSIffParserRuleCall_0()); } | ||
4025 | ) | ||
4026 | |||
4027 | ; | ||
4028 | finally { | ||
4029 | restoreStackSize(stackSize); | ||
4030 | } | ||
4031 | |||
4032 | |||
4033 | rule__ALSOr__Group__1 | ||
4034 | @init { | ||
4035 | int stackSize = keepStackSize(); | ||
4036 | } | ||
4037 | : | ||
4038 | rule__ALSOr__Group__1__Impl | ||
4039 | ; | ||
4040 | finally { | ||
4041 | restoreStackSize(stackSize); | ||
4042 | } | ||
4043 | |||
4044 | rule__ALSOr__Group__1__Impl | ||
4045 | @init { | ||
4046 | int stackSize = keepStackSize(); | ||
4047 | } | ||
4048 | : | ||
4049 | ( | ||
4050 | { before(grammarAccess.getALSOrAccess().getGroup_1()); } | ||
4051 | (rule__ALSOr__Group_1__0)? | ||
4052 | { after(grammarAccess.getALSOrAccess().getGroup_1()); } | ||
4053 | ) | ||
4054 | |||
4055 | ; | ||
4056 | finally { | ||
4057 | restoreStackSize(stackSize); | ||
4058 | } | ||
4059 | |||
4060 | |||
4061 | |||
4062 | |||
4063 | |||
4064 | |||
4065 | rule__ALSOr__Group_1__0 | ||
4066 | @init { | ||
4067 | int stackSize = keepStackSize(); | ||
4068 | } | ||
4069 | : | ||
4070 | rule__ALSOr__Group_1__0__Impl | ||
4071 | rule__ALSOr__Group_1__1 | ||
4072 | ; | ||
4073 | finally { | ||
4074 | restoreStackSize(stackSize); | ||
4075 | } | ||
4076 | |||
4077 | rule__ALSOr__Group_1__0__Impl | ||
4078 | @init { | ||
4079 | int stackSize = keepStackSize(); | ||
4080 | } | ||
4081 | : | ||
4082 | ( | ||
4083 | { before(grammarAccess.getALSOrAccess().getALSOrLeftOperandAction_1_0()); } | ||
4084 | ( | ||
4085 | |||
4086 | ) | ||
4087 | { after(grammarAccess.getALSOrAccess().getALSOrLeftOperandAction_1_0()); } | ||
4088 | ) | ||
4089 | |||
4090 | ; | ||
4091 | finally { | ||
4092 | restoreStackSize(stackSize); | ||
4093 | } | ||
4094 | |||
4095 | |||
4096 | rule__ALSOr__Group_1__1 | ||
4097 | @init { | ||
4098 | int stackSize = keepStackSize(); | ||
4099 | } | ||
4100 | : | ||
4101 | rule__ALSOr__Group_1__1__Impl | ||
4102 | rule__ALSOr__Group_1__2 | ||
4103 | ; | ||
4104 | finally { | ||
4105 | restoreStackSize(stackSize); | ||
4106 | } | ||
4107 | |||
4108 | rule__ALSOr__Group_1__1__Impl | ||
4109 | @init { | ||
4110 | int stackSize = keepStackSize(); | ||
4111 | } | ||
4112 | : | ||
4113 | ( | ||
4114 | { before(grammarAccess.getALSOrAccess().getAlternatives_1_1()); } | ||
4115 | (rule__ALSOr__Alternatives_1_1) | ||
4116 | { after(grammarAccess.getALSOrAccess().getAlternatives_1_1()); } | ||
4117 | ) | ||
4118 | |||
4119 | ; | ||
4120 | finally { | ||
4121 | restoreStackSize(stackSize); | ||
4122 | } | ||
4123 | |||
4124 | |||
4125 | rule__ALSOr__Group_1__2 | ||
4126 | @init { | ||
4127 | int stackSize = keepStackSize(); | ||
4128 | } | ||
4129 | : | ||
4130 | rule__ALSOr__Group_1__2__Impl | ||
4131 | ; | ||
4132 | finally { | ||
4133 | restoreStackSize(stackSize); | ||
4134 | } | ||
4135 | |||
4136 | rule__ALSOr__Group_1__2__Impl | ||
4137 | @init { | ||
4138 | int stackSize = keepStackSize(); | ||
4139 | } | ||
4140 | : | ||
4141 | ( | ||
4142 | { before(grammarAccess.getALSOrAccess().getRightOperandAssignment_1_2()); } | ||
4143 | (rule__ALSOr__RightOperandAssignment_1_2) | ||
4144 | { after(grammarAccess.getALSOrAccess().getRightOperandAssignment_1_2()); } | ||
4145 | ) | ||
4146 | |||
4147 | ; | ||
4148 | finally { | ||
4149 | restoreStackSize(stackSize); | ||
4150 | } | ||
4151 | |||
4152 | |||
4153 | |||
4154 | |||
4155 | |||
4156 | |||
4157 | |||
4158 | |||
4159 | rule__ALSIff__Group__0 | ||
4160 | @init { | ||
4161 | int stackSize = keepStackSize(); | ||
4162 | } | ||
4163 | : | ||
4164 | rule__ALSIff__Group__0__Impl | ||
4165 | rule__ALSIff__Group__1 | ||
4166 | ; | ||
4167 | finally { | ||
4168 | restoreStackSize(stackSize); | ||
4169 | } | ||
4170 | |||
4171 | rule__ALSIff__Group__0__Impl | ||
4172 | @init { | ||
4173 | int stackSize = keepStackSize(); | ||
4174 | } | ||
4175 | : | ||
4176 | ( | ||
4177 | { before(grammarAccess.getALSIffAccess().getALSImplParserRuleCall_0()); } | ||
4178 | ruleALSImpl | ||
4179 | { after(grammarAccess.getALSIffAccess().getALSImplParserRuleCall_0()); } | ||
4180 | ) | ||
4181 | |||
4182 | ; | ||
4183 | finally { | ||
4184 | restoreStackSize(stackSize); | ||
4185 | } | ||
4186 | |||
4187 | |||
4188 | rule__ALSIff__Group__1 | ||
4189 | @init { | ||
4190 | int stackSize = keepStackSize(); | ||
4191 | } | ||
4192 | : | ||
4193 | rule__ALSIff__Group__1__Impl | ||
4194 | ; | ||
4195 | finally { | ||
4196 | restoreStackSize(stackSize); | ||
4197 | } | ||
4198 | |||
4199 | rule__ALSIff__Group__1__Impl | ||
4200 | @init { | ||
4201 | int stackSize = keepStackSize(); | ||
4202 | } | ||
4203 | : | ||
4204 | ( | ||
4205 | { before(grammarAccess.getALSIffAccess().getGroup_1()); } | ||
4206 | (rule__ALSIff__Group_1__0)? | ||
4207 | { after(grammarAccess.getALSIffAccess().getGroup_1()); } | ||
4208 | ) | ||
4209 | |||
4210 | ; | ||
4211 | finally { | ||
4212 | restoreStackSize(stackSize); | ||
4213 | } | ||
4214 | |||
4215 | |||
4216 | |||
4217 | |||
4218 | |||
4219 | |||
4220 | rule__ALSIff__Group_1__0 | ||
4221 | @init { | ||
4222 | int stackSize = keepStackSize(); | ||
4223 | } | ||
4224 | : | ||
4225 | rule__ALSIff__Group_1__0__Impl | ||
4226 | rule__ALSIff__Group_1__1 | ||
4227 | ; | ||
4228 | finally { | ||
4229 | restoreStackSize(stackSize); | ||
4230 | } | ||
4231 | |||
4232 | rule__ALSIff__Group_1__0__Impl | ||
4233 | @init { | ||
4234 | int stackSize = keepStackSize(); | ||
4235 | } | ||
4236 | : | ||
4237 | ( | ||
4238 | { before(grammarAccess.getALSIffAccess().getALSIffLeftOperandAction_1_0()); } | ||
4239 | ( | ||
4240 | |||
4241 | ) | ||
4242 | { after(grammarAccess.getALSIffAccess().getALSIffLeftOperandAction_1_0()); } | ||
4243 | ) | ||
4244 | |||
4245 | ; | ||
4246 | finally { | ||
4247 | restoreStackSize(stackSize); | ||
4248 | } | ||
4249 | |||
4250 | |||
4251 | rule__ALSIff__Group_1__1 | ||
4252 | @init { | ||
4253 | int stackSize = keepStackSize(); | ||
4254 | } | ||
4255 | : | ||
4256 | rule__ALSIff__Group_1__1__Impl | ||
4257 | rule__ALSIff__Group_1__2 | ||
4258 | ; | ||
4259 | finally { | ||
4260 | restoreStackSize(stackSize); | ||
4261 | } | ||
4262 | |||
4263 | rule__ALSIff__Group_1__1__Impl | ||
4264 | @init { | ||
4265 | int stackSize = keepStackSize(); | ||
4266 | } | ||
4267 | : | ||
4268 | ( | ||
4269 | { before(grammarAccess.getALSIffAccess().getAlternatives_1_1()); } | ||
4270 | (rule__ALSIff__Alternatives_1_1) | ||
4271 | { after(grammarAccess.getALSIffAccess().getAlternatives_1_1()); } | ||
4272 | ) | ||
4273 | |||
4274 | ; | ||
4275 | finally { | ||
4276 | restoreStackSize(stackSize); | ||
4277 | } | ||
4278 | |||
4279 | |||
4280 | rule__ALSIff__Group_1__2 | ||
4281 | @init { | ||
4282 | int stackSize = keepStackSize(); | ||
4283 | } | ||
4284 | : | ||
4285 | rule__ALSIff__Group_1__2__Impl | ||
4286 | ; | ||
4287 | finally { | ||
4288 | restoreStackSize(stackSize); | ||
4289 | } | ||
4290 | |||
4291 | rule__ALSIff__Group_1__2__Impl | ||
4292 | @init { | ||
4293 | int stackSize = keepStackSize(); | ||
4294 | } | ||
4295 | : | ||
4296 | ( | ||
4297 | { before(grammarAccess.getALSIffAccess().getRightOperandAssignment_1_2()); } | ||
4298 | (rule__ALSIff__RightOperandAssignment_1_2) | ||
4299 | { after(grammarAccess.getALSIffAccess().getRightOperandAssignment_1_2()); } | ||
4300 | ) | ||
4301 | |||
4302 | ; | ||
4303 | finally { | ||
4304 | restoreStackSize(stackSize); | ||
4305 | } | ||
4306 | |||
4307 | |||
4308 | |||
4309 | |||
4310 | |||
4311 | |||
4312 | |||
4313 | |||
4314 | rule__ALSImpl__Group__0 | ||
4315 | @init { | ||
4316 | int stackSize = keepStackSize(); | ||
4317 | } | ||
4318 | : | ||
4319 | rule__ALSImpl__Group__0__Impl | ||
4320 | rule__ALSImpl__Group__1 | ||
4321 | ; | ||
4322 | finally { | ||
4323 | restoreStackSize(stackSize); | ||
4324 | } | ||
4325 | |||
4326 | rule__ALSImpl__Group__0__Impl | ||
4327 | @init { | ||
4328 | int stackSize = keepStackSize(); | ||
4329 | } | ||
4330 | : | ||
4331 | ( | ||
4332 | { before(grammarAccess.getALSImplAccess().getALSAndParserRuleCall_0()); } | ||
4333 | ruleALSAnd | ||
4334 | { after(grammarAccess.getALSImplAccess().getALSAndParserRuleCall_0()); } | ||
4335 | ) | ||
4336 | |||
4337 | ; | ||
4338 | finally { | ||
4339 | restoreStackSize(stackSize); | ||
4340 | } | ||
4341 | |||
4342 | |||
4343 | rule__ALSImpl__Group__1 | ||
4344 | @init { | ||
4345 | int stackSize = keepStackSize(); | ||
4346 | } | ||
4347 | : | ||
4348 | rule__ALSImpl__Group__1__Impl | ||
4349 | ; | ||
4350 | finally { | ||
4351 | restoreStackSize(stackSize); | ||
4352 | } | ||
4353 | |||
4354 | rule__ALSImpl__Group__1__Impl | ||
4355 | @init { | ||
4356 | int stackSize = keepStackSize(); | ||
4357 | } | ||
4358 | : | ||
4359 | ( | ||
4360 | { before(grammarAccess.getALSImplAccess().getGroup_1()); } | ||
4361 | (rule__ALSImpl__Group_1__0)? | ||
4362 | { after(grammarAccess.getALSImplAccess().getGroup_1()); } | ||
4363 | ) | ||
4364 | |||
4365 | ; | ||
4366 | finally { | ||
4367 | restoreStackSize(stackSize); | ||
4368 | } | ||
4369 | |||
4370 | |||
4371 | |||
4372 | |||
4373 | |||
4374 | |||
4375 | rule__ALSImpl__Group_1__0 | ||
4376 | @init { | ||
4377 | int stackSize = keepStackSize(); | ||
4378 | } | ||
4379 | : | ||
4380 | rule__ALSImpl__Group_1__0__Impl | ||
4381 | rule__ALSImpl__Group_1__1 | ||
4382 | ; | ||
4383 | finally { | ||
4384 | restoreStackSize(stackSize); | ||
4385 | } | ||
4386 | |||
4387 | rule__ALSImpl__Group_1__0__Impl | ||
4388 | @init { | ||
4389 | int stackSize = keepStackSize(); | ||
4390 | } | ||
4391 | : | ||
4392 | ( | ||
4393 | { before(grammarAccess.getALSImplAccess().getALSImplLeftOperandAction_1_0()); } | ||
4394 | ( | ||
4395 | |||
4396 | ) | ||
4397 | { after(grammarAccess.getALSImplAccess().getALSImplLeftOperandAction_1_0()); } | ||
4398 | ) | ||
4399 | |||
4400 | ; | ||
4401 | finally { | ||
4402 | restoreStackSize(stackSize); | ||
4403 | } | ||
4404 | |||
4405 | |||
4406 | rule__ALSImpl__Group_1__1 | ||
4407 | @init { | ||
4408 | int stackSize = keepStackSize(); | ||
4409 | } | ||
4410 | : | ||
4411 | rule__ALSImpl__Group_1__1__Impl | ||
4412 | rule__ALSImpl__Group_1__2 | ||
4413 | ; | ||
4414 | finally { | ||
4415 | restoreStackSize(stackSize); | ||
4416 | } | ||
4417 | |||
4418 | rule__ALSImpl__Group_1__1__Impl | ||
4419 | @init { | ||
4420 | int stackSize = keepStackSize(); | ||
4421 | } | ||
4422 | : | ||
4423 | ( | ||
4424 | { before(grammarAccess.getALSImplAccess().getAlternatives_1_1()); } | ||
4425 | (rule__ALSImpl__Alternatives_1_1) | ||
4426 | { after(grammarAccess.getALSImplAccess().getAlternatives_1_1()); } | ||
4427 | ) | ||
4428 | |||
4429 | ; | ||
4430 | finally { | ||
4431 | restoreStackSize(stackSize); | ||
4432 | } | ||
4433 | |||
4434 | |||
4435 | rule__ALSImpl__Group_1__2 | ||
4436 | @init { | ||
4437 | int stackSize = keepStackSize(); | ||
4438 | } | ||
4439 | : | ||
4440 | rule__ALSImpl__Group_1__2__Impl | ||
4441 | rule__ALSImpl__Group_1__3 | ||
4442 | ; | ||
4443 | finally { | ||
4444 | restoreStackSize(stackSize); | ||
4445 | } | ||
4446 | |||
4447 | rule__ALSImpl__Group_1__2__Impl | ||
4448 | @init { | ||
4449 | int stackSize = keepStackSize(); | ||
4450 | } | ||
4451 | : | ||
4452 | ( | ||
4453 | { before(grammarAccess.getALSImplAccess().getRightOperandAssignment_1_2()); } | ||
4454 | (rule__ALSImpl__RightOperandAssignment_1_2) | ||
4455 | { after(grammarAccess.getALSImplAccess().getRightOperandAssignment_1_2()); } | ||
4456 | ) | ||
4457 | |||
4458 | ; | ||
4459 | finally { | ||
4460 | restoreStackSize(stackSize); | ||
4461 | } | ||
4462 | |||
4463 | |||
4464 | rule__ALSImpl__Group_1__3 | ||
4465 | @init { | ||
4466 | int stackSize = keepStackSize(); | ||
4467 | } | ||
4468 | : | ||
4469 | rule__ALSImpl__Group_1__3__Impl | ||
4470 | ; | ||
4471 | finally { | ||
4472 | restoreStackSize(stackSize); | ||
4473 | } | ||
4474 | |||
4475 | rule__ALSImpl__Group_1__3__Impl | ||
4476 | @init { | ||
4477 | int stackSize = keepStackSize(); | ||
4478 | } | ||
4479 | : | ||
4480 | ( | ||
4481 | { before(grammarAccess.getALSImplAccess().getGroup_1_3()); } | ||
4482 | (rule__ALSImpl__Group_1_3__0)? | ||
4483 | { after(grammarAccess.getALSImplAccess().getGroup_1_3()); } | ||
4484 | ) | ||
4485 | |||
4486 | ; | ||
4487 | finally { | ||
4488 | restoreStackSize(stackSize); | ||
4489 | } | ||
4490 | |||
4491 | |||
4492 | |||
4493 | |||
4494 | |||
4495 | |||
4496 | |||
4497 | |||
4498 | |||
4499 | |||
4500 | rule__ALSImpl__Group_1_3__0 | ||
4501 | @init { | ||
4502 | int stackSize = keepStackSize(); | ||
4503 | } | ||
4504 | : | ||
4505 | rule__ALSImpl__Group_1_3__0__Impl | ||
4506 | rule__ALSImpl__Group_1_3__1 | ||
4507 | ; | ||
4508 | finally { | ||
4509 | restoreStackSize(stackSize); | ||
4510 | } | ||
4511 | |||
4512 | rule__ALSImpl__Group_1_3__0__Impl | ||
4513 | @init { | ||
4514 | int stackSize = keepStackSize(); | ||
4515 | } | ||
4516 | : | ||
4517 | ( | ||
4518 | { before(grammarAccess.getALSImplAccess().getElseKeyword_1_3_0()); } | ||
4519 | |||
4520 | 'else' | ||
4521 | |||
4522 | { after(grammarAccess.getALSImplAccess().getElseKeyword_1_3_0()); } | ||
4523 | ) | ||
4524 | |||
4525 | ; | ||
4526 | finally { | ||
4527 | restoreStackSize(stackSize); | ||
4528 | } | ||
4529 | |||
4530 | |||
4531 | rule__ALSImpl__Group_1_3__1 | ||
4532 | @init { | ||
4533 | int stackSize = keepStackSize(); | ||
4534 | } | ||
4535 | : | ||
4536 | rule__ALSImpl__Group_1_3__1__Impl | ||
4537 | ; | ||
4538 | finally { | ||
4539 | restoreStackSize(stackSize); | ||
4540 | } | ||
4541 | |||
4542 | rule__ALSImpl__Group_1_3__1__Impl | ||
4543 | @init { | ||
4544 | int stackSize = keepStackSize(); | ||
4545 | } | ||
4546 | : | ||
4547 | ( | ||
4548 | { before(grammarAccess.getALSImplAccess().getElseOperandAssignment_1_3_1()); } | ||
4549 | (rule__ALSImpl__ElseOperandAssignment_1_3_1) | ||
4550 | { after(grammarAccess.getALSImplAccess().getElseOperandAssignment_1_3_1()); } | ||
4551 | ) | ||
4552 | |||
4553 | ; | ||
4554 | finally { | ||
4555 | restoreStackSize(stackSize); | ||
4556 | } | ||
4557 | |||
4558 | |||
4559 | |||
4560 | |||
4561 | |||
4562 | |||
4563 | rule__ALSAnd__Group__0 | ||
4564 | @init { | ||
4565 | int stackSize = keepStackSize(); | ||
4566 | } | ||
4567 | : | ||
4568 | rule__ALSAnd__Group__0__Impl | ||
4569 | rule__ALSAnd__Group__1 | ||
4570 | ; | ||
4571 | finally { | ||
4572 | restoreStackSize(stackSize); | ||
4573 | } | ||
4574 | |||
4575 | rule__ALSAnd__Group__0__Impl | ||
4576 | @init { | ||
4577 | int stackSize = keepStackSize(); | ||
4578 | } | ||
4579 | : | ||
4580 | ( | ||
4581 | { before(grammarAccess.getALSAndAccess().getALSComparisonParserRuleCall_0()); } | ||
4582 | ruleALSComparison | ||
4583 | { after(grammarAccess.getALSAndAccess().getALSComparisonParserRuleCall_0()); } | ||
4584 | ) | ||
4585 | |||
4586 | ; | ||
4587 | finally { | ||
4588 | restoreStackSize(stackSize); | ||
4589 | } | ||
4590 | |||
4591 | |||
4592 | rule__ALSAnd__Group__1 | ||
4593 | @init { | ||
4594 | int stackSize = keepStackSize(); | ||
4595 | } | ||
4596 | : | ||
4597 | rule__ALSAnd__Group__1__Impl | ||
4598 | ; | ||
4599 | finally { | ||
4600 | restoreStackSize(stackSize); | ||
4601 | } | ||
4602 | |||
4603 | rule__ALSAnd__Group__1__Impl | ||
4604 | @init { | ||
4605 | int stackSize = keepStackSize(); | ||
4606 | } | ||
4607 | : | ||
4608 | ( | ||
4609 | { before(grammarAccess.getALSAndAccess().getGroup_1()); } | ||
4610 | (rule__ALSAnd__Group_1__0)? | ||
4611 | { after(grammarAccess.getALSAndAccess().getGroup_1()); } | ||
4612 | ) | ||
4613 | |||
4614 | ; | ||
4615 | finally { | ||
4616 | restoreStackSize(stackSize); | ||
4617 | } | ||
4618 | |||
4619 | |||
4620 | |||
4621 | |||
4622 | |||
4623 | |||
4624 | rule__ALSAnd__Group_1__0 | ||
4625 | @init { | ||
4626 | int stackSize = keepStackSize(); | ||
4627 | } | ||
4628 | : | ||
4629 | rule__ALSAnd__Group_1__0__Impl | ||
4630 | rule__ALSAnd__Group_1__1 | ||
4631 | ; | ||
4632 | finally { | ||
4633 | restoreStackSize(stackSize); | ||
4634 | } | ||
4635 | |||
4636 | rule__ALSAnd__Group_1__0__Impl | ||
4637 | @init { | ||
4638 | int stackSize = keepStackSize(); | ||
4639 | } | ||
4640 | : | ||
4641 | ( | ||
4642 | { before(grammarAccess.getALSAndAccess().getALSAndLeftOperandAction_1_0()); } | ||
4643 | ( | ||
4644 | |||
4645 | ) | ||
4646 | { after(grammarAccess.getALSAndAccess().getALSAndLeftOperandAction_1_0()); } | ||
4647 | ) | ||
4648 | |||
4649 | ; | ||
4650 | finally { | ||
4651 | restoreStackSize(stackSize); | ||
4652 | } | ||
4653 | |||
4654 | |||
4655 | rule__ALSAnd__Group_1__1 | ||
4656 | @init { | ||
4657 | int stackSize = keepStackSize(); | ||
4658 | } | ||
4659 | : | ||
4660 | rule__ALSAnd__Group_1__1__Impl | ||
4661 | rule__ALSAnd__Group_1__2 | ||
4662 | ; | ||
4663 | finally { | ||
4664 | restoreStackSize(stackSize); | ||
4665 | } | ||
4666 | |||
4667 | rule__ALSAnd__Group_1__1__Impl | ||
4668 | @init { | ||
4669 | int stackSize = keepStackSize(); | ||
4670 | } | ||
4671 | : | ||
4672 | ( | ||
4673 | { before(grammarAccess.getALSAndAccess().getAlternatives_1_1()); } | ||
4674 | (rule__ALSAnd__Alternatives_1_1) | ||
4675 | { after(grammarAccess.getALSAndAccess().getAlternatives_1_1()); } | ||
4676 | ) | ||
4677 | |||
4678 | ; | ||
4679 | finally { | ||
4680 | restoreStackSize(stackSize); | ||
4681 | } | ||
4682 | |||
4683 | |||
4684 | rule__ALSAnd__Group_1__2 | ||
4685 | @init { | ||
4686 | int stackSize = keepStackSize(); | ||
4687 | } | ||
4688 | : | ||
4689 | rule__ALSAnd__Group_1__2__Impl | ||
4690 | ; | ||
4691 | finally { | ||
4692 | restoreStackSize(stackSize); | ||
4693 | } | ||
4694 | |||
4695 | rule__ALSAnd__Group_1__2__Impl | ||
4696 | @init { | ||
4697 | int stackSize = keepStackSize(); | ||
4698 | } | ||
4699 | : | ||
4700 | ( | ||
4701 | { before(grammarAccess.getALSAndAccess().getRightOperandAssignment_1_2()); } | ||
4702 | (rule__ALSAnd__RightOperandAssignment_1_2) | ||
4703 | { after(grammarAccess.getALSAndAccess().getRightOperandAssignment_1_2()); } | ||
4704 | ) | ||
4705 | |||
4706 | ; | ||
4707 | finally { | ||
4708 | restoreStackSize(stackSize); | ||
4709 | } | ||
4710 | |||
4711 | |||
4712 | |||
4713 | |||
4714 | |||
4715 | |||
4716 | |||
4717 | |||
4718 | rule__ALSComparison__Group__0 | ||
4719 | @init { | ||
4720 | int stackSize = keepStackSize(); | ||
4721 | } | ||
4722 | : | ||
4723 | rule__ALSComparison__Group__0__Impl | ||
4724 | rule__ALSComparison__Group__1 | ||
4725 | ; | ||
4726 | finally { | ||
4727 | restoreStackSize(stackSize); | ||
4728 | } | ||
4729 | |||
4730 | rule__ALSComparison__Group__0__Impl | ||
4731 | @init { | ||
4732 | int stackSize = keepStackSize(); | ||
4733 | } | ||
4734 | : | ||
4735 | ( | ||
4736 | { before(grammarAccess.getALSComparisonAccess().getALSOverrideParserRuleCall_0()); } | ||
4737 | ruleALSOverride | ||
4738 | { after(grammarAccess.getALSComparisonAccess().getALSOverrideParserRuleCall_0()); } | ||
4739 | ) | ||
4740 | |||
4741 | ; | ||
4742 | finally { | ||
4743 | restoreStackSize(stackSize); | ||
4744 | } | ||
4745 | |||
4746 | |||
4747 | rule__ALSComparison__Group__1 | ||
4748 | @init { | ||
4749 | int stackSize = keepStackSize(); | ||
4750 | } | ||
4751 | : | ||
4752 | rule__ALSComparison__Group__1__Impl | ||
4753 | ; | ||
4754 | finally { | ||
4755 | restoreStackSize(stackSize); | ||
4756 | } | ||
4757 | |||
4758 | rule__ALSComparison__Group__1__Impl | ||
4759 | @init { | ||
4760 | int stackSize = keepStackSize(); | ||
4761 | } | ||
4762 | : | ||
4763 | ( | ||
4764 | { before(grammarAccess.getALSComparisonAccess().getGroup_1()); } | ||
4765 | (rule__ALSComparison__Group_1__0)? | ||
4766 | { after(grammarAccess.getALSComparisonAccess().getGroup_1()); } | ||
4767 | ) | ||
4768 | |||
4769 | ; | ||
4770 | finally { | ||
4771 | restoreStackSize(stackSize); | ||
4772 | } | ||
4773 | |||
4774 | |||
4775 | |||
4776 | |||
4777 | |||
4778 | |||
4779 | rule__ALSComparison__Group_1__0 | ||
4780 | @init { | ||
4781 | int stackSize = keepStackSize(); | ||
4782 | } | ||
4783 | : | ||
4784 | rule__ALSComparison__Group_1__0__Impl | ||
4785 | rule__ALSComparison__Group_1__1 | ||
4786 | ; | ||
4787 | finally { | ||
4788 | restoreStackSize(stackSize); | ||
4789 | } | ||
4790 | |||
4791 | rule__ALSComparison__Group_1__0__Impl | ||
4792 | @init { | ||
4793 | int stackSize = keepStackSize(); | ||
4794 | } | ||
4795 | : | ||
4796 | ( | ||
4797 | { before(grammarAccess.getALSComparisonAccess().getAlternatives_1_0()); } | ||
4798 | (rule__ALSComparison__Alternatives_1_0) | ||
4799 | { after(grammarAccess.getALSComparisonAccess().getAlternatives_1_0()); } | ||
4800 | ) | ||
4801 | |||
4802 | ; | ||
4803 | finally { | ||
4804 | restoreStackSize(stackSize); | ||
4805 | } | ||
4806 | |||
4807 | |||
4808 | rule__ALSComparison__Group_1__1 | ||
4809 | @init { | ||
4810 | int stackSize = keepStackSize(); | ||
4811 | } | ||
4812 | : | ||
4813 | rule__ALSComparison__Group_1__1__Impl | ||
4814 | ; | ||
4815 | finally { | ||
4816 | restoreStackSize(stackSize); | ||
4817 | } | ||
4818 | |||
4819 | rule__ALSComparison__Group_1__1__Impl | ||
4820 | @init { | ||
4821 | int stackSize = keepStackSize(); | ||
4822 | } | ||
4823 | : | ||
4824 | ( | ||
4825 | { before(grammarAccess.getALSComparisonAccess().getRightOperandAssignment_1_1()); } | ||
4826 | (rule__ALSComparison__RightOperandAssignment_1_1) | ||
4827 | { after(grammarAccess.getALSComparisonAccess().getRightOperandAssignment_1_1()); } | ||
4828 | ) | ||
4829 | |||
4830 | ; | ||
4831 | finally { | ||
4832 | restoreStackSize(stackSize); | ||
4833 | } | ||
4834 | |||
4835 | |||
4836 | |||
4837 | |||
4838 | |||
4839 | |||
4840 | rule__ALSComparison__Group_1_0_0__0 | ||
4841 | @init { | ||
4842 | int stackSize = keepStackSize(); | ||
4843 | } | ||
4844 | : | ||
4845 | rule__ALSComparison__Group_1_0_0__0__Impl | ||
4846 | rule__ALSComparison__Group_1_0_0__1 | ||
4847 | ; | ||
4848 | finally { | ||
4849 | restoreStackSize(stackSize); | ||
4850 | } | ||
4851 | |||
4852 | rule__ALSComparison__Group_1_0_0__0__Impl | ||
4853 | @init { | ||
4854 | int stackSize = keepStackSize(); | ||
4855 | } | ||
4856 | : | ||
4857 | ( | ||
4858 | { before(grammarAccess.getALSComparisonAccess().getALSEqualsLeftOperandAction_1_0_0_0()); } | ||
4859 | ( | ||
4860 | |||
4861 | ) | ||
4862 | { after(grammarAccess.getALSComparisonAccess().getALSEqualsLeftOperandAction_1_0_0_0()); } | ||
4863 | ) | ||
4864 | |||
4865 | ; | ||
4866 | finally { | ||
4867 | restoreStackSize(stackSize); | ||
4868 | } | ||
4869 | |||
4870 | |||
4871 | rule__ALSComparison__Group_1_0_0__1 | ||
4872 | @init { | ||
4873 | int stackSize = keepStackSize(); | ||
4874 | } | ||
4875 | : | ||
4876 | rule__ALSComparison__Group_1_0_0__1__Impl | ||
4877 | ; | ||
4878 | finally { | ||
4879 | restoreStackSize(stackSize); | ||
4880 | } | ||
4881 | |||
4882 | rule__ALSComparison__Group_1_0_0__1__Impl | ||
4883 | @init { | ||
4884 | int stackSize = keepStackSize(); | ||
4885 | } | ||
4886 | : | ||
4887 | ( | ||
4888 | { before(grammarAccess.getALSComparisonAccess().getEqualsSignKeyword_1_0_0_1()); } | ||
4889 | |||
4890 | '=' | ||
4891 | |||
4892 | { after(grammarAccess.getALSComparisonAccess().getEqualsSignKeyword_1_0_0_1()); } | ||
4893 | ) | ||
4894 | |||
4895 | ; | ||
4896 | finally { | ||
4897 | restoreStackSize(stackSize); | ||
4898 | } | ||
4899 | |||
4900 | |||
4901 | |||
4902 | |||
4903 | |||
4904 | |||
4905 | rule__ALSComparison__Group_1_0_1__0 | ||
4906 | @init { | ||
4907 | int stackSize = keepStackSize(); | ||
4908 | } | ||
4909 | : | ||
4910 | rule__ALSComparison__Group_1_0_1__0__Impl | ||
4911 | rule__ALSComparison__Group_1_0_1__1 | ||
4912 | ; | ||
4913 | finally { | ||
4914 | restoreStackSize(stackSize); | ||
4915 | } | ||
4916 | |||
4917 | rule__ALSComparison__Group_1_0_1__0__Impl | ||
4918 | @init { | ||
4919 | int stackSize = keepStackSize(); | ||
4920 | } | ||
4921 | : | ||
4922 | ( | ||
4923 | { before(grammarAccess.getALSComparisonAccess().getALSNotEqualsLeftOperandAction_1_0_1_0()); } | ||
4924 | ( | ||
4925 | |||
4926 | ) | ||
4927 | { after(grammarAccess.getALSComparisonAccess().getALSNotEqualsLeftOperandAction_1_0_1_0()); } | ||
4928 | ) | ||
4929 | |||
4930 | ; | ||
4931 | finally { | ||
4932 | restoreStackSize(stackSize); | ||
4933 | } | ||
4934 | |||
4935 | |||
4936 | rule__ALSComparison__Group_1_0_1__1 | ||
4937 | @init { | ||
4938 | int stackSize = keepStackSize(); | ||
4939 | } | ||
4940 | : | ||
4941 | rule__ALSComparison__Group_1_0_1__1__Impl | ||
4942 | ; | ||
4943 | finally { | ||
4944 | restoreStackSize(stackSize); | ||
4945 | } | ||
4946 | |||
4947 | rule__ALSComparison__Group_1_0_1__1__Impl | ||
4948 | @init { | ||
4949 | int stackSize = keepStackSize(); | ||
4950 | } | ||
4951 | : | ||
4952 | ( | ||
4953 | { before(grammarAccess.getALSComparisonAccess().getExclamationMarkEqualsSignKeyword_1_0_1_1()); } | ||
4954 | |||
4955 | '!=' | ||
4956 | |||
4957 | { after(grammarAccess.getALSComparisonAccess().getExclamationMarkEqualsSignKeyword_1_0_1_1()); } | ||
4958 | ) | ||
4959 | |||
4960 | ; | ||
4961 | finally { | ||
4962 | restoreStackSize(stackSize); | ||
4963 | } | ||
4964 | |||
4965 | |||
4966 | |||
4967 | |||
4968 | |||
4969 | |||
4970 | rule__ALSComparison__Group_1_0_2__0 | ||
4971 | @init { | ||
4972 | int stackSize = keepStackSize(); | ||
4973 | } | ||
4974 | : | ||
4975 | rule__ALSComparison__Group_1_0_2__0__Impl | ||
4976 | rule__ALSComparison__Group_1_0_2__1 | ||
4977 | ; | ||
4978 | finally { | ||
4979 | restoreStackSize(stackSize); | ||
4980 | } | ||
4981 | |||
4982 | rule__ALSComparison__Group_1_0_2__0__Impl | ||
4983 | @init { | ||
4984 | int stackSize = keepStackSize(); | ||
4985 | } | ||
4986 | : | ||
4987 | ( | ||
4988 | { before(grammarAccess.getALSComparisonAccess().getALSSubsetLeftOperandAction_1_0_2_0()); } | ||
4989 | ( | ||
4990 | |||
4991 | ) | ||
4992 | { after(grammarAccess.getALSComparisonAccess().getALSSubsetLeftOperandAction_1_0_2_0()); } | ||
4993 | ) | ||
4994 | |||
4995 | ; | ||
4996 | finally { | ||
4997 | restoreStackSize(stackSize); | ||
4998 | } | ||
4999 | |||
5000 | |||
5001 | rule__ALSComparison__Group_1_0_2__1 | ||
5002 | @init { | ||
5003 | int stackSize = keepStackSize(); | ||
5004 | } | ||
5005 | : | ||
5006 | rule__ALSComparison__Group_1_0_2__1__Impl | ||
5007 | ; | ||
5008 | finally { | ||
5009 | restoreStackSize(stackSize); | ||
5010 | } | ||
5011 | |||
5012 | rule__ALSComparison__Group_1_0_2__1__Impl | ||
5013 | @init { | ||
5014 | int stackSize = keepStackSize(); | ||
5015 | } | ||
5016 | : | ||
5017 | ( | ||
5018 | { before(grammarAccess.getALSComparisonAccess().getInKeyword_1_0_2_1()); } | ||
5019 | |||
5020 | 'in' | ||
5021 | |||
5022 | { after(grammarAccess.getALSComparisonAccess().getInKeyword_1_0_2_1()); } | ||
5023 | ) | ||
5024 | |||
5025 | ; | ||
5026 | finally { | ||
5027 | restoreStackSize(stackSize); | ||
5028 | } | ||
5029 | |||
5030 | |||
5031 | |||
5032 | |||
5033 | |||
5034 | |||
5035 | rule__ALSComparison__Group_1_0_3__0 | ||
5036 | @init { | ||
5037 | int stackSize = keepStackSize(); | ||
5038 | } | ||
5039 | : | ||
5040 | rule__ALSComparison__Group_1_0_3__0__Impl | ||
5041 | rule__ALSComparison__Group_1_0_3__1 | ||
5042 | ; | ||
5043 | finally { | ||
5044 | restoreStackSize(stackSize); | ||
5045 | } | ||
5046 | |||
5047 | rule__ALSComparison__Group_1_0_3__0__Impl | ||
5048 | @init { | ||
5049 | int stackSize = keepStackSize(); | ||
5050 | } | ||
5051 | : | ||
5052 | ( | ||
5053 | { before(grammarAccess.getALSComparisonAccess().getALSLessLeftOperandAction_1_0_3_0()); } | ||
5054 | ( | ||
5055 | |||
5056 | ) | ||
5057 | { after(grammarAccess.getALSComparisonAccess().getALSLessLeftOperandAction_1_0_3_0()); } | ||
5058 | ) | ||
5059 | |||
5060 | ; | ||
5061 | finally { | ||
5062 | restoreStackSize(stackSize); | ||
5063 | } | ||
5064 | |||
5065 | |||
5066 | rule__ALSComparison__Group_1_0_3__1 | ||
5067 | @init { | ||
5068 | int stackSize = keepStackSize(); | ||
5069 | } | ||
5070 | : | ||
5071 | rule__ALSComparison__Group_1_0_3__1__Impl | ||
5072 | ; | ||
5073 | finally { | ||
5074 | restoreStackSize(stackSize); | ||
5075 | } | ||
5076 | |||
5077 | rule__ALSComparison__Group_1_0_3__1__Impl | ||
5078 | @init { | ||
5079 | int stackSize = keepStackSize(); | ||
5080 | } | ||
5081 | : | ||
5082 | ( | ||
5083 | { before(grammarAccess.getALSComparisonAccess().getGreaterThanSignKeyword_1_0_3_1()); } | ||
5084 | |||
5085 | '>' | ||
5086 | |||
5087 | { after(grammarAccess.getALSComparisonAccess().getGreaterThanSignKeyword_1_0_3_1()); } | ||
5088 | ) | ||
5089 | |||
5090 | ; | ||
5091 | finally { | ||
5092 | restoreStackSize(stackSize); | ||
5093 | } | ||
5094 | |||
5095 | |||
5096 | |||
5097 | |||
5098 | |||
5099 | |||
5100 | rule__ALSComparison__Group_1_0_4__0 | ||
5101 | @init { | ||
5102 | int stackSize = keepStackSize(); | ||
5103 | } | ||
5104 | : | ||
5105 | rule__ALSComparison__Group_1_0_4__0__Impl | ||
5106 | rule__ALSComparison__Group_1_0_4__1 | ||
5107 | ; | ||
5108 | finally { | ||
5109 | restoreStackSize(stackSize); | ||
5110 | } | ||
5111 | |||
5112 | rule__ALSComparison__Group_1_0_4__0__Impl | ||
5113 | @init { | ||
5114 | int stackSize = keepStackSize(); | ||
5115 | } | ||
5116 | : | ||
5117 | ( | ||
5118 | { before(grammarAccess.getALSComparisonAccess().getALSLeqLeftOperandAction_1_0_4_0()); } | ||
5119 | ( | ||
5120 | |||
5121 | ) | ||
5122 | { after(grammarAccess.getALSComparisonAccess().getALSLeqLeftOperandAction_1_0_4_0()); } | ||
5123 | ) | ||
5124 | |||
5125 | ; | ||
5126 | finally { | ||
5127 | restoreStackSize(stackSize); | ||
5128 | } | ||
5129 | |||
5130 | |||
5131 | rule__ALSComparison__Group_1_0_4__1 | ||
5132 | @init { | ||
5133 | int stackSize = keepStackSize(); | ||
5134 | } | ||
5135 | : | ||
5136 | rule__ALSComparison__Group_1_0_4__1__Impl | ||
5137 | ; | ||
5138 | finally { | ||
5139 | restoreStackSize(stackSize); | ||
5140 | } | ||
5141 | |||
5142 | rule__ALSComparison__Group_1_0_4__1__Impl | ||
5143 | @init { | ||
5144 | int stackSize = keepStackSize(); | ||
5145 | } | ||
5146 | : | ||
5147 | ( | ||
5148 | { before(grammarAccess.getALSComparisonAccess().getGreaterThanSignEqualsSignKeyword_1_0_4_1()); } | ||
5149 | |||
5150 | '>=' | ||
5151 | |||
5152 | { after(grammarAccess.getALSComparisonAccess().getGreaterThanSignEqualsSignKeyword_1_0_4_1()); } | ||
5153 | ) | ||
5154 | |||
5155 | ; | ||
5156 | finally { | ||
5157 | restoreStackSize(stackSize); | ||
5158 | } | ||
5159 | |||
5160 | |||
5161 | |||
5162 | |||
5163 | |||
5164 | |||
5165 | rule__ALSComparison__Group_1_0_5__0 | ||
5166 | @init { | ||
5167 | int stackSize = keepStackSize(); | ||
5168 | } | ||
5169 | : | ||
5170 | rule__ALSComparison__Group_1_0_5__0__Impl | ||
5171 | rule__ALSComparison__Group_1_0_5__1 | ||
5172 | ; | ||
5173 | finally { | ||
5174 | restoreStackSize(stackSize); | ||
5175 | } | ||
5176 | |||
5177 | rule__ALSComparison__Group_1_0_5__0__Impl | ||
5178 | @init { | ||
5179 | int stackSize = keepStackSize(); | ||
5180 | } | ||
5181 | : | ||
5182 | ( | ||
5183 | { before(grammarAccess.getALSComparisonAccess().getALSMoreLeftOperandAction_1_0_5_0()); } | ||
5184 | ( | ||
5185 | |||
5186 | ) | ||
5187 | { after(grammarAccess.getALSComparisonAccess().getALSMoreLeftOperandAction_1_0_5_0()); } | ||
5188 | ) | ||
5189 | |||
5190 | ; | ||
5191 | finally { | ||
5192 | restoreStackSize(stackSize); | ||
5193 | } | ||
5194 | |||
5195 | |||
5196 | rule__ALSComparison__Group_1_0_5__1 | ||
5197 | @init { | ||
5198 | int stackSize = keepStackSize(); | ||
5199 | } | ||
5200 | : | ||
5201 | rule__ALSComparison__Group_1_0_5__1__Impl | ||
5202 | ; | ||
5203 | finally { | ||
5204 | restoreStackSize(stackSize); | ||
5205 | } | ||
5206 | |||
5207 | rule__ALSComparison__Group_1_0_5__1__Impl | ||
5208 | @init { | ||
5209 | int stackSize = keepStackSize(); | ||
5210 | } | ||
5211 | : | ||
5212 | ( | ||
5213 | { before(grammarAccess.getALSComparisonAccess().getLessThanSignKeyword_1_0_5_1()); } | ||
5214 | |||
5215 | '<' | ||
5216 | |||
5217 | { after(grammarAccess.getALSComparisonAccess().getLessThanSignKeyword_1_0_5_1()); } | ||
5218 | ) | ||
5219 | |||
5220 | ; | ||
5221 | finally { | ||
5222 | restoreStackSize(stackSize); | ||
5223 | } | ||
5224 | |||
5225 | |||
5226 | |||
5227 | |||
5228 | |||
5229 | |||
5230 | rule__ALSComparison__Group_1_0_6__0 | ||
5231 | @init { | ||
5232 | int stackSize = keepStackSize(); | ||
5233 | } | ||
5234 | : | ||
5235 | rule__ALSComparison__Group_1_0_6__0__Impl | ||
5236 | rule__ALSComparison__Group_1_0_6__1 | ||
5237 | ; | ||
5238 | finally { | ||
5239 | restoreStackSize(stackSize); | ||
5240 | } | ||
5241 | |||
5242 | rule__ALSComparison__Group_1_0_6__0__Impl | ||
5243 | @init { | ||
5244 | int stackSize = keepStackSize(); | ||
5245 | } | ||
5246 | : | ||
5247 | ( | ||
5248 | { before(grammarAccess.getALSComparisonAccess().getALSMeqLeftOperandAction_1_0_6_0()); } | ||
5249 | ( | ||
5250 | |||
5251 | ) | ||
5252 | { after(grammarAccess.getALSComparisonAccess().getALSMeqLeftOperandAction_1_0_6_0()); } | ||
5253 | ) | ||
5254 | |||
5255 | ; | ||
5256 | finally { | ||
5257 | restoreStackSize(stackSize); | ||
5258 | } | ||
5259 | |||
5260 | |||
5261 | rule__ALSComparison__Group_1_0_6__1 | ||
5262 | @init { | ||
5263 | int stackSize = keepStackSize(); | ||
5264 | } | ||
5265 | : | ||
5266 | rule__ALSComparison__Group_1_0_6__1__Impl | ||
5267 | ; | ||
5268 | finally { | ||
5269 | restoreStackSize(stackSize); | ||
5270 | } | ||
5271 | |||
5272 | rule__ALSComparison__Group_1_0_6__1__Impl | ||
5273 | @init { | ||
5274 | int stackSize = keepStackSize(); | ||
5275 | } | ||
5276 | : | ||
5277 | ( | ||
5278 | { before(grammarAccess.getALSComparisonAccess().getLessThanSignEqualsSignKeyword_1_0_6_1()); } | ||
5279 | |||
5280 | '<=' | ||
5281 | |||
5282 | { after(grammarAccess.getALSComparisonAccess().getLessThanSignEqualsSignKeyword_1_0_6_1()); } | ||
5283 | ) | ||
5284 | |||
5285 | ; | ||
5286 | finally { | ||
5287 | restoreStackSize(stackSize); | ||
5288 | } | ||
5289 | |||
5290 | |||
5291 | |||
5292 | |||
5293 | |||
5294 | |||
5295 | rule__ALSOverride__Group__0 | ||
5296 | @init { | ||
5297 | int stackSize = keepStackSize(); | ||
5298 | } | ||
5299 | : | ||
5300 | rule__ALSOverride__Group__0__Impl | ||
5301 | rule__ALSOverride__Group__1 | ||
5302 | ; | ||
5303 | finally { | ||
5304 | restoreStackSize(stackSize); | ||
5305 | } | ||
5306 | |||
5307 | rule__ALSOverride__Group__0__Impl | ||
5308 | @init { | ||
5309 | int stackSize = keepStackSize(); | ||
5310 | } | ||
5311 | : | ||
5312 | ( | ||
5313 | { before(grammarAccess.getALSOverrideAccess().getALSRangeRestrictionRightParserRuleCall_0()); } | ||
5314 | ruleALSRangeRestrictionRight | ||
5315 | { after(grammarAccess.getALSOverrideAccess().getALSRangeRestrictionRightParserRuleCall_0()); } | ||
5316 | ) | ||
5317 | |||
5318 | ; | ||
5319 | finally { | ||
5320 | restoreStackSize(stackSize); | ||
5321 | } | ||
5322 | |||
5323 | |||
5324 | rule__ALSOverride__Group__1 | ||
5325 | @init { | ||
5326 | int stackSize = keepStackSize(); | ||
5327 | } | ||
5328 | : | ||
5329 | rule__ALSOverride__Group__1__Impl | ||
5330 | ; | ||
5331 | finally { | ||
5332 | restoreStackSize(stackSize); | ||
5333 | } | ||
5334 | |||
5335 | rule__ALSOverride__Group__1__Impl | ||
5336 | @init { | ||
5337 | int stackSize = keepStackSize(); | ||
5338 | } | ||
5339 | : | ||
5340 | ( | ||
5341 | { before(grammarAccess.getALSOverrideAccess().getGroup_1()); } | ||
5342 | (rule__ALSOverride__Group_1__0)? | ||
5343 | { after(grammarAccess.getALSOverrideAccess().getGroup_1()); } | ||
5344 | ) | ||
5345 | |||
5346 | ; | ||
5347 | finally { | ||
5348 | restoreStackSize(stackSize); | ||
5349 | } | ||
5350 | |||
5351 | |||
5352 | |||
5353 | |||
5354 | |||
5355 | |||
5356 | rule__ALSOverride__Group_1__0 | ||
5357 | @init { | ||
5358 | int stackSize = keepStackSize(); | ||
5359 | } | ||
5360 | : | ||
5361 | rule__ALSOverride__Group_1__0__Impl | ||
5362 | rule__ALSOverride__Group_1__1 | ||
5363 | ; | ||
5364 | finally { | ||
5365 | restoreStackSize(stackSize); | ||
5366 | } | ||
5367 | |||
5368 | rule__ALSOverride__Group_1__0__Impl | ||
5369 | @init { | ||
5370 | int stackSize = keepStackSize(); | ||
5371 | } | ||
5372 | : | ||
5373 | ( | ||
5374 | { before(grammarAccess.getALSOverrideAccess().getALSOverrideLeftOperandAction_1_0()); } | ||
5375 | ( | ||
5376 | |||
5377 | ) | ||
5378 | { after(grammarAccess.getALSOverrideAccess().getALSOverrideLeftOperandAction_1_0()); } | ||
5379 | ) | ||
5380 | |||
5381 | ; | ||
5382 | finally { | ||
5383 | restoreStackSize(stackSize); | ||
5384 | } | ||
5385 | |||
5386 | |||
5387 | rule__ALSOverride__Group_1__1 | ||
5388 | @init { | ||
5389 | int stackSize = keepStackSize(); | ||
5390 | } | ||
5391 | : | ||
5392 | rule__ALSOverride__Group_1__1__Impl | ||
5393 | rule__ALSOverride__Group_1__2 | ||
5394 | ; | ||
5395 | finally { | ||
5396 | restoreStackSize(stackSize); | ||
5397 | } | ||
5398 | |||
5399 | rule__ALSOverride__Group_1__1__Impl | ||
5400 | @init { | ||
5401 | int stackSize = keepStackSize(); | ||
5402 | } | ||
5403 | : | ||
5404 | ( | ||
5405 | { before(grammarAccess.getALSOverrideAccess().getPlusSignPlusSignKeyword_1_1()); } | ||
5406 | |||
5407 | '++' | ||
5408 | |||
5409 | { after(grammarAccess.getALSOverrideAccess().getPlusSignPlusSignKeyword_1_1()); } | ||
5410 | ) | ||
5411 | |||
5412 | ; | ||
5413 | finally { | ||
5414 | restoreStackSize(stackSize); | ||
5415 | } | ||
5416 | |||
5417 | |||
5418 | rule__ALSOverride__Group_1__2 | ||
5419 | @init { | ||
5420 | int stackSize = keepStackSize(); | ||
5421 | } | ||
5422 | : | ||
5423 | rule__ALSOverride__Group_1__2__Impl | ||
5424 | ; | ||
5425 | finally { | ||
5426 | restoreStackSize(stackSize); | ||
5427 | } | ||
5428 | |||
5429 | rule__ALSOverride__Group_1__2__Impl | ||
5430 | @init { | ||
5431 | int stackSize = keepStackSize(); | ||
5432 | } | ||
5433 | : | ||
5434 | ( | ||
5435 | { before(grammarAccess.getALSOverrideAccess().getRightOperandAssignment_1_2()); } | ||
5436 | (rule__ALSOverride__RightOperandAssignment_1_2) | ||
5437 | { after(grammarAccess.getALSOverrideAccess().getRightOperandAssignment_1_2()); } | ||
5438 | ) | ||
5439 | |||
5440 | ; | ||
5441 | finally { | ||
5442 | restoreStackSize(stackSize); | ||
5443 | } | ||
5444 | |||
5445 | |||
5446 | |||
5447 | |||
5448 | |||
5449 | |||
5450 | |||
5451 | |||
5452 | rule__ALSRangeRestrictionRight__Group__0 | ||
5453 | @init { | ||
5454 | int stackSize = keepStackSize(); | ||
5455 | } | ||
5456 | : | ||
5457 | rule__ALSRangeRestrictionRight__Group__0__Impl | ||
5458 | rule__ALSRangeRestrictionRight__Group__1 | ||
5459 | ; | ||
5460 | finally { | ||
5461 | restoreStackSize(stackSize); | ||
5462 | } | ||
5463 | |||
5464 | rule__ALSRangeRestrictionRight__Group__0__Impl | ||
5465 | @init { | ||
5466 | int stackSize = keepStackSize(); | ||
5467 | } | ||
5468 | : | ||
5469 | ( | ||
5470 | { before(grammarAccess.getALSRangeRestrictionRightAccess().getALSRangeRestrictionLeftParserRuleCall_0()); } | ||
5471 | ruleALSRangeRestrictionLeft | ||
5472 | { after(grammarAccess.getALSRangeRestrictionRightAccess().getALSRangeRestrictionLeftParserRuleCall_0()); } | ||
5473 | ) | ||
5474 | |||
5475 | ; | ||
5476 | finally { | ||
5477 | restoreStackSize(stackSize); | ||
5478 | } | ||
5479 | |||
5480 | |||
5481 | rule__ALSRangeRestrictionRight__Group__1 | ||
5482 | @init { | ||
5483 | int stackSize = keepStackSize(); | ||
5484 | } | ||
5485 | : | ||
5486 | rule__ALSRangeRestrictionRight__Group__1__Impl | ||
5487 | ; | ||
5488 | finally { | ||
5489 | restoreStackSize(stackSize); | ||
5490 | } | ||
5491 | |||
5492 | rule__ALSRangeRestrictionRight__Group__1__Impl | ||
5493 | @init { | ||
5494 | int stackSize = keepStackSize(); | ||
5495 | } | ||
5496 | : | ||
5497 | ( | ||
5498 | { before(grammarAccess.getALSRangeRestrictionRightAccess().getGroup_1()); } | ||
5499 | (rule__ALSRangeRestrictionRight__Group_1__0)? | ||
5500 | { after(grammarAccess.getALSRangeRestrictionRightAccess().getGroup_1()); } | ||
5501 | ) | ||
5502 | |||
5503 | ; | ||
5504 | finally { | ||
5505 | restoreStackSize(stackSize); | ||
5506 | } | ||
5507 | |||
5508 | |||
5509 | |||
5510 | |||
5511 | |||
5512 | |||
5513 | rule__ALSRangeRestrictionRight__Group_1__0 | ||
5514 | @init { | ||
5515 | int stackSize = keepStackSize(); | ||
5516 | } | ||
5517 | : | ||
5518 | rule__ALSRangeRestrictionRight__Group_1__0__Impl | ||
5519 | rule__ALSRangeRestrictionRight__Group_1__1 | ||
5520 | ; | ||
5521 | finally { | ||
5522 | restoreStackSize(stackSize); | ||
5523 | } | ||
5524 | |||
5525 | rule__ALSRangeRestrictionRight__Group_1__0__Impl | ||
5526 | @init { | ||
5527 | int stackSize = keepStackSize(); | ||
5528 | } | ||
5529 | : | ||
5530 | ( | ||
5531 | { before(grammarAccess.getALSRangeRestrictionRightAccess().getALSRangeRestrictionRightRelationAction_1_0()); } | ||
5532 | ( | ||
5533 | |||
5534 | ) | ||
5535 | { after(grammarAccess.getALSRangeRestrictionRightAccess().getALSRangeRestrictionRightRelationAction_1_0()); } | ||
5536 | ) | ||
5537 | |||
5538 | ; | ||
5539 | finally { | ||
5540 | restoreStackSize(stackSize); | ||
5541 | } | ||
5542 | |||
5543 | |||
5544 | rule__ALSRangeRestrictionRight__Group_1__1 | ||
5545 | @init { | ||
5546 | int stackSize = keepStackSize(); | ||
5547 | } | ||
5548 | : | ||
5549 | rule__ALSRangeRestrictionRight__Group_1__1__Impl | ||
5550 | rule__ALSRangeRestrictionRight__Group_1__2 | ||
5551 | ; | ||
5552 | finally { | ||
5553 | restoreStackSize(stackSize); | ||
5554 | } | ||
5555 | |||
5556 | rule__ALSRangeRestrictionRight__Group_1__1__Impl | ||
5557 | @init { | ||
5558 | int stackSize = keepStackSize(); | ||
5559 | } | ||
5560 | : | ||
5561 | ( | ||
5562 | { before(grammarAccess.getALSRangeRestrictionRightAccess().getColonGreaterThanSignKeyword_1_1()); } | ||
5563 | |||
5564 | ':>' | ||
5565 | |||
5566 | { after(grammarAccess.getALSRangeRestrictionRightAccess().getColonGreaterThanSignKeyword_1_1()); } | ||
5567 | ) | ||
5568 | |||
5569 | ; | ||
5570 | finally { | ||
5571 | restoreStackSize(stackSize); | ||
5572 | } | ||
5573 | |||
5574 | |||
5575 | rule__ALSRangeRestrictionRight__Group_1__2 | ||
5576 | @init { | ||
5577 | int stackSize = keepStackSize(); | ||
5578 | } | ||
5579 | : | ||
5580 | rule__ALSRangeRestrictionRight__Group_1__2__Impl | ||
5581 | ; | ||
5582 | finally { | ||
5583 | restoreStackSize(stackSize); | ||
5584 | } | ||
5585 | |||
5586 | rule__ALSRangeRestrictionRight__Group_1__2__Impl | ||
5587 | @init { | ||
5588 | int stackSize = keepStackSize(); | ||
5589 | } | ||
5590 | : | ||
5591 | ( | ||
5592 | { before(grammarAccess.getALSRangeRestrictionRightAccess().getFilterAssignment_1_2()); } | ||
5593 | (rule__ALSRangeRestrictionRight__FilterAssignment_1_2) | ||
5594 | { after(grammarAccess.getALSRangeRestrictionRightAccess().getFilterAssignment_1_2()); } | ||
5595 | ) | ||
5596 | |||
5597 | ; | ||
5598 | finally { | ||
5599 | restoreStackSize(stackSize); | ||
5600 | } | ||
5601 | |||
5602 | |||
5603 | |||
5604 | |||
5605 | |||
5606 | |||
5607 | |||
5608 | |||
5609 | rule__ALSRangeRestrictionLeft__Group__0 | ||
5610 | @init { | ||
5611 | int stackSize = keepStackSize(); | ||
5612 | } | ||
5613 | : | ||
5614 | rule__ALSRangeRestrictionLeft__Group__0__Impl | ||
5615 | rule__ALSRangeRestrictionLeft__Group__1 | ||
5616 | ; | ||
5617 | finally { | ||
5618 | restoreStackSize(stackSize); | ||
5619 | } | ||
5620 | |||
5621 | rule__ALSRangeRestrictionLeft__Group__0__Impl | ||
5622 | @init { | ||
5623 | int stackSize = keepStackSize(); | ||
5624 | } | ||
5625 | : | ||
5626 | ( | ||
5627 | { before(grammarAccess.getALSRangeRestrictionLeftAccess().getALSJoinParserRuleCall_0()); } | ||
5628 | ruleALSJoin | ||
5629 | { after(grammarAccess.getALSRangeRestrictionLeftAccess().getALSJoinParserRuleCall_0()); } | ||
5630 | ) | ||
5631 | |||
5632 | ; | ||
5633 | finally { | ||
5634 | restoreStackSize(stackSize); | ||
5635 | } | ||
5636 | |||
5637 | |||
5638 | rule__ALSRangeRestrictionLeft__Group__1 | ||
5639 | @init { | ||
5640 | int stackSize = keepStackSize(); | ||
5641 | } | ||
5642 | : | ||
5643 | rule__ALSRangeRestrictionLeft__Group__1__Impl | ||
5644 | ; | ||
5645 | finally { | ||
5646 | restoreStackSize(stackSize); | ||
5647 | } | ||
5648 | |||
5649 | rule__ALSRangeRestrictionLeft__Group__1__Impl | ||
5650 | @init { | ||
5651 | int stackSize = keepStackSize(); | ||
5652 | } | ||
5653 | : | ||
5654 | ( | ||
5655 | { before(grammarAccess.getALSRangeRestrictionLeftAccess().getGroup_1()); } | ||
5656 | (rule__ALSRangeRestrictionLeft__Group_1__0)? | ||
5657 | { after(grammarAccess.getALSRangeRestrictionLeftAccess().getGroup_1()); } | ||
5658 | ) | ||
5659 | |||
5660 | ; | ||
5661 | finally { | ||
5662 | restoreStackSize(stackSize); | ||
5663 | } | ||
5664 | |||
5665 | |||
5666 | |||
5667 | |||
5668 | |||
5669 | |||
5670 | rule__ALSRangeRestrictionLeft__Group_1__0 | ||
5671 | @init { | ||
5672 | int stackSize = keepStackSize(); | ||
5673 | } | ||
5674 | : | ||
5675 | rule__ALSRangeRestrictionLeft__Group_1__0__Impl | ||
5676 | rule__ALSRangeRestrictionLeft__Group_1__1 | ||
5677 | ; | ||
5678 | finally { | ||
5679 | restoreStackSize(stackSize); | ||
5680 | } | ||
5681 | |||
5682 | rule__ALSRangeRestrictionLeft__Group_1__0__Impl | ||
5683 | @init { | ||
5684 | int stackSize = keepStackSize(); | ||
5685 | } | ||
5686 | : | ||
5687 | ( | ||
5688 | { before(grammarAccess.getALSRangeRestrictionLeftAccess().getALSRangeRestrictionLeftFilterAction_1_0()); } | ||
5689 | ( | ||
5690 | |||
5691 | ) | ||
5692 | { after(grammarAccess.getALSRangeRestrictionLeftAccess().getALSRangeRestrictionLeftFilterAction_1_0()); } | ||
5693 | ) | ||
5694 | |||
5695 | ; | ||
5696 | finally { | ||
5697 | restoreStackSize(stackSize); | ||
5698 | } | ||
5699 | |||
5700 | |||
5701 | rule__ALSRangeRestrictionLeft__Group_1__1 | ||
5702 | @init { | ||
5703 | int stackSize = keepStackSize(); | ||
5704 | } | ||
5705 | : | ||
5706 | rule__ALSRangeRestrictionLeft__Group_1__1__Impl | ||
5707 | rule__ALSRangeRestrictionLeft__Group_1__2 | ||
5708 | ; | ||
5709 | finally { | ||
5710 | restoreStackSize(stackSize); | ||
5711 | } | ||
5712 | |||
5713 | rule__ALSRangeRestrictionLeft__Group_1__1__Impl | ||
5714 | @init { | ||
5715 | int stackSize = keepStackSize(); | ||
5716 | } | ||
5717 | : | ||
5718 | ( | ||
5719 | { before(grammarAccess.getALSRangeRestrictionLeftAccess().getLessThanSignColonKeyword_1_1()); } | ||
5720 | |||
5721 | '<:' | ||
5722 | |||
5723 | { after(grammarAccess.getALSRangeRestrictionLeftAccess().getLessThanSignColonKeyword_1_1()); } | ||
5724 | ) | ||
5725 | |||
5726 | ; | ||
5727 | finally { | ||
5728 | restoreStackSize(stackSize); | ||
5729 | } | ||
5730 | |||
5731 | |||
5732 | rule__ALSRangeRestrictionLeft__Group_1__2 | ||
5733 | @init { | ||
5734 | int stackSize = keepStackSize(); | ||
5735 | } | ||
5736 | : | ||
5737 | rule__ALSRangeRestrictionLeft__Group_1__2__Impl | ||
5738 | ; | ||
5739 | finally { | ||
5740 | restoreStackSize(stackSize); | ||
5741 | } | ||
5742 | |||
5743 | rule__ALSRangeRestrictionLeft__Group_1__2__Impl | ||
5744 | @init { | ||
5745 | int stackSize = keepStackSize(); | ||
5746 | } | ||
5747 | : | ||
5748 | ( | ||
5749 | { before(grammarAccess.getALSRangeRestrictionLeftAccess().getRelationAssignment_1_2()); } | ||
5750 | (rule__ALSRangeRestrictionLeft__RelationAssignment_1_2) | ||
5751 | { after(grammarAccess.getALSRangeRestrictionLeftAccess().getRelationAssignment_1_2()); } | ||
5752 | ) | ||
5753 | |||
5754 | ; | ||
5755 | finally { | ||
5756 | restoreStackSize(stackSize); | ||
5757 | } | ||
5758 | |||
5759 | |||
5760 | |||
5761 | |||
5762 | |||
5763 | |||
5764 | |||
5765 | |||
5766 | rule__ALSJoin__Group__0 | ||
5767 | @init { | ||
5768 | int stackSize = keepStackSize(); | ||
5769 | } | ||
5770 | : | ||
5771 | rule__ALSJoin__Group__0__Impl | ||
5772 | rule__ALSJoin__Group__1 | ||
5773 | ; | ||
5774 | finally { | ||
5775 | restoreStackSize(stackSize); | ||
5776 | } | ||
5777 | |||
5778 | rule__ALSJoin__Group__0__Impl | ||
5779 | @init { | ||
5780 | int stackSize = keepStackSize(); | ||
5781 | } | ||
5782 | : | ||
5783 | ( | ||
5784 | { before(grammarAccess.getALSJoinAccess().getALSMinusParserRuleCall_0()); } | ||
5785 | ruleALSMinus | ||
5786 | { after(grammarAccess.getALSJoinAccess().getALSMinusParserRuleCall_0()); } | ||
5787 | ) | ||
5788 | |||
5789 | ; | ||
5790 | finally { | ||
5791 | restoreStackSize(stackSize); | ||
5792 | } | ||
5793 | |||
5794 | |||
5795 | rule__ALSJoin__Group__1 | ||
5796 | @init { | ||
5797 | int stackSize = keepStackSize(); | ||
5798 | } | ||
5799 | : | ||
5800 | rule__ALSJoin__Group__1__Impl | ||
5801 | ; | ||
5802 | finally { | ||
5803 | restoreStackSize(stackSize); | ||
5804 | } | ||
5805 | |||
5806 | rule__ALSJoin__Group__1__Impl | ||
5807 | @init { | ||
5808 | int stackSize = keepStackSize(); | ||
5809 | } | ||
5810 | : | ||
5811 | ( | ||
5812 | { before(grammarAccess.getALSJoinAccess().getGroup_1()); } | ||
5813 | (rule__ALSJoin__Group_1__0)* | ||
5814 | { after(grammarAccess.getALSJoinAccess().getGroup_1()); } | ||
5815 | ) | ||
5816 | |||
5817 | ; | ||
5818 | finally { | ||
5819 | restoreStackSize(stackSize); | ||
5820 | } | ||
5821 | |||
5822 | |||
5823 | |||
5824 | |||
5825 | |||
5826 | |||
5827 | rule__ALSJoin__Group_1__0 | ||
5828 | @init { | ||
5829 | int stackSize = keepStackSize(); | ||
5830 | } | ||
5831 | : | ||
5832 | rule__ALSJoin__Group_1__0__Impl | ||
5833 | rule__ALSJoin__Group_1__1 | ||
5834 | ; | ||
5835 | finally { | ||
5836 | restoreStackSize(stackSize); | ||
5837 | } | ||
5838 | |||
5839 | rule__ALSJoin__Group_1__0__Impl | ||
5840 | @init { | ||
5841 | int stackSize = keepStackSize(); | ||
5842 | } | ||
5843 | : | ||
5844 | ( | ||
5845 | { before(grammarAccess.getALSJoinAccess().getALSJoinLeftOperandAction_1_0()); } | ||
5846 | ( | ||
5847 | |||
5848 | ) | ||
5849 | { after(grammarAccess.getALSJoinAccess().getALSJoinLeftOperandAction_1_0()); } | ||
5850 | ) | ||
5851 | |||
5852 | ; | ||
5853 | finally { | ||
5854 | restoreStackSize(stackSize); | ||
5855 | } | ||
5856 | |||
5857 | |||
5858 | rule__ALSJoin__Group_1__1 | ||
5859 | @init { | ||
5860 | int stackSize = keepStackSize(); | ||
5861 | } | ||
5862 | : | ||
5863 | rule__ALSJoin__Group_1__1__Impl | ||
5864 | rule__ALSJoin__Group_1__2 | ||
5865 | ; | ||
5866 | finally { | ||
5867 | restoreStackSize(stackSize); | ||
5868 | } | ||
5869 | |||
5870 | rule__ALSJoin__Group_1__1__Impl | ||
5871 | @init { | ||
5872 | int stackSize = keepStackSize(); | ||
5873 | } | ||
5874 | : | ||
5875 | ( | ||
5876 | { before(grammarAccess.getALSJoinAccess().getFullStopKeyword_1_1()); } | ||
5877 | |||
5878 | '.' | ||
5879 | |||
5880 | { after(grammarAccess.getALSJoinAccess().getFullStopKeyword_1_1()); } | ||
5881 | ) | ||
5882 | |||
5883 | ; | ||
5884 | finally { | ||
5885 | restoreStackSize(stackSize); | ||
5886 | } | ||
5887 | |||
5888 | |||
5889 | rule__ALSJoin__Group_1__2 | ||
5890 | @init { | ||
5891 | int stackSize = keepStackSize(); | ||
5892 | } | ||
5893 | : | ||
5894 | rule__ALSJoin__Group_1__2__Impl | ||
5895 | ; | ||
5896 | finally { | ||
5897 | restoreStackSize(stackSize); | ||
5898 | } | ||
5899 | |||
5900 | rule__ALSJoin__Group_1__2__Impl | ||
5901 | @init { | ||
5902 | int stackSize = keepStackSize(); | ||
5903 | } | ||
5904 | : | ||
5905 | ( | ||
5906 | { before(grammarAccess.getALSJoinAccess().getRightOperandAssignment_1_2()); } | ||
5907 | (rule__ALSJoin__RightOperandAssignment_1_2) | ||
5908 | { after(grammarAccess.getALSJoinAccess().getRightOperandAssignment_1_2()); } | ||
5909 | ) | ||
5910 | |||
5911 | ; | ||
5912 | finally { | ||
5913 | restoreStackSize(stackSize); | ||
5914 | } | ||
5915 | |||
5916 | |||
5917 | |||
5918 | |||
5919 | |||
5920 | |||
5921 | |||
5922 | |||
5923 | rule__ALSMinus__Group__0 | ||
5924 | @init { | ||
5925 | int stackSize = keepStackSize(); | ||
5926 | } | ||
5927 | : | ||
5928 | rule__ALSMinus__Group__0__Impl | ||
5929 | rule__ALSMinus__Group__1 | ||
5930 | ; | ||
5931 | finally { | ||
5932 | restoreStackSize(stackSize); | ||
5933 | } | ||
5934 | |||
5935 | rule__ALSMinus__Group__0__Impl | ||
5936 | @init { | ||
5937 | int stackSize = keepStackSize(); | ||
5938 | } | ||
5939 | : | ||
5940 | ( | ||
5941 | { before(grammarAccess.getALSMinusAccess().getALSPlusParserRuleCall_0()); } | ||
5942 | ruleALSPlus | ||
5943 | { after(grammarAccess.getALSMinusAccess().getALSPlusParserRuleCall_0()); } | ||
5944 | ) | ||
5945 | |||
5946 | ; | ||
5947 | finally { | ||
5948 | restoreStackSize(stackSize); | ||
5949 | } | ||
5950 | |||
5951 | |||
5952 | rule__ALSMinus__Group__1 | ||
5953 | @init { | ||
5954 | int stackSize = keepStackSize(); | ||
5955 | } | ||
5956 | : | ||
5957 | rule__ALSMinus__Group__1__Impl | ||
5958 | ; | ||
5959 | finally { | ||
5960 | restoreStackSize(stackSize); | ||
5961 | } | ||
5962 | |||
5963 | rule__ALSMinus__Group__1__Impl | ||
5964 | @init { | ||
5965 | int stackSize = keepStackSize(); | ||
5966 | } | ||
5967 | : | ||
5968 | ( | ||
5969 | { before(grammarAccess.getALSMinusAccess().getGroup_1()); } | ||
5970 | (rule__ALSMinus__Group_1__0)* | ||
5971 | { after(grammarAccess.getALSMinusAccess().getGroup_1()); } | ||
5972 | ) | ||
5973 | |||
5974 | ; | ||
5975 | finally { | ||
5976 | restoreStackSize(stackSize); | ||
5977 | } | ||
5978 | |||
5979 | |||
5980 | |||
5981 | |||
5982 | |||
5983 | |||
5984 | rule__ALSMinus__Group_1__0 | ||
5985 | @init { | ||
5986 | int stackSize = keepStackSize(); | ||
5987 | } | ||
5988 | : | ||
5989 | rule__ALSMinus__Group_1__0__Impl | ||
5990 | rule__ALSMinus__Group_1__1 | ||
5991 | ; | ||
5992 | finally { | ||
5993 | restoreStackSize(stackSize); | ||
5994 | } | ||
5995 | |||
5996 | rule__ALSMinus__Group_1__0__Impl | ||
5997 | @init { | ||
5998 | int stackSize = keepStackSize(); | ||
5999 | } | ||
6000 | : | ||
6001 | ( | ||
6002 | { before(grammarAccess.getALSMinusAccess().getALSMinusLeftOperandAction_1_0()); } | ||
6003 | ( | ||
6004 | |||
6005 | ) | ||
6006 | { after(grammarAccess.getALSMinusAccess().getALSMinusLeftOperandAction_1_0()); } | ||
6007 | ) | ||
6008 | |||
6009 | ; | ||
6010 | finally { | ||
6011 | restoreStackSize(stackSize); | ||
6012 | } | ||
6013 | |||
6014 | |||
6015 | rule__ALSMinus__Group_1__1 | ||
6016 | @init { | ||
6017 | int stackSize = keepStackSize(); | ||
6018 | } | ||
6019 | : | ||
6020 | rule__ALSMinus__Group_1__1__Impl | ||
6021 | rule__ALSMinus__Group_1__2 | ||
6022 | ; | ||
6023 | finally { | ||
6024 | restoreStackSize(stackSize); | ||
6025 | } | ||
6026 | |||
6027 | rule__ALSMinus__Group_1__1__Impl | ||
6028 | @init { | ||
6029 | int stackSize = keepStackSize(); | ||
6030 | } | ||
6031 | : | ||
6032 | ( | ||
6033 | { before(grammarAccess.getALSMinusAccess().getHyphenMinusKeyword_1_1()); } | ||
6034 | |||
6035 | '-' | ||
6036 | |||
6037 | { after(grammarAccess.getALSMinusAccess().getHyphenMinusKeyword_1_1()); } | ||
6038 | ) | ||
6039 | |||
6040 | ; | ||
6041 | finally { | ||
6042 | restoreStackSize(stackSize); | ||
6043 | } | ||
6044 | |||
6045 | |||
6046 | rule__ALSMinus__Group_1__2 | ||
6047 | @init { | ||
6048 | int stackSize = keepStackSize(); | ||
6049 | } | ||
6050 | : | ||
6051 | rule__ALSMinus__Group_1__2__Impl | ||
6052 | ; | ||
6053 | finally { | ||
6054 | restoreStackSize(stackSize); | ||
6055 | } | ||
6056 | |||
6057 | rule__ALSMinus__Group_1__2__Impl | ||
6058 | @init { | ||
6059 | int stackSize = keepStackSize(); | ||
6060 | } | ||
6061 | : | ||
6062 | ( | ||
6063 | { before(grammarAccess.getALSMinusAccess().getRightOperandAssignment_1_2()); } | ||
6064 | (rule__ALSMinus__RightOperandAssignment_1_2) | ||
6065 | { after(grammarAccess.getALSMinusAccess().getRightOperandAssignment_1_2()); } | ||
6066 | ) | ||
6067 | |||
6068 | ; | ||
6069 | finally { | ||
6070 | restoreStackSize(stackSize); | ||
6071 | } | ||
6072 | |||
6073 | |||
6074 | |||
6075 | |||
6076 | |||
6077 | |||
6078 | |||
6079 | |||
6080 | rule__ALSPlus__Group__0 | ||
6081 | @init { | ||
6082 | int stackSize = keepStackSize(); | ||
6083 | } | ||
6084 | : | ||
6085 | rule__ALSPlus__Group__0__Impl | ||
6086 | rule__ALSPlus__Group__1 | ||
6087 | ; | ||
6088 | finally { | ||
6089 | restoreStackSize(stackSize); | ||
6090 | } | ||
6091 | |||
6092 | rule__ALSPlus__Group__0__Impl | ||
6093 | @init { | ||
6094 | int stackSize = keepStackSize(); | ||
6095 | } | ||
6096 | : | ||
6097 | ( | ||
6098 | { before(grammarAccess.getALSPlusAccess().getALSIntersectionParserRuleCall_0()); } | ||
6099 | ruleALSIntersection | ||
6100 | { after(grammarAccess.getALSPlusAccess().getALSIntersectionParserRuleCall_0()); } | ||
6101 | ) | ||
6102 | |||
6103 | ; | ||
6104 | finally { | ||
6105 | restoreStackSize(stackSize); | ||
6106 | } | ||
6107 | |||
6108 | |||
6109 | rule__ALSPlus__Group__1 | ||
6110 | @init { | ||
6111 | int stackSize = keepStackSize(); | ||
6112 | } | ||
6113 | : | ||
6114 | rule__ALSPlus__Group__1__Impl | ||
6115 | ; | ||
6116 | finally { | ||
6117 | restoreStackSize(stackSize); | ||
6118 | } | ||
6119 | |||
6120 | rule__ALSPlus__Group__1__Impl | ||
6121 | @init { | ||
6122 | int stackSize = keepStackSize(); | ||
6123 | } | ||
6124 | : | ||
6125 | ( | ||
6126 | { before(grammarAccess.getALSPlusAccess().getGroup_1()); } | ||
6127 | (rule__ALSPlus__Group_1__0)* | ||
6128 | { after(grammarAccess.getALSPlusAccess().getGroup_1()); } | ||
6129 | ) | ||
6130 | |||
6131 | ; | ||
6132 | finally { | ||
6133 | restoreStackSize(stackSize); | ||
6134 | } | ||
6135 | |||
6136 | |||
6137 | |||
6138 | |||
6139 | |||
6140 | |||
6141 | rule__ALSPlus__Group_1__0 | ||
6142 | @init { | ||
6143 | int stackSize = keepStackSize(); | ||
6144 | } | ||
6145 | : | ||
6146 | rule__ALSPlus__Group_1__0__Impl | ||
6147 | rule__ALSPlus__Group_1__1 | ||
6148 | ; | ||
6149 | finally { | ||
6150 | restoreStackSize(stackSize); | ||
6151 | } | ||
6152 | |||
6153 | rule__ALSPlus__Group_1__0__Impl | ||
6154 | @init { | ||
6155 | int stackSize = keepStackSize(); | ||
6156 | } | ||
6157 | : | ||
6158 | ( | ||
6159 | { before(grammarAccess.getALSPlusAccess().getALSPlusLeftOperandAction_1_0()); } | ||
6160 | ( | ||
6161 | |||
6162 | ) | ||
6163 | { after(grammarAccess.getALSPlusAccess().getALSPlusLeftOperandAction_1_0()); } | ||
6164 | ) | ||
6165 | |||
6166 | ; | ||
6167 | finally { | ||
6168 | restoreStackSize(stackSize); | ||
6169 | } | ||
6170 | |||
6171 | |||
6172 | rule__ALSPlus__Group_1__1 | ||
6173 | @init { | ||
6174 | int stackSize = keepStackSize(); | ||
6175 | } | ||
6176 | : | ||
6177 | rule__ALSPlus__Group_1__1__Impl | ||
6178 | rule__ALSPlus__Group_1__2 | ||
6179 | ; | ||
6180 | finally { | ||
6181 | restoreStackSize(stackSize); | ||
6182 | } | ||
6183 | |||
6184 | rule__ALSPlus__Group_1__1__Impl | ||
6185 | @init { | ||
6186 | int stackSize = keepStackSize(); | ||
6187 | } | ||
6188 | : | ||
6189 | ( | ||
6190 | { before(grammarAccess.getALSPlusAccess().getPlusSignKeyword_1_1()); } | ||
6191 | |||
6192 | '+' | ||
6193 | |||
6194 | { after(grammarAccess.getALSPlusAccess().getPlusSignKeyword_1_1()); } | ||
6195 | ) | ||
6196 | |||
6197 | ; | ||
6198 | finally { | ||
6199 | restoreStackSize(stackSize); | ||
6200 | } | ||
6201 | |||
6202 | |||
6203 | rule__ALSPlus__Group_1__2 | ||
6204 | @init { | ||
6205 | int stackSize = keepStackSize(); | ||
6206 | } | ||
6207 | : | ||
6208 | rule__ALSPlus__Group_1__2__Impl | ||
6209 | ; | ||
6210 | finally { | ||
6211 | restoreStackSize(stackSize); | ||
6212 | } | ||
6213 | |||
6214 | rule__ALSPlus__Group_1__2__Impl | ||
6215 | @init { | ||
6216 | int stackSize = keepStackSize(); | ||
6217 | } | ||
6218 | : | ||
6219 | ( | ||
6220 | { before(grammarAccess.getALSPlusAccess().getRightOperandAssignment_1_2()); } | ||
6221 | (rule__ALSPlus__RightOperandAssignment_1_2) | ||
6222 | { after(grammarAccess.getALSPlusAccess().getRightOperandAssignment_1_2()); } | ||
6223 | ) | ||
6224 | |||
6225 | ; | ||
6226 | finally { | ||
6227 | restoreStackSize(stackSize); | ||
6228 | } | ||
6229 | |||
6230 | |||
6231 | |||
6232 | |||
6233 | |||
6234 | |||
6235 | |||
6236 | |||
6237 | rule__ALSIntersection__Group__0 | ||
6238 | @init { | ||
6239 | int stackSize = keepStackSize(); | ||
6240 | } | ||
6241 | : | ||
6242 | rule__ALSIntersection__Group__0__Impl | ||
6243 | rule__ALSIntersection__Group__1 | ||
6244 | ; | ||
6245 | finally { | ||
6246 | restoreStackSize(stackSize); | ||
6247 | } | ||
6248 | |||
6249 | rule__ALSIntersection__Group__0__Impl | ||
6250 | @init { | ||
6251 | int stackSize = keepStackSize(); | ||
6252 | } | ||
6253 | : | ||
6254 | ( | ||
6255 | { before(grammarAccess.getALSIntersectionAccess().getALSDirectProductParserRuleCall_0()); } | ||
6256 | ruleALSDirectProduct | ||
6257 | { after(grammarAccess.getALSIntersectionAccess().getALSDirectProductParserRuleCall_0()); } | ||
6258 | ) | ||
6259 | |||
6260 | ; | ||
6261 | finally { | ||
6262 | restoreStackSize(stackSize); | ||
6263 | } | ||
6264 | |||
6265 | |||
6266 | rule__ALSIntersection__Group__1 | ||
6267 | @init { | ||
6268 | int stackSize = keepStackSize(); | ||
6269 | } | ||
6270 | : | ||
6271 | rule__ALSIntersection__Group__1__Impl | ||
6272 | ; | ||
6273 | finally { | ||
6274 | restoreStackSize(stackSize); | ||
6275 | } | ||
6276 | |||
6277 | rule__ALSIntersection__Group__1__Impl | ||
6278 | @init { | ||
6279 | int stackSize = keepStackSize(); | ||
6280 | } | ||
6281 | : | ||
6282 | ( | ||
6283 | { before(grammarAccess.getALSIntersectionAccess().getGroup_1()); } | ||
6284 | (rule__ALSIntersection__Group_1__0)* | ||
6285 | { after(grammarAccess.getALSIntersectionAccess().getGroup_1()); } | ||
6286 | ) | ||
6287 | |||
6288 | ; | ||
6289 | finally { | ||
6290 | restoreStackSize(stackSize); | ||
6291 | } | ||
6292 | |||
6293 | |||
6294 | |||
6295 | |||
6296 | |||
6297 | |||
6298 | rule__ALSIntersection__Group_1__0 | ||
6299 | @init { | ||
6300 | int stackSize = keepStackSize(); | ||
6301 | } | ||
6302 | : | ||
6303 | rule__ALSIntersection__Group_1__0__Impl | ||
6304 | rule__ALSIntersection__Group_1__1 | ||
6305 | ; | ||
6306 | finally { | ||
6307 | restoreStackSize(stackSize); | ||
6308 | } | ||
6309 | |||
6310 | rule__ALSIntersection__Group_1__0__Impl | ||
6311 | @init { | ||
6312 | int stackSize = keepStackSize(); | ||
6313 | } | ||
6314 | : | ||
6315 | ( | ||
6316 | { before(grammarAccess.getALSIntersectionAccess().getALSIntersectionLeftOperandAction_1_0()); } | ||
6317 | ( | ||
6318 | |||
6319 | ) | ||
6320 | { after(grammarAccess.getALSIntersectionAccess().getALSIntersectionLeftOperandAction_1_0()); } | ||
6321 | ) | ||
6322 | |||
6323 | ; | ||
6324 | finally { | ||
6325 | restoreStackSize(stackSize); | ||
6326 | } | ||
6327 | |||
6328 | |||
6329 | rule__ALSIntersection__Group_1__1 | ||
6330 | @init { | ||
6331 | int stackSize = keepStackSize(); | ||
6332 | } | ||
6333 | : | ||
6334 | rule__ALSIntersection__Group_1__1__Impl | ||
6335 | rule__ALSIntersection__Group_1__2 | ||
6336 | ; | ||
6337 | finally { | ||
6338 | restoreStackSize(stackSize); | ||
6339 | } | ||
6340 | |||
6341 | rule__ALSIntersection__Group_1__1__Impl | ||
6342 | @init { | ||
6343 | int stackSize = keepStackSize(); | ||
6344 | } | ||
6345 | : | ||
6346 | ( | ||
6347 | { before(grammarAccess.getALSIntersectionAccess().getAmpersandKeyword_1_1()); } | ||
6348 | |||
6349 | '&' | ||
6350 | |||
6351 | { after(grammarAccess.getALSIntersectionAccess().getAmpersandKeyword_1_1()); } | ||
6352 | ) | ||
6353 | |||
6354 | ; | ||
6355 | finally { | ||
6356 | restoreStackSize(stackSize); | ||
6357 | } | ||
6358 | |||
6359 | |||
6360 | rule__ALSIntersection__Group_1__2 | ||
6361 | @init { | ||
6362 | int stackSize = keepStackSize(); | ||
6363 | } | ||
6364 | : | ||
6365 | rule__ALSIntersection__Group_1__2__Impl | ||
6366 | ; | ||
6367 | finally { | ||
6368 | restoreStackSize(stackSize); | ||
6369 | } | ||
6370 | |||
6371 | rule__ALSIntersection__Group_1__2__Impl | ||
6372 | @init { | ||
6373 | int stackSize = keepStackSize(); | ||
6374 | } | ||
6375 | : | ||
6376 | ( | ||
6377 | { before(grammarAccess.getALSIntersectionAccess().getRightOperandAssignment_1_2()); } | ||
6378 | (rule__ALSIntersection__RightOperandAssignment_1_2) | ||
6379 | { after(grammarAccess.getALSIntersectionAccess().getRightOperandAssignment_1_2()); } | ||
6380 | ) | ||
6381 | |||
6382 | ; | ||
6383 | finally { | ||
6384 | restoreStackSize(stackSize); | ||
6385 | } | ||
6386 | |||
6387 | |||
6388 | |||
6389 | |||
6390 | |||
6391 | |||
6392 | |||
6393 | |||
6394 | rule__ALSDirectProduct__Group__0 | ||
6395 | @init { | ||
6396 | int stackSize = keepStackSize(); | ||
6397 | } | ||
6398 | : | ||
6399 | rule__ALSDirectProduct__Group__0__Impl | ||
6400 | rule__ALSDirectProduct__Group__1 | ||
6401 | ; | ||
6402 | finally { | ||
6403 | restoreStackSize(stackSize); | ||
6404 | } | ||
6405 | |||
6406 | rule__ALSDirectProduct__Group__0__Impl | ||
6407 | @init { | ||
6408 | int stackSize = keepStackSize(); | ||
6409 | } | ||
6410 | : | ||
6411 | ( | ||
6412 | { before(grammarAccess.getALSDirectProductAccess().getALSPreficedParserRuleCall_0()); } | ||
6413 | ruleALSPreficed | ||
6414 | { after(grammarAccess.getALSDirectProductAccess().getALSPreficedParserRuleCall_0()); } | ||
6415 | ) | ||
6416 | |||
6417 | ; | ||
6418 | finally { | ||
6419 | restoreStackSize(stackSize); | ||
6420 | } | ||
6421 | |||
6422 | |||
6423 | rule__ALSDirectProduct__Group__1 | ||
6424 | @init { | ||
6425 | int stackSize = keepStackSize(); | ||
6426 | } | ||
6427 | : | ||
6428 | rule__ALSDirectProduct__Group__1__Impl | ||
6429 | ; | ||
6430 | finally { | ||
6431 | restoreStackSize(stackSize); | ||
6432 | } | ||
6433 | |||
6434 | rule__ALSDirectProduct__Group__1__Impl | ||
6435 | @init { | ||
6436 | int stackSize = keepStackSize(); | ||
6437 | } | ||
6438 | : | ||
6439 | ( | ||
6440 | { before(grammarAccess.getALSDirectProductAccess().getGroup_1()); } | ||
6441 | (rule__ALSDirectProduct__Group_1__0)? | ||
6442 | { after(grammarAccess.getALSDirectProductAccess().getGroup_1()); } | ||
6443 | ) | ||
6444 | |||
6445 | ; | ||
6446 | finally { | ||
6447 | restoreStackSize(stackSize); | ||
6448 | } | ||
6449 | |||
6450 | |||
6451 | |||
6452 | |||
6453 | |||
6454 | |||
6455 | rule__ALSDirectProduct__Group_1__0 | ||
6456 | @init { | ||
6457 | int stackSize = keepStackSize(); | ||
6458 | } | ||
6459 | : | ||
6460 | rule__ALSDirectProduct__Group_1__0__Impl | ||
6461 | rule__ALSDirectProduct__Group_1__1 | ||
6462 | ; | ||
6463 | finally { | ||
6464 | restoreStackSize(stackSize); | ||
6465 | } | ||
6466 | |||
6467 | rule__ALSDirectProduct__Group_1__0__Impl | ||
6468 | @init { | ||
6469 | int stackSize = keepStackSize(); | ||
6470 | } | ||
6471 | : | ||
6472 | ( | ||
6473 | { before(grammarAccess.getALSDirectProductAccess().getALSDirectProductLeftOperandAction_1_0()); } | ||
6474 | ( | ||
6475 | |||
6476 | ) | ||
6477 | { after(grammarAccess.getALSDirectProductAccess().getALSDirectProductLeftOperandAction_1_0()); } | ||
6478 | ) | ||
6479 | |||
6480 | ; | ||
6481 | finally { | ||
6482 | restoreStackSize(stackSize); | ||
6483 | } | ||
6484 | |||
6485 | |||
6486 | rule__ALSDirectProduct__Group_1__1 | ||
6487 | @init { | ||
6488 | int stackSize = keepStackSize(); | ||
6489 | } | ||
6490 | : | ||
6491 | rule__ALSDirectProduct__Group_1__1__Impl | ||
6492 | rule__ALSDirectProduct__Group_1__2 | ||
6493 | ; | ||
6494 | finally { | ||
6495 | restoreStackSize(stackSize); | ||
6496 | } | ||
6497 | |||
6498 | rule__ALSDirectProduct__Group_1__1__Impl | ||
6499 | @init { | ||
6500 | int stackSize = keepStackSize(); | ||
6501 | } | ||
6502 | : | ||
6503 | ( | ||
6504 | { before(grammarAccess.getALSDirectProductAccess().getLeftMultiplicitAssignment_1_1()); } | ||
6505 | (rule__ALSDirectProduct__LeftMultiplicitAssignment_1_1)? | ||
6506 | { after(grammarAccess.getALSDirectProductAccess().getLeftMultiplicitAssignment_1_1()); } | ||
6507 | ) | ||
6508 | |||
6509 | ; | ||
6510 | finally { | ||
6511 | restoreStackSize(stackSize); | ||
6512 | } | ||
6513 | |||
6514 | |||
6515 | rule__ALSDirectProduct__Group_1__2 | ||
6516 | @init { | ||
6517 | int stackSize = keepStackSize(); | ||
6518 | } | ||
6519 | : | ||
6520 | rule__ALSDirectProduct__Group_1__2__Impl | ||
6521 | rule__ALSDirectProduct__Group_1__3 | ||
6522 | ; | ||
6523 | finally { | ||
6524 | restoreStackSize(stackSize); | ||
6525 | } | ||
6526 | |||
6527 | rule__ALSDirectProduct__Group_1__2__Impl | ||
6528 | @init { | ||
6529 | int stackSize = keepStackSize(); | ||
6530 | } | ||
6531 | : | ||
6532 | ( | ||
6533 | { before(grammarAccess.getALSDirectProductAccess().getHyphenMinusGreaterThanSignKeyword_1_2()); } | ||
6534 | |||
6535 | '->' | ||
6536 | |||
6537 | { after(grammarAccess.getALSDirectProductAccess().getHyphenMinusGreaterThanSignKeyword_1_2()); } | ||
6538 | ) | ||
6539 | |||
6540 | ; | ||
6541 | finally { | ||
6542 | restoreStackSize(stackSize); | ||
6543 | } | ||
6544 | |||
6545 | |||
6546 | rule__ALSDirectProduct__Group_1__3 | ||
6547 | @init { | ||
6548 | int stackSize = keepStackSize(); | ||
6549 | } | ||
6550 | : | ||
6551 | rule__ALSDirectProduct__Group_1__3__Impl | ||
6552 | rule__ALSDirectProduct__Group_1__4 | ||
6553 | ; | ||
6554 | finally { | ||
6555 | restoreStackSize(stackSize); | ||
6556 | } | ||
6557 | |||
6558 | rule__ALSDirectProduct__Group_1__3__Impl | ||
6559 | @init { | ||
6560 | int stackSize = keepStackSize(); | ||
6561 | } | ||
6562 | : | ||
6563 | ( | ||
6564 | { before(grammarAccess.getALSDirectProductAccess().getRightMultiplicitAssignment_1_3()); } | ||
6565 | (rule__ALSDirectProduct__RightMultiplicitAssignment_1_3)? | ||
6566 | { after(grammarAccess.getALSDirectProductAccess().getRightMultiplicitAssignment_1_3()); } | ||
6567 | ) | ||
6568 | |||
6569 | ; | ||
6570 | finally { | ||
6571 | restoreStackSize(stackSize); | ||
6572 | } | ||
6573 | |||
6574 | |||
6575 | rule__ALSDirectProduct__Group_1__4 | ||
6576 | @init { | ||
6577 | int stackSize = keepStackSize(); | ||
6578 | } | ||
6579 | : | ||
6580 | rule__ALSDirectProduct__Group_1__4__Impl | ||
6581 | ; | ||
6582 | finally { | ||
6583 | restoreStackSize(stackSize); | ||
6584 | } | ||
6585 | |||
6586 | rule__ALSDirectProduct__Group_1__4__Impl | ||
6587 | @init { | ||
6588 | int stackSize = keepStackSize(); | ||
6589 | } | ||
6590 | : | ||
6591 | ( | ||
6592 | { before(grammarAccess.getALSDirectProductAccess().getRightOperandAssignment_1_4()); } | ||
6593 | (rule__ALSDirectProduct__RightOperandAssignment_1_4) | ||
6594 | { after(grammarAccess.getALSDirectProductAccess().getRightOperandAssignment_1_4()); } | ||
6595 | ) | ||
6596 | |||
6597 | ; | ||
6598 | finally { | ||
6599 | restoreStackSize(stackSize); | ||
6600 | } | ||
6601 | |||
6602 | |||
6603 | |||
6604 | |||
6605 | |||
6606 | |||
6607 | |||
6608 | |||
6609 | |||
6610 | |||
6611 | |||
6612 | |||
6613 | rule__ALSPreficed__Group_0__0 | ||
6614 | @init { | ||
6615 | int stackSize = keepStackSize(); | ||
6616 | } | ||
6617 | : | ||
6618 | rule__ALSPreficed__Group_0__0__Impl | ||
6619 | rule__ALSPreficed__Group_0__1 | ||
6620 | ; | ||
6621 | finally { | ||
6622 | restoreStackSize(stackSize); | ||
6623 | } | ||
6624 | |||
6625 | rule__ALSPreficed__Group_0__0__Impl | ||
6626 | @init { | ||
6627 | int stackSize = keepStackSize(); | ||
6628 | } | ||
6629 | : | ||
6630 | ( | ||
6631 | { before(grammarAccess.getALSPreficedAccess().getALSNotAction_0_0()); } | ||
6632 | ( | ||
6633 | |||
6634 | ) | ||
6635 | { after(grammarAccess.getALSPreficedAccess().getALSNotAction_0_0()); } | ||
6636 | ) | ||
6637 | |||
6638 | ; | ||
6639 | finally { | ||
6640 | restoreStackSize(stackSize); | ||
6641 | } | ||
6642 | |||
6643 | |||
6644 | rule__ALSPreficed__Group_0__1 | ||
6645 | @init { | ||
6646 | int stackSize = keepStackSize(); | ||
6647 | } | ||
6648 | : | ||
6649 | rule__ALSPreficed__Group_0__1__Impl | ||
6650 | rule__ALSPreficed__Group_0__2 | ||
6651 | ; | ||
6652 | finally { | ||
6653 | restoreStackSize(stackSize); | ||
6654 | } | ||
6655 | |||
6656 | rule__ALSPreficed__Group_0__1__Impl | ||
6657 | @init { | ||
6658 | int stackSize = keepStackSize(); | ||
6659 | } | ||
6660 | : | ||
6661 | ( | ||
6662 | { before(grammarAccess.getALSPreficedAccess().getGroup_0_1()); } | ||
6663 | (rule__ALSPreficed__Group_0_1__0) | ||
6664 | { after(grammarAccess.getALSPreficedAccess().getGroup_0_1()); } | ||
6665 | ) | ||
6666 | |||
6667 | ; | ||
6668 | finally { | ||
6669 | restoreStackSize(stackSize); | ||
6670 | } | ||
6671 | |||
6672 | |||
6673 | rule__ALSPreficed__Group_0__2 | ||
6674 | @init { | ||
6675 | int stackSize = keepStackSize(); | ||
6676 | } | ||
6677 | : | ||
6678 | rule__ALSPreficed__Group_0__2__Impl | ||
6679 | ; | ||
6680 | finally { | ||
6681 | restoreStackSize(stackSize); | ||
6682 | } | ||
6683 | |||
6684 | rule__ALSPreficed__Group_0__2__Impl | ||
6685 | @init { | ||
6686 | int stackSize = keepStackSize(); | ||
6687 | } | ||
6688 | : | ||
6689 | ( | ||
6690 | { before(grammarAccess.getALSPreficedAccess().getOperandAssignment_0_2()); } | ||
6691 | (rule__ALSPreficed__OperandAssignment_0_2) | ||
6692 | { after(grammarAccess.getALSPreficedAccess().getOperandAssignment_0_2()); } | ||
6693 | ) | ||
6694 | |||
6695 | ; | ||
6696 | finally { | ||
6697 | restoreStackSize(stackSize); | ||
6698 | } | ||
6699 | |||
6700 | |||
6701 | |||
6702 | |||
6703 | |||
6704 | |||
6705 | |||
6706 | |||
6707 | rule__ALSPreficed__Group_0_1__0 | ||
6708 | @init { | ||
6709 | int stackSize = keepStackSize(); | ||
6710 | } | ||
6711 | : | ||
6712 | rule__ALSPreficed__Group_0_1__0__Impl | ||
6713 | ; | ||
6714 | finally { | ||
6715 | restoreStackSize(stackSize); | ||
6716 | } | ||
6717 | |||
6718 | rule__ALSPreficed__Group_0_1__0__Impl | ||
6719 | @init { | ||
6720 | int stackSize = keepStackSize(); | ||
6721 | } | ||
6722 | : | ||
6723 | ( | ||
6724 | { before(grammarAccess.getALSPreficedAccess().getAlternatives_0_1_0()); } | ||
6725 | (rule__ALSPreficed__Alternatives_0_1_0) | ||
6726 | { after(grammarAccess.getALSPreficedAccess().getAlternatives_0_1_0()); } | ||
6727 | ) | ||
6728 | |||
6729 | ; | ||
6730 | finally { | ||
6731 | restoreStackSize(stackSize); | ||
6732 | } | ||
6733 | |||
6734 | |||
6735 | |||
6736 | |||
6737 | rule__ALSPreficed__Group_1__0 | ||
6738 | @init { | ||
6739 | int stackSize = keepStackSize(); | ||
6740 | } | ||
6741 | : | ||
6742 | rule__ALSPreficed__Group_1__0__Impl | ||
6743 | rule__ALSPreficed__Group_1__1 | ||
6744 | ; | ||
6745 | finally { | ||
6746 | restoreStackSize(stackSize); | ||
6747 | } | ||
6748 | |||
6749 | rule__ALSPreficed__Group_1__0__Impl | ||
6750 | @init { | ||
6751 | int stackSize = keepStackSize(); | ||
6752 | } | ||
6753 | : | ||
6754 | ( | ||
6755 | { before(grammarAccess.getALSPreficedAccess().getALSInverseRelationAction_1_0()); } | ||
6756 | ( | ||
6757 | |||
6758 | ) | ||
6759 | { after(grammarAccess.getALSPreficedAccess().getALSInverseRelationAction_1_0()); } | ||
6760 | ) | ||
6761 | |||
6762 | ; | ||
6763 | finally { | ||
6764 | restoreStackSize(stackSize); | ||
6765 | } | ||
6766 | |||
6767 | |||
6768 | rule__ALSPreficed__Group_1__1 | ||
6769 | @init { | ||
6770 | int stackSize = keepStackSize(); | ||
6771 | } | ||
6772 | : | ||
6773 | rule__ALSPreficed__Group_1__1__Impl | ||
6774 | rule__ALSPreficed__Group_1__2 | ||
6775 | ; | ||
6776 | finally { | ||
6777 | restoreStackSize(stackSize); | ||
6778 | } | ||
6779 | |||
6780 | rule__ALSPreficed__Group_1__1__Impl | ||
6781 | @init { | ||
6782 | int stackSize = keepStackSize(); | ||
6783 | } | ||
6784 | : | ||
6785 | ( | ||
6786 | { before(grammarAccess.getALSPreficedAccess().getTildeKeyword_1_1()); } | ||
6787 | ( | ||
6788 | '~' | ||
6789 | ) | ||
6790 | { after(grammarAccess.getALSPreficedAccess().getTildeKeyword_1_1()); } | ||
6791 | ) | ||
6792 | |||
6793 | ; | ||
6794 | finally { | ||
6795 | restoreStackSize(stackSize); | ||
6796 | } | ||
6797 | |||
6798 | |||
6799 | rule__ALSPreficed__Group_1__2 | ||
6800 | @init { | ||
6801 | int stackSize = keepStackSize(); | ||
6802 | } | ||
6803 | : | ||
6804 | rule__ALSPreficed__Group_1__2__Impl | ||
6805 | ; | ||
6806 | finally { | ||
6807 | restoreStackSize(stackSize); | ||
6808 | } | ||
6809 | |||
6810 | rule__ALSPreficed__Group_1__2__Impl | ||
6811 | @init { | ||
6812 | int stackSize = keepStackSize(); | ||
6813 | } | ||
6814 | : | ||
6815 | ( | ||
6816 | { before(grammarAccess.getALSPreficedAccess().getOperandAssignment_1_2()); } | ||
6817 | (rule__ALSPreficed__OperandAssignment_1_2) | ||
6818 | { after(grammarAccess.getALSPreficedAccess().getOperandAssignment_1_2()); } | ||
6819 | ) | ||
6820 | |||
6821 | ; | ||
6822 | finally { | ||
6823 | restoreStackSize(stackSize); | ||
6824 | } | ||
6825 | |||
6826 | |||
6827 | |||
6828 | |||
6829 | |||
6830 | |||
6831 | |||
6832 | |||
6833 | rule__ALSPreficed__Group_2__0 | ||
6834 | @init { | ||
6835 | int stackSize = keepStackSize(); | ||
6836 | } | ||
6837 | : | ||
6838 | rule__ALSPreficed__Group_2__0__Impl | ||
6839 | rule__ALSPreficed__Group_2__1 | ||
6840 | ; | ||
6841 | finally { | ||
6842 | restoreStackSize(stackSize); | ||
6843 | } | ||
6844 | |||
6845 | rule__ALSPreficed__Group_2__0__Impl | ||
6846 | @init { | ||
6847 | int stackSize = keepStackSize(); | ||
6848 | } | ||
6849 | : | ||
6850 | ( | ||
6851 | { before(grammarAccess.getALSPreficedAccess().getAlSTransitiveClosureAction_2_0()); } | ||
6852 | ( | ||
6853 | |||
6854 | ) | ||
6855 | { after(grammarAccess.getALSPreficedAccess().getAlSTransitiveClosureAction_2_0()); } | ||
6856 | ) | ||
6857 | |||
6858 | ; | ||
6859 | finally { | ||
6860 | restoreStackSize(stackSize); | ||
6861 | } | ||
6862 | |||
6863 | |||
6864 | rule__ALSPreficed__Group_2__1 | ||
6865 | @init { | ||
6866 | int stackSize = keepStackSize(); | ||
6867 | } | ||
6868 | : | ||
6869 | rule__ALSPreficed__Group_2__1__Impl | ||
6870 | rule__ALSPreficed__Group_2__2 | ||
6871 | ; | ||
6872 | finally { | ||
6873 | restoreStackSize(stackSize); | ||
6874 | } | ||
6875 | |||
6876 | rule__ALSPreficed__Group_2__1__Impl | ||
6877 | @init { | ||
6878 | int stackSize = keepStackSize(); | ||
6879 | } | ||
6880 | : | ||
6881 | ( | ||
6882 | { before(grammarAccess.getALSPreficedAccess().getCircumflexAccentKeyword_2_1()); } | ||
6883 | |||
6884 | '^' | ||
6885 | |||
6886 | { after(grammarAccess.getALSPreficedAccess().getCircumflexAccentKeyword_2_1()); } | ||
6887 | ) | ||
6888 | |||
6889 | ; | ||
6890 | finally { | ||
6891 | restoreStackSize(stackSize); | ||
6892 | } | ||
6893 | |||
6894 | |||
6895 | rule__ALSPreficed__Group_2__2 | ||
6896 | @init { | ||
6897 | int stackSize = keepStackSize(); | ||
6898 | } | ||
6899 | : | ||
6900 | rule__ALSPreficed__Group_2__2__Impl | ||
6901 | ; | ||
6902 | finally { | ||
6903 | restoreStackSize(stackSize); | ||
6904 | } | ||
6905 | |||
6906 | rule__ALSPreficed__Group_2__2__Impl | ||
6907 | @init { | ||
6908 | int stackSize = keepStackSize(); | ||
6909 | } | ||
6910 | : | ||
6911 | ( | ||
6912 | { before(grammarAccess.getALSPreficedAccess().getOperandAssignment_2_2()); } | ||
6913 | (rule__ALSPreficed__OperandAssignment_2_2) | ||
6914 | { after(grammarAccess.getALSPreficedAccess().getOperandAssignment_2_2()); } | ||
6915 | ) | ||
6916 | |||
6917 | ; | ||
6918 | finally { | ||
6919 | restoreStackSize(stackSize); | ||
6920 | } | ||
6921 | |||
6922 | |||
6923 | |||
6924 | |||
6925 | |||
6926 | |||
6927 | |||
6928 | |||
6929 | rule__ALSPreficed__Group_3__0 | ||
6930 | @init { | ||
6931 | int stackSize = keepStackSize(); | ||
6932 | } | ||
6933 | : | ||
6934 | rule__ALSPreficed__Group_3__0__Impl | ||
6935 | rule__ALSPreficed__Group_3__1 | ||
6936 | ; | ||
6937 | finally { | ||
6938 | restoreStackSize(stackSize); | ||
6939 | } | ||
6940 | |||
6941 | rule__ALSPreficed__Group_3__0__Impl | ||
6942 | @init { | ||
6943 | int stackSize = keepStackSize(); | ||
6944 | } | ||
6945 | : | ||
6946 | ( | ||
6947 | { before(grammarAccess.getALSPreficedAccess().getALSReflectiveTransitiveClosureAction_3_0()); } | ||
6948 | ( | ||
6949 | |||
6950 | ) | ||
6951 | { after(grammarAccess.getALSPreficedAccess().getALSReflectiveTransitiveClosureAction_3_0()); } | ||
6952 | ) | ||
6953 | |||
6954 | ; | ||
6955 | finally { | ||
6956 | restoreStackSize(stackSize); | ||
6957 | } | ||
6958 | |||
6959 | |||
6960 | rule__ALSPreficed__Group_3__1 | ||
6961 | @init { | ||
6962 | int stackSize = keepStackSize(); | ||
6963 | } | ||
6964 | : | ||
6965 | rule__ALSPreficed__Group_3__1__Impl | ||
6966 | rule__ALSPreficed__Group_3__2 | ||
6967 | ; | ||
6968 | finally { | ||
6969 | restoreStackSize(stackSize); | ||
6970 | } | ||
6971 | |||
6972 | rule__ALSPreficed__Group_3__1__Impl | ||
6973 | @init { | ||
6974 | int stackSize = keepStackSize(); | ||
6975 | } | ||
6976 | : | ||
6977 | ( | ||
6978 | { before(grammarAccess.getALSPreficedAccess().getAsteriskKeyword_3_1()); } | ||
6979 | |||
6980 | '*' | ||
6981 | |||
6982 | { after(grammarAccess.getALSPreficedAccess().getAsteriskKeyword_3_1()); } | ||
6983 | ) | ||
6984 | |||
6985 | ; | ||
6986 | finally { | ||
6987 | restoreStackSize(stackSize); | ||
6988 | } | ||
6989 | |||
6990 | |||
6991 | rule__ALSPreficed__Group_3__2 | ||
6992 | @init { | ||
6993 | int stackSize = keepStackSize(); | ||
6994 | } | ||
6995 | : | ||
6996 | rule__ALSPreficed__Group_3__2__Impl | ||
6997 | ; | ||
6998 | finally { | ||
6999 | restoreStackSize(stackSize); | ||
7000 | } | ||
7001 | |||
7002 | rule__ALSPreficed__Group_3__2__Impl | ||
7003 | @init { | ||
7004 | int stackSize = keepStackSize(); | ||
7005 | } | ||
7006 | : | ||
7007 | ( | ||
7008 | { before(grammarAccess.getALSPreficedAccess().getOperandAssignment_3_2()); } | ||
7009 | (rule__ALSPreficed__OperandAssignment_3_2) | ||
7010 | { after(grammarAccess.getALSPreficedAccess().getOperandAssignment_3_2()); } | ||
7011 | ) | ||
7012 | |||
7013 | ; | ||
7014 | finally { | ||
7015 | restoreStackSize(stackSize); | ||
7016 | } | ||
7017 | |||
7018 | |||
7019 | |||
7020 | |||
7021 | |||
7022 | |||
7023 | |||
7024 | |||
7025 | rule__ALSPreficed__Group_4__0 | ||
7026 | @init { | ||
7027 | int stackSize = keepStackSize(); | ||
7028 | } | ||
7029 | : | ||
7030 | rule__ALSPreficed__Group_4__0__Impl | ||
7031 | rule__ALSPreficed__Group_4__1 | ||
7032 | ; | ||
7033 | finally { | ||
7034 | restoreStackSize(stackSize); | ||
7035 | } | ||
7036 | |||
7037 | rule__ALSPreficed__Group_4__0__Impl | ||
7038 | @init { | ||
7039 | int stackSize = keepStackSize(); | ||
7040 | } | ||
7041 | : | ||
7042 | ( | ||
7043 | { before(grammarAccess.getALSPreficedAccess().getALSCardinalityAction_4_0()); } | ||
7044 | ( | ||
7045 | |||
7046 | ) | ||
7047 | { after(grammarAccess.getALSPreficedAccess().getALSCardinalityAction_4_0()); } | ||
7048 | ) | ||
7049 | |||
7050 | ; | ||
7051 | finally { | ||
7052 | restoreStackSize(stackSize); | ||
7053 | } | ||
7054 | |||
7055 | |||
7056 | rule__ALSPreficed__Group_4__1 | ||
7057 | @init { | ||
7058 | int stackSize = keepStackSize(); | ||
7059 | } | ||
7060 | : | ||
7061 | rule__ALSPreficed__Group_4__1__Impl | ||
7062 | rule__ALSPreficed__Group_4__2 | ||
7063 | ; | ||
7064 | finally { | ||
7065 | restoreStackSize(stackSize); | ||
7066 | } | ||
7067 | |||
7068 | rule__ALSPreficed__Group_4__1__Impl | ||
7069 | @init { | ||
7070 | int stackSize = keepStackSize(); | ||
7071 | } | ||
7072 | : | ||
7073 | ( | ||
7074 | { before(grammarAccess.getALSPreficedAccess().getNumberSignKeyword_4_1()); } | ||
7075 | |||
7076 | '#' | ||
7077 | |||
7078 | { after(grammarAccess.getALSPreficedAccess().getNumberSignKeyword_4_1()); } | ||
7079 | ) | ||
7080 | |||
7081 | ; | ||
7082 | finally { | ||
7083 | restoreStackSize(stackSize); | ||
7084 | } | ||
7085 | |||
7086 | |||
7087 | rule__ALSPreficed__Group_4__2 | ||
7088 | @init { | ||
7089 | int stackSize = keepStackSize(); | ||
7090 | } | ||
7091 | : | ||
7092 | rule__ALSPreficed__Group_4__2__Impl | ||
7093 | ; | ||
7094 | finally { | ||
7095 | restoreStackSize(stackSize); | ||
7096 | } | ||
7097 | |||
7098 | rule__ALSPreficed__Group_4__2__Impl | ||
7099 | @init { | ||
7100 | int stackSize = keepStackSize(); | ||
7101 | } | ||
7102 | : | ||
7103 | ( | ||
7104 | { before(grammarAccess.getALSPreficedAccess().getOperandAssignment_4_2()); } | ||
7105 | (rule__ALSPreficed__OperandAssignment_4_2) | ||
7106 | { after(grammarAccess.getALSPreficedAccess().getOperandAssignment_4_2()); } | ||
7107 | ) | ||
7108 | |||
7109 | ; | ||
7110 | finally { | ||
7111 | restoreStackSize(stackSize); | ||
7112 | } | ||
7113 | |||
7114 | |||
7115 | |||
7116 | |||
7117 | |||
7118 | |||
7119 | |||
7120 | |||
7121 | rule__ALSPreficed__Group_5__0 | ||
7122 | @init { | ||
7123 | int stackSize = keepStackSize(); | ||
7124 | } | ||
7125 | : | ||
7126 | rule__ALSPreficed__Group_5__0__Impl | ||
7127 | rule__ALSPreficed__Group_5__1 | ||
7128 | ; | ||
7129 | finally { | ||
7130 | restoreStackSize(stackSize); | ||
7131 | } | ||
7132 | |||
7133 | rule__ALSPreficed__Group_5__0__Impl | ||
7134 | @init { | ||
7135 | int stackSize = keepStackSize(); | ||
7136 | } | ||
7137 | : | ||
7138 | ( | ||
7139 | { before(grammarAccess.getALSPreficedAccess().getALSUnaryMinusAction_5_0()); } | ||
7140 | ( | ||
7141 | |||
7142 | ) | ||
7143 | { after(grammarAccess.getALSPreficedAccess().getALSUnaryMinusAction_5_0()); } | ||
7144 | ) | ||
7145 | |||
7146 | ; | ||
7147 | finally { | ||
7148 | restoreStackSize(stackSize); | ||
7149 | } | ||
7150 | |||
7151 | |||
7152 | rule__ALSPreficed__Group_5__1 | ||
7153 | @init { | ||
7154 | int stackSize = keepStackSize(); | ||
7155 | } | ||
7156 | : | ||
7157 | rule__ALSPreficed__Group_5__1__Impl | ||
7158 | rule__ALSPreficed__Group_5__2 | ||
7159 | ; | ||
7160 | finally { | ||
7161 | restoreStackSize(stackSize); | ||
7162 | } | ||
7163 | |||
7164 | rule__ALSPreficed__Group_5__1__Impl | ||
7165 | @init { | ||
7166 | int stackSize = keepStackSize(); | ||
7167 | } | ||
7168 | : | ||
7169 | ( | ||
7170 | { before(grammarAccess.getALSPreficedAccess().getHyphenMinusKeyword_5_1()); } | ||
7171 | ( | ||
7172 | '-' | ||
7173 | ) | ||
7174 | { after(grammarAccess.getALSPreficedAccess().getHyphenMinusKeyword_5_1()); } | ||
7175 | ) | ||
7176 | |||
7177 | ; | ||
7178 | finally { | ||
7179 | restoreStackSize(stackSize); | ||
7180 | } | ||
7181 | |||
7182 | |||
7183 | rule__ALSPreficed__Group_5__2 | ||
7184 | @init { | ||
7185 | int stackSize = keepStackSize(); | ||
7186 | } | ||
7187 | : | ||
7188 | rule__ALSPreficed__Group_5__2__Impl | ||
7189 | ; | ||
7190 | finally { | ||
7191 | restoreStackSize(stackSize); | ||
7192 | } | ||
7193 | |||
7194 | rule__ALSPreficed__Group_5__2__Impl | ||
7195 | @init { | ||
7196 | int stackSize = keepStackSize(); | ||
7197 | } | ||
7198 | : | ||
7199 | ( | ||
7200 | { before(grammarAccess.getALSPreficedAccess().getOperandAssignment_5_2()); } | ||
7201 | (rule__ALSPreficed__OperandAssignment_5_2) | ||
7202 | { after(grammarAccess.getALSPreficedAccess().getOperandAssignment_5_2()); } | ||
7203 | ) | ||
7204 | |||
7205 | ; | ||
7206 | finally { | ||
7207 | restoreStackSize(stackSize); | ||
7208 | } | ||
7209 | |||
7210 | |||
7211 | |||
7212 | |||
7213 | |||
7214 | |||
7215 | |||
7216 | |||
7217 | rule__ALSPreficed__Group_6__0 | ||
7218 | @init { | ||
7219 | int stackSize = keepStackSize(); | ||
7220 | } | ||
7221 | : | ||
7222 | rule__ALSPreficed__Group_6__0__Impl | ||
7223 | rule__ALSPreficed__Group_6__1 | ||
7224 | ; | ||
7225 | finally { | ||
7226 | restoreStackSize(stackSize); | ||
7227 | } | ||
7228 | |||
7229 | rule__ALSPreficed__Group_6__0__Impl | ||
7230 | @init { | ||
7231 | int stackSize = keepStackSize(); | ||
7232 | } | ||
7233 | : | ||
7234 | ( | ||
7235 | { before(grammarAccess.getALSPreficedAccess().getALSSumAction_6_0()); } | ||
7236 | ( | ||
7237 | |||
7238 | ) | ||
7239 | { after(grammarAccess.getALSPreficedAccess().getALSSumAction_6_0()); } | ||
7240 | ) | ||
7241 | |||
7242 | ; | ||
7243 | finally { | ||
7244 | restoreStackSize(stackSize); | ||
7245 | } | ||
7246 | |||
7247 | |||
7248 | rule__ALSPreficed__Group_6__1 | ||
7249 | @init { | ||
7250 | int stackSize = keepStackSize(); | ||
7251 | } | ||
7252 | : | ||
7253 | rule__ALSPreficed__Group_6__1__Impl | ||
7254 | rule__ALSPreficed__Group_6__2 | ||
7255 | ; | ||
7256 | finally { | ||
7257 | restoreStackSize(stackSize); | ||
7258 | } | ||
7259 | |||
7260 | rule__ALSPreficed__Group_6__1__Impl | ||
7261 | @init { | ||
7262 | int stackSize = keepStackSize(); | ||
7263 | } | ||
7264 | : | ||
7265 | ( | ||
7266 | { before(grammarAccess.getALSPreficedAccess().getSumKeyword_6_1()); } | ||
7267 | |||
7268 | 'sum' | ||
7269 | |||
7270 | { after(grammarAccess.getALSPreficedAccess().getSumKeyword_6_1()); } | ||
7271 | ) | ||
7272 | |||
7273 | ; | ||
7274 | finally { | ||
7275 | restoreStackSize(stackSize); | ||
7276 | } | ||
7277 | |||
7278 | |||
7279 | rule__ALSPreficed__Group_6__2 | ||
7280 | @init { | ||
7281 | int stackSize = keepStackSize(); | ||
7282 | } | ||
7283 | : | ||
7284 | rule__ALSPreficed__Group_6__2__Impl | ||
7285 | rule__ALSPreficed__Group_6__3 | ||
7286 | ; | ||
7287 | finally { | ||
7288 | restoreStackSize(stackSize); | ||
7289 | } | ||
7290 | |||
7291 | rule__ALSPreficed__Group_6__2__Impl | ||
7292 | @init { | ||
7293 | int stackSize = keepStackSize(); | ||
7294 | } | ||
7295 | : | ||
7296 | ( | ||
7297 | { before(grammarAccess.getALSPreficedAccess().getVariablesAssignment_6_2()); } | ||
7298 | (rule__ALSPreficed__VariablesAssignment_6_2) | ||
7299 | { after(grammarAccess.getALSPreficedAccess().getVariablesAssignment_6_2()); } | ||
7300 | ) | ||
7301 | |||
7302 | ; | ||
7303 | finally { | ||
7304 | restoreStackSize(stackSize); | ||
7305 | } | ||
7306 | |||
7307 | |||
7308 | rule__ALSPreficed__Group_6__3 | ||
7309 | @init { | ||
7310 | int stackSize = keepStackSize(); | ||
7311 | } | ||
7312 | : | ||
7313 | rule__ALSPreficed__Group_6__3__Impl | ||
7314 | rule__ALSPreficed__Group_6__4 | ||
7315 | ; | ||
7316 | finally { | ||
7317 | restoreStackSize(stackSize); | ||
7318 | } | ||
7319 | |||
7320 | rule__ALSPreficed__Group_6__3__Impl | ||
7321 | @init { | ||
7322 | int stackSize = keepStackSize(); | ||
7323 | } | ||
7324 | : | ||
7325 | ( | ||
7326 | { before(grammarAccess.getALSPreficedAccess().getGroup_6_3()); } | ||
7327 | (rule__ALSPreficed__Group_6_3__0)* | ||
7328 | { after(grammarAccess.getALSPreficedAccess().getGroup_6_3()); } | ||
7329 | ) | ||
7330 | |||
7331 | ; | ||
7332 | finally { | ||
7333 | restoreStackSize(stackSize); | ||
7334 | } | ||
7335 | |||
7336 | |||
7337 | rule__ALSPreficed__Group_6__4 | ||
7338 | @init { | ||
7339 | int stackSize = keepStackSize(); | ||
7340 | } | ||
7341 | : | ||
7342 | rule__ALSPreficed__Group_6__4__Impl | ||
7343 | rule__ALSPreficed__Group_6__5 | ||
7344 | ; | ||
7345 | finally { | ||
7346 | restoreStackSize(stackSize); | ||
7347 | } | ||
7348 | |||
7349 | rule__ALSPreficed__Group_6__4__Impl | ||
7350 | @init { | ||
7351 | int stackSize = keepStackSize(); | ||
7352 | } | ||
7353 | : | ||
7354 | ( | ||
7355 | { before(grammarAccess.getALSPreficedAccess().getLeftCurlyBracketKeyword_6_4()); } | ||
7356 | |||
7357 | '{' | ||
7358 | |||
7359 | { after(grammarAccess.getALSPreficedAccess().getLeftCurlyBracketKeyword_6_4()); } | ||
7360 | ) | ||
7361 | |||
7362 | ; | ||
7363 | finally { | ||
7364 | restoreStackSize(stackSize); | ||
7365 | } | ||
7366 | |||
7367 | |||
7368 | rule__ALSPreficed__Group_6__5 | ||
7369 | @init { | ||
7370 | int stackSize = keepStackSize(); | ||
7371 | } | ||
7372 | : | ||
7373 | rule__ALSPreficed__Group_6__5__Impl | ||
7374 | rule__ALSPreficed__Group_6__6 | ||
7375 | ; | ||
7376 | finally { | ||
7377 | restoreStackSize(stackSize); | ||
7378 | } | ||
7379 | |||
7380 | rule__ALSPreficed__Group_6__5__Impl | ||
7381 | @init { | ||
7382 | int stackSize = keepStackSize(); | ||
7383 | } | ||
7384 | : | ||
7385 | ( | ||
7386 | { before(grammarAccess.getALSPreficedAccess().getExpressionAssignment_6_5()); } | ||
7387 | (rule__ALSPreficed__ExpressionAssignment_6_5) | ||
7388 | { after(grammarAccess.getALSPreficedAccess().getExpressionAssignment_6_5()); } | ||
7389 | ) | ||
7390 | |||
7391 | ; | ||
7392 | finally { | ||
7393 | restoreStackSize(stackSize); | ||
7394 | } | ||
7395 | |||
7396 | |||
7397 | rule__ALSPreficed__Group_6__6 | ||
7398 | @init { | ||
7399 | int stackSize = keepStackSize(); | ||
7400 | } | ||
7401 | : | ||
7402 | rule__ALSPreficed__Group_6__6__Impl | ||
7403 | ; | ||
7404 | finally { | ||
7405 | restoreStackSize(stackSize); | ||
7406 | } | ||
7407 | |||
7408 | rule__ALSPreficed__Group_6__6__Impl | ||
7409 | @init { | ||
7410 | int stackSize = keepStackSize(); | ||
7411 | } | ||
7412 | : | ||
7413 | ( | ||
7414 | { before(grammarAccess.getALSPreficedAccess().getRightCurlyBracketKeyword_6_6()); } | ||
7415 | |||
7416 | '}' | ||
7417 | |||
7418 | { after(grammarAccess.getALSPreficedAccess().getRightCurlyBracketKeyword_6_6()); } | ||
7419 | ) | ||
7420 | |||
7421 | ; | ||
7422 | finally { | ||
7423 | restoreStackSize(stackSize); | ||
7424 | } | ||
7425 | |||
7426 | |||
7427 | |||
7428 | |||
7429 | |||
7430 | |||
7431 | |||
7432 | |||
7433 | |||
7434 | |||
7435 | |||
7436 | |||
7437 | |||
7438 | |||
7439 | |||
7440 | |||
7441 | rule__ALSPreficed__Group_6_3__0 | ||
7442 | @init { | ||
7443 | int stackSize = keepStackSize(); | ||
7444 | } | ||
7445 | : | ||
7446 | rule__ALSPreficed__Group_6_3__0__Impl | ||
7447 | rule__ALSPreficed__Group_6_3__1 | ||
7448 | ; | ||
7449 | finally { | ||
7450 | restoreStackSize(stackSize); | ||
7451 | } | ||
7452 | |||
7453 | rule__ALSPreficed__Group_6_3__0__Impl | ||
7454 | @init { | ||
7455 | int stackSize = keepStackSize(); | ||
7456 | } | ||
7457 | : | ||
7458 | ( | ||
7459 | { before(grammarAccess.getALSPreficedAccess().getCommaKeyword_6_3_0()); } | ||
7460 | |||
7461 | ',' | ||
7462 | |||
7463 | { after(grammarAccess.getALSPreficedAccess().getCommaKeyword_6_3_0()); } | ||
7464 | ) | ||
7465 | |||
7466 | ; | ||
7467 | finally { | ||
7468 | restoreStackSize(stackSize); | ||
7469 | } | ||
7470 | |||
7471 | |||
7472 | rule__ALSPreficed__Group_6_3__1 | ||
7473 | @init { | ||
7474 | int stackSize = keepStackSize(); | ||
7475 | } | ||
7476 | : | ||
7477 | rule__ALSPreficed__Group_6_3__1__Impl | ||
7478 | ; | ||
7479 | finally { | ||
7480 | restoreStackSize(stackSize); | ||
7481 | } | ||
7482 | |||
7483 | rule__ALSPreficed__Group_6_3__1__Impl | ||
7484 | @init { | ||
7485 | int stackSize = keepStackSize(); | ||
7486 | } | ||
7487 | : | ||
7488 | ( | ||
7489 | { before(grammarAccess.getALSPreficedAccess().getVariablesAssignment_6_3_1()); } | ||
7490 | (rule__ALSPreficed__VariablesAssignment_6_3_1) | ||
7491 | { after(grammarAccess.getALSPreficedAccess().getVariablesAssignment_6_3_1()); } | ||
7492 | ) | ||
7493 | |||
7494 | ; | ||
7495 | finally { | ||
7496 | restoreStackSize(stackSize); | ||
7497 | } | ||
7498 | |||
7499 | |||
7500 | |||
7501 | |||
7502 | |||
7503 | |||
7504 | rule__ALSPreficed__Group_7__0 | ||
7505 | @init { | ||
7506 | int stackSize = keepStackSize(); | ||
7507 | } | ||
7508 | : | ||
7509 | rule__ALSPreficed__Group_7__0__Impl | ||
7510 | rule__ALSPreficed__Group_7__1 | ||
7511 | ; | ||
7512 | finally { | ||
7513 | restoreStackSize(stackSize); | ||
7514 | } | ||
7515 | |||
7516 | rule__ALSPreficed__Group_7__0__Impl | ||
7517 | @init { | ||
7518 | int stackSize = keepStackSize(); | ||
7519 | } | ||
7520 | : | ||
7521 | ( | ||
7522 | { before(grammarAccess.getALSPreficedAccess().getALSFunctionCallAction_7_0()); } | ||
7523 | ( | ||
7524 | |||
7525 | ) | ||
7526 | { after(grammarAccess.getALSPreficedAccess().getALSFunctionCallAction_7_0()); } | ||
7527 | ) | ||
7528 | |||
7529 | ; | ||
7530 | finally { | ||
7531 | restoreStackSize(stackSize); | ||
7532 | } | ||
7533 | |||
7534 | |||
7535 | rule__ALSPreficed__Group_7__1 | ||
7536 | @init { | ||
7537 | int stackSize = keepStackSize(); | ||
7538 | } | ||
7539 | : | ||
7540 | rule__ALSPreficed__Group_7__1__Impl | ||
7541 | rule__ALSPreficed__Group_7__2 | ||
7542 | ; | ||
7543 | finally { | ||
7544 | restoreStackSize(stackSize); | ||
7545 | } | ||
7546 | |||
7547 | rule__ALSPreficed__Group_7__1__Impl | ||
7548 | @init { | ||
7549 | int stackSize = keepStackSize(); | ||
7550 | } | ||
7551 | : | ||
7552 | ( | ||
7553 | { before(grammarAccess.getALSPreficedAccess().getAlternatives_7_1()); } | ||
7554 | (rule__ALSPreficed__Alternatives_7_1) | ||
7555 | { after(grammarAccess.getALSPreficedAccess().getAlternatives_7_1()); } | ||
7556 | ) | ||
7557 | |||
7558 | ; | ||
7559 | finally { | ||
7560 | restoreStackSize(stackSize); | ||
7561 | } | ||
7562 | |||
7563 | |||
7564 | rule__ALSPreficed__Group_7__2 | ||
7565 | @init { | ||
7566 | int stackSize = keepStackSize(); | ||
7567 | } | ||
7568 | : | ||
7569 | rule__ALSPreficed__Group_7__2__Impl | ||
7570 | rule__ALSPreficed__Group_7__3 | ||
7571 | ; | ||
7572 | finally { | ||
7573 | restoreStackSize(stackSize); | ||
7574 | } | ||
7575 | |||
7576 | rule__ALSPreficed__Group_7__2__Impl | ||
7577 | @init { | ||
7578 | int stackSize = keepStackSize(); | ||
7579 | } | ||
7580 | : | ||
7581 | ( | ||
7582 | { before(grammarAccess.getALSPreficedAccess().getLeftSquareBracketKeyword_7_2()); } | ||
7583 | |||
7584 | '[' | ||
7585 | |||
7586 | { after(grammarAccess.getALSPreficedAccess().getLeftSquareBracketKeyword_7_2()); } | ||
7587 | ) | ||
7588 | |||
7589 | ; | ||
7590 | finally { | ||
7591 | restoreStackSize(stackSize); | ||
7592 | } | ||
7593 | |||
7594 | |||
7595 | rule__ALSPreficed__Group_7__3 | ||
7596 | @init { | ||
7597 | int stackSize = keepStackSize(); | ||
7598 | } | ||
7599 | : | ||
7600 | rule__ALSPreficed__Group_7__3__Impl | ||
7601 | rule__ALSPreficed__Group_7__4 | ||
7602 | ; | ||
7603 | finally { | ||
7604 | restoreStackSize(stackSize); | ||
7605 | } | ||
7606 | |||
7607 | rule__ALSPreficed__Group_7__3__Impl | ||
7608 | @init { | ||
7609 | int stackSize = keepStackSize(); | ||
7610 | } | ||
7611 | : | ||
7612 | ( | ||
7613 | { before(grammarAccess.getALSPreficedAccess().getParamsAssignment_7_3()); } | ||
7614 | (rule__ALSPreficed__ParamsAssignment_7_3) | ||
7615 | { after(grammarAccess.getALSPreficedAccess().getParamsAssignment_7_3()); } | ||
7616 | ) | ||
7617 | |||
7618 | ; | ||
7619 | finally { | ||
7620 | restoreStackSize(stackSize); | ||
7621 | } | ||
7622 | |||
7623 | |||
7624 | rule__ALSPreficed__Group_7__4 | ||
7625 | @init { | ||
7626 | int stackSize = keepStackSize(); | ||
7627 | } | ||
7628 | : | ||
7629 | rule__ALSPreficed__Group_7__4__Impl | ||
7630 | rule__ALSPreficed__Group_7__5 | ||
7631 | ; | ||
7632 | finally { | ||
7633 | restoreStackSize(stackSize); | ||
7634 | } | ||
7635 | |||
7636 | rule__ALSPreficed__Group_7__4__Impl | ||
7637 | @init { | ||
7638 | int stackSize = keepStackSize(); | ||
7639 | } | ||
7640 | : | ||
7641 | ( | ||
7642 | { before(grammarAccess.getALSPreficedAccess().getGroup_7_4()); } | ||
7643 | (rule__ALSPreficed__Group_7_4__0)* | ||
7644 | { after(grammarAccess.getALSPreficedAccess().getGroup_7_4()); } | ||
7645 | ) | ||
7646 | |||
7647 | ; | ||
7648 | finally { | ||
7649 | restoreStackSize(stackSize); | ||
7650 | } | ||
7651 | |||
7652 | |||
7653 | rule__ALSPreficed__Group_7__5 | ||
7654 | @init { | ||
7655 | int stackSize = keepStackSize(); | ||
7656 | } | ||
7657 | : | ||
7658 | rule__ALSPreficed__Group_7__5__Impl | ||
7659 | ; | ||
7660 | finally { | ||
7661 | restoreStackSize(stackSize); | ||
7662 | } | ||
7663 | |||
7664 | rule__ALSPreficed__Group_7__5__Impl | ||
7665 | @init { | ||
7666 | int stackSize = keepStackSize(); | ||
7667 | } | ||
7668 | : | ||
7669 | ( | ||
7670 | { before(grammarAccess.getALSPreficedAccess().getRightSquareBracketKeyword_7_5()); } | ||
7671 | |||
7672 | ']' | ||
7673 | |||
7674 | { after(grammarAccess.getALSPreficedAccess().getRightSquareBracketKeyword_7_5()); } | ||
7675 | ) | ||
7676 | |||
7677 | ; | ||
7678 | finally { | ||
7679 | restoreStackSize(stackSize); | ||
7680 | } | ||
7681 | |||
7682 | |||
7683 | |||
7684 | |||
7685 | |||
7686 | |||
7687 | |||
7688 | |||
7689 | |||
7690 | |||
7691 | |||
7692 | |||
7693 | |||
7694 | |||
7695 | rule__ALSPreficed__Group_7_4__0 | ||
7696 | @init { | ||
7697 | int stackSize = keepStackSize(); | ||
7698 | } | ||
7699 | : | ||
7700 | rule__ALSPreficed__Group_7_4__0__Impl | ||
7701 | rule__ALSPreficed__Group_7_4__1 | ||
7702 | ; | ||
7703 | finally { | ||
7704 | restoreStackSize(stackSize); | ||
7705 | } | ||
7706 | |||
7707 | rule__ALSPreficed__Group_7_4__0__Impl | ||
7708 | @init { | ||
7709 | int stackSize = keepStackSize(); | ||
7710 | } | ||
7711 | : | ||
7712 | ( | ||
7713 | { before(grammarAccess.getALSPreficedAccess().getCommaKeyword_7_4_0()); } | ||
7714 | |||
7715 | ',' | ||
7716 | |||
7717 | { after(grammarAccess.getALSPreficedAccess().getCommaKeyword_7_4_0()); } | ||
7718 | ) | ||
7719 | |||
7720 | ; | ||
7721 | finally { | ||
7722 | restoreStackSize(stackSize); | ||
7723 | } | ||
7724 | |||
7725 | |||
7726 | rule__ALSPreficed__Group_7_4__1 | ||
7727 | @init { | ||
7728 | int stackSize = keepStackSize(); | ||
7729 | } | ||
7730 | : | ||
7731 | rule__ALSPreficed__Group_7_4__1__Impl | ||
7732 | ; | ||
7733 | finally { | ||
7734 | restoreStackSize(stackSize); | ||
7735 | } | ||
7736 | |||
7737 | rule__ALSPreficed__Group_7_4__1__Impl | ||
7738 | @init { | ||
7739 | int stackSize = keepStackSize(); | ||
7740 | } | ||
7741 | : | ||
7742 | ( | ||
7743 | { before(grammarAccess.getALSPreficedAccess().getParamsAssignment_7_4_1()); } | ||
7744 | (rule__ALSPreficed__ParamsAssignment_7_4_1) | ||
7745 | { after(grammarAccess.getALSPreficedAccess().getParamsAssignment_7_4_1()); } | ||
7746 | ) | ||
7747 | |||
7748 | ; | ||
7749 | finally { | ||
7750 | restoreStackSize(stackSize); | ||
7751 | } | ||
7752 | |||
7753 | |||
7754 | |||
7755 | |||
7756 | |||
7757 | |||
7758 | rule__ALSVariableDeclaration__Group__0 | ||
7759 | @init { | ||
7760 | int stackSize = keepStackSize(); | ||
7761 | } | ||
7762 | : | ||
7763 | rule__ALSVariableDeclaration__Group__0__Impl | ||
7764 | rule__ALSVariableDeclaration__Group__1 | ||
7765 | ; | ||
7766 | finally { | ||
7767 | restoreStackSize(stackSize); | ||
7768 | } | ||
7769 | |||
7770 | rule__ALSVariableDeclaration__Group__0__Impl | ||
7771 | @init { | ||
7772 | int stackSize = keepStackSize(); | ||
7773 | } | ||
7774 | : | ||
7775 | ( | ||
7776 | { before(grammarAccess.getALSVariableDeclarationAccess().getNameAssignment_0()); } | ||
7777 | (rule__ALSVariableDeclaration__NameAssignment_0) | ||
7778 | { after(grammarAccess.getALSVariableDeclarationAccess().getNameAssignment_0()); } | ||
7779 | ) | ||
7780 | |||
7781 | ; | ||
7782 | finally { | ||
7783 | restoreStackSize(stackSize); | ||
7784 | } | ||
7785 | |||
7786 | |||
7787 | rule__ALSVariableDeclaration__Group__1 | ||
7788 | @init { | ||
7789 | int stackSize = keepStackSize(); | ||
7790 | } | ||
7791 | : | ||
7792 | rule__ALSVariableDeclaration__Group__1__Impl | ||
7793 | rule__ALSVariableDeclaration__Group__2 | ||
7794 | ; | ||
7795 | finally { | ||
7796 | restoreStackSize(stackSize); | ||
7797 | } | ||
7798 | |||
7799 | rule__ALSVariableDeclaration__Group__1__Impl | ||
7800 | @init { | ||
7801 | int stackSize = keepStackSize(); | ||
7802 | } | ||
7803 | : | ||
7804 | ( | ||
7805 | { before(grammarAccess.getALSVariableDeclarationAccess().getColonKeyword_1()); } | ||
7806 | |||
7807 | ':' | ||
7808 | |||
7809 | { after(grammarAccess.getALSVariableDeclarationAccess().getColonKeyword_1()); } | ||
7810 | ) | ||
7811 | |||
7812 | ; | ||
7813 | finally { | ||
7814 | restoreStackSize(stackSize); | ||
7815 | } | ||
7816 | |||
7817 | |||
7818 | rule__ALSVariableDeclaration__Group__2 | ||
7819 | @init { | ||
7820 | int stackSize = keepStackSize(); | ||
7821 | } | ||
7822 | : | ||
7823 | rule__ALSVariableDeclaration__Group__2__Impl | ||
7824 | ; | ||
7825 | finally { | ||
7826 | restoreStackSize(stackSize); | ||
7827 | } | ||
7828 | |||
7829 | rule__ALSVariableDeclaration__Group__2__Impl | ||
7830 | @init { | ||
7831 | int stackSize = keepStackSize(); | ||
7832 | } | ||
7833 | : | ||
7834 | ( | ||
7835 | { before(grammarAccess.getALSVariableDeclarationAccess().getRangeAssignment_2()); } | ||
7836 | (rule__ALSVariableDeclaration__RangeAssignment_2) | ||
7837 | { after(grammarAccess.getALSVariableDeclarationAccess().getRangeAssignment_2()); } | ||
7838 | ) | ||
7839 | |||
7840 | ; | ||
7841 | finally { | ||
7842 | restoreStackSize(stackSize); | ||
7843 | } | ||
7844 | |||
7845 | |||
7846 | |||
7847 | |||
7848 | |||
7849 | |||
7850 | |||
7851 | |||
7852 | rule__ALSBasicRelationTerm__Group_0__0 | ||
7853 | @init { | ||
7854 | int stackSize = keepStackSize(); | ||
7855 | } | ||
7856 | : | ||
7857 | rule__ALSBasicRelationTerm__Group_0__0__Impl | ||
7858 | rule__ALSBasicRelationTerm__Group_0__1 | ||
7859 | ; | ||
7860 | finally { | ||
7861 | restoreStackSize(stackSize); | ||
7862 | } | ||
7863 | |||
7864 | rule__ALSBasicRelationTerm__Group_0__0__Impl | ||
7865 | @init { | ||
7866 | int stackSize = keepStackSize(); | ||
7867 | } | ||
7868 | : | ||
7869 | ( | ||
7870 | { before(grammarAccess.getALSBasicRelationTermAccess().getALSNoneAction_0_0()); } | ||
7871 | ( | ||
7872 | |||
7873 | ) | ||
7874 | { after(grammarAccess.getALSBasicRelationTermAccess().getALSNoneAction_0_0()); } | ||
7875 | ) | ||
7876 | |||
7877 | ; | ||
7878 | finally { | ||
7879 | restoreStackSize(stackSize); | ||
7880 | } | ||
7881 | |||
7882 | |||
7883 | rule__ALSBasicRelationTerm__Group_0__1 | ||
7884 | @init { | ||
7885 | int stackSize = keepStackSize(); | ||
7886 | } | ||
7887 | : | ||
7888 | rule__ALSBasicRelationTerm__Group_0__1__Impl | ||
7889 | ; | ||
7890 | finally { | ||
7891 | restoreStackSize(stackSize); | ||
7892 | } | ||
7893 | |||
7894 | rule__ALSBasicRelationTerm__Group_0__1__Impl | ||
7895 | @init { | ||
7896 | int stackSize = keepStackSize(); | ||
7897 | } | ||
7898 | : | ||
7899 | ( | ||
7900 | { before(grammarAccess.getALSBasicRelationTermAccess().getNoneKeyword_0_1()); } | ||
7901 | |||
7902 | 'none' | ||
7903 | |||
7904 | { after(grammarAccess.getALSBasicRelationTermAccess().getNoneKeyword_0_1()); } | ||
7905 | ) | ||
7906 | |||
7907 | ; | ||
7908 | finally { | ||
7909 | restoreStackSize(stackSize); | ||
7910 | } | ||
7911 | |||
7912 | |||
7913 | |||
7914 | |||
7915 | |||
7916 | |||
7917 | rule__ALSBasicRelationTerm__Group_1__0 | ||
7918 | @init { | ||
7919 | int stackSize = keepStackSize(); | ||
7920 | } | ||
7921 | : | ||
7922 | rule__ALSBasicRelationTerm__Group_1__0__Impl | ||
7923 | rule__ALSBasicRelationTerm__Group_1__1 | ||
7924 | ; | ||
7925 | finally { | ||
7926 | restoreStackSize(stackSize); | ||
7927 | } | ||
7928 | |||
7929 | rule__ALSBasicRelationTerm__Group_1__0__Impl | ||
7930 | @init { | ||
7931 | int stackSize = keepStackSize(); | ||
7932 | } | ||
7933 | : | ||
7934 | ( | ||
7935 | { before(grammarAccess.getALSBasicRelationTermAccess().getALSIdenAction_1_0()); } | ||
7936 | ( | ||
7937 | |||
7938 | ) | ||
7939 | { after(grammarAccess.getALSBasicRelationTermAccess().getALSIdenAction_1_0()); } | ||
7940 | ) | ||
7941 | |||
7942 | ; | ||
7943 | finally { | ||
7944 | restoreStackSize(stackSize); | ||
7945 | } | ||
7946 | |||
7947 | |||
7948 | rule__ALSBasicRelationTerm__Group_1__1 | ||
7949 | @init { | ||
7950 | int stackSize = keepStackSize(); | ||
7951 | } | ||
7952 | : | ||
7953 | rule__ALSBasicRelationTerm__Group_1__1__Impl | ||
7954 | ; | ||
7955 | finally { | ||
7956 | restoreStackSize(stackSize); | ||
7957 | } | ||
7958 | |||
7959 | rule__ALSBasicRelationTerm__Group_1__1__Impl | ||
7960 | @init { | ||
7961 | int stackSize = keepStackSize(); | ||
7962 | } | ||
7963 | : | ||
7964 | ( | ||
7965 | { before(grammarAccess.getALSBasicRelationTermAccess().getIdenKeyword_1_1()); } | ||
7966 | |||
7967 | 'iden' | ||
7968 | |||
7969 | { after(grammarAccess.getALSBasicRelationTermAccess().getIdenKeyword_1_1()); } | ||
7970 | ) | ||
7971 | |||
7972 | ; | ||
7973 | finally { | ||
7974 | restoreStackSize(stackSize); | ||
7975 | } | ||
7976 | |||
7977 | |||
7978 | |||
7979 | |||
7980 | |||
7981 | |||
7982 | rule__ALSBasicRelationTerm__Group_2__0 | ||
7983 | @init { | ||
7984 | int stackSize = keepStackSize(); | ||
7985 | } | ||
7986 | : | ||
7987 | rule__ALSBasicRelationTerm__Group_2__0__Impl | ||
7988 | rule__ALSBasicRelationTerm__Group_2__1 | ||
7989 | ; | ||
7990 | finally { | ||
7991 | restoreStackSize(stackSize); | ||
7992 | } | ||
7993 | |||
7994 | rule__ALSBasicRelationTerm__Group_2__0__Impl | ||
7995 | @init { | ||
7996 | int stackSize = keepStackSize(); | ||
7997 | } | ||
7998 | : | ||
7999 | ( | ||
8000 | { before(grammarAccess.getALSBasicRelationTermAccess().getALSUnivAction_2_0()); } | ||
8001 | ( | ||
8002 | |||
8003 | ) | ||
8004 | { after(grammarAccess.getALSBasicRelationTermAccess().getALSUnivAction_2_0()); } | ||
8005 | ) | ||
8006 | |||
8007 | ; | ||
8008 | finally { | ||
8009 | restoreStackSize(stackSize); | ||
8010 | } | ||
8011 | |||
8012 | |||
8013 | rule__ALSBasicRelationTerm__Group_2__1 | ||
8014 | @init { | ||
8015 | int stackSize = keepStackSize(); | ||
8016 | } | ||
8017 | : | ||
8018 | rule__ALSBasicRelationTerm__Group_2__1__Impl | ||
8019 | ; | ||
8020 | finally { | ||
8021 | restoreStackSize(stackSize); | ||
8022 | } | ||
8023 | |||
8024 | rule__ALSBasicRelationTerm__Group_2__1__Impl | ||
8025 | @init { | ||
8026 | int stackSize = keepStackSize(); | ||
8027 | } | ||
8028 | : | ||
8029 | ( | ||
8030 | { before(grammarAccess.getALSBasicRelationTermAccess().getUnivKeyword_2_1()); } | ||
8031 | |||
8032 | 'univ' | ||
8033 | |||
8034 | { after(grammarAccess.getALSBasicRelationTermAccess().getUnivKeyword_2_1()); } | ||
8035 | ) | ||
8036 | |||
8037 | ; | ||
8038 | finally { | ||
8039 | restoreStackSize(stackSize); | ||
8040 | } | ||
8041 | |||
8042 | |||
8043 | |||
8044 | |||
8045 | |||
8046 | |||
8047 | rule__ALSBasicRelationTerm__Group_3__0 | ||
8048 | @init { | ||
8049 | int stackSize = keepStackSize(); | ||
8050 | } | ||
8051 | : | ||
8052 | rule__ALSBasicRelationTerm__Group_3__0__Impl | ||
8053 | rule__ALSBasicRelationTerm__Group_3__1 | ||
8054 | ; | ||
8055 | finally { | ||
8056 | restoreStackSize(stackSize); | ||
8057 | } | ||
8058 | |||
8059 | rule__ALSBasicRelationTerm__Group_3__0__Impl | ||
8060 | @init { | ||
8061 | int stackSize = keepStackSize(); | ||
8062 | } | ||
8063 | : | ||
8064 | ( | ||
8065 | { before(grammarAccess.getALSBasicRelationTermAccess().getALSIntAction_3_0()); } | ||
8066 | ( | ||
8067 | |||
8068 | ) | ||
8069 | { after(grammarAccess.getALSBasicRelationTermAccess().getALSIntAction_3_0()); } | ||
8070 | ) | ||
8071 | |||
8072 | ; | ||
8073 | finally { | ||
8074 | restoreStackSize(stackSize); | ||
8075 | } | ||
8076 | |||
8077 | |||
8078 | rule__ALSBasicRelationTerm__Group_3__1 | ||
8079 | @init { | ||
8080 | int stackSize = keepStackSize(); | ||
8081 | } | ||
8082 | : | ||
8083 | rule__ALSBasicRelationTerm__Group_3__1__Impl | ||
8084 | ; | ||
8085 | finally { | ||
8086 | restoreStackSize(stackSize); | ||
8087 | } | ||
8088 | |||
8089 | rule__ALSBasicRelationTerm__Group_3__1__Impl | ||
8090 | @init { | ||
8091 | int stackSize = keepStackSize(); | ||
8092 | } | ||
8093 | : | ||
8094 | ( | ||
8095 | { before(grammarAccess.getALSBasicRelationTermAccess().getIntKeyword_3_1()); } | ||
8096 | |||
8097 | 'Int' | ||
8098 | |||
8099 | { after(grammarAccess.getALSBasicRelationTermAccess().getIntKeyword_3_1()); } | ||
8100 | ) | ||
8101 | |||
8102 | ; | ||
8103 | finally { | ||
8104 | restoreStackSize(stackSize); | ||
8105 | } | ||
8106 | |||
8107 | |||
8108 | |||
8109 | |||
8110 | |||
8111 | |||
8112 | rule__ALSBasicRelationTerm__Group_4__0 | ||
8113 | @init { | ||
8114 | int stackSize = keepStackSize(); | ||
8115 | } | ||
8116 | : | ||
8117 | rule__ALSBasicRelationTerm__Group_4__0__Impl | ||
8118 | rule__ALSBasicRelationTerm__Group_4__1 | ||
8119 | ; | ||
8120 | finally { | ||
8121 | restoreStackSize(stackSize); | ||
8122 | } | ||
8123 | |||
8124 | rule__ALSBasicRelationTerm__Group_4__0__Impl | ||
8125 | @init { | ||
8126 | int stackSize = keepStackSize(); | ||
8127 | } | ||
8128 | : | ||
8129 | ( | ||
8130 | { before(grammarAccess.getALSBasicRelationTermAccess().getALSStringAction_4_0()); } | ||
8131 | ( | ||
8132 | |||
8133 | ) | ||
8134 | { after(grammarAccess.getALSBasicRelationTermAccess().getALSStringAction_4_0()); } | ||
8135 | ) | ||
8136 | |||
8137 | ; | ||
8138 | finally { | ||
8139 | restoreStackSize(stackSize); | ||
8140 | } | ||
8141 | |||
8142 | |||
8143 | rule__ALSBasicRelationTerm__Group_4__1 | ||
8144 | @init { | ||
8145 | int stackSize = keepStackSize(); | ||
8146 | } | ||
8147 | : | ||
8148 | rule__ALSBasicRelationTerm__Group_4__1__Impl | ||
8149 | ; | ||
8150 | finally { | ||
8151 | restoreStackSize(stackSize); | ||
8152 | } | ||
8153 | |||
8154 | rule__ALSBasicRelationTerm__Group_4__1__Impl | ||
8155 | @init { | ||
8156 | int stackSize = keepStackSize(); | ||
8157 | } | ||
8158 | : | ||
8159 | ( | ||
8160 | { before(grammarAccess.getALSBasicRelationTermAccess().getStringKeyword_4_1()); } | ||
8161 | |||
8162 | 'String' | ||
8163 | |||
8164 | { after(grammarAccess.getALSBasicRelationTermAccess().getStringKeyword_4_1()); } | ||
8165 | ) | ||
8166 | |||
8167 | ; | ||
8168 | finally { | ||
8169 | restoreStackSize(stackSize); | ||
8170 | } | ||
8171 | |||
8172 | |||
8173 | |||
8174 | |||
8175 | |||
8176 | |||
8177 | rule__ALSBasicRelationTerm__Group_5__0 | ||
8178 | @init { | ||
8179 | int stackSize = keepStackSize(); | ||
8180 | } | ||
8181 | : | ||
8182 | rule__ALSBasicRelationTerm__Group_5__0__Impl | ||
8183 | rule__ALSBasicRelationTerm__Group_5__1 | ||
8184 | ; | ||
8185 | finally { | ||
8186 | restoreStackSize(stackSize); | ||
8187 | } | ||
8188 | |||
8189 | rule__ALSBasicRelationTerm__Group_5__0__Impl | ||
8190 | @init { | ||
8191 | int stackSize = keepStackSize(); | ||
8192 | } | ||
8193 | : | ||
8194 | ( | ||
8195 | { before(grammarAccess.getALSBasicRelationTermAccess().getALSReferenceAction_5_0()); } | ||
8196 | ( | ||
8197 | |||
8198 | ) | ||
8199 | { after(grammarAccess.getALSBasicRelationTermAccess().getALSReferenceAction_5_0()); } | ||
8200 | ) | ||
8201 | |||
8202 | ; | ||
8203 | finally { | ||
8204 | restoreStackSize(stackSize); | ||
8205 | } | ||
8206 | |||
8207 | |||
8208 | rule__ALSBasicRelationTerm__Group_5__1 | ||
8209 | @init { | ||
8210 | int stackSize = keepStackSize(); | ||
8211 | } | ||
8212 | : | ||
8213 | rule__ALSBasicRelationTerm__Group_5__1__Impl | ||
8214 | ; | ||
8215 | finally { | ||
8216 | restoreStackSize(stackSize); | ||
8217 | } | ||
8218 | |||
8219 | rule__ALSBasicRelationTerm__Group_5__1__Impl | ||
8220 | @init { | ||
8221 | int stackSize = keepStackSize(); | ||
8222 | } | ||
8223 | : | ||
8224 | ( | ||
8225 | { before(grammarAccess.getALSBasicRelationTermAccess().getReferredAssignment_5_1()); } | ||
8226 | (rule__ALSBasicRelationTerm__ReferredAssignment_5_1) | ||
8227 | { after(grammarAccess.getALSBasicRelationTermAccess().getReferredAssignment_5_1()); } | ||
8228 | ) | ||
8229 | |||
8230 | ; | ||
8231 | finally { | ||
8232 | restoreStackSize(stackSize); | ||
8233 | } | ||
8234 | |||
8235 | |||
8236 | |||
8237 | |||
8238 | |||
8239 | |||
8240 | rule__ALSBasicRelationTerm__Group_6__0 | ||
8241 | @init { | ||
8242 | int stackSize = keepStackSize(); | ||
8243 | } | ||
8244 | : | ||
8245 | rule__ALSBasicRelationTerm__Group_6__0__Impl | ||
8246 | rule__ALSBasicRelationTerm__Group_6__1 | ||
8247 | ; | ||
8248 | finally { | ||
8249 | restoreStackSize(stackSize); | ||
8250 | } | ||
8251 | |||
8252 | rule__ALSBasicRelationTerm__Group_6__0__Impl | ||
8253 | @init { | ||
8254 | int stackSize = keepStackSize(); | ||
8255 | } | ||
8256 | : | ||
8257 | ( | ||
8258 | { before(grammarAccess.getALSBasicRelationTermAccess().getALSNumberLiteralAction_6_0()); } | ||
8259 | ( | ||
8260 | |||
8261 | ) | ||
8262 | { after(grammarAccess.getALSBasicRelationTermAccess().getALSNumberLiteralAction_6_0()); } | ||
8263 | ) | ||
8264 | |||
8265 | ; | ||
8266 | finally { | ||
8267 | restoreStackSize(stackSize); | ||
8268 | } | ||
8269 | |||
8270 | |||
8271 | rule__ALSBasicRelationTerm__Group_6__1 | ||
8272 | @init { | ||
8273 | int stackSize = keepStackSize(); | ||
8274 | } | ||
8275 | : | ||
8276 | rule__ALSBasicRelationTerm__Group_6__1__Impl | ||
8277 | ; | ||
8278 | finally { | ||
8279 | restoreStackSize(stackSize); | ||
8280 | } | ||
8281 | |||
8282 | rule__ALSBasicRelationTerm__Group_6__1__Impl | ||
8283 | @init { | ||
8284 | int stackSize = keepStackSize(); | ||
8285 | } | ||
8286 | : | ||
8287 | ( | ||
8288 | { before(grammarAccess.getALSBasicRelationTermAccess().getValueAssignment_6_1()); } | ||
8289 | (rule__ALSBasicRelationTerm__ValueAssignment_6_1) | ||
8290 | { after(grammarAccess.getALSBasicRelationTermAccess().getValueAssignment_6_1()); } | ||
8291 | ) | ||
8292 | |||
8293 | ; | ||
8294 | finally { | ||
8295 | restoreStackSize(stackSize); | ||
8296 | } | ||
8297 | |||
8298 | |||
8299 | |||
8300 | |||
8301 | |||
8302 | |||
8303 | rule__ALSBasicRelationTerm__Group_7__0 | ||
8304 | @init { | ||
8305 | int stackSize = keepStackSize(); | ||
8306 | } | ||
8307 | : | ||
8308 | rule__ALSBasicRelationTerm__Group_7__0__Impl | ||
8309 | rule__ALSBasicRelationTerm__Group_7__1 | ||
8310 | ; | ||
8311 | finally { | ||
8312 | restoreStackSize(stackSize); | ||
8313 | } | ||
8314 | |||
8315 | rule__ALSBasicRelationTerm__Group_7__0__Impl | ||
8316 | @init { | ||
8317 | int stackSize = keepStackSize(); | ||
8318 | } | ||
8319 | : | ||
8320 | ( | ||
8321 | { before(grammarAccess.getALSBasicRelationTermAccess().getALSStringLiteralAction_7_0()); } | ||
8322 | ( | ||
8323 | |||
8324 | ) | ||
8325 | { after(grammarAccess.getALSBasicRelationTermAccess().getALSStringLiteralAction_7_0()); } | ||
8326 | ) | ||
8327 | |||
8328 | ; | ||
8329 | finally { | ||
8330 | restoreStackSize(stackSize); | ||
8331 | } | ||
8332 | |||
8333 | |||
8334 | rule__ALSBasicRelationTerm__Group_7__1 | ||
8335 | @init { | ||
8336 | int stackSize = keepStackSize(); | ||
8337 | } | ||
8338 | : | ||
8339 | rule__ALSBasicRelationTerm__Group_7__1__Impl | ||
8340 | ; | ||
8341 | finally { | ||
8342 | restoreStackSize(stackSize); | ||
8343 | } | ||
8344 | |||
8345 | rule__ALSBasicRelationTerm__Group_7__1__Impl | ||
8346 | @init { | ||
8347 | int stackSize = keepStackSize(); | ||
8348 | } | ||
8349 | : | ||
8350 | ( | ||
8351 | { before(grammarAccess.getALSBasicRelationTermAccess().getValueAssignment_7_1()); } | ||
8352 | (rule__ALSBasicRelationTerm__ValueAssignment_7_1) | ||
8353 | { after(grammarAccess.getALSBasicRelationTermAccess().getValueAssignment_7_1()); } | ||
8354 | ) | ||
8355 | |||
8356 | ; | ||
8357 | finally { | ||
8358 | restoreStackSize(stackSize); | ||
8359 | } | ||
8360 | |||
8361 | |||
8362 | |||
8363 | |||
8364 | |||
8365 | |||
8366 | rule__ALSBasicRelationTerm__Group_8__0 | ||
8367 | @init { | ||
8368 | int stackSize = keepStackSize(); | ||
8369 | } | ||
8370 | : | ||
8371 | rule__ALSBasicRelationTerm__Group_8__0__Impl | ||
8372 | rule__ALSBasicRelationTerm__Group_8__1 | ||
8373 | ; | ||
8374 | finally { | ||
8375 | restoreStackSize(stackSize); | ||
8376 | } | ||
8377 | |||
8378 | rule__ALSBasicRelationTerm__Group_8__0__Impl | ||
8379 | @init { | ||
8380 | int stackSize = keepStackSize(); | ||
8381 | } | ||
8382 | : | ||
8383 | ( | ||
8384 | { before(grammarAccess.getALSBasicRelationTermAccess().getLeftParenthesisKeyword_8_0()); } | ||
8385 | |||
8386 | '(' | ||
8387 | |||
8388 | { after(grammarAccess.getALSBasicRelationTermAccess().getLeftParenthesisKeyword_8_0()); } | ||
8389 | ) | ||
8390 | |||
8391 | ; | ||
8392 | finally { | ||
8393 | restoreStackSize(stackSize); | ||
8394 | } | ||
8395 | |||
8396 | |||
8397 | rule__ALSBasicRelationTerm__Group_8__1 | ||
8398 | @init { | ||
8399 | int stackSize = keepStackSize(); | ||
8400 | } | ||
8401 | : | ||
8402 | rule__ALSBasicRelationTerm__Group_8__1__Impl | ||
8403 | rule__ALSBasicRelationTerm__Group_8__2 | ||
8404 | ; | ||
8405 | finally { | ||
8406 | restoreStackSize(stackSize); | ||
8407 | } | ||
8408 | |||
8409 | rule__ALSBasicRelationTerm__Group_8__1__Impl | ||
8410 | @init { | ||
8411 | int stackSize = keepStackSize(); | ||
8412 | } | ||
8413 | : | ||
8414 | ( | ||
8415 | { before(grammarAccess.getALSBasicRelationTermAccess().getALSTermParserRuleCall_8_1()); } | ||
8416 | ruleALSTerm | ||
8417 | { after(grammarAccess.getALSBasicRelationTermAccess().getALSTermParserRuleCall_8_1()); } | ||
8418 | ) | ||
8419 | |||
8420 | ; | ||
8421 | finally { | ||
8422 | restoreStackSize(stackSize); | ||
8423 | } | ||
8424 | |||
8425 | |||
8426 | rule__ALSBasicRelationTerm__Group_8__2 | ||
8427 | @init { | ||
8428 | int stackSize = keepStackSize(); | ||
8429 | } | ||
8430 | : | ||
8431 | rule__ALSBasicRelationTerm__Group_8__2__Impl | ||
8432 | ; | ||
8433 | finally { | ||
8434 | restoreStackSize(stackSize); | ||
8435 | } | ||
8436 | |||
8437 | rule__ALSBasicRelationTerm__Group_8__2__Impl | ||
8438 | @init { | ||
8439 | int stackSize = keepStackSize(); | ||
8440 | } | ||
8441 | : | ||
8442 | ( | ||
8443 | { before(grammarAccess.getALSBasicRelationTermAccess().getRightParenthesisKeyword_8_2()); } | ||
8444 | |||
8445 | ')' | ||
8446 | |||
8447 | { after(grammarAccess.getALSBasicRelationTermAccess().getRightParenthesisKeyword_8_2()); } | ||
8448 | ) | ||
8449 | |||
8450 | ; | ||
8451 | finally { | ||
8452 | restoreStackSize(stackSize); | ||
8453 | } | ||
8454 | |||
8455 | |||
8456 | |||
8457 | |||
8458 | |||
8459 | |||
8460 | |||
8461 | |||
8462 | rule__ALSRunCommand__Group__0 | ||
8463 | @init { | ||
8464 | int stackSize = keepStackSize(); | ||
8465 | } | ||
8466 | : | ||
8467 | rule__ALSRunCommand__Group__0__Impl | ||
8468 | rule__ALSRunCommand__Group__1 | ||
8469 | ; | ||
8470 | finally { | ||
8471 | restoreStackSize(stackSize); | ||
8472 | } | ||
8473 | |||
8474 | rule__ALSRunCommand__Group__0__Impl | ||
8475 | @init { | ||
8476 | int stackSize = keepStackSize(); | ||
8477 | } | ||
8478 | : | ||
8479 | ( | ||
8480 | { before(grammarAccess.getALSRunCommandAccess().getALSRunCommandAction_0()); } | ||
8481 | ( | ||
8482 | |||
8483 | ) | ||
8484 | { after(grammarAccess.getALSRunCommandAccess().getALSRunCommandAction_0()); } | ||
8485 | ) | ||
8486 | |||
8487 | ; | ||
8488 | finally { | ||
8489 | restoreStackSize(stackSize); | ||
8490 | } | ||
8491 | |||
8492 | |||
8493 | rule__ALSRunCommand__Group__1 | ||
8494 | @init { | ||
8495 | int stackSize = keepStackSize(); | ||
8496 | } | ||
8497 | : | ||
8498 | rule__ALSRunCommand__Group__1__Impl | ||
8499 | rule__ALSRunCommand__Group__2 | ||
8500 | ; | ||
8501 | finally { | ||
8502 | restoreStackSize(stackSize); | ||
8503 | } | ||
8504 | |||
8505 | rule__ALSRunCommand__Group__1__Impl | ||
8506 | @init { | ||
8507 | int stackSize = keepStackSize(); | ||
8508 | } | ||
8509 | : | ||
8510 | ( | ||
8511 | { before(grammarAccess.getALSRunCommandAccess().getRunKeyword_1()); } | ||
8512 | |||
8513 | 'run' | ||
8514 | |||
8515 | { after(grammarAccess.getALSRunCommandAccess().getRunKeyword_1()); } | ||
8516 | ) | ||
8517 | |||
8518 | ; | ||
8519 | finally { | ||
8520 | restoreStackSize(stackSize); | ||
8521 | } | ||
8522 | |||
8523 | |||
8524 | rule__ALSRunCommand__Group__2 | ||
8525 | @init { | ||
8526 | int stackSize = keepStackSize(); | ||
8527 | } | ||
8528 | : | ||
8529 | rule__ALSRunCommand__Group__2__Impl | ||
8530 | rule__ALSRunCommand__Group__3 | ||
8531 | ; | ||
8532 | finally { | ||
8533 | restoreStackSize(stackSize); | ||
8534 | } | ||
8535 | |||
8536 | rule__ALSRunCommand__Group__2__Impl | ||
8537 | @init { | ||
8538 | int stackSize = keepStackSize(); | ||
8539 | } | ||
8540 | : | ||
8541 | ( | ||
8542 | { before(grammarAccess.getALSRunCommandAccess().getLeftCurlyBracketKeyword_2()); } | ||
8543 | |||
8544 | '{' | ||
8545 | |||
8546 | { after(grammarAccess.getALSRunCommandAccess().getLeftCurlyBracketKeyword_2()); } | ||
8547 | ) | ||
8548 | |||
8549 | ; | ||
8550 | finally { | ||
8551 | restoreStackSize(stackSize); | ||
8552 | } | ||
8553 | |||
8554 | |||
8555 | rule__ALSRunCommand__Group__3 | ||
8556 | @init { | ||
8557 | int stackSize = keepStackSize(); | ||
8558 | } | ||
8559 | : | ||
8560 | rule__ALSRunCommand__Group__3__Impl | ||
8561 | rule__ALSRunCommand__Group__4 | ||
8562 | ; | ||
8563 | finally { | ||
8564 | restoreStackSize(stackSize); | ||
8565 | } | ||
8566 | |||
8567 | rule__ALSRunCommand__Group__3__Impl | ||
8568 | @init { | ||
8569 | int stackSize = keepStackSize(); | ||
8570 | } | ||
8571 | : | ||
8572 | ( | ||
8573 | { before(grammarAccess.getALSRunCommandAccess().getRightCurlyBracketKeyword_3()); } | ||
8574 | |||
8575 | '}' | ||
8576 | |||
8577 | { after(grammarAccess.getALSRunCommandAccess().getRightCurlyBracketKeyword_3()); } | ||
8578 | ) | ||
8579 | |||
8580 | ; | ||
8581 | finally { | ||
8582 | restoreStackSize(stackSize); | ||
8583 | } | ||
8584 | |||
8585 | |||
8586 | rule__ALSRunCommand__Group__4 | ||
8587 | @init { | ||
8588 | int stackSize = keepStackSize(); | ||
8589 | } | ||
8590 | : | ||
8591 | rule__ALSRunCommand__Group__4__Impl | ||
8592 | ; | ||
8593 | finally { | ||
8594 | restoreStackSize(stackSize); | ||
8595 | } | ||
8596 | |||
8597 | rule__ALSRunCommand__Group__4__Impl | ||
8598 | @init { | ||
8599 | int stackSize = keepStackSize(); | ||
8600 | } | ||
8601 | : | ||
8602 | ( | ||
8603 | { before(grammarAccess.getALSRunCommandAccess().getGroup_4()); } | ||
8604 | (rule__ALSRunCommand__Group_4__0)? | ||
8605 | { after(grammarAccess.getALSRunCommandAccess().getGroup_4()); } | ||
8606 | ) | ||
8607 | |||
8608 | ; | ||
8609 | finally { | ||
8610 | restoreStackSize(stackSize); | ||
8611 | } | ||
8612 | |||
8613 | |||
8614 | |||
8615 | |||
8616 | |||
8617 | |||
8618 | |||
8619 | |||
8620 | |||
8621 | |||
8622 | |||
8623 | |||
8624 | rule__ALSRunCommand__Group_4__0 | ||
8625 | @init { | ||
8626 | int stackSize = keepStackSize(); | ||
8627 | } | ||
8628 | : | ||
8629 | rule__ALSRunCommand__Group_4__0__Impl | ||
8630 | rule__ALSRunCommand__Group_4__1 | ||
8631 | ; | ||
8632 | finally { | ||
8633 | restoreStackSize(stackSize); | ||
8634 | } | ||
8635 | |||
8636 | rule__ALSRunCommand__Group_4__0__Impl | ||
8637 | @init { | ||
8638 | int stackSize = keepStackSize(); | ||
8639 | } | ||
8640 | : | ||
8641 | ( | ||
8642 | { before(grammarAccess.getALSRunCommandAccess().getForKeyword_4_0()); } | ||
8643 | |||
8644 | 'for' | ||
8645 | |||
8646 | { after(grammarAccess.getALSRunCommandAccess().getForKeyword_4_0()); } | ||
8647 | ) | ||
8648 | |||
8649 | ; | ||
8650 | finally { | ||
8651 | restoreStackSize(stackSize); | ||
8652 | } | ||
8653 | |||
8654 | |||
8655 | rule__ALSRunCommand__Group_4__1 | ||
8656 | @init { | ||
8657 | int stackSize = keepStackSize(); | ||
8658 | } | ||
8659 | : | ||
8660 | rule__ALSRunCommand__Group_4__1__Impl | ||
8661 | rule__ALSRunCommand__Group_4__2 | ||
8662 | ; | ||
8663 | finally { | ||
8664 | restoreStackSize(stackSize); | ||
8665 | } | ||
8666 | |||
8667 | rule__ALSRunCommand__Group_4__1__Impl | ||
8668 | @init { | ||
8669 | int stackSize = keepStackSize(); | ||
8670 | } | ||
8671 | : | ||
8672 | ( | ||
8673 | { before(grammarAccess.getALSRunCommandAccess().getTypeScopesAssignment_4_1()); } | ||
8674 | (rule__ALSRunCommand__TypeScopesAssignment_4_1) | ||
8675 | { after(grammarAccess.getALSRunCommandAccess().getTypeScopesAssignment_4_1()); } | ||
8676 | ) | ||
8677 | |||
8678 | ; | ||
8679 | finally { | ||
8680 | restoreStackSize(stackSize); | ||
8681 | } | ||
8682 | |||
8683 | |||
8684 | rule__ALSRunCommand__Group_4__2 | ||
8685 | @init { | ||
8686 | int stackSize = keepStackSize(); | ||
8687 | } | ||
8688 | : | ||
8689 | rule__ALSRunCommand__Group_4__2__Impl | ||
8690 | ; | ||
8691 | finally { | ||
8692 | restoreStackSize(stackSize); | ||
8693 | } | ||
8694 | |||
8695 | rule__ALSRunCommand__Group_4__2__Impl | ||
8696 | @init { | ||
8697 | int stackSize = keepStackSize(); | ||
8698 | } | ||
8699 | : | ||
8700 | ( | ||
8701 | { before(grammarAccess.getALSRunCommandAccess().getGroup_4_2()); } | ||
8702 | (rule__ALSRunCommand__Group_4_2__0)* | ||
8703 | { after(grammarAccess.getALSRunCommandAccess().getGroup_4_2()); } | ||
8704 | ) | ||
8705 | |||
8706 | ; | ||
8707 | finally { | ||
8708 | restoreStackSize(stackSize); | ||
8709 | } | ||
8710 | |||
8711 | |||
8712 | |||
8713 | |||
8714 | |||
8715 | |||
8716 | |||
8717 | |||
8718 | rule__ALSRunCommand__Group_4_2__0 | ||
8719 | @init { | ||
8720 | int stackSize = keepStackSize(); | ||
8721 | } | ||
8722 | : | ||
8723 | rule__ALSRunCommand__Group_4_2__0__Impl | ||
8724 | rule__ALSRunCommand__Group_4_2__1 | ||
8725 | ; | ||
8726 | finally { | ||
8727 | restoreStackSize(stackSize); | ||
8728 | } | ||
8729 | |||
8730 | rule__ALSRunCommand__Group_4_2__0__Impl | ||
8731 | @init { | ||
8732 | int stackSize = keepStackSize(); | ||
8733 | } | ||
8734 | : | ||
8735 | ( | ||
8736 | { before(grammarAccess.getALSRunCommandAccess().getCommaKeyword_4_2_0()); } | ||
8737 | |||
8738 | ',' | ||
8739 | |||
8740 | { after(grammarAccess.getALSRunCommandAccess().getCommaKeyword_4_2_0()); } | ||
8741 | ) | ||
8742 | |||
8743 | ; | ||
8744 | finally { | ||
8745 | restoreStackSize(stackSize); | ||
8746 | } | ||
8747 | |||
8748 | |||
8749 | rule__ALSRunCommand__Group_4_2__1 | ||
8750 | @init { | ||
8751 | int stackSize = keepStackSize(); | ||
8752 | } | ||
8753 | : | ||
8754 | rule__ALSRunCommand__Group_4_2__1__Impl | ||
8755 | ; | ||
8756 | finally { | ||
8757 | restoreStackSize(stackSize); | ||
8758 | } | ||
8759 | |||
8760 | rule__ALSRunCommand__Group_4_2__1__Impl | ||
8761 | @init { | ||
8762 | int stackSize = keepStackSize(); | ||
8763 | } | ||
8764 | : | ||
8765 | ( | ||
8766 | { before(grammarAccess.getALSRunCommandAccess().getTypeScopesAssignment_4_2_1()); } | ||
8767 | (rule__ALSRunCommand__TypeScopesAssignment_4_2_1) | ||
8768 | { after(grammarAccess.getALSRunCommandAccess().getTypeScopesAssignment_4_2_1()); } | ||
8769 | ) | ||
8770 | |||
8771 | ; | ||
8772 | finally { | ||
8773 | restoreStackSize(stackSize); | ||
8774 | } | ||
8775 | |||
8776 | |||
8777 | |||
8778 | |||
8779 | |||
8780 | |||
8781 | rule__ALSSigScope__Group__0 | ||
8782 | @init { | ||
8783 | int stackSize = keepStackSize(); | ||
8784 | } | ||
8785 | : | ||
8786 | rule__ALSSigScope__Group__0__Impl | ||
8787 | rule__ALSSigScope__Group__1 | ||
8788 | ; | ||
8789 | finally { | ||
8790 | restoreStackSize(stackSize); | ||
8791 | } | ||
8792 | |||
8793 | rule__ALSSigScope__Group__0__Impl | ||
8794 | @init { | ||
8795 | int stackSize = keepStackSize(); | ||
8796 | } | ||
8797 | : | ||
8798 | ( | ||
8799 | { before(grammarAccess.getALSSigScopeAccess().getExactlyAssignment_0()); } | ||
8800 | (rule__ALSSigScope__ExactlyAssignment_0)? | ||
8801 | { after(grammarAccess.getALSSigScopeAccess().getExactlyAssignment_0()); } | ||
8802 | ) | ||
8803 | |||
8804 | ; | ||
8805 | finally { | ||
8806 | restoreStackSize(stackSize); | ||
8807 | } | ||
8808 | |||
8809 | |||
8810 | rule__ALSSigScope__Group__1 | ||
8811 | @init { | ||
8812 | int stackSize = keepStackSize(); | ||
8813 | } | ||
8814 | : | ||
8815 | rule__ALSSigScope__Group__1__Impl | ||
8816 | rule__ALSSigScope__Group__2 | ||
8817 | ; | ||
8818 | finally { | ||
8819 | restoreStackSize(stackSize); | ||
8820 | } | ||
8821 | |||
8822 | rule__ALSSigScope__Group__1__Impl | ||
8823 | @init { | ||
8824 | int stackSize = keepStackSize(); | ||
8825 | } | ||
8826 | : | ||
8827 | ( | ||
8828 | { before(grammarAccess.getALSSigScopeAccess().getNumberAssignment_1()); } | ||
8829 | (rule__ALSSigScope__NumberAssignment_1) | ||
8830 | { after(grammarAccess.getALSSigScopeAccess().getNumberAssignment_1()); } | ||
8831 | ) | ||
8832 | |||
8833 | ; | ||
8834 | finally { | ||
8835 | restoreStackSize(stackSize); | ||
8836 | } | ||
8837 | |||
8838 | |||
8839 | rule__ALSSigScope__Group__2 | ||
8840 | @init { | ||
8841 | int stackSize = keepStackSize(); | ||
8842 | } | ||
8843 | : | ||
8844 | rule__ALSSigScope__Group__2__Impl | ||
8845 | ; | ||
8846 | finally { | ||
8847 | restoreStackSize(stackSize); | ||
8848 | } | ||
8849 | |||
8850 | rule__ALSSigScope__Group__2__Impl | ||
8851 | @init { | ||
8852 | int stackSize = keepStackSize(); | ||
8853 | } | ||
8854 | : | ||
8855 | ( | ||
8856 | { before(grammarAccess.getALSSigScopeAccess().getTypeAssignment_2()); } | ||
8857 | (rule__ALSSigScope__TypeAssignment_2) | ||
8858 | { after(grammarAccess.getALSSigScopeAccess().getTypeAssignment_2()); } | ||
8859 | ) | ||
8860 | |||
8861 | ; | ||
8862 | finally { | ||
8863 | restoreStackSize(stackSize); | ||
8864 | } | ||
8865 | |||
8866 | |||
8867 | |||
8868 | |||
8869 | |||
8870 | |||
8871 | |||
8872 | |||
8873 | rule__ALSIntScope__Group__0 | ||
8874 | @init { | ||
8875 | int stackSize = keepStackSize(); | ||
8876 | } | ||
8877 | : | ||
8878 | rule__ALSIntScope__Group__0__Impl | ||
8879 | rule__ALSIntScope__Group__1 | ||
8880 | ; | ||
8881 | finally { | ||
8882 | restoreStackSize(stackSize); | ||
8883 | } | ||
8884 | |||
8885 | rule__ALSIntScope__Group__0__Impl | ||
8886 | @init { | ||
8887 | int stackSize = keepStackSize(); | ||
8888 | } | ||
8889 | : | ||
8890 | ( | ||
8891 | { before(grammarAccess.getALSIntScopeAccess().getNumberAssignment_0()); } | ||
8892 | (rule__ALSIntScope__NumberAssignment_0) | ||
8893 | { after(grammarAccess.getALSIntScopeAccess().getNumberAssignment_0()); } | ||
8894 | ) | ||
8895 | |||
8896 | ; | ||
8897 | finally { | ||
8898 | restoreStackSize(stackSize); | ||
8899 | } | ||
8900 | |||
8901 | |||
8902 | rule__ALSIntScope__Group__1 | ||
8903 | @init { | ||
8904 | int stackSize = keepStackSize(); | ||
8905 | } | ||
8906 | : | ||
8907 | rule__ALSIntScope__Group__1__Impl | ||
8908 | ; | ||
8909 | finally { | ||
8910 | restoreStackSize(stackSize); | ||
8911 | } | ||
8912 | |||
8913 | rule__ALSIntScope__Group__1__Impl | ||
8914 | @init { | ||
8915 | int stackSize = keepStackSize(); | ||
8916 | } | ||
8917 | : | ||
8918 | ( | ||
8919 | { before(grammarAccess.getALSIntScopeAccess().getIntKeyword_1()); } | ||
8920 | |||
8921 | 'Int' | ||
8922 | |||
8923 | { after(grammarAccess.getALSIntScopeAccess().getIntKeyword_1()); } | ||
8924 | ) | ||
8925 | |||
8926 | ; | ||
8927 | finally { | ||
8928 | restoreStackSize(stackSize); | ||
8929 | } | ||
8930 | |||
8931 | |||
8932 | |||
8933 | |||
8934 | |||
8935 | |||
8936 | rule__ALSStringScope__Group__0 | ||
8937 | @init { | ||
8938 | int stackSize = keepStackSize(); | ||
8939 | } | ||
8940 | : | ||
8941 | rule__ALSStringScope__Group__0__Impl | ||
8942 | rule__ALSStringScope__Group__1 | ||
8943 | ; | ||
8944 | finally { | ||
8945 | restoreStackSize(stackSize); | ||
8946 | } | ||
8947 | |||
8948 | rule__ALSStringScope__Group__0__Impl | ||
8949 | @init { | ||
8950 | int stackSize = keepStackSize(); | ||
8951 | } | ||
8952 | : | ||
8953 | ( | ||
8954 | { before(grammarAccess.getALSStringScopeAccess().getExactlyKeyword_0()); } | ||
8955 | |||
8956 | 'exactly' | ||
8957 | |||
8958 | { after(grammarAccess.getALSStringScopeAccess().getExactlyKeyword_0()); } | ||
8959 | ) | ||
8960 | |||
8961 | ; | ||
8962 | finally { | ||
8963 | restoreStackSize(stackSize); | ||
8964 | } | ||
8965 | |||
8966 | |||
8967 | rule__ALSStringScope__Group__1 | ||
8968 | @init { | ||
8969 | int stackSize = keepStackSize(); | ||
8970 | } | ||
8971 | : | ||
8972 | rule__ALSStringScope__Group__1__Impl | ||
8973 | rule__ALSStringScope__Group__2 | ||
8974 | ; | ||
8975 | finally { | ||
8976 | restoreStackSize(stackSize); | ||
8977 | } | ||
8978 | |||
8979 | rule__ALSStringScope__Group__1__Impl | ||
8980 | @init { | ||
8981 | int stackSize = keepStackSize(); | ||
8982 | } | ||
8983 | : | ||
8984 | ( | ||
8985 | { before(grammarAccess.getALSStringScopeAccess().getNumberAssignment_1()); } | ||
8986 | (rule__ALSStringScope__NumberAssignment_1) | ||
8987 | { after(grammarAccess.getALSStringScopeAccess().getNumberAssignment_1()); } | ||
8988 | ) | ||
8989 | |||
8990 | ; | ||
8991 | finally { | ||
8992 | restoreStackSize(stackSize); | ||
8993 | } | ||
8994 | |||
8995 | |||
8996 | rule__ALSStringScope__Group__2 | ||
8997 | @init { | ||
8998 | int stackSize = keepStackSize(); | ||
8999 | } | ||
9000 | : | ||
9001 | rule__ALSStringScope__Group__2__Impl | ||
9002 | ; | ||
9003 | finally { | ||
9004 | restoreStackSize(stackSize); | ||
9005 | } | ||
9006 | |||
9007 | rule__ALSStringScope__Group__2__Impl | ||
9008 | @init { | ||
9009 | int stackSize = keepStackSize(); | ||
9010 | } | ||
9011 | : | ||
9012 | ( | ||
9013 | { before(grammarAccess.getALSStringScopeAccess().getStringKeyword_2()); } | ||
9014 | |||
9015 | 'String' | ||
9016 | |||
9017 | { after(grammarAccess.getALSStringScopeAccess().getStringKeyword_2()); } | ||
9018 | ) | ||
9019 | |||
9020 | ; | ||
9021 | finally { | ||
9022 | restoreStackSize(stackSize); | ||
9023 | } | ||
9024 | |||
9025 | |||
9026 | |||
9027 | |||
9028 | |||
9029 | |||
9030 | |||
9031 | |||
9032 | |||
9033 | rule__ALSSignatureBody__UnorderedGroup_0 | ||
9034 | @init { | ||
9035 | int stackSize = keepStackSize(); | ||
9036 | getUnorderedGroupHelper().enter(grammarAccess.getALSSignatureBodyAccess().getUnorderedGroup_0()); | ||
9037 | } | ||
9038 | : | ||
9039 | rule__ALSSignatureBody__UnorderedGroup_0__0 | ||
9040 | ? | ||
9041 | |||
9042 | ; | ||
9043 | finally { | ||
9044 | getUnorderedGroupHelper().leave(grammarAccess.getALSSignatureBodyAccess().getUnorderedGroup_0()); | ||
9045 | restoreStackSize(stackSize); | ||
9046 | } | ||
9047 | |||
9048 | |||
9049 | rule__ALSSignatureBody__UnorderedGroup_0__Impl | ||
9050 | @init { | ||
9051 | int stackSize = keepStackSize(); | ||
9052 | boolean selected = false; | ||
9053 | } | ||
9054 | : | ||
9055 | ( | ||
9056 | |||
9057 | ( | ||
9058 | {getUnorderedGroupHelper().canSelect(grammarAccess.getALSSignatureBodyAccess().getUnorderedGroup_0(), 0)}?=>( | ||
9059 | { | ||
9060 | getUnorderedGroupHelper().select(grammarAccess.getALSSignatureBodyAccess().getUnorderedGroup_0(), 0); | ||
9061 | } | ||
9062 | { | ||
9063 | selected = true; | ||
9064 | } | ||
9065 | ( | ||
9066 | |||
9067 | { before(grammarAccess.getALSSignatureBodyAccess().getMultiplicityAssignment_0_0()); } | ||
9068 | (rule__ALSSignatureBody__MultiplicityAssignment_0_0) | ||
9069 | { after(grammarAccess.getALSSignatureBodyAccess().getMultiplicityAssignment_0_0()); } | ||
9070 | ) | ||
9071 | ) | ||
9072 | ) | | ||
9073 | |||
9074 | ( | ||
9075 | {getUnorderedGroupHelper().canSelect(grammarAccess.getALSSignatureBodyAccess().getUnorderedGroup_0(), 1)}?=>( | ||
9076 | { | ||
9077 | getUnorderedGroupHelper().select(grammarAccess.getALSSignatureBodyAccess().getUnorderedGroup_0(), 1); | ||
9078 | } | ||
9079 | { | ||
9080 | selected = true; | ||
9081 | } | ||
9082 | ( | ||
9083 | |||
9084 | { before(grammarAccess.getALSSignatureBodyAccess().getAbstractAssignment_0_1()); } | ||
9085 | (rule__ALSSignatureBody__AbstractAssignment_0_1) | ||
9086 | { after(grammarAccess.getALSSignatureBodyAccess().getAbstractAssignment_0_1()); } | ||
9087 | ) | ||
9088 | ) | ||
9089 | ) | ||
9090 | |||
9091 | ) | ||
9092 | ; | ||
9093 | finally { | ||
9094 | if (selected) | ||
9095 | getUnorderedGroupHelper().returnFromSelection(grammarAccess.getALSSignatureBodyAccess().getUnorderedGroup_0()); | ||
9096 | restoreStackSize(stackSize); | ||
9097 | } | ||
9098 | |||
9099 | |||
9100 | rule__ALSSignatureBody__UnorderedGroup_0__0 | ||
9101 | @init { | ||
9102 | int stackSize = keepStackSize(); | ||
9103 | } | ||
9104 | : | ||
9105 | rule__ALSSignatureBody__UnorderedGroup_0__Impl | ||
9106 | rule__ALSSignatureBody__UnorderedGroup_0__1? | ||
9107 | ; | ||
9108 | finally { | ||
9109 | restoreStackSize(stackSize); | ||
9110 | } | ||
9111 | |||
9112 | |||
9113 | rule__ALSSignatureBody__UnorderedGroup_0__1 | ||
9114 | @init { | ||
9115 | int stackSize = keepStackSize(); | ||
9116 | } | ||
9117 | : | ||
9118 | rule__ALSSignatureBody__UnorderedGroup_0__Impl | ||
9119 | ; | ||
9120 | finally { | ||
9121 | restoreStackSize(stackSize); | ||
9122 | } | ||
9123 | |||
9124 | |||
9125 | |||
9126 | |||
9127 | |||
9128 | |||
9129 | rule__ALSDocument__EnumDeclarationsAssignment_0_0 | ||
9130 | @init { | ||
9131 | int stackSize = keepStackSize(); | ||
9132 | } | ||
9133 | : | ||
9134 | ( | ||
9135 | { before(grammarAccess.getALSDocumentAccess().getEnumDeclarationsALSEnumDeclarationParserRuleCall_0_0_0()); } | ||
9136 | ruleALSEnumDeclaration{ after(grammarAccess.getALSDocumentAccess().getEnumDeclarationsALSEnumDeclarationParserRuleCall_0_0_0()); } | ||
9137 | ) | ||
9138 | |||
9139 | ; | ||
9140 | finally { | ||
9141 | restoreStackSize(stackSize); | ||
9142 | } | ||
9143 | |||
9144 | rule__ALSDocument__SignatureBodiesAssignment_0_1 | ||
9145 | @init { | ||
9146 | int stackSize = keepStackSize(); | ||
9147 | } | ||
9148 | : | ||
9149 | ( | ||
9150 | { before(grammarAccess.getALSDocumentAccess().getSignatureBodiesALSSignatureBodyParserRuleCall_0_1_0()); } | ||
9151 | ruleALSSignatureBody{ after(grammarAccess.getALSDocumentAccess().getSignatureBodiesALSSignatureBodyParserRuleCall_0_1_0()); } | ||
9152 | ) | ||
9153 | |||
9154 | ; | ||
9155 | finally { | ||
9156 | restoreStackSize(stackSize); | ||
9157 | } | ||
9158 | |||
9159 | rule__ALSDocument__FunctionDefinitionsAssignment_0_2 | ||
9160 | @init { | ||
9161 | int stackSize = keepStackSize(); | ||
9162 | } | ||
9163 | : | ||
9164 | ( | ||
9165 | { before(grammarAccess.getALSDocumentAccess().getFunctionDefinitionsALSFunctionDefinitionParserRuleCall_0_2_0()); } | ||
9166 | ruleALSFunctionDefinition{ after(grammarAccess.getALSDocumentAccess().getFunctionDefinitionsALSFunctionDefinitionParserRuleCall_0_2_0()); } | ||
9167 | ) | ||
9168 | |||
9169 | ; | ||
9170 | finally { | ||
9171 | restoreStackSize(stackSize); | ||
9172 | } | ||
9173 | |||
9174 | rule__ALSDocument__RelationDefinitionsAssignment_0_3 | ||
9175 | @init { | ||
9176 | int stackSize = keepStackSize(); | ||
9177 | } | ||
9178 | : | ||
9179 | ( | ||
9180 | { before(grammarAccess.getALSDocumentAccess().getRelationDefinitionsALSRelationDefinitionParserRuleCall_0_3_0()); } | ||
9181 | ruleALSRelationDefinition{ after(grammarAccess.getALSDocumentAccess().getRelationDefinitionsALSRelationDefinitionParserRuleCall_0_3_0()); } | ||
9182 | ) | ||
9183 | |||
9184 | ; | ||
9185 | finally { | ||
9186 | restoreStackSize(stackSize); | ||
9187 | } | ||
9188 | |||
9189 | rule__ALSDocument__FactDeclarationsAssignment_0_4 | ||
9190 | @init { | ||
9191 | int stackSize = keepStackSize(); | ||
9192 | } | ||
9193 | : | ||
9194 | ( | ||
9195 | { before(grammarAccess.getALSDocumentAccess().getFactDeclarationsALSFactDeclarationParserRuleCall_0_4_0()); } | ||
9196 | ruleALSFactDeclaration{ after(grammarAccess.getALSDocumentAccess().getFactDeclarationsALSFactDeclarationParserRuleCall_0_4_0()); } | ||
9197 | ) | ||
9198 | |||
9199 | ; | ||
9200 | finally { | ||
9201 | restoreStackSize(stackSize); | ||
9202 | } | ||
9203 | |||
9204 | rule__ALSDocument__RunCommandAssignment_1 | ||
9205 | @init { | ||
9206 | int stackSize = keepStackSize(); | ||
9207 | } | ||
9208 | : | ||
9209 | ( | ||
9210 | { before(grammarAccess.getALSDocumentAccess().getRunCommandALSRunCommandParserRuleCall_1_0()); } | ||
9211 | ruleALSRunCommand{ after(grammarAccess.getALSDocumentAccess().getRunCommandALSRunCommandParserRuleCall_1_0()); } | ||
9212 | ) | ||
9213 | |||
9214 | ; | ||
9215 | finally { | ||
9216 | restoreStackSize(stackSize); | ||
9217 | } | ||
9218 | |||
9219 | rule__ALSEnumDeclaration__NameAssignment_1 | ||
9220 | @init { | ||
9221 | int stackSize = keepStackSize(); | ||
9222 | } | ||
9223 | : | ||
9224 | ( | ||
9225 | { before(grammarAccess.getALSEnumDeclarationAccess().getNameALSIDParserRuleCall_1_0()); } | ||
9226 | ruleALSID{ after(grammarAccess.getALSEnumDeclarationAccess().getNameALSIDParserRuleCall_1_0()); } | ||
9227 | ) | ||
9228 | |||
9229 | ; | ||
9230 | finally { | ||
9231 | restoreStackSize(stackSize); | ||
9232 | } | ||
9233 | |||
9234 | rule__ALSEnumDeclaration__LiteralAssignment_3 | ||
9235 | @init { | ||
9236 | int stackSize = keepStackSize(); | ||
9237 | } | ||
9238 | : | ||
9239 | ( | ||
9240 | { before(grammarAccess.getALSEnumDeclarationAccess().getLiteralALSEnumLiteralParserRuleCall_3_0()); } | ||
9241 | ruleALSEnumLiteral{ after(grammarAccess.getALSEnumDeclarationAccess().getLiteralALSEnumLiteralParserRuleCall_3_0()); } | ||
9242 | ) | ||
9243 | |||
9244 | ; | ||
9245 | finally { | ||
9246 | restoreStackSize(stackSize); | ||
9247 | } | ||
9248 | |||
9249 | rule__ALSEnumDeclaration__LiteralAssignment_4_1 | ||
9250 | @init { | ||
9251 | int stackSize = keepStackSize(); | ||
9252 | } | ||
9253 | : | ||
9254 | ( | ||
9255 | { before(grammarAccess.getALSEnumDeclarationAccess().getLiteralALSEnumLiteralParserRuleCall_4_1_0()); } | ||
9256 | ruleALSEnumLiteral{ after(grammarAccess.getALSEnumDeclarationAccess().getLiteralALSEnumLiteralParserRuleCall_4_1_0()); } | ||
9257 | ) | ||
9258 | |||
9259 | ; | ||
9260 | finally { | ||
9261 | restoreStackSize(stackSize); | ||
9262 | } | ||
9263 | |||
9264 | rule__ALSEnumLiteral__NameAssignment | ||
9265 | @init { | ||
9266 | int stackSize = keepStackSize(); | ||
9267 | } | ||
9268 | : | ||
9269 | ( | ||
9270 | { before(grammarAccess.getALSEnumLiteralAccess().getNameALSIDParserRuleCall_0()); } | ||
9271 | ruleALSID{ after(grammarAccess.getALSEnumLiteralAccess().getNameALSIDParserRuleCall_0()); } | ||
9272 | ) | ||
9273 | |||
9274 | ; | ||
9275 | finally { | ||
9276 | restoreStackSize(stackSize); | ||
9277 | } | ||
9278 | |||
9279 | rule__ALSSignatureDeclaration__NameAssignment | ||
9280 | @init { | ||
9281 | int stackSize = keepStackSize(); | ||
9282 | } | ||
9283 | : | ||
9284 | ( | ||
9285 | { before(grammarAccess.getALSSignatureDeclarationAccess().getNameALSIDParserRuleCall_0()); } | ||
9286 | ruleALSID{ after(grammarAccess.getALSSignatureDeclarationAccess().getNameALSIDParserRuleCall_0()); } | ||
9287 | ) | ||
9288 | |||
9289 | ; | ||
9290 | finally { | ||
9291 | restoreStackSize(stackSize); | ||
9292 | } | ||
9293 | |||
9294 | rule__ALSSignatureBody__MultiplicityAssignment_0_0 | ||
9295 | @init { | ||
9296 | int stackSize = keepStackSize(); | ||
9297 | } | ||
9298 | : | ||
9299 | ( | ||
9300 | { before(grammarAccess.getALSSignatureBodyAccess().getMultiplicityALSMultiplicityEnumRuleCall_0_0_0()); } | ||
9301 | ruleALSMultiplicity{ after(grammarAccess.getALSSignatureBodyAccess().getMultiplicityALSMultiplicityEnumRuleCall_0_0_0()); } | ||
9302 | ) | ||
9303 | |||
9304 | ; | ||
9305 | finally { | ||
9306 | restoreStackSize(stackSize); | ||
9307 | } | ||
9308 | |||
9309 | rule__ALSSignatureBody__AbstractAssignment_0_1 | ||
9310 | @init { | ||
9311 | int stackSize = keepStackSize(); | ||
9312 | } | ||
9313 | : | ||
9314 | ( | ||
9315 | { before(grammarAccess.getALSSignatureBodyAccess().getAbstractAbstractKeyword_0_1_0()); } | ||
9316 | ( | ||
9317 | { before(grammarAccess.getALSSignatureBodyAccess().getAbstractAbstractKeyword_0_1_0()); } | ||
9318 | |||
9319 | 'abstract' | ||
9320 | |||
9321 | { after(grammarAccess.getALSSignatureBodyAccess().getAbstractAbstractKeyword_0_1_0()); } | ||
9322 | ) | ||
9323 | |||
9324 | { after(grammarAccess.getALSSignatureBodyAccess().getAbstractAbstractKeyword_0_1_0()); } | ||
9325 | ) | ||
9326 | |||
9327 | ; | ||
9328 | finally { | ||
9329 | restoreStackSize(stackSize); | ||
9330 | } | ||
9331 | |||
9332 | rule__ALSSignatureBody__DeclarationsAssignment_2 | ||
9333 | @init { | ||
9334 | int stackSize = keepStackSize(); | ||
9335 | } | ||
9336 | : | ||
9337 | ( | ||
9338 | { before(grammarAccess.getALSSignatureBodyAccess().getDeclarationsALSSignatureDeclarationParserRuleCall_2_0()); } | ||
9339 | ruleALSSignatureDeclaration{ after(grammarAccess.getALSSignatureBodyAccess().getDeclarationsALSSignatureDeclarationParserRuleCall_2_0()); } | ||
9340 | ) | ||
9341 | |||
9342 | ; | ||
9343 | finally { | ||
9344 | restoreStackSize(stackSize); | ||
9345 | } | ||
9346 | |||
9347 | rule__ALSSignatureBody__DeclarationsAssignment_3_1 | ||
9348 | @init { | ||
9349 | int stackSize = keepStackSize(); | ||
9350 | } | ||
9351 | : | ||
9352 | ( | ||
9353 | { before(grammarAccess.getALSSignatureBodyAccess().getDeclarationsALSSignatureDeclarationParserRuleCall_3_1_0()); } | ||
9354 | ruleALSSignatureDeclaration{ after(grammarAccess.getALSSignatureBodyAccess().getDeclarationsALSSignatureDeclarationParserRuleCall_3_1_0()); } | ||
9355 | ) | ||
9356 | |||
9357 | ; | ||
9358 | finally { | ||
9359 | restoreStackSize(stackSize); | ||
9360 | } | ||
9361 | |||
9362 | rule__ALSSignatureBody__SupertypeAssignment_4_0_1 | ||
9363 | @init { | ||
9364 | int stackSize = keepStackSize(); | ||
9365 | } | ||
9366 | : | ||
9367 | ( | ||
9368 | { before(grammarAccess.getALSSignatureBodyAccess().getSupertypeALSSignatureDeclarationCrossReference_4_0_1_0()); } | ||
9369 | ( | ||
9370 | { before(grammarAccess.getALSSignatureBodyAccess().getSupertypeALSSignatureDeclarationIDTerminalRuleCall_4_0_1_0_1()); } | ||
9371 | RULE_ID{ after(grammarAccess.getALSSignatureBodyAccess().getSupertypeALSSignatureDeclarationIDTerminalRuleCall_4_0_1_0_1()); } | ||
9372 | ) | ||
9373 | { after(grammarAccess.getALSSignatureBodyAccess().getSupertypeALSSignatureDeclarationCrossReference_4_0_1_0()); } | ||
9374 | ) | ||
9375 | |||
9376 | ; | ||
9377 | finally { | ||
9378 | restoreStackSize(stackSize); | ||
9379 | } | ||
9380 | |||
9381 | rule__ALSSignatureBody__SupersetAssignment_4_1_1 | ||
9382 | @init { | ||
9383 | int stackSize = keepStackSize(); | ||
9384 | } | ||
9385 | : | ||
9386 | ( | ||
9387 | { before(grammarAccess.getALSSignatureBodyAccess().getSupersetALSSignatureDeclarationCrossReference_4_1_1_0()); } | ||
9388 | ( | ||
9389 | { before(grammarAccess.getALSSignatureBodyAccess().getSupersetALSSignatureDeclarationIDTerminalRuleCall_4_1_1_0_1()); } | ||
9390 | RULE_ID{ after(grammarAccess.getALSSignatureBodyAccess().getSupersetALSSignatureDeclarationIDTerminalRuleCall_4_1_1_0_1()); } | ||
9391 | ) | ||
9392 | { after(grammarAccess.getALSSignatureBodyAccess().getSupersetALSSignatureDeclarationCrossReference_4_1_1_0()); } | ||
9393 | ) | ||
9394 | |||
9395 | ; | ||
9396 | finally { | ||
9397 | restoreStackSize(stackSize); | ||
9398 | } | ||
9399 | |||
9400 | rule__ALSSignatureBody__SupersetAssignment_4_1_2_1 | ||
9401 | @init { | ||
9402 | int stackSize = keepStackSize(); | ||
9403 | } | ||
9404 | : | ||
9405 | ( | ||
9406 | { before(grammarAccess.getALSSignatureBodyAccess().getSupersetALSSignatureDeclarationCrossReference_4_1_2_1_0()); } | ||
9407 | ( | ||
9408 | { before(grammarAccess.getALSSignatureBodyAccess().getSupersetALSSignatureDeclarationIDTerminalRuleCall_4_1_2_1_0_1()); } | ||
9409 | RULE_ID{ after(grammarAccess.getALSSignatureBodyAccess().getSupersetALSSignatureDeclarationIDTerminalRuleCall_4_1_2_1_0_1()); } | ||
9410 | ) | ||
9411 | { after(grammarAccess.getALSSignatureBodyAccess().getSupersetALSSignatureDeclarationCrossReference_4_1_2_1_0()); } | ||
9412 | ) | ||
9413 | |||
9414 | ; | ||
9415 | finally { | ||
9416 | restoreStackSize(stackSize); | ||
9417 | } | ||
9418 | |||
9419 | rule__ALSSignatureBody__FieldsAssignment_6_0 | ||
9420 | @init { | ||
9421 | int stackSize = keepStackSize(); | ||
9422 | } | ||
9423 | : | ||
9424 | ( | ||
9425 | { before(grammarAccess.getALSSignatureBodyAccess().getFieldsALSFieldDeclarationParserRuleCall_6_0_0()); } | ||
9426 | ruleALSFieldDeclaration{ after(grammarAccess.getALSSignatureBodyAccess().getFieldsALSFieldDeclarationParserRuleCall_6_0_0()); } | ||
9427 | ) | ||
9428 | |||
9429 | ; | ||
9430 | finally { | ||
9431 | restoreStackSize(stackSize); | ||
9432 | } | ||
9433 | |||
9434 | rule__ALSSignatureBody__FieldsAssignment_6_1_1 | ||
9435 | @init { | ||
9436 | int stackSize = keepStackSize(); | ||
9437 | } | ||
9438 | : | ||
9439 | ( | ||
9440 | { before(grammarAccess.getALSSignatureBodyAccess().getFieldsALSFieldDeclarationParserRuleCall_6_1_1_0()); } | ||
9441 | ruleALSFieldDeclaration{ after(grammarAccess.getALSSignatureBodyAccess().getFieldsALSFieldDeclarationParserRuleCall_6_1_1_0()); } | ||
9442 | ) | ||
9443 | |||
9444 | ; | ||
9445 | finally { | ||
9446 | restoreStackSize(stackSize); | ||
9447 | } | ||
9448 | |||
9449 | rule__ALSFieldDeclaration__NameAssignment_0 | ||
9450 | @init { | ||
9451 | int stackSize = keepStackSize(); | ||
9452 | } | ||
9453 | : | ||
9454 | ( | ||
9455 | { before(grammarAccess.getALSFieldDeclarationAccess().getNameALSIDParserRuleCall_0_0()); } | ||
9456 | ruleALSID{ after(grammarAccess.getALSFieldDeclarationAccess().getNameALSIDParserRuleCall_0_0()); } | ||
9457 | ) | ||
9458 | |||
9459 | ; | ||
9460 | finally { | ||
9461 | restoreStackSize(stackSize); | ||
9462 | } | ||
9463 | |||
9464 | rule__ALSFieldDeclaration__MultiplicityAssignment_2 | ||
9465 | @init { | ||
9466 | int stackSize = keepStackSize(); | ||
9467 | } | ||
9468 | : | ||
9469 | ( | ||
9470 | { before(grammarAccess.getALSFieldDeclarationAccess().getMultiplicityALSMultiplicityEnumRuleCall_2_0()); } | ||
9471 | ruleALSMultiplicity{ after(grammarAccess.getALSFieldDeclarationAccess().getMultiplicityALSMultiplicityEnumRuleCall_2_0()); } | ||
9472 | ) | ||
9473 | |||
9474 | ; | ||
9475 | finally { | ||
9476 | restoreStackSize(stackSize); | ||
9477 | } | ||
9478 | |||
9479 | rule__ALSFieldDeclaration__TypeAssignment_3 | ||
9480 | @init { | ||
9481 | int stackSize = keepStackSize(); | ||
9482 | } | ||
9483 | : | ||
9484 | ( | ||
9485 | { before(grammarAccess.getALSFieldDeclarationAccess().getTypeALSTermParserRuleCall_3_0()); } | ||
9486 | ruleALSTerm{ after(grammarAccess.getALSFieldDeclarationAccess().getTypeALSTermParserRuleCall_3_0()); } | ||
9487 | ) | ||
9488 | |||
9489 | ; | ||
9490 | finally { | ||
9491 | restoreStackSize(stackSize); | ||
9492 | } | ||
9493 | |||
9494 | rule__ALSFunctionDefinition__NameAssignment_1 | ||
9495 | @init { | ||
9496 | int stackSize = keepStackSize(); | ||
9497 | } | ||
9498 | : | ||
9499 | ( | ||
9500 | { before(grammarAccess.getALSFunctionDefinitionAccess().getNameALSIDParserRuleCall_1_0()); } | ||
9501 | ruleALSID{ after(grammarAccess.getALSFunctionDefinitionAccess().getNameALSIDParserRuleCall_1_0()); } | ||
9502 | ) | ||
9503 | |||
9504 | ; | ||
9505 | finally { | ||
9506 | restoreStackSize(stackSize); | ||
9507 | } | ||
9508 | |||
9509 | rule__ALSFunctionDefinition__VariablesAssignment_3 | ||
9510 | @init { | ||
9511 | int stackSize = keepStackSize(); | ||
9512 | } | ||
9513 | : | ||
9514 | ( | ||
9515 | { before(grammarAccess.getALSFunctionDefinitionAccess().getVariablesALSVariableDeclarationParserRuleCall_3_0()); } | ||
9516 | ruleALSVariableDeclaration{ after(grammarAccess.getALSFunctionDefinitionAccess().getVariablesALSVariableDeclarationParserRuleCall_3_0()); } | ||
9517 | ) | ||
9518 | |||
9519 | ; | ||
9520 | finally { | ||
9521 | restoreStackSize(stackSize); | ||
9522 | } | ||
9523 | |||
9524 | rule__ALSFunctionDefinition__VariablesAssignment_4_1 | ||
9525 | @init { | ||
9526 | int stackSize = keepStackSize(); | ||
9527 | } | ||
9528 | : | ||
9529 | ( | ||
9530 | { before(grammarAccess.getALSFunctionDefinitionAccess().getVariablesALSVariableDeclarationParserRuleCall_4_1_0()); } | ||
9531 | ruleALSVariableDeclaration{ after(grammarAccess.getALSFunctionDefinitionAccess().getVariablesALSVariableDeclarationParserRuleCall_4_1_0()); } | ||
9532 | ) | ||
9533 | |||
9534 | ; | ||
9535 | finally { | ||
9536 | restoreStackSize(stackSize); | ||
9537 | } | ||
9538 | |||
9539 | rule__ALSFunctionDefinition__TypeAssignment_7 | ||
9540 | @init { | ||
9541 | int stackSize = keepStackSize(); | ||
9542 | } | ||
9543 | : | ||
9544 | ( | ||
9545 | { before(grammarAccess.getALSFunctionDefinitionAccess().getTypeALSTermParserRuleCall_7_0()); } | ||
9546 | ruleALSTerm{ after(grammarAccess.getALSFunctionDefinitionAccess().getTypeALSTermParserRuleCall_7_0()); } | ||
9547 | ) | ||
9548 | |||
9549 | ; | ||
9550 | finally { | ||
9551 | restoreStackSize(stackSize); | ||
9552 | } | ||
9553 | |||
9554 | rule__ALSFunctionDefinition__ValueAssignment_9 | ||
9555 | @init { | ||
9556 | int stackSize = keepStackSize(); | ||
9557 | } | ||
9558 | : | ||
9559 | ( | ||
9560 | { before(grammarAccess.getALSFunctionDefinitionAccess().getValueALSTermParserRuleCall_9_0()); } | ||
9561 | ruleALSTerm{ after(grammarAccess.getALSFunctionDefinitionAccess().getValueALSTermParserRuleCall_9_0()); } | ||
9562 | ) | ||
9563 | |||
9564 | ; | ||
9565 | finally { | ||
9566 | restoreStackSize(stackSize); | ||
9567 | } | ||
9568 | |||
9569 | rule__ALSRelationDefinition__NameAssignment_1 | ||
9570 | @init { | ||
9571 | int stackSize = keepStackSize(); | ||
9572 | } | ||
9573 | : | ||
9574 | ( | ||
9575 | { before(grammarAccess.getALSRelationDefinitionAccess().getNameALSIDParserRuleCall_1_0()); } | ||
9576 | ruleALSID{ after(grammarAccess.getALSRelationDefinitionAccess().getNameALSIDParserRuleCall_1_0()); } | ||
9577 | ) | ||
9578 | |||
9579 | ; | ||
9580 | finally { | ||
9581 | restoreStackSize(stackSize); | ||
9582 | } | ||
9583 | |||
9584 | rule__ALSRelationDefinition__VariablesAssignment_3 | ||
9585 | @init { | ||
9586 | int stackSize = keepStackSize(); | ||
9587 | } | ||
9588 | : | ||
9589 | ( | ||
9590 | { before(grammarAccess.getALSRelationDefinitionAccess().getVariablesALSVariableDeclarationParserRuleCall_3_0()); } | ||
9591 | ruleALSVariableDeclaration{ after(grammarAccess.getALSRelationDefinitionAccess().getVariablesALSVariableDeclarationParserRuleCall_3_0()); } | ||
9592 | ) | ||
9593 | |||
9594 | ; | ||
9595 | finally { | ||
9596 | restoreStackSize(stackSize); | ||
9597 | } | ||
9598 | |||
9599 | rule__ALSRelationDefinition__VariablesAssignment_4_1 | ||
9600 | @init { | ||
9601 | int stackSize = keepStackSize(); | ||
9602 | } | ||
9603 | : | ||
9604 | ( | ||
9605 | { before(grammarAccess.getALSRelationDefinitionAccess().getVariablesALSVariableDeclarationParserRuleCall_4_1_0()); } | ||
9606 | ruleALSVariableDeclaration{ after(grammarAccess.getALSRelationDefinitionAccess().getVariablesALSVariableDeclarationParserRuleCall_4_1_0()); } | ||
9607 | ) | ||
9608 | |||
9609 | ; | ||
9610 | finally { | ||
9611 | restoreStackSize(stackSize); | ||
9612 | } | ||
9613 | |||
9614 | rule__ALSRelationDefinition__ValueAssignment_7 | ||
9615 | @init { | ||
9616 | int stackSize = keepStackSize(); | ||
9617 | } | ||
9618 | : | ||
9619 | ( | ||
9620 | { before(grammarAccess.getALSRelationDefinitionAccess().getValueALSTermParserRuleCall_7_0()); } | ||
9621 | ruleALSTerm{ after(grammarAccess.getALSRelationDefinitionAccess().getValueALSTermParserRuleCall_7_0()); } | ||
9622 | ) | ||
9623 | |||
9624 | ; | ||
9625 | finally { | ||
9626 | restoreStackSize(stackSize); | ||
9627 | } | ||
9628 | |||
9629 | rule__ALSFactDeclaration__NameAssignment_2 | ||
9630 | @init { | ||
9631 | int stackSize = keepStackSize(); | ||
9632 | } | ||
9633 | : | ||
9634 | ( | ||
9635 | { before(grammarAccess.getALSFactDeclarationAccess().getNameALSIDParserRuleCall_2_0()); } | ||
9636 | ruleALSID{ after(grammarAccess.getALSFactDeclarationAccess().getNameALSIDParserRuleCall_2_0()); } | ||
9637 | ) | ||
9638 | |||
9639 | ; | ||
9640 | finally { | ||
9641 | restoreStackSize(stackSize); | ||
9642 | } | ||
9643 | |||
9644 | rule__ALSFactDeclaration__TermAssignment_4 | ||
9645 | @init { | ||
9646 | int stackSize = keepStackSize(); | ||
9647 | } | ||
9648 | : | ||
9649 | ( | ||
9650 | { before(grammarAccess.getALSFactDeclarationAccess().getTermALSTermParserRuleCall_4_0()); } | ||
9651 | ruleALSTerm{ after(grammarAccess.getALSFactDeclarationAccess().getTermALSTermParserRuleCall_4_0()); } | ||
9652 | ) | ||
9653 | |||
9654 | ; | ||
9655 | finally { | ||
9656 | restoreStackSize(stackSize); | ||
9657 | } | ||
9658 | |||
9659 | rule__ALSQuantified__TypeAssignment_0_1 | ||
9660 | @init { | ||
9661 | int stackSize = keepStackSize(); | ||
9662 | } | ||
9663 | : | ||
9664 | ( | ||
9665 | { before(grammarAccess.getALSQuantifiedAccess().getTypeALSMultiplicityEnumRuleCall_0_1_0()); } | ||
9666 | ruleALSMultiplicity{ after(grammarAccess.getALSQuantifiedAccess().getTypeALSMultiplicityEnumRuleCall_0_1_0()); } | ||
9667 | ) | ||
9668 | |||
9669 | ; | ||
9670 | finally { | ||
9671 | restoreStackSize(stackSize); | ||
9672 | } | ||
9673 | |||
9674 | rule__ALSQuantified__DisjAssignment_0_2 | ||
9675 | @init { | ||
9676 | int stackSize = keepStackSize(); | ||
9677 | } | ||
9678 | : | ||
9679 | ( | ||
9680 | { before(grammarAccess.getALSQuantifiedAccess().getDisjDisjKeyword_0_2_0()); } | ||
9681 | ( | ||
9682 | { before(grammarAccess.getALSQuantifiedAccess().getDisjDisjKeyword_0_2_0()); } | ||
9683 | |||
9684 | 'disj' | ||
9685 | |||
9686 | { after(grammarAccess.getALSQuantifiedAccess().getDisjDisjKeyword_0_2_0()); } | ||
9687 | ) | ||
9688 | |||
9689 | { after(grammarAccess.getALSQuantifiedAccess().getDisjDisjKeyword_0_2_0()); } | ||
9690 | ) | ||
9691 | |||
9692 | ; | ||
9693 | finally { | ||
9694 | restoreStackSize(stackSize); | ||
9695 | } | ||
9696 | |||
9697 | rule__ALSQuantified__VariablesAssignment_0_3 | ||
9698 | @init { | ||
9699 | int stackSize = keepStackSize(); | ||
9700 | } | ||
9701 | : | ||
9702 | ( | ||
9703 | { before(grammarAccess.getALSQuantifiedAccess().getVariablesALSVariableDeclarationParserRuleCall_0_3_0()); } | ||
9704 | ruleALSVariableDeclaration{ after(grammarAccess.getALSQuantifiedAccess().getVariablesALSVariableDeclarationParserRuleCall_0_3_0()); } | ||
9705 | ) | ||
9706 | |||
9707 | ; | ||
9708 | finally { | ||
9709 | restoreStackSize(stackSize); | ||
9710 | } | ||
9711 | |||
9712 | rule__ALSQuantified__VariablesAssignment_0_4_1 | ||
9713 | @init { | ||
9714 | int stackSize = keepStackSize(); | ||
9715 | } | ||
9716 | : | ||
9717 | ( | ||
9718 | { before(grammarAccess.getALSQuantifiedAccess().getVariablesALSVariableDeclarationParserRuleCall_0_4_1_0()); } | ||
9719 | ruleALSVariableDeclaration{ after(grammarAccess.getALSQuantifiedAccess().getVariablesALSVariableDeclarationParserRuleCall_0_4_1_0()); } | ||
9720 | ) | ||
9721 | |||
9722 | ; | ||
9723 | finally { | ||
9724 | restoreStackSize(stackSize); | ||
9725 | } | ||
9726 | |||
9727 | rule__ALSQuantified__ExpressionAssignment_0_6 | ||
9728 | @init { | ||
9729 | int stackSize = keepStackSize(); | ||
9730 | } | ||
9731 | : | ||
9732 | ( | ||
9733 | { before(grammarAccess.getALSQuantifiedAccess().getExpressionALSTermParserRuleCall_0_6_0()); } | ||
9734 | ruleALSTerm{ after(grammarAccess.getALSQuantifiedAccess().getExpressionALSTermParserRuleCall_0_6_0()); } | ||
9735 | ) | ||
9736 | |||
9737 | ; | ||
9738 | finally { | ||
9739 | restoreStackSize(stackSize); | ||
9740 | } | ||
9741 | |||
9742 | rule__ALSOr__RightOperandAssignment_1_2 | ||
9743 | @init { | ||
9744 | int stackSize = keepStackSize(); | ||
9745 | } | ||
9746 | : | ||
9747 | ( | ||
9748 | { before(grammarAccess.getALSOrAccess().getRightOperandALSIffParserRuleCall_1_2_0()); } | ||
9749 | ruleALSIff{ after(grammarAccess.getALSOrAccess().getRightOperandALSIffParserRuleCall_1_2_0()); } | ||
9750 | ) | ||
9751 | |||
9752 | ; | ||
9753 | finally { | ||
9754 | restoreStackSize(stackSize); | ||
9755 | } | ||
9756 | |||
9757 | rule__ALSIff__RightOperandAssignment_1_2 | ||
9758 | @init { | ||
9759 | int stackSize = keepStackSize(); | ||
9760 | } | ||
9761 | : | ||
9762 | ( | ||
9763 | { before(grammarAccess.getALSIffAccess().getRightOperandALSImplParserRuleCall_1_2_0()); } | ||
9764 | ruleALSImpl{ after(grammarAccess.getALSIffAccess().getRightOperandALSImplParserRuleCall_1_2_0()); } | ||
9765 | ) | ||
9766 | |||
9767 | ; | ||
9768 | finally { | ||
9769 | restoreStackSize(stackSize); | ||
9770 | } | ||
9771 | |||
9772 | rule__ALSImpl__RightOperandAssignment_1_2 | ||
9773 | @init { | ||
9774 | int stackSize = keepStackSize(); | ||
9775 | } | ||
9776 | : | ||
9777 | ( | ||
9778 | { before(grammarAccess.getALSImplAccess().getRightOperandALSAndParserRuleCall_1_2_0()); } | ||
9779 | ruleALSAnd{ after(grammarAccess.getALSImplAccess().getRightOperandALSAndParserRuleCall_1_2_0()); } | ||
9780 | ) | ||
9781 | |||
9782 | ; | ||
9783 | finally { | ||
9784 | restoreStackSize(stackSize); | ||
9785 | } | ||
9786 | |||
9787 | rule__ALSImpl__ElseOperandAssignment_1_3_1 | ||
9788 | @init { | ||
9789 | int stackSize = keepStackSize(); | ||
9790 | } | ||
9791 | : | ||
9792 | ( | ||
9793 | { before(grammarAccess.getALSImplAccess().getElseOperandALSAndParserRuleCall_1_3_1_0()); } | ||
9794 | ruleALSAnd{ after(grammarAccess.getALSImplAccess().getElseOperandALSAndParserRuleCall_1_3_1_0()); } | ||
9795 | ) | ||
9796 | |||
9797 | ; | ||
9798 | finally { | ||
9799 | restoreStackSize(stackSize); | ||
9800 | } | ||
9801 | |||
9802 | rule__ALSAnd__RightOperandAssignment_1_2 | ||
9803 | @init { | ||
9804 | int stackSize = keepStackSize(); | ||
9805 | } | ||
9806 | : | ||
9807 | ( | ||
9808 | { before(grammarAccess.getALSAndAccess().getRightOperandALSComparisonParserRuleCall_1_2_0()); } | ||
9809 | ruleALSComparison{ after(grammarAccess.getALSAndAccess().getRightOperandALSComparisonParserRuleCall_1_2_0()); } | ||
9810 | ) | ||
9811 | |||
9812 | ; | ||
9813 | finally { | ||
9814 | restoreStackSize(stackSize); | ||
9815 | } | ||
9816 | |||
9817 | rule__ALSComparison__RightOperandAssignment_1_1 | ||
9818 | @init { | ||
9819 | int stackSize = keepStackSize(); | ||
9820 | } | ||
9821 | : | ||
9822 | ( | ||
9823 | { before(grammarAccess.getALSComparisonAccess().getRightOperandALSOverrideParserRuleCall_1_1_0()); } | ||
9824 | ruleALSOverride{ after(grammarAccess.getALSComparisonAccess().getRightOperandALSOverrideParserRuleCall_1_1_0()); } | ||
9825 | ) | ||
9826 | |||
9827 | ; | ||
9828 | finally { | ||
9829 | restoreStackSize(stackSize); | ||
9830 | } | ||
9831 | |||
9832 | rule__ALSOverride__RightOperandAssignment_1_2 | ||
9833 | @init { | ||
9834 | int stackSize = keepStackSize(); | ||
9835 | } | ||
9836 | : | ||
9837 | ( | ||
9838 | { before(grammarAccess.getALSOverrideAccess().getRightOperandALSRangeRestrictionRightParserRuleCall_1_2_0()); } | ||
9839 | ruleALSRangeRestrictionRight{ after(grammarAccess.getALSOverrideAccess().getRightOperandALSRangeRestrictionRightParserRuleCall_1_2_0()); } | ||
9840 | ) | ||
9841 | |||
9842 | ; | ||
9843 | finally { | ||
9844 | restoreStackSize(stackSize); | ||
9845 | } | ||
9846 | |||
9847 | rule__ALSRangeRestrictionRight__FilterAssignment_1_2 | ||
9848 | @init { | ||
9849 | int stackSize = keepStackSize(); | ||
9850 | } | ||
9851 | : | ||
9852 | ( | ||
9853 | { before(grammarAccess.getALSRangeRestrictionRightAccess().getFilterALSRangeRestrictionLeftParserRuleCall_1_2_0()); } | ||
9854 | ruleALSRangeRestrictionLeft{ after(grammarAccess.getALSRangeRestrictionRightAccess().getFilterALSRangeRestrictionLeftParserRuleCall_1_2_0()); } | ||
9855 | ) | ||
9856 | |||
9857 | ; | ||
9858 | finally { | ||
9859 | restoreStackSize(stackSize); | ||
9860 | } | ||
9861 | |||
9862 | rule__ALSRangeRestrictionLeft__RelationAssignment_1_2 | ||
9863 | @init { | ||
9864 | int stackSize = keepStackSize(); | ||
9865 | } | ||
9866 | : | ||
9867 | ( | ||
9868 | { before(grammarAccess.getALSRangeRestrictionLeftAccess().getRelationALSJoinParserRuleCall_1_2_0()); } | ||
9869 | ruleALSJoin{ after(grammarAccess.getALSRangeRestrictionLeftAccess().getRelationALSJoinParserRuleCall_1_2_0()); } | ||
9870 | ) | ||
9871 | |||
9872 | ; | ||
9873 | finally { | ||
9874 | restoreStackSize(stackSize); | ||
9875 | } | ||
9876 | |||
9877 | rule__ALSJoin__RightOperandAssignment_1_2 | ||
9878 | @init { | ||
9879 | int stackSize = keepStackSize(); | ||
9880 | } | ||
9881 | : | ||
9882 | ( | ||
9883 | { before(grammarAccess.getALSJoinAccess().getRightOperandALSMinusParserRuleCall_1_2_0()); } | ||
9884 | ruleALSMinus{ after(grammarAccess.getALSJoinAccess().getRightOperandALSMinusParserRuleCall_1_2_0()); } | ||
9885 | ) | ||
9886 | |||
9887 | ; | ||
9888 | finally { | ||
9889 | restoreStackSize(stackSize); | ||
9890 | } | ||
9891 | |||
9892 | rule__ALSMinus__RightOperandAssignment_1_2 | ||
9893 | @init { | ||
9894 | int stackSize = keepStackSize(); | ||
9895 | } | ||
9896 | : | ||
9897 | ( | ||
9898 | { before(grammarAccess.getALSMinusAccess().getRightOperandALSPlusParserRuleCall_1_2_0()); } | ||
9899 | ruleALSPlus{ after(grammarAccess.getALSMinusAccess().getRightOperandALSPlusParserRuleCall_1_2_0()); } | ||
9900 | ) | ||
9901 | |||
9902 | ; | ||
9903 | finally { | ||
9904 | restoreStackSize(stackSize); | ||
9905 | } | ||
9906 | |||
9907 | rule__ALSPlus__RightOperandAssignment_1_2 | ||
9908 | @init { | ||
9909 | int stackSize = keepStackSize(); | ||
9910 | } | ||
9911 | : | ||
9912 | ( | ||
9913 | { before(grammarAccess.getALSPlusAccess().getRightOperandALSIntersectionParserRuleCall_1_2_0()); } | ||
9914 | ruleALSIntersection{ after(grammarAccess.getALSPlusAccess().getRightOperandALSIntersectionParserRuleCall_1_2_0()); } | ||
9915 | ) | ||
9916 | |||
9917 | ; | ||
9918 | finally { | ||
9919 | restoreStackSize(stackSize); | ||
9920 | } | ||
9921 | |||
9922 | rule__ALSIntersection__RightOperandAssignment_1_2 | ||
9923 | @init { | ||
9924 | int stackSize = keepStackSize(); | ||
9925 | } | ||
9926 | : | ||
9927 | ( | ||
9928 | { before(grammarAccess.getALSIntersectionAccess().getRightOperandALSDirectProductParserRuleCall_1_2_0()); } | ||
9929 | ruleALSDirectProduct{ after(grammarAccess.getALSIntersectionAccess().getRightOperandALSDirectProductParserRuleCall_1_2_0()); } | ||
9930 | ) | ||
9931 | |||
9932 | ; | ||
9933 | finally { | ||
9934 | restoreStackSize(stackSize); | ||
9935 | } | ||
9936 | |||
9937 | rule__ALSDirectProduct__LeftMultiplicitAssignment_1_1 | ||
9938 | @init { | ||
9939 | int stackSize = keepStackSize(); | ||
9940 | } | ||
9941 | : | ||
9942 | ( | ||
9943 | { before(grammarAccess.getALSDirectProductAccess().getLeftMultiplicitALSMultiplicityEnumRuleCall_1_1_0()); } | ||
9944 | ruleALSMultiplicity{ after(grammarAccess.getALSDirectProductAccess().getLeftMultiplicitALSMultiplicityEnumRuleCall_1_1_0()); } | ||
9945 | ) | ||
9946 | |||
9947 | ; | ||
9948 | finally { | ||
9949 | restoreStackSize(stackSize); | ||
9950 | } | ||
9951 | |||
9952 | rule__ALSDirectProduct__RightMultiplicitAssignment_1_3 | ||
9953 | @init { | ||
9954 | int stackSize = keepStackSize(); | ||
9955 | } | ||
9956 | : | ||
9957 | ( | ||
9958 | { before(grammarAccess.getALSDirectProductAccess().getRightMultiplicitALSMultiplicityEnumRuleCall_1_3_0()); } | ||
9959 | ruleALSMultiplicity{ after(grammarAccess.getALSDirectProductAccess().getRightMultiplicitALSMultiplicityEnumRuleCall_1_3_0()); } | ||
9960 | ) | ||
9961 | |||
9962 | ; | ||
9963 | finally { | ||
9964 | restoreStackSize(stackSize); | ||
9965 | } | ||
9966 | |||
9967 | rule__ALSDirectProduct__RightOperandAssignment_1_4 | ||
9968 | @init { | ||
9969 | int stackSize = keepStackSize(); | ||
9970 | } | ||
9971 | : | ||
9972 | ( | ||
9973 | { before(grammarAccess.getALSDirectProductAccess().getRightOperandALSPreficedParserRuleCall_1_4_0()); } | ||
9974 | ruleALSPreficed{ after(grammarAccess.getALSDirectProductAccess().getRightOperandALSPreficedParserRuleCall_1_4_0()); } | ||
9975 | ) | ||
9976 | |||
9977 | ; | ||
9978 | finally { | ||
9979 | restoreStackSize(stackSize); | ||
9980 | } | ||
9981 | |||
9982 | rule__ALSPreficed__OperandAssignment_0_2 | ||
9983 | @init { | ||
9984 | int stackSize = keepStackSize(); | ||
9985 | } | ||
9986 | : | ||
9987 | ( | ||
9988 | { before(grammarAccess.getALSPreficedAccess().getOperandALSBasicRelationTermParserRuleCall_0_2_0()); } | ||
9989 | ruleALSBasicRelationTerm{ after(grammarAccess.getALSPreficedAccess().getOperandALSBasicRelationTermParserRuleCall_0_2_0()); } | ||
9990 | ) | ||
9991 | |||
9992 | ; | ||
9993 | finally { | ||
9994 | restoreStackSize(stackSize); | ||
9995 | } | ||
9996 | |||
9997 | rule__ALSPreficed__OperandAssignment_1_2 | ||
9998 | @init { | ||
9999 | int stackSize = keepStackSize(); | ||
10000 | } | ||
10001 | : | ||
10002 | ( | ||
10003 | { before(grammarAccess.getALSPreficedAccess().getOperandALSBasicRelationTermParserRuleCall_1_2_0()); } | ||
10004 | ruleALSBasicRelationTerm{ after(grammarAccess.getALSPreficedAccess().getOperandALSBasicRelationTermParserRuleCall_1_2_0()); } | ||
10005 | ) | ||
10006 | |||
10007 | ; | ||
10008 | finally { | ||
10009 | restoreStackSize(stackSize); | ||
10010 | } | ||
10011 | |||
10012 | rule__ALSPreficed__OperandAssignment_2_2 | ||
10013 | @init { | ||
10014 | int stackSize = keepStackSize(); | ||
10015 | } | ||
10016 | : | ||
10017 | ( | ||
10018 | { before(grammarAccess.getALSPreficedAccess().getOperandALSBasicRelationTermParserRuleCall_2_2_0()); } | ||
10019 | ruleALSBasicRelationTerm{ after(grammarAccess.getALSPreficedAccess().getOperandALSBasicRelationTermParserRuleCall_2_2_0()); } | ||
10020 | ) | ||
10021 | |||
10022 | ; | ||
10023 | finally { | ||
10024 | restoreStackSize(stackSize); | ||
10025 | } | ||
10026 | |||
10027 | rule__ALSPreficed__OperandAssignment_3_2 | ||
10028 | @init { | ||
10029 | int stackSize = keepStackSize(); | ||
10030 | } | ||
10031 | : | ||
10032 | ( | ||
10033 | { before(grammarAccess.getALSPreficedAccess().getOperandALSBasicRelationTermParserRuleCall_3_2_0()); } | ||
10034 | ruleALSBasicRelationTerm{ after(grammarAccess.getALSPreficedAccess().getOperandALSBasicRelationTermParserRuleCall_3_2_0()); } | ||
10035 | ) | ||
10036 | |||
10037 | ; | ||
10038 | finally { | ||
10039 | restoreStackSize(stackSize); | ||
10040 | } | ||
10041 | |||
10042 | rule__ALSPreficed__OperandAssignment_4_2 | ||
10043 | @init { | ||
10044 | int stackSize = keepStackSize(); | ||
10045 | } | ||
10046 | : | ||
10047 | ( | ||
10048 | { before(grammarAccess.getALSPreficedAccess().getOperandALSBasicRelationTermParserRuleCall_4_2_0()); } | ||
10049 | ruleALSBasicRelationTerm{ after(grammarAccess.getALSPreficedAccess().getOperandALSBasicRelationTermParserRuleCall_4_2_0()); } | ||
10050 | ) | ||
10051 | |||
10052 | ; | ||
10053 | finally { | ||
10054 | restoreStackSize(stackSize); | ||
10055 | } | ||
10056 | |||
10057 | rule__ALSPreficed__OperandAssignment_5_2 | ||
10058 | @init { | ||
10059 | int stackSize = keepStackSize(); | ||
10060 | } | ||
10061 | : | ||
10062 | ( | ||
10063 | { before(grammarAccess.getALSPreficedAccess().getOperandALSBasicRelationTermParserRuleCall_5_2_0()); } | ||
10064 | ruleALSBasicRelationTerm{ after(grammarAccess.getALSPreficedAccess().getOperandALSBasicRelationTermParserRuleCall_5_2_0()); } | ||
10065 | ) | ||
10066 | |||
10067 | ; | ||
10068 | finally { | ||
10069 | restoreStackSize(stackSize); | ||
10070 | } | ||
10071 | |||
10072 | rule__ALSPreficed__VariablesAssignment_6_2 | ||
10073 | @init { | ||
10074 | int stackSize = keepStackSize(); | ||
10075 | } | ||
10076 | : | ||
10077 | ( | ||
10078 | { before(grammarAccess.getALSPreficedAccess().getVariablesALSVariableDeclarationParserRuleCall_6_2_0()); } | ||
10079 | ruleALSVariableDeclaration{ after(grammarAccess.getALSPreficedAccess().getVariablesALSVariableDeclarationParserRuleCall_6_2_0()); } | ||
10080 | ) | ||
10081 | |||
10082 | ; | ||
10083 | finally { | ||
10084 | restoreStackSize(stackSize); | ||
10085 | } | ||
10086 | |||
10087 | rule__ALSPreficed__VariablesAssignment_6_3_1 | ||
10088 | @init { | ||
10089 | int stackSize = keepStackSize(); | ||
10090 | } | ||
10091 | : | ||
10092 | ( | ||
10093 | { before(grammarAccess.getALSPreficedAccess().getVariablesALSVariableDeclarationParserRuleCall_6_3_1_0()); } | ||
10094 | ruleALSVariableDeclaration{ after(grammarAccess.getALSPreficedAccess().getVariablesALSVariableDeclarationParserRuleCall_6_3_1_0()); } | ||
10095 | ) | ||
10096 | |||
10097 | ; | ||
10098 | finally { | ||
10099 | restoreStackSize(stackSize); | ||
10100 | } | ||
10101 | |||
10102 | rule__ALSPreficed__ExpressionAssignment_6_5 | ||
10103 | @init { | ||
10104 | int stackSize = keepStackSize(); | ||
10105 | } | ||
10106 | : | ||
10107 | ( | ||
10108 | { before(grammarAccess.getALSPreficedAccess().getExpressionALSTermParserRuleCall_6_5_0()); } | ||
10109 | ruleALSTerm{ after(grammarAccess.getALSPreficedAccess().getExpressionALSTermParserRuleCall_6_5_0()); } | ||
10110 | ) | ||
10111 | |||
10112 | ; | ||
10113 | finally { | ||
10114 | restoreStackSize(stackSize); | ||
10115 | } | ||
10116 | |||
10117 | rule__ALSPreficed__ReferredDefinitionAssignment_7_1_0 | ||
10118 | @init { | ||
10119 | int stackSize = keepStackSize(); | ||
10120 | } | ||
10121 | : | ||
10122 | ( | ||
10123 | { before(grammarAccess.getALSPreficedAccess().getReferredDefinitionALSDefinitionCrossReference_7_1_0_0()); } | ||
10124 | ( | ||
10125 | { before(grammarAccess.getALSPreficedAccess().getReferredDefinitionALSDefinitionIDTerminalRuleCall_7_1_0_0_1()); } | ||
10126 | RULE_ID{ after(grammarAccess.getALSPreficedAccess().getReferredDefinitionALSDefinitionIDTerminalRuleCall_7_1_0_0_1()); } | ||
10127 | ) | ||
10128 | { after(grammarAccess.getALSPreficedAccess().getReferredDefinitionALSDefinitionCrossReference_7_1_0_0()); } | ||
10129 | ) | ||
10130 | |||
10131 | ; | ||
10132 | finally { | ||
10133 | restoreStackSize(stackSize); | ||
10134 | } | ||
10135 | |||
10136 | rule__ALSPreficed__ReferredNumericOperatorAssignment_7_1_1 | ||
10137 | @init { | ||
10138 | int stackSize = keepStackSize(); | ||
10139 | } | ||
10140 | : | ||
10141 | ( | ||
10142 | { before(grammarAccess.getALSPreficedAccess().getReferredNumericOperatorALSNumericOperatorEnumRuleCall_7_1_1_0()); } | ||
10143 | ruleALSNumericOperator{ after(grammarAccess.getALSPreficedAccess().getReferredNumericOperatorALSNumericOperatorEnumRuleCall_7_1_1_0()); } | ||
10144 | ) | ||
10145 | |||
10146 | ; | ||
10147 | finally { | ||
10148 | restoreStackSize(stackSize); | ||
10149 | } | ||
10150 | |||
10151 | rule__ALSPreficed__ParamsAssignment_7_3 | ||
10152 | @init { | ||
10153 | int stackSize = keepStackSize(); | ||
10154 | } | ||
10155 | : | ||
10156 | ( | ||
10157 | { before(grammarAccess.getALSPreficedAccess().getParamsALSTermParserRuleCall_7_3_0()); } | ||
10158 | ruleALSTerm{ after(grammarAccess.getALSPreficedAccess().getParamsALSTermParserRuleCall_7_3_0()); } | ||
10159 | ) | ||
10160 | |||
10161 | ; | ||
10162 | finally { | ||
10163 | restoreStackSize(stackSize); | ||
10164 | } | ||
10165 | |||
10166 | rule__ALSPreficed__ParamsAssignment_7_4_1 | ||
10167 | @init { | ||
10168 | int stackSize = keepStackSize(); | ||
10169 | } | ||
10170 | : | ||
10171 | ( | ||
10172 | { before(grammarAccess.getALSPreficedAccess().getParamsALSTermParserRuleCall_7_4_1_0()); } | ||
10173 | ruleALSTerm{ after(grammarAccess.getALSPreficedAccess().getParamsALSTermParserRuleCall_7_4_1_0()); } | ||
10174 | ) | ||
10175 | |||
10176 | ; | ||
10177 | finally { | ||
10178 | restoreStackSize(stackSize); | ||
10179 | } | ||
10180 | |||
10181 | rule__ALSVariableDeclaration__NameAssignment_0 | ||
10182 | @init { | ||
10183 | int stackSize = keepStackSize(); | ||
10184 | } | ||
10185 | : | ||
10186 | ( | ||
10187 | { before(grammarAccess.getALSVariableDeclarationAccess().getNameALSIDParserRuleCall_0_0()); } | ||
10188 | ruleALSID{ after(grammarAccess.getALSVariableDeclarationAccess().getNameALSIDParserRuleCall_0_0()); } | ||
10189 | ) | ||
10190 | |||
10191 | ; | ||
10192 | finally { | ||
10193 | restoreStackSize(stackSize); | ||
10194 | } | ||
10195 | |||
10196 | rule__ALSVariableDeclaration__RangeAssignment_2 | ||
10197 | @init { | ||
10198 | int stackSize = keepStackSize(); | ||
10199 | } | ||
10200 | : | ||
10201 | ( | ||
10202 | { before(grammarAccess.getALSVariableDeclarationAccess().getRangeALSTermParserRuleCall_2_0()); } | ||
10203 | ruleALSTerm{ after(grammarAccess.getALSVariableDeclarationAccess().getRangeALSTermParserRuleCall_2_0()); } | ||
10204 | ) | ||
10205 | |||
10206 | ; | ||
10207 | finally { | ||
10208 | restoreStackSize(stackSize); | ||
10209 | } | ||
10210 | |||
10211 | rule__ALSBasicRelationTerm__ReferredAssignment_5_1 | ||
10212 | @init { | ||
10213 | int stackSize = keepStackSize(); | ||
10214 | } | ||
10215 | : | ||
10216 | ( | ||
10217 | { before(grammarAccess.getALSBasicRelationTermAccess().getReferredALSRelationDeclarationCrossReference_5_1_0()); } | ||
10218 | ( | ||
10219 | { before(grammarAccess.getALSBasicRelationTermAccess().getReferredALSRelationDeclarationIDTerminalRuleCall_5_1_0_1()); } | ||
10220 | RULE_ID{ after(grammarAccess.getALSBasicRelationTermAccess().getReferredALSRelationDeclarationIDTerminalRuleCall_5_1_0_1()); } | ||
10221 | ) | ||
10222 | { after(grammarAccess.getALSBasicRelationTermAccess().getReferredALSRelationDeclarationCrossReference_5_1_0()); } | ||
10223 | ) | ||
10224 | |||
10225 | ; | ||
10226 | finally { | ||
10227 | restoreStackSize(stackSize); | ||
10228 | } | ||
10229 | |||
10230 | rule__ALSBasicRelationTerm__ValueAssignment_6_1 | ||
10231 | @init { | ||
10232 | int stackSize = keepStackSize(); | ||
10233 | } | ||
10234 | : | ||
10235 | ( | ||
10236 | { before(grammarAccess.getALSBasicRelationTermAccess().getValueINTTerminalRuleCall_6_1_0()); } | ||
10237 | RULE_INT{ after(grammarAccess.getALSBasicRelationTermAccess().getValueINTTerminalRuleCall_6_1_0()); } | ||
10238 | ) | ||
10239 | |||
10240 | ; | ||
10241 | finally { | ||
10242 | restoreStackSize(stackSize); | ||
10243 | } | ||
10244 | |||
10245 | rule__ALSBasicRelationTerm__ValueAssignment_7_1 | ||
10246 | @init { | ||
10247 | int stackSize = keepStackSize(); | ||
10248 | } | ||
10249 | : | ||
10250 | ( | ||
10251 | { before(grammarAccess.getALSBasicRelationTermAccess().getValueSTRINGTerminalRuleCall_7_1_0()); } | ||
10252 | RULE_STRING{ after(grammarAccess.getALSBasicRelationTermAccess().getValueSTRINGTerminalRuleCall_7_1_0()); } | ||
10253 | ) | ||
10254 | |||
10255 | ; | ||
10256 | finally { | ||
10257 | restoreStackSize(stackSize); | ||
10258 | } | ||
10259 | |||
10260 | rule__ALSRunCommand__TypeScopesAssignment_4_1 | ||
10261 | @init { | ||
10262 | int stackSize = keepStackSize(); | ||
10263 | } | ||
10264 | : | ||
10265 | ( | ||
10266 | { before(grammarAccess.getALSRunCommandAccess().getTypeScopesALSTypeScopeParserRuleCall_4_1_0()); } | ||
10267 | ruleALSTypeScope{ after(grammarAccess.getALSRunCommandAccess().getTypeScopesALSTypeScopeParserRuleCall_4_1_0()); } | ||
10268 | ) | ||
10269 | |||
10270 | ; | ||
10271 | finally { | ||
10272 | restoreStackSize(stackSize); | ||
10273 | } | ||
10274 | |||
10275 | rule__ALSRunCommand__TypeScopesAssignment_4_2_1 | ||
10276 | @init { | ||
10277 | int stackSize = keepStackSize(); | ||
10278 | } | ||
10279 | : | ||
10280 | ( | ||
10281 | { before(grammarAccess.getALSRunCommandAccess().getTypeScopesALSTypeScopeParserRuleCall_4_2_1_0()); } | ||
10282 | ruleALSTypeScope{ after(grammarAccess.getALSRunCommandAccess().getTypeScopesALSTypeScopeParserRuleCall_4_2_1_0()); } | ||
10283 | ) | ||
10284 | |||
10285 | ; | ||
10286 | finally { | ||
10287 | restoreStackSize(stackSize); | ||
10288 | } | ||
10289 | |||
10290 | rule__ALSSigScope__ExactlyAssignment_0 | ||
10291 | @init { | ||
10292 | int stackSize = keepStackSize(); | ||
10293 | } | ||
10294 | : | ||
10295 | ( | ||
10296 | { before(grammarAccess.getALSSigScopeAccess().getExactlyExactlyKeyword_0_0()); } | ||
10297 | ( | ||
10298 | { before(grammarAccess.getALSSigScopeAccess().getExactlyExactlyKeyword_0_0()); } | ||
10299 | |||
10300 | 'exactly' | ||
10301 | |||
10302 | { after(grammarAccess.getALSSigScopeAccess().getExactlyExactlyKeyword_0_0()); } | ||
10303 | ) | ||
10304 | |||
10305 | { after(grammarAccess.getALSSigScopeAccess().getExactlyExactlyKeyword_0_0()); } | ||
10306 | ) | ||
10307 | |||
10308 | ; | ||
10309 | finally { | ||
10310 | restoreStackSize(stackSize); | ||
10311 | } | ||
10312 | |||
10313 | rule__ALSSigScope__NumberAssignment_1 | ||
10314 | @init { | ||
10315 | int stackSize = keepStackSize(); | ||
10316 | } | ||
10317 | : | ||
10318 | ( | ||
10319 | { before(grammarAccess.getALSSigScopeAccess().getNumberINTTerminalRuleCall_1_0()); } | ||
10320 | RULE_INT{ after(grammarAccess.getALSSigScopeAccess().getNumberINTTerminalRuleCall_1_0()); } | ||
10321 | ) | ||
10322 | |||
10323 | ; | ||
10324 | finally { | ||
10325 | restoreStackSize(stackSize); | ||
10326 | } | ||
10327 | |||
10328 | rule__ALSSigScope__TypeAssignment_2 | ||
10329 | @init { | ||
10330 | int stackSize = keepStackSize(); | ||
10331 | } | ||
10332 | : | ||
10333 | ( | ||
10334 | { before(grammarAccess.getALSSigScopeAccess().getTypeALSSignatureDeclarationCrossReference_2_0()); } | ||
10335 | ( | ||
10336 | { before(grammarAccess.getALSSigScopeAccess().getTypeALSSignatureDeclarationIDTerminalRuleCall_2_0_1()); } | ||
10337 | RULE_ID{ after(grammarAccess.getALSSigScopeAccess().getTypeALSSignatureDeclarationIDTerminalRuleCall_2_0_1()); } | ||
10338 | ) | ||
10339 | { after(grammarAccess.getALSSigScopeAccess().getTypeALSSignatureDeclarationCrossReference_2_0()); } | ||
10340 | ) | ||
10341 | |||
10342 | ; | ||
10343 | finally { | ||
10344 | restoreStackSize(stackSize); | ||
10345 | } | ||
10346 | |||
10347 | rule__ALSIntScope__NumberAssignment_0 | ||
10348 | @init { | ||
10349 | int stackSize = keepStackSize(); | ||
10350 | } | ||
10351 | : | ||
10352 | ( | ||
10353 | { before(grammarAccess.getALSIntScopeAccess().getNumberINTTerminalRuleCall_0_0()); } | ||
10354 | RULE_INT{ after(grammarAccess.getALSIntScopeAccess().getNumberINTTerminalRuleCall_0_0()); } | ||
10355 | ) | ||
10356 | |||
10357 | ; | ||
10358 | finally { | ||
10359 | restoreStackSize(stackSize); | ||
10360 | } | ||
10361 | |||
10362 | rule__ALSStringScope__NumberAssignment_1 | ||
10363 | @init { | ||
10364 | int stackSize = keepStackSize(); | ||
10365 | } | ||
10366 | : | ||
10367 | ( | ||
10368 | { before(grammarAccess.getALSStringScopeAccess().getNumberINTTerminalRuleCall_1_0()); } | ||
10369 | RULE_INT{ after(grammarAccess.getALSStringScopeAccess().getNumberINTTerminalRuleCall_1_0()); } | ||
10370 | ) | ||
10371 | |||
10372 | ; | ||
10373 | finally { | ||
10374 | restoreStackSize(stackSize); | ||
10375 | } | ||
10376 | |||
10377 | |||
10378 | RULE_ID : ('a'..'z'|'A'..'Z'|'_') ('a'..'z'|'A'..'Z'|'_'|'\''|'"'|'0'..'9')*; | ||
10379 | |||
10380 | RULE_INT : ('0'..'9')+; | ||
10381 | |||
10382 | RULE_STRING : ('"' ('\\' .|~(('\\'|'"')))* '"'|'\'' ('\\' .|~(('\\'|'\'')))* '\''); | ||
10383 | |||
10384 | RULE_ML_COMMENT : '/*' ( options {greedy=false;} : . )*'*/'; | ||
10385 | |||
10386 | RULE_SL_COMMENT : '//' ~(('\n'|'\r'))* ('\r'? '\n')?; | ||
10387 | |||
10388 | RULE_WS : (' '|'\t'|'\r'|'\n')+; | ||
10389 | |||
10390 | RULE_ANY_OTHER : .; | ||
10391 | |||
10392 | |||
diff --git a/Solvers/Alloy-Solver2/hu.bme.mit.inf.dslreasoner.alloy.language.ui/src-gen/hu/bme/mit/inf/dslreasoner/ui/contentassist/antlr/internal/InternalAlloyLanguage.tokens b/Solvers/Alloy-Solver2/hu.bme.mit.inf.dslreasoner.alloy.language.ui/src-gen/hu/bme/mit/inf/dslreasoner/ui/contentassist/antlr/internal/InternalAlloyLanguage.tokens new file mode 100644 index 00000000..a7695d52 --- /dev/null +++ b/Solvers/Alloy-Solver2/hu.bme.mit.inf.dslreasoner.alloy.language.ui/src-gen/hu/bme/mit/inf/dslreasoner/ui/contentassist/antlr/internal/InternalAlloyLanguage.tokens | |||
@@ -0,0 +1,139 @@ | |||
1 | '!'=19 | ||
2 | '!='=48 | ||
3 | '#'=63 | ||
4 | '&&'=17 | ||
5 | '&'=58 | ||
6 | '('=70 | ||
7 | ')'=71 | ||
8 | '*'=62 | ||
9 | '+'=39 | ||
10 | '++'=53 | ||
11 | ','=35 | ||
12 | '-'=57 | ||
13 | '->'=59 | ||
14 | '.'=56 | ||
15 | ':'=40 | ||
16 | ':>'=54 | ||
17 | '<'=51 | ||
18 | '<:'=55 | ||
19 | '<='=52 | ||
20 | '<=>'=13 | ||
21 | '='=47 | ||
22 | '=>'=15 | ||
23 | '>'=49 | ||
24 | '>='=50 | ||
25 | 'Int'=68 | ||
26 | 'String'=69 | ||
27 | '['=42 | ||
28 | ']'=43 | ||
29 | '^'=61 | ||
30 | 'abstract'=75 | ||
31 | 'all'=21 | ||
32 | 'and'=18 | ||
33 | 'disj'=76 | ||
34 | 'div'=31 | ||
35 | 'else'=46 | ||
36 | 'enum'=32 | ||
37 | 'exactly'=74 | ||
38 | 'extends'=37 | ||
39 | 'fact'=45 | ||
40 | 'for'=73 | ||
41 | 'fun'=41 | ||
42 | 'iden'=66 | ||
43 | 'iff'=14 | ||
44 | 'implies'=16 | ||
45 | 'in'=38 | ||
46 | 'lone'=24 | ||
47 | 'mul'=29 | ||
48 | 'no'=22 | ||
49 | 'none'=65 | ||
50 | 'not'=20 | ||
51 | 'one'=25 | ||
52 | 'or'=12 | ||
53 | 'plus'=27 | ||
54 | 'pred'=44 | ||
55 | 'rem'=30 | ||
56 | 'run'=72 | ||
57 | 'set'=26 | ||
58 | 'sig'=36 | ||
59 | 'some'=23 | ||
60 | 'sub'=28 | ||
61 | 'sum'=64 | ||
62 | 'univ'=67 | ||
63 | '{'=33 | ||
64 | '||'=11 | ||
65 | '}'=34 | ||
66 | '~'=60 | ||
67 | RULE_ANY_OTHER=10 | ||
68 | RULE_ID=4 | ||
69 | RULE_INT=5 | ||
70 | RULE_ML_COMMENT=7 | ||
71 | RULE_SL_COMMENT=8 | ||
72 | RULE_STRING=6 | ||
73 | RULE_WS=9 | ||
74 | T__11=11 | ||
75 | T__12=12 | ||
76 | T__13=13 | ||
77 | T__14=14 | ||
78 | T__15=15 | ||
79 | T__16=16 | ||
80 | T__17=17 | ||
81 | T__18=18 | ||
82 | T__19=19 | ||
83 | T__20=20 | ||
84 | T__21=21 | ||
85 | T__22=22 | ||
86 | T__23=23 | ||
87 | T__24=24 | ||
88 | T__25=25 | ||
89 | T__26=26 | ||
90 | T__27=27 | ||
91 | T__28=28 | ||
92 | T__29=29 | ||
93 | T__30=30 | ||
94 | T__31=31 | ||
95 | T__32=32 | ||
96 | T__33=33 | ||
97 | T__34=34 | ||
98 | T__35=35 | ||
99 | T__36=36 | ||
100 | T__37=37 | ||
101 | T__38=38 | ||
102 | T__39=39 | ||
103 | T__40=40 | ||
104 | T__41=41 | ||
105 | T__42=42 | ||
106 | T__43=43 | ||
107 | T__44=44 | ||
108 | T__45=45 | ||
109 | T__46=46 | ||
110 | T__47=47 | ||
111 | T__48=48 | ||
112 | T__49=49 | ||
113 | T__50=50 | ||
114 | T__51=51 | ||
115 | T__52=52 | ||
116 | T__53=53 | ||
117 | T__54=54 | ||
118 | T__55=55 | ||
119 | T__56=56 | ||
120 | T__57=57 | ||
121 | T__58=58 | ||
122 | T__59=59 | ||
123 | T__60=60 | ||
124 | T__61=61 | ||
125 | T__62=62 | ||
126 | T__63=63 | ||
127 | T__64=64 | ||
128 | T__65=65 | ||
129 | T__66=66 | ||
130 | T__67=67 | ||
131 | T__68=68 | ||
132 | T__69=69 | ||
133 | T__70=70 | ||
134 | T__71=71 | ||
135 | T__72=72 | ||
136 | T__73=73 | ||
137 | T__74=74 | ||
138 | T__75=75 | ||
139 | T__76=76 | ||
diff --git a/Solvers/Alloy-Solver2/hu.bme.mit.inf.dslreasoner.alloy.language.ui/src-gen/hu/bme/mit/inf/dslreasoner/ui/contentassist/antlr/internal/InternalAlloyLanguageLexer.java b/Solvers/Alloy-Solver2/hu.bme.mit.inf.dslreasoner.alloy.language.ui/src-gen/hu/bme/mit/inf/dslreasoner/ui/contentassist/antlr/internal/InternalAlloyLanguageLexer.java new file mode 100644 index 00000000..410c21e7 --- /dev/null +++ b/Solvers/Alloy-Solver2/hu.bme.mit.inf.dslreasoner.alloy.language.ui/src-gen/hu/bme/mit/inf/dslreasoner/ui/contentassist/antlr/internal/InternalAlloyLanguageLexer.java | |||
@@ -0,0 +1,2854 @@ | |||
1 | package hu.bme.mit.inf.dslreasoner.ui.contentassist.antlr.internal; | ||
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.ui.editor.contentassist.antlr.internal.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 InternalAlloyLanguageLexer extends Lexer { | ||
15 | public static final int T__50=50; | ||
16 | public static final int T__19=19; | ||
17 | public static final int T__15=15; | ||
18 | public static final int T__59=59; | ||
19 | public static final int T__16=16; | ||
20 | public static final int T__17=17; | ||
21 | public static final int T__18=18; | ||
22 | public static final int T__11=11; | ||
23 | public static final int T__55=55; | ||
24 | public static final int T__12=12; | ||
25 | public static final int T__56=56; | ||
26 | public static final int T__13=13; | ||
27 | public static final int T__57=57; | ||
28 | public static final int T__14=14; | ||
29 | public static final int T__58=58; | ||
30 | public static final int T__51=51; | ||
31 | public static final int T__52=52; | ||
32 | public static final int T__53=53; | ||
33 | public static final int T__54=54; | ||
34 | public static final int T__60=60; | ||
35 | public static final int T__61=61; | ||
36 | public static final int RULE_ID=4; | ||
37 | public static final int T__26=26; | ||
38 | public static final int T__27=27; | ||
39 | public static final int T__28=28; | ||
40 | public static final int RULE_INT=5; | ||
41 | public static final int T__29=29; | ||
42 | public static final int T__22=22; | ||
43 | public static final int T__66=66; | ||
44 | public static final int RULE_ML_COMMENT=7; | ||
45 | public static final int T__23=23; | ||
46 | public static final int T__67=67; | ||
47 | public static final int T__24=24; | ||
48 | public static final int T__68=68; | ||
49 | public static final int T__25=25; | ||
50 | public static final int T__69=69; | ||
51 | public static final int T__62=62; | ||
52 | public static final int T__63=63; | ||
53 | public static final int T__20=20; | ||
54 | public static final int T__64=64; | ||
55 | public static final int T__21=21; | ||
56 | public static final int T__65=65; | ||
57 | public static final int T__70=70; | ||
58 | public static final int T__71=71; | ||
59 | public static final int T__72=72; | ||
60 | public static final int RULE_STRING=6; | ||
61 | public static final int RULE_SL_COMMENT=8; | ||
62 | public static final int T__37=37; | ||
63 | public static final int T__38=38; | ||
64 | public static final int T__39=39; | ||
65 | public static final int T__33=33; | ||
66 | public static final int T__34=34; | ||
67 | public static final int T__35=35; | ||
68 | public static final int T__36=36; | ||
69 | public static final int T__73=73; | ||
70 | public static final int EOF=-1; | ||
71 | public static final int T__30=30; | ||
72 | public static final int T__74=74; | ||
73 | public static final int T__31=31; | ||
74 | public static final int T__75=75; | ||
75 | public static final int T__32=32; | ||
76 | public static final int T__76=76; | ||
77 | public static final int RULE_WS=9; | ||
78 | public static final int RULE_ANY_OTHER=10; | ||
79 | public static final int T__48=48; | ||
80 | public static final int T__49=49; | ||
81 | public static final int T__44=44; | ||
82 | public static final int T__45=45; | ||
83 | public static final int T__46=46; | ||
84 | public static final int T__47=47; | ||
85 | public static final int T__40=40; | ||
86 | public static final int T__41=41; | ||
87 | public static final int T__42=42; | ||
88 | public static final int T__43=43; | ||
89 | |||
90 | // delegates | ||
91 | // delegators | ||
92 | |||
93 | public InternalAlloyLanguageLexer() {;} | ||
94 | public InternalAlloyLanguageLexer(CharStream input) { | ||
95 | this(input, new RecognizerSharedState()); | ||
96 | } | ||
97 | public InternalAlloyLanguageLexer(CharStream input, RecognizerSharedState state) { | ||
98 | super(input,state); | ||
99 | |||
100 | } | ||
101 | public String getGrammarFileName() { return "InternalAlloyLanguage.g"; } | ||
102 | |||
103 | // $ANTLR start "T__11" | ||
104 | public final void mT__11() throws RecognitionException { | ||
105 | try { | ||
106 | int _type = T__11; | ||
107 | int _channel = DEFAULT_TOKEN_CHANNEL; | ||
108 | // InternalAlloyLanguage.g:11:7: ( '||' ) | ||
109 | // InternalAlloyLanguage.g:11:9: '||' | ||
110 | { | ||
111 | match("||"); | ||
112 | |||
113 | |||
114 | } | ||
115 | |||
116 | state.type = _type; | ||
117 | state.channel = _channel; | ||
118 | } | ||
119 | finally { | ||
120 | } | ||
121 | } | ||
122 | // $ANTLR end "T__11" | ||
123 | |||
124 | // $ANTLR start "T__12" | ||
125 | public final void mT__12() throws RecognitionException { | ||
126 | try { | ||
127 | int _type = T__12; | ||
128 | int _channel = DEFAULT_TOKEN_CHANNEL; | ||
129 | // InternalAlloyLanguage.g:12:7: ( 'or' ) | ||
130 | // InternalAlloyLanguage.g:12:9: 'or' | ||
131 | { | ||
132 | match("or"); | ||
133 | |||
134 | |||
135 | } | ||
136 | |||
137 | state.type = _type; | ||
138 | state.channel = _channel; | ||
139 | } | ||
140 | finally { | ||
141 | } | ||
142 | } | ||
143 | // $ANTLR end "T__12" | ||
144 | |||
145 | // $ANTLR start "T__13" | ||
146 | public final void mT__13() throws RecognitionException { | ||
147 | try { | ||
148 | int _type = T__13; | ||
149 | int _channel = DEFAULT_TOKEN_CHANNEL; | ||
150 | // InternalAlloyLanguage.g:13:7: ( '<=>' ) | ||
151 | // InternalAlloyLanguage.g:13:9: '<=>' | ||
152 | { | ||
153 | match("<=>"); | ||
154 | |||
155 | |||
156 | } | ||
157 | |||
158 | state.type = _type; | ||
159 | state.channel = _channel; | ||
160 | } | ||
161 | finally { | ||
162 | } | ||
163 | } | ||
164 | // $ANTLR end "T__13" | ||
165 | |||
166 | // $ANTLR start "T__14" | ||
167 | public final void mT__14() throws RecognitionException { | ||
168 | try { | ||
169 | int _type = T__14; | ||
170 | int _channel = DEFAULT_TOKEN_CHANNEL; | ||
171 | // InternalAlloyLanguage.g:14:7: ( 'iff' ) | ||
172 | // InternalAlloyLanguage.g:14:9: 'iff' | ||
173 | { | ||
174 | match("iff"); | ||
175 | |||
176 | |||
177 | } | ||
178 | |||
179 | state.type = _type; | ||
180 | state.channel = _channel; | ||
181 | } | ||
182 | finally { | ||
183 | } | ||
184 | } | ||
185 | // $ANTLR end "T__14" | ||
186 | |||
187 | // $ANTLR start "T__15" | ||
188 | public final void mT__15() throws RecognitionException { | ||
189 | try { | ||
190 | int _type = T__15; | ||
191 | int _channel = DEFAULT_TOKEN_CHANNEL; | ||
192 | // InternalAlloyLanguage.g:15:7: ( '=>' ) | ||
193 | // InternalAlloyLanguage.g:15:9: '=>' | ||
194 | { | ||
195 | match("=>"); | ||
196 | |||
197 | |||
198 | } | ||
199 | |||
200 | state.type = _type; | ||
201 | state.channel = _channel; | ||
202 | } | ||
203 | finally { | ||
204 | } | ||
205 | } | ||
206 | // $ANTLR end "T__15" | ||
207 | |||
208 | // $ANTLR start "T__16" | ||
209 | public final void mT__16() throws RecognitionException { | ||
210 | try { | ||
211 | int _type = T__16; | ||
212 | int _channel = DEFAULT_TOKEN_CHANNEL; | ||
213 | // InternalAlloyLanguage.g:16:7: ( 'implies' ) | ||
214 | // InternalAlloyLanguage.g:16:9: 'implies' | ||
215 | { | ||
216 | match("implies"); | ||
217 | |||
218 | |||
219 | } | ||
220 | |||
221 | state.type = _type; | ||
222 | state.channel = _channel; | ||
223 | } | ||
224 | finally { | ||
225 | } | ||
226 | } | ||
227 | // $ANTLR end "T__16" | ||
228 | |||
229 | // $ANTLR start "T__17" | ||
230 | public final void mT__17() throws RecognitionException { | ||
231 | try { | ||
232 | int _type = T__17; | ||
233 | int _channel = DEFAULT_TOKEN_CHANNEL; | ||
234 | // InternalAlloyLanguage.g:17:7: ( '&&' ) | ||
235 | // InternalAlloyLanguage.g:17:9: '&&' | ||
236 | { | ||
237 | match("&&"); | ||
238 | |||
239 | |||
240 | } | ||
241 | |||
242 | state.type = _type; | ||
243 | state.channel = _channel; | ||
244 | } | ||
245 | finally { | ||
246 | } | ||
247 | } | ||
248 | // $ANTLR end "T__17" | ||
249 | |||
250 | // $ANTLR start "T__18" | ||
251 | public final void mT__18() throws RecognitionException { | ||
252 | try { | ||
253 | int _type = T__18; | ||
254 | int _channel = DEFAULT_TOKEN_CHANNEL; | ||
255 | // InternalAlloyLanguage.g:18:7: ( 'and' ) | ||
256 | // InternalAlloyLanguage.g:18:9: 'and' | ||
257 | { | ||
258 | match("and"); | ||
259 | |||
260 | |||
261 | } | ||
262 | |||
263 | state.type = _type; | ||
264 | state.channel = _channel; | ||
265 | } | ||
266 | finally { | ||
267 | } | ||
268 | } | ||
269 | // $ANTLR end "T__18" | ||
270 | |||
271 | // $ANTLR start "T__19" | ||
272 | public final void mT__19() throws RecognitionException { | ||
273 | try { | ||
274 | int _type = T__19; | ||
275 | int _channel = DEFAULT_TOKEN_CHANNEL; | ||
276 | // InternalAlloyLanguage.g:19:7: ( '!' ) | ||
277 | // InternalAlloyLanguage.g:19:9: '!' | ||
278 | { | ||
279 | match('!'); | ||
280 | |||
281 | } | ||
282 | |||
283 | state.type = _type; | ||
284 | state.channel = _channel; | ||
285 | } | ||
286 | finally { | ||
287 | } | ||
288 | } | ||
289 | // $ANTLR end "T__19" | ||
290 | |||
291 | // $ANTLR start "T__20" | ||
292 | public final void mT__20() throws RecognitionException { | ||
293 | try { | ||
294 | int _type = T__20; | ||
295 | int _channel = DEFAULT_TOKEN_CHANNEL; | ||
296 | // InternalAlloyLanguage.g:20:7: ( 'not' ) | ||
297 | // InternalAlloyLanguage.g:20:9: 'not' | ||
298 | { | ||
299 | match("not"); | ||
300 | |||
301 | |||
302 | } | ||
303 | |||
304 | state.type = _type; | ||
305 | state.channel = _channel; | ||
306 | } | ||
307 | finally { | ||
308 | } | ||
309 | } | ||
310 | // $ANTLR end "T__20" | ||
311 | |||
312 | // $ANTLR start "T__21" | ||
313 | public final void mT__21() throws RecognitionException { | ||
314 | try { | ||
315 | int _type = T__21; | ||
316 | int _channel = DEFAULT_TOKEN_CHANNEL; | ||
317 | // InternalAlloyLanguage.g:21:7: ( 'all' ) | ||
318 | // InternalAlloyLanguage.g:21:9: 'all' | ||
319 | { | ||
320 | match("all"); | ||
321 | |||
322 | |||
323 | } | ||
324 | |||
325 | state.type = _type; | ||
326 | state.channel = _channel; | ||
327 | } | ||
328 | finally { | ||
329 | } | ||
330 | } | ||
331 | // $ANTLR end "T__21" | ||
332 | |||
333 | // $ANTLR start "T__22" | ||
334 | public final void mT__22() throws RecognitionException { | ||
335 | try { | ||
336 | int _type = T__22; | ||
337 | int _channel = DEFAULT_TOKEN_CHANNEL; | ||
338 | // InternalAlloyLanguage.g:22:7: ( 'no' ) | ||
339 | // InternalAlloyLanguage.g:22:9: 'no' | ||
340 | { | ||
341 | match("no"); | ||
342 | |||
343 | |||
344 | } | ||
345 | |||
346 | state.type = _type; | ||
347 | state.channel = _channel; | ||
348 | } | ||
349 | finally { | ||
350 | } | ||
351 | } | ||
352 | // $ANTLR end "T__22" | ||
353 | |||
354 | // $ANTLR start "T__23" | ||
355 | public final void mT__23() throws RecognitionException { | ||
356 | try { | ||
357 | int _type = T__23; | ||
358 | int _channel = DEFAULT_TOKEN_CHANNEL; | ||
359 | // InternalAlloyLanguage.g:23:7: ( 'some' ) | ||
360 | // InternalAlloyLanguage.g:23:9: 'some' | ||
361 | { | ||
362 | match("some"); | ||
363 | |||
364 | |||
365 | } | ||
366 | |||
367 | state.type = _type; | ||
368 | state.channel = _channel; | ||
369 | } | ||
370 | finally { | ||
371 | } | ||
372 | } | ||
373 | // $ANTLR end "T__23" | ||
374 | |||
375 | // $ANTLR start "T__24" | ||
376 | public final void mT__24() throws RecognitionException { | ||
377 | try { | ||
378 | int _type = T__24; | ||
379 | int _channel = DEFAULT_TOKEN_CHANNEL; | ||
380 | // InternalAlloyLanguage.g:24:7: ( 'lone' ) | ||
381 | // InternalAlloyLanguage.g:24:9: 'lone' | ||
382 | { | ||
383 | match("lone"); | ||
384 | |||
385 | |||
386 | } | ||
387 | |||
388 | state.type = _type; | ||
389 | state.channel = _channel; | ||
390 | } | ||
391 | finally { | ||
392 | } | ||
393 | } | ||
394 | // $ANTLR end "T__24" | ||
395 | |||
396 | // $ANTLR start "T__25" | ||
397 | public final void mT__25() throws RecognitionException { | ||
398 | try { | ||
399 | int _type = T__25; | ||
400 | int _channel = DEFAULT_TOKEN_CHANNEL; | ||
401 | // InternalAlloyLanguage.g:25:7: ( 'one' ) | ||
402 | // InternalAlloyLanguage.g:25:9: 'one' | ||
403 | { | ||
404 | match("one"); | ||
405 | |||
406 | |||
407 | } | ||
408 | |||
409 | state.type = _type; | ||
410 | state.channel = _channel; | ||
411 | } | ||
412 | finally { | ||
413 | } | ||
414 | } | ||
415 | // $ANTLR end "T__25" | ||
416 | |||
417 | // $ANTLR start "T__26" | ||
418 | public final void mT__26() throws RecognitionException { | ||
419 | try { | ||
420 | int _type = T__26; | ||
421 | int _channel = DEFAULT_TOKEN_CHANNEL; | ||
422 | // InternalAlloyLanguage.g:26:7: ( 'set' ) | ||
423 | // InternalAlloyLanguage.g:26:9: 'set' | ||
424 | { | ||
425 | match("set"); | ||
426 | |||
427 | |||
428 | } | ||
429 | |||
430 | state.type = _type; | ||
431 | state.channel = _channel; | ||
432 | } | ||
433 | finally { | ||
434 | } | ||
435 | } | ||
436 | // $ANTLR end "T__26" | ||
437 | |||
438 | // $ANTLR start "T__27" | ||
439 | public final void mT__27() throws RecognitionException { | ||
440 | try { | ||
441 | int _type = T__27; | ||
442 | int _channel = DEFAULT_TOKEN_CHANNEL; | ||
443 | // InternalAlloyLanguage.g:27:7: ( 'plus' ) | ||
444 | // InternalAlloyLanguage.g:27:9: 'plus' | ||
445 | { | ||
446 | match("plus"); | ||
447 | |||
448 | |||
449 | } | ||
450 | |||
451 | state.type = _type; | ||
452 | state.channel = _channel; | ||
453 | } | ||
454 | finally { | ||
455 | } | ||
456 | } | ||
457 | // $ANTLR end "T__27" | ||
458 | |||
459 | // $ANTLR start "T__28" | ||
460 | public final void mT__28() throws RecognitionException { | ||
461 | try { | ||
462 | int _type = T__28; | ||
463 | int _channel = DEFAULT_TOKEN_CHANNEL; | ||
464 | // InternalAlloyLanguage.g:28:7: ( 'sub' ) | ||
465 | // InternalAlloyLanguage.g:28:9: 'sub' | ||
466 | { | ||
467 | match("sub"); | ||
468 | |||
469 | |||
470 | } | ||
471 | |||
472 | state.type = _type; | ||
473 | state.channel = _channel; | ||
474 | } | ||
475 | finally { | ||
476 | } | ||
477 | } | ||
478 | // $ANTLR end "T__28" | ||
479 | |||
480 | // $ANTLR start "T__29" | ||
481 | public final void mT__29() throws RecognitionException { | ||
482 | try { | ||
483 | int _type = T__29; | ||
484 | int _channel = DEFAULT_TOKEN_CHANNEL; | ||
485 | // InternalAlloyLanguage.g:29:7: ( 'mul' ) | ||
486 | // InternalAlloyLanguage.g:29:9: 'mul' | ||
487 | { | ||
488 | match("mul"); | ||
489 | |||
490 | |||
491 | } | ||
492 | |||
493 | state.type = _type; | ||
494 | state.channel = _channel; | ||
495 | } | ||
496 | finally { | ||
497 | } | ||
498 | } | ||
499 | // $ANTLR end "T__29" | ||
500 | |||
501 | // $ANTLR start "T__30" | ||
502 | public final void mT__30() throws RecognitionException { | ||
503 | try { | ||
504 | int _type = T__30; | ||
505 | int _channel = DEFAULT_TOKEN_CHANNEL; | ||
506 | // InternalAlloyLanguage.g:30:7: ( 'rem' ) | ||
507 | // InternalAlloyLanguage.g:30:9: 'rem' | ||
508 | { | ||
509 | match("rem"); | ||
510 | |||
511 | |||
512 | } | ||
513 | |||
514 | state.type = _type; | ||
515 | state.channel = _channel; | ||
516 | } | ||
517 | finally { | ||
518 | } | ||
519 | } | ||
520 | // $ANTLR end "T__30" | ||
521 | |||
522 | // $ANTLR start "T__31" | ||
523 | public final void mT__31() throws RecognitionException { | ||
524 | try { | ||
525 | int _type = T__31; | ||
526 | int _channel = DEFAULT_TOKEN_CHANNEL; | ||
527 | // InternalAlloyLanguage.g:31:7: ( 'div' ) | ||
528 | // InternalAlloyLanguage.g:31:9: 'div' | ||
529 | { | ||
530 | match("div"); | ||
531 | |||
532 | |||
533 | } | ||
534 | |||
535 | state.type = _type; | ||
536 | state.channel = _channel; | ||
537 | } | ||
538 | finally { | ||
539 | } | ||
540 | } | ||
541 | // $ANTLR end "T__31" | ||
542 | |||
543 | // $ANTLR start "T__32" | ||
544 | public final void mT__32() throws RecognitionException { | ||
545 | try { | ||
546 | int _type = T__32; | ||
547 | int _channel = DEFAULT_TOKEN_CHANNEL; | ||
548 | // InternalAlloyLanguage.g:32:7: ( 'enum' ) | ||
549 | // InternalAlloyLanguage.g:32:9: 'enum' | ||
550 | { | ||
551 | match("enum"); | ||
552 | |||
553 | |||
554 | } | ||
555 | |||
556 | state.type = _type; | ||
557 | state.channel = _channel; | ||
558 | } | ||
559 | finally { | ||
560 | } | ||
561 | } | ||
562 | // $ANTLR end "T__32" | ||
563 | |||
564 | // $ANTLR start "T__33" | ||
565 | public final void mT__33() throws RecognitionException { | ||
566 | try { | ||
567 | int _type = T__33; | ||
568 | int _channel = DEFAULT_TOKEN_CHANNEL; | ||
569 | // InternalAlloyLanguage.g:33:7: ( '{' ) | ||
570 | // InternalAlloyLanguage.g:33:9: '{' | ||
571 | { | ||
572 | match('{'); | ||
573 | |||
574 | } | ||
575 | |||
576 | state.type = _type; | ||
577 | state.channel = _channel; | ||
578 | } | ||
579 | finally { | ||
580 | } | ||
581 | } | ||
582 | // $ANTLR end "T__33" | ||
583 | |||
584 | // $ANTLR start "T__34" | ||
585 | public final void mT__34() throws RecognitionException { | ||
586 | try { | ||
587 | int _type = T__34; | ||
588 | int _channel = DEFAULT_TOKEN_CHANNEL; | ||
589 | // InternalAlloyLanguage.g:34:7: ( '}' ) | ||
590 | // InternalAlloyLanguage.g:34:9: '}' | ||
591 | { | ||
592 | match('}'); | ||
593 | |||
594 | } | ||
595 | |||
596 | state.type = _type; | ||
597 | state.channel = _channel; | ||
598 | } | ||
599 | finally { | ||
600 | } | ||
601 | } | ||
602 | // $ANTLR end "T__34" | ||
603 | |||
604 | // $ANTLR start "T__35" | ||
605 | public final void mT__35() throws RecognitionException { | ||
606 | try { | ||
607 | int _type = T__35; | ||
608 | int _channel = DEFAULT_TOKEN_CHANNEL; | ||
609 | // InternalAlloyLanguage.g:35:7: ( ',' ) | ||
610 | // InternalAlloyLanguage.g:35:9: ',' | ||
611 | { | ||
612 | match(','); | ||
613 | |||
614 | } | ||
615 | |||
616 | state.type = _type; | ||
617 | state.channel = _channel; | ||
618 | } | ||
619 | finally { | ||
620 | } | ||
621 | } | ||
622 | // $ANTLR end "T__35" | ||
623 | |||
624 | // $ANTLR start "T__36" | ||
625 | public final void mT__36() throws RecognitionException { | ||
626 | try { | ||
627 | int _type = T__36; | ||
628 | int _channel = DEFAULT_TOKEN_CHANNEL; | ||
629 | // InternalAlloyLanguage.g:36:7: ( 'sig' ) | ||
630 | // InternalAlloyLanguage.g:36:9: 'sig' | ||
631 | { | ||
632 | match("sig"); | ||
633 | |||
634 | |||
635 | } | ||
636 | |||
637 | state.type = _type; | ||
638 | state.channel = _channel; | ||
639 | } | ||
640 | finally { | ||
641 | } | ||
642 | } | ||
643 | // $ANTLR end "T__36" | ||
644 | |||
645 | // $ANTLR start "T__37" | ||
646 | public final void mT__37() throws RecognitionException { | ||
647 | try { | ||
648 | int _type = T__37; | ||
649 | int _channel = DEFAULT_TOKEN_CHANNEL; | ||
650 | // InternalAlloyLanguage.g:37:7: ( 'extends' ) | ||
651 | // InternalAlloyLanguage.g:37:9: 'extends' | ||
652 | { | ||
653 | match("extends"); | ||
654 | |||
655 | |||
656 | } | ||
657 | |||
658 | state.type = _type; | ||
659 | state.channel = _channel; | ||
660 | } | ||
661 | finally { | ||
662 | } | ||
663 | } | ||
664 | // $ANTLR end "T__37" | ||
665 | |||
666 | // $ANTLR start "T__38" | ||
667 | public final void mT__38() throws RecognitionException { | ||
668 | try { | ||
669 | int _type = T__38; | ||
670 | int _channel = DEFAULT_TOKEN_CHANNEL; | ||
671 | // InternalAlloyLanguage.g:38:7: ( 'in' ) | ||
672 | // InternalAlloyLanguage.g:38:9: 'in' | ||
673 | { | ||
674 | match("in"); | ||
675 | |||
676 | |||
677 | } | ||
678 | |||
679 | state.type = _type; | ||
680 | state.channel = _channel; | ||
681 | } | ||
682 | finally { | ||
683 | } | ||
684 | } | ||
685 | // $ANTLR end "T__38" | ||
686 | |||
687 | // $ANTLR start "T__39" | ||
688 | public final void mT__39() throws RecognitionException { | ||
689 | try { | ||
690 | int _type = T__39; | ||
691 | int _channel = DEFAULT_TOKEN_CHANNEL; | ||
692 | // InternalAlloyLanguage.g:39:7: ( '+' ) | ||
693 | // InternalAlloyLanguage.g:39:9: '+' | ||
694 | { | ||
695 | match('+'); | ||
696 | |||
697 | } | ||
698 | |||
699 | state.type = _type; | ||
700 | state.channel = _channel; | ||
701 | } | ||
702 | finally { | ||
703 | } | ||
704 | } | ||
705 | // $ANTLR end "T__39" | ||
706 | |||
707 | // $ANTLR start "T__40" | ||
708 | public final void mT__40() throws RecognitionException { | ||
709 | try { | ||
710 | int _type = T__40; | ||
711 | int _channel = DEFAULT_TOKEN_CHANNEL; | ||
712 | // InternalAlloyLanguage.g:40:7: ( ':' ) | ||
713 | // InternalAlloyLanguage.g:40:9: ':' | ||
714 | { | ||
715 | match(':'); | ||
716 | |||
717 | } | ||
718 | |||
719 | state.type = _type; | ||
720 | state.channel = _channel; | ||
721 | } | ||
722 | finally { | ||
723 | } | ||
724 | } | ||
725 | // $ANTLR end "T__40" | ||
726 | |||
727 | // $ANTLR start "T__41" | ||
728 | public final void mT__41() throws RecognitionException { | ||
729 | try { | ||
730 | int _type = T__41; | ||
731 | int _channel = DEFAULT_TOKEN_CHANNEL; | ||
732 | // InternalAlloyLanguage.g:41:7: ( 'fun' ) | ||
733 | // InternalAlloyLanguage.g:41:9: 'fun' | ||
734 | { | ||
735 | match("fun"); | ||
736 | |||
737 | |||
738 | } | ||
739 | |||
740 | state.type = _type; | ||
741 | state.channel = _channel; | ||
742 | } | ||
743 | finally { | ||
744 | } | ||
745 | } | ||
746 | // $ANTLR end "T__41" | ||
747 | |||
748 | // $ANTLR start "T__42" | ||
749 | public final void mT__42() throws RecognitionException { | ||
750 | try { | ||
751 | int _type = T__42; | ||
752 | int _channel = DEFAULT_TOKEN_CHANNEL; | ||
753 | // InternalAlloyLanguage.g:42:7: ( '[' ) | ||
754 | // InternalAlloyLanguage.g:42:9: '[' | ||
755 | { | ||
756 | match('['); | ||
757 | |||
758 | } | ||
759 | |||
760 | state.type = _type; | ||
761 | state.channel = _channel; | ||
762 | } | ||
763 | finally { | ||
764 | } | ||
765 | } | ||
766 | // $ANTLR end "T__42" | ||
767 | |||
768 | // $ANTLR start "T__43" | ||
769 | public final void mT__43() throws RecognitionException { | ||
770 | try { | ||
771 | int _type = T__43; | ||
772 | int _channel = DEFAULT_TOKEN_CHANNEL; | ||
773 | // InternalAlloyLanguage.g:43:7: ( ']' ) | ||
774 | // InternalAlloyLanguage.g:43:9: ']' | ||
775 | { | ||
776 | match(']'); | ||
777 | |||
778 | } | ||
779 | |||
780 | state.type = _type; | ||
781 | state.channel = _channel; | ||
782 | } | ||
783 | finally { | ||
784 | } | ||
785 | } | ||
786 | // $ANTLR end "T__43" | ||
787 | |||
788 | // $ANTLR start "T__44" | ||
789 | public final void mT__44() throws RecognitionException { | ||
790 | try { | ||
791 | int _type = T__44; | ||
792 | int _channel = DEFAULT_TOKEN_CHANNEL; | ||
793 | // InternalAlloyLanguage.g:44:7: ( 'pred' ) | ||
794 | // InternalAlloyLanguage.g:44:9: 'pred' | ||
795 | { | ||
796 | match("pred"); | ||
797 | |||
798 | |||
799 | } | ||
800 | |||
801 | state.type = _type; | ||
802 | state.channel = _channel; | ||
803 | } | ||
804 | finally { | ||
805 | } | ||
806 | } | ||
807 | // $ANTLR end "T__44" | ||
808 | |||
809 | // $ANTLR start "T__45" | ||
810 | public final void mT__45() throws RecognitionException { | ||
811 | try { | ||
812 | int _type = T__45; | ||
813 | int _channel = DEFAULT_TOKEN_CHANNEL; | ||
814 | // InternalAlloyLanguage.g:45:7: ( 'fact' ) | ||
815 | // InternalAlloyLanguage.g:45:9: 'fact' | ||
816 | { | ||
817 | match("fact"); | ||
818 | |||
819 | |||
820 | } | ||
821 | |||
822 | state.type = _type; | ||
823 | state.channel = _channel; | ||
824 | } | ||
825 | finally { | ||
826 | } | ||
827 | } | ||
828 | // $ANTLR end "T__45" | ||
829 | |||
830 | // $ANTLR start "T__46" | ||
831 | public final void mT__46() throws RecognitionException { | ||
832 | try { | ||
833 | int _type = T__46; | ||
834 | int _channel = DEFAULT_TOKEN_CHANNEL; | ||
835 | // InternalAlloyLanguage.g:46:7: ( 'else' ) | ||
836 | // InternalAlloyLanguage.g:46:9: 'else' | ||
837 | { | ||
838 | match("else"); | ||
839 | |||
840 | |||
841 | } | ||
842 | |||
843 | state.type = _type; | ||
844 | state.channel = _channel; | ||
845 | } | ||
846 | finally { | ||
847 | } | ||
848 | } | ||
849 | // $ANTLR end "T__46" | ||
850 | |||
851 | // $ANTLR start "T__47" | ||
852 | public final void mT__47() throws RecognitionException { | ||
853 | try { | ||
854 | int _type = T__47; | ||
855 | int _channel = DEFAULT_TOKEN_CHANNEL; | ||
856 | // InternalAlloyLanguage.g:47:7: ( '=' ) | ||
857 | // InternalAlloyLanguage.g:47:9: '=' | ||
858 | { | ||
859 | match('='); | ||
860 | |||
861 | } | ||
862 | |||
863 | state.type = _type; | ||
864 | state.channel = _channel; | ||
865 | } | ||
866 | finally { | ||
867 | } | ||
868 | } | ||
869 | // $ANTLR end "T__47" | ||
870 | |||
871 | // $ANTLR start "T__48" | ||
872 | public final void mT__48() throws RecognitionException { | ||
873 | try { | ||
874 | int _type = T__48; | ||
875 | int _channel = DEFAULT_TOKEN_CHANNEL; | ||
876 | // InternalAlloyLanguage.g:48:7: ( '!=' ) | ||
877 | // InternalAlloyLanguage.g:48:9: '!=' | ||
878 | { | ||
879 | match("!="); | ||
880 | |||
881 | |||
882 | } | ||
883 | |||
884 | state.type = _type; | ||
885 | state.channel = _channel; | ||
886 | } | ||
887 | finally { | ||
888 | } | ||
889 | } | ||
890 | // $ANTLR end "T__48" | ||
891 | |||
892 | // $ANTLR start "T__49" | ||
893 | public final void mT__49() throws RecognitionException { | ||
894 | try { | ||
895 | int _type = T__49; | ||
896 | int _channel = DEFAULT_TOKEN_CHANNEL; | ||
897 | // InternalAlloyLanguage.g:49:7: ( '>' ) | ||
898 | // InternalAlloyLanguage.g:49:9: '>' | ||
899 | { | ||
900 | match('>'); | ||
901 | |||
902 | } | ||
903 | |||
904 | state.type = _type; | ||
905 | state.channel = _channel; | ||
906 | } | ||
907 | finally { | ||
908 | } | ||
909 | } | ||
910 | // $ANTLR end "T__49" | ||
911 | |||
912 | // $ANTLR start "T__50" | ||
913 | public final void mT__50() throws RecognitionException { | ||
914 | try { | ||
915 | int _type = T__50; | ||
916 | int _channel = DEFAULT_TOKEN_CHANNEL; | ||
917 | // InternalAlloyLanguage.g:50:7: ( '>=' ) | ||
918 | // InternalAlloyLanguage.g:50:9: '>=' | ||
919 | { | ||
920 | match(">="); | ||
921 | |||
922 | |||
923 | } | ||
924 | |||
925 | state.type = _type; | ||
926 | state.channel = _channel; | ||
927 | } | ||
928 | finally { | ||
929 | } | ||
930 | } | ||
931 | // $ANTLR end "T__50" | ||
932 | |||
933 | // $ANTLR start "T__51" | ||
934 | public final void mT__51() throws RecognitionException { | ||
935 | try { | ||
936 | int _type = T__51; | ||
937 | int _channel = DEFAULT_TOKEN_CHANNEL; | ||
938 | // InternalAlloyLanguage.g:51:7: ( '<' ) | ||
939 | // InternalAlloyLanguage.g:51:9: '<' | ||
940 | { | ||
941 | match('<'); | ||
942 | |||
943 | } | ||
944 | |||
945 | state.type = _type; | ||
946 | state.channel = _channel; | ||
947 | } | ||
948 | finally { | ||
949 | } | ||
950 | } | ||
951 | // $ANTLR end "T__51" | ||
952 | |||
953 | // $ANTLR start "T__52" | ||
954 | public final void mT__52() throws RecognitionException { | ||
955 | try { | ||
956 | int _type = T__52; | ||
957 | int _channel = DEFAULT_TOKEN_CHANNEL; | ||
958 | // InternalAlloyLanguage.g:52:7: ( '<=' ) | ||
959 | // InternalAlloyLanguage.g:52:9: '<=' | ||
960 | { | ||
961 | match("<="); | ||
962 | |||
963 | |||
964 | } | ||
965 | |||
966 | state.type = _type; | ||
967 | state.channel = _channel; | ||
968 | } | ||
969 | finally { | ||
970 | } | ||
971 | } | ||
972 | // $ANTLR end "T__52" | ||
973 | |||
974 | // $ANTLR start "T__53" | ||
975 | public final void mT__53() throws RecognitionException { | ||
976 | try { | ||
977 | int _type = T__53; | ||
978 | int _channel = DEFAULT_TOKEN_CHANNEL; | ||
979 | // InternalAlloyLanguage.g:53:7: ( '++' ) | ||
980 | // InternalAlloyLanguage.g:53:9: '++' | ||
981 | { | ||
982 | match("++"); | ||
983 | |||
984 | |||
985 | } | ||
986 | |||
987 | state.type = _type; | ||
988 | state.channel = _channel; | ||
989 | } | ||
990 | finally { | ||
991 | } | ||
992 | } | ||
993 | // $ANTLR end "T__53" | ||
994 | |||
995 | // $ANTLR start "T__54" | ||
996 | public final void mT__54() throws RecognitionException { | ||
997 | try { | ||
998 | int _type = T__54; | ||
999 | int _channel = DEFAULT_TOKEN_CHANNEL; | ||
1000 | // InternalAlloyLanguage.g:54:7: ( ':>' ) | ||
1001 | // InternalAlloyLanguage.g:54:9: ':>' | ||
1002 | { | ||
1003 | match(":>"); | ||
1004 | |||
1005 | |||
1006 | } | ||
1007 | |||
1008 | state.type = _type; | ||
1009 | state.channel = _channel; | ||
1010 | } | ||
1011 | finally { | ||
1012 | } | ||
1013 | } | ||
1014 | // $ANTLR end "T__54" | ||
1015 | |||
1016 | // $ANTLR start "T__55" | ||
1017 | public final void mT__55() throws RecognitionException { | ||
1018 | try { | ||
1019 | int _type = T__55; | ||
1020 | int _channel = DEFAULT_TOKEN_CHANNEL; | ||
1021 | // InternalAlloyLanguage.g:55:7: ( '<:' ) | ||
1022 | // InternalAlloyLanguage.g:55:9: '<:' | ||
1023 | { | ||
1024 | match("<:"); | ||
1025 | |||
1026 | |||
1027 | } | ||
1028 | |||
1029 | state.type = _type; | ||
1030 | state.channel = _channel; | ||
1031 | } | ||
1032 | finally { | ||
1033 | } | ||
1034 | } | ||
1035 | // $ANTLR end "T__55" | ||
1036 | |||
1037 | // $ANTLR start "T__56" | ||
1038 | public final void mT__56() throws RecognitionException { | ||
1039 | try { | ||
1040 | int _type = T__56; | ||
1041 | int _channel = DEFAULT_TOKEN_CHANNEL; | ||
1042 | // InternalAlloyLanguage.g:56:7: ( '.' ) | ||
1043 | // InternalAlloyLanguage.g:56:9: '.' | ||
1044 | { | ||
1045 | match('.'); | ||
1046 | |||
1047 | } | ||
1048 | |||
1049 | state.type = _type; | ||
1050 | state.channel = _channel; | ||
1051 | } | ||
1052 | finally { | ||
1053 | } | ||
1054 | } | ||
1055 | // $ANTLR end "T__56" | ||
1056 | |||
1057 | // $ANTLR start "T__57" | ||
1058 | public final void mT__57() throws RecognitionException { | ||
1059 | try { | ||
1060 | int _type = T__57; | ||
1061 | int _channel = DEFAULT_TOKEN_CHANNEL; | ||
1062 | // InternalAlloyLanguage.g:57:7: ( '-' ) | ||
1063 | // InternalAlloyLanguage.g:57:9: '-' | ||
1064 | { | ||
1065 | match('-'); | ||
1066 | |||
1067 | } | ||
1068 | |||
1069 | state.type = _type; | ||
1070 | state.channel = _channel; | ||
1071 | } | ||
1072 | finally { | ||
1073 | } | ||
1074 | } | ||
1075 | // $ANTLR end "T__57" | ||
1076 | |||
1077 | // $ANTLR start "T__58" | ||
1078 | public final void mT__58() throws RecognitionException { | ||
1079 | try { | ||
1080 | int _type = T__58; | ||
1081 | int _channel = DEFAULT_TOKEN_CHANNEL; | ||
1082 | // InternalAlloyLanguage.g:58:7: ( '&' ) | ||
1083 | // InternalAlloyLanguage.g:58:9: '&' | ||
1084 | { | ||
1085 | match('&'); | ||
1086 | |||
1087 | } | ||
1088 | |||
1089 | state.type = _type; | ||
1090 | state.channel = _channel; | ||
1091 | } | ||
1092 | finally { | ||
1093 | } | ||
1094 | } | ||
1095 | // $ANTLR end "T__58" | ||
1096 | |||
1097 | // $ANTLR start "T__59" | ||
1098 | public final void mT__59() throws RecognitionException { | ||
1099 | try { | ||
1100 | int _type = T__59; | ||
1101 | int _channel = DEFAULT_TOKEN_CHANNEL; | ||
1102 | // InternalAlloyLanguage.g:59:7: ( '->' ) | ||
1103 | // InternalAlloyLanguage.g:59:9: '->' | ||
1104 | { | ||
1105 | match("->"); | ||
1106 | |||
1107 | |||
1108 | } | ||
1109 | |||
1110 | state.type = _type; | ||
1111 | state.channel = _channel; | ||
1112 | } | ||
1113 | finally { | ||
1114 | } | ||
1115 | } | ||
1116 | // $ANTLR end "T__59" | ||
1117 | |||
1118 | // $ANTLR start "T__60" | ||
1119 | public final void mT__60() throws RecognitionException { | ||
1120 | try { | ||
1121 | int _type = T__60; | ||
1122 | int _channel = DEFAULT_TOKEN_CHANNEL; | ||
1123 | // InternalAlloyLanguage.g:60:7: ( '~' ) | ||
1124 | // InternalAlloyLanguage.g:60:9: '~' | ||
1125 | { | ||
1126 | match('~'); | ||
1127 | |||
1128 | } | ||
1129 | |||
1130 | state.type = _type; | ||
1131 | state.channel = _channel; | ||
1132 | } | ||
1133 | finally { | ||
1134 | } | ||
1135 | } | ||
1136 | // $ANTLR end "T__60" | ||
1137 | |||
1138 | // $ANTLR start "T__61" | ||
1139 | public final void mT__61() throws RecognitionException { | ||
1140 | try { | ||
1141 | int _type = T__61; | ||
1142 | int _channel = DEFAULT_TOKEN_CHANNEL; | ||
1143 | // InternalAlloyLanguage.g:61:7: ( '^' ) | ||
1144 | // InternalAlloyLanguage.g:61:9: '^' | ||
1145 | { | ||
1146 | match('^'); | ||
1147 | |||
1148 | } | ||
1149 | |||
1150 | state.type = _type; | ||
1151 | state.channel = _channel; | ||
1152 | } | ||
1153 | finally { | ||
1154 | } | ||
1155 | } | ||
1156 | // $ANTLR end "T__61" | ||
1157 | |||
1158 | // $ANTLR start "T__62" | ||
1159 | public final void mT__62() throws RecognitionException { | ||
1160 | try { | ||
1161 | int _type = T__62; | ||
1162 | int _channel = DEFAULT_TOKEN_CHANNEL; | ||
1163 | // InternalAlloyLanguage.g:62:7: ( '*' ) | ||
1164 | // InternalAlloyLanguage.g:62:9: '*' | ||
1165 | { | ||
1166 | match('*'); | ||
1167 | |||
1168 | } | ||
1169 | |||
1170 | state.type = _type; | ||
1171 | state.channel = _channel; | ||
1172 | } | ||
1173 | finally { | ||
1174 | } | ||
1175 | } | ||
1176 | // $ANTLR end "T__62" | ||
1177 | |||
1178 | // $ANTLR start "T__63" | ||
1179 | public final void mT__63() throws RecognitionException { | ||
1180 | try { | ||
1181 | int _type = T__63; | ||
1182 | int _channel = DEFAULT_TOKEN_CHANNEL; | ||
1183 | // InternalAlloyLanguage.g:63:7: ( '#' ) | ||
1184 | // InternalAlloyLanguage.g:63:9: '#' | ||
1185 | { | ||
1186 | match('#'); | ||
1187 | |||
1188 | } | ||
1189 | |||
1190 | state.type = _type; | ||
1191 | state.channel = _channel; | ||
1192 | } | ||
1193 | finally { | ||
1194 | } | ||
1195 | } | ||
1196 | // $ANTLR end "T__63" | ||
1197 | |||
1198 | // $ANTLR start "T__64" | ||
1199 | public final void mT__64() throws RecognitionException { | ||
1200 | try { | ||
1201 | int _type = T__64; | ||
1202 | int _channel = DEFAULT_TOKEN_CHANNEL; | ||
1203 | // InternalAlloyLanguage.g:64:7: ( 'sum' ) | ||
1204 | // InternalAlloyLanguage.g:64:9: 'sum' | ||
1205 | { | ||
1206 | match("sum"); | ||
1207 | |||
1208 | |||
1209 | } | ||
1210 | |||
1211 | state.type = _type; | ||
1212 | state.channel = _channel; | ||
1213 | } | ||
1214 | finally { | ||
1215 | } | ||
1216 | } | ||
1217 | // $ANTLR end "T__64" | ||
1218 | |||
1219 | // $ANTLR start "T__65" | ||
1220 | public final void mT__65() throws RecognitionException { | ||
1221 | try { | ||
1222 | int _type = T__65; | ||
1223 | int _channel = DEFAULT_TOKEN_CHANNEL; | ||
1224 | // InternalAlloyLanguage.g:65:7: ( 'none' ) | ||
1225 | // InternalAlloyLanguage.g:65:9: 'none' | ||
1226 | { | ||
1227 | match("none"); | ||
1228 | |||
1229 | |||
1230 | } | ||
1231 | |||
1232 | state.type = _type; | ||
1233 | state.channel = _channel; | ||
1234 | } | ||
1235 | finally { | ||
1236 | } | ||
1237 | } | ||
1238 | // $ANTLR end "T__65" | ||
1239 | |||
1240 | // $ANTLR start "T__66" | ||
1241 | public final void mT__66() throws RecognitionException { | ||
1242 | try { | ||
1243 | int _type = T__66; | ||
1244 | int _channel = DEFAULT_TOKEN_CHANNEL; | ||
1245 | // InternalAlloyLanguage.g:66:7: ( 'iden' ) | ||
1246 | // InternalAlloyLanguage.g:66:9: 'iden' | ||
1247 | { | ||
1248 | match("iden"); | ||
1249 | |||
1250 | |||
1251 | } | ||
1252 | |||
1253 | state.type = _type; | ||
1254 | state.channel = _channel; | ||
1255 | } | ||
1256 | finally { | ||
1257 | } | ||
1258 | } | ||
1259 | // $ANTLR end "T__66" | ||
1260 | |||
1261 | // $ANTLR start "T__67" | ||
1262 | public final void mT__67() throws RecognitionException { | ||
1263 | try { | ||
1264 | int _type = T__67; | ||
1265 | int _channel = DEFAULT_TOKEN_CHANNEL; | ||
1266 | // InternalAlloyLanguage.g:67:7: ( 'univ' ) | ||
1267 | // InternalAlloyLanguage.g:67:9: 'univ' | ||
1268 | { | ||
1269 | match("univ"); | ||
1270 | |||
1271 | |||
1272 | } | ||
1273 | |||
1274 | state.type = _type; | ||
1275 | state.channel = _channel; | ||
1276 | } | ||
1277 | finally { | ||
1278 | } | ||
1279 | } | ||
1280 | // $ANTLR end "T__67" | ||
1281 | |||
1282 | // $ANTLR start "T__68" | ||
1283 | public final void mT__68() throws RecognitionException { | ||
1284 | try { | ||
1285 | int _type = T__68; | ||
1286 | int _channel = DEFAULT_TOKEN_CHANNEL; | ||
1287 | // InternalAlloyLanguage.g:68:7: ( 'Int' ) | ||
1288 | // InternalAlloyLanguage.g:68:9: 'Int' | ||
1289 | { | ||
1290 | match("Int"); | ||
1291 | |||
1292 | |||
1293 | } | ||
1294 | |||
1295 | state.type = _type; | ||
1296 | state.channel = _channel; | ||
1297 | } | ||
1298 | finally { | ||
1299 | } | ||
1300 | } | ||
1301 | // $ANTLR end "T__68" | ||
1302 | |||
1303 | // $ANTLR start "T__69" | ||
1304 | public final void mT__69() throws RecognitionException { | ||
1305 | try { | ||
1306 | int _type = T__69; | ||
1307 | int _channel = DEFAULT_TOKEN_CHANNEL; | ||
1308 | // InternalAlloyLanguage.g:69:7: ( 'String' ) | ||
1309 | // InternalAlloyLanguage.g:69:9: 'String' | ||
1310 | { | ||
1311 | match("String"); | ||
1312 | |||
1313 | |||
1314 | } | ||
1315 | |||
1316 | state.type = _type; | ||
1317 | state.channel = _channel; | ||
1318 | } | ||
1319 | finally { | ||
1320 | } | ||
1321 | } | ||
1322 | // $ANTLR end "T__69" | ||
1323 | |||
1324 | // $ANTLR start "T__70" | ||
1325 | public final void mT__70() throws RecognitionException { | ||
1326 | try { | ||
1327 | int _type = T__70; | ||
1328 | int _channel = DEFAULT_TOKEN_CHANNEL; | ||
1329 | // InternalAlloyLanguage.g:70:7: ( '(' ) | ||
1330 | // InternalAlloyLanguage.g:70:9: '(' | ||
1331 | { | ||
1332 | match('('); | ||
1333 | |||
1334 | } | ||
1335 | |||
1336 | state.type = _type; | ||
1337 | state.channel = _channel; | ||
1338 | } | ||
1339 | finally { | ||
1340 | } | ||
1341 | } | ||
1342 | // $ANTLR end "T__70" | ||
1343 | |||
1344 | // $ANTLR start "T__71" | ||
1345 | public final void mT__71() throws RecognitionException { | ||
1346 | try { | ||
1347 | int _type = T__71; | ||
1348 | int _channel = DEFAULT_TOKEN_CHANNEL; | ||
1349 | // InternalAlloyLanguage.g:71:7: ( ')' ) | ||
1350 | // InternalAlloyLanguage.g:71:9: ')' | ||
1351 | { | ||
1352 | match(')'); | ||
1353 | |||
1354 | } | ||
1355 | |||
1356 | state.type = _type; | ||
1357 | state.channel = _channel; | ||
1358 | } | ||
1359 | finally { | ||
1360 | } | ||
1361 | } | ||
1362 | // $ANTLR end "T__71" | ||
1363 | |||
1364 | // $ANTLR start "T__72" | ||
1365 | public final void mT__72() throws RecognitionException { | ||
1366 | try { | ||
1367 | int _type = T__72; | ||
1368 | int _channel = DEFAULT_TOKEN_CHANNEL; | ||
1369 | // InternalAlloyLanguage.g:72:7: ( 'run' ) | ||
1370 | // InternalAlloyLanguage.g:72:9: 'run' | ||
1371 | { | ||
1372 | match("run"); | ||
1373 | |||
1374 | |||
1375 | } | ||
1376 | |||
1377 | state.type = _type; | ||
1378 | state.channel = _channel; | ||
1379 | } | ||
1380 | finally { | ||
1381 | } | ||
1382 | } | ||
1383 | // $ANTLR end "T__72" | ||
1384 | |||
1385 | // $ANTLR start "T__73" | ||
1386 | public final void mT__73() throws RecognitionException { | ||
1387 | try { | ||
1388 | int _type = T__73; | ||
1389 | int _channel = DEFAULT_TOKEN_CHANNEL; | ||
1390 | // InternalAlloyLanguage.g:73:7: ( 'for' ) | ||
1391 | // InternalAlloyLanguage.g:73:9: 'for' | ||
1392 | { | ||
1393 | match("for"); | ||
1394 | |||
1395 | |||
1396 | } | ||
1397 | |||
1398 | state.type = _type; | ||
1399 | state.channel = _channel; | ||
1400 | } | ||
1401 | finally { | ||
1402 | } | ||
1403 | } | ||
1404 | // $ANTLR end "T__73" | ||
1405 | |||
1406 | // $ANTLR start "T__74" | ||
1407 | public final void mT__74() throws RecognitionException { | ||
1408 | try { | ||
1409 | int _type = T__74; | ||
1410 | int _channel = DEFAULT_TOKEN_CHANNEL; | ||
1411 | // InternalAlloyLanguage.g:74:7: ( 'exactly' ) | ||
1412 | // InternalAlloyLanguage.g:74:9: 'exactly' | ||
1413 | { | ||
1414 | match("exactly"); | ||
1415 | |||
1416 | |||
1417 | } | ||
1418 | |||
1419 | state.type = _type; | ||
1420 | state.channel = _channel; | ||
1421 | } | ||
1422 | finally { | ||
1423 | } | ||
1424 | } | ||
1425 | // $ANTLR end "T__74" | ||
1426 | |||
1427 | // $ANTLR start "T__75" | ||
1428 | public final void mT__75() throws RecognitionException { | ||
1429 | try { | ||
1430 | int _type = T__75; | ||
1431 | int _channel = DEFAULT_TOKEN_CHANNEL; | ||
1432 | // InternalAlloyLanguage.g:75:7: ( 'abstract' ) | ||
1433 | // InternalAlloyLanguage.g:75:9: 'abstract' | ||
1434 | { | ||
1435 | match("abstract"); | ||
1436 | |||
1437 | |||
1438 | } | ||
1439 | |||
1440 | state.type = _type; | ||
1441 | state.channel = _channel; | ||
1442 | } | ||
1443 | finally { | ||
1444 | } | ||
1445 | } | ||
1446 | // $ANTLR end "T__75" | ||
1447 | |||
1448 | // $ANTLR start "T__76" | ||
1449 | public final void mT__76() throws RecognitionException { | ||
1450 | try { | ||
1451 | int _type = T__76; | ||
1452 | int _channel = DEFAULT_TOKEN_CHANNEL; | ||
1453 | // InternalAlloyLanguage.g:76:7: ( 'disj' ) | ||
1454 | // InternalAlloyLanguage.g:76:9: 'disj' | ||
1455 | { | ||
1456 | match("disj"); | ||
1457 | |||
1458 | |||
1459 | } | ||
1460 | |||
1461 | state.type = _type; | ||
1462 | state.channel = _channel; | ||
1463 | } | ||
1464 | finally { | ||
1465 | } | ||
1466 | } | ||
1467 | // $ANTLR end "T__76" | ||
1468 | |||
1469 | // $ANTLR start "RULE_ID" | ||
1470 | public final void mRULE_ID() throws RecognitionException { | ||
1471 | try { | ||
1472 | int _type = RULE_ID; | ||
1473 | int _channel = DEFAULT_TOKEN_CHANNEL; | ||
1474 | // InternalAlloyLanguage.g:10378:9: ( ( 'a' .. 'z' | 'A' .. 'Z' | '_' ) ( 'a' .. 'z' | 'A' .. 'Z' | '_' | '\\'' | '\"' | '0' .. '9' )* ) | ||
1475 | // InternalAlloyLanguage.g:10378:11: ( 'a' .. 'z' | 'A' .. 'Z' | '_' ) ( 'a' .. 'z' | 'A' .. 'Z' | '_' | '\\'' | '\"' | '0' .. '9' )* | ||
1476 | { | ||
1477 | if ( (input.LA(1)>='A' && input.LA(1)<='Z')||input.LA(1)=='_'||(input.LA(1)>='a' && input.LA(1)<='z') ) { | ||
1478 | input.consume(); | ||
1479 | |||
1480 | } | ||
1481 | else { | ||
1482 | MismatchedSetException mse = new MismatchedSetException(null,input); | ||
1483 | recover(mse); | ||
1484 | throw mse;} | ||
1485 | |||
1486 | // InternalAlloyLanguage.g:10378:35: ( 'a' .. 'z' | 'A' .. 'Z' | '_' | '\\'' | '\"' | '0' .. '9' )* | ||
1487 | loop1: | ||
1488 | do { | ||
1489 | int alt1=2; | ||
1490 | int LA1_0 = input.LA(1); | ||
1491 | |||
1492 | if ( (LA1_0=='\"'||LA1_0=='\''||(LA1_0>='0' && LA1_0<='9')||(LA1_0>='A' && LA1_0<='Z')||LA1_0=='_'||(LA1_0>='a' && LA1_0<='z')) ) { | ||
1493 | alt1=1; | ||
1494 | } | ||
1495 | |||
1496 | |||
1497 | switch (alt1) { | ||
1498 | case 1 : | ||
1499 | // InternalAlloyLanguage.g: | ||
1500 | { | ||
1501 | if ( input.LA(1)=='\"'||input.LA(1)=='\''||(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') ) { | ||
1502 | input.consume(); | ||
1503 | |||
1504 | } | ||
1505 | else { | ||
1506 | MismatchedSetException mse = new MismatchedSetException(null,input); | ||
1507 | recover(mse); | ||
1508 | throw mse;} | ||
1509 | |||
1510 | |||
1511 | } | ||
1512 | break; | ||
1513 | |||
1514 | default : | ||
1515 | break loop1; | ||
1516 | } | ||
1517 | } while (true); | ||
1518 | |||
1519 | |||
1520 | } | ||
1521 | |||
1522 | state.type = _type; | ||
1523 | state.channel = _channel; | ||
1524 | } | ||
1525 | finally { | ||
1526 | } | ||
1527 | } | ||
1528 | // $ANTLR end "RULE_ID" | ||
1529 | |||
1530 | // $ANTLR start "RULE_INT" | ||
1531 | public final void mRULE_INT() throws RecognitionException { | ||
1532 | try { | ||
1533 | int _type = RULE_INT; | ||
1534 | int _channel = DEFAULT_TOKEN_CHANNEL; | ||
1535 | // InternalAlloyLanguage.g:10380:10: ( ( '0' .. '9' )+ ) | ||
1536 | // InternalAlloyLanguage.g:10380:12: ( '0' .. '9' )+ | ||
1537 | { | ||
1538 | // InternalAlloyLanguage.g:10380:12: ( '0' .. '9' )+ | ||
1539 | int cnt2=0; | ||
1540 | loop2: | ||
1541 | do { | ||
1542 | int alt2=2; | ||
1543 | int LA2_0 = input.LA(1); | ||
1544 | |||
1545 | if ( ((LA2_0>='0' && LA2_0<='9')) ) { | ||
1546 | alt2=1; | ||
1547 | } | ||
1548 | |||
1549 | |||
1550 | switch (alt2) { | ||
1551 | case 1 : | ||
1552 | // InternalAlloyLanguage.g:10380:13: '0' .. '9' | ||
1553 | { | ||
1554 | matchRange('0','9'); | ||
1555 | |||
1556 | } | ||
1557 | break; | ||
1558 | |||
1559 | default : | ||
1560 | if ( cnt2 >= 1 ) break loop2; | ||
1561 | EarlyExitException eee = | ||
1562 | new EarlyExitException(2, input); | ||
1563 | throw eee; | ||
1564 | } | ||
1565 | cnt2++; | ||
1566 | } while (true); | ||
1567 | |||
1568 | |||
1569 | } | ||
1570 | |||
1571 | state.type = _type; | ||
1572 | state.channel = _channel; | ||
1573 | } | ||
1574 | finally { | ||
1575 | } | ||
1576 | } | ||
1577 | // $ANTLR end "RULE_INT" | ||
1578 | |||
1579 | // $ANTLR start "RULE_STRING" | ||
1580 | public final void mRULE_STRING() throws RecognitionException { | ||
1581 | try { | ||
1582 | int _type = RULE_STRING; | ||
1583 | int _channel = DEFAULT_TOKEN_CHANNEL; | ||
1584 | // InternalAlloyLanguage.g:10382:13: ( ( '\"' ( '\\\\' . | ~ ( ( '\\\\' | '\"' ) ) )* '\"' | '\\'' ( '\\\\' . | ~ ( ( '\\\\' | '\\'' ) ) )* '\\'' ) ) | ||
1585 | // InternalAlloyLanguage.g:10382:15: ( '\"' ( '\\\\' . | ~ ( ( '\\\\' | '\"' ) ) )* '\"' | '\\'' ( '\\\\' . | ~ ( ( '\\\\' | '\\'' ) ) )* '\\'' ) | ||
1586 | { | ||
1587 | // InternalAlloyLanguage.g:10382:15: ( '\"' ( '\\\\' . | ~ ( ( '\\\\' | '\"' ) ) )* '\"' | '\\'' ( '\\\\' . | ~ ( ( '\\\\' | '\\'' ) ) )* '\\'' ) | ||
1588 | int alt5=2; | ||
1589 | int LA5_0 = input.LA(1); | ||
1590 | |||
1591 | if ( (LA5_0=='\"') ) { | ||
1592 | alt5=1; | ||
1593 | } | ||
1594 | else if ( (LA5_0=='\'') ) { | ||
1595 | alt5=2; | ||
1596 | } | ||
1597 | else { | ||
1598 | NoViableAltException nvae = | ||
1599 | new NoViableAltException("", 5, 0, input); | ||
1600 | |||
1601 | throw nvae; | ||
1602 | } | ||
1603 | switch (alt5) { | ||
1604 | case 1 : | ||
1605 | // InternalAlloyLanguage.g:10382:16: '\"' ( '\\\\' . | ~ ( ( '\\\\' | '\"' ) ) )* '\"' | ||
1606 | { | ||
1607 | match('\"'); | ||
1608 | // InternalAlloyLanguage.g:10382:20: ( '\\\\' . | ~ ( ( '\\\\' | '\"' ) ) )* | ||
1609 | loop3: | ||
1610 | do { | ||
1611 | int alt3=3; | ||
1612 | int LA3_0 = input.LA(1); | ||
1613 | |||
1614 | if ( (LA3_0=='\\') ) { | ||
1615 | alt3=1; | ||
1616 | } | ||
1617 | else if ( ((LA3_0>='\u0000' && LA3_0<='!')||(LA3_0>='#' && LA3_0<='[')||(LA3_0>=']' && LA3_0<='\uFFFF')) ) { | ||
1618 | alt3=2; | ||
1619 | } | ||
1620 | |||
1621 | |||
1622 | switch (alt3) { | ||
1623 | case 1 : | ||
1624 | // InternalAlloyLanguage.g:10382:21: '\\\\' . | ||
1625 | { | ||
1626 | match('\\'); | ||
1627 | matchAny(); | ||
1628 | |||
1629 | } | ||
1630 | break; | ||
1631 | case 2 : | ||
1632 | // InternalAlloyLanguage.g:10382:28: ~ ( ( '\\\\' | '\"' ) ) | ||
1633 | { | ||
1634 | if ( (input.LA(1)>='\u0000' && input.LA(1)<='!')||(input.LA(1)>='#' && input.LA(1)<='[')||(input.LA(1)>=']' && input.LA(1)<='\uFFFF') ) { | ||
1635 | input.consume(); | ||
1636 | |||
1637 | } | ||
1638 | else { | ||
1639 | MismatchedSetException mse = new MismatchedSetException(null,input); | ||
1640 | recover(mse); | ||
1641 | throw mse;} | ||
1642 | |||
1643 | |||
1644 | } | ||
1645 | break; | ||
1646 | |||
1647 | default : | ||
1648 | break loop3; | ||
1649 | } | ||
1650 | } while (true); | ||
1651 | |||
1652 | match('\"'); | ||
1653 | |||
1654 | } | ||
1655 | break; | ||
1656 | case 2 : | ||
1657 | // InternalAlloyLanguage.g:10382:48: '\\'' ( '\\\\' . | ~ ( ( '\\\\' | '\\'' ) ) )* '\\'' | ||
1658 | { | ||
1659 | match('\''); | ||
1660 | // InternalAlloyLanguage.g:10382:53: ( '\\\\' . | ~ ( ( '\\\\' | '\\'' ) ) )* | ||
1661 | loop4: | ||
1662 | do { | ||
1663 | int alt4=3; | ||
1664 | int LA4_0 = input.LA(1); | ||
1665 | |||
1666 | if ( (LA4_0=='\\') ) { | ||
1667 | alt4=1; | ||
1668 | } | ||
1669 | else if ( ((LA4_0>='\u0000' && LA4_0<='&')||(LA4_0>='(' && LA4_0<='[')||(LA4_0>=']' && LA4_0<='\uFFFF')) ) { | ||
1670 | alt4=2; | ||
1671 | } | ||
1672 | |||
1673 | |||
1674 | switch (alt4) { | ||
1675 | case 1 : | ||
1676 | // InternalAlloyLanguage.g:10382:54: '\\\\' . | ||
1677 | { | ||
1678 | match('\\'); | ||
1679 | matchAny(); | ||
1680 | |||
1681 | } | ||
1682 | break; | ||
1683 | case 2 : | ||
1684 | // InternalAlloyLanguage.g:10382:61: ~ ( ( '\\\\' | '\\'' ) ) | ||
1685 | { | ||
1686 | if ( (input.LA(1)>='\u0000' && input.LA(1)<='&')||(input.LA(1)>='(' && input.LA(1)<='[')||(input.LA(1)>=']' && input.LA(1)<='\uFFFF') ) { | ||
1687 | input.consume(); | ||
1688 | |||
1689 | } | ||
1690 | else { | ||
1691 | MismatchedSetException mse = new MismatchedSetException(null,input); | ||
1692 | recover(mse); | ||
1693 | throw mse;} | ||
1694 | |||
1695 | |||
1696 | } | ||
1697 | break; | ||
1698 | |||
1699 | default : | ||
1700 | break loop4; | ||
1701 | } | ||
1702 | } while (true); | ||
1703 | |||
1704 | match('\''); | ||
1705 | |||
1706 | } | ||
1707 | break; | ||
1708 | |||
1709 | } | ||
1710 | |||
1711 | |||
1712 | } | ||
1713 | |||
1714 | state.type = _type; | ||
1715 | state.channel = _channel; | ||
1716 | } | ||
1717 | finally { | ||
1718 | } | ||
1719 | } | ||
1720 | // $ANTLR end "RULE_STRING" | ||
1721 | |||
1722 | // $ANTLR start "RULE_ML_COMMENT" | ||
1723 | public final void mRULE_ML_COMMENT() throws RecognitionException { | ||
1724 | try { | ||
1725 | int _type = RULE_ML_COMMENT; | ||
1726 | int _channel = DEFAULT_TOKEN_CHANNEL; | ||
1727 | // InternalAlloyLanguage.g:10384:17: ( '/*' ( options {greedy=false; } : . )* '*/' ) | ||
1728 | // InternalAlloyLanguage.g:10384:19: '/*' ( options {greedy=false; } : . )* '*/' | ||
1729 | { | ||
1730 | match("/*"); | ||
1731 | |||
1732 | // InternalAlloyLanguage.g:10384:24: ( options {greedy=false; } : . )* | ||
1733 | loop6: | ||
1734 | do { | ||
1735 | int alt6=2; | ||
1736 | int LA6_0 = input.LA(1); | ||
1737 | |||
1738 | if ( (LA6_0=='*') ) { | ||
1739 | int LA6_1 = input.LA(2); | ||
1740 | |||
1741 | if ( (LA6_1=='/') ) { | ||
1742 | alt6=2; | ||
1743 | } | ||
1744 | else if ( ((LA6_1>='\u0000' && LA6_1<='.')||(LA6_1>='0' && LA6_1<='\uFFFF')) ) { | ||
1745 | alt6=1; | ||
1746 | } | ||
1747 | |||
1748 | |||
1749 | } | ||
1750 | else if ( ((LA6_0>='\u0000' && LA6_0<=')')||(LA6_0>='+' && LA6_0<='\uFFFF')) ) { | ||
1751 | alt6=1; | ||
1752 | } | ||
1753 | |||
1754 | |||
1755 | switch (alt6) { | ||
1756 | case 1 : | ||
1757 | // InternalAlloyLanguage.g:10384:52: . | ||
1758 | { | ||
1759 | matchAny(); | ||
1760 | |||
1761 | } | ||
1762 | break; | ||
1763 | |||
1764 | default : | ||
1765 | break loop6; | ||
1766 | } | ||
1767 | } while (true); | ||
1768 | |||
1769 | match("*/"); | ||
1770 | |||
1771 | |||
1772 | } | ||
1773 | |||
1774 | state.type = _type; | ||
1775 | state.channel = _channel; | ||
1776 | } | ||
1777 | finally { | ||
1778 | } | ||
1779 | } | ||
1780 | // $ANTLR end "RULE_ML_COMMENT" | ||
1781 | |||
1782 | // $ANTLR start "RULE_SL_COMMENT" | ||
1783 | public final void mRULE_SL_COMMENT() throws RecognitionException { | ||
1784 | try { | ||
1785 | int _type = RULE_SL_COMMENT; | ||
1786 | int _channel = DEFAULT_TOKEN_CHANNEL; | ||
1787 | // InternalAlloyLanguage.g:10386:17: ( '//' (~ ( ( '\\n' | '\\r' ) ) )* ( ( '\\r' )? '\\n' )? ) | ||
1788 | // InternalAlloyLanguage.g:10386:19: '//' (~ ( ( '\\n' | '\\r' ) ) )* ( ( '\\r' )? '\\n' )? | ||
1789 | { | ||
1790 | match("//"); | ||
1791 | |||
1792 | // InternalAlloyLanguage.g:10386:24: (~ ( ( '\\n' | '\\r' ) ) )* | ||
1793 | loop7: | ||
1794 | do { | ||
1795 | int alt7=2; | ||
1796 | int LA7_0 = input.LA(1); | ||
1797 | |||
1798 | if ( ((LA7_0>='\u0000' && LA7_0<='\t')||(LA7_0>='\u000B' && LA7_0<='\f')||(LA7_0>='\u000E' && LA7_0<='\uFFFF')) ) { | ||
1799 | alt7=1; | ||
1800 | } | ||
1801 | |||
1802 | |||
1803 | switch (alt7) { | ||
1804 | case 1 : | ||
1805 | // InternalAlloyLanguage.g:10386:24: ~ ( ( '\\n' | '\\r' ) ) | ||
1806 | { | ||
1807 | 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') ) { | ||
1808 | input.consume(); | ||
1809 | |||
1810 | } | ||
1811 | else { | ||
1812 | MismatchedSetException mse = new MismatchedSetException(null,input); | ||
1813 | recover(mse); | ||
1814 | throw mse;} | ||
1815 | |||
1816 | |||
1817 | } | ||
1818 | break; | ||
1819 | |||
1820 | default : | ||
1821 | break loop7; | ||
1822 | } | ||
1823 | } while (true); | ||
1824 | |||
1825 | // InternalAlloyLanguage.g:10386:40: ( ( '\\r' )? '\\n' )? | ||
1826 | int alt9=2; | ||
1827 | int LA9_0 = input.LA(1); | ||
1828 | |||
1829 | if ( (LA9_0=='\n'||LA9_0=='\r') ) { | ||
1830 | alt9=1; | ||
1831 | } | ||
1832 | switch (alt9) { | ||
1833 | case 1 : | ||
1834 | // InternalAlloyLanguage.g:10386:41: ( '\\r' )? '\\n' | ||
1835 | { | ||
1836 | // InternalAlloyLanguage.g:10386:41: ( '\\r' )? | ||
1837 | int alt8=2; | ||
1838 | int LA8_0 = input.LA(1); | ||
1839 | |||
1840 | if ( (LA8_0=='\r') ) { | ||
1841 | alt8=1; | ||
1842 | } | ||
1843 | switch (alt8) { | ||
1844 | case 1 : | ||
1845 | // InternalAlloyLanguage.g:10386:41: '\\r' | ||
1846 | { | ||
1847 | match('\r'); | ||
1848 | |||
1849 | } | ||
1850 | break; | ||
1851 | |||
1852 | } | ||
1853 | |||
1854 | match('\n'); | ||
1855 | |||
1856 | } | ||
1857 | break; | ||
1858 | |||
1859 | } | ||
1860 | |||
1861 | |||
1862 | } | ||
1863 | |||
1864 | state.type = _type; | ||
1865 | state.channel = _channel; | ||
1866 | } | ||
1867 | finally { | ||
1868 | } | ||
1869 | } | ||
1870 | // $ANTLR end "RULE_SL_COMMENT" | ||
1871 | |||
1872 | // $ANTLR start "RULE_WS" | ||
1873 | public final void mRULE_WS() throws RecognitionException { | ||
1874 | try { | ||
1875 | int _type = RULE_WS; | ||
1876 | int _channel = DEFAULT_TOKEN_CHANNEL; | ||
1877 | // InternalAlloyLanguage.g:10388:9: ( ( ' ' | '\\t' | '\\r' | '\\n' )+ ) | ||
1878 | // InternalAlloyLanguage.g:10388:11: ( ' ' | '\\t' | '\\r' | '\\n' )+ | ||
1879 | { | ||
1880 | // InternalAlloyLanguage.g:10388:11: ( ' ' | '\\t' | '\\r' | '\\n' )+ | ||
1881 | int cnt10=0; | ||
1882 | loop10: | ||
1883 | do { | ||
1884 | int alt10=2; | ||
1885 | int LA10_0 = input.LA(1); | ||
1886 | |||
1887 | if ( ((LA10_0>='\t' && LA10_0<='\n')||LA10_0=='\r'||LA10_0==' ') ) { | ||
1888 | alt10=1; | ||
1889 | } | ||
1890 | |||
1891 | |||
1892 | switch (alt10) { | ||
1893 | case 1 : | ||
1894 | // InternalAlloyLanguage.g: | ||
1895 | { | ||
1896 | if ( (input.LA(1)>='\t' && input.LA(1)<='\n')||input.LA(1)=='\r'||input.LA(1)==' ' ) { | ||
1897 | input.consume(); | ||
1898 | |||
1899 | } | ||
1900 | else { | ||
1901 | MismatchedSetException mse = new MismatchedSetException(null,input); | ||
1902 | recover(mse); | ||
1903 | throw mse;} | ||
1904 | |||
1905 | |||
1906 | } | ||
1907 | break; | ||
1908 | |||
1909 | default : | ||
1910 | if ( cnt10 >= 1 ) break loop10; | ||
1911 | EarlyExitException eee = | ||
1912 | new EarlyExitException(10, input); | ||
1913 | throw eee; | ||
1914 | } | ||
1915 | cnt10++; | ||
1916 | } while (true); | ||
1917 | |||
1918 | |||
1919 | } | ||
1920 | |||
1921 | state.type = _type; | ||
1922 | state.channel = _channel; | ||
1923 | } | ||
1924 | finally { | ||
1925 | } | ||
1926 | } | ||
1927 | // $ANTLR end "RULE_WS" | ||
1928 | |||
1929 | // $ANTLR start "RULE_ANY_OTHER" | ||
1930 | public final void mRULE_ANY_OTHER() throws RecognitionException { | ||
1931 | try { | ||
1932 | int _type = RULE_ANY_OTHER; | ||
1933 | int _channel = DEFAULT_TOKEN_CHANNEL; | ||
1934 | // InternalAlloyLanguage.g:10390:16: ( . ) | ||
1935 | // InternalAlloyLanguage.g:10390:18: . | ||
1936 | { | ||
1937 | matchAny(); | ||
1938 | |||
1939 | } | ||
1940 | |||
1941 | state.type = _type; | ||
1942 | state.channel = _channel; | ||
1943 | } | ||
1944 | finally { | ||
1945 | } | ||
1946 | } | ||
1947 | // $ANTLR end "RULE_ANY_OTHER" | ||
1948 | |||
1949 | public void mTokens() throws RecognitionException { | ||
1950 | // InternalAlloyLanguage.g:1:8: ( T__11 | T__12 | T__13 | T__14 | T__15 | T__16 | T__17 | T__18 | T__19 | T__20 | T__21 | T__22 | T__23 | T__24 | T__25 | T__26 | T__27 | T__28 | T__29 | T__30 | T__31 | T__32 | T__33 | T__34 | T__35 | T__36 | T__37 | T__38 | T__39 | T__40 | T__41 | T__42 | T__43 | T__44 | T__45 | T__46 | T__47 | T__48 | T__49 | T__50 | T__51 | T__52 | T__53 | T__54 | T__55 | T__56 | T__57 | T__58 | T__59 | T__60 | T__61 | T__62 | T__63 | T__64 | T__65 | T__66 | T__67 | T__68 | T__69 | T__70 | T__71 | T__72 | T__73 | T__74 | T__75 | T__76 | RULE_ID | RULE_INT | RULE_STRING | RULE_ML_COMMENT | RULE_SL_COMMENT | RULE_WS | RULE_ANY_OTHER ) | ||
1951 | int alt11=73; | ||
1952 | alt11 = dfa11.predict(input); | ||
1953 | switch (alt11) { | ||
1954 | case 1 : | ||
1955 | // InternalAlloyLanguage.g:1:10: T__11 | ||
1956 | { | ||
1957 | mT__11(); | ||
1958 | |||
1959 | } | ||
1960 | break; | ||
1961 | case 2 : | ||
1962 | // InternalAlloyLanguage.g:1:16: T__12 | ||
1963 | { | ||
1964 | mT__12(); | ||
1965 | |||
1966 | } | ||
1967 | break; | ||
1968 | case 3 : | ||
1969 | // InternalAlloyLanguage.g:1:22: T__13 | ||
1970 | { | ||
1971 | mT__13(); | ||
1972 | |||
1973 | } | ||
1974 | break; | ||
1975 | case 4 : | ||
1976 | // InternalAlloyLanguage.g:1:28: T__14 | ||
1977 | { | ||
1978 | mT__14(); | ||
1979 | |||
1980 | } | ||
1981 | break; | ||
1982 | case 5 : | ||
1983 | // InternalAlloyLanguage.g:1:34: T__15 | ||
1984 | { | ||
1985 | mT__15(); | ||
1986 | |||
1987 | } | ||
1988 | break; | ||
1989 | case 6 : | ||
1990 | // InternalAlloyLanguage.g:1:40: T__16 | ||
1991 | { | ||
1992 | mT__16(); | ||
1993 | |||
1994 | } | ||
1995 | break; | ||
1996 | case 7 : | ||
1997 | // InternalAlloyLanguage.g:1:46: T__17 | ||
1998 | { | ||
1999 | mT__17(); | ||
2000 | |||
2001 | } | ||
2002 | break; | ||
2003 | case 8 : | ||
2004 | // InternalAlloyLanguage.g:1:52: T__18 | ||
2005 | { | ||
2006 | mT__18(); | ||
2007 | |||
2008 | } | ||
2009 | break; | ||
2010 | case 9 : | ||
2011 | // InternalAlloyLanguage.g:1:58: T__19 | ||
2012 | { | ||
2013 | mT__19(); | ||
2014 | |||
2015 | } | ||
2016 | break; | ||
2017 | case 10 : | ||
2018 | // InternalAlloyLanguage.g:1:64: T__20 | ||
2019 | { | ||
2020 | mT__20(); | ||
2021 | |||
2022 | } | ||
2023 | break; | ||
2024 | case 11 : | ||
2025 | // InternalAlloyLanguage.g:1:70: T__21 | ||
2026 | { | ||
2027 | mT__21(); | ||
2028 | |||
2029 | } | ||
2030 | break; | ||
2031 | case 12 : | ||
2032 | // InternalAlloyLanguage.g:1:76: T__22 | ||
2033 | { | ||
2034 | mT__22(); | ||
2035 | |||
2036 | } | ||
2037 | break; | ||
2038 | case 13 : | ||
2039 | // InternalAlloyLanguage.g:1:82: T__23 | ||
2040 | { | ||
2041 | mT__23(); | ||
2042 | |||
2043 | } | ||
2044 | break; | ||
2045 | case 14 : | ||
2046 | // InternalAlloyLanguage.g:1:88: T__24 | ||
2047 | { | ||
2048 | mT__24(); | ||
2049 | |||
2050 | } | ||
2051 | break; | ||
2052 | case 15 : | ||
2053 | // InternalAlloyLanguage.g:1:94: T__25 | ||
2054 | { | ||
2055 | mT__25(); | ||
2056 | |||
2057 | } | ||
2058 | break; | ||
2059 | case 16 : | ||
2060 | // InternalAlloyLanguage.g:1:100: T__26 | ||
2061 | { | ||
2062 | mT__26(); | ||
2063 | |||
2064 | } | ||
2065 | break; | ||
2066 | case 17 : | ||
2067 | // InternalAlloyLanguage.g:1:106: T__27 | ||
2068 | { | ||
2069 | mT__27(); | ||
2070 | |||
2071 | } | ||
2072 | break; | ||
2073 | case 18 : | ||
2074 | // InternalAlloyLanguage.g:1:112: T__28 | ||
2075 | { | ||
2076 | mT__28(); | ||
2077 | |||
2078 | } | ||
2079 | break; | ||
2080 | case 19 : | ||
2081 | // InternalAlloyLanguage.g:1:118: T__29 | ||
2082 | { | ||
2083 | mT__29(); | ||
2084 | |||
2085 | } | ||
2086 | break; | ||
2087 | case 20 : | ||
2088 | // InternalAlloyLanguage.g:1:124: T__30 | ||
2089 | { | ||
2090 | mT__30(); | ||
2091 | |||
2092 | } | ||
2093 | break; | ||
2094 | case 21 : | ||
2095 | // InternalAlloyLanguage.g:1:130: T__31 | ||
2096 | { | ||
2097 | mT__31(); | ||
2098 | |||
2099 | } | ||
2100 | break; | ||
2101 | case 22 : | ||
2102 | // InternalAlloyLanguage.g:1:136: T__32 | ||
2103 | { | ||
2104 | mT__32(); | ||
2105 | |||
2106 | } | ||
2107 | break; | ||
2108 | case 23 : | ||
2109 | // InternalAlloyLanguage.g:1:142: T__33 | ||
2110 | { | ||
2111 | mT__33(); | ||
2112 | |||
2113 | } | ||
2114 | break; | ||
2115 | case 24 : | ||
2116 | // InternalAlloyLanguage.g:1:148: T__34 | ||
2117 | { | ||
2118 | mT__34(); | ||
2119 | |||
2120 | } | ||
2121 | break; | ||
2122 | case 25 : | ||
2123 | // InternalAlloyLanguage.g:1:154: T__35 | ||
2124 | { | ||
2125 | mT__35(); | ||
2126 | |||
2127 | } | ||
2128 | break; | ||
2129 | case 26 : | ||
2130 | // InternalAlloyLanguage.g:1:160: T__36 | ||
2131 | { | ||
2132 | mT__36(); | ||
2133 | |||
2134 | } | ||
2135 | break; | ||
2136 | case 27 : | ||
2137 | // InternalAlloyLanguage.g:1:166: T__37 | ||
2138 | { | ||
2139 | mT__37(); | ||
2140 | |||
2141 | } | ||
2142 | break; | ||
2143 | case 28 : | ||
2144 | // InternalAlloyLanguage.g:1:172: T__38 | ||
2145 | { | ||
2146 | mT__38(); | ||
2147 | |||
2148 | } | ||
2149 | break; | ||
2150 | case 29 : | ||
2151 | // InternalAlloyLanguage.g:1:178: T__39 | ||
2152 | { | ||
2153 | mT__39(); | ||
2154 | |||
2155 | } | ||
2156 | break; | ||
2157 | case 30 : | ||
2158 | // InternalAlloyLanguage.g:1:184: T__40 | ||
2159 | { | ||
2160 | mT__40(); | ||
2161 | |||
2162 | } | ||
2163 | break; | ||
2164 | case 31 : | ||
2165 | // InternalAlloyLanguage.g:1:190: T__41 | ||
2166 | { | ||
2167 | mT__41(); | ||
2168 | |||
2169 | } | ||
2170 | break; | ||
2171 | case 32 : | ||
2172 | // InternalAlloyLanguage.g:1:196: T__42 | ||
2173 | { | ||
2174 | mT__42(); | ||
2175 | |||
2176 | } | ||
2177 | break; | ||
2178 | case 33 : | ||
2179 | // InternalAlloyLanguage.g:1:202: T__43 | ||
2180 | { | ||
2181 | mT__43(); | ||
2182 | |||
2183 | } | ||
2184 | break; | ||
2185 | case 34 : | ||
2186 | // InternalAlloyLanguage.g:1:208: T__44 | ||
2187 | { | ||
2188 | mT__44(); | ||
2189 | |||
2190 | } | ||
2191 | break; | ||
2192 | case 35 : | ||
2193 | // InternalAlloyLanguage.g:1:214: T__45 | ||
2194 | { | ||
2195 | mT__45(); | ||
2196 | |||
2197 | } | ||
2198 | break; | ||
2199 | case 36 : | ||
2200 | // InternalAlloyLanguage.g:1:220: T__46 | ||
2201 | { | ||
2202 | mT__46(); | ||
2203 | |||
2204 | } | ||
2205 | break; | ||
2206 | case 37 : | ||
2207 | // InternalAlloyLanguage.g:1:226: T__47 | ||
2208 | { | ||
2209 | mT__47(); | ||
2210 | |||
2211 | } | ||
2212 | break; | ||
2213 | case 38 : | ||
2214 | // InternalAlloyLanguage.g:1:232: T__48 | ||
2215 | { | ||
2216 | mT__48(); | ||
2217 | |||
2218 | } | ||
2219 | break; | ||
2220 | case 39 : | ||
2221 | // InternalAlloyLanguage.g:1:238: T__49 | ||
2222 | { | ||
2223 | mT__49(); | ||
2224 | |||
2225 | } | ||
2226 | break; | ||
2227 | case 40 : | ||
2228 | // InternalAlloyLanguage.g:1:244: T__50 | ||
2229 | { | ||
2230 | mT__50(); | ||
2231 | |||
2232 | } | ||
2233 | break; | ||
2234 | case 41 : | ||
2235 | // InternalAlloyLanguage.g:1:250: T__51 | ||
2236 | { | ||
2237 | mT__51(); | ||
2238 | |||
2239 | } | ||
2240 | break; | ||
2241 | case 42 : | ||
2242 | // InternalAlloyLanguage.g:1:256: T__52 | ||
2243 | { | ||
2244 | mT__52(); | ||
2245 | |||
2246 | } | ||
2247 | break; | ||
2248 | case 43 : | ||
2249 | // InternalAlloyLanguage.g:1:262: T__53 | ||
2250 | { | ||
2251 | mT__53(); | ||
2252 | |||
2253 | } | ||
2254 | break; | ||
2255 | case 44 : | ||
2256 | // InternalAlloyLanguage.g:1:268: T__54 | ||
2257 | { | ||
2258 | mT__54(); | ||
2259 | |||
2260 | } | ||
2261 | break; | ||
2262 | case 45 : | ||
2263 | // InternalAlloyLanguage.g:1:274: T__55 | ||
2264 | { | ||
2265 | mT__55(); | ||
2266 | |||
2267 | } | ||
2268 | break; | ||
2269 | case 46 : | ||
2270 | // InternalAlloyLanguage.g:1:280: T__56 | ||
2271 | { | ||
2272 | mT__56(); | ||
2273 | |||
2274 | } | ||
2275 | break; | ||
2276 | case 47 : | ||
2277 | // InternalAlloyLanguage.g:1:286: T__57 | ||
2278 | { | ||
2279 | mT__57(); | ||
2280 | |||
2281 | } | ||
2282 | break; | ||
2283 | case 48 : | ||
2284 | // InternalAlloyLanguage.g:1:292: T__58 | ||
2285 | { | ||
2286 | mT__58(); | ||
2287 | |||
2288 | } | ||
2289 | break; | ||
2290 | case 49 : | ||
2291 | // InternalAlloyLanguage.g:1:298: T__59 | ||
2292 | { | ||
2293 | mT__59(); | ||
2294 | |||
2295 | } | ||
2296 | break; | ||
2297 | case 50 : | ||
2298 | // InternalAlloyLanguage.g:1:304: T__60 | ||
2299 | { | ||
2300 | mT__60(); | ||
2301 | |||
2302 | } | ||
2303 | break; | ||
2304 | case 51 : | ||
2305 | // InternalAlloyLanguage.g:1:310: T__61 | ||
2306 | { | ||
2307 | mT__61(); | ||
2308 | |||
2309 | } | ||
2310 | break; | ||
2311 | case 52 : | ||
2312 | // InternalAlloyLanguage.g:1:316: T__62 | ||
2313 | { | ||
2314 | mT__62(); | ||
2315 | |||
2316 | } | ||
2317 | break; | ||
2318 | case 53 : | ||
2319 | // InternalAlloyLanguage.g:1:322: T__63 | ||
2320 | { | ||
2321 | mT__63(); | ||
2322 | |||
2323 | } | ||
2324 | break; | ||
2325 | case 54 : | ||
2326 | // InternalAlloyLanguage.g:1:328: T__64 | ||
2327 | { | ||
2328 | mT__64(); | ||
2329 | |||
2330 | } | ||
2331 | break; | ||
2332 | case 55 : | ||
2333 | // InternalAlloyLanguage.g:1:334: T__65 | ||
2334 | { | ||
2335 | mT__65(); | ||
2336 | |||
2337 | } | ||
2338 | break; | ||
2339 | case 56 : | ||
2340 | // InternalAlloyLanguage.g:1:340: T__66 | ||
2341 | { | ||
2342 | mT__66(); | ||
2343 | |||
2344 | } | ||
2345 | break; | ||
2346 | case 57 : | ||
2347 | // InternalAlloyLanguage.g:1:346: T__67 | ||
2348 | { | ||
2349 | mT__67(); | ||
2350 | |||
2351 | } | ||
2352 | break; | ||
2353 | case 58 : | ||
2354 | // InternalAlloyLanguage.g:1:352: T__68 | ||
2355 | { | ||
2356 | mT__68(); | ||
2357 | |||
2358 | } | ||
2359 | break; | ||
2360 | case 59 : | ||
2361 | // InternalAlloyLanguage.g:1:358: T__69 | ||
2362 | { | ||
2363 | mT__69(); | ||
2364 | |||
2365 | } | ||
2366 | break; | ||
2367 | case 60 : | ||
2368 | // InternalAlloyLanguage.g:1:364: T__70 | ||
2369 | { | ||
2370 | mT__70(); | ||
2371 | |||
2372 | } | ||
2373 | break; | ||
2374 | case 61 : | ||
2375 | // InternalAlloyLanguage.g:1:370: T__71 | ||
2376 | { | ||
2377 | mT__71(); | ||
2378 | |||
2379 | } | ||
2380 | break; | ||
2381 | case 62 : | ||
2382 | // InternalAlloyLanguage.g:1:376: T__72 | ||
2383 | { | ||
2384 | mT__72(); | ||
2385 | |||
2386 | } | ||
2387 | break; | ||
2388 | case 63 : | ||
2389 | // InternalAlloyLanguage.g:1:382: T__73 | ||
2390 | { | ||
2391 | mT__73(); | ||
2392 | |||
2393 | } | ||
2394 | break; | ||
2395 | case 64 : | ||
2396 | // InternalAlloyLanguage.g:1:388: T__74 | ||
2397 | { | ||
2398 | mT__74(); | ||
2399 | |||
2400 | } | ||
2401 | break; | ||
2402 | case 65 : | ||
2403 | // InternalAlloyLanguage.g:1:394: T__75 | ||
2404 | { | ||
2405 | mT__75(); | ||
2406 | |||
2407 | } | ||
2408 | break; | ||
2409 | case 66 : | ||
2410 | // InternalAlloyLanguage.g:1:400: T__76 | ||
2411 | { | ||
2412 | mT__76(); | ||
2413 | |||
2414 | } | ||
2415 | break; | ||
2416 | case 67 : | ||
2417 | // InternalAlloyLanguage.g:1:406: RULE_ID | ||
2418 | { | ||
2419 | mRULE_ID(); | ||
2420 | |||
2421 | } | ||
2422 | break; | ||
2423 | case 68 : | ||
2424 | // InternalAlloyLanguage.g:1:414: RULE_INT | ||
2425 | { | ||
2426 | mRULE_INT(); | ||
2427 | |||
2428 | } | ||
2429 | break; | ||
2430 | case 69 : | ||
2431 | // InternalAlloyLanguage.g:1:423: RULE_STRING | ||
2432 | { | ||
2433 | mRULE_STRING(); | ||
2434 | |||
2435 | } | ||
2436 | break; | ||
2437 | case 70 : | ||
2438 | // InternalAlloyLanguage.g:1:435: RULE_ML_COMMENT | ||
2439 | { | ||
2440 | mRULE_ML_COMMENT(); | ||
2441 | |||
2442 | } | ||
2443 | break; | ||
2444 | case 71 : | ||
2445 | // InternalAlloyLanguage.g:1:451: RULE_SL_COMMENT | ||
2446 | { | ||
2447 | mRULE_SL_COMMENT(); | ||
2448 | |||
2449 | } | ||
2450 | break; | ||
2451 | case 72 : | ||
2452 | // InternalAlloyLanguage.g:1:467: RULE_WS | ||
2453 | { | ||
2454 | mRULE_WS(); | ||
2455 | |||
2456 | } | ||
2457 | break; | ||
2458 | case 73 : | ||
2459 | // InternalAlloyLanguage.g:1:475: RULE_ANY_OTHER | ||
2460 | { | ||
2461 | mRULE_ANY_OTHER(); | ||
2462 | |||
2463 | } | ||
2464 | break; | ||
2465 | |||
2466 | } | ||
2467 | |||
2468 | } | ||
2469 | |||
2470 | |||
2471 | protected DFA11 dfa11 = new DFA11(this); | ||
2472 | static final String DFA11_eotS = | ||
2473 | "\1\uffff\1\53\1\57\1\62\1\57\1\70\1\72\1\57\1\77\10\57\3\uffff\1\123\1\125\1\57\2\uffff\1\134\1\uffff\1\137\4\uffff\3\57\4\uffff\3\53\3\uffff\1\156\1\57\1\uffff\1\161\2\uffff\2\57\1\164\1\57\4\uffff\3\57\2\uffff\1\173\16\57\7\uffff\3\57\13\uffff\3\57\10\uffff\1\u0093\2\uffff\1\u0094\1\57\1\uffff\1\57\1\u0097\1\u0098\1\57\1\u009a\1\57\1\uffff\1\57\1\u009d\1\u009e\1\u009f\1\u00a0\3\57\1\u00a4\1\u00a5\1\u00a6\1\u00a7\5\57\1\u00ad\1\57\1\u00af\1\57\1\u00b1\1\57\2\uffff\1\57\1\u00b4\2\uffff\1\57\1\uffff\1\u00b6\1\u00b7\4\uffff\1\u00b8\1\u00b9\1\u00ba\4\uffff\1\u00bb\1\u00bc\2\57\1\u00bf\1\uffff\1\u00c0\1\uffff\1\u00c1\1\uffff\2\57\1\uffff\1\57\7\uffff\2\57\3\uffff\5\57\1\u00cc\1\u00cd\1\57\1\u00cf\1\u00d0\2\uffff\1\u00d1\3\uffff"; | ||
2474 | static final String DFA11_eofS = | ||
2475 | "\u00d2\uffff"; | ||
2476 | static final String DFA11_minS = | ||
2477 | "\1\0\1\174\1\156\1\72\1\144\1\76\1\46\1\142\1\75\1\157\1\145\1\157\1\154\1\165\1\145\1\151\1\154\3\uffff\1\53\1\76\1\141\2\uffff\1\75\1\uffff\1\76\4\uffff\2\156\1\164\4\uffff\2\0\1\52\3\uffff\1\42\1\145\1\uffff\1\76\2\uffff\1\146\1\160\1\42\1\145\4\uffff\1\144\1\154\1\163\2\uffff\1\42\1\155\1\164\1\142\1\147\1\156\1\165\1\145\1\154\1\155\1\156\1\163\1\165\1\141\1\163\7\uffff\1\156\1\143\1\162\13\uffff\1\151\1\164\1\162\10\uffff\1\42\2\uffff\1\42\1\154\1\uffff\1\156\2\42\1\164\1\42\1\145\1\uffff\1\145\4\42\1\145\1\163\1\144\4\42\1\152\1\155\1\145\1\143\1\145\1\42\1\164\1\42\1\166\1\42\1\151\2\uffff\1\151\1\42\2\uffff\1\162\1\uffff\2\42\4\uffff\3\42\4\uffff\2\42\1\156\1\164\1\42\1\uffff\1\42\1\uffff\1\42\1\uffff\1\156\1\145\1\uffff\1\141\7\uffff\1\144\1\154\3\uffff\1\147\1\163\1\143\1\163\1\171\2\42\1\164\2\42\2\uffff\1\42\3\uffff"; | ||
2478 | static final String DFA11_maxS = | ||
2479 | "\1\uffff\1\174\1\162\1\75\1\156\1\76\1\46\1\156\1\75\1\157\1\165\1\157\1\162\2\165\1\151\1\170\3\uffff\1\53\1\76\1\165\2\uffff\1\75\1\uffff\1\76\4\uffff\2\156\1\164\4\uffff\2\uffff\1\57\3\uffff\1\172\1\145\1\uffff\1\76\2\uffff\1\146\1\160\1\172\1\145\4\uffff\1\144\1\154\1\163\2\uffff\1\172\1\155\1\164\1\155\1\147\1\156\1\165\1\145\1\154\1\155\1\156\1\166\1\165\1\164\1\163\7\uffff\1\156\1\143\1\162\13\uffff\1\151\1\164\1\162\10\uffff\1\172\2\uffff\1\172\1\154\1\uffff\1\156\2\172\1\164\1\172\1\145\1\uffff\1\145\4\172\1\145\1\163\1\144\4\172\1\152\1\155\1\145\1\143\1\145\1\172\1\164\1\172\1\166\1\172\1\151\2\uffff\1\151\1\172\2\uffff\1\162\1\uffff\2\172\4\uffff\3\172\4\uffff\2\172\1\156\1\164\1\172\1\uffff\1\172\1\uffff\1\172\1\uffff\1\156\1\145\1\uffff\1\141\7\uffff\1\144\1\154\3\uffff\1\147\1\163\1\143\1\163\1\171\2\172\1\164\2\172\2\uffff\1\172\3\uffff"; | ||
2480 | static final String DFA11_acceptS = | ||
2481 | "\21\uffff\1\27\1\30\1\31\3\uffff\1\40\1\41\1\uffff\1\56\1\uffff\1\62\1\63\1\64\1\65\3\uffff\1\74\1\75\1\103\1\104\3\uffff\1\110\1\111\1\1\2\uffff\1\103\1\uffff\1\55\1\51\4\uffff\1\5\1\45\1\7\1\60\3\uffff\1\46\1\11\17\uffff\1\27\1\30\1\31\1\53\1\35\1\54\1\36\3\uffff\1\40\1\41\1\50\1\47\1\56\1\61\1\57\1\62\1\63\1\64\1\65\3\uffff\1\74\1\75\1\104\1\105\1\106\1\107\1\110\1\2\1\uffff\1\3\1\52\2\uffff\1\34\6\uffff\1\14\27\uffff\1\17\1\4\2\uffff\1\10\1\13\1\uffff\1\12\2\uffff\1\20\1\22\1\66\1\32\3\uffff\1\23\1\24\1\76\1\25\5\uffff\1\37\1\uffff\1\77\1\uffff\1\72\2\uffff\1\70\1\uffff\1\67\1\15\1\16\1\21\1\42\1\102\1\26\2\uffff\1\44\1\43\1\71\12\uffff\1\73\1\6\1\uffff\1\33\1\100\1\101"; | ||
2482 | static final String DFA11_specialS = | ||
2483 | "\1\2\46\uffff\1\1\1\0\u00a9\uffff}>"; | ||
2484 | static final String[] DFA11_transitionS = { | ||
2485 | "\11\53\2\52\2\53\1\52\22\53\1\52\1\10\1\47\1\37\2\53\1\6\1\50\1\43\1\44\1\36\1\24\1\23\1\33\1\32\1\51\12\46\1\25\1\53\1\3\1\5\1\31\2\53\10\45\1\41\11\45\1\42\7\45\1\27\1\53\1\30\1\35\1\45\1\53\1\7\2\45\1\17\1\20\1\26\2\45\1\4\2\45\1\13\1\15\1\11\1\2\1\14\1\45\1\16\1\12\1\45\1\40\5\45\1\21\1\1\1\22\1\34\uff81\53", | ||
2486 | "\1\54", | ||
2487 | "\1\56\3\uffff\1\55", | ||
2488 | "\1\61\2\uffff\1\60", | ||
2489 | "\1\66\1\uffff\1\63\6\uffff\1\64\1\65", | ||
2490 | "\1\67", | ||
2491 | "\1\71", | ||
2492 | "\1\75\11\uffff\1\74\1\uffff\1\73", | ||
2493 | "\1\76", | ||
2494 | "\1\100", | ||
2495 | "\1\102\3\uffff\1\104\5\uffff\1\101\5\uffff\1\103", | ||
2496 | "\1\105", | ||
2497 | "\1\106\5\uffff\1\107", | ||
2498 | "\1\110", | ||
2499 | "\1\111\17\uffff\1\112", | ||
2500 | "\1\113", | ||
2501 | "\1\116\1\uffff\1\114\11\uffff\1\115", | ||
2502 | "", | ||
2503 | "", | ||
2504 | "", | ||
2505 | "\1\122", | ||
2506 | "\1\124", | ||
2507 | "\1\127\15\uffff\1\130\5\uffff\1\126", | ||
2508 | "", | ||
2509 | "", | ||
2510 | "\1\133", | ||
2511 | "", | ||
2512 | "\1\136", | ||
2513 | "", | ||
2514 | "", | ||
2515 | "", | ||
2516 | "", | ||
2517 | "\1\144", | ||
2518 | "\1\145", | ||
2519 | "\1\146", | ||
2520 | "", | ||
2521 | "", | ||
2522 | "", | ||
2523 | "", | ||
2524 | "\0\152", | ||
2525 | "\0\152", | ||
2526 | "\1\153\4\uffff\1\154", | ||
2527 | "", | ||
2528 | "", | ||
2529 | "", | ||
2530 | "\1\57\4\uffff\1\57\10\uffff\12\57\7\uffff\32\57\4\uffff\1\57\1\uffff\32\57", | ||
2531 | "\1\157", | ||
2532 | "", | ||
2533 | "\1\160", | ||
2534 | "", | ||
2535 | "", | ||
2536 | "\1\162", | ||
2537 | "\1\163", | ||
2538 | "\1\57\4\uffff\1\57\10\uffff\12\57\7\uffff\32\57\4\uffff\1\57\1\uffff\32\57", | ||
2539 | "\1\165", | ||
2540 | "", | ||
2541 | "", | ||
2542 | "", | ||
2543 | "", | ||
2544 | "\1\166", | ||
2545 | "\1\167", | ||
2546 | "\1\170", | ||
2547 | "", | ||
2548 | "", | ||
2549 | "\1\57\4\uffff\1\57\10\uffff\12\57\7\uffff\32\57\4\uffff\1\57\1\uffff\15\57\1\172\5\57\1\171\6\57", | ||
2550 | "\1\174", | ||
2551 | "\1\175", | ||
2552 | "\1\176\12\uffff\1\177", | ||
2553 | "\1\u0080", | ||
2554 | "\1\u0081", | ||
2555 | "\1\u0082", | ||
2556 | "\1\u0083", | ||
2557 | "\1\u0084", | ||
2558 | "\1\u0085", | ||
2559 | "\1\u0086", | ||
2560 | "\1\u0088\2\uffff\1\u0087", | ||
2561 | "\1\u0089", | ||
2562 | "\1\u008b\22\uffff\1\u008a", | ||
2563 | "\1\u008c", | ||
2564 | "", | ||
2565 | "", | ||
2566 | "", | ||
2567 | "", | ||
2568 | "", | ||
2569 | "", | ||
2570 | "", | ||
2571 | "\1\u008d", | ||
2572 | "\1\u008e", | ||
2573 | "\1\u008f", | ||
2574 | "", | ||
2575 | "", | ||
2576 | "", | ||
2577 | "", | ||
2578 | "", | ||
2579 | "", | ||
2580 | "", | ||
2581 | "", | ||
2582 | "", | ||
2583 | "", | ||
2584 | "", | ||
2585 | "\1\u0090", | ||
2586 | "\1\u0091", | ||
2587 | "\1\u0092", | ||
2588 | "", | ||
2589 | "", | ||
2590 | "", | ||
2591 | "", | ||
2592 | "", | ||
2593 | "", | ||
2594 | "", | ||
2595 | "", | ||
2596 | "\1\57\4\uffff\1\57\10\uffff\12\57\7\uffff\32\57\4\uffff\1\57\1\uffff\32\57", | ||
2597 | "", | ||
2598 | "", | ||
2599 | "\1\57\4\uffff\1\57\10\uffff\12\57\7\uffff\32\57\4\uffff\1\57\1\uffff\32\57", | ||
2600 | "\1\u0095", | ||
2601 | "", | ||
2602 | "\1\u0096", | ||
2603 | "\1\57\4\uffff\1\57\10\uffff\12\57\7\uffff\32\57\4\uffff\1\57\1\uffff\32\57", | ||
2604 | "\1\57\4\uffff\1\57\10\uffff\12\57\7\uffff\32\57\4\uffff\1\57\1\uffff\32\57", | ||
2605 | "\1\u0099", | ||
2606 | "\1\57\4\uffff\1\57\10\uffff\12\57\7\uffff\32\57\4\uffff\1\57\1\uffff\32\57", | ||
2607 | "\1\u009b", | ||
2608 | "", | ||
2609 | "\1\u009c", | ||
2610 | "\1\57\4\uffff\1\57\10\uffff\12\57\7\uffff\32\57\4\uffff\1\57\1\uffff\32\57", | ||
2611 | "\1\57\4\uffff\1\57\10\uffff\12\57\7\uffff\32\57\4\uffff\1\57\1\uffff\32\57", | ||
2612 | "\1\57\4\uffff\1\57\10\uffff\12\57\7\uffff\32\57\4\uffff\1\57\1\uffff\32\57", | ||
2613 | "\1\57\4\uffff\1\57\10\uffff\12\57\7\uffff\32\57\4\uffff\1\57\1\uffff\32\57", | ||
2614 | "\1\u00a1", | ||
2615 | "\1\u00a2", | ||
2616 | "\1\u00a3", | ||
2617 | "\1\57\4\uffff\1\57\10\uffff\12\57\7\uffff\32\57\4\uffff\1\57\1\uffff\32\57", | ||
2618 | "\1\57\4\uffff\1\57\10\uffff\12\57\7\uffff\32\57\4\uffff\1\57\1\uffff\32\57", | ||
2619 | "\1\57\4\uffff\1\57\10\uffff\12\57\7\uffff\32\57\4\uffff\1\57\1\uffff\32\57", | ||
2620 | "\1\57\4\uffff\1\57\10\uffff\12\57\7\uffff\32\57\4\uffff\1\57\1\uffff\32\57", | ||
2621 | "\1\u00a8", | ||
2622 | "\1\u00a9", | ||
2623 | "\1\u00aa", | ||
2624 | "\1\u00ab", | ||
2625 | "\1\u00ac", | ||
2626 | "\1\57\4\uffff\1\57\10\uffff\12\57\7\uffff\32\57\4\uffff\1\57\1\uffff\32\57", | ||
2627 | "\1\u00ae", | ||
2628 | "\1\57\4\uffff\1\57\10\uffff\12\57\7\uffff\32\57\4\uffff\1\57\1\uffff\32\57", | ||
2629 | "\1\u00b0", | ||
2630 | "\1\57\4\uffff\1\57\10\uffff\12\57\7\uffff\32\57\4\uffff\1\57\1\uffff\32\57", | ||
2631 | "\1\u00b2", | ||
2632 | "", | ||
2633 | "", | ||
2634 | "\1\u00b3", | ||
2635 | "\1\57\4\uffff\1\57\10\uffff\12\57\7\uffff\32\57\4\uffff\1\57\1\uffff\32\57", | ||
2636 | "", | ||
2637 | "", | ||
2638 | "\1\u00b5", | ||
2639 | "", | ||
2640 | "\1\57\4\uffff\1\57\10\uffff\12\57\7\uffff\32\57\4\uffff\1\57\1\uffff\32\57", | ||
2641 | "\1\57\4\uffff\1\57\10\uffff\12\57\7\uffff\32\57\4\uffff\1\57\1\uffff\32\57", | ||
2642 | "", | ||
2643 | "", | ||
2644 | "", | ||
2645 | "", | ||
2646 | "\1\57\4\uffff\1\57\10\uffff\12\57\7\uffff\32\57\4\uffff\1\57\1\uffff\32\57", | ||
2647 | "\1\57\4\uffff\1\57\10\uffff\12\57\7\uffff\32\57\4\uffff\1\57\1\uffff\32\57", | ||
2648 | "\1\57\4\uffff\1\57\10\uffff\12\57\7\uffff\32\57\4\uffff\1\57\1\uffff\32\57", | ||
2649 | "", | ||
2650 | "", | ||
2651 | "", | ||
2652 | "", | ||
2653 | "\1\57\4\uffff\1\57\10\uffff\12\57\7\uffff\32\57\4\uffff\1\57\1\uffff\32\57", | ||
2654 | "\1\57\4\uffff\1\57\10\uffff\12\57\7\uffff\32\57\4\uffff\1\57\1\uffff\32\57", | ||
2655 | "\1\u00bd", | ||
2656 | "\1\u00be", | ||
2657 | "\1\57\4\uffff\1\57\10\uffff\12\57\7\uffff\32\57\4\uffff\1\57\1\uffff\32\57", | ||
2658 | "", | ||
2659 | "\1\57\4\uffff\1\57\10\uffff\12\57\7\uffff\32\57\4\uffff\1\57\1\uffff\32\57", | ||
2660 | "", | ||
2661 | "\1\57\4\uffff\1\57\10\uffff\12\57\7\uffff\32\57\4\uffff\1\57\1\uffff\32\57", | ||
2662 | "", | ||
2663 | "\1\u00c2", | ||
2664 | "\1\u00c3", | ||
2665 | "", | ||
2666 | "\1\u00c4", | ||
2667 | "", | ||
2668 | "", | ||
2669 | "", | ||
2670 | "", | ||
2671 | "", | ||
2672 | "", | ||
2673 | "", | ||
2674 | "\1\u00c5", | ||
2675 | "\1\u00c6", | ||
2676 | "", | ||
2677 | "", | ||
2678 | "", | ||
2679 | "\1\u00c7", | ||
2680 | "\1\u00c8", | ||
2681 | "\1\u00c9", | ||
2682 | "\1\u00ca", | ||
2683 | "\1\u00cb", | ||
2684 | "\1\57\4\uffff\1\57\10\uffff\12\57\7\uffff\32\57\4\uffff\1\57\1\uffff\32\57", | ||
2685 | "\1\57\4\uffff\1\57\10\uffff\12\57\7\uffff\32\57\4\uffff\1\57\1\uffff\32\57", | ||
2686 | "\1\u00ce", | ||
2687 | "\1\57\4\uffff\1\57\10\uffff\12\57\7\uffff\32\57\4\uffff\1\57\1\uffff\32\57", | ||
2688 | "\1\57\4\uffff\1\57\10\uffff\12\57\7\uffff\32\57\4\uffff\1\57\1\uffff\32\57", | ||
2689 | "", | ||
2690 | "", | ||
2691 | "\1\57\4\uffff\1\57\10\uffff\12\57\7\uffff\32\57\4\uffff\1\57\1\uffff\32\57", | ||
2692 | "", | ||
2693 | "", | ||
2694 | "" | ||
2695 | }; | ||
2696 | |||
2697 | static final short[] DFA11_eot = DFA.unpackEncodedString(DFA11_eotS); | ||
2698 | static final short[] DFA11_eof = DFA.unpackEncodedString(DFA11_eofS); | ||
2699 | static final char[] DFA11_min = DFA.unpackEncodedStringToUnsignedChars(DFA11_minS); | ||
2700 | static final char[] DFA11_max = DFA.unpackEncodedStringToUnsignedChars(DFA11_maxS); | ||
2701 | static final short[] DFA11_accept = DFA.unpackEncodedString(DFA11_acceptS); | ||
2702 | static final short[] DFA11_special = DFA.unpackEncodedString(DFA11_specialS); | ||
2703 | static final short[][] DFA11_transition; | ||
2704 | |||
2705 | static { | ||
2706 | int numStates = DFA11_transitionS.length; | ||
2707 | DFA11_transition = new short[numStates][]; | ||
2708 | for (int i=0; i<numStates; i++) { | ||
2709 | DFA11_transition[i] = DFA.unpackEncodedString(DFA11_transitionS[i]); | ||
2710 | } | ||
2711 | } | ||
2712 | |||
2713 | class DFA11 extends DFA { | ||
2714 | |||
2715 | public DFA11(BaseRecognizer recognizer) { | ||
2716 | this.recognizer = recognizer; | ||
2717 | this.decisionNumber = 11; | ||
2718 | this.eot = DFA11_eot; | ||
2719 | this.eof = DFA11_eof; | ||
2720 | this.min = DFA11_min; | ||
2721 | this.max = DFA11_max; | ||
2722 | this.accept = DFA11_accept; | ||
2723 | this.special = DFA11_special; | ||
2724 | this.transition = DFA11_transition; | ||
2725 | } | ||
2726 | public String getDescription() { | ||
2727 | return "1:1: Tokens : ( T__11 | T__12 | T__13 | T__14 | T__15 | T__16 | T__17 | T__18 | T__19 | T__20 | T__21 | T__22 | T__23 | T__24 | T__25 | T__26 | T__27 | T__28 | T__29 | T__30 | T__31 | T__32 | T__33 | T__34 | T__35 | T__36 | T__37 | T__38 | T__39 | T__40 | T__41 | T__42 | T__43 | T__44 | T__45 | T__46 | T__47 | T__48 | T__49 | T__50 | T__51 | T__52 | T__53 | T__54 | T__55 | T__56 | T__57 | T__58 | T__59 | T__60 | T__61 | T__62 | T__63 | T__64 | T__65 | T__66 | T__67 | T__68 | T__69 | T__70 | T__71 | T__72 | T__73 | T__74 | T__75 | T__76 | RULE_ID | RULE_INT | RULE_STRING | RULE_ML_COMMENT | RULE_SL_COMMENT | RULE_WS | RULE_ANY_OTHER );"; | ||
2728 | } | ||
2729 | public int specialStateTransition(int s, IntStream _input) throws NoViableAltException { | ||
2730 | IntStream input = _input; | ||
2731 | int _s = s; | ||
2732 | switch ( s ) { | ||
2733 | case 0 : | ||
2734 | int LA11_40 = input.LA(1); | ||
2735 | |||
2736 | s = -1; | ||
2737 | if ( ((LA11_40>='\u0000' && LA11_40<='\uFFFF')) ) {s = 106;} | ||
2738 | |||
2739 | else s = 43; | ||
2740 | |||
2741 | if ( s>=0 ) return s; | ||
2742 | break; | ||
2743 | case 1 : | ||
2744 | int LA11_39 = input.LA(1); | ||
2745 | |||
2746 | s = -1; | ||
2747 | if ( ((LA11_39>='\u0000' && LA11_39<='\uFFFF')) ) {s = 106;} | ||
2748 | |||
2749 | else s = 43; | ||
2750 | |||
2751 | if ( s>=0 ) return s; | ||
2752 | break; | ||
2753 | case 2 : | ||
2754 | int LA11_0 = input.LA(1); | ||
2755 | |||
2756 | s = -1; | ||
2757 | if ( (LA11_0=='|') ) {s = 1;} | ||
2758 | |||
2759 | else if ( (LA11_0=='o') ) {s = 2;} | ||
2760 | |||
2761 | else if ( (LA11_0=='<') ) {s = 3;} | ||
2762 | |||
2763 | else if ( (LA11_0=='i') ) {s = 4;} | ||
2764 | |||
2765 | else if ( (LA11_0=='=') ) {s = 5;} | ||
2766 | |||
2767 | else if ( (LA11_0=='&') ) {s = 6;} | ||
2768 | |||
2769 | else if ( (LA11_0=='a') ) {s = 7;} | ||
2770 | |||
2771 | else if ( (LA11_0=='!') ) {s = 8;} | ||
2772 | |||
2773 | else if ( (LA11_0=='n') ) {s = 9;} | ||
2774 | |||
2775 | else if ( (LA11_0=='s') ) {s = 10;} | ||
2776 | |||
2777 | else if ( (LA11_0=='l') ) {s = 11;} | ||
2778 | |||
2779 | else if ( (LA11_0=='p') ) {s = 12;} | ||
2780 | |||
2781 | else if ( (LA11_0=='m') ) {s = 13;} | ||
2782 | |||
2783 | else if ( (LA11_0=='r') ) {s = 14;} | ||
2784 | |||
2785 | else if ( (LA11_0=='d') ) {s = 15;} | ||
2786 | |||
2787 | else if ( (LA11_0=='e') ) {s = 16;} | ||
2788 | |||
2789 | else if ( (LA11_0=='{') ) {s = 17;} | ||
2790 | |||
2791 | else if ( (LA11_0=='}') ) {s = 18;} | ||
2792 | |||
2793 | else if ( (LA11_0==',') ) {s = 19;} | ||
2794 | |||
2795 | else if ( (LA11_0=='+') ) {s = 20;} | ||
2796 | |||
2797 | else if ( (LA11_0==':') ) {s = 21;} | ||
2798 | |||
2799 | else if ( (LA11_0=='f') ) {s = 22;} | ||
2800 | |||
2801 | else if ( (LA11_0=='[') ) {s = 23;} | ||
2802 | |||
2803 | else if ( (LA11_0==']') ) {s = 24;} | ||
2804 | |||
2805 | else if ( (LA11_0=='>') ) {s = 25;} | ||
2806 | |||
2807 | else if ( (LA11_0=='.') ) {s = 26;} | ||
2808 | |||
2809 | else if ( (LA11_0=='-') ) {s = 27;} | ||
2810 | |||
2811 | else if ( (LA11_0=='~') ) {s = 28;} | ||
2812 | |||
2813 | else if ( (LA11_0=='^') ) {s = 29;} | ||
2814 | |||
2815 | else if ( (LA11_0=='*') ) {s = 30;} | ||
2816 | |||
2817 | else if ( (LA11_0=='#') ) {s = 31;} | ||
2818 | |||
2819 | else if ( (LA11_0=='u') ) {s = 32;} | ||
2820 | |||
2821 | else if ( (LA11_0=='I') ) {s = 33;} | ||
2822 | |||
2823 | else if ( (LA11_0=='S') ) {s = 34;} | ||
2824 | |||
2825 | else if ( (LA11_0=='(') ) {s = 35;} | ||
2826 | |||
2827 | else if ( (LA11_0==')') ) {s = 36;} | ||
2828 | |||
2829 | else if ( ((LA11_0>='A' && LA11_0<='H')||(LA11_0>='J' && LA11_0<='R')||(LA11_0>='T' && LA11_0<='Z')||LA11_0=='_'||(LA11_0>='b' && LA11_0<='c')||(LA11_0>='g' && LA11_0<='h')||(LA11_0>='j' && LA11_0<='k')||LA11_0=='q'||LA11_0=='t'||(LA11_0>='v' && LA11_0<='z')) ) {s = 37;} | ||
2830 | |||
2831 | else if ( ((LA11_0>='0' && LA11_0<='9')) ) {s = 38;} | ||
2832 | |||
2833 | else if ( (LA11_0=='\"') ) {s = 39;} | ||
2834 | |||
2835 | else if ( (LA11_0=='\'') ) {s = 40;} | ||
2836 | |||
2837 | else if ( (LA11_0=='/') ) {s = 41;} | ||
2838 | |||
2839 | else if ( ((LA11_0>='\t' && LA11_0<='\n')||LA11_0=='\r'||LA11_0==' ') ) {s = 42;} | ||
2840 | |||
2841 | else if ( ((LA11_0>='\u0000' && LA11_0<='\b')||(LA11_0>='\u000B' && LA11_0<='\f')||(LA11_0>='\u000E' && LA11_0<='\u001F')||(LA11_0>='$' && LA11_0<='%')||LA11_0==';'||(LA11_0>='?' && LA11_0<='@')||LA11_0=='\\'||LA11_0=='`'||(LA11_0>='\u007F' && LA11_0<='\uFFFF')) ) {s = 43;} | ||
2842 | |||
2843 | if ( s>=0 ) return s; | ||
2844 | break; | ||
2845 | } | ||
2846 | NoViableAltException nvae = | ||
2847 | new NoViableAltException(getDescription(), 11, _s, input); | ||
2848 | error(nvae); | ||
2849 | throw nvae; | ||
2850 | } | ||
2851 | } | ||
2852 | |||
2853 | |||
2854 | } \ No newline at end of file | ||
diff --git a/Solvers/Alloy-Solver2/hu.bme.mit.inf.dslreasoner.alloy.language.ui/src-gen/hu/bme/mit/inf/dslreasoner/ui/contentassist/antlr/internal/InternalAlloyLanguageParser.java b/Solvers/Alloy-Solver2/hu.bme.mit.inf.dslreasoner.alloy.language.ui/src-gen/hu/bme/mit/inf/dslreasoner/ui/contentassist/antlr/internal/InternalAlloyLanguageParser.java new file mode 100644 index 00000000..96888ce4 --- /dev/null +++ b/Solvers/Alloy-Solver2/hu.bme.mit.inf.dslreasoner.alloy.language.ui/src-gen/hu/bme/mit/inf/dslreasoner/ui/contentassist/antlr/internal/InternalAlloyLanguageParser.java | |||
@@ -0,0 +1,29554 @@ | |||
1 | package hu.bme.mit.inf.dslreasoner.ui.contentassist.antlr.internal; | ||
2 | |||
3 | import java.io.InputStream; | ||
4 | import org.eclipse.xtext.*; | ||
5 | import org.eclipse.xtext.parser.*; | ||
6 | import org.eclipse.xtext.parser.impl.*; | ||
7 | import org.eclipse.emf.ecore.util.EcoreUtil; | ||
8 | import org.eclipse.emf.ecore.EObject; | ||
9 | import org.eclipse.xtext.parser.antlr.XtextTokenStream; | ||
10 | import org.eclipse.xtext.parser.antlr.XtextTokenStream.HiddenTokens; | ||
11 | import org.eclipse.xtext.ui.editor.contentassist.antlr.internal.AbstractInternalContentAssistParser; | ||
12 | import org.eclipse.xtext.ui.editor.contentassist.antlr.internal.DFA; | ||
13 | import hu.bme.mit.inf.dslreasoner.services.AlloyLanguageGrammarAccess; | ||
14 | |||
15 | |||
16 | |||
17 | import org.antlr.runtime.*; | ||
18 | import java.util.Stack; | ||
19 | import java.util.List; | ||
20 | import java.util.ArrayList; | ||
21 | import java.util.Map; | ||
22 | import java.util.HashMap; | ||
23 | @SuppressWarnings("all") | ||
24 | public class InternalAlloyLanguageParser extends AbstractInternalContentAssistParser { | ||
25 | public static final String[] tokenNames = new String[] { | ||
26 | "<invalid>", "<EOR>", "<DOWN>", "<UP>", "RULE_ID", "RULE_INT", "RULE_STRING", "RULE_ML_COMMENT", "RULE_SL_COMMENT", "RULE_WS", "RULE_ANY_OTHER", "'||'", "'or'", "'<=>'", "'iff'", "'=>'", "'implies'", "'&&'", "'and'", "'!'", "'not'", "'all'", "'no'", "'some'", "'lone'", "'one'", "'set'", "'plus'", "'sub'", "'mul'", "'rem'", "'div'", "'enum'", "'{'", "'}'", "','", "'sig'", "'extends'", "'in'", "'+'", "':'", "'fun'", "'['", "']'", "'pred'", "'fact'", "'else'", "'='", "'!='", "'>'", "'>='", "'<'", "'<='", "'++'", "':>'", "'<:'", "'.'", "'-'", "'&'", "'->'", "'~'", "'^'", "'*'", "'#'", "'sum'", "'none'", "'iden'", "'univ'", "'Int'", "'String'", "'('", "')'", "'run'", "'for'", "'exactly'", "'abstract'", "'disj'" | ||
27 | }; | ||
28 | public static final int T__50=50; | ||
29 | public static final int T__19=19; | ||
30 | public static final int T__15=15; | ||
31 | public static final int T__59=59; | ||
32 | public static final int T__16=16; | ||
33 | public static final int T__17=17; | ||
34 | public static final int T__18=18; | ||
35 | public static final int T__11=11; | ||
36 | public static final int T__55=55; | ||
37 | public static final int T__12=12; | ||
38 | public static final int T__56=56; | ||
39 | public static final int T__13=13; | ||
40 | public static final int T__57=57; | ||
41 | public static final int T__14=14; | ||
42 | public static final int T__58=58; | ||
43 | public static final int T__51=51; | ||
44 | public static final int T__52=52; | ||
45 | public static final int T__53=53; | ||
46 | public static final int T__54=54; | ||
47 | public static final int T__60=60; | ||
48 | public static final int T__61=61; | ||
49 | public static final int RULE_ID=4; | ||
50 | public static final int T__26=26; | ||
51 | public static final int T__27=27; | ||
52 | public static final int T__28=28; | ||
53 | public static final int RULE_INT=5; | ||
54 | public static final int T__29=29; | ||
55 | public static final int T__22=22; | ||
56 | public static final int T__66=66; | ||
57 | public static final int RULE_ML_COMMENT=7; | ||
58 | public static final int T__23=23; | ||
59 | public static final int T__67=67; | ||
60 | public static final int T__24=24; | ||
61 | public static final int T__68=68; | ||
62 | public static final int T__25=25; | ||
63 | public static final int T__69=69; | ||
64 | public static final int T__62=62; | ||
65 | public static final int T__63=63; | ||
66 | public static final int T__20=20; | ||
67 | public static final int T__64=64; | ||
68 | public static final int T__21=21; | ||
69 | public static final int T__65=65; | ||
70 | public static final int T__70=70; | ||
71 | public static final int T__71=71; | ||
72 | public static final int T__72=72; | ||
73 | public static final int RULE_STRING=6; | ||
74 | public static final int RULE_SL_COMMENT=8; | ||
75 | public static final int T__37=37; | ||
76 | public static final int T__38=38; | ||
77 | public static final int T__39=39; | ||
78 | public static final int T__33=33; | ||
79 | public static final int T__34=34; | ||
80 | public static final int T__35=35; | ||
81 | public static final int T__36=36; | ||
82 | public static final int T__73=73; | ||
83 | public static final int EOF=-1; | ||
84 | public static final int T__30=30; | ||
85 | public static final int T__74=74; | ||
86 | public static final int T__31=31; | ||
87 | public static final int T__75=75; | ||
88 | public static final int T__32=32; | ||
89 | public static final int T__76=76; | ||
90 | public static final int RULE_WS=9; | ||
91 | public static final int RULE_ANY_OTHER=10; | ||
92 | public static final int T__48=48; | ||
93 | public static final int T__49=49; | ||
94 | public static final int T__44=44; | ||
95 | public static final int T__45=45; | ||
96 | public static final int T__46=46; | ||
97 | public static final int T__47=47; | ||
98 | public static final int T__40=40; | ||
99 | public static final int T__41=41; | ||
100 | public static final int T__42=42; | ||
101 | public static final int T__43=43; | ||
102 | |||
103 | // delegates | ||
104 | // delegators | ||
105 | |||
106 | |||
107 | public InternalAlloyLanguageParser(TokenStream input) { | ||
108 | this(input, new RecognizerSharedState()); | ||
109 | } | ||
110 | public InternalAlloyLanguageParser(TokenStream input, RecognizerSharedState state) { | ||
111 | super(input, state); | ||
112 | |||
113 | } | ||
114 | |||
115 | |||
116 | public String[] getTokenNames() { return InternalAlloyLanguageParser.tokenNames; } | ||
117 | public String getGrammarFileName() { return "InternalAlloyLanguage.g"; } | ||
118 | |||
119 | |||
120 | |||
121 | private AlloyLanguageGrammarAccess grammarAccess; | ||
122 | |||
123 | public void setGrammarAccess(AlloyLanguageGrammarAccess grammarAccess) { | ||
124 | this.grammarAccess = grammarAccess; | ||
125 | } | ||
126 | |||
127 | @Override | ||
128 | protected Grammar getGrammar() { | ||
129 | return grammarAccess.getGrammar(); | ||
130 | } | ||
131 | |||
132 | @Override | ||
133 | protected String getValueForTokenName(String tokenName) { | ||
134 | return tokenName; | ||
135 | } | ||
136 | |||
137 | |||
138 | |||
139 | |||
140 | // $ANTLR start "entryRuleALSDocument" | ||
141 | // InternalAlloyLanguage.g:61:1: entryRuleALSDocument : ruleALSDocument EOF ; | ||
142 | public final void entryRuleALSDocument() throws RecognitionException { | ||
143 | try { | ||
144 | // InternalAlloyLanguage.g:62:1: ( ruleALSDocument EOF ) | ||
145 | // InternalAlloyLanguage.g:63:1: ruleALSDocument EOF | ||
146 | { | ||
147 | if ( state.backtracking==0 ) { | ||
148 | before(grammarAccess.getALSDocumentRule()); | ||
149 | } | ||
150 | pushFollow(FOLLOW_1); | ||
151 | ruleALSDocument(); | ||
152 | |||
153 | state._fsp--; | ||
154 | if (state.failed) return ; | ||
155 | if ( state.backtracking==0 ) { | ||
156 | after(grammarAccess.getALSDocumentRule()); | ||
157 | } | ||
158 | match(input,EOF,FOLLOW_2); if (state.failed) return ; | ||
159 | |||
160 | } | ||
161 | |||
162 | } | ||
163 | catch (RecognitionException re) { | ||
164 | reportError(re); | ||
165 | recover(input,re); | ||
166 | } | ||
167 | finally { | ||
168 | } | ||
169 | return ; | ||
170 | } | ||
171 | // $ANTLR end "entryRuleALSDocument" | ||
172 | |||
173 | |||
174 | // $ANTLR start "ruleALSDocument" | ||
175 | // InternalAlloyLanguage.g:70:1: ruleALSDocument : ( ( rule__ALSDocument__Group__0 ) ) ; | ||
176 | public final void ruleALSDocument() throws RecognitionException { | ||
177 | |||
178 | int stackSize = keepStackSize(); | ||
179 | |||
180 | try { | ||
181 | // InternalAlloyLanguage.g:74:2: ( ( ( rule__ALSDocument__Group__0 ) ) ) | ||
182 | // InternalAlloyLanguage.g:75:1: ( ( rule__ALSDocument__Group__0 ) ) | ||
183 | { | ||
184 | // InternalAlloyLanguage.g:75:1: ( ( rule__ALSDocument__Group__0 ) ) | ||
185 | // InternalAlloyLanguage.g:76:1: ( rule__ALSDocument__Group__0 ) | ||
186 | { | ||
187 | if ( state.backtracking==0 ) { | ||
188 | before(grammarAccess.getALSDocumentAccess().getGroup()); | ||
189 | } | ||
190 | // InternalAlloyLanguage.g:77:1: ( rule__ALSDocument__Group__0 ) | ||
191 | // InternalAlloyLanguage.g:77:2: rule__ALSDocument__Group__0 | ||
192 | { | ||
193 | pushFollow(FOLLOW_2); | ||
194 | rule__ALSDocument__Group__0(); | ||
195 | |||
196 | state._fsp--; | ||
197 | if (state.failed) return ; | ||
198 | |||
199 | } | ||
200 | |||
201 | if ( state.backtracking==0 ) { | ||
202 | after(grammarAccess.getALSDocumentAccess().getGroup()); | ||
203 | } | ||
204 | |||
205 | } | ||
206 | |||
207 | |||
208 | } | ||
209 | |||
210 | } | ||
211 | catch (RecognitionException re) { | ||
212 | reportError(re); | ||
213 | recover(input,re); | ||
214 | } | ||
215 | finally { | ||
216 | |||
217 | restoreStackSize(stackSize); | ||
218 | |||
219 | } | ||
220 | return ; | ||
221 | } | ||
222 | // $ANTLR end "ruleALSDocument" | ||
223 | |||
224 | |||
225 | // $ANTLR start "entryRuleALSID" | ||
226 | // InternalAlloyLanguage.g:89:1: entryRuleALSID : ruleALSID EOF ; | ||
227 | public final void entryRuleALSID() throws RecognitionException { | ||
228 | try { | ||
229 | // InternalAlloyLanguage.g:90:1: ( ruleALSID EOF ) | ||
230 | // InternalAlloyLanguage.g:91:1: ruleALSID EOF | ||
231 | { | ||
232 | if ( state.backtracking==0 ) { | ||
233 | before(grammarAccess.getALSIDRule()); | ||
234 | } | ||
235 | pushFollow(FOLLOW_1); | ||
236 | ruleALSID(); | ||
237 | |||
238 | state._fsp--; | ||
239 | if (state.failed) return ; | ||
240 | if ( state.backtracking==0 ) { | ||
241 | after(grammarAccess.getALSIDRule()); | ||
242 | } | ||
243 | match(input,EOF,FOLLOW_2); if (state.failed) return ; | ||
244 | |||
245 | } | ||
246 | |||
247 | } | ||
248 | catch (RecognitionException re) { | ||
249 | reportError(re); | ||
250 | recover(input,re); | ||
251 | } | ||
252 | finally { | ||
253 | } | ||
254 | return ; | ||
255 | } | ||
256 | // $ANTLR end "entryRuleALSID" | ||
257 | |||
258 | |||
259 | // $ANTLR start "ruleALSID" | ||
260 | // InternalAlloyLanguage.g:98:1: ruleALSID : ( RULE_ID ) ; | ||
261 | public final void ruleALSID() throws RecognitionException { | ||
262 | |||
263 | int stackSize = keepStackSize(); | ||
264 | |||
265 | try { | ||
266 | // InternalAlloyLanguage.g:102:2: ( ( RULE_ID ) ) | ||
267 | // InternalAlloyLanguage.g:103:1: ( RULE_ID ) | ||
268 | { | ||
269 | // InternalAlloyLanguage.g:103:1: ( RULE_ID ) | ||
270 | // InternalAlloyLanguage.g:104:1: RULE_ID | ||
271 | { | ||
272 | if ( state.backtracking==0 ) { | ||
273 | before(grammarAccess.getALSIDAccess().getIDTerminalRuleCall()); | ||
274 | } | ||
275 | match(input,RULE_ID,FOLLOW_2); if (state.failed) return ; | ||
276 | if ( state.backtracking==0 ) { | ||
277 | after(grammarAccess.getALSIDAccess().getIDTerminalRuleCall()); | ||
278 | } | ||
279 | |||
280 | } | ||
281 | |||
282 | |||
283 | } | ||
284 | |||
285 | } | ||
286 | catch (RecognitionException re) { | ||
287 | reportError(re); | ||
288 | recover(input,re); | ||
289 | } | ||
290 | finally { | ||
291 | |||
292 | restoreStackSize(stackSize); | ||
293 | |||
294 | } | ||
295 | return ; | ||
296 | } | ||
297 | // $ANTLR end "ruleALSID" | ||
298 | |||
299 | |||
300 | // $ANTLR start "entryRuleALSTypeDeclaration" | ||
301 | // InternalAlloyLanguage.g:119:1: entryRuleALSTypeDeclaration : ruleALSTypeDeclaration EOF ; | ||
302 | public final void entryRuleALSTypeDeclaration() throws RecognitionException { | ||
303 | try { | ||
304 | // InternalAlloyLanguage.g:120:1: ( ruleALSTypeDeclaration EOF ) | ||
305 | // InternalAlloyLanguage.g:121:1: ruleALSTypeDeclaration EOF | ||
306 | { | ||
307 | if ( state.backtracking==0 ) { | ||
308 | before(grammarAccess.getALSTypeDeclarationRule()); | ||
309 | } | ||
310 | pushFollow(FOLLOW_1); | ||
311 | ruleALSTypeDeclaration(); | ||
312 | |||
313 | state._fsp--; | ||
314 | if (state.failed) return ; | ||
315 | if ( state.backtracking==0 ) { | ||
316 | after(grammarAccess.getALSTypeDeclarationRule()); | ||
317 | } | ||
318 | match(input,EOF,FOLLOW_2); if (state.failed) return ; | ||
319 | |||
320 | } | ||
321 | |||
322 | } | ||
323 | catch (RecognitionException re) { | ||
324 | reportError(re); | ||
325 | recover(input,re); | ||
326 | } | ||
327 | finally { | ||
328 | } | ||
329 | return ; | ||
330 | } | ||
331 | // $ANTLR end "entryRuleALSTypeDeclaration" | ||
332 | |||
333 | |||
334 | // $ANTLR start "ruleALSTypeDeclaration" | ||
335 | // InternalAlloyLanguage.g:128:1: ruleALSTypeDeclaration : ( ( rule__ALSTypeDeclaration__Alternatives ) ) ; | ||
336 | public final void ruleALSTypeDeclaration() throws RecognitionException { | ||
337 | |||
338 | int stackSize = keepStackSize(); | ||
339 | |||
340 | try { | ||
341 | // InternalAlloyLanguage.g:132:2: ( ( ( rule__ALSTypeDeclaration__Alternatives ) ) ) | ||
342 | // InternalAlloyLanguage.g:133:1: ( ( rule__ALSTypeDeclaration__Alternatives ) ) | ||
343 | { | ||
344 | // InternalAlloyLanguage.g:133:1: ( ( rule__ALSTypeDeclaration__Alternatives ) ) | ||
345 | // InternalAlloyLanguage.g:134:1: ( rule__ALSTypeDeclaration__Alternatives ) | ||
346 | { | ||
347 | if ( state.backtracking==0 ) { | ||
348 | before(grammarAccess.getALSTypeDeclarationAccess().getAlternatives()); | ||
349 | } | ||
350 | // InternalAlloyLanguage.g:135:1: ( rule__ALSTypeDeclaration__Alternatives ) | ||
351 | // InternalAlloyLanguage.g:135:2: rule__ALSTypeDeclaration__Alternatives | ||
352 | { | ||
353 | pushFollow(FOLLOW_2); | ||
354 | rule__ALSTypeDeclaration__Alternatives(); | ||
355 | |||
356 | state._fsp--; | ||
357 | if (state.failed) return ; | ||
358 | |||
359 | } | ||
360 | |||
361 | if ( state.backtracking==0 ) { | ||
362 | after(grammarAccess.getALSTypeDeclarationAccess().getAlternatives()); | ||
363 | } | ||
364 | |||
365 | } | ||
366 | |||
367 | |||
368 | } | ||
369 | |||
370 | } | ||
371 | catch (RecognitionException re) { | ||
372 | reportError(re); | ||
373 | recover(input,re); | ||
374 | } | ||
375 | finally { | ||
376 | |||
377 | restoreStackSize(stackSize); | ||
378 | |||
379 | } | ||
380 | return ; | ||
381 | } | ||
382 | // $ANTLR end "ruleALSTypeDeclaration" | ||
383 | |||
384 | |||
385 | // $ANTLR start "entryRuleALSEnumDeclaration" | ||
386 | // InternalAlloyLanguage.g:147:1: entryRuleALSEnumDeclaration : ruleALSEnumDeclaration EOF ; | ||
387 | public final void entryRuleALSEnumDeclaration() throws RecognitionException { | ||
388 | try { | ||
389 | // InternalAlloyLanguage.g:148:1: ( ruleALSEnumDeclaration EOF ) | ||
390 | // InternalAlloyLanguage.g:149:1: ruleALSEnumDeclaration EOF | ||
391 | { | ||
392 | if ( state.backtracking==0 ) { | ||
393 | before(grammarAccess.getALSEnumDeclarationRule()); | ||
394 | } | ||
395 | pushFollow(FOLLOW_1); | ||
396 | ruleALSEnumDeclaration(); | ||
397 | |||
398 | state._fsp--; | ||
399 | if (state.failed) return ; | ||
400 | if ( state.backtracking==0 ) { | ||
401 | after(grammarAccess.getALSEnumDeclarationRule()); | ||
402 | } | ||
403 | match(input,EOF,FOLLOW_2); if (state.failed) return ; | ||
404 | |||
405 | } | ||
406 | |||
407 | } | ||
408 | catch (RecognitionException re) { | ||
409 | reportError(re); | ||
410 | recover(input,re); | ||
411 | } | ||
412 | finally { | ||
413 | } | ||
414 | return ; | ||
415 | } | ||
416 | // $ANTLR end "entryRuleALSEnumDeclaration" | ||
417 | |||
418 | |||
419 | // $ANTLR start "ruleALSEnumDeclaration" | ||
420 | // InternalAlloyLanguage.g:156:1: ruleALSEnumDeclaration : ( ( rule__ALSEnumDeclaration__Group__0 ) ) ; | ||
421 | public final void ruleALSEnumDeclaration() throws RecognitionException { | ||
422 | |||
423 | int stackSize = keepStackSize(); | ||
424 | |||
425 | try { | ||
426 | // InternalAlloyLanguage.g:160:2: ( ( ( rule__ALSEnumDeclaration__Group__0 ) ) ) | ||
427 | // InternalAlloyLanguage.g:161:1: ( ( rule__ALSEnumDeclaration__Group__0 ) ) | ||
428 | { | ||
429 | // InternalAlloyLanguage.g:161:1: ( ( rule__ALSEnumDeclaration__Group__0 ) ) | ||
430 | // InternalAlloyLanguage.g:162:1: ( rule__ALSEnumDeclaration__Group__0 ) | ||
431 | { | ||
432 | if ( state.backtracking==0 ) { | ||
433 | before(grammarAccess.getALSEnumDeclarationAccess().getGroup()); | ||
434 | } | ||
435 | // InternalAlloyLanguage.g:163:1: ( rule__ALSEnumDeclaration__Group__0 ) | ||
436 | // InternalAlloyLanguage.g:163:2: rule__ALSEnumDeclaration__Group__0 | ||
437 | { | ||
438 | pushFollow(FOLLOW_2); | ||
439 | rule__ALSEnumDeclaration__Group__0(); | ||
440 | |||
441 | state._fsp--; | ||
442 | if (state.failed) return ; | ||
443 | |||
444 | } | ||
445 | |||
446 | if ( state.backtracking==0 ) { | ||
447 | after(grammarAccess.getALSEnumDeclarationAccess().getGroup()); | ||
448 | } | ||
449 | |||
450 | } | ||
451 | |||
452 | |||
453 | } | ||
454 | |||
455 | } | ||
456 | catch (RecognitionException re) { | ||
457 | reportError(re); | ||
458 | recover(input,re); | ||
459 | } | ||
460 | finally { | ||
461 | |||
462 | restoreStackSize(stackSize); | ||
463 | |||
464 | } | ||
465 | return ; | ||
466 | } | ||
467 | // $ANTLR end "ruleALSEnumDeclaration" | ||
468 | |||
469 | |||
470 | // $ANTLR start "entryRuleALSEnumLiteral" | ||
471 | // InternalAlloyLanguage.g:175:1: entryRuleALSEnumLiteral : ruleALSEnumLiteral EOF ; | ||
472 | public final void entryRuleALSEnumLiteral() throws RecognitionException { | ||
473 | try { | ||
474 | // InternalAlloyLanguage.g:176:1: ( ruleALSEnumLiteral EOF ) | ||
475 | // InternalAlloyLanguage.g:177:1: ruleALSEnumLiteral EOF | ||
476 | { | ||
477 | if ( state.backtracking==0 ) { | ||
478 | before(grammarAccess.getALSEnumLiteralRule()); | ||
479 | } | ||
480 | pushFollow(FOLLOW_1); | ||
481 | ruleALSEnumLiteral(); | ||
482 | |||
483 | state._fsp--; | ||
484 | if (state.failed) return ; | ||
485 | if ( state.backtracking==0 ) { | ||
486 | after(grammarAccess.getALSEnumLiteralRule()); | ||
487 | } | ||
488 | match(input,EOF,FOLLOW_2); if (state.failed) return ; | ||
489 | |||
490 | } | ||
491 | |||
492 | } | ||
493 | catch (RecognitionException re) { | ||
494 | reportError(re); | ||
495 | recover(input,re); | ||
496 | } | ||
497 | finally { | ||
498 | } | ||
499 | return ; | ||
500 | } | ||
501 | // $ANTLR end "entryRuleALSEnumLiteral" | ||
502 | |||
503 | |||
504 | // $ANTLR start "ruleALSEnumLiteral" | ||
505 | // InternalAlloyLanguage.g:184:1: ruleALSEnumLiteral : ( ( rule__ALSEnumLiteral__NameAssignment ) ) ; | ||
506 | public final void ruleALSEnumLiteral() throws RecognitionException { | ||
507 | |||
508 | int stackSize = keepStackSize(); | ||
509 | |||
510 | try { | ||
511 | // InternalAlloyLanguage.g:188:2: ( ( ( rule__ALSEnumLiteral__NameAssignment ) ) ) | ||
512 | // InternalAlloyLanguage.g:189:1: ( ( rule__ALSEnumLiteral__NameAssignment ) ) | ||
513 | { | ||
514 | // InternalAlloyLanguage.g:189:1: ( ( rule__ALSEnumLiteral__NameAssignment ) ) | ||
515 | // InternalAlloyLanguage.g:190:1: ( rule__ALSEnumLiteral__NameAssignment ) | ||
516 | { | ||
517 | if ( state.backtracking==0 ) { | ||
518 | before(grammarAccess.getALSEnumLiteralAccess().getNameAssignment()); | ||
519 | } | ||
520 | // InternalAlloyLanguage.g:191:1: ( rule__ALSEnumLiteral__NameAssignment ) | ||
521 | // InternalAlloyLanguage.g:191:2: rule__ALSEnumLiteral__NameAssignment | ||
522 | { | ||
523 | pushFollow(FOLLOW_2); | ||
524 | rule__ALSEnumLiteral__NameAssignment(); | ||
525 | |||
526 | state._fsp--; | ||
527 | if (state.failed) return ; | ||
528 | |||
529 | } | ||
530 | |||
531 | if ( state.backtracking==0 ) { | ||
532 | after(grammarAccess.getALSEnumLiteralAccess().getNameAssignment()); | ||
533 | } | ||
534 | |||
535 | } | ||
536 | |||
537 | |||
538 | } | ||
539 | |||
540 | } | ||
541 | catch (RecognitionException re) { | ||
542 | reportError(re); | ||
543 | recover(input,re); | ||
544 | } | ||
545 | finally { | ||
546 | |||
547 | restoreStackSize(stackSize); | ||
548 | |||
549 | } | ||
550 | return ; | ||
551 | } | ||
552 | // $ANTLR end "ruleALSEnumLiteral" | ||
553 | |||
554 | |||
555 | // $ANTLR start "entryRuleALSSignatureDeclaration" | ||
556 | // InternalAlloyLanguage.g:203:1: entryRuleALSSignatureDeclaration : ruleALSSignatureDeclaration EOF ; | ||
557 | public final void entryRuleALSSignatureDeclaration() throws RecognitionException { | ||
558 | try { | ||
559 | // InternalAlloyLanguage.g:204:1: ( ruleALSSignatureDeclaration EOF ) | ||
560 | // InternalAlloyLanguage.g:205:1: ruleALSSignatureDeclaration EOF | ||
561 | { | ||
562 | if ( state.backtracking==0 ) { | ||
563 | before(grammarAccess.getALSSignatureDeclarationRule()); | ||
564 | } | ||
565 | pushFollow(FOLLOW_1); | ||
566 | ruleALSSignatureDeclaration(); | ||
567 | |||
568 | state._fsp--; | ||
569 | if (state.failed) return ; | ||
570 | if ( state.backtracking==0 ) { | ||
571 | after(grammarAccess.getALSSignatureDeclarationRule()); | ||
572 | } | ||
573 | match(input,EOF,FOLLOW_2); if (state.failed) return ; | ||
574 | |||
575 | } | ||
576 | |||
577 | } | ||
578 | catch (RecognitionException re) { | ||
579 | reportError(re); | ||
580 | recover(input,re); | ||
581 | } | ||
582 | finally { | ||
583 | } | ||
584 | return ; | ||
585 | } | ||
586 | // $ANTLR end "entryRuleALSSignatureDeclaration" | ||
587 | |||
588 | |||
589 | // $ANTLR start "ruleALSSignatureDeclaration" | ||
590 | // InternalAlloyLanguage.g:212:1: ruleALSSignatureDeclaration : ( ( rule__ALSSignatureDeclaration__NameAssignment ) ) ; | ||
591 | public final void ruleALSSignatureDeclaration() throws RecognitionException { | ||
592 | |||
593 | int stackSize = keepStackSize(); | ||
594 | |||
595 | try { | ||
596 | // InternalAlloyLanguage.g:216:2: ( ( ( rule__ALSSignatureDeclaration__NameAssignment ) ) ) | ||
597 | // InternalAlloyLanguage.g:217:1: ( ( rule__ALSSignatureDeclaration__NameAssignment ) ) | ||
598 | { | ||
599 | // InternalAlloyLanguage.g:217:1: ( ( rule__ALSSignatureDeclaration__NameAssignment ) ) | ||
600 | // InternalAlloyLanguage.g:218:1: ( rule__ALSSignatureDeclaration__NameAssignment ) | ||
601 | { | ||
602 | if ( state.backtracking==0 ) { | ||
603 | before(grammarAccess.getALSSignatureDeclarationAccess().getNameAssignment()); | ||
604 | } | ||
605 | // InternalAlloyLanguage.g:219:1: ( rule__ALSSignatureDeclaration__NameAssignment ) | ||
606 | // InternalAlloyLanguage.g:219:2: rule__ALSSignatureDeclaration__NameAssignment | ||
607 | { | ||
608 | pushFollow(FOLLOW_2); | ||
609 | rule__ALSSignatureDeclaration__NameAssignment(); | ||
610 | |||
611 | state._fsp--; | ||
612 | if (state.failed) return ; | ||
613 | |||
614 | } | ||
615 | |||
616 | if ( state.backtracking==0 ) { | ||
617 | after(grammarAccess.getALSSignatureDeclarationAccess().getNameAssignment()); | ||
618 | } | ||
619 | |||
620 | } | ||
621 | |||
622 | |||
623 | } | ||
624 | |||
625 | } | ||
626 | catch (RecognitionException re) { | ||
627 | reportError(re); | ||
628 | recover(input,re); | ||
629 | } | ||
630 | finally { | ||
631 | |||
632 | restoreStackSize(stackSize); | ||
633 | |||
634 | } | ||
635 | return ; | ||
636 | } | ||
637 | // $ANTLR end "ruleALSSignatureDeclaration" | ||
638 | |||
639 | |||
640 | // $ANTLR start "entryRuleALSSignatureBody" | ||
641 | // InternalAlloyLanguage.g:231:1: entryRuleALSSignatureBody : ruleALSSignatureBody EOF ; | ||
642 | public final void entryRuleALSSignatureBody() throws RecognitionException { | ||
643 | try { | ||
644 | // InternalAlloyLanguage.g:232:1: ( ruleALSSignatureBody EOF ) | ||
645 | // InternalAlloyLanguage.g:233:1: ruleALSSignatureBody EOF | ||
646 | { | ||
647 | if ( state.backtracking==0 ) { | ||
648 | before(grammarAccess.getALSSignatureBodyRule()); | ||
649 | } | ||
650 | pushFollow(FOLLOW_1); | ||
651 | ruleALSSignatureBody(); | ||
652 | |||
653 | state._fsp--; | ||
654 | if (state.failed) return ; | ||
655 | if ( state.backtracking==0 ) { | ||
656 | after(grammarAccess.getALSSignatureBodyRule()); | ||
657 | } | ||
658 | match(input,EOF,FOLLOW_2); if (state.failed) return ; | ||
659 | |||
660 | } | ||
661 | |||
662 | } | ||
663 | catch (RecognitionException re) { | ||
664 | reportError(re); | ||
665 | recover(input,re); | ||
666 | } | ||
667 | finally { | ||
668 | } | ||
669 | return ; | ||
670 | } | ||
671 | // $ANTLR end "entryRuleALSSignatureBody" | ||
672 | |||
673 | |||
674 | // $ANTLR start "ruleALSSignatureBody" | ||
675 | // InternalAlloyLanguage.g:240:1: ruleALSSignatureBody : ( ( rule__ALSSignatureBody__Group__0 ) ) ; | ||
676 | public final void ruleALSSignatureBody() throws RecognitionException { | ||
677 | |||
678 | int stackSize = keepStackSize(); | ||
679 | |||
680 | try { | ||
681 | // InternalAlloyLanguage.g:244:2: ( ( ( rule__ALSSignatureBody__Group__0 ) ) ) | ||
682 | // InternalAlloyLanguage.g:245:1: ( ( rule__ALSSignatureBody__Group__0 ) ) | ||
683 | { | ||
684 | // InternalAlloyLanguage.g:245:1: ( ( rule__ALSSignatureBody__Group__0 ) ) | ||
685 | // InternalAlloyLanguage.g:246:1: ( rule__ALSSignatureBody__Group__0 ) | ||
686 | { | ||
687 | if ( state.backtracking==0 ) { | ||
688 | before(grammarAccess.getALSSignatureBodyAccess().getGroup()); | ||
689 | } | ||
690 | // InternalAlloyLanguage.g:247:1: ( rule__ALSSignatureBody__Group__0 ) | ||
691 | // InternalAlloyLanguage.g:247:2: rule__ALSSignatureBody__Group__0 | ||
692 | { | ||
693 | pushFollow(FOLLOW_2); | ||
694 | rule__ALSSignatureBody__Group__0(); | ||
695 | |||
696 | state._fsp--; | ||
697 | if (state.failed) return ; | ||
698 | |||
699 | } | ||
700 | |||
701 | if ( state.backtracking==0 ) { | ||
702 | after(grammarAccess.getALSSignatureBodyAccess().getGroup()); | ||
703 | } | ||
704 | |||
705 | } | ||
706 | |||
707 | |||
708 | } | ||
709 | |||
710 | } | ||
711 | catch (RecognitionException re) { | ||
712 | reportError(re); | ||
713 | recover(input,re); | ||
714 | } | ||
715 | finally { | ||
716 | |||
717 | restoreStackSize(stackSize); | ||
718 | |||
719 | } | ||
720 | return ; | ||
721 | } | ||
722 | // $ANTLR end "ruleALSSignatureBody" | ||
723 | |||
724 | |||
725 | // $ANTLR start "entryRuleALSFieldDeclaration" | ||
726 | // InternalAlloyLanguage.g:259:1: entryRuleALSFieldDeclaration : ruleALSFieldDeclaration EOF ; | ||
727 | public final void entryRuleALSFieldDeclaration() throws RecognitionException { | ||
728 | try { | ||
729 | // InternalAlloyLanguage.g:260:1: ( ruleALSFieldDeclaration EOF ) | ||
730 | // InternalAlloyLanguage.g:261:1: ruleALSFieldDeclaration EOF | ||
731 | { | ||
732 | if ( state.backtracking==0 ) { | ||
733 | before(grammarAccess.getALSFieldDeclarationRule()); | ||
734 | } | ||
735 | pushFollow(FOLLOW_1); | ||
736 | ruleALSFieldDeclaration(); | ||
737 | |||
738 | state._fsp--; | ||
739 | if (state.failed) return ; | ||
740 | if ( state.backtracking==0 ) { | ||
741 | after(grammarAccess.getALSFieldDeclarationRule()); | ||
742 | } | ||
743 | match(input,EOF,FOLLOW_2); if (state.failed) return ; | ||
744 | |||
745 | } | ||
746 | |||
747 | } | ||
748 | catch (RecognitionException re) { | ||
749 | reportError(re); | ||
750 | recover(input,re); | ||
751 | } | ||
752 | finally { | ||
753 | } | ||
754 | return ; | ||
755 | } | ||
756 | // $ANTLR end "entryRuleALSFieldDeclaration" | ||
757 | |||
758 | |||
759 | // $ANTLR start "ruleALSFieldDeclaration" | ||
760 | // InternalAlloyLanguage.g:268:1: ruleALSFieldDeclaration : ( ( rule__ALSFieldDeclaration__Group__0 ) ) ; | ||
761 | public final void ruleALSFieldDeclaration() throws RecognitionException { | ||
762 | |||
763 | int stackSize = keepStackSize(); | ||
764 | |||
765 | try { | ||
766 | // InternalAlloyLanguage.g:272:2: ( ( ( rule__ALSFieldDeclaration__Group__0 ) ) ) | ||
767 | // InternalAlloyLanguage.g:273:1: ( ( rule__ALSFieldDeclaration__Group__0 ) ) | ||
768 | { | ||
769 | // InternalAlloyLanguage.g:273:1: ( ( rule__ALSFieldDeclaration__Group__0 ) ) | ||
770 | // InternalAlloyLanguage.g:274:1: ( rule__ALSFieldDeclaration__Group__0 ) | ||
771 | { | ||
772 | if ( state.backtracking==0 ) { | ||
773 | before(grammarAccess.getALSFieldDeclarationAccess().getGroup()); | ||
774 | } | ||
775 | // InternalAlloyLanguage.g:275:1: ( rule__ALSFieldDeclaration__Group__0 ) | ||
776 | // InternalAlloyLanguage.g:275:2: rule__ALSFieldDeclaration__Group__0 | ||
777 | { | ||
778 | pushFollow(FOLLOW_2); | ||
779 | rule__ALSFieldDeclaration__Group__0(); | ||
780 | |||
781 | state._fsp--; | ||
782 | if (state.failed) return ; | ||
783 | |||
784 | } | ||
785 | |||
786 | if ( state.backtracking==0 ) { | ||
787 | after(grammarAccess.getALSFieldDeclarationAccess().getGroup()); | ||
788 | } | ||
789 | |||
790 | } | ||
791 | |||
792 | |||
793 | } | ||
794 | |||
795 | } | ||
796 | catch (RecognitionException re) { | ||
797 | reportError(re); | ||
798 | recover(input,re); | ||
799 | } | ||
800 | finally { | ||
801 | |||
802 | restoreStackSize(stackSize); | ||
803 | |||
804 | } | ||
805 | return ; | ||
806 | } | ||
807 | // $ANTLR end "ruleALSFieldDeclaration" | ||
808 | |||
809 | |||
810 | // $ANTLR start "entryRuleALSFunctionDefinition" | ||
811 | // InternalAlloyLanguage.g:289:1: entryRuleALSFunctionDefinition : ruleALSFunctionDefinition EOF ; | ||
812 | public final void entryRuleALSFunctionDefinition() throws RecognitionException { | ||
813 | try { | ||
814 | // InternalAlloyLanguage.g:290:1: ( ruleALSFunctionDefinition EOF ) | ||
815 | // InternalAlloyLanguage.g:291:1: ruleALSFunctionDefinition EOF | ||
816 | { | ||
817 | if ( state.backtracking==0 ) { | ||
818 | before(grammarAccess.getALSFunctionDefinitionRule()); | ||
819 | } | ||
820 | pushFollow(FOLLOW_1); | ||
821 | ruleALSFunctionDefinition(); | ||
822 | |||
823 | state._fsp--; | ||
824 | if (state.failed) return ; | ||
825 | if ( state.backtracking==0 ) { | ||
826 | after(grammarAccess.getALSFunctionDefinitionRule()); | ||
827 | } | ||
828 | match(input,EOF,FOLLOW_2); if (state.failed) return ; | ||
829 | |||
830 | } | ||
831 | |||
832 | } | ||
833 | catch (RecognitionException re) { | ||
834 | reportError(re); | ||
835 | recover(input,re); | ||
836 | } | ||
837 | finally { | ||
838 | } | ||
839 | return ; | ||
840 | } | ||
841 | // $ANTLR end "entryRuleALSFunctionDefinition" | ||
842 | |||
843 | |||
844 | // $ANTLR start "ruleALSFunctionDefinition" | ||
845 | // InternalAlloyLanguage.g:298:1: ruleALSFunctionDefinition : ( ( rule__ALSFunctionDefinition__Group__0 ) ) ; | ||
846 | public final void ruleALSFunctionDefinition() throws RecognitionException { | ||
847 | |||
848 | int stackSize = keepStackSize(); | ||
849 | |||
850 | try { | ||
851 | // InternalAlloyLanguage.g:302:2: ( ( ( rule__ALSFunctionDefinition__Group__0 ) ) ) | ||
852 | // InternalAlloyLanguage.g:303:1: ( ( rule__ALSFunctionDefinition__Group__0 ) ) | ||
853 | { | ||
854 | // InternalAlloyLanguage.g:303:1: ( ( rule__ALSFunctionDefinition__Group__0 ) ) | ||
855 | // InternalAlloyLanguage.g:304:1: ( rule__ALSFunctionDefinition__Group__0 ) | ||
856 | { | ||
857 | if ( state.backtracking==0 ) { | ||
858 | before(grammarAccess.getALSFunctionDefinitionAccess().getGroup()); | ||
859 | } | ||
860 | // InternalAlloyLanguage.g:305:1: ( rule__ALSFunctionDefinition__Group__0 ) | ||
861 | // InternalAlloyLanguage.g:305:2: rule__ALSFunctionDefinition__Group__0 | ||
862 | { | ||
863 | pushFollow(FOLLOW_2); | ||
864 | rule__ALSFunctionDefinition__Group__0(); | ||
865 | |||
866 | state._fsp--; | ||
867 | if (state.failed) return ; | ||
868 | |||
869 | } | ||
870 | |||
871 | if ( state.backtracking==0 ) { | ||
872 | after(grammarAccess.getALSFunctionDefinitionAccess().getGroup()); | ||
873 | } | ||
874 | |||
875 | } | ||
876 | |||
877 | |||
878 | } | ||
879 | |||
880 | } | ||
881 | catch (RecognitionException re) { | ||
882 | reportError(re); | ||
883 | recover(input,re); | ||
884 | } | ||
885 | finally { | ||
886 | |||
887 | restoreStackSize(stackSize); | ||
888 | |||
889 | } | ||
890 | return ; | ||
891 | } | ||
892 | // $ANTLR end "ruleALSFunctionDefinition" | ||
893 | |||
894 | |||
895 | // $ANTLR start "entryRuleALSRelationDefinition" | ||
896 | // InternalAlloyLanguage.g:317:1: entryRuleALSRelationDefinition : ruleALSRelationDefinition EOF ; | ||
897 | public final void entryRuleALSRelationDefinition() throws RecognitionException { | ||
898 | try { | ||
899 | // InternalAlloyLanguage.g:318:1: ( ruleALSRelationDefinition EOF ) | ||
900 | // InternalAlloyLanguage.g:319:1: ruleALSRelationDefinition EOF | ||
901 | { | ||
902 | if ( state.backtracking==0 ) { | ||
903 | before(grammarAccess.getALSRelationDefinitionRule()); | ||
904 | } | ||
905 | pushFollow(FOLLOW_1); | ||
906 | ruleALSRelationDefinition(); | ||
907 | |||
908 | state._fsp--; | ||
909 | if (state.failed) return ; | ||
910 | if ( state.backtracking==0 ) { | ||
911 | after(grammarAccess.getALSRelationDefinitionRule()); | ||
912 | } | ||
913 | match(input,EOF,FOLLOW_2); if (state.failed) return ; | ||
914 | |||
915 | } | ||
916 | |||
917 | } | ||
918 | catch (RecognitionException re) { | ||
919 | reportError(re); | ||
920 | recover(input,re); | ||
921 | } | ||
922 | finally { | ||
923 | } | ||
924 | return ; | ||
925 | } | ||
926 | // $ANTLR end "entryRuleALSRelationDefinition" | ||
927 | |||
928 | |||
929 | // $ANTLR start "ruleALSRelationDefinition" | ||
930 | // InternalAlloyLanguage.g:326:1: ruleALSRelationDefinition : ( ( rule__ALSRelationDefinition__Group__0 ) ) ; | ||
931 | public final void ruleALSRelationDefinition() throws RecognitionException { | ||
932 | |||
933 | int stackSize = keepStackSize(); | ||
934 | |||
935 | try { | ||
936 | // InternalAlloyLanguage.g:330:2: ( ( ( rule__ALSRelationDefinition__Group__0 ) ) ) | ||
937 | // InternalAlloyLanguage.g:331:1: ( ( rule__ALSRelationDefinition__Group__0 ) ) | ||
938 | { | ||
939 | // InternalAlloyLanguage.g:331:1: ( ( rule__ALSRelationDefinition__Group__0 ) ) | ||
940 | // InternalAlloyLanguage.g:332:1: ( rule__ALSRelationDefinition__Group__0 ) | ||
941 | { | ||
942 | if ( state.backtracking==0 ) { | ||
943 | before(grammarAccess.getALSRelationDefinitionAccess().getGroup()); | ||
944 | } | ||
945 | // InternalAlloyLanguage.g:333:1: ( rule__ALSRelationDefinition__Group__0 ) | ||
946 | // InternalAlloyLanguage.g:333:2: rule__ALSRelationDefinition__Group__0 | ||
947 | { | ||
948 | pushFollow(FOLLOW_2); | ||
949 | rule__ALSRelationDefinition__Group__0(); | ||
950 | |||
951 | state._fsp--; | ||
952 | if (state.failed) return ; | ||
953 | |||
954 | } | ||
955 | |||
956 | if ( state.backtracking==0 ) { | ||
957 | after(grammarAccess.getALSRelationDefinitionAccess().getGroup()); | ||
958 | } | ||
959 | |||
960 | } | ||
961 | |||
962 | |||
963 | } | ||
964 | |||
965 | } | ||
966 | catch (RecognitionException re) { | ||
967 | reportError(re); | ||
968 | recover(input,re); | ||
969 | } | ||
970 | finally { | ||
971 | |||
972 | restoreStackSize(stackSize); | ||
973 | |||
974 | } | ||
975 | return ; | ||
976 | } | ||
977 | // $ANTLR end "ruleALSRelationDefinition" | ||
978 | |||
979 | |||
980 | // $ANTLR start "entryRuleALSFactDeclaration" | ||
981 | // InternalAlloyLanguage.g:345:1: entryRuleALSFactDeclaration : ruleALSFactDeclaration EOF ; | ||
982 | public final void entryRuleALSFactDeclaration() throws RecognitionException { | ||
983 | try { | ||
984 | // InternalAlloyLanguage.g:346:1: ( ruleALSFactDeclaration EOF ) | ||
985 | // InternalAlloyLanguage.g:347:1: ruleALSFactDeclaration EOF | ||
986 | { | ||
987 | if ( state.backtracking==0 ) { | ||
988 | before(grammarAccess.getALSFactDeclarationRule()); | ||
989 | } | ||
990 | pushFollow(FOLLOW_1); | ||
991 | ruleALSFactDeclaration(); | ||
992 | |||
993 | state._fsp--; | ||
994 | if (state.failed) return ; | ||
995 | if ( state.backtracking==0 ) { | ||
996 | after(grammarAccess.getALSFactDeclarationRule()); | ||
997 | } | ||
998 | match(input,EOF,FOLLOW_2); if (state.failed) return ; | ||
999 | |||
1000 | } | ||
1001 | |||
1002 | } | ||
1003 | catch (RecognitionException re) { | ||
1004 | reportError(re); | ||
1005 | recover(input,re); | ||
1006 | } | ||
1007 | finally { | ||
1008 | } | ||
1009 | return ; | ||
1010 | } | ||
1011 | // $ANTLR end "entryRuleALSFactDeclaration" | ||
1012 | |||
1013 | |||
1014 | // $ANTLR start "ruleALSFactDeclaration" | ||
1015 | // InternalAlloyLanguage.g:354:1: ruleALSFactDeclaration : ( ( rule__ALSFactDeclaration__Group__0 ) ) ; | ||
1016 | public final void ruleALSFactDeclaration() throws RecognitionException { | ||
1017 | |||
1018 | int stackSize = keepStackSize(); | ||
1019 | |||
1020 | try { | ||
1021 | // InternalAlloyLanguage.g:358:2: ( ( ( rule__ALSFactDeclaration__Group__0 ) ) ) | ||
1022 | // InternalAlloyLanguage.g:359:1: ( ( rule__ALSFactDeclaration__Group__0 ) ) | ||
1023 | { | ||
1024 | // InternalAlloyLanguage.g:359:1: ( ( rule__ALSFactDeclaration__Group__0 ) ) | ||
1025 | // InternalAlloyLanguage.g:360:1: ( rule__ALSFactDeclaration__Group__0 ) | ||
1026 | { | ||
1027 | if ( state.backtracking==0 ) { | ||
1028 | before(grammarAccess.getALSFactDeclarationAccess().getGroup()); | ||
1029 | } | ||
1030 | // InternalAlloyLanguage.g:361:1: ( rule__ALSFactDeclaration__Group__0 ) | ||
1031 | // InternalAlloyLanguage.g:361:2: rule__ALSFactDeclaration__Group__0 | ||
1032 | { | ||
1033 | pushFollow(FOLLOW_2); | ||
1034 | rule__ALSFactDeclaration__Group__0(); | ||
1035 | |||
1036 | state._fsp--; | ||
1037 | if (state.failed) return ; | ||
1038 | |||
1039 | } | ||
1040 | |||
1041 | if ( state.backtracking==0 ) { | ||
1042 | after(grammarAccess.getALSFactDeclarationAccess().getGroup()); | ||
1043 | } | ||
1044 | |||
1045 | } | ||
1046 | |||
1047 | |||
1048 | } | ||
1049 | |||
1050 | } | ||
1051 | catch (RecognitionException re) { | ||
1052 | reportError(re); | ||
1053 | recover(input,re); | ||
1054 | } | ||
1055 | finally { | ||
1056 | |||
1057 | restoreStackSize(stackSize); | ||
1058 | |||
1059 | } | ||
1060 | return ; | ||
1061 | } | ||
1062 | // $ANTLR end "ruleALSFactDeclaration" | ||
1063 | |||
1064 | |||
1065 | // $ANTLR start "entryRuleALSTerm" | ||
1066 | // InternalAlloyLanguage.g:373:1: entryRuleALSTerm : ruleALSTerm EOF ; | ||
1067 | public final void entryRuleALSTerm() throws RecognitionException { | ||
1068 | try { | ||
1069 | // InternalAlloyLanguage.g:374:1: ( ruleALSTerm EOF ) | ||
1070 | // InternalAlloyLanguage.g:375:1: ruleALSTerm EOF | ||
1071 | { | ||
1072 | if ( state.backtracking==0 ) { | ||
1073 | before(grammarAccess.getALSTermRule()); | ||
1074 | } | ||
1075 | pushFollow(FOLLOW_1); | ||
1076 | ruleALSTerm(); | ||
1077 | |||
1078 | state._fsp--; | ||
1079 | if (state.failed) return ; | ||
1080 | if ( state.backtracking==0 ) { | ||
1081 | after(grammarAccess.getALSTermRule()); | ||
1082 | } | ||
1083 | match(input,EOF,FOLLOW_2); if (state.failed) return ; | ||
1084 | |||
1085 | } | ||
1086 | |||
1087 | } | ||
1088 | catch (RecognitionException re) { | ||
1089 | reportError(re); | ||
1090 | recover(input,re); | ||
1091 | } | ||
1092 | finally { | ||
1093 | } | ||
1094 | return ; | ||
1095 | } | ||
1096 | // $ANTLR end "entryRuleALSTerm" | ||
1097 | |||
1098 | |||
1099 | // $ANTLR start "ruleALSTerm" | ||
1100 | // InternalAlloyLanguage.g:382:1: ruleALSTerm : ( ruleALSQuantified ) ; | ||
1101 | public final void ruleALSTerm() throws RecognitionException { | ||
1102 | |||
1103 | int stackSize = keepStackSize(); | ||
1104 | |||
1105 | try { | ||
1106 | // InternalAlloyLanguage.g:386:2: ( ( ruleALSQuantified ) ) | ||
1107 | // InternalAlloyLanguage.g:387:1: ( ruleALSQuantified ) | ||
1108 | { | ||
1109 | // InternalAlloyLanguage.g:387:1: ( ruleALSQuantified ) | ||
1110 | // InternalAlloyLanguage.g:388:1: ruleALSQuantified | ||
1111 | { | ||
1112 | if ( state.backtracking==0 ) { | ||
1113 | before(grammarAccess.getALSTermAccess().getALSQuantifiedParserRuleCall()); | ||
1114 | } | ||
1115 | pushFollow(FOLLOW_2); | ||
1116 | ruleALSQuantified(); | ||
1117 | |||
1118 | state._fsp--; | ||
1119 | if (state.failed) return ; | ||
1120 | if ( state.backtracking==0 ) { | ||
1121 | after(grammarAccess.getALSTermAccess().getALSQuantifiedParserRuleCall()); | ||
1122 | } | ||
1123 | |||
1124 | } | ||
1125 | |||
1126 | |||
1127 | } | ||
1128 | |||
1129 | } | ||
1130 | catch (RecognitionException re) { | ||
1131 | reportError(re); | ||
1132 | recover(input,re); | ||
1133 | } | ||
1134 | finally { | ||
1135 | |||
1136 | restoreStackSize(stackSize); | ||
1137 | |||
1138 | } | ||
1139 | return ; | ||
1140 | } | ||
1141 | // $ANTLR end "ruleALSTerm" | ||
1142 | |||
1143 | |||
1144 | // $ANTLR start "entryRuleALSQuantified" | ||
1145 | // InternalAlloyLanguage.g:401:1: entryRuleALSQuantified : ruleALSQuantified EOF ; | ||
1146 | public final void entryRuleALSQuantified() throws RecognitionException { | ||
1147 | try { | ||
1148 | // InternalAlloyLanguage.g:402:1: ( ruleALSQuantified EOF ) | ||
1149 | // InternalAlloyLanguage.g:403:1: ruleALSQuantified EOF | ||
1150 | { | ||
1151 | if ( state.backtracking==0 ) { | ||
1152 | before(grammarAccess.getALSQuantifiedRule()); | ||
1153 | } | ||
1154 | pushFollow(FOLLOW_1); | ||
1155 | ruleALSQuantified(); | ||
1156 | |||
1157 | state._fsp--; | ||
1158 | if (state.failed) return ; | ||
1159 | if ( state.backtracking==0 ) { | ||
1160 | after(grammarAccess.getALSQuantifiedRule()); | ||
1161 | } | ||
1162 | match(input,EOF,FOLLOW_2); if (state.failed) return ; | ||
1163 | |||
1164 | } | ||
1165 | |||
1166 | } | ||
1167 | catch (RecognitionException re) { | ||
1168 | reportError(re); | ||
1169 | recover(input,re); | ||
1170 | } | ||
1171 | finally { | ||
1172 | } | ||
1173 | return ; | ||
1174 | } | ||
1175 | // $ANTLR end "entryRuleALSQuantified" | ||
1176 | |||
1177 | |||
1178 | // $ANTLR start "ruleALSQuantified" | ||
1179 | // InternalAlloyLanguage.g:410:1: ruleALSQuantified : ( ( rule__ALSQuantified__Alternatives ) ) ; | ||
1180 | public final void ruleALSQuantified() throws RecognitionException { | ||
1181 | |||
1182 | int stackSize = keepStackSize(); | ||
1183 | |||
1184 | try { | ||
1185 | // InternalAlloyLanguage.g:414:2: ( ( ( rule__ALSQuantified__Alternatives ) ) ) | ||
1186 | // InternalAlloyLanguage.g:415:1: ( ( rule__ALSQuantified__Alternatives ) ) | ||
1187 | { | ||
1188 | // InternalAlloyLanguage.g:415:1: ( ( rule__ALSQuantified__Alternatives ) ) | ||
1189 | // InternalAlloyLanguage.g:416:1: ( rule__ALSQuantified__Alternatives ) | ||
1190 | { | ||
1191 | if ( state.backtracking==0 ) { | ||
1192 | before(grammarAccess.getALSQuantifiedAccess().getAlternatives()); | ||
1193 | } | ||
1194 | // InternalAlloyLanguage.g:417:1: ( rule__ALSQuantified__Alternatives ) | ||
1195 | // InternalAlloyLanguage.g:417:2: rule__ALSQuantified__Alternatives | ||
1196 | { | ||
1197 | pushFollow(FOLLOW_2); | ||
1198 | rule__ALSQuantified__Alternatives(); | ||
1199 | |||
1200 | state._fsp--; | ||
1201 | if (state.failed) return ; | ||
1202 | |||
1203 | } | ||
1204 | |||
1205 | if ( state.backtracking==0 ) { | ||
1206 | after(grammarAccess.getALSQuantifiedAccess().getAlternatives()); | ||
1207 | } | ||
1208 | |||
1209 | } | ||
1210 | |||
1211 | |||
1212 | } | ||
1213 | |||
1214 | } | ||
1215 | catch (RecognitionException re) { | ||
1216 | reportError(re); | ||
1217 | recover(input,re); | ||
1218 | } | ||
1219 | finally { | ||
1220 | |||
1221 | restoreStackSize(stackSize); | ||
1222 | |||
1223 | } | ||
1224 | return ; | ||
1225 | } | ||
1226 | // $ANTLR end "ruleALSQuantified" | ||
1227 | |||
1228 | |||
1229 | // $ANTLR start "entryRuleALSOr" | ||
1230 | // InternalAlloyLanguage.g:429:1: entryRuleALSOr : ruleALSOr EOF ; | ||
1231 | public final void entryRuleALSOr() throws RecognitionException { | ||
1232 | try { | ||
1233 | // InternalAlloyLanguage.g:430:1: ( ruleALSOr EOF ) | ||
1234 | // InternalAlloyLanguage.g:431:1: ruleALSOr EOF | ||
1235 | { | ||
1236 | if ( state.backtracking==0 ) { | ||
1237 | before(grammarAccess.getALSOrRule()); | ||
1238 | } | ||
1239 | pushFollow(FOLLOW_1); | ||
1240 | ruleALSOr(); | ||
1241 | |||
1242 | state._fsp--; | ||
1243 | if (state.failed) return ; | ||
1244 | if ( state.backtracking==0 ) { | ||
1245 | after(grammarAccess.getALSOrRule()); | ||
1246 | } | ||
1247 | match(input,EOF,FOLLOW_2); if (state.failed) return ; | ||
1248 | |||
1249 | } | ||
1250 | |||
1251 | } | ||
1252 | catch (RecognitionException re) { | ||
1253 | reportError(re); | ||
1254 | recover(input,re); | ||
1255 | } | ||
1256 | finally { | ||
1257 | } | ||
1258 | return ; | ||
1259 | } | ||
1260 | // $ANTLR end "entryRuleALSOr" | ||
1261 | |||
1262 | |||
1263 | // $ANTLR start "ruleALSOr" | ||
1264 | // InternalAlloyLanguage.g:438:1: ruleALSOr : ( ( rule__ALSOr__Group__0 ) ) ; | ||
1265 | public final void ruleALSOr() throws RecognitionException { | ||
1266 | |||
1267 | int stackSize = keepStackSize(); | ||
1268 | |||
1269 | try { | ||
1270 | // InternalAlloyLanguage.g:442:2: ( ( ( rule__ALSOr__Group__0 ) ) ) | ||
1271 | // InternalAlloyLanguage.g:443:1: ( ( rule__ALSOr__Group__0 ) ) | ||
1272 | { | ||
1273 | // InternalAlloyLanguage.g:443:1: ( ( rule__ALSOr__Group__0 ) ) | ||
1274 | // InternalAlloyLanguage.g:444:1: ( rule__ALSOr__Group__0 ) | ||
1275 | { | ||
1276 | if ( state.backtracking==0 ) { | ||
1277 | before(grammarAccess.getALSOrAccess().getGroup()); | ||
1278 | } | ||
1279 | // InternalAlloyLanguage.g:445:1: ( rule__ALSOr__Group__0 ) | ||
1280 | // InternalAlloyLanguage.g:445:2: rule__ALSOr__Group__0 | ||
1281 | { | ||
1282 | pushFollow(FOLLOW_2); | ||
1283 | rule__ALSOr__Group__0(); | ||
1284 | |||
1285 | state._fsp--; | ||
1286 | if (state.failed) return ; | ||
1287 | |||
1288 | } | ||
1289 | |||
1290 | if ( state.backtracking==0 ) { | ||
1291 | after(grammarAccess.getALSOrAccess().getGroup()); | ||
1292 | } | ||
1293 | |||
1294 | } | ||
1295 | |||
1296 | |||
1297 | } | ||
1298 | |||
1299 | } | ||
1300 | catch (RecognitionException re) { | ||
1301 | reportError(re); | ||
1302 | recover(input,re); | ||
1303 | } | ||
1304 | finally { | ||
1305 | |||
1306 | restoreStackSize(stackSize); | ||
1307 | |||
1308 | } | ||
1309 | return ; | ||
1310 | } | ||
1311 | // $ANTLR end "ruleALSOr" | ||
1312 | |||
1313 | |||
1314 | // $ANTLR start "entryRuleALSIff" | ||
1315 | // InternalAlloyLanguage.g:457:1: entryRuleALSIff : ruleALSIff EOF ; | ||
1316 | public final void entryRuleALSIff() throws RecognitionException { | ||
1317 | try { | ||
1318 | // InternalAlloyLanguage.g:458:1: ( ruleALSIff EOF ) | ||
1319 | // InternalAlloyLanguage.g:459:1: ruleALSIff EOF | ||
1320 | { | ||
1321 | if ( state.backtracking==0 ) { | ||
1322 | before(grammarAccess.getALSIffRule()); | ||
1323 | } | ||
1324 | pushFollow(FOLLOW_1); | ||
1325 | ruleALSIff(); | ||
1326 | |||
1327 | state._fsp--; | ||
1328 | if (state.failed) return ; | ||
1329 | if ( state.backtracking==0 ) { | ||
1330 | after(grammarAccess.getALSIffRule()); | ||
1331 | } | ||
1332 | match(input,EOF,FOLLOW_2); if (state.failed) return ; | ||
1333 | |||
1334 | } | ||
1335 | |||
1336 | } | ||
1337 | catch (RecognitionException re) { | ||
1338 | reportError(re); | ||
1339 | recover(input,re); | ||
1340 | } | ||
1341 | finally { | ||
1342 | } | ||
1343 | return ; | ||
1344 | } | ||
1345 | // $ANTLR end "entryRuleALSIff" | ||
1346 | |||
1347 | |||
1348 | // $ANTLR start "ruleALSIff" | ||
1349 | // InternalAlloyLanguage.g:466:1: ruleALSIff : ( ( rule__ALSIff__Group__0 ) ) ; | ||
1350 | public final void ruleALSIff() throws RecognitionException { | ||
1351 | |||
1352 | int stackSize = keepStackSize(); | ||
1353 | |||
1354 | try { | ||
1355 | // InternalAlloyLanguage.g:470:2: ( ( ( rule__ALSIff__Group__0 ) ) ) | ||
1356 | // InternalAlloyLanguage.g:471:1: ( ( rule__ALSIff__Group__0 ) ) | ||
1357 | { | ||
1358 | // InternalAlloyLanguage.g:471:1: ( ( rule__ALSIff__Group__0 ) ) | ||
1359 | // InternalAlloyLanguage.g:472:1: ( rule__ALSIff__Group__0 ) | ||
1360 | { | ||
1361 | if ( state.backtracking==0 ) { | ||
1362 | before(grammarAccess.getALSIffAccess().getGroup()); | ||
1363 | } | ||
1364 | // InternalAlloyLanguage.g:473:1: ( rule__ALSIff__Group__0 ) | ||
1365 | // InternalAlloyLanguage.g:473:2: rule__ALSIff__Group__0 | ||
1366 | { | ||
1367 | pushFollow(FOLLOW_2); | ||
1368 | rule__ALSIff__Group__0(); | ||
1369 | |||
1370 | state._fsp--; | ||
1371 | if (state.failed) return ; | ||
1372 | |||
1373 | } | ||
1374 | |||
1375 | if ( state.backtracking==0 ) { | ||
1376 | after(grammarAccess.getALSIffAccess().getGroup()); | ||
1377 | } | ||
1378 | |||
1379 | } | ||
1380 | |||
1381 | |||
1382 | } | ||
1383 | |||
1384 | } | ||
1385 | catch (RecognitionException re) { | ||
1386 | reportError(re); | ||
1387 | recover(input,re); | ||
1388 | } | ||
1389 | finally { | ||
1390 | |||
1391 | restoreStackSize(stackSize); | ||
1392 | |||
1393 | } | ||
1394 | return ; | ||
1395 | } | ||
1396 | // $ANTLR end "ruleALSIff" | ||
1397 | |||
1398 | |||
1399 | // $ANTLR start "entryRuleALSImpl" | ||
1400 | // InternalAlloyLanguage.g:485:1: entryRuleALSImpl : ruleALSImpl EOF ; | ||
1401 | public final void entryRuleALSImpl() throws RecognitionException { | ||
1402 | try { | ||
1403 | // InternalAlloyLanguage.g:486:1: ( ruleALSImpl EOF ) | ||
1404 | // InternalAlloyLanguage.g:487:1: ruleALSImpl EOF | ||
1405 | { | ||
1406 | if ( state.backtracking==0 ) { | ||
1407 | before(grammarAccess.getALSImplRule()); | ||
1408 | } | ||
1409 | pushFollow(FOLLOW_1); | ||
1410 | ruleALSImpl(); | ||
1411 | |||
1412 | state._fsp--; | ||
1413 | if (state.failed) return ; | ||
1414 | if ( state.backtracking==0 ) { | ||
1415 | after(grammarAccess.getALSImplRule()); | ||
1416 | } | ||
1417 | match(input,EOF,FOLLOW_2); if (state.failed) return ; | ||
1418 | |||
1419 | } | ||
1420 | |||
1421 | } | ||
1422 | catch (RecognitionException re) { | ||
1423 | reportError(re); | ||
1424 | recover(input,re); | ||
1425 | } | ||
1426 | finally { | ||
1427 | } | ||
1428 | return ; | ||
1429 | } | ||
1430 | // $ANTLR end "entryRuleALSImpl" | ||
1431 | |||
1432 | |||
1433 | // $ANTLR start "ruleALSImpl" | ||
1434 | // InternalAlloyLanguage.g:494:1: ruleALSImpl : ( ( rule__ALSImpl__Group__0 ) ) ; | ||
1435 | public final void ruleALSImpl() throws RecognitionException { | ||
1436 | |||
1437 | int stackSize = keepStackSize(); | ||
1438 | |||
1439 | try { | ||
1440 | // InternalAlloyLanguage.g:498:2: ( ( ( rule__ALSImpl__Group__0 ) ) ) | ||
1441 | // InternalAlloyLanguage.g:499:1: ( ( rule__ALSImpl__Group__0 ) ) | ||
1442 | { | ||
1443 | // InternalAlloyLanguage.g:499:1: ( ( rule__ALSImpl__Group__0 ) ) | ||
1444 | // InternalAlloyLanguage.g:500:1: ( rule__ALSImpl__Group__0 ) | ||
1445 | { | ||
1446 | if ( state.backtracking==0 ) { | ||
1447 | before(grammarAccess.getALSImplAccess().getGroup()); | ||
1448 | } | ||
1449 | // InternalAlloyLanguage.g:501:1: ( rule__ALSImpl__Group__0 ) | ||
1450 | // InternalAlloyLanguage.g:501:2: rule__ALSImpl__Group__0 | ||
1451 | { | ||
1452 | pushFollow(FOLLOW_2); | ||
1453 | rule__ALSImpl__Group__0(); | ||
1454 | |||
1455 | state._fsp--; | ||
1456 | if (state.failed) return ; | ||
1457 | |||
1458 | } | ||
1459 | |||
1460 | if ( state.backtracking==0 ) { | ||
1461 | after(grammarAccess.getALSImplAccess().getGroup()); | ||
1462 | } | ||
1463 | |||
1464 | } | ||
1465 | |||
1466 | |||
1467 | } | ||
1468 | |||
1469 | } | ||
1470 | catch (RecognitionException re) { | ||
1471 | reportError(re); | ||
1472 | recover(input,re); | ||
1473 | } | ||
1474 | finally { | ||
1475 | |||
1476 | restoreStackSize(stackSize); | ||
1477 | |||
1478 | } | ||
1479 | return ; | ||
1480 | } | ||
1481 | // $ANTLR end "ruleALSImpl" | ||
1482 | |||
1483 | |||
1484 | // $ANTLR start "entryRuleALSAnd" | ||
1485 | // InternalAlloyLanguage.g:513:1: entryRuleALSAnd : ruleALSAnd EOF ; | ||
1486 | public final void entryRuleALSAnd() throws RecognitionException { | ||
1487 | try { | ||
1488 | // InternalAlloyLanguage.g:514:1: ( ruleALSAnd EOF ) | ||
1489 | // InternalAlloyLanguage.g:515:1: ruleALSAnd EOF | ||
1490 | { | ||
1491 | if ( state.backtracking==0 ) { | ||
1492 | before(grammarAccess.getALSAndRule()); | ||
1493 | } | ||
1494 | pushFollow(FOLLOW_1); | ||
1495 | ruleALSAnd(); | ||
1496 | |||
1497 | state._fsp--; | ||
1498 | if (state.failed) return ; | ||
1499 | if ( state.backtracking==0 ) { | ||
1500 | after(grammarAccess.getALSAndRule()); | ||
1501 | } | ||
1502 | match(input,EOF,FOLLOW_2); if (state.failed) return ; | ||
1503 | |||
1504 | } | ||
1505 | |||
1506 | } | ||
1507 | catch (RecognitionException re) { | ||
1508 | reportError(re); | ||
1509 | recover(input,re); | ||
1510 | } | ||
1511 | finally { | ||
1512 | } | ||
1513 | return ; | ||
1514 | } | ||
1515 | // $ANTLR end "entryRuleALSAnd" | ||
1516 | |||
1517 | |||
1518 | // $ANTLR start "ruleALSAnd" | ||
1519 | // InternalAlloyLanguage.g:522:1: ruleALSAnd : ( ( rule__ALSAnd__Group__0 ) ) ; | ||
1520 | public final void ruleALSAnd() throws RecognitionException { | ||
1521 | |||
1522 | int stackSize = keepStackSize(); | ||
1523 | |||
1524 | try { | ||
1525 | // InternalAlloyLanguage.g:526:2: ( ( ( rule__ALSAnd__Group__0 ) ) ) | ||
1526 | // InternalAlloyLanguage.g:527:1: ( ( rule__ALSAnd__Group__0 ) ) | ||
1527 | { | ||
1528 | // InternalAlloyLanguage.g:527:1: ( ( rule__ALSAnd__Group__0 ) ) | ||
1529 | // InternalAlloyLanguage.g:528:1: ( rule__ALSAnd__Group__0 ) | ||
1530 | { | ||
1531 | if ( state.backtracking==0 ) { | ||
1532 | before(grammarAccess.getALSAndAccess().getGroup()); | ||
1533 | } | ||
1534 | // InternalAlloyLanguage.g:529:1: ( rule__ALSAnd__Group__0 ) | ||
1535 | // InternalAlloyLanguage.g:529:2: rule__ALSAnd__Group__0 | ||
1536 | { | ||
1537 | pushFollow(FOLLOW_2); | ||
1538 | rule__ALSAnd__Group__0(); | ||
1539 | |||
1540 | state._fsp--; | ||
1541 | if (state.failed) return ; | ||
1542 | |||
1543 | } | ||
1544 | |||
1545 | if ( state.backtracking==0 ) { | ||
1546 | after(grammarAccess.getALSAndAccess().getGroup()); | ||
1547 | } | ||
1548 | |||
1549 | } | ||
1550 | |||
1551 | |||
1552 | } | ||
1553 | |||
1554 | } | ||
1555 | catch (RecognitionException re) { | ||
1556 | reportError(re); | ||
1557 | recover(input,re); | ||
1558 | } | ||
1559 | finally { | ||
1560 | |||
1561 | restoreStackSize(stackSize); | ||
1562 | |||
1563 | } | ||
1564 | return ; | ||
1565 | } | ||
1566 | // $ANTLR end "ruleALSAnd" | ||
1567 | |||
1568 | |||
1569 | // $ANTLR start "entryRuleALSComparison" | ||
1570 | // InternalAlloyLanguage.g:541:1: entryRuleALSComparison : ruleALSComparison EOF ; | ||
1571 | public final void entryRuleALSComparison() throws RecognitionException { | ||
1572 | try { | ||
1573 | // InternalAlloyLanguage.g:542:1: ( ruleALSComparison EOF ) | ||
1574 | // InternalAlloyLanguage.g:543:1: ruleALSComparison EOF | ||
1575 | { | ||
1576 | if ( state.backtracking==0 ) { | ||
1577 | before(grammarAccess.getALSComparisonRule()); | ||
1578 | } | ||
1579 | pushFollow(FOLLOW_1); | ||
1580 | ruleALSComparison(); | ||
1581 | |||
1582 | state._fsp--; | ||
1583 | if (state.failed) return ; | ||
1584 | if ( state.backtracking==0 ) { | ||
1585 | after(grammarAccess.getALSComparisonRule()); | ||
1586 | } | ||
1587 | match(input,EOF,FOLLOW_2); if (state.failed) return ; | ||
1588 | |||
1589 | } | ||
1590 | |||
1591 | } | ||
1592 | catch (RecognitionException re) { | ||
1593 | reportError(re); | ||
1594 | recover(input,re); | ||
1595 | } | ||
1596 | finally { | ||
1597 | } | ||
1598 | return ; | ||
1599 | } | ||
1600 | // $ANTLR end "entryRuleALSComparison" | ||
1601 | |||
1602 | |||
1603 | // $ANTLR start "ruleALSComparison" | ||
1604 | // InternalAlloyLanguage.g:550:1: ruleALSComparison : ( ( rule__ALSComparison__Group__0 ) ) ; | ||
1605 | public final void ruleALSComparison() throws RecognitionException { | ||
1606 | |||
1607 | int stackSize = keepStackSize(); | ||
1608 | |||
1609 | try { | ||
1610 | // InternalAlloyLanguage.g:554:2: ( ( ( rule__ALSComparison__Group__0 ) ) ) | ||
1611 | // InternalAlloyLanguage.g:555:1: ( ( rule__ALSComparison__Group__0 ) ) | ||
1612 | { | ||
1613 | // InternalAlloyLanguage.g:555:1: ( ( rule__ALSComparison__Group__0 ) ) | ||
1614 | // InternalAlloyLanguage.g:556:1: ( rule__ALSComparison__Group__0 ) | ||
1615 | { | ||
1616 | if ( state.backtracking==0 ) { | ||
1617 | before(grammarAccess.getALSComparisonAccess().getGroup()); | ||
1618 | } | ||
1619 | // InternalAlloyLanguage.g:557:1: ( rule__ALSComparison__Group__0 ) | ||
1620 | // InternalAlloyLanguage.g:557:2: rule__ALSComparison__Group__0 | ||
1621 | { | ||
1622 | pushFollow(FOLLOW_2); | ||
1623 | rule__ALSComparison__Group__0(); | ||
1624 | |||
1625 | state._fsp--; | ||
1626 | if (state.failed) return ; | ||
1627 | |||
1628 | } | ||
1629 | |||
1630 | if ( state.backtracking==0 ) { | ||
1631 | after(grammarAccess.getALSComparisonAccess().getGroup()); | ||
1632 | } | ||
1633 | |||
1634 | } | ||
1635 | |||
1636 | |||
1637 | } | ||
1638 | |||
1639 | } | ||
1640 | catch (RecognitionException re) { | ||
1641 | reportError(re); | ||
1642 | recover(input,re); | ||
1643 | } | ||
1644 | finally { | ||
1645 | |||
1646 | restoreStackSize(stackSize); | ||
1647 | |||
1648 | } | ||
1649 | return ; | ||
1650 | } | ||
1651 | // $ANTLR end "ruleALSComparison" | ||
1652 | |||
1653 | |||
1654 | // $ANTLR start "entryRuleALSOverride" | ||
1655 | // InternalAlloyLanguage.g:569:1: entryRuleALSOverride : ruleALSOverride EOF ; | ||
1656 | public final void entryRuleALSOverride() throws RecognitionException { | ||
1657 | try { | ||
1658 | // InternalAlloyLanguage.g:570:1: ( ruleALSOverride EOF ) | ||
1659 | // InternalAlloyLanguage.g:571:1: ruleALSOverride EOF | ||
1660 | { | ||
1661 | if ( state.backtracking==0 ) { | ||
1662 | before(grammarAccess.getALSOverrideRule()); | ||
1663 | } | ||
1664 | pushFollow(FOLLOW_1); | ||
1665 | ruleALSOverride(); | ||
1666 | |||
1667 | state._fsp--; | ||
1668 | if (state.failed) return ; | ||
1669 | if ( state.backtracking==0 ) { | ||
1670 | after(grammarAccess.getALSOverrideRule()); | ||
1671 | } | ||
1672 | match(input,EOF,FOLLOW_2); if (state.failed) return ; | ||
1673 | |||
1674 | } | ||
1675 | |||
1676 | } | ||
1677 | catch (RecognitionException re) { | ||
1678 | reportError(re); | ||
1679 | recover(input,re); | ||
1680 | } | ||
1681 | finally { | ||
1682 | } | ||
1683 | return ; | ||
1684 | } | ||
1685 | // $ANTLR end "entryRuleALSOverride" | ||
1686 | |||
1687 | |||
1688 | // $ANTLR start "ruleALSOverride" | ||
1689 | // InternalAlloyLanguage.g:578:1: ruleALSOverride : ( ( rule__ALSOverride__Group__0 ) ) ; | ||
1690 | public final void ruleALSOverride() throws RecognitionException { | ||
1691 | |||
1692 | int stackSize = keepStackSize(); | ||
1693 | |||
1694 | try { | ||
1695 | // InternalAlloyLanguage.g:582:2: ( ( ( rule__ALSOverride__Group__0 ) ) ) | ||
1696 | // InternalAlloyLanguage.g:583:1: ( ( rule__ALSOverride__Group__0 ) ) | ||
1697 | { | ||
1698 | // InternalAlloyLanguage.g:583:1: ( ( rule__ALSOverride__Group__0 ) ) | ||
1699 | // InternalAlloyLanguage.g:584:1: ( rule__ALSOverride__Group__0 ) | ||
1700 | { | ||
1701 | if ( state.backtracking==0 ) { | ||
1702 | before(grammarAccess.getALSOverrideAccess().getGroup()); | ||
1703 | } | ||
1704 | // InternalAlloyLanguage.g:585:1: ( rule__ALSOverride__Group__0 ) | ||
1705 | // InternalAlloyLanguage.g:585:2: rule__ALSOverride__Group__0 | ||
1706 | { | ||
1707 | pushFollow(FOLLOW_2); | ||
1708 | rule__ALSOverride__Group__0(); | ||
1709 | |||
1710 | state._fsp--; | ||
1711 | if (state.failed) return ; | ||
1712 | |||
1713 | } | ||
1714 | |||
1715 | if ( state.backtracking==0 ) { | ||
1716 | after(grammarAccess.getALSOverrideAccess().getGroup()); | ||
1717 | } | ||
1718 | |||
1719 | } | ||
1720 | |||
1721 | |||
1722 | } | ||
1723 | |||
1724 | } | ||
1725 | catch (RecognitionException re) { | ||
1726 | reportError(re); | ||
1727 | recover(input,re); | ||
1728 | } | ||
1729 | finally { | ||
1730 | |||
1731 | restoreStackSize(stackSize); | ||
1732 | |||
1733 | } | ||
1734 | return ; | ||
1735 | } | ||
1736 | // $ANTLR end "ruleALSOverride" | ||
1737 | |||
1738 | |||
1739 | // $ANTLR start "entryRuleALSRangeRestrictionRight" | ||
1740 | // InternalAlloyLanguage.g:597:1: entryRuleALSRangeRestrictionRight : ruleALSRangeRestrictionRight EOF ; | ||
1741 | public final void entryRuleALSRangeRestrictionRight() throws RecognitionException { | ||
1742 | try { | ||
1743 | // InternalAlloyLanguage.g:598:1: ( ruleALSRangeRestrictionRight EOF ) | ||
1744 | // InternalAlloyLanguage.g:599:1: ruleALSRangeRestrictionRight EOF | ||
1745 | { | ||
1746 | if ( state.backtracking==0 ) { | ||
1747 | before(grammarAccess.getALSRangeRestrictionRightRule()); | ||
1748 | } | ||
1749 | pushFollow(FOLLOW_1); | ||
1750 | ruleALSRangeRestrictionRight(); | ||
1751 | |||
1752 | state._fsp--; | ||
1753 | if (state.failed) return ; | ||
1754 | if ( state.backtracking==0 ) { | ||
1755 | after(grammarAccess.getALSRangeRestrictionRightRule()); | ||
1756 | } | ||
1757 | match(input,EOF,FOLLOW_2); if (state.failed) return ; | ||
1758 | |||
1759 | } | ||
1760 | |||
1761 | } | ||
1762 | catch (RecognitionException re) { | ||
1763 | reportError(re); | ||
1764 | recover(input,re); | ||
1765 | } | ||
1766 | finally { | ||
1767 | } | ||
1768 | return ; | ||
1769 | } | ||
1770 | // $ANTLR end "entryRuleALSRangeRestrictionRight" | ||
1771 | |||
1772 | |||
1773 | // $ANTLR start "ruleALSRangeRestrictionRight" | ||
1774 | // InternalAlloyLanguage.g:606:1: ruleALSRangeRestrictionRight : ( ( rule__ALSRangeRestrictionRight__Group__0 ) ) ; | ||
1775 | public final void ruleALSRangeRestrictionRight() throws RecognitionException { | ||
1776 | |||
1777 | int stackSize = keepStackSize(); | ||
1778 | |||
1779 | try { | ||
1780 | // InternalAlloyLanguage.g:610:2: ( ( ( rule__ALSRangeRestrictionRight__Group__0 ) ) ) | ||
1781 | // InternalAlloyLanguage.g:611:1: ( ( rule__ALSRangeRestrictionRight__Group__0 ) ) | ||
1782 | { | ||
1783 | // InternalAlloyLanguage.g:611:1: ( ( rule__ALSRangeRestrictionRight__Group__0 ) ) | ||
1784 | // InternalAlloyLanguage.g:612:1: ( rule__ALSRangeRestrictionRight__Group__0 ) | ||
1785 | { | ||
1786 | if ( state.backtracking==0 ) { | ||
1787 | before(grammarAccess.getALSRangeRestrictionRightAccess().getGroup()); | ||
1788 | } | ||
1789 | // InternalAlloyLanguage.g:613:1: ( rule__ALSRangeRestrictionRight__Group__0 ) | ||
1790 | // InternalAlloyLanguage.g:613:2: rule__ALSRangeRestrictionRight__Group__0 | ||
1791 | { | ||
1792 | pushFollow(FOLLOW_2); | ||
1793 | rule__ALSRangeRestrictionRight__Group__0(); | ||
1794 | |||
1795 | state._fsp--; | ||
1796 | if (state.failed) return ; | ||
1797 | |||
1798 | } | ||
1799 | |||
1800 | if ( state.backtracking==0 ) { | ||
1801 | after(grammarAccess.getALSRangeRestrictionRightAccess().getGroup()); | ||
1802 | } | ||
1803 | |||
1804 | } | ||
1805 | |||
1806 | |||
1807 | } | ||
1808 | |||
1809 | } | ||
1810 | catch (RecognitionException re) { | ||
1811 | reportError(re); | ||
1812 | recover(input,re); | ||
1813 | } | ||
1814 | finally { | ||
1815 | |||
1816 | restoreStackSize(stackSize); | ||
1817 | |||
1818 | } | ||
1819 | return ; | ||
1820 | } | ||
1821 | // $ANTLR end "ruleALSRangeRestrictionRight" | ||
1822 | |||
1823 | |||
1824 | // $ANTLR start "entryRuleALSRangeRestrictionLeft" | ||
1825 | // InternalAlloyLanguage.g:625:1: entryRuleALSRangeRestrictionLeft : ruleALSRangeRestrictionLeft EOF ; | ||
1826 | public final void entryRuleALSRangeRestrictionLeft() throws RecognitionException { | ||
1827 | try { | ||
1828 | // InternalAlloyLanguage.g:626:1: ( ruleALSRangeRestrictionLeft EOF ) | ||
1829 | // InternalAlloyLanguage.g:627:1: ruleALSRangeRestrictionLeft EOF | ||
1830 | { | ||
1831 | if ( state.backtracking==0 ) { | ||
1832 | before(grammarAccess.getALSRangeRestrictionLeftRule()); | ||
1833 | } | ||
1834 | pushFollow(FOLLOW_1); | ||
1835 | ruleALSRangeRestrictionLeft(); | ||
1836 | |||
1837 | state._fsp--; | ||
1838 | if (state.failed) return ; | ||
1839 | if ( state.backtracking==0 ) { | ||
1840 | after(grammarAccess.getALSRangeRestrictionLeftRule()); | ||
1841 | } | ||
1842 | match(input,EOF,FOLLOW_2); if (state.failed) return ; | ||
1843 | |||
1844 | } | ||
1845 | |||
1846 | } | ||
1847 | catch (RecognitionException re) { | ||
1848 | reportError(re); | ||
1849 | recover(input,re); | ||
1850 | } | ||
1851 | finally { | ||
1852 | } | ||
1853 | return ; | ||
1854 | } | ||
1855 | // $ANTLR end "entryRuleALSRangeRestrictionLeft" | ||
1856 | |||
1857 | |||
1858 | // $ANTLR start "ruleALSRangeRestrictionLeft" | ||
1859 | // InternalAlloyLanguage.g:634:1: ruleALSRangeRestrictionLeft : ( ( rule__ALSRangeRestrictionLeft__Group__0 ) ) ; | ||
1860 | public final void ruleALSRangeRestrictionLeft() throws RecognitionException { | ||
1861 | |||
1862 | int stackSize = keepStackSize(); | ||
1863 | |||
1864 | try { | ||
1865 | // InternalAlloyLanguage.g:638:2: ( ( ( rule__ALSRangeRestrictionLeft__Group__0 ) ) ) | ||
1866 | // InternalAlloyLanguage.g:639:1: ( ( rule__ALSRangeRestrictionLeft__Group__0 ) ) | ||
1867 | { | ||
1868 | // InternalAlloyLanguage.g:639:1: ( ( rule__ALSRangeRestrictionLeft__Group__0 ) ) | ||
1869 | // InternalAlloyLanguage.g:640:1: ( rule__ALSRangeRestrictionLeft__Group__0 ) | ||
1870 | { | ||
1871 | if ( state.backtracking==0 ) { | ||
1872 | before(grammarAccess.getALSRangeRestrictionLeftAccess().getGroup()); | ||
1873 | } | ||
1874 | // InternalAlloyLanguage.g:641:1: ( rule__ALSRangeRestrictionLeft__Group__0 ) | ||
1875 | // InternalAlloyLanguage.g:641:2: rule__ALSRangeRestrictionLeft__Group__0 | ||
1876 | { | ||
1877 | pushFollow(FOLLOW_2); | ||
1878 | rule__ALSRangeRestrictionLeft__Group__0(); | ||
1879 | |||
1880 | state._fsp--; | ||
1881 | if (state.failed) return ; | ||
1882 | |||
1883 | } | ||
1884 | |||
1885 | if ( state.backtracking==0 ) { | ||
1886 | after(grammarAccess.getALSRangeRestrictionLeftAccess().getGroup()); | ||
1887 | } | ||
1888 | |||
1889 | } | ||
1890 | |||
1891 | |||
1892 | } | ||
1893 | |||
1894 | } | ||
1895 | catch (RecognitionException re) { | ||
1896 | reportError(re); | ||
1897 | recover(input,re); | ||
1898 | } | ||
1899 | finally { | ||
1900 | |||
1901 | restoreStackSize(stackSize); | ||
1902 | |||
1903 | } | ||
1904 | return ; | ||
1905 | } | ||
1906 | // $ANTLR end "ruleALSRangeRestrictionLeft" | ||
1907 | |||
1908 | |||
1909 | // $ANTLR start "entryRuleALSJoin" | ||
1910 | // InternalAlloyLanguage.g:653:1: entryRuleALSJoin : ruleALSJoin EOF ; | ||
1911 | public final void entryRuleALSJoin() throws RecognitionException { | ||
1912 | try { | ||
1913 | // InternalAlloyLanguage.g:654:1: ( ruleALSJoin EOF ) | ||
1914 | // InternalAlloyLanguage.g:655:1: ruleALSJoin EOF | ||
1915 | { | ||
1916 | if ( state.backtracking==0 ) { | ||
1917 | before(grammarAccess.getALSJoinRule()); | ||
1918 | } | ||
1919 | pushFollow(FOLLOW_1); | ||
1920 | ruleALSJoin(); | ||
1921 | |||
1922 | state._fsp--; | ||
1923 | if (state.failed) return ; | ||
1924 | if ( state.backtracking==0 ) { | ||
1925 | after(grammarAccess.getALSJoinRule()); | ||
1926 | } | ||
1927 | match(input,EOF,FOLLOW_2); if (state.failed) return ; | ||
1928 | |||
1929 | } | ||
1930 | |||
1931 | } | ||
1932 | catch (RecognitionException re) { | ||
1933 | reportError(re); | ||
1934 | recover(input,re); | ||
1935 | } | ||
1936 | finally { | ||
1937 | } | ||
1938 | return ; | ||
1939 | } | ||
1940 | // $ANTLR end "entryRuleALSJoin" | ||
1941 | |||
1942 | |||
1943 | // $ANTLR start "ruleALSJoin" | ||
1944 | // InternalAlloyLanguage.g:662:1: ruleALSJoin : ( ( rule__ALSJoin__Group__0 ) ) ; | ||
1945 | public final void ruleALSJoin() throws RecognitionException { | ||
1946 | |||
1947 | int stackSize = keepStackSize(); | ||
1948 | |||
1949 | try { | ||
1950 | // InternalAlloyLanguage.g:666:2: ( ( ( rule__ALSJoin__Group__0 ) ) ) | ||
1951 | // InternalAlloyLanguage.g:667:1: ( ( rule__ALSJoin__Group__0 ) ) | ||
1952 | { | ||
1953 | // InternalAlloyLanguage.g:667:1: ( ( rule__ALSJoin__Group__0 ) ) | ||
1954 | // InternalAlloyLanguage.g:668:1: ( rule__ALSJoin__Group__0 ) | ||
1955 | { | ||
1956 | if ( state.backtracking==0 ) { | ||
1957 | before(grammarAccess.getALSJoinAccess().getGroup()); | ||
1958 | } | ||
1959 | // InternalAlloyLanguage.g:669:1: ( rule__ALSJoin__Group__0 ) | ||
1960 | // InternalAlloyLanguage.g:669:2: rule__ALSJoin__Group__0 | ||
1961 | { | ||
1962 | pushFollow(FOLLOW_2); | ||
1963 | rule__ALSJoin__Group__0(); | ||
1964 | |||
1965 | state._fsp--; | ||
1966 | if (state.failed) return ; | ||
1967 | |||
1968 | } | ||
1969 | |||
1970 | if ( state.backtracking==0 ) { | ||
1971 | after(grammarAccess.getALSJoinAccess().getGroup()); | ||
1972 | } | ||
1973 | |||
1974 | } | ||
1975 | |||
1976 | |||
1977 | } | ||
1978 | |||
1979 | } | ||
1980 | catch (RecognitionException re) { | ||
1981 | reportError(re); | ||
1982 | recover(input,re); | ||
1983 | } | ||
1984 | finally { | ||
1985 | |||
1986 | restoreStackSize(stackSize); | ||
1987 | |||
1988 | } | ||
1989 | return ; | ||
1990 | } | ||
1991 | // $ANTLR end "ruleALSJoin" | ||
1992 | |||
1993 | |||
1994 | // $ANTLR start "entryRuleALSMinus" | ||
1995 | // InternalAlloyLanguage.g:681:1: entryRuleALSMinus : ruleALSMinus EOF ; | ||
1996 | public final void entryRuleALSMinus() throws RecognitionException { | ||
1997 | try { | ||
1998 | // InternalAlloyLanguage.g:682:1: ( ruleALSMinus EOF ) | ||
1999 | // InternalAlloyLanguage.g:683:1: ruleALSMinus EOF | ||
2000 | { | ||
2001 | if ( state.backtracking==0 ) { | ||
2002 | before(grammarAccess.getALSMinusRule()); | ||
2003 | } | ||
2004 | pushFollow(FOLLOW_1); | ||
2005 | ruleALSMinus(); | ||
2006 | |||
2007 | state._fsp--; | ||
2008 | if (state.failed) return ; | ||
2009 | if ( state.backtracking==0 ) { | ||
2010 | after(grammarAccess.getALSMinusRule()); | ||
2011 | } | ||
2012 | match(input,EOF,FOLLOW_2); if (state.failed) return ; | ||
2013 | |||
2014 | } | ||
2015 | |||
2016 | } | ||
2017 | catch (RecognitionException re) { | ||
2018 | reportError(re); | ||
2019 | recover(input,re); | ||
2020 | } | ||
2021 | finally { | ||
2022 | } | ||
2023 | return ; | ||
2024 | } | ||
2025 | // $ANTLR end "entryRuleALSMinus" | ||
2026 | |||
2027 | |||
2028 | // $ANTLR start "ruleALSMinus" | ||
2029 | // InternalAlloyLanguage.g:690:1: ruleALSMinus : ( ( rule__ALSMinus__Group__0 ) ) ; | ||
2030 | public final void ruleALSMinus() throws RecognitionException { | ||
2031 | |||
2032 | int stackSize = keepStackSize(); | ||
2033 | |||
2034 | try { | ||
2035 | // InternalAlloyLanguage.g:694:2: ( ( ( rule__ALSMinus__Group__0 ) ) ) | ||
2036 | // InternalAlloyLanguage.g:695:1: ( ( rule__ALSMinus__Group__0 ) ) | ||
2037 | { | ||
2038 | // InternalAlloyLanguage.g:695:1: ( ( rule__ALSMinus__Group__0 ) ) | ||
2039 | // InternalAlloyLanguage.g:696:1: ( rule__ALSMinus__Group__0 ) | ||
2040 | { | ||
2041 | if ( state.backtracking==0 ) { | ||
2042 | before(grammarAccess.getALSMinusAccess().getGroup()); | ||
2043 | } | ||
2044 | // InternalAlloyLanguage.g:697:1: ( rule__ALSMinus__Group__0 ) | ||
2045 | // InternalAlloyLanguage.g:697:2: rule__ALSMinus__Group__0 | ||
2046 | { | ||
2047 | pushFollow(FOLLOW_2); | ||
2048 | rule__ALSMinus__Group__0(); | ||
2049 | |||
2050 | state._fsp--; | ||
2051 | if (state.failed) return ; | ||
2052 | |||
2053 | } | ||
2054 | |||
2055 | if ( state.backtracking==0 ) { | ||
2056 | after(grammarAccess.getALSMinusAccess().getGroup()); | ||
2057 | } | ||
2058 | |||
2059 | } | ||
2060 | |||
2061 | |||
2062 | } | ||
2063 | |||
2064 | } | ||
2065 | catch (RecognitionException re) { | ||
2066 | reportError(re); | ||
2067 | recover(input,re); | ||
2068 | } | ||
2069 | finally { | ||
2070 | |||
2071 | restoreStackSize(stackSize); | ||
2072 | |||
2073 | } | ||
2074 | return ; | ||
2075 | } | ||
2076 | // $ANTLR end "ruleALSMinus" | ||
2077 | |||
2078 | |||
2079 | // $ANTLR start "entryRuleALSPlus" | ||
2080 | // InternalAlloyLanguage.g:709:1: entryRuleALSPlus : ruleALSPlus EOF ; | ||
2081 | public final void entryRuleALSPlus() throws RecognitionException { | ||
2082 | try { | ||
2083 | // InternalAlloyLanguage.g:710:1: ( ruleALSPlus EOF ) | ||
2084 | // InternalAlloyLanguage.g:711:1: ruleALSPlus EOF | ||
2085 | { | ||
2086 | if ( state.backtracking==0 ) { | ||
2087 | before(grammarAccess.getALSPlusRule()); | ||
2088 | } | ||
2089 | pushFollow(FOLLOW_1); | ||
2090 | ruleALSPlus(); | ||
2091 | |||
2092 | state._fsp--; | ||
2093 | if (state.failed) return ; | ||
2094 | if ( state.backtracking==0 ) { | ||
2095 | after(grammarAccess.getALSPlusRule()); | ||
2096 | } | ||
2097 | match(input,EOF,FOLLOW_2); if (state.failed) return ; | ||
2098 | |||
2099 | } | ||
2100 | |||
2101 | } | ||
2102 | catch (RecognitionException re) { | ||
2103 | reportError(re); | ||
2104 | recover(input,re); | ||
2105 | } | ||
2106 | finally { | ||
2107 | } | ||
2108 | return ; | ||
2109 | } | ||
2110 | // $ANTLR end "entryRuleALSPlus" | ||
2111 | |||
2112 | |||
2113 | // $ANTLR start "ruleALSPlus" | ||
2114 | // InternalAlloyLanguage.g:718:1: ruleALSPlus : ( ( rule__ALSPlus__Group__0 ) ) ; | ||
2115 | public final void ruleALSPlus() throws RecognitionException { | ||
2116 | |||
2117 | int stackSize = keepStackSize(); | ||
2118 | |||
2119 | try { | ||
2120 | // InternalAlloyLanguage.g:722:2: ( ( ( rule__ALSPlus__Group__0 ) ) ) | ||
2121 | // InternalAlloyLanguage.g:723:1: ( ( rule__ALSPlus__Group__0 ) ) | ||
2122 | { | ||
2123 | // InternalAlloyLanguage.g:723:1: ( ( rule__ALSPlus__Group__0 ) ) | ||
2124 | // InternalAlloyLanguage.g:724:1: ( rule__ALSPlus__Group__0 ) | ||
2125 | { | ||
2126 | if ( state.backtracking==0 ) { | ||
2127 | before(grammarAccess.getALSPlusAccess().getGroup()); | ||
2128 | } | ||
2129 | // InternalAlloyLanguage.g:725:1: ( rule__ALSPlus__Group__0 ) | ||
2130 | // InternalAlloyLanguage.g:725:2: rule__ALSPlus__Group__0 | ||
2131 | { | ||
2132 | pushFollow(FOLLOW_2); | ||
2133 | rule__ALSPlus__Group__0(); | ||
2134 | |||
2135 | state._fsp--; | ||
2136 | if (state.failed) return ; | ||
2137 | |||
2138 | } | ||
2139 | |||
2140 | if ( state.backtracking==0 ) { | ||
2141 | after(grammarAccess.getALSPlusAccess().getGroup()); | ||
2142 | } | ||
2143 | |||
2144 | } | ||
2145 | |||
2146 | |||
2147 | } | ||
2148 | |||
2149 | } | ||
2150 | catch (RecognitionException re) { | ||
2151 | reportError(re); | ||
2152 | recover(input,re); | ||
2153 | } | ||
2154 | finally { | ||
2155 | |||
2156 | restoreStackSize(stackSize); | ||
2157 | |||
2158 | } | ||
2159 | return ; | ||
2160 | } | ||
2161 | // $ANTLR end "ruleALSPlus" | ||
2162 | |||
2163 | |||
2164 | // $ANTLR start "entryRuleALSIntersection" | ||
2165 | // InternalAlloyLanguage.g:737:1: entryRuleALSIntersection : ruleALSIntersection EOF ; | ||
2166 | public final void entryRuleALSIntersection() throws RecognitionException { | ||
2167 | try { | ||
2168 | // InternalAlloyLanguage.g:738:1: ( ruleALSIntersection EOF ) | ||
2169 | // InternalAlloyLanguage.g:739:1: ruleALSIntersection EOF | ||
2170 | { | ||
2171 | if ( state.backtracking==0 ) { | ||
2172 | before(grammarAccess.getALSIntersectionRule()); | ||
2173 | } | ||
2174 | pushFollow(FOLLOW_1); | ||
2175 | ruleALSIntersection(); | ||
2176 | |||
2177 | state._fsp--; | ||
2178 | if (state.failed) return ; | ||
2179 | if ( state.backtracking==0 ) { | ||
2180 | after(grammarAccess.getALSIntersectionRule()); | ||
2181 | } | ||
2182 | match(input,EOF,FOLLOW_2); if (state.failed) return ; | ||
2183 | |||
2184 | } | ||
2185 | |||
2186 | } | ||
2187 | catch (RecognitionException re) { | ||
2188 | reportError(re); | ||
2189 | recover(input,re); | ||
2190 | } | ||
2191 | finally { | ||
2192 | } | ||
2193 | return ; | ||
2194 | } | ||
2195 | // $ANTLR end "entryRuleALSIntersection" | ||
2196 | |||
2197 | |||
2198 | // $ANTLR start "ruleALSIntersection" | ||
2199 | // InternalAlloyLanguage.g:746:1: ruleALSIntersection : ( ( rule__ALSIntersection__Group__0 ) ) ; | ||
2200 | public final void ruleALSIntersection() throws RecognitionException { | ||
2201 | |||
2202 | int stackSize = keepStackSize(); | ||
2203 | |||
2204 | try { | ||
2205 | // InternalAlloyLanguage.g:750:2: ( ( ( rule__ALSIntersection__Group__0 ) ) ) | ||
2206 | // InternalAlloyLanguage.g:751:1: ( ( rule__ALSIntersection__Group__0 ) ) | ||
2207 | { | ||
2208 | // InternalAlloyLanguage.g:751:1: ( ( rule__ALSIntersection__Group__0 ) ) | ||
2209 | // InternalAlloyLanguage.g:752:1: ( rule__ALSIntersection__Group__0 ) | ||
2210 | { | ||
2211 | if ( state.backtracking==0 ) { | ||
2212 | before(grammarAccess.getALSIntersectionAccess().getGroup()); | ||
2213 | } | ||
2214 | // InternalAlloyLanguage.g:753:1: ( rule__ALSIntersection__Group__0 ) | ||
2215 | // InternalAlloyLanguage.g:753:2: rule__ALSIntersection__Group__0 | ||
2216 | { | ||
2217 | pushFollow(FOLLOW_2); | ||
2218 | rule__ALSIntersection__Group__0(); | ||
2219 | |||
2220 | state._fsp--; | ||
2221 | if (state.failed) return ; | ||
2222 | |||
2223 | } | ||
2224 | |||
2225 | if ( state.backtracking==0 ) { | ||
2226 | after(grammarAccess.getALSIntersectionAccess().getGroup()); | ||
2227 | } | ||
2228 | |||
2229 | } | ||
2230 | |||
2231 | |||
2232 | } | ||
2233 | |||
2234 | } | ||
2235 | catch (RecognitionException re) { | ||
2236 | reportError(re); | ||
2237 | recover(input,re); | ||
2238 | } | ||
2239 | finally { | ||
2240 | |||
2241 | restoreStackSize(stackSize); | ||
2242 | |||
2243 | } | ||
2244 | return ; | ||
2245 | } | ||
2246 | // $ANTLR end "ruleALSIntersection" | ||
2247 | |||
2248 | |||
2249 | // $ANTLR start "entryRuleALSDirectProduct" | ||
2250 | // InternalAlloyLanguage.g:765:1: entryRuleALSDirectProduct : ruleALSDirectProduct EOF ; | ||
2251 | public final void entryRuleALSDirectProduct() throws RecognitionException { | ||
2252 | try { | ||
2253 | // InternalAlloyLanguage.g:766:1: ( ruleALSDirectProduct EOF ) | ||
2254 | // InternalAlloyLanguage.g:767:1: ruleALSDirectProduct EOF | ||
2255 | { | ||
2256 | if ( state.backtracking==0 ) { | ||
2257 | before(grammarAccess.getALSDirectProductRule()); | ||
2258 | } | ||
2259 | pushFollow(FOLLOW_1); | ||
2260 | ruleALSDirectProduct(); | ||
2261 | |||
2262 | state._fsp--; | ||
2263 | if (state.failed) return ; | ||
2264 | if ( state.backtracking==0 ) { | ||
2265 | after(grammarAccess.getALSDirectProductRule()); | ||
2266 | } | ||
2267 | match(input,EOF,FOLLOW_2); if (state.failed) return ; | ||
2268 | |||
2269 | } | ||
2270 | |||
2271 | } | ||
2272 | catch (RecognitionException re) { | ||
2273 | reportError(re); | ||
2274 | recover(input,re); | ||
2275 | } | ||
2276 | finally { | ||
2277 | } | ||
2278 | return ; | ||
2279 | } | ||
2280 | // $ANTLR end "entryRuleALSDirectProduct" | ||
2281 | |||
2282 | |||
2283 | // $ANTLR start "ruleALSDirectProduct" | ||
2284 | // InternalAlloyLanguage.g:774:1: ruleALSDirectProduct : ( ( rule__ALSDirectProduct__Group__0 ) ) ; | ||
2285 | public final void ruleALSDirectProduct() throws RecognitionException { | ||
2286 | |||
2287 | int stackSize = keepStackSize(); | ||
2288 | |||
2289 | try { | ||
2290 | // InternalAlloyLanguage.g:778:2: ( ( ( rule__ALSDirectProduct__Group__0 ) ) ) | ||
2291 | // InternalAlloyLanguage.g:779:1: ( ( rule__ALSDirectProduct__Group__0 ) ) | ||
2292 | { | ||
2293 | // InternalAlloyLanguage.g:779:1: ( ( rule__ALSDirectProduct__Group__0 ) ) | ||
2294 | // InternalAlloyLanguage.g:780:1: ( rule__ALSDirectProduct__Group__0 ) | ||
2295 | { | ||
2296 | if ( state.backtracking==0 ) { | ||
2297 | before(grammarAccess.getALSDirectProductAccess().getGroup()); | ||
2298 | } | ||
2299 | // InternalAlloyLanguage.g:781:1: ( rule__ALSDirectProduct__Group__0 ) | ||
2300 | // InternalAlloyLanguage.g:781:2: rule__ALSDirectProduct__Group__0 | ||
2301 | { | ||
2302 | pushFollow(FOLLOW_2); | ||
2303 | rule__ALSDirectProduct__Group__0(); | ||
2304 | |||
2305 | state._fsp--; | ||
2306 | if (state.failed) return ; | ||
2307 | |||
2308 | } | ||
2309 | |||
2310 | if ( state.backtracking==0 ) { | ||
2311 | after(grammarAccess.getALSDirectProductAccess().getGroup()); | ||
2312 | } | ||
2313 | |||
2314 | } | ||
2315 | |||
2316 | |||
2317 | } | ||
2318 | |||
2319 | } | ||
2320 | catch (RecognitionException re) { | ||
2321 | reportError(re); | ||
2322 | recover(input,re); | ||
2323 | } | ||
2324 | finally { | ||
2325 | |||
2326 | restoreStackSize(stackSize); | ||
2327 | |||
2328 | } | ||
2329 | return ; | ||
2330 | } | ||
2331 | // $ANTLR end "ruleALSDirectProduct" | ||
2332 | |||
2333 | |||
2334 | // $ANTLR start "entryRuleALSPreficed" | ||
2335 | // InternalAlloyLanguage.g:793:1: entryRuleALSPreficed : ruleALSPreficed EOF ; | ||
2336 | public final void entryRuleALSPreficed() throws RecognitionException { | ||
2337 | try { | ||
2338 | // InternalAlloyLanguage.g:794:1: ( ruleALSPreficed EOF ) | ||
2339 | // InternalAlloyLanguage.g:795:1: ruleALSPreficed EOF | ||
2340 | { | ||
2341 | if ( state.backtracking==0 ) { | ||
2342 | before(grammarAccess.getALSPreficedRule()); | ||
2343 | } | ||
2344 | pushFollow(FOLLOW_1); | ||
2345 | ruleALSPreficed(); | ||
2346 | |||
2347 | state._fsp--; | ||
2348 | if (state.failed) return ; | ||
2349 | if ( state.backtracking==0 ) { | ||
2350 | after(grammarAccess.getALSPreficedRule()); | ||
2351 | } | ||
2352 | match(input,EOF,FOLLOW_2); if (state.failed) return ; | ||
2353 | |||
2354 | } | ||
2355 | |||
2356 | } | ||
2357 | catch (RecognitionException re) { | ||
2358 | reportError(re); | ||
2359 | recover(input,re); | ||
2360 | } | ||
2361 | finally { | ||
2362 | } | ||
2363 | return ; | ||
2364 | } | ||
2365 | // $ANTLR end "entryRuleALSPreficed" | ||
2366 | |||
2367 | |||
2368 | // $ANTLR start "ruleALSPreficed" | ||
2369 | // InternalAlloyLanguage.g:802:1: ruleALSPreficed : ( ( rule__ALSPreficed__Alternatives ) ) ; | ||
2370 | public final void ruleALSPreficed() throws RecognitionException { | ||
2371 | |||
2372 | int stackSize = keepStackSize(); | ||
2373 | |||
2374 | try { | ||
2375 | // InternalAlloyLanguage.g:806:2: ( ( ( rule__ALSPreficed__Alternatives ) ) ) | ||
2376 | // InternalAlloyLanguage.g:807:1: ( ( rule__ALSPreficed__Alternatives ) ) | ||
2377 | { | ||
2378 | // InternalAlloyLanguage.g:807:1: ( ( rule__ALSPreficed__Alternatives ) ) | ||
2379 | // InternalAlloyLanguage.g:808:1: ( rule__ALSPreficed__Alternatives ) | ||
2380 | { | ||
2381 | if ( state.backtracking==0 ) { | ||
2382 | before(grammarAccess.getALSPreficedAccess().getAlternatives()); | ||
2383 | } | ||
2384 | // InternalAlloyLanguage.g:809:1: ( rule__ALSPreficed__Alternatives ) | ||
2385 | // InternalAlloyLanguage.g:809:2: rule__ALSPreficed__Alternatives | ||
2386 | { | ||
2387 | pushFollow(FOLLOW_2); | ||
2388 | rule__ALSPreficed__Alternatives(); | ||
2389 | |||
2390 | state._fsp--; | ||
2391 | if (state.failed) return ; | ||
2392 | |||
2393 | } | ||
2394 | |||
2395 | if ( state.backtracking==0 ) { | ||
2396 | after(grammarAccess.getALSPreficedAccess().getAlternatives()); | ||
2397 | } | ||
2398 | |||
2399 | } | ||
2400 | |||
2401 | |||
2402 | } | ||
2403 | |||
2404 | } | ||
2405 | catch (RecognitionException re) { | ||
2406 | reportError(re); | ||
2407 | recover(input,re); | ||
2408 | } | ||
2409 | finally { | ||
2410 | |||
2411 | restoreStackSize(stackSize); | ||
2412 | |||
2413 | } | ||
2414 | return ; | ||
2415 | } | ||
2416 | // $ANTLR end "ruleALSPreficed" | ||
2417 | |||
2418 | |||
2419 | // $ANTLR start "entryRuleALSVariableDeclaration" | ||
2420 | // InternalAlloyLanguage.g:821:1: entryRuleALSVariableDeclaration : ruleALSVariableDeclaration EOF ; | ||
2421 | public final void entryRuleALSVariableDeclaration() throws RecognitionException { | ||
2422 | try { | ||
2423 | // InternalAlloyLanguage.g:822:1: ( ruleALSVariableDeclaration EOF ) | ||
2424 | // InternalAlloyLanguage.g:823:1: ruleALSVariableDeclaration EOF | ||
2425 | { | ||
2426 | if ( state.backtracking==0 ) { | ||
2427 | before(grammarAccess.getALSVariableDeclarationRule()); | ||
2428 | } | ||
2429 | pushFollow(FOLLOW_1); | ||
2430 | ruleALSVariableDeclaration(); | ||
2431 | |||
2432 | state._fsp--; | ||
2433 | if (state.failed) return ; | ||
2434 | if ( state.backtracking==0 ) { | ||
2435 | after(grammarAccess.getALSVariableDeclarationRule()); | ||
2436 | } | ||
2437 | match(input,EOF,FOLLOW_2); if (state.failed) return ; | ||
2438 | |||
2439 | } | ||
2440 | |||
2441 | } | ||
2442 | catch (RecognitionException re) { | ||
2443 | reportError(re); | ||
2444 | recover(input,re); | ||
2445 | } | ||
2446 | finally { | ||
2447 | } | ||
2448 | return ; | ||
2449 | } | ||
2450 | // $ANTLR end "entryRuleALSVariableDeclaration" | ||
2451 | |||
2452 | |||
2453 | // $ANTLR start "ruleALSVariableDeclaration" | ||
2454 | // InternalAlloyLanguage.g:830:1: ruleALSVariableDeclaration : ( ( rule__ALSVariableDeclaration__Group__0 ) ) ; | ||
2455 | public final void ruleALSVariableDeclaration() throws RecognitionException { | ||
2456 | |||
2457 | int stackSize = keepStackSize(); | ||
2458 | |||
2459 | try { | ||
2460 | // InternalAlloyLanguage.g:834:2: ( ( ( rule__ALSVariableDeclaration__Group__0 ) ) ) | ||
2461 | // InternalAlloyLanguage.g:835:1: ( ( rule__ALSVariableDeclaration__Group__0 ) ) | ||
2462 | { | ||
2463 | // InternalAlloyLanguage.g:835:1: ( ( rule__ALSVariableDeclaration__Group__0 ) ) | ||
2464 | // InternalAlloyLanguage.g:836:1: ( rule__ALSVariableDeclaration__Group__0 ) | ||
2465 | { | ||
2466 | if ( state.backtracking==0 ) { | ||
2467 | before(grammarAccess.getALSVariableDeclarationAccess().getGroup()); | ||
2468 | } | ||
2469 | // InternalAlloyLanguage.g:837:1: ( rule__ALSVariableDeclaration__Group__0 ) | ||
2470 | // InternalAlloyLanguage.g:837:2: rule__ALSVariableDeclaration__Group__0 | ||
2471 | { | ||
2472 | pushFollow(FOLLOW_2); | ||
2473 | rule__ALSVariableDeclaration__Group__0(); | ||
2474 | |||
2475 | state._fsp--; | ||
2476 | if (state.failed) return ; | ||
2477 | |||
2478 | } | ||
2479 | |||
2480 | if ( state.backtracking==0 ) { | ||
2481 | after(grammarAccess.getALSVariableDeclarationAccess().getGroup()); | ||
2482 | } | ||
2483 | |||
2484 | } | ||
2485 | |||
2486 | |||
2487 | } | ||
2488 | |||
2489 | } | ||
2490 | catch (RecognitionException re) { | ||
2491 | reportError(re); | ||
2492 | recover(input,re); | ||
2493 | } | ||
2494 | finally { | ||
2495 | |||
2496 | restoreStackSize(stackSize); | ||
2497 | |||
2498 | } | ||
2499 | return ; | ||
2500 | } | ||
2501 | // $ANTLR end "ruleALSVariableDeclaration" | ||
2502 | |||
2503 | |||
2504 | // $ANTLR start "entryRuleALSBasicRelationTerm" | ||
2505 | // InternalAlloyLanguage.g:849:1: entryRuleALSBasicRelationTerm : ruleALSBasicRelationTerm EOF ; | ||
2506 | public final void entryRuleALSBasicRelationTerm() throws RecognitionException { | ||
2507 | try { | ||
2508 | // InternalAlloyLanguage.g:850:1: ( ruleALSBasicRelationTerm EOF ) | ||
2509 | // InternalAlloyLanguage.g:851:1: ruleALSBasicRelationTerm EOF | ||
2510 | { | ||
2511 | if ( state.backtracking==0 ) { | ||
2512 | before(grammarAccess.getALSBasicRelationTermRule()); | ||
2513 | } | ||
2514 | pushFollow(FOLLOW_1); | ||
2515 | ruleALSBasicRelationTerm(); | ||
2516 | |||
2517 | state._fsp--; | ||
2518 | if (state.failed) return ; | ||
2519 | if ( state.backtracking==0 ) { | ||
2520 | after(grammarAccess.getALSBasicRelationTermRule()); | ||
2521 | } | ||
2522 | match(input,EOF,FOLLOW_2); if (state.failed) return ; | ||
2523 | |||
2524 | } | ||
2525 | |||
2526 | } | ||
2527 | catch (RecognitionException re) { | ||
2528 | reportError(re); | ||
2529 | recover(input,re); | ||
2530 | } | ||
2531 | finally { | ||
2532 | } | ||
2533 | return ; | ||
2534 | } | ||
2535 | // $ANTLR end "entryRuleALSBasicRelationTerm" | ||
2536 | |||
2537 | |||
2538 | // $ANTLR start "ruleALSBasicRelationTerm" | ||
2539 | // InternalAlloyLanguage.g:858:1: ruleALSBasicRelationTerm : ( ( rule__ALSBasicRelationTerm__Alternatives ) ) ; | ||
2540 | public final void ruleALSBasicRelationTerm() throws RecognitionException { | ||
2541 | |||
2542 | int stackSize = keepStackSize(); | ||
2543 | |||
2544 | try { | ||
2545 | // InternalAlloyLanguage.g:862:2: ( ( ( rule__ALSBasicRelationTerm__Alternatives ) ) ) | ||
2546 | // InternalAlloyLanguage.g:863:1: ( ( rule__ALSBasicRelationTerm__Alternatives ) ) | ||
2547 | { | ||
2548 | // InternalAlloyLanguage.g:863:1: ( ( rule__ALSBasicRelationTerm__Alternatives ) ) | ||
2549 | // InternalAlloyLanguage.g:864:1: ( rule__ALSBasicRelationTerm__Alternatives ) | ||
2550 | { | ||
2551 | if ( state.backtracking==0 ) { | ||
2552 | before(grammarAccess.getALSBasicRelationTermAccess().getAlternatives()); | ||
2553 | } | ||
2554 | // InternalAlloyLanguage.g:865:1: ( rule__ALSBasicRelationTerm__Alternatives ) | ||
2555 | // InternalAlloyLanguage.g:865:2: rule__ALSBasicRelationTerm__Alternatives | ||
2556 | { | ||
2557 | pushFollow(FOLLOW_2); | ||
2558 | rule__ALSBasicRelationTerm__Alternatives(); | ||
2559 | |||
2560 | state._fsp--; | ||
2561 | if (state.failed) return ; | ||
2562 | |||
2563 | } | ||
2564 | |||
2565 | if ( state.backtracking==0 ) { | ||
2566 | after(grammarAccess.getALSBasicRelationTermAccess().getAlternatives()); | ||
2567 | } | ||
2568 | |||
2569 | } | ||
2570 | |||
2571 | |||
2572 | } | ||
2573 | |||
2574 | } | ||
2575 | catch (RecognitionException re) { | ||
2576 | reportError(re); | ||
2577 | recover(input,re); | ||
2578 | } | ||
2579 | finally { | ||
2580 | |||
2581 | restoreStackSize(stackSize); | ||
2582 | |||
2583 | } | ||
2584 | return ; | ||
2585 | } | ||
2586 | // $ANTLR end "ruleALSBasicRelationTerm" | ||
2587 | |||
2588 | |||
2589 | // $ANTLR start "entryRuleALSRunCommand" | ||
2590 | // InternalAlloyLanguage.g:877:1: entryRuleALSRunCommand : ruleALSRunCommand EOF ; | ||
2591 | public final void entryRuleALSRunCommand() throws RecognitionException { | ||
2592 | try { | ||
2593 | // InternalAlloyLanguage.g:878:1: ( ruleALSRunCommand EOF ) | ||
2594 | // InternalAlloyLanguage.g:879:1: ruleALSRunCommand EOF | ||
2595 | { | ||
2596 | if ( state.backtracking==0 ) { | ||
2597 | before(grammarAccess.getALSRunCommandRule()); | ||
2598 | } | ||
2599 | pushFollow(FOLLOW_1); | ||
2600 | ruleALSRunCommand(); | ||
2601 | |||
2602 | state._fsp--; | ||
2603 | if (state.failed) return ; | ||
2604 | if ( state.backtracking==0 ) { | ||
2605 | after(grammarAccess.getALSRunCommandRule()); | ||
2606 | } | ||
2607 | match(input,EOF,FOLLOW_2); if (state.failed) return ; | ||
2608 | |||
2609 | } | ||
2610 | |||
2611 | } | ||
2612 | catch (RecognitionException re) { | ||
2613 | reportError(re); | ||
2614 | recover(input,re); | ||
2615 | } | ||
2616 | finally { | ||
2617 | } | ||
2618 | return ; | ||
2619 | } | ||
2620 | // $ANTLR end "entryRuleALSRunCommand" | ||
2621 | |||
2622 | |||
2623 | // $ANTLR start "ruleALSRunCommand" | ||
2624 | // InternalAlloyLanguage.g:886:1: ruleALSRunCommand : ( ( rule__ALSRunCommand__Group__0 ) ) ; | ||
2625 | public final void ruleALSRunCommand() throws RecognitionException { | ||
2626 | |||
2627 | int stackSize = keepStackSize(); | ||
2628 | |||
2629 | try { | ||
2630 | // InternalAlloyLanguage.g:890:2: ( ( ( rule__ALSRunCommand__Group__0 ) ) ) | ||
2631 | // InternalAlloyLanguage.g:891:1: ( ( rule__ALSRunCommand__Group__0 ) ) | ||
2632 | { | ||
2633 | // InternalAlloyLanguage.g:891:1: ( ( rule__ALSRunCommand__Group__0 ) ) | ||
2634 | // InternalAlloyLanguage.g:892:1: ( rule__ALSRunCommand__Group__0 ) | ||
2635 | { | ||
2636 | if ( state.backtracking==0 ) { | ||
2637 | before(grammarAccess.getALSRunCommandAccess().getGroup()); | ||
2638 | } | ||
2639 | // InternalAlloyLanguage.g:893:1: ( rule__ALSRunCommand__Group__0 ) | ||
2640 | // InternalAlloyLanguage.g:893:2: rule__ALSRunCommand__Group__0 | ||
2641 | { | ||
2642 | pushFollow(FOLLOW_2); | ||
2643 | rule__ALSRunCommand__Group__0(); | ||
2644 | |||
2645 | state._fsp--; | ||
2646 | if (state.failed) return ; | ||
2647 | |||
2648 | } | ||
2649 | |||
2650 | if ( state.backtracking==0 ) { | ||
2651 | after(grammarAccess.getALSRunCommandAccess().getGroup()); | ||
2652 | } | ||
2653 | |||
2654 | } | ||
2655 | |||
2656 | |||
2657 | } | ||
2658 | |||
2659 | } | ||
2660 | catch (RecognitionException re) { | ||
2661 | reportError(re); | ||
2662 | recover(input,re); | ||
2663 | } | ||
2664 | finally { | ||
2665 | |||
2666 | restoreStackSize(stackSize); | ||
2667 | |||
2668 | } | ||
2669 | return ; | ||
2670 | } | ||
2671 | // $ANTLR end "ruleALSRunCommand" | ||
2672 | |||
2673 | |||
2674 | // $ANTLR start "entryRuleALSTypeScope" | ||
2675 | // InternalAlloyLanguage.g:905:1: entryRuleALSTypeScope : ruleALSTypeScope EOF ; | ||
2676 | public final void entryRuleALSTypeScope() throws RecognitionException { | ||
2677 | try { | ||
2678 | // InternalAlloyLanguage.g:906:1: ( ruleALSTypeScope EOF ) | ||
2679 | // InternalAlloyLanguage.g:907:1: ruleALSTypeScope EOF | ||
2680 | { | ||
2681 | if ( state.backtracking==0 ) { | ||
2682 | before(grammarAccess.getALSTypeScopeRule()); | ||
2683 | } | ||
2684 | pushFollow(FOLLOW_1); | ||
2685 | ruleALSTypeScope(); | ||
2686 | |||
2687 | state._fsp--; | ||
2688 | if (state.failed) return ; | ||
2689 | if ( state.backtracking==0 ) { | ||
2690 | after(grammarAccess.getALSTypeScopeRule()); | ||
2691 | } | ||
2692 | match(input,EOF,FOLLOW_2); if (state.failed) return ; | ||
2693 | |||
2694 | } | ||
2695 | |||
2696 | } | ||
2697 | catch (RecognitionException re) { | ||
2698 | reportError(re); | ||
2699 | recover(input,re); | ||
2700 | } | ||
2701 | finally { | ||
2702 | } | ||
2703 | return ; | ||
2704 | } | ||
2705 | // $ANTLR end "entryRuleALSTypeScope" | ||
2706 | |||
2707 | |||
2708 | // $ANTLR start "ruleALSTypeScope" | ||
2709 | // InternalAlloyLanguage.g:914:1: ruleALSTypeScope : ( ( rule__ALSTypeScope__Alternatives ) ) ; | ||
2710 | public final void ruleALSTypeScope() throws RecognitionException { | ||
2711 | |||
2712 | int stackSize = keepStackSize(); | ||
2713 | |||
2714 | try { | ||
2715 | // InternalAlloyLanguage.g:918:2: ( ( ( rule__ALSTypeScope__Alternatives ) ) ) | ||
2716 | // InternalAlloyLanguage.g:919:1: ( ( rule__ALSTypeScope__Alternatives ) ) | ||
2717 | { | ||
2718 | // InternalAlloyLanguage.g:919:1: ( ( rule__ALSTypeScope__Alternatives ) ) | ||
2719 | // InternalAlloyLanguage.g:920:1: ( rule__ALSTypeScope__Alternatives ) | ||
2720 | { | ||
2721 | if ( state.backtracking==0 ) { | ||
2722 | before(grammarAccess.getALSTypeScopeAccess().getAlternatives()); | ||
2723 | } | ||
2724 | // InternalAlloyLanguage.g:921:1: ( rule__ALSTypeScope__Alternatives ) | ||
2725 | // InternalAlloyLanguage.g:921:2: rule__ALSTypeScope__Alternatives | ||
2726 | { | ||
2727 | pushFollow(FOLLOW_2); | ||
2728 | rule__ALSTypeScope__Alternatives(); | ||
2729 | |||
2730 | state._fsp--; | ||
2731 | if (state.failed) return ; | ||
2732 | |||
2733 | } | ||
2734 | |||
2735 | if ( state.backtracking==0 ) { | ||
2736 | after(grammarAccess.getALSTypeScopeAccess().getAlternatives()); | ||
2737 | } | ||
2738 | |||
2739 | } | ||
2740 | |||
2741 | |||
2742 | } | ||
2743 | |||
2744 | } | ||
2745 | catch (RecognitionException re) { | ||
2746 | reportError(re); | ||
2747 | recover(input,re); | ||
2748 | } | ||
2749 | finally { | ||
2750 | |||
2751 | restoreStackSize(stackSize); | ||
2752 | |||
2753 | } | ||
2754 | return ; | ||
2755 | } | ||
2756 | // $ANTLR end "ruleALSTypeScope" | ||
2757 | |||
2758 | |||
2759 | // $ANTLR start "entryRuleALSSigScope" | ||
2760 | // InternalAlloyLanguage.g:933:1: entryRuleALSSigScope : ruleALSSigScope EOF ; | ||
2761 | public final void entryRuleALSSigScope() throws RecognitionException { | ||
2762 | try { | ||
2763 | // InternalAlloyLanguage.g:934:1: ( ruleALSSigScope EOF ) | ||
2764 | // InternalAlloyLanguage.g:935:1: ruleALSSigScope EOF | ||
2765 | { | ||
2766 | if ( state.backtracking==0 ) { | ||
2767 | before(grammarAccess.getALSSigScopeRule()); | ||
2768 | } | ||
2769 | pushFollow(FOLLOW_1); | ||
2770 | ruleALSSigScope(); | ||
2771 | |||
2772 | state._fsp--; | ||
2773 | if (state.failed) return ; | ||
2774 | if ( state.backtracking==0 ) { | ||
2775 | after(grammarAccess.getALSSigScopeRule()); | ||
2776 | } | ||
2777 | match(input,EOF,FOLLOW_2); if (state.failed) return ; | ||
2778 | |||
2779 | } | ||
2780 | |||
2781 | } | ||
2782 | catch (RecognitionException re) { | ||
2783 | reportError(re); | ||
2784 | recover(input,re); | ||
2785 | } | ||
2786 | finally { | ||
2787 | } | ||
2788 | return ; | ||
2789 | } | ||
2790 | // $ANTLR end "entryRuleALSSigScope" | ||
2791 | |||
2792 | |||
2793 | // $ANTLR start "ruleALSSigScope" | ||
2794 | // InternalAlloyLanguage.g:942:1: ruleALSSigScope : ( ( rule__ALSSigScope__Group__0 ) ) ; | ||
2795 | public final void ruleALSSigScope() throws RecognitionException { | ||
2796 | |||
2797 | int stackSize = keepStackSize(); | ||
2798 | |||
2799 | try { | ||
2800 | // InternalAlloyLanguage.g:946:2: ( ( ( rule__ALSSigScope__Group__0 ) ) ) | ||
2801 | // InternalAlloyLanguage.g:947:1: ( ( rule__ALSSigScope__Group__0 ) ) | ||
2802 | { | ||
2803 | // InternalAlloyLanguage.g:947:1: ( ( rule__ALSSigScope__Group__0 ) ) | ||
2804 | // InternalAlloyLanguage.g:948:1: ( rule__ALSSigScope__Group__0 ) | ||
2805 | { | ||
2806 | if ( state.backtracking==0 ) { | ||
2807 | before(grammarAccess.getALSSigScopeAccess().getGroup()); | ||
2808 | } | ||
2809 | // InternalAlloyLanguage.g:949:1: ( rule__ALSSigScope__Group__0 ) | ||
2810 | // InternalAlloyLanguage.g:949:2: rule__ALSSigScope__Group__0 | ||
2811 | { | ||
2812 | pushFollow(FOLLOW_2); | ||
2813 | rule__ALSSigScope__Group__0(); | ||
2814 | |||
2815 | state._fsp--; | ||
2816 | if (state.failed) return ; | ||
2817 | |||
2818 | } | ||
2819 | |||
2820 | if ( state.backtracking==0 ) { | ||
2821 | after(grammarAccess.getALSSigScopeAccess().getGroup()); | ||
2822 | } | ||
2823 | |||
2824 | } | ||
2825 | |||
2826 | |||
2827 | } | ||
2828 | |||
2829 | } | ||
2830 | catch (RecognitionException re) { | ||
2831 | reportError(re); | ||
2832 | recover(input,re); | ||
2833 | } | ||
2834 | finally { | ||
2835 | |||
2836 | restoreStackSize(stackSize); | ||
2837 | |||
2838 | } | ||
2839 | return ; | ||
2840 | } | ||
2841 | // $ANTLR end "ruleALSSigScope" | ||
2842 | |||
2843 | |||
2844 | // $ANTLR start "entryRuleALSIntScope" | ||
2845 | // InternalAlloyLanguage.g:961:1: entryRuleALSIntScope : ruleALSIntScope EOF ; | ||
2846 | public final void entryRuleALSIntScope() throws RecognitionException { | ||
2847 | try { | ||
2848 | // InternalAlloyLanguage.g:962:1: ( ruleALSIntScope EOF ) | ||
2849 | // InternalAlloyLanguage.g:963:1: ruleALSIntScope EOF | ||
2850 | { | ||
2851 | if ( state.backtracking==0 ) { | ||
2852 | before(grammarAccess.getALSIntScopeRule()); | ||
2853 | } | ||
2854 | pushFollow(FOLLOW_1); | ||
2855 | ruleALSIntScope(); | ||
2856 | |||
2857 | state._fsp--; | ||
2858 | if (state.failed) return ; | ||
2859 | if ( state.backtracking==0 ) { | ||
2860 | after(grammarAccess.getALSIntScopeRule()); | ||
2861 | } | ||
2862 | match(input,EOF,FOLLOW_2); if (state.failed) return ; | ||
2863 | |||
2864 | } | ||
2865 | |||
2866 | } | ||
2867 | catch (RecognitionException re) { | ||
2868 | reportError(re); | ||
2869 | recover(input,re); | ||
2870 | } | ||
2871 | finally { | ||
2872 | } | ||
2873 | return ; | ||
2874 | } | ||
2875 | // $ANTLR end "entryRuleALSIntScope" | ||
2876 | |||
2877 | |||
2878 | // $ANTLR start "ruleALSIntScope" | ||
2879 | // InternalAlloyLanguage.g:970:1: ruleALSIntScope : ( ( rule__ALSIntScope__Group__0 ) ) ; | ||
2880 | public final void ruleALSIntScope() throws RecognitionException { | ||
2881 | |||
2882 | int stackSize = keepStackSize(); | ||
2883 | |||
2884 | try { | ||
2885 | // InternalAlloyLanguage.g:974:2: ( ( ( rule__ALSIntScope__Group__0 ) ) ) | ||
2886 | // InternalAlloyLanguage.g:975:1: ( ( rule__ALSIntScope__Group__0 ) ) | ||
2887 | { | ||
2888 | // InternalAlloyLanguage.g:975:1: ( ( rule__ALSIntScope__Group__0 ) ) | ||
2889 | // InternalAlloyLanguage.g:976:1: ( rule__ALSIntScope__Group__0 ) | ||
2890 | { | ||
2891 | if ( state.backtracking==0 ) { | ||
2892 | before(grammarAccess.getALSIntScopeAccess().getGroup()); | ||
2893 | } | ||
2894 | // InternalAlloyLanguage.g:977:1: ( rule__ALSIntScope__Group__0 ) | ||
2895 | // InternalAlloyLanguage.g:977:2: rule__ALSIntScope__Group__0 | ||
2896 | { | ||
2897 | pushFollow(FOLLOW_2); | ||
2898 | rule__ALSIntScope__Group__0(); | ||
2899 | |||
2900 | state._fsp--; | ||
2901 | if (state.failed) return ; | ||
2902 | |||
2903 | } | ||
2904 | |||
2905 | if ( state.backtracking==0 ) { | ||
2906 | after(grammarAccess.getALSIntScopeAccess().getGroup()); | ||
2907 | } | ||
2908 | |||
2909 | } | ||
2910 | |||
2911 | |||
2912 | } | ||
2913 | |||
2914 | } | ||
2915 | catch (RecognitionException re) { | ||
2916 | reportError(re); | ||
2917 | recover(input,re); | ||
2918 | } | ||
2919 | finally { | ||
2920 | |||
2921 | restoreStackSize(stackSize); | ||
2922 | |||
2923 | } | ||
2924 | return ; | ||
2925 | } | ||
2926 | // $ANTLR end "ruleALSIntScope" | ||
2927 | |||
2928 | |||
2929 | // $ANTLR start "entryRuleALSStringScope" | ||
2930 | // InternalAlloyLanguage.g:989:1: entryRuleALSStringScope : ruleALSStringScope EOF ; | ||
2931 | public final void entryRuleALSStringScope() throws RecognitionException { | ||
2932 | try { | ||
2933 | // InternalAlloyLanguage.g:990:1: ( ruleALSStringScope EOF ) | ||
2934 | // InternalAlloyLanguage.g:991:1: ruleALSStringScope EOF | ||
2935 | { | ||
2936 | if ( state.backtracking==0 ) { | ||
2937 | before(grammarAccess.getALSStringScopeRule()); | ||
2938 | } | ||
2939 | pushFollow(FOLLOW_1); | ||
2940 | ruleALSStringScope(); | ||
2941 | |||
2942 | state._fsp--; | ||
2943 | if (state.failed) return ; | ||
2944 | if ( state.backtracking==0 ) { | ||
2945 | after(grammarAccess.getALSStringScopeRule()); | ||
2946 | } | ||
2947 | match(input,EOF,FOLLOW_2); if (state.failed) return ; | ||
2948 | |||
2949 | } | ||
2950 | |||
2951 | } | ||
2952 | catch (RecognitionException re) { | ||
2953 | reportError(re); | ||
2954 | recover(input,re); | ||
2955 | } | ||
2956 | finally { | ||
2957 | } | ||
2958 | return ; | ||
2959 | } | ||
2960 | // $ANTLR end "entryRuleALSStringScope" | ||
2961 | |||
2962 | |||
2963 | // $ANTLR start "ruleALSStringScope" | ||
2964 | // InternalAlloyLanguage.g:998:1: ruleALSStringScope : ( ( rule__ALSStringScope__Group__0 ) ) ; | ||
2965 | public final void ruleALSStringScope() throws RecognitionException { | ||
2966 | |||
2967 | int stackSize = keepStackSize(); | ||
2968 | |||
2969 | try { | ||
2970 | // InternalAlloyLanguage.g:1002:2: ( ( ( rule__ALSStringScope__Group__0 ) ) ) | ||
2971 | // InternalAlloyLanguage.g:1003:1: ( ( rule__ALSStringScope__Group__0 ) ) | ||
2972 | { | ||
2973 | // InternalAlloyLanguage.g:1003:1: ( ( rule__ALSStringScope__Group__0 ) ) | ||
2974 | // InternalAlloyLanguage.g:1004:1: ( rule__ALSStringScope__Group__0 ) | ||
2975 | { | ||
2976 | if ( state.backtracking==0 ) { | ||
2977 | before(grammarAccess.getALSStringScopeAccess().getGroup()); | ||
2978 | } | ||
2979 | // InternalAlloyLanguage.g:1005:1: ( rule__ALSStringScope__Group__0 ) | ||
2980 | // InternalAlloyLanguage.g:1005:2: rule__ALSStringScope__Group__0 | ||
2981 | { | ||
2982 | pushFollow(FOLLOW_2); | ||
2983 | rule__ALSStringScope__Group__0(); | ||
2984 | |||
2985 | state._fsp--; | ||
2986 | if (state.failed) return ; | ||
2987 | |||
2988 | } | ||
2989 | |||
2990 | if ( state.backtracking==0 ) { | ||
2991 | after(grammarAccess.getALSStringScopeAccess().getGroup()); | ||
2992 | } | ||
2993 | |||
2994 | } | ||
2995 | |||
2996 | |||
2997 | } | ||
2998 | |||
2999 | } | ||
3000 | catch (RecognitionException re) { | ||
3001 | reportError(re); | ||
3002 | recover(input,re); | ||
3003 | } | ||
3004 | finally { | ||
3005 | |||
3006 | restoreStackSize(stackSize); | ||
3007 | |||
3008 | } | ||
3009 | return ; | ||
3010 | } | ||
3011 | // $ANTLR end "ruleALSStringScope" | ||
3012 | |||
3013 | |||
3014 | // $ANTLR start "ruleALSMultiplicity" | ||
3015 | // InternalAlloyLanguage.g:1018:1: ruleALSMultiplicity : ( ( rule__ALSMultiplicity__Alternatives ) ) ; | ||
3016 | public final void ruleALSMultiplicity() throws RecognitionException { | ||
3017 | |||
3018 | int stackSize = keepStackSize(); | ||
3019 | |||
3020 | try { | ||
3021 | // InternalAlloyLanguage.g:1022:1: ( ( ( rule__ALSMultiplicity__Alternatives ) ) ) | ||
3022 | // InternalAlloyLanguage.g:1023:1: ( ( rule__ALSMultiplicity__Alternatives ) ) | ||
3023 | { | ||
3024 | // InternalAlloyLanguage.g:1023:1: ( ( rule__ALSMultiplicity__Alternatives ) ) | ||
3025 | // InternalAlloyLanguage.g:1024:1: ( rule__ALSMultiplicity__Alternatives ) | ||
3026 | { | ||
3027 | if ( state.backtracking==0 ) { | ||
3028 | before(grammarAccess.getALSMultiplicityAccess().getAlternatives()); | ||
3029 | } | ||
3030 | // InternalAlloyLanguage.g:1025:1: ( rule__ALSMultiplicity__Alternatives ) | ||
3031 | // InternalAlloyLanguage.g:1025:2: rule__ALSMultiplicity__Alternatives | ||
3032 | { | ||
3033 | pushFollow(FOLLOW_2); | ||
3034 | rule__ALSMultiplicity__Alternatives(); | ||
3035 | |||
3036 | state._fsp--; | ||
3037 | if (state.failed) return ; | ||
3038 | |||
3039 | } | ||
3040 | |||
3041 | if ( state.backtracking==0 ) { | ||
3042 | after(grammarAccess.getALSMultiplicityAccess().getAlternatives()); | ||
3043 | } | ||
3044 | |||
3045 | } | ||
3046 | |||
3047 | |||
3048 | } | ||
3049 | |||
3050 | } | ||
3051 | catch (RecognitionException re) { | ||
3052 | reportError(re); | ||
3053 | recover(input,re); | ||
3054 | } | ||
3055 | finally { | ||
3056 | |||
3057 | restoreStackSize(stackSize); | ||
3058 | |||
3059 | } | ||
3060 | return ; | ||
3061 | } | ||
3062 | // $ANTLR end "ruleALSMultiplicity" | ||
3063 | |||
3064 | |||
3065 | // $ANTLR start "ruleALSNumericOperator" | ||
3066 | // InternalAlloyLanguage.g:1037:1: ruleALSNumericOperator : ( ( rule__ALSNumericOperator__Alternatives ) ) ; | ||
3067 | public final void ruleALSNumericOperator() throws RecognitionException { | ||
3068 | |||
3069 | int stackSize = keepStackSize(); | ||
3070 | |||
3071 | try { | ||
3072 | // InternalAlloyLanguage.g:1041:1: ( ( ( rule__ALSNumericOperator__Alternatives ) ) ) | ||
3073 | // InternalAlloyLanguage.g:1042:1: ( ( rule__ALSNumericOperator__Alternatives ) ) | ||
3074 | { | ||
3075 | // InternalAlloyLanguage.g:1042:1: ( ( rule__ALSNumericOperator__Alternatives ) ) | ||
3076 | // InternalAlloyLanguage.g:1043:1: ( rule__ALSNumericOperator__Alternatives ) | ||
3077 | { | ||
3078 | if ( state.backtracking==0 ) { | ||
3079 | before(grammarAccess.getALSNumericOperatorAccess().getAlternatives()); | ||
3080 | } | ||
3081 | // InternalAlloyLanguage.g:1044:1: ( rule__ALSNumericOperator__Alternatives ) | ||
3082 | // InternalAlloyLanguage.g:1044:2: rule__ALSNumericOperator__Alternatives | ||
3083 | { | ||
3084 | pushFollow(FOLLOW_2); | ||
3085 | rule__ALSNumericOperator__Alternatives(); | ||
3086 | |||
3087 | state._fsp--; | ||
3088 | if (state.failed) return ; | ||
3089 | |||
3090 | } | ||
3091 | |||
3092 | if ( state.backtracking==0 ) { | ||
3093 | after(grammarAccess.getALSNumericOperatorAccess().getAlternatives()); | ||
3094 | } | ||
3095 | |||
3096 | } | ||
3097 | |||
3098 | |||
3099 | } | ||
3100 | |||
3101 | } | ||
3102 | catch (RecognitionException re) { | ||
3103 | reportError(re); | ||
3104 | recover(input,re); | ||
3105 | } | ||
3106 | finally { | ||
3107 | |||
3108 | restoreStackSize(stackSize); | ||
3109 | |||
3110 | } | ||
3111 | return ; | ||
3112 | } | ||
3113 | // $ANTLR end "ruleALSNumericOperator" | ||
3114 | |||
3115 | |||
3116 | // $ANTLR start "rule__ALSDocument__Alternatives_0" | ||
3117 | // InternalAlloyLanguage.g:1055:1: rule__ALSDocument__Alternatives_0 : ( ( ( rule__ALSDocument__EnumDeclarationsAssignment_0_0 ) ) | ( ( rule__ALSDocument__SignatureBodiesAssignment_0_1 ) ) | ( ( rule__ALSDocument__FunctionDefinitionsAssignment_0_2 ) ) | ( ( rule__ALSDocument__RelationDefinitionsAssignment_0_3 ) ) | ( ( rule__ALSDocument__FactDeclarationsAssignment_0_4 ) ) ); | ||
3118 | public final void rule__ALSDocument__Alternatives_0() throws RecognitionException { | ||
3119 | |||
3120 | int stackSize = keepStackSize(); | ||
3121 | |||
3122 | try { | ||
3123 | // InternalAlloyLanguage.g:1059:1: ( ( ( rule__ALSDocument__EnumDeclarationsAssignment_0_0 ) ) | ( ( rule__ALSDocument__SignatureBodiesAssignment_0_1 ) ) | ( ( rule__ALSDocument__FunctionDefinitionsAssignment_0_2 ) ) | ( ( rule__ALSDocument__RelationDefinitionsAssignment_0_3 ) ) | ( ( rule__ALSDocument__FactDeclarationsAssignment_0_4 ) ) ) | ||
3124 | int alt1=5; | ||
3125 | switch ( input.LA(1) ) { | ||
3126 | case 32: | ||
3127 | { | ||
3128 | alt1=1; | ||
3129 | } | ||
3130 | break; | ||
3131 | case 21: | ||
3132 | case 22: | ||
3133 | case 23: | ||
3134 | case 24: | ||
3135 | case 25: | ||
3136 | case 26: | ||
3137 | case 36: | ||
3138 | case 75: | ||
3139 | { | ||
3140 | alt1=2; | ||
3141 | } | ||
3142 | break; | ||
3143 | case 41: | ||
3144 | { | ||
3145 | alt1=3; | ||
3146 | } | ||
3147 | break; | ||
3148 | case 44: | ||
3149 | { | ||
3150 | alt1=4; | ||
3151 | } | ||
3152 | break; | ||
3153 | case 45: | ||
3154 | { | ||
3155 | alt1=5; | ||
3156 | } | ||
3157 | break; | ||
3158 | default: | ||
3159 | if (state.backtracking>0) {state.failed=true; return ;} | ||
3160 | NoViableAltException nvae = | ||
3161 | new NoViableAltException("", 1, 0, input); | ||
3162 | |||
3163 | throw nvae; | ||
3164 | } | ||
3165 | |||
3166 | switch (alt1) { | ||
3167 | case 1 : | ||
3168 | // InternalAlloyLanguage.g:1060:1: ( ( rule__ALSDocument__EnumDeclarationsAssignment_0_0 ) ) | ||
3169 | { | ||
3170 | // InternalAlloyLanguage.g:1060:1: ( ( rule__ALSDocument__EnumDeclarationsAssignment_0_0 ) ) | ||
3171 | // InternalAlloyLanguage.g:1061:1: ( rule__ALSDocument__EnumDeclarationsAssignment_0_0 ) | ||
3172 | { | ||
3173 | if ( state.backtracking==0 ) { | ||
3174 | before(grammarAccess.getALSDocumentAccess().getEnumDeclarationsAssignment_0_0()); | ||
3175 | } | ||
3176 | // InternalAlloyLanguage.g:1062:1: ( rule__ALSDocument__EnumDeclarationsAssignment_0_0 ) | ||
3177 | // InternalAlloyLanguage.g:1062:2: rule__ALSDocument__EnumDeclarationsAssignment_0_0 | ||
3178 | { | ||
3179 | pushFollow(FOLLOW_2); | ||
3180 | rule__ALSDocument__EnumDeclarationsAssignment_0_0(); | ||
3181 | |||
3182 | state._fsp--; | ||
3183 | if (state.failed) return ; | ||
3184 | |||
3185 | } | ||
3186 | |||
3187 | if ( state.backtracking==0 ) { | ||
3188 | after(grammarAccess.getALSDocumentAccess().getEnumDeclarationsAssignment_0_0()); | ||
3189 | } | ||
3190 | |||
3191 | } | ||
3192 | |||
3193 | |||
3194 | } | ||
3195 | break; | ||
3196 | case 2 : | ||
3197 | // InternalAlloyLanguage.g:1066:6: ( ( rule__ALSDocument__SignatureBodiesAssignment_0_1 ) ) | ||
3198 | { | ||
3199 | // InternalAlloyLanguage.g:1066:6: ( ( rule__ALSDocument__SignatureBodiesAssignment_0_1 ) ) | ||
3200 | // InternalAlloyLanguage.g:1067:1: ( rule__ALSDocument__SignatureBodiesAssignment_0_1 ) | ||
3201 | { | ||
3202 | if ( state.backtracking==0 ) { | ||
3203 | before(grammarAccess.getALSDocumentAccess().getSignatureBodiesAssignment_0_1()); | ||
3204 | } | ||
3205 | // InternalAlloyLanguage.g:1068:1: ( rule__ALSDocument__SignatureBodiesAssignment_0_1 ) | ||
3206 | // InternalAlloyLanguage.g:1068:2: rule__ALSDocument__SignatureBodiesAssignment_0_1 | ||
3207 | { | ||
3208 | pushFollow(FOLLOW_2); | ||
3209 | rule__ALSDocument__SignatureBodiesAssignment_0_1(); | ||
3210 | |||
3211 | state._fsp--; | ||
3212 | if (state.failed) return ; | ||
3213 | |||
3214 | } | ||
3215 | |||
3216 | if ( state.backtracking==0 ) { | ||
3217 | after(grammarAccess.getALSDocumentAccess().getSignatureBodiesAssignment_0_1()); | ||
3218 | } | ||
3219 | |||
3220 | } | ||
3221 | |||
3222 | |||
3223 | } | ||
3224 | break; | ||
3225 | case 3 : | ||
3226 | // InternalAlloyLanguage.g:1072:6: ( ( rule__ALSDocument__FunctionDefinitionsAssignment_0_2 ) ) | ||
3227 | { | ||
3228 | // InternalAlloyLanguage.g:1072:6: ( ( rule__ALSDocument__FunctionDefinitionsAssignment_0_2 ) ) | ||
3229 | // InternalAlloyLanguage.g:1073:1: ( rule__ALSDocument__FunctionDefinitionsAssignment_0_2 ) | ||
3230 | { | ||
3231 | if ( state.backtracking==0 ) { | ||
3232 | before(grammarAccess.getALSDocumentAccess().getFunctionDefinitionsAssignment_0_2()); | ||
3233 | } | ||
3234 | // InternalAlloyLanguage.g:1074:1: ( rule__ALSDocument__FunctionDefinitionsAssignment_0_2 ) | ||
3235 | // InternalAlloyLanguage.g:1074:2: rule__ALSDocument__FunctionDefinitionsAssignment_0_2 | ||
3236 | { | ||
3237 | pushFollow(FOLLOW_2); | ||
3238 | rule__ALSDocument__FunctionDefinitionsAssignment_0_2(); | ||
3239 | |||
3240 | state._fsp--; | ||
3241 | if (state.failed) return ; | ||
3242 | |||
3243 | } | ||
3244 | |||
3245 | if ( state.backtracking==0 ) { | ||
3246 | after(grammarAccess.getALSDocumentAccess().getFunctionDefinitionsAssignment_0_2()); | ||
3247 | } | ||
3248 | |||
3249 | } | ||
3250 | |||
3251 | |||
3252 | } | ||
3253 | break; | ||
3254 | case 4 : | ||
3255 | // InternalAlloyLanguage.g:1078:6: ( ( rule__ALSDocument__RelationDefinitionsAssignment_0_3 ) ) | ||
3256 | { | ||
3257 | // InternalAlloyLanguage.g:1078:6: ( ( rule__ALSDocument__RelationDefinitionsAssignment_0_3 ) ) | ||
3258 | // InternalAlloyLanguage.g:1079:1: ( rule__ALSDocument__RelationDefinitionsAssignment_0_3 ) | ||
3259 | { | ||
3260 | if ( state.backtracking==0 ) { | ||
3261 | before(grammarAccess.getALSDocumentAccess().getRelationDefinitionsAssignment_0_3()); | ||
3262 | } | ||
3263 | // InternalAlloyLanguage.g:1080:1: ( rule__ALSDocument__RelationDefinitionsAssignment_0_3 ) | ||
3264 | // InternalAlloyLanguage.g:1080:2: rule__ALSDocument__RelationDefinitionsAssignment_0_3 | ||
3265 | { | ||
3266 | pushFollow(FOLLOW_2); | ||
3267 | rule__ALSDocument__RelationDefinitionsAssignment_0_3(); | ||
3268 | |||
3269 | state._fsp--; | ||
3270 | if (state.failed) return ; | ||
3271 | |||
3272 | } | ||
3273 | |||
3274 | if ( state.backtracking==0 ) { | ||
3275 | after(grammarAccess.getALSDocumentAccess().getRelationDefinitionsAssignment_0_3()); | ||
3276 | } | ||
3277 | |||
3278 | } | ||
3279 | |||
3280 | |||
3281 | } | ||
3282 | break; | ||
3283 | case 5 : | ||
3284 | // InternalAlloyLanguage.g:1084:6: ( ( rule__ALSDocument__FactDeclarationsAssignment_0_4 ) ) | ||
3285 | { | ||
3286 | // InternalAlloyLanguage.g:1084:6: ( ( rule__ALSDocument__FactDeclarationsAssignment_0_4 ) ) | ||
3287 | // InternalAlloyLanguage.g:1085:1: ( rule__ALSDocument__FactDeclarationsAssignment_0_4 ) | ||
3288 | { | ||
3289 | if ( state.backtracking==0 ) { | ||
3290 | before(grammarAccess.getALSDocumentAccess().getFactDeclarationsAssignment_0_4()); | ||
3291 | } | ||
3292 | // InternalAlloyLanguage.g:1086:1: ( rule__ALSDocument__FactDeclarationsAssignment_0_4 ) | ||
3293 | // InternalAlloyLanguage.g:1086:2: rule__ALSDocument__FactDeclarationsAssignment_0_4 | ||
3294 | { | ||
3295 | pushFollow(FOLLOW_2); | ||
3296 | rule__ALSDocument__FactDeclarationsAssignment_0_4(); | ||
3297 | |||
3298 | state._fsp--; | ||
3299 | if (state.failed) return ; | ||
3300 | |||
3301 | } | ||
3302 | |||
3303 | if ( state.backtracking==0 ) { | ||
3304 | after(grammarAccess.getALSDocumentAccess().getFactDeclarationsAssignment_0_4()); | ||
3305 | } | ||
3306 | |||
3307 | } | ||
3308 | |||
3309 | |||
3310 | } | ||
3311 | break; | ||
3312 | |||
3313 | } | ||
3314 | } | ||
3315 | catch (RecognitionException re) { | ||
3316 | reportError(re); | ||
3317 | recover(input,re); | ||
3318 | } | ||
3319 | finally { | ||
3320 | |||
3321 | restoreStackSize(stackSize); | ||
3322 | |||
3323 | } | ||
3324 | return ; | ||
3325 | } | ||
3326 | // $ANTLR end "rule__ALSDocument__Alternatives_0" | ||
3327 | |||
3328 | |||
3329 | // $ANTLR start "rule__ALSTypeDeclaration__Alternatives" | ||
3330 | // InternalAlloyLanguage.g:1096:1: rule__ALSTypeDeclaration__Alternatives : ( ( ruleALSEnumDeclaration ) | ( ruleALSSignatureDeclaration ) ); | ||
3331 | public final void rule__ALSTypeDeclaration__Alternatives() throws RecognitionException { | ||
3332 | |||
3333 | int stackSize = keepStackSize(); | ||
3334 | |||
3335 | try { | ||
3336 | // InternalAlloyLanguage.g:1100:1: ( ( ruleALSEnumDeclaration ) | ( ruleALSSignatureDeclaration ) ) | ||
3337 | int alt2=2; | ||
3338 | int LA2_0 = input.LA(1); | ||
3339 | |||
3340 | if ( (LA2_0==32) ) { | ||
3341 | alt2=1; | ||
3342 | } | ||
3343 | else if ( (LA2_0==RULE_ID) ) { | ||
3344 | alt2=2; | ||
3345 | } | ||
3346 | else { | ||
3347 | if (state.backtracking>0) {state.failed=true; return ;} | ||
3348 | NoViableAltException nvae = | ||
3349 | new NoViableAltException("", 2, 0, input); | ||
3350 | |||
3351 | throw nvae; | ||
3352 | } | ||
3353 | switch (alt2) { | ||
3354 | case 1 : | ||
3355 | // InternalAlloyLanguage.g:1101:1: ( ruleALSEnumDeclaration ) | ||
3356 | { | ||
3357 | // InternalAlloyLanguage.g:1101:1: ( ruleALSEnumDeclaration ) | ||
3358 | // InternalAlloyLanguage.g:1102:1: ruleALSEnumDeclaration | ||
3359 | { | ||
3360 | if ( state.backtracking==0 ) { | ||
3361 | before(grammarAccess.getALSTypeDeclarationAccess().getALSEnumDeclarationParserRuleCall_0()); | ||
3362 | } | ||
3363 | pushFollow(FOLLOW_2); | ||
3364 | ruleALSEnumDeclaration(); | ||
3365 | |||
3366 | state._fsp--; | ||
3367 | if (state.failed) return ; | ||
3368 | if ( state.backtracking==0 ) { | ||
3369 | after(grammarAccess.getALSTypeDeclarationAccess().getALSEnumDeclarationParserRuleCall_0()); | ||
3370 | } | ||
3371 | |||
3372 | } | ||
3373 | |||
3374 | |||
3375 | } | ||
3376 | break; | ||
3377 | case 2 : | ||
3378 | // InternalAlloyLanguage.g:1107:6: ( ruleALSSignatureDeclaration ) | ||
3379 | { | ||
3380 | // InternalAlloyLanguage.g:1107:6: ( ruleALSSignatureDeclaration ) | ||
3381 | // InternalAlloyLanguage.g:1108:1: ruleALSSignatureDeclaration | ||
3382 | { | ||
3383 | if ( state.backtracking==0 ) { | ||
3384 | before(grammarAccess.getALSTypeDeclarationAccess().getALSSignatureDeclarationParserRuleCall_1()); | ||
3385 | } | ||
3386 | pushFollow(FOLLOW_2); | ||
3387 | ruleALSSignatureDeclaration(); | ||
3388 | |||
3389 | state._fsp--; | ||
3390 | if (state.failed) return ; | ||
3391 | if ( state.backtracking==0 ) { | ||
3392 | after(grammarAccess.getALSTypeDeclarationAccess().getALSSignatureDeclarationParserRuleCall_1()); | ||
3393 | } | ||
3394 | |||
3395 | } | ||
3396 | |||
3397 | |||
3398 | } | ||
3399 | break; | ||
3400 | |||
3401 | } | ||
3402 | } | ||
3403 | catch (RecognitionException re) { | ||
3404 | reportError(re); | ||
3405 | recover(input,re); | ||
3406 | } | ||
3407 | finally { | ||
3408 | |||
3409 | restoreStackSize(stackSize); | ||
3410 | |||
3411 | } | ||
3412 | return ; | ||
3413 | } | ||
3414 | // $ANTLR end "rule__ALSTypeDeclaration__Alternatives" | ||
3415 | |||
3416 | |||
3417 | // $ANTLR start "rule__ALSSignatureBody__Alternatives_4" | ||
3418 | // InternalAlloyLanguage.g:1118:1: rule__ALSSignatureBody__Alternatives_4 : ( ( ( rule__ALSSignatureBody__Group_4_0__0 ) ) | ( ( rule__ALSSignatureBody__Group_4_1__0 ) ) ); | ||
3419 | public final void rule__ALSSignatureBody__Alternatives_4() throws RecognitionException { | ||
3420 | |||
3421 | int stackSize = keepStackSize(); | ||
3422 | |||
3423 | try { | ||
3424 | // InternalAlloyLanguage.g:1122:1: ( ( ( rule__ALSSignatureBody__Group_4_0__0 ) ) | ( ( rule__ALSSignatureBody__Group_4_1__0 ) ) ) | ||
3425 | int alt3=2; | ||
3426 | int LA3_0 = input.LA(1); | ||
3427 | |||
3428 | if ( (LA3_0==37) ) { | ||
3429 | alt3=1; | ||
3430 | } | ||
3431 | else if ( (LA3_0==38) ) { | ||
3432 | alt3=2; | ||
3433 | } | ||
3434 | else { | ||
3435 | if (state.backtracking>0) {state.failed=true; return ;} | ||
3436 | NoViableAltException nvae = | ||
3437 | new NoViableAltException("", 3, 0, input); | ||
3438 | |||
3439 | throw nvae; | ||
3440 | } | ||
3441 | switch (alt3) { | ||
3442 | case 1 : | ||
3443 | // InternalAlloyLanguage.g:1123:1: ( ( rule__ALSSignatureBody__Group_4_0__0 ) ) | ||
3444 | { | ||
3445 | // InternalAlloyLanguage.g:1123:1: ( ( rule__ALSSignatureBody__Group_4_0__0 ) ) | ||
3446 | // InternalAlloyLanguage.g:1124:1: ( rule__ALSSignatureBody__Group_4_0__0 ) | ||
3447 | { | ||
3448 | if ( state.backtracking==0 ) { | ||
3449 | before(grammarAccess.getALSSignatureBodyAccess().getGroup_4_0()); | ||
3450 | } | ||
3451 | // InternalAlloyLanguage.g:1125:1: ( rule__ALSSignatureBody__Group_4_0__0 ) | ||
3452 | // InternalAlloyLanguage.g:1125:2: rule__ALSSignatureBody__Group_4_0__0 | ||
3453 | { | ||
3454 | pushFollow(FOLLOW_2); | ||
3455 | rule__ALSSignatureBody__Group_4_0__0(); | ||
3456 | |||
3457 | state._fsp--; | ||
3458 | if (state.failed) return ; | ||
3459 | |||
3460 | } | ||
3461 | |||
3462 | if ( state.backtracking==0 ) { | ||
3463 | after(grammarAccess.getALSSignatureBodyAccess().getGroup_4_0()); | ||
3464 | } | ||
3465 | |||
3466 | } | ||
3467 | |||
3468 | |||
3469 | } | ||
3470 | break; | ||
3471 | case 2 : | ||
3472 | // InternalAlloyLanguage.g:1129:6: ( ( rule__ALSSignatureBody__Group_4_1__0 ) ) | ||
3473 | { | ||
3474 | // InternalAlloyLanguage.g:1129:6: ( ( rule__ALSSignatureBody__Group_4_1__0 ) ) | ||
3475 | // InternalAlloyLanguage.g:1130:1: ( rule__ALSSignatureBody__Group_4_1__0 ) | ||
3476 | { | ||
3477 | if ( state.backtracking==0 ) { | ||
3478 | before(grammarAccess.getALSSignatureBodyAccess().getGroup_4_1()); | ||
3479 | } | ||
3480 | // InternalAlloyLanguage.g:1131:1: ( rule__ALSSignatureBody__Group_4_1__0 ) | ||
3481 | // InternalAlloyLanguage.g:1131:2: rule__ALSSignatureBody__Group_4_1__0 | ||
3482 | { | ||
3483 | pushFollow(FOLLOW_2); | ||
3484 | rule__ALSSignatureBody__Group_4_1__0(); | ||
3485 | |||
3486 | state._fsp--; | ||
3487 | if (state.failed) return ; | ||
3488 | |||
3489 | } | ||
3490 | |||
3491 | if ( state.backtracking==0 ) { | ||
3492 | after(grammarAccess.getALSSignatureBodyAccess().getGroup_4_1()); | ||
3493 | } | ||
3494 | |||
3495 | } | ||
3496 | |||
3497 | |||
3498 | } | ||
3499 | break; | ||
3500 | |||
3501 | } | ||
3502 | } | ||
3503 | catch (RecognitionException re) { | ||
3504 | reportError(re); | ||
3505 | recover(input,re); | ||
3506 | } | ||
3507 | finally { | ||
3508 | |||
3509 | restoreStackSize(stackSize); | ||
3510 | |||
3511 | } | ||
3512 | return ; | ||
3513 | } | ||
3514 | // $ANTLR end "rule__ALSSignatureBody__Alternatives_4" | ||
3515 | |||
3516 | |||
3517 | // $ANTLR start "rule__ALSQuantified__Alternatives" | ||
3518 | // InternalAlloyLanguage.g:1141:1: rule__ALSQuantified__Alternatives : ( ( ( rule__ALSQuantified__Group_0__0 ) ) | ( ruleALSOr ) ); | ||
3519 | public final void rule__ALSQuantified__Alternatives() throws RecognitionException { | ||
3520 | |||
3521 | int stackSize = keepStackSize(); | ||
3522 | |||
3523 | try { | ||
3524 | // InternalAlloyLanguage.g:1145:1: ( ( ( rule__ALSQuantified__Group_0__0 ) ) | ( ruleALSOr ) ) | ||
3525 | int alt4=2; | ||
3526 | int LA4_0 = input.LA(1); | ||
3527 | |||
3528 | if ( ((LA4_0>=21 && LA4_0<=26)) ) { | ||
3529 | alt4=1; | ||
3530 | } | ||
3531 | else if ( ((LA4_0>=RULE_ID && LA4_0<=RULE_STRING)||(LA4_0>=19 && LA4_0<=20)||(LA4_0>=27 && LA4_0<=31)||LA4_0==57||(LA4_0>=60 && LA4_0<=70)) ) { | ||
3532 | alt4=2; | ||
3533 | } | ||
3534 | else { | ||
3535 | if (state.backtracking>0) {state.failed=true; return ;} | ||
3536 | NoViableAltException nvae = | ||
3537 | new NoViableAltException("", 4, 0, input); | ||
3538 | |||
3539 | throw nvae; | ||
3540 | } | ||
3541 | switch (alt4) { | ||
3542 | case 1 : | ||
3543 | // InternalAlloyLanguage.g:1146:1: ( ( rule__ALSQuantified__Group_0__0 ) ) | ||
3544 | { | ||
3545 | // InternalAlloyLanguage.g:1146:1: ( ( rule__ALSQuantified__Group_0__0 ) ) | ||
3546 | // InternalAlloyLanguage.g:1147:1: ( rule__ALSQuantified__Group_0__0 ) | ||
3547 | { | ||
3548 | if ( state.backtracking==0 ) { | ||
3549 | before(grammarAccess.getALSQuantifiedAccess().getGroup_0()); | ||
3550 | } | ||
3551 | // InternalAlloyLanguage.g:1148:1: ( rule__ALSQuantified__Group_0__0 ) | ||
3552 | // InternalAlloyLanguage.g:1148:2: rule__ALSQuantified__Group_0__0 | ||
3553 | { | ||
3554 | pushFollow(FOLLOW_2); | ||
3555 | rule__ALSQuantified__Group_0__0(); | ||
3556 | |||
3557 | state._fsp--; | ||
3558 | if (state.failed) return ; | ||
3559 | |||
3560 | } | ||
3561 | |||
3562 | if ( state.backtracking==0 ) { | ||
3563 | after(grammarAccess.getALSQuantifiedAccess().getGroup_0()); | ||
3564 | } | ||
3565 | |||
3566 | } | ||
3567 | |||
3568 | |||
3569 | } | ||
3570 | break; | ||
3571 | case 2 : | ||
3572 | // InternalAlloyLanguage.g:1152:6: ( ruleALSOr ) | ||
3573 | { | ||
3574 | // InternalAlloyLanguage.g:1152:6: ( ruleALSOr ) | ||
3575 | // InternalAlloyLanguage.g:1153:1: ruleALSOr | ||
3576 | { | ||
3577 | if ( state.backtracking==0 ) { | ||
3578 | before(grammarAccess.getALSQuantifiedAccess().getALSOrParserRuleCall_1()); | ||
3579 | } | ||
3580 | pushFollow(FOLLOW_2); | ||
3581 | ruleALSOr(); | ||
3582 | |||
3583 | state._fsp--; | ||
3584 | if (state.failed) return ; | ||
3585 | if ( state.backtracking==0 ) { | ||
3586 | after(grammarAccess.getALSQuantifiedAccess().getALSOrParserRuleCall_1()); | ||
3587 | } | ||
3588 | |||
3589 | } | ||
3590 | |||
3591 | |||
3592 | } | ||
3593 | break; | ||
3594 | |||
3595 | } | ||
3596 | } | ||
3597 | catch (RecognitionException re) { | ||
3598 | reportError(re); | ||
3599 | recover(input,re); | ||
3600 | } | ||
3601 | finally { | ||
3602 | |||
3603 | restoreStackSize(stackSize); | ||
3604 | |||
3605 | } | ||
3606 | return ; | ||
3607 | } | ||
3608 | // $ANTLR end "rule__ALSQuantified__Alternatives" | ||
3609 | |||
3610 | |||
3611 | // $ANTLR start "rule__ALSOr__Alternatives_1_1" | ||
3612 | // InternalAlloyLanguage.g:1163:1: rule__ALSOr__Alternatives_1_1 : ( ( '||' ) | ( 'or' ) ); | ||
3613 | public final void rule__ALSOr__Alternatives_1_1() throws RecognitionException { | ||
3614 | |||
3615 | int stackSize = keepStackSize(); | ||
3616 | |||
3617 | try { | ||
3618 | // InternalAlloyLanguage.g:1167:1: ( ( '||' ) | ( 'or' ) ) | ||
3619 | int alt5=2; | ||
3620 | int LA5_0 = input.LA(1); | ||
3621 | |||
3622 | if ( (LA5_0==11) ) { | ||
3623 | alt5=1; | ||
3624 | } | ||
3625 | else if ( (LA5_0==12) ) { | ||
3626 | alt5=2; | ||
3627 | } | ||
3628 | else { | ||
3629 | if (state.backtracking>0) {state.failed=true; return ;} | ||
3630 | NoViableAltException nvae = | ||
3631 | new NoViableAltException("", 5, 0, input); | ||
3632 | |||
3633 | throw nvae; | ||
3634 | } | ||
3635 | switch (alt5) { | ||
3636 | case 1 : | ||
3637 | // InternalAlloyLanguage.g:1168:1: ( '||' ) | ||
3638 | { | ||
3639 | // InternalAlloyLanguage.g:1168:1: ( '||' ) | ||
3640 | // InternalAlloyLanguage.g:1169:1: '||' | ||
3641 | { | ||
3642 | if ( state.backtracking==0 ) { | ||
3643 | before(grammarAccess.getALSOrAccess().getVerticalLineVerticalLineKeyword_1_1_0()); | ||
3644 | } | ||
3645 | match(input,11,FOLLOW_2); if (state.failed) return ; | ||
3646 | if ( state.backtracking==0 ) { | ||
3647 | after(grammarAccess.getALSOrAccess().getVerticalLineVerticalLineKeyword_1_1_0()); | ||
3648 | } | ||
3649 | |||
3650 | } | ||
3651 | |||
3652 | |||
3653 | } | ||
3654 | break; | ||
3655 | case 2 : | ||
3656 | // InternalAlloyLanguage.g:1176:6: ( 'or' ) | ||
3657 | { | ||
3658 | // InternalAlloyLanguage.g:1176:6: ( 'or' ) | ||
3659 | // InternalAlloyLanguage.g:1177:1: 'or' | ||
3660 | { | ||
3661 | if ( state.backtracking==0 ) { | ||
3662 | before(grammarAccess.getALSOrAccess().getOrKeyword_1_1_1()); | ||
3663 | } | ||
3664 | match(input,12,FOLLOW_2); if (state.failed) return ; | ||
3665 | if ( state.backtracking==0 ) { | ||
3666 | after(grammarAccess.getALSOrAccess().getOrKeyword_1_1_1()); | ||
3667 | } | ||
3668 | |||
3669 | } | ||
3670 | |||
3671 | |||
3672 | } | ||
3673 | break; | ||
3674 | |||
3675 | } | ||
3676 | } | ||
3677 | catch (RecognitionException re) { | ||
3678 | reportError(re); | ||
3679 | recover(input,re); | ||
3680 | } | ||
3681 | finally { | ||
3682 | |||
3683 | restoreStackSize(stackSize); | ||
3684 | |||
3685 | } | ||
3686 | return ; | ||
3687 | } | ||
3688 | // $ANTLR end "rule__ALSOr__Alternatives_1_1" | ||
3689 | |||
3690 | |||
3691 | // $ANTLR start "rule__ALSIff__Alternatives_1_1" | ||
3692 | // InternalAlloyLanguage.g:1189:1: rule__ALSIff__Alternatives_1_1 : ( ( '<=>' ) | ( 'iff' ) ); | ||
3693 | public final void rule__ALSIff__Alternatives_1_1() throws RecognitionException { | ||
3694 | |||
3695 | int stackSize = keepStackSize(); | ||
3696 | |||
3697 | try { | ||
3698 | // InternalAlloyLanguage.g:1193:1: ( ( '<=>' ) | ( 'iff' ) ) | ||
3699 | int alt6=2; | ||
3700 | int LA6_0 = input.LA(1); | ||
3701 | |||
3702 | if ( (LA6_0==13) ) { | ||
3703 | alt6=1; | ||
3704 | } | ||
3705 | else if ( (LA6_0==14) ) { | ||
3706 | alt6=2; | ||
3707 | } | ||
3708 | else { | ||
3709 | if (state.backtracking>0) {state.failed=true; return ;} | ||
3710 | NoViableAltException nvae = | ||
3711 | new NoViableAltException("", 6, 0, input); | ||
3712 | |||
3713 | throw nvae; | ||
3714 | } | ||
3715 | switch (alt6) { | ||
3716 | case 1 : | ||
3717 | // InternalAlloyLanguage.g:1194:1: ( '<=>' ) | ||
3718 | { | ||
3719 | // InternalAlloyLanguage.g:1194:1: ( '<=>' ) | ||
3720 | // InternalAlloyLanguage.g:1195:1: '<=>' | ||
3721 | { | ||
3722 | if ( state.backtracking==0 ) { | ||
3723 | before(grammarAccess.getALSIffAccess().getLessThanSignEqualsSignGreaterThanSignKeyword_1_1_0()); | ||
3724 | } | ||
3725 | match(input,13,FOLLOW_2); if (state.failed) return ; | ||
3726 | if ( state.backtracking==0 ) { | ||
3727 | after(grammarAccess.getALSIffAccess().getLessThanSignEqualsSignGreaterThanSignKeyword_1_1_0()); | ||
3728 | } | ||
3729 | |||
3730 | } | ||
3731 | |||
3732 | |||
3733 | } | ||
3734 | break; | ||
3735 | case 2 : | ||
3736 | // InternalAlloyLanguage.g:1202:6: ( 'iff' ) | ||
3737 | { | ||
3738 | // InternalAlloyLanguage.g:1202:6: ( 'iff' ) | ||
3739 | // InternalAlloyLanguage.g:1203:1: 'iff' | ||
3740 | { | ||
3741 | if ( state.backtracking==0 ) { | ||
3742 | before(grammarAccess.getALSIffAccess().getIffKeyword_1_1_1()); | ||
3743 | } | ||
3744 | match(input,14,FOLLOW_2); if (state.failed) return ; | ||
3745 | if ( state.backtracking==0 ) { | ||
3746 | after(grammarAccess.getALSIffAccess().getIffKeyword_1_1_1()); | ||
3747 | } | ||
3748 | |||
3749 | } | ||
3750 | |||
3751 | |||
3752 | } | ||
3753 | break; | ||
3754 | |||
3755 | } | ||
3756 | } | ||
3757 | catch (RecognitionException re) { | ||
3758 | reportError(re); | ||
3759 | recover(input,re); | ||
3760 | } | ||
3761 | finally { | ||
3762 | |||
3763 | restoreStackSize(stackSize); | ||
3764 | |||
3765 | } | ||
3766 | return ; | ||
3767 | } | ||
3768 | // $ANTLR end "rule__ALSIff__Alternatives_1_1" | ||
3769 | |||
3770 | |||
3771 | // $ANTLR start "rule__ALSImpl__Alternatives_1_1" | ||
3772 | // InternalAlloyLanguage.g:1215:1: rule__ALSImpl__Alternatives_1_1 : ( ( '=>' ) | ( 'implies' ) ); | ||
3773 | public final void rule__ALSImpl__Alternatives_1_1() throws RecognitionException { | ||
3774 | |||
3775 | int stackSize = keepStackSize(); | ||
3776 | |||
3777 | try { | ||
3778 | // InternalAlloyLanguage.g:1219:1: ( ( '=>' ) | ( 'implies' ) ) | ||
3779 | int alt7=2; | ||
3780 | int LA7_0 = input.LA(1); | ||
3781 | |||
3782 | if ( (LA7_0==15) ) { | ||
3783 | alt7=1; | ||
3784 | } | ||
3785 | else if ( (LA7_0==16) ) { | ||
3786 | alt7=2; | ||
3787 | } | ||
3788 | else { | ||
3789 | if (state.backtracking>0) {state.failed=true; return ;} | ||
3790 | NoViableAltException nvae = | ||
3791 | new NoViableAltException("", 7, 0, input); | ||
3792 | |||
3793 | throw nvae; | ||
3794 | } | ||
3795 | switch (alt7) { | ||
3796 | case 1 : | ||
3797 | // InternalAlloyLanguage.g:1220:1: ( '=>' ) | ||
3798 | { | ||
3799 | // InternalAlloyLanguage.g:1220:1: ( '=>' ) | ||
3800 | // InternalAlloyLanguage.g:1221:1: '=>' | ||
3801 | { | ||
3802 | if ( state.backtracking==0 ) { | ||
3803 | before(grammarAccess.getALSImplAccess().getEqualsSignGreaterThanSignKeyword_1_1_0()); | ||
3804 | } | ||
3805 | match(input,15,FOLLOW_2); if (state.failed) return ; | ||
3806 | if ( state.backtracking==0 ) { | ||
3807 | after(grammarAccess.getALSImplAccess().getEqualsSignGreaterThanSignKeyword_1_1_0()); | ||
3808 | } | ||
3809 | |||
3810 | } | ||
3811 | |||
3812 | |||
3813 | } | ||
3814 | break; | ||
3815 | case 2 : | ||
3816 | // InternalAlloyLanguage.g:1228:6: ( 'implies' ) | ||
3817 | { | ||
3818 | // InternalAlloyLanguage.g:1228:6: ( 'implies' ) | ||
3819 | // InternalAlloyLanguage.g:1229:1: 'implies' | ||
3820 | { | ||
3821 | if ( state.backtracking==0 ) { | ||
3822 | before(grammarAccess.getALSImplAccess().getImpliesKeyword_1_1_1()); | ||
3823 | } | ||
3824 | match(input,16,FOLLOW_2); if (state.failed) return ; | ||
3825 | if ( state.backtracking==0 ) { | ||
3826 | after(grammarAccess.getALSImplAccess().getImpliesKeyword_1_1_1()); | ||
3827 | } | ||
3828 | |||
3829 | } | ||
3830 | |||
3831 | |||
3832 | } | ||
3833 | break; | ||
3834 | |||
3835 | } | ||
3836 | } | ||
3837 | catch (RecognitionException re) { | ||
3838 | reportError(re); | ||
3839 | recover(input,re); | ||
3840 | } | ||
3841 | finally { | ||
3842 | |||
3843 | restoreStackSize(stackSize); | ||
3844 | |||
3845 | } | ||
3846 | return ; | ||
3847 | } | ||
3848 | // $ANTLR end "rule__ALSImpl__Alternatives_1_1" | ||
3849 | |||
3850 | |||
3851 | // $ANTLR start "rule__ALSAnd__Alternatives_1_1" | ||
3852 | // InternalAlloyLanguage.g:1241:1: rule__ALSAnd__Alternatives_1_1 : ( ( '&&' ) | ( 'and' ) ); | ||
3853 | public final void rule__ALSAnd__Alternatives_1_1() throws RecognitionException { | ||
3854 | |||
3855 | int stackSize = keepStackSize(); | ||
3856 | |||
3857 | try { | ||
3858 | // InternalAlloyLanguage.g:1245:1: ( ( '&&' ) | ( 'and' ) ) | ||
3859 | int alt8=2; | ||
3860 | int LA8_0 = input.LA(1); | ||
3861 | |||
3862 | if ( (LA8_0==17) ) { | ||
3863 | alt8=1; | ||
3864 | } | ||
3865 | else if ( (LA8_0==18) ) { | ||
3866 | alt8=2; | ||
3867 | } | ||
3868 | else { | ||
3869 | if (state.backtracking>0) {state.failed=true; return ;} | ||
3870 | NoViableAltException nvae = | ||
3871 | new NoViableAltException("", 8, 0, input); | ||
3872 | |||
3873 | throw nvae; | ||
3874 | } | ||
3875 | switch (alt8) { | ||
3876 | case 1 : | ||
3877 | // InternalAlloyLanguage.g:1246:1: ( '&&' ) | ||
3878 | { | ||
3879 | // InternalAlloyLanguage.g:1246:1: ( '&&' ) | ||
3880 | // InternalAlloyLanguage.g:1247:1: '&&' | ||
3881 | { | ||
3882 | if ( state.backtracking==0 ) { | ||
3883 | before(grammarAccess.getALSAndAccess().getAmpersandAmpersandKeyword_1_1_0()); | ||
3884 | } | ||
3885 | match(input,17,FOLLOW_2); if (state.failed) return ; | ||
3886 | if ( state.backtracking==0 ) { | ||
3887 | after(grammarAccess.getALSAndAccess().getAmpersandAmpersandKeyword_1_1_0()); | ||
3888 | } | ||
3889 | |||
3890 | } | ||
3891 | |||
3892 | |||
3893 | } | ||
3894 | break; | ||
3895 | case 2 : | ||
3896 | // InternalAlloyLanguage.g:1254:6: ( 'and' ) | ||
3897 | { | ||
3898 | // InternalAlloyLanguage.g:1254:6: ( 'and' ) | ||
3899 | // InternalAlloyLanguage.g:1255:1: 'and' | ||
3900 | { | ||
3901 | if ( state.backtracking==0 ) { | ||
3902 | before(grammarAccess.getALSAndAccess().getAndKeyword_1_1_1()); | ||
3903 | } | ||
3904 | match(input,18,FOLLOW_2); if (state.failed) return ; | ||
3905 | if ( state.backtracking==0 ) { | ||
3906 | after(grammarAccess.getALSAndAccess().getAndKeyword_1_1_1()); | ||
3907 | } | ||
3908 | |||
3909 | } | ||
3910 | |||
3911 | |||
3912 | } | ||
3913 | break; | ||
3914 | |||
3915 | } | ||
3916 | } | ||
3917 | catch (RecognitionException re) { | ||
3918 | reportError(re); | ||
3919 | recover(input,re); | ||
3920 | } | ||
3921 | finally { | ||
3922 | |||
3923 | restoreStackSize(stackSize); | ||
3924 | |||
3925 | } | ||
3926 | return ; | ||
3927 | } | ||
3928 | // $ANTLR end "rule__ALSAnd__Alternatives_1_1" | ||
3929 | |||
3930 | |||
3931 | // $ANTLR start "rule__ALSComparison__Alternatives_1_0" | ||
3932 | // InternalAlloyLanguage.g:1267:1: rule__ALSComparison__Alternatives_1_0 : ( ( ( rule__ALSComparison__Group_1_0_0__0 ) ) | ( ( rule__ALSComparison__Group_1_0_1__0 ) ) | ( ( rule__ALSComparison__Group_1_0_2__0 ) ) | ( ( rule__ALSComparison__Group_1_0_3__0 ) ) | ( ( rule__ALSComparison__Group_1_0_4__0 ) ) | ( ( rule__ALSComparison__Group_1_0_5__0 ) ) | ( ( rule__ALSComparison__Group_1_0_6__0 ) ) ); | ||
3933 | public final void rule__ALSComparison__Alternatives_1_0() throws RecognitionException { | ||
3934 | |||
3935 | int stackSize = keepStackSize(); | ||
3936 | |||
3937 | try { | ||
3938 | // InternalAlloyLanguage.g:1271:1: ( ( ( rule__ALSComparison__Group_1_0_0__0 ) ) | ( ( rule__ALSComparison__Group_1_0_1__0 ) ) | ( ( rule__ALSComparison__Group_1_0_2__0 ) ) | ( ( rule__ALSComparison__Group_1_0_3__0 ) ) | ( ( rule__ALSComparison__Group_1_0_4__0 ) ) | ( ( rule__ALSComparison__Group_1_0_5__0 ) ) | ( ( rule__ALSComparison__Group_1_0_6__0 ) ) ) | ||
3939 | int alt9=7; | ||
3940 | switch ( input.LA(1) ) { | ||
3941 | case 47: | ||
3942 | { | ||
3943 | alt9=1; | ||
3944 | } | ||
3945 | break; | ||
3946 | case 48: | ||
3947 | { | ||
3948 | alt9=2; | ||
3949 | } | ||
3950 | break; | ||
3951 | case 38: | ||
3952 | { | ||
3953 | alt9=3; | ||
3954 | } | ||
3955 | break; | ||
3956 | case 49: | ||
3957 | { | ||
3958 | alt9=4; | ||
3959 | } | ||
3960 | break; | ||
3961 | case 50: | ||
3962 | { | ||
3963 | alt9=5; | ||
3964 | } | ||
3965 | break; | ||
3966 | case 51: | ||
3967 | { | ||
3968 | alt9=6; | ||
3969 | } | ||
3970 | break; | ||
3971 | case 52: | ||
3972 | { | ||
3973 | alt9=7; | ||
3974 | } | ||
3975 | break; | ||
3976 | default: | ||
3977 | if (state.backtracking>0) {state.failed=true; return ;} | ||
3978 | NoViableAltException nvae = | ||
3979 | new NoViableAltException("", 9, 0, input); | ||
3980 | |||
3981 | throw nvae; | ||
3982 | } | ||
3983 | |||
3984 | switch (alt9) { | ||
3985 | case 1 : | ||
3986 | // InternalAlloyLanguage.g:1272:1: ( ( rule__ALSComparison__Group_1_0_0__0 ) ) | ||
3987 | { | ||
3988 | // InternalAlloyLanguage.g:1272:1: ( ( rule__ALSComparison__Group_1_0_0__0 ) ) | ||
3989 | // InternalAlloyLanguage.g:1273:1: ( rule__ALSComparison__Group_1_0_0__0 ) | ||
3990 | { | ||
3991 | if ( state.backtracking==0 ) { | ||
3992 | before(grammarAccess.getALSComparisonAccess().getGroup_1_0_0()); | ||
3993 | } | ||
3994 | // InternalAlloyLanguage.g:1274:1: ( rule__ALSComparison__Group_1_0_0__0 ) | ||
3995 | // InternalAlloyLanguage.g:1274:2: rule__ALSComparison__Group_1_0_0__0 | ||
3996 | { | ||
3997 | pushFollow(FOLLOW_2); | ||
3998 | rule__ALSComparison__Group_1_0_0__0(); | ||
3999 | |||
4000 | state._fsp--; | ||
4001 | if (state.failed) return ; | ||
4002 | |||
4003 | } | ||
4004 | |||
4005 | if ( state.backtracking==0 ) { | ||
4006 | after(grammarAccess.getALSComparisonAccess().getGroup_1_0_0()); | ||
4007 | } | ||
4008 | |||
4009 | } | ||
4010 | |||
4011 | |||
4012 | } | ||
4013 | break; | ||
4014 | case 2 : | ||
4015 | // InternalAlloyLanguage.g:1278:6: ( ( rule__ALSComparison__Group_1_0_1__0 ) ) | ||
4016 | { | ||
4017 | // InternalAlloyLanguage.g:1278:6: ( ( rule__ALSComparison__Group_1_0_1__0 ) ) | ||
4018 | // InternalAlloyLanguage.g:1279:1: ( rule__ALSComparison__Group_1_0_1__0 ) | ||
4019 | { | ||
4020 | if ( state.backtracking==0 ) { | ||
4021 | before(grammarAccess.getALSComparisonAccess().getGroup_1_0_1()); | ||
4022 | } | ||
4023 | // InternalAlloyLanguage.g:1280:1: ( rule__ALSComparison__Group_1_0_1__0 ) | ||
4024 | // InternalAlloyLanguage.g:1280:2: rule__ALSComparison__Group_1_0_1__0 | ||
4025 | { | ||
4026 | pushFollow(FOLLOW_2); | ||
4027 | rule__ALSComparison__Group_1_0_1__0(); | ||
4028 | |||
4029 | state._fsp--; | ||
4030 | if (state.failed) return ; | ||
4031 | |||
4032 | } | ||
4033 | |||
4034 | if ( state.backtracking==0 ) { | ||
4035 | after(grammarAccess.getALSComparisonAccess().getGroup_1_0_1()); | ||
4036 | } | ||
4037 | |||
4038 | } | ||
4039 | |||
4040 | |||
4041 | } | ||
4042 | break; | ||
4043 | case 3 : | ||
4044 | // InternalAlloyLanguage.g:1284:6: ( ( rule__ALSComparison__Group_1_0_2__0 ) ) | ||
4045 | { | ||
4046 | // InternalAlloyLanguage.g:1284:6: ( ( rule__ALSComparison__Group_1_0_2__0 ) ) | ||
4047 | // InternalAlloyLanguage.g:1285:1: ( rule__ALSComparison__Group_1_0_2__0 ) | ||
4048 | { | ||
4049 | if ( state.backtracking==0 ) { | ||
4050 | before(grammarAccess.getALSComparisonAccess().getGroup_1_0_2()); | ||
4051 | } | ||
4052 | // InternalAlloyLanguage.g:1286:1: ( rule__ALSComparison__Group_1_0_2__0 ) | ||
4053 | // InternalAlloyLanguage.g:1286:2: rule__ALSComparison__Group_1_0_2__0 | ||
4054 | { | ||
4055 | pushFollow(FOLLOW_2); | ||
4056 | rule__ALSComparison__Group_1_0_2__0(); | ||
4057 | |||
4058 | state._fsp--; | ||
4059 | if (state.failed) return ; | ||
4060 | |||
4061 | } | ||
4062 | |||
4063 | if ( state.backtracking==0 ) { | ||
4064 | after(grammarAccess.getALSComparisonAccess().getGroup_1_0_2()); | ||
4065 | } | ||
4066 | |||
4067 | } | ||
4068 | |||
4069 | |||
4070 | } | ||
4071 | break; | ||
4072 | case 4 : | ||
4073 | // InternalAlloyLanguage.g:1290:6: ( ( rule__ALSComparison__Group_1_0_3__0 ) ) | ||
4074 | { | ||
4075 | // InternalAlloyLanguage.g:1290:6: ( ( rule__ALSComparison__Group_1_0_3__0 ) ) | ||
4076 | // InternalAlloyLanguage.g:1291:1: ( rule__ALSComparison__Group_1_0_3__0 ) | ||
4077 | { | ||
4078 | if ( state.backtracking==0 ) { | ||
4079 | before(grammarAccess.getALSComparisonAccess().getGroup_1_0_3()); | ||
4080 | } | ||
4081 | // InternalAlloyLanguage.g:1292:1: ( rule__ALSComparison__Group_1_0_3__0 ) | ||
4082 | // InternalAlloyLanguage.g:1292:2: rule__ALSComparison__Group_1_0_3__0 | ||
4083 | { | ||
4084 | pushFollow(FOLLOW_2); | ||
4085 | rule__ALSComparison__Group_1_0_3__0(); | ||
4086 | |||
4087 | state._fsp--; | ||
4088 | if (state.failed) return ; | ||
4089 | |||
4090 | } | ||
4091 | |||
4092 | if ( state.backtracking==0 ) { | ||
4093 | after(grammarAccess.getALSComparisonAccess().getGroup_1_0_3()); | ||
4094 | } | ||
4095 | |||
4096 | } | ||
4097 | |||
4098 | |||
4099 | } | ||
4100 | break; | ||
4101 | case 5 : | ||
4102 | // InternalAlloyLanguage.g:1296:6: ( ( rule__ALSComparison__Group_1_0_4__0 ) ) | ||
4103 | { | ||
4104 | // InternalAlloyLanguage.g:1296:6: ( ( rule__ALSComparison__Group_1_0_4__0 ) ) | ||
4105 | // InternalAlloyLanguage.g:1297:1: ( rule__ALSComparison__Group_1_0_4__0 ) | ||
4106 | { | ||
4107 | if ( state.backtracking==0 ) { | ||
4108 | before(grammarAccess.getALSComparisonAccess().getGroup_1_0_4()); | ||
4109 | } | ||
4110 | // InternalAlloyLanguage.g:1298:1: ( rule__ALSComparison__Group_1_0_4__0 ) | ||
4111 | // InternalAlloyLanguage.g:1298:2: rule__ALSComparison__Group_1_0_4__0 | ||
4112 | { | ||
4113 | pushFollow(FOLLOW_2); | ||
4114 | rule__ALSComparison__Group_1_0_4__0(); | ||
4115 | |||
4116 | state._fsp--; | ||
4117 | if (state.failed) return ; | ||
4118 | |||
4119 | } | ||
4120 | |||
4121 | if ( state.backtracking==0 ) { | ||
4122 | after(grammarAccess.getALSComparisonAccess().getGroup_1_0_4()); | ||
4123 | } | ||
4124 | |||
4125 | } | ||
4126 | |||
4127 | |||
4128 | } | ||
4129 | break; | ||
4130 | case 6 : | ||
4131 | // InternalAlloyLanguage.g:1302:6: ( ( rule__ALSComparison__Group_1_0_5__0 ) ) | ||
4132 | { | ||
4133 | // InternalAlloyLanguage.g:1302:6: ( ( rule__ALSComparison__Group_1_0_5__0 ) ) | ||
4134 | // InternalAlloyLanguage.g:1303:1: ( rule__ALSComparison__Group_1_0_5__0 ) | ||
4135 | { | ||
4136 | if ( state.backtracking==0 ) { | ||
4137 | before(grammarAccess.getALSComparisonAccess().getGroup_1_0_5()); | ||
4138 | } | ||
4139 | // InternalAlloyLanguage.g:1304:1: ( rule__ALSComparison__Group_1_0_5__0 ) | ||
4140 | // InternalAlloyLanguage.g:1304:2: rule__ALSComparison__Group_1_0_5__0 | ||
4141 | { | ||
4142 | pushFollow(FOLLOW_2); | ||
4143 | rule__ALSComparison__Group_1_0_5__0(); | ||
4144 | |||
4145 | state._fsp--; | ||
4146 | if (state.failed) return ; | ||
4147 | |||
4148 | } | ||
4149 | |||
4150 | if ( state.backtracking==0 ) { | ||
4151 | after(grammarAccess.getALSComparisonAccess().getGroup_1_0_5()); | ||
4152 | } | ||
4153 | |||
4154 | } | ||
4155 | |||
4156 | |||
4157 | } | ||
4158 | break; | ||
4159 | case 7 : | ||
4160 | // InternalAlloyLanguage.g:1308:6: ( ( rule__ALSComparison__Group_1_0_6__0 ) ) | ||
4161 | { | ||
4162 | // InternalAlloyLanguage.g:1308:6: ( ( rule__ALSComparison__Group_1_0_6__0 ) ) | ||
4163 | // InternalAlloyLanguage.g:1309:1: ( rule__ALSComparison__Group_1_0_6__0 ) | ||
4164 | { | ||
4165 | if ( state.backtracking==0 ) { | ||
4166 | before(grammarAccess.getALSComparisonAccess().getGroup_1_0_6()); | ||
4167 | } | ||
4168 | // InternalAlloyLanguage.g:1310:1: ( rule__ALSComparison__Group_1_0_6__0 ) | ||
4169 | // InternalAlloyLanguage.g:1310:2: rule__ALSComparison__Group_1_0_6__0 | ||
4170 | { | ||
4171 | pushFollow(FOLLOW_2); | ||
4172 | rule__ALSComparison__Group_1_0_6__0(); | ||
4173 | |||
4174 | state._fsp--; | ||
4175 | if (state.failed) return ; | ||
4176 | |||
4177 | } | ||
4178 | |||
4179 | if ( state.backtracking==0 ) { | ||
4180 | after(grammarAccess.getALSComparisonAccess().getGroup_1_0_6()); | ||
4181 | } | ||
4182 | |||
4183 | } | ||
4184 | |||
4185 | |||
4186 | } | ||
4187 | break; | ||
4188 | |||
4189 | } | ||
4190 | } | ||
4191 | catch (RecognitionException re) { | ||
4192 | reportError(re); | ||
4193 | recover(input,re); | ||
4194 | } | ||
4195 | finally { | ||
4196 | |||
4197 | restoreStackSize(stackSize); | ||
4198 | |||
4199 | } | ||
4200 | return ; | ||
4201 | } | ||
4202 | // $ANTLR end "rule__ALSComparison__Alternatives_1_0" | ||
4203 | |||
4204 | |||
4205 | // $ANTLR start "rule__ALSPreficed__Alternatives" | ||
4206 | // InternalAlloyLanguage.g:1319:1: rule__ALSPreficed__Alternatives : ( ( ( rule__ALSPreficed__Group_0__0 ) ) | ( ( rule__ALSPreficed__Group_1__0 ) ) | ( ( rule__ALSPreficed__Group_2__0 ) ) | ( ( rule__ALSPreficed__Group_3__0 ) ) | ( ( rule__ALSPreficed__Group_4__0 ) ) | ( ( rule__ALSPreficed__Group_5__0 ) ) | ( ( rule__ALSPreficed__Group_6__0 ) ) | ( ( rule__ALSPreficed__Group_7__0 ) ) | ( ruleALSBasicRelationTerm ) ); | ||
4207 | public final void rule__ALSPreficed__Alternatives() throws RecognitionException { | ||
4208 | |||
4209 | int stackSize = keepStackSize(); | ||
4210 | |||
4211 | try { | ||
4212 | // InternalAlloyLanguage.g:1323:1: ( ( ( rule__ALSPreficed__Group_0__0 ) ) | ( ( rule__ALSPreficed__Group_1__0 ) ) | ( ( rule__ALSPreficed__Group_2__0 ) ) | ( ( rule__ALSPreficed__Group_3__0 ) ) | ( ( rule__ALSPreficed__Group_4__0 ) ) | ( ( rule__ALSPreficed__Group_5__0 ) ) | ( ( rule__ALSPreficed__Group_6__0 ) ) | ( ( rule__ALSPreficed__Group_7__0 ) ) | ( ruleALSBasicRelationTerm ) ) | ||
4213 | int alt10=9; | ||
4214 | alt10 = dfa10.predict(input); | ||
4215 | switch (alt10) { | ||
4216 | case 1 : | ||
4217 | // InternalAlloyLanguage.g:1324:1: ( ( rule__ALSPreficed__Group_0__0 ) ) | ||
4218 | { | ||
4219 | // InternalAlloyLanguage.g:1324:1: ( ( rule__ALSPreficed__Group_0__0 ) ) | ||
4220 | // InternalAlloyLanguage.g:1325:1: ( rule__ALSPreficed__Group_0__0 ) | ||
4221 | { | ||
4222 | if ( state.backtracking==0 ) { | ||
4223 | before(grammarAccess.getALSPreficedAccess().getGroup_0()); | ||
4224 | } | ||
4225 | // InternalAlloyLanguage.g:1326:1: ( rule__ALSPreficed__Group_0__0 ) | ||
4226 | // InternalAlloyLanguage.g:1326:2: rule__ALSPreficed__Group_0__0 | ||
4227 | { | ||
4228 | pushFollow(FOLLOW_2); | ||
4229 | rule__ALSPreficed__Group_0__0(); | ||
4230 | |||
4231 | state._fsp--; | ||
4232 | if (state.failed) return ; | ||
4233 | |||
4234 | } | ||
4235 | |||
4236 | if ( state.backtracking==0 ) { | ||
4237 | after(grammarAccess.getALSPreficedAccess().getGroup_0()); | ||
4238 | } | ||
4239 | |||
4240 | } | ||
4241 | |||
4242 | |||
4243 | } | ||
4244 | break; | ||
4245 | case 2 : | ||
4246 | // InternalAlloyLanguage.g:1330:6: ( ( rule__ALSPreficed__Group_1__0 ) ) | ||
4247 | { | ||
4248 | // InternalAlloyLanguage.g:1330:6: ( ( rule__ALSPreficed__Group_1__0 ) ) | ||
4249 | // InternalAlloyLanguage.g:1331:1: ( rule__ALSPreficed__Group_1__0 ) | ||
4250 | { | ||
4251 | if ( state.backtracking==0 ) { | ||
4252 | before(grammarAccess.getALSPreficedAccess().getGroup_1()); | ||
4253 | } | ||
4254 | // InternalAlloyLanguage.g:1332:1: ( rule__ALSPreficed__Group_1__0 ) | ||
4255 | // InternalAlloyLanguage.g:1332:2: rule__ALSPreficed__Group_1__0 | ||
4256 | { | ||
4257 | pushFollow(FOLLOW_2); | ||
4258 | rule__ALSPreficed__Group_1__0(); | ||
4259 | |||
4260 | state._fsp--; | ||
4261 | if (state.failed) return ; | ||
4262 | |||
4263 | } | ||
4264 | |||
4265 | if ( state.backtracking==0 ) { | ||
4266 | after(grammarAccess.getALSPreficedAccess().getGroup_1()); | ||
4267 | } | ||
4268 | |||
4269 | } | ||
4270 | |||
4271 | |||
4272 | } | ||
4273 | break; | ||
4274 | case 3 : | ||
4275 | // InternalAlloyLanguage.g:1336:6: ( ( rule__ALSPreficed__Group_2__0 ) ) | ||
4276 | { | ||
4277 | // InternalAlloyLanguage.g:1336:6: ( ( rule__ALSPreficed__Group_2__0 ) ) | ||
4278 | // InternalAlloyLanguage.g:1337:1: ( rule__ALSPreficed__Group_2__0 ) | ||
4279 | { | ||
4280 | if ( state.backtracking==0 ) { | ||
4281 | before(grammarAccess.getALSPreficedAccess().getGroup_2()); | ||
4282 | } | ||
4283 | // InternalAlloyLanguage.g:1338:1: ( rule__ALSPreficed__Group_2__0 ) | ||
4284 | // InternalAlloyLanguage.g:1338:2: rule__ALSPreficed__Group_2__0 | ||
4285 | { | ||
4286 | pushFollow(FOLLOW_2); | ||
4287 | rule__ALSPreficed__Group_2__0(); | ||
4288 | |||
4289 | state._fsp--; | ||
4290 | if (state.failed) return ; | ||
4291 | |||
4292 | } | ||
4293 | |||
4294 | if ( state.backtracking==0 ) { | ||
4295 | after(grammarAccess.getALSPreficedAccess().getGroup_2()); | ||
4296 | } | ||
4297 | |||
4298 | } | ||
4299 | |||
4300 | |||
4301 | } | ||
4302 | break; | ||
4303 | case 4 : | ||
4304 | // InternalAlloyLanguage.g:1342:6: ( ( rule__ALSPreficed__Group_3__0 ) ) | ||
4305 | { | ||
4306 | // InternalAlloyLanguage.g:1342:6: ( ( rule__ALSPreficed__Group_3__0 ) ) | ||
4307 | // InternalAlloyLanguage.g:1343:1: ( rule__ALSPreficed__Group_3__0 ) | ||
4308 | { | ||
4309 | if ( state.backtracking==0 ) { | ||
4310 | before(grammarAccess.getALSPreficedAccess().getGroup_3()); | ||
4311 | } | ||
4312 | // InternalAlloyLanguage.g:1344:1: ( rule__ALSPreficed__Group_3__0 ) | ||
4313 | // InternalAlloyLanguage.g:1344:2: rule__ALSPreficed__Group_3__0 | ||
4314 | { | ||
4315 | pushFollow(FOLLOW_2); | ||
4316 | rule__ALSPreficed__Group_3__0(); | ||
4317 | |||
4318 | state._fsp--; | ||
4319 | if (state.failed) return ; | ||
4320 | |||
4321 | } | ||
4322 | |||
4323 | if ( state.backtracking==0 ) { | ||
4324 | after(grammarAccess.getALSPreficedAccess().getGroup_3()); | ||
4325 | } | ||
4326 | |||
4327 | } | ||
4328 | |||
4329 | |||
4330 | } | ||
4331 | break; | ||
4332 | case 5 : | ||
4333 | // InternalAlloyLanguage.g:1348:6: ( ( rule__ALSPreficed__Group_4__0 ) ) | ||
4334 | { | ||
4335 | // InternalAlloyLanguage.g:1348:6: ( ( rule__ALSPreficed__Group_4__0 ) ) | ||
4336 | // InternalAlloyLanguage.g:1349:1: ( rule__ALSPreficed__Group_4__0 ) | ||
4337 | { | ||
4338 | if ( state.backtracking==0 ) { | ||
4339 | before(grammarAccess.getALSPreficedAccess().getGroup_4()); | ||
4340 | } | ||
4341 | // InternalAlloyLanguage.g:1350:1: ( rule__ALSPreficed__Group_4__0 ) | ||
4342 | // InternalAlloyLanguage.g:1350:2: rule__ALSPreficed__Group_4__0 | ||
4343 | { | ||
4344 | pushFollow(FOLLOW_2); | ||
4345 | rule__ALSPreficed__Group_4__0(); | ||
4346 | |||
4347 | state._fsp--; | ||
4348 | if (state.failed) return ; | ||
4349 | |||
4350 | } | ||
4351 | |||
4352 | if ( state.backtracking==0 ) { | ||
4353 | after(grammarAccess.getALSPreficedAccess().getGroup_4()); | ||
4354 | } | ||
4355 | |||
4356 | } | ||
4357 | |||
4358 | |||
4359 | } | ||
4360 | break; | ||
4361 | case 6 : | ||
4362 | // InternalAlloyLanguage.g:1354:6: ( ( rule__ALSPreficed__Group_5__0 ) ) | ||
4363 | { | ||
4364 | // InternalAlloyLanguage.g:1354:6: ( ( rule__ALSPreficed__Group_5__0 ) ) | ||
4365 | // InternalAlloyLanguage.g:1355:1: ( rule__ALSPreficed__Group_5__0 ) | ||
4366 | { | ||
4367 | if ( state.backtracking==0 ) { | ||
4368 | before(grammarAccess.getALSPreficedAccess().getGroup_5()); | ||
4369 | } | ||
4370 | // InternalAlloyLanguage.g:1356:1: ( rule__ALSPreficed__Group_5__0 ) | ||
4371 | // InternalAlloyLanguage.g:1356:2: rule__ALSPreficed__Group_5__0 | ||
4372 | { | ||
4373 | pushFollow(FOLLOW_2); | ||
4374 | rule__ALSPreficed__Group_5__0(); | ||
4375 | |||
4376 | state._fsp--; | ||
4377 | if (state.failed) return ; | ||
4378 | |||
4379 | } | ||
4380 | |||
4381 | if ( state.backtracking==0 ) { | ||
4382 | after(grammarAccess.getALSPreficedAccess().getGroup_5()); | ||
4383 | } | ||
4384 | |||
4385 | } | ||
4386 | |||
4387 | |||
4388 | } | ||
4389 | break; | ||
4390 | case 7 : | ||
4391 | // InternalAlloyLanguage.g:1360:6: ( ( rule__ALSPreficed__Group_6__0 ) ) | ||
4392 | { | ||
4393 | // InternalAlloyLanguage.g:1360:6: ( ( rule__ALSPreficed__Group_6__0 ) ) | ||
4394 | // InternalAlloyLanguage.g:1361:1: ( rule__ALSPreficed__Group_6__0 ) | ||
4395 | { | ||
4396 | if ( state.backtracking==0 ) { | ||
4397 | before(grammarAccess.getALSPreficedAccess().getGroup_6()); | ||
4398 | } | ||
4399 | // InternalAlloyLanguage.g:1362:1: ( rule__ALSPreficed__Group_6__0 ) | ||
4400 | // InternalAlloyLanguage.g:1362:2: rule__ALSPreficed__Group_6__0 | ||
4401 | { | ||
4402 | pushFollow(FOLLOW_2); | ||
4403 | rule__ALSPreficed__Group_6__0(); | ||
4404 | |||
4405 | state._fsp--; | ||
4406 | if (state.failed) return ; | ||
4407 | |||
4408 | } | ||
4409 | |||
4410 | if ( state.backtracking==0 ) { | ||
4411 | after(grammarAccess.getALSPreficedAccess().getGroup_6()); | ||
4412 | } | ||
4413 | |||
4414 | } | ||
4415 | |||
4416 | |||
4417 | } | ||
4418 | break; | ||
4419 | case 8 : | ||
4420 | // InternalAlloyLanguage.g:1366:6: ( ( rule__ALSPreficed__Group_7__0 ) ) | ||
4421 | { | ||
4422 | // InternalAlloyLanguage.g:1366:6: ( ( rule__ALSPreficed__Group_7__0 ) ) | ||
4423 | // InternalAlloyLanguage.g:1367:1: ( rule__ALSPreficed__Group_7__0 ) | ||
4424 | { | ||
4425 | if ( state.backtracking==0 ) { | ||
4426 | before(grammarAccess.getALSPreficedAccess().getGroup_7()); | ||
4427 | } | ||
4428 | // InternalAlloyLanguage.g:1368:1: ( rule__ALSPreficed__Group_7__0 ) | ||
4429 | // InternalAlloyLanguage.g:1368:2: rule__ALSPreficed__Group_7__0 | ||
4430 | { | ||
4431 | pushFollow(FOLLOW_2); | ||
4432 | rule__ALSPreficed__Group_7__0(); | ||
4433 | |||
4434 | state._fsp--; | ||
4435 | if (state.failed) return ; | ||
4436 | |||
4437 | } | ||
4438 | |||
4439 | if ( state.backtracking==0 ) { | ||
4440 | after(grammarAccess.getALSPreficedAccess().getGroup_7()); | ||
4441 | } | ||
4442 | |||
4443 | } | ||
4444 | |||
4445 | |||
4446 | } | ||
4447 | break; | ||
4448 | case 9 : | ||
4449 | // InternalAlloyLanguage.g:1372:6: ( ruleALSBasicRelationTerm ) | ||
4450 | { | ||
4451 | // InternalAlloyLanguage.g:1372:6: ( ruleALSBasicRelationTerm ) | ||
4452 | // InternalAlloyLanguage.g:1373:1: ruleALSBasicRelationTerm | ||
4453 | { | ||
4454 | if ( state.backtracking==0 ) { | ||
4455 | before(grammarAccess.getALSPreficedAccess().getALSBasicRelationTermParserRuleCall_8()); | ||
4456 | } | ||
4457 | pushFollow(FOLLOW_2); | ||
4458 | ruleALSBasicRelationTerm(); | ||
4459 | |||
4460 | state._fsp--; | ||
4461 | if (state.failed) return ; | ||
4462 | if ( state.backtracking==0 ) { | ||
4463 | after(grammarAccess.getALSPreficedAccess().getALSBasicRelationTermParserRuleCall_8()); | ||
4464 | } | ||
4465 | |||
4466 | } | ||
4467 | |||
4468 | |||
4469 | } | ||
4470 | break; | ||
4471 | |||
4472 | } | ||
4473 | } | ||
4474 | catch (RecognitionException re) { | ||
4475 | reportError(re); | ||
4476 | recover(input,re); | ||
4477 | } | ||
4478 | finally { | ||
4479 | |||
4480 | restoreStackSize(stackSize); | ||
4481 | |||
4482 | } | ||
4483 | return ; | ||
4484 | } | ||
4485 | // $ANTLR end "rule__ALSPreficed__Alternatives" | ||
4486 | |||
4487 | |||
4488 | // $ANTLR start "rule__ALSPreficed__Alternatives_0_1_0" | ||
4489 | // InternalAlloyLanguage.g:1383:1: rule__ALSPreficed__Alternatives_0_1_0 : ( ( '!' ) | ( 'not' ) ); | ||
4490 | public final void rule__ALSPreficed__Alternatives_0_1_0() throws RecognitionException { | ||
4491 | |||
4492 | int stackSize = keepStackSize(); | ||
4493 | |||
4494 | try { | ||
4495 | // InternalAlloyLanguage.g:1387:1: ( ( '!' ) | ( 'not' ) ) | ||
4496 | int alt11=2; | ||
4497 | int LA11_0 = input.LA(1); | ||
4498 | |||
4499 | if ( (LA11_0==19) ) { | ||
4500 | alt11=1; | ||
4501 | } | ||
4502 | else if ( (LA11_0==20) ) { | ||
4503 | alt11=2; | ||
4504 | } | ||
4505 | else { | ||
4506 | if (state.backtracking>0) {state.failed=true; return ;} | ||
4507 | NoViableAltException nvae = | ||
4508 | new NoViableAltException("", 11, 0, input); | ||
4509 | |||
4510 | throw nvae; | ||
4511 | } | ||
4512 | switch (alt11) { | ||
4513 | case 1 : | ||
4514 | // InternalAlloyLanguage.g:1388:1: ( '!' ) | ||
4515 | { | ||
4516 | // InternalAlloyLanguage.g:1388:1: ( '!' ) | ||
4517 | // InternalAlloyLanguage.g:1389:1: '!' | ||
4518 | { | ||
4519 | if ( state.backtracking==0 ) { | ||
4520 | before(grammarAccess.getALSPreficedAccess().getExclamationMarkKeyword_0_1_0_0()); | ||
4521 | } | ||
4522 | match(input,19,FOLLOW_2); if (state.failed) return ; | ||
4523 | if ( state.backtracking==0 ) { | ||
4524 | after(grammarAccess.getALSPreficedAccess().getExclamationMarkKeyword_0_1_0_0()); | ||
4525 | } | ||
4526 | |||
4527 | } | ||
4528 | |||
4529 | |||
4530 | } | ||
4531 | break; | ||
4532 | case 2 : | ||
4533 | // InternalAlloyLanguage.g:1396:6: ( 'not' ) | ||
4534 | { | ||
4535 | // InternalAlloyLanguage.g:1396:6: ( 'not' ) | ||
4536 | // InternalAlloyLanguage.g:1397:1: 'not' | ||
4537 | { | ||
4538 | if ( state.backtracking==0 ) { | ||
4539 | before(grammarAccess.getALSPreficedAccess().getNotKeyword_0_1_0_1()); | ||
4540 | } | ||
4541 | match(input,20,FOLLOW_2); if (state.failed) return ; | ||
4542 | if ( state.backtracking==0 ) { | ||
4543 | after(grammarAccess.getALSPreficedAccess().getNotKeyword_0_1_0_1()); | ||
4544 | } | ||
4545 | |||
4546 | } | ||
4547 | |||
4548 | |||
4549 | } | ||
4550 | break; | ||
4551 | |||
4552 | } | ||
4553 | } | ||
4554 | catch (RecognitionException re) { | ||
4555 | reportError(re); | ||
4556 | recover(input,re); | ||
4557 | } | ||
4558 | finally { | ||
4559 | |||
4560 | restoreStackSize(stackSize); | ||
4561 | |||
4562 | } | ||
4563 | return ; | ||
4564 | } | ||
4565 | // $ANTLR end "rule__ALSPreficed__Alternatives_0_1_0" | ||
4566 | |||
4567 | |||
4568 | // $ANTLR start "rule__ALSPreficed__Alternatives_7_1" | ||
4569 | // InternalAlloyLanguage.g:1409:1: rule__ALSPreficed__Alternatives_7_1 : ( ( ( rule__ALSPreficed__ReferredDefinitionAssignment_7_1_0 ) ) | ( ( rule__ALSPreficed__ReferredNumericOperatorAssignment_7_1_1 ) ) ); | ||
4570 | public final void rule__ALSPreficed__Alternatives_7_1() throws RecognitionException { | ||
4571 | |||
4572 | int stackSize = keepStackSize(); | ||
4573 | |||
4574 | try { | ||
4575 | // InternalAlloyLanguage.g:1413:1: ( ( ( rule__ALSPreficed__ReferredDefinitionAssignment_7_1_0 ) ) | ( ( rule__ALSPreficed__ReferredNumericOperatorAssignment_7_1_1 ) ) ) | ||
4576 | int alt12=2; | ||
4577 | int LA12_0 = input.LA(1); | ||
4578 | |||
4579 | if ( (LA12_0==RULE_ID) ) { | ||
4580 | alt12=1; | ||
4581 | } | ||
4582 | else if ( ((LA12_0>=27 && LA12_0<=31)) ) { | ||
4583 | alt12=2; | ||
4584 | } | ||
4585 | else { | ||
4586 | if (state.backtracking>0) {state.failed=true; return ;} | ||
4587 | NoViableAltException nvae = | ||
4588 | new NoViableAltException("", 12, 0, input); | ||
4589 | |||
4590 | throw nvae; | ||
4591 | } | ||
4592 | switch (alt12) { | ||
4593 | case 1 : | ||
4594 | // InternalAlloyLanguage.g:1414:1: ( ( rule__ALSPreficed__ReferredDefinitionAssignment_7_1_0 ) ) | ||
4595 | { | ||
4596 | // InternalAlloyLanguage.g:1414:1: ( ( rule__ALSPreficed__ReferredDefinitionAssignment_7_1_0 ) ) | ||
4597 | // InternalAlloyLanguage.g:1415:1: ( rule__ALSPreficed__ReferredDefinitionAssignment_7_1_0 ) | ||
4598 | { | ||
4599 | if ( state.backtracking==0 ) { | ||
4600 | before(grammarAccess.getALSPreficedAccess().getReferredDefinitionAssignment_7_1_0()); | ||
4601 | } | ||
4602 | // InternalAlloyLanguage.g:1416:1: ( rule__ALSPreficed__ReferredDefinitionAssignment_7_1_0 ) | ||
4603 | // InternalAlloyLanguage.g:1416:2: rule__ALSPreficed__ReferredDefinitionAssignment_7_1_0 | ||
4604 | { | ||
4605 | pushFollow(FOLLOW_2); | ||
4606 | rule__ALSPreficed__ReferredDefinitionAssignment_7_1_0(); | ||
4607 | |||
4608 | state._fsp--; | ||
4609 | if (state.failed) return ; | ||
4610 | |||
4611 | } | ||
4612 | |||
4613 | if ( state.backtracking==0 ) { | ||
4614 | after(grammarAccess.getALSPreficedAccess().getReferredDefinitionAssignment_7_1_0()); | ||
4615 | } | ||
4616 | |||
4617 | } | ||
4618 | |||
4619 | |||
4620 | } | ||
4621 | break; | ||
4622 | case 2 : | ||
4623 | // InternalAlloyLanguage.g:1420:6: ( ( rule__ALSPreficed__ReferredNumericOperatorAssignment_7_1_1 ) ) | ||
4624 | { | ||
4625 | // InternalAlloyLanguage.g:1420:6: ( ( rule__ALSPreficed__ReferredNumericOperatorAssignment_7_1_1 ) ) | ||
4626 | // InternalAlloyLanguage.g:1421:1: ( rule__ALSPreficed__ReferredNumericOperatorAssignment_7_1_1 ) | ||
4627 | { | ||
4628 | if ( state.backtracking==0 ) { | ||
4629 | before(grammarAccess.getALSPreficedAccess().getReferredNumericOperatorAssignment_7_1_1()); | ||
4630 | } | ||
4631 | // InternalAlloyLanguage.g:1422:1: ( rule__ALSPreficed__ReferredNumericOperatorAssignment_7_1_1 ) | ||
4632 | // InternalAlloyLanguage.g:1422:2: rule__ALSPreficed__ReferredNumericOperatorAssignment_7_1_1 | ||
4633 | { | ||
4634 | pushFollow(FOLLOW_2); | ||
4635 | rule__ALSPreficed__ReferredNumericOperatorAssignment_7_1_1(); | ||
4636 | |||
4637 | state._fsp--; | ||
4638 | if (state.failed) return ; | ||
4639 | |||
4640 | } | ||
4641 | |||
4642 | if ( state.backtracking==0 ) { | ||
4643 | after(grammarAccess.getALSPreficedAccess().getReferredNumericOperatorAssignment_7_1_1()); | ||
4644 | } | ||
4645 | |||
4646 | } | ||
4647 | |||
4648 | |||
4649 | } | ||
4650 | break; | ||
4651 | |||
4652 | } | ||
4653 | } | ||
4654 | catch (RecognitionException re) { | ||
4655 | reportError(re); | ||
4656 | recover(input,re); | ||
4657 | } | ||
4658 | finally { | ||
4659 | |||
4660 | restoreStackSize(stackSize); | ||
4661 | |||
4662 | } | ||
4663 | return ; | ||
4664 | } | ||
4665 | // $ANTLR end "rule__ALSPreficed__Alternatives_7_1" | ||
4666 | |||
4667 | |||
4668 | // $ANTLR start "rule__ALSBasicRelationTerm__Alternatives" | ||
4669 | // InternalAlloyLanguage.g:1431:1: rule__ALSBasicRelationTerm__Alternatives : ( ( ( rule__ALSBasicRelationTerm__Group_0__0 ) ) | ( ( rule__ALSBasicRelationTerm__Group_1__0 ) ) | ( ( rule__ALSBasicRelationTerm__Group_2__0 ) ) | ( ( rule__ALSBasicRelationTerm__Group_3__0 ) ) | ( ( rule__ALSBasicRelationTerm__Group_4__0 ) ) | ( ( rule__ALSBasicRelationTerm__Group_5__0 ) ) | ( ( rule__ALSBasicRelationTerm__Group_6__0 ) ) | ( ( rule__ALSBasicRelationTerm__Group_7__0 ) ) | ( ( rule__ALSBasicRelationTerm__Group_8__0 ) ) ); | ||
4670 | public final void rule__ALSBasicRelationTerm__Alternatives() throws RecognitionException { | ||
4671 | |||
4672 | int stackSize = keepStackSize(); | ||
4673 | |||
4674 | try { | ||
4675 | // InternalAlloyLanguage.g:1435:1: ( ( ( rule__ALSBasicRelationTerm__Group_0__0 ) ) | ( ( rule__ALSBasicRelationTerm__Group_1__0 ) ) | ( ( rule__ALSBasicRelationTerm__Group_2__0 ) ) | ( ( rule__ALSBasicRelationTerm__Group_3__0 ) ) | ( ( rule__ALSBasicRelationTerm__Group_4__0 ) ) | ( ( rule__ALSBasicRelationTerm__Group_5__0 ) ) | ( ( rule__ALSBasicRelationTerm__Group_6__0 ) ) | ( ( rule__ALSBasicRelationTerm__Group_7__0 ) ) | ( ( rule__ALSBasicRelationTerm__Group_8__0 ) ) ) | ||
4676 | int alt13=9; | ||
4677 | switch ( input.LA(1) ) { | ||
4678 | case 65: | ||
4679 | { | ||
4680 | alt13=1; | ||
4681 | } | ||
4682 | break; | ||
4683 | case 66: | ||
4684 | { | ||
4685 | alt13=2; | ||
4686 | } | ||
4687 | break; | ||
4688 | case 67: | ||
4689 | { | ||
4690 | alt13=3; | ||
4691 | } | ||
4692 | break; | ||
4693 | case 68: | ||
4694 | { | ||
4695 | alt13=4; | ||
4696 | } | ||
4697 | break; | ||
4698 | case 69: | ||
4699 | { | ||
4700 | alt13=5; | ||
4701 | } | ||
4702 | break; | ||
4703 | case RULE_ID: | ||
4704 | { | ||
4705 | alt13=6; | ||
4706 | } | ||
4707 | break; | ||
4708 | case RULE_INT: | ||
4709 | { | ||
4710 | alt13=7; | ||
4711 | } | ||
4712 | break; | ||
4713 | case RULE_STRING: | ||
4714 | { | ||
4715 | alt13=8; | ||
4716 | } | ||
4717 | break; | ||
4718 | case 70: | ||
4719 | { | ||
4720 | alt13=9; | ||
4721 | } | ||
4722 | break; | ||
4723 | default: | ||
4724 | if (state.backtracking>0) {state.failed=true; return ;} | ||
4725 | NoViableAltException nvae = | ||
4726 | new NoViableAltException("", 13, 0, input); | ||
4727 | |||
4728 | throw nvae; | ||
4729 | } | ||
4730 | |||
4731 | switch (alt13) { | ||
4732 | case 1 : | ||
4733 | // InternalAlloyLanguage.g:1436:1: ( ( rule__ALSBasicRelationTerm__Group_0__0 ) ) | ||
4734 | { | ||
4735 | // InternalAlloyLanguage.g:1436:1: ( ( rule__ALSBasicRelationTerm__Group_0__0 ) ) | ||
4736 | // InternalAlloyLanguage.g:1437:1: ( rule__ALSBasicRelationTerm__Group_0__0 ) | ||
4737 | { | ||
4738 | if ( state.backtracking==0 ) { | ||
4739 | before(grammarAccess.getALSBasicRelationTermAccess().getGroup_0()); | ||
4740 | } | ||
4741 | // InternalAlloyLanguage.g:1438:1: ( rule__ALSBasicRelationTerm__Group_0__0 ) | ||
4742 | // InternalAlloyLanguage.g:1438:2: rule__ALSBasicRelationTerm__Group_0__0 | ||
4743 | { | ||
4744 | pushFollow(FOLLOW_2); | ||
4745 | rule__ALSBasicRelationTerm__Group_0__0(); | ||
4746 | |||
4747 | state._fsp--; | ||
4748 | if (state.failed) return ; | ||
4749 | |||
4750 | } | ||
4751 | |||
4752 | if ( state.backtracking==0 ) { | ||
4753 | after(grammarAccess.getALSBasicRelationTermAccess().getGroup_0()); | ||
4754 | } | ||
4755 | |||
4756 | } | ||
4757 | |||
4758 | |||
4759 | } | ||
4760 | break; | ||
4761 | case 2 : | ||
4762 | // InternalAlloyLanguage.g:1442:6: ( ( rule__ALSBasicRelationTerm__Group_1__0 ) ) | ||
4763 | { | ||
4764 | // InternalAlloyLanguage.g:1442:6: ( ( rule__ALSBasicRelationTerm__Group_1__0 ) ) | ||
4765 | // InternalAlloyLanguage.g:1443:1: ( rule__ALSBasicRelationTerm__Group_1__0 ) | ||
4766 | { | ||
4767 | if ( state.backtracking==0 ) { | ||
4768 | before(grammarAccess.getALSBasicRelationTermAccess().getGroup_1()); | ||
4769 | } | ||
4770 | // InternalAlloyLanguage.g:1444:1: ( rule__ALSBasicRelationTerm__Group_1__0 ) | ||
4771 | // InternalAlloyLanguage.g:1444:2: rule__ALSBasicRelationTerm__Group_1__0 | ||
4772 | { | ||
4773 | pushFollow(FOLLOW_2); | ||
4774 | rule__ALSBasicRelationTerm__Group_1__0(); | ||
4775 | |||
4776 | state._fsp--; | ||
4777 | if (state.failed) return ; | ||
4778 | |||
4779 | } | ||
4780 | |||
4781 | if ( state.backtracking==0 ) { | ||
4782 | after(grammarAccess.getALSBasicRelationTermAccess().getGroup_1()); | ||
4783 | } | ||
4784 | |||
4785 | } | ||
4786 | |||
4787 | |||
4788 | } | ||
4789 | break; | ||
4790 | case 3 : | ||
4791 | // InternalAlloyLanguage.g:1448:6: ( ( rule__ALSBasicRelationTerm__Group_2__0 ) ) | ||
4792 | { | ||
4793 | // InternalAlloyLanguage.g:1448:6: ( ( rule__ALSBasicRelationTerm__Group_2__0 ) ) | ||
4794 | // InternalAlloyLanguage.g:1449:1: ( rule__ALSBasicRelationTerm__Group_2__0 ) | ||
4795 | { | ||
4796 | if ( state.backtracking==0 ) { | ||
4797 | before(grammarAccess.getALSBasicRelationTermAccess().getGroup_2()); | ||
4798 | } | ||
4799 | // InternalAlloyLanguage.g:1450:1: ( rule__ALSBasicRelationTerm__Group_2__0 ) | ||
4800 | // InternalAlloyLanguage.g:1450:2: rule__ALSBasicRelationTerm__Group_2__0 | ||
4801 | { | ||
4802 | pushFollow(FOLLOW_2); | ||
4803 | rule__ALSBasicRelationTerm__Group_2__0(); | ||
4804 | |||
4805 | state._fsp--; | ||
4806 | if (state.failed) return ; | ||
4807 | |||
4808 | } | ||
4809 | |||
4810 | if ( state.backtracking==0 ) { | ||
4811 | after(grammarAccess.getALSBasicRelationTermAccess().getGroup_2()); | ||
4812 | } | ||
4813 | |||
4814 | } | ||
4815 | |||
4816 | |||
4817 | } | ||
4818 | break; | ||
4819 | case 4 : | ||
4820 | // InternalAlloyLanguage.g:1454:6: ( ( rule__ALSBasicRelationTerm__Group_3__0 ) ) | ||
4821 | { | ||
4822 | // InternalAlloyLanguage.g:1454:6: ( ( rule__ALSBasicRelationTerm__Group_3__0 ) ) | ||
4823 | // InternalAlloyLanguage.g:1455:1: ( rule__ALSBasicRelationTerm__Group_3__0 ) | ||
4824 | { | ||
4825 | if ( state.backtracking==0 ) { | ||
4826 | before(grammarAccess.getALSBasicRelationTermAccess().getGroup_3()); | ||
4827 | } | ||
4828 | // InternalAlloyLanguage.g:1456:1: ( rule__ALSBasicRelationTerm__Group_3__0 ) | ||
4829 | // InternalAlloyLanguage.g:1456:2: rule__ALSBasicRelationTerm__Group_3__0 | ||
4830 | { | ||
4831 | pushFollow(FOLLOW_2); | ||
4832 | rule__ALSBasicRelationTerm__Group_3__0(); | ||
4833 | |||
4834 | state._fsp--; | ||
4835 | if (state.failed) return ; | ||
4836 | |||
4837 | } | ||
4838 | |||
4839 | if ( state.backtracking==0 ) { | ||
4840 | after(grammarAccess.getALSBasicRelationTermAccess().getGroup_3()); | ||
4841 | } | ||
4842 | |||
4843 | } | ||
4844 | |||
4845 | |||
4846 | } | ||
4847 | break; | ||
4848 | case 5 : | ||
4849 | // InternalAlloyLanguage.g:1460:6: ( ( rule__ALSBasicRelationTerm__Group_4__0 ) ) | ||
4850 | { | ||
4851 | // InternalAlloyLanguage.g:1460:6: ( ( rule__ALSBasicRelationTerm__Group_4__0 ) ) | ||
4852 | // InternalAlloyLanguage.g:1461:1: ( rule__ALSBasicRelationTerm__Group_4__0 ) | ||
4853 | { | ||
4854 | if ( state.backtracking==0 ) { | ||
4855 | before(grammarAccess.getALSBasicRelationTermAccess().getGroup_4()); | ||
4856 | } | ||
4857 | // InternalAlloyLanguage.g:1462:1: ( rule__ALSBasicRelationTerm__Group_4__0 ) | ||
4858 | // InternalAlloyLanguage.g:1462:2: rule__ALSBasicRelationTerm__Group_4__0 | ||
4859 | { | ||
4860 | pushFollow(FOLLOW_2); | ||
4861 | rule__ALSBasicRelationTerm__Group_4__0(); | ||
4862 | |||
4863 | state._fsp--; | ||
4864 | if (state.failed) return ; | ||
4865 | |||
4866 | } | ||
4867 | |||
4868 | if ( state.backtracking==0 ) { | ||
4869 | after(grammarAccess.getALSBasicRelationTermAccess().getGroup_4()); | ||
4870 | } | ||
4871 | |||
4872 | } | ||
4873 | |||
4874 | |||
4875 | } | ||
4876 | break; | ||
4877 | case 6 : | ||
4878 | // InternalAlloyLanguage.g:1466:6: ( ( rule__ALSBasicRelationTerm__Group_5__0 ) ) | ||
4879 | { | ||
4880 | // InternalAlloyLanguage.g:1466:6: ( ( rule__ALSBasicRelationTerm__Group_5__0 ) ) | ||
4881 | // InternalAlloyLanguage.g:1467:1: ( rule__ALSBasicRelationTerm__Group_5__0 ) | ||
4882 | { | ||
4883 | if ( state.backtracking==0 ) { | ||
4884 | before(grammarAccess.getALSBasicRelationTermAccess().getGroup_5()); | ||
4885 | } | ||
4886 | // InternalAlloyLanguage.g:1468:1: ( rule__ALSBasicRelationTerm__Group_5__0 ) | ||
4887 | // InternalAlloyLanguage.g:1468:2: rule__ALSBasicRelationTerm__Group_5__0 | ||
4888 | { | ||
4889 | pushFollow(FOLLOW_2); | ||
4890 | rule__ALSBasicRelationTerm__Group_5__0(); | ||
4891 | |||
4892 | state._fsp--; | ||
4893 | if (state.failed) return ; | ||
4894 | |||
4895 | } | ||
4896 | |||
4897 | if ( state.backtracking==0 ) { | ||
4898 | after(grammarAccess.getALSBasicRelationTermAccess().getGroup_5()); | ||
4899 | } | ||
4900 | |||
4901 | } | ||
4902 | |||
4903 | |||
4904 | } | ||
4905 | break; | ||
4906 | case 7 : | ||
4907 | // InternalAlloyLanguage.g:1472:6: ( ( rule__ALSBasicRelationTerm__Group_6__0 ) ) | ||
4908 | { | ||
4909 | // InternalAlloyLanguage.g:1472:6: ( ( rule__ALSBasicRelationTerm__Group_6__0 ) ) | ||
4910 | // InternalAlloyLanguage.g:1473:1: ( rule__ALSBasicRelationTerm__Group_6__0 ) | ||
4911 | { | ||
4912 | if ( state.backtracking==0 ) { | ||
4913 | before(grammarAccess.getALSBasicRelationTermAccess().getGroup_6()); | ||
4914 | } | ||
4915 | // InternalAlloyLanguage.g:1474:1: ( rule__ALSBasicRelationTerm__Group_6__0 ) | ||
4916 | // InternalAlloyLanguage.g:1474:2: rule__ALSBasicRelationTerm__Group_6__0 | ||
4917 | { | ||
4918 | pushFollow(FOLLOW_2); | ||
4919 | rule__ALSBasicRelationTerm__Group_6__0(); | ||
4920 | |||
4921 | state._fsp--; | ||
4922 | if (state.failed) return ; | ||
4923 | |||
4924 | } | ||
4925 | |||
4926 | if ( state.backtracking==0 ) { | ||
4927 | after(grammarAccess.getALSBasicRelationTermAccess().getGroup_6()); | ||
4928 | } | ||
4929 | |||
4930 | } | ||
4931 | |||
4932 | |||
4933 | } | ||
4934 | break; | ||
4935 | case 8 : | ||
4936 | // InternalAlloyLanguage.g:1478:6: ( ( rule__ALSBasicRelationTerm__Group_7__0 ) ) | ||
4937 | { | ||
4938 | // InternalAlloyLanguage.g:1478:6: ( ( rule__ALSBasicRelationTerm__Group_7__0 ) ) | ||
4939 | // InternalAlloyLanguage.g:1479:1: ( rule__ALSBasicRelationTerm__Group_7__0 ) | ||
4940 | { | ||
4941 | if ( state.backtracking==0 ) { | ||
4942 | before(grammarAccess.getALSBasicRelationTermAccess().getGroup_7()); | ||
4943 | } | ||
4944 | // InternalAlloyLanguage.g:1480:1: ( rule__ALSBasicRelationTerm__Group_7__0 ) | ||
4945 | // InternalAlloyLanguage.g:1480:2: rule__ALSBasicRelationTerm__Group_7__0 | ||
4946 | { | ||
4947 | pushFollow(FOLLOW_2); | ||
4948 | rule__ALSBasicRelationTerm__Group_7__0(); | ||
4949 | |||
4950 | state._fsp--; | ||
4951 | if (state.failed) return ; | ||
4952 | |||
4953 | } | ||
4954 | |||
4955 | if ( state.backtracking==0 ) { | ||
4956 | after(grammarAccess.getALSBasicRelationTermAccess().getGroup_7()); | ||
4957 | } | ||
4958 | |||
4959 | } | ||
4960 | |||
4961 | |||
4962 | } | ||
4963 | break; | ||
4964 | case 9 : | ||
4965 | // InternalAlloyLanguage.g:1484:6: ( ( rule__ALSBasicRelationTerm__Group_8__0 ) ) | ||
4966 | { | ||
4967 | // InternalAlloyLanguage.g:1484:6: ( ( rule__ALSBasicRelationTerm__Group_8__0 ) ) | ||
4968 | // InternalAlloyLanguage.g:1485:1: ( rule__ALSBasicRelationTerm__Group_8__0 ) | ||
4969 | { | ||
4970 | if ( state.backtracking==0 ) { | ||
4971 | before(grammarAccess.getALSBasicRelationTermAccess().getGroup_8()); | ||
4972 | } | ||
4973 | // InternalAlloyLanguage.g:1486:1: ( rule__ALSBasicRelationTerm__Group_8__0 ) | ||
4974 | // InternalAlloyLanguage.g:1486:2: rule__ALSBasicRelationTerm__Group_8__0 | ||
4975 | { | ||
4976 | pushFollow(FOLLOW_2); | ||
4977 | rule__ALSBasicRelationTerm__Group_8__0(); | ||
4978 | |||
4979 | state._fsp--; | ||
4980 | if (state.failed) return ; | ||
4981 | |||
4982 | } | ||
4983 | |||
4984 | if ( state.backtracking==0 ) { | ||
4985 | after(grammarAccess.getALSBasicRelationTermAccess().getGroup_8()); | ||
4986 | } | ||
4987 | |||
4988 | } | ||
4989 | |||
4990 | |||
4991 | } | ||
4992 | break; | ||
4993 | |||
4994 | } | ||
4995 | } | ||
4996 | catch (RecognitionException re) { | ||
4997 | reportError(re); | ||
4998 | recover(input,re); | ||
4999 | } | ||
5000 | finally { | ||
5001 | |||
5002 | restoreStackSize(stackSize); | ||
5003 | |||
5004 | } | ||
5005 | return ; | ||
5006 | } | ||
5007 | // $ANTLR end "rule__ALSBasicRelationTerm__Alternatives" | ||
5008 | |||
5009 | |||
5010 | // $ANTLR start "rule__ALSTypeScope__Alternatives" | ||
5011 | // InternalAlloyLanguage.g:1495:1: rule__ALSTypeScope__Alternatives : ( ( ruleALSSigScope ) | ( ruleALSIntScope ) | ( ruleALSStringScope ) ); | ||
5012 | public final void rule__ALSTypeScope__Alternatives() throws RecognitionException { | ||
5013 | |||
5014 | int stackSize = keepStackSize(); | ||
5015 | |||
5016 | try { | ||
5017 | // InternalAlloyLanguage.g:1499:1: ( ( ruleALSSigScope ) | ( ruleALSIntScope ) | ( ruleALSStringScope ) ) | ||
5018 | int alt14=3; | ||
5019 | int LA14_0 = input.LA(1); | ||
5020 | |||
5021 | if ( (LA14_0==74) ) { | ||
5022 | int LA14_1 = input.LA(2); | ||
5023 | |||
5024 | if ( (LA14_1==RULE_INT) ) { | ||
5025 | int LA14_3 = input.LA(3); | ||
5026 | |||
5027 | if ( (LA14_3==69) ) { | ||
5028 | alt14=3; | ||
5029 | } | ||
5030 | else if ( (LA14_3==RULE_ID) ) { | ||
5031 | alt14=1; | ||
5032 | } | ||
5033 | else { | ||
5034 | if (state.backtracking>0) {state.failed=true; return ;} | ||
5035 | NoViableAltException nvae = | ||
5036 | new NoViableAltException("", 14, 3, input); | ||
5037 | |||
5038 | throw nvae; | ||
5039 | } | ||
5040 | } | ||
5041 | else { | ||
5042 | if (state.backtracking>0) {state.failed=true; return ;} | ||
5043 | NoViableAltException nvae = | ||
5044 | new NoViableAltException("", 14, 1, input); | ||
5045 | |||
5046 | throw nvae; | ||
5047 | } | ||
5048 | } | ||
5049 | else if ( (LA14_0==RULE_INT) ) { | ||
5050 | int LA14_2 = input.LA(2); | ||
5051 | |||
5052 | if ( (LA14_2==68) ) { | ||
5053 | alt14=2; | ||
5054 | } | ||
5055 | else if ( (LA14_2==RULE_ID) ) { | ||
5056 | alt14=1; | ||
5057 | } | ||
5058 | else { | ||
5059 | if (state.backtracking>0) {state.failed=true; return ;} | ||
5060 | NoViableAltException nvae = | ||
5061 | new NoViableAltException("", 14, 2, input); | ||
5062 | |||
5063 | throw nvae; | ||
5064 | } | ||
5065 | } | ||
5066 | else { | ||
5067 | if (state.backtracking>0) {state.failed=true; return ;} | ||
5068 | NoViableAltException nvae = | ||
5069 | new NoViableAltException("", 14, 0, input); | ||
5070 | |||
5071 | throw nvae; | ||
5072 | } | ||
5073 | switch (alt14) { | ||
5074 | case 1 : | ||
5075 | // InternalAlloyLanguage.g:1500:1: ( ruleALSSigScope ) | ||
5076 | { | ||
5077 | // InternalAlloyLanguage.g:1500:1: ( ruleALSSigScope ) | ||
5078 | // InternalAlloyLanguage.g:1501:1: ruleALSSigScope | ||
5079 | { | ||
5080 | if ( state.backtracking==0 ) { | ||
5081 | before(grammarAccess.getALSTypeScopeAccess().getALSSigScopeParserRuleCall_0()); | ||
5082 | } | ||
5083 | pushFollow(FOLLOW_2); | ||
5084 | ruleALSSigScope(); | ||
5085 | |||
5086 | state._fsp--; | ||
5087 | if (state.failed) return ; | ||
5088 | if ( state.backtracking==0 ) { | ||
5089 | after(grammarAccess.getALSTypeScopeAccess().getALSSigScopeParserRuleCall_0()); | ||
5090 | } | ||
5091 | |||
5092 | } | ||
5093 | |||
5094 | |||
5095 | } | ||
5096 | break; | ||
5097 | case 2 : | ||
5098 | // InternalAlloyLanguage.g:1506:6: ( ruleALSIntScope ) | ||
5099 | { | ||
5100 | // InternalAlloyLanguage.g:1506:6: ( ruleALSIntScope ) | ||
5101 | // InternalAlloyLanguage.g:1507:1: ruleALSIntScope | ||
5102 | { | ||
5103 | if ( state.backtracking==0 ) { | ||
5104 | before(grammarAccess.getALSTypeScopeAccess().getALSIntScopeParserRuleCall_1()); | ||
5105 | } | ||
5106 | pushFollow(FOLLOW_2); | ||
5107 | ruleALSIntScope(); | ||
5108 | |||
5109 | state._fsp--; | ||
5110 | if (state.failed) return ; | ||
5111 | if ( state.backtracking==0 ) { | ||
5112 | after(grammarAccess.getALSTypeScopeAccess().getALSIntScopeParserRuleCall_1()); | ||
5113 | } | ||
5114 | |||
5115 | } | ||
5116 | |||
5117 | |||
5118 | } | ||
5119 | break; | ||
5120 | case 3 : | ||
5121 | // InternalAlloyLanguage.g:1512:6: ( ruleALSStringScope ) | ||
5122 | { | ||
5123 | // InternalAlloyLanguage.g:1512:6: ( ruleALSStringScope ) | ||
5124 | // InternalAlloyLanguage.g:1513:1: ruleALSStringScope | ||
5125 | { | ||
5126 | if ( state.backtracking==0 ) { | ||
5127 | before(grammarAccess.getALSTypeScopeAccess().getALSStringScopeParserRuleCall_2()); | ||
5128 | } | ||
5129 | pushFollow(FOLLOW_2); | ||
5130 | ruleALSStringScope(); | ||
5131 | |||
5132 | state._fsp--; | ||
5133 | if (state.failed) return ; | ||
5134 | if ( state.backtracking==0 ) { | ||
5135 | after(grammarAccess.getALSTypeScopeAccess().getALSStringScopeParserRuleCall_2()); | ||
5136 | } | ||
5137 | |||
5138 | } | ||
5139 | |||
5140 | |||
5141 | } | ||
5142 | break; | ||
5143 | |||
5144 | } | ||
5145 | } | ||
5146 | catch (RecognitionException re) { | ||
5147 | reportError(re); | ||
5148 | recover(input,re); | ||
5149 | } | ||
5150 | finally { | ||
5151 | |||
5152 | restoreStackSize(stackSize); | ||
5153 | |||
5154 | } | ||
5155 | return ; | ||
5156 | } | ||
5157 | // $ANTLR end "rule__ALSTypeScope__Alternatives" | ||
5158 | |||
5159 | |||
5160 | // $ANTLR start "rule__ALSMultiplicity__Alternatives" | ||
5161 | // InternalAlloyLanguage.g:1523:1: rule__ALSMultiplicity__Alternatives : ( ( ( 'all' ) ) | ( ( 'no' ) ) | ( ( 'some' ) ) | ( ( 'lone' ) ) | ( ( 'one' ) ) | ( ( 'set' ) ) ); | ||
5162 | public final void rule__ALSMultiplicity__Alternatives() throws RecognitionException { | ||
5163 | |||
5164 | int stackSize = keepStackSize(); | ||
5165 | |||
5166 | try { | ||
5167 | // InternalAlloyLanguage.g:1527:1: ( ( ( 'all' ) ) | ( ( 'no' ) ) | ( ( 'some' ) ) | ( ( 'lone' ) ) | ( ( 'one' ) ) | ( ( 'set' ) ) ) | ||
5168 | int alt15=6; | ||
5169 | switch ( input.LA(1) ) { | ||
5170 | case 21: | ||
5171 | { | ||
5172 | alt15=1; | ||
5173 | } | ||
5174 | break; | ||
5175 | case 22: | ||
5176 | { | ||
5177 | alt15=2; | ||
5178 | } | ||
5179 | break; | ||
5180 | case 23: | ||
5181 | { | ||
5182 | alt15=3; | ||
5183 | } | ||
5184 | break; | ||
5185 | case 24: | ||
5186 | { | ||
5187 | alt15=4; | ||
5188 | } | ||
5189 | break; | ||
5190 | case 25: | ||
5191 | { | ||
5192 | alt15=5; | ||
5193 | } | ||
5194 | break; | ||
5195 | case 26: | ||
5196 | { | ||
5197 | alt15=6; | ||
5198 | } | ||
5199 | break; | ||
5200 | default: | ||
5201 | if (state.backtracking>0) {state.failed=true; return ;} | ||
5202 | NoViableAltException nvae = | ||
5203 | new NoViableAltException("", 15, 0, input); | ||
5204 | |||
5205 | throw nvae; | ||
5206 | } | ||
5207 | |||
5208 | switch (alt15) { | ||
5209 | case 1 : | ||
5210 | // InternalAlloyLanguage.g:1528:1: ( ( 'all' ) ) | ||
5211 | { | ||
5212 | // InternalAlloyLanguage.g:1528:1: ( ( 'all' ) ) | ||
5213 | // InternalAlloyLanguage.g:1529:1: ( 'all' ) | ||
5214 | { | ||
5215 | if ( state.backtracking==0 ) { | ||
5216 | before(grammarAccess.getALSMultiplicityAccess().getAllEnumLiteralDeclaration_0()); | ||
5217 | } | ||
5218 | // InternalAlloyLanguage.g:1530:1: ( 'all' ) | ||
5219 | // InternalAlloyLanguage.g:1530:3: 'all' | ||
5220 | { | ||
5221 | match(input,21,FOLLOW_2); if (state.failed) return ; | ||
5222 | |||
5223 | } | ||
5224 | |||
5225 | if ( state.backtracking==0 ) { | ||
5226 | after(grammarAccess.getALSMultiplicityAccess().getAllEnumLiteralDeclaration_0()); | ||
5227 | } | ||
5228 | |||
5229 | } | ||
5230 | |||
5231 | |||
5232 | } | ||
5233 | break; | ||
5234 | case 2 : | ||
5235 | // InternalAlloyLanguage.g:1535:6: ( ( 'no' ) ) | ||
5236 | { | ||
5237 | // InternalAlloyLanguage.g:1535:6: ( ( 'no' ) ) | ||
5238 | // InternalAlloyLanguage.g:1536:1: ( 'no' ) | ||
5239 | { | ||
5240 | if ( state.backtracking==0 ) { | ||
5241 | before(grammarAccess.getALSMultiplicityAccess().getNoEnumLiteralDeclaration_1()); | ||
5242 | } | ||
5243 | // InternalAlloyLanguage.g:1537:1: ( 'no' ) | ||
5244 | // InternalAlloyLanguage.g:1537:3: 'no' | ||
5245 | { | ||
5246 | match(input,22,FOLLOW_2); if (state.failed) return ; | ||
5247 | |||
5248 | } | ||
5249 | |||
5250 | if ( state.backtracking==0 ) { | ||
5251 | after(grammarAccess.getALSMultiplicityAccess().getNoEnumLiteralDeclaration_1()); | ||
5252 | } | ||
5253 | |||
5254 | } | ||
5255 | |||
5256 | |||
5257 | } | ||
5258 | break; | ||
5259 | case 3 : | ||
5260 | // InternalAlloyLanguage.g:1542:6: ( ( 'some' ) ) | ||
5261 | { | ||
5262 | // InternalAlloyLanguage.g:1542:6: ( ( 'some' ) ) | ||
5263 | // InternalAlloyLanguage.g:1543:1: ( 'some' ) | ||
5264 | { | ||
5265 | if ( state.backtracking==0 ) { | ||
5266 | before(grammarAccess.getALSMultiplicityAccess().getSomeEnumLiteralDeclaration_2()); | ||
5267 | } | ||
5268 | // InternalAlloyLanguage.g:1544:1: ( 'some' ) | ||
5269 | // InternalAlloyLanguage.g:1544:3: 'some' | ||
5270 | { | ||
5271 | match(input,23,FOLLOW_2); if (state.failed) return ; | ||
5272 | |||
5273 | } | ||
5274 | |||
5275 | if ( state.backtracking==0 ) { | ||
5276 | after(grammarAccess.getALSMultiplicityAccess().getSomeEnumLiteralDeclaration_2()); | ||
5277 | } | ||
5278 | |||
5279 | } | ||
5280 | |||
5281 | |||
5282 | } | ||
5283 | break; | ||
5284 | case 4 : | ||
5285 | // InternalAlloyLanguage.g:1549:6: ( ( 'lone' ) ) | ||
5286 | { | ||
5287 | // InternalAlloyLanguage.g:1549:6: ( ( 'lone' ) ) | ||
5288 | // InternalAlloyLanguage.g:1550:1: ( 'lone' ) | ||
5289 | { | ||
5290 | if ( state.backtracking==0 ) { | ||
5291 | before(grammarAccess.getALSMultiplicityAccess().getLoneEnumLiteralDeclaration_3()); | ||
5292 | } | ||
5293 | // InternalAlloyLanguage.g:1551:1: ( 'lone' ) | ||
5294 | // InternalAlloyLanguage.g:1551:3: 'lone' | ||
5295 | { | ||
5296 | match(input,24,FOLLOW_2); if (state.failed) return ; | ||
5297 | |||
5298 | } | ||
5299 | |||
5300 | if ( state.backtracking==0 ) { | ||
5301 | after(grammarAccess.getALSMultiplicityAccess().getLoneEnumLiteralDeclaration_3()); | ||
5302 | } | ||
5303 | |||
5304 | } | ||
5305 | |||
5306 | |||
5307 | } | ||
5308 | break; | ||
5309 | case 5 : | ||
5310 | // InternalAlloyLanguage.g:1556:6: ( ( 'one' ) ) | ||
5311 | { | ||
5312 | // InternalAlloyLanguage.g:1556:6: ( ( 'one' ) ) | ||
5313 | // InternalAlloyLanguage.g:1557:1: ( 'one' ) | ||
5314 | { | ||
5315 | if ( state.backtracking==0 ) { | ||
5316 | before(grammarAccess.getALSMultiplicityAccess().getOneEnumLiteralDeclaration_4()); | ||
5317 | } | ||
5318 | // InternalAlloyLanguage.g:1558:1: ( 'one' ) | ||
5319 | // InternalAlloyLanguage.g:1558:3: 'one' | ||
5320 | { | ||
5321 | match(input,25,FOLLOW_2); if (state.failed) return ; | ||
5322 | |||
5323 | } | ||
5324 | |||
5325 | if ( state.backtracking==0 ) { | ||
5326 | after(grammarAccess.getALSMultiplicityAccess().getOneEnumLiteralDeclaration_4()); | ||
5327 | } | ||
5328 | |||
5329 | } | ||
5330 | |||
5331 | |||
5332 | } | ||
5333 | break; | ||
5334 | case 6 : | ||
5335 | // InternalAlloyLanguage.g:1563:6: ( ( 'set' ) ) | ||
5336 | { | ||
5337 | // InternalAlloyLanguage.g:1563:6: ( ( 'set' ) ) | ||
5338 | // InternalAlloyLanguage.g:1564:1: ( 'set' ) | ||
5339 | { | ||
5340 | if ( state.backtracking==0 ) { | ||
5341 | before(grammarAccess.getALSMultiplicityAccess().getSetEnumLiteralDeclaration_5()); | ||
5342 | } | ||
5343 | // InternalAlloyLanguage.g:1565:1: ( 'set' ) | ||
5344 | // InternalAlloyLanguage.g:1565:3: 'set' | ||
5345 | { | ||
5346 | match(input,26,FOLLOW_2); if (state.failed) return ; | ||
5347 | |||
5348 | } | ||
5349 | |||
5350 | if ( state.backtracking==0 ) { | ||
5351 | after(grammarAccess.getALSMultiplicityAccess().getSetEnumLiteralDeclaration_5()); | ||
5352 | } | ||
5353 | |||
5354 | } | ||
5355 | |||
5356 | |||
5357 | } | ||
5358 | break; | ||
5359 | |||
5360 | } | ||
5361 | } | ||
5362 | catch (RecognitionException re) { | ||
5363 | reportError(re); | ||
5364 | recover(input,re); | ||
5365 | } | ||
5366 | finally { | ||
5367 | |||
5368 | restoreStackSize(stackSize); | ||
5369 | |||
5370 | } | ||
5371 | return ; | ||
5372 | } | ||
5373 | // $ANTLR end "rule__ALSMultiplicity__Alternatives" | ||
5374 | |||
5375 | |||
5376 | // $ANTLR start "rule__ALSNumericOperator__Alternatives" | ||
5377 | // InternalAlloyLanguage.g:1575:1: rule__ALSNumericOperator__Alternatives : ( ( ( 'plus' ) ) | ( ( 'sub' ) ) | ( ( 'mul' ) ) | ( ( 'rem' ) ) | ( ( 'div' ) ) ); | ||
5378 | public final void rule__ALSNumericOperator__Alternatives() throws RecognitionException { | ||
5379 | |||
5380 | int stackSize = keepStackSize(); | ||
5381 | |||
5382 | try { | ||
5383 | // InternalAlloyLanguage.g:1579:1: ( ( ( 'plus' ) ) | ( ( 'sub' ) ) | ( ( 'mul' ) ) | ( ( 'rem' ) ) | ( ( 'div' ) ) ) | ||
5384 | int alt16=5; | ||
5385 | switch ( input.LA(1) ) { | ||
5386 | case 27: | ||
5387 | { | ||
5388 | alt16=1; | ||
5389 | } | ||
5390 | break; | ||
5391 | case 28: | ||
5392 | { | ||
5393 | alt16=2; | ||
5394 | } | ||
5395 | break; | ||
5396 | case 29: | ||
5397 | { | ||
5398 | alt16=3; | ||
5399 | } | ||
5400 | break; | ||
5401 | case 30: | ||
5402 | { | ||
5403 | alt16=4; | ||
5404 | } | ||
5405 | break; | ||
5406 | case 31: | ||
5407 | { | ||
5408 | alt16=5; | ||
5409 | } | ||
5410 | break; | ||
5411 | default: | ||
5412 | if (state.backtracking>0) {state.failed=true; return ;} | ||
5413 | NoViableAltException nvae = | ||
5414 | new NoViableAltException("", 16, 0, input); | ||
5415 | |||
5416 | throw nvae; | ||
5417 | } | ||
5418 | |||
5419 | switch (alt16) { | ||
5420 | case 1 : | ||
5421 | // InternalAlloyLanguage.g:1580:1: ( ( 'plus' ) ) | ||
5422 | { | ||
5423 | // InternalAlloyLanguage.g:1580:1: ( ( 'plus' ) ) | ||
5424 | // InternalAlloyLanguage.g:1581:1: ( 'plus' ) | ||
5425 | { | ||
5426 | if ( state.backtracking==0 ) { | ||
5427 | before(grammarAccess.getALSNumericOperatorAccess().getPlusEnumLiteralDeclaration_0()); | ||
5428 | } | ||
5429 | // InternalAlloyLanguage.g:1582:1: ( 'plus' ) | ||
5430 | // InternalAlloyLanguage.g:1582:3: 'plus' | ||
5431 | { | ||
5432 | match(input,27,FOLLOW_2); if (state.failed) return ; | ||
5433 | |||
5434 | } | ||
5435 | |||
5436 | if ( state.backtracking==0 ) { | ||
5437 | after(grammarAccess.getALSNumericOperatorAccess().getPlusEnumLiteralDeclaration_0()); | ||
5438 | } | ||
5439 | |||
5440 | } | ||
5441 | |||
5442 | |||
5443 | } | ||
5444 | break; | ||
5445 | case 2 : | ||
5446 | // InternalAlloyLanguage.g:1587:6: ( ( 'sub' ) ) | ||
5447 | { | ||
5448 | // InternalAlloyLanguage.g:1587:6: ( ( 'sub' ) ) | ||
5449 | // InternalAlloyLanguage.g:1588:1: ( 'sub' ) | ||
5450 | { | ||
5451 | if ( state.backtracking==0 ) { | ||
5452 | before(grammarAccess.getALSNumericOperatorAccess().getSubEnumLiteralDeclaration_1()); | ||
5453 | } | ||
5454 | // InternalAlloyLanguage.g:1589:1: ( 'sub' ) | ||
5455 | // InternalAlloyLanguage.g:1589:3: 'sub' | ||
5456 | { | ||
5457 | match(input,28,FOLLOW_2); if (state.failed) return ; | ||
5458 | |||
5459 | } | ||
5460 | |||
5461 | if ( state.backtracking==0 ) { | ||
5462 | after(grammarAccess.getALSNumericOperatorAccess().getSubEnumLiteralDeclaration_1()); | ||
5463 | } | ||
5464 | |||
5465 | } | ||
5466 | |||
5467 | |||
5468 | } | ||
5469 | break; | ||
5470 | case 3 : | ||
5471 | // InternalAlloyLanguage.g:1594:6: ( ( 'mul' ) ) | ||
5472 | { | ||
5473 | // InternalAlloyLanguage.g:1594:6: ( ( 'mul' ) ) | ||
5474 | // InternalAlloyLanguage.g:1595:1: ( 'mul' ) | ||
5475 | { | ||
5476 | if ( state.backtracking==0 ) { | ||
5477 | before(grammarAccess.getALSNumericOperatorAccess().getMulEnumLiteralDeclaration_2()); | ||
5478 | } | ||
5479 | // InternalAlloyLanguage.g:1596:1: ( 'mul' ) | ||
5480 | // InternalAlloyLanguage.g:1596:3: 'mul' | ||
5481 | { | ||
5482 | match(input,29,FOLLOW_2); if (state.failed) return ; | ||
5483 | |||
5484 | } | ||
5485 | |||
5486 | if ( state.backtracking==0 ) { | ||
5487 | after(grammarAccess.getALSNumericOperatorAccess().getMulEnumLiteralDeclaration_2()); | ||
5488 | } | ||
5489 | |||
5490 | } | ||
5491 | |||
5492 | |||
5493 | } | ||
5494 | break; | ||
5495 | case 4 : | ||
5496 | // InternalAlloyLanguage.g:1601:6: ( ( 'rem' ) ) | ||
5497 | { | ||
5498 | // InternalAlloyLanguage.g:1601:6: ( ( 'rem' ) ) | ||
5499 | // InternalAlloyLanguage.g:1602:1: ( 'rem' ) | ||
5500 | { | ||
5501 | if ( state.backtracking==0 ) { | ||
5502 | before(grammarAccess.getALSNumericOperatorAccess().getRemEnumLiteralDeclaration_3()); | ||
5503 | } | ||
5504 | // InternalAlloyLanguage.g:1603:1: ( 'rem' ) | ||
5505 | // InternalAlloyLanguage.g:1603:3: 'rem' | ||
5506 | { | ||
5507 | match(input,30,FOLLOW_2); if (state.failed) return ; | ||
5508 | |||
5509 | } | ||
5510 | |||
5511 | if ( state.backtracking==0 ) { | ||
5512 | after(grammarAccess.getALSNumericOperatorAccess().getRemEnumLiteralDeclaration_3()); | ||
5513 | } | ||
5514 | |||
5515 | } | ||
5516 | |||
5517 | |||
5518 | } | ||
5519 | break; | ||
5520 | case 5 : | ||
5521 | // InternalAlloyLanguage.g:1608:6: ( ( 'div' ) ) | ||
5522 | { | ||
5523 | // InternalAlloyLanguage.g:1608:6: ( ( 'div' ) ) | ||
5524 | // InternalAlloyLanguage.g:1609:1: ( 'div' ) | ||
5525 | { | ||
5526 | if ( state.backtracking==0 ) { | ||
5527 | before(grammarAccess.getALSNumericOperatorAccess().getDivEnumLiteralDeclaration_4()); | ||
5528 | } | ||
5529 | // InternalAlloyLanguage.g:1610:1: ( 'div' ) | ||
5530 | // InternalAlloyLanguage.g:1610:3: 'div' | ||
5531 | { | ||
5532 | match(input,31,FOLLOW_2); if (state.failed) return ; | ||
5533 | |||
5534 | } | ||
5535 | |||
5536 | if ( state.backtracking==0 ) { | ||
5537 | after(grammarAccess.getALSNumericOperatorAccess().getDivEnumLiteralDeclaration_4()); | ||
5538 | } | ||
5539 | |||
5540 | } | ||
5541 | |||
5542 | |||
5543 | } | ||
5544 | break; | ||
5545 | |||
5546 | } | ||
5547 | } | ||
5548 | catch (RecognitionException re) { | ||
5549 | reportError(re); | ||
5550 | recover(input,re); | ||
5551 | } | ||
5552 | finally { | ||
5553 | |||
5554 | restoreStackSize(stackSize); | ||
5555 | |||
5556 | } | ||
5557 | return ; | ||
5558 | } | ||
5559 | // $ANTLR end "rule__ALSNumericOperator__Alternatives" | ||
5560 | |||
5561 | |||
5562 | // $ANTLR start "rule__ALSDocument__Group__0" | ||
5563 | // InternalAlloyLanguage.g:1622:1: rule__ALSDocument__Group__0 : rule__ALSDocument__Group__0__Impl rule__ALSDocument__Group__1 ; | ||
5564 | public final void rule__ALSDocument__Group__0() throws RecognitionException { | ||
5565 | |||
5566 | int stackSize = keepStackSize(); | ||
5567 | |||
5568 | try { | ||
5569 | // InternalAlloyLanguage.g:1626:1: ( rule__ALSDocument__Group__0__Impl rule__ALSDocument__Group__1 ) | ||
5570 | // InternalAlloyLanguage.g:1627:2: rule__ALSDocument__Group__0__Impl rule__ALSDocument__Group__1 | ||
5571 | { | ||
5572 | pushFollow(FOLLOW_3); | ||
5573 | rule__ALSDocument__Group__0__Impl(); | ||
5574 | |||
5575 | state._fsp--; | ||
5576 | if (state.failed) return ; | ||
5577 | pushFollow(FOLLOW_2); | ||
5578 | rule__ALSDocument__Group__1(); | ||
5579 | |||
5580 | state._fsp--; | ||
5581 | if (state.failed) return ; | ||
5582 | |||
5583 | } | ||
5584 | |||
5585 | } | ||
5586 | catch (RecognitionException re) { | ||
5587 | reportError(re); | ||
5588 | recover(input,re); | ||
5589 | } | ||
5590 | finally { | ||
5591 | |||
5592 | restoreStackSize(stackSize); | ||
5593 | |||
5594 | } | ||
5595 | return ; | ||
5596 | } | ||
5597 | // $ANTLR end "rule__ALSDocument__Group__0" | ||
5598 | |||
5599 | |||
5600 | // $ANTLR start "rule__ALSDocument__Group__0__Impl" | ||
5601 | // InternalAlloyLanguage.g:1634:1: rule__ALSDocument__Group__0__Impl : ( ( ( rule__ALSDocument__Alternatives_0 ) ) ( ( rule__ALSDocument__Alternatives_0 )* ) ) ; | ||
5602 | public final void rule__ALSDocument__Group__0__Impl() throws RecognitionException { | ||
5603 | |||
5604 | int stackSize = keepStackSize(); | ||
5605 | |||
5606 | try { | ||
5607 | // InternalAlloyLanguage.g:1638:1: ( ( ( ( rule__ALSDocument__Alternatives_0 ) ) ( ( rule__ALSDocument__Alternatives_0 )* ) ) ) | ||
5608 | // InternalAlloyLanguage.g:1639:1: ( ( ( rule__ALSDocument__Alternatives_0 ) ) ( ( rule__ALSDocument__Alternatives_0 )* ) ) | ||
5609 | { | ||
5610 | // InternalAlloyLanguage.g:1639:1: ( ( ( rule__ALSDocument__Alternatives_0 ) ) ( ( rule__ALSDocument__Alternatives_0 )* ) ) | ||
5611 | // InternalAlloyLanguage.g:1640:1: ( ( rule__ALSDocument__Alternatives_0 ) ) ( ( rule__ALSDocument__Alternatives_0 )* ) | ||
5612 | { | ||
5613 | // InternalAlloyLanguage.g:1640:1: ( ( rule__ALSDocument__Alternatives_0 ) ) | ||
5614 | // InternalAlloyLanguage.g:1641:1: ( rule__ALSDocument__Alternatives_0 ) | ||
5615 | { | ||
5616 | if ( state.backtracking==0 ) { | ||
5617 | before(grammarAccess.getALSDocumentAccess().getAlternatives_0()); | ||
5618 | } | ||
5619 | // InternalAlloyLanguage.g:1642:1: ( rule__ALSDocument__Alternatives_0 ) | ||
5620 | // InternalAlloyLanguage.g:1642:2: rule__ALSDocument__Alternatives_0 | ||
5621 | { | ||
5622 | pushFollow(FOLLOW_4); | ||
5623 | rule__ALSDocument__Alternatives_0(); | ||
5624 | |||
5625 | state._fsp--; | ||
5626 | if (state.failed) return ; | ||
5627 | |||
5628 | } | ||
5629 | |||
5630 | if ( state.backtracking==0 ) { | ||
5631 | after(grammarAccess.getALSDocumentAccess().getAlternatives_0()); | ||
5632 | } | ||
5633 | |||
5634 | } | ||
5635 | |||
5636 | // InternalAlloyLanguage.g:1645:1: ( ( rule__ALSDocument__Alternatives_0 )* ) | ||
5637 | // InternalAlloyLanguage.g:1646:1: ( rule__ALSDocument__Alternatives_0 )* | ||
5638 | { | ||
5639 | if ( state.backtracking==0 ) { | ||
5640 | before(grammarAccess.getALSDocumentAccess().getAlternatives_0()); | ||
5641 | } | ||
5642 | // InternalAlloyLanguage.g:1647:1: ( rule__ALSDocument__Alternatives_0 )* | ||
5643 | loop17: | ||
5644 | do { | ||
5645 | int alt17=2; | ||
5646 | int LA17_0 = input.LA(1); | ||
5647 | |||
5648 | if ( ((LA17_0>=21 && LA17_0<=26)||LA17_0==32||LA17_0==36||LA17_0==41||(LA17_0>=44 && LA17_0<=45)||LA17_0==75) ) { | ||
5649 | alt17=1; | ||
5650 | } | ||
5651 | |||
5652 | |||
5653 | switch (alt17) { | ||
5654 | case 1 : | ||
5655 | // InternalAlloyLanguage.g:1647:2: rule__ALSDocument__Alternatives_0 | ||
5656 | { | ||
5657 | pushFollow(FOLLOW_4); | ||
5658 | rule__ALSDocument__Alternatives_0(); | ||
5659 | |||
5660 | state._fsp--; | ||
5661 | if (state.failed) return ; | ||
5662 | |||
5663 | } | ||
5664 | break; | ||
5665 | |||
5666 | default : | ||
5667 | break loop17; | ||
5668 | } | ||
5669 | } while (true); | ||
5670 | |||
5671 | if ( state.backtracking==0 ) { | ||
5672 | after(grammarAccess.getALSDocumentAccess().getAlternatives_0()); | ||
5673 | } | ||
5674 | |||
5675 | } | ||
5676 | |||
5677 | |||
5678 | } | ||
5679 | |||
5680 | |||
5681 | } | ||
5682 | |||
5683 | } | ||
5684 | catch (RecognitionException re) { | ||
5685 | reportError(re); | ||
5686 | recover(input,re); | ||
5687 | } | ||
5688 | finally { | ||
5689 | |||
5690 | restoreStackSize(stackSize); | ||
5691 | |||
5692 | } | ||
5693 | return ; | ||
5694 | } | ||
5695 | // $ANTLR end "rule__ALSDocument__Group__0__Impl" | ||
5696 | |||
5697 | |||
5698 | // $ANTLR start "rule__ALSDocument__Group__1" | ||
5699 | // InternalAlloyLanguage.g:1658:1: rule__ALSDocument__Group__1 : rule__ALSDocument__Group__1__Impl ; | ||
5700 | public final void rule__ALSDocument__Group__1() throws RecognitionException { | ||
5701 | |||
5702 | int stackSize = keepStackSize(); | ||
5703 | |||
5704 | try { | ||
5705 | // InternalAlloyLanguage.g:1662:1: ( rule__ALSDocument__Group__1__Impl ) | ||
5706 | // InternalAlloyLanguage.g:1663:2: rule__ALSDocument__Group__1__Impl | ||
5707 | { | ||
5708 | pushFollow(FOLLOW_2); | ||
5709 | rule__ALSDocument__Group__1__Impl(); | ||
5710 | |||
5711 | state._fsp--; | ||
5712 | if (state.failed) return ; | ||
5713 | |||
5714 | } | ||
5715 | |||
5716 | } | ||
5717 | catch (RecognitionException re) { | ||
5718 | reportError(re); | ||
5719 | recover(input,re); | ||
5720 | } | ||
5721 | finally { | ||
5722 | |||
5723 | restoreStackSize(stackSize); | ||
5724 | |||
5725 | } | ||
5726 | return ; | ||
5727 | } | ||
5728 | // $ANTLR end "rule__ALSDocument__Group__1" | ||
5729 | |||
5730 | |||
5731 | // $ANTLR start "rule__ALSDocument__Group__1__Impl" | ||
5732 | // InternalAlloyLanguage.g:1669:1: rule__ALSDocument__Group__1__Impl : ( ( rule__ALSDocument__RunCommandAssignment_1 ) ) ; | ||
5733 | public final void rule__ALSDocument__Group__1__Impl() throws RecognitionException { | ||
5734 | |||
5735 | int stackSize = keepStackSize(); | ||
5736 | |||
5737 | try { | ||
5738 | // InternalAlloyLanguage.g:1673:1: ( ( ( rule__ALSDocument__RunCommandAssignment_1 ) ) ) | ||
5739 | // InternalAlloyLanguage.g:1674:1: ( ( rule__ALSDocument__RunCommandAssignment_1 ) ) | ||
5740 | { | ||
5741 | // InternalAlloyLanguage.g:1674:1: ( ( rule__ALSDocument__RunCommandAssignment_1 ) ) | ||
5742 | // InternalAlloyLanguage.g:1675:1: ( rule__ALSDocument__RunCommandAssignment_1 ) | ||
5743 | { | ||
5744 | if ( state.backtracking==0 ) { | ||
5745 | before(grammarAccess.getALSDocumentAccess().getRunCommandAssignment_1()); | ||
5746 | } | ||
5747 | // InternalAlloyLanguage.g:1676:1: ( rule__ALSDocument__RunCommandAssignment_1 ) | ||
5748 | // InternalAlloyLanguage.g:1676:2: rule__ALSDocument__RunCommandAssignment_1 | ||
5749 | { | ||
5750 | pushFollow(FOLLOW_2); | ||
5751 | rule__ALSDocument__RunCommandAssignment_1(); | ||
5752 | |||
5753 | state._fsp--; | ||
5754 | if (state.failed) return ; | ||
5755 | |||
5756 | } | ||
5757 | |||
5758 | if ( state.backtracking==0 ) { | ||
5759 | after(grammarAccess.getALSDocumentAccess().getRunCommandAssignment_1()); | ||
5760 | } | ||
5761 | |||
5762 | } | ||
5763 | |||
5764 | |||
5765 | } | ||
5766 | |||
5767 | } | ||
5768 | catch (RecognitionException re) { | ||
5769 | reportError(re); | ||
5770 | recover(input,re); | ||
5771 | } | ||
5772 | finally { | ||
5773 | |||
5774 | restoreStackSize(stackSize); | ||
5775 | |||
5776 | } | ||
5777 | return ; | ||
5778 | } | ||
5779 | // $ANTLR end "rule__ALSDocument__Group__1__Impl" | ||
5780 | |||
5781 | |||
5782 | // $ANTLR start "rule__ALSEnumDeclaration__Group__0" | ||
5783 | // InternalAlloyLanguage.g:1690:1: rule__ALSEnumDeclaration__Group__0 : rule__ALSEnumDeclaration__Group__0__Impl rule__ALSEnumDeclaration__Group__1 ; | ||
5784 | public final void rule__ALSEnumDeclaration__Group__0() throws RecognitionException { | ||
5785 | |||
5786 | int stackSize = keepStackSize(); | ||
5787 | |||
5788 | try { | ||
5789 | // InternalAlloyLanguage.g:1694:1: ( rule__ALSEnumDeclaration__Group__0__Impl rule__ALSEnumDeclaration__Group__1 ) | ||
5790 | // InternalAlloyLanguage.g:1695:2: rule__ALSEnumDeclaration__Group__0__Impl rule__ALSEnumDeclaration__Group__1 | ||
5791 | { | ||
5792 | pushFollow(FOLLOW_5); | ||
5793 | rule__ALSEnumDeclaration__Group__0__Impl(); | ||
5794 | |||
5795 | state._fsp--; | ||
5796 | if (state.failed) return ; | ||
5797 | pushFollow(FOLLOW_2); | ||
5798 | rule__ALSEnumDeclaration__Group__1(); | ||
5799 | |||
5800 | state._fsp--; | ||
5801 | if (state.failed) return ; | ||
5802 | |||
5803 | } | ||
5804 | |||
5805 | } | ||
5806 | catch (RecognitionException re) { | ||
5807 | reportError(re); | ||
5808 | recover(input,re); | ||
5809 | } | ||
5810 | finally { | ||
5811 | |||
5812 | restoreStackSize(stackSize); | ||
5813 | |||
5814 | } | ||
5815 | return ; | ||
5816 | } | ||
5817 | // $ANTLR end "rule__ALSEnumDeclaration__Group__0" | ||
5818 | |||
5819 | |||
5820 | // $ANTLR start "rule__ALSEnumDeclaration__Group__0__Impl" | ||
5821 | // InternalAlloyLanguage.g:1702:1: rule__ALSEnumDeclaration__Group__0__Impl : ( 'enum' ) ; | ||
5822 | public final void rule__ALSEnumDeclaration__Group__0__Impl() throws RecognitionException { | ||
5823 | |||
5824 | int stackSize = keepStackSize(); | ||
5825 | |||
5826 | try { | ||
5827 | // InternalAlloyLanguage.g:1706:1: ( ( 'enum' ) ) | ||
5828 | // InternalAlloyLanguage.g:1707:1: ( 'enum' ) | ||
5829 | { | ||
5830 | // InternalAlloyLanguage.g:1707:1: ( 'enum' ) | ||
5831 | // InternalAlloyLanguage.g:1708:1: 'enum' | ||
5832 | { | ||
5833 | if ( state.backtracking==0 ) { | ||
5834 | before(grammarAccess.getALSEnumDeclarationAccess().getEnumKeyword_0()); | ||
5835 | } | ||
5836 | match(input,32,FOLLOW_2); if (state.failed) return ; | ||
5837 | if ( state.backtracking==0 ) { | ||
5838 | after(grammarAccess.getALSEnumDeclarationAccess().getEnumKeyword_0()); | ||
5839 | } | ||
5840 | |||
5841 | } | ||
5842 | |||
5843 | |||
5844 | } | ||
5845 | |||
5846 | } | ||
5847 | catch (RecognitionException re) { | ||
5848 | reportError(re); | ||
5849 | recover(input,re); | ||
5850 | } | ||
5851 | finally { | ||
5852 | |||
5853 | restoreStackSize(stackSize); | ||
5854 | |||
5855 | } | ||
5856 | return ; | ||
5857 | } | ||
5858 | // $ANTLR end "rule__ALSEnumDeclaration__Group__0__Impl" | ||
5859 | |||
5860 | |||
5861 | // $ANTLR start "rule__ALSEnumDeclaration__Group__1" | ||
5862 | // InternalAlloyLanguage.g:1721:1: rule__ALSEnumDeclaration__Group__1 : rule__ALSEnumDeclaration__Group__1__Impl rule__ALSEnumDeclaration__Group__2 ; | ||
5863 | public final void rule__ALSEnumDeclaration__Group__1() throws RecognitionException { | ||
5864 | |||
5865 | int stackSize = keepStackSize(); | ||
5866 | |||
5867 | try { | ||
5868 | // InternalAlloyLanguage.g:1725:1: ( rule__ALSEnumDeclaration__Group__1__Impl rule__ALSEnumDeclaration__Group__2 ) | ||
5869 | // InternalAlloyLanguage.g:1726:2: rule__ALSEnumDeclaration__Group__1__Impl rule__ALSEnumDeclaration__Group__2 | ||
5870 | { | ||
5871 | pushFollow(FOLLOW_6); | ||
5872 | rule__ALSEnumDeclaration__Group__1__Impl(); | ||
5873 | |||
5874 | state._fsp--; | ||
5875 | if (state.failed) return ; | ||
5876 | pushFollow(FOLLOW_2); | ||
5877 | rule__ALSEnumDeclaration__Group__2(); | ||
5878 | |||
5879 | state._fsp--; | ||
5880 | if (state.failed) return ; | ||
5881 | |||
5882 | } | ||
5883 | |||
5884 | } | ||
5885 | catch (RecognitionException re) { | ||
5886 | reportError(re); | ||
5887 | recover(input,re); | ||
5888 | } | ||
5889 | finally { | ||
5890 | |||
5891 | restoreStackSize(stackSize); | ||
5892 | |||
5893 | } | ||
5894 | return ; | ||
5895 | } | ||
5896 | // $ANTLR end "rule__ALSEnumDeclaration__Group__1" | ||
5897 | |||
5898 | |||
5899 | // $ANTLR start "rule__ALSEnumDeclaration__Group__1__Impl" | ||
5900 | // InternalAlloyLanguage.g:1733:1: rule__ALSEnumDeclaration__Group__1__Impl : ( ( rule__ALSEnumDeclaration__NameAssignment_1 ) ) ; | ||
5901 | public final void rule__ALSEnumDeclaration__Group__1__Impl() throws RecognitionException { | ||
5902 | |||
5903 | int stackSize = keepStackSize(); | ||
5904 | |||
5905 | try { | ||
5906 | // InternalAlloyLanguage.g:1737:1: ( ( ( rule__ALSEnumDeclaration__NameAssignment_1 ) ) ) | ||
5907 | // InternalAlloyLanguage.g:1738:1: ( ( rule__ALSEnumDeclaration__NameAssignment_1 ) ) | ||
5908 | { | ||
5909 | // InternalAlloyLanguage.g:1738:1: ( ( rule__ALSEnumDeclaration__NameAssignment_1 ) ) | ||
5910 | // InternalAlloyLanguage.g:1739:1: ( rule__ALSEnumDeclaration__NameAssignment_1 ) | ||
5911 | { | ||
5912 | if ( state.backtracking==0 ) { | ||
5913 | before(grammarAccess.getALSEnumDeclarationAccess().getNameAssignment_1()); | ||
5914 | } | ||
5915 | // InternalAlloyLanguage.g:1740:1: ( rule__ALSEnumDeclaration__NameAssignment_1 ) | ||
5916 | // InternalAlloyLanguage.g:1740:2: rule__ALSEnumDeclaration__NameAssignment_1 | ||
5917 | { | ||
5918 | pushFollow(FOLLOW_2); | ||
5919 | rule__ALSEnumDeclaration__NameAssignment_1(); | ||
5920 | |||
5921 | state._fsp--; | ||
5922 | if (state.failed) return ; | ||
5923 | |||
5924 | } | ||
5925 | |||
5926 | if ( state.backtracking==0 ) { | ||
5927 | after(grammarAccess.getALSEnumDeclarationAccess().getNameAssignment_1()); | ||
5928 | } | ||
5929 | |||
5930 | } | ||
5931 | |||
5932 | |||
5933 | } | ||
5934 | |||
5935 | } | ||
5936 | catch (RecognitionException re) { | ||
5937 | reportError(re); | ||
5938 | recover(input,re); | ||
5939 | } | ||
5940 | finally { | ||
5941 | |||
5942 | restoreStackSize(stackSize); | ||
5943 | |||
5944 | } | ||
5945 | return ; | ||
5946 | } | ||
5947 | // $ANTLR end "rule__ALSEnumDeclaration__Group__1__Impl" | ||
5948 | |||
5949 | |||
5950 | // $ANTLR start "rule__ALSEnumDeclaration__Group__2" | ||
5951 | // InternalAlloyLanguage.g:1750:1: rule__ALSEnumDeclaration__Group__2 : rule__ALSEnumDeclaration__Group__2__Impl rule__ALSEnumDeclaration__Group__3 ; | ||
5952 | public final void rule__ALSEnumDeclaration__Group__2() throws RecognitionException { | ||
5953 | |||
5954 | int stackSize = keepStackSize(); | ||
5955 | |||
5956 | try { | ||
5957 | // InternalAlloyLanguage.g:1754:1: ( rule__ALSEnumDeclaration__Group__2__Impl rule__ALSEnumDeclaration__Group__3 ) | ||
5958 | // InternalAlloyLanguage.g:1755:2: rule__ALSEnumDeclaration__Group__2__Impl rule__ALSEnumDeclaration__Group__3 | ||
5959 | { | ||
5960 | pushFollow(FOLLOW_5); | ||
5961 | rule__ALSEnumDeclaration__Group__2__Impl(); | ||
5962 | |||
5963 | state._fsp--; | ||
5964 | if (state.failed) return ; | ||
5965 | pushFollow(FOLLOW_2); | ||
5966 | rule__ALSEnumDeclaration__Group__3(); | ||
5967 | |||
5968 | state._fsp--; | ||
5969 | if (state.failed) return ; | ||
5970 | |||
5971 | } | ||
5972 | |||
5973 | } | ||
5974 | catch (RecognitionException re) { | ||
5975 | reportError(re); | ||
5976 | recover(input,re); | ||
5977 | } | ||
5978 | finally { | ||
5979 | |||
5980 | restoreStackSize(stackSize); | ||
5981 | |||
5982 | } | ||
5983 | return ; | ||
5984 | } | ||
5985 | // $ANTLR end "rule__ALSEnumDeclaration__Group__2" | ||
5986 | |||
5987 | |||
5988 | // $ANTLR start "rule__ALSEnumDeclaration__Group__2__Impl" | ||
5989 | // InternalAlloyLanguage.g:1762:1: rule__ALSEnumDeclaration__Group__2__Impl : ( '{' ) ; | ||
5990 | public final void rule__ALSEnumDeclaration__Group__2__Impl() throws RecognitionException { | ||
5991 | |||
5992 | int stackSize = keepStackSize(); | ||
5993 | |||
5994 | try { | ||
5995 | // InternalAlloyLanguage.g:1766:1: ( ( '{' ) ) | ||
5996 | // InternalAlloyLanguage.g:1767:1: ( '{' ) | ||
5997 | { | ||
5998 | // InternalAlloyLanguage.g:1767:1: ( '{' ) | ||
5999 | // InternalAlloyLanguage.g:1768:1: '{' | ||
6000 | { | ||
6001 | if ( state.backtracking==0 ) { | ||
6002 | before(grammarAccess.getALSEnumDeclarationAccess().getLeftCurlyBracketKeyword_2()); | ||
6003 | } | ||
6004 | match(input,33,FOLLOW_2); if (state.failed) return ; | ||
6005 | if ( state.backtracking==0 ) { | ||
6006 | after(grammarAccess.getALSEnumDeclarationAccess().getLeftCurlyBracketKeyword_2()); | ||
6007 | } | ||
6008 | |||
6009 | } | ||
6010 | |||
6011 | |||
6012 | } | ||
6013 | |||
6014 | } | ||
6015 | catch (RecognitionException re) { | ||
6016 | reportError(re); | ||
6017 | recover(input,re); | ||
6018 | } | ||
6019 | finally { | ||
6020 | |||
6021 | restoreStackSize(stackSize); | ||
6022 | |||
6023 | } | ||
6024 | return ; | ||
6025 | } | ||
6026 | // $ANTLR end "rule__ALSEnumDeclaration__Group__2__Impl" | ||
6027 | |||
6028 | |||
6029 | // $ANTLR start "rule__ALSEnumDeclaration__Group__3" | ||
6030 | // InternalAlloyLanguage.g:1781:1: rule__ALSEnumDeclaration__Group__3 : rule__ALSEnumDeclaration__Group__3__Impl rule__ALSEnumDeclaration__Group__4 ; | ||
6031 | public final void rule__ALSEnumDeclaration__Group__3() throws RecognitionException { | ||
6032 | |||
6033 | int stackSize = keepStackSize(); | ||
6034 | |||
6035 | try { | ||
6036 | // InternalAlloyLanguage.g:1785:1: ( rule__ALSEnumDeclaration__Group__3__Impl rule__ALSEnumDeclaration__Group__4 ) | ||
6037 | // InternalAlloyLanguage.g:1786:2: rule__ALSEnumDeclaration__Group__3__Impl rule__ALSEnumDeclaration__Group__4 | ||
6038 | { | ||
6039 | pushFollow(FOLLOW_7); | ||
6040 | rule__ALSEnumDeclaration__Group__3__Impl(); | ||
6041 | |||
6042 | state._fsp--; | ||
6043 | if (state.failed) return ; | ||
6044 | pushFollow(FOLLOW_2); | ||
6045 | rule__ALSEnumDeclaration__Group__4(); | ||
6046 | |||
6047 | state._fsp--; | ||
6048 | if (state.failed) return ; | ||
6049 | |||
6050 | } | ||
6051 | |||
6052 | } | ||
6053 | catch (RecognitionException re) { | ||
6054 | reportError(re); | ||
6055 | recover(input,re); | ||
6056 | } | ||
6057 | finally { | ||
6058 | |||
6059 | restoreStackSize(stackSize); | ||
6060 | |||
6061 | } | ||
6062 | return ; | ||
6063 | } | ||
6064 | // $ANTLR end "rule__ALSEnumDeclaration__Group__3" | ||
6065 | |||
6066 | |||
6067 | // $ANTLR start "rule__ALSEnumDeclaration__Group__3__Impl" | ||
6068 | // InternalAlloyLanguage.g:1793:1: rule__ALSEnumDeclaration__Group__3__Impl : ( ( rule__ALSEnumDeclaration__LiteralAssignment_3 ) ) ; | ||
6069 | public final void rule__ALSEnumDeclaration__Group__3__Impl() throws RecognitionException { | ||
6070 | |||
6071 | int stackSize = keepStackSize(); | ||
6072 | |||
6073 | try { | ||
6074 | // InternalAlloyLanguage.g:1797:1: ( ( ( rule__ALSEnumDeclaration__LiteralAssignment_3 ) ) ) | ||
6075 | // InternalAlloyLanguage.g:1798:1: ( ( rule__ALSEnumDeclaration__LiteralAssignment_3 ) ) | ||
6076 | { | ||
6077 | // InternalAlloyLanguage.g:1798:1: ( ( rule__ALSEnumDeclaration__LiteralAssignment_3 ) ) | ||
6078 | // InternalAlloyLanguage.g:1799:1: ( rule__ALSEnumDeclaration__LiteralAssignment_3 ) | ||
6079 | { | ||
6080 | if ( state.backtracking==0 ) { | ||
6081 | before(grammarAccess.getALSEnumDeclarationAccess().getLiteralAssignment_3()); | ||
6082 | } | ||
6083 | // InternalAlloyLanguage.g:1800:1: ( rule__ALSEnumDeclaration__LiteralAssignment_3 ) | ||
6084 | // InternalAlloyLanguage.g:1800:2: rule__ALSEnumDeclaration__LiteralAssignment_3 | ||
6085 | { | ||
6086 | pushFollow(FOLLOW_2); | ||
6087 | rule__ALSEnumDeclaration__LiteralAssignment_3(); | ||
6088 | |||
6089 | state._fsp--; | ||
6090 | if (state.failed) return ; | ||
6091 | |||
6092 | } | ||
6093 | |||
6094 | if ( state.backtracking==0 ) { | ||
6095 | after(grammarAccess.getALSEnumDeclarationAccess().getLiteralAssignment_3()); | ||
6096 | } | ||
6097 | |||
6098 | } | ||
6099 | |||
6100 | |||
6101 | } | ||
6102 | |||
6103 | } | ||
6104 | catch (RecognitionException re) { | ||
6105 | reportError(re); | ||
6106 | recover(input,re); | ||
6107 | } | ||
6108 | finally { | ||
6109 | |||
6110 | restoreStackSize(stackSize); | ||
6111 | |||
6112 | } | ||
6113 | return ; | ||
6114 | } | ||
6115 | // $ANTLR end "rule__ALSEnumDeclaration__Group__3__Impl" | ||
6116 | |||
6117 | |||
6118 | // $ANTLR start "rule__ALSEnumDeclaration__Group__4" | ||
6119 | // InternalAlloyLanguage.g:1810:1: rule__ALSEnumDeclaration__Group__4 : rule__ALSEnumDeclaration__Group__4__Impl rule__ALSEnumDeclaration__Group__5 ; | ||
6120 | public final void rule__ALSEnumDeclaration__Group__4() throws RecognitionException { | ||
6121 | |||
6122 | int stackSize = keepStackSize(); | ||
6123 | |||
6124 | try { | ||
6125 | // InternalAlloyLanguage.g:1814:1: ( rule__ALSEnumDeclaration__Group__4__Impl rule__ALSEnumDeclaration__Group__5 ) | ||
6126 | // InternalAlloyLanguage.g:1815:2: rule__ALSEnumDeclaration__Group__4__Impl rule__ALSEnumDeclaration__Group__5 | ||
6127 | { | ||
6128 | pushFollow(FOLLOW_7); | ||
6129 | rule__ALSEnumDeclaration__Group__4__Impl(); | ||
6130 | |||
6131 | state._fsp--; | ||
6132 | if (state.failed) return ; | ||
6133 | pushFollow(FOLLOW_2); | ||
6134 | rule__ALSEnumDeclaration__Group__5(); | ||
6135 | |||
6136 | state._fsp--; | ||
6137 | if (state.failed) return ; | ||
6138 | |||
6139 | } | ||
6140 | |||
6141 | } | ||
6142 | catch (RecognitionException re) { | ||
6143 | reportError(re); | ||
6144 | recover(input,re); | ||
6145 | } | ||
6146 | finally { | ||
6147 | |||
6148 | restoreStackSize(stackSize); | ||
6149 | |||
6150 | } | ||
6151 | return ; | ||
6152 | } | ||
6153 | // $ANTLR end "rule__ALSEnumDeclaration__Group__4" | ||
6154 | |||
6155 | |||
6156 | // $ANTLR start "rule__ALSEnumDeclaration__Group__4__Impl" | ||
6157 | // InternalAlloyLanguage.g:1822:1: rule__ALSEnumDeclaration__Group__4__Impl : ( ( rule__ALSEnumDeclaration__Group_4__0 )* ) ; | ||
6158 | public final void rule__ALSEnumDeclaration__Group__4__Impl() throws RecognitionException { | ||
6159 | |||
6160 | int stackSize = keepStackSize(); | ||
6161 | |||
6162 | try { | ||
6163 | // InternalAlloyLanguage.g:1826:1: ( ( ( rule__ALSEnumDeclaration__Group_4__0 )* ) ) | ||
6164 | // InternalAlloyLanguage.g:1827:1: ( ( rule__ALSEnumDeclaration__Group_4__0 )* ) | ||
6165 | { | ||
6166 | // InternalAlloyLanguage.g:1827:1: ( ( rule__ALSEnumDeclaration__Group_4__0 )* ) | ||
6167 | // InternalAlloyLanguage.g:1828:1: ( rule__ALSEnumDeclaration__Group_4__0 )* | ||
6168 | { | ||
6169 | if ( state.backtracking==0 ) { | ||
6170 | before(grammarAccess.getALSEnumDeclarationAccess().getGroup_4()); | ||
6171 | } | ||
6172 | // InternalAlloyLanguage.g:1829:1: ( rule__ALSEnumDeclaration__Group_4__0 )* | ||
6173 | loop18: | ||
6174 | do { | ||
6175 | int alt18=2; | ||
6176 | int LA18_0 = input.LA(1); | ||
6177 | |||
6178 | if ( (LA18_0==35) ) { | ||
6179 | alt18=1; | ||
6180 | } | ||
6181 | |||
6182 | |||
6183 | switch (alt18) { | ||
6184 | case 1 : | ||
6185 | // InternalAlloyLanguage.g:1829:2: rule__ALSEnumDeclaration__Group_4__0 | ||
6186 | { | ||
6187 | pushFollow(FOLLOW_8); | ||
6188 | rule__ALSEnumDeclaration__Group_4__0(); | ||
6189 | |||
6190 | state._fsp--; | ||
6191 | if (state.failed) return ; | ||
6192 | |||
6193 | } | ||
6194 | break; | ||
6195 | |||
6196 | default : | ||
6197 | break loop18; | ||
6198 | } | ||
6199 | } while (true); | ||
6200 | |||
6201 | if ( state.backtracking==0 ) { | ||
6202 | after(grammarAccess.getALSEnumDeclarationAccess().getGroup_4()); | ||
6203 | } | ||
6204 | |||
6205 | } | ||
6206 | |||
6207 | |||
6208 | } | ||
6209 | |||
6210 | } | ||
6211 | catch (RecognitionException re) { | ||
6212 | reportError(re); | ||
6213 | recover(input,re); | ||
6214 | } | ||
6215 | finally { | ||
6216 | |||
6217 | restoreStackSize(stackSize); | ||
6218 | |||
6219 | } | ||
6220 | return ; | ||
6221 | } | ||
6222 | // $ANTLR end "rule__ALSEnumDeclaration__Group__4__Impl" | ||
6223 | |||
6224 | |||
6225 | // $ANTLR start "rule__ALSEnumDeclaration__Group__5" | ||
6226 | // InternalAlloyLanguage.g:1839:1: rule__ALSEnumDeclaration__Group__5 : rule__ALSEnumDeclaration__Group__5__Impl ; | ||
6227 | public final void rule__ALSEnumDeclaration__Group__5() throws RecognitionException { | ||
6228 | |||
6229 | int stackSize = keepStackSize(); | ||
6230 | |||
6231 | try { | ||
6232 | // InternalAlloyLanguage.g:1843:1: ( rule__ALSEnumDeclaration__Group__5__Impl ) | ||
6233 | // InternalAlloyLanguage.g:1844:2: rule__ALSEnumDeclaration__Group__5__Impl | ||
6234 | { | ||
6235 | pushFollow(FOLLOW_2); | ||
6236 | rule__ALSEnumDeclaration__Group__5__Impl(); | ||
6237 | |||
6238 | state._fsp--; | ||
6239 | if (state.failed) return ; | ||
6240 | |||
6241 | } | ||
6242 | |||
6243 | } | ||
6244 | catch (RecognitionException re) { | ||
6245 | reportError(re); | ||
6246 | recover(input,re); | ||
6247 | } | ||
6248 | finally { | ||
6249 | |||
6250 | restoreStackSize(stackSize); | ||
6251 | |||
6252 | } | ||
6253 | return ; | ||
6254 | } | ||
6255 | // $ANTLR end "rule__ALSEnumDeclaration__Group__5" | ||
6256 | |||
6257 | |||
6258 | // $ANTLR start "rule__ALSEnumDeclaration__Group__5__Impl" | ||
6259 | // InternalAlloyLanguage.g:1850:1: rule__ALSEnumDeclaration__Group__5__Impl : ( '}' ) ; | ||
6260 | public final void rule__ALSEnumDeclaration__Group__5__Impl() throws RecognitionException { | ||
6261 | |||
6262 | int stackSize = keepStackSize(); | ||
6263 | |||
6264 | try { | ||
6265 | // InternalAlloyLanguage.g:1854:1: ( ( '}' ) ) | ||
6266 | // InternalAlloyLanguage.g:1855:1: ( '}' ) | ||
6267 | { | ||
6268 | // InternalAlloyLanguage.g:1855:1: ( '}' ) | ||
6269 | // InternalAlloyLanguage.g:1856:1: '}' | ||
6270 | { | ||
6271 | if ( state.backtracking==0 ) { | ||
6272 | before(grammarAccess.getALSEnumDeclarationAccess().getRightCurlyBracketKeyword_5()); | ||
6273 | } | ||
6274 | match(input,34,FOLLOW_2); if (state.failed) return ; | ||
6275 | if ( state.backtracking==0 ) { | ||
6276 | after(grammarAccess.getALSEnumDeclarationAccess().getRightCurlyBracketKeyword_5()); | ||
6277 | } | ||
6278 | |||
6279 | } | ||
6280 | |||
6281 | |||
6282 | } | ||
6283 | |||
6284 | } | ||
6285 | catch (RecognitionException re) { | ||
6286 | reportError(re); | ||
6287 | recover(input,re); | ||
6288 | } | ||
6289 | finally { | ||
6290 | |||
6291 | restoreStackSize(stackSize); | ||
6292 | |||
6293 | } | ||
6294 | return ; | ||
6295 | } | ||
6296 | // $ANTLR end "rule__ALSEnumDeclaration__Group__5__Impl" | ||
6297 | |||
6298 | |||
6299 | // $ANTLR start "rule__ALSEnumDeclaration__Group_4__0" | ||
6300 | // InternalAlloyLanguage.g:1881:1: rule__ALSEnumDeclaration__Group_4__0 : rule__ALSEnumDeclaration__Group_4__0__Impl rule__ALSEnumDeclaration__Group_4__1 ; | ||
6301 | public final void rule__ALSEnumDeclaration__Group_4__0() throws RecognitionException { | ||
6302 | |||
6303 | int stackSize = keepStackSize(); | ||
6304 | |||
6305 | try { | ||
6306 | // InternalAlloyLanguage.g:1885:1: ( rule__ALSEnumDeclaration__Group_4__0__Impl rule__ALSEnumDeclaration__Group_4__1 ) | ||
6307 | // InternalAlloyLanguage.g:1886:2: rule__ALSEnumDeclaration__Group_4__0__Impl rule__ALSEnumDeclaration__Group_4__1 | ||
6308 | { | ||
6309 | pushFollow(FOLLOW_5); | ||
6310 | rule__ALSEnumDeclaration__Group_4__0__Impl(); | ||
6311 | |||
6312 | state._fsp--; | ||
6313 | if (state.failed) return ; | ||
6314 | pushFollow(FOLLOW_2); | ||
6315 | rule__ALSEnumDeclaration__Group_4__1(); | ||
6316 | |||
6317 | state._fsp--; | ||
6318 | if (state.failed) return ; | ||
6319 | |||
6320 | } | ||
6321 | |||
6322 | } | ||
6323 | catch (RecognitionException re) { | ||
6324 | reportError(re); | ||
6325 | recover(input,re); | ||
6326 | } | ||
6327 | finally { | ||
6328 | |||
6329 | restoreStackSize(stackSize); | ||
6330 | |||
6331 | } | ||
6332 | return ; | ||
6333 | } | ||
6334 | // $ANTLR end "rule__ALSEnumDeclaration__Group_4__0" | ||
6335 | |||
6336 | |||
6337 | // $ANTLR start "rule__ALSEnumDeclaration__Group_4__0__Impl" | ||
6338 | // InternalAlloyLanguage.g:1893:1: rule__ALSEnumDeclaration__Group_4__0__Impl : ( ',' ) ; | ||
6339 | public final void rule__ALSEnumDeclaration__Group_4__0__Impl() throws RecognitionException { | ||
6340 | |||
6341 | int stackSize = keepStackSize(); | ||
6342 | |||
6343 | try { | ||
6344 | // InternalAlloyLanguage.g:1897:1: ( ( ',' ) ) | ||
6345 | // InternalAlloyLanguage.g:1898:1: ( ',' ) | ||
6346 | { | ||
6347 | // InternalAlloyLanguage.g:1898:1: ( ',' ) | ||
6348 | // InternalAlloyLanguage.g:1899:1: ',' | ||
6349 | { | ||
6350 | if ( state.backtracking==0 ) { | ||
6351 | before(grammarAccess.getALSEnumDeclarationAccess().getCommaKeyword_4_0()); | ||
6352 | } | ||
6353 | match(input,35,FOLLOW_2); if (state.failed) return ; | ||
6354 | if ( state.backtracking==0 ) { | ||
6355 | after(grammarAccess.getALSEnumDeclarationAccess().getCommaKeyword_4_0()); | ||
6356 | } | ||
6357 | |||
6358 | } | ||
6359 | |||
6360 | |||
6361 | } | ||
6362 | |||
6363 | } | ||
6364 | catch (RecognitionException re) { | ||
6365 | reportError(re); | ||
6366 | recover(input,re); | ||
6367 | } | ||
6368 | finally { | ||
6369 | |||
6370 | restoreStackSize(stackSize); | ||
6371 | |||
6372 | } | ||
6373 | return ; | ||
6374 | } | ||
6375 | // $ANTLR end "rule__ALSEnumDeclaration__Group_4__0__Impl" | ||
6376 | |||
6377 | |||
6378 | // $ANTLR start "rule__ALSEnumDeclaration__Group_4__1" | ||
6379 | // InternalAlloyLanguage.g:1912:1: rule__ALSEnumDeclaration__Group_4__1 : rule__ALSEnumDeclaration__Group_4__1__Impl ; | ||
6380 | public final void rule__ALSEnumDeclaration__Group_4__1() throws RecognitionException { | ||
6381 | |||
6382 | int stackSize = keepStackSize(); | ||
6383 | |||
6384 | try { | ||
6385 | // InternalAlloyLanguage.g:1916:1: ( rule__ALSEnumDeclaration__Group_4__1__Impl ) | ||
6386 | // InternalAlloyLanguage.g:1917:2: rule__ALSEnumDeclaration__Group_4__1__Impl | ||
6387 | { | ||
6388 | pushFollow(FOLLOW_2); | ||
6389 | rule__ALSEnumDeclaration__Group_4__1__Impl(); | ||
6390 | |||
6391 | state._fsp--; | ||
6392 | if (state.failed) return ; | ||
6393 | |||
6394 | } | ||
6395 | |||
6396 | } | ||
6397 | catch (RecognitionException re) { | ||
6398 | reportError(re); | ||
6399 | recover(input,re); | ||
6400 | } | ||
6401 | finally { | ||
6402 | |||
6403 | restoreStackSize(stackSize); | ||
6404 | |||
6405 | } | ||
6406 | return ; | ||
6407 | } | ||
6408 | // $ANTLR end "rule__ALSEnumDeclaration__Group_4__1" | ||
6409 | |||
6410 | |||
6411 | // $ANTLR start "rule__ALSEnumDeclaration__Group_4__1__Impl" | ||
6412 | // InternalAlloyLanguage.g:1923:1: rule__ALSEnumDeclaration__Group_4__1__Impl : ( ( rule__ALSEnumDeclaration__LiteralAssignment_4_1 ) ) ; | ||
6413 | public final void rule__ALSEnumDeclaration__Group_4__1__Impl() throws RecognitionException { | ||
6414 | |||
6415 | int stackSize = keepStackSize(); | ||
6416 | |||
6417 | try { | ||
6418 | // InternalAlloyLanguage.g:1927:1: ( ( ( rule__ALSEnumDeclaration__LiteralAssignment_4_1 ) ) ) | ||
6419 | // InternalAlloyLanguage.g:1928:1: ( ( rule__ALSEnumDeclaration__LiteralAssignment_4_1 ) ) | ||
6420 | { | ||
6421 | // InternalAlloyLanguage.g:1928:1: ( ( rule__ALSEnumDeclaration__LiteralAssignment_4_1 ) ) | ||
6422 | // InternalAlloyLanguage.g:1929:1: ( rule__ALSEnumDeclaration__LiteralAssignment_4_1 ) | ||
6423 | { | ||
6424 | if ( state.backtracking==0 ) { | ||
6425 | before(grammarAccess.getALSEnumDeclarationAccess().getLiteralAssignment_4_1()); | ||
6426 | } | ||
6427 | // InternalAlloyLanguage.g:1930:1: ( rule__ALSEnumDeclaration__LiteralAssignment_4_1 ) | ||
6428 | // InternalAlloyLanguage.g:1930:2: rule__ALSEnumDeclaration__LiteralAssignment_4_1 | ||
6429 | { | ||
6430 | pushFollow(FOLLOW_2); | ||
6431 | rule__ALSEnumDeclaration__LiteralAssignment_4_1(); | ||
6432 | |||
6433 | state._fsp--; | ||
6434 | if (state.failed) return ; | ||
6435 | |||
6436 | } | ||
6437 | |||
6438 | if ( state.backtracking==0 ) { | ||
6439 | after(grammarAccess.getALSEnumDeclarationAccess().getLiteralAssignment_4_1()); | ||
6440 | } | ||
6441 | |||
6442 | } | ||
6443 | |||
6444 | |||
6445 | } | ||
6446 | |||
6447 | } | ||
6448 | catch (RecognitionException re) { | ||
6449 | reportError(re); | ||
6450 | recover(input,re); | ||
6451 | } | ||
6452 | finally { | ||
6453 | |||
6454 | restoreStackSize(stackSize); | ||
6455 | |||
6456 | } | ||
6457 | return ; | ||
6458 | } | ||
6459 | // $ANTLR end "rule__ALSEnumDeclaration__Group_4__1__Impl" | ||
6460 | |||
6461 | |||
6462 | // $ANTLR start "rule__ALSSignatureBody__Group__0" | ||
6463 | // InternalAlloyLanguage.g:1944:1: rule__ALSSignatureBody__Group__0 : rule__ALSSignatureBody__Group__0__Impl rule__ALSSignatureBody__Group__1 ; | ||
6464 | public final void rule__ALSSignatureBody__Group__0() throws RecognitionException { | ||
6465 | |||
6466 | int stackSize = keepStackSize(); | ||
6467 | |||
6468 | try { | ||
6469 | // InternalAlloyLanguage.g:1948:1: ( rule__ALSSignatureBody__Group__0__Impl rule__ALSSignatureBody__Group__1 ) | ||
6470 | // InternalAlloyLanguage.g:1949:2: rule__ALSSignatureBody__Group__0__Impl rule__ALSSignatureBody__Group__1 | ||
6471 | { | ||
6472 | pushFollow(FOLLOW_9); | ||
6473 | rule__ALSSignatureBody__Group__0__Impl(); | ||
6474 | |||
6475 | state._fsp--; | ||
6476 | if (state.failed) return ; | ||
6477 | pushFollow(FOLLOW_2); | ||
6478 | rule__ALSSignatureBody__Group__1(); | ||
6479 | |||
6480 | state._fsp--; | ||
6481 | if (state.failed) return ; | ||
6482 | |||
6483 | } | ||
6484 | |||
6485 | } | ||
6486 | catch (RecognitionException re) { | ||
6487 | reportError(re); | ||
6488 | recover(input,re); | ||
6489 | } | ||
6490 | finally { | ||
6491 | |||
6492 | restoreStackSize(stackSize); | ||
6493 | |||
6494 | } | ||
6495 | return ; | ||
6496 | } | ||
6497 | // $ANTLR end "rule__ALSSignatureBody__Group__0" | ||
6498 | |||
6499 | |||
6500 | // $ANTLR start "rule__ALSSignatureBody__Group__0__Impl" | ||
6501 | // InternalAlloyLanguage.g:1956:1: rule__ALSSignatureBody__Group__0__Impl : ( ( rule__ALSSignatureBody__UnorderedGroup_0 ) ) ; | ||
6502 | public final void rule__ALSSignatureBody__Group__0__Impl() throws RecognitionException { | ||
6503 | |||
6504 | int stackSize = keepStackSize(); | ||
6505 | |||
6506 | try { | ||
6507 | // InternalAlloyLanguage.g:1960:1: ( ( ( rule__ALSSignatureBody__UnorderedGroup_0 ) ) ) | ||
6508 | // InternalAlloyLanguage.g:1961:1: ( ( rule__ALSSignatureBody__UnorderedGroup_0 ) ) | ||
6509 | { | ||
6510 | // InternalAlloyLanguage.g:1961:1: ( ( rule__ALSSignatureBody__UnorderedGroup_0 ) ) | ||
6511 | // InternalAlloyLanguage.g:1962:1: ( rule__ALSSignatureBody__UnorderedGroup_0 ) | ||
6512 | { | ||
6513 | if ( state.backtracking==0 ) { | ||
6514 | before(grammarAccess.getALSSignatureBodyAccess().getUnorderedGroup_0()); | ||
6515 | } | ||
6516 | // InternalAlloyLanguage.g:1963:1: ( rule__ALSSignatureBody__UnorderedGroup_0 ) | ||
6517 | // InternalAlloyLanguage.g:1963:2: rule__ALSSignatureBody__UnorderedGroup_0 | ||
6518 | { | ||
6519 | pushFollow(FOLLOW_2); | ||
6520 | rule__ALSSignatureBody__UnorderedGroup_0(); | ||
6521 | |||
6522 | state._fsp--; | ||
6523 | if (state.failed) return ; | ||
6524 | |||
6525 | } | ||
6526 | |||
6527 | if ( state.backtracking==0 ) { | ||
6528 | after(grammarAccess.getALSSignatureBodyAccess().getUnorderedGroup_0()); | ||
6529 | } | ||
6530 | |||
6531 | } | ||
6532 | |||
6533 | |||
6534 | } | ||
6535 | |||
6536 | } | ||
6537 | catch (RecognitionException re) { | ||
6538 | reportError(re); | ||
6539 | recover(input,re); | ||
6540 | } | ||
6541 | finally { | ||
6542 | |||
6543 | restoreStackSize(stackSize); | ||
6544 | |||
6545 | } | ||
6546 | return ; | ||
6547 | } | ||
6548 | // $ANTLR end "rule__ALSSignatureBody__Group__0__Impl" | ||
6549 | |||
6550 | |||
6551 | // $ANTLR start "rule__ALSSignatureBody__Group__1" | ||
6552 | // InternalAlloyLanguage.g:1973:1: rule__ALSSignatureBody__Group__1 : rule__ALSSignatureBody__Group__1__Impl rule__ALSSignatureBody__Group__2 ; | ||
6553 | public final void rule__ALSSignatureBody__Group__1() throws RecognitionException { | ||
6554 | |||
6555 | int stackSize = keepStackSize(); | ||
6556 | |||
6557 | try { | ||
6558 | // InternalAlloyLanguage.g:1977:1: ( rule__ALSSignatureBody__Group__1__Impl rule__ALSSignatureBody__Group__2 ) | ||
6559 | // InternalAlloyLanguage.g:1978:2: rule__ALSSignatureBody__Group__1__Impl rule__ALSSignatureBody__Group__2 | ||
6560 | { | ||
6561 | pushFollow(FOLLOW_5); | ||
6562 | rule__ALSSignatureBody__Group__1__Impl(); | ||
6563 | |||
6564 | state._fsp--; | ||
6565 | if (state.failed) return ; | ||
6566 | pushFollow(FOLLOW_2); | ||
6567 | rule__ALSSignatureBody__Group__2(); | ||
6568 | |||
6569 | state._fsp--; | ||
6570 | if (state.failed) return ; | ||
6571 | |||
6572 | } | ||
6573 | |||
6574 | } | ||
6575 | catch (RecognitionException re) { | ||
6576 | reportError(re); | ||
6577 | recover(input,re); | ||
6578 | } | ||
6579 | finally { | ||
6580 | |||
6581 | restoreStackSize(stackSize); | ||
6582 | |||
6583 | } | ||
6584 | return ; | ||
6585 | } | ||
6586 | // $ANTLR end "rule__ALSSignatureBody__Group__1" | ||
6587 | |||
6588 | |||
6589 | // $ANTLR start "rule__ALSSignatureBody__Group__1__Impl" | ||
6590 | // InternalAlloyLanguage.g:1985:1: rule__ALSSignatureBody__Group__1__Impl : ( 'sig' ) ; | ||
6591 | public final void rule__ALSSignatureBody__Group__1__Impl() throws RecognitionException { | ||
6592 | |||
6593 | int stackSize = keepStackSize(); | ||
6594 | |||
6595 | try { | ||
6596 | // InternalAlloyLanguage.g:1989:1: ( ( 'sig' ) ) | ||
6597 | // InternalAlloyLanguage.g:1990:1: ( 'sig' ) | ||
6598 | { | ||
6599 | // InternalAlloyLanguage.g:1990:1: ( 'sig' ) | ||
6600 | // InternalAlloyLanguage.g:1991:1: 'sig' | ||
6601 | { | ||
6602 | if ( state.backtracking==0 ) { | ||
6603 | before(grammarAccess.getALSSignatureBodyAccess().getSigKeyword_1()); | ||
6604 | } | ||
6605 | match(input,36,FOLLOW_2); if (state.failed) return ; | ||
6606 | if ( state.backtracking==0 ) { | ||
6607 | after(grammarAccess.getALSSignatureBodyAccess().getSigKeyword_1()); | ||
6608 | } | ||
6609 | |||
6610 | } | ||
6611 | |||
6612 | |||
6613 | } | ||
6614 | |||
6615 | } | ||
6616 | catch (RecognitionException re) { | ||
6617 | reportError(re); | ||
6618 | recover(input,re); | ||
6619 | } | ||
6620 | finally { | ||
6621 | |||
6622 | restoreStackSize(stackSize); | ||
6623 | |||
6624 | } | ||
6625 | return ; | ||
6626 | } | ||
6627 | // $ANTLR end "rule__ALSSignatureBody__Group__1__Impl" | ||
6628 | |||
6629 | |||
6630 | // $ANTLR start "rule__ALSSignatureBody__Group__2" | ||
6631 | // InternalAlloyLanguage.g:2004:1: rule__ALSSignatureBody__Group__2 : rule__ALSSignatureBody__Group__2__Impl rule__ALSSignatureBody__Group__3 ; | ||
6632 | public final void rule__ALSSignatureBody__Group__2() throws RecognitionException { | ||
6633 | |||
6634 | int stackSize = keepStackSize(); | ||
6635 | |||
6636 | try { | ||
6637 | // InternalAlloyLanguage.g:2008:1: ( rule__ALSSignatureBody__Group__2__Impl rule__ALSSignatureBody__Group__3 ) | ||
6638 | // InternalAlloyLanguage.g:2009:2: rule__ALSSignatureBody__Group__2__Impl rule__ALSSignatureBody__Group__3 | ||
6639 | { | ||
6640 | pushFollow(FOLLOW_10); | ||
6641 | rule__ALSSignatureBody__Group__2__Impl(); | ||
6642 | |||
6643 | state._fsp--; | ||
6644 | if (state.failed) return ; | ||
6645 | pushFollow(FOLLOW_2); | ||
6646 | rule__ALSSignatureBody__Group__3(); | ||
6647 | |||
6648 | state._fsp--; | ||
6649 | if (state.failed) return ; | ||
6650 | |||
6651 | } | ||
6652 | |||
6653 | } | ||
6654 | catch (RecognitionException re) { | ||
6655 | reportError(re); | ||
6656 | recover(input,re); | ||
6657 | } | ||
6658 | finally { | ||
6659 | |||
6660 | restoreStackSize(stackSize); | ||
6661 | |||
6662 | } | ||
6663 | return ; | ||
6664 | } | ||
6665 | // $ANTLR end "rule__ALSSignatureBody__Group__2" | ||
6666 | |||
6667 | |||
6668 | // $ANTLR start "rule__ALSSignatureBody__Group__2__Impl" | ||
6669 | // InternalAlloyLanguage.g:2016:1: rule__ALSSignatureBody__Group__2__Impl : ( ( rule__ALSSignatureBody__DeclarationsAssignment_2 ) ) ; | ||
6670 | public final void rule__ALSSignatureBody__Group__2__Impl() throws RecognitionException { | ||
6671 | |||
6672 | int stackSize = keepStackSize(); | ||
6673 | |||
6674 | try { | ||
6675 | // InternalAlloyLanguage.g:2020:1: ( ( ( rule__ALSSignatureBody__DeclarationsAssignment_2 ) ) ) | ||
6676 | // InternalAlloyLanguage.g:2021:1: ( ( rule__ALSSignatureBody__DeclarationsAssignment_2 ) ) | ||
6677 | { | ||
6678 | // InternalAlloyLanguage.g:2021:1: ( ( rule__ALSSignatureBody__DeclarationsAssignment_2 ) ) | ||
6679 | // InternalAlloyLanguage.g:2022:1: ( rule__ALSSignatureBody__DeclarationsAssignment_2 ) | ||
6680 | { | ||
6681 | if ( state.backtracking==0 ) { | ||
6682 | before(grammarAccess.getALSSignatureBodyAccess().getDeclarationsAssignment_2()); | ||
6683 | } | ||
6684 | // InternalAlloyLanguage.g:2023:1: ( rule__ALSSignatureBody__DeclarationsAssignment_2 ) | ||
6685 | // InternalAlloyLanguage.g:2023:2: rule__ALSSignatureBody__DeclarationsAssignment_2 | ||
6686 | { | ||
6687 | pushFollow(FOLLOW_2); | ||
6688 | rule__ALSSignatureBody__DeclarationsAssignment_2(); | ||
6689 | |||
6690 | state._fsp--; | ||
6691 | if (state.failed) return ; | ||
6692 | |||
6693 | } | ||
6694 | |||
6695 | if ( state.backtracking==0 ) { | ||
6696 | after(grammarAccess.getALSSignatureBodyAccess().getDeclarationsAssignment_2()); | ||
6697 | } | ||
6698 | |||
6699 | } | ||
6700 | |||
6701 | |||
6702 | } | ||
6703 | |||
6704 | } | ||
6705 | catch (RecognitionException re) { | ||
6706 | reportError(re); | ||
6707 | recover(input,re); | ||
6708 | } | ||
6709 | finally { | ||
6710 | |||
6711 | restoreStackSize(stackSize); | ||
6712 | |||
6713 | } | ||
6714 | return ; | ||
6715 | } | ||
6716 | // $ANTLR end "rule__ALSSignatureBody__Group__2__Impl" | ||
6717 | |||
6718 | |||
6719 | // $ANTLR start "rule__ALSSignatureBody__Group__3" | ||
6720 | // InternalAlloyLanguage.g:2033:1: rule__ALSSignatureBody__Group__3 : rule__ALSSignatureBody__Group__3__Impl rule__ALSSignatureBody__Group__4 ; | ||
6721 | public final void rule__ALSSignatureBody__Group__3() throws RecognitionException { | ||
6722 | |||
6723 | int stackSize = keepStackSize(); | ||
6724 | |||
6725 | try { | ||
6726 | // InternalAlloyLanguage.g:2037:1: ( rule__ALSSignatureBody__Group__3__Impl rule__ALSSignatureBody__Group__4 ) | ||
6727 | // InternalAlloyLanguage.g:2038:2: rule__ALSSignatureBody__Group__3__Impl rule__ALSSignatureBody__Group__4 | ||
6728 | { | ||
6729 | pushFollow(FOLLOW_10); | ||
6730 | rule__ALSSignatureBody__Group__3__Impl(); | ||
6731 | |||
6732 | state._fsp--; | ||
6733 | if (state.failed) return ; | ||
6734 | pushFollow(FOLLOW_2); | ||
6735 | rule__ALSSignatureBody__Group__4(); | ||
6736 | |||
6737 | state._fsp--; | ||
6738 | if (state.failed) return ; | ||
6739 | |||
6740 | } | ||
6741 | |||
6742 | } | ||
6743 | catch (RecognitionException re) { | ||
6744 | reportError(re); | ||
6745 | recover(input,re); | ||
6746 | } | ||
6747 | finally { | ||
6748 | |||
6749 | restoreStackSize(stackSize); | ||
6750 | |||
6751 | } | ||
6752 | return ; | ||
6753 | } | ||
6754 | // $ANTLR end "rule__ALSSignatureBody__Group__3" | ||
6755 | |||
6756 | |||
6757 | // $ANTLR start "rule__ALSSignatureBody__Group__3__Impl" | ||
6758 | // InternalAlloyLanguage.g:2045:1: rule__ALSSignatureBody__Group__3__Impl : ( ( rule__ALSSignatureBody__Group_3__0 )* ) ; | ||
6759 | public final void rule__ALSSignatureBody__Group__3__Impl() throws RecognitionException { | ||
6760 | |||
6761 | int stackSize = keepStackSize(); | ||
6762 | |||
6763 | try { | ||
6764 | // InternalAlloyLanguage.g:2049:1: ( ( ( rule__ALSSignatureBody__Group_3__0 )* ) ) | ||
6765 | // InternalAlloyLanguage.g:2050:1: ( ( rule__ALSSignatureBody__Group_3__0 )* ) | ||
6766 | { | ||
6767 | // InternalAlloyLanguage.g:2050:1: ( ( rule__ALSSignatureBody__Group_3__0 )* ) | ||
6768 | // InternalAlloyLanguage.g:2051:1: ( rule__ALSSignatureBody__Group_3__0 )* | ||
6769 | { | ||
6770 | if ( state.backtracking==0 ) { | ||
6771 | before(grammarAccess.getALSSignatureBodyAccess().getGroup_3()); | ||
6772 | } | ||
6773 | // InternalAlloyLanguage.g:2052:1: ( rule__ALSSignatureBody__Group_3__0 )* | ||
6774 | loop19: | ||
6775 | do { | ||
6776 | int alt19=2; | ||
6777 | int LA19_0 = input.LA(1); | ||
6778 | |||
6779 | if ( (LA19_0==35) ) { | ||
6780 | alt19=1; | ||
6781 | } | ||
6782 | |||
6783 | |||
6784 | switch (alt19) { | ||
6785 | case 1 : | ||
6786 | // InternalAlloyLanguage.g:2052:2: rule__ALSSignatureBody__Group_3__0 | ||
6787 | { | ||
6788 | pushFollow(FOLLOW_8); | ||
6789 | rule__ALSSignatureBody__Group_3__0(); | ||
6790 | |||
6791 | state._fsp--; | ||
6792 | if (state.failed) return ; | ||
6793 | |||
6794 | } | ||
6795 | break; | ||
6796 | |||
6797 | default : | ||
6798 | break loop19; | ||
6799 | } | ||
6800 | } while (true); | ||
6801 | |||
6802 | if ( state.backtracking==0 ) { | ||
6803 | after(grammarAccess.getALSSignatureBodyAccess().getGroup_3()); | ||
6804 | } | ||
6805 | |||
6806 | } | ||
6807 | |||
6808 | |||
6809 | } | ||
6810 | |||
6811 | } | ||
6812 | catch (RecognitionException re) { | ||
6813 | reportError(re); | ||
6814 | recover(input,re); | ||
6815 | } | ||
6816 | finally { | ||
6817 | |||
6818 | restoreStackSize(stackSize); | ||
6819 | |||
6820 | } | ||
6821 | return ; | ||
6822 | } | ||
6823 | // $ANTLR end "rule__ALSSignatureBody__Group__3__Impl" | ||
6824 | |||
6825 | |||
6826 | // $ANTLR start "rule__ALSSignatureBody__Group__4" | ||
6827 | // InternalAlloyLanguage.g:2062:1: rule__ALSSignatureBody__Group__4 : rule__ALSSignatureBody__Group__4__Impl rule__ALSSignatureBody__Group__5 ; | ||
6828 | public final void rule__ALSSignatureBody__Group__4() throws RecognitionException { | ||
6829 | |||
6830 | int stackSize = keepStackSize(); | ||
6831 | |||
6832 | try { | ||
6833 | // InternalAlloyLanguage.g:2066:1: ( rule__ALSSignatureBody__Group__4__Impl rule__ALSSignatureBody__Group__5 ) | ||
6834 | // InternalAlloyLanguage.g:2067:2: rule__ALSSignatureBody__Group__4__Impl rule__ALSSignatureBody__Group__5 | ||
6835 | { | ||
6836 | pushFollow(FOLLOW_10); | ||
6837 | rule__ALSSignatureBody__Group__4__Impl(); | ||
6838 | |||
6839 | state._fsp--; | ||
6840 | if (state.failed) return ; | ||
6841 | pushFollow(FOLLOW_2); | ||
6842 | rule__ALSSignatureBody__Group__5(); | ||
6843 | |||
6844 | state._fsp--; | ||
6845 | if (state.failed) return ; | ||
6846 | |||
6847 | } | ||
6848 | |||
6849 | } | ||
6850 | catch (RecognitionException re) { | ||
6851 | reportError(re); | ||
6852 | recover(input,re); | ||
6853 | } | ||
6854 | finally { | ||
6855 | |||
6856 | restoreStackSize(stackSize); | ||
6857 | |||
6858 | } | ||
6859 | return ; | ||
6860 | } | ||
6861 | // $ANTLR end "rule__ALSSignatureBody__Group__4" | ||
6862 | |||
6863 | |||
6864 | // $ANTLR start "rule__ALSSignatureBody__Group__4__Impl" | ||
6865 | // InternalAlloyLanguage.g:2074:1: rule__ALSSignatureBody__Group__4__Impl : ( ( rule__ALSSignatureBody__Alternatives_4 )? ) ; | ||
6866 | public final void rule__ALSSignatureBody__Group__4__Impl() throws RecognitionException { | ||
6867 | |||
6868 | int stackSize = keepStackSize(); | ||
6869 | |||
6870 | try { | ||
6871 | // InternalAlloyLanguage.g:2078:1: ( ( ( rule__ALSSignatureBody__Alternatives_4 )? ) ) | ||
6872 | // InternalAlloyLanguage.g:2079:1: ( ( rule__ALSSignatureBody__Alternatives_4 )? ) | ||
6873 | { | ||
6874 | // InternalAlloyLanguage.g:2079:1: ( ( rule__ALSSignatureBody__Alternatives_4 )? ) | ||
6875 | // InternalAlloyLanguage.g:2080:1: ( rule__ALSSignatureBody__Alternatives_4 )? | ||
6876 | { | ||
6877 | if ( state.backtracking==0 ) { | ||
6878 | before(grammarAccess.getALSSignatureBodyAccess().getAlternatives_4()); | ||
6879 | } | ||
6880 | // InternalAlloyLanguage.g:2081:1: ( rule__ALSSignatureBody__Alternatives_4 )? | ||
6881 | int alt20=2; | ||
6882 | int LA20_0 = input.LA(1); | ||
6883 | |||
6884 | if ( ((LA20_0>=37 && LA20_0<=38)) ) { | ||
6885 | alt20=1; | ||
6886 | } | ||
6887 | switch (alt20) { | ||
6888 | case 1 : | ||
6889 | // InternalAlloyLanguage.g:2081:2: rule__ALSSignatureBody__Alternatives_4 | ||
6890 | { | ||
6891 | pushFollow(FOLLOW_2); | ||
6892 | rule__ALSSignatureBody__Alternatives_4(); | ||
6893 | |||
6894 | state._fsp--; | ||
6895 | if (state.failed) return ; | ||
6896 | |||
6897 | } | ||
6898 | break; | ||
6899 | |||
6900 | } | ||
6901 | |||
6902 | if ( state.backtracking==0 ) { | ||
6903 | after(grammarAccess.getALSSignatureBodyAccess().getAlternatives_4()); | ||
6904 | } | ||
6905 | |||
6906 | } | ||
6907 | |||
6908 | |||
6909 | } | ||
6910 | |||
6911 | } | ||
6912 | catch (RecognitionException re) { | ||
6913 | reportError(re); | ||
6914 | recover(input,re); | ||
6915 | } | ||
6916 | finally { | ||
6917 | |||
6918 | restoreStackSize(stackSize); | ||
6919 | |||
6920 | } | ||
6921 | return ; | ||
6922 | } | ||
6923 | // $ANTLR end "rule__ALSSignatureBody__Group__4__Impl" | ||
6924 | |||
6925 | |||
6926 | // $ANTLR start "rule__ALSSignatureBody__Group__5" | ||
6927 | // InternalAlloyLanguage.g:2091:1: rule__ALSSignatureBody__Group__5 : rule__ALSSignatureBody__Group__5__Impl rule__ALSSignatureBody__Group__6 ; | ||
6928 | public final void rule__ALSSignatureBody__Group__5() throws RecognitionException { | ||
6929 | |||
6930 | int stackSize = keepStackSize(); | ||
6931 | |||
6932 | try { | ||
6933 | // InternalAlloyLanguage.g:2095:1: ( rule__ALSSignatureBody__Group__5__Impl rule__ALSSignatureBody__Group__6 ) | ||
6934 | // InternalAlloyLanguage.g:2096:2: rule__ALSSignatureBody__Group__5__Impl rule__ALSSignatureBody__Group__6 | ||
6935 | { | ||
6936 | pushFollow(FOLLOW_11); | ||
6937 | rule__ALSSignatureBody__Group__5__Impl(); | ||
6938 | |||
6939 | state._fsp--; | ||
6940 | if (state.failed) return ; | ||
6941 | pushFollow(FOLLOW_2); | ||
6942 | rule__ALSSignatureBody__Group__6(); | ||
6943 | |||
6944 | state._fsp--; | ||
6945 | if (state.failed) return ; | ||
6946 | |||
6947 | } | ||
6948 | |||
6949 | } | ||
6950 | catch (RecognitionException re) { | ||
6951 | reportError(re); | ||
6952 | recover(input,re); | ||
6953 | } | ||
6954 | finally { | ||
6955 | |||
6956 | restoreStackSize(stackSize); | ||
6957 | |||
6958 | } | ||
6959 | return ; | ||
6960 | } | ||
6961 | // $ANTLR end "rule__ALSSignatureBody__Group__5" | ||
6962 | |||
6963 | |||
6964 | // $ANTLR start "rule__ALSSignatureBody__Group__5__Impl" | ||
6965 | // InternalAlloyLanguage.g:2103:1: rule__ALSSignatureBody__Group__5__Impl : ( '{' ) ; | ||
6966 | public final void rule__ALSSignatureBody__Group__5__Impl() throws RecognitionException { | ||
6967 | |||
6968 | int stackSize = keepStackSize(); | ||
6969 | |||
6970 | try { | ||
6971 | // InternalAlloyLanguage.g:2107:1: ( ( '{' ) ) | ||
6972 | // InternalAlloyLanguage.g:2108:1: ( '{' ) | ||
6973 | { | ||
6974 | // InternalAlloyLanguage.g:2108:1: ( '{' ) | ||
6975 | // InternalAlloyLanguage.g:2109:1: '{' | ||
6976 | { | ||
6977 | if ( state.backtracking==0 ) { | ||
6978 | before(grammarAccess.getALSSignatureBodyAccess().getLeftCurlyBracketKeyword_5()); | ||
6979 | } | ||
6980 | match(input,33,FOLLOW_2); if (state.failed) return ; | ||
6981 | if ( state.backtracking==0 ) { | ||
6982 | after(grammarAccess.getALSSignatureBodyAccess().getLeftCurlyBracketKeyword_5()); | ||
6983 | } | ||
6984 | |||
6985 | } | ||
6986 | |||
6987 | |||
6988 | } | ||
6989 | |||
6990 | } | ||
6991 | catch (RecognitionException re) { | ||
6992 | reportError(re); | ||
6993 | recover(input,re); | ||
6994 | } | ||
6995 | finally { | ||
6996 | |||
6997 | restoreStackSize(stackSize); | ||
6998 | |||
6999 | } | ||
7000 | return ; | ||
7001 | } | ||
7002 | // $ANTLR end "rule__ALSSignatureBody__Group__5__Impl" | ||
7003 | |||
7004 | |||
7005 | // $ANTLR start "rule__ALSSignatureBody__Group__6" | ||
7006 | // InternalAlloyLanguage.g:2122:1: rule__ALSSignatureBody__Group__6 : rule__ALSSignatureBody__Group__6__Impl rule__ALSSignatureBody__Group__7 ; | ||
7007 | public final void rule__ALSSignatureBody__Group__6() throws RecognitionException { | ||
7008 | |||
7009 | int stackSize = keepStackSize(); | ||
7010 | |||
7011 | try { | ||
7012 | // InternalAlloyLanguage.g:2126:1: ( rule__ALSSignatureBody__Group__6__Impl rule__ALSSignatureBody__Group__7 ) | ||
7013 | // InternalAlloyLanguage.g:2127:2: rule__ALSSignatureBody__Group__6__Impl rule__ALSSignatureBody__Group__7 | ||
7014 | { | ||
7015 | pushFollow(FOLLOW_11); | ||
7016 | rule__ALSSignatureBody__Group__6__Impl(); | ||
7017 | |||
7018 | state._fsp--; | ||
7019 | if (state.failed) return ; | ||
7020 | pushFollow(FOLLOW_2); | ||
7021 | rule__ALSSignatureBody__Group__7(); | ||
7022 | |||
7023 | state._fsp--; | ||
7024 | if (state.failed) return ; | ||
7025 | |||
7026 | } | ||
7027 | |||
7028 | } | ||
7029 | catch (RecognitionException re) { | ||
7030 | reportError(re); | ||
7031 | recover(input,re); | ||
7032 | } | ||
7033 | finally { | ||
7034 | |||
7035 | restoreStackSize(stackSize); | ||
7036 | |||
7037 | } | ||
7038 | return ; | ||
7039 | } | ||
7040 | // $ANTLR end "rule__ALSSignatureBody__Group__6" | ||
7041 | |||
7042 | |||
7043 | // $ANTLR start "rule__ALSSignatureBody__Group__6__Impl" | ||
7044 | // InternalAlloyLanguage.g:2134:1: rule__ALSSignatureBody__Group__6__Impl : ( ( rule__ALSSignatureBody__Group_6__0 )? ) ; | ||
7045 | public final void rule__ALSSignatureBody__Group__6__Impl() throws RecognitionException { | ||
7046 | |||
7047 | int stackSize = keepStackSize(); | ||
7048 | |||
7049 | try { | ||
7050 | // InternalAlloyLanguage.g:2138:1: ( ( ( rule__ALSSignatureBody__Group_6__0 )? ) ) | ||
7051 | // InternalAlloyLanguage.g:2139:1: ( ( rule__ALSSignatureBody__Group_6__0 )? ) | ||
7052 | { | ||
7053 | // InternalAlloyLanguage.g:2139:1: ( ( rule__ALSSignatureBody__Group_6__0 )? ) | ||
7054 | // InternalAlloyLanguage.g:2140:1: ( rule__ALSSignatureBody__Group_6__0 )? | ||
7055 | { | ||
7056 | if ( state.backtracking==0 ) { | ||
7057 | before(grammarAccess.getALSSignatureBodyAccess().getGroup_6()); | ||
7058 | } | ||
7059 | // InternalAlloyLanguage.g:2141:1: ( rule__ALSSignatureBody__Group_6__0 )? | ||
7060 | int alt21=2; | ||
7061 | int LA21_0 = input.LA(1); | ||
7062 | |||
7063 | if ( (LA21_0==RULE_ID) ) { | ||
7064 | alt21=1; | ||
7065 | } | ||
7066 | switch (alt21) { | ||
7067 | case 1 : | ||
7068 | // InternalAlloyLanguage.g:2141:2: rule__ALSSignatureBody__Group_6__0 | ||
7069 | { | ||
7070 | pushFollow(FOLLOW_2); | ||
7071 | rule__ALSSignatureBody__Group_6__0(); | ||
7072 | |||
7073 | state._fsp--; | ||
7074 | if (state.failed) return ; | ||
7075 | |||
7076 | } | ||
7077 | break; | ||
7078 | |||
7079 | } | ||
7080 | |||
7081 | if ( state.backtracking==0 ) { | ||
7082 | after(grammarAccess.getALSSignatureBodyAccess().getGroup_6()); | ||
7083 | } | ||
7084 | |||
7085 | } | ||
7086 | |||
7087 | |||
7088 | } | ||
7089 | |||
7090 | } | ||
7091 | catch (RecognitionException re) { | ||
7092 | reportError(re); | ||
7093 | recover(input,re); | ||
7094 | } | ||
7095 | finally { | ||
7096 | |||
7097 | restoreStackSize(stackSize); | ||
7098 | |||
7099 | } | ||
7100 | return ; | ||
7101 | } | ||
7102 | // $ANTLR end "rule__ALSSignatureBody__Group__6__Impl" | ||
7103 | |||
7104 | |||
7105 | // $ANTLR start "rule__ALSSignatureBody__Group__7" | ||
7106 | // InternalAlloyLanguage.g:2151:1: rule__ALSSignatureBody__Group__7 : rule__ALSSignatureBody__Group__7__Impl ; | ||
7107 | public final void rule__ALSSignatureBody__Group__7() throws RecognitionException { | ||
7108 | |||
7109 | int stackSize = keepStackSize(); | ||
7110 | |||
7111 | try { | ||
7112 | // InternalAlloyLanguage.g:2155:1: ( rule__ALSSignatureBody__Group__7__Impl ) | ||
7113 | // InternalAlloyLanguage.g:2156:2: rule__ALSSignatureBody__Group__7__Impl | ||
7114 | { | ||
7115 | pushFollow(FOLLOW_2); | ||
7116 | rule__ALSSignatureBody__Group__7__Impl(); | ||
7117 | |||
7118 | state._fsp--; | ||
7119 | if (state.failed) return ; | ||
7120 | |||
7121 | } | ||
7122 | |||
7123 | } | ||
7124 | catch (RecognitionException re) { | ||
7125 | reportError(re); | ||
7126 | recover(input,re); | ||
7127 | } | ||
7128 | finally { | ||
7129 | |||
7130 | restoreStackSize(stackSize); | ||
7131 | |||
7132 | } | ||
7133 | return ; | ||
7134 | } | ||
7135 | // $ANTLR end "rule__ALSSignatureBody__Group__7" | ||
7136 | |||
7137 | |||
7138 | // $ANTLR start "rule__ALSSignatureBody__Group__7__Impl" | ||
7139 | // InternalAlloyLanguage.g:2162:1: rule__ALSSignatureBody__Group__7__Impl : ( '}' ) ; | ||
7140 | public final void rule__ALSSignatureBody__Group__7__Impl() throws RecognitionException { | ||
7141 | |||
7142 | int stackSize = keepStackSize(); | ||
7143 | |||
7144 | try { | ||
7145 | // InternalAlloyLanguage.g:2166:1: ( ( '}' ) ) | ||
7146 | // InternalAlloyLanguage.g:2167:1: ( '}' ) | ||
7147 | { | ||
7148 | // InternalAlloyLanguage.g:2167:1: ( '}' ) | ||
7149 | // InternalAlloyLanguage.g:2168:1: '}' | ||
7150 | { | ||
7151 | if ( state.backtracking==0 ) { | ||
7152 | before(grammarAccess.getALSSignatureBodyAccess().getRightCurlyBracketKeyword_7()); | ||
7153 | } | ||
7154 | match(input,34,FOLLOW_2); if (state.failed) return ; | ||
7155 | if ( state.backtracking==0 ) { | ||
7156 | after(grammarAccess.getALSSignatureBodyAccess().getRightCurlyBracketKeyword_7()); | ||
7157 | } | ||
7158 | |||
7159 | } | ||
7160 | |||
7161 | |||
7162 | } | ||
7163 | |||
7164 | } | ||
7165 | catch (RecognitionException re) { | ||
7166 | reportError(re); | ||
7167 | recover(input,re); | ||
7168 | } | ||
7169 | finally { | ||
7170 | |||
7171 | restoreStackSize(stackSize); | ||
7172 | |||
7173 | } | ||
7174 | return ; | ||
7175 | } | ||
7176 | // $ANTLR end "rule__ALSSignatureBody__Group__7__Impl" | ||
7177 | |||
7178 | |||
7179 | // $ANTLR start "rule__ALSSignatureBody__Group_3__0" | ||
7180 | // InternalAlloyLanguage.g:2197:1: rule__ALSSignatureBody__Group_3__0 : rule__ALSSignatureBody__Group_3__0__Impl rule__ALSSignatureBody__Group_3__1 ; | ||
7181 | public final void rule__ALSSignatureBody__Group_3__0() throws RecognitionException { | ||
7182 | |||
7183 | int stackSize = keepStackSize(); | ||
7184 | |||
7185 | try { | ||
7186 | // InternalAlloyLanguage.g:2201:1: ( rule__ALSSignatureBody__Group_3__0__Impl rule__ALSSignatureBody__Group_3__1 ) | ||
7187 | // InternalAlloyLanguage.g:2202:2: rule__ALSSignatureBody__Group_3__0__Impl rule__ALSSignatureBody__Group_3__1 | ||
7188 | { | ||
7189 | pushFollow(FOLLOW_5); | ||
7190 | rule__ALSSignatureBody__Group_3__0__Impl(); | ||
7191 | |||
7192 | state._fsp--; | ||
7193 | if (state.failed) return ; | ||
7194 | pushFollow(FOLLOW_2); | ||
7195 | rule__ALSSignatureBody__Group_3__1(); | ||
7196 | |||
7197 | state._fsp--; | ||
7198 | if (state.failed) return ; | ||
7199 | |||
7200 | } | ||
7201 | |||
7202 | } | ||
7203 | catch (RecognitionException re) { | ||
7204 | reportError(re); | ||
7205 | recover(input,re); | ||
7206 | } | ||
7207 | finally { | ||
7208 | |||
7209 | restoreStackSize(stackSize); | ||
7210 | |||
7211 | } | ||
7212 | return ; | ||
7213 | } | ||
7214 | // $ANTLR end "rule__ALSSignatureBody__Group_3__0" | ||
7215 | |||
7216 | |||
7217 | // $ANTLR start "rule__ALSSignatureBody__Group_3__0__Impl" | ||
7218 | // InternalAlloyLanguage.g:2209:1: rule__ALSSignatureBody__Group_3__0__Impl : ( ',' ) ; | ||
7219 | public final void rule__ALSSignatureBody__Group_3__0__Impl() throws RecognitionException { | ||
7220 | |||
7221 | int stackSize = keepStackSize(); | ||
7222 | |||
7223 | try { | ||
7224 | // InternalAlloyLanguage.g:2213:1: ( ( ',' ) ) | ||
7225 | // InternalAlloyLanguage.g:2214:1: ( ',' ) | ||
7226 | { | ||
7227 | // InternalAlloyLanguage.g:2214:1: ( ',' ) | ||
7228 | // InternalAlloyLanguage.g:2215:1: ',' | ||
7229 | { | ||
7230 | if ( state.backtracking==0 ) { | ||
7231 | before(grammarAccess.getALSSignatureBodyAccess().getCommaKeyword_3_0()); | ||
7232 | } | ||
7233 | match(input,35,FOLLOW_2); if (state.failed) return ; | ||
7234 | if ( state.backtracking==0 ) { | ||
7235 | after(grammarAccess.getALSSignatureBodyAccess().getCommaKeyword_3_0()); | ||
7236 | } | ||
7237 | |||
7238 | } | ||
7239 | |||
7240 | |||
7241 | } | ||
7242 | |||
7243 | } | ||
7244 | catch (RecognitionException re) { | ||
7245 | reportError(re); | ||
7246 | recover(input,re); | ||
7247 | } | ||
7248 | finally { | ||
7249 | |||
7250 | restoreStackSize(stackSize); | ||
7251 | |||
7252 | } | ||
7253 | return ; | ||
7254 | } | ||
7255 | // $ANTLR end "rule__ALSSignatureBody__Group_3__0__Impl" | ||
7256 | |||
7257 | |||
7258 | // $ANTLR start "rule__ALSSignatureBody__Group_3__1" | ||
7259 | // InternalAlloyLanguage.g:2228:1: rule__ALSSignatureBody__Group_3__1 : rule__ALSSignatureBody__Group_3__1__Impl ; | ||
7260 | public final void rule__ALSSignatureBody__Group_3__1() throws RecognitionException { | ||
7261 | |||
7262 | int stackSize = keepStackSize(); | ||
7263 | |||
7264 | try { | ||
7265 | // InternalAlloyLanguage.g:2232:1: ( rule__ALSSignatureBody__Group_3__1__Impl ) | ||
7266 | // InternalAlloyLanguage.g:2233:2: rule__ALSSignatureBody__Group_3__1__Impl | ||
7267 | { | ||
7268 | pushFollow(FOLLOW_2); | ||
7269 | rule__ALSSignatureBody__Group_3__1__Impl(); | ||
7270 | |||
7271 | state._fsp--; | ||
7272 | if (state.failed) return ; | ||
7273 | |||
7274 | } | ||
7275 | |||
7276 | } | ||
7277 | catch (RecognitionException re) { | ||
7278 | reportError(re); | ||
7279 | recover(input,re); | ||
7280 | } | ||
7281 | finally { | ||
7282 | |||
7283 | restoreStackSize(stackSize); | ||
7284 | |||
7285 | } | ||
7286 | return ; | ||
7287 | } | ||
7288 | // $ANTLR end "rule__ALSSignatureBody__Group_3__1" | ||
7289 | |||
7290 | |||
7291 | // $ANTLR start "rule__ALSSignatureBody__Group_3__1__Impl" | ||
7292 | // InternalAlloyLanguage.g:2239:1: rule__ALSSignatureBody__Group_3__1__Impl : ( ( rule__ALSSignatureBody__DeclarationsAssignment_3_1 ) ) ; | ||
7293 | public final void rule__ALSSignatureBody__Group_3__1__Impl() throws RecognitionException { | ||
7294 | |||
7295 | int stackSize = keepStackSize(); | ||
7296 | |||
7297 | try { | ||
7298 | // InternalAlloyLanguage.g:2243:1: ( ( ( rule__ALSSignatureBody__DeclarationsAssignment_3_1 ) ) ) | ||
7299 | // InternalAlloyLanguage.g:2244:1: ( ( rule__ALSSignatureBody__DeclarationsAssignment_3_1 ) ) | ||
7300 | { | ||
7301 | // InternalAlloyLanguage.g:2244:1: ( ( rule__ALSSignatureBody__DeclarationsAssignment_3_1 ) ) | ||
7302 | // InternalAlloyLanguage.g:2245:1: ( rule__ALSSignatureBody__DeclarationsAssignment_3_1 ) | ||
7303 | { | ||
7304 | if ( state.backtracking==0 ) { | ||
7305 | before(grammarAccess.getALSSignatureBodyAccess().getDeclarationsAssignment_3_1()); | ||
7306 | } | ||
7307 | // InternalAlloyLanguage.g:2246:1: ( rule__ALSSignatureBody__DeclarationsAssignment_3_1 ) | ||
7308 | // InternalAlloyLanguage.g:2246:2: rule__ALSSignatureBody__DeclarationsAssignment_3_1 | ||
7309 | { | ||
7310 | pushFollow(FOLLOW_2); | ||
7311 | rule__ALSSignatureBody__DeclarationsAssignment_3_1(); | ||
7312 | |||
7313 | state._fsp--; | ||
7314 | if (state.failed) return ; | ||
7315 | |||
7316 | } | ||
7317 | |||
7318 | if ( state.backtracking==0 ) { | ||
7319 | after(grammarAccess.getALSSignatureBodyAccess().getDeclarationsAssignment_3_1()); | ||
7320 | } | ||
7321 | |||
7322 | } | ||
7323 | |||
7324 | |||
7325 | } | ||
7326 | |||
7327 | } | ||
7328 | catch (RecognitionException re) { | ||
7329 | reportError(re); | ||
7330 | recover(input,re); | ||
7331 | } | ||
7332 | finally { | ||
7333 | |||
7334 | restoreStackSize(stackSize); | ||
7335 | |||
7336 | } | ||
7337 | return ; | ||
7338 | } | ||
7339 | // $ANTLR end "rule__ALSSignatureBody__Group_3__1__Impl" | ||
7340 | |||
7341 | |||
7342 | // $ANTLR start "rule__ALSSignatureBody__Group_4_0__0" | ||
7343 | // InternalAlloyLanguage.g:2260:1: rule__ALSSignatureBody__Group_4_0__0 : rule__ALSSignatureBody__Group_4_0__0__Impl rule__ALSSignatureBody__Group_4_0__1 ; | ||
7344 | public final void rule__ALSSignatureBody__Group_4_0__0() throws RecognitionException { | ||
7345 | |||
7346 | int stackSize = keepStackSize(); | ||
7347 | |||
7348 | try { | ||
7349 | // InternalAlloyLanguage.g:2264:1: ( rule__ALSSignatureBody__Group_4_0__0__Impl rule__ALSSignatureBody__Group_4_0__1 ) | ||
7350 | // InternalAlloyLanguage.g:2265:2: rule__ALSSignatureBody__Group_4_0__0__Impl rule__ALSSignatureBody__Group_4_0__1 | ||
7351 | { | ||
7352 | pushFollow(FOLLOW_5); | ||
7353 | rule__ALSSignatureBody__Group_4_0__0__Impl(); | ||
7354 | |||
7355 | state._fsp--; | ||
7356 | if (state.failed) return ; | ||
7357 | pushFollow(FOLLOW_2); | ||
7358 | rule__ALSSignatureBody__Group_4_0__1(); | ||
7359 | |||
7360 | state._fsp--; | ||
7361 | if (state.failed) return ; | ||
7362 | |||
7363 | } | ||
7364 | |||
7365 | } | ||
7366 | catch (RecognitionException re) { | ||
7367 | reportError(re); | ||
7368 | recover(input,re); | ||
7369 | } | ||
7370 | finally { | ||
7371 | |||
7372 | restoreStackSize(stackSize); | ||
7373 | |||
7374 | } | ||
7375 | return ; | ||
7376 | } | ||
7377 | // $ANTLR end "rule__ALSSignatureBody__Group_4_0__0" | ||
7378 | |||
7379 | |||
7380 | // $ANTLR start "rule__ALSSignatureBody__Group_4_0__0__Impl" | ||
7381 | // InternalAlloyLanguage.g:2272:1: rule__ALSSignatureBody__Group_4_0__0__Impl : ( 'extends' ) ; | ||
7382 | public final void rule__ALSSignatureBody__Group_4_0__0__Impl() throws RecognitionException { | ||
7383 | |||
7384 | int stackSize = keepStackSize(); | ||
7385 | |||
7386 | try { | ||
7387 | // InternalAlloyLanguage.g:2276:1: ( ( 'extends' ) ) | ||
7388 | // InternalAlloyLanguage.g:2277:1: ( 'extends' ) | ||
7389 | { | ||
7390 | // InternalAlloyLanguage.g:2277:1: ( 'extends' ) | ||
7391 | // InternalAlloyLanguage.g:2278:1: 'extends' | ||
7392 | { | ||
7393 | if ( state.backtracking==0 ) { | ||
7394 | before(grammarAccess.getALSSignatureBodyAccess().getExtendsKeyword_4_0_0()); | ||
7395 | } | ||
7396 | match(input,37,FOLLOW_2); if (state.failed) return ; | ||
7397 | if ( state.backtracking==0 ) { | ||
7398 | after(grammarAccess.getALSSignatureBodyAccess().getExtendsKeyword_4_0_0()); | ||
7399 | } | ||
7400 | |||
7401 | } | ||
7402 | |||
7403 | |||
7404 | } | ||
7405 | |||
7406 | } | ||
7407 | catch (RecognitionException re) { | ||
7408 | reportError(re); | ||
7409 | recover(input,re); | ||
7410 | } | ||
7411 | finally { | ||
7412 | |||
7413 | restoreStackSize(stackSize); | ||
7414 | |||
7415 | } | ||
7416 | return ; | ||
7417 | } | ||
7418 | // $ANTLR end "rule__ALSSignatureBody__Group_4_0__0__Impl" | ||
7419 | |||
7420 | |||
7421 | // $ANTLR start "rule__ALSSignatureBody__Group_4_0__1" | ||
7422 | // InternalAlloyLanguage.g:2291:1: rule__ALSSignatureBody__Group_4_0__1 : rule__ALSSignatureBody__Group_4_0__1__Impl ; | ||
7423 | public final void rule__ALSSignatureBody__Group_4_0__1() throws RecognitionException { | ||
7424 | |||
7425 | int stackSize = keepStackSize(); | ||
7426 | |||
7427 | try { | ||
7428 | // InternalAlloyLanguage.g:2295:1: ( rule__ALSSignatureBody__Group_4_0__1__Impl ) | ||
7429 | // InternalAlloyLanguage.g:2296:2: rule__ALSSignatureBody__Group_4_0__1__Impl | ||
7430 | { | ||
7431 | pushFollow(FOLLOW_2); | ||
7432 | rule__ALSSignatureBody__Group_4_0__1__Impl(); | ||
7433 | |||
7434 | state._fsp--; | ||
7435 | if (state.failed) return ; | ||
7436 | |||
7437 | } | ||
7438 | |||
7439 | } | ||
7440 | catch (RecognitionException re) { | ||
7441 | reportError(re); | ||
7442 | recover(input,re); | ||
7443 | } | ||
7444 | finally { | ||
7445 | |||
7446 | restoreStackSize(stackSize); | ||
7447 | |||
7448 | } | ||
7449 | return ; | ||
7450 | } | ||
7451 | // $ANTLR end "rule__ALSSignatureBody__Group_4_0__1" | ||
7452 | |||
7453 | |||
7454 | // $ANTLR start "rule__ALSSignatureBody__Group_4_0__1__Impl" | ||
7455 | // InternalAlloyLanguage.g:2302:1: rule__ALSSignatureBody__Group_4_0__1__Impl : ( ( rule__ALSSignatureBody__SupertypeAssignment_4_0_1 ) ) ; | ||
7456 | public final void rule__ALSSignatureBody__Group_4_0__1__Impl() throws RecognitionException { | ||
7457 | |||
7458 | int stackSize = keepStackSize(); | ||
7459 | |||
7460 | try { | ||
7461 | // InternalAlloyLanguage.g:2306:1: ( ( ( rule__ALSSignatureBody__SupertypeAssignment_4_0_1 ) ) ) | ||
7462 | // InternalAlloyLanguage.g:2307:1: ( ( rule__ALSSignatureBody__SupertypeAssignment_4_0_1 ) ) | ||
7463 | { | ||
7464 | // InternalAlloyLanguage.g:2307:1: ( ( rule__ALSSignatureBody__SupertypeAssignment_4_0_1 ) ) | ||
7465 | // InternalAlloyLanguage.g:2308:1: ( rule__ALSSignatureBody__SupertypeAssignment_4_0_1 ) | ||
7466 | { | ||
7467 | if ( state.backtracking==0 ) { | ||
7468 | before(grammarAccess.getALSSignatureBodyAccess().getSupertypeAssignment_4_0_1()); | ||
7469 | } | ||
7470 | // InternalAlloyLanguage.g:2309:1: ( rule__ALSSignatureBody__SupertypeAssignment_4_0_1 ) | ||
7471 | // InternalAlloyLanguage.g:2309:2: rule__ALSSignatureBody__SupertypeAssignment_4_0_1 | ||
7472 | { | ||
7473 | pushFollow(FOLLOW_2); | ||
7474 | rule__ALSSignatureBody__SupertypeAssignment_4_0_1(); | ||
7475 | |||
7476 | state._fsp--; | ||
7477 | if (state.failed) return ; | ||
7478 | |||
7479 | } | ||
7480 | |||
7481 | if ( state.backtracking==0 ) { | ||
7482 | after(grammarAccess.getALSSignatureBodyAccess().getSupertypeAssignment_4_0_1()); | ||
7483 | } | ||
7484 | |||
7485 | } | ||
7486 | |||
7487 | |||
7488 | } | ||
7489 | |||
7490 | } | ||
7491 | catch (RecognitionException re) { | ||
7492 | reportError(re); | ||
7493 | recover(input,re); | ||
7494 | } | ||
7495 | finally { | ||
7496 | |||
7497 | restoreStackSize(stackSize); | ||
7498 | |||
7499 | } | ||
7500 | return ; | ||
7501 | } | ||
7502 | // $ANTLR end "rule__ALSSignatureBody__Group_4_0__1__Impl" | ||
7503 | |||
7504 | |||
7505 | // $ANTLR start "rule__ALSSignatureBody__Group_4_1__0" | ||
7506 | // InternalAlloyLanguage.g:2323:1: rule__ALSSignatureBody__Group_4_1__0 : rule__ALSSignatureBody__Group_4_1__0__Impl rule__ALSSignatureBody__Group_4_1__1 ; | ||
7507 | public final void rule__ALSSignatureBody__Group_4_1__0() throws RecognitionException { | ||
7508 | |||
7509 | int stackSize = keepStackSize(); | ||
7510 | |||
7511 | try { | ||
7512 | // InternalAlloyLanguage.g:2327:1: ( rule__ALSSignatureBody__Group_4_1__0__Impl rule__ALSSignatureBody__Group_4_1__1 ) | ||
7513 | // InternalAlloyLanguage.g:2328:2: rule__ALSSignatureBody__Group_4_1__0__Impl rule__ALSSignatureBody__Group_4_1__1 | ||
7514 | { | ||
7515 | pushFollow(FOLLOW_5); | ||
7516 | rule__ALSSignatureBody__Group_4_1__0__Impl(); | ||
7517 | |||
7518 | state._fsp--; | ||
7519 | if (state.failed) return ; | ||
7520 | pushFollow(FOLLOW_2); | ||
7521 | rule__ALSSignatureBody__Group_4_1__1(); | ||
7522 | |||
7523 | state._fsp--; | ||
7524 | if (state.failed) return ; | ||
7525 | |||
7526 | } | ||
7527 | |||
7528 | } | ||
7529 | catch (RecognitionException re) { | ||
7530 | reportError(re); | ||
7531 | recover(input,re); | ||
7532 | } | ||
7533 | finally { | ||
7534 | |||
7535 | restoreStackSize(stackSize); | ||
7536 | |||
7537 | } | ||
7538 | return ; | ||
7539 | } | ||
7540 | // $ANTLR end "rule__ALSSignatureBody__Group_4_1__0" | ||
7541 | |||
7542 | |||
7543 | // $ANTLR start "rule__ALSSignatureBody__Group_4_1__0__Impl" | ||
7544 | // InternalAlloyLanguage.g:2335:1: rule__ALSSignatureBody__Group_4_1__0__Impl : ( 'in' ) ; | ||
7545 | public final void rule__ALSSignatureBody__Group_4_1__0__Impl() throws RecognitionException { | ||
7546 | |||
7547 | int stackSize = keepStackSize(); | ||
7548 | |||
7549 | try { | ||
7550 | // InternalAlloyLanguage.g:2339:1: ( ( 'in' ) ) | ||
7551 | // InternalAlloyLanguage.g:2340:1: ( 'in' ) | ||
7552 | { | ||
7553 | // InternalAlloyLanguage.g:2340:1: ( 'in' ) | ||
7554 | // InternalAlloyLanguage.g:2341:1: 'in' | ||
7555 | { | ||
7556 | if ( state.backtracking==0 ) { | ||
7557 | before(grammarAccess.getALSSignatureBodyAccess().getInKeyword_4_1_0()); | ||
7558 | } | ||
7559 | match(input,38,FOLLOW_2); if (state.failed) return ; | ||
7560 | if ( state.backtracking==0 ) { | ||
7561 | after(grammarAccess.getALSSignatureBodyAccess().getInKeyword_4_1_0()); | ||
7562 | } | ||
7563 | |||
7564 | } | ||
7565 | |||
7566 | |||
7567 | } | ||
7568 | |||
7569 | } | ||
7570 | catch (RecognitionException re) { | ||
7571 | reportError(re); | ||
7572 | recover(input,re); | ||
7573 | } | ||
7574 | finally { | ||
7575 | |||
7576 | restoreStackSize(stackSize); | ||
7577 | |||
7578 | } | ||
7579 | return ; | ||
7580 | } | ||
7581 | // $ANTLR end "rule__ALSSignatureBody__Group_4_1__0__Impl" | ||
7582 | |||
7583 | |||
7584 | // $ANTLR start "rule__ALSSignatureBody__Group_4_1__1" | ||
7585 | // InternalAlloyLanguage.g:2354:1: rule__ALSSignatureBody__Group_4_1__1 : rule__ALSSignatureBody__Group_4_1__1__Impl rule__ALSSignatureBody__Group_4_1__2 ; | ||
7586 | public final void rule__ALSSignatureBody__Group_4_1__1() throws RecognitionException { | ||
7587 | |||
7588 | int stackSize = keepStackSize(); | ||
7589 | |||
7590 | try { | ||
7591 | // InternalAlloyLanguage.g:2358:1: ( rule__ALSSignatureBody__Group_4_1__1__Impl rule__ALSSignatureBody__Group_4_1__2 ) | ||
7592 | // InternalAlloyLanguage.g:2359:2: rule__ALSSignatureBody__Group_4_1__1__Impl rule__ALSSignatureBody__Group_4_1__2 | ||
7593 | { | ||
7594 | pushFollow(FOLLOW_12); | ||
7595 | rule__ALSSignatureBody__Group_4_1__1__Impl(); | ||
7596 | |||
7597 | state._fsp--; | ||
7598 | if (state.failed) return ; | ||
7599 | pushFollow(FOLLOW_2); | ||
7600 | rule__ALSSignatureBody__Group_4_1__2(); | ||
7601 | |||
7602 | state._fsp--; | ||
7603 | if (state.failed) return ; | ||
7604 | |||
7605 | } | ||
7606 | |||
7607 | } | ||
7608 | catch (RecognitionException re) { | ||
7609 | reportError(re); | ||
7610 | recover(input,re); | ||
7611 | } | ||
7612 | finally { | ||
7613 | |||
7614 | restoreStackSize(stackSize); | ||
7615 | |||
7616 | } | ||
7617 | return ; | ||
7618 | } | ||
7619 | // $ANTLR end "rule__ALSSignatureBody__Group_4_1__1" | ||
7620 | |||
7621 | |||
7622 | // $ANTLR start "rule__ALSSignatureBody__Group_4_1__1__Impl" | ||
7623 | // InternalAlloyLanguage.g:2366:1: rule__ALSSignatureBody__Group_4_1__1__Impl : ( ( rule__ALSSignatureBody__SupersetAssignment_4_1_1 ) ) ; | ||
7624 | public final void rule__ALSSignatureBody__Group_4_1__1__Impl() throws RecognitionException { | ||
7625 | |||
7626 | int stackSize = keepStackSize(); | ||
7627 | |||
7628 | try { | ||
7629 | // InternalAlloyLanguage.g:2370:1: ( ( ( rule__ALSSignatureBody__SupersetAssignment_4_1_1 ) ) ) | ||
7630 | // InternalAlloyLanguage.g:2371:1: ( ( rule__ALSSignatureBody__SupersetAssignment_4_1_1 ) ) | ||
7631 | { | ||
7632 | // InternalAlloyLanguage.g:2371:1: ( ( rule__ALSSignatureBody__SupersetAssignment_4_1_1 ) ) | ||
7633 | // InternalAlloyLanguage.g:2372:1: ( rule__ALSSignatureBody__SupersetAssignment_4_1_1 ) | ||
7634 | { | ||
7635 | if ( state.backtracking==0 ) { | ||
7636 | before(grammarAccess.getALSSignatureBodyAccess().getSupersetAssignment_4_1_1()); | ||
7637 | } | ||
7638 | // InternalAlloyLanguage.g:2373:1: ( rule__ALSSignatureBody__SupersetAssignment_4_1_1 ) | ||
7639 | // InternalAlloyLanguage.g:2373:2: rule__ALSSignatureBody__SupersetAssignment_4_1_1 | ||
7640 | { | ||
7641 | pushFollow(FOLLOW_2); | ||
7642 | rule__ALSSignatureBody__SupersetAssignment_4_1_1(); | ||
7643 | |||
7644 | state._fsp--; | ||
7645 | if (state.failed) return ; | ||
7646 | |||
7647 | } | ||
7648 | |||
7649 | if ( state.backtracking==0 ) { | ||
7650 | after(grammarAccess.getALSSignatureBodyAccess().getSupersetAssignment_4_1_1()); | ||
7651 | } | ||
7652 | |||
7653 | } | ||
7654 | |||
7655 | |||
7656 | } | ||
7657 | |||
7658 | } | ||
7659 | catch (RecognitionException re) { | ||
7660 | reportError(re); | ||
7661 | recover(input,re); | ||
7662 | } | ||
7663 | finally { | ||
7664 | |||
7665 | restoreStackSize(stackSize); | ||
7666 | |||
7667 | } | ||
7668 | return ; | ||
7669 | } | ||
7670 | // $ANTLR end "rule__ALSSignatureBody__Group_4_1__1__Impl" | ||
7671 | |||
7672 | |||
7673 | // $ANTLR start "rule__ALSSignatureBody__Group_4_1__2" | ||
7674 | // InternalAlloyLanguage.g:2383:1: rule__ALSSignatureBody__Group_4_1__2 : rule__ALSSignatureBody__Group_4_1__2__Impl ; | ||
7675 | public final void rule__ALSSignatureBody__Group_4_1__2() throws RecognitionException { | ||
7676 | |||
7677 | int stackSize = keepStackSize(); | ||
7678 | |||
7679 | try { | ||
7680 | // InternalAlloyLanguage.g:2387:1: ( rule__ALSSignatureBody__Group_4_1__2__Impl ) | ||
7681 | // InternalAlloyLanguage.g:2388:2: rule__ALSSignatureBody__Group_4_1__2__Impl | ||
7682 | { | ||
7683 | pushFollow(FOLLOW_2); | ||
7684 | rule__ALSSignatureBody__Group_4_1__2__Impl(); | ||
7685 | |||
7686 | state._fsp--; | ||
7687 | if (state.failed) return ; | ||
7688 | |||
7689 | } | ||
7690 | |||
7691 | } | ||
7692 | catch (RecognitionException re) { | ||
7693 | reportError(re); | ||
7694 | recover(input,re); | ||
7695 | } | ||
7696 | finally { | ||
7697 | |||
7698 | restoreStackSize(stackSize); | ||
7699 | |||
7700 | } | ||
7701 | return ; | ||
7702 | } | ||
7703 | // $ANTLR end "rule__ALSSignatureBody__Group_4_1__2" | ||
7704 | |||
7705 | |||
7706 | // $ANTLR start "rule__ALSSignatureBody__Group_4_1__2__Impl" | ||
7707 | // InternalAlloyLanguage.g:2394:1: rule__ALSSignatureBody__Group_4_1__2__Impl : ( ( rule__ALSSignatureBody__Group_4_1_2__0 )* ) ; | ||
7708 | public final void rule__ALSSignatureBody__Group_4_1__2__Impl() throws RecognitionException { | ||
7709 | |||
7710 | int stackSize = keepStackSize(); | ||
7711 | |||
7712 | try { | ||
7713 | // InternalAlloyLanguage.g:2398:1: ( ( ( rule__ALSSignatureBody__Group_4_1_2__0 )* ) ) | ||
7714 | // InternalAlloyLanguage.g:2399:1: ( ( rule__ALSSignatureBody__Group_4_1_2__0 )* ) | ||
7715 | { | ||
7716 | // InternalAlloyLanguage.g:2399:1: ( ( rule__ALSSignatureBody__Group_4_1_2__0 )* ) | ||
7717 | // InternalAlloyLanguage.g:2400:1: ( rule__ALSSignatureBody__Group_4_1_2__0 )* | ||
7718 | { | ||
7719 | if ( state.backtracking==0 ) { | ||
7720 | before(grammarAccess.getALSSignatureBodyAccess().getGroup_4_1_2()); | ||
7721 | } | ||
7722 | // InternalAlloyLanguage.g:2401:1: ( rule__ALSSignatureBody__Group_4_1_2__0 )* | ||
7723 | loop22: | ||
7724 | do { | ||
7725 | int alt22=2; | ||
7726 | int LA22_0 = input.LA(1); | ||
7727 | |||
7728 | if ( (LA22_0==39) ) { | ||
7729 | alt22=1; | ||
7730 | } | ||
7731 | |||
7732 | |||
7733 | switch (alt22) { | ||
7734 | case 1 : | ||
7735 | // InternalAlloyLanguage.g:2401:2: rule__ALSSignatureBody__Group_4_1_2__0 | ||
7736 | { | ||
7737 | pushFollow(FOLLOW_13); | ||
7738 | rule__ALSSignatureBody__Group_4_1_2__0(); | ||
7739 | |||
7740 | state._fsp--; | ||
7741 | if (state.failed) return ; | ||
7742 | |||
7743 | } | ||
7744 | break; | ||
7745 | |||
7746 | default : | ||
7747 | break loop22; | ||
7748 | } | ||
7749 | } while (true); | ||
7750 | |||
7751 | if ( state.backtracking==0 ) { | ||
7752 | after(grammarAccess.getALSSignatureBodyAccess().getGroup_4_1_2()); | ||
7753 | } | ||
7754 | |||
7755 | } | ||
7756 | |||
7757 | |||
7758 | } | ||
7759 | |||
7760 | } | ||
7761 | catch (RecognitionException re) { | ||
7762 | reportError(re); | ||
7763 | recover(input,re); | ||
7764 | } | ||
7765 | finally { | ||
7766 | |||
7767 | restoreStackSize(stackSize); | ||
7768 | |||
7769 | } | ||
7770 | return ; | ||
7771 | } | ||
7772 | // $ANTLR end "rule__ALSSignatureBody__Group_4_1__2__Impl" | ||
7773 | |||
7774 | |||
7775 | // $ANTLR start "rule__ALSSignatureBody__Group_4_1_2__0" | ||
7776 | // InternalAlloyLanguage.g:2417:1: rule__ALSSignatureBody__Group_4_1_2__0 : rule__ALSSignatureBody__Group_4_1_2__0__Impl rule__ALSSignatureBody__Group_4_1_2__1 ; | ||
7777 | public final void rule__ALSSignatureBody__Group_4_1_2__0() throws RecognitionException { | ||
7778 | |||
7779 | int stackSize = keepStackSize(); | ||
7780 | |||
7781 | try { | ||
7782 | // InternalAlloyLanguage.g:2421:1: ( rule__ALSSignatureBody__Group_4_1_2__0__Impl rule__ALSSignatureBody__Group_4_1_2__1 ) | ||
7783 | // InternalAlloyLanguage.g:2422:2: rule__ALSSignatureBody__Group_4_1_2__0__Impl rule__ALSSignatureBody__Group_4_1_2__1 | ||
7784 | { | ||
7785 | pushFollow(FOLLOW_5); | ||
7786 | rule__ALSSignatureBody__Group_4_1_2__0__Impl(); | ||
7787 | |||
7788 | state._fsp--; | ||
7789 | if (state.failed) return ; | ||
7790 | pushFollow(FOLLOW_2); | ||
7791 | rule__ALSSignatureBody__Group_4_1_2__1(); | ||
7792 | |||
7793 | state._fsp--; | ||
7794 | if (state.failed) return ; | ||
7795 | |||
7796 | } | ||
7797 | |||
7798 | } | ||
7799 | catch (RecognitionException re) { | ||
7800 | reportError(re); | ||
7801 | recover(input,re); | ||
7802 | } | ||
7803 | finally { | ||
7804 | |||
7805 | restoreStackSize(stackSize); | ||
7806 | |||
7807 | } | ||
7808 | return ; | ||
7809 | } | ||
7810 | // $ANTLR end "rule__ALSSignatureBody__Group_4_1_2__0" | ||
7811 | |||
7812 | |||
7813 | // $ANTLR start "rule__ALSSignatureBody__Group_4_1_2__0__Impl" | ||
7814 | // InternalAlloyLanguage.g:2429:1: rule__ALSSignatureBody__Group_4_1_2__0__Impl : ( '+' ) ; | ||
7815 | public final void rule__ALSSignatureBody__Group_4_1_2__0__Impl() throws RecognitionException { | ||
7816 | |||
7817 | int stackSize = keepStackSize(); | ||
7818 | |||
7819 | try { | ||
7820 | // InternalAlloyLanguage.g:2433:1: ( ( '+' ) ) | ||
7821 | // InternalAlloyLanguage.g:2434:1: ( '+' ) | ||
7822 | { | ||
7823 | // InternalAlloyLanguage.g:2434:1: ( '+' ) | ||
7824 | // InternalAlloyLanguage.g:2435:1: '+' | ||
7825 | { | ||
7826 | if ( state.backtracking==0 ) { | ||
7827 | before(grammarAccess.getALSSignatureBodyAccess().getPlusSignKeyword_4_1_2_0()); | ||
7828 | } | ||
7829 | match(input,39,FOLLOW_2); if (state.failed) return ; | ||
7830 | if ( state.backtracking==0 ) { | ||
7831 | after(grammarAccess.getALSSignatureBodyAccess().getPlusSignKeyword_4_1_2_0()); | ||
7832 | } | ||
7833 | |||
7834 | } | ||
7835 | |||
7836 | |||
7837 | } | ||
7838 | |||
7839 | } | ||
7840 | catch (RecognitionException re) { | ||
7841 | reportError(re); | ||
7842 | recover(input,re); | ||
7843 | } | ||
7844 | finally { | ||
7845 | |||
7846 | restoreStackSize(stackSize); | ||
7847 | |||
7848 | } | ||
7849 | return ; | ||
7850 | } | ||
7851 | // $ANTLR end "rule__ALSSignatureBody__Group_4_1_2__0__Impl" | ||
7852 | |||
7853 | |||
7854 | // $ANTLR start "rule__ALSSignatureBody__Group_4_1_2__1" | ||
7855 | // InternalAlloyLanguage.g:2448:1: rule__ALSSignatureBody__Group_4_1_2__1 : rule__ALSSignatureBody__Group_4_1_2__1__Impl ; | ||
7856 | public final void rule__ALSSignatureBody__Group_4_1_2__1() throws RecognitionException { | ||
7857 | |||
7858 | int stackSize = keepStackSize(); | ||
7859 | |||
7860 | try { | ||
7861 | // InternalAlloyLanguage.g:2452:1: ( rule__ALSSignatureBody__Group_4_1_2__1__Impl ) | ||
7862 | // InternalAlloyLanguage.g:2453:2: rule__ALSSignatureBody__Group_4_1_2__1__Impl | ||
7863 | { | ||
7864 | pushFollow(FOLLOW_2); | ||
7865 | rule__ALSSignatureBody__Group_4_1_2__1__Impl(); | ||
7866 | |||
7867 | state._fsp--; | ||
7868 | if (state.failed) return ; | ||
7869 | |||
7870 | } | ||
7871 | |||
7872 | } | ||
7873 | catch (RecognitionException re) { | ||
7874 | reportError(re); | ||
7875 | recover(input,re); | ||
7876 | } | ||
7877 | finally { | ||
7878 | |||
7879 | restoreStackSize(stackSize); | ||
7880 | |||
7881 | } | ||
7882 | return ; | ||
7883 | } | ||
7884 | // $ANTLR end "rule__ALSSignatureBody__Group_4_1_2__1" | ||
7885 | |||
7886 | |||
7887 | // $ANTLR start "rule__ALSSignatureBody__Group_4_1_2__1__Impl" | ||
7888 | // InternalAlloyLanguage.g:2459:1: rule__ALSSignatureBody__Group_4_1_2__1__Impl : ( ( rule__ALSSignatureBody__SupersetAssignment_4_1_2_1 ) ) ; | ||
7889 | public final void rule__ALSSignatureBody__Group_4_1_2__1__Impl() throws RecognitionException { | ||
7890 | |||
7891 | int stackSize = keepStackSize(); | ||
7892 | |||
7893 | try { | ||
7894 | // InternalAlloyLanguage.g:2463:1: ( ( ( rule__ALSSignatureBody__SupersetAssignment_4_1_2_1 ) ) ) | ||
7895 | // InternalAlloyLanguage.g:2464:1: ( ( rule__ALSSignatureBody__SupersetAssignment_4_1_2_1 ) ) | ||
7896 | { | ||
7897 | // InternalAlloyLanguage.g:2464:1: ( ( rule__ALSSignatureBody__SupersetAssignment_4_1_2_1 ) ) | ||
7898 | // InternalAlloyLanguage.g:2465:1: ( rule__ALSSignatureBody__SupersetAssignment_4_1_2_1 ) | ||
7899 | { | ||
7900 | if ( state.backtracking==0 ) { | ||
7901 | before(grammarAccess.getALSSignatureBodyAccess().getSupersetAssignment_4_1_2_1()); | ||
7902 | } | ||
7903 | // InternalAlloyLanguage.g:2466:1: ( rule__ALSSignatureBody__SupersetAssignment_4_1_2_1 ) | ||
7904 | // InternalAlloyLanguage.g:2466:2: rule__ALSSignatureBody__SupersetAssignment_4_1_2_1 | ||
7905 | { | ||
7906 | pushFollow(FOLLOW_2); | ||
7907 | rule__ALSSignatureBody__SupersetAssignment_4_1_2_1(); | ||
7908 | |||
7909 | state._fsp--; | ||
7910 | if (state.failed) return ; | ||
7911 | |||
7912 | } | ||
7913 | |||
7914 | if ( state.backtracking==0 ) { | ||
7915 | after(grammarAccess.getALSSignatureBodyAccess().getSupersetAssignment_4_1_2_1()); | ||
7916 | } | ||
7917 | |||
7918 | } | ||
7919 | |||
7920 | |||
7921 | } | ||
7922 | |||
7923 | } | ||
7924 | catch (RecognitionException re) { | ||
7925 | reportError(re); | ||
7926 | recover(input,re); | ||
7927 | } | ||
7928 | finally { | ||
7929 | |||
7930 | restoreStackSize(stackSize); | ||
7931 | |||
7932 | } | ||
7933 | return ; | ||
7934 | } | ||
7935 | // $ANTLR end "rule__ALSSignatureBody__Group_4_1_2__1__Impl" | ||
7936 | |||
7937 | |||
7938 | // $ANTLR start "rule__ALSSignatureBody__Group_6__0" | ||
7939 | // InternalAlloyLanguage.g:2480:1: rule__ALSSignatureBody__Group_6__0 : rule__ALSSignatureBody__Group_6__0__Impl rule__ALSSignatureBody__Group_6__1 ; | ||
7940 | public final void rule__ALSSignatureBody__Group_6__0() throws RecognitionException { | ||
7941 | |||
7942 | int stackSize = keepStackSize(); | ||
7943 | |||
7944 | try { | ||
7945 | // InternalAlloyLanguage.g:2484:1: ( rule__ALSSignatureBody__Group_6__0__Impl rule__ALSSignatureBody__Group_6__1 ) | ||
7946 | // InternalAlloyLanguage.g:2485:2: rule__ALSSignatureBody__Group_6__0__Impl rule__ALSSignatureBody__Group_6__1 | ||
7947 | { | ||
7948 | pushFollow(FOLLOW_14); | ||
7949 | rule__ALSSignatureBody__Group_6__0__Impl(); | ||
7950 | |||
7951 | state._fsp--; | ||
7952 | if (state.failed) return ; | ||
7953 | pushFollow(FOLLOW_2); | ||
7954 | rule__ALSSignatureBody__Group_6__1(); | ||
7955 | |||
7956 | state._fsp--; | ||
7957 | if (state.failed) return ; | ||
7958 | |||
7959 | } | ||
7960 | |||
7961 | } | ||
7962 | catch (RecognitionException re) { | ||
7963 | reportError(re); | ||
7964 | recover(input,re); | ||
7965 | } | ||
7966 | finally { | ||
7967 | |||
7968 | restoreStackSize(stackSize); | ||
7969 | |||
7970 | } | ||
7971 | return ; | ||
7972 | } | ||
7973 | // $ANTLR end "rule__ALSSignatureBody__Group_6__0" | ||
7974 | |||
7975 | |||
7976 | // $ANTLR start "rule__ALSSignatureBody__Group_6__0__Impl" | ||
7977 | // InternalAlloyLanguage.g:2492:1: rule__ALSSignatureBody__Group_6__0__Impl : ( ( rule__ALSSignatureBody__FieldsAssignment_6_0 ) ) ; | ||
7978 | public final void rule__ALSSignatureBody__Group_6__0__Impl() throws RecognitionException { | ||
7979 | |||
7980 | int stackSize = keepStackSize(); | ||
7981 | |||
7982 | try { | ||
7983 | // InternalAlloyLanguage.g:2496:1: ( ( ( rule__ALSSignatureBody__FieldsAssignment_6_0 ) ) ) | ||
7984 | // InternalAlloyLanguage.g:2497:1: ( ( rule__ALSSignatureBody__FieldsAssignment_6_0 ) ) | ||
7985 | { | ||
7986 | // InternalAlloyLanguage.g:2497:1: ( ( rule__ALSSignatureBody__FieldsAssignment_6_0 ) ) | ||
7987 | // InternalAlloyLanguage.g:2498:1: ( rule__ALSSignatureBody__FieldsAssignment_6_0 ) | ||
7988 | { | ||
7989 | if ( state.backtracking==0 ) { | ||
7990 | before(grammarAccess.getALSSignatureBodyAccess().getFieldsAssignment_6_0()); | ||
7991 | } | ||
7992 | // InternalAlloyLanguage.g:2499:1: ( rule__ALSSignatureBody__FieldsAssignment_6_0 ) | ||
7993 | // InternalAlloyLanguage.g:2499:2: rule__ALSSignatureBody__FieldsAssignment_6_0 | ||
7994 | { | ||
7995 | pushFollow(FOLLOW_2); | ||
7996 | rule__ALSSignatureBody__FieldsAssignment_6_0(); | ||
7997 | |||
7998 | state._fsp--; | ||
7999 | if (state.failed) return ; | ||
8000 | |||
8001 | } | ||
8002 | |||
8003 | if ( state.backtracking==0 ) { | ||
8004 | after(grammarAccess.getALSSignatureBodyAccess().getFieldsAssignment_6_0()); | ||
8005 | } | ||
8006 | |||
8007 | } | ||
8008 | |||
8009 | |||
8010 | } | ||
8011 | |||
8012 | } | ||
8013 | catch (RecognitionException re) { | ||
8014 | reportError(re); | ||
8015 | recover(input,re); | ||
8016 | } | ||
8017 | finally { | ||
8018 | |||
8019 | restoreStackSize(stackSize); | ||
8020 | |||
8021 | } | ||
8022 | return ; | ||
8023 | } | ||
8024 | // $ANTLR end "rule__ALSSignatureBody__Group_6__0__Impl" | ||
8025 | |||
8026 | |||
8027 | // $ANTLR start "rule__ALSSignatureBody__Group_6__1" | ||
8028 | // InternalAlloyLanguage.g:2509:1: rule__ALSSignatureBody__Group_6__1 : rule__ALSSignatureBody__Group_6__1__Impl ; | ||
8029 | public final void rule__ALSSignatureBody__Group_6__1() throws RecognitionException { | ||
8030 | |||
8031 | int stackSize = keepStackSize(); | ||
8032 | |||
8033 | try { | ||
8034 | // InternalAlloyLanguage.g:2513:1: ( rule__ALSSignatureBody__Group_6__1__Impl ) | ||
8035 | // InternalAlloyLanguage.g:2514:2: rule__ALSSignatureBody__Group_6__1__Impl | ||
8036 | { | ||
8037 | pushFollow(FOLLOW_2); | ||
8038 | rule__ALSSignatureBody__Group_6__1__Impl(); | ||
8039 | |||
8040 | state._fsp--; | ||
8041 | if (state.failed) return ; | ||
8042 | |||
8043 | } | ||
8044 | |||
8045 | } | ||
8046 | catch (RecognitionException re) { | ||
8047 | reportError(re); | ||
8048 | recover(input,re); | ||
8049 | } | ||
8050 | finally { | ||
8051 | |||
8052 | restoreStackSize(stackSize); | ||
8053 | |||
8054 | } | ||
8055 | return ; | ||
8056 | } | ||
8057 | // $ANTLR end "rule__ALSSignatureBody__Group_6__1" | ||
8058 | |||
8059 | |||
8060 | // $ANTLR start "rule__ALSSignatureBody__Group_6__1__Impl" | ||
8061 | // InternalAlloyLanguage.g:2520:1: rule__ALSSignatureBody__Group_6__1__Impl : ( ( rule__ALSSignatureBody__Group_6_1__0 )* ) ; | ||
8062 | public final void rule__ALSSignatureBody__Group_6__1__Impl() throws RecognitionException { | ||
8063 | |||
8064 | int stackSize = keepStackSize(); | ||
8065 | |||
8066 | try { | ||
8067 | // InternalAlloyLanguage.g:2524:1: ( ( ( rule__ALSSignatureBody__Group_6_1__0 )* ) ) | ||
8068 | // InternalAlloyLanguage.g:2525:1: ( ( rule__ALSSignatureBody__Group_6_1__0 )* ) | ||
8069 | { | ||
8070 | // InternalAlloyLanguage.g:2525:1: ( ( rule__ALSSignatureBody__Group_6_1__0 )* ) | ||
8071 | // InternalAlloyLanguage.g:2526:1: ( rule__ALSSignatureBody__Group_6_1__0 )* | ||
8072 | { | ||
8073 | if ( state.backtracking==0 ) { | ||
8074 | before(grammarAccess.getALSSignatureBodyAccess().getGroup_6_1()); | ||
8075 | } | ||
8076 | // InternalAlloyLanguage.g:2527:1: ( rule__ALSSignatureBody__Group_6_1__0 )* | ||
8077 | loop23: | ||
8078 | do { | ||
8079 | int alt23=2; | ||
8080 | int LA23_0 = input.LA(1); | ||
8081 | |||
8082 | if ( (LA23_0==35) ) { | ||
8083 | alt23=1; | ||
8084 | } | ||
8085 | |||
8086 | |||
8087 | switch (alt23) { | ||
8088 | case 1 : | ||
8089 | // InternalAlloyLanguage.g:2527:2: rule__ALSSignatureBody__Group_6_1__0 | ||
8090 | { | ||
8091 | pushFollow(FOLLOW_8); | ||
8092 | rule__ALSSignatureBody__Group_6_1__0(); | ||
8093 | |||
8094 | state._fsp--; | ||
8095 | if (state.failed) return ; | ||
8096 | |||
8097 | } | ||
8098 | break; | ||
8099 | |||
8100 | default : | ||
8101 | break loop23; | ||
8102 | } | ||
8103 | } while (true); | ||
8104 | |||
8105 | if ( state.backtracking==0 ) { | ||
8106 | after(grammarAccess.getALSSignatureBodyAccess().getGroup_6_1()); | ||
8107 | } | ||
8108 | |||
8109 | } | ||
8110 | |||
8111 | |||
8112 | } | ||
8113 | |||
8114 | } | ||
8115 | catch (RecognitionException re) { | ||
8116 | reportError(re); | ||
8117 | recover(input,re); | ||
8118 | } | ||
8119 | finally { | ||
8120 | |||
8121 | restoreStackSize(stackSize); | ||
8122 | |||
8123 | } | ||
8124 | return ; | ||
8125 | } | ||
8126 | // $ANTLR end "rule__ALSSignatureBody__Group_6__1__Impl" | ||
8127 | |||
8128 | |||
8129 | // $ANTLR start "rule__ALSSignatureBody__Group_6_1__0" | ||
8130 | // InternalAlloyLanguage.g:2541:1: rule__ALSSignatureBody__Group_6_1__0 : rule__ALSSignatureBody__Group_6_1__0__Impl rule__ALSSignatureBody__Group_6_1__1 ; | ||
8131 | public final void rule__ALSSignatureBody__Group_6_1__0() throws RecognitionException { | ||
8132 | |||
8133 | int stackSize = keepStackSize(); | ||
8134 | |||
8135 | try { | ||
8136 | // InternalAlloyLanguage.g:2545:1: ( rule__ALSSignatureBody__Group_6_1__0__Impl rule__ALSSignatureBody__Group_6_1__1 ) | ||
8137 | // InternalAlloyLanguage.g:2546:2: rule__ALSSignatureBody__Group_6_1__0__Impl rule__ALSSignatureBody__Group_6_1__1 | ||
8138 | { | ||
8139 | pushFollow(FOLLOW_5); | ||
8140 | rule__ALSSignatureBody__Group_6_1__0__Impl(); | ||
8141 | |||
8142 | state._fsp--; | ||
8143 | if (state.failed) return ; | ||
8144 | pushFollow(FOLLOW_2); | ||
8145 | rule__ALSSignatureBody__Group_6_1__1(); | ||
8146 | |||
8147 | state._fsp--; | ||
8148 | if (state.failed) return ; | ||
8149 | |||
8150 | } | ||
8151 | |||
8152 | } | ||
8153 | catch (RecognitionException re) { | ||
8154 | reportError(re); | ||
8155 | recover(input,re); | ||
8156 | } | ||
8157 | finally { | ||
8158 | |||
8159 | restoreStackSize(stackSize); | ||
8160 | |||
8161 | } | ||
8162 | return ; | ||
8163 | } | ||
8164 | // $ANTLR end "rule__ALSSignatureBody__Group_6_1__0" | ||
8165 | |||
8166 | |||
8167 | // $ANTLR start "rule__ALSSignatureBody__Group_6_1__0__Impl" | ||
8168 | // InternalAlloyLanguage.g:2553:1: rule__ALSSignatureBody__Group_6_1__0__Impl : ( ',' ) ; | ||
8169 | public final void rule__ALSSignatureBody__Group_6_1__0__Impl() throws RecognitionException { | ||
8170 | |||
8171 | int stackSize = keepStackSize(); | ||
8172 | |||
8173 | try { | ||
8174 | // InternalAlloyLanguage.g:2557:1: ( ( ',' ) ) | ||
8175 | // InternalAlloyLanguage.g:2558:1: ( ',' ) | ||
8176 | { | ||
8177 | // InternalAlloyLanguage.g:2558:1: ( ',' ) | ||
8178 | // InternalAlloyLanguage.g:2559:1: ',' | ||
8179 | { | ||
8180 | if ( state.backtracking==0 ) { | ||
8181 | before(grammarAccess.getALSSignatureBodyAccess().getCommaKeyword_6_1_0()); | ||
8182 | } | ||
8183 | match(input,35,FOLLOW_2); if (state.failed) return ; | ||
8184 | if ( state.backtracking==0 ) { | ||
8185 | after(grammarAccess.getALSSignatureBodyAccess().getCommaKeyword_6_1_0()); | ||
8186 | } | ||
8187 | |||
8188 | } | ||
8189 | |||
8190 | |||
8191 | } | ||
8192 | |||
8193 | } | ||
8194 | catch (RecognitionException re) { | ||
8195 | reportError(re); | ||
8196 | recover(input,re); | ||
8197 | } | ||
8198 | finally { | ||
8199 | |||
8200 | restoreStackSize(stackSize); | ||
8201 | |||
8202 | } | ||
8203 | return ; | ||
8204 | } | ||
8205 | // $ANTLR end "rule__ALSSignatureBody__Group_6_1__0__Impl" | ||
8206 | |||
8207 | |||
8208 | // $ANTLR start "rule__ALSSignatureBody__Group_6_1__1" | ||
8209 | // InternalAlloyLanguage.g:2572:1: rule__ALSSignatureBody__Group_6_1__1 : rule__ALSSignatureBody__Group_6_1__1__Impl ; | ||
8210 | public final void rule__ALSSignatureBody__Group_6_1__1() throws RecognitionException { | ||
8211 | |||
8212 | int stackSize = keepStackSize(); | ||
8213 | |||
8214 | try { | ||
8215 | // InternalAlloyLanguage.g:2576:1: ( rule__ALSSignatureBody__Group_6_1__1__Impl ) | ||
8216 | // InternalAlloyLanguage.g:2577:2: rule__ALSSignatureBody__Group_6_1__1__Impl | ||
8217 | { | ||
8218 | pushFollow(FOLLOW_2); | ||
8219 | rule__ALSSignatureBody__Group_6_1__1__Impl(); | ||
8220 | |||
8221 | state._fsp--; | ||
8222 | if (state.failed) return ; | ||
8223 | |||
8224 | } | ||
8225 | |||
8226 | } | ||
8227 | catch (RecognitionException re) { | ||
8228 | reportError(re); | ||
8229 | recover(input,re); | ||
8230 | } | ||
8231 | finally { | ||
8232 | |||
8233 | restoreStackSize(stackSize); | ||
8234 | |||
8235 | } | ||
8236 | return ; | ||
8237 | } | ||
8238 | // $ANTLR end "rule__ALSSignatureBody__Group_6_1__1" | ||
8239 | |||
8240 | |||
8241 | // $ANTLR start "rule__ALSSignatureBody__Group_6_1__1__Impl" | ||
8242 | // InternalAlloyLanguage.g:2583:1: rule__ALSSignatureBody__Group_6_1__1__Impl : ( ( rule__ALSSignatureBody__FieldsAssignment_6_1_1 ) ) ; | ||
8243 | public final void rule__ALSSignatureBody__Group_6_1__1__Impl() throws RecognitionException { | ||
8244 | |||
8245 | int stackSize = keepStackSize(); | ||
8246 | |||
8247 | try { | ||
8248 | // InternalAlloyLanguage.g:2587:1: ( ( ( rule__ALSSignatureBody__FieldsAssignment_6_1_1 ) ) ) | ||
8249 | // InternalAlloyLanguage.g:2588:1: ( ( rule__ALSSignatureBody__FieldsAssignment_6_1_1 ) ) | ||
8250 | { | ||
8251 | // InternalAlloyLanguage.g:2588:1: ( ( rule__ALSSignatureBody__FieldsAssignment_6_1_1 ) ) | ||
8252 | // InternalAlloyLanguage.g:2589:1: ( rule__ALSSignatureBody__FieldsAssignment_6_1_1 ) | ||
8253 | { | ||
8254 | if ( state.backtracking==0 ) { | ||
8255 | before(grammarAccess.getALSSignatureBodyAccess().getFieldsAssignment_6_1_1()); | ||
8256 | } | ||
8257 | // InternalAlloyLanguage.g:2590:1: ( rule__ALSSignatureBody__FieldsAssignment_6_1_1 ) | ||
8258 | // InternalAlloyLanguage.g:2590:2: rule__ALSSignatureBody__FieldsAssignment_6_1_1 | ||
8259 | { | ||
8260 | pushFollow(FOLLOW_2); | ||
8261 | rule__ALSSignatureBody__FieldsAssignment_6_1_1(); | ||
8262 | |||
8263 | state._fsp--; | ||
8264 | if (state.failed) return ; | ||
8265 | |||
8266 | } | ||
8267 | |||
8268 | if ( state.backtracking==0 ) { | ||
8269 | after(grammarAccess.getALSSignatureBodyAccess().getFieldsAssignment_6_1_1()); | ||
8270 | } | ||
8271 | |||
8272 | } | ||
8273 | |||
8274 | |||
8275 | } | ||
8276 | |||
8277 | } | ||
8278 | catch (RecognitionException re) { | ||
8279 | reportError(re); | ||
8280 | recover(input,re); | ||
8281 | } | ||
8282 | finally { | ||
8283 | |||
8284 | restoreStackSize(stackSize); | ||
8285 | |||
8286 | } | ||
8287 | return ; | ||
8288 | } | ||
8289 | // $ANTLR end "rule__ALSSignatureBody__Group_6_1__1__Impl" | ||
8290 | |||
8291 | |||
8292 | // $ANTLR start "rule__ALSFieldDeclaration__Group__0" | ||
8293 | // InternalAlloyLanguage.g:2604:1: rule__ALSFieldDeclaration__Group__0 : rule__ALSFieldDeclaration__Group__0__Impl rule__ALSFieldDeclaration__Group__1 ; | ||
8294 | public final void rule__ALSFieldDeclaration__Group__0() throws RecognitionException { | ||
8295 | |||
8296 | int stackSize = keepStackSize(); | ||
8297 | |||
8298 | try { | ||
8299 | // InternalAlloyLanguage.g:2608:1: ( rule__ALSFieldDeclaration__Group__0__Impl rule__ALSFieldDeclaration__Group__1 ) | ||
8300 | // InternalAlloyLanguage.g:2609:2: rule__ALSFieldDeclaration__Group__0__Impl rule__ALSFieldDeclaration__Group__1 | ||
8301 | { | ||
8302 | pushFollow(FOLLOW_15); | ||
8303 | rule__ALSFieldDeclaration__Group__0__Impl(); | ||
8304 | |||
8305 | state._fsp--; | ||
8306 | if (state.failed) return ; | ||
8307 | pushFollow(FOLLOW_2); | ||
8308 | rule__ALSFieldDeclaration__Group__1(); | ||
8309 | |||
8310 | state._fsp--; | ||
8311 | if (state.failed) return ; | ||
8312 | |||
8313 | } | ||
8314 | |||
8315 | } | ||
8316 | catch (RecognitionException re) { | ||
8317 | reportError(re); | ||
8318 | recover(input,re); | ||
8319 | } | ||
8320 | finally { | ||
8321 | |||
8322 | restoreStackSize(stackSize); | ||
8323 | |||
8324 | } | ||
8325 | return ; | ||
8326 | } | ||
8327 | // $ANTLR end "rule__ALSFieldDeclaration__Group__0" | ||
8328 | |||
8329 | |||
8330 | // $ANTLR start "rule__ALSFieldDeclaration__Group__0__Impl" | ||
8331 | // InternalAlloyLanguage.g:2616:1: rule__ALSFieldDeclaration__Group__0__Impl : ( ( rule__ALSFieldDeclaration__NameAssignment_0 ) ) ; | ||
8332 | public final void rule__ALSFieldDeclaration__Group__0__Impl() throws RecognitionException { | ||
8333 | |||
8334 | int stackSize = keepStackSize(); | ||
8335 | |||
8336 | try { | ||
8337 | // InternalAlloyLanguage.g:2620:1: ( ( ( rule__ALSFieldDeclaration__NameAssignment_0 ) ) ) | ||
8338 | // InternalAlloyLanguage.g:2621:1: ( ( rule__ALSFieldDeclaration__NameAssignment_0 ) ) | ||
8339 | { | ||
8340 | // InternalAlloyLanguage.g:2621:1: ( ( rule__ALSFieldDeclaration__NameAssignment_0 ) ) | ||
8341 | // InternalAlloyLanguage.g:2622:1: ( rule__ALSFieldDeclaration__NameAssignment_0 ) | ||
8342 | { | ||
8343 | if ( state.backtracking==0 ) { | ||
8344 | before(grammarAccess.getALSFieldDeclarationAccess().getNameAssignment_0()); | ||
8345 | } | ||
8346 | // InternalAlloyLanguage.g:2623:1: ( rule__ALSFieldDeclaration__NameAssignment_0 ) | ||
8347 | // InternalAlloyLanguage.g:2623:2: rule__ALSFieldDeclaration__NameAssignment_0 | ||
8348 | { | ||
8349 | pushFollow(FOLLOW_2); | ||
8350 | rule__ALSFieldDeclaration__NameAssignment_0(); | ||
8351 | |||
8352 | state._fsp--; | ||
8353 | if (state.failed) return ; | ||
8354 | |||
8355 | } | ||
8356 | |||
8357 | if ( state.backtracking==0 ) { | ||
8358 | after(grammarAccess.getALSFieldDeclarationAccess().getNameAssignment_0()); | ||
8359 | } | ||
8360 | |||
8361 | } | ||
8362 | |||
8363 | |||
8364 | } | ||
8365 | |||
8366 | } | ||
8367 | catch (RecognitionException re) { | ||
8368 | reportError(re); | ||
8369 | recover(input,re); | ||
8370 | } | ||
8371 | finally { | ||
8372 | |||
8373 | restoreStackSize(stackSize); | ||
8374 | |||
8375 | } | ||
8376 | return ; | ||
8377 | } | ||
8378 | // $ANTLR end "rule__ALSFieldDeclaration__Group__0__Impl" | ||
8379 | |||
8380 | |||
8381 | // $ANTLR start "rule__ALSFieldDeclaration__Group__1" | ||
8382 | // InternalAlloyLanguage.g:2633:1: rule__ALSFieldDeclaration__Group__1 : rule__ALSFieldDeclaration__Group__1__Impl rule__ALSFieldDeclaration__Group__2 ; | ||
8383 | public final void rule__ALSFieldDeclaration__Group__1() throws RecognitionException { | ||
8384 | |||
8385 | int stackSize = keepStackSize(); | ||
8386 | |||
8387 | try { | ||
8388 | // InternalAlloyLanguage.g:2637:1: ( rule__ALSFieldDeclaration__Group__1__Impl rule__ALSFieldDeclaration__Group__2 ) | ||
8389 | // InternalAlloyLanguage.g:2638:2: rule__ALSFieldDeclaration__Group__1__Impl rule__ALSFieldDeclaration__Group__2 | ||
8390 | { | ||
8391 | pushFollow(FOLLOW_16); | ||
8392 | rule__ALSFieldDeclaration__Group__1__Impl(); | ||
8393 | |||
8394 | state._fsp--; | ||
8395 | if (state.failed) return ; | ||
8396 | pushFollow(FOLLOW_2); | ||
8397 | rule__ALSFieldDeclaration__Group__2(); | ||
8398 | |||
8399 | state._fsp--; | ||
8400 | if (state.failed) return ; | ||
8401 | |||
8402 | } | ||
8403 | |||
8404 | } | ||
8405 | catch (RecognitionException re) { | ||
8406 | reportError(re); | ||
8407 | recover(input,re); | ||
8408 | } | ||
8409 | finally { | ||
8410 | |||
8411 | restoreStackSize(stackSize); | ||
8412 | |||
8413 | } | ||
8414 | return ; | ||
8415 | } | ||
8416 | // $ANTLR end "rule__ALSFieldDeclaration__Group__1" | ||
8417 | |||
8418 | |||
8419 | // $ANTLR start "rule__ALSFieldDeclaration__Group__1__Impl" | ||
8420 | // InternalAlloyLanguage.g:2645:1: rule__ALSFieldDeclaration__Group__1__Impl : ( ':' ) ; | ||
8421 | public final void rule__ALSFieldDeclaration__Group__1__Impl() throws RecognitionException { | ||
8422 | |||
8423 | int stackSize = keepStackSize(); | ||
8424 | |||
8425 | try { | ||
8426 | // InternalAlloyLanguage.g:2649:1: ( ( ':' ) ) | ||
8427 | // InternalAlloyLanguage.g:2650:1: ( ':' ) | ||
8428 | { | ||
8429 | // InternalAlloyLanguage.g:2650:1: ( ':' ) | ||
8430 | // InternalAlloyLanguage.g:2651:1: ':' | ||
8431 | { | ||
8432 | if ( state.backtracking==0 ) { | ||
8433 | before(grammarAccess.getALSFieldDeclarationAccess().getColonKeyword_1()); | ||
8434 | } | ||
8435 | match(input,40,FOLLOW_2); if (state.failed) return ; | ||
8436 | if ( state.backtracking==0 ) { | ||
8437 | after(grammarAccess.getALSFieldDeclarationAccess().getColonKeyword_1()); | ||
8438 | } | ||
8439 | |||
8440 | } | ||
8441 | |||
8442 | |||
8443 | } | ||
8444 | |||
8445 | } | ||
8446 | catch (RecognitionException re) { | ||
8447 | reportError(re); | ||
8448 | recover(input,re); | ||
8449 | } | ||
8450 | finally { | ||
8451 | |||
8452 | restoreStackSize(stackSize); | ||
8453 | |||
8454 | } | ||
8455 | return ; | ||
8456 | } | ||
8457 | // $ANTLR end "rule__ALSFieldDeclaration__Group__1__Impl" | ||
8458 | |||
8459 | |||
8460 | // $ANTLR start "rule__ALSFieldDeclaration__Group__2" | ||
8461 | // InternalAlloyLanguage.g:2664:1: rule__ALSFieldDeclaration__Group__2 : rule__ALSFieldDeclaration__Group__2__Impl rule__ALSFieldDeclaration__Group__3 ; | ||
8462 | public final void rule__ALSFieldDeclaration__Group__2() throws RecognitionException { | ||
8463 | |||
8464 | int stackSize = keepStackSize(); | ||
8465 | |||
8466 | try { | ||
8467 | // InternalAlloyLanguage.g:2668:1: ( rule__ALSFieldDeclaration__Group__2__Impl rule__ALSFieldDeclaration__Group__3 ) | ||
8468 | // InternalAlloyLanguage.g:2669:2: rule__ALSFieldDeclaration__Group__2__Impl rule__ALSFieldDeclaration__Group__3 | ||
8469 | { | ||
8470 | pushFollow(FOLLOW_16); | ||
8471 | rule__ALSFieldDeclaration__Group__2__Impl(); | ||
8472 | |||
8473 | state._fsp--; | ||
8474 | if (state.failed) return ; | ||
8475 | pushFollow(FOLLOW_2); | ||
8476 | rule__ALSFieldDeclaration__Group__3(); | ||
8477 | |||
8478 | state._fsp--; | ||
8479 | if (state.failed) return ; | ||
8480 | |||
8481 | } | ||
8482 | |||
8483 | } | ||
8484 | catch (RecognitionException re) { | ||
8485 | reportError(re); | ||
8486 | recover(input,re); | ||
8487 | } | ||
8488 | finally { | ||
8489 | |||
8490 | restoreStackSize(stackSize); | ||
8491 | |||
8492 | } | ||
8493 | return ; | ||
8494 | } | ||
8495 | // $ANTLR end "rule__ALSFieldDeclaration__Group__2" | ||
8496 | |||
8497 | |||
8498 | // $ANTLR start "rule__ALSFieldDeclaration__Group__2__Impl" | ||
8499 | // InternalAlloyLanguage.g:2676:1: rule__ALSFieldDeclaration__Group__2__Impl : ( ( rule__ALSFieldDeclaration__MultiplicityAssignment_2 )? ) ; | ||
8500 | public final void rule__ALSFieldDeclaration__Group__2__Impl() throws RecognitionException { | ||
8501 | |||
8502 | int stackSize = keepStackSize(); | ||
8503 | |||
8504 | try { | ||
8505 | // InternalAlloyLanguage.g:2680:1: ( ( ( rule__ALSFieldDeclaration__MultiplicityAssignment_2 )? ) ) | ||
8506 | // InternalAlloyLanguage.g:2681:1: ( ( rule__ALSFieldDeclaration__MultiplicityAssignment_2 )? ) | ||
8507 | { | ||
8508 | // InternalAlloyLanguage.g:2681:1: ( ( rule__ALSFieldDeclaration__MultiplicityAssignment_2 )? ) | ||
8509 | // InternalAlloyLanguage.g:2682:1: ( rule__ALSFieldDeclaration__MultiplicityAssignment_2 )? | ||
8510 | { | ||
8511 | if ( state.backtracking==0 ) { | ||
8512 | before(grammarAccess.getALSFieldDeclarationAccess().getMultiplicityAssignment_2()); | ||
8513 | } | ||
8514 | // InternalAlloyLanguage.g:2683:1: ( rule__ALSFieldDeclaration__MultiplicityAssignment_2 )? | ||
8515 | int alt24=2; | ||
8516 | alt24 = dfa24.predict(input); | ||
8517 | switch (alt24) { | ||
8518 | case 1 : | ||
8519 | // InternalAlloyLanguage.g:2683:2: rule__ALSFieldDeclaration__MultiplicityAssignment_2 | ||
8520 | { | ||
8521 | pushFollow(FOLLOW_2); | ||
8522 | rule__ALSFieldDeclaration__MultiplicityAssignment_2(); | ||
8523 | |||
8524 | state._fsp--; | ||
8525 | if (state.failed) return ; | ||
8526 | |||
8527 | } | ||
8528 | break; | ||
8529 | |||
8530 | } | ||
8531 | |||
8532 | if ( state.backtracking==0 ) { | ||
8533 | after(grammarAccess.getALSFieldDeclarationAccess().getMultiplicityAssignment_2()); | ||
8534 | } | ||
8535 | |||
8536 | } | ||
8537 | |||
8538 | |||
8539 | } | ||
8540 | |||
8541 | } | ||
8542 | catch (RecognitionException re) { | ||
8543 | reportError(re); | ||
8544 | recover(input,re); | ||
8545 | } | ||
8546 | finally { | ||
8547 | |||
8548 | restoreStackSize(stackSize); | ||
8549 | |||
8550 | } | ||
8551 | return ; | ||
8552 | } | ||
8553 | // $ANTLR end "rule__ALSFieldDeclaration__Group__2__Impl" | ||
8554 | |||
8555 | |||
8556 | // $ANTLR start "rule__ALSFieldDeclaration__Group__3" | ||
8557 | // InternalAlloyLanguage.g:2693:1: rule__ALSFieldDeclaration__Group__3 : rule__ALSFieldDeclaration__Group__3__Impl ; | ||
8558 | public final void rule__ALSFieldDeclaration__Group__3() throws RecognitionException { | ||
8559 | |||
8560 | int stackSize = keepStackSize(); | ||
8561 | |||
8562 | try { | ||
8563 | // InternalAlloyLanguage.g:2697:1: ( rule__ALSFieldDeclaration__Group__3__Impl ) | ||
8564 | // InternalAlloyLanguage.g:2698:2: rule__ALSFieldDeclaration__Group__3__Impl | ||
8565 | { | ||
8566 | pushFollow(FOLLOW_2); | ||
8567 | rule__ALSFieldDeclaration__Group__3__Impl(); | ||
8568 | |||
8569 | state._fsp--; | ||
8570 | if (state.failed) return ; | ||
8571 | |||
8572 | } | ||
8573 | |||
8574 | } | ||
8575 | catch (RecognitionException re) { | ||
8576 | reportError(re); | ||
8577 | recover(input,re); | ||
8578 | } | ||
8579 | finally { | ||
8580 | |||
8581 | restoreStackSize(stackSize); | ||
8582 | |||
8583 | } | ||
8584 | return ; | ||
8585 | } | ||
8586 | // $ANTLR end "rule__ALSFieldDeclaration__Group__3" | ||
8587 | |||
8588 | |||
8589 | // $ANTLR start "rule__ALSFieldDeclaration__Group__3__Impl" | ||
8590 | // InternalAlloyLanguage.g:2704:1: rule__ALSFieldDeclaration__Group__3__Impl : ( ( rule__ALSFieldDeclaration__TypeAssignment_3 ) ) ; | ||
8591 | public final void rule__ALSFieldDeclaration__Group__3__Impl() throws RecognitionException { | ||
8592 | |||
8593 | int stackSize = keepStackSize(); | ||
8594 | |||
8595 | try { | ||
8596 | // InternalAlloyLanguage.g:2708:1: ( ( ( rule__ALSFieldDeclaration__TypeAssignment_3 ) ) ) | ||
8597 | // InternalAlloyLanguage.g:2709:1: ( ( rule__ALSFieldDeclaration__TypeAssignment_3 ) ) | ||
8598 | { | ||
8599 | // InternalAlloyLanguage.g:2709:1: ( ( rule__ALSFieldDeclaration__TypeAssignment_3 ) ) | ||
8600 | // InternalAlloyLanguage.g:2710:1: ( rule__ALSFieldDeclaration__TypeAssignment_3 ) | ||
8601 | { | ||
8602 | if ( state.backtracking==0 ) { | ||
8603 | before(grammarAccess.getALSFieldDeclarationAccess().getTypeAssignment_3()); | ||
8604 | } | ||
8605 | // InternalAlloyLanguage.g:2711:1: ( rule__ALSFieldDeclaration__TypeAssignment_3 ) | ||
8606 | // InternalAlloyLanguage.g:2711:2: rule__ALSFieldDeclaration__TypeAssignment_3 | ||
8607 | { | ||
8608 | pushFollow(FOLLOW_2); | ||
8609 | rule__ALSFieldDeclaration__TypeAssignment_3(); | ||
8610 | |||
8611 | state._fsp--; | ||
8612 | if (state.failed) return ; | ||
8613 | |||
8614 | } | ||
8615 | |||
8616 | if ( state.backtracking==0 ) { | ||
8617 | after(grammarAccess.getALSFieldDeclarationAccess().getTypeAssignment_3()); | ||
8618 | } | ||
8619 | |||
8620 | } | ||
8621 | |||
8622 | |||
8623 | } | ||
8624 | |||
8625 | } | ||
8626 | catch (RecognitionException re) { | ||
8627 | reportError(re); | ||
8628 | recover(input,re); | ||
8629 | } | ||
8630 | finally { | ||
8631 | |||
8632 | restoreStackSize(stackSize); | ||
8633 | |||
8634 | } | ||
8635 | return ; | ||
8636 | } | ||
8637 | // $ANTLR end "rule__ALSFieldDeclaration__Group__3__Impl" | ||
8638 | |||
8639 | |||
8640 | // $ANTLR start "rule__ALSFunctionDefinition__Group__0" | ||
8641 | // InternalAlloyLanguage.g:2729:1: rule__ALSFunctionDefinition__Group__0 : rule__ALSFunctionDefinition__Group__0__Impl rule__ALSFunctionDefinition__Group__1 ; | ||
8642 | public final void rule__ALSFunctionDefinition__Group__0() throws RecognitionException { | ||
8643 | |||
8644 | int stackSize = keepStackSize(); | ||
8645 | |||
8646 | try { | ||
8647 | // InternalAlloyLanguage.g:2733:1: ( rule__ALSFunctionDefinition__Group__0__Impl rule__ALSFunctionDefinition__Group__1 ) | ||
8648 | // InternalAlloyLanguage.g:2734:2: rule__ALSFunctionDefinition__Group__0__Impl rule__ALSFunctionDefinition__Group__1 | ||
8649 | { | ||
8650 | pushFollow(FOLLOW_5); | ||
8651 | rule__ALSFunctionDefinition__Group__0__Impl(); | ||
8652 | |||
8653 | state._fsp--; | ||
8654 | if (state.failed) return ; | ||
8655 | pushFollow(FOLLOW_2); | ||
8656 | rule__ALSFunctionDefinition__Group__1(); | ||
8657 | |||
8658 | state._fsp--; | ||
8659 | if (state.failed) return ; | ||
8660 | |||
8661 | } | ||
8662 | |||
8663 | } | ||
8664 | catch (RecognitionException re) { | ||
8665 | reportError(re); | ||
8666 | recover(input,re); | ||
8667 | } | ||
8668 | finally { | ||
8669 | |||
8670 | restoreStackSize(stackSize); | ||
8671 | |||
8672 | } | ||
8673 | return ; | ||
8674 | } | ||
8675 | // $ANTLR end "rule__ALSFunctionDefinition__Group__0" | ||
8676 | |||
8677 | |||
8678 | // $ANTLR start "rule__ALSFunctionDefinition__Group__0__Impl" | ||
8679 | // InternalAlloyLanguage.g:2741:1: rule__ALSFunctionDefinition__Group__0__Impl : ( 'fun' ) ; | ||
8680 | public final void rule__ALSFunctionDefinition__Group__0__Impl() throws RecognitionException { | ||
8681 | |||
8682 | int stackSize = keepStackSize(); | ||
8683 | |||
8684 | try { | ||
8685 | // InternalAlloyLanguage.g:2745:1: ( ( 'fun' ) ) | ||
8686 | // InternalAlloyLanguage.g:2746:1: ( 'fun' ) | ||
8687 | { | ||
8688 | // InternalAlloyLanguage.g:2746:1: ( 'fun' ) | ||
8689 | // InternalAlloyLanguage.g:2747:1: 'fun' | ||
8690 | { | ||
8691 | if ( state.backtracking==0 ) { | ||
8692 | before(grammarAccess.getALSFunctionDefinitionAccess().getFunKeyword_0()); | ||
8693 | } | ||
8694 | match(input,41,FOLLOW_2); if (state.failed) return ; | ||
8695 | if ( state.backtracking==0 ) { | ||
8696 | after(grammarAccess.getALSFunctionDefinitionAccess().getFunKeyword_0()); | ||
8697 | } | ||
8698 | |||
8699 | } | ||
8700 | |||
8701 | |||
8702 | } | ||
8703 | |||
8704 | } | ||
8705 | catch (RecognitionException re) { | ||
8706 | reportError(re); | ||
8707 | recover(input,re); | ||
8708 | } | ||
8709 | finally { | ||
8710 | |||
8711 | restoreStackSize(stackSize); | ||
8712 | |||
8713 | } | ||
8714 | return ; | ||
8715 | } | ||
8716 | // $ANTLR end "rule__ALSFunctionDefinition__Group__0__Impl" | ||
8717 | |||
8718 | |||
8719 | // $ANTLR start "rule__ALSFunctionDefinition__Group__1" | ||
8720 | // InternalAlloyLanguage.g:2760:1: rule__ALSFunctionDefinition__Group__1 : rule__ALSFunctionDefinition__Group__1__Impl rule__ALSFunctionDefinition__Group__2 ; | ||
8721 | public final void rule__ALSFunctionDefinition__Group__1() throws RecognitionException { | ||
8722 | |||
8723 | int stackSize = keepStackSize(); | ||
8724 | |||
8725 | try { | ||
8726 | // InternalAlloyLanguage.g:2764:1: ( rule__ALSFunctionDefinition__Group__1__Impl rule__ALSFunctionDefinition__Group__2 ) | ||
8727 | // InternalAlloyLanguage.g:2765:2: rule__ALSFunctionDefinition__Group__1__Impl rule__ALSFunctionDefinition__Group__2 | ||
8728 | { | ||
8729 | pushFollow(FOLLOW_17); | ||
8730 | rule__ALSFunctionDefinition__Group__1__Impl(); | ||
8731 | |||
8732 | state._fsp--; | ||
8733 | if (state.failed) return ; | ||
8734 | pushFollow(FOLLOW_2); | ||
8735 | rule__ALSFunctionDefinition__Group__2(); | ||
8736 | |||
8737 | state._fsp--; | ||
8738 | if (state.failed) return ; | ||
8739 | |||
8740 | } | ||
8741 | |||
8742 | } | ||
8743 | catch (RecognitionException re) { | ||
8744 | reportError(re); | ||
8745 | recover(input,re); | ||
8746 | } | ||
8747 | finally { | ||
8748 | |||
8749 | restoreStackSize(stackSize); | ||
8750 | |||
8751 | } | ||
8752 | return ; | ||
8753 | } | ||
8754 | // $ANTLR end "rule__ALSFunctionDefinition__Group__1" | ||
8755 | |||
8756 | |||
8757 | // $ANTLR start "rule__ALSFunctionDefinition__Group__1__Impl" | ||
8758 | // InternalAlloyLanguage.g:2772:1: rule__ALSFunctionDefinition__Group__1__Impl : ( ( rule__ALSFunctionDefinition__NameAssignment_1 ) ) ; | ||
8759 | public final void rule__ALSFunctionDefinition__Group__1__Impl() throws RecognitionException { | ||
8760 | |||
8761 | int stackSize = keepStackSize(); | ||
8762 | |||
8763 | try { | ||
8764 | // InternalAlloyLanguage.g:2776:1: ( ( ( rule__ALSFunctionDefinition__NameAssignment_1 ) ) ) | ||
8765 | // InternalAlloyLanguage.g:2777:1: ( ( rule__ALSFunctionDefinition__NameAssignment_1 ) ) | ||
8766 | { | ||
8767 | // InternalAlloyLanguage.g:2777:1: ( ( rule__ALSFunctionDefinition__NameAssignment_1 ) ) | ||
8768 | // InternalAlloyLanguage.g:2778:1: ( rule__ALSFunctionDefinition__NameAssignment_1 ) | ||
8769 | { | ||
8770 | if ( state.backtracking==0 ) { | ||
8771 | before(grammarAccess.getALSFunctionDefinitionAccess().getNameAssignment_1()); | ||
8772 | } | ||
8773 | // InternalAlloyLanguage.g:2779:1: ( rule__ALSFunctionDefinition__NameAssignment_1 ) | ||
8774 | // InternalAlloyLanguage.g:2779:2: rule__ALSFunctionDefinition__NameAssignment_1 | ||
8775 | { | ||
8776 | pushFollow(FOLLOW_2); | ||
8777 | rule__ALSFunctionDefinition__NameAssignment_1(); | ||
8778 | |||
8779 | state._fsp--; | ||
8780 | if (state.failed) return ; | ||
8781 | |||
8782 | } | ||
8783 | |||
8784 | if ( state.backtracking==0 ) { | ||
8785 | after(grammarAccess.getALSFunctionDefinitionAccess().getNameAssignment_1()); | ||
8786 | } | ||
8787 | |||
8788 | } | ||
8789 | |||
8790 | |||
8791 | } | ||
8792 | |||
8793 | } | ||
8794 | catch (RecognitionException re) { | ||
8795 | reportError(re); | ||
8796 | recover(input,re); | ||
8797 | } | ||
8798 | finally { | ||
8799 | |||
8800 | restoreStackSize(stackSize); | ||
8801 | |||
8802 | } | ||
8803 | return ; | ||
8804 | } | ||
8805 | // $ANTLR end "rule__ALSFunctionDefinition__Group__1__Impl" | ||
8806 | |||
8807 | |||
8808 | // $ANTLR start "rule__ALSFunctionDefinition__Group__2" | ||
8809 | // InternalAlloyLanguage.g:2789:1: rule__ALSFunctionDefinition__Group__2 : rule__ALSFunctionDefinition__Group__2__Impl rule__ALSFunctionDefinition__Group__3 ; | ||
8810 | public final void rule__ALSFunctionDefinition__Group__2() throws RecognitionException { | ||
8811 | |||
8812 | int stackSize = keepStackSize(); | ||
8813 | |||
8814 | try { | ||
8815 | // InternalAlloyLanguage.g:2793:1: ( rule__ALSFunctionDefinition__Group__2__Impl rule__ALSFunctionDefinition__Group__3 ) | ||
8816 | // InternalAlloyLanguage.g:2794:2: rule__ALSFunctionDefinition__Group__2__Impl rule__ALSFunctionDefinition__Group__3 | ||
8817 | { | ||
8818 | pushFollow(FOLLOW_5); | ||
8819 | rule__ALSFunctionDefinition__Group__2__Impl(); | ||
8820 | |||
8821 | state._fsp--; | ||
8822 | if (state.failed) return ; | ||
8823 | pushFollow(FOLLOW_2); | ||
8824 | rule__ALSFunctionDefinition__Group__3(); | ||
8825 | |||
8826 | state._fsp--; | ||
8827 | if (state.failed) return ; | ||
8828 | |||
8829 | } | ||
8830 | |||
8831 | } | ||
8832 | catch (RecognitionException re) { | ||
8833 | reportError(re); | ||
8834 | recover(input,re); | ||
8835 | } | ||
8836 | finally { | ||
8837 | |||
8838 | restoreStackSize(stackSize); | ||
8839 | |||
8840 | } | ||
8841 | return ; | ||
8842 | } | ||
8843 | // $ANTLR end "rule__ALSFunctionDefinition__Group__2" | ||
8844 | |||
8845 | |||
8846 | // $ANTLR start "rule__ALSFunctionDefinition__Group__2__Impl" | ||
8847 | // InternalAlloyLanguage.g:2801:1: rule__ALSFunctionDefinition__Group__2__Impl : ( '[' ) ; | ||
8848 | public final void rule__ALSFunctionDefinition__Group__2__Impl() throws RecognitionException { | ||
8849 | |||
8850 | int stackSize = keepStackSize(); | ||
8851 | |||
8852 | try { | ||
8853 | // InternalAlloyLanguage.g:2805:1: ( ( '[' ) ) | ||
8854 | // InternalAlloyLanguage.g:2806:1: ( '[' ) | ||
8855 | { | ||
8856 | // InternalAlloyLanguage.g:2806:1: ( '[' ) | ||
8857 | // InternalAlloyLanguage.g:2807:1: '[' | ||
8858 | { | ||
8859 | if ( state.backtracking==0 ) { | ||
8860 | before(grammarAccess.getALSFunctionDefinitionAccess().getLeftSquareBracketKeyword_2()); | ||
8861 | } | ||
8862 | match(input,42,FOLLOW_2); if (state.failed) return ; | ||
8863 | if ( state.backtracking==0 ) { | ||
8864 | after(grammarAccess.getALSFunctionDefinitionAccess().getLeftSquareBracketKeyword_2()); | ||
8865 | } | ||
8866 | |||
8867 | } | ||
8868 | |||
8869 | |||
8870 | } | ||
8871 | |||
8872 | } | ||
8873 | catch (RecognitionException re) { | ||
8874 | reportError(re); | ||
8875 | recover(input,re); | ||
8876 | } | ||
8877 | finally { | ||
8878 | |||
8879 | restoreStackSize(stackSize); | ||
8880 | |||
8881 | } | ||
8882 | return ; | ||
8883 | } | ||
8884 | // $ANTLR end "rule__ALSFunctionDefinition__Group__2__Impl" | ||
8885 | |||
8886 | |||
8887 | // $ANTLR start "rule__ALSFunctionDefinition__Group__3" | ||
8888 | // InternalAlloyLanguage.g:2820:1: rule__ALSFunctionDefinition__Group__3 : rule__ALSFunctionDefinition__Group__3__Impl rule__ALSFunctionDefinition__Group__4 ; | ||
8889 | public final void rule__ALSFunctionDefinition__Group__3() throws RecognitionException { | ||
8890 | |||
8891 | int stackSize = keepStackSize(); | ||
8892 | |||
8893 | try { | ||
8894 | // InternalAlloyLanguage.g:2824:1: ( rule__ALSFunctionDefinition__Group__3__Impl rule__ALSFunctionDefinition__Group__4 ) | ||
8895 | // InternalAlloyLanguage.g:2825:2: rule__ALSFunctionDefinition__Group__3__Impl rule__ALSFunctionDefinition__Group__4 | ||
8896 | { | ||
8897 | pushFollow(FOLLOW_18); | ||
8898 | rule__ALSFunctionDefinition__Group__3__Impl(); | ||
8899 | |||
8900 | state._fsp--; | ||
8901 | if (state.failed) return ; | ||
8902 | pushFollow(FOLLOW_2); | ||
8903 | rule__ALSFunctionDefinition__Group__4(); | ||
8904 | |||
8905 | state._fsp--; | ||
8906 | if (state.failed) return ; | ||
8907 | |||
8908 | } | ||
8909 | |||
8910 | } | ||
8911 | catch (RecognitionException re) { | ||
8912 | reportError(re); | ||
8913 | recover(input,re); | ||
8914 | } | ||
8915 | finally { | ||
8916 | |||
8917 | restoreStackSize(stackSize); | ||
8918 | |||
8919 | } | ||
8920 | return ; | ||
8921 | } | ||
8922 | // $ANTLR end "rule__ALSFunctionDefinition__Group__3" | ||
8923 | |||
8924 | |||
8925 | // $ANTLR start "rule__ALSFunctionDefinition__Group__3__Impl" | ||
8926 | // InternalAlloyLanguage.g:2832:1: rule__ALSFunctionDefinition__Group__3__Impl : ( ( rule__ALSFunctionDefinition__VariablesAssignment_3 ) ) ; | ||
8927 | public final void rule__ALSFunctionDefinition__Group__3__Impl() throws RecognitionException { | ||
8928 | |||
8929 | int stackSize = keepStackSize(); | ||
8930 | |||
8931 | try { | ||
8932 | // InternalAlloyLanguage.g:2836:1: ( ( ( rule__ALSFunctionDefinition__VariablesAssignment_3 ) ) ) | ||
8933 | // InternalAlloyLanguage.g:2837:1: ( ( rule__ALSFunctionDefinition__VariablesAssignment_3 ) ) | ||
8934 | { | ||
8935 | // InternalAlloyLanguage.g:2837:1: ( ( rule__ALSFunctionDefinition__VariablesAssignment_3 ) ) | ||
8936 | // InternalAlloyLanguage.g:2838:1: ( rule__ALSFunctionDefinition__VariablesAssignment_3 ) | ||
8937 | { | ||
8938 | if ( state.backtracking==0 ) { | ||
8939 | before(grammarAccess.getALSFunctionDefinitionAccess().getVariablesAssignment_3()); | ||
8940 | } | ||
8941 | // InternalAlloyLanguage.g:2839:1: ( rule__ALSFunctionDefinition__VariablesAssignment_3 ) | ||
8942 | // InternalAlloyLanguage.g:2839:2: rule__ALSFunctionDefinition__VariablesAssignment_3 | ||
8943 | { | ||
8944 | pushFollow(FOLLOW_2); | ||
8945 | rule__ALSFunctionDefinition__VariablesAssignment_3(); | ||
8946 | |||
8947 | state._fsp--; | ||
8948 | if (state.failed) return ; | ||
8949 | |||
8950 | } | ||
8951 | |||
8952 | if ( state.backtracking==0 ) { | ||
8953 | after(grammarAccess.getALSFunctionDefinitionAccess().getVariablesAssignment_3()); | ||
8954 | } | ||
8955 | |||
8956 | } | ||
8957 | |||
8958 | |||
8959 | } | ||
8960 | |||
8961 | } | ||
8962 | catch (RecognitionException re) { | ||
8963 | reportError(re); | ||
8964 | recover(input,re); | ||
8965 | } | ||
8966 | finally { | ||
8967 | |||
8968 | restoreStackSize(stackSize); | ||
8969 | |||
8970 | } | ||
8971 | return ; | ||
8972 | } | ||
8973 | // $ANTLR end "rule__ALSFunctionDefinition__Group__3__Impl" | ||
8974 | |||
8975 | |||
8976 | // $ANTLR start "rule__ALSFunctionDefinition__Group__4" | ||
8977 | // InternalAlloyLanguage.g:2849:1: rule__ALSFunctionDefinition__Group__4 : rule__ALSFunctionDefinition__Group__4__Impl rule__ALSFunctionDefinition__Group__5 ; | ||
8978 | public final void rule__ALSFunctionDefinition__Group__4() throws RecognitionException { | ||
8979 | |||
8980 | int stackSize = keepStackSize(); | ||
8981 | |||
8982 | try { | ||
8983 | // InternalAlloyLanguage.g:2853:1: ( rule__ALSFunctionDefinition__Group__4__Impl rule__ALSFunctionDefinition__Group__5 ) | ||
8984 | // InternalAlloyLanguage.g:2854:2: rule__ALSFunctionDefinition__Group__4__Impl rule__ALSFunctionDefinition__Group__5 | ||
8985 | { | ||
8986 | pushFollow(FOLLOW_18); | ||
8987 | rule__ALSFunctionDefinition__Group__4__Impl(); | ||
8988 | |||
8989 | state._fsp--; | ||
8990 | if (state.failed) return ; | ||
8991 | pushFollow(FOLLOW_2); | ||
8992 | rule__ALSFunctionDefinition__Group__5(); | ||
8993 | |||
8994 | state._fsp--; | ||
8995 | if (state.failed) return ; | ||
8996 | |||
8997 | } | ||
8998 | |||
8999 | } | ||
9000 | catch (RecognitionException re) { | ||
9001 | reportError(re); | ||
9002 | recover(input,re); | ||
9003 | } | ||
9004 | finally { | ||
9005 | |||
9006 | restoreStackSize(stackSize); | ||
9007 | |||
9008 | } | ||
9009 | return ; | ||
9010 | } | ||
9011 | // $ANTLR end "rule__ALSFunctionDefinition__Group__4" | ||
9012 | |||
9013 | |||
9014 | // $ANTLR start "rule__ALSFunctionDefinition__Group__4__Impl" | ||
9015 | // InternalAlloyLanguage.g:2861:1: rule__ALSFunctionDefinition__Group__4__Impl : ( ( rule__ALSFunctionDefinition__Group_4__0 )* ) ; | ||
9016 | public final void rule__ALSFunctionDefinition__Group__4__Impl() throws RecognitionException { | ||
9017 | |||
9018 | int stackSize = keepStackSize(); | ||
9019 | |||
9020 | try { | ||
9021 | // InternalAlloyLanguage.g:2865:1: ( ( ( rule__ALSFunctionDefinition__Group_4__0 )* ) ) | ||
9022 | // InternalAlloyLanguage.g:2866:1: ( ( rule__ALSFunctionDefinition__Group_4__0 )* ) | ||
9023 | { | ||
9024 | // InternalAlloyLanguage.g:2866:1: ( ( rule__ALSFunctionDefinition__Group_4__0 )* ) | ||
9025 | // InternalAlloyLanguage.g:2867:1: ( rule__ALSFunctionDefinition__Group_4__0 )* | ||
9026 | { | ||
9027 | if ( state.backtracking==0 ) { | ||
9028 | before(grammarAccess.getALSFunctionDefinitionAccess().getGroup_4()); | ||
9029 | } | ||
9030 | // InternalAlloyLanguage.g:2868:1: ( rule__ALSFunctionDefinition__Group_4__0 )* | ||
9031 | loop25: | ||
9032 | do { | ||
9033 | int alt25=2; | ||
9034 | int LA25_0 = input.LA(1); | ||
9035 | |||
9036 | if ( (LA25_0==35) ) { | ||
9037 | alt25=1; | ||
9038 | } | ||
9039 | |||
9040 | |||
9041 | switch (alt25) { | ||
9042 | case 1 : | ||
9043 | // InternalAlloyLanguage.g:2868:2: rule__ALSFunctionDefinition__Group_4__0 | ||
9044 | { | ||
9045 | pushFollow(FOLLOW_8); | ||
9046 | rule__ALSFunctionDefinition__Group_4__0(); | ||
9047 | |||
9048 | state._fsp--; | ||
9049 | if (state.failed) return ; | ||
9050 | |||
9051 | } | ||
9052 | break; | ||
9053 | |||
9054 | default : | ||
9055 | break loop25; | ||
9056 | } | ||
9057 | } while (true); | ||
9058 | |||
9059 | if ( state.backtracking==0 ) { | ||
9060 | after(grammarAccess.getALSFunctionDefinitionAccess().getGroup_4()); | ||
9061 | } | ||
9062 | |||
9063 | } | ||
9064 | |||
9065 | |||
9066 | } | ||
9067 | |||
9068 | } | ||
9069 | catch (RecognitionException re) { | ||
9070 | reportError(re); | ||
9071 | recover(input,re); | ||
9072 | } | ||
9073 | finally { | ||
9074 | |||
9075 | restoreStackSize(stackSize); | ||
9076 | |||
9077 | } | ||
9078 | return ; | ||
9079 | } | ||
9080 | // $ANTLR end "rule__ALSFunctionDefinition__Group__4__Impl" | ||
9081 | |||
9082 | |||
9083 | // $ANTLR start "rule__ALSFunctionDefinition__Group__5" | ||
9084 | // InternalAlloyLanguage.g:2878:1: rule__ALSFunctionDefinition__Group__5 : rule__ALSFunctionDefinition__Group__5__Impl rule__ALSFunctionDefinition__Group__6 ; | ||
9085 | public final void rule__ALSFunctionDefinition__Group__5() throws RecognitionException { | ||
9086 | |||
9087 | int stackSize = keepStackSize(); | ||
9088 | |||
9089 | try { | ||
9090 | // InternalAlloyLanguage.g:2882:1: ( rule__ALSFunctionDefinition__Group__5__Impl rule__ALSFunctionDefinition__Group__6 ) | ||
9091 | // InternalAlloyLanguage.g:2883:2: rule__ALSFunctionDefinition__Group__5__Impl rule__ALSFunctionDefinition__Group__6 | ||
9092 | { | ||
9093 | pushFollow(FOLLOW_15); | ||
9094 | rule__ALSFunctionDefinition__Group__5__Impl(); | ||
9095 | |||
9096 | state._fsp--; | ||
9097 | if (state.failed) return ; | ||
9098 | pushFollow(FOLLOW_2); | ||
9099 | rule__ALSFunctionDefinition__Group__6(); | ||
9100 | |||
9101 | state._fsp--; | ||
9102 | if (state.failed) return ; | ||
9103 | |||
9104 | } | ||
9105 | |||
9106 | } | ||
9107 | catch (RecognitionException re) { | ||
9108 | reportError(re); | ||
9109 | recover(input,re); | ||
9110 | } | ||
9111 | finally { | ||
9112 | |||
9113 | restoreStackSize(stackSize); | ||
9114 | |||
9115 | } | ||
9116 | return ; | ||
9117 | } | ||
9118 | // $ANTLR end "rule__ALSFunctionDefinition__Group__5" | ||
9119 | |||
9120 | |||
9121 | // $ANTLR start "rule__ALSFunctionDefinition__Group__5__Impl" | ||
9122 | // InternalAlloyLanguage.g:2890:1: rule__ALSFunctionDefinition__Group__5__Impl : ( ']' ) ; | ||
9123 | public final void rule__ALSFunctionDefinition__Group__5__Impl() throws RecognitionException { | ||
9124 | |||
9125 | int stackSize = keepStackSize(); | ||
9126 | |||
9127 | try { | ||
9128 | // InternalAlloyLanguage.g:2894:1: ( ( ']' ) ) | ||
9129 | // InternalAlloyLanguage.g:2895:1: ( ']' ) | ||
9130 | { | ||
9131 | // InternalAlloyLanguage.g:2895:1: ( ']' ) | ||
9132 | // InternalAlloyLanguage.g:2896:1: ']' | ||
9133 | { | ||
9134 | if ( state.backtracking==0 ) { | ||
9135 | before(grammarAccess.getALSFunctionDefinitionAccess().getRightSquareBracketKeyword_5()); | ||
9136 | } | ||
9137 | match(input,43,FOLLOW_2); if (state.failed) return ; | ||
9138 | if ( state.backtracking==0 ) { | ||
9139 | after(grammarAccess.getALSFunctionDefinitionAccess().getRightSquareBracketKeyword_5()); | ||
9140 | } | ||
9141 | |||
9142 | } | ||
9143 | |||
9144 | |||
9145 | } | ||
9146 | |||
9147 | } | ||
9148 | catch (RecognitionException re) { | ||
9149 | reportError(re); | ||
9150 | recover(input,re); | ||
9151 | } | ||
9152 | finally { | ||
9153 | |||
9154 | restoreStackSize(stackSize); | ||
9155 | |||
9156 | } | ||
9157 | return ; | ||
9158 | } | ||
9159 | // $ANTLR end "rule__ALSFunctionDefinition__Group__5__Impl" | ||
9160 | |||
9161 | |||
9162 | // $ANTLR start "rule__ALSFunctionDefinition__Group__6" | ||
9163 | // InternalAlloyLanguage.g:2909:1: rule__ALSFunctionDefinition__Group__6 : rule__ALSFunctionDefinition__Group__6__Impl rule__ALSFunctionDefinition__Group__7 ; | ||
9164 | public final void rule__ALSFunctionDefinition__Group__6() throws RecognitionException { | ||
9165 | |||
9166 | int stackSize = keepStackSize(); | ||
9167 | |||
9168 | try { | ||
9169 | // InternalAlloyLanguage.g:2913:1: ( rule__ALSFunctionDefinition__Group__6__Impl rule__ALSFunctionDefinition__Group__7 ) | ||
9170 | // InternalAlloyLanguage.g:2914:2: rule__ALSFunctionDefinition__Group__6__Impl rule__ALSFunctionDefinition__Group__7 | ||
9171 | { | ||
9172 | pushFollow(FOLLOW_16); | ||
9173 | rule__ALSFunctionDefinition__Group__6__Impl(); | ||
9174 | |||
9175 | state._fsp--; | ||
9176 | if (state.failed) return ; | ||
9177 | pushFollow(FOLLOW_2); | ||
9178 | rule__ALSFunctionDefinition__Group__7(); | ||
9179 | |||
9180 | state._fsp--; | ||
9181 | if (state.failed) return ; | ||
9182 | |||
9183 | } | ||
9184 | |||
9185 | } | ||
9186 | catch (RecognitionException re) { | ||
9187 | reportError(re); | ||
9188 | recover(input,re); | ||
9189 | } | ||
9190 | finally { | ||
9191 | |||
9192 | restoreStackSize(stackSize); | ||
9193 | |||
9194 | } | ||
9195 | return ; | ||
9196 | } | ||
9197 | // $ANTLR end "rule__ALSFunctionDefinition__Group__6" | ||
9198 | |||
9199 | |||
9200 | // $ANTLR start "rule__ALSFunctionDefinition__Group__6__Impl" | ||
9201 | // InternalAlloyLanguage.g:2921:1: rule__ALSFunctionDefinition__Group__6__Impl : ( ':' ) ; | ||
9202 | public final void rule__ALSFunctionDefinition__Group__6__Impl() throws RecognitionException { | ||
9203 | |||
9204 | int stackSize = keepStackSize(); | ||
9205 | |||
9206 | try { | ||
9207 | // InternalAlloyLanguage.g:2925:1: ( ( ':' ) ) | ||
9208 | // InternalAlloyLanguage.g:2926:1: ( ':' ) | ||
9209 | { | ||
9210 | // InternalAlloyLanguage.g:2926:1: ( ':' ) | ||
9211 | // InternalAlloyLanguage.g:2927:1: ':' | ||
9212 | { | ||
9213 | if ( state.backtracking==0 ) { | ||
9214 | before(grammarAccess.getALSFunctionDefinitionAccess().getColonKeyword_6()); | ||
9215 | } | ||
9216 | match(input,40,FOLLOW_2); if (state.failed) return ; | ||
9217 | if ( state.backtracking==0 ) { | ||
9218 | after(grammarAccess.getALSFunctionDefinitionAccess().getColonKeyword_6()); | ||
9219 | } | ||
9220 | |||
9221 | } | ||
9222 | |||
9223 | |||
9224 | } | ||
9225 | |||
9226 | } | ||
9227 | catch (RecognitionException re) { | ||
9228 | reportError(re); | ||
9229 | recover(input,re); | ||
9230 | } | ||
9231 | finally { | ||
9232 | |||
9233 | restoreStackSize(stackSize); | ||
9234 | |||
9235 | } | ||
9236 | return ; | ||
9237 | } | ||
9238 | // $ANTLR end "rule__ALSFunctionDefinition__Group__6__Impl" | ||
9239 | |||
9240 | |||
9241 | // $ANTLR start "rule__ALSFunctionDefinition__Group__7" | ||
9242 | // InternalAlloyLanguage.g:2940:1: rule__ALSFunctionDefinition__Group__7 : rule__ALSFunctionDefinition__Group__7__Impl rule__ALSFunctionDefinition__Group__8 ; | ||
9243 | public final void rule__ALSFunctionDefinition__Group__7() throws RecognitionException { | ||
9244 | |||
9245 | int stackSize = keepStackSize(); | ||
9246 | |||
9247 | try { | ||
9248 | // InternalAlloyLanguage.g:2944:1: ( rule__ALSFunctionDefinition__Group__7__Impl rule__ALSFunctionDefinition__Group__8 ) | ||
9249 | // InternalAlloyLanguage.g:2945:2: rule__ALSFunctionDefinition__Group__7__Impl rule__ALSFunctionDefinition__Group__8 | ||
9250 | { | ||
9251 | pushFollow(FOLLOW_6); | ||
9252 | rule__ALSFunctionDefinition__Group__7__Impl(); | ||
9253 | |||
9254 | state._fsp--; | ||
9255 | if (state.failed) return ; | ||
9256 | pushFollow(FOLLOW_2); | ||
9257 | rule__ALSFunctionDefinition__Group__8(); | ||
9258 | |||
9259 | state._fsp--; | ||
9260 | if (state.failed) return ; | ||
9261 | |||
9262 | } | ||
9263 | |||
9264 | } | ||
9265 | catch (RecognitionException re) { | ||
9266 | reportError(re); | ||
9267 | recover(input,re); | ||
9268 | } | ||
9269 | finally { | ||
9270 | |||
9271 | restoreStackSize(stackSize); | ||
9272 | |||
9273 | } | ||
9274 | return ; | ||
9275 | } | ||
9276 | // $ANTLR end "rule__ALSFunctionDefinition__Group__7" | ||
9277 | |||
9278 | |||
9279 | // $ANTLR start "rule__ALSFunctionDefinition__Group__7__Impl" | ||
9280 | // InternalAlloyLanguage.g:2952:1: rule__ALSFunctionDefinition__Group__7__Impl : ( ( rule__ALSFunctionDefinition__TypeAssignment_7 ) ) ; | ||
9281 | public final void rule__ALSFunctionDefinition__Group__7__Impl() throws RecognitionException { | ||
9282 | |||
9283 | int stackSize = keepStackSize(); | ||
9284 | |||
9285 | try { | ||
9286 | // InternalAlloyLanguage.g:2956:1: ( ( ( rule__ALSFunctionDefinition__TypeAssignment_7 ) ) ) | ||
9287 | // InternalAlloyLanguage.g:2957:1: ( ( rule__ALSFunctionDefinition__TypeAssignment_7 ) ) | ||
9288 | { | ||
9289 | // InternalAlloyLanguage.g:2957:1: ( ( rule__ALSFunctionDefinition__TypeAssignment_7 ) ) | ||
9290 | // InternalAlloyLanguage.g:2958:1: ( rule__ALSFunctionDefinition__TypeAssignment_7 ) | ||
9291 | { | ||
9292 | if ( state.backtracking==0 ) { | ||
9293 | before(grammarAccess.getALSFunctionDefinitionAccess().getTypeAssignment_7()); | ||
9294 | } | ||
9295 | // InternalAlloyLanguage.g:2959:1: ( rule__ALSFunctionDefinition__TypeAssignment_7 ) | ||
9296 | // InternalAlloyLanguage.g:2959:2: rule__ALSFunctionDefinition__TypeAssignment_7 | ||
9297 | { | ||
9298 | pushFollow(FOLLOW_2); | ||
9299 | rule__ALSFunctionDefinition__TypeAssignment_7(); | ||
9300 | |||
9301 | state._fsp--; | ||
9302 | if (state.failed) return ; | ||
9303 | |||
9304 | } | ||
9305 | |||
9306 | if ( state.backtracking==0 ) { | ||
9307 | after(grammarAccess.getALSFunctionDefinitionAccess().getTypeAssignment_7()); | ||
9308 | } | ||
9309 | |||
9310 | } | ||
9311 | |||
9312 | |||
9313 | } | ||
9314 | |||
9315 | } | ||
9316 | catch (RecognitionException re) { | ||
9317 | reportError(re); | ||
9318 | recover(input,re); | ||
9319 | } | ||
9320 | finally { | ||
9321 | |||
9322 | restoreStackSize(stackSize); | ||
9323 | |||
9324 | } | ||
9325 | return ; | ||
9326 | } | ||
9327 | // $ANTLR end "rule__ALSFunctionDefinition__Group__7__Impl" | ||
9328 | |||
9329 | |||
9330 | // $ANTLR start "rule__ALSFunctionDefinition__Group__8" | ||
9331 | // InternalAlloyLanguage.g:2969:1: rule__ALSFunctionDefinition__Group__8 : rule__ALSFunctionDefinition__Group__8__Impl rule__ALSFunctionDefinition__Group__9 ; | ||
9332 | public final void rule__ALSFunctionDefinition__Group__8() throws RecognitionException { | ||
9333 | |||
9334 | int stackSize = keepStackSize(); | ||
9335 | |||
9336 | try { | ||
9337 | // InternalAlloyLanguage.g:2973:1: ( rule__ALSFunctionDefinition__Group__8__Impl rule__ALSFunctionDefinition__Group__9 ) | ||
9338 | // InternalAlloyLanguage.g:2974:2: rule__ALSFunctionDefinition__Group__8__Impl rule__ALSFunctionDefinition__Group__9 | ||
9339 | { | ||
9340 | pushFollow(FOLLOW_16); | ||
9341 | rule__ALSFunctionDefinition__Group__8__Impl(); | ||
9342 | |||
9343 | state._fsp--; | ||
9344 | if (state.failed) return ; | ||
9345 | pushFollow(FOLLOW_2); | ||
9346 | rule__ALSFunctionDefinition__Group__9(); | ||
9347 | |||
9348 | state._fsp--; | ||
9349 | if (state.failed) return ; | ||
9350 | |||
9351 | } | ||
9352 | |||
9353 | } | ||
9354 | catch (RecognitionException re) { | ||
9355 | reportError(re); | ||
9356 | recover(input,re); | ||
9357 | } | ||
9358 | finally { | ||
9359 | |||
9360 | restoreStackSize(stackSize); | ||
9361 | |||
9362 | } | ||
9363 | return ; | ||
9364 | } | ||
9365 | // $ANTLR end "rule__ALSFunctionDefinition__Group__8" | ||
9366 | |||
9367 | |||
9368 | // $ANTLR start "rule__ALSFunctionDefinition__Group__8__Impl" | ||
9369 | // InternalAlloyLanguage.g:2981:1: rule__ALSFunctionDefinition__Group__8__Impl : ( '{' ) ; | ||
9370 | public final void rule__ALSFunctionDefinition__Group__8__Impl() throws RecognitionException { | ||
9371 | |||
9372 | int stackSize = keepStackSize(); | ||
9373 | |||
9374 | try { | ||
9375 | // InternalAlloyLanguage.g:2985:1: ( ( '{' ) ) | ||
9376 | // InternalAlloyLanguage.g:2986:1: ( '{' ) | ||
9377 | { | ||
9378 | // InternalAlloyLanguage.g:2986:1: ( '{' ) | ||
9379 | // InternalAlloyLanguage.g:2987:1: '{' | ||
9380 | { | ||
9381 | if ( state.backtracking==0 ) { | ||
9382 | before(grammarAccess.getALSFunctionDefinitionAccess().getLeftCurlyBracketKeyword_8()); | ||
9383 | } | ||
9384 | match(input,33,FOLLOW_2); if (state.failed) return ; | ||
9385 | if ( state.backtracking==0 ) { | ||
9386 | after(grammarAccess.getALSFunctionDefinitionAccess().getLeftCurlyBracketKeyword_8()); | ||
9387 | } | ||
9388 | |||
9389 | } | ||
9390 | |||
9391 | |||
9392 | } | ||
9393 | |||
9394 | } | ||
9395 | catch (RecognitionException re) { | ||
9396 | reportError(re); | ||
9397 | recover(input,re); | ||
9398 | } | ||
9399 | finally { | ||
9400 | |||
9401 | restoreStackSize(stackSize); | ||
9402 | |||
9403 | } | ||
9404 | return ; | ||
9405 | } | ||
9406 | // $ANTLR end "rule__ALSFunctionDefinition__Group__8__Impl" | ||
9407 | |||
9408 | |||
9409 | // $ANTLR start "rule__ALSFunctionDefinition__Group__9" | ||
9410 | // InternalAlloyLanguage.g:3000:1: rule__ALSFunctionDefinition__Group__9 : rule__ALSFunctionDefinition__Group__9__Impl rule__ALSFunctionDefinition__Group__10 ; | ||
9411 | public final void rule__ALSFunctionDefinition__Group__9() throws RecognitionException { | ||
9412 | |||
9413 | int stackSize = keepStackSize(); | ||
9414 | |||
9415 | try { | ||
9416 | // InternalAlloyLanguage.g:3004:1: ( rule__ALSFunctionDefinition__Group__9__Impl rule__ALSFunctionDefinition__Group__10 ) | ||
9417 | // InternalAlloyLanguage.g:3005:2: rule__ALSFunctionDefinition__Group__9__Impl rule__ALSFunctionDefinition__Group__10 | ||
9418 | { | ||
9419 | pushFollow(FOLLOW_19); | ||
9420 | rule__ALSFunctionDefinition__Group__9__Impl(); | ||
9421 | |||
9422 | state._fsp--; | ||
9423 | if (state.failed) return ; | ||
9424 | pushFollow(FOLLOW_2); | ||
9425 | rule__ALSFunctionDefinition__Group__10(); | ||
9426 | |||
9427 | state._fsp--; | ||
9428 | if (state.failed) return ; | ||
9429 | |||
9430 | } | ||
9431 | |||
9432 | } | ||
9433 | catch (RecognitionException re) { | ||
9434 | reportError(re); | ||
9435 | recover(input,re); | ||
9436 | } | ||
9437 | finally { | ||
9438 | |||
9439 | restoreStackSize(stackSize); | ||
9440 | |||
9441 | } | ||
9442 | return ; | ||
9443 | } | ||
9444 | // $ANTLR end "rule__ALSFunctionDefinition__Group__9" | ||
9445 | |||
9446 | |||
9447 | // $ANTLR start "rule__ALSFunctionDefinition__Group__9__Impl" | ||
9448 | // InternalAlloyLanguage.g:3012:1: rule__ALSFunctionDefinition__Group__9__Impl : ( ( rule__ALSFunctionDefinition__ValueAssignment_9 ) ) ; | ||
9449 | public final void rule__ALSFunctionDefinition__Group__9__Impl() throws RecognitionException { | ||
9450 | |||
9451 | int stackSize = keepStackSize(); | ||
9452 | |||
9453 | try { | ||
9454 | // InternalAlloyLanguage.g:3016:1: ( ( ( rule__ALSFunctionDefinition__ValueAssignment_9 ) ) ) | ||
9455 | // InternalAlloyLanguage.g:3017:1: ( ( rule__ALSFunctionDefinition__ValueAssignment_9 ) ) | ||
9456 | { | ||
9457 | // InternalAlloyLanguage.g:3017:1: ( ( rule__ALSFunctionDefinition__ValueAssignment_9 ) ) | ||
9458 | // InternalAlloyLanguage.g:3018:1: ( rule__ALSFunctionDefinition__ValueAssignment_9 ) | ||
9459 | { | ||
9460 | if ( state.backtracking==0 ) { | ||
9461 | before(grammarAccess.getALSFunctionDefinitionAccess().getValueAssignment_9()); | ||
9462 | } | ||
9463 | // InternalAlloyLanguage.g:3019:1: ( rule__ALSFunctionDefinition__ValueAssignment_9 ) | ||
9464 | // InternalAlloyLanguage.g:3019:2: rule__ALSFunctionDefinition__ValueAssignment_9 | ||
9465 | { | ||
9466 | pushFollow(FOLLOW_2); | ||
9467 | rule__ALSFunctionDefinition__ValueAssignment_9(); | ||
9468 | |||
9469 | state._fsp--; | ||
9470 | if (state.failed) return ; | ||
9471 | |||
9472 | } | ||
9473 | |||
9474 | if ( state.backtracking==0 ) { | ||
9475 | after(grammarAccess.getALSFunctionDefinitionAccess().getValueAssignment_9()); | ||
9476 | } | ||
9477 | |||
9478 | } | ||
9479 | |||
9480 | |||
9481 | } | ||
9482 | |||
9483 | } | ||
9484 | catch (RecognitionException re) { | ||
9485 | reportError(re); | ||
9486 | recover(input,re); | ||
9487 | } | ||
9488 | finally { | ||
9489 | |||
9490 | restoreStackSize(stackSize); | ||
9491 | |||
9492 | } | ||
9493 | return ; | ||
9494 | } | ||
9495 | // $ANTLR end "rule__ALSFunctionDefinition__Group__9__Impl" | ||
9496 | |||
9497 | |||
9498 | // $ANTLR start "rule__ALSFunctionDefinition__Group__10" | ||
9499 | // InternalAlloyLanguage.g:3029:1: rule__ALSFunctionDefinition__Group__10 : rule__ALSFunctionDefinition__Group__10__Impl ; | ||
9500 | public final void rule__ALSFunctionDefinition__Group__10() throws RecognitionException { | ||
9501 | |||
9502 | int stackSize = keepStackSize(); | ||
9503 | |||
9504 | try { | ||
9505 | // InternalAlloyLanguage.g:3033:1: ( rule__ALSFunctionDefinition__Group__10__Impl ) | ||
9506 | // InternalAlloyLanguage.g:3034:2: rule__ALSFunctionDefinition__Group__10__Impl | ||
9507 | { | ||
9508 | pushFollow(FOLLOW_2); | ||
9509 | rule__ALSFunctionDefinition__Group__10__Impl(); | ||
9510 | |||
9511 | state._fsp--; | ||
9512 | if (state.failed) return ; | ||
9513 | |||
9514 | } | ||
9515 | |||
9516 | } | ||
9517 | catch (RecognitionException re) { | ||
9518 | reportError(re); | ||
9519 | recover(input,re); | ||
9520 | } | ||
9521 | finally { | ||
9522 | |||
9523 | restoreStackSize(stackSize); | ||
9524 | |||
9525 | } | ||
9526 | return ; | ||
9527 | } | ||
9528 | // $ANTLR end "rule__ALSFunctionDefinition__Group__10" | ||
9529 | |||
9530 | |||
9531 | // $ANTLR start "rule__ALSFunctionDefinition__Group__10__Impl" | ||
9532 | // InternalAlloyLanguage.g:3040:1: rule__ALSFunctionDefinition__Group__10__Impl : ( '}' ) ; | ||
9533 | public final void rule__ALSFunctionDefinition__Group__10__Impl() throws RecognitionException { | ||
9534 | |||
9535 | int stackSize = keepStackSize(); | ||
9536 | |||
9537 | try { | ||
9538 | // InternalAlloyLanguage.g:3044:1: ( ( '}' ) ) | ||
9539 | // InternalAlloyLanguage.g:3045:1: ( '}' ) | ||
9540 | { | ||
9541 | // InternalAlloyLanguage.g:3045:1: ( '}' ) | ||
9542 | // InternalAlloyLanguage.g:3046:1: '}' | ||
9543 | { | ||
9544 | if ( state.backtracking==0 ) { | ||
9545 | before(grammarAccess.getALSFunctionDefinitionAccess().getRightCurlyBracketKeyword_10()); | ||
9546 | } | ||
9547 | match(input,34,FOLLOW_2); if (state.failed) return ; | ||
9548 | if ( state.backtracking==0 ) { | ||
9549 | after(grammarAccess.getALSFunctionDefinitionAccess().getRightCurlyBracketKeyword_10()); | ||
9550 | } | ||
9551 | |||
9552 | } | ||
9553 | |||
9554 | |||
9555 | } | ||
9556 | |||
9557 | } | ||
9558 | catch (RecognitionException re) { | ||
9559 | reportError(re); | ||
9560 | recover(input,re); | ||
9561 | } | ||
9562 | finally { | ||
9563 | |||
9564 | restoreStackSize(stackSize); | ||
9565 | |||
9566 | } | ||
9567 | return ; | ||
9568 | } | ||
9569 | // $ANTLR end "rule__ALSFunctionDefinition__Group__10__Impl" | ||
9570 | |||
9571 | |||
9572 | // $ANTLR start "rule__ALSFunctionDefinition__Group_4__0" | ||
9573 | // InternalAlloyLanguage.g:3081:1: rule__ALSFunctionDefinition__Group_4__0 : rule__ALSFunctionDefinition__Group_4__0__Impl rule__ALSFunctionDefinition__Group_4__1 ; | ||
9574 | public final void rule__ALSFunctionDefinition__Group_4__0() throws RecognitionException { | ||
9575 | |||
9576 | int stackSize = keepStackSize(); | ||
9577 | |||
9578 | try { | ||
9579 | // InternalAlloyLanguage.g:3085:1: ( rule__ALSFunctionDefinition__Group_4__0__Impl rule__ALSFunctionDefinition__Group_4__1 ) | ||
9580 | // InternalAlloyLanguage.g:3086:2: rule__ALSFunctionDefinition__Group_4__0__Impl rule__ALSFunctionDefinition__Group_4__1 | ||
9581 | { | ||
9582 | pushFollow(FOLLOW_5); | ||
9583 | rule__ALSFunctionDefinition__Group_4__0__Impl(); | ||
9584 | |||
9585 | state._fsp--; | ||
9586 | if (state.failed) return ; | ||
9587 | pushFollow(FOLLOW_2); | ||
9588 | rule__ALSFunctionDefinition__Group_4__1(); | ||
9589 | |||
9590 | state._fsp--; | ||
9591 | if (state.failed) return ; | ||
9592 | |||
9593 | } | ||
9594 | |||
9595 | } | ||
9596 | catch (RecognitionException re) { | ||
9597 | reportError(re); | ||
9598 | recover(input,re); | ||
9599 | } | ||
9600 | finally { | ||
9601 | |||
9602 | restoreStackSize(stackSize); | ||
9603 | |||
9604 | } | ||
9605 | return ; | ||
9606 | } | ||
9607 | // $ANTLR end "rule__ALSFunctionDefinition__Group_4__0" | ||
9608 | |||
9609 | |||
9610 | // $ANTLR start "rule__ALSFunctionDefinition__Group_4__0__Impl" | ||
9611 | // InternalAlloyLanguage.g:3093:1: rule__ALSFunctionDefinition__Group_4__0__Impl : ( ',' ) ; | ||
9612 | public final void rule__ALSFunctionDefinition__Group_4__0__Impl() throws RecognitionException { | ||
9613 | |||
9614 | int stackSize = keepStackSize(); | ||
9615 | |||
9616 | try { | ||
9617 | // InternalAlloyLanguage.g:3097:1: ( ( ',' ) ) | ||
9618 | // InternalAlloyLanguage.g:3098:1: ( ',' ) | ||
9619 | { | ||
9620 | // InternalAlloyLanguage.g:3098:1: ( ',' ) | ||
9621 | // InternalAlloyLanguage.g:3099:1: ',' | ||
9622 | { | ||
9623 | if ( state.backtracking==0 ) { | ||
9624 | before(grammarAccess.getALSFunctionDefinitionAccess().getCommaKeyword_4_0()); | ||
9625 | } | ||
9626 | match(input,35,FOLLOW_2); if (state.failed) return ; | ||
9627 | if ( state.backtracking==0 ) { | ||
9628 | after(grammarAccess.getALSFunctionDefinitionAccess().getCommaKeyword_4_0()); | ||
9629 | } | ||
9630 | |||
9631 | } | ||
9632 | |||
9633 | |||
9634 | } | ||
9635 | |||
9636 | } | ||
9637 | catch (RecognitionException re) { | ||
9638 | reportError(re); | ||
9639 | recover(input,re); | ||
9640 | } | ||
9641 | finally { | ||
9642 | |||
9643 | restoreStackSize(stackSize); | ||
9644 | |||
9645 | } | ||
9646 | return ; | ||
9647 | } | ||
9648 | // $ANTLR end "rule__ALSFunctionDefinition__Group_4__0__Impl" | ||
9649 | |||
9650 | |||
9651 | // $ANTLR start "rule__ALSFunctionDefinition__Group_4__1" | ||
9652 | // InternalAlloyLanguage.g:3112:1: rule__ALSFunctionDefinition__Group_4__1 : rule__ALSFunctionDefinition__Group_4__1__Impl ; | ||
9653 | public final void rule__ALSFunctionDefinition__Group_4__1() throws RecognitionException { | ||
9654 | |||
9655 | int stackSize = keepStackSize(); | ||
9656 | |||
9657 | try { | ||
9658 | // InternalAlloyLanguage.g:3116:1: ( rule__ALSFunctionDefinition__Group_4__1__Impl ) | ||
9659 | // InternalAlloyLanguage.g:3117:2: rule__ALSFunctionDefinition__Group_4__1__Impl | ||
9660 | { | ||
9661 | pushFollow(FOLLOW_2); | ||
9662 | rule__ALSFunctionDefinition__Group_4__1__Impl(); | ||
9663 | |||
9664 | state._fsp--; | ||
9665 | if (state.failed) return ; | ||
9666 | |||
9667 | } | ||
9668 | |||
9669 | } | ||
9670 | catch (RecognitionException re) { | ||
9671 | reportError(re); | ||
9672 | recover(input,re); | ||
9673 | } | ||
9674 | finally { | ||
9675 | |||
9676 | restoreStackSize(stackSize); | ||
9677 | |||
9678 | } | ||
9679 | return ; | ||
9680 | } | ||
9681 | // $ANTLR end "rule__ALSFunctionDefinition__Group_4__1" | ||
9682 | |||
9683 | |||
9684 | // $ANTLR start "rule__ALSFunctionDefinition__Group_4__1__Impl" | ||
9685 | // InternalAlloyLanguage.g:3123:1: rule__ALSFunctionDefinition__Group_4__1__Impl : ( ( rule__ALSFunctionDefinition__VariablesAssignment_4_1 ) ) ; | ||
9686 | public final void rule__ALSFunctionDefinition__Group_4__1__Impl() throws RecognitionException { | ||
9687 | |||
9688 | int stackSize = keepStackSize(); | ||
9689 | |||
9690 | try { | ||
9691 | // InternalAlloyLanguage.g:3127:1: ( ( ( rule__ALSFunctionDefinition__VariablesAssignment_4_1 ) ) ) | ||
9692 | // InternalAlloyLanguage.g:3128:1: ( ( rule__ALSFunctionDefinition__VariablesAssignment_4_1 ) ) | ||
9693 | { | ||
9694 | // InternalAlloyLanguage.g:3128:1: ( ( rule__ALSFunctionDefinition__VariablesAssignment_4_1 ) ) | ||
9695 | // InternalAlloyLanguage.g:3129:1: ( rule__ALSFunctionDefinition__VariablesAssignment_4_1 ) | ||
9696 | { | ||
9697 | if ( state.backtracking==0 ) { | ||
9698 | before(grammarAccess.getALSFunctionDefinitionAccess().getVariablesAssignment_4_1()); | ||
9699 | } | ||
9700 | // InternalAlloyLanguage.g:3130:1: ( rule__ALSFunctionDefinition__VariablesAssignment_4_1 ) | ||
9701 | // InternalAlloyLanguage.g:3130:2: rule__ALSFunctionDefinition__VariablesAssignment_4_1 | ||
9702 | { | ||
9703 | pushFollow(FOLLOW_2); | ||
9704 | rule__ALSFunctionDefinition__VariablesAssignment_4_1(); | ||
9705 | |||
9706 | state._fsp--; | ||
9707 | if (state.failed) return ; | ||
9708 | |||
9709 | } | ||
9710 | |||
9711 | if ( state.backtracking==0 ) { | ||
9712 | after(grammarAccess.getALSFunctionDefinitionAccess().getVariablesAssignment_4_1()); | ||
9713 | } | ||
9714 | |||
9715 | } | ||
9716 | |||
9717 | |||
9718 | } | ||
9719 | |||
9720 | } | ||
9721 | catch (RecognitionException re) { | ||
9722 | reportError(re); | ||
9723 | recover(input,re); | ||
9724 | } | ||
9725 | finally { | ||
9726 | |||
9727 | restoreStackSize(stackSize); | ||
9728 | |||
9729 | } | ||
9730 | return ; | ||
9731 | } | ||
9732 | // $ANTLR end "rule__ALSFunctionDefinition__Group_4__1__Impl" | ||
9733 | |||
9734 | |||
9735 | // $ANTLR start "rule__ALSRelationDefinition__Group__0" | ||
9736 | // InternalAlloyLanguage.g:3144:1: rule__ALSRelationDefinition__Group__0 : rule__ALSRelationDefinition__Group__0__Impl rule__ALSRelationDefinition__Group__1 ; | ||
9737 | public final void rule__ALSRelationDefinition__Group__0() throws RecognitionException { | ||
9738 | |||
9739 | int stackSize = keepStackSize(); | ||
9740 | |||
9741 | try { | ||
9742 | // InternalAlloyLanguage.g:3148:1: ( rule__ALSRelationDefinition__Group__0__Impl rule__ALSRelationDefinition__Group__1 ) | ||
9743 | // InternalAlloyLanguage.g:3149:2: rule__ALSRelationDefinition__Group__0__Impl rule__ALSRelationDefinition__Group__1 | ||
9744 | { | ||
9745 | pushFollow(FOLLOW_5); | ||
9746 | rule__ALSRelationDefinition__Group__0__Impl(); | ||
9747 | |||
9748 | state._fsp--; | ||
9749 | if (state.failed) return ; | ||
9750 | pushFollow(FOLLOW_2); | ||
9751 | rule__ALSRelationDefinition__Group__1(); | ||
9752 | |||
9753 | state._fsp--; | ||
9754 | if (state.failed) return ; | ||
9755 | |||
9756 | } | ||
9757 | |||
9758 | } | ||
9759 | catch (RecognitionException re) { | ||
9760 | reportError(re); | ||
9761 | recover(input,re); | ||
9762 | } | ||
9763 | finally { | ||
9764 | |||
9765 | restoreStackSize(stackSize); | ||
9766 | |||
9767 | } | ||
9768 | return ; | ||
9769 | } | ||
9770 | // $ANTLR end "rule__ALSRelationDefinition__Group__0" | ||
9771 | |||
9772 | |||
9773 | // $ANTLR start "rule__ALSRelationDefinition__Group__0__Impl" | ||
9774 | // InternalAlloyLanguage.g:3156:1: rule__ALSRelationDefinition__Group__0__Impl : ( 'pred' ) ; | ||
9775 | public final void rule__ALSRelationDefinition__Group__0__Impl() throws RecognitionException { | ||
9776 | |||
9777 | int stackSize = keepStackSize(); | ||
9778 | |||
9779 | try { | ||
9780 | // InternalAlloyLanguage.g:3160:1: ( ( 'pred' ) ) | ||
9781 | // InternalAlloyLanguage.g:3161:1: ( 'pred' ) | ||
9782 | { | ||
9783 | // InternalAlloyLanguage.g:3161:1: ( 'pred' ) | ||
9784 | // InternalAlloyLanguage.g:3162:1: 'pred' | ||
9785 | { | ||
9786 | if ( state.backtracking==0 ) { | ||
9787 | before(grammarAccess.getALSRelationDefinitionAccess().getPredKeyword_0()); | ||
9788 | } | ||
9789 | match(input,44,FOLLOW_2); if (state.failed) return ; | ||
9790 | if ( state.backtracking==0 ) { | ||
9791 | after(grammarAccess.getALSRelationDefinitionAccess().getPredKeyword_0()); | ||
9792 | } | ||
9793 | |||
9794 | } | ||
9795 | |||
9796 | |||
9797 | } | ||
9798 | |||
9799 | } | ||
9800 | catch (RecognitionException re) { | ||
9801 | reportError(re); | ||
9802 | recover(input,re); | ||
9803 | } | ||
9804 | finally { | ||
9805 | |||
9806 | restoreStackSize(stackSize); | ||
9807 | |||
9808 | } | ||
9809 | return ; | ||
9810 | } | ||
9811 | // $ANTLR end "rule__ALSRelationDefinition__Group__0__Impl" | ||
9812 | |||
9813 | |||
9814 | // $ANTLR start "rule__ALSRelationDefinition__Group__1" | ||
9815 | // InternalAlloyLanguage.g:3175:1: rule__ALSRelationDefinition__Group__1 : rule__ALSRelationDefinition__Group__1__Impl rule__ALSRelationDefinition__Group__2 ; | ||
9816 | public final void rule__ALSRelationDefinition__Group__1() throws RecognitionException { | ||
9817 | |||
9818 | int stackSize = keepStackSize(); | ||
9819 | |||
9820 | try { | ||
9821 | // InternalAlloyLanguage.g:3179:1: ( rule__ALSRelationDefinition__Group__1__Impl rule__ALSRelationDefinition__Group__2 ) | ||
9822 | // InternalAlloyLanguage.g:3180:2: rule__ALSRelationDefinition__Group__1__Impl rule__ALSRelationDefinition__Group__2 | ||
9823 | { | ||
9824 | pushFollow(FOLLOW_17); | ||
9825 | rule__ALSRelationDefinition__Group__1__Impl(); | ||
9826 | |||
9827 | state._fsp--; | ||
9828 | if (state.failed) return ; | ||
9829 | pushFollow(FOLLOW_2); | ||
9830 | rule__ALSRelationDefinition__Group__2(); | ||
9831 | |||
9832 | state._fsp--; | ||
9833 | if (state.failed) return ; | ||
9834 | |||
9835 | } | ||
9836 | |||
9837 | } | ||
9838 | catch (RecognitionException re) { | ||
9839 | reportError(re); | ||
9840 | recover(input,re); | ||
9841 | } | ||
9842 | finally { | ||
9843 | |||
9844 | restoreStackSize(stackSize); | ||
9845 | |||
9846 | } | ||
9847 | return ; | ||
9848 | } | ||
9849 | // $ANTLR end "rule__ALSRelationDefinition__Group__1" | ||
9850 | |||
9851 | |||
9852 | // $ANTLR start "rule__ALSRelationDefinition__Group__1__Impl" | ||
9853 | // InternalAlloyLanguage.g:3187:1: rule__ALSRelationDefinition__Group__1__Impl : ( ( rule__ALSRelationDefinition__NameAssignment_1 ) ) ; | ||
9854 | public final void rule__ALSRelationDefinition__Group__1__Impl() throws RecognitionException { | ||
9855 | |||
9856 | int stackSize = keepStackSize(); | ||
9857 | |||
9858 | try { | ||
9859 | // InternalAlloyLanguage.g:3191:1: ( ( ( rule__ALSRelationDefinition__NameAssignment_1 ) ) ) | ||
9860 | // InternalAlloyLanguage.g:3192:1: ( ( rule__ALSRelationDefinition__NameAssignment_1 ) ) | ||
9861 | { | ||
9862 | // InternalAlloyLanguage.g:3192:1: ( ( rule__ALSRelationDefinition__NameAssignment_1 ) ) | ||
9863 | // InternalAlloyLanguage.g:3193:1: ( rule__ALSRelationDefinition__NameAssignment_1 ) | ||
9864 | { | ||
9865 | if ( state.backtracking==0 ) { | ||
9866 | before(grammarAccess.getALSRelationDefinitionAccess().getNameAssignment_1()); | ||
9867 | } | ||
9868 | // InternalAlloyLanguage.g:3194:1: ( rule__ALSRelationDefinition__NameAssignment_1 ) | ||
9869 | // InternalAlloyLanguage.g:3194:2: rule__ALSRelationDefinition__NameAssignment_1 | ||
9870 | { | ||
9871 | pushFollow(FOLLOW_2); | ||
9872 | rule__ALSRelationDefinition__NameAssignment_1(); | ||
9873 | |||
9874 | state._fsp--; | ||
9875 | if (state.failed) return ; | ||
9876 | |||
9877 | } | ||
9878 | |||
9879 | if ( state.backtracking==0 ) { | ||
9880 | after(grammarAccess.getALSRelationDefinitionAccess().getNameAssignment_1()); | ||
9881 | } | ||
9882 | |||
9883 | } | ||
9884 | |||
9885 | |||
9886 | } | ||
9887 | |||
9888 | } | ||
9889 | catch (RecognitionException re) { | ||
9890 | reportError(re); | ||
9891 | recover(input,re); | ||
9892 | } | ||
9893 | finally { | ||
9894 | |||
9895 | restoreStackSize(stackSize); | ||
9896 | |||
9897 | } | ||
9898 | return ; | ||
9899 | } | ||
9900 | // $ANTLR end "rule__ALSRelationDefinition__Group__1__Impl" | ||
9901 | |||
9902 | |||
9903 | // $ANTLR start "rule__ALSRelationDefinition__Group__2" | ||
9904 | // InternalAlloyLanguage.g:3204:1: rule__ALSRelationDefinition__Group__2 : rule__ALSRelationDefinition__Group__2__Impl rule__ALSRelationDefinition__Group__3 ; | ||
9905 | public final void rule__ALSRelationDefinition__Group__2() throws RecognitionException { | ||
9906 | |||
9907 | int stackSize = keepStackSize(); | ||
9908 | |||
9909 | try { | ||
9910 | // InternalAlloyLanguage.g:3208:1: ( rule__ALSRelationDefinition__Group__2__Impl rule__ALSRelationDefinition__Group__3 ) | ||
9911 | // InternalAlloyLanguage.g:3209:2: rule__ALSRelationDefinition__Group__2__Impl rule__ALSRelationDefinition__Group__3 | ||
9912 | { | ||
9913 | pushFollow(FOLLOW_5); | ||
9914 | rule__ALSRelationDefinition__Group__2__Impl(); | ||
9915 | |||
9916 | state._fsp--; | ||
9917 | if (state.failed) return ; | ||
9918 | pushFollow(FOLLOW_2); | ||
9919 | rule__ALSRelationDefinition__Group__3(); | ||
9920 | |||
9921 | state._fsp--; | ||
9922 | if (state.failed) return ; | ||
9923 | |||
9924 | } | ||
9925 | |||
9926 | } | ||
9927 | catch (RecognitionException re) { | ||
9928 | reportError(re); | ||
9929 | recover(input,re); | ||
9930 | } | ||
9931 | finally { | ||
9932 | |||
9933 | restoreStackSize(stackSize); | ||
9934 | |||
9935 | } | ||
9936 | return ; | ||
9937 | } | ||
9938 | // $ANTLR end "rule__ALSRelationDefinition__Group__2" | ||
9939 | |||
9940 | |||
9941 | // $ANTLR start "rule__ALSRelationDefinition__Group__2__Impl" | ||
9942 | // InternalAlloyLanguage.g:3216:1: rule__ALSRelationDefinition__Group__2__Impl : ( '[' ) ; | ||
9943 | public final void rule__ALSRelationDefinition__Group__2__Impl() throws RecognitionException { | ||
9944 | |||
9945 | int stackSize = keepStackSize(); | ||
9946 | |||
9947 | try { | ||
9948 | // InternalAlloyLanguage.g:3220:1: ( ( '[' ) ) | ||
9949 | // InternalAlloyLanguage.g:3221:1: ( '[' ) | ||
9950 | { | ||
9951 | // InternalAlloyLanguage.g:3221:1: ( '[' ) | ||
9952 | // InternalAlloyLanguage.g:3222:1: '[' | ||
9953 | { | ||
9954 | if ( state.backtracking==0 ) { | ||
9955 | before(grammarAccess.getALSRelationDefinitionAccess().getLeftSquareBracketKeyword_2()); | ||
9956 | } | ||
9957 | match(input,42,FOLLOW_2); if (state.failed) return ; | ||
9958 | if ( state.backtracking==0 ) { | ||
9959 | after(grammarAccess.getALSRelationDefinitionAccess().getLeftSquareBracketKeyword_2()); | ||
9960 | } | ||
9961 | |||
9962 | } | ||
9963 | |||
9964 | |||
9965 | } | ||
9966 | |||
9967 | } | ||
9968 | catch (RecognitionException re) { | ||
9969 | reportError(re); | ||
9970 | recover(input,re); | ||
9971 | } | ||
9972 | finally { | ||
9973 | |||
9974 | restoreStackSize(stackSize); | ||
9975 | |||
9976 | } | ||
9977 | return ; | ||
9978 | } | ||
9979 | // $ANTLR end "rule__ALSRelationDefinition__Group__2__Impl" | ||
9980 | |||
9981 | |||
9982 | // $ANTLR start "rule__ALSRelationDefinition__Group__3" | ||
9983 | // InternalAlloyLanguage.g:3235:1: rule__ALSRelationDefinition__Group__3 : rule__ALSRelationDefinition__Group__3__Impl rule__ALSRelationDefinition__Group__4 ; | ||
9984 | public final void rule__ALSRelationDefinition__Group__3() throws RecognitionException { | ||
9985 | |||
9986 | int stackSize = keepStackSize(); | ||
9987 | |||
9988 | try { | ||
9989 | // InternalAlloyLanguage.g:3239:1: ( rule__ALSRelationDefinition__Group__3__Impl rule__ALSRelationDefinition__Group__4 ) | ||
9990 | // InternalAlloyLanguage.g:3240:2: rule__ALSRelationDefinition__Group__3__Impl rule__ALSRelationDefinition__Group__4 | ||
9991 | { | ||
9992 | pushFollow(FOLLOW_18); | ||
9993 | rule__ALSRelationDefinition__Group__3__Impl(); | ||
9994 | |||
9995 | state._fsp--; | ||
9996 | if (state.failed) return ; | ||
9997 | pushFollow(FOLLOW_2); | ||
9998 | rule__ALSRelationDefinition__Group__4(); | ||
9999 | |||
10000 | state._fsp--; | ||
10001 | if (state.failed) return ; | ||
10002 | |||
10003 | } | ||
10004 | |||
10005 | } | ||
10006 | catch (RecognitionException re) { | ||
10007 | reportError(re); | ||
10008 | recover(input,re); | ||
10009 | } | ||
10010 | finally { | ||
10011 | |||
10012 | restoreStackSize(stackSize); | ||
10013 | |||
10014 | } | ||
10015 | return ; | ||
10016 | } | ||
10017 | // $ANTLR end "rule__ALSRelationDefinition__Group__3" | ||
10018 | |||
10019 | |||
10020 | // $ANTLR start "rule__ALSRelationDefinition__Group__3__Impl" | ||
10021 | // InternalAlloyLanguage.g:3247:1: rule__ALSRelationDefinition__Group__3__Impl : ( ( rule__ALSRelationDefinition__VariablesAssignment_3 ) ) ; | ||
10022 | public final void rule__ALSRelationDefinition__Group__3__Impl() throws RecognitionException { | ||
10023 | |||
10024 | int stackSize = keepStackSize(); | ||
10025 | |||
10026 | try { | ||
10027 | // InternalAlloyLanguage.g:3251:1: ( ( ( rule__ALSRelationDefinition__VariablesAssignment_3 ) ) ) | ||
10028 | // InternalAlloyLanguage.g:3252:1: ( ( rule__ALSRelationDefinition__VariablesAssignment_3 ) ) | ||
10029 | { | ||
10030 | // InternalAlloyLanguage.g:3252:1: ( ( rule__ALSRelationDefinition__VariablesAssignment_3 ) ) | ||
10031 | // InternalAlloyLanguage.g:3253:1: ( rule__ALSRelationDefinition__VariablesAssignment_3 ) | ||
10032 | { | ||
10033 | if ( state.backtracking==0 ) { | ||
10034 | before(grammarAccess.getALSRelationDefinitionAccess().getVariablesAssignment_3()); | ||
10035 | } | ||
10036 | // InternalAlloyLanguage.g:3254:1: ( rule__ALSRelationDefinition__VariablesAssignment_3 ) | ||
10037 | // InternalAlloyLanguage.g:3254:2: rule__ALSRelationDefinition__VariablesAssignment_3 | ||
10038 | { | ||
10039 | pushFollow(FOLLOW_2); | ||
10040 | rule__ALSRelationDefinition__VariablesAssignment_3(); | ||
10041 | |||
10042 | state._fsp--; | ||
10043 | if (state.failed) return ; | ||
10044 | |||
10045 | } | ||
10046 | |||
10047 | if ( state.backtracking==0 ) { | ||
10048 | after(grammarAccess.getALSRelationDefinitionAccess().getVariablesAssignment_3()); | ||
10049 | } | ||
10050 | |||
10051 | } | ||
10052 | |||
10053 | |||
10054 | } | ||
10055 | |||
10056 | } | ||
10057 | catch (RecognitionException re) { | ||
10058 | reportError(re); | ||
10059 | recover(input,re); | ||
10060 | } | ||
10061 | finally { | ||
10062 | |||
10063 | restoreStackSize(stackSize); | ||
10064 | |||
10065 | } | ||
10066 | return ; | ||
10067 | } | ||
10068 | // $ANTLR end "rule__ALSRelationDefinition__Group__3__Impl" | ||
10069 | |||
10070 | |||
10071 | // $ANTLR start "rule__ALSRelationDefinition__Group__4" | ||
10072 | // InternalAlloyLanguage.g:3264:1: rule__ALSRelationDefinition__Group__4 : rule__ALSRelationDefinition__Group__4__Impl rule__ALSRelationDefinition__Group__5 ; | ||
10073 | public final void rule__ALSRelationDefinition__Group__4() throws RecognitionException { | ||
10074 | |||
10075 | int stackSize = keepStackSize(); | ||
10076 | |||
10077 | try { | ||
10078 | // InternalAlloyLanguage.g:3268:1: ( rule__ALSRelationDefinition__Group__4__Impl rule__ALSRelationDefinition__Group__5 ) | ||
10079 | // InternalAlloyLanguage.g:3269:2: rule__ALSRelationDefinition__Group__4__Impl rule__ALSRelationDefinition__Group__5 | ||
10080 | { | ||
10081 | pushFollow(FOLLOW_18); | ||
10082 | rule__ALSRelationDefinition__Group__4__Impl(); | ||
10083 | |||
10084 | state._fsp--; | ||
10085 | if (state.failed) return ; | ||
10086 | pushFollow(FOLLOW_2); | ||
10087 | rule__ALSRelationDefinition__Group__5(); | ||
10088 | |||
10089 | state._fsp--; | ||
10090 | if (state.failed) return ; | ||
10091 | |||
10092 | } | ||
10093 | |||
10094 | } | ||
10095 | catch (RecognitionException re) { | ||
10096 | reportError(re); | ||
10097 | recover(input,re); | ||
10098 | } | ||
10099 | finally { | ||
10100 | |||
10101 | restoreStackSize(stackSize); | ||
10102 | |||
10103 | } | ||
10104 | return ; | ||
10105 | } | ||
10106 | // $ANTLR end "rule__ALSRelationDefinition__Group__4" | ||
10107 | |||
10108 | |||
10109 | // $ANTLR start "rule__ALSRelationDefinition__Group__4__Impl" | ||
10110 | // InternalAlloyLanguage.g:3276:1: rule__ALSRelationDefinition__Group__4__Impl : ( ( rule__ALSRelationDefinition__Group_4__0 )* ) ; | ||
10111 | public final void rule__ALSRelationDefinition__Group__4__Impl() throws RecognitionException { | ||
10112 | |||
10113 | int stackSize = keepStackSize(); | ||
10114 | |||
10115 | try { | ||
10116 | // InternalAlloyLanguage.g:3280:1: ( ( ( rule__ALSRelationDefinition__Group_4__0 )* ) ) | ||
10117 | // InternalAlloyLanguage.g:3281:1: ( ( rule__ALSRelationDefinition__Group_4__0 )* ) | ||
10118 | { | ||
10119 | // InternalAlloyLanguage.g:3281:1: ( ( rule__ALSRelationDefinition__Group_4__0 )* ) | ||
10120 | // InternalAlloyLanguage.g:3282:1: ( rule__ALSRelationDefinition__Group_4__0 )* | ||
10121 | { | ||
10122 | if ( state.backtracking==0 ) { | ||
10123 | before(grammarAccess.getALSRelationDefinitionAccess().getGroup_4()); | ||
10124 | } | ||
10125 | // InternalAlloyLanguage.g:3283:1: ( rule__ALSRelationDefinition__Group_4__0 )* | ||
10126 | loop26: | ||
10127 | do { | ||
10128 | int alt26=2; | ||
10129 | int LA26_0 = input.LA(1); | ||
10130 | |||
10131 | if ( (LA26_0==35) ) { | ||
10132 | alt26=1; | ||
10133 | } | ||
10134 | |||
10135 | |||
10136 | switch (alt26) { | ||
10137 | case 1 : | ||
10138 | // InternalAlloyLanguage.g:3283:2: rule__ALSRelationDefinition__Group_4__0 | ||
10139 | { | ||
10140 | pushFollow(FOLLOW_8); | ||
10141 | rule__ALSRelationDefinition__Group_4__0(); | ||
10142 | |||
10143 | state._fsp--; | ||
10144 | if (state.failed) return ; | ||
10145 | |||
10146 | } | ||
10147 | break; | ||
10148 | |||
10149 | default : | ||
10150 | break loop26; | ||
10151 | } | ||
10152 | } while (true); | ||
10153 | |||
10154 | if ( state.backtracking==0 ) { | ||
10155 | after(grammarAccess.getALSRelationDefinitionAccess().getGroup_4()); | ||
10156 | } | ||
10157 | |||
10158 | } | ||
10159 | |||
10160 | |||
10161 | } | ||
10162 | |||
10163 | } | ||
10164 | catch (RecognitionException re) { | ||
10165 | reportError(re); | ||
10166 | recover(input,re); | ||
10167 | } | ||
10168 | finally { | ||
10169 | |||
10170 | restoreStackSize(stackSize); | ||
10171 | |||
10172 | } | ||
10173 | return ; | ||
10174 | } | ||
10175 | // $ANTLR end "rule__ALSRelationDefinition__Group__4__Impl" | ||
10176 | |||
10177 | |||
10178 | // $ANTLR start "rule__ALSRelationDefinition__Group__5" | ||
10179 | // InternalAlloyLanguage.g:3293:1: rule__ALSRelationDefinition__Group__5 : rule__ALSRelationDefinition__Group__5__Impl rule__ALSRelationDefinition__Group__6 ; | ||
10180 | public final void rule__ALSRelationDefinition__Group__5() throws RecognitionException { | ||
10181 | |||
10182 | int stackSize = keepStackSize(); | ||
10183 | |||
10184 | try { | ||
10185 | // InternalAlloyLanguage.g:3297:1: ( rule__ALSRelationDefinition__Group__5__Impl rule__ALSRelationDefinition__Group__6 ) | ||
10186 | // InternalAlloyLanguage.g:3298:2: rule__ALSRelationDefinition__Group__5__Impl rule__ALSRelationDefinition__Group__6 | ||
10187 | { | ||
10188 | pushFollow(FOLLOW_6); | ||
10189 | rule__ALSRelationDefinition__Group__5__Impl(); | ||
10190 | |||
10191 | state._fsp--; | ||
10192 | if (state.failed) return ; | ||
10193 | pushFollow(FOLLOW_2); | ||
10194 | rule__ALSRelationDefinition__Group__6(); | ||
10195 | |||
10196 | state._fsp--; | ||
10197 | if (state.failed) return ; | ||
10198 | |||
10199 | } | ||
10200 | |||
10201 | } | ||
10202 | catch (RecognitionException re) { | ||
10203 | reportError(re); | ||
10204 | recover(input,re); | ||
10205 | } | ||
10206 | finally { | ||
10207 | |||
10208 | restoreStackSize(stackSize); | ||
10209 | |||
10210 | } | ||
10211 | return ; | ||
10212 | } | ||
10213 | // $ANTLR end "rule__ALSRelationDefinition__Group__5" | ||
10214 | |||
10215 | |||
10216 | // $ANTLR start "rule__ALSRelationDefinition__Group__5__Impl" | ||
10217 | // InternalAlloyLanguage.g:3305:1: rule__ALSRelationDefinition__Group__5__Impl : ( ']' ) ; | ||
10218 | public final void rule__ALSRelationDefinition__Group__5__Impl() throws RecognitionException { | ||
10219 | |||
10220 | int stackSize = keepStackSize(); | ||
10221 | |||
10222 | try { | ||
10223 | // InternalAlloyLanguage.g:3309:1: ( ( ']' ) ) | ||
10224 | // InternalAlloyLanguage.g:3310:1: ( ']' ) | ||
10225 | { | ||
10226 | // InternalAlloyLanguage.g:3310:1: ( ']' ) | ||
10227 | // InternalAlloyLanguage.g:3311:1: ']' | ||
10228 | { | ||
10229 | if ( state.backtracking==0 ) { | ||
10230 | before(grammarAccess.getALSRelationDefinitionAccess().getRightSquareBracketKeyword_5()); | ||
10231 | } | ||
10232 | match(input,43,FOLLOW_2); if (state.failed) return ; | ||
10233 | if ( state.backtracking==0 ) { | ||
10234 | after(grammarAccess.getALSRelationDefinitionAccess().getRightSquareBracketKeyword_5()); | ||
10235 | } | ||
10236 | |||
10237 | } | ||
10238 | |||
10239 | |||
10240 | } | ||
10241 | |||
10242 | } | ||
10243 | catch (RecognitionException re) { | ||
10244 | reportError(re); | ||
10245 | recover(input,re); | ||
10246 | } | ||
10247 | finally { | ||
10248 | |||
10249 | restoreStackSize(stackSize); | ||
10250 | |||
10251 | } | ||
10252 | return ; | ||
10253 | } | ||
10254 | // $ANTLR end "rule__ALSRelationDefinition__Group__5__Impl" | ||
10255 | |||
10256 | |||
10257 | // $ANTLR start "rule__ALSRelationDefinition__Group__6" | ||
10258 | // InternalAlloyLanguage.g:3324:1: rule__ALSRelationDefinition__Group__6 : rule__ALSRelationDefinition__Group__6__Impl rule__ALSRelationDefinition__Group__7 ; | ||
10259 | public final void rule__ALSRelationDefinition__Group__6() throws RecognitionException { | ||
10260 | |||
10261 | int stackSize = keepStackSize(); | ||
10262 | |||
10263 | try { | ||
10264 | // InternalAlloyLanguage.g:3328:1: ( rule__ALSRelationDefinition__Group__6__Impl rule__ALSRelationDefinition__Group__7 ) | ||
10265 | // InternalAlloyLanguage.g:3329:2: rule__ALSRelationDefinition__Group__6__Impl rule__ALSRelationDefinition__Group__7 | ||
10266 | { | ||
10267 | pushFollow(FOLLOW_16); | ||
10268 | rule__ALSRelationDefinition__Group__6__Impl(); | ||
10269 | |||
10270 | state._fsp--; | ||
10271 | if (state.failed) return ; | ||
10272 | pushFollow(FOLLOW_2); | ||
10273 | rule__ALSRelationDefinition__Group__7(); | ||
10274 | |||
10275 | state._fsp--; | ||
10276 | if (state.failed) return ; | ||
10277 | |||
10278 | } | ||
10279 | |||
10280 | } | ||
10281 | catch (RecognitionException re) { | ||
10282 | reportError(re); | ||
10283 | recover(input,re); | ||
10284 | } | ||
10285 | finally { | ||
10286 | |||
10287 | restoreStackSize(stackSize); | ||
10288 | |||
10289 | } | ||
10290 | return ; | ||
10291 | } | ||
10292 | // $ANTLR end "rule__ALSRelationDefinition__Group__6" | ||
10293 | |||
10294 | |||
10295 | // $ANTLR start "rule__ALSRelationDefinition__Group__6__Impl" | ||
10296 | // InternalAlloyLanguage.g:3336:1: rule__ALSRelationDefinition__Group__6__Impl : ( '{' ) ; | ||
10297 | public final void rule__ALSRelationDefinition__Group__6__Impl() throws RecognitionException { | ||
10298 | |||
10299 | int stackSize = keepStackSize(); | ||
10300 | |||
10301 | try { | ||
10302 | // InternalAlloyLanguage.g:3340:1: ( ( '{' ) ) | ||
10303 | // InternalAlloyLanguage.g:3341:1: ( '{' ) | ||
10304 | { | ||
10305 | // InternalAlloyLanguage.g:3341:1: ( '{' ) | ||
10306 | // InternalAlloyLanguage.g:3342:1: '{' | ||
10307 | { | ||
10308 | if ( state.backtracking==0 ) { | ||
10309 | before(grammarAccess.getALSRelationDefinitionAccess().getLeftCurlyBracketKeyword_6()); | ||
10310 | } | ||
10311 | match(input,33,FOLLOW_2); if (state.failed) return ; | ||
10312 | if ( state.backtracking==0 ) { | ||
10313 | after(grammarAccess.getALSRelationDefinitionAccess().getLeftCurlyBracketKeyword_6()); | ||
10314 | } | ||
10315 | |||
10316 | } | ||
10317 | |||
10318 | |||
10319 | } | ||
10320 | |||
10321 | } | ||
10322 | catch (RecognitionException re) { | ||
10323 | reportError(re); | ||
10324 | recover(input,re); | ||
10325 | } | ||
10326 | finally { | ||
10327 | |||
10328 | restoreStackSize(stackSize); | ||
10329 | |||
10330 | } | ||
10331 | return ; | ||
10332 | } | ||
10333 | // $ANTLR end "rule__ALSRelationDefinition__Group__6__Impl" | ||
10334 | |||
10335 | |||
10336 | // $ANTLR start "rule__ALSRelationDefinition__Group__7" | ||
10337 | // InternalAlloyLanguage.g:3355:1: rule__ALSRelationDefinition__Group__7 : rule__ALSRelationDefinition__Group__7__Impl rule__ALSRelationDefinition__Group__8 ; | ||
10338 | public final void rule__ALSRelationDefinition__Group__7() throws RecognitionException { | ||
10339 | |||
10340 | int stackSize = keepStackSize(); | ||
10341 | |||
10342 | try { | ||
10343 | // InternalAlloyLanguage.g:3359:1: ( rule__ALSRelationDefinition__Group__7__Impl rule__ALSRelationDefinition__Group__8 ) | ||
10344 | // InternalAlloyLanguage.g:3360:2: rule__ALSRelationDefinition__Group__7__Impl rule__ALSRelationDefinition__Group__8 | ||
10345 | { | ||
10346 | pushFollow(FOLLOW_19); | ||
10347 | rule__ALSRelationDefinition__Group__7__Impl(); | ||
10348 | |||
10349 | state._fsp--; | ||
10350 | if (state.failed) return ; | ||
10351 | pushFollow(FOLLOW_2); | ||
10352 | rule__ALSRelationDefinition__Group__8(); | ||
10353 | |||
10354 | state._fsp--; | ||
10355 | if (state.failed) return ; | ||
10356 | |||
10357 | } | ||
10358 | |||
10359 | } | ||
10360 | catch (RecognitionException re) { | ||
10361 | reportError(re); | ||
10362 | recover(input,re); | ||
10363 | } | ||
10364 | finally { | ||
10365 | |||
10366 | restoreStackSize(stackSize); | ||
10367 | |||
10368 | } | ||
10369 | return ; | ||
10370 | } | ||
10371 | // $ANTLR end "rule__ALSRelationDefinition__Group__7" | ||
10372 | |||
10373 | |||
10374 | // $ANTLR start "rule__ALSRelationDefinition__Group__7__Impl" | ||
10375 | // InternalAlloyLanguage.g:3367:1: rule__ALSRelationDefinition__Group__7__Impl : ( ( rule__ALSRelationDefinition__ValueAssignment_7 ) ) ; | ||
10376 | public final void rule__ALSRelationDefinition__Group__7__Impl() throws RecognitionException { | ||
10377 | |||
10378 | int stackSize = keepStackSize(); | ||
10379 | |||
10380 | try { | ||
10381 | // InternalAlloyLanguage.g:3371:1: ( ( ( rule__ALSRelationDefinition__ValueAssignment_7 ) ) ) | ||
10382 | // InternalAlloyLanguage.g:3372:1: ( ( rule__ALSRelationDefinition__ValueAssignment_7 ) ) | ||
10383 | { | ||
10384 | // InternalAlloyLanguage.g:3372:1: ( ( rule__ALSRelationDefinition__ValueAssignment_7 ) ) | ||
10385 | // InternalAlloyLanguage.g:3373:1: ( rule__ALSRelationDefinition__ValueAssignment_7 ) | ||
10386 | { | ||
10387 | if ( state.backtracking==0 ) { | ||
10388 | before(grammarAccess.getALSRelationDefinitionAccess().getValueAssignment_7()); | ||
10389 | } | ||
10390 | // InternalAlloyLanguage.g:3374:1: ( rule__ALSRelationDefinition__ValueAssignment_7 ) | ||
10391 | // InternalAlloyLanguage.g:3374:2: rule__ALSRelationDefinition__ValueAssignment_7 | ||
10392 | { | ||
10393 | pushFollow(FOLLOW_2); | ||
10394 | rule__ALSRelationDefinition__ValueAssignment_7(); | ||
10395 | |||
10396 | state._fsp--; | ||
10397 | if (state.failed) return ; | ||
10398 | |||
10399 | } | ||
10400 | |||
10401 | if ( state.backtracking==0 ) { | ||
10402 | after(grammarAccess.getALSRelationDefinitionAccess().getValueAssignment_7()); | ||
10403 | } | ||
10404 | |||
10405 | } | ||
10406 | |||
10407 | |||
10408 | } | ||
10409 | |||
10410 | } | ||
10411 | catch (RecognitionException re) { | ||
10412 | reportError(re); | ||
10413 | recover(input,re); | ||
10414 | } | ||
10415 | finally { | ||
10416 | |||
10417 | restoreStackSize(stackSize); | ||
10418 | |||
10419 | } | ||
10420 | return ; | ||
10421 | } | ||
10422 | // $ANTLR end "rule__ALSRelationDefinition__Group__7__Impl" | ||
10423 | |||
10424 | |||
10425 | // $ANTLR start "rule__ALSRelationDefinition__Group__8" | ||
10426 | // InternalAlloyLanguage.g:3384:1: rule__ALSRelationDefinition__Group__8 : rule__ALSRelationDefinition__Group__8__Impl ; | ||
10427 | public final void rule__ALSRelationDefinition__Group__8() throws RecognitionException { | ||
10428 | |||
10429 | int stackSize = keepStackSize(); | ||
10430 | |||
10431 | try { | ||
10432 | // InternalAlloyLanguage.g:3388:1: ( rule__ALSRelationDefinition__Group__8__Impl ) | ||
10433 | // InternalAlloyLanguage.g:3389:2: rule__ALSRelationDefinition__Group__8__Impl | ||
10434 | { | ||
10435 | pushFollow(FOLLOW_2); | ||
10436 | rule__ALSRelationDefinition__Group__8__Impl(); | ||
10437 | |||
10438 | state._fsp--; | ||
10439 | if (state.failed) return ; | ||
10440 | |||
10441 | } | ||
10442 | |||
10443 | } | ||
10444 | catch (RecognitionException re) { | ||
10445 | reportError(re); | ||
10446 | recover(input,re); | ||
10447 | } | ||
10448 | finally { | ||
10449 | |||
10450 | restoreStackSize(stackSize); | ||
10451 | |||
10452 | } | ||
10453 | return ; | ||
10454 | } | ||
10455 | // $ANTLR end "rule__ALSRelationDefinition__Group__8" | ||
10456 | |||
10457 | |||
10458 | // $ANTLR start "rule__ALSRelationDefinition__Group__8__Impl" | ||
10459 | // InternalAlloyLanguage.g:3395:1: rule__ALSRelationDefinition__Group__8__Impl : ( '}' ) ; | ||
10460 | public final void rule__ALSRelationDefinition__Group__8__Impl() throws RecognitionException { | ||
10461 | |||
10462 | int stackSize = keepStackSize(); | ||
10463 | |||
10464 | try { | ||
10465 | // InternalAlloyLanguage.g:3399:1: ( ( '}' ) ) | ||
10466 | // InternalAlloyLanguage.g:3400:1: ( '}' ) | ||
10467 | { | ||
10468 | // InternalAlloyLanguage.g:3400:1: ( '}' ) | ||
10469 | // InternalAlloyLanguage.g:3401:1: '}' | ||
10470 | { | ||
10471 | if ( state.backtracking==0 ) { | ||
10472 | before(grammarAccess.getALSRelationDefinitionAccess().getRightCurlyBracketKeyword_8()); | ||
10473 | } | ||
10474 | match(input,34,FOLLOW_2); if (state.failed) return ; | ||
10475 | if ( state.backtracking==0 ) { | ||
10476 | after(grammarAccess.getALSRelationDefinitionAccess().getRightCurlyBracketKeyword_8()); | ||
10477 | } | ||
10478 | |||
10479 | } | ||
10480 | |||
10481 | |||
10482 | } | ||
10483 | |||
10484 | } | ||
10485 | catch (RecognitionException re) { | ||
10486 | reportError(re); | ||
10487 | recover(input,re); | ||
10488 | } | ||
10489 | finally { | ||
10490 | |||
10491 | restoreStackSize(stackSize); | ||
10492 | |||
10493 | } | ||
10494 | return ; | ||
10495 | } | ||
10496 | // $ANTLR end "rule__ALSRelationDefinition__Group__8__Impl" | ||
10497 | |||
10498 | |||
10499 | // $ANTLR start "rule__ALSRelationDefinition__Group_4__0" | ||
10500 | // InternalAlloyLanguage.g:3432:1: rule__ALSRelationDefinition__Group_4__0 : rule__ALSRelationDefinition__Group_4__0__Impl rule__ALSRelationDefinition__Group_4__1 ; | ||
10501 | public final void rule__ALSRelationDefinition__Group_4__0() throws RecognitionException { | ||
10502 | |||
10503 | int stackSize = keepStackSize(); | ||
10504 | |||
10505 | try { | ||
10506 | // InternalAlloyLanguage.g:3436:1: ( rule__ALSRelationDefinition__Group_4__0__Impl rule__ALSRelationDefinition__Group_4__1 ) | ||
10507 | // InternalAlloyLanguage.g:3437:2: rule__ALSRelationDefinition__Group_4__0__Impl rule__ALSRelationDefinition__Group_4__1 | ||
10508 | { | ||
10509 | pushFollow(FOLLOW_5); | ||
10510 | rule__ALSRelationDefinition__Group_4__0__Impl(); | ||
10511 | |||
10512 | state._fsp--; | ||
10513 | if (state.failed) return ; | ||
10514 | pushFollow(FOLLOW_2); | ||
10515 | rule__ALSRelationDefinition__Group_4__1(); | ||
10516 | |||
10517 | state._fsp--; | ||
10518 | if (state.failed) return ; | ||
10519 | |||
10520 | } | ||
10521 | |||
10522 | } | ||
10523 | catch (RecognitionException re) { | ||
10524 | reportError(re); | ||
10525 | recover(input,re); | ||
10526 | } | ||
10527 | finally { | ||
10528 | |||
10529 | restoreStackSize(stackSize); | ||
10530 | |||
10531 | } | ||
10532 | return ; | ||
10533 | } | ||
10534 | // $ANTLR end "rule__ALSRelationDefinition__Group_4__0" | ||
10535 | |||
10536 | |||
10537 | // $ANTLR start "rule__ALSRelationDefinition__Group_4__0__Impl" | ||
10538 | // InternalAlloyLanguage.g:3444:1: rule__ALSRelationDefinition__Group_4__0__Impl : ( ',' ) ; | ||
10539 | public final void rule__ALSRelationDefinition__Group_4__0__Impl() throws RecognitionException { | ||
10540 | |||
10541 | int stackSize = keepStackSize(); | ||
10542 | |||
10543 | try { | ||
10544 | // InternalAlloyLanguage.g:3448:1: ( ( ',' ) ) | ||
10545 | // InternalAlloyLanguage.g:3449:1: ( ',' ) | ||
10546 | { | ||
10547 | // InternalAlloyLanguage.g:3449:1: ( ',' ) | ||
10548 | // InternalAlloyLanguage.g:3450:1: ',' | ||
10549 | { | ||
10550 | if ( state.backtracking==0 ) { | ||
10551 | before(grammarAccess.getALSRelationDefinitionAccess().getCommaKeyword_4_0()); | ||
10552 | } | ||
10553 | match(input,35,FOLLOW_2); if (state.failed) return ; | ||
10554 | if ( state.backtracking==0 ) { | ||
10555 | after(grammarAccess.getALSRelationDefinitionAccess().getCommaKeyword_4_0()); | ||
10556 | } | ||
10557 | |||
10558 | } | ||
10559 | |||
10560 | |||
10561 | } | ||
10562 | |||
10563 | } | ||
10564 | catch (RecognitionException re) { | ||
10565 | reportError(re); | ||
10566 | recover(input,re); | ||
10567 | } | ||
10568 | finally { | ||
10569 | |||
10570 | restoreStackSize(stackSize); | ||
10571 | |||
10572 | } | ||
10573 | return ; | ||
10574 | } | ||
10575 | // $ANTLR end "rule__ALSRelationDefinition__Group_4__0__Impl" | ||
10576 | |||
10577 | |||
10578 | // $ANTLR start "rule__ALSRelationDefinition__Group_4__1" | ||
10579 | // InternalAlloyLanguage.g:3463:1: rule__ALSRelationDefinition__Group_4__1 : rule__ALSRelationDefinition__Group_4__1__Impl ; | ||
10580 | public final void rule__ALSRelationDefinition__Group_4__1() throws RecognitionException { | ||
10581 | |||
10582 | int stackSize = keepStackSize(); | ||
10583 | |||
10584 | try { | ||
10585 | // InternalAlloyLanguage.g:3467:1: ( rule__ALSRelationDefinition__Group_4__1__Impl ) | ||
10586 | // InternalAlloyLanguage.g:3468:2: rule__ALSRelationDefinition__Group_4__1__Impl | ||
10587 | { | ||
10588 | pushFollow(FOLLOW_2); | ||
10589 | rule__ALSRelationDefinition__Group_4__1__Impl(); | ||
10590 | |||
10591 | state._fsp--; | ||
10592 | if (state.failed) return ; | ||
10593 | |||
10594 | } | ||
10595 | |||
10596 | } | ||
10597 | catch (RecognitionException re) { | ||
10598 | reportError(re); | ||
10599 | recover(input,re); | ||
10600 | } | ||
10601 | finally { | ||
10602 | |||
10603 | restoreStackSize(stackSize); | ||
10604 | |||
10605 | } | ||
10606 | return ; | ||
10607 | } | ||
10608 | // $ANTLR end "rule__ALSRelationDefinition__Group_4__1" | ||
10609 | |||
10610 | |||
10611 | // $ANTLR start "rule__ALSRelationDefinition__Group_4__1__Impl" | ||
10612 | // InternalAlloyLanguage.g:3474:1: rule__ALSRelationDefinition__Group_4__1__Impl : ( ( rule__ALSRelationDefinition__VariablesAssignment_4_1 ) ) ; | ||
10613 | public final void rule__ALSRelationDefinition__Group_4__1__Impl() throws RecognitionException { | ||
10614 | |||
10615 | int stackSize = keepStackSize(); | ||
10616 | |||
10617 | try { | ||
10618 | // InternalAlloyLanguage.g:3478:1: ( ( ( rule__ALSRelationDefinition__VariablesAssignment_4_1 ) ) ) | ||
10619 | // InternalAlloyLanguage.g:3479:1: ( ( rule__ALSRelationDefinition__VariablesAssignment_4_1 ) ) | ||
10620 | { | ||
10621 | // InternalAlloyLanguage.g:3479:1: ( ( rule__ALSRelationDefinition__VariablesAssignment_4_1 ) ) | ||
10622 | // InternalAlloyLanguage.g:3480:1: ( rule__ALSRelationDefinition__VariablesAssignment_4_1 ) | ||
10623 | { | ||
10624 | if ( state.backtracking==0 ) { | ||
10625 | before(grammarAccess.getALSRelationDefinitionAccess().getVariablesAssignment_4_1()); | ||
10626 | } | ||
10627 | // InternalAlloyLanguage.g:3481:1: ( rule__ALSRelationDefinition__VariablesAssignment_4_1 ) | ||
10628 | // InternalAlloyLanguage.g:3481:2: rule__ALSRelationDefinition__VariablesAssignment_4_1 | ||
10629 | { | ||
10630 | pushFollow(FOLLOW_2); | ||
10631 | rule__ALSRelationDefinition__VariablesAssignment_4_1(); | ||
10632 | |||
10633 | state._fsp--; | ||
10634 | if (state.failed) return ; | ||
10635 | |||
10636 | } | ||
10637 | |||
10638 | if ( state.backtracking==0 ) { | ||
10639 | after(grammarAccess.getALSRelationDefinitionAccess().getVariablesAssignment_4_1()); | ||
10640 | } | ||
10641 | |||
10642 | } | ||
10643 | |||
10644 | |||
10645 | } | ||
10646 | |||
10647 | } | ||
10648 | catch (RecognitionException re) { | ||
10649 | reportError(re); | ||
10650 | recover(input,re); | ||
10651 | } | ||
10652 | finally { | ||
10653 | |||
10654 | restoreStackSize(stackSize); | ||
10655 | |||
10656 | } | ||
10657 | return ; | ||
10658 | } | ||
10659 | // $ANTLR end "rule__ALSRelationDefinition__Group_4__1__Impl" | ||
10660 | |||
10661 | |||
10662 | // $ANTLR start "rule__ALSFactDeclaration__Group__0" | ||
10663 | // InternalAlloyLanguage.g:3495:1: rule__ALSFactDeclaration__Group__0 : rule__ALSFactDeclaration__Group__0__Impl rule__ALSFactDeclaration__Group__1 ; | ||
10664 | public final void rule__ALSFactDeclaration__Group__0() throws RecognitionException { | ||
10665 | |||
10666 | int stackSize = keepStackSize(); | ||
10667 | |||
10668 | try { | ||
10669 | // InternalAlloyLanguage.g:3499:1: ( rule__ALSFactDeclaration__Group__0__Impl rule__ALSFactDeclaration__Group__1 ) | ||
10670 | // InternalAlloyLanguage.g:3500:2: rule__ALSFactDeclaration__Group__0__Impl rule__ALSFactDeclaration__Group__1 | ||
10671 | { | ||
10672 | pushFollow(FOLLOW_20); | ||
10673 | rule__ALSFactDeclaration__Group__0__Impl(); | ||
10674 | |||
10675 | state._fsp--; | ||
10676 | if (state.failed) return ; | ||
10677 | pushFollow(FOLLOW_2); | ||
10678 | rule__ALSFactDeclaration__Group__1(); | ||
10679 | |||
10680 | state._fsp--; | ||
10681 | if (state.failed) return ; | ||
10682 | |||
10683 | } | ||
10684 | |||
10685 | } | ||
10686 | catch (RecognitionException re) { | ||
10687 | reportError(re); | ||
10688 | recover(input,re); | ||
10689 | } | ||
10690 | finally { | ||
10691 | |||
10692 | restoreStackSize(stackSize); | ||
10693 | |||
10694 | } | ||
10695 | return ; | ||
10696 | } | ||
10697 | // $ANTLR end "rule__ALSFactDeclaration__Group__0" | ||
10698 | |||
10699 | |||
10700 | // $ANTLR start "rule__ALSFactDeclaration__Group__0__Impl" | ||
10701 | // InternalAlloyLanguage.g:3507:1: rule__ALSFactDeclaration__Group__0__Impl : ( () ) ; | ||
10702 | public final void rule__ALSFactDeclaration__Group__0__Impl() throws RecognitionException { | ||
10703 | |||
10704 | int stackSize = keepStackSize(); | ||
10705 | |||
10706 | try { | ||
10707 | // InternalAlloyLanguage.g:3511:1: ( ( () ) ) | ||
10708 | // InternalAlloyLanguage.g:3512:1: ( () ) | ||
10709 | { | ||
10710 | // InternalAlloyLanguage.g:3512:1: ( () ) | ||
10711 | // InternalAlloyLanguage.g:3513:1: () | ||
10712 | { | ||
10713 | if ( state.backtracking==0 ) { | ||
10714 | before(grammarAccess.getALSFactDeclarationAccess().getALSFactDeclarationAction_0()); | ||
10715 | } | ||
10716 | // InternalAlloyLanguage.g:3514:1: () | ||
10717 | // InternalAlloyLanguage.g:3516:1: | ||
10718 | { | ||
10719 | } | ||
10720 | |||
10721 | if ( state.backtracking==0 ) { | ||
10722 | after(grammarAccess.getALSFactDeclarationAccess().getALSFactDeclarationAction_0()); | ||
10723 | } | ||
10724 | |||
10725 | } | ||
10726 | |||
10727 | |||
10728 | } | ||
10729 | |||
10730 | } | ||
10731 | finally { | ||
10732 | |||
10733 | restoreStackSize(stackSize); | ||
10734 | |||
10735 | } | ||
10736 | return ; | ||
10737 | } | ||
10738 | // $ANTLR end "rule__ALSFactDeclaration__Group__0__Impl" | ||
10739 | |||
10740 | |||
10741 | // $ANTLR start "rule__ALSFactDeclaration__Group__1" | ||
10742 | // InternalAlloyLanguage.g:3526:1: rule__ALSFactDeclaration__Group__1 : rule__ALSFactDeclaration__Group__1__Impl rule__ALSFactDeclaration__Group__2 ; | ||
10743 | public final void rule__ALSFactDeclaration__Group__1() throws RecognitionException { | ||
10744 | |||
10745 | int stackSize = keepStackSize(); | ||
10746 | |||
10747 | try { | ||
10748 | // InternalAlloyLanguage.g:3530:1: ( rule__ALSFactDeclaration__Group__1__Impl rule__ALSFactDeclaration__Group__2 ) | ||
10749 | // InternalAlloyLanguage.g:3531:2: rule__ALSFactDeclaration__Group__1__Impl rule__ALSFactDeclaration__Group__2 | ||
10750 | { | ||
10751 | pushFollow(FOLLOW_21); | ||
10752 | rule__ALSFactDeclaration__Group__1__Impl(); | ||
10753 | |||
10754 | state._fsp--; | ||
10755 | if (state.failed) return ; | ||
10756 | pushFollow(FOLLOW_2); | ||
10757 | rule__ALSFactDeclaration__Group__2(); | ||
10758 | |||
10759 | state._fsp--; | ||
10760 | if (state.failed) return ; | ||
10761 | |||
10762 | } | ||
10763 | |||
10764 | } | ||
10765 | catch (RecognitionException re) { | ||
10766 | reportError(re); | ||
10767 | recover(input,re); | ||
10768 | } | ||
10769 | finally { | ||
10770 | |||
10771 | restoreStackSize(stackSize); | ||
10772 | |||
10773 | } | ||
10774 | return ; | ||
10775 | } | ||
10776 | // $ANTLR end "rule__ALSFactDeclaration__Group__1" | ||
10777 | |||
10778 | |||
10779 | // $ANTLR start "rule__ALSFactDeclaration__Group__1__Impl" | ||
10780 | // InternalAlloyLanguage.g:3538:1: rule__ALSFactDeclaration__Group__1__Impl : ( 'fact' ) ; | ||
10781 | public final void rule__ALSFactDeclaration__Group__1__Impl() throws RecognitionException { | ||
10782 | |||
10783 | int stackSize = keepStackSize(); | ||
10784 | |||
10785 | try { | ||
10786 | // InternalAlloyLanguage.g:3542:1: ( ( 'fact' ) ) | ||
10787 | // InternalAlloyLanguage.g:3543:1: ( 'fact' ) | ||
10788 | { | ||
10789 | // InternalAlloyLanguage.g:3543:1: ( 'fact' ) | ||
10790 | // InternalAlloyLanguage.g:3544:1: 'fact' | ||
10791 | { | ||
10792 | if ( state.backtracking==0 ) { | ||
10793 | before(grammarAccess.getALSFactDeclarationAccess().getFactKeyword_1()); | ||
10794 | } | ||
10795 | match(input,45,FOLLOW_2); if (state.failed) return ; | ||
10796 | if ( state.backtracking==0 ) { | ||
10797 | after(grammarAccess.getALSFactDeclarationAccess().getFactKeyword_1()); | ||
10798 | } | ||
10799 | |||
10800 | } | ||
10801 | |||
10802 | |||
10803 | } | ||
10804 | |||
10805 | } | ||
10806 | catch (RecognitionException re) { | ||
10807 | reportError(re); | ||
10808 | recover(input,re); | ||
10809 | } | ||
10810 | finally { | ||
10811 | |||
10812 | restoreStackSize(stackSize); | ||
10813 | |||
10814 | } | ||
10815 | return ; | ||
10816 | } | ||
10817 | // $ANTLR end "rule__ALSFactDeclaration__Group__1__Impl" | ||
10818 | |||
10819 | |||
10820 | // $ANTLR start "rule__ALSFactDeclaration__Group__2" | ||
10821 | // InternalAlloyLanguage.g:3557:1: rule__ALSFactDeclaration__Group__2 : rule__ALSFactDeclaration__Group__2__Impl rule__ALSFactDeclaration__Group__3 ; | ||
10822 | public final void rule__ALSFactDeclaration__Group__2() throws RecognitionException { | ||
10823 | |||
10824 | int stackSize = keepStackSize(); | ||
10825 | |||
10826 | try { | ||
10827 | // InternalAlloyLanguage.g:3561:1: ( rule__ALSFactDeclaration__Group__2__Impl rule__ALSFactDeclaration__Group__3 ) | ||
10828 | // InternalAlloyLanguage.g:3562:2: rule__ALSFactDeclaration__Group__2__Impl rule__ALSFactDeclaration__Group__3 | ||
10829 | { | ||
10830 | pushFollow(FOLLOW_21); | ||
10831 | rule__ALSFactDeclaration__Group__2__Impl(); | ||
10832 | |||
10833 | state._fsp--; | ||
10834 | if (state.failed) return ; | ||
10835 | pushFollow(FOLLOW_2); | ||
10836 | rule__ALSFactDeclaration__Group__3(); | ||
10837 | |||
10838 | state._fsp--; | ||
10839 | if (state.failed) return ; | ||
10840 | |||
10841 | } | ||
10842 | |||
10843 | } | ||
10844 | catch (RecognitionException re) { | ||
10845 | reportError(re); | ||
10846 | recover(input,re); | ||
10847 | } | ||
10848 | finally { | ||
10849 | |||
10850 | restoreStackSize(stackSize); | ||
10851 | |||
10852 | } | ||
10853 | return ; | ||
10854 | } | ||
10855 | // $ANTLR end "rule__ALSFactDeclaration__Group__2" | ||
10856 | |||
10857 | |||
10858 | // $ANTLR start "rule__ALSFactDeclaration__Group__2__Impl" | ||
10859 | // InternalAlloyLanguage.g:3569:1: rule__ALSFactDeclaration__Group__2__Impl : ( ( rule__ALSFactDeclaration__NameAssignment_2 )? ) ; | ||
10860 | public final void rule__ALSFactDeclaration__Group__2__Impl() throws RecognitionException { | ||
10861 | |||
10862 | int stackSize = keepStackSize(); | ||
10863 | |||
10864 | try { | ||
10865 | // InternalAlloyLanguage.g:3573:1: ( ( ( rule__ALSFactDeclaration__NameAssignment_2 )? ) ) | ||
10866 | // InternalAlloyLanguage.g:3574:1: ( ( rule__ALSFactDeclaration__NameAssignment_2 )? ) | ||
10867 | { | ||
10868 | // InternalAlloyLanguage.g:3574:1: ( ( rule__ALSFactDeclaration__NameAssignment_2 )? ) | ||
10869 | // InternalAlloyLanguage.g:3575:1: ( rule__ALSFactDeclaration__NameAssignment_2 )? | ||
10870 | { | ||
10871 | if ( state.backtracking==0 ) { | ||
10872 | before(grammarAccess.getALSFactDeclarationAccess().getNameAssignment_2()); | ||
10873 | } | ||
10874 | // InternalAlloyLanguage.g:3576:1: ( rule__ALSFactDeclaration__NameAssignment_2 )? | ||
10875 | int alt27=2; | ||
10876 | int LA27_0 = input.LA(1); | ||
10877 | |||
10878 | if ( (LA27_0==RULE_ID) ) { | ||
10879 | alt27=1; | ||
10880 | } | ||
10881 | switch (alt27) { | ||
10882 | case 1 : | ||
10883 | // InternalAlloyLanguage.g:3576:2: rule__ALSFactDeclaration__NameAssignment_2 | ||
10884 | { | ||
10885 | pushFollow(FOLLOW_2); | ||
10886 | rule__ALSFactDeclaration__NameAssignment_2(); | ||
10887 | |||
10888 | state._fsp--; | ||
10889 | if (state.failed) return ; | ||
10890 | |||
10891 | } | ||
10892 | break; | ||
10893 | |||
10894 | } | ||
10895 | |||
10896 | if ( state.backtracking==0 ) { | ||
10897 | after(grammarAccess.getALSFactDeclarationAccess().getNameAssignment_2()); | ||
10898 | } | ||
10899 | |||
10900 | } | ||
10901 | |||
10902 | |||
10903 | } | ||
10904 | |||
10905 | } | ||
10906 | catch (RecognitionException re) { | ||
10907 | reportError(re); | ||
10908 | recover(input,re); | ||
10909 | } | ||
10910 | finally { | ||
10911 | |||
10912 | restoreStackSize(stackSize); | ||
10913 | |||
10914 | } | ||
10915 | return ; | ||
10916 | } | ||
10917 | // $ANTLR end "rule__ALSFactDeclaration__Group__2__Impl" | ||
10918 | |||
10919 | |||
10920 | // $ANTLR start "rule__ALSFactDeclaration__Group__3" | ||
10921 | // InternalAlloyLanguage.g:3586:1: rule__ALSFactDeclaration__Group__3 : rule__ALSFactDeclaration__Group__3__Impl rule__ALSFactDeclaration__Group__4 ; | ||
10922 | public final void rule__ALSFactDeclaration__Group__3() throws RecognitionException { | ||
10923 | |||
10924 | int stackSize = keepStackSize(); | ||
10925 | |||
10926 | try { | ||
10927 | // InternalAlloyLanguage.g:3590:1: ( rule__ALSFactDeclaration__Group__3__Impl rule__ALSFactDeclaration__Group__4 ) | ||
10928 | // InternalAlloyLanguage.g:3591:2: rule__ALSFactDeclaration__Group__3__Impl rule__ALSFactDeclaration__Group__4 | ||
10929 | { | ||
10930 | pushFollow(FOLLOW_16); | ||
10931 | rule__ALSFactDeclaration__Group__3__Impl(); | ||
10932 | |||
10933 | state._fsp--; | ||
10934 | if (state.failed) return ; | ||
10935 | pushFollow(FOLLOW_2); | ||
10936 | rule__ALSFactDeclaration__Group__4(); | ||
10937 | |||
10938 | state._fsp--; | ||
10939 | if (state.failed) return ; | ||
10940 | |||
10941 | } | ||
10942 | |||
10943 | } | ||
10944 | catch (RecognitionException re) { | ||
10945 | reportError(re); | ||
10946 | recover(input,re); | ||
10947 | } | ||
10948 | finally { | ||
10949 | |||
10950 | restoreStackSize(stackSize); | ||
10951 | |||
10952 | } | ||
10953 | return ; | ||
10954 | } | ||
10955 | // $ANTLR end "rule__ALSFactDeclaration__Group__3" | ||
10956 | |||
10957 | |||
10958 | // $ANTLR start "rule__ALSFactDeclaration__Group__3__Impl" | ||
10959 | // InternalAlloyLanguage.g:3598:1: rule__ALSFactDeclaration__Group__3__Impl : ( '{' ) ; | ||
10960 | public final void rule__ALSFactDeclaration__Group__3__Impl() throws RecognitionException { | ||
10961 | |||
10962 | int stackSize = keepStackSize(); | ||
10963 | |||
10964 | try { | ||
10965 | // InternalAlloyLanguage.g:3602:1: ( ( '{' ) ) | ||
10966 | // InternalAlloyLanguage.g:3603:1: ( '{' ) | ||
10967 | { | ||
10968 | // InternalAlloyLanguage.g:3603:1: ( '{' ) | ||
10969 | // InternalAlloyLanguage.g:3604:1: '{' | ||
10970 | { | ||
10971 | if ( state.backtracking==0 ) { | ||
10972 | before(grammarAccess.getALSFactDeclarationAccess().getLeftCurlyBracketKeyword_3()); | ||
10973 | } | ||
10974 | match(input,33,FOLLOW_2); if (state.failed) return ; | ||
10975 | if ( state.backtracking==0 ) { | ||
10976 | after(grammarAccess.getALSFactDeclarationAccess().getLeftCurlyBracketKeyword_3()); | ||
10977 | } | ||
10978 | |||
10979 | } | ||
10980 | |||
10981 | |||
10982 | } | ||
10983 | |||
10984 | } | ||
10985 | catch (RecognitionException re) { | ||
10986 | reportError(re); | ||
10987 | recover(input,re); | ||
10988 | } | ||
10989 | finally { | ||
10990 | |||
10991 | restoreStackSize(stackSize); | ||
10992 | |||
10993 | } | ||
10994 | return ; | ||
10995 | } | ||
10996 | // $ANTLR end "rule__ALSFactDeclaration__Group__3__Impl" | ||
10997 | |||
10998 | |||
10999 | // $ANTLR start "rule__ALSFactDeclaration__Group__4" | ||
11000 | // InternalAlloyLanguage.g:3617:1: rule__ALSFactDeclaration__Group__4 : rule__ALSFactDeclaration__Group__4__Impl rule__ALSFactDeclaration__Group__5 ; | ||
11001 | public final void rule__ALSFactDeclaration__Group__4() throws RecognitionException { | ||
11002 | |||
11003 | int stackSize = keepStackSize(); | ||
11004 | |||
11005 | try { | ||
11006 | // InternalAlloyLanguage.g:3621:1: ( rule__ALSFactDeclaration__Group__4__Impl rule__ALSFactDeclaration__Group__5 ) | ||
11007 | // InternalAlloyLanguage.g:3622:2: rule__ALSFactDeclaration__Group__4__Impl rule__ALSFactDeclaration__Group__5 | ||
11008 | { | ||
11009 | pushFollow(FOLLOW_19); | ||
11010 | rule__ALSFactDeclaration__Group__4__Impl(); | ||
11011 | |||
11012 | state._fsp--; | ||
11013 | if (state.failed) return ; | ||
11014 | pushFollow(FOLLOW_2); | ||
11015 | rule__ALSFactDeclaration__Group__5(); | ||
11016 | |||
11017 | state._fsp--; | ||
11018 | if (state.failed) return ; | ||
11019 | |||
11020 | } | ||
11021 | |||
11022 | } | ||
11023 | catch (RecognitionException re) { | ||
11024 | reportError(re); | ||
11025 | recover(input,re); | ||
11026 | } | ||
11027 | finally { | ||
11028 | |||
11029 | restoreStackSize(stackSize); | ||
11030 | |||
11031 | } | ||
11032 | return ; | ||
11033 | } | ||
11034 | // $ANTLR end "rule__ALSFactDeclaration__Group__4" | ||
11035 | |||
11036 | |||
11037 | // $ANTLR start "rule__ALSFactDeclaration__Group__4__Impl" | ||
11038 | // InternalAlloyLanguage.g:3629:1: rule__ALSFactDeclaration__Group__4__Impl : ( ( rule__ALSFactDeclaration__TermAssignment_4 ) ) ; | ||
11039 | public final void rule__ALSFactDeclaration__Group__4__Impl() throws RecognitionException { | ||
11040 | |||
11041 | int stackSize = keepStackSize(); | ||
11042 | |||
11043 | try { | ||
11044 | // InternalAlloyLanguage.g:3633:1: ( ( ( rule__ALSFactDeclaration__TermAssignment_4 ) ) ) | ||
11045 | // InternalAlloyLanguage.g:3634:1: ( ( rule__ALSFactDeclaration__TermAssignment_4 ) ) | ||
11046 | { | ||
11047 | // InternalAlloyLanguage.g:3634:1: ( ( rule__ALSFactDeclaration__TermAssignment_4 ) ) | ||
11048 | // InternalAlloyLanguage.g:3635:1: ( rule__ALSFactDeclaration__TermAssignment_4 ) | ||
11049 | { | ||
11050 | if ( state.backtracking==0 ) { | ||
11051 | before(grammarAccess.getALSFactDeclarationAccess().getTermAssignment_4()); | ||
11052 | } | ||
11053 | // InternalAlloyLanguage.g:3636:1: ( rule__ALSFactDeclaration__TermAssignment_4 ) | ||
11054 | // InternalAlloyLanguage.g:3636:2: rule__ALSFactDeclaration__TermAssignment_4 | ||
11055 | { | ||
11056 | pushFollow(FOLLOW_2); | ||
11057 | rule__ALSFactDeclaration__TermAssignment_4(); | ||
11058 | |||
11059 | state._fsp--; | ||
11060 | if (state.failed) return ; | ||
11061 | |||
11062 | } | ||
11063 | |||
11064 | if ( state.backtracking==0 ) { | ||
11065 | after(grammarAccess.getALSFactDeclarationAccess().getTermAssignment_4()); | ||
11066 | } | ||
11067 | |||
11068 | } | ||
11069 | |||
11070 | |||
11071 | } | ||
11072 | |||
11073 | } | ||
11074 | catch (RecognitionException re) { | ||
11075 | reportError(re); | ||
11076 | recover(input,re); | ||
11077 | } | ||
11078 | finally { | ||
11079 | |||
11080 | restoreStackSize(stackSize); | ||
11081 | |||
11082 | } | ||
11083 | return ; | ||
11084 | } | ||
11085 | // $ANTLR end "rule__ALSFactDeclaration__Group__4__Impl" | ||
11086 | |||
11087 | |||
11088 | // $ANTLR start "rule__ALSFactDeclaration__Group__5" | ||
11089 | // InternalAlloyLanguage.g:3646:1: rule__ALSFactDeclaration__Group__5 : rule__ALSFactDeclaration__Group__5__Impl ; | ||
11090 | public final void rule__ALSFactDeclaration__Group__5() throws RecognitionException { | ||
11091 | |||
11092 | int stackSize = keepStackSize(); | ||
11093 | |||
11094 | try { | ||
11095 | // InternalAlloyLanguage.g:3650:1: ( rule__ALSFactDeclaration__Group__5__Impl ) | ||
11096 | // InternalAlloyLanguage.g:3651:2: rule__ALSFactDeclaration__Group__5__Impl | ||
11097 | { | ||
11098 | pushFollow(FOLLOW_2); | ||
11099 | rule__ALSFactDeclaration__Group__5__Impl(); | ||
11100 | |||
11101 | state._fsp--; | ||
11102 | if (state.failed) return ; | ||
11103 | |||
11104 | } | ||
11105 | |||
11106 | } | ||
11107 | catch (RecognitionException re) { | ||
11108 | reportError(re); | ||
11109 | recover(input,re); | ||
11110 | } | ||
11111 | finally { | ||
11112 | |||
11113 | restoreStackSize(stackSize); | ||
11114 | |||
11115 | } | ||
11116 | return ; | ||
11117 | } | ||
11118 | // $ANTLR end "rule__ALSFactDeclaration__Group__5" | ||
11119 | |||
11120 | |||
11121 | // $ANTLR start "rule__ALSFactDeclaration__Group__5__Impl" | ||
11122 | // InternalAlloyLanguage.g:3657:1: rule__ALSFactDeclaration__Group__5__Impl : ( '}' ) ; | ||
11123 | public final void rule__ALSFactDeclaration__Group__5__Impl() throws RecognitionException { | ||
11124 | |||
11125 | int stackSize = keepStackSize(); | ||
11126 | |||
11127 | try { | ||
11128 | // InternalAlloyLanguage.g:3661:1: ( ( '}' ) ) | ||
11129 | // InternalAlloyLanguage.g:3662:1: ( '}' ) | ||
11130 | { | ||
11131 | // InternalAlloyLanguage.g:3662:1: ( '}' ) | ||
11132 | // InternalAlloyLanguage.g:3663:1: '}' | ||
11133 | { | ||
11134 | if ( state.backtracking==0 ) { | ||
11135 | before(grammarAccess.getALSFactDeclarationAccess().getRightCurlyBracketKeyword_5()); | ||
11136 | } | ||
11137 | match(input,34,FOLLOW_2); if (state.failed) return ; | ||
11138 | if ( state.backtracking==0 ) { | ||
11139 | after(grammarAccess.getALSFactDeclarationAccess().getRightCurlyBracketKeyword_5()); | ||
11140 | } | ||
11141 | |||
11142 | } | ||
11143 | |||
11144 | |||
11145 | } | ||
11146 | |||
11147 | } | ||
11148 | catch (RecognitionException re) { | ||
11149 | reportError(re); | ||
11150 | recover(input,re); | ||
11151 | } | ||
11152 | finally { | ||
11153 | |||
11154 | restoreStackSize(stackSize); | ||
11155 | |||
11156 | } | ||
11157 | return ; | ||
11158 | } | ||
11159 | // $ANTLR end "rule__ALSFactDeclaration__Group__5__Impl" | ||
11160 | |||
11161 | |||
11162 | // $ANTLR start "rule__ALSQuantified__Group_0__0" | ||
11163 | // InternalAlloyLanguage.g:3688:1: rule__ALSQuantified__Group_0__0 : rule__ALSQuantified__Group_0__0__Impl rule__ALSQuantified__Group_0__1 ; | ||
11164 | public final void rule__ALSQuantified__Group_0__0() throws RecognitionException { | ||
11165 | |||
11166 | int stackSize = keepStackSize(); | ||
11167 | |||
11168 | try { | ||
11169 | // InternalAlloyLanguage.g:3692:1: ( rule__ALSQuantified__Group_0__0__Impl rule__ALSQuantified__Group_0__1 ) | ||
11170 | // InternalAlloyLanguage.g:3693:2: rule__ALSQuantified__Group_0__0__Impl rule__ALSQuantified__Group_0__1 | ||
11171 | { | ||
11172 | pushFollow(FOLLOW_22); | ||
11173 | rule__ALSQuantified__Group_0__0__Impl(); | ||
11174 | |||
11175 | state._fsp--; | ||
11176 | if (state.failed) return ; | ||
11177 | pushFollow(FOLLOW_2); | ||
11178 | rule__ALSQuantified__Group_0__1(); | ||
11179 | |||
11180 | state._fsp--; | ||
11181 | if (state.failed) return ; | ||
11182 | |||
11183 | } | ||
11184 | |||
11185 | } | ||
11186 | catch (RecognitionException re) { | ||
11187 | reportError(re); | ||
11188 | recover(input,re); | ||
11189 | } | ||
11190 | finally { | ||
11191 | |||
11192 | restoreStackSize(stackSize); | ||
11193 | |||
11194 | } | ||
11195 | return ; | ||
11196 | } | ||
11197 | // $ANTLR end "rule__ALSQuantified__Group_0__0" | ||
11198 | |||
11199 | |||
11200 | // $ANTLR start "rule__ALSQuantified__Group_0__0__Impl" | ||
11201 | // InternalAlloyLanguage.g:3700:1: rule__ALSQuantified__Group_0__0__Impl : ( () ) ; | ||
11202 | public final void rule__ALSQuantified__Group_0__0__Impl() throws RecognitionException { | ||
11203 | |||
11204 | int stackSize = keepStackSize(); | ||
11205 | |||
11206 | try { | ||
11207 | // InternalAlloyLanguage.g:3704:1: ( ( () ) ) | ||
11208 | // InternalAlloyLanguage.g:3705:1: ( () ) | ||
11209 | { | ||
11210 | // InternalAlloyLanguage.g:3705:1: ( () ) | ||
11211 | // InternalAlloyLanguage.g:3706:1: () | ||
11212 | { | ||
11213 | if ( state.backtracking==0 ) { | ||
11214 | before(grammarAccess.getALSQuantifiedAccess().getALSQuantifiedExAction_0_0()); | ||
11215 | } | ||
11216 | // InternalAlloyLanguage.g:3707:1: () | ||
11217 | // InternalAlloyLanguage.g:3709:1: | ||
11218 | { | ||
11219 | } | ||
11220 | |||
11221 | if ( state.backtracking==0 ) { | ||
11222 | after(grammarAccess.getALSQuantifiedAccess().getALSQuantifiedExAction_0_0()); | ||
11223 | } | ||
11224 | |||
11225 | } | ||
11226 | |||
11227 | |||
11228 | } | ||
11229 | |||
11230 | } | ||
11231 | finally { | ||
11232 | |||
11233 | restoreStackSize(stackSize); | ||
11234 | |||
11235 | } | ||
11236 | return ; | ||
11237 | } | ||
11238 | // $ANTLR end "rule__ALSQuantified__Group_0__0__Impl" | ||
11239 | |||
11240 | |||
11241 | // $ANTLR start "rule__ALSQuantified__Group_0__1" | ||
11242 | // InternalAlloyLanguage.g:3719:1: rule__ALSQuantified__Group_0__1 : rule__ALSQuantified__Group_0__1__Impl rule__ALSQuantified__Group_0__2 ; | ||
11243 | public final void rule__ALSQuantified__Group_0__1() throws RecognitionException { | ||
11244 | |||
11245 | int stackSize = keepStackSize(); | ||
11246 | |||
11247 | try { | ||
11248 | // InternalAlloyLanguage.g:3723:1: ( rule__ALSQuantified__Group_0__1__Impl rule__ALSQuantified__Group_0__2 ) | ||
11249 | // InternalAlloyLanguage.g:3724:2: rule__ALSQuantified__Group_0__1__Impl rule__ALSQuantified__Group_0__2 | ||
11250 | { | ||
11251 | pushFollow(FOLLOW_23); | ||
11252 | rule__ALSQuantified__Group_0__1__Impl(); | ||
11253 | |||
11254 | state._fsp--; | ||
11255 | if (state.failed) return ; | ||
11256 | pushFollow(FOLLOW_2); | ||
11257 | rule__ALSQuantified__Group_0__2(); | ||
11258 | |||
11259 | state._fsp--; | ||
11260 | if (state.failed) return ; | ||
11261 | |||
11262 | } | ||
11263 | |||
11264 | } | ||
11265 | catch (RecognitionException re) { | ||
11266 | reportError(re); | ||
11267 | recover(input,re); | ||
11268 | } | ||
11269 | finally { | ||
11270 | |||
11271 | restoreStackSize(stackSize); | ||
11272 | |||
11273 | } | ||
11274 | return ; | ||
11275 | } | ||
11276 | // $ANTLR end "rule__ALSQuantified__Group_0__1" | ||
11277 | |||
11278 | |||
11279 | // $ANTLR start "rule__ALSQuantified__Group_0__1__Impl" | ||
11280 | // InternalAlloyLanguage.g:3731:1: rule__ALSQuantified__Group_0__1__Impl : ( ( rule__ALSQuantified__TypeAssignment_0_1 ) ) ; | ||
11281 | public final void rule__ALSQuantified__Group_0__1__Impl() throws RecognitionException { | ||
11282 | |||
11283 | int stackSize = keepStackSize(); | ||
11284 | |||
11285 | try { | ||
11286 | // InternalAlloyLanguage.g:3735:1: ( ( ( rule__ALSQuantified__TypeAssignment_0_1 ) ) ) | ||
11287 | // InternalAlloyLanguage.g:3736:1: ( ( rule__ALSQuantified__TypeAssignment_0_1 ) ) | ||
11288 | { | ||
11289 | // InternalAlloyLanguage.g:3736:1: ( ( rule__ALSQuantified__TypeAssignment_0_1 ) ) | ||
11290 | // InternalAlloyLanguage.g:3737:1: ( rule__ALSQuantified__TypeAssignment_0_1 ) | ||
11291 | { | ||
11292 | if ( state.backtracking==0 ) { | ||
11293 | before(grammarAccess.getALSQuantifiedAccess().getTypeAssignment_0_1()); | ||
11294 | } | ||
11295 | // InternalAlloyLanguage.g:3738:1: ( rule__ALSQuantified__TypeAssignment_0_1 ) | ||
11296 | // InternalAlloyLanguage.g:3738:2: rule__ALSQuantified__TypeAssignment_0_1 | ||
11297 | { | ||
11298 | pushFollow(FOLLOW_2); | ||
11299 | rule__ALSQuantified__TypeAssignment_0_1(); | ||
11300 | |||
11301 | state._fsp--; | ||
11302 | if (state.failed) return ; | ||
11303 | |||
11304 | } | ||
11305 | |||
11306 | if ( state.backtracking==0 ) { | ||
11307 | after(grammarAccess.getALSQuantifiedAccess().getTypeAssignment_0_1()); | ||
11308 | } | ||
11309 | |||
11310 | } | ||
11311 | |||
11312 | |||
11313 | } | ||
11314 | |||
11315 | } | ||
11316 | catch (RecognitionException re) { | ||
11317 | reportError(re); | ||
11318 | recover(input,re); | ||
11319 | } | ||
11320 | finally { | ||
11321 | |||
11322 | restoreStackSize(stackSize); | ||
11323 | |||
11324 | } | ||
11325 | return ; | ||
11326 | } | ||
11327 | // $ANTLR end "rule__ALSQuantified__Group_0__1__Impl" | ||
11328 | |||
11329 | |||
11330 | // $ANTLR start "rule__ALSQuantified__Group_0__2" | ||
11331 | // InternalAlloyLanguage.g:3748:1: rule__ALSQuantified__Group_0__2 : rule__ALSQuantified__Group_0__2__Impl rule__ALSQuantified__Group_0__3 ; | ||
11332 | public final void rule__ALSQuantified__Group_0__2() throws RecognitionException { | ||
11333 | |||
11334 | int stackSize = keepStackSize(); | ||
11335 | |||
11336 | try { | ||
11337 | // InternalAlloyLanguage.g:3752:1: ( rule__ALSQuantified__Group_0__2__Impl rule__ALSQuantified__Group_0__3 ) | ||
11338 | // InternalAlloyLanguage.g:3753:2: rule__ALSQuantified__Group_0__2__Impl rule__ALSQuantified__Group_0__3 | ||
11339 | { | ||
11340 | pushFollow(FOLLOW_23); | ||
11341 | rule__ALSQuantified__Group_0__2__Impl(); | ||
11342 | |||
11343 | state._fsp--; | ||
11344 | if (state.failed) return ; | ||
11345 | pushFollow(FOLLOW_2); | ||
11346 | rule__ALSQuantified__Group_0__3(); | ||
11347 | |||
11348 | state._fsp--; | ||
11349 | if (state.failed) return ; | ||
11350 | |||
11351 | } | ||
11352 | |||
11353 | } | ||
11354 | catch (RecognitionException re) { | ||
11355 | reportError(re); | ||
11356 | recover(input,re); | ||
11357 | } | ||
11358 | finally { | ||
11359 | |||
11360 | restoreStackSize(stackSize); | ||
11361 | |||
11362 | } | ||
11363 | return ; | ||
11364 | } | ||
11365 | // $ANTLR end "rule__ALSQuantified__Group_0__2" | ||
11366 | |||
11367 | |||
11368 | // $ANTLR start "rule__ALSQuantified__Group_0__2__Impl" | ||
11369 | // InternalAlloyLanguage.g:3760:1: rule__ALSQuantified__Group_0__2__Impl : ( ( rule__ALSQuantified__DisjAssignment_0_2 )? ) ; | ||
11370 | public final void rule__ALSQuantified__Group_0__2__Impl() throws RecognitionException { | ||
11371 | |||
11372 | int stackSize = keepStackSize(); | ||
11373 | |||
11374 | try { | ||
11375 | // InternalAlloyLanguage.g:3764:1: ( ( ( rule__ALSQuantified__DisjAssignment_0_2 )? ) ) | ||
11376 | // InternalAlloyLanguage.g:3765:1: ( ( rule__ALSQuantified__DisjAssignment_0_2 )? ) | ||
11377 | { | ||
11378 | // InternalAlloyLanguage.g:3765:1: ( ( rule__ALSQuantified__DisjAssignment_0_2 )? ) | ||
11379 | // InternalAlloyLanguage.g:3766:1: ( rule__ALSQuantified__DisjAssignment_0_2 )? | ||
11380 | { | ||
11381 | if ( state.backtracking==0 ) { | ||
11382 | before(grammarAccess.getALSQuantifiedAccess().getDisjAssignment_0_2()); | ||
11383 | } | ||
11384 | // InternalAlloyLanguage.g:3767:1: ( rule__ALSQuantified__DisjAssignment_0_2 )? | ||
11385 | int alt28=2; | ||
11386 | int LA28_0 = input.LA(1); | ||
11387 | |||
11388 | if ( (LA28_0==76) ) { | ||
11389 | alt28=1; | ||
11390 | } | ||
11391 | switch (alt28) { | ||
11392 | case 1 : | ||
11393 | // InternalAlloyLanguage.g:3767:2: rule__ALSQuantified__DisjAssignment_0_2 | ||
11394 | { | ||
11395 | pushFollow(FOLLOW_2); | ||
11396 | rule__ALSQuantified__DisjAssignment_0_2(); | ||
11397 | |||
11398 | state._fsp--; | ||
11399 | if (state.failed) return ; | ||
11400 | |||
11401 | } | ||
11402 | break; | ||
11403 | |||
11404 | } | ||
11405 | |||
11406 | if ( state.backtracking==0 ) { | ||
11407 | after(grammarAccess.getALSQuantifiedAccess().getDisjAssignment_0_2()); | ||
11408 | } | ||
11409 | |||
11410 | } | ||
11411 | |||
11412 | |||
11413 | } | ||
11414 | |||
11415 | } | ||
11416 | catch (RecognitionException re) { | ||
11417 | reportError(re); | ||
11418 | recover(input,re); | ||
11419 | } | ||
11420 | finally { | ||
11421 | |||
11422 | restoreStackSize(stackSize); | ||
11423 | |||
11424 | } | ||
11425 | return ; | ||
11426 | } | ||
11427 | // $ANTLR end "rule__ALSQuantified__Group_0__2__Impl" | ||
11428 | |||
11429 | |||
11430 | // $ANTLR start "rule__ALSQuantified__Group_0__3" | ||
11431 | // InternalAlloyLanguage.g:3777:1: rule__ALSQuantified__Group_0__3 : rule__ALSQuantified__Group_0__3__Impl rule__ALSQuantified__Group_0__4 ; | ||
11432 | public final void rule__ALSQuantified__Group_0__3() throws RecognitionException { | ||
11433 | |||
11434 | int stackSize = keepStackSize(); | ||
11435 | |||
11436 | try { | ||
11437 | // InternalAlloyLanguage.g:3781:1: ( rule__ALSQuantified__Group_0__3__Impl rule__ALSQuantified__Group_0__4 ) | ||
11438 | // InternalAlloyLanguage.g:3782:2: rule__ALSQuantified__Group_0__3__Impl rule__ALSQuantified__Group_0__4 | ||
11439 | { | ||
11440 | pushFollow(FOLLOW_24); | ||
11441 | rule__ALSQuantified__Group_0__3__Impl(); | ||
11442 | |||
11443 | state._fsp--; | ||
11444 | if (state.failed) return ; | ||
11445 | pushFollow(FOLLOW_2); | ||
11446 | rule__ALSQuantified__Group_0__4(); | ||
11447 | |||
11448 | state._fsp--; | ||
11449 | if (state.failed) return ; | ||
11450 | |||
11451 | } | ||
11452 | |||
11453 | } | ||
11454 | catch (RecognitionException re) { | ||
11455 | reportError(re); | ||
11456 | recover(input,re); | ||
11457 | } | ||
11458 | finally { | ||
11459 | |||
11460 | restoreStackSize(stackSize); | ||
11461 | |||
11462 | } | ||
11463 | return ; | ||
11464 | } | ||
11465 | // $ANTLR end "rule__ALSQuantified__Group_0__3" | ||
11466 | |||
11467 | |||
11468 | // $ANTLR start "rule__ALSQuantified__Group_0__3__Impl" | ||
11469 | // InternalAlloyLanguage.g:3789:1: rule__ALSQuantified__Group_0__3__Impl : ( ( rule__ALSQuantified__VariablesAssignment_0_3 ) ) ; | ||
11470 | public final void rule__ALSQuantified__Group_0__3__Impl() throws RecognitionException { | ||
11471 | |||
11472 | int stackSize = keepStackSize(); | ||
11473 | |||
11474 | try { | ||
11475 | // InternalAlloyLanguage.g:3793:1: ( ( ( rule__ALSQuantified__VariablesAssignment_0_3 ) ) ) | ||
11476 | // InternalAlloyLanguage.g:3794:1: ( ( rule__ALSQuantified__VariablesAssignment_0_3 ) ) | ||
11477 | { | ||
11478 | // InternalAlloyLanguage.g:3794:1: ( ( rule__ALSQuantified__VariablesAssignment_0_3 ) ) | ||
11479 | // InternalAlloyLanguage.g:3795:1: ( rule__ALSQuantified__VariablesAssignment_0_3 ) | ||
11480 | { | ||
11481 | if ( state.backtracking==0 ) { | ||
11482 | before(grammarAccess.getALSQuantifiedAccess().getVariablesAssignment_0_3()); | ||
11483 | } | ||
11484 | // InternalAlloyLanguage.g:3796:1: ( rule__ALSQuantified__VariablesAssignment_0_3 ) | ||
11485 | // InternalAlloyLanguage.g:3796:2: rule__ALSQuantified__VariablesAssignment_0_3 | ||
11486 | { | ||
11487 | pushFollow(FOLLOW_2); | ||
11488 | rule__ALSQuantified__VariablesAssignment_0_3(); | ||
11489 | |||
11490 | state._fsp--; | ||
11491 | if (state.failed) return ; | ||
11492 | |||
11493 | } | ||
11494 | |||
11495 | if ( state.backtracking==0 ) { | ||
11496 | after(grammarAccess.getALSQuantifiedAccess().getVariablesAssignment_0_3()); | ||
11497 | } | ||
11498 | |||
11499 | } | ||
11500 | |||
11501 | |||
11502 | } | ||
11503 | |||
11504 | } | ||
11505 | catch (RecognitionException re) { | ||
11506 | reportError(re); | ||
11507 | recover(input,re); | ||
11508 | } | ||
11509 | finally { | ||
11510 | |||
11511 | restoreStackSize(stackSize); | ||
11512 | |||
11513 | } | ||
11514 | return ; | ||
11515 | } | ||
11516 | // $ANTLR end "rule__ALSQuantified__Group_0__3__Impl" | ||
11517 | |||
11518 | |||
11519 | // $ANTLR start "rule__ALSQuantified__Group_0__4" | ||
11520 | // InternalAlloyLanguage.g:3806:1: rule__ALSQuantified__Group_0__4 : rule__ALSQuantified__Group_0__4__Impl rule__ALSQuantified__Group_0__5 ; | ||
11521 | public final void rule__ALSQuantified__Group_0__4() throws RecognitionException { | ||
11522 | |||
11523 | int stackSize = keepStackSize(); | ||
11524 | |||
11525 | try { | ||
11526 | // InternalAlloyLanguage.g:3810:1: ( rule__ALSQuantified__Group_0__4__Impl rule__ALSQuantified__Group_0__5 ) | ||
11527 | // InternalAlloyLanguage.g:3811:2: rule__ALSQuantified__Group_0__4__Impl rule__ALSQuantified__Group_0__5 | ||
11528 | { | ||
11529 | pushFollow(FOLLOW_24); | ||
11530 | rule__ALSQuantified__Group_0__4__Impl(); | ||
11531 | |||
11532 | state._fsp--; | ||
11533 | if (state.failed) return ; | ||
11534 | pushFollow(FOLLOW_2); | ||
11535 | rule__ALSQuantified__Group_0__5(); | ||
11536 | |||
11537 | state._fsp--; | ||
11538 | if (state.failed) return ; | ||
11539 | |||
11540 | } | ||
11541 | |||
11542 | } | ||
11543 | catch (RecognitionException re) { | ||
11544 | reportError(re); | ||
11545 | recover(input,re); | ||
11546 | } | ||
11547 | finally { | ||
11548 | |||
11549 | restoreStackSize(stackSize); | ||
11550 | |||
11551 | } | ||
11552 | return ; | ||
11553 | } | ||
11554 | // $ANTLR end "rule__ALSQuantified__Group_0__4" | ||
11555 | |||
11556 | |||
11557 | // $ANTLR start "rule__ALSQuantified__Group_0__4__Impl" | ||
11558 | // InternalAlloyLanguage.g:3818:1: rule__ALSQuantified__Group_0__4__Impl : ( ( rule__ALSQuantified__Group_0_4__0 )* ) ; | ||
11559 | public final void rule__ALSQuantified__Group_0__4__Impl() throws RecognitionException { | ||
11560 | |||
11561 | int stackSize = keepStackSize(); | ||
11562 | |||
11563 | try { | ||
11564 | // InternalAlloyLanguage.g:3822:1: ( ( ( rule__ALSQuantified__Group_0_4__0 )* ) ) | ||
11565 | // InternalAlloyLanguage.g:3823:1: ( ( rule__ALSQuantified__Group_0_4__0 )* ) | ||
11566 | { | ||
11567 | // InternalAlloyLanguage.g:3823:1: ( ( rule__ALSQuantified__Group_0_4__0 )* ) | ||
11568 | // InternalAlloyLanguage.g:3824:1: ( rule__ALSQuantified__Group_0_4__0 )* | ||
11569 | { | ||
11570 | if ( state.backtracking==0 ) { | ||
11571 | before(grammarAccess.getALSQuantifiedAccess().getGroup_0_4()); | ||
11572 | } | ||
11573 | // InternalAlloyLanguage.g:3825:1: ( rule__ALSQuantified__Group_0_4__0 )* | ||
11574 | loop29: | ||
11575 | do { | ||
11576 | int alt29=2; | ||
11577 | int LA29_0 = input.LA(1); | ||
11578 | |||
11579 | if ( (LA29_0==35) ) { | ||
11580 | alt29=1; | ||
11581 | } | ||
11582 | |||
11583 | |||
11584 | switch (alt29) { | ||
11585 | case 1 : | ||
11586 | // InternalAlloyLanguage.g:3825:2: rule__ALSQuantified__Group_0_4__0 | ||
11587 | { | ||
11588 | pushFollow(FOLLOW_8); | ||
11589 | rule__ALSQuantified__Group_0_4__0(); | ||
11590 | |||
11591 | state._fsp--; | ||
11592 | if (state.failed) return ; | ||
11593 | |||
11594 | } | ||
11595 | break; | ||
11596 | |||
11597 | default : | ||
11598 | break loop29; | ||
11599 | } | ||
11600 | } while (true); | ||
11601 | |||
11602 | if ( state.backtracking==0 ) { | ||
11603 | after(grammarAccess.getALSQuantifiedAccess().getGroup_0_4()); | ||
11604 | } | ||
11605 | |||
11606 | } | ||
11607 | |||
11608 | |||
11609 | } | ||
11610 | |||
11611 | } | ||
11612 | catch (RecognitionException re) { | ||
11613 | reportError(re); | ||
11614 | recover(input,re); | ||
11615 | } | ||
11616 | finally { | ||
11617 | |||
11618 | restoreStackSize(stackSize); | ||
11619 | |||
11620 | } | ||
11621 | return ; | ||
11622 | } | ||
11623 | // $ANTLR end "rule__ALSQuantified__Group_0__4__Impl" | ||
11624 | |||
11625 | |||
11626 | // $ANTLR start "rule__ALSQuantified__Group_0__5" | ||
11627 | // InternalAlloyLanguage.g:3835:1: rule__ALSQuantified__Group_0__5 : rule__ALSQuantified__Group_0__5__Impl rule__ALSQuantified__Group_0__6 ; | ||
11628 | public final void rule__ALSQuantified__Group_0__5() throws RecognitionException { | ||
11629 | |||
11630 | int stackSize = keepStackSize(); | ||
11631 | |||
11632 | try { | ||
11633 | // InternalAlloyLanguage.g:3839:1: ( rule__ALSQuantified__Group_0__5__Impl rule__ALSQuantified__Group_0__6 ) | ||
11634 | // InternalAlloyLanguage.g:3840:2: rule__ALSQuantified__Group_0__5__Impl rule__ALSQuantified__Group_0__6 | ||
11635 | { | ||
11636 | pushFollow(FOLLOW_16); | ||
11637 | rule__ALSQuantified__Group_0__5__Impl(); | ||
11638 | |||
11639 | state._fsp--; | ||
11640 | if (state.failed) return ; | ||
11641 | pushFollow(FOLLOW_2); | ||
11642 | rule__ALSQuantified__Group_0__6(); | ||
11643 | |||
11644 | state._fsp--; | ||
11645 | if (state.failed) return ; | ||
11646 | |||
11647 | } | ||
11648 | |||
11649 | } | ||
11650 | catch (RecognitionException re) { | ||
11651 | reportError(re); | ||
11652 | recover(input,re); | ||
11653 | } | ||
11654 | finally { | ||
11655 | |||
11656 | restoreStackSize(stackSize); | ||
11657 | |||
11658 | } | ||
11659 | return ; | ||
11660 | } | ||
11661 | // $ANTLR end "rule__ALSQuantified__Group_0__5" | ||
11662 | |||
11663 | |||
11664 | // $ANTLR start "rule__ALSQuantified__Group_0__5__Impl" | ||
11665 | // InternalAlloyLanguage.g:3847:1: rule__ALSQuantified__Group_0__5__Impl : ( '{' ) ; | ||
11666 | public final void rule__ALSQuantified__Group_0__5__Impl() throws RecognitionException { | ||
11667 | |||
11668 | int stackSize = keepStackSize(); | ||
11669 | |||
11670 | try { | ||
11671 | // InternalAlloyLanguage.g:3851:1: ( ( '{' ) ) | ||
11672 | // InternalAlloyLanguage.g:3852:1: ( '{' ) | ||
11673 | { | ||
11674 | // InternalAlloyLanguage.g:3852:1: ( '{' ) | ||
11675 | // InternalAlloyLanguage.g:3853:1: '{' | ||
11676 | { | ||
11677 | if ( state.backtracking==0 ) { | ||
11678 | before(grammarAccess.getALSQuantifiedAccess().getLeftCurlyBracketKeyword_0_5()); | ||
11679 | } | ||
11680 | match(input,33,FOLLOW_2); if (state.failed) return ; | ||
11681 | if ( state.backtracking==0 ) { | ||
11682 | after(grammarAccess.getALSQuantifiedAccess().getLeftCurlyBracketKeyword_0_5()); | ||
11683 | } | ||
11684 | |||
11685 | } | ||
11686 | |||
11687 | |||
11688 | } | ||
11689 | |||
11690 | } | ||
11691 | catch (RecognitionException re) { | ||
11692 | reportError(re); | ||
11693 | recover(input,re); | ||
11694 | } | ||
11695 | finally { | ||
11696 | |||
11697 | restoreStackSize(stackSize); | ||
11698 | |||
11699 | } | ||
11700 | return ; | ||
11701 | } | ||
11702 | // $ANTLR end "rule__ALSQuantified__Group_0__5__Impl" | ||
11703 | |||
11704 | |||
11705 | // $ANTLR start "rule__ALSQuantified__Group_0__6" | ||
11706 | // InternalAlloyLanguage.g:3866:1: rule__ALSQuantified__Group_0__6 : rule__ALSQuantified__Group_0__6__Impl rule__ALSQuantified__Group_0__7 ; | ||
11707 | public final void rule__ALSQuantified__Group_0__6() throws RecognitionException { | ||
11708 | |||
11709 | int stackSize = keepStackSize(); | ||
11710 | |||
11711 | try { | ||
11712 | // InternalAlloyLanguage.g:3870:1: ( rule__ALSQuantified__Group_0__6__Impl rule__ALSQuantified__Group_0__7 ) | ||
11713 | // InternalAlloyLanguage.g:3871:2: rule__ALSQuantified__Group_0__6__Impl rule__ALSQuantified__Group_0__7 | ||
11714 | { | ||
11715 | pushFollow(FOLLOW_19); | ||
11716 | rule__ALSQuantified__Group_0__6__Impl(); | ||
11717 | |||
11718 | state._fsp--; | ||
11719 | if (state.failed) return ; | ||
11720 | pushFollow(FOLLOW_2); | ||
11721 | rule__ALSQuantified__Group_0__7(); | ||
11722 | |||
11723 | state._fsp--; | ||
11724 | if (state.failed) return ; | ||
11725 | |||
11726 | } | ||
11727 | |||
11728 | } | ||
11729 | catch (RecognitionException re) { | ||
11730 | reportError(re); | ||
11731 | recover(input,re); | ||
11732 | } | ||
11733 | finally { | ||
11734 | |||
11735 | restoreStackSize(stackSize); | ||
11736 | |||
11737 | } | ||
11738 | return ; | ||
11739 | } | ||
11740 | // $ANTLR end "rule__ALSQuantified__Group_0__6" | ||
11741 | |||
11742 | |||
11743 | // $ANTLR start "rule__ALSQuantified__Group_0__6__Impl" | ||
11744 | // InternalAlloyLanguage.g:3878:1: rule__ALSQuantified__Group_0__6__Impl : ( ( rule__ALSQuantified__ExpressionAssignment_0_6 ) ) ; | ||
11745 | public final void rule__ALSQuantified__Group_0__6__Impl() throws RecognitionException { | ||
11746 | |||
11747 | int stackSize = keepStackSize(); | ||
11748 | |||
11749 | try { | ||
11750 | // InternalAlloyLanguage.g:3882:1: ( ( ( rule__ALSQuantified__ExpressionAssignment_0_6 ) ) ) | ||
11751 | // InternalAlloyLanguage.g:3883:1: ( ( rule__ALSQuantified__ExpressionAssignment_0_6 ) ) | ||
11752 | { | ||
11753 | // InternalAlloyLanguage.g:3883:1: ( ( rule__ALSQuantified__ExpressionAssignment_0_6 ) ) | ||
11754 | // InternalAlloyLanguage.g:3884:1: ( rule__ALSQuantified__ExpressionAssignment_0_6 ) | ||
11755 | { | ||
11756 | if ( state.backtracking==0 ) { | ||
11757 | before(grammarAccess.getALSQuantifiedAccess().getExpressionAssignment_0_6()); | ||
11758 | } | ||
11759 | // InternalAlloyLanguage.g:3885:1: ( rule__ALSQuantified__ExpressionAssignment_0_6 ) | ||
11760 | // InternalAlloyLanguage.g:3885:2: rule__ALSQuantified__ExpressionAssignment_0_6 | ||
11761 | { | ||
11762 | pushFollow(FOLLOW_2); | ||
11763 | rule__ALSQuantified__ExpressionAssignment_0_6(); | ||
11764 | |||
11765 | state._fsp--; | ||
11766 | if (state.failed) return ; | ||
11767 | |||
11768 | } | ||
11769 | |||
11770 | if ( state.backtracking==0 ) { | ||
11771 | after(grammarAccess.getALSQuantifiedAccess().getExpressionAssignment_0_6()); | ||
11772 | } | ||
11773 | |||
11774 | } | ||
11775 | |||
11776 | |||
11777 | } | ||
11778 | |||
11779 | } | ||
11780 | catch (RecognitionException re) { | ||
11781 | reportError(re); | ||
11782 | recover(input,re); | ||
11783 | } | ||
11784 | finally { | ||
11785 | |||
11786 | restoreStackSize(stackSize); | ||
11787 | |||
11788 | } | ||
11789 | return ; | ||
11790 | } | ||
11791 | // $ANTLR end "rule__ALSQuantified__Group_0__6__Impl" | ||
11792 | |||
11793 | |||
11794 | // $ANTLR start "rule__ALSQuantified__Group_0__7" | ||
11795 | // InternalAlloyLanguage.g:3895:1: rule__ALSQuantified__Group_0__7 : rule__ALSQuantified__Group_0__7__Impl ; | ||
11796 | public final void rule__ALSQuantified__Group_0__7() throws RecognitionException { | ||
11797 | |||
11798 | int stackSize = keepStackSize(); | ||
11799 | |||
11800 | try { | ||
11801 | // InternalAlloyLanguage.g:3899:1: ( rule__ALSQuantified__Group_0__7__Impl ) | ||
11802 | // InternalAlloyLanguage.g:3900:2: rule__ALSQuantified__Group_0__7__Impl | ||
11803 | { | ||
11804 | pushFollow(FOLLOW_2); | ||
11805 | rule__ALSQuantified__Group_0__7__Impl(); | ||
11806 | |||
11807 | state._fsp--; | ||
11808 | if (state.failed) return ; | ||
11809 | |||
11810 | } | ||
11811 | |||
11812 | } | ||
11813 | catch (RecognitionException re) { | ||
11814 | reportError(re); | ||
11815 | recover(input,re); | ||
11816 | } | ||
11817 | finally { | ||
11818 | |||
11819 | restoreStackSize(stackSize); | ||
11820 | |||
11821 | } | ||
11822 | return ; | ||
11823 | } | ||
11824 | // $ANTLR end "rule__ALSQuantified__Group_0__7" | ||
11825 | |||
11826 | |||
11827 | // $ANTLR start "rule__ALSQuantified__Group_0__7__Impl" | ||
11828 | // InternalAlloyLanguage.g:3906:1: rule__ALSQuantified__Group_0__7__Impl : ( '}' ) ; | ||
11829 | public final void rule__ALSQuantified__Group_0__7__Impl() throws RecognitionException { | ||
11830 | |||
11831 | int stackSize = keepStackSize(); | ||
11832 | |||
11833 | try { | ||
11834 | // InternalAlloyLanguage.g:3910:1: ( ( '}' ) ) | ||
11835 | // InternalAlloyLanguage.g:3911:1: ( '}' ) | ||
11836 | { | ||
11837 | // InternalAlloyLanguage.g:3911:1: ( '}' ) | ||
11838 | // InternalAlloyLanguage.g:3912:1: '}' | ||
11839 | { | ||
11840 | if ( state.backtracking==0 ) { | ||
11841 | before(grammarAccess.getALSQuantifiedAccess().getRightCurlyBracketKeyword_0_7()); | ||
11842 | } | ||
11843 | match(input,34,FOLLOW_2); if (state.failed) return ; | ||
11844 | if ( state.backtracking==0 ) { | ||
11845 | after(grammarAccess.getALSQuantifiedAccess().getRightCurlyBracketKeyword_0_7()); | ||
11846 | } | ||
11847 | |||
11848 | } | ||
11849 | |||
11850 | |||
11851 | } | ||
11852 | |||
11853 | } | ||
11854 | catch (RecognitionException re) { | ||
11855 | reportError(re); | ||
11856 | recover(input,re); | ||
11857 | } | ||
11858 | finally { | ||
11859 | |||
11860 | restoreStackSize(stackSize); | ||
11861 | |||
11862 | } | ||
11863 | return ; | ||
11864 | } | ||
11865 | // $ANTLR end "rule__ALSQuantified__Group_0__7__Impl" | ||
11866 | |||
11867 | |||
11868 | // $ANTLR start "rule__ALSQuantified__Group_0_4__0" | ||
11869 | // InternalAlloyLanguage.g:3941:1: rule__ALSQuantified__Group_0_4__0 : rule__ALSQuantified__Group_0_4__0__Impl rule__ALSQuantified__Group_0_4__1 ; | ||
11870 | public final void rule__ALSQuantified__Group_0_4__0() throws RecognitionException { | ||
11871 | |||
11872 | int stackSize = keepStackSize(); | ||
11873 | |||
11874 | try { | ||
11875 | // InternalAlloyLanguage.g:3945:1: ( rule__ALSQuantified__Group_0_4__0__Impl rule__ALSQuantified__Group_0_4__1 ) | ||
11876 | // InternalAlloyLanguage.g:3946:2: rule__ALSQuantified__Group_0_4__0__Impl rule__ALSQuantified__Group_0_4__1 | ||
11877 | { | ||
11878 | pushFollow(FOLLOW_5); | ||
11879 | rule__ALSQuantified__Group_0_4__0__Impl(); | ||
11880 | |||
11881 | state._fsp--; | ||
11882 | if (state.failed) return ; | ||
11883 | pushFollow(FOLLOW_2); | ||
11884 | rule__ALSQuantified__Group_0_4__1(); | ||
11885 | |||
11886 | state._fsp--; | ||
11887 | if (state.failed) return ; | ||
11888 | |||
11889 | } | ||
11890 | |||
11891 | } | ||
11892 | catch (RecognitionException re) { | ||
11893 | reportError(re); | ||
11894 | recover(input,re); | ||
11895 | } | ||
11896 | finally { | ||
11897 | |||
11898 | restoreStackSize(stackSize); | ||
11899 | |||
11900 | } | ||
11901 | return ; | ||
11902 | } | ||
11903 | // $ANTLR end "rule__ALSQuantified__Group_0_4__0" | ||
11904 | |||
11905 | |||
11906 | // $ANTLR start "rule__ALSQuantified__Group_0_4__0__Impl" | ||
11907 | // InternalAlloyLanguage.g:3953:1: rule__ALSQuantified__Group_0_4__0__Impl : ( ',' ) ; | ||
11908 | public final void rule__ALSQuantified__Group_0_4__0__Impl() throws RecognitionException { | ||
11909 | |||
11910 | int stackSize = keepStackSize(); | ||
11911 | |||
11912 | try { | ||
11913 | // InternalAlloyLanguage.g:3957:1: ( ( ',' ) ) | ||
11914 | // InternalAlloyLanguage.g:3958:1: ( ',' ) | ||
11915 | { | ||
11916 | // InternalAlloyLanguage.g:3958:1: ( ',' ) | ||
11917 | // InternalAlloyLanguage.g:3959:1: ',' | ||
11918 | { | ||
11919 | if ( state.backtracking==0 ) { | ||
11920 | before(grammarAccess.getALSQuantifiedAccess().getCommaKeyword_0_4_0()); | ||
11921 | } | ||
11922 | match(input,35,FOLLOW_2); if (state.failed) return ; | ||
11923 | if ( state.backtracking==0 ) { | ||
11924 | after(grammarAccess.getALSQuantifiedAccess().getCommaKeyword_0_4_0()); | ||
11925 | } | ||
11926 | |||
11927 | } | ||
11928 | |||
11929 | |||
11930 | } | ||
11931 | |||
11932 | } | ||
11933 | catch (RecognitionException re) { | ||
11934 | reportError(re); | ||
11935 | recover(input,re); | ||
11936 | } | ||
11937 | finally { | ||
11938 | |||
11939 | restoreStackSize(stackSize); | ||
11940 | |||
11941 | } | ||
11942 | return ; | ||
11943 | } | ||
11944 | // $ANTLR end "rule__ALSQuantified__Group_0_4__0__Impl" | ||
11945 | |||
11946 | |||
11947 | // $ANTLR start "rule__ALSQuantified__Group_0_4__1" | ||
11948 | // InternalAlloyLanguage.g:3972:1: rule__ALSQuantified__Group_0_4__1 : rule__ALSQuantified__Group_0_4__1__Impl ; | ||
11949 | public final void rule__ALSQuantified__Group_0_4__1() throws RecognitionException { | ||
11950 | |||
11951 | int stackSize = keepStackSize(); | ||
11952 | |||
11953 | try { | ||
11954 | // InternalAlloyLanguage.g:3976:1: ( rule__ALSQuantified__Group_0_4__1__Impl ) | ||
11955 | // InternalAlloyLanguage.g:3977:2: rule__ALSQuantified__Group_0_4__1__Impl | ||
11956 | { | ||
11957 | pushFollow(FOLLOW_2); | ||
11958 | rule__ALSQuantified__Group_0_4__1__Impl(); | ||
11959 | |||
11960 | state._fsp--; | ||
11961 | if (state.failed) return ; | ||
11962 | |||
11963 | } | ||
11964 | |||
11965 | } | ||
11966 | catch (RecognitionException re) { | ||
11967 | reportError(re); | ||
11968 | recover(input,re); | ||
11969 | } | ||
11970 | finally { | ||
11971 | |||
11972 | restoreStackSize(stackSize); | ||
11973 | |||
11974 | } | ||
11975 | return ; | ||
11976 | } | ||
11977 | // $ANTLR end "rule__ALSQuantified__Group_0_4__1" | ||
11978 | |||
11979 | |||
11980 | // $ANTLR start "rule__ALSQuantified__Group_0_4__1__Impl" | ||
11981 | // InternalAlloyLanguage.g:3983:1: rule__ALSQuantified__Group_0_4__1__Impl : ( ( rule__ALSQuantified__VariablesAssignment_0_4_1 ) ) ; | ||
11982 | public final void rule__ALSQuantified__Group_0_4__1__Impl() throws RecognitionException { | ||
11983 | |||
11984 | int stackSize = keepStackSize(); | ||
11985 | |||
11986 | try { | ||
11987 | // InternalAlloyLanguage.g:3987:1: ( ( ( rule__ALSQuantified__VariablesAssignment_0_4_1 ) ) ) | ||
11988 | // InternalAlloyLanguage.g:3988:1: ( ( rule__ALSQuantified__VariablesAssignment_0_4_1 ) ) | ||
11989 | { | ||
11990 | // InternalAlloyLanguage.g:3988:1: ( ( rule__ALSQuantified__VariablesAssignment_0_4_1 ) ) | ||
11991 | // InternalAlloyLanguage.g:3989:1: ( rule__ALSQuantified__VariablesAssignment_0_4_1 ) | ||
11992 | { | ||
11993 | if ( state.backtracking==0 ) { | ||
11994 | before(grammarAccess.getALSQuantifiedAccess().getVariablesAssignment_0_4_1()); | ||
11995 | } | ||
11996 | // InternalAlloyLanguage.g:3990:1: ( rule__ALSQuantified__VariablesAssignment_0_4_1 ) | ||
11997 | // InternalAlloyLanguage.g:3990:2: rule__ALSQuantified__VariablesAssignment_0_4_1 | ||
11998 | { | ||
11999 | pushFollow(FOLLOW_2); | ||
12000 | rule__ALSQuantified__VariablesAssignment_0_4_1(); | ||
12001 | |||
12002 | state._fsp--; | ||
12003 | if (state.failed) return ; | ||
12004 | |||
12005 | } | ||
12006 | |||
12007 | if ( state.backtracking==0 ) { | ||
12008 | after(grammarAccess.getALSQuantifiedAccess().getVariablesAssignment_0_4_1()); | ||
12009 | } | ||
12010 | |||
12011 | } | ||
12012 | |||
12013 | |||
12014 | } | ||
12015 | |||
12016 | } | ||
12017 | catch (RecognitionException re) { | ||
12018 | reportError(re); | ||
12019 | recover(input,re); | ||
12020 | } | ||
12021 | finally { | ||
12022 | |||
12023 | restoreStackSize(stackSize); | ||
12024 | |||
12025 | } | ||
12026 | return ; | ||
12027 | } | ||
12028 | // $ANTLR end "rule__ALSQuantified__Group_0_4__1__Impl" | ||
12029 | |||
12030 | |||
12031 | // $ANTLR start "rule__ALSOr__Group__0" | ||
12032 | // InternalAlloyLanguage.g:4004:1: rule__ALSOr__Group__0 : rule__ALSOr__Group__0__Impl rule__ALSOr__Group__1 ; | ||
12033 | public final void rule__ALSOr__Group__0() throws RecognitionException { | ||
12034 | |||
12035 | int stackSize = keepStackSize(); | ||
12036 | |||
12037 | try { | ||
12038 | // InternalAlloyLanguage.g:4008:1: ( rule__ALSOr__Group__0__Impl rule__ALSOr__Group__1 ) | ||
12039 | // InternalAlloyLanguage.g:4009:2: rule__ALSOr__Group__0__Impl rule__ALSOr__Group__1 | ||
12040 | { | ||
12041 | pushFollow(FOLLOW_25); | ||
12042 | rule__ALSOr__Group__0__Impl(); | ||
12043 | |||
12044 | state._fsp--; | ||
12045 | if (state.failed) return ; | ||
12046 | pushFollow(FOLLOW_2); | ||
12047 | rule__ALSOr__Group__1(); | ||
12048 | |||
12049 | state._fsp--; | ||
12050 | if (state.failed) return ; | ||
12051 | |||
12052 | } | ||
12053 | |||
12054 | } | ||
12055 | catch (RecognitionException re) { | ||
12056 | reportError(re); | ||
12057 | recover(input,re); | ||
12058 | } | ||
12059 | finally { | ||
12060 | |||
12061 | restoreStackSize(stackSize); | ||
12062 | |||
12063 | } | ||
12064 | return ; | ||
12065 | } | ||
12066 | // $ANTLR end "rule__ALSOr__Group__0" | ||
12067 | |||
12068 | |||
12069 | // $ANTLR start "rule__ALSOr__Group__0__Impl" | ||
12070 | // InternalAlloyLanguage.g:4016:1: rule__ALSOr__Group__0__Impl : ( ruleALSIff ) ; | ||
12071 | public final void rule__ALSOr__Group__0__Impl() throws RecognitionException { | ||
12072 | |||
12073 | int stackSize = keepStackSize(); | ||
12074 | |||
12075 | try { | ||
12076 | // InternalAlloyLanguage.g:4020:1: ( ( ruleALSIff ) ) | ||
12077 | // InternalAlloyLanguage.g:4021:1: ( ruleALSIff ) | ||
12078 | { | ||
12079 | // InternalAlloyLanguage.g:4021:1: ( ruleALSIff ) | ||
12080 | // InternalAlloyLanguage.g:4022:1: ruleALSIff | ||
12081 | { | ||
12082 | if ( state.backtracking==0 ) { | ||
12083 | before(grammarAccess.getALSOrAccess().getALSIffParserRuleCall_0()); | ||
12084 | } | ||
12085 | pushFollow(FOLLOW_2); | ||
12086 | ruleALSIff(); | ||
12087 | |||
12088 | state._fsp--; | ||
12089 | if (state.failed) return ; | ||
12090 | if ( state.backtracking==0 ) { | ||
12091 | after(grammarAccess.getALSOrAccess().getALSIffParserRuleCall_0()); | ||
12092 | } | ||
12093 | |||
12094 | } | ||
12095 | |||
12096 | |||
12097 | } | ||
12098 | |||
12099 | } | ||
12100 | catch (RecognitionException re) { | ||
12101 | reportError(re); | ||
12102 | recover(input,re); | ||
12103 | } | ||
12104 | finally { | ||
12105 | |||
12106 | restoreStackSize(stackSize); | ||
12107 | |||
12108 | } | ||
12109 | return ; | ||
12110 | } | ||
12111 | // $ANTLR end "rule__ALSOr__Group__0__Impl" | ||
12112 | |||
12113 | |||
12114 | // $ANTLR start "rule__ALSOr__Group__1" | ||
12115 | // InternalAlloyLanguage.g:4033:1: rule__ALSOr__Group__1 : rule__ALSOr__Group__1__Impl ; | ||
12116 | public final void rule__ALSOr__Group__1() throws RecognitionException { | ||
12117 | |||
12118 | int stackSize = keepStackSize(); | ||
12119 | |||
12120 | try { | ||
12121 | // InternalAlloyLanguage.g:4037:1: ( rule__ALSOr__Group__1__Impl ) | ||
12122 | // InternalAlloyLanguage.g:4038:2: rule__ALSOr__Group__1__Impl | ||
12123 | { | ||
12124 | pushFollow(FOLLOW_2); | ||
12125 | rule__ALSOr__Group__1__Impl(); | ||
12126 | |||
12127 | state._fsp--; | ||
12128 | if (state.failed) return ; | ||
12129 | |||
12130 | } | ||
12131 | |||
12132 | } | ||
12133 | catch (RecognitionException re) { | ||
12134 | reportError(re); | ||
12135 | recover(input,re); | ||
12136 | } | ||
12137 | finally { | ||
12138 | |||
12139 | restoreStackSize(stackSize); | ||
12140 | |||
12141 | } | ||
12142 | return ; | ||
12143 | } | ||
12144 | // $ANTLR end "rule__ALSOr__Group__1" | ||
12145 | |||
12146 | |||
12147 | // $ANTLR start "rule__ALSOr__Group__1__Impl" | ||
12148 | // InternalAlloyLanguage.g:4044:1: rule__ALSOr__Group__1__Impl : ( ( rule__ALSOr__Group_1__0 )? ) ; | ||
12149 | public final void rule__ALSOr__Group__1__Impl() throws RecognitionException { | ||
12150 | |||
12151 | int stackSize = keepStackSize(); | ||
12152 | |||
12153 | try { | ||
12154 | // InternalAlloyLanguage.g:4048:1: ( ( ( rule__ALSOr__Group_1__0 )? ) ) | ||
12155 | // InternalAlloyLanguage.g:4049:1: ( ( rule__ALSOr__Group_1__0 )? ) | ||
12156 | { | ||
12157 | // InternalAlloyLanguage.g:4049:1: ( ( rule__ALSOr__Group_1__0 )? ) | ||
12158 | // InternalAlloyLanguage.g:4050:1: ( rule__ALSOr__Group_1__0 )? | ||
12159 | { | ||
12160 | if ( state.backtracking==0 ) { | ||
12161 | before(grammarAccess.getALSOrAccess().getGroup_1()); | ||
12162 | } | ||
12163 | // InternalAlloyLanguage.g:4051:1: ( rule__ALSOr__Group_1__0 )? | ||
12164 | int alt30=2; | ||
12165 | int LA30_0 = input.LA(1); | ||
12166 | |||
12167 | if ( ((LA30_0>=11 && LA30_0<=12)) ) { | ||
12168 | alt30=1; | ||
12169 | } | ||
12170 | switch (alt30) { | ||
12171 | case 1 : | ||
12172 | // InternalAlloyLanguage.g:4051:2: rule__ALSOr__Group_1__0 | ||
12173 | { | ||
12174 | pushFollow(FOLLOW_2); | ||
12175 | rule__ALSOr__Group_1__0(); | ||
12176 | |||
12177 | state._fsp--; | ||
12178 | if (state.failed) return ; | ||
12179 | |||
12180 | } | ||
12181 | break; | ||
12182 | |||
12183 | } | ||
12184 | |||
12185 | if ( state.backtracking==0 ) { | ||
12186 | after(grammarAccess.getALSOrAccess().getGroup_1()); | ||
12187 | } | ||
12188 | |||
12189 | } | ||
12190 | |||
12191 | |||
12192 | } | ||
12193 | |||
12194 | } | ||
12195 | catch (RecognitionException re) { | ||
12196 | reportError(re); | ||
12197 | recover(input,re); | ||
12198 | } | ||
12199 | finally { | ||
12200 | |||
12201 | restoreStackSize(stackSize); | ||
12202 | |||
12203 | } | ||
12204 | return ; | ||
12205 | } | ||
12206 | // $ANTLR end "rule__ALSOr__Group__1__Impl" | ||
12207 | |||
12208 | |||
12209 | // $ANTLR start "rule__ALSOr__Group_1__0" | ||
12210 | // InternalAlloyLanguage.g:4065:1: rule__ALSOr__Group_1__0 : rule__ALSOr__Group_1__0__Impl rule__ALSOr__Group_1__1 ; | ||
12211 | public final void rule__ALSOr__Group_1__0() throws RecognitionException { | ||
12212 | |||
12213 | int stackSize = keepStackSize(); | ||
12214 | |||
12215 | try { | ||
12216 | // InternalAlloyLanguage.g:4069:1: ( rule__ALSOr__Group_1__0__Impl rule__ALSOr__Group_1__1 ) | ||
12217 | // InternalAlloyLanguage.g:4070:2: rule__ALSOr__Group_1__0__Impl rule__ALSOr__Group_1__1 | ||
12218 | { | ||
12219 | pushFollow(FOLLOW_25); | ||
12220 | rule__ALSOr__Group_1__0__Impl(); | ||
12221 | |||
12222 | state._fsp--; | ||
12223 | if (state.failed) return ; | ||
12224 | pushFollow(FOLLOW_2); | ||
12225 | rule__ALSOr__Group_1__1(); | ||
12226 | |||
12227 | state._fsp--; | ||
12228 | if (state.failed) return ; | ||
12229 | |||
12230 | } | ||
12231 | |||
12232 | } | ||
12233 | catch (RecognitionException re) { | ||
12234 | reportError(re); | ||
12235 | recover(input,re); | ||
12236 | } | ||
12237 | finally { | ||
12238 | |||
12239 | restoreStackSize(stackSize); | ||
12240 | |||
12241 | } | ||
12242 | return ; | ||
12243 | } | ||
12244 | // $ANTLR end "rule__ALSOr__Group_1__0" | ||
12245 | |||
12246 | |||
12247 | // $ANTLR start "rule__ALSOr__Group_1__0__Impl" | ||
12248 | // InternalAlloyLanguage.g:4077:1: rule__ALSOr__Group_1__0__Impl : ( () ) ; | ||
12249 | public final void rule__ALSOr__Group_1__0__Impl() throws RecognitionException { | ||
12250 | |||
12251 | int stackSize = keepStackSize(); | ||
12252 | |||
12253 | try { | ||
12254 | // InternalAlloyLanguage.g:4081:1: ( ( () ) ) | ||
12255 | // InternalAlloyLanguage.g:4082:1: ( () ) | ||
12256 | { | ||
12257 | // InternalAlloyLanguage.g:4082:1: ( () ) | ||
12258 | // InternalAlloyLanguage.g:4083:1: () | ||
12259 | { | ||
12260 | if ( state.backtracking==0 ) { | ||
12261 | before(grammarAccess.getALSOrAccess().getALSOrLeftOperandAction_1_0()); | ||
12262 | } | ||
12263 | // InternalAlloyLanguage.g:4084:1: () | ||
12264 | // InternalAlloyLanguage.g:4086:1: | ||
12265 | { | ||
12266 | } | ||
12267 | |||
12268 | if ( state.backtracking==0 ) { | ||
12269 | after(grammarAccess.getALSOrAccess().getALSOrLeftOperandAction_1_0()); | ||
12270 | } | ||
12271 | |||
12272 | } | ||
12273 | |||
12274 | |||
12275 | } | ||
12276 | |||
12277 | } | ||
12278 | finally { | ||
12279 | |||
12280 | restoreStackSize(stackSize); | ||
12281 | |||
12282 | } | ||
12283 | return ; | ||
12284 | } | ||
12285 | // $ANTLR end "rule__ALSOr__Group_1__0__Impl" | ||
12286 | |||
12287 | |||
12288 | // $ANTLR start "rule__ALSOr__Group_1__1" | ||
12289 | // InternalAlloyLanguage.g:4096:1: rule__ALSOr__Group_1__1 : rule__ALSOr__Group_1__1__Impl rule__ALSOr__Group_1__2 ; | ||
12290 | public final void rule__ALSOr__Group_1__1() throws RecognitionException { | ||
12291 | |||
12292 | int stackSize = keepStackSize(); | ||
12293 | |||
12294 | try { | ||
12295 | // InternalAlloyLanguage.g:4100:1: ( rule__ALSOr__Group_1__1__Impl rule__ALSOr__Group_1__2 ) | ||
12296 | // InternalAlloyLanguage.g:4101:2: rule__ALSOr__Group_1__1__Impl rule__ALSOr__Group_1__2 | ||
12297 | { | ||
12298 | pushFollow(FOLLOW_16); | ||
12299 | rule__ALSOr__Group_1__1__Impl(); | ||
12300 | |||
12301 | state._fsp--; | ||
12302 | if (state.failed) return ; | ||
12303 | pushFollow(FOLLOW_2); | ||
12304 | rule__ALSOr__Group_1__2(); | ||
12305 | |||
12306 | state._fsp--; | ||
12307 | if (state.failed) return ; | ||
12308 | |||
12309 | } | ||
12310 | |||
12311 | } | ||
12312 | catch (RecognitionException re) { | ||
12313 | reportError(re); | ||
12314 | recover(input,re); | ||
12315 | } | ||
12316 | finally { | ||
12317 | |||
12318 | restoreStackSize(stackSize); | ||
12319 | |||
12320 | } | ||
12321 | return ; | ||
12322 | } | ||
12323 | // $ANTLR end "rule__ALSOr__Group_1__1" | ||
12324 | |||
12325 | |||
12326 | // $ANTLR start "rule__ALSOr__Group_1__1__Impl" | ||
12327 | // InternalAlloyLanguage.g:4108:1: rule__ALSOr__Group_1__1__Impl : ( ( rule__ALSOr__Alternatives_1_1 ) ) ; | ||
12328 | public final void rule__ALSOr__Group_1__1__Impl() throws RecognitionException { | ||
12329 | |||
12330 | int stackSize = keepStackSize(); | ||
12331 | |||
12332 | try { | ||
12333 | // InternalAlloyLanguage.g:4112:1: ( ( ( rule__ALSOr__Alternatives_1_1 ) ) ) | ||
12334 | // InternalAlloyLanguage.g:4113:1: ( ( rule__ALSOr__Alternatives_1_1 ) ) | ||
12335 | { | ||
12336 | // InternalAlloyLanguage.g:4113:1: ( ( rule__ALSOr__Alternatives_1_1 ) ) | ||
12337 | // InternalAlloyLanguage.g:4114:1: ( rule__ALSOr__Alternatives_1_1 ) | ||
12338 | { | ||
12339 | if ( state.backtracking==0 ) { | ||
12340 | before(grammarAccess.getALSOrAccess().getAlternatives_1_1()); | ||
12341 | } | ||
12342 | // InternalAlloyLanguage.g:4115:1: ( rule__ALSOr__Alternatives_1_1 ) | ||
12343 | // InternalAlloyLanguage.g:4115:2: rule__ALSOr__Alternatives_1_1 | ||
12344 | { | ||
12345 | pushFollow(FOLLOW_2); | ||
12346 | rule__ALSOr__Alternatives_1_1(); | ||
12347 | |||
12348 | state._fsp--; | ||
12349 | if (state.failed) return ; | ||
12350 | |||
12351 | } | ||
12352 | |||
12353 | if ( state.backtracking==0 ) { | ||
12354 | after(grammarAccess.getALSOrAccess().getAlternatives_1_1()); | ||
12355 | } | ||
12356 | |||
12357 | } | ||
12358 | |||
12359 | |||
12360 | } | ||
12361 | |||
12362 | } | ||
12363 | catch (RecognitionException re) { | ||
12364 | reportError(re); | ||
12365 | recover(input,re); | ||
12366 | } | ||
12367 | finally { | ||
12368 | |||
12369 | restoreStackSize(stackSize); | ||
12370 | |||
12371 | } | ||
12372 | return ; | ||
12373 | } | ||
12374 | // $ANTLR end "rule__ALSOr__Group_1__1__Impl" | ||
12375 | |||
12376 | |||
12377 | // $ANTLR start "rule__ALSOr__Group_1__2" | ||
12378 | // InternalAlloyLanguage.g:4125:1: rule__ALSOr__Group_1__2 : rule__ALSOr__Group_1__2__Impl ; | ||
12379 | public final void rule__ALSOr__Group_1__2() throws RecognitionException { | ||
12380 | |||
12381 | int stackSize = keepStackSize(); | ||
12382 | |||
12383 | try { | ||
12384 | // InternalAlloyLanguage.g:4129:1: ( rule__ALSOr__Group_1__2__Impl ) | ||
12385 | // InternalAlloyLanguage.g:4130:2: rule__ALSOr__Group_1__2__Impl | ||
12386 | { | ||
12387 | pushFollow(FOLLOW_2); | ||
12388 | rule__ALSOr__Group_1__2__Impl(); | ||
12389 | |||
12390 | state._fsp--; | ||
12391 | if (state.failed) return ; | ||
12392 | |||
12393 | } | ||
12394 | |||
12395 | } | ||
12396 | catch (RecognitionException re) { | ||
12397 | reportError(re); | ||
12398 | recover(input,re); | ||
12399 | } | ||
12400 | finally { | ||
12401 | |||
12402 | restoreStackSize(stackSize); | ||
12403 | |||
12404 | } | ||
12405 | return ; | ||
12406 | } | ||
12407 | // $ANTLR end "rule__ALSOr__Group_1__2" | ||
12408 | |||
12409 | |||
12410 | // $ANTLR start "rule__ALSOr__Group_1__2__Impl" | ||
12411 | // InternalAlloyLanguage.g:4136:1: rule__ALSOr__Group_1__2__Impl : ( ( rule__ALSOr__RightOperandAssignment_1_2 ) ) ; | ||
12412 | public final void rule__ALSOr__Group_1__2__Impl() throws RecognitionException { | ||
12413 | |||
12414 | int stackSize = keepStackSize(); | ||
12415 | |||
12416 | try { | ||
12417 | // InternalAlloyLanguage.g:4140:1: ( ( ( rule__ALSOr__RightOperandAssignment_1_2 ) ) ) | ||
12418 | // InternalAlloyLanguage.g:4141:1: ( ( rule__ALSOr__RightOperandAssignment_1_2 ) ) | ||
12419 | { | ||
12420 | // InternalAlloyLanguage.g:4141:1: ( ( rule__ALSOr__RightOperandAssignment_1_2 ) ) | ||
12421 | // InternalAlloyLanguage.g:4142:1: ( rule__ALSOr__RightOperandAssignment_1_2 ) | ||
12422 | { | ||
12423 | if ( state.backtracking==0 ) { | ||
12424 | before(grammarAccess.getALSOrAccess().getRightOperandAssignment_1_2()); | ||
12425 | } | ||
12426 | // InternalAlloyLanguage.g:4143:1: ( rule__ALSOr__RightOperandAssignment_1_2 ) | ||
12427 | // InternalAlloyLanguage.g:4143:2: rule__ALSOr__RightOperandAssignment_1_2 | ||
12428 | { | ||
12429 | pushFollow(FOLLOW_2); | ||
12430 | rule__ALSOr__RightOperandAssignment_1_2(); | ||
12431 | |||
12432 | state._fsp--; | ||
12433 | if (state.failed) return ; | ||
12434 | |||
12435 | } | ||
12436 | |||
12437 | if ( state.backtracking==0 ) { | ||
12438 | after(grammarAccess.getALSOrAccess().getRightOperandAssignment_1_2()); | ||
12439 | } | ||
12440 | |||
12441 | } | ||
12442 | |||
12443 | |||
12444 | } | ||
12445 | |||
12446 | } | ||
12447 | catch (RecognitionException re) { | ||
12448 | reportError(re); | ||
12449 | recover(input,re); | ||
12450 | } | ||
12451 | finally { | ||
12452 | |||
12453 | restoreStackSize(stackSize); | ||
12454 | |||
12455 | } | ||
12456 | return ; | ||
12457 | } | ||
12458 | // $ANTLR end "rule__ALSOr__Group_1__2__Impl" | ||
12459 | |||
12460 | |||
12461 | // $ANTLR start "rule__ALSIff__Group__0" | ||
12462 | // InternalAlloyLanguage.g:4159:1: rule__ALSIff__Group__0 : rule__ALSIff__Group__0__Impl rule__ALSIff__Group__1 ; | ||
12463 | public final void rule__ALSIff__Group__0() throws RecognitionException { | ||
12464 | |||
12465 | int stackSize = keepStackSize(); | ||
12466 | |||
12467 | try { | ||
12468 | // InternalAlloyLanguage.g:4163:1: ( rule__ALSIff__Group__0__Impl rule__ALSIff__Group__1 ) | ||
12469 | // InternalAlloyLanguage.g:4164:2: rule__ALSIff__Group__0__Impl rule__ALSIff__Group__1 | ||
12470 | { | ||
12471 | pushFollow(FOLLOW_26); | ||
12472 | rule__ALSIff__Group__0__Impl(); | ||
12473 | |||
12474 | state._fsp--; | ||
12475 | if (state.failed) return ; | ||
12476 | pushFollow(FOLLOW_2); | ||
12477 | rule__ALSIff__Group__1(); | ||
12478 | |||
12479 | state._fsp--; | ||
12480 | if (state.failed) return ; | ||
12481 | |||
12482 | } | ||
12483 | |||
12484 | } | ||
12485 | catch (RecognitionException re) { | ||
12486 | reportError(re); | ||
12487 | recover(input,re); | ||
12488 | } | ||
12489 | finally { | ||
12490 | |||
12491 | restoreStackSize(stackSize); | ||
12492 | |||
12493 | } | ||
12494 | return ; | ||
12495 | } | ||
12496 | // $ANTLR end "rule__ALSIff__Group__0" | ||
12497 | |||
12498 | |||
12499 | // $ANTLR start "rule__ALSIff__Group__0__Impl" | ||
12500 | // InternalAlloyLanguage.g:4171:1: rule__ALSIff__Group__0__Impl : ( ruleALSImpl ) ; | ||
12501 | public final void rule__ALSIff__Group__0__Impl() throws RecognitionException { | ||
12502 | |||
12503 | int stackSize = keepStackSize(); | ||
12504 | |||
12505 | try { | ||
12506 | // InternalAlloyLanguage.g:4175:1: ( ( ruleALSImpl ) ) | ||
12507 | // InternalAlloyLanguage.g:4176:1: ( ruleALSImpl ) | ||
12508 | { | ||
12509 | // InternalAlloyLanguage.g:4176:1: ( ruleALSImpl ) | ||
12510 | // InternalAlloyLanguage.g:4177:1: ruleALSImpl | ||
12511 | { | ||
12512 | if ( state.backtracking==0 ) { | ||
12513 | before(grammarAccess.getALSIffAccess().getALSImplParserRuleCall_0()); | ||
12514 | } | ||
12515 | pushFollow(FOLLOW_2); | ||
12516 | ruleALSImpl(); | ||
12517 | |||
12518 | state._fsp--; | ||
12519 | if (state.failed) return ; | ||
12520 | if ( state.backtracking==0 ) { | ||
12521 | after(grammarAccess.getALSIffAccess().getALSImplParserRuleCall_0()); | ||
12522 | } | ||
12523 | |||
12524 | } | ||
12525 | |||
12526 | |||
12527 | } | ||
12528 | |||
12529 | } | ||
12530 | catch (RecognitionException re) { | ||
12531 | reportError(re); | ||
12532 | recover(input,re); | ||
12533 | } | ||
12534 | finally { | ||
12535 | |||
12536 | restoreStackSize(stackSize); | ||
12537 | |||
12538 | } | ||
12539 | return ; | ||
12540 | } | ||
12541 | // $ANTLR end "rule__ALSIff__Group__0__Impl" | ||
12542 | |||
12543 | |||
12544 | // $ANTLR start "rule__ALSIff__Group__1" | ||
12545 | // InternalAlloyLanguage.g:4188:1: rule__ALSIff__Group__1 : rule__ALSIff__Group__1__Impl ; | ||
12546 | public final void rule__ALSIff__Group__1() throws RecognitionException { | ||
12547 | |||
12548 | int stackSize = keepStackSize(); | ||
12549 | |||
12550 | try { | ||
12551 | // InternalAlloyLanguage.g:4192:1: ( rule__ALSIff__Group__1__Impl ) | ||
12552 | // InternalAlloyLanguage.g:4193:2: rule__ALSIff__Group__1__Impl | ||
12553 | { | ||
12554 | pushFollow(FOLLOW_2); | ||
12555 | rule__ALSIff__Group__1__Impl(); | ||
12556 | |||
12557 | state._fsp--; | ||
12558 | if (state.failed) return ; | ||
12559 | |||
12560 | } | ||
12561 | |||
12562 | } | ||
12563 | catch (RecognitionException re) { | ||
12564 | reportError(re); | ||
12565 | recover(input,re); | ||
12566 | } | ||
12567 | finally { | ||
12568 | |||
12569 | restoreStackSize(stackSize); | ||
12570 | |||
12571 | } | ||
12572 | return ; | ||
12573 | } | ||
12574 | // $ANTLR end "rule__ALSIff__Group__1" | ||
12575 | |||
12576 | |||
12577 | // $ANTLR start "rule__ALSIff__Group__1__Impl" | ||
12578 | // InternalAlloyLanguage.g:4199:1: rule__ALSIff__Group__1__Impl : ( ( rule__ALSIff__Group_1__0 )? ) ; | ||
12579 | public final void rule__ALSIff__Group__1__Impl() throws RecognitionException { | ||
12580 | |||
12581 | int stackSize = keepStackSize(); | ||
12582 | |||
12583 | try { | ||
12584 | // InternalAlloyLanguage.g:4203:1: ( ( ( rule__ALSIff__Group_1__0 )? ) ) | ||
12585 | // InternalAlloyLanguage.g:4204:1: ( ( rule__ALSIff__Group_1__0 )? ) | ||
12586 | { | ||
12587 | // InternalAlloyLanguage.g:4204:1: ( ( rule__ALSIff__Group_1__0 )? ) | ||
12588 | // InternalAlloyLanguage.g:4205:1: ( rule__ALSIff__Group_1__0 )? | ||
12589 | { | ||
12590 | if ( state.backtracking==0 ) { | ||
12591 | before(grammarAccess.getALSIffAccess().getGroup_1()); | ||
12592 | } | ||
12593 | // InternalAlloyLanguage.g:4206:1: ( rule__ALSIff__Group_1__0 )? | ||
12594 | int alt31=2; | ||
12595 | int LA31_0 = input.LA(1); | ||
12596 | |||
12597 | if ( ((LA31_0>=13 && LA31_0<=14)) ) { | ||
12598 | alt31=1; | ||
12599 | } | ||
12600 | switch (alt31) { | ||
12601 | case 1 : | ||
12602 | // InternalAlloyLanguage.g:4206:2: rule__ALSIff__Group_1__0 | ||
12603 | { | ||
12604 | pushFollow(FOLLOW_2); | ||
12605 | rule__ALSIff__Group_1__0(); | ||
12606 | |||
12607 | state._fsp--; | ||
12608 | if (state.failed) return ; | ||
12609 | |||
12610 | } | ||
12611 | break; | ||
12612 | |||
12613 | } | ||
12614 | |||
12615 | if ( state.backtracking==0 ) { | ||
12616 | after(grammarAccess.getALSIffAccess().getGroup_1()); | ||
12617 | } | ||
12618 | |||
12619 | } | ||
12620 | |||
12621 | |||
12622 | } | ||
12623 | |||
12624 | } | ||
12625 | catch (RecognitionException re) { | ||
12626 | reportError(re); | ||
12627 | recover(input,re); | ||
12628 | } | ||
12629 | finally { | ||
12630 | |||
12631 | restoreStackSize(stackSize); | ||
12632 | |||
12633 | } | ||
12634 | return ; | ||
12635 | } | ||
12636 | // $ANTLR end "rule__ALSIff__Group__1__Impl" | ||
12637 | |||
12638 | |||
12639 | // $ANTLR start "rule__ALSIff__Group_1__0" | ||
12640 | // InternalAlloyLanguage.g:4220:1: rule__ALSIff__Group_1__0 : rule__ALSIff__Group_1__0__Impl rule__ALSIff__Group_1__1 ; | ||
12641 | public final void rule__ALSIff__Group_1__0() throws RecognitionException { | ||
12642 | |||
12643 | int stackSize = keepStackSize(); | ||
12644 | |||
12645 | try { | ||
12646 | // InternalAlloyLanguage.g:4224:1: ( rule__ALSIff__Group_1__0__Impl rule__ALSIff__Group_1__1 ) | ||
12647 | // InternalAlloyLanguage.g:4225:2: rule__ALSIff__Group_1__0__Impl rule__ALSIff__Group_1__1 | ||
12648 | { | ||
12649 | pushFollow(FOLLOW_26); | ||
12650 | rule__ALSIff__Group_1__0__Impl(); | ||
12651 | |||
12652 | state._fsp--; | ||
12653 | if (state.failed) return ; | ||
12654 | pushFollow(FOLLOW_2); | ||
12655 | rule__ALSIff__Group_1__1(); | ||
12656 | |||
12657 | state._fsp--; | ||
12658 | if (state.failed) return ; | ||
12659 | |||
12660 | } | ||
12661 | |||
12662 | } | ||
12663 | catch (RecognitionException re) { | ||
12664 | reportError(re); | ||
12665 | recover(input,re); | ||
12666 | } | ||
12667 | finally { | ||
12668 | |||
12669 | restoreStackSize(stackSize); | ||
12670 | |||
12671 | } | ||
12672 | return ; | ||
12673 | } | ||
12674 | // $ANTLR end "rule__ALSIff__Group_1__0" | ||
12675 | |||
12676 | |||
12677 | // $ANTLR start "rule__ALSIff__Group_1__0__Impl" | ||
12678 | // InternalAlloyLanguage.g:4232:1: rule__ALSIff__Group_1__0__Impl : ( () ) ; | ||
12679 | public final void rule__ALSIff__Group_1__0__Impl() throws RecognitionException { | ||
12680 | |||
12681 | int stackSize = keepStackSize(); | ||
12682 | |||
12683 | try { | ||
12684 | // InternalAlloyLanguage.g:4236:1: ( ( () ) ) | ||
12685 | // InternalAlloyLanguage.g:4237:1: ( () ) | ||
12686 | { | ||
12687 | // InternalAlloyLanguage.g:4237:1: ( () ) | ||
12688 | // InternalAlloyLanguage.g:4238:1: () | ||
12689 | { | ||
12690 | if ( state.backtracking==0 ) { | ||
12691 | before(grammarAccess.getALSIffAccess().getALSIffLeftOperandAction_1_0()); | ||
12692 | } | ||
12693 | // InternalAlloyLanguage.g:4239:1: () | ||
12694 | // InternalAlloyLanguage.g:4241:1: | ||
12695 | { | ||
12696 | } | ||
12697 | |||
12698 | if ( state.backtracking==0 ) { | ||
12699 | after(grammarAccess.getALSIffAccess().getALSIffLeftOperandAction_1_0()); | ||
12700 | } | ||
12701 | |||
12702 | } | ||
12703 | |||
12704 | |||
12705 | } | ||
12706 | |||
12707 | } | ||
12708 | finally { | ||
12709 | |||
12710 | restoreStackSize(stackSize); | ||
12711 | |||
12712 | } | ||
12713 | return ; | ||
12714 | } | ||
12715 | // $ANTLR end "rule__ALSIff__Group_1__0__Impl" | ||
12716 | |||
12717 | |||
12718 | // $ANTLR start "rule__ALSIff__Group_1__1" | ||
12719 | // InternalAlloyLanguage.g:4251:1: rule__ALSIff__Group_1__1 : rule__ALSIff__Group_1__1__Impl rule__ALSIff__Group_1__2 ; | ||
12720 | public final void rule__ALSIff__Group_1__1() throws RecognitionException { | ||
12721 | |||
12722 | int stackSize = keepStackSize(); | ||
12723 | |||
12724 | try { | ||
12725 | // InternalAlloyLanguage.g:4255:1: ( rule__ALSIff__Group_1__1__Impl rule__ALSIff__Group_1__2 ) | ||
12726 | // InternalAlloyLanguage.g:4256:2: rule__ALSIff__Group_1__1__Impl rule__ALSIff__Group_1__2 | ||
12727 | { | ||
12728 | pushFollow(FOLLOW_16); | ||
12729 | rule__ALSIff__Group_1__1__Impl(); | ||
12730 | |||
12731 | state._fsp--; | ||
12732 | if (state.failed) return ; | ||
12733 | pushFollow(FOLLOW_2); | ||
12734 | rule__ALSIff__Group_1__2(); | ||
12735 | |||
12736 | state._fsp--; | ||
12737 | if (state.failed) return ; | ||
12738 | |||
12739 | } | ||
12740 | |||
12741 | } | ||
12742 | catch (RecognitionException re) { | ||
12743 | reportError(re); | ||
12744 | recover(input,re); | ||
12745 | } | ||
12746 | finally { | ||
12747 | |||
12748 | restoreStackSize(stackSize); | ||
12749 | |||
12750 | } | ||
12751 | return ; | ||
12752 | } | ||
12753 | // $ANTLR end "rule__ALSIff__Group_1__1" | ||
12754 | |||
12755 | |||
12756 | // $ANTLR start "rule__ALSIff__Group_1__1__Impl" | ||
12757 | // InternalAlloyLanguage.g:4263:1: rule__ALSIff__Group_1__1__Impl : ( ( rule__ALSIff__Alternatives_1_1 ) ) ; | ||
12758 | public final void rule__ALSIff__Group_1__1__Impl() throws RecognitionException { | ||
12759 | |||
12760 | int stackSize = keepStackSize(); | ||
12761 | |||
12762 | try { | ||
12763 | // InternalAlloyLanguage.g:4267:1: ( ( ( rule__ALSIff__Alternatives_1_1 ) ) ) | ||
12764 | // InternalAlloyLanguage.g:4268:1: ( ( rule__ALSIff__Alternatives_1_1 ) ) | ||
12765 | { | ||
12766 | // InternalAlloyLanguage.g:4268:1: ( ( rule__ALSIff__Alternatives_1_1 ) ) | ||
12767 | // InternalAlloyLanguage.g:4269:1: ( rule__ALSIff__Alternatives_1_1 ) | ||
12768 | { | ||
12769 | if ( state.backtracking==0 ) { | ||
12770 | before(grammarAccess.getALSIffAccess().getAlternatives_1_1()); | ||
12771 | } | ||
12772 | // InternalAlloyLanguage.g:4270:1: ( rule__ALSIff__Alternatives_1_1 ) | ||
12773 | // InternalAlloyLanguage.g:4270:2: rule__ALSIff__Alternatives_1_1 | ||
12774 | { | ||
12775 | pushFollow(FOLLOW_2); | ||
12776 | rule__ALSIff__Alternatives_1_1(); | ||
12777 | |||
12778 | state._fsp--; | ||
12779 | if (state.failed) return ; | ||
12780 | |||
12781 | } | ||
12782 | |||
12783 | if ( state.backtracking==0 ) { | ||
12784 | after(grammarAccess.getALSIffAccess().getAlternatives_1_1()); | ||
12785 | } | ||
12786 | |||
12787 | } | ||
12788 | |||
12789 | |||
12790 | } | ||
12791 | |||
12792 | } | ||
12793 | catch (RecognitionException re) { | ||
12794 | reportError(re); | ||
12795 | recover(input,re); | ||
12796 | } | ||
12797 | finally { | ||
12798 | |||
12799 | restoreStackSize(stackSize); | ||
12800 | |||
12801 | } | ||
12802 | return ; | ||
12803 | } | ||
12804 | // $ANTLR end "rule__ALSIff__Group_1__1__Impl" | ||
12805 | |||
12806 | |||
12807 | // $ANTLR start "rule__ALSIff__Group_1__2" | ||
12808 | // InternalAlloyLanguage.g:4280:1: rule__ALSIff__Group_1__2 : rule__ALSIff__Group_1__2__Impl ; | ||
12809 | public final void rule__ALSIff__Group_1__2() throws RecognitionException { | ||
12810 | |||
12811 | int stackSize = keepStackSize(); | ||
12812 | |||
12813 | try { | ||
12814 | // InternalAlloyLanguage.g:4284:1: ( rule__ALSIff__Group_1__2__Impl ) | ||
12815 | // InternalAlloyLanguage.g:4285:2: rule__ALSIff__Group_1__2__Impl | ||
12816 | { | ||
12817 | pushFollow(FOLLOW_2); | ||
12818 | rule__ALSIff__Group_1__2__Impl(); | ||
12819 | |||
12820 | state._fsp--; | ||
12821 | if (state.failed) return ; | ||
12822 | |||
12823 | } | ||
12824 | |||
12825 | } | ||
12826 | catch (RecognitionException re) { | ||
12827 | reportError(re); | ||
12828 | recover(input,re); | ||
12829 | } | ||
12830 | finally { | ||
12831 | |||
12832 | restoreStackSize(stackSize); | ||
12833 | |||
12834 | } | ||
12835 | return ; | ||
12836 | } | ||
12837 | // $ANTLR end "rule__ALSIff__Group_1__2" | ||
12838 | |||
12839 | |||
12840 | // $ANTLR start "rule__ALSIff__Group_1__2__Impl" | ||
12841 | // InternalAlloyLanguage.g:4291:1: rule__ALSIff__Group_1__2__Impl : ( ( rule__ALSIff__RightOperandAssignment_1_2 ) ) ; | ||
12842 | public final void rule__ALSIff__Group_1__2__Impl() throws RecognitionException { | ||
12843 | |||
12844 | int stackSize = keepStackSize(); | ||
12845 | |||
12846 | try { | ||
12847 | // InternalAlloyLanguage.g:4295:1: ( ( ( rule__ALSIff__RightOperandAssignment_1_2 ) ) ) | ||
12848 | // InternalAlloyLanguage.g:4296:1: ( ( rule__ALSIff__RightOperandAssignment_1_2 ) ) | ||
12849 | { | ||
12850 | // InternalAlloyLanguage.g:4296:1: ( ( rule__ALSIff__RightOperandAssignment_1_2 ) ) | ||
12851 | // InternalAlloyLanguage.g:4297:1: ( rule__ALSIff__RightOperandAssignment_1_2 ) | ||
12852 | { | ||
12853 | if ( state.backtracking==0 ) { | ||
12854 | before(grammarAccess.getALSIffAccess().getRightOperandAssignment_1_2()); | ||
12855 | } | ||
12856 | // InternalAlloyLanguage.g:4298:1: ( rule__ALSIff__RightOperandAssignment_1_2 ) | ||
12857 | // InternalAlloyLanguage.g:4298:2: rule__ALSIff__RightOperandAssignment_1_2 | ||
12858 | { | ||
12859 | pushFollow(FOLLOW_2); | ||
12860 | rule__ALSIff__RightOperandAssignment_1_2(); | ||
12861 | |||
12862 | state._fsp--; | ||
12863 | if (state.failed) return ; | ||
12864 | |||
12865 | } | ||
12866 | |||
12867 | if ( state.backtracking==0 ) { | ||
12868 | after(grammarAccess.getALSIffAccess().getRightOperandAssignment_1_2()); | ||
12869 | } | ||
12870 | |||
12871 | } | ||
12872 | |||
12873 | |||
12874 | } | ||
12875 | |||
12876 | } | ||
12877 | catch (RecognitionException re) { | ||
12878 | reportError(re); | ||
12879 | recover(input,re); | ||
12880 | } | ||
12881 | finally { | ||
12882 | |||
12883 | restoreStackSize(stackSize); | ||
12884 | |||
12885 | } | ||
12886 | return ; | ||
12887 | } | ||
12888 | // $ANTLR end "rule__ALSIff__Group_1__2__Impl" | ||
12889 | |||
12890 | |||
12891 | // $ANTLR start "rule__ALSImpl__Group__0" | ||
12892 | // InternalAlloyLanguage.g:4314:1: rule__ALSImpl__Group__0 : rule__ALSImpl__Group__0__Impl rule__ALSImpl__Group__1 ; | ||
12893 | public final void rule__ALSImpl__Group__0() throws RecognitionException { | ||
12894 | |||
12895 | int stackSize = keepStackSize(); | ||
12896 | |||
12897 | try { | ||
12898 | // InternalAlloyLanguage.g:4318:1: ( rule__ALSImpl__Group__0__Impl rule__ALSImpl__Group__1 ) | ||
12899 | // InternalAlloyLanguage.g:4319:2: rule__ALSImpl__Group__0__Impl rule__ALSImpl__Group__1 | ||
12900 | { | ||
12901 | pushFollow(FOLLOW_27); | ||
12902 | rule__ALSImpl__Group__0__Impl(); | ||
12903 | |||
12904 | state._fsp--; | ||
12905 | if (state.failed) return ; | ||
12906 | pushFollow(FOLLOW_2); | ||
12907 | rule__ALSImpl__Group__1(); | ||
12908 | |||
12909 | state._fsp--; | ||
12910 | if (state.failed) return ; | ||
12911 | |||
12912 | } | ||
12913 | |||
12914 | } | ||
12915 | catch (RecognitionException re) { | ||
12916 | reportError(re); | ||
12917 | recover(input,re); | ||
12918 | } | ||
12919 | finally { | ||
12920 | |||
12921 | restoreStackSize(stackSize); | ||
12922 | |||
12923 | } | ||
12924 | return ; | ||
12925 | } | ||
12926 | // $ANTLR end "rule__ALSImpl__Group__0" | ||
12927 | |||
12928 | |||
12929 | // $ANTLR start "rule__ALSImpl__Group__0__Impl" | ||
12930 | // InternalAlloyLanguage.g:4326:1: rule__ALSImpl__Group__0__Impl : ( ruleALSAnd ) ; | ||
12931 | public final void rule__ALSImpl__Group__0__Impl() throws RecognitionException { | ||
12932 | |||
12933 | int stackSize = keepStackSize(); | ||
12934 | |||
12935 | try { | ||
12936 | // InternalAlloyLanguage.g:4330:1: ( ( ruleALSAnd ) ) | ||
12937 | // InternalAlloyLanguage.g:4331:1: ( ruleALSAnd ) | ||
12938 | { | ||
12939 | // InternalAlloyLanguage.g:4331:1: ( ruleALSAnd ) | ||
12940 | // InternalAlloyLanguage.g:4332:1: ruleALSAnd | ||
12941 | { | ||
12942 | if ( state.backtracking==0 ) { | ||
12943 | before(grammarAccess.getALSImplAccess().getALSAndParserRuleCall_0()); | ||
12944 | } | ||
12945 | pushFollow(FOLLOW_2); | ||
12946 | ruleALSAnd(); | ||
12947 | |||
12948 | state._fsp--; | ||
12949 | if (state.failed) return ; | ||
12950 | if ( state.backtracking==0 ) { | ||
12951 | after(grammarAccess.getALSImplAccess().getALSAndParserRuleCall_0()); | ||
12952 | } | ||
12953 | |||
12954 | } | ||
12955 | |||
12956 | |||
12957 | } | ||
12958 | |||
12959 | } | ||
12960 | catch (RecognitionException re) { | ||
12961 | reportError(re); | ||
12962 | recover(input,re); | ||
12963 | } | ||
12964 | finally { | ||
12965 | |||
12966 | restoreStackSize(stackSize); | ||
12967 | |||
12968 | } | ||
12969 | return ; | ||
12970 | } | ||
12971 | // $ANTLR end "rule__ALSImpl__Group__0__Impl" | ||
12972 | |||
12973 | |||
12974 | // $ANTLR start "rule__ALSImpl__Group__1" | ||
12975 | // InternalAlloyLanguage.g:4343:1: rule__ALSImpl__Group__1 : rule__ALSImpl__Group__1__Impl ; | ||
12976 | public final void rule__ALSImpl__Group__1() throws RecognitionException { | ||
12977 | |||
12978 | int stackSize = keepStackSize(); | ||
12979 | |||
12980 | try { | ||
12981 | // InternalAlloyLanguage.g:4347:1: ( rule__ALSImpl__Group__1__Impl ) | ||
12982 | // InternalAlloyLanguage.g:4348:2: rule__ALSImpl__Group__1__Impl | ||
12983 | { | ||
12984 | pushFollow(FOLLOW_2); | ||
12985 | rule__ALSImpl__Group__1__Impl(); | ||
12986 | |||
12987 | state._fsp--; | ||
12988 | if (state.failed) return ; | ||
12989 | |||
12990 | } | ||
12991 | |||
12992 | } | ||
12993 | catch (RecognitionException re) { | ||
12994 | reportError(re); | ||
12995 | recover(input,re); | ||
12996 | } | ||
12997 | finally { | ||
12998 | |||
12999 | restoreStackSize(stackSize); | ||
13000 | |||
13001 | } | ||
13002 | return ; | ||
13003 | } | ||
13004 | // $ANTLR end "rule__ALSImpl__Group__1" | ||
13005 | |||
13006 | |||
13007 | // $ANTLR start "rule__ALSImpl__Group__1__Impl" | ||
13008 | // InternalAlloyLanguage.g:4354:1: rule__ALSImpl__Group__1__Impl : ( ( rule__ALSImpl__Group_1__0 )? ) ; | ||
13009 | public final void rule__ALSImpl__Group__1__Impl() throws RecognitionException { | ||
13010 | |||
13011 | int stackSize = keepStackSize(); | ||
13012 | |||
13013 | try { | ||
13014 | // InternalAlloyLanguage.g:4358:1: ( ( ( rule__ALSImpl__Group_1__0 )? ) ) | ||
13015 | // InternalAlloyLanguage.g:4359:1: ( ( rule__ALSImpl__Group_1__0 )? ) | ||
13016 | { | ||
13017 | // InternalAlloyLanguage.g:4359:1: ( ( rule__ALSImpl__Group_1__0 )? ) | ||
13018 | // InternalAlloyLanguage.g:4360:1: ( rule__ALSImpl__Group_1__0 )? | ||
13019 | { | ||
13020 | if ( state.backtracking==0 ) { | ||
13021 | before(grammarAccess.getALSImplAccess().getGroup_1()); | ||
13022 | } | ||
13023 | // InternalAlloyLanguage.g:4361:1: ( rule__ALSImpl__Group_1__0 )? | ||
13024 | int alt32=2; | ||
13025 | int LA32_0 = input.LA(1); | ||
13026 | |||
13027 | if ( ((LA32_0>=15 && LA32_0<=16)) ) { | ||
13028 | alt32=1; | ||
13029 | } | ||
13030 | switch (alt32) { | ||
13031 | case 1 : | ||
13032 | // InternalAlloyLanguage.g:4361:2: rule__ALSImpl__Group_1__0 | ||
13033 | { | ||
13034 | pushFollow(FOLLOW_2); | ||
13035 | rule__ALSImpl__Group_1__0(); | ||
13036 | |||
13037 | state._fsp--; | ||
13038 | if (state.failed) return ; | ||
13039 | |||
13040 | } | ||
13041 | break; | ||
13042 | |||
13043 | } | ||
13044 | |||
13045 | if ( state.backtracking==0 ) { | ||
13046 | after(grammarAccess.getALSImplAccess().getGroup_1()); | ||
13047 | } | ||
13048 | |||
13049 | } | ||
13050 | |||
13051 | |||
13052 | } | ||
13053 | |||
13054 | } | ||
13055 | catch (RecognitionException re) { | ||
13056 | reportError(re); | ||
13057 | recover(input,re); | ||
13058 | } | ||
13059 | finally { | ||
13060 | |||
13061 | restoreStackSize(stackSize); | ||
13062 | |||
13063 | } | ||
13064 | return ; | ||
13065 | } | ||
13066 | // $ANTLR end "rule__ALSImpl__Group__1__Impl" | ||
13067 | |||
13068 | |||
13069 | // $ANTLR start "rule__ALSImpl__Group_1__0" | ||
13070 | // InternalAlloyLanguage.g:4375:1: rule__ALSImpl__Group_1__0 : rule__ALSImpl__Group_1__0__Impl rule__ALSImpl__Group_1__1 ; | ||
13071 | public final void rule__ALSImpl__Group_1__0() throws RecognitionException { | ||
13072 | |||
13073 | int stackSize = keepStackSize(); | ||
13074 | |||
13075 | try { | ||
13076 | // InternalAlloyLanguage.g:4379:1: ( rule__ALSImpl__Group_1__0__Impl rule__ALSImpl__Group_1__1 ) | ||
13077 | // InternalAlloyLanguage.g:4380:2: rule__ALSImpl__Group_1__0__Impl rule__ALSImpl__Group_1__1 | ||
13078 | { | ||
13079 | pushFollow(FOLLOW_27); | ||
13080 | rule__ALSImpl__Group_1__0__Impl(); | ||
13081 | |||
13082 | state._fsp--; | ||
13083 | if (state.failed) return ; | ||
13084 | pushFollow(FOLLOW_2); | ||
13085 | rule__ALSImpl__Group_1__1(); | ||
13086 | |||
13087 | state._fsp--; | ||
13088 | if (state.failed) return ; | ||
13089 | |||
13090 | } | ||
13091 | |||
13092 | } | ||
13093 | catch (RecognitionException re) { | ||
13094 | reportError(re); | ||
13095 | recover(input,re); | ||
13096 | } | ||
13097 | finally { | ||
13098 | |||
13099 | restoreStackSize(stackSize); | ||
13100 | |||
13101 | } | ||
13102 | return ; | ||
13103 | } | ||
13104 | // $ANTLR end "rule__ALSImpl__Group_1__0" | ||
13105 | |||
13106 | |||
13107 | // $ANTLR start "rule__ALSImpl__Group_1__0__Impl" | ||
13108 | // InternalAlloyLanguage.g:4387:1: rule__ALSImpl__Group_1__0__Impl : ( () ) ; | ||
13109 | public final void rule__ALSImpl__Group_1__0__Impl() throws RecognitionException { | ||
13110 | |||
13111 | int stackSize = keepStackSize(); | ||
13112 | |||
13113 | try { | ||
13114 | // InternalAlloyLanguage.g:4391:1: ( ( () ) ) | ||
13115 | // InternalAlloyLanguage.g:4392:1: ( () ) | ||
13116 | { | ||
13117 | // InternalAlloyLanguage.g:4392:1: ( () ) | ||
13118 | // InternalAlloyLanguage.g:4393:1: () | ||
13119 | { | ||
13120 | if ( state.backtracking==0 ) { | ||
13121 | before(grammarAccess.getALSImplAccess().getALSImplLeftOperandAction_1_0()); | ||
13122 | } | ||
13123 | // InternalAlloyLanguage.g:4394:1: () | ||
13124 | // InternalAlloyLanguage.g:4396:1: | ||
13125 | { | ||
13126 | } | ||
13127 | |||
13128 | if ( state.backtracking==0 ) { | ||
13129 | after(grammarAccess.getALSImplAccess().getALSImplLeftOperandAction_1_0()); | ||
13130 | } | ||
13131 | |||
13132 | } | ||
13133 | |||
13134 | |||
13135 | } | ||
13136 | |||
13137 | } | ||
13138 | finally { | ||
13139 | |||
13140 | restoreStackSize(stackSize); | ||
13141 | |||
13142 | } | ||
13143 | return ; | ||
13144 | } | ||
13145 | // $ANTLR end "rule__ALSImpl__Group_1__0__Impl" | ||
13146 | |||
13147 | |||
13148 | // $ANTLR start "rule__ALSImpl__Group_1__1" | ||
13149 | // InternalAlloyLanguage.g:4406:1: rule__ALSImpl__Group_1__1 : rule__ALSImpl__Group_1__1__Impl rule__ALSImpl__Group_1__2 ; | ||
13150 | public final void rule__ALSImpl__Group_1__1() throws RecognitionException { | ||
13151 | |||
13152 | int stackSize = keepStackSize(); | ||
13153 | |||
13154 | try { | ||
13155 | // InternalAlloyLanguage.g:4410:1: ( rule__ALSImpl__Group_1__1__Impl rule__ALSImpl__Group_1__2 ) | ||
13156 | // InternalAlloyLanguage.g:4411:2: rule__ALSImpl__Group_1__1__Impl rule__ALSImpl__Group_1__2 | ||
13157 | { | ||
13158 | pushFollow(FOLLOW_16); | ||
13159 | rule__ALSImpl__Group_1__1__Impl(); | ||
13160 | |||
13161 | state._fsp--; | ||
13162 | if (state.failed) return ; | ||
13163 | pushFollow(FOLLOW_2); | ||
13164 | rule__ALSImpl__Group_1__2(); | ||
13165 | |||
13166 | state._fsp--; | ||
13167 | if (state.failed) return ; | ||
13168 | |||
13169 | } | ||
13170 | |||
13171 | } | ||
13172 | catch (RecognitionException re) { | ||
13173 | reportError(re); | ||
13174 | recover(input,re); | ||
13175 | } | ||
13176 | finally { | ||
13177 | |||
13178 | restoreStackSize(stackSize); | ||
13179 | |||
13180 | } | ||
13181 | return ; | ||
13182 | } | ||
13183 | // $ANTLR end "rule__ALSImpl__Group_1__1" | ||
13184 | |||
13185 | |||
13186 | // $ANTLR start "rule__ALSImpl__Group_1__1__Impl" | ||
13187 | // InternalAlloyLanguage.g:4418:1: rule__ALSImpl__Group_1__1__Impl : ( ( rule__ALSImpl__Alternatives_1_1 ) ) ; | ||
13188 | public final void rule__ALSImpl__Group_1__1__Impl() throws RecognitionException { | ||
13189 | |||
13190 | int stackSize = keepStackSize(); | ||
13191 | |||
13192 | try { | ||
13193 | // InternalAlloyLanguage.g:4422:1: ( ( ( rule__ALSImpl__Alternatives_1_1 ) ) ) | ||
13194 | // InternalAlloyLanguage.g:4423:1: ( ( rule__ALSImpl__Alternatives_1_1 ) ) | ||
13195 | { | ||
13196 | // InternalAlloyLanguage.g:4423:1: ( ( rule__ALSImpl__Alternatives_1_1 ) ) | ||
13197 | // InternalAlloyLanguage.g:4424:1: ( rule__ALSImpl__Alternatives_1_1 ) | ||
13198 | { | ||
13199 | if ( state.backtracking==0 ) { | ||
13200 | before(grammarAccess.getALSImplAccess().getAlternatives_1_1()); | ||
13201 | } | ||
13202 | // InternalAlloyLanguage.g:4425:1: ( rule__ALSImpl__Alternatives_1_1 ) | ||
13203 | // InternalAlloyLanguage.g:4425:2: rule__ALSImpl__Alternatives_1_1 | ||
13204 | { | ||
13205 | pushFollow(FOLLOW_2); | ||
13206 | rule__ALSImpl__Alternatives_1_1(); | ||
13207 | |||
13208 | state._fsp--; | ||
13209 | if (state.failed) return ; | ||
13210 | |||
13211 | } | ||
13212 | |||
13213 | if ( state.backtracking==0 ) { | ||
13214 | after(grammarAccess.getALSImplAccess().getAlternatives_1_1()); | ||
13215 | } | ||
13216 | |||
13217 | } | ||
13218 | |||
13219 | |||
13220 | } | ||
13221 | |||
13222 | } | ||
13223 | catch (RecognitionException re) { | ||
13224 | reportError(re); | ||
13225 | recover(input,re); | ||
13226 | } | ||
13227 | finally { | ||
13228 | |||
13229 | restoreStackSize(stackSize); | ||
13230 | |||
13231 | } | ||
13232 | return ; | ||
13233 | } | ||
13234 | // $ANTLR end "rule__ALSImpl__Group_1__1__Impl" | ||
13235 | |||
13236 | |||
13237 | // $ANTLR start "rule__ALSImpl__Group_1__2" | ||
13238 | // InternalAlloyLanguage.g:4435:1: rule__ALSImpl__Group_1__2 : rule__ALSImpl__Group_1__2__Impl rule__ALSImpl__Group_1__3 ; | ||
13239 | public final void rule__ALSImpl__Group_1__2() throws RecognitionException { | ||
13240 | |||
13241 | int stackSize = keepStackSize(); | ||
13242 | |||
13243 | try { | ||
13244 | // InternalAlloyLanguage.g:4439:1: ( rule__ALSImpl__Group_1__2__Impl rule__ALSImpl__Group_1__3 ) | ||
13245 | // InternalAlloyLanguage.g:4440:2: rule__ALSImpl__Group_1__2__Impl rule__ALSImpl__Group_1__3 | ||
13246 | { | ||
13247 | pushFollow(FOLLOW_28); | ||
13248 | rule__ALSImpl__Group_1__2__Impl(); | ||
13249 | |||
13250 | state._fsp--; | ||
13251 | if (state.failed) return ; | ||
13252 | pushFollow(FOLLOW_2); | ||
13253 | rule__ALSImpl__Group_1__3(); | ||
13254 | |||
13255 | state._fsp--; | ||
13256 | if (state.failed) return ; | ||
13257 | |||
13258 | } | ||
13259 | |||
13260 | } | ||
13261 | catch (RecognitionException re) { | ||
13262 | reportError(re); | ||
13263 | recover(input,re); | ||
13264 | } | ||
13265 | finally { | ||
13266 | |||
13267 | restoreStackSize(stackSize); | ||
13268 | |||
13269 | } | ||
13270 | return ; | ||
13271 | } | ||
13272 | // $ANTLR end "rule__ALSImpl__Group_1__2" | ||
13273 | |||
13274 | |||
13275 | // $ANTLR start "rule__ALSImpl__Group_1__2__Impl" | ||
13276 | // InternalAlloyLanguage.g:4447:1: rule__ALSImpl__Group_1__2__Impl : ( ( rule__ALSImpl__RightOperandAssignment_1_2 ) ) ; | ||
13277 | public final void rule__ALSImpl__Group_1__2__Impl() throws RecognitionException { | ||
13278 | |||
13279 | int stackSize = keepStackSize(); | ||
13280 | |||
13281 | try { | ||
13282 | // InternalAlloyLanguage.g:4451:1: ( ( ( rule__ALSImpl__RightOperandAssignment_1_2 ) ) ) | ||
13283 | // InternalAlloyLanguage.g:4452:1: ( ( rule__ALSImpl__RightOperandAssignment_1_2 ) ) | ||
13284 | { | ||
13285 | // InternalAlloyLanguage.g:4452:1: ( ( rule__ALSImpl__RightOperandAssignment_1_2 ) ) | ||
13286 | // InternalAlloyLanguage.g:4453:1: ( rule__ALSImpl__RightOperandAssignment_1_2 ) | ||
13287 | { | ||
13288 | if ( state.backtracking==0 ) { | ||
13289 | before(grammarAccess.getALSImplAccess().getRightOperandAssignment_1_2()); | ||
13290 | } | ||
13291 | // InternalAlloyLanguage.g:4454:1: ( rule__ALSImpl__RightOperandAssignment_1_2 ) | ||
13292 | // InternalAlloyLanguage.g:4454:2: rule__ALSImpl__RightOperandAssignment_1_2 | ||
13293 | { | ||
13294 | pushFollow(FOLLOW_2); | ||
13295 | rule__ALSImpl__RightOperandAssignment_1_2(); | ||
13296 | |||
13297 | state._fsp--; | ||
13298 | if (state.failed) return ; | ||
13299 | |||
13300 | } | ||
13301 | |||
13302 | if ( state.backtracking==0 ) { | ||
13303 | after(grammarAccess.getALSImplAccess().getRightOperandAssignment_1_2()); | ||
13304 | } | ||
13305 | |||
13306 | } | ||
13307 | |||
13308 | |||
13309 | } | ||
13310 | |||
13311 | } | ||
13312 | catch (RecognitionException re) { | ||
13313 | reportError(re); | ||
13314 | recover(input,re); | ||
13315 | } | ||
13316 | finally { | ||
13317 | |||
13318 | restoreStackSize(stackSize); | ||
13319 | |||
13320 | } | ||
13321 | return ; | ||
13322 | } | ||
13323 | // $ANTLR end "rule__ALSImpl__Group_1__2__Impl" | ||
13324 | |||
13325 | |||
13326 | // $ANTLR start "rule__ALSImpl__Group_1__3" | ||
13327 | // InternalAlloyLanguage.g:4464:1: rule__ALSImpl__Group_1__3 : rule__ALSImpl__Group_1__3__Impl ; | ||
13328 | public final void rule__ALSImpl__Group_1__3() throws RecognitionException { | ||
13329 | |||
13330 | int stackSize = keepStackSize(); | ||
13331 | |||
13332 | try { | ||
13333 | // InternalAlloyLanguage.g:4468:1: ( rule__ALSImpl__Group_1__3__Impl ) | ||
13334 | // InternalAlloyLanguage.g:4469:2: rule__ALSImpl__Group_1__3__Impl | ||
13335 | { | ||
13336 | pushFollow(FOLLOW_2); | ||
13337 | rule__ALSImpl__Group_1__3__Impl(); | ||
13338 | |||
13339 | state._fsp--; | ||
13340 | if (state.failed) return ; | ||
13341 | |||
13342 | } | ||
13343 | |||
13344 | } | ||
13345 | catch (RecognitionException re) { | ||
13346 | reportError(re); | ||
13347 | recover(input,re); | ||
13348 | } | ||
13349 | finally { | ||
13350 | |||
13351 | restoreStackSize(stackSize); | ||
13352 | |||
13353 | } | ||
13354 | return ; | ||
13355 | } | ||
13356 | // $ANTLR end "rule__ALSImpl__Group_1__3" | ||
13357 | |||
13358 | |||
13359 | // $ANTLR start "rule__ALSImpl__Group_1__3__Impl" | ||
13360 | // InternalAlloyLanguage.g:4475:1: rule__ALSImpl__Group_1__3__Impl : ( ( rule__ALSImpl__Group_1_3__0 )? ) ; | ||
13361 | public final void rule__ALSImpl__Group_1__3__Impl() throws RecognitionException { | ||
13362 | |||
13363 | int stackSize = keepStackSize(); | ||
13364 | |||
13365 | try { | ||
13366 | // InternalAlloyLanguage.g:4479:1: ( ( ( rule__ALSImpl__Group_1_3__0 )? ) ) | ||
13367 | // InternalAlloyLanguage.g:4480:1: ( ( rule__ALSImpl__Group_1_3__0 )? ) | ||
13368 | { | ||
13369 | // InternalAlloyLanguage.g:4480:1: ( ( rule__ALSImpl__Group_1_3__0 )? ) | ||
13370 | // InternalAlloyLanguage.g:4481:1: ( rule__ALSImpl__Group_1_3__0 )? | ||
13371 | { | ||
13372 | if ( state.backtracking==0 ) { | ||
13373 | before(grammarAccess.getALSImplAccess().getGroup_1_3()); | ||
13374 | } | ||
13375 | // InternalAlloyLanguage.g:4482:1: ( rule__ALSImpl__Group_1_3__0 )? | ||
13376 | int alt33=2; | ||
13377 | int LA33_0 = input.LA(1); | ||
13378 | |||
13379 | if ( (LA33_0==46) ) { | ||
13380 | alt33=1; | ||
13381 | } | ||
13382 | switch (alt33) { | ||
13383 | case 1 : | ||
13384 | // InternalAlloyLanguage.g:4482:2: rule__ALSImpl__Group_1_3__0 | ||
13385 | { | ||
13386 | pushFollow(FOLLOW_2); | ||
13387 | rule__ALSImpl__Group_1_3__0(); | ||
13388 | |||
13389 | state._fsp--; | ||
13390 | if (state.failed) return ; | ||
13391 | |||
13392 | } | ||
13393 | break; | ||
13394 | |||
13395 | } | ||
13396 | |||
13397 | if ( state.backtracking==0 ) { | ||
13398 | after(grammarAccess.getALSImplAccess().getGroup_1_3()); | ||
13399 | } | ||
13400 | |||
13401 | } | ||
13402 | |||
13403 | |||
13404 | } | ||
13405 | |||
13406 | } | ||
13407 | catch (RecognitionException re) { | ||
13408 | reportError(re); | ||
13409 | recover(input,re); | ||
13410 | } | ||
13411 | finally { | ||
13412 | |||
13413 | restoreStackSize(stackSize); | ||
13414 | |||
13415 | } | ||
13416 | return ; | ||
13417 | } | ||
13418 | // $ANTLR end "rule__ALSImpl__Group_1__3__Impl" | ||
13419 | |||
13420 | |||
13421 | // $ANTLR start "rule__ALSImpl__Group_1_3__0" | ||
13422 | // InternalAlloyLanguage.g:4500:1: rule__ALSImpl__Group_1_3__0 : rule__ALSImpl__Group_1_3__0__Impl rule__ALSImpl__Group_1_3__1 ; | ||
13423 | public final void rule__ALSImpl__Group_1_3__0() throws RecognitionException { | ||
13424 | |||
13425 | int stackSize = keepStackSize(); | ||
13426 | |||
13427 | try { | ||
13428 | // InternalAlloyLanguage.g:4504:1: ( rule__ALSImpl__Group_1_3__0__Impl rule__ALSImpl__Group_1_3__1 ) | ||
13429 | // InternalAlloyLanguage.g:4505:2: rule__ALSImpl__Group_1_3__0__Impl rule__ALSImpl__Group_1_3__1 | ||
13430 | { | ||
13431 | pushFollow(FOLLOW_16); | ||
13432 | rule__ALSImpl__Group_1_3__0__Impl(); | ||
13433 | |||
13434 | state._fsp--; | ||
13435 | if (state.failed) return ; | ||
13436 | pushFollow(FOLLOW_2); | ||
13437 | rule__ALSImpl__Group_1_3__1(); | ||
13438 | |||
13439 | state._fsp--; | ||
13440 | if (state.failed) return ; | ||
13441 | |||
13442 | } | ||
13443 | |||
13444 | } | ||
13445 | catch (RecognitionException re) { | ||
13446 | reportError(re); | ||
13447 | recover(input,re); | ||
13448 | } | ||
13449 | finally { | ||
13450 | |||
13451 | restoreStackSize(stackSize); | ||
13452 | |||
13453 | } | ||
13454 | return ; | ||
13455 | } | ||
13456 | // $ANTLR end "rule__ALSImpl__Group_1_3__0" | ||
13457 | |||
13458 | |||
13459 | // $ANTLR start "rule__ALSImpl__Group_1_3__0__Impl" | ||
13460 | // InternalAlloyLanguage.g:4512:1: rule__ALSImpl__Group_1_3__0__Impl : ( 'else' ) ; | ||
13461 | public final void rule__ALSImpl__Group_1_3__0__Impl() throws RecognitionException { | ||
13462 | |||
13463 | int stackSize = keepStackSize(); | ||
13464 | |||
13465 | try { | ||
13466 | // InternalAlloyLanguage.g:4516:1: ( ( 'else' ) ) | ||
13467 | // InternalAlloyLanguage.g:4517:1: ( 'else' ) | ||
13468 | { | ||
13469 | // InternalAlloyLanguage.g:4517:1: ( 'else' ) | ||
13470 | // InternalAlloyLanguage.g:4518:1: 'else' | ||
13471 | { | ||
13472 | if ( state.backtracking==0 ) { | ||
13473 | before(grammarAccess.getALSImplAccess().getElseKeyword_1_3_0()); | ||
13474 | } | ||
13475 | match(input,46,FOLLOW_2); if (state.failed) return ; | ||
13476 | if ( state.backtracking==0 ) { | ||
13477 | after(grammarAccess.getALSImplAccess().getElseKeyword_1_3_0()); | ||
13478 | } | ||
13479 | |||
13480 | } | ||
13481 | |||
13482 | |||
13483 | } | ||
13484 | |||
13485 | } | ||
13486 | catch (RecognitionException re) { | ||
13487 | reportError(re); | ||
13488 | recover(input,re); | ||
13489 | } | ||
13490 | finally { | ||
13491 | |||
13492 | restoreStackSize(stackSize); | ||
13493 | |||
13494 | } | ||
13495 | return ; | ||
13496 | } | ||
13497 | // $ANTLR end "rule__ALSImpl__Group_1_3__0__Impl" | ||
13498 | |||
13499 | |||
13500 | // $ANTLR start "rule__ALSImpl__Group_1_3__1" | ||
13501 | // InternalAlloyLanguage.g:4531:1: rule__ALSImpl__Group_1_3__1 : rule__ALSImpl__Group_1_3__1__Impl ; | ||
13502 | public final void rule__ALSImpl__Group_1_3__1() throws RecognitionException { | ||
13503 | |||
13504 | int stackSize = keepStackSize(); | ||
13505 | |||
13506 | try { | ||
13507 | // InternalAlloyLanguage.g:4535:1: ( rule__ALSImpl__Group_1_3__1__Impl ) | ||
13508 | // InternalAlloyLanguage.g:4536:2: rule__ALSImpl__Group_1_3__1__Impl | ||
13509 | { | ||
13510 | pushFollow(FOLLOW_2); | ||
13511 | rule__ALSImpl__Group_1_3__1__Impl(); | ||
13512 | |||
13513 | state._fsp--; | ||
13514 | if (state.failed) return ; | ||
13515 | |||
13516 | } | ||
13517 | |||
13518 | } | ||
13519 | catch (RecognitionException re) { | ||
13520 | reportError(re); | ||
13521 | recover(input,re); | ||
13522 | } | ||
13523 | finally { | ||
13524 | |||
13525 | restoreStackSize(stackSize); | ||
13526 | |||
13527 | } | ||
13528 | return ; | ||
13529 | } | ||
13530 | // $ANTLR end "rule__ALSImpl__Group_1_3__1" | ||
13531 | |||
13532 | |||
13533 | // $ANTLR start "rule__ALSImpl__Group_1_3__1__Impl" | ||
13534 | // InternalAlloyLanguage.g:4542:1: rule__ALSImpl__Group_1_3__1__Impl : ( ( rule__ALSImpl__ElseOperandAssignment_1_3_1 ) ) ; | ||
13535 | public final void rule__ALSImpl__Group_1_3__1__Impl() throws RecognitionException { | ||
13536 | |||
13537 | int stackSize = keepStackSize(); | ||
13538 | |||
13539 | try { | ||
13540 | // InternalAlloyLanguage.g:4546:1: ( ( ( rule__ALSImpl__ElseOperandAssignment_1_3_1 ) ) ) | ||
13541 | // InternalAlloyLanguage.g:4547:1: ( ( rule__ALSImpl__ElseOperandAssignment_1_3_1 ) ) | ||
13542 | { | ||
13543 | // InternalAlloyLanguage.g:4547:1: ( ( rule__ALSImpl__ElseOperandAssignment_1_3_1 ) ) | ||
13544 | // InternalAlloyLanguage.g:4548:1: ( rule__ALSImpl__ElseOperandAssignment_1_3_1 ) | ||
13545 | { | ||
13546 | if ( state.backtracking==0 ) { | ||
13547 | before(grammarAccess.getALSImplAccess().getElseOperandAssignment_1_3_1()); | ||
13548 | } | ||
13549 | // InternalAlloyLanguage.g:4549:1: ( rule__ALSImpl__ElseOperandAssignment_1_3_1 ) | ||
13550 | // InternalAlloyLanguage.g:4549:2: rule__ALSImpl__ElseOperandAssignment_1_3_1 | ||
13551 | { | ||
13552 | pushFollow(FOLLOW_2); | ||
13553 | rule__ALSImpl__ElseOperandAssignment_1_3_1(); | ||
13554 | |||
13555 | state._fsp--; | ||
13556 | if (state.failed) return ; | ||
13557 | |||
13558 | } | ||
13559 | |||
13560 | if ( state.backtracking==0 ) { | ||
13561 | after(grammarAccess.getALSImplAccess().getElseOperandAssignment_1_3_1()); | ||
13562 | } | ||
13563 | |||
13564 | } | ||
13565 | |||
13566 | |||
13567 | } | ||
13568 | |||
13569 | } | ||
13570 | catch (RecognitionException re) { | ||
13571 | reportError(re); | ||
13572 | recover(input,re); | ||
13573 | } | ||
13574 | finally { | ||
13575 | |||
13576 | restoreStackSize(stackSize); | ||
13577 | |||
13578 | } | ||
13579 | return ; | ||
13580 | } | ||
13581 | // $ANTLR end "rule__ALSImpl__Group_1_3__1__Impl" | ||
13582 | |||
13583 | |||
13584 | // $ANTLR start "rule__ALSAnd__Group__0" | ||
13585 | // InternalAlloyLanguage.g:4563:1: rule__ALSAnd__Group__0 : rule__ALSAnd__Group__0__Impl rule__ALSAnd__Group__1 ; | ||
13586 | public final void rule__ALSAnd__Group__0() throws RecognitionException { | ||
13587 | |||
13588 | int stackSize = keepStackSize(); | ||
13589 | |||
13590 | try { | ||
13591 | // InternalAlloyLanguage.g:4567:1: ( rule__ALSAnd__Group__0__Impl rule__ALSAnd__Group__1 ) | ||
13592 | // InternalAlloyLanguage.g:4568:2: rule__ALSAnd__Group__0__Impl rule__ALSAnd__Group__1 | ||
13593 | { | ||
13594 | pushFollow(FOLLOW_29); | ||
13595 | rule__ALSAnd__Group__0__Impl(); | ||
13596 | |||
13597 | state._fsp--; | ||
13598 | if (state.failed) return ; | ||
13599 | pushFollow(FOLLOW_2); | ||
13600 | rule__ALSAnd__Group__1(); | ||
13601 | |||
13602 | state._fsp--; | ||
13603 | if (state.failed) return ; | ||
13604 | |||
13605 | } | ||
13606 | |||
13607 | } | ||
13608 | catch (RecognitionException re) { | ||
13609 | reportError(re); | ||
13610 | recover(input,re); | ||
13611 | } | ||
13612 | finally { | ||
13613 | |||
13614 | restoreStackSize(stackSize); | ||
13615 | |||
13616 | } | ||
13617 | return ; | ||
13618 | } | ||
13619 | // $ANTLR end "rule__ALSAnd__Group__0" | ||
13620 | |||
13621 | |||
13622 | // $ANTLR start "rule__ALSAnd__Group__0__Impl" | ||
13623 | // InternalAlloyLanguage.g:4575:1: rule__ALSAnd__Group__0__Impl : ( ruleALSComparison ) ; | ||
13624 | public final void rule__ALSAnd__Group__0__Impl() throws RecognitionException { | ||
13625 | |||
13626 | int stackSize = keepStackSize(); | ||
13627 | |||
13628 | try { | ||
13629 | // InternalAlloyLanguage.g:4579:1: ( ( ruleALSComparison ) ) | ||
13630 | // InternalAlloyLanguage.g:4580:1: ( ruleALSComparison ) | ||
13631 | { | ||
13632 | // InternalAlloyLanguage.g:4580:1: ( ruleALSComparison ) | ||
13633 | // InternalAlloyLanguage.g:4581:1: ruleALSComparison | ||
13634 | { | ||
13635 | if ( state.backtracking==0 ) { | ||
13636 | before(grammarAccess.getALSAndAccess().getALSComparisonParserRuleCall_0()); | ||
13637 | } | ||
13638 | pushFollow(FOLLOW_2); | ||
13639 | ruleALSComparison(); | ||
13640 | |||
13641 | state._fsp--; | ||
13642 | if (state.failed) return ; | ||
13643 | if ( state.backtracking==0 ) { | ||
13644 | after(grammarAccess.getALSAndAccess().getALSComparisonParserRuleCall_0()); | ||
13645 | } | ||
13646 | |||
13647 | } | ||
13648 | |||
13649 | |||
13650 | } | ||
13651 | |||
13652 | } | ||
13653 | catch (RecognitionException re) { | ||
13654 | reportError(re); | ||
13655 | recover(input,re); | ||
13656 | } | ||
13657 | finally { | ||
13658 | |||
13659 | restoreStackSize(stackSize); | ||
13660 | |||
13661 | } | ||
13662 | return ; | ||
13663 | } | ||
13664 | // $ANTLR end "rule__ALSAnd__Group__0__Impl" | ||
13665 | |||
13666 | |||
13667 | // $ANTLR start "rule__ALSAnd__Group__1" | ||
13668 | // InternalAlloyLanguage.g:4592:1: rule__ALSAnd__Group__1 : rule__ALSAnd__Group__1__Impl ; | ||
13669 | public final void rule__ALSAnd__Group__1() throws RecognitionException { | ||
13670 | |||
13671 | int stackSize = keepStackSize(); | ||
13672 | |||
13673 | try { | ||
13674 | // InternalAlloyLanguage.g:4596:1: ( rule__ALSAnd__Group__1__Impl ) | ||
13675 | // InternalAlloyLanguage.g:4597:2: rule__ALSAnd__Group__1__Impl | ||
13676 | { | ||
13677 | pushFollow(FOLLOW_2); | ||
13678 | rule__ALSAnd__Group__1__Impl(); | ||
13679 | |||
13680 | state._fsp--; | ||
13681 | if (state.failed) return ; | ||
13682 | |||
13683 | } | ||
13684 | |||
13685 | } | ||
13686 | catch (RecognitionException re) { | ||
13687 | reportError(re); | ||
13688 | recover(input,re); | ||
13689 | } | ||
13690 | finally { | ||
13691 | |||
13692 | restoreStackSize(stackSize); | ||
13693 | |||
13694 | } | ||
13695 | return ; | ||
13696 | } | ||
13697 | // $ANTLR end "rule__ALSAnd__Group__1" | ||
13698 | |||
13699 | |||
13700 | // $ANTLR start "rule__ALSAnd__Group__1__Impl" | ||
13701 | // InternalAlloyLanguage.g:4603:1: rule__ALSAnd__Group__1__Impl : ( ( rule__ALSAnd__Group_1__0 )? ) ; | ||
13702 | public final void rule__ALSAnd__Group__1__Impl() throws RecognitionException { | ||
13703 | |||
13704 | int stackSize = keepStackSize(); | ||
13705 | |||
13706 | try { | ||
13707 | // InternalAlloyLanguage.g:4607:1: ( ( ( rule__ALSAnd__Group_1__0 )? ) ) | ||
13708 | // InternalAlloyLanguage.g:4608:1: ( ( rule__ALSAnd__Group_1__0 )? ) | ||
13709 | { | ||
13710 | // InternalAlloyLanguage.g:4608:1: ( ( rule__ALSAnd__Group_1__0 )? ) | ||
13711 | // InternalAlloyLanguage.g:4609:1: ( rule__ALSAnd__Group_1__0 )? | ||
13712 | { | ||
13713 | if ( state.backtracking==0 ) { | ||
13714 | before(grammarAccess.getALSAndAccess().getGroup_1()); | ||
13715 | } | ||
13716 | // InternalAlloyLanguage.g:4610:1: ( rule__ALSAnd__Group_1__0 )? | ||
13717 | int alt34=2; | ||
13718 | int LA34_0 = input.LA(1); | ||
13719 | |||
13720 | if ( ((LA34_0>=17 && LA34_0<=18)) ) { | ||
13721 | alt34=1; | ||
13722 | } | ||
13723 | switch (alt34) { | ||
13724 | case 1 : | ||
13725 | // InternalAlloyLanguage.g:4610:2: rule__ALSAnd__Group_1__0 | ||
13726 | { | ||
13727 | pushFollow(FOLLOW_2); | ||
13728 | rule__ALSAnd__Group_1__0(); | ||
13729 | |||
13730 | state._fsp--; | ||
13731 | if (state.failed) return ; | ||
13732 | |||
13733 | } | ||
13734 | break; | ||
13735 | |||
13736 | } | ||
13737 | |||
13738 | if ( state.backtracking==0 ) { | ||
13739 | after(grammarAccess.getALSAndAccess().getGroup_1()); | ||
13740 | } | ||
13741 | |||
13742 | } | ||
13743 | |||
13744 | |||
13745 | } | ||
13746 | |||
13747 | } | ||
13748 | catch (RecognitionException re) { | ||
13749 | reportError(re); | ||
13750 | recover(input,re); | ||
13751 | } | ||
13752 | finally { | ||
13753 | |||
13754 | restoreStackSize(stackSize); | ||
13755 | |||
13756 | } | ||
13757 | return ; | ||
13758 | } | ||
13759 | // $ANTLR end "rule__ALSAnd__Group__1__Impl" | ||
13760 | |||
13761 | |||
13762 | // $ANTLR start "rule__ALSAnd__Group_1__0" | ||
13763 | // InternalAlloyLanguage.g:4624:1: rule__ALSAnd__Group_1__0 : rule__ALSAnd__Group_1__0__Impl rule__ALSAnd__Group_1__1 ; | ||
13764 | public final void rule__ALSAnd__Group_1__0() throws RecognitionException { | ||
13765 | |||
13766 | int stackSize = keepStackSize(); | ||
13767 | |||
13768 | try { | ||
13769 | // InternalAlloyLanguage.g:4628:1: ( rule__ALSAnd__Group_1__0__Impl rule__ALSAnd__Group_1__1 ) | ||
13770 | // InternalAlloyLanguage.g:4629:2: rule__ALSAnd__Group_1__0__Impl rule__ALSAnd__Group_1__1 | ||
13771 | { | ||
13772 | pushFollow(FOLLOW_29); | ||
13773 | rule__ALSAnd__Group_1__0__Impl(); | ||
13774 | |||
13775 | state._fsp--; | ||
13776 | if (state.failed) return ; | ||
13777 | pushFollow(FOLLOW_2); | ||
13778 | rule__ALSAnd__Group_1__1(); | ||
13779 | |||
13780 | state._fsp--; | ||
13781 | if (state.failed) return ; | ||
13782 | |||
13783 | } | ||
13784 | |||
13785 | } | ||
13786 | catch (RecognitionException re) { | ||
13787 | reportError(re); | ||
13788 | recover(input,re); | ||
13789 | } | ||
13790 | finally { | ||
13791 | |||
13792 | restoreStackSize(stackSize); | ||
13793 | |||
13794 | } | ||
13795 | return ; | ||
13796 | } | ||
13797 | // $ANTLR end "rule__ALSAnd__Group_1__0" | ||
13798 | |||
13799 | |||
13800 | // $ANTLR start "rule__ALSAnd__Group_1__0__Impl" | ||
13801 | // InternalAlloyLanguage.g:4636:1: rule__ALSAnd__Group_1__0__Impl : ( () ) ; | ||
13802 | public final void rule__ALSAnd__Group_1__0__Impl() throws RecognitionException { | ||
13803 | |||
13804 | int stackSize = keepStackSize(); | ||
13805 | |||
13806 | try { | ||
13807 | // InternalAlloyLanguage.g:4640:1: ( ( () ) ) | ||
13808 | // InternalAlloyLanguage.g:4641:1: ( () ) | ||
13809 | { | ||
13810 | // InternalAlloyLanguage.g:4641:1: ( () ) | ||
13811 | // InternalAlloyLanguage.g:4642:1: () | ||
13812 | { | ||
13813 | if ( state.backtracking==0 ) { | ||
13814 | before(grammarAccess.getALSAndAccess().getALSAndLeftOperandAction_1_0()); | ||
13815 | } | ||
13816 | // InternalAlloyLanguage.g:4643:1: () | ||
13817 | // InternalAlloyLanguage.g:4645:1: | ||
13818 | { | ||
13819 | } | ||
13820 | |||
13821 | if ( state.backtracking==0 ) { | ||
13822 | after(grammarAccess.getALSAndAccess().getALSAndLeftOperandAction_1_0()); | ||
13823 | } | ||
13824 | |||
13825 | } | ||
13826 | |||
13827 | |||
13828 | } | ||
13829 | |||
13830 | } | ||
13831 | finally { | ||
13832 | |||
13833 | restoreStackSize(stackSize); | ||
13834 | |||
13835 | } | ||
13836 | return ; | ||
13837 | } | ||
13838 | // $ANTLR end "rule__ALSAnd__Group_1__0__Impl" | ||
13839 | |||
13840 | |||
13841 | // $ANTLR start "rule__ALSAnd__Group_1__1" | ||
13842 | // InternalAlloyLanguage.g:4655:1: rule__ALSAnd__Group_1__1 : rule__ALSAnd__Group_1__1__Impl rule__ALSAnd__Group_1__2 ; | ||
13843 | public final void rule__ALSAnd__Group_1__1() throws RecognitionException { | ||
13844 | |||
13845 | int stackSize = keepStackSize(); | ||
13846 | |||
13847 | try { | ||
13848 | // InternalAlloyLanguage.g:4659:1: ( rule__ALSAnd__Group_1__1__Impl rule__ALSAnd__Group_1__2 ) | ||
13849 | // InternalAlloyLanguage.g:4660:2: rule__ALSAnd__Group_1__1__Impl rule__ALSAnd__Group_1__2 | ||
13850 | { | ||
13851 | pushFollow(FOLLOW_16); | ||
13852 | rule__ALSAnd__Group_1__1__Impl(); | ||
13853 | |||
13854 | state._fsp--; | ||
13855 | if (state.failed) return ; | ||
13856 | pushFollow(FOLLOW_2); | ||
13857 | rule__ALSAnd__Group_1__2(); | ||
13858 | |||
13859 | state._fsp--; | ||
13860 | if (state.failed) return ; | ||
13861 | |||
13862 | } | ||
13863 | |||
13864 | } | ||
13865 | catch (RecognitionException re) { | ||
13866 | reportError(re); | ||
13867 | recover(input,re); | ||
13868 | } | ||
13869 | finally { | ||
13870 | |||
13871 | restoreStackSize(stackSize); | ||
13872 | |||
13873 | } | ||
13874 | return ; | ||
13875 | } | ||
13876 | // $ANTLR end "rule__ALSAnd__Group_1__1" | ||
13877 | |||
13878 | |||
13879 | // $ANTLR start "rule__ALSAnd__Group_1__1__Impl" | ||
13880 | // InternalAlloyLanguage.g:4667:1: rule__ALSAnd__Group_1__1__Impl : ( ( rule__ALSAnd__Alternatives_1_1 ) ) ; | ||
13881 | public final void rule__ALSAnd__Group_1__1__Impl() throws RecognitionException { | ||
13882 | |||
13883 | int stackSize = keepStackSize(); | ||
13884 | |||
13885 | try { | ||
13886 | // InternalAlloyLanguage.g:4671:1: ( ( ( rule__ALSAnd__Alternatives_1_1 ) ) ) | ||
13887 | // InternalAlloyLanguage.g:4672:1: ( ( rule__ALSAnd__Alternatives_1_1 ) ) | ||
13888 | { | ||
13889 | // InternalAlloyLanguage.g:4672:1: ( ( rule__ALSAnd__Alternatives_1_1 ) ) | ||
13890 | // InternalAlloyLanguage.g:4673:1: ( rule__ALSAnd__Alternatives_1_1 ) | ||
13891 | { | ||
13892 | if ( state.backtracking==0 ) { | ||
13893 | before(grammarAccess.getALSAndAccess().getAlternatives_1_1()); | ||
13894 | } | ||
13895 | // InternalAlloyLanguage.g:4674:1: ( rule__ALSAnd__Alternatives_1_1 ) | ||
13896 | // InternalAlloyLanguage.g:4674:2: rule__ALSAnd__Alternatives_1_1 | ||
13897 | { | ||
13898 | pushFollow(FOLLOW_2); | ||
13899 | rule__ALSAnd__Alternatives_1_1(); | ||
13900 | |||
13901 | state._fsp--; | ||
13902 | if (state.failed) return ; | ||
13903 | |||
13904 | } | ||
13905 | |||
13906 | if ( state.backtracking==0 ) { | ||
13907 | after(grammarAccess.getALSAndAccess().getAlternatives_1_1()); | ||
13908 | } | ||
13909 | |||
13910 | } | ||
13911 | |||
13912 | |||
13913 | } | ||
13914 | |||
13915 | } | ||
13916 | catch (RecognitionException re) { | ||
13917 | reportError(re); | ||
13918 | recover(input,re); | ||
13919 | } | ||
13920 | finally { | ||
13921 | |||
13922 | restoreStackSize(stackSize); | ||
13923 | |||
13924 | } | ||
13925 | return ; | ||
13926 | } | ||
13927 | // $ANTLR end "rule__ALSAnd__Group_1__1__Impl" | ||
13928 | |||
13929 | |||
13930 | // $ANTLR start "rule__ALSAnd__Group_1__2" | ||
13931 | // InternalAlloyLanguage.g:4684:1: rule__ALSAnd__Group_1__2 : rule__ALSAnd__Group_1__2__Impl ; | ||
13932 | public final void rule__ALSAnd__Group_1__2() throws RecognitionException { | ||
13933 | |||
13934 | int stackSize = keepStackSize(); | ||
13935 | |||
13936 | try { | ||
13937 | // InternalAlloyLanguage.g:4688:1: ( rule__ALSAnd__Group_1__2__Impl ) | ||
13938 | // InternalAlloyLanguage.g:4689:2: rule__ALSAnd__Group_1__2__Impl | ||
13939 | { | ||
13940 | pushFollow(FOLLOW_2); | ||
13941 | rule__ALSAnd__Group_1__2__Impl(); | ||
13942 | |||
13943 | state._fsp--; | ||
13944 | if (state.failed) return ; | ||
13945 | |||
13946 | } | ||
13947 | |||
13948 | } | ||
13949 | catch (RecognitionException re) { | ||
13950 | reportError(re); | ||
13951 | recover(input,re); | ||
13952 | } | ||
13953 | finally { | ||
13954 | |||
13955 | restoreStackSize(stackSize); | ||
13956 | |||
13957 | } | ||
13958 | return ; | ||
13959 | } | ||
13960 | // $ANTLR end "rule__ALSAnd__Group_1__2" | ||
13961 | |||
13962 | |||
13963 | // $ANTLR start "rule__ALSAnd__Group_1__2__Impl" | ||
13964 | // InternalAlloyLanguage.g:4695:1: rule__ALSAnd__Group_1__2__Impl : ( ( rule__ALSAnd__RightOperandAssignment_1_2 ) ) ; | ||
13965 | public final void rule__ALSAnd__Group_1__2__Impl() throws RecognitionException { | ||
13966 | |||
13967 | int stackSize = keepStackSize(); | ||
13968 | |||
13969 | try { | ||
13970 | // InternalAlloyLanguage.g:4699:1: ( ( ( rule__ALSAnd__RightOperandAssignment_1_2 ) ) ) | ||
13971 | // InternalAlloyLanguage.g:4700:1: ( ( rule__ALSAnd__RightOperandAssignment_1_2 ) ) | ||
13972 | { | ||
13973 | // InternalAlloyLanguage.g:4700:1: ( ( rule__ALSAnd__RightOperandAssignment_1_2 ) ) | ||
13974 | // InternalAlloyLanguage.g:4701:1: ( rule__ALSAnd__RightOperandAssignment_1_2 ) | ||
13975 | { | ||
13976 | if ( state.backtracking==0 ) { | ||
13977 | before(grammarAccess.getALSAndAccess().getRightOperandAssignment_1_2()); | ||
13978 | } | ||
13979 | // InternalAlloyLanguage.g:4702:1: ( rule__ALSAnd__RightOperandAssignment_1_2 ) | ||
13980 | // InternalAlloyLanguage.g:4702:2: rule__ALSAnd__RightOperandAssignment_1_2 | ||
13981 | { | ||
13982 | pushFollow(FOLLOW_2); | ||
13983 | rule__ALSAnd__RightOperandAssignment_1_2(); | ||
13984 | |||
13985 | state._fsp--; | ||
13986 | if (state.failed) return ; | ||
13987 | |||
13988 | } | ||
13989 | |||
13990 | if ( state.backtracking==0 ) { | ||
13991 | after(grammarAccess.getALSAndAccess().getRightOperandAssignment_1_2()); | ||
13992 | } | ||
13993 | |||
13994 | } | ||
13995 | |||
13996 | |||
13997 | } | ||
13998 | |||
13999 | } | ||
14000 | catch (RecognitionException re) { | ||
14001 | reportError(re); | ||
14002 | recover(input,re); | ||
14003 | } | ||
14004 | finally { | ||
14005 | |||
14006 | restoreStackSize(stackSize); | ||
14007 | |||
14008 | } | ||
14009 | return ; | ||
14010 | } | ||
14011 | // $ANTLR end "rule__ALSAnd__Group_1__2__Impl" | ||
14012 | |||
14013 | |||
14014 | // $ANTLR start "rule__ALSComparison__Group__0" | ||
14015 | // InternalAlloyLanguage.g:4718:1: rule__ALSComparison__Group__0 : rule__ALSComparison__Group__0__Impl rule__ALSComparison__Group__1 ; | ||
14016 | public final void rule__ALSComparison__Group__0() throws RecognitionException { | ||
14017 | |||
14018 | int stackSize = keepStackSize(); | ||
14019 | |||
14020 | try { | ||
14021 | // InternalAlloyLanguage.g:4722:1: ( rule__ALSComparison__Group__0__Impl rule__ALSComparison__Group__1 ) | ||
14022 | // InternalAlloyLanguage.g:4723:2: rule__ALSComparison__Group__0__Impl rule__ALSComparison__Group__1 | ||
14023 | { | ||
14024 | pushFollow(FOLLOW_30); | ||
14025 | rule__ALSComparison__Group__0__Impl(); | ||
14026 | |||
14027 | state._fsp--; | ||
14028 | if (state.failed) return ; | ||
14029 | pushFollow(FOLLOW_2); | ||
14030 | rule__ALSComparison__Group__1(); | ||
14031 | |||
14032 | state._fsp--; | ||
14033 | if (state.failed) return ; | ||
14034 | |||
14035 | } | ||
14036 | |||
14037 | } | ||
14038 | catch (RecognitionException re) { | ||
14039 | reportError(re); | ||
14040 | recover(input,re); | ||
14041 | } | ||
14042 | finally { | ||
14043 | |||
14044 | restoreStackSize(stackSize); | ||
14045 | |||
14046 | } | ||
14047 | return ; | ||
14048 | } | ||
14049 | // $ANTLR end "rule__ALSComparison__Group__0" | ||
14050 | |||
14051 | |||
14052 | // $ANTLR start "rule__ALSComparison__Group__0__Impl" | ||
14053 | // InternalAlloyLanguage.g:4730:1: rule__ALSComparison__Group__0__Impl : ( ruleALSOverride ) ; | ||
14054 | public final void rule__ALSComparison__Group__0__Impl() throws RecognitionException { | ||
14055 | |||
14056 | int stackSize = keepStackSize(); | ||
14057 | |||
14058 | try { | ||
14059 | // InternalAlloyLanguage.g:4734:1: ( ( ruleALSOverride ) ) | ||
14060 | // InternalAlloyLanguage.g:4735:1: ( ruleALSOverride ) | ||
14061 | { | ||
14062 | // InternalAlloyLanguage.g:4735:1: ( ruleALSOverride ) | ||
14063 | // InternalAlloyLanguage.g:4736:1: ruleALSOverride | ||
14064 | { | ||
14065 | if ( state.backtracking==0 ) { | ||
14066 | before(grammarAccess.getALSComparisonAccess().getALSOverrideParserRuleCall_0()); | ||
14067 | } | ||
14068 | pushFollow(FOLLOW_2); | ||
14069 | ruleALSOverride(); | ||
14070 | |||
14071 | state._fsp--; | ||
14072 | if (state.failed) return ; | ||
14073 | if ( state.backtracking==0 ) { | ||
14074 | after(grammarAccess.getALSComparisonAccess().getALSOverrideParserRuleCall_0()); | ||
14075 | } | ||
14076 | |||
14077 | } | ||
14078 | |||
14079 | |||
14080 | } | ||
14081 | |||
14082 | } | ||
14083 | catch (RecognitionException re) { | ||
14084 | reportError(re); | ||
14085 | recover(input,re); | ||
14086 | } | ||
14087 | finally { | ||
14088 | |||
14089 | restoreStackSize(stackSize); | ||
14090 | |||
14091 | } | ||
14092 | return ; | ||
14093 | } | ||
14094 | // $ANTLR end "rule__ALSComparison__Group__0__Impl" | ||
14095 | |||
14096 | |||
14097 | // $ANTLR start "rule__ALSComparison__Group__1" | ||
14098 | // InternalAlloyLanguage.g:4747:1: rule__ALSComparison__Group__1 : rule__ALSComparison__Group__1__Impl ; | ||
14099 | public final void rule__ALSComparison__Group__1() throws RecognitionException { | ||
14100 | |||
14101 | int stackSize = keepStackSize(); | ||
14102 | |||
14103 | try { | ||
14104 | // InternalAlloyLanguage.g:4751:1: ( rule__ALSComparison__Group__1__Impl ) | ||
14105 | // InternalAlloyLanguage.g:4752:2: rule__ALSComparison__Group__1__Impl | ||
14106 | { | ||
14107 | pushFollow(FOLLOW_2); | ||
14108 | rule__ALSComparison__Group__1__Impl(); | ||
14109 | |||
14110 | state._fsp--; | ||
14111 | if (state.failed) return ; | ||
14112 | |||
14113 | } | ||
14114 | |||
14115 | } | ||
14116 | catch (RecognitionException re) { | ||
14117 | reportError(re); | ||
14118 | recover(input,re); | ||
14119 | } | ||
14120 | finally { | ||
14121 | |||
14122 | restoreStackSize(stackSize); | ||
14123 | |||
14124 | } | ||
14125 | return ; | ||
14126 | } | ||
14127 | // $ANTLR end "rule__ALSComparison__Group__1" | ||
14128 | |||
14129 | |||
14130 | // $ANTLR start "rule__ALSComparison__Group__1__Impl" | ||
14131 | // InternalAlloyLanguage.g:4758:1: rule__ALSComparison__Group__1__Impl : ( ( rule__ALSComparison__Group_1__0 )? ) ; | ||
14132 | public final void rule__ALSComparison__Group__1__Impl() throws RecognitionException { | ||
14133 | |||
14134 | int stackSize = keepStackSize(); | ||
14135 | |||
14136 | try { | ||
14137 | // InternalAlloyLanguage.g:4762:1: ( ( ( rule__ALSComparison__Group_1__0 )? ) ) | ||
14138 | // InternalAlloyLanguage.g:4763:1: ( ( rule__ALSComparison__Group_1__0 )? ) | ||
14139 | { | ||
14140 | // InternalAlloyLanguage.g:4763:1: ( ( rule__ALSComparison__Group_1__0 )? ) | ||
14141 | // InternalAlloyLanguage.g:4764:1: ( rule__ALSComparison__Group_1__0 )? | ||
14142 | { | ||
14143 | if ( state.backtracking==0 ) { | ||
14144 | before(grammarAccess.getALSComparisonAccess().getGroup_1()); | ||
14145 | } | ||
14146 | // InternalAlloyLanguage.g:4765:1: ( rule__ALSComparison__Group_1__0 )? | ||
14147 | int alt35=2; | ||
14148 | int LA35_0 = input.LA(1); | ||
14149 | |||
14150 | if ( (LA35_0==38||(LA35_0>=47 && LA35_0<=52)) ) { | ||
14151 | alt35=1; | ||
14152 | } | ||
14153 | switch (alt35) { | ||
14154 | case 1 : | ||
14155 | // InternalAlloyLanguage.g:4765:2: rule__ALSComparison__Group_1__0 | ||
14156 | { | ||
14157 | pushFollow(FOLLOW_2); | ||
14158 | rule__ALSComparison__Group_1__0(); | ||
14159 | |||
14160 | state._fsp--; | ||
14161 | if (state.failed) return ; | ||
14162 | |||
14163 | } | ||
14164 | break; | ||
14165 | |||
14166 | } | ||
14167 | |||
14168 | if ( state.backtracking==0 ) { | ||
14169 | after(grammarAccess.getALSComparisonAccess().getGroup_1()); | ||
14170 | } | ||
14171 | |||
14172 | } | ||
14173 | |||
14174 | |||
14175 | } | ||
14176 | |||
14177 | } | ||
14178 | catch (RecognitionException re) { | ||
14179 | reportError(re); | ||
14180 | recover(input,re); | ||
14181 | } | ||
14182 | finally { | ||
14183 | |||
14184 | restoreStackSize(stackSize); | ||
14185 | |||
14186 | } | ||
14187 | return ; | ||
14188 | } | ||
14189 | // $ANTLR end "rule__ALSComparison__Group__1__Impl" | ||
14190 | |||
14191 | |||
14192 | // $ANTLR start "rule__ALSComparison__Group_1__0" | ||
14193 | // InternalAlloyLanguage.g:4779:1: rule__ALSComparison__Group_1__0 : rule__ALSComparison__Group_1__0__Impl rule__ALSComparison__Group_1__1 ; | ||
14194 | public final void rule__ALSComparison__Group_1__0() throws RecognitionException { | ||
14195 | |||
14196 | int stackSize = keepStackSize(); | ||
14197 | |||
14198 | try { | ||
14199 | // InternalAlloyLanguage.g:4783:1: ( rule__ALSComparison__Group_1__0__Impl rule__ALSComparison__Group_1__1 ) | ||
14200 | // InternalAlloyLanguage.g:4784:2: rule__ALSComparison__Group_1__0__Impl rule__ALSComparison__Group_1__1 | ||
14201 | { | ||
14202 | pushFollow(FOLLOW_16); | ||
14203 | rule__ALSComparison__Group_1__0__Impl(); | ||
14204 | |||
14205 | state._fsp--; | ||
14206 | if (state.failed) return ; | ||
14207 | pushFollow(FOLLOW_2); | ||
14208 | rule__ALSComparison__Group_1__1(); | ||
14209 | |||
14210 | state._fsp--; | ||
14211 | if (state.failed) return ; | ||
14212 | |||
14213 | } | ||
14214 | |||
14215 | } | ||
14216 | catch (RecognitionException re) { | ||
14217 | reportError(re); | ||
14218 | recover(input,re); | ||
14219 | } | ||
14220 | finally { | ||
14221 | |||
14222 | restoreStackSize(stackSize); | ||
14223 | |||
14224 | } | ||
14225 | return ; | ||
14226 | } | ||
14227 | // $ANTLR end "rule__ALSComparison__Group_1__0" | ||
14228 | |||
14229 | |||
14230 | // $ANTLR start "rule__ALSComparison__Group_1__0__Impl" | ||
14231 | // InternalAlloyLanguage.g:4791:1: rule__ALSComparison__Group_1__0__Impl : ( ( rule__ALSComparison__Alternatives_1_0 ) ) ; | ||
14232 | public final void rule__ALSComparison__Group_1__0__Impl() throws RecognitionException { | ||
14233 | |||
14234 | int stackSize = keepStackSize(); | ||
14235 | |||
14236 | try { | ||
14237 | // InternalAlloyLanguage.g:4795:1: ( ( ( rule__ALSComparison__Alternatives_1_0 ) ) ) | ||
14238 | // InternalAlloyLanguage.g:4796:1: ( ( rule__ALSComparison__Alternatives_1_0 ) ) | ||
14239 | { | ||
14240 | // InternalAlloyLanguage.g:4796:1: ( ( rule__ALSComparison__Alternatives_1_0 ) ) | ||
14241 | // InternalAlloyLanguage.g:4797:1: ( rule__ALSComparison__Alternatives_1_0 ) | ||
14242 | { | ||
14243 | if ( state.backtracking==0 ) { | ||
14244 | before(grammarAccess.getALSComparisonAccess().getAlternatives_1_0()); | ||
14245 | } | ||
14246 | // InternalAlloyLanguage.g:4798:1: ( rule__ALSComparison__Alternatives_1_0 ) | ||
14247 | // InternalAlloyLanguage.g:4798:2: rule__ALSComparison__Alternatives_1_0 | ||
14248 | { | ||
14249 | pushFollow(FOLLOW_2); | ||
14250 | rule__ALSComparison__Alternatives_1_0(); | ||
14251 | |||
14252 | state._fsp--; | ||
14253 | if (state.failed) return ; | ||
14254 | |||
14255 | } | ||
14256 | |||
14257 | if ( state.backtracking==0 ) { | ||
14258 | after(grammarAccess.getALSComparisonAccess().getAlternatives_1_0()); | ||
14259 | } | ||
14260 | |||
14261 | } | ||
14262 | |||
14263 | |||
14264 | } | ||
14265 | |||
14266 | } | ||
14267 | catch (RecognitionException re) { | ||
14268 | reportError(re); | ||
14269 | recover(input,re); | ||
14270 | } | ||
14271 | finally { | ||
14272 | |||
14273 | restoreStackSize(stackSize); | ||
14274 | |||
14275 | } | ||
14276 | return ; | ||
14277 | } | ||
14278 | // $ANTLR end "rule__ALSComparison__Group_1__0__Impl" | ||
14279 | |||
14280 | |||
14281 | // $ANTLR start "rule__ALSComparison__Group_1__1" | ||
14282 | // InternalAlloyLanguage.g:4808:1: rule__ALSComparison__Group_1__1 : rule__ALSComparison__Group_1__1__Impl ; | ||
14283 | public final void rule__ALSComparison__Group_1__1() throws RecognitionException { | ||
14284 | |||
14285 | int stackSize = keepStackSize(); | ||
14286 | |||
14287 | try { | ||
14288 | // InternalAlloyLanguage.g:4812:1: ( rule__ALSComparison__Group_1__1__Impl ) | ||
14289 | // InternalAlloyLanguage.g:4813:2: rule__ALSComparison__Group_1__1__Impl | ||
14290 | { | ||
14291 | pushFollow(FOLLOW_2); | ||
14292 | rule__ALSComparison__Group_1__1__Impl(); | ||
14293 | |||
14294 | state._fsp--; | ||
14295 | if (state.failed) return ; | ||
14296 | |||
14297 | } | ||
14298 | |||
14299 | } | ||
14300 | catch (RecognitionException re) { | ||
14301 | reportError(re); | ||
14302 | recover(input,re); | ||
14303 | } | ||
14304 | finally { | ||
14305 | |||
14306 | restoreStackSize(stackSize); | ||
14307 | |||
14308 | } | ||
14309 | return ; | ||
14310 | } | ||
14311 | // $ANTLR end "rule__ALSComparison__Group_1__1" | ||
14312 | |||
14313 | |||
14314 | // $ANTLR start "rule__ALSComparison__Group_1__1__Impl" | ||
14315 | // InternalAlloyLanguage.g:4819:1: rule__ALSComparison__Group_1__1__Impl : ( ( rule__ALSComparison__RightOperandAssignment_1_1 ) ) ; | ||
14316 | public final void rule__ALSComparison__Group_1__1__Impl() throws RecognitionException { | ||
14317 | |||
14318 | int stackSize = keepStackSize(); | ||
14319 | |||
14320 | try { | ||
14321 | // InternalAlloyLanguage.g:4823:1: ( ( ( rule__ALSComparison__RightOperandAssignment_1_1 ) ) ) | ||
14322 | // InternalAlloyLanguage.g:4824:1: ( ( rule__ALSComparison__RightOperandAssignment_1_1 ) ) | ||
14323 | { | ||
14324 | // InternalAlloyLanguage.g:4824:1: ( ( rule__ALSComparison__RightOperandAssignment_1_1 ) ) | ||
14325 | // InternalAlloyLanguage.g:4825:1: ( rule__ALSComparison__RightOperandAssignment_1_1 ) | ||
14326 | { | ||
14327 | if ( state.backtracking==0 ) { | ||
14328 | before(grammarAccess.getALSComparisonAccess().getRightOperandAssignment_1_1()); | ||
14329 | } | ||
14330 | // InternalAlloyLanguage.g:4826:1: ( rule__ALSComparison__RightOperandAssignment_1_1 ) | ||
14331 | // InternalAlloyLanguage.g:4826:2: rule__ALSComparison__RightOperandAssignment_1_1 | ||
14332 | { | ||
14333 | pushFollow(FOLLOW_2); | ||
14334 | rule__ALSComparison__RightOperandAssignment_1_1(); | ||
14335 | |||
14336 | state._fsp--; | ||
14337 | if (state.failed) return ; | ||
14338 | |||
14339 | } | ||
14340 | |||
14341 | if ( state.backtracking==0 ) { | ||
14342 | after(grammarAccess.getALSComparisonAccess().getRightOperandAssignment_1_1()); | ||
14343 | } | ||
14344 | |||
14345 | } | ||
14346 | |||
14347 | |||
14348 | } | ||
14349 | |||
14350 | } | ||
14351 | catch (RecognitionException re) { | ||
14352 | reportError(re); | ||
14353 | recover(input,re); | ||
14354 | } | ||
14355 | finally { | ||
14356 | |||
14357 | restoreStackSize(stackSize); | ||
14358 | |||
14359 | } | ||
14360 | return ; | ||
14361 | } | ||
14362 | // $ANTLR end "rule__ALSComparison__Group_1__1__Impl" | ||
14363 | |||
14364 | |||
14365 | // $ANTLR start "rule__ALSComparison__Group_1_0_0__0" | ||
14366 | // InternalAlloyLanguage.g:4840:1: rule__ALSComparison__Group_1_0_0__0 : rule__ALSComparison__Group_1_0_0__0__Impl rule__ALSComparison__Group_1_0_0__1 ; | ||
14367 | public final void rule__ALSComparison__Group_1_0_0__0() throws RecognitionException { | ||
14368 | |||
14369 | int stackSize = keepStackSize(); | ||
14370 | |||
14371 | try { | ||
14372 | // InternalAlloyLanguage.g:4844:1: ( rule__ALSComparison__Group_1_0_0__0__Impl rule__ALSComparison__Group_1_0_0__1 ) | ||
14373 | // InternalAlloyLanguage.g:4845:2: rule__ALSComparison__Group_1_0_0__0__Impl rule__ALSComparison__Group_1_0_0__1 | ||
14374 | { | ||
14375 | pushFollow(FOLLOW_31); | ||
14376 | rule__ALSComparison__Group_1_0_0__0__Impl(); | ||
14377 | |||
14378 | state._fsp--; | ||
14379 | if (state.failed) return ; | ||
14380 | pushFollow(FOLLOW_2); | ||
14381 | rule__ALSComparison__Group_1_0_0__1(); | ||
14382 | |||
14383 | state._fsp--; | ||
14384 | if (state.failed) return ; | ||
14385 | |||
14386 | } | ||
14387 | |||
14388 | } | ||
14389 | catch (RecognitionException re) { | ||
14390 | reportError(re); | ||
14391 | recover(input,re); | ||
14392 | } | ||
14393 | finally { | ||
14394 | |||
14395 | restoreStackSize(stackSize); | ||
14396 | |||
14397 | } | ||
14398 | return ; | ||
14399 | } | ||
14400 | // $ANTLR end "rule__ALSComparison__Group_1_0_0__0" | ||
14401 | |||
14402 | |||
14403 | // $ANTLR start "rule__ALSComparison__Group_1_0_0__0__Impl" | ||
14404 | // InternalAlloyLanguage.g:4852:1: rule__ALSComparison__Group_1_0_0__0__Impl : ( () ) ; | ||
14405 | public final void rule__ALSComparison__Group_1_0_0__0__Impl() throws RecognitionException { | ||
14406 | |||
14407 | int stackSize = keepStackSize(); | ||
14408 | |||
14409 | try { | ||
14410 | // InternalAlloyLanguage.g:4856:1: ( ( () ) ) | ||
14411 | // InternalAlloyLanguage.g:4857:1: ( () ) | ||
14412 | { | ||
14413 | // InternalAlloyLanguage.g:4857:1: ( () ) | ||
14414 | // InternalAlloyLanguage.g:4858:1: () | ||
14415 | { | ||
14416 | if ( state.backtracking==0 ) { | ||
14417 | before(grammarAccess.getALSComparisonAccess().getALSEqualsLeftOperandAction_1_0_0_0()); | ||
14418 | } | ||
14419 | // InternalAlloyLanguage.g:4859:1: () | ||
14420 | // InternalAlloyLanguage.g:4861:1: | ||
14421 | { | ||
14422 | } | ||
14423 | |||
14424 | if ( state.backtracking==0 ) { | ||
14425 | after(grammarAccess.getALSComparisonAccess().getALSEqualsLeftOperandAction_1_0_0_0()); | ||
14426 | } | ||
14427 | |||
14428 | } | ||
14429 | |||
14430 | |||
14431 | } | ||
14432 | |||
14433 | } | ||
14434 | finally { | ||
14435 | |||
14436 | restoreStackSize(stackSize); | ||
14437 | |||
14438 | } | ||
14439 | return ; | ||
14440 | } | ||
14441 | // $ANTLR end "rule__ALSComparison__Group_1_0_0__0__Impl" | ||
14442 | |||
14443 | |||
14444 | // $ANTLR start "rule__ALSComparison__Group_1_0_0__1" | ||
14445 | // InternalAlloyLanguage.g:4871:1: rule__ALSComparison__Group_1_0_0__1 : rule__ALSComparison__Group_1_0_0__1__Impl ; | ||
14446 | public final void rule__ALSComparison__Group_1_0_0__1() throws RecognitionException { | ||
14447 | |||
14448 | int stackSize = keepStackSize(); | ||
14449 | |||
14450 | try { | ||
14451 | // InternalAlloyLanguage.g:4875:1: ( rule__ALSComparison__Group_1_0_0__1__Impl ) | ||
14452 | // InternalAlloyLanguage.g:4876:2: rule__ALSComparison__Group_1_0_0__1__Impl | ||
14453 | { | ||
14454 | pushFollow(FOLLOW_2); | ||
14455 | rule__ALSComparison__Group_1_0_0__1__Impl(); | ||
14456 | |||
14457 | state._fsp--; | ||
14458 | if (state.failed) return ; | ||
14459 | |||
14460 | } | ||
14461 | |||
14462 | } | ||
14463 | catch (RecognitionException re) { | ||
14464 | reportError(re); | ||
14465 | recover(input,re); | ||
14466 | } | ||
14467 | finally { | ||
14468 | |||
14469 | restoreStackSize(stackSize); | ||
14470 | |||
14471 | } | ||
14472 | return ; | ||
14473 | } | ||
14474 | // $ANTLR end "rule__ALSComparison__Group_1_0_0__1" | ||
14475 | |||
14476 | |||
14477 | // $ANTLR start "rule__ALSComparison__Group_1_0_0__1__Impl" | ||
14478 | // InternalAlloyLanguage.g:4882:1: rule__ALSComparison__Group_1_0_0__1__Impl : ( '=' ) ; | ||
14479 | public final void rule__ALSComparison__Group_1_0_0__1__Impl() throws RecognitionException { | ||
14480 | |||
14481 | int stackSize = keepStackSize(); | ||
14482 | |||
14483 | try { | ||
14484 | // InternalAlloyLanguage.g:4886:1: ( ( '=' ) ) | ||
14485 | // InternalAlloyLanguage.g:4887:1: ( '=' ) | ||
14486 | { | ||
14487 | // InternalAlloyLanguage.g:4887:1: ( '=' ) | ||
14488 | // InternalAlloyLanguage.g:4888:1: '=' | ||
14489 | { | ||
14490 | if ( state.backtracking==0 ) { | ||
14491 | before(grammarAccess.getALSComparisonAccess().getEqualsSignKeyword_1_0_0_1()); | ||
14492 | } | ||
14493 | match(input,47,FOLLOW_2); if (state.failed) return ; | ||
14494 | if ( state.backtracking==0 ) { | ||
14495 | after(grammarAccess.getALSComparisonAccess().getEqualsSignKeyword_1_0_0_1()); | ||
14496 | } | ||
14497 | |||
14498 | } | ||
14499 | |||
14500 | |||
14501 | } | ||
14502 | |||
14503 | } | ||
14504 | catch (RecognitionException re) { | ||
14505 | reportError(re); | ||
14506 | recover(input,re); | ||
14507 | } | ||
14508 | finally { | ||
14509 | |||
14510 | restoreStackSize(stackSize); | ||
14511 | |||
14512 | } | ||
14513 | return ; | ||
14514 | } | ||
14515 | // $ANTLR end "rule__ALSComparison__Group_1_0_0__1__Impl" | ||
14516 | |||
14517 | |||
14518 | // $ANTLR start "rule__ALSComparison__Group_1_0_1__0" | ||
14519 | // InternalAlloyLanguage.g:4905:1: rule__ALSComparison__Group_1_0_1__0 : rule__ALSComparison__Group_1_0_1__0__Impl rule__ALSComparison__Group_1_0_1__1 ; | ||
14520 | public final void rule__ALSComparison__Group_1_0_1__0() throws RecognitionException { | ||
14521 | |||
14522 | int stackSize = keepStackSize(); | ||
14523 | |||
14524 | try { | ||
14525 | // InternalAlloyLanguage.g:4909:1: ( rule__ALSComparison__Group_1_0_1__0__Impl rule__ALSComparison__Group_1_0_1__1 ) | ||
14526 | // InternalAlloyLanguage.g:4910:2: rule__ALSComparison__Group_1_0_1__0__Impl rule__ALSComparison__Group_1_0_1__1 | ||
14527 | { | ||
14528 | pushFollow(FOLLOW_32); | ||
14529 | rule__ALSComparison__Group_1_0_1__0__Impl(); | ||
14530 | |||
14531 | state._fsp--; | ||
14532 | if (state.failed) return ; | ||
14533 | pushFollow(FOLLOW_2); | ||
14534 | rule__ALSComparison__Group_1_0_1__1(); | ||
14535 | |||
14536 | state._fsp--; | ||
14537 | if (state.failed) return ; | ||
14538 | |||
14539 | } | ||
14540 | |||
14541 | } | ||
14542 | catch (RecognitionException re) { | ||
14543 | reportError(re); | ||
14544 | recover(input,re); | ||
14545 | } | ||
14546 | finally { | ||
14547 | |||
14548 | restoreStackSize(stackSize); | ||
14549 | |||
14550 | } | ||
14551 | return ; | ||
14552 | } | ||
14553 | // $ANTLR end "rule__ALSComparison__Group_1_0_1__0" | ||
14554 | |||
14555 | |||
14556 | // $ANTLR start "rule__ALSComparison__Group_1_0_1__0__Impl" | ||
14557 | // InternalAlloyLanguage.g:4917:1: rule__ALSComparison__Group_1_0_1__0__Impl : ( () ) ; | ||
14558 | public final void rule__ALSComparison__Group_1_0_1__0__Impl() throws RecognitionException { | ||
14559 | |||
14560 | int stackSize = keepStackSize(); | ||
14561 | |||
14562 | try { | ||
14563 | // InternalAlloyLanguage.g:4921:1: ( ( () ) ) | ||
14564 | // InternalAlloyLanguage.g:4922:1: ( () ) | ||
14565 | { | ||
14566 | // InternalAlloyLanguage.g:4922:1: ( () ) | ||
14567 | // InternalAlloyLanguage.g:4923:1: () | ||
14568 | { | ||
14569 | if ( state.backtracking==0 ) { | ||
14570 | before(grammarAccess.getALSComparisonAccess().getALSNotEqualsLeftOperandAction_1_0_1_0()); | ||
14571 | } | ||
14572 | // InternalAlloyLanguage.g:4924:1: () | ||
14573 | // InternalAlloyLanguage.g:4926:1: | ||
14574 | { | ||
14575 | } | ||
14576 | |||
14577 | if ( state.backtracking==0 ) { | ||
14578 | after(grammarAccess.getALSComparisonAccess().getALSNotEqualsLeftOperandAction_1_0_1_0()); | ||
14579 | } | ||
14580 | |||
14581 | } | ||
14582 | |||
14583 | |||
14584 | } | ||
14585 | |||
14586 | } | ||
14587 | finally { | ||
14588 | |||
14589 | restoreStackSize(stackSize); | ||
14590 | |||
14591 | } | ||
14592 | return ; | ||
14593 | } | ||
14594 | // $ANTLR end "rule__ALSComparison__Group_1_0_1__0__Impl" | ||
14595 | |||
14596 | |||
14597 | // $ANTLR start "rule__ALSComparison__Group_1_0_1__1" | ||
14598 | // InternalAlloyLanguage.g:4936:1: rule__ALSComparison__Group_1_0_1__1 : rule__ALSComparison__Group_1_0_1__1__Impl ; | ||
14599 | public final void rule__ALSComparison__Group_1_0_1__1() throws RecognitionException { | ||
14600 | |||
14601 | int stackSize = keepStackSize(); | ||
14602 | |||
14603 | try { | ||
14604 | // InternalAlloyLanguage.g:4940:1: ( rule__ALSComparison__Group_1_0_1__1__Impl ) | ||
14605 | // InternalAlloyLanguage.g:4941:2: rule__ALSComparison__Group_1_0_1__1__Impl | ||
14606 | { | ||
14607 | pushFollow(FOLLOW_2); | ||
14608 | rule__ALSComparison__Group_1_0_1__1__Impl(); | ||
14609 | |||
14610 | state._fsp--; | ||
14611 | if (state.failed) return ; | ||
14612 | |||
14613 | } | ||
14614 | |||
14615 | } | ||
14616 | catch (RecognitionException re) { | ||
14617 | reportError(re); | ||
14618 | recover(input,re); | ||
14619 | } | ||
14620 | finally { | ||
14621 | |||
14622 | restoreStackSize(stackSize); | ||
14623 | |||
14624 | } | ||
14625 | return ; | ||
14626 | } | ||
14627 | // $ANTLR end "rule__ALSComparison__Group_1_0_1__1" | ||
14628 | |||
14629 | |||
14630 | // $ANTLR start "rule__ALSComparison__Group_1_0_1__1__Impl" | ||
14631 | // InternalAlloyLanguage.g:4947:1: rule__ALSComparison__Group_1_0_1__1__Impl : ( '!=' ) ; | ||
14632 | public final void rule__ALSComparison__Group_1_0_1__1__Impl() throws RecognitionException { | ||
14633 | |||
14634 | int stackSize = keepStackSize(); | ||
14635 | |||
14636 | try { | ||
14637 | // InternalAlloyLanguage.g:4951:1: ( ( '!=' ) ) | ||
14638 | // InternalAlloyLanguage.g:4952:1: ( '!=' ) | ||
14639 | { | ||
14640 | // InternalAlloyLanguage.g:4952:1: ( '!=' ) | ||
14641 | // InternalAlloyLanguage.g:4953:1: '!=' | ||
14642 | { | ||
14643 | if ( state.backtracking==0 ) { | ||
14644 | before(grammarAccess.getALSComparisonAccess().getExclamationMarkEqualsSignKeyword_1_0_1_1()); | ||
14645 | } | ||
14646 | match(input,48,FOLLOW_2); if (state.failed) return ; | ||
14647 | if ( state.backtracking==0 ) { | ||
14648 | after(grammarAccess.getALSComparisonAccess().getExclamationMarkEqualsSignKeyword_1_0_1_1()); | ||
14649 | } | ||
14650 | |||
14651 | } | ||
14652 | |||
14653 | |||
14654 | } | ||
14655 | |||
14656 | } | ||
14657 | catch (RecognitionException re) { | ||
14658 | reportError(re); | ||
14659 | recover(input,re); | ||
14660 | } | ||
14661 | finally { | ||
14662 | |||
14663 | restoreStackSize(stackSize); | ||
14664 | |||
14665 | } | ||
14666 | return ; | ||
14667 | } | ||
14668 | // $ANTLR end "rule__ALSComparison__Group_1_0_1__1__Impl" | ||
14669 | |||
14670 | |||
14671 | // $ANTLR start "rule__ALSComparison__Group_1_0_2__0" | ||
14672 | // InternalAlloyLanguage.g:4970:1: rule__ALSComparison__Group_1_0_2__0 : rule__ALSComparison__Group_1_0_2__0__Impl rule__ALSComparison__Group_1_0_2__1 ; | ||
14673 | public final void rule__ALSComparison__Group_1_0_2__0() throws RecognitionException { | ||
14674 | |||
14675 | int stackSize = keepStackSize(); | ||
14676 | |||
14677 | try { | ||
14678 | // InternalAlloyLanguage.g:4974:1: ( rule__ALSComparison__Group_1_0_2__0__Impl rule__ALSComparison__Group_1_0_2__1 ) | ||
14679 | // InternalAlloyLanguage.g:4975:2: rule__ALSComparison__Group_1_0_2__0__Impl rule__ALSComparison__Group_1_0_2__1 | ||
14680 | { | ||
14681 | pushFollow(FOLLOW_33); | ||
14682 | rule__ALSComparison__Group_1_0_2__0__Impl(); | ||
14683 | |||
14684 | state._fsp--; | ||
14685 | if (state.failed) return ; | ||
14686 | pushFollow(FOLLOW_2); | ||
14687 | rule__ALSComparison__Group_1_0_2__1(); | ||
14688 | |||
14689 | state._fsp--; | ||
14690 | if (state.failed) return ; | ||
14691 | |||
14692 | } | ||
14693 | |||
14694 | } | ||
14695 | catch (RecognitionException re) { | ||
14696 | reportError(re); | ||
14697 | recover(input,re); | ||
14698 | } | ||
14699 | finally { | ||
14700 | |||
14701 | restoreStackSize(stackSize); | ||
14702 | |||
14703 | } | ||
14704 | return ; | ||
14705 | } | ||
14706 | // $ANTLR end "rule__ALSComparison__Group_1_0_2__0" | ||
14707 | |||
14708 | |||
14709 | // $ANTLR start "rule__ALSComparison__Group_1_0_2__0__Impl" | ||
14710 | // InternalAlloyLanguage.g:4982:1: rule__ALSComparison__Group_1_0_2__0__Impl : ( () ) ; | ||
14711 | public final void rule__ALSComparison__Group_1_0_2__0__Impl() throws RecognitionException { | ||
14712 | |||
14713 | int stackSize = keepStackSize(); | ||
14714 | |||
14715 | try { | ||
14716 | // InternalAlloyLanguage.g:4986:1: ( ( () ) ) | ||
14717 | // InternalAlloyLanguage.g:4987:1: ( () ) | ||
14718 | { | ||
14719 | // InternalAlloyLanguage.g:4987:1: ( () ) | ||
14720 | // InternalAlloyLanguage.g:4988:1: () | ||
14721 | { | ||
14722 | if ( state.backtracking==0 ) { | ||
14723 | before(grammarAccess.getALSComparisonAccess().getALSSubsetLeftOperandAction_1_0_2_0()); | ||
14724 | } | ||
14725 | // InternalAlloyLanguage.g:4989:1: () | ||
14726 | // InternalAlloyLanguage.g:4991:1: | ||
14727 | { | ||
14728 | } | ||
14729 | |||
14730 | if ( state.backtracking==0 ) { | ||
14731 | after(grammarAccess.getALSComparisonAccess().getALSSubsetLeftOperandAction_1_0_2_0()); | ||
14732 | } | ||
14733 | |||
14734 | } | ||
14735 | |||
14736 | |||
14737 | } | ||
14738 | |||
14739 | } | ||
14740 | finally { | ||
14741 | |||
14742 | restoreStackSize(stackSize); | ||
14743 | |||
14744 | } | ||
14745 | return ; | ||
14746 | } | ||
14747 | // $ANTLR end "rule__ALSComparison__Group_1_0_2__0__Impl" | ||
14748 | |||
14749 | |||
14750 | // $ANTLR start "rule__ALSComparison__Group_1_0_2__1" | ||
14751 | // InternalAlloyLanguage.g:5001:1: rule__ALSComparison__Group_1_0_2__1 : rule__ALSComparison__Group_1_0_2__1__Impl ; | ||
14752 | public final void rule__ALSComparison__Group_1_0_2__1() throws RecognitionException { | ||
14753 | |||
14754 | int stackSize = keepStackSize(); | ||
14755 | |||
14756 | try { | ||
14757 | // InternalAlloyLanguage.g:5005:1: ( rule__ALSComparison__Group_1_0_2__1__Impl ) | ||
14758 | // InternalAlloyLanguage.g:5006:2: rule__ALSComparison__Group_1_0_2__1__Impl | ||
14759 | { | ||
14760 | pushFollow(FOLLOW_2); | ||
14761 | rule__ALSComparison__Group_1_0_2__1__Impl(); | ||
14762 | |||
14763 | state._fsp--; | ||
14764 | if (state.failed) return ; | ||
14765 | |||
14766 | } | ||
14767 | |||
14768 | } | ||
14769 | catch (RecognitionException re) { | ||
14770 | reportError(re); | ||
14771 | recover(input,re); | ||
14772 | } | ||
14773 | finally { | ||
14774 | |||
14775 | restoreStackSize(stackSize); | ||
14776 | |||
14777 | } | ||
14778 | return ; | ||
14779 | } | ||
14780 | // $ANTLR end "rule__ALSComparison__Group_1_0_2__1" | ||
14781 | |||
14782 | |||
14783 | // $ANTLR start "rule__ALSComparison__Group_1_0_2__1__Impl" | ||
14784 | // InternalAlloyLanguage.g:5012:1: rule__ALSComparison__Group_1_0_2__1__Impl : ( 'in' ) ; | ||
14785 | public final void rule__ALSComparison__Group_1_0_2__1__Impl() throws RecognitionException { | ||
14786 | |||
14787 | int stackSize = keepStackSize(); | ||
14788 | |||
14789 | try { | ||
14790 | // InternalAlloyLanguage.g:5016:1: ( ( 'in' ) ) | ||
14791 | // InternalAlloyLanguage.g:5017:1: ( 'in' ) | ||
14792 | { | ||
14793 | // InternalAlloyLanguage.g:5017:1: ( 'in' ) | ||
14794 | // InternalAlloyLanguage.g:5018:1: 'in' | ||
14795 | { | ||
14796 | if ( state.backtracking==0 ) { | ||
14797 | before(grammarAccess.getALSComparisonAccess().getInKeyword_1_0_2_1()); | ||
14798 | } | ||
14799 | match(input,38,FOLLOW_2); if (state.failed) return ; | ||
14800 | if ( state.backtracking==0 ) { | ||
14801 | after(grammarAccess.getALSComparisonAccess().getInKeyword_1_0_2_1()); | ||
14802 | } | ||
14803 | |||
14804 | } | ||
14805 | |||
14806 | |||
14807 | } | ||
14808 | |||
14809 | } | ||
14810 | catch (RecognitionException re) { | ||
14811 | reportError(re); | ||
14812 | recover(input,re); | ||
14813 | } | ||
14814 | finally { | ||
14815 | |||
14816 | restoreStackSize(stackSize); | ||
14817 | |||
14818 | } | ||
14819 | return ; | ||
14820 | } | ||
14821 | // $ANTLR end "rule__ALSComparison__Group_1_0_2__1__Impl" | ||
14822 | |||
14823 | |||
14824 | // $ANTLR start "rule__ALSComparison__Group_1_0_3__0" | ||
14825 | // InternalAlloyLanguage.g:5035:1: rule__ALSComparison__Group_1_0_3__0 : rule__ALSComparison__Group_1_0_3__0__Impl rule__ALSComparison__Group_1_0_3__1 ; | ||
14826 | public final void rule__ALSComparison__Group_1_0_3__0() throws RecognitionException { | ||
14827 | |||
14828 | int stackSize = keepStackSize(); | ||
14829 | |||
14830 | try { | ||
14831 | // InternalAlloyLanguage.g:5039:1: ( rule__ALSComparison__Group_1_0_3__0__Impl rule__ALSComparison__Group_1_0_3__1 ) | ||
14832 | // InternalAlloyLanguage.g:5040:2: rule__ALSComparison__Group_1_0_3__0__Impl rule__ALSComparison__Group_1_0_3__1 | ||
14833 | { | ||
14834 | pushFollow(FOLLOW_34); | ||
14835 | rule__ALSComparison__Group_1_0_3__0__Impl(); | ||
14836 | |||
14837 | state._fsp--; | ||
14838 | if (state.failed) return ; | ||
14839 | pushFollow(FOLLOW_2); | ||
14840 | rule__ALSComparison__Group_1_0_3__1(); | ||
14841 | |||
14842 | state._fsp--; | ||
14843 | if (state.failed) return ; | ||
14844 | |||
14845 | } | ||
14846 | |||
14847 | } | ||
14848 | catch (RecognitionException re) { | ||
14849 | reportError(re); | ||
14850 | recover(input,re); | ||
14851 | } | ||
14852 | finally { | ||
14853 | |||
14854 | restoreStackSize(stackSize); | ||
14855 | |||
14856 | } | ||
14857 | return ; | ||
14858 | } | ||
14859 | // $ANTLR end "rule__ALSComparison__Group_1_0_3__0" | ||
14860 | |||
14861 | |||
14862 | // $ANTLR start "rule__ALSComparison__Group_1_0_3__0__Impl" | ||
14863 | // InternalAlloyLanguage.g:5047:1: rule__ALSComparison__Group_1_0_3__0__Impl : ( () ) ; | ||
14864 | public final void rule__ALSComparison__Group_1_0_3__0__Impl() throws RecognitionException { | ||
14865 | |||
14866 | int stackSize = keepStackSize(); | ||
14867 | |||
14868 | try { | ||
14869 | // InternalAlloyLanguage.g:5051:1: ( ( () ) ) | ||
14870 | // InternalAlloyLanguage.g:5052:1: ( () ) | ||
14871 | { | ||
14872 | // InternalAlloyLanguage.g:5052:1: ( () ) | ||
14873 | // InternalAlloyLanguage.g:5053:1: () | ||
14874 | { | ||
14875 | if ( state.backtracking==0 ) { | ||
14876 | before(grammarAccess.getALSComparisonAccess().getALSLessLeftOperandAction_1_0_3_0()); | ||
14877 | } | ||
14878 | // InternalAlloyLanguage.g:5054:1: () | ||
14879 | // InternalAlloyLanguage.g:5056:1: | ||
14880 | { | ||
14881 | } | ||
14882 | |||
14883 | if ( state.backtracking==0 ) { | ||
14884 | after(grammarAccess.getALSComparisonAccess().getALSLessLeftOperandAction_1_0_3_0()); | ||
14885 | } | ||
14886 | |||
14887 | } | ||
14888 | |||
14889 | |||
14890 | } | ||
14891 | |||
14892 | } | ||
14893 | finally { | ||
14894 | |||
14895 | restoreStackSize(stackSize); | ||
14896 | |||
14897 | } | ||
14898 | return ; | ||
14899 | } | ||
14900 | // $ANTLR end "rule__ALSComparison__Group_1_0_3__0__Impl" | ||
14901 | |||
14902 | |||
14903 | // $ANTLR start "rule__ALSComparison__Group_1_0_3__1" | ||
14904 | // InternalAlloyLanguage.g:5066:1: rule__ALSComparison__Group_1_0_3__1 : rule__ALSComparison__Group_1_0_3__1__Impl ; | ||
14905 | public final void rule__ALSComparison__Group_1_0_3__1() throws RecognitionException { | ||
14906 | |||
14907 | int stackSize = keepStackSize(); | ||
14908 | |||
14909 | try { | ||
14910 | // InternalAlloyLanguage.g:5070:1: ( rule__ALSComparison__Group_1_0_3__1__Impl ) | ||
14911 | // InternalAlloyLanguage.g:5071:2: rule__ALSComparison__Group_1_0_3__1__Impl | ||
14912 | { | ||
14913 | pushFollow(FOLLOW_2); | ||
14914 | rule__ALSComparison__Group_1_0_3__1__Impl(); | ||
14915 | |||
14916 | state._fsp--; | ||
14917 | if (state.failed) return ; | ||
14918 | |||
14919 | } | ||
14920 | |||
14921 | } | ||
14922 | catch (RecognitionException re) { | ||
14923 | reportError(re); | ||
14924 | recover(input,re); | ||
14925 | } | ||
14926 | finally { | ||
14927 | |||
14928 | restoreStackSize(stackSize); | ||
14929 | |||
14930 | } | ||
14931 | return ; | ||
14932 | } | ||
14933 | // $ANTLR end "rule__ALSComparison__Group_1_0_3__1" | ||
14934 | |||
14935 | |||
14936 | // $ANTLR start "rule__ALSComparison__Group_1_0_3__1__Impl" | ||
14937 | // InternalAlloyLanguage.g:5077:1: rule__ALSComparison__Group_1_0_3__1__Impl : ( '>' ) ; | ||
14938 | public final void rule__ALSComparison__Group_1_0_3__1__Impl() throws RecognitionException { | ||
14939 | |||
14940 | int stackSize = keepStackSize(); | ||
14941 | |||
14942 | try { | ||
14943 | // InternalAlloyLanguage.g:5081:1: ( ( '>' ) ) | ||
14944 | // InternalAlloyLanguage.g:5082:1: ( '>' ) | ||
14945 | { | ||
14946 | // InternalAlloyLanguage.g:5082:1: ( '>' ) | ||
14947 | // InternalAlloyLanguage.g:5083:1: '>' | ||
14948 | { | ||
14949 | if ( state.backtracking==0 ) { | ||
14950 | before(grammarAccess.getALSComparisonAccess().getGreaterThanSignKeyword_1_0_3_1()); | ||
14951 | } | ||
14952 | match(input,49,FOLLOW_2); if (state.failed) return ; | ||
14953 | if ( state.backtracking==0 ) { | ||
14954 | after(grammarAccess.getALSComparisonAccess().getGreaterThanSignKeyword_1_0_3_1()); | ||
14955 | } | ||
14956 | |||
14957 | } | ||
14958 | |||
14959 | |||
14960 | } | ||
14961 | |||
14962 | } | ||
14963 | catch (RecognitionException re) { | ||
14964 | reportError(re); | ||
14965 | recover(input,re); | ||
14966 | } | ||
14967 | finally { | ||
14968 | |||
14969 | restoreStackSize(stackSize); | ||
14970 | |||
14971 | } | ||
14972 | return ; | ||
14973 | } | ||
14974 | // $ANTLR end "rule__ALSComparison__Group_1_0_3__1__Impl" | ||
14975 | |||
14976 | |||
14977 | // $ANTLR start "rule__ALSComparison__Group_1_0_4__0" | ||
14978 | // InternalAlloyLanguage.g:5100:1: rule__ALSComparison__Group_1_0_4__0 : rule__ALSComparison__Group_1_0_4__0__Impl rule__ALSComparison__Group_1_0_4__1 ; | ||
14979 | public final void rule__ALSComparison__Group_1_0_4__0() throws RecognitionException { | ||
14980 | |||
14981 | int stackSize = keepStackSize(); | ||
14982 | |||
14983 | try { | ||
14984 | // InternalAlloyLanguage.g:5104:1: ( rule__ALSComparison__Group_1_0_4__0__Impl rule__ALSComparison__Group_1_0_4__1 ) | ||
14985 | // InternalAlloyLanguage.g:5105:2: rule__ALSComparison__Group_1_0_4__0__Impl rule__ALSComparison__Group_1_0_4__1 | ||
14986 | { | ||
14987 | pushFollow(FOLLOW_35); | ||
14988 | rule__ALSComparison__Group_1_0_4__0__Impl(); | ||
14989 | |||
14990 | state._fsp--; | ||
14991 | if (state.failed) return ; | ||
14992 | pushFollow(FOLLOW_2); | ||
14993 | rule__ALSComparison__Group_1_0_4__1(); | ||
14994 | |||
14995 | state._fsp--; | ||
14996 | if (state.failed) return ; | ||
14997 | |||
14998 | } | ||
14999 | |||
15000 | } | ||
15001 | catch (RecognitionException re) { | ||
15002 | reportError(re); | ||
15003 | recover(input,re); | ||
15004 | } | ||
15005 | finally { | ||
15006 | |||
15007 | restoreStackSize(stackSize); | ||
15008 | |||
15009 | } | ||
15010 | return ; | ||
15011 | } | ||
15012 | // $ANTLR end "rule__ALSComparison__Group_1_0_4__0" | ||
15013 | |||
15014 | |||
15015 | // $ANTLR start "rule__ALSComparison__Group_1_0_4__0__Impl" | ||
15016 | // InternalAlloyLanguage.g:5112:1: rule__ALSComparison__Group_1_0_4__0__Impl : ( () ) ; | ||
15017 | public final void rule__ALSComparison__Group_1_0_4__0__Impl() throws RecognitionException { | ||
15018 | |||
15019 | int stackSize = keepStackSize(); | ||
15020 | |||
15021 | try { | ||
15022 | // InternalAlloyLanguage.g:5116:1: ( ( () ) ) | ||
15023 | // InternalAlloyLanguage.g:5117:1: ( () ) | ||
15024 | { | ||
15025 | // InternalAlloyLanguage.g:5117:1: ( () ) | ||
15026 | // InternalAlloyLanguage.g:5118:1: () | ||
15027 | { | ||
15028 | if ( state.backtracking==0 ) { | ||
15029 | before(grammarAccess.getALSComparisonAccess().getALSLeqLeftOperandAction_1_0_4_0()); | ||
15030 | } | ||
15031 | // InternalAlloyLanguage.g:5119:1: () | ||
15032 | // InternalAlloyLanguage.g:5121:1: | ||
15033 | { | ||
15034 | } | ||
15035 | |||
15036 | if ( state.backtracking==0 ) { | ||
15037 | after(grammarAccess.getALSComparisonAccess().getALSLeqLeftOperandAction_1_0_4_0()); | ||
15038 | } | ||
15039 | |||
15040 | } | ||
15041 | |||
15042 | |||
15043 | } | ||
15044 | |||
15045 | } | ||
15046 | finally { | ||
15047 | |||
15048 | restoreStackSize(stackSize); | ||
15049 | |||
15050 | } | ||
15051 | return ; | ||
15052 | } | ||
15053 | // $ANTLR end "rule__ALSComparison__Group_1_0_4__0__Impl" | ||
15054 | |||
15055 | |||
15056 | // $ANTLR start "rule__ALSComparison__Group_1_0_4__1" | ||
15057 | // InternalAlloyLanguage.g:5131:1: rule__ALSComparison__Group_1_0_4__1 : rule__ALSComparison__Group_1_0_4__1__Impl ; | ||
15058 | public final void rule__ALSComparison__Group_1_0_4__1() throws RecognitionException { | ||
15059 | |||
15060 | int stackSize = keepStackSize(); | ||
15061 | |||
15062 | try { | ||
15063 | // InternalAlloyLanguage.g:5135:1: ( rule__ALSComparison__Group_1_0_4__1__Impl ) | ||
15064 | // InternalAlloyLanguage.g:5136:2: rule__ALSComparison__Group_1_0_4__1__Impl | ||
15065 | { | ||
15066 | pushFollow(FOLLOW_2); | ||
15067 | rule__ALSComparison__Group_1_0_4__1__Impl(); | ||
15068 | |||
15069 | state._fsp--; | ||
15070 | if (state.failed) return ; | ||
15071 | |||
15072 | } | ||
15073 | |||
15074 | } | ||
15075 | catch (RecognitionException re) { | ||
15076 | reportError(re); | ||
15077 | recover(input,re); | ||
15078 | } | ||
15079 | finally { | ||
15080 | |||
15081 | restoreStackSize(stackSize); | ||
15082 | |||
15083 | } | ||
15084 | return ; | ||
15085 | } | ||
15086 | // $ANTLR end "rule__ALSComparison__Group_1_0_4__1" | ||
15087 | |||
15088 | |||
15089 | // $ANTLR start "rule__ALSComparison__Group_1_0_4__1__Impl" | ||
15090 | // InternalAlloyLanguage.g:5142:1: rule__ALSComparison__Group_1_0_4__1__Impl : ( '>=' ) ; | ||
15091 | public final void rule__ALSComparison__Group_1_0_4__1__Impl() throws RecognitionException { | ||
15092 | |||
15093 | int stackSize = keepStackSize(); | ||
15094 | |||
15095 | try { | ||
15096 | // InternalAlloyLanguage.g:5146:1: ( ( '>=' ) ) | ||
15097 | // InternalAlloyLanguage.g:5147:1: ( '>=' ) | ||
15098 | { | ||
15099 | // InternalAlloyLanguage.g:5147:1: ( '>=' ) | ||
15100 | // InternalAlloyLanguage.g:5148:1: '>=' | ||
15101 | { | ||
15102 | if ( state.backtracking==0 ) { | ||
15103 | before(grammarAccess.getALSComparisonAccess().getGreaterThanSignEqualsSignKeyword_1_0_4_1()); | ||
15104 | } | ||
15105 | match(input,50,FOLLOW_2); if (state.failed) return ; | ||
15106 | if ( state.backtracking==0 ) { | ||
15107 | after(grammarAccess.getALSComparisonAccess().getGreaterThanSignEqualsSignKeyword_1_0_4_1()); | ||
15108 | } | ||
15109 | |||
15110 | } | ||
15111 | |||
15112 | |||
15113 | } | ||
15114 | |||
15115 | } | ||
15116 | catch (RecognitionException re) { | ||
15117 | reportError(re); | ||
15118 | recover(input,re); | ||
15119 | } | ||
15120 | finally { | ||
15121 | |||
15122 | restoreStackSize(stackSize); | ||
15123 | |||
15124 | } | ||
15125 | return ; | ||
15126 | } | ||
15127 | // $ANTLR end "rule__ALSComparison__Group_1_0_4__1__Impl" | ||
15128 | |||
15129 | |||
15130 | // $ANTLR start "rule__ALSComparison__Group_1_0_5__0" | ||
15131 | // InternalAlloyLanguage.g:5165:1: rule__ALSComparison__Group_1_0_5__0 : rule__ALSComparison__Group_1_0_5__0__Impl rule__ALSComparison__Group_1_0_5__1 ; | ||
15132 | public final void rule__ALSComparison__Group_1_0_5__0() throws RecognitionException { | ||
15133 | |||
15134 | int stackSize = keepStackSize(); | ||
15135 | |||
15136 | try { | ||
15137 | // InternalAlloyLanguage.g:5169:1: ( rule__ALSComparison__Group_1_0_5__0__Impl rule__ALSComparison__Group_1_0_5__1 ) | ||
15138 | // InternalAlloyLanguage.g:5170:2: rule__ALSComparison__Group_1_0_5__0__Impl rule__ALSComparison__Group_1_0_5__1 | ||
15139 | { | ||
15140 | pushFollow(FOLLOW_36); | ||
15141 | rule__ALSComparison__Group_1_0_5__0__Impl(); | ||
15142 | |||
15143 | state._fsp--; | ||
15144 | if (state.failed) return ; | ||
15145 | pushFollow(FOLLOW_2); | ||
15146 | rule__ALSComparison__Group_1_0_5__1(); | ||
15147 | |||
15148 | state._fsp--; | ||
15149 | if (state.failed) return ; | ||
15150 | |||
15151 | } | ||
15152 | |||
15153 | } | ||
15154 | catch (RecognitionException re) { | ||
15155 | reportError(re); | ||
15156 | recover(input,re); | ||
15157 | } | ||
15158 | finally { | ||
15159 | |||
15160 | restoreStackSize(stackSize); | ||
15161 | |||
15162 | } | ||
15163 | return ; | ||
15164 | } | ||
15165 | // $ANTLR end "rule__ALSComparison__Group_1_0_5__0" | ||
15166 | |||
15167 | |||
15168 | // $ANTLR start "rule__ALSComparison__Group_1_0_5__0__Impl" | ||
15169 | // InternalAlloyLanguage.g:5177:1: rule__ALSComparison__Group_1_0_5__0__Impl : ( () ) ; | ||
15170 | public final void rule__ALSComparison__Group_1_0_5__0__Impl() throws RecognitionException { | ||
15171 | |||
15172 | int stackSize = keepStackSize(); | ||
15173 | |||
15174 | try { | ||
15175 | // InternalAlloyLanguage.g:5181:1: ( ( () ) ) | ||
15176 | // InternalAlloyLanguage.g:5182:1: ( () ) | ||
15177 | { | ||
15178 | // InternalAlloyLanguage.g:5182:1: ( () ) | ||
15179 | // InternalAlloyLanguage.g:5183:1: () | ||
15180 | { | ||
15181 | if ( state.backtracking==0 ) { | ||
15182 | before(grammarAccess.getALSComparisonAccess().getALSMoreLeftOperandAction_1_0_5_0()); | ||
15183 | } | ||
15184 | // InternalAlloyLanguage.g:5184:1: () | ||
15185 | // InternalAlloyLanguage.g:5186:1: | ||
15186 | { | ||
15187 | } | ||
15188 | |||
15189 | if ( state.backtracking==0 ) { | ||
15190 | after(grammarAccess.getALSComparisonAccess().getALSMoreLeftOperandAction_1_0_5_0()); | ||
15191 | } | ||
15192 | |||
15193 | } | ||
15194 | |||
15195 | |||
15196 | } | ||
15197 | |||
15198 | } | ||
15199 | finally { | ||
15200 | |||
15201 | restoreStackSize(stackSize); | ||
15202 | |||
15203 | } | ||
15204 | return ; | ||
15205 | } | ||
15206 | // $ANTLR end "rule__ALSComparison__Group_1_0_5__0__Impl" | ||
15207 | |||
15208 | |||
15209 | // $ANTLR start "rule__ALSComparison__Group_1_0_5__1" | ||
15210 | // InternalAlloyLanguage.g:5196:1: rule__ALSComparison__Group_1_0_5__1 : rule__ALSComparison__Group_1_0_5__1__Impl ; | ||
15211 | public final void rule__ALSComparison__Group_1_0_5__1() throws RecognitionException { | ||
15212 | |||
15213 | int stackSize = keepStackSize(); | ||
15214 | |||
15215 | try { | ||
15216 | // InternalAlloyLanguage.g:5200:1: ( rule__ALSComparison__Group_1_0_5__1__Impl ) | ||
15217 | // InternalAlloyLanguage.g:5201:2: rule__ALSComparison__Group_1_0_5__1__Impl | ||
15218 | { | ||
15219 | pushFollow(FOLLOW_2); | ||
15220 | rule__ALSComparison__Group_1_0_5__1__Impl(); | ||
15221 | |||
15222 | state._fsp--; | ||
15223 | if (state.failed) return ; | ||
15224 | |||
15225 | } | ||
15226 | |||
15227 | } | ||
15228 | catch (RecognitionException re) { | ||
15229 | reportError(re); | ||
15230 | recover(input,re); | ||
15231 | } | ||
15232 | finally { | ||
15233 | |||
15234 | restoreStackSize(stackSize); | ||
15235 | |||
15236 | } | ||
15237 | return ; | ||
15238 | } | ||
15239 | // $ANTLR end "rule__ALSComparison__Group_1_0_5__1" | ||
15240 | |||
15241 | |||
15242 | // $ANTLR start "rule__ALSComparison__Group_1_0_5__1__Impl" | ||
15243 | // InternalAlloyLanguage.g:5207:1: rule__ALSComparison__Group_1_0_5__1__Impl : ( '<' ) ; | ||
15244 | public final void rule__ALSComparison__Group_1_0_5__1__Impl() throws RecognitionException { | ||
15245 | |||
15246 | int stackSize = keepStackSize(); | ||
15247 | |||
15248 | try { | ||
15249 | // InternalAlloyLanguage.g:5211:1: ( ( '<' ) ) | ||
15250 | // InternalAlloyLanguage.g:5212:1: ( '<' ) | ||
15251 | { | ||
15252 | // InternalAlloyLanguage.g:5212:1: ( '<' ) | ||
15253 | // InternalAlloyLanguage.g:5213:1: '<' | ||
15254 | { | ||
15255 | if ( state.backtracking==0 ) { | ||
15256 | before(grammarAccess.getALSComparisonAccess().getLessThanSignKeyword_1_0_5_1()); | ||
15257 | } | ||
15258 | match(input,51,FOLLOW_2); if (state.failed) return ; | ||
15259 | if ( state.backtracking==0 ) { | ||
15260 | after(grammarAccess.getALSComparisonAccess().getLessThanSignKeyword_1_0_5_1()); | ||
15261 | } | ||
15262 | |||
15263 | } | ||
15264 | |||
15265 | |||
15266 | } | ||
15267 | |||
15268 | } | ||
15269 | catch (RecognitionException re) { | ||
15270 | reportError(re); | ||
15271 | recover(input,re); | ||
15272 | } | ||
15273 | finally { | ||
15274 | |||
15275 | restoreStackSize(stackSize); | ||
15276 | |||
15277 | } | ||
15278 | return ; | ||
15279 | } | ||
15280 | // $ANTLR end "rule__ALSComparison__Group_1_0_5__1__Impl" | ||
15281 | |||
15282 | |||
15283 | // $ANTLR start "rule__ALSComparison__Group_1_0_6__0" | ||
15284 | // InternalAlloyLanguage.g:5230:1: rule__ALSComparison__Group_1_0_6__0 : rule__ALSComparison__Group_1_0_6__0__Impl rule__ALSComparison__Group_1_0_6__1 ; | ||
15285 | public final void rule__ALSComparison__Group_1_0_6__0() throws RecognitionException { | ||
15286 | |||
15287 | int stackSize = keepStackSize(); | ||
15288 | |||
15289 | try { | ||
15290 | // InternalAlloyLanguage.g:5234:1: ( rule__ALSComparison__Group_1_0_6__0__Impl rule__ALSComparison__Group_1_0_6__1 ) | ||
15291 | // InternalAlloyLanguage.g:5235:2: rule__ALSComparison__Group_1_0_6__0__Impl rule__ALSComparison__Group_1_0_6__1 | ||
15292 | { | ||
15293 | pushFollow(FOLLOW_30); | ||
15294 | rule__ALSComparison__Group_1_0_6__0__Impl(); | ||
15295 | |||
15296 | state._fsp--; | ||
15297 | if (state.failed) return ; | ||
15298 | pushFollow(FOLLOW_2); | ||
15299 | rule__ALSComparison__Group_1_0_6__1(); | ||
15300 | |||
15301 | state._fsp--; | ||
15302 | if (state.failed) return ; | ||
15303 | |||
15304 | } | ||
15305 | |||
15306 | } | ||
15307 | catch (RecognitionException re) { | ||
15308 | reportError(re); | ||
15309 | recover(input,re); | ||
15310 | } | ||
15311 | finally { | ||
15312 | |||
15313 | restoreStackSize(stackSize); | ||
15314 | |||
15315 | } | ||
15316 | return ; | ||
15317 | } | ||
15318 | // $ANTLR end "rule__ALSComparison__Group_1_0_6__0" | ||
15319 | |||
15320 | |||
15321 | // $ANTLR start "rule__ALSComparison__Group_1_0_6__0__Impl" | ||
15322 | // InternalAlloyLanguage.g:5242:1: rule__ALSComparison__Group_1_0_6__0__Impl : ( () ) ; | ||
15323 | public final void rule__ALSComparison__Group_1_0_6__0__Impl() throws RecognitionException { | ||
15324 | |||
15325 | int stackSize = keepStackSize(); | ||
15326 | |||
15327 | try { | ||
15328 | // InternalAlloyLanguage.g:5246:1: ( ( () ) ) | ||
15329 | // InternalAlloyLanguage.g:5247:1: ( () ) | ||
15330 | { | ||
15331 | // InternalAlloyLanguage.g:5247:1: ( () ) | ||
15332 | // InternalAlloyLanguage.g:5248:1: () | ||
15333 | { | ||
15334 | if ( state.backtracking==0 ) { | ||
15335 | before(grammarAccess.getALSComparisonAccess().getALSMeqLeftOperandAction_1_0_6_0()); | ||
15336 | } | ||
15337 | // InternalAlloyLanguage.g:5249:1: () | ||
15338 | // InternalAlloyLanguage.g:5251:1: | ||
15339 | { | ||
15340 | } | ||
15341 | |||
15342 | if ( state.backtracking==0 ) { | ||
15343 | after(grammarAccess.getALSComparisonAccess().getALSMeqLeftOperandAction_1_0_6_0()); | ||
15344 | } | ||
15345 | |||
15346 | } | ||
15347 | |||
15348 | |||
15349 | } | ||
15350 | |||
15351 | } | ||
15352 | finally { | ||
15353 | |||
15354 | restoreStackSize(stackSize); | ||
15355 | |||
15356 | } | ||
15357 | return ; | ||
15358 | } | ||
15359 | // $ANTLR end "rule__ALSComparison__Group_1_0_6__0__Impl" | ||
15360 | |||
15361 | |||
15362 | // $ANTLR start "rule__ALSComparison__Group_1_0_6__1" | ||
15363 | // InternalAlloyLanguage.g:5261:1: rule__ALSComparison__Group_1_0_6__1 : rule__ALSComparison__Group_1_0_6__1__Impl ; | ||
15364 | public final void rule__ALSComparison__Group_1_0_6__1() throws RecognitionException { | ||
15365 | |||
15366 | int stackSize = keepStackSize(); | ||
15367 | |||
15368 | try { | ||
15369 | // InternalAlloyLanguage.g:5265:1: ( rule__ALSComparison__Group_1_0_6__1__Impl ) | ||
15370 | // InternalAlloyLanguage.g:5266:2: rule__ALSComparison__Group_1_0_6__1__Impl | ||
15371 | { | ||
15372 | pushFollow(FOLLOW_2); | ||
15373 | rule__ALSComparison__Group_1_0_6__1__Impl(); | ||
15374 | |||
15375 | state._fsp--; | ||
15376 | if (state.failed) return ; | ||
15377 | |||
15378 | } | ||
15379 | |||
15380 | } | ||
15381 | catch (RecognitionException re) { | ||
15382 | reportError(re); | ||
15383 | recover(input,re); | ||
15384 | } | ||
15385 | finally { | ||
15386 | |||
15387 | restoreStackSize(stackSize); | ||
15388 | |||
15389 | } | ||
15390 | return ; | ||
15391 | } | ||
15392 | // $ANTLR end "rule__ALSComparison__Group_1_0_6__1" | ||
15393 | |||
15394 | |||
15395 | // $ANTLR start "rule__ALSComparison__Group_1_0_6__1__Impl" | ||
15396 | // InternalAlloyLanguage.g:5272:1: rule__ALSComparison__Group_1_0_6__1__Impl : ( '<=' ) ; | ||
15397 | public final void rule__ALSComparison__Group_1_0_6__1__Impl() throws RecognitionException { | ||
15398 | |||
15399 | int stackSize = keepStackSize(); | ||
15400 | |||
15401 | try { | ||
15402 | // InternalAlloyLanguage.g:5276:1: ( ( '<=' ) ) | ||
15403 | // InternalAlloyLanguage.g:5277:1: ( '<=' ) | ||
15404 | { | ||
15405 | // InternalAlloyLanguage.g:5277:1: ( '<=' ) | ||
15406 | // InternalAlloyLanguage.g:5278:1: '<=' | ||
15407 | { | ||
15408 | if ( state.backtracking==0 ) { | ||
15409 | before(grammarAccess.getALSComparisonAccess().getLessThanSignEqualsSignKeyword_1_0_6_1()); | ||
15410 | } | ||
15411 | match(input,52,FOLLOW_2); if (state.failed) return ; | ||
15412 | if ( state.backtracking==0 ) { | ||
15413 | after(grammarAccess.getALSComparisonAccess().getLessThanSignEqualsSignKeyword_1_0_6_1()); | ||
15414 | } | ||
15415 | |||
15416 | } | ||
15417 | |||
15418 | |||
15419 | } | ||
15420 | |||
15421 | } | ||
15422 | catch (RecognitionException re) { | ||
15423 | reportError(re); | ||
15424 | recover(input,re); | ||
15425 | } | ||
15426 | finally { | ||
15427 | |||
15428 | restoreStackSize(stackSize); | ||
15429 | |||
15430 | } | ||
15431 | return ; | ||
15432 | } | ||
15433 | // $ANTLR end "rule__ALSComparison__Group_1_0_6__1__Impl" | ||
15434 | |||
15435 | |||
15436 | // $ANTLR start "rule__ALSOverride__Group__0" | ||
15437 | // InternalAlloyLanguage.g:5295:1: rule__ALSOverride__Group__0 : rule__ALSOverride__Group__0__Impl rule__ALSOverride__Group__1 ; | ||
15438 | public final void rule__ALSOverride__Group__0() throws RecognitionException { | ||
15439 | |||
15440 | int stackSize = keepStackSize(); | ||
15441 | |||
15442 | try { | ||
15443 | // InternalAlloyLanguage.g:5299:1: ( rule__ALSOverride__Group__0__Impl rule__ALSOverride__Group__1 ) | ||
15444 | // InternalAlloyLanguage.g:5300:2: rule__ALSOverride__Group__0__Impl rule__ALSOverride__Group__1 | ||
15445 | { | ||
15446 | pushFollow(FOLLOW_37); | ||
15447 | rule__ALSOverride__Group__0__Impl(); | ||
15448 | |||
15449 | state._fsp--; | ||
15450 | if (state.failed) return ; | ||
15451 | pushFollow(FOLLOW_2); | ||
15452 | rule__ALSOverride__Group__1(); | ||
15453 | |||
15454 | state._fsp--; | ||
15455 | if (state.failed) return ; | ||
15456 | |||
15457 | } | ||
15458 | |||
15459 | } | ||
15460 | catch (RecognitionException re) { | ||
15461 | reportError(re); | ||
15462 | recover(input,re); | ||
15463 | } | ||
15464 | finally { | ||
15465 | |||
15466 | restoreStackSize(stackSize); | ||
15467 | |||
15468 | } | ||
15469 | return ; | ||
15470 | } | ||
15471 | // $ANTLR end "rule__ALSOverride__Group__0" | ||
15472 | |||
15473 | |||
15474 | // $ANTLR start "rule__ALSOverride__Group__0__Impl" | ||
15475 | // InternalAlloyLanguage.g:5307:1: rule__ALSOverride__Group__0__Impl : ( ruleALSRangeRestrictionRight ) ; | ||
15476 | public final void rule__ALSOverride__Group__0__Impl() throws RecognitionException { | ||
15477 | |||
15478 | int stackSize = keepStackSize(); | ||
15479 | |||
15480 | try { | ||
15481 | // InternalAlloyLanguage.g:5311:1: ( ( ruleALSRangeRestrictionRight ) ) | ||
15482 | // InternalAlloyLanguage.g:5312:1: ( ruleALSRangeRestrictionRight ) | ||
15483 | { | ||
15484 | // InternalAlloyLanguage.g:5312:1: ( ruleALSRangeRestrictionRight ) | ||
15485 | // InternalAlloyLanguage.g:5313:1: ruleALSRangeRestrictionRight | ||
15486 | { | ||
15487 | if ( state.backtracking==0 ) { | ||
15488 | before(grammarAccess.getALSOverrideAccess().getALSRangeRestrictionRightParserRuleCall_0()); | ||
15489 | } | ||
15490 | pushFollow(FOLLOW_2); | ||
15491 | ruleALSRangeRestrictionRight(); | ||
15492 | |||
15493 | state._fsp--; | ||
15494 | if (state.failed) return ; | ||
15495 | if ( state.backtracking==0 ) { | ||
15496 | after(grammarAccess.getALSOverrideAccess().getALSRangeRestrictionRightParserRuleCall_0()); | ||
15497 | } | ||
15498 | |||
15499 | } | ||
15500 | |||
15501 | |||
15502 | } | ||
15503 | |||
15504 | } | ||
15505 | catch (RecognitionException re) { | ||
15506 | reportError(re); | ||
15507 | recover(input,re); | ||
15508 | } | ||
15509 | finally { | ||
15510 | |||
15511 | restoreStackSize(stackSize); | ||
15512 | |||
15513 | } | ||
15514 | return ; | ||
15515 | } | ||
15516 | // $ANTLR end "rule__ALSOverride__Group__0__Impl" | ||
15517 | |||
15518 | |||
15519 | // $ANTLR start "rule__ALSOverride__Group__1" | ||
15520 | // InternalAlloyLanguage.g:5324:1: rule__ALSOverride__Group__1 : rule__ALSOverride__Group__1__Impl ; | ||
15521 | public final void rule__ALSOverride__Group__1() throws RecognitionException { | ||
15522 | |||
15523 | int stackSize = keepStackSize(); | ||
15524 | |||
15525 | try { | ||
15526 | // InternalAlloyLanguage.g:5328:1: ( rule__ALSOverride__Group__1__Impl ) | ||
15527 | // InternalAlloyLanguage.g:5329:2: rule__ALSOverride__Group__1__Impl | ||
15528 | { | ||
15529 | pushFollow(FOLLOW_2); | ||
15530 | rule__ALSOverride__Group__1__Impl(); | ||
15531 | |||
15532 | state._fsp--; | ||
15533 | if (state.failed) return ; | ||
15534 | |||
15535 | } | ||
15536 | |||
15537 | } | ||
15538 | catch (RecognitionException re) { | ||
15539 | reportError(re); | ||
15540 | recover(input,re); | ||
15541 | } | ||
15542 | finally { | ||
15543 | |||
15544 | restoreStackSize(stackSize); | ||
15545 | |||
15546 | } | ||
15547 | return ; | ||
15548 | } | ||
15549 | // $ANTLR end "rule__ALSOverride__Group__1" | ||
15550 | |||
15551 | |||
15552 | // $ANTLR start "rule__ALSOverride__Group__1__Impl" | ||
15553 | // InternalAlloyLanguage.g:5335:1: rule__ALSOverride__Group__1__Impl : ( ( rule__ALSOverride__Group_1__0 )? ) ; | ||
15554 | public final void rule__ALSOverride__Group__1__Impl() throws RecognitionException { | ||
15555 | |||
15556 | int stackSize = keepStackSize(); | ||
15557 | |||
15558 | try { | ||
15559 | // InternalAlloyLanguage.g:5339:1: ( ( ( rule__ALSOverride__Group_1__0 )? ) ) | ||
15560 | // InternalAlloyLanguage.g:5340:1: ( ( rule__ALSOverride__Group_1__0 )? ) | ||
15561 | { | ||
15562 | // InternalAlloyLanguage.g:5340:1: ( ( rule__ALSOverride__Group_1__0 )? ) | ||
15563 | // InternalAlloyLanguage.g:5341:1: ( rule__ALSOverride__Group_1__0 )? | ||
15564 | { | ||
15565 | if ( state.backtracking==0 ) { | ||
15566 | before(grammarAccess.getALSOverrideAccess().getGroup_1()); | ||
15567 | } | ||
15568 | // InternalAlloyLanguage.g:5342:1: ( rule__ALSOverride__Group_1__0 )? | ||
15569 | int alt36=2; | ||
15570 | int LA36_0 = input.LA(1); | ||
15571 | |||
15572 | if ( (LA36_0==53) ) { | ||
15573 | alt36=1; | ||
15574 | } | ||
15575 | switch (alt36) { | ||
15576 | case 1 : | ||
15577 | // InternalAlloyLanguage.g:5342:2: rule__ALSOverride__Group_1__0 | ||
15578 | { | ||
15579 | pushFollow(FOLLOW_2); | ||
15580 | rule__ALSOverride__Group_1__0(); | ||
15581 | |||
15582 | state._fsp--; | ||
15583 | if (state.failed) return ; | ||
15584 | |||
15585 | } | ||
15586 | break; | ||
15587 | |||
15588 | } | ||
15589 | |||
15590 | if ( state.backtracking==0 ) { | ||
15591 | after(grammarAccess.getALSOverrideAccess().getGroup_1()); | ||
15592 | } | ||
15593 | |||
15594 | } | ||
15595 | |||
15596 | |||
15597 | } | ||
15598 | |||
15599 | } | ||
15600 | catch (RecognitionException re) { | ||
15601 | reportError(re); | ||
15602 | recover(input,re); | ||
15603 | } | ||
15604 | finally { | ||
15605 | |||
15606 | restoreStackSize(stackSize); | ||
15607 | |||
15608 | } | ||
15609 | return ; | ||
15610 | } | ||
15611 | // $ANTLR end "rule__ALSOverride__Group__1__Impl" | ||
15612 | |||
15613 | |||
15614 | // $ANTLR start "rule__ALSOverride__Group_1__0" | ||
15615 | // InternalAlloyLanguage.g:5356:1: rule__ALSOverride__Group_1__0 : rule__ALSOverride__Group_1__0__Impl rule__ALSOverride__Group_1__1 ; | ||
15616 | public final void rule__ALSOverride__Group_1__0() throws RecognitionException { | ||
15617 | |||
15618 | int stackSize = keepStackSize(); | ||
15619 | |||
15620 | try { | ||
15621 | // InternalAlloyLanguage.g:5360:1: ( rule__ALSOverride__Group_1__0__Impl rule__ALSOverride__Group_1__1 ) | ||
15622 | // InternalAlloyLanguage.g:5361:2: rule__ALSOverride__Group_1__0__Impl rule__ALSOverride__Group_1__1 | ||
15623 | { | ||
15624 | pushFollow(FOLLOW_37); | ||
15625 | rule__ALSOverride__Group_1__0__Impl(); | ||
15626 | |||
15627 | state._fsp--; | ||
15628 | if (state.failed) return ; | ||
15629 | pushFollow(FOLLOW_2); | ||
15630 | rule__ALSOverride__Group_1__1(); | ||
15631 | |||
15632 | state._fsp--; | ||
15633 | if (state.failed) return ; | ||
15634 | |||
15635 | } | ||
15636 | |||
15637 | } | ||
15638 | catch (RecognitionException re) { | ||
15639 | reportError(re); | ||
15640 | recover(input,re); | ||
15641 | } | ||
15642 | finally { | ||
15643 | |||
15644 | restoreStackSize(stackSize); | ||
15645 | |||
15646 | } | ||
15647 | return ; | ||
15648 | } | ||
15649 | // $ANTLR end "rule__ALSOverride__Group_1__0" | ||
15650 | |||
15651 | |||
15652 | // $ANTLR start "rule__ALSOverride__Group_1__0__Impl" | ||
15653 | // InternalAlloyLanguage.g:5368:1: rule__ALSOverride__Group_1__0__Impl : ( () ) ; | ||
15654 | public final void rule__ALSOverride__Group_1__0__Impl() throws RecognitionException { | ||
15655 | |||
15656 | int stackSize = keepStackSize(); | ||
15657 | |||
15658 | try { | ||
15659 | // InternalAlloyLanguage.g:5372:1: ( ( () ) ) | ||
15660 | // InternalAlloyLanguage.g:5373:1: ( () ) | ||
15661 | { | ||
15662 | // InternalAlloyLanguage.g:5373:1: ( () ) | ||
15663 | // InternalAlloyLanguage.g:5374:1: () | ||
15664 | { | ||
15665 | if ( state.backtracking==0 ) { | ||
15666 | before(grammarAccess.getALSOverrideAccess().getALSOverrideLeftOperandAction_1_0()); | ||
15667 | } | ||
15668 | // InternalAlloyLanguage.g:5375:1: () | ||
15669 | // InternalAlloyLanguage.g:5377:1: | ||
15670 | { | ||
15671 | } | ||
15672 | |||
15673 | if ( state.backtracking==0 ) { | ||
15674 | after(grammarAccess.getALSOverrideAccess().getALSOverrideLeftOperandAction_1_0()); | ||
15675 | } | ||
15676 | |||
15677 | } | ||
15678 | |||
15679 | |||
15680 | } | ||
15681 | |||
15682 | } | ||
15683 | finally { | ||
15684 | |||
15685 | restoreStackSize(stackSize); | ||
15686 | |||
15687 | } | ||
15688 | return ; | ||
15689 | } | ||
15690 | // $ANTLR end "rule__ALSOverride__Group_1__0__Impl" | ||
15691 | |||
15692 | |||
15693 | // $ANTLR start "rule__ALSOverride__Group_1__1" | ||
15694 | // InternalAlloyLanguage.g:5387:1: rule__ALSOverride__Group_1__1 : rule__ALSOverride__Group_1__1__Impl rule__ALSOverride__Group_1__2 ; | ||
15695 | public final void rule__ALSOverride__Group_1__1() throws RecognitionException { | ||
15696 | |||
15697 | int stackSize = keepStackSize(); | ||
15698 | |||
15699 | try { | ||
15700 | // InternalAlloyLanguage.g:5391:1: ( rule__ALSOverride__Group_1__1__Impl rule__ALSOverride__Group_1__2 ) | ||
15701 | // InternalAlloyLanguage.g:5392:2: rule__ALSOverride__Group_1__1__Impl rule__ALSOverride__Group_1__2 | ||
15702 | { | ||
15703 | pushFollow(FOLLOW_16); | ||
15704 | rule__ALSOverride__Group_1__1__Impl(); | ||
15705 | |||
15706 | state._fsp--; | ||
15707 | if (state.failed) return ; | ||
15708 | pushFollow(FOLLOW_2); | ||
15709 | rule__ALSOverride__Group_1__2(); | ||
15710 | |||
15711 | state._fsp--; | ||
15712 | if (state.failed) return ; | ||
15713 | |||
15714 | } | ||
15715 | |||
15716 | } | ||
15717 | catch (RecognitionException re) { | ||
15718 | reportError(re); | ||
15719 | recover(input,re); | ||
15720 | } | ||
15721 | finally { | ||
15722 | |||
15723 | restoreStackSize(stackSize); | ||
15724 | |||
15725 | } | ||
15726 | return ; | ||
15727 | } | ||
15728 | // $ANTLR end "rule__ALSOverride__Group_1__1" | ||
15729 | |||
15730 | |||
15731 | // $ANTLR start "rule__ALSOverride__Group_1__1__Impl" | ||
15732 | // InternalAlloyLanguage.g:5399:1: rule__ALSOverride__Group_1__1__Impl : ( '++' ) ; | ||
15733 | public final void rule__ALSOverride__Group_1__1__Impl() throws RecognitionException { | ||
15734 | |||
15735 | int stackSize = keepStackSize(); | ||
15736 | |||
15737 | try { | ||
15738 | // InternalAlloyLanguage.g:5403:1: ( ( '++' ) ) | ||
15739 | // InternalAlloyLanguage.g:5404:1: ( '++' ) | ||
15740 | { | ||
15741 | // InternalAlloyLanguage.g:5404:1: ( '++' ) | ||
15742 | // InternalAlloyLanguage.g:5405:1: '++' | ||
15743 | { | ||
15744 | if ( state.backtracking==0 ) { | ||
15745 | before(grammarAccess.getALSOverrideAccess().getPlusSignPlusSignKeyword_1_1()); | ||
15746 | } | ||
15747 | match(input,53,FOLLOW_2); if (state.failed) return ; | ||
15748 | if ( state.backtracking==0 ) { | ||
15749 | after(grammarAccess.getALSOverrideAccess().getPlusSignPlusSignKeyword_1_1()); | ||
15750 | } | ||
15751 | |||
15752 | } | ||
15753 | |||
15754 | |||
15755 | } | ||
15756 | |||
15757 | } | ||
15758 | catch (RecognitionException re) { | ||
15759 | reportError(re); | ||
15760 | recover(input,re); | ||
15761 | } | ||
15762 | finally { | ||
15763 | |||
15764 | restoreStackSize(stackSize); | ||
15765 | |||
15766 | } | ||
15767 | return ; | ||
15768 | } | ||
15769 | // $ANTLR end "rule__ALSOverride__Group_1__1__Impl" | ||
15770 | |||
15771 | |||
15772 | // $ANTLR start "rule__ALSOverride__Group_1__2" | ||
15773 | // InternalAlloyLanguage.g:5418:1: rule__ALSOverride__Group_1__2 : rule__ALSOverride__Group_1__2__Impl ; | ||
15774 | public final void rule__ALSOverride__Group_1__2() throws RecognitionException { | ||
15775 | |||
15776 | int stackSize = keepStackSize(); | ||
15777 | |||
15778 | try { | ||
15779 | // InternalAlloyLanguage.g:5422:1: ( rule__ALSOverride__Group_1__2__Impl ) | ||
15780 | // InternalAlloyLanguage.g:5423:2: rule__ALSOverride__Group_1__2__Impl | ||
15781 | { | ||
15782 | pushFollow(FOLLOW_2); | ||
15783 | rule__ALSOverride__Group_1__2__Impl(); | ||
15784 | |||
15785 | state._fsp--; | ||
15786 | if (state.failed) return ; | ||
15787 | |||
15788 | } | ||
15789 | |||
15790 | } | ||
15791 | catch (RecognitionException re) { | ||
15792 | reportError(re); | ||
15793 | recover(input,re); | ||
15794 | } | ||
15795 | finally { | ||
15796 | |||
15797 | restoreStackSize(stackSize); | ||
15798 | |||
15799 | } | ||
15800 | return ; | ||
15801 | } | ||
15802 | // $ANTLR end "rule__ALSOverride__Group_1__2" | ||
15803 | |||
15804 | |||
15805 | // $ANTLR start "rule__ALSOverride__Group_1__2__Impl" | ||
15806 | // InternalAlloyLanguage.g:5429:1: rule__ALSOverride__Group_1__2__Impl : ( ( rule__ALSOverride__RightOperandAssignment_1_2 ) ) ; | ||
15807 | public final void rule__ALSOverride__Group_1__2__Impl() throws RecognitionException { | ||
15808 | |||
15809 | int stackSize = keepStackSize(); | ||
15810 | |||
15811 | try { | ||
15812 | // InternalAlloyLanguage.g:5433:1: ( ( ( rule__ALSOverride__RightOperandAssignment_1_2 ) ) ) | ||
15813 | // InternalAlloyLanguage.g:5434:1: ( ( rule__ALSOverride__RightOperandAssignment_1_2 ) ) | ||
15814 | { | ||
15815 | // InternalAlloyLanguage.g:5434:1: ( ( rule__ALSOverride__RightOperandAssignment_1_2 ) ) | ||
15816 | // InternalAlloyLanguage.g:5435:1: ( rule__ALSOverride__RightOperandAssignment_1_2 ) | ||
15817 | { | ||
15818 | if ( state.backtracking==0 ) { | ||
15819 | before(grammarAccess.getALSOverrideAccess().getRightOperandAssignment_1_2()); | ||
15820 | } | ||
15821 | // InternalAlloyLanguage.g:5436:1: ( rule__ALSOverride__RightOperandAssignment_1_2 ) | ||
15822 | // InternalAlloyLanguage.g:5436:2: rule__ALSOverride__RightOperandAssignment_1_2 | ||
15823 | { | ||
15824 | pushFollow(FOLLOW_2); | ||
15825 | rule__ALSOverride__RightOperandAssignment_1_2(); | ||
15826 | |||
15827 | state._fsp--; | ||
15828 | if (state.failed) return ; | ||
15829 | |||
15830 | } | ||
15831 | |||
15832 | if ( state.backtracking==0 ) { | ||
15833 | after(grammarAccess.getALSOverrideAccess().getRightOperandAssignment_1_2()); | ||
15834 | } | ||
15835 | |||
15836 | } | ||
15837 | |||
15838 | |||
15839 | } | ||
15840 | |||
15841 | } | ||
15842 | catch (RecognitionException re) { | ||
15843 | reportError(re); | ||
15844 | recover(input,re); | ||
15845 | } | ||
15846 | finally { | ||
15847 | |||
15848 | restoreStackSize(stackSize); | ||
15849 | |||
15850 | } | ||
15851 | return ; | ||
15852 | } | ||
15853 | // $ANTLR end "rule__ALSOverride__Group_1__2__Impl" | ||
15854 | |||
15855 | |||
15856 | // $ANTLR start "rule__ALSRangeRestrictionRight__Group__0" | ||
15857 | // InternalAlloyLanguage.g:5452:1: rule__ALSRangeRestrictionRight__Group__0 : rule__ALSRangeRestrictionRight__Group__0__Impl rule__ALSRangeRestrictionRight__Group__1 ; | ||
15858 | public final void rule__ALSRangeRestrictionRight__Group__0() throws RecognitionException { | ||
15859 | |||
15860 | int stackSize = keepStackSize(); | ||
15861 | |||
15862 | try { | ||
15863 | // InternalAlloyLanguage.g:5456:1: ( rule__ALSRangeRestrictionRight__Group__0__Impl rule__ALSRangeRestrictionRight__Group__1 ) | ||
15864 | // InternalAlloyLanguage.g:5457:2: rule__ALSRangeRestrictionRight__Group__0__Impl rule__ALSRangeRestrictionRight__Group__1 | ||
15865 | { | ||
15866 | pushFollow(FOLLOW_38); | ||
15867 | rule__ALSRangeRestrictionRight__Group__0__Impl(); | ||
15868 | |||
15869 | state._fsp--; | ||
15870 | if (state.failed) return ; | ||
15871 | pushFollow(FOLLOW_2); | ||
15872 | rule__ALSRangeRestrictionRight__Group__1(); | ||
15873 | |||
15874 | state._fsp--; | ||
15875 | if (state.failed) return ; | ||
15876 | |||
15877 | } | ||
15878 | |||
15879 | } | ||
15880 | catch (RecognitionException re) { | ||
15881 | reportError(re); | ||
15882 | recover(input,re); | ||
15883 | } | ||
15884 | finally { | ||
15885 | |||
15886 | restoreStackSize(stackSize); | ||
15887 | |||
15888 | } | ||
15889 | return ; | ||
15890 | } | ||
15891 | // $ANTLR end "rule__ALSRangeRestrictionRight__Group__0" | ||
15892 | |||
15893 | |||
15894 | // $ANTLR start "rule__ALSRangeRestrictionRight__Group__0__Impl" | ||
15895 | // InternalAlloyLanguage.g:5464:1: rule__ALSRangeRestrictionRight__Group__0__Impl : ( ruleALSRangeRestrictionLeft ) ; | ||
15896 | public final void rule__ALSRangeRestrictionRight__Group__0__Impl() throws RecognitionException { | ||
15897 | |||
15898 | int stackSize = keepStackSize(); | ||
15899 | |||
15900 | try { | ||
15901 | // InternalAlloyLanguage.g:5468:1: ( ( ruleALSRangeRestrictionLeft ) ) | ||
15902 | // InternalAlloyLanguage.g:5469:1: ( ruleALSRangeRestrictionLeft ) | ||
15903 | { | ||
15904 | // InternalAlloyLanguage.g:5469:1: ( ruleALSRangeRestrictionLeft ) | ||
15905 | // InternalAlloyLanguage.g:5470:1: ruleALSRangeRestrictionLeft | ||
15906 | { | ||
15907 | if ( state.backtracking==0 ) { | ||
15908 | before(grammarAccess.getALSRangeRestrictionRightAccess().getALSRangeRestrictionLeftParserRuleCall_0()); | ||
15909 | } | ||
15910 | pushFollow(FOLLOW_2); | ||
15911 | ruleALSRangeRestrictionLeft(); | ||
15912 | |||
15913 | state._fsp--; | ||
15914 | if (state.failed) return ; | ||
15915 | if ( state.backtracking==0 ) { | ||
15916 | after(grammarAccess.getALSRangeRestrictionRightAccess().getALSRangeRestrictionLeftParserRuleCall_0()); | ||
15917 | } | ||
15918 | |||
15919 | } | ||
15920 | |||
15921 | |||
15922 | } | ||
15923 | |||
15924 | } | ||
15925 | catch (RecognitionException re) { | ||
15926 | reportError(re); | ||
15927 | recover(input,re); | ||
15928 | } | ||
15929 | finally { | ||
15930 | |||
15931 | restoreStackSize(stackSize); | ||
15932 | |||
15933 | } | ||
15934 | return ; | ||
15935 | } | ||
15936 | // $ANTLR end "rule__ALSRangeRestrictionRight__Group__0__Impl" | ||
15937 | |||
15938 | |||
15939 | // $ANTLR start "rule__ALSRangeRestrictionRight__Group__1" | ||
15940 | // InternalAlloyLanguage.g:5481:1: rule__ALSRangeRestrictionRight__Group__1 : rule__ALSRangeRestrictionRight__Group__1__Impl ; | ||
15941 | public final void rule__ALSRangeRestrictionRight__Group__1() throws RecognitionException { | ||
15942 | |||
15943 | int stackSize = keepStackSize(); | ||
15944 | |||
15945 | try { | ||
15946 | // InternalAlloyLanguage.g:5485:1: ( rule__ALSRangeRestrictionRight__Group__1__Impl ) | ||
15947 | // InternalAlloyLanguage.g:5486:2: rule__ALSRangeRestrictionRight__Group__1__Impl | ||
15948 | { | ||
15949 | pushFollow(FOLLOW_2); | ||
15950 | rule__ALSRangeRestrictionRight__Group__1__Impl(); | ||
15951 | |||
15952 | state._fsp--; | ||
15953 | if (state.failed) return ; | ||
15954 | |||
15955 | } | ||
15956 | |||
15957 | } | ||
15958 | catch (RecognitionException re) { | ||
15959 | reportError(re); | ||
15960 | recover(input,re); | ||
15961 | } | ||
15962 | finally { | ||
15963 | |||
15964 | restoreStackSize(stackSize); | ||
15965 | |||
15966 | } | ||
15967 | return ; | ||
15968 | } | ||
15969 | // $ANTLR end "rule__ALSRangeRestrictionRight__Group__1" | ||
15970 | |||
15971 | |||
15972 | // $ANTLR start "rule__ALSRangeRestrictionRight__Group__1__Impl" | ||
15973 | // InternalAlloyLanguage.g:5492:1: rule__ALSRangeRestrictionRight__Group__1__Impl : ( ( rule__ALSRangeRestrictionRight__Group_1__0 )? ) ; | ||
15974 | public final void rule__ALSRangeRestrictionRight__Group__1__Impl() throws RecognitionException { | ||
15975 | |||
15976 | int stackSize = keepStackSize(); | ||
15977 | |||
15978 | try { | ||
15979 | // InternalAlloyLanguage.g:5496:1: ( ( ( rule__ALSRangeRestrictionRight__Group_1__0 )? ) ) | ||
15980 | // InternalAlloyLanguage.g:5497:1: ( ( rule__ALSRangeRestrictionRight__Group_1__0 )? ) | ||
15981 | { | ||
15982 | // InternalAlloyLanguage.g:5497:1: ( ( rule__ALSRangeRestrictionRight__Group_1__0 )? ) | ||
15983 | // InternalAlloyLanguage.g:5498:1: ( rule__ALSRangeRestrictionRight__Group_1__0 )? | ||
15984 | { | ||
15985 | if ( state.backtracking==0 ) { | ||
15986 | before(grammarAccess.getALSRangeRestrictionRightAccess().getGroup_1()); | ||
15987 | } | ||
15988 | // InternalAlloyLanguage.g:5499:1: ( rule__ALSRangeRestrictionRight__Group_1__0 )? | ||
15989 | int alt37=2; | ||
15990 | int LA37_0 = input.LA(1); | ||
15991 | |||
15992 | if ( (LA37_0==54) ) { | ||
15993 | alt37=1; | ||
15994 | } | ||
15995 | switch (alt37) { | ||
15996 | case 1 : | ||
15997 | // InternalAlloyLanguage.g:5499:2: rule__ALSRangeRestrictionRight__Group_1__0 | ||
15998 | { | ||
15999 | pushFollow(FOLLOW_2); | ||
16000 | rule__ALSRangeRestrictionRight__Group_1__0(); | ||
16001 | |||
16002 | state._fsp--; | ||
16003 | if (state.failed) return ; | ||
16004 | |||
16005 | } | ||
16006 | break; | ||
16007 | |||
16008 | } | ||
16009 | |||
16010 | if ( state.backtracking==0 ) { | ||
16011 | after(grammarAccess.getALSRangeRestrictionRightAccess().getGroup_1()); | ||
16012 | } | ||
16013 | |||
16014 | } | ||
16015 | |||
16016 | |||
16017 | } | ||
16018 | |||
16019 | } | ||
16020 | catch (RecognitionException re) { | ||
16021 | reportError(re); | ||
16022 | recover(input,re); | ||
16023 | } | ||
16024 | finally { | ||
16025 | |||
16026 | restoreStackSize(stackSize); | ||
16027 | |||
16028 | } | ||
16029 | return ; | ||
16030 | } | ||
16031 | // $ANTLR end "rule__ALSRangeRestrictionRight__Group__1__Impl" | ||
16032 | |||
16033 | |||
16034 | // $ANTLR start "rule__ALSRangeRestrictionRight__Group_1__0" | ||
16035 | // InternalAlloyLanguage.g:5513:1: rule__ALSRangeRestrictionRight__Group_1__0 : rule__ALSRangeRestrictionRight__Group_1__0__Impl rule__ALSRangeRestrictionRight__Group_1__1 ; | ||
16036 | public final void rule__ALSRangeRestrictionRight__Group_1__0() throws RecognitionException { | ||
16037 | |||
16038 | int stackSize = keepStackSize(); | ||
16039 | |||
16040 | try { | ||
16041 | // InternalAlloyLanguage.g:5517:1: ( rule__ALSRangeRestrictionRight__Group_1__0__Impl rule__ALSRangeRestrictionRight__Group_1__1 ) | ||
16042 | // InternalAlloyLanguage.g:5518:2: rule__ALSRangeRestrictionRight__Group_1__0__Impl rule__ALSRangeRestrictionRight__Group_1__1 | ||
16043 | { | ||
16044 | pushFollow(FOLLOW_38); | ||
16045 | rule__ALSRangeRestrictionRight__Group_1__0__Impl(); | ||
16046 | |||
16047 | state._fsp--; | ||
16048 | if (state.failed) return ; | ||
16049 | pushFollow(FOLLOW_2); | ||
16050 | rule__ALSRangeRestrictionRight__Group_1__1(); | ||
16051 | |||
16052 | state._fsp--; | ||
16053 | if (state.failed) return ; | ||
16054 | |||
16055 | } | ||
16056 | |||
16057 | } | ||
16058 | catch (RecognitionException re) { | ||
16059 | reportError(re); | ||
16060 | recover(input,re); | ||
16061 | } | ||
16062 | finally { | ||
16063 | |||
16064 | restoreStackSize(stackSize); | ||
16065 | |||
16066 | } | ||
16067 | return ; | ||
16068 | } | ||
16069 | // $ANTLR end "rule__ALSRangeRestrictionRight__Group_1__0" | ||
16070 | |||
16071 | |||
16072 | // $ANTLR start "rule__ALSRangeRestrictionRight__Group_1__0__Impl" | ||
16073 | // InternalAlloyLanguage.g:5525:1: rule__ALSRangeRestrictionRight__Group_1__0__Impl : ( () ) ; | ||
16074 | public final void rule__ALSRangeRestrictionRight__Group_1__0__Impl() throws RecognitionException { | ||
16075 | |||
16076 | int stackSize = keepStackSize(); | ||
16077 | |||
16078 | try { | ||
16079 | // InternalAlloyLanguage.g:5529:1: ( ( () ) ) | ||
16080 | // InternalAlloyLanguage.g:5530:1: ( () ) | ||
16081 | { | ||
16082 | // InternalAlloyLanguage.g:5530:1: ( () ) | ||
16083 | // InternalAlloyLanguage.g:5531:1: () | ||
16084 | { | ||
16085 | if ( state.backtracking==0 ) { | ||
16086 | before(grammarAccess.getALSRangeRestrictionRightAccess().getALSRangeRestrictionRightRelationAction_1_0()); | ||
16087 | } | ||
16088 | // InternalAlloyLanguage.g:5532:1: () | ||
16089 | // InternalAlloyLanguage.g:5534:1: | ||
16090 | { | ||
16091 | } | ||
16092 | |||
16093 | if ( state.backtracking==0 ) { | ||
16094 | after(grammarAccess.getALSRangeRestrictionRightAccess().getALSRangeRestrictionRightRelationAction_1_0()); | ||
16095 | } | ||
16096 | |||
16097 | } | ||
16098 | |||
16099 | |||
16100 | } | ||
16101 | |||
16102 | } | ||
16103 | finally { | ||
16104 | |||
16105 | restoreStackSize(stackSize); | ||
16106 | |||
16107 | } | ||
16108 | return ; | ||
16109 | } | ||
16110 | // $ANTLR end "rule__ALSRangeRestrictionRight__Group_1__0__Impl" | ||
16111 | |||
16112 | |||
16113 | // $ANTLR start "rule__ALSRangeRestrictionRight__Group_1__1" | ||
16114 | // InternalAlloyLanguage.g:5544:1: rule__ALSRangeRestrictionRight__Group_1__1 : rule__ALSRangeRestrictionRight__Group_1__1__Impl rule__ALSRangeRestrictionRight__Group_1__2 ; | ||
16115 | public final void rule__ALSRangeRestrictionRight__Group_1__1() throws RecognitionException { | ||
16116 | |||
16117 | int stackSize = keepStackSize(); | ||
16118 | |||
16119 | try { | ||
16120 | // InternalAlloyLanguage.g:5548:1: ( rule__ALSRangeRestrictionRight__Group_1__1__Impl rule__ALSRangeRestrictionRight__Group_1__2 ) | ||
16121 | // InternalAlloyLanguage.g:5549:2: rule__ALSRangeRestrictionRight__Group_1__1__Impl rule__ALSRangeRestrictionRight__Group_1__2 | ||
16122 | { | ||
16123 | pushFollow(FOLLOW_16); | ||
16124 | rule__ALSRangeRestrictionRight__Group_1__1__Impl(); | ||
16125 | |||
16126 | state._fsp--; | ||
16127 | if (state.failed) return ; | ||
16128 | pushFollow(FOLLOW_2); | ||
16129 | rule__ALSRangeRestrictionRight__Group_1__2(); | ||
16130 | |||
16131 | state._fsp--; | ||
16132 | if (state.failed) return ; | ||
16133 | |||
16134 | } | ||
16135 | |||
16136 | } | ||
16137 | catch (RecognitionException re) { | ||
16138 | reportError(re); | ||
16139 | recover(input,re); | ||
16140 | } | ||
16141 | finally { | ||
16142 | |||
16143 | restoreStackSize(stackSize); | ||
16144 | |||
16145 | } | ||
16146 | return ; | ||
16147 | } | ||
16148 | // $ANTLR end "rule__ALSRangeRestrictionRight__Group_1__1" | ||
16149 | |||
16150 | |||
16151 | // $ANTLR start "rule__ALSRangeRestrictionRight__Group_1__1__Impl" | ||
16152 | // InternalAlloyLanguage.g:5556:1: rule__ALSRangeRestrictionRight__Group_1__1__Impl : ( ':>' ) ; | ||
16153 | public final void rule__ALSRangeRestrictionRight__Group_1__1__Impl() throws RecognitionException { | ||
16154 | |||
16155 | int stackSize = keepStackSize(); | ||
16156 | |||
16157 | try { | ||
16158 | // InternalAlloyLanguage.g:5560:1: ( ( ':>' ) ) | ||
16159 | // InternalAlloyLanguage.g:5561:1: ( ':>' ) | ||
16160 | { | ||
16161 | // InternalAlloyLanguage.g:5561:1: ( ':>' ) | ||
16162 | // InternalAlloyLanguage.g:5562:1: ':>' | ||
16163 | { | ||
16164 | if ( state.backtracking==0 ) { | ||
16165 | before(grammarAccess.getALSRangeRestrictionRightAccess().getColonGreaterThanSignKeyword_1_1()); | ||
16166 | } | ||
16167 | match(input,54,FOLLOW_2); if (state.failed) return ; | ||
16168 | if ( state.backtracking==0 ) { | ||
16169 | after(grammarAccess.getALSRangeRestrictionRightAccess().getColonGreaterThanSignKeyword_1_1()); | ||
16170 | } | ||
16171 | |||
16172 | } | ||
16173 | |||
16174 | |||
16175 | } | ||
16176 | |||
16177 | } | ||
16178 | catch (RecognitionException re) { | ||
16179 | reportError(re); | ||
16180 | recover(input,re); | ||
16181 | } | ||
16182 | finally { | ||
16183 | |||
16184 | restoreStackSize(stackSize); | ||
16185 | |||
16186 | } | ||
16187 | return ; | ||
16188 | } | ||
16189 | // $ANTLR end "rule__ALSRangeRestrictionRight__Group_1__1__Impl" | ||
16190 | |||
16191 | |||
16192 | // $ANTLR start "rule__ALSRangeRestrictionRight__Group_1__2" | ||
16193 | // InternalAlloyLanguage.g:5575:1: rule__ALSRangeRestrictionRight__Group_1__2 : rule__ALSRangeRestrictionRight__Group_1__2__Impl ; | ||
16194 | public final void rule__ALSRangeRestrictionRight__Group_1__2() throws RecognitionException { | ||
16195 | |||
16196 | int stackSize = keepStackSize(); | ||
16197 | |||
16198 | try { | ||
16199 | // InternalAlloyLanguage.g:5579:1: ( rule__ALSRangeRestrictionRight__Group_1__2__Impl ) | ||
16200 | // InternalAlloyLanguage.g:5580:2: rule__ALSRangeRestrictionRight__Group_1__2__Impl | ||
16201 | { | ||
16202 | pushFollow(FOLLOW_2); | ||
16203 | rule__ALSRangeRestrictionRight__Group_1__2__Impl(); | ||
16204 | |||
16205 | state._fsp--; | ||
16206 | if (state.failed) return ; | ||
16207 | |||
16208 | } | ||
16209 | |||
16210 | } | ||
16211 | catch (RecognitionException re) { | ||
16212 | reportError(re); | ||
16213 | recover(input,re); | ||
16214 | } | ||
16215 | finally { | ||
16216 | |||
16217 | restoreStackSize(stackSize); | ||
16218 | |||
16219 | } | ||
16220 | return ; | ||
16221 | } | ||
16222 | // $ANTLR end "rule__ALSRangeRestrictionRight__Group_1__2" | ||
16223 | |||
16224 | |||
16225 | // $ANTLR start "rule__ALSRangeRestrictionRight__Group_1__2__Impl" | ||
16226 | // InternalAlloyLanguage.g:5586:1: rule__ALSRangeRestrictionRight__Group_1__2__Impl : ( ( rule__ALSRangeRestrictionRight__FilterAssignment_1_2 ) ) ; | ||
16227 | public final void rule__ALSRangeRestrictionRight__Group_1__2__Impl() throws RecognitionException { | ||
16228 | |||
16229 | int stackSize = keepStackSize(); | ||
16230 | |||
16231 | try { | ||
16232 | // InternalAlloyLanguage.g:5590:1: ( ( ( rule__ALSRangeRestrictionRight__FilterAssignment_1_2 ) ) ) | ||
16233 | // InternalAlloyLanguage.g:5591:1: ( ( rule__ALSRangeRestrictionRight__FilterAssignment_1_2 ) ) | ||
16234 | { | ||
16235 | // InternalAlloyLanguage.g:5591:1: ( ( rule__ALSRangeRestrictionRight__FilterAssignment_1_2 ) ) | ||
16236 | // InternalAlloyLanguage.g:5592:1: ( rule__ALSRangeRestrictionRight__FilterAssignment_1_2 ) | ||
16237 | { | ||
16238 | if ( state.backtracking==0 ) { | ||
16239 | before(grammarAccess.getALSRangeRestrictionRightAccess().getFilterAssignment_1_2()); | ||
16240 | } | ||
16241 | // InternalAlloyLanguage.g:5593:1: ( rule__ALSRangeRestrictionRight__FilterAssignment_1_2 ) | ||
16242 | // InternalAlloyLanguage.g:5593:2: rule__ALSRangeRestrictionRight__FilterAssignment_1_2 | ||
16243 | { | ||
16244 | pushFollow(FOLLOW_2); | ||
16245 | rule__ALSRangeRestrictionRight__FilterAssignment_1_2(); | ||
16246 | |||
16247 | state._fsp--; | ||
16248 | if (state.failed) return ; | ||
16249 | |||
16250 | } | ||
16251 | |||
16252 | if ( state.backtracking==0 ) { | ||
16253 | after(grammarAccess.getALSRangeRestrictionRightAccess().getFilterAssignment_1_2()); | ||
16254 | } | ||
16255 | |||
16256 | } | ||
16257 | |||
16258 | |||
16259 | } | ||
16260 | |||
16261 | } | ||
16262 | catch (RecognitionException re) { | ||
16263 | reportError(re); | ||
16264 | recover(input,re); | ||
16265 | } | ||
16266 | finally { | ||
16267 | |||
16268 | restoreStackSize(stackSize); | ||
16269 | |||
16270 | } | ||
16271 | return ; | ||
16272 | } | ||
16273 | // $ANTLR end "rule__ALSRangeRestrictionRight__Group_1__2__Impl" | ||
16274 | |||
16275 | |||
16276 | // $ANTLR start "rule__ALSRangeRestrictionLeft__Group__0" | ||
16277 | // InternalAlloyLanguage.g:5609:1: rule__ALSRangeRestrictionLeft__Group__0 : rule__ALSRangeRestrictionLeft__Group__0__Impl rule__ALSRangeRestrictionLeft__Group__1 ; | ||
16278 | public final void rule__ALSRangeRestrictionLeft__Group__0() throws RecognitionException { | ||
16279 | |||
16280 | int stackSize = keepStackSize(); | ||
16281 | |||
16282 | try { | ||
16283 | // InternalAlloyLanguage.g:5613:1: ( rule__ALSRangeRestrictionLeft__Group__0__Impl rule__ALSRangeRestrictionLeft__Group__1 ) | ||
16284 | // InternalAlloyLanguage.g:5614:2: rule__ALSRangeRestrictionLeft__Group__0__Impl rule__ALSRangeRestrictionLeft__Group__1 | ||
16285 | { | ||
16286 | pushFollow(FOLLOW_39); | ||
16287 | rule__ALSRangeRestrictionLeft__Group__0__Impl(); | ||
16288 | |||
16289 | state._fsp--; | ||
16290 | if (state.failed) return ; | ||
16291 | pushFollow(FOLLOW_2); | ||
16292 | rule__ALSRangeRestrictionLeft__Group__1(); | ||
16293 | |||
16294 | state._fsp--; | ||
16295 | if (state.failed) return ; | ||
16296 | |||
16297 | } | ||
16298 | |||
16299 | } | ||
16300 | catch (RecognitionException re) { | ||
16301 | reportError(re); | ||
16302 | recover(input,re); | ||
16303 | } | ||
16304 | finally { | ||
16305 | |||
16306 | restoreStackSize(stackSize); | ||
16307 | |||
16308 | } | ||
16309 | return ; | ||
16310 | } | ||
16311 | // $ANTLR end "rule__ALSRangeRestrictionLeft__Group__0" | ||
16312 | |||
16313 | |||
16314 | // $ANTLR start "rule__ALSRangeRestrictionLeft__Group__0__Impl" | ||
16315 | // InternalAlloyLanguage.g:5621:1: rule__ALSRangeRestrictionLeft__Group__0__Impl : ( ruleALSJoin ) ; | ||
16316 | public final void rule__ALSRangeRestrictionLeft__Group__0__Impl() throws RecognitionException { | ||
16317 | |||
16318 | int stackSize = keepStackSize(); | ||
16319 | |||
16320 | try { | ||
16321 | // InternalAlloyLanguage.g:5625:1: ( ( ruleALSJoin ) ) | ||
16322 | // InternalAlloyLanguage.g:5626:1: ( ruleALSJoin ) | ||
16323 | { | ||
16324 | // InternalAlloyLanguage.g:5626:1: ( ruleALSJoin ) | ||
16325 | // InternalAlloyLanguage.g:5627:1: ruleALSJoin | ||
16326 | { | ||
16327 | if ( state.backtracking==0 ) { | ||
16328 | before(grammarAccess.getALSRangeRestrictionLeftAccess().getALSJoinParserRuleCall_0()); | ||
16329 | } | ||
16330 | pushFollow(FOLLOW_2); | ||
16331 | ruleALSJoin(); | ||
16332 | |||
16333 | state._fsp--; | ||
16334 | if (state.failed) return ; | ||
16335 | if ( state.backtracking==0 ) { | ||
16336 | after(grammarAccess.getALSRangeRestrictionLeftAccess().getALSJoinParserRuleCall_0()); | ||
16337 | } | ||
16338 | |||
16339 | } | ||
16340 | |||
16341 | |||
16342 | } | ||
16343 | |||
16344 | } | ||
16345 | catch (RecognitionException re) { | ||
16346 | reportError(re); | ||
16347 | recover(input,re); | ||
16348 | } | ||
16349 | finally { | ||
16350 | |||
16351 | restoreStackSize(stackSize); | ||
16352 | |||
16353 | } | ||
16354 | return ; | ||
16355 | } | ||
16356 | // $ANTLR end "rule__ALSRangeRestrictionLeft__Group__0__Impl" | ||
16357 | |||
16358 | |||
16359 | // $ANTLR start "rule__ALSRangeRestrictionLeft__Group__1" | ||
16360 | // InternalAlloyLanguage.g:5638:1: rule__ALSRangeRestrictionLeft__Group__1 : rule__ALSRangeRestrictionLeft__Group__1__Impl ; | ||
16361 | public final void rule__ALSRangeRestrictionLeft__Group__1() throws RecognitionException { | ||
16362 | |||
16363 | int stackSize = keepStackSize(); | ||
16364 | |||
16365 | try { | ||
16366 | // InternalAlloyLanguage.g:5642:1: ( rule__ALSRangeRestrictionLeft__Group__1__Impl ) | ||
16367 | // InternalAlloyLanguage.g:5643:2: rule__ALSRangeRestrictionLeft__Group__1__Impl | ||
16368 | { | ||
16369 | pushFollow(FOLLOW_2); | ||
16370 | rule__ALSRangeRestrictionLeft__Group__1__Impl(); | ||
16371 | |||
16372 | state._fsp--; | ||
16373 | if (state.failed) return ; | ||
16374 | |||
16375 | } | ||
16376 | |||
16377 | } | ||
16378 | catch (RecognitionException re) { | ||
16379 | reportError(re); | ||
16380 | recover(input,re); | ||
16381 | } | ||
16382 | finally { | ||
16383 | |||
16384 | restoreStackSize(stackSize); | ||
16385 | |||
16386 | } | ||
16387 | return ; | ||
16388 | } | ||
16389 | // $ANTLR end "rule__ALSRangeRestrictionLeft__Group__1" | ||
16390 | |||
16391 | |||
16392 | // $ANTLR start "rule__ALSRangeRestrictionLeft__Group__1__Impl" | ||
16393 | // InternalAlloyLanguage.g:5649:1: rule__ALSRangeRestrictionLeft__Group__1__Impl : ( ( rule__ALSRangeRestrictionLeft__Group_1__0 )? ) ; | ||
16394 | public final void rule__ALSRangeRestrictionLeft__Group__1__Impl() throws RecognitionException { | ||
16395 | |||
16396 | int stackSize = keepStackSize(); | ||
16397 | |||
16398 | try { | ||
16399 | // InternalAlloyLanguage.g:5653:1: ( ( ( rule__ALSRangeRestrictionLeft__Group_1__0 )? ) ) | ||
16400 | // InternalAlloyLanguage.g:5654:1: ( ( rule__ALSRangeRestrictionLeft__Group_1__0 )? ) | ||
16401 | { | ||
16402 | // InternalAlloyLanguage.g:5654:1: ( ( rule__ALSRangeRestrictionLeft__Group_1__0 )? ) | ||
16403 | // InternalAlloyLanguage.g:5655:1: ( rule__ALSRangeRestrictionLeft__Group_1__0 )? | ||
16404 | { | ||
16405 | if ( state.backtracking==0 ) { | ||
16406 | before(grammarAccess.getALSRangeRestrictionLeftAccess().getGroup_1()); | ||
16407 | } | ||
16408 | // InternalAlloyLanguage.g:5656:1: ( rule__ALSRangeRestrictionLeft__Group_1__0 )? | ||
16409 | int alt38=2; | ||
16410 | int LA38_0 = input.LA(1); | ||
16411 | |||
16412 | if ( (LA38_0==55) ) { | ||
16413 | alt38=1; | ||
16414 | } | ||
16415 | switch (alt38) { | ||
16416 | case 1 : | ||
16417 | // InternalAlloyLanguage.g:5656:2: rule__ALSRangeRestrictionLeft__Group_1__0 | ||
16418 | { | ||
16419 | pushFollow(FOLLOW_2); | ||
16420 | rule__ALSRangeRestrictionLeft__Group_1__0(); | ||
16421 | |||
16422 | state._fsp--; | ||
16423 | if (state.failed) return ; | ||
16424 | |||
16425 | } | ||
16426 | break; | ||
16427 | |||
16428 | } | ||
16429 | |||
16430 | if ( state.backtracking==0 ) { | ||
16431 | after(grammarAccess.getALSRangeRestrictionLeftAccess().getGroup_1()); | ||
16432 | } | ||
16433 | |||
16434 | } | ||
16435 | |||
16436 | |||
16437 | } | ||
16438 | |||
16439 | } | ||
16440 | catch (RecognitionException re) { | ||
16441 | reportError(re); | ||
16442 | recover(input,re); | ||
16443 | } | ||
16444 | finally { | ||
16445 | |||
16446 | restoreStackSize(stackSize); | ||
16447 | |||
16448 | } | ||
16449 | return ; | ||
16450 | } | ||
16451 | // $ANTLR end "rule__ALSRangeRestrictionLeft__Group__1__Impl" | ||
16452 | |||
16453 | |||
16454 | // $ANTLR start "rule__ALSRangeRestrictionLeft__Group_1__0" | ||
16455 | // InternalAlloyLanguage.g:5670:1: rule__ALSRangeRestrictionLeft__Group_1__0 : rule__ALSRangeRestrictionLeft__Group_1__0__Impl rule__ALSRangeRestrictionLeft__Group_1__1 ; | ||
16456 | public final void rule__ALSRangeRestrictionLeft__Group_1__0() throws RecognitionException { | ||
16457 | |||
16458 | int stackSize = keepStackSize(); | ||
16459 | |||
16460 | try { | ||
16461 | // InternalAlloyLanguage.g:5674:1: ( rule__ALSRangeRestrictionLeft__Group_1__0__Impl rule__ALSRangeRestrictionLeft__Group_1__1 ) | ||
16462 | // InternalAlloyLanguage.g:5675:2: rule__ALSRangeRestrictionLeft__Group_1__0__Impl rule__ALSRangeRestrictionLeft__Group_1__1 | ||
16463 | { | ||
16464 | pushFollow(FOLLOW_39); | ||
16465 | rule__ALSRangeRestrictionLeft__Group_1__0__Impl(); | ||
16466 | |||
16467 | state._fsp--; | ||
16468 | if (state.failed) return ; | ||
16469 | pushFollow(FOLLOW_2); | ||
16470 | rule__ALSRangeRestrictionLeft__Group_1__1(); | ||
16471 | |||
16472 | state._fsp--; | ||
16473 | if (state.failed) return ; | ||
16474 | |||
16475 | } | ||
16476 | |||
16477 | } | ||
16478 | catch (RecognitionException re) { | ||
16479 | reportError(re); | ||
16480 | recover(input,re); | ||
16481 | } | ||
16482 | finally { | ||
16483 | |||
16484 | restoreStackSize(stackSize); | ||
16485 | |||
16486 | } | ||
16487 | return ; | ||
16488 | } | ||
16489 | // $ANTLR end "rule__ALSRangeRestrictionLeft__Group_1__0" | ||
16490 | |||
16491 | |||
16492 | // $ANTLR start "rule__ALSRangeRestrictionLeft__Group_1__0__Impl" | ||
16493 | // InternalAlloyLanguage.g:5682:1: rule__ALSRangeRestrictionLeft__Group_1__0__Impl : ( () ) ; | ||
16494 | public final void rule__ALSRangeRestrictionLeft__Group_1__0__Impl() throws RecognitionException { | ||
16495 | |||
16496 | int stackSize = keepStackSize(); | ||
16497 | |||
16498 | try { | ||
16499 | // InternalAlloyLanguage.g:5686:1: ( ( () ) ) | ||
16500 | // InternalAlloyLanguage.g:5687:1: ( () ) | ||
16501 | { | ||
16502 | // InternalAlloyLanguage.g:5687:1: ( () ) | ||
16503 | // InternalAlloyLanguage.g:5688:1: () | ||
16504 | { | ||
16505 | if ( state.backtracking==0 ) { | ||
16506 | before(grammarAccess.getALSRangeRestrictionLeftAccess().getALSRangeRestrictionLeftFilterAction_1_0()); | ||
16507 | } | ||
16508 | // InternalAlloyLanguage.g:5689:1: () | ||
16509 | // InternalAlloyLanguage.g:5691:1: | ||
16510 | { | ||
16511 | } | ||
16512 | |||
16513 | if ( state.backtracking==0 ) { | ||
16514 | after(grammarAccess.getALSRangeRestrictionLeftAccess().getALSRangeRestrictionLeftFilterAction_1_0()); | ||
16515 | } | ||
16516 | |||
16517 | } | ||
16518 | |||
16519 | |||
16520 | } | ||
16521 | |||
16522 | } | ||
16523 | finally { | ||
16524 | |||
16525 | restoreStackSize(stackSize); | ||
16526 | |||
16527 | } | ||
16528 | return ; | ||
16529 | } | ||
16530 | // $ANTLR end "rule__ALSRangeRestrictionLeft__Group_1__0__Impl" | ||
16531 | |||
16532 | |||
16533 | // $ANTLR start "rule__ALSRangeRestrictionLeft__Group_1__1" | ||
16534 | // InternalAlloyLanguage.g:5701:1: rule__ALSRangeRestrictionLeft__Group_1__1 : rule__ALSRangeRestrictionLeft__Group_1__1__Impl rule__ALSRangeRestrictionLeft__Group_1__2 ; | ||
16535 | public final void rule__ALSRangeRestrictionLeft__Group_1__1() throws RecognitionException { | ||
16536 | |||
16537 | int stackSize = keepStackSize(); | ||
16538 | |||
16539 | try { | ||
16540 | // InternalAlloyLanguage.g:5705:1: ( rule__ALSRangeRestrictionLeft__Group_1__1__Impl rule__ALSRangeRestrictionLeft__Group_1__2 ) | ||
16541 | // InternalAlloyLanguage.g:5706:2: rule__ALSRangeRestrictionLeft__Group_1__1__Impl rule__ALSRangeRestrictionLeft__Group_1__2 | ||
16542 | { | ||
16543 | pushFollow(FOLLOW_16); | ||
16544 | rule__ALSRangeRestrictionLeft__Group_1__1__Impl(); | ||
16545 | |||
16546 | state._fsp--; | ||
16547 | if (state.failed) return ; | ||
16548 | pushFollow(FOLLOW_2); | ||
16549 | rule__ALSRangeRestrictionLeft__Group_1__2(); | ||
16550 | |||
16551 | state._fsp--; | ||
16552 | if (state.failed) return ; | ||
16553 | |||
16554 | } | ||
16555 | |||
16556 | } | ||
16557 | catch (RecognitionException re) { | ||
16558 | reportError(re); | ||
16559 | recover(input,re); | ||
16560 | } | ||
16561 | finally { | ||
16562 | |||
16563 | restoreStackSize(stackSize); | ||
16564 | |||
16565 | } | ||
16566 | return ; | ||
16567 | } | ||
16568 | // $ANTLR end "rule__ALSRangeRestrictionLeft__Group_1__1" | ||
16569 | |||
16570 | |||
16571 | // $ANTLR start "rule__ALSRangeRestrictionLeft__Group_1__1__Impl" | ||
16572 | // InternalAlloyLanguage.g:5713:1: rule__ALSRangeRestrictionLeft__Group_1__1__Impl : ( '<:' ) ; | ||
16573 | public final void rule__ALSRangeRestrictionLeft__Group_1__1__Impl() throws RecognitionException { | ||
16574 | |||
16575 | int stackSize = keepStackSize(); | ||
16576 | |||
16577 | try { | ||
16578 | // InternalAlloyLanguage.g:5717:1: ( ( '<:' ) ) | ||
16579 | // InternalAlloyLanguage.g:5718:1: ( '<:' ) | ||
16580 | { | ||
16581 | // InternalAlloyLanguage.g:5718:1: ( '<:' ) | ||
16582 | // InternalAlloyLanguage.g:5719:1: '<:' | ||
16583 | { | ||
16584 | if ( state.backtracking==0 ) { | ||
16585 | before(grammarAccess.getALSRangeRestrictionLeftAccess().getLessThanSignColonKeyword_1_1()); | ||
16586 | } | ||
16587 | match(input,55,FOLLOW_2); if (state.failed) return ; | ||
16588 | if ( state.backtracking==0 ) { | ||
16589 | after(grammarAccess.getALSRangeRestrictionLeftAccess().getLessThanSignColonKeyword_1_1()); | ||
16590 | } | ||
16591 | |||
16592 | } | ||
16593 | |||
16594 | |||
16595 | } | ||
16596 | |||
16597 | } | ||
16598 | catch (RecognitionException re) { | ||
16599 | reportError(re); | ||
16600 | recover(input,re); | ||
16601 | } | ||
16602 | finally { | ||
16603 | |||
16604 | restoreStackSize(stackSize); | ||
16605 | |||
16606 | } | ||
16607 | return ; | ||
16608 | } | ||
16609 | // $ANTLR end "rule__ALSRangeRestrictionLeft__Group_1__1__Impl" | ||
16610 | |||
16611 | |||
16612 | // $ANTLR start "rule__ALSRangeRestrictionLeft__Group_1__2" | ||
16613 | // InternalAlloyLanguage.g:5732:1: rule__ALSRangeRestrictionLeft__Group_1__2 : rule__ALSRangeRestrictionLeft__Group_1__2__Impl ; | ||
16614 | public final void rule__ALSRangeRestrictionLeft__Group_1__2() throws RecognitionException { | ||
16615 | |||
16616 | int stackSize = keepStackSize(); | ||
16617 | |||
16618 | try { | ||
16619 | // InternalAlloyLanguage.g:5736:1: ( rule__ALSRangeRestrictionLeft__Group_1__2__Impl ) | ||
16620 | // InternalAlloyLanguage.g:5737:2: rule__ALSRangeRestrictionLeft__Group_1__2__Impl | ||
16621 | { | ||
16622 | pushFollow(FOLLOW_2); | ||
16623 | rule__ALSRangeRestrictionLeft__Group_1__2__Impl(); | ||
16624 | |||
16625 | state._fsp--; | ||
16626 | if (state.failed) return ; | ||
16627 | |||
16628 | } | ||
16629 | |||
16630 | } | ||
16631 | catch (RecognitionException re) { | ||
16632 | reportError(re); | ||
16633 | recover(input,re); | ||
16634 | } | ||
16635 | finally { | ||
16636 | |||
16637 | restoreStackSize(stackSize); | ||
16638 | |||
16639 | } | ||
16640 | return ; | ||
16641 | } | ||
16642 | // $ANTLR end "rule__ALSRangeRestrictionLeft__Group_1__2" | ||
16643 | |||
16644 | |||
16645 | // $ANTLR start "rule__ALSRangeRestrictionLeft__Group_1__2__Impl" | ||
16646 | // InternalAlloyLanguage.g:5743:1: rule__ALSRangeRestrictionLeft__Group_1__2__Impl : ( ( rule__ALSRangeRestrictionLeft__RelationAssignment_1_2 ) ) ; | ||
16647 | public final void rule__ALSRangeRestrictionLeft__Group_1__2__Impl() throws RecognitionException { | ||
16648 | |||
16649 | int stackSize = keepStackSize(); | ||
16650 | |||
16651 | try { | ||
16652 | // InternalAlloyLanguage.g:5747:1: ( ( ( rule__ALSRangeRestrictionLeft__RelationAssignment_1_2 ) ) ) | ||
16653 | // InternalAlloyLanguage.g:5748:1: ( ( rule__ALSRangeRestrictionLeft__RelationAssignment_1_2 ) ) | ||
16654 | { | ||
16655 | // InternalAlloyLanguage.g:5748:1: ( ( rule__ALSRangeRestrictionLeft__RelationAssignment_1_2 ) ) | ||
16656 | // InternalAlloyLanguage.g:5749:1: ( rule__ALSRangeRestrictionLeft__RelationAssignment_1_2 ) | ||
16657 | { | ||
16658 | if ( state.backtracking==0 ) { | ||
16659 | before(grammarAccess.getALSRangeRestrictionLeftAccess().getRelationAssignment_1_2()); | ||
16660 | } | ||
16661 | // InternalAlloyLanguage.g:5750:1: ( rule__ALSRangeRestrictionLeft__RelationAssignment_1_2 ) | ||
16662 | // InternalAlloyLanguage.g:5750:2: rule__ALSRangeRestrictionLeft__RelationAssignment_1_2 | ||
16663 | { | ||
16664 | pushFollow(FOLLOW_2); | ||
16665 | rule__ALSRangeRestrictionLeft__RelationAssignment_1_2(); | ||
16666 | |||
16667 | state._fsp--; | ||
16668 | if (state.failed) return ; | ||
16669 | |||
16670 | } | ||
16671 | |||
16672 | if ( state.backtracking==0 ) { | ||
16673 | after(grammarAccess.getALSRangeRestrictionLeftAccess().getRelationAssignment_1_2()); | ||
16674 | } | ||
16675 | |||
16676 | } | ||
16677 | |||
16678 | |||
16679 | } | ||
16680 | |||
16681 | } | ||
16682 | catch (RecognitionException re) { | ||
16683 | reportError(re); | ||
16684 | recover(input,re); | ||
16685 | } | ||
16686 | finally { | ||
16687 | |||
16688 | restoreStackSize(stackSize); | ||
16689 | |||
16690 | } | ||
16691 | return ; | ||
16692 | } | ||
16693 | // $ANTLR end "rule__ALSRangeRestrictionLeft__Group_1__2__Impl" | ||
16694 | |||
16695 | |||
16696 | // $ANTLR start "rule__ALSJoin__Group__0" | ||
16697 | // InternalAlloyLanguage.g:5766:1: rule__ALSJoin__Group__0 : rule__ALSJoin__Group__0__Impl rule__ALSJoin__Group__1 ; | ||
16698 | public final void rule__ALSJoin__Group__0() throws RecognitionException { | ||
16699 | |||
16700 | int stackSize = keepStackSize(); | ||
16701 | |||
16702 | try { | ||
16703 | // InternalAlloyLanguage.g:5770:1: ( rule__ALSJoin__Group__0__Impl rule__ALSJoin__Group__1 ) | ||
16704 | // InternalAlloyLanguage.g:5771:2: rule__ALSJoin__Group__0__Impl rule__ALSJoin__Group__1 | ||
16705 | { | ||
16706 | pushFollow(FOLLOW_40); | ||
16707 | rule__ALSJoin__Group__0__Impl(); | ||
16708 | |||
16709 | state._fsp--; | ||
16710 | if (state.failed) return ; | ||
16711 | pushFollow(FOLLOW_2); | ||
16712 | rule__ALSJoin__Group__1(); | ||
16713 | |||
16714 | state._fsp--; | ||
16715 | if (state.failed) return ; | ||
16716 | |||
16717 | } | ||
16718 | |||
16719 | } | ||
16720 | catch (RecognitionException re) { | ||
16721 | reportError(re); | ||
16722 | recover(input,re); | ||
16723 | } | ||
16724 | finally { | ||
16725 | |||
16726 | restoreStackSize(stackSize); | ||
16727 | |||
16728 | } | ||
16729 | return ; | ||
16730 | } | ||
16731 | // $ANTLR end "rule__ALSJoin__Group__0" | ||
16732 | |||
16733 | |||
16734 | // $ANTLR start "rule__ALSJoin__Group__0__Impl" | ||
16735 | // InternalAlloyLanguage.g:5778:1: rule__ALSJoin__Group__0__Impl : ( ruleALSMinus ) ; | ||
16736 | public final void rule__ALSJoin__Group__0__Impl() throws RecognitionException { | ||
16737 | |||
16738 | int stackSize = keepStackSize(); | ||
16739 | |||
16740 | try { | ||
16741 | // InternalAlloyLanguage.g:5782:1: ( ( ruleALSMinus ) ) | ||
16742 | // InternalAlloyLanguage.g:5783:1: ( ruleALSMinus ) | ||
16743 | { | ||
16744 | // InternalAlloyLanguage.g:5783:1: ( ruleALSMinus ) | ||
16745 | // InternalAlloyLanguage.g:5784:1: ruleALSMinus | ||
16746 | { | ||
16747 | if ( state.backtracking==0 ) { | ||
16748 | before(grammarAccess.getALSJoinAccess().getALSMinusParserRuleCall_0()); | ||
16749 | } | ||
16750 | pushFollow(FOLLOW_2); | ||
16751 | ruleALSMinus(); | ||
16752 | |||
16753 | state._fsp--; | ||
16754 | if (state.failed) return ; | ||
16755 | if ( state.backtracking==0 ) { | ||
16756 | after(grammarAccess.getALSJoinAccess().getALSMinusParserRuleCall_0()); | ||
16757 | } | ||
16758 | |||
16759 | } | ||
16760 | |||
16761 | |||
16762 | } | ||
16763 | |||
16764 | } | ||
16765 | catch (RecognitionException re) { | ||
16766 | reportError(re); | ||
16767 | recover(input,re); | ||
16768 | } | ||
16769 | finally { | ||
16770 | |||
16771 | restoreStackSize(stackSize); | ||
16772 | |||
16773 | } | ||
16774 | return ; | ||
16775 | } | ||
16776 | // $ANTLR end "rule__ALSJoin__Group__0__Impl" | ||
16777 | |||
16778 | |||
16779 | // $ANTLR start "rule__ALSJoin__Group__1" | ||
16780 | // InternalAlloyLanguage.g:5795:1: rule__ALSJoin__Group__1 : rule__ALSJoin__Group__1__Impl ; | ||
16781 | public final void rule__ALSJoin__Group__1() throws RecognitionException { | ||
16782 | |||
16783 | int stackSize = keepStackSize(); | ||
16784 | |||
16785 | try { | ||
16786 | // InternalAlloyLanguage.g:5799:1: ( rule__ALSJoin__Group__1__Impl ) | ||
16787 | // InternalAlloyLanguage.g:5800:2: rule__ALSJoin__Group__1__Impl | ||
16788 | { | ||
16789 | pushFollow(FOLLOW_2); | ||
16790 | rule__ALSJoin__Group__1__Impl(); | ||
16791 | |||
16792 | state._fsp--; | ||
16793 | if (state.failed) return ; | ||
16794 | |||
16795 | } | ||
16796 | |||
16797 | } | ||
16798 | catch (RecognitionException re) { | ||
16799 | reportError(re); | ||
16800 | recover(input,re); | ||
16801 | } | ||
16802 | finally { | ||
16803 | |||
16804 | restoreStackSize(stackSize); | ||
16805 | |||
16806 | } | ||
16807 | return ; | ||
16808 | } | ||
16809 | // $ANTLR end "rule__ALSJoin__Group__1" | ||
16810 | |||
16811 | |||
16812 | // $ANTLR start "rule__ALSJoin__Group__1__Impl" | ||
16813 | // InternalAlloyLanguage.g:5806:1: rule__ALSJoin__Group__1__Impl : ( ( rule__ALSJoin__Group_1__0 )* ) ; | ||
16814 | public final void rule__ALSJoin__Group__1__Impl() throws RecognitionException { | ||
16815 | |||
16816 | int stackSize = keepStackSize(); | ||
16817 | |||
16818 | try { | ||
16819 | // InternalAlloyLanguage.g:5810:1: ( ( ( rule__ALSJoin__Group_1__0 )* ) ) | ||
16820 | // InternalAlloyLanguage.g:5811:1: ( ( rule__ALSJoin__Group_1__0 )* ) | ||
16821 | { | ||
16822 | // InternalAlloyLanguage.g:5811:1: ( ( rule__ALSJoin__Group_1__0 )* ) | ||
16823 | // InternalAlloyLanguage.g:5812:1: ( rule__ALSJoin__Group_1__0 )* | ||
16824 | { | ||
16825 | if ( state.backtracking==0 ) { | ||
16826 | before(grammarAccess.getALSJoinAccess().getGroup_1()); | ||
16827 | } | ||
16828 | // InternalAlloyLanguage.g:5813:1: ( rule__ALSJoin__Group_1__0 )* | ||
16829 | loop39: | ||
16830 | do { | ||
16831 | int alt39=2; | ||
16832 | int LA39_0 = input.LA(1); | ||
16833 | |||
16834 | if ( (LA39_0==56) ) { | ||
16835 | alt39=1; | ||
16836 | } | ||
16837 | |||
16838 | |||
16839 | switch (alt39) { | ||
16840 | case 1 : | ||
16841 | // InternalAlloyLanguage.g:5813:2: rule__ALSJoin__Group_1__0 | ||
16842 | { | ||
16843 | pushFollow(FOLLOW_41); | ||
16844 | rule__ALSJoin__Group_1__0(); | ||
16845 | |||
16846 | state._fsp--; | ||
16847 | if (state.failed) return ; | ||
16848 | |||
16849 | } | ||
16850 | break; | ||
16851 | |||
16852 | default : | ||
16853 | break loop39; | ||
16854 | } | ||
16855 | } while (true); | ||
16856 | |||
16857 | if ( state.backtracking==0 ) { | ||
16858 | after(grammarAccess.getALSJoinAccess().getGroup_1()); | ||
16859 | } | ||
16860 | |||
16861 | } | ||
16862 | |||
16863 | |||
16864 | } | ||
16865 | |||
16866 | } | ||
16867 | catch (RecognitionException re) { | ||
16868 | reportError(re); | ||
16869 | recover(input,re); | ||
16870 | } | ||
16871 | finally { | ||
16872 | |||
16873 | restoreStackSize(stackSize); | ||
16874 | |||
16875 | } | ||
16876 | return ; | ||
16877 | } | ||
16878 | // $ANTLR end "rule__ALSJoin__Group__1__Impl" | ||
16879 | |||
16880 | |||
16881 | // $ANTLR start "rule__ALSJoin__Group_1__0" | ||
16882 | // InternalAlloyLanguage.g:5827:1: rule__ALSJoin__Group_1__0 : rule__ALSJoin__Group_1__0__Impl rule__ALSJoin__Group_1__1 ; | ||
16883 | public final void rule__ALSJoin__Group_1__0() throws RecognitionException { | ||
16884 | |||
16885 | int stackSize = keepStackSize(); | ||
16886 | |||
16887 | try { | ||
16888 | // InternalAlloyLanguage.g:5831:1: ( rule__ALSJoin__Group_1__0__Impl rule__ALSJoin__Group_1__1 ) | ||
16889 | // InternalAlloyLanguage.g:5832:2: rule__ALSJoin__Group_1__0__Impl rule__ALSJoin__Group_1__1 | ||
16890 | { | ||
16891 | pushFollow(FOLLOW_40); | ||
16892 | rule__ALSJoin__Group_1__0__Impl(); | ||
16893 | |||
16894 | state._fsp--; | ||
16895 | if (state.failed) return ; | ||
16896 | pushFollow(FOLLOW_2); | ||
16897 | rule__ALSJoin__Group_1__1(); | ||
16898 | |||
16899 | state._fsp--; | ||
16900 | if (state.failed) return ; | ||
16901 | |||
16902 | } | ||
16903 | |||
16904 | } | ||
16905 | catch (RecognitionException re) { | ||
16906 | reportError(re); | ||
16907 | recover(input,re); | ||
16908 | } | ||
16909 | finally { | ||
16910 | |||
16911 | restoreStackSize(stackSize); | ||
16912 | |||
16913 | } | ||
16914 | return ; | ||
16915 | } | ||
16916 | // $ANTLR end "rule__ALSJoin__Group_1__0" | ||
16917 | |||
16918 | |||
16919 | // $ANTLR start "rule__ALSJoin__Group_1__0__Impl" | ||
16920 | // InternalAlloyLanguage.g:5839:1: rule__ALSJoin__Group_1__0__Impl : ( () ) ; | ||
16921 | public final void rule__ALSJoin__Group_1__0__Impl() throws RecognitionException { | ||
16922 | |||
16923 | int stackSize = keepStackSize(); | ||
16924 | |||
16925 | try { | ||
16926 | // InternalAlloyLanguage.g:5843:1: ( ( () ) ) | ||
16927 | // InternalAlloyLanguage.g:5844:1: ( () ) | ||
16928 | { | ||
16929 | // InternalAlloyLanguage.g:5844:1: ( () ) | ||
16930 | // InternalAlloyLanguage.g:5845:1: () | ||
16931 | { | ||
16932 | if ( state.backtracking==0 ) { | ||
16933 | before(grammarAccess.getALSJoinAccess().getALSJoinLeftOperandAction_1_0()); | ||
16934 | } | ||
16935 | // InternalAlloyLanguage.g:5846:1: () | ||
16936 | // InternalAlloyLanguage.g:5848:1: | ||
16937 | { | ||
16938 | } | ||
16939 | |||
16940 | if ( state.backtracking==0 ) { | ||
16941 | after(grammarAccess.getALSJoinAccess().getALSJoinLeftOperandAction_1_0()); | ||
16942 | } | ||
16943 | |||
16944 | } | ||
16945 | |||
16946 | |||
16947 | } | ||
16948 | |||
16949 | } | ||
16950 | finally { | ||
16951 | |||
16952 | restoreStackSize(stackSize); | ||
16953 | |||
16954 | } | ||
16955 | return ; | ||
16956 | } | ||
16957 | // $ANTLR end "rule__ALSJoin__Group_1__0__Impl" | ||
16958 | |||
16959 | |||
16960 | // $ANTLR start "rule__ALSJoin__Group_1__1" | ||
16961 | // InternalAlloyLanguage.g:5858:1: rule__ALSJoin__Group_1__1 : rule__ALSJoin__Group_1__1__Impl rule__ALSJoin__Group_1__2 ; | ||
16962 | public final void rule__ALSJoin__Group_1__1() throws RecognitionException { | ||
16963 | |||
16964 | int stackSize = keepStackSize(); | ||
16965 | |||
16966 | try { | ||
16967 | // InternalAlloyLanguage.g:5862:1: ( rule__ALSJoin__Group_1__1__Impl rule__ALSJoin__Group_1__2 ) | ||
16968 | // InternalAlloyLanguage.g:5863:2: rule__ALSJoin__Group_1__1__Impl rule__ALSJoin__Group_1__2 | ||
16969 | { | ||
16970 | pushFollow(FOLLOW_16); | ||
16971 | rule__ALSJoin__Group_1__1__Impl(); | ||
16972 | |||
16973 | state._fsp--; | ||
16974 | if (state.failed) return ; | ||
16975 | pushFollow(FOLLOW_2); | ||
16976 | rule__ALSJoin__Group_1__2(); | ||
16977 | |||
16978 | state._fsp--; | ||
16979 | if (state.failed) return ; | ||
16980 | |||
16981 | } | ||
16982 | |||
16983 | } | ||
16984 | catch (RecognitionException re) { | ||
16985 | reportError(re); | ||
16986 | recover(input,re); | ||
16987 | } | ||
16988 | finally { | ||
16989 | |||
16990 | restoreStackSize(stackSize); | ||
16991 | |||
16992 | } | ||
16993 | return ; | ||
16994 | } | ||
16995 | // $ANTLR end "rule__ALSJoin__Group_1__1" | ||
16996 | |||
16997 | |||
16998 | // $ANTLR start "rule__ALSJoin__Group_1__1__Impl" | ||
16999 | // InternalAlloyLanguage.g:5870:1: rule__ALSJoin__Group_1__1__Impl : ( '.' ) ; | ||
17000 | public final void rule__ALSJoin__Group_1__1__Impl() throws RecognitionException { | ||
17001 | |||
17002 | int stackSize = keepStackSize(); | ||
17003 | |||
17004 | try { | ||
17005 | // InternalAlloyLanguage.g:5874:1: ( ( '.' ) ) | ||
17006 | // InternalAlloyLanguage.g:5875:1: ( '.' ) | ||
17007 | { | ||
17008 | // InternalAlloyLanguage.g:5875:1: ( '.' ) | ||
17009 | // InternalAlloyLanguage.g:5876:1: '.' | ||
17010 | { | ||
17011 | if ( state.backtracking==0 ) { | ||
17012 | before(grammarAccess.getALSJoinAccess().getFullStopKeyword_1_1()); | ||
17013 | } | ||
17014 | match(input,56,FOLLOW_2); if (state.failed) return ; | ||
17015 | if ( state.backtracking==0 ) { | ||
17016 | after(grammarAccess.getALSJoinAccess().getFullStopKeyword_1_1()); | ||
17017 | } | ||
17018 | |||
17019 | } | ||
17020 | |||
17021 | |||
17022 | } | ||
17023 | |||
17024 | } | ||
17025 | catch (RecognitionException re) { | ||
17026 | reportError(re); | ||
17027 | recover(input,re); | ||
17028 | } | ||
17029 | finally { | ||
17030 | |||
17031 | restoreStackSize(stackSize); | ||
17032 | |||
17033 | } | ||
17034 | return ; | ||
17035 | } | ||
17036 | // $ANTLR end "rule__ALSJoin__Group_1__1__Impl" | ||
17037 | |||
17038 | |||
17039 | // $ANTLR start "rule__ALSJoin__Group_1__2" | ||
17040 | // InternalAlloyLanguage.g:5889:1: rule__ALSJoin__Group_1__2 : rule__ALSJoin__Group_1__2__Impl ; | ||
17041 | public final void rule__ALSJoin__Group_1__2() throws RecognitionException { | ||
17042 | |||
17043 | int stackSize = keepStackSize(); | ||
17044 | |||
17045 | try { | ||
17046 | // InternalAlloyLanguage.g:5893:1: ( rule__ALSJoin__Group_1__2__Impl ) | ||
17047 | // InternalAlloyLanguage.g:5894:2: rule__ALSJoin__Group_1__2__Impl | ||
17048 | { | ||
17049 | pushFollow(FOLLOW_2); | ||
17050 | rule__ALSJoin__Group_1__2__Impl(); | ||
17051 | |||
17052 | state._fsp--; | ||
17053 | if (state.failed) return ; | ||
17054 | |||
17055 | } | ||
17056 | |||
17057 | } | ||
17058 | catch (RecognitionException re) { | ||
17059 | reportError(re); | ||
17060 | recover(input,re); | ||
17061 | } | ||
17062 | finally { | ||
17063 | |||
17064 | restoreStackSize(stackSize); | ||
17065 | |||
17066 | } | ||
17067 | return ; | ||
17068 | } | ||
17069 | // $ANTLR end "rule__ALSJoin__Group_1__2" | ||
17070 | |||
17071 | |||
17072 | // $ANTLR start "rule__ALSJoin__Group_1__2__Impl" | ||
17073 | // InternalAlloyLanguage.g:5900:1: rule__ALSJoin__Group_1__2__Impl : ( ( rule__ALSJoin__RightOperandAssignment_1_2 ) ) ; | ||
17074 | public final void rule__ALSJoin__Group_1__2__Impl() throws RecognitionException { | ||
17075 | |||
17076 | int stackSize = keepStackSize(); | ||
17077 | |||
17078 | try { | ||
17079 | // InternalAlloyLanguage.g:5904:1: ( ( ( rule__ALSJoin__RightOperandAssignment_1_2 ) ) ) | ||
17080 | // InternalAlloyLanguage.g:5905:1: ( ( rule__ALSJoin__RightOperandAssignment_1_2 ) ) | ||
17081 | { | ||
17082 | // InternalAlloyLanguage.g:5905:1: ( ( rule__ALSJoin__RightOperandAssignment_1_2 ) ) | ||
17083 | // InternalAlloyLanguage.g:5906:1: ( rule__ALSJoin__RightOperandAssignment_1_2 ) | ||
17084 | { | ||
17085 | if ( state.backtracking==0 ) { | ||
17086 | before(grammarAccess.getALSJoinAccess().getRightOperandAssignment_1_2()); | ||
17087 | } | ||
17088 | // InternalAlloyLanguage.g:5907:1: ( rule__ALSJoin__RightOperandAssignment_1_2 ) | ||
17089 | // InternalAlloyLanguage.g:5907:2: rule__ALSJoin__RightOperandAssignment_1_2 | ||
17090 | { | ||
17091 | pushFollow(FOLLOW_2); | ||
17092 | rule__ALSJoin__RightOperandAssignment_1_2(); | ||
17093 | |||
17094 | state._fsp--; | ||
17095 | if (state.failed) return ; | ||
17096 | |||
17097 | } | ||
17098 | |||
17099 | if ( state.backtracking==0 ) { | ||
17100 | after(grammarAccess.getALSJoinAccess().getRightOperandAssignment_1_2()); | ||
17101 | } | ||
17102 | |||
17103 | } | ||
17104 | |||
17105 | |||
17106 | } | ||
17107 | |||
17108 | } | ||
17109 | catch (RecognitionException re) { | ||
17110 | reportError(re); | ||
17111 | recover(input,re); | ||
17112 | } | ||
17113 | finally { | ||
17114 | |||
17115 | restoreStackSize(stackSize); | ||
17116 | |||
17117 | } | ||
17118 | return ; | ||
17119 | } | ||
17120 | // $ANTLR end "rule__ALSJoin__Group_1__2__Impl" | ||
17121 | |||
17122 | |||
17123 | // $ANTLR start "rule__ALSMinus__Group__0" | ||
17124 | // InternalAlloyLanguage.g:5923:1: rule__ALSMinus__Group__0 : rule__ALSMinus__Group__0__Impl rule__ALSMinus__Group__1 ; | ||
17125 | public final void rule__ALSMinus__Group__0() throws RecognitionException { | ||
17126 | |||
17127 | int stackSize = keepStackSize(); | ||
17128 | |||
17129 | try { | ||
17130 | // InternalAlloyLanguage.g:5927:1: ( rule__ALSMinus__Group__0__Impl rule__ALSMinus__Group__1 ) | ||
17131 | // InternalAlloyLanguage.g:5928:2: rule__ALSMinus__Group__0__Impl rule__ALSMinus__Group__1 | ||
17132 | { | ||
17133 | pushFollow(FOLLOW_42); | ||
17134 | rule__ALSMinus__Group__0__Impl(); | ||
17135 | |||
17136 | state._fsp--; | ||
17137 | if (state.failed) return ; | ||
17138 | pushFollow(FOLLOW_2); | ||
17139 | rule__ALSMinus__Group__1(); | ||
17140 | |||
17141 | state._fsp--; | ||
17142 | if (state.failed) return ; | ||
17143 | |||
17144 | } | ||
17145 | |||
17146 | } | ||
17147 | catch (RecognitionException re) { | ||
17148 | reportError(re); | ||
17149 | recover(input,re); | ||
17150 | } | ||
17151 | finally { | ||
17152 | |||
17153 | restoreStackSize(stackSize); | ||
17154 | |||
17155 | } | ||
17156 | return ; | ||
17157 | } | ||
17158 | // $ANTLR end "rule__ALSMinus__Group__0" | ||
17159 | |||
17160 | |||
17161 | // $ANTLR start "rule__ALSMinus__Group__0__Impl" | ||
17162 | // InternalAlloyLanguage.g:5935:1: rule__ALSMinus__Group__0__Impl : ( ruleALSPlus ) ; | ||
17163 | public final void rule__ALSMinus__Group__0__Impl() throws RecognitionException { | ||
17164 | |||
17165 | int stackSize = keepStackSize(); | ||
17166 | |||
17167 | try { | ||
17168 | // InternalAlloyLanguage.g:5939:1: ( ( ruleALSPlus ) ) | ||
17169 | // InternalAlloyLanguage.g:5940:1: ( ruleALSPlus ) | ||
17170 | { | ||
17171 | // InternalAlloyLanguage.g:5940:1: ( ruleALSPlus ) | ||
17172 | // InternalAlloyLanguage.g:5941:1: ruleALSPlus | ||
17173 | { | ||
17174 | if ( state.backtracking==0 ) { | ||
17175 | before(grammarAccess.getALSMinusAccess().getALSPlusParserRuleCall_0()); | ||
17176 | } | ||
17177 | pushFollow(FOLLOW_2); | ||
17178 | ruleALSPlus(); | ||
17179 | |||
17180 | state._fsp--; | ||
17181 | if (state.failed) return ; | ||
17182 | if ( state.backtracking==0 ) { | ||
17183 | after(grammarAccess.getALSMinusAccess().getALSPlusParserRuleCall_0()); | ||
17184 | } | ||
17185 | |||
17186 | } | ||
17187 | |||
17188 | |||
17189 | } | ||
17190 | |||
17191 | } | ||
17192 | catch (RecognitionException re) { | ||
17193 | reportError(re); | ||
17194 | recover(input,re); | ||
17195 | } | ||
17196 | finally { | ||
17197 | |||
17198 | restoreStackSize(stackSize); | ||
17199 | |||
17200 | } | ||
17201 | return ; | ||
17202 | } | ||
17203 | // $ANTLR end "rule__ALSMinus__Group__0__Impl" | ||
17204 | |||
17205 | |||
17206 | // $ANTLR start "rule__ALSMinus__Group__1" | ||
17207 | // InternalAlloyLanguage.g:5952:1: rule__ALSMinus__Group__1 : rule__ALSMinus__Group__1__Impl ; | ||
17208 | public final void rule__ALSMinus__Group__1() throws RecognitionException { | ||
17209 | |||
17210 | int stackSize = keepStackSize(); | ||
17211 | |||
17212 | try { | ||
17213 | // InternalAlloyLanguage.g:5956:1: ( rule__ALSMinus__Group__1__Impl ) | ||
17214 | // InternalAlloyLanguage.g:5957:2: rule__ALSMinus__Group__1__Impl | ||
17215 | { | ||
17216 | pushFollow(FOLLOW_2); | ||
17217 | rule__ALSMinus__Group__1__Impl(); | ||
17218 | |||
17219 | state._fsp--; | ||
17220 | if (state.failed) return ; | ||
17221 | |||
17222 | } | ||
17223 | |||
17224 | } | ||
17225 | catch (RecognitionException re) { | ||
17226 | reportError(re); | ||
17227 | recover(input,re); | ||
17228 | } | ||
17229 | finally { | ||
17230 | |||
17231 | restoreStackSize(stackSize); | ||
17232 | |||
17233 | } | ||
17234 | return ; | ||
17235 | } | ||
17236 | // $ANTLR end "rule__ALSMinus__Group__1" | ||
17237 | |||
17238 | |||
17239 | // $ANTLR start "rule__ALSMinus__Group__1__Impl" | ||
17240 | // InternalAlloyLanguage.g:5963:1: rule__ALSMinus__Group__1__Impl : ( ( rule__ALSMinus__Group_1__0 )* ) ; | ||
17241 | public final void rule__ALSMinus__Group__1__Impl() throws RecognitionException { | ||
17242 | |||
17243 | int stackSize = keepStackSize(); | ||
17244 | |||
17245 | try { | ||
17246 | // InternalAlloyLanguage.g:5967:1: ( ( ( rule__ALSMinus__Group_1__0 )* ) ) | ||
17247 | // InternalAlloyLanguage.g:5968:1: ( ( rule__ALSMinus__Group_1__0 )* ) | ||
17248 | { | ||
17249 | // InternalAlloyLanguage.g:5968:1: ( ( rule__ALSMinus__Group_1__0 )* ) | ||
17250 | // InternalAlloyLanguage.g:5969:1: ( rule__ALSMinus__Group_1__0 )* | ||
17251 | { | ||
17252 | if ( state.backtracking==0 ) { | ||
17253 | before(grammarAccess.getALSMinusAccess().getGroup_1()); | ||
17254 | } | ||
17255 | // InternalAlloyLanguage.g:5970:1: ( rule__ALSMinus__Group_1__0 )* | ||
17256 | loop40: | ||
17257 | do { | ||
17258 | int alt40=2; | ||
17259 | int LA40_0 = input.LA(1); | ||
17260 | |||
17261 | if ( (LA40_0==57) ) { | ||
17262 | alt40=1; | ||
17263 | } | ||
17264 | |||
17265 | |||
17266 | switch (alt40) { | ||
17267 | case 1 : | ||
17268 | // InternalAlloyLanguage.g:5970:2: rule__ALSMinus__Group_1__0 | ||
17269 | { | ||
17270 | pushFollow(FOLLOW_43); | ||
17271 | rule__ALSMinus__Group_1__0(); | ||
17272 | |||
17273 | state._fsp--; | ||
17274 | if (state.failed) return ; | ||
17275 | |||
17276 | } | ||
17277 | break; | ||
17278 | |||
17279 | default : | ||
17280 | break loop40; | ||
17281 | } | ||
17282 | } while (true); | ||
17283 | |||
17284 | if ( state.backtracking==0 ) { | ||
17285 | after(grammarAccess.getALSMinusAccess().getGroup_1()); | ||
17286 | } | ||
17287 | |||
17288 | } | ||
17289 | |||
17290 | |||
17291 | } | ||
17292 | |||
17293 | } | ||
17294 | catch (RecognitionException re) { | ||
17295 | reportError(re); | ||
17296 | recover(input,re); | ||
17297 | } | ||
17298 | finally { | ||
17299 | |||
17300 | restoreStackSize(stackSize); | ||
17301 | |||
17302 | } | ||
17303 | return ; | ||
17304 | } | ||
17305 | // $ANTLR end "rule__ALSMinus__Group__1__Impl" | ||
17306 | |||
17307 | |||
17308 | // $ANTLR start "rule__ALSMinus__Group_1__0" | ||
17309 | // InternalAlloyLanguage.g:5984:1: rule__ALSMinus__Group_1__0 : rule__ALSMinus__Group_1__0__Impl rule__ALSMinus__Group_1__1 ; | ||
17310 | public final void rule__ALSMinus__Group_1__0() throws RecognitionException { | ||
17311 | |||
17312 | int stackSize = keepStackSize(); | ||
17313 | |||
17314 | try { | ||
17315 | // InternalAlloyLanguage.g:5988:1: ( rule__ALSMinus__Group_1__0__Impl rule__ALSMinus__Group_1__1 ) | ||
17316 | // InternalAlloyLanguage.g:5989:2: rule__ALSMinus__Group_1__0__Impl rule__ALSMinus__Group_1__1 | ||
17317 | { | ||
17318 | pushFollow(FOLLOW_42); | ||
17319 | rule__ALSMinus__Group_1__0__Impl(); | ||
17320 | |||
17321 | state._fsp--; | ||
17322 | if (state.failed) return ; | ||
17323 | pushFollow(FOLLOW_2); | ||
17324 | rule__ALSMinus__Group_1__1(); | ||
17325 | |||
17326 | state._fsp--; | ||
17327 | if (state.failed) return ; | ||
17328 | |||
17329 | } | ||
17330 | |||
17331 | } | ||
17332 | catch (RecognitionException re) { | ||
17333 | reportError(re); | ||
17334 | recover(input,re); | ||
17335 | } | ||
17336 | finally { | ||
17337 | |||
17338 | restoreStackSize(stackSize); | ||
17339 | |||
17340 | } | ||
17341 | return ; | ||
17342 | } | ||
17343 | // $ANTLR end "rule__ALSMinus__Group_1__0" | ||
17344 | |||
17345 | |||
17346 | // $ANTLR start "rule__ALSMinus__Group_1__0__Impl" | ||
17347 | // InternalAlloyLanguage.g:5996:1: rule__ALSMinus__Group_1__0__Impl : ( () ) ; | ||
17348 | public final void rule__ALSMinus__Group_1__0__Impl() throws RecognitionException { | ||
17349 | |||
17350 | int stackSize = keepStackSize(); | ||
17351 | |||
17352 | try { | ||
17353 | // InternalAlloyLanguage.g:6000:1: ( ( () ) ) | ||
17354 | // InternalAlloyLanguage.g:6001:1: ( () ) | ||
17355 | { | ||
17356 | // InternalAlloyLanguage.g:6001:1: ( () ) | ||
17357 | // InternalAlloyLanguage.g:6002:1: () | ||
17358 | { | ||
17359 | if ( state.backtracking==0 ) { | ||
17360 | before(grammarAccess.getALSMinusAccess().getALSMinusLeftOperandAction_1_0()); | ||
17361 | } | ||
17362 | // InternalAlloyLanguage.g:6003:1: () | ||
17363 | // InternalAlloyLanguage.g:6005:1: | ||
17364 | { | ||
17365 | } | ||
17366 | |||
17367 | if ( state.backtracking==0 ) { | ||
17368 | after(grammarAccess.getALSMinusAccess().getALSMinusLeftOperandAction_1_0()); | ||
17369 | } | ||
17370 | |||
17371 | } | ||
17372 | |||
17373 | |||
17374 | } | ||
17375 | |||
17376 | } | ||
17377 | finally { | ||
17378 | |||
17379 | restoreStackSize(stackSize); | ||
17380 | |||
17381 | } | ||
17382 | return ; | ||
17383 | } | ||
17384 | // $ANTLR end "rule__ALSMinus__Group_1__0__Impl" | ||
17385 | |||
17386 | |||
17387 | // $ANTLR start "rule__ALSMinus__Group_1__1" | ||
17388 | // InternalAlloyLanguage.g:6015:1: rule__ALSMinus__Group_1__1 : rule__ALSMinus__Group_1__1__Impl rule__ALSMinus__Group_1__2 ; | ||
17389 | public final void rule__ALSMinus__Group_1__1() throws RecognitionException { | ||
17390 | |||
17391 | int stackSize = keepStackSize(); | ||
17392 | |||
17393 | try { | ||
17394 | // InternalAlloyLanguage.g:6019:1: ( rule__ALSMinus__Group_1__1__Impl rule__ALSMinus__Group_1__2 ) | ||
17395 | // InternalAlloyLanguage.g:6020:2: rule__ALSMinus__Group_1__1__Impl rule__ALSMinus__Group_1__2 | ||
17396 | { | ||
17397 | pushFollow(FOLLOW_16); | ||
17398 | rule__ALSMinus__Group_1__1__Impl(); | ||
17399 | |||
17400 | state._fsp--; | ||
17401 | if (state.failed) return ; | ||
17402 | pushFollow(FOLLOW_2); | ||
17403 | rule__ALSMinus__Group_1__2(); | ||
17404 | |||
17405 | state._fsp--; | ||
17406 | if (state.failed) return ; | ||
17407 | |||
17408 | } | ||
17409 | |||
17410 | } | ||
17411 | catch (RecognitionException re) { | ||
17412 | reportError(re); | ||
17413 | recover(input,re); | ||
17414 | } | ||
17415 | finally { | ||
17416 | |||
17417 | restoreStackSize(stackSize); | ||
17418 | |||
17419 | } | ||
17420 | return ; | ||
17421 | } | ||
17422 | // $ANTLR end "rule__ALSMinus__Group_1__1" | ||
17423 | |||
17424 | |||
17425 | // $ANTLR start "rule__ALSMinus__Group_1__1__Impl" | ||
17426 | // InternalAlloyLanguage.g:6027:1: rule__ALSMinus__Group_1__1__Impl : ( '-' ) ; | ||
17427 | public final void rule__ALSMinus__Group_1__1__Impl() throws RecognitionException { | ||
17428 | |||
17429 | int stackSize = keepStackSize(); | ||
17430 | |||
17431 | try { | ||
17432 | // InternalAlloyLanguage.g:6031:1: ( ( '-' ) ) | ||
17433 | // InternalAlloyLanguage.g:6032:1: ( '-' ) | ||
17434 | { | ||
17435 | // InternalAlloyLanguage.g:6032:1: ( '-' ) | ||
17436 | // InternalAlloyLanguage.g:6033:1: '-' | ||
17437 | { | ||
17438 | if ( state.backtracking==0 ) { | ||
17439 | before(grammarAccess.getALSMinusAccess().getHyphenMinusKeyword_1_1()); | ||
17440 | } | ||
17441 | match(input,57,FOLLOW_2); if (state.failed) return ; | ||
17442 | if ( state.backtracking==0 ) { | ||
17443 | after(grammarAccess.getALSMinusAccess().getHyphenMinusKeyword_1_1()); | ||
17444 | } | ||
17445 | |||
17446 | } | ||
17447 | |||
17448 | |||
17449 | } | ||
17450 | |||
17451 | } | ||
17452 | catch (RecognitionException re) { | ||
17453 | reportError(re); | ||
17454 | recover(input,re); | ||
17455 | } | ||
17456 | finally { | ||
17457 | |||
17458 | restoreStackSize(stackSize); | ||
17459 | |||
17460 | } | ||
17461 | return ; | ||
17462 | } | ||
17463 | // $ANTLR end "rule__ALSMinus__Group_1__1__Impl" | ||
17464 | |||
17465 | |||
17466 | // $ANTLR start "rule__ALSMinus__Group_1__2" | ||
17467 | // InternalAlloyLanguage.g:6046:1: rule__ALSMinus__Group_1__2 : rule__ALSMinus__Group_1__2__Impl ; | ||
17468 | public final void rule__ALSMinus__Group_1__2() throws RecognitionException { | ||
17469 | |||
17470 | int stackSize = keepStackSize(); | ||
17471 | |||
17472 | try { | ||
17473 | // InternalAlloyLanguage.g:6050:1: ( rule__ALSMinus__Group_1__2__Impl ) | ||
17474 | // InternalAlloyLanguage.g:6051:2: rule__ALSMinus__Group_1__2__Impl | ||
17475 | { | ||
17476 | pushFollow(FOLLOW_2); | ||
17477 | rule__ALSMinus__Group_1__2__Impl(); | ||
17478 | |||
17479 | state._fsp--; | ||
17480 | if (state.failed) return ; | ||
17481 | |||
17482 | } | ||
17483 | |||
17484 | } | ||
17485 | catch (RecognitionException re) { | ||
17486 | reportError(re); | ||
17487 | recover(input,re); | ||
17488 | } | ||
17489 | finally { | ||
17490 | |||
17491 | restoreStackSize(stackSize); | ||
17492 | |||
17493 | } | ||
17494 | return ; | ||
17495 | } | ||
17496 | // $ANTLR end "rule__ALSMinus__Group_1__2" | ||
17497 | |||
17498 | |||
17499 | // $ANTLR start "rule__ALSMinus__Group_1__2__Impl" | ||
17500 | // InternalAlloyLanguage.g:6057:1: rule__ALSMinus__Group_1__2__Impl : ( ( rule__ALSMinus__RightOperandAssignment_1_2 ) ) ; | ||
17501 | public final void rule__ALSMinus__Group_1__2__Impl() throws RecognitionException { | ||
17502 | |||
17503 | int stackSize = keepStackSize(); | ||
17504 | |||
17505 | try { | ||
17506 | // InternalAlloyLanguage.g:6061:1: ( ( ( rule__ALSMinus__RightOperandAssignment_1_2 ) ) ) | ||
17507 | // InternalAlloyLanguage.g:6062:1: ( ( rule__ALSMinus__RightOperandAssignment_1_2 ) ) | ||
17508 | { | ||
17509 | // InternalAlloyLanguage.g:6062:1: ( ( rule__ALSMinus__RightOperandAssignment_1_2 ) ) | ||
17510 | // InternalAlloyLanguage.g:6063:1: ( rule__ALSMinus__RightOperandAssignment_1_2 ) | ||
17511 | { | ||
17512 | if ( state.backtracking==0 ) { | ||
17513 | before(grammarAccess.getALSMinusAccess().getRightOperandAssignment_1_2()); | ||
17514 | } | ||
17515 | // InternalAlloyLanguage.g:6064:1: ( rule__ALSMinus__RightOperandAssignment_1_2 ) | ||
17516 | // InternalAlloyLanguage.g:6064:2: rule__ALSMinus__RightOperandAssignment_1_2 | ||
17517 | { | ||
17518 | pushFollow(FOLLOW_2); | ||
17519 | rule__ALSMinus__RightOperandAssignment_1_2(); | ||
17520 | |||
17521 | state._fsp--; | ||
17522 | if (state.failed) return ; | ||
17523 | |||
17524 | } | ||
17525 | |||
17526 | if ( state.backtracking==0 ) { | ||
17527 | after(grammarAccess.getALSMinusAccess().getRightOperandAssignment_1_2()); | ||
17528 | } | ||
17529 | |||
17530 | } | ||
17531 | |||
17532 | |||
17533 | } | ||
17534 | |||
17535 | } | ||
17536 | catch (RecognitionException re) { | ||
17537 | reportError(re); | ||
17538 | recover(input,re); | ||
17539 | } | ||
17540 | finally { | ||
17541 | |||
17542 | restoreStackSize(stackSize); | ||
17543 | |||
17544 | } | ||
17545 | return ; | ||
17546 | } | ||
17547 | // $ANTLR end "rule__ALSMinus__Group_1__2__Impl" | ||
17548 | |||
17549 | |||
17550 | // $ANTLR start "rule__ALSPlus__Group__0" | ||
17551 | // InternalAlloyLanguage.g:6080:1: rule__ALSPlus__Group__0 : rule__ALSPlus__Group__0__Impl rule__ALSPlus__Group__1 ; | ||
17552 | public final void rule__ALSPlus__Group__0() throws RecognitionException { | ||
17553 | |||
17554 | int stackSize = keepStackSize(); | ||
17555 | |||
17556 | try { | ||
17557 | // InternalAlloyLanguage.g:6084:1: ( rule__ALSPlus__Group__0__Impl rule__ALSPlus__Group__1 ) | ||
17558 | // InternalAlloyLanguage.g:6085:2: rule__ALSPlus__Group__0__Impl rule__ALSPlus__Group__1 | ||
17559 | { | ||
17560 | pushFollow(FOLLOW_12); | ||
17561 | rule__ALSPlus__Group__0__Impl(); | ||
17562 | |||
17563 | state._fsp--; | ||
17564 | if (state.failed) return ; | ||
17565 | pushFollow(FOLLOW_2); | ||
17566 | rule__ALSPlus__Group__1(); | ||
17567 | |||
17568 | state._fsp--; | ||
17569 | if (state.failed) return ; | ||
17570 | |||
17571 | } | ||
17572 | |||
17573 | } | ||
17574 | catch (RecognitionException re) { | ||
17575 | reportError(re); | ||
17576 | recover(input,re); | ||
17577 | } | ||
17578 | finally { | ||
17579 | |||
17580 | restoreStackSize(stackSize); | ||
17581 | |||
17582 | } | ||
17583 | return ; | ||
17584 | } | ||
17585 | // $ANTLR end "rule__ALSPlus__Group__0" | ||
17586 | |||
17587 | |||
17588 | // $ANTLR start "rule__ALSPlus__Group__0__Impl" | ||
17589 | // InternalAlloyLanguage.g:6092:1: rule__ALSPlus__Group__0__Impl : ( ruleALSIntersection ) ; | ||
17590 | public final void rule__ALSPlus__Group__0__Impl() throws RecognitionException { | ||
17591 | |||
17592 | int stackSize = keepStackSize(); | ||
17593 | |||
17594 | try { | ||
17595 | // InternalAlloyLanguage.g:6096:1: ( ( ruleALSIntersection ) ) | ||
17596 | // InternalAlloyLanguage.g:6097:1: ( ruleALSIntersection ) | ||
17597 | { | ||
17598 | // InternalAlloyLanguage.g:6097:1: ( ruleALSIntersection ) | ||
17599 | // InternalAlloyLanguage.g:6098:1: ruleALSIntersection | ||
17600 | { | ||
17601 | if ( state.backtracking==0 ) { | ||
17602 | before(grammarAccess.getALSPlusAccess().getALSIntersectionParserRuleCall_0()); | ||
17603 | } | ||
17604 | pushFollow(FOLLOW_2); | ||
17605 | ruleALSIntersection(); | ||
17606 | |||
17607 | state._fsp--; | ||
17608 | if (state.failed) return ; | ||
17609 | if ( state.backtracking==0 ) { | ||
17610 | after(grammarAccess.getALSPlusAccess().getALSIntersectionParserRuleCall_0()); | ||
17611 | } | ||
17612 | |||
17613 | } | ||
17614 | |||
17615 | |||
17616 | } | ||
17617 | |||
17618 | } | ||
17619 | catch (RecognitionException re) { | ||
17620 | reportError(re); | ||
17621 | recover(input,re); | ||
17622 | } | ||
17623 | finally { | ||
17624 | |||
17625 | restoreStackSize(stackSize); | ||
17626 | |||
17627 | } | ||
17628 | return ; | ||
17629 | } | ||
17630 | // $ANTLR end "rule__ALSPlus__Group__0__Impl" | ||
17631 | |||
17632 | |||
17633 | // $ANTLR start "rule__ALSPlus__Group__1" | ||
17634 | // InternalAlloyLanguage.g:6109:1: rule__ALSPlus__Group__1 : rule__ALSPlus__Group__1__Impl ; | ||
17635 | public final void rule__ALSPlus__Group__1() throws RecognitionException { | ||
17636 | |||
17637 | int stackSize = keepStackSize(); | ||
17638 | |||
17639 | try { | ||
17640 | // InternalAlloyLanguage.g:6113:1: ( rule__ALSPlus__Group__1__Impl ) | ||
17641 | // InternalAlloyLanguage.g:6114:2: rule__ALSPlus__Group__1__Impl | ||
17642 | { | ||
17643 | pushFollow(FOLLOW_2); | ||
17644 | rule__ALSPlus__Group__1__Impl(); | ||
17645 | |||
17646 | state._fsp--; | ||
17647 | if (state.failed) return ; | ||
17648 | |||
17649 | } | ||
17650 | |||
17651 | } | ||
17652 | catch (RecognitionException re) { | ||
17653 | reportError(re); | ||
17654 | recover(input,re); | ||
17655 | } | ||
17656 | finally { | ||
17657 | |||
17658 | restoreStackSize(stackSize); | ||
17659 | |||
17660 | } | ||
17661 | return ; | ||
17662 | } | ||
17663 | // $ANTLR end "rule__ALSPlus__Group__1" | ||
17664 | |||
17665 | |||
17666 | // $ANTLR start "rule__ALSPlus__Group__1__Impl" | ||
17667 | // InternalAlloyLanguage.g:6120:1: rule__ALSPlus__Group__1__Impl : ( ( rule__ALSPlus__Group_1__0 )* ) ; | ||
17668 | public final void rule__ALSPlus__Group__1__Impl() throws RecognitionException { | ||
17669 | |||
17670 | int stackSize = keepStackSize(); | ||
17671 | |||
17672 | try { | ||
17673 | // InternalAlloyLanguage.g:6124:1: ( ( ( rule__ALSPlus__Group_1__0 )* ) ) | ||
17674 | // InternalAlloyLanguage.g:6125:1: ( ( rule__ALSPlus__Group_1__0 )* ) | ||
17675 | { | ||
17676 | // InternalAlloyLanguage.g:6125:1: ( ( rule__ALSPlus__Group_1__0 )* ) | ||
17677 | // InternalAlloyLanguage.g:6126:1: ( rule__ALSPlus__Group_1__0 )* | ||
17678 | { | ||
17679 | if ( state.backtracking==0 ) { | ||
17680 | before(grammarAccess.getALSPlusAccess().getGroup_1()); | ||
17681 | } | ||
17682 | // InternalAlloyLanguage.g:6127:1: ( rule__ALSPlus__Group_1__0 )* | ||
17683 | loop41: | ||
17684 | do { | ||
17685 | int alt41=2; | ||
17686 | int LA41_0 = input.LA(1); | ||
17687 | |||
17688 | if ( (LA41_0==39) ) { | ||
17689 | alt41=1; | ||
17690 | } | ||
17691 | |||
17692 | |||
17693 | switch (alt41) { | ||
17694 | case 1 : | ||
17695 | // InternalAlloyLanguage.g:6127:2: rule__ALSPlus__Group_1__0 | ||
17696 | { | ||
17697 | pushFollow(FOLLOW_13); | ||
17698 | rule__ALSPlus__Group_1__0(); | ||
17699 | |||
17700 | state._fsp--; | ||
17701 | if (state.failed) return ; | ||
17702 | |||
17703 | } | ||
17704 | break; | ||
17705 | |||
17706 | default : | ||
17707 | break loop41; | ||
17708 | } | ||
17709 | } while (true); | ||
17710 | |||
17711 | if ( state.backtracking==0 ) { | ||
17712 | after(grammarAccess.getALSPlusAccess().getGroup_1()); | ||
17713 | } | ||
17714 | |||
17715 | } | ||
17716 | |||
17717 | |||
17718 | } | ||
17719 | |||
17720 | } | ||
17721 | catch (RecognitionException re) { | ||
17722 | reportError(re); | ||
17723 | recover(input,re); | ||
17724 | } | ||
17725 | finally { | ||
17726 | |||
17727 | restoreStackSize(stackSize); | ||
17728 | |||
17729 | } | ||
17730 | return ; | ||
17731 | } | ||
17732 | // $ANTLR end "rule__ALSPlus__Group__1__Impl" | ||
17733 | |||
17734 | |||
17735 | // $ANTLR start "rule__ALSPlus__Group_1__0" | ||
17736 | // InternalAlloyLanguage.g:6141:1: rule__ALSPlus__Group_1__0 : rule__ALSPlus__Group_1__0__Impl rule__ALSPlus__Group_1__1 ; | ||
17737 | public final void rule__ALSPlus__Group_1__0() throws RecognitionException { | ||
17738 | |||
17739 | int stackSize = keepStackSize(); | ||
17740 | |||
17741 | try { | ||
17742 | // InternalAlloyLanguage.g:6145:1: ( rule__ALSPlus__Group_1__0__Impl rule__ALSPlus__Group_1__1 ) | ||
17743 | // InternalAlloyLanguage.g:6146:2: rule__ALSPlus__Group_1__0__Impl rule__ALSPlus__Group_1__1 | ||
17744 | { | ||
17745 | pushFollow(FOLLOW_12); | ||
17746 | rule__ALSPlus__Group_1__0__Impl(); | ||
17747 | |||
17748 | state._fsp--; | ||
17749 | if (state.failed) return ; | ||
17750 | pushFollow(FOLLOW_2); | ||
17751 | rule__ALSPlus__Group_1__1(); | ||
17752 | |||
17753 | state._fsp--; | ||
17754 | if (state.failed) return ; | ||
17755 | |||
17756 | } | ||
17757 | |||
17758 | } | ||
17759 | catch (RecognitionException re) { | ||
17760 | reportError(re); | ||
17761 | recover(input,re); | ||
17762 | } | ||
17763 | finally { | ||
17764 | |||
17765 | restoreStackSize(stackSize); | ||
17766 | |||
17767 | } | ||
17768 | return ; | ||
17769 | } | ||
17770 | // $ANTLR end "rule__ALSPlus__Group_1__0" | ||
17771 | |||
17772 | |||
17773 | // $ANTLR start "rule__ALSPlus__Group_1__0__Impl" | ||
17774 | // InternalAlloyLanguage.g:6153:1: rule__ALSPlus__Group_1__0__Impl : ( () ) ; | ||
17775 | public final void rule__ALSPlus__Group_1__0__Impl() throws RecognitionException { | ||
17776 | |||
17777 | int stackSize = keepStackSize(); | ||
17778 | |||
17779 | try { | ||
17780 | // InternalAlloyLanguage.g:6157:1: ( ( () ) ) | ||
17781 | // InternalAlloyLanguage.g:6158:1: ( () ) | ||
17782 | { | ||
17783 | // InternalAlloyLanguage.g:6158:1: ( () ) | ||
17784 | // InternalAlloyLanguage.g:6159:1: () | ||
17785 | { | ||
17786 | if ( state.backtracking==0 ) { | ||
17787 | before(grammarAccess.getALSPlusAccess().getALSPlusLeftOperandAction_1_0()); | ||
17788 | } | ||
17789 | // InternalAlloyLanguage.g:6160:1: () | ||
17790 | // InternalAlloyLanguage.g:6162:1: | ||
17791 | { | ||
17792 | } | ||
17793 | |||
17794 | if ( state.backtracking==0 ) { | ||
17795 | after(grammarAccess.getALSPlusAccess().getALSPlusLeftOperandAction_1_0()); | ||
17796 | } | ||
17797 | |||
17798 | } | ||
17799 | |||
17800 | |||
17801 | } | ||
17802 | |||
17803 | } | ||
17804 | finally { | ||
17805 | |||
17806 | restoreStackSize(stackSize); | ||
17807 | |||
17808 | } | ||
17809 | return ; | ||
17810 | } | ||
17811 | // $ANTLR end "rule__ALSPlus__Group_1__0__Impl" | ||
17812 | |||
17813 | |||
17814 | // $ANTLR start "rule__ALSPlus__Group_1__1" | ||
17815 | // InternalAlloyLanguage.g:6172:1: rule__ALSPlus__Group_1__1 : rule__ALSPlus__Group_1__1__Impl rule__ALSPlus__Group_1__2 ; | ||
17816 | public final void rule__ALSPlus__Group_1__1() throws RecognitionException { | ||
17817 | |||
17818 | int stackSize = keepStackSize(); | ||
17819 | |||
17820 | try { | ||
17821 | // InternalAlloyLanguage.g:6176:1: ( rule__ALSPlus__Group_1__1__Impl rule__ALSPlus__Group_1__2 ) | ||
17822 | // InternalAlloyLanguage.g:6177:2: rule__ALSPlus__Group_1__1__Impl rule__ALSPlus__Group_1__2 | ||
17823 | { | ||
17824 | pushFollow(FOLLOW_16); | ||
17825 | rule__ALSPlus__Group_1__1__Impl(); | ||
17826 | |||
17827 | state._fsp--; | ||
17828 | if (state.failed) return ; | ||
17829 | pushFollow(FOLLOW_2); | ||
17830 | rule__ALSPlus__Group_1__2(); | ||
17831 | |||
17832 | state._fsp--; | ||
17833 | if (state.failed) return ; | ||
17834 | |||
17835 | } | ||
17836 | |||
17837 | } | ||
17838 | catch (RecognitionException re) { | ||
17839 | reportError(re); | ||
17840 | recover(input,re); | ||
17841 | } | ||
17842 | finally { | ||
17843 | |||
17844 | restoreStackSize(stackSize); | ||
17845 | |||
17846 | } | ||
17847 | return ; | ||
17848 | } | ||
17849 | // $ANTLR end "rule__ALSPlus__Group_1__1" | ||
17850 | |||
17851 | |||
17852 | // $ANTLR start "rule__ALSPlus__Group_1__1__Impl" | ||
17853 | // InternalAlloyLanguage.g:6184:1: rule__ALSPlus__Group_1__1__Impl : ( '+' ) ; | ||
17854 | public final void rule__ALSPlus__Group_1__1__Impl() throws RecognitionException { | ||
17855 | |||
17856 | int stackSize = keepStackSize(); | ||
17857 | |||
17858 | try { | ||
17859 | // InternalAlloyLanguage.g:6188:1: ( ( '+' ) ) | ||
17860 | // InternalAlloyLanguage.g:6189:1: ( '+' ) | ||
17861 | { | ||
17862 | // InternalAlloyLanguage.g:6189:1: ( '+' ) | ||
17863 | // InternalAlloyLanguage.g:6190:1: '+' | ||
17864 | { | ||
17865 | if ( state.backtracking==0 ) { | ||
17866 | before(grammarAccess.getALSPlusAccess().getPlusSignKeyword_1_1()); | ||
17867 | } | ||
17868 | match(input,39,FOLLOW_2); if (state.failed) return ; | ||
17869 | if ( state.backtracking==0 ) { | ||
17870 | after(grammarAccess.getALSPlusAccess().getPlusSignKeyword_1_1()); | ||
17871 | } | ||
17872 | |||
17873 | } | ||
17874 | |||
17875 | |||
17876 | } | ||
17877 | |||
17878 | } | ||
17879 | catch (RecognitionException re) { | ||
17880 | reportError(re); | ||
17881 | recover(input,re); | ||
17882 | } | ||
17883 | finally { | ||
17884 | |||
17885 | restoreStackSize(stackSize); | ||
17886 | |||
17887 | } | ||
17888 | return ; | ||
17889 | } | ||
17890 | // $ANTLR end "rule__ALSPlus__Group_1__1__Impl" | ||
17891 | |||
17892 | |||
17893 | // $ANTLR start "rule__ALSPlus__Group_1__2" | ||
17894 | // InternalAlloyLanguage.g:6203:1: rule__ALSPlus__Group_1__2 : rule__ALSPlus__Group_1__2__Impl ; | ||
17895 | public final void rule__ALSPlus__Group_1__2() throws RecognitionException { | ||
17896 | |||
17897 | int stackSize = keepStackSize(); | ||
17898 | |||
17899 | try { | ||
17900 | // InternalAlloyLanguage.g:6207:1: ( rule__ALSPlus__Group_1__2__Impl ) | ||
17901 | // InternalAlloyLanguage.g:6208:2: rule__ALSPlus__Group_1__2__Impl | ||
17902 | { | ||
17903 | pushFollow(FOLLOW_2); | ||
17904 | rule__ALSPlus__Group_1__2__Impl(); | ||
17905 | |||
17906 | state._fsp--; | ||
17907 | if (state.failed) return ; | ||
17908 | |||
17909 | } | ||
17910 | |||
17911 | } | ||
17912 | catch (RecognitionException re) { | ||
17913 | reportError(re); | ||
17914 | recover(input,re); | ||
17915 | } | ||
17916 | finally { | ||
17917 | |||
17918 | restoreStackSize(stackSize); | ||
17919 | |||
17920 | } | ||
17921 | return ; | ||
17922 | } | ||
17923 | // $ANTLR end "rule__ALSPlus__Group_1__2" | ||
17924 | |||
17925 | |||
17926 | // $ANTLR start "rule__ALSPlus__Group_1__2__Impl" | ||
17927 | // InternalAlloyLanguage.g:6214:1: rule__ALSPlus__Group_1__2__Impl : ( ( rule__ALSPlus__RightOperandAssignment_1_2 ) ) ; | ||
17928 | public final void rule__ALSPlus__Group_1__2__Impl() throws RecognitionException { | ||
17929 | |||
17930 | int stackSize = keepStackSize(); | ||
17931 | |||
17932 | try { | ||
17933 | // InternalAlloyLanguage.g:6218:1: ( ( ( rule__ALSPlus__RightOperandAssignment_1_2 ) ) ) | ||
17934 | // InternalAlloyLanguage.g:6219:1: ( ( rule__ALSPlus__RightOperandAssignment_1_2 ) ) | ||
17935 | { | ||
17936 | // InternalAlloyLanguage.g:6219:1: ( ( rule__ALSPlus__RightOperandAssignment_1_2 ) ) | ||
17937 | // InternalAlloyLanguage.g:6220:1: ( rule__ALSPlus__RightOperandAssignment_1_2 ) | ||
17938 | { | ||
17939 | if ( state.backtracking==0 ) { | ||
17940 | before(grammarAccess.getALSPlusAccess().getRightOperandAssignment_1_2()); | ||
17941 | } | ||
17942 | // InternalAlloyLanguage.g:6221:1: ( rule__ALSPlus__RightOperandAssignment_1_2 ) | ||
17943 | // InternalAlloyLanguage.g:6221:2: rule__ALSPlus__RightOperandAssignment_1_2 | ||
17944 | { | ||
17945 | pushFollow(FOLLOW_2); | ||
17946 | rule__ALSPlus__RightOperandAssignment_1_2(); | ||
17947 | |||
17948 | state._fsp--; | ||
17949 | if (state.failed) return ; | ||
17950 | |||
17951 | } | ||
17952 | |||
17953 | if ( state.backtracking==0 ) { | ||
17954 | after(grammarAccess.getALSPlusAccess().getRightOperandAssignment_1_2()); | ||
17955 | } | ||
17956 | |||
17957 | } | ||
17958 | |||
17959 | |||
17960 | } | ||
17961 | |||
17962 | } | ||
17963 | catch (RecognitionException re) { | ||
17964 | reportError(re); | ||
17965 | recover(input,re); | ||
17966 | } | ||
17967 | finally { | ||
17968 | |||
17969 | restoreStackSize(stackSize); | ||
17970 | |||
17971 | } | ||
17972 | return ; | ||
17973 | } | ||
17974 | // $ANTLR end "rule__ALSPlus__Group_1__2__Impl" | ||
17975 | |||
17976 | |||
17977 | // $ANTLR start "rule__ALSIntersection__Group__0" | ||
17978 | // InternalAlloyLanguage.g:6237:1: rule__ALSIntersection__Group__0 : rule__ALSIntersection__Group__0__Impl rule__ALSIntersection__Group__1 ; | ||
17979 | public final void rule__ALSIntersection__Group__0() throws RecognitionException { | ||
17980 | |||
17981 | int stackSize = keepStackSize(); | ||
17982 | |||
17983 | try { | ||
17984 | // InternalAlloyLanguage.g:6241:1: ( rule__ALSIntersection__Group__0__Impl rule__ALSIntersection__Group__1 ) | ||
17985 | // InternalAlloyLanguage.g:6242:2: rule__ALSIntersection__Group__0__Impl rule__ALSIntersection__Group__1 | ||
17986 | { | ||
17987 | pushFollow(FOLLOW_44); | ||
17988 | rule__ALSIntersection__Group__0__Impl(); | ||
17989 | |||
17990 | state._fsp--; | ||
17991 | if (state.failed) return ; | ||
17992 | pushFollow(FOLLOW_2); | ||
17993 | rule__ALSIntersection__Group__1(); | ||
17994 | |||
17995 | state._fsp--; | ||
17996 | if (state.failed) return ; | ||
17997 | |||
17998 | } | ||
17999 | |||
18000 | } | ||
18001 | catch (RecognitionException re) { | ||
18002 | reportError(re); | ||
18003 | recover(input,re); | ||
18004 | } | ||
18005 | finally { | ||
18006 | |||
18007 | restoreStackSize(stackSize); | ||
18008 | |||
18009 | } | ||
18010 | return ; | ||
18011 | } | ||
18012 | // $ANTLR end "rule__ALSIntersection__Group__0" | ||
18013 | |||
18014 | |||
18015 | // $ANTLR start "rule__ALSIntersection__Group__0__Impl" | ||
18016 | // InternalAlloyLanguage.g:6249:1: rule__ALSIntersection__Group__0__Impl : ( ruleALSDirectProduct ) ; | ||
18017 | public final void rule__ALSIntersection__Group__0__Impl() throws RecognitionException { | ||
18018 | |||
18019 | int stackSize = keepStackSize(); | ||
18020 | |||
18021 | try { | ||
18022 | // InternalAlloyLanguage.g:6253:1: ( ( ruleALSDirectProduct ) ) | ||
18023 | // InternalAlloyLanguage.g:6254:1: ( ruleALSDirectProduct ) | ||
18024 | { | ||
18025 | // InternalAlloyLanguage.g:6254:1: ( ruleALSDirectProduct ) | ||
18026 | // InternalAlloyLanguage.g:6255:1: ruleALSDirectProduct | ||
18027 | { | ||
18028 | if ( state.backtracking==0 ) { | ||
18029 | before(grammarAccess.getALSIntersectionAccess().getALSDirectProductParserRuleCall_0()); | ||
18030 | } | ||
18031 | pushFollow(FOLLOW_2); | ||
18032 | ruleALSDirectProduct(); | ||
18033 | |||
18034 | state._fsp--; | ||
18035 | if (state.failed) return ; | ||
18036 | if ( state.backtracking==0 ) { | ||
18037 | after(grammarAccess.getALSIntersectionAccess().getALSDirectProductParserRuleCall_0()); | ||
18038 | } | ||
18039 | |||
18040 | } | ||
18041 | |||
18042 | |||
18043 | } | ||
18044 | |||
18045 | } | ||
18046 | catch (RecognitionException re) { | ||
18047 | reportError(re); | ||
18048 | recover(input,re); | ||
18049 | } | ||
18050 | finally { | ||
18051 | |||
18052 | restoreStackSize(stackSize); | ||
18053 | |||
18054 | } | ||
18055 | return ; | ||
18056 | } | ||
18057 | // $ANTLR end "rule__ALSIntersection__Group__0__Impl" | ||
18058 | |||
18059 | |||
18060 | // $ANTLR start "rule__ALSIntersection__Group__1" | ||
18061 | // InternalAlloyLanguage.g:6266:1: rule__ALSIntersection__Group__1 : rule__ALSIntersection__Group__1__Impl ; | ||
18062 | public final void rule__ALSIntersection__Group__1() throws RecognitionException { | ||
18063 | |||
18064 | int stackSize = keepStackSize(); | ||
18065 | |||
18066 | try { | ||
18067 | // InternalAlloyLanguage.g:6270:1: ( rule__ALSIntersection__Group__1__Impl ) | ||
18068 | // InternalAlloyLanguage.g:6271:2: rule__ALSIntersection__Group__1__Impl | ||
18069 | { | ||
18070 | pushFollow(FOLLOW_2); | ||
18071 | rule__ALSIntersection__Group__1__Impl(); | ||
18072 | |||
18073 | state._fsp--; | ||
18074 | if (state.failed) return ; | ||
18075 | |||
18076 | } | ||
18077 | |||
18078 | } | ||
18079 | catch (RecognitionException re) { | ||
18080 | reportError(re); | ||
18081 | recover(input,re); | ||
18082 | } | ||
18083 | finally { | ||
18084 | |||
18085 | restoreStackSize(stackSize); | ||
18086 | |||
18087 | } | ||
18088 | return ; | ||
18089 | } | ||
18090 | // $ANTLR end "rule__ALSIntersection__Group__1" | ||
18091 | |||
18092 | |||
18093 | // $ANTLR start "rule__ALSIntersection__Group__1__Impl" | ||
18094 | // InternalAlloyLanguage.g:6277:1: rule__ALSIntersection__Group__1__Impl : ( ( rule__ALSIntersection__Group_1__0 )* ) ; | ||
18095 | public final void rule__ALSIntersection__Group__1__Impl() throws RecognitionException { | ||
18096 | |||
18097 | int stackSize = keepStackSize(); | ||
18098 | |||
18099 | try { | ||
18100 | // InternalAlloyLanguage.g:6281:1: ( ( ( rule__ALSIntersection__Group_1__0 )* ) ) | ||
18101 | // InternalAlloyLanguage.g:6282:1: ( ( rule__ALSIntersection__Group_1__0 )* ) | ||
18102 | { | ||
18103 | // InternalAlloyLanguage.g:6282:1: ( ( rule__ALSIntersection__Group_1__0 )* ) | ||
18104 | // InternalAlloyLanguage.g:6283:1: ( rule__ALSIntersection__Group_1__0 )* | ||
18105 | { | ||
18106 | if ( state.backtracking==0 ) { | ||
18107 | before(grammarAccess.getALSIntersectionAccess().getGroup_1()); | ||
18108 | } | ||
18109 | // InternalAlloyLanguage.g:6284:1: ( rule__ALSIntersection__Group_1__0 )* | ||
18110 | loop42: | ||
18111 | do { | ||
18112 | int alt42=2; | ||
18113 | int LA42_0 = input.LA(1); | ||
18114 | |||
18115 | if ( (LA42_0==58) ) { | ||
18116 | alt42=1; | ||
18117 | } | ||
18118 | |||
18119 | |||
18120 | switch (alt42) { | ||
18121 | case 1 : | ||
18122 | // InternalAlloyLanguage.g:6284:2: rule__ALSIntersection__Group_1__0 | ||
18123 | { | ||
18124 | pushFollow(FOLLOW_45); | ||
18125 | rule__ALSIntersection__Group_1__0(); | ||
18126 | |||
18127 | state._fsp--; | ||
18128 | if (state.failed) return ; | ||
18129 | |||
18130 | } | ||
18131 | break; | ||
18132 | |||
18133 | default : | ||
18134 | break loop42; | ||
18135 | } | ||
18136 | } while (true); | ||
18137 | |||
18138 | if ( state.backtracking==0 ) { | ||
18139 | after(grammarAccess.getALSIntersectionAccess().getGroup_1()); | ||
18140 | } | ||
18141 | |||
18142 | } | ||
18143 | |||
18144 | |||
18145 | } | ||
18146 | |||
18147 | } | ||
18148 | catch (RecognitionException re) { | ||
18149 | reportError(re); | ||
18150 | recover(input,re); | ||
18151 | } | ||
18152 | finally { | ||
18153 | |||
18154 | restoreStackSize(stackSize); | ||
18155 | |||
18156 | } | ||
18157 | return ; | ||
18158 | } | ||
18159 | // $ANTLR end "rule__ALSIntersection__Group__1__Impl" | ||
18160 | |||
18161 | |||
18162 | // $ANTLR start "rule__ALSIntersection__Group_1__0" | ||
18163 | // InternalAlloyLanguage.g:6298:1: rule__ALSIntersection__Group_1__0 : rule__ALSIntersection__Group_1__0__Impl rule__ALSIntersection__Group_1__1 ; | ||
18164 | public final void rule__ALSIntersection__Group_1__0() throws RecognitionException { | ||
18165 | |||
18166 | int stackSize = keepStackSize(); | ||
18167 | |||
18168 | try { | ||
18169 | // InternalAlloyLanguage.g:6302:1: ( rule__ALSIntersection__Group_1__0__Impl rule__ALSIntersection__Group_1__1 ) | ||
18170 | // InternalAlloyLanguage.g:6303:2: rule__ALSIntersection__Group_1__0__Impl rule__ALSIntersection__Group_1__1 | ||
18171 | { | ||
18172 | pushFollow(FOLLOW_44); | ||
18173 | rule__ALSIntersection__Group_1__0__Impl(); | ||
18174 | |||
18175 | state._fsp--; | ||
18176 | if (state.failed) return ; | ||
18177 | pushFollow(FOLLOW_2); | ||
18178 | rule__ALSIntersection__Group_1__1(); | ||
18179 | |||
18180 | state._fsp--; | ||
18181 | if (state.failed) return ; | ||
18182 | |||
18183 | } | ||
18184 | |||
18185 | } | ||
18186 | catch (RecognitionException re) { | ||
18187 | reportError(re); | ||
18188 | recover(input,re); | ||
18189 | } | ||
18190 | finally { | ||
18191 | |||
18192 | restoreStackSize(stackSize); | ||
18193 | |||
18194 | } | ||
18195 | return ; | ||
18196 | } | ||
18197 | // $ANTLR end "rule__ALSIntersection__Group_1__0" | ||
18198 | |||
18199 | |||
18200 | // $ANTLR start "rule__ALSIntersection__Group_1__0__Impl" | ||
18201 | // InternalAlloyLanguage.g:6310:1: rule__ALSIntersection__Group_1__0__Impl : ( () ) ; | ||
18202 | public final void rule__ALSIntersection__Group_1__0__Impl() throws RecognitionException { | ||
18203 | |||
18204 | int stackSize = keepStackSize(); | ||
18205 | |||
18206 | try { | ||
18207 | // InternalAlloyLanguage.g:6314:1: ( ( () ) ) | ||
18208 | // InternalAlloyLanguage.g:6315:1: ( () ) | ||
18209 | { | ||
18210 | // InternalAlloyLanguage.g:6315:1: ( () ) | ||
18211 | // InternalAlloyLanguage.g:6316:1: () | ||
18212 | { | ||
18213 | if ( state.backtracking==0 ) { | ||
18214 | before(grammarAccess.getALSIntersectionAccess().getALSIntersectionLeftOperandAction_1_0()); | ||
18215 | } | ||
18216 | // InternalAlloyLanguage.g:6317:1: () | ||
18217 | // InternalAlloyLanguage.g:6319:1: | ||
18218 | { | ||
18219 | } | ||
18220 | |||
18221 | if ( state.backtracking==0 ) { | ||
18222 | after(grammarAccess.getALSIntersectionAccess().getALSIntersectionLeftOperandAction_1_0()); | ||
18223 | } | ||
18224 | |||
18225 | } | ||
18226 | |||
18227 | |||
18228 | } | ||
18229 | |||
18230 | } | ||
18231 | finally { | ||
18232 | |||
18233 | restoreStackSize(stackSize); | ||
18234 | |||
18235 | } | ||
18236 | return ; | ||
18237 | } | ||
18238 | // $ANTLR end "rule__ALSIntersection__Group_1__0__Impl" | ||
18239 | |||
18240 | |||
18241 | // $ANTLR start "rule__ALSIntersection__Group_1__1" | ||
18242 | // InternalAlloyLanguage.g:6329:1: rule__ALSIntersection__Group_1__1 : rule__ALSIntersection__Group_1__1__Impl rule__ALSIntersection__Group_1__2 ; | ||
18243 | public final void rule__ALSIntersection__Group_1__1() throws RecognitionException { | ||
18244 | |||
18245 | int stackSize = keepStackSize(); | ||
18246 | |||
18247 | try { | ||
18248 | // InternalAlloyLanguage.g:6333:1: ( rule__ALSIntersection__Group_1__1__Impl rule__ALSIntersection__Group_1__2 ) | ||
18249 | // InternalAlloyLanguage.g:6334:2: rule__ALSIntersection__Group_1__1__Impl rule__ALSIntersection__Group_1__2 | ||
18250 | { | ||
18251 | pushFollow(FOLLOW_16); | ||
18252 | rule__ALSIntersection__Group_1__1__Impl(); | ||
18253 | |||
18254 | state._fsp--; | ||
18255 | if (state.failed) return ; | ||
18256 | pushFollow(FOLLOW_2); | ||
18257 | rule__ALSIntersection__Group_1__2(); | ||
18258 | |||
18259 | state._fsp--; | ||
18260 | if (state.failed) return ; | ||
18261 | |||
18262 | } | ||
18263 | |||
18264 | } | ||
18265 | catch (RecognitionException re) { | ||
18266 | reportError(re); | ||
18267 | recover(input,re); | ||
18268 | } | ||
18269 | finally { | ||
18270 | |||
18271 | restoreStackSize(stackSize); | ||
18272 | |||
18273 | } | ||
18274 | return ; | ||
18275 | } | ||
18276 | // $ANTLR end "rule__ALSIntersection__Group_1__1" | ||
18277 | |||
18278 | |||
18279 | // $ANTLR start "rule__ALSIntersection__Group_1__1__Impl" | ||
18280 | // InternalAlloyLanguage.g:6341:1: rule__ALSIntersection__Group_1__1__Impl : ( '&' ) ; | ||
18281 | public final void rule__ALSIntersection__Group_1__1__Impl() throws RecognitionException { | ||
18282 | |||
18283 | int stackSize = keepStackSize(); | ||
18284 | |||
18285 | try { | ||
18286 | // InternalAlloyLanguage.g:6345:1: ( ( '&' ) ) | ||
18287 | // InternalAlloyLanguage.g:6346:1: ( '&' ) | ||
18288 | { | ||
18289 | // InternalAlloyLanguage.g:6346:1: ( '&' ) | ||
18290 | // InternalAlloyLanguage.g:6347:1: '&' | ||
18291 | { | ||
18292 | if ( state.backtracking==0 ) { | ||
18293 | before(grammarAccess.getALSIntersectionAccess().getAmpersandKeyword_1_1()); | ||
18294 | } | ||
18295 | match(input,58,FOLLOW_2); if (state.failed) return ; | ||
18296 | if ( state.backtracking==0 ) { | ||
18297 | after(grammarAccess.getALSIntersectionAccess().getAmpersandKeyword_1_1()); | ||
18298 | } | ||
18299 | |||
18300 | } | ||
18301 | |||
18302 | |||
18303 | } | ||
18304 | |||
18305 | } | ||
18306 | catch (RecognitionException re) { | ||
18307 | reportError(re); | ||
18308 | recover(input,re); | ||
18309 | } | ||
18310 | finally { | ||
18311 | |||
18312 | restoreStackSize(stackSize); | ||
18313 | |||
18314 | } | ||
18315 | return ; | ||
18316 | } | ||
18317 | // $ANTLR end "rule__ALSIntersection__Group_1__1__Impl" | ||
18318 | |||
18319 | |||
18320 | // $ANTLR start "rule__ALSIntersection__Group_1__2" | ||
18321 | // InternalAlloyLanguage.g:6360:1: rule__ALSIntersection__Group_1__2 : rule__ALSIntersection__Group_1__2__Impl ; | ||
18322 | public final void rule__ALSIntersection__Group_1__2() throws RecognitionException { | ||
18323 | |||
18324 | int stackSize = keepStackSize(); | ||
18325 | |||
18326 | try { | ||
18327 | // InternalAlloyLanguage.g:6364:1: ( rule__ALSIntersection__Group_1__2__Impl ) | ||
18328 | // InternalAlloyLanguage.g:6365:2: rule__ALSIntersection__Group_1__2__Impl | ||
18329 | { | ||
18330 | pushFollow(FOLLOW_2); | ||
18331 | rule__ALSIntersection__Group_1__2__Impl(); | ||
18332 | |||
18333 | state._fsp--; | ||
18334 | if (state.failed) return ; | ||
18335 | |||
18336 | } | ||
18337 | |||
18338 | } | ||
18339 | catch (RecognitionException re) { | ||
18340 | reportError(re); | ||
18341 | recover(input,re); | ||
18342 | } | ||
18343 | finally { | ||
18344 | |||
18345 | restoreStackSize(stackSize); | ||
18346 | |||
18347 | } | ||
18348 | return ; | ||
18349 | } | ||
18350 | // $ANTLR end "rule__ALSIntersection__Group_1__2" | ||
18351 | |||
18352 | |||
18353 | // $ANTLR start "rule__ALSIntersection__Group_1__2__Impl" | ||
18354 | // InternalAlloyLanguage.g:6371:1: rule__ALSIntersection__Group_1__2__Impl : ( ( rule__ALSIntersection__RightOperandAssignment_1_2 ) ) ; | ||
18355 | public final void rule__ALSIntersection__Group_1__2__Impl() throws RecognitionException { | ||
18356 | |||
18357 | int stackSize = keepStackSize(); | ||
18358 | |||
18359 | try { | ||
18360 | // InternalAlloyLanguage.g:6375:1: ( ( ( rule__ALSIntersection__RightOperandAssignment_1_2 ) ) ) | ||
18361 | // InternalAlloyLanguage.g:6376:1: ( ( rule__ALSIntersection__RightOperandAssignment_1_2 ) ) | ||
18362 | { | ||
18363 | // InternalAlloyLanguage.g:6376:1: ( ( rule__ALSIntersection__RightOperandAssignment_1_2 ) ) | ||
18364 | // InternalAlloyLanguage.g:6377:1: ( rule__ALSIntersection__RightOperandAssignment_1_2 ) | ||
18365 | { | ||
18366 | if ( state.backtracking==0 ) { | ||
18367 | before(grammarAccess.getALSIntersectionAccess().getRightOperandAssignment_1_2()); | ||
18368 | } | ||
18369 | // InternalAlloyLanguage.g:6378:1: ( rule__ALSIntersection__RightOperandAssignment_1_2 ) | ||
18370 | // InternalAlloyLanguage.g:6378:2: rule__ALSIntersection__RightOperandAssignment_1_2 | ||
18371 | { | ||
18372 | pushFollow(FOLLOW_2); | ||
18373 | rule__ALSIntersection__RightOperandAssignment_1_2(); | ||
18374 | |||
18375 | state._fsp--; | ||
18376 | if (state.failed) return ; | ||
18377 | |||
18378 | } | ||
18379 | |||
18380 | if ( state.backtracking==0 ) { | ||
18381 | after(grammarAccess.getALSIntersectionAccess().getRightOperandAssignment_1_2()); | ||
18382 | } | ||
18383 | |||
18384 | } | ||
18385 | |||
18386 | |||
18387 | } | ||
18388 | |||
18389 | } | ||
18390 | catch (RecognitionException re) { | ||
18391 | reportError(re); | ||
18392 | recover(input,re); | ||
18393 | } | ||
18394 | finally { | ||
18395 | |||
18396 | restoreStackSize(stackSize); | ||
18397 | |||
18398 | } | ||
18399 | return ; | ||
18400 | } | ||
18401 | // $ANTLR end "rule__ALSIntersection__Group_1__2__Impl" | ||
18402 | |||
18403 | |||
18404 | // $ANTLR start "rule__ALSDirectProduct__Group__0" | ||
18405 | // InternalAlloyLanguage.g:6394:1: rule__ALSDirectProduct__Group__0 : rule__ALSDirectProduct__Group__0__Impl rule__ALSDirectProduct__Group__1 ; | ||
18406 | public final void rule__ALSDirectProduct__Group__0() throws RecognitionException { | ||
18407 | |||
18408 | int stackSize = keepStackSize(); | ||
18409 | |||
18410 | try { | ||
18411 | // InternalAlloyLanguage.g:6398:1: ( rule__ALSDirectProduct__Group__0__Impl rule__ALSDirectProduct__Group__1 ) | ||
18412 | // InternalAlloyLanguage.g:6399:2: rule__ALSDirectProduct__Group__0__Impl rule__ALSDirectProduct__Group__1 | ||
18413 | { | ||
18414 | pushFollow(FOLLOW_46); | ||
18415 | rule__ALSDirectProduct__Group__0__Impl(); | ||
18416 | |||
18417 | state._fsp--; | ||
18418 | if (state.failed) return ; | ||
18419 | pushFollow(FOLLOW_2); | ||
18420 | rule__ALSDirectProduct__Group__1(); | ||
18421 | |||
18422 | state._fsp--; | ||
18423 | if (state.failed) return ; | ||
18424 | |||
18425 | } | ||
18426 | |||
18427 | } | ||
18428 | catch (RecognitionException re) { | ||
18429 | reportError(re); | ||
18430 | recover(input,re); | ||
18431 | } | ||
18432 | finally { | ||
18433 | |||
18434 | restoreStackSize(stackSize); | ||
18435 | |||
18436 | } | ||
18437 | return ; | ||
18438 | } | ||
18439 | // $ANTLR end "rule__ALSDirectProduct__Group__0" | ||
18440 | |||
18441 | |||
18442 | // $ANTLR start "rule__ALSDirectProduct__Group__0__Impl" | ||
18443 | // InternalAlloyLanguage.g:6406:1: rule__ALSDirectProduct__Group__0__Impl : ( ruleALSPreficed ) ; | ||
18444 | public final void rule__ALSDirectProduct__Group__0__Impl() throws RecognitionException { | ||
18445 | |||
18446 | int stackSize = keepStackSize(); | ||
18447 | |||
18448 | try { | ||
18449 | // InternalAlloyLanguage.g:6410:1: ( ( ruleALSPreficed ) ) | ||
18450 | // InternalAlloyLanguage.g:6411:1: ( ruleALSPreficed ) | ||
18451 | { | ||
18452 | // InternalAlloyLanguage.g:6411:1: ( ruleALSPreficed ) | ||
18453 | // InternalAlloyLanguage.g:6412:1: ruleALSPreficed | ||
18454 | { | ||
18455 | if ( state.backtracking==0 ) { | ||
18456 | before(grammarAccess.getALSDirectProductAccess().getALSPreficedParserRuleCall_0()); | ||
18457 | } | ||
18458 | pushFollow(FOLLOW_2); | ||
18459 | ruleALSPreficed(); | ||
18460 | |||
18461 | state._fsp--; | ||
18462 | if (state.failed) return ; | ||
18463 | if ( state.backtracking==0 ) { | ||
18464 | after(grammarAccess.getALSDirectProductAccess().getALSPreficedParserRuleCall_0()); | ||
18465 | } | ||
18466 | |||
18467 | } | ||
18468 | |||
18469 | |||
18470 | } | ||
18471 | |||
18472 | } | ||
18473 | catch (RecognitionException re) { | ||
18474 | reportError(re); | ||
18475 | recover(input,re); | ||
18476 | } | ||
18477 | finally { | ||
18478 | |||
18479 | restoreStackSize(stackSize); | ||
18480 | |||
18481 | } | ||
18482 | return ; | ||
18483 | } | ||
18484 | // $ANTLR end "rule__ALSDirectProduct__Group__0__Impl" | ||
18485 | |||
18486 | |||
18487 | // $ANTLR start "rule__ALSDirectProduct__Group__1" | ||
18488 | // InternalAlloyLanguage.g:6423:1: rule__ALSDirectProduct__Group__1 : rule__ALSDirectProduct__Group__1__Impl ; | ||
18489 | public final void rule__ALSDirectProduct__Group__1() throws RecognitionException { | ||
18490 | |||
18491 | int stackSize = keepStackSize(); | ||
18492 | |||
18493 | try { | ||
18494 | // InternalAlloyLanguage.g:6427:1: ( rule__ALSDirectProduct__Group__1__Impl ) | ||
18495 | // InternalAlloyLanguage.g:6428:2: rule__ALSDirectProduct__Group__1__Impl | ||
18496 | { | ||
18497 | pushFollow(FOLLOW_2); | ||
18498 | rule__ALSDirectProduct__Group__1__Impl(); | ||
18499 | |||
18500 | state._fsp--; | ||
18501 | if (state.failed) return ; | ||
18502 | |||
18503 | } | ||
18504 | |||
18505 | } | ||
18506 | catch (RecognitionException re) { | ||
18507 | reportError(re); | ||
18508 | recover(input,re); | ||
18509 | } | ||
18510 | finally { | ||
18511 | |||
18512 | restoreStackSize(stackSize); | ||
18513 | |||
18514 | } | ||
18515 | return ; | ||
18516 | } | ||
18517 | // $ANTLR end "rule__ALSDirectProduct__Group__1" | ||
18518 | |||
18519 | |||
18520 | // $ANTLR start "rule__ALSDirectProduct__Group__1__Impl" | ||
18521 | // InternalAlloyLanguage.g:6434:1: rule__ALSDirectProduct__Group__1__Impl : ( ( rule__ALSDirectProduct__Group_1__0 )? ) ; | ||
18522 | public final void rule__ALSDirectProduct__Group__1__Impl() throws RecognitionException { | ||
18523 | |||
18524 | int stackSize = keepStackSize(); | ||
18525 | |||
18526 | try { | ||
18527 | // InternalAlloyLanguage.g:6438:1: ( ( ( rule__ALSDirectProduct__Group_1__0 )? ) ) | ||
18528 | // InternalAlloyLanguage.g:6439:1: ( ( rule__ALSDirectProduct__Group_1__0 )? ) | ||
18529 | { | ||
18530 | // InternalAlloyLanguage.g:6439:1: ( ( rule__ALSDirectProduct__Group_1__0 )? ) | ||
18531 | // InternalAlloyLanguage.g:6440:1: ( rule__ALSDirectProduct__Group_1__0 )? | ||
18532 | { | ||
18533 | if ( state.backtracking==0 ) { | ||
18534 | before(grammarAccess.getALSDirectProductAccess().getGroup_1()); | ||
18535 | } | ||
18536 | // InternalAlloyLanguage.g:6441:1: ( rule__ALSDirectProduct__Group_1__0 )? | ||
18537 | int alt43=2; | ||
18538 | int LA43_0 = input.LA(1); | ||
18539 | |||
18540 | if ( ((LA43_0>=21 && LA43_0<=26)||LA43_0==59) ) { | ||
18541 | alt43=1; | ||
18542 | } | ||
18543 | switch (alt43) { | ||
18544 | case 1 : | ||
18545 | // InternalAlloyLanguage.g:6441:2: rule__ALSDirectProduct__Group_1__0 | ||
18546 | { | ||
18547 | pushFollow(FOLLOW_2); | ||
18548 | rule__ALSDirectProduct__Group_1__0(); | ||
18549 | |||
18550 | state._fsp--; | ||
18551 | if (state.failed) return ; | ||
18552 | |||
18553 | } | ||
18554 | break; | ||
18555 | |||
18556 | } | ||
18557 | |||
18558 | if ( state.backtracking==0 ) { | ||
18559 | after(grammarAccess.getALSDirectProductAccess().getGroup_1()); | ||
18560 | } | ||
18561 | |||
18562 | } | ||
18563 | |||
18564 | |||
18565 | } | ||
18566 | |||
18567 | } | ||
18568 | catch (RecognitionException re) { | ||
18569 | reportError(re); | ||
18570 | recover(input,re); | ||
18571 | } | ||
18572 | finally { | ||
18573 | |||
18574 | restoreStackSize(stackSize); | ||
18575 | |||
18576 | } | ||
18577 | return ; | ||
18578 | } | ||
18579 | // $ANTLR end "rule__ALSDirectProduct__Group__1__Impl" | ||
18580 | |||
18581 | |||
18582 | // $ANTLR start "rule__ALSDirectProduct__Group_1__0" | ||
18583 | // InternalAlloyLanguage.g:6455:1: rule__ALSDirectProduct__Group_1__0 : rule__ALSDirectProduct__Group_1__0__Impl rule__ALSDirectProduct__Group_1__1 ; | ||
18584 | public final void rule__ALSDirectProduct__Group_1__0() throws RecognitionException { | ||
18585 | |||
18586 | int stackSize = keepStackSize(); | ||
18587 | |||
18588 | try { | ||
18589 | // InternalAlloyLanguage.g:6459:1: ( rule__ALSDirectProduct__Group_1__0__Impl rule__ALSDirectProduct__Group_1__1 ) | ||
18590 | // InternalAlloyLanguage.g:6460:2: rule__ALSDirectProduct__Group_1__0__Impl rule__ALSDirectProduct__Group_1__1 | ||
18591 | { | ||
18592 | pushFollow(FOLLOW_46); | ||
18593 | rule__ALSDirectProduct__Group_1__0__Impl(); | ||
18594 | |||
18595 | state._fsp--; | ||
18596 | if (state.failed) return ; | ||
18597 | pushFollow(FOLLOW_2); | ||
18598 | rule__ALSDirectProduct__Group_1__1(); | ||
18599 | |||
18600 | state._fsp--; | ||
18601 | if (state.failed) return ; | ||
18602 | |||
18603 | } | ||
18604 | |||
18605 | } | ||
18606 | catch (RecognitionException re) { | ||
18607 | reportError(re); | ||
18608 | recover(input,re); | ||
18609 | } | ||
18610 | finally { | ||
18611 | |||
18612 | restoreStackSize(stackSize); | ||
18613 | |||
18614 | } | ||
18615 | return ; | ||
18616 | } | ||
18617 | // $ANTLR end "rule__ALSDirectProduct__Group_1__0" | ||
18618 | |||
18619 | |||
18620 | // $ANTLR start "rule__ALSDirectProduct__Group_1__0__Impl" | ||
18621 | // InternalAlloyLanguage.g:6467:1: rule__ALSDirectProduct__Group_1__0__Impl : ( () ) ; | ||
18622 | public final void rule__ALSDirectProduct__Group_1__0__Impl() throws RecognitionException { | ||
18623 | |||
18624 | int stackSize = keepStackSize(); | ||
18625 | |||
18626 | try { | ||
18627 | // InternalAlloyLanguage.g:6471:1: ( ( () ) ) | ||
18628 | // InternalAlloyLanguage.g:6472:1: ( () ) | ||
18629 | { | ||
18630 | // InternalAlloyLanguage.g:6472:1: ( () ) | ||
18631 | // InternalAlloyLanguage.g:6473:1: () | ||
18632 | { | ||
18633 | if ( state.backtracking==0 ) { | ||
18634 | before(grammarAccess.getALSDirectProductAccess().getALSDirectProductLeftOperandAction_1_0()); | ||
18635 | } | ||
18636 | // InternalAlloyLanguage.g:6474:1: () | ||
18637 | // InternalAlloyLanguage.g:6476:1: | ||
18638 | { | ||
18639 | } | ||
18640 | |||
18641 | if ( state.backtracking==0 ) { | ||
18642 | after(grammarAccess.getALSDirectProductAccess().getALSDirectProductLeftOperandAction_1_0()); | ||
18643 | } | ||
18644 | |||
18645 | } | ||
18646 | |||
18647 | |||
18648 | } | ||
18649 | |||
18650 | } | ||
18651 | finally { | ||
18652 | |||
18653 | restoreStackSize(stackSize); | ||
18654 | |||
18655 | } | ||
18656 | return ; | ||
18657 | } | ||
18658 | // $ANTLR end "rule__ALSDirectProduct__Group_1__0__Impl" | ||
18659 | |||
18660 | |||
18661 | // $ANTLR start "rule__ALSDirectProduct__Group_1__1" | ||
18662 | // InternalAlloyLanguage.g:6486:1: rule__ALSDirectProduct__Group_1__1 : rule__ALSDirectProduct__Group_1__1__Impl rule__ALSDirectProduct__Group_1__2 ; | ||
18663 | public final void rule__ALSDirectProduct__Group_1__1() throws RecognitionException { | ||
18664 | |||
18665 | int stackSize = keepStackSize(); | ||
18666 | |||
18667 | try { | ||
18668 | // InternalAlloyLanguage.g:6490:1: ( rule__ALSDirectProduct__Group_1__1__Impl rule__ALSDirectProduct__Group_1__2 ) | ||
18669 | // InternalAlloyLanguage.g:6491:2: rule__ALSDirectProduct__Group_1__1__Impl rule__ALSDirectProduct__Group_1__2 | ||
18670 | { | ||
18671 | pushFollow(FOLLOW_46); | ||
18672 | rule__ALSDirectProduct__Group_1__1__Impl(); | ||
18673 | |||
18674 | state._fsp--; | ||
18675 | if (state.failed) return ; | ||
18676 | pushFollow(FOLLOW_2); | ||
18677 | rule__ALSDirectProduct__Group_1__2(); | ||
18678 | |||
18679 | state._fsp--; | ||
18680 | if (state.failed) return ; | ||
18681 | |||
18682 | } | ||
18683 | |||
18684 | } | ||
18685 | catch (RecognitionException re) { | ||
18686 | reportError(re); | ||
18687 | recover(input,re); | ||
18688 | } | ||
18689 | finally { | ||
18690 | |||
18691 | restoreStackSize(stackSize); | ||
18692 | |||
18693 | } | ||
18694 | return ; | ||
18695 | } | ||
18696 | // $ANTLR end "rule__ALSDirectProduct__Group_1__1" | ||
18697 | |||
18698 | |||
18699 | // $ANTLR start "rule__ALSDirectProduct__Group_1__1__Impl" | ||
18700 | // InternalAlloyLanguage.g:6498:1: rule__ALSDirectProduct__Group_1__1__Impl : ( ( rule__ALSDirectProduct__LeftMultiplicitAssignment_1_1 )? ) ; | ||
18701 | public final void rule__ALSDirectProduct__Group_1__1__Impl() throws RecognitionException { | ||
18702 | |||
18703 | int stackSize = keepStackSize(); | ||
18704 | |||
18705 | try { | ||
18706 | // InternalAlloyLanguage.g:6502:1: ( ( ( rule__ALSDirectProduct__LeftMultiplicitAssignment_1_1 )? ) ) | ||
18707 | // InternalAlloyLanguage.g:6503:1: ( ( rule__ALSDirectProduct__LeftMultiplicitAssignment_1_1 )? ) | ||
18708 | { | ||
18709 | // InternalAlloyLanguage.g:6503:1: ( ( rule__ALSDirectProduct__LeftMultiplicitAssignment_1_1 )? ) | ||
18710 | // InternalAlloyLanguage.g:6504:1: ( rule__ALSDirectProduct__LeftMultiplicitAssignment_1_1 )? | ||
18711 | { | ||
18712 | if ( state.backtracking==0 ) { | ||
18713 | before(grammarAccess.getALSDirectProductAccess().getLeftMultiplicitAssignment_1_1()); | ||
18714 | } | ||
18715 | // InternalAlloyLanguage.g:6505:1: ( rule__ALSDirectProduct__LeftMultiplicitAssignment_1_1 )? | ||
18716 | int alt44=2; | ||
18717 | int LA44_0 = input.LA(1); | ||
18718 | |||
18719 | if ( ((LA44_0>=21 && LA44_0<=26)) ) { | ||
18720 | alt44=1; | ||
18721 | } | ||
18722 | switch (alt44) { | ||
18723 | case 1 : | ||
18724 | // InternalAlloyLanguage.g:6505:2: rule__ALSDirectProduct__LeftMultiplicitAssignment_1_1 | ||
18725 | { | ||
18726 | pushFollow(FOLLOW_2); | ||
18727 | rule__ALSDirectProduct__LeftMultiplicitAssignment_1_1(); | ||
18728 | |||
18729 | state._fsp--; | ||
18730 | if (state.failed) return ; | ||
18731 | |||
18732 | } | ||
18733 | break; | ||
18734 | |||
18735 | } | ||
18736 | |||
18737 | if ( state.backtracking==0 ) { | ||
18738 | after(grammarAccess.getALSDirectProductAccess().getLeftMultiplicitAssignment_1_1()); | ||
18739 | } | ||
18740 | |||
18741 | } | ||
18742 | |||
18743 | |||
18744 | } | ||
18745 | |||
18746 | } | ||
18747 | catch (RecognitionException re) { | ||
18748 | reportError(re); | ||
18749 | recover(input,re); | ||
18750 | } | ||
18751 | finally { | ||
18752 | |||
18753 | restoreStackSize(stackSize); | ||
18754 | |||
18755 | } | ||
18756 | return ; | ||
18757 | } | ||
18758 | // $ANTLR end "rule__ALSDirectProduct__Group_1__1__Impl" | ||
18759 | |||
18760 | |||
18761 | // $ANTLR start "rule__ALSDirectProduct__Group_1__2" | ||
18762 | // InternalAlloyLanguage.g:6515:1: rule__ALSDirectProduct__Group_1__2 : rule__ALSDirectProduct__Group_1__2__Impl rule__ALSDirectProduct__Group_1__3 ; | ||
18763 | public final void rule__ALSDirectProduct__Group_1__2() throws RecognitionException { | ||
18764 | |||
18765 | int stackSize = keepStackSize(); | ||
18766 | |||
18767 | try { | ||
18768 | // InternalAlloyLanguage.g:6519:1: ( rule__ALSDirectProduct__Group_1__2__Impl rule__ALSDirectProduct__Group_1__3 ) | ||
18769 | // InternalAlloyLanguage.g:6520:2: rule__ALSDirectProduct__Group_1__2__Impl rule__ALSDirectProduct__Group_1__3 | ||
18770 | { | ||
18771 | pushFollow(FOLLOW_16); | ||
18772 | rule__ALSDirectProduct__Group_1__2__Impl(); | ||
18773 | |||
18774 | state._fsp--; | ||
18775 | if (state.failed) return ; | ||
18776 | pushFollow(FOLLOW_2); | ||
18777 | rule__ALSDirectProduct__Group_1__3(); | ||
18778 | |||
18779 | state._fsp--; | ||
18780 | if (state.failed) return ; | ||
18781 | |||
18782 | } | ||
18783 | |||
18784 | } | ||
18785 | catch (RecognitionException re) { | ||
18786 | reportError(re); | ||
18787 | recover(input,re); | ||
18788 | } | ||
18789 | finally { | ||
18790 | |||
18791 | restoreStackSize(stackSize); | ||
18792 | |||
18793 | } | ||
18794 | return ; | ||
18795 | } | ||
18796 | // $ANTLR end "rule__ALSDirectProduct__Group_1__2" | ||
18797 | |||
18798 | |||
18799 | // $ANTLR start "rule__ALSDirectProduct__Group_1__2__Impl" | ||
18800 | // InternalAlloyLanguage.g:6527:1: rule__ALSDirectProduct__Group_1__2__Impl : ( '->' ) ; | ||
18801 | public final void rule__ALSDirectProduct__Group_1__2__Impl() throws RecognitionException { | ||
18802 | |||
18803 | int stackSize = keepStackSize(); | ||
18804 | |||
18805 | try { | ||
18806 | // InternalAlloyLanguage.g:6531:1: ( ( '->' ) ) | ||
18807 | // InternalAlloyLanguage.g:6532:1: ( '->' ) | ||
18808 | { | ||
18809 | // InternalAlloyLanguage.g:6532:1: ( '->' ) | ||
18810 | // InternalAlloyLanguage.g:6533:1: '->' | ||
18811 | { | ||
18812 | if ( state.backtracking==0 ) { | ||
18813 | before(grammarAccess.getALSDirectProductAccess().getHyphenMinusGreaterThanSignKeyword_1_2()); | ||
18814 | } | ||
18815 | match(input,59,FOLLOW_2); if (state.failed) return ; | ||
18816 | if ( state.backtracking==0 ) { | ||
18817 | after(grammarAccess.getALSDirectProductAccess().getHyphenMinusGreaterThanSignKeyword_1_2()); | ||
18818 | } | ||
18819 | |||
18820 | } | ||
18821 | |||
18822 | |||
18823 | } | ||
18824 | |||
18825 | } | ||
18826 | catch (RecognitionException re) { | ||
18827 | reportError(re); | ||
18828 | recover(input,re); | ||
18829 | } | ||
18830 | finally { | ||
18831 | |||
18832 | restoreStackSize(stackSize); | ||
18833 | |||
18834 | } | ||
18835 | return ; | ||
18836 | } | ||
18837 | // $ANTLR end "rule__ALSDirectProduct__Group_1__2__Impl" | ||
18838 | |||
18839 | |||
18840 | // $ANTLR start "rule__ALSDirectProduct__Group_1__3" | ||
18841 | // InternalAlloyLanguage.g:6546:1: rule__ALSDirectProduct__Group_1__3 : rule__ALSDirectProduct__Group_1__3__Impl rule__ALSDirectProduct__Group_1__4 ; | ||
18842 | public final void rule__ALSDirectProduct__Group_1__3() throws RecognitionException { | ||
18843 | |||
18844 | int stackSize = keepStackSize(); | ||
18845 | |||
18846 | try { | ||
18847 | // InternalAlloyLanguage.g:6550:1: ( rule__ALSDirectProduct__Group_1__3__Impl rule__ALSDirectProduct__Group_1__4 ) | ||
18848 | // InternalAlloyLanguage.g:6551:2: rule__ALSDirectProduct__Group_1__3__Impl rule__ALSDirectProduct__Group_1__4 | ||
18849 | { | ||
18850 | pushFollow(FOLLOW_16); | ||
18851 | rule__ALSDirectProduct__Group_1__3__Impl(); | ||
18852 | |||
18853 | state._fsp--; | ||
18854 | if (state.failed) return ; | ||
18855 | pushFollow(FOLLOW_2); | ||
18856 | rule__ALSDirectProduct__Group_1__4(); | ||
18857 | |||
18858 | state._fsp--; | ||
18859 | if (state.failed) return ; | ||
18860 | |||
18861 | } | ||
18862 | |||
18863 | } | ||
18864 | catch (RecognitionException re) { | ||
18865 | reportError(re); | ||
18866 | recover(input,re); | ||
18867 | } | ||
18868 | finally { | ||
18869 | |||
18870 | restoreStackSize(stackSize); | ||
18871 | |||
18872 | } | ||
18873 | return ; | ||
18874 | } | ||
18875 | // $ANTLR end "rule__ALSDirectProduct__Group_1__3" | ||
18876 | |||
18877 | |||
18878 | // $ANTLR start "rule__ALSDirectProduct__Group_1__3__Impl" | ||
18879 | // InternalAlloyLanguage.g:6558:1: rule__ALSDirectProduct__Group_1__3__Impl : ( ( rule__ALSDirectProduct__RightMultiplicitAssignment_1_3 )? ) ; | ||
18880 | public final void rule__ALSDirectProduct__Group_1__3__Impl() throws RecognitionException { | ||
18881 | |||
18882 | int stackSize = keepStackSize(); | ||
18883 | |||
18884 | try { | ||
18885 | // InternalAlloyLanguage.g:6562:1: ( ( ( rule__ALSDirectProduct__RightMultiplicitAssignment_1_3 )? ) ) | ||
18886 | // InternalAlloyLanguage.g:6563:1: ( ( rule__ALSDirectProduct__RightMultiplicitAssignment_1_3 )? ) | ||
18887 | { | ||
18888 | // InternalAlloyLanguage.g:6563:1: ( ( rule__ALSDirectProduct__RightMultiplicitAssignment_1_3 )? ) | ||
18889 | // InternalAlloyLanguage.g:6564:1: ( rule__ALSDirectProduct__RightMultiplicitAssignment_1_3 )? | ||
18890 | { | ||
18891 | if ( state.backtracking==0 ) { | ||
18892 | before(grammarAccess.getALSDirectProductAccess().getRightMultiplicitAssignment_1_3()); | ||
18893 | } | ||
18894 | // InternalAlloyLanguage.g:6565:1: ( rule__ALSDirectProduct__RightMultiplicitAssignment_1_3 )? | ||
18895 | int alt45=2; | ||
18896 | int LA45_0 = input.LA(1); | ||
18897 | |||
18898 | if ( ((LA45_0>=21 && LA45_0<=26)) ) { | ||
18899 | alt45=1; | ||
18900 | } | ||
18901 | switch (alt45) { | ||
18902 | case 1 : | ||
18903 | // InternalAlloyLanguage.g:6565:2: rule__ALSDirectProduct__RightMultiplicitAssignment_1_3 | ||
18904 | { | ||
18905 | pushFollow(FOLLOW_2); | ||
18906 | rule__ALSDirectProduct__RightMultiplicitAssignment_1_3(); | ||
18907 | |||
18908 | state._fsp--; | ||
18909 | if (state.failed) return ; | ||
18910 | |||
18911 | } | ||
18912 | break; | ||
18913 | |||
18914 | } | ||
18915 | |||
18916 | if ( state.backtracking==0 ) { | ||
18917 | after(grammarAccess.getALSDirectProductAccess().getRightMultiplicitAssignment_1_3()); | ||
18918 | } | ||
18919 | |||
18920 | } | ||
18921 | |||
18922 | |||
18923 | } | ||
18924 | |||
18925 | } | ||
18926 | catch (RecognitionException re) { | ||
18927 | reportError(re); | ||
18928 | recover(input,re); | ||
18929 | } | ||
18930 | finally { | ||
18931 | |||
18932 | restoreStackSize(stackSize); | ||
18933 | |||
18934 | } | ||
18935 | return ; | ||
18936 | } | ||
18937 | // $ANTLR end "rule__ALSDirectProduct__Group_1__3__Impl" | ||
18938 | |||
18939 | |||
18940 | // $ANTLR start "rule__ALSDirectProduct__Group_1__4" | ||
18941 | // InternalAlloyLanguage.g:6575:1: rule__ALSDirectProduct__Group_1__4 : rule__ALSDirectProduct__Group_1__4__Impl ; | ||
18942 | public final void rule__ALSDirectProduct__Group_1__4() throws RecognitionException { | ||
18943 | |||
18944 | int stackSize = keepStackSize(); | ||
18945 | |||
18946 | try { | ||
18947 | // InternalAlloyLanguage.g:6579:1: ( rule__ALSDirectProduct__Group_1__4__Impl ) | ||
18948 | // InternalAlloyLanguage.g:6580:2: rule__ALSDirectProduct__Group_1__4__Impl | ||
18949 | { | ||
18950 | pushFollow(FOLLOW_2); | ||
18951 | rule__ALSDirectProduct__Group_1__4__Impl(); | ||
18952 | |||
18953 | state._fsp--; | ||
18954 | if (state.failed) return ; | ||
18955 | |||
18956 | } | ||
18957 | |||
18958 | } | ||
18959 | catch (RecognitionException re) { | ||
18960 | reportError(re); | ||
18961 | recover(input,re); | ||
18962 | } | ||
18963 | finally { | ||
18964 | |||
18965 | restoreStackSize(stackSize); | ||
18966 | |||
18967 | } | ||
18968 | return ; | ||
18969 | } | ||
18970 | // $ANTLR end "rule__ALSDirectProduct__Group_1__4" | ||
18971 | |||
18972 | |||
18973 | // $ANTLR start "rule__ALSDirectProduct__Group_1__4__Impl" | ||
18974 | // InternalAlloyLanguage.g:6586:1: rule__ALSDirectProduct__Group_1__4__Impl : ( ( rule__ALSDirectProduct__RightOperandAssignment_1_4 ) ) ; | ||
18975 | public final void rule__ALSDirectProduct__Group_1__4__Impl() throws RecognitionException { | ||
18976 | |||
18977 | int stackSize = keepStackSize(); | ||
18978 | |||
18979 | try { | ||
18980 | // InternalAlloyLanguage.g:6590:1: ( ( ( rule__ALSDirectProduct__RightOperandAssignment_1_4 ) ) ) | ||
18981 | // InternalAlloyLanguage.g:6591:1: ( ( rule__ALSDirectProduct__RightOperandAssignment_1_4 ) ) | ||
18982 | { | ||
18983 | // InternalAlloyLanguage.g:6591:1: ( ( rule__ALSDirectProduct__RightOperandAssignment_1_4 ) ) | ||
18984 | // InternalAlloyLanguage.g:6592:1: ( rule__ALSDirectProduct__RightOperandAssignment_1_4 ) | ||
18985 | { | ||
18986 | if ( state.backtracking==0 ) { | ||
18987 | before(grammarAccess.getALSDirectProductAccess().getRightOperandAssignment_1_4()); | ||
18988 | } | ||
18989 | // InternalAlloyLanguage.g:6593:1: ( rule__ALSDirectProduct__RightOperandAssignment_1_4 ) | ||
18990 | // InternalAlloyLanguage.g:6593:2: rule__ALSDirectProduct__RightOperandAssignment_1_4 | ||
18991 | { | ||
18992 | pushFollow(FOLLOW_2); | ||
18993 | rule__ALSDirectProduct__RightOperandAssignment_1_4(); | ||
18994 | |||
18995 | state._fsp--; | ||
18996 | if (state.failed) return ; | ||
18997 | |||
18998 | } | ||
18999 | |||
19000 | if ( state.backtracking==0 ) { | ||
19001 | after(grammarAccess.getALSDirectProductAccess().getRightOperandAssignment_1_4()); | ||
19002 | } | ||
19003 | |||
19004 | } | ||
19005 | |||
19006 | |||
19007 | } | ||
19008 | |||
19009 | } | ||
19010 | catch (RecognitionException re) { | ||
19011 | reportError(re); | ||
19012 | recover(input,re); | ||
19013 | } | ||
19014 | finally { | ||
19015 | |||
19016 | restoreStackSize(stackSize); | ||
19017 | |||
19018 | } | ||
19019 | return ; | ||
19020 | } | ||
19021 | // $ANTLR end "rule__ALSDirectProduct__Group_1__4__Impl" | ||
19022 | |||
19023 | |||
19024 | // $ANTLR start "rule__ALSPreficed__Group_0__0" | ||
19025 | // InternalAlloyLanguage.g:6613:1: rule__ALSPreficed__Group_0__0 : rule__ALSPreficed__Group_0__0__Impl rule__ALSPreficed__Group_0__1 ; | ||
19026 | public final void rule__ALSPreficed__Group_0__0() throws RecognitionException { | ||
19027 | |||
19028 | int stackSize = keepStackSize(); | ||
19029 | |||
19030 | try { | ||
19031 | // InternalAlloyLanguage.g:6617:1: ( rule__ALSPreficed__Group_0__0__Impl rule__ALSPreficed__Group_0__1 ) | ||
19032 | // InternalAlloyLanguage.g:6618:2: rule__ALSPreficed__Group_0__0__Impl rule__ALSPreficed__Group_0__1 | ||
19033 | { | ||
19034 | pushFollow(FOLLOW_47); | ||
19035 | rule__ALSPreficed__Group_0__0__Impl(); | ||
19036 | |||
19037 | state._fsp--; | ||
19038 | if (state.failed) return ; | ||
19039 | pushFollow(FOLLOW_2); | ||
19040 | rule__ALSPreficed__Group_0__1(); | ||
19041 | |||
19042 | state._fsp--; | ||
19043 | if (state.failed) return ; | ||
19044 | |||
19045 | } | ||
19046 | |||
19047 | } | ||
19048 | catch (RecognitionException re) { | ||
19049 | reportError(re); | ||
19050 | recover(input,re); | ||
19051 | } | ||
19052 | finally { | ||
19053 | |||
19054 | restoreStackSize(stackSize); | ||
19055 | |||
19056 | } | ||
19057 | return ; | ||
19058 | } | ||
19059 | // $ANTLR end "rule__ALSPreficed__Group_0__0" | ||
19060 | |||
19061 | |||
19062 | // $ANTLR start "rule__ALSPreficed__Group_0__0__Impl" | ||
19063 | // InternalAlloyLanguage.g:6625:1: rule__ALSPreficed__Group_0__0__Impl : ( () ) ; | ||
19064 | public final void rule__ALSPreficed__Group_0__0__Impl() throws RecognitionException { | ||
19065 | |||
19066 | int stackSize = keepStackSize(); | ||
19067 | |||
19068 | try { | ||
19069 | // InternalAlloyLanguage.g:6629:1: ( ( () ) ) | ||
19070 | // InternalAlloyLanguage.g:6630:1: ( () ) | ||
19071 | { | ||
19072 | // InternalAlloyLanguage.g:6630:1: ( () ) | ||
19073 | // InternalAlloyLanguage.g:6631:1: () | ||
19074 | { | ||
19075 | if ( state.backtracking==0 ) { | ||
19076 | before(grammarAccess.getALSPreficedAccess().getALSNotAction_0_0()); | ||
19077 | } | ||
19078 | // InternalAlloyLanguage.g:6632:1: () | ||
19079 | // InternalAlloyLanguage.g:6634:1: | ||
19080 | { | ||
19081 | } | ||
19082 | |||
19083 | if ( state.backtracking==0 ) { | ||
19084 | after(grammarAccess.getALSPreficedAccess().getALSNotAction_0_0()); | ||
19085 | } | ||
19086 | |||
19087 | } | ||
19088 | |||
19089 | |||
19090 | } | ||
19091 | |||
19092 | } | ||
19093 | finally { | ||
19094 | |||
19095 | restoreStackSize(stackSize); | ||
19096 | |||
19097 | } | ||
19098 | return ; | ||
19099 | } | ||
19100 | // $ANTLR end "rule__ALSPreficed__Group_0__0__Impl" | ||
19101 | |||
19102 | |||
19103 | // $ANTLR start "rule__ALSPreficed__Group_0__1" | ||
19104 | // InternalAlloyLanguage.g:6644:1: rule__ALSPreficed__Group_0__1 : rule__ALSPreficed__Group_0__1__Impl rule__ALSPreficed__Group_0__2 ; | ||
19105 | public final void rule__ALSPreficed__Group_0__1() throws RecognitionException { | ||
19106 | |||
19107 | int stackSize = keepStackSize(); | ||
19108 | |||
19109 | try { | ||
19110 | // InternalAlloyLanguage.g:6648:1: ( rule__ALSPreficed__Group_0__1__Impl rule__ALSPreficed__Group_0__2 ) | ||
19111 | // InternalAlloyLanguage.g:6649:2: rule__ALSPreficed__Group_0__1__Impl rule__ALSPreficed__Group_0__2 | ||
19112 | { | ||
19113 | pushFollow(FOLLOW_16); | ||
19114 | rule__ALSPreficed__Group_0__1__Impl(); | ||
19115 | |||
19116 | state._fsp--; | ||
19117 | if (state.failed) return ; | ||
19118 | pushFollow(FOLLOW_2); | ||
19119 | rule__ALSPreficed__Group_0__2(); | ||
19120 | |||
19121 | state._fsp--; | ||
19122 | if (state.failed) return ; | ||
19123 | |||
19124 | } | ||
19125 | |||
19126 | } | ||
19127 | catch (RecognitionException re) { | ||
19128 | reportError(re); | ||
19129 | recover(input,re); | ||
19130 | } | ||
19131 | finally { | ||
19132 | |||
19133 | restoreStackSize(stackSize); | ||
19134 | |||
19135 | } | ||
19136 | return ; | ||
19137 | } | ||
19138 | // $ANTLR end "rule__ALSPreficed__Group_0__1" | ||
19139 | |||
19140 | |||
19141 | // $ANTLR start "rule__ALSPreficed__Group_0__1__Impl" | ||
19142 | // InternalAlloyLanguage.g:6656:1: rule__ALSPreficed__Group_0__1__Impl : ( ( rule__ALSPreficed__Group_0_1__0 ) ) ; | ||
19143 | public final void rule__ALSPreficed__Group_0__1__Impl() throws RecognitionException { | ||
19144 | |||
19145 | int stackSize = keepStackSize(); | ||
19146 | |||
19147 | try { | ||
19148 | // InternalAlloyLanguage.g:6660:1: ( ( ( rule__ALSPreficed__Group_0_1__0 ) ) ) | ||
19149 | // InternalAlloyLanguage.g:6661:1: ( ( rule__ALSPreficed__Group_0_1__0 ) ) | ||
19150 | { | ||
19151 | // InternalAlloyLanguage.g:6661:1: ( ( rule__ALSPreficed__Group_0_1__0 ) ) | ||
19152 | // InternalAlloyLanguage.g:6662:1: ( rule__ALSPreficed__Group_0_1__0 ) | ||
19153 | { | ||
19154 | if ( state.backtracking==0 ) { | ||
19155 | before(grammarAccess.getALSPreficedAccess().getGroup_0_1()); | ||
19156 | } | ||
19157 | // InternalAlloyLanguage.g:6663:1: ( rule__ALSPreficed__Group_0_1__0 ) | ||
19158 | // InternalAlloyLanguage.g:6663:2: rule__ALSPreficed__Group_0_1__0 | ||
19159 | { | ||
19160 | pushFollow(FOLLOW_2); | ||
19161 | rule__ALSPreficed__Group_0_1__0(); | ||
19162 | |||
19163 | state._fsp--; | ||
19164 | if (state.failed) return ; | ||
19165 | |||
19166 | } | ||
19167 | |||
19168 | if ( state.backtracking==0 ) { | ||
19169 | after(grammarAccess.getALSPreficedAccess().getGroup_0_1()); | ||
19170 | } | ||
19171 | |||
19172 | } | ||
19173 | |||
19174 | |||
19175 | } | ||
19176 | |||
19177 | } | ||
19178 | catch (RecognitionException re) { | ||
19179 | reportError(re); | ||
19180 | recover(input,re); | ||
19181 | } | ||
19182 | finally { | ||
19183 | |||
19184 | restoreStackSize(stackSize); | ||
19185 | |||
19186 | } | ||
19187 | return ; | ||
19188 | } | ||
19189 | // $ANTLR end "rule__ALSPreficed__Group_0__1__Impl" | ||
19190 | |||
19191 | |||
19192 | // $ANTLR start "rule__ALSPreficed__Group_0__2" | ||
19193 | // InternalAlloyLanguage.g:6673:1: rule__ALSPreficed__Group_0__2 : rule__ALSPreficed__Group_0__2__Impl ; | ||
19194 | public final void rule__ALSPreficed__Group_0__2() throws RecognitionException { | ||
19195 | |||
19196 | int stackSize = keepStackSize(); | ||
19197 | |||
19198 | try { | ||
19199 | // InternalAlloyLanguage.g:6677:1: ( rule__ALSPreficed__Group_0__2__Impl ) | ||
19200 | // InternalAlloyLanguage.g:6678:2: rule__ALSPreficed__Group_0__2__Impl | ||
19201 | { | ||
19202 | pushFollow(FOLLOW_2); | ||
19203 | rule__ALSPreficed__Group_0__2__Impl(); | ||
19204 | |||
19205 | state._fsp--; | ||
19206 | if (state.failed) return ; | ||
19207 | |||
19208 | } | ||
19209 | |||
19210 | } | ||
19211 | catch (RecognitionException re) { | ||
19212 | reportError(re); | ||
19213 | recover(input,re); | ||
19214 | } | ||
19215 | finally { | ||
19216 | |||
19217 | restoreStackSize(stackSize); | ||
19218 | |||
19219 | } | ||
19220 | return ; | ||
19221 | } | ||
19222 | // $ANTLR end "rule__ALSPreficed__Group_0__2" | ||
19223 | |||
19224 | |||
19225 | // $ANTLR start "rule__ALSPreficed__Group_0__2__Impl" | ||
19226 | // InternalAlloyLanguage.g:6684:1: rule__ALSPreficed__Group_0__2__Impl : ( ( rule__ALSPreficed__OperandAssignment_0_2 ) ) ; | ||
19227 | public final void rule__ALSPreficed__Group_0__2__Impl() throws RecognitionException { | ||
19228 | |||
19229 | int stackSize = keepStackSize(); | ||
19230 | |||
19231 | try { | ||
19232 | // InternalAlloyLanguage.g:6688:1: ( ( ( rule__ALSPreficed__OperandAssignment_0_2 ) ) ) | ||
19233 | // InternalAlloyLanguage.g:6689:1: ( ( rule__ALSPreficed__OperandAssignment_0_2 ) ) | ||
19234 | { | ||
19235 | // InternalAlloyLanguage.g:6689:1: ( ( rule__ALSPreficed__OperandAssignment_0_2 ) ) | ||
19236 | // InternalAlloyLanguage.g:6690:1: ( rule__ALSPreficed__OperandAssignment_0_2 ) | ||
19237 | { | ||
19238 | if ( state.backtracking==0 ) { | ||
19239 | before(grammarAccess.getALSPreficedAccess().getOperandAssignment_0_2()); | ||
19240 | } | ||
19241 | // InternalAlloyLanguage.g:6691:1: ( rule__ALSPreficed__OperandAssignment_0_2 ) | ||
19242 | // InternalAlloyLanguage.g:6691:2: rule__ALSPreficed__OperandAssignment_0_2 | ||
19243 | { | ||
19244 | pushFollow(FOLLOW_2); | ||
19245 | rule__ALSPreficed__OperandAssignment_0_2(); | ||
19246 | |||
19247 | state._fsp--; | ||
19248 | if (state.failed) return ; | ||
19249 | |||
19250 | } | ||
19251 | |||
19252 | if ( state.backtracking==0 ) { | ||
19253 | after(grammarAccess.getALSPreficedAccess().getOperandAssignment_0_2()); | ||
19254 | } | ||
19255 | |||
19256 | } | ||
19257 | |||
19258 | |||
19259 | } | ||
19260 | |||
19261 | } | ||
19262 | catch (RecognitionException re) { | ||
19263 | reportError(re); | ||
19264 | recover(input,re); | ||
19265 | } | ||
19266 | finally { | ||
19267 | |||
19268 | restoreStackSize(stackSize); | ||
19269 | |||
19270 | } | ||
19271 | return ; | ||
19272 | } | ||
19273 | // $ANTLR end "rule__ALSPreficed__Group_0__2__Impl" | ||
19274 | |||
19275 | |||
19276 | // $ANTLR start "rule__ALSPreficed__Group_0_1__0" | ||
19277 | // InternalAlloyLanguage.g:6707:1: rule__ALSPreficed__Group_0_1__0 : rule__ALSPreficed__Group_0_1__0__Impl ; | ||
19278 | public final void rule__ALSPreficed__Group_0_1__0() throws RecognitionException { | ||
19279 | |||
19280 | int stackSize = keepStackSize(); | ||
19281 | |||
19282 | try { | ||
19283 | // InternalAlloyLanguage.g:6711:1: ( rule__ALSPreficed__Group_0_1__0__Impl ) | ||
19284 | // InternalAlloyLanguage.g:6712:2: rule__ALSPreficed__Group_0_1__0__Impl | ||
19285 | { | ||
19286 | pushFollow(FOLLOW_2); | ||
19287 | rule__ALSPreficed__Group_0_1__0__Impl(); | ||
19288 | |||
19289 | state._fsp--; | ||
19290 | if (state.failed) return ; | ||
19291 | |||
19292 | } | ||
19293 | |||
19294 | } | ||
19295 | catch (RecognitionException re) { | ||
19296 | reportError(re); | ||
19297 | recover(input,re); | ||
19298 | } | ||
19299 | finally { | ||
19300 | |||
19301 | restoreStackSize(stackSize); | ||
19302 | |||
19303 | } | ||
19304 | return ; | ||
19305 | } | ||
19306 | // $ANTLR end "rule__ALSPreficed__Group_0_1__0" | ||
19307 | |||
19308 | |||
19309 | // $ANTLR start "rule__ALSPreficed__Group_0_1__0__Impl" | ||
19310 | // InternalAlloyLanguage.g:6718:1: rule__ALSPreficed__Group_0_1__0__Impl : ( ( rule__ALSPreficed__Alternatives_0_1_0 ) ) ; | ||
19311 | public final void rule__ALSPreficed__Group_0_1__0__Impl() throws RecognitionException { | ||
19312 | |||
19313 | int stackSize = keepStackSize(); | ||
19314 | |||
19315 | try { | ||
19316 | // InternalAlloyLanguage.g:6722:1: ( ( ( rule__ALSPreficed__Alternatives_0_1_0 ) ) ) | ||
19317 | // InternalAlloyLanguage.g:6723:1: ( ( rule__ALSPreficed__Alternatives_0_1_0 ) ) | ||
19318 | { | ||
19319 | // InternalAlloyLanguage.g:6723:1: ( ( rule__ALSPreficed__Alternatives_0_1_0 ) ) | ||
19320 | // InternalAlloyLanguage.g:6724:1: ( rule__ALSPreficed__Alternatives_0_1_0 ) | ||
19321 | { | ||
19322 | if ( state.backtracking==0 ) { | ||
19323 | before(grammarAccess.getALSPreficedAccess().getAlternatives_0_1_0()); | ||
19324 | } | ||
19325 | // InternalAlloyLanguage.g:6725:1: ( rule__ALSPreficed__Alternatives_0_1_0 ) | ||
19326 | // InternalAlloyLanguage.g:6725:2: rule__ALSPreficed__Alternatives_0_1_0 | ||
19327 | { | ||
19328 | pushFollow(FOLLOW_2); | ||
19329 | rule__ALSPreficed__Alternatives_0_1_0(); | ||
19330 | |||
19331 | state._fsp--; | ||
19332 | if (state.failed) return ; | ||
19333 | |||
19334 | } | ||
19335 | |||
19336 | if ( state.backtracking==0 ) { | ||
19337 | after(grammarAccess.getALSPreficedAccess().getAlternatives_0_1_0()); | ||
19338 | } | ||
19339 | |||
19340 | } | ||
19341 | |||
19342 | |||
19343 | } | ||
19344 | |||
19345 | } | ||
19346 | catch (RecognitionException re) { | ||
19347 | reportError(re); | ||
19348 | recover(input,re); | ||
19349 | } | ||
19350 | finally { | ||
19351 | |||
19352 | restoreStackSize(stackSize); | ||
19353 | |||
19354 | } | ||
19355 | return ; | ||
19356 | } | ||
19357 | // $ANTLR end "rule__ALSPreficed__Group_0_1__0__Impl" | ||
19358 | |||
19359 | |||
19360 | // $ANTLR start "rule__ALSPreficed__Group_1__0" | ||
19361 | // InternalAlloyLanguage.g:6737:1: rule__ALSPreficed__Group_1__0 : rule__ALSPreficed__Group_1__0__Impl rule__ALSPreficed__Group_1__1 ; | ||
19362 | public final void rule__ALSPreficed__Group_1__0() throws RecognitionException { | ||
19363 | |||
19364 | int stackSize = keepStackSize(); | ||
19365 | |||
19366 | try { | ||
19367 | // InternalAlloyLanguage.g:6741:1: ( rule__ALSPreficed__Group_1__0__Impl rule__ALSPreficed__Group_1__1 ) | ||
19368 | // InternalAlloyLanguage.g:6742:2: rule__ALSPreficed__Group_1__0__Impl rule__ALSPreficed__Group_1__1 | ||
19369 | { | ||
19370 | pushFollow(FOLLOW_48); | ||
19371 | rule__ALSPreficed__Group_1__0__Impl(); | ||
19372 | |||
19373 | state._fsp--; | ||
19374 | if (state.failed) return ; | ||
19375 | pushFollow(FOLLOW_2); | ||
19376 | rule__ALSPreficed__Group_1__1(); | ||
19377 | |||
19378 | state._fsp--; | ||
19379 | if (state.failed) return ; | ||
19380 | |||
19381 | } | ||
19382 | |||
19383 | } | ||
19384 | catch (RecognitionException re) { | ||
19385 | reportError(re); | ||
19386 | recover(input,re); | ||
19387 | } | ||
19388 | finally { | ||
19389 | |||
19390 | restoreStackSize(stackSize); | ||
19391 | |||
19392 | } | ||
19393 | return ; | ||
19394 | } | ||
19395 | // $ANTLR end "rule__ALSPreficed__Group_1__0" | ||
19396 | |||
19397 | |||
19398 | // $ANTLR start "rule__ALSPreficed__Group_1__0__Impl" | ||
19399 | // InternalAlloyLanguage.g:6749:1: rule__ALSPreficed__Group_1__0__Impl : ( () ) ; | ||
19400 | public final void rule__ALSPreficed__Group_1__0__Impl() throws RecognitionException { | ||
19401 | |||
19402 | int stackSize = keepStackSize(); | ||
19403 | |||
19404 | try { | ||
19405 | // InternalAlloyLanguage.g:6753:1: ( ( () ) ) | ||
19406 | // InternalAlloyLanguage.g:6754:1: ( () ) | ||
19407 | { | ||
19408 | // InternalAlloyLanguage.g:6754:1: ( () ) | ||
19409 | // InternalAlloyLanguage.g:6755:1: () | ||
19410 | { | ||
19411 | if ( state.backtracking==0 ) { | ||
19412 | before(grammarAccess.getALSPreficedAccess().getALSInverseRelationAction_1_0()); | ||
19413 | } | ||
19414 | // InternalAlloyLanguage.g:6756:1: () | ||
19415 | // InternalAlloyLanguage.g:6758:1: | ||
19416 | { | ||
19417 | } | ||
19418 | |||
19419 | if ( state.backtracking==0 ) { | ||
19420 | after(grammarAccess.getALSPreficedAccess().getALSInverseRelationAction_1_0()); | ||
19421 | } | ||
19422 | |||
19423 | } | ||
19424 | |||
19425 | |||
19426 | } | ||
19427 | |||
19428 | } | ||
19429 | finally { | ||
19430 | |||
19431 | restoreStackSize(stackSize); | ||
19432 | |||
19433 | } | ||
19434 | return ; | ||
19435 | } | ||
19436 | // $ANTLR end "rule__ALSPreficed__Group_1__0__Impl" | ||
19437 | |||
19438 | |||
19439 | // $ANTLR start "rule__ALSPreficed__Group_1__1" | ||
19440 | // InternalAlloyLanguage.g:6768:1: rule__ALSPreficed__Group_1__1 : rule__ALSPreficed__Group_1__1__Impl rule__ALSPreficed__Group_1__2 ; | ||
19441 | public final void rule__ALSPreficed__Group_1__1() throws RecognitionException { | ||
19442 | |||
19443 | int stackSize = keepStackSize(); | ||
19444 | |||
19445 | try { | ||
19446 | // InternalAlloyLanguage.g:6772:1: ( rule__ALSPreficed__Group_1__1__Impl rule__ALSPreficed__Group_1__2 ) | ||
19447 | // InternalAlloyLanguage.g:6773:2: rule__ALSPreficed__Group_1__1__Impl rule__ALSPreficed__Group_1__2 | ||
19448 | { | ||
19449 | pushFollow(FOLLOW_16); | ||
19450 | rule__ALSPreficed__Group_1__1__Impl(); | ||
19451 | |||
19452 | state._fsp--; | ||
19453 | if (state.failed) return ; | ||
19454 | pushFollow(FOLLOW_2); | ||
19455 | rule__ALSPreficed__Group_1__2(); | ||
19456 | |||
19457 | state._fsp--; | ||
19458 | if (state.failed) return ; | ||
19459 | |||
19460 | } | ||
19461 | |||
19462 | } | ||
19463 | catch (RecognitionException re) { | ||
19464 | reportError(re); | ||
19465 | recover(input,re); | ||
19466 | } | ||
19467 | finally { | ||
19468 | |||
19469 | restoreStackSize(stackSize); | ||
19470 | |||
19471 | } | ||
19472 | return ; | ||
19473 | } | ||
19474 | // $ANTLR end "rule__ALSPreficed__Group_1__1" | ||
19475 | |||
19476 | |||
19477 | // $ANTLR start "rule__ALSPreficed__Group_1__1__Impl" | ||
19478 | // InternalAlloyLanguage.g:6780:1: rule__ALSPreficed__Group_1__1__Impl : ( ( '~' ) ) ; | ||
19479 | public final void rule__ALSPreficed__Group_1__1__Impl() throws RecognitionException { | ||
19480 | |||
19481 | int stackSize = keepStackSize(); | ||
19482 | |||
19483 | try { | ||
19484 | // InternalAlloyLanguage.g:6784:1: ( ( ( '~' ) ) ) | ||
19485 | // InternalAlloyLanguage.g:6785:1: ( ( '~' ) ) | ||
19486 | { | ||
19487 | // InternalAlloyLanguage.g:6785:1: ( ( '~' ) ) | ||
19488 | // InternalAlloyLanguage.g:6786:1: ( '~' ) | ||
19489 | { | ||
19490 | if ( state.backtracking==0 ) { | ||
19491 | before(grammarAccess.getALSPreficedAccess().getTildeKeyword_1_1()); | ||
19492 | } | ||
19493 | // InternalAlloyLanguage.g:6787:1: ( '~' ) | ||
19494 | // InternalAlloyLanguage.g:6788:2: '~' | ||
19495 | { | ||
19496 | match(input,60,FOLLOW_2); if (state.failed) return ; | ||
19497 | |||
19498 | } | ||
19499 | |||
19500 | if ( state.backtracking==0 ) { | ||
19501 | after(grammarAccess.getALSPreficedAccess().getTildeKeyword_1_1()); | ||
19502 | } | ||
19503 | |||
19504 | } | ||
19505 | |||
19506 | |||
19507 | } | ||
19508 | |||
19509 | } | ||
19510 | catch (RecognitionException re) { | ||
19511 | reportError(re); | ||
19512 | recover(input,re); | ||
19513 | } | ||
19514 | finally { | ||
19515 | |||
19516 | restoreStackSize(stackSize); | ||
19517 | |||
19518 | } | ||
19519 | return ; | ||
19520 | } | ||
19521 | // $ANTLR end "rule__ALSPreficed__Group_1__1__Impl" | ||
19522 | |||
19523 | |||
19524 | // $ANTLR start "rule__ALSPreficed__Group_1__2" | ||
19525 | // InternalAlloyLanguage.g:6799:1: rule__ALSPreficed__Group_1__2 : rule__ALSPreficed__Group_1__2__Impl ; | ||
19526 | public final void rule__ALSPreficed__Group_1__2() throws RecognitionException { | ||
19527 | |||
19528 | int stackSize = keepStackSize(); | ||
19529 | |||
19530 | try { | ||
19531 | // InternalAlloyLanguage.g:6803:1: ( rule__ALSPreficed__Group_1__2__Impl ) | ||
19532 | // InternalAlloyLanguage.g:6804:2: rule__ALSPreficed__Group_1__2__Impl | ||
19533 | { | ||
19534 | pushFollow(FOLLOW_2); | ||
19535 | rule__ALSPreficed__Group_1__2__Impl(); | ||
19536 | |||
19537 | state._fsp--; | ||
19538 | if (state.failed) return ; | ||
19539 | |||
19540 | } | ||
19541 | |||
19542 | } | ||
19543 | catch (RecognitionException re) { | ||
19544 | reportError(re); | ||
19545 | recover(input,re); | ||
19546 | } | ||
19547 | finally { | ||
19548 | |||
19549 | restoreStackSize(stackSize); | ||
19550 | |||
19551 | } | ||
19552 | return ; | ||
19553 | } | ||
19554 | // $ANTLR end "rule__ALSPreficed__Group_1__2" | ||
19555 | |||
19556 | |||
19557 | // $ANTLR start "rule__ALSPreficed__Group_1__2__Impl" | ||
19558 | // InternalAlloyLanguage.g:6810:1: rule__ALSPreficed__Group_1__2__Impl : ( ( rule__ALSPreficed__OperandAssignment_1_2 ) ) ; | ||
19559 | public final void rule__ALSPreficed__Group_1__2__Impl() throws RecognitionException { | ||
19560 | |||
19561 | int stackSize = keepStackSize(); | ||
19562 | |||
19563 | try { | ||
19564 | // InternalAlloyLanguage.g:6814:1: ( ( ( rule__ALSPreficed__OperandAssignment_1_2 ) ) ) | ||
19565 | // InternalAlloyLanguage.g:6815:1: ( ( rule__ALSPreficed__OperandAssignment_1_2 ) ) | ||
19566 | { | ||
19567 | // InternalAlloyLanguage.g:6815:1: ( ( rule__ALSPreficed__OperandAssignment_1_2 ) ) | ||
19568 | // InternalAlloyLanguage.g:6816:1: ( rule__ALSPreficed__OperandAssignment_1_2 ) | ||
19569 | { | ||
19570 | if ( state.backtracking==0 ) { | ||
19571 | before(grammarAccess.getALSPreficedAccess().getOperandAssignment_1_2()); | ||
19572 | } | ||
19573 | // InternalAlloyLanguage.g:6817:1: ( rule__ALSPreficed__OperandAssignment_1_2 ) | ||
19574 | // InternalAlloyLanguage.g:6817:2: rule__ALSPreficed__OperandAssignment_1_2 | ||
19575 | { | ||
19576 | pushFollow(FOLLOW_2); | ||
19577 | rule__ALSPreficed__OperandAssignment_1_2(); | ||
19578 | |||
19579 | state._fsp--; | ||
19580 | if (state.failed) return ; | ||
19581 | |||
19582 | } | ||
19583 | |||
19584 | if ( state.backtracking==0 ) { | ||
19585 | after(grammarAccess.getALSPreficedAccess().getOperandAssignment_1_2()); | ||
19586 | } | ||
19587 | |||
19588 | } | ||
19589 | |||
19590 | |||
19591 | } | ||
19592 | |||
19593 | } | ||
19594 | catch (RecognitionException re) { | ||
19595 | reportError(re); | ||
19596 | recover(input,re); | ||
19597 | } | ||
19598 | finally { | ||
19599 | |||
19600 | restoreStackSize(stackSize); | ||
19601 | |||
19602 | } | ||
19603 | return ; | ||
19604 | } | ||
19605 | // $ANTLR end "rule__ALSPreficed__Group_1__2__Impl" | ||
19606 | |||
19607 | |||
19608 | // $ANTLR start "rule__ALSPreficed__Group_2__0" | ||
19609 | // InternalAlloyLanguage.g:6833:1: rule__ALSPreficed__Group_2__0 : rule__ALSPreficed__Group_2__0__Impl rule__ALSPreficed__Group_2__1 ; | ||
19610 | public final void rule__ALSPreficed__Group_2__0() throws RecognitionException { | ||
19611 | |||
19612 | int stackSize = keepStackSize(); | ||
19613 | |||
19614 | try { | ||
19615 | // InternalAlloyLanguage.g:6837:1: ( rule__ALSPreficed__Group_2__0__Impl rule__ALSPreficed__Group_2__1 ) | ||
19616 | // InternalAlloyLanguage.g:6838:2: rule__ALSPreficed__Group_2__0__Impl rule__ALSPreficed__Group_2__1 | ||
19617 | { | ||
19618 | pushFollow(FOLLOW_49); | ||
19619 | rule__ALSPreficed__Group_2__0__Impl(); | ||
19620 | |||
19621 | state._fsp--; | ||
19622 | if (state.failed) return ; | ||
19623 | pushFollow(FOLLOW_2); | ||
19624 | rule__ALSPreficed__Group_2__1(); | ||
19625 | |||
19626 | state._fsp--; | ||
19627 | if (state.failed) return ; | ||
19628 | |||
19629 | } | ||
19630 | |||
19631 | } | ||
19632 | catch (RecognitionException re) { | ||
19633 | reportError(re); | ||
19634 | recover(input,re); | ||
19635 | } | ||
19636 | finally { | ||
19637 | |||
19638 | restoreStackSize(stackSize); | ||
19639 | |||
19640 | } | ||
19641 | return ; | ||
19642 | } | ||
19643 | // $ANTLR end "rule__ALSPreficed__Group_2__0" | ||
19644 | |||
19645 | |||
19646 | // $ANTLR start "rule__ALSPreficed__Group_2__0__Impl" | ||
19647 | // InternalAlloyLanguage.g:6845:1: rule__ALSPreficed__Group_2__0__Impl : ( () ) ; | ||
19648 | public final void rule__ALSPreficed__Group_2__0__Impl() throws RecognitionException { | ||
19649 | |||
19650 | int stackSize = keepStackSize(); | ||
19651 | |||
19652 | try { | ||
19653 | // InternalAlloyLanguage.g:6849:1: ( ( () ) ) | ||
19654 | // InternalAlloyLanguage.g:6850:1: ( () ) | ||
19655 | { | ||
19656 | // InternalAlloyLanguage.g:6850:1: ( () ) | ||
19657 | // InternalAlloyLanguage.g:6851:1: () | ||
19658 | { | ||
19659 | if ( state.backtracking==0 ) { | ||
19660 | before(grammarAccess.getALSPreficedAccess().getAlSTransitiveClosureAction_2_0()); | ||
19661 | } | ||
19662 | // InternalAlloyLanguage.g:6852:1: () | ||
19663 | // InternalAlloyLanguage.g:6854:1: | ||
19664 | { | ||
19665 | } | ||
19666 | |||
19667 | if ( state.backtracking==0 ) { | ||
19668 | after(grammarAccess.getALSPreficedAccess().getAlSTransitiveClosureAction_2_0()); | ||
19669 | } | ||
19670 | |||
19671 | } | ||
19672 | |||
19673 | |||
19674 | } | ||
19675 | |||
19676 | } | ||
19677 | finally { | ||
19678 | |||
19679 | restoreStackSize(stackSize); | ||
19680 | |||
19681 | } | ||
19682 | return ; | ||
19683 | } | ||
19684 | // $ANTLR end "rule__ALSPreficed__Group_2__0__Impl" | ||
19685 | |||
19686 | |||
19687 | // $ANTLR start "rule__ALSPreficed__Group_2__1" | ||
19688 | // InternalAlloyLanguage.g:6864:1: rule__ALSPreficed__Group_2__1 : rule__ALSPreficed__Group_2__1__Impl rule__ALSPreficed__Group_2__2 ; | ||
19689 | public final void rule__ALSPreficed__Group_2__1() throws RecognitionException { | ||
19690 | |||
19691 | int stackSize = keepStackSize(); | ||
19692 | |||
19693 | try { | ||
19694 | // InternalAlloyLanguage.g:6868:1: ( rule__ALSPreficed__Group_2__1__Impl rule__ALSPreficed__Group_2__2 ) | ||
19695 | // InternalAlloyLanguage.g:6869:2: rule__ALSPreficed__Group_2__1__Impl rule__ALSPreficed__Group_2__2 | ||
19696 | { | ||
19697 | pushFollow(FOLLOW_16); | ||
19698 | rule__ALSPreficed__Group_2__1__Impl(); | ||
19699 | |||
19700 | state._fsp--; | ||
19701 | if (state.failed) return ; | ||
19702 | pushFollow(FOLLOW_2); | ||
19703 | rule__ALSPreficed__Group_2__2(); | ||
19704 | |||
19705 | state._fsp--; | ||
19706 | if (state.failed) return ; | ||
19707 | |||
19708 | } | ||
19709 | |||
19710 | } | ||
19711 | catch (RecognitionException re) { | ||
19712 | reportError(re); | ||
19713 | recover(input,re); | ||
19714 | } | ||
19715 | finally { | ||
19716 | |||
19717 | restoreStackSize(stackSize); | ||
19718 | |||
19719 | } | ||
19720 | return ; | ||
19721 | } | ||
19722 | // $ANTLR end "rule__ALSPreficed__Group_2__1" | ||
19723 | |||
19724 | |||
19725 | // $ANTLR start "rule__ALSPreficed__Group_2__1__Impl" | ||
19726 | // InternalAlloyLanguage.g:6876:1: rule__ALSPreficed__Group_2__1__Impl : ( '^' ) ; | ||
19727 | public final void rule__ALSPreficed__Group_2__1__Impl() throws RecognitionException { | ||
19728 | |||
19729 | int stackSize = keepStackSize(); | ||
19730 | |||
19731 | try { | ||
19732 | // InternalAlloyLanguage.g:6880:1: ( ( '^' ) ) | ||
19733 | // InternalAlloyLanguage.g:6881:1: ( '^' ) | ||
19734 | { | ||
19735 | // InternalAlloyLanguage.g:6881:1: ( '^' ) | ||
19736 | // InternalAlloyLanguage.g:6882:1: '^' | ||
19737 | { | ||
19738 | if ( state.backtracking==0 ) { | ||
19739 | before(grammarAccess.getALSPreficedAccess().getCircumflexAccentKeyword_2_1()); | ||
19740 | } | ||
19741 | match(input,61,FOLLOW_2); if (state.failed) return ; | ||
19742 | if ( state.backtracking==0 ) { | ||
19743 | after(grammarAccess.getALSPreficedAccess().getCircumflexAccentKeyword_2_1()); | ||
19744 | } | ||
19745 | |||
19746 | } | ||
19747 | |||
19748 | |||
19749 | } | ||
19750 | |||
19751 | } | ||
19752 | catch (RecognitionException re) { | ||
19753 | reportError(re); | ||
19754 | recover(input,re); | ||
19755 | } | ||
19756 | finally { | ||
19757 | |||
19758 | restoreStackSize(stackSize); | ||
19759 | |||
19760 | } | ||
19761 | return ; | ||
19762 | } | ||
19763 | // $ANTLR end "rule__ALSPreficed__Group_2__1__Impl" | ||
19764 | |||
19765 | |||
19766 | // $ANTLR start "rule__ALSPreficed__Group_2__2" | ||
19767 | // InternalAlloyLanguage.g:6895:1: rule__ALSPreficed__Group_2__2 : rule__ALSPreficed__Group_2__2__Impl ; | ||
19768 | public final void rule__ALSPreficed__Group_2__2() throws RecognitionException { | ||
19769 | |||
19770 | int stackSize = keepStackSize(); | ||
19771 | |||
19772 | try { | ||
19773 | // InternalAlloyLanguage.g:6899:1: ( rule__ALSPreficed__Group_2__2__Impl ) | ||
19774 | // InternalAlloyLanguage.g:6900:2: rule__ALSPreficed__Group_2__2__Impl | ||
19775 | { | ||
19776 | pushFollow(FOLLOW_2); | ||
19777 | rule__ALSPreficed__Group_2__2__Impl(); | ||
19778 | |||
19779 | state._fsp--; | ||
19780 | if (state.failed) return ; | ||
19781 | |||
19782 | } | ||
19783 | |||
19784 | } | ||
19785 | catch (RecognitionException re) { | ||
19786 | reportError(re); | ||
19787 | recover(input,re); | ||
19788 | } | ||
19789 | finally { | ||
19790 | |||
19791 | restoreStackSize(stackSize); | ||
19792 | |||
19793 | } | ||
19794 | return ; | ||
19795 | } | ||
19796 | // $ANTLR end "rule__ALSPreficed__Group_2__2" | ||
19797 | |||
19798 | |||
19799 | // $ANTLR start "rule__ALSPreficed__Group_2__2__Impl" | ||
19800 | // InternalAlloyLanguage.g:6906:1: rule__ALSPreficed__Group_2__2__Impl : ( ( rule__ALSPreficed__OperandAssignment_2_2 ) ) ; | ||
19801 | public final void rule__ALSPreficed__Group_2__2__Impl() throws RecognitionException { | ||
19802 | |||
19803 | int stackSize = keepStackSize(); | ||
19804 | |||
19805 | try { | ||
19806 | // InternalAlloyLanguage.g:6910:1: ( ( ( rule__ALSPreficed__OperandAssignment_2_2 ) ) ) | ||
19807 | // InternalAlloyLanguage.g:6911:1: ( ( rule__ALSPreficed__OperandAssignment_2_2 ) ) | ||
19808 | { | ||
19809 | // InternalAlloyLanguage.g:6911:1: ( ( rule__ALSPreficed__OperandAssignment_2_2 ) ) | ||
19810 | // InternalAlloyLanguage.g:6912:1: ( rule__ALSPreficed__OperandAssignment_2_2 ) | ||
19811 | { | ||
19812 | if ( state.backtracking==0 ) { | ||
19813 | before(grammarAccess.getALSPreficedAccess().getOperandAssignment_2_2()); | ||
19814 | } | ||
19815 | // InternalAlloyLanguage.g:6913:1: ( rule__ALSPreficed__OperandAssignment_2_2 ) | ||
19816 | // InternalAlloyLanguage.g:6913:2: rule__ALSPreficed__OperandAssignment_2_2 | ||
19817 | { | ||
19818 | pushFollow(FOLLOW_2); | ||
19819 | rule__ALSPreficed__OperandAssignment_2_2(); | ||
19820 | |||
19821 | state._fsp--; | ||
19822 | if (state.failed) return ; | ||
19823 | |||
19824 | } | ||
19825 | |||
19826 | if ( state.backtracking==0 ) { | ||
19827 | after(grammarAccess.getALSPreficedAccess().getOperandAssignment_2_2()); | ||
19828 | } | ||
19829 | |||
19830 | } | ||
19831 | |||
19832 | |||
19833 | } | ||
19834 | |||
19835 | } | ||
19836 | catch (RecognitionException re) { | ||
19837 | reportError(re); | ||
19838 | recover(input,re); | ||
19839 | } | ||
19840 | finally { | ||
19841 | |||
19842 | restoreStackSize(stackSize); | ||
19843 | |||
19844 | } | ||
19845 | return ; | ||
19846 | } | ||
19847 | // $ANTLR end "rule__ALSPreficed__Group_2__2__Impl" | ||
19848 | |||
19849 | |||
19850 | // $ANTLR start "rule__ALSPreficed__Group_3__0" | ||
19851 | // InternalAlloyLanguage.g:6929:1: rule__ALSPreficed__Group_3__0 : rule__ALSPreficed__Group_3__0__Impl rule__ALSPreficed__Group_3__1 ; | ||
19852 | public final void rule__ALSPreficed__Group_3__0() throws RecognitionException { | ||
19853 | |||
19854 | int stackSize = keepStackSize(); | ||
19855 | |||
19856 | try { | ||
19857 | // InternalAlloyLanguage.g:6933:1: ( rule__ALSPreficed__Group_3__0__Impl rule__ALSPreficed__Group_3__1 ) | ||
19858 | // InternalAlloyLanguage.g:6934:2: rule__ALSPreficed__Group_3__0__Impl rule__ALSPreficed__Group_3__1 | ||
19859 | { | ||
19860 | pushFollow(FOLLOW_50); | ||
19861 | rule__ALSPreficed__Group_3__0__Impl(); | ||
19862 | |||
19863 | state._fsp--; | ||
19864 | if (state.failed) return ; | ||
19865 | pushFollow(FOLLOW_2); | ||
19866 | rule__ALSPreficed__Group_3__1(); | ||
19867 | |||
19868 | state._fsp--; | ||
19869 | if (state.failed) return ; | ||
19870 | |||
19871 | } | ||
19872 | |||
19873 | } | ||
19874 | catch (RecognitionException re) { | ||
19875 | reportError(re); | ||
19876 | recover(input,re); | ||
19877 | } | ||
19878 | finally { | ||
19879 | |||
19880 | restoreStackSize(stackSize); | ||
19881 | |||
19882 | } | ||
19883 | return ; | ||
19884 | } | ||
19885 | // $ANTLR end "rule__ALSPreficed__Group_3__0" | ||
19886 | |||
19887 | |||
19888 | // $ANTLR start "rule__ALSPreficed__Group_3__0__Impl" | ||
19889 | // InternalAlloyLanguage.g:6941:1: rule__ALSPreficed__Group_3__0__Impl : ( () ) ; | ||
19890 | public final void rule__ALSPreficed__Group_3__0__Impl() throws RecognitionException { | ||
19891 | |||
19892 | int stackSize = keepStackSize(); | ||
19893 | |||
19894 | try { | ||
19895 | // InternalAlloyLanguage.g:6945:1: ( ( () ) ) | ||
19896 | // InternalAlloyLanguage.g:6946:1: ( () ) | ||
19897 | { | ||
19898 | // InternalAlloyLanguage.g:6946:1: ( () ) | ||
19899 | // InternalAlloyLanguage.g:6947:1: () | ||
19900 | { | ||
19901 | if ( state.backtracking==0 ) { | ||
19902 | before(grammarAccess.getALSPreficedAccess().getALSReflectiveTransitiveClosureAction_3_0()); | ||
19903 | } | ||
19904 | // InternalAlloyLanguage.g:6948:1: () | ||
19905 | // InternalAlloyLanguage.g:6950:1: | ||
19906 | { | ||
19907 | } | ||
19908 | |||
19909 | if ( state.backtracking==0 ) { | ||
19910 | after(grammarAccess.getALSPreficedAccess().getALSReflectiveTransitiveClosureAction_3_0()); | ||
19911 | } | ||
19912 | |||
19913 | } | ||
19914 | |||
19915 | |||
19916 | } | ||
19917 | |||
19918 | } | ||
19919 | finally { | ||
19920 | |||
19921 | restoreStackSize(stackSize); | ||
19922 | |||
19923 | } | ||
19924 | return ; | ||
19925 | } | ||
19926 | // $ANTLR end "rule__ALSPreficed__Group_3__0__Impl" | ||
19927 | |||
19928 | |||
19929 | // $ANTLR start "rule__ALSPreficed__Group_3__1" | ||
19930 | // InternalAlloyLanguage.g:6960:1: rule__ALSPreficed__Group_3__1 : rule__ALSPreficed__Group_3__1__Impl rule__ALSPreficed__Group_3__2 ; | ||
19931 | public final void rule__ALSPreficed__Group_3__1() throws RecognitionException { | ||
19932 | |||
19933 | int stackSize = keepStackSize(); | ||
19934 | |||
19935 | try { | ||
19936 | // InternalAlloyLanguage.g:6964:1: ( rule__ALSPreficed__Group_3__1__Impl rule__ALSPreficed__Group_3__2 ) | ||
19937 | // InternalAlloyLanguage.g:6965:2: rule__ALSPreficed__Group_3__1__Impl rule__ALSPreficed__Group_3__2 | ||
19938 | { | ||
19939 | pushFollow(FOLLOW_16); | ||
19940 | rule__ALSPreficed__Group_3__1__Impl(); | ||
19941 | |||
19942 | state._fsp--; | ||
19943 | if (state.failed) return ; | ||
19944 | pushFollow(FOLLOW_2); | ||
19945 | rule__ALSPreficed__Group_3__2(); | ||
19946 | |||
19947 | state._fsp--; | ||
19948 | if (state.failed) return ; | ||
19949 | |||
19950 | } | ||
19951 | |||
19952 | } | ||
19953 | catch (RecognitionException re) { | ||
19954 | reportError(re); | ||
19955 | recover(input,re); | ||
19956 | } | ||
19957 | finally { | ||
19958 | |||
19959 | restoreStackSize(stackSize); | ||
19960 | |||
19961 | } | ||
19962 | return ; | ||
19963 | } | ||
19964 | // $ANTLR end "rule__ALSPreficed__Group_3__1" | ||
19965 | |||
19966 | |||
19967 | // $ANTLR start "rule__ALSPreficed__Group_3__1__Impl" | ||
19968 | // InternalAlloyLanguage.g:6972:1: rule__ALSPreficed__Group_3__1__Impl : ( '*' ) ; | ||
19969 | public final void rule__ALSPreficed__Group_3__1__Impl() throws RecognitionException { | ||
19970 | |||
19971 | int stackSize = keepStackSize(); | ||
19972 | |||
19973 | try { | ||
19974 | // InternalAlloyLanguage.g:6976:1: ( ( '*' ) ) | ||
19975 | // InternalAlloyLanguage.g:6977:1: ( '*' ) | ||
19976 | { | ||
19977 | // InternalAlloyLanguage.g:6977:1: ( '*' ) | ||
19978 | // InternalAlloyLanguage.g:6978:1: '*' | ||
19979 | { | ||
19980 | if ( state.backtracking==0 ) { | ||
19981 | before(grammarAccess.getALSPreficedAccess().getAsteriskKeyword_3_1()); | ||
19982 | } | ||
19983 | match(input,62,FOLLOW_2); if (state.failed) return ; | ||
19984 | if ( state.backtracking==0 ) { | ||
19985 | after(grammarAccess.getALSPreficedAccess().getAsteriskKeyword_3_1()); | ||
19986 | } | ||
19987 | |||
19988 | } | ||
19989 | |||
19990 | |||
19991 | } | ||
19992 | |||
19993 | } | ||
19994 | catch (RecognitionException re) { | ||
19995 | reportError(re); | ||
19996 | recover(input,re); | ||
19997 | } | ||
19998 | finally { | ||
19999 | |||
20000 | restoreStackSize(stackSize); | ||
20001 | |||
20002 | } | ||
20003 | return ; | ||
20004 | } | ||
20005 | // $ANTLR end "rule__ALSPreficed__Group_3__1__Impl" | ||
20006 | |||
20007 | |||
20008 | // $ANTLR start "rule__ALSPreficed__Group_3__2" | ||
20009 | // InternalAlloyLanguage.g:6991:1: rule__ALSPreficed__Group_3__2 : rule__ALSPreficed__Group_3__2__Impl ; | ||
20010 | public final void rule__ALSPreficed__Group_3__2() throws RecognitionException { | ||
20011 | |||
20012 | int stackSize = keepStackSize(); | ||
20013 | |||
20014 | try { | ||
20015 | // InternalAlloyLanguage.g:6995:1: ( rule__ALSPreficed__Group_3__2__Impl ) | ||
20016 | // InternalAlloyLanguage.g:6996:2: rule__ALSPreficed__Group_3__2__Impl | ||
20017 | { | ||
20018 | pushFollow(FOLLOW_2); | ||
20019 | rule__ALSPreficed__Group_3__2__Impl(); | ||
20020 | |||
20021 | state._fsp--; | ||
20022 | if (state.failed) return ; | ||
20023 | |||
20024 | } | ||
20025 | |||
20026 | } | ||
20027 | catch (RecognitionException re) { | ||
20028 | reportError(re); | ||
20029 | recover(input,re); | ||
20030 | } | ||
20031 | finally { | ||
20032 | |||
20033 | restoreStackSize(stackSize); | ||
20034 | |||
20035 | } | ||
20036 | return ; | ||
20037 | } | ||
20038 | // $ANTLR end "rule__ALSPreficed__Group_3__2" | ||
20039 | |||
20040 | |||
20041 | // $ANTLR start "rule__ALSPreficed__Group_3__2__Impl" | ||
20042 | // InternalAlloyLanguage.g:7002:1: rule__ALSPreficed__Group_3__2__Impl : ( ( rule__ALSPreficed__OperandAssignment_3_2 ) ) ; | ||
20043 | public final void rule__ALSPreficed__Group_3__2__Impl() throws RecognitionException { | ||
20044 | |||
20045 | int stackSize = keepStackSize(); | ||
20046 | |||
20047 | try { | ||
20048 | // InternalAlloyLanguage.g:7006:1: ( ( ( rule__ALSPreficed__OperandAssignment_3_2 ) ) ) | ||
20049 | // InternalAlloyLanguage.g:7007:1: ( ( rule__ALSPreficed__OperandAssignment_3_2 ) ) | ||
20050 | { | ||
20051 | // InternalAlloyLanguage.g:7007:1: ( ( rule__ALSPreficed__OperandAssignment_3_2 ) ) | ||
20052 | // InternalAlloyLanguage.g:7008:1: ( rule__ALSPreficed__OperandAssignment_3_2 ) | ||
20053 | { | ||
20054 | if ( state.backtracking==0 ) { | ||
20055 | before(grammarAccess.getALSPreficedAccess().getOperandAssignment_3_2()); | ||
20056 | } | ||
20057 | // InternalAlloyLanguage.g:7009:1: ( rule__ALSPreficed__OperandAssignment_3_2 ) | ||
20058 | // InternalAlloyLanguage.g:7009:2: rule__ALSPreficed__OperandAssignment_3_2 | ||
20059 | { | ||
20060 | pushFollow(FOLLOW_2); | ||
20061 | rule__ALSPreficed__OperandAssignment_3_2(); | ||
20062 | |||
20063 | state._fsp--; | ||
20064 | if (state.failed) return ; | ||
20065 | |||
20066 | } | ||
20067 | |||
20068 | if ( state.backtracking==0 ) { | ||
20069 | after(grammarAccess.getALSPreficedAccess().getOperandAssignment_3_2()); | ||
20070 | } | ||
20071 | |||
20072 | } | ||
20073 | |||
20074 | |||
20075 | } | ||
20076 | |||
20077 | } | ||
20078 | catch (RecognitionException re) { | ||
20079 | reportError(re); | ||
20080 | recover(input,re); | ||
20081 | } | ||
20082 | finally { | ||
20083 | |||
20084 | restoreStackSize(stackSize); | ||
20085 | |||
20086 | } | ||
20087 | return ; | ||
20088 | } | ||
20089 | // $ANTLR end "rule__ALSPreficed__Group_3__2__Impl" | ||
20090 | |||
20091 | |||
20092 | // $ANTLR start "rule__ALSPreficed__Group_4__0" | ||
20093 | // InternalAlloyLanguage.g:7025:1: rule__ALSPreficed__Group_4__0 : rule__ALSPreficed__Group_4__0__Impl rule__ALSPreficed__Group_4__1 ; | ||
20094 | public final void rule__ALSPreficed__Group_4__0() throws RecognitionException { | ||
20095 | |||
20096 | int stackSize = keepStackSize(); | ||
20097 | |||
20098 | try { | ||
20099 | // InternalAlloyLanguage.g:7029:1: ( rule__ALSPreficed__Group_4__0__Impl rule__ALSPreficed__Group_4__1 ) | ||
20100 | // InternalAlloyLanguage.g:7030:2: rule__ALSPreficed__Group_4__0__Impl rule__ALSPreficed__Group_4__1 | ||
20101 | { | ||
20102 | pushFollow(FOLLOW_51); | ||
20103 | rule__ALSPreficed__Group_4__0__Impl(); | ||
20104 | |||
20105 | state._fsp--; | ||
20106 | if (state.failed) return ; | ||
20107 | pushFollow(FOLLOW_2); | ||
20108 | rule__ALSPreficed__Group_4__1(); | ||
20109 | |||
20110 | state._fsp--; | ||
20111 | if (state.failed) return ; | ||
20112 | |||
20113 | } | ||
20114 | |||
20115 | } | ||
20116 | catch (RecognitionException re) { | ||
20117 | reportError(re); | ||
20118 | recover(input,re); | ||
20119 | } | ||
20120 | finally { | ||
20121 | |||
20122 | restoreStackSize(stackSize); | ||
20123 | |||
20124 | } | ||
20125 | return ; | ||
20126 | } | ||
20127 | // $ANTLR end "rule__ALSPreficed__Group_4__0" | ||
20128 | |||
20129 | |||
20130 | // $ANTLR start "rule__ALSPreficed__Group_4__0__Impl" | ||
20131 | // InternalAlloyLanguage.g:7037:1: rule__ALSPreficed__Group_4__0__Impl : ( () ) ; | ||
20132 | public final void rule__ALSPreficed__Group_4__0__Impl() throws RecognitionException { | ||
20133 | |||
20134 | int stackSize = keepStackSize(); | ||
20135 | |||
20136 | try { | ||
20137 | // InternalAlloyLanguage.g:7041:1: ( ( () ) ) | ||
20138 | // InternalAlloyLanguage.g:7042:1: ( () ) | ||
20139 | { | ||
20140 | // InternalAlloyLanguage.g:7042:1: ( () ) | ||
20141 | // InternalAlloyLanguage.g:7043:1: () | ||
20142 | { | ||
20143 | if ( state.backtracking==0 ) { | ||
20144 | before(grammarAccess.getALSPreficedAccess().getALSCardinalityAction_4_0()); | ||
20145 | } | ||
20146 | // InternalAlloyLanguage.g:7044:1: () | ||
20147 | // InternalAlloyLanguage.g:7046:1: | ||
20148 | { | ||
20149 | } | ||
20150 | |||
20151 | if ( state.backtracking==0 ) { | ||
20152 | after(grammarAccess.getALSPreficedAccess().getALSCardinalityAction_4_0()); | ||
20153 | } | ||
20154 | |||
20155 | } | ||
20156 | |||
20157 | |||
20158 | } | ||
20159 | |||
20160 | } | ||
20161 | finally { | ||
20162 | |||
20163 | restoreStackSize(stackSize); | ||
20164 | |||
20165 | } | ||
20166 | return ; | ||
20167 | } | ||
20168 | // $ANTLR end "rule__ALSPreficed__Group_4__0__Impl" | ||
20169 | |||
20170 | |||
20171 | // $ANTLR start "rule__ALSPreficed__Group_4__1" | ||
20172 | // InternalAlloyLanguage.g:7056:1: rule__ALSPreficed__Group_4__1 : rule__ALSPreficed__Group_4__1__Impl rule__ALSPreficed__Group_4__2 ; | ||
20173 | public final void rule__ALSPreficed__Group_4__1() throws RecognitionException { | ||
20174 | |||
20175 | int stackSize = keepStackSize(); | ||
20176 | |||
20177 | try { | ||
20178 | // InternalAlloyLanguage.g:7060:1: ( rule__ALSPreficed__Group_4__1__Impl rule__ALSPreficed__Group_4__2 ) | ||
20179 | // InternalAlloyLanguage.g:7061:2: rule__ALSPreficed__Group_4__1__Impl rule__ALSPreficed__Group_4__2 | ||
20180 | { | ||
20181 | pushFollow(FOLLOW_16); | ||
20182 | rule__ALSPreficed__Group_4__1__Impl(); | ||
20183 | |||
20184 | state._fsp--; | ||
20185 | if (state.failed) return ; | ||
20186 | pushFollow(FOLLOW_2); | ||
20187 | rule__ALSPreficed__Group_4__2(); | ||
20188 | |||
20189 | state._fsp--; | ||
20190 | if (state.failed) return ; | ||
20191 | |||
20192 | } | ||
20193 | |||
20194 | } | ||
20195 | catch (RecognitionException re) { | ||
20196 | reportError(re); | ||
20197 | recover(input,re); | ||
20198 | } | ||
20199 | finally { | ||
20200 | |||
20201 | restoreStackSize(stackSize); | ||
20202 | |||
20203 | } | ||
20204 | return ; | ||
20205 | } | ||
20206 | // $ANTLR end "rule__ALSPreficed__Group_4__1" | ||
20207 | |||
20208 | |||
20209 | // $ANTLR start "rule__ALSPreficed__Group_4__1__Impl" | ||
20210 | // InternalAlloyLanguage.g:7068:1: rule__ALSPreficed__Group_4__1__Impl : ( '#' ) ; | ||
20211 | public final void rule__ALSPreficed__Group_4__1__Impl() throws RecognitionException { | ||
20212 | |||
20213 | int stackSize = keepStackSize(); | ||
20214 | |||
20215 | try { | ||
20216 | // InternalAlloyLanguage.g:7072:1: ( ( '#' ) ) | ||
20217 | // InternalAlloyLanguage.g:7073:1: ( '#' ) | ||
20218 | { | ||
20219 | // InternalAlloyLanguage.g:7073:1: ( '#' ) | ||
20220 | // InternalAlloyLanguage.g:7074:1: '#' | ||
20221 | { | ||
20222 | if ( state.backtracking==0 ) { | ||
20223 | before(grammarAccess.getALSPreficedAccess().getNumberSignKeyword_4_1()); | ||
20224 | } | ||
20225 | match(input,63,FOLLOW_2); if (state.failed) return ; | ||
20226 | if ( state.backtracking==0 ) { | ||
20227 | after(grammarAccess.getALSPreficedAccess().getNumberSignKeyword_4_1()); | ||
20228 | } | ||
20229 | |||
20230 | } | ||
20231 | |||
20232 | |||
20233 | } | ||
20234 | |||
20235 | } | ||
20236 | catch (RecognitionException re) { | ||
20237 | reportError(re); | ||
20238 | recover(input,re); | ||
20239 | } | ||
20240 | finally { | ||
20241 | |||
20242 | restoreStackSize(stackSize); | ||
20243 | |||
20244 | } | ||
20245 | return ; | ||
20246 | } | ||
20247 | // $ANTLR end "rule__ALSPreficed__Group_4__1__Impl" | ||
20248 | |||
20249 | |||
20250 | // $ANTLR start "rule__ALSPreficed__Group_4__2" | ||
20251 | // InternalAlloyLanguage.g:7087:1: rule__ALSPreficed__Group_4__2 : rule__ALSPreficed__Group_4__2__Impl ; | ||
20252 | public final void rule__ALSPreficed__Group_4__2() throws RecognitionException { | ||
20253 | |||
20254 | int stackSize = keepStackSize(); | ||
20255 | |||
20256 | try { | ||
20257 | // InternalAlloyLanguage.g:7091:1: ( rule__ALSPreficed__Group_4__2__Impl ) | ||
20258 | // InternalAlloyLanguage.g:7092:2: rule__ALSPreficed__Group_4__2__Impl | ||
20259 | { | ||
20260 | pushFollow(FOLLOW_2); | ||
20261 | rule__ALSPreficed__Group_4__2__Impl(); | ||
20262 | |||
20263 | state._fsp--; | ||
20264 | if (state.failed) return ; | ||
20265 | |||
20266 | } | ||
20267 | |||
20268 | } | ||
20269 | catch (RecognitionException re) { | ||
20270 | reportError(re); | ||
20271 | recover(input,re); | ||
20272 | } | ||
20273 | finally { | ||
20274 | |||
20275 | restoreStackSize(stackSize); | ||
20276 | |||
20277 | } | ||
20278 | return ; | ||
20279 | } | ||
20280 | // $ANTLR end "rule__ALSPreficed__Group_4__2" | ||
20281 | |||
20282 | |||
20283 | // $ANTLR start "rule__ALSPreficed__Group_4__2__Impl" | ||
20284 | // InternalAlloyLanguage.g:7098:1: rule__ALSPreficed__Group_4__2__Impl : ( ( rule__ALSPreficed__OperandAssignment_4_2 ) ) ; | ||
20285 | public final void rule__ALSPreficed__Group_4__2__Impl() throws RecognitionException { | ||
20286 | |||
20287 | int stackSize = keepStackSize(); | ||
20288 | |||
20289 | try { | ||
20290 | // InternalAlloyLanguage.g:7102:1: ( ( ( rule__ALSPreficed__OperandAssignment_4_2 ) ) ) | ||
20291 | // InternalAlloyLanguage.g:7103:1: ( ( rule__ALSPreficed__OperandAssignment_4_2 ) ) | ||
20292 | { | ||
20293 | // InternalAlloyLanguage.g:7103:1: ( ( rule__ALSPreficed__OperandAssignment_4_2 ) ) | ||
20294 | // InternalAlloyLanguage.g:7104:1: ( rule__ALSPreficed__OperandAssignment_4_2 ) | ||
20295 | { | ||
20296 | if ( state.backtracking==0 ) { | ||
20297 | before(grammarAccess.getALSPreficedAccess().getOperandAssignment_4_2()); | ||
20298 | } | ||
20299 | // InternalAlloyLanguage.g:7105:1: ( rule__ALSPreficed__OperandAssignment_4_2 ) | ||
20300 | // InternalAlloyLanguage.g:7105:2: rule__ALSPreficed__OperandAssignment_4_2 | ||
20301 | { | ||
20302 | pushFollow(FOLLOW_2); | ||
20303 | rule__ALSPreficed__OperandAssignment_4_2(); | ||
20304 | |||
20305 | state._fsp--; | ||
20306 | if (state.failed) return ; | ||
20307 | |||
20308 | } | ||
20309 | |||
20310 | if ( state.backtracking==0 ) { | ||
20311 | after(grammarAccess.getALSPreficedAccess().getOperandAssignment_4_2()); | ||
20312 | } | ||
20313 | |||
20314 | } | ||
20315 | |||
20316 | |||
20317 | } | ||
20318 | |||
20319 | } | ||
20320 | catch (RecognitionException re) { | ||
20321 | reportError(re); | ||
20322 | recover(input,re); | ||
20323 | } | ||
20324 | finally { | ||
20325 | |||
20326 | restoreStackSize(stackSize); | ||
20327 | |||
20328 | } | ||
20329 | return ; | ||
20330 | } | ||
20331 | // $ANTLR end "rule__ALSPreficed__Group_4__2__Impl" | ||
20332 | |||
20333 | |||
20334 | // $ANTLR start "rule__ALSPreficed__Group_5__0" | ||
20335 | // InternalAlloyLanguage.g:7121:1: rule__ALSPreficed__Group_5__0 : rule__ALSPreficed__Group_5__0__Impl rule__ALSPreficed__Group_5__1 ; | ||
20336 | public final void rule__ALSPreficed__Group_5__0() throws RecognitionException { | ||
20337 | |||
20338 | int stackSize = keepStackSize(); | ||
20339 | |||
20340 | try { | ||
20341 | // InternalAlloyLanguage.g:7125:1: ( rule__ALSPreficed__Group_5__0__Impl rule__ALSPreficed__Group_5__1 ) | ||
20342 | // InternalAlloyLanguage.g:7126:2: rule__ALSPreficed__Group_5__0__Impl rule__ALSPreficed__Group_5__1 | ||
20343 | { | ||
20344 | pushFollow(FOLLOW_42); | ||
20345 | rule__ALSPreficed__Group_5__0__Impl(); | ||
20346 | |||
20347 | state._fsp--; | ||
20348 | if (state.failed) return ; | ||
20349 | pushFollow(FOLLOW_2); | ||
20350 | rule__ALSPreficed__Group_5__1(); | ||
20351 | |||
20352 | state._fsp--; | ||
20353 | if (state.failed) return ; | ||
20354 | |||
20355 | } | ||
20356 | |||
20357 | } | ||
20358 | catch (RecognitionException re) { | ||
20359 | reportError(re); | ||
20360 | recover(input,re); | ||
20361 | } | ||
20362 | finally { | ||
20363 | |||
20364 | restoreStackSize(stackSize); | ||
20365 | |||
20366 | } | ||
20367 | return ; | ||
20368 | } | ||
20369 | // $ANTLR end "rule__ALSPreficed__Group_5__0" | ||
20370 | |||
20371 | |||
20372 | // $ANTLR start "rule__ALSPreficed__Group_5__0__Impl" | ||
20373 | // InternalAlloyLanguage.g:7133:1: rule__ALSPreficed__Group_5__0__Impl : ( () ) ; | ||
20374 | public final void rule__ALSPreficed__Group_5__0__Impl() throws RecognitionException { | ||
20375 | |||
20376 | int stackSize = keepStackSize(); | ||
20377 | |||
20378 | try { | ||
20379 | // InternalAlloyLanguage.g:7137:1: ( ( () ) ) | ||
20380 | // InternalAlloyLanguage.g:7138:1: ( () ) | ||
20381 | { | ||
20382 | // InternalAlloyLanguage.g:7138:1: ( () ) | ||
20383 | // InternalAlloyLanguage.g:7139:1: () | ||
20384 | { | ||
20385 | if ( state.backtracking==0 ) { | ||
20386 | before(grammarAccess.getALSPreficedAccess().getALSUnaryMinusAction_5_0()); | ||
20387 | } | ||
20388 | // InternalAlloyLanguage.g:7140:1: () | ||
20389 | // InternalAlloyLanguage.g:7142:1: | ||
20390 | { | ||
20391 | } | ||
20392 | |||
20393 | if ( state.backtracking==0 ) { | ||
20394 | after(grammarAccess.getALSPreficedAccess().getALSUnaryMinusAction_5_0()); | ||
20395 | } | ||
20396 | |||
20397 | } | ||
20398 | |||
20399 | |||
20400 | } | ||
20401 | |||
20402 | } | ||
20403 | finally { | ||
20404 | |||
20405 | restoreStackSize(stackSize); | ||
20406 | |||
20407 | } | ||
20408 | return ; | ||
20409 | } | ||
20410 | // $ANTLR end "rule__ALSPreficed__Group_5__0__Impl" | ||
20411 | |||
20412 | |||
20413 | // $ANTLR start "rule__ALSPreficed__Group_5__1" | ||
20414 | // InternalAlloyLanguage.g:7152:1: rule__ALSPreficed__Group_5__1 : rule__ALSPreficed__Group_5__1__Impl rule__ALSPreficed__Group_5__2 ; | ||
20415 | public final void rule__ALSPreficed__Group_5__1() throws RecognitionException { | ||
20416 | |||
20417 | int stackSize = keepStackSize(); | ||
20418 | |||
20419 | try { | ||
20420 | // InternalAlloyLanguage.g:7156:1: ( rule__ALSPreficed__Group_5__1__Impl rule__ALSPreficed__Group_5__2 ) | ||
20421 | // InternalAlloyLanguage.g:7157:2: rule__ALSPreficed__Group_5__1__Impl rule__ALSPreficed__Group_5__2 | ||
20422 | { | ||
20423 | pushFollow(FOLLOW_16); | ||
20424 | rule__ALSPreficed__Group_5__1__Impl(); | ||
20425 | |||
20426 | state._fsp--; | ||
20427 | if (state.failed) return ; | ||
20428 | pushFollow(FOLLOW_2); | ||
20429 | rule__ALSPreficed__Group_5__2(); | ||
20430 | |||
20431 | state._fsp--; | ||
20432 | if (state.failed) return ; | ||
20433 | |||
20434 | } | ||
20435 | |||
20436 | } | ||
20437 | catch (RecognitionException re) { | ||
20438 | reportError(re); | ||
20439 | recover(input,re); | ||
20440 | } | ||
20441 | finally { | ||
20442 | |||
20443 | restoreStackSize(stackSize); | ||
20444 | |||
20445 | } | ||
20446 | return ; | ||
20447 | } | ||
20448 | // $ANTLR end "rule__ALSPreficed__Group_5__1" | ||
20449 | |||
20450 | |||
20451 | // $ANTLR start "rule__ALSPreficed__Group_5__1__Impl" | ||
20452 | // InternalAlloyLanguage.g:7164:1: rule__ALSPreficed__Group_5__1__Impl : ( ( '-' ) ) ; | ||
20453 | public final void rule__ALSPreficed__Group_5__1__Impl() throws RecognitionException { | ||
20454 | |||
20455 | int stackSize = keepStackSize(); | ||
20456 | |||
20457 | try { | ||
20458 | // InternalAlloyLanguage.g:7168:1: ( ( ( '-' ) ) ) | ||
20459 | // InternalAlloyLanguage.g:7169:1: ( ( '-' ) ) | ||
20460 | { | ||
20461 | // InternalAlloyLanguage.g:7169:1: ( ( '-' ) ) | ||
20462 | // InternalAlloyLanguage.g:7170:1: ( '-' ) | ||
20463 | { | ||
20464 | if ( state.backtracking==0 ) { | ||
20465 | before(grammarAccess.getALSPreficedAccess().getHyphenMinusKeyword_5_1()); | ||
20466 | } | ||
20467 | // InternalAlloyLanguage.g:7171:1: ( '-' ) | ||
20468 | // InternalAlloyLanguage.g:7172:2: '-' | ||
20469 | { | ||
20470 | match(input,57,FOLLOW_2); if (state.failed) return ; | ||
20471 | |||
20472 | } | ||
20473 | |||
20474 | if ( state.backtracking==0 ) { | ||
20475 | after(grammarAccess.getALSPreficedAccess().getHyphenMinusKeyword_5_1()); | ||
20476 | } | ||
20477 | |||
20478 | } | ||
20479 | |||
20480 | |||
20481 | } | ||
20482 | |||
20483 | } | ||
20484 | catch (RecognitionException re) { | ||
20485 | reportError(re); | ||
20486 | recover(input,re); | ||
20487 | } | ||
20488 | finally { | ||
20489 | |||
20490 | restoreStackSize(stackSize); | ||
20491 | |||
20492 | } | ||
20493 | return ; | ||
20494 | } | ||
20495 | // $ANTLR end "rule__ALSPreficed__Group_5__1__Impl" | ||
20496 | |||
20497 | |||
20498 | // $ANTLR start "rule__ALSPreficed__Group_5__2" | ||
20499 | // InternalAlloyLanguage.g:7183:1: rule__ALSPreficed__Group_5__2 : rule__ALSPreficed__Group_5__2__Impl ; | ||
20500 | public final void rule__ALSPreficed__Group_5__2() throws RecognitionException { | ||
20501 | |||
20502 | int stackSize = keepStackSize(); | ||
20503 | |||
20504 | try { | ||
20505 | // InternalAlloyLanguage.g:7187:1: ( rule__ALSPreficed__Group_5__2__Impl ) | ||
20506 | // InternalAlloyLanguage.g:7188:2: rule__ALSPreficed__Group_5__2__Impl | ||
20507 | { | ||
20508 | pushFollow(FOLLOW_2); | ||
20509 | rule__ALSPreficed__Group_5__2__Impl(); | ||
20510 | |||
20511 | state._fsp--; | ||
20512 | if (state.failed) return ; | ||
20513 | |||
20514 | } | ||
20515 | |||
20516 | } | ||
20517 | catch (RecognitionException re) { | ||
20518 | reportError(re); | ||
20519 | recover(input,re); | ||
20520 | } | ||
20521 | finally { | ||
20522 | |||
20523 | restoreStackSize(stackSize); | ||
20524 | |||
20525 | } | ||
20526 | return ; | ||
20527 | } | ||
20528 | // $ANTLR end "rule__ALSPreficed__Group_5__2" | ||
20529 | |||
20530 | |||
20531 | // $ANTLR start "rule__ALSPreficed__Group_5__2__Impl" | ||
20532 | // InternalAlloyLanguage.g:7194:1: rule__ALSPreficed__Group_5__2__Impl : ( ( rule__ALSPreficed__OperandAssignment_5_2 ) ) ; | ||
20533 | public final void rule__ALSPreficed__Group_5__2__Impl() throws RecognitionException { | ||
20534 | |||
20535 | int stackSize = keepStackSize(); | ||
20536 | |||
20537 | try { | ||
20538 | // InternalAlloyLanguage.g:7198:1: ( ( ( rule__ALSPreficed__OperandAssignment_5_2 ) ) ) | ||
20539 | // InternalAlloyLanguage.g:7199:1: ( ( rule__ALSPreficed__OperandAssignment_5_2 ) ) | ||
20540 | { | ||
20541 | // InternalAlloyLanguage.g:7199:1: ( ( rule__ALSPreficed__OperandAssignment_5_2 ) ) | ||
20542 | // InternalAlloyLanguage.g:7200:1: ( rule__ALSPreficed__OperandAssignment_5_2 ) | ||
20543 | { | ||
20544 | if ( state.backtracking==0 ) { | ||
20545 | before(grammarAccess.getALSPreficedAccess().getOperandAssignment_5_2()); | ||
20546 | } | ||
20547 | // InternalAlloyLanguage.g:7201:1: ( rule__ALSPreficed__OperandAssignment_5_2 ) | ||
20548 | // InternalAlloyLanguage.g:7201:2: rule__ALSPreficed__OperandAssignment_5_2 | ||
20549 | { | ||
20550 | pushFollow(FOLLOW_2); | ||
20551 | rule__ALSPreficed__OperandAssignment_5_2(); | ||
20552 | |||
20553 | state._fsp--; | ||
20554 | if (state.failed) return ; | ||
20555 | |||
20556 | } | ||
20557 | |||
20558 | if ( state.backtracking==0 ) { | ||
20559 | after(grammarAccess.getALSPreficedAccess().getOperandAssignment_5_2()); | ||
20560 | } | ||
20561 | |||
20562 | } | ||
20563 | |||
20564 | |||
20565 | } | ||
20566 | |||
20567 | } | ||
20568 | catch (RecognitionException re) { | ||
20569 | reportError(re); | ||
20570 | recover(input,re); | ||
20571 | } | ||
20572 | finally { | ||
20573 | |||
20574 | restoreStackSize(stackSize); | ||
20575 | |||
20576 | } | ||
20577 | return ; | ||
20578 | } | ||
20579 | // $ANTLR end "rule__ALSPreficed__Group_5__2__Impl" | ||
20580 | |||
20581 | |||
20582 | // $ANTLR start "rule__ALSPreficed__Group_6__0" | ||
20583 | // InternalAlloyLanguage.g:7217:1: rule__ALSPreficed__Group_6__0 : rule__ALSPreficed__Group_6__0__Impl rule__ALSPreficed__Group_6__1 ; | ||
20584 | public final void rule__ALSPreficed__Group_6__0() throws RecognitionException { | ||
20585 | |||
20586 | int stackSize = keepStackSize(); | ||
20587 | |||
20588 | try { | ||
20589 | // InternalAlloyLanguage.g:7221:1: ( rule__ALSPreficed__Group_6__0__Impl rule__ALSPreficed__Group_6__1 ) | ||
20590 | // InternalAlloyLanguage.g:7222:2: rule__ALSPreficed__Group_6__0__Impl rule__ALSPreficed__Group_6__1 | ||
20591 | { | ||
20592 | pushFollow(FOLLOW_52); | ||
20593 | rule__ALSPreficed__Group_6__0__Impl(); | ||
20594 | |||
20595 | state._fsp--; | ||
20596 | if (state.failed) return ; | ||
20597 | pushFollow(FOLLOW_2); | ||
20598 | rule__ALSPreficed__Group_6__1(); | ||
20599 | |||
20600 | state._fsp--; | ||
20601 | if (state.failed) return ; | ||
20602 | |||
20603 | } | ||
20604 | |||
20605 | } | ||
20606 | catch (RecognitionException re) { | ||
20607 | reportError(re); | ||
20608 | recover(input,re); | ||
20609 | } | ||
20610 | finally { | ||
20611 | |||
20612 | restoreStackSize(stackSize); | ||
20613 | |||
20614 | } | ||
20615 | return ; | ||
20616 | } | ||
20617 | // $ANTLR end "rule__ALSPreficed__Group_6__0" | ||
20618 | |||
20619 | |||
20620 | // $ANTLR start "rule__ALSPreficed__Group_6__0__Impl" | ||
20621 | // InternalAlloyLanguage.g:7229:1: rule__ALSPreficed__Group_6__0__Impl : ( () ) ; | ||
20622 | public final void rule__ALSPreficed__Group_6__0__Impl() throws RecognitionException { | ||
20623 | |||
20624 | int stackSize = keepStackSize(); | ||
20625 | |||
20626 | try { | ||
20627 | // InternalAlloyLanguage.g:7233:1: ( ( () ) ) | ||
20628 | // InternalAlloyLanguage.g:7234:1: ( () ) | ||
20629 | { | ||
20630 | // InternalAlloyLanguage.g:7234:1: ( () ) | ||
20631 | // InternalAlloyLanguage.g:7235:1: () | ||
20632 | { | ||
20633 | if ( state.backtracking==0 ) { | ||
20634 | before(grammarAccess.getALSPreficedAccess().getALSSumAction_6_0()); | ||
20635 | } | ||
20636 | // InternalAlloyLanguage.g:7236:1: () | ||
20637 | // InternalAlloyLanguage.g:7238:1: | ||
20638 | { | ||
20639 | } | ||
20640 | |||
20641 | if ( state.backtracking==0 ) { | ||
20642 | after(grammarAccess.getALSPreficedAccess().getALSSumAction_6_0()); | ||
20643 | } | ||
20644 | |||
20645 | } | ||
20646 | |||
20647 | |||
20648 | } | ||
20649 | |||
20650 | } | ||
20651 | finally { | ||
20652 | |||
20653 | restoreStackSize(stackSize); | ||
20654 | |||
20655 | } | ||
20656 | return ; | ||
20657 | } | ||
20658 | // $ANTLR end "rule__ALSPreficed__Group_6__0__Impl" | ||
20659 | |||
20660 | |||
20661 | // $ANTLR start "rule__ALSPreficed__Group_6__1" | ||
20662 | // InternalAlloyLanguage.g:7248:1: rule__ALSPreficed__Group_6__1 : rule__ALSPreficed__Group_6__1__Impl rule__ALSPreficed__Group_6__2 ; | ||
20663 | public final void rule__ALSPreficed__Group_6__1() throws RecognitionException { | ||
20664 | |||
20665 | int stackSize = keepStackSize(); | ||
20666 | |||
20667 | try { | ||
20668 | // InternalAlloyLanguage.g:7252:1: ( rule__ALSPreficed__Group_6__1__Impl rule__ALSPreficed__Group_6__2 ) | ||
20669 | // InternalAlloyLanguage.g:7253:2: rule__ALSPreficed__Group_6__1__Impl rule__ALSPreficed__Group_6__2 | ||
20670 | { | ||
20671 | pushFollow(FOLLOW_5); | ||
20672 | rule__ALSPreficed__Group_6__1__Impl(); | ||
20673 | |||
20674 | state._fsp--; | ||
20675 | if (state.failed) return ; | ||
20676 | pushFollow(FOLLOW_2); | ||
20677 | rule__ALSPreficed__Group_6__2(); | ||
20678 | |||
20679 | state._fsp--; | ||
20680 | if (state.failed) return ; | ||
20681 | |||
20682 | } | ||
20683 | |||
20684 | } | ||
20685 | catch (RecognitionException re) { | ||
20686 | reportError(re); | ||
20687 | recover(input,re); | ||
20688 | } | ||
20689 | finally { | ||
20690 | |||
20691 | restoreStackSize(stackSize); | ||
20692 | |||
20693 | } | ||
20694 | return ; | ||
20695 | } | ||
20696 | // $ANTLR end "rule__ALSPreficed__Group_6__1" | ||
20697 | |||
20698 | |||
20699 | // $ANTLR start "rule__ALSPreficed__Group_6__1__Impl" | ||
20700 | // InternalAlloyLanguage.g:7260:1: rule__ALSPreficed__Group_6__1__Impl : ( 'sum' ) ; | ||
20701 | public final void rule__ALSPreficed__Group_6__1__Impl() throws RecognitionException { | ||
20702 | |||
20703 | int stackSize = keepStackSize(); | ||
20704 | |||
20705 | try { | ||
20706 | // InternalAlloyLanguage.g:7264:1: ( ( 'sum' ) ) | ||
20707 | // InternalAlloyLanguage.g:7265:1: ( 'sum' ) | ||
20708 | { | ||
20709 | // InternalAlloyLanguage.g:7265:1: ( 'sum' ) | ||
20710 | // InternalAlloyLanguage.g:7266:1: 'sum' | ||
20711 | { | ||
20712 | if ( state.backtracking==0 ) { | ||
20713 | before(grammarAccess.getALSPreficedAccess().getSumKeyword_6_1()); | ||
20714 | } | ||
20715 | match(input,64,FOLLOW_2); if (state.failed) return ; | ||
20716 | if ( state.backtracking==0 ) { | ||
20717 | after(grammarAccess.getALSPreficedAccess().getSumKeyword_6_1()); | ||
20718 | } | ||
20719 | |||
20720 | } | ||
20721 | |||
20722 | |||
20723 | } | ||
20724 | |||
20725 | } | ||
20726 | catch (RecognitionException re) { | ||
20727 | reportError(re); | ||
20728 | recover(input,re); | ||
20729 | } | ||
20730 | finally { | ||
20731 | |||
20732 | restoreStackSize(stackSize); | ||
20733 | |||
20734 | } | ||
20735 | return ; | ||
20736 | } | ||
20737 | // $ANTLR end "rule__ALSPreficed__Group_6__1__Impl" | ||
20738 | |||
20739 | |||
20740 | // $ANTLR start "rule__ALSPreficed__Group_6__2" | ||
20741 | // InternalAlloyLanguage.g:7279:1: rule__ALSPreficed__Group_6__2 : rule__ALSPreficed__Group_6__2__Impl rule__ALSPreficed__Group_6__3 ; | ||
20742 | public final void rule__ALSPreficed__Group_6__2() throws RecognitionException { | ||
20743 | |||
20744 | int stackSize = keepStackSize(); | ||
20745 | |||
20746 | try { | ||
20747 | // InternalAlloyLanguage.g:7283:1: ( rule__ALSPreficed__Group_6__2__Impl rule__ALSPreficed__Group_6__3 ) | ||
20748 | // InternalAlloyLanguage.g:7284:2: rule__ALSPreficed__Group_6__2__Impl rule__ALSPreficed__Group_6__3 | ||
20749 | { | ||
20750 | pushFollow(FOLLOW_24); | ||
20751 | rule__ALSPreficed__Group_6__2__Impl(); | ||
20752 | |||
20753 | state._fsp--; | ||
20754 | if (state.failed) return ; | ||
20755 | pushFollow(FOLLOW_2); | ||
20756 | rule__ALSPreficed__Group_6__3(); | ||
20757 | |||
20758 | state._fsp--; | ||
20759 | if (state.failed) return ; | ||
20760 | |||
20761 | } | ||
20762 | |||
20763 | } | ||
20764 | catch (RecognitionException re) { | ||
20765 | reportError(re); | ||
20766 | recover(input,re); | ||
20767 | } | ||
20768 | finally { | ||
20769 | |||
20770 | restoreStackSize(stackSize); | ||
20771 | |||
20772 | } | ||
20773 | return ; | ||
20774 | } | ||
20775 | // $ANTLR end "rule__ALSPreficed__Group_6__2" | ||
20776 | |||
20777 | |||
20778 | // $ANTLR start "rule__ALSPreficed__Group_6__2__Impl" | ||
20779 | // InternalAlloyLanguage.g:7291:1: rule__ALSPreficed__Group_6__2__Impl : ( ( rule__ALSPreficed__VariablesAssignment_6_2 ) ) ; | ||
20780 | public final void rule__ALSPreficed__Group_6__2__Impl() throws RecognitionException { | ||
20781 | |||
20782 | int stackSize = keepStackSize(); | ||
20783 | |||
20784 | try { | ||
20785 | // InternalAlloyLanguage.g:7295:1: ( ( ( rule__ALSPreficed__VariablesAssignment_6_2 ) ) ) | ||
20786 | // InternalAlloyLanguage.g:7296:1: ( ( rule__ALSPreficed__VariablesAssignment_6_2 ) ) | ||
20787 | { | ||
20788 | // InternalAlloyLanguage.g:7296:1: ( ( rule__ALSPreficed__VariablesAssignment_6_2 ) ) | ||
20789 | // InternalAlloyLanguage.g:7297:1: ( rule__ALSPreficed__VariablesAssignment_6_2 ) | ||
20790 | { | ||
20791 | if ( state.backtracking==0 ) { | ||
20792 | before(grammarAccess.getALSPreficedAccess().getVariablesAssignment_6_2()); | ||
20793 | } | ||
20794 | // InternalAlloyLanguage.g:7298:1: ( rule__ALSPreficed__VariablesAssignment_6_2 ) | ||
20795 | // InternalAlloyLanguage.g:7298:2: rule__ALSPreficed__VariablesAssignment_6_2 | ||
20796 | { | ||
20797 | pushFollow(FOLLOW_2); | ||
20798 | rule__ALSPreficed__VariablesAssignment_6_2(); | ||
20799 | |||
20800 | state._fsp--; | ||
20801 | if (state.failed) return ; | ||
20802 | |||
20803 | } | ||
20804 | |||
20805 | if ( state.backtracking==0 ) { | ||
20806 | after(grammarAccess.getALSPreficedAccess().getVariablesAssignment_6_2()); | ||
20807 | } | ||
20808 | |||
20809 | } | ||
20810 | |||
20811 | |||
20812 | } | ||
20813 | |||
20814 | } | ||
20815 | catch (RecognitionException re) { | ||
20816 | reportError(re); | ||
20817 | recover(input,re); | ||
20818 | } | ||
20819 | finally { | ||
20820 | |||
20821 | restoreStackSize(stackSize); | ||
20822 | |||
20823 | } | ||
20824 | return ; | ||
20825 | } | ||
20826 | // $ANTLR end "rule__ALSPreficed__Group_6__2__Impl" | ||
20827 | |||
20828 | |||
20829 | // $ANTLR start "rule__ALSPreficed__Group_6__3" | ||
20830 | // InternalAlloyLanguage.g:7308:1: rule__ALSPreficed__Group_6__3 : rule__ALSPreficed__Group_6__3__Impl rule__ALSPreficed__Group_6__4 ; | ||
20831 | public final void rule__ALSPreficed__Group_6__3() throws RecognitionException { | ||
20832 | |||
20833 | int stackSize = keepStackSize(); | ||
20834 | |||
20835 | try { | ||
20836 | // InternalAlloyLanguage.g:7312:1: ( rule__ALSPreficed__Group_6__3__Impl rule__ALSPreficed__Group_6__4 ) | ||
20837 | // InternalAlloyLanguage.g:7313:2: rule__ALSPreficed__Group_6__3__Impl rule__ALSPreficed__Group_6__4 | ||
20838 | { | ||
20839 | pushFollow(FOLLOW_24); | ||
20840 | rule__ALSPreficed__Group_6__3__Impl(); | ||
20841 | |||
20842 | state._fsp--; | ||
20843 | if (state.failed) return ; | ||
20844 | pushFollow(FOLLOW_2); | ||
20845 | rule__ALSPreficed__Group_6__4(); | ||
20846 | |||
20847 | state._fsp--; | ||
20848 | if (state.failed) return ; | ||
20849 | |||
20850 | } | ||
20851 | |||
20852 | } | ||
20853 | catch (RecognitionException re) { | ||
20854 | reportError(re); | ||
20855 | recover(input,re); | ||
20856 | } | ||
20857 | finally { | ||
20858 | |||
20859 | restoreStackSize(stackSize); | ||
20860 | |||
20861 | } | ||
20862 | return ; | ||
20863 | } | ||
20864 | // $ANTLR end "rule__ALSPreficed__Group_6__3" | ||
20865 | |||
20866 | |||
20867 | // $ANTLR start "rule__ALSPreficed__Group_6__3__Impl" | ||
20868 | // InternalAlloyLanguage.g:7320:1: rule__ALSPreficed__Group_6__3__Impl : ( ( rule__ALSPreficed__Group_6_3__0 )* ) ; | ||
20869 | public final void rule__ALSPreficed__Group_6__3__Impl() throws RecognitionException { | ||
20870 | |||
20871 | int stackSize = keepStackSize(); | ||
20872 | |||
20873 | try { | ||
20874 | // InternalAlloyLanguage.g:7324:1: ( ( ( rule__ALSPreficed__Group_6_3__0 )* ) ) | ||
20875 | // InternalAlloyLanguage.g:7325:1: ( ( rule__ALSPreficed__Group_6_3__0 )* ) | ||
20876 | { | ||
20877 | // InternalAlloyLanguage.g:7325:1: ( ( rule__ALSPreficed__Group_6_3__0 )* ) | ||
20878 | // InternalAlloyLanguage.g:7326:1: ( rule__ALSPreficed__Group_6_3__0 )* | ||
20879 | { | ||
20880 | if ( state.backtracking==0 ) { | ||
20881 | before(grammarAccess.getALSPreficedAccess().getGroup_6_3()); | ||
20882 | } | ||
20883 | // InternalAlloyLanguage.g:7327:1: ( rule__ALSPreficed__Group_6_3__0 )* | ||
20884 | loop46: | ||
20885 | do { | ||
20886 | int alt46=2; | ||
20887 | int LA46_0 = input.LA(1); | ||
20888 | |||
20889 | if ( (LA46_0==35) ) { | ||
20890 | alt46=1; | ||
20891 | } | ||
20892 | |||
20893 | |||
20894 | switch (alt46) { | ||
20895 | case 1 : | ||
20896 | // InternalAlloyLanguage.g:7327:2: rule__ALSPreficed__Group_6_3__0 | ||
20897 | { | ||
20898 | pushFollow(FOLLOW_8); | ||
20899 | rule__ALSPreficed__Group_6_3__0(); | ||
20900 | |||
20901 | state._fsp--; | ||
20902 | if (state.failed) return ; | ||
20903 | |||
20904 | } | ||
20905 | break; | ||
20906 | |||
20907 | default : | ||
20908 | break loop46; | ||
20909 | } | ||
20910 | } while (true); | ||
20911 | |||
20912 | if ( state.backtracking==0 ) { | ||
20913 | after(grammarAccess.getALSPreficedAccess().getGroup_6_3()); | ||
20914 | } | ||
20915 | |||
20916 | } | ||
20917 | |||
20918 | |||
20919 | } | ||
20920 | |||
20921 | } | ||
20922 | catch (RecognitionException re) { | ||
20923 | reportError(re); | ||
20924 | recover(input,re); | ||
20925 | } | ||
20926 | finally { | ||
20927 | |||
20928 | restoreStackSize(stackSize); | ||
20929 | |||
20930 | } | ||
20931 | return ; | ||
20932 | } | ||
20933 | // $ANTLR end "rule__ALSPreficed__Group_6__3__Impl" | ||
20934 | |||
20935 | |||
20936 | // $ANTLR start "rule__ALSPreficed__Group_6__4" | ||
20937 | // InternalAlloyLanguage.g:7337:1: rule__ALSPreficed__Group_6__4 : rule__ALSPreficed__Group_6__4__Impl rule__ALSPreficed__Group_6__5 ; | ||
20938 | public final void rule__ALSPreficed__Group_6__4() throws RecognitionException { | ||
20939 | |||
20940 | int stackSize = keepStackSize(); | ||
20941 | |||
20942 | try { | ||
20943 | // InternalAlloyLanguage.g:7341:1: ( rule__ALSPreficed__Group_6__4__Impl rule__ALSPreficed__Group_6__5 ) | ||
20944 | // InternalAlloyLanguage.g:7342:2: rule__ALSPreficed__Group_6__4__Impl rule__ALSPreficed__Group_6__5 | ||
20945 | { | ||
20946 | pushFollow(FOLLOW_16); | ||
20947 | rule__ALSPreficed__Group_6__4__Impl(); | ||
20948 | |||
20949 | state._fsp--; | ||
20950 | if (state.failed) return ; | ||
20951 | pushFollow(FOLLOW_2); | ||
20952 | rule__ALSPreficed__Group_6__5(); | ||
20953 | |||
20954 | state._fsp--; | ||
20955 | if (state.failed) return ; | ||
20956 | |||
20957 | } | ||
20958 | |||
20959 | } | ||
20960 | catch (RecognitionException re) { | ||
20961 | reportError(re); | ||
20962 | recover(input,re); | ||
20963 | } | ||
20964 | finally { | ||
20965 | |||
20966 | restoreStackSize(stackSize); | ||
20967 | |||
20968 | } | ||
20969 | return ; | ||
20970 | } | ||
20971 | // $ANTLR end "rule__ALSPreficed__Group_6__4" | ||
20972 | |||
20973 | |||
20974 | // $ANTLR start "rule__ALSPreficed__Group_6__4__Impl" | ||
20975 | // InternalAlloyLanguage.g:7349:1: rule__ALSPreficed__Group_6__4__Impl : ( '{' ) ; | ||
20976 | public final void rule__ALSPreficed__Group_6__4__Impl() throws RecognitionException { | ||
20977 | |||
20978 | int stackSize = keepStackSize(); | ||
20979 | |||
20980 | try { | ||
20981 | // InternalAlloyLanguage.g:7353:1: ( ( '{' ) ) | ||
20982 | // InternalAlloyLanguage.g:7354:1: ( '{' ) | ||
20983 | { | ||
20984 | // InternalAlloyLanguage.g:7354:1: ( '{' ) | ||
20985 | // InternalAlloyLanguage.g:7355:1: '{' | ||
20986 | { | ||
20987 | if ( state.backtracking==0 ) { | ||
20988 | before(grammarAccess.getALSPreficedAccess().getLeftCurlyBracketKeyword_6_4()); | ||
20989 | } | ||
20990 | match(input,33,FOLLOW_2); if (state.failed) return ; | ||
20991 | if ( state.backtracking==0 ) { | ||
20992 | after(grammarAccess.getALSPreficedAccess().getLeftCurlyBracketKeyword_6_4()); | ||
20993 | } | ||
20994 | |||
20995 | } | ||
20996 | |||
20997 | |||
20998 | } | ||
20999 | |||
21000 | } | ||
21001 | catch (RecognitionException re) { | ||
21002 | reportError(re); | ||
21003 | recover(input,re); | ||
21004 | } | ||
21005 | finally { | ||
21006 | |||
21007 | restoreStackSize(stackSize); | ||
21008 | |||
21009 | } | ||
21010 | return ; | ||
21011 | } | ||
21012 | // $ANTLR end "rule__ALSPreficed__Group_6__4__Impl" | ||
21013 | |||
21014 | |||
21015 | // $ANTLR start "rule__ALSPreficed__Group_6__5" | ||
21016 | // InternalAlloyLanguage.g:7368:1: rule__ALSPreficed__Group_6__5 : rule__ALSPreficed__Group_6__5__Impl rule__ALSPreficed__Group_6__6 ; | ||
21017 | public final void rule__ALSPreficed__Group_6__5() throws RecognitionException { | ||
21018 | |||
21019 | int stackSize = keepStackSize(); | ||
21020 | |||
21021 | try { | ||
21022 | // InternalAlloyLanguage.g:7372:1: ( rule__ALSPreficed__Group_6__5__Impl rule__ALSPreficed__Group_6__6 ) | ||
21023 | // InternalAlloyLanguage.g:7373:2: rule__ALSPreficed__Group_6__5__Impl rule__ALSPreficed__Group_6__6 | ||
21024 | { | ||
21025 | pushFollow(FOLLOW_19); | ||
21026 | rule__ALSPreficed__Group_6__5__Impl(); | ||
21027 | |||
21028 | state._fsp--; | ||
21029 | if (state.failed) return ; | ||
21030 | pushFollow(FOLLOW_2); | ||
21031 | rule__ALSPreficed__Group_6__6(); | ||
21032 | |||
21033 | state._fsp--; | ||
21034 | if (state.failed) return ; | ||
21035 | |||
21036 | } | ||
21037 | |||
21038 | } | ||
21039 | catch (RecognitionException re) { | ||
21040 | reportError(re); | ||
21041 | recover(input,re); | ||
21042 | } | ||
21043 | finally { | ||
21044 | |||
21045 | restoreStackSize(stackSize); | ||
21046 | |||
21047 | } | ||
21048 | return ; | ||
21049 | } | ||
21050 | // $ANTLR end "rule__ALSPreficed__Group_6__5" | ||
21051 | |||
21052 | |||
21053 | // $ANTLR start "rule__ALSPreficed__Group_6__5__Impl" | ||
21054 | // InternalAlloyLanguage.g:7380:1: rule__ALSPreficed__Group_6__5__Impl : ( ( rule__ALSPreficed__ExpressionAssignment_6_5 ) ) ; | ||
21055 | public final void rule__ALSPreficed__Group_6__5__Impl() throws RecognitionException { | ||
21056 | |||
21057 | int stackSize = keepStackSize(); | ||
21058 | |||
21059 | try { | ||
21060 | // InternalAlloyLanguage.g:7384:1: ( ( ( rule__ALSPreficed__ExpressionAssignment_6_5 ) ) ) | ||
21061 | // InternalAlloyLanguage.g:7385:1: ( ( rule__ALSPreficed__ExpressionAssignment_6_5 ) ) | ||
21062 | { | ||
21063 | // InternalAlloyLanguage.g:7385:1: ( ( rule__ALSPreficed__ExpressionAssignment_6_5 ) ) | ||
21064 | // InternalAlloyLanguage.g:7386:1: ( rule__ALSPreficed__ExpressionAssignment_6_5 ) | ||
21065 | { | ||
21066 | if ( state.backtracking==0 ) { | ||
21067 | before(grammarAccess.getALSPreficedAccess().getExpressionAssignment_6_5()); | ||
21068 | } | ||
21069 | // InternalAlloyLanguage.g:7387:1: ( rule__ALSPreficed__ExpressionAssignment_6_5 ) | ||
21070 | // InternalAlloyLanguage.g:7387:2: rule__ALSPreficed__ExpressionAssignment_6_5 | ||
21071 | { | ||
21072 | pushFollow(FOLLOW_2); | ||
21073 | rule__ALSPreficed__ExpressionAssignment_6_5(); | ||
21074 | |||
21075 | state._fsp--; | ||
21076 | if (state.failed) return ; | ||
21077 | |||
21078 | } | ||
21079 | |||
21080 | if ( state.backtracking==0 ) { | ||
21081 | after(grammarAccess.getALSPreficedAccess().getExpressionAssignment_6_5()); | ||
21082 | } | ||
21083 | |||
21084 | } | ||
21085 | |||
21086 | |||
21087 | } | ||
21088 | |||
21089 | } | ||
21090 | catch (RecognitionException re) { | ||
21091 | reportError(re); | ||
21092 | recover(input,re); | ||
21093 | } | ||
21094 | finally { | ||
21095 | |||
21096 | restoreStackSize(stackSize); | ||
21097 | |||
21098 | } | ||
21099 | return ; | ||
21100 | } | ||
21101 | // $ANTLR end "rule__ALSPreficed__Group_6__5__Impl" | ||
21102 | |||
21103 | |||
21104 | // $ANTLR start "rule__ALSPreficed__Group_6__6" | ||
21105 | // InternalAlloyLanguage.g:7397:1: rule__ALSPreficed__Group_6__6 : rule__ALSPreficed__Group_6__6__Impl ; | ||
21106 | public final void rule__ALSPreficed__Group_6__6() throws RecognitionException { | ||
21107 | |||
21108 | int stackSize = keepStackSize(); | ||
21109 | |||
21110 | try { | ||
21111 | // InternalAlloyLanguage.g:7401:1: ( rule__ALSPreficed__Group_6__6__Impl ) | ||
21112 | // InternalAlloyLanguage.g:7402:2: rule__ALSPreficed__Group_6__6__Impl | ||
21113 | { | ||
21114 | pushFollow(FOLLOW_2); | ||
21115 | rule__ALSPreficed__Group_6__6__Impl(); | ||
21116 | |||
21117 | state._fsp--; | ||
21118 | if (state.failed) return ; | ||
21119 | |||
21120 | } | ||
21121 | |||
21122 | } | ||
21123 | catch (RecognitionException re) { | ||
21124 | reportError(re); | ||
21125 | recover(input,re); | ||
21126 | } | ||
21127 | finally { | ||
21128 | |||
21129 | restoreStackSize(stackSize); | ||
21130 | |||
21131 | } | ||
21132 | return ; | ||
21133 | } | ||
21134 | // $ANTLR end "rule__ALSPreficed__Group_6__6" | ||
21135 | |||
21136 | |||
21137 | // $ANTLR start "rule__ALSPreficed__Group_6__6__Impl" | ||
21138 | // InternalAlloyLanguage.g:7408:1: rule__ALSPreficed__Group_6__6__Impl : ( '}' ) ; | ||
21139 | public final void rule__ALSPreficed__Group_6__6__Impl() throws RecognitionException { | ||
21140 | |||
21141 | int stackSize = keepStackSize(); | ||
21142 | |||
21143 | try { | ||
21144 | // InternalAlloyLanguage.g:7412:1: ( ( '}' ) ) | ||
21145 | // InternalAlloyLanguage.g:7413:1: ( '}' ) | ||
21146 | { | ||
21147 | // InternalAlloyLanguage.g:7413:1: ( '}' ) | ||
21148 | // InternalAlloyLanguage.g:7414:1: '}' | ||
21149 | { | ||
21150 | if ( state.backtracking==0 ) { | ||
21151 | before(grammarAccess.getALSPreficedAccess().getRightCurlyBracketKeyword_6_6()); | ||
21152 | } | ||
21153 | match(input,34,FOLLOW_2); if (state.failed) return ; | ||
21154 | if ( state.backtracking==0 ) { | ||
21155 | after(grammarAccess.getALSPreficedAccess().getRightCurlyBracketKeyword_6_6()); | ||
21156 | } | ||
21157 | |||
21158 | } | ||
21159 | |||
21160 | |||
21161 | } | ||
21162 | |||
21163 | } | ||
21164 | catch (RecognitionException re) { | ||
21165 | reportError(re); | ||
21166 | recover(input,re); | ||
21167 | } | ||
21168 | finally { | ||
21169 | |||
21170 | restoreStackSize(stackSize); | ||
21171 | |||
21172 | } | ||
21173 | return ; | ||
21174 | } | ||
21175 | // $ANTLR end "rule__ALSPreficed__Group_6__6__Impl" | ||
21176 | |||
21177 | |||
21178 | // $ANTLR start "rule__ALSPreficed__Group_6_3__0" | ||
21179 | // InternalAlloyLanguage.g:7441:1: rule__ALSPreficed__Group_6_3__0 : rule__ALSPreficed__Group_6_3__0__Impl rule__ALSPreficed__Group_6_3__1 ; | ||
21180 | public final void rule__ALSPreficed__Group_6_3__0() throws RecognitionException { | ||
21181 | |||
21182 | int stackSize = keepStackSize(); | ||
21183 | |||
21184 | try { | ||
21185 | // InternalAlloyLanguage.g:7445:1: ( rule__ALSPreficed__Group_6_3__0__Impl rule__ALSPreficed__Group_6_3__1 ) | ||
21186 | // InternalAlloyLanguage.g:7446:2: rule__ALSPreficed__Group_6_3__0__Impl rule__ALSPreficed__Group_6_3__1 | ||
21187 | { | ||
21188 | pushFollow(FOLLOW_5); | ||
21189 | rule__ALSPreficed__Group_6_3__0__Impl(); | ||
21190 | |||
21191 | state._fsp--; | ||
21192 | if (state.failed) return ; | ||
21193 | pushFollow(FOLLOW_2); | ||
21194 | rule__ALSPreficed__Group_6_3__1(); | ||
21195 | |||
21196 | state._fsp--; | ||
21197 | if (state.failed) return ; | ||
21198 | |||
21199 | } | ||
21200 | |||
21201 | } | ||
21202 | catch (RecognitionException re) { | ||
21203 | reportError(re); | ||
21204 | recover(input,re); | ||
21205 | } | ||
21206 | finally { | ||
21207 | |||
21208 | restoreStackSize(stackSize); | ||
21209 | |||
21210 | } | ||
21211 | return ; | ||
21212 | } | ||
21213 | // $ANTLR end "rule__ALSPreficed__Group_6_3__0" | ||
21214 | |||
21215 | |||
21216 | // $ANTLR start "rule__ALSPreficed__Group_6_3__0__Impl" | ||
21217 | // InternalAlloyLanguage.g:7453:1: rule__ALSPreficed__Group_6_3__0__Impl : ( ',' ) ; | ||
21218 | public final void rule__ALSPreficed__Group_6_3__0__Impl() throws RecognitionException { | ||
21219 | |||
21220 | int stackSize = keepStackSize(); | ||
21221 | |||
21222 | try { | ||
21223 | // InternalAlloyLanguage.g:7457:1: ( ( ',' ) ) | ||
21224 | // InternalAlloyLanguage.g:7458:1: ( ',' ) | ||
21225 | { | ||
21226 | // InternalAlloyLanguage.g:7458:1: ( ',' ) | ||
21227 | // InternalAlloyLanguage.g:7459:1: ',' | ||
21228 | { | ||
21229 | if ( state.backtracking==0 ) { | ||
21230 | before(grammarAccess.getALSPreficedAccess().getCommaKeyword_6_3_0()); | ||
21231 | } | ||
21232 | match(input,35,FOLLOW_2); if (state.failed) return ; | ||
21233 | if ( state.backtracking==0 ) { | ||
21234 | after(grammarAccess.getALSPreficedAccess().getCommaKeyword_6_3_0()); | ||
21235 | } | ||
21236 | |||
21237 | } | ||
21238 | |||
21239 | |||
21240 | } | ||
21241 | |||
21242 | } | ||
21243 | catch (RecognitionException re) { | ||
21244 | reportError(re); | ||
21245 | recover(input,re); | ||
21246 | } | ||
21247 | finally { | ||
21248 | |||
21249 | restoreStackSize(stackSize); | ||
21250 | |||
21251 | } | ||
21252 | return ; | ||
21253 | } | ||
21254 | // $ANTLR end "rule__ALSPreficed__Group_6_3__0__Impl" | ||
21255 | |||
21256 | |||
21257 | // $ANTLR start "rule__ALSPreficed__Group_6_3__1" | ||
21258 | // InternalAlloyLanguage.g:7472:1: rule__ALSPreficed__Group_6_3__1 : rule__ALSPreficed__Group_6_3__1__Impl ; | ||
21259 | public final void rule__ALSPreficed__Group_6_3__1() throws RecognitionException { | ||
21260 | |||
21261 | int stackSize = keepStackSize(); | ||
21262 | |||
21263 | try { | ||
21264 | // InternalAlloyLanguage.g:7476:1: ( rule__ALSPreficed__Group_6_3__1__Impl ) | ||
21265 | // InternalAlloyLanguage.g:7477:2: rule__ALSPreficed__Group_6_3__1__Impl | ||
21266 | { | ||
21267 | pushFollow(FOLLOW_2); | ||
21268 | rule__ALSPreficed__Group_6_3__1__Impl(); | ||
21269 | |||
21270 | state._fsp--; | ||
21271 | if (state.failed) return ; | ||
21272 | |||
21273 | } | ||
21274 | |||
21275 | } | ||
21276 | catch (RecognitionException re) { | ||
21277 | reportError(re); | ||
21278 | recover(input,re); | ||
21279 | } | ||
21280 | finally { | ||
21281 | |||
21282 | restoreStackSize(stackSize); | ||
21283 | |||
21284 | } | ||
21285 | return ; | ||
21286 | } | ||
21287 | // $ANTLR end "rule__ALSPreficed__Group_6_3__1" | ||
21288 | |||
21289 | |||
21290 | // $ANTLR start "rule__ALSPreficed__Group_6_3__1__Impl" | ||
21291 | // InternalAlloyLanguage.g:7483:1: rule__ALSPreficed__Group_6_3__1__Impl : ( ( rule__ALSPreficed__VariablesAssignment_6_3_1 ) ) ; | ||
21292 | public final void rule__ALSPreficed__Group_6_3__1__Impl() throws RecognitionException { | ||
21293 | |||
21294 | int stackSize = keepStackSize(); | ||
21295 | |||
21296 | try { | ||
21297 | // InternalAlloyLanguage.g:7487:1: ( ( ( rule__ALSPreficed__VariablesAssignment_6_3_1 ) ) ) | ||
21298 | // InternalAlloyLanguage.g:7488:1: ( ( rule__ALSPreficed__VariablesAssignment_6_3_1 ) ) | ||
21299 | { | ||
21300 | // InternalAlloyLanguage.g:7488:1: ( ( rule__ALSPreficed__VariablesAssignment_6_3_1 ) ) | ||
21301 | // InternalAlloyLanguage.g:7489:1: ( rule__ALSPreficed__VariablesAssignment_6_3_1 ) | ||
21302 | { | ||
21303 | if ( state.backtracking==0 ) { | ||
21304 | before(grammarAccess.getALSPreficedAccess().getVariablesAssignment_6_3_1()); | ||
21305 | } | ||
21306 | // InternalAlloyLanguage.g:7490:1: ( rule__ALSPreficed__VariablesAssignment_6_3_1 ) | ||
21307 | // InternalAlloyLanguage.g:7490:2: rule__ALSPreficed__VariablesAssignment_6_3_1 | ||
21308 | { | ||
21309 | pushFollow(FOLLOW_2); | ||
21310 | rule__ALSPreficed__VariablesAssignment_6_3_1(); | ||
21311 | |||
21312 | state._fsp--; | ||
21313 | if (state.failed) return ; | ||
21314 | |||
21315 | } | ||
21316 | |||
21317 | if ( state.backtracking==0 ) { | ||
21318 | after(grammarAccess.getALSPreficedAccess().getVariablesAssignment_6_3_1()); | ||
21319 | } | ||
21320 | |||
21321 | } | ||
21322 | |||
21323 | |||
21324 | } | ||
21325 | |||
21326 | } | ||
21327 | catch (RecognitionException re) { | ||
21328 | reportError(re); | ||
21329 | recover(input,re); | ||
21330 | } | ||
21331 | finally { | ||
21332 | |||
21333 | restoreStackSize(stackSize); | ||
21334 | |||
21335 | } | ||
21336 | return ; | ||
21337 | } | ||
21338 | // $ANTLR end "rule__ALSPreficed__Group_6_3__1__Impl" | ||
21339 | |||
21340 | |||
21341 | // $ANTLR start "rule__ALSPreficed__Group_7__0" | ||
21342 | // InternalAlloyLanguage.g:7504:1: rule__ALSPreficed__Group_7__0 : rule__ALSPreficed__Group_7__0__Impl rule__ALSPreficed__Group_7__1 ; | ||
21343 | public final void rule__ALSPreficed__Group_7__0() throws RecognitionException { | ||
21344 | |||
21345 | int stackSize = keepStackSize(); | ||
21346 | |||
21347 | try { | ||
21348 | // InternalAlloyLanguage.g:7508:1: ( rule__ALSPreficed__Group_7__0__Impl rule__ALSPreficed__Group_7__1 ) | ||
21349 | // InternalAlloyLanguage.g:7509:2: rule__ALSPreficed__Group_7__0__Impl rule__ALSPreficed__Group_7__1 | ||
21350 | { | ||
21351 | pushFollow(FOLLOW_53); | ||
21352 | rule__ALSPreficed__Group_7__0__Impl(); | ||
21353 | |||
21354 | state._fsp--; | ||
21355 | if (state.failed) return ; | ||
21356 | pushFollow(FOLLOW_2); | ||
21357 | rule__ALSPreficed__Group_7__1(); | ||
21358 | |||
21359 | state._fsp--; | ||
21360 | if (state.failed) return ; | ||
21361 | |||
21362 | } | ||
21363 | |||
21364 | } | ||
21365 | catch (RecognitionException re) { | ||
21366 | reportError(re); | ||
21367 | recover(input,re); | ||
21368 | } | ||
21369 | finally { | ||
21370 | |||
21371 | restoreStackSize(stackSize); | ||
21372 | |||
21373 | } | ||
21374 | return ; | ||
21375 | } | ||
21376 | // $ANTLR end "rule__ALSPreficed__Group_7__0" | ||
21377 | |||
21378 | |||
21379 | // $ANTLR start "rule__ALSPreficed__Group_7__0__Impl" | ||
21380 | // InternalAlloyLanguage.g:7516:1: rule__ALSPreficed__Group_7__0__Impl : ( () ) ; | ||
21381 | public final void rule__ALSPreficed__Group_7__0__Impl() throws RecognitionException { | ||
21382 | |||
21383 | int stackSize = keepStackSize(); | ||
21384 | |||
21385 | try { | ||
21386 | // InternalAlloyLanguage.g:7520:1: ( ( () ) ) | ||
21387 | // InternalAlloyLanguage.g:7521:1: ( () ) | ||
21388 | { | ||
21389 | // InternalAlloyLanguage.g:7521:1: ( () ) | ||
21390 | // InternalAlloyLanguage.g:7522:1: () | ||
21391 | { | ||
21392 | if ( state.backtracking==0 ) { | ||
21393 | before(grammarAccess.getALSPreficedAccess().getALSFunctionCallAction_7_0()); | ||
21394 | } | ||
21395 | // InternalAlloyLanguage.g:7523:1: () | ||
21396 | // InternalAlloyLanguage.g:7525:1: | ||
21397 | { | ||
21398 | } | ||
21399 | |||
21400 | if ( state.backtracking==0 ) { | ||
21401 | after(grammarAccess.getALSPreficedAccess().getALSFunctionCallAction_7_0()); | ||
21402 | } | ||
21403 | |||
21404 | } | ||
21405 | |||
21406 | |||
21407 | } | ||
21408 | |||
21409 | } | ||
21410 | finally { | ||
21411 | |||
21412 | restoreStackSize(stackSize); | ||
21413 | |||
21414 | } | ||
21415 | return ; | ||
21416 | } | ||
21417 | // $ANTLR end "rule__ALSPreficed__Group_7__0__Impl" | ||
21418 | |||
21419 | |||
21420 | // $ANTLR start "rule__ALSPreficed__Group_7__1" | ||
21421 | // InternalAlloyLanguage.g:7535:1: rule__ALSPreficed__Group_7__1 : rule__ALSPreficed__Group_7__1__Impl rule__ALSPreficed__Group_7__2 ; | ||
21422 | public final void rule__ALSPreficed__Group_7__1() throws RecognitionException { | ||
21423 | |||
21424 | int stackSize = keepStackSize(); | ||
21425 | |||
21426 | try { | ||
21427 | // InternalAlloyLanguage.g:7539:1: ( rule__ALSPreficed__Group_7__1__Impl rule__ALSPreficed__Group_7__2 ) | ||
21428 | // InternalAlloyLanguage.g:7540:2: rule__ALSPreficed__Group_7__1__Impl rule__ALSPreficed__Group_7__2 | ||
21429 | { | ||
21430 | pushFollow(FOLLOW_17); | ||
21431 | rule__ALSPreficed__Group_7__1__Impl(); | ||
21432 | |||
21433 | state._fsp--; | ||
21434 | if (state.failed) return ; | ||
21435 | pushFollow(FOLLOW_2); | ||
21436 | rule__ALSPreficed__Group_7__2(); | ||
21437 | |||
21438 | state._fsp--; | ||
21439 | if (state.failed) return ; | ||
21440 | |||
21441 | } | ||
21442 | |||
21443 | } | ||
21444 | catch (RecognitionException re) { | ||
21445 | reportError(re); | ||
21446 | recover(input,re); | ||
21447 | } | ||
21448 | finally { | ||
21449 | |||
21450 | restoreStackSize(stackSize); | ||
21451 | |||
21452 | } | ||
21453 | return ; | ||
21454 | } | ||
21455 | // $ANTLR end "rule__ALSPreficed__Group_7__1" | ||
21456 | |||
21457 | |||
21458 | // $ANTLR start "rule__ALSPreficed__Group_7__1__Impl" | ||
21459 | // InternalAlloyLanguage.g:7547:1: rule__ALSPreficed__Group_7__1__Impl : ( ( rule__ALSPreficed__Alternatives_7_1 ) ) ; | ||
21460 | public final void rule__ALSPreficed__Group_7__1__Impl() throws RecognitionException { | ||
21461 | |||
21462 | int stackSize = keepStackSize(); | ||
21463 | |||
21464 | try { | ||
21465 | // InternalAlloyLanguage.g:7551:1: ( ( ( rule__ALSPreficed__Alternatives_7_1 ) ) ) | ||
21466 | // InternalAlloyLanguage.g:7552:1: ( ( rule__ALSPreficed__Alternatives_7_1 ) ) | ||
21467 | { | ||
21468 | // InternalAlloyLanguage.g:7552:1: ( ( rule__ALSPreficed__Alternatives_7_1 ) ) | ||
21469 | // InternalAlloyLanguage.g:7553:1: ( rule__ALSPreficed__Alternatives_7_1 ) | ||
21470 | { | ||
21471 | if ( state.backtracking==0 ) { | ||
21472 | before(grammarAccess.getALSPreficedAccess().getAlternatives_7_1()); | ||
21473 | } | ||
21474 | // InternalAlloyLanguage.g:7554:1: ( rule__ALSPreficed__Alternatives_7_1 ) | ||
21475 | // InternalAlloyLanguage.g:7554:2: rule__ALSPreficed__Alternatives_7_1 | ||
21476 | { | ||
21477 | pushFollow(FOLLOW_2); | ||
21478 | rule__ALSPreficed__Alternatives_7_1(); | ||
21479 | |||
21480 | state._fsp--; | ||
21481 | if (state.failed) return ; | ||
21482 | |||
21483 | } | ||
21484 | |||
21485 | if ( state.backtracking==0 ) { | ||
21486 | after(grammarAccess.getALSPreficedAccess().getAlternatives_7_1()); | ||
21487 | } | ||
21488 | |||
21489 | } | ||
21490 | |||
21491 | |||
21492 | } | ||
21493 | |||
21494 | } | ||
21495 | catch (RecognitionException re) { | ||
21496 | reportError(re); | ||
21497 | recover(input,re); | ||
21498 | } | ||
21499 | finally { | ||
21500 | |||
21501 | restoreStackSize(stackSize); | ||
21502 | |||
21503 | } | ||
21504 | return ; | ||
21505 | } | ||
21506 | // $ANTLR end "rule__ALSPreficed__Group_7__1__Impl" | ||
21507 | |||
21508 | |||
21509 | // $ANTLR start "rule__ALSPreficed__Group_7__2" | ||
21510 | // InternalAlloyLanguage.g:7564:1: rule__ALSPreficed__Group_7__2 : rule__ALSPreficed__Group_7__2__Impl rule__ALSPreficed__Group_7__3 ; | ||
21511 | public final void rule__ALSPreficed__Group_7__2() throws RecognitionException { | ||
21512 | |||
21513 | int stackSize = keepStackSize(); | ||
21514 | |||
21515 | try { | ||
21516 | // InternalAlloyLanguage.g:7568:1: ( rule__ALSPreficed__Group_7__2__Impl rule__ALSPreficed__Group_7__3 ) | ||
21517 | // InternalAlloyLanguage.g:7569:2: rule__ALSPreficed__Group_7__2__Impl rule__ALSPreficed__Group_7__3 | ||
21518 | { | ||
21519 | pushFollow(FOLLOW_16); | ||
21520 | rule__ALSPreficed__Group_7__2__Impl(); | ||
21521 | |||
21522 | state._fsp--; | ||
21523 | if (state.failed) return ; | ||
21524 | pushFollow(FOLLOW_2); | ||
21525 | rule__ALSPreficed__Group_7__3(); | ||
21526 | |||
21527 | state._fsp--; | ||
21528 | if (state.failed) return ; | ||
21529 | |||
21530 | } | ||
21531 | |||
21532 | } | ||
21533 | catch (RecognitionException re) { | ||
21534 | reportError(re); | ||
21535 | recover(input,re); | ||
21536 | } | ||
21537 | finally { | ||
21538 | |||
21539 | restoreStackSize(stackSize); | ||
21540 | |||
21541 | } | ||
21542 | return ; | ||
21543 | } | ||
21544 | // $ANTLR end "rule__ALSPreficed__Group_7__2" | ||
21545 | |||
21546 | |||
21547 | // $ANTLR start "rule__ALSPreficed__Group_7__2__Impl" | ||
21548 | // InternalAlloyLanguage.g:7576:1: rule__ALSPreficed__Group_7__2__Impl : ( '[' ) ; | ||
21549 | public final void rule__ALSPreficed__Group_7__2__Impl() throws RecognitionException { | ||
21550 | |||
21551 | int stackSize = keepStackSize(); | ||
21552 | |||
21553 | try { | ||
21554 | // InternalAlloyLanguage.g:7580:1: ( ( '[' ) ) | ||
21555 | // InternalAlloyLanguage.g:7581:1: ( '[' ) | ||
21556 | { | ||
21557 | // InternalAlloyLanguage.g:7581:1: ( '[' ) | ||
21558 | // InternalAlloyLanguage.g:7582:1: '[' | ||
21559 | { | ||
21560 | if ( state.backtracking==0 ) { | ||
21561 | before(grammarAccess.getALSPreficedAccess().getLeftSquareBracketKeyword_7_2()); | ||
21562 | } | ||
21563 | match(input,42,FOLLOW_2); if (state.failed) return ; | ||
21564 | if ( state.backtracking==0 ) { | ||
21565 | after(grammarAccess.getALSPreficedAccess().getLeftSquareBracketKeyword_7_2()); | ||
21566 | } | ||
21567 | |||
21568 | } | ||
21569 | |||
21570 | |||
21571 | } | ||
21572 | |||
21573 | } | ||
21574 | catch (RecognitionException re) { | ||
21575 | reportError(re); | ||
21576 | recover(input,re); | ||
21577 | } | ||
21578 | finally { | ||
21579 | |||
21580 | restoreStackSize(stackSize); | ||
21581 | |||
21582 | } | ||
21583 | return ; | ||
21584 | } | ||
21585 | // $ANTLR end "rule__ALSPreficed__Group_7__2__Impl" | ||
21586 | |||
21587 | |||
21588 | // $ANTLR start "rule__ALSPreficed__Group_7__3" | ||
21589 | // InternalAlloyLanguage.g:7595:1: rule__ALSPreficed__Group_7__3 : rule__ALSPreficed__Group_7__3__Impl rule__ALSPreficed__Group_7__4 ; | ||
21590 | public final void rule__ALSPreficed__Group_7__3() throws RecognitionException { | ||
21591 | |||
21592 | int stackSize = keepStackSize(); | ||
21593 | |||
21594 | try { | ||
21595 | // InternalAlloyLanguage.g:7599:1: ( rule__ALSPreficed__Group_7__3__Impl rule__ALSPreficed__Group_7__4 ) | ||
21596 | // InternalAlloyLanguage.g:7600:2: rule__ALSPreficed__Group_7__3__Impl rule__ALSPreficed__Group_7__4 | ||
21597 | { | ||
21598 | pushFollow(FOLLOW_18); | ||
21599 | rule__ALSPreficed__Group_7__3__Impl(); | ||
21600 | |||
21601 | state._fsp--; | ||
21602 | if (state.failed) return ; | ||
21603 | pushFollow(FOLLOW_2); | ||
21604 | rule__ALSPreficed__Group_7__4(); | ||
21605 | |||
21606 | state._fsp--; | ||
21607 | if (state.failed) return ; | ||
21608 | |||
21609 | } | ||
21610 | |||
21611 | } | ||
21612 | catch (RecognitionException re) { | ||
21613 | reportError(re); | ||
21614 | recover(input,re); | ||
21615 | } | ||
21616 | finally { | ||
21617 | |||
21618 | restoreStackSize(stackSize); | ||
21619 | |||
21620 | } | ||
21621 | return ; | ||
21622 | } | ||
21623 | // $ANTLR end "rule__ALSPreficed__Group_7__3" | ||
21624 | |||
21625 | |||
21626 | // $ANTLR start "rule__ALSPreficed__Group_7__3__Impl" | ||
21627 | // InternalAlloyLanguage.g:7607:1: rule__ALSPreficed__Group_7__3__Impl : ( ( rule__ALSPreficed__ParamsAssignment_7_3 ) ) ; | ||
21628 | public final void rule__ALSPreficed__Group_7__3__Impl() throws RecognitionException { | ||
21629 | |||
21630 | int stackSize = keepStackSize(); | ||
21631 | |||
21632 | try { | ||
21633 | // InternalAlloyLanguage.g:7611:1: ( ( ( rule__ALSPreficed__ParamsAssignment_7_3 ) ) ) | ||
21634 | // InternalAlloyLanguage.g:7612:1: ( ( rule__ALSPreficed__ParamsAssignment_7_3 ) ) | ||
21635 | { | ||
21636 | // InternalAlloyLanguage.g:7612:1: ( ( rule__ALSPreficed__ParamsAssignment_7_3 ) ) | ||
21637 | // InternalAlloyLanguage.g:7613:1: ( rule__ALSPreficed__ParamsAssignment_7_3 ) | ||
21638 | { | ||
21639 | if ( state.backtracking==0 ) { | ||
21640 | before(grammarAccess.getALSPreficedAccess().getParamsAssignment_7_3()); | ||
21641 | } | ||
21642 | // InternalAlloyLanguage.g:7614:1: ( rule__ALSPreficed__ParamsAssignment_7_3 ) | ||
21643 | // InternalAlloyLanguage.g:7614:2: rule__ALSPreficed__ParamsAssignment_7_3 | ||
21644 | { | ||
21645 | pushFollow(FOLLOW_2); | ||
21646 | rule__ALSPreficed__ParamsAssignment_7_3(); | ||
21647 | |||
21648 | state._fsp--; | ||
21649 | if (state.failed) return ; | ||
21650 | |||
21651 | } | ||
21652 | |||
21653 | if ( state.backtracking==0 ) { | ||
21654 | after(grammarAccess.getALSPreficedAccess().getParamsAssignment_7_3()); | ||
21655 | } | ||
21656 | |||
21657 | } | ||
21658 | |||
21659 | |||
21660 | } | ||
21661 | |||
21662 | } | ||
21663 | catch (RecognitionException re) { | ||
21664 | reportError(re); | ||
21665 | recover(input,re); | ||
21666 | } | ||
21667 | finally { | ||
21668 | |||
21669 | restoreStackSize(stackSize); | ||
21670 | |||
21671 | } | ||
21672 | return ; | ||
21673 | } | ||
21674 | // $ANTLR end "rule__ALSPreficed__Group_7__3__Impl" | ||
21675 | |||
21676 | |||
21677 | // $ANTLR start "rule__ALSPreficed__Group_7__4" | ||
21678 | // InternalAlloyLanguage.g:7624:1: rule__ALSPreficed__Group_7__4 : rule__ALSPreficed__Group_7__4__Impl rule__ALSPreficed__Group_7__5 ; | ||
21679 | public final void rule__ALSPreficed__Group_7__4() throws RecognitionException { | ||
21680 | |||
21681 | int stackSize = keepStackSize(); | ||
21682 | |||
21683 | try { | ||
21684 | // InternalAlloyLanguage.g:7628:1: ( rule__ALSPreficed__Group_7__4__Impl rule__ALSPreficed__Group_7__5 ) | ||
21685 | // InternalAlloyLanguage.g:7629:2: rule__ALSPreficed__Group_7__4__Impl rule__ALSPreficed__Group_7__5 | ||
21686 | { | ||
21687 | pushFollow(FOLLOW_18); | ||
21688 | rule__ALSPreficed__Group_7__4__Impl(); | ||
21689 | |||
21690 | state._fsp--; | ||
21691 | if (state.failed) return ; | ||
21692 | pushFollow(FOLLOW_2); | ||
21693 | rule__ALSPreficed__Group_7__5(); | ||
21694 | |||
21695 | state._fsp--; | ||
21696 | if (state.failed) return ; | ||
21697 | |||
21698 | } | ||
21699 | |||
21700 | } | ||
21701 | catch (RecognitionException re) { | ||
21702 | reportError(re); | ||
21703 | recover(input,re); | ||
21704 | } | ||
21705 | finally { | ||
21706 | |||
21707 | restoreStackSize(stackSize); | ||
21708 | |||
21709 | } | ||
21710 | return ; | ||
21711 | } | ||
21712 | // $ANTLR end "rule__ALSPreficed__Group_7__4" | ||
21713 | |||
21714 | |||
21715 | // $ANTLR start "rule__ALSPreficed__Group_7__4__Impl" | ||
21716 | // InternalAlloyLanguage.g:7636:1: rule__ALSPreficed__Group_7__4__Impl : ( ( rule__ALSPreficed__Group_7_4__0 )* ) ; | ||
21717 | public final void rule__ALSPreficed__Group_7__4__Impl() throws RecognitionException { | ||
21718 | |||
21719 | int stackSize = keepStackSize(); | ||
21720 | |||
21721 | try { | ||
21722 | // InternalAlloyLanguage.g:7640:1: ( ( ( rule__ALSPreficed__Group_7_4__0 )* ) ) | ||
21723 | // InternalAlloyLanguage.g:7641:1: ( ( rule__ALSPreficed__Group_7_4__0 )* ) | ||
21724 | { | ||
21725 | // InternalAlloyLanguage.g:7641:1: ( ( rule__ALSPreficed__Group_7_4__0 )* ) | ||
21726 | // InternalAlloyLanguage.g:7642:1: ( rule__ALSPreficed__Group_7_4__0 )* | ||
21727 | { | ||
21728 | if ( state.backtracking==0 ) { | ||
21729 | before(grammarAccess.getALSPreficedAccess().getGroup_7_4()); | ||
21730 | } | ||
21731 | // InternalAlloyLanguage.g:7643:1: ( rule__ALSPreficed__Group_7_4__0 )* | ||
21732 | loop47: | ||
21733 | do { | ||
21734 | int alt47=2; | ||
21735 | int LA47_0 = input.LA(1); | ||
21736 | |||
21737 | if ( (LA47_0==35) ) { | ||
21738 | alt47=1; | ||
21739 | } | ||
21740 | |||
21741 | |||
21742 | switch (alt47) { | ||
21743 | case 1 : | ||
21744 | // InternalAlloyLanguage.g:7643:2: rule__ALSPreficed__Group_7_4__0 | ||
21745 | { | ||
21746 | pushFollow(FOLLOW_8); | ||
21747 | rule__ALSPreficed__Group_7_4__0(); | ||
21748 | |||
21749 | state._fsp--; | ||
21750 | if (state.failed) return ; | ||
21751 | |||
21752 | } | ||
21753 | break; | ||
21754 | |||
21755 | default : | ||
21756 | break loop47; | ||
21757 | } | ||
21758 | } while (true); | ||
21759 | |||
21760 | if ( state.backtracking==0 ) { | ||
21761 | after(grammarAccess.getALSPreficedAccess().getGroup_7_4()); | ||
21762 | } | ||
21763 | |||
21764 | } | ||
21765 | |||
21766 | |||
21767 | } | ||
21768 | |||
21769 | } | ||
21770 | catch (RecognitionException re) { | ||
21771 | reportError(re); | ||
21772 | recover(input,re); | ||
21773 | } | ||
21774 | finally { | ||
21775 | |||
21776 | restoreStackSize(stackSize); | ||
21777 | |||
21778 | } | ||
21779 | return ; | ||
21780 | } | ||
21781 | // $ANTLR end "rule__ALSPreficed__Group_7__4__Impl" | ||
21782 | |||
21783 | |||
21784 | // $ANTLR start "rule__ALSPreficed__Group_7__5" | ||
21785 | // InternalAlloyLanguage.g:7653:1: rule__ALSPreficed__Group_7__5 : rule__ALSPreficed__Group_7__5__Impl ; | ||
21786 | public final void rule__ALSPreficed__Group_7__5() throws RecognitionException { | ||
21787 | |||
21788 | int stackSize = keepStackSize(); | ||
21789 | |||
21790 | try { | ||
21791 | // InternalAlloyLanguage.g:7657:1: ( rule__ALSPreficed__Group_7__5__Impl ) | ||
21792 | // InternalAlloyLanguage.g:7658:2: rule__ALSPreficed__Group_7__5__Impl | ||
21793 | { | ||
21794 | pushFollow(FOLLOW_2); | ||
21795 | rule__ALSPreficed__Group_7__5__Impl(); | ||
21796 | |||
21797 | state._fsp--; | ||
21798 | if (state.failed) return ; | ||
21799 | |||
21800 | } | ||
21801 | |||
21802 | } | ||
21803 | catch (RecognitionException re) { | ||
21804 | reportError(re); | ||
21805 | recover(input,re); | ||
21806 | } | ||
21807 | finally { | ||
21808 | |||
21809 | restoreStackSize(stackSize); | ||
21810 | |||
21811 | } | ||
21812 | return ; | ||
21813 | } | ||
21814 | // $ANTLR end "rule__ALSPreficed__Group_7__5" | ||
21815 | |||
21816 | |||
21817 | // $ANTLR start "rule__ALSPreficed__Group_7__5__Impl" | ||
21818 | // InternalAlloyLanguage.g:7664:1: rule__ALSPreficed__Group_7__5__Impl : ( ']' ) ; | ||
21819 | public final void rule__ALSPreficed__Group_7__5__Impl() throws RecognitionException { | ||
21820 | |||
21821 | int stackSize = keepStackSize(); | ||
21822 | |||
21823 | try { | ||
21824 | // InternalAlloyLanguage.g:7668:1: ( ( ']' ) ) | ||
21825 | // InternalAlloyLanguage.g:7669:1: ( ']' ) | ||
21826 | { | ||
21827 | // InternalAlloyLanguage.g:7669:1: ( ']' ) | ||
21828 | // InternalAlloyLanguage.g:7670:1: ']' | ||
21829 | { | ||
21830 | if ( state.backtracking==0 ) { | ||
21831 | before(grammarAccess.getALSPreficedAccess().getRightSquareBracketKeyword_7_5()); | ||
21832 | } | ||
21833 | match(input,43,FOLLOW_2); if (state.failed) return ; | ||
21834 | if ( state.backtracking==0 ) { | ||
21835 | after(grammarAccess.getALSPreficedAccess().getRightSquareBracketKeyword_7_5()); | ||
21836 | } | ||
21837 | |||
21838 | } | ||
21839 | |||
21840 | |||
21841 | } | ||
21842 | |||
21843 | } | ||
21844 | catch (RecognitionException re) { | ||
21845 | reportError(re); | ||
21846 | recover(input,re); | ||
21847 | } | ||
21848 | finally { | ||
21849 | |||
21850 | restoreStackSize(stackSize); | ||
21851 | |||
21852 | } | ||
21853 | return ; | ||
21854 | } | ||
21855 | // $ANTLR end "rule__ALSPreficed__Group_7__5__Impl" | ||
21856 | |||
21857 | |||
21858 | // $ANTLR start "rule__ALSPreficed__Group_7_4__0" | ||
21859 | // InternalAlloyLanguage.g:7695:1: rule__ALSPreficed__Group_7_4__0 : rule__ALSPreficed__Group_7_4__0__Impl rule__ALSPreficed__Group_7_4__1 ; | ||
21860 | public final void rule__ALSPreficed__Group_7_4__0() throws RecognitionException { | ||
21861 | |||
21862 | int stackSize = keepStackSize(); | ||
21863 | |||
21864 | try { | ||
21865 | // InternalAlloyLanguage.g:7699:1: ( rule__ALSPreficed__Group_7_4__0__Impl rule__ALSPreficed__Group_7_4__1 ) | ||
21866 | // InternalAlloyLanguage.g:7700:2: rule__ALSPreficed__Group_7_4__0__Impl rule__ALSPreficed__Group_7_4__1 | ||
21867 | { | ||
21868 | pushFollow(FOLLOW_16); | ||
21869 | rule__ALSPreficed__Group_7_4__0__Impl(); | ||
21870 | |||
21871 | state._fsp--; | ||
21872 | if (state.failed) return ; | ||
21873 | pushFollow(FOLLOW_2); | ||
21874 | rule__ALSPreficed__Group_7_4__1(); | ||
21875 | |||
21876 | state._fsp--; | ||
21877 | if (state.failed) return ; | ||
21878 | |||
21879 | } | ||
21880 | |||
21881 | } | ||
21882 | catch (RecognitionException re) { | ||
21883 | reportError(re); | ||
21884 | recover(input,re); | ||
21885 | } | ||
21886 | finally { | ||
21887 | |||
21888 | restoreStackSize(stackSize); | ||
21889 | |||
21890 | } | ||
21891 | return ; | ||
21892 | } | ||
21893 | // $ANTLR end "rule__ALSPreficed__Group_7_4__0" | ||
21894 | |||
21895 | |||
21896 | // $ANTLR start "rule__ALSPreficed__Group_7_4__0__Impl" | ||
21897 | // InternalAlloyLanguage.g:7707:1: rule__ALSPreficed__Group_7_4__0__Impl : ( ',' ) ; | ||
21898 | public final void rule__ALSPreficed__Group_7_4__0__Impl() throws RecognitionException { | ||
21899 | |||
21900 | int stackSize = keepStackSize(); | ||
21901 | |||
21902 | try { | ||
21903 | // InternalAlloyLanguage.g:7711:1: ( ( ',' ) ) | ||
21904 | // InternalAlloyLanguage.g:7712:1: ( ',' ) | ||
21905 | { | ||
21906 | // InternalAlloyLanguage.g:7712:1: ( ',' ) | ||
21907 | // InternalAlloyLanguage.g:7713:1: ',' | ||
21908 | { | ||
21909 | if ( state.backtracking==0 ) { | ||
21910 | before(grammarAccess.getALSPreficedAccess().getCommaKeyword_7_4_0()); | ||
21911 | } | ||
21912 | match(input,35,FOLLOW_2); if (state.failed) return ; | ||
21913 | if ( state.backtracking==0 ) { | ||
21914 | after(grammarAccess.getALSPreficedAccess().getCommaKeyword_7_4_0()); | ||
21915 | } | ||
21916 | |||
21917 | } | ||
21918 | |||
21919 | |||
21920 | } | ||
21921 | |||
21922 | } | ||
21923 | catch (RecognitionException re) { | ||
21924 | reportError(re); | ||
21925 | recover(input,re); | ||
21926 | } | ||
21927 | finally { | ||
21928 | |||
21929 | restoreStackSize(stackSize); | ||
21930 | |||
21931 | } | ||
21932 | return ; | ||
21933 | } | ||
21934 | // $ANTLR end "rule__ALSPreficed__Group_7_4__0__Impl" | ||
21935 | |||
21936 | |||
21937 | // $ANTLR start "rule__ALSPreficed__Group_7_4__1" | ||
21938 | // InternalAlloyLanguage.g:7726:1: rule__ALSPreficed__Group_7_4__1 : rule__ALSPreficed__Group_7_4__1__Impl ; | ||
21939 | public final void rule__ALSPreficed__Group_7_4__1() throws RecognitionException { | ||
21940 | |||
21941 | int stackSize = keepStackSize(); | ||
21942 | |||
21943 | try { | ||
21944 | // InternalAlloyLanguage.g:7730:1: ( rule__ALSPreficed__Group_7_4__1__Impl ) | ||
21945 | // InternalAlloyLanguage.g:7731:2: rule__ALSPreficed__Group_7_4__1__Impl | ||
21946 | { | ||
21947 | pushFollow(FOLLOW_2); | ||
21948 | rule__ALSPreficed__Group_7_4__1__Impl(); | ||
21949 | |||
21950 | state._fsp--; | ||
21951 | if (state.failed) return ; | ||
21952 | |||
21953 | } | ||
21954 | |||
21955 | } | ||
21956 | catch (RecognitionException re) { | ||
21957 | reportError(re); | ||
21958 | recover(input,re); | ||
21959 | } | ||
21960 | finally { | ||
21961 | |||
21962 | restoreStackSize(stackSize); | ||
21963 | |||
21964 | } | ||
21965 | return ; | ||
21966 | } | ||
21967 | // $ANTLR end "rule__ALSPreficed__Group_7_4__1" | ||
21968 | |||
21969 | |||
21970 | // $ANTLR start "rule__ALSPreficed__Group_7_4__1__Impl" | ||
21971 | // InternalAlloyLanguage.g:7737:1: rule__ALSPreficed__Group_7_4__1__Impl : ( ( rule__ALSPreficed__ParamsAssignment_7_4_1 ) ) ; | ||
21972 | public final void rule__ALSPreficed__Group_7_4__1__Impl() throws RecognitionException { | ||
21973 | |||
21974 | int stackSize = keepStackSize(); | ||
21975 | |||
21976 | try { | ||
21977 | // InternalAlloyLanguage.g:7741:1: ( ( ( rule__ALSPreficed__ParamsAssignment_7_4_1 ) ) ) | ||
21978 | // InternalAlloyLanguage.g:7742:1: ( ( rule__ALSPreficed__ParamsAssignment_7_4_1 ) ) | ||
21979 | { | ||
21980 | // InternalAlloyLanguage.g:7742:1: ( ( rule__ALSPreficed__ParamsAssignment_7_4_1 ) ) | ||
21981 | // InternalAlloyLanguage.g:7743:1: ( rule__ALSPreficed__ParamsAssignment_7_4_1 ) | ||
21982 | { | ||
21983 | if ( state.backtracking==0 ) { | ||
21984 | before(grammarAccess.getALSPreficedAccess().getParamsAssignment_7_4_1()); | ||
21985 | } | ||
21986 | // InternalAlloyLanguage.g:7744:1: ( rule__ALSPreficed__ParamsAssignment_7_4_1 ) | ||
21987 | // InternalAlloyLanguage.g:7744:2: rule__ALSPreficed__ParamsAssignment_7_4_1 | ||
21988 | { | ||
21989 | pushFollow(FOLLOW_2); | ||
21990 | rule__ALSPreficed__ParamsAssignment_7_4_1(); | ||
21991 | |||
21992 | state._fsp--; | ||
21993 | if (state.failed) return ; | ||
21994 | |||
21995 | } | ||
21996 | |||
21997 | if ( state.backtracking==0 ) { | ||
21998 | after(grammarAccess.getALSPreficedAccess().getParamsAssignment_7_4_1()); | ||
21999 | } | ||
22000 | |||
22001 | } | ||
22002 | |||
22003 | |||
22004 | } | ||
22005 | |||
22006 | } | ||
22007 | catch (RecognitionException re) { | ||
22008 | reportError(re); | ||
22009 | recover(input,re); | ||
22010 | } | ||
22011 | finally { | ||
22012 | |||
22013 | restoreStackSize(stackSize); | ||
22014 | |||
22015 | } | ||
22016 | return ; | ||
22017 | } | ||
22018 | // $ANTLR end "rule__ALSPreficed__Group_7_4__1__Impl" | ||
22019 | |||
22020 | |||
22021 | // $ANTLR start "rule__ALSVariableDeclaration__Group__0" | ||
22022 | // InternalAlloyLanguage.g:7758:1: rule__ALSVariableDeclaration__Group__0 : rule__ALSVariableDeclaration__Group__0__Impl rule__ALSVariableDeclaration__Group__1 ; | ||
22023 | public final void rule__ALSVariableDeclaration__Group__0() throws RecognitionException { | ||
22024 | |||
22025 | int stackSize = keepStackSize(); | ||
22026 | |||
22027 | try { | ||
22028 | // InternalAlloyLanguage.g:7762:1: ( rule__ALSVariableDeclaration__Group__0__Impl rule__ALSVariableDeclaration__Group__1 ) | ||
22029 | // InternalAlloyLanguage.g:7763:2: rule__ALSVariableDeclaration__Group__0__Impl rule__ALSVariableDeclaration__Group__1 | ||
22030 | { | ||
22031 | pushFollow(FOLLOW_15); | ||
22032 | rule__ALSVariableDeclaration__Group__0__Impl(); | ||
22033 | |||
22034 | state._fsp--; | ||
22035 | if (state.failed) return ; | ||
22036 | pushFollow(FOLLOW_2); | ||
22037 | rule__ALSVariableDeclaration__Group__1(); | ||
22038 | |||
22039 | state._fsp--; | ||
22040 | if (state.failed) return ; | ||
22041 | |||
22042 | } | ||
22043 | |||
22044 | } | ||
22045 | catch (RecognitionException re) { | ||
22046 | reportError(re); | ||
22047 | recover(input,re); | ||
22048 | } | ||
22049 | finally { | ||
22050 | |||
22051 | restoreStackSize(stackSize); | ||
22052 | |||
22053 | } | ||
22054 | return ; | ||
22055 | } | ||
22056 | // $ANTLR end "rule__ALSVariableDeclaration__Group__0" | ||
22057 | |||
22058 | |||
22059 | // $ANTLR start "rule__ALSVariableDeclaration__Group__0__Impl" | ||
22060 | // InternalAlloyLanguage.g:7770:1: rule__ALSVariableDeclaration__Group__0__Impl : ( ( rule__ALSVariableDeclaration__NameAssignment_0 ) ) ; | ||
22061 | public final void rule__ALSVariableDeclaration__Group__0__Impl() throws RecognitionException { | ||
22062 | |||
22063 | int stackSize = keepStackSize(); | ||
22064 | |||
22065 | try { | ||
22066 | // InternalAlloyLanguage.g:7774:1: ( ( ( rule__ALSVariableDeclaration__NameAssignment_0 ) ) ) | ||
22067 | // InternalAlloyLanguage.g:7775:1: ( ( rule__ALSVariableDeclaration__NameAssignment_0 ) ) | ||
22068 | { | ||
22069 | // InternalAlloyLanguage.g:7775:1: ( ( rule__ALSVariableDeclaration__NameAssignment_0 ) ) | ||
22070 | // InternalAlloyLanguage.g:7776:1: ( rule__ALSVariableDeclaration__NameAssignment_0 ) | ||
22071 | { | ||
22072 | if ( state.backtracking==0 ) { | ||
22073 | before(grammarAccess.getALSVariableDeclarationAccess().getNameAssignment_0()); | ||
22074 | } | ||
22075 | // InternalAlloyLanguage.g:7777:1: ( rule__ALSVariableDeclaration__NameAssignment_0 ) | ||
22076 | // InternalAlloyLanguage.g:7777:2: rule__ALSVariableDeclaration__NameAssignment_0 | ||
22077 | { | ||
22078 | pushFollow(FOLLOW_2); | ||
22079 | rule__ALSVariableDeclaration__NameAssignment_0(); | ||
22080 | |||
22081 | state._fsp--; | ||
22082 | if (state.failed) return ; | ||
22083 | |||
22084 | } | ||
22085 | |||
22086 | if ( state.backtracking==0 ) { | ||
22087 | after(grammarAccess.getALSVariableDeclarationAccess().getNameAssignment_0()); | ||
22088 | } | ||
22089 | |||
22090 | } | ||
22091 | |||
22092 | |||
22093 | } | ||
22094 | |||
22095 | } | ||
22096 | catch (RecognitionException re) { | ||
22097 | reportError(re); | ||
22098 | recover(input,re); | ||
22099 | } | ||
22100 | finally { | ||
22101 | |||
22102 | restoreStackSize(stackSize); | ||
22103 | |||
22104 | } | ||
22105 | return ; | ||
22106 | } | ||
22107 | // $ANTLR end "rule__ALSVariableDeclaration__Group__0__Impl" | ||
22108 | |||
22109 | |||
22110 | // $ANTLR start "rule__ALSVariableDeclaration__Group__1" | ||
22111 | // InternalAlloyLanguage.g:7787:1: rule__ALSVariableDeclaration__Group__1 : rule__ALSVariableDeclaration__Group__1__Impl rule__ALSVariableDeclaration__Group__2 ; | ||
22112 | public final void rule__ALSVariableDeclaration__Group__1() throws RecognitionException { | ||
22113 | |||
22114 | int stackSize = keepStackSize(); | ||
22115 | |||
22116 | try { | ||
22117 | // InternalAlloyLanguage.g:7791:1: ( rule__ALSVariableDeclaration__Group__1__Impl rule__ALSVariableDeclaration__Group__2 ) | ||
22118 | // InternalAlloyLanguage.g:7792:2: rule__ALSVariableDeclaration__Group__1__Impl rule__ALSVariableDeclaration__Group__2 | ||
22119 | { | ||
22120 | pushFollow(FOLLOW_16); | ||
22121 | rule__ALSVariableDeclaration__Group__1__Impl(); | ||
22122 | |||
22123 | state._fsp--; | ||
22124 | if (state.failed) return ; | ||
22125 | pushFollow(FOLLOW_2); | ||
22126 | rule__ALSVariableDeclaration__Group__2(); | ||
22127 | |||
22128 | state._fsp--; | ||
22129 | if (state.failed) return ; | ||
22130 | |||
22131 | } | ||
22132 | |||
22133 | } | ||
22134 | catch (RecognitionException re) { | ||
22135 | reportError(re); | ||
22136 | recover(input,re); | ||
22137 | } | ||
22138 | finally { | ||
22139 | |||
22140 | restoreStackSize(stackSize); | ||
22141 | |||
22142 | } | ||
22143 | return ; | ||
22144 | } | ||
22145 | // $ANTLR end "rule__ALSVariableDeclaration__Group__1" | ||
22146 | |||
22147 | |||
22148 | // $ANTLR start "rule__ALSVariableDeclaration__Group__1__Impl" | ||
22149 | // InternalAlloyLanguage.g:7799:1: rule__ALSVariableDeclaration__Group__1__Impl : ( ':' ) ; | ||
22150 | public final void rule__ALSVariableDeclaration__Group__1__Impl() throws RecognitionException { | ||
22151 | |||
22152 | int stackSize = keepStackSize(); | ||
22153 | |||
22154 | try { | ||
22155 | // InternalAlloyLanguage.g:7803:1: ( ( ':' ) ) | ||
22156 | // InternalAlloyLanguage.g:7804:1: ( ':' ) | ||
22157 | { | ||
22158 | // InternalAlloyLanguage.g:7804:1: ( ':' ) | ||
22159 | // InternalAlloyLanguage.g:7805:1: ':' | ||
22160 | { | ||
22161 | if ( state.backtracking==0 ) { | ||
22162 | before(grammarAccess.getALSVariableDeclarationAccess().getColonKeyword_1()); | ||
22163 | } | ||
22164 | match(input,40,FOLLOW_2); if (state.failed) return ; | ||
22165 | if ( state.backtracking==0 ) { | ||
22166 | after(grammarAccess.getALSVariableDeclarationAccess().getColonKeyword_1()); | ||
22167 | } | ||
22168 | |||
22169 | } | ||
22170 | |||
22171 | |||
22172 | } | ||
22173 | |||
22174 | } | ||
22175 | catch (RecognitionException re) { | ||
22176 | reportError(re); | ||
22177 | recover(input,re); | ||
22178 | } | ||
22179 | finally { | ||
22180 | |||
22181 | restoreStackSize(stackSize); | ||
22182 | |||
22183 | } | ||
22184 | return ; | ||
22185 | } | ||
22186 | // $ANTLR end "rule__ALSVariableDeclaration__Group__1__Impl" | ||
22187 | |||
22188 | |||
22189 | // $ANTLR start "rule__ALSVariableDeclaration__Group__2" | ||
22190 | // InternalAlloyLanguage.g:7818:1: rule__ALSVariableDeclaration__Group__2 : rule__ALSVariableDeclaration__Group__2__Impl ; | ||
22191 | public final void rule__ALSVariableDeclaration__Group__2() throws RecognitionException { | ||
22192 | |||
22193 | int stackSize = keepStackSize(); | ||
22194 | |||
22195 | try { | ||
22196 | // InternalAlloyLanguage.g:7822:1: ( rule__ALSVariableDeclaration__Group__2__Impl ) | ||
22197 | // InternalAlloyLanguage.g:7823:2: rule__ALSVariableDeclaration__Group__2__Impl | ||
22198 | { | ||
22199 | pushFollow(FOLLOW_2); | ||
22200 | rule__ALSVariableDeclaration__Group__2__Impl(); | ||
22201 | |||
22202 | state._fsp--; | ||
22203 | if (state.failed) return ; | ||
22204 | |||
22205 | } | ||
22206 | |||
22207 | } | ||
22208 | catch (RecognitionException re) { | ||
22209 | reportError(re); | ||
22210 | recover(input,re); | ||
22211 | } | ||
22212 | finally { | ||
22213 | |||
22214 | restoreStackSize(stackSize); | ||
22215 | |||
22216 | } | ||
22217 | return ; | ||
22218 | } | ||
22219 | // $ANTLR end "rule__ALSVariableDeclaration__Group__2" | ||
22220 | |||
22221 | |||
22222 | // $ANTLR start "rule__ALSVariableDeclaration__Group__2__Impl" | ||
22223 | // InternalAlloyLanguage.g:7829:1: rule__ALSVariableDeclaration__Group__2__Impl : ( ( rule__ALSVariableDeclaration__RangeAssignment_2 ) ) ; | ||
22224 | public final void rule__ALSVariableDeclaration__Group__2__Impl() throws RecognitionException { | ||
22225 | |||
22226 | int stackSize = keepStackSize(); | ||
22227 | |||
22228 | try { | ||
22229 | // InternalAlloyLanguage.g:7833:1: ( ( ( rule__ALSVariableDeclaration__RangeAssignment_2 ) ) ) | ||
22230 | // InternalAlloyLanguage.g:7834:1: ( ( rule__ALSVariableDeclaration__RangeAssignment_2 ) ) | ||
22231 | { | ||
22232 | // InternalAlloyLanguage.g:7834:1: ( ( rule__ALSVariableDeclaration__RangeAssignment_2 ) ) | ||
22233 | // InternalAlloyLanguage.g:7835:1: ( rule__ALSVariableDeclaration__RangeAssignment_2 ) | ||
22234 | { | ||
22235 | if ( state.backtracking==0 ) { | ||
22236 | before(grammarAccess.getALSVariableDeclarationAccess().getRangeAssignment_2()); | ||
22237 | } | ||
22238 | // InternalAlloyLanguage.g:7836:1: ( rule__ALSVariableDeclaration__RangeAssignment_2 ) | ||
22239 | // InternalAlloyLanguage.g:7836:2: rule__ALSVariableDeclaration__RangeAssignment_2 | ||
22240 | { | ||
22241 | pushFollow(FOLLOW_2); | ||
22242 | rule__ALSVariableDeclaration__RangeAssignment_2(); | ||
22243 | |||
22244 | state._fsp--; | ||
22245 | if (state.failed) return ; | ||
22246 | |||
22247 | } | ||
22248 | |||
22249 | if ( state.backtracking==0 ) { | ||
22250 | after(grammarAccess.getALSVariableDeclarationAccess().getRangeAssignment_2()); | ||
22251 | } | ||
22252 | |||
22253 | } | ||
22254 | |||
22255 | |||
22256 | } | ||
22257 | |||
22258 | } | ||
22259 | catch (RecognitionException re) { | ||
22260 | reportError(re); | ||
22261 | recover(input,re); | ||
22262 | } | ||
22263 | finally { | ||
22264 | |||
22265 | restoreStackSize(stackSize); | ||
22266 | |||
22267 | } | ||
22268 | return ; | ||
22269 | } | ||
22270 | // $ANTLR end "rule__ALSVariableDeclaration__Group__2__Impl" | ||
22271 | |||
22272 | |||
22273 | // $ANTLR start "rule__ALSBasicRelationTerm__Group_0__0" | ||
22274 | // InternalAlloyLanguage.g:7852:1: rule__ALSBasicRelationTerm__Group_0__0 : rule__ALSBasicRelationTerm__Group_0__0__Impl rule__ALSBasicRelationTerm__Group_0__1 ; | ||
22275 | public final void rule__ALSBasicRelationTerm__Group_0__0() throws RecognitionException { | ||
22276 | |||
22277 | int stackSize = keepStackSize(); | ||
22278 | |||
22279 | try { | ||
22280 | // InternalAlloyLanguage.g:7856:1: ( rule__ALSBasicRelationTerm__Group_0__0__Impl rule__ALSBasicRelationTerm__Group_0__1 ) | ||
22281 | // InternalAlloyLanguage.g:7857:2: rule__ALSBasicRelationTerm__Group_0__0__Impl rule__ALSBasicRelationTerm__Group_0__1 | ||
22282 | { | ||
22283 | pushFollow(FOLLOW_54); | ||
22284 | rule__ALSBasicRelationTerm__Group_0__0__Impl(); | ||
22285 | |||
22286 | state._fsp--; | ||
22287 | if (state.failed) return ; | ||
22288 | pushFollow(FOLLOW_2); | ||
22289 | rule__ALSBasicRelationTerm__Group_0__1(); | ||
22290 | |||
22291 | state._fsp--; | ||
22292 | if (state.failed) return ; | ||
22293 | |||
22294 | } | ||
22295 | |||
22296 | } | ||
22297 | catch (RecognitionException re) { | ||
22298 | reportError(re); | ||
22299 | recover(input,re); | ||
22300 | } | ||
22301 | finally { | ||
22302 | |||
22303 | restoreStackSize(stackSize); | ||
22304 | |||
22305 | } | ||
22306 | return ; | ||
22307 | } | ||
22308 | // $ANTLR end "rule__ALSBasicRelationTerm__Group_0__0" | ||
22309 | |||
22310 | |||
22311 | // $ANTLR start "rule__ALSBasicRelationTerm__Group_0__0__Impl" | ||
22312 | // InternalAlloyLanguage.g:7864:1: rule__ALSBasicRelationTerm__Group_0__0__Impl : ( () ) ; | ||
22313 | public final void rule__ALSBasicRelationTerm__Group_0__0__Impl() throws RecognitionException { | ||
22314 | |||
22315 | int stackSize = keepStackSize(); | ||
22316 | |||
22317 | try { | ||
22318 | // InternalAlloyLanguage.g:7868:1: ( ( () ) ) | ||
22319 | // InternalAlloyLanguage.g:7869:1: ( () ) | ||
22320 | { | ||
22321 | // InternalAlloyLanguage.g:7869:1: ( () ) | ||
22322 | // InternalAlloyLanguage.g:7870:1: () | ||
22323 | { | ||
22324 | if ( state.backtracking==0 ) { | ||
22325 | before(grammarAccess.getALSBasicRelationTermAccess().getALSNoneAction_0_0()); | ||
22326 | } | ||
22327 | // InternalAlloyLanguage.g:7871:1: () | ||
22328 | // InternalAlloyLanguage.g:7873:1: | ||
22329 | { | ||
22330 | } | ||
22331 | |||
22332 | if ( state.backtracking==0 ) { | ||
22333 | after(grammarAccess.getALSBasicRelationTermAccess().getALSNoneAction_0_0()); | ||
22334 | } | ||
22335 | |||
22336 | } | ||
22337 | |||
22338 | |||
22339 | } | ||
22340 | |||
22341 | } | ||
22342 | finally { | ||
22343 | |||
22344 | restoreStackSize(stackSize); | ||
22345 | |||
22346 | } | ||
22347 | return ; | ||
22348 | } | ||
22349 | // $ANTLR end "rule__ALSBasicRelationTerm__Group_0__0__Impl" | ||
22350 | |||
22351 | |||
22352 | // $ANTLR start "rule__ALSBasicRelationTerm__Group_0__1" | ||
22353 | // InternalAlloyLanguage.g:7883:1: rule__ALSBasicRelationTerm__Group_0__1 : rule__ALSBasicRelationTerm__Group_0__1__Impl ; | ||
22354 | public final void rule__ALSBasicRelationTerm__Group_0__1() throws RecognitionException { | ||
22355 | |||
22356 | int stackSize = keepStackSize(); | ||
22357 | |||
22358 | try { | ||
22359 | // InternalAlloyLanguage.g:7887:1: ( rule__ALSBasicRelationTerm__Group_0__1__Impl ) | ||
22360 | // InternalAlloyLanguage.g:7888:2: rule__ALSBasicRelationTerm__Group_0__1__Impl | ||
22361 | { | ||
22362 | pushFollow(FOLLOW_2); | ||
22363 | rule__ALSBasicRelationTerm__Group_0__1__Impl(); | ||
22364 | |||
22365 | state._fsp--; | ||
22366 | if (state.failed) return ; | ||
22367 | |||
22368 | } | ||
22369 | |||
22370 | } | ||
22371 | catch (RecognitionException re) { | ||
22372 | reportError(re); | ||
22373 | recover(input,re); | ||
22374 | } | ||
22375 | finally { | ||
22376 | |||
22377 | restoreStackSize(stackSize); | ||
22378 | |||
22379 | } | ||
22380 | return ; | ||
22381 | } | ||
22382 | // $ANTLR end "rule__ALSBasicRelationTerm__Group_0__1" | ||
22383 | |||
22384 | |||
22385 | // $ANTLR start "rule__ALSBasicRelationTerm__Group_0__1__Impl" | ||
22386 | // InternalAlloyLanguage.g:7894:1: rule__ALSBasicRelationTerm__Group_0__1__Impl : ( 'none' ) ; | ||
22387 | public final void rule__ALSBasicRelationTerm__Group_0__1__Impl() throws RecognitionException { | ||
22388 | |||
22389 | int stackSize = keepStackSize(); | ||
22390 | |||
22391 | try { | ||
22392 | // InternalAlloyLanguage.g:7898:1: ( ( 'none' ) ) | ||
22393 | // InternalAlloyLanguage.g:7899:1: ( 'none' ) | ||
22394 | { | ||
22395 | // InternalAlloyLanguage.g:7899:1: ( 'none' ) | ||
22396 | // InternalAlloyLanguage.g:7900:1: 'none' | ||
22397 | { | ||
22398 | if ( state.backtracking==0 ) { | ||
22399 | before(grammarAccess.getALSBasicRelationTermAccess().getNoneKeyword_0_1()); | ||
22400 | } | ||
22401 | match(input,65,FOLLOW_2); if (state.failed) return ; | ||
22402 | if ( state.backtracking==0 ) { | ||
22403 | after(grammarAccess.getALSBasicRelationTermAccess().getNoneKeyword_0_1()); | ||
22404 | } | ||
22405 | |||
22406 | } | ||
22407 | |||
22408 | |||
22409 | } | ||
22410 | |||
22411 | } | ||
22412 | catch (RecognitionException re) { | ||
22413 | reportError(re); | ||
22414 | recover(input,re); | ||
22415 | } | ||
22416 | finally { | ||
22417 | |||
22418 | restoreStackSize(stackSize); | ||
22419 | |||
22420 | } | ||
22421 | return ; | ||
22422 | } | ||
22423 | // $ANTLR end "rule__ALSBasicRelationTerm__Group_0__1__Impl" | ||
22424 | |||
22425 | |||
22426 | // $ANTLR start "rule__ALSBasicRelationTerm__Group_1__0" | ||
22427 | // InternalAlloyLanguage.g:7917:1: rule__ALSBasicRelationTerm__Group_1__0 : rule__ALSBasicRelationTerm__Group_1__0__Impl rule__ALSBasicRelationTerm__Group_1__1 ; | ||
22428 | public final void rule__ALSBasicRelationTerm__Group_1__0() throws RecognitionException { | ||
22429 | |||
22430 | int stackSize = keepStackSize(); | ||
22431 | |||
22432 | try { | ||
22433 | // InternalAlloyLanguage.g:7921:1: ( rule__ALSBasicRelationTerm__Group_1__0__Impl rule__ALSBasicRelationTerm__Group_1__1 ) | ||
22434 | // InternalAlloyLanguage.g:7922:2: rule__ALSBasicRelationTerm__Group_1__0__Impl rule__ALSBasicRelationTerm__Group_1__1 | ||
22435 | { | ||
22436 | pushFollow(FOLLOW_55); | ||
22437 | rule__ALSBasicRelationTerm__Group_1__0__Impl(); | ||
22438 | |||
22439 | state._fsp--; | ||
22440 | if (state.failed) return ; | ||
22441 | pushFollow(FOLLOW_2); | ||
22442 | rule__ALSBasicRelationTerm__Group_1__1(); | ||
22443 | |||
22444 | state._fsp--; | ||
22445 | if (state.failed) return ; | ||
22446 | |||
22447 | } | ||
22448 | |||
22449 | } | ||
22450 | catch (RecognitionException re) { | ||
22451 | reportError(re); | ||
22452 | recover(input,re); | ||
22453 | } | ||
22454 | finally { | ||
22455 | |||
22456 | restoreStackSize(stackSize); | ||
22457 | |||
22458 | } | ||
22459 | return ; | ||
22460 | } | ||
22461 | // $ANTLR end "rule__ALSBasicRelationTerm__Group_1__0" | ||
22462 | |||
22463 | |||
22464 | // $ANTLR start "rule__ALSBasicRelationTerm__Group_1__0__Impl" | ||
22465 | // InternalAlloyLanguage.g:7929:1: rule__ALSBasicRelationTerm__Group_1__0__Impl : ( () ) ; | ||
22466 | public final void rule__ALSBasicRelationTerm__Group_1__0__Impl() throws RecognitionException { | ||
22467 | |||
22468 | int stackSize = keepStackSize(); | ||
22469 | |||
22470 | try { | ||
22471 | // InternalAlloyLanguage.g:7933:1: ( ( () ) ) | ||
22472 | // InternalAlloyLanguage.g:7934:1: ( () ) | ||
22473 | { | ||
22474 | // InternalAlloyLanguage.g:7934:1: ( () ) | ||
22475 | // InternalAlloyLanguage.g:7935:1: () | ||
22476 | { | ||
22477 | if ( state.backtracking==0 ) { | ||
22478 | before(grammarAccess.getALSBasicRelationTermAccess().getALSIdenAction_1_0()); | ||
22479 | } | ||
22480 | // InternalAlloyLanguage.g:7936:1: () | ||
22481 | // InternalAlloyLanguage.g:7938:1: | ||
22482 | { | ||
22483 | } | ||
22484 | |||
22485 | if ( state.backtracking==0 ) { | ||
22486 | after(grammarAccess.getALSBasicRelationTermAccess().getALSIdenAction_1_0()); | ||
22487 | } | ||
22488 | |||
22489 | } | ||
22490 | |||
22491 | |||
22492 | } | ||
22493 | |||
22494 | } | ||
22495 | finally { | ||
22496 | |||
22497 | restoreStackSize(stackSize); | ||
22498 | |||
22499 | } | ||
22500 | return ; | ||
22501 | } | ||
22502 | // $ANTLR end "rule__ALSBasicRelationTerm__Group_1__0__Impl" | ||
22503 | |||
22504 | |||
22505 | // $ANTLR start "rule__ALSBasicRelationTerm__Group_1__1" | ||
22506 | // InternalAlloyLanguage.g:7948:1: rule__ALSBasicRelationTerm__Group_1__1 : rule__ALSBasicRelationTerm__Group_1__1__Impl ; | ||
22507 | public final void rule__ALSBasicRelationTerm__Group_1__1() throws RecognitionException { | ||
22508 | |||
22509 | int stackSize = keepStackSize(); | ||
22510 | |||
22511 | try { | ||
22512 | // InternalAlloyLanguage.g:7952:1: ( rule__ALSBasicRelationTerm__Group_1__1__Impl ) | ||
22513 | // InternalAlloyLanguage.g:7953:2: rule__ALSBasicRelationTerm__Group_1__1__Impl | ||
22514 | { | ||
22515 | pushFollow(FOLLOW_2); | ||
22516 | rule__ALSBasicRelationTerm__Group_1__1__Impl(); | ||
22517 | |||
22518 | state._fsp--; | ||
22519 | if (state.failed) return ; | ||
22520 | |||
22521 | } | ||
22522 | |||
22523 | } | ||
22524 | catch (RecognitionException re) { | ||
22525 | reportError(re); | ||
22526 | recover(input,re); | ||
22527 | } | ||
22528 | finally { | ||
22529 | |||
22530 | restoreStackSize(stackSize); | ||
22531 | |||
22532 | } | ||
22533 | return ; | ||
22534 | } | ||
22535 | // $ANTLR end "rule__ALSBasicRelationTerm__Group_1__1" | ||
22536 | |||
22537 | |||
22538 | // $ANTLR start "rule__ALSBasicRelationTerm__Group_1__1__Impl" | ||
22539 | // InternalAlloyLanguage.g:7959:1: rule__ALSBasicRelationTerm__Group_1__1__Impl : ( 'iden' ) ; | ||
22540 | public final void rule__ALSBasicRelationTerm__Group_1__1__Impl() throws RecognitionException { | ||
22541 | |||
22542 | int stackSize = keepStackSize(); | ||
22543 | |||
22544 | try { | ||
22545 | // InternalAlloyLanguage.g:7963:1: ( ( 'iden' ) ) | ||
22546 | // InternalAlloyLanguage.g:7964:1: ( 'iden' ) | ||
22547 | { | ||
22548 | // InternalAlloyLanguage.g:7964:1: ( 'iden' ) | ||
22549 | // InternalAlloyLanguage.g:7965:1: 'iden' | ||
22550 | { | ||
22551 | if ( state.backtracking==0 ) { | ||
22552 | before(grammarAccess.getALSBasicRelationTermAccess().getIdenKeyword_1_1()); | ||
22553 | } | ||
22554 | match(input,66,FOLLOW_2); if (state.failed) return ; | ||
22555 | if ( state.backtracking==0 ) { | ||
22556 | after(grammarAccess.getALSBasicRelationTermAccess().getIdenKeyword_1_1()); | ||
22557 | } | ||
22558 | |||
22559 | } | ||
22560 | |||
22561 | |||
22562 | } | ||
22563 | |||
22564 | } | ||
22565 | catch (RecognitionException re) { | ||
22566 | reportError(re); | ||
22567 | recover(input,re); | ||
22568 | } | ||
22569 | finally { | ||
22570 | |||
22571 | restoreStackSize(stackSize); | ||
22572 | |||
22573 | } | ||
22574 | return ; | ||
22575 | } | ||
22576 | // $ANTLR end "rule__ALSBasicRelationTerm__Group_1__1__Impl" | ||
22577 | |||
22578 | |||
22579 | // $ANTLR start "rule__ALSBasicRelationTerm__Group_2__0" | ||
22580 | // InternalAlloyLanguage.g:7982:1: rule__ALSBasicRelationTerm__Group_2__0 : rule__ALSBasicRelationTerm__Group_2__0__Impl rule__ALSBasicRelationTerm__Group_2__1 ; | ||
22581 | public final void rule__ALSBasicRelationTerm__Group_2__0() throws RecognitionException { | ||
22582 | |||
22583 | int stackSize = keepStackSize(); | ||
22584 | |||
22585 | try { | ||
22586 | // InternalAlloyLanguage.g:7986:1: ( rule__ALSBasicRelationTerm__Group_2__0__Impl rule__ALSBasicRelationTerm__Group_2__1 ) | ||
22587 | // InternalAlloyLanguage.g:7987:2: rule__ALSBasicRelationTerm__Group_2__0__Impl rule__ALSBasicRelationTerm__Group_2__1 | ||
22588 | { | ||
22589 | pushFollow(FOLLOW_56); | ||
22590 | rule__ALSBasicRelationTerm__Group_2__0__Impl(); | ||
22591 | |||
22592 | state._fsp--; | ||
22593 | if (state.failed) return ; | ||
22594 | pushFollow(FOLLOW_2); | ||
22595 | rule__ALSBasicRelationTerm__Group_2__1(); | ||
22596 | |||
22597 | state._fsp--; | ||
22598 | if (state.failed) return ; | ||
22599 | |||
22600 | } | ||
22601 | |||
22602 | } | ||
22603 | catch (RecognitionException re) { | ||
22604 | reportError(re); | ||
22605 | recover(input,re); | ||
22606 | } | ||
22607 | finally { | ||
22608 | |||
22609 | restoreStackSize(stackSize); | ||
22610 | |||
22611 | } | ||
22612 | return ; | ||
22613 | } | ||
22614 | // $ANTLR end "rule__ALSBasicRelationTerm__Group_2__0" | ||
22615 | |||
22616 | |||
22617 | // $ANTLR start "rule__ALSBasicRelationTerm__Group_2__0__Impl" | ||
22618 | // InternalAlloyLanguage.g:7994:1: rule__ALSBasicRelationTerm__Group_2__0__Impl : ( () ) ; | ||
22619 | public final void rule__ALSBasicRelationTerm__Group_2__0__Impl() throws RecognitionException { | ||
22620 | |||
22621 | int stackSize = keepStackSize(); | ||
22622 | |||
22623 | try { | ||
22624 | // InternalAlloyLanguage.g:7998:1: ( ( () ) ) | ||
22625 | // InternalAlloyLanguage.g:7999:1: ( () ) | ||
22626 | { | ||
22627 | // InternalAlloyLanguage.g:7999:1: ( () ) | ||
22628 | // InternalAlloyLanguage.g:8000:1: () | ||
22629 | { | ||
22630 | if ( state.backtracking==0 ) { | ||
22631 | before(grammarAccess.getALSBasicRelationTermAccess().getALSUnivAction_2_0()); | ||
22632 | } | ||
22633 | // InternalAlloyLanguage.g:8001:1: () | ||
22634 | // InternalAlloyLanguage.g:8003:1: | ||
22635 | { | ||
22636 | } | ||
22637 | |||
22638 | if ( state.backtracking==0 ) { | ||
22639 | after(grammarAccess.getALSBasicRelationTermAccess().getALSUnivAction_2_0()); | ||
22640 | } | ||
22641 | |||
22642 | } | ||
22643 | |||
22644 | |||
22645 | } | ||
22646 | |||
22647 | } | ||
22648 | finally { | ||
22649 | |||
22650 | restoreStackSize(stackSize); | ||
22651 | |||
22652 | } | ||
22653 | return ; | ||
22654 | } | ||
22655 | // $ANTLR end "rule__ALSBasicRelationTerm__Group_2__0__Impl" | ||
22656 | |||
22657 | |||
22658 | // $ANTLR start "rule__ALSBasicRelationTerm__Group_2__1" | ||
22659 | // InternalAlloyLanguage.g:8013:1: rule__ALSBasicRelationTerm__Group_2__1 : rule__ALSBasicRelationTerm__Group_2__1__Impl ; | ||
22660 | public final void rule__ALSBasicRelationTerm__Group_2__1() throws RecognitionException { | ||
22661 | |||
22662 | int stackSize = keepStackSize(); | ||
22663 | |||
22664 | try { | ||
22665 | // InternalAlloyLanguage.g:8017:1: ( rule__ALSBasicRelationTerm__Group_2__1__Impl ) | ||
22666 | // InternalAlloyLanguage.g:8018:2: rule__ALSBasicRelationTerm__Group_2__1__Impl | ||
22667 | { | ||
22668 | pushFollow(FOLLOW_2); | ||
22669 | rule__ALSBasicRelationTerm__Group_2__1__Impl(); | ||
22670 | |||
22671 | state._fsp--; | ||
22672 | if (state.failed) return ; | ||
22673 | |||
22674 | } | ||
22675 | |||
22676 | } | ||
22677 | catch (RecognitionException re) { | ||
22678 | reportError(re); | ||
22679 | recover(input,re); | ||
22680 | } | ||
22681 | finally { | ||
22682 | |||
22683 | restoreStackSize(stackSize); | ||
22684 | |||
22685 | } | ||
22686 | return ; | ||
22687 | } | ||
22688 | // $ANTLR end "rule__ALSBasicRelationTerm__Group_2__1" | ||
22689 | |||
22690 | |||
22691 | // $ANTLR start "rule__ALSBasicRelationTerm__Group_2__1__Impl" | ||
22692 | // InternalAlloyLanguage.g:8024:1: rule__ALSBasicRelationTerm__Group_2__1__Impl : ( 'univ' ) ; | ||
22693 | public final void rule__ALSBasicRelationTerm__Group_2__1__Impl() throws RecognitionException { | ||
22694 | |||
22695 | int stackSize = keepStackSize(); | ||
22696 | |||
22697 | try { | ||
22698 | // InternalAlloyLanguage.g:8028:1: ( ( 'univ' ) ) | ||
22699 | // InternalAlloyLanguage.g:8029:1: ( 'univ' ) | ||
22700 | { | ||
22701 | // InternalAlloyLanguage.g:8029:1: ( 'univ' ) | ||
22702 | // InternalAlloyLanguage.g:8030:1: 'univ' | ||
22703 | { | ||
22704 | if ( state.backtracking==0 ) { | ||
22705 | before(grammarAccess.getALSBasicRelationTermAccess().getUnivKeyword_2_1()); | ||
22706 | } | ||
22707 | match(input,67,FOLLOW_2); if (state.failed) return ; | ||
22708 | if ( state.backtracking==0 ) { | ||
22709 | after(grammarAccess.getALSBasicRelationTermAccess().getUnivKeyword_2_1()); | ||
22710 | } | ||
22711 | |||
22712 | } | ||
22713 | |||
22714 | |||
22715 | } | ||
22716 | |||
22717 | } | ||
22718 | catch (RecognitionException re) { | ||
22719 | reportError(re); | ||
22720 | recover(input,re); | ||
22721 | } | ||
22722 | finally { | ||
22723 | |||
22724 | restoreStackSize(stackSize); | ||
22725 | |||
22726 | } | ||
22727 | return ; | ||
22728 | } | ||
22729 | // $ANTLR end "rule__ALSBasicRelationTerm__Group_2__1__Impl" | ||
22730 | |||
22731 | |||
22732 | // $ANTLR start "rule__ALSBasicRelationTerm__Group_3__0" | ||
22733 | // InternalAlloyLanguage.g:8047:1: rule__ALSBasicRelationTerm__Group_3__0 : rule__ALSBasicRelationTerm__Group_3__0__Impl rule__ALSBasicRelationTerm__Group_3__1 ; | ||
22734 | public final void rule__ALSBasicRelationTerm__Group_3__0() throws RecognitionException { | ||
22735 | |||
22736 | int stackSize = keepStackSize(); | ||
22737 | |||
22738 | try { | ||
22739 | // InternalAlloyLanguage.g:8051:1: ( rule__ALSBasicRelationTerm__Group_3__0__Impl rule__ALSBasicRelationTerm__Group_3__1 ) | ||
22740 | // InternalAlloyLanguage.g:8052:2: rule__ALSBasicRelationTerm__Group_3__0__Impl rule__ALSBasicRelationTerm__Group_3__1 | ||
22741 | { | ||
22742 | pushFollow(FOLLOW_57); | ||
22743 | rule__ALSBasicRelationTerm__Group_3__0__Impl(); | ||
22744 | |||
22745 | state._fsp--; | ||
22746 | if (state.failed) return ; | ||
22747 | pushFollow(FOLLOW_2); | ||
22748 | rule__ALSBasicRelationTerm__Group_3__1(); | ||
22749 | |||
22750 | state._fsp--; | ||
22751 | if (state.failed) return ; | ||
22752 | |||
22753 | } | ||
22754 | |||
22755 | } | ||
22756 | catch (RecognitionException re) { | ||
22757 | reportError(re); | ||
22758 | recover(input,re); | ||
22759 | } | ||
22760 | finally { | ||
22761 | |||
22762 | restoreStackSize(stackSize); | ||
22763 | |||
22764 | } | ||
22765 | return ; | ||
22766 | } | ||
22767 | // $ANTLR end "rule__ALSBasicRelationTerm__Group_3__0" | ||
22768 | |||
22769 | |||
22770 | // $ANTLR start "rule__ALSBasicRelationTerm__Group_3__0__Impl" | ||
22771 | // InternalAlloyLanguage.g:8059:1: rule__ALSBasicRelationTerm__Group_3__0__Impl : ( () ) ; | ||
22772 | public final void rule__ALSBasicRelationTerm__Group_3__0__Impl() throws RecognitionException { | ||
22773 | |||
22774 | int stackSize = keepStackSize(); | ||
22775 | |||
22776 | try { | ||
22777 | // InternalAlloyLanguage.g:8063:1: ( ( () ) ) | ||
22778 | // InternalAlloyLanguage.g:8064:1: ( () ) | ||
22779 | { | ||
22780 | // InternalAlloyLanguage.g:8064:1: ( () ) | ||
22781 | // InternalAlloyLanguage.g:8065:1: () | ||
22782 | { | ||
22783 | if ( state.backtracking==0 ) { | ||
22784 | before(grammarAccess.getALSBasicRelationTermAccess().getALSIntAction_3_0()); | ||
22785 | } | ||
22786 | // InternalAlloyLanguage.g:8066:1: () | ||
22787 | // InternalAlloyLanguage.g:8068:1: | ||
22788 | { | ||
22789 | } | ||
22790 | |||
22791 | if ( state.backtracking==0 ) { | ||
22792 | after(grammarAccess.getALSBasicRelationTermAccess().getALSIntAction_3_0()); | ||
22793 | } | ||
22794 | |||
22795 | } | ||
22796 | |||
22797 | |||
22798 | } | ||
22799 | |||
22800 | } | ||
22801 | finally { | ||
22802 | |||
22803 | restoreStackSize(stackSize); | ||
22804 | |||
22805 | } | ||
22806 | return ; | ||
22807 | } | ||
22808 | // $ANTLR end "rule__ALSBasicRelationTerm__Group_3__0__Impl" | ||
22809 | |||
22810 | |||
22811 | // $ANTLR start "rule__ALSBasicRelationTerm__Group_3__1" | ||
22812 | // InternalAlloyLanguage.g:8078:1: rule__ALSBasicRelationTerm__Group_3__1 : rule__ALSBasicRelationTerm__Group_3__1__Impl ; | ||
22813 | public final void rule__ALSBasicRelationTerm__Group_3__1() throws RecognitionException { | ||
22814 | |||
22815 | int stackSize = keepStackSize(); | ||
22816 | |||
22817 | try { | ||
22818 | // InternalAlloyLanguage.g:8082:1: ( rule__ALSBasicRelationTerm__Group_3__1__Impl ) | ||
22819 | // InternalAlloyLanguage.g:8083:2: rule__ALSBasicRelationTerm__Group_3__1__Impl | ||
22820 | { | ||
22821 | pushFollow(FOLLOW_2); | ||
22822 | rule__ALSBasicRelationTerm__Group_3__1__Impl(); | ||
22823 | |||
22824 | state._fsp--; | ||
22825 | if (state.failed) return ; | ||
22826 | |||
22827 | } | ||
22828 | |||
22829 | } | ||
22830 | catch (RecognitionException re) { | ||
22831 | reportError(re); | ||
22832 | recover(input,re); | ||
22833 | } | ||
22834 | finally { | ||
22835 | |||
22836 | restoreStackSize(stackSize); | ||
22837 | |||
22838 | } | ||
22839 | return ; | ||
22840 | } | ||
22841 | // $ANTLR end "rule__ALSBasicRelationTerm__Group_3__1" | ||
22842 | |||
22843 | |||
22844 | // $ANTLR start "rule__ALSBasicRelationTerm__Group_3__1__Impl" | ||
22845 | // InternalAlloyLanguage.g:8089:1: rule__ALSBasicRelationTerm__Group_3__1__Impl : ( 'Int' ) ; | ||
22846 | public final void rule__ALSBasicRelationTerm__Group_3__1__Impl() throws RecognitionException { | ||
22847 | |||
22848 | int stackSize = keepStackSize(); | ||
22849 | |||
22850 | try { | ||
22851 | // InternalAlloyLanguage.g:8093:1: ( ( 'Int' ) ) | ||
22852 | // InternalAlloyLanguage.g:8094:1: ( 'Int' ) | ||
22853 | { | ||
22854 | // InternalAlloyLanguage.g:8094:1: ( 'Int' ) | ||
22855 | // InternalAlloyLanguage.g:8095:1: 'Int' | ||
22856 | { | ||
22857 | if ( state.backtracking==0 ) { | ||
22858 | before(grammarAccess.getALSBasicRelationTermAccess().getIntKeyword_3_1()); | ||
22859 | } | ||
22860 | match(input,68,FOLLOW_2); if (state.failed) return ; | ||
22861 | if ( state.backtracking==0 ) { | ||
22862 | after(grammarAccess.getALSBasicRelationTermAccess().getIntKeyword_3_1()); | ||
22863 | } | ||
22864 | |||
22865 | } | ||
22866 | |||
22867 | |||
22868 | } | ||
22869 | |||
22870 | } | ||
22871 | catch (RecognitionException re) { | ||
22872 | reportError(re); | ||
22873 | recover(input,re); | ||
22874 | } | ||
22875 | finally { | ||
22876 | |||
22877 | restoreStackSize(stackSize); | ||
22878 | |||
22879 | } | ||
22880 | return ; | ||
22881 | } | ||
22882 | // $ANTLR end "rule__ALSBasicRelationTerm__Group_3__1__Impl" | ||
22883 | |||
22884 | |||
22885 | // $ANTLR start "rule__ALSBasicRelationTerm__Group_4__0" | ||
22886 | // InternalAlloyLanguage.g:8112:1: rule__ALSBasicRelationTerm__Group_4__0 : rule__ALSBasicRelationTerm__Group_4__0__Impl rule__ALSBasicRelationTerm__Group_4__1 ; | ||
22887 | public final void rule__ALSBasicRelationTerm__Group_4__0() throws RecognitionException { | ||
22888 | |||
22889 | int stackSize = keepStackSize(); | ||
22890 | |||
22891 | try { | ||
22892 | // InternalAlloyLanguage.g:8116:1: ( rule__ALSBasicRelationTerm__Group_4__0__Impl rule__ALSBasicRelationTerm__Group_4__1 ) | ||
22893 | // InternalAlloyLanguage.g:8117:2: rule__ALSBasicRelationTerm__Group_4__0__Impl rule__ALSBasicRelationTerm__Group_4__1 | ||
22894 | { | ||
22895 | pushFollow(FOLLOW_58); | ||
22896 | rule__ALSBasicRelationTerm__Group_4__0__Impl(); | ||
22897 | |||
22898 | state._fsp--; | ||
22899 | if (state.failed) return ; | ||
22900 | pushFollow(FOLLOW_2); | ||
22901 | rule__ALSBasicRelationTerm__Group_4__1(); | ||
22902 | |||
22903 | state._fsp--; | ||
22904 | if (state.failed) return ; | ||
22905 | |||
22906 | } | ||
22907 | |||
22908 | } | ||
22909 | catch (RecognitionException re) { | ||
22910 | reportError(re); | ||
22911 | recover(input,re); | ||
22912 | } | ||
22913 | finally { | ||
22914 | |||
22915 | restoreStackSize(stackSize); | ||
22916 | |||
22917 | } | ||
22918 | return ; | ||
22919 | } | ||
22920 | // $ANTLR end "rule__ALSBasicRelationTerm__Group_4__0" | ||
22921 | |||
22922 | |||
22923 | // $ANTLR start "rule__ALSBasicRelationTerm__Group_4__0__Impl" | ||
22924 | // InternalAlloyLanguage.g:8124:1: rule__ALSBasicRelationTerm__Group_4__0__Impl : ( () ) ; | ||
22925 | public final void rule__ALSBasicRelationTerm__Group_4__0__Impl() throws RecognitionException { | ||
22926 | |||
22927 | int stackSize = keepStackSize(); | ||
22928 | |||
22929 | try { | ||
22930 | // InternalAlloyLanguage.g:8128:1: ( ( () ) ) | ||
22931 | // InternalAlloyLanguage.g:8129:1: ( () ) | ||
22932 | { | ||
22933 | // InternalAlloyLanguage.g:8129:1: ( () ) | ||
22934 | // InternalAlloyLanguage.g:8130:1: () | ||
22935 | { | ||
22936 | if ( state.backtracking==0 ) { | ||
22937 | before(grammarAccess.getALSBasicRelationTermAccess().getALSStringAction_4_0()); | ||
22938 | } | ||
22939 | // InternalAlloyLanguage.g:8131:1: () | ||
22940 | // InternalAlloyLanguage.g:8133:1: | ||
22941 | { | ||
22942 | } | ||
22943 | |||
22944 | if ( state.backtracking==0 ) { | ||
22945 | after(grammarAccess.getALSBasicRelationTermAccess().getALSStringAction_4_0()); | ||
22946 | } | ||
22947 | |||
22948 | } | ||
22949 | |||
22950 | |||
22951 | } | ||
22952 | |||
22953 | } | ||
22954 | finally { | ||
22955 | |||
22956 | restoreStackSize(stackSize); | ||
22957 | |||
22958 | } | ||
22959 | return ; | ||
22960 | } | ||
22961 | // $ANTLR end "rule__ALSBasicRelationTerm__Group_4__0__Impl" | ||
22962 | |||
22963 | |||
22964 | // $ANTLR start "rule__ALSBasicRelationTerm__Group_4__1" | ||
22965 | // InternalAlloyLanguage.g:8143:1: rule__ALSBasicRelationTerm__Group_4__1 : rule__ALSBasicRelationTerm__Group_4__1__Impl ; | ||
22966 | public final void rule__ALSBasicRelationTerm__Group_4__1() throws RecognitionException { | ||
22967 | |||
22968 | int stackSize = keepStackSize(); | ||
22969 | |||
22970 | try { | ||
22971 | // InternalAlloyLanguage.g:8147:1: ( rule__ALSBasicRelationTerm__Group_4__1__Impl ) | ||
22972 | // InternalAlloyLanguage.g:8148:2: rule__ALSBasicRelationTerm__Group_4__1__Impl | ||
22973 | { | ||
22974 | pushFollow(FOLLOW_2); | ||
22975 | rule__ALSBasicRelationTerm__Group_4__1__Impl(); | ||
22976 | |||
22977 | state._fsp--; | ||
22978 | if (state.failed) return ; | ||
22979 | |||
22980 | } | ||
22981 | |||
22982 | } | ||
22983 | catch (RecognitionException re) { | ||
22984 | reportError(re); | ||
22985 | recover(input,re); | ||
22986 | } | ||
22987 | finally { | ||
22988 | |||
22989 | restoreStackSize(stackSize); | ||
22990 | |||
22991 | } | ||
22992 | return ; | ||
22993 | } | ||
22994 | // $ANTLR end "rule__ALSBasicRelationTerm__Group_4__1" | ||
22995 | |||
22996 | |||
22997 | // $ANTLR start "rule__ALSBasicRelationTerm__Group_4__1__Impl" | ||
22998 | // InternalAlloyLanguage.g:8154:1: rule__ALSBasicRelationTerm__Group_4__1__Impl : ( 'String' ) ; | ||
22999 | public final void rule__ALSBasicRelationTerm__Group_4__1__Impl() throws RecognitionException { | ||
23000 | |||
23001 | int stackSize = keepStackSize(); | ||
23002 | |||
23003 | try { | ||
23004 | // InternalAlloyLanguage.g:8158:1: ( ( 'String' ) ) | ||
23005 | // InternalAlloyLanguage.g:8159:1: ( 'String' ) | ||
23006 | { | ||
23007 | // InternalAlloyLanguage.g:8159:1: ( 'String' ) | ||
23008 | // InternalAlloyLanguage.g:8160:1: 'String' | ||
23009 | { | ||
23010 | if ( state.backtracking==0 ) { | ||
23011 | before(grammarAccess.getALSBasicRelationTermAccess().getStringKeyword_4_1()); | ||
23012 | } | ||
23013 | match(input,69,FOLLOW_2); if (state.failed) return ; | ||
23014 | if ( state.backtracking==0 ) { | ||
23015 | after(grammarAccess.getALSBasicRelationTermAccess().getStringKeyword_4_1()); | ||
23016 | } | ||
23017 | |||
23018 | } | ||
23019 | |||
23020 | |||
23021 | } | ||
23022 | |||
23023 | } | ||
23024 | catch (RecognitionException re) { | ||
23025 | reportError(re); | ||
23026 | recover(input,re); | ||
23027 | } | ||
23028 | finally { | ||
23029 | |||
23030 | restoreStackSize(stackSize); | ||
23031 | |||
23032 | } | ||
23033 | return ; | ||
23034 | } | ||
23035 | // $ANTLR end "rule__ALSBasicRelationTerm__Group_4__1__Impl" | ||
23036 | |||
23037 | |||
23038 | // $ANTLR start "rule__ALSBasicRelationTerm__Group_5__0" | ||
23039 | // InternalAlloyLanguage.g:8177:1: rule__ALSBasicRelationTerm__Group_5__0 : rule__ALSBasicRelationTerm__Group_5__0__Impl rule__ALSBasicRelationTerm__Group_5__1 ; | ||
23040 | public final void rule__ALSBasicRelationTerm__Group_5__0() throws RecognitionException { | ||
23041 | |||
23042 | int stackSize = keepStackSize(); | ||
23043 | |||
23044 | try { | ||
23045 | // InternalAlloyLanguage.g:8181:1: ( rule__ALSBasicRelationTerm__Group_5__0__Impl rule__ALSBasicRelationTerm__Group_5__1 ) | ||
23046 | // InternalAlloyLanguage.g:8182:2: rule__ALSBasicRelationTerm__Group_5__0__Impl rule__ALSBasicRelationTerm__Group_5__1 | ||
23047 | { | ||
23048 | pushFollow(FOLLOW_5); | ||
23049 | rule__ALSBasicRelationTerm__Group_5__0__Impl(); | ||
23050 | |||
23051 | state._fsp--; | ||
23052 | if (state.failed) return ; | ||
23053 | pushFollow(FOLLOW_2); | ||
23054 | rule__ALSBasicRelationTerm__Group_5__1(); | ||
23055 | |||
23056 | state._fsp--; | ||
23057 | if (state.failed) return ; | ||
23058 | |||
23059 | } | ||
23060 | |||
23061 | } | ||
23062 | catch (RecognitionException re) { | ||
23063 | reportError(re); | ||
23064 | recover(input,re); | ||
23065 | } | ||
23066 | finally { | ||
23067 | |||
23068 | restoreStackSize(stackSize); | ||
23069 | |||
23070 | } | ||
23071 | return ; | ||
23072 | } | ||
23073 | // $ANTLR end "rule__ALSBasicRelationTerm__Group_5__0" | ||
23074 | |||
23075 | |||
23076 | // $ANTLR start "rule__ALSBasicRelationTerm__Group_5__0__Impl" | ||
23077 | // InternalAlloyLanguage.g:8189:1: rule__ALSBasicRelationTerm__Group_5__0__Impl : ( () ) ; | ||
23078 | public final void rule__ALSBasicRelationTerm__Group_5__0__Impl() throws RecognitionException { | ||
23079 | |||
23080 | int stackSize = keepStackSize(); | ||
23081 | |||
23082 | try { | ||
23083 | // InternalAlloyLanguage.g:8193:1: ( ( () ) ) | ||
23084 | // InternalAlloyLanguage.g:8194:1: ( () ) | ||
23085 | { | ||
23086 | // InternalAlloyLanguage.g:8194:1: ( () ) | ||
23087 | // InternalAlloyLanguage.g:8195:1: () | ||
23088 | { | ||
23089 | if ( state.backtracking==0 ) { | ||
23090 | before(grammarAccess.getALSBasicRelationTermAccess().getALSReferenceAction_5_0()); | ||
23091 | } | ||
23092 | // InternalAlloyLanguage.g:8196:1: () | ||
23093 | // InternalAlloyLanguage.g:8198:1: | ||
23094 | { | ||
23095 | } | ||
23096 | |||
23097 | if ( state.backtracking==0 ) { | ||
23098 | after(grammarAccess.getALSBasicRelationTermAccess().getALSReferenceAction_5_0()); | ||
23099 | } | ||
23100 | |||
23101 | } | ||
23102 | |||
23103 | |||
23104 | } | ||
23105 | |||
23106 | } | ||
23107 | finally { | ||
23108 | |||
23109 | restoreStackSize(stackSize); | ||
23110 | |||
23111 | } | ||
23112 | return ; | ||
23113 | } | ||
23114 | // $ANTLR end "rule__ALSBasicRelationTerm__Group_5__0__Impl" | ||
23115 | |||
23116 | |||
23117 | // $ANTLR start "rule__ALSBasicRelationTerm__Group_5__1" | ||
23118 | // InternalAlloyLanguage.g:8208:1: rule__ALSBasicRelationTerm__Group_5__1 : rule__ALSBasicRelationTerm__Group_5__1__Impl ; | ||
23119 | public final void rule__ALSBasicRelationTerm__Group_5__1() throws RecognitionException { | ||
23120 | |||
23121 | int stackSize = keepStackSize(); | ||
23122 | |||
23123 | try { | ||
23124 | // InternalAlloyLanguage.g:8212:1: ( rule__ALSBasicRelationTerm__Group_5__1__Impl ) | ||
23125 | // InternalAlloyLanguage.g:8213:2: rule__ALSBasicRelationTerm__Group_5__1__Impl | ||
23126 | { | ||
23127 | pushFollow(FOLLOW_2); | ||
23128 | rule__ALSBasicRelationTerm__Group_5__1__Impl(); | ||
23129 | |||
23130 | state._fsp--; | ||
23131 | if (state.failed) return ; | ||
23132 | |||
23133 | } | ||
23134 | |||
23135 | } | ||
23136 | catch (RecognitionException re) { | ||
23137 | reportError(re); | ||
23138 | recover(input,re); | ||
23139 | } | ||
23140 | finally { | ||
23141 | |||
23142 | restoreStackSize(stackSize); | ||
23143 | |||
23144 | } | ||
23145 | return ; | ||
23146 | } | ||
23147 | // $ANTLR end "rule__ALSBasicRelationTerm__Group_5__1" | ||
23148 | |||
23149 | |||
23150 | // $ANTLR start "rule__ALSBasicRelationTerm__Group_5__1__Impl" | ||
23151 | // InternalAlloyLanguage.g:8219:1: rule__ALSBasicRelationTerm__Group_5__1__Impl : ( ( rule__ALSBasicRelationTerm__ReferredAssignment_5_1 ) ) ; | ||
23152 | public final void rule__ALSBasicRelationTerm__Group_5__1__Impl() throws RecognitionException { | ||
23153 | |||
23154 | int stackSize = keepStackSize(); | ||
23155 | |||
23156 | try { | ||
23157 | // InternalAlloyLanguage.g:8223:1: ( ( ( rule__ALSBasicRelationTerm__ReferredAssignment_5_1 ) ) ) | ||
23158 | // InternalAlloyLanguage.g:8224:1: ( ( rule__ALSBasicRelationTerm__ReferredAssignment_5_1 ) ) | ||
23159 | { | ||
23160 | // InternalAlloyLanguage.g:8224:1: ( ( rule__ALSBasicRelationTerm__ReferredAssignment_5_1 ) ) | ||
23161 | // InternalAlloyLanguage.g:8225:1: ( rule__ALSBasicRelationTerm__ReferredAssignment_5_1 ) | ||
23162 | { | ||
23163 | if ( state.backtracking==0 ) { | ||
23164 | before(grammarAccess.getALSBasicRelationTermAccess().getReferredAssignment_5_1()); | ||
23165 | } | ||
23166 | // InternalAlloyLanguage.g:8226:1: ( rule__ALSBasicRelationTerm__ReferredAssignment_5_1 ) | ||
23167 | // InternalAlloyLanguage.g:8226:2: rule__ALSBasicRelationTerm__ReferredAssignment_5_1 | ||
23168 | { | ||
23169 | pushFollow(FOLLOW_2); | ||
23170 | rule__ALSBasicRelationTerm__ReferredAssignment_5_1(); | ||
23171 | |||
23172 | state._fsp--; | ||
23173 | if (state.failed) return ; | ||
23174 | |||
23175 | } | ||
23176 | |||
23177 | if ( state.backtracking==0 ) { | ||
23178 | after(grammarAccess.getALSBasicRelationTermAccess().getReferredAssignment_5_1()); | ||
23179 | } | ||
23180 | |||
23181 | } | ||
23182 | |||
23183 | |||
23184 | } | ||
23185 | |||
23186 | } | ||
23187 | catch (RecognitionException re) { | ||
23188 | reportError(re); | ||
23189 | recover(input,re); | ||
23190 | } | ||
23191 | finally { | ||
23192 | |||
23193 | restoreStackSize(stackSize); | ||
23194 | |||
23195 | } | ||
23196 | return ; | ||
23197 | } | ||
23198 | // $ANTLR end "rule__ALSBasicRelationTerm__Group_5__1__Impl" | ||
23199 | |||
23200 | |||
23201 | // $ANTLR start "rule__ALSBasicRelationTerm__Group_6__0" | ||
23202 | // InternalAlloyLanguage.g:8240:1: rule__ALSBasicRelationTerm__Group_6__0 : rule__ALSBasicRelationTerm__Group_6__0__Impl rule__ALSBasicRelationTerm__Group_6__1 ; | ||
23203 | public final void rule__ALSBasicRelationTerm__Group_6__0() throws RecognitionException { | ||
23204 | |||
23205 | int stackSize = keepStackSize(); | ||
23206 | |||
23207 | try { | ||
23208 | // InternalAlloyLanguage.g:8244:1: ( rule__ALSBasicRelationTerm__Group_6__0__Impl rule__ALSBasicRelationTerm__Group_6__1 ) | ||
23209 | // InternalAlloyLanguage.g:8245:2: rule__ALSBasicRelationTerm__Group_6__0__Impl rule__ALSBasicRelationTerm__Group_6__1 | ||
23210 | { | ||
23211 | pushFollow(FOLLOW_59); | ||
23212 | rule__ALSBasicRelationTerm__Group_6__0__Impl(); | ||
23213 | |||
23214 | state._fsp--; | ||
23215 | if (state.failed) return ; | ||
23216 | pushFollow(FOLLOW_2); | ||
23217 | rule__ALSBasicRelationTerm__Group_6__1(); | ||
23218 | |||
23219 | state._fsp--; | ||
23220 | if (state.failed) return ; | ||
23221 | |||
23222 | } | ||
23223 | |||
23224 | } | ||
23225 | catch (RecognitionException re) { | ||
23226 | reportError(re); | ||
23227 | recover(input,re); | ||
23228 | } | ||
23229 | finally { | ||
23230 | |||
23231 | restoreStackSize(stackSize); | ||
23232 | |||
23233 | } | ||
23234 | return ; | ||
23235 | } | ||
23236 | // $ANTLR end "rule__ALSBasicRelationTerm__Group_6__0" | ||
23237 | |||
23238 | |||
23239 | // $ANTLR start "rule__ALSBasicRelationTerm__Group_6__0__Impl" | ||
23240 | // InternalAlloyLanguage.g:8252:1: rule__ALSBasicRelationTerm__Group_6__0__Impl : ( () ) ; | ||
23241 | public final void rule__ALSBasicRelationTerm__Group_6__0__Impl() throws RecognitionException { | ||
23242 | |||
23243 | int stackSize = keepStackSize(); | ||
23244 | |||
23245 | try { | ||
23246 | // InternalAlloyLanguage.g:8256:1: ( ( () ) ) | ||
23247 | // InternalAlloyLanguage.g:8257:1: ( () ) | ||
23248 | { | ||
23249 | // InternalAlloyLanguage.g:8257:1: ( () ) | ||
23250 | // InternalAlloyLanguage.g:8258:1: () | ||
23251 | { | ||
23252 | if ( state.backtracking==0 ) { | ||
23253 | before(grammarAccess.getALSBasicRelationTermAccess().getALSNumberLiteralAction_6_0()); | ||
23254 | } | ||
23255 | // InternalAlloyLanguage.g:8259:1: () | ||
23256 | // InternalAlloyLanguage.g:8261:1: | ||
23257 | { | ||
23258 | } | ||
23259 | |||
23260 | if ( state.backtracking==0 ) { | ||
23261 | after(grammarAccess.getALSBasicRelationTermAccess().getALSNumberLiteralAction_6_0()); | ||
23262 | } | ||
23263 | |||
23264 | } | ||
23265 | |||
23266 | |||
23267 | } | ||
23268 | |||
23269 | } | ||
23270 | finally { | ||
23271 | |||
23272 | restoreStackSize(stackSize); | ||
23273 | |||
23274 | } | ||
23275 | return ; | ||
23276 | } | ||
23277 | // $ANTLR end "rule__ALSBasicRelationTerm__Group_6__0__Impl" | ||
23278 | |||
23279 | |||
23280 | // $ANTLR start "rule__ALSBasicRelationTerm__Group_6__1" | ||
23281 | // InternalAlloyLanguage.g:8271:1: rule__ALSBasicRelationTerm__Group_6__1 : rule__ALSBasicRelationTerm__Group_6__1__Impl ; | ||
23282 | public final void rule__ALSBasicRelationTerm__Group_6__1() throws RecognitionException { | ||
23283 | |||
23284 | int stackSize = keepStackSize(); | ||
23285 | |||
23286 | try { | ||
23287 | // InternalAlloyLanguage.g:8275:1: ( rule__ALSBasicRelationTerm__Group_6__1__Impl ) | ||
23288 | // InternalAlloyLanguage.g:8276:2: rule__ALSBasicRelationTerm__Group_6__1__Impl | ||
23289 | { | ||
23290 | pushFollow(FOLLOW_2); | ||
23291 | rule__ALSBasicRelationTerm__Group_6__1__Impl(); | ||
23292 | |||
23293 | state._fsp--; | ||
23294 | if (state.failed) return ; | ||
23295 | |||
23296 | } | ||
23297 | |||
23298 | } | ||
23299 | catch (RecognitionException re) { | ||
23300 | reportError(re); | ||
23301 | recover(input,re); | ||
23302 | } | ||
23303 | finally { | ||
23304 | |||
23305 | restoreStackSize(stackSize); | ||
23306 | |||
23307 | } | ||
23308 | return ; | ||
23309 | } | ||
23310 | // $ANTLR end "rule__ALSBasicRelationTerm__Group_6__1" | ||
23311 | |||
23312 | |||
23313 | // $ANTLR start "rule__ALSBasicRelationTerm__Group_6__1__Impl" | ||
23314 | // InternalAlloyLanguage.g:8282:1: rule__ALSBasicRelationTerm__Group_6__1__Impl : ( ( rule__ALSBasicRelationTerm__ValueAssignment_6_1 ) ) ; | ||
23315 | public final void rule__ALSBasicRelationTerm__Group_6__1__Impl() throws RecognitionException { | ||
23316 | |||
23317 | int stackSize = keepStackSize(); | ||
23318 | |||
23319 | try { | ||
23320 | // InternalAlloyLanguage.g:8286:1: ( ( ( rule__ALSBasicRelationTerm__ValueAssignment_6_1 ) ) ) | ||
23321 | // InternalAlloyLanguage.g:8287:1: ( ( rule__ALSBasicRelationTerm__ValueAssignment_6_1 ) ) | ||
23322 | { | ||
23323 | // InternalAlloyLanguage.g:8287:1: ( ( rule__ALSBasicRelationTerm__ValueAssignment_6_1 ) ) | ||
23324 | // InternalAlloyLanguage.g:8288:1: ( rule__ALSBasicRelationTerm__ValueAssignment_6_1 ) | ||
23325 | { | ||
23326 | if ( state.backtracking==0 ) { | ||
23327 | before(grammarAccess.getALSBasicRelationTermAccess().getValueAssignment_6_1()); | ||
23328 | } | ||
23329 | // InternalAlloyLanguage.g:8289:1: ( rule__ALSBasicRelationTerm__ValueAssignment_6_1 ) | ||
23330 | // InternalAlloyLanguage.g:8289:2: rule__ALSBasicRelationTerm__ValueAssignment_6_1 | ||
23331 | { | ||
23332 | pushFollow(FOLLOW_2); | ||
23333 | rule__ALSBasicRelationTerm__ValueAssignment_6_1(); | ||
23334 | |||
23335 | state._fsp--; | ||
23336 | if (state.failed) return ; | ||
23337 | |||
23338 | } | ||
23339 | |||
23340 | if ( state.backtracking==0 ) { | ||
23341 | after(grammarAccess.getALSBasicRelationTermAccess().getValueAssignment_6_1()); | ||
23342 | } | ||
23343 | |||
23344 | } | ||
23345 | |||
23346 | |||
23347 | } | ||
23348 | |||
23349 | } | ||
23350 | catch (RecognitionException re) { | ||
23351 | reportError(re); | ||
23352 | recover(input,re); | ||
23353 | } | ||
23354 | finally { | ||
23355 | |||
23356 | restoreStackSize(stackSize); | ||
23357 | |||
23358 | } | ||
23359 | return ; | ||
23360 | } | ||
23361 | // $ANTLR end "rule__ALSBasicRelationTerm__Group_6__1__Impl" | ||
23362 | |||
23363 | |||
23364 | // $ANTLR start "rule__ALSBasicRelationTerm__Group_7__0" | ||
23365 | // InternalAlloyLanguage.g:8303:1: rule__ALSBasicRelationTerm__Group_7__0 : rule__ALSBasicRelationTerm__Group_7__0__Impl rule__ALSBasicRelationTerm__Group_7__1 ; | ||
23366 | public final void rule__ALSBasicRelationTerm__Group_7__0() throws RecognitionException { | ||
23367 | |||
23368 | int stackSize = keepStackSize(); | ||
23369 | |||
23370 | try { | ||
23371 | // InternalAlloyLanguage.g:8307:1: ( rule__ALSBasicRelationTerm__Group_7__0__Impl rule__ALSBasicRelationTerm__Group_7__1 ) | ||
23372 | // InternalAlloyLanguage.g:8308:2: rule__ALSBasicRelationTerm__Group_7__0__Impl rule__ALSBasicRelationTerm__Group_7__1 | ||
23373 | { | ||
23374 | pushFollow(FOLLOW_60); | ||
23375 | rule__ALSBasicRelationTerm__Group_7__0__Impl(); | ||
23376 | |||
23377 | state._fsp--; | ||
23378 | if (state.failed) return ; | ||
23379 | pushFollow(FOLLOW_2); | ||
23380 | rule__ALSBasicRelationTerm__Group_7__1(); | ||
23381 | |||
23382 | state._fsp--; | ||
23383 | if (state.failed) return ; | ||
23384 | |||
23385 | } | ||
23386 | |||
23387 | } | ||
23388 | catch (RecognitionException re) { | ||
23389 | reportError(re); | ||
23390 | recover(input,re); | ||
23391 | } | ||
23392 | finally { | ||
23393 | |||
23394 | restoreStackSize(stackSize); | ||
23395 | |||
23396 | } | ||
23397 | return ; | ||
23398 | } | ||
23399 | // $ANTLR end "rule__ALSBasicRelationTerm__Group_7__0" | ||
23400 | |||
23401 | |||
23402 | // $ANTLR start "rule__ALSBasicRelationTerm__Group_7__0__Impl" | ||
23403 | // InternalAlloyLanguage.g:8315:1: rule__ALSBasicRelationTerm__Group_7__0__Impl : ( () ) ; | ||
23404 | public final void rule__ALSBasicRelationTerm__Group_7__0__Impl() throws RecognitionException { | ||
23405 | |||
23406 | int stackSize = keepStackSize(); | ||
23407 | |||
23408 | try { | ||
23409 | // InternalAlloyLanguage.g:8319:1: ( ( () ) ) | ||
23410 | // InternalAlloyLanguage.g:8320:1: ( () ) | ||
23411 | { | ||
23412 | // InternalAlloyLanguage.g:8320:1: ( () ) | ||
23413 | // InternalAlloyLanguage.g:8321:1: () | ||
23414 | { | ||
23415 | if ( state.backtracking==0 ) { | ||
23416 | before(grammarAccess.getALSBasicRelationTermAccess().getALSStringLiteralAction_7_0()); | ||
23417 | } | ||
23418 | // InternalAlloyLanguage.g:8322:1: () | ||
23419 | // InternalAlloyLanguage.g:8324:1: | ||
23420 | { | ||
23421 | } | ||
23422 | |||
23423 | if ( state.backtracking==0 ) { | ||
23424 | after(grammarAccess.getALSBasicRelationTermAccess().getALSStringLiteralAction_7_0()); | ||
23425 | } | ||
23426 | |||
23427 | } | ||
23428 | |||
23429 | |||
23430 | } | ||
23431 | |||
23432 | } | ||
23433 | finally { | ||
23434 | |||
23435 | restoreStackSize(stackSize); | ||
23436 | |||
23437 | } | ||
23438 | return ; | ||
23439 | } | ||
23440 | // $ANTLR end "rule__ALSBasicRelationTerm__Group_7__0__Impl" | ||
23441 | |||
23442 | |||
23443 | // $ANTLR start "rule__ALSBasicRelationTerm__Group_7__1" | ||
23444 | // InternalAlloyLanguage.g:8334:1: rule__ALSBasicRelationTerm__Group_7__1 : rule__ALSBasicRelationTerm__Group_7__1__Impl ; | ||
23445 | public final void rule__ALSBasicRelationTerm__Group_7__1() throws RecognitionException { | ||
23446 | |||
23447 | int stackSize = keepStackSize(); | ||
23448 | |||
23449 | try { | ||
23450 | // InternalAlloyLanguage.g:8338:1: ( rule__ALSBasicRelationTerm__Group_7__1__Impl ) | ||
23451 | // InternalAlloyLanguage.g:8339:2: rule__ALSBasicRelationTerm__Group_7__1__Impl | ||
23452 | { | ||
23453 | pushFollow(FOLLOW_2); | ||
23454 | rule__ALSBasicRelationTerm__Group_7__1__Impl(); | ||
23455 | |||
23456 | state._fsp--; | ||
23457 | if (state.failed) return ; | ||
23458 | |||
23459 | } | ||
23460 | |||
23461 | } | ||
23462 | catch (RecognitionException re) { | ||
23463 | reportError(re); | ||
23464 | recover(input,re); | ||
23465 | } | ||
23466 | finally { | ||
23467 | |||
23468 | restoreStackSize(stackSize); | ||
23469 | |||
23470 | } | ||
23471 | return ; | ||
23472 | } | ||
23473 | // $ANTLR end "rule__ALSBasicRelationTerm__Group_7__1" | ||
23474 | |||
23475 | |||
23476 | // $ANTLR start "rule__ALSBasicRelationTerm__Group_7__1__Impl" | ||
23477 | // InternalAlloyLanguage.g:8345:1: rule__ALSBasicRelationTerm__Group_7__1__Impl : ( ( rule__ALSBasicRelationTerm__ValueAssignment_7_1 ) ) ; | ||
23478 | public final void rule__ALSBasicRelationTerm__Group_7__1__Impl() throws RecognitionException { | ||
23479 | |||
23480 | int stackSize = keepStackSize(); | ||
23481 | |||
23482 | try { | ||
23483 | // InternalAlloyLanguage.g:8349:1: ( ( ( rule__ALSBasicRelationTerm__ValueAssignment_7_1 ) ) ) | ||
23484 | // InternalAlloyLanguage.g:8350:1: ( ( rule__ALSBasicRelationTerm__ValueAssignment_7_1 ) ) | ||
23485 | { | ||
23486 | // InternalAlloyLanguage.g:8350:1: ( ( rule__ALSBasicRelationTerm__ValueAssignment_7_1 ) ) | ||
23487 | // InternalAlloyLanguage.g:8351:1: ( rule__ALSBasicRelationTerm__ValueAssignment_7_1 ) | ||
23488 | { | ||
23489 | if ( state.backtracking==0 ) { | ||
23490 | before(grammarAccess.getALSBasicRelationTermAccess().getValueAssignment_7_1()); | ||
23491 | } | ||
23492 | // InternalAlloyLanguage.g:8352:1: ( rule__ALSBasicRelationTerm__ValueAssignment_7_1 ) | ||
23493 | // InternalAlloyLanguage.g:8352:2: rule__ALSBasicRelationTerm__ValueAssignment_7_1 | ||
23494 | { | ||
23495 | pushFollow(FOLLOW_2); | ||
23496 | rule__ALSBasicRelationTerm__ValueAssignment_7_1(); | ||
23497 | |||
23498 | state._fsp--; | ||
23499 | if (state.failed) return ; | ||
23500 | |||
23501 | } | ||
23502 | |||
23503 | if ( state.backtracking==0 ) { | ||
23504 | after(grammarAccess.getALSBasicRelationTermAccess().getValueAssignment_7_1()); | ||
23505 | } | ||
23506 | |||
23507 | } | ||
23508 | |||
23509 | |||
23510 | } | ||
23511 | |||
23512 | } | ||
23513 | catch (RecognitionException re) { | ||
23514 | reportError(re); | ||
23515 | recover(input,re); | ||
23516 | } | ||
23517 | finally { | ||
23518 | |||
23519 | restoreStackSize(stackSize); | ||
23520 | |||
23521 | } | ||
23522 | return ; | ||
23523 | } | ||
23524 | // $ANTLR end "rule__ALSBasicRelationTerm__Group_7__1__Impl" | ||
23525 | |||
23526 | |||
23527 | // $ANTLR start "rule__ALSBasicRelationTerm__Group_8__0" | ||
23528 | // InternalAlloyLanguage.g:8366:1: rule__ALSBasicRelationTerm__Group_8__0 : rule__ALSBasicRelationTerm__Group_8__0__Impl rule__ALSBasicRelationTerm__Group_8__1 ; | ||
23529 | public final void rule__ALSBasicRelationTerm__Group_8__0() throws RecognitionException { | ||
23530 | |||
23531 | int stackSize = keepStackSize(); | ||
23532 | |||
23533 | try { | ||
23534 | // InternalAlloyLanguage.g:8370:1: ( rule__ALSBasicRelationTerm__Group_8__0__Impl rule__ALSBasicRelationTerm__Group_8__1 ) | ||
23535 | // InternalAlloyLanguage.g:8371:2: rule__ALSBasicRelationTerm__Group_8__0__Impl rule__ALSBasicRelationTerm__Group_8__1 | ||
23536 | { | ||
23537 | pushFollow(FOLLOW_16); | ||
23538 | rule__ALSBasicRelationTerm__Group_8__0__Impl(); | ||
23539 | |||
23540 | state._fsp--; | ||
23541 | if (state.failed) return ; | ||
23542 | pushFollow(FOLLOW_2); | ||
23543 | rule__ALSBasicRelationTerm__Group_8__1(); | ||
23544 | |||
23545 | state._fsp--; | ||
23546 | if (state.failed) return ; | ||
23547 | |||
23548 | } | ||
23549 | |||
23550 | } | ||
23551 | catch (RecognitionException re) { | ||
23552 | reportError(re); | ||
23553 | recover(input,re); | ||
23554 | } | ||
23555 | finally { | ||
23556 | |||
23557 | restoreStackSize(stackSize); | ||
23558 | |||
23559 | } | ||
23560 | return ; | ||
23561 | } | ||
23562 | // $ANTLR end "rule__ALSBasicRelationTerm__Group_8__0" | ||
23563 | |||
23564 | |||
23565 | // $ANTLR start "rule__ALSBasicRelationTerm__Group_8__0__Impl" | ||
23566 | // InternalAlloyLanguage.g:8378:1: rule__ALSBasicRelationTerm__Group_8__0__Impl : ( '(' ) ; | ||
23567 | public final void rule__ALSBasicRelationTerm__Group_8__0__Impl() throws RecognitionException { | ||
23568 | |||
23569 | int stackSize = keepStackSize(); | ||
23570 | |||
23571 | try { | ||
23572 | // InternalAlloyLanguage.g:8382:1: ( ( '(' ) ) | ||
23573 | // InternalAlloyLanguage.g:8383:1: ( '(' ) | ||
23574 | { | ||
23575 | // InternalAlloyLanguage.g:8383:1: ( '(' ) | ||
23576 | // InternalAlloyLanguage.g:8384:1: '(' | ||
23577 | { | ||
23578 | if ( state.backtracking==0 ) { | ||
23579 | before(grammarAccess.getALSBasicRelationTermAccess().getLeftParenthesisKeyword_8_0()); | ||
23580 | } | ||
23581 | match(input,70,FOLLOW_2); if (state.failed) return ; | ||
23582 | if ( state.backtracking==0 ) { | ||
23583 | after(grammarAccess.getALSBasicRelationTermAccess().getLeftParenthesisKeyword_8_0()); | ||
23584 | } | ||
23585 | |||
23586 | } | ||
23587 | |||
23588 | |||
23589 | } | ||
23590 | |||
23591 | } | ||
23592 | catch (RecognitionException re) { | ||
23593 | reportError(re); | ||
23594 | recover(input,re); | ||
23595 | } | ||
23596 | finally { | ||
23597 | |||
23598 | restoreStackSize(stackSize); | ||
23599 | |||
23600 | } | ||
23601 | return ; | ||
23602 | } | ||
23603 | // $ANTLR end "rule__ALSBasicRelationTerm__Group_8__0__Impl" | ||
23604 | |||
23605 | |||
23606 | // $ANTLR start "rule__ALSBasicRelationTerm__Group_8__1" | ||
23607 | // InternalAlloyLanguage.g:8397:1: rule__ALSBasicRelationTerm__Group_8__1 : rule__ALSBasicRelationTerm__Group_8__1__Impl rule__ALSBasicRelationTerm__Group_8__2 ; | ||
23608 | public final void rule__ALSBasicRelationTerm__Group_8__1() throws RecognitionException { | ||
23609 | |||
23610 | int stackSize = keepStackSize(); | ||
23611 | |||
23612 | try { | ||
23613 | // InternalAlloyLanguage.g:8401:1: ( rule__ALSBasicRelationTerm__Group_8__1__Impl rule__ALSBasicRelationTerm__Group_8__2 ) | ||
23614 | // InternalAlloyLanguage.g:8402:2: rule__ALSBasicRelationTerm__Group_8__1__Impl rule__ALSBasicRelationTerm__Group_8__2 | ||
23615 | { | ||
23616 | pushFollow(FOLLOW_61); | ||
23617 | rule__ALSBasicRelationTerm__Group_8__1__Impl(); | ||
23618 | |||
23619 | state._fsp--; | ||
23620 | if (state.failed) return ; | ||
23621 | pushFollow(FOLLOW_2); | ||
23622 | rule__ALSBasicRelationTerm__Group_8__2(); | ||
23623 | |||
23624 | state._fsp--; | ||
23625 | if (state.failed) return ; | ||
23626 | |||
23627 | } | ||
23628 | |||
23629 | } | ||
23630 | catch (RecognitionException re) { | ||
23631 | reportError(re); | ||
23632 | recover(input,re); | ||
23633 | } | ||
23634 | finally { | ||
23635 | |||
23636 | restoreStackSize(stackSize); | ||
23637 | |||
23638 | } | ||
23639 | return ; | ||
23640 | } | ||
23641 | // $ANTLR end "rule__ALSBasicRelationTerm__Group_8__1" | ||
23642 | |||
23643 | |||
23644 | // $ANTLR start "rule__ALSBasicRelationTerm__Group_8__1__Impl" | ||
23645 | // InternalAlloyLanguage.g:8409:1: rule__ALSBasicRelationTerm__Group_8__1__Impl : ( ruleALSTerm ) ; | ||
23646 | public final void rule__ALSBasicRelationTerm__Group_8__1__Impl() throws RecognitionException { | ||
23647 | |||
23648 | int stackSize = keepStackSize(); | ||
23649 | |||
23650 | try { | ||
23651 | // InternalAlloyLanguage.g:8413:1: ( ( ruleALSTerm ) ) | ||
23652 | // InternalAlloyLanguage.g:8414:1: ( ruleALSTerm ) | ||
23653 | { | ||
23654 | // InternalAlloyLanguage.g:8414:1: ( ruleALSTerm ) | ||
23655 | // InternalAlloyLanguage.g:8415:1: ruleALSTerm | ||
23656 | { | ||
23657 | if ( state.backtracking==0 ) { | ||
23658 | before(grammarAccess.getALSBasicRelationTermAccess().getALSTermParserRuleCall_8_1()); | ||
23659 | } | ||
23660 | pushFollow(FOLLOW_2); | ||
23661 | ruleALSTerm(); | ||
23662 | |||
23663 | state._fsp--; | ||
23664 | if (state.failed) return ; | ||
23665 | if ( state.backtracking==0 ) { | ||
23666 | after(grammarAccess.getALSBasicRelationTermAccess().getALSTermParserRuleCall_8_1()); | ||
23667 | } | ||
23668 | |||
23669 | } | ||
23670 | |||
23671 | |||
23672 | } | ||
23673 | |||
23674 | } | ||
23675 | catch (RecognitionException re) { | ||
23676 | reportError(re); | ||
23677 | recover(input,re); | ||
23678 | } | ||
23679 | finally { | ||
23680 | |||
23681 | restoreStackSize(stackSize); | ||
23682 | |||
23683 | } | ||
23684 | return ; | ||
23685 | } | ||
23686 | // $ANTLR end "rule__ALSBasicRelationTerm__Group_8__1__Impl" | ||
23687 | |||
23688 | |||
23689 | // $ANTLR start "rule__ALSBasicRelationTerm__Group_8__2" | ||
23690 | // InternalAlloyLanguage.g:8426:1: rule__ALSBasicRelationTerm__Group_8__2 : rule__ALSBasicRelationTerm__Group_8__2__Impl ; | ||
23691 | public final void rule__ALSBasicRelationTerm__Group_8__2() throws RecognitionException { | ||
23692 | |||
23693 | int stackSize = keepStackSize(); | ||
23694 | |||
23695 | try { | ||
23696 | // InternalAlloyLanguage.g:8430:1: ( rule__ALSBasicRelationTerm__Group_8__2__Impl ) | ||
23697 | // InternalAlloyLanguage.g:8431:2: rule__ALSBasicRelationTerm__Group_8__2__Impl | ||
23698 | { | ||
23699 | pushFollow(FOLLOW_2); | ||
23700 | rule__ALSBasicRelationTerm__Group_8__2__Impl(); | ||
23701 | |||
23702 | state._fsp--; | ||
23703 | if (state.failed) return ; | ||
23704 | |||
23705 | } | ||
23706 | |||
23707 | } | ||
23708 | catch (RecognitionException re) { | ||
23709 | reportError(re); | ||
23710 | recover(input,re); | ||
23711 | } | ||
23712 | finally { | ||
23713 | |||
23714 | restoreStackSize(stackSize); | ||
23715 | |||
23716 | } | ||
23717 | return ; | ||
23718 | } | ||
23719 | // $ANTLR end "rule__ALSBasicRelationTerm__Group_8__2" | ||
23720 | |||
23721 | |||
23722 | // $ANTLR start "rule__ALSBasicRelationTerm__Group_8__2__Impl" | ||
23723 | // InternalAlloyLanguage.g:8437:1: rule__ALSBasicRelationTerm__Group_8__2__Impl : ( ')' ) ; | ||
23724 | public final void rule__ALSBasicRelationTerm__Group_8__2__Impl() throws RecognitionException { | ||
23725 | |||
23726 | int stackSize = keepStackSize(); | ||
23727 | |||
23728 | try { | ||
23729 | // InternalAlloyLanguage.g:8441:1: ( ( ')' ) ) | ||
23730 | // InternalAlloyLanguage.g:8442:1: ( ')' ) | ||
23731 | { | ||
23732 | // InternalAlloyLanguage.g:8442:1: ( ')' ) | ||
23733 | // InternalAlloyLanguage.g:8443:1: ')' | ||
23734 | { | ||
23735 | if ( state.backtracking==0 ) { | ||
23736 | before(grammarAccess.getALSBasicRelationTermAccess().getRightParenthesisKeyword_8_2()); | ||
23737 | } | ||
23738 | match(input,71,FOLLOW_2); if (state.failed) return ; | ||
23739 | if ( state.backtracking==0 ) { | ||
23740 | after(grammarAccess.getALSBasicRelationTermAccess().getRightParenthesisKeyword_8_2()); | ||
23741 | } | ||
23742 | |||
23743 | } | ||
23744 | |||
23745 | |||
23746 | } | ||
23747 | |||
23748 | } | ||
23749 | catch (RecognitionException re) { | ||
23750 | reportError(re); | ||
23751 | recover(input,re); | ||
23752 | } | ||
23753 | finally { | ||
23754 | |||
23755 | restoreStackSize(stackSize); | ||
23756 | |||
23757 | } | ||
23758 | return ; | ||
23759 | } | ||
23760 | // $ANTLR end "rule__ALSBasicRelationTerm__Group_8__2__Impl" | ||
23761 | |||
23762 | |||
23763 | // $ANTLR start "rule__ALSRunCommand__Group__0" | ||
23764 | // InternalAlloyLanguage.g:8462:1: rule__ALSRunCommand__Group__0 : rule__ALSRunCommand__Group__0__Impl rule__ALSRunCommand__Group__1 ; | ||
23765 | public final void rule__ALSRunCommand__Group__0() throws RecognitionException { | ||
23766 | |||
23767 | int stackSize = keepStackSize(); | ||
23768 | |||
23769 | try { | ||
23770 | // InternalAlloyLanguage.g:8466:1: ( rule__ALSRunCommand__Group__0__Impl rule__ALSRunCommand__Group__1 ) | ||
23771 | // InternalAlloyLanguage.g:8467:2: rule__ALSRunCommand__Group__0__Impl rule__ALSRunCommand__Group__1 | ||
23772 | { | ||
23773 | pushFollow(FOLLOW_3); | ||
23774 | rule__ALSRunCommand__Group__0__Impl(); | ||
23775 | |||
23776 | state._fsp--; | ||
23777 | if (state.failed) return ; | ||
23778 | pushFollow(FOLLOW_2); | ||
23779 | rule__ALSRunCommand__Group__1(); | ||
23780 | |||
23781 | state._fsp--; | ||
23782 | if (state.failed) return ; | ||
23783 | |||
23784 | } | ||
23785 | |||
23786 | } | ||
23787 | catch (RecognitionException re) { | ||
23788 | reportError(re); | ||
23789 | recover(input,re); | ||
23790 | } | ||
23791 | finally { | ||
23792 | |||
23793 | restoreStackSize(stackSize); | ||
23794 | |||
23795 | } | ||
23796 | return ; | ||
23797 | } | ||
23798 | // $ANTLR end "rule__ALSRunCommand__Group__0" | ||
23799 | |||
23800 | |||
23801 | // $ANTLR start "rule__ALSRunCommand__Group__0__Impl" | ||
23802 | // InternalAlloyLanguage.g:8474:1: rule__ALSRunCommand__Group__0__Impl : ( () ) ; | ||
23803 | public final void rule__ALSRunCommand__Group__0__Impl() throws RecognitionException { | ||
23804 | |||
23805 | int stackSize = keepStackSize(); | ||
23806 | |||
23807 | try { | ||
23808 | // InternalAlloyLanguage.g:8478:1: ( ( () ) ) | ||
23809 | // InternalAlloyLanguage.g:8479:1: ( () ) | ||
23810 | { | ||
23811 | // InternalAlloyLanguage.g:8479:1: ( () ) | ||
23812 | // InternalAlloyLanguage.g:8480:1: () | ||
23813 | { | ||
23814 | if ( state.backtracking==0 ) { | ||
23815 | before(grammarAccess.getALSRunCommandAccess().getALSRunCommandAction_0()); | ||
23816 | } | ||
23817 | // InternalAlloyLanguage.g:8481:1: () | ||
23818 | // InternalAlloyLanguage.g:8483:1: | ||
23819 | { | ||
23820 | } | ||
23821 | |||
23822 | if ( state.backtracking==0 ) { | ||
23823 | after(grammarAccess.getALSRunCommandAccess().getALSRunCommandAction_0()); | ||
23824 | } | ||
23825 | |||
23826 | } | ||
23827 | |||
23828 | |||
23829 | } | ||
23830 | |||
23831 | } | ||
23832 | finally { | ||
23833 | |||
23834 | restoreStackSize(stackSize); | ||
23835 | |||
23836 | } | ||
23837 | return ; | ||
23838 | } | ||
23839 | // $ANTLR end "rule__ALSRunCommand__Group__0__Impl" | ||
23840 | |||
23841 | |||
23842 | // $ANTLR start "rule__ALSRunCommand__Group__1" | ||
23843 | // InternalAlloyLanguage.g:8493:1: rule__ALSRunCommand__Group__1 : rule__ALSRunCommand__Group__1__Impl rule__ALSRunCommand__Group__2 ; | ||
23844 | public final void rule__ALSRunCommand__Group__1() throws RecognitionException { | ||
23845 | |||
23846 | int stackSize = keepStackSize(); | ||
23847 | |||
23848 | try { | ||
23849 | // InternalAlloyLanguage.g:8497:1: ( rule__ALSRunCommand__Group__1__Impl rule__ALSRunCommand__Group__2 ) | ||
23850 | // InternalAlloyLanguage.g:8498:2: rule__ALSRunCommand__Group__1__Impl rule__ALSRunCommand__Group__2 | ||
23851 | { | ||
23852 | pushFollow(FOLLOW_6); | ||
23853 | rule__ALSRunCommand__Group__1__Impl(); | ||
23854 | |||
23855 | state._fsp--; | ||
23856 | if (state.failed) return ; | ||
23857 | pushFollow(FOLLOW_2); | ||
23858 | rule__ALSRunCommand__Group__2(); | ||
23859 | |||
23860 | state._fsp--; | ||
23861 | if (state.failed) return ; | ||
23862 | |||
23863 | } | ||
23864 | |||
23865 | } | ||
23866 | catch (RecognitionException re) { | ||
23867 | reportError(re); | ||
23868 | recover(input,re); | ||
23869 | } | ||
23870 | finally { | ||
23871 | |||
23872 | restoreStackSize(stackSize); | ||
23873 | |||
23874 | } | ||
23875 | return ; | ||
23876 | } | ||
23877 | // $ANTLR end "rule__ALSRunCommand__Group__1" | ||
23878 | |||
23879 | |||
23880 | // $ANTLR start "rule__ALSRunCommand__Group__1__Impl" | ||
23881 | // InternalAlloyLanguage.g:8505:1: rule__ALSRunCommand__Group__1__Impl : ( 'run' ) ; | ||
23882 | public final void rule__ALSRunCommand__Group__1__Impl() throws RecognitionException { | ||
23883 | |||
23884 | int stackSize = keepStackSize(); | ||
23885 | |||
23886 | try { | ||
23887 | // InternalAlloyLanguage.g:8509:1: ( ( 'run' ) ) | ||
23888 | // InternalAlloyLanguage.g:8510:1: ( 'run' ) | ||
23889 | { | ||
23890 | // InternalAlloyLanguage.g:8510:1: ( 'run' ) | ||
23891 | // InternalAlloyLanguage.g:8511:1: 'run' | ||
23892 | { | ||
23893 | if ( state.backtracking==0 ) { | ||
23894 | before(grammarAccess.getALSRunCommandAccess().getRunKeyword_1()); | ||
23895 | } | ||
23896 | match(input,72,FOLLOW_2); if (state.failed) return ; | ||
23897 | if ( state.backtracking==0 ) { | ||
23898 | after(grammarAccess.getALSRunCommandAccess().getRunKeyword_1()); | ||
23899 | } | ||
23900 | |||
23901 | } | ||
23902 | |||
23903 | |||
23904 | } | ||
23905 | |||
23906 | } | ||
23907 | catch (RecognitionException re) { | ||
23908 | reportError(re); | ||
23909 | recover(input,re); | ||
23910 | } | ||
23911 | finally { | ||
23912 | |||
23913 | restoreStackSize(stackSize); | ||
23914 | |||
23915 | } | ||
23916 | return ; | ||
23917 | } | ||
23918 | // $ANTLR end "rule__ALSRunCommand__Group__1__Impl" | ||
23919 | |||
23920 | |||
23921 | // $ANTLR start "rule__ALSRunCommand__Group__2" | ||
23922 | // InternalAlloyLanguage.g:8524:1: rule__ALSRunCommand__Group__2 : rule__ALSRunCommand__Group__2__Impl rule__ALSRunCommand__Group__3 ; | ||
23923 | public final void rule__ALSRunCommand__Group__2() throws RecognitionException { | ||
23924 | |||
23925 | int stackSize = keepStackSize(); | ||
23926 | |||
23927 | try { | ||
23928 | // InternalAlloyLanguage.g:8528:1: ( rule__ALSRunCommand__Group__2__Impl rule__ALSRunCommand__Group__3 ) | ||
23929 | // InternalAlloyLanguage.g:8529:2: rule__ALSRunCommand__Group__2__Impl rule__ALSRunCommand__Group__3 | ||
23930 | { | ||
23931 | pushFollow(FOLLOW_19); | ||
23932 | rule__ALSRunCommand__Group__2__Impl(); | ||
23933 | |||
23934 | state._fsp--; | ||
23935 | if (state.failed) return ; | ||
23936 | pushFollow(FOLLOW_2); | ||
23937 | rule__ALSRunCommand__Group__3(); | ||
23938 | |||
23939 | state._fsp--; | ||
23940 | if (state.failed) return ; | ||
23941 | |||
23942 | } | ||
23943 | |||
23944 | } | ||
23945 | catch (RecognitionException re) { | ||
23946 | reportError(re); | ||
23947 | recover(input,re); | ||
23948 | } | ||
23949 | finally { | ||
23950 | |||
23951 | restoreStackSize(stackSize); | ||
23952 | |||
23953 | } | ||
23954 | return ; | ||
23955 | } | ||
23956 | // $ANTLR end "rule__ALSRunCommand__Group__2" | ||
23957 | |||
23958 | |||
23959 | // $ANTLR start "rule__ALSRunCommand__Group__2__Impl" | ||
23960 | // InternalAlloyLanguage.g:8536:1: rule__ALSRunCommand__Group__2__Impl : ( '{' ) ; | ||
23961 | public final void rule__ALSRunCommand__Group__2__Impl() throws RecognitionException { | ||
23962 | |||
23963 | int stackSize = keepStackSize(); | ||
23964 | |||
23965 | try { | ||
23966 | // InternalAlloyLanguage.g:8540:1: ( ( '{' ) ) | ||
23967 | // InternalAlloyLanguage.g:8541:1: ( '{' ) | ||
23968 | { | ||
23969 | // InternalAlloyLanguage.g:8541:1: ( '{' ) | ||
23970 | // InternalAlloyLanguage.g:8542:1: '{' | ||
23971 | { | ||
23972 | if ( state.backtracking==0 ) { | ||
23973 | before(grammarAccess.getALSRunCommandAccess().getLeftCurlyBracketKeyword_2()); | ||
23974 | } | ||
23975 | match(input,33,FOLLOW_2); if (state.failed) return ; | ||
23976 | if ( state.backtracking==0 ) { | ||
23977 | after(grammarAccess.getALSRunCommandAccess().getLeftCurlyBracketKeyword_2()); | ||
23978 | } | ||
23979 | |||
23980 | } | ||
23981 | |||
23982 | |||
23983 | } | ||
23984 | |||
23985 | } | ||
23986 | catch (RecognitionException re) { | ||
23987 | reportError(re); | ||
23988 | recover(input,re); | ||
23989 | } | ||
23990 | finally { | ||
23991 | |||
23992 | restoreStackSize(stackSize); | ||
23993 | |||
23994 | } | ||
23995 | return ; | ||
23996 | } | ||
23997 | // $ANTLR end "rule__ALSRunCommand__Group__2__Impl" | ||
23998 | |||
23999 | |||
24000 | // $ANTLR start "rule__ALSRunCommand__Group__3" | ||
24001 | // InternalAlloyLanguage.g:8555:1: rule__ALSRunCommand__Group__3 : rule__ALSRunCommand__Group__3__Impl rule__ALSRunCommand__Group__4 ; | ||
24002 | public final void rule__ALSRunCommand__Group__3() throws RecognitionException { | ||
24003 | |||
24004 | int stackSize = keepStackSize(); | ||
24005 | |||
24006 | try { | ||
24007 | // InternalAlloyLanguage.g:8559:1: ( rule__ALSRunCommand__Group__3__Impl rule__ALSRunCommand__Group__4 ) | ||
24008 | // InternalAlloyLanguage.g:8560:2: rule__ALSRunCommand__Group__3__Impl rule__ALSRunCommand__Group__4 | ||
24009 | { | ||
24010 | pushFollow(FOLLOW_62); | ||
24011 | rule__ALSRunCommand__Group__3__Impl(); | ||
24012 | |||
24013 | state._fsp--; | ||
24014 | if (state.failed) return ; | ||
24015 | pushFollow(FOLLOW_2); | ||
24016 | rule__ALSRunCommand__Group__4(); | ||
24017 | |||
24018 | state._fsp--; | ||
24019 | if (state.failed) return ; | ||
24020 | |||
24021 | } | ||
24022 | |||
24023 | } | ||
24024 | catch (RecognitionException re) { | ||
24025 | reportError(re); | ||
24026 | recover(input,re); | ||
24027 | } | ||
24028 | finally { | ||
24029 | |||
24030 | restoreStackSize(stackSize); | ||
24031 | |||
24032 | } | ||
24033 | return ; | ||
24034 | } | ||
24035 | // $ANTLR end "rule__ALSRunCommand__Group__3" | ||
24036 | |||
24037 | |||
24038 | // $ANTLR start "rule__ALSRunCommand__Group__3__Impl" | ||
24039 | // InternalAlloyLanguage.g:8567:1: rule__ALSRunCommand__Group__3__Impl : ( '}' ) ; | ||
24040 | public final void rule__ALSRunCommand__Group__3__Impl() throws RecognitionException { | ||
24041 | |||
24042 | int stackSize = keepStackSize(); | ||
24043 | |||
24044 | try { | ||
24045 | // InternalAlloyLanguage.g:8571:1: ( ( '}' ) ) | ||
24046 | // InternalAlloyLanguage.g:8572:1: ( '}' ) | ||
24047 | { | ||
24048 | // InternalAlloyLanguage.g:8572:1: ( '}' ) | ||
24049 | // InternalAlloyLanguage.g:8573:1: '}' | ||
24050 | { | ||
24051 | if ( state.backtracking==0 ) { | ||
24052 | before(grammarAccess.getALSRunCommandAccess().getRightCurlyBracketKeyword_3()); | ||
24053 | } | ||
24054 | match(input,34,FOLLOW_2); if (state.failed) return ; | ||
24055 | if ( state.backtracking==0 ) { | ||
24056 | after(grammarAccess.getALSRunCommandAccess().getRightCurlyBracketKeyword_3()); | ||
24057 | } | ||
24058 | |||
24059 | } | ||
24060 | |||
24061 | |||
24062 | } | ||
24063 | |||
24064 | } | ||
24065 | catch (RecognitionException re) { | ||
24066 | reportError(re); | ||
24067 | recover(input,re); | ||
24068 | } | ||
24069 | finally { | ||
24070 | |||
24071 | restoreStackSize(stackSize); | ||
24072 | |||
24073 | } | ||
24074 | return ; | ||
24075 | } | ||
24076 | // $ANTLR end "rule__ALSRunCommand__Group__3__Impl" | ||
24077 | |||
24078 | |||
24079 | // $ANTLR start "rule__ALSRunCommand__Group__4" | ||
24080 | // InternalAlloyLanguage.g:8586:1: rule__ALSRunCommand__Group__4 : rule__ALSRunCommand__Group__4__Impl ; | ||
24081 | public final void rule__ALSRunCommand__Group__4() throws RecognitionException { | ||
24082 | |||
24083 | int stackSize = keepStackSize(); | ||
24084 | |||
24085 | try { | ||
24086 | // InternalAlloyLanguage.g:8590:1: ( rule__ALSRunCommand__Group__4__Impl ) | ||
24087 | // InternalAlloyLanguage.g:8591:2: rule__ALSRunCommand__Group__4__Impl | ||
24088 | { | ||
24089 | pushFollow(FOLLOW_2); | ||
24090 | rule__ALSRunCommand__Group__4__Impl(); | ||
24091 | |||
24092 | state._fsp--; | ||
24093 | if (state.failed) return ; | ||
24094 | |||
24095 | } | ||
24096 | |||
24097 | } | ||
24098 | catch (RecognitionException re) { | ||
24099 | reportError(re); | ||
24100 | recover(input,re); | ||
24101 | } | ||
24102 | finally { | ||
24103 | |||
24104 | restoreStackSize(stackSize); | ||
24105 | |||
24106 | } | ||
24107 | return ; | ||
24108 | } | ||
24109 | // $ANTLR end "rule__ALSRunCommand__Group__4" | ||
24110 | |||
24111 | |||
24112 | // $ANTLR start "rule__ALSRunCommand__Group__4__Impl" | ||
24113 | // InternalAlloyLanguage.g:8597:1: rule__ALSRunCommand__Group__4__Impl : ( ( rule__ALSRunCommand__Group_4__0 )? ) ; | ||
24114 | public final void rule__ALSRunCommand__Group__4__Impl() throws RecognitionException { | ||
24115 | |||
24116 | int stackSize = keepStackSize(); | ||
24117 | |||
24118 | try { | ||
24119 | // InternalAlloyLanguage.g:8601:1: ( ( ( rule__ALSRunCommand__Group_4__0 )? ) ) | ||
24120 | // InternalAlloyLanguage.g:8602:1: ( ( rule__ALSRunCommand__Group_4__0 )? ) | ||
24121 | { | ||
24122 | // InternalAlloyLanguage.g:8602:1: ( ( rule__ALSRunCommand__Group_4__0 )? ) | ||
24123 | // InternalAlloyLanguage.g:8603:1: ( rule__ALSRunCommand__Group_4__0 )? | ||
24124 | { | ||
24125 | if ( state.backtracking==0 ) { | ||
24126 | before(grammarAccess.getALSRunCommandAccess().getGroup_4()); | ||
24127 | } | ||
24128 | // InternalAlloyLanguage.g:8604:1: ( rule__ALSRunCommand__Group_4__0 )? | ||
24129 | int alt48=2; | ||
24130 | int LA48_0 = input.LA(1); | ||
24131 | |||
24132 | if ( (LA48_0==73) ) { | ||
24133 | alt48=1; | ||
24134 | } | ||
24135 | switch (alt48) { | ||
24136 | case 1 : | ||
24137 | // InternalAlloyLanguage.g:8604:2: rule__ALSRunCommand__Group_4__0 | ||
24138 | { | ||
24139 | pushFollow(FOLLOW_2); | ||
24140 | rule__ALSRunCommand__Group_4__0(); | ||
24141 | |||
24142 | state._fsp--; | ||
24143 | if (state.failed) return ; | ||
24144 | |||
24145 | } | ||
24146 | break; | ||
24147 | |||
24148 | } | ||
24149 | |||
24150 | if ( state.backtracking==0 ) { | ||
24151 | after(grammarAccess.getALSRunCommandAccess().getGroup_4()); | ||
24152 | } | ||
24153 | |||
24154 | } | ||
24155 | |||
24156 | |||
24157 | } | ||
24158 | |||
24159 | } | ||
24160 | catch (RecognitionException re) { | ||
24161 | reportError(re); | ||
24162 | recover(input,re); | ||
24163 | } | ||
24164 | finally { | ||
24165 | |||
24166 | restoreStackSize(stackSize); | ||
24167 | |||
24168 | } | ||
24169 | return ; | ||
24170 | } | ||
24171 | // $ANTLR end "rule__ALSRunCommand__Group__4__Impl" | ||
24172 | |||
24173 | |||
24174 | // $ANTLR start "rule__ALSRunCommand__Group_4__0" | ||
24175 | // InternalAlloyLanguage.g:8624:1: rule__ALSRunCommand__Group_4__0 : rule__ALSRunCommand__Group_4__0__Impl rule__ALSRunCommand__Group_4__1 ; | ||
24176 | public final void rule__ALSRunCommand__Group_4__0() throws RecognitionException { | ||
24177 | |||
24178 | int stackSize = keepStackSize(); | ||
24179 | |||
24180 | try { | ||
24181 | // InternalAlloyLanguage.g:8628:1: ( rule__ALSRunCommand__Group_4__0__Impl rule__ALSRunCommand__Group_4__1 ) | ||
24182 | // InternalAlloyLanguage.g:8629:2: rule__ALSRunCommand__Group_4__0__Impl rule__ALSRunCommand__Group_4__1 | ||
24183 | { | ||
24184 | pushFollow(FOLLOW_63); | ||
24185 | rule__ALSRunCommand__Group_4__0__Impl(); | ||
24186 | |||
24187 | state._fsp--; | ||
24188 | if (state.failed) return ; | ||
24189 | pushFollow(FOLLOW_2); | ||
24190 | rule__ALSRunCommand__Group_4__1(); | ||
24191 | |||
24192 | state._fsp--; | ||
24193 | if (state.failed) return ; | ||
24194 | |||
24195 | } | ||
24196 | |||
24197 | } | ||
24198 | catch (RecognitionException re) { | ||
24199 | reportError(re); | ||
24200 | recover(input,re); | ||
24201 | } | ||
24202 | finally { | ||
24203 | |||
24204 | restoreStackSize(stackSize); | ||
24205 | |||
24206 | } | ||
24207 | return ; | ||
24208 | } | ||
24209 | // $ANTLR end "rule__ALSRunCommand__Group_4__0" | ||
24210 | |||
24211 | |||
24212 | // $ANTLR start "rule__ALSRunCommand__Group_4__0__Impl" | ||
24213 | // InternalAlloyLanguage.g:8636:1: rule__ALSRunCommand__Group_4__0__Impl : ( 'for' ) ; | ||
24214 | public final void rule__ALSRunCommand__Group_4__0__Impl() throws RecognitionException { | ||
24215 | |||
24216 | int stackSize = keepStackSize(); | ||
24217 | |||
24218 | try { | ||
24219 | // InternalAlloyLanguage.g:8640:1: ( ( 'for' ) ) | ||
24220 | // InternalAlloyLanguage.g:8641:1: ( 'for' ) | ||
24221 | { | ||
24222 | // InternalAlloyLanguage.g:8641:1: ( 'for' ) | ||
24223 | // InternalAlloyLanguage.g:8642:1: 'for' | ||
24224 | { | ||
24225 | if ( state.backtracking==0 ) { | ||
24226 | before(grammarAccess.getALSRunCommandAccess().getForKeyword_4_0()); | ||
24227 | } | ||
24228 | match(input,73,FOLLOW_2); if (state.failed) return ; | ||
24229 | if ( state.backtracking==0 ) { | ||
24230 | after(grammarAccess.getALSRunCommandAccess().getForKeyword_4_0()); | ||
24231 | } | ||
24232 | |||
24233 | } | ||
24234 | |||
24235 | |||
24236 | } | ||
24237 | |||
24238 | } | ||
24239 | catch (RecognitionException re) { | ||
24240 | reportError(re); | ||
24241 | recover(input,re); | ||
24242 | } | ||
24243 | finally { | ||
24244 | |||
24245 | restoreStackSize(stackSize); | ||
24246 | |||
24247 | } | ||
24248 | return ; | ||
24249 | } | ||
24250 | // $ANTLR end "rule__ALSRunCommand__Group_4__0__Impl" | ||
24251 | |||
24252 | |||
24253 | // $ANTLR start "rule__ALSRunCommand__Group_4__1" | ||
24254 | // InternalAlloyLanguage.g:8655:1: rule__ALSRunCommand__Group_4__1 : rule__ALSRunCommand__Group_4__1__Impl rule__ALSRunCommand__Group_4__2 ; | ||
24255 | public final void rule__ALSRunCommand__Group_4__1() throws RecognitionException { | ||
24256 | |||
24257 | int stackSize = keepStackSize(); | ||
24258 | |||
24259 | try { | ||
24260 | // InternalAlloyLanguage.g:8659:1: ( rule__ALSRunCommand__Group_4__1__Impl rule__ALSRunCommand__Group_4__2 ) | ||
24261 | // InternalAlloyLanguage.g:8660:2: rule__ALSRunCommand__Group_4__1__Impl rule__ALSRunCommand__Group_4__2 | ||
24262 | { | ||
24263 | pushFollow(FOLLOW_14); | ||
24264 | rule__ALSRunCommand__Group_4__1__Impl(); | ||
24265 | |||
24266 | state._fsp--; | ||
24267 | if (state.failed) return ; | ||
24268 | pushFollow(FOLLOW_2); | ||
24269 | rule__ALSRunCommand__Group_4__2(); | ||
24270 | |||
24271 | state._fsp--; | ||
24272 | if (state.failed) return ; | ||
24273 | |||
24274 | } | ||
24275 | |||
24276 | } | ||
24277 | catch (RecognitionException re) { | ||
24278 | reportError(re); | ||
24279 | recover(input,re); | ||
24280 | } | ||
24281 | finally { | ||
24282 | |||
24283 | restoreStackSize(stackSize); | ||
24284 | |||
24285 | } | ||
24286 | return ; | ||
24287 | } | ||
24288 | // $ANTLR end "rule__ALSRunCommand__Group_4__1" | ||
24289 | |||
24290 | |||
24291 | // $ANTLR start "rule__ALSRunCommand__Group_4__1__Impl" | ||
24292 | // InternalAlloyLanguage.g:8667:1: rule__ALSRunCommand__Group_4__1__Impl : ( ( rule__ALSRunCommand__TypeScopesAssignment_4_1 ) ) ; | ||
24293 | public final void rule__ALSRunCommand__Group_4__1__Impl() throws RecognitionException { | ||
24294 | |||
24295 | int stackSize = keepStackSize(); | ||
24296 | |||
24297 | try { | ||
24298 | // InternalAlloyLanguage.g:8671:1: ( ( ( rule__ALSRunCommand__TypeScopesAssignment_4_1 ) ) ) | ||
24299 | // InternalAlloyLanguage.g:8672:1: ( ( rule__ALSRunCommand__TypeScopesAssignment_4_1 ) ) | ||
24300 | { | ||
24301 | // InternalAlloyLanguage.g:8672:1: ( ( rule__ALSRunCommand__TypeScopesAssignment_4_1 ) ) | ||
24302 | // InternalAlloyLanguage.g:8673:1: ( rule__ALSRunCommand__TypeScopesAssignment_4_1 ) | ||
24303 | { | ||
24304 | if ( state.backtracking==0 ) { | ||
24305 | before(grammarAccess.getALSRunCommandAccess().getTypeScopesAssignment_4_1()); | ||
24306 | } | ||
24307 | // InternalAlloyLanguage.g:8674:1: ( rule__ALSRunCommand__TypeScopesAssignment_4_1 ) | ||
24308 | // InternalAlloyLanguage.g:8674:2: rule__ALSRunCommand__TypeScopesAssignment_4_1 | ||
24309 | { | ||
24310 | pushFollow(FOLLOW_2); | ||
24311 | rule__ALSRunCommand__TypeScopesAssignment_4_1(); | ||
24312 | |||
24313 | state._fsp--; | ||
24314 | if (state.failed) return ; | ||
24315 | |||
24316 | } | ||
24317 | |||
24318 | if ( state.backtracking==0 ) { | ||
24319 | after(grammarAccess.getALSRunCommandAccess().getTypeScopesAssignment_4_1()); | ||
24320 | } | ||
24321 | |||
24322 | } | ||
24323 | |||
24324 | |||
24325 | } | ||
24326 | |||
24327 | } | ||
24328 | catch (RecognitionException re) { | ||
24329 | reportError(re); | ||
24330 | recover(input,re); | ||
24331 | } | ||
24332 | finally { | ||
24333 | |||
24334 | restoreStackSize(stackSize); | ||
24335 | |||
24336 | } | ||
24337 | return ; | ||
24338 | } | ||
24339 | // $ANTLR end "rule__ALSRunCommand__Group_4__1__Impl" | ||
24340 | |||
24341 | |||
24342 | // $ANTLR start "rule__ALSRunCommand__Group_4__2" | ||
24343 | // InternalAlloyLanguage.g:8684:1: rule__ALSRunCommand__Group_4__2 : rule__ALSRunCommand__Group_4__2__Impl ; | ||
24344 | public final void rule__ALSRunCommand__Group_4__2() throws RecognitionException { | ||
24345 | |||
24346 | int stackSize = keepStackSize(); | ||
24347 | |||
24348 | try { | ||
24349 | // InternalAlloyLanguage.g:8688:1: ( rule__ALSRunCommand__Group_4__2__Impl ) | ||
24350 | // InternalAlloyLanguage.g:8689:2: rule__ALSRunCommand__Group_4__2__Impl | ||
24351 | { | ||
24352 | pushFollow(FOLLOW_2); | ||
24353 | rule__ALSRunCommand__Group_4__2__Impl(); | ||
24354 | |||
24355 | state._fsp--; | ||
24356 | if (state.failed) return ; | ||
24357 | |||
24358 | } | ||
24359 | |||
24360 | } | ||
24361 | catch (RecognitionException re) { | ||
24362 | reportError(re); | ||
24363 | recover(input,re); | ||
24364 | } | ||
24365 | finally { | ||
24366 | |||
24367 | restoreStackSize(stackSize); | ||
24368 | |||
24369 | } | ||
24370 | return ; | ||
24371 | } | ||
24372 | // $ANTLR end "rule__ALSRunCommand__Group_4__2" | ||
24373 | |||
24374 | |||
24375 | // $ANTLR start "rule__ALSRunCommand__Group_4__2__Impl" | ||
24376 | // InternalAlloyLanguage.g:8695:1: rule__ALSRunCommand__Group_4__2__Impl : ( ( rule__ALSRunCommand__Group_4_2__0 )* ) ; | ||
24377 | public final void rule__ALSRunCommand__Group_4__2__Impl() throws RecognitionException { | ||
24378 | |||
24379 | int stackSize = keepStackSize(); | ||
24380 | |||
24381 | try { | ||
24382 | // InternalAlloyLanguage.g:8699:1: ( ( ( rule__ALSRunCommand__Group_4_2__0 )* ) ) | ||
24383 | // InternalAlloyLanguage.g:8700:1: ( ( rule__ALSRunCommand__Group_4_2__0 )* ) | ||
24384 | { | ||
24385 | // InternalAlloyLanguage.g:8700:1: ( ( rule__ALSRunCommand__Group_4_2__0 )* ) | ||
24386 | // InternalAlloyLanguage.g:8701:1: ( rule__ALSRunCommand__Group_4_2__0 )* | ||
24387 | { | ||
24388 | if ( state.backtracking==0 ) { | ||
24389 | before(grammarAccess.getALSRunCommandAccess().getGroup_4_2()); | ||
24390 | } | ||
24391 | // InternalAlloyLanguage.g:8702:1: ( rule__ALSRunCommand__Group_4_2__0 )* | ||
24392 | loop49: | ||
24393 | do { | ||
24394 | int alt49=2; | ||
24395 | int LA49_0 = input.LA(1); | ||
24396 | |||
24397 | if ( (LA49_0==35) ) { | ||
24398 | alt49=1; | ||
24399 | } | ||
24400 | |||
24401 | |||
24402 | switch (alt49) { | ||
24403 | case 1 : | ||
24404 | // InternalAlloyLanguage.g:8702:2: rule__ALSRunCommand__Group_4_2__0 | ||
24405 | { | ||
24406 | pushFollow(FOLLOW_8); | ||
24407 | rule__ALSRunCommand__Group_4_2__0(); | ||
24408 | |||
24409 | state._fsp--; | ||
24410 | if (state.failed) return ; | ||
24411 | |||
24412 | } | ||
24413 | break; | ||
24414 | |||
24415 | default : | ||
24416 | break loop49; | ||
24417 | } | ||
24418 | } while (true); | ||
24419 | |||
24420 | if ( state.backtracking==0 ) { | ||
24421 | after(grammarAccess.getALSRunCommandAccess().getGroup_4_2()); | ||
24422 | } | ||
24423 | |||
24424 | } | ||
24425 | |||
24426 | |||
24427 | } | ||
24428 | |||
24429 | } | ||
24430 | catch (RecognitionException re) { | ||
24431 | reportError(re); | ||
24432 | recover(input,re); | ||
24433 | } | ||
24434 | finally { | ||
24435 | |||
24436 | restoreStackSize(stackSize); | ||
24437 | |||
24438 | } | ||
24439 | return ; | ||
24440 | } | ||
24441 | // $ANTLR end "rule__ALSRunCommand__Group_4__2__Impl" | ||
24442 | |||
24443 | |||
24444 | // $ANTLR start "rule__ALSRunCommand__Group_4_2__0" | ||
24445 | // InternalAlloyLanguage.g:8718:1: rule__ALSRunCommand__Group_4_2__0 : rule__ALSRunCommand__Group_4_2__0__Impl rule__ALSRunCommand__Group_4_2__1 ; | ||
24446 | public final void rule__ALSRunCommand__Group_4_2__0() throws RecognitionException { | ||
24447 | |||
24448 | int stackSize = keepStackSize(); | ||
24449 | |||
24450 | try { | ||
24451 | // InternalAlloyLanguage.g:8722:1: ( rule__ALSRunCommand__Group_4_2__0__Impl rule__ALSRunCommand__Group_4_2__1 ) | ||
24452 | // InternalAlloyLanguage.g:8723:2: rule__ALSRunCommand__Group_4_2__0__Impl rule__ALSRunCommand__Group_4_2__1 | ||
24453 | { | ||
24454 | pushFollow(FOLLOW_63); | ||
24455 | rule__ALSRunCommand__Group_4_2__0__Impl(); | ||
24456 | |||
24457 | state._fsp--; | ||
24458 | if (state.failed) return ; | ||
24459 | pushFollow(FOLLOW_2); | ||
24460 | rule__ALSRunCommand__Group_4_2__1(); | ||
24461 | |||
24462 | state._fsp--; | ||
24463 | if (state.failed) return ; | ||
24464 | |||
24465 | } | ||
24466 | |||
24467 | } | ||
24468 | catch (RecognitionException re) { | ||
24469 | reportError(re); | ||
24470 | recover(input,re); | ||
24471 | } | ||
24472 | finally { | ||
24473 | |||
24474 | restoreStackSize(stackSize); | ||
24475 | |||
24476 | } | ||
24477 | return ; | ||
24478 | } | ||
24479 | // $ANTLR end "rule__ALSRunCommand__Group_4_2__0" | ||
24480 | |||
24481 | |||
24482 | // $ANTLR start "rule__ALSRunCommand__Group_4_2__0__Impl" | ||
24483 | // InternalAlloyLanguage.g:8730:1: rule__ALSRunCommand__Group_4_2__0__Impl : ( ',' ) ; | ||
24484 | public final void rule__ALSRunCommand__Group_4_2__0__Impl() throws RecognitionException { | ||
24485 | |||
24486 | int stackSize = keepStackSize(); | ||
24487 | |||
24488 | try { | ||
24489 | // InternalAlloyLanguage.g:8734:1: ( ( ',' ) ) | ||
24490 | // InternalAlloyLanguage.g:8735:1: ( ',' ) | ||
24491 | { | ||
24492 | // InternalAlloyLanguage.g:8735:1: ( ',' ) | ||
24493 | // InternalAlloyLanguage.g:8736:1: ',' | ||
24494 | { | ||
24495 | if ( state.backtracking==0 ) { | ||
24496 | before(grammarAccess.getALSRunCommandAccess().getCommaKeyword_4_2_0()); | ||
24497 | } | ||
24498 | match(input,35,FOLLOW_2); if (state.failed) return ; | ||
24499 | if ( state.backtracking==0 ) { | ||
24500 | after(grammarAccess.getALSRunCommandAccess().getCommaKeyword_4_2_0()); | ||
24501 | } | ||
24502 | |||
24503 | } | ||
24504 | |||
24505 | |||
24506 | } | ||
24507 | |||
24508 | } | ||
24509 | catch (RecognitionException re) { | ||
24510 | reportError(re); | ||
24511 | recover(input,re); | ||
24512 | } | ||
24513 | finally { | ||
24514 | |||
24515 | restoreStackSize(stackSize); | ||
24516 | |||
24517 | } | ||
24518 | return ; | ||
24519 | } | ||
24520 | // $ANTLR end "rule__ALSRunCommand__Group_4_2__0__Impl" | ||
24521 | |||
24522 | |||
24523 | // $ANTLR start "rule__ALSRunCommand__Group_4_2__1" | ||
24524 | // InternalAlloyLanguage.g:8749:1: rule__ALSRunCommand__Group_4_2__1 : rule__ALSRunCommand__Group_4_2__1__Impl ; | ||
24525 | public final void rule__ALSRunCommand__Group_4_2__1() throws RecognitionException { | ||
24526 | |||
24527 | int stackSize = keepStackSize(); | ||
24528 | |||
24529 | try { | ||
24530 | // InternalAlloyLanguage.g:8753:1: ( rule__ALSRunCommand__Group_4_2__1__Impl ) | ||
24531 | // InternalAlloyLanguage.g:8754:2: rule__ALSRunCommand__Group_4_2__1__Impl | ||
24532 | { | ||
24533 | pushFollow(FOLLOW_2); | ||
24534 | rule__ALSRunCommand__Group_4_2__1__Impl(); | ||
24535 | |||
24536 | state._fsp--; | ||
24537 | if (state.failed) return ; | ||
24538 | |||
24539 | } | ||
24540 | |||
24541 | } | ||
24542 | catch (RecognitionException re) { | ||
24543 | reportError(re); | ||
24544 | recover(input,re); | ||
24545 | } | ||
24546 | finally { | ||
24547 | |||
24548 | restoreStackSize(stackSize); | ||
24549 | |||
24550 | } | ||
24551 | return ; | ||
24552 | } | ||
24553 | // $ANTLR end "rule__ALSRunCommand__Group_4_2__1" | ||
24554 | |||
24555 | |||
24556 | // $ANTLR start "rule__ALSRunCommand__Group_4_2__1__Impl" | ||
24557 | // InternalAlloyLanguage.g:8760:1: rule__ALSRunCommand__Group_4_2__1__Impl : ( ( rule__ALSRunCommand__TypeScopesAssignment_4_2_1 ) ) ; | ||
24558 | public final void rule__ALSRunCommand__Group_4_2__1__Impl() throws RecognitionException { | ||
24559 | |||
24560 | int stackSize = keepStackSize(); | ||
24561 | |||
24562 | try { | ||
24563 | // InternalAlloyLanguage.g:8764:1: ( ( ( rule__ALSRunCommand__TypeScopesAssignment_4_2_1 ) ) ) | ||
24564 | // InternalAlloyLanguage.g:8765:1: ( ( rule__ALSRunCommand__TypeScopesAssignment_4_2_1 ) ) | ||
24565 | { | ||
24566 | // InternalAlloyLanguage.g:8765:1: ( ( rule__ALSRunCommand__TypeScopesAssignment_4_2_1 ) ) | ||
24567 | // InternalAlloyLanguage.g:8766:1: ( rule__ALSRunCommand__TypeScopesAssignment_4_2_1 ) | ||
24568 | { | ||
24569 | if ( state.backtracking==0 ) { | ||
24570 | before(grammarAccess.getALSRunCommandAccess().getTypeScopesAssignment_4_2_1()); | ||
24571 | } | ||
24572 | // InternalAlloyLanguage.g:8767:1: ( rule__ALSRunCommand__TypeScopesAssignment_4_2_1 ) | ||
24573 | // InternalAlloyLanguage.g:8767:2: rule__ALSRunCommand__TypeScopesAssignment_4_2_1 | ||
24574 | { | ||
24575 | pushFollow(FOLLOW_2); | ||
24576 | rule__ALSRunCommand__TypeScopesAssignment_4_2_1(); | ||
24577 | |||
24578 | state._fsp--; | ||
24579 | if (state.failed) return ; | ||
24580 | |||
24581 | } | ||
24582 | |||
24583 | if ( state.backtracking==0 ) { | ||
24584 | after(grammarAccess.getALSRunCommandAccess().getTypeScopesAssignment_4_2_1()); | ||
24585 | } | ||
24586 | |||
24587 | } | ||
24588 | |||
24589 | |||
24590 | } | ||
24591 | |||
24592 | } | ||
24593 | catch (RecognitionException re) { | ||
24594 | reportError(re); | ||
24595 | recover(input,re); | ||
24596 | } | ||
24597 | finally { | ||
24598 | |||
24599 | restoreStackSize(stackSize); | ||
24600 | |||
24601 | } | ||
24602 | return ; | ||
24603 | } | ||
24604 | // $ANTLR end "rule__ALSRunCommand__Group_4_2__1__Impl" | ||
24605 | |||
24606 | |||
24607 | // $ANTLR start "rule__ALSSigScope__Group__0" | ||
24608 | // InternalAlloyLanguage.g:8781:1: rule__ALSSigScope__Group__0 : rule__ALSSigScope__Group__0__Impl rule__ALSSigScope__Group__1 ; | ||
24609 | public final void rule__ALSSigScope__Group__0() throws RecognitionException { | ||
24610 | |||
24611 | int stackSize = keepStackSize(); | ||
24612 | |||
24613 | try { | ||
24614 | // InternalAlloyLanguage.g:8785:1: ( rule__ALSSigScope__Group__0__Impl rule__ALSSigScope__Group__1 ) | ||
24615 | // InternalAlloyLanguage.g:8786:2: rule__ALSSigScope__Group__0__Impl rule__ALSSigScope__Group__1 | ||
24616 | { | ||
24617 | pushFollow(FOLLOW_63); | ||
24618 | rule__ALSSigScope__Group__0__Impl(); | ||
24619 | |||
24620 | state._fsp--; | ||
24621 | if (state.failed) return ; | ||
24622 | pushFollow(FOLLOW_2); | ||
24623 | rule__ALSSigScope__Group__1(); | ||
24624 | |||
24625 | state._fsp--; | ||
24626 | if (state.failed) return ; | ||
24627 | |||
24628 | } | ||
24629 | |||
24630 | } | ||
24631 | catch (RecognitionException re) { | ||
24632 | reportError(re); | ||
24633 | recover(input,re); | ||
24634 | } | ||
24635 | finally { | ||
24636 | |||
24637 | restoreStackSize(stackSize); | ||
24638 | |||
24639 | } | ||
24640 | return ; | ||
24641 | } | ||
24642 | // $ANTLR end "rule__ALSSigScope__Group__0" | ||
24643 | |||
24644 | |||
24645 | // $ANTLR start "rule__ALSSigScope__Group__0__Impl" | ||
24646 | // InternalAlloyLanguage.g:8793:1: rule__ALSSigScope__Group__0__Impl : ( ( rule__ALSSigScope__ExactlyAssignment_0 )? ) ; | ||
24647 | public final void rule__ALSSigScope__Group__0__Impl() throws RecognitionException { | ||
24648 | |||
24649 | int stackSize = keepStackSize(); | ||
24650 | |||
24651 | try { | ||
24652 | // InternalAlloyLanguage.g:8797:1: ( ( ( rule__ALSSigScope__ExactlyAssignment_0 )? ) ) | ||
24653 | // InternalAlloyLanguage.g:8798:1: ( ( rule__ALSSigScope__ExactlyAssignment_0 )? ) | ||
24654 | { | ||
24655 | // InternalAlloyLanguage.g:8798:1: ( ( rule__ALSSigScope__ExactlyAssignment_0 )? ) | ||
24656 | // InternalAlloyLanguage.g:8799:1: ( rule__ALSSigScope__ExactlyAssignment_0 )? | ||
24657 | { | ||
24658 | if ( state.backtracking==0 ) { | ||
24659 | before(grammarAccess.getALSSigScopeAccess().getExactlyAssignment_0()); | ||
24660 | } | ||
24661 | // InternalAlloyLanguage.g:8800:1: ( rule__ALSSigScope__ExactlyAssignment_0 )? | ||
24662 | int alt50=2; | ||
24663 | int LA50_0 = input.LA(1); | ||
24664 | |||
24665 | if ( (LA50_0==74) ) { | ||
24666 | alt50=1; | ||
24667 | } | ||
24668 | switch (alt50) { | ||
24669 | case 1 : | ||
24670 | // InternalAlloyLanguage.g:8800:2: rule__ALSSigScope__ExactlyAssignment_0 | ||
24671 | { | ||
24672 | pushFollow(FOLLOW_2); | ||
24673 | rule__ALSSigScope__ExactlyAssignment_0(); | ||
24674 | |||
24675 | state._fsp--; | ||
24676 | if (state.failed) return ; | ||
24677 | |||
24678 | } | ||
24679 | break; | ||
24680 | |||
24681 | } | ||
24682 | |||
24683 | if ( state.backtracking==0 ) { | ||
24684 | after(grammarAccess.getALSSigScopeAccess().getExactlyAssignment_0()); | ||
24685 | } | ||
24686 | |||
24687 | } | ||
24688 | |||
24689 | |||
24690 | } | ||
24691 | |||
24692 | } | ||
24693 | catch (RecognitionException re) { | ||
24694 | reportError(re); | ||
24695 | recover(input,re); | ||
24696 | } | ||
24697 | finally { | ||
24698 | |||
24699 | restoreStackSize(stackSize); | ||
24700 | |||
24701 | } | ||
24702 | return ; | ||
24703 | } | ||
24704 | // $ANTLR end "rule__ALSSigScope__Group__0__Impl" | ||
24705 | |||
24706 | |||
24707 | // $ANTLR start "rule__ALSSigScope__Group__1" | ||
24708 | // InternalAlloyLanguage.g:8810:1: rule__ALSSigScope__Group__1 : rule__ALSSigScope__Group__1__Impl rule__ALSSigScope__Group__2 ; | ||
24709 | public final void rule__ALSSigScope__Group__1() throws RecognitionException { | ||
24710 | |||
24711 | int stackSize = keepStackSize(); | ||
24712 | |||
24713 | try { | ||
24714 | // InternalAlloyLanguage.g:8814:1: ( rule__ALSSigScope__Group__1__Impl rule__ALSSigScope__Group__2 ) | ||
24715 | // InternalAlloyLanguage.g:8815:2: rule__ALSSigScope__Group__1__Impl rule__ALSSigScope__Group__2 | ||
24716 | { | ||
24717 | pushFollow(FOLLOW_5); | ||
24718 | rule__ALSSigScope__Group__1__Impl(); | ||
24719 | |||
24720 | state._fsp--; | ||
24721 | if (state.failed) return ; | ||
24722 | pushFollow(FOLLOW_2); | ||
24723 | rule__ALSSigScope__Group__2(); | ||
24724 | |||
24725 | state._fsp--; | ||
24726 | if (state.failed) return ; | ||
24727 | |||
24728 | } | ||
24729 | |||
24730 | } | ||
24731 | catch (RecognitionException re) { | ||
24732 | reportError(re); | ||
24733 | recover(input,re); | ||
24734 | } | ||
24735 | finally { | ||
24736 | |||
24737 | restoreStackSize(stackSize); | ||
24738 | |||
24739 | } | ||
24740 | return ; | ||
24741 | } | ||
24742 | // $ANTLR end "rule__ALSSigScope__Group__1" | ||
24743 | |||
24744 | |||
24745 | // $ANTLR start "rule__ALSSigScope__Group__1__Impl" | ||
24746 | // InternalAlloyLanguage.g:8822:1: rule__ALSSigScope__Group__1__Impl : ( ( rule__ALSSigScope__NumberAssignment_1 ) ) ; | ||
24747 | public final void rule__ALSSigScope__Group__1__Impl() throws RecognitionException { | ||
24748 | |||
24749 | int stackSize = keepStackSize(); | ||
24750 | |||
24751 | try { | ||
24752 | // InternalAlloyLanguage.g:8826:1: ( ( ( rule__ALSSigScope__NumberAssignment_1 ) ) ) | ||
24753 | // InternalAlloyLanguage.g:8827:1: ( ( rule__ALSSigScope__NumberAssignment_1 ) ) | ||
24754 | { | ||
24755 | // InternalAlloyLanguage.g:8827:1: ( ( rule__ALSSigScope__NumberAssignment_1 ) ) | ||
24756 | // InternalAlloyLanguage.g:8828:1: ( rule__ALSSigScope__NumberAssignment_1 ) | ||
24757 | { | ||
24758 | if ( state.backtracking==0 ) { | ||
24759 | before(grammarAccess.getALSSigScopeAccess().getNumberAssignment_1()); | ||
24760 | } | ||
24761 | // InternalAlloyLanguage.g:8829:1: ( rule__ALSSigScope__NumberAssignment_1 ) | ||
24762 | // InternalAlloyLanguage.g:8829:2: rule__ALSSigScope__NumberAssignment_1 | ||
24763 | { | ||
24764 | pushFollow(FOLLOW_2); | ||
24765 | rule__ALSSigScope__NumberAssignment_1(); | ||
24766 | |||
24767 | state._fsp--; | ||
24768 | if (state.failed) return ; | ||
24769 | |||
24770 | } | ||
24771 | |||
24772 | if ( state.backtracking==0 ) { | ||
24773 | after(grammarAccess.getALSSigScopeAccess().getNumberAssignment_1()); | ||
24774 | } | ||
24775 | |||
24776 | } | ||
24777 | |||
24778 | |||
24779 | } | ||
24780 | |||
24781 | } | ||
24782 | catch (RecognitionException re) { | ||
24783 | reportError(re); | ||
24784 | recover(input,re); | ||
24785 | } | ||
24786 | finally { | ||
24787 | |||
24788 | restoreStackSize(stackSize); | ||
24789 | |||
24790 | } | ||
24791 | return ; | ||
24792 | } | ||
24793 | // $ANTLR end "rule__ALSSigScope__Group__1__Impl" | ||
24794 | |||
24795 | |||
24796 | // $ANTLR start "rule__ALSSigScope__Group__2" | ||
24797 | // InternalAlloyLanguage.g:8839:1: rule__ALSSigScope__Group__2 : rule__ALSSigScope__Group__2__Impl ; | ||
24798 | public final void rule__ALSSigScope__Group__2() throws RecognitionException { | ||
24799 | |||
24800 | int stackSize = keepStackSize(); | ||
24801 | |||
24802 | try { | ||
24803 | // InternalAlloyLanguage.g:8843:1: ( rule__ALSSigScope__Group__2__Impl ) | ||
24804 | // InternalAlloyLanguage.g:8844:2: rule__ALSSigScope__Group__2__Impl | ||
24805 | { | ||
24806 | pushFollow(FOLLOW_2); | ||
24807 | rule__ALSSigScope__Group__2__Impl(); | ||
24808 | |||
24809 | state._fsp--; | ||
24810 | if (state.failed) return ; | ||
24811 | |||
24812 | } | ||
24813 | |||
24814 | } | ||
24815 | catch (RecognitionException re) { | ||
24816 | reportError(re); | ||
24817 | recover(input,re); | ||
24818 | } | ||
24819 | finally { | ||
24820 | |||
24821 | restoreStackSize(stackSize); | ||
24822 | |||
24823 | } | ||
24824 | return ; | ||
24825 | } | ||
24826 | // $ANTLR end "rule__ALSSigScope__Group__2" | ||
24827 | |||
24828 | |||
24829 | // $ANTLR start "rule__ALSSigScope__Group__2__Impl" | ||
24830 | // InternalAlloyLanguage.g:8850:1: rule__ALSSigScope__Group__2__Impl : ( ( rule__ALSSigScope__TypeAssignment_2 ) ) ; | ||
24831 | public final void rule__ALSSigScope__Group__2__Impl() throws RecognitionException { | ||
24832 | |||
24833 | int stackSize = keepStackSize(); | ||
24834 | |||
24835 | try { | ||
24836 | // InternalAlloyLanguage.g:8854:1: ( ( ( rule__ALSSigScope__TypeAssignment_2 ) ) ) | ||
24837 | // InternalAlloyLanguage.g:8855:1: ( ( rule__ALSSigScope__TypeAssignment_2 ) ) | ||
24838 | { | ||
24839 | // InternalAlloyLanguage.g:8855:1: ( ( rule__ALSSigScope__TypeAssignment_2 ) ) | ||
24840 | // InternalAlloyLanguage.g:8856:1: ( rule__ALSSigScope__TypeAssignment_2 ) | ||
24841 | { | ||
24842 | if ( state.backtracking==0 ) { | ||
24843 | before(grammarAccess.getALSSigScopeAccess().getTypeAssignment_2()); | ||
24844 | } | ||
24845 | // InternalAlloyLanguage.g:8857:1: ( rule__ALSSigScope__TypeAssignment_2 ) | ||
24846 | // InternalAlloyLanguage.g:8857:2: rule__ALSSigScope__TypeAssignment_2 | ||
24847 | { | ||
24848 | pushFollow(FOLLOW_2); | ||
24849 | rule__ALSSigScope__TypeAssignment_2(); | ||
24850 | |||
24851 | state._fsp--; | ||
24852 | if (state.failed) return ; | ||
24853 | |||
24854 | } | ||
24855 | |||
24856 | if ( state.backtracking==0 ) { | ||
24857 | after(grammarAccess.getALSSigScopeAccess().getTypeAssignment_2()); | ||
24858 | } | ||
24859 | |||
24860 | } | ||
24861 | |||
24862 | |||
24863 | } | ||
24864 | |||
24865 | } | ||
24866 | catch (RecognitionException re) { | ||
24867 | reportError(re); | ||
24868 | recover(input,re); | ||
24869 | } | ||
24870 | finally { | ||
24871 | |||
24872 | restoreStackSize(stackSize); | ||
24873 | |||
24874 | } | ||
24875 | return ; | ||
24876 | } | ||
24877 | // $ANTLR end "rule__ALSSigScope__Group__2__Impl" | ||
24878 | |||
24879 | |||
24880 | // $ANTLR start "rule__ALSIntScope__Group__0" | ||
24881 | // InternalAlloyLanguage.g:8873:1: rule__ALSIntScope__Group__0 : rule__ALSIntScope__Group__0__Impl rule__ALSIntScope__Group__1 ; | ||
24882 | public final void rule__ALSIntScope__Group__0() throws RecognitionException { | ||
24883 | |||
24884 | int stackSize = keepStackSize(); | ||
24885 | |||
24886 | try { | ||
24887 | // InternalAlloyLanguage.g:8877:1: ( rule__ALSIntScope__Group__0__Impl rule__ALSIntScope__Group__1 ) | ||
24888 | // InternalAlloyLanguage.g:8878:2: rule__ALSIntScope__Group__0__Impl rule__ALSIntScope__Group__1 | ||
24889 | { | ||
24890 | pushFollow(FOLLOW_57); | ||
24891 | rule__ALSIntScope__Group__0__Impl(); | ||
24892 | |||
24893 | state._fsp--; | ||
24894 | if (state.failed) return ; | ||
24895 | pushFollow(FOLLOW_2); | ||
24896 | rule__ALSIntScope__Group__1(); | ||
24897 | |||
24898 | state._fsp--; | ||
24899 | if (state.failed) return ; | ||
24900 | |||
24901 | } | ||
24902 | |||
24903 | } | ||
24904 | catch (RecognitionException re) { | ||
24905 | reportError(re); | ||
24906 | recover(input,re); | ||
24907 | } | ||
24908 | finally { | ||
24909 | |||
24910 | restoreStackSize(stackSize); | ||
24911 | |||
24912 | } | ||
24913 | return ; | ||
24914 | } | ||
24915 | // $ANTLR end "rule__ALSIntScope__Group__0" | ||
24916 | |||
24917 | |||
24918 | // $ANTLR start "rule__ALSIntScope__Group__0__Impl" | ||
24919 | // InternalAlloyLanguage.g:8885:1: rule__ALSIntScope__Group__0__Impl : ( ( rule__ALSIntScope__NumberAssignment_0 ) ) ; | ||
24920 | public final void rule__ALSIntScope__Group__0__Impl() throws RecognitionException { | ||
24921 | |||
24922 | int stackSize = keepStackSize(); | ||
24923 | |||
24924 | try { | ||
24925 | // InternalAlloyLanguage.g:8889:1: ( ( ( rule__ALSIntScope__NumberAssignment_0 ) ) ) | ||
24926 | // InternalAlloyLanguage.g:8890:1: ( ( rule__ALSIntScope__NumberAssignment_0 ) ) | ||
24927 | { | ||
24928 | // InternalAlloyLanguage.g:8890:1: ( ( rule__ALSIntScope__NumberAssignment_0 ) ) | ||
24929 | // InternalAlloyLanguage.g:8891:1: ( rule__ALSIntScope__NumberAssignment_0 ) | ||
24930 | { | ||
24931 | if ( state.backtracking==0 ) { | ||
24932 | before(grammarAccess.getALSIntScopeAccess().getNumberAssignment_0()); | ||
24933 | } | ||
24934 | // InternalAlloyLanguage.g:8892:1: ( rule__ALSIntScope__NumberAssignment_0 ) | ||
24935 | // InternalAlloyLanguage.g:8892:2: rule__ALSIntScope__NumberAssignment_0 | ||
24936 | { | ||
24937 | pushFollow(FOLLOW_2); | ||
24938 | rule__ALSIntScope__NumberAssignment_0(); | ||
24939 | |||
24940 | state._fsp--; | ||
24941 | if (state.failed) return ; | ||
24942 | |||
24943 | } | ||
24944 | |||
24945 | if ( state.backtracking==0 ) { | ||
24946 | after(grammarAccess.getALSIntScopeAccess().getNumberAssignment_0()); | ||
24947 | } | ||
24948 | |||
24949 | } | ||
24950 | |||
24951 | |||
24952 | } | ||
24953 | |||
24954 | } | ||
24955 | catch (RecognitionException re) { | ||
24956 | reportError(re); | ||
24957 | recover(input,re); | ||
24958 | } | ||
24959 | finally { | ||
24960 | |||
24961 | restoreStackSize(stackSize); | ||
24962 | |||
24963 | } | ||
24964 | return ; | ||
24965 | } | ||
24966 | // $ANTLR end "rule__ALSIntScope__Group__0__Impl" | ||
24967 | |||
24968 | |||
24969 | // $ANTLR start "rule__ALSIntScope__Group__1" | ||
24970 | // InternalAlloyLanguage.g:8902:1: rule__ALSIntScope__Group__1 : rule__ALSIntScope__Group__1__Impl ; | ||
24971 | public final void rule__ALSIntScope__Group__1() throws RecognitionException { | ||
24972 | |||
24973 | int stackSize = keepStackSize(); | ||
24974 | |||
24975 | try { | ||
24976 | // InternalAlloyLanguage.g:8906:1: ( rule__ALSIntScope__Group__1__Impl ) | ||
24977 | // InternalAlloyLanguage.g:8907:2: rule__ALSIntScope__Group__1__Impl | ||
24978 | { | ||
24979 | pushFollow(FOLLOW_2); | ||
24980 | rule__ALSIntScope__Group__1__Impl(); | ||
24981 | |||
24982 | state._fsp--; | ||
24983 | if (state.failed) return ; | ||
24984 | |||
24985 | } | ||
24986 | |||
24987 | } | ||
24988 | catch (RecognitionException re) { | ||
24989 | reportError(re); | ||
24990 | recover(input,re); | ||
24991 | } | ||
24992 | finally { | ||
24993 | |||
24994 | restoreStackSize(stackSize); | ||
24995 | |||
24996 | } | ||
24997 | return ; | ||
24998 | } | ||
24999 | // $ANTLR end "rule__ALSIntScope__Group__1" | ||
25000 | |||
25001 | |||
25002 | // $ANTLR start "rule__ALSIntScope__Group__1__Impl" | ||
25003 | // InternalAlloyLanguage.g:8913:1: rule__ALSIntScope__Group__1__Impl : ( 'Int' ) ; | ||
25004 | public final void rule__ALSIntScope__Group__1__Impl() throws RecognitionException { | ||
25005 | |||
25006 | int stackSize = keepStackSize(); | ||
25007 | |||
25008 | try { | ||
25009 | // InternalAlloyLanguage.g:8917:1: ( ( 'Int' ) ) | ||
25010 | // InternalAlloyLanguage.g:8918:1: ( 'Int' ) | ||
25011 | { | ||
25012 | // InternalAlloyLanguage.g:8918:1: ( 'Int' ) | ||
25013 | // InternalAlloyLanguage.g:8919:1: 'Int' | ||
25014 | { | ||
25015 | if ( state.backtracking==0 ) { | ||
25016 | before(grammarAccess.getALSIntScopeAccess().getIntKeyword_1()); | ||
25017 | } | ||
25018 | match(input,68,FOLLOW_2); if (state.failed) return ; | ||
25019 | if ( state.backtracking==0 ) { | ||
25020 | after(grammarAccess.getALSIntScopeAccess().getIntKeyword_1()); | ||
25021 | } | ||
25022 | |||
25023 | } | ||
25024 | |||
25025 | |||
25026 | } | ||
25027 | |||
25028 | } | ||
25029 | catch (RecognitionException re) { | ||
25030 | reportError(re); | ||
25031 | recover(input,re); | ||
25032 | } | ||
25033 | finally { | ||
25034 | |||
25035 | restoreStackSize(stackSize); | ||
25036 | |||
25037 | } | ||
25038 | return ; | ||
25039 | } | ||
25040 | // $ANTLR end "rule__ALSIntScope__Group__1__Impl" | ||
25041 | |||
25042 | |||
25043 | // $ANTLR start "rule__ALSStringScope__Group__0" | ||
25044 | // InternalAlloyLanguage.g:8936:1: rule__ALSStringScope__Group__0 : rule__ALSStringScope__Group__0__Impl rule__ALSStringScope__Group__1 ; | ||
25045 | public final void rule__ALSStringScope__Group__0() throws RecognitionException { | ||
25046 | |||
25047 | int stackSize = keepStackSize(); | ||
25048 | |||
25049 | try { | ||
25050 | // InternalAlloyLanguage.g:8940:1: ( rule__ALSStringScope__Group__0__Impl rule__ALSStringScope__Group__1 ) | ||
25051 | // InternalAlloyLanguage.g:8941:2: rule__ALSStringScope__Group__0__Impl rule__ALSStringScope__Group__1 | ||
25052 | { | ||
25053 | pushFollow(FOLLOW_59); | ||
25054 | rule__ALSStringScope__Group__0__Impl(); | ||
25055 | |||
25056 | state._fsp--; | ||
25057 | if (state.failed) return ; | ||
25058 | pushFollow(FOLLOW_2); | ||
25059 | rule__ALSStringScope__Group__1(); | ||
25060 | |||
25061 | state._fsp--; | ||
25062 | if (state.failed) return ; | ||
25063 | |||
25064 | } | ||
25065 | |||
25066 | } | ||
25067 | catch (RecognitionException re) { | ||
25068 | reportError(re); | ||
25069 | recover(input,re); | ||
25070 | } | ||
25071 | finally { | ||
25072 | |||
25073 | restoreStackSize(stackSize); | ||
25074 | |||
25075 | } | ||
25076 | return ; | ||
25077 | } | ||
25078 | // $ANTLR end "rule__ALSStringScope__Group__0" | ||
25079 | |||
25080 | |||
25081 | // $ANTLR start "rule__ALSStringScope__Group__0__Impl" | ||
25082 | // InternalAlloyLanguage.g:8948:1: rule__ALSStringScope__Group__0__Impl : ( 'exactly' ) ; | ||
25083 | public final void rule__ALSStringScope__Group__0__Impl() throws RecognitionException { | ||
25084 | |||
25085 | int stackSize = keepStackSize(); | ||
25086 | |||
25087 | try { | ||
25088 | // InternalAlloyLanguage.g:8952:1: ( ( 'exactly' ) ) | ||
25089 | // InternalAlloyLanguage.g:8953:1: ( 'exactly' ) | ||
25090 | { | ||
25091 | // InternalAlloyLanguage.g:8953:1: ( 'exactly' ) | ||
25092 | // InternalAlloyLanguage.g:8954:1: 'exactly' | ||
25093 | { | ||
25094 | if ( state.backtracking==0 ) { | ||
25095 | before(grammarAccess.getALSStringScopeAccess().getExactlyKeyword_0()); | ||
25096 | } | ||
25097 | match(input,74,FOLLOW_2); if (state.failed) return ; | ||
25098 | if ( state.backtracking==0 ) { | ||
25099 | after(grammarAccess.getALSStringScopeAccess().getExactlyKeyword_0()); | ||
25100 | } | ||
25101 | |||
25102 | } | ||
25103 | |||
25104 | |||
25105 | } | ||
25106 | |||
25107 | } | ||
25108 | catch (RecognitionException re) { | ||
25109 | reportError(re); | ||
25110 | recover(input,re); | ||
25111 | } | ||
25112 | finally { | ||
25113 | |||
25114 | restoreStackSize(stackSize); | ||
25115 | |||
25116 | } | ||
25117 | return ; | ||
25118 | } | ||
25119 | // $ANTLR end "rule__ALSStringScope__Group__0__Impl" | ||
25120 | |||
25121 | |||
25122 | // $ANTLR start "rule__ALSStringScope__Group__1" | ||
25123 | // InternalAlloyLanguage.g:8967:1: rule__ALSStringScope__Group__1 : rule__ALSStringScope__Group__1__Impl rule__ALSStringScope__Group__2 ; | ||
25124 | public final void rule__ALSStringScope__Group__1() throws RecognitionException { | ||
25125 | |||
25126 | int stackSize = keepStackSize(); | ||
25127 | |||
25128 | try { | ||
25129 | // InternalAlloyLanguage.g:8971:1: ( rule__ALSStringScope__Group__1__Impl rule__ALSStringScope__Group__2 ) | ||
25130 | // InternalAlloyLanguage.g:8972:2: rule__ALSStringScope__Group__1__Impl rule__ALSStringScope__Group__2 | ||
25131 | { | ||
25132 | pushFollow(FOLLOW_58); | ||
25133 | rule__ALSStringScope__Group__1__Impl(); | ||
25134 | |||
25135 | state._fsp--; | ||
25136 | if (state.failed) return ; | ||
25137 | pushFollow(FOLLOW_2); | ||
25138 | rule__ALSStringScope__Group__2(); | ||
25139 | |||
25140 | state._fsp--; | ||
25141 | if (state.failed) return ; | ||
25142 | |||
25143 | } | ||
25144 | |||
25145 | } | ||
25146 | catch (RecognitionException re) { | ||
25147 | reportError(re); | ||
25148 | recover(input,re); | ||
25149 | } | ||
25150 | finally { | ||
25151 | |||
25152 | restoreStackSize(stackSize); | ||
25153 | |||
25154 | } | ||
25155 | return ; | ||
25156 | } | ||
25157 | // $ANTLR end "rule__ALSStringScope__Group__1" | ||
25158 | |||
25159 | |||
25160 | // $ANTLR start "rule__ALSStringScope__Group__1__Impl" | ||
25161 | // InternalAlloyLanguage.g:8979:1: rule__ALSStringScope__Group__1__Impl : ( ( rule__ALSStringScope__NumberAssignment_1 ) ) ; | ||
25162 | public final void rule__ALSStringScope__Group__1__Impl() throws RecognitionException { | ||
25163 | |||
25164 | int stackSize = keepStackSize(); | ||
25165 | |||
25166 | try { | ||
25167 | // InternalAlloyLanguage.g:8983:1: ( ( ( rule__ALSStringScope__NumberAssignment_1 ) ) ) | ||
25168 | // InternalAlloyLanguage.g:8984:1: ( ( rule__ALSStringScope__NumberAssignment_1 ) ) | ||
25169 | { | ||
25170 | // InternalAlloyLanguage.g:8984:1: ( ( rule__ALSStringScope__NumberAssignment_1 ) ) | ||
25171 | // InternalAlloyLanguage.g:8985:1: ( rule__ALSStringScope__NumberAssignment_1 ) | ||
25172 | { | ||
25173 | if ( state.backtracking==0 ) { | ||
25174 | before(grammarAccess.getALSStringScopeAccess().getNumberAssignment_1()); | ||
25175 | } | ||
25176 | // InternalAlloyLanguage.g:8986:1: ( rule__ALSStringScope__NumberAssignment_1 ) | ||
25177 | // InternalAlloyLanguage.g:8986:2: rule__ALSStringScope__NumberAssignment_1 | ||
25178 | { | ||
25179 | pushFollow(FOLLOW_2); | ||
25180 | rule__ALSStringScope__NumberAssignment_1(); | ||
25181 | |||
25182 | state._fsp--; | ||
25183 | if (state.failed) return ; | ||
25184 | |||
25185 | } | ||
25186 | |||
25187 | if ( state.backtracking==0 ) { | ||
25188 | after(grammarAccess.getALSStringScopeAccess().getNumberAssignment_1()); | ||
25189 | } | ||
25190 | |||
25191 | } | ||
25192 | |||
25193 | |||
25194 | } | ||
25195 | |||
25196 | } | ||
25197 | catch (RecognitionException re) { | ||
25198 | reportError(re); | ||
25199 | recover(input,re); | ||
25200 | } | ||
25201 | finally { | ||
25202 | |||
25203 | restoreStackSize(stackSize); | ||
25204 | |||
25205 | } | ||
25206 | return ; | ||
25207 | } | ||
25208 | // $ANTLR end "rule__ALSStringScope__Group__1__Impl" | ||
25209 | |||
25210 | |||
25211 | // $ANTLR start "rule__ALSStringScope__Group__2" | ||
25212 | // InternalAlloyLanguage.g:8996:1: rule__ALSStringScope__Group__2 : rule__ALSStringScope__Group__2__Impl ; | ||
25213 | public final void rule__ALSStringScope__Group__2() throws RecognitionException { | ||
25214 | |||
25215 | int stackSize = keepStackSize(); | ||
25216 | |||
25217 | try { | ||
25218 | // InternalAlloyLanguage.g:9000:1: ( rule__ALSStringScope__Group__2__Impl ) | ||
25219 | // InternalAlloyLanguage.g:9001:2: rule__ALSStringScope__Group__2__Impl | ||
25220 | { | ||
25221 | pushFollow(FOLLOW_2); | ||
25222 | rule__ALSStringScope__Group__2__Impl(); | ||
25223 | |||
25224 | state._fsp--; | ||
25225 | if (state.failed) return ; | ||
25226 | |||
25227 | } | ||
25228 | |||
25229 | } | ||
25230 | catch (RecognitionException re) { | ||
25231 | reportError(re); | ||
25232 | recover(input,re); | ||
25233 | } | ||
25234 | finally { | ||
25235 | |||
25236 | restoreStackSize(stackSize); | ||
25237 | |||
25238 | } | ||
25239 | return ; | ||
25240 | } | ||
25241 | // $ANTLR end "rule__ALSStringScope__Group__2" | ||
25242 | |||
25243 | |||
25244 | // $ANTLR start "rule__ALSStringScope__Group__2__Impl" | ||
25245 | // InternalAlloyLanguage.g:9007:1: rule__ALSStringScope__Group__2__Impl : ( 'String' ) ; | ||
25246 | public final void rule__ALSStringScope__Group__2__Impl() throws RecognitionException { | ||
25247 | |||
25248 | int stackSize = keepStackSize(); | ||
25249 | |||
25250 | try { | ||
25251 | // InternalAlloyLanguage.g:9011:1: ( ( 'String' ) ) | ||
25252 | // InternalAlloyLanguage.g:9012:1: ( 'String' ) | ||
25253 | { | ||
25254 | // InternalAlloyLanguage.g:9012:1: ( 'String' ) | ||
25255 | // InternalAlloyLanguage.g:9013:1: 'String' | ||
25256 | { | ||
25257 | if ( state.backtracking==0 ) { | ||
25258 | before(grammarAccess.getALSStringScopeAccess().getStringKeyword_2()); | ||
25259 | } | ||
25260 | match(input,69,FOLLOW_2); if (state.failed) return ; | ||
25261 | if ( state.backtracking==0 ) { | ||
25262 | after(grammarAccess.getALSStringScopeAccess().getStringKeyword_2()); | ||
25263 | } | ||
25264 | |||
25265 | } | ||
25266 | |||
25267 | |||
25268 | } | ||
25269 | |||
25270 | } | ||
25271 | catch (RecognitionException re) { | ||
25272 | reportError(re); | ||
25273 | recover(input,re); | ||
25274 | } | ||
25275 | finally { | ||
25276 | |||
25277 | restoreStackSize(stackSize); | ||
25278 | |||
25279 | } | ||
25280 | return ; | ||
25281 | } | ||
25282 | // $ANTLR end "rule__ALSStringScope__Group__2__Impl" | ||
25283 | |||
25284 | |||
25285 | // $ANTLR start "rule__ALSSignatureBody__UnorderedGroup_0" | ||
25286 | // InternalAlloyLanguage.g:9033:1: rule__ALSSignatureBody__UnorderedGroup_0 : ( rule__ALSSignatureBody__UnorderedGroup_0__0 )? ; | ||
25287 | public final void rule__ALSSignatureBody__UnorderedGroup_0() throws RecognitionException { | ||
25288 | |||
25289 | int stackSize = keepStackSize(); | ||
25290 | getUnorderedGroupHelper().enter(grammarAccess.getALSSignatureBodyAccess().getUnorderedGroup_0()); | ||
25291 | |||
25292 | try { | ||
25293 | // InternalAlloyLanguage.g:9038:1: ( ( rule__ALSSignatureBody__UnorderedGroup_0__0 )? ) | ||
25294 | // InternalAlloyLanguage.g:9039:2: ( rule__ALSSignatureBody__UnorderedGroup_0__0 )? | ||
25295 | { | ||
25296 | // InternalAlloyLanguage.g:9039:2: ( rule__ALSSignatureBody__UnorderedGroup_0__0 )? | ||
25297 | int alt51=2; | ||
25298 | int LA51_0 = input.LA(1); | ||
25299 | |||
25300 | if ( LA51_0 == 21 && getUnorderedGroupHelper().canSelect(grammarAccess.getALSSignatureBodyAccess().getUnorderedGroup_0(), 0) ) { | ||
25301 | alt51=1; | ||
25302 | } | ||
25303 | else if ( LA51_0 == 22 && getUnorderedGroupHelper().canSelect(grammarAccess.getALSSignatureBodyAccess().getUnorderedGroup_0(), 0) ) { | ||
25304 | alt51=1; | ||
25305 | } | ||
25306 | else if ( LA51_0 == 23 && getUnorderedGroupHelper().canSelect(grammarAccess.getALSSignatureBodyAccess().getUnorderedGroup_0(), 0) ) { | ||
25307 | alt51=1; | ||
25308 | } | ||
25309 | else if ( LA51_0 == 24 && getUnorderedGroupHelper().canSelect(grammarAccess.getALSSignatureBodyAccess().getUnorderedGroup_0(), 0) ) { | ||
25310 | alt51=1; | ||
25311 | } | ||
25312 | else if ( LA51_0 == 25 && getUnorderedGroupHelper().canSelect(grammarAccess.getALSSignatureBodyAccess().getUnorderedGroup_0(), 0) ) { | ||
25313 | alt51=1; | ||
25314 | } | ||
25315 | else if ( LA51_0 == 26 && getUnorderedGroupHelper().canSelect(grammarAccess.getALSSignatureBodyAccess().getUnorderedGroup_0(), 0) ) { | ||
25316 | alt51=1; | ||
25317 | } | ||
25318 | else if ( LA51_0 == 75 && getUnorderedGroupHelper().canSelect(grammarAccess.getALSSignatureBodyAccess().getUnorderedGroup_0(), 1) ) { | ||
25319 | alt51=1; | ||
25320 | } | ||
25321 | switch (alt51) { | ||
25322 | case 1 : | ||
25323 | // InternalAlloyLanguage.g:0:0: rule__ALSSignatureBody__UnorderedGroup_0__0 | ||
25324 | { | ||
25325 | pushFollow(FOLLOW_2); | ||
25326 | rule__ALSSignatureBody__UnorderedGroup_0__0(); | ||
25327 | |||
25328 | state._fsp--; | ||
25329 | if (state.failed) return ; | ||
25330 | |||
25331 | } | ||
25332 | break; | ||
25333 | |||
25334 | } | ||
25335 | |||
25336 | |||
25337 | } | ||
25338 | |||
25339 | } | ||
25340 | catch (RecognitionException re) { | ||
25341 | reportError(re); | ||
25342 | recover(input,re); | ||
25343 | } | ||
25344 | finally { | ||
25345 | |||
25346 | getUnorderedGroupHelper().leave(grammarAccess.getALSSignatureBodyAccess().getUnorderedGroup_0()); | ||
25347 | restoreStackSize(stackSize); | ||
25348 | |||
25349 | } | ||
25350 | return ; | ||
25351 | } | ||
25352 | // $ANTLR end "rule__ALSSignatureBody__UnorderedGroup_0" | ||
25353 | |||
25354 | |||
25355 | // $ANTLR start "rule__ALSSignatureBody__UnorderedGroup_0__Impl" | ||
25356 | // InternalAlloyLanguage.g:9049:1: rule__ALSSignatureBody__UnorderedGroup_0__Impl : ( ({...}? => ( ( ( rule__ALSSignatureBody__MultiplicityAssignment_0_0 ) ) ) ) | ({...}? => ( ( ( rule__ALSSignatureBody__AbstractAssignment_0_1 ) ) ) ) ) ; | ||
25357 | public final void rule__ALSSignatureBody__UnorderedGroup_0__Impl() throws RecognitionException { | ||
25358 | |||
25359 | int stackSize = keepStackSize(); | ||
25360 | boolean selected = false; | ||
25361 | |||
25362 | try { | ||
25363 | // InternalAlloyLanguage.g:9054:1: ( ( ({...}? => ( ( ( rule__ALSSignatureBody__MultiplicityAssignment_0_0 ) ) ) ) | ({...}? => ( ( ( rule__ALSSignatureBody__AbstractAssignment_0_1 ) ) ) ) ) ) | ||
25364 | // InternalAlloyLanguage.g:9055:3: ( ({...}? => ( ( ( rule__ALSSignatureBody__MultiplicityAssignment_0_0 ) ) ) ) | ({...}? => ( ( ( rule__ALSSignatureBody__AbstractAssignment_0_1 ) ) ) ) ) | ||
25365 | { | ||
25366 | // InternalAlloyLanguage.g:9055:3: ( ({...}? => ( ( ( rule__ALSSignatureBody__MultiplicityAssignment_0_0 ) ) ) ) | ({...}? => ( ( ( rule__ALSSignatureBody__AbstractAssignment_0_1 ) ) ) ) ) | ||
25367 | int alt52=2; | ||
25368 | int LA52_0 = input.LA(1); | ||
25369 | |||
25370 | if ( LA52_0 == 21 && getUnorderedGroupHelper().canSelect(grammarAccess.getALSSignatureBodyAccess().getUnorderedGroup_0(), 0) ) { | ||
25371 | alt52=1; | ||
25372 | } | ||
25373 | else if ( LA52_0 == 22 && getUnorderedGroupHelper().canSelect(grammarAccess.getALSSignatureBodyAccess().getUnorderedGroup_0(), 0) ) { | ||
25374 | alt52=1; | ||
25375 | } | ||
25376 | else if ( LA52_0 == 23 && getUnorderedGroupHelper().canSelect(grammarAccess.getALSSignatureBodyAccess().getUnorderedGroup_0(), 0) ) { | ||
25377 | alt52=1; | ||
25378 | } | ||
25379 | else if ( LA52_0 == 24 && getUnorderedGroupHelper().canSelect(grammarAccess.getALSSignatureBodyAccess().getUnorderedGroup_0(), 0) ) { | ||
25380 | alt52=1; | ||
25381 | } | ||
25382 | else if ( LA52_0 == 25 && getUnorderedGroupHelper().canSelect(grammarAccess.getALSSignatureBodyAccess().getUnorderedGroup_0(), 0) ) { | ||
25383 | alt52=1; | ||
25384 | } | ||
25385 | else if ( LA52_0 == 26 && getUnorderedGroupHelper().canSelect(grammarAccess.getALSSignatureBodyAccess().getUnorderedGroup_0(), 0) ) { | ||
25386 | alt52=1; | ||
25387 | } | ||
25388 | else if ( LA52_0 == 75 && getUnorderedGroupHelper().canSelect(grammarAccess.getALSSignatureBodyAccess().getUnorderedGroup_0(), 1) ) { | ||
25389 | alt52=2; | ||
25390 | } | ||
25391 | else { | ||
25392 | if (state.backtracking>0) {state.failed=true; return ;} | ||
25393 | NoViableAltException nvae = | ||
25394 | new NoViableAltException("", 52, 0, input); | ||
25395 | |||
25396 | throw nvae; | ||
25397 | } | ||
25398 | switch (alt52) { | ||
25399 | case 1 : | ||
25400 | // InternalAlloyLanguage.g:9057:4: ({...}? => ( ( ( rule__ALSSignatureBody__MultiplicityAssignment_0_0 ) ) ) ) | ||
25401 | { | ||
25402 | // InternalAlloyLanguage.g:9057:4: ({...}? => ( ( ( rule__ALSSignatureBody__MultiplicityAssignment_0_0 ) ) ) ) | ||
25403 | // InternalAlloyLanguage.g:9058:5: {...}? => ( ( ( rule__ALSSignatureBody__MultiplicityAssignment_0_0 ) ) ) | ||
25404 | { | ||
25405 | if ( ! getUnorderedGroupHelper().canSelect(grammarAccess.getALSSignatureBodyAccess().getUnorderedGroup_0(), 0) ) { | ||
25406 | if (state.backtracking>0) {state.failed=true; return ;} | ||
25407 | throw new FailedPredicateException(input, "rule__ALSSignatureBody__UnorderedGroup_0__Impl", "getUnorderedGroupHelper().canSelect(grammarAccess.getALSSignatureBodyAccess().getUnorderedGroup_0(), 0)"); | ||
25408 | } | ||
25409 | // InternalAlloyLanguage.g:9058:113: ( ( ( rule__ALSSignatureBody__MultiplicityAssignment_0_0 ) ) ) | ||
25410 | // InternalAlloyLanguage.g:9059:6: ( ( rule__ALSSignatureBody__MultiplicityAssignment_0_0 ) ) | ||
25411 | { | ||
25412 | getUnorderedGroupHelper().select(grammarAccess.getALSSignatureBodyAccess().getUnorderedGroup_0(), 0); | ||
25413 | selected = true; | ||
25414 | // InternalAlloyLanguage.g:9065:6: ( ( rule__ALSSignatureBody__MultiplicityAssignment_0_0 ) ) | ||
25415 | // InternalAlloyLanguage.g:9067:7: ( rule__ALSSignatureBody__MultiplicityAssignment_0_0 ) | ||
25416 | { | ||
25417 | if ( state.backtracking==0 ) { | ||
25418 | before(grammarAccess.getALSSignatureBodyAccess().getMultiplicityAssignment_0_0()); | ||
25419 | } | ||
25420 | // InternalAlloyLanguage.g:9068:7: ( rule__ALSSignatureBody__MultiplicityAssignment_0_0 ) | ||
25421 | // InternalAlloyLanguage.g:9068:8: rule__ALSSignatureBody__MultiplicityAssignment_0_0 | ||
25422 | { | ||
25423 | pushFollow(FOLLOW_2); | ||
25424 | rule__ALSSignatureBody__MultiplicityAssignment_0_0(); | ||
25425 | |||
25426 | state._fsp--; | ||
25427 | if (state.failed) return ; | ||
25428 | |||
25429 | } | ||
25430 | |||
25431 | if ( state.backtracking==0 ) { | ||
25432 | after(grammarAccess.getALSSignatureBodyAccess().getMultiplicityAssignment_0_0()); | ||
25433 | } | ||
25434 | |||
25435 | } | ||
25436 | |||
25437 | |||
25438 | } | ||
25439 | |||
25440 | |||
25441 | } | ||
25442 | |||
25443 | |||
25444 | } | ||
25445 | break; | ||
25446 | case 2 : | ||
25447 | // InternalAlloyLanguage.g:9074:4: ({...}? => ( ( ( rule__ALSSignatureBody__AbstractAssignment_0_1 ) ) ) ) | ||
25448 | { | ||
25449 | // InternalAlloyLanguage.g:9074:4: ({...}? => ( ( ( rule__ALSSignatureBody__AbstractAssignment_0_1 ) ) ) ) | ||
25450 | // InternalAlloyLanguage.g:9075:5: {...}? => ( ( ( rule__ALSSignatureBody__AbstractAssignment_0_1 ) ) ) | ||
25451 | { | ||
25452 | if ( ! getUnorderedGroupHelper().canSelect(grammarAccess.getALSSignatureBodyAccess().getUnorderedGroup_0(), 1) ) { | ||
25453 | if (state.backtracking>0) {state.failed=true; return ;} | ||
25454 | throw new FailedPredicateException(input, "rule__ALSSignatureBody__UnorderedGroup_0__Impl", "getUnorderedGroupHelper().canSelect(grammarAccess.getALSSignatureBodyAccess().getUnorderedGroup_0(), 1)"); | ||
25455 | } | ||
25456 | // InternalAlloyLanguage.g:9075:113: ( ( ( rule__ALSSignatureBody__AbstractAssignment_0_1 ) ) ) | ||
25457 | // InternalAlloyLanguage.g:9076:6: ( ( rule__ALSSignatureBody__AbstractAssignment_0_1 ) ) | ||
25458 | { | ||
25459 | getUnorderedGroupHelper().select(grammarAccess.getALSSignatureBodyAccess().getUnorderedGroup_0(), 1); | ||
25460 | selected = true; | ||
25461 | // InternalAlloyLanguage.g:9082:6: ( ( rule__ALSSignatureBody__AbstractAssignment_0_1 ) ) | ||
25462 | // InternalAlloyLanguage.g:9084:7: ( rule__ALSSignatureBody__AbstractAssignment_0_1 ) | ||
25463 | { | ||
25464 | if ( state.backtracking==0 ) { | ||
25465 | before(grammarAccess.getALSSignatureBodyAccess().getAbstractAssignment_0_1()); | ||
25466 | } | ||
25467 | // InternalAlloyLanguage.g:9085:7: ( rule__ALSSignatureBody__AbstractAssignment_0_1 ) | ||
25468 | // InternalAlloyLanguage.g:9085:8: rule__ALSSignatureBody__AbstractAssignment_0_1 | ||
25469 | { | ||
25470 | pushFollow(FOLLOW_2); | ||
25471 | rule__ALSSignatureBody__AbstractAssignment_0_1(); | ||
25472 | |||
25473 | state._fsp--; | ||
25474 | if (state.failed) return ; | ||
25475 | |||
25476 | } | ||
25477 | |||
25478 | if ( state.backtracking==0 ) { | ||
25479 | after(grammarAccess.getALSSignatureBodyAccess().getAbstractAssignment_0_1()); | ||
25480 | } | ||
25481 | |||
25482 | } | ||
25483 | |||
25484 | |||
25485 | } | ||
25486 | |||
25487 | |||
25488 | } | ||
25489 | |||
25490 | |||
25491 | } | ||
25492 | break; | ||
25493 | |||
25494 | } | ||
25495 | |||
25496 | |||
25497 | } | ||
25498 | |||
25499 | } | ||
25500 | catch (RecognitionException re) { | ||
25501 | reportError(re); | ||
25502 | recover(input,re); | ||
25503 | } | ||
25504 | finally { | ||
25505 | |||
25506 | if (selected) | ||
25507 | getUnorderedGroupHelper().returnFromSelection(grammarAccess.getALSSignatureBodyAccess().getUnorderedGroup_0()); | ||
25508 | restoreStackSize(stackSize); | ||
25509 | |||
25510 | } | ||
25511 | return ; | ||
25512 | } | ||
25513 | // $ANTLR end "rule__ALSSignatureBody__UnorderedGroup_0__Impl" | ||
25514 | |||
25515 | |||
25516 | // $ANTLR start "rule__ALSSignatureBody__UnorderedGroup_0__0" | ||
25517 | // InternalAlloyLanguage.g:9100:1: rule__ALSSignatureBody__UnorderedGroup_0__0 : rule__ALSSignatureBody__UnorderedGroup_0__Impl ( rule__ALSSignatureBody__UnorderedGroup_0__1 )? ; | ||
25518 | public final void rule__ALSSignatureBody__UnorderedGroup_0__0() throws RecognitionException { | ||
25519 | |||
25520 | int stackSize = keepStackSize(); | ||
25521 | |||
25522 | try { | ||
25523 | // InternalAlloyLanguage.g:9104:1: ( rule__ALSSignatureBody__UnorderedGroup_0__Impl ( rule__ALSSignatureBody__UnorderedGroup_0__1 )? ) | ||
25524 | // InternalAlloyLanguage.g:9105:2: rule__ALSSignatureBody__UnorderedGroup_0__Impl ( rule__ALSSignatureBody__UnorderedGroup_0__1 )? | ||
25525 | { | ||
25526 | pushFollow(FOLLOW_64); | ||
25527 | rule__ALSSignatureBody__UnorderedGroup_0__Impl(); | ||
25528 | |||
25529 | state._fsp--; | ||
25530 | if (state.failed) return ; | ||
25531 | // InternalAlloyLanguage.g:9106:2: ( rule__ALSSignatureBody__UnorderedGroup_0__1 )? | ||
25532 | int alt53=2; | ||
25533 | int LA53_0 = input.LA(1); | ||
25534 | |||
25535 | if ( LA53_0 == 21 && getUnorderedGroupHelper().canSelect(grammarAccess.getALSSignatureBodyAccess().getUnorderedGroup_0(), 0) ) { | ||
25536 | alt53=1; | ||
25537 | } | ||
25538 | else if ( LA53_0 == 22 && getUnorderedGroupHelper().canSelect(grammarAccess.getALSSignatureBodyAccess().getUnorderedGroup_0(), 0) ) { | ||
25539 | alt53=1; | ||
25540 | } | ||
25541 | else if ( LA53_0 == 23 && getUnorderedGroupHelper().canSelect(grammarAccess.getALSSignatureBodyAccess().getUnorderedGroup_0(), 0) ) { | ||
25542 | alt53=1; | ||
25543 | } | ||
25544 | else if ( LA53_0 == 24 && getUnorderedGroupHelper().canSelect(grammarAccess.getALSSignatureBodyAccess().getUnorderedGroup_0(), 0) ) { | ||
25545 | alt53=1; | ||
25546 | } | ||
25547 | else if ( LA53_0 == 25 && getUnorderedGroupHelper().canSelect(grammarAccess.getALSSignatureBodyAccess().getUnorderedGroup_0(), 0) ) { | ||
25548 | alt53=1; | ||
25549 | } | ||
25550 | else if ( LA53_0 == 26 && getUnorderedGroupHelper().canSelect(grammarAccess.getALSSignatureBodyAccess().getUnorderedGroup_0(), 0) ) { | ||
25551 | alt53=1; | ||
25552 | } | ||
25553 | else if ( LA53_0 == 75 && getUnorderedGroupHelper().canSelect(grammarAccess.getALSSignatureBodyAccess().getUnorderedGroup_0(), 1) ) { | ||
25554 | alt53=1; | ||
25555 | } | ||
25556 | switch (alt53) { | ||
25557 | case 1 : | ||
25558 | // InternalAlloyLanguage.g:0:0: rule__ALSSignatureBody__UnorderedGroup_0__1 | ||
25559 | { | ||
25560 | pushFollow(FOLLOW_2); | ||
25561 | rule__ALSSignatureBody__UnorderedGroup_0__1(); | ||
25562 | |||
25563 | state._fsp--; | ||
25564 | if (state.failed) return ; | ||
25565 | |||
25566 | } | ||
25567 | break; | ||
25568 | |||
25569 | } | ||
25570 | |||
25571 | |||
25572 | } | ||
25573 | |||
25574 | } | ||
25575 | catch (RecognitionException re) { | ||
25576 | reportError(re); | ||
25577 | recover(input,re); | ||
25578 | } | ||
25579 | finally { | ||
25580 | |||
25581 | restoreStackSize(stackSize); | ||
25582 | |||
25583 | } | ||
25584 | return ; | ||
25585 | } | ||
25586 | // $ANTLR end "rule__ALSSignatureBody__UnorderedGroup_0__0" | ||
25587 | |||
25588 | |||
25589 | // $ANTLR start "rule__ALSSignatureBody__UnorderedGroup_0__1" | ||
25590 | // InternalAlloyLanguage.g:9113:1: rule__ALSSignatureBody__UnorderedGroup_0__1 : rule__ALSSignatureBody__UnorderedGroup_0__Impl ; | ||
25591 | public final void rule__ALSSignatureBody__UnorderedGroup_0__1() throws RecognitionException { | ||
25592 | |||
25593 | int stackSize = keepStackSize(); | ||
25594 | |||
25595 | try { | ||
25596 | // InternalAlloyLanguage.g:9117:1: ( rule__ALSSignatureBody__UnorderedGroup_0__Impl ) | ||
25597 | // InternalAlloyLanguage.g:9118:2: rule__ALSSignatureBody__UnorderedGroup_0__Impl | ||
25598 | { | ||
25599 | pushFollow(FOLLOW_2); | ||
25600 | rule__ALSSignatureBody__UnorderedGroup_0__Impl(); | ||
25601 | |||
25602 | state._fsp--; | ||
25603 | if (state.failed) return ; | ||
25604 | |||
25605 | } | ||
25606 | |||
25607 | } | ||
25608 | catch (RecognitionException re) { | ||
25609 | reportError(re); | ||
25610 | recover(input,re); | ||
25611 | } | ||
25612 | finally { | ||
25613 | |||
25614 | restoreStackSize(stackSize); | ||
25615 | |||
25616 | } | ||
25617 | return ; | ||
25618 | } | ||
25619 | // $ANTLR end "rule__ALSSignatureBody__UnorderedGroup_0__1" | ||
25620 | |||
25621 | |||
25622 | // $ANTLR start "rule__ALSDocument__EnumDeclarationsAssignment_0_0" | ||
25623 | // InternalAlloyLanguage.g:9129:1: rule__ALSDocument__EnumDeclarationsAssignment_0_0 : ( ruleALSEnumDeclaration ) ; | ||
25624 | public final void rule__ALSDocument__EnumDeclarationsAssignment_0_0() throws RecognitionException { | ||
25625 | |||
25626 | int stackSize = keepStackSize(); | ||
25627 | |||
25628 | try { | ||
25629 | // InternalAlloyLanguage.g:9133:1: ( ( ruleALSEnumDeclaration ) ) | ||
25630 | // InternalAlloyLanguage.g:9134:1: ( ruleALSEnumDeclaration ) | ||
25631 | { | ||
25632 | // InternalAlloyLanguage.g:9134:1: ( ruleALSEnumDeclaration ) | ||
25633 | // InternalAlloyLanguage.g:9135:1: ruleALSEnumDeclaration | ||
25634 | { | ||
25635 | if ( state.backtracking==0 ) { | ||
25636 | before(grammarAccess.getALSDocumentAccess().getEnumDeclarationsALSEnumDeclarationParserRuleCall_0_0_0()); | ||
25637 | } | ||
25638 | pushFollow(FOLLOW_2); | ||
25639 | ruleALSEnumDeclaration(); | ||
25640 | |||
25641 | state._fsp--; | ||
25642 | if (state.failed) return ; | ||
25643 | if ( state.backtracking==0 ) { | ||
25644 | after(grammarAccess.getALSDocumentAccess().getEnumDeclarationsALSEnumDeclarationParserRuleCall_0_0_0()); | ||
25645 | } | ||
25646 | |||
25647 | } | ||
25648 | |||
25649 | |||
25650 | } | ||
25651 | |||
25652 | } | ||
25653 | catch (RecognitionException re) { | ||
25654 | reportError(re); | ||
25655 | recover(input,re); | ||
25656 | } | ||
25657 | finally { | ||
25658 | |||
25659 | restoreStackSize(stackSize); | ||
25660 | |||
25661 | } | ||
25662 | return ; | ||
25663 | } | ||
25664 | // $ANTLR end "rule__ALSDocument__EnumDeclarationsAssignment_0_0" | ||
25665 | |||
25666 | |||
25667 | // $ANTLR start "rule__ALSDocument__SignatureBodiesAssignment_0_1" | ||
25668 | // InternalAlloyLanguage.g:9144:1: rule__ALSDocument__SignatureBodiesAssignment_0_1 : ( ruleALSSignatureBody ) ; | ||
25669 | public final void rule__ALSDocument__SignatureBodiesAssignment_0_1() throws RecognitionException { | ||
25670 | |||
25671 | int stackSize = keepStackSize(); | ||
25672 | |||
25673 | try { | ||
25674 | // InternalAlloyLanguage.g:9148:1: ( ( ruleALSSignatureBody ) ) | ||
25675 | // InternalAlloyLanguage.g:9149:1: ( ruleALSSignatureBody ) | ||
25676 | { | ||
25677 | // InternalAlloyLanguage.g:9149:1: ( ruleALSSignatureBody ) | ||
25678 | // InternalAlloyLanguage.g:9150:1: ruleALSSignatureBody | ||
25679 | { | ||
25680 | if ( state.backtracking==0 ) { | ||
25681 | before(grammarAccess.getALSDocumentAccess().getSignatureBodiesALSSignatureBodyParserRuleCall_0_1_0()); | ||
25682 | } | ||
25683 | pushFollow(FOLLOW_2); | ||
25684 | ruleALSSignatureBody(); | ||
25685 | |||
25686 | state._fsp--; | ||
25687 | if (state.failed) return ; | ||
25688 | if ( state.backtracking==0 ) { | ||
25689 | after(grammarAccess.getALSDocumentAccess().getSignatureBodiesALSSignatureBodyParserRuleCall_0_1_0()); | ||
25690 | } | ||
25691 | |||
25692 | } | ||
25693 | |||
25694 | |||
25695 | } | ||
25696 | |||
25697 | } | ||
25698 | catch (RecognitionException re) { | ||
25699 | reportError(re); | ||
25700 | recover(input,re); | ||
25701 | } | ||
25702 | finally { | ||
25703 | |||
25704 | restoreStackSize(stackSize); | ||
25705 | |||
25706 | } | ||
25707 | return ; | ||
25708 | } | ||
25709 | // $ANTLR end "rule__ALSDocument__SignatureBodiesAssignment_0_1" | ||
25710 | |||
25711 | |||
25712 | // $ANTLR start "rule__ALSDocument__FunctionDefinitionsAssignment_0_2" | ||
25713 | // InternalAlloyLanguage.g:9159:1: rule__ALSDocument__FunctionDefinitionsAssignment_0_2 : ( ruleALSFunctionDefinition ) ; | ||
25714 | public final void rule__ALSDocument__FunctionDefinitionsAssignment_0_2() throws RecognitionException { | ||
25715 | |||
25716 | int stackSize = keepStackSize(); | ||
25717 | |||
25718 | try { | ||
25719 | // InternalAlloyLanguage.g:9163:1: ( ( ruleALSFunctionDefinition ) ) | ||
25720 | // InternalAlloyLanguage.g:9164:1: ( ruleALSFunctionDefinition ) | ||
25721 | { | ||
25722 | // InternalAlloyLanguage.g:9164:1: ( ruleALSFunctionDefinition ) | ||
25723 | // InternalAlloyLanguage.g:9165:1: ruleALSFunctionDefinition | ||
25724 | { | ||
25725 | if ( state.backtracking==0 ) { | ||
25726 | before(grammarAccess.getALSDocumentAccess().getFunctionDefinitionsALSFunctionDefinitionParserRuleCall_0_2_0()); | ||
25727 | } | ||
25728 | pushFollow(FOLLOW_2); | ||
25729 | ruleALSFunctionDefinition(); | ||
25730 | |||
25731 | state._fsp--; | ||
25732 | if (state.failed) return ; | ||
25733 | if ( state.backtracking==0 ) { | ||
25734 | after(grammarAccess.getALSDocumentAccess().getFunctionDefinitionsALSFunctionDefinitionParserRuleCall_0_2_0()); | ||
25735 | } | ||
25736 | |||
25737 | } | ||
25738 | |||
25739 | |||
25740 | } | ||
25741 | |||
25742 | } | ||
25743 | catch (RecognitionException re) { | ||
25744 | reportError(re); | ||
25745 | recover(input,re); | ||
25746 | } | ||
25747 | finally { | ||
25748 | |||
25749 | restoreStackSize(stackSize); | ||
25750 | |||
25751 | } | ||
25752 | return ; | ||
25753 | } | ||
25754 | // $ANTLR end "rule__ALSDocument__FunctionDefinitionsAssignment_0_2" | ||
25755 | |||
25756 | |||
25757 | // $ANTLR start "rule__ALSDocument__RelationDefinitionsAssignment_0_3" | ||
25758 | // InternalAlloyLanguage.g:9174:1: rule__ALSDocument__RelationDefinitionsAssignment_0_3 : ( ruleALSRelationDefinition ) ; | ||
25759 | public final void rule__ALSDocument__RelationDefinitionsAssignment_0_3() throws RecognitionException { | ||
25760 | |||
25761 | int stackSize = keepStackSize(); | ||
25762 | |||
25763 | try { | ||
25764 | // InternalAlloyLanguage.g:9178:1: ( ( ruleALSRelationDefinition ) ) | ||
25765 | // InternalAlloyLanguage.g:9179:1: ( ruleALSRelationDefinition ) | ||
25766 | { | ||
25767 | // InternalAlloyLanguage.g:9179:1: ( ruleALSRelationDefinition ) | ||
25768 | // InternalAlloyLanguage.g:9180:1: ruleALSRelationDefinition | ||
25769 | { | ||
25770 | if ( state.backtracking==0 ) { | ||
25771 | before(grammarAccess.getALSDocumentAccess().getRelationDefinitionsALSRelationDefinitionParserRuleCall_0_3_0()); | ||
25772 | } | ||
25773 | pushFollow(FOLLOW_2); | ||
25774 | ruleALSRelationDefinition(); | ||
25775 | |||
25776 | state._fsp--; | ||
25777 | if (state.failed) return ; | ||
25778 | if ( state.backtracking==0 ) { | ||
25779 | after(grammarAccess.getALSDocumentAccess().getRelationDefinitionsALSRelationDefinitionParserRuleCall_0_3_0()); | ||
25780 | } | ||
25781 | |||
25782 | } | ||
25783 | |||
25784 | |||
25785 | } | ||
25786 | |||
25787 | } | ||
25788 | catch (RecognitionException re) { | ||
25789 | reportError(re); | ||
25790 | recover(input,re); | ||
25791 | } | ||
25792 | finally { | ||
25793 | |||
25794 | restoreStackSize(stackSize); | ||
25795 | |||
25796 | } | ||
25797 | return ; | ||
25798 | } | ||
25799 | // $ANTLR end "rule__ALSDocument__RelationDefinitionsAssignment_0_3" | ||
25800 | |||
25801 | |||
25802 | // $ANTLR start "rule__ALSDocument__FactDeclarationsAssignment_0_4" | ||
25803 | // InternalAlloyLanguage.g:9189:1: rule__ALSDocument__FactDeclarationsAssignment_0_4 : ( ruleALSFactDeclaration ) ; | ||
25804 | public final void rule__ALSDocument__FactDeclarationsAssignment_0_4() throws RecognitionException { | ||
25805 | |||
25806 | int stackSize = keepStackSize(); | ||
25807 | |||
25808 | try { | ||
25809 | // InternalAlloyLanguage.g:9193:1: ( ( ruleALSFactDeclaration ) ) | ||
25810 | // InternalAlloyLanguage.g:9194:1: ( ruleALSFactDeclaration ) | ||
25811 | { | ||
25812 | // InternalAlloyLanguage.g:9194:1: ( ruleALSFactDeclaration ) | ||
25813 | // InternalAlloyLanguage.g:9195:1: ruleALSFactDeclaration | ||
25814 | { | ||
25815 | if ( state.backtracking==0 ) { | ||
25816 | before(grammarAccess.getALSDocumentAccess().getFactDeclarationsALSFactDeclarationParserRuleCall_0_4_0()); | ||
25817 | } | ||
25818 | pushFollow(FOLLOW_2); | ||
25819 | ruleALSFactDeclaration(); | ||
25820 | |||
25821 | state._fsp--; | ||
25822 | if (state.failed) return ; | ||
25823 | if ( state.backtracking==0 ) { | ||
25824 | after(grammarAccess.getALSDocumentAccess().getFactDeclarationsALSFactDeclarationParserRuleCall_0_4_0()); | ||
25825 | } | ||
25826 | |||
25827 | } | ||
25828 | |||
25829 | |||
25830 | } | ||
25831 | |||
25832 | } | ||
25833 | catch (RecognitionException re) { | ||
25834 | reportError(re); | ||
25835 | recover(input,re); | ||
25836 | } | ||
25837 | finally { | ||
25838 | |||
25839 | restoreStackSize(stackSize); | ||
25840 | |||
25841 | } | ||
25842 | return ; | ||
25843 | } | ||
25844 | // $ANTLR end "rule__ALSDocument__FactDeclarationsAssignment_0_4" | ||
25845 | |||
25846 | |||
25847 | // $ANTLR start "rule__ALSDocument__RunCommandAssignment_1" | ||
25848 | // InternalAlloyLanguage.g:9204:1: rule__ALSDocument__RunCommandAssignment_1 : ( ruleALSRunCommand ) ; | ||
25849 | public final void rule__ALSDocument__RunCommandAssignment_1() throws RecognitionException { | ||
25850 | |||
25851 | int stackSize = keepStackSize(); | ||
25852 | |||
25853 | try { | ||
25854 | // InternalAlloyLanguage.g:9208:1: ( ( ruleALSRunCommand ) ) | ||
25855 | // InternalAlloyLanguage.g:9209:1: ( ruleALSRunCommand ) | ||
25856 | { | ||
25857 | // InternalAlloyLanguage.g:9209:1: ( ruleALSRunCommand ) | ||
25858 | // InternalAlloyLanguage.g:9210:1: ruleALSRunCommand | ||
25859 | { | ||
25860 | if ( state.backtracking==0 ) { | ||
25861 | before(grammarAccess.getALSDocumentAccess().getRunCommandALSRunCommandParserRuleCall_1_0()); | ||
25862 | } | ||
25863 | pushFollow(FOLLOW_2); | ||
25864 | ruleALSRunCommand(); | ||
25865 | |||
25866 | state._fsp--; | ||
25867 | if (state.failed) return ; | ||
25868 | if ( state.backtracking==0 ) { | ||
25869 | after(grammarAccess.getALSDocumentAccess().getRunCommandALSRunCommandParserRuleCall_1_0()); | ||
25870 | } | ||
25871 | |||
25872 | } | ||
25873 | |||
25874 | |||
25875 | } | ||
25876 | |||
25877 | } | ||
25878 | catch (RecognitionException re) { | ||
25879 | reportError(re); | ||
25880 | recover(input,re); | ||
25881 | } | ||
25882 | finally { | ||
25883 | |||
25884 | restoreStackSize(stackSize); | ||
25885 | |||
25886 | } | ||
25887 | return ; | ||
25888 | } | ||
25889 | // $ANTLR end "rule__ALSDocument__RunCommandAssignment_1" | ||
25890 | |||
25891 | |||
25892 | // $ANTLR start "rule__ALSEnumDeclaration__NameAssignment_1" | ||
25893 | // InternalAlloyLanguage.g:9219:1: rule__ALSEnumDeclaration__NameAssignment_1 : ( ruleALSID ) ; | ||
25894 | public final void rule__ALSEnumDeclaration__NameAssignment_1() throws RecognitionException { | ||
25895 | |||
25896 | int stackSize = keepStackSize(); | ||
25897 | |||
25898 | try { | ||
25899 | // InternalAlloyLanguage.g:9223:1: ( ( ruleALSID ) ) | ||
25900 | // InternalAlloyLanguage.g:9224:1: ( ruleALSID ) | ||
25901 | { | ||
25902 | // InternalAlloyLanguage.g:9224:1: ( ruleALSID ) | ||
25903 | // InternalAlloyLanguage.g:9225:1: ruleALSID | ||
25904 | { | ||
25905 | if ( state.backtracking==0 ) { | ||
25906 | before(grammarAccess.getALSEnumDeclarationAccess().getNameALSIDParserRuleCall_1_0()); | ||
25907 | } | ||
25908 | pushFollow(FOLLOW_2); | ||
25909 | ruleALSID(); | ||
25910 | |||
25911 | state._fsp--; | ||
25912 | if (state.failed) return ; | ||
25913 | if ( state.backtracking==0 ) { | ||
25914 | after(grammarAccess.getALSEnumDeclarationAccess().getNameALSIDParserRuleCall_1_0()); | ||
25915 | } | ||
25916 | |||
25917 | } | ||
25918 | |||
25919 | |||
25920 | } | ||
25921 | |||
25922 | } | ||
25923 | catch (RecognitionException re) { | ||
25924 | reportError(re); | ||
25925 | recover(input,re); | ||
25926 | } | ||
25927 | finally { | ||
25928 | |||
25929 | restoreStackSize(stackSize); | ||
25930 | |||
25931 | } | ||
25932 | return ; | ||
25933 | } | ||
25934 | // $ANTLR end "rule__ALSEnumDeclaration__NameAssignment_1" | ||
25935 | |||
25936 | |||
25937 | // $ANTLR start "rule__ALSEnumDeclaration__LiteralAssignment_3" | ||
25938 | // InternalAlloyLanguage.g:9234:1: rule__ALSEnumDeclaration__LiteralAssignment_3 : ( ruleALSEnumLiteral ) ; | ||
25939 | public final void rule__ALSEnumDeclaration__LiteralAssignment_3() throws RecognitionException { | ||
25940 | |||
25941 | int stackSize = keepStackSize(); | ||
25942 | |||
25943 | try { | ||
25944 | // InternalAlloyLanguage.g:9238:1: ( ( ruleALSEnumLiteral ) ) | ||
25945 | // InternalAlloyLanguage.g:9239:1: ( ruleALSEnumLiteral ) | ||
25946 | { | ||
25947 | // InternalAlloyLanguage.g:9239:1: ( ruleALSEnumLiteral ) | ||
25948 | // InternalAlloyLanguage.g:9240:1: ruleALSEnumLiteral | ||
25949 | { | ||
25950 | if ( state.backtracking==0 ) { | ||
25951 | before(grammarAccess.getALSEnumDeclarationAccess().getLiteralALSEnumLiteralParserRuleCall_3_0()); | ||
25952 | } | ||
25953 | pushFollow(FOLLOW_2); | ||
25954 | ruleALSEnumLiteral(); | ||
25955 | |||
25956 | state._fsp--; | ||
25957 | if (state.failed) return ; | ||
25958 | if ( state.backtracking==0 ) { | ||
25959 | after(grammarAccess.getALSEnumDeclarationAccess().getLiteralALSEnumLiteralParserRuleCall_3_0()); | ||
25960 | } | ||
25961 | |||
25962 | } | ||
25963 | |||
25964 | |||
25965 | } | ||
25966 | |||
25967 | } | ||
25968 | catch (RecognitionException re) { | ||
25969 | reportError(re); | ||
25970 | recover(input,re); | ||
25971 | } | ||
25972 | finally { | ||
25973 | |||
25974 | restoreStackSize(stackSize); | ||
25975 | |||
25976 | } | ||
25977 | return ; | ||
25978 | } | ||
25979 | // $ANTLR end "rule__ALSEnumDeclaration__LiteralAssignment_3" | ||
25980 | |||
25981 | |||
25982 | // $ANTLR start "rule__ALSEnumDeclaration__LiteralAssignment_4_1" | ||
25983 | // InternalAlloyLanguage.g:9249:1: rule__ALSEnumDeclaration__LiteralAssignment_4_1 : ( ruleALSEnumLiteral ) ; | ||
25984 | public final void rule__ALSEnumDeclaration__LiteralAssignment_4_1() throws RecognitionException { | ||
25985 | |||
25986 | int stackSize = keepStackSize(); | ||
25987 | |||
25988 | try { | ||
25989 | // InternalAlloyLanguage.g:9253:1: ( ( ruleALSEnumLiteral ) ) | ||
25990 | // InternalAlloyLanguage.g:9254:1: ( ruleALSEnumLiteral ) | ||
25991 | { | ||
25992 | // InternalAlloyLanguage.g:9254:1: ( ruleALSEnumLiteral ) | ||
25993 | // InternalAlloyLanguage.g:9255:1: ruleALSEnumLiteral | ||
25994 | { | ||
25995 | if ( state.backtracking==0 ) { | ||
25996 | before(grammarAccess.getALSEnumDeclarationAccess().getLiteralALSEnumLiteralParserRuleCall_4_1_0()); | ||
25997 | } | ||
25998 | pushFollow(FOLLOW_2); | ||
25999 | ruleALSEnumLiteral(); | ||
26000 | |||
26001 | state._fsp--; | ||
26002 | if (state.failed) return ; | ||
26003 | if ( state.backtracking==0 ) { | ||
26004 | after(grammarAccess.getALSEnumDeclarationAccess().getLiteralALSEnumLiteralParserRuleCall_4_1_0()); | ||
26005 | } | ||
26006 | |||
26007 | } | ||
26008 | |||
26009 | |||
26010 | } | ||
26011 | |||
26012 | } | ||
26013 | catch (RecognitionException re) { | ||
26014 | reportError(re); | ||
26015 | recover(input,re); | ||
26016 | } | ||
26017 | finally { | ||
26018 | |||
26019 | restoreStackSize(stackSize); | ||
26020 | |||
26021 | } | ||
26022 | return ; | ||
26023 | } | ||
26024 | // $ANTLR end "rule__ALSEnumDeclaration__LiteralAssignment_4_1" | ||
26025 | |||
26026 | |||
26027 | // $ANTLR start "rule__ALSEnumLiteral__NameAssignment" | ||
26028 | // InternalAlloyLanguage.g:9264:1: rule__ALSEnumLiteral__NameAssignment : ( ruleALSID ) ; | ||
26029 | public final void rule__ALSEnumLiteral__NameAssignment() throws RecognitionException { | ||
26030 | |||
26031 | int stackSize = keepStackSize(); | ||
26032 | |||
26033 | try { | ||
26034 | // InternalAlloyLanguage.g:9268:1: ( ( ruleALSID ) ) | ||
26035 | // InternalAlloyLanguage.g:9269:1: ( ruleALSID ) | ||
26036 | { | ||
26037 | // InternalAlloyLanguage.g:9269:1: ( ruleALSID ) | ||
26038 | // InternalAlloyLanguage.g:9270:1: ruleALSID | ||
26039 | { | ||
26040 | if ( state.backtracking==0 ) { | ||
26041 | before(grammarAccess.getALSEnumLiteralAccess().getNameALSIDParserRuleCall_0()); | ||
26042 | } | ||
26043 | pushFollow(FOLLOW_2); | ||
26044 | ruleALSID(); | ||
26045 | |||
26046 | state._fsp--; | ||
26047 | if (state.failed) return ; | ||
26048 | if ( state.backtracking==0 ) { | ||
26049 | after(grammarAccess.getALSEnumLiteralAccess().getNameALSIDParserRuleCall_0()); | ||
26050 | } | ||
26051 | |||
26052 | } | ||
26053 | |||
26054 | |||
26055 | } | ||
26056 | |||
26057 | } | ||
26058 | catch (RecognitionException re) { | ||
26059 | reportError(re); | ||
26060 | recover(input,re); | ||
26061 | } | ||
26062 | finally { | ||
26063 | |||
26064 | restoreStackSize(stackSize); | ||
26065 | |||
26066 | } | ||
26067 | return ; | ||
26068 | } | ||
26069 | // $ANTLR end "rule__ALSEnumLiteral__NameAssignment" | ||
26070 | |||
26071 | |||
26072 | // $ANTLR start "rule__ALSSignatureDeclaration__NameAssignment" | ||
26073 | // InternalAlloyLanguage.g:9279:1: rule__ALSSignatureDeclaration__NameAssignment : ( ruleALSID ) ; | ||
26074 | public final void rule__ALSSignatureDeclaration__NameAssignment() throws RecognitionException { | ||
26075 | |||
26076 | int stackSize = keepStackSize(); | ||
26077 | |||
26078 | try { | ||
26079 | // InternalAlloyLanguage.g:9283:1: ( ( ruleALSID ) ) | ||
26080 | // InternalAlloyLanguage.g:9284:1: ( ruleALSID ) | ||
26081 | { | ||
26082 | // InternalAlloyLanguage.g:9284:1: ( ruleALSID ) | ||
26083 | // InternalAlloyLanguage.g:9285:1: ruleALSID | ||
26084 | { | ||
26085 | if ( state.backtracking==0 ) { | ||
26086 | before(grammarAccess.getALSSignatureDeclarationAccess().getNameALSIDParserRuleCall_0()); | ||
26087 | } | ||
26088 | pushFollow(FOLLOW_2); | ||
26089 | ruleALSID(); | ||
26090 | |||
26091 | state._fsp--; | ||
26092 | if (state.failed) return ; | ||
26093 | if ( state.backtracking==0 ) { | ||
26094 | after(grammarAccess.getALSSignatureDeclarationAccess().getNameALSIDParserRuleCall_0()); | ||
26095 | } | ||
26096 | |||
26097 | } | ||
26098 | |||
26099 | |||
26100 | } | ||
26101 | |||
26102 | } | ||
26103 | catch (RecognitionException re) { | ||
26104 | reportError(re); | ||
26105 | recover(input,re); | ||
26106 | } | ||
26107 | finally { | ||
26108 | |||
26109 | restoreStackSize(stackSize); | ||
26110 | |||
26111 | } | ||
26112 | return ; | ||
26113 | } | ||
26114 | // $ANTLR end "rule__ALSSignatureDeclaration__NameAssignment" | ||
26115 | |||
26116 | |||
26117 | // $ANTLR start "rule__ALSSignatureBody__MultiplicityAssignment_0_0" | ||
26118 | // InternalAlloyLanguage.g:9294:1: rule__ALSSignatureBody__MultiplicityAssignment_0_0 : ( ruleALSMultiplicity ) ; | ||
26119 | public final void rule__ALSSignatureBody__MultiplicityAssignment_0_0() throws RecognitionException { | ||
26120 | |||
26121 | int stackSize = keepStackSize(); | ||
26122 | |||
26123 | try { | ||
26124 | // InternalAlloyLanguage.g:9298:1: ( ( ruleALSMultiplicity ) ) | ||
26125 | // InternalAlloyLanguage.g:9299:1: ( ruleALSMultiplicity ) | ||
26126 | { | ||
26127 | // InternalAlloyLanguage.g:9299:1: ( ruleALSMultiplicity ) | ||
26128 | // InternalAlloyLanguage.g:9300:1: ruleALSMultiplicity | ||
26129 | { | ||
26130 | if ( state.backtracking==0 ) { | ||
26131 | before(grammarAccess.getALSSignatureBodyAccess().getMultiplicityALSMultiplicityEnumRuleCall_0_0_0()); | ||
26132 | } | ||
26133 | pushFollow(FOLLOW_2); | ||
26134 | ruleALSMultiplicity(); | ||
26135 | |||
26136 | state._fsp--; | ||
26137 | if (state.failed) return ; | ||
26138 | if ( state.backtracking==0 ) { | ||
26139 | after(grammarAccess.getALSSignatureBodyAccess().getMultiplicityALSMultiplicityEnumRuleCall_0_0_0()); | ||
26140 | } | ||
26141 | |||
26142 | } | ||
26143 | |||
26144 | |||
26145 | } | ||
26146 | |||
26147 | } | ||
26148 | catch (RecognitionException re) { | ||
26149 | reportError(re); | ||
26150 | recover(input,re); | ||
26151 | } | ||
26152 | finally { | ||
26153 | |||
26154 | restoreStackSize(stackSize); | ||
26155 | |||
26156 | } | ||
26157 | return ; | ||
26158 | } | ||
26159 | // $ANTLR end "rule__ALSSignatureBody__MultiplicityAssignment_0_0" | ||
26160 | |||
26161 | |||
26162 | // $ANTLR start "rule__ALSSignatureBody__AbstractAssignment_0_1" | ||
26163 | // InternalAlloyLanguage.g:9309:1: rule__ALSSignatureBody__AbstractAssignment_0_1 : ( ( 'abstract' ) ) ; | ||
26164 | public final void rule__ALSSignatureBody__AbstractAssignment_0_1() throws RecognitionException { | ||
26165 | |||
26166 | int stackSize = keepStackSize(); | ||
26167 | |||
26168 | try { | ||
26169 | // InternalAlloyLanguage.g:9313:1: ( ( ( 'abstract' ) ) ) | ||
26170 | // InternalAlloyLanguage.g:9314:1: ( ( 'abstract' ) ) | ||
26171 | { | ||
26172 | // InternalAlloyLanguage.g:9314:1: ( ( 'abstract' ) ) | ||
26173 | // InternalAlloyLanguage.g:9315:1: ( 'abstract' ) | ||
26174 | { | ||
26175 | if ( state.backtracking==0 ) { | ||
26176 | before(grammarAccess.getALSSignatureBodyAccess().getAbstractAbstractKeyword_0_1_0()); | ||
26177 | } | ||
26178 | // InternalAlloyLanguage.g:9316:1: ( 'abstract' ) | ||
26179 | // InternalAlloyLanguage.g:9317:1: 'abstract' | ||
26180 | { | ||
26181 | if ( state.backtracking==0 ) { | ||
26182 | before(grammarAccess.getALSSignatureBodyAccess().getAbstractAbstractKeyword_0_1_0()); | ||
26183 | } | ||
26184 | match(input,75,FOLLOW_2); if (state.failed) return ; | ||
26185 | if ( state.backtracking==0 ) { | ||
26186 | after(grammarAccess.getALSSignatureBodyAccess().getAbstractAbstractKeyword_0_1_0()); | ||
26187 | } | ||
26188 | |||
26189 | } | ||
26190 | |||
26191 | if ( state.backtracking==0 ) { | ||
26192 | after(grammarAccess.getALSSignatureBodyAccess().getAbstractAbstractKeyword_0_1_0()); | ||
26193 | } | ||
26194 | |||
26195 | } | ||
26196 | |||
26197 | |||
26198 | } | ||
26199 | |||
26200 | } | ||
26201 | catch (RecognitionException re) { | ||
26202 | reportError(re); | ||
26203 | recover(input,re); | ||
26204 | } | ||
26205 | finally { | ||
26206 | |||
26207 | restoreStackSize(stackSize); | ||
26208 | |||
26209 | } | ||
26210 | return ; | ||
26211 | } | ||
26212 | // $ANTLR end "rule__ALSSignatureBody__AbstractAssignment_0_1" | ||
26213 | |||
26214 | |||
26215 | // $ANTLR start "rule__ALSSignatureBody__DeclarationsAssignment_2" | ||
26216 | // InternalAlloyLanguage.g:9332:1: rule__ALSSignatureBody__DeclarationsAssignment_2 : ( ruleALSSignatureDeclaration ) ; | ||
26217 | public final void rule__ALSSignatureBody__DeclarationsAssignment_2() throws RecognitionException { | ||
26218 | |||
26219 | int stackSize = keepStackSize(); | ||
26220 | |||
26221 | try { | ||
26222 | // InternalAlloyLanguage.g:9336:1: ( ( ruleALSSignatureDeclaration ) ) | ||
26223 | // InternalAlloyLanguage.g:9337:1: ( ruleALSSignatureDeclaration ) | ||
26224 | { | ||
26225 | // InternalAlloyLanguage.g:9337:1: ( ruleALSSignatureDeclaration ) | ||
26226 | // InternalAlloyLanguage.g:9338:1: ruleALSSignatureDeclaration | ||
26227 | { | ||
26228 | if ( state.backtracking==0 ) { | ||
26229 | before(grammarAccess.getALSSignatureBodyAccess().getDeclarationsALSSignatureDeclarationParserRuleCall_2_0()); | ||
26230 | } | ||
26231 | pushFollow(FOLLOW_2); | ||
26232 | ruleALSSignatureDeclaration(); | ||
26233 | |||
26234 | state._fsp--; | ||
26235 | if (state.failed) return ; | ||
26236 | if ( state.backtracking==0 ) { | ||
26237 | after(grammarAccess.getALSSignatureBodyAccess().getDeclarationsALSSignatureDeclarationParserRuleCall_2_0()); | ||
26238 | } | ||
26239 | |||
26240 | } | ||
26241 | |||
26242 | |||
26243 | } | ||
26244 | |||
26245 | } | ||
26246 | catch (RecognitionException re) { | ||
26247 | reportError(re); | ||
26248 | recover(input,re); | ||
26249 | } | ||
26250 | finally { | ||
26251 | |||
26252 | restoreStackSize(stackSize); | ||
26253 | |||
26254 | } | ||
26255 | return ; | ||
26256 | } | ||
26257 | // $ANTLR end "rule__ALSSignatureBody__DeclarationsAssignment_2" | ||
26258 | |||
26259 | |||
26260 | // $ANTLR start "rule__ALSSignatureBody__DeclarationsAssignment_3_1" | ||
26261 | // InternalAlloyLanguage.g:9347:1: rule__ALSSignatureBody__DeclarationsAssignment_3_1 : ( ruleALSSignatureDeclaration ) ; | ||
26262 | public final void rule__ALSSignatureBody__DeclarationsAssignment_3_1() throws RecognitionException { | ||
26263 | |||
26264 | int stackSize = keepStackSize(); | ||
26265 | |||
26266 | try { | ||
26267 | // InternalAlloyLanguage.g:9351:1: ( ( ruleALSSignatureDeclaration ) ) | ||
26268 | // InternalAlloyLanguage.g:9352:1: ( ruleALSSignatureDeclaration ) | ||
26269 | { | ||
26270 | // InternalAlloyLanguage.g:9352:1: ( ruleALSSignatureDeclaration ) | ||
26271 | // InternalAlloyLanguage.g:9353:1: ruleALSSignatureDeclaration | ||
26272 | { | ||
26273 | if ( state.backtracking==0 ) { | ||
26274 | before(grammarAccess.getALSSignatureBodyAccess().getDeclarationsALSSignatureDeclarationParserRuleCall_3_1_0()); | ||
26275 | } | ||
26276 | pushFollow(FOLLOW_2); | ||
26277 | ruleALSSignatureDeclaration(); | ||
26278 | |||
26279 | state._fsp--; | ||
26280 | if (state.failed) return ; | ||
26281 | if ( state.backtracking==0 ) { | ||
26282 | after(grammarAccess.getALSSignatureBodyAccess().getDeclarationsALSSignatureDeclarationParserRuleCall_3_1_0()); | ||
26283 | } | ||
26284 | |||
26285 | } | ||
26286 | |||
26287 | |||
26288 | } | ||
26289 | |||
26290 | } | ||
26291 | catch (RecognitionException re) { | ||
26292 | reportError(re); | ||
26293 | recover(input,re); | ||
26294 | } | ||
26295 | finally { | ||
26296 | |||
26297 | restoreStackSize(stackSize); | ||
26298 | |||
26299 | } | ||
26300 | return ; | ||
26301 | } | ||
26302 | // $ANTLR end "rule__ALSSignatureBody__DeclarationsAssignment_3_1" | ||
26303 | |||
26304 | |||
26305 | // $ANTLR start "rule__ALSSignatureBody__SupertypeAssignment_4_0_1" | ||
26306 | // InternalAlloyLanguage.g:9362:1: rule__ALSSignatureBody__SupertypeAssignment_4_0_1 : ( ( RULE_ID ) ) ; | ||
26307 | public final void rule__ALSSignatureBody__SupertypeAssignment_4_0_1() throws RecognitionException { | ||
26308 | |||
26309 | int stackSize = keepStackSize(); | ||
26310 | |||
26311 | try { | ||
26312 | // InternalAlloyLanguage.g:9366:1: ( ( ( RULE_ID ) ) ) | ||
26313 | // InternalAlloyLanguage.g:9367:1: ( ( RULE_ID ) ) | ||
26314 | { | ||
26315 | // InternalAlloyLanguage.g:9367:1: ( ( RULE_ID ) ) | ||
26316 | // InternalAlloyLanguage.g:9368:1: ( RULE_ID ) | ||
26317 | { | ||
26318 | if ( state.backtracking==0 ) { | ||
26319 | before(grammarAccess.getALSSignatureBodyAccess().getSupertypeALSSignatureDeclarationCrossReference_4_0_1_0()); | ||
26320 | } | ||
26321 | // InternalAlloyLanguage.g:9369:1: ( RULE_ID ) | ||
26322 | // InternalAlloyLanguage.g:9370:1: RULE_ID | ||
26323 | { | ||
26324 | if ( state.backtracking==0 ) { | ||
26325 | before(grammarAccess.getALSSignatureBodyAccess().getSupertypeALSSignatureDeclarationIDTerminalRuleCall_4_0_1_0_1()); | ||
26326 | } | ||
26327 | match(input,RULE_ID,FOLLOW_2); if (state.failed) return ; | ||
26328 | if ( state.backtracking==0 ) { | ||
26329 | after(grammarAccess.getALSSignatureBodyAccess().getSupertypeALSSignatureDeclarationIDTerminalRuleCall_4_0_1_0_1()); | ||
26330 | } | ||
26331 | |||
26332 | } | ||
26333 | |||
26334 | if ( state.backtracking==0 ) { | ||
26335 | after(grammarAccess.getALSSignatureBodyAccess().getSupertypeALSSignatureDeclarationCrossReference_4_0_1_0()); | ||
26336 | } | ||
26337 | |||
26338 | } | ||
26339 | |||
26340 | |||
26341 | } | ||
26342 | |||
26343 | } | ||
26344 | catch (RecognitionException re) { | ||
26345 | reportError(re); | ||
26346 | recover(input,re); | ||
26347 | } | ||
26348 | finally { | ||
26349 | |||
26350 | restoreStackSize(stackSize); | ||
26351 | |||
26352 | } | ||
26353 | return ; | ||
26354 | } | ||
26355 | // $ANTLR end "rule__ALSSignatureBody__SupertypeAssignment_4_0_1" | ||
26356 | |||
26357 | |||
26358 | // $ANTLR start "rule__ALSSignatureBody__SupersetAssignment_4_1_1" | ||
26359 | // InternalAlloyLanguage.g:9381:1: rule__ALSSignatureBody__SupersetAssignment_4_1_1 : ( ( RULE_ID ) ) ; | ||
26360 | public final void rule__ALSSignatureBody__SupersetAssignment_4_1_1() throws RecognitionException { | ||
26361 | |||
26362 | int stackSize = keepStackSize(); | ||
26363 | |||
26364 | try { | ||
26365 | // InternalAlloyLanguage.g:9385:1: ( ( ( RULE_ID ) ) ) | ||
26366 | // InternalAlloyLanguage.g:9386:1: ( ( RULE_ID ) ) | ||
26367 | { | ||
26368 | // InternalAlloyLanguage.g:9386:1: ( ( RULE_ID ) ) | ||
26369 | // InternalAlloyLanguage.g:9387:1: ( RULE_ID ) | ||
26370 | { | ||
26371 | if ( state.backtracking==0 ) { | ||
26372 | before(grammarAccess.getALSSignatureBodyAccess().getSupersetALSSignatureDeclarationCrossReference_4_1_1_0()); | ||
26373 | } | ||
26374 | // InternalAlloyLanguage.g:9388:1: ( RULE_ID ) | ||
26375 | // InternalAlloyLanguage.g:9389:1: RULE_ID | ||
26376 | { | ||
26377 | if ( state.backtracking==0 ) { | ||
26378 | before(grammarAccess.getALSSignatureBodyAccess().getSupersetALSSignatureDeclarationIDTerminalRuleCall_4_1_1_0_1()); | ||
26379 | } | ||
26380 | match(input,RULE_ID,FOLLOW_2); if (state.failed) return ; | ||
26381 | if ( state.backtracking==0 ) { | ||
26382 | after(grammarAccess.getALSSignatureBodyAccess().getSupersetALSSignatureDeclarationIDTerminalRuleCall_4_1_1_0_1()); | ||
26383 | } | ||
26384 | |||
26385 | } | ||
26386 | |||
26387 | if ( state.backtracking==0 ) { | ||
26388 | after(grammarAccess.getALSSignatureBodyAccess().getSupersetALSSignatureDeclarationCrossReference_4_1_1_0()); | ||
26389 | } | ||
26390 | |||
26391 | } | ||
26392 | |||
26393 | |||
26394 | } | ||
26395 | |||
26396 | } | ||
26397 | catch (RecognitionException re) { | ||
26398 | reportError(re); | ||
26399 | recover(input,re); | ||
26400 | } | ||
26401 | finally { | ||
26402 | |||
26403 | restoreStackSize(stackSize); | ||
26404 | |||
26405 | } | ||
26406 | return ; | ||
26407 | } | ||
26408 | // $ANTLR end "rule__ALSSignatureBody__SupersetAssignment_4_1_1" | ||
26409 | |||
26410 | |||
26411 | // $ANTLR start "rule__ALSSignatureBody__SupersetAssignment_4_1_2_1" | ||
26412 | // InternalAlloyLanguage.g:9400:1: rule__ALSSignatureBody__SupersetAssignment_4_1_2_1 : ( ( RULE_ID ) ) ; | ||
26413 | public final void rule__ALSSignatureBody__SupersetAssignment_4_1_2_1() throws RecognitionException { | ||
26414 | |||
26415 | int stackSize = keepStackSize(); | ||
26416 | |||
26417 | try { | ||
26418 | // InternalAlloyLanguage.g:9404:1: ( ( ( RULE_ID ) ) ) | ||
26419 | // InternalAlloyLanguage.g:9405:1: ( ( RULE_ID ) ) | ||
26420 | { | ||
26421 | // InternalAlloyLanguage.g:9405:1: ( ( RULE_ID ) ) | ||
26422 | // InternalAlloyLanguage.g:9406:1: ( RULE_ID ) | ||
26423 | { | ||
26424 | if ( state.backtracking==0 ) { | ||
26425 | before(grammarAccess.getALSSignatureBodyAccess().getSupersetALSSignatureDeclarationCrossReference_4_1_2_1_0()); | ||
26426 | } | ||
26427 | // InternalAlloyLanguage.g:9407:1: ( RULE_ID ) | ||
26428 | // InternalAlloyLanguage.g:9408:1: RULE_ID | ||
26429 | { | ||
26430 | if ( state.backtracking==0 ) { | ||
26431 | before(grammarAccess.getALSSignatureBodyAccess().getSupersetALSSignatureDeclarationIDTerminalRuleCall_4_1_2_1_0_1()); | ||
26432 | } | ||
26433 | match(input,RULE_ID,FOLLOW_2); if (state.failed) return ; | ||
26434 | if ( state.backtracking==0 ) { | ||
26435 | after(grammarAccess.getALSSignatureBodyAccess().getSupersetALSSignatureDeclarationIDTerminalRuleCall_4_1_2_1_0_1()); | ||
26436 | } | ||
26437 | |||
26438 | } | ||
26439 | |||
26440 | if ( state.backtracking==0 ) { | ||
26441 | after(grammarAccess.getALSSignatureBodyAccess().getSupersetALSSignatureDeclarationCrossReference_4_1_2_1_0()); | ||
26442 | } | ||
26443 | |||
26444 | } | ||
26445 | |||
26446 | |||
26447 | } | ||
26448 | |||
26449 | } | ||
26450 | catch (RecognitionException re) { | ||
26451 | reportError(re); | ||
26452 | recover(input,re); | ||
26453 | } | ||
26454 | finally { | ||
26455 | |||
26456 | restoreStackSize(stackSize); | ||
26457 | |||
26458 | } | ||
26459 | return ; | ||
26460 | } | ||
26461 | // $ANTLR end "rule__ALSSignatureBody__SupersetAssignment_4_1_2_1" | ||
26462 | |||
26463 | |||
26464 | // $ANTLR start "rule__ALSSignatureBody__FieldsAssignment_6_0" | ||
26465 | // InternalAlloyLanguage.g:9419:1: rule__ALSSignatureBody__FieldsAssignment_6_0 : ( ruleALSFieldDeclaration ) ; | ||
26466 | public final void rule__ALSSignatureBody__FieldsAssignment_6_0() throws RecognitionException { | ||
26467 | |||
26468 | int stackSize = keepStackSize(); | ||
26469 | |||
26470 | try { | ||
26471 | // InternalAlloyLanguage.g:9423:1: ( ( ruleALSFieldDeclaration ) ) | ||
26472 | // InternalAlloyLanguage.g:9424:1: ( ruleALSFieldDeclaration ) | ||
26473 | { | ||
26474 | // InternalAlloyLanguage.g:9424:1: ( ruleALSFieldDeclaration ) | ||
26475 | // InternalAlloyLanguage.g:9425:1: ruleALSFieldDeclaration | ||
26476 | { | ||
26477 | if ( state.backtracking==0 ) { | ||
26478 | before(grammarAccess.getALSSignatureBodyAccess().getFieldsALSFieldDeclarationParserRuleCall_6_0_0()); | ||
26479 | } | ||
26480 | pushFollow(FOLLOW_2); | ||
26481 | ruleALSFieldDeclaration(); | ||
26482 | |||
26483 | state._fsp--; | ||
26484 | if (state.failed) return ; | ||
26485 | if ( state.backtracking==0 ) { | ||
26486 | after(grammarAccess.getALSSignatureBodyAccess().getFieldsALSFieldDeclarationParserRuleCall_6_0_0()); | ||
26487 | } | ||
26488 | |||
26489 | } | ||
26490 | |||
26491 | |||
26492 | } | ||
26493 | |||
26494 | } | ||
26495 | catch (RecognitionException re) { | ||
26496 | reportError(re); | ||
26497 | recover(input,re); | ||
26498 | } | ||
26499 | finally { | ||
26500 | |||
26501 | restoreStackSize(stackSize); | ||
26502 | |||
26503 | } | ||
26504 | return ; | ||
26505 | } | ||
26506 | // $ANTLR end "rule__ALSSignatureBody__FieldsAssignment_6_0" | ||
26507 | |||
26508 | |||
26509 | // $ANTLR start "rule__ALSSignatureBody__FieldsAssignment_6_1_1" | ||
26510 | // InternalAlloyLanguage.g:9434:1: rule__ALSSignatureBody__FieldsAssignment_6_1_1 : ( ruleALSFieldDeclaration ) ; | ||
26511 | public final void rule__ALSSignatureBody__FieldsAssignment_6_1_1() throws RecognitionException { | ||
26512 | |||
26513 | int stackSize = keepStackSize(); | ||
26514 | |||
26515 | try { | ||
26516 | // InternalAlloyLanguage.g:9438:1: ( ( ruleALSFieldDeclaration ) ) | ||
26517 | // InternalAlloyLanguage.g:9439:1: ( ruleALSFieldDeclaration ) | ||
26518 | { | ||
26519 | // InternalAlloyLanguage.g:9439:1: ( ruleALSFieldDeclaration ) | ||
26520 | // InternalAlloyLanguage.g:9440:1: ruleALSFieldDeclaration | ||
26521 | { | ||
26522 | if ( state.backtracking==0 ) { | ||
26523 | before(grammarAccess.getALSSignatureBodyAccess().getFieldsALSFieldDeclarationParserRuleCall_6_1_1_0()); | ||
26524 | } | ||
26525 | pushFollow(FOLLOW_2); | ||
26526 | ruleALSFieldDeclaration(); | ||
26527 | |||
26528 | state._fsp--; | ||
26529 | if (state.failed) return ; | ||
26530 | if ( state.backtracking==0 ) { | ||
26531 | after(grammarAccess.getALSSignatureBodyAccess().getFieldsALSFieldDeclarationParserRuleCall_6_1_1_0()); | ||
26532 | } | ||
26533 | |||
26534 | } | ||
26535 | |||
26536 | |||
26537 | } | ||
26538 | |||
26539 | } | ||
26540 | catch (RecognitionException re) { | ||
26541 | reportError(re); | ||
26542 | recover(input,re); | ||
26543 | } | ||
26544 | finally { | ||
26545 | |||
26546 | restoreStackSize(stackSize); | ||
26547 | |||
26548 | } | ||
26549 | return ; | ||
26550 | } | ||
26551 | // $ANTLR end "rule__ALSSignatureBody__FieldsAssignment_6_1_1" | ||
26552 | |||
26553 | |||
26554 | // $ANTLR start "rule__ALSFieldDeclaration__NameAssignment_0" | ||
26555 | // InternalAlloyLanguage.g:9449:1: rule__ALSFieldDeclaration__NameAssignment_0 : ( ruleALSID ) ; | ||
26556 | public final void rule__ALSFieldDeclaration__NameAssignment_0() throws RecognitionException { | ||
26557 | |||
26558 | int stackSize = keepStackSize(); | ||
26559 | |||
26560 | try { | ||
26561 | // InternalAlloyLanguage.g:9453:1: ( ( ruleALSID ) ) | ||
26562 | // InternalAlloyLanguage.g:9454:1: ( ruleALSID ) | ||
26563 | { | ||
26564 | // InternalAlloyLanguage.g:9454:1: ( ruleALSID ) | ||
26565 | // InternalAlloyLanguage.g:9455:1: ruleALSID | ||
26566 | { | ||
26567 | if ( state.backtracking==0 ) { | ||
26568 | before(grammarAccess.getALSFieldDeclarationAccess().getNameALSIDParserRuleCall_0_0()); | ||
26569 | } | ||
26570 | pushFollow(FOLLOW_2); | ||
26571 | ruleALSID(); | ||
26572 | |||
26573 | state._fsp--; | ||
26574 | if (state.failed) return ; | ||
26575 | if ( state.backtracking==0 ) { | ||
26576 | after(grammarAccess.getALSFieldDeclarationAccess().getNameALSIDParserRuleCall_0_0()); | ||
26577 | } | ||
26578 | |||
26579 | } | ||
26580 | |||
26581 | |||
26582 | } | ||
26583 | |||
26584 | } | ||
26585 | catch (RecognitionException re) { | ||
26586 | reportError(re); | ||
26587 | recover(input,re); | ||
26588 | } | ||
26589 | finally { | ||
26590 | |||
26591 | restoreStackSize(stackSize); | ||
26592 | |||
26593 | } | ||
26594 | return ; | ||
26595 | } | ||
26596 | // $ANTLR end "rule__ALSFieldDeclaration__NameAssignment_0" | ||
26597 | |||
26598 | |||
26599 | // $ANTLR start "rule__ALSFieldDeclaration__MultiplicityAssignment_2" | ||
26600 | // InternalAlloyLanguage.g:9464:1: rule__ALSFieldDeclaration__MultiplicityAssignment_2 : ( ruleALSMultiplicity ) ; | ||
26601 | public final void rule__ALSFieldDeclaration__MultiplicityAssignment_2() throws RecognitionException { | ||
26602 | |||
26603 | int stackSize = keepStackSize(); | ||
26604 | |||
26605 | try { | ||
26606 | // InternalAlloyLanguage.g:9468:1: ( ( ruleALSMultiplicity ) ) | ||
26607 | // InternalAlloyLanguage.g:9469:1: ( ruleALSMultiplicity ) | ||
26608 | { | ||
26609 | // InternalAlloyLanguage.g:9469:1: ( ruleALSMultiplicity ) | ||
26610 | // InternalAlloyLanguage.g:9470:1: ruleALSMultiplicity | ||
26611 | { | ||
26612 | if ( state.backtracking==0 ) { | ||
26613 | before(grammarAccess.getALSFieldDeclarationAccess().getMultiplicityALSMultiplicityEnumRuleCall_2_0()); | ||
26614 | } | ||
26615 | pushFollow(FOLLOW_2); | ||
26616 | ruleALSMultiplicity(); | ||
26617 | |||
26618 | state._fsp--; | ||
26619 | if (state.failed) return ; | ||
26620 | if ( state.backtracking==0 ) { | ||
26621 | after(grammarAccess.getALSFieldDeclarationAccess().getMultiplicityALSMultiplicityEnumRuleCall_2_0()); | ||
26622 | } | ||
26623 | |||
26624 | } | ||
26625 | |||
26626 | |||
26627 | } | ||
26628 | |||
26629 | } | ||
26630 | catch (RecognitionException re) { | ||
26631 | reportError(re); | ||
26632 | recover(input,re); | ||
26633 | } | ||
26634 | finally { | ||
26635 | |||
26636 | restoreStackSize(stackSize); | ||
26637 | |||
26638 | } | ||
26639 | return ; | ||
26640 | } | ||
26641 | // $ANTLR end "rule__ALSFieldDeclaration__MultiplicityAssignment_2" | ||
26642 | |||
26643 | |||
26644 | // $ANTLR start "rule__ALSFieldDeclaration__TypeAssignment_3" | ||
26645 | // InternalAlloyLanguage.g:9479:1: rule__ALSFieldDeclaration__TypeAssignment_3 : ( ruleALSTerm ) ; | ||
26646 | public final void rule__ALSFieldDeclaration__TypeAssignment_3() throws RecognitionException { | ||
26647 | |||
26648 | int stackSize = keepStackSize(); | ||
26649 | |||
26650 | try { | ||
26651 | // InternalAlloyLanguage.g:9483:1: ( ( ruleALSTerm ) ) | ||
26652 | // InternalAlloyLanguage.g:9484:1: ( ruleALSTerm ) | ||
26653 | { | ||
26654 | // InternalAlloyLanguage.g:9484:1: ( ruleALSTerm ) | ||
26655 | // InternalAlloyLanguage.g:9485:1: ruleALSTerm | ||
26656 | { | ||
26657 | if ( state.backtracking==0 ) { | ||
26658 | before(grammarAccess.getALSFieldDeclarationAccess().getTypeALSTermParserRuleCall_3_0()); | ||
26659 | } | ||
26660 | pushFollow(FOLLOW_2); | ||
26661 | ruleALSTerm(); | ||
26662 | |||
26663 | state._fsp--; | ||
26664 | if (state.failed) return ; | ||
26665 | if ( state.backtracking==0 ) { | ||
26666 | after(grammarAccess.getALSFieldDeclarationAccess().getTypeALSTermParserRuleCall_3_0()); | ||
26667 | } | ||
26668 | |||
26669 | } | ||
26670 | |||
26671 | |||
26672 | } | ||
26673 | |||
26674 | } | ||
26675 | catch (RecognitionException re) { | ||
26676 | reportError(re); | ||
26677 | recover(input,re); | ||
26678 | } | ||
26679 | finally { | ||
26680 | |||
26681 | restoreStackSize(stackSize); | ||
26682 | |||
26683 | } | ||
26684 | return ; | ||
26685 | } | ||
26686 | // $ANTLR end "rule__ALSFieldDeclaration__TypeAssignment_3" | ||
26687 | |||
26688 | |||
26689 | // $ANTLR start "rule__ALSFunctionDefinition__NameAssignment_1" | ||
26690 | // InternalAlloyLanguage.g:9494:1: rule__ALSFunctionDefinition__NameAssignment_1 : ( ruleALSID ) ; | ||
26691 | public final void rule__ALSFunctionDefinition__NameAssignment_1() throws RecognitionException { | ||
26692 | |||
26693 | int stackSize = keepStackSize(); | ||
26694 | |||
26695 | try { | ||
26696 | // InternalAlloyLanguage.g:9498:1: ( ( ruleALSID ) ) | ||
26697 | // InternalAlloyLanguage.g:9499:1: ( ruleALSID ) | ||
26698 | { | ||
26699 | // InternalAlloyLanguage.g:9499:1: ( ruleALSID ) | ||
26700 | // InternalAlloyLanguage.g:9500:1: ruleALSID | ||
26701 | { | ||
26702 | if ( state.backtracking==0 ) { | ||
26703 | before(grammarAccess.getALSFunctionDefinitionAccess().getNameALSIDParserRuleCall_1_0()); | ||
26704 | } | ||
26705 | pushFollow(FOLLOW_2); | ||
26706 | ruleALSID(); | ||
26707 | |||
26708 | state._fsp--; | ||
26709 | if (state.failed) return ; | ||
26710 | if ( state.backtracking==0 ) { | ||
26711 | after(grammarAccess.getALSFunctionDefinitionAccess().getNameALSIDParserRuleCall_1_0()); | ||
26712 | } | ||
26713 | |||
26714 | } | ||
26715 | |||
26716 | |||
26717 | } | ||
26718 | |||
26719 | } | ||
26720 | catch (RecognitionException re) { | ||
26721 | reportError(re); | ||
26722 | recover(input,re); | ||
26723 | } | ||
26724 | finally { | ||
26725 | |||
26726 | restoreStackSize(stackSize); | ||
26727 | |||
26728 | } | ||
26729 | return ; | ||
26730 | } | ||
26731 | // $ANTLR end "rule__ALSFunctionDefinition__NameAssignment_1" | ||
26732 | |||
26733 | |||
26734 | // $ANTLR start "rule__ALSFunctionDefinition__VariablesAssignment_3" | ||
26735 | // InternalAlloyLanguage.g:9509:1: rule__ALSFunctionDefinition__VariablesAssignment_3 : ( ruleALSVariableDeclaration ) ; | ||
26736 | public final void rule__ALSFunctionDefinition__VariablesAssignment_3() throws RecognitionException { | ||
26737 | |||
26738 | int stackSize = keepStackSize(); | ||
26739 | |||
26740 | try { | ||
26741 | // InternalAlloyLanguage.g:9513:1: ( ( ruleALSVariableDeclaration ) ) | ||
26742 | // InternalAlloyLanguage.g:9514:1: ( ruleALSVariableDeclaration ) | ||
26743 | { | ||
26744 | // InternalAlloyLanguage.g:9514:1: ( ruleALSVariableDeclaration ) | ||
26745 | // InternalAlloyLanguage.g:9515:1: ruleALSVariableDeclaration | ||
26746 | { | ||
26747 | if ( state.backtracking==0 ) { | ||
26748 | before(grammarAccess.getALSFunctionDefinitionAccess().getVariablesALSVariableDeclarationParserRuleCall_3_0()); | ||
26749 | } | ||
26750 | pushFollow(FOLLOW_2); | ||
26751 | ruleALSVariableDeclaration(); | ||
26752 | |||
26753 | state._fsp--; | ||
26754 | if (state.failed) return ; | ||
26755 | if ( state.backtracking==0 ) { | ||
26756 | after(grammarAccess.getALSFunctionDefinitionAccess().getVariablesALSVariableDeclarationParserRuleCall_3_0()); | ||
26757 | } | ||
26758 | |||
26759 | } | ||
26760 | |||
26761 | |||
26762 | } | ||
26763 | |||
26764 | } | ||
26765 | catch (RecognitionException re) { | ||
26766 | reportError(re); | ||
26767 | recover(input,re); | ||
26768 | } | ||
26769 | finally { | ||
26770 | |||
26771 | restoreStackSize(stackSize); | ||
26772 | |||
26773 | } | ||
26774 | return ; | ||
26775 | } | ||
26776 | // $ANTLR end "rule__ALSFunctionDefinition__VariablesAssignment_3" | ||
26777 | |||
26778 | |||
26779 | // $ANTLR start "rule__ALSFunctionDefinition__VariablesAssignment_4_1" | ||
26780 | // InternalAlloyLanguage.g:9524:1: rule__ALSFunctionDefinition__VariablesAssignment_4_1 : ( ruleALSVariableDeclaration ) ; | ||
26781 | public final void rule__ALSFunctionDefinition__VariablesAssignment_4_1() throws RecognitionException { | ||
26782 | |||
26783 | int stackSize = keepStackSize(); | ||
26784 | |||
26785 | try { | ||
26786 | // InternalAlloyLanguage.g:9528:1: ( ( ruleALSVariableDeclaration ) ) | ||
26787 | // InternalAlloyLanguage.g:9529:1: ( ruleALSVariableDeclaration ) | ||
26788 | { | ||
26789 | // InternalAlloyLanguage.g:9529:1: ( ruleALSVariableDeclaration ) | ||
26790 | // InternalAlloyLanguage.g:9530:1: ruleALSVariableDeclaration | ||
26791 | { | ||
26792 | if ( state.backtracking==0 ) { | ||
26793 | before(grammarAccess.getALSFunctionDefinitionAccess().getVariablesALSVariableDeclarationParserRuleCall_4_1_0()); | ||
26794 | } | ||
26795 | pushFollow(FOLLOW_2); | ||
26796 | ruleALSVariableDeclaration(); | ||
26797 | |||
26798 | state._fsp--; | ||
26799 | if (state.failed) return ; | ||
26800 | if ( state.backtracking==0 ) { | ||
26801 | after(grammarAccess.getALSFunctionDefinitionAccess().getVariablesALSVariableDeclarationParserRuleCall_4_1_0()); | ||
26802 | } | ||
26803 | |||
26804 | } | ||
26805 | |||
26806 | |||
26807 | } | ||
26808 | |||
26809 | } | ||
26810 | catch (RecognitionException re) { | ||
26811 | reportError(re); | ||
26812 | recover(input,re); | ||
26813 | } | ||
26814 | finally { | ||
26815 | |||
26816 | restoreStackSize(stackSize); | ||
26817 | |||
26818 | } | ||
26819 | return ; | ||
26820 | } | ||
26821 | // $ANTLR end "rule__ALSFunctionDefinition__VariablesAssignment_4_1" | ||
26822 | |||
26823 | |||
26824 | // $ANTLR start "rule__ALSFunctionDefinition__TypeAssignment_7" | ||
26825 | // InternalAlloyLanguage.g:9539:1: rule__ALSFunctionDefinition__TypeAssignment_7 : ( ruleALSTerm ) ; | ||
26826 | public final void rule__ALSFunctionDefinition__TypeAssignment_7() throws RecognitionException { | ||
26827 | |||
26828 | int stackSize = keepStackSize(); | ||
26829 | |||
26830 | try { | ||
26831 | // InternalAlloyLanguage.g:9543:1: ( ( ruleALSTerm ) ) | ||
26832 | // InternalAlloyLanguage.g:9544:1: ( ruleALSTerm ) | ||
26833 | { | ||
26834 | // InternalAlloyLanguage.g:9544:1: ( ruleALSTerm ) | ||
26835 | // InternalAlloyLanguage.g:9545:1: ruleALSTerm | ||
26836 | { | ||
26837 | if ( state.backtracking==0 ) { | ||
26838 | before(grammarAccess.getALSFunctionDefinitionAccess().getTypeALSTermParserRuleCall_7_0()); | ||
26839 | } | ||
26840 | pushFollow(FOLLOW_2); | ||
26841 | ruleALSTerm(); | ||
26842 | |||
26843 | state._fsp--; | ||
26844 | if (state.failed) return ; | ||
26845 | if ( state.backtracking==0 ) { | ||
26846 | after(grammarAccess.getALSFunctionDefinitionAccess().getTypeALSTermParserRuleCall_7_0()); | ||
26847 | } | ||
26848 | |||
26849 | } | ||
26850 | |||
26851 | |||
26852 | } | ||
26853 | |||
26854 | } | ||
26855 | catch (RecognitionException re) { | ||
26856 | reportError(re); | ||
26857 | recover(input,re); | ||
26858 | } | ||
26859 | finally { | ||
26860 | |||
26861 | restoreStackSize(stackSize); | ||
26862 | |||
26863 | } | ||
26864 | return ; | ||
26865 | } | ||
26866 | // $ANTLR end "rule__ALSFunctionDefinition__TypeAssignment_7" | ||
26867 | |||
26868 | |||
26869 | // $ANTLR start "rule__ALSFunctionDefinition__ValueAssignment_9" | ||
26870 | // InternalAlloyLanguage.g:9554:1: rule__ALSFunctionDefinition__ValueAssignment_9 : ( ruleALSTerm ) ; | ||
26871 | public final void rule__ALSFunctionDefinition__ValueAssignment_9() throws RecognitionException { | ||
26872 | |||
26873 | int stackSize = keepStackSize(); | ||
26874 | |||
26875 | try { | ||
26876 | // InternalAlloyLanguage.g:9558:1: ( ( ruleALSTerm ) ) | ||
26877 | // InternalAlloyLanguage.g:9559:1: ( ruleALSTerm ) | ||
26878 | { | ||
26879 | // InternalAlloyLanguage.g:9559:1: ( ruleALSTerm ) | ||
26880 | // InternalAlloyLanguage.g:9560:1: ruleALSTerm | ||
26881 | { | ||
26882 | if ( state.backtracking==0 ) { | ||
26883 | before(grammarAccess.getALSFunctionDefinitionAccess().getValueALSTermParserRuleCall_9_0()); | ||
26884 | } | ||
26885 | pushFollow(FOLLOW_2); | ||
26886 | ruleALSTerm(); | ||
26887 | |||
26888 | state._fsp--; | ||
26889 | if (state.failed) return ; | ||
26890 | if ( state.backtracking==0 ) { | ||
26891 | after(grammarAccess.getALSFunctionDefinitionAccess().getValueALSTermParserRuleCall_9_0()); | ||
26892 | } | ||
26893 | |||
26894 | } | ||
26895 | |||
26896 | |||
26897 | } | ||
26898 | |||
26899 | } | ||
26900 | catch (RecognitionException re) { | ||
26901 | reportError(re); | ||
26902 | recover(input,re); | ||
26903 | } | ||
26904 | finally { | ||
26905 | |||
26906 | restoreStackSize(stackSize); | ||
26907 | |||
26908 | } | ||
26909 | return ; | ||
26910 | } | ||
26911 | // $ANTLR end "rule__ALSFunctionDefinition__ValueAssignment_9" | ||
26912 | |||
26913 | |||
26914 | // $ANTLR start "rule__ALSRelationDefinition__NameAssignment_1" | ||
26915 | // InternalAlloyLanguage.g:9569:1: rule__ALSRelationDefinition__NameAssignment_1 : ( ruleALSID ) ; | ||
26916 | public final void rule__ALSRelationDefinition__NameAssignment_1() throws RecognitionException { | ||
26917 | |||
26918 | int stackSize = keepStackSize(); | ||
26919 | |||
26920 | try { | ||
26921 | // InternalAlloyLanguage.g:9573:1: ( ( ruleALSID ) ) | ||
26922 | // InternalAlloyLanguage.g:9574:1: ( ruleALSID ) | ||
26923 | { | ||
26924 | // InternalAlloyLanguage.g:9574:1: ( ruleALSID ) | ||
26925 | // InternalAlloyLanguage.g:9575:1: ruleALSID | ||
26926 | { | ||
26927 | if ( state.backtracking==0 ) { | ||
26928 | before(grammarAccess.getALSRelationDefinitionAccess().getNameALSIDParserRuleCall_1_0()); | ||
26929 | } | ||
26930 | pushFollow(FOLLOW_2); | ||
26931 | ruleALSID(); | ||
26932 | |||
26933 | state._fsp--; | ||
26934 | if (state.failed) return ; | ||
26935 | if ( state.backtracking==0 ) { | ||
26936 | after(grammarAccess.getALSRelationDefinitionAccess().getNameALSIDParserRuleCall_1_0()); | ||
26937 | } | ||
26938 | |||
26939 | } | ||
26940 | |||
26941 | |||
26942 | } | ||
26943 | |||
26944 | } | ||
26945 | catch (RecognitionException re) { | ||
26946 | reportError(re); | ||
26947 | recover(input,re); | ||
26948 | } | ||
26949 | finally { | ||
26950 | |||
26951 | restoreStackSize(stackSize); | ||
26952 | |||
26953 | } | ||
26954 | return ; | ||
26955 | } | ||
26956 | // $ANTLR end "rule__ALSRelationDefinition__NameAssignment_1" | ||
26957 | |||
26958 | |||
26959 | // $ANTLR start "rule__ALSRelationDefinition__VariablesAssignment_3" | ||
26960 | // InternalAlloyLanguage.g:9584:1: rule__ALSRelationDefinition__VariablesAssignment_3 : ( ruleALSVariableDeclaration ) ; | ||
26961 | public final void rule__ALSRelationDefinition__VariablesAssignment_3() throws RecognitionException { | ||
26962 | |||
26963 | int stackSize = keepStackSize(); | ||
26964 | |||
26965 | try { | ||
26966 | // InternalAlloyLanguage.g:9588:1: ( ( ruleALSVariableDeclaration ) ) | ||
26967 | // InternalAlloyLanguage.g:9589:1: ( ruleALSVariableDeclaration ) | ||
26968 | { | ||
26969 | // InternalAlloyLanguage.g:9589:1: ( ruleALSVariableDeclaration ) | ||
26970 | // InternalAlloyLanguage.g:9590:1: ruleALSVariableDeclaration | ||
26971 | { | ||
26972 | if ( state.backtracking==0 ) { | ||
26973 | before(grammarAccess.getALSRelationDefinitionAccess().getVariablesALSVariableDeclarationParserRuleCall_3_0()); | ||
26974 | } | ||
26975 | pushFollow(FOLLOW_2); | ||
26976 | ruleALSVariableDeclaration(); | ||
26977 | |||
26978 | state._fsp--; | ||
26979 | if (state.failed) return ; | ||
26980 | if ( state.backtracking==0 ) { | ||
26981 | after(grammarAccess.getALSRelationDefinitionAccess().getVariablesALSVariableDeclarationParserRuleCall_3_0()); | ||
26982 | } | ||
26983 | |||
26984 | } | ||
26985 | |||
26986 | |||
26987 | } | ||
26988 | |||
26989 | } | ||
26990 | catch (RecognitionException re) { | ||
26991 | reportError(re); | ||
26992 | recover(input,re); | ||
26993 | } | ||
26994 | finally { | ||
26995 | |||
26996 | restoreStackSize(stackSize); | ||
26997 | |||
26998 | } | ||
26999 | return ; | ||
27000 | } | ||
27001 | // $ANTLR end "rule__ALSRelationDefinition__VariablesAssignment_3" | ||
27002 | |||
27003 | |||
27004 | // $ANTLR start "rule__ALSRelationDefinition__VariablesAssignment_4_1" | ||
27005 | // InternalAlloyLanguage.g:9599:1: rule__ALSRelationDefinition__VariablesAssignment_4_1 : ( ruleALSVariableDeclaration ) ; | ||
27006 | public final void rule__ALSRelationDefinition__VariablesAssignment_4_1() throws RecognitionException { | ||
27007 | |||
27008 | int stackSize = keepStackSize(); | ||
27009 | |||
27010 | try { | ||
27011 | // InternalAlloyLanguage.g:9603:1: ( ( ruleALSVariableDeclaration ) ) | ||
27012 | // InternalAlloyLanguage.g:9604:1: ( ruleALSVariableDeclaration ) | ||
27013 | { | ||
27014 | // InternalAlloyLanguage.g:9604:1: ( ruleALSVariableDeclaration ) | ||
27015 | // InternalAlloyLanguage.g:9605:1: ruleALSVariableDeclaration | ||
27016 | { | ||
27017 | if ( state.backtracking==0 ) { | ||
27018 | before(grammarAccess.getALSRelationDefinitionAccess().getVariablesALSVariableDeclarationParserRuleCall_4_1_0()); | ||
27019 | } | ||
27020 | pushFollow(FOLLOW_2); | ||
27021 | ruleALSVariableDeclaration(); | ||
27022 | |||
27023 | state._fsp--; | ||
27024 | if (state.failed) return ; | ||
27025 | if ( state.backtracking==0 ) { | ||
27026 | after(grammarAccess.getALSRelationDefinitionAccess().getVariablesALSVariableDeclarationParserRuleCall_4_1_0()); | ||
27027 | } | ||
27028 | |||
27029 | } | ||
27030 | |||
27031 | |||
27032 | } | ||
27033 | |||
27034 | } | ||
27035 | catch (RecognitionException re) { | ||
27036 | reportError(re); | ||
27037 | recover(input,re); | ||
27038 | } | ||
27039 | finally { | ||
27040 | |||
27041 | restoreStackSize(stackSize); | ||
27042 | |||
27043 | } | ||
27044 | return ; | ||
27045 | } | ||
27046 | // $ANTLR end "rule__ALSRelationDefinition__VariablesAssignment_4_1" | ||
27047 | |||
27048 | |||
27049 | // $ANTLR start "rule__ALSRelationDefinition__ValueAssignment_7" | ||
27050 | // InternalAlloyLanguage.g:9614:1: rule__ALSRelationDefinition__ValueAssignment_7 : ( ruleALSTerm ) ; | ||
27051 | public final void rule__ALSRelationDefinition__ValueAssignment_7() throws RecognitionException { | ||
27052 | |||
27053 | int stackSize = keepStackSize(); | ||
27054 | |||
27055 | try { | ||
27056 | // InternalAlloyLanguage.g:9618:1: ( ( ruleALSTerm ) ) | ||
27057 | // InternalAlloyLanguage.g:9619:1: ( ruleALSTerm ) | ||
27058 | { | ||
27059 | // InternalAlloyLanguage.g:9619:1: ( ruleALSTerm ) | ||
27060 | // InternalAlloyLanguage.g:9620:1: ruleALSTerm | ||
27061 | { | ||
27062 | if ( state.backtracking==0 ) { | ||
27063 | before(grammarAccess.getALSRelationDefinitionAccess().getValueALSTermParserRuleCall_7_0()); | ||
27064 | } | ||
27065 | pushFollow(FOLLOW_2); | ||
27066 | ruleALSTerm(); | ||
27067 | |||
27068 | state._fsp--; | ||
27069 | if (state.failed) return ; | ||
27070 | if ( state.backtracking==0 ) { | ||
27071 | after(grammarAccess.getALSRelationDefinitionAccess().getValueALSTermParserRuleCall_7_0()); | ||
27072 | } | ||
27073 | |||
27074 | } | ||
27075 | |||
27076 | |||
27077 | } | ||
27078 | |||
27079 | } | ||
27080 | catch (RecognitionException re) { | ||
27081 | reportError(re); | ||
27082 | recover(input,re); | ||
27083 | } | ||
27084 | finally { | ||
27085 | |||
27086 | restoreStackSize(stackSize); | ||
27087 | |||
27088 | } | ||
27089 | return ; | ||
27090 | } | ||
27091 | // $ANTLR end "rule__ALSRelationDefinition__ValueAssignment_7" | ||
27092 | |||
27093 | |||
27094 | // $ANTLR start "rule__ALSFactDeclaration__NameAssignment_2" | ||
27095 | // InternalAlloyLanguage.g:9629:1: rule__ALSFactDeclaration__NameAssignment_2 : ( ruleALSID ) ; | ||
27096 | public final void rule__ALSFactDeclaration__NameAssignment_2() throws RecognitionException { | ||
27097 | |||
27098 | int stackSize = keepStackSize(); | ||
27099 | |||
27100 | try { | ||
27101 | // InternalAlloyLanguage.g:9633:1: ( ( ruleALSID ) ) | ||
27102 | // InternalAlloyLanguage.g:9634:1: ( ruleALSID ) | ||
27103 | { | ||
27104 | // InternalAlloyLanguage.g:9634:1: ( ruleALSID ) | ||
27105 | // InternalAlloyLanguage.g:9635:1: ruleALSID | ||
27106 | { | ||
27107 | if ( state.backtracking==0 ) { | ||
27108 | before(grammarAccess.getALSFactDeclarationAccess().getNameALSIDParserRuleCall_2_0()); | ||
27109 | } | ||
27110 | pushFollow(FOLLOW_2); | ||
27111 | ruleALSID(); | ||
27112 | |||
27113 | state._fsp--; | ||
27114 | if (state.failed) return ; | ||
27115 | if ( state.backtracking==0 ) { | ||
27116 | after(grammarAccess.getALSFactDeclarationAccess().getNameALSIDParserRuleCall_2_0()); | ||
27117 | } | ||
27118 | |||
27119 | } | ||
27120 | |||
27121 | |||
27122 | } | ||
27123 | |||
27124 | } | ||
27125 | catch (RecognitionException re) { | ||
27126 | reportError(re); | ||
27127 | recover(input,re); | ||
27128 | } | ||
27129 | finally { | ||
27130 | |||
27131 | restoreStackSize(stackSize); | ||
27132 | |||
27133 | } | ||
27134 | return ; | ||
27135 | } | ||
27136 | // $ANTLR end "rule__ALSFactDeclaration__NameAssignment_2" | ||
27137 | |||
27138 | |||
27139 | // $ANTLR start "rule__ALSFactDeclaration__TermAssignment_4" | ||
27140 | // InternalAlloyLanguage.g:9644:1: rule__ALSFactDeclaration__TermAssignment_4 : ( ruleALSTerm ) ; | ||
27141 | public final void rule__ALSFactDeclaration__TermAssignment_4() throws RecognitionException { | ||
27142 | |||
27143 | int stackSize = keepStackSize(); | ||
27144 | |||
27145 | try { | ||
27146 | // InternalAlloyLanguage.g:9648:1: ( ( ruleALSTerm ) ) | ||
27147 | // InternalAlloyLanguage.g:9649:1: ( ruleALSTerm ) | ||
27148 | { | ||
27149 | // InternalAlloyLanguage.g:9649:1: ( ruleALSTerm ) | ||
27150 | // InternalAlloyLanguage.g:9650:1: ruleALSTerm | ||
27151 | { | ||
27152 | if ( state.backtracking==0 ) { | ||
27153 | before(grammarAccess.getALSFactDeclarationAccess().getTermALSTermParserRuleCall_4_0()); | ||
27154 | } | ||
27155 | pushFollow(FOLLOW_2); | ||
27156 | ruleALSTerm(); | ||
27157 | |||
27158 | state._fsp--; | ||
27159 | if (state.failed) return ; | ||
27160 | if ( state.backtracking==0 ) { | ||
27161 | after(grammarAccess.getALSFactDeclarationAccess().getTermALSTermParserRuleCall_4_0()); | ||
27162 | } | ||
27163 | |||
27164 | } | ||
27165 | |||
27166 | |||
27167 | } | ||
27168 | |||
27169 | } | ||
27170 | catch (RecognitionException re) { | ||
27171 | reportError(re); | ||
27172 | recover(input,re); | ||
27173 | } | ||
27174 | finally { | ||
27175 | |||
27176 | restoreStackSize(stackSize); | ||
27177 | |||
27178 | } | ||
27179 | return ; | ||
27180 | } | ||
27181 | // $ANTLR end "rule__ALSFactDeclaration__TermAssignment_4" | ||
27182 | |||
27183 | |||
27184 | // $ANTLR start "rule__ALSQuantified__TypeAssignment_0_1" | ||
27185 | // InternalAlloyLanguage.g:9659:1: rule__ALSQuantified__TypeAssignment_0_1 : ( ruleALSMultiplicity ) ; | ||
27186 | public final void rule__ALSQuantified__TypeAssignment_0_1() throws RecognitionException { | ||
27187 | |||
27188 | int stackSize = keepStackSize(); | ||
27189 | |||
27190 | try { | ||
27191 | // InternalAlloyLanguage.g:9663:1: ( ( ruleALSMultiplicity ) ) | ||
27192 | // InternalAlloyLanguage.g:9664:1: ( ruleALSMultiplicity ) | ||
27193 | { | ||
27194 | // InternalAlloyLanguage.g:9664:1: ( ruleALSMultiplicity ) | ||
27195 | // InternalAlloyLanguage.g:9665:1: ruleALSMultiplicity | ||
27196 | { | ||
27197 | if ( state.backtracking==0 ) { | ||
27198 | before(grammarAccess.getALSQuantifiedAccess().getTypeALSMultiplicityEnumRuleCall_0_1_0()); | ||
27199 | } | ||
27200 | pushFollow(FOLLOW_2); | ||
27201 | ruleALSMultiplicity(); | ||
27202 | |||
27203 | state._fsp--; | ||
27204 | if (state.failed) return ; | ||
27205 | if ( state.backtracking==0 ) { | ||
27206 | after(grammarAccess.getALSQuantifiedAccess().getTypeALSMultiplicityEnumRuleCall_0_1_0()); | ||
27207 | } | ||
27208 | |||
27209 | } | ||
27210 | |||
27211 | |||
27212 | } | ||
27213 | |||
27214 | } | ||
27215 | catch (RecognitionException re) { | ||
27216 | reportError(re); | ||
27217 | recover(input,re); | ||
27218 | } | ||
27219 | finally { | ||
27220 | |||
27221 | restoreStackSize(stackSize); | ||
27222 | |||
27223 | } | ||
27224 | return ; | ||
27225 | } | ||
27226 | // $ANTLR end "rule__ALSQuantified__TypeAssignment_0_1" | ||
27227 | |||
27228 | |||
27229 | // $ANTLR start "rule__ALSQuantified__DisjAssignment_0_2" | ||
27230 | // InternalAlloyLanguage.g:9674:1: rule__ALSQuantified__DisjAssignment_0_2 : ( ( 'disj' ) ) ; | ||
27231 | public final void rule__ALSQuantified__DisjAssignment_0_2() throws RecognitionException { | ||
27232 | |||
27233 | int stackSize = keepStackSize(); | ||
27234 | |||
27235 | try { | ||
27236 | // InternalAlloyLanguage.g:9678:1: ( ( ( 'disj' ) ) ) | ||
27237 | // InternalAlloyLanguage.g:9679:1: ( ( 'disj' ) ) | ||
27238 | { | ||
27239 | // InternalAlloyLanguage.g:9679:1: ( ( 'disj' ) ) | ||
27240 | // InternalAlloyLanguage.g:9680:1: ( 'disj' ) | ||
27241 | { | ||
27242 | if ( state.backtracking==0 ) { | ||
27243 | before(grammarAccess.getALSQuantifiedAccess().getDisjDisjKeyword_0_2_0()); | ||
27244 | } | ||
27245 | // InternalAlloyLanguage.g:9681:1: ( 'disj' ) | ||
27246 | // InternalAlloyLanguage.g:9682:1: 'disj' | ||
27247 | { | ||
27248 | if ( state.backtracking==0 ) { | ||
27249 | before(grammarAccess.getALSQuantifiedAccess().getDisjDisjKeyword_0_2_0()); | ||
27250 | } | ||
27251 | match(input,76,FOLLOW_2); if (state.failed) return ; | ||
27252 | if ( state.backtracking==0 ) { | ||
27253 | after(grammarAccess.getALSQuantifiedAccess().getDisjDisjKeyword_0_2_0()); | ||
27254 | } | ||
27255 | |||
27256 | } | ||
27257 | |||
27258 | if ( state.backtracking==0 ) { | ||
27259 | after(grammarAccess.getALSQuantifiedAccess().getDisjDisjKeyword_0_2_0()); | ||
27260 | } | ||
27261 | |||
27262 | } | ||
27263 | |||
27264 | |||
27265 | } | ||
27266 | |||
27267 | } | ||
27268 | catch (RecognitionException re) { | ||
27269 | reportError(re); | ||
27270 | recover(input,re); | ||
27271 | } | ||
27272 | finally { | ||
27273 | |||
27274 | restoreStackSize(stackSize); | ||
27275 | |||
27276 | } | ||
27277 | return ; | ||
27278 | } | ||
27279 | // $ANTLR end "rule__ALSQuantified__DisjAssignment_0_2" | ||
27280 | |||
27281 | |||
27282 | // $ANTLR start "rule__ALSQuantified__VariablesAssignment_0_3" | ||
27283 | // InternalAlloyLanguage.g:9697:1: rule__ALSQuantified__VariablesAssignment_0_3 : ( ruleALSVariableDeclaration ) ; | ||
27284 | public final void rule__ALSQuantified__VariablesAssignment_0_3() throws RecognitionException { | ||
27285 | |||
27286 | int stackSize = keepStackSize(); | ||
27287 | |||
27288 | try { | ||
27289 | // InternalAlloyLanguage.g:9701:1: ( ( ruleALSVariableDeclaration ) ) | ||
27290 | // InternalAlloyLanguage.g:9702:1: ( ruleALSVariableDeclaration ) | ||
27291 | { | ||
27292 | // InternalAlloyLanguage.g:9702:1: ( ruleALSVariableDeclaration ) | ||
27293 | // InternalAlloyLanguage.g:9703:1: ruleALSVariableDeclaration | ||
27294 | { | ||
27295 | if ( state.backtracking==0 ) { | ||
27296 | before(grammarAccess.getALSQuantifiedAccess().getVariablesALSVariableDeclarationParserRuleCall_0_3_0()); | ||
27297 | } | ||
27298 | pushFollow(FOLLOW_2); | ||
27299 | ruleALSVariableDeclaration(); | ||
27300 | |||
27301 | state._fsp--; | ||
27302 | if (state.failed) return ; | ||
27303 | if ( state.backtracking==0 ) { | ||
27304 | after(grammarAccess.getALSQuantifiedAccess().getVariablesALSVariableDeclarationParserRuleCall_0_3_0()); | ||
27305 | } | ||
27306 | |||
27307 | } | ||
27308 | |||
27309 | |||
27310 | } | ||
27311 | |||
27312 | } | ||
27313 | catch (RecognitionException re) { | ||
27314 | reportError(re); | ||
27315 | recover(input,re); | ||
27316 | } | ||
27317 | finally { | ||
27318 | |||
27319 | restoreStackSize(stackSize); | ||
27320 | |||
27321 | } | ||
27322 | return ; | ||
27323 | } | ||
27324 | // $ANTLR end "rule__ALSQuantified__VariablesAssignment_0_3" | ||
27325 | |||
27326 | |||
27327 | // $ANTLR start "rule__ALSQuantified__VariablesAssignment_0_4_1" | ||
27328 | // InternalAlloyLanguage.g:9712:1: rule__ALSQuantified__VariablesAssignment_0_4_1 : ( ruleALSVariableDeclaration ) ; | ||
27329 | public final void rule__ALSQuantified__VariablesAssignment_0_4_1() throws RecognitionException { | ||
27330 | |||
27331 | int stackSize = keepStackSize(); | ||
27332 | |||
27333 | try { | ||
27334 | // InternalAlloyLanguage.g:9716:1: ( ( ruleALSVariableDeclaration ) ) | ||
27335 | // InternalAlloyLanguage.g:9717:1: ( ruleALSVariableDeclaration ) | ||
27336 | { | ||
27337 | // InternalAlloyLanguage.g:9717:1: ( ruleALSVariableDeclaration ) | ||
27338 | // InternalAlloyLanguage.g:9718:1: ruleALSVariableDeclaration | ||
27339 | { | ||
27340 | if ( state.backtracking==0 ) { | ||
27341 | before(grammarAccess.getALSQuantifiedAccess().getVariablesALSVariableDeclarationParserRuleCall_0_4_1_0()); | ||
27342 | } | ||
27343 | pushFollow(FOLLOW_2); | ||
27344 | ruleALSVariableDeclaration(); | ||
27345 | |||
27346 | state._fsp--; | ||
27347 | if (state.failed) return ; | ||
27348 | if ( state.backtracking==0 ) { | ||
27349 | after(grammarAccess.getALSQuantifiedAccess().getVariablesALSVariableDeclarationParserRuleCall_0_4_1_0()); | ||
27350 | } | ||
27351 | |||
27352 | } | ||
27353 | |||
27354 | |||
27355 | } | ||
27356 | |||
27357 | } | ||
27358 | catch (RecognitionException re) { | ||
27359 | reportError(re); | ||
27360 | recover(input,re); | ||
27361 | } | ||
27362 | finally { | ||
27363 | |||
27364 | restoreStackSize(stackSize); | ||
27365 | |||
27366 | } | ||
27367 | return ; | ||
27368 | } | ||
27369 | // $ANTLR end "rule__ALSQuantified__VariablesAssignment_0_4_1" | ||
27370 | |||
27371 | |||
27372 | // $ANTLR start "rule__ALSQuantified__ExpressionAssignment_0_6" | ||
27373 | // InternalAlloyLanguage.g:9727:1: rule__ALSQuantified__ExpressionAssignment_0_6 : ( ruleALSTerm ) ; | ||
27374 | public final void rule__ALSQuantified__ExpressionAssignment_0_6() throws RecognitionException { | ||
27375 | |||
27376 | int stackSize = keepStackSize(); | ||
27377 | |||
27378 | try { | ||
27379 | // InternalAlloyLanguage.g:9731:1: ( ( ruleALSTerm ) ) | ||
27380 | // InternalAlloyLanguage.g:9732:1: ( ruleALSTerm ) | ||
27381 | { | ||
27382 | // InternalAlloyLanguage.g:9732:1: ( ruleALSTerm ) | ||
27383 | // InternalAlloyLanguage.g:9733:1: ruleALSTerm | ||
27384 | { | ||
27385 | if ( state.backtracking==0 ) { | ||
27386 | before(grammarAccess.getALSQuantifiedAccess().getExpressionALSTermParserRuleCall_0_6_0()); | ||
27387 | } | ||
27388 | pushFollow(FOLLOW_2); | ||
27389 | ruleALSTerm(); | ||
27390 | |||
27391 | state._fsp--; | ||
27392 | if (state.failed) return ; | ||
27393 | if ( state.backtracking==0 ) { | ||
27394 | after(grammarAccess.getALSQuantifiedAccess().getExpressionALSTermParserRuleCall_0_6_0()); | ||
27395 | } | ||
27396 | |||
27397 | } | ||
27398 | |||
27399 | |||
27400 | } | ||
27401 | |||
27402 | } | ||
27403 | catch (RecognitionException re) { | ||
27404 | reportError(re); | ||
27405 | recover(input,re); | ||
27406 | } | ||
27407 | finally { | ||
27408 | |||
27409 | restoreStackSize(stackSize); | ||
27410 | |||
27411 | } | ||
27412 | return ; | ||
27413 | } | ||
27414 | // $ANTLR end "rule__ALSQuantified__ExpressionAssignment_0_6" | ||
27415 | |||
27416 | |||
27417 | // $ANTLR start "rule__ALSOr__RightOperandAssignment_1_2" | ||
27418 | // InternalAlloyLanguage.g:9742:1: rule__ALSOr__RightOperandAssignment_1_2 : ( ruleALSIff ) ; | ||
27419 | public final void rule__ALSOr__RightOperandAssignment_1_2() throws RecognitionException { | ||
27420 | |||
27421 | int stackSize = keepStackSize(); | ||
27422 | |||
27423 | try { | ||
27424 | // InternalAlloyLanguage.g:9746:1: ( ( ruleALSIff ) ) | ||
27425 | // InternalAlloyLanguage.g:9747:1: ( ruleALSIff ) | ||
27426 | { | ||
27427 | // InternalAlloyLanguage.g:9747:1: ( ruleALSIff ) | ||
27428 | // InternalAlloyLanguage.g:9748:1: ruleALSIff | ||
27429 | { | ||
27430 | if ( state.backtracking==0 ) { | ||
27431 | before(grammarAccess.getALSOrAccess().getRightOperandALSIffParserRuleCall_1_2_0()); | ||
27432 | } | ||
27433 | pushFollow(FOLLOW_2); | ||
27434 | ruleALSIff(); | ||
27435 | |||
27436 | state._fsp--; | ||
27437 | if (state.failed) return ; | ||
27438 | if ( state.backtracking==0 ) { | ||
27439 | after(grammarAccess.getALSOrAccess().getRightOperandALSIffParserRuleCall_1_2_0()); | ||
27440 | } | ||
27441 | |||
27442 | } | ||
27443 | |||
27444 | |||
27445 | } | ||
27446 | |||
27447 | } | ||
27448 | catch (RecognitionException re) { | ||
27449 | reportError(re); | ||
27450 | recover(input,re); | ||
27451 | } | ||
27452 | finally { | ||
27453 | |||
27454 | restoreStackSize(stackSize); | ||
27455 | |||
27456 | } | ||
27457 | return ; | ||
27458 | } | ||
27459 | // $ANTLR end "rule__ALSOr__RightOperandAssignment_1_2" | ||
27460 | |||
27461 | |||
27462 | // $ANTLR start "rule__ALSIff__RightOperandAssignment_1_2" | ||
27463 | // InternalAlloyLanguage.g:9757:1: rule__ALSIff__RightOperandAssignment_1_2 : ( ruleALSImpl ) ; | ||
27464 | public final void rule__ALSIff__RightOperandAssignment_1_2() throws RecognitionException { | ||
27465 | |||
27466 | int stackSize = keepStackSize(); | ||
27467 | |||
27468 | try { | ||
27469 | // InternalAlloyLanguage.g:9761:1: ( ( ruleALSImpl ) ) | ||
27470 | // InternalAlloyLanguage.g:9762:1: ( ruleALSImpl ) | ||
27471 | { | ||
27472 | // InternalAlloyLanguage.g:9762:1: ( ruleALSImpl ) | ||
27473 | // InternalAlloyLanguage.g:9763:1: ruleALSImpl | ||
27474 | { | ||
27475 | if ( state.backtracking==0 ) { | ||
27476 | before(grammarAccess.getALSIffAccess().getRightOperandALSImplParserRuleCall_1_2_0()); | ||
27477 | } | ||
27478 | pushFollow(FOLLOW_2); | ||
27479 | ruleALSImpl(); | ||
27480 | |||
27481 | state._fsp--; | ||
27482 | if (state.failed) return ; | ||
27483 | if ( state.backtracking==0 ) { | ||
27484 | after(grammarAccess.getALSIffAccess().getRightOperandALSImplParserRuleCall_1_2_0()); | ||
27485 | } | ||
27486 | |||
27487 | } | ||
27488 | |||
27489 | |||
27490 | } | ||
27491 | |||
27492 | } | ||
27493 | catch (RecognitionException re) { | ||
27494 | reportError(re); | ||
27495 | recover(input,re); | ||
27496 | } | ||
27497 | finally { | ||
27498 | |||
27499 | restoreStackSize(stackSize); | ||
27500 | |||
27501 | } | ||
27502 | return ; | ||
27503 | } | ||
27504 | // $ANTLR end "rule__ALSIff__RightOperandAssignment_1_2" | ||
27505 | |||
27506 | |||
27507 | // $ANTLR start "rule__ALSImpl__RightOperandAssignment_1_2" | ||
27508 | // InternalAlloyLanguage.g:9772:1: rule__ALSImpl__RightOperandAssignment_1_2 : ( ruleALSAnd ) ; | ||
27509 | public final void rule__ALSImpl__RightOperandAssignment_1_2() throws RecognitionException { | ||
27510 | |||
27511 | int stackSize = keepStackSize(); | ||
27512 | |||
27513 | try { | ||
27514 | // InternalAlloyLanguage.g:9776:1: ( ( ruleALSAnd ) ) | ||
27515 | // InternalAlloyLanguage.g:9777:1: ( ruleALSAnd ) | ||
27516 | { | ||
27517 | // InternalAlloyLanguage.g:9777:1: ( ruleALSAnd ) | ||
27518 | // InternalAlloyLanguage.g:9778:1: ruleALSAnd | ||
27519 | { | ||
27520 | if ( state.backtracking==0 ) { | ||
27521 | before(grammarAccess.getALSImplAccess().getRightOperandALSAndParserRuleCall_1_2_0()); | ||
27522 | } | ||
27523 | pushFollow(FOLLOW_2); | ||
27524 | ruleALSAnd(); | ||
27525 | |||
27526 | state._fsp--; | ||
27527 | if (state.failed) return ; | ||
27528 | if ( state.backtracking==0 ) { | ||
27529 | after(grammarAccess.getALSImplAccess().getRightOperandALSAndParserRuleCall_1_2_0()); | ||
27530 | } | ||
27531 | |||
27532 | } | ||
27533 | |||
27534 | |||
27535 | } | ||
27536 | |||
27537 | } | ||
27538 | catch (RecognitionException re) { | ||
27539 | reportError(re); | ||
27540 | recover(input,re); | ||
27541 | } | ||
27542 | finally { | ||
27543 | |||
27544 | restoreStackSize(stackSize); | ||
27545 | |||
27546 | } | ||
27547 | return ; | ||
27548 | } | ||
27549 | // $ANTLR end "rule__ALSImpl__RightOperandAssignment_1_2" | ||
27550 | |||
27551 | |||
27552 | // $ANTLR start "rule__ALSImpl__ElseOperandAssignment_1_3_1" | ||
27553 | // InternalAlloyLanguage.g:9787:1: rule__ALSImpl__ElseOperandAssignment_1_3_1 : ( ruleALSAnd ) ; | ||
27554 | public final void rule__ALSImpl__ElseOperandAssignment_1_3_1() throws RecognitionException { | ||
27555 | |||
27556 | int stackSize = keepStackSize(); | ||
27557 | |||
27558 | try { | ||
27559 | // InternalAlloyLanguage.g:9791:1: ( ( ruleALSAnd ) ) | ||
27560 | // InternalAlloyLanguage.g:9792:1: ( ruleALSAnd ) | ||
27561 | { | ||
27562 | // InternalAlloyLanguage.g:9792:1: ( ruleALSAnd ) | ||
27563 | // InternalAlloyLanguage.g:9793:1: ruleALSAnd | ||
27564 | { | ||
27565 | if ( state.backtracking==0 ) { | ||
27566 | before(grammarAccess.getALSImplAccess().getElseOperandALSAndParserRuleCall_1_3_1_0()); | ||
27567 | } | ||
27568 | pushFollow(FOLLOW_2); | ||
27569 | ruleALSAnd(); | ||
27570 | |||
27571 | state._fsp--; | ||
27572 | if (state.failed) return ; | ||
27573 | if ( state.backtracking==0 ) { | ||
27574 | after(grammarAccess.getALSImplAccess().getElseOperandALSAndParserRuleCall_1_3_1_0()); | ||
27575 | } | ||
27576 | |||
27577 | } | ||
27578 | |||
27579 | |||
27580 | } | ||
27581 | |||
27582 | } | ||
27583 | catch (RecognitionException re) { | ||
27584 | reportError(re); | ||
27585 | recover(input,re); | ||
27586 | } | ||
27587 | finally { | ||
27588 | |||
27589 | restoreStackSize(stackSize); | ||
27590 | |||
27591 | } | ||
27592 | return ; | ||
27593 | } | ||
27594 | // $ANTLR end "rule__ALSImpl__ElseOperandAssignment_1_3_1" | ||
27595 | |||
27596 | |||
27597 | // $ANTLR start "rule__ALSAnd__RightOperandAssignment_1_2" | ||
27598 | // InternalAlloyLanguage.g:9802:1: rule__ALSAnd__RightOperandAssignment_1_2 : ( ruleALSComparison ) ; | ||
27599 | public final void rule__ALSAnd__RightOperandAssignment_1_2() throws RecognitionException { | ||
27600 | |||
27601 | int stackSize = keepStackSize(); | ||
27602 | |||
27603 | try { | ||
27604 | // InternalAlloyLanguage.g:9806:1: ( ( ruleALSComparison ) ) | ||
27605 | // InternalAlloyLanguage.g:9807:1: ( ruleALSComparison ) | ||
27606 | { | ||
27607 | // InternalAlloyLanguage.g:9807:1: ( ruleALSComparison ) | ||
27608 | // InternalAlloyLanguage.g:9808:1: ruleALSComparison | ||
27609 | { | ||
27610 | if ( state.backtracking==0 ) { | ||
27611 | before(grammarAccess.getALSAndAccess().getRightOperandALSComparisonParserRuleCall_1_2_0()); | ||
27612 | } | ||
27613 | pushFollow(FOLLOW_2); | ||
27614 | ruleALSComparison(); | ||
27615 | |||
27616 | state._fsp--; | ||
27617 | if (state.failed) return ; | ||
27618 | if ( state.backtracking==0 ) { | ||
27619 | after(grammarAccess.getALSAndAccess().getRightOperandALSComparisonParserRuleCall_1_2_0()); | ||
27620 | } | ||
27621 | |||
27622 | } | ||
27623 | |||
27624 | |||
27625 | } | ||
27626 | |||
27627 | } | ||
27628 | catch (RecognitionException re) { | ||
27629 | reportError(re); | ||
27630 | recover(input,re); | ||
27631 | } | ||
27632 | finally { | ||
27633 | |||
27634 | restoreStackSize(stackSize); | ||
27635 | |||
27636 | } | ||
27637 | return ; | ||
27638 | } | ||
27639 | // $ANTLR end "rule__ALSAnd__RightOperandAssignment_1_2" | ||
27640 | |||
27641 | |||
27642 | // $ANTLR start "rule__ALSComparison__RightOperandAssignment_1_1" | ||
27643 | // InternalAlloyLanguage.g:9817:1: rule__ALSComparison__RightOperandAssignment_1_1 : ( ruleALSOverride ) ; | ||
27644 | public final void rule__ALSComparison__RightOperandAssignment_1_1() throws RecognitionException { | ||
27645 | |||
27646 | int stackSize = keepStackSize(); | ||
27647 | |||
27648 | try { | ||
27649 | // InternalAlloyLanguage.g:9821:1: ( ( ruleALSOverride ) ) | ||
27650 | // InternalAlloyLanguage.g:9822:1: ( ruleALSOverride ) | ||
27651 | { | ||
27652 | // InternalAlloyLanguage.g:9822:1: ( ruleALSOverride ) | ||
27653 | // InternalAlloyLanguage.g:9823:1: ruleALSOverride | ||
27654 | { | ||
27655 | if ( state.backtracking==0 ) { | ||
27656 | before(grammarAccess.getALSComparisonAccess().getRightOperandALSOverrideParserRuleCall_1_1_0()); | ||
27657 | } | ||
27658 | pushFollow(FOLLOW_2); | ||
27659 | ruleALSOverride(); | ||
27660 | |||
27661 | state._fsp--; | ||
27662 | if (state.failed) return ; | ||
27663 | if ( state.backtracking==0 ) { | ||
27664 | after(grammarAccess.getALSComparisonAccess().getRightOperandALSOverrideParserRuleCall_1_1_0()); | ||
27665 | } | ||
27666 | |||
27667 | } | ||
27668 | |||
27669 | |||
27670 | } | ||
27671 | |||
27672 | } | ||
27673 | catch (RecognitionException re) { | ||
27674 | reportError(re); | ||
27675 | recover(input,re); | ||
27676 | } | ||
27677 | finally { | ||
27678 | |||
27679 | restoreStackSize(stackSize); | ||
27680 | |||
27681 | } | ||
27682 | return ; | ||
27683 | } | ||
27684 | // $ANTLR end "rule__ALSComparison__RightOperandAssignment_1_1" | ||
27685 | |||
27686 | |||
27687 | // $ANTLR start "rule__ALSOverride__RightOperandAssignment_1_2" | ||
27688 | // InternalAlloyLanguage.g:9832:1: rule__ALSOverride__RightOperandAssignment_1_2 : ( ruleALSRangeRestrictionRight ) ; | ||
27689 | public final void rule__ALSOverride__RightOperandAssignment_1_2() throws RecognitionException { | ||
27690 | |||
27691 | int stackSize = keepStackSize(); | ||
27692 | |||
27693 | try { | ||
27694 | // InternalAlloyLanguage.g:9836:1: ( ( ruleALSRangeRestrictionRight ) ) | ||
27695 | // InternalAlloyLanguage.g:9837:1: ( ruleALSRangeRestrictionRight ) | ||
27696 | { | ||
27697 | // InternalAlloyLanguage.g:9837:1: ( ruleALSRangeRestrictionRight ) | ||
27698 | // InternalAlloyLanguage.g:9838:1: ruleALSRangeRestrictionRight | ||
27699 | { | ||
27700 | if ( state.backtracking==0 ) { | ||
27701 | before(grammarAccess.getALSOverrideAccess().getRightOperandALSRangeRestrictionRightParserRuleCall_1_2_0()); | ||
27702 | } | ||
27703 | pushFollow(FOLLOW_2); | ||
27704 | ruleALSRangeRestrictionRight(); | ||
27705 | |||
27706 | state._fsp--; | ||
27707 | if (state.failed) return ; | ||
27708 | if ( state.backtracking==0 ) { | ||
27709 | after(grammarAccess.getALSOverrideAccess().getRightOperandALSRangeRestrictionRightParserRuleCall_1_2_0()); | ||
27710 | } | ||
27711 | |||
27712 | } | ||
27713 | |||
27714 | |||
27715 | } | ||
27716 | |||
27717 | } | ||
27718 | catch (RecognitionException re) { | ||
27719 | reportError(re); | ||
27720 | recover(input,re); | ||
27721 | } | ||
27722 | finally { | ||
27723 | |||
27724 | restoreStackSize(stackSize); | ||
27725 | |||
27726 | } | ||
27727 | return ; | ||
27728 | } | ||
27729 | // $ANTLR end "rule__ALSOverride__RightOperandAssignment_1_2" | ||
27730 | |||
27731 | |||
27732 | // $ANTLR start "rule__ALSRangeRestrictionRight__FilterAssignment_1_2" | ||
27733 | // InternalAlloyLanguage.g:9847:1: rule__ALSRangeRestrictionRight__FilterAssignment_1_2 : ( ruleALSRangeRestrictionLeft ) ; | ||
27734 | public final void rule__ALSRangeRestrictionRight__FilterAssignment_1_2() throws RecognitionException { | ||
27735 | |||
27736 | int stackSize = keepStackSize(); | ||
27737 | |||
27738 | try { | ||
27739 | // InternalAlloyLanguage.g:9851:1: ( ( ruleALSRangeRestrictionLeft ) ) | ||
27740 | // InternalAlloyLanguage.g:9852:1: ( ruleALSRangeRestrictionLeft ) | ||
27741 | { | ||
27742 | // InternalAlloyLanguage.g:9852:1: ( ruleALSRangeRestrictionLeft ) | ||
27743 | // InternalAlloyLanguage.g:9853:1: ruleALSRangeRestrictionLeft | ||
27744 | { | ||
27745 | if ( state.backtracking==0 ) { | ||
27746 | before(grammarAccess.getALSRangeRestrictionRightAccess().getFilterALSRangeRestrictionLeftParserRuleCall_1_2_0()); | ||
27747 | } | ||
27748 | pushFollow(FOLLOW_2); | ||
27749 | ruleALSRangeRestrictionLeft(); | ||
27750 | |||
27751 | state._fsp--; | ||
27752 | if (state.failed) return ; | ||
27753 | if ( state.backtracking==0 ) { | ||
27754 | after(grammarAccess.getALSRangeRestrictionRightAccess().getFilterALSRangeRestrictionLeftParserRuleCall_1_2_0()); | ||
27755 | } | ||
27756 | |||
27757 | } | ||
27758 | |||
27759 | |||
27760 | } | ||
27761 | |||
27762 | } | ||
27763 | catch (RecognitionException re) { | ||
27764 | reportError(re); | ||
27765 | recover(input,re); | ||
27766 | } | ||
27767 | finally { | ||
27768 | |||
27769 | restoreStackSize(stackSize); | ||
27770 | |||
27771 | } | ||
27772 | return ; | ||
27773 | } | ||
27774 | // $ANTLR end "rule__ALSRangeRestrictionRight__FilterAssignment_1_2" | ||
27775 | |||
27776 | |||
27777 | // $ANTLR start "rule__ALSRangeRestrictionLeft__RelationAssignment_1_2" | ||
27778 | // InternalAlloyLanguage.g:9862:1: rule__ALSRangeRestrictionLeft__RelationAssignment_1_2 : ( ruleALSJoin ) ; | ||
27779 | public final void rule__ALSRangeRestrictionLeft__RelationAssignment_1_2() throws RecognitionException { | ||
27780 | |||
27781 | int stackSize = keepStackSize(); | ||
27782 | |||
27783 | try { | ||
27784 | // InternalAlloyLanguage.g:9866:1: ( ( ruleALSJoin ) ) | ||
27785 | // InternalAlloyLanguage.g:9867:1: ( ruleALSJoin ) | ||
27786 | { | ||
27787 | // InternalAlloyLanguage.g:9867:1: ( ruleALSJoin ) | ||
27788 | // InternalAlloyLanguage.g:9868:1: ruleALSJoin | ||
27789 | { | ||
27790 | if ( state.backtracking==0 ) { | ||
27791 | before(grammarAccess.getALSRangeRestrictionLeftAccess().getRelationALSJoinParserRuleCall_1_2_0()); | ||
27792 | } | ||
27793 | pushFollow(FOLLOW_2); | ||
27794 | ruleALSJoin(); | ||
27795 | |||
27796 | state._fsp--; | ||
27797 | if (state.failed) return ; | ||
27798 | if ( state.backtracking==0 ) { | ||
27799 | after(grammarAccess.getALSRangeRestrictionLeftAccess().getRelationALSJoinParserRuleCall_1_2_0()); | ||
27800 | } | ||
27801 | |||
27802 | } | ||
27803 | |||
27804 | |||
27805 | } | ||
27806 | |||
27807 | } | ||
27808 | catch (RecognitionException re) { | ||
27809 | reportError(re); | ||
27810 | recover(input,re); | ||
27811 | } | ||
27812 | finally { | ||
27813 | |||
27814 | restoreStackSize(stackSize); | ||
27815 | |||
27816 | } | ||
27817 | return ; | ||
27818 | } | ||
27819 | // $ANTLR end "rule__ALSRangeRestrictionLeft__RelationAssignment_1_2" | ||
27820 | |||
27821 | |||
27822 | // $ANTLR start "rule__ALSJoin__RightOperandAssignment_1_2" | ||
27823 | // InternalAlloyLanguage.g:9877:1: rule__ALSJoin__RightOperandAssignment_1_2 : ( ruleALSMinus ) ; | ||
27824 | public final void rule__ALSJoin__RightOperandAssignment_1_2() throws RecognitionException { | ||
27825 | |||
27826 | int stackSize = keepStackSize(); | ||
27827 | |||
27828 | try { | ||
27829 | // InternalAlloyLanguage.g:9881:1: ( ( ruleALSMinus ) ) | ||
27830 | // InternalAlloyLanguage.g:9882:1: ( ruleALSMinus ) | ||
27831 | { | ||
27832 | // InternalAlloyLanguage.g:9882:1: ( ruleALSMinus ) | ||
27833 | // InternalAlloyLanguage.g:9883:1: ruleALSMinus | ||
27834 | { | ||
27835 | if ( state.backtracking==0 ) { | ||
27836 | before(grammarAccess.getALSJoinAccess().getRightOperandALSMinusParserRuleCall_1_2_0()); | ||
27837 | } | ||
27838 | pushFollow(FOLLOW_2); | ||
27839 | ruleALSMinus(); | ||
27840 | |||
27841 | state._fsp--; | ||
27842 | if (state.failed) return ; | ||
27843 | if ( state.backtracking==0 ) { | ||
27844 | after(grammarAccess.getALSJoinAccess().getRightOperandALSMinusParserRuleCall_1_2_0()); | ||
27845 | } | ||
27846 | |||
27847 | } | ||
27848 | |||
27849 | |||
27850 | } | ||
27851 | |||
27852 | } | ||
27853 | catch (RecognitionException re) { | ||
27854 | reportError(re); | ||
27855 | recover(input,re); | ||
27856 | } | ||
27857 | finally { | ||
27858 | |||
27859 | restoreStackSize(stackSize); | ||
27860 | |||
27861 | } | ||
27862 | return ; | ||
27863 | } | ||
27864 | // $ANTLR end "rule__ALSJoin__RightOperandAssignment_1_2" | ||
27865 | |||
27866 | |||
27867 | // $ANTLR start "rule__ALSMinus__RightOperandAssignment_1_2" | ||
27868 | // InternalAlloyLanguage.g:9892:1: rule__ALSMinus__RightOperandAssignment_1_2 : ( ruleALSPlus ) ; | ||
27869 | public final void rule__ALSMinus__RightOperandAssignment_1_2() throws RecognitionException { | ||
27870 | |||
27871 | int stackSize = keepStackSize(); | ||
27872 | |||
27873 | try { | ||
27874 | // InternalAlloyLanguage.g:9896:1: ( ( ruleALSPlus ) ) | ||
27875 | // InternalAlloyLanguage.g:9897:1: ( ruleALSPlus ) | ||
27876 | { | ||
27877 | // InternalAlloyLanguage.g:9897:1: ( ruleALSPlus ) | ||
27878 | // InternalAlloyLanguage.g:9898:1: ruleALSPlus | ||
27879 | { | ||
27880 | if ( state.backtracking==0 ) { | ||
27881 | before(grammarAccess.getALSMinusAccess().getRightOperandALSPlusParserRuleCall_1_2_0()); | ||
27882 | } | ||
27883 | pushFollow(FOLLOW_2); | ||
27884 | ruleALSPlus(); | ||
27885 | |||
27886 | state._fsp--; | ||
27887 | if (state.failed) return ; | ||
27888 | if ( state.backtracking==0 ) { | ||
27889 | after(grammarAccess.getALSMinusAccess().getRightOperandALSPlusParserRuleCall_1_2_0()); | ||
27890 | } | ||
27891 | |||
27892 | } | ||
27893 | |||
27894 | |||
27895 | } | ||
27896 | |||
27897 | } | ||
27898 | catch (RecognitionException re) { | ||
27899 | reportError(re); | ||
27900 | recover(input,re); | ||
27901 | } | ||
27902 | finally { | ||
27903 | |||
27904 | restoreStackSize(stackSize); | ||
27905 | |||
27906 | } | ||
27907 | return ; | ||
27908 | } | ||
27909 | // $ANTLR end "rule__ALSMinus__RightOperandAssignment_1_2" | ||
27910 | |||
27911 | |||
27912 | // $ANTLR start "rule__ALSPlus__RightOperandAssignment_1_2" | ||
27913 | // InternalAlloyLanguage.g:9907:1: rule__ALSPlus__RightOperandAssignment_1_2 : ( ruleALSIntersection ) ; | ||
27914 | public final void rule__ALSPlus__RightOperandAssignment_1_2() throws RecognitionException { | ||
27915 | |||
27916 | int stackSize = keepStackSize(); | ||
27917 | |||
27918 | try { | ||
27919 | // InternalAlloyLanguage.g:9911:1: ( ( ruleALSIntersection ) ) | ||
27920 | // InternalAlloyLanguage.g:9912:1: ( ruleALSIntersection ) | ||
27921 | { | ||
27922 | // InternalAlloyLanguage.g:9912:1: ( ruleALSIntersection ) | ||
27923 | // InternalAlloyLanguage.g:9913:1: ruleALSIntersection | ||
27924 | { | ||
27925 | if ( state.backtracking==0 ) { | ||
27926 | before(grammarAccess.getALSPlusAccess().getRightOperandALSIntersectionParserRuleCall_1_2_0()); | ||
27927 | } | ||
27928 | pushFollow(FOLLOW_2); | ||
27929 | ruleALSIntersection(); | ||
27930 | |||
27931 | state._fsp--; | ||
27932 | if (state.failed) return ; | ||
27933 | if ( state.backtracking==0 ) { | ||
27934 | after(grammarAccess.getALSPlusAccess().getRightOperandALSIntersectionParserRuleCall_1_2_0()); | ||
27935 | } | ||
27936 | |||
27937 | } | ||
27938 | |||
27939 | |||
27940 | } | ||
27941 | |||
27942 | } | ||
27943 | catch (RecognitionException re) { | ||
27944 | reportError(re); | ||
27945 | recover(input,re); | ||
27946 | } | ||
27947 | finally { | ||
27948 | |||
27949 | restoreStackSize(stackSize); | ||
27950 | |||
27951 | } | ||
27952 | return ; | ||
27953 | } | ||
27954 | // $ANTLR end "rule__ALSPlus__RightOperandAssignment_1_2" | ||
27955 | |||
27956 | |||
27957 | // $ANTLR start "rule__ALSIntersection__RightOperandAssignment_1_2" | ||
27958 | // InternalAlloyLanguage.g:9922:1: rule__ALSIntersection__RightOperandAssignment_1_2 : ( ruleALSDirectProduct ) ; | ||
27959 | public final void rule__ALSIntersection__RightOperandAssignment_1_2() throws RecognitionException { | ||
27960 | |||
27961 | int stackSize = keepStackSize(); | ||
27962 | |||
27963 | try { | ||
27964 | // InternalAlloyLanguage.g:9926:1: ( ( ruleALSDirectProduct ) ) | ||
27965 | // InternalAlloyLanguage.g:9927:1: ( ruleALSDirectProduct ) | ||
27966 | { | ||
27967 | // InternalAlloyLanguage.g:9927:1: ( ruleALSDirectProduct ) | ||
27968 | // InternalAlloyLanguage.g:9928:1: ruleALSDirectProduct | ||
27969 | { | ||
27970 | if ( state.backtracking==0 ) { | ||
27971 | before(grammarAccess.getALSIntersectionAccess().getRightOperandALSDirectProductParserRuleCall_1_2_0()); | ||
27972 | } | ||
27973 | pushFollow(FOLLOW_2); | ||
27974 | ruleALSDirectProduct(); | ||
27975 | |||
27976 | state._fsp--; | ||
27977 | if (state.failed) return ; | ||
27978 | if ( state.backtracking==0 ) { | ||
27979 | after(grammarAccess.getALSIntersectionAccess().getRightOperandALSDirectProductParserRuleCall_1_2_0()); | ||
27980 | } | ||
27981 | |||
27982 | } | ||
27983 | |||
27984 | |||
27985 | } | ||
27986 | |||
27987 | } | ||
27988 | catch (RecognitionException re) { | ||
27989 | reportError(re); | ||
27990 | recover(input,re); | ||
27991 | } | ||
27992 | finally { | ||
27993 | |||
27994 | restoreStackSize(stackSize); | ||
27995 | |||
27996 | } | ||
27997 | return ; | ||
27998 | } | ||
27999 | // $ANTLR end "rule__ALSIntersection__RightOperandAssignment_1_2" | ||
28000 | |||
28001 | |||
28002 | // $ANTLR start "rule__ALSDirectProduct__LeftMultiplicitAssignment_1_1" | ||
28003 | // InternalAlloyLanguage.g:9937:1: rule__ALSDirectProduct__LeftMultiplicitAssignment_1_1 : ( ruleALSMultiplicity ) ; | ||
28004 | public final void rule__ALSDirectProduct__LeftMultiplicitAssignment_1_1() throws RecognitionException { | ||
28005 | |||
28006 | int stackSize = keepStackSize(); | ||
28007 | |||
28008 | try { | ||
28009 | // InternalAlloyLanguage.g:9941:1: ( ( ruleALSMultiplicity ) ) | ||
28010 | // InternalAlloyLanguage.g:9942:1: ( ruleALSMultiplicity ) | ||
28011 | { | ||
28012 | // InternalAlloyLanguage.g:9942:1: ( ruleALSMultiplicity ) | ||
28013 | // InternalAlloyLanguage.g:9943:1: ruleALSMultiplicity | ||
28014 | { | ||
28015 | if ( state.backtracking==0 ) { | ||
28016 | before(grammarAccess.getALSDirectProductAccess().getLeftMultiplicitALSMultiplicityEnumRuleCall_1_1_0()); | ||
28017 | } | ||
28018 | pushFollow(FOLLOW_2); | ||
28019 | ruleALSMultiplicity(); | ||
28020 | |||
28021 | state._fsp--; | ||
28022 | if (state.failed) return ; | ||
28023 | if ( state.backtracking==0 ) { | ||
28024 | after(grammarAccess.getALSDirectProductAccess().getLeftMultiplicitALSMultiplicityEnumRuleCall_1_1_0()); | ||
28025 | } | ||
28026 | |||
28027 | } | ||
28028 | |||
28029 | |||
28030 | } | ||
28031 | |||
28032 | } | ||
28033 | catch (RecognitionException re) { | ||
28034 | reportError(re); | ||
28035 | recover(input,re); | ||
28036 | } | ||
28037 | finally { | ||
28038 | |||
28039 | restoreStackSize(stackSize); | ||
28040 | |||
28041 | } | ||
28042 | return ; | ||
28043 | } | ||
28044 | // $ANTLR end "rule__ALSDirectProduct__LeftMultiplicitAssignment_1_1" | ||
28045 | |||
28046 | |||
28047 | // $ANTLR start "rule__ALSDirectProduct__RightMultiplicitAssignment_1_3" | ||
28048 | // InternalAlloyLanguage.g:9952:1: rule__ALSDirectProduct__RightMultiplicitAssignment_1_3 : ( ruleALSMultiplicity ) ; | ||
28049 | public final void rule__ALSDirectProduct__RightMultiplicitAssignment_1_3() throws RecognitionException { | ||
28050 | |||
28051 | int stackSize = keepStackSize(); | ||
28052 | |||
28053 | try { | ||
28054 | // InternalAlloyLanguage.g:9956:1: ( ( ruleALSMultiplicity ) ) | ||
28055 | // InternalAlloyLanguage.g:9957:1: ( ruleALSMultiplicity ) | ||
28056 | { | ||
28057 | // InternalAlloyLanguage.g:9957:1: ( ruleALSMultiplicity ) | ||
28058 | // InternalAlloyLanguage.g:9958:1: ruleALSMultiplicity | ||
28059 | { | ||
28060 | if ( state.backtracking==0 ) { | ||
28061 | before(grammarAccess.getALSDirectProductAccess().getRightMultiplicitALSMultiplicityEnumRuleCall_1_3_0()); | ||
28062 | } | ||
28063 | pushFollow(FOLLOW_2); | ||
28064 | ruleALSMultiplicity(); | ||
28065 | |||
28066 | state._fsp--; | ||
28067 | if (state.failed) return ; | ||
28068 | if ( state.backtracking==0 ) { | ||
28069 | after(grammarAccess.getALSDirectProductAccess().getRightMultiplicitALSMultiplicityEnumRuleCall_1_3_0()); | ||
28070 | } | ||
28071 | |||
28072 | } | ||
28073 | |||
28074 | |||
28075 | } | ||
28076 | |||
28077 | } | ||
28078 | catch (RecognitionException re) { | ||
28079 | reportError(re); | ||
28080 | recover(input,re); | ||
28081 | } | ||
28082 | finally { | ||
28083 | |||
28084 | restoreStackSize(stackSize); | ||
28085 | |||
28086 | } | ||
28087 | return ; | ||
28088 | } | ||
28089 | // $ANTLR end "rule__ALSDirectProduct__RightMultiplicitAssignment_1_3" | ||
28090 | |||
28091 | |||
28092 | // $ANTLR start "rule__ALSDirectProduct__RightOperandAssignment_1_4" | ||
28093 | // InternalAlloyLanguage.g:9967:1: rule__ALSDirectProduct__RightOperandAssignment_1_4 : ( ruleALSPreficed ) ; | ||
28094 | public final void rule__ALSDirectProduct__RightOperandAssignment_1_4() throws RecognitionException { | ||
28095 | |||
28096 | int stackSize = keepStackSize(); | ||
28097 | |||
28098 | try { | ||
28099 | // InternalAlloyLanguage.g:9971:1: ( ( ruleALSPreficed ) ) | ||
28100 | // InternalAlloyLanguage.g:9972:1: ( ruleALSPreficed ) | ||
28101 | { | ||
28102 | // InternalAlloyLanguage.g:9972:1: ( ruleALSPreficed ) | ||
28103 | // InternalAlloyLanguage.g:9973:1: ruleALSPreficed | ||
28104 | { | ||
28105 | if ( state.backtracking==0 ) { | ||
28106 | before(grammarAccess.getALSDirectProductAccess().getRightOperandALSPreficedParserRuleCall_1_4_0()); | ||
28107 | } | ||
28108 | pushFollow(FOLLOW_2); | ||
28109 | ruleALSPreficed(); | ||
28110 | |||
28111 | state._fsp--; | ||
28112 | if (state.failed) return ; | ||
28113 | if ( state.backtracking==0 ) { | ||
28114 | after(grammarAccess.getALSDirectProductAccess().getRightOperandALSPreficedParserRuleCall_1_4_0()); | ||
28115 | } | ||
28116 | |||
28117 | } | ||
28118 | |||
28119 | |||
28120 | } | ||
28121 | |||
28122 | } | ||
28123 | catch (RecognitionException re) { | ||
28124 | reportError(re); | ||
28125 | recover(input,re); | ||
28126 | } | ||
28127 | finally { | ||
28128 | |||
28129 | restoreStackSize(stackSize); | ||
28130 | |||
28131 | } | ||
28132 | return ; | ||
28133 | } | ||
28134 | // $ANTLR end "rule__ALSDirectProduct__RightOperandAssignment_1_4" | ||
28135 | |||
28136 | |||
28137 | // $ANTLR start "rule__ALSPreficed__OperandAssignment_0_2" | ||
28138 | // InternalAlloyLanguage.g:9982:1: rule__ALSPreficed__OperandAssignment_0_2 : ( ruleALSBasicRelationTerm ) ; | ||
28139 | public final void rule__ALSPreficed__OperandAssignment_0_2() throws RecognitionException { | ||
28140 | |||
28141 | int stackSize = keepStackSize(); | ||
28142 | |||
28143 | try { | ||
28144 | // InternalAlloyLanguage.g:9986:1: ( ( ruleALSBasicRelationTerm ) ) | ||
28145 | // InternalAlloyLanguage.g:9987:1: ( ruleALSBasicRelationTerm ) | ||
28146 | { | ||
28147 | // InternalAlloyLanguage.g:9987:1: ( ruleALSBasicRelationTerm ) | ||
28148 | // InternalAlloyLanguage.g:9988:1: ruleALSBasicRelationTerm | ||
28149 | { | ||
28150 | if ( state.backtracking==0 ) { | ||
28151 | before(grammarAccess.getALSPreficedAccess().getOperandALSBasicRelationTermParserRuleCall_0_2_0()); | ||
28152 | } | ||
28153 | pushFollow(FOLLOW_2); | ||
28154 | ruleALSBasicRelationTerm(); | ||
28155 | |||
28156 | state._fsp--; | ||
28157 | if (state.failed) return ; | ||
28158 | if ( state.backtracking==0 ) { | ||
28159 | after(grammarAccess.getALSPreficedAccess().getOperandALSBasicRelationTermParserRuleCall_0_2_0()); | ||
28160 | } | ||
28161 | |||
28162 | } | ||
28163 | |||
28164 | |||
28165 | } | ||
28166 | |||
28167 | } | ||
28168 | catch (RecognitionException re) { | ||
28169 | reportError(re); | ||
28170 | recover(input,re); | ||
28171 | } | ||
28172 | finally { | ||
28173 | |||
28174 | restoreStackSize(stackSize); | ||
28175 | |||
28176 | } | ||
28177 | return ; | ||
28178 | } | ||
28179 | // $ANTLR end "rule__ALSPreficed__OperandAssignment_0_2" | ||
28180 | |||
28181 | |||
28182 | // $ANTLR start "rule__ALSPreficed__OperandAssignment_1_2" | ||
28183 | // InternalAlloyLanguage.g:9997:1: rule__ALSPreficed__OperandAssignment_1_2 : ( ruleALSBasicRelationTerm ) ; | ||
28184 | public final void rule__ALSPreficed__OperandAssignment_1_2() throws RecognitionException { | ||
28185 | |||
28186 | int stackSize = keepStackSize(); | ||
28187 | |||
28188 | try { | ||
28189 | // InternalAlloyLanguage.g:10001:1: ( ( ruleALSBasicRelationTerm ) ) | ||
28190 | // InternalAlloyLanguage.g:10002:1: ( ruleALSBasicRelationTerm ) | ||
28191 | { | ||
28192 | // InternalAlloyLanguage.g:10002:1: ( ruleALSBasicRelationTerm ) | ||
28193 | // InternalAlloyLanguage.g:10003:1: ruleALSBasicRelationTerm | ||
28194 | { | ||
28195 | if ( state.backtracking==0 ) { | ||
28196 | before(grammarAccess.getALSPreficedAccess().getOperandALSBasicRelationTermParserRuleCall_1_2_0()); | ||
28197 | } | ||
28198 | pushFollow(FOLLOW_2); | ||
28199 | ruleALSBasicRelationTerm(); | ||
28200 | |||
28201 | state._fsp--; | ||
28202 | if (state.failed) return ; | ||
28203 | if ( state.backtracking==0 ) { | ||
28204 | after(grammarAccess.getALSPreficedAccess().getOperandALSBasicRelationTermParserRuleCall_1_2_0()); | ||
28205 | } | ||
28206 | |||
28207 | } | ||
28208 | |||
28209 | |||
28210 | } | ||
28211 | |||
28212 | } | ||
28213 | catch (RecognitionException re) { | ||
28214 | reportError(re); | ||
28215 | recover(input,re); | ||
28216 | } | ||
28217 | finally { | ||
28218 | |||
28219 | restoreStackSize(stackSize); | ||
28220 | |||
28221 | } | ||
28222 | return ; | ||
28223 | } | ||
28224 | // $ANTLR end "rule__ALSPreficed__OperandAssignment_1_2" | ||
28225 | |||
28226 | |||
28227 | // $ANTLR start "rule__ALSPreficed__OperandAssignment_2_2" | ||
28228 | // InternalAlloyLanguage.g:10012:1: rule__ALSPreficed__OperandAssignment_2_2 : ( ruleALSBasicRelationTerm ) ; | ||
28229 | public final void rule__ALSPreficed__OperandAssignment_2_2() throws RecognitionException { | ||
28230 | |||
28231 | int stackSize = keepStackSize(); | ||
28232 | |||
28233 | try { | ||
28234 | // InternalAlloyLanguage.g:10016:1: ( ( ruleALSBasicRelationTerm ) ) | ||
28235 | // InternalAlloyLanguage.g:10017:1: ( ruleALSBasicRelationTerm ) | ||
28236 | { | ||
28237 | // InternalAlloyLanguage.g:10017:1: ( ruleALSBasicRelationTerm ) | ||
28238 | // InternalAlloyLanguage.g:10018:1: ruleALSBasicRelationTerm | ||
28239 | { | ||
28240 | if ( state.backtracking==0 ) { | ||
28241 | before(grammarAccess.getALSPreficedAccess().getOperandALSBasicRelationTermParserRuleCall_2_2_0()); | ||
28242 | } | ||
28243 | pushFollow(FOLLOW_2); | ||
28244 | ruleALSBasicRelationTerm(); | ||
28245 | |||
28246 | state._fsp--; | ||
28247 | if (state.failed) return ; | ||
28248 | if ( state.backtracking==0 ) { | ||
28249 | after(grammarAccess.getALSPreficedAccess().getOperandALSBasicRelationTermParserRuleCall_2_2_0()); | ||
28250 | } | ||
28251 | |||
28252 | } | ||
28253 | |||
28254 | |||
28255 | } | ||
28256 | |||
28257 | } | ||
28258 | catch (RecognitionException re) { | ||
28259 | reportError(re); | ||
28260 | recover(input,re); | ||
28261 | } | ||
28262 | finally { | ||
28263 | |||
28264 | restoreStackSize(stackSize); | ||
28265 | |||
28266 | } | ||
28267 | return ; | ||
28268 | } | ||
28269 | // $ANTLR end "rule__ALSPreficed__OperandAssignment_2_2" | ||
28270 | |||
28271 | |||
28272 | // $ANTLR start "rule__ALSPreficed__OperandAssignment_3_2" | ||
28273 | // InternalAlloyLanguage.g:10027:1: rule__ALSPreficed__OperandAssignment_3_2 : ( ruleALSBasicRelationTerm ) ; | ||
28274 | public final void rule__ALSPreficed__OperandAssignment_3_2() throws RecognitionException { | ||
28275 | |||
28276 | int stackSize = keepStackSize(); | ||
28277 | |||
28278 | try { | ||
28279 | // InternalAlloyLanguage.g:10031:1: ( ( ruleALSBasicRelationTerm ) ) | ||
28280 | // InternalAlloyLanguage.g:10032:1: ( ruleALSBasicRelationTerm ) | ||
28281 | { | ||
28282 | // InternalAlloyLanguage.g:10032:1: ( ruleALSBasicRelationTerm ) | ||
28283 | // InternalAlloyLanguage.g:10033:1: ruleALSBasicRelationTerm | ||
28284 | { | ||
28285 | if ( state.backtracking==0 ) { | ||
28286 | before(grammarAccess.getALSPreficedAccess().getOperandALSBasicRelationTermParserRuleCall_3_2_0()); | ||
28287 | } | ||
28288 | pushFollow(FOLLOW_2); | ||
28289 | ruleALSBasicRelationTerm(); | ||
28290 | |||
28291 | state._fsp--; | ||
28292 | if (state.failed) return ; | ||
28293 | if ( state.backtracking==0 ) { | ||
28294 | after(grammarAccess.getALSPreficedAccess().getOperandALSBasicRelationTermParserRuleCall_3_2_0()); | ||
28295 | } | ||
28296 | |||
28297 | } | ||
28298 | |||
28299 | |||
28300 | } | ||
28301 | |||
28302 | } | ||
28303 | catch (RecognitionException re) { | ||
28304 | reportError(re); | ||
28305 | recover(input,re); | ||
28306 | } | ||
28307 | finally { | ||
28308 | |||
28309 | restoreStackSize(stackSize); | ||
28310 | |||
28311 | } | ||
28312 | return ; | ||
28313 | } | ||
28314 | // $ANTLR end "rule__ALSPreficed__OperandAssignment_3_2" | ||
28315 | |||
28316 | |||
28317 | // $ANTLR start "rule__ALSPreficed__OperandAssignment_4_2" | ||
28318 | // InternalAlloyLanguage.g:10042:1: rule__ALSPreficed__OperandAssignment_4_2 : ( ruleALSBasicRelationTerm ) ; | ||
28319 | public final void rule__ALSPreficed__OperandAssignment_4_2() throws RecognitionException { | ||
28320 | |||
28321 | int stackSize = keepStackSize(); | ||
28322 | |||
28323 | try { | ||
28324 | // InternalAlloyLanguage.g:10046:1: ( ( ruleALSBasicRelationTerm ) ) | ||
28325 | // InternalAlloyLanguage.g:10047:1: ( ruleALSBasicRelationTerm ) | ||
28326 | { | ||
28327 | // InternalAlloyLanguage.g:10047:1: ( ruleALSBasicRelationTerm ) | ||
28328 | // InternalAlloyLanguage.g:10048:1: ruleALSBasicRelationTerm | ||
28329 | { | ||
28330 | if ( state.backtracking==0 ) { | ||
28331 | before(grammarAccess.getALSPreficedAccess().getOperandALSBasicRelationTermParserRuleCall_4_2_0()); | ||
28332 | } | ||
28333 | pushFollow(FOLLOW_2); | ||
28334 | ruleALSBasicRelationTerm(); | ||
28335 | |||
28336 | state._fsp--; | ||
28337 | if (state.failed) return ; | ||
28338 | if ( state.backtracking==0 ) { | ||
28339 | after(grammarAccess.getALSPreficedAccess().getOperandALSBasicRelationTermParserRuleCall_4_2_0()); | ||
28340 | } | ||
28341 | |||
28342 | } | ||
28343 | |||
28344 | |||
28345 | } | ||
28346 | |||
28347 | } | ||
28348 | catch (RecognitionException re) { | ||
28349 | reportError(re); | ||
28350 | recover(input,re); | ||
28351 | } | ||
28352 | finally { | ||
28353 | |||
28354 | restoreStackSize(stackSize); | ||
28355 | |||
28356 | } | ||
28357 | return ; | ||
28358 | } | ||
28359 | // $ANTLR end "rule__ALSPreficed__OperandAssignment_4_2" | ||
28360 | |||
28361 | |||
28362 | // $ANTLR start "rule__ALSPreficed__OperandAssignment_5_2" | ||
28363 | // InternalAlloyLanguage.g:10057:1: rule__ALSPreficed__OperandAssignment_5_2 : ( ruleALSBasicRelationTerm ) ; | ||
28364 | public final void rule__ALSPreficed__OperandAssignment_5_2() throws RecognitionException { | ||
28365 | |||
28366 | int stackSize = keepStackSize(); | ||
28367 | |||
28368 | try { | ||
28369 | // InternalAlloyLanguage.g:10061:1: ( ( ruleALSBasicRelationTerm ) ) | ||
28370 | // InternalAlloyLanguage.g:10062:1: ( ruleALSBasicRelationTerm ) | ||
28371 | { | ||
28372 | // InternalAlloyLanguage.g:10062:1: ( ruleALSBasicRelationTerm ) | ||
28373 | // InternalAlloyLanguage.g:10063:1: ruleALSBasicRelationTerm | ||
28374 | { | ||
28375 | if ( state.backtracking==0 ) { | ||
28376 | before(grammarAccess.getALSPreficedAccess().getOperandALSBasicRelationTermParserRuleCall_5_2_0()); | ||
28377 | } | ||
28378 | pushFollow(FOLLOW_2); | ||
28379 | ruleALSBasicRelationTerm(); | ||
28380 | |||
28381 | state._fsp--; | ||
28382 | if (state.failed) return ; | ||
28383 | if ( state.backtracking==0 ) { | ||
28384 | after(grammarAccess.getALSPreficedAccess().getOperandALSBasicRelationTermParserRuleCall_5_2_0()); | ||
28385 | } | ||
28386 | |||
28387 | } | ||
28388 | |||
28389 | |||
28390 | } | ||
28391 | |||
28392 | } | ||
28393 | catch (RecognitionException re) { | ||
28394 | reportError(re); | ||
28395 | recover(input,re); | ||
28396 | } | ||
28397 | finally { | ||
28398 | |||
28399 | restoreStackSize(stackSize); | ||
28400 | |||
28401 | } | ||
28402 | return ; | ||
28403 | } | ||
28404 | // $ANTLR end "rule__ALSPreficed__OperandAssignment_5_2" | ||
28405 | |||
28406 | |||
28407 | // $ANTLR start "rule__ALSPreficed__VariablesAssignment_6_2" | ||
28408 | // InternalAlloyLanguage.g:10072:1: rule__ALSPreficed__VariablesAssignment_6_2 : ( ruleALSVariableDeclaration ) ; | ||
28409 | public final void rule__ALSPreficed__VariablesAssignment_6_2() throws RecognitionException { | ||
28410 | |||
28411 | int stackSize = keepStackSize(); | ||
28412 | |||
28413 | try { | ||
28414 | // InternalAlloyLanguage.g:10076:1: ( ( ruleALSVariableDeclaration ) ) | ||
28415 | // InternalAlloyLanguage.g:10077:1: ( ruleALSVariableDeclaration ) | ||
28416 | { | ||
28417 | // InternalAlloyLanguage.g:10077:1: ( ruleALSVariableDeclaration ) | ||
28418 | // InternalAlloyLanguage.g:10078:1: ruleALSVariableDeclaration | ||
28419 | { | ||
28420 | if ( state.backtracking==0 ) { | ||
28421 | before(grammarAccess.getALSPreficedAccess().getVariablesALSVariableDeclarationParserRuleCall_6_2_0()); | ||
28422 | } | ||
28423 | pushFollow(FOLLOW_2); | ||
28424 | ruleALSVariableDeclaration(); | ||
28425 | |||
28426 | state._fsp--; | ||
28427 | if (state.failed) return ; | ||
28428 | if ( state.backtracking==0 ) { | ||
28429 | after(grammarAccess.getALSPreficedAccess().getVariablesALSVariableDeclarationParserRuleCall_6_2_0()); | ||
28430 | } | ||
28431 | |||
28432 | } | ||
28433 | |||
28434 | |||
28435 | } | ||
28436 | |||
28437 | } | ||
28438 | catch (RecognitionException re) { | ||
28439 | reportError(re); | ||
28440 | recover(input,re); | ||
28441 | } | ||
28442 | finally { | ||
28443 | |||
28444 | restoreStackSize(stackSize); | ||
28445 | |||
28446 | } | ||
28447 | return ; | ||
28448 | } | ||
28449 | // $ANTLR end "rule__ALSPreficed__VariablesAssignment_6_2" | ||
28450 | |||
28451 | |||
28452 | // $ANTLR start "rule__ALSPreficed__VariablesAssignment_6_3_1" | ||
28453 | // InternalAlloyLanguage.g:10087:1: rule__ALSPreficed__VariablesAssignment_6_3_1 : ( ruleALSVariableDeclaration ) ; | ||
28454 | public final void rule__ALSPreficed__VariablesAssignment_6_3_1() throws RecognitionException { | ||
28455 | |||
28456 | int stackSize = keepStackSize(); | ||
28457 | |||
28458 | try { | ||
28459 | // InternalAlloyLanguage.g:10091:1: ( ( ruleALSVariableDeclaration ) ) | ||
28460 | // InternalAlloyLanguage.g:10092:1: ( ruleALSVariableDeclaration ) | ||
28461 | { | ||
28462 | // InternalAlloyLanguage.g:10092:1: ( ruleALSVariableDeclaration ) | ||
28463 | // InternalAlloyLanguage.g:10093:1: ruleALSVariableDeclaration | ||
28464 | { | ||
28465 | if ( state.backtracking==0 ) { | ||
28466 | before(grammarAccess.getALSPreficedAccess().getVariablesALSVariableDeclarationParserRuleCall_6_3_1_0()); | ||
28467 | } | ||
28468 | pushFollow(FOLLOW_2); | ||
28469 | ruleALSVariableDeclaration(); | ||
28470 | |||
28471 | state._fsp--; | ||
28472 | if (state.failed) return ; | ||
28473 | if ( state.backtracking==0 ) { | ||
28474 | after(grammarAccess.getALSPreficedAccess().getVariablesALSVariableDeclarationParserRuleCall_6_3_1_0()); | ||
28475 | } | ||
28476 | |||
28477 | } | ||
28478 | |||
28479 | |||
28480 | } | ||
28481 | |||
28482 | } | ||
28483 | catch (RecognitionException re) { | ||
28484 | reportError(re); | ||
28485 | recover(input,re); | ||
28486 | } | ||
28487 | finally { | ||
28488 | |||
28489 | restoreStackSize(stackSize); | ||
28490 | |||
28491 | } | ||
28492 | return ; | ||
28493 | } | ||
28494 | // $ANTLR end "rule__ALSPreficed__VariablesAssignment_6_3_1" | ||
28495 | |||
28496 | |||
28497 | // $ANTLR start "rule__ALSPreficed__ExpressionAssignment_6_5" | ||
28498 | // InternalAlloyLanguage.g:10102:1: rule__ALSPreficed__ExpressionAssignment_6_5 : ( ruleALSTerm ) ; | ||
28499 | public final void rule__ALSPreficed__ExpressionAssignment_6_5() throws RecognitionException { | ||
28500 | |||
28501 | int stackSize = keepStackSize(); | ||
28502 | |||
28503 | try { | ||
28504 | // InternalAlloyLanguage.g:10106:1: ( ( ruleALSTerm ) ) | ||
28505 | // InternalAlloyLanguage.g:10107:1: ( ruleALSTerm ) | ||
28506 | { | ||
28507 | // InternalAlloyLanguage.g:10107:1: ( ruleALSTerm ) | ||
28508 | // InternalAlloyLanguage.g:10108:1: ruleALSTerm | ||
28509 | { | ||
28510 | if ( state.backtracking==0 ) { | ||
28511 | before(grammarAccess.getALSPreficedAccess().getExpressionALSTermParserRuleCall_6_5_0()); | ||
28512 | } | ||
28513 | pushFollow(FOLLOW_2); | ||
28514 | ruleALSTerm(); | ||
28515 | |||
28516 | state._fsp--; | ||
28517 | if (state.failed) return ; | ||
28518 | if ( state.backtracking==0 ) { | ||
28519 | after(grammarAccess.getALSPreficedAccess().getExpressionALSTermParserRuleCall_6_5_0()); | ||
28520 | } | ||
28521 | |||
28522 | } | ||
28523 | |||
28524 | |||
28525 | } | ||
28526 | |||
28527 | } | ||
28528 | catch (RecognitionException re) { | ||
28529 | reportError(re); | ||
28530 | recover(input,re); | ||
28531 | } | ||
28532 | finally { | ||
28533 | |||
28534 | restoreStackSize(stackSize); | ||
28535 | |||
28536 | } | ||
28537 | return ; | ||
28538 | } | ||
28539 | // $ANTLR end "rule__ALSPreficed__ExpressionAssignment_6_5" | ||
28540 | |||
28541 | |||
28542 | // $ANTLR start "rule__ALSPreficed__ReferredDefinitionAssignment_7_1_0" | ||
28543 | // InternalAlloyLanguage.g:10117:1: rule__ALSPreficed__ReferredDefinitionAssignment_7_1_0 : ( ( RULE_ID ) ) ; | ||
28544 | public final void rule__ALSPreficed__ReferredDefinitionAssignment_7_1_0() throws RecognitionException { | ||
28545 | |||
28546 | int stackSize = keepStackSize(); | ||
28547 | |||
28548 | try { | ||
28549 | // InternalAlloyLanguage.g:10121:1: ( ( ( RULE_ID ) ) ) | ||
28550 | // InternalAlloyLanguage.g:10122:1: ( ( RULE_ID ) ) | ||
28551 | { | ||
28552 | // InternalAlloyLanguage.g:10122:1: ( ( RULE_ID ) ) | ||
28553 | // InternalAlloyLanguage.g:10123:1: ( RULE_ID ) | ||
28554 | { | ||
28555 | if ( state.backtracking==0 ) { | ||
28556 | before(grammarAccess.getALSPreficedAccess().getReferredDefinitionALSDefinitionCrossReference_7_1_0_0()); | ||
28557 | } | ||
28558 | // InternalAlloyLanguage.g:10124:1: ( RULE_ID ) | ||
28559 | // InternalAlloyLanguage.g:10125:1: RULE_ID | ||
28560 | { | ||
28561 | if ( state.backtracking==0 ) { | ||
28562 | before(grammarAccess.getALSPreficedAccess().getReferredDefinitionALSDefinitionIDTerminalRuleCall_7_1_0_0_1()); | ||
28563 | } | ||
28564 | match(input,RULE_ID,FOLLOW_2); if (state.failed) return ; | ||
28565 | if ( state.backtracking==0 ) { | ||
28566 | after(grammarAccess.getALSPreficedAccess().getReferredDefinitionALSDefinitionIDTerminalRuleCall_7_1_0_0_1()); | ||
28567 | } | ||
28568 | |||
28569 | } | ||
28570 | |||
28571 | if ( state.backtracking==0 ) { | ||
28572 | after(grammarAccess.getALSPreficedAccess().getReferredDefinitionALSDefinitionCrossReference_7_1_0_0()); | ||
28573 | } | ||
28574 | |||
28575 | } | ||
28576 | |||
28577 | |||
28578 | } | ||
28579 | |||
28580 | } | ||
28581 | catch (RecognitionException re) { | ||
28582 | reportError(re); | ||
28583 | recover(input,re); | ||
28584 | } | ||
28585 | finally { | ||
28586 | |||
28587 | restoreStackSize(stackSize); | ||
28588 | |||
28589 | } | ||
28590 | return ; | ||
28591 | } | ||
28592 | // $ANTLR end "rule__ALSPreficed__ReferredDefinitionAssignment_7_1_0" | ||
28593 | |||
28594 | |||
28595 | // $ANTLR start "rule__ALSPreficed__ReferredNumericOperatorAssignment_7_1_1" | ||
28596 | // InternalAlloyLanguage.g:10136:1: rule__ALSPreficed__ReferredNumericOperatorAssignment_7_1_1 : ( ruleALSNumericOperator ) ; | ||
28597 | public final void rule__ALSPreficed__ReferredNumericOperatorAssignment_7_1_1() throws RecognitionException { | ||
28598 | |||
28599 | int stackSize = keepStackSize(); | ||
28600 | |||
28601 | try { | ||
28602 | // InternalAlloyLanguage.g:10140:1: ( ( ruleALSNumericOperator ) ) | ||
28603 | // InternalAlloyLanguage.g:10141:1: ( ruleALSNumericOperator ) | ||
28604 | { | ||
28605 | // InternalAlloyLanguage.g:10141:1: ( ruleALSNumericOperator ) | ||
28606 | // InternalAlloyLanguage.g:10142:1: ruleALSNumericOperator | ||
28607 | { | ||
28608 | if ( state.backtracking==0 ) { | ||
28609 | before(grammarAccess.getALSPreficedAccess().getReferredNumericOperatorALSNumericOperatorEnumRuleCall_7_1_1_0()); | ||
28610 | } | ||
28611 | pushFollow(FOLLOW_2); | ||
28612 | ruleALSNumericOperator(); | ||
28613 | |||
28614 | state._fsp--; | ||
28615 | if (state.failed) return ; | ||
28616 | if ( state.backtracking==0 ) { | ||
28617 | after(grammarAccess.getALSPreficedAccess().getReferredNumericOperatorALSNumericOperatorEnumRuleCall_7_1_1_0()); | ||
28618 | } | ||
28619 | |||
28620 | } | ||
28621 | |||
28622 | |||
28623 | } | ||
28624 | |||
28625 | } | ||
28626 | catch (RecognitionException re) { | ||
28627 | reportError(re); | ||
28628 | recover(input,re); | ||
28629 | } | ||
28630 | finally { | ||
28631 | |||
28632 | restoreStackSize(stackSize); | ||
28633 | |||
28634 | } | ||
28635 | return ; | ||
28636 | } | ||
28637 | // $ANTLR end "rule__ALSPreficed__ReferredNumericOperatorAssignment_7_1_1" | ||
28638 | |||
28639 | |||
28640 | // $ANTLR start "rule__ALSPreficed__ParamsAssignment_7_3" | ||
28641 | // InternalAlloyLanguage.g:10151:1: rule__ALSPreficed__ParamsAssignment_7_3 : ( ruleALSTerm ) ; | ||
28642 | public final void rule__ALSPreficed__ParamsAssignment_7_3() throws RecognitionException { | ||
28643 | |||
28644 | int stackSize = keepStackSize(); | ||
28645 | |||
28646 | try { | ||
28647 | // InternalAlloyLanguage.g:10155:1: ( ( ruleALSTerm ) ) | ||
28648 | // InternalAlloyLanguage.g:10156:1: ( ruleALSTerm ) | ||
28649 | { | ||
28650 | // InternalAlloyLanguage.g:10156:1: ( ruleALSTerm ) | ||
28651 | // InternalAlloyLanguage.g:10157:1: ruleALSTerm | ||
28652 | { | ||
28653 | if ( state.backtracking==0 ) { | ||
28654 | before(grammarAccess.getALSPreficedAccess().getParamsALSTermParserRuleCall_7_3_0()); | ||
28655 | } | ||
28656 | pushFollow(FOLLOW_2); | ||
28657 | ruleALSTerm(); | ||
28658 | |||
28659 | state._fsp--; | ||
28660 | if (state.failed) return ; | ||
28661 | if ( state.backtracking==0 ) { | ||
28662 | after(grammarAccess.getALSPreficedAccess().getParamsALSTermParserRuleCall_7_3_0()); | ||
28663 | } | ||
28664 | |||
28665 | } | ||
28666 | |||
28667 | |||
28668 | } | ||
28669 | |||
28670 | } | ||
28671 | catch (RecognitionException re) { | ||
28672 | reportError(re); | ||
28673 | recover(input,re); | ||
28674 | } | ||
28675 | finally { | ||
28676 | |||
28677 | restoreStackSize(stackSize); | ||
28678 | |||
28679 | } | ||
28680 | return ; | ||
28681 | } | ||
28682 | // $ANTLR end "rule__ALSPreficed__ParamsAssignment_7_3" | ||
28683 | |||
28684 | |||
28685 | // $ANTLR start "rule__ALSPreficed__ParamsAssignment_7_4_1" | ||
28686 | // InternalAlloyLanguage.g:10166:1: rule__ALSPreficed__ParamsAssignment_7_4_1 : ( ruleALSTerm ) ; | ||
28687 | public final void rule__ALSPreficed__ParamsAssignment_7_4_1() throws RecognitionException { | ||
28688 | |||
28689 | int stackSize = keepStackSize(); | ||
28690 | |||
28691 | try { | ||
28692 | // InternalAlloyLanguage.g:10170:1: ( ( ruleALSTerm ) ) | ||
28693 | // InternalAlloyLanguage.g:10171:1: ( ruleALSTerm ) | ||
28694 | { | ||
28695 | // InternalAlloyLanguage.g:10171:1: ( ruleALSTerm ) | ||
28696 | // InternalAlloyLanguage.g:10172:1: ruleALSTerm | ||
28697 | { | ||
28698 | if ( state.backtracking==0 ) { | ||
28699 | before(grammarAccess.getALSPreficedAccess().getParamsALSTermParserRuleCall_7_4_1_0()); | ||
28700 | } | ||
28701 | pushFollow(FOLLOW_2); | ||
28702 | ruleALSTerm(); | ||
28703 | |||
28704 | state._fsp--; | ||
28705 | if (state.failed) return ; | ||
28706 | if ( state.backtracking==0 ) { | ||
28707 | after(grammarAccess.getALSPreficedAccess().getParamsALSTermParserRuleCall_7_4_1_0()); | ||
28708 | } | ||
28709 | |||
28710 | } | ||
28711 | |||
28712 | |||
28713 | } | ||
28714 | |||
28715 | } | ||
28716 | catch (RecognitionException re) { | ||
28717 | reportError(re); | ||
28718 | recover(input,re); | ||
28719 | } | ||
28720 | finally { | ||
28721 | |||
28722 | restoreStackSize(stackSize); | ||
28723 | |||
28724 | } | ||
28725 | return ; | ||
28726 | } | ||
28727 | // $ANTLR end "rule__ALSPreficed__ParamsAssignment_7_4_1" | ||
28728 | |||
28729 | |||
28730 | // $ANTLR start "rule__ALSVariableDeclaration__NameAssignment_0" | ||
28731 | // InternalAlloyLanguage.g:10181:1: rule__ALSVariableDeclaration__NameAssignment_0 : ( ruleALSID ) ; | ||
28732 | public final void rule__ALSVariableDeclaration__NameAssignment_0() throws RecognitionException { | ||
28733 | |||
28734 | int stackSize = keepStackSize(); | ||
28735 | |||
28736 | try { | ||
28737 | // InternalAlloyLanguage.g:10185:1: ( ( ruleALSID ) ) | ||
28738 | // InternalAlloyLanguage.g:10186:1: ( ruleALSID ) | ||
28739 | { | ||
28740 | // InternalAlloyLanguage.g:10186:1: ( ruleALSID ) | ||
28741 | // InternalAlloyLanguage.g:10187:1: ruleALSID | ||
28742 | { | ||
28743 | if ( state.backtracking==0 ) { | ||
28744 | before(grammarAccess.getALSVariableDeclarationAccess().getNameALSIDParserRuleCall_0_0()); | ||
28745 | } | ||
28746 | pushFollow(FOLLOW_2); | ||
28747 | ruleALSID(); | ||
28748 | |||
28749 | state._fsp--; | ||
28750 | if (state.failed) return ; | ||
28751 | if ( state.backtracking==0 ) { | ||
28752 | after(grammarAccess.getALSVariableDeclarationAccess().getNameALSIDParserRuleCall_0_0()); | ||
28753 | } | ||
28754 | |||
28755 | } | ||
28756 | |||
28757 | |||
28758 | } | ||
28759 | |||
28760 | } | ||
28761 | catch (RecognitionException re) { | ||
28762 | reportError(re); | ||
28763 | recover(input,re); | ||
28764 | } | ||
28765 | finally { | ||
28766 | |||
28767 | restoreStackSize(stackSize); | ||
28768 | |||
28769 | } | ||
28770 | return ; | ||
28771 | } | ||
28772 | // $ANTLR end "rule__ALSVariableDeclaration__NameAssignment_0" | ||
28773 | |||
28774 | |||
28775 | // $ANTLR start "rule__ALSVariableDeclaration__RangeAssignment_2" | ||
28776 | // InternalAlloyLanguage.g:10196:1: rule__ALSVariableDeclaration__RangeAssignment_2 : ( ruleALSTerm ) ; | ||
28777 | public final void rule__ALSVariableDeclaration__RangeAssignment_2() throws RecognitionException { | ||
28778 | |||
28779 | int stackSize = keepStackSize(); | ||
28780 | |||
28781 | try { | ||
28782 | // InternalAlloyLanguage.g:10200:1: ( ( ruleALSTerm ) ) | ||
28783 | // InternalAlloyLanguage.g:10201:1: ( ruleALSTerm ) | ||
28784 | { | ||
28785 | // InternalAlloyLanguage.g:10201:1: ( ruleALSTerm ) | ||
28786 | // InternalAlloyLanguage.g:10202:1: ruleALSTerm | ||
28787 | { | ||
28788 | if ( state.backtracking==0 ) { | ||
28789 | before(grammarAccess.getALSVariableDeclarationAccess().getRangeALSTermParserRuleCall_2_0()); | ||
28790 | } | ||
28791 | pushFollow(FOLLOW_2); | ||
28792 | ruleALSTerm(); | ||
28793 | |||
28794 | state._fsp--; | ||
28795 | if (state.failed) return ; | ||
28796 | if ( state.backtracking==0 ) { | ||
28797 | after(grammarAccess.getALSVariableDeclarationAccess().getRangeALSTermParserRuleCall_2_0()); | ||
28798 | } | ||
28799 | |||
28800 | } | ||
28801 | |||
28802 | |||
28803 | } | ||
28804 | |||
28805 | } | ||
28806 | catch (RecognitionException re) { | ||
28807 | reportError(re); | ||
28808 | recover(input,re); | ||
28809 | } | ||
28810 | finally { | ||
28811 | |||
28812 | restoreStackSize(stackSize); | ||
28813 | |||
28814 | } | ||
28815 | return ; | ||
28816 | } | ||
28817 | // $ANTLR end "rule__ALSVariableDeclaration__RangeAssignment_2" | ||
28818 | |||
28819 | |||
28820 | // $ANTLR start "rule__ALSBasicRelationTerm__ReferredAssignment_5_1" | ||
28821 | // InternalAlloyLanguage.g:10211:1: rule__ALSBasicRelationTerm__ReferredAssignment_5_1 : ( ( RULE_ID ) ) ; | ||
28822 | public final void rule__ALSBasicRelationTerm__ReferredAssignment_5_1() throws RecognitionException { | ||
28823 | |||
28824 | int stackSize = keepStackSize(); | ||
28825 | |||
28826 | try { | ||
28827 | // InternalAlloyLanguage.g:10215:1: ( ( ( RULE_ID ) ) ) | ||
28828 | // InternalAlloyLanguage.g:10216:1: ( ( RULE_ID ) ) | ||
28829 | { | ||
28830 | // InternalAlloyLanguage.g:10216:1: ( ( RULE_ID ) ) | ||
28831 | // InternalAlloyLanguage.g:10217:1: ( RULE_ID ) | ||
28832 | { | ||
28833 | if ( state.backtracking==0 ) { | ||
28834 | before(grammarAccess.getALSBasicRelationTermAccess().getReferredALSRelationDeclarationCrossReference_5_1_0()); | ||
28835 | } | ||
28836 | // InternalAlloyLanguage.g:10218:1: ( RULE_ID ) | ||
28837 | // InternalAlloyLanguage.g:10219:1: RULE_ID | ||
28838 | { | ||
28839 | if ( state.backtracking==0 ) { | ||
28840 | before(grammarAccess.getALSBasicRelationTermAccess().getReferredALSRelationDeclarationIDTerminalRuleCall_5_1_0_1()); | ||
28841 | } | ||
28842 | match(input,RULE_ID,FOLLOW_2); if (state.failed) return ; | ||
28843 | if ( state.backtracking==0 ) { | ||
28844 | after(grammarAccess.getALSBasicRelationTermAccess().getReferredALSRelationDeclarationIDTerminalRuleCall_5_1_0_1()); | ||
28845 | } | ||
28846 | |||
28847 | } | ||
28848 | |||
28849 | if ( state.backtracking==0 ) { | ||
28850 | after(grammarAccess.getALSBasicRelationTermAccess().getReferredALSRelationDeclarationCrossReference_5_1_0()); | ||
28851 | } | ||
28852 | |||
28853 | } | ||
28854 | |||
28855 | |||
28856 | } | ||
28857 | |||
28858 | } | ||
28859 | catch (RecognitionException re) { | ||
28860 | reportError(re); | ||
28861 | recover(input,re); | ||
28862 | } | ||
28863 | finally { | ||
28864 | |||
28865 | restoreStackSize(stackSize); | ||
28866 | |||
28867 | } | ||
28868 | return ; | ||
28869 | } | ||
28870 | // $ANTLR end "rule__ALSBasicRelationTerm__ReferredAssignment_5_1" | ||
28871 | |||
28872 | |||
28873 | // $ANTLR start "rule__ALSBasicRelationTerm__ValueAssignment_6_1" | ||
28874 | // InternalAlloyLanguage.g:10230:1: rule__ALSBasicRelationTerm__ValueAssignment_6_1 : ( RULE_INT ) ; | ||
28875 | public final void rule__ALSBasicRelationTerm__ValueAssignment_6_1() throws RecognitionException { | ||
28876 | |||
28877 | int stackSize = keepStackSize(); | ||
28878 | |||
28879 | try { | ||
28880 | // InternalAlloyLanguage.g:10234:1: ( ( RULE_INT ) ) | ||
28881 | // InternalAlloyLanguage.g:10235:1: ( RULE_INT ) | ||
28882 | { | ||
28883 | // InternalAlloyLanguage.g:10235:1: ( RULE_INT ) | ||
28884 | // InternalAlloyLanguage.g:10236:1: RULE_INT | ||
28885 | { | ||
28886 | if ( state.backtracking==0 ) { | ||
28887 | before(grammarAccess.getALSBasicRelationTermAccess().getValueINTTerminalRuleCall_6_1_0()); | ||
28888 | } | ||
28889 | match(input,RULE_INT,FOLLOW_2); if (state.failed) return ; | ||
28890 | if ( state.backtracking==0 ) { | ||
28891 | after(grammarAccess.getALSBasicRelationTermAccess().getValueINTTerminalRuleCall_6_1_0()); | ||
28892 | } | ||
28893 | |||
28894 | } | ||
28895 | |||
28896 | |||
28897 | } | ||
28898 | |||
28899 | } | ||
28900 | catch (RecognitionException re) { | ||
28901 | reportError(re); | ||
28902 | recover(input,re); | ||
28903 | } | ||
28904 | finally { | ||
28905 | |||
28906 | restoreStackSize(stackSize); | ||
28907 | |||
28908 | } | ||
28909 | return ; | ||
28910 | } | ||
28911 | // $ANTLR end "rule__ALSBasicRelationTerm__ValueAssignment_6_1" | ||
28912 | |||
28913 | |||
28914 | // $ANTLR start "rule__ALSBasicRelationTerm__ValueAssignment_7_1" | ||
28915 | // InternalAlloyLanguage.g:10245:1: rule__ALSBasicRelationTerm__ValueAssignment_7_1 : ( RULE_STRING ) ; | ||
28916 | public final void rule__ALSBasicRelationTerm__ValueAssignment_7_1() throws RecognitionException { | ||
28917 | |||
28918 | int stackSize = keepStackSize(); | ||
28919 | |||
28920 | try { | ||
28921 | // InternalAlloyLanguage.g:10249:1: ( ( RULE_STRING ) ) | ||
28922 | // InternalAlloyLanguage.g:10250:1: ( RULE_STRING ) | ||
28923 | { | ||
28924 | // InternalAlloyLanguage.g:10250:1: ( RULE_STRING ) | ||
28925 | // InternalAlloyLanguage.g:10251:1: RULE_STRING | ||
28926 | { | ||
28927 | if ( state.backtracking==0 ) { | ||
28928 | before(grammarAccess.getALSBasicRelationTermAccess().getValueSTRINGTerminalRuleCall_7_1_0()); | ||
28929 | } | ||
28930 | match(input,RULE_STRING,FOLLOW_2); if (state.failed) return ; | ||
28931 | if ( state.backtracking==0 ) { | ||
28932 | after(grammarAccess.getALSBasicRelationTermAccess().getValueSTRINGTerminalRuleCall_7_1_0()); | ||
28933 | } | ||
28934 | |||
28935 | } | ||
28936 | |||
28937 | |||
28938 | } | ||
28939 | |||
28940 | } | ||
28941 | catch (RecognitionException re) { | ||
28942 | reportError(re); | ||
28943 | recover(input,re); | ||
28944 | } | ||
28945 | finally { | ||
28946 | |||
28947 | restoreStackSize(stackSize); | ||
28948 | |||
28949 | } | ||
28950 | return ; | ||
28951 | } | ||
28952 | // $ANTLR end "rule__ALSBasicRelationTerm__ValueAssignment_7_1" | ||
28953 | |||
28954 | |||
28955 | // $ANTLR start "rule__ALSRunCommand__TypeScopesAssignment_4_1" | ||
28956 | // InternalAlloyLanguage.g:10260:1: rule__ALSRunCommand__TypeScopesAssignment_4_1 : ( ruleALSTypeScope ) ; | ||
28957 | public final void rule__ALSRunCommand__TypeScopesAssignment_4_1() throws RecognitionException { | ||
28958 | |||
28959 | int stackSize = keepStackSize(); | ||
28960 | |||
28961 | try { | ||
28962 | // InternalAlloyLanguage.g:10264:1: ( ( ruleALSTypeScope ) ) | ||
28963 | // InternalAlloyLanguage.g:10265:1: ( ruleALSTypeScope ) | ||
28964 | { | ||
28965 | // InternalAlloyLanguage.g:10265:1: ( ruleALSTypeScope ) | ||
28966 | // InternalAlloyLanguage.g:10266:1: ruleALSTypeScope | ||
28967 | { | ||
28968 | if ( state.backtracking==0 ) { | ||
28969 | before(grammarAccess.getALSRunCommandAccess().getTypeScopesALSTypeScopeParserRuleCall_4_1_0()); | ||
28970 | } | ||
28971 | pushFollow(FOLLOW_2); | ||
28972 | ruleALSTypeScope(); | ||
28973 | |||
28974 | state._fsp--; | ||
28975 | if (state.failed) return ; | ||
28976 | if ( state.backtracking==0 ) { | ||
28977 | after(grammarAccess.getALSRunCommandAccess().getTypeScopesALSTypeScopeParserRuleCall_4_1_0()); | ||
28978 | } | ||
28979 | |||
28980 | } | ||
28981 | |||
28982 | |||
28983 | } | ||
28984 | |||
28985 | } | ||
28986 | catch (RecognitionException re) { | ||
28987 | reportError(re); | ||
28988 | recover(input,re); | ||
28989 | } | ||
28990 | finally { | ||
28991 | |||
28992 | restoreStackSize(stackSize); | ||
28993 | |||
28994 | } | ||
28995 | return ; | ||
28996 | } | ||
28997 | // $ANTLR end "rule__ALSRunCommand__TypeScopesAssignment_4_1" | ||
28998 | |||
28999 | |||
29000 | // $ANTLR start "rule__ALSRunCommand__TypeScopesAssignment_4_2_1" | ||
29001 | // InternalAlloyLanguage.g:10275:1: rule__ALSRunCommand__TypeScopesAssignment_4_2_1 : ( ruleALSTypeScope ) ; | ||
29002 | public final void rule__ALSRunCommand__TypeScopesAssignment_4_2_1() throws RecognitionException { | ||
29003 | |||
29004 | int stackSize = keepStackSize(); | ||
29005 | |||
29006 | try { | ||
29007 | // InternalAlloyLanguage.g:10279:1: ( ( ruleALSTypeScope ) ) | ||
29008 | // InternalAlloyLanguage.g:10280:1: ( ruleALSTypeScope ) | ||
29009 | { | ||
29010 | // InternalAlloyLanguage.g:10280:1: ( ruleALSTypeScope ) | ||
29011 | // InternalAlloyLanguage.g:10281:1: ruleALSTypeScope | ||
29012 | { | ||
29013 | if ( state.backtracking==0 ) { | ||
29014 | before(grammarAccess.getALSRunCommandAccess().getTypeScopesALSTypeScopeParserRuleCall_4_2_1_0()); | ||
29015 | } | ||
29016 | pushFollow(FOLLOW_2); | ||
29017 | ruleALSTypeScope(); | ||
29018 | |||
29019 | state._fsp--; | ||
29020 | if (state.failed) return ; | ||
29021 | if ( state.backtracking==0 ) { | ||
29022 | after(grammarAccess.getALSRunCommandAccess().getTypeScopesALSTypeScopeParserRuleCall_4_2_1_0()); | ||
29023 | } | ||
29024 | |||
29025 | } | ||
29026 | |||
29027 | |||
29028 | } | ||
29029 | |||
29030 | } | ||
29031 | catch (RecognitionException re) { | ||
29032 | reportError(re); | ||
29033 | recover(input,re); | ||
29034 | } | ||
29035 | finally { | ||
29036 | |||
29037 | restoreStackSize(stackSize); | ||
29038 | |||
29039 | } | ||
29040 | return ; | ||
29041 | } | ||
29042 | // $ANTLR end "rule__ALSRunCommand__TypeScopesAssignment_4_2_1" | ||
29043 | |||
29044 | |||
29045 | // $ANTLR start "rule__ALSSigScope__ExactlyAssignment_0" | ||
29046 | // InternalAlloyLanguage.g:10290:1: rule__ALSSigScope__ExactlyAssignment_0 : ( ( 'exactly' ) ) ; | ||
29047 | public final void rule__ALSSigScope__ExactlyAssignment_0() throws RecognitionException { | ||
29048 | |||
29049 | int stackSize = keepStackSize(); | ||
29050 | |||
29051 | try { | ||
29052 | // InternalAlloyLanguage.g:10294:1: ( ( ( 'exactly' ) ) ) | ||
29053 | // InternalAlloyLanguage.g:10295:1: ( ( 'exactly' ) ) | ||
29054 | { | ||
29055 | // InternalAlloyLanguage.g:10295:1: ( ( 'exactly' ) ) | ||
29056 | // InternalAlloyLanguage.g:10296:1: ( 'exactly' ) | ||
29057 | { | ||
29058 | if ( state.backtracking==0 ) { | ||
29059 | before(grammarAccess.getALSSigScopeAccess().getExactlyExactlyKeyword_0_0()); | ||
29060 | } | ||
29061 | // InternalAlloyLanguage.g:10297:1: ( 'exactly' ) | ||
29062 | // InternalAlloyLanguage.g:10298:1: 'exactly' | ||
29063 | { | ||
29064 | if ( state.backtracking==0 ) { | ||
29065 | before(grammarAccess.getALSSigScopeAccess().getExactlyExactlyKeyword_0_0()); | ||
29066 | } | ||
29067 | match(input,74,FOLLOW_2); if (state.failed) return ; | ||
29068 | if ( state.backtracking==0 ) { | ||
29069 | after(grammarAccess.getALSSigScopeAccess().getExactlyExactlyKeyword_0_0()); | ||
29070 | } | ||
29071 | |||
29072 | } | ||
29073 | |||
29074 | if ( state.backtracking==0 ) { | ||
29075 | after(grammarAccess.getALSSigScopeAccess().getExactlyExactlyKeyword_0_0()); | ||
29076 | } | ||
29077 | |||
29078 | } | ||
29079 | |||
29080 | |||
29081 | } | ||
29082 | |||
29083 | } | ||
29084 | catch (RecognitionException re) { | ||
29085 | reportError(re); | ||
29086 | recover(input,re); | ||
29087 | } | ||
29088 | finally { | ||
29089 | |||
29090 | restoreStackSize(stackSize); | ||
29091 | |||
29092 | } | ||
29093 | return ; | ||
29094 | } | ||
29095 | // $ANTLR end "rule__ALSSigScope__ExactlyAssignment_0" | ||
29096 | |||
29097 | |||
29098 | // $ANTLR start "rule__ALSSigScope__NumberAssignment_1" | ||
29099 | // InternalAlloyLanguage.g:10313:1: rule__ALSSigScope__NumberAssignment_1 : ( RULE_INT ) ; | ||
29100 | public final void rule__ALSSigScope__NumberAssignment_1() throws RecognitionException { | ||
29101 | |||
29102 | int stackSize = keepStackSize(); | ||
29103 | |||
29104 | try { | ||
29105 | // InternalAlloyLanguage.g:10317:1: ( ( RULE_INT ) ) | ||
29106 | // InternalAlloyLanguage.g:10318:1: ( RULE_INT ) | ||
29107 | { | ||
29108 | // InternalAlloyLanguage.g:10318:1: ( RULE_INT ) | ||
29109 | // InternalAlloyLanguage.g:10319:1: RULE_INT | ||
29110 | { | ||
29111 | if ( state.backtracking==0 ) { | ||
29112 | before(grammarAccess.getALSSigScopeAccess().getNumberINTTerminalRuleCall_1_0()); | ||
29113 | } | ||
29114 | match(input,RULE_INT,FOLLOW_2); if (state.failed) return ; | ||
29115 | if ( state.backtracking==0 ) { | ||
29116 | after(grammarAccess.getALSSigScopeAccess().getNumberINTTerminalRuleCall_1_0()); | ||
29117 | } | ||
29118 | |||
29119 | } | ||
29120 | |||
29121 | |||
29122 | } | ||
29123 | |||
29124 | } | ||
29125 | catch (RecognitionException re) { | ||
29126 | reportError(re); | ||
29127 | recover(input,re); | ||
29128 | } | ||
29129 | finally { | ||
29130 | |||
29131 | restoreStackSize(stackSize); | ||
29132 | |||
29133 | } | ||
29134 | return ; | ||
29135 | } | ||
29136 | // $ANTLR end "rule__ALSSigScope__NumberAssignment_1" | ||
29137 | |||
29138 | |||
29139 | // $ANTLR start "rule__ALSSigScope__TypeAssignment_2" | ||
29140 | // InternalAlloyLanguage.g:10328:1: rule__ALSSigScope__TypeAssignment_2 : ( ( RULE_ID ) ) ; | ||
29141 | public final void rule__ALSSigScope__TypeAssignment_2() throws RecognitionException { | ||
29142 | |||
29143 | int stackSize = keepStackSize(); | ||
29144 | |||
29145 | try { | ||
29146 | // InternalAlloyLanguage.g:10332:1: ( ( ( RULE_ID ) ) ) | ||
29147 | // InternalAlloyLanguage.g:10333:1: ( ( RULE_ID ) ) | ||
29148 | { | ||
29149 | // InternalAlloyLanguage.g:10333:1: ( ( RULE_ID ) ) | ||
29150 | // InternalAlloyLanguage.g:10334:1: ( RULE_ID ) | ||
29151 | { | ||
29152 | if ( state.backtracking==0 ) { | ||
29153 | before(grammarAccess.getALSSigScopeAccess().getTypeALSSignatureDeclarationCrossReference_2_0()); | ||
29154 | } | ||
29155 | // InternalAlloyLanguage.g:10335:1: ( RULE_ID ) | ||
29156 | // InternalAlloyLanguage.g:10336:1: RULE_ID | ||
29157 | { | ||
29158 | if ( state.backtracking==0 ) { | ||
29159 | before(grammarAccess.getALSSigScopeAccess().getTypeALSSignatureDeclarationIDTerminalRuleCall_2_0_1()); | ||
29160 | } | ||
29161 | match(input,RULE_ID,FOLLOW_2); if (state.failed) return ; | ||
29162 | if ( state.backtracking==0 ) { | ||
29163 | after(grammarAccess.getALSSigScopeAccess().getTypeALSSignatureDeclarationIDTerminalRuleCall_2_0_1()); | ||
29164 | } | ||
29165 | |||
29166 | } | ||
29167 | |||
29168 | if ( state.backtracking==0 ) { | ||
29169 | after(grammarAccess.getALSSigScopeAccess().getTypeALSSignatureDeclarationCrossReference_2_0()); | ||
29170 | } | ||
29171 | |||
29172 | } | ||
29173 | |||
29174 | |||
29175 | } | ||
29176 | |||
29177 | } | ||
29178 | catch (RecognitionException re) { | ||
29179 | reportError(re); | ||
29180 | recover(input,re); | ||
29181 | } | ||
29182 | finally { | ||
29183 | |||
29184 | restoreStackSize(stackSize); | ||
29185 | |||
29186 | } | ||
29187 | return ; | ||
29188 | } | ||
29189 | // $ANTLR end "rule__ALSSigScope__TypeAssignment_2" | ||
29190 | |||
29191 | |||
29192 | // $ANTLR start "rule__ALSIntScope__NumberAssignment_0" | ||
29193 | // InternalAlloyLanguage.g:10347:1: rule__ALSIntScope__NumberAssignment_0 : ( RULE_INT ) ; | ||
29194 | public final void rule__ALSIntScope__NumberAssignment_0() throws RecognitionException { | ||
29195 | |||
29196 | int stackSize = keepStackSize(); | ||
29197 | |||
29198 | try { | ||
29199 | // InternalAlloyLanguage.g:10351:1: ( ( RULE_INT ) ) | ||
29200 | // InternalAlloyLanguage.g:10352:1: ( RULE_INT ) | ||
29201 | { | ||
29202 | // InternalAlloyLanguage.g:10352:1: ( RULE_INT ) | ||
29203 | // InternalAlloyLanguage.g:10353:1: RULE_INT | ||
29204 | { | ||
29205 | if ( state.backtracking==0 ) { | ||
29206 | before(grammarAccess.getALSIntScopeAccess().getNumberINTTerminalRuleCall_0_0()); | ||
29207 | } | ||
29208 | match(input,RULE_INT,FOLLOW_2); if (state.failed) return ; | ||
29209 | if ( state.backtracking==0 ) { | ||
29210 | after(grammarAccess.getALSIntScopeAccess().getNumberINTTerminalRuleCall_0_0()); | ||
29211 | } | ||
29212 | |||
29213 | } | ||
29214 | |||
29215 | |||
29216 | } | ||
29217 | |||
29218 | } | ||
29219 | catch (RecognitionException re) { | ||
29220 | reportError(re); | ||
29221 | recover(input,re); | ||
29222 | } | ||
29223 | finally { | ||
29224 | |||
29225 | restoreStackSize(stackSize); | ||
29226 | |||
29227 | } | ||
29228 | return ; | ||
29229 | } | ||
29230 | // $ANTLR end "rule__ALSIntScope__NumberAssignment_0" | ||
29231 | |||
29232 | |||
29233 | // $ANTLR start "rule__ALSStringScope__NumberAssignment_1" | ||
29234 | // InternalAlloyLanguage.g:10362:1: rule__ALSStringScope__NumberAssignment_1 : ( RULE_INT ) ; | ||
29235 | public final void rule__ALSStringScope__NumberAssignment_1() throws RecognitionException { | ||
29236 | |||
29237 | int stackSize = keepStackSize(); | ||
29238 | |||
29239 | try { | ||
29240 | // InternalAlloyLanguage.g:10366:1: ( ( RULE_INT ) ) | ||
29241 | // InternalAlloyLanguage.g:10367:1: ( RULE_INT ) | ||
29242 | { | ||
29243 | // InternalAlloyLanguage.g:10367:1: ( RULE_INT ) | ||
29244 | // InternalAlloyLanguage.g:10368:1: RULE_INT | ||
29245 | { | ||
29246 | if ( state.backtracking==0 ) { | ||
29247 | before(grammarAccess.getALSStringScopeAccess().getNumberINTTerminalRuleCall_1_0()); | ||
29248 | } | ||
29249 | match(input,RULE_INT,FOLLOW_2); if (state.failed) return ; | ||
29250 | if ( state.backtracking==0 ) { | ||
29251 | after(grammarAccess.getALSStringScopeAccess().getNumberINTTerminalRuleCall_1_0()); | ||
29252 | } | ||
29253 | |||
29254 | } | ||
29255 | |||
29256 | |||
29257 | } | ||
29258 | |||
29259 | } | ||
29260 | catch (RecognitionException re) { | ||
29261 | reportError(re); | ||
29262 | recover(input,re); | ||
29263 | } | ||
29264 | finally { | ||
29265 | |||
29266 | restoreStackSize(stackSize); | ||
29267 | |||
29268 | } | ||
29269 | return ; | ||
29270 | } | ||
29271 | // $ANTLR end "rule__ALSStringScope__NumberAssignment_1" | ||
29272 | |||
29273 | // $ANTLR start synpred81_InternalAlloyLanguage | ||
29274 | public final void synpred81_InternalAlloyLanguage_fragment() throws RecognitionException { | ||
29275 | // InternalAlloyLanguage.g:9039:2: ( rule__ALSSignatureBody__UnorderedGroup_0__0 ) | ||
29276 | // InternalAlloyLanguage.g:9039:2: rule__ALSSignatureBody__UnorderedGroup_0__0 | ||
29277 | { | ||
29278 | pushFollow(FOLLOW_2); | ||
29279 | rule__ALSSignatureBody__UnorderedGroup_0__0(); | ||
29280 | |||
29281 | state._fsp--; | ||
29282 | if (state.failed) return ; | ||
29283 | |||
29284 | } | ||
29285 | } | ||
29286 | // $ANTLR end synpred81_InternalAlloyLanguage | ||
29287 | |||
29288 | // $ANTLR start synpred82_InternalAlloyLanguage | ||
29289 | public final void synpred82_InternalAlloyLanguage_fragment() throws RecognitionException { | ||
29290 | // InternalAlloyLanguage.g:9057:4: ( ({...}? => ( ( ( rule__ALSSignatureBody__MultiplicityAssignment_0_0 ) ) ) ) ) | ||
29291 | // InternalAlloyLanguage.g:9057:4: ({...}? => ( ( ( rule__ALSSignatureBody__MultiplicityAssignment_0_0 ) ) ) ) | ||
29292 | { | ||
29293 | // InternalAlloyLanguage.g:9057:4: ({...}? => ( ( ( rule__ALSSignatureBody__MultiplicityAssignment_0_0 ) ) ) ) | ||
29294 | // InternalAlloyLanguage.g:9058:5: {...}? => ( ( ( rule__ALSSignatureBody__MultiplicityAssignment_0_0 ) ) ) | ||
29295 | { | ||
29296 | if ( ! getUnorderedGroupHelper().canSelect(grammarAccess.getALSSignatureBodyAccess().getUnorderedGroup_0(), 0) ) { | ||
29297 | if (state.backtracking>0) {state.failed=true; return ;} | ||
29298 | throw new FailedPredicateException(input, "synpred82_InternalAlloyLanguage", "getUnorderedGroupHelper().canSelect(grammarAccess.getALSSignatureBodyAccess().getUnorderedGroup_0(), 0)"); | ||
29299 | } | ||
29300 | // InternalAlloyLanguage.g:9058:113: ( ( ( rule__ALSSignatureBody__MultiplicityAssignment_0_0 ) ) ) | ||
29301 | // InternalAlloyLanguage.g:9059:6: ( ( rule__ALSSignatureBody__MultiplicityAssignment_0_0 ) ) | ||
29302 | { | ||
29303 | getUnorderedGroupHelper().select(grammarAccess.getALSSignatureBodyAccess().getUnorderedGroup_0(), 0); | ||
29304 | // InternalAlloyLanguage.g:9065:6: ( ( rule__ALSSignatureBody__MultiplicityAssignment_0_0 ) ) | ||
29305 | // InternalAlloyLanguage.g:9067:7: ( rule__ALSSignatureBody__MultiplicityAssignment_0_0 ) | ||
29306 | { | ||
29307 | if ( state.backtracking==0 ) { | ||
29308 | before(grammarAccess.getALSSignatureBodyAccess().getMultiplicityAssignment_0_0()); | ||
29309 | } | ||
29310 | // InternalAlloyLanguage.g:9068:7: ( rule__ALSSignatureBody__MultiplicityAssignment_0_0 ) | ||
29311 | // InternalAlloyLanguage.g:9068:8: rule__ALSSignatureBody__MultiplicityAssignment_0_0 | ||
29312 | { | ||
29313 | pushFollow(FOLLOW_2); | ||
29314 | rule__ALSSignatureBody__MultiplicityAssignment_0_0(); | ||
29315 | |||
29316 | state._fsp--; | ||
29317 | if (state.failed) return ; | ||
29318 | |||
29319 | } | ||
29320 | |||
29321 | |||
29322 | } | ||
29323 | |||
29324 | |||
29325 | } | ||
29326 | |||
29327 | |||
29328 | } | ||
29329 | |||
29330 | |||
29331 | } | ||
29332 | } | ||
29333 | // $ANTLR end synpred82_InternalAlloyLanguage | ||
29334 | |||
29335 | // $ANTLR start synpred83_InternalAlloyLanguage | ||
29336 | public final void synpred83_InternalAlloyLanguage_fragment() throws RecognitionException { | ||
29337 | // InternalAlloyLanguage.g:9106:2: ( rule__ALSSignatureBody__UnorderedGroup_0__1 ) | ||
29338 | // InternalAlloyLanguage.g:9106:2: rule__ALSSignatureBody__UnorderedGroup_0__1 | ||
29339 | { | ||
29340 | pushFollow(FOLLOW_2); | ||
29341 | rule__ALSSignatureBody__UnorderedGroup_0__1(); | ||
29342 | |||
29343 | state._fsp--; | ||
29344 | if (state.failed) return ; | ||
29345 | |||
29346 | } | ||
29347 | } | ||
29348 | // $ANTLR end synpred83_InternalAlloyLanguage | ||
29349 | |||
29350 | // Delegated rules | ||
29351 | |||
29352 | public final boolean synpred82_InternalAlloyLanguage() { | ||
29353 | state.backtracking++; | ||
29354 | int start = input.mark(); | ||
29355 | try { | ||
29356 | synpred82_InternalAlloyLanguage_fragment(); // can never throw exception | ||
29357 | } catch (RecognitionException re) { | ||
29358 | System.err.println("impossible: "+re); | ||
29359 | } | ||
29360 | boolean success = !state.failed; | ||
29361 | input.rewind(start); | ||
29362 | state.backtracking--; | ||
29363 | state.failed=false; | ||
29364 | return success; | ||
29365 | } | ||
29366 | public final boolean synpred81_InternalAlloyLanguage() { | ||
29367 | state.backtracking++; | ||
29368 | int start = input.mark(); | ||
29369 | try { | ||
29370 | synpred81_InternalAlloyLanguage_fragment(); // can never throw exception | ||
29371 | } catch (RecognitionException re) { | ||
29372 | System.err.println("impossible: "+re); | ||
29373 | } | ||
29374 | boolean success = !state.failed; | ||
29375 | input.rewind(start); | ||
29376 | state.backtracking--; | ||
29377 | state.failed=false; | ||
29378 | return success; | ||
29379 | } | ||
29380 | public final boolean synpred83_InternalAlloyLanguage() { | ||
29381 | state.backtracking++; | ||
29382 | int start = input.mark(); | ||
29383 | try { | ||
29384 | synpred83_InternalAlloyLanguage_fragment(); // can never throw exception | ||
29385 | } catch (RecognitionException re) { | ||
29386 | System.err.println("impossible: "+re); | ||
29387 | } | ||
29388 | boolean success = !state.failed; | ||
29389 | input.rewind(start); | ||
29390 | state.backtracking--; | ||
29391 | state.failed=false; | ||
29392 | return success; | ||
29393 | } | ||
29394 | |||
29395 | |||
29396 | protected DFA10 dfa10 = new DFA10(this); | ||
29397 | protected DFA24 dfa24 = new DFA24(this); | ||
29398 | static final String dfa_1s = "\13\uffff"; | ||
29399 | static final String dfa_2s = "\10\uffff\1\12\2\uffff"; | ||
29400 | static final String dfa_3s = "\1\4\7\uffff\1\13\2\uffff"; | ||
29401 | static final String dfa_4s = "\1\106\7\uffff\1\107\2\uffff"; | ||
29402 | static final String dfa_5s = "\1\uffff\1\1\1\2\1\3\1\4\1\5\1\6\1\7\1\uffff\1\10\1\11"; | ||
29403 | static final String dfa_6s = "\13\uffff}>"; | ||
29404 | static final String[] dfa_7s = { | ||
29405 | "\1\10\2\12\14\uffff\2\1\6\uffff\5\11\31\uffff\1\6\2\uffff\1\2\1\3\1\4\1\5\1\7\6\12", | ||
29406 | "", | ||
29407 | "", | ||
29408 | "", | ||
29409 | "", | ||
29410 | "", | ||
29411 | "", | ||
29412 | "", | ||
29413 | "\10\12\2\uffff\6\12\6\uffff\3\12\2\uffff\2\12\2\uffff\1\11\1\12\2\uffff\16\12\13\uffff\1\12", | ||
29414 | "", | ||
29415 | "" | ||
29416 | }; | ||
29417 | |||
29418 | static final short[] dfa_1 = DFA.unpackEncodedString(dfa_1s); | ||
29419 | static final short[] dfa_2 = DFA.unpackEncodedString(dfa_2s); | ||
29420 | static final char[] dfa_3 = DFA.unpackEncodedStringToUnsignedChars(dfa_3s); | ||
29421 | static final char[] dfa_4 = DFA.unpackEncodedStringToUnsignedChars(dfa_4s); | ||
29422 | static final short[] dfa_5 = DFA.unpackEncodedString(dfa_5s); | ||
29423 | static final short[] dfa_6 = DFA.unpackEncodedString(dfa_6s); | ||
29424 | static final short[][] dfa_7 = unpackEncodedStringArray(dfa_7s); | ||
29425 | |||
29426 | class DFA10 extends DFA { | ||
29427 | |||
29428 | public DFA10(BaseRecognizer recognizer) { | ||
29429 | this.recognizer = recognizer; | ||
29430 | this.decisionNumber = 10; | ||
29431 | this.eot = dfa_1; | ||
29432 | this.eof = dfa_2; | ||
29433 | this.min = dfa_3; | ||
29434 | this.max = dfa_4; | ||
29435 | this.accept = dfa_5; | ||
29436 | this.special = dfa_6; | ||
29437 | this.transition = dfa_7; | ||
29438 | } | ||
29439 | public String getDescription() { | ||
29440 | return "1319:1: rule__ALSPreficed__Alternatives : ( ( ( rule__ALSPreficed__Group_0__0 ) ) | ( ( rule__ALSPreficed__Group_1__0 ) ) | ( ( rule__ALSPreficed__Group_2__0 ) ) | ( ( rule__ALSPreficed__Group_3__0 ) ) | ( ( rule__ALSPreficed__Group_4__0 ) ) | ( ( rule__ALSPreficed__Group_5__0 ) ) | ( ( rule__ALSPreficed__Group_6__0 ) ) | ( ( rule__ALSPreficed__Group_7__0 ) ) | ( ruleALSBasicRelationTerm ) );"; | ||
29441 | } | ||
29442 | } | ||
29443 | static final String dfa_8s = "\12\uffff"; | ||
29444 | static final String dfa_9s = "\11\uffff\1\10"; | ||
29445 | static final String dfa_10s = "\7\4\2\uffff\1\13"; | ||
29446 | static final String dfa_11s = "\1\106\6\114\2\uffff\1\73"; | ||
29447 | static final String dfa_12s = "\7\uffff\1\2\1\1\1\uffff"; | ||
29448 | static final String dfa_13s = "\12\uffff}>"; | ||
29449 | static final String[] dfa_14s = { | ||
29450 | "\3\7\14\uffff\2\7\1\1\1\2\1\3\1\4\1\5\1\6\5\7\31\uffff\1\7\2\uffff\13\7", | ||
29451 | "\1\11\2\10\14\uffff\15\10\31\uffff\1\10\2\uffff\13\10\5\uffff\1\7", | ||
29452 | "\1\11\2\10\14\uffff\15\10\31\uffff\1\10\2\uffff\13\10\5\uffff\1\7", | ||
29453 | "\1\11\2\10\14\uffff\15\10\31\uffff\1\10\2\uffff\13\10\5\uffff\1\7", | ||
29454 | "\1\11\2\10\14\uffff\15\10\31\uffff\1\10\2\uffff\13\10\5\uffff\1\7", | ||
29455 | "\1\11\2\10\14\uffff\15\10\31\uffff\1\10\2\uffff\13\10\5\uffff\1\7", | ||
29456 | "\1\11\2\10\14\uffff\15\10\31\uffff\1\10\2\uffff\13\10\5\uffff\1\7", | ||
29457 | "", | ||
29458 | "", | ||
29459 | "\10\10\2\uffff\6\10\7\uffff\2\10\2\uffff\2\10\1\7\1\uffff\1\10\4\uffff\15\10" | ||
29460 | }; | ||
29461 | |||
29462 | static final short[] dfa_8 = DFA.unpackEncodedString(dfa_8s); | ||
29463 | static final short[] dfa_9 = DFA.unpackEncodedString(dfa_9s); | ||
29464 | static final char[] dfa_10 = DFA.unpackEncodedStringToUnsignedChars(dfa_10s); | ||
29465 | static final char[] dfa_11 = DFA.unpackEncodedStringToUnsignedChars(dfa_11s); | ||
29466 | static final short[] dfa_12 = DFA.unpackEncodedString(dfa_12s); | ||
29467 | static final short[] dfa_13 = DFA.unpackEncodedString(dfa_13s); | ||
29468 | static final short[][] dfa_14 = unpackEncodedStringArray(dfa_14s); | ||
29469 | |||
29470 | class DFA24 extends DFA { | ||
29471 | |||
29472 | public DFA24(BaseRecognizer recognizer) { | ||
29473 | this.recognizer = recognizer; | ||
29474 | this.decisionNumber = 24; | ||
29475 | this.eot = dfa_8; | ||
29476 | this.eof = dfa_9; | ||
29477 | this.min = dfa_10; | ||
29478 | this.max = dfa_11; | ||
29479 | this.accept = dfa_12; | ||
29480 | this.special = dfa_13; | ||
29481 | this.transition = dfa_14; | ||
29482 | } | ||
29483 | public String getDescription() { | ||
29484 | return "2683:1: ( rule__ALSFieldDeclaration__MultiplicityAssignment_2 )?"; | ||
29485 | } | ||
29486 | } | ||
29487 | |||
29488 | |||
29489 | public static final BitSet FOLLOW_1 = new BitSet(new long[]{0x0000000000000000L}); | ||
29490 | public static final BitSet FOLLOW_2 = new BitSet(new long[]{0x0000000000000002L}); | ||
29491 | public static final BitSet FOLLOW_3 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000100L}); | ||
29492 | public static final BitSet FOLLOW_4 = new BitSet(new long[]{0x0000320107E00002L,0x0000000000000800L}); | ||
29493 | public static final BitSet FOLLOW_5 = new BitSet(new long[]{0x0000000000000010L}); | ||
29494 | public static final BitSet FOLLOW_6 = new BitSet(new long[]{0x0000000200000000L}); | ||
29495 | public static final BitSet FOLLOW_7 = new BitSet(new long[]{0x0000000C00000000L}); | ||
29496 | public static final BitSet FOLLOW_8 = new BitSet(new long[]{0x0000000800000002L}); | ||
29497 | public static final BitSet FOLLOW_9 = new BitSet(new long[]{0x0000001000000000L}); | ||
29498 | public static final BitSet FOLLOW_10 = new BitSet(new long[]{0x0000006A00000000L}); | ||
29499 | public static final BitSet FOLLOW_11 = new BitSet(new long[]{0x0000000400000010L}); | ||
29500 | public static final BitSet FOLLOW_12 = new BitSet(new long[]{0x0000008000000000L}); | ||
29501 | public static final BitSet FOLLOW_13 = new BitSet(new long[]{0x0000008000000002L}); | ||
29502 | public static final BitSet FOLLOW_14 = new BitSet(new long[]{0x0000000800000000L}); | ||
29503 | public static final BitSet FOLLOW_15 = new BitSet(new long[]{0x0000010000000000L}); | ||
29504 | public static final BitSet FOLLOW_16 = new BitSet(new long[]{0xF2000000FFF80070L,0x000000000000007FL}); | ||
29505 | public static final BitSet FOLLOW_17 = new BitSet(new long[]{0x0000040000000000L}); | ||
29506 | public static final BitSet FOLLOW_18 = new BitSet(new long[]{0x0000080800000000L}); | ||
29507 | public static final BitSet FOLLOW_19 = new BitSet(new long[]{0x0000000400000000L}); | ||
29508 | public static final BitSet FOLLOW_20 = new BitSet(new long[]{0x0000320107E00000L,0x0000000000000800L}); | ||
29509 | public static final BitSet FOLLOW_21 = new BitSet(new long[]{0x0000000200000010L}); | ||
29510 | public static final BitSet FOLLOW_22 = new BitSet(new long[]{0x0000000007E00000L}); | ||
29511 | public static final BitSet FOLLOW_23 = new BitSet(new long[]{0x0000000000000010L,0x0000000000001000L}); | ||
29512 | public static final BitSet FOLLOW_24 = new BitSet(new long[]{0x0000000A00000000L}); | ||
29513 | public static final BitSet FOLLOW_25 = new BitSet(new long[]{0x0000000000001800L}); | ||
29514 | public static final BitSet FOLLOW_26 = new BitSet(new long[]{0x0000000000006000L}); | ||
29515 | public static final BitSet FOLLOW_27 = new BitSet(new long[]{0x0000000000018000L}); | ||
29516 | public static final BitSet FOLLOW_28 = new BitSet(new long[]{0x0000400000000000L}); | ||
29517 | public static final BitSet FOLLOW_29 = new BitSet(new long[]{0x0000000000060000L}); | ||
29518 | public static final BitSet FOLLOW_30 = new BitSet(new long[]{0x001F804000000000L}); | ||
29519 | public static final BitSet FOLLOW_31 = new BitSet(new long[]{0x0000800000000000L}); | ||
29520 | public static final BitSet FOLLOW_32 = new BitSet(new long[]{0x0001000000000000L}); | ||
29521 | public static final BitSet FOLLOW_33 = new BitSet(new long[]{0x0000004000000000L}); | ||
29522 | public static final BitSet FOLLOW_34 = new BitSet(new long[]{0x0002000000000000L}); | ||
29523 | public static final BitSet FOLLOW_35 = new BitSet(new long[]{0x0004000000000000L}); | ||
29524 | public static final BitSet FOLLOW_36 = new BitSet(new long[]{0x0008000000000000L}); | ||
29525 | public static final BitSet FOLLOW_37 = new BitSet(new long[]{0x0020000000000000L}); | ||
29526 | public static final BitSet FOLLOW_38 = new BitSet(new long[]{0x0040000000000000L}); | ||
29527 | public static final BitSet FOLLOW_39 = new BitSet(new long[]{0x0080000000000000L}); | ||
29528 | public static final BitSet FOLLOW_40 = new BitSet(new long[]{0x0100000000000000L}); | ||
29529 | public static final BitSet FOLLOW_41 = new BitSet(new long[]{0x0100000000000002L}); | ||
29530 | public static final BitSet FOLLOW_42 = new BitSet(new long[]{0x0200000000000000L}); | ||
29531 | public static final BitSet FOLLOW_43 = new BitSet(new long[]{0x0200000000000002L}); | ||
29532 | public static final BitSet FOLLOW_44 = new BitSet(new long[]{0x0400000000000000L}); | ||
29533 | public static final BitSet FOLLOW_45 = new BitSet(new long[]{0x0400000000000002L}); | ||
29534 | public static final BitSet FOLLOW_46 = new BitSet(new long[]{0x0800000007E00000L}); | ||
29535 | public static final BitSet FOLLOW_47 = new BitSet(new long[]{0x0000000000180000L}); | ||
29536 | public static final BitSet FOLLOW_48 = new BitSet(new long[]{0x1000000000000000L}); | ||
29537 | public static final BitSet FOLLOW_49 = new BitSet(new long[]{0x2000000000000000L}); | ||
29538 | public static final BitSet FOLLOW_50 = new BitSet(new long[]{0x4000000000000000L}); | ||
29539 | public static final BitSet FOLLOW_51 = new BitSet(new long[]{0x8000000000000000L}); | ||
29540 | public static final BitSet FOLLOW_52 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000001L}); | ||
29541 | public static final BitSet FOLLOW_53 = new BitSet(new long[]{0x00000000F8000010L}); | ||
29542 | public static final BitSet FOLLOW_54 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000002L}); | ||
29543 | public static final BitSet FOLLOW_55 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000004L}); | ||
29544 | public static final BitSet FOLLOW_56 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000008L}); | ||
29545 | public static final BitSet FOLLOW_57 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000010L}); | ||
29546 | public static final BitSet FOLLOW_58 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000020L}); | ||
29547 | public static final BitSet FOLLOW_59 = new BitSet(new long[]{0x0000000000000020L}); | ||
29548 | public static final BitSet FOLLOW_60 = new BitSet(new long[]{0x0000000000000040L}); | ||
29549 | public static final BitSet FOLLOW_61 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000080L}); | ||
29550 | public static final BitSet FOLLOW_62 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000200L}); | ||
29551 | public static final BitSet FOLLOW_63 = new BitSet(new long[]{0x0000000000000020L,0x0000000000000400L}); | ||
29552 | public static final BitSet FOLLOW_64 = new BitSet(new long[]{0x0000000007E00002L,0x0000000000000800L}); | ||
29553 | |||
29554 | } | ||
diff --git a/Solvers/Alloy-Solver2/hu.bme.mit.inf.dslreasoner.alloy.language.ui/src-gen/hu/bme/mit/inf/dslreasoner/ui/internal/AlloyLanguageActivator.java b/Solvers/Alloy-Solver2/hu.bme.mit.inf.dslreasoner.alloy.language.ui/src-gen/hu/bme/mit/inf/dslreasoner/ui/internal/AlloyLanguageActivator.java new file mode 100644 index 00000000..5eab6f1f --- /dev/null +++ b/Solvers/Alloy-Solver2/hu.bme.mit.inf.dslreasoner.alloy.language.ui/src-gen/hu/bme/mit/inf/dslreasoner/ui/internal/AlloyLanguageActivator.java | |||
@@ -0,0 +1,95 @@ | |||
1 | /* | ||
2 | * generated by Xtext | ||
3 | */ | ||
4 | package hu.bme.mit.inf.dslreasoner.ui.internal; | ||
5 | |||
6 | import java.util.Collections; | ||
7 | import java.util.Map; | ||
8 | |||
9 | import org.apache.log4j.Logger; | ||
10 | import org.eclipse.ui.plugin.AbstractUIPlugin; | ||
11 | import org.eclipse.xtext.ui.shared.SharedStateModule; | ||
12 | import org.eclipse.xtext.util.Modules2; | ||
13 | import org.osgi.framework.BundleContext; | ||
14 | |||
15 | import com.google.common.collect.Maps; | ||
16 | import com.google.inject.Guice; | ||
17 | import com.google.inject.Injector; | ||
18 | import com.google.inject.Module; | ||
19 | |||
20 | /** | ||
21 | * This class was generated. Customizations should only happen in a newly | ||
22 | * introduced subclass. | ||
23 | */ | ||
24 | public class AlloyLanguageActivator extends AbstractUIPlugin { | ||
25 | |||
26 | public static final String HU_BME_MIT_INF_DSLREASONER_ALLOYLANGUAGE = "hu.bme.mit.inf.dslreasoner.AlloyLanguage"; | ||
27 | |||
28 | private static final Logger logger = Logger.getLogger(AlloyLanguageActivator.class); | ||
29 | |||
30 | private static AlloyLanguageActivator INSTANCE; | ||
31 | |||
32 | private Map<String, Injector> injectors = Collections.synchronizedMap(Maps.<String, Injector> newHashMapWithExpectedSize(1)); | ||
33 | |||
34 | @Override | ||
35 | public void start(BundleContext context) throws Exception { | ||
36 | super.start(context); | ||
37 | INSTANCE = this; | ||
38 | } | ||
39 | |||
40 | @Override | ||
41 | public void stop(BundleContext context) throws Exception { | ||
42 | injectors.clear(); | ||
43 | INSTANCE = null; | ||
44 | super.stop(context); | ||
45 | } | ||
46 | |||
47 | public static AlloyLanguageActivator getInstance() { | ||
48 | return INSTANCE; | ||
49 | } | ||
50 | |||
51 | public Injector getInjector(String language) { | ||
52 | synchronized (injectors) { | ||
53 | Injector injector = injectors.get(language); | ||
54 | if (injector == null) { | ||
55 | injectors.put(language, injector = createInjector(language)); | ||
56 | } | ||
57 | return injector; | ||
58 | } | ||
59 | } | ||
60 | |||
61 | protected Injector createInjector(String language) { | ||
62 | try { | ||
63 | Module runtimeModule = getRuntimeModule(language); | ||
64 | Module sharedStateModule = getSharedStateModule(); | ||
65 | Module uiModule = getUiModule(language); | ||
66 | Module mergedModule = Modules2.mixin(runtimeModule, sharedStateModule, uiModule); | ||
67 | return Guice.createInjector(mergedModule); | ||
68 | } catch (Exception e) { | ||
69 | logger.error("Failed to create injector for " + language); | ||
70 | logger.error(e.getMessage(), e); | ||
71 | throw new RuntimeException("Failed to create injector for " + language, e); | ||
72 | } | ||
73 | } | ||
74 | |||
75 | protected Module getRuntimeModule(String grammar) { | ||
76 | if (HU_BME_MIT_INF_DSLREASONER_ALLOYLANGUAGE.equals(grammar)) { | ||
77 | return new hu.bme.mit.inf.dslreasoner.AlloyLanguageRuntimeModule(); | ||
78 | } | ||
79 | |||
80 | throw new IllegalArgumentException(grammar); | ||
81 | } | ||
82 | |||
83 | protected Module getUiModule(String grammar) { | ||
84 | if (HU_BME_MIT_INF_DSLREASONER_ALLOYLANGUAGE.equals(grammar)) { | ||
85 | return new hu.bme.mit.inf.dslreasoner.ui.AlloyLanguageUiModule(this); | ||
86 | } | ||
87 | |||
88 | throw new IllegalArgumentException(grammar); | ||
89 | } | ||
90 | |||
91 | protected Module getSharedStateModule() { | ||
92 | return new SharedStateModule(); | ||
93 | } | ||
94 | |||
95 | } | ||