diff options
Diffstat (limited to 'Solvers/Alloy-Solver/hu.bme.mit.inf.dslreasoner.alloy.language.ui/src-gen')
10 files changed, 42675 insertions, 0 deletions
diff --git a/Solvers/Alloy-Solver/hu.bme.mit.inf.dslreasoner.alloy.language.ui/src-gen/hu/bme/mit/inf/dslreasoner/ui/AbstractAlloyLanguageUiModule.java b/Solvers/Alloy-Solver/hu.bme.mit.inf.dslreasoner.alloy.language.ui/src-gen/hu/bme/mit/inf/dslreasoner/ui/AbstractAlloyLanguageUiModule.java new file mode 100644 index 00000000..b9842e1b --- /dev/null +++ b/Solvers/Alloy-Solver/hu.bme.mit.inf.dslreasoner.alloy.language.ui/src-gen/hu/bme/mit/inf/dslreasoner/ui/AbstractAlloyLanguageUiModule.java | |||
@@ -0,0 +1,196 @@ | |||
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 | |||
196 | } | ||
diff --git a/Solvers/Alloy-Solver/hu.bme.mit.inf.dslreasoner.alloy.language.ui/src-gen/hu/bme/mit/inf/dslreasoner/ui/AlloyLanguageExecutableExtensionFactory.java b/Solvers/Alloy-Solver/hu.bme.mit.inf.dslreasoner.alloy.language.ui/src-gen/hu/bme/mit/inf/dslreasoner/ui/AlloyLanguageExecutableExtensionFactory.java new file mode 100644 index 00000000..410813d6 --- /dev/null +++ b/Solvers/Alloy-Solver/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-Solver/hu.bme.mit.inf.dslreasoner.alloy.language.ui/src-gen/hu/bme/mit/inf/dslreasoner/ui/contentassist/AbstractAlloyLanguageProposalProvider.java b/Solvers/Alloy-Solver/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..ef687883 --- /dev/null +++ b/Solvers/Alloy-Solver/hu.bme.mit.inf.dslreasoner.alloy.language.ui/src-gen/hu/bme/mit/inf/dslreasoner/ui/contentassist/AbstractAlloyLanguageProposalProvider.java | |||
@@ -0,0 +1,320 @@ | |||
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 | |||
209 | public void complete_ALSDocument(EObject model, RuleCall ruleCall, ContentAssistContext context, ICompletionProposalAcceptor acceptor) { | ||
210 | // subclasses may override | ||
211 | } | ||
212 | public void complete_ALSID(EObject model, RuleCall ruleCall, ContentAssistContext context, ICompletionProposalAcceptor acceptor) { | ||
213 | // subclasses may override | ||
214 | } | ||
215 | public void complete_ALSMultiplicity(EObject model, RuleCall ruleCall, ContentAssistContext context, ICompletionProposalAcceptor acceptor) { | ||
216 | // subclasses may override | ||
217 | } | ||
218 | public void complete_ALSRelationDeclaration(EObject model, RuleCall ruleCall, ContentAssistContext context, ICompletionProposalAcceptor acceptor) { | ||
219 | // subclasses may override | ||
220 | } | ||
221 | public void complete_ALSTypeDeclaration(EObject model, RuleCall ruleCall, ContentAssistContext context, ICompletionProposalAcceptor acceptor) { | ||
222 | // subclasses may override | ||
223 | } | ||
224 | public void complete_ALSEnumDeclaration(EObject model, RuleCall ruleCall, ContentAssistContext context, ICompletionProposalAcceptor acceptor) { | ||
225 | // subclasses may override | ||
226 | } | ||
227 | public void complete_ALSEnumLiteral(EObject model, RuleCall ruleCall, ContentAssistContext context, ICompletionProposalAcceptor acceptor) { | ||
228 | // subclasses may override | ||
229 | } | ||
230 | public void complete_ALSSignatureDeclaration(EObject model, RuleCall ruleCall, ContentAssistContext context, ICompletionProposalAcceptor acceptor) { | ||
231 | // subclasses may override | ||
232 | } | ||
233 | public void complete_ALSSignatureBody(EObject model, RuleCall ruleCall, ContentAssistContext context, ICompletionProposalAcceptor acceptor) { | ||
234 | // subclasses may override | ||
235 | } | ||
236 | public void complete_ALSFieldDeclaration(EObject model, RuleCall ruleCall, ContentAssistContext context, ICompletionProposalAcceptor acceptor) { | ||
237 | // subclasses may override | ||
238 | } | ||
239 | public void complete_ALSDefinition(EObject model, RuleCall ruleCall, ContentAssistContext context, ICompletionProposalAcceptor acceptor) { | ||
240 | // subclasses may override | ||
241 | } | ||
242 | public void complete_ALSFunctionDefinition(EObject model, RuleCall ruleCall, ContentAssistContext context, ICompletionProposalAcceptor acceptor) { | ||
243 | // subclasses may override | ||
244 | } | ||
245 | public void complete_ALSRelationDefinition(EObject model, RuleCall ruleCall, ContentAssistContext context, ICompletionProposalAcceptor acceptor) { | ||
246 | // subclasses may override | ||
247 | } | ||
248 | public void complete_ALSFactDeclaration(EObject model, RuleCall ruleCall, ContentAssistContext context, ICompletionProposalAcceptor acceptor) { | ||
249 | // subclasses may override | ||
250 | } | ||
251 | public void complete_ALSTerm(EObject model, RuleCall ruleCall, ContentAssistContext context, ICompletionProposalAcceptor acceptor) { | ||
252 | // subclasses may override | ||
253 | } | ||
254 | public void complete_ALSQuantified(EObject model, RuleCall ruleCall, ContentAssistContext context, ICompletionProposalAcceptor acceptor) { | ||
255 | // subclasses may override | ||
256 | } | ||
257 | public void complete_ALSOr(EObject model, RuleCall ruleCall, ContentAssistContext context, ICompletionProposalAcceptor acceptor) { | ||
258 | // subclasses may override | ||
259 | } | ||
260 | public void complete_ALSIff(EObject model, RuleCall ruleCall, ContentAssistContext context, ICompletionProposalAcceptor acceptor) { | ||
261 | // subclasses may override | ||
262 | } | ||
263 | public void complete_ALSImpl(EObject model, RuleCall ruleCall, ContentAssistContext context, ICompletionProposalAcceptor acceptor) { | ||
264 | // subclasses may override | ||
265 | } | ||
266 | public void complete_ALSAnd(EObject model, RuleCall ruleCall, ContentAssistContext context, ICompletionProposalAcceptor acceptor) { | ||
267 | // subclasses may override | ||
268 | } | ||
269 | public void complete_ALSComparison(EObject model, RuleCall ruleCall, ContentAssistContext context, ICompletionProposalAcceptor acceptor) { | ||
270 | // subclasses may override | ||
271 | } | ||
272 | public void complete_ALSOverride(EObject model, RuleCall ruleCall, ContentAssistContext context, ICompletionProposalAcceptor acceptor) { | ||
273 | // subclasses may override | ||
274 | } | ||
275 | public void complete_ALSRangeRestrictionRight(EObject model, RuleCall ruleCall, ContentAssistContext context, ICompletionProposalAcceptor acceptor) { | ||
276 | // subclasses may override | ||
277 | } | ||
278 | public void complete_ALSRangeRestrictionLeft(EObject model, RuleCall ruleCall, ContentAssistContext context, ICompletionProposalAcceptor acceptor) { | ||
279 | // subclasses may override | ||
280 | } | ||
281 | public void complete_ALSJoin(EObject model, RuleCall ruleCall, ContentAssistContext context, ICompletionProposalAcceptor acceptor) { | ||
282 | // subclasses may override | ||
283 | } | ||
284 | public void complete_ALSMinus(EObject model, RuleCall ruleCall, ContentAssistContext context, ICompletionProposalAcceptor acceptor) { | ||
285 | // subclasses may override | ||
286 | } | ||
287 | public void complete_ALSPlus(EObject model, RuleCall ruleCall, ContentAssistContext context, ICompletionProposalAcceptor acceptor) { | ||
288 | // subclasses may override | ||
289 | } | ||
290 | public void complete_ALSIntersection(EObject model, RuleCall ruleCall, ContentAssistContext context, ICompletionProposalAcceptor acceptor) { | ||
291 | // subclasses may override | ||
292 | } | ||
293 | public void complete_ALSDirectProduct(EObject model, RuleCall ruleCall, ContentAssistContext context, ICompletionProposalAcceptor acceptor) { | ||
294 | // subclasses may override | ||
295 | } | ||
296 | public void complete_ALSPreficed(EObject model, RuleCall ruleCall, ContentAssistContext context, ICompletionProposalAcceptor acceptor) { | ||
297 | // subclasses may override | ||
298 | } | ||
299 | public void complete_ALSNumericOperator(EObject model, RuleCall ruleCall, ContentAssistContext context, ICompletionProposalAcceptor acceptor) { | ||
300 | // subclasses may override | ||
301 | } | ||
302 | public void complete_ALSVariableDeclaration(EObject model, RuleCall ruleCall, ContentAssistContext context, ICompletionProposalAcceptor acceptor) { | ||
303 | // subclasses may override | ||
304 | } | ||
305 | public void complete_ALSBasicRelationTerm(EObject model, RuleCall ruleCall, ContentAssistContext context, ICompletionProposalAcceptor acceptor) { | ||
306 | // subclasses may override | ||
307 | } | ||
308 | public void complete_ALSRunCommand(EObject model, RuleCall ruleCall, ContentAssistContext context, ICompletionProposalAcceptor acceptor) { | ||
309 | // subclasses may override | ||
310 | } | ||
311 | public void complete_ALSTypeScope(EObject model, RuleCall ruleCall, ContentAssistContext context, ICompletionProposalAcceptor acceptor) { | ||
312 | // subclasses may override | ||
313 | } | ||
314 | public void complete_ALSSigScope(EObject model, RuleCall ruleCall, ContentAssistContext context, ICompletionProposalAcceptor acceptor) { | ||
315 | // subclasses may override | ||
316 | } | ||
317 | public void complete_ALSIntScope(EObject model, RuleCall ruleCall, ContentAssistContext context, ICompletionProposalAcceptor acceptor) { | ||
318 | // subclasses may override | ||
319 | } | ||
320 | } | ||
diff --git a/Solvers/Alloy-Solver/hu.bme.mit.inf.dslreasoner.alloy.language.ui/src-gen/hu/bme/mit/inf/dslreasoner/ui/contentassist/antlr/AlloyLanguageParser.java b/Solvers/Alloy-Solver/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..ff0c48fa --- /dev/null +++ b/Solvers/Alloy-Solver/hu.bme.mit.inf.dslreasoner.alloy.language.ui/src-gen/hu/bme/mit/inf/dslreasoner/ui/contentassist/antlr/AlloyLanguageParser.java | |||
@@ -0,0 +1,242 @@ | |||
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.getALSRunCommandAccess().getGroup(), "rule__ALSRunCommand__Group__0"); | ||
130 | put(grammarAccess.getALSRunCommandAccess().getGroup_4(), "rule__ALSRunCommand__Group_4__0"); | ||
131 | put(grammarAccess.getALSRunCommandAccess().getGroup_4_2(), "rule__ALSRunCommand__Group_4_2__0"); | ||
132 | put(grammarAccess.getALSSigScopeAccess().getGroup(), "rule__ALSSigScope__Group__0"); | ||
133 | put(grammarAccess.getALSIntScopeAccess().getGroup(), "rule__ALSIntScope__Group__0"); | ||
134 | put(grammarAccess.getALSDocumentAccess().getEnumDeclarationsAssignment_0_0(), "rule__ALSDocument__EnumDeclarationsAssignment_0_0"); | ||
135 | put(grammarAccess.getALSDocumentAccess().getSignatureBodiesAssignment_0_1(), "rule__ALSDocument__SignatureBodiesAssignment_0_1"); | ||
136 | put(grammarAccess.getALSDocumentAccess().getFunctionDefinitionsAssignment_0_2(), "rule__ALSDocument__FunctionDefinitionsAssignment_0_2"); | ||
137 | put(grammarAccess.getALSDocumentAccess().getRelationDefinitionsAssignment_0_3(), "rule__ALSDocument__RelationDefinitionsAssignment_0_3"); | ||
138 | put(grammarAccess.getALSDocumentAccess().getFactDeclarationsAssignment_0_4(), "rule__ALSDocument__FactDeclarationsAssignment_0_4"); | ||
139 | put(grammarAccess.getALSDocumentAccess().getRunCommandAssignment_1(), "rule__ALSDocument__RunCommandAssignment_1"); | ||
140 | put(grammarAccess.getALSEnumDeclarationAccess().getNameAssignment_1(), "rule__ALSEnumDeclaration__NameAssignment_1"); | ||
141 | put(grammarAccess.getALSEnumDeclarationAccess().getLiteralAssignment_3(), "rule__ALSEnumDeclaration__LiteralAssignment_3"); | ||
142 | put(grammarAccess.getALSEnumDeclarationAccess().getLiteralAssignment_4_1(), "rule__ALSEnumDeclaration__LiteralAssignment_4_1"); | ||
143 | put(grammarAccess.getALSEnumLiteralAccess().getNameAssignment(), "rule__ALSEnumLiteral__NameAssignment"); | ||
144 | put(grammarAccess.getALSSignatureDeclarationAccess().getNameAssignment(), "rule__ALSSignatureDeclaration__NameAssignment"); | ||
145 | put(grammarAccess.getALSSignatureBodyAccess().getMultiplicityAssignment_0_0(), "rule__ALSSignatureBody__MultiplicityAssignment_0_0"); | ||
146 | put(grammarAccess.getALSSignatureBodyAccess().getAbstractAssignment_0_1(), "rule__ALSSignatureBody__AbstractAssignment_0_1"); | ||
147 | put(grammarAccess.getALSSignatureBodyAccess().getDeclarationsAssignment_2(), "rule__ALSSignatureBody__DeclarationsAssignment_2"); | ||
148 | put(grammarAccess.getALSSignatureBodyAccess().getDeclarationsAssignment_3_1(), "rule__ALSSignatureBody__DeclarationsAssignment_3_1"); | ||
149 | put(grammarAccess.getALSSignatureBodyAccess().getSupertypeAssignment_4_0_1(), "rule__ALSSignatureBody__SupertypeAssignment_4_0_1"); | ||
150 | put(grammarAccess.getALSSignatureBodyAccess().getSupersetAssignment_4_1_1(), "rule__ALSSignatureBody__SupersetAssignment_4_1_1"); | ||
151 | put(grammarAccess.getALSSignatureBodyAccess().getSupersetAssignment_4_1_2_1(), "rule__ALSSignatureBody__SupersetAssignment_4_1_2_1"); | ||
152 | put(grammarAccess.getALSSignatureBodyAccess().getFieldsAssignment_6_0(), "rule__ALSSignatureBody__FieldsAssignment_6_0"); | ||
153 | put(grammarAccess.getALSSignatureBodyAccess().getFieldsAssignment_6_1_1(), "rule__ALSSignatureBody__FieldsAssignment_6_1_1"); | ||
154 | put(grammarAccess.getALSFieldDeclarationAccess().getNameAssignment_0(), "rule__ALSFieldDeclaration__NameAssignment_0"); | ||
155 | put(grammarAccess.getALSFieldDeclarationAccess().getMultiplicityAssignment_2(), "rule__ALSFieldDeclaration__MultiplicityAssignment_2"); | ||
156 | put(grammarAccess.getALSFieldDeclarationAccess().getTypeAssignment_3(), "rule__ALSFieldDeclaration__TypeAssignment_3"); | ||
157 | put(grammarAccess.getALSFunctionDefinitionAccess().getNameAssignment_1(), "rule__ALSFunctionDefinition__NameAssignment_1"); | ||
158 | put(grammarAccess.getALSFunctionDefinitionAccess().getVariablesAssignment_3(), "rule__ALSFunctionDefinition__VariablesAssignment_3"); | ||
159 | put(grammarAccess.getALSFunctionDefinitionAccess().getVariablesAssignment_4_1(), "rule__ALSFunctionDefinition__VariablesAssignment_4_1"); | ||
160 | put(grammarAccess.getALSFunctionDefinitionAccess().getTypeAssignment_7(), "rule__ALSFunctionDefinition__TypeAssignment_7"); | ||
161 | put(grammarAccess.getALSFunctionDefinitionAccess().getValueAssignment_9(), "rule__ALSFunctionDefinition__ValueAssignment_9"); | ||
162 | put(grammarAccess.getALSRelationDefinitionAccess().getNameAssignment_1(), "rule__ALSRelationDefinition__NameAssignment_1"); | ||
163 | put(grammarAccess.getALSRelationDefinitionAccess().getVariablesAssignment_3(), "rule__ALSRelationDefinition__VariablesAssignment_3"); | ||
164 | put(grammarAccess.getALSRelationDefinitionAccess().getVariablesAssignment_4_1(), "rule__ALSRelationDefinition__VariablesAssignment_4_1"); | ||
165 | put(grammarAccess.getALSRelationDefinitionAccess().getValueAssignment_7(), "rule__ALSRelationDefinition__ValueAssignment_7"); | ||
166 | put(grammarAccess.getALSFactDeclarationAccess().getNameAssignment_2(), "rule__ALSFactDeclaration__NameAssignment_2"); | ||
167 | put(grammarAccess.getALSFactDeclarationAccess().getTermAssignment_4(), "rule__ALSFactDeclaration__TermAssignment_4"); | ||
168 | put(grammarAccess.getALSQuantifiedAccess().getTypeAssignment_0_1(), "rule__ALSQuantified__TypeAssignment_0_1"); | ||
169 | put(grammarAccess.getALSQuantifiedAccess().getDisjAssignment_0_2(), "rule__ALSQuantified__DisjAssignment_0_2"); | ||
170 | put(grammarAccess.getALSQuantifiedAccess().getVariablesAssignment_0_3(), "rule__ALSQuantified__VariablesAssignment_0_3"); | ||
171 | put(grammarAccess.getALSQuantifiedAccess().getVariablesAssignment_0_4_1(), "rule__ALSQuantified__VariablesAssignment_0_4_1"); | ||
172 | put(grammarAccess.getALSQuantifiedAccess().getExpressionAssignment_0_6(), "rule__ALSQuantified__ExpressionAssignment_0_6"); | ||
173 | put(grammarAccess.getALSOrAccess().getRightOperandAssignment_1_2(), "rule__ALSOr__RightOperandAssignment_1_2"); | ||
174 | put(grammarAccess.getALSIffAccess().getRightOperandAssignment_1_2(), "rule__ALSIff__RightOperandAssignment_1_2"); | ||
175 | put(grammarAccess.getALSImplAccess().getRightOperandAssignment_1_2(), "rule__ALSImpl__RightOperandAssignment_1_2"); | ||
176 | put(grammarAccess.getALSImplAccess().getElseOperandAssignment_1_3_1(), "rule__ALSImpl__ElseOperandAssignment_1_3_1"); | ||
177 | put(grammarAccess.getALSAndAccess().getRightOperandAssignment_1_2(), "rule__ALSAnd__RightOperandAssignment_1_2"); | ||
178 | put(grammarAccess.getALSComparisonAccess().getRightOperandAssignment_1_1(), "rule__ALSComparison__RightOperandAssignment_1_1"); | ||
179 | put(grammarAccess.getALSOverrideAccess().getRightOperandAssignment_1_2(), "rule__ALSOverride__RightOperandAssignment_1_2"); | ||
180 | put(grammarAccess.getALSRangeRestrictionRightAccess().getFilterAssignment_1_2(), "rule__ALSRangeRestrictionRight__FilterAssignment_1_2"); | ||
181 | put(grammarAccess.getALSRangeRestrictionLeftAccess().getRelationAssignment_1_2(), "rule__ALSRangeRestrictionLeft__RelationAssignment_1_2"); | ||
182 | put(grammarAccess.getALSJoinAccess().getRightOperandAssignment_1_2(), "rule__ALSJoin__RightOperandAssignment_1_2"); | ||
183 | put(grammarAccess.getALSMinusAccess().getRightOperandAssignment_1_2(), "rule__ALSMinus__RightOperandAssignment_1_2"); | ||
184 | put(grammarAccess.getALSPlusAccess().getRightOperandAssignment_1_2(), "rule__ALSPlus__RightOperandAssignment_1_2"); | ||
185 | put(grammarAccess.getALSIntersectionAccess().getRightOperandAssignment_1_2(), "rule__ALSIntersection__RightOperandAssignment_1_2"); | ||
186 | put(grammarAccess.getALSDirectProductAccess().getLeftMultiplicitAssignment_1_1(), "rule__ALSDirectProduct__LeftMultiplicitAssignment_1_1"); | ||
187 | put(grammarAccess.getALSDirectProductAccess().getRightMultiplicitAssignment_1_3(), "rule__ALSDirectProduct__RightMultiplicitAssignment_1_3"); | ||
188 | put(grammarAccess.getALSDirectProductAccess().getRightOperandAssignment_1_4(), "rule__ALSDirectProduct__RightOperandAssignment_1_4"); | ||
189 | put(grammarAccess.getALSPreficedAccess().getOperandAssignment_0_2(), "rule__ALSPreficed__OperandAssignment_0_2"); | ||
190 | put(grammarAccess.getALSPreficedAccess().getOperandAssignment_1_2(), "rule__ALSPreficed__OperandAssignment_1_2"); | ||
191 | put(grammarAccess.getALSPreficedAccess().getOperandAssignment_2_2(), "rule__ALSPreficed__OperandAssignment_2_2"); | ||
192 | put(grammarAccess.getALSPreficedAccess().getOperandAssignment_3_2(), "rule__ALSPreficed__OperandAssignment_3_2"); | ||
193 | put(grammarAccess.getALSPreficedAccess().getOperandAssignment_4_2(), "rule__ALSPreficed__OperandAssignment_4_2"); | ||
194 | put(grammarAccess.getALSPreficedAccess().getOperandAssignment_5_2(), "rule__ALSPreficed__OperandAssignment_5_2"); | ||
195 | put(grammarAccess.getALSPreficedAccess().getVariablesAssignment_6_2(), "rule__ALSPreficed__VariablesAssignment_6_2"); | ||
196 | put(grammarAccess.getALSPreficedAccess().getVariablesAssignment_6_3_1(), "rule__ALSPreficed__VariablesAssignment_6_3_1"); | ||
197 | put(grammarAccess.getALSPreficedAccess().getExpressionAssignment_6_5(), "rule__ALSPreficed__ExpressionAssignment_6_5"); | ||
198 | put(grammarAccess.getALSPreficedAccess().getReferredDefinitionAssignment_7_1_0(), "rule__ALSPreficed__ReferredDefinitionAssignment_7_1_0"); | ||
199 | put(grammarAccess.getALSPreficedAccess().getReferredNumericOperatorAssignment_7_1_1(), "rule__ALSPreficed__ReferredNumericOperatorAssignment_7_1_1"); | ||
200 | put(grammarAccess.getALSPreficedAccess().getParamsAssignment_7_3(), "rule__ALSPreficed__ParamsAssignment_7_3"); | ||
201 | put(grammarAccess.getALSPreficedAccess().getParamsAssignment_7_4_1(), "rule__ALSPreficed__ParamsAssignment_7_4_1"); | ||
202 | put(grammarAccess.getALSVariableDeclarationAccess().getNameAssignment_0(), "rule__ALSVariableDeclaration__NameAssignment_0"); | ||
203 | put(grammarAccess.getALSVariableDeclarationAccess().getRangeAssignment_2(), "rule__ALSVariableDeclaration__RangeAssignment_2"); | ||
204 | put(grammarAccess.getALSBasicRelationTermAccess().getReferredAssignment_4_1(), "rule__ALSBasicRelationTerm__ReferredAssignment_4_1"); | ||
205 | put(grammarAccess.getALSBasicRelationTermAccess().getValueAssignment_5_1(), "rule__ALSBasicRelationTerm__ValueAssignment_5_1"); | ||
206 | put(grammarAccess.getALSRunCommandAccess().getTypeScopesAssignment_4_1(), "rule__ALSRunCommand__TypeScopesAssignment_4_1"); | ||
207 | put(grammarAccess.getALSRunCommandAccess().getTypeScopesAssignment_4_2_1(), "rule__ALSRunCommand__TypeScopesAssignment_4_2_1"); | ||
208 | put(grammarAccess.getALSSigScopeAccess().getExactlyAssignment_0(), "rule__ALSSigScope__ExactlyAssignment_0"); | ||
209 | put(grammarAccess.getALSSigScopeAccess().getNumberAssignment_1(), "rule__ALSSigScope__NumberAssignment_1"); | ||
210 | put(grammarAccess.getALSSigScopeAccess().getTypeAssignment_2(), "rule__ALSSigScope__TypeAssignment_2"); | ||
211 | put(grammarAccess.getALSIntScopeAccess().getNumberAssignment_0(), "rule__ALSIntScope__NumberAssignment_0"); | ||
212 | put(grammarAccess.getALSSignatureBodyAccess().getUnorderedGroup_0(), "rule__ALSSignatureBody__UnorderedGroup_0"); | ||
213 | } | ||
214 | }; | ||
215 | } | ||
216 | return nameMappings.get(element); | ||
217 | } | ||
218 | |||
219 | @Override | ||
220 | protected Collection<FollowElement> getFollowElements(AbstractInternalContentAssistParser parser) { | ||
221 | try { | ||
222 | hu.bme.mit.inf.dslreasoner.ui.contentassist.antlr.internal.InternalAlloyLanguageParser typedParser = (hu.bme.mit.inf.dslreasoner.ui.contentassist.antlr.internal.InternalAlloyLanguageParser) parser; | ||
223 | typedParser.entryRuleALSDocument(); | ||
224 | return typedParser.getFollowElements(); | ||
225 | } catch(RecognitionException ex) { | ||
226 | throw new RuntimeException(ex); | ||
227 | } | ||
228 | } | ||
229 | |||
230 | @Override | ||
231 | protected String[] getInitialHiddenTokens() { | ||
232 | return new String[] { "RULE_WS", "RULE_ML_COMMENT", "RULE_SL_COMMENT" }; | ||
233 | } | ||
234 | |||
235 | public AlloyLanguageGrammarAccess getGrammarAccess() { | ||
236 | return this.grammarAccess; | ||
237 | } | ||
238 | |||
239 | public void setGrammarAccess(AlloyLanguageGrammarAccess grammarAccess) { | ||
240 | this.grammarAccess = grammarAccess; | ||
241 | } | ||
242 | } | ||
diff --git a/Solvers/Alloy-Solver/hu.bme.mit.inf.dslreasoner.alloy.language.ui/src-gen/hu/bme/mit/inf/dslreasoner/ui/contentassist/antlr/PartialAlloyLanguageContentAssistParser.java b/Solvers/Alloy-Solver/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..f677daed --- /dev/null +++ b/Solvers/Alloy-Solver/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-Solver/hu.bme.mit.inf.dslreasoner.alloy.language.ui/src-gen/hu/bme/mit/inf/dslreasoner/ui/contentassist/antlr/internal/InternalAlloyLanguage.g b/Solvers/Alloy-Solver/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..1551eeee --- /dev/null +++ b/Solvers/Alloy-Solver/hu.bme.mit.inf.dslreasoner.alloy.language.ui/src-gen/hu/bme/mit/inf/dslreasoner/ui/contentassist/antlr/internal/InternalAlloyLanguage.g | |||
@@ -0,0 +1,10092 @@ | |||
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 | |||
989 | // Rule ALSMultiplicity | ||
990 | ruleALSMultiplicity | ||
991 | @init { | ||
992 | int stackSize = keepStackSize(); | ||
993 | } | ||
994 | : | ||
995 | ( | ||
996 | { before(grammarAccess.getALSMultiplicityAccess().getAlternatives()); } | ||
997 | (rule__ALSMultiplicity__Alternatives) | ||
998 | { after(grammarAccess.getALSMultiplicityAccess().getAlternatives()); } | ||
999 | ) | ||
1000 | |||
1001 | ; | ||
1002 | finally { | ||
1003 | restoreStackSize(stackSize); | ||
1004 | } | ||
1005 | |||
1006 | |||
1007 | |||
1008 | // Rule ALSNumericOperator | ||
1009 | ruleALSNumericOperator | ||
1010 | @init { | ||
1011 | int stackSize = keepStackSize(); | ||
1012 | } | ||
1013 | : | ||
1014 | ( | ||
1015 | { before(grammarAccess.getALSNumericOperatorAccess().getAlternatives()); } | ||
1016 | (rule__ALSNumericOperator__Alternatives) | ||
1017 | { after(grammarAccess.getALSNumericOperatorAccess().getAlternatives()); } | ||
1018 | ) | ||
1019 | |||
1020 | ; | ||
1021 | finally { | ||
1022 | restoreStackSize(stackSize); | ||
1023 | } | ||
1024 | |||
1025 | |||
1026 | |||
1027 | rule__ALSDocument__Alternatives_0 | ||
1028 | @init { | ||
1029 | int stackSize = keepStackSize(); | ||
1030 | } | ||
1031 | : | ||
1032 | ( | ||
1033 | { before(grammarAccess.getALSDocumentAccess().getEnumDeclarationsAssignment_0_0()); } | ||
1034 | (rule__ALSDocument__EnumDeclarationsAssignment_0_0) | ||
1035 | { after(grammarAccess.getALSDocumentAccess().getEnumDeclarationsAssignment_0_0()); } | ||
1036 | ) | ||
1037 | |||
1038 | |( | ||
1039 | { before(grammarAccess.getALSDocumentAccess().getSignatureBodiesAssignment_0_1()); } | ||
1040 | (rule__ALSDocument__SignatureBodiesAssignment_0_1) | ||
1041 | { after(grammarAccess.getALSDocumentAccess().getSignatureBodiesAssignment_0_1()); } | ||
1042 | ) | ||
1043 | |||
1044 | |( | ||
1045 | { before(grammarAccess.getALSDocumentAccess().getFunctionDefinitionsAssignment_0_2()); } | ||
1046 | (rule__ALSDocument__FunctionDefinitionsAssignment_0_2) | ||
1047 | { after(grammarAccess.getALSDocumentAccess().getFunctionDefinitionsAssignment_0_2()); } | ||
1048 | ) | ||
1049 | |||
1050 | |( | ||
1051 | { before(grammarAccess.getALSDocumentAccess().getRelationDefinitionsAssignment_0_3()); } | ||
1052 | (rule__ALSDocument__RelationDefinitionsAssignment_0_3) | ||
1053 | { after(grammarAccess.getALSDocumentAccess().getRelationDefinitionsAssignment_0_3()); } | ||
1054 | ) | ||
1055 | |||
1056 | |( | ||
1057 | { before(grammarAccess.getALSDocumentAccess().getFactDeclarationsAssignment_0_4()); } | ||
1058 | (rule__ALSDocument__FactDeclarationsAssignment_0_4) | ||
1059 | { after(grammarAccess.getALSDocumentAccess().getFactDeclarationsAssignment_0_4()); } | ||
1060 | ) | ||
1061 | |||
1062 | ; | ||
1063 | finally { | ||
1064 | restoreStackSize(stackSize); | ||
1065 | } | ||
1066 | |||
1067 | |||
1068 | rule__ALSTypeDeclaration__Alternatives | ||
1069 | @init { | ||
1070 | int stackSize = keepStackSize(); | ||
1071 | } | ||
1072 | : | ||
1073 | ( | ||
1074 | { before(grammarAccess.getALSTypeDeclarationAccess().getALSEnumDeclarationParserRuleCall_0()); } | ||
1075 | ruleALSEnumDeclaration | ||
1076 | { after(grammarAccess.getALSTypeDeclarationAccess().getALSEnumDeclarationParserRuleCall_0()); } | ||
1077 | ) | ||
1078 | |||
1079 | |( | ||
1080 | { before(grammarAccess.getALSTypeDeclarationAccess().getALSSignatureDeclarationParserRuleCall_1()); } | ||
1081 | ruleALSSignatureDeclaration | ||
1082 | { after(grammarAccess.getALSTypeDeclarationAccess().getALSSignatureDeclarationParserRuleCall_1()); } | ||
1083 | ) | ||
1084 | |||
1085 | ; | ||
1086 | finally { | ||
1087 | restoreStackSize(stackSize); | ||
1088 | } | ||
1089 | |||
1090 | rule__ALSSignatureBody__Alternatives_4 | ||
1091 | @init { | ||
1092 | int stackSize = keepStackSize(); | ||
1093 | } | ||
1094 | : | ||
1095 | ( | ||
1096 | { before(grammarAccess.getALSSignatureBodyAccess().getGroup_4_0()); } | ||
1097 | (rule__ALSSignatureBody__Group_4_0__0) | ||
1098 | { after(grammarAccess.getALSSignatureBodyAccess().getGroup_4_0()); } | ||
1099 | ) | ||
1100 | |||
1101 | |( | ||
1102 | { before(grammarAccess.getALSSignatureBodyAccess().getGroup_4_1()); } | ||
1103 | (rule__ALSSignatureBody__Group_4_1__0) | ||
1104 | { after(grammarAccess.getALSSignatureBodyAccess().getGroup_4_1()); } | ||
1105 | ) | ||
1106 | |||
1107 | ; | ||
1108 | finally { | ||
1109 | restoreStackSize(stackSize); | ||
1110 | } | ||
1111 | |||
1112 | |||
1113 | rule__ALSQuantified__Alternatives | ||
1114 | @init { | ||
1115 | int stackSize = keepStackSize(); | ||
1116 | } | ||
1117 | : | ||
1118 | ( | ||
1119 | { before(grammarAccess.getALSQuantifiedAccess().getGroup_0()); } | ||
1120 | (rule__ALSQuantified__Group_0__0) | ||
1121 | { after(grammarAccess.getALSQuantifiedAccess().getGroup_0()); } | ||
1122 | ) | ||
1123 | |||
1124 | |( | ||
1125 | { before(grammarAccess.getALSQuantifiedAccess().getALSOrParserRuleCall_1()); } | ||
1126 | ruleALSOr | ||
1127 | { after(grammarAccess.getALSQuantifiedAccess().getALSOrParserRuleCall_1()); } | ||
1128 | ) | ||
1129 | |||
1130 | ; | ||
1131 | finally { | ||
1132 | restoreStackSize(stackSize); | ||
1133 | } | ||
1134 | |||
1135 | rule__ALSOr__Alternatives_1_1 | ||
1136 | @init { | ||
1137 | int stackSize = keepStackSize(); | ||
1138 | } | ||
1139 | : | ||
1140 | ( | ||
1141 | { before(grammarAccess.getALSOrAccess().getVerticalLineVerticalLineKeyword_1_1_0()); } | ||
1142 | |||
1143 | '||' | ||
1144 | |||
1145 | { after(grammarAccess.getALSOrAccess().getVerticalLineVerticalLineKeyword_1_1_0()); } | ||
1146 | ) | ||
1147 | |||
1148 | |( | ||
1149 | { before(grammarAccess.getALSOrAccess().getOrKeyword_1_1_1()); } | ||
1150 | |||
1151 | 'or' | ||
1152 | |||
1153 | { after(grammarAccess.getALSOrAccess().getOrKeyword_1_1_1()); } | ||
1154 | ) | ||
1155 | |||
1156 | ; | ||
1157 | finally { | ||
1158 | restoreStackSize(stackSize); | ||
1159 | } | ||
1160 | |||
1161 | rule__ALSIff__Alternatives_1_1 | ||
1162 | @init { | ||
1163 | int stackSize = keepStackSize(); | ||
1164 | } | ||
1165 | : | ||
1166 | ( | ||
1167 | { before(grammarAccess.getALSIffAccess().getLessThanSignEqualsSignGreaterThanSignKeyword_1_1_0()); } | ||
1168 | |||
1169 | '<=>' | ||
1170 | |||
1171 | { after(grammarAccess.getALSIffAccess().getLessThanSignEqualsSignGreaterThanSignKeyword_1_1_0()); } | ||
1172 | ) | ||
1173 | |||
1174 | |( | ||
1175 | { before(grammarAccess.getALSIffAccess().getIffKeyword_1_1_1()); } | ||
1176 | |||
1177 | 'iff' | ||
1178 | |||
1179 | { after(grammarAccess.getALSIffAccess().getIffKeyword_1_1_1()); } | ||
1180 | ) | ||
1181 | |||
1182 | ; | ||
1183 | finally { | ||
1184 | restoreStackSize(stackSize); | ||
1185 | } | ||
1186 | |||
1187 | rule__ALSImpl__Alternatives_1_1 | ||
1188 | @init { | ||
1189 | int stackSize = keepStackSize(); | ||
1190 | } | ||
1191 | : | ||
1192 | ( | ||
1193 | { before(grammarAccess.getALSImplAccess().getEqualsSignGreaterThanSignKeyword_1_1_0()); } | ||
1194 | |||
1195 | '=>' | ||
1196 | |||
1197 | { after(grammarAccess.getALSImplAccess().getEqualsSignGreaterThanSignKeyword_1_1_0()); } | ||
1198 | ) | ||
1199 | |||
1200 | |( | ||
1201 | { before(grammarAccess.getALSImplAccess().getImpliesKeyword_1_1_1()); } | ||
1202 | |||
1203 | 'implies' | ||
1204 | |||
1205 | { after(grammarAccess.getALSImplAccess().getImpliesKeyword_1_1_1()); } | ||
1206 | ) | ||
1207 | |||
1208 | ; | ||
1209 | finally { | ||
1210 | restoreStackSize(stackSize); | ||
1211 | } | ||
1212 | |||
1213 | rule__ALSAnd__Alternatives_1_1 | ||
1214 | @init { | ||
1215 | int stackSize = keepStackSize(); | ||
1216 | } | ||
1217 | : | ||
1218 | ( | ||
1219 | { before(grammarAccess.getALSAndAccess().getAmpersandAmpersandKeyword_1_1_0()); } | ||
1220 | |||
1221 | '&&' | ||
1222 | |||
1223 | { after(grammarAccess.getALSAndAccess().getAmpersandAmpersandKeyword_1_1_0()); } | ||
1224 | ) | ||
1225 | |||
1226 | |( | ||
1227 | { before(grammarAccess.getALSAndAccess().getAndKeyword_1_1_1()); } | ||
1228 | |||
1229 | 'and' | ||
1230 | |||
1231 | { after(grammarAccess.getALSAndAccess().getAndKeyword_1_1_1()); } | ||
1232 | ) | ||
1233 | |||
1234 | ; | ||
1235 | finally { | ||
1236 | restoreStackSize(stackSize); | ||
1237 | } | ||
1238 | |||
1239 | rule__ALSComparison__Alternatives_1_0 | ||
1240 | @init { | ||
1241 | int stackSize = keepStackSize(); | ||
1242 | } | ||
1243 | : | ||
1244 | ( | ||
1245 | { before(grammarAccess.getALSComparisonAccess().getGroup_1_0_0()); } | ||
1246 | (rule__ALSComparison__Group_1_0_0__0) | ||
1247 | { after(grammarAccess.getALSComparisonAccess().getGroup_1_0_0()); } | ||
1248 | ) | ||
1249 | |||
1250 | |( | ||
1251 | { before(grammarAccess.getALSComparisonAccess().getGroup_1_0_1()); } | ||
1252 | (rule__ALSComparison__Group_1_0_1__0) | ||
1253 | { after(grammarAccess.getALSComparisonAccess().getGroup_1_0_1()); } | ||
1254 | ) | ||
1255 | |||
1256 | |( | ||
1257 | { before(grammarAccess.getALSComparisonAccess().getGroup_1_0_2()); } | ||
1258 | (rule__ALSComparison__Group_1_0_2__0) | ||
1259 | { after(grammarAccess.getALSComparisonAccess().getGroup_1_0_2()); } | ||
1260 | ) | ||
1261 | |||
1262 | |( | ||
1263 | { before(grammarAccess.getALSComparisonAccess().getGroup_1_0_3()); } | ||
1264 | (rule__ALSComparison__Group_1_0_3__0) | ||
1265 | { after(grammarAccess.getALSComparisonAccess().getGroup_1_0_3()); } | ||
1266 | ) | ||
1267 | |||
1268 | |( | ||
1269 | { before(grammarAccess.getALSComparisonAccess().getGroup_1_0_4()); } | ||
1270 | (rule__ALSComparison__Group_1_0_4__0) | ||
1271 | { after(grammarAccess.getALSComparisonAccess().getGroup_1_0_4()); } | ||
1272 | ) | ||
1273 | |||
1274 | |( | ||
1275 | { before(grammarAccess.getALSComparisonAccess().getGroup_1_0_5()); } | ||
1276 | (rule__ALSComparison__Group_1_0_5__0) | ||
1277 | { after(grammarAccess.getALSComparisonAccess().getGroup_1_0_5()); } | ||
1278 | ) | ||
1279 | |||
1280 | |( | ||
1281 | { before(grammarAccess.getALSComparisonAccess().getGroup_1_0_6()); } | ||
1282 | (rule__ALSComparison__Group_1_0_6__0) | ||
1283 | { after(grammarAccess.getALSComparisonAccess().getGroup_1_0_6()); } | ||
1284 | ) | ||
1285 | |||
1286 | ; | ||
1287 | finally { | ||
1288 | restoreStackSize(stackSize); | ||
1289 | } | ||
1290 | |||
1291 | rule__ALSPreficed__Alternatives | ||
1292 | @init { | ||
1293 | int stackSize = keepStackSize(); | ||
1294 | } | ||
1295 | : | ||
1296 | ( | ||
1297 | { before(grammarAccess.getALSPreficedAccess().getGroup_0()); } | ||
1298 | (rule__ALSPreficed__Group_0__0) | ||
1299 | { after(grammarAccess.getALSPreficedAccess().getGroup_0()); } | ||
1300 | ) | ||
1301 | |||
1302 | |( | ||
1303 | { before(grammarAccess.getALSPreficedAccess().getGroup_1()); } | ||
1304 | (rule__ALSPreficed__Group_1__0) | ||
1305 | { after(grammarAccess.getALSPreficedAccess().getGroup_1()); } | ||
1306 | ) | ||
1307 | |||
1308 | |( | ||
1309 | { before(grammarAccess.getALSPreficedAccess().getGroup_2()); } | ||
1310 | (rule__ALSPreficed__Group_2__0) | ||
1311 | { after(grammarAccess.getALSPreficedAccess().getGroup_2()); } | ||
1312 | ) | ||
1313 | |||
1314 | |( | ||
1315 | { before(grammarAccess.getALSPreficedAccess().getGroup_3()); } | ||
1316 | (rule__ALSPreficed__Group_3__0) | ||
1317 | { after(grammarAccess.getALSPreficedAccess().getGroup_3()); } | ||
1318 | ) | ||
1319 | |||
1320 | |( | ||
1321 | { before(grammarAccess.getALSPreficedAccess().getGroup_4()); } | ||
1322 | (rule__ALSPreficed__Group_4__0) | ||
1323 | { after(grammarAccess.getALSPreficedAccess().getGroup_4()); } | ||
1324 | ) | ||
1325 | |||
1326 | |( | ||
1327 | { before(grammarAccess.getALSPreficedAccess().getGroup_5()); } | ||
1328 | (rule__ALSPreficed__Group_5__0) | ||
1329 | { after(grammarAccess.getALSPreficedAccess().getGroup_5()); } | ||
1330 | ) | ||
1331 | |||
1332 | |( | ||
1333 | { before(grammarAccess.getALSPreficedAccess().getGroup_6()); } | ||
1334 | (rule__ALSPreficed__Group_6__0) | ||
1335 | { after(grammarAccess.getALSPreficedAccess().getGroup_6()); } | ||
1336 | ) | ||
1337 | |||
1338 | |( | ||
1339 | { before(grammarAccess.getALSPreficedAccess().getGroup_7()); } | ||
1340 | (rule__ALSPreficed__Group_7__0) | ||
1341 | { after(grammarAccess.getALSPreficedAccess().getGroup_7()); } | ||
1342 | ) | ||
1343 | |||
1344 | |( | ||
1345 | { before(grammarAccess.getALSPreficedAccess().getALSBasicRelationTermParserRuleCall_8()); } | ||
1346 | ruleALSBasicRelationTerm | ||
1347 | { after(grammarAccess.getALSPreficedAccess().getALSBasicRelationTermParserRuleCall_8()); } | ||
1348 | ) | ||
1349 | |||
1350 | ; | ||
1351 | finally { | ||
1352 | restoreStackSize(stackSize); | ||
1353 | } | ||
1354 | |||
1355 | rule__ALSPreficed__Alternatives_0_1_0 | ||
1356 | @init { | ||
1357 | int stackSize = keepStackSize(); | ||
1358 | } | ||
1359 | : | ||
1360 | ( | ||
1361 | { before(grammarAccess.getALSPreficedAccess().getExclamationMarkKeyword_0_1_0_0()); } | ||
1362 | |||
1363 | '!' | ||
1364 | |||
1365 | { after(grammarAccess.getALSPreficedAccess().getExclamationMarkKeyword_0_1_0_0()); } | ||
1366 | ) | ||
1367 | |||
1368 | |( | ||
1369 | { before(grammarAccess.getALSPreficedAccess().getNotKeyword_0_1_0_1()); } | ||
1370 | |||
1371 | 'not' | ||
1372 | |||
1373 | { after(grammarAccess.getALSPreficedAccess().getNotKeyword_0_1_0_1()); } | ||
1374 | ) | ||
1375 | |||
1376 | ; | ||
1377 | finally { | ||
1378 | restoreStackSize(stackSize); | ||
1379 | } | ||
1380 | |||
1381 | rule__ALSPreficed__Alternatives_7_1 | ||
1382 | @init { | ||
1383 | int stackSize = keepStackSize(); | ||
1384 | } | ||
1385 | : | ||
1386 | ( | ||
1387 | { before(grammarAccess.getALSPreficedAccess().getReferredDefinitionAssignment_7_1_0()); } | ||
1388 | (rule__ALSPreficed__ReferredDefinitionAssignment_7_1_0) | ||
1389 | { after(grammarAccess.getALSPreficedAccess().getReferredDefinitionAssignment_7_1_0()); } | ||
1390 | ) | ||
1391 | |||
1392 | |( | ||
1393 | { before(grammarAccess.getALSPreficedAccess().getReferredNumericOperatorAssignment_7_1_1()); } | ||
1394 | (rule__ALSPreficed__ReferredNumericOperatorAssignment_7_1_1) | ||
1395 | { after(grammarAccess.getALSPreficedAccess().getReferredNumericOperatorAssignment_7_1_1()); } | ||
1396 | ) | ||
1397 | |||
1398 | ; | ||
1399 | finally { | ||
1400 | restoreStackSize(stackSize); | ||
1401 | } | ||
1402 | |||
1403 | rule__ALSBasicRelationTerm__Alternatives | ||
1404 | @init { | ||
1405 | int stackSize = keepStackSize(); | ||
1406 | } | ||
1407 | : | ||
1408 | ( | ||
1409 | { before(grammarAccess.getALSBasicRelationTermAccess().getGroup_0()); } | ||
1410 | (rule__ALSBasicRelationTerm__Group_0__0) | ||
1411 | { after(grammarAccess.getALSBasicRelationTermAccess().getGroup_0()); } | ||
1412 | ) | ||
1413 | |||
1414 | |( | ||
1415 | { before(grammarAccess.getALSBasicRelationTermAccess().getGroup_1()); } | ||
1416 | (rule__ALSBasicRelationTerm__Group_1__0) | ||
1417 | { after(grammarAccess.getALSBasicRelationTermAccess().getGroup_1()); } | ||
1418 | ) | ||
1419 | |||
1420 | |( | ||
1421 | { before(grammarAccess.getALSBasicRelationTermAccess().getGroup_2()); } | ||
1422 | (rule__ALSBasicRelationTerm__Group_2__0) | ||
1423 | { after(grammarAccess.getALSBasicRelationTermAccess().getGroup_2()); } | ||
1424 | ) | ||
1425 | |||
1426 | |( | ||
1427 | { before(grammarAccess.getALSBasicRelationTermAccess().getGroup_3()); } | ||
1428 | (rule__ALSBasicRelationTerm__Group_3__0) | ||
1429 | { after(grammarAccess.getALSBasicRelationTermAccess().getGroup_3()); } | ||
1430 | ) | ||
1431 | |||
1432 | |( | ||
1433 | { before(grammarAccess.getALSBasicRelationTermAccess().getGroup_4()); } | ||
1434 | (rule__ALSBasicRelationTerm__Group_4__0) | ||
1435 | { after(grammarAccess.getALSBasicRelationTermAccess().getGroup_4()); } | ||
1436 | ) | ||
1437 | |||
1438 | |( | ||
1439 | { before(grammarAccess.getALSBasicRelationTermAccess().getGroup_5()); } | ||
1440 | (rule__ALSBasicRelationTerm__Group_5__0) | ||
1441 | { after(grammarAccess.getALSBasicRelationTermAccess().getGroup_5()); } | ||
1442 | ) | ||
1443 | |||
1444 | |( | ||
1445 | { before(grammarAccess.getALSBasicRelationTermAccess().getGroup_6()); } | ||
1446 | (rule__ALSBasicRelationTerm__Group_6__0) | ||
1447 | { after(grammarAccess.getALSBasicRelationTermAccess().getGroup_6()); } | ||
1448 | ) | ||
1449 | |||
1450 | ; | ||
1451 | finally { | ||
1452 | restoreStackSize(stackSize); | ||
1453 | } | ||
1454 | |||
1455 | rule__ALSTypeScope__Alternatives | ||
1456 | @init { | ||
1457 | int stackSize = keepStackSize(); | ||
1458 | } | ||
1459 | : | ||
1460 | ( | ||
1461 | { before(grammarAccess.getALSTypeScopeAccess().getALSSigScopeParserRuleCall_0()); } | ||
1462 | ruleALSSigScope | ||
1463 | { after(grammarAccess.getALSTypeScopeAccess().getALSSigScopeParserRuleCall_0()); } | ||
1464 | ) | ||
1465 | |||
1466 | |( | ||
1467 | { before(grammarAccess.getALSTypeScopeAccess().getALSIntScopeParserRuleCall_1()); } | ||
1468 | ruleALSIntScope | ||
1469 | { after(grammarAccess.getALSTypeScopeAccess().getALSIntScopeParserRuleCall_1()); } | ||
1470 | ) | ||
1471 | |||
1472 | ; | ||
1473 | finally { | ||
1474 | restoreStackSize(stackSize); | ||
1475 | } | ||
1476 | |||
1477 | rule__ALSMultiplicity__Alternatives | ||
1478 | @init { | ||
1479 | int stackSize = keepStackSize(); | ||
1480 | } | ||
1481 | : | ||
1482 | ( | ||
1483 | { before(grammarAccess.getALSMultiplicityAccess().getAllEnumLiteralDeclaration_0()); } | ||
1484 | ( 'all' | ||
1485 | ) | ||
1486 | { after(grammarAccess.getALSMultiplicityAccess().getAllEnumLiteralDeclaration_0()); } | ||
1487 | ) | ||
1488 | |||
1489 | |( | ||
1490 | { before(grammarAccess.getALSMultiplicityAccess().getNoEnumLiteralDeclaration_1()); } | ||
1491 | ( 'no' | ||
1492 | ) | ||
1493 | { after(grammarAccess.getALSMultiplicityAccess().getNoEnumLiteralDeclaration_1()); } | ||
1494 | ) | ||
1495 | |||
1496 | |( | ||
1497 | { before(grammarAccess.getALSMultiplicityAccess().getSomeEnumLiteralDeclaration_2()); } | ||
1498 | ( 'some' | ||
1499 | ) | ||
1500 | { after(grammarAccess.getALSMultiplicityAccess().getSomeEnumLiteralDeclaration_2()); } | ||
1501 | ) | ||
1502 | |||
1503 | |( | ||
1504 | { before(grammarAccess.getALSMultiplicityAccess().getLoneEnumLiteralDeclaration_3()); } | ||
1505 | ( 'lone' | ||
1506 | ) | ||
1507 | { after(grammarAccess.getALSMultiplicityAccess().getLoneEnumLiteralDeclaration_3()); } | ||
1508 | ) | ||
1509 | |||
1510 | |( | ||
1511 | { before(grammarAccess.getALSMultiplicityAccess().getOneEnumLiteralDeclaration_4()); } | ||
1512 | ( 'one' | ||
1513 | ) | ||
1514 | { after(grammarAccess.getALSMultiplicityAccess().getOneEnumLiteralDeclaration_4()); } | ||
1515 | ) | ||
1516 | |||
1517 | |( | ||
1518 | { before(grammarAccess.getALSMultiplicityAccess().getSetEnumLiteralDeclaration_5()); } | ||
1519 | ( 'set' | ||
1520 | ) | ||
1521 | { after(grammarAccess.getALSMultiplicityAccess().getSetEnumLiteralDeclaration_5()); } | ||
1522 | ) | ||
1523 | |||
1524 | ; | ||
1525 | finally { | ||
1526 | restoreStackSize(stackSize); | ||
1527 | } | ||
1528 | |||
1529 | rule__ALSNumericOperator__Alternatives | ||
1530 | @init { | ||
1531 | int stackSize = keepStackSize(); | ||
1532 | } | ||
1533 | : | ||
1534 | ( | ||
1535 | { before(grammarAccess.getALSNumericOperatorAccess().getPlusEnumLiteralDeclaration_0()); } | ||
1536 | ( 'plus' | ||
1537 | ) | ||
1538 | { after(grammarAccess.getALSNumericOperatorAccess().getPlusEnumLiteralDeclaration_0()); } | ||
1539 | ) | ||
1540 | |||
1541 | |( | ||
1542 | { before(grammarAccess.getALSNumericOperatorAccess().getSubEnumLiteralDeclaration_1()); } | ||
1543 | ( 'sub' | ||
1544 | ) | ||
1545 | { after(grammarAccess.getALSNumericOperatorAccess().getSubEnumLiteralDeclaration_1()); } | ||
1546 | ) | ||
1547 | |||
1548 | |( | ||
1549 | { before(grammarAccess.getALSNumericOperatorAccess().getMulEnumLiteralDeclaration_2()); } | ||
1550 | ( 'mul' | ||
1551 | ) | ||
1552 | { after(grammarAccess.getALSNumericOperatorAccess().getMulEnumLiteralDeclaration_2()); } | ||
1553 | ) | ||
1554 | |||
1555 | |( | ||
1556 | { before(grammarAccess.getALSNumericOperatorAccess().getRemEnumLiteralDeclaration_3()); } | ||
1557 | ( 'rem' | ||
1558 | ) | ||
1559 | { after(grammarAccess.getALSNumericOperatorAccess().getRemEnumLiteralDeclaration_3()); } | ||
1560 | ) | ||
1561 | |||
1562 | |( | ||
1563 | { before(grammarAccess.getALSNumericOperatorAccess().getDivEnumLiteralDeclaration_4()); } | ||
1564 | ( 'div' | ||
1565 | ) | ||
1566 | { after(grammarAccess.getALSNumericOperatorAccess().getDivEnumLiteralDeclaration_4()); } | ||
1567 | ) | ||
1568 | |||
1569 | ; | ||
1570 | finally { | ||
1571 | restoreStackSize(stackSize); | ||
1572 | } | ||
1573 | |||
1574 | |||
1575 | |||
1576 | rule__ALSDocument__Group__0 | ||
1577 | @init { | ||
1578 | int stackSize = keepStackSize(); | ||
1579 | } | ||
1580 | : | ||
1581 | rule__ALSDocument__Group__0__Impl | ||
1582 | rule__ALSDocument__Group__1 | ||
1583 | ; | ||
1584 | finally { | ||
1585 | restoreStackSize(stackSize); | ||
1586 | } | ||
1587 | |||
1588 | rule__ALSDocument__Group__0__Impl | ||
1589 | @init { | ||
1590 | int stackSize = keepStackSize(); | ||
1591 | } | ||
1592 | : | ||
1593 | ( | ||
1594 | ( | ||
1595 | { before(grammarAccess.getALSDocumentAccess().getAlternatives_0()); } | ||
1596 | (rule__ALSDocument__Alternatives_0) | ||
1597 | { after(grammarAccess.getALSDocumentAccess().getAlternatives_0()); } | ||
1598 | ) | ||
1599 | ( | ||
1600 | { before(grammarAccess.getALSDocumentAccess().getAlternatives_0()); } | ||
1601 | (rule__ALSDocument__Alternatives_0)* | ||
1602 | { after(grammarAccess.getALSDocumentAccess().getAlternatives_0()); } | ||
1603 | ) | ||
1604 | ) | ||
1605 | |||
1606 | ; | ||
1607 | finally { | ||
1608 | restoreStackSize(stackSize); | ||
1609 | } | ||
1610 | |||
1611 | |||
1612 | rule__ALSDocument__Group__1 | ||
1613 | @init { | ||
1614 | int stackSize = keepStackSize(); | ||
1615 | } | ||
1616 | : | ||
1617 | rule__ALSDocument__Group__1__Impl | ||
1618 | ; | ||
1619 | finally { | ||
1620 | restoreStackSize(stackSize); | ||
1621 | } | ||
1622 | |||
1623 | rule__ALSDocument__Group__1__Impl | ||
1624 | @init { | ||
1625 | int stackSize = keepStackSize(); | ||
1626 | } | ||
1627 | : | ||
1628 | ( | ||
1629 | { before(grammarAccess.getALSDocumentAccess().getRunCommandAssignment_1()); } | ||
1630 | (rule__ALSDocument__RunCommandAssignment_1) | ||
1631 | { after(grammarAccess.getALSDocumentAccess().getRunCommandAssignment_1()); } | ||
1632 | ) | ||
1633 | |||
1634 | ; | ||
1635 | finally { | ||
1636 | restoreStackSize(stackSize); | ||
1637 | } | ||
1638 | |||
1639 | |||
1640 | |||
1641 | |||
1642 | |||
1643 | |||
1644 | rule__ALSEnumDeclaration__Group__0 | ||
1645 | @init { | ||
1646 | int stackSize = keepStackSize(); | ||
1647 | } | ||
1648 | : | ||
1649 | rule__ALSEnumDeclaration__Group__0__Impl | ||
1650 | rule__ALSEnumDeclaration__Group__1 | ||
1651 | ; | ||
1652 | finally { | ||
1653 | restoreStackSize(stackSize); | ||
1654 | } | ||
1655 | |||
1656 | rule__ALSEnumDeclaration__Group__0__Impl | ||
1657 | @init { | ||
1658 | int stackSize = keepStackSize(); | ||
1659 | } | ||
1660 | : | ||
1661 | ( | ||
1662 | { before(grammarAccess.getALSEnumDeclarationAccess().getEnumKeyword_0()); } | ||
1663 | |||
1664 | 'enum' | ||
1665 | |||
1666 | { after(grammarAccess.getALSEnumDeclarationAccess().getEnumKeyword_0()); } | ||
1667 | ) | ||
1668 | |||
1669 | ; | ||
1670 | finally { | ||
1671 | restoreStackSize(stackSize); | ||
1672 | } | ||
1673 | |||
1674 | |||
1675 | rule__ALSEnumDeclaration__Group__1 | ||
1676 | @init { | ||
1677 | int stackSize = keepStackSize(); | ||
1678 | } | ||
1679 | : | ||
1680 | rule__ALSEnumDeclaration__Group__1__Impl | ||
1681 | rule__ALSEnumDeclaration__Group__2 | ||
1682 | ; | ||
1683 | finally { | ||
1684 | restoreStackSize(stackSize); | ||
1685 | } | ||
1686 | |||
1687 | rule__ALSEnumDeclaration__Group__1__Impl | ||
1688 | @init { | ||
1689 | int stackSize = keepStackSize(); | ||
1690 | } | ||
1691 | : | ||
1692 | ( | ||
1693 | { before(grammarAccess.getALSEnumDeclarationAccess().getNameAssignment_1()); } | ||
1694 | (rule__ALSEnumDeclaration__NameAssignment_1) | ||
1695 | { after(grammarAccess.getALSEnumDeclarationAccess().getNameAssignment_1()); } | ||
1696 | ) | ||
1697 | |||
1698 | ; | ||
1699 | finally { | ||
1700 | restoreStackSize(stackSize); | ||
1701 | } | ||
1702 | |||
1703 | |||
1704 | rule__ALSEnumDeclaration__Group__2 | ||
1705 | @init { | ||
1706 | int stackSize = keepStackSize(); | ||
1707 | } | ||
1708 | : | ||
1709 | rule__ALSEnumDeclaration__Group__2__Impl | ||
1710 | rule__ALSEnumDeclaration__Group__3 | ||
1711 | ; | ||
1712 | finally { | ||
1713 | restoreStackSize(stackSize); | ||
1714 | } | ||
1715 | |||
1716 | rule__ALSEnumDeclaration__Group__2__Impl | ||
1717 | @init { | ||
1718 | int stackSize = keepStackSize(); | ||
1719 | } | ||
1720 | : | ||
1721 | ( | ||
1722 | { before(grammarAccess.getALSEnumDeclarationAccess().getLeftCurlyBracketKeyword_2()); } | ||
1723 | |||
1724 | '{' | ||
1725 | |||
1726 | { after(grammarAccess.getALSEnumDeclarationAccess().getLeftCurlyBracketKeyword_2()); } | ||
1727 | ) | ||
1728 | |||
1729 | ; | ||
1730 | finally { | ||
1731 | restoreStackSize(stackSize); | ||
1732 | } | ||
1733 | |||
1734 | |||
1735 | rule__ALSEnumDeclaration__Group__3 | ||
1736 | @init { | ||
1737 | int stackSize = keepStackSize(); | ||
1738 | } | ||
1739 | : | ||
1740 | rule__ALSEnumDeclaration__Group__3__Impl | ||
1741 | rule__ALSEnumDeclaration__Group__4 | ||
1742 | ; | ||
1743 | finally { | ||
1744 | restoreStackSize(stackSize); | ||
1745 | } | ||
1746 | |||
1747 | rule__ALSEnumDeclaration__Group__3__Impl | ||
1748 | @init { | ||
1749 | int stackSize = keepStackSize(); | ||
1750 | } | ||
1751 | : | ||
1752 | ( | ||
1753 | { before(grammarAccess.getALSEnumDeclarationAccess().getLiteralAssignment_3()); } | ||
1754 | (rule__ALSEnumDeclaration__LiteralAssignment_3) | ||
1755 | { after(grammarAccess.getALSEnumDeclarationAccess().getLiteralAssignment_3()); } | ||
1756 | ) | ||
1757 | |||
1758 | ; | ||
1759 | finally { | ||
1760 | restoreStackSize(stackSize); | ||
1761 | } | ||
1762 | |||
1763 | |||
1764 | rule__ALSEnumDeclaration__Group__4 | ||
1765 | @init { | ||
1766 | int stackSize = keepStackSize(); | ||
1767 | } | ||
1768 | : | ||
1769 | rule__ALSEnumDeclaration__Group__4__Impl | ||
1770 | rule__ALSEnumDeclaration__Group__5 | ||
1771 | ; | ||
1772 | finally { | ||
1773 | restoreStackSize(stackSize); | ||
1774 | } | ||
1775 | |||
1776 | rule__ALSEnumDeclaration__Group__4__Impl | ||
1777 | @init { | ||
1778 | int stackSize = keepStackSize(); | ||
1779 | } | ||
1780 | : | ||
1781 | ( | ||
1782 | { before(grammarAccess.getALSEnumDeclarationAccess().getGroup_4()); } | ||
1783 | (rule__ALSEnumDeclaration__Group_4__0)* | ||
1784 | { after(grammarAccess.getALSEnumDeclarationAccess().getGroup_4()); } | ||
1785 | ) | ||
1786 | |||
1787 | ; | ||
1788 | finally { | ||
1789 | restoreStackSize(stackSize); | ||
1790 | } | ||
1791 | |||
1792 | |||
1793 | rule__ALSEnumDeclaration__Group__5 | ||
1794 | @init { | ||
1795 | int stackSize = keepStackSize(); | ||
1796 | } | ||
1797 | : | ||
1798 | rule__ALSEnumDeclaration__Group__5__Impl | ||
1799 | ; | ||
1800 | finally { | ||
1801 | restoreStackSize(stackSize); | ||
1802 | } | ||
1803 | |||
1804 | rule__ALSEnumDeclaration__Group__5__Impl | ||
1805 | @init { | ||
1806 | int stackSize = keepStackSize(); | ||
1807 | } | ||
1808 | : | ||
1809 | ( | ||
1810 | { before(grammarAccess.getALSEnumDeclarationAccess().getRightCurlyBracketKeyword_5()); } | ||
1811 | |||
1812 | '}' | ||
1813 | |||
1814 | { after(grammarAccess.getALSEnumDeclarationAccess().getRightCurlyBracketKeyword_5()); } | ||
1815 | ) | ||
1816 | |||
1817 | ; | ||
1818 | finally { | ||
1819 | restoreStackSize(stackSize); | ||
1820 | } | ||
1821 | |||
1822 | |||
1823 | |||
1824 | |||
1825 | |||
1826 | |||
1827 | |||
1828 | |||
1829 | |||
1830 | |||
1831 | |||
1832 | |||
1833 | |||
1834 | |||
1835 | rule__ALSEnumDeclaration__Group_4__0 | ||
1836 | @init { | ||
1837 | int stackSize = keepStackSize(); | ||
1838 | } | ||
1839 | : | ||
1840 | rule__ALSEnumDeclaration__Group_4__0__Impl | ||
1841 | rule__ALSEnumDeclaration__Group_4__1 | ||
1842 | ; | ||
1843 | finally { | ||
1844 | restoreStackSize(stackSize); | ||
1845 | } | ||
1846 | |||
1847 | rule__ALSEnumDeclaration__Group_4__0__Impl | ||
1848 | @init { | ||
1849 | int stackSize = keepStackSize(); | ||
1850 | } | ||
1851 | : | ||
1852 | ( | ||
1853 | { before(grammarAccess.getALSEnumDeclarationAccess().getCommaKeyword_4_0()); } | ||
1854 | |||
1855 | ',' | ||
1856 | |||
1857 | { after(grammarAccess.getALSEnumDeclarationAccess().getCommaKeyword_4_0()); } | ||
1858 | ) | ||
1859 | |||
1860 | ; | ||
1861 | finally { | ||
1862 | restoreStackSize(stackSize); | ||
1863 | } | ||
1864 | |||
1865 | |||
1866 | rule__ALSEnumDeclaration__Group_4__1 | ||
1867 | @init { | ||
1868 | int stackSize = keepStackSize(); | ||
1869 | } | ||
1870 | : | ||
1871 | rule__ALSEnumDeclaration__Group_4__1__Impl | ||
1872 | ; | ||
1873 | finally { | ||
1874 | restoreStackSize(stackSize); | ||
1875 | } | ||
1876 | |||
1877 | rule__ALSEnumDeclaration__Group_4__1__Impl | ||
1878 | @init { | ||
1879 | int stackSize = keepStackSize(); | ||
1880 | } | ||
1881 | : | ||
1882 | ( | ||
1883 | { before(grammarAccess.getALSEnumDeclarationAccess().getLiteralAssignment_4_1()); } | ||
1884 | (rule__ALSEnumDeclaration__LiteralAssignment_4_1) | ||
1885 | { after(grammarAccess.getALSEnumDeclarationAccess().getLiteralAssignment_4_1()); } | ||
1886 | ) | ||
1887 | |||
1888 | ; | ||
1889 | finally { | ||
1890 | restoreStackSize(stackSize); | ||
1891 | } | ||
1892 | |||
1893 | |||
1894 | |||
1895 | |||
1896 | |||
1897 | |||
1898 | rule__ALSSignatureBody__Group__0 | ||
1899 | @init { | ||
1900 | int stackSize = keepStackSize(); | ||
1901 | } | ||
1902 | : | ||
1903 | rule__ALSSignatureBody__Group__0__Impl | ||
1904 | rule__ALSSignatureBody__Group__1 | ||
1905 | ; | ||
1906 | finally { | ||
1907 | restoreStackSize(stackSize); | ||
1908 | } | ||
1909 | |||
1910 | rule__ALSSignatureBody__Group__0__Impl | ||
1911 | @init { | ||
1912 | int stackSize = keepStackSize(); | ||
1913 | } | ||
1914 | : | ||
1915 | ( | ||
1916 | { before(grammarAccess.getALSSignatureBodyAccess().getUnorderedGroup_0()); } | ||
1917 | (rule__ALSSignatureBody__UnorderedGroup_0) | ||
1918 | { after(grammarAccess.getALSSignatureBodyAccess().getUnorderedGroup_0()); } | ||
1919 | ) | ||
1920 | |||
1921 | ; | ||
1922 | finally { | ||
1923 | restoreStackSize(stackSize); | ||
1924 | } | ||
1925 | |||
1926 | |||
1927 | rule__ALSSignatureBody__Group__1 | ||
1928 | @init { | ||
1929 | int stackSize = keepStackSize(); | ||
1930 | } | ||
1931 | : | ||
1932 | rule__ALSSignatureBody__Group__1__Impl | ||
1933 | rule__ALSSignatureBody__Group__2 | ||
1934 | ; | ||
1935 | finally { | ||
1936 | restoreStackSize(stackSize); | ||
1937 | } | ||
1938 | |||
1939 | rule__ALSSignatureBody__Group__1__Impl | ||
1940 | @init { | ||
1941 | int stackSize = keepStackSize(); | ||
1942 | } | ||
1943 | : | ||
1944 | ( | ||
1945 | { before(grammarAccess.getALSSignatureBodyAccess().getSigKeyword_1()); } | ||
1946 | |||
1947 | 'sig' | ||
1948 | |||
1949 | { after(grammarAccess.getALSSignatureBodyAccess().getSigKeyword_1()); } | ||
1950 | ) | ||
1951 | |||
1952 | ; | ||
1953 | finally { | ||
1954 | restoreStackSize(stackSize); | ||
1955 | } | ||
1956 | |||
1957 | |||
1958 | rule__ALSSignatureBody__Group__2 | ||
1959 | @init { | ||
1960 | int stackSize = keepStackSize(); | ||
1961 | } | ||
1962 | : | ||
1963 | rule__ALSSignatureBody__Group__2__Impl | ||
1964 | rule__ALSSignatureBody__Group__3 | ||
1965 | ; | ||
1966 | finally { | ||
1967 | restoreStackSize(stackSize); | ||
1968 | } | ||
1969 | |||
1970 | rule__ALSSignatureBody__Group__2__Impl | ||
1971 | @init { | ||
1972 | int stackSize = keepStackSize(); | ||
1973 | } | ||
1974 | : | ||
1975 | ( | ||
1976 | { before(grammarAccess.getALSSignatureBodyAccess().getDeclarationsAssignment_2()); } | ||
1977 | (rule__ALSSignatureBody__DeclarationsAssignment_2) | ||
1978 | { after(grammarAccess.getALSSignatureBodyAccess().getDeclarationsAssignment_2()); } | ||
1979 | ) | ||
1980 | |||
1981 | ; | ||
1982 | finally { | ||
1983 | restoreStackSize(stackSize); | ||
1984 | } | ||
1985 | |||
1986 | |||
1987 | rule__ALSSignatureBody__Group__3 | ||
1988 | @init { | ||
1989 | int stackSize = keepStackSize(); | ||
1990 | } | ||
1991 | : | ||
1992 | rule__ALSSignatureBody__Group__3__Impl | ||
1993 | rule__ALSSignatureBody__Group__4 | ||
1994 | ; | ||
1995 | finally { | ||
1996 | restoreStackSize(stackSize); | ||
1997 | } | ||
1998 | |||
1999 | rule__ALSSignatureBody__Group__3__Impl | ||
2000 | @init { | ||
2001 | int stackSize = keepStackSize(); | ||
2002 | } | ||
2003 | : | ||
2004 | ( | ||
2005 | { before(grammarAccess.getALSSignatureBodyAccess().getGroup_3()); } | ||
2006 | (rule__ALSSignatureBody__Group_3__0)* | ||
2007 | { after(grammarAccess.getALSSignatureBodyAccess().getGroup_3()); } | ||
2008 | ) | ||
2009 | |||
2010 | ; | ||
2011 | finally { | ||
2012 | restoreStackSize(stackSize); | ||
2013 | } | ||
2014 | |||
2015 | |||
2016 | rule__ALSSignatureBody__Group__4 | ||
2017 | @init { | ||
2018 | int stackSize = keepStackSize(); | ||
2019 | } | ||
2020 | : | ||
2021 | rule__ALSSignatureBody__Group__4__Impl | ||
2022 | rule__ALSSignatureBody__Group__5 | ||
2023 | ; | ||
2024 | finally { | ||
2025 | restoreStackSize(stackSize); | ||
2026 | } | ||
2027 | |||
2028 | rule__ALSSignatureBody__Group__4__Impl | ||
2029 | @init { | ||
2030 | int stackSize = keepStackSize(); | ||
2031 | } | ||
2032 | : | ||
2033 | ( | ||
2034 | { before(grammarAccess.getALSSignatureBodyAccess().getAlternatives_4()); } | ||
2035 | (rule__ALSSignatureBody__Alternatives_4)? | ||
2036 | { after(grammarAccess.getALSSignatureBodyAccess().getAlternatives_4()); } | ||
2037 | ) | ||
2038 | |||
2039 | ; | ||
2040 | finally { | ||
2041 | restoreStackSize(stackSize); | ||
2042 | } | ||
2043 | |||
2044 | |||
2045 | rule__ALSSignatureBody__Group__5 | ||
2046 | @init { | ||
2047 | int stackSize = keepStackSize(); | ||
2048 | } | ||
2049 | : | ||
2050 | rule__ALSSignatureBody__Group__5__Impl | ||
2051 | rule__ALSSignatureBody__Group__6 | ||
2052 | ; | ||
2053 | finally { | ||
2054 | restoreStackSize(stackSize); | ||
2055 | } | ||
2056 | |||
2057 | rule__ALSSignatureBody__Group__5__Impl | ||
2058 | @init { | ||
2059 | int stackSize = keepStackSize(); | ||
2060 | } | ||
2061 | : | ||
2062 | ( | ||
2063 | { before(grammarAccess.getALSSignatureBodyAccess().getLeftCurlyBracketKeyword_5()); } | ||
2064 | |||
2065 | '{' | ||
2066 | |||
2067 | { after(grammarAccess.getALSSignatureBodyAccess().getLeftCurlyBracketKeyword_5()); } | ||
2068 | ) | ||
2069 | |||
2070 | ; | ||
2071 | finally { | ||
2072 | restoreStackSize(stackSize); | ||
2073 | } | ||
2074 | |||
2075 | |||
2076 | rule__ALSSignatureBody__Group__6 | ||
2077 | @init { | ||
2078 | int stackSize = keepStackSize(); | ||
2079 | } | ||
2080 | : | ||
2081 | rule__ALSSignatureBody__Group__6__Impl | ||
2082 | rule__ALSSignatureBody__Group__7 | ||
2083 | ; | ||
2084 | finally { | ||
2085 | restoreStackSize(stackSize); | ||
2086 | } | ||
2087 | |||
2088 | rule__ALSSignatureBody__Group__6__Impl | ||
2089 | @init { | ||
2090 | int stackSize = keepStackSize(); | ||
2091 | } | ||
2092 | : | ||
2093 | ( | ||
2094 | { before(grammarAccess.getALSSignatureBodyAccess().getGroup_6()); } | ||
2095 | (rule__ALSSignatureBody__Group_6__0)? | ||
2096 | { after(grammarAccess.getALSSignatureBodyAccess().getGroup_6()); } | ||
2097 | ) | ||
2098 | |||
2099 | ; | ||
2100 | finally { | ||
2101 | restoreStackSize(stackSize); | ||
2102 | } | ||
2103 | |||
2104 | |||
2105 | rule__ALSSignatureBody__Group__7 | ||
2106 | @init { | ||
2107 | int stackSize = keepStackSize(); | ||
2108 | } | ||
2109 | : | ||
2110 | rule__ALSSignatureBody__Group__7__Impl | ||
2111 | ; | ||
2112 | finally { | ||
2113 | restoreStackSize(stackSize); | ||
2114 | } | ||
2115 | |||
2116 | rule__ALSSignatureBody__Group__7__Impl | ||
2117 | @init { | ||
2118 | int stackSize = keepStackSize(); | ||
2119 | } | ||
2120 | : | ||
2121 | ( | ||
2122 | { before(grammarAccess.getALSSignatureBodyAccess().getRightCurlyBracketKeyword_7()); } | ||
2123 | |||
2124 | '}' | ||
2125 | |||
2126 | { after(grammarAccess.getALSSignatureBodyAccess().getRightCurlyBracketKeyword_7()); } | ||
2127 | ) | ||
2128 | |||
2129 | ; | ||
2130 | finally { | ||
2131 | restoreStackSize(stackSize); | ||
2132 | } | ||
2133 | |||
2134 | |||
2135 | |||
2136 | |||
2137 | |||
2138 | |||
2139 | |||
2140 | |||
2141 | |||
2142 | |||
2143 | |||
2144 | |||
2145 | |||
2146 | |||
2147 | |||
2148 | |||
2149 | |||
2150 | |||
2151 | rule__ALSSignatureBody__Group_3__0 | ||
2152 | @init { | ||
2153 | int stackSize = keepStackSize(); | ||
2154 | } | ||
2155 | : | ||
2156 | rule__ALSSignatureBody__Group_3__0__Impl | ||
2157 | rule__ALSSignatureBody__Group_3__1 | ||
2158 | ; | ||
2159 | finally { | ||
2160 | restoreStackSize(stackSize); | ||
2161 | } | ||
2162 | |||
2163 | rule__ALSSignatureBody__Group_3__0__Impl | ||
2164 | @init { | ||
2165 | int stackSize = keepStackSize(); | ||
2166 | } | ||
2167 | : | ||
2168 | ( | ||
2169 | { before(grammarAccess.getALSSignatureBodyAccess().getCommaKeyword_3_0()); } | ||
2170 | |||
2171 | ',' | ||
2172 | |||
2173 | { after(grammarAccess.getALSSignatureBodyAccess().getCommaKeyword_3_0()); } | ||
2174 | ) | ||
2175 | |||
2176 | ; | ||
2177 | finally { | ||
2178 | restoreStackSize(stackSize); | ||
2179 | } | ||
2180 | |||
2181 | |||
2182 | rule__ALSSignatureBody__Group_3__1 | ||
2183 | @init { | ||
2184 | int stackSize = keepStackSize(); | ||
2185 | } | ||
2186 | : | ||
2187 | rule__ALSSignatureBody__Group_3__1__Impl | ||
2188 | ; | ||
2189 | finally { | ||
2190 | restoreStackSize(stackSize); | ||
2191 | } | ||
2192 | |||
2193 | rule__ALSSignatureBody__Group_3__1__Impl | ||
2194 | @init { | ||
2195 | int stackSize = keepStackSize(); | ||
2196 | } | ||
2197 | : | ||
2198 | ( | ||
2199 | { before(grammarAccess.getALSSignatureBodyAccess().getDeclarationsAssignment_3_1()); } | ||
2200 | (rule__ALSSignatureBody__DeclarationsAssignment_3_1) | ||
2201 | { after(grammarAccess.getALSSignatureBodyAccess().getDeclarationsAssignment_3_1()); } | ||
2202 | ) | ||
2203 | |||
2204 | ; | ||
2205 | finally { | ||
2206 | restoreStackSize(stackSize); | ||
2207 | } | ||
2208 | |||
2209 | |||
2210 | |||
2211 | |||
2212 | |||
2213 | |||
2214 | rule__ALSSignatureBody__Group_4_0__0 | ||
2215 | @init { | ||
2216 | int stackSize = keepStackSize(); | ||
2217 | } | ||
2218 | : | ||
2219 | rule__ALSSignatureBody__Group_4_0__0__Impl | ||
2220 | rule__ALSSignatureBody__Group_4_0__1 | ||
2221 | ; | ||
2222 | finally { | ||
2223 | restoreStackSize(stackSize); | ||
2224 | } | ||
2225 | |||
2226 | rule__ALSSignatureBody__Group_4_0__0__Impl | ||
2227 | @init { | ||
2228 | int stackSize = keepStackSize(); | ||
2229 | } | ||
2230 | : | ||
2231 | ( | ||
2232 | { before(grammarAccess.getALSSignatureBodyAccess().getExtendsKeyword_4_0_0()); } | ||
2233 | |||
2234 | 'extends' | ||
2235 | |||
2236 | { after(grammarAccess.getALSSignatureBodyAccess().getExtendsKeyword_4_0_0()); } | ||
2237 | ) | ||
2238 | |||
2239 | ; | ||
2240 | finally { | ||
2241 | restoreStackSize(stackSize); | ||
2242 | } | ||
2243 | |||
2244 | |||
2245 | rule__ALSSignatureBody__Group_4_0__1 | ||
2246 | @init { | ||
2247 | int stackSize = keepStackSize(); | ||
2248 | } | ||
2249 | : | ||
2250 | rule__ALSSignatureBody__Group_4_0__1__Impl | ||
2251 | ; | ||
2252 | finally { | ||
2253 | restoreStackSize(stackSize); | ||
2254 | } | ||
2255 | |||
2256 | rule__ALSSignatureBody__Group_4_0__1__Impl | ||
2257 | @init { | ||
2258 | int stackSize = keepStackSize(); | ||
2259 | } | ||
2260 | : | ||
2261 | ( | ||
2262 | { before(grammarAccess.getALSSignatureBodyAccess().getSupertypeAssignment_4_0_1()); } | ||
2263 | (rule__ALSSignatureBody__SupertypeAssignment_4_0_1) | ||
2264 | { after(grammarAccess.getALSSignatureBodyAccess().getSupertypeAssignment_4_0_1()); } | ||
2265 | ) | ||
2266 | |||
2267 | ; | ||
2268 | finally { | ||
2269 | restoreStackSize(stackSize); | ||
2270 | } | ||
2271 | |||
2272 | |||
2273 | |||
2274 | |||
2275 | |||
2276 | |||
2277 | rule__ALSSignatureBody__Group_4_1__0 | ||
2278 | @init { | ||
2279 | int stackSize = keepStackSize(); | ||
2280 | } | ||
2281 | : | ||
2282 | rule__ALSSignatureBody__Group_4_1__0__Impl | ||
2283 | rule__ALSSignatureBody__Group_4_1__1 | ||
2284 | ; | ||
2285 | finally { | ||
2286 | restoreStackSize(stackSize); | ||
2287 | } | ||
2288 | |||
2289 | rule__ALSSignatureBody__Group_4_1__0__Impl | ||
2290 | @init { | ||
2291 | int stackSize = keepStackSize(); | ||
2292 | } | ||
2293 | : | ||
2294 | ( | ||
2295 | { before(grammarAccess.getALSSignatureBodyAccess().getInKeyword_4_1_0()); } | ||
2296 | |||
2297 | 'in' | ||
2298 | |||
2299 | { after(grammarAccess.getALSSignatureBodyAccess().getInKeyword_4_1_0()); } | ||
2300 | ) | ||
2301 | |||
2302 | ; | ||
2303 | finally { | ||
2304 | restoreStackSize(stackSize); | ||
2305 | } | ||
2306 | |||
2307 | |||
2308 | rule__ALSSignatureBody__Group_4_1__1 | ||
2309 | @init { | ||
2310 | int stackSize = keepStackSize(); | ||
2311 | } | ||
2312 | : | ||
2313 | rule__ALSSignatureBody__Group_4_1__1__Impl | ||
2314 | rule__ALSSignatureBody__Group_4_1__2 | ||
2315 | ; | ||
2316 | finally { | ||
2317 | restoreStackSize(stackSize); | ||
2318 | } | ||
2319 | |||
2320 | rule__ALSSignatureBody__Group_4_1__1__Impl | ||
2321 | @init { | ||
2322 | int stackSize = keepStackSize(); | ||
2323 | } | ||
2324 | : | ||
2325 | ( | ||
2326 | { before(grammarAccess.getALSSignatureBodyAccess().getSupersetAssignment_4_1_1()); } | ||
2327 | (rule__ALSSignatureBody__SupersetAssignment_4_1_1) | ||
2328 | { after(grammarAccess.getALSSignatureBodyAccess().getSupersetAssignment_4_1_1()); } | ||
2329 | ) | ||
2330 | |||
2331 | ; | ||
2332 | finally { | ||
2333 | restoreStackSize(stackSize); | ||
2334 | } | ||
2335 | |||
2336 | |||
2337 | rule__ALSSignatureBody__Group_4_1__2 | ||
2338 | @init { | ||
2339 | int stackSize = keepStackSize(); | ||
2340 | } | ||
2341 | : | ||
2342 | rule__ALSSignatureBody__Group_4_1__2__Impl | ||
2343 | ; | ||
2344 | finally { | ||
2345 | restoreStackSize(stackSize); | ||
2346 | } | ||
2347 | |||
2348 | rule__ALSSignatureBody__Group_4_1__2__Impl | ||
2349 | @init { | ||
2350 | int stackSize = keepStackSize(); | ||
2351 | } | ||
2352 | : | ||
2353 | ( | ||
2354 | { before(grammarAccess.getALSSignatureBodyAccess().getGroup_4_1_2()); } | ||
2355 | (rule__ALSSignatureBody__Group_4_1_2__0)* | ||
2356 | { after(grammarAccess.getALSSignatureBodyAccess().getGroup_4_1_2()); } | ||
2357 | ) | ||
2358 | |||
2359 | ; | ||
2360 | finally { | ||
2361 | restoreStackSize(stackSize); | ||
2362 | } | ||
2363 | |||
2364 | |||
2365 | |||
2366 | |||
2367 | |||
2368 | |||
2369 | |||
2370 | |||
2371 | rule__ALSSignatureBody__Group_4_1_2__0 | ||
2372 | @init { | ||
2373 | int stackSize = keepStackSize(); | ||
2374 | } | ||
2375 | : | ||
2376 | rule__ALSSignatureBody__Group_4_1_2__0__Impl | ||
2377 | rule__ALSSignatureBody__Group_4_1_2__1 | ||
2378 | ; | ||
2379 | finally { | ||
2380 | restoreStackSize(stackSize); | ||
2381 | } | ||
2382 | |||
2383 | rule__ALSSignatureBody__Group_4_1_2__0__Impl | ||
2384 | @init { | ||
2385 | int stackSize = keepStackSize(); | ||
2386 | } | ||
2387 | : | ||
2388 | ( | ||
2389 | { before(grammarAccess.getALSSignatureBodyAccess().getPlusSignKeyword_4_1_2_0()); } | ||
2390 | |||
2391 | '+' | ||
2392 | |||
2393 | { after(grammarAccess.getALSSignatureBodyAccess().getPlusSignKeyword_4_1_2_0()); } | ||
2394 | ) | ||
2395 | |||
2396 | ; | ||
2397 | finally { | ||
2398 | restoreStackSize(stackSize); | ||
2399 | } | ||
2400 | |||
2401 | |||
2402 | rule__ALSSignatureBody__Group_4_1_2__1 | ||
2403 | @init { | ||
2404 | int stackSize = keepStackSize(); | ||
2405 | } | ||
2406 | : | ||
2407 | rule__ALSSignatureBody__Group_4_1_2__1__Impl | ||
2408 | ; | ||
2409 | finally { | ||
2410 | restoreStackSize(stackSize); | ||
2411 | } | ||
2412 | |||
2413 | rule__ALSSignatureBody__Group_4_1_2__1__Impl | ||
2414 | @init { | ||
2415 | int stackSize = keepStackSize(); | ||
2416 | } | ||
2417 | : | ||
2418 | ( | ||
2419 | { before(grammarAccess.getALSSignatureBodyAccess().getSupersetAssignment_4_1_2_1()); } | ||
2420 | (rule__ALSSignatureBody__SupersetAssignment_4_1_2_1) | ||
2421 | { after(grammarAccess.getALSSignatureBodyAccess().getSupersetAssignment_4_1_2_1()); } | ||
2422 | ) | ||
2423 | |||
2424 | ; | ||
2425 | finally { | ||
2426 | restoreStackSize(stackSize); | ||
2427 | } | ||
2428 | |||
2429 | |||
2430 | |||
2431 | |||
2432 | |||
2433 | |||
2434 | rule__ALSSignatureBody__Group_6__0 | ||
2435 | @init { | ||
2436 | int stackSize = keepStackSize(); | ||
2437 | } | ||
2438 | : | ||
2439 | rule__ALSSignatureBody__Group_6__0__Impl | ||
2440 | rule__ALSSignatureBody__Group_6__1 | ||
2441 | ; | ||
2442 | finally { | ||
2443 | restoreStackSize(stackSize); | ||
2444 | } | ||
2445 | |||
2446 | rule__ALSSignatureBody__Group_6__0__Impl | ||
2447 | @init { | ||
2448 | int stackSize = keepStackSize(); | ||
2449 | } | ||
2450 | : | ||
2451 | ( | ||
2452 | { before(grammarAccess.getALSSignatureBodyAccess().getFieldsAssignment_6_0()); } | ||
2453 | (rule__ALSSignatureBody__FieldsAssignment_6_0) | ||
2454 | { after(grammarAccess.getALSSignatureBodyAccess().getFieldsAssignment_6_0()); } | ||
2455 | ) | ||
2456 | |||
2457 | ; | ||
2458 | finally { | ||
2459 | restoreStackSize(stackSize); | ||
2460 | } | ||
2461 | |||
2462 | |||
2463 | rule__ALSSignatureBody__Group_6__1 | ||
2464 | @init { | ||
2465 | int stackSize = keepStackSize(); | ||
2466 | } | ||
2467 | : | ||
2468 | rule__ALSSignatureBody__Group_6__1__Impl | ||
2469 | ; | ||
2470 | finally { | ||
2471 | restoreStackSize(stackSize); | ||
2472 | } | ||
2473 | |||
2474 | rule__ALSSignatureBody__Group_6__1__Impl | ||
2475 | @init { | ||
2476 | int stackSize = keepStackSize(); | ||
2477 | } | ||
2478 | : | ||
2479 | ( | ||
2480 | { before(grammarAccess.getALSSignatureBodyAccess().getGroup_6_1()); } | ||
2481 | (rule__ALSSignatureBody__Group_6_1__0)* | ||
2482 | { after(grammarAccess.getALSSignatureBodyAccess().getGroup_6_1()); } | ||
2483 | ) | ||
2484 | |||
2485 | ; | ||
2486 | finally { | ||
2487 | restoreStackSize(stackSize); | ||
2488 | } | ||
2489 | |||
2490 | |||
2491 | |||
2492 | |||
2493 | |||
2494 | |||
2495 | rule__ALSSignatureBody__Group_6_1__0 | ||
2496 | @init { | ||
2497 | int stackSize = keepStackSize(); | ||
2498 | } | ||
2499 | : | ||
2500 | rule__ALSSignatureBody__Group_6_1__0__Impl | ||
2501 | rule__ALSSignatureBody__Group_6_1__1 | ||
2502 | ; | ||
2503 | finally { | ||
2504 | restoreStackSize(stackSize); | ||
2505 | } | ||
2506 | |||
2507 | rule__ALSSignatureBody__Group_6_1__0__Impl | ||
2508 | @init { | ||
2509 | int stackSize = keepStackSize(); | ||
2510 | } | ||
2511 | : | ||
2512 | ( | ||
2513 | { before(grammarAccess.getALSSignatureBodyAccess().getCommaKeyword_6_1_0()); } | ||
2514 | |||
2515 | ',' | ||
2516 | |||
2517 | { after(grammarAccess.getALSSignatureBodyAccess().getCommaKeyword_6_1_0()); } | ||
2518 | ) | ||
2519 | |||
2520 | ; | ||
2521 | finally { | ||
2522 | restoreStackSize(stackSize); | ||
2523 | } | ||
2524 | |||
2525 | |||
2526 | rule__ALSSignatureBody__Group_6_1__1 | ||
2527 | @init { | ||
2528 | int stackSize = keepStackSize(); | ||
2529 | } | ||
2530 | : | ||
2531 | rule__ALSSignatureBody__Group_6_1__1__Impl | ||
2532 | ; | ||
2533 | finally { | ||
2534 | restoreStackSize(stackSize); | ||
2535 | } | ||
2536 | |||
2537 | rule__ALSSignatureBody__Group_6_1__1__Impl | ||
2538 | @init { | ||
2539 | int stackSize = keepStackSize(); | ||
2540 | } | ||
2541 | : | ||
2542 | ( | ||
2543 | { before(grammarAccess.getALSSignatureBodyAccess().getFieldsAssignment_6_1_1()); } | ||
2544 | (rule__ALSSignatureBody__FieldsAssignment_6_1_1) | ||
2545 | { after(grammarAccess.getALSSignatureBodyAccess().getFieldsAssignment_6_1_1()); } | ||
2546 | ) | ||
2547 | |||
2548 | ; | ||
2549 | finally { | ||
2550 | restoreStackSize(stackSize); | ||
2551 | } | ||
2552 | |||
2553 | |||
2554 | |||
2555 | |||
2556 | |||
2557 | |||
2558 | rule__ALSFieldDeclaration__Group__0 | ||
2559 | @init { | ||
2560 | int stackSize = keepStackSize(); | ||
2561 | } | ||
2562 | : | ||
2563 | rule__ALSFieldDeclaration__Group__0__Impl | ||
2564 | rule__ALSFieldDeclaration__Group__1 | ||
2565 | ; | ||
2566 | finally { | ||
2567 | restoreStackSize(stackSize); | ||
2568 | } | ||
2569 | |||
2570 | rule__ALSFieldDeclaration__Group__0__Impl | ||
2571 | @init { | ||
2572 | int stackSize = keepStackSize(); | ||
2573 | } | ||
2574 | : | ||
2575 | ( | ||
2576 | { before(grammarAccess.getALSFieldDeclarationAccess().getNameAssignment_0()); } | ||
2577 | (rule__ALSFieldDeclaration__NameAssignment_0) | ||
2578 | { after(grammarAccess.getALSFieldDeclarationAccess().getNameAssignment_0()); } | ||
2579 | ) | ||
2580 | |||
2581 | ; | ||
2582 | finally { | ||
2583 | restoreStackSize(stackSize); | ||
2584 | } | ||
2585 | |||
2586 | |||
2587 | rule__ALSFieldDeclaration__Group__1 | ||
2588 | @init { | ||
2589 | int stackSize = keepStackSize(); | ||
2590 | } | ||
2591 | : | ||
2592 | rule__ALSFieldDeclaration__Group__1__Impl | ||
2593 | rule__ALSFieldDeclaration__Group__2 | ||
2594 | ; | ||
2595 | finally { | ||
2596 | restoreStackSize(stackSize); | ||
2597 | } | ||
2598 | |||
2599 | rule__ALSFieldDeclaration__Group__1__Impl | ||
2600 | @init { | ||
2601 | int stackSize = keepStackSize(); | ||
2602 | } | ||
2603 | : | ||
2604 | ( | ||
2605 | { before(grammarAccess.getALSFieldDeclarationAccess().getColonKeyword_1()); } | ||
2606 | |||
2607 | ':' | ||
2608 | |||
2609 | { after(grammarAccess.getALSFieldDeclarationAccess().getColonKeyword_1()); } | ||
2610 | ) | ||
2611 | |||
2612 | ; | ||
2613 | finally { | ||
2614 | restoreStackSize(stackSize); | ||
2615 | } | ||
2616 | |||
2617 | |||
2618 | rule__ALSFieldDeclaration__Group__2 | ||
2619 | @init { | ||
2620 | int stackSize = keepStackSize(); | ||
2621 | } | ||
2622 | : | ||
2623 | rule__ALSFieldDeclaration__Group__2__Impl | ||
2624 | rule__ALSFieldDeclaration__Group__3 | ||
2625 | ; | ||
2626 | finally { | ||
2627 | restoreStackSize(stackSize); | ||
2628 | } | ||
2629 | |||
2630 | rule__ALSFieldDeclaration__Group__2__Impl | ||
2631 | @init { | ||
2632 | int stackSize = keepStackSize(); | ||
2633 | } | ||
2634 | : | ||
2635 | ( | ||
2636 | { before(grammarAccess.getALSFieldDeclarationAccess().getMultiplicityAssignment_2()); } | ||
2637 | (rule__ALSFieldDeclaration__MultiplicityAssignment_2)? | ||
2638 | { after(grammarAccess.getALSFieldDeclarationAccess().getMultiplicityAssignment_2()); } | ||
2639 | ) | ||
2640 | |||
2641 | ; | ||
2642 | finally { | ||
2643 | restoreStackSize(stackSize); | ||
2644 | } | ||
2645 | |||
2646 | |||
2647 | rule__ALSFieldDeclaration__Group__3 | ||
2648 | @init { | ||
2649 | int stackSize = keepStackSize(); | ||
2650 | } | ||
2651 | : | ||
2652 | rule__ALSFieldDeclaration__Group__3__Impl | ||
2653 | ; | ||
2654 | finally { | ||
2655 | restoreStackSize(stackSize); | ||
2656 | } | ||
2657 | |||
2658 | rule__ALSFieldDeclaration__Group__3__Impl | ||
2659 | @init { | ||
2660 | int stackSize = keepStackSize(); | ||
2661 | } | ||
2662 | : | ||
2663 | ( | ||
2664 | { before(grammarAccess.getALSFieldDeclarationAccess().getTypeAssignment_3()); } | ||
2665 | (rule__ALSFieldDeclaration__TypeAssignment_3) | ||
2666 | { after(grammarAccess.getALSFieldDeclarationAccess().getTypeAssignment_3()); } | ||
2667 | ) | ||
2668 | |||
2669 | ; | ||
2670 | finally { | ||
2671 | restoreStackSize(stackSize); | ||
2672 | } | ||
2673 | |||
2674 | |||
2675 | |||
2676 | |||
2677 | |||
2678 | |||
2679 | |||
2680 | |||
2681 | |||
2682 | |||
2683 | rule__ALSFunctionDefinition__Group__0 | ||
2684 | @init { | ||
2685 | int stackSize = keepStackSize(); | ||
2686 | } | ||
2687 | : | ||
2688 | rule__ALSFunctionDefinition__Group__0__Impl | ||
2689 | rule__ALSFunctionDefinition__Group__1 | ||
2690 | ; | ||
2691 | finally { | ||
2692 | restoreStackSize(stackSize); | ||
2693 | } | ||
2694 | |||
2695 | rule__ALSFunctionDefinition__Group__0__Impl | ||
2696 | @init { | ||
2697 | int stackSize = keepStackSize(); | ||
2698 | } | ||
2699 | : | ||
2700 | ( | ||
2701 | { before(grammarAccess.getALSFunctionDefinitionAccess().getFunKeyword_0()); } | ||
2702 | |||
2703 | 'fun' | ||
2704 | |||
2705 | { after(grammarAccess.getALSFunctionDefinitionAccess().getFunKeyword_0()); } | ||
2706 | ) | ||
2707 | |||
2708 | ; | ||
2709 | finally { | ||
2710 | restoreStackSize(stackSize); | ||
2711 | } | ||
2712 | |||
2713 | |||
2714 | rule__ALSFunctionDefinition__Group__1 | ||
2715 | @init { | ||
2716 | int stackSize = keepStackSize(); | ||
2717 | } | ||
2718 | : | ||
2719 | rule__ALSFunctionDefinition__Group__1__Impl | ||
2720 | rule__ALSFunctionDefinition__Group__2 | ||
2721 | ; | ||
2722 | finally { | ||
2723 | restoreStackSize(stackSize); | ||
2724 | } | ||
2725 | |||
2726 | rule__ALSFunctionDefinition__Group__1__Impl | ||
2727 | @init { | ||
2728 | int stackSize = keepStackSize(); | ||
2729 | } | ||
2730 | : | ||
2731 | ( | ||
2732 | { before(grammarAccess.getALSFunctionDefinitionAccess().getNameAssignment_1()); } | ||
2733 | (rule__ALSFunctionDefinition__NameAssignment_1) | ||
2734 | { after(grammarAccess.getALSFunctionDefinitionAccess().getNameAssignment_1()); } | ||
2735 | ) | ||
2736 | |||
2737 | ; | ||
2738 | finally { | ||
2739 | restoreStackSize(stackSize); | ||
2740 | } | ||
2741 | |||
2742 | |||
2743 | rule__ALSFunctionDefinition__Group__2 | ||
2744 | @init { | ||
2745 | int stackSize = keepStackSize(); | ||
2746 | } | ||
2747 | : | ||
2748 | rule__ALSFunctionDefinition__Group__2__Impl | ||
2749 | rule__ALSFunctionDefinition__Group__3 | ||
2750 | ; | ||
2751 | finally { | ||
2752 | restoreStackSize(stackSize); | ||
2753 | } | ||
2754 | |||
2755 | rule__ALSFunctionDefinition__Group__2__Impl | ||
2756 | @init { | ||
2757 | int stackSize = keepStackSize(); | ||
2758 | } | ||
2759 | : | ||
2760 | ( | ||
2761 | { before(grammarAccess.getALSFunctionDefinitionAccess().getLeftSquareBracketKeyword_2()); } | ||
2762 | |||
2763 | '[' | ||
2764 | |||
2765 | { after(grammarAccess.getALSFunctionDefinitionAccess().getLeftSquareBracketKeyword_2()); } | ||
2766 | ) | ||
2767 | |||
2768 | ; | ||
2769 | finally { | ||
2770 | restoreStackSize(stackSize); | ||
2771 | } | ||
2772 | |||
2773 | |||
2774 | rule__ALSFunctionDefinition__Group__3 | ||
2775 | @init { | ||
2776 | int stackSize = keepStackSize(); | ||
2777 | } | ||
2778 | : | ||
2779 | rule__ALSFunctionDefinition__Group__3__Impl | ||
2780 | rule__ALSFunctionDefinition__Group__4 | ||
2781 | ; | ||
2782 | finally { | ||
2783 | restoreStackSize(stackSize); | ||
2784 | } | ||
2785 | |||
2786 | rule__ALSFunctionDefinition__Group__3__Impl | ||
2787 | @init { | ||
2788 | int stackSize = keepStackSize(); | ||
2789 | } | ||
2790 | : | ||
2791 | ( | ||
2792 | { before(grammarAccess.getALSFunctionDefinitionAccess().getVariablesAssignment_3()); } | ||
2793 | (rule__ALSFunctionDefinition__VariablesAssignment_3) | ||
2794 | { after(grammarAccess.getALSFunctionDefinitionAccess().getVariablesAssignment_3()); } | ||
2795 | ) | ||
2796 | |||
2797 | ; | ||
2798 | finally { | ||
2799 | restoreStackSize(stackSize); | ||
2800 | } | ||
2801 | |||
2802 | |||
2803 | rule__ALSFunctionDefinition__Group__4 | ||
2804 | @init { | ||
2805 | int stackSize = keepStackSize(); | ||
2806 | } | ||
2807 | : | ||
2808 | rule__ALSFunctionDefinition__Group__4__Impl | ||
2809 | rule__ALSFunctionDefinition__Group__5 | ||
2810 | ; | ||
2811 | finally { | ||
2812 | restoreStackSize(stackSize); | ||
2813 | } | ||
2814 | |||
2815 | rule__ALSFunctionDefinition__Group__4__Impl | ||
2816 | @init { | ||
2817 | int stackSize = keepStackSize(); | ||
2818 | } | ||
2819 | : | ||
2820 | ( | ||
2821 | { before(grammarAccess.getALSFunctionDefinitionAccess().getGroup_4()); } | ||
2822 | (rule__ALSFunctionDefinition__Group_4__0)* | ||
2823 | { after(grammarAccess.getALSFunctionDefinitionAccess().getGroup_4()); } | ||
2824 | ) | ||
2825 | |||
2826 | ; | ||
2827 | finally { | ||
2828 | restoreStackSize(stackSize); | ||
2829 | } | ||
2830 | |||
2831 | |||
2832 | rule__ALSFunctionDefinition__Group__5 | ||
2833 | @init { | ||
2834 | int stackSize = keepStackSize(); | ||
2835 | } | ||
2836 | : | ||
2837 | rule__ALSFunctionDefinition__Group__5__Impl | ||
2838 | rule__ALSFunctionDefinition__Group__6 | ||
2839 | ; | ||
2840 | finally { | ||
2841 | restoreStackSize(stackSize); | ||
2842 | } | ||
2843 | |||
2844 | rule__ALSFunctionDefinition__Group__5__Impl | ||
2845 | @init { | ||
2846 | int stackSize = keepStackSize(); | ||
2847 | } | ||
2848 | : | ||
2849 | ( | ||
2850 | { before(grammarAccess.getALSFunctionDefinitionAccess().getRightSquareBracketKeyword_5()); } | ||
2851 | |||
2852 | ']' | ||
2853 | |||
2854 | { after(grammarAccess.getALSFunctionDefinitionAccess().getRightSquareBracketKeyword_5()); } | ||
2855 | ) | ||
2856 | |||
2857 | ; | ||
2858 | finally { | ||
2859 | restoreStackSize(stackSize); | ||
2860 | } | ||
2861 | |||
2862 | |||
2863 | rule__ALSFunctionDefinition__Group__6 | ||
2864 | @init { | ||
2865 | int stackSize = keepStackSize(); | ||
2866 | } | ||
2867 | : | ||
2868 | rule__ALSFunctionDefinition__Group__6__Impl | ||
2869 | rule__ALSFunctionDefinition__Group__7 | ||
2870 | ; | ||
2871 | finally { | ||
2872 | restoreStackSize(stackSize); | ||
2873 | } | ||
2874 | |||
2875 | rule__ALSFunctionDefinition__Group__6__Impl | ||
2876 | @init { | ||
2877 | int stackSize = keepStackSize(); | ||
2878 | } | ||
2879 | : | ||
2880 | ( | ||
2881 | { before(grammarAccess.getALSFunctionDefinitionAccess().getColonKeyword_6()); } | ||
2882 | |||
2883 | ':' | ||
2884 | |||
2885 | { after(grammarAccess.getALSFunctionDefinitionAccess().getColonKeyword_6()); } | ||
2886 | ) | ||
2887 | |||
2888 | ; | ||
2889 | finally { | ||
2890 | restoreStackSize(stackSize); | ||
2891 | } | ||
2892 | |||
2893 | |||
2894 | rule__ALSFunctionDefinition__Group__7 | ||
2895 | @init { | ||
2896 | int stackSize = keepStackSize(); | ||
2897 | } | ||
2898 | : | ||
2899 | rule__ALSFunctionDefinition__Group__7__Impl | ||
2900 | rule__ALSFunctionDefinition__Group__8 | ||
2901 | ; | ||
2902 | finally { | ||
2903 | restoreStackSize(stackSize); | ||
2904 | } | ||
2905 | |||
2906 | rule__ALSFunctionDefinition__Group__7__Impl | ||
2907 | @init { | ||
2908 | int stackSize = keepStackSize(); | ||
2909 | } | ||
2910 | : | ||
2911 | ( | ||
2912 | { before(grammarAccess.getALSFunctionDefinitionAccess().getTypeAssignment_7()); } | ||
2913 | (rule__ALSFunctionDefinition__TypeAssignment_7) | ||
2914 | { after(grammarAccess.getALSFunctionDefinitionAccess().getTypeAssignment_7()); } | ||
2915 | ) | ||
2916 | |||
2917 | ; | ||
2918 | finally { | ||
2919 | restoreStackSize(stackSize); | ||
2920 | } | ||
2921 | |||
2922 | |||
2923 | rule__ALSFunctionDefinition__Group__8 | ||
2924 | @init { | ||
2925 | int stackSize = keepStackSize(); | ||
2926 | } | ||
2927 | : | ||
2928 | rule__ALSFunctionDefinition__Group__8__Impl | ||
2929 | rule__ALSFunctionDefinition__Group__9 | ||
2930 | ; | ||
2931 | finally { | ||
2932 | restoreStackSize(stackSize); | ||
2933 | } | ||
2934 | |||
2935 | rule__ALSFunctionDefinition__Group__8__Impl | ||
2936 | @init { | ||
2937 | int stackSize = keepStackSize(); | ||
2938 | } | ||
2939 | : | ||
2940 | ( | ||
2941 | { before(grammarAccess.getALSFunctionDefinitionAccess().getLeftCurlyBracketKeyword_8()); } | ||
2942 | |||
2943 | '{' | ||
2944 | |||
2945 | { after(grammarAccess.getALSFunctionDefinitionAccess().getLeftCurlyBracketKeyword_8()); } | ||
2946 | ) | ||
2947 | |||
2948 | ; | ||
2949 | finally { | ||
2950 | restoreStackSize(stackSize); | ||
2951 | } | ||
2952 | |||
2953 | |||
2954 | rule__ALSFunctionDefinition__Group__9 | ||
2955 | @init { | ||
2956 | int stackSize = keepStackSize(); | ||
2957 | } | ||
2958 | : | ||
2959 | rule__ALSFunctionDefinition__Group__9__Impl | ||
2960 | rule__ALSFunctionDefinition__Group__10 | ||
2961 | ; | ||
2962 | finally { | ||
2963 | restoreStackSize(stackSize); | ||
2964 | } | ||
2965 | |||
2966 | rule__ALSFunctionDefinition__Group__9__Impl | ||
2967 | @init { | ||
2968 | int stackSize = keepStackSize(); | ||
2969 | } | ||
2970 | : | ||
2971 | ( | ||
2972 | { before(grammarAccess.getALSFunctionDefinitionAccess().getValueAssignment_9()); } | ||
2973 | (rule__ALSFunctionDefinition__ValueAssignment_9) | ||
2974 | { after(grammarAccess.getALSFunctionDefinitionAccess().getValueAssignment_9()); } | ||
2975 | ) | ||
2976 | |||
2977 | ; | ||
2978 | finally { | ||
2979 | restoreStackSize(stackSize); | ||
2980 | } | ||
2981 | |||
2982 | |||
2983 | rule__ALSFunctionDefinition__Group__10 | ||
2984 | @init { | ||
2985 | int stackSize = keepStackSize(); | ||
2986 | } | ||
2987 | : | ||
2988 | rule__ALSFunctionDefinition__Group__10__Impl | ||
2989 | ; | ||
2990 | finally { | ||
2991 | restoreStackSize(stackSize); | ||
2992 | } | ||
2993 | |||
2994 | rule__ALSFunctionDefinition__Group__10__Impl | ||
2995 | @init { | ||
2996 | int stackSize = keepStackSize(); | ||
2997 | } | ||
2998 | : | ||
2999 | ( | ||
3000 | { before(grammarAccess.getALSFunctionDefinitionAccess().getRightCurlyBracketKeyword_10()); } | ||
3001 | |||
3002 | '}' | ||
3003 | |||
3004 | { after(grammarAccess.getALSFunctionDefinitionAccess().getRightCurlyBracketKeyword_10()); } | ||
3005 | ) | ||
3006 | |||
3007 | ; | ||
3008 | finally { | ||
3009 | restoreStackSize(stackSize); | ||
3010 | } | ||
3011 | |||
3012 | |||
3013 | |||
3014 | |||
3015 | |||
3016 | |||
3017 | |||
3018 | |||
3019 | |||
3020 | |||
3021 | |||
3022 | |||
3023 | |||
3024 | |||
3025 | |||
3026 | |||
3027 | |||
3028 | |||
3029 | |||
3030 | |||
3031 | |||
3032 | |||
3033 | |||
3034 | |||
3035 | rule__ALSFunctionDefinition__Group_4__0 | ||
3036 | @init { | ||
3037 | int stackSize = keepStackSize(); | ||
3038 | } | ||
3039 | : | ||
3040 | rule__ALSFunctionDefinition__Group_4__0__Impl | ||
3041 | rule__ALSFunctionDefinition__Group_4__1 | ||
3042 | ; | ||
3043 | finally { | ||
3044 | restoreStackSize(stackSize); | ||
3045 | } | ||
3046 | |||
3047 | rule__ALSFunctionDefinition__Group_4__0__Impl | ||
3048 | @init { | ||
3049 | int stackSize = keepStackSize(); | ||
3050 | } | ||
3051 | : | ||
3052 | ( | ||
3053 | { before(grammarAccess.getALSFunctionDefinitionAccess().getCommaKeyword_4_0()); } | ||
3054 | |||
3055 | ',' | ||
3056 | |||
3057 | { after(grammarAccess.getALSFunctionDefinitionAccess().getCommaKeyword_4_0()); } | ||
3058 | ) | ||
3059 | |||
3060 | ; | ||
3061 | finally { | ||
3062 | restoreStackSize(stackSize); | ||
3063 | } | ||
3064 | |||
3065 | |||
3066 | rule__ALSFunctionDefinition__Group_4__1 | ||
3067 | @init { | ||
3068 | int stackSize = keepStackSize(); | ||
3069 | } | ||
3070 | : | ||
3071 | rule__ALSFunctionDefinition__Group_4__1__Impl | ||
3072 | ; | ||
3073 | finally { | ||
3074 | restoreStackSize(stackSize); | ||
3075 | } | ||
3076 | |||
3077 | rule__ALSFunctionDefinition__Group_4__1__Impl | ||
3078 | @init { | ||
3079 | int stackSize = keepStackSize(); | ||
3080 | } | ||
3081 | : | ||
3082 | ( | ||
3083 | { before(grammarAccess.getALSFunctionDefinitionAccess().getVariablesAssignment_4_1()); } | ||
3084 | (rule__ALSFunctionDefinition__VariablesAssignment_4_1) | ||
3085 | { after(grammarAccess.getALSFunctionDefinitionAccess().getVariablesAssignment_4_1()); } | ||
3086 | ) | ||
3087 | |||
3088 | ; | ||
3089 | finally { | ||
3090 | restoreStackSize(stackSize); | ||
3091 | } | ||
3092 | |||
3093 | |||
3094 | |||
3095 | |||
3096 | |||
3097 | |||
3098 | rule__ALSRelationDefinition__Group__0 | ||
3099 | @init { | ||
3100 | int stackSize = keepStackSize(); | ||
3101 | } | ||
3102 | : | ||
3103 | rule__ALSRelationDefinition__Group__0__Impl | ||
3104 | rule__ALSRelationDefinition__Group__1 | ||
3105 | ; | ||
3106 | finally { | ||
3107 | restoreStackSize(stackSize); | ||
3108 | } | ||
3109 | |||
3110 | rule__ALSRelationDefinition__Group__0__Impl | ||
3111 | @init { | ||
3112 | int stackSize = keepStackSize(); | ||
3113 | } | ||
3114 | : | ||
3115 | ( | ||
3116 | { before(grammarAccess.getALSRelationDefinitionAccess().getPredKeyword_0()); } | ||
3117 | |||
3118 | 'pred' | ||
3119 | |||
3120 | { after(grammarAccess.getALSRelationDefinitionAccess().getPredKeyword_0()); } | ||
3121 | ) | ||
3122 | |||
3123 | ; | ||
3124 | finally { | ||
3125 | restoreStackSize(stackSize); | ||
3126 | } | ||
3127 | |||
3128 | |||
3129 | rule__ALSRelationDefinition__Group__1 | ||
3130 | @init { | ||
3131 | int stackSize = keepStackSize(); | ||
3132 | } | ||
3133 | : | ||
3134 | rule__ALSRelationDefinition__Group__1__Impl | ||
3135 | rule__ALSRelationDefinition__Group__2 | ||
3136 | ; | ||
3137 | finally { | ||
3138 | restoreStackSize(stackSize); | ||
3139 | } | ||
3140 | |||
3141 | rule__ALSRelationDefinition__Group__1__Impl | ||
3142 | @init { | ||
3143 | int stackSize = keepStackSize(); | ||
3144 | } | ||
3145 | : | ||
3146 | ( | ||
3147 | { before(grammarAccess.getALSRelationDefinitionAccess().getNameAssignment_1()); } | ||
3148 | (rule__ALSRelationDefinition__NameAssignment_1) | ||
3149 | { after(grammarAccess.getALSRelationDefinitionAccess().getNameAssignment_1()); } | ||
3150 | ) | ||
3151 | |||
3152 | ; | ||
3153 | finally { | ||
3154 | restoreStackSize(stackSize); | ||
3155 | } | ||
3156 | |||
3157 | |||
3158 | rule__ALSRelationDefinition__Group__2 | ||
3159 | @init { | ||
3160 | int stackSize = keepStackSize(); | ||
3161 | } | ||
3162 | : | ||
3163 | rule__ALSRelationDefinition__Group__2__Impl | ||
3164 | rule__ALSRelationDefinition__Group__3 | ||
3165 | ; | ||
3166 | finally { | ||
3167 | restoreStackSize(stackSize); | ||
3168 | } | ||
3169 | |||
3170 | rule__ALSRelationDefinition__Group__2__Impl | ||
3171 | @init { | ||
3172 | int stackSize = keepStackSize(); | ||
3173 | } | ||
3174 | : | ||
3175 | ( | ||
3176 | { before(grammarAccess.getALSRelationDefinitionAccess().getLeftSquareBracketKeyword_2()); } | ||
3177 | |||
3178 | '[' | ||
3179 | |||
3180 | { after(grammarAccess.getALSRelationDefinitionAccess().getLeftSquareBracketKeyword_2()); } | ||
3181 | ) | ||
3182 | |||
3183 | ; | ||
3184 | finally { | ||
3185 | restoreStackSize(stackSize); | ||
3186 | } | ||
3187 | |||
3188 | |||
3189 | rule__ALSRelationDefinition__Group__3 | ||
3190 | @init { | ||
3191 | int stackSize = keepStackSize(); | ||
3192 | } | ||
3193 | : | ||
3194 | rule__ALSRelationDefinition__Group__3__Impl | ||
3195 | rule__ALSRelationDefinition__Group__4 | ||
3196 | ; | ||
3197 | finally { | ||
3198 | restoreStackSize(stackSize); | ||
3199 | } | ||
3200 | |||
3201 | rule__ALSRelationDefinition__Group__3__Impl | ||
3202 | @init { | ||
3203 | int stackSize = keepStackSize(); | ||
3204 | } | ||
3205 | : | ||
3206 | ( | ||
3207 | { before(grammarAccess.getALSRelationDefinitionAccess().getVariablesAssignment_3()); } | ||
3208 | (rule__ALSRelationDefinition__VariablesAssignment_3) | ||
3209 | { after(grammarAccess.getALSRelationDefinitionAccess().getVariablesAssignment_3()); } | ||
3210 | ) | ||
3211 | |||
3212 | ; | ||
3213 | finally { | ||
3214 | restoreStackSize(stackSize); | ||
3215 | } | ||
3216 | |||
3217 | |||
3218 | rule__ALSRelationDefinition__Group__4 | ||
3219 | @init { | ||
3220 | int stackSize = keepStackSize(); | ||
3221 | } | ||
3222 | : | ||
3223 | rule__ALSRelationDefinition__Group__4__Impl | ||
3224 | rule__ALSRelationDefinition__Group__5 | ||
3225 | ; | ||
3226 | finally { | ||
3227 | restoreStackSize(stackSize); | ||
3228 | } | ||
3229 | |||
3230 | rule__ALSRelationDefinition__Group__4__Impl | ||
3231 | @init { | ||
3232 | int stackSize = keepStackSize(); | ||
3233 | } | ||
3234 | : | ||
3235 | ( | ||
3236 | { before(grammarAccess.getALSRelationDefinitionAccess().getGroup_4()); } | ||
3237 | (rule__ALSRelationDefinition__Group_4__0)* | ||
3238 | { after(grammarAccess.getALSRelationDefinitionAccess().getGroup_4()); } | ||
3239 | ) | ||
3240 | |||
3241 | ; | ||
3242 | finally { | ||
3243 | restoreStackSize(stackSize); | ||
3244 | } | ||
3245 | |||
3246 | |||
3247 | rule__ALSRelationDefinition__Group__5 | ||
3248 | @init { | ||
3249 | int stackSize = keepStackSize(); | ||
3250 | } | ||
3251 | : | ||
3252 | rule__ALSRelationDefinition__Group__5__Impl | ||
3253 | rule__ALSRelationDefinition__Group__6 | ||
3254 | ; | ||
3255 | finally { | ||
3256 | restoreStackSize(stackSize); | ||
3257 | } | ||
3258 | |||
3259 | rule__ALSRelationDefinition__Group__5__Impl | ||
3260 | @init { | ||
3261 | int stackSize = keepStackSize(); | ||
3262 | } | ||
3263 | : | ||
3264 | ( | ||
3265 | { before(grammarAccess.getALSRelationDefinitionAccess().getRightSquareBracketKeyword_5()); } | ||
3266 | |||
3267 | ']' | ||
3268 | |||
3269 | { after(grammarAccess.getALSRelationDefinitionAccess().getRightSquareBracketKeyword_5()); } | ||
3270 | ) | ||
3271 | |||
3272 | ; | ||
3273 | finally { | ||
3274 | restoreStackSize(stackSize); | ||
3275 | } | ||
3276 | |||
3277 | |||
3278 | rule__ALSRelationDefinition__Group__6 | ||
3279 | @init { | ||
3280 | int stackSize = keepStackSize(); | ||
3281 | } | ||
3282 | : | ||
3283 | rule__ALSRelationDefinition__Group__6__Impl | ||
3284 | rule__ALSRelationDefinition__Group__7 | ||
3285 | ; | ||
3286 | finally { | ||
3287 | restoreStackSize(stackSize); | ||
3288 | } | ||
3289 | |||
3290 | rule__ALSRelationDefinition__Group__6__Impl | ||
3291 | @init { | ||
3292 | int stackSize = keepStackSize(); | ||
3293 | } | ||
3294 | : | ||
3295 | ( | ||
3296 | { before(grammarAccess.getALSRelationDefinitionAccess().getLeftCurlyBracketKeyword_6()); } | ||
3297 | |||
3298 | '{' | ||
3299 | |||
3300 | { after(grammarAccess.getALSRelationDefinitionAccess().getLeftCurlyBracketKeyword_6()); } | ||
3301 | ) | ||
3302 | |||
3303 | ; | ||
3304 | finally { | ||
3305 | restoreStackSize(stackSize); | ||
3306 | } | ||
3307 | |||
3308 | |||
3309 | rule__ALSRelationDefinition__Group__7 | ||
3310 | @init { | ||
3311 | int stackSize = keepStackSize(); | ||
3312 | } | ||
3313 | : | ||
3314 | rule__ALSRelationDefinition__Group__7__Impl | ||
3315 | rule__ALSRelationDefinition__Group__8 | ||
3316 | ; | ||
3317 | finally { | ||
3318 | restoreStackSize(stackSize); | ||
3319 | } | ||
3320 | |||
3321 | rule__ALSRelationDefinition__Group__7__Impl | ||
3322 | @init { | ||
3323 | int stackSize = keepStackSize(); | ||
3324 | } | ||
3325 | : | ||
3326 | ( | ||
3327 | { before(grammarAccess.getALSRelationDefinitionAccess().getValueAssignment_7()); } | ||
3328 | (rule__ALSRelationDefinition__ValueAssignment_7) | ||
3329 | { after(grammarAccess.getALSRelationDefinitionAccess().getValueAssignment_7()); } | ||
3330 | ) | ||
3331 | |||
3332 | ; | ||
3333 | finally { | ||
3334 | restoreStackSize(stackSize); | ||
3335 | } | ||
3336 | |||
3337 | |||
3338 | rule__ALSRelationDefinition__Group__8 | ||
3339 | @init { | ||
3340 | int stackSize = keepStackSize(); | ||
3341 | } | ||
3342 | : | ||
3343 | rule__ALSRelationDefinition__Group__8__Impl | ||
3344 | ; | ||
3345 | finally { | ||
3346 | restoreStackSize(stackSize); | ||
3347 | } | ||
3348 | |||
3349 | rule__ALSRelationDefinition__Group__8__Impl | ||
3350 | @init { | ||
3351 | int stackSize = keepStackSize(); | ||
3352 | } | ||
3353 | : | ||
3354 | ( | ||
3355 | { before(grammarAccess.getALSRelationDefinitionAccess().getRightCurlyBracketKeyword_8()); } | ||
3356 | |||
3357 | '}' | ||
3358 | |||
3359 | { after(grammarAccess.getALSRelationDefinitionAccess().getRightCurlyBracketKeyword_8()); } | ||
3360 | ) | ||
3361 | |||
3362 | ; | ||
3363 | finally { | ||
3364 | restoreStackSize(stackSize); | ||
3365 | } | ||
3366 | |||
3367 | |||
3368 | |||
3369 | |||
3370 | |||
3371 | |||
3372 | |||
3373 | |||
3374 | |||
3375 | |||
3376 | |||
3377 | |||
3378 | |||
3379 | |||
3380 | |||
3381 | |||
3382 | |||
3383 | |||
3384 | |||
3385 | |||
3386 | rule__ALSRelationDefinition__Group_4__0 | ||
3387 | @init { | ||
3388 | int stackSize = keepStackSize(); | ||
3389 | } | ||
3390 | : | ||
3391 | rule__ALSRelationDefinition__Group_4__0__Impl | ||
3392 | rule__ALSRelationDefinition__Group_4__1 | ||
3393 | ; | ||
3394 | finally { | ||
3395 | restoreStackSize(stackSize); | ||
3396 | } | ||
3397 | |||
3398 | rule__ALSRelationDefinition__Group_4__0__Impl | ||
3399 | @init { | ||
3400 | int stackSize = keepStackSize(); | ||
3401 | } | ||
3402 | : | ||
3403 | ( | ||
3404 | { before(grammarAccess.getALSRelationDefinitionAccess().getCommaKeyword_4_0()); } | ||
3405 | |||
3406 | ',' | ||
3407 | |||
3408 | { after(grammarAccess.getALSRelationDefinitionAccess().getCommaKeyword_4_0()); } | ||
3409 | ) | ||
3410 | |||
3411 | ; | ||
3412 | finally { | ||
3413 | restoreStackSize(stackSize); | ||
3414 | } | ||
3415 | |||
3416 | |||
3417 | rule__ALSRelationDefinition__Group_4__1 | ||
3418 | @init { | ||
3419 | int stackSize = keepStackSize(); | ||
3420 | } | ||
3421 | : | ||
3422 | rule__ALSRelationDefinition__Group_4__1__Impl | ||
3423 | ; | ||
3424 | finally { | ||
3425 | restoreStackSize(stackSize); | ||
3426 | } | ||
3427 | |||
3428 | rule__ALSRelationDefinition__Group_4__1__Impl | ||
3429 | @init { | ||
3430 | int stackSize = keepStackSize(); | ||
3431 | } | ||
3432 | : | ||
3433 | ( | ||
3434 | { before(grammarAccess.getALSRelationDefinitionAccess().getVariablesAssignment_4_1()); } | ||
3435 | (rule__ALSRelationDefinition__VariablesAssignment_4_1) | ||
3436 | { after(grammarAccess.getALSRelationDefinitionAccess().getVariablesAssignment_4_1()); } | ||
3437 | ) | ||
3438 | |||
3439 | ; | ||
3440 | finally { | ||
3441 | restoreStackSize(stackSize); | ||
3442 | } | ||
3443 | |||
3444 | |||
3445 | |||
3446 | |||
3447 | |||
3448 | |||
3449 | rule__ALSFactDeclaration__Group__0 | ||
3450 | @init { | ||
3451 | int stackSize = keepStackSize(); | ||
3452 | } | ||
3453 | : | ||
3454 | rule__ALSFactDeclaration__Group__0__Impl | ||
3455 | rule__ALSFactDeclaration__Group__1 | ||
3456 | ; | ||
3457 | finally { | ||
3458 | restoreStackSize(stackSize); | ||
3459 | } | ||
3460 | |||
3461 | rule__ALSFactDeclaration__Group__0__Impl | ||
3462 | @init { | ||
3463 | int stackSize = keepStackSize(); | ||
3464 | } | ||
3465 | : | ||
3466 | ( | ||
3467 | { before(grammarAccess.getALSFactDeclarationAccess().getALSFactDeclarationAction_0()); } | ||
3468 | ( | ||
3469 | |||
3470 | ) | ||
3471 | { after(grammarAccess.getALSFactDeclarationAccess().getALSFactDeclarationAction_0()); } | ||
3472 | ) | ||
3473 | |||
3474 | ; | ||
3475 | finally { | ||
3476 | restoreStackSize(stackSize); | ||
3477 | } | ||
3478 | |||
3479 | |||
3480 | rule__ALSFactDeclaration__Group__1 | ||
3481 | @init { | ||
3482 | int stackSize = keepStackSize(); | ||
3483 | } | ||
3484 | : | ||
3485 | rule__ALSFactDeclaration__Group__1__Impl | ||
3486 | rule__ALSFactDeclaration__Group__2 | ||
3487 | ; | ||
3488 | finally { | ||
3489 | restoreStackSize(stackSize); | ||
3490 | } | ||
3491 | |||
3492 | rule__ALSFactDeclaration__Group__1__Impl | ||
3493 | @init { | ||
3494 | int stackSize = keepStackSize(); | ||
3495 | } | ||
3496 | : | ||
3497 | ( | ||
3498 | { before(grammarAccess.getALSFactDeclarationAccess().getFactKeyword_1()); } | ||
3499 | |||
3500 | 'fact' | ||
3501 | |||
3502 | { after(grammarAccess.getALSFactDeclarationAccess().getFactKeyword_1()); } | ||
3503 | ) | ||
3504 | |||
3505 | ; | ||
3506 | finally { | ||
3507 | restoreStackSize(stackSize); | ||
3508 | } | ||
3509 | |||
3510 | |||
3511 | rule__ALSFactDeclaration__Group__2 | ||
3512 | @init { | ||
3513 | int stackSize = keepStackSize(); | ||
3514 | } | ||
3515 | : | ||
3516 | rule__ALSFactDeclaration__Group__2__Impl | ||
3517 | rule__ALSFactDeclaration__Group__3 | ||
3518 | ; | ||
3519 | finally { | ||
3520 | restoreStackSize(stackSize); | ||
3521 | } | ||
3522 | |||
3523 | rule__ALSFactDeclaration__Group__2__Impl | ||
3524 | @init { | ||
3525 | int stackSize = keepStackSize(); | ||
3526 | } | ||
3527 | : | ||
3528 | ( | ||
3529 | { before(grammarAccess.getALSFactDeclarationAccess().getNameAssignment_2()); } | ||
3530 | (rule__ALSFactDeclaration__NameAssignment_2)? | ||
3531 | { after(grammarAccess.getALSFactDeclarationAccess().getNameAssignment_2()); } | ||
3532 | ) | ||
3533 | |||
3534 | ; | ||
3535 | finally { | ||
3536 | restoreStackSize(stackSize); | ||
3537 | } | ||
3538 | |||
3539 | |||
3540 | rule__ALSFactDeclaration__Group__3 | ||
3541 | @init { | ||
3542 | int stackSize = keepStackSize(); | ||
3543 | } | ||
3544 | : | ||
3545 | rule__ALSFactDeclaration__Group__3__Impl | ||
3546 | rule__ALSFactDeclaration__Group__4 | ||
3547 | ; | ||
3548 | finally { | ||
3549 | restoreStackSize(stackSize); | ||
3550 | } | ||
3551 | |||
3552 | rule__ALSFactDeclaration__Group__3__Impl | ||
3553 | @init { | ||
3554 | int stackSize = keepStackSize(); | ||
3555 | } | ||
3556 | : | ||
3557 | ( | ||
3558 | { before(grammarAccess.getALSFactDeclarationAccess().getLeftCurlyBracketKeyword_3()); } | ||
3559 | |||
3560 | '{' | ||
3561 | |||
3562 | { after(grammarAccess.getALSFactDeclarationAccess().getLeftCurlyBracketKeyword_3()); } | ||
3563 | ) | ||
3564 | |||
3565 | ; | ||
3566 | finally { | ||
3567 | restoreStackSize(stackSize); | ||
3568 | } | ||
3569 | |||
3570 | |||
3571 | rule__ALSFactDeclaration__Group__4 | ||
3572 | @init { | ||
3573 | int stackSize = keepStackSize(); | ||
3574 | } | ||
3575 | : | ||
3576 | rule__ALSFactDeclaration__Group__4__Impl | ||
3577 | rule__ALSFactDeclaration__Group__5 | ||
3578 | ; | ||
3579 | finally { | ||
3580 | restoreStackSize(stackSize); | ||
3581 | } | ||
3582 | |||
3583 | rule__ALSFactDeclaration__Group__4__Impl | ||
3584 | @init { | ||
3585 | int stackSize = keepStackSize(); | ||
3586 | } | ||
3587 | : | ||
3588 | ( | ||
3589 | { before(grammarAccess.getALSFactDeclarationAccess().getTermAssignment_4()); } | ||
3590 | (rule__ALSFactDeclaration__TermAssignment_4) | ||
3591 | { after(grammarAccess.getALSFactDeclarationAccess().getTermAssignment_4()); } | ||
3592 | ) | ||
3593 | |||
3594 | ; | ||
3595 | finally { | ||
3596 | restoreStackSize(stackSize); | ||
3597 | } | ||
3598 | |||
3599 | |||
3600 | rule__ALSFactDeclaration__Group__5 | ||
3601 | @init { | ||
3602 | int stackSize = keepStackSize(); | ||
3603 | } | ||
3604 | : | ||
3605 | rule__ALSFactDeclaration__Group__5__Impl | ||
3606 | ; | ||
3607 | finally { | ||
3608 | restoreStackSize(stackSize); | ||
3609 | } | ||
3610 | |||
3611 | rule__ALSFactDeclaration__Group__5__Impl | ||
3612 | @init { | ||
3613 | int stackSize = keepStackSize(); | ||
3614 | } | ||
3615 | : | ||
3616 | ( | ||
3617 | { before(grammarAccess.getALSFactDeclarationAccess().getRightCurlyBracketKeyword_5()); } | ||
3618 | |||
3619 | '}' | ||
3620 | |||
3621 | { after(grammarAccess.getALSFactDeclarationAccess().getRightCurlyBracketKeyword_5()); } | ||
3622 | ) | ||
3623 | |||
3624 | ; | ||
3625 | finally { | ||
3626 | restoreStackSize(stackSize); | ||
3627 | } | ||
3628 | |||
3629 | |||
3630 | |||
3631 | |||
3632 | |||
3633 | |||
3634 | |||
3635 | |||
3636 | |||
3637 | |||
3638 | |||
3639 | |||
3640 | |||
3641 | |||
3642 | rule__ALSQuantified__Group_0__0 | ||
3643 | @init { | ||
3644 | int stackSize = keepStackSize(); | ||
3645 | } | ||
3646 | : | ||
3647 | rule__ALSQuantified__Group_0__0__Impl | ||
3648 | rule__ALSQuantified__Group_0__1 | ||
3649 | ; | ||
3650 | finally { | ||
3651 | restoreStackSize(stackSize); | ||
3652 | } | ||
3653 | |||
3654 | rule__ALSQuantified__Group_0__0__Impl | ||
3655 | @init { | ||
3656 | int stackSize = keepStackSize(); | ||
3657 | } | ||
3658 | : | ||
3659 | ( | ||
3660 | { before(grammarAccess.getALSQuantifiedAccess().getALSQuantifiedExAction_0_0()); } | ||
3661 | ( | ||
3662 | |||
3663 | ) | ||
3664 | { after(grammarAccess.getALSQuantifiedAccess().getALSQuantifiedExAction_0_0()); } | ||
3665 | ) | ||
3666 | |||
3667 | ; | ||
3668 | finally { | ||
3669 | restoreStackSize(stackSize); | ||
3670 | } | ||
3671 | |||
3672 | |||
3673 | rule__ALSQuantified__Group_0__1 | ||
3674 | @init { | ||
3675 | int stackSize = keepStackSize(); | ||
3676 | } | ||
3677 | : | ||
3678 | rule__ALSQuantified__Group_0__1__Impl | ||
3679 | rule__ALSQuantified__Group_0__2 | ||
3680 | ; | ||
3681 | finally { | ||
3682 | restoreStackSize(stackSize); | ||
3683 | } | ||
3684 | |||
3685 | rule__ALSQuantified__Group_0__1__Impl | ||
3686 | @init { | ||
3687 | int stackSize = keepStackSize(); | ||
3688 | } | ||
3689 | : | ||
3690 | ( | ||
3691 | { before(grammarAccess.getALSQuantifiedAccess().getTypeAssignment_0_1()); } | ||
3692 | (rule__ALSQuantified__TypeAssignment_0_1) | ||
3693 | { after(grammarAccess.getALSQuantifiedAccess().getTypeAssignment_0_1()); } | ||
3694 | ) | ||
3695 | |||
3696 | ; | ||
3697 | finally { | ||
3698 | restoreStackSize(stackSize); | ||
3699 | } | ||
3700 | |||
3701 | |||
3702 | rule__ALSQuantified__Group_0__2 | ||
3703 | @init { | ||
3704 | int stackSize = keepStackSize(); | ||
3705 | } | ||
3706 | : | ||
3707 | rule__ALSQuantified__Group_0__2__Impl | ||
3708 | rule__ALSQuantified__Group_0__3 | ||
3709 | ; | ||
3710 | finally { | ||
3711 | restoreStackSize(stackSize); | ||
3712 | } | ||
3713 | |||
3714 | rule__ALSQuantified__Group_0__2__Impl | ||
3715 | @init { | ||
3716 | int stackSize = keepStackSize(); | ||
3717 | } | ||
3718 | : | ||
3719 | ( | ||
3720 | { before(grammarAccess.getALSQuantifiedAccess().getDisjAssignment_0_2()); } | ||
3721 | (rule__ALSQuantified__DisjAssignment_0_2)? | ||
3722 | { after(grammarAccess.getALSQuantifiedAccess().getDisjAssignment_0_2()); } | ||
3723 | ) | ||
3724 | |||
3725 | ; | ||
3726 | finally { | ||
3727 | restoreStackSize(stackSize); | ||
3728 | } | ||
3729 | |||
3730 | |||
3731 | rule__ALSQuantified__Group_0__3 | ||
3732 | @init { | ||
3733 | int stackSize = keepStackSize(); | ||
3734 | } | ||
3735 | : | ||
3736 | rule__ALSQuantified__Group_0__3__Impl | ||
3737 | rule__ALSQuantified__Group_0__4 | ||
3738 | ; | ||
3739 | finally { | ||
3740 | restoreStackSize(stackSize); | ||
3741 | } | ||
3742 | |||
3743 | rule__ALSQuantified__Group_0__3__Impl | ||
3744 | @init { | ||
3745 | int stackSize = keepStackSize(); | ||
3746 | } | ||
3747 | : | ||
3748 | ( | ||
3749 | { before(grammarAccess.getALSQuantifiedAccess().getVariablesAssignment_0_3()); } | ||
3750 | (rule__ALSQuantified__VariablesAssignment_0_3) | ||
3751 | { after(grammarAccess.getALSQuantifiedAccess().getVariablesAssignment_0_3()); } | ||
3752 | ) | ||
3753 | |||
3754 | ; | ||
3755 | finally { | ||
3756 | restoreStackSize(stackSize); | ||
3757 | } | ||
3758 | |||
3759 | |||
3760 | rule__ALSQuantified__Group_0__4 | ||
3761 | @init { | ||
3762 | int stackSize = keepStackSize(); | ||
3763 | } | ||
3764 | : | ||
3765 | rule__ALSQuantified__Group_0__4__Impl | ||
3766 | rule__ALSQuantified__Group_0__5 | ||
3767 | ; | ||
3768 | finally { | ||
3769 | restoreStackSize(stackSize); | ||
3770 | } | ||
3771 | |||
3772 | rule__ALSQuantified__Group_0__4__Impl | ||
3773 | @init { | ||
3774 | int stackSize = keepStackSize(); | ||
3775 | } | ||
3776 | : | ||
3777 | ( | ||
3778 | { before(grammarAccess.getALSQuantifiedAccess().getGroup_0_4()); } | ||
3779 | (rule__ALSQuantified__Group_0_4__0)* | ||
3780 | { after(grammarAccess.getALSQuantifiedAccess().getGroup_0_4()); } | ||
3781 | ) | ||
3782 | |||
3783 | ; | ||
3784 | finally { | ||
3785 | restoreStackSize(stackSize); | ||
3786 | } | ||
3787 | |||
3788 | |||
3789 | rule__ALSQuantified__Group_0__5 | ||
3790 | @init { | ||
3791 | int stackSize = keepStackSize(); | ||
3792 | } | ||
3793 | : | ||
3794 | rule__ALSQuantified__Group_0__5__Impl | ||
3795 | rule__ALSQuantified__Group_0__6 | ||
3796 | ; | ||
3797 | finally { | ||
3798 | restoreStackSize(stackSize); | ||
3799 | } | ||
3800 | |||
3801 | rule__ALSQuantified__Group_0__5__Impl | ||
3802 | @init { | ||
3803 | int stackSize = keepStackSize(); | ||
3804 | } | ||
3805 | : | ||
3806 | ( | ||
3807 | { before(grammarAccess.getALSQuantifiedAccess().getLeftCurlyBracketKeyword_0_5()); } | ||
3808 | |||
3809 | '{' | ||
3810 | |||
3811 | { after(grammarAccess.getALSQuantifiedAccess().getLeftCurlyBracketKeyword_0_5()); } | ||
3812 | ) | ||
3813 | |||
3814 | ; | ||
3815 | finally { | ||
3816 | restoreStackSize(stackSize); | ||
3817 | } | ||
3818 | |||
3819 | |||
3820 | rule__ALSQuantified__Group_0__6 | ||
3821 | @init { | ||
3822 | int stackSize = keepStackSize(); | ||
3823 | } | ||
3824 | : | ||
3825 | rule__ALSQuantified__Group_0__6__Impl | ||
3826 | rule__ALSQuantified__Group_0__7 | ||
3827 | ; | ||
3828 | finally { | ||
3829 | restoreStackSize(stackSize); | ||
3830 | } | ||
3831 | |||
3832 | rule__ALSQuantified__Group_0__6__Impl | ||
3833 | @init { | ||
3834 | int stackSize = keepStackSize(); | ||
3835 | } | ||
3836 | : | ||
3837 | ( | ||
3838 | { before(grammarAccess.getALSQuantifiedAccess().getExpressionAssignment_0_6()); } | ||
3839 | (rule__ALSQuantified__ExpressionAssignment_0_6) | ||
3840 | { after(grammarAccess.getALSQuantifiedAccess().getExpressionAssignment_0_6()); } | ||
3841 | ) | ||
3842 | |||
3843 | ; | ||
3844 | finally { | ||
3845 | restoreStackSize(stackSize); | ||
3846 | } | ||
3847 | |||
3848 | |||
3849 | rule__ALSQuantified__Group_0__7 | ||
3850 | @init { | ||
3851 | int stackSize = keepStackSize(); | ||
3852 | } | ||
3853 | : | ||
3854 | rule__ALSQuantified__Group_0__7__Impl | ||
3855 | ; | ||
3856 | finally { | ||
3857 | restoreStackSize(stackSize); | ||
3858 | } | ||
3859 | |||
3860 | rule__ALSQuantified__Group_0__7__Impl | ||
3861 | @init { | ||
3862 | int stackSize = keepStackSize(); | ||
3863 | } | ||
3864 | : | ||
3865 | ( | ||
3866 | { before(grammarAccess.getALSQuantifiedAccess().getRightCurlyBracketKeyword_0_7()); } | ||
3867 | |||
3868 | '}' | ||
3869 | |||
3870 | { after(grammarAccess.getALSQuantifiedAccess().getRightCurlyBracketKeyword_0_7()); } | ||
3871 | ) | ||
3872 | |||
3873 | ; | ||
3874 | finally { | ||
3875 | restoreStackSize(stackSize); | ||
3876 | } | ||
3877 | |||
3878 | |||
3879 | |||
3880 | |||
3881 | |||
3882 | |||
3883 | |||
3884 | |||
3885 | |||
3886 | |||
3887 | |||
3888 | |||
3889 | |||
3890 | |||
3891 | |||
3892 | |||
3893 | |||
3894 | |||
3895 | rule__ALSQuantified__Group_0_4__0 | ||
3896 | @init { | ||
3897 | int stackSize = keepStackSize(); | ||
3898 | } | ||
3899 | : | ||
3900 | rule__ALSQuantified__Group_0_4__0__Impl | ||
3901 | rule__ALSQuantified__Group_0_4__1 | ||
3902 | ; | ||
3903 | finally { | ||
3904 | restoreStackSize(stackSize); | ||
3905 | } | ||
3906 | |||
3907 | rule__ALSQuantified__Group_0_4__0__Impl | ||
3908 | @init { | ||
3909 | int stackSize = keepStackSize(); | ||
3910 | } | ||
3911 | : | ||
3912 | ( | ||
3913 | { before(grammarAccess.getALSQuantifiedAccess().getCommaKeyword_0_4_0()); } | ||
3914 | |||
3915 | ',' | ||
3916 | |||
3917 | { after(grammarAccess.getALSQuantifiedAccess().getCommaKeyword_0_4_0()); } | ||
3918 | ) | ||
3919 | |||
3920 | ; | ||
3921 | finally { | ||
3922 | restoreStackSize(stackSize); | ||
3923 | } | ||
3924 | |||
3925 | |||
3926 | rule__ALSQuantified__Group_0_4__1 | ||
3927 | @init { | ||
3928 | int stackSize = keepStackSize(); | ||
3929 | } | ||
3930 | : | ||
3931 | rule__ALSQuantified__Group_0_4__1__Impl | ||
3932 | ; | ||
3933 | finally { | ||
3934 | restoreStackSize(stackSize); | ||
3935 | } | ||
3936 | |||
3937 | rule__ALSQuantified__Group_0_4__1__Impl | ||
3938 | @init { | ||
3939 | int stackSize = keepStackSize(); | ||
3940 | } | ||
3941 | : | ||
3942 | ( | ||
3943 | { before(grammarAccess.getALSQuantifiedAccess().getVariablesAssignment_0_4_1()); } | ||
3944 | (rule__ALSQuantified__VariablesAssignment_0_4_1) | ||
3945 | { after(grammarAccess.getALSQuantifiedAccess().getVariablesAssignment_0_4_1()); } | ||
3946 | ) | ||
3947 | |||
3948 | ; | ||
3949 | finally { | ||
3950 | restoreStackSize(stackSize); | ||
3951 | } | ||
3952 | |||
3953 | |||
3954 | |||
3955 | |||
3956 | |||
3957 | |||
3958 | rule__ALSOr__Group__0 | ||
3959 | @init { | ||
3960 | int stackSize = keepStackSize(); | ||
3961 | } | ||
3962 | : | ||
3963 | rule__ALSOr__Group__0__Impl | ||
3964 | rule__ALSOr__Group__1 | ||
3965 | ; | ||
3966 | finally { | ||
3967 | restoreStackSize(stackSize); | ||
3968 | } | ||
3969 | |||
3970 | rule__ALSOr__Group__0__Impl | ||
3971 | @init { | ||
3972 | int stackSize = keepStackSize(); | ||
3973 | } | ||
3974 | : | ||
3975 | ( | ||
3976 | { before(grammarAccess.getALSOrAccess().getALSIffParserRuleCall_0()); } | ||
3977 | ruleALSIff | ||
3978 | { after(grammarAccess.getALSOrAccess().getALSIffParserRuleCall_0()); } | ||
3979 | ) | ||
3980 | |||
3981 | ; | ||
3982 | finally { | ||
3983 | restoreStackSize(stackSize); | ||
3984 | } | ||
3985 | |||
3986 | |||
3987 | rule__ALSOr__Group__1 | ||
3988 | @init { | ||
3989 | int stackSize = keepStackSize(); | ||
3990 | } | ||
3991 | : | ||
3992 | rule__ALSOr__Group__1__Impl | ||
3993 | ; | ||
3994 | finally { | ||
3995 | restoreStackSize(stackSize); | ||
3996 | } | ||
3997 | |||
3998 | rule__ALSOr__Group__1__Impl | ||
3999 | @init { | ||
4000 | int stackSize = keepStackSize(); | ||
4001 | } | ||
4002 | : | ||
4003 | ( | ||
4004 | { before(grammarAccess.getALSOrAccess().getGroup_1()); } | ||
4005 | (rule__ALSOr__Group_1__0)? | ||
4006 | { after(grammarAccess.getALSOrAccess().getGroup_1()); } | ||
4007 | ) | ||
4008 | |||
4009 | ; | ||
4010 | finally { | ||
4011 | restoreStackSize(stackSize); | ||
4012 | } | ||
4013 | |||
4014 | |||
4015 | |||
4016 | |||
4017 | |||
4018 | |||
4019 | rule__ALSOr__Group_1__0 | ||
4020 | @init { | ||
4021 | int stackSize = keepStackSize(); | ||
4022 | } | ||
4023 | : | ||
4024 | rule__ALSOr__Group_1__0__Impl | ||
4025 | rule__ALSOr__Group_1__1 | ||
4026 | ; | ||
4027 | finally { | ||
4028 | restoreStackSize(stackSize); | ||
4029 | } | ||
4030 | |||
4031 | rule__ALSOr__Group_1__0__Impl | ||
4032 | @init { | ||
4033 | int stackSize = keepStackSize(); | ||
4034 | } | ||
4035 | : | ||
4036 | ( | ||
4037 | { before(grammarAccess.getALSOrAccess().getALSOrLeftOperandAction_1_0()); } | ||
4038 | ( | ||
4039 | |||
4040 | ) | ||
4041 | { after(grammarAccess.getALSOrAccess().getALSOrLeftOperandAction_1_0()); } | ||
4042 | ) | ||
4043 | |||
4044 | ; | ||
4045 | finally { | ||
4046 | restoreStackSize(stackSize); | ||
4047 | } | ||
4048 | |||
4049 | |||
4050 | rule__ALSOr__Group_1__1 | ||
4051 | @init { | ||
4052 | int stackSize = keepStackSize(); | ||
4053 | } | ||
4054 | : | ||
4055 | rule__ALSOr__Group_1__1__Impl | ||
4056 | rule__ALSOr__Group_1__2 | ||
4057 | ; | ||
4058 | finally { | ||
4059 | restoreStackSize(stackSize); | ||
4060 | } | ||
4061 | |||
4062 | rule__ALSOr__Group_1__1__Impl | ||
4063 | @init { | ||
4064 | int stackSize = keepStackSize(); | ||
4065 | } | ||
4066 | : | ||
4067 | ( | ||
4068 | { before(grammarAccess.getALSOrAccess().getAlternatives_1_1()); } | ||
4069 | (rule__ALSOr__Alternatives_1_1) | ||
4070 | { after(grammarAccess.getALSOrAccess().getAlternatives_1_1()); } | ||
4071 | ) | ||
4072 | |||
4073 | ; | ||
4074 | finally { | ||
4075 | restoreStackSize(stackSize); | ||
4076 | } | ||
4077 | |||
4078 | |||
4079 | rule__ALSOr__Group_1__2 | ||
4080 | @init { | ||
4081 | int stackSize = keepStackSize(); | ||
4082 | } | ||
4083 | : | ||
4084 | rule__ALSOr__Group_1__2__Impl | ||
4085 | ; | ||
4086 | finally { | ||
4087 | restoreStackSize(stackSize); | ||
4088 | } | ||
4089 | |||
4090 | rule__ALSOr__Group_1__2__Impl | ||
4091 | @init { | ||
4092 | int stackSize = keepStackSize(); | ||
4093 | } | ||
4094 | : | ||
4095 | ( | ||
4096 | { before(grammarAccess.getALSOrAccess().getRightOperandAssignment_1_2()); } | ||
4097 | (rule__ALSOr__RightOperandAssignment_1_2) | ||
4098 | { after(grammarAccess.getALSOrAccess().getRightOperandAssignment_1_2()); } | ||
4099 | ) | ||
4100 | |||
4101 | ; | ||
4102 | finally { | ||
4103 | restoreStackSize(stackSize); | ||
4104 | } | ||
4105 | |||
4106 | |||
4107 | |||
4108 | |||
4109 | |||
4110 | |||
4111 | |||
4112 | |||
4113 | rule__ALSIff__Group__0 | ||
4114 | @init { | ||
4115 | int stackSize = keepStackSize(); | ||
4116 | } | ||
4117 | : | ||
4118 | rule__ALSIff__Group__0__Impl | ||
4119 | rule__ALSIff__Group__1 | ||
4120 | ; | ||
4121 | finally { | ||
4122 | restoreStackSize(stackSize); | ||
4123 | } | ||
4124 | |||
4125 | rule__ALSIff__Group__0__Impl | ||
4126 | @init { | ||
4127 | int stackSize = keepStackSize(); | ||
4128 | } | ||
4129 | : | ||
4130 | ( | ||
4131 | { before(grammarAccess.getALSIffAccess().getALSImplParserRuleCall_0()); } | ||
4132 | ruleALSImpl | ||
4133 | { after(grammarAccess.getALSIffAccess().getALSImplParserRuleCall_0()); } | ||
4134 | ) | ||
4135 | |||
4136 | ; | ||
4137 | finally { | ||
4138 | restoreStackSize(stackSize); | ||
4139 | } | ||
4140 | |||
4141 | |||
4142 | rule__ALSIff__Group__1 | ||
4143 | @init { | ||
4144 | int stackSize = keepStackSize(); | ||
4145 | } | ||
4146 | : | ||
4147 | rule__ALSIff__Group__1__Impl | ||
4148 | ; | ||
4149 | finally { | ||
4150 | restoreStackSize(stackSize); | ||
4151 | } | ||
4152 | |||
4153 | rule__ALSIff__Group__1__Impl | ||
4154 | @init { | ||
4155 | int stackSize = keepStackSize(); | ||
4156 | } | ||
4157 | : | ||
4158 | ( | ||
4159 | { before(grammarAccess.getALSIffAccess().getGroup_1()); } | ||
4160 | (rule__ALSIff__Group_1__0)? | ||
4161 | { after(grammarAccess.getALSIffAccess().getGroup_1()); } | ||
4162 | ) | ||
4163 | |||
4164 | ; | ||
4165 | finally { | ||
4166 | restoreStackSize(stackSize); | ||
4167 | } | ||
4168 | |||
4169 | |||
4170 | |||
4171 | |||
4172 | |||
4173 | |||
4174 | rule__ALSIff__Group_1__0 | ||
4175 | @init { | ||
4176 | int stackSize = keepStackSize(); | ||
4177 | } | ||
4178 | : | ||
4179 | rule__ALSIff__Group_1__0__Impl | ||
4180 | rule__ALSIff__Group_1__1 | ||
4181 | ; | ||
4182 | finally { | ||
4183 | restoreStackSize(stackSize); | ||
4184 | } | ||
4185 | |||
4186 | rule__ALSIff__Group_1__0__Impl | ||
4187 | @init { | ||
4188 | int stackSize = keepStackSize(); | ||
4189 | } | ||
4190 | : | ||
4191 | ( | ||
4192 | { before(grammarAccess.getALSIffAccess().getALSIffLeftOperandAction_1_0()); } | ||
4193 | ( | ||
4194 | |||
4195 | ) | ||
4196 | { after(grammarAccess.getALSIffAccess().getALSIffLeftOperandAction_1_0()); } | ||
4197 | ) | ||
4198 | |||
4199 | ; | ||
4200 | finally { | ||
4201 | restoreStackSize(stackSize); | ||
4202 | } | ||
4203 | |||
4204 | |||
4205 | rule__ALSIff__Group_1__1 | ||
4206 | @init { | ||
4207 | int stackSize = keepStackSize(); | ||
4208 | } | ||
4209 | : | ||
4210 | rule__ALSIff__Group_1__1__Impl | ||
4211 | rule__ALSIff__Group_1__2 | ||
4212 | ; | ||
4213 | finally { | ||
4214 | restoreStackSize(stackSize); | ||
4215 | } | ||
4216 | |||
4217 | rule__ALSIff__Group_1__1__Impl | ||
4218 | @init { | ||
4219 | int stackSize = keepStackSize(); | ||
4220 | } | ||
4221 | : | ||
4222 | ( | ||
4223 | { before(grammarAccess.getALSIffAccess().getAlternatives_1_1()); } | ||
4224 | (rule__ALSIff__Alternatives_1_1) | ||
4225 | { after(grammarAccess.getALSIffAccess().getAlternatives_1_1()); } | ||
4226 | ) | ||
4227 | |||
4228 | ; | ||
4229 | finally { | ||
4230 | restoreStackSize(stackSize); | ||
4231 | } | ||
4232 | |||
4233 | |||
4234 | rule__ALSIff__Group_1__2 | ||
4235 | @init { | ||
4236 | int stackSize = keepStackSize(); | ||
4237 | } | ||
4238 | : | ||
4239 | rule__ALSIff__Group_1__2__Impl | ||
4240 | ; | ||
4241 | finally { | ||
4242 | restoreStackSize(stackSize); | ||
4243 | } | ||
4244 | |||
4245 | rule__ALSIff__Group_1__2__Impl | ||
4246 | @init { | ||
4247 | int stackSize = keepStackSize(); | ||
4248 | } | ||
4249 | : | ||
4250 | ( | ||
4251 | { before(grammarAccess.getALSIffAccess().getRightOperandAssignment_1_2()); } | ||
4252 | (rule__ALSIff__RightOperandAssignment_1_2) | ||
4253 | { after(grammarAccess.getALSIffAccess().getRightOperandAssignment_1_2()); } | ||
4254 | ) | ||
4255 | |||
4256 | ; | ||
4257 | finally { | ||
4258 | restoreStackSize(stackSize); | ||
4259 | } | ||
4260 | |||
4261 | |||
4262 | |||
4263 | |||
4264 | |||
4265 | |||
4266 | |||
4267 | |||
4268 | rule__ALSImpl__Group__0 | ||
4269 | @init { | ||
4270 | int stackSize = keepStackSize(); | ||
4271 | } | ||
4272 | : | ||
4273 | rule__ALSImpl__Group__0__Impl | ||
4274 | rule__ALSImpl__Group__1 | ||
4275 | ; | ||
4276 | finally { | ||
4277 | restoreStackSize(stackSize); | ||
4278 | } | ||
4279 | |||
4280 | rule__ALSImpl__Group__0__Impl | ||
4281 | @init { | ||
4282 | int stackSize = keepStackSize(); | ||
4283 | } | ||
4284 | : | ||
4285 | ( | ||
4286 | { before(grammarAccess.getALSImplAccess().getALSAndParserRuleCall_0()); } | ||
4287 | ruleALSAnd | ||
4288 | { after(grammarAccess.getALSImplAccess().getALSAndParserRuleCall_0()); } | ||
4289 | ) | ||
4290 | |||
4291 | ; | ||
4292 | finally { | ||
4293 | restoreStackSize(stackSize); | ||
4294 | } | ||
4295 | |||
4296 | |||
4297 | rule__ALSImpl__Group__1 | ||
4298 | @init { | ||
4299 | int stackSize = keepStackSize(); | ||
4300 | } | ||
4301 | : | ||
4302 | rule__ALSImpl__Group__1__Impl | ||
4303 | ; | ||
4304 | finally { | ||
4305 | restoreStackSize(stackSize); | ||
4306 | } | ||
4307 | |||
4308 | rule__ALSImpl__Group__1__Impl | ||
4309 | @init { | ||
4310 | int stackSize = keepStackSize(); | ||
4311 | } | ||
4312 | : | ||
4313 | ( | ||
4314 | { before(grammarAccess.getALSImplAccess().getGroup_1()); } | ||
4315 | (rule__ALSImpl__Group_1__0)? | ||
4316 | { after(grammarAccess.getALSImplAccess().getGroup_1()); } | ||
4317 | ) | ||
4318 | |||
4319 | ; | ||
4320 | finally { | ||
4321 | restoreStackSize(stackSize); | ||
4322 | } | ||
4323 | |||
4324 | |||
4325 | |||
4326 | |||
4327 | |||
4328 | |||
4329 | rule__ALSImpl__Group_1__0 | ||
4330 | @init { | ||
4331 | int stackSize = keepStackSize(); | ||
4332 | } | ||
4333 | : | ||
4334 | rule__ALSImpl__Group_1__0__Impl | ||
4335 | rule__ALSImpl__Group_1__1 | ||
4336 | ; | ||
4337 | finally { | ||
4338 | restoreStackSize(stackSize); | ||
4339 | } | ||
4340 | |||
4341 | rule__ALSImpl__Group_1__0__Impl | ||
4342 | @init { | ||
4343 | int stackSize = keepStackSize(); | ||
4344 | } | ||
4345 | : | ||
4346 | ( | ||
4347 | { before(grammarAccess.getALSImplAccess().getALSImplLeftOperandAction_1_0()); } | ||
4348 | ( | ||
4349 | |||
4350 | ) | ||
4351 | { after(grammarAccess.getALSImplAccess().getALSImplLeftOperandAction_1_0()); } | ||
4352 | ) | ||
4353 | |||
4354 | ; | ||
4355 | finally { | ||
4356 | restoreStackSize(stackSize); | ||
4357 | } | ||
4358 | |||
4359 | |||
4360 | rule__ALSImpl__Group_1__1 | ||
4361 | @init { | ||
4362 | int stackSize = keepStackSize(); | ||
4363 | } | ||
4364 | : | ||
4365 | rule__ALSImpl__Group_1__1__Impl | ||
4366 | rule__ALSImpl__Group_1__2 | ||
4367 | ; | ||
4368 | finally { | ||
4369 | restoreStackSize(stackSize); | ||
4370 | } | ||
4371 | |||
4372 | rule__ALSImpl__Group_1__1__Impl | ||
4373 | @init { | ||
4374 | int stackSize = keepStackSize(); | ||
4375 | } | ||
4376 | : | ||
4377 | ( | ||
4378 | { before(grammarAccess.getALSImplAccess().getAlternatives_1_1()); } | ||
4379 | (rule__ALSImpl__Alternatives_1_1) | ||
4380 | { after(grammarAccess.getALSImplAccess().getAlternatives_1_1()); } | ||
4381 | ) | ||
4382 | |||
4383 | ; | ||
4384 | finally { | ||
4385 | restoreStackSize(stackSize); | ||
4386 | } | ||
4387 | |||
4388 | |||
4389 | rule__ALSImpl__Group_1__2 | ||
4390 | @init { | ||
4391 | int stackSize = keepStackSize(); | ||
4392 | } | ||
4393 | : | ||
4394 | rule__ALSImpl__Group_1__2__Impl | ||
4395 | rule__ALSImpl__Group_1__3 | ||
4396 | ; | ||
4397 | finally { | ||
4398 | restoreStackSize(stackSize); | ||
4399 | } | ||
4400 | |||
4401 | rule__ALSImpl__Group_1__2__Impl | ||
4402 | @init { | ||
4403 | int stackSize = keepStackSize(); | ||
4404 | } | ||
4405 | : | ||
4406 | ( | ||
4407 | { before(grammarAccess.getALSImplAccess().getRightOperandAssignment_1_2()); } | ||
4408 | (rule__ALSImpl__RightOperandAssignment_1_2) | ||
4409 | { after(grammarAccess.getALSImplAccess().getRightOperandAssignment_1_2()); } | ||
4410 | ) | ||
4411 | |||
4412 | ; | ||
4413 | finally { | ||
4414 | restoreStackSize(stackSize); | ||
4415 | } | ||
4416 | |||
4417 | |||
4418 | rule__ALSImpl__Group_1__3 | ||
4419 | @init { | ||
4420 | int stackSize = keepStackSize(); | ||
4421 | } | ||
4422 | : | ||
4423 | rule__ALSImpl__Group_1__3__Impl | ||
4424 | ; | ||
4425 | finally { | ||
4426 | restoreStackSize(stackSize); | ||
4427 | } | ||
4428 | |||
4429 | rule__ALSImpl__Group_1__3__Impl | ||
4430 | @init { | ||
4431 | int stackSize = keepStackSize(); | ||
4432 | } | ||
4433 | : | ||
4434 | ( | ||
4435 | { before(grammarAccess.getALSImplAccess().getGroup_1_3()); } | ||
4436 | (rule__ALSImpl__Group_1_3__0)? | ||
4437 | { after(grammarAccess.getALSImplAccess().getGroup_1_3()); } | ||
4438 | ) | ||
4439 | |||
4440 | ; | ||
4441 | finally { | ||
4442 | restoreStackSize(stackSize); | ||
4443 | } | ||
4444 | |||
4445 | |||
4446 | |||
4447 | |||
4448 | |||
4449 | |||
4450 | |||
4451 | |||
4452 | |||
4453 | |||
4454 | rule__ALSImpl__Group_1_3__0 | ||
4455 | @init { | ||
4456 | int stackSize = keepStackSize(); | ||
4457 | } | ||
4458 | : | ||
4459 | rule__ALSImpl__Group_1_3__0__Impl | ||
4460 | rule__ALSImpl__Group_1_3__1 | ||
4461 | ; | ||
4462 | finally { | ||
4463 | restoreStackSize(stackSize); | ||
4464 | } | ||
4465 | |||
4466 | rule__ALSImpl__Group_1_3__0__Impl | ||
4467 | @init { | ||
4468 | int stackSize = keepStackSize(); | ||
4469 | } | ||
4470 | : | ||
4471 | ( | ||
4472 | { before(grammarAccess.getALSImplAccess().getElseKeyword_1_3_0()); } | ||
4473 | |||
4474 | 'else' | ||
4475 | |||
4476 | { after(grammarAccess.getALSImplAccess().getElseKeyword_1_3_0()); } | ||
4477 | ) | ||
4478 | |||
4479 | ; | ||
4480 | finally { | ||
4481 | restoreStackSize(stackSize); | ||
4482 | } | ||
4483 | |||
4484 | |||
4485 | rule__ALSImpl__Group_1_3__1 | ||
4486 | @init { | ||
4487 | int stackSize = keepStackSize(); | ||
4488 | } | ||
4489 | : | ||
4490 | rule__ALSImpl__Group_1_3__1__Impl | ||
4491 | ; | ||
4492 | finally { | ||
4493 | restoreStackSize(stackSize); | ||
4494 | } | ||
4495 | |||
4496 | rule__ALSImpl__Group_1_3__1__Impl | ||
4497 | @init { | ||
4498 | int stackSize = keepStackSize(); | ||
4499 | } | ||
4500 | : | ||
4501 | ( | ||
4502 | { before(grammarAccess.getALSImplAccess().getElseOperandAssignment_1_3_1()); } | ||
4503 | (rule__ALSImpl__ElseOperandAssignment_1_3_1) | ||
4504 | { after(grammarAccess.getALSImplAccess().getElseOperandAssignment_1_3_1()); } | ||
4505 | ) | ||
4506 | |||
4507 | ; | ||
4508 | finally { | ||
4509 | restoreStackSize(stackSize); | ||
4510 | } | ||
4511 | |||
4512 | |||
4513 | |||
4514 | |||
4515 | |||
4516 | |||
4517 | rule__ALSAnd__Group__0 | ||
4518 | @init { | ||
4519 | int stackSize = keepStackSize(); | ||
4520 | } | ||
4521 | : | ||
4522 | rule__ALSAnd__Group__0__Impl | ||
4523 | rule__ALSAnd__Group__1 | ||
4524 | ; | ||
4525 | finally { | ||
4526 | restoreStackSize(stackSize); | ||
4527 | } | ||
4528 | |||
4529 | rule__ALSAnd__Group__0__Impl | ||
4530 | @init { | ||
4531 | int stackSize = keepStackSize(); | ||
4532 | } | ||
4533 | : | ||
4534 | ( | ||
4535 | { before(grammarAccess.getALSAndAccess().getALSComparisonParserRuleCall_0()); } | ||
4536 | ruleALSComparison | ||
4537 | { after(grammarAccess.getALSAndAccess().getALSComparisonParserRuleCall_0()); } | ||
4538 | ) | ||
4539 | |||
4540 | ; | ||
4541 | finally { | ||
4542 | restoreStackSize(stackSize); | ||
4543 | } | ||
4544 | |||
4545 | |||
4546 | rule__ALSAnd__Group__1 | ||
4547 | @init { | ||
4548 | int stackSize = keepStackSize(); | ||
4549 | } | ||
4550 | : | ||
4551 | rule__ALSAnd__Group__1__Impl | ||
4552 | ; | ||
4553 | finally { | ||
4554 | restoreStackSize(stackSize); | ||
4555 | } | ||
4556 | |||
4557 | rule__ALSAnd__Group__1__Impl | ||
4558 | @init { | ||
4559 | int stackSize = keepStackSize(); | ||
4560 | } | ||
4561 | : | ||
4562 | ( | ||
4563 | { before(grammarAccess.getALSAndAccess().getGroup_1()); } | ||
4564 | (rule__ALSAnd__Group_1__0)? | ||
4565 | { after(grammarAccess.getALSAndAccess().getGroup_1()); } | ||
4566 | ) | ||
4567 | |||
4568 | ; | ||
4569 | finally { | ||
4570 | restoreStackSize(stackSize); | ||
4571 | } | ||
4572 | |||
4573 | |||
4574 | |||
4575 | |||
4576 | |||
4577 | |||
4578 | rule__ALSAnd__Group_1__0 | ||
4579 | @init { | ||
4580 | int stackSize = keepStackSize(); | ||
4581 | } | ||
4582 | : | ||
4583 | rule__ALSAnd__Group_1__0__Impl | ||
4584 | rule__ALSAnd__Group_1__1 | ||
4585 | ; | ||
4586 | finally { | ||
4587 | restoreStackSize(stackSize); | ||
4588 | } | ||
4589 | |||
4590 | rule__ALSAnd__Group_1__0__Impl | ||
4591 | @init { | ||
4592 | int stackSize = keepStackSize(); | ||
4593 | } | ||
4594 | : | ||
4595 | ( | ||
4596 | { before(grammarAccess.getALSAndAccess().getALSAndLeftOperandAction_1_0()); } | ||
4597 | ( | ||
4598 | |||
4599 | ) | ||
4600 | { after(grammarAccess.getALSAndAccess().getALSAndLeftOperandAction_1_0()); } | ||
4601 | ) | ||
4602 | |||
4603 | ; | ||
4604 | finally { | ||
4605 | restoreStackSize(stackSize); | ||
4606 | } | ||
4607 | |||
4608 | |||
4609 | rule__ALSAnd__Group_1__1 | ||
4610 | @init { | ||
4611 | int stackSize = keepStackSize(); | ||
4612 | } | ||
4613 | : | ||
4614 | rule__ALSAnd__Group_1__1__Impl | ||
4615 | rule__ALSAnd__Group_1__2 | ||
4616 | ; | ||
4617 | finally { | ||
4618 | restoreStackSize(stackSize); | ||
4619 | } | ||
4620 | |||
4621 | rule__ALSAnd__Group_1__1__Impl | ||
4622 | @init { | ||
4623 | int stackSize = keepStackSize(); | ||
4624 | } | ||
4625 | : | ||
4626 | ( | ||
4627 | { before(grammarAccess.getALSAndAccess().getAlternatives_1_1()); } | ||
4628 | (rule__ALSAnd__Alternatives_1_1) | ||
4629 | { after(grammarAccess.getALSAndAccess().getAlternatives_1_1()); } | ||
4630 | ) | ||
4631 | |||
4632 | ; | ||
4633 | finally { | ||
4634 | restoreStackSize(stackSize); | ||
4635 | } | ||
4636 | |||
4637 | |||
4638 | rule__ALSAnd__Group_1__2 | ||
4639 | @init { | ||
4640 | int stackSize = keepStackSize(); | ||
4641 | } | ||
4642 | : | ||
4643 | rule__ALSAnd__Group_1__2__Impl | ||
4644 | ; | ||
4645 | finally { | ||
4646 | restoreStackSize(stackSize); | ||
4647 | } | ||
4648 | |||
4649 | rule__ALSAnd__Group_1__2__Impl | ||
4650 | @init { | ||
4651 | int stackSize = keepStackSize(); | ||
4652 | } | ||
4653 | : | ||
4654 | ( | ||
4655 | { before(grammarAccess.getALSAndAccess().getRightOperandAssignment_1_2()); } | ||
4656 | (rule__ALSAnd__RightOperandAssignment_1_2) | ||
4657 | { after(grammarAccess.getALSAndAccess().getRightOperandAssignment_1_2()); } | ||
4658 | ) | ||
4659 | |||
4660 | ; | ||
4661 | finally { | ||
4662 | restoreStackSize(stackSize); | ||
4663 | } | ||
4664 | |||
4665 | |||
4666 | |||
4667 | |||
4668 | |||
4669 | |||
4670 | |||
4671 | |||
4672 | rule__ALSComparison__Group__0 | ||
4673 | @init { | ||
4674 | int stackSize = keepStackSize(); | ||
4675 | } | ||
4676 | : | ||
4677 | rule__ALSComparison__Group__0__Impl | ||
4678 | rule__ALSComparison__Group__1 | ||
4679 | ; | ||
4680 | finally { | ||
4681 | restoreStackSize(stackSize); | ||
4682 | } | ||
4683 | |||
4684 | rule__ALSComparison__Group__0__Impl | ||
4685 | @init { | ||
4686 | int stackSize = keepStackSize(); | ||
4687 | } | ||
4688 | : | ||
4689 | ( | ||
4690 | { before(grammarAccess.getALSComparisonAccess().getALSOverrideParserRuleCall_0()); } | ||
4691 | ruleALSOverride | ||
4692 | { after(grammarAccess.getALSComparisonAccess().getALSOverrideParserRuleCall_0()); } | ||
4693 | ) | ||
4694 | |||
4695 | ; | ||
4696 | finally { | ||
4697 | restoreStackSize(stackSize); | ||
4698 | } | ||
4699 | |||
4700 | |||
4701 | rule__ALSComparison__Group__1 | ||
4702 | @init { | ||
4703 | int stackSize = keepStackSize(); | ||
4704 | } | ||
4705 | : | ||
4706 | rule__ALSComparison__Group__1__Impl | ||
4707 | ; | ||
4708 | finally { | ||
4709 | restoreStackSize(stackSize); | ||
4710 | } | ||
4711 | |||
4712 | rule__ALSComparison__Group__1__Impl | ||
4713 | @init { | ||
4714 | int stackSize = keepStackSize(); | ||
4715 | } | ||
4716 | : | ||
4717 | ( | ||
4718 | { before(grammarAccess.getALSComparisonAccess().getGroup_1()); } | ||
4719 | (rule__ALSComparison__Group_1__0)? | ||
4720 | { after(grammarAccess.getALSComparisonAccess().getGroup_1()); } | ||
4721 | ) | ||
4722 | |||
4723 | ; | ||
4724 | finally { | ||
4725 | restoreStackSize(stackSize); | ||
4726 | } | ||
4727 | |||
4728 | |||
4729 | |||
4730 | |||
4731 | |||
4732 | |||
4733 | rule__ALSComparison__Group_1__0 | ||
4734 | @init { | ||
4735 | int stackSize = keepStackSize(); | ||
4736 | } | ||
4737 | : | ||
4738 | rule__ALSComparison__Group_1__0__Impl | ||
4739 | rule__ALSComparison__Group_1__1 | ||
4740 | ; | ||
4741 | finally { | ||
4742 | restoreStackSize(stackSize); | ||
4743 | } | ||
4744 | |||
4745 | rule__ALSComparison__Group_1__0__Impl | ||
4746 | @init { | ||
4747 | int stackSize = keepStackSize(); | ||
4748 | } | ||
4749 | : | ||
4750 | ( | ||
4751 | { before(grammarAccess.getALSComparisonAccess().getAlternatives_1_0()); } | ||
4752 | (rule__ALSComparison__Alternatives_1_0) | ||
4753 | { after(grammarAccess.getALSComparisonAccess().getAlternatives_1_0()); } | ||
4754 | ) | ||
4755 | |||
4756 | ; | ||
4757 | finally { | ||
4758 | restoreStackSize(stackSize); | ||
4759 | } | ||
4760 | |||
4761 | |||
4762 | rule__ALSComparison__Group_1__1 | ||
4763 | @init { | ||
4764 | int stackSize = keepStackSize(); | ||
4765 | } | ||
4766 | : | ||
4767 | rule__ALSComparison__Group_1__1__Impl | ||
4768 | ; | ||
4769 | finally { | ||
4770 | restoreStackSize(stackSize); | ||
4771 | } | ||
4772 | |||
4773 | rule__ALSComparison__Group_1__1__Impl | ||
4774 | @init { | ||
4775 | int stackSize = keepStackSize(); | ||
4776 | } | ||
4777 | : | ||
4778 | ( | ||
4779 | { before(grammarAccess.getALSComparisonAccess().getRightOperandAssignment_1_1()); } | ||
4780 | (rule__ALSComparison__RightOperandAssignment_1_1) | ||
4781 | { after(grammarAccess.getALSComparisonAccess().getRightOperandAssignment_1_1()); } | ||
4782 | ) | ||
4783 | |||
4784 | ; | ||
4785 | finally { | ||
4786 | restoreStackSize(stackSize); | ||
4787 | } | ||
4788 | |||
4789 | |||
4790 | |||
4791 | |||
4792 | |||
4793 | |||
4794 | rule__ALSComparison__Group_1_0_0__0 | ||
4795 | @init { | ||
4796 | int stackSize = keepStackSize(); | ||
4797 | } | ||
4798 | : | ||
4799 | rule__ALSComparison__Group_1_0_0__0__Impl | ||
4800 | rule__ALSComparison__Group_1_0_0__1 | ||
4801 | ; | ||
4802 | finally { | ||
4803 | restoreStackSize(stackSize); | ||
4804 | } | ||
4805 | |||
4806 | rule__ALSComparison__Group_1_0_0__0__Impl | ||
4807 | @init { | ||
4808 | int stackSize = keepStackSize(); | ||
4809 | } | ||
4810 | : | ||
4811 | ( | ||
4812 | { before(grammarAccess.getALSComparisonAccess().getALSEqualsLeftOperandAction_1_0_0_0()); } | ||
4813 | ( | ||
4814 | |||
4815 | ) | ||
4816 | { after(grammarAccess.getALSComparisonAccess().getALSEqualsLeftOperandAction_1_0_0_0()); } | ||
4817 | ) | ||
4818 | |||
4819 | ; | ||
4820 | finally { | ||
4821 | restoreStackSize(stackSize); | ||
4822 | } | ||
4823 | |||
4824 | |||
4825 | rule__ALSComparison__Group_1_0_0__1 | ||
4826 | @init { | ||
4827 | int stackSize = keepStackSize(); | ||
4828 | } | ||
4829 | : | ||
4830 | rule__ALSComparison__Group_1_0_0__1__Impl | ||
4831 | ; | ||
4832 | finally { | ||
4833 | restoreStackSize(stackSize); | ||
4834 | } | ||
4835 | |||
4836 | rule__ALSComparison__Group_1_0_0__1__Impl | ||
4837 | @init { | ||
4838 | int stackSize = keepStackSize(); | ||
4839 | } | ||
4840 | : | ||
4841 | ( | ||
4842 | { before(grammarAccess.getALSComparisonAccess().getEqualsSignKeyword_1_0_0_1()); } | ||
4843 | |||
4844 | '=' | ||
4845 | |||
4846 | { after(grammarAccess.getALSComparisonAccess().getEqualsSignKeyword_1_0_0_1()); } | ||
4847 | ) | ||
4848 | |||
4849 | ; | ||
4850 | finally { | ||
4851 | restoreStackSize(stackSize); | ||
4852 | } | ||
4853 | |||
4854 | |||
4855 | |||
4856 | |||
4857 | |||
4858 | |||
4859 | rule__ALSComparison__Group_1_0_1__0 | ||
4860 | @init { | ||
4861 | int stackSize = keepStackSize(); | ||
4862 | } | ||
4863 | : | ||
4864 | rule__ALSComparison__Group_1_0_1__0__Impl | ||
4865 | rule__ALSComparison__Group_1_0_1__1 | ||
4866 | ; | ||
4867 | finally { | ||
4868 | restoreStackSize(stackSize); | ||
4869 | } | ||
4870 | |||
4871 | rule__ALSComparison__Group_1_0_1__0__Impl | ||
4872 | @init { | ||
4873 | int stackSize = keepStackSize(); | ||
4874 | } | ||
4875 | : | ||
4876 | ( | ||
4877 | { before(grammarAccess.getALSComparisonAccess().getALSNotEqualsLeftOperandAction_1_0_1_0()); } | ||
4878 | ( | ||
4879 | |||
4880 | ) | ||
4881 | { after(grammarAccess.getALSComparisonAccess().getALSNotEqualsLeftOperandAction_1_0_1_0()); } | ||
4882 | ) | ||
4883 | |||
4884 | ; | ||
4885 | finally { | ||
4886 | restoreStackSize(stackSize); | ||
4887 | } | ||
4888 | |||
4889 | |||
4890 | rule__ALSComparison__Group_1_0_1__1 | ||
4891 | @init { | ||
4892 | int stackSize = keepStackSize(); | ||
4893 | } | ||
4894 | : | ||
4895 | rule__ALSComparison__Group_1_0_1__1__Impl | ||
4896 | ; | ||
4897 | finally { | ||
4898 | restoreStackSize(stackSize); | ||
4899 | } | ||
4900 | |||
4901 | rule__ALSComparison__Group_1_0_1__1__Impl | ||
4902 | @init { | ||
4903 | int stackSize = keepStackSize(); | ||
4904 | } | ||
4905 | : | ||
4906 | ( | ||
4907 | { before(grammarAccess.getALSComparisonAccess().getExclamationMarkEqualsSignKeyword_1_0_1_1()); } | ||
4908 | |||
4909 | '!=' | ||
4910 | |||
4911 | { after(grammarAccess.getALSComparisonAccess().getExclamationMarkEqualsSignKeyword_1_0_1_1()); } | ||
4912 | ) | ||
4913 | |||
4914 | ; | ||
4915 | finally { | ||
4916 | restoreStackSize(stackSize); | ||
4917 | } | ||
4918 | |||
4919 | |||
4920 | |||
4921 | |||
4922 | |||
4923 | |||
4924 | rule__ALSComparison__Group_1_0_2__0 | ||
4925 | @init { | ||
4926 | int stackSize = keepStackSize(); | ||
4927 | } | ||
4928 | : | ||
4929 | rule__ALSComparison__Group_1_0_2__0__Impl | ||
4930 | rule__ALSComparison__Group_1_0_2__1 | ||
4931 | ; | ||
4932 | finally { | ||
4933 | restoreStackSize(stackSize); | ||
4934 | } | ||
4935 | |||
4936 | rule__ALSComparison__Group_1_0_2__0__Impl | ||
4937 | @init { | ||
4938 | int stackSize = keepStackSize(); | ||
4939 | } | ||
4940 | : | ||
4941 | ( | ||
4942 | { before(grammarAccess.getALSComparisonAccess().getALSSubsetLeftOperandAction_1_0_2_0()); } | ||
4943 | ( | ||
4944 | |||
4945 | ) | ||
4946 | { after(grammarAccess.getALSComparisonAccess().getALSSubsetLeftOperandAction_1_0_2_0()); } | ||
4947 | ) | ||
4948 | |||
4949 | ; | ||
4950 | finally { | ||
4951 | restoreStackSize(stackSize); | ||
4952 | } | ||
4953 | |||
4954 | |||
4955 | rule__ALSComparison__Group_1_0_2__1 | ||
4956 | @init { | ||
4957 | int stackSize = keepStackSize(); | ||
4958 | } | ||
4959 | : | ||
4960 | rule__ALSComparison__Group_1_0_2__1__Impl | ||
4961 | ; | ||
4962 | finally { | ||
4963 | restoreStackSize(stackSize); | ||
4964 | } | ||
4965 | |||
4966 | rule__ALSComparison__Group_1_0_2__1__Impl | ||
4967 | @init { | ||
4968 | int stackSize = keepStackSize(); | ||
4969 | } | ||
4970 | : | ||
4971 | ( | ||
4972 | { before(grammarAccess.getALSComparisonAccess().getInKeyword_1_0_2_1()); } | ||
4973 | |||
4974 | 'in' | ||
4975 | |||
4976 | { after(grammarAccess.getALSComparisonAccess().getInKeyword_1_0_2_1()); } | ||
4977 | ) | ||
4978 | |||
4979 | ; | ||
4980 | finally { | ||
4981 | restoreStackSize(stackSize); | ||
4982 | } | ||
4983 | |||
4984 | |||
4985 | |||
4986 | |||
4987 | |||
4988 | |||
4989 | rule__ALSComparison__Group_1_0_3__0 | ||
4990 | @init { | ||
4991 | int stackSize = keepStackSize(); | ||
4992 | } | ||
4993 | : | ||
4994 | rule__ALSComparison__Group_1_0_3__0__Impl | ||
4995 | rule__ALSComparison__Group_1_0_3__1 | ||
4996 | ; | ||
4997 | finally { | ||
4998 | restoreStackSize(stackSize); | ||
4999 | } | ||
5000 | |||
5001 | rule__ALSComparison__Group_1_0_3__0__Impl | ||
5002 | @init { | ||
5003 | int stackSize = keepStackSize(); | ||
5004 | } | ||
5005 | : | ||
5006 | ( | ||
5007 | { before(grammarAccess.getALSComparisonAccess().getALSLessLeftOperandAction_1_0_3_0()); } | ||
5008 | ( | ||
5009 | |||
5010 | ) | ||
5011 | { after(grammarAccess.getALSComparisonAccess().getALSLessLeftOperandAction_1_0_3_0()); } | ||
5012 | ) | ||
5013 | |||
5014 | ; | ||
5015 | finally { | ||
5016 | restoreStackSize(stackSize); | ||
5017 | } | ||
5018 | |||
5019 | |||
5020 | rule__ALSComparison__Group_1_0_3__1 | ||
5021 | @init { | ||
5022 | int stackSize = keepStackSize(); | ||
5023 | } | ||
5024 | : | ||
5025 | rule__ALSComparison__Group_1_0_3__1__Impl | ||
5026 | ; | ||
5027 | finally { | ||
5028 | restoreStackSize(stackSize); | ||
5029 | } | ||
5030 | |||
5031 | rule__ALSComparison__Group_1_0_3__1__Impl | ||
5032 | @init { | ||
5033 | int stackSize = keepStackSize(); | ||
5034 | } | ||
5035 | : | ||
5036 | ( | ||
5037 | { before(grammarAccess.getALSComparisonAccess().getGreaterThanSignKeyword_1_0_3_1()); } | ||
5038 | |||
5039 | '>' | ||
5040 | |||
5041 | { after(grammarAccess.getALSComparisonAccess().getGreaterThanSignKeyword_1_0_3_1()); } | ||
5042 | ) | ||
5043 | |||
5044 | ; | ||
5045 | finally { | ||
5046 | restoreStackSize(stackSize); | ||
5047 | } | ||
5048 | |||
5049 | |||
5050 | |||
5051 | |||
5052 | |||
5053 | |||
5054 | rule__ALSComparison__Group_1_0_4__0 | ||
5055 | @init { | ||
5056 | int stackSize = keepStackSize(); | ||
5057 | } | ||
5058 | : | ||
5059 | rule__ALSComparison__Group_1_0_4__0__Impl | ||
5060 | rule__ALSComparison__Group_1_0_4__1 | ||
5061 | ; | ||
5062 | finally { | ||
5063 | restoreStackSize(stackSize); | ||
5064 | } | ||
5065 | |||
5066 | rule__ALSComparison__Group_1_0_4__0__Impl | ||
5067 | @init { | ||
5068 | int stackSize = keepStackSize(); | ||
5069 | } | ||
5070 | : | ||
5071 | ( | ||
5072 | { before(grammarAccess.getALSComparisonAccess().getALSLeqLeftOperandAction_1_0_4_0()); } | ||
5073 | ( | ||
5074 | |||
5075 | ) | ||
5076 | { after(grammarAccess.getALSComparisonAccess().getALSLeqLeftOperandAction_1_0_4_0()); } | ||
5077 | ) | ||
5078 | |||
5079 | ; | ||
5080 | finally { | ||
5081 | restoreStackSize(stackSize); | ||
5082 | } | ||
5083 | |||
5084 | |||
5085 | rule__ALSComparison__Group_1_0_4__1 | ||
5086 | @init { | ||
5087 | int stackSize = keepStackSize(); | ||
5088 | } | ||
5089 | : | ||
5090 | rule__ALSComparison__Group_1_0_4__1__Impl | ||
5091 | ; | ||
5092 | finally { | ||
5093 | restoreStackSize(stackSize); | ||
5094 | } | ||
5095 | |||
5096 | rule__ALSComparison__Group_1_0_4__1__Impl | ||
5097 | @init { | ||
5098 | int stackSize = keepStackSize(); | ||
5099 | } | ||
5100 | : | ||
5101 | ( | ||
5102 | { before(grammarAccess.getALSComparisonAccess().getGreaterThanSignEqualsSignKeyword_1_0_4_1()); } | ||
5103 | |||
5104 | '>=' | ||
5105 | |||
5106 | { after(grammarAccess.getALSComparisonAccess().getGreaterThanSignEqualsSignKeyword_1_0_4_1()); } | ||
5107 | ) | ||
5108 | |||
5109 | ; | ||
5110 | finally { | ||
5111 | restoreStackSize(stackSize); | ||
5112 | } | ||
5113 | |||
5114 | |||
5115 | |||
5116 | |||
5117 | |||
5118 | |||
5119 | rule__ALSComparison__Group_1_0_5__0 | ||
5120 | @init { | ||
5121 | int stackSize = keepStackSize(); | ||
5122 | } | ||
5123 | : | ||
5124 | rule__ALSComparison__Group_1_0_5__0__Impl | ||
5125 | rule__ALSComparison__Group_1_0_5__1 | ||
5126 | ; | ||
5127 | finally { | ||
5128 | restoreStackSize(stackSize); | ||
5129 | } | ||
5130 | |||
5131 | rule__ALSComparison__Group_1_0_5__0__Impl | ||
5132 | @init { | ||
5133 | int stackSize = keepStackSize(); | ||
5134 | } | ||
5135 | : | ||
5136 | ( | ||
5137 | { before(grammarAccess.getALSComparisonAccess().getALSMoreLeftOperandAction_1_0_5_0()); } | ||
5138 | ( | ||
5139 | |||
5140 | ) | ||
5141 | { after(grammarAccess.getALSComparisonAccess().getALSMoreLeftOperandAction_1_0_5_0()); } | ||
5142 | ) | ||
5143 | |||
5144 | ; | ||
5145 | finally { | ||
5146 | restoreStackSize(stackSize); | ||
5147 | } | ||
5148 | |||
5149 | |||
5150 | rule__ALSComparison__Group_1_0_5__1 | ||
5151 | @init { | ||
5152 | int stackSize = keepStackSize(); | ||
5153 | } | ||
5154 | : | ||
5155 | rule__ALSComparison__Group_1_0_5__1__Impl | ||
5156 | ; | ||
5157 | finally { | ||
5158 | restoreStackSize(stackSize); | ||
5159 | } | ||
5160 | |||
5161 | rule__ALSComparison__Group_1_0_5__1__Impl | ||
5162 | @init { | ||
5163 | int stackSize = keepStackSize(); | ||
5164 | } | ||
5165 | : | ||
5166 | ( | ||
5167 | { before(grammarAccess.getALSComparisonAccess().getLessThanSignKeyword_1_0_5_1()); } | ||
5168 | |||
5169 | '<' | ||
5170 | |||
5171 | { after(grammarAccess.getALSComparisonAccess().getLessThanSignKeyword_1_0_5_1()); } | ||
5172 | ) | ||
5173 | |||
5174 | ; | ||
5175 | finally { | ||
5176 | restoreStackSize(stackSize); | ||
5177 | } | ||
5178 | |||
5179 | |||
5180 | |||
5181 | |||
5182 | |||
5183 | |||
5184 | rule__ALSComparison__Group_1_0_6__0 | ||
5185 | @init { | ||
5186 | int stackSize = keepStackSize(); | ||
5187 | } | ||
5188 | : | ||
5189 | rule__ALSComparison__Group_1_0_6__0__Impl | ||
5190 | rule__ALSComparison__Group_1_0_6__1 | ||
5191 | ; | ||
5192 | finally { | ||
5193 | restoreStackSize(stackSize); | ||
5194 | } | ||
5195 | |||
5196 | rule__ALSComparison__Group_1_0_6__0__Impl | ||
5197 | @init { | ||
5198 | int stackSize = keepStackSize(); | ||
5199 | } | ||
5200 | : | ||
5201 | ( | ||
5202 | { before(grammarAccess.getALSComparisonAccess().getALSMeqLeftOperandAction_1_0_6_0()); } | ||
5203 | ( | ||
5204 | |||
5205 | ) | ||
5206 | { after(grammarAccess.getALSComparisonAccess().getALSMeqLeftOperandAction_1_0_6_0()); } | ||
5207 | ) | ||
5208 | |||
5209 | ; | ||
5210 | finally { | ||
5211 | restoreStackSize(stackSize); | ||
5212 | } | ||
5213 | |||
5214 | |||
5215 | rule__ALSComparison__Group_1_0_6__1 | ||
5216 | @init { | ||
5217 | int stackSize = keepStackSize(); | ||
5218 | } | ||
5219 | : | ||
5220 | rule__ALSComparison__Group_1_0_6__1__Impl | ||
5221 | ; | ||
5222 | finally { | ||
5223 | restoreStackSize(stackSize); | ||
5224 | } | ||
5225 | |||
5226 | rule__ALSComparison__Group_1_0_6__1__Impl | ||
5227 | @init { | ||
5228 | int stackSize = keepStackSize(); | ||
5229 | } | ||
5230 | : | ||
5231 | ( | ||
5232 | { before(grammarAccess.getALSComparisonAccess().getLessThanSignEqualsSignKeyword_1_0_6_1()); } | ||
5233 | |||
5234 | '<=' | ||
5235 | |||
5236 | { after(grammarAccess.getALSComparisonAccess().getLessThanSignEqualsSignKeyword_1_0_6_1()); } | ||
5237 | ) | ||
5238 | |||
5239 | ; | ||
5240 | finally { | ||
5241 | restoreStackSize(stackSize); | ||
5242 | } | ||
5243 | |||
5244 | |||
5245 | |||
5246 | |||
5247 | |||
5248 | |||
5249 | rule__ALSOverride__Group__0 | ||
5250 | @init { | ||
5251 | int stackSize = keepStackSize(); | ||
5252 | } | ||
5253 | : | ||
5254 | rule__ALSOverride__Group__0__Impl | ||
5255 | rule__ALSOverride__Group__1 | ||
5256 | ; | ||
5257 | finally { | ||
5258 | restoreStackSize(stackSize); | ||
5259 | } | ||
5260 | |||
5261 | rule__ALSOverride__Group__0__Impl | ||
5262 | @init { | ||
5263 | int stackSize = keepStackSize(); | ||
5264 | } | ||
5265 | : | ||
5266 | ( | ||
5267 | { before(grammarAccess.getALSOverrideAccess().getALSRangeRestrictionRightParserRuleCall_0()); } | ||
5268 | ruleALSRangeRestrictionRight | ||
5269 | { after(grammarAccess.getALSOverrideAccess().getALSRangeRestrictionRightParserRuleCall_0()); } | ||
5270 | ) | ||
5271 | |||
5272 | ; | ||
5273 | finally { | ||
5274 | restoreStackSize(stackSize); | ||
5275 | } | ||
5276 | |||
5277 | |||
5278 | rule__ALSOverride__Group__1 | ||
5279 | @init { | ||
5280 | int stackSize = keepStackSize(); | ||
5281 | } | ||
5282 | : | ||
5283 | rule__ALSOverride__Group__1__Impl | ||
5284 | ; | ||
5285 | finally { | ||
5286 | restoreStackSize(stackSize); | ||
5287 | } | ||
5288 | |||
5289 | rule__ALSOverride__Group__1__Impl | ||
5290 | @init { | ||
5291 | int stackSize = keepStackSize(); | ||
5292 | } | ||
5293 | : | ||
5294 | ( | ||
5295 | { before(grammarAccess.getALSOverrideAccess().getGroup_1()); } | ||
5296 | (rule__ALSOverride__Group_1__0)? | ||
5297 | { after(grammarAccess.getALSOverrideAccess().getGroup_1()); } | ||
5298 | ) | ||
5299 | |||
5300 | ; | ||
5301 | finally { | ||
5302 | restoreStackSize(stackSize); | ||
5303 | } | ||
5304 | |||
5305 | |||
5306 | |||
5307 | |||
5308 | |||
5309 | |||
5310 | rule__ALSOverride__Group_1__0 | ||
5311 | @init { | ||
5312 | int stackSize = keepStackSize(); | ||
5313 | } | ||
5314 | : | ||
5315 | rule__ALSOverride__Group_1__0__Impl | ||
5316 | rule__ALSOverride__Group_1__1 | ||
5317 | ; | ||
5318 | finally { | ||
5319 | restoreStackSize(stackSize); | ||
5320 | } | ||
5321 | |||
5322 | rule__ALSOverride__Group_1__0__Impl | ||
5323 | @init { | ||
5324 | int stackSize = keepStackSize(); | ||
5325 | } | ||
5326 | : | ||
5327 | ( | ||
5328 | { before(grammarAccess.getALSOverrideAccess().getALSOverrideLeftOperandAction_1_0()); } | ||
5329 | ( | ||
5330 | |||
5331 | ) | ||
5332 | { after(grammarAccess.getALSOverrideAccess().getALSOverrideLeftOperandAction_1_0()); } | ||
5333 | ) | ||
5334 | |||
5335 | ; | ||
5336 | finally { | ||
5337 | restoreStackSize(stackSize); | ||
5338 | } | ||
5339 | |||
5340 | |||
5341 | rule__ALSOverride__Group_1__1 | ||
5342 | @init { | ||
5343 | int stackSize = keepStackSize(); | ||
5344 | } | ||
5345 | : | ||
5346 | rule__ALSOverride__Group_1__1__Impl | ||
5347 | rule__ALSOverride__Group_1__2 | ||
5348 | ; | ||
5349 | finally { | ||
5350 | restoreStackSize(stackSize); | ||
5351 | } | ||
5352 | |||
5353 | rule__ALSOverride__Group_1__1__Impl | ||
5354 | @init { | ||
5355 | int stackSize = keepStackSize(); | ||
5356 | } | ||
5357 | : | ||
5358 | ( | ||
5359 | { before(grammarAccess.getALSOverrideAccess().getPlusSignPlusSignKeyword_1_1()); } | ||
5360 | |||
5361 | '++' | ||
5362 | |||
5363 | { after(grammarAccess.getALSOverrideAccess().getPlusSignPlusSignKeyword_1_1()); } | ||
5364 | ) | ||
5365 | |||
5366 | ; | ||
5367 | finally { | ||
5368 | restoreStackSize(stackSize); | ||
5369 | } | ||
5370 | |||
5371 | |||
5372 | rule__ALSOverride__Group_1__2 | ||
5373 | @init { | ||
5374 | int stackSize = keepStackSize(); | ||
5375 | } | ||
5376 | : | ||
5377 | rule__ALSOverride__Group_1__2__Impl | ||
5378 | ; | ||
5379 | finally { | ||
5380 | restoreStackSize(stackSize); | ||
5381 | } | ||
5382 | |||
5383 | rule__ALSOverride__Group_1__2__Impl | ||
5384 | @init { | ||
5385 | int stackSize = keepStackSize(); | ||
5386 | } | ||
5387 | : | ||
5388 | ( | ||
5389 | { before(grammarAccess.getALSOverrideAccess().getRightOperandAssignment_1_2()); } | ||
5390 | (rule__ALSOverride__RightOperandAssignment_1_2) | ||
5391 | { after(grammarAccess.getALSOverrideAccess().getRightOperandAssignment_1_2()); } | ||
5392 | ) | ||
5393 | |||
5394 | ; | ||
5395 | finally { | ||
5396 | restoreStackSize(stackSize); | ||
5397 | } | ||
5398 | |||
5399 | |||
5400 | |||
5401 | |||
5402 | |||
5403 | |||
5404 | |||
5405 | |||
5406 | rule__ALSRangeRestrictionRight__Group__0 | ||
5407 | @init { | ||
5408 | int stackSize = keepStackSize(); | ||
5409 | } | ||
5410 | : | ||
5411 | rule__ALSRangeRestrictionRight__Group__0__Impl | ||
5412 | rule__ALSRangeRestrictionRight__Group__1 | ||
5413 | ; | ||
5414 | finally { | ||
5415 | restoreStackSize(stackSize); | ||
5416 | } | ||
5417 | |||
5418 | rule__ALSRangeRestrictionRight__Group__0__Impl | ||
5419 | @init { | ||
5420 | int stackSize = keepStackSize(); | ||
5421 | } | ||
5422 | : | ||
5423 | ( | ||
5424 | { before(grammarAccess.getALSRangeRestrictionRightAccess().getALSRangeRestrictionLeftParserRuleCall_0()); } | ||
5425 | ruleALSRangeRestrictionLeft | ||
5426 | { after(grammarAccess.getALSRangeRestrictionRightAccess().getALSRangeRestrictionLeftParserRuleCall_0()); } | ||
5427 | ) | ||
5428 | |||
5429 | ; | ||
5430 | finally { | ||
5431 | restoreStackSize(stackSize); | ||
5432 | } | ||
5433 | |||
5434 | |||
5435 | rule__ALSRangeRestrictionRight__Group__1 | ||
5436 | @init { | ||
5437 | int stackSize = keepStackSize(); | ||
5438 | } | ||
5439 | : | ||
5440 | rule__ALSRangeRestrictionRight__Group__1__Impl | ||
5441 | ; | ||
5442 | finally { | ||
5443 | restoreStackSize(stackSize); | ||
5444 | } | ||
5445 | |||
5446 | rule__ALSRangeRestrictionRight__Group__1__Impl | ||
5447 | @init { | ||
5448 | int stackSize = keepStackSize(); | ||
5449 | } | ||
5450 | : | ||
5451 | ( | ||
5452 | { before(grammarAccess.getALSRangeRestrictionRightAccess().getGroup_1()); } | ||
5453 | (rule__ALSRangeRestrictionRight__Group_1__0)? | ||
5454 | { after(grammarAccess.getALSRangeRestrictionRightAccess().getGroup_1()); } | ||
5455 | ) | ||
5456 | |||
5457 | ; | ||
5458 | finally { | ||
5459 | restoreStackSize(stackSize); | ||
5460 | } | ||
5461 | |||
5462 | |||
5463 | |||
5464 | |||
5465 | |||
5466 | |||
5467 | rule__ALSRangeRestrictionRight__Group_1__0 | ||
5468 | @init { | ||
5469 | int stackSize = keepStackSize(); | ||
5470 | } | ||
5471 | : | ||
5472 | rule__ALSRangeRestrictionRight__Group_1__0__Impl | ||
5473 | rule__ALSRangeRestrictionRight__Group_1__1 | ||
5474 | ; | ||
5475 | finally { | ||
5476 | restoreStackSize(stackSize); | ||
5477 | } | ||
5478 | |||
5479 | rule__ALSRangeRestrictionRight__Group_1__0__Impl | ||
5480 | @init { | ||
5481 | int stackSize = keepStackSize(); | ||
5482 | } | ||
5483 | : | ||
5484 | ( | ||
5485 | { before(grammarAccess.getALSRangeRestrictionRightAccess().getALSRangeRestrictionRightRelationAction_1_0()); } | ||
5486 | ( | ||
5487 | |||
5488 | ) | ||
5489 | { after(grammarAccess.getALSRangeRestrictionRightAccess().getALSRangeRestrictionRightRelationAction_1_0()); } | ||
5490 | ) | ||
5491 | |||
5492 | ; | ||
5493 | finally { | ||
5494 | restoreStackSize(stackSize); | ||
5495 | } | ||
5496 | |||
5497 | |||
5498 | rule__ALSRangeRestrictionRight__Group_1__1 | ||
5499 | @init { | ||
5500 | int stackSize = keepStackSize(); | ||
5501 | } | ||
5502 | : | ||
5503 | rule__ALSRangeRestrictionRight__Group_1__1__Impl | ||
5504 | rule__ALSRangeRestrictionRight__Group_1__2 | ||
5505 | ; | ||
5506 | finally { | ||
5507 | restoreStackSize(stackSize); | ||
5508 | } | ||
5509 | |||
5510 | rule__ALSRangeRestrictionRight__Group_1__1__Impl | ||
5511 | @init { | ||
5512 | int stackSize = keepStackSize(); | ||
5513 | } | ||
5514 | : | ||
5515 | ( | ||
5516 | { before(grammarAccess.getALSRangeRestrictionRightAccess().getColonGreaterThanSignKeyword_1_1()); } | ||
5517 | |||
5518 | ':>' | ||
5519 | |||
5520 | { after(grammarAccess.getALSRangeRestrictionRightAccess().getColonGreaterThanSignKeyword_1_1()); } | ||
5521 | ) | ||
5522 | |||
5523 | ; | ||
5524 | finally { | ||
5525 | restoreStackSize(stackSize); | ||
5526 | } | ||
5527 | |||
5528 | |||
5529 | rule__ALSRangeRestrictionRight__Group_1__2 | ||
5530 | @init { | ||
5531 | int stackSize = keepStackSize(); | ||
5532 | } | ||
5533 | : | ||
5534 | rule__ALSRangeRestrictionRight__Group_1__2__Impl | ||
5535 | ; | ||
5536 | finally { | ||
5537 | restoreStackSize(stackSize); | ||
5538 | } | ||
5539 | |||
5540 | rule__ALSRangeRestrictionRight__Group_1__2__Impl | ||
5541 | @init { | ||
5542 | int stackSize = keepStackSize(); | ||
5543 | } | ||
5544 | : | ||
5545 | ( | ||
5546 | { before(grammarAccess.getALSRangeRestrictionRightAccess().getFilterAssignment_1_2()); } | ||
5547 | (rule__ALSRangeRestrictionRight__FilterAssignment_1_2) | ||
5548 | { after(grammarAccess.getALSRangeRestrictionRightAccess().getFilterAssignment_1_2()); } | ||
5549 | ) | ||
5550 | |||
5551 | ; | ||
5552 | finally { | ||
5553 | restoreStackSize(stackSize); | ||
5554 | } | ||
5555 | |||
5556 | |||
5557 | |||
5558 | |||
5559 | |||
5560 | |||
5561 | |||
5562 | |||
5563 | rule__ALSRangeRestrictionLeft__Group__0 | ||
5564 | @init { | ||
5565 | int stackSize = keepStackSize(); | ||
5566 | } | ||
5567 | : | ||
5568 | rule__ALSRangeRestrictionLeft__Group__0__Impl | ||
5569 | rule__ALSRangeRestrictionLeft__Group__1 | ||
5570 | ; | ||
5571 | finally { | ||
5572 | restoreStackSize(stackSize); | ||
5573 | } | ||
5574 | |||
5575 | rule__ALSRangeRestrictionLeft__Group__0__Impl | ||
5576 | @init { | ||
5577 | int stackSize = keepStackSize(); | ||
5578 | } | ||
5579 | : | ||
5580 | ( | ||
5581 | { before(grammarAccess.getALSRangeRestrictionLeftAccess().getALSJoinParserRuleCall_0()); } | ||
5582 | ruleALSJoin | ||
5583 | { after(grammarAccess.getALSRangeRestrictionLeftAccess().getALSJoinParserRuleCall_0()); } | ||
5584 | ) | ||
5585 | |||
5586 | ; | ||
5587 | finally { | ||
5588 | restoreStackSize(stackSize); | ||
5589 | } | ||
5590 | |||
5591 | |||
5592 | rule__ALSRangeRestrictionLeft__Group__1 | ||
5593 | @init { | ||
5594 | int stackSize = keepStackSize(); | ||
5595 | } | ||
5596 | : | ||
5597 | rule__ALSRangeRestrictionLeft__Group__1__Impl | ||
5598 | ; | ||
5599 | finally { | ||
5600 | restoreStackSize(stackSize); | ||
5601 | } | ||
5602 | |||
5603 | rule__ALSRangeRestrictionLeft__Group__1__Impl | ||
5604 | @init { | ||
5605 | int stackSize = keepStackSize(); | ||
5606 | } | ||
5607 | : | ||
5608 | ( | ||
5609 | { before(grammarAccess.getALSRangeRestrictionLeftAccess().getGroup_1()); } | ||
5610 | (rule__ALSRangeRestrictionLeft__Group_1__0)? | ||
5611 | { after(grammarAccess.getALSRangeRestrictionLeftAccess().getGroup_1()); } | ||
5612 | ) | ||
5613 | |||
5614 | ; | ||
5615 | finally { | ||
5616 | restoreStackSize(stackSize); | ||
5617 | } | ||
5618 | |||
5619 | |||
5620 | |||
5621 | |||
5622 | |||
5623 | |||
5624 | rule__ALSRangeRestrictionLeft__Group_1__0 | ||
5625 | @init { | ||
5626 | int stackSize = keepStackSize(); | ||
5627 | } | ||
5628 | : | ||
5629 | rule__ALSRangeRestrictionLeft__Group_1__0__Impl | ||
5630 | rule__ALSRangeRestrictionLeft__Group_1__1 | ||
5631 | ; | ||
5632 | finally { | ||
5633 | restoreStackSize(stackSize); | ||
5634 | } | ||
5635 | |||
5636 | rule__ALSRangeRestrictionLeft__Group_1__0__Impl | ||
5637 | @init { | ||
5638 | int stackSize = keepStackSize(); | ||
5639 | } | ||
5640 | : | ||
5641 | ( | ||
5642 | { before(grammarAccess.getALSRangeRestrictionLeftAccess().getALSRangeRestrictionLeftFilterAction_1_0()); } | ||
5643 | ( | ||
5644 | |||
5645 | ) | ||
5646 | { after(grammarAccess.getALSRangeRestrictionLeftAccess().getALSRangeRestrictionLeftFilterAction_1_0()); } | ||
5647 | ) | ||
5648 | |||
5649 | ; | ||
5650 | finally { | ||
5651 | restoreStackSize(stackSize); | ||
5652 | } | ||
5653 | |||
5654 | |||
5655 | rule__ALSRangeRestrictionLeft__Group_1__1 | ||
5656 | @init { | ||
5657 | int stackSize = keepStackSize(); | ||
5658 | } | ||
5659 | : | ||
5660 | rule__ALSRangeRestrictionLeft__Group_1__1__Impl | ||
5661 | rule__ALSRangeRestrictionLeft__Group_1__2 | ||
5662 | ; | ||
5663 | finally { | ||
5664 | restoreStackSize(stackSize); | ||
5665 | } | ||
5666 | |||
5667 | rule__ALSRangeRestrictionLeft__Group_1__1__Impl | ||
5668 | @init { | ||
5669 | int stackSize = keepStackSize(); | ||
5670 | } | ||
5671 | : | ||
5672 | ( | ||
5673 | { before(grammarAccess.getALSRangeRestrictionLeftAccess().getLessThanSignColonKeyword_1_1()); } | ||
5674 | |||
5675 | '<:' | ||
5676 | |||
5677 | { after(grammarAccess.getALSRangeRestrictionLeftAccess().getLessThanSignColonKeyword_1_1()); } | ||
5678 | ) | ||
5679 | |||
5680 | ; | ||
5681 | finally { | ||
5682 | restoreStackSize(stackSize); | ||
5683 | } | ||
5684 | |||
5685 | |||
5686 | rule__ALSRangeRestrictionLeft__Group_1__2 | ||
5687 | @init { | ||
5688 | int stackSize = keepStackSize(); | ||
5689 | } | ||
5690 | : | ||
5691 | rule__ALSRangeRestrictionLeft__Group_1__2__Impl | ||
5692 | ; | ||
5693 | finally { | ||
5694 | restoreStackSize(stackSize); | ||
5695 | } | ||
5696 | |||
5697 | rule__ALSRangeRestrictionLeft__Group_1__2__Impl | ||
5698 | @init { | ||
5699 | int stackSize = keepStackSize(); | ||
5700 | } | ||
5701 | : | ||
5702 | ( | ||
5703 | { before(grammarAccess.getALSRangeRestrictionLeftAccess().getRelationAssignment_1_2()); } | ||
5704 | (rule__ALSRangeRestrictionLeft__RelationAssignment_1_2) | ||
5705 | { after(grammarAccess.getALSRangeRestrictionLeftAccess().getRelationAssignment_1_2()); } | ||
5706 | ) | ||
5707 | |||
5708 | ; | ||
5709 | finally { | ||
5710 | restoreStackSize(stackSize); | ||
5711 | } | ||
5712 | |||
5713 | |||
5714 | |||
5715 | |||
5716 | |||
5717 | |||
5718 | |||
5719 | |||
5720 | rule__ALSJoin__Group__0 | ||
5721 | @init { | ||
5722 | int stackSize = keepStackSize(); | ||
5723 | } | ||
5724 | : | ||
5725 | rule__ALSJoin__Group__0__Impl | ||
5726 | rule__ALSJoin__Group__1 | ||
5727 | ; | ||
5728 | finally { | ||
5729 | restoreStackSize(stackSize); | ||
5730 | } | ||
5731 | |||
5732 | rule__ALSJoin__Group__0__Impl | ||
5733 | @init { | ||
5734 | int stackSize = keepStackSize(); | ||
5735 | } | ||
5736 | : | ||
5737 | ( | ||
5738 | { before(grammarAccess.getALSJoinAccess().getALSMinusParserRuleCall_0()); } | ||
5739 | ruleALSMinus | ||
5740 | { after(grammarAccess.getALSJoinAccess().getALSMinusParserRuleCall_0()); } | ||
5741 | ) | ||
5742 | |||
5743 | ; | ||
5744 | finally { | ||
5745 | restoreStackSize(stackSize); | ||
5746 | } | ||
5747 | |||
5748 | |||
5749 | rule__ALSJoin__Group__1 | ||
5750 | @init { | ||
5751 | int stackSize = keepStackSize(); | ||
5752 | } | ||
5753 | : | ||
5754 | rule__ALSJoin__Group__1__Impl | ||
5755 | ; | ||
5756 | finally { | ||
5757 | restoreStackSize(stackSize); | ||
5758 | } | ||
5759 | |||
5760 | rule__ALSJoin__Group__1__Impl | ||
5761 | @init { | ||
5762 | int stackSize = keepStackSize(); | ||
5763 | } | ||
5764 | : | ||
5765 | ( | ||
5766 | { before(grammarAccess.getALSJoinAccess().getGroup_1()); } | ||
5767 | (rule__ALSJoin__Group_1__0)* | ||
5768 | { after(grammarAccess.getALSJoinAccess().getGroup_1()); } | ||
5769 | ) | ||
5770 | |||
5771 | ; | ||
5772 | finally { | ||
5773 | restoreStackSize(stackSize); | ||
5774 | } | ||
5775 | |||
5776 | |||
5777 | |||
5778 | |||
5779 | |||
5780 | |||
5781 | rule__ALSJoin__Group_1__0 | ||
5782 | @init { | ||
5783 | int stackSize = keepStackSize(); | ||
5784 | } | ||
5785 | : | ||
5786 | rule__ALSJoin__Group_1__0__Impl | ||
5787 | rule__ALSJoin__Group_1__1 | ||
5788 | ; | ||
5789 | finally { | ||
5790 | restoreStackSize(stackSize); | ||
5791 | } | ||
5792 | |||
5793 | rule__ALSJoin__Group_1__0__Impl | ||
5794 | @init { | ||
5795 | int stackSize = keepStackSize(); | ||
5796 | } | ||
5797 | : | ||
5798 | ( | ||
5799 | { before(grammarAccess.getALSJoinAccess().getALSJoinLeftOperandAction_1_0()); } | ||
5800 | ( | ||
5801 | |||
5802 | ) | ||
5803 | { after(grammarAccess.getALSJoinAccess().getALSJoinLeftOperandAction_1_0()); } | ||
5804 | ) | ||
5805 | |||
5806 | ; | ||
5807 | finally { | ||
5808 | restoreStackSize(stackSize); | ||
5809 | } | ||
5810 | |||
5811 | |||
5812 | rule__ALSJoin__Group_1__1 | ||
5813 | @init { | ||
5814 | int stackSize = keepStackSize(); | ||
5815 | } | ||
5816 | : | ||
5817 | rule__ALSJoin__Group_1__1__Impl | ||
5818 | rule__ALSJoin__Group_1__2 | ||
5819 | ; | ||
5820 | finally { | ||
5821 | restoreStackSize(stackSize); | ||
5822 | } | ||
5823 | |||
5824 | rule__ALSJoin__Group_1__1__Impl | ||
5825 | @init { | ||
5826 | int stackSize = keepStackSize(); | ||
5827 | } | ||
5828 | : | ||
5829 | ( | ||
5830 | { before(grammarAccess.getALSJoinAccess().getFullStopKeyword_1_1()); } | ||
5831 | |||
5832 | '.' | ||
5833 | |||
5834 | { after(grammarAccess.getALSJoinAccess().getFullStopKeyword_1_1()); } | ||
5835 | ) | ||
5836 | |||
5837 | ; | ||
5838 | finally { | ||
5839 | restoreStackSize(stackSize); | ||
5840 | } | ||
5841 | |||
5842 | |||
5843 | rule__ALSJoin__Group_1__2 | ||
5844 | @init { | ||
5845 | int stackSize = keepStackSize(); | ||
5846 | } | ||
5847 | : | ||
5848 | rule__ALSJoin__Group_1__2__Impl | ||
5849 | ; | ||
5850 | finally { | ||
5851 | restoreStackSize(stackSize); | ||
5852 | } | ||
5853 | |||
5854 | rule__ALSJoin__Group_1__2__Impl | ||
5855 | @init { | ||
5856 | int stackSize = keepStackSize(); | ||
5857 | } | ||
5858 | : | ||
5859 | ( | ||
5860 | { before(grammarAccess.getALSJoinAccess().getRightOperandAssignment_1_2()); } | ||
5861 | (rule__ALSJoin__RightOperandAssignment_1_2) | ||
5862 | { after(grammarAccess.getALSJoinAccess().getRightOperandAssignment_1_2()); } | ||
5863 | ) | ||
5864 | |||
5865 | ; | ||
5866 | finally { | ||
5867 | restoreStackSize(stackSize); | ||
5868 | } | ||
5869 | |||
5870 | |||
5871 | |||
5872 | |||
5873 | |||
5874 | |||
5875 | |||
5876 | |||
5877 | rule__ALSMinus__Group__0 | ||
5878 | @init { | ||
5879 | int stackSize = keepStackSize(); | ||
5880 | } | ||
5881 | : | ||
5882 | rule__ALSMinus__Group__0__Impl | ||
5883 | rule__ALSMinus__Group__1 | ||
5884 | ; | ||
5885 | finally { | ||
5886 | restoreStackSize(stackSize); | ||
5887 | } | ||
5888 | |||
5889 | rule__ALSMinus__Group__0__Impl | ||
5890 | @init { | ||
5891 | int stackSize = keepStackSize(); | ||
5892 | } | ||
5893 | : | ||
5894 | ( | ||
5895 | { before(grammarAccess.getALSMinusAccess().getALSPlusParserRuleCall_0()); } | ||
5896 | ruleALSPlus | ||
5897 | { after(grammarAccess.getALSMinusAccess().getALSPlusParserRuleCall_0()); } | ||
5898 | ) | ||
5899 | |||
5900 | ; | ||
5901 | finally { | ||
5902 | restoreStackSize(stackSize); | ||
5903 | } | ||
5904 | |||
5905 | |||
5906 | rule__ALSMinus__Group__1 | ||
5907 | @init { | ||
5908 | int stackSize = keepStackSize(); | ||
5909 | } | ||
5910 | : | ||
5911 | rule__ALSMinus__Group__1__Impl | ||
5912 | ; | ||
5913 | finally { | ||
5914 | restoreStackSize(stackSize); | ||
5915 | } | ||
5916 | |||
5917 | rule__ALSMinus__Group__1__Impl | ||
5918 | @init { | ||
5919 | int stackSize = keepStackSize(); | ||
5920 | } | ||
5921 | : | ||
5922 | ( | ||
5923 | { before(grammarAccess.getALSMinusAccess().getGroup_1()); } | ||
5924 | (rule__ALSMinus__Group_1__0)* | ||
5925 | { after(grammarAccess.getALSMinusAccess().getGroup_1()); } | ||
5926 | ) | ||
5927 | |||
5928 | ; | ||
5929 | finally { | ||
5930 | restoreStackSize(stackSize); | ||
5931 | } | ||
5932 | |||
5933 | |||
5934 | |||
5935 | |||
5936 | |||
5937 | |||
5938 | rule__ALSMinus__Group_1__0 | ||
5939 | @init { | ||
5940 | int stackSize = keepStackSize(); | ||
5941 | } | ||
5942 | : | ||
5943 | rule__ALSMinus__Group_1__0__Impl | ||
5944 | rule__ALSMinus__Group_1__1 | ||
5945 | ; | ||
5946 | finally { | ||
5947 | restoreStackSize(stackSize); | ||
5948 | } | ||
5949 | |||
5950 | rule__ALSMinus__Group_1__0__Impl | ||
5951 | @init { | ||
5952 | int stackSize = keepStackSize(); | ||
5953 | } | ||
5954 | : | ||
5955 | ( | ||
5956 | { before(grammarAccess.getALSMinusAccess().getALSMinusLeftOperandAction_1_0()); } | ||
5957 | ( | ||
5958 | |||
5959 | ) | ||
5960 | { after(grammarAccess.getALSMinusAccess().getALSMinusLeftOperandAction_1_0()); } | ||
5961 | ) | ||
5962 | |||
5963 | ; | ||
5964 | finally { | ||
5965 | restoreStackSize(stackSize); | ||
5966 | } | ||
5967 | |||
5968 | |||
5969 | rule__ALSMinus__Group_1__1 | ||
5970 | @init { | ||
5971 | int stackSize = keepStackSize(); | ||
5972 | } | ||
5973 | : | ||
5974 | rule__ALSMinus__Group_1__1__Impl | ||
5975 | rule__ALSMinus__Group_1__2 | ||
5976 | ; | ||
5977 | finally { | ||
5978 | restoreStackSize(stackSize); | ||
5979 | } | ||
5980 | |||
5981 | rule__ALSMinus__Group_1__1__Impl | ||
5982 | @init { | ||
5983 | int stackSize = keepStackSize(); | ||
5984 | } | ||
5985 | : | ||
5986 | ( | ||
5987 | { before(grammarAccess.getALSMinusAccess().getHyphenMinusKeyword_1_1()); } | ||
5988 | |||
5989 | '-' | ||
5990 | |||
5991 | { after(grammarAccess.getALSMinusAccess().getHyphenMinusKeyword_1_1()); } | ||
5992 | ) | ||
5993 | |||
5994 | ; | ||
5995 | finally { | ||
5996 | restoreStackSize(stackSize); | ||
5997 | } | ||
5998 | |||
5999 | |||
6000 | rule__ALSMinus__Group_1__2 | ||
6001 | @init { | ||
6002 | int stackSize = keepStackSize(); | ||
6003 | } | ||
6004 | : | ||
6005 | rule__ALSMinus__Group_1__2__Impl | ||
6006 | ; | ||
6007 | finally { | ||
6008 | restoreStackSize(stackSize); | ||
6009 | } | ||
6010 | |||
6011 | rule__ALSMinus__Group_1__2__Impl | ||
6012 | @init { | ||
6013 | int stackSize = keepStackSize(); | ||
6014 | } | ||
6015 | : | ||
6016 | ( | ||
6017 | { before(grammarAccess.getALSMinusAccess().getRightOperandAssignment_1_2()); } | ||
6018 | (rule__ALSMinus__RightOperandAssignment_1_2) | ||
6019 | { after(grammarAccess.getALSMinusAccess().getRightOperandAssignment_1_2()); } | ||
6020 | ) | ||
6021 | |||
6022 | ; | ||
6023 | finally { | ||
6024 | restoreStackSize(stackSize); | ||
6025 | } | ||
6026 | |||
6027 | |||
6028 | |||
6029 | |||
6030 | |||
6031 | |||
6032 | |||
6033 | |||
6034 | rule__ALSPlus__Group__0 | ||
6035 | @init { | ||
6036 | int stackSize = keepStackSize(); | ||
6037 | } | ||
6038 | : | ||
6039 | rule__ALSPlus__Group__0__Impl | ||
6040 | rule__ALSPlus__Group__1 | ||
6041 | ; | ||
6042 | finally { | ||
6043 | restoreStackSize(stackSize); | ||
6044 | } | ||
6045 | |||
6046 | rule__ALSPlus__Group__0__Impl | ||
6047 | @init { | ||
6048 | int stackSize = keepStackSize(); | ||
6049 | } | ||
6050 | : | ||
6051 | ( | ||
6052 | { before(grammarAccess.getALSPlusAccess().getALSIntersectionParserRuleCall_0()); } | ||
6053 | ruleALSIntersection | ||
6054 | { after(grammarAccess.getALSPlusAccess().getALSIntersectionParserRuleCall_0()); } | ||
6055 | ) | ||
6056 | |||
6057 | ; | ||
6058 | finally { | ||
6059 | restoreStackSize(stackSize); | ||
6060 | } | ||
6061 | |||
6062 | |||
6063 | rule__ALSPlus__Group__1 | ||
6064 | @init { | ||
6065 | int stackSize = keepStackSize(); | ||
6066 | } | ||
6067 | : | ||
6068 | rule__ALSPlus__Group__1__Impl | ||
6069 | ; | ||
6070 | finally { | ||
6071 | restoreStackSize(stackSize); | ||
6072 | } | ||
6073 | |||
6074 | rule__ALSPlus__Group__1__Impl | ||
6075 | @init { | ||
6076 | int stackSize = keepStackSize(); | ||
6077 | } | ||
6078 | : | ||
6079 | ( | ||
6080 | { before(grammarAccess.getALSPlusAccess().getGroup_1()); } | ||
6081 | (rule__ALSPlus__Group_1__0)* | ||
6082 | { after(grammarAccess.getALSPlusAccess().getGroup_1()); } | ||
6083 | ) | ||
6084 | |||
6085 | ; | ||
6086 | finally { | ||
6087 | restoreStackSize(stackSize); | ||
6088 | } | ||
6089 | |||
6090 | |||
6091 | |||
6092 | |||
6093 | |||
6094 | |||
6095 | rule__ALSPlus__Group_1__0 | ||
6096 | @init { | ||
6097 | int stackSize = keepStackSize(); | ||
6098 | } | ||
6099 | : | ||
6100 | rule__ALSPlus__Group_1__0__Impl | ||
6101 | rule__ALSPlus__Group_1__1 | ||
6102 | ; | ||
6103 | finally { | ||
6104 | restoreStackSize(stackSize); | ||
6105 | } | ||
6106 | |||
6107 | rule__ALSPlus__Group_1__0__Impl | ||
6108 | @init { | ||
6109 | int stackSize = keepStackSize(); | ||
6110 | } | ||
6111 | : | ||
6112 | ( | ||
6113 | { before(grammarAccess.getALSPlusAccess().getALSPlusLeftOperandAction_1_0()); } | ||
6114 | ( | ||
6115 | |||
6116 | ) | ||
6117 | { after(grammarAccess.getALSPlusAccess().getALSPlusLeftOperandAction_1_0()); } | ||
6118 | ) | ||
6119 | |||
6120 | ; | ||
6121 | finally { | ||
6122 | restoreStackSize(stackSize); | ||
6123 | } | ||
6124 | |||
6125 | |||
6126 | rule__ALSPlus__Group_1__1 | ||
6127 | @init { | ||
6128 | int stackSize = keepStackSize(); | ||
6129 | } | ||
6130 | : | ||
6131 | rule__ALSPlus__Group_1__1__Impl | ||
6132 | rule__ALSPlus__Group_1__2 | ||
6133 | ; | ||
6134 | finally { | ||
6135 | restoreStackSize(stackSize); | ||
6136 | } | ||
6137 | |||
6138 | rule__ALSPlus__Group_1__1__Impl | ||
6139 | @init { | ||
6140 | int stackSize = keepStackSize(); | ||
6141 | } | ||
6142 | : | ||
6143 | ( | ||
6144 | { before(grammarAccess.getALSPlusAccess().getPlusSignKeyword_1_1()); } | ||
6145 | |||
6146 | '+' | ||
6147 | |||
6148 | { after(grammarAccess.getALSPlusAccess().getPlusSignKeyword_1_1()); } | ||
6149 | ) | ||
6150 | |||
6151 | ; | ||
6152 | finally { | ||
6153 | restoreStackSize(stackSize); | ||
6154 | } | ||
6155 | |||
6156 | |||
6157 | rule__ALSPlus__Group_1__2 | ||
6158 | @init { | ||
6159 | int stackSize = keepStackSize(); | ||
6160 | } | ||
6161 | : | ||
6162 | rule__ALSPlus__Group_1__2__Impl | ||
6163 | ; | ||
6164 | finally { | ||
6165 | restoreStackSize(stackSize); | ||
6166 | } | ||
6167 | |||
6168 | rule__ALSPlus__Group_1__2__Impl | ||
6169 | @init { | ||
6170 | int stackSize = keepStackSize(); | ||
6171 | } | ||
6172 | : | ||
6173 | ( | ||
6174 | { before(grammarAccess.getALSPlusAccess().getRightOperandAssignment_1_2()); } | ||
6175 | (rule__ALSPlus__RightOperandAssignment_1_2) | ||
6176 | { after(grammarAccess.getALSPlusAccess().getRightOperandAssignment_1_2()); } | ||
6177 | ) | ||
6178 | |||
6179 | ; | ||
6180 | finally { | ||
6181 | restoreStackSize(stackSize); | ||
6182 | } | ||
6183 | |||
6184 | |||
6185 | |||
6186 | |||
6187 | |||
6188 | |||
6189 | |||
6190 | |||
6191 | rule__ALSIntersection__Group__0 | ||
6192 | @init { | ||
6193 | int stackSize = keepStackSize(); | ||
6194 | } | ||
6195 | : | ||
6196 | rule__ALSIntersection__Group__0__Impl | ||
6197 | rule__ALSIntersection__Group__1 | ||
6198 | ; | ||
6199 | finally { | ||
6200 | restoreStackSize(stackSize); | ||
6201 | } | ||
6202 | |||
6203 | rule__ALSIntersection__Group__0__Impl | ||
6204 | @init { | ||
6205 | int stackSize = keepStackSize(); | ||
6206 | } | ||
6207 | : | ||
6208 | ( | ||
6209 | { before(grammarAccess.getALSIntersectionAccess().getALSDirectProductParserRuleCall_0()); } | ||
6210 | ruleALSDirectProduct | ||
6211 | { after(grammarAccess.getALSIntersectionAccess().getALSDirectProductParserRuleCall_0()); } | ||
6212 | ) | ||
6213 | |||
6214 | ; | ||
6215 | finally { | ||
6216 | restoreStackSize(stackSize); | ||
6217 | } | ||
6218 | |||
6219 | |||
6220 | rule__ALSIntersection__Group__1 | ||
6221 | @init { | ||
6222 | int stackSize = keepStackSize(); | ||
6223 | } | ||
6224 | : | ||
6225 | rule__ALSIntersection__Group__1__Impl | ||
6226 | ; | ||
6227 | finally { | ||
6228 | restoreStackSize(stackSize); | ||
6229 | } | ||
6230 | |||
6231 | rule__ALSIntersection__Group__1__Impl | ||
6232 | @init { | ||
6233 | int stackSize = keepStackSize(); | ||
6234 | } | ||
6235 | : | ||
6236 | ( | ||
6237 | { before(grammarAccess.getALSIntersectionAccess().getGroup_1()); } | ||
6238 | (rule__ALSIntersection__Group_1__0)* | ||
6239 | { after(grammarAccess.getALSIntersectionAccess().getGroup_1()); } | ||
6240 | ) | ||
6241 | |||
6242 | ; | ||
6243 | finally { | ||
6244 | restoreStackSize(stackSize); | ||
6245 | } | ||
6246 | |||
6247 | |||
6248 | |||
6249 | |||
6250 | |||
6251 | |||
6252 | rule__ALSIntersection__Group_1__0 | ||
6253 | @init { | ||
6254 | int stackSize = keepStackSize(); | ||
6255 | } | ||
6256 | : | ||
6257 | rule__ALSIntersection__Group_1__0__Impl | ||
6258 | rule__ALSIntersection__Group_1__1 | ||
6259 | ; | ||
6260 | finally { | ||
6261 | restoreStackSize(stackSize); | ||
6262 | } | ||
6263 | |||
6264 | rule__ALSIntersection__Group_1__0__Impl | ||
6265 | @init { | ||
6266 | int stackSize = keepStackSize(); | ||
6267 | } | ||
6268 | : | ||
6269 | ( | ||
6270 | { before(grammarAccess.getALSIntersectionAccess().getALSIntersectionLeftOperandAction_1_0()); } | ||
6271 | ( | ||
6272 | |||
6273 | ) | ||
6274 | { after(grammarAccess.getALSIntersectionAccess().getALSIntersectionLeftOperandAction_1_0()); } | ||
6275 | ) | ||
6276 | |||
6277 | ; | ||
6278 | finally { | ||
6279 | restoreStackSize(stackSize); | ||
6280 | } | ||
6281 | |||
6282 | |||
6283 | rule__ALSIntersection__Group_1__1 | ||
6284 | @init { | ||
6285 | int stackSize = keepStackSize(); | ||
6286 | } | ||
6287 | : | ||
6288 | rule__ALSIntersection__Group_1__1__Impl | ||
6289 | rule__ALSIntersection__Group_1__2 | ||
6290 | ; | ||
6291 | finally { | ||
6292 | restoreStackSize(stackSize); | ||
6293 | } | ||
6294 | |||
6295 | rule__ALSIntersection__Group_1__1__Impl | ||
6296 | @init { | ||
6297 | int stackSize = keepStackSize(); | ||
6298 | } | ||
6299 | : | ||
6300 | ( | ||
6301 | { before(grammarAccess.getALSIntersectionAccess().getAmpersandKeyword_1_1()); } | ||
6302 | |||
6303 | '&' | ||
6304 | |||
6305 | { after(grammarAccess.getALSIntersectionAccess().getAmpersandKeyword_1_1()); } | ||
6306 | ) | ||
6307 | |||
6308 | ; | ||
6309 | finally { | ||
6310 | restoreStackSize(stackSize); | ||
6311 | } | ||
6312 | |||
6313 | |||
6314 | rule__ALSIntersection__Group_1__2 | ||
6315 | @init { | ||
6316 | int stackSize = keepStackSize(); | ||
6317 | } | ||
6318 | : | ||
6319 | rule__ALSIntersection__Group_1__2__Impl | ||
6320 | ; | ||
6321 | finally { | ||
6322 | restoreStackSize(stackSize); | ||
6323 | } | ||
6324 | |||
6325 | rule__ALSIntersection__Group_1__2__Impl | ||
6326 | @init { | ||
6327 | int stackSize = keepStackSize(); | ||
6328 | } | ||
6329 | : | ||
6330 | ( | ||
6331 | { before(grammarAccess.getALSIntersectionAccess().getRightOperandAssignment_1_2()); } | ||
6332 | (rule__ALSIntersection__RightOperandAssignment_1_2) | ||
6333 | { after(grammarAccess.getALSIntersectionAccess().getRightOperandAssignment_1_2()); } | ||
6334 | ) | ||
6335 | |||
6336 | ; | ||
6337 | finally { | ||
6338 | restoreStackSize(stackSize); | ||
6339 | } | ||
6340 | |||
6341 | |||
6342 | |||
6343 | |||
6344 | |||
6345 | |||
6346 | |||
6347 | |||
6348 | rule__ALSDirectProduct__Group__0 | ||
6349 | @init { | ||
6350 | int stackSize = keepStackSize(); | ||
6351 | } | ||
6352 | : | ||
6353 | rule__ALSDirectProduct__Group__0__Impl | ||
6354 | rule__ALSDirectProduct__Group__1 | ||
6355 | ; | ||
6356 | finally { | ||
6357 | restoreStackSize(stackSize); | ||
6358 | } | ||
6359 | |||
6360 | rule__ALSDirectProduct__Group__0__Impl | ||
6361 | @init { | ||
6362 | int stackSize = keepStackSize(); | ||
6363 | } | ||
6364 | : | ||
6365 | ( | ||
6366 | { before(grammarAccess.getALSDirectProductAccess().getALSPreficedParserRuleCall_0()); } | ||
6367 | ruleALSPreficed | ||
6368 | { after(grammarAccess.getALSDirectProductAccess().getALSPreficedParserRuleCall_0()); } | ||
6369 | ) | ||
6370 | |||
6371 | ; | ||
6372 | finally { | ||
6373 | restoreStackSize(stackSize); | ||
6374 | } | ||
6375 | |||
6376 | |||
6377 | rule__ALSDirectProduct__Group__1 | ||
6378 | @init { | ||
6379 | int stackSize = keepStackSize(); | ||
6380 | } | ||
6381 | : | ||
6382 | rule__ALSDirectProduct__Group__1__Impl | ||
6383 | ; | ||
6384 | finally { | ||
6385 | restoreStackSize(stackSize); | ||
6386 | } | ||
6387 | |||
6388 | rule__ALSDirectProduct__Group__1__Impl | ||
6389 | @init { | ||
6390 | int stackSize = keepStackSize(); | ||
6391 | } | ||
6392 | : | ||
6393 | ( | ||
6394 | { before(grammarAccess.getALSDirectProductAccess().getGroup_1()); } | ||
6395 | (rule__ALSDirectProduct__Group_1__0)? | ||
6396 | { after(grammarAccess.getALSDirectProductAccess().getGroup_1()); } | ||
6397 | ) | ||
6398 | |||
6399 | ; | ||
6400 | finally { | ||
6401 | restoreStackSize(stackSize); | ||
6402 | } | ||
6403 | |||
6404 | |||
6405 | |||
6406 | |||
6407 | |||
6408 | |||
6409 | rule__ALSDirectProduct__Group_1__0 | ||
6410 | @init { | ||
6411 | int stackSize = keepStackSize(); | ||
6412 | } | ||
6413 | : | ||
6414 | rule__ALSDirectProduct__Group_1__0__Impl | ||
6415 | rule__ALSDirectProduct__Group_1__1 | ||
6416 | ; | ||
6417 | finally { | ||
6418 | restoreStackSize(stackSize); | ||
6419 | } | ||
6420 | |||
6421 | rule__ALSDirectProduct__Group_1__0__Impl | ||
6422 | @init { | ||
6423 | int stackSize = keepStackSize(); | ||
6424 | } | ||
6425 | : | ||
6426 | ( | ||
6427 | { before(grammarAccess.getALSDirectProductAccess().getALSDirectProductLeftOperandAction_1_0()); } | ||
6428 | ( | ||
6429 | |||
6430 | ) | ||
6431 | { after(grammarAccess.getALSDirectProductAccess().getALSDirectProductLeftOperandAction_1_0()); } | ||
6432 | ) | ||
6433 | |||
6434 | ; | ||
6435 | finally { | ||
6436 | restoreStackSize(stackSize); | ||
6437 | } | ||
6438 | |||
6439 | |||
6440 | rule__ALSDirectProduct__Group_1__1 | ||
6441 | @init { | ||
6442 | int stackSize = keepStackSize(); | ||
6443 | } | ||
6444 | : | ||
6445 | rule__ALSDirectProduct__Group_1__1__Impl | ||
6446 | rule__ALSDirectProduct__Group_1__2 | ||
6447 | ; | ||
6448 | finally { | ||
6449 | restoreStackSize(stackSize); | ||
6450 | } | ||
6451 | |||
6452 | rule__ALSDirectProduct__Group_1__1__Impl | ||
6453 | @init { | ||
6454 | int stackSize = keepStackSize(); | ||
6455 | } | ||
6456 | : | ||
6457 | ( | ||
6458 | { before(grammarAccess.getALSDirectProductAccess().getLeftMultiplicitAssignment_1_1()); } | ||
6459 | (rule__ALSDirectProduct__LeftMultiplicitAssignment_1_1)? | ||
6460 | { after(grammarAccess.getALSDirectProductAccess().getLeftMultiplicitAssignment_1_1()); } | ||
6461 | ) | ||
6462 | |||
6463 | ; | ||
6464 | finally { | ||
6465 | restoreStackSize(stackSize); | ||
6466 | } | ||
6467 | |||
6468 | |||
6469 | rule__ALSDirectProduct__Group_1__2 | ||
6470 | @init { | ||
6471 | int stackSize = keepStackSize(); | ||
6472 | } | ||
6473 | : | ||
6474 | rule__ALSDirectProduct__Group_1__2__Impl | ||
6475 | rule__ALSDirectProduct__Group_1__3 | ||
6476 | ; | ||
6477 | finally { | ||
6478 | restoreStackSize(stackSize); | ||
6479 | } | ||
6480 | |||
6481 | rule__ALSDirectProduct__Group_1__2__Impl | ||
6482 | @init { | ||
6483 | int stackSize = keepStackSize(); | ||
6484 | } | ||
6485 | : | ||
6486 | ( | ||
6487 | { before(grammarAccess.getALSDirectProductAccess().getHyphenMinusGreaterThanSignKeyword_1_2()); } | ||
6488 | |||
6489 | '->' | ||
6490 | |||
6491 | { after(grammarAccess.getALSDirectProductAccess().getHyphenMinusGreaterThanSignKeyword_1_2()); } | ||
6492 | ) | ||
6493 | |||
6494 | ; | ||
6495 | finally { | ||
6496 | restoreStackSize(stackSize); | ||
6497 | } | ||
6498 | |||
6499 | |||
6500 | rule__ALSDirectProduct__Group_1__3 | ||
6501 | @init { | ||
6502 | int stackSize = keepStackSize(); | ||
6503 | } | ||
6504 | : | ||
6505 | rule__ALSDirectProduct__Group_1__3__Impl | ||
6506 | rule__ALSDirectProduct__Group_1__4 | ||
6507 | ; | ||
6508 | finally { | ||
6509 | restoreStackSize(stackSize); | ||
6510 | } | ||
6511 | |||
6512 | rule__ALSDirectProduct__Group_1__3__Impl | ||
6513 | @init { | ||
6514 | int stackSize = keepStackSize(); | ||
6515 | } | ||
6516 | : | ||
6517 | ( | ||
6518 | { before(grammarAccess.getALSDirectProductAccess().getRightMultiplicitAssignment_1_3()); } | ||
6519 | (rule__ALSDirectProduct__RightMultiplicitAssignment_1_3)? | ||
6520 | { after(grammarAccess.getALSDirectProductAccess().getRightMultiplicitAssignment_1_3()); } | ||
6521 | ) | ||
6522 | |||
6523 | ; | ||
6524 | finally { | ||
6525 | restoreStackSize(stackSize); | ||
6526 | } | ||
6527 | |||
6528 | |||
6529 | rule__ALSDirectProduct__Group_1__4 | ||
6530 | @init { | ||
6531 | int stackSize = keepStackSize(); | ||
6532 | } | ||
6533 | : | ||
6534 | rule__ALSDirectProduct__Group_1__4__Impl | ||
6535 | ; | ||
6536 | finally { | ||
6537 | restoreStackSize(stackSize); | ||
6538 | } | ||
6539 | |||
6540 | rule__ALSDirectProduct__Group_1__4__Impl | ||
6541 | @init { | ||
6542 | int stackSize = keepStackSize(); | ||
6543 | } | ||
6544 | : | ||
6545 | ( | ||
6546 | { before(grammarAccess.getALSDirectProductAccess().getRightOperandAssignment_1_4()); } | ||
6547 | (rule__ALSDirectProduct__RightOperandAssignment_1_4) | ||
6548 | { after(grammarAccess.getALSDirectProductAccess().getRightOperandAssignment_1_4()); } | ||
6549 | ) | ||
6550 | |||
6551 | ; | ||
6552 | finally { | ||
6553 | restoreStackSize(stackSize); | ||
6554 | } | ||
6555 | |||
6556 | |||
6557 | |||
6558 | |||
6559 | |||
6560 | |||
6561 | |||
6562 | |||
6563 | |||
6564 | |||
6565 | |||
6566 | |||
6567 | rule__ALSPreficed__Group_0__0 | ||
6568 | @init { | ||
6569 | int stackSize = keepStackSize(); | ||
6570 | } | ||
6571 | : | ||
6572 | rule__ALSPreficed__Group_0__0__Impl | ||
6573 | rule__ALSPreficed__Group_0__1 | ||
6574 | ; | ||
6575 | finally { | ||
6576 | restoreStackSize(stackSize); | ||
6577 | } | ||
6578 | |||
6579 | rule__ALSPreficed__Group_0__0__Impl | ||
6580 | @init { | ||
6581 | int stackSize = keepStackSize(); | ||
6582 | } | ||
6583 | : | ||
6584 | ( | ||
6585 | { before(grammarAccess.getALSPreficedAccess().getALSNotAction_0_0()); } | ||
6586 | ( | ||
6587 | |||
6588 | ) | ||
6589 | { after(grammarAccess.getALSPreficedAccess().getALSNotAction_0_0()); } | ||
6590 | ) | ||
6591 | |||
6592 | ; | ||
6593 | finally { | ||
6594 | restoreStackSize(stackSize); | ||
6595 | } | ||
6596 | |||
6597 | |||
6598 | rule__ALSPreficed__Group_0__1 | ||
6599 | @init { | ||
6600 | int stackSize = keepStackSize(); | ||
6601 | } | ||
6602 | : | ||
6603 | rule__ALSPreficed__Group_0__1__Impl | ||
6604 | rule__ALSPreficed__Group_0__2 | ||
6605 | ; | ||
6606 | finally { | ||
6607 | restoreStackSize(stackSize); | ||
6608 | } | ||
6609 | |||
6610 | rule__ALSPreficed__Group_0__1__Impl | ||
6611 | @init { | ||
6612 | int stackSize = keepStackSize(); | ||
6613 | } | ||
6614 | : | ||
6615 | ( | ||
6616 | { before(grammarAccess.getALSPreficedAccess().getGroup_0_1()); } | ||
6617 | (rule__ALSPreficed__Group_0_1__0) | ||
6618 | { after(grammarAccess.getALSPreficedAccess().getGroup_0_1()); } | ||
6619 | ) | ||
6620 | |||
6621 | ; | ||
6622 | finally { | ||
6623 | restoreStackSize(stackSize); | ||
6624 | } | ||
6625 | |||
6626 | |||
6627 | rule__ALSPreficed__Group_0__2 | ||
6628 | @init { | ||
6629 | int stackSize = keepStackSize(); | ||
6630 | } | ||
6631 | : | ||
6632 | rule__ALSPreficed__Group_0__2__Impl | ||
6633 | ; | ||
6634 | finally { | ||
6635 | restoreStackSize(stackSize); | ||
6636 | } | ||
6637 | |||
6638 | rule__ALSPreficed__Group_0__2__Impl | ||
6639 | @init { | ||
6640 | int stackSize = keepStackSize(); | ||
6641 | } | ||
6642 | : | ||
6643 | ( | ||
6644 | { before(grammarAccess.getALSPreficedAccess().getOperandAssignment_0_2()); } | ||
6645 | (rule__ALSPreficed__OperandAssignment_0_2) | ||
6646 | { after(grammarAccess.getALSPreficedAccess().getOperandAssignment_0_2()); } | ||
6647 | ) | ||
6648 | |||
6649 | ; | ||
6650 | finally { | ||
6651 | restoreStackSize(stackSize); | ||
6652 | } | ||
6653 | |||
6654 | |||
6655 | |||
6656 | |||
6657 | |||
6658 | |||
6659 | |||
6660 | |||
6661 | rule__ALSPreficed__Group_0_1__0 | ||
6662 | @init { | ||
6663 | int stackSize = keepStackSize(); | ||
6664 | } | ||
6665 | : | ||
6666 | rule__ALSPreficed__Group_0_1__0__Impl | ||
6667 | ; | ||
6668 | finally { | ||
6669 | restoreStackSize(stackSize); | ||
6670 | } | ||
6671 | |||
6672 | rule__ALSPreficed__Group_0_1__0__Impl | ||
6673 | @init { | ||
6674 | int stackSize = keepStackSize(); | ||
6675 | } | ||
6676 | : | ||
6677 | ( | ||
6678 | { before(grammarAccess.getALSPreficedAccess().getAlternatives_0_1_0()); } | ||
6679 | (rule__ALSPreficed__Alternatives_0_1_0) | ||
6680 | { after(grammarAccess.getALSPreficedAccess().getAlternatives_0_1_0()); } | ||
6681 | ) | ||
6682 | |||
6683 | ; | ||
6684 | finally { | ||
6685 | restoreStackSize(stackSize); | ||
6686 | } | ||
6687 | |||
6688 | |||
6689 | |||
6690 | |||
6691 | rule__ALSPreficed__Group_1__0 | ||
6692 | @init { | ||
6693 | int stackSize = keepStackSize(); | ||
6694 | } | ||
6695 | : | ||
6696 | rule__ALSPreficed__Group_1__0__Impl | ||
6697 | rule__ALSPreficed__Group_1__1 | ||
6698 | ; | ||
6699 | finally { | ||
6700 | restoreStackSize(stackSize); | ||
6701 | } | ||
6702 | |||
6703 | rule__ALSPreficed__Group_1__0__Impl | ||
6704 | @init { | ||
6705 | int stackSize = keepStackSize(); | ||
6706 | } | ||
6707 | : | ||
6708 | ( | ||
6709 | { before(grammarAccess.getALSPreficedAccess().getALSInverseRelationAction_1_0()); } | ||
6710 | ( | ||
6711 | |||
6712 | ) | ||
6713 | { after(grammarAccess.getALSPreficedAccess().getALSInverseRelationAction_1_0()); } | ||
6714 | ) | ||
6715 | |||
6716 | ; | ||
6717 | finally { | ||
6718 | restoreStackSize(stackSize); | ||
6719 | } | ||
6720 | |||
6721 | |||
6722 | rule__ALSPreficed__Group_1__1 | ||
6723 | @init { | ||
6724 | int stackSize = keepStackSize(); | ||
6725 | } | ||
6726 | : | ||
6727 | rule__ALSPreficed__Group_1__1__Impl | ||
6728 | rule__ALSPreficed__Group_1__2 | ||
6729 | ; | ||
6730 | finally { | ||
6731 | restoreStackSize(stackSize); | ||
6732 | } | ||
6733 | |||
6734 | rule__ALSPreficed__Group_1__1__Impl | ||
6735 | @init { | ||
6736 | int stackSize = keepStackSize(); | ||
6737 | } | ||
6738 | : | ||
6739 | ( | ||
6740 | { before(grammarAccess.getALSPreficedAccess().getTildeKeyword_1_1()); } | ||
6741 | ( | ||
6742 | '~' | ||
6743 | ) | ||
6744 | { after(grammarAccess.getALSPreficedAccess().getTildeKeyword_1_1()); } | ||
6745 | ) | ||
6746 | |||
6747 | ; | ||
6748 | finally { | ||
6749 | restoreStackSize(stackSize); | ||
6750 | } | ||
6751 | |||
6752 | |||
6753 | rule__ALSPreficed__Group_1__2 | ||
6754 | @init { | ||
6755 | int stackSize = keepStackSize(); | ||
6756 | } | ||
6757 | : | ||
6758 | rule__ALSPreficed__Group_1__2__Impl | ||
6759 | ; | ||
6760 | finally { | ||
6761 | restoreStackSize(stackSize); | ||
6762 | } | ||
6763 | |||
6764 | rule__ALSPreficed__Group_1__2__Impl | ||
6765 | @init { | ||
6766 | int stackSize = keepStackSize(); | ||
6767 | } | ||
6768 | : | ||
6769 | ( | ||
6770 | { before(grammarAccess.getALSPreficedAccess().getOperandAssignment_1_2()); } | ||
6771 | (rule__ALSPreficed__OperandAssignment_1_2) | ||
6772 | { after(grammarAccess.getALSPreficedAccess().getOperandAssignment_1_2()); } | ||
6773 | ) | ||
6774 | |||
6775 | ; | ||
6776 | finally { | ||
6777 | restoreStackSize(stackSize); | ||
6778 | } | ||
6779 | |||
6780 | |||
6781 | |||
6782 | |||
6783 | |||
6784 | |||
6785 | |||
6786 | |||
6787 | rule__ALSPreficed__Group_2__0 | ||
6788 | @init { | ||
6789 | int stackSize = keepStackSize(); | ||
6790 | } | ||
6791 | : | ||
6792 | rule__ALSPreficed__Group_2__0__Impl | ||
6793 | rule__ALSPreficed__Group_2__1 | ||
6794 | ; | ||
6795 | finally { | ||
6796 | restoreStackSize(stackSize); | ||
6797 | } | ||
6798 | |||
6799 | rule__ALSPreficed__Group_2__0__Impl | ||
6800 | @init { | ||
6801 | int stackSize = keepStackSize(); | ||
6802 | } | ||
6803 | : | ||
6804 | ( | ||
6805 | { before(grammarAccess.getALSPreficedAccess().getAlSTransitiveClosureAction_2_0()); } | ||
6806 | ( | ||
6807 | |||
6808 | ) | ||
6809 | { after(grammarAccess.getALSPreficedAccess().getAlSTransitiveClosureAction_2_0()); } | ||
6810 | ) | ||
6811 | |||
6812 | ; | ||
6813 | finally { | ||
6814 | restoreStackSize(stackSize); | ||
6815 | } | ||
6816 | |||
6817 | |||
6818 | rule__ALSPreficed__Group_2__1 | ||
6819 | @init { | ||
6820 | int stackSize = keepStackSize(); | ||
6821 | } | ||
6822 | : | ||
6823 | rule__ALSPreficed__Group_2__1__Impl | ||
6824 | rule__ALSPreficed__Group_2__2 | ||
6825 | ; | ||
6826 | finally { | ||
6827 | restoreStackSize(stackSize); | ||
6828 | } | ||
6829 | |||
6830 | rule__ALSPreficed__Group_2__1__Impl | ||
6831 | @init { | ||
6832 | int stackSize = keepStackSize(); | ||
6833 | } | ||
6834 | : | ||
6835 | ( | ||
6836 | { before(grammarAccess.getALSPreficedAccess().getCircumflexAccentKeyword_2_1()); } | ||
6837 | |||
6838 | '^' | ||
6839 | |||
6840 | { after(grammarAccess.getALSPreficedAccess().getCircumflexAccentKeyword_2_1()); } | ||
6841 | ) | ||
6842 | |||
6843 | ; | ||
6844 | finally { | ||
6845 | restoreStackSize(stackSize); | ||
6846 | } | ||
6847 | |||
6848 | |||
6849 | rule__ALSPreficed__Group_2__2 | ||
6850 | @init { | ||
6851 | int stackSize = keepStackSize(); | ||
6852 | } | ||
6853 | : | ||
6854 | rule__ALSPreficed__Group_2__2__Impl | ||
6855 | ; | ||
6856 | finally { | ||
6857 | restoreStackSize(stackSize); | ||
6858 | } | ||
6859 | |||
6860 | rule__ALSPreficed__Group_2__2__Impl | ||
6861 | @init { | ||
6862 | int stackSize = keepStackSize(); | ||
6863 | } | ||
6864 | : | ||
6865 | ( | ||
6866 | { before(grammarAccess.getALSPreficedAccess().getOperandAssignment_2_2()); } | ||
6867 | (rule__ALSPreficed__OperandAssignment_2_2) | ||
6868 | { after(grammarAccess.getALSPreficedAccess().getOperandAssignment_2_2()); } | ||
6869 | ) | ||
6870 | |||
6871 | ; | ||
6872 | finally { | ||
6873 | restoreStackSize(stackSize); | ||
6874 | } | ||
6875 | |||
6876 | |||
6877 | |||
6878 | |||
6879 | |||
6880 | |||
6881 | |||
6882 | |||
6883 | rule__ALSPreficed__Group_3__0 | ||
6884 | @init { | ||
6885 | int stackSize = keepStackSize(); | ||
6886 | } | ||
6887 | : | ||
6888 | rule__ALSPreficed__Group_3__0__Impl | ||
6889 | rule__ALSPreficed__Group_3__1 | ||
6890 | ; | ||
6891 | finally { | ||
6892 | restoreStackSize(stackSize); | ||
6893 | } | ||
6894 | |||
6895 | rule__ALSPreficed__Group_3__0__Impl | ||
6896 | @init { | ||
6897 | int stackSize = keepStackSize(); | ||
6898 | } | ||
6899 | : | ||
6900 | ( | ||
6901 | { before(grammarAccess.getALSPreficedAccess().getALSReflectiveTransitiveClosureAction_3_0()); } | ||
6902 | ( | ||
6903 | |||
6904 | ) | ||
6905 | { after(grammarAccess.getALSPreficedAccess().getALSReflectiveTransitiveClosureAction_3_0()); } | ||
6906 | ) | ||
6907 | |||
6908 | ; | ||
6909 | finally { | ||
6910 | restoreStackSize(stackSize); | ||
6911 | } | ||
6912 | |||
6913 | |||
6914 | rule__ALSPreficed__Group_3__1 | ||
6915 | @init { | ||
6916 | int stackSize = keepStackSize(); | ||
6917 | } | ||
6918 | : | ||
6919 | rule__ALSPreficed__Group_3__1__Impl | ||
6920 | rule__ALSPreficed__Group_3__2 | ||
6921 | ; | ||
6922 | finally { | ||
6923 | restoreStackSize(stackSize); | ||
6924 | } | ||
6925 | |||
6926 | rule__ALSPreficed__Group_3__1__Impl | ||
6927 | @init { | ||
6928 | int stackSize = keepStackSize(); | ||
6929 | } | ||
6930 | : | ||
6931 | ( | ||
6932 | { before(grammarAccess.getALSPreficedAccess().getAsteriskKeyword_3_1()); } | ||
6933 | |||
6934 | '*' | ||
6935 | |||
6936 | { after(grammarAccess.getALSPreficedAccess().getAsteriskKeyword_3_1()); } | ||
6937 | ) | ||
6938 | |||
6939 | ; | ||
6940 | finally { | ||
6941 | restoreStackSize(stackSize); | ||
6942 | } | ||
6943 | |||
6944 | |||
6945 | rule__ALSPreficed__Group_3__2 | ||
6946 | @init { | ||
6947 | int stackSize = keepStackSize(); | ||
6948 | } | ||
6949 | : | ||
6950 | rule__ALSPreficed__Group_3__2__Impl | ||
6951 | ; | ||
6952 | finally { | ||
6953 | restoreStackSize(stackSize); | ||
6954 | } | ||
6955 | |||
6956 | rule__ALSPreficed__Group_3__2__Impl | ||
6957 | @init { | ||
6958 | int stackSize = keepStackSize(); | ||
6959 | } | ||
6960 | : | ||
6961 | ( | ||
6962 | { before(grammarAccess.getALSPreficedAccess().getOperandAssignment_3_2()); } | ||
6963 | (rule__ALSPreficed__OperandAssignment_3_2) | ||
6964 | { after(grammarAccess.getALSPreficedAccess().getOperandAssignment_3_2()); } | ||
6965 | ) | ||
6966 | |||
6967 | ; | ||
6968 | finally { | ||
6969 | restoreStackSize(stackSize); | ||
6970 | } | ||
6971 | |||
6972 | |||
6973 | |||
6974 | |||
6975 | |||
6976 | |||
6977 | |||
6978 | |||
6979 | rule__ALSPreficed__Group_4__0 | ||
6980 | @init { | ||
6981 | int stackSize = keepStackSize(); | ||
6982 | } | ||
6983 | : | ||
6984 | rule__ALSPreficed__Group_4__0__Impl | ||
6985 | rule__ALSPreficed__Group_4__1 | ||
6986 | ; | ||
6987 | finally { | ||
6988 | restoreStackSize(stackSize); | ||
6989 | } | ||
6990 | |||
6991 | rule__ALSPreficed__Group_4__0__Impl | ||
6992 | @init { | ||
6993 | int stackSize = keepStackSize(); | ||
6994 | } | ||
6995 | : | ||
6996 | ( | ||
6997 | { before(grammarAccess.getALSPreficedAccess().getALSCardinalityAction_4_0()); } | ||
6998 | ( | ||
6999 | |||
7000 | ) | ||
7001 | { after(grammarAccess.getALSPreficedAccess().getALSCardinalityAction_4_0()); } | ||
7002 | ) | ||
7003 | |||
7004 | ; | ||
7005 | finally { | ||
7006 | restoreStackSize(stackSize); | ||
7007 | } | ||
7008 | |||
7009 | |||
7010 | rule__ALSPreficed__Group_4__1 | ||
7011 | @init { | ||
7012 | int stackSize = keepStackSize(); | ||
7013 | } | ||
7014 | : | ||
7015 | rule__ALSPreficed__Group_4__1__Impl | ||
7016 | rule__ALSPreficed__Group_4__2 | ||
7017 | ; | ||
7018 | finally { | ||
7019 | restoreStackSize(stackSize); | ||
7020 | } | ||
7021 | |||
7022 | rule__ALSPreficed__Group_4__1__Impl | ||
7023 | @init { | ||
7024 | int stackSize = keepStackSize(); | ||
7025 | } | ||
7026 | : | ||
7027 | ( | ||
7028 | { before(grammarAccess.getALSPreficedAccess().getNumberSignKeyword_4_1()); } | ||
7029 | |||
7030 | '#' | ||
7031 | |||
7032 | { after(grammarAccess.getALSPreficedAccess().getNumberSignKeyword_4_1()); } | ||
7033 | ) | ||
7034 | |||
7035 | ; | ||
7036 | finally { | ||
7037 | restoreStackSize(stackSize); | ||
7038 | } | ||
7039 | |||
7040 | |||
7041 | rule__ALSPreficed__Group_4__2 | ||
7042 | @init { | ||
7043 | int stackSize = keepStackSize(); | ||
7044 | } | ||
7045 | : | ||
7046 | rule__ALSPreficed__Group_4__2__Impl | ||
7047 | ; | ||
7048 | finally { | ||
7049 | restoreStackSize(stackSize); | ||
7050 | } | ||
7051 | |||
7052 | rule__ALSPreficed__Group_4__2__Impl | ||
7053 | @init { | ||
7054 | int stackSize = keepStackSize(); | ||
7055 | } | ||
7056 | : | ||
7057 | ( | ||
7058 | { before(grammarAccess.getALSPreficedAccess().getOperandAssignment_4_2()); } | ||
7059 | (rule__ALSPreficed__OperandAssignment_4_2) | ||
7060 | { after(grammarAccess.getALSPreficedAccess().getOperandAssignment_4_2()); } | ||
7061 | ) | ||
7062 | |||
7063 | ; | ||
7064 | finally { | ||
7065 | restoreStackSize(stackSize); | ||
7066 | } | ||
7067 | |||
7068 | |||
7069 | |||
7070 | |||
7071 | |||
7072 | |||
7073 | |||
7074 | |||
7075 | rule__ALSPreficed__Group_5__0 | ||
7076 | @init { | ||
7077 | int stackSize = keepStackSize(); | ||
7078 | } | ||
7079 | : | ||
7080 | rule__ALSPreficed__Group_5__0__Impl | ||
7081 | rule__ALSPreficed__Group_5__1 | ||
7082 | ; | ||
7083 | finally { | ||
7084 | restoreStackSize(stackSize); | ||
7085 | } | ||
7086 | |||
7087 | rule__ALSPreficed__Group_5__0__Impl | ||
7088 | @init { | ||
7089 | int stackSize = keepStackSize(); | ||
7090 | } | ||
7091 | : | ||
7092 | ( | ||
7093 | { before(grammarAccess.getALSPreficedAccess().getALSUnaryMinusAction_5_0()); } | ||
7094 | ( | ||
7095 | |||
7096 | ) | ||
7097 | { after(grammarAccess.getALSPreficedAccess().getALSUnaryMinusAction_5_0()); } | ||
7098 | ) | ||
7099 | |||
7100 | ; | ||
7101 | finally { | ||
7102 | restoreStackSize(stackSize); | ||
7103 | } | ||
7104 | |||
7105 | |||
7106 | rule__ALSPreficed__Group_5__1 | ||
7107 | @init { | ||
7108 | int stackSize = keepStackSize(); | ||
7109 | } | ||
7110 | : | ||
7111 | rule__ALSPreficed__Group_5__1__Impl | ||
7112 | rule__ALSPreficed__Group_5__2 | ||
7113 | ; | ||
7114 | finally { | ||
7115 | restoreStackSize(stackSize); | ||
7116 | } | ||
7117 | |||
7118 | rule__ALSPreficed__Group_5__1__Impl | ||
7119 | @init { | ||
7120 | int stackSize = keepStackSize(); | ||
7121 | } | ||
7122 | : | ||
7123 | ( | ||
7124 | { before(grammarAccess.getALSPreficedAccess().getHyphenMinusKeyword_5_1()); } | ||
7125 | ( | ||
7126 | '-' | ||
7127 | ) | ||
7128 | { after(grammarAccess.getALSPreficedAccess().getHyphenMinusKeyword_5_1()); } | ||
7129 | ) | ||
7130 | |||
7131 | ; | ||
7132 | finally { | ||
7133 | restoreStackSize(stackSize); | ||
7134 | } | ||
7135 | |||
7136 | |||
7137 | rule__ALSPreficed__Group_5__2 | ||
7138 | @init { | ||
7139 | int stackSize = keepStackSize(); | ||
7140 | } | ||
7141 | : | ||
7142 | rule__ALSPreficed__Group_5__2__Impl | ||
7143 | ; | ||
7144 | finally { | ||
7145 | restoreStackSize(stackSize); | ||
7146 | } | ||
7147 | |||
7148 | rule__ALSPreficed__Group_5__2__Impl | ||
7149 | @init { | ||
7150 | int stackSize = keepStackSize(); | ||
7151 | } | ||
7152 | : | ||
7153 | ( | ||
7154 | { before(grammarAccess.getALSPreficedAccess().getOperandAssignment_5_2()); } | ||
7155 | (rule__ALSPreficed__OperandAssignment_5_2) | ||
7156 | { after(grammarAccess.getALSPreficedAccess().getOperandAssignment_5_2()); } | ||
7157 | ) | ||
7158 | |||
7159 | ; | ||
7160 | finally { | ||
7161 | restoreStackSize(stackSize); | ||
7162 | } | ||
7163 | |||
7164 | |||
7165 | |||
7166 | |||
7167 | |||
7168 | |||
7169 | |||
7170 | |||
7171 | rule__ALSPreficed__Group_6__0 | ||
7172 | @init { | ||
7173 | int stackSize = keepStackSize(); | ||
7174 | } | ||
7175 | : | ||
7176 | rule__ALSPreficed__Group_6__0__Impl | ||
7177 | rule__ALSPreficed__Group_6__1 | ||
7178 | ; | ||
7179 | finally { | ||
7180 | restoreStackSize(stackSize); | ||
7181 | } | ||
7182 | |||
7183 | rule__ALSPreficed__Group_6__0__Impl | ||
7184 | @init { | ||
7185 | int stackSize = keepStackSize(); | ||
7186 | } | ||
7187 | : | ||
7188 | ( | ||
7189 | { before(grammarAccess.getALSPreficedAccess().getALSSumAction_6_0()); } | ||
7190 | ( | ||
7191 | |||
7192 | ) | ||
7193 | { after(grammarAccess.getALSPreficedAccess().getALSSumAction_6_0()); } | ||
7194 | ) | ||
7195 | |||
7196 | ; | ||
7197 | finally { | ||
7198 | restoreStackSize(stackSize); | ||
7199 | } | ||
7200 | |||
7201 | |||
7202 | rule__ALSPreficed__Group_6__1 | ||
7203 | @init { | ||
7204 | int stackSize = keepStackSize(); | ||
7205 | } | ||
7206 | : | ||
7207 | rule__ALSPreficed__Group_6__1__Impl | ||
7208 | rule__ALSPreficed__Group_6__2 | ||
7209 | ; | ||
7210 | finally { | ||
7211 | restoreStackSize(stackSize); | ||
7212 | } | ||
7213 | |||
7214 | rule__ALSPreficed__Group_6__1__Impl | ||
7215 | @init { | ||
7216 | int stackSize = keepStackSize(); | ||
7217 | } | ||
7218 | : | ||
7219 | ( | ||
7220 | { before(grammarAccess.getALSPreficedAccess().getSumKeyword_6_1()); } | ||
7221 | |||
7222 | 'sum' | ||
7223 | |||
7224 | { after(grammarAccess.getALSPreficedAccess().getSumKeyword_6_1()); } | ||
7225 | ) | ||
7226 | |||
7227 | ; | ||
7228 | finally { | ||
7229 | restoreStackSize(stackSize); | ||
7230 | } | ||
7231 | |||
7232 | |||
7233 | rule__ALSPreficed__Group_6__2 | ||
7234 | @init { | ||
7235 | int stackSize = keepStackSize(); | ||
7236 | } | ||
7237 | : | ||
7238 | rule__ALSPreficed__Group_6__2__Impl | ||
7239 | rule__ALSPreficed__Group_6__3 | ||
7240 | ; | ||
7241 | finally { | ||
7242 | restoreStackSize(stackSize); | ||
7243 | } | ||
7244 | |||
7245 | rule__ALSPreficed__Group_6__2__Impl | ||
7246 | @init { | ||
7247 | int stackSize = keepStackSize(); | ||
7248 | } | ||
7249 | : | ||
7250 | ( | ||
7251 | { before(grammarAccess.getALSPreficedAccess().getVariablesAssignment_6_2()); } | ||
7252 | (rule__ALSPreficed__VariablesAssignment_6_2) | ||
7253 | { after(grammarAccess.getALSPreficedAccess().getVariablesAssignment_6_2()); } | ||
7254 | ) | ||
7255 | |||
7256 | ; | ||
7257 | finally { | ||
7258 | restoreStackSize(stackSize); | ||
7259 | } | ||
7260 | |||
7261 | |||
7262 | rule__ALSPreficed__Group_6__3 | ||
7263 | @init { | ||
7264 | int stackSize = keepStackSize(); | ||
7265 | } | ||
7266 | : | ||
7267 | rule__ALSPreficed__Group_6__3__Impl | ||
7268 | rule__ALSPreficed__Group_6__4 | ||
7269 | ; | ||
7270 | finally { | ||
7271 | restoreStackSize(stackSize); | ||
7272 | } | ||
7273 | |||
7274 | rule__ALSPreficed__Group_6__3__Impl | ||
7275 | @init { | ||
7276 | int stackSize = keepStackSize(); | ||
7277 | } | ||
7278 | : | ||
7279 | ( | ||
7280 | { before(grammarAccess.getALSPreficedAccess().getGroup_6_3()); } | ||
7281 | (rule__ALSPreficed__Group_6_3__0)* | ||
7282 | { after(grammarAccess.getALSPreficedAccess().getGroup_6_3()); } | ||
7283 | ) | ||
7284 | |||
7285 | ; | ||
7286 | finally { | ||
7287 | restoreStackSize(stackSize); | ||
7288 | } | ||
7289 | |||
7290 | |||
7291 | rule__ALSPreficed__Group_6__4 | ||
7292 | @init { | ||
7293 | int stackSize = keepStackSize(); | ||
7294 | } | ||
7295 | : | ||
7296 | rule__ALSPreficed__Group_6__4__Impl | ||
7297 | rule__ALSPreficed__Group_6__5 | ||
7298 | ; | ||
7299 | finally { | ||
7300 | restoreStackSize(stackSize); | ||
7301 | } | ||
7302 | |||
7303 | rule__ALSPreficed__Group_6__4__Impl | ||
7304 | @init { | ||
7305 | int stackSize = keepStackSize(); | ||
7306 | } | ||
7307 | : | ||
7308 | ( | ||
7309 | { before(grammarAccess.getALSPreficedAccess().getLeftCurlyBracketKeyword_6_4()); } | ||
7310 | |||
7311 | '{' | ||
7312 | |||
7313 | { after(grammarAccess.getALSPreficedAccess().getLeftCurlyBracketKeyword_6_4()); } | ||
7314 | ) | ||
7315 | |||
7316 | ; | ||
7317 | finally { | ||
7318 | restoreStackSize(stackSize); | ||
7319 | } | ||
7320 | |||
7321 | |||
7322 | rule__ALSPreficed__Group_6__5 | ||
7323 | @init { | ||
7324 | int stackSize = keepStackSize(); | ||
7325 | } | ||
7326 | : | ||
7327 | rule__ALSPreficed__Group_6__5__Impl | ||
7328 | rule__ALSPreficed__Group_6__6 | ||
7329 | ; | ||
7330 | finally { | ||
7331 | restoreStackSize(stackSize); | ||
7332 | } | ||
7333 | |||
7334 | rule__ALSPreficed__Group_6__5__Impl | ||
7335 | @init { | ||
7336 | int stackSize = keepStackSize(); | ||
7337 | } | ||
7338 | : | ||
7339 | ( | ||
7340 | { before(grammarAccess.getALSPreficedAccess().getExpressionAssignment_6_5()); } | ||
7341 | (rule__ALSPreficed__ExpressionAssignment_6_5) | ||
7342 | { after(grammarAccess.getALSPreficedAccess().getExpressionAssignment_6_5()); } | ||
7343 | ) | ||
7344 | |||
7345 | ; | ||
7346 | finally { | ||
7347 | restoreStackSize(stackSize); | ||
7348 | } | ||
7349 | |||
7350 | |||
7351 | rule__ALSPreficed__Group_6__6 | ||
7352 | @init { | ||
7353 | int stackSize = keepStackSize(); | ||
7354 | } | ||
7355 | : | ||
7356 | rule__ALSPreficed__Group_6__6__Impl | ||
7357 | ; | ||
7358 | finally { | ||
7359 | restoreStackSize(stackSize); | ||
7360 | } | ||
7361 | |||
7362 | rule__ALSPreficed__Group_6__6__Impl | ||
7363 | @init { | ||
7364 | int stackSize = keepStackSize(); | ||
7365 | } | ||
7366 | : | ||
7367 | ( | ||
7368 | { before(grammarAccess.getALSPreficedAccess().getRightCurlyBracketKeyword_6_6()); } | ||
7369 | |||
7370 | '}' | ||
7371 | |||
7372 | { after(grammarAccess.getALSPreficedAccess().getRightCurlyBracketKeyword_6_6()); } | ||
7373 | ) | ||
7374 | |||
7375 | ; | ||
7376 | finally { | ||
7377 | restoreStackSize(stackSize); | ||
7378 | } | ||
7379 | |||
7380 | |||
7381 | |||
7382 | |||
7383 | |||
7384 | |||
7385 | |||
7386 | |||
7387 | |||
7388 | |||
7389 | |||
7390 | |||
7391 | |||
7392 | |||
7393 | |||
7394 | |||
7395 | rule__ALSPreficed__Group_6_3__0 | ||
7396 | @init { | ||
7397 | int stackSize = keepStackSize(); | ||
7398 | } | ||
7399 | : | ||
7400 | rule__ALSPreficed__Group_6_3__0__Impl | ||
7401 | rule__ALSPreficed__Group_6_3__1 | ||
7402 | ; | ||
7403 | finally { | ||
7404 | restoreStackSize(stackSize); | ||
7405 | } | ||
7406 | |||
7407 | rule__ALSPreficed__Group_6_3__0__Impl | ||
7408 | @init { | ||
7409 | int stackSize = keepStackSize(); | ||
7410 | } | ||
7411 | : | ||
7412 | ( | ||
7413 | { before(grammarAccess.getALSPreficedAccess().getCommaKeyword_6_3_0()); } | ||
7414 | |||
7415 | ',' | ||
7416 | |||
7417 | { after(grammarAccess.getALSPreficedAccess().getCommaKeyword_6_3_0()); } | ||
7418 | ) | ||
7419 | |||
7420 | ; | ||
7421 | finally { | ||
7422 | restoreStackSize(stackSize); | ||
7423 | } | ||
7424 | |||
7425 | |||
7426 | rule__ALSPreficed__Group_6_3__1 | ||
7427 | @init { | ||
7428 | int stackSize = keepStackSize(); | ||
7429 | } | ||
7430 | : | ||
7431 | rule__ALSPreficed__Group_6_3__1__Impl | ||
7432 | ; | ||
7433 | finally { | ||
7434 | restoreStackSize(stackSize); | ||
7435 | } | ||
7436 | |||
7437 | rule__ALSPreficed__Group_6_3__1__Impl | ||
7438 | @init { | ||
7439 | int stackSize = keepStackSize(); | ||
7440 | } | ||
7441 | : | ||
7442 | ( | ||
7443 | { before(grammarAccess.getALSPreficedAccess().getVariablesAssignment_6_3_1()); } | ||
7444 | (rule__ALSPreficed__VariablesAssignment_6_3_1) | ||
7445 | { after(grammarAccess.getALSPreficedAccess().getVariablesAssignment_6_3_1()); } | ||
7446 | ) | ||
7447 | |||
7448 | ; | ||
7449 | finally { | ||
7450 | restoreStackSize(stackSize); | ||
7451 | } | ||
7452 | |||
7453 | |||
7454 | |||
7455 | |||
7456 | |||
7457 | |||
7458 | rule__ALSPreficed__Group_7__0 | ||
7459 | @init { | ||
7460 | int stackSize = keepStackSize(); | ||
7461 | } | ||
7462 | : | ||
7463 | rule__ALSPreficed__Group_7__0__Impl | ||
7464 | rule__ALSPreficed__Group_7__1 | ||
7465 | ; | ||
7466 | finally { | ||
7467 | restoreStackSize(stackSize); | ||
7468 | } | ||
7469 | |||
7470 | rule__ALSPreficed__Group_7__0__Impl | ||
7471 | @init { | ||
7472 | int stackSize = keepStackSize(); | ||
7473 | } | ||
7474 | : | ||
7475 | ( | ||
7476 | { before(grammarAccess.getALSPreficedAccess().getALSFunctionCallAction_7_0()); } | ||
7477 | ( | ||
7478 | |||
7479 | ) | ||
7480 | { after(grammarAccess.getALSPreficedAccess().getALSFunctionCallAction_7_0()); } | ||
7481 | ) | ||
7482 | |||
7483 | ; | ||
7484 | finally { | ||
7485 | restoreStackSize(stackSize); | ||
7486 | } | ||
7487 | |||
7488 | |||
7489 | rule__ALSPreficed__Group_7__1 | ||
7490 | @init { | ||
7491 | int stackSize = keepStackSize(); | ||
7492 | } | ||
7493 | : | ||
7494 | rule__ALSPreficed__Group_7__1__Impl | ||
7495 | rule__ALSPreficed__Group_7__2 | ||
7496 | ; | ||
7497 | finally { | ||
7498 | restoreStackSize(stackSize); | ||
7499 | } | ||
7500 | |||
7501 | rule__ALSPreficed__Group_7__1__Impl | ||
7502 | @init { | ||
7503 | int stackSize = keepStackSize(); | ||
7504 | } | ||
7505 | : | ||
7506 | ( | ||
7507 | { before(grammarAccess.getALSPreficedAccess().getAlternatives_7_1()); } | ||
7508 | (rule__ALSPreficed__Alternatives_7_1) | ||
7509 | { after(grammarAccess.getALSPreficedAccess().getAlternatives_7_1()); } | ||
7510 | ) | ||
7511 | |||
7512 | ; | ||
7513 | finally { | ||
7514 | restoreStackSize(stackSize); | ||
7515 | } | ||
7516 | |||
7517 | |||
7518 | rule__ALSPreficed__Group_7__2 | ||
7519 | @init { | ||
7520 | int stackSize = keepStackSize(); | ||
7521 | } | ||
7522 | : | ||
7523 | rule__ALSPreficed__Group_7__2__Impl | ||
7524 | rule__ALSPreficed__Group_7__3 | ||
7525 | ; | ||
7526 | finally { | ||
7527 | restoreStackSize(stackSize); | ||
7528 | } | ||
7529 | |||
7530 | rule__ALSPreficed__Group_7__2__Impl | ||
7531 | @init { | ||
7532 | int stackSize = keepStackSize(); | ||
7533 | } | ||
7534 | : | ||
7535 | ( | ||
7536 | { before(grammarAccess.getALSPreficedAccess().getLeftSquareBracketKeyword_7_2()); } | ||
7537 | |||
7538 | '[' | ||
7539 | |||
7540 | { after(grammarAccess.getALSPreficedAccess().getLeftSquareBracketKeyword_7_2()); } | ||
7541 | ) | ||
7542 | |||
7543 | ; | ||
7544 | finally { | ||
7545 | restoreStackSize(stackSize); | ||
7546 | } | ||
7547 | |||
7548 | |||
7549 | rule__ALSPreficed__Group_7__3 | ||
7550 | @init { | ||
7551 | int stackSize = keepStackSize(); | ||
7552 | } | ||
7553 | : | ||
7554 | rule__ALSPreficed__Group_7__3__Impl | ||
7555 | rule__ALSPreficed__Group_7__4 | ||
7556 | ; | ||
7557 | finally { | ||
7558 | restoreStackSize(stackSize); | ||
7559 | } | ||
7560 | |||
7561 | rule__ALSPreficed__Group_7__3__Impl | ||
7562 | @init { | ||
7563 | int stackSize = keepStackSize(); | ||
7564 | } | ||
7565 | : | ||
7566 | ( | ||
7567 | { before(grammarAccess.getALSPreficedAccess().getParamsAssignment_7_3()); } | ||
7568 | (rule__ALSPreficed__ParamsAssignment_7_3) | ||
7569 | { after(grammarAccess.getALSPreficedAccess().getParamsAssignment_7_3()); } | ||
7570 | ) | ||
7571 | |||
7572 | ; | ||
7573 | finally { | ||
7574 | restoreStackSize(stackSize); | ||
7575 | } | ||
7576 | |||
7577 | |||
7578 | rule__ALSPreficed__Group_7__4 | ||
7579 | @init { | ||
7580 | int stackSize = keepStackSize(); | ||
7581 | } | ||
7582 | : | ||
7583 | rule__ALSPreficed__Group_7__4__Impl | ||
7584 | rule__ALSPreficed__Group_7__5 | ||
7585 | ; | ||
7586 | finally { | ||
7587 | restoreStackSize(stackSize); | ||
7588 | } | ||
7589 | |||
7590 | rule__ALSPreficed__Group_7__4__Impl | ||
7591 | @init { | ||
7592 | int stackSize = keepStackSize(); | ||
7593 | } | ||
7594 | : | ||
7595 | ( | ||
7596 | { before(grammarAccess.getALSPreficedAccess().getGroup_7_4()); } | ||
7597 | (rule__ALSPreficed__Group_7_4__0)* | ||
7598 | { after(grammarAccess.getALSPreficedAccess().getGroup_7_4()); } | ||
7599 | ) | ||
7600 | |||
7601 | ; | ||
7602 | finally { | ||
7603 | restoreStackSize(stackSize); | ||
7604 | } | ||
7605 | |||
7606 | |||
7607 | rule__ALSPreficed__Group_7__5 | ||
7608 | @init { | ||
7609 | int stackSize = keepStackSize(); | ||
7610 | } | ||
7611 | : | ||
7612 | rule__ALSPreficed__Group_7__5__Impl | ||
7613 | ; | ||
7614 | finally { | ||
7615 | restoreStackSize(stackSize); | ||
7616 | } | ||
7617 | |||
7618 | rule__ALSPreficed__Group_7__5__Impl | ||
7619 | @init { | ||
7620 | int stackSize = keepStackSize(); | ||
7621 | } | ||
7622 | : | ||
7623 | ( | ||
7624 | { before(grammarAccess.getALSPreficedAccess().getRightSquareBracketKeyword_7_5()); } | ||
7625 | |||
7626 | ']' | ||
7627 | |||
7628 | { after(grammarAccess.getALSPreficedAccess().getRightSquareBracketKeyword_7_5()); } | ||
7629 | ) | ||
7630 | |||
7631 | ; | ||
7632 | finally { | ||
7633 | restoreStackSize(stackSize); | ||
7634 | } | ||
7635 | |||
7636 | |||
7637 | |||
7638 | |||
7639 | |||
7640 | |||
7641 | |||
7642 | |||
7643 | |||
7644 | |||
7645 | |||
7646 | |||
7647 | |||
7648 | |||
7649 | rule__ALSPreficed__Group_7_4__0 | ||
7650 | @init { | ||
7651 | int stackSize = keepStackSize(); | ||
7652 | } | ||
7653 | : | ||
7654 | rule__ALSPreficed__Group_7_4__0__Impl | ||
7655 | rule__ALSPreficed__Group_7_4__1 | ||
7656 | ; | ||
7657 | finally { | ||
7658 | restoreStackSize(stackSize); | ||
7659 | } | ||
7660 | |||
7661 | rule__ALSPreficed__Group_7_4__0__Impl | ||
7662 | @init { | ||
7663 | int stackSize = keepStackSize(); | ||
7664 | } | ||
7665 | : | ||
7666 | ( | ||
7667 | { before(grammarAccess.getALSPreficedAccess().getCommaKeyword_7_4_0()); } | ||
7668 | |||
7669 | ',' | ||
7670 | |||
7671 | { after(grammarAccess.getALSPreficedAccess().getCommaKeyword_7_4_0()); } | ||
7672 | ) | ||
7673 | |||
7674 | ; | ||
7675 | finally { | ||
7676 | restoreStackSize(stackSize); | ||
7677 | } | ||
7678 | |||
7679 | |||
7680 | rule__ALSPreficed__Group_7_4__1 | ||
7681 | @init { | ||
7682 | int stackSize = keepStackSize(); | ||
7683 | } | ||
7684 | : | ||
7685 | rule__ALSPreficed__Group_7_4__1__Impl | ||
7686 | ; | ||
7687 | finally { | ||
7688 | restoreStackSize(stackSize); | ||
7689 | } | ||
7690 | |||
7691 | rule__ALSPreficed__Group_7_4__1__Impl | ||
7692 | @init { | ||
7693 | int stackSize = keepStackSize(); | ||
7694 | } | ||
7695 | : | ||
7696 | ( | ||
7697 | { before(grammarAccess.getALSPreficedAccess().getParamsAssignment_7_4_1()); } | ||
7698 | (rule__ALSPreficed__ParamsAssignment_7_4_1) | ||
7699 | { after(grammarAccess.getALSPreficedAccess().getParamsAssignment_7_4_1()); } | ||
7700 | ) | ||
7701 | |||
7702 | ; | ||
7703 | finally { | ||
7704 | restoreStackSize(stackSize); | ||
7705 | } | ||
7706 | |||
7707 | |||
7708 | |||
7709 | |||
7710 | |||
7711 | |||
7712 | rule__ALSVariableDeclaration__Group__0 | ||
7713 | @init { | ||
7714 | int stackSize = keepStackSize(); | ||
7715 | } | ||
7716 | : | ||
7717 | rule__ALSVariableDeclaration__Group__0__Impl | ||
7718 | rule__ALSVariableDeclaration__Group__1 | ||
7719 | ; | ||
7720 | finally { | ||
7721 | restoreStackSize(stackSize); | ||
7722 | } | ||
7723 | |||
7724 | rule__ALSVariableDeclaration__Group__0__Impl | ||
7725 | @init { | ||
7726 | int stackSize = keepStackSize(); | ||
7727 | } | ||
7728 | : | ||
7729 | ( | ||
7730 | { before(grammarAccess.getALSVariableDeclarationAccess().getNameAssignment_0()); } | ||
7731 | (rule__ALSVariableDeclaration__NameAssignment_0) | ||
7732 | { after(grammarAccess.getALSVariableDeclarationAccess().getNameAssignment_0()); } | ||
7733 | ) | ||
7734 | |||
7735 | ; | ||
7736 | finally { | ||
7737 | restoreStackSize(stackSize); | ||
7738 | } | ||
7739 | |||
7740 | |||
7741 | rule__ALSVariableDeclaration__Group__1 | ||
7742 | @init { | ||
7743 | int stackSize = keepStackSize(); | ||
7744 | } | ||
7745 | : | ||
7746 | rule__ALSVariableDeclaration__Group__1__Impl | ||
7747 | rule__ALSVariableDeclaration__Group__2 | ||
7748 | ; | ||
7749 | finally { | ||
7750 | restoreStackSize(stackSize); | ||
7751 | } | ||
7752 | |||
7753 | rule__ALSVariableDeclaration__Group__1__Impl | ||
7754 | @init { | ||
7755 | int stackSize = keepStackSize(); | ||
7756 | } | ||
7757 | : | ||
7758 | ( | ||
7759 | { before(grammarAccess.getALSVariableDeclarationAccess().getColonKeyword_1()); } | ||
7760 | |||
7761 | ':' | ||
7762 | |||
7763 | { after(grammarAccess.getALSVariableDeclarationAccess().getColonKeyword_1()); } | ||
7764 | ) | ||
7765 | |||
7766 | ; | ||
7767 | finally { | ||
7768 | restoreStackSize(stackSize); | ||
7769 | } | ||
7770 | |||
7771 | |||
7772 | rule__ALSVariableDeclaration__Group__2 | ||
7773 | @init { | ||
7774 | int stackSize = keepStackSize(); | ||
7775 | } | ||
7776 | : | ||
7777 | rule__ALSVariableDeclaration__Group__2__Impl | ||
7778 | ; | ||
7779 | finally { | ||
7780 | restoreStackSize(stackSize); | ||
7781 | } | ||
7782 | |||
7783 | rule__ALSVariableDeclaration__Group__2__Impl | ||
7784 | @init { | ||
7785 | int stackSize = keepStackSize(); | ||
7786 | } | ||
7787 | : | ||
7788 | ( | ||
7789 | { before(grammarAccess.getALSVariableDeclarationAccess().getRangeAssignment_2()); } | ||
7790 | (rule__ALSVariableDeclaration__RangeAssignment_2) | ||
7791 | { after(grammarAccess.getALSVariableDeclarationAccess().getRangeAssignment_2()); } | ||
7792 | ) | ||
7793 | |||
7794 | ; | ||
7795 | finally { | ||
7796 | restoreStackSize(stackSize); | ||
7797 | } | ||
7798 | |||
7799 | |||
7800 | |||
7801 | |||
7802 | |||
7803 | |||
7804 | |||
7805 | |||
7806 | rule__ALSBasicRelationTerm__Group_0__0 | ||
7807 | @init { | ||
7808 | int stackSize = keepStackSize(); | ||
7809 | } | ||
7810 | : | ||
7811 | rule__ALSBasicRelationTerm__Group_0__0__Impl | ||
7812 | rule__ALSBasicRelationTerm__Group_0__1 | ||
7813 | ; | ||
7814 | finally { | ||
7815 | restoreStackSize(stackSize); | ||
7816 | } | ||
7817 | |||
7818 | rule__ALSBasicRelationTerm__Group_0__0__Impl | ||
7819 | @init { | ||
7820 | int stackSize = keepStackSize(); | ||
7821 | } | ||
7822 | : | ||
7823 | ( | ||
7824 | { before(grammarAccess.getALSBasicRelationTermAccess().getALSNoneAction_0_0()); } | ||
7825 | ( | ||
7826 | |||
7827 | ) | ||
7828 | { after(grammarAccess.getALSBasicRelationTermAccess().getALSNoneAction_0_0()); } | ||
7829 | ) | ||
7830 | |||
7831 | ; | ||
7832 | finally { | ||
7833 | restoreStackSize(stackSize); | ||
7834 | } | ||
7835 | |||
7836 | |||
7837 | rule__ALSBasicRelationTerm__Group_0__1 | ||
7838 | @init { | ||
7839 | int stackSize = keepStackSize(); | ||
7840 | } | ||
7841 | : | ||
7842 | rule__ALSBasicRelationTerm__Group_0__1__Impl | ||
7843 | ; | ||
7844 | finally { | ||
7845 | restoreStackSize(stackSize); | ||
7846 | } | ||
7847 | |||
7848 | rule__ALSBasicRelationTerm__Group_0__1__Impl | ||
7849 | @init { | ||
7850 | int stackSize = keepStackSize(); | ||
7851 | } | ||
7852 | : | ||
7853 | ( | ||
7854 | { before(grammarAccess.getALSBasicRelationTermAccess().getNoneKeyword_0_1()); } | ||
7855 | |||
7856 | 'none' | ||
7857 | |||
7858 | { after(grammarAccess.getALSBasicRelationTermAccess().getNoneKeyword_0_1()); } | ||
7859 | ) | ||
7860 | |||
7861 | ; | ||
7862 | finally { | ||
7863 | restoreStackSize(stackSize); | ||
7864 | } | ||
7865 | |||
7866 | |||
7867 | |||
7868 | |||
7869 | |||
7870 | |||
7871 | rule__ALSBasicRelationTerm__Group_1__0 | ||
7872 | @init { | ||
7873 | int stackSize = keepStackSize(); | ||
7874 | } | ||
7875 | : | ||
7876 | rule__ALSBasicRelationTerm__Group_1__0__Impl | ||
7877 | rule__ALSBasicRelationTerm__Group_1__1 | ||
7878 | ; | ||
7879 | finally { | ||
7880 | restoreStackSize(stackSize); | ||
7881 | } | ||
7882 | |||
7883 | rule__ALSBasicRelationTerm__Group_1__0__Impl | ||
7884 | @init { | ||
7885 | int stackSize = keepStackSize(); | ||
7886 | } | ||
7887 | : | ||
7888 | ( | ||
7889 | { before(grammarAccess.getALSBasicRelationTermAccess().getALSIdenAction_1_0()); } | ||
7890 | ( | ||
7891 | |||
7892 | ) | ||
7893 | { after(grammarAccess.getALSBasicRelationTermAccess().getALSIdenAction_1_0()); } | ||
7894 | ) | ||
7895 | |||
7896 | ; | ||
7897 | finally { | ||
7898 | restoreStackSize(stackSize); | ||
7899 | } | ||
7900 | |||
7901 | |||
7902 | rule__ALSBasicRelationTerm__Group_1__1 | ||
7903 | @init { | ||
7904 | int stackSize = keepStackSize(); | ||
7905 | } | ||
7906 | : | ||
7907 | rule__ALSBasicRelationTerm__Group_1__1__Impl | ||
7908 | ; | ||
7909 | finally { | ||
7910 | restoreStackSize(stackSize); | ||
7911 | } | ||
7912 | |||
7913 | rule__ALSBasicRelationTerm__Group_1__1__Impl | ||
7914 | @init { | ||
7915 | int stackSize = keepStackSize(); | ||
7916 | } | ||
7917 | : | ||
7918 | ( | ||
7919 | { before(grammarAccess.getALSBasicRelationTermAccess().getIdenKeyword_1_1()); } | ||
7920 | |||
7921 | 'iden' | ||
7922 | |||
7923 | { after(grammarAccess.getALSBasicRelationTermAccess().getIdenKeyword_1_1()); } | ||
7924 | ) | ||
7925 | |||
7926 | ; | ||
7927 | finally { | ||
7928 | restoreStackSize(stackSize); | ||
7929 | } | ||
7930 | |||
7931 | |||
7932 | |||
7933 | |||
7934 | |||
7935 | |||
7936 | rule__ALSBasicRelationTerm__Group_2__0 | ||
7937 | @init { | ||
7938 | int stackSize = keepStackSize(); | ||
7939 | } | ||
7940 | : | ||
7941 | rule__ALSBasicRelationTerm__Group_2__0__Impl | ||
7942 | rule__ALSBasicRelationTerm__Group_2__1 | ||
7943 | ; | ||
7944 | finally { | ||
7945 | restoreStackSize(stackSize); | ||
7946 | } | ||
7947 | |||
7948 | rule__ALSBasicRelationTerm__Group_2__0__Impl | ||
7949 | @init { | ||
7950 | int stackSize = keepStackSize(); | ||
7951 | } | ||
7952 | : | ||
7953 | ( | ||
7954 | { before(grammarAccess.getALSBasicRelationTermAccess().getALSUnivAction_2_0()); } | ||
7955 | ( | ||
7956 | |||
7957 | ) | ||
7958 | { after(grammarAccess.getALSBasicRelationTermAccess().getALSUnivAction_2_0()); } | ||
7959 | ) | ||
7960 | |||
7961 | ; | ||
7962 | finally { | ||
7963 | restoreStackSize(stackSize); | ||
7964 | } | ||
7965 | |||
7966 | |||
7967 | rule__ALSBasicRelationTerm__Group_2__1 | ||
7968 | @init { | ||
7969 | int stackSize = keepStackSize(); | ||
7970 | } | ||
7971 | : | ||
7972 | rule__ALSBasicRelationTerm__Group_2__1__Impl | ||
7973 | ; | ||
7974 | finally { | ||
7975 | restoreStackSize(stackSize); | ||
7976 | } | ||
7977 | |||
7978 | rule__ALSBasicRelationTerm__Group_2__1__Impl | ||
7979 | @init { | ||
7980 | int stackSize = keepStackSize(); | ||
7981 | } | ||
7982 | : | ||
7983 | ( | ||
7984 | { before(grammarAccess.getALSBasicRelationTermAccess().getUnivKeyword_2_1()); } | ||
7985 | |||
7986 | 'univ' | ||
7987 | |||
7988 | { after(grammarAccess.getALSBasicRelationTermAccess().getUnivKeyword_2_1()); } | ||
7989 | ) | ||
7990 | |||
7991 | ; | ||
7992 | finally { | ||
7993 | restoreStackSize(stackSize); | ||
7994 | } | ||
7995 | |||
7996 | |||
7997 | |||
7998 | |||
7999 | |||
8000 | |||
8001 | rule__ALSBasicRelationTerm__Group_3__0 | ||
8002 | @init { | ||
8003 | int stackSize = keepStackSize(); | ||
8004 | } | ||
8005 | : | ||
8006 | rule__ALSBasicRelationTerm__Group_3__0__Impl | ||
8007 | rule__ALSBasicRelationTerm__Group_3__1 | ||
8008 | ; | ||
8009 | finally { | ||
8010 | restoreStackSize(stackSize); | ||
8011 | } | ||
8012 | |||
8013 | rule__ALSBasicRelationTerm__Group_3__0__Impl | ||
8014 | @init { | ||
8015 | int stackSize = keepStackSize(); | ||
8016 | } | ||
8017 | : | ||
8018 | ( | ||
8019 | { before(grammarAccess.getALSBasicRelationTermAccess().getALSIntAction_3_0()); } | ||
8020 | ( | ||
8021 | |||
8022 | ) | ||
8023 | { after(grammarAccess.getALSBasicRelationTermAccess().getALSIntAction_3_0()); } | ||
8024 | ) | ||
8025 | |||
8026 | ; | ||
8027 | finally { | ||
8028 | restoreStackSize(stackSize); | ||
8029 | } | ||
8030 | |||
8031 | |||
8032 | rule__ALSBasicRelationTerm__Group_3__1 | ||
8033 | @init { | ||
8034 | int stackSize = keepStackSize(); | ||
8035 | } | ||
8036 | : | ||
8037 | rule__ALSBasicRelationTerm__Group_3__1__Impl | ||
8038 | ; | ||
8039 | finally { | ||
8040 | restoreStackSize(stackSize); | ||
8041 | } | ||
8042 | |||
8043 | rule__ALSBasicRelationTerm__Group_3__1__Impl | ||
8044 | @init { | ||
8045 | int stackSize = keepStackSize(); | ||
8046 | } | ||
8047 | : | ||
8048 | ( | ||
8049 | { before(grammarAccess.getALSBasicRelationTermAccess().getIntKeyword_3_1()); } | ||
8050 | |||
8051 | 'Int' | ||
8052 | |||
8053 | { after(grammarAccess.getALSBasicRelationTermAccess().getIntKeyword_3_1()); } | ||
8054 | ) | ||
8055 | |||
8056 | ; | ||
8057 | finally { | ||
8058 | restoreStackSize(stackSize); | ||
8059 | } | ||
8060 | |||
8061 | |||
8062 | |||
8063 | |||
8064 | |||
8065 | |||
8066 | rule__ALSBasicRelationTerm__Group_4__0 | ||
8067 | @init { | ||
8068 | int stackSize = keepStackSize(); | ||
8069 | } | ||
8070 | : | ||
8071 | rule__ALSBasicRelationTerm__Group_4__0__Impl | ||
8072 | rule__ALSBasicRelationTerm__Group_4__1 | ||
8073 | ; | ||
8074 | finally { | ||
8075 | restoreStackSize(stackSize); | ||
8076 | } | ||
8077 | |||
8078 | rule__ALSBasicRelationTerm__Group_4__0__Impl | ||
8079 | @init { | ||
8080 | int stackSize = keepStackSize(); | ||
8081 | } | ||
8082 | : | ||
8083 | ( | ||
8084 | { before(grammarAccess.getALSBasicRelationTermAccess().getALSReferenceAction_4_0()); } | ||
8085 | ( | ||
8086 | |||
8087 | ) | ||
8088 | { after(grammarAccess.getALSBasicRelationTermAccess().getALSReferenceAction_4_0()); } | ||
8089 | ) | ||
8090 | |||
8091 | ; | ||
8092 | finally { | ||
8093 | restoreStackSize(stackSize); | ||
8094 | } | ||
8095 | |||
8096 | |||
8097 | rule__ALSBasicRelationTerm__Group_4__1 | ||
8098 | @init { | ||
8099 | int stackSize = keepStackSize(); | ||
8100 | } | ||
8101 | : | ||
8102 | rule__ALSBasicRelationTerm__Group_4__1__Impl | ||
8103 | ; | ||
8104 | finally { | ||
8105 | restoreStackSize(stackSize); | ||
8106 | } | ||
8107 | |||
8108 | rule__ALSBasicRelationTerm__Group_4__1__Impl | ||
8109 | @init { | ||
8110 | int stackSize = keepStackSize(); | ||
8111 | } | ||
8112 | : | ||
8113 | ( | ||
8114 | { before(grammarAccess.getALSBasicRelationTermAccess().getReferredAssignment_4_1()); } | ||
8115 | (rule__ALSBasicRelationTerm__ReferredAssignment_4_1) | ||
8116 | { after(grammarAccess.getALSBasicRelationTermAccess().getReferredAssignment_4_1()); } | ||
8117 | ) | ||
8118 | |||
8119 | ; | ||
8120 | finally { | ||
8121 | restoreStackSize(stackSize); | ||
8122 | } | ||
8123 | |||
8124 | |||
8125 | |||
8126 | |||
8127 | |||
8128 | |||
8129 | rule__ALSBasicRelationTerm__Group_5__0 | ||
8130 | @init { | ||
8131 | int stackSize = keepStackSize(); | ||
8132 | } | ||
8133 | : | ||
8134 | rule__ALSBasicRelationTerm__Group_5__0__Impl | ||
8135 | rule__ALSBasicRelationTerm__Group_5__1 | ||
8136 | ; | ||
8137 | finally { | ||
8138 | restoreStackSize(stackSize); | ||
8139 | } | ||
8140 | |||
8141 | rule__ALSBasicRelationTerm__Group_5__0__Impl | ||
8142 | @init { | ||
8143 | int stackSize = keepStackSize(); | ||
8144 | } | ||
8145 | : | ||
8146 | ( | ||
8147 | { before(grammarAccess.getALSBasicRelationTermAccess().getALSNumberLiteralAction_5_0()); } | ||
8148 | ( | ||
8149 | |||
8150 | ) | ||
8151 | { after(grammarAccess.getALSBasicRelationTermAccess().getALSNumberLiteralAction_5_0()); } | ||
8152 | ) | ||
8153 | |||
8154 | ; | ||
8155 | finally { | ||
8156 | restoreStackSize(stackSize); | ||
8157 | } | ||
8158 | |||
8159 | |||
8160 | rule__ALSBasicRelationTerm__Group_5__1 | ||
8161 | @init { | ||
8162 | int stackSize = keepStackSize(); | ||
8163 | } | ||
8164 | : | ||
8165 | rule__ALSBasicRelationTerm__Group_5__1__Impl | ||
8166 | ; | ||
8167 | finally { | ||
8168 | restoreStackSize(stackSize); | ||
8169 | } | ||
8170 | |||
8171 | rule__ALSBasicRelationTerm__Group_5__1__Impl | ||
8172 | @init { | ||
8173 | int stackSize = keepStackSize(); | ||
8174 | } | ||
8175 | : | ||
8176 | ( | ||
8177 | { before(grammarAccess.getALSBasicRelationTermAccess().getValueAssignment_5_1()); } | ||
8178 | (rule__ALSBasicRelationTerm__ValueAssignment_5_1) | ||
8179 | { after(grammarAccess.getALSBasicRelationTermAccess().getValueAssignment_5_1()); } | ||
8180 | ) | ||
8181 | |||
8182 | ; | ||
8183 | finally { | ||
8184 | restoreStackSize(stackSize); | ||
8185 | } | ||
8186 | |||
8187 | |||
8188 | |||
8189 | |||
8190 | |||
8191 | |||
8192 | rule__ALSBasicRelationTerm__Group_6__0 | ||
8193 | @init { | ||
8194 | int stackSize = keepStackSize(); | ||
8195 | } | ||
8196 | : | ||
8197 | rule__ALSBasicRelationTerm__Group_6__0__Impl | ||
8198 | rule__ALSBasicRelationTerm__Group_6__1 | ||
8199 | ; | ||
8200 | finally { | ||
8201 | restoreStackSize(stackSize); | ||
8202 | } | ||
8203 | |||
8204 | rule__ALSBasicRelationTerm__Group_6__0__Impl | ||
8205 | @init { | ||
8206 | int stackSize = keepStackSize(); | ||
8207 | } | ||
8208 | : | ||
8209 | ( | ||
8210 | { before(grammarAccess.getALSBasicRelationTermAccess().getLeftParenthesisKeyword_6_0()); } | ||
8211 | |||
8212 | '(' | ||
8213 | |||
8214 | { after(grammarAccess.getALSBasicRelationTermAccess().getLeftParenthesisKeyword_6_0()); } | ||
8215 | ) | ||
8216 | |||
8217 | ; | ||
8218 | finally { | ||
8219 | restoreStackSize(stackSize); | ||
8220 | } | ||
8221 | |||
8222 | |||
8223 | rule__ALSBasicRelationTerm__Group_6__1 | ||
8224 | @init { | ||
8225 | int stackSize = keepStackSize(); | ||
8226 | } | ||
8227 | : | ||
8228 | rule__ALSBasicRelationTerm__Group_6__1__Impl | ||
8229 | rule__ALSBasicRelationTerm__Group_6__2 | ||
8230 | ; | ||
8231 | finally { | ||
8232 | restoreStackSize(stackSize); | ||
8233 | } | ||
8234 | |||
8235 | rule__ALSBasicRelationTerm__Group_6__1__Impl | ||
8236 | @init { | ||
8237 | int stackSize = keepStackSize(); | ||
8238 | } | ||
8239 | : | ||
8240 | ( | ||
8241 | { before(grammarAccess.getALSBasicRelationTermAccess().getALSTermParserRuleCall_6_1()); } | ||
8242 | ruleALSTerm | ||
8243 | { after(grammarAccess.getALSBasicRelationTermAccess().getALSTermParserRuleCall_6_1()); } | ||
8244 | ) | ||
8245 | |||
8246 | ; | ||
8247 | finally { | ||
8248 | restoreStackSize(stackSize); | ||
8249 | } | ||
8250 | |||
8251 | |||
8252 | rule__ALSBasicRelationTerm__Group_6__2 | ||
8253 | @init { | ||
8254 | int stackSize = keepStackSize(); | ||
8255 | } | ||
8256 | : | ||
8257 | rule__ALSBasicRelationTerm__Group_6__2__Impl | ||
8258 | ; | ||
8259 | finally { | ||
8260 | restoreStackSize(stackSize); | ||
8261 | } | ||
8262 | |||
8263 | rule__ALSBasicRelationTerm__Group_6__2__Impl | ||
8264 | @init { | ||
8265 | int stackSize = keepStackSize(); | ||
8266 | } | ||
8267 | : | ||
8268 | ( | ||
8269 | { before(grammarAccess.getALSBasicRelationTermAccess().getRightParenthesisKeyword_6_2()); } | ||
8270 | |||
8271 | ')' | ||
8272 | |||
8273 | { after(grammarAccess.getALSBasicRelationTermAccess().getRightParenthesisKeyword_6_2()); } | ||
8274 | ) | ||
8275 | |||
8276 | ; | ||
8277 | finally { | ||
8278 | restoreStackSize(stackSize); | ||
8279 | } | ||
8280 | |||
8281 | |||
8282 | |||
8283 | |||
8284 | |||
8285 | |||
8286 | |||
8287 | |||
8288 | rule__ALSRunCommand__Group__0 | ||
8289 | @init { | ||
8290 | int stackSize = keepStackSize(); | ||
8291 | } | ||
8292 | : | ||
8293 | rule__ALSRunCommand__Group__0__Impl | ||
8294 | rule__ALSRunCommand__Group__1 | ||
8295 | ; | ||
8296 | finally { | ||
8297 | restoreStackSize(stackSize); | ||
8298 | } | ||
8299 | |||
8300 | rule__ALSRunCommand__Group__0__Impl | ||
8301 | @init { | ||
8302 | int stackSize = keepStackSize(); | ||
8303 | } | ||
8304 | : | ||
8305 | ( | ||
8306 | { before(grammarAccess.getALSRunCommandAccess().getALSRunCommandAction_0()); } | ||
8307 | ( | ||
8308 | |||
8309 | ) | ||
8310 | { after(grammarAccess.getALSRunCommandAccess().getALSRunCommandAction_0()); } | ||
8311 | ) | ||
8312 | |||
8313 | ; | ||
8314 | finally { | ||
8315 | restoreStackSize(stackSize); | ||
8316 | } | ||
8317 | |||
8318 | |||
8319 | rule__ALSRunCommand__Group__1 | ||
8320 | @init { | ||
8321 | int stackSize = keepStackSize(); | ||
8322 | } | ||
8323 | : | ||
8324 | rule__ALSRunCommand__Group__1__Impl | ||
8325 | rule__ALSRunCommand__Group__2 | ||
8326 | ; | ||
8327 | finally { | ||
8328 | restoreStackSize(stackSize); | ||
8329 | } | ||
8330 | |||
8331 | rule__ALSRunCommand__Group__1__Impl | ||
8332 | @init { | ||
8333 | int stackSize = keepStackSize(); | ||
8334 | } | ||
8335 | : | ||
8336 | ( | ||
8337 | { before(grammarAccess.getALSRunCommandAccess().getRunKeyword_1()); } | ||
8338 | |||
8339 | 'run' | ||
8340 | |||
8341 | { after(grammarAccess.getALSRunCommandAccess().getRunKeyword_1()); } | ||
8342 | ) | ||
8343 | |||
8344 | ; | ||
8345 | finally { | ||
8346 | restoreStackSize(stackSize); | ||
8347 | } | ||
8348 | |||
8349 | |||
8350 | rule__ALSRunCommand__Group__2 | ||
8351 | @init { | ||
8352 | int stackSize = keepStackSize(); | ||
8353 | } | ||
8354 | : | ||
8355 | rule__ALSRunCommand__Group__2__Impl | ||
8356 | rule__ALSRunCommand__Group__3 | ||
8357 | ; | ||
8358 | finally { | ||
8359 | restoreStackSize(stackSize); | ||
8360 | } | ||
8361 | |||
8362 | rule__ALSRunCommand__Group__2__Impl | ||
8363 | @init { | ||
8364 | int stackSize = keepStackSize(); | ||
8365 | } | ||
8366 | : | ||
8367 | ( | ||
8368 | { before(grammarAccess.getALSRunCommandAccess().getLeftCurlyBracketKeyword_2()); } | ||
8369 | |||
8370 | '{' | ||
8371 | |||
8372 | { after(grammarAccess.getALSRunCommandAccess().getLeftCurlyBracketKeyword_2()); } | ||
8373 | ) | ||
8374 | |||
8375 | ; | ||
8376 | finally { | ||
8377 | restoreStackSize(stackSize); | ||
8378 | } | ||
8379 | |||
8380 | |||
8381 | rule__ALSRunCommand__Group__3 | ||
8382 | @init { | ||
8383 | int stackSize = keepStackSize(); | ||
8384 | } | ||
8385 | : | ||
8386 | rule__ALSRunCommand__Group__3__Impl | ||
8387 | rule__ALSRunCommand__Group__4 | ||
8388 | ; | ||
8389 | finally { | ||
8390 | restoreStackSize(stackSize); | ||
8391 | } | ||
8392 | |||
8393 | rule__ALSRunCommand__Group__3__Impl | ||
8394 | @init { | ||
8395 | int stackSize = keepStackSize(); | ||
8396 | } | ||
8397 | : | ||
8398 | ( | ||
8399 | { before(grammarAccess.getALSRunCommandAccess().getRightCurlyBracketKeyword_3()); } | ||
8400 | |||
8401 | '}' | ||
8402 | |||
8403 | { after(grammarAccess.getALSRunCommandAccess().getRightCurlyBracketKeyword_3()); } | ||
8404 | ) | ||
8405 | |||
8406 | ; | ||
8407 | finally { | ||
8408 | restoreStackSize(stackSize); | ||
8409 | } | ||
8410 | |||
8411 | |||
8412 | rule__ALSRunCommand__Group__4 | ||
8413 | @init { | ||
8414 | int stackSize = keepStackSize(); | ||
8415 | } | ||
8416 | : | ||
8417 | rule__ALSRunCommand__Group__4__Impl | ||
8418 | ; | ||
8419 | finally { | ||
8420 | restoreStackSize(stackSize); | ||
8421 | } | ||
8422 | |||
8423 | rule__ALSRunCommand__Group__4__Impl | ||
8424 | @init { | ||
8425 | int stackSize = keepStackSize(); | ||
8426 | } | ||
8427 | : | ||
8428 | ( | ||
8429 | { before(grammarAccess.getALSRunCommandAccess().getGroup_4()); } | ||
8430 | (rule__ALSRunCommand__Group_4__0)? | ||
8431 | { after(grammarAccess.getALSRunCommandAccess().getGroup_4()); } | ||
8432 | ) | ||
8433 | |||
8434 | ; | ||
8435 | finally { | ||
8436 | restoreStackSize(stackSize); | ||
8437 | } | ||
8438 | |||
8439 | |||
8440 | |||
8441 | |||
8442 | |||
8443 | |||
8444 | |||
8445 | |||
8446 | |||
8447 | |||
8448 | |||
8449 | |||
8450 | rule__ALSRunCommand__Group_4__0 | ||
8451 | @init { | ||
8452 | int stackSize = keepStackSize(); | ||
8453 | } | ||
8454 | : | ||
8455 | rule__ALSRunCommand__Group_4__0__Impl | ||
8456 | rule__ALSRunCommand__Group_4__1 | ||
8457 | ; | ||
8458 | finally { | ||
8459 | restoreStackSize(stackSize); | ||
8460 | } | ||
8461 | |||
8462 | rule__ALSRunCommand__Group_4__0__Impl | ||
8463 | @init { | ||
8464 | int stackSize = keepStackSize(); | ||
8465 | } | ||
8466 | : | ||
8467 | ( | ||
8468 | { before(grammarAccess.getALSRunCommandAccess().getForKeyword_4_0()); } | ||
8469 | |||
8470 | 'for' | ||
8471 | |||
8472 | { after(grammarAccess.getALSRunCommandAccess().getForKeyword_4_0()); } | ||
8473 | ) | ||
8474 | |||
8475 | ; | ||
8476 | finally { | ||
8477 | restoreStackSize(stackSize); | ||
8478 | } | ||
8479 | |||
8480 | |||
8481 | rule__ALSRunCommand__Group_4__1 | ||
8482 | @init { | ||
8483 | int stackSize = keepStackSize(); | ||
8484 | } | ||
8485 | : | ||
8486 | rule__ALSRunCommand__Group_4__1__Impl | ||
8487 | rule__ALSRunCommand__Group_4__2 | ||
8488 | ; | ||
8489 | finally { | ||
8490 | restoreStackSize(stackSize); | ||
8491 | } | ||
8492 | |||
8493 | rule__ALSRunCommand__Group_4__1__Impl | ||
8494 | @init { | ||
8495 | int stackSize = keepStackSize(); | ||
8496 | } | ||
8497 | : | ||
8498 | ( | ||
8499 | { before(grammarAccess.getALSRunCommandAccess().getTypeScopesAssignment_4_1()); } | ||
8500 | (rule__ALSRunCommand__TypeScopesAssignment_4_1) | ||
8501 | { after(grammarAccess.getALSRunCommandAccess().getTypeScopesAssignment_4_1()); } | ||
8502 | ) | ||
8503 | |||
8504 | ; | ||
8505 | finally { | ||
8506 | restoreStackSize(stackSize); | ||
8507 | } | ||
8508 | |||
8509 | |||
8510 | rule__ALSRunCommand__Group_4__2 | ||
8511 | @init { | ||
8512 | int stackSize = keepStackSize(); | ||
8513 | } | ||
8514 | : | ||
8515 | rule__ALSRunCommand__Group_4__2__Impl | ||
8516 | ; | ||
8517 | finally { | ||
8518 | restoreStackSize(stackSize); | ||
8519 | } | ||
8520 | |||
8521 | rule__ALSRunCommand__Group_4__2__Impl | ||
8522 | @init { | ||
8523 | int stackSize = keepStackSize(); | ||
8524 | } | ||
8525 | : | ||
8526 | ( | ||
8527 | { before(grammarAccess.getALSRunCommandAccess().getGroup_4_2()); } | ||
8528 | (rule__ALSRunCommand__Group_4_2__0)* | ||
8529 | { after(grammarAccess.getALSRunCommandAccess().getGroup_4_2()); } | ||
8530 | ) | ||
8531 | |||
8532 | ; | ||
8533 | finally { | ||
8534 | restoreStackSize(stackSize); | ||
8535 | } | ||
8536 | |||
8537 | |||
8538 | |||
8539 | |||
8540 | |||
8541 | |||
8542 | |||
8543 | |||
8544 | rule__ALSRunCommand__Group_4_2__0 | ||
8545 | @init { | ||
8546 | int stackSize = keepStackSize(); | ||
8547 | } | ||
8548 | : | ||
8549 | rule__ALSRunCommand__Group_4_2__0__Impl | ||
8550 | rule__ALSRunCommand__Group_4_2__1 | ||
8551 | ; | ||
8552 | finally { | ||
8553 | restoreStackSize(stackSize); | ||
8554 | } | ||
8555 | |||
8556 | rule__ALSRunCommand__Group_4_2__0__Impl | ||
8557 | @init { | ||
8558 | int stackSize = keepStackSize(); | ||
8559 | } | ||
8560 | : | ||
8561 | ( | ||
8562 | { before(grammarAccess.getALSRunCommandAccess().getCommaKeyword_4_2_0()); } | ||
8563 | |||
8564 | ',' | ||
8565 | |||
8566 | { after(grammarAccess.getALSRunCommandAccess().getCommaKeyword_4_2_0()); } | ||
8567 | ) | ||
8568 | |||
8569 | ; | ||
8570 | finally { | ||
8571 | restoreStackSize(stackSize); | ||
8572 | } | ||
8573 | |||
8574 | |||
8575 | rule__ALSRunCommand__Group_4_2__1 | ||
8576 | @init { | ||
8577 | int stackSize = keepStackSize(); | ||
8578 | } | ||
8579 | : | ||
8580 | rule__ALSRunCommand__Group_4_2__1__Impl | ||
8581 | ; | ||
8582 | finally { | ||
8583 | restoreStackSize(stackSize); | ||
8584 | } | ||
8585 | |||
8586 | rule__ALSRunCommand__Group_4_2__1__Impl | ||
8587 | @init { | ||
8588 | int stackSize = keepStackSize(); | ||
8589 | } | ||
8590 | : | ||
8591 | ( | ||
8592 | { before(grammarAccess.getALSRunCommandAccess().getTypeScopesAssignment_4_2_1()); } | ||
8593 | (rule__ALSRunCommand__TypeScopesAssignment_4_2_1) | ||
8594 | { after(grammarAccess.getALSRunCommandAccess().getTypeScopesAssignment_4_2_1()); } | ||
8595 | ) | ||
8596 | |||
8597 | ; | ||
8598 | finally { | ||
8599 | restoreStackSize(stackSize); | ||
8600 | } | ||
8601 | |||
8602 | |||
8603 | |||
8604 | |||
8605 | |||
8606 | |||
8607 | rule__ALSSigScope__Group__0 | ||
8608 | @init { | ||
8609 | int stackSize = keepStackSize(); | ||
8610 | } | ||
8611 | : | ||
8612 | rule__ALSSigScope__Group__0__Impl | ||
8613 | rule__ALSSigScope__Group__1 | ||
8614 | ; | ||
8615 | finally { | ||
8616 | restoreStackSize(stackSize); | ||
8617 | } | ||
8618 | |||
8619 | rule__ALSSigScope__Group__0__Impl | ||
8620 | @init { | ||
8621 | int stackSize = keepStackSize(); | ||
8622 | } | ||
8623 | : | ||
8624 | ( | ||
8625 | { before(grammarAccess.getALSSigScopeAccess().getExactlyAssignment_0()); } | ||
8626 | (rule__ALSSigScope__ExactlyAssignment_0)? | ||
8627 | { after(grammarAccess.getALSSigScopeAccess().getExactlyAssignment_0()); } | ||
8628 | ) | ||
8629 | |||
8630 | ; | ||
8631 | finally { | ||
8632 | restoreStackSize(stackSize); | ||
8633 | } | ||
8634 | |||
8635 | |||
8636 | rule__ALSSigScope__Group__1 | ||
8637 | @init { | ||
8638 | int stackSize = keepStackSize(); | ||
8639 | } | ||
8640 | : | ||
8641 | rule__ALSSigScope__Group__1__Impl | ||
8642 | rule__ALSSigScope__Group__2 | ||
8643 | ; | ||
8644 | finally { | ||
8645 | restoreStackSize(stackSize); | ||
8646 | } | ||
8647 | |||
8648 | rule__ALSSigScope__Group__1__Impl | ||
8649 | @init { | ||
8650 | int stackSize = keepStackSize(); | ||
8651 | } | ||
8652 | : | ||
8653 | ( | ||
8654 | { before(grammarAccess.getALSSigScopeAccess().getNumberAssignment_1()); } | ||
8655 | (rule__ALSSigScope__NumberAssignment_1) | ||
8656 | { after(grammarAccess.getALSSigScopeAccess().getNumberAssignment_1()); } | ||
8657 | ) | ||
8658 | |||
8659 | ; | ||
8660 | finally { | ||
8661 | restoreStackSize(stackSize); | ||
8662 | } | ||
8663 | |||
8664 | |||
8665 | rule__ALSSigScope__Group__2 | ||
8666 | @init { | ||
8667 | int stackSize = keepStackSize(); | ||
8668 | } | ||
8669 | : | ||
8670 | rule__ALSSigScope__Group__2__Impl | ||
8671 | ; | ||
8672 | finally { | ||
8673 | restoreStackSize(stackSize); | ||
8674 | } | ||
8675 | |||
8676 | rule__ALSSigScope__Group__2__Impl | ||
8677 | @init { | ||
8678 | int stackSize = keepStackSize(); | ||
8679 | } | ||
8680 | : | ||
8681 | ( | ||
8682 | { before(grammarAccess.getALSSigScopeAccess().getTypeAssignment_2()); } | ||
8683 | (rule__ALSSigScope__TypeAssignment_2) | ||
8684 | { after(grammarAccess.getALSSigScopeAccess().getTypeAssignment_2()); } | ||
8685 | ) | ||
8686 | |||
8687 | ; | ||
8688 | finally { | ||
8689 | restoreStackSize(stackSize); | ||
8690 | } | ||
8691 | |||
8692 | |||
8693 | |||
8694 | |||
8695 | |||
8696 | |||
8697 | |||
8698 | |||
8699 | rule__ALSIntScope__Group__0 | ||
8700 | @init { | ||
8701 | int stackSize = keepStackSize(); | ||
8702 | } | ||
8703 | : | ||
8704 | rule__ALSIntScope__Group__0__Impl | ||
8705 | rule__ALSIntScope__Group__1 | ||
8706 | ; | ||
8707 | finally { | ||
8708 | restoreStackSize(stackSize); | ||
8709 | } | ||
8710 | |||
8711 | rule__ALSIntScope__Group__0__Impl | ||
8712 | @init { | ||
8713 | int stackSize = keepStackSize(); | ||
8714 | } | ||
8715 | : | ||
8716 | ( | ||
8717 | { before(grammarAccess.getALSIntScopeAccess().getNumberAssignment_0()); } | ||
8718 | (rule__ALSIntScope__NumberAssignment_0) | ||
8719 | { after(grammarAccess.getALSIntScopeAccess().getNumberAssignment_0()); } | ||
8720 | ) | ||
8721 | |||
8722 | ; | ||
8723 | finally { | ||
8724 | restoreStackSize(stackSize); | ||
8725 | } | ||
8726 | |||
8727 | |||
8728 | rule__ALSIntScope__Group__1 | ||
8729 | @init { | ||
8730 | int stackSize = keepStackSize(); | ||
8731 | } | ||
8732 | : | ||
8733 | rule__ALSIntScope__Group__1__Impl | ||
8734 | ; | ||
8735 | finally { | ||
8736 | restoreStackSize(stackSize); | ||
8737 | } | ||
8738 | |||
8739 | rule__ALSIntScope__Group__1__Impl | ||
8740 | @init { | ||
8741 | int stackSize = keepStackSize(); | ||
8742 | } | ||
8743 | : | ||
8744 | ( | ||
8745 | { before(grammarAccess.getALSIntScopeAccess().getIntKeyword_1()); } | ||
8746 | |||
8747 | 'Int' | ||
8748 | |||
8749 | { after(grammarAccess.getALSIntScopeAccess().getIntKeyword_1()); } | ||
8750 | ) | ||
8751 | |||
8752 | ; | ||
8753 | finally { | ||
8754 | restoreStackSize(stackSize); | ||
8755 | } | ||
8756 | |||
8757 | |||
8758 | |||
8759 | |||
8760 | |||
8761 | |||
8762 | |||
8763 | rule__ALSSignatureBody__UnorderedGroup_0 | ||
8764 | @init { | ||
8765 | int stackSize = keepStackSize(); | ||
8766 | getUnorderedGroupHelper().enter(grammarAccess.getALSSignatureBodyAccess().getUnorderedGroup_0()); | ||
8767 | } | ||
8768 | : | ||
8769 | rule__ALSSignatureBody__UnorderedGroup_0__0 | ||
8770 | ? | ||
8771 | |||
8772 | ; | ||
8773 | finally { | ||
8774 | getUnorderedGroupHelper().leave(grammarAccess.getALSSignatureBodyAccess().getUnorderedGroup_0()); | ||
8775 | restoreStackSize(stackSize); | ||
8776 | } | ||
8777 | |||
8778 | |||
8779 | rule__ALSSignatureBody__UnorderedGroup_0__Impl | ||
8780 | @init { | ||
8781 | int stackSize = keepStackSize(); | ||
8782 | boolean selected = false; | ||
8783 | } | ||
8784 | : | ||
8785 | ( | ||
8786 | |||
8787 | ( | ||
8788 | {getUnorderedGroupHelper().canSelect(grammarAccess.getALSSignatureBodyAccess().getUnorderedGroup_0(), 0)}?=>( | ||
8789 | { | ||
8790 | getUnorderedGroupHelper().select(grammarAccess.getALSSignatureBodyAccess().getUnorderedGroup_0(), 0); | ||
8791 | } | ||
8792 | { | ||
8793 | selected = true; | ||
8794 | } | ||
8795 | ( | ||
8796 | |||
8797 | { before(grammarAccess.getALSSignatureBodyAccess().getMultiplicityAssignment_0_0()); } | ||
8798 | (rule__ALSSignatureBody__MultiplicityAssignment_0_0) | ||
8799 | { after(grammarAccess.getALSSignatureBodyAccess().getMultiplicityAssignment_0_0()); } | ||
8800 | ) | ||
8801 | ) | ||
8802 | ) | | ||
8803 | |||
8804 | ( | ||
8805 | {getUnorderedGroupHelper().canSelect(grammarAccess.getALSSignatureBodyAccess().getUnorderedGroup_0(), 1)}?=>( | ||
8806 | { | ||
8807 | getUnorderedGroupHelper().select(grammarAccess.getALSSignatureBodyAccess().getUnorderedGroup_0(), 1); | ||
8808 | } | ||
8809 | { | ||
8810 | selected = true; | ||
8811 | } | ||
8812 | ( | ||
8813 | |||
8814 | { before(grammarAccess.getALSSignatureBodyAccess().getAbstractAssignment_0_1()); } | ||
8815 | (rule__ALSSignatureBody__AbstractAssignment_0_1) | ||
8816 | { after(grammarAccess.getALSSignatureBodyAccess().getAbstractAssignment_0_1()); } | ||
8817 | ) | ||
8818 | ) | ||
8819 | ) | ||
8820 | |||
8821 | ) | ||
8822 | ; | ||
8823 | finally { | ||
8824 | if (selected) | ||
8825 | getUnorderedGroupHelper().returnFromSelection(grammarAccess.getALSSignatureBodyAccess().getUnorderedGroup_0()); | ||
8826 | restoreStackSize(stackSize); | ||
8827 | } | ||
8828 | |||
8829 | |||
8830 | rule__ALSSignatureBody__UnorderedGroup_0__0 | ||
8831 | @init { | ||
8832 | int stackSize = keepStackSize(); | ||
8833 | } | ||
8834 | : | ||
8835 | rule__ALSSignatureBody__UnorderedGroup_0__Impl | ||
8836 | rule__ALSSignatureBody__UnorderedGroup_0__1? | ||
8837 | ; | ||
8838 | finally { | ||
8839 | restoreStackSize(stackSize); | ||
8840 | } | ||
8841 | |||
8842 | |||
8843 | rule__ALSSignatureBody__UnorderedGroup_0__1 | ||
8844 | @init { | ||
8845 | int stackSize = keepStackSize(); | ||
8846 | } | ||
8847 | : | ||
8848 | rule__ALSSignatureBody__UnorderedGroup_0__Impl | ||
8849 | ; | ||
8850 | finally { | ||
8851 | restoreStackSize(stackSize); | ||
8852 | } | ||
8853 | |||
8854 | |||
8855 | |||
8856 | |||
8857 | |||
8858 | |||
8859 | rule__ALSDocument__EnumDeclarationsAssignment_0_0 | ||
8860 | @init { | ||
8861 | int stackSize = keepStackSize(); | ||
8862 | } | ||
8863 | : | ||
8864 | ( | ||
8865 | { before(grammarAccess.getALSDocumentAccess().getEnumDeclarationsALSEnumDeclarationParserRuleCall_0_0_0()); } | ||
8866 | ruleALSEnumDeclaration{ after(grammarAccess.getALSDocumentAccess().getEnumDeclarationsALSEnumDeclarationParserRuleCall_0_0_0()); } | ||
8867 | ) | ||
8868 | |||
8869 | ; | ||
8870 | finally { | ||
8871 | restoreStackSize(stackSize); | ||
8872 | } | ||
8873 | |||
8874 | rule__ALSDocument__SignatureBodiesAssignment_0_1 | ||
8875 | @init { | ||
8876 | int stackSize = keepStackSize(); | ||
8877 | } | ||
8878 | : | ||
8879 | ( | ||
8880 | { before(grammarAccess.getALSDocumentAccess().getSignatureBodiesALSSignatureBodyParserRuleCall_0_1_0()); } | ||
8881 | ruleALSSignatureBody{ after(grammarAccess.getALSDocumentAccess().getSignatureBodiesALSSignatureBodyParserRuleCall_0_1_0()); } | ||
8882 | ) | ||
8883 | |||
8884 | ; | ||
8885 | finally { | ||
8886 | restoreStackSize(stackSize); | ||
8887 | } | ||
8888 | |||
8889 | rule__ALSDocument__FunctionDefinitionsAssignment_0_2 | ||
8890 | @init { | ||
8891 | int stackSize = keepStackSize(); | ||
8892 | } | ||
8893 | : | ||
8894 | ( | ||
8895 | { before(grammarAccess.getALSDocumentAccess().getFunctionDefinitionsALSFunctionDefinitionParserRuleCall_0_2_0()); } | ||
8896 | ruleALSFunctionDefinition{ after(grammarAccess.getALSDocumentAccess().getFunctionDefinitionsALSFunctionDefinitionParserRuleCall_0_2_0()); } | ||
8897 | ) | ||
8898 | |||
8899 | ; | ||
8900 | finally { | ||
8901 | restoreStackSize(stackSize); | ||
8902 | } | ||
8903 | |||
8904 | rule__ALSDocument__RelationDefinitionsAssignment_0_3 | ||
8905 | @init { | ||
8906 | int stackSize = keepStackSize(); | ||
8907 | } | ||
8908 | : | ||
8909 | ( | ||
8910 | { before(grammarAccess.getALSDocumentAccess().getRelationDefinitionsALSRelationDefinitionParserRuleCall_0_3_0()); } | ||
8911 | ruleALSRelationDefinition{ after(grammarAccess.getALSDocumentAccess().getRelationDefinitionsALSRelationDefinitionParserRuleCall_0_3_0()); } | ||
8912 | ) | ||
8913 | |||
8914 | ; | ||
8915 | finally { | ||
8916 | restoreStackSize(stackSize); | ||
8917 | } | ||
8918 | |||
8919 | rule__ALSDocument__FactDeclarationsAssignment_0_4 | ||
8920 | @init { | ||
8921 | int stackSize = keepStackSize(); | ||
8922 | } | ||
8923 | : | ||
8924 | ( | ||
8925 | { before(grammarAccess.getALSDocumentAccess().getFactDeclarationsALSFactDeclarationParserRuleCall_0_4_0()); } | ||
8926 | ruleALSFactDeclaration{ after(grammarAccess.getALSDocumentAccess().getFactDeclarationsALSFactDeclarationParserRuleCall_0_4_0()); } | ||
8927 | ) | ||
8928 | |||
8929 | ; | ||
8930 | finally { | ||
8931 | restoreStackSize(stackSize); | ||
8932 | } | ||
8933 | |||
8934 | rule__ALSDocument__RunCommandAssignment_1 | ||
8935 | @init { | ||
8936 | int stackSize = keepStackSize(); | ||
8937 | } | ||
8938 | : | ||
8939 | ( | ||
8940 | { before(grammarAccess.getALSDocumentAccess().getRunCommandALSRunCommandParserRuleCall_1_0()); } | ||
8941 | ruleALSRunCommand{ after(grammarAccess.getALSDocumentAccess().getRunCommandALSRunCommandParserRuleCall_1_0()); } | ||
8942 | ) | ||
8943 | |||
8944 | ; | ||
8945 | finally { | ||
8946 | restoreStackSize(stackSize); | ||
8947 | } | ||
8948 | |||
8949 | rule__ALSEnumDeclaration__NameAssignment_1 | ||
8950 | @init { | ||
8951 | int stackSize = keepStackSize(); | ||
8952 | } | ||
8953 | : | ||
8954 | ( | ||
8955 | { before(grammarAccess.getALSEnumDeclarationAccess().getNameALSIDParserRuleCall_1_0()); } | ||
8956 | ruleALSID{ after(grammarAccess.getALSEnumDeclarationAccess().getNameALSIDParserRuleCall_1_0()); } | ||
8957 | ) | ||
8958 | |||
8959 | ; | ||
8960 | finally { | ||
8961 | restoreStackSize(stackSize); | ||
8962 | } | ||
8963 | |||
8964 | rule__ALSEnumDeclaration__LiteralAssignment_3 | ||
8965 | @init { | ||
8966 | int stackSize = keepStackSize(); | ||
8967 | } | ||
8968 | : | ||
8969 | ( | ||
8970 | { before(grammarAccess.getALSEnumDeclarationAccess().getLiteralALSEnumLiteralParserRuleCall_3_0()); } | ||
8971 | ruleALSEnumLiteral{ after(grammarAccess.getALSEnumDeclarationAccess().getLiteralALSEnumLiteralParserRuleCall_3_0()); } | ||
8972 | ) | ||
8973 | |||
8974 | ; | ||
8975 | finally { | ||
8976 | restoreStackSize(stackSize); | ||
8977 | } | ||
8978 | |||
8979 | rule__ALSEnumDeclaration__LiteralAssignment_4_1 | ||
8980 | @init { | ||
8981 | int stackSize = keepStackSize(); | ||
8982 | } | ||
8983 | : | ||
8984 | ( | ||
8985 | { before(grammarAccess.getALSEnumDeclarationAccess().getLiteralALSEnumLiteralParserRuleCall_4_1_0()); } | ||
8986 | ruleALSEnumLiteral{ after(grammarAccess.getALSEnumDeclarationAccess().getLiteralALSEnumLiteralParserRuleCall_4_1_0()); } | ||
8987 | ) | ||
8988 | |||
8989 | ; | ||
8990 | finally { | ||
8991 | restoreStackSize(stackSize); | ||
8992 | } | ||
8993 | |||
8994 | rule__ALSEnumLiteral__NameAssignment | ||
8995 | @init { | ||
8996 | int stackSize = keepStackSize(); | ||
8997 | } | ||
8998 | : | ||
8999 | ( | ||
9000 | { before(grammarAccess.getALSEnumLiteralAccess().getNameALSIDParserRuleCall_0()); } | ||
9001 | ruleALSID{ after(grammarAccess.getALSEnumLiteralAccess().getNameALSIDParserRuleCall_0()); } | ||
9002 | ) | ||
9003 | |||
9004 | ; | ||
9005 | finally { | ||
9006 | restoreStackSize(stackSize); | ||
9007 | } | ||
9008 | |||
9009 | rule__ALSSignatureDeclaration__NameAssignment | ||
9010 | @init { | ||
9011 | int stackSize = keepStackSize(); | ||
9012 | } | ||
9013 | : | ||
9014 | ( | ||
9015 | { before(grammarAccess.getALSSignatureDeclarationAccess().getNameALSIDParserRuleCall_0()); } | ||
9016 | ruleALSID{ after(grammarAccess.getALSSignatureDeclarationAccess().getNameALSIDParserRuleCall_0()); } | ||
9017 | ) | ||
9018 | |||
9019 | ; | ||
9020 | finally { | ||
9021 | restoreStackSize(stackSize); | ||
9022 | } | ||
9023 | |||
9024 | rule__ALSSignatureBody__MultiplicityAssignment_0_0 | ||
9025 | @init { | ||
9026 | int stackSize = keepStackSize(); | ||
9027 | } | ||
9028 | : | ||
9029 | ( | ||
9030 | { before(grammarAccess.getALSSignatureBodyAccess().getMultiplicityALSMultiplicityEnumRuleCall_0_0_0()); } | ||
9031 | ruleALSMultiplicity{ after(grammarAccess.getALSSignatureBodyAccess().getMultiplicityALSMultiplicityEnumRuleCall_0_0_0()); } | ||
9032 | ) | ||
9033 | |||
9034 | ; | ||
9035 | finally { | ||
9036 | restoreStackSize(stackSize); | ||
9037 | } | ||
9038 | |||
9039 | rule__ALSSignatureBody__AbstractAssignment_0_1 | ||
9040 | @init { | ||
9041 | int stackSize = keepStackSize(); | ||
9042 | } | ||
9043 | : | ||
9044 | ( | ||
9045 | { before(grammarAccess.getALSSignatureBodyAccess().getAbstractAbstractKeyword_0_1_0()); } | ||
9046 | ( | ||
9047 | { before(grammarAccess.getALSSignatureBodyAccess().getAbstractAbstractKeyword_0_1_0()); } | ||
9048 | |||
9049 | 'abstract' | ||
9050 | |||
9051 | { after(grammarAccess.getALSSignatureBodyAccess().getAbstractAbstractKeyword_0_1_0()); } | ||
9052 | ) | ||
9053 | |||
9054 | { after(grammarAccess.getALSSignatureBodyAccess().getAbstractAbstractKeyword_0_1_0()); } | ||
9055 | ) | ||
9056 | |||
9057 | ; | ||
9058 | finally { | ||
9059 | restoreStackSize(stackSize); | ||
9060 | } | ||
9061 | |||
9062 | rule__ALSSignatureBody__DeclarationsAssignment_2 | ||
9063 | @init { | ||
9064 | int stackSize = keepStackSize(); | ||
9065 | } | ||
9066 | : | ||
9067 | ( | ||
9068 | { before(grammarAccess.getALSSignatureBodyAccess().getDeclarationsALSSignatureDeclarationParserRuleCall_2_0()); } | ||
9069 | ruleALSSignatureDeclaration{ after(grammarAccess.getALSSignatureBodyAccess().getDeclarationsALSSignatureDeclarationParserRuleCall_2_0()); } | ||
9070 | ) | ||
9071 | |||
9072 | ; | ||
9073 | finally { | ||
9074 | restoreStackSize(stackSize); | ||
9075 | } | ||
9076 | |||
9077 | rule__ALSSignatureBody__DeclarationsAssignment_3_1 | ||
9078 | @init { | ||
9079 | int stackSize = keepStackSize(); | ||
9080 | } | ||
9081 | : | ||
9082 | ( | ||
9083 | { before(grammarAccess.getALSSignatureBodyAccess().getDeclarationsALSSignatureDeclarationParserRuleCall_3_1_0()); } | ||
9084 | ruleALSSignatureDeclaration{ after(grammarAccess.getALSSignatureBodyAccess().getDeclarationsALSSignatureDeclarationParserRuleCall_3_1_0()); } | ||
9085 | ) | ||
9086 | |||
9087 | ; | ||
9088 | finally { | ||
9089 | restoreStackSize(stackSize); | ||
9090 | } | ||
9091 | |||
9092 | rule__ALSSignatureBody__SupertypeAssignment_4_0_1 | ||
9093 | @init { | ||
9094 | int stackSize = keepStackSize(); | ||
9095 | } | ||
9096 | : | ||
9097 | ( | ||
9098 | { before(grammarAccess.getALSSignatureBodyAccess().getSupertypeALSSignatureDeclarationCrossReference_4_0_1_0()); } | ||
9099 | ( | ||
9100 | { before(grammarAccess.getALSSignatureBodyAccess().getSupertypeALSSignatureDeclarationIDTerminalRuleCall_4_0_1_0_1()); } | ||
9101 | RULE_ID{ after(grammarAccess.getALSSignatureBodyAccess().getSupertypeALSSignatureDeclarationIDTerminalRuleCall_4_0_1_0_1()); } | ||
9102 | ) | ||
9103 | { after(grammarAccess.getALSSignatureBodyAccess().getSupertypeALSSignatureDeclarationCrossReference_4_0_1_0()); } | ||
9104 | ) | ||
9105 | |||
9106 | ; | ||
9107 | finally { | ||
9108 | restoreStackSize(stackSize); | ||
9109 | } | ||
9110 | |||
9111 | rule__ALSSignatureBody__SupersetAssignment_4_1_1 | ||
9112 | @init { | ||
9113 | int stackSize = keepStackSize(); | ||
9114 | } | ||
9115 | : | ||
9116 | ( | ||
9117 | { before(grammarAccess.getALSSignatureBodyAccess().getSupersetALSSignatureDeclarationCrossReference_4_1_1_0()); } | ||
9118 | ( | ||
9119 | { before(grammarAccess.getALSSignatureBodyAccess().getSupersetALSSignatureDeclarationIDTerminalRuleCall_4_1_1_0_1()); } | ||
9120 | RULE_ID{ after(grammarAccess.getALSSignatureBodyAccess().getSupersetALSSignatureDeclarationIDTerminalRuleCall_4_1_1_0_1()); } | ||
9121 | ) | ||
9122 | { after(grammarAccess.getALSSignatureBodyAccess().getSupersetALSSignatureDeclarationCrossReference_4_1_1_0()); } | ||
9123 | ) | ||
9124 | |||
9125 | ; | ||
9126 | finally { | ||
9127 | restoreStackSize(stackSize); | ||
9128 | } | ||
9129 | |||
9130 | rule__ALSSignatureBody__SupersetAssignment_4_1_2_1 | ||
9131 | @init { | ||
9132 | int stackSize = keepStackSize(); | ||
9133 | } | ||
9134 | : | ||
9135 | ( | ||
9136 | { before(grammarAccess.getALSSignatureBodyAccess().getSupersetALSSignatureDeclarationCrossReference_4_1_2_1_0()); } | ||
9137 | ( | ||
9138 | { before(grammarAccess.getALSSignatureBodyAccess().getSupersetALSSignatureDeclarationIDTerminalRuleCall_4_1_2_1_0_1()); } | ||
9139 | RULE_ID{ after(grammarAccess.getALSSignatureBodyAccess().getSupersetALSSignatureDeclarationIDTerminalRuleCall_4_1_2_1_0_1()); } | ||
9140 | ) | ||
9141 | { after(grammarAccess.getALSSignatureBodyAccess().getSupersetALSSignatureDeclarationCrossReference_4_1_2_1_0()); } | ||
9142 | ) | ||
9143 | |||
9144 | ; | ||
9145 | finally { | ||
9146 | restoreStackSize(stackSize); | ||
9147 | } | ||
9148 | |||
9149 | rule__ALSSignatureBody__FieldsAssignment_6_0 | ||
9150 | @init { | ||
9151 | int stackSize = keepStackSize(); | ||
9152 | } | ||
9153 | : | ||
9154 | ( | ||
9155 | { before(grammarAccess.getALSSignatureBodyAccess().getFieldsALSFieldDeclarationParserRuleCall_6_0_0()); } | ||
9156 | ruleALSFieldDeclaration{ after(grammarAccess.getALSSignatureBodyAccess().getFieldsALSFieldDeclarationParserRuleCall_6_0_0()); } | ||
9157 | ) | ||
9158 | |||
9159 | ; | ||
9160 | finally { | ||
9161 | restoreStackSize(stackSize); | ||
9162 | } | ||
9163 | |||
9164 | rule__ALSSignatureBody__FieldsAssignment_6_1_1 | ||
9165 | @init { | ||
9166 | int stackSize = keepStackSize(); | ||
9167 | } | ||
9168 | : | ||
9169 | ( | ||
9170 | { before(grammarAccess.getALSSignatureBodyAccess().getFieldsALSFieldDeclarationParserRuleCall_6_1_1_0()); } | ||
9171 | ruleALSFieldDeclaration{ after(grammarAccess.getALSSignatureBodyAccess().getFieldsALSFieldDeclarationParserRuleCall_6_1_1_0()); } | ||
9172 | ) | ||
9173 | |||
9174 | ; | ||
9175 | finally { | ||
9176 | restoreStackSize(stackSize); | ||
9177 | } | ||
9178 | |||
9179 | rule__ALSFieldDeclaration__NameAssignment_0 | ||
9180 | @init { | ||
9181 | int stackSize = keepStackSize(); | ||
9182 | } | ||
9183 | : | ||
9184 | ( | ||
9185 | { before(grammarAccess.getALSFieldDeclarationAccess().getNameALSIDParserRuleCall_0_0()); } | ||
9186 | ruleALSID{ after(grammarAccess.getALSFieldDeclarationAccess().getNameALSIDParserRuleCall_0_0()); } | ||
9187 | ) | ||
9188 | |||
9189 | ; | ||
9190 | finally { | ||
9191 | restoreStackSize(stackSize); | ||
9192 | } | ||
9193 | |||
9194 | rule__ALSFieldDeclaration__MultiplicityAssignment_2 | ||
9195 | @init { | ||
9196 | int stackSize = keepStackSize(); | ||
9197 | } | ||
9198 | : | ||
9199 | ( | ||
9200 | { before(grammarAccess.getALSFieldDeclarationAccess().getMultiplicityALSMultiplicityEnumRuleCall_2_0()); } | ||
9201 | ruleALSMultiplicity{ after(grammarAccess.getALSFieldDeclarationAccess().getMultiplicityALSMultiplicityEnumRuleCall_2_0()); } | ||
9202 | ) | ||
9203 | |||
9204 | ; | ||
9205 | finally { | ||
9206 | restoreStackSize(stackSize); | ||
9207 | } | ||
9208 | |||
9209 | rule__ALSFieldDeclaration__TypeAssignment_3 | ||
9210 | @init { | ||
9211 | int stackSize = keepStackSize(); | ||
9212 | } | ||
9213 | : | ||
9214 | ( | ||
9215 | { before(grammarAccess.getALSFieldDeclarationAccess().getTypeALSTermParserRuleCall_3_0()); } | ||
9216 | ruleALSTerm{ after(grammarAccess.getALSFieldDeclarationAccess().getTypeALSTermParserRuleCall_3_0()); } | ||
9217 | ) | ||
9218 | |||
9219 | ; | ||
9220 | finally { | ||
9221 | restoreStackSize(stackSize); | ||
9222 | } | ||
9223 | |||
9224 | rule__ALSFunctionDefinition__NameAssignment_1 | ||
9225 | @init { | ||
9226 | int stackSize = keepStackSize(); | ||
9227 | } | ||
9228 | : | ||
9229 | ( | ||
9230 | { before(grammarAccess.getALSFunctionDefinitionAccess().getNameALSIDParserRuleCall_1_0()); } | ||
9231 | ruleALSID{ after(grammarAccess.getALSFunctionDefinitionAccess().getNameALSIDParserRuleCall_1_0()); } | ||
9232 | ) | ||
9233 | |||
9234 | ; | ||
9235 | finally { | ||
9236 | restoreStackSize(stackSize); | ||
9237 | } | ||
9238 | |||
9239 | rule__ALSFunctionDefinition__VariablesAssignment_3 | ||
9240 | @init { | ||
9241 | int stackSize = keepStackSize(); | ||
9242 | } | ||
9243 | : | ||
9244 | ( | ||
9245 | { before(grammarAccess.getALSFunctionDefinitionAccess().getVariablesALSVariableDeclarationParserRuleCall_3_0()); } | ||
9246 | ruleALSVariableDeclaration{ after(grammarAccess.getALSFunctionDefinitionAccess().getVariablesALSVariableDeclarationParserRuleCall_3_0()); } | ||
9247 | ) | ||
9248 | |||
9249 | ; | ||
9250 | finally { | ||
9251 | restoreStackSize(stackSize); | ||
9252 | } | ||
9253 | |||
9254 | rule__ALSFunctionDefinition__VariablesAssignment_4_1 | ||
9255 | @init { | ||
9256 | int stackSize = keepStackSize(); | ||
9257 | } | ||
9258 | : | ||
9259 | ( | ||
9260 | { before(grammarAccess.getALSFunctionDefinitionAccess().getVariablesALSVariableDeclarationParserRuleCall_4_1_0()); } | ||
9261 | ruleALSVariableDeclaration{ after(grammarAccess.getALSFunctionDefinitionAccess().getVariablesALSVariableDeclarationParserRuleCall_4_1_0()); } | ||
9262 | ) | ||
9263 | |||
9264 | ; | ||
9265 | finally { | ||
9266 | restoreStackSize(stackSize); | ||
9267 | } | ||
9268 | |||
9269 | rule__ALSFunctionDefinition__TypeAssignment_7 | ||
9270 | @init { | ||
9271 | int stackSize = keepStackSize(); | ||
9272 | } | ||
9273 | : | ||
9274 | ( | ||
9275 | { before(grammarAccess.getALSFunctionDefinitionAccess().getTypeALSTermParserRuleCall_7_0()); } | ||
9276 | ruleALSTerm{ after(grammarAccess.getALSFunctionDefinitionAccess().getTypeALSTermParserRuleCall_7_0()); } | ||
9277 | ) | ||
9278 | |||
9279 | ; | ||
9280 | finally { | ||
9281 | restoreStackSize(stackSize); | ||
9282 | } | ||
9283 | |||
9284 | rule__ALSFunctionDefinition__ValueAssignment_9 | ||
9285 | @init { | ||
9286 | int stackSize = keepStackSize(); | ||
9287 | } | ||
9288 | : | ||
9289 | ( | ||
9290 | { before(grammarAccess.getALSFunctionDefinitionAccess().getValueALSTermParserRuleCall_9_0()); } | ||
9291 | ruleALSTerm{ after(grammarAccess.getALSFunctionDefinitionAccess().getValueALSTermParserRuleCall_9_0()); } | ||
9292 | ) | ||
9293 | |||
9294 | ; | ||
9295 | finally { | ||
9296 | restoreStackSize(stackSize); | ||
9297 | } | ||
9298 | |||
9299 | rule__ALSRelationDefinition__NameAssignment_1 | ||
9300 | @init { | ||
9301 | int stackSize = keepStackSize(); | ||
9302 | } | ||
9303 | : | ||
9304 | ( | ||
9305 | { before(grammarAccess.getALSRelationDefinitionAccess().getNameALSIDParserRuleCall_1_0()); } | ||
9306 | ruleALSID{ after(grammarAccess.getALSRelationDefinitionAccess().getNameALSIDParserRuleCall_1_0()); } | ||
9307 | ) | ||
9308 | |||
9309 | ; | ||
9310 | finally { | ||
9311 | restoreStackSize(stackSize); | ||
9312 | } | ||
9313 | |||
9314 | rule__ALSRelationDefinition__VariablesAssignment_3 | ||
9315 | @init { | ||
9316 | int stackSize = keepStackSize(); | ||
9317 | } | ||
9318 | : | ||
9319 | ( | ||
9320 | { before(grammarAccess.getALSRelationDefinitionAccess().getVariablesALSVariableDeclarationParserRuleCall_3_0()); } | ||
9321 | ruleALSVariableDeclaration{ after(grammarAccess.getALSRelationDefinitionAccess().getVariablesALSVariableDeclarationParserRuleCall_3_0()); } | ||
9322 | ) | ||
9323 | |||
9324 | ; | ||
9325 | finally { | ||
9326 | restoreStackSize(stackSize); | ||
9327 | } | ||
9328 | |||
9329 | rule__ALSRelationDefinition__VariablesAssignment_4_1 | ||
9330 | @init { | ||
9331 | int stackSize = keepStackSize(); | ||
9332 | } | ||
9333 | : | ||
9334 | ( | ||
9335 | { before(grammarAccess.getALSRelationDefinitionAccess().getVariablesALSVariableDeclarationParserRuleCall_4_1_0()); } | ||
9336 | ruleALSVariableDeclaration{ after(grammarAccess.getALSRelationDefinitionAccess().getVariablesALSVariableDeclarationParserRuleCall_4_1_0()); } | ||
9337 | ) | ||
9338 | |||
9339 | ; | ||
9340 | finally { | ||
9341 | restoreStackSize(stackSize); | ||
9342 | } | ||
9343 | |||
9344 | rule__ALSRelationDefinition__ValueAssignment_7 | ||
9345 | @init { | ||
9346 | int stackSize = keepStackSize(); | ||
9347 | } | ||
9348 | : | ||
9349 | ( | ||
9350 | { before(grammarAccess.getALSRelationDefinitionAccess().getValueALSTermParserRuleCall_7_0()); } | ||
9351 | ruleALSTerm{ after(grammarAccess.getALSRelationDefinitionAccess().getValueALSTermParserRuleCall_7_0()); } | ||
9352 | ) | ||
9353 | |||
9354 | ; | ||
9355 | finally { | ||
9356 | restoreStackSize(stackSize); | ||
9357 | } | ||
9358 | |||
9359 | rule__ALSFactDeclaration__NameAssignment_2 | ||
9360 | @init { | ||
9361 | int stackSize = keepStackSize(); | ||
9362 | } | ||
9363 | : | ||
9364 | ( | ||
9365 | { before(grammarAccess.getALSFactDeclarationAccess().getNameALSIDParserRuleCall_2_0()); } | ||
9366 | ruleALSID{ after(grammarAccess.getALSFactDeclarationAccess().getNameALSIDParserRuleCall_2_0()); } | ||
9367 | ) | ||
9368 | |||
9369 | ; | ||
9370 | finally { | ||
9371 | restoreStackSize(stackSize); | ||
9372 | } | ||
9373 | |||
9374 | rule__ALSFactDeclaration__TermAssignment_4 | ||
9375 | @init { | ||
9376 | int stackSize = keepStackSize(); | ||
9377 | } | ||
9378 | : | ||
9379 | ( | ||
9380 | { before(grammarAccess.getALSFactDeclarationAccess().getTermALSTermParserRuleCall_4_0()); } | ||
9381 | ruleALSTerm{ after(grammarAccess.getALSFactDeclarationAccess().getTermALSTermParserRuleCall_4_0()); } | ||
9382 | ) | ||
9383 | |||
9384 | ; | ||
9385 | finally { | ||
9386 | restoreStackSize(stackSize); | ||
9387 | } | ||
9388 | |||
9389 | rule__ALSQuantified__TypeAssignment_0_1 | ||
9390 | @init { | ||
9391 | int stackSize = keepStackSize(); | ||
9392 | } | ||
9393 | : | ||
9394 | ( | ||
9395 | { before(grammarAccess.getALSQuantifiedAccess().getTypeALSMultiplicityEnumRuleCall_0_1_0()); } | ||
9396 | ruleALSMultiplicity{ after(grammarAccess.getALSQuantifiedAccess().getTypeALSMultiplicityEnumRuleCall_0_1_0()); } | ||
9397 | ) | ||
9398 | |||
9399 | ; | ||
9400 | finally { | ||
9401 | restoreStackSize(stackSize); | ||
9402 | } | ||
9403 | |||
9404 | rule__ALSQuantified__DisjAssignment_0_2 | ||
9405 | @init { | ||
9406 | int stackSize = keepStackSize(); | ||
9407 | } | ||
9408 | : | ||
9409 | ( | ||
9410 | { before(grammarAccess.getALSQuantifiedAccess().getDisjDisjKeyword_0_2_0()); } | ||
9411 | ( | ||
9412 | { before(grammarAccess.getALSQuantifiedAccess().getDisjDisjKeyword_0_2_0()); } | ||
9413 | |||
9414 | 'disj' | ||
9415 | |||
9416 | { after(grammarAccess.getALSQuantifiedAccess().getDisjDisjKeyword_0_2_0()); } | ||
9417 | ) | ||
9418 | |||
9419 | { after(grammarAccess.getALSQuantifiedAccess().getDisjDisjKeyword_0_2_0()); } | ||
9420 | ) | ||
9421 | |||
9422 | ; | ||
9423 | finally { | ||
9424 | restoreStackSize(stackSize); | ||
9425 | } | ||
9426 | |||
9427 | rule__ALSQuantified__VariablesAssignment_0_3 | ||
9428 | @init { | ||
9429 | int stackSize = keepStackSize(); | ||
9430 | } | ||
9431 | : | ||
9432 | ( | ||
9433 | { before(grammarAccess.getALSQuantifiedAccess().getVariablesALSVariableDeclarationParserRuleCall_0_3_0()); } | ||
9434 | ruleALSVariableDeclaration{ after(grammarAccess.getALSQuantifiedAccess().getVariablesALSVariableDeclarationParserRuleCall_0_3_0()); } | ||
9435 | ) | ||
9436 | |||
9437 | ; | ||
9438 | finally { | ||
9439 | restoreStackSize(stackSize); | ||
9440 | } | ||
9441 | |||
9442 | rule__ALSQuantified__VariablesAssignment_0_4_1 | ||
9443 | @init { | ||
9444 | int stackSize = keepStackSize(); | ||
9445 | } | ||
9446 | : | ||
9447 | ( | ||
9448 | { before(grammarAccess.getALSQuantifiedAccess().getVariablesALSVariableDeclarationParserRuleCall_0_4_1_0()); } | ||
9449 | ruleALSVariableDeclaration{ after(grammarAccess.getALSQuantifiedAccess().getVariablesALSVariableDeclarationParserRuleCall_0_4_1_0()); } | ||
9450 | ) | ||
9451 | |||
9452 | ; | ||
9453 | finally { | ||
9454 | restoreStackSize(stackSize); | ||
9455 | } | ||
9456 | |||
9457 | rule__ALSQuantified__ExpressionAssignment_0_6 | ||
9458 | @init { | ||
9459 | int stackSize = keepStackSize(); | ||
9460 | } | ||
9461 | : | ||
9462 | ( | ||
9463 | { before(grammarAccess.getALSQuantifiedAccess().getExpressionALSTermParserRuleCall_0_6_0()); } | ||
9464 | ruleALSTerm{ after(grammarAccess.getALSQuantifiedAccess().getExpressionALSTermParserRuleCall_0_6_0()); } | ||
9465 | ) | ||
9466 | |||
9467 | ; | ||
9468 | finally { | ||
9469 | restoreStackSize(stackSize); | ||
9470 | } | ||
9471 | |||
9472 | rule__ALSOr__RightOperandAssignment_1_2 | ||
9473 | @init { | ||
9474 | int stackSize = keepStackSize(); | ||
9475 | } | ||
9476 | : | ||
9477 | ( | ||
9478 | { before(grammarAccess.getALSOrAccess().getRightOperandALSIffParserRuleCall_1_2_0()); } | ||
9479 | ruleALSIff{ after(grammarAccess.getALSOrAccess().getRightOperandALSIffParserRuleCall_1_2_0()); } | ||
9480 | ) | ||
9481 | |||
9482 | ; | ||
9483 | finally { | ||
9484 | restoreStackSize(stackSize); | ||
9485 | } | ||
9486 | |||
9487 | rule__ALSIff__RightOperandAssignment_1_2 | ||
9488 | @init { | ||
9489 | int stackSize = keepStackSize(); | ||
9490 | } | ||
9491 | : | ||
9492 | ( | ||
9493 | { before(grammarAccess.getALSIffAccess().getRightOperandALSImplParserRuleCall_1_2_0()); } | ||
9494 | ruleALSImpl{ after(grammarAccess.getALSIffAccess().getRightOperandALSImplParserRuleCall_1_2_0()); } | ||
9495 | ) | ||
9496 | |||
9497 | ; | ||
9498 | finally { | ||
9499 | restoreStackSize(stackSize); | ||
9500 | } | ||
9501 | |||
9502 | rule__ALSImpl__RightOperandAssignment_1_2 | ||
9503 | @init { | ||
9504 | int stackSize = keepStackSize(); | ||
9505 | } | ||
9506 | : | ||
9507 | ( | ||
9508 | { before(grammarAccess.getALSImplAccess().getRightOperandALSAndParserRuleCall_1_2_0()); } | ||
9509 | ruleALSAnd{ after(grammarAccess.getALSImplAccess().getRightOperandALSAndParserRuleCall_1_2_0()); } | ||
9510 | ) | ||
9511 | |||
9512 | ; | ||
9513 | finally { | ||
9514 | restoreStackSize(stackSize); | ||
9515 | } | ||
9516 | |||
9517 | rule__ALSImpl__ElseOperandAssignment_1_3_1 | ||
9518 | @init { | ||
9519 | int stackSize = keepStackSize(); | ||
9520 | } | ||
9521 | : | ||
9522 | ( | ||
9523 | { before(grammarAccess.getALSImplAccess().getElseOperandALSAndParserRuleCall_1_3_1_0()); } | ||
9524 | ruleALSAnd{ after(grammarAccess.getALSImplAccess().getElseOperandALSAndParserRuleCall_1_3_1_0()); } | ||
9525 | ) | ||
9526 | |||
9527 | ; | ||
9528 | finally { | ||
9529 | restoreStackSize(stackSize); | ||
9530 | } | ||
9531 | |||
9532 | rule__ALSAnd__RightOperandAssignment_1_2 | ||
9533 | @init { | ||
9534 | int stackSize = keepStackSize(); | ||
9535 | } | ||
9536 | : | ||
9537 | ( | ||
9538 | { before(grammarAccess.getALSAndAccess().getRightOperandALSComparisonParserRuleCall_1_2_0()); } | ||
9539 | ruleALSComparison{ after(grammarAccess.getALSAndAccess().getRightOperandALSComparisonParserRuleCall_1_2_0()); } | ||
9540 | ) | ||
9541 | |||
9542 | ; | ||
9543 | finally { | ||
9544 | restoreStackSize(stackSize); | ||
9545 | } | ||
9546 | |||
9547 | rule__ALSComparison__RightOperandAssignment_1_1 | ||
9548 | @init { | ||
9549 | int stackSize = keepStackSize(); | ||
9550 | } | ||
9551 | : | ||
9552 | ( | ||
9553 | { before(grammarAccess.getALSComparisonAccess().getRightOperandALSOverrideParserRuleCall_1_1_0()); } | ||
9554 | ruleALSOverride{ after(grammarAccess.getALSComparisonAccess().getRightOperandALSOverrideParserRuleCall_1_1_0()); } | ||
9555 | ) | ||
9556 | |||
9557 | ; | ||
9558 | finally { | ||
9559 | restoreStackSize(stackSize); | ||
9560 | } | ||
9561 | |||
9562 | rule__ALSOverride__RightOperandAssignment_1_2 | ||
9563 | @init { | ||
9564 | int stackSize = keepStackSize(); | ||
9565 | } | ||
9566 | : | ||
9567 | ( | ||
9568 | { before(grammarAccess.getALSOverrideAccess().getRightOperandALSRangeRestrictionRightParserRuleCall_1_2_0()); } | ||
9569 | ruleALSRangeRestrictionRight{ after(grammarAccess.getALSOverrideAccess().getRightOperandALSRangeRestrictionRightParserRuleCall_1_2_0()); } | ||
9570 | ) | ||
9571 | |||
9572 | ; | ||
9573 | finally { | ||
9574 | restoreStackSize(stackSize); | ||
9575 | } | ||
9576 | |||
9577 | rule__ALSRangeRestrictionRight__FilterAssignment_1_2 | ||
9578 | @init { | ||
9579 | int stackSize = keepStackSize(); | ||
9580 | } | ||
9581 | : | ||
9582 | ( | ||
9583 | { before(grammarAccess.getALSRangeRestrictionRightAccess().getFilterALSRangeRestrictionLeftParserRuleCall_1_2_0()); } | ||
9584 | ruleALSRangeRestrictionLeft{ after(grammarAccess.getALSRangeRestrictionRightAccess().getFilterALSRangeRestrictionLeftParserRuleCall_1_2_0()); } | ||
9585 | ) | ||
9586 | |||
9587 | ; | ||
9588 | finally { | ||
9589 | restoreStackSize(stackSize); | ||
9590 | } | ||
9591 | |||
9592 | rule__ALSRangeRestrictionLeft__RelationAssignment_1_2 | ||
9593 | @init { | ||
9594 | int stackSize = keepStackSize(); | ||
9595 | } | ||
9596 | : | ||
9597 | ( | ||
9598 | { before(grammarAccess.getALSRangeRestrictionLeftAccess().getRelationALSJoinParserRuleCall_1_2_0()); } | ||
9599 | ruleALSJoin{ after(grammarAccess.getALSRangeRestrictionLeftAccess().getRelationALSJoinParserRuleCall_1_2_0()); } | ||
9600 | ) | ||
9601 | |||
9602 | ; | ||
9603 | finally { | ||
9604 | restoreStackSize(stackSize); | ||
9605 | } | ||
9606 | |||
9607 | rule__ALSJoin__RightOperandAssignment_1_2 | ||
9608 | @init { | ||
9609 | int stackSize = keepStackSize(); | ||
9610 | } | ||
9611 | : | ||
9612 | ( | ||
9613 | { before(grammarAccess.getALSJoinAccess().getRightOperandALSMinusParserRuleCall_1_2_0()); } | ||
9614 | ruleALSMinus{ after(grammarAccess.getALSJoinAccess().getRightOperandALSMinusParserRuleCall_1_2_0()); } | ||
9615 | ) | ||
9616 | |||
9617 | ; | ||
9618 | finally { | ||
9619 | restoreStackSize(stackSize); | ||
9620 | } | ||
9621 | |||
9622 | rule__ALSMinus__RightOperandAssignment_1_2 | ||
9623 | @init { | ||
9624 | int stackSize = keepStackSize(); | ||
9625 | } | ||
9626 | : | ||
9627 | ( | ||
9628 | { before(grammarAccess.getALSMinusAccess().getRightOperandALSPlusParserRuleCall_1_2_0()); } | ||
9629 | ruleALSPlus{ after(grammarAccess.getALSMinusAccess().getRightOperandALSPlusParserRuleCall_1_2_0()); } | ||
9630 | ) | ||
9631 | |||
9632 | ; | ||
9633 | finally { | ||
9634 | restoreStackSize(stackSize); | ||
9635 | } | ||
9636 | |||
9637 | rule__ALSPlus__RightOperandAssignment_1_2 | ||
9638 | @init { | ||
9639 | int stackSize = keepStackSize(); | ||
9640 | } | ||
9641 | : | ||
9642 | ( | ||
9643 | { before(grammarAccess.getALSPlusAccess().getRightOperandALSIntersectionParserRuleCall_1_2_0()); } | ||
9644 | ruleALSIntersection{ after(grammarAccess.getALSPlusAccess().getRightOperandALSIntersectionParserRuleCall_1_2_0()); } | ||
9645 | ) | ||
9646 | |||
9647 | ; | ||
9648 | finally { | ||
9649 | restoreStackSize(stackSize); | ||
9650 | } | ||
9651 | |||
9652 | rule__ALSIntersection__RightOperandAssignment_1_2 | ||
9653 | @init { | ||
9654 | int stackSize = keepStackSize(); | ||
9655 | } | ||
9656 | : | ||
9657 | ( | ||
9658 | { before(grammarAccess.getALSIntersectionAccess().getRightOperandALSDirectProductParserRuleCall_1_2_0()); } | ||
9659 | ruleALSDirectProduct{ after(grammarAccess.getALSIntersectionAccess().getRightOperandALSDirectProductParserRuleCall_1_2_0()); } | ||
9660 | ) | ||
9661 | |||
9662 | ; | ||
9663 | finally { | ||
9664 | restoreStackSize(stackSize); | ||
9665 | } | ||
9666 | |||
9667 | rule__ALSDirectProduct__LeftMultiplicitAssignment_1_1 | ||
9668 | @init { | ||
9669 | int stackSize = keepStackSize(); | ||
9670 | } | ||
9671 | : | ||
9672 | ( | ||
9673 | { before(grammarAccess.getALSDirectProductAccess().getLeftMultiplicitALSMultiplicityEnumRuleCall_1_1_0()); } | ||
9674 | ruleALSMultiplicity{ after(grammarAccess.getALSDirectProductAccess().getLeftMultiplicitALSMultiplicityEnumRuleCall_1_1_0()); } | ||
9675 | ) | ||
9676 | |||
9677 | ; | ||
9678 | finally { | ||
9679 | restoreStackSize(stackSize); | ||
9680 | } | ||
9681 | |||
9682 | rule__ALSDirectProduct__RightMultiplicitAssignment_1_3 | ||
9683 | @init { | ||
9684 | int stackSize = keepStackSize(); | ||
9685 | } | ||
9686 | : | ||
9687 | ( | ||
9688 | { before(grammarAccess.getALSDirectProductAccess().getRightMultiplicitALSMultiplicityEnumRuleCall_1_3_0()); } | ||
9689 | ruleALSMultiplicity{ after(grammarAccess.getALSDirectProductAccess().getRightMultiplicitALSMultiplicityEnumRuleCall_1_3_0()); } | ||
9690 | ) | ||
9691 | |||
9692 | ; | ||
9693 | finally { | ||
9694 | restoreStackSize(stackSize); | ||
9695 | } | ||
9696 | |||
9697 | rule__ALSDirectProduct__RightOperandAssignment_1_4 | ||
9698 | @init { | ||
9699 | int stackSize = keepStackSize(); | ||
9700 | } | ||
9701 | : | ||
9702 | ( | ||
9703 | { before(grammarAccess.getALSDirectProductAccess().getRightOperandALSPreficedParserRuleCall_1_4_0()); } | ||
9704 | ruleALSPreficed{ after(grammarAccess.getALSDirectProductAccess().getRightOperandALSPreficedParserRuleCall_1_4_0()); } | ||
9705 | ) | ||
9706 | |||
9707 | ; | ||
9708 | finally { | ||
9709 | restoreStackSize(stackSize); | ||
9710 | } | ||
9711 | |||
9712 | rule__ALSPreficed__OperandAssignment_0_2 | ||
9713 | @init { | ||
9714 | int stackSize = keepStackSize(); | ||
9715 | } | ||
9716 | : | ||
9717 | ( | ||
9718 | { before(grammarAccess.getALSPreficedAccess().getOperandALSBasicRelationTermParserRuleCall_0_2_0()); } | ||
9719 | ruleALSBasicRelationTerm{ after(grammarAccess.getALSPreficedAccess().getOperandALSBasicRelationTermParserRuleCall_0_2_0()); } | ||
9720 | ) | ||
9721 | |||
9722 | ; | ||
9723 | finally { | ||
9724 | restoreStackSize(stackSize); | ||
9725 | } | ||
9726 | |||
9727 | rule__ALSPreficed__OperandAssignment_1_2 | ||
9728 | @init { | ||
9729 | int stackSize = keepStackSize(); | ||
9730 | } | ||
9731 | : | ||
9732 | ( | ||
9733 | { before(grammarAccess.getALSPreficedAccess().getOperandALSBasicRelationTermParserRuleCall_1_2_0()); } | ||
9734 | ruleALSBasicRelationTerm{ after(grammarAccess.getALSPreficedAccess().getOperandALSBasicRelationTermParserRuleCall_1_2_0()); } | ||
9735 | ) | ||
9736 | |||
9737 | ; | ||
9738 | finally { | ||
9739 | restoreStackSize(stackSize); | ||
9740 | } | ||
9741 | |||
9742 | rule__ALSPreficed__OperandAssignment_2_2 | ||
9743 | @init { | ||
9744 | int stackSize = keepStackSize(); | ||
9745 | } | ||
9746 | : | ||
9747 | ( | ||
9748 | { before(grammarAccess.getALSPreficedAccess().getOperandALSBasicRelationTermParserRuleCall_2_2_0()); } | ||
9749 | ruleALSBasicRelationTerm{ after(grammarAccess.getALSPreficedAccess().getOperandALSBasicRelationTermParserRuleCall_2_2_0()); } | ||
9750 | ) | ||
9751 | |||
9752 | ; | ||
9753 | finally { | ||
9754 | restoreStackSize(stackSize); | ||
9755 | } | ||
9756 | |||
9757 | rule__ALSPreficed__OperandAssignment_3_2 | ||
9758 | @init { | ||
9759 | int stackSize = keepStackSize(); | ||
9760 | } | ||
9761 | : | ||
9762 | ( | ||
9763 | { before(grammarAccess.getALSPreficedAccess().getOperandALSBasicRelationTermParserRuleCall_3_2_0()); } | ||
9764 | ruleALSBasicRelationTerm{ after(grammarAccess.getALSPreficedAccess().getOperandALSBasicRelationTermParserRuleCall_3_2_0()); } | ||
9765 | ) | ||
9766 | |||
9767 | ; | ||
9768 | finally { | ||
9769 | restoreStackSize(stackSize); | ||
9770 | } | ||
9771 | |||
9772 | rule__ALSPreficed__OperandAssignment_4_2 | ||
9773 | @init { | ||
9774 | int stackSize = keepStackSize(); | ||
9775 | } | ||
9776 | : | ||
9777 | ( | ||
9778 | { before(grammarAccess.getALSPreficedAccess().getOperandALSBasicRelationTermParserRuleCall_4_2_0()); } | ||
9779 | ruleALSBasicRelationTerm{ after(grammarAccess.getALSPreficedAccess().getOperandALSBasicRelationTermParserRuleCall_4_2_0()); } | ||
9780 | ) | ||
9781 | |||
9782 | ; | ||
9783 | finally { | ||
9784 | restoreStackSize(stackSize); | ||
9785 | } | ||
9786 | |||
9787 | rule__ALSPreficed__OperandAssignment_5_2 | ||
9788 | @init { | ||
9789 | int stackSize = keepStackSize(); | ||
9790 | } | ||
9791 | : | ||
9792 | ( | ||
9793 | { before(grammarAccess.getALSPreficedAccess().getOperandALSBasicRelationTermParserRuleCall_5_2_0()); } | ||
9794 | ruleALSBasicRelationTerm{ after(grammarAccess.getALSPreficedAccess().getOperandALSBasicRelationTermParserRuleCall_5_2_0()); } | ||
9795 | ) | ||
9796 | |||
9797 | ; | ||
9798 | finally { | ||
9799 | restoreStackSize(stackSize); | ||
9800 | } | ||
9801 | |||
9802 | rule__ALSPreficed__VariablesAssignment_6_2 | ||
9803 | @init { | ||
9804 | int stackSize = keepStackSize(); | ||
9805 | } | ||
9806 | : | ||
9807 | ( | ||
9808 | { before(grammarAccess.getALSPreficedAccess().getVariablesALSVariableDeclarationParserRuleCall_6_2_0()); } | ||
9809 | ruleALSVariableDeclaration{ after(grammarAccess.getALSPreficedAccess().getVariablesALSVariableDeclarationParserRuleCall_6_2_0()); } | ||
9810 | ) | ||
9811 | |||
9812 | ; | ||
9813 | finally { | ||
9814 | restoreStackSize(stackSize); | ||
9815 | } | ||
9816 | |||
9817 | rule__ALSPreficed__VariablesAssignment_6_3_1 | ||
9818 | @init { | ||
9819 | int stackSize = keepStackSize(); | ||
9820 | } | ||
9821 | : | ||
9822 | ( | ||
9823 | { before(grammarAccess.getALSPreficedAccess().getVariablesALSVariableDeclarationParserRuleCall_6_3_1_0()); } | ||
9824 | ruleALSVariableDeclaration{ after(grammarAccess.getALSPreficedAccess().getVariablesALSVariableDeclarationParserRuleCall_6_3_1_0()); } | ||
9825 | ) | ||
9826 | |||
9827 | ; | ||
9828 | finally { | ||
9829 | restoreStackSize(stackSize); | ||
9830 | } | ||
9831 | |||
9832 | rule__ALSPreficed__ExpressionAssignment_6_5 | ||
9833 | @init { | ||
9834 | int stackSize = keepStackSize(); | ||
9835 | } | ||
9836 | : | ||
9837 | ( | ||
9838 | { before(grammarAccess.getALSPreficedAccess().getExpressionALSTermParserRuleCall_6_5_0()); } | ||
9839 | ruleALSTerm{ after(grammarAccess.getALSPreficedAccess().getExpressionALSTermParserRuleCall_6_5_0()); } | ||
9840 | ) | ||
9841 | |||
9842 | ; | ||
9843 | finally { | ||
9844 | restoreStackSize(stackSize); | ||
9845 | } | ||
9846 | |||
9847 | rule__ALSPreficed__ReferredDefinitionAssignment_7_1_0 | ||
9848 | @init { | ||
9849 | int stackSize = keepStackSize(); | ||
9850 | } | ||
9851 | : | ||
9852 | ( | ||
9853 | { before(grammarAccess.getALSPreficedAccess().getReferredDefinitionALSDefinitionCrossReference_7_1_0_0()); } | ||
9854 | ( | ||
9855 | { before(grammarAccess.getALSPreficedAccess().getReferredDefinitionALSDefinitionIDTerminalRuleCall_7_1_0_0_1()); } | ||
9856 | RULE_ID{ after(grammarAccess.getALSPreficedAccess().getReferredDefinitionALSDefinitionIDTerminalRuleCall_7_1_0_0_1()); } | ||
9857 | ) | ||
9858 | { after(grammarAccess.getALSPreficedAccess().getReferredDefinitionALSDefinitionCrossReference_7_1_0_0()); } | ||
9859 | ) | ||
9860 | |||
9861 | ; | ||
9862 | finally { | ||
9863 | restoreStackSize(stackSize); | ||
9864 | } | ||
9865 | |||
9866 | rule__ALSPreficed__ReferredNumericOperatorAssignment_7_1_1 | ||
9867 | @init { | ||
9868 | int stackSize = keepStackSize(); | ||
9869 | } | ||
9870 | : | ||
9871 | ( | ||
9872 | { before(grammarAccess.getALSPreficedAccess().getReferredNumericOperatorALSNumericOperatorEnumRuleCall_7_1_1_0()); } | ||
9873 | ruleALSNumericOperator{ after(grammarAccess.getALSPreficedAccess().getReferredNumericOperatorALSNumericOperatorEnumRuleCall_7_1_1_0()); } | ||
9874 | ) | ||
9875 | |||
9876 | ; | ||
9877 | finally { | ||
9878 | restoreStackSize(stackSize); | ||
9879 | } | ||
9880 | |||
9881 | rule__ALSPreficed__ParamsAssignment_7_3 | ||
9882 | @init { | ||
9883 | int stackSize = keepStackSize(); | ||
9884 | } | ||
9885 | : | ||
9886 | ( | ||
9887 | { before(grammarAccess.getALSPreficedAccess().getParamsALSTermParserRuleCall_7_3_0()); } | ||
9888 | ruleALSTerm{ after(grammarAccess.getALSPreficedAccess().getParamsALSTermParserRuleCall_7_3_0()); } | ||
9889 | ) | ||
9890 | |||
9891 | ; | ||
9892 | finally { | ||
9893 | restoreStackSize(stackSize); | ||
9894 | } | ||
9895 | |||
9896 | rule__ALSPreficed__ParamsAssignment_7_4_1 | ||
9897 | @init { | ||
9898 | int stackSize = keepStackSize(); | ||
9899 | } | ||
9900 | : | ||
9901 | ( | ||
9902 | { before(grammarAccess.getALSPreficedAccess().getParamsALSTermParserRuleCall_7_4_1_0()); } | ||
9903 | ruleALSTerm{ after(grammarAccess.getALSPreficedAccess().getParamsALSTermParserRuleCall_7_4_1_0()); } | ||
9904 | ) | ||
9905 | |||
9906 | ; | ||
9907 | finally { | ||
9908 | restoreStackSize(stackSize); | ||
9909 | } | ||
9910 | |||
9911 | rule__ALSVariableDeclaration__NameAssignment_0 | ||
9912 | @init { | ||
9913 | int stackSize = keepStackSize(); | ||
9914 | } | ||
9915 | : | ||
9916 | ( | ||
9917 | { before(grammarAccess.getALSVariableDeclarationAccess().getNameALSIDParserRuleCall_0_0()); } | ||
9918 | ruleALSID{ after(grammarAccess.getALSVariableDeclarationAccess().getNameALSIDParserRuleCall_0_0()); } | ||
9919 | ) | ||
9920 | |||
9921 | ; | ||
9922 | finally { | ||
9923 | restoreStackSize(stackSize); | ||
9924 | } | ||
9925 | |||
9926 | rule__ALSVariableDeclaration__RangeAssignment_2 | ||
9927 | @init { | ||
9928 | int stackSize = keepStackSize(); | ||
9929 | } | ||
9930 | : | ||
9931 | ( | ||
9932 | { before(grammarAccess.getALSVariableDeclarationAccess().getRangeALSTermParserRuleCall_2_0()); } | ||
9933 | ruleALSTerm{ after(grammarAccess.getALSVariableDeclarationAccess().getRangeALSTermParserRuleCall_2_0()); } | ||
9934 | ) | ||
9935 | |||
9936 | ; | ||
9937 | finally { | ||
9938 | restoreStackSize(stackSize); | ||
9939 | } | ||
9940 | |||
9941 | rule__ALSBasicRelationTerm__ReferredAssignment_4_1 | ||
9942 | @init { | ||
9943 | int stackSize = keepStackSize(); | ||
9944 | } | ||
9945 | : | ||
9946 | ( | ||
9947 | { before(grammarAccess.getALSBasicRelationTermAccess().getReferredALSRelationDeclarationCrossReference_4_1_0()); } | ||
9948 | ( | ||
9949 | { before(grammarAccess.getALSBasicRelationTermAccess().getReferredALSRelationDeclarationIDTerminalRuleCall_4_1_0_1()); } | ||
9950 | RULE_ID{ after(grammarAccess.getALSBasicRelationTermAccess().getReferredALSRelationDeclarationIDTerminalRuleCall_4_1_0_1()); } | ||
9951 | ) | ||
9952 | { after(grammarAccess.getALSBasicRelationTermAccess().getReferredALSRelationDeclarationCrossReference_4_1_0()); } | ||
9953 | ) | ||
9954 | |||
9955 | ; | ||
9956 | finally { | ||
9957 | restoreStackSize(stackSize); | ||
9958 | } | ||
9959 | |||
9960 | rule__ALSBasicRelationTerm__ValueAssignment_5_1 | ||
9961 | @init { | ||
9962 | int stackSize = keepStackSize(); | ||
9963 | } | ||
9964 | : | ||
9965 | ( | ||
9966 | { before(grammarAccess.getALSBasicRelationTermAccess().getValueINTTerminalRuleCall_5_1_0()); } | ||
9967 | RULE_INT{ after(grammarAccess.getALSBasicRelationTermAccess().getValueINTTerminalRuleCall_5_1_0()); } | ||
9968 | ) | ||
9969 | |||
9970 | ; | ||
9971 | finally { | ||
9972 | restoreStackSize(stackSize); | ||
9973 | } | ||
9974 | |||
9975 | rule__ALSRunCommand__TypeScopesAssignment_4_1 | ||
9976 | @init { | ||
9977 | int stackSize = keepStackSize(); | ||
9978 | } | ||
9979 | : | ||
9980 | ( | ||
9981 | { before(grammarAccess.getALSRunCommandAccess().getTypeScopesALSTypeScopeParserRuleCall_4_1_0()); } | ||
9982 | ruleALSTypeScope{ after(grammarAccess.getALSRunCommandAccess().getTypeScopesALSTypeScopeParserRuleCall_4_1_0()); } | ||
9983 | ) | ||
9984 | |||
9985 | ; | ||
9986 | finally { | ||
9987 | restoreStackSize(stackSize); | ||
9988 | } | ||
9989 | |||
9990 | rule__ALSRunCommand__TypeScopesAssignment_4_2_1 | ||
9991 | @init { | ||
9992 | int stackSize = keepStackSize(); | ||
9993 | } | ||
9994 | : | ||
9995 | ( | ||
9996 | { before(grammarAccess.getALSRunCommandAccess().getTypeScopesALSTypeScopeParserRuleCall_4_2_1_0()); } | ||
9997 | ruleALSTypeScope{ after(grammarAccess.getALSRunCommandAccess().getTypeScopesALSTypeScopeParserRuleCall_4_2_1_0()); } | ||
9998 | ) | ||
9999 | |||
10000 | ; | ||
10001 | finally { | ||
10002 | restoreStackSize(stackSize); | ||
10003 | } | ||
10004 | |||
10005 | rule__ALSSigScope__ExactlyAssignment_0 | ||
10006 | @init { | ||
10007 | int stackSize = keepStackSize(); | ||
10008 | } | ||
10009 | : | ||
10010 | ( | ||
10011 | { before(grammarAccess.getALSSigScopeAccess().getExactlyExactlyKeyword_0_0()); } | ||
10012 | ( | ||
10013 | { before(grammarAccess.getALSSigScopeAccess().getExactlyExactlyKeyword_0_0()); } | ||
10014 | |||
10015 | 'exactly' | ||
10016 | |||
10017 | { after(grammarAccess.getALSSigScopeAccess().getExactlyExactlyKeyword_0_0()); } | ||
10018 | ) | ||
10019 | |||
10020 | { after(grammarAccess.getALSSigScopeAccess().getExactlyExactlyKeyword_0_0()); } | ||
10021 | ) | ||
10022 | |||
10023 | ; | ||
10024 | finally { | ||
10025 | restoreStackSize(stackSize); | ||
10026 | } | ||
10027 | |||
10028 | rule__ALSSigScope__NumberAssignment_1 | ||
10029 | @init { | ||
10030 | int stackSize = keepStackSize(); | ||
10031 | } | ||
10032 | : | ||
10033 | ( | ||
10034 | { before(grammarAccess.getALSSigScopeAccess().getNumberINTTerminalRuleCall_1_0()); } | ||
10035 | RULE_INT{ after(grammarAccess.getALSSigScopeAccess().getNumberINTTerminalRuleCall_1_0()); } | ||
10036 | ) | ||
10037 | |||
10038 | ; | ||
10039 | finally { | ||
10040 | restoreStackSize(stackSize); | ||
10041 | } | ||
10042 | |||
10043 | rule__ALSSigScope__TypeAssignment_2 | ||
10044 | @init { | ||
10045 | int stackSize = keepStackSize(); | ||
10046 | } | ||
10047 | : | ||
10048 | ( | ||
10049 | { before(grammarAccess.getALSSigScopeAccess().getTypeALSSignatureDeclarationCrossReference_2_0()); } | ||
10050 | ( | ||
10051 | { before(grammarAccess.getALSSigScopeAccess().getTypeALSSignatureDeclarationIDTerminalRuleCall_2_0_1()); } | ||
10052 | RULE_ID{ after(grammarAccess.getALSSigScopeAccess().getTypeALSSignatureDeclarationIDTerminalRuleCall_2_0_1()); } | ||
10053 | ) | ||
10054 | { after(grammarAccess.getALSSigScopeAccess().getTypeALSSignatureDeclarationCrossReference_2_0()); } | ||
10055 | ) | ||
10056 | |||
10057 | ; | ||
10058 | finally { | ||
10059 | restoreStackSize(stackSize); | ||
10060 | } | ||
10061 | |||
10062 | rule__ALSIntScope__NumberAssignment_0 | ||
10063 | @init { | ||
10064 | int stackSize = keepStackSize(); | ||
10065 | } | ||
10066 | : | ||
10067 | ( | ||
10068 | { before(grammarAccess.getALSIntScopeAccess().getNumberINTTerminalRuleCall_0_0()); } | ||
10069 | RULE_INT{ after(grammarAccess.getALSIntScopeAccess().getNumberINTTerminalRuleCall_0_0()); } | ||
10070 | ) | ||
10071 | |||
10072 | ; | ||
10073 | finally { | ||
10074 | restoreStackSize(stackSize); | ||
10075 | } | ||
10076 | |||
10077 | |||
10078 | RULE_ID : ('a'..'z'|'A'..'Z'|'_') ('a'..'z'|'A'..'Z'|'_'|'\''|'"'|'0'..'9')*; | ||
10079 | |||
10080 | RULE_INT : ('0'..'9')+; | ||
10081 | |||
10082 | RULE_STRING : ('"' ('\\' .|~(('\\'|'"')))* '"'|'\'' ('\\' .|~(('\\'|'\'')))* '\''); | ||
10083 | |||
10084 | RULE_ML_COMMENT : '/*' ( options {greedy=false;} : . )*'*/'; | ||
10085 | |||
10086 | RULE_SL_COMMENT : '//' ~(('\n'|'\r'))* ('\r'? '\n')?; | ||
10087 | |||
10088 | RULE_WS : (' '|'\t'|'\r'|'\n')+; | ||
10089 | |||
10090 | RULE_ANY_OTHER : .; | ||
10091 | |||
10092 | |||
diff --git a/Solvers/Alloy-Solver/hu.bme.mit.inf.dslreasoner.alloy.language.ui/src-gen/hu/bme/mit/inf/dslreasoner/ui/contentassist/antlr/internal/InternalAlloyLanguage.tokens b/Solvers/Alloy-Solver/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..4b2cb3c8 --- /dev/null +++ b/Solvers/Alloy-Solver/hu.bme.mit.inf.dslreasoner.alloy.language.ui/src-gen/hu/bme/mit/inf/dslreasoner/ui/contentassist/antlr/internal/InternalAlloyLanguage.tokens | |||
@@ -0,0 +1,137 @@ | |||
1 | '!'=19 | ||
2 | '!='=48 | ||
3 | '#'=63 | ||
4 | '&&'=17 | ||
5 | '&'=58 | ||
6 | '('=69 | ||
7 | ')'=70 | ||
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 | '['=42 | ||
27 | ']'=43 | ||
28 | '^'=61 | ||
29 | 'abstract'=73 | ||
30 | 'all'=21 | ||
31 | 'and'=18 | ||
32 | 'disj'=74 | ||
33 | 'div'=31 | ||
34 | 'else'=46 | ||
35 | 'enum'=32 | ||
36 | 'exactly'=75 | ||
37 | 'extends'=37 | ||
38 | 'fact'=45 | ||
39 | 'for'=72 | ||
40 | 'fun'=41 | ||
41 | 'iden'=66 | ||
42 | 'iff'=14 | ||
43 | 'implies'=16 | ||
44 | 'in'=38 | ||
45 | 'lone'=24 | ||
46 | 'mul'=29 | ||
47 | 'no'=22 | ||
48 | 'none'=65 | ||
49 | 'not'=20 | ||
50 | 'one'=25 | ||
51 | 'or'=12 | ||
52 | 'plus'=27 | ||
53 | 'pred'=44 | ||
54 | 'rem'=30 | ||
55 | 'run'=71 | ||
56 | 'set'=26 | ||
57 | 'sig'=36 | ||
58 | 'some'=23 | ||
59 | 'sub'=28 | ||
60 | 'sum'=64 | ||
61 | 'univ'=67 | ||
62 | '{'=33 | ||
63 | '||'=11 | ||
64 | '}'=34 | ||
65 | '~'=60 | ||
66 | RULE_ANY_OTHER=10 | ||
67 | RULE_ID=4 | ||
68 | RULE_INT=5 | ||
69 | RULE_ML_COMMENT=7 | ||
70 | RULE_SL_COMMENT=8 | ||
71 | RULE_STRING=6 | ||
72 | RULE_WS=9 | ||
73 | T__11=11 | ||
74 | T__12=12 | ||
75 | T__13=13 | ||
76 | T__14=14 | ||
77 | T__15=15 | ||
78 | T__16=16 | ||
79 | T__17=17 | ||
80 | T__18=18 | ||
81 | T__19=19 | ||
82 | T__20=20 | ||
83 | T__21=21 | ||
84 | T__22=22 | ||
85 | T__23=23 | ||
86 | T__24=24 | ||
87 | T__25=25 | ||
88 | T__26=26 | ||
89 | T__27=27 | ||
90 | T__28=28 | ||
91 | T__29=29 | ||
92 | T__30=30 | ||
93 | T__31=31 | ||
94 | T__32=32 | ||
95 | T__33=33 | ||
96 | T__34=34 | ||
97 | T__35=35 | ||
98 | T__36=36 | ||
99 | T__37=37 | ||
100 | T__38=38 | ||
101 | T__39=39 | ||
102 | T__40=40 | ||
103 | T__41=41 | ||
104 | T__42=42 | ||
105 | T__43=43 | ||
106 | T__44=44 | ||
107 | T__45=45 | ||
108 | T__46=46 | ||
109 | T__47=47 | ||
110 | T__48=48 | ||
111 | T__49=49 | ||
112 | T__50=50 | ||
113 | T__51=51 | ||
114 | T__52=52 | ||
115 | T__53=53 | ||
116 | T__54=54 | ||
117 | T__55=55 | ||
118 | T__56=56 | ||
119 | T__57=57 | ||
120 | T__58=58 | ||
121 | T__59=59 | ||
122 | T__60=60 | ||
123 | T__61=61 | ||
124 | T__62=62 | ||
125 | T__63=63 | ||
126 | T__64=64 | ||
127 | T__65=65 | ||
128 | T__66=66 | ||
129 | T__67=67 | ||
130 | T__68=68 | ||
131 | T__69=69 | ||
132 | T__70=70 | ||
133 | T__71=71 | ||
134 | T__72=72 | ||
135 | T__73=73 | ||
136 | T__74=74 | ||
137 | T__75=75 | ||
diff --git a/Solvers/Alloy-Solver/hu.bme.mit.inf.dslreasoner.alloy.language.ui/src-gen/hu/bme/mit/inf/dslreasoner/ui/contentassist/antlr/internal/InternalAlloyLanguageLexer.java b/Solvers/Alloy-Solver/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..3009516a --- /dev/null +++ b/Solvers/Alloy-Solver/hu.bme.mit.inf.dslreasoner.alloy.language.ui/src-gen/hu/bme/mit/inf/dslreasoner/ui/contentassist/antlr/internal/InternalAlloyLanguageLexer.java | |||
@@ -0,0 +1,2816 @@ | |||
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 RULE_WS=9; | ||
77 | public static final int RULE_ANY_OTHER=10; | ||
78 | public static final int T__48=48; | ||
79 | public static final int T__49=49; | ||
80 | public static final int T__44=44; | ||
81 | public static final int T__45=45; | ||
82 | public static final int T__46=46; | ||
83 | public static final int T__47=47; | ||
84 | public static final int T__40=40; | ||
85 | public static final int T__41=41; | ||
86 | public static final int T__42=42; | ||
87 | public static final int T__43=43; | ||
88 | |||
89 | // delegates | ||
90 | // delegators | ||
91 | |||
92 | public InternalAlloyLanguageLexer() {;} | ||
93 | public InternalAlloyLanguageLexer(CharStream input) { | ||
94 | this(input, new RecognizerSharedState()); | ||
95 | } | ||
96 | public InternalAlloyLanguageLexer(CharStream input, RecognizerSharedState state) { | ||
97 | super(input,state); | ||
98 | |||
99 | } | ||
100 | public String getGrammarFileName() { return "InternalAlloyLanguage.g"; } | ||
101 | |||
102 | // $ANTLR start "T__11" | ||
103 | public final void mT__11() throws RecognitionException { | ||
104 | try { | ||
105 | int _type = T__11; | ||
106 | int _channel = DEFAULT_TOKEN_CHANNEL; | ||
107 | // InternalAlloyLanguage.g:11:7: ( '||' ) | ||
108 | // InternalAlloyLanguage.g:11:9: '||' | ||
109 | { | ||
110 | match("||"); | ||
111 | |||
112 | |||
113 | } | ||
114 | |||
115 | state.type = _type; | ||
116 | state.channel = _channel; | ||
117 | } | ||
118 | finally { | ||
119 | } | ||
120 | } | ||
121 | // $ANTLR end "T__11" | ||
122 | |||
123 | // $ANTLR start "T__12" | ||
124 | public final void mT__12() throws RecognitionException { | ||
125 | try { | ||
126 | int _type = T__12; | ||
127 | int _channel = DEFAULT_TOKEN_CHANNEL; | ||
128 | // InternalAlloyLanguage.g:12:7: ( 'or' ) | ||
129 | // InternalAlloyLanguage.g:12:9: 'or' | ||
130 | { | ||
131 | match("or"); | ||
132 | |||
133 | |||
134 | } | ||
135 | |||
136 | state.type = _type; | ||
137 | state.channel = _channel; | ||
138 | } | ||
139 | finally { | ||
140 | } | ||
141 | } | ||
142 | // $ANTLR end "T__12" | ||
143 | |||
144 | // $ANTLR start "T__13" | ||
145 | public final void mT__13() throws RecognitionException { | ||
146 | try { | ||
147 | int _type = T__13; | ||
148 | int _channel = DEFAULT_TOKEN_CHANNEL; | ||
149 | // InternalAlloyLanguage.g:13:7: ( '<=>' ) | ||
150 | // InternalAlloyLanguage.g:13:9: '<=>' | ||
151 | { | ||
152 | match("<=>"); | ||
153 | |||
154 | |||
155 | } | ||
156 | |||
157 | state.type = _type; | ||
158 | state.channel = _channel; | ||
159 | } | ||
160 | finally { | ||
161 | } | ||
162 | } | ||
163 | // $ANTLR end "T__13" | ||
164 | |||
165 | // $ANTLR start "T__14" | ||
166 | public final void mT__14() throws RecognitionException { | ||
167 | try { | ||
168 | int _type = T__14; | ||
169 | int _channel = DEFAULT_TOKEN_CHANNEL; | ||
170 | // InternalAlloyLanguage.g:14:7: ( 'iff' ) | ||
171 | // InternalAlloyLanguage.g:14:9: 'iff' | ||
172 | { | ||
173 | match("iff"); | ||
174 | |||
175 | |||
176 | } | ||
177 | |||
178 | state.type = _type; | ||
179 | state.channel = _channel; | ||
180 | } | ||
181 | finally { | ||
182 | } | ||
183 | } | ||
184 | // $ANTLR end "T__14" | ||
185 | |||
186 | // $ANTLR start "T__15" | ||
187 | public final void mT__15() throws RecognitionException { | ||
188 | try { | ||
189 | int _type = T__15; | ||
190 | int _channel = DEFAULT_TOKEN_CHANNEL; | ||
191 | // InternalAlloyLanguage.g:15:7: ( '=>' ) | ||
192 | // InternalAlloyLanguage.g:15:9: '=>' | ||
193 | { | ||
194 | match("=>"); | ||
195 | |||
196 | |||
197 | } | ||
198 | |||
199 | state.type = _type; | ||
200 | state.channel = _channel; | ||
201 | } | ||
202 | finally { | ||
203 | } | ||
204 | } | ||
205 | // $ANTLR end "T__15" | ||
206 | |||
207 | // $ANTLR start "T__16" | ||
208 | public final void mT__16() throws RecognitionException { | ||
209 | try { | ||
210 | int _type = T__16; | ||
211 | int _channel = DEFAULT_TOKEN_CHANNEL; | ||
212 | // InternalAlloyLanguage.g:16:7: ( 'implies' ) | ||
213 | // InternalAlloyLanguage.g:16:9: 'implies' | ||
214 | { | ||
215 | match("implies"); | ||
216 | |||
217 | |||
218 | } | ||
219 | |||
220 | state.type = _type; | ||
221 | state.channel = _channel; | ||
222 | } | ||
223 | finally { | ||
224 | } | ||
225 | } | ||
226 | // $ANTLR end "T__16" | ||
227 | |||
228 | // $ANTLR start "T__17" | ||
229 | public final void mT__17() throws RecognitionException { | ||
230 | try { | ||
231 | int _type = T__17; | ||
232 | int _channel = DEFAULT_TOKEN_CHANNEL; | ||
233 | // InternalAlloyLanguage.g:17:7: ( '&&' ) | ||
234 | // InternalAlloyLanguage.g:17:9: '&&' | ||
235 | { | ||
236 | match("&&"); | ||
237 | |||
238 | |||
239 | } | ||
240 | |||
241 | state.type = _type; | ||
242 | state.channel = _channel; | ||
243 | } | ||
244 | finally { | ||
245 | } | ||
246 | } | ||
247 | // $ANTLR end "T__17" | ||
248 | |||
249 | // $ANTLR start "T__18" | ||
250 | public final void mT__18() throws RecognitionException { | ||
251 | try { | ||
252 | int _type = T__18; | ||
253 | int _channel = DEFAULT_TOKEN_CHANNEL; | ||
254 | // InternalAlloyLanguage.g:18:7: ( 'and' ) | ||
255 | // InternalAlloyLanguage.g:18:9: 'and' | ||
256 | { | ||
257 | match("and"); | ||
258 | |||
259 | |||
260 | } | ||
261 | |||
262 | state.type = _type; | ||
263 | state.channel = _channel; | ||
264 | } | ||
265 | finally { | ||
266 | } | ||
267 | } | ||
268 | // $ANTLR end "T__18" | ||
269 | |||
270 | // $ANTLR start "T__19" | ||
271 | public final void mT__19() throws RecognitionException { | ||
272 | try { | ||
273 | int _type = T__19; | ||
274 | int _channel = DEFAULT_TOKEN_CHANNEL; | ||
275 | // InternalAlloyLanguage.g:19:7: ( '!' ) | ||
276 | // InternalAlloyLanguage.g:19:9: '!' | ||
277 | { | ||
278 | match('!'); | ||
279 | |||
280 | } | ||
281 | |||
282 | state.type = _type; | ||
283 | state.channel = _channel; | ||
284 | } | ||
285 | finally { | ||
286 | } | ||
287 | } | ||
288 | // $ANTLR end "T__19" | ||
289 | |||
290 | // $ANTLR start "T__20" | ||
291 | public final void mT__20() throws RecognitionException { | ||
292 | try { | ||
293 | int _type = T__20; | ||
294 | int _channel = DEFAULT_TOKEN_CHANNEL; | ||
295 | // InternalAlloyLanguage.g:20:7: ( 'not' ) | ||
296 | // InternalAlloyLanguage.g:20:9: 'not' | ||
297 | { | ||
298 | match("not"); | ||
299 | |||
300 | |||
301 | } | ||
302 | |||
303 | state.type = _type; | ||
304 | state.channel = _channel; | ||
305 | } | ||
306 | finally { | ||
307 | } | ||
308 | } | ||
309 | // $ANTLR end "T__20" | ||
310 | |||
311 | // $ANTLR start "T__21" | ||
312 | public final void mT__21() throws RecognitionException { | ||
313 | try { | ||
314 | int _type = T__21; | ||
315 | int _channel = DEFAULT_TOKEN_CHANNEL; | ||
316 | // InternalAlloyLanguage.g:21:7: ( 'all' ) | ||
317 | // InternalAlloyLanguage.g:21:9: 'all' | ||
318 | { | ||
319 | match("all"); | ||
320 | |||
321 | |||
322 | } | ||
323 | |||
324 | state.type = _type; | ||
325 | state.channel = _channel; | ||
326 | } | ||
327 | finally { | ||
328 | } | ||
329 | } | ||
330 | // $ANTLR end "T__21" | ||
331 | |||
332 | // $ANTLR start "T__22" | ||
333 | public final void mT__22() throws RecognitionException { | ||
334 | try { | ||
335 | int _type = T__22; | ||
336 | int _channel = DEFAULT_TOKEN_CHANNEL; | ||
337 | // InternalAlloyLanguage.g:22:7: ( 'no' ) | ||
338 | // InternalAlloyLanguage.g:22:9: 'no' | ||
339 | { | ||
340 | match("no"); | ||
341 | |||
342 | |||
343 | } | ||
344 | |||
345 | state.type = _type; | ||
346 | state.channel = _channel; | ||
347 | } | ||
348 | finally { | ||
349 | } | ||
350 | } | ||
351 | // $ANTLR end "T__22" | ||
352 | |||
353 | // $ANTLR start "T__23" | ||
354 | public final void mT__23() throws RecognitionException { | ||
355 | try { | ||
356 | int _type = T__23; | ||
357 | int _channel = DEFAULT_TOKEN_CHANNEL; | ||
358 | // InternalAlloyLanguage.g:23:7: ( 'some' ) | ||
359 | // InternalAlloyLanguage.g:23:9: 'some' | ||
360 | { | ||
361 | match("some"); | ||
362 | |||
363 | |||
364 | } | ||
365 | |||
366 | state.type = _type; | ||
367 | state.channel = _channel; | ||
368 | } | ||
369 | finally { | ||
370 | } | ||
371 | } | ||
372 | // $ANTLR end "T__23" | ||
373 | |||
374 | // $ANTLR start "T__24" | ||
375 | public final void mT__24() throws RecognitionException { | ||
376 | try { | ||
377 | int _type = T__24; | ||
378 | int _channel = DEFAULT_TOKEN_CHANNEL; | ||
379 | // InternalAlloyLanguage.g:24:7: ( 'lone' ) | ||
380 | // InternalAlloyLanguage.g:24:9: 'lone' | ||
381 | { | ||
382 | match("lone"); | ||
383 | |||
384 | |||
385 | } | ||
386 | |||
387 | state.type = _type; | ||
388 | state.channel = _channel; | ||
389 | } | ||
390 | finally { | ||
391 | } | ||
392 | } | ||
393 | // $ANTLR end "T__24" | ||
394 | |||
395 | // $ANTLR start "T__25" | ||
396 | public final void mT__25() throws RecognitionException { | ||
397 | try { | ||
398 | int _type = T__25; | ||
399 | int _channel = DEFAULT_TOKEN_CHANNEL; | ||
400 | // InternalAlloyLanguage.g:25:7: ( 'one' ) | ||
401 | // InternalAlloyLanguage.g:25:9: 'one' | ||
402 | { | ||
403 | match("one"); | ||
404 | |||
405 | |||
406 | } | ||
407 | |||
408 | state.type = _type; | ||
409 | state.channel = _channel; | ||
410 | } | ||
411 | finally { | ||
412 | } | ||
413 | } | ||
414 | // $ANTLR end "T__25" | ||
415 | |||
416 | // $ANTLR start "T__26" | ||
417 | public final void mT__26() throws RecognitionException { | ||
418 | try { | ||
419 | int _type = T__26; | ||
420 | int _channel = DEFAULT_TOKEN_CHANNEL; | ||
421 | // InternalAlloyLanguage.g:26:7: ( 'set' ) | ||
422 | // InternalAlloyLanguage.g:26:9: 'set' | ||
423 | { | ||
424 | match("set"); | ||
425 | |||
426 | |||
427 | } | ||
428 | |||
429 | state.type = _type; | ||
430 | state.channel = _channel; | ||
431 | } | ||
432 | finally { | ||
433 | } | ||
434 | } | ||
435 | // $ANTLR end "T__26" | ||
436 | |||
437 | // $ANTLR start "T__27" | ||
438 | public final void mT__27() throws RecognitionException { | ||
439 | try { | ||
440 | int _type = T__27; | ||
441 | int _channel = DEFAULT_TOKEN_CHANNEL; | ||
442 | // InternalAlloyLanguage.g:27:7: ( 'plus' ) | ||
443 | // InternalAlloyLanguage.g:27:9: 'plus' | ||
444 | { | ||
445 | match("plus"); | ||
446 | |||
447 | |||
448 | } | ||
449 | |||
450 | state.type = _type; | ||
451 | state.channel = _channel; | ||
452 | } | ||
453 | finally { | ||
454 | } | ||
455 | } | ||
456 | // $ANTLR end "T__27" | ||
457 | |||
458 | // $ANTLR start "T__28" | ||
459 | public final void mT__28() throws RecognitionException { | ||
460 | try { | ||
461 | int _type = T__28; | ||
462 | int _channel = DEFAULT_TOKEN_CHANNEL; | ||
463 | // InternalAlloyLanguage.g:28:7: ( 'sub' ) | ||
464 | // InternalAlloyLanguage.g:28:9: 'sub' | ||
465 | { | ||
466 | match("sub"); | ||
467 | |||
468 | |||
469 | } | ||
470 | |||
471 | state.type = _type; | ||
472 | state.channel = _channel; | ||
473 | } | ||
474 | finally { | ||
475 | } | ||
476 | } | ||
477 | // $ANTLR end "T__28" | ||
478 | |||
479 | // $ANTLR start "T__29" | ||
480 | public final void mT__29() throws RecognitionException { | ||
481 | try { | ||
482 | int _type = T__29; | ||
483 | int _channel = DEFAULT_TOKEN_CHANNEL; | ||
484 | // InternalAlloyLanguage.g:29:7: ( 'mul' ) | ||
485 | // InternalAlloyLanguage.g:29:9: 'mul' | ||
486 | { | ||
487 | match("mul"); | ||
488 | |||
489 | |||
490 | } | ||
491 | |||
492 | state.type = _type; | ||
493 | state.channel = _channel; | ||
494 | } | ||
495 | finally { | ||
496 | } | ||
497 | } | ||
498 | // $ANTLR end "T__29" | ||
499 | |||
500 | // $ANTLR start "T__30" | ||
501 | public final void mT__30() throws RecognitionException { | ||
502 | try { | ||
503 | int _type = T__30; | ||
504 | int _channel = DEFAULT_TOKEN_CHANNEL; | ||
505 | // InternalAlloyLanguage.g:30:7: ( 'rem' ) | ||
506 | // InternalAlloyLanguage.g:30:9: 'rem' | ||
507 | { | ||
508 | match("rem"); | ||
509 | |||
510 | |||
511 | } | ||
512 | |||
513 | state.type = _type; | ||
514 | state.channel = _channel; | ||
515 | } | ||
516 | finally { | ||
517 | } | ||
518 | } | ||
519 | // $ANTLR end "T__30" | ||
520 | |||
521 | // $ANTLR start "T__31" | ||
522 | public final void mT__31() throws RecognitionException { | ||
523 | try { | ||
524 | int _type = T__31; | ||
525 | int _channel = DEFAULT_TOKEN_CHANNEL; | ||
526 | // InternalAlloyLanguage.g:31:7: ( 'div' ) | ||
527 | // InternalAlloyLanguage.g:31:9: 'div' | ||
528 | { | ||
529 | match("div"); | ||
530 | |||
531 | |||
532 | } | ||
533 | |||
534 | state.type = _type; | ||
535 | state.channel = _channel; | ||
536 | } | ||
537 | finally { | ||
538 | } | ||
539 | } | ||
540 | // $ANTLR end "T__31" | ||
541 | |||
542 | // $ANTLR start "T__32" | ||
543 | public final void mT__32() throws RecognitionException { | ||
544 | try { | ||
545 | int _type = T__32; | ||
546 | int _channel = DEFAULT_TOKEN_CHANNEL; | ||
547 | // InternalAlloyLanguage.g:32:7: ( 'enum' ) | ||
548 | // InternalAlloyLanguage.g:32:9: 'enum' | ||
549 | { | ||
550 | match("enum"); | ||
551 | |||
552 | |||
553 | } | ||
554 | |||
555 | state.type = _type; | ||
556 | state.channel = _channel; | ||
557 | } | ||
558 | finally { | ||
559 | } | ||
560 | } | ||
561 | // $ANTLR end "T__32" | ||
562 | |||
563 | // $ANTLR start "T__33" | ||
564 | public final void mT__33() throws RecognitionException { | ||
565 | try { | ||
566 | int _type = T__33; | ||
567 | int _channel = DEFAULT_TOKEN_CHANNEL; | ||
568 | // InternalAlloyLanguage.g:33:7: ( '{' ) | ||
569 | // InternalAlloyLanguage.g:33:9: '{' | ||
570 | { | ||
571 | match('{'); | ||
572 | |||
573 | } | ||
574 | |||
575 | state.type = _type; | ||
576 | state.channel = _channel; | ||
577 | } | ||
578 | finally { | ||
579 | } | ||
580 | } | ||
581 | // $ANTLR end "T__33" | ||
582 | |||
583 | // $ANTLR start "T__34" | ||
584 | public final void mT__34() throws RecognitionException { | ||
585 | try { | ||
586 | int _type = T__34; | ||
587 | int _channel = DEFAULT_TOKEN_CHANNEL; | ||
588 | // InternalAlloyLanguage.g:34:7: ( '}' ) | ||
589 | // InternalAlloyLanguage.g:34:9: '}' | ||
590 | { | ||
591 | match('}'); | ||
592 | |||
593 | } | ||
594 | |||
595 | state.type = _type; | ||
596 | state.channel = _channel; | ||
597 | } | ||
598 | finally { | ||
599 | } | ||
600 | } | ||
601 | // $ANTLR end "T__34" | ||
602 | |||
603 | // $ANTLR start "T__35" | ||
604 | public final void mT__35() throws RecognitionException { | ||
605 | try { | ||
606 | int _type = T__35; | ||
607 | int _channel = DEFAULT_TOKEN_CHANNEL; | ||
608 | // InternalAlloyLanguage.g:35:7: ( ',' ) | ||
609 | // InternalAlloyLanguage.g:35:9: ',' | ||
610 | { | ||
611 | match(','); | ||
612 | |||
613 | } | ||
614 | |||
615 | state.type = _type; | ||
616 | state.channel = _channel; | ||
617 | } | ||
618 | finally { | ||
619 | } | ||
620 | } | ||
621 | // $ANTLR end "T__35" | ||
622 | |||
623 | // $ANTLR start "T__36" | ||
624 | public final void mT__36() throws RecognitionException { | ||
625 | try { | ||
626 | int _type = T__36; | ||
627 | int _channel = DEFAULT_TOKEN_CHANNEL; | ||
628 | // InternalAlloyLanguage.g:36:7: ( 'sig' ) | ||
629 | // InternalAlloyLanguage.g:36:9: 'sig' | ||
630 | { | ||
631 | match("sig"); | ||
632 | |||
633 | |||
634 | } | ||
635 | |||
636 | state.type = _type; | ||
637 | state.channel = _channel; | ||
638 | } | ||
639 | finally { | ||
640 | } | ||
641 | } | ||
642 | // $ANTLR end "T__36" | ||
643 | |||
644 | // $ANTLR start "T__37" | ||
645 | public final void mT__37() throws RecognitionException { | ||
646 | try { | ||
647 | int _type = T__37; | ||
648 | int _channel = DEFAULT_TOKEN_CHANNEL; | ||
649 | // InternalAlloyLanguage.g:37:7: ( 'extends' ) | ||
650 | // InternalAlloyLanguage.g:37:9: 'extends' | ||
651 | { | ||
652 | match("extends"); | ||
653 | |||
654 | |||
655 | } | ||
656 | |||
657 | state.type = _type; | ||
658 | state.channel = _channel; | ||
659 | } | ||
660 | finally { | ||
661 | } | ||
662 | } | ||
663 | // $ANTLR end "T__37" | ||
664 | |||
665 | // $ANTLR start "T__38" | ||
666 | public final void mT__38() throws RecognitionException { | ||
667 | try { | ||
668 | int _type = T__38; | ||
669 | int _channel = DEFAULT_TOKEN_CHANNEL; | ||
670 | // InternalAlloyLanguage.g:38:7: ( 'in' ) | ||
671 | // InternalAlloyLanguage.g:38:9: 'in' | ||
672 | { | ||
673 | match("in"); | ||
674 | |||
675 | |||
676 | } | ||
677 | |||
678 | state.type = _type; | ||
679 | state.channel = _channel; | ||
680 | } | ||
681 | finally { | ||
682 | } | ||
683 | } | ||
684 | // $ANTLR end "T__38" | ||
685 | |||
686 | // $ANTLR start "T__39" | ||
687 | public final void mT__39() throws RecognitionException { | ||
688 | try { | ||
689 | int _type = T__39; | ||
690 | int _channel = DEFAULT_TOKEN_CHANNEL; | ||
691 | // InternalAlloyLanguage.g:39:7: ( '+' ) | ||
692 | // InternalAlloyLanguage.g:39:9: '+' | ||
693 | { | ||
694 | match('+'); | ||
695 | |||
696 | } | ||
697 | |||
698 | state.type = _type; | ||
699 | state.channel = _channel; | ||
700 | } | ||
701 | finally { | ||
702 | } | ||
703 | } | ||
704 | // $ANTLR end "T__39" | ||
705 | |||
706 | // $ANTLR start "T__40" | ||
707 | public final void mT__40() throws RecognitionException { | ||
708 | try { | ||
709 | int _type = T__40; | ||
710 | int _channel = DEFAULT_TOKEN_CHANNEL; | ||
711 | // InternalAlloyLanguage.g:40:7: ( ':' ) | ||
712 | // InternalAlloyLanguage.g:40:9: ':' | ||
713 | { | ||
714 | match(':'); | ||
715 | |||
716 | } | ||
717 | |||
718 | state.type = _type; | ||
719 | state.channel = _channel; | ||
720 | } | ||
721 | finally { | ||
722 | } | ||
723 | } | ||
724 | // $ANTLR end "T__40" | ||
725 | |||
726 | // $ANTLR start "T__41" | ||
727 | public final void mT__41() throws RecognitionException { | ||
728 | try { | ||
729 | int _type = T__41; | ||
730 | int _channel = DEFAULT_TOKEN_CHANNEL; | ||
731 | // InternalAlloyLanguage.g:41:7: ( 'fun' ) | ||
732 | // InternalAlloyLanguage.g:41:9: 'fun' | ||
733 | { | ||
734 | match("fun"); | ||
735 | |||
736 | |||
737 | } | ||
738 | |||
739 | state.type = _type; | ||
740 | state.channel = _channel; | ||
741 | } | ||
742 | finally { | ||
743 | } | ||
744 | } | ||
745 | // $ANTLR end "T__41" | ||
746 | |||
747 | // $ANTLR start "T__42" | ||
748 | public final void mT__42() throws RecognitionException { | ||
749 | try { | ||
750 | int _type = T__42; | ||
751 | int _channel = DEFAULT_TOKEN_CHANNEL; | ||
752 | // InternalAlloyLanguage.g:42:7: ( '[' ) | ||
753 | // InternalAlloyLanguage.g:42:9: '[' | ||
754 | { | ||
755 | match('['); | ||
756 | |||
757 | } | ||
758 | |||
759 | state.type = _type; | ||
760 | state.channel = _channel; | ||
761 | } | ||
762 | finally { | ||
763 | } | ||
764 | } | ||
765 | // $ANTLR end "T__42" | ||
766 | |||
767 | // $ANTLR start "T__43" | ||
768 | public final void mT__43() throws RecognitionException { | ||
769 | try { | ||
770 | int _type = T__43; | ||
771 | int _channel = DEFAULT_TOKEN_CHANNEL; | ||
772 | // InternalAlloyLanguage.g:43:7: ( ']' ) | ||
773 | // InternalAlloyLanguage.g:43:9: ']' | ||
774 | { | ||
775 | match(']'); | ||
776 | |||
777 | } | ||
778 | |||
779 | state.type = _type; | ||
780 | state.channel = _channel; | ||
781 | } | ||
782 | finally { | ||
783 | } | ||
784 | } | ||
785 | // $ANTLR end "T__43" | ||
786 | |||
787 | // $ANTLR start "T__44" | ||
788 | public final void mT__44() throws RecognitionException { | ||
789 | try { | ||
790 | int _type = T__44; | ||
791 | int _channel = DEFAULT_TOKEN_CHANNEL; | ||
792 | // InternalAlloyLanguage.g:44:7: ( 'pred' ) | ||
793 | // InternalAlloyLanguage.g:44:9: 'pred' | ||
794 | { | ||
795 | match("pred"); | ||
796 | |||
797 | |||
798 | } | ||
799 | |||
800 | state.type = _type; | ||
801 | state.channel = _channel; | ||
802 | } | ||
803 | finally { | ||
804 | } | ||
805 | } | ||
806 | // $ANTLR end "T__44" | ||
807 | |||
808 | // $ANTLR start "T__45" | ||
809 | public final void mT__45() throws RecognitionException { | ||
810 | try { | ||
811 | int _type = T__45; | ||
812 | int _channel = DEFAULT_TOKEN_CHANNEL; | ||
813 | // InternalAlloyLanguage.g:45:7: ( 'fact' ) | ||
814 | // InternalAlloyLanguage.g:45:9: 'fact' | ||
815 | { | ||
816 | match("fact"); | ||
817 | |||
818 | |||
819 | } | ||
820 | |||
821 | state.type = _type; | ||
822 | state.channel = _channel; | ||
823 | } | ||
824 | finally { | ||
825 | } | ||
826 | } | ||
827 | // $ANTLR end "T__45" | ||
828 | |||
829 | // $ANTLR start "T__46" | ||
830 | public final void mT__46() throws RecognitionException { | ||
831 | try { | ||
832 | int _type = T__46; | ||
833 | int _channel = DEFAULT_TOKEN_CHANNEL; | ||
834 | // InternalAlloyLanguage.g:46:7: ( 'else' ) | ||
835 | // InternalAlloyLanguage.g:46:9: 'else' | ||
836 | { | ||
837 | match("else"); | ||
838 | |||
839 | |||
840 | } | ||
841 | |||
842 | state.type = _type; | ||
843 | state.channel = _channel; | ||
844 | } | ||
845 | finally { | ||
846 | } | ||
847 | } | ||
848 | // $ANTLR end "T__46" | ||
849 | |||
850 | // $ANTLR start "T__47" | ||
851 | public final void mT__47() throws RecognitionException { | ||
852 | try { | ||
853 | int _type = T__47; | ||
854 | int _channel = DEFAULT_TOKEN_CHANNEL; | ||
855 | // InternalAlloyLanguage.g:47:7: ( '=' ) | ||
856 | // InternalAlloyLanguage.g:47:9: '=' | ||
857 | { | ||
858 | match('='); | ||
859 | |||
860 | } | ||
861 | |||
862 | state.type = _type; | ||
863 | state.channel = _channel; | ||
864 | } | ||
865 | finally { | ||
866 | } | ||
867 | } | ||
868 | // $ANTLR end "T__47" | ||
869 | |||
870 | // $ANTLR start "T__48" | ||
871 | public final void mT__48() throws RecognitionException { | ||
872 | try { | ||
873 | int _type = T__48; | ||
874 | int _channel = DEFAULT_TOKEN_CHANNEL; | ||
875 | // InternalAlloyLanguage.g:48:7: ( '!=' ) | ||
876 | // InternalAlloyLanguage.g:48:9: '!=' | ||
877 | { | ||
878 | match("!="); | ||
879 | |||
880 | |||
881 | } | ||
882 | |||
883 | state.type = _type; | ||
884 | state.channel = _channel; | ||
885 | } | ||
886 | finally { | ||
887 | } | ||
888 | } | ||
889 | // $ANTLR end "T__48" | ||
890 | |||
891 | // $ANTLR start "T__49" | ||
892 | public final void mT__49() throws RecognitionException { | ||
893 | try { | ||
894 | int _type = T__49; | ||
895 | int _channel = DEFAULT_TOKEN_CHANNEL; | ||
896 | // InternalAlloyLanguage.g:49:7: ( '>' ) | ||
897 | // InternalAlloyLanguage.g:49:9: '>' | ||
898 | { | ||
899 | match('>'); | ||
900 | |||
901 | } | ||
902 | |||
903 | state.type = _type; | ||
904 | state.channel = _channel; | ||
905 | } | ||
906 | finally { | ||
907 | } | ||
908 | } | ||
909 | // $ANTLR end "T__49" | ||
910 | |||
911 | // $ANTLR start "T__50" | ||
912 | public final void mT__50() throws RecognitionException { | ||
913 | try { | ||
914 | int _type = T__50; | ||
915 | int _channel = DEFAULT_TOKEN_CHANNEL; | ||
916 | // InternalAlloyLanguage.g:50:7: ( '>=' ) | ||
917 | // InternalAlloyLanguage.g:50:9: '>=' | ||
918 | { | ||
919 | match(">="); | ||
920 | |||
921 | |||
922 | } | ||
923 | |||
924 | state.type = _type; | ||
925 | state.channel = _channel; | ||
926 | } | ||
927 | finally { | ||
928 | } | ||
929 | } | ||
930 | // $ANTLR end "T__50" | ||
931 | |||
932 | // $ANTLR start "T__51" | ||
933 | public final void mT__51() throws RecognitionException { | ||
934 | try { | ||
935 | int _type = T__51; | ||
936 | int _channel = DEFAULT_TOKEN_CHANNEL; | ||
937 | // InternalAlloyLanguage.g:51:7: ( '<' ) | ||
938 | // InternalAlloyLanguage.g:51:9: '<' | ||
939 | { | ||
940 | match('<'); | ||
941 | |||
942 | } | ||
943 | |||
944 | state.type = _type; | ||
945 | state.channel = _channel; | ||
946 | } | ||
947 | finally { | ||
948 | } | ||
949 | } | ||
950 | // $ANTLR end "T__51" | ||
951 | |||
952 | // $ANTLR start "T__52" | ||
953 | public final void mT__52() throws RecognitionException { | ||
954 | try { | ||
955 | int _type = T__52; | ||
956 | int _channel = DEFAULT_TOKEN_CHANNEL; | ||
957 | // InternalAlloyLanguage.g:52:7: ( '<=' ) | ||
958 | // InternalAlloyLanguage.g:52:9: '<=' | ||
959 | { | ||
960 | match("<="); | ||
961 | |||
962 | |||
963 | } | ||
964 | |||
965 | state.type = _type; | ||
966 | state.channel = _channel; | ||
967 | } | ||
968 | finally { | ||
969 | } | ||
970 | } | ||
971 | // $ANTLR end "T__52" | ||
972 | |||
973 | // $ANTLR start "T__53" | ||
974 | public final void mT__53() throws RecognitionException { | ||
975 | try { | ||
976 | int _type = T__53; | ||
977 | int _channel = DEFAULT_TOKEN_CHANNEL; | ||
978 | // InternalAlloyLanguage.g:53:7: ( '++' ) | ||
979 | // InternalAlloyLanguage.g:53:9: '++' | ||
980 | { | ||
981 | match("++"); | ||
982 | |||
983 | |||
984 | } | ||
985 | |||
986 | state.type = _type; | ||
987 | state.channel = _channel; | ||
988 | } | ||
989 | finally { | ||
990 | } | ||
991 | } | ||
992 | // $ANTLR end "T__53" | ||
993 | |||
994 | // $ANTLR start "T__54" | ||
995 | public final void mT__54() throws RecognitionException { | ||
996 | try { | ||
997 | int _type = T__54; | ||
998 | int _channel = DEFAULT_TOKEN_CHANNEL; | ||
999 | // InternalAlloyLanguage.g:54:7: ( ':>' ) | ||
1000 | // InternalAlloyLanguage.g:54:9: ':>' | ||
1001 | { | ||
1002 | match(":>"); | ||
1003 | |||
1004 | |||
1005 | } | ||
1006 | |||
1007 | state.type = _type; | ||
1008 | state.channel = _channel; | ||
1009 | } | ||
1010 | finally { | ||
1011 | } | ||
1012 | } | ||
1013 | // $ANTLR end "T__54" | ||
1014 | |||
1015 | // $ANTLR start "T__55" | ||
1016 | public final void mT__55() throws RecognitionException { | ||
1017 | try { | ||
1018 | int _type = T__55; | ||
1019 | int _channel = DEFAULT_TOKEN_CHANNEL; | ||
1020 | // InternalAlloyLanguage.g:55:7: ( '<:' ) | ||
1021 | // InternalAlloyLanguage.g:55:9: '<:' | ||
1022 | { | ||
1023 | match("<:"); | ||
1024 | |||
1025 | |||
1026 | } | ||
1027 | |||
1028 | state.type = _type; | ||
1029 | state.channel = _channel; | ||
1030 | } | ||
1031 | finally { | ||
1032 | } | ||
1033 | } | ||
1034 | // $ANTLR end "T__55" | ||
1035 | |||
1036 | // $ANTLR start "T__56" | ||
1037 | public final void mT__56() throws RecognitionException { | ||
1038 | try { | ||
1039 | int _type = T__56; | ||
1040 | int _channel = DEFAULT_TOKEN_CHANNEL; | ||
1041 | // InternalAlloyLanguage.g:56:7: ( '.' ) | ||
1042 | // InternalAlloyLanguage.g:56:9: '.' | ||
1043 | { | ||
1044 | match('.'); | ||
1045 | |||
1046 | } | ||
1047 | |||
1048 | state.type = _type; | ||
1049 | state.channel = _channel; | ||
1050 | } | ||
1051 | finally { | ||
1052 | } | ||
1053 | } | ||
1054 | // $ANTLR end "T__56" | ||
1055 | |||
1056 | // $ANTLR start "T__57" | ||
1057 | public final void mT__57() throws RecognitionException { | ||
1058 | try { | ||
1059 | int _type = T__57; | ||
1060 | int _channel = DEFAULT_TOKEN_CHANNEL; | ||
1061 | // InternalAlloyLanguage.g:57:7: ( '-' ) | ||
1062 | // InternalAlloyLanguage.g:57:9: '-' | ||
1063 | { | ||
1064 | match('-'); | ||
1065 | |||
1066 | } | ||
1067 | |||
1068 | state.type = _type; | ||
1069 | state.channel = _channel; | ||
1070 | } | ||
1071 | finally { | ||
1072 | } | ||
1073 | } | ||
1074 | // $ANTLR end "T__57" | ||
1075 | |||
1076 | // $ANTLR start "T__58" | ||
1077 | public final void mT__58() throws RecognitionException { | ||
1078 | try { | ||
1079 | int _type = T__58; | ||
1080 | int _channel = DEFAULT_TOKEN_CHANNEL; | ||
1081 | // InternalAlloyLanguage.g:58:7: ( '&' ) | ||
1082 | // InternalAlloyLanguage.g:58:9: '&' | ||
1083 | { | ||
1084 | match('&'); | ||
1085 | |||
1086 | } | ||
1087 | |||
1088 | state.type = _type; | ||
1089 | state.channel = _channel; | ||
1090 | } | ||
1091 | finally { | ||
1092 | } | ||
1093 | } | ||
1094 | // $ANTLR end "T__58" | ||
1095 | |||
1096 | // $ANTLR start "T__59" | ||
1097 | public final void mT__59() throws RecognitionException { | ||
1098 | try { | ||
1099 | int _type = T__59; | ||
1100 | int _channel = DEFAULT_TOKEN_CHANNEL; | ||
1101 | // InternalAlloyLanguage.g:59:7: ( '->' ) | ||
1102 | // InternalAlloyLanguage.g:59:9: '->' | ||
1103 | { | ||
1104 | match("->"); | ||
1105 | |||
1106 | |||
1107 | } | ||
1108 | |||
1109 | state.type = _type; | ||
1110 | state.channel = _channel; | ||
1111 | } | ||
1112 | finally { | ||
1113 | } | ||
1114 | } | ||
1115 | // $ANTLR end "T__59" | ||
1116 | |||
1117 | // $ANTLR start "T__60" | ||
1118 | public final void mT__60() throws RecognitionException { | ||
1119 | try { | ||
1120 | int _type = T__60; | ||
1121 | int _channel = DEFAULT_TOKEN_CHANNEL; | ||
1122 | // InternalAlloyLanguage.g:60:7: ( '~' ) | ||
1123 | // InternalAlloyLanguage.g:60:9: '~' | ||
1124 | { | ||
1125 | match('~'); | ||
1126 | |||
1127 | } | ||
1128 | |||
1129 | state.type = _type; | ||
1130 | state.channel = _channel; | ||
1131 | } | ||
1132 | finally { | ||
1133 | } | ||
1134 | } | ||
1135 | // $ANTLR end "T__60" | ||
1136 | |||
1137 | // $ANTLR start "T__61" | ||
1138 | public final void mT__61() throws RecognitionException { | ||
1139 | try { | ||
1140 | int _type = T__61; | ||
1141 | int _channel = DEFAULT_TOKEN_CHANNEL; | ||
1142 | // InternalAlloyLanguage.g:61:7: ( '^' ) | ||
1143 | // InternalAlloyLanguage.g:61:9: '^' | ||
1144 | { | ||
1145 | match('^'); | ||
1146 | |||
1147 | } | ||
1148 | |||
1149 | state.type = _type; | ||
1150 | state.channel = _channel; | ||
1151 | } | ||
1152 | finally { | ||
1153 | } | ||
1154 | } | ||
1155 | // $ANTLR end "T__61" | ||
1156 | |||
1157 | // $ANTLR start "T__62" | ||
1158 | public final void mT__62() throws RecognitionException { | ||
1159 | try { | ||
1160 | int _type = T__62; | ||
1161 | int _channel = DEFAULT_TOKEN_CHANNEL; | ||
1162 | // InternalAlloyLanguage.g:62:7: ( '*' ) | ||
1163 | // InternalAlloyLanguage.g:62:9: '*' | ||
1164 | { | ||
1165 | match('*'); | ||
1166 | |||
1167 | } | ||
1168 | |||
1169 | state.type = _type; | ||
1170 | state.channel = _channel; | ||
1171 | } | ||
1172 | finally { | ||
1173 | } | ||
1174 | } | ||
1175 | // $ANTLR end "T__62" | ||
1176 | |||
1177 | // $ANTLR start "T__63" | ||
1178 | public final void mT__63() throws RecognitionException { | ||
1179 | try { | ||
1180 | int _type = T__63; | ||
1181 | int _channel = DEFAULT_TOKEN_CHANNEL; | ||
1182 | // InternalAlloyLanguage.g:63:7: ( '#' ) | ||
1183 | // InternalAlloyLanguage.g:63:9: '#' | ||
1184 | { | ||
1185 | match('#'); | ||
1186 | |||
1187 | } | ||
1188 | |||
1189 | state.type = _type; | ||
1190 | state.channel = _channel; | ||
1191 | } | ||
1192 | finally { | ||
1193 | } | ||
1194 | } | ||
1195 | // $ANTLR end "T__63" | ||
1196 | |||
1197 | // $ANTLR start "T__64" | ||
1198 | public final void mT__64() throws RecognitionException { | ||
1199 | try { | ||
1200 | int _type = T__64; | ||
1201 | int _channel = DEFAULT_TOKEN_CHANNEL; | ||
1202 | // InternalAlloyLanguage.g:64:7: ( 'sum' ) | ||
1203 | // InternalAlloyLanguage.g:64:9: 'sum' | ||
1204 | { | ||
1205 | match("sum"); | ||
1206 | |||
1207 | |||
1208 | } | ||
1209 | |||
1210 | state.type = _type; | ||
1211 | state.channel = _channel; | ||
1212 | } | ||
1213 | finally { | ||
1214 | } | ||
1215 | } | ||
1216 | // $ANTLR end "T__64" | ||
1217 | |||
1218 | // $ANTLR start "T__65" | ||
1219 | public final void mT__65() throws RecognitionException { | ||
1220 | try { | ||
1221 | int _type = T__65; | ||
1222 | int _channel = DEFAULT_TOKEN_CHANNEL; | ||
1223 | // InternalAlloyLanguage.g:65:7: ( 'none' ) | ||
1224 | // InternalAlloyLanguage.g:65:9: 'none' | ||
1225 | { | ||
1226 | match("none"); | ||
1227 | |||
1228 | |||
1229 | } | ||
1230 | |||
1231 | state.type = _type; | ||
1232 | state.channel = _channel; | ||
1233 | } | ||
1234 | finally { | ||
1235 | } | ||
1236 | } | ||
1237 | // $ANTLR end "T__65" | ||
1238 | |||
1239 | // $ANTLR start "T__66" | ||
1240 | public final void mT__66() throws RecognitionException { | ||
1241 | try { | ||
1242 | int _type = T__66; | ||
1243 | int _channel = DEFAULT_TOKEN_CHANNEL; | ||
1244 | // InternalAlloyLanguage.g:66:7: ( 'iden' ) | ||
1245 | // InternalAlloyLanguage.g:66:9: 'iden' | ||
1246 | { | ||
1247 | match("iden"); | ||
1248 | |||
1249 | |||
1250 | } | ||
1251 | |||
1252 | state.type = _type; | ||
1253 | state.channel = _channel; | ||
1254 | } | ||
1255 | finally { | ||
1256 | } | ||
1257 | } | ||
1258 | // $ANTLR end "T__66" | ||
1259 | |||
1260 | // $ANTLR start "T__67" | ||
1261 | public final void mT__67() throws RecognitionException { | ||
1262 | try { | ||
1263 | int _type = T__67; | ||
1264 | int _channel = DEFAULT_TOKEN_CHANNEL; | ||
1265 | // InternalAlloyLanguage.g:67:7: ( 'univ' ) | ||
1266 | // InternalAlloyLanguage.g:67:9: 'univ' | ||
1267 | { | ||
1268 | match("univ"); | ||
1269 | |||
1270 | |||
1271 | } | ||
1272 | |||
1273 | state.type = _type; | ||
1274 | state.channel = _channel; | ||
1275 | } | ||
1276 | finally { | ||
1277 | } | ||
1278 | } | ||
1279 | // $ANTLR end "T__67" | ||
1280 | |||
1281 | // $ANTLR start "T__68" | ||
1282 | public final void mT__68() throws RecognitionException { | ||
1283 | try { | ||
1284 | int _type = T__68; | ||
1285 | int _channel = DEFAULT_TOKEN_CHANNEL; | ||
1286 | // InternalAlloyLanguage.g:68:7: ( 'Int' ) | ||
1287 | // InternalAlloyLanguage.g:68:9: 'Int' | ||
1288 | { | ||
1289 | match("Int"); | ||
1290 | |||
1291 | |||
1292 | } | ||
1293 | |||
1294 | state.type = _type; | ||
1295 | state.channel = _channel; | ||
1296 | } | ||
1297 | finally { | ||
1298 | } | ||
1299 | } | ||
1300 | // $ANTLR end "T__68" | ||
1301 | |||
1302 | // $ANTLR start "T__69" | ||
1303 | public final void mT__69() throws RecognitionException { | ||
1304 | try { | ||
1305 | int _type = T__69; | ||
1306 | int _channel = DEFAULT_TOKEN_CHANNEL; | ||
1307 | // InternalAlloyLanguage.g:69:7: ( '(' ) | ||
1308 | // InternalAlloyLanguage.g:69:9: '(' | ||
1309 | { | ||
1310 | match('('); | ||
1311 | |||
1312 | } | ||
1313 | |||
1314 | state.type = _type; | ||
1315 | state.channel = _channel; | ||
1316 | } | ||
1317 | finally { | ||
1318 | } | ||
1319 | } | ||
1320 | // $ANTLR end "T__69" | ||
1321 | |||
1322 | // $ANTLR start "T__70" | ||
1323 | public final void mT__70() throws RecognitionException { | ||
1324 | try { | ||
1325 | int _type = T__70; | ||
1326 | int _channel = DEFAULT_TOKEN_CHANNEL; | ||
1327 | // InternalAlloyLanguage.g:70:7: ( ')' ) | ||
1328 | // InternalAlloyLanguage.g:70:9: ')' | ||
1329 | { | ||
1330 | match(')'); | ||
1331 | |||
1332 | } | ||
1333 | |||
1334 | state.type = _type; | ||
1335 | state.channel = _channel; | ||
1336 | } | ||
1337 | finally { | ||
1338 | } | ||
1339 | } | ||
1340 | // $ANTLR end "T__70" | ||
1341 | |||
1342 | // $ANTLR start "T__71" | ||
1343 | public final void mT__71() throws RecognitionException { | ||
1344 | try { | ||
1345 | int _type = T__71; | ||
1346 | int _channel = DEFAULT_TOKEN_CHANNEL; | ||
1347 | // InternalAlloyLanguage.g:71:7: ( 'run' ) | ||
1348 | // InternalAlloyLanguage.g:71:9: 'run' | ||
1349 | { | ||
1350 | match("run"); | ||
1351 | |||
1352 | |||
1353 | } | ||
1354 | |||
1355 | state.type = _type; | ||
1356 | state.channel = _channel; | ||
1357 | } | ||
1358 | finally { | ||
1359 | } | ||
1360 | } | ||
1361 | // $ANTLR end "T__71" | ||
1362 | |||
1363 | // $ANTLR start "T__72" | ||
1364 | public final void mT__72() throws RecognitionException { | ||
1365 | try { | ||
1366 | int _type = T__72; | ||
1367 | int _channel = DEFAULT_TOKEN_CHANNEL; | ||
1368 | // InternalAlloyLanguage.g:72:7: ( 'for' ) | ||
1369 | // InternalAlloyLanguage.g:72:9: 'for' | ||
1370 | { | ||
1371 | match("for"); | ||
1372 | |||
1373 | |||
1374 | } | ||
1375 | |||
1376 | state.type = _type; | ||
1377 | state.channel = _channel; | ||
1378 | } | ||
1379 | finally { | ||
1380 | } | ||
1381 | } | ||
1382 | // $ANTLR end "T__72" | ||
1383 | |||
1384 | // $ANTLR start "T__73" | ||
1385 | public final void mT__73() throws RecognitionException { | ||
1386 | try { | ||
1387 | int _type = T__73; | ||
1388 | int _channel = DEFAULT_TOKEN_CHANNEL; | ||
1389 | // InternalAlloyLanguage.g:73:7: ( 'abstract' ) | ||
1390 | // InternalAlloyLanguage.g:73:9: 'abstract' | ||
1391 | { | ||
1392 | match("abstract"); | ||
1393 | |||
1394 | |||
1395 | } | ||
1396 | |||
1397 | state.type = _type; | ||
1398 | state.channel = _channel; | ||
1399 | } | ||
1400 | finally { | ||
1401 | } | ||
1402 | } | ||
1403 | // $ANTLR end "T__73" | ||
1404 | |||
1405 | // $ANTLR start "T__74" | ||
1406 | public final void mT__74() throws RecognitionException { | ||
1407 | try { | ||
1408 | int _type = T__74; | ||
1409 | int _channel = DEFAULT_TOKEN_CHANNEL; | ||
1410 | // InternalAlloyLanguage.g:74:7: ( 'disj' ) | ||
1411 | // InternalAlloyLanguage.g:74:9: 'disj' | ||
1412 | { | ||
1413 | match("disj"); | ||
1414 | |||
1415 | |||
1416 | } | ||
1417 | |||
1418 | state.type = _type; | ||
1419 | state.channel = _channel; | ||
1420 | } | ||
1421 | finally { | ||
1422 | } | ||
1423 | } | ||
1424 | // $ANTLR end "T__74" | ||
1425 | |||
1426 | // $ANTLR start "T__75" | ||
1427 | public final void mT__75() throws RecognitionException { | ||
1428 | try { | ||
1429 | int _type = T__75; | ||
1430 | int _channel = DEFAULT_TOKEN_CHANNEL; | ||
1431 | // InternalAlloyLanguage.g:75:7: ( 'exactly' ) | ||
1432 | // InternalAlloyLanguage.g:75:9: 'exactly' | ||
1433 | { | ||
1434 | match("exactly"); | ||
1435 | |||
1436 | |||
1437 | } | ||
1438 | |||
1439 | state.type = _type; | ||
1440 | state.channel = _channel; | ||
1441 | } | ||
1442 | finally { | ||
1443 | } | ||
1444 | } | ||
1445 | // $ANTLR end "T__75" | ||
1446 | |||
1447 | // $ANTLR start "RULE_ID" | ||
1448 | public final void mRULE_ID() throws RecognitionException { | ||
1449 | try { | ||
1450 | int _type = RULE_ID; | ||
1451 | int _channel = DEFAULT_TOKEN_CHANNEL; | ||
1452 | // InternalAlloyLanguage.g:10078:9: ( ( 'a' .. 'z' | 'A' .. 'Z' | '_' ) ( 'a' .. 'z' | 'A' .. 'Z' | '_' | '\\'' | '\"' | '0' .. '9' )* ) | ||
1453 | // InternalAlloyLanguage.g:10078:11: ( 'a' .. 'z' | 'A' .. 'Z' | '_' ) ( 'a' .. 'z' | 'A' .. 'Z' | '_' | '\\'' | '\"' | '0' .. '9' )* | ||
1454 | { | ||
1455 | if ( (input.LA(1)>='A' && input.LA(1)<='Z')||input.LA(1)=='_'||(input.LA(1)>='a' && input.LA(1)<='z') ) { | ||
1456 | input.consume(); | ||
1457 | |||
1458 | } | ||
1459 | else { | ||
1460 | MismatchedSetException mse = new MismatchedSetException(null,input); | ||
1461 | recover(mse); | ||
1462 | throw mse;} | ||
1463 | |||
1464 | // InternalAlloyLanguage.g:10078:35: ( 'a' .. 'z' | 'A' .. 'Z' | '_' | '\\'' | '\"' | '0' .. '9' )* | ||
1465 | loop1: | ||
1466 | do { | ||
1467 | int alt1=2; | ||
1468 | int LA1_0 = input.LA(1); | ||
1469 | |||
1470 | 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')) ) { | ||
1471 | alt1=1; | ||
1472 | } | ||
1473 | |||
1474 | |||
1475 | switch (alt1) { | ||
1476 | case 1 : | ||
1477 | // InternalAlloyLanguage.g: | ||
1478 | { | ||
1479 | 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') ) { | ||
1480 | input.consume(); | ||
1481 | |||
1482 | } | ||
1483 | else { | ||
1484 | MismatchedSetException mse = new MismatchedSetException(null,input); | ||
1485 | recover(mse); | ||
1486 | throw mse;} | ||
1487 | |||
1488 | |||
1489 | } | ||
1490 | break; | ||
1491 | |||
1492 | default : | ||
1493 | break loop1; | ||
1494 | } | ||
1495 | } while (true); | ||
1496 | |||
1497 | |||
1498 | } | ||
1499 | |||
1500 | state.type = _type; | ||
1501 | state.channel = _channel; | ||
1502 | } | ||
1503 | finally { | ||
1504 | } | ||
1505 | } | ||
1506 | // $ANTLR end "RULE_ID" | ||
1507 | |||
1508 | // $ANTLR start "RULE_INT" | ||
1509 | public final void mRULE_INT() throws RecognitionException { | ||
1510 | try { | ||
1511 | int _type = RULE_INT; | ||
1512 | int _channel = DEFAULT_TOKEN_CHANNEL; | ||
1513 | // InternalAlloyLanguage.g:10080:10: ( ( '0' .. '9' )+ ) | ||
1514 | // InternalAlloyLanguage.g:10080:12: ( '0' .. '9' )+ | ||
1515 | { | ||
1516 | // InternalAlloyLanguage.g:10080:12: ( '0' .. '9' )+ | ||
1517 | int cnt2=0; | ||
1518 | loop2: | ||
1519 | do { | ||
1520 | int alt2=2; | ||
1521 | int LA2_0 = input.LA(1); | ||
1522 | |||
1523 | if ( ((LA2_0>='0' && LA2_0<='9')) ) { | ||
1524 | alt2=1; | ||
1525 | } | ||
1526 | |||
1527 | |||
1528 | switch (alt2) { | ||
1529 | case 1 : | ||
1530 | // InternalAlloyLanguage.g:10080:13: '0' .. '9' | ||
1531 | { | ||
1532 | matchRange('0','9'); | ||
1533 | |||
1534 | } | ||
1535 | break; | ||
1536 | |||
1537 | default : | ||
1538 | if ( cnt2 >= 1 ) break loop2; | ||
1539 | EarlyExitException eee = | ||
1540 | new EarlyExitException(2, input); | ||
1541 | throw eee; | ||
1542 | } | ||
1543 | cnt2++; | ||
1544 | } while (true); | ||
1545 | |||
1546 | |||
1547 | } | ||
1548 | |||
1549 | state.type = _type; | ||
1550 | state.channel = _channel; | ||
1551 | } | ||
1552 | finally { | ||
1553 | } | ||
1554 | } | ||
1555 | // $ANTLR end "RULE_INT" | ||
1556 | |||
1557 | // $ANTLR start "RULE_STRING" | ||
1558 | public final void mRULE_STRING() throws RecognitionException { | ||
1559 | try { | ||
1560 | int _type = RULE_STRING; | ||
1561 | int _channel = DEFAULT_TOKEN_CHANNEL; | ||
1562 | // InternalAlloyLanguage.g:10082:13: ( ( '\"' ( '\\\\' . | ~ ( ( '\\\\' | '\"' ) ) )* '\"' | '\\'' ( '\\\\' . | ~ ( ( '\\\\' | '\\'' ) ) )* '\\'' ) ) | ||
1563 | // InternalAlloyLanguage.g:10082:15: ( '\"' ( '\\\\' . | ~ ( ( '\\\\' | '\"' ) ) )* '\"' | '\\'' ( '\\\\' . | ~ ( ( '\\\\' | '\\'' ) ) )* '\\'' ) | ||
1564 | { | ||
1565 | // InternalAlloyLanguage.g:10082:15: ( '\"' ( '\\\\' . | ~ ( ( '\\\\' | '\"' ) ) )* '\"' | '\\'' ( '\\\\' . | ~ ( ( '\\\\' | '\\'' ) ) )* '\\'' ) | ||
1566 | int alt5=2; | ||
1567 | int LA5_0 = input.LA(1); | ||
1568 | |||
1569 | if ( (LA5_0=='\"') ) { | ||
1570 | alt5=1; | ||
1571 | } | ||
1572 | else if ( (LA5_0=='\'') ) { | ||
1573 | alt5=2; | ||
1574 | } | ||
1575 | else { | ||
1576 | NoViableAltException nvae = | ||
1577 | new NoViableAltException("", 5, 0, input); | ||
1578 | |||
1579 | throw nvae; | ||
1580 | } | ||
1581 | switch (alt5) { | ||
1582 | case 1 : | ||
1583 | // InternalAlloyLanguage.g:10082:16: '\"' ( '\\\\' . | ~ ( ( '\\\\' | '\"' ) ) )* '\"' | ||
1584 | { | ||
1585 | match('\"'); | ||
1586 | // InternalAlloyLanguage.g:10082:20: ( '\\\\' . | ~ ( ( '\\\\' | '\"' ) ) )* | ||
1587 | loop3: | ||
1588 | do { | ||
1589 | int alt3=3; | ||
1590 | int LA3_0 = input.LA(1); | ||
1591 | |||
1592 | if ( (LA3_0=='\\') ) { | ||
1593 | alt3=1; | ||
1594 | } | ||
1595 | else if ( ((LA3_0>='\u0000' && LA3_0<='!')||(LA3_0>='#' && LA3_0<='[')||(LA3_0>=']' && LA3_0<='\uFFFF')) ) { | ||
1596 | alt3=2; | ||
1597 | } | ||
1598 | |||
1599 | |||
1600 | switch (alt3) { | ||
1601 | case 1 : | ||
1602 | // InternalAlloyLanguage.g:10082:21: '\\\\' . | ||
1603 | { | ||
1604 | match('\\'); | ||
1605 | matchAny(); | ||
1606 | |||
1607 | } | ||
1608 | break; | ||
1609 | case 2 : | ||
1610 | // InternalAlloyLanguage.g:10082:28: ~ ( ( '\\\\' | '\"' ) ) | ||
1611 | { | ||
1612 | if ( (input.LA(1)>='\u0000' && input.LA(1)<='!')||(input.LA(1)>='#' && input.LA(1)<='[')||(input.LA(1)>=']' && input.LA(1)<='\uFFFF') ) { | ||
1613 | input.consume(); | ||
1614 | |||
1615 | } | ||
1616 | else { | ||
1617 | MismatchedSetException mse = new MismatchedSetException(null,input); | ||
1618 | recover(mse); | ||
1619 | throw mse;} | ||
1620 | |||
1621 | |||
1622 | } | ||
1623 | break; | ||
1624 | |||
1625 | default : | ||
1626 | break loop3; | ||
1627 | } | ||
1628 | } while (true); | ||
1629 | |||
1630 | match('\"'); | ||
1631 | |||
1632 | } | ||
1633 | break; | ||
1634 | case 2 : | ||
1635 | // InternalAlloyLanguage.g:10082:48: '\\'' ( '\\\\' . | ~ ( ( '\\\\' | '\\'' ) ) )* '\\'' | ||
1636 | { | ||
1637 | match('\''); | ||
1638 | // InternalAlloyLanguage.g:10082:53: ( '\\\\' . | ~ ( ( '\\\\' | '\\'' ) ) )* | ||
1639 | loop4: | ||
1640 | do { | ||
1641 | int alt4=3; | ||
1642 | int LA4_0 = input.LA(1); | ||
1643 | |||
1644 | if ( (LA4_0=='\\') ) { | ||
1645 | alt4=1; | ||
1646 | } | ||
1647 | else if ( ((LA4_0>='\u0000' && LA4_0<='&')||(LA4_0>='(' && LA4_0<='[')||(LA4_0>=']' && LA4_0<='\uFFFF')) ) { | ||
1648 | alt4=2; | ||
1649 | } | ||
1650 | |||
1651 | |||
1652 | switch (alt4) { | ||
1653 | case 1 : | ||
1654 | // InternalAlloyLanguage.g:10082:54: '\\\\' . | ||
1655 | { | ||
1656 | match('\\'); | ||
1657 | matchAny(); | ||
1658 | |||
1659 | } | ||
1660 | break; | ||
1661 | case 2 : | ||
1662 | // InternalAlloyLanguage.g:10082:61: ~ ( ( '\\\\' | '\\'' ) ) | ||
1663 | { | ||
1664 | if ( (input.LA(1)>='\u0000' && input.LA(1)<='&')||(input.LA(1)>='(' && input.LA(1)<='[')||(input.LA(1)>=']' && input.LA(1)<='\uFFFF') ) { | ||
1665 | input.consume(); | ||
1666 | |||
1667 | } | ||
1668 | else { | ||
1669 | MismatchedSetException mse = new MismatchedSetException(null,input); | ||
1670 | recover(mse); | ||
1671 | throw mse;} | ||
1672 | |||
1673 | |||
1674 | } | ||
1675 | break; | ||
1676 | |||
1677 | default : | ||
1678 | break loop4; | ||
1679 | } | ||
1680 | } while (true); | ||
1681 | |||
1682 | match('\''); | ||
1683 | |||
1684 | } | ||
1685 | break; | ||
1686 | |||
1687 | } | ||
1688 | |||
1689 | |||
1690 | } | ||
1691 | |||
1692 | state.type = _type; | ||
1693 | state.channel = _channel; | ||
1694 | } | ||
1695 | finally { | ||
1696 | } | ||
1697 | } | ||
1698 | // $ANTLR end "RULE_STRING" | ||
1699 | |||
1700 | // $ANTLR start "RULE_ML_COMMENT" | ||
1701 | public final void mRULE_ML_COMMENT() throws RecognitionException { | ||
1702 | try { | ||
1703 | int _type = RULE_ML_COMMENT; | ||
1704 | int _channel = DEFAULT_TOKEN_CHANNEL; | ||
1705 | // InternalAlloyLanguage.g:10084:17: ( '/*' ( options {greedy=false; } : . )* '*/' ) | ||
1706 | // InternalAlloyLanguage.g:10084:19: '/*' ( options {greedy=false; } : . )* '*/' | ||
1707 | { | ||
1708 | match("/*"); | ||
1709 | |||
1710 | // InternalAlloyLanguage.g:10084:24: ( options {greedy=false; } : . )* | ||
1711 | loop6: | ||
1712 | do { | ||
1713 | int alt6=2; | ||
1714 | int LA6_0 = input.LA(1); | ||
1715 | |||
1716 | if ( (LA6_0=='*') ) { | ||
1717 | int LA6_1 = input.LA(2); | ||
1718 | |||
1719 | if ( (LA6_1=='/') ) { | ||
1720 | alt6=2; | ||
1721 | } | ||
1722 | else if ( ((LA6_1>='\u0000' && LA6_1<='.')||(LA6_1>='0' && LA6_1<='\uFFFF')) ) { | ||
1723 | alt6=1; | ||
1724 | } | ||
1725 | |||
1726 | |||
1727 | } | ||
1728 | else if ( ((LA6_0>='\u0000' && LA6_0<=')')||(LA6_0>='+' && LA6_0<='\uFFFF')) ) { | ||
1729 | alt6=1; | ||
1730 | } | ||
1731 | |||
1732 | |||
1733 | switch (alt6) { | ||
1734 | case 1 : | ||
1735 | // InternalAlloyLanguage.g:10084:52: . | ||
1736 | { | ||
1737 | matchAny(); | ||
1738 | |||
1739 | } | ||
1740 | break; | ||
1741 | |||
1742 | default : | ||
1743 | break loop6; | ||
1744 | } | ||
1745 | } while (true); | ||
1746 | |||
1747 | match("*/"); | ||
1748 | |||
1749 | |||
1750 | } | ||
1751 | |||
1752 | state.type = _type; | ||
1753 | state.channel = _channel; | ||
1754 | } | ||
1755 | finally { | ||
1756 | } | ||
1757 | } | ||
1758 | // $ANTLR end "RULE_ML_COMMENT" | ||
1759 | |||
1760 | // $ANTLR start "RULE_SL_COMMENT" | ||
1761 | public final void mRULE_SL_COMMENT() throws RecognitionException { | ||
1762 | try { | ||
1763 | int _type = RULE_SL_COMMENT; | ||
1764 | int _channel = DEFAULT_TOKEN_CHANNEL; | ||
1765 | // InternalAlloyLanguage.g:10086:17: ( '//' (~ ( ( '\\n' | '\\r' ) ) )* ( ( '\\r' )? '\\n' )? ) | ||
1766 | // InternalAlloyLanguage.g:10086:19: '//' (~ ( ( '\\n' | '\\r' ) ) )* ( ( '\\r' )? '\\n' )? | ||
1767 | { | ||
1768 | match("//"); | ||
1769 | |||
1770 | // InternalAlloyLanguage.g:10086:24: (~ ( ( '\\n' | '\\r' ) ) )* | ||
1771 | loop7: | ||
1772 | do { | ||
1773 | int alt7=2; | ||
1774 | int LA7_0 = input.LA(1); | ||
1775 | |||
1776 | if ( ((LA7_0>='\u0000' && LA7_0<='\t')||(LA7_0>='\u000B' && LA7_0<='\f')||(LA7_0>='\u000E' && LA7_0<='\uFFFF')) ) { | ||
1777 | alt7=1; | ||
1778 | } | ||
1779 | |||
1780 | |||
1781 | switch (alt7) { | ||
1782 | case 1 : | ||
1783 | // InternalAlloyLanguage.g:10086:24: ~ ( ( '\\n' | '\\r' ) ) | ||
1784 | { | ||
1785 | 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') ) { | ||
1786 | input.consume(); | ||
1787 | |||
1788 | } | ||
1789 | else { | ||
1790 | MismatchedSetException mse = new MismatchedSetException(null,input); | ||
1791 | recover(mse); | ||
1792 | throw mse;} | ||
1793 | |||
1794 | |||
1795 | } | ||
1796 | break; | ||
1797 | |||
1798 | default : | ||
1799 | break loop7; | ||
1800 | } | ||
1801 | } while (true); | ||
1802 | |||
1803 | // InternalAlloyLanguage.g:10086:40: ( ( '\\r' )? '\\n' )? | ||
1804 | int alt9=2; | ||
1805 | int LA9_0 = input.LA(1); | ||
1806 | |||
1807 | if ( (LA9_0=='\n'||LA9_0=='\r') ) { | ||
1808 | alt9=1; | ||
1809 | } | ||
1810 | switch (alt9) { | ||
1811 | case 1 : | ||
1812 | // InternalAlloyLanguage.g:10086:41: ( '\\r' )? '\\n' | ||
1813 | { | ||
1814 | // InternalAlloyLanguage.g:10086:41: ( '\\r' )? | ||
1815 | int alt8=2; | ||
1816 | int LA8_0 = input.LA(1); | ||
1817 | |||
1818 | if ( (LA8_0=='\r') ) { | ||
1819 | alt8=1; | ||
1820 | } | ||
1821 | switch (alt8) { | ||
1822 | case 1 : | ||
1823 | // InternalAlloyLanguage.g:10086:41: '\\r' | ||
1824 | { | ||
1825 | match('\r'); | ||
1826 | |||
1827 | } | ||
1828 | break; | ||
1829 | |||
1830 | } | ||
1831 | |||
1832 | match('\n'); | ||
1833 | |||
1834 | } | ||
1835 | break; | ||
1836 | |||
1837 | } | ||
1838 | |||
1839 | |||
1840 | } | ||
1841 | |||
1842 | state.type = _type; | ||
1843 | state.channel = _channel; | ||
1844 | } | ||
1845 | finally { | ||
1846 | } | ||
1847 | } | ||
1848 | // $ANTLR end "RULE_SL_COMMENT" | ||
1849 | |||
1850 | // $ANTLR start "RULE_WS" | ||
1851 | public final void mRULE_WS() throws RecognitionException { | ||
1852 | try { | ||
1853 | int _type = RULE_WS; | ||
1854 | int _channel = DEFAULT_TOKEN_CHANNEL; | ||
1855 | // InternalAlloyLanguage.g:10088:9: ( ( ' ' | '\\t' | '\\r' | '\\n' )+ ) | ||
1856 | // InternalAlloyLanguage.g:10088:11: ( ' ' | '\\t' | '\\r' | '\\n' )+ | ||
1857 | { | ||
1858 | // InternalAlloyLanguage.g:10088:11: ( ' ' | '\\t' | '\\r' | '\\n' )+ | ||
1859 | int cnt10=0; | ||
1860 | loop10: | ||
1861 | do { | ||
1862 | int alt10=2; | ||
1863 | int LA10_0 = input.LA(1); | ||
1864 | |||
1865 | if ( ((LA10_0>='\t' && LA10_0<='\n')||LA10_0=='\r'||LA10_0==' ') ) { | ||
1866 | alt10=1; | ||
1867 | } | ||
1868 | |||
1869 | |||
1870 | switch (alt10) { | ||
1871 | case 1 : | ||
1872 | // InternalAlloyLanguage.g: | ||
1873 | { | ||
1874 | if ( (input.LA(1)>='\t' && input.LA(1)<='\n')||input.LA(1)=='\r'||input.LA(1)==' ' ) { | ||
1875 | input.consume(); | ||
1876 | |||
1877 | } | ||
1878 | else { | ||
1879 | MismatchedSetException mse = new MismatchedSetException(null,input); | ||
1880 | recover(mse); | ||
1881 | throw mse;} | ||
1882 | |||
1883 | |||
1884 | } | ||
1885 | break; | ||
1886 | |||
1887 | default : | ||
1888 | if ( cnt10 >= 1 ) break loop10; | ||
1889 | EarlyExitException eee = | ||
1890 | new EarlyExitException(10, input); | ||
1891 | throw eee; | ||
1892 | } | ||
1893 | cnt10++; | ||
1894 | } while (true); | ||
1895 | |||
1896 | |||
1897 | } | ||
1898 | |||
1899 | state.type = _type; | ||
1900 | state.channel = _channel; | ||
1901 | } | ||
1902 | finally { | ||
1903 | } | ||
1904 | } | ||
1905 | // $ANTLR end "RULE_WS" | ||
1906 | |||
1907 | // $ANTLR start "RULE_ANY_OTHER" | ||
1908 | public final void mRULE_ANY_OTHER() throws RecognitionException { | ||
1909 | try { | ||
1910 | int _type = RULE_ANY_OTHER; | ||
1911 | int _channel = DEFAULT_TOKEN_CHANNEL; | ||
1912 | // InternalAlloyLanguage.g:10090:16: ( . ) | ||
1913 | // InternalAlloyLanguage.g:10090:18: . | ||
1914 | { | ||
1915 | matchAny(); | ||
1916 | |||
1917 | } | ||
1918 | |||
1919 | state.type = _type; | ||
1920 | state.channel = _channel; | ||
1921 | } | ||
1922 | finally { | ||
1923 | } | ||
1924 | } | ||
1925 | // $ANTLR end "RULE_ANY_OTHER" | ||
1926 | |||
1927 | public void mTokens() throws RecognitionException { | ||
1928 | // 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 | RULE_ID | RULE_INT | RULE_STRING | RULE_ML_COMMENT | RULE_SL_COMMENT | RULE_WS | RULE_ANY_OTHER ) | ||
1929 | int alt11=72; | ||
1930 | alt11 = dfa11.predict(input); | ||
1931 | switch (alt11) { | ||
1932 | case 1 : | ||
1933 | // InternalAlloyLanguage.g:1:10: T__11 | ||
1934 | { | ||
1935 | mT__11(); | ||
1936 | |||
1937 | } | ||
1938 | break; | ||
1939 | case 2 : | ||
1940 | // InternalAlloyLanguage.g:1:16: T__12 | ||
1941 | { | ||
1942 | mT__12(); | ||
1943 | |||
1944 | } | ||
1945 | break; | ||
1946 | case 3 : | ||
1947 | // InternalAlloyLanguage.g:1:22: T__13 | ||
1948 | { | ||
1949 | mT__13(); | ||
1950 | |||
1951 | } | ||
1952 | break; | ||
1953 | case 4 : | ||
1954 | // InternalAlloyLanguage.g:1:28: T__14 | ||
1955 | { | ||
1956 | mT__14(); | ||
1957 | |||
1958 | } | ||
1959 | break; | ||
1960 | case 5 : | ||
1961 | // InternalAlloyLanguage.g:1:34: T__15 | ||
1962 | { | ||
1963 | mT__15(); | ||
1964 | |||
1965 | } | ||
1966 | break; | ||
1967 | case 6 : | ||
1968 | // InternalAlloyLanguage.g:1:40: T__16 | ||
1969 | { | ||
1970 | mT__16(); | ||
1971 | |||
1972 | } | ||
1973 | break; | ||
1974 | case 7 : | ||
1975 | // InternalAlloyLanguage.g:1:46: T__17 | ||
1976 | { | ||
1977 | mT__17(); | ||
1978 | |||
1979 | } | ||
1980 | break; | ||
1981 | case 8 : | ||
1982 | // InternalAlloyLanguage.g:1:52: T__18 | ||
1983 | { | ||
1984 | mT__18(); | ||
1985 | |||
1986 | } | ||
1987 | break; | ||
1988 | case 9 : | ||
1989 | // InternalAlloyLanguage.g:1:58: T__19 | ||
1990 | { | ||
1991 | mT__19(); | ||
1992 | |||
1993 | } | ||
1994 | break; | ||
1995 | case 10 : | ||
1996 | // InternalAlloyLanguage.g:1:64: T__20 | ||
1997 | { | ||
1998 | mT__20(); | ||
1999 | |||
2000 | } | ||
2001 | break; | ||
2002 | case 11 : | ||
2003 | // InternalAlloyLanguage.g:1:70: T__21 | ||
2004 | { | ||
2005 | mT__21(); | ||
2006 | |||
2007 | } | ||
2008 | break; | ||
2009 | case 12 : | ||
2010 | // InternalAlloyLanguage.g:1:76: T__22 | ||
2011 | { | ||
2012 | mT__22(); | ||
2013 | |||
2014 | } | ||
2015 | break; | ||
2016 | case 13 : | ||
2017 | // InternalAlloyLanguage.g:1:82: T__23 | ||
2018 | { | ||
2019 | mT__23(); | ||
2020 | |||
2021 | } | ||
2022 | break; | ||
2023 | case 14 : | ||
2024 | // InternalAlloyLanguage.g:1:88: T__24 | ||
2025 | { | ||
2026 | mT__24(); | ||
2027 | |||
2028 | } | ||
2029 | break; | ||
2030 | case 15 : | ||
2031 | // InternalAlloyLanguage.g:1:94: T__25 | ||
2032 | { | ||
2033 | mT__25(); | ||
2034 | |||
2035 | } | ||
2036 | break; | ||
2037 | case 16 : | ||
2038 | // InternalAlloyLanguage.g:1:100: T__26 | ||
2039 | { | ||
2040 | mT__26(); | ||
2041 | |||
2042 | } | ||
2043 | break; | ||
2044 | case 17 : | ||
2045 | // InternalAlloyLanguage.g:1:106: T__27 | ||
2046 | { | ||
2047 | mT__27(); | ||
2048 | |||
2049 | } | ||
2050 | break; | ||
2051 | case 18 : | ||
2052 | // InternalAlloyLanguage.g:1:112: T__28 | ||
2053 | { | ||
2054 | mT__28(); | ||
2055 | |||
2056 | } | ||
2057 | break; | ||
2058 | case 19 : | ||
2059 | // InternalAlloyLanguage.g:1:118: T__29 | ||
2060 | { | ||
2061 | mT__29(); | ||
2062 | |||
2063 | } | ||
2064 | break; | ||
2065 | case 20 : | ||
2066 | // InternalAlloyLanguage.g:1:124: T__30 | ||
2067 | { | ||
2068 | mT__30(); | ||
2069 | |||
2070 | } | ||
2071 | break; | ||
2072 | case 21 : | ||
2073 | // InternalAlloyLanguage.g:1:130: T__31 | ||
2074 | { | ||
2075 | mT__31(); | ||
2076 | |||
2077 | } | ||
2078 | break; | ||
2079 | case 22 : | ||
2080 | // InternalAlloyLanguage.g:1:136: T__32 | ||
2081 | { | ||
2082 | mT__32(); | ||
2083 | |||
2084 | } | ||
2085 | break; | ||
2086 | case 23 : | ||
2087 | // InternalAlloyLanguage.g:1:142: T__33 | ||
2088 | { | ||
2089 | mT__33(); | ||
2090 | |||
2091 | } | ||
2092 | break; | ||
2093 | case 24 : | ||
2094 | // InternalAlloyLanguage.g:1:148: T__34 | ||
2095 | { | ||
2096 | mT__34(); | ||
2097 | |||
2098 | } | ||
2099 | break; | ||
2100 | case 25 : | ||
2101 | // InternalAlloyLanguage.g:1:154: T__35 | ||
2102 | { | ||
2103 | mT__35(); | ||
2104 | |||
2105 | } | ||
2106 | break; | ||
2107 | case 26 : | ||
2108 | // InternalAlloyLanguage.g:1:160: T__36 | ||
2109 | { | ||
2110 | mT__36(); | ||
2111 | |||
2112 | } | ||
2113 | break; | ||
2114 | case 27 : | ||
2115 | // InternalAlloyLanguage.g:1:166: T__37 | ||
2116 | { | ||
2117 | mT__37(); | ||
2118 | |||
2119 | } | ||
2120 | break; | ||
2121 | case 28 : | ||
2122 | // InternalAlloyLanguage.g:1:172: T__38 | ||
2123 | { | ||
2124 | mT__38(); | ||
2125 | |||
2126 | } | ||
2127 | break; | ||
2128 | case 29 : | ||
2129 | // InternalAlloyLanguage.g:1:178: T__39 | ||
2130 | { | ||
2131 | mT__39(); | ||
2132 | |||
2133 | } | ||
2134 | break; | ||
2135 | case 30 : | ||
2136 | // InternalAlloyLanguage.g:1:184: T__40 | ||
2137 | { | ||
2138 | mT__40(); | ||
2139 | |||
2140 | } | ||
2141 | break; | ||
2142 | case 31 : | ||
2143 | // InternalAlloyLanguage.g:1:190: T__41 | ||
2144 | { | ||
2145 | mT__41(); | ||
2146 | |||
2147 | } | ||
2148 | break; | ||
2149 | case 32 : | ||
2150 | // InternalAlloyLanguage.g:1:196: T__42 | ||
2151 | { | ||
2152 | mT__42(); | ||
2153 | |||
2154 | } | ||
2155 | break; | ||
2156 | case 33 : | ||
2157 | // InternalAlloyLanguage.g:1:202: T__43 | ||
2158 | { | ||
2159 | mT__43(); | ||
2160 | |||
2161 | } | ||
2162 | break; | ||
2163 | case 34 : | ||
2164 | // InternalAlloyLanguage.g:1:208: T__44 | ||
2165 | { | ||
2166 | mT__44(); | ||
2167 | |||
2168 | } | ||
2169 | break; | ||
2170 | case 35 : | ||
2171 | // InternalAlloyLanguage.g:1:214: T__45 | ||
2172 | { | ||
2173 | mT__45(); | ||
2174 | |||
2175 | } | ||
2176 | break; | ||
2177 | case 36 : | ||
2178 | // InternalAlloyLanguage.g:1:220: T__46 | ||
2179 | { | ||
2180 | mT__46(); | ||
2181 | |||
2182 | } | ||
2183 | break; | ||
2184 | case 37 : | ||
2185 | // InternalAlloyLanguage.g:1:226: T__47 | ||
2186 | { | ||
2187 | mT__47(); | ||
2188 | |||
2189 | } | ||
2190 | break; | ||
2191 | case 38 : | ||
2192 | // InternalAlloyLanguage.g:1:232: T__48 | ||
2193 | { | ||
2194 | mT__48(); | ||
2195 | |||
2196 | } | ||
2197 | break; | ||
2198 | case 39 : | ||
2199 | // InternalAlloyLanguage.g:1:238: T__49 | ||
2200 | { | ||
2201 | mT__49(); | ||
2202 | |||
2203 | } | ||
2204 | break; | ||
2205 | case 40 : | ||
2206 | // InternalAlloyLanguage.g:1:244: T__50 | ||
2207 | { | ||
2208 | mT__50(); | ||
2209 | |||
2210 | } | ||
2211 | break; | ||
2212 | case 41 : | ||
2213 | // InternalAlloyLanguage.g:1:250: T__51 | ||
2214 | { | ||
2215 | mT__51(); | ||
2216 | |||
2217 | } | ||
2218 | break; | ||
2219 | case 42 : | ||
2220 | // InternalAlloyLanguage.g:1:256: T__52 | ||
2221 | { | ||
2222 | mT__52(); | ||
2223 | |||
2224 | } | ||
2225 | break; | ||
2226 | case 43 : | ||
2227 | // InternalAlloyLanguage.g:1:262: T__53 | ||
2228 | { | ||
2229 | mT__53(); | ||
2230 | |||
2231 | } | ||
2232 | break; | ||
2233 | case 44 : | ||
2234 | // InternalAlloyLanguage.g:1:268: T__54 | ||
2235 | { | ||
2236 | mT__54(); | ||
2237 | |||
2238 | } | ||
2239 | break; | ||
2240 | case 45 : | ||
2241 | // InternalAlloyLanguage.g:1:274: T__55 | ||
2242 | { | ||
2243 | mT__55(); | ||
2244 | |||
2245 | } | ||
2246 | break; | ||
2247 | case 46 : | ||
2248 | // InternalAlloyLanguage.g:1:280: T__56 | ||
2249 | { | ||
2250 | mT__56(); | ||
2251 | |||
2252 | } | ||
2253 | break; | ||
2254 | case 47 : | ||
2255 | // InternalAlloyLanguage.g:1:286: T__57 | ||
2256 | { | ||
2257 | mT__57(); | ||
2258 | |||
2259 | } | ||
2260 | break; | ||
2261 | case 48 : | ||
2262 | // InternalAlloyLanguage.g:1:292: T__58 | ||
2263 | { | ||
2264 | mT__58(); | ||
2265 | |||
2266 | } | ||
2267 | break; | ||
2268 | case 49 : | ||
2269 | // InternalAlloyLanguage.g:1:298: T__59 | ||
2270 | { | ||
2271 | mT__59(); | ||
2272 | |||
2273 | } | ||
2274 | break; | ||
2275 | case 50 : | ||
2276 | // InternalAlloyLanguage.g:1:304: T__60 | ||
2277 | { | ||
2278 | mT__60(); | ||
2279 | |||
2280 | } | ||
2281 | break; | ||
2282 | case 51 : | ||
2283 | // InternalAlloyLanguage.g:1:310: T__61 | ||
2284 | { | ||
2285 | mT__61(); | ||
2286 | |||
2287 | } | ||
2288 | break; | ||
2289 | case 52 : | ||
2290 | // InternalAlloyLanguage.g:1:316: T__62 | ||
2291 | { | ||
2292 | mT__62(); | ||
2293 | |||
2294 | } | ||
2295 | break; | ||
2296 | case 53 : | ||
2297 | // InternalAlloyLanguage.g:1:322: T__63 | ||
2298 | { | ||
2299 | mT__63(); | ||
2300 | |||
2301 | } | ||
2302 | break; | ||
2303 | case 54 : | ||
2304 | // InternalAlloyLanguage.g:1:328: T__64 | ||
2305 | { | ||
2306 | mT__64(); | ||
2307 | |||
2308 | } | ||
2309 | break; | ||
2310 | case 55 : | ||
2311 | // InternalAlloyLanguage.g:1:334: T__65 | ||
2312 | { | ||
2313 | mT__65(); | ||
2314 | |||
2315 | } | ||
2316 | break; | ||
2317 | case 56 : | ||
2318 | // InternalAlloyLanguage.g:1:340: T__66 | ||
2319 | { | ||
2320 | mT__66(); | ||
2321 | |||
2322 | } | ||
2323 | break; | ||
2324 | case 57 : | ||
2325 | // InternalAlloyLanguage.g:1:346: T__67 | ||
2326 | { | ||
2327 | mT__67(); | ||
2328 | |||
2329 | } | ||
2330 | break; | ||
2331 | case 58 : | ||
2332 | // InternalAlloyLanguage.g:1:352: T__68 | ||
2333 | { | ||
2334 | mT__68(); | ||
2335 | |||
2336 | } | ||
2337 | break; | ||
2338 | case 59 : | ||
2339 | // InternalAlloyLanguage.g:1:358: T__69 | ||
2340 | { | ||
2341 | mT__69(); | ||
2342 | |||
2343 | } | ||
2344 | break; | ||
2345 | case 60 : | ||
2346 | // InternalAlloyLanguage.g:1:364: T__70 | ||
2347 | { | ||
2348 | mT__70(); | ||
2349 | |||
2350 | } | ||
2351 | break; | ||
2352 | case 61 : | ||
2353 | // InternalAlloyLanguage.g:1:370: T__71 | ||
2354 | { | ||
2355 | mT__71(); | ||
2356 | |||
2357 | } | ||
2358 | break; | ||
2359 | case 62 : | ||
2360 | // InternalAlloyLanguage.g:1:376: T__72 | ||
2361 | { | ||
2362 | mT__72(); | ||
2363 | |||
2364 | } | ||
2365 | break; | ||
2366 | case 63 : | ||
2367 | // InternalAlloyLanguage.g:1:382: T__73 | ||
2368 | { | ||
2369 | mT__73(); | ||
2370 | |||
2371 | } | ||
2372 | break; | ||
2373 | case 64 : | ||
2374 | // InternalAlloyLanguage.g:1:388: T__74 | ||
2375 | { | ||
2376 | mT__74(); | ||
2377 | |||
2378 | } | ||
2379 | break; | ||
2380 | case 65 : | ||
2381 | // InternalAlloyLanguage.g:1:394: T__75 | ||
2382 | { | ||
2383 | mT__75(); | ||
2384 | |||
2385 | } | ||
2386 | break; | ||
2387 | case 66 : | ||
2388 | // InternalAlloyLanguage.g:1:400: RULE_ID | ||
2389 | { | ||
2390 | mRULE_ID(); | ||
2391 | |||
2392 | } | ||
2393 | break; | ||
2394 | case 67 : | ||
2395 | // InternalAlloyLanguage.g:1:408: RULE_INT | ||
2396 | { | ||
2397 | mRULE_INT(); | ||
2398 | |||
2399 | } | ||
2400 | break; | ||
2401 | case 68 : | ||
2402 | // InternalAlloyLanguage.g:1:417: RULE_STRING | ||
2403 | { | ||
2404 | mRULE_STRING(); | ||
2405 | |||
2406 | } | ||
2407 | break; | ||
2408 | case 69 : | ||
2409 | // InternalAlloyLanguage.g:1:429: RULE_ML_COMMENT | ||
2410 | { | ||
2411 | mRULE_ML_COMMENT(); | ||
2412 | |||
2413 | } | ||
2414 | break; | ||
2415 | case 70 : | ||
2416 | // InternalAlloyLanguage.g:1:445: RULE_SL_COMMENT | ||
2417 | { | ||
2418 | mRULE_SL_COMMENT(); | ||
2419 | |||
2420 | } | ||
2421 | break; | ||
2422 | case 71 : | ||
2423 | // InternalAlloyLanguage.g:1:461: RULE_WS | ||
2424 | { | ||
2425 | mRULE_WS(); | ||
2426 | |||
2427 | } | ||
2428 | break; | ||
2429 | case 72 : | ||
2430 | // InternalAlloyLanguage.g:1:469: RULE_ANY_OTHER | ||
2431 | { | ||
2432 | mRULE_ANY_OTHER(); | ||
2433 | |||
2434 | } | ||
2435 | break; | ||
2436 | |||
2437 | } | ||
2438 | |||
2439 | } | ||
2440 | |||
2441 | |||
2442 | protected DFA11 dfa11 = new DFA11(this); | ||
2443 | static final String DFA11_eotS = | ||
2444 | "\1\uffff\1\52\1\56\1\61\1\56\1\67\1\71\1\56\1\76\10\56\3\uffff\1\122\1\124\1\56\2\uffff\1\133\1\uffff\1\136\4\uffff\2\56\4\uffff\3\52\3\uffff\1\154\1\56\1\uffff\1\157\2\uffff\2\56\1\162\1\56\4\uffff\3\56\2\uffff\1\171\16\56\7\uffff\3\56\13\uffff\2\56\10\uffff\1\u0090\2\uffff\1\u0091\1\56\1\uffff\1\56\1\u0094\1\u0095\1\56\1\u0097\1\56\1\uffff\1\56\1\u009a\1\u009b\1\u009c\1\u009d\3\56\1\u00a1\1\u00a2\1\u00a3\1\u00a4\5\56\1\u00aa\1\56\1\u00ac\1\56\1\u00ae\2\uffff\1\56\1\u00b0\2\uffff\1\56\1\uffff\1\u00b2\1\u00b3\4\uffff\1\u00b4\1\u00b5\1\u00b6\4\uffff\1\u00b7\1\u00b8\2\56\1\u00bb\1\uffff\1\u00bc\1\uffff\1\u00bd\1\uffff\1\56\1\uffff\1\56\7\uffff\2\56\3\uffff\4\56\1\u00c6\1\56\1\u00c8\1\u00c9\1\uffff\1\u00ca\3\uffff"; | ||
2445 | static final String DFA11_eofS = | ||
2446 | "\u00cb\uffff"; | ||
2447 | static final String DFA11_minS = | ||
2448 | "\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\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\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\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\145\1\uffff\1\141\7\uffff\1\144\1\154\3\uffff\1\163\1\143\1\163\1\171\1\42\1\164\2\42\1\uffff\1\42\3\uffff"; | ||
2449 | static final String DFA11_maxS = | ||
2450 | "\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\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\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\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\145\1\uffff\1\141\7\uffff\1\144\1\154\3\uffff\1\163\1\143\1\163\1\171\1\172\1\164\2\172\1\uffff\1\172\3\uffff"; | ||
2451 | static final String DFA11_acceptS = | ||
2452 | "\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\2\uffff\1\73\1\74\1\102\1\103\3\uffff\1\107\1\110\1\1\2\uffff\1\102\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\2\uffff\1\73\1\74\1\103\1\104\1\105\1\106\1\107\1\2\1\uffff\1\3\1\52\2\uffff\1\34\6\uffff\1\14\26\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\75\1\25\5\uffff\1\37\1\uffff\1\76\1\uffff\1\72\1\uffff\1\70\1\uffff\1\67\1\15\1\16\1\21\1\42\1\100\1\26\2\uffff\1\44\1\43\1\71\10\uffff\1\6\1\uffff\1\33\1\101\1\77"; | ||
2453 | static final String DFA11_specialS = | ||
2454 | "\1\1\45\uffff\1\0\1\2\u00a3\uffff}>"; | ||
2455 | static final String[] DFA11_transitionS = { | ||
2456 | "\11\52\2\51\2\52\1\51\22\52\1\51\1\10\1\46\1\37\2\52\1\6\1\47\1\42\1\43\1\36\1\24\1\23\1\33\1\32\1\50\12\45\1\25\1\52\1\3\1\5\1\31\2\52\10\44\1\41\21\44\1\27\1\52\1\30\1\35\1\44\1\52\1\7\2\44\1\17\1\20\1\26\2\44\1\4\2\44\1\13\1\15\1\11\1\2\1\14\1\44\1\16\1\12\1\44\1\40\5\44\1\21\1\1\1\22\1\34\uff81\52", | ||
2457 | "\1\53", | ||
2458 | "\1\55\3\uffff\1\54", | ||
2459 | "\1\60\2\uffff\1\57", | ||
2460 | "\1\65\1\uffff\1\62\6\uffff\1\63\1\64", | ||
2461 | "\1\66", | ||
2462 | "\1\70", | ||
2463 | "\1\74\11\uffff\1\73\1\uffff\1\72", | ||
2464 | "\1\75", | ||
2465 | "\1\77", | ||
2466 | "\1\101\3\uffff\1\103\5\uffff\1\100\5\uffff\1\102", | ||
2467 | "\1\104", | ||
2468 | "\1\105\5\uffff\1\106", | ||
2469 | "\1\107", | ||
2470 | "\1\110\17\uffff\1\111", | ||
2471 | "\1\112", | ||
2472 | "\1\115\1\uffff\1\113\11\uffff\1\114", | ||
2473 | "", | ||
2474 | "", | ||
2475 | "", | ||
2476 | "\1\121", | ||
2477 | "\1\123", | ||
2478 | "\1\126\15\uffff\1\127\5\uffff\1\125", | ||
2479 | "", | ||
2480 | "", | ||
2481 | "\1\132", | ||
2482 | "", | ||
2483 | "\1\135", | ||
2484 | "", | ||
2485 | "", | ||
2486 | "", | ||
2487 | "", | ||
2488 | "\1\143", | ||
2489 | "\1\144", | ||
2490 | "", | ||
2491 | "", | ||
2492 | "", | ||
2493 | "", | ||
2494 | "\0\150", | ||
2495 | "\0\150", | ||
2496 | "\1\151\4\uffff\1\152", | ||
2497 | "", | ||
2498 | "", | ||
2499 | "", | ||
2500 | "\1\56\4\uffff\1\56\10\uffff\12\56\7\uffff\32\56\4\uffff\1\56\1\uffff\32\56", | ||
2501 | "\1\155", | ||
2502 | "", | ||
2503 | "\1\156", | ||
2504 | "", | ||
2505 | "", | ||
2506 | "\1\160", | ||
2507 | "\1\161", | ||
2508 | "\1\56\4\uffff\1\56\10\uffff\12\56\7\uffff\32\56\4\uffff\1\56\1\uffff\32\56", | ||
2509 | "\1\163", | ||
2510 | "", | ||
2511 | "", | ||
2512 | "", | ||
2513 | "", | ||
2514 | "\1\164", | ||
2515 | "\1\165", | ||
2516 | "\1\166", | ||
2517 | "", | ||
2518 | "", | ||
2519 | "\1\56\4\uffff\1\56\10\uffff\12\56\7\uffff\32\56\4\uffff\1\56\1\uffff\15\56\1\170\5\56\1\167\6\56", | ||
2520 | "\1\172", | ||
2521 | "\1\173", | ||
2522 | "\1\174\12\uffff\1\175", | ||
2523 | "\1\176", | ||
2524 | "\1\177", | ||
2525 | "\1\u0080", | ||
2526 | "\1\u0081", | ||
2527 | "\1\u0082", | ||
2528 | "\1\u0083", | ||
2529 | "\1\u0084", | ||
2530 | "\1\u0086\2\uffff\1\u0085", | ||
2531 | "\1\u0087", | ||
2532 | "\1\u0089\22\uffff\1\u0088", | ||
2533 | "\1\u008a", | ||
2534 | "", | ||
2535 | "", | ||
2536 | "", | ||
2537 | "", | ||
2538 | "", | ||
2539 | "", | ||
2540 | "", | ||
2541 | "\1\u008b", | ||
2542 | "\1\u008c", | ||
2543 | "\1\u008d", | ||
2544 | "", | ||
2545 | "", | ||
2546 | "", | ||
2547 | "", | ||
2548 | "", | ||
2549 | "", | ||
2550 | "", | ||
2551 | "", | ||
2552 | "", | ||
2553 | "", | ||
2554 | "", | ||
2555 | "\1\u008e", | ||
2556 | "\1\u008f", | ||
2557 | "", | ||
2558 | "", | ||
2559 | "", | ||
2560 | "", | ||
2561 | "", | ||
2562 | "", | ||
2563 | "", | ||
2564 | "", | ||
2565 | "\1\56\4\uffff\1\56\10\uffff\12\56\7\uffff\32\56\4\uffff\1\56\1\uffff\32\56", | ||
2566 | "", | ||
2567 | "", | ||
2568 | "\1\56\4\uffff\1\56\10\uffff\12\56\7\uffff\32\56\4\uffff\1\56\1\uffff\32\56", | ||
2569 | "\1\u0092", | ||
2570 | "", | ||
2571 | "\1\u0093", | ||
2572 | "\1\56\4\uffff\1\56\10\uffff\12\56\7\uffff\32\56\4\uffff\1\56\1\uffff\32\56", | ||
2573 | "\1\56\4\uffff\1\56\10\uffff\12\56\7\uffff\32\56\4\uffff\1\56\1\uffff\32\56", | ||
2574 | "\1\u0096", | ||
2575 | "\1\56\4\uffff\1\56\10\uffff\12\56\7\uffff\32\56\4\uffff\1\56\1\uffff\32\56", | ||
2576 | "\1\u0098", | ||
2577 | "", | ||
2578 | "\1\u0099", | ||
2579 | "\1\56\4\uffff\1\56\10\uffff\12\56\7\uffff\32\56\4\uffff\1\56\1\uffff\32\56", | ||
2580 | "\1\56\4\uffff\1\56\10\uffff\12\56\7\uffff\32\56\4\uffff\1\56\1\uffff\32\56", | ||
2581 | "\1\56\4\uffff\1\56\10\uffff\12\56\7\uffff\32\56\4\uffff\1\56\1\uffff\32\56", | ||
2582 | "\1\56\4\uffff\1\56\10\uffff\12\56\7\uffff\32\56\4\uffff\1\56\1\uffff\32\56", | ||
2583 | "\1\u009e", | ||
2584 | "\1\u009f", | ||
2585 | "\1\u00a0", | ||
2586 | "\1\56\4\uffff\1\56\10\uffff\12\56\7\uffff\32\56\4\uffff\1\56\1\uffff\32\56", | ||
2587 | "\1\56\4\uffff\1\56\10\uffff\12\56\7\uffff\32\56\4\uffff\1\56\1\uffff\32\56", | ||
2588 | "\1\56\4\uffff\1\56\10\uffff\12\56\7\uffff\32\56\4\uffff\1\56\1\uffff\32\56", | ||
2589 | "\1\56\4\uffff\1\56\10\uffff\12\56\7\uffff\32\56\4\uffff\1\56\1\uffff\32\56", | ||
2590 | "\1\u00a5", | ||
2591 | "\1\u00a6", | ||
2592 | "\1\u00a7", | ||
2593 | "\1\u00a8", | ||
2594 | "\1\u00a9", | ||
2595 | "\1\56\4\uffff\1\56\10\uffff\12\56\7\uffff\32\56\4\uffff\1\56\1\uffff\32\56", | ||
2596 | "\1\u00ab", | ||
2597 | "\1\56\4\uffff\1\56\10\uffff\12\56\7\uffff\32\56\4\uffff\1\56\1\uffff\32\56", | ||
2598 | "\1\u00ad", | ||
2599 | "\1\56\4\uffff\1\56\10\uffff\12\56\7\uffff\32\56\4\uffff\1\56\1\uffff\32\56", | ||
2600 | "", | ||
2601 | "", | ||
2602 | "\1\u00af", | ||
2603 | "\1\56\4\uffff\1\56\10\uffff\12\56\7\uffff\32\56\4\uffff\1\56\1\uffff\32\56", | ||
2604 | "", | ||
2605 | "", | ||
2606 | "\1\u00b1", | ||
2607 | "", | ||
2608 | "\1\56\4\uffff\1\56\10\uffff\12\56\7\uffff\32\56\4\uffff\1\56\1\uffff\32\56", | ||
2609 | "\1\56\4\uffff\1\56\10\uffff\12\56\7\uffff\32\56\4\uffff\1\56\1\uffff\32\56", | ||
2610 | "", | ||
2611 | "", | ||
2612 | "", | ||
2613 | "", | ||
2614 | "\1\56\4\uffff\1\56\10\uffff\12\56\7\uffff\32\56\4\uffff\1\56\1\uffff\32\56", | ||
2615 | "\1\56\4\uffff\1\56\10\uffff\12\56\7\uffff\32\56\4\uffff\1\56\1\uffff\32\56", | ||
2616 | "\1\56\4\uffff\1\56\10\uffff\12\56\7\uffff\32\56\4\uffff\1\56\1\uffff\32\56", | ||
2617 | "", | ||
2618 | "", | ||
2619 | "", | ||
2620 | "", | ||
2621 | "\1\56\4\uffff\1\56\10\uffff\12\56\7\uffff\32\56\4\uffff\1\56\1\uffff\32\56", | ||
2622 | "\1\56\4\uffff\1\56\10\uffff\12\56\7\uffff\32\56\4\uffff\1\56\1\uffff\32\56", | ||
2623 | "\1\u00b9", | ||
2624 | "\1\u00ba", | ||
2625 | "\1\56\4\uffff\1\56\10\uffff\12\56\7\uffff\32\56\4\uffff\1\56\1\uffff\32\56", | ||
2626 | "", | ||
2627 | "\1\56\4\uffff\1\56\10\uffff\12\56\7\uffff\32\56\4\uffff\1\56\1\uffff\32\56", | ||
2628 | "", | ||
2629 | "\1\56\4\uffff\1\56\10\uffff\12\56\7\uffff\32\56\4\uffff\1\56\1\uffff\32\56", | ||
2630 | "", | ||
2631 | "\1\u00be", | ||
2632 | "", | ||
2633 | "\1\u00bf", | ||
2634 | "", | ||
2635 | "", | ||
2636 | "", | ||
2637 | "", | ||
2638 | "", | ||
2639 | "", | ||
2640 | "", | ||
2641 | "\1\u00c0", | ||
2642 | "\1\u00c1", | ||
2643 | "", | ||
2644 | "", | ||
2645 | "", | ||
2646 | "\1\u00c2", | ||
2647 | "\1\u00c3", | ||
2648 | "\1\u00c4", | ||
2649 | "\1\u00c5", | ||
2650 | "\1\56\4\uffff\1\56\10\uffff\12\56\7\uffff\32\56\4\uffff\1\56\1\uffff\32\56", | ||
2651 | "\1\u00c7", | ||
2652 | "\1\56\4\uffff\1\56\10\uffff\12\56\7\uffff\32\56\4\uffff\1\56\1\uffff\32\56", | ||
2653 | "\1\56\4\uffff\1\56\10\uffff\12\56\7\uffff\32\56\4\uffff\1\56\1\uffff\32\56", | ||
2654 | "", | ||
2655 | "\1\56\4\uffff\1\56\10\uffff\12\56\7\uffff\32\56\4\uffff\1\56\1\uffff\32\56", | ||
2656 | "", | ||
2657 | "", | ||
2658 | "" | ||
2659 | }; | ||
2660 | |||
2661 | static final short[] DFA11_eot = DFA.unpackEncodedString(DFA11_eotS); | ||
2662 | static final short[] DFA11_eof = DFA.unpackEncodedString(DFA11_eofS); | ||
2663 | static final char[] DFA11_min = DFA.unpackEncodedStringToUnsignedChars(DFA11_minS); | ||
2664 | static final char[] DFA11_max = DFA.unpackEncodedStringToUnsignedChars(DFA11_maxS); | ||
2665 | static final short[] DFA11_accept = DFA.unpackEncodedString(DFA11_acceptS); | ||
2666 | static final short[] DFA11_special = DFA.unpackEncodedString(DFA11_specialS); | ||
2667 | static final short[][] DFA11_transition; | ||
2668 | |||
2669 | static { | ||
2670 | int numStates = DFA11_transitionS.length; | ||
2671 | DFA11_transition = new short[numStates][]; | ||
2672 | for (int i=0; i<numStates; i++) { | ||
2673 | DFA11_transition[i] = DFA.unpackEncodedString(DFA11_transitionS[i]); | ||
2674 | } | ||
2675 | } | ||
2676 | |||
2677 | class DFA11 extends DFA { | ||
2678 | |||
2679 | public DFA11(BaseRecognizer recognizer) { | ||
2680 | this.recognizer = recognizer; | ||
2681 | this.decisionNumber = 11; | ||
2682 | this.eot = DFA11_eot; | ||
2683 | this.eof = DFA11_eof; | ||
2684 | this.min = DFA11_min; | ||
2685 | this.max = DFA11_max; | ||
2686 | this.accept = DFA11_accept; | ||
2687 | this.special = DFA11_special; | ||
2688 | this.transition = DFA11_transition; | ||
2689 | } | ||
2690 | public String getDescription() { | ||
2691 | 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 | RULE_ID | RULE_INT | RULE_STRING | RULE_ML_COMMENT | RULE_SL_COMMENT | RULE_WS | RULE_ANY_OTHER );"; | ||
2692 | } | ||
2693 | public int specialStateTransition(int s, IntStream _input) throws NoViableAltException { | ||
2694 | IntStream input = _input; | ||
2695 | int _s = s; | ||
2696 | switch ( s ) { | ||
2697 | case 0 : | ||
2698 | int LA11_38 = input.LA(1); | ||
2699 | |||
2700 | s = -1; | ||
2701 | if ( ((LA11_38>='\u0000' && LA11_38<='\uFFFF')) ) {s = 104;} | ||
2702 | |||
2703 | else s = 42; | ||
2704 | |||
2705 | if ( s>=0 ) return s; | ||
2706 | break; | ||
2707 | case 1 : | ||
2708 | int LA11_0 = input.LA(1); | ||
2709 | |||
2710 | s = -1; | ||
2711 | if ( (LA11_0=='|') ) {s = 1;} | ||
2712 | |||
2713 | else if ( (LA11_0=='o') ) {s = 2;} | ||
2714 | |||
2715 | else if ( (LA11_0=='<') ) {s = 3;} | ||
2716 | |||
2717 | else if ( (LA11_0=='i') ) {s = 4;} | ||
2718 | |||
2719 | else if ( (LA11_0=='=') ) {s = 5;} | ||
2720 | |||
2721 | else if ( (LA11_0=='&') ) {s = 6;} | ||
2722 | |||
2723 | else if ( (LA11_0=='a') ) {s = 7;} | ||
2724 | |||
2725 | else if ( (LA11_0=='!') ) {s = 8;} | ||
2726 | |||
2727 | else if ( (LA11_0=='n') ) {s = 9;} | ||
2728 | |||
2729 | else if ( (LA11_0=='s') ) {s = 10;} | ||
2730 | |||
2731 | else if ( (LA11_0=='l') ) {s = 11;} | ||
2732 | |||
2733 | else if ( (LA11_0=='p') ) {s = 12;} | ||
2734 | |||
2735 | else if ( (LA11_0=='m') ) {s = 13;} | ||
2736 | |||
2737 | else if ( (LA11_0=='r') ) {s = 14;} | ||
2738 | |||
2739 | else if ( (LA11_0=='d') ) {s = 15;} | ||
2740 | |||
2741 | else if ( (LA11_0=='e') ) {s = 16;} | ||
2742 | |||
2743 | else if ( (LA11_0=='{') ) {s = 17;} | ||
2744 | |||
2745 | else if ( (LA11_0=='}') ) {s = 18;} | ||
2746 | |||
2747 | else if ( (LA11_0==',') ) {s = 19;} | ||
2748 | |||
2749 | else if ( (LA11_0=='+') ) {s = 20;} | ||
2750 | |||
2751 | else if ( (LA11_0==':') ) {s = 21;} | ||
2752 | |||
2753 | else if ( (LA11_0=='f') ) {s = 22;} | ||
2754 | |||
2755 | else if ( (LA11_0=='[') ) {s = 23;} | ||
2756 | |||
2757 | else if ( (LA11_0==']') ) {s = 24;} | ||
2758 | |||
2759 | else if ( (LA11_0=='>') ) {s = 25;} | ||
2760 | |||
2761 | else if ( (LA11_0=='.') ) {s = 26;} | ||
2762 | |||
2763 | else if ( (LA11_0=='-') ) {s = 27;} | ||
2764 | |||
2765 | else if ( (LA11_0=='~') ) {s = 28;} | ||
2766 | |||
2767 | else if ( (LA11_0=='^') ) {s = 29;} | ||
2768 | |||
2769 | else if ( (LA11_0=='*') ) {s = 30;} | ||
2770 | |||
2771 | else if ( (LA11_0=='#') ) {s = 31;} | ||
2772 | |||
2773 | else if ( (LA11_0=='u') ) {s = 32;} | ||
2774 | |||
2775 | else if ( (LA11_0=='I') ) {s = 33;} | ||
2776 | |||
2777 | else if ( (LA11_0=='(') ) {s = 34;} | ||
2778 | |||
2779 | else if ( (LA11_0==')') ) {s = 35;} | ||
2780 | |||
2781 | else if ( ((LA11_0>='A' && LA11_0<='H')||(LA11_0>='J' && 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 = 36;} | ||
2782 | |||
2783 | else if ( ((LA11_0>='0' && LA11_0<='9')) ) {s = 37;} | ||
2784 | |||
2785 | else if ( (LA11_0=='\"') ) {s = 38;} | ||
2786 | |||
2787 | else if ( (LA11_0=='\'') ) {s = 39;} | ||
2788 | |||
2789 | else if ( (LA11_0=='/') ) {s = 40;} | ||
2790 | |||
2791 | else if ( ((LA11_0>='\t' && LA11_0<='\n')||LA11_0=='\r'||LA11_0==' ') ) {s = 41;} | ||
2792 | |||
2793 | 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 = 42;} | ||
2794 | |||
2795 | if ( s>=0 ) return s; | ||
2796 | break; | ||
2797 | case 2 : | ||
2798 | int LA11_39 = input.LA(1); | ||
2799 | |||
2800 | s = -1; | ||
2801 | if ( ((LA11_39>='\u0000' && LA11_39<='\uFFFF')) ) {s = 104;} | ||
2802 | |||
2803 | else s = 42; | ||
2804 | |||
2805 | if ( s>=0 ) return s; | ||
2806 | break; | ||
2807 | } | ||
2808 | NoViableAltException nvae = | ||
2809 | new NoViableAltException(getDescription(), 11, _s, input); | ||
2810 | error(nvae); | ||
2811 | throw nvae; | ||
2812 | } | ||
2813 | } | ||
2814 | |||
2815 | |||
2816 | } \ No newline at end of file | ||
diff --git a/Solvers/Alloy-Solver/hu.bme.mit.inf.dslreasoner.alloy.language.ui/src-gen/hu/bme/mit/inf/dslreasoner/ui/contentassist/antlr/internal/InternalAlloyLanguageParser.java b/Solvers/Alloy-Solver/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..0ba4673a --- /dev/null +++ b/Solvers/Alloy-Solver/hu.bme.mit.inf.dslreasoner.alloy.language.ui/src-gen/hu/bme/mit/inf/dslreasoner/ui/contentassist/antlr/internal/InternalAlloyLanguageParser.java | |||
@@ -0,0 +1,28710 @@ | |||
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'", "'('", "')'", "'run'", "'for'", "'abstract'", "'disj'", "'exactly'" | ||
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 RULE_WS=9; | ||
90 | public static final int RULE_ANY_OTHER=10; | ||
91 | public static final int T__48=48; | ||
92 | public static final int T__49=49; | ||
93 | public static final int T__44=44; | ||
94 | public static final int T__45=45; | ||
95 | public static final int T__46=46; | ||
96 | public static final int T__47=47; | ||
97 | public static final int T__40=40; | ||
98 | public static final int T__41=41; | ||
99 | public static final int T__42=42; | ||
100 | public static final int T__43=43; | ||
101 | |||
102 | // delegates | ||
103 | // delegators | ||
104 | |||
105 | |||
106 | public InternalAlloyLanguageParser(TokenStream input) { | ||
107 | this(input, new RecognizerSharedState()); | ||
108 | } | ||
109 | public InternalAlloyLanguageParser(TokenStream input, RecognizerSharedState state) { | ||
110 | super(input, state); | ||
111 | |||
112 | } | ||
113 | |||
114 | |||
115 | public String[] getTokenNames() { return InternalAlloyLanguageParser.tokenNames; } | ||
116 | public String getGrammarFileName() { return "InternalAlloyLanguage.g"; } | ||
117 | |||
118 | |||
119 | |||
120 | private AlloyLanguageGrammarAccess grammarAccess; | ||
121 | |||
122 | public void setGrammarAccess(AlloyLanguageGrammarAccess grammarAccess) { | ||
123 | this.grammarAccess = grammarAccess; | ||
124 | } | ||
125 | |||
126 | @Override | ||
127 | protected Grammar getGrammar() { | ||
128 | return grammarAccess.getGrammar(); | ||
129 | } | ||
130 | |||
131 | @Override | ||
132 | protected String getValueForTokenName(String tokenName) { | ||
133 | return tokenName; | ||
134 | } | ||
135 | |||
136 | |||
137 | |||
138 | |||
139 | // $ANTLR start "entryRuleALSDocument" | ||
140 | // InternalAlloyLanguage.g:61:1: entryRuleALSDocument : ruleALSDocument EOF ; | ||
141 | public final void entryRuleALSDocument() throws RecognitionException { | ||
142 | try { | ||
143 | // InternalAlloyLanguage.g:62:1: ( ruleALSDocument EOF ) | ||
144 | // InternalAlloyLanguage.g:63:1: ruleALSDocument EOF | ||
145 | { | ||
146 | if ( state.backtracking==0 ) { | ||
147 | before(grammarAccess.getALSDocumentRule()); | ||
148 | } | ||
149 | pushFollow(FOLLOW_1); | ||
150 | ruleALSDocument(); | ||
151 | |||
152 | state._fsp--; | ||
153 | if (state.failed) return ; | ||
154 | if ( state.backtracking==0 ) { | ||
155 | after(grammarAccess.getALSDocumentRule()); | ||
156 | } | ||
157 | match(input,EOF,FOLLOW_2); if (state.failed) return ; | ||
158 | |||
159 | } | ||
160 | |||
161 | } | ||
162 | catch (RecognitionException re) { | ||
163 | reportError(re); | ||
164 | recover(input,re); | ||
165 | } | ||
166 | finally { | ||
167 | } | ||
168 | return ; | ||
169 | } | ||
170 | // $ANTLR end "entryRuleALSDocument" | ||
171 | |||
172 | |||
173 | // $ANTLR start "ruleALSDocument" | ||
174 | // InternalAlloyLanguage.g:70:1: ruleALSDocument : ( ( rule__ALSDocument__Group__0 ) ) ; | ||
175 | public final void ruleALSDocument() throws RecognitionException { | ||
176 | |||
177 | int stackSize = keepStackSize(); | ||
178 | |||
179 | try { | ||
180 | // InternalAlloyLanguage.g:74:2: ( ( ( rule__ALSDocument__Group__0 ) ) ) | ||
181 | // InternalAlloyLanguage.g:75:1: ( ( rule__ALSDocument__Group__0 ) ) | ||
182 | { | ||
183 | // InternalAlloyLanguage.g:75:1: ( ( rule__ALSDocument__Group__0 ) ) | ||
184 | // InternalAlloyLanguage.g:76:1: ( rule__ALSDocument__Group__0 ) | ||
185 | { | ||
186 | if ( state.backtracking==0 ) { | ||
187 | before(grammarAccess.getALSDocumentAccess().getGroup()); | ||
188 | } | ||
189 | // InternalAlloyLanguage.g:77:1: ( rule__ALSDocument__Group__0 ) | ||
190 | // InternalAlloyLanguage.g:77:2: rule__ALSDocument__Group__0 | ||
191 | { | ||
192 | pushFollow(FOLLOW_2); | ||
193 | rule__ALSDocument__Group__0(); | ||
194 | |||
195 | state._fsp--; | ||
196 | if (state.failed) return ; | ||
197 | |||
198 | } | ||
199 | |||
200 | if ( state.backtracking==0 ) { | ||
201 | after(grammarAccess.getALSDocumentAccess().getGroup()); | ||
202 | } | ||
203 | |||
204 | } | ||
205 | |||
206 | |||
207 | } | ||
208 | |||
209 | } | ||
210 | catch (RecognitionException re) { | ||
211 | reportError(re); | ||
212 | recover(input,re); | ||
213 | } | ||
214 | finally { | ||
215 | |||
216 | restoreStackSize(stackSize); | ||
217 | |||
218 | } | ||
219 | return ; | ||
220 | } | ||
221 | // $ANTLR end "ruleALSDocument" | ||
222 | |||
223 | |||
224 | // $ANTLR start "entryRuleALSID" | ||
225 | // InternalAlloyLanguage.g:89:1: entryRuleALSID : ruleALSID EOF ; | ||
226 | public final void entryRuleALSID() throws RecognitionException { | ||
227 | try { | ||
228 | // InternalAlloyLanguage.g:90:1: ( ruleALSID EOF ) | ||
229 | // InternalAlloyLanguage.g:91:1: ruleALSID EOF | ||
230 | { | ||
231 | if ( state.backtracking==0 ) { | ||
232 | before(grammarAccess.getALSIDRule()); | ||
233 | } | ||
234 | pushFollow(FOLLOW_1); | ||
235 | ruleALSID(); | ||
236 | |||
237 | state._fsp--; | ||
238 | if (state.failed) return ; | ||
239 | if ( state.backtracking==0 ) { | ||
240 | after(grammarAccess.getALSIDRule()); | ||
241 | } | ||
242 | match(input,EOF,FOLLOW_2); if (state.failed) return ; | ||
243 | |||
244 | } | ||
245 | |||
246 | } | ||
247 | catch (RecognitionException re) { | ||
248 | reportError(re); | ||
249 | recover(input,re); | ||
250 | } | ||
251 | finally { | ||
252 | } | ||
253 | return ; | ||
254 | } | ||
255 | // $ANTLR end "entryRuleALSID" | ||
256 | |||
257 | |||
258 | // $ANTLR start "ruleALSID" | ||
259 | // InternalAlloyLanguage.g:98:1: ruleALSID : ( RULE_ID ) ; | ||
260 | public final void ruleALSID() throws RecognitionException { | ||
261 | |||
262 | int stackSize = keepStackSize(); | ||
263 | |||
264 | try { | ||
265 | // InternalAlloyLanguage.g:102:2: ( ( RULE_ID ) ) | ||
266 | // InternalAlloyLanguage.g:103:1: ( RULE_ID ) | ||
267 | { | ||
268 | // InternalAlloyLanguage.g:103:1: ( RULE_ID ) | ||
269 | // InternalAlloyLanguage.g:104:1: RULE_ID | ||
270 | { | ||
271 | if ( state.backtracking==0 ) { | ||
272 | before(grammarAccess.getALSIDAccess().getIDTerminalRuleCall()); | ||
273 | } | ||
274 | match(input,RULE_ID,FOLLOW_2); if (state.failed) return ; | ||
275 | if ( state.backtracking==0 ) { | ||
276 | after(grammarAccess.getALSIDAccess().getIDTerminalRuleCall()); | ||
277 | } | ||
278 | |||
279 | } | ||
280 | |||
281 | |||
282 | } | ||
283 | |||
284 | } | ||
285 | catch (RecognitionException re) { | ||
286 | reportError(re); | ||
287 | recover(input,re); | ||
288 | } | ||
289 | finally { | ||
290 | |||
291 | restoreStackSize(stackSize); | ||
292 | |||
293 | } | ||
294 | return ; | ||
295 | } | ||
296 | // $ANTLR end "ruleALSID" | ||
297 | |||
298 | |||
299 | // $ANTLR start "entryRuleALSTypeDeclaration" | ||
300 | // InternalAlloyLanguage.g:119:1: entryRuleALSTypeDeclaration : ruleALSTypeDeclaration EOF ; | ||
301 | public final void entryRuleALSTypeDeclaration() throws RecognitionException { | ||
302 | try { | ||
303 | // InternalAlloyLanguage.g:120:1: ( ruleALSTypeDeclaration EOF ) | ||
304 | // InternalAlloyLanguage.g:121:1: ruleALSTypeDeclaration EOF | ||
305 | { | ||
306 | if ( state.backtracking==0 ) { | ||
307 | before(grammarAccess.getALSTypeDeclarationRule()); | ||
308 | } | ||
309 | pushFollow(FOLLOW_1); | ||
310 | ruleALSTypeDeclaration(); | ||
311 | |||
312 | state._fsp--; | ||
313 | if (state.failed) return ; | ||
314 | if ( state.backtracking==0 ) { | ||
315 | after(grammarAccess.getALSTypeDeclarationRule()); | ||
316 | } | ||
317 | match(input,EOF,FOLLOW_2); if (state.failed) return ; | ||
318 | |||
319 | } | ||
320 | |||
321 | } | ||
322 | catch (RecognitionException re) { | ||
323 | reportError(re); | ||
324 | recover(input,re); | ||
325 | } | ||
326 | finally { | ||
327 | } | ||
328 | return ; | ||
329 | } | ||
330 | // $ANTLR end "entryRuleALSTypeDeclaration" | ||
331 | |||
332 | |||
333 | // $ANTLR start "ruleALSTypeDeclaration" | ||
334 | // InternalAlloyLanguage.g:128:1: ruleALSTypeDeclaration : ( ( rule__ALSTypeDeclaration__Alternatives ) ) ; | ||
335 | public final void ruleALSTypeDeclaration() throws RecognitionException { | ||
336 | |||
337 | int stackSize = keepStackSize(); | ||
338 | |||
339 | try { | ||
340 | // InternalAlloyLanguage.g:132:2: ( ( ( rule__ALSTypeDeclaration__Alternatives ) ) ) | ||
341 | // InternalAlloyLanguage.g:133:1: ( ( rule__ALSTypeDeclaration__Alternatives ) ) | ||
342 | { | ||
343 | // InternalAlloyLanguage.g:133:1: ( ( rule__ALSTypeDeclaration__Alternatives ) ) | ||
344 | // InternalAlloyLanguage.g:134:1: ( rule__ALSTypeDeclaration__Alternatives ) | ||
345 | { | ||
346 | if ( state.backtracking==0 ) { | ||
347 | before(grammarAccess.getALSTypeDeclarationAccess().getAlternatives()); | ||
348 | } | ||
349 | // InternalAlloyLanguage.g:135:1: ( rule__ALSTypeDeclaration__Alternatives ) | ||
350 | // InternalAlloyLanguage.g:135:2: rule__ALSTypeDeclaration__Alternatives | ||
351 | { | ||
352 | pushFollow(FOLLOW_2); | ||
353 | rule__ALSTypeDeclaration__Alternatives(); | ||
354 | |||
355 | state._fsp--; | ||
356 | if (state.failed) return ; | ||
357 | |||
358 | } | ||
359 | |||
360 | if ( state.backtracking==0 ) { | ||
361 | after(grammarAccess.getALSTypeDeclarationAccess().getAlternatives()); | ||
362 | } | ||
363 | |||
364 | } | ||
365 | |||
366 | |||
367 | } | ||
368 | |||
369 | } | ||
370 | catch (RecognitionException re) { | ||
371 | reportError(re); | ||
372 | recover(input,re); | ||
373 | } | ||
374 | finally { | ||
375 | |||
376 | restoreStackSize(stackSize); | ||
377 | |||
378 | } | ||
379 | return ; | ||
380 | } | ||
381 | // $ANTLR end "ruleALSTypeDeclaration" | ||
382 | |||
383 | |||
384 | // $ANTLR start "entryRuleALSEnumDeclaration" | ||
385 | // InternalAlloyLanguage.g:147:1: entryRuleALSEnumDeclaration : ruleALSEnumDeclaration EOF ; | ||
386 | public final void entryRuleALSEnumDeclaration() throws RecognitionException { | ||
387 | try { | ||
388 | // InternalAlloyLanguage.g:148:1: ( ruleALSEnumDeclaration EOF ) | ||
389 | // InternalAlloyLanguage.g:149:1: ruleALSEnumDeclaration EOF | ||
390 | { | ||
391 | if ( state.backtracking==0 ) { | ||
392 | before(grammarAccess.getALSEnumDeclarationRule()); | ||
393 | } | ||
394 | pushFollow(FOLLOW_1); | ||
395 | ruleALSEnumDeclaration(); | ||
396 | |||
397 | state._fsp--; | ||
398 | if (state.failed) return ; | ||
399 | if ( state.backtracking==0 ) { | ||
400 | after(grammarAccess.getALSEnumDeclarationRule()); | ||
401 | } | ||
402 | match(input,EOF,FOLLOW_2); if (state.failed) return ; | ||
403 | |||
404 | } | ||
405 | |||
406 | } | ||
407 | catch (RecognitionException re) { | ||
408 | reportError(re); | ||
409 | recover(input,re); | ||
410 | } | ||
411 | finally { | ||
412 | } | ||
413 | return ; | ||
414 | } | ||
415 | // $ANTLR end "entryRuleALSEnumDeclaration" | ||
416 | |||
417 | |||
418 | // $ANTLR start "ruleALSEnumDeclaration" | ||
419 | // InternalAlloyLanguage.g:156:1: ruleALSEnumDeclaration : ( ( rule__ALSEnumDeclaration__Group__0 ) ) ; | ||
420 | public final void ruleALSEnumDeclaration() throws RecognitionException { | ||
421 | |||
422 | int stackSize = keepStackSize(); | ||
423 | |||
424 | try { | ||
425 | // InternalAlloyLanguage.g:160:2: ( ( ( rule__ALSEnumDeclaration__Group__0 ) ) ) | ||
426 | // InternalAlloyLanguage.g:161:1: ( ( rule__ALSEnumDeclaration__Group__0 ) ) | ||
427 | { | ||
428 | // InternalAlloyLanguage.g:161:1: ( ( rule__ALSEnumDeclaration__Group__0 ) ) | ||
429 | // InternalAlloyLanguage.g:162:1: ( rule__ALSEnumDeclaration__Group__0 ) | ||
430 | { | ||
431 | if ( state.backtracking==0 ) { | ||
432 | before(grammarAccess.getALSEnumDeclarationAccess().getGroup()); | ||
433 | } | ||
434 | // InternalAlloyLanguage.g:163:1: ( rule__ALSEnumDeclaration__Group__0 ) | ||
435 | // InternalAlloyLanguage.g:163:2: rule__ALSEnumDeclaration__Group__0 | ||
436 | { | ||
437 | pushFollow(FOLLOW_2); | ||
438 | rule__ALSEnumDeclaration__Group__0(); | ||
439 | |||
440 | state._fsp--; | ||
441 | if (state.failed) return ; | ||
442 | |||
443 | } | ||
444 | |||
445 | if ( state.backtracking==0 ) { | ||
446 | after(grammarAccess.getALSEnumDeclarationAccess().getGroup()); | ||
447 | } | ||
448 | |||
449 | } | ||
450 | |||
451 | |||
452 | } | ||
453 | |||
454 | } | ||
455 | catch (RecognitionException re) { | ||
456 | reportError(re); | ||
457 | recover(input,re); | ||
458 | } | ||
459 | finally { | ||
460 | |||
461 | restoreStackSize(stackSize); | ||
462 | |||
463 | } | ||
464 | return ; | ||
465 | } | ||
466 | // $ANTLR end "ruleALSEnumDeclaration" | ||
467 | |||
468 | |||
469 | // $ANTLR start "entryRuleALSEnumLiteral" | ||
470 | // InternalAlloyLanguage.g:175:1: entryRuleALSEnumLiteral : ruleALSEnumLiteral EOF ; | ||
471 | public final void entryRuleALSEnumLiteral() throws RecognitionException { | ||
472 | try { | ||
473 | // InternalAlloyLanguage.g:176:1: ( ruleALSEnumLiteral EOF ) | ||
474 | // InternalAlloyLanguage.g:177:1: ruleALSEnumLiteral EOF | ||
475 | { | ||
476 | if ( state.backtracking==0 ) { | ||
477 | before(grammarAccess.getALSEnumLiteralRule()); | ||
478 | } | ||
479 | pushFollow(FOLLOW_1); | ||
480 | ruleALSEnumLiteral(); | ||
481 | |||
482 | state._fsp--; | ||
483 | if (state.failed) return ; | ||
484 | if ( state.backtracking==0 ) { | ||
485 | after(grammarAccess.getALSEnumLiteralRule()); | ||
486 | } | ||
487 | match(input,EOF,FOLLOW_2); if (state.failed) return ; | ||
488 | |||
489 | } | ||
490 | |||
491 | } | ||
492 | catch (RecognitionException re) { | ||
493 | reportError(re); | ||
494 | recover(input,re); | ||
495 | } | ||
496 | finally { | ||
497 | } | ||
498 | return ; | ||
499 | } | ||
500 | // $ANTLR end "entryRuleALSEnumLiteral" | ||
501 | |||
502 | |||
503 | // $ANTLR start "ruleALSEnumLiteral" | ||
504 | // InternalAlloyLanguage.g:184:1: ruleALSEnumLiteral : ( ( rule__ALSEnumLiteral__NameAssignment ) ) ; | ||
505 | public final void ruleALSEnumLiteral() throws RecognitionException { | ||
506 | |||
507 | int stackSize = keepStackSize(); | ||
508 | |||
509 | try { | ||
510 | // InternalAlloyLanguage.g:188:2: ( ( ( rule__ALSEnumLiteral__NameAssignment ) ) ) | ||
511 | // InternalAlloyLanguage.g:189:1: ( ( rule__ALSEnumLiteral__NameAssignment ) ) | ||
512 | { | ||
513 | // InternalAlloyLanguage.g:189:1: ( ( rule__ALSEnumLiteral__NameAssignment ) ) | ||
514 | // InternalAlloyLanguage.g:190:1: ( rule__ALSEnumLiteral__NameAssignment ) | ||
515 | { | ||
516 | if ( state.backtracking==0 ) { | ||
517 | before(grammarAccess.getALSEnumLiteralAccess().getNameAssignment()); | ||
518 | } | ||
519 | // InternalAlloyLanguage.g:191:1: ( rule__ALSEnumLiteral__NameAssignment ) | ||
520 | // InternalAlloyLanguage.g:191:2: rule__ALSEnumLiteral__NameAssignment | ||
521 | { | ||
522 | pushFollow(FOLLOW_2); | ||
523 | rule__ALSEnumLiteral__NameAssignment(); | ||
524 | |||
525 | state._fsp--; | ||
526 | if (state.failed) return ; | ||
527 | |||
528 | } | ||
529 | |||
530 | if ( state.backtracking==0 ) { | ||
531 | after(grammarAccess.getALSEnumLiteralAccess().getNameAssignment()); | ||
532 | } | ||
533 | |||
534 | } | ||
535 | |||
536 | |||
537 | } | ||
538 | |||
539 | } | ||
540 | catch (RecognitionException re) { | ||
541 | reportError(re); | ||
542 | recover(input,re); | ||
543 | } | ||
544 | finally { | ||
545 | |||
546 | restoreStackSize(stackSize); | ||
547 | |||
548 | } | ||
549 | return ; | ||
550 | } | ||
551 | // $ANTLR end "ruleALSEnumLiteral" | ||
552 | |||
553 | |||
554 | // $ANTLR start "entryRuleALSSignatureDeclaration" | ||
555 | // InternalAlloyLanguage.g:203:1: entryRuleALSSignatureDeclaration : ruleALSSignatureDeclaration EOF ; | ||
556 | public final void entryRuleALSSignatureDeclaration() throws RecognitionException { | ||
557 | try { | ||
558 | // InternalAlloyLanguage.g:204:1: ( ruleALSSignatureDeclaration EOF ) | ||
559 | // InternalAlloyLanguage.g:205:1: ruleALSSignatureDeclaration EOF | ||
560 | { | ||
561 | if ( state.backtracking==0 ) { | ||
562 | before(grammarAccess.getALSSignatureDeclarationRule()); | ||
563 | } | ||
564 | pushFollow(FOLLOW_1); | ||
565 | ruleALSSignatureDeclaration(); | ||
566 | |||
567 | state._fsp--; | ||
568 | if (state.failed) return ; | ||
569 | if ( state.backtracking==0 ) { | ||
570 | after(grammarAccess.getALSSignatureDeclarationRule()); | ||
571 | } | ||
572 | match(input,EOF,FOLLOW_2); if (state.failed) return ; | ||
573 | |||
574 | } | ||
575 | |||
576 | } | ||
577 | catch (RecognitionException re) { | ||
578 | reportError(re); | ||
579 | recover(input,re); | ||
580 | } | ||
581 | finally { | ||
582 | } | ||
583 | return ; | ||
584 | } | ||
585 | // $ANTLR end "entryRuleALSSignatureDeclaration" | ||
586 | |||
587 | |||
588 | // $ANTLR start "ruleALSSignatureDeclaration" | ||
589 | // InternalAlloyLanguage.g:212:1: ruleALSSignatureDeclaration : ( ( rule__ALSSignatureDeclaration__NameAssignment ) ) ; | ||
590 | public final void ruleALSSignatureDeclaration() throws RecognitionException { | ||
591 | |||
592 | int stackSize = keepStackSize(); | ||
593 | |||
594 | try { | ||
595 | // InternalAlloyLanguage.g:216:2: ( ( ( rule__ALSSignatureDeclaration__NameAssignment ) ) ) | ||
596 | // InternalAlloyLanguage.g:217:1: ( ( rule__ALSSignatureDeclaration__NameAssignment ) ) | ||
597 | { | ||
598 | // InternalAlloyLanguage.g:217:1: ( ( rule__ALSSignatureDeclaration__NameAssignment ) ) | ||
599 | // InternalAlloyLanguage.g:218:1: ( rule__ALSSignatureDeclaration__NameAssignment ) | ||
600 | { | ||
601 | if ( state.backtracking==0 ) { | ||
602 | before(grammarAccess.getALSSignatureDeclarationAccess().getNameAssignment()); | ||
603 | } | ||
604 | // InternalAlloyLanguage.g:219:1: ( rule__ALSSignatureDeclaration__NameAssignment ) | ||
605 | // InternalAlloyLanguage.g:219:2: rule__ALSSignatureDeclaration__NameAssignment | ||
606 | { | ||
607 | pushFollow(FOLLOW_2); | ||
608 | rule__ALSSignatureDeclaration__NameAssignment(); | ||
609 | |||
610 | state._fsp--; | ||
611 | if (state.failed) return ; | ||
612 | |||
613 | } | ||
614 | |||
615 | if ( state.backtracking==0 ) { | ||
616 | after(grammarAccess.getALSSignatureDeclarationAccess().getNameAssignment()); | ||
617 | } | ||
618 | |||
619 | } | ||
620 | |||
621 | |||
622 | } | ||
623 | |||
624 | } | ||
625 | catch (RecognitionException re) { | ||
626 | reportError(re); | ||
627 | recover(input,re); | ||
628 | } | ||
629 | finally { | ||
630 | |||
631 | restoreStackSize(stackSize); | ||
632 | |||
633 | } | ||
634 | return ; | ||
635 | } | ||
636 | // $ANTLR end "ruleALSSignatureDeclaration" | ||
637 | |||
638 | |||
639 | // $ANTLR start "entryRuleALSSignatureBody" | ||
640 | // InternalAlloyLanguage.g:231:1: entryRuleALSSignatureBody : ruleALSSignatureBody EOF ; | ||
641 | public final void entryRuleALSSignatureBody() throws RecognitionException { | ||
642 | try { | ||
643 | // InternalAlloyLanguage.g:232:1: ( ruleALSSignatureBody EOF ) | ||
644 | // InternalAlloyLanguage.g:233:1: ruleALSSignatureBody EOF | ||
645 | { | ||
646 | if ( state.backtracking==0 ) { | ||
647 | before(grammarAccess.getALSSignatureBodyRule()); | ||
648 | } | ||
649 | pushFollow(FOLLOW_1); | ||
650 | ruleALSSignatureBody(); | ||
651 | |||
652 | state._fsp--; | ||
653 | if (state.failed) return ; | ||
654 | if ( state.backtracking==0 ) { | ||
655 | after(grammarAccess.getALSSignatureBodyRule()); | ||
656 | } | ||
657 | match(input,EOF,FOLLOW_2); if (state.failed) return ; | ||
658 | |||
659 | } | ||
660 | |||
661 | } | ||
662 | catch (RecognitionException re) { | ||
663 | reportError(re); | ||
664 | recover(input,re); | ||
665 | } | ||
666 | finally { | ||
667 | } | ||
668 | return ; | ||
669 | } | ||
670 | // $ANTLR end "entryRuleALSSignatureBody" | ||
671 | |||
672 | |||
673 | // $ANTLR start "ruleALSSignatureBody" | ||
674 | // InternalAlloyLanguage.g:240:1: ruleALSSignatureBody : ( ( rule__ALSSignatureBody__Group__0 ) ) ; | ||
675 | public final void ruleALSSignatureBody() throws RecognitionException { | ||
676 | |||
677 | int stackSize = keepStackSize(); | ||
678 | |||
679 | try { | ||
680 | // InternalAlloyLanguage.g:244:2: ( ( ( rule__ALSSignatureBody__Group__0 ) ) ) | ||
681 | // InternalAlloyLanguage.g:245:1: ( ( rule__ALSSignatureBody__Group__0 ) ) | ||
682 | { | ||
683 | // InternalAlloyLanguage.g:245:1: ( ( rule__ALSSignatureBody__Group__0 ) ) | ||
684 | // InternalAlloyLanguage.g:246:1: ( rule__ALSSignatureBody__Group__0 ) | ||
685 | { | ||
686 | if ( state.backtracking==0 ) { | ||
687 | before(grammarAccess.getALSSignatureBodyAccess().getGroup()); | ||
688 | } | ||
689 | // InternalAlloyLanguage.g:247:1: ( rule__ALSSignatureBody__Group__0 ) | ||
690 | // InternalAlloyLanguage.g:247:2: rule__ALSSignatureBody__Group__0 | ||
691 | { | ||
692 | pushFollow(FOLLOW_2); | ||
693 | rule__ALSSignatureBody__Group__0(); | ||
694 | |||
695 | state._fsp--; | ||
696 | if (state.failed) return ; | ||
697 | |||
698 | } | ||
699 | |||
700 | if ( state.backtracking==0 ) { | ||
701 | after(grammarAccess.getALSSignatureBodyAccess().getGroup()); | ||
702 | } | ||
703 | |||
704 | } | ||
705 | |||
706 | |||
707 | } | ||
708 | |||
709 | } | ||
710 | catch (RecognitionException re) { | ||
711 | reportError(re); | ||
712 | recover(input,re); | ||
713 | } | ||
714 | finally { | ||
715 | |||
716 | restoreStackSize(stackSize); | ||
717 | |||
718 | } | ||
719 | return ; | ||
720 | } | ||
721 | // $ANTLR end "ruleALSSignatureBody" | ||
722 | |||
723 | |||
724 | // $ANTLR start "entryRuleALSFieldDeclaration" | ||
725 | // InternalAlloyLanguage.g:259:1: entryRuleALSFieldDeclaration : ruleALSFieldDeclaration EOF ; | ||
726 | public final void entryRuleALSFieldDeclaration() throws RecognitionException { | ||
727 | try { | ||
728 | // InternalAlloyLanguage.g:260:1: ( ruleALSFieldDeclaration EOF ) | ||
729 | // InternalAlloyLanguage.g:261:1: ruleALSFieldDeclaration EOF | ||
730 | { | ||
731 | if ( state.backtracking==0 ) { | ||
732 | before(grammarAccess.getALSFieldDeclarationRule()); | ||
733 | } | ||
734 | pushFollow(FOLLOW_1); | ||
735 | ruleALSFieldDeclaration(); | ||
736 | |||
737 | state._fsp--; | ||
738 | if (state.failed) return ; | ||
739 | if ( state.backtracking==0 ) { | ||
740 | after(grammarAccess.getALSFieldDeclarationRule()); | ||
741 | } | ||
742 | match(input,EOF,FOLLOW_2); if (state.failed) return ; | ||
743 | |||
744 | } | ||
745 | |||
746 | } | ||
747 | catch (RecognitionException re) { | ||
748 | reportError(re); | ||
749 | recover(input,re); | ||
750 | } | ||
751 | finally { | ||
752 | } | ||
753 | return ; | ||
754 | } | ||
755 | // $ANTLR end "entryRuleALSFieldDeclaration" | ||
756 | |||
757 | |||
758 | // $ANTLR start "ruleALSFieldDeclaration" | ||
759 | // InternalAlloyLanguage.g:268:1: ruleALSFieldDeclaration : ( ( rule__ALSFieldDeclaration__Group__0 ) ) ; | ||
760 | public final void ruleALSFieldDeclaration() throws RecognitionException { | ||
761 | |||
762 | int stackSize = keepStackSize(); | ||
763 | |||
764 | try { | ||
765 | // InternalAlloyLanguage.g:272:2: ( ( ( rule__ALSFieldDeclaration__Group__0 ) ) ) | ||
766 | // InternalAlloyLanguage.g:273:1: ( ( rule__ALSFieldDeclaration__Group__0 ) ) | ||
767 | { | ||
768 | // InternalAlloyLanguage.g:273:1: ( ( rule__ALSFieldDeclaration__Group__0 ) ) | ||
769 | // InternalAlloyLanguage.g:274:1: ( rule__ALSFieldDeclaration__Group__0 ) | ||
770 | { | ||
771 | if ( state.backtracking==0 ) { | ||
772 | before(grammarAccess.getALSFieldDeclarationAccess().getGroup()); | ||
773 | } | ||
774 | // InternalAlloyLanguage.g:275:1: ( rule__ALSFieldDeclaration__Group__0 ) | ||
775 | // InternalAlloyLanguage.g:275:2: rule__ALSFieldDeclaration__Group__0 | ||
776 | { | ||
777 | pushFollow(FOLLOW_2); | ||
778 | rule__ALSFieldDeclaration__Group__0(); | ||
779 | |||
780 | state._fsp--; | ||
781 | if (state.failed) return ; | ||
782 | |||
783 | } | ||
784 | |||
785 | if ( state.backtracking==0 ) { | ||
786 | after(grammarAccess.getALSFieldDeclarationAccess().getGroup()); | ||
787 | } | ||
788 | |||
789 | } | ||
790 | |||
791 | |||
792 | } | ||
793 | |||
794 | } | ||
795 | catch (RecognitionException re) { | ||
796 | reportError(re); | ||
797 | recover(input,re); | ||
798 | } | ||
799 | finally { | ||
800 | |||
801 | restoreStackSize(stackSize); | ||
802 | |||
803 | } | ||
804 | return ; | ||
805 | } | ||
806 | // $ANTLR end "ruleALSFieldDeclaration" | ||
807 | |||
808 | |||
809 | // $ANTLR start "entryRuleALSFunctionDefinition" | ||
810 | // InternalAlloyLanguage.g:289:1: entryRuleALSFunctionDefinition : ruleALSFunctionDefinition EOF ; | ||
811 | public final void entryRuleALSFunctionDefinition() throws RecognitionException { | ||
812 | try { | ||
813 | // InternalAlloyLanguage.g:290:1: ( ruleALSFunctionDefinition EOF ) | ||
814 | // InternalAlloyLanguage.g:291:1: ruleALSFunctionDefinition EOF | ||
815 | { | ||
816 | if ( state.backtracking==0 ) { | ||
817 | before(grammarAccess.getALSFunctionDefinitionRule()); | ||
818 | } | ||
819 | pushFollow(FOLLOW_1); | ||
820 | ruleALSFunctionDefinition(); | ||
821 | |||
822 | state._fsp--; | ||
823 | if (state.failed) return ; | ||
824 | if ( state.backtracking==0 ) { | ||
825 | after(grammarAccess.getALSFunctionDefinitionRule()); | ||
826 | } | ||
827 | match(input,EOF,FOLLOW_2); if (state.failed) return ; | ||
828 | |||
829 | } | ||
830 | |||
831 | } | ||
832 | catch (RecognitionException re) { | ||
833 | reportError(re); | ||
834 | recover(input,re); | ||
835 | } | ||
836 | finally { | ||
837 | } | ||
838 | return ; | ||
839 | } | ||
840 | // $ANTLR end "entryRuleALSFunctionDefinition" | ||
841 | |||
842 | |||
843 | // $ANTLR start "ruleALSFunctionDefinition" | ||
844 | // InternalAlloyLanguage.g:298:1: ruleALSFunctionDefinition : ( ( rule__ALSFunctionDefinition__Group__0 ) ) ; | ||
845 | public final void ruleALSFunctionDefinition() throws RecognitionException { | ||
846 | |||
847 | int stackSize = keepStackSize(); | ||
848 | |||
849 | try { | ||
850 | // InternalAlloyLanguage.g:302:2: ( ( ( rule__ALSFunctionDefinition__Group__0 ) ) ) | ||
851 | // InternalAlloyLanguage.g:303:1: ( ( rule__ALSFunctionDefinition__Group__0 ) ) | ||
852 | { | ||
853 | // InternalAlloyLanguage.g:303:1: ( ( rule__ALSFunctionDefinition__Group__0 ) ) | ||
854 | // InternalAlloyLanguage.g:304:1: ( rule__ALSFunctionDefinition__Group__0 ) | ||
855 | { | ||
856 | if ( state.backtracking==0 ) { | ||
857 | before(grammarAccess.getALSFunctionDefinitionAccess().getGroup()); | ||
858 | } | ||
859 | // InternalAlloyLanguage.g:305:1: ( rule__ALSFunctionDefinition__Group__0 ) | ||
860 | // InternalAlloyLanguage.g:305:2: rule__ALSFunctionDefinition__Group__0 | ||
861 | { | ||
862 | pushFollow(FOLLOW_2); | ||
863 | rule__ALSFunctionDefinition__Group__0(); | ||
864 | |||
865 | state._fsp--; | ||
866 | if (state.failed) return ; | ||
867 | |||
868 | } | ||
869 | |||
870 | if ( state.backtracking==0 ) { | ||
871 | after(grammarAccess.getALSFunctionDefinitionAccess().getGroup()); | ||
872 | } | ||
873 | |||
874 | } | ||
875 | |||
876 | |||
877 | } | ||
878 | |||
879 | } | ||
880 | catch (RecognitionException re) { | ||
881 | reportError(re); | ||
882 | recover(input,re); | ||
883 | } | ||
884 | finally { | ||
885 | |||
886 | restoreStackSize(stackSize); | ||
887 | |||
888 | } | ||
889 | return ; | ||
890 | } | ||
891 | // $ANTLR end "ruleALSFunctionDefinition" | ||
892 | |||
893 | |||
894 | // $ANTLR start "entryRuleALSRelationDefinition" | ||
895 | // InternalAlloyLanguage.g:317:1: entryRuleALSRelationDefinition : ruleALSRelationDefinition EOF ; | ||
896 | public final void entryRuleALSRelationDefinition() throws RecognitionException { | ||
897 | try { | ||
898 | // InternalAlloyLanguage.g:318:1: ( ruleALSRelationDefinition EOF ) | ||
899 | // InternalAlloyLanguage.g:319:1: ruleALSRelationDefinition EOF | ||
900 | { | ||
901 | if ( state.backtracking==0 ) { | ||
902 | before(grammarAccess.getALSRelationDefinitionRule()); | ||
903 | } | ||
904 | pushFollow(FOLLOW_1); | ||
905 | ruleALSRelationDefinition(); | ||
906 | |||
907 | state._fsp--; | ||
908 | if (state.failed) return ; | ||
909 | if ( state.backtracking==0 ) { | ||
910 | after(grammarAccess.getALSRelationDefinitionRule()); | ||
911 | } | ||
912 | match(input,EOF,FOLLOW_2); if (state.failed) return ; | ||
913 | |||
914 | } | ||
915 | |||
916 | } | ||
917 | catch (RecognitionException re) { | ||
918 | reportError(re); | ||
919 | recover(input,re); | ||
920 | } | ||
921 | finally { | ||
922 | } | ||
923 | return ; | ||
924 | } | ||
925 | // $ANTLR end "entryRuleALSRelationDefinition" | ||
926 | |||
927 | |||
928 | // $ANTLR start "ruleALSRelationDefinition" | ||
929 | // InternalAlloyLanguage.g:326:1: ruleALSRelationDefinition : ( ( rule__ALSRelationDefinition__Group__0 ) ) ; | ||
930 | public final void ruleALSRelationDefinition() throws RecognitionException { | ||
931 | |||
932 | int stackSize = keepStackSize(); | ||
933 | |||
934 | try { | ||
935 | // InternalAlloyLanguage.g:330:2: ( ( ( rule__ALSRelationDefinition__Group__0 ) ) ) | ||
936 | // InternalAlloyLanguage.g:331:1: ( ( rule__ALSRelationDefinition__Group__0 ) ) | ||
937 | { | ||
938 | // InternalAlloyLanguage.g:331:1: ( ( rule__ALSRelationDefinition__Group__0 ) ) | ||
939 | // InternalAlloyLanguage.g:332:1: ( rule__ALSRelationDefinition__Group__0 ) | ||
940 | { | ||
941 | if ( state.backtracking==0 ) { | ||
942 | before(grammarAccess.getALSRelationDefinitionAccess().getGroup()); | ||
943 | } | ||
944 | // InternalAlloyLanguage.g:333:1: ( rule__ALSRelationDefinition__Group__0 ) | ||
945 | // InternalAlloyLanguage.g:333:2: rule__ALSRelationDefinition__Group__0 | ||
946 | { | ||
947 | pushFollow(FOLLOW_2); | ||
948 | rule__ALSRelationDefinition__Group__0(); | ||
949 | |||
950 | state._fsp--; | ||
951 | if (state.failed) return ; | ||
952 | |||
953 | } | ||
954 | |||
955 | if ( state.backtracking==0 ) { | ||
956 | after(grammarAccess.getALSRelationDefinitionAccess().getGroup()); | ||
957 | } | ||
958 | |||
959 | } | ||
960 | |||
961 | |||
962 | } | ||
963 | |||
964 | } | ||
965 | catch (RecognitionException re) { | ||
966 | reportError(re); | ||
967 | recover(input,re); | ||
968 | } | ||
969 | finally { | ||
970 | |||
971 | restoreStackSize(stackSize); | ||
972 | |||
973 | } | ||
974 | return ; | ||
975 | } | ||
976 | // $ANTLR end "ruleALSRelationDefinition" | ||
977 | |||
978 | |||
979 | // $ANTLR start "entryRuleALSFactDeclaration" | ||
980 | // InternalAlloyLanguage.g:345:1: entryRuleALSFactDeclaration : ruleALSFactDeclaration EOF ; | ||
981 | public final void entryRuleALSFactDeclaration() throws RecognitionException { | ||
982 | try { | ||
983 | // InternalAlloyLanguage.g:346:1: ( ruleALSFactDeclaration EOF ) | ||
984 | // InternalAlloyLanguage.g:347:1: ruleALSFactDeclaration EOF | ||
985 | { | ||
986 | if ( state.backtracking==0 ) { | ||
987 | before(grammarAccess.getALSFactDeclarationRule()); | ||
988 | } | ||
989 | pushFollow(FOLLOW_1); | ||
990 | ruleALSFactDeclaration(); | ||
991 | |||
992 | state._fsp--; | ||
993 | if (state.failed) return ; | ||
994 | if ( state.backtracking==0 ) { | ||
995 | after(grammarAccess.getALSFactDeclarationRule()); | ||
996 | } | ||
997 | match(input,EOF,FOLLOW_2); if (state.failed) return ; | ||
998 | |||
999 | } | ||
1000 | |||
1001 | } | ||
1002 | catch (RecognitionException re) { | ||
1003 | reportError(re); | ||
1004 | recover(input,re); | ||
1005 | } | ||
1006 | finally { | ||
1007 | } | ||
1008 | return ; | ||
1009 | } | ||
1010 | // $ANTLR end "entryRuleALSFactDeclaration" | ||
1011 | |||
1012 | |||
1013 | // $ANTLR start "ruleALSFactDeclaration" | ||
1014 | // InternalAlloyLanguage.g:354:1: ruleALSFactDeclaration : ( ( rule__ALSFactDeclaration__Group__0 ) ) ; | ||
1015 | public final void ruleALSFactDeclaration() throws RecognitionException { | ||
1016 | |||
1017 | int stackSize = keepStackSize(); | ||
1018 | |||
1019 | try { | ||
1020 | // InternalAlloyLanguage.g:358:2: ( ( ( rule__ALSFactDeclaration__Group__0 ) ) ) | ||
1021 | // InternalAlloyLanguage.g:359:1: ( ( rule__ALSFactDeclaration__Group__0 ) ) | ||
1022 | { | ||
1023 | // InternalAlloyLanguage.g:359:1: ( ( rule__ALSFactDeclaration__Group__0 ) ) | ||
1024 | // InternalAlloyLanguage.g:360:1: ( rule__ALSFactDeclaration__Group__0 ) | ||
1025 | { | ||
1026 | if ( state.backtracking==0 ) { | ||
1027 | before(grammarAccess.getALSFactDeclarationAccess().getGroup()); | ||
1028 | } | ||
1029 | // InternalAlloyLanguage.g:361:1: ( rule__ALSFactDeclaration__Group__0 ) | ||
1030 | // InternalAlloyLanguage.g:361:2: rule__ALSFactDeclaration__Group__0 | ||
1031 | { | ||
1032 | pushFollow(FOLLOW_2); | ||
1033 | rule__ALSFactDeclaration__Group__0(); | ||
1034 | |||
1035 | state._fsp--; | ||
1036 | if (state.failed) return ; | ||
1037 | |||
1038 | } | ||
1039 | |||
1040 | if ( state.backtracking==0 ) { | ||
1041 | after(grammarAccess.getALSFactDeclarationAccess().getGroup()); | ||
1042 | } | ||
1043 | |||
1044 | } | ||
1045 | |||
1046 | |||
1047 | } | ||
1048 | |||
1049 | } | ||
1050 | catch (RecognitionException re) { | ||
1051 | reportError(re); | ||
1052 | recover(input,re); | ||
1053 | } | ||
1054 | finally { | ||
1055 | |||
1056 | restoreStackSize(stackSize); | ||
1057 | |||
1058 | } | ||
1059 | return ; | ||
1060 | } | ||
1061 | // $ANTLR end "ruleALSFactDeclaration" | ||
1062 | |||
1063 | |||
1064 | // $ANTLR start "entryRuleALSTerm" | ||
1065 | // InternalAlloyLanguage.g:373:1: entryRuleALSTerm : ruleALSTerm EOF ; | ||
1066 | public final void entryRuleALSTerm() throws RecognitionException { | ||
1067 | try { | ||
1068 | // InternalAlloyLanguage.g:374:1: ( ruleALSTerm EOF ) | ||
1069 | // InternalAlloyLanguage.g:375:1: ruleALSTerm EOF | ||
1070 | { | ||
1071 | if ( state.backtracking==0 ) { | ||
1072 | before(grammarAccess.getALSTermRule()); | ||
1073 | } | ||
1074 | pushFollow(FOLLOW_1); | ||
1075 | ruleALSTerm(); | ||
1076 | |||
1077 | state._fsp--; | ||
1078 | if (state.failed) return ; | ||
1079 | if ( state.backtracking==0 ) { | ||
1080 | after(grammarAccess.getALSTermRule()); | ||
1081 | } | ||
1082 | match(input,EOF,FOLLOW_2); if (state.failed) return ; | ||
1083 | |||
1084 | } | ||
1085 | |||
1086 | } | ||
1087 | catch (RecognitionException re) { | ||
1088 | reportError(re); | ||
1089 | recover(input,re); | ||
1090 | } | ||
1091 | finally { | ||
1092 | } | ||
1093 | return ; | ||
1094 | } | ||
1095 | // $ANTLR end "entryRuleALSTerm" | ||
1096 | |||
1097 | |||
1098 | // $ANTLR start "ruleALSTerm" | ||
1099 | // InternalAlloyLanguage.g:382:1: ruleALSTerm : ( ruleALSQuantified ) ; | ||
1100 | public final void ruleALSTerm() throws RecognitionException { | ||
1101 | |||
1102 | int stackSize = keepStackSize(); | ||
1103 | |||
1104 | try { | ||
1105 | // InternalAlloyLanguage.g:386:2: ( ( ruleALSQuantified ) ) | ||
1106 | // InternalAlloyLanguage.g:387:1: ( ruleALSQuantified ) | ||
1107 | { | ||
1108 | // InternalAlloyLanguage.g:387:1: ( ruleALSQuantified ) | ||
1109 | // InternalAlloyLanguage.g:388:1: ruleALSQuantified | ||
1110 | { | ||
1111 | if ( state.backtracking==0 ) { | ||
1112 | before(grammarAccess.getALSTermAccess().getALSQuantifiedParserRuleCall()); | ||
1113 | } | ||
1114 | pushFollow(FOLLOW_2); | ||
1115 | ruleALSQuantified(); | ||
1116 | |||
1117 | state._fsp--; | ||
1118 | if (state.failed) return ; | ||
1119 | if ( state.backtracking==0 ) { | ||
1120 | after(grammarAccess.getALSTermAccess().getALSQuantifiedParserRuleCall()); | ||
1121 | } | ||
1122 | |||
1123 | } | ||
1124 | |||
1125 | |||
1126 | } | ||
1127 | |||
1128 | } | ||
1129 | catch (RecognitionException re) { | ||
1130 | reportError(re); | ||
1131 | recover(input,re); | ||
1132 | } | ||
1133 | finally { | ||
1134 | |||
1135 | restoreStackSize(stackSize); | ||
1136 | |||
1137 | } | ||
1138 | return ; | ||
1139 | } | ||
1140 | // $ANTLR end "ruleALSTerm" | ||
1141 | |||
1142 | |||
1143 | // $ANTLR start "entryRuleALSQuantified" | ||
1144 | // InternalAlloyLanguage.g:401:1: entryRuleALSQuantified : ruleALSQuantified EOF ; | ||
1145 | public final void entryRuleALSQuantified() throws RecognitionException { | ||
1146 | try { | ||
1147 | // InternalAlloyLanguage.g:402:1: ( ruleALSQuantified EOF ) | ||
1148 | // InternalAlloyLanguage.g:403:1: ruleALSQuantified EOF | ||
1149 | { | ||
1150 | if ( state.backtracking==0 ) { | ||
1151 | before(grammarAccess.getALSQuantifiedRule()); | ||
1152 | } | ||
1153 | pushFollow(FOLLOW_1); | ||
1154 | ruleALSQuantified(); | ||
1155 | |||
1156 | state._fsp--; | ||
1157 | if (state.failed) return ; | ||
1158 | if ( state.backtracking==0 ) { | ||
1159 | after(grammarAccess.getALSQuantifiedRule()); | ||
1160 | } | ||
1161 | match(input,EOF,FOLLOW_2); if (state.failed) return ; | ||
1162 | |||
1163 | } | ||
1164 | |||
1165 | } | ||
1166 | catch (RecognitionException re) { | ||
1167 | reportError(re); | ||
1168 | recover(input,re); | ||
1169 | } | ||
1170 | finally { | ||
1171 | } | ||
1172 | return ; | ||
1173 | } | ||
1174 | // $ANTLR end "entryRuleALSQuantified" | ||
1175 | |||
1176 | |||
1177 | // $ANTLR start "ruleALSQuantified" | ||
1178 | // InternalAlloyLanguage.g:410:1: ruleALSQuantified : ( ( rule__ALSQuantified__Alternatives ) ) ; | ||
1179 | public final void ruleALSQuantified() throws RecognitionException { | ||
1180 | |||
1181 | int stackSize = keepStackSize(); | ||
1182 | |||
1183 | try { | ||
1184 | // InternalAlloyLanguage.g:414:2: ( ( ( rule__ALSQuantified__Alternatives ) ) ) | ||
1185 | // InternalAlloyLanguage.g:415:1: ( ( rule__ALSQuantified__Alternatives ) ) | ||
1186 | { | ||
1187 | // InternalAlloyLanguage.g:415:1: ( ( rule__ALSQuantified__Alternatives ) ) | ||
1188 | // InternalAlloyLanguage.g:416:1: ( rule__ALSQuantified__Alternatives ) | ||
1189 | { | ||
1190 | if ( state.backtracking==0 ) { | ||
1191 | before(grammarAccess.getALSQuantifiedAccess().getAlternatives()); | ||
1192 | } | ||
1193 | // InternalAlloyLanguage.g:417:1: ( rule__ALSQuantified__Alternatives ) | ||
1194 | // InternalAlloyLanguage.g:417:2: rule__ALSQuantified__Alternatives | ||
1195 | { | ||
1196 | pushFollow(FOLLOW_2); | ||
1197 | rule__ALSQuantified__Alternatives(); | ||
1198 | |||
1199 | state._fsp--; | ||
1200 | if (state.failed) return ; | ||
1201 | |||
1202 | } | ||
1203 | |||
1204 | if ( state.backtracking==0 ) { | ||
1205 | after(grammarAccess.getALSQuantifiedAccess().getAlternatives()); | ||
1206 | } | ||
1207 | |||
1208 | } | ||
1209 | |||
1210 | |||
1211 | } | ||
1212 | |||
1213 | } | ||
1214 | catch (RecognitionException re) { | ||
1215 | reportError(re); | ||
1216 | recover(input,re); | ||
1217 | } | ||
1218 | finally { | ||
1219 | |||
1220 | restoreStackSize(stackSize); | ||
1221 | |||
1222 | } | ||
1223 | return ; | ||
1224 | } | ||
1225 | // $ANTLR end "ruleALSQuantified" | ||
1226 | |||
1227 | |||
1228 | // $ANTLR start "entryRuleALSOr" | ||
1229 | // InternalAlloyLanguage.g:429:1: entryRuleALSOr : ruleALSOr EOF ; | ||
1230 | public final void entryRuleALSOr() throws RecognitionException { | ||
1231 | try { | ||
1232 | // InternalAlloyLanguage.g:430:1: ( ruleALSOr EOF ) | ||
1233 | // InternalAlloyLanguage.g:431:1: ruleALSOr EOF | ||
1234 | { | ||
1235 | if ( state.backtracking==0 ) { | ||
1236 | before(grammarAccess.getALSOrRule()); | ||
1237 | } | ||
1238 | pushFollow(FOLLOW_1); | ||
1239 | ruleALSOr(); | ||
1240 | |||
1241 | state._fsp--; | ||
1242 | if (state.failed) return ; | ||
1243 | if ( state.backtracking==0 ) { | ||
1244 | after(grammarAccess.getALSOrRule()); | ||
1245 | } | ||
1246 | match(input,EOF,FOLLOW_2); if (state.failed) return ; | ||
1247 | |||
1248 | } | ||
1249 | |||
1250 | } | ||
1251 | catch (RecognitionException re) { | ||
1252 | reportError(re); | ||
1253 | recover(input,re); | ||
1254 | } | ||
1255 | finally { | ||
1256 | } | ||
1257 | return ; | ||
1258 | } | ||
1259 | // $ANTLR end "entryRuleALSOr" | ||
1260 | |||
1261 | |||
1262 | // $ANTLR start "ruleALSOr" | ||
1263 | // InternalAlloyLanguage.g:438:1: ruleALSOr : ( ( rule__ALSOr__Group__0 ) ) ; | ||
1264 | public final void ruleALSOr() throws RecognitionException { | ||
1265 | |||
1266 | int stackSize = keepStackSize(); | ||
1267 | |||
1268 | try { | ||
1269 | // InternalAlloyLanguage.g:442:2: ( ( ( rule__ALSOr__Group__0 ) ) ) | ||
1270 | // InternalAlloyLanguage.g:443:1: ( ( rule__ALSOr__Group__0 ) ) | ||
1271 | { | ||
1272 | // InternalAlloyLanguage.g:443:1: ( ( rule__ALSOr__Group__0 ) ) | ||
1273 | // InternalAlloyLanguage.g:444:1: ( rule__ALSOr__Group__0 ) | ||
1274 | { | ||
1275 | if ( state.backtracking==0 ) { | ||
1276 | before(grammarAccess.getALSOrAccess().getGroup()); | ||
1277 | } | ||
1278 | // InternalAlloyLanguage.g:445:1: ( rule__ALSOr__Group__0 ) | ||
1279 | // InternalAlloyLanguage.g:445:2: rule__ALSOr__Group__0 | ||
1280 | { | ||
1281 | pushFollow(FOLLOW_2); | ||
1282 | rule__ALSOr__Group__0(); | ||
1283 | |||
1284 | state._fsp--; | ||
1285 | if (state.failed) return ; | ||
1286 | |||
1287 | } | ||
1288 | |||
1289 | if ( state.backtracking==0 ) { | ||
1290 | after(grammarAccess.getALSOrAccess().getGroup()); | ||
1291 | } | ||
1292 | |||
1293 | } | ||
1294 | |||
1295 | |||
1296 | } | ||
1297 | |||
1298 | } | ||
1299 | catch (RecognitionException re) { | ||
1300 | reportError(re); | ||
1301 | recover(input,re); | ||
1302 | } | ||
1303 | finally { | ||
1304 | |||
1305 | restoreStackSize(stackSize); | ||
1306 | |||
1307 | } | ||
1308 | return ; | ||
1309 | } | ||
1310 | // $ANTLR end "ruleALSOr" | ||
1311 | |||
1312 | |||
1313 | // $ANTLR start "entryRuleALSIff" | ||
1314 | // InternalAlloyLanguage.g:457:1: entryRuleALSIff : ruleALSIff EOF ; | ||
1315 | public final void entryRuleALSIff() throws RecognitionException { | ||
1316 | try { | ||
1317 | // InternalAlloyLanguage.g:458:1: ( ruleALSIff EOF ) | ||
1318 | // InternalAlloyLanguage.g:459:1: ruleALSIff EOF | ||
1319 | { | ||
1320 | if ( state.backtracking==0 ) { | ||
1321 | before(grammarAccess.getALSIffRule()); | ||
1322 | } | ||
1323 | pushFollow(FOLLOW_1); | ||
1324 | ruleALSIff(); | ||
1325 | |||
1326 | state._fsp--; | ||
1327 | if (state.failed) return ; | ||
1328 | if ( state.backtracking==0 ) { | ||
1329 | after(grammarAccess.getALSIffRule()); | ||
1330 | } | ||
1331 | match(input,EOF,FOLLOW_2); if (state.failed) return ; | ||
1332 | |||
1333 | } | ||
1334 | |||
1335 | } | ||
1336 | catch (RecognitionException re) { | ||
1337 | reportError(re); | ||
1338 | recover(input,re); | ||
1339 | } | ||
1340 | finally { | ||
1341 | } | ||
1342 | return ; | ||
1343 | } | ||
1344 | // $ANTLR end "entryRuleALSIff" | ||
1345 | |||
1346 | |||
1347 | // $ANTLR start "ruleALSIff" | ||
1348 | // InternalAlloyLanguage.g:466:1: ruleALSIff : ( ( rule__ALSIff__Group__0 ) ) ; | ||
1349 | public final void ruleALSIff() throws RecognitionException { | ||
1350 | |||
1351 | int stackSize = keepStackSize(); | ||
1352 | |||
1353 | try { | ||
1354 | // InternalAlloyLanguage.g:470:2: ( ( ( rule__ALSIff__Group__0 ) ) ) | ||
1355 | // InternalAlloyLanguage.g:471:1: ( ( rule__ALSIff__Group__0 ) ) | ||
1356 | { | ||
1357 | // InternalAlloyLanguage.g:471:1: ( ( rule__ALSIff__Group__0 ) ) | ||
1358 | // InternalAlloyLanguage.g:472:1: ( rule__ALSIff__Group__0 ) | ||
1359 | { | ||
1360 | if ( state.backtracking==0 ) { | ||
1361 | before(grammarAccess.getALSIffAccess().getGroup()); | ||
1362 | } | ||
1363 | // InternalAlloyLanguage.g:473:1: ( rule__ALSIff__Group__0 ) | ||
1364 | // InternalAlloyLanguage.g:473:2: rule__ALSIff__Group__0 | ||
1365 | { | ||
1366 | pushFollow(FOLLOW_2); | ||
1367 | rule__ALSIff__Group__0(); | ||
1368 | |||
1369 | state._fsp--; | ||
1370 | if (state.failed) return ; | ||
1371 | |||
1372 | } | ||
1373 | |||
1374 | if ( state.backtracking==0 ) { | ||
1375 | after(grammarAccess.getALSIffAccess().getGroup()); | ||
1376 | } | ||
1377 | |||
1378 | } | ||
1379 | |||
1380 | |||
1381 | } | ||
1382 | |||
1383 | } | ||
1384 | catch (RecognitionException re) { | ||
1385 | reportError(re); | ||
1386 | recover(input,re); | ||
1387 | } | ||
1388 | finally { | ||
1389 | |||
1390 | restoreStackSize(stackSize); | ||
1391 | |||
1392 | } | ||
1393 | return ; | ||
1394 | } | ||
1395 | // $ANTLR end "ruleALSIff" | ||
1396 | |||
1397 | |||
1398 | // $ANTLR start "entryRuleALSImpl" | ||
1399 | // InternalAlloyLanguage.g:485:1: entryRuleALSImpl : ruleALSImpl EOF ; | ||
1400 | public final void entryRuleALSImpl() throws RecognitionException { | ||
1401 | try { | ||
1402 | // InternalAlloyLanguage.g:486:1: ( ruleALSImpl EOF ) | ||
1403 | // InternalAlloyLanguage.g:487:1: ruleALSImpl EOF | ||
1404 | { | ||
1405 | if ( state.backtracking==0 ) { | ||
1406 | before(grammarAccess.getALSImplRule()); | ||
1407 | } | ||
1408 | pushFollow(FOLLOW_1); | ||
1409 | ruleALSImpl(); | ||
1410 | |||
1411 | state._fsp--; | ||
1412 | if (state.failed) return ; | ||
1413 | if ( state.backtracking==0 ) { | ||
1414 | after(grammarAccess.getALSImplRule()); | ||
1415 | } | ||
1416 | match(input,EOF,FOLLOW_2); if (state.failed) return ; | ||
1417 | |||
1418 | } | ||
1419 | |||
1420 | } | ||
1421 | catch (RecognitionException re) { | ||
1422 | reportError(re); | ||
1423 | recover(input,re); | ||
1424 | } | ||
1425 | finally { | ||
1426 | } | ||
1427 | return ; | ||
1428 | } | ||
1429 | // $ANTLR end "entryRuleALSImpl" | ||
1430 | |||
1431 | |||
1432 | // $ANTLR start "ruleALSImpl" | ||
1433 | // InternalAlloyLanguage.g:494:1: ruleALSImpl : ( ( rule__ALSImpl__Group__0 ) ) ; | ||
1434 | public final void ruleALSImpl() throws RecognitionException { | ||
1435 | |||
1436 | int stackSize = keepStackSize(); | ||
1437 | |||
1438 | try { | ||
1439 | // InternalAlloyLanguage.g:498:2: ( ( ( rule__ALSImpl__Group__0 ) ) ) | ||
1440 | // InternalAlloyLanguage.g:499:1: ( ( rule__ALSImpl__Group__0 ) ) | ||
1441 | { | ||
1442 | // InternalAlloyLanguage.g:499:1: ( ( rule__ALSImpl__Group__0 ) ) | ||
1443 | // InternalAlloyLanguage.g:500:1: ( rule__ALSImpl__Group__0 ) | ||
1444 | { | ||
1445 | if ( state.backtracking==0 ) { | ||
1446 | before(grammarAccess.getALSImplAccess().getGroup()); | ||
1447 | } | ||
1448 | // InternalAlloyLanguage.g:501:1: ( rule__ALSImpl__Group__0 ) | ||
1449 | // InternalAlloyLanguage.g:501:2: rule__ALSImpl__Group__0 | ||
1450 | { | ||
1451 | pushFollow(FOLLOW_2); | ||
1452 | rule__ALSImpl__Group__0(); | ||
1453 | |||
1454 | state._fsp--; | ||
1455 | if (state.failed) return ; | ||
1456 | |||
1457 | } | ||
1458 | |||
1459 | if ( state.backtracking==0 ) { | ||
1460 | after(grammarAccess.getALSImplAccess().getGroup()); | ||
1461 | } | ||
1462 | |||
1463 | } | ||
1464 | |||
1465 | |||
1466 | } | ||
1467 | |||
1468 | } | ||
1469 | catch (RecognitionException re) { | ||
1470 | reportError(re); | ||
1471 | recover(input,re); | ||
1472 | } | ||
1473 | finally { | ||
1474 | |||
1475 | restoreStackSize(stackSize); | ||
1476 | |||
1477 | } | ||
1478 | return ; | ||
1479 | } | ||
1480 | // $ANTLR end "ruleALSImpl" | ||
1481 | |||
1482 | |||
1483 | // $ANTLR start "entryRuleALSAnd" | ||
1484 | // InternalAlloyLanguage.g:513:1: entryRuleALSAnd : ruleALSAnd EOF ; | ||
1485 | public final void entryRuleALSAnd() throws RecognitionException { | ||
1486 | try { | ||
1487 | // InternalAlloyLanguage.g:514:1: ( ruleALSAnd EOF ) | ||
1488 | // InternalAlloyLanguage.g:515:1: ruleALSAnd EOF | ||
1489 | { | ||
1490 | if ( state.backtracking==0 ) { | ||
1491 | before(grammarAccess.getALSAndRule()); | ||
1492 | } | ||
1493 | pushFollow(FOLLOW_1); | ||
1494 | ruleALSAnd(); | ||
1495 | |||
1496 | state._fsp--; | ||
1497 | if (state.failed) return ; | ||
1498 | if ( state.backtracking==0 ) { | ||
1499 | after(grammarAccess.getALSAndRule()); | ||
1500 | } | ||
1501 | match(input,EOF,FOLLOW_2); if (state.failed) return ; | ||
1502 | |||
1503 | } | ||
1504 | |||
1505 | } | ||
1506 | catch (RecognitionException re) { | ||
1507 | reportError(re); | ||
1508 | recover(input,re); | ||
1509 | } | ||
1510 | finally { | ||
1511 | } | ||
1512 | return ; | ||
1513 | } | ||
1514 | // $ANTLR end "entryRuleALSAnd" | ||
1515 | |||
1516 | |||
1517 | // $ANTLR start "ruleALSAnd" | ||
1518 | // InternalAlloyLanguage.g:522:1: ruleALSAnd : ( ( rule__ALSAnd__Group__0 ) ) ; | ||
1519 | public final void ruleALSAnd() throws RecognitionException { | ||
1520 | |||
1521 | int stackSize = keepStackSize(); | ||
1522 | |||
1523 | try { | ||
1524 | // InternalAlloyLanguage.g:526:2: ( ( ( rule__ALSAnd__Group__0 ) ) ) | ||
1525 | // InternalAlloyLanguage.g:527:1: ( ( rule__ALSAnd__Group__0 ) ) | ||
1526 | { | ||
1527 | // InternalAlloyLanguage.g:527:1: ( ( rule__ALSAnd__Group__0 ) ) | ||
1528 | // InternalAlloyLanguage.g:528:1: ( rule__ALSAnd__Group__0 ) | ||
1529 | { | ||
1530 | if ( state.backtracking==0 ) { | ||
1531 | before(grammarAccess.getALSAndAccess().getGroup()); | ||
1532 | } | ||
1533 | // InternalAlloyLanguage.g:529:1: ( rule__ALSAnd__Group__0 ) | ||
1534 | // InternalAlloyLanguage.g:529:2: rule__ALSAnd__Group__0 | ||
1535 | { | ||
1536 | pushFollow(FOLLOW_2); | ||
1537 | rule__ALSAnd__Group__0(); | ||
1538 | |||
1539 | state._fsp--; | ||
1540 | if (state.failed) return ; | ||
1541 | |||
1542 | } | ||
1543 | |||
1544 | if ( state.backtracking==0 ) { | ||
1545 | after(grammarAccess.getALSAndAccess().getGroup()); | ||
1546 | } | ||
1547 | |||
1548 | } | ||
1549 | |||
1550 | |||
1551 | } | ||
1552 | |||
1553 | } | ||
1554 | catch (RecognitionException re) { | ||
1555 | reportError(re); | ||
1556 | recover(input,re); | ||
1557 | } | ||
1558 | finally { | ||
1559 | |||
1560 | restoreStackSize(stackSize); | ||
1561 | |||
1562 | } | ||
1563 | return ; | ||
1564 | } | ||
1565 | // $ANTLR end "ruleALSAnd" | ||
1566 | |||
1567 | |||
1568 | // $ANTLR start "entryRuleALSComparison" | ||
1569 | // InternalAlloyLanguage.g:541:1: entryRuleALSComparison : ruleALSComparison EOF ; | ||
1570 | public final void entryRuleALSComparison() throws RecognitionException { | ||
1571 | try { | ||
1572 | // InternalAlloyLanguage.g:542:1: ( ruleALSComparison EOF ) | ||
1573 | // InternalAlloyLanguage.g:543:1: ruleALSComparison EOF | ||
1574 | { | ||
1575 | if ( state.backtracking==0 ) { | ||
1576 | before(grammarAccess.getALSComparisonRule()); | ||
1577 | } | ||
1578 | pushFollow(FOLLOW_1); | ||
1579 | ruleALSComparison(); | ||
1580 | |||
1581 | state._fsp--; | ||
1582 | if (state.failed) return ; | ||
1583 | if ( state.backtracking==0 ) { | ||
1584 | after(grammarAccess.getALSComparisonRule()); | ||
1585 | } | ||
1586 | match(input,EOF,FOLLOW_2); if (state.failed) return ; | ||
1587 | |||
1588 | } | ||
1589 | |||
1590 | } | ||
1591 | catch (RecognitionException re) { | ||
1592 | reportError(re); | ||
1593 | recover(input,re); | ||
1594 | } | ||
1595 | finally { | ||
1596 | } | ||
1597 | return ; | ||
1598 | } | ||
1599 | // $ANTLR end "entryRuleALSComparison" | ||
1600 | |||
1601 | |||
1602 | // $ANTLR start "ruleALSComparison" | ||
1603 | // InternalAlloyLanguage.g:550:1: ruleALSComparison : ( ( rule__ALSComparison__Group__0 ) ) ; | ||
1604 | public final void ruleALSComparison() throws RecognitionException { | ||
1605 | |||
1606 | int stackSize = keepStackSize(); | ||
1607 | |||
1608 | try { | ||
1609 | // InternalAlloyLanguage.g:554:2: ( ( ( rule__ALSComparison__Group__0 ) ) ) | ||
1610 | // InternalAlloyLanguage.g:555:1: ( ( rule__ALSComparison__Group__0 ) ) | ||
1611 | { | ||
1612 | // InternalAlloyLanguage.g:555:1: ( ( rule__ALSComparison__Group__0 ) ) | ||
1613 | // InternalAlloyLanguage.g:556:1: ( rule__ALSComparison__Group__0 ) | ||
1614 | { | ||
1615 | if ( state.backtracking==0 ) { | ||
1616 | before(grammarAccess.getALSComparisonAccess().getGroup()); | ||
1617 | } | ||
1618 | // InternalAlloyLanguage.g:557:1: ( rule__ALSComparison__Group__0 ) | ||
1619 | // InternalAlloyLanguage.g:557:2: rule__ALSComparison__Group__0 | ||
1620 | { | ||
1621 | pushFollow(FOLLOW_2); | ||
1622 | rule__ALSComparison__Group__0(); | ||
1623 | |||
1624 | state._fsp--; | ||
1625 | if (state.failed) return ; | ||
1626 | |||
1627 | } | ||
1628 | |||
1629 | if ( state.backtracking==0 ) { | ||
1630 | after(grammarAccess.getALSComparisonAccess().getGroup()); | ||
1631 | } | ||
1632 | |||
1633 | } | ||
1634 | |||
1635 | |||
1636 | } | ||
1637 | |||
1638 | } | ||
1639 | catch (RecognitionException re) { | ||
1640 | reportError(re); | ||
1641 | recover(input,re); | ||
1642 | } | ||
1643 | finally { | ||
1644 | |||
1645 | restoreStackSize(stackSize); | ||
1646 | |||
1647 | } | ||
1648 | return ; | ||
1649 | } | ||
1650 | // $ANTLR end "ruleALSComparison" | ||
1651 | |||
1652 | |||
1653 | // $ANTLR start "entryRuleALSOverride" | ||
1654 | // InternalAlloyLanguage.g:569:1: entryRuleALSOverride : ruleALSOverride EOF ; | ||
1655 | public final void entryRuleALSOverride() throws RecognitionException { | ||
1656 | try { | ||
1657 | // InternalAlloyLanguage.g:570:1: ( ruleALSOverride EOF ) | ||
1658 | // InternalAlloyLanguage.g:571:1: ruleALSOverride EOF | ||
1659 | { | ||
1660 | if ( state.backtracking==0 ) { | ||
1661 | before(grammarAccess.getALSOverrideRule()); | ||
1662 | } | ||
1663 | pushFollow(FOLLOW_1); | ||
1664 | ruleALSOverride(); | ||
1665 | |||
1666 | state._fsp--; | ||
1667 | if (state.failed) return ; | ||
1668 | if ( state.backtracking==0 ) { | ||
1669 | after(grammarAccess.getALSOverrideRule()); | ||
1670 | } | ||
1671 | match(input,EOF,FOLLOW_2); if (state.failed) return ; | ||
1672 | |||
1673 | } | ||
1674 | |||
1675 | } | ||
1676 | catch (RecognitionException re) { | ||
1677 | reportError(re); | ||
1678 | recover(input,re); | ||
1679 | } | ||
1680 | finally { | ||
1681 | } | ||
1682 | return ; | ||
1683 | } | ||
1684 | // $ANTLR end "entryRuleALSOverride" | ||
1685 | |||
1686 | |||
1687 | // $ANTLR start "ruleALSOverride" | ||
1688 | // InternalAlloyLanguage.g:578:1: ruleALSOverride : ( ( rule__ALSOverride__Group__0 ) ) ; | ||
1689 | public final void ruleALSOverride() throws RecognitionException { | ||
1690 | |||
1691 | int stackSize = keepStackSize(); | ||
1692 | |||
1693 | try { | ||
1694 | // InternalAlloyLanguage.g:582:2: ( ( ( rule__ALSOverride__Group__0 ) ) ) | ||
1695 | // InternalAlloyLanguage.g:583:1: ( ( rule__ALSOverride__Group__0 ) ) | ||
1696 | { | ||
1697 | // InternalAlloyLanguage.g:583:1: ( ( rule__ALSOverride__Group__0 ) ) | ||
1698 | // InternalAlloyLanguage.g:584:1: ( rule__ALSOverride__Group__0 ) | ||
1699 | { | ||
1700 | if ( state.backtracking==0 ) { | ||
1701 | before(grammarAccess.getALSOverrideAccess().getGroup()); | ||
1702 | } | ||
1703 | // InternalAlloyLanguage.g:585:1: ( rule__ALSOverride__Group__0 ) | ||
1704 | // InternalAlloyLanguage.g:585:2: rule__ALSOverride__Group__0 | ||
1705 | { | ||
1706 | pushFollow(FOLLOW_2); | ||
1707 | rule__ALSOverride__Group__0(); | ||
1708 | |||
1709 | state._fsp--; | ||
1710 | if (state.failed) return ; | ||
1711 | |||
1712 | } | ||
1713 | |||
1714 | if ( state.backtracking==0 ) { | ||
1715 | after(grammarAccess.getALSOverrideAccess().getGroup()); | ||
1716 | } | ||
1717 | |||
1718 | } | ||
1719 | |||
1720 | |||
1721 | } | ||
1722 | |||
1723 | } | ||
1724 | catch (RecognitionException re) { | ||
1725 | reportError(re); | ||
1726 | recover(input,re); | ||
1727 | } | ||
1728 | finally { | ||
1729 | |||
1730 | restoreStackSize(stackSize); | ||
1731 | |||
1732 | } | ||
1733 | return ; | ||
1734 | } | ||
1735 | // $ANTLR end "ruleALSOverride" | ||
1736 | |||
1737 | |||
1738 | // $ANTLR start "entryRuleALSRangeRestrictionRight" | ||
1739 | // InternalAlloyLanguage.g:597:1: entryRuleALSRangeRestrictionRight : ruleALSRangeRestrictionRight EOF ; | ||
1740 | public final void entryRuleALSRangeRestrictionRight() throws RecognitionException { | ||
1741 | try { | ||
1742 | // InternalAlloyLanguage.g:598:1: ( ruleALSRangeRestrictionRight EOF ) | ||
1743 | // InternalAlloyLanguage.g:599:1: ruleALSRangeRestrictionRight EOF | ||
1744 | { | ||
1745 | if ( state.backtracking==0 ) { | ||
1746 | before(grammarAccess.getALSRangeRestrictionRightRule()); | ||
1747 | } | ||
1748 | pushFollow(FOLLOW_1); | ||
1749 | ruleALSRangeRestrictionRight(); | ||
1750 | |||
1751 | state._fsp--; | ||
1752 | if (state.failed) return ; | ||
1753 | if ( state.backtracking==0 ) { | ||
1754 | after(grammarAccess.getALSRangeRestrictionRightRule()); | ||
1755 | } | ||
1756 | match(input,EOF,FOLLOW_2); if (state.failed) return ; | ||
1757 | |||
1758 | } | ||
1759 | |||
1760 | } | ||
1761 | catch (RecognitionException re) { | ||
1762 | reportError(re); | ||
1763 | recover(input,re); | ||
1764 | } | ||
1765 | finally { | ||
1766 | } | ||
1767 | return ; | ||
1768 | } | ||
1769 | // $ANTLR end "entryRuleALSRangeRestrictionRight" | ||
1770 | |||
1771 | |||
1772 | // $ANTLR start "ruleALSRangeRestrictionRight" | ||
1773 | // InternalAlloyLanguage.g:606:1: ruleALSRangeRestrictionRight : ( ( rule__ALSRangeRestrictionRight__Group__0 ) ) ; | ||
1774 | public final void ruleALSRangeRestrictionRight() throws RecognitionException { | ||
1775 | |||
1776 | int stackSize = keepStackSize(); | ||
1777 | |||
1778 | try { | ||
1779 | // InternalAlloyLanguage.g:610:2: ( ( ( rule__ALSRangeRestrictionRight__Group__0 ) ) ) | ||
1780 | // InternalAlloyLanguage.g:611:1: ( ( rule__ALSRangeRestrictionRight__Group__0 ) ) | ||
1781 | { | ||
1782 | // InternalAlloyLanguage.g:611:1: ( ( rule__ALSRangeRestrictionRight__Group__0 ) ) | ||
1783 | // InternalAlloyLanguage.g:612:1: ( rule__ALSRangeRestrictionRight__Group__0 ) | ||
1784 | { | ||
1785 | if ( state.backtracking==0 ) { | ||
1786 | before(grammarAccess.getALSRangeRestrictionRightAccess().getGroup()); | ||
1787 | } | ||
1788 | // InternalAlloyLanguage.g:613:1: ( rule__ALSRangeRestrictionRight__Group__0 ) | ||
1789 | // InternalAlloyLanguage.g:613:2: rule__ALSRangeRestrictionRight__Group__0 | ||
1790 | { | ||
1791 | pushFollow(FOLLOW_2); | ||
1792 | rule__ALSRangeRestrictionRight__Group__0(); | ||
1793 | |||
1794 | state._fsp--; | ||
1795 | if (state.failed) return ; | ||
1796 | |||
1797 | } | ||
1798 | |||
1799 | if ( state.backtracking==0 ) { | ||
1800 | after(grammarAccess.getALSRangeRestrictionRightAccess().getGroup()); | ||
1801 | } | ||
1802 | |||
1803 | } | ||
1804 | |||
1805 | |||
1806 | } | ||
1807 | |||
1808 | } | ||
1809 | catch (RecognitionException re) { | ||
1810 | reportError(re); | ||
1811 | recover(input,re); | ||
1812 | } | ||
1813 | finally { | ||
1814 | |||
1815 | restoreStackSize(stackSize); | ||
1816 | |||
1817 | } | ||
1818 | return ; | ||
1819 | } | ||
1820 | // $ANTLR end "ruleALSRangeRestrictionRight" | ||
1821 | |||
1822 | |||
1823 | // $ANTLR start "entryRuleALSRangeRestrictionLeft" | ||
1824 | // InternalAlloyLanguage.g:625:1: entryRuleALSRangeRestrictionLeft : ruleALSRangeRestrictionLeft EOF ; | ||
1825 | public final void entryRuleALSRangeRestrictionLeft() throws RecognitionException { | ||
1826 | try { | ||
1827 | // InternalAlloyLanguage.g:626:1: ( ruleALSRangeRestrictionLeft EOF ) | ||
1828 | // InternalAlloyLanguage.g:627:1: ruleALSRangeRestrictionLeft EOF | ||
1829 | { | ||
1830 | if ( state.backtracking==0 ) { | ||
1831 | before(grammarAccess.getALSRangeRestrictionLeftRule()); | ||
1832 | } | ||
1833 | pushFollow(FOLLOW_1); | ||
1834 | ruleALSRangeRestrictionLeft(); | ||
1835 | |||
1836 | state._fsp--; | ||
1837 | if (state.failed) return ; | ||
1838 | if ( state.backtracking==0 ) { | ||
1839 | after(grammarAccess.getALSRangeRestrictionLeftRule()); | ||
1840 | } | ||
1841 | match(input,EOF,FOLLOW_2); if (state.failed) return ; | ||
1842 | |||
1843 | } | ||
1844 | |||
1845 | } | ||
1846 | catch (RecognitionException re) { | ||
1847 | reportError(re); | ||
1848 | recover(input,re); | ||
1849 | } | ||
1850 | finally { | ||
1851 | } | ||
1852 | return ; | ||
1853 | } | ||
1854 | // $ANTLR end "entryRuleALSRangeRestrictionLeft" | ||
1855 | |||
1856 | |||
1857 | // $ANTLR start "ruleALSRangeRestrictionLeft" | ||
1858 | // InternalAlloyLanguage.g:634:1: ruleALSRangeRestrictionLeft : ( ( rule__ALSRangeRestrictionLeft__Group__0 ) ) ; | ||
1859 | public final void ruleALSRangeRestrictionLeft() throws RecognitionException { | ||
1860 | |||
1861 | int stackSize = keepStackSize(); | ||
1862 | |||
1863 | try { | ||
1864 | // InternalAlloyLanguage.g:638:2: ( ( ( rule__ALSRangeRestrictionLeft__Group__0 ) ) ) | ||
1865 | // InternalAlloyLanguage.g:639:1: ( ( rule__ALSRangeRestrictionLeft__Group__0 ) ) | ||
1866 | { | ||
1867 | // InternalAlloyLanguage.g:639:1: ( ( rule__ALSRangeRestrictionLeft__Group__0 ) ) | ||
1868 | // InternalAlloyLanguage.g:640:1: ( rule__ALSRangeRestrictionLeft__Group__0 ) | ||
1869 | { | ||
1870 | if ( state.backtracking==0 ) { | ||
1871 | before(grammarAccess.getALSRangeRestrictionLeftAccess().getGroup()); | ||
1872 | } | ||
1873 | // InternalAlloyLanguage.g:641:1: ( rule__ALSRangeRestrictionLeft__Group__0 ) | ||
1874 | // InternalAlloyLanguage.g:641:2: rule__ALSRangeRestrictionLeft__Group__0 | ||
1875 | { | ||
1876 | pushFollow(FOLLOW_2); | ||
1877 | rule__ALSRangeRestrictionLeft__Group__0(); | ||
1878 | |||
1879 | state._fsp--; | ||
1880 | if (state.failed) return ; | ||
1881 | |||
1882 | } | ||
1883 | |||
1884 | if ( state.backtracking==0 ) { | ||
1885 | after(grammarAccess.getALSRangeRestrictionLeftAccess().getGroup()); | ||
1886 | } | ||
1887 | |||
1888 | } | ||
1889 | |||
1890 | |||
1891 | } | ||
1892 | |||
1893 | } | ||
1894 | catch (RecognitionException re) { | ||
1895 | reportError(re); | ||
1896 | recover(input,re); | ||
1897 | } | ||
1898 | finally { | ||
1899 | |||
1900 | restoreStackSize(stackSize); | ||
1901 | |||
1902 | } | ||
1903 | return ; | ||
1904 | } | ||
1905 | // $ANTLR end "ruleALSRangeRestrictionLeft" | ||
1906 | |||
1907 | |||
1908 | // $ANTLR start "entryRuleALSJoin" | ||
1909 | // InternalAlloyLanguage.g:653:1: entryRuleALSJoin : ruleALSJoin EOF ; | ||
1910 | public final void entryRuleALSJoin() throws RecognitionException { | ||
1911 | try { | ||
1912 | // InternalAlloyLanguage.g:654:1: ( ruleALSJoin EOF ) | ||
1913 | // InternalAlloyLanguage.g:655:1: ruleALSJoin EOF | ||
1914 | { | ||
1915 | if ( state.backtracking==0 ) { | ||
1916 | before(grammarAccess.getALSJoinRule()); | ||
1917 | } | ||
1918 | pushFollow(FOLLOW_1); | ||
1919 | ruleALSJoin(); | ||
1920 | |||
1921 | state._fsp--; | ||
1922 | if (state.failed) return ; | ||
1923 | if ( state.backtracking==0 ) { | ||
1924 | after(grammarAccess.getALSJoinRule()); | ||
1925 | } | ||
1926 | match(input,EOF,FOLLOW_2); if (state.failed) return ; | ||
1927 | |||
1928 | } | ||
1929 | |||
1930 | } | ||
1931 | catch (RecognitionException re) { | ||
1932 | reportError(re); | ||
1933 | recover(input,re); | ||
1934 | } | ||
1935 | finally { | ||
1936 | } | ||
1937 | return ; | ||
1938 | } | ||
1939 | // $ANTLR end "entryRuleALSJoin" | ||
1940 | |||
1941 | |||
1942 | // $ANTLR start "ruleALSJoin" | ||
1943 | // InternalAlloyLanguage.g:662:1: ruleALSJoin : ( ( rule__ALSJoin__Group__0 ) ) ; | ||
1944 | public final void ruleALSJoin() throws RecognitionException { | ||
1945 | |||
1946 | int stackSize = keepStackSize(); | ||
1947 | |||
1948 | try { | ||
1949 | // InternalAlloyLanguage.g:666:2: ( ( ( rule__ALSJoin__Group__0 ) ) ) | ||
1950 | // InternalAlloyLanguage.g:667:1: ( ( rule__ALSJoin__Group__0 ) ) | ||
1951 | { | ||
1952 | // InternalAlloyLanguage.g:667:1: ( ( rule__ALSJoin__Group__0 ) ) | ||
1953 | // InternalAlloyLanguage.g:668:1: ( rule__ALSJoin__Group__0 ) | ||
1954 | { | ||
1955 | if ( state.backtracking==0 ) { | ||
1956 | before(grammarAccess.getALSJoinAccess().getGroup()); | ||
1957 | } | ||
1958 | // InternalAlloyLanguage.g:669:1: ( rule__ALSJoin__Group__0 ) | ||
1959 | // InternalAlloyLanguage.g:669:2: rule__ALSJoin__Group__0 | ||
1960 | { | ||
1961 | pushFollow(FOLLOW_2); | ||
1962 | rule__ALSJoin__Group__0(); | ||
1963 | |||
1964 | state._fsp--; | ||
1965 | if (state.failed) return ; | ||
1966 | |||
1967 | } | ||
1968 | |||
1969 | if ( state.backtracking==0 ) { | ||
1970 | after(grammarAccess.getALSJoinAccess().getGroup()); | ||
1971 | } | ||
1972 | |||
1973 | } | ||
1974 | |||
1975 | |||
1976 | } | ||
1977 | |||
1978 | } | ||
1979 | catch (RecognitionException re) { | ||
1980 | reportError(re); | ||
1981 | recover(input,re); | ||
1982 | } | ||
1983 | finally { | ||
1984 | |||
1985 | restoreStackSize(stackSize); | ||
1986 | |||
1987 | } | ||
1988 | return ; | ||
1989 | } | ||
1990 | // $ANTLR end "ruleALSJoin" | ||
1991 | |||
1992 | |||
1993 | // $ANTLR start "entryRuleALSMinus" | ||
1994 | // InternalAlloyLanguage.g:681:1: entryRuleALSMinus : ruleALSMinus EOF ; | ||
1995 | public final void entryRuleALSMinus() throws RecognitionException { | ||
1996 | try { | ||
1997 | // InternalAlloyLanguage.g:682:1: ( ruleALSMinus EOF ) | ||
1998 | // InternalAlloyLanguage.g:683:1: ruleALSMinus EOF | ||
1999 | { | ||
2000 | if ( state.backtracking==0 ) { | ||
2001 | before(grammarAccess.getALSMinusRule()); | ||
2002 | } | ||
2003 | pushFollow(FOLLOW_1); | ||
2004 | ruleALSMinus(); | ||
2005 | |||
2006 | state._fsp--; | ||
2007 | if (state.failed) return ; | ||
2008 | if ( state.backtracking==0 ) { | ||
2009 | after(grammarAccess.getALSMinusRule()); | ||
2010 | } | ||
2011 | match(input,EOF,FOLLOW_2); if (state.failed) return ; | ||
2012 | |||
2013 | } | ||
2014 | |||
2015 | } | ||
2016 | catch (RecognitionException re) { | ||
2017 | reportError(re); | ||
2018 | recover(input,re); | ||
2019 | } | ||
2020 | finally { | ||
2021 | } | ||
2022 | return ; | ||
2023 | } | ||
2024 | // $ANTLR end "entryRuleALSMinus" | ||
2025 | |||
2026 | |||
2027 | // $ANTLR start "ruleALSMinus" | ||
2028 | // InternalAlloyLanguage.g:690:1: ruleALSMinus : ( ( rule__ALSMinus__Group__0 ) ) ; | ||
2029 | public final void ruleALSMinus() throws RecognitionException { | ||
2030 | |||
2031 | int stackSize = keepStackSize(); | ||
2032 | |||
2033 | try { | ||
2034 | // InternalAlloyLanguage.g:694:2: ( ( ( rule__ALSMinus__Group__0 ) ) ) | ||
2035 | // InternalAlloyLanguage.g:695:1: ( ( rule__ALSMinus__Group__0 ) ) | ||
2036 | { | ||
2037 | // InternalAlloyLanguage.g:695:1: ( ( rule__ALSMinus__Group__0 ) ) | ||
2038 | // InternalAlloyLanguage.g:696:1: ( rule__ALSMinus__Group__0 ) | ||
2039 | { | ||
2040 | if ( state.backtracking==0 ) { | ||
2041 | before(grammarAccess.getALSMinusAccess().getGroup()); | ||
2042 | } | ||
2043 | // InternalAlloyLanguage.g:697:1: ( rule__ALSMinus__Group__0 ) | ||
2044 | // InternalAlloyLanguage.g:697:2: rule__ALSMinus__Group__0 | ||
2045 | { | ||
2046 | pushFollow(FOLLOW_2); | ||
2047 | rule__ALSMinus__Group__0(); | ||
2048 | |||
2049 | state._fsp--; | ||
2050 | if (state.failed) return ; | ||
2051 | |||
2052 | } | ||
2053 | |||
2054 | if ( state.backtracking==0 ) { | ||
2055 | after(grammarAccess.getALSMinusAccess().getGroup()); | ||
2056 | } | ||
2057 | |||
2058 | } | ||
2059 | |||
2060 | |||
2061 | } | ||
2062 | |||
2063 | } | ||
2064 | catch (RecognitionException re) { | ||
2065 | reportError(re); | ||
2066 | recover(input,re); | ||
2067 | } | ||
2068 | finally { | ||
2069 | |||
2070 | restoreStackSize(stackSize); | ||
2071 | |||
2072 | } | ||
2073 | return ; | ||
2074 | } | ||
2075 | // $ANTLR end "ruleALSMinus" | ||
2076 | |||
2077 | |||
2078 | // $ANTLR start "entryRuleALSPlus" | ||
2079 | // InternalAlloyLanguage.g:709:1: entryRuleALSPlus : ruleALSPlus EOF ; | ||
2080 | public final void entryRuleALSPlus() throws RecognitionException { | ||
2081 | try { | ||
2082 | // InternalAlloyLanguage.g:710:1: ( ruleALSPlus EOF ) | ||
2083 | // InternalAlloyLanguage.g:711:1: ruleALSPlus EOF | ||
2084 | { | ||
2085 | if ( state.backtracking==0 ) { | ||
2086 | before(grammarAccess.getALSPlusRule()); | ||
2087 | } | ||
2088 | pushFollow(FOLLOW_1); | ||
2089 | ruleALSPlus(); | ||
2090 | |||
2091 | state._fsp--; | ||
2092 | if (state.failed) return ; | ||
2093 | if ( state.backtracking==0 ) { | ||
2094 | after(grammarAccess.getALSPlusRule()); | ||
2095 | } | ||
2096 | match(input,EOF,FOLLOW_2); if (state.failed) return ; | ||
2097 | |||
2098 | } | ||
2099 | |||
2100 | } | ||
2101 | catch (RecognitionException re) { | ||
2102 | reportError(re); | ||
2103 | recover(input,re); | ||
2104 | } | ||
2105 | finally { | ||
2106 | } | ||
2107 | return ; | ||
2108 | } | ||
2109 | // $ANTLR end "entryRuleALSPlus" | ||
2110 | |||
2111 | |||
2112 | // $ANTLR start "ruleALSPlus" | ||
2113 | // InternalAlloyLanguage.g:718:1: ruleALSPlus : ( ( rule__ALSPlus__Group__0 ) ) ; | ||
2114 | public final void ruleALSPlus() throws RecognitionException { | ||
2115 | |||
2116 | int stackSize = keepStackSize(); | ||
2117 | |||
2118 | try { | ||
2119 | // InternalAlloyLanguage.g:722:2: ( ( ( rule__ALSPlus__Group__0 ) ) ) | ||
2120 | // InternalAlloyLanguage.g:723:1: ( ( rule__ALSPlus__Group__0 ) ) | ||
2121 | { | ||
2122 | // InternalAlloyLanguage.g:723:1: ( ( rule__ALSPlus__Group__0 ) ) | ||
2123 | // InternalAlloyLanguage.g:724:1: ( rule__ALSPlus__Group__0 ) | ||
2124 | { | ||
2125 | if ( state.backtracking==0 ) { | ||
2126 | before(grammarAccess.getALSPlusAccess().getGroup()); | ||
2127 | } | ||
2128 | // InternalAlloyLanguage.g:725:1: ( rule__ALSPlus__Group__0 ) | ||
2129 | // InternalAlloyLanguage.g:725:2: rule__ALSPlus__Group__0 | ||
2130 | { | ||
2131 | pushFollow(FOLLOW_2); | ||
2132 | rule__ALSPlus__Group__0(); | ||
2133 | |||
2134 | state._fsp--; | ||
2135 | if (state.failed) return ; | ||
2136 | |||
2137 | } | ||
2138 | |||
2139 | if ( state.backtracking==0 ) { | ||
2140 | after(grammarAccess.getALSPlusAccess().getGroup()); | ||
2141 | } | ||
2142 | |||
2143 | } | ||
2144 | |||
2145 | |||
2146 | } | ||
2147 | |||
2148 | } | ||
2149 | catch (RecognitionException re) { | ||
2150 | reportError(re); | ||
2151 | recover(input,re); | ||
2152 | } | ||
2153 | finally { | ||
2154 | |||
2155 | restoreStackSize(stackSize); | ||
2156 | |||
2157 | } | ||
2158 | return ; | ||
2159 | } | ||
2160 | // $ANTLR end "ruleALSPlus" | ||
2161 | |||
2162 | |||
2163 | // $ANTLR start "entryRuleALSIntersection" | ||
2164 | // InternalAlloyLanguage.g:737:1: entryRuleALSIntersection : ruleALSIntersection EOF ; | ||
2165 | public final void entryRuleALSIntersection() throws RecognitionException { | ||
2166 | try { | ||
2167 | // InternalAlloyLanguage.g:738:1: ( ruleALSIntersection EOF ) | ||
2168 | // InternalAlloyLanguage.g:739:1: ruleALSIntersection EOF | ||
2169 | { | ||
2170 | if ( state.backtracking==0 ) { | ||
2171 | before(grammarAccess.getALSIntersectionRule()); | ||
2172 | } | ||
2173 | pushFollow(FOLLOW_1); | ||
2174 | ruleALSIntersection(); | ||
2175 | |||
2176 | state._fsp--; | ||
2177 | if (state.failed) return ; | ||
2178 | if ( state.backtracking==0 ) { | ||
2179 | after(grammarAccess.getALSIntersectionRule()); | ||
2180 | } | ||
2181 | match(input,EOF,FOLLOW_2); if (state.failed) return ; | ||
2182 | |||
2183 | } | ||
2184 | |||
2185 | } | ||
2186 | catch (RecognitionException re) { | ||
2187 | reportError(re); | ||
2188 | recover(input,re); | ||
2189 | } | ||
2190 | finally { | ||
2191 | } | ||
2192 | return ; | ||
2193 | } | ||
2194 | // $ANTLR end "entryRuleALSIntersection" | ||
2195 | |||
2196 | |||
2197 | // $ANTLR start "ruleALSIntersection" | ||
2198 | // InternalAlloyLanguage.g:746:1: ruleALSIntersection : ( ( rule__ALSIntersection__Group__0 ) ) ; | ||
2199 | public final void ruleALSIntersection() throws RecognitionException { | ||
2200 | |||
2201 | int stackSize = keepStackSize(); | ||
2202 | |||
2203 | try { | ||
2204 | // InternalAlloyLanguage.g:750:2: ( ( ( rule__ALSIntersection__Group__0 ) ) ) | ||
2205 | // InternalAlloyLanguage.g:751:1: ( ( rule__ALSIntersection__Group__0 ) ) | ||
2206 | { | ||
2207 | // InternalAlloyLanguage.g:751:1: ( ( rule__ALSIntersection__Group__0 ) ) | ||
2208 | // InternalAlloyLanguage.g:752:1: ( rule__ALSIntersection__Group__0 ) | ||
2209 | { | ||
2210 | if ( state.backtracking==0 ) { | ||
2211 | before(grammarAccess.getALSIntersectionAccess().getGroup()); | ||
2212 | } | ||
2213 | // InternalAlloyLanguage.g:753:1: ( rule__ALSIntersection__Group__0 ) | ||
2214 | // InternalAlloyLanguage.g:753:2: rule__ALSIntersection__Group__0 | ||
2215 | { | ||
2216 | pushFollow(FOLLOW_2); | ||
2217 | rule__ALSIntersection__Group__0(); | ||
2218 | |||
2219 | state._fsp--; | ||
2220 | if (state.failed) return ; | ||
2221 | |||
2222 | } | ||
2223 | |||
2224 | if ( state.backtracking==0 ) { | ||
2225 | after(grammarAccess.getALSIntersectionAccess().getGroup()); | ||
2226 | } | ||
2227 | |||
2228 | } | ||
2229 | |||
2230 | |||
2231 | } | ||
2232 | |||
2233 | } | ||
2234 | catch (RecognitionException re) { | ||
2235 | reportError(re); | ||
2236 | recover(input,re); | ||
2237 | } | ||
2238 | finally { | ||
2239 | |||
2240 | restoreStackSize(stackSize); | ||
2241 | |||
2242 | } | ||
2243 | return ; | ||
2244 | } | ||
2245 | // $ANTLR end "ruleALSIntersection" | ||
2246 | |||
2247 | |||
2248 | // $ANTLR start "entryRuleALSDirectProduct" | ||
2249 | // InternalAlloyLanguage.g:765:1: entryRuleALSDirectProduct : ruleALSDirectProduct EOF ; | ||
2250 | public final void entryRuleALSDirectProduct() throws RecognitionException { | ||
2251 | try { | ||
2252 | // InternalAlloyLanguage.g:766:1: ( ruleALSDirectProduct EOF ) | ||
2253 | // InternalAlloyLanguage.g:767:1: ruleALSDirectProduct EOF | ||
2254 | { | ||
2255 | if ( state.backtracking==0 ) { | ||
2256 | before(grammarAccess.getALSDirectProductRule()); | ||
2257 | } | ||
2258 | pushFollow(FOLLOW_1); | ||
2259 | ruleALSDirectProduct(); | ||
2260 | |||
2261 | state._fsp--; | ||
2262 | if (state.failed) return ; | ||
2263 | if ( state.backtracking==0 ) { | ||
2264 | after(grammarAccess.getALSDirectProductRule()); | ||
2265 | } | ||
2266 | match(input,EOF,FOLLOW_2); if (state.failed) return ; | ||
2267 | |||
2268 | } | ||
2269 | |||
2270 | } | ||
2271 | catch (RecognitionException re) { | ||
2272 | reportError(re); | ||
2273 | recover(input,re); | ||
2274 | } | ||
2275 | finally { | ||
2276 | } | ||
2277 | return ; | ||
2278 | } | ||
2279 | // $ANTLR end "entryRuleALSDirectProduct" | ||
2280 | |||
2281 | |||
2282 | // $ANTLR start "ruleALSDirectProduct" | ||
2283 | // InternalAlloyLanguage.g:774:1: ruleALSDirectProduct : ( ( rule__ALSDirectProduct__Group__0 ) ) ; | ||
2284 | public final void ruleALSDirectProduct() throws RecognitionException { | ||
2285 | |||
2286 | int stackSize = keepStackSize(); | ||
2287 | |||
2288 | try { | ||
2289 | // InternalAlloyLanguage.g:778:2: ( ( ( rule__ALSDirectProduct__Group__0 ) ) ) | ||
2290 | // InternalAlloyLanguage.g:779:1: ( ( rule__ALSDirectProduct__Group__0 ) ) | ||
2291 | { | ||
2292 | // InternalAlloyLanguage.g:779:1: ( ( rule__ALSDirectProduct__Group__0 ) ) | ||
2293 | // InternalAlloyLanguage.g:780:1: ( rule__ALSDirectProduct__Group__0 ) | ||
2294 | { | ||
2295 | if ( state.backtracking==0 ) { | ||
2296 | before(grammarAccess.getALSDirectProductAccess().getGroup()); | ||
2297 | } | ||
2298 | // InternalAlloyLanguage.g:781:1: ( rule__ALSDirectProduct__Group__0 ) | ||
2299 | // InternalAlloyLanguage.g:781:2: rule__ALSDirectProduct__Group__0 | ||
2300 | { | ||
2301 | pushFollow(FOLLOW_2); | ||
2302 | rule__ALSDirectProduct__Group__0(); | ||
2303 | |||
2304 | state._fsp--; | ||
2305 | if (state.failed) return ; | ||
2306 | |||
2307 | } | ||
2308 | |||
2309 | if ( state.backtracking==0 ) { | ||
2310 | after(grammarAccess.getALSDirectProductAccess().getGroup()); | ||
2311 | } | ||
2312 | |||
2313 | } | ||
2314 | |||
2315 | |||
2316 | } | ||
2317 | |||
2318 | } | ||
2319 | catch (RecognitionException re) { | ||
2320 | reportError(re); | ||
2321 | recover(input,re); | ||
2322 | } | ||
2323 | finally { | ||
2324 | |||
2325 | restoreStackSize(stackSize); | ||
2326 | |||
2327 | } | ||
2328 | return ; | ||
2329 | } | ||
2330 | // $ANTLR end "ruleALSDirectProduct" | ||
2331 | |||
2332 | |||
2333 | // $ANTLR start "entryRuleALSPreficed" | ||
2334 | // InternalAlloyLanguage.g:793:1: entryRuleALSPreficed : ruleALSPreficed EOF ; | ||
2335 | public final void entryRuleALSPreficed() throws RecognitionException { | ||
2336 | try { | ||
2337 | // InternalAlloyLanguage.g:794:1: ( ruleALSPreficed EOF ) | ||
2338 | // InternalAlloyLanguage.g:795:1: ruleALSPreficed EOF | ||
2339 | { | ||
2340 | if ( state.backtracking==0 ) { | ||
2341 | before(grammarAccess.getALSPreficedRule()); | ||
2342 | } | ||
2343 | pushFollow(FOLLOW_1); | ||
2344 | ruleALSPreficed(); | ||
2345 | |||
2346 | state._fsp--; | ||
2347 | if (state.failed) return ; | ||
2348 | if ( state.backtracking==0 ) { | ||
2349 | after(grammarAccess.getALSPreficedRule()); | ||
2350 | } | ||
2351 | match(input,EOF,FOLLOW_2); if (state.failed) return ; | ||
2352 | |||
2353 | } | ||
2354 | |||
2355 | } | ||
2356 | catch (RecognitionException re) { | ||
2357 | reportError(re); | ||
2358 | recover(input,re); | ||
2359 | } | ||
2360 | finally { | ||
2361 | } | ||
2362 | return ; | ||
2363 | } | ||
2364 | // $ANTLR end "entryRuleALSPreficed" | ||
2365 | |||
2366 | |||
2367 | // $ANTLR start "ruleALSPreficed" | ||
2368 | // InternalAlloyLanguage.g:802:1: ruleALSPreficed : ( ( rule__ALSPreficed__Alternatives ) ) ; | ||
2369 | public final void ruleALSPreficed() throws RecognitionException { | ||
2370 | |||
2371 | int stackSize = keepStackSize(); | ||
2372 | |||
2373 | try { | ||
2374 | // InternalAlloyLanguage.g:806:2: ( ( ( rule__ALSPreficed__Alternatives ) ) ) | ||
2375 | // InternalAlloyLanguage.g:807:1: ( ( rule__ALSPreficed__Alternatives ) ) | ||
2376 | { | ||
2377 | // InternalAlloyLanguage.g:807:1: ( ( rule__ALSPreficed__Alternatives ) ) | ||
2378 | // InternalAlloyLanguage.g:808:1: ( rule__ALSPreficed__Alternatives ) | ||
2379 | { | ||
2380 | if ( state.backtracking==0 ) { | ||
2381 | before(grammarAccess.getALSPreficedAccess().getAlternatives()); | ||
2382 | } | ||
2383 | // InternalAlloyLanguage.g:809:1: ( rule__ALSPreficed__Alternatives ) | ||
2384 | // InternalAlloyLanguage.g:809:2: rule__ALSPreficed__Alternatives | ||
2385 | { | ||
2386 | pushFollow(FOLLOW_2); | ||
2387 | rule__ALSPreficed__Alternatives(); | ||
2388 | |||
2389 | state._fsp--; | ||
2390 | if (state.failed) return ; | ||
2391 | |||
2392 | } | ||
2393 | |||
2394 | if ( state.backtracking==0 ) { | ||
2395 | after(grammarAccess.getALSPreficedAccess().getAlternatives()); | ||
2396 | } | ||
2397 | |||
2398 | } | ||
2399 | |||
2400 | |||
2401 | } | ||
2402 | |||
2403 | } | ||
2404 | catch (RecognitionException re) { | ||
2405 | reportError(re); | ||
2406 | recover(input,re); | ||
2407 | } | ||
2408 | finally { | ||
2409 | |||
2410 | restoreStackSize(stackSize); | ||
2411 | |||
2412 | } | ||
2413 | return ; | ||
2414 | } | ||
2415 | // $ANTLR end "ruleALSPreficed" | ||
2416 | |||
2417 | |||
2418 | // $ANTLR start "entryRuleALSVariableDeclaration" | ||
2419 | // InternalAlloyLanguage.g:821:1: entryRuleALSVariableDeclaration : ruleALSVariableDeclaration EOF ; | ||
2420 | public final void entryRuleALSVariableDeclaration() throws RecognitionException { | ||
2421 | try { | ||
2422 | // InternalAlloyLanguage.g:822:1: ( ruleALSVariableDeclaration EOF ) | ||
2423 | // InternalAlloyLanguage.g:823:1: ruleALSVariableDeclaration EOF | ||
2424 | { | ||
2425 | if ( state.backtracking==0 ) { | ||
2426 | before(grammarAccess.getALSVariableDeclarationRule()); | ||
2427 | } | ||
2428 | pushFollow(FOLLOW_1); | ||
2429 | ruleALSVariableDeclaration(); | ||
2430 | |||
2431 | state._fsp--; | ||
2432 | if (state.failed) return ; | ||
2433 | if ( state.backtracking==0 ) { | ||
2434 | after(grammarAccess.getALSVariableDeclarationRule()); | ||
2435 | } | ||
2436 | match(input,EOF,FOLLOW_2); if (state.failed) return ; | ||
2437 | |||
2438 | } | ||
2439 | |||
2440 | } | ||
2441 | catch (RecognitionException re) { | ||
2442 | reportError(re); | ||
2443 | recover(input,re); | ||
2444 | } | ||
2445 | finally { | ||
2446 | } | ||
2447 | return ; | ||
2448 | } | ||
2449 | // $ANTLR end "entryRuleALSVariableDeclaration" | ||
2450 | |||
2451 | |||
2452 | // $ANTLR start "ruleALSVariableDeclaration" | ||
2453 | // InternalAlloyLanguage.g:830:1: ruleALSVariableDeclaration : ( ( rule__ALSVariableDeclaration__Group__0 ) ) ; | ||
2454 | public final void ruleALSVariableDeclaration() throws RecognitionException { | ||
2455 | |||
2456 | int stackSize = keepStackSize(); | ||
2457 | |||
2458 | try { | ||
2459 | // InternalAlloyLanguage.g:834:2: ( ( ( rule__ALSVariableDeclaration__Group__0 ) ) ) | ||
2460 | // InternalAlloyLanguage.g:835:1: ( ( rule__ALSVariableDeclaration__Group__0 ) ) | ||
2461 | { | ||
2462 | // InternalAlloyLanguage.g:835:1: ( ( rule__ALSVariableDeclaration__Group__0 ) ) | ||
2463 | // InternalAlloyLanguage.g:836:1: ( rule__ALSVariableDeclaration__Group__0 ) | ||
2464 | { | ||
2465 | if ( state.backtracking==0 ) { | ||
2466 | before(grammarAccess.getALSVariableDeclarationAccess().getGroup()); | ||
2467 | } | ||
2468 | // InternalAlloyLanguage.g:837:1: ( rule__ALSVariableDeclaration__Group__0 ) | ||
2469 | // InternalAlloyLanguage.g:837:2: rule__ALSVariableDeclaration__Group__0 | ||
2470 | { | ||
2471 | pushFollow(FOLLOW_2); | ||
2472 | rule__ALSVariableDeclaration__Group__0(); | ||
2473 | |||
2474 | state._fsp--; | ||
2475 | if (state.failed) return ; | ||
2476 | |||
2477 | } | ||
2478 | |||
2479 | if ( state.backtracking==0 ) { | ||
2480 | after(grammarAccess.getALSVariableDeclarationAccess().getGroup()); | ||
2481 | } | ||
2482 | |||
2483 | } | ||
2484 | |||
2485 | |||
2486 | } | ||
2487 | |||
2488 | } | ||
2489 | catch (RecognitionException re) { | ||
2490 | reportError(re); | ||
2491 | recover(input,re); | ||
2492 | } | ||
2493 | finally { | ||
2494 | |||
2495 | restoreStackSize(stackSize); | ||
2496 | |||
2497 | } | ||
2498 | return ; | ||
2499 | } | ||
2500 | // $ANTLR end "ruleALSVariableDeclaration" | ||
2501 | |||
2502 | |||
2503 | // $ANTLR start "entryRuleALSBasicRelationTerm" | ||
2504 | // InternalAlloyLanguage.g:849:1: entryRuleALSBasicRelationTerm : ruleALSBasicRelationTerm EOF ; | ||
2505 | public final void entryRuleALSBasicRelationTerm() throws RecognitionException { | ||
2506 | try { | ||
2507 | // InternalAlloyLanguage.g:850:1: ( ruleALSBasicRelationTerm EOF ) | ||
2508 | // InternalAlloyLanguage.g:851:1: ruleALSBasicRelationTerm EOF | ||
2509 | { | ||
2510 | if ( state.backtracking==0 ) { | ||
2511 | before(grammarAccess.getALSBasicRelationTermRule()); | ||
2512 | } | ||
2513 | pushFollow(FOLLOW_1); | ||
2514 | ruleALSBasicRelationTerm(); | ||
2515 | |||
2516 | state._fsp--; | ||
2517 | if (state.failed) return ; | ||
2518 | if ( state.backtracking==0 ) { | ||
2519 | after(grammarAccess.getALSBasicRelationTermRule()); | ||
2520 | } | ||
2521 | match(input,EOF,FOLLOW_2); if (state.failed) return ; | ||
2522 | |||
2523 | } | ||
2524 | |||
2525 | } | ||
2526 | catch (RecognitionException re) { | ||
2527 | reportError(re); | ||
2528 | recover(input,re); | ||
2529 | } | ||
2530 | finally { | ||
2531 | } | ||
2532 | return ; | ||
2533 | } | ||
2534 | // $ANTLR end "entryRuleALSBasicRelationTerm" | ||
2535 | |||
2536 | |||
2537 | // $ANTLR start "ruleALSBasicRelationTerm" | ||
2538 | // InternalAlloyLanguage.g:858:1: ruleALSBasicRelationTerm : ( ( rule__ALSBasicRelationTerm__Alternatives ) ) ; | ||
2539 | public final void ruleALSBasicRelationTerm() throws RecognitionException { | ||
2540 | |||
2541 | int stackSize = keepStackSize(); | ||
2542 | |||
2543 | try { | ||
2544 | // InternalAlloyLanguage.g:862:2: ( ( ( rule__ALSBasicRelationTerm__Alternatives ) ) ) | ||
2545 | // InternalAlloyLanguage.g:863:1: ( ( rule__ALSBasicRelationTerm__Alternatives ) ) | ||
2546 | { | ||
2547 | // InternalAlloyLanguage.g:863:1: ( ( rule__ALSBasicRelationTerm__Alternatives ) ) | ||
2548 | // InternalAlloyLanguage.g:864:1: ( rule__ALSBasicRelationTerm__Alternatives ) | ||
2549 | { | ||
2550 | if ( state.backtracking==0 ) { | ||
2551 | before(grammarAccess.getALSBasicRelationTermAccess().getAlternatives()); | ||
2552 | } | ||
2553 | // InternalAlloyLanguage.g:865:1: ( rule__ALSBasicRelationTerm__Alternatives ) | ||
2554 | // InternalAlloyLanguage.g:865:2: rule__ALSBasicRelationTerm__Alternatives | ||
2555 | { | ||
2556 | pushFollow(FOLLOW_2); | ||
2557 | rule__ALSBasicRelationTerm__Alternatives(); | ||
2558 | |||
2559 | state._fsp--; | ||
2560 | if (state.failed) return ; | ||
2561 | |||
2562 | } | ||
2563 | |||
2564 | if ( state.backtracking==0 ) { | ||
2565 | after(grammarAccess.getALSBasicRelationTermAccess().getAlternatives()); | ||
2566 | } | ||
2567 | |||
2568 | } | ||
2569 | |||
2570 | |||
2571 | } | ||
2572 | |||
2573 | } | ||
2574 | catch (RecognitionException re) { | ||
2575 | reportError(re); | ||
2576 | recover(input,re); | ||
2577 | } | ||
2578 | finally { | ||
2579 | |||
2580 | restoreStackSize(stackSize); | ||
2581 | |||
2582 | } | ||
2583 | return ; | ||
2584 | } | ||
2585 | // $ANTLR end "ruleALSBasicRelationTerm" | ||
2586 | |||
2587 | |||
2588 | // $ANTLR start "entryRuleALSRunCommand" | ||
2589 | // InternalAlloyLanguage.g:877:1: entryRuleALSRunCommand : ruleALSRunCommand EOF ; | ||
2590 | public final void entryRuleALSRunCommand() throws RecognitionException { | ||
2591 | try { | ||
2592 | // InternalAlloyLanguage.g:878:1: ( ruleALSRunCommand EOF ) | ||
2593 | // InternalAlloyLanguage.g:879:1: ruleALSRunCommand EOF | ||
2594 | { | ||
2595 | if ( state.backtracking==0 ) { | ||
2596 | before(grammarAccess.getALSRunCommandRule()); | ||
2597 | } | ||
2598 | pushFollow(FOLLOW_1); | ||
2599 | ruleALSRunCommand(); | ||
2600 | |||
2601 | state._fsp--; | ||
2602 | if (state.failed) return ; | ||
2603 | if ( state.backtracking==0 ) { | ||
2604 | after(grammarAccess.getALSRunCommandRule()); | ||
2605 | } | ||
2606 | match(input,EOF,FOLLOW_2); if (state.failed) return ; | ||
2607 | |||
2608 | } | ||
2609 | |||
2610 | } | ||
2611 | catch (RecognitionException re) { | ||
2612 | reportError(re); | ||
2613 | recover(input,re); | ||
2614 | } | ||
2615 | finally { | ||
2616 | } | ||
2617 | return ; | ||
2618 | } | ||
2619 | // $ANTLR end "entryRuleALSRunCommand" | ||
2620 | |||
2621 | |||
2622 | // $ANTLR start "ruleALSRunCommand" | ||
2623 | // InternalAlloyLanguage.g:886:1: ruleALSRunCommand : ( ( rule__ALSRunCommand__Group__0 ) ) ; | ||
2624 | public final void ruleALSRunCommand() throws RecognitionException { | ||
2625 | |||
2626 | int stackSize = keepStackSize(); | ||
2627 | |||
2628 | try { | ||
2629 | // InternalAlloyLanguage.g:890:2: ( ( ( rule__ALSRunCommand__Group__0 ) ) ) | ||
2630 | // InternalAlloyLanguage.g:891:1: ( ( rule__ALSRunCommand__Group__0 ) ) | ||
2631 | { | ||
2632 | // InternalAlloyLanguage.g:891:1: ( ( rule__ALSRunCommand__Group__0 ) ) | ||
2633 | // InternalAlloyLanguage.g:892:1: ( rule__ALSRunCommand__Group__0 ) | ||
2634 | { | ||
2635 | if ( state.backtracking==0 ) { | ||
2636 | before(grammarAccess.getALSRunCommandAccess().getGroup()); | ||
2637 | } | ||
2638 | // InternalAlloyLanguage.g:893:1: ( rule__ALSRunCommand__Group__0 ) | ||
2639 | // InternalAlloyLanguage.g:893:2: rule__ALSRunCommand__Group__0 | ||
2640 | { | ||
2641 | pushFollow(FOLLOW_2); | ||
2642 | rule__ALSRunCommand__Group__0(); | ||
2643 | |||
2644 | state._fsp--; | ||
2645 | if (state.failed) return ; | ||
2646 | |||
2647 | } | ||
2648 | |||
2649 | if ( state.backtracking==0 ) { | ||
2650 | after(grammarAccess.getALSRunCommandAccess().getGroup()); | ||
2651 | } | ||
2652 | |||
2653 | } | ||
2654 | |||
2655 | |||
2656 | } | ||
2657 | |||
2658 | } | ||
2659 | catch (RecognitionException re) { | ||
2660 | reportError(re); | ||
2661 | recover(input,re); | ||
2662 | } | ||
2663 | finally { | ||
2664 | |||
2665 | restoreStackSize(stackSize); | ||
2666 | |||
2667 | } | ||
2668 | return ; | ||
2669 | } | ||
2670 | // $ANTLR end "ruleALSRunCommand" | ||
2671 | |||
2672 | |||
2673 | // $ANTLR start "entryRuleALSTypeScope" | ||
2674 | // InternalAlloyLanguage.g:905:1: entryRuleALSTypeScope : ruleALSTypeScope EOF ; | ||
2675 | public final void entryRuleALSTypeScope() throws RecognitionException { | ||
2676 | try { | ||
2677 | // InternalAlloyLanguage.g:906:1: ( ruleALSTypeScope EOF ) | ||
2678 | // InternalAlloyLanguage.g:907:1: ruleALSTypeScope EOF | ||
2679 | { | ||
2680 | if ( state.backtracking==0 ) { | ||
2681 | before(grammarAccess.getALSTypeScopeRule()); | ||
2682 | } | ||
2683 | pushFollow(FOLLOW_1); | ||
2684 | ruleALSTypeScope(); | ||
2685 | |||
2686 | state._fsp--; | ||
2687 | if (state.failed) return ; | ||
2688 | if ( state.backtracking==0 ) { | ||
2689 | after(grammarAccess.getALSTypeScopeRule()); | ||
2690 | } | ||
2691 | match(input,EOF,FOLLOW_2); if (state.failed) return ; | ||
2692 | |||
2693 | } | ||
2694 | |||
2695 | } | ||
2696 | catch (RecognitionException re) { | ||
2697 | reportError(re); | ||
2698 | recover(input,re); | ||
2699 | } | ||
2700 | finally { | ||
2701 | } | ||
2702 | return ; | ||
2703 | } | ||
2704 | // $ANTLR end "entryRuleALSTypeScope" | ||
2705 | |||
2706 | |||
2707 | // $ANTLR start "ruleALSTypeScope" | ||
2708 | // InternalAlloyLanguage.g:914:1: ruleALSTypeScope : ( ( rule__ALSTypeScope__Alternatives ) ) ; | ||
2709 | public final void ruleALSTypeScope() throws RecognitionException { | ||
2710 | |||
2711 | int stackSize = keepStackSize(); | ||
2712 | |||
2713 | try { | ||
2714 | // InternalAlloyLanguage.g:918:2: ( ( ( rule__ALSTypeScope__Alternatives ) ) ) | ||
2715 | // InternalAlloyLanguage.g:919:1: ( ( rule__ALSTypeScope__Alternatives ) ) | ||
2716 | { | ||
2717 | // InternalAlloyLanguage.g:919:1: ( ( rule__ALSTypeScope__Alternatives ) ) | ||
2718 | // InternalAlloyLanguage.g:920:1: ( rule__ALSTypeScope__Alternatives ) | ||
2719 | { | ||
2720 | if ( state.backtracking==0 ) { | ||
2721 | before(grammarAccess.getALSTypeScopeAccess().getAlternatives()); | ||
2722 | } | ||
2723 | // InternalAlloyLanguage.g:921:1: ( rule__ALSTypeScope__Alternatives ) | ||
2724 | // InternalAlloyLanguage.g:921:2: rule__ALSTypeScope__Alternatives | ||
2725 | { | ||
2726 | pushFollow(FOLLOW_2); | ||
2727 | rule__ALSTypeScope__Alternatives(); | ||
2728 | |||
2729 | state._fsp--; | ||
2730 | if (state.failed) return ; | ||
2731 | |||
2732 | } | ||
2733 | |||
2734 | if ( state.backtracking==0 ) { | ||
2735 | after(grammarAccess.getALSTypeScopeAccess().getAlternatives()); | ||
2736 | } | ||
2737 | |||
2738 | } | ||
2739 | |||
2740 | |||
2741 | } | ||
2742 | |||
2743 | } | ||
2744 | catch (RecognitionException re) { | ||
2745 | reportError(re); | ||
2746 | recover(input,re); | ||
2747 | } | ||
2748 | finally { | ||
2749 | |||
2750 | restoreStackSize(stackSize); | ||
2751 | |||
2752 | } | ||
2753 | return ; | ||
2754 | } | ||
2755 | // $ANTLR end "ruleALSTypeScope" | ||
2756 | |||
2757 | |||
2758 | // $ANTLR start "entryRuleALSSigScope" | ||
2759 | // InternalAlloyLanguage.g:933:1: entryRuleALSSigScope : ruleALSSigScope EOF ; | ||
2760 | public final void entryRuleALSSigScope() throws RecognitionException { | ||
2761 | try { | ||
2762 | // InternalAlloyLanguage.g:934:1: ( ruleALSSigScope EOF ) | ||
2763 | // InternalAlloyLanguage.g:935:1: ruleALSSigScope EOF | ||
2764 | { | ||
2765 | if ( state.backtracking==0 ) { | ||
2766 | before(grammarAccess.getALSSigScopeRule()); | ||
2767 | } | ||
2768 | pushFollow(FOLLOW_1); | ||
2769 | ruleALSSigScope(); | ||
2770 | |||
2771 | state._fsp--; | ||
2772 | if (state.failed) return ; | ||
2773 | if ( state.backtracking==0 ) { | ||
2774 | after(grammarAccess.getALSSigScopeRule()); | ||
2775 | } | ||
2776 | match(input,EOF,FOLLOW_2); if (state.failed) return ; | ||
2777 | |||
2778 | } | ||
2779 | |||
2780 | } | ||
2781 | catch (RecognitionException re) { | ||
2782 | reportError(re); | ||
2783 | recover(input,re); | ||
2784 | } | ||
2785 | finally { | ||
2786 | } | ||
2787 | return ; | ||
2788 | } | ||
2789 | // $ANTLR end "entryRuleALSSigScope" | ||
2790 | |||
2791 | |||
2792 | // $ANTLR start "ruleALSSigScope" | ||
2793 | // InternalAlloyLanguage.g:942:1: ruleALSSigScope : ( ( rule__ALSSigScope__Group__0 ) ) ; | ||
2794 | public final void ruleALSSigScope() throws RecognitionException { | ||
2795 | |||
2796 | int stackSize = keepStackSize(); | ||
2797 | |||
2798 | try { | ||
2799 | // InternalAlloyLanguage.g:946:2: ( ( ( rule__ALSSigScope__Group__0 ) ) ) | ||
2800 | // InternalAlloyLanguage.g:947:1: ( ( rule__ALSSigScope__Group__0 ) ) | ||
2801 | { | ||
2802 | // InternalAlloyLanguage.g:947:1: ( ( rule__ALSSigScope__Group__0 ) ) | ||
2803 | // InternalAlloyLanguage.g:948:1: ( rule__ALSSigScope__Group__0 ) | ||
2804 | { | ||
2805 | if ( state.backtracking==0 ) { | ||
2806 | before(grammarAccess.getALSSigScopeAccess().getGroup()); | ||
2807 | } | ||
2808 | // InternalAlloyLanguage.g:949:1: ( rule__ALSSigScope__Group__0 ) | ||
2809 | // InternalAlloyLanguage.g:949:2: rule__ALSSigScope__Group__0 | ||
2810 | { | ||
2811 | pushFollow(FOLLOW_2); | ||
2812 | rule__ALSSigScope__Group__0(); | ||
2813 | |||
2814 | state._fsp--; | ||
2815 | if (state.failed) return ; | ||
2816 | |||
2817 | } | ||
2818 | |||
2819 | if ( state.backtracking==0 ) { | ||
2820 | after(grammarAccess.getALSSigScopeAccess().getGroup()); | ||
2821 | } | ||
2822 | |||
2823 | } | ||
2824 | |||
2825 | |||
2826 | } | ||
2827 | |||
2828 | } | ||
2829 | catch (RecognitionException re) { | ||
2830 | reportError(re); | ||
2831 | recover(input,re); | ||
2832 | } | ||
2833 | finally { | ||
2834 | |||
2835 | restoreStackSize(stackSize); | ||
2836 | |||
2837 | } | ||
2838 | return ; | ||
2839 | } | ||
2840 | // $ANTLR end "ruleALSSigScope" | ||
2841 | |||
2842 | |||
2843 | // $ANTLR start "entryRuleALSIntScope" | ||
2844 | // InternalAlloyLanguage.g:961:1: entryRuleALSIntScope : ruleALSIntScope EOF ; | ||
2845 | public final void entryRuleALSIntScope() throws RecognitionException { | ||
2846 | try { | ||
2847 | // InternalAlloyLanguage.g:962:1: ( ruleALSIntScope EOF ) | ||
2848 | // InternalAlloyLanguage.g:963:1: ruleALSIntScope EOF | ||
2849 | { | ||
2850 | if ( state.backtracking==0 ) { | ||
2851 | before(grammarAccess.getALSIntScopeRule()); | ||
2852 | } | ||
2853 | pushFollow(FOLLOW_1); | ||
2854 | ruleALSIntScope(); | ||
2855 | |||
2856 | state._fsp--; | ||
2857 | if (state.failed) return ; | ||
2858 | if ( state.backtracking==0 ) { | ||
2859 | after(grammarAccess.getALSIntScopeRule()); | ||
2860 | } | ||
2861 | match(input,EOF,FOLLOW_2); if (state.failed) return ; | ||
2862 | |||
2863 | } | ||
2864 | |||
2865 | } | ||
2866 | catch (RecognitionException re) { | ||
2867 | reportError(re); | ||
2868 | recover(input,re); | ||
2869 | } | ||
2870 | finally { | ||
2871 | } | ||
2872 | return ; | ||
2873 | } | ||
2874 | // $ANTLR end "entryRuleALSIntScope" | ||
2875 | |||
2876 | |||
2877 | // $ANTLR start "ruleALSIntScope" | ||
2878 | // InternalAlloyLanguage.g:970:1: ruleALSIntScope : ( ( rule__ALSIntScope__Group__0 ) ) ; | ||
2879 | public final void ruleALSIntScope() throws RecognitionException { | ||
2880 | |||
2881 | int stackSize = keepStackSize(); | ||
2882 | |||
2883 | try { | ||
2884 | // InternalAlloyLanguage.g:974:2: ( ( ( rule__ALSIntScope__Group__0 ) ) ) | ||
2885 | // InternalAlloyLanguage.g:975:1: ( ( rule__ALSIntScope__Group__0 ) ) | ||
2886 | { | ||
2887 | // InternalAlloyLanguage.g:975:1: ( ( rule__ALSIntScope__Group__0 ) ) | ||
2888 | // InternalAlloyLanguage.g:976:1: ( rule__ALSIntScope__Group__0 ) | ||
2889 | { | ||
2890 | if ( state.backtracking==0 ) { | ||
2891 | before(grammarAccess.getALSIntScopeAccess().getGroup()); | ||
2892 | } | ||
2893 | // InternalAlloyLanguage.g:977:1: ( rule__ALSIntScope__Group__0 ) | ||
2894 | // InternalAlloyLanguage.g:977:2: rule__ALSIntScope__Group__0 | ||
2895 | { | ||
2896 | pushFollow(FOLLOW_2); | ||
2897 | rule__ALSIntScope__Group__0(); | ||
2898 | |||
2899 | state._fsp--; | ||
2900 | if (state.failed) return ; | ||
2901 | |||
2902 | } | ||
2903 | |||
2904 | if ( state.backtracking==0 ) { | ||
2905 | after(grammarAccess.getALSIntScopeAccess().getGroup()); | ||
2906 | } | ||
2907 | |||
2908 | } | ||
2909 | |||
2910 | |||
2911 | } | ||
2912 | |||
2913 | } | ||
2914 | catch (RecognitionException re) { | ||
2915 | reportError(re); | ||
2916 | recover(input,re); | ||
2917 | } | ||
2918 | finally { | ||
2919 | |||
2920 | restoreStackSize(stackSize); | ||
2921 | |||
2922 | } | ||
2923 | return ; | ||
2924 | } | ||
2925 | // $ANTLR end "ruleALSIntScope" | ||
2926 | |||
2927 | |||
2928 | // $ANTLR start "ruleALSMultiplicity" | ||
2929 | // InternalAlloyLanguage.g:990:1: ruleALSMultiplicity : ( ( rule__ALSMultiplicity__Alternatives ) ) ; | ||
2930 | public final void ruleALSMultiplicity() throws RecognitionException { | ||
2931 | |||
2932 | int stackSize = keepStackSize(); | ||
2933 | |||
2934 | try { | ||
2935 | // InternalAlloyLanguage.g:994:1: ( ( ( rule__ALSMultiplicity__Alternatives ) ) ) | ||
2936 | // InternalAlloyLanguage.g:995:1: ( ( rule__ALSMultiplicity__Alternatives ) ) | ||
2937 | { | ||
2938 | // InternalAlloyLanguage.g:995:1: ( ( rule__ALSMultiplicity__Alternatives ) ) | ||
2939 | // InternalAlloyLanguage.g:996:1: ( rule__ALSMultiplicity__Alternatives ) | ||
2940 | { | ||
2941 | if ( state.backtracking==0 ) { | ||
2942 | before(grammarAccess.getALSMultiplicityAccess().getAlternatives()); | ||
2943 | } | ||
2944 | // InternalAlloyLanguage.g:997:1: ( rule__ALSMultiplicity__Alternatives ) | ||
2945 | // InternalAlloyLanguage.g:997:2: rule__ALSMultiplicity__Alternatives | ||
2946 | { | ||
2947 | pushFollow(FOLLOW_2); | ||
2948 | rule__ALSMultiplicity__Alternatives(); | ||
2949 | |||
2950 | state._fsp--; | ||
2951 | if (state.failed) return ; | ||
2952 | |||
2953 | } | ||
2954 | |||
2955 | if ( state.backtracking==0 ) { | ||
2956 | after(grammarAccess.getALSMultiplicityAccess().getAlternatives()); | ||
2957 | } | ||
2958 | |||
2959 | } | ||
2960 | |||
2961 | |||
2962 | } | ||
2963 | |||
2964 | } | ||
2965 | catch (RecognitionException re) { | ||
2966 | reportError(re); | ||
2967 | recover(input,re); | ||
2968 | } | ||
2969 | finally { | ||
2970 | |||
2971 | restoreStackSize(stackSize); | ||
2972 | |||
2973 | } | ||
2974 | return ; | ||
2975 | } | ||
2976 | // $ANTLR end "ruleALSMultiplicity" | ||
2977 | |||
2978 | |||
2979 | // $ANTLR start "ruleALSNumericOperator" | ||
2980 | // InternalAlloyLanguage.g:1009:1: ruleALSNumericOperator : ( ( rule__ALSNumericOperator__Alternatives ) ) ; | ||
2981 | public final void ruleALSNumericOperator() throws RecognitionException { | ||
2982 | |||
2983 | int stackSize = keepStackSize(); | ||
2984 | |||
2985 | try { | ||
2986 | // InternalAlloyLanguage.g:1013:1: ( ( ( rule__ALSNumericOperator__Alternatives ) ) ) | ||
2987 | // InternalAlloyLanguage.g:1014:1: ( ( rule__ALSNumericOperator__Alternatives ) ) | ||
2988 | { | ||
2989 | // InternalAlloyLanguage.g:1014:1: ( ( rule__ALSNumericOperator__Alternatives ) ) | ||
2990 | // InternalAlloyLanguage.g:1015:1: ( rule__ALSNumericOperator__Alternatives ) | ||
2991 | { | ||
2992 | if ( state.backtracking==0 ) { | ||
2993 | before(grammarAccess.getALSNumericOperatorAccess().getAlternatives()); | ||
2994 | } | ||
2995 | // InternalAlloyLanguage.g:1016:1: ( rule__ALSNumericOperator__Alternatives ) | ||
2996 | // InternalAlloyLanguage.g:1016:2: rule__ALSNumericOperator__Alternatives | ||
2997 | { | ||
2998 | pushFollow(FOLLOW_2); | ||
2999 | rule__ALSNumericOperator__Alternatives(); | ||
3000 | |||
3001 | state._fsp--; | ||
3002 | if (state.failed) return ; | ||
3003 | |||
3004 | } | ||
3005 | |||
3006 | if ( state.backtracking==0 ) { | ||
3007 | after(grammarAccess.getALSNumericOperatorAccess().getAlternatives()); | ||
3008 | } | ||
3009 | |||
3010 | } | ||
3011 | |||
3012 | |||
3013 | } | ||
3014 | |||
3015 | } | ||
3016 | catch (RecognitionException re) { | ||
3017 | reportError(re); | ||
3018 | recover(input,re); | ||
3019 | } | ||
3020 | finally { | ||
3021 | |||
3022 | restoreStackSize(stackSize); | ||
3023 | |||
3024 | } | ||
3025 | return ; | ||
3026 | } | ||
3027 | // $ANTLR end "ruleALSNumericOperator" | ||
3028 | |||
3029 | |||
3030 | // $ANTLR start "rule__ALSDocument__Alternatives_0" | ||
3031 | // InternalAlloyLanguage.g:1027: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 ) ) ); | ||
3032 | public final void rule__ALSDocument__Alternatives_0() throws RecognitionException { | ||
3033 | |||
3034 | int stackSize = keepStackSize(); | ||
3035 | |||
3036 | try { | ||
3037 | // InternalAlloyLanguage.g:1031: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 ) ) ) | ||
3038 | int alt1=5; | ||
3039 | switch ( input.LA(1) ) { | ||
3040 | case 32: | ||
3041 | { | ||
3042 | alt1=1; | ||
3043 | } | ||
3044 | break; | ||
3045 | case 21: | ||
3046 | case 22: | ||
3047 | case 23: | ||
3048 | case 24: | ||
3049 | case 25: | ||
3050 | case 26: | ||
3051 | case 36: | ||
3052 | case 73: | ||
3053 | { | ||
3054 | alt1=2; | ||
3055 | } | ||
3056 | break; | ||
3057 | case 41: | ||
3058 | { | ||
3059 | alt1=3; | ||
3060 | } | ||
3061 | break; | ||
3062 | case 44: | ||
3063 | { | ||
3064 | alt1=4; | ||
3065 | } | ||
3066 | break; | ||
3067 | case 45: | ||
3068 | { | ||
3069 | alt1=5; | ||
3070 | } | ||
3071 | break; | ||
3072 | default: | ||
3073 | if (state.backtracking>0) {state.failed=true; return ;} | ||
3074 | NoViableAltException nvae = | ||
3075 | new NoViableAltException("", 1, 0, input); | ||
3076 | |||
3077 | throw nvae; | ||
3078 | } | ||
3079 | |||
3080 | switch (alt1) { | ||
3081 | case 1 : | ||
3082 | // InternalAlloyLanguage.g:1032:1: ( ( rule__ALSDocument__EnumDeclarationsAssignment_0_0 ) ) | ||
3083 | { | ||
3084 | // InternalAlloyLanguage.g:1032:1: ( ( rule__ALSDocument__EnumDeclarationsAssignment_0_0 ) ) | ||
3085 | // InternalAlloyLanguage.g:1033:1: ( rule__ALSDocument__EnumDeclarationsAssignment_0_0 ) | ||
3086 | { | ||
3087 | if ( state.backtracking==0 ) { | ||
3088 | before(grammarAccess.getALSDocumentAccess().getEnumDeclarationsAssignment_0_0()); | ||
3089 | } | ||
3090 | // InternalAlloyLanguage.g:1034:1: ( rule__ALSDocument__EnumDeclarationsAssignment_0_0 ) | ||
3091 | // InternalAlloyLanguage.g:1034:2: rule__ALSDocument__EnumDeclarationsAssignment_0_0 | ||
3092 | { | ||
3093 | pushFollow(FOLLOW_2); | ||
3094 | rule__ALSDocument__EnumDeclarationsAssignment_0_0(); | ||
3095 | |||
3096 | state._fsp--; | ||
3097 | if (state.failed) return ; | ||
3098 | |||
3099 | } | ||
3100 | |||
3101 | if ( state.backtracking==0 ) { | ||
3102 | after(grammarAccess.getALSDocumentAccess().getEnumDeclarationsAssignment_0_0()); | ||
3103 | } | ||
3104 | |||
3105 | } | ||
3106 | |||
3107 | |||
3108 | } | ||
3109 | break; | ||
3110 | case 2 : | ||
3111 | // InternalAlloyLanguage.g:1038:6: ( ( rule__ALSDocument__SignatureBodiesAssignment_0_1 ) ) | ||
3112 | { | ||
3113 | // InternalAlloyLanguage.g:1038:6: ( ( rule__ALSDocument__SignatureBodiesAssignment_0_1 ) ) | ||
3114 | // InternalAlloyLanguage.g:1039:1: ( rule__ALSDocument__SignatureBodiesAssignment_0_1 ) | ||
3115 | { | ||
3116 | if ( state.backtracking==0 ) { | ||
3117 | before(grammarAccess.getALSDocumentAccess().getSignatureBodiesAssignment_0_1()); | ||
3118 | } | ||
3119 | // InternalAlloyLanguage.g:1040:1: ( rule__ALSDocument__SignatureBodiesAssignment_0_1 ) | ||
3120 | // InternalAlloyLanguage.g:1040:2: rule__ALSDocument__SignatureBodiesAssignment_0_1 | ||
3121 | { | ||
3122 | pushFollow(FOLLOW_2); | ||
3123 | rule__ALSDocument__SignatureBodiesAssignment_0_1(); | ||
3124 | |||
3125 | state._fsp--; | ||
3126 | if (state.failed) return ; | ||
3127 | |||
3128 | } | ||
3129 | |||
3130 | if ( state.backtracking==0 ) { | ||
3131 | after(grammarAccess.getALSDocumentAccess().getSignatureBodiesAssignment_0_1()); | ||
3132 | } | ||
3133 | |||
3134 | } | ||
3135 | |||
3136 | |||
3137 | } | ||
3138 | break; | ||
3139 | case 3 : | ||
3140 | // InternalAlloyLanguage.g:1044:6: ( ( rule__ALSDocument__FunctionDefinitionsAssignment_0_2 ) ) | ||
3141 | { | ||
3142 | // InternalAlloyLanguage.g:1044:6: ( ( rule__ALSDocument__FunctionDefinitionsAssignment_0_2 ) ) | ||
3143 | // InternalAlloyLanguage.g:1045:1: ( rule__ALSDocument__FunctionDefinitionsAssignment_0_2 ) | ||
3144 | { | ||
3145 | if ( state.backtracking==0 ) { | ||
3146 | before(grammarAccess.getALSDocumentAccess().getFunctionDefinitionsAssignment_0_2()); | ||
3147 | } | ||
3148 | // InternalAlloyLanguage.g:1046:1: ( rule__ALSDocument__FunctionDefinitionsAssignment_0_2 ) | ||
3149 | // InternalAlloyLanguage.g:1046:2: rule__ALSDocument__FunctionDefinitionsAssignment_0_2 | ||
3150 | { | ||
3151 | pushFollow(FOLLOW_2); | ||
3152 | rule__ALSDocument__FunctionDefinitionsAssignment_0_2(); | ||
3153 | |||
3154 | state._fsp--; | ||
3155 | if (state.failed) return ; | ||
3156 | |||
3157 | } | ||
3158 | |||
3159 | if ( state.backtracking==0 ) { | ||
3160 | after(grammarAccess.getALSDocumentAccess().getFunctionDefinitionsAssignment_0_2()); | ||
3161 | } | ||
3162 | |||
3163 | } | ||
3164 | |||
3165 | |||
3166 | } | ||
3167 | break; | ||
3168 | case 4 : | ||
3169 | // InternalAlloyLanguage.g:1050:6: ( ( rule__ALSDocument__RelationDefinitionsAssignment_0_3 ) ) | ||
3170 | { | ||
3171 | // InternalAlloyLanguage.g:1050:6: ( ( rule__ALSDocument__RelationDefinitionsAssignment_0_3 ) ) | ||
3172 | // InternalAlloyLanguage.g:1051:1: ( rule__ALSDocument__RelationDefinitionsAssignment_0_3 ) | ||
3173 | { | ||
3174 | if ( state.backtracking==0 ) { | ||
3175 | before(grammarAccess.getALSDocumentAccess().getRelationDefinitionsAssignment_0_3()); | ||
3176 | } | ||
3177 | // InternalAlloyLanguage.g:1052:1: ( rule__ALSDocument__RelationDefinitionsAssignment_0_3 ) | ||
3178 | // InternalAlloyLanguage.g:1052:2: rule__ALSDocument__RelationDefinitionsAssignment_0_3 | ||
3179 | { | ||
3180 | pushFollow(FOLLOW_2); | ||
3181 | rule__ALSDocument__RelationDefinitionsAssignment_0_3(); | ||
3182 | |||
3183 | state._fsp--; | ||
3184 | if (state.failed) return ; | ||
3185 | |||
3186 | } | ||
3187 | |||
3188 | if ( state.backtracking==0 ) { | ||
3189 | after(grammarAccess.getALSDocumentAccess().getRelationDefinitionsAssignment_0_3()); | ||
3190 | } | ||
3191 | |||
3192 | } | ||
3193 | |||
3194 | |||
3195 | } | ||
3196 | break; | ||
3197 | case 5 : | ||
3198 | // InternalAlloyLanguage.g:1056:6: ( ( rule__ALSDocument__FactDeclarationsAssignment_0_4 ) ) | ||
3199 | { | ||
3200 | // InternalAlloyLanguage.g:1056:6: ( ( rule__ALSDocument__FactDeclarationsAssignment_0_4 ) ) | ||
3201 | // InternalAlloyLanguage.g:1057:1: ( rule__ALSDocument__FactDeclarationsAssignment_0_4 ) | ||
3202 | { | ||
3203 | if ( state.backtracking==0 ) { | ||
3204 | before(grammarAccess.getALSDocumentAccess().getFactDeclarationsAssignment_0_4()); | ||
3205 | } | ||
3206 | // InternalAlloyLanguage.g:1058:1: ( rule__ALSDocument__FactDeclarationsAssignment_0_4 ) | ||
3207 | // InternalAlloyLanguage.g:1058:2: rule__ALSDocument__FactDeclarationsAssignment_0_4 | ||
3208 | { | ||
3209 | pushFollow(FOLLOW_2); | ||
3210 | rule__ALSDocument__FactDeclarationsAssignment_0_4(); | ||
3211 | |||
3212 | state._fsp--; | ||
3213 | if (state.failed) return ; | ||
3214 | |||
3215 | } | ||
3216 | |||
3217 | if ( state.backtracking==0 ) { | ||
3218 | after(grammarAccess.getALSDocumentAccess().getFactDeclarationsAssignment_0_4()); | ||
3219 | } | ||
3220 | |||
3221 | } | ||
3222 | |||
3223 | |||
3224 | } | ||
3225 | break; | ||
3226 | |||
3227 | } | ||
3228 | } | ||
3229 | catch (RecognitionException re) { | ||
3230 | reportError(re); | ||
3231 | recover(input,re); | ||
3232 | } | ||
3233 | finally { | ||
3234 | |||
3235 | restoreStackSize(stackSize); | ||
3236 | |||
3237 | } | ||
3238 | return ; | ||
3239 | } | ||
3240 | // $ANTLR end "rule__ALSDocument__Alternatives_0" | ||
3241 | |||
3242 | |||
3243 | // $ANTLR start "rule__ALSTypeDeclaration__Alternatives" | ||
3244 | // InternalAlloyLanguage.g:1068:1: rule__ALSTypeDeclaration__Alternatives : ( ( ruleALSEnumDeclaration ) | ( ruleALSSignatureDeclaration ) ); | ||
3245 | public final void rule__ALSTypeDeclaration__Alternatives() throws RecognitionException { | ||
3246 | |||
3247 | int stackSize = keepStackSize(); | ||
3248 | |||
3249 | try { | ||
3250 | // InternalAlloyLanguage.g:1072:1: ( ( ruleALSEnumDeclaration ) | ( ruleALSSignatureDeclaration ) ) | ||
3251 | int alt2=2; | ||
3252 | int LA2_0 = input.LA(1); | ||
3253 | |||
3254 | if ( (LA2_0==32) ) { | ||
3255 | alt2=1; | ||
3256 | } | ||
3257 | else if ( (LA2_0==RULE_ID) ) { | ||
3258 | alt2=2; | ||
3259 | } | ||
3260 | else { | ||
3261 | if (state.backtracking>0) {state.failed=true; return ;} | ||
3262 | NoViableAltException nvae = | ||
3263 | new NoViableAltException("", 2, 0, input); | ||
3264 | |||
3265 | throw nvae; | ||
3266 | } | ||
3267 | switch (alt2) { | ||
3268 | case 1 : | ||
3269 | // InternalAlloyLanguage.g:1073:1: ( ruleALSEnumDeclaration ) | ||
3270 | { | ||
3271 | // InternalAlloyLanguage.g:1073:1: ( ruleALSEnumDeclaration ) | ||
3272 | // InternalAlloyLanguage.g:1074:1: ruleALSEnumDeclaration | ||
3273 | { | ||
3274 | if ( state.backtracking==0 ) { | ||
3275 | before(grammarAccess.getALSTypeDeclarationAccess().getALSEnumDeclarationParserRuleCall_0()); | ||
3276 | } | ||
3277 | pushFollow(FOLLOW_2); | ||
3278 | ruleALSEnumDeclaration(); | ||
3279 | |||
3280 | state._fsp--; | ||
3281 | if (state.failed) return ; | ||
3282 | if ( state.backtracking==0 ) { | ||
3283 | after(grammarAccess.getALSTypeDeclarationAccess().getALSEnumDeclarationParserRuleCall_0()); | ||
3284 | } | ||
3285 | |||
3286 | } | ||
3287 | |||
3288 | |||
3289 | } | ||
3290 | break; | ||
3291 | case 2 : | ||
3292 | // InternalAlloyLanguage.g:1079:6: ( ruleALSSignatureDeclaration ) | ||
3293 | { | ||
3294 | // InternalAlloyLanguage.g:1079:6: ( ruleALSSignatureDeclaration ) | ||
3295 | // InternalAlloyLanguage.g:1080:1: ruleALSSignatureDeclaration | ||
3296 | { | ||
3297 | if ( state.backtracking==0 ) { | ||
3298 | before(grammarAccess.getALSTypeDeclarationAccess().getALSSignatureDeclarationParserRuleCall_1()); | ||
3299 | } | ||
3300 | pushFollow(FOLLOW_2); | ||
3301 | ruleALSSignatureDeclaration(); | ||
3302 | |||
3303 | state._fsp--; | ||
3304 | if (state.failed) return ; | ||
3305 | if ( state.backtracking==0 ) { | ||
3306 | after(grammarAccess.getALSTypeDeclarationAccess().getALSSignatureDeclarationParserRuleCall_1()); | ||
3307 | } | ||
3308 | |||
3309 | } | ||
3310 | |||
3311 | |||
3312 | } | ||
3313 | break; | ||
3314 | |||
3315 | } | ||
3316 | } | ||
3317 | catch (RecognitionException re) { | ||
3318 | reportError(re); | ||
3319 | recover(input,re); | ||
3320 | } | ||
3321 | finally { | ||
3322 | |||
3323 | restoreStackSize(stackSize); | ||
3324 | |||
3325 | } | ||
3326 | return ; | ||
3327 | } | ||
3328 | // $ANTLR end "rule__ALSTypeDeclaration__Alternatives" | ||
3329 | |||
3330 | |||
3331 | // $ANTLR start "rule__ALSSignatureBody__Alternatives_4" | ||
3332 | // InternalAlloyLanguage.g:1090:1: rule__ALSSignatureBody__Alternatives_4 : ( ( ( rule__ALSSignatureBody__Group_4_0__0 ) ) | ( ( rule__ALSSignatureBody__Group_4_1__0 ) ) ); | ||
3333 | public final void rule__ALSSignatureBody__Alternatives_4() throws RecognitionException { | ||
3334 | |||
3335 | int stackSize = keepStackSize(); | ||
3336 | |||
3337 | try { | ||
3338 | // InternalAlloyLanguage.g:1094:1: ( ( ( rule__ALSSignatureBody__Group_4_0__0 ) ) | ( ( rule__ALSSignatureBody__Group_4_1__0 ) ) ) | ||
3339 | int alt3=2; | ||
3340 | int LA3_0 = input.LA(1); | ||
3341 | |||
3342 | if ( (LA3_0==37) ) { | ||
3343 | alt3=1; | ||
3344 | } | ||
3345 | else if ( (LA3_0==38) ) { | ||
3346 | alt3=2; | ||
3347 | } | ||
3348 | else { | ||
3349 | if (state.backtracking>0) {state.failed=true; return ;} | ||
3350 | NoViableAltException nvae = | ||
3351 | new NoViableAltException("", 3, 0, input); | ||
3352 | |||
3353 | throw nvae; | ||
3354 | } | ||
3355 | switch (alt3) { | ||
3356 | case 1 : | ||
3357 | // InternalAlloyLanguage.g:1095:1: ( ( rule__ALSSignatureBody__Group_4_0__0 ) ) | ||
3358 | { | ||
3359 | // InternalAlloyLanguage.g:1095:1: ( ( rule__ALSSignatureBody__Group_4_0__0 ) ) | ||
3360 | // InternalAlloyLanguage.g:1096:1: ( rule__ALSSignatureBody__Group_4_0__0 ) | ||
3361 | { | ||
3362 | if ( state.backtracking==0 ) { | ||
3363 | before(grammarAccess.getALSSignatureBodyAccess().getGroup_4_0()); | ||
3364 | } | ||
3365 | // InternalAlloyLanguage.g:1097:1: ( rule__ALSSignatureBody__Group_4_0__0 ) | ||
3366 | // InternalAlloyLanguage.g:1097:2: rule__ALSSignatureBody__Group_4_0__0 | ||
3367 | { | ||
3368 | pushFollow(FOLLOW_2); | ||
3369 | rule__ALSSignatureBody__Group_4_0__0(); | ||
3370 | |||
3371 | state._fsp--; | ||
3372 | if (state.failed) return ; | ||
3373 | |||
3374 | } | ||
3375 | |||
3376 | if ( state.backtracking==0 ) { | ||
3377 | after(grammarAccess.getALSSignatureBodyAccess().getGroup_4_0()); | ||
3378 | } | ||
3379 | |||
3380 | } | ||
3381 | |||
3382 | |||
3383 | } | ||
3384 | break; | ||
3385 | case 2 : | ||
3386 | // InternalAlloyLanguage.g:1101:6: ( ( rule__ALSSignatureBody__Group_4_1__0 ) ) | ||
3387 | { | ||
3388 | // InternalAlloyLanguage.g:1101:6: ( ( rule__ALSSignatureBody__Group_4_1__0 ) ) | ||
3389 | // InternalAlloyLanguage.g:1102:1: ( rule__ALSSignatureBody__Group_4_1__0 ) | ||
3390 | { | ||
3391 | if ( state.backtracking==0 ) { | ||
3392 | before(grammarAccess.getALSSignatureBodyAccess().getGroup_4_1()); | ||
3393 | } | ||
3394 | // InternalAlloyLanguage.g:1103:1: ( rule__ALSSignatureBody__Group_4_1__0 ) | ||
3395 | // InternalAlloyLanguage.g:1103:2: rule__ALSSignatureBody__Group_4_1__0 | ||
3396 | { | ||
3397 | pushFollow(FOLLOW_2); | ||
3398 | rule__ALSSignatureBody__Group_4_1__0(); | ||
3399 | |||
3400 | state._fsp--; | ||
3401 | if (state.failed) return ; | ||
3402 | |||
3403 | } | ||
3404 | |||
3405 | if ( state.backtracking==0 ) { | ||
3406 | after(grammarAccess.getALSSignatureBodyAccess().getGroup_4_1()); | ||
3407 | } | ||
3408 | |||
3409 | } | ||
3410 | |||
3411 | |||
3412 | } | ||
3413 | break; | ||
3414 | |||
3415 | } | ||
3416 | } | ||
3417 | catch (RecognitionException re) { | ||
3418 | reportError(re); | ||
3419 | recover(input,re); | ||
3420 | } | ||
3421 | finally { | ||
3422 | |||
3423 | restoreStackSize(stackSize); | ||
3424 | |||
3425 | } | ||
3426 | return ; | ||
3427 | } | ||
3428 | // $ANTLR end "rule__ALSSignatureBody__Alternatives_4" | ||
3429 | |||
3430 | |||
3431 | // $ANTLR start "rule__ALSQuantified__Alternatives" | ||
3432 | // InternalAlloyLanguage.g:1113:1: rule__ALSQuantified__Alternatives : ( ( ( rule__ALSQuantified__Group_0__0 ) ) | ( ruleALSOr ) ); | ||
3433 | public final void rule__ALSQuantified__Alternatives() throws RecognitionException { | ||
3434 | |||
3435 | int stackSize = keepStackSize(); | ||
3436 | |||
3437 | try { | ||
3438 | // InternalAlloyLanguage.g:1117:1: ( ( ( rule__ALSQuantified__Group_0__0 ) ) | ( ruleALSOr ) ) | ||
3439 | int alt4=2; | ||
3440 | int LA4_0 = input.LA(1); | ||
3441 | |||
3442 | if ( ((LA4_0>=21 && LA4_0<=26)) ) { | ||
3443 | alt4=1; | ||
3444 | } | ||
3445 | else if ( ((LA4_0>=RULE_ID && LA4_0<=RULE_INT)||(LA4_0>=19 && LA4_0<=20)||(LA4_0>=27 && LA4_0<=31)||LA4_0==57||(LA4_0>=60 && LA4_0<=69)) ) { | ||
3446 | alt4=2; | ||
3447 | } | ||
3448 | else { | ||
3449 | if (state.backtracking>0) {state.failed=true; return ;} | ||
3450 | NoViableAltException nvae = | ||
3451 | new NoViableAltException("", 4, 0, input); | ||
3452 | |||
3453 | throw nvae; | ||
3454 | } | ||
3455 | switch (alt4) { | ||
3456 | case 1 : | ||
3457 | // InternalAlloyLanguage.g:1118:1: ( ( rule__ALSQuantified__Group_0__0 ) ) | ||
3458 | { | ||
3459 | // InternalAlloyLanguage.g:1118:1: ( ( rule__ALSQuantified__Group_0__0 ) ) | ||
3460 | // InternalAlloyLanguage.g:1119:1: ( rule__ALSQuantified__Group_0__0 ) | ||
3461 | { | ||
3462 | if ( state.backtracking==0 ) { | ||
3463 | before(grammarAccess.getALSQuantifiedAccess().getGroup_0()); | ||
3464 | } | ||
3465 | // InternalAlloyLanguage.g:1120:1: ( rule__ALSQuantified__Group_0__0 ) | ||
3466 | // InternalAlloyLanguage.g:1120:2: rule__ALSQuantified__Group_0__0 | ||
3467 | { | ||
3468 | pushFollow(FOLLOW_2); | ||
3469 | rule__ALSQuantified__Group_0__0(); | ||
3470 | |||
3471 | state._fsp--; | ||
3472 | if (state.failed) return ; | ||
3473 | |||
3474 | } | ||
3475 | |||
3476 | if ( state.backtracking==0 ) { | ||
3477 | after(grammarAccess.getALSQuantifiedAccess().getGroup_0()); | ||
3478 | } | ||
3479 | |||
3480 | } | ||
3481 | |||
3482 | |||
3483 | } | ||
3484 | break; | ||
3485 | case 2 : | ||
3486 | // InternalAlloyLanguage.g:1124:6: ( ruleALSOr ) | ||
3487 | { | ||
3488 | // InternalAlloyLanguage.g:1124:6: ( ruleALSOr ) | ||
3489 | // InternalAlloyLanguage.g:1125:1: ruleALSOr | ||
3490 | { | ||
3491 | if ( state.backtracking==0 ) { | ||
3492 | before(grammarAccess.getALSQuantifiedAccess().getALSOrParserRuleCall_1()); | ||
3493 | } | ||
3494 | pushFollow(FOLLOW_2); | ||
3495 | ruleALSOr(); | ||
3496 | |||
3497 | state._fsp--; | ||
3498 | if (state.failed) return ; | ||
3499 | if ( state.backtracking==0 ) { | ||
3500 | after(grammarAccess.getALSQuantifiedAccess().getALSOrParserRuleCall_1()); | ||
3501 | } | ||
3502 | |||
3503 | } | ||
3504 | |||
3505 | |||
3506 | } | ||
3507 | break; | ||
3508 | |||
3509 | } | ||
3510 | } | ||
3511 | catch (RecognitionException re) { | ||
3512 | reportError(re); | ||
3513 | recover(input,re); | ||
3514 | } | ||
3515 | finally { | ||
3516 | |||
3517 | restoreStackSize(stackSize); | ||
3518 | |||
3519 | } | ||
3520 | return ; | ||
3521 | } | ||
3522 | // $ANTLR end "rule__ALSQuantified__Alternatives" | ||
3523 | |||
3524 | |||
3525 | // $ANTLR start "rule__ALSOr__Alternatives_1_1" | ||
3526 | // InternalAlloyLanguage.g:1135:1: rule__ALSOr__Alternatives_1_1 : ( ( '||' ) | ( 'or' ) ); | ||
3527 | public final void rule__ALSOr__Alternatives_1_1() throws RecognitionException { | ||
3528 | |||
3529 | int stackSize = keepStackSize(); | ||
3530 | |||
3531 | try { | ||
3532 | // InternalAlloyLanguage.g:1139:1: ( ( '||' ) | ( 'or' ) ) | ||
3533 | int alt5=2; | ||
3534 | int LA5_0 = input.LA(1); | ||
3535 | |||
3536 | if ( (LA5_0==11) ) { | ||
3537 | alt5=1; | ||
3538 | } | ||
3539 | else if ( (LA5_0==12) ) { | ||
3540 | alt5=2; | ||
3541 | } | ||
3542 | else { | ||
3543 | if (state.backtracking>0) {state.failed=true; return ;} | ||
3544 | NoViableAltException nvae = | ||
3545 | new NoViableAltException("", 5, 0, input); | ||
3546 | |||
3547 | throw nvae; | ||
3548 | } | ||
3549 | switch (alt5) { | ||
3550 | case 1 : | ||
3551 | // InternalAlloyLanguage.g:1140:1: ( '||' ) | ||
3552 | { | ||
3553 | // InternalAlloyLanguage.g:1140:1: ( '||' ) | ||
3554 | // InternalAlloyLanguage.g:1141:1: '||' | ||
3555 | { | ||
3556 | if ( state.backtracking==0 ) { | ||
3557 | before(grammarAccess.getALSOrAccess().getVerticalLineVerticalLineKeyword_1_1_0()); | ||
3558 | } | ||
3559 | match(input,11,FOLLOW_2); if (state.failed) return ; | ||
3560 | if ( state.backtracking==0 ) { | ||
3561 | after(grammarAccess.getALSOrAccess().getVerticalLineVerticalLineKeyword_1_1_0()); | ||
3562 | } | ||
3563 | |||
3564 | } | ||
3565 | |||
3566 | |||
3567 | } | ||
3568 | break; | ||
3569 | case 2 : | ||
3570 | // InternalAlloyLanguage.g:1148:6: ( 'or' ) | ||
3571 | { | ||
3572 | // InternalAlloyLanguage.g:1148:6: ( 'or' ) | ||
3573 | // InternalAlloyLanguage.g:1149:1: 'or' | ||
3574 | { | ||
3575 | if ( state.backtracking==0 ) { | ||
3576 | before(grammarAccess.getALSOrAccess().getOrKeyword_1_1_1()); | ||
3577 | } | ||
3578 | match(input,12,FOLLOW_2); if (state.failed) return ; | ||
3579 | if ( state.backtracking==0 ) { | ||
3580 | after(grammarAccess.getALSOrAccess().getOrKeyword_1_1_1()); | ||
3581 | } | ||
3582 | |||
3583 | } | ||
3584 | |||
3585 | |||
3586 | } | ||
3587 | break; | ||
3588 | |||
3589 | } | ||
3590 | } | ||
3591 | catch (RecognitionException re) { | ||
3592 | reportError(re); | ||
3593 | recover(input,re); | ||
3594 | } | ||
3595 | finally { | ||
3596 | |||
3597 | restoreStackSize(stackSize); | ||
3598 | |||
3599 | } | ||
3600 | return ; | ||
3601 | } | ||
3602 | // $ANTLR end "rule__ALSOr__Alternatives_1_1" | ||
3603 | |||
3604 | |||
3605 | // $ANTLR start "rule__ALSIff__Alternatives_1_1" | ||
3606 | // InternalAlloyLanguage.g:1161:1: rule__ALSIff__Alternatives_1_1 : ( ( '<=>' ) | ( 'iff' ) ); | ||
3607 | public final void rule__ALSIff__Alternatives_1_1() throws RecognitionException { | ||
3608 | |||
3609 | int stackSize = keepStackSize(); | ||
3610 | |||
3611 | try { | ||
3612 | // InternalAlloyLanguage.g:1165:1: ( ( '<=>' ) | ( 'iff' ) ) | ||
3613 | int alt6=2; | ||
3614 | int LA6_0 = input.LA(1); | ||
3615 | |||
3616 | if ( (LA6_0==13) ) { | ||
3617 | alt6=1; | ||
3618 | } | ||
3619 | else if ( (LA6_0==14) ) { | ||
3620 | alt6=2; | ||
3621 | } | ||
3622 | else { | ||
3623 | if (state.backtracking>0) {state.failed=true; return ;} | ||
3624 | NoViableAltException nvae = | ||
3625 | new NoViableAltException("", 6, 0, input); | ||
3626 | |||
3627 | throw nvae; | ||
3628 | } | ||
3629 | switch (alt6) { | ||
3630 | case 1 : | ||
3631 | // InternalAlloyLanguage.g:1166:1: ( '<=>' ) | ||
3632 | { | ||
3633 | // InternalAlloyLanguage.g:1166:1: ( '<=>' ) | ||
3634 | // InternalAlloyLanguage.g:1167:1: '<=>' | ||
3635 | { | ||
3636 | if ( state.backtracking==0 ) { | ||
3637 | before(grammarAccess.getALSIffAccess().getLessThanSignEqualsSignGreaterThanSignKeyword_1_1_0()); | ||
3638 | } | ||
3639 | match(input,13,FOLLOW_2); if (state.failed) return ; | ||
3640 | if ( state.backtracking==0 ) { | ||
3641 | after(grammarAccess.getALSIffAccess().getLessThanSignEqualsSignGreaterThanSignKeyword_1_1_0()); | ||
3642 | } | ||
3643 | |||
3644 | } | ||
3645 | |||
3646 | |||
3647 | } | ||
3648 | break; | ||
3649 | case 2 : | ||
3650 | // InternalAlloyLanguage.g:1174:6: ( 'iff' ) | ||
3651 | { | ||
3652 | // InternalAlloyLanguage.g:1174:6: ( 'iff' ) | ||
3653 | // InternalAlloyLanguage.g:1175:1: 'iff' | ||
3654 | { | ||
3655 | if ( state.backtracking==0 ) { | ||
3656 | before(grammarAccess.getALSIffAccess().getIffKeyword_1_1_1()); | ||
3657 | } | ||
3658 | match(input,14,FOLLOW_2); if (state.failed) return ; | ||
3659 | if ( state.backtracking==0 ) { | ||
3660 | after(grammarAccess.getALSIffAccess().getIffKeyword_1_1_1()); | ||
3661 | } | ||
3662 | |||
3663 | } | ||
3664 | |||
3665 | |||
3666 | } | ||
3667 | break; | ||
3668 | |||
3669 | } | ||
3670 | } | ||
3671 | catch (RecognitionException re) { | ||
3672 | reportError(re); | ||
3673 | recover(input,re); | ||
3674 | } | ||
3675 | finally { | ||
3676 | |||
3677 | restoreStackSize(stackSize); | ||
3678 | |||
3679 | } | ||
3680 | return ; | ||
3681 | } | ||
3682 | // $ANTLR end "rule__ALSIff__Alternatives_1_1" | ||
3683 | |||
3684 | |||
3685 | // $ANTLR start "rule__ALSImpl__Alternatives_1_1" | ||
3686 | // InternalAlloyLanguage.g:1187:1: rule__ALSImpl__Alternatives_1_1 : ( ( '=>' ) | ( 'implies' ) ); | ||
3687 | public final void rule__ALSImpl__Alternatives_1_1() throws RecognitionException { | ||
3688 | |||
3689 | int stackSize = keepStackSize(); | ||
3690 | |||
3691 | try { | ||
3692 | // InternalAlloyLanguage.g:1191:1: ( ( '=>' ) | ( 'implies' ) ) | ||
3693 | int alt7=2; | ||
3694 | int LA7_0 = input.LA(1); | ||
3695 | |||
3696 | if ( (LA7_0==15) ) { | ||
3697 | alt7=1; | ||
3698 | } | ||
3699 | else if ( (LA7_0==16) ) { | ||
3700 | alt7=2; | ||
3701 | } | ||
3702 | else { | ||
3703 | if (state.backtracking>0) {state.failed=true; return ;} | ||
3704 | NoViableAltException nvae = | ||
3705 | new NoViableAltException("", 7, 0, input); | ||
3706 | |||
3707 | throw nvae; | ||
3708 | } | ||
3709 | switch (alt7) { | ||
3710 | case 1 : | ||
3711 | // InternalAlloyLanguage.g:1192:1: ( '=>' ) | ||
3712 | { | ||
3713 | // InternalAlloyLanguage.g:1192:1: ( '=>' ) | ||
3714 | // InternalAlloyLanguage.g:1193:1: '=>' | ||
3715 | { | ||
3716 | if ( state.backtracking==0 ) { | ||
3717 | before(grammarAccess.getALSImplAccess().getEqualsSignGreaterThanSignKeyword_1_1_0()); | ||
3718 | } | ||
3719 | match(input,15,FOLLOW_2); if (state.failed) return ; | ||
3720 | if ( state.backtracking==0 ) { | ||
3721 | after(grammarAccess.getALSImplAccess().getEqualsSignGreaterThanSignKeyword_1_1_0()); | ||
3722 | } | ||
3723 | |||
3724 | } | ||
3725 | |||
3726 | |||
3727 | } | ||
3728 | break; | ||
3729 | case 2 : | ||
3730 | // InternalAlloyLanguage.g:1200:6: ( 'implies' ) | ||
3731 | { | ||
3732 | // InternalAlloyLanguage.g:1200:6: ( 'implies' ) | ||
3733 | // InternalAlloyLanguage.g:1201:1: 'implies' | ||
3734 | { | ||
3735 | if ( state.backtracking==0 ) { | ||
3736 | before(grammarAccess.getALSImplAccess().getImpliesKeyword_1_1_1()); | ||
3737 | } | ||
3738 | match(input,16,FOLLOW_2); if (state.failed) return ; | ||
3739 | if ( state.backtracking==0 ) { | ||
3740 | after(grammarAccess.getALSImplAccess().getImpliesKeyword_1_1_1()); | ||
3741 | } | ||
3742 | |||
3743 | } | ||
3744 | |||
3745 | |||
3746 | } | ||
3747 | break; | ||
3748 | |||
3749 | } | ||
3750 | } | ||
3751 | catch (RecognitionException re) { | ||
3752 | reportError(re); | ||
3753 | recover(input,re); | ||
3754 | } | ||
3755 | finally { | ||
3756 | |||
3757 | restoreStackSize(stackSize); | ||
3758 | |||
3759 | } | ||
3760 | return ; | ||
3761 | } | ||
3762 | // $ANTLR end "rule__ALSImpl__Alternatives_1_1" | ||
3763 | |||
3764 | |||
3765 | // $ANTLR start "rule__ALSAnd__Alternatives_1_1" | ||
3766 | // InternalAlloyLanguage.g:1213:1: rule__ALSAnd__Alternatives_1_1 : ( ( '&&' ) | ( 'and' ) ); | ||
3767 | public final void rule__ALSAnd__Alternatives_1_1() throws RecognitionException { | ||
3768 | |||
3769 | int stackSize = keepStackSize(); | ||
3770 | |||
3771 | try { | ||
3772 | // InternalAlloyLanguage.g:1217:1: ( ( '&&' ) | ( 'and' ) ) | ||
3773 | int alt8=2; | ||
3774 | int LA8_0 = input.LA(1); | ||
3775 | |||
3776 | if ( (LA8_0==17) ) { | ||
3777 | alt8=1; | ||
3778 | } | ||
3779 | else if ( (LA8_0==18) ) { | ||
3780 | alt8=2; | ||
3781 | } | ||
3782 | else { | ||
3783 | if (state.backtracking>0) {state.failed=true; return ;} | ||
3784 | NoViableAltException nvae = | ||
3785 | new NoViableAltException("", 8, 0, input); | ||
3786 | |||
3787 | throw nvae; | ||
3788 | } | ||
3789 | switch (alt8) { | ||
3790 | case 1 : | ||
3791 | // InternalAlloyLanguage.g:1218:1: ( '&&' ) | ||
3792 | { | ||
3793 | // InternalAlloyLanguage.g:1218:1: ( '&&' ) | ||
3794 | // InternalAlloyLanguage.g:1219:1: '&&' | ||
3795 | { | ||
3796 | if ( state.backtracking==0 ) { | ||
3797 | before(grammarAccess.getALSAndAccess().getAmpersandAmpersandKeyword_1_1_0()); | ||
3798 | } | ||
3799 | match(input,17,FOLLOW_2); if (state.failed) return ; | ||
3800 | if ( state.backtracking==0 ) { | ||
3801 | after(grammarAccess.getALSAndAccess().getAmpersandAmpersandKeyword_1_1_0()); | ||
3802 | } | ||
3803 | |||
3804 | } | ||
3805 | |||
3806 | |||
3807 | } | ||
3808 | break; | ||
3809 | case 2 : | ||
3810 | // InternalAlloyLanguage.g:1226:6: ( 'and' ) | ||
3811 | { | ||
3812 | // InternalAlloyLanguage.g:1226:6: ( 'and' ) | ||
3813 | // InternalAlloyLanguage.g:1227:1: 'and' | ||
3814 | { | ||
3815 | if ( state.backtracking==0 ) { | ||
3816 | before(grammarAccess.getALSAndAccess().getAndKeyword_1_1_1()); | ||
3817 | } | ||
3818 | match(input,18,FOLLOW_2); if (state.failed) return ; | ||
3819 | if ( state.backtracking==0 ) { | ||
3820 | after(grammarAccess.getALSAndAccess().getAndKeyword_1_1_1()); | ||
3821 | } | ||
3822 | |||
3823 | } | ||
3824 | |||
3825 | |||
3826 | } | ||
3827 | break; | ||
3828 | |||
3829 | } | ||
3830 | } | ||
3831 | catch (RecognitionException re) { | ||
3832 | reportError(re); | ||
3833 | recover(input,re); | ||
3834 | } | ||
3835 | finally { | ||
3836 | |||
3837 | restoreStackSize(stackSize); | ||
3838 | |||
3839 | } | ||
3840 | return ; | ||
3841 | } | ||
3842 | // $ANTLR end "rule__ALSAnd__Alternatives_1_1" | ||
3843 | |||
3844 | |||
3845 | // $ANTLR start "rule__ALSComparison__Alternatives_1_0" | ||
3846 | // InternalAlloyLanguage.g:1239: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 ) ) ); | ||
3847 | public final void rule__ALSComparison__Alternatives_1_0() throws RecognitionException { | ||
3848 | |||
3849 | int stackSize = keepStackSize(); | ||
3850 | |||
3851 | try { | ||
3852 | // InternalAlloyLanguage.g:1243: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 ) ) ) | ||
3853 | int alt9=7; | ||
3854 | switch ( input.LA(1) ) { | ||
3855 | case 47: | ||
3856 | { | ||
3857 | alt9=1; | ||
3858 | } | ||
3859 | break; | ||
3860 | case 48: | ||
3861 | { | ||
3862 | alt9=2; | ||
3863 | } | ||
3864 | break; | ||
3865 | case 38: | ||
3866 | { | ||
3867 | alt9=3; | ||
3868 | } | ||
3869 | break; | ||
3870 | case 49: | ||
3871 | { | ||
3872 | alt9=4; | ||
3873 | } | ||
3874 | break; | ||
3875 | case 50: | ||
3876 | { | ||
3877 | alt9=5; | ||
3878 | } | ||
3879 | break; | ||
3880 | case 51: | ||
3881 | { | ||
3882 | alt9=6; | ||
3883 | } | ||
3884 | break; | ||
3885 | case 52: | ||
3886 | { | ||
3887 | alt9=7; | ||
3888 | } | ||
3889 | break; | ||
3890 | default: | ||
3891 | if (state.backtracking>0) {state.failed=true; return ;} | ||
3892 | NoViableAltException nvae = | ||
3893 | new NoViableAltException("", 9, 0, input); | ||
3894 | |||
3895 | throw nvae; | ||
3896 | } | ||
3897 | |||
3898 | switch (alt9) { | ||
3899 | case 1 : | ||
3900 | // InternalAlloyLanguage.g:1244:1: ( ( rule__ALSComparison__Group_1_0_0__0 ) ) | ||
3901 | { | ||
3902 | // InternalAlloyLanguage.g:1244:1: ( ( rule__ALSComparison__Group_1_0_0__0 ) ) | ||
3903 | // InternalAlloyLanguage.g:1245:1: ( rule__ALSComparison__Group_1_0_0__0 ) | ||
3904 | { | ||
3905 | if ( state.backtracking==0 ) { | ||
3906 | before(grammarAccess.getALSComparisonAccess().getGroup_1_0_0()); | ||
3907 | } | ||
3908 | // InternalAlloyLanguage.g:1246:1: ( rule__ALSComparison__Group_1_0_0__0 ) | ||
3909 | // InternalAlloyLanguage.g:1246:2: rule__ALSComparison__Group_1_0_0__0 | ||
3910 | { | ||
3911 | pushFollow(FOLLOW_2); | ||
3912 | rule__ALSComparison__Group_1_0_0__0(); | ||
3913 | |||
3914 | state._fsp--; | ||
3915 | if (state.failed) return ; | ||
3916 | |||
3917 | } | ||
3918 | |||
3919 | if ( state.backtracking==0 ) { | ||
3920 | after(grammarAccess.getALSComparisonAccess().getGroup_1_0_0()); | ||
3921 | } | ||
3922 | |||
3923 | } | ||
3924 | |||
3925 | |||
3926 | } | ||
3927 | break; | ||
3928 | case 2 : | ||
3929 | // InternalAlloyLanguage.g:1250:6: ( ( rule__ALSComparison__Group_1_0_1__0 ) ) | ||
3930 | { | ||
3931 | // InternalAlloyLanguage.g:1250:6: ( ( rule__ALSComparison__Group_1_0_1__0 ) ) | ||
3932 | // InternalAlloyLanguage.g:1251:1: ( rule__ALSComparison__Group_1_0_1__0 ) | ||
3933 | { | ||
3934 | if ( state.backtracking==0 ) { | ||
3935 | before(grammarAccess.getALSComparisonAccess().getGroup_1_0_1()); | ||
3936 | } | ||
3937 | // InternalAlloyLanguage.g:1252:1: ( rule__ALSComparison__Group_1_0_1__0 ) | ||
3938 | // InternalAlloyLanguage.g:1252:2: rule__ALSComparison__Group_1_0_1__0 | ||
3939 | { | ||
3940 | pushFollow(FOLLOW_2); | ||
3941 | rule__ALSComparison__Group_1_0_1__0(); | ||
3942 | |||
3943 | state._fsp--; | ||
3944 | if (state.failed) return ; | ||
3945 | |||
3946 | } | ||
3947 | |||
3948 | if ( state.backtracking==0 ) { | ||
3949 | after(grammarAccess.getALSComparisonAccess().getGroup_1_0_1()); | ||
3950 | } | ||
3951 | |||
3952 | } | ||
3953 | |||
3954 | |||
3955 | } | ||
3956 | break; | ||
3957 | case 3 : | ||
3958 | // InternalAlloyLanguage.g:1256:6: ( ( rule__ALSComparison__Group_1_0_2__0 ) ) | ||
3959 | { | ||
3960 | // InternalAlloyLanguage.g:1256:6: ( ( rule__ALSComparison__Group_1_0_2__0 ) ) | ||
3961 | // InternalAlloyLanguage.g:1257:1: ( rule__ALSComparison__Group_1_0_2__0 ) | ||
3962 | { | ||
3963 | if ( state.backtracking==0 ) { | ||
3964 | before(grammarAccess.getALSComparisonAccess().getGroup_1_0_2()); | ||
3965 | } | ||
3966 | // InternalAlloyLanguage.g:1258:1: ( rule__ALSComparison__Group_1_0_2__0 ) | ||
3967 | // InternalAlloyLanguage.g:1258:2: rule__ALSComparison__Group_1_0_2__0 | ||
3968 | { | ||
3969 | pushFollow(FOLLOW_2); | ||
3970 | rule__ALSComparison__Group_1_0_2__0(); | ||
3971 | |||
3972 | state._fsp--; | ||
3973 | if (state.failed) return ; | ||
3974 | |||
3975 | } | ||
3976 | |||
3977 | if ( state.backtracking==0 ) { | ||
3978 | after(grammarAccess.getALSComparisonAccess().getGroup_1_0_2()); | ||
3979 | } | ||
3980 | |||
3981 | } | ||
3982 | |||
3983 | |||
3984 | } | ||
3985 | break; | ||
3986 | case 4 : | ||
3987 | // InternalAlloyLanguage.g:1262:6: ( ( rule__ALSComparison__Group_1_0_3__0 ) ) | ||
3988 | { | ||
3989 | // InternalAlloyLanguage.g:1262:6: ( ( rule__ALSComparison__Group_1_0_3__0 ) ) | ||
3990 | // InternalAlloyLanguage.g:1263:1: ( rule__ALSComparison__Group_1_0_3__0 ) | ||
3991 | { | ||
3992 | if ( state.backtracking==0 ) { | ||
3993 | before(grammarAccess.getALSComparisonAccess().getGroup_1_0_3()); | ||
3994 | } | ||
3995 | // InternalAlloyLanguage.g:1264:1: ( rule__ALSComparison__Group_1_0_3__0 ) | ||
3996 | // InternalAlloyLanguage.g:1264:2: rule__ALSComparison__Group_1_0_3__0 | ||
3997 | { | ||
3998 | pushFollow(FOLLOW_2); | ||
3999 | rule__ALSComparison__Group_1_0_3__0(); | ||
4000 | |||
4001 | state._fsp--; | ||
4002 | if (state.failed) return ; | ||
4003 | |||
4004 | } | ||
4005 | |||
4006 | if ( state.backtracking==0 ) { | ||
4007 | after(grammarAccess.getALSComparisonAccess().getGroup_1_0_3()); | ||
4008 | } | ||
4009 | |||
4010 | } | ||
4011 | |||
4012 | |||
4013 | } | ||
4014 | break; | ||
4015 | case 5 : | ||
4016 | // InternalAlloyLanguage.g:1268:6: ( ( rule__ALSComparison__Group_1_0_4__0 ) ) | ||
4017 | { | ||
4018 | // InternalAlloyLanguage.g:1268:6: ( ( rule__ALSComparison__Group_1_0_4__0 ) ) | ||
4019 | // InternalAlloyLanguage.g:1269:1: ( rule__ALSComparison__Group_1_0_4__0 ) | ||
4020 | { | ||
4021 | if ( state.backtracking==0 ) { | ||
4022 | before(grammarAccess.getALSComparisonAccess().getGroup_1_0_4()); | ||
4023 | } | ||
4024 | // InternalAlloyLanguage.g:1270:1: ( rule__ALSComparison__Group_1_0_4__0 ) | ||
4025 | // InternalAlloyLanguage.g:1270:2: rule__ALSComparison__Group_1_0_4__0 | ||
4026 | { | ||
4027 | pushFollow(FOLLOW_2); | ||
4028 | rule__ALSComparison__Group_1_0_4__0(); | ||
4029 | |||
4030 | state._fsp--; | ||
4031 | if (state.failed) return ; | ||
4032 | |||
4033 | } | ||
4034 | |||
4035 | if ( state.backtracking==0 ) { | ||
4036 | after(grammarAccess.getALSComparisonAccess().getGroup_1_0_4()); | ||
4037 | } | ||
4038 | |||
4039 | } | ||
4040 | |||
4041 | |||
4042 | } | ||
4043 | break; | ||
4044 | case 6 : | ||
4045 | // InternalAlloyLanguage.g:1274:6: ( ( rule__ALSComparison__Group_1_0_5__0 ) ) | ||
4046 | { | ||
4047 | // InternalAlloyLanguage.g:1274:6: ( ( rule__ALSComparison__Group_1_0_5__0 ) ) | ||
4048 | // InternalAlloyLanguage.g:1275:1: ( rule__ALSComparison__Group_1_0_5__0 ) | ||
4049 | { | ||
4050 | if ( state.backtracking==0 ) { | ||
4051 | before(grammarAccess.getALSComparisonAccess().getGroup_1_0_5()); | ||
4052 | } | ||
4053 | // InternalAlloyLanguage.g:1276:1: ( rule__ALSComparison__Group_1_0_5__0 ) | ||
4054 | // InternalAlloyLanguage.g:1276:2: rule__ALSComparison__Group_1_0_5__0 | ||
4055 | { | ||
4056 | pushFollow(FOLLOW_2); | ||
4057 | rule__ALSComparison__Group_1_0_5__0(); | ||
4058 | |||
4059 | state._fsp--; | ||
4060 | if (state.failed) return ; | ||
4061 | |||
4062 | } | ||
4063 | |||
4064 | if ( state.backtracking==0 ) { | ||
4065 | after(grammarAccess.getALSComparisonAccess().getGroup_1_0_5()); | ||
4066 | } | ||
4067 | |||
4068 | } | ||
4069 | |||
4070 | |||
4071 | } | ||
4072 | break; | ||
4073 | case 7 : | ||
4074 | // InternalAlloyLanguage.g:1280:6: ( ( rule__ALSComparison__Group_1_0_6__0 ) ) | ||
4075 | { | ||
4076 | // InternalAlloyLanguage.g:1280:6: ( ( rule__ALSComparison__Group_1_0_6__0 ) ) | ||
4077 | // InternalAlloyLanguage.g:1281:1: ( rule__ALSComparison__Group_1_0_6__0 ) | ||
4078 | { | ||
4079 | if ( state.backtracking==0 ) { | ||
4080 | before(grammarAccess.getALSComparisonAccess().getGroup_1_0_6()); | ||
4081 | } | ||
4082 | // InternalAlloyLanguage.g:1282:1: ( rule__ALSComparison__Group_1_0_6__0 ) | ||
4083 | // InternalAlloyLanguage.g:1282:2: rule__ALSComparison__Group_1_0_6__0 | ||
4084 | { | ||
4085 | pushFollow(FOLLOW_2); | ||
4086 | rule__ALSComparison__Group_1_0_6__0(); | ||
4087 | |||
4088 | state._fsp--; | ||
4089 | if (state.failed) return ; | ||
4090 | |||
4091 | } | ||
4092 | |||
4093 | if ( state.backtracking==0 ) { | ||
4094 | after(grammarAccess.getALSComparisonAccess().getGroup_1_0_6()); | ||
4095 | } | ||
4096 | |||
4097 | } | ||
4098 | |||
4099 | |||
4100 | } | ||
4101 | break; | ||
4102 | |||
4103 | } | ||
4104 | } | ||
4105 | catch (RecognitionException re) { | ||
4106 | reportError(re); | ||
4107 | recover(input,re); | ||
4108 | } | ||
4109 | finally { | ||
4110 | |||
4111 | restoreStackSize(stackSize); | ||
4112 | |||
4113 | } | ||
4114 | return ; | ||
4115 | } | ||
4116 | // $ANTLR end "rule__ALSComparison__Alternatives_1_0" | ||
4117 | |||
4118 | |||
4119 | // $ANTLR start "rule__ALSPreficed__Alternatives" | ||
4120 | // InternalAlloyLanguage.g:1291: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 ) ); | ||
4121 | public final void rule__ALSPreficed__Alternatives() throws RecognitionException { | ||
4122 | |||
4123 | int stackSize = keepStackSize(); | ||
4124 | |||
4125 | try { | ||
4126 | // InternalAlloyLanguage.g:1295: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 ) ) | ||
4127 | int alt10=9; | ||
4128 | alt10 = dfa10.predict(input); | ||
4129 | switch (alt10) { | ||
4130 | case 1 : | ||
4131 | // InternalAlloyLanguage.g:1296:1: ( ( rule__ALSPreficed__Group_0__0 ) ) | ||
4132 | { | ||
4133 | // InternalAlloyLanguage.g:1296:1: ( ( rule__ALSPreficed__Group_0__0 ) ) | ||
4134 | // InternalAlloyLanguage.g:1297:1: ( rule__ALSPreficed__Group_0__0 ) | ||
4135 | { | ||
4136 | if ( state.backtracking==0 ) { | ||
4137 | before(grammarAccess.getALSPreficedAccess().getGroup_0()); | ||
4138 | } | ||
4139 | // InternalAlloyLanguage.g:1298:1: ( rule__ALSPreficed__Group_0__0 ) | ||
4140 | // InternalAlloyLanguage.g:1298:2: rule__ALSPreficed__Group_0__0 | ||
4141 | { | ||
4142 | pushFollow(FOLLOW_2); | ||
4143 | rule__ALSPreficed__Group_0__0(); | ||
4144 | |||
4145 | state._fsp--; | ||
4146 | if (state.failed) return ; | ||
4147 | |||
4148 | } | ||
4149 | |||
4150 | if ( state.backtracking==0 ) { | ||
4151 | after(grammarAccess.getALSPreficedAccess().getGroup_0()); | ||
4152 | } | ||
4153 | |||
4154 | } | ||
4155 | |||
4156 | |||
4157 | } | ||
4158 | break; | ||
4159 | case 2 : | ||
4160 | // InternalAlloyLanguage.g:1302:6: ( ( rule__ALSPreficed__Group_1__0 ) ) | ||
4161 | { | ||
4162 | // InternalAlloyLanguage.g:1302:6: ( ( rule__ALSPreficed__Group_1__0 ) ) | ||
4163 | // InternalAlloyLanguage.g:1303:1: ( rule__ALSPreficed__Group_1__0 ) | ||
4164 | { | ||
4165 | if ( state.backtracking==0 ) { | ||
4166 | before(grammarAccess.getALSPreficedAccess().getGroup_1()); | ||
4167 | } | ||
4168 | // InternalAlloyLanguage.g:1304:1: ( rule__ALSPreficed__Group_1__0 ) | ||
4169 | // InternalAlloyLanguage.g:1304:2: rule__ALSPreficed__Group_1__0 | ||
4170 | { | ||
4171 | pushFollow(FOLLOW_2); | ||
4172 | rule__ALSPreficed__Group_1__0(); | ||
4173 | |||
4174 | state._fsp--; | ||
4175 | if (state.failed) return ; | ||
4176 | |||
4177 | } | ||
4178 | |||
4179 | if ( state.backtracking==0 ) { | ||
4180 | after(grammarAccess.getALSPreficedAccess().getGroup_1()); | ||
4181 | } | ||
4182 | |||
4183 | } | ||
4184 | |||
4185 | |||
4186 | } | ||
4187 | break; | ||
4188 | case 3 : | ||
4189 | // InternalAlloyLanguage.g:1308:6: ( ( rule__ALSPreficed__Group_2__0 ) ) | ||
4190 | { | ||
4191 | // InternalAlloyLanguage.g:1308:6: ( ( rule__ALSPreficed__Group_2__0 ) ) | ||
4192 | // InternalAlloyLanguage.g:1309:1: ( rule__ALSPreficed__Group_2__0 ) | ||
4193 | { | ||
4194 | if ( state.backtracking==0 ) { | ||
4195 | before(grammarAccess.getALSPreficedAccess().getGroup_2()); | ||
4196 | } | ||
4197 | // InternalAlloyLanguage.g:1310:1: ( rule__ALSPreficed__Group_2__0 ) | ||
4198 | // InternalAlloyLanguage.g:1310:2: rule__ALSPreficed__Group_2__0 | ||
4199 | { | ||
4200 | pushFollow(FOLLOW_2); | ||
4201 | rule__ALSPreficed__Group_2__0(); | ||
4202 | |||
4203 | state._fsp--; | ||
4204 | if (state.failed) return ; | ||
4205 | |||
4206 | } | ||
4207 | |||
4208 | if ( state.backtracking==0 ) { | ||
4209 | after(grammarAccess.getALSPreficedAccess().getGroup_2()); | ||
4210 | } | ||
4211 | |||
4212 | } | ||
4213 | |||
4214 | |||
4215 | } | ||
4216 | break; | ||
4217 | case 4 : | ||
4218 | // InternalAlloyLanguage.g:1314:6: ( ( rule__ALSPreficed__Group_3__0 ) ) | ||
4219 | { | ||
4220 | // InternalAlloyLanguage.g:1314:6: ( ( rule__ALSPreficed__Group_3__0 ) ) | ||
4221 | // InternalAlloyLanguage.g:1315:1: ( rule__ALSPreficed__Group_3__0 ) | ||
4222 | { | ||
4223 | if ( state.backtracking==0 ) { | ||
4224 | before(grammarAccess.getALSPreficedAccess().getGroup_3()); | ||
4225 | } | ||
4226 | // InternalAlloyLanguage.g:1316:1: ( rule__ALSPreficed__Group_3__0 ) | ||
4227 | // InternalAlloyLanguage.g:1316:2: rule__ALSPreficed__Group_3__0 | ||
4228 | { | ||
4229 | pushFollow(FOLLOW_2); | ||
4230 | rule__ALSPreficed__Group_3__0(); | ||
4231 | |||
4232 | state._fsp--; | ||
4233 | if (state.failed) return ; | ||
4234 | |||
4235 | } | ||
4236 | |||
4237 | if ( state.backtracking==0 ) { | ||
4238 | after(grammarAccess.getALSPreficedAccess().getGroup_3()); | ||
4239 | } | ||
4240 | |||
4241 | } | ||
4242 | |||
4243 | |||
4244 | } | ||
4245 | break; | ||
4246 | case 5 : | ||
4247 | // InternalAlloyLanguage.g:1320:6: ( ( rule__ALSPreficed__Group_4__0 ) ) | ||
4248 | { | ||
4249 | // InternalAlloyLanguage.g:1320:6: ( ( rule__ALSPreficed__Group_4__0 ) ) | ||
4250 | // InternalAlloyLanguage.g:1321:1: ( rule__ALSPreficed__Group_4__0 ) | ||
4251 | { | ||
4252 | if ( state.backtracking==0 ) { | ||
4253 | before(grammarAccess.getALSPreficedAccess().getGroup_4()); | ||
4254 | } | ||
4255 | // InternalAlloyLanguage.g:1322:1: ( rule__ALSPreficed__Group_4__0 ) | ||
4256 | // InternalAlloyLanguage.g:1322:2: rule__ALSPreficed__Group_4__0 | ||
4257 | { | ||
4258 | pushFollow(FOLLOW_2); | ||
4259 | rule__ALSPreficed__Group_4__0(); | ||
4260 | |||
4261 | state._fsp--; | ||
4262 | if (state.failed) return ; | ||
4263 | |||
4264 | } | ||
4265 | |||
4266 | if ( state.backtracking==0 ) { | ||
4267 | after(grammarAccess.getALSPreficedAccess().getGroup_4()); | ||
4268 | } | ||
4269 | |||
4270 | } | ||
4271 | |||
4272 | |||
4273 | } | ||
4274 | break; | ||
4275 | case 6 : | ||
4276 | // InternalAlloyLanguage.g:1326:6: ( ( rule__ALSPreficed__Group_5__0 ) ) | ||
4277 | { | ||
4278 | // InternalAlloyLanguage.g:1326:6: ( ( rule__ALSPreficed__Group_5__0 ) ) | ||
4279 | // InternalAlloyLanguage.g:1327:1: ( rule__ALSPreficed__Group_5__0 ) | ||
4280 | { | ||
4281 | if ( state.backtracking==0 ) { | ||
4282 | before(grammarAccess.getALSPreficedAccess().getGroup_5()); | ||
4283 | } | ||
4284 | // InternalAlloyLanguage.g:1328:1: ( rule__ALSPreficed__Group_5__0 ) | ||
4285 | // InternalAlloyLanguage.g:1328:2: rule__ALSPreficed__Group_5__0 | ||
4286 | { | ||
4287 | pushFollow(FOLLOW_2); | ||
4288 | rule__ALSPreficed__Group_5__0(); | ||
4289 | |||
4290 | state._fsp--; | ||
4291 | if (state.failed) return ; | ||
4292 | |||
4293 | } | ||
4294 | |||
4295 | if ( state.backtracking==0 ) { | ||
4296 | after(grammarAccess.getALSPreficedAccess().getGroup_5()); | ||
4297 | } | ||
4298 | |||
4299 | } | ||
4300 | |||
4301 | |||
4302 | } | ||
4303 | break; | ||
4304 | case 7 : | ||
4305 | // InternalAlloyLanguage.g:1332:6: ( ( rule__ALSPreficed__Group_6__0 ) ) | ||
4306 | { | ||
4307 | // InternalAlloyLanguage.g:1332:6: ( ( rule__ALSPreficed__Group_6__0 ) ) | ||
4308 | // InternalAlloyLanguage.g:1333:1: ( rule__ALSPreficed__Group_6__0 ) | ||
4309 | { | ||
4310 | if ( state.backtracking==0 ) { | ||
4311 | before(grammarAccess.getALSPreficedAccess().getGroup_6()); | ||
4312 | } | ||
4313 | // InternalAlloyLanguage.g:1334:1: ( rule__ALSPreficed__Group_6__0 ) | ||
4314 | // InternalAlloyLanguage.g:1334:2: rule__ALSPreficed__Group_6__0 | ||
4315 | { | ||
4316 | pushFollow(FOLLOW_2); | ||
4317 | rule__ALSPreficed__Group_6__0(); | ||
4318 | |||
4319 | state._fsp--; | ||
4320 | if (state.failed) return ; | ||
4321 | |||
4322 | } | ||
4323 | |||
4324 | if ( state.backtracking==0 ) { | ||
4325 | after(grammarAccess.getALSPreficedAccess().getGroup_6()); | ||
4326 | } | ||
4327 | |||
4328 | } | ||
4329 | |||
4330 | |||
4331 | } | ||
4332 | break; | ||
4333 | case 8 : | ||
4334 | // InternalAlloyLanguage.g:1338:6: ( ( rule__ALSPreficed__Group_7__0 ) ) | ||
4335 | { | ||
4336 | // InternalAlloyLanguage.g:1338:6: ( ( rule__ALSPreficed__Group_7__0 ) ) | ||
4337 | // InternalAlloyLanguage.g:1339:1: ( rule__ALSPreficed__Group_7__0 ) | ||
4338 | { | ||
4339 | if ( state.backtracking==0 ) { | ||
4340 | before(grammarAccess.getALSPreficedAccess().getGroup_7()); | ||
4341 | } | ||
4342 | // InternalAlloyLanguage.g:1340:1: ( rule__ALSPreficed__Group_7__0 ) | ||
4343 | // InternalAlloyLanguage.g:1340:2: rule__ALSPreficed__Group_7__0 | ||
4344 | { | ||
4345 | pushFollow(FOLLOW_2); | ||
4346 | rule__ALSPreficed__Group_7__0(); | ||
4347 | |||
4348 | state._fsp--; | ||
4349 | if (state.failed) return ; | ||
4350 | |||
4351 | } | ||
4352 | |||
4353 | if ( state.backtracking==0 ) { | ||
4354 | after(grammarAccess.getALSPreficedAccess().getGroup_7()); | ||
4355 | } | ||
4356 | |||
4357 | } | ||
4358 | |||
4359 | |||
4360 | } | ||
4361 | break; | ||
4362 | case 9 : | ||
4363 | // InternalAlloyLanguage.g:1344:6: ( ruleALSBasicRelationTerm ) | ||
4364 | { | ||
4365 | // InternalAlloyLanguage.g:1344:6: ( ruleALSBasicRelationTerm ) | ||
4366 | // InternalAlloyLanguage.g:1345:1: ruleALSBasicRelationTerm | ||
4367 | { | ||
4368 | if ( state.backtracking==0 ) { | ||
4369 | before(grammarAccess.getALSPreficedAccess().getALSBasicRelationTermParserRuleCall_8()); | ||
4370 | } | ||
4371 | pushFollow(FOLLOW_2); | ||
4372 | ruleALSBasicRelationTerm(); | ||
4373 | |||
4374 | state._fsp--; | ||
4375 | if (state.failed) return ; | ||
4376 | if ( state.backtracking==0 ) { | ||
4377 | after(grammarAccess.getALSPreficedAccess().getALSBasicRelationTermParserRuleCall_8()); | ||
4378 | } | ||
4379 | |||
4380 | } | ||
4381 | |||
4382 | |||
4383 | } | ||
4384 | break; | ||
4385 | |||
4386 | } | ||
4387 | } | ||
4388 | catch (RecognitionException re) { | ||
4389 | reportError(re); | ||
4390 | recover(input,re); | ||
4391 | } | ||
4392 | finally { | ||
4393 | |||
4394 | restoreStackSize(stackSize); | ||
4395 | |||
4396 | } | ||
4397 | return ; | ||
4398 | } | ||
4399 | // $ANTLR end "rule__ALSPreficed__Alternatives" | ||
4400 | |||
4401 | |||
4402 | // $ANTLR start "rule__ALSPreficed__Alternatives_0_1_0" | ||
4403 | // InternalAlloyLanguage.g:1355:1: rule__ALSPreficed__Alternatives_0_1_0 : ( ( '!' ) | ( 'not' ) ); | ||
4404 | public final void rule__ALSPreficed__Alternatives_0_1_0() throws RecognitionException { | ||
4405 | |||
4406 | int stackSize = keepStackSize(); | ||
4407 | |||
4408 | try { | ||
4409 | // InternalAlloyLanguage.g:1359:1: ( ( '!' ) | ( 'not' ) ) | ||
4410 | int alt11=2; | ||
4411 | int LA11_0 = input.LA(1); | ||
4412 | |||
4413 | if ( (LA11_0==19) ) { | ||
4414 | alt11=1; | ||
4415 | } | ||
4416 | else if ( (LA11_0==20) ) { | ||
4417 | alt11=2; | ||
4418 | } | ||
4419 | else { | ||
4420 | if (state.backtracking>0) {state.failed=true; return ;} | ||
4421 | NoViableAltException nvae = | ||
4422 | new NoViableAltException("", 11, 0, input); | ||
4423 | |||
4424 | throw nvae; | ||
4425 | } | ||
4426 | switch (alt11) { | ||
4427 | case 1 : | ||
4428 | // InternalAlloyLanguage.g:1360:1: ( '!' ) | ||
4429 | { | ||
4430 | // InternalAlloyLanguage.g:1360:1: ( '!' ) | ||
4431 | // InternalAlloyLanguage.g:1361:1: '!' | ||
4432 | { | ||
4433 | if ( state.backtracking==0 ) { | ||
4434 | before(grammarAccess.getALSPreficedAccess().getExclamationMarkKeyword_0_1_0_0()); | ||
4435 | } | ||
4436 | match(input,19,FOLLOW_2); if (state.failed) return ; | ||
4437 | if ( state.backtracking==0 ) { | ||
4438 | after(grammarAccess.getALSPreficedAccess().getExclamationMarkKeyword_0_1_0_0()); | ||
4439 | } | ||
4440 | |||
4441 | } | ||
4442 | |||
4443 | |||
4444 | } | ||
4445 | break; | ||
4446 | case 2 : | ||
4447 | // InternalAlloyLanguage.g:1368:6: ( 'not' ) | ||
4448 | { | ||
4449 | // InternalAlloyLanguage.g:1368:6: ( 'not' ) | ||
4450 | // InternalAlloyLanguage.g:1369:1: 'not' | ||
4451 | { | ||
4452 | if ( state.backtracking==0 ) { | ||
4453 | before(grammarAccess.getALSPreficedAccess().getNotKeyword_0_1_0_1()); | ||
4454 | } | ||
4455 | match(input,20,FOLLOW_2); if (state.failed) return ; | ||
4456 | if ( state.backtracking==0 ) { | ||
4457 | after(grammarAccess.getALSPreficedAccess().getNotKeyword_0_1_0_1()); | ||
4458 | } | ||
4459 | |||
4460 | } | ||
4461 | |||
4462 | |||
4463 | } | ||
4464 | break; | ||
4465 | |||
4466 | } | ||
4467 | } | ||
4468 | catch (RecognitionException re) { | ||
4469 | reportError(re); | ||
4470 | recover(input,re); | ||
4471 | } | ||
4472 | finally { | ||
4473 | |||
4474 | restoreStackSize(stackSize); | ||
4475 | |||
4476 | } | ||
4477 | return ; | ||
4478 | } | ||
4479 | // $ANTLR end "rule__ALSPreficed__Alternatives_0_1_0" | ||
4480 | |||
4481 | |||
4482 | // $ANTLR start "rule__ALSPreficed__Alternatives_7_1" | ||
4483 | // InternalAlloyLanguage.g:1381:1: rule__ALSPreficed__Alternatives_7_1 : ( ( ( rule__ALSPreficed__ReferredDefinitionAssignment_7_1_0 ) ) | ( ( rule__ALSPreficed__ReferredNumericOperatorAssignment_7_1_1 ) ) ); | ||
4484 | public final void rule__ALSPreficed__Alternatives_7_1() throws RecognitionException { | ||
4485 | |||
4486 | int stackSize = keepStackSize(); | ||
4487 | |||
4488 | try { | ||
4489 | // InternalAlloyLanguage.g:1385:1: ( ( ( rule__ALSPreficed__ReferredDefinitionAssignment_7_1_0 ) ) | ( ( rule__ALSPreficed__ReferredNumericOperatorAssignment_7_1_1 ) ) ) | ||
4490 | int alt12=2; | ||
4491 | int LA12_0 = input.LA(1); | ||
4492 | |||
4493 | if ( (LA12_0==RULE_ID) ) { | ||
4494 | alt12=1; | ||
4495 | } | ||
4496 | else if ( ((LA12_0>=27 && LA12_0<=31)) ) { | ||
4497 | alt12=2; | ||
4498 | } | ||
4499 | else { | ||
4500 | if (state.backtracking>0) {state.failed=true; return ;} | ||
4501 | NoViableAltException nvae = | ||
4502 | new NoViableAltException("", 12, 0, input); | ||
4503 | |||
4504 | throw nvae; | ||
4505 | } | ||
4506 | switch (alt12) { | ||
4507 | case 1 : | ||
4508 | // InternalAlloyLanguage.g:1386:1: ( ( rule__ALSPreficed__ReferredDefinitionAssignment_7_1_0 ) ) | ||
4509 | { | ||
4510 | // InternalAlloyLanguage.g:1386:1: ( ( rule__ALSPreficed__ReferredDefinitionAssignment_7_1_0 ) ) | ||
4511 | // InternalAlloyLanguage.g:1387:1: ( rule__ALSPreficed__ReferredDefinitionAssignment_7_1_0 ) | ||
4512 | { | ||
4513 | if ( state.backtracking==0 ) { | ||
4514 | before(grammarAccess.getALSPreficedAccess().getReferredDefinitionAssignment_7_1_0()); | ||
4515 | } | ||
4516 | // InternalAlloyLanguage.g:1388:1: ( rule__ALSPreficed__ReferredDefinitionAssignment_7_1_0 ) | ||
4517 | // InternalAlloyLanguage.g:1388:2: rule__ALSPreficed__ReferredDefinitionAssignment_7_1_0 | ||
4518 | { | ||
4519 | pushFollow(FOLLOW_2); | ||
4520 | rule__ALSPreficed__ReferredDefinitionAssignment_7_1_0(); | ||
4521 | |||
4522 | state._fsp--; | ||
4523 | if (state.failed) return ; | ||
4524 | |||
4525 | } | ||
4526 | |||
4527 | if ( state.backtracking==0 ) { | ||
4528 | after(grammarAccess.getALSPreficedAccess().getReferredDefinitionAssignment_7_1_0()); | ||
4529 | } | ||
4530 | |||
4531 | } | ||
4532 | |||
4533 | |||
4534 | } | ||
4535 | break; | ||
4536 | case 2 : | ||
4537 | // InternalAlloyLanguage.g:1392:6: ( ( rule__ALSPreficed__ReferredNumericOperatorAssignment_7_1_1 ) ) | ||
4538 | { | ||
4539 | // InternalAlloyLanguage.g:1392:6: ( ( rule__ALSPreficed__ReferredNumericOperatorAssignment_7_1_1 ) ) | ||
4540 | // InternalAlloyLanguage.g:1393:1: ( rule__ALSPreficed__ReferredNumericOperatorAssignment_7_1_1 ) | ||
4541 | { | ||
4542 | if ( state.backtracking==0 ) { | ||
4543 | before(grammarAccess.getALSPreficedAccess().getReferredNumericOperatorAssignment_7_1_1()); | ||
4544 | } | ||
4545 | // InternalAlloyLanguage.g:1394:1: ( rule__ALSPreficed__ReferredNumericOperatorAssignment_7_1_1 ) | ||
4546 | // InternalAlloyLanguage.g:1394:2: rule__ALSPreficed__ReferredNumericOperatorAssignment_7_1_1 | ||
4547 | { | ||
4548 | pushFollow(FOLLOW_2); | ||
4549 | rule__ALSPreficed__ReferredNumericOperatorAssignment_7_1_1(); | ||
4550 | |||
4551 | state._fsp--; | ||
4552 | if (state.failed) return ; | ||
4553 | |||
4554 | } | ||
4555 | |||
4556 | if ( state.backtracking==0 ) { | ||
4557 | after(grammarAccess.getALSPreficedAccess().getReferredNumericOperatorAssignment_7_1_1()); | ||
4558 | } | ||
4559 | |||
4560 | } | ||
4561 | |||
4562 | |||
4563 | } | ||
4564 | break; | ||
4565 | |||
4566 | } | ||
4567 | } | ||
4568 | catch (RecognitionException re) { | ||
4569 | reportError(re); | ||
4570 | recover(input,re); | ||
4571 | } | ||
4572 | finally { | ||
4573 | |||
4574 | restoreStackSize(stackSize); | ||
4575 | |||
4576 | } | ||
4577 | return ; | ||
4578 | } | ||
4579 | // $ANTLR end "rule__ALSPreficed__Alternatives_7_1" | ||
4580 | |||
4581 | |||
4582 | // $ANTLR start "rule__ALSBasicRelationTerm__Alternatives" | ||
4583 | // InternalAlloyLanguage.g:1403: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 ) ) ); | ||
4584 | public final void rule__ALSBasicRelationTerm__Alternatives() throws RecognitionException { | ||
4585 | |||
4586 | int stackSize = keepStackSize(); | ||
4587 | |||
4588 | try { | ||
4589 | // InternalAlloyLanguage.g:1407: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 ) ) ) | ||
4590 | int alt13=7; | ||
4591 | switch ( input.LA(1) ) { | ||
4592 | case 65: | ||
4593 | { | ||
4594 | alt13=1; | ||
4595 | } | ||
4596 | break; | ||
4597 | case 66: | ||
4598 | { | ||
4599 | alt13=2; | ||
4600 | } | ||
4601 | break; | ||
4602 | case 67: | ||
4603 | { | ||
4604 | alt13=3; | ||
4605 | } | ||
4606 | break; | ||
4607 | case 68: | ||
4608 | { | ||
4609 | alt13=4; | ||
4610 | } | ||
4611 | break; | ||
4612 | case RULE_ID: | ||
4613 | { | ||
4614 | alt13=5; | ||
4615 | } | ||
4616 | break; | ||
4617 | case RULE_INT: | ||
4618 | { | ||
4619 | alt13=6; | ||
4620 | } | ||
4621 | break; | ||
4622 | case 69: | ||
4623 | { | ||
4624 | alt13=7; | ||
4625 | } | ||
4626 | break; | ||
4627 | default: | ||
4628 | if (state.backtracking>0) {state.failed=true; return ;} | ||
4629 | NoViableAltException nvae = | ||
4630 | new NoViableAltException("", 13, 0, input); | ||
4631 | |||
4632 | throw nvae; | ||
4633 | } | ||
4634 | |||
4635 | switch (alt13) { | ||
4636 | case 1 : | ||
4637 | // InternalAlloyLanguage.g:1408:1: ( ( rule__ALSBasicRelationTerm__Group_0__0 ) ) | ||
4638 | { | ||
4639 | // InternalAlloyLanguage.g:1408:1: ( ( rule__ALSBasicRelationTerm__Group_0__0 ) ) | ||
4640 | // InternalAlloyLanguage.g:1409:1: ( rule__ALSBasicRelationTerm__Group_0__0 ) | ||
4641 | { | ||
4642 | if ( state.backtracking==0 ) { | ||
4643 | before(grammarAccess.getALSBasicRelationTermAccess().getGroup_0()); | ||
4644 | } | ||
4645 | // InternalAlloyLanguage.g:1410:1: ( rule__ALSBasicRelationTerm__Group_0__0 ) | ||
4646 | // InternalAlloyLanguage.g:1410:2: rule__ALSBasicRelationTerm__Group_0__0 | ||
4647 | { | ||
4648 | pushFollow(FOLLOW_2); | ||
4649 | rule__ALSBasicRelationTerm__Group_0__0(); | ||
4650 | |||
4651 | state._fsp--; | ||
4652 | if (state.failed) return ; | ||
4653 | |||
4654 | } | ||
4655 | |||
4656 | if ( state.backtracking==0 ) { | ||
4657 | after(grammarAccess.getALSBasicRelationTermAccess().getGroup_0()); | ||
4658 | } | ||
4659 | |||
4660 | } | ||
4661 | |||
4662 | |||
4663 | } | ||
4664 | break; | ||
4665 | case 2 : | ||
4666 | // InternalAlloyLanguage.g:1414:6: ( ( rule__ALSBasicRelationTerm__Group_1__0 ) ) | ||
4667 | { | ||
4668 | // InternalAlloyLanguage.g:1414:6: ( ( rule__ALSBasicRelationTerm__Group_1__0 ) ) | ||
4669 | // InternalAlloyLanguage.g:1415:1: ( rule__ALSBasicRelationTerm__Group_1__0 ) | ||
4670 | { | ||
4671 | if ( state.backtracking==0 ) { | ||
4672 | before(grammarAccess.getALSBasicRelationTermAccess().getGroup_1()); | ||
4673 | } | ||
4674 | // InternalAlloyLanguage.g:1416:1: ( rule__ALSBasicRelationTerm__Group_1__0 ) | ||
4675 | // InternalAlloyLanguage.g:1416:2: rule__ALSBasicRelationTerm__Group_1__0 | ||
4676 | { | ||
4677 | pushFollow(FOLLOW_2); | ||
4678 | rule__ALSBasicRelationTerm__Group_1__0(); | ||
4679 | |||
4680 | state._fsp--; | ||
4681 | if (state.failed) return ; | ||
4682 | |||
4683 | } | ||
4684 | |||
4685 | if ( state.backtracking==0 ) { | ||
4686 | after(grammarAccess.getALSBasicRelationTermAccess().getGroup_1()); | ||
4687 | } | ||
4688 | |||
4689 | } | ||
4690 | |||
4691 | |||
4692 | } | ||
4693 | break; | ||
4694 | case 3 : | ||
4695 | // InternalAlloyLanguage.g:1420:6: ( ( rule__ALSBasicRelationTerm__Group_2__0 ) ) | ||
4696 | { | ||
4697 | // InternalAlloyLanguage.g:1420:6: ( ( rule__ALSBasicRelationTerm__Group_2__0 ) ) | ||
4698 | // InternalAlloyLanguage.g:1421:1: ( rule__ALSBasicRelationTerm__Group_2__0 ) | ||
4699 | { | ||
4700 | if ( state.backtracking==0 ) { | ||
4701 | before(grammarAccess.getALSBasicRelationTermAccess().getGroup_2()); | ||
4702 | } | ||
4703 | // InternalAlloyLanguage.g:1422:1: ( rule__ALSBasicRelationTerm__Group_2__0 ) | ||
4704 | // InternalAlloyLanguage.g:1422:2: rule__ALSBasicRelationTerm__Group_2__0 | ||
4705 | { | ||
4706 | pushFollow(FOLLOW_2); | ||
4707 | rule__ALSBasicRelationTerm__Group_2__0(); | ||
4708 | |||
4709 | state._fsp--; | ||
4710 | if (state.failed) return ; | ||
4711 | |||
4712 | } | ||
4713 | |||
4714 | if ( state.backtracking==0 ) { | ||
4715 | after(grammarAccess.getALSBasicRelationTermAccess().getGroup_2()); | ||
4716 | } | ||
4717 | |||
4718 | } | ||
4719 | |||
4720 | |||
4721 | } | ||
4722 | break; | ||
4723 | case 4 : | ||
4724 | // InternalAlloyLanguage.g:1426:6: ( ( rule__ALSBasicRelationTerm__Group_3__0 ) ) | ||
4725 | { | ||
4726 | // InternalAlloyLanguage.g:1426:6: ( ( rule__ALSBasicRelationTerm__Group_3__0 ) ) | ||
4727 | // InternalAlloyLanguage.g:1427:1: ( rule__ALSBasicRelationTerm__Group_3__0 ) | ||
4728 | { | ||
4729 | if ( state.backtracking==0 ) { | ||
4730 | before(grammarAccess.getALSBasicRelationTermAccess().getGroup_3()); | ||
4731 | } | ||
4732 | // InternalAlloyLanguage.g:1428:1: ( rule__ALSBasicRelationTerm__Group_3__0 ) | ||
4733 | // InternalAlloyLanguage.g:1428:2: rule__ALSBasicRelationTerm__Group_3__0 | ||
4734 | { | ||
4735 | pushFollow(FOLLOW_2); | ||
4736 | rule__ALSBasicRelationTerm__Group_3__0(); | ||
4737 | |||
4738 | state._fsp--; | ||
4739 | if (state.failed) return ; | ||
4740 | |||
4741 | } | ||
4742 | |||
4743 | if ( state.backtracking==0 ) { | ||
4744 | after(grammarAccess.getALSBasicRelationTermAccess().getGroup_3()); | ||
4745 | } | ||
4746 | |||
4747 | } | ||
4748 | |||
4749 | |||
4750 | } | ||
4751 | break; | ||
4752 | case 5 : | ||
4753 | // InternalAlloyLanguage.g:1432:6: ( ( rule__ALSBasicRelationTerm__Group_4__0 ) ) | ||
4754 | { | ||
4755 | // InternalAlloyLanguage.g:1432:6: ( ( rule__ALSBasicRelationTerm__Group_4__0 ) ) | ||
4756 | // InternalAlloyLanguage.g:1433:1: ( rule__ALSBasicRelationTerm__Group_4__0 ) | ||
4757 | { | ||
4758 | if ( state.backtracking==0 ) { | ||
4759 | before(grammarAccess.getALSBasicRelationTermAccess().getGroup_4()); | ||
4760 | } | ||
4761 | // InternalAlloyLanguage.g:1434:1: ( rule__ALSBasicRelationTerm__Group_4__0 ) | ||
4762 | // InternalAlloyLanguage.g:1434:2: rule__ALSBasicRelationTerm__Group_4__0 | ||
4763 | { | ||
4764 | pushFollow(FOLLOW_2); | ||
4765 | rule__ALSBasicRelationTerm__Group_4__0(); | ||
4766 | |||
4767 | state._fsp--; | ||
4768 | if (state.failed) return ; | ||
4769 | |||
4770 | } | ||
4771 | |||
4772 | if ( state.backtracking==0 ) { | ||
4773 | after(grammarAccess.getALSBasicRelationTermAccess().getGroup_4()); | ||
4774 | } | ||
4775 | |||
4776 | } | ||
4777 | |||
4778 | |||
4779 | } | ||
4780 | break; | ||
4781 | case 6 : | ||
4782 | // InternalAlloyLanguage.g:1438:6: ( ( rule__ALSBasicRelationTerm__Group_5__0 ) ) | ||
4783 | { | ||
4784 | // InternalAlloyLanguage.g:1438:6: ( ( rule__ALSBasicRelationTerm__Group_5__0 ) ) | ||
4785 | // InternalAlloyLanguage.g:1439:1: ( rule__ALSBasicRelationTerm__Group_5__0 ) | ||
4786 | { | ||
4787 | if ( state.backtracking==0 ) { | ||
4788 | before(grammarAccess.getALSBasicRelationTermAccess().getGroup_5()); | ||
4789 | } | ||
4790 | // InternalAlloyLanguage.g:1440:1: ( rule__ALSBasicRelationTerm__Group_5__0 ) | ||
4791 | // InternalAlloyLanguage.g:1440:2: rule__ALSBasicRelationTerm__Group_5__0 | ||
4792 | { | ||
4793 | pushFollow(FOLLOW_2); | ||
4794 | rule__ALSBasicRelationTerm__Group_5__0(); | ||
4795 | |||
4796 | state._fsp--; | ||
4797 | if (state.failed) return ; | ||
4798 | |||
4799 | } | ||
4800 | |||
4801 | if ( state.backtracking==0 ) { | ||
4802 | after(grammarAccess.getALSBasicRelationTermAccess().getGroup_5()); | ||
4803 | } | ||
4804 | |||
4805 | } | ||
4806 | |||
4807 | |||
4808 | } | ||
4809 | break; | ||
4810 | case 7 : | ||
4811 | // InternalAlloyLanguage.g:1444:6: ( ( rule__ALSBasicRelationTerm__Group_6__0 ) ) | ||
4812 | { | ||
4813 | // InternalAlloyLanguage.g:1444:6: ( ( rule__ALSBasicRelationTerm__Group_6__0 ) ) | ||
4814 | // InternalAlloyLanguage.g:1445:1: ( rule__ALSBasicRelationTerm__Group_6__0 ) | ||
4815 | { | ||
4816 | if ( state.backtracking==0 ) { | ||
4817 | before(grammarAccess.getALSBasicRelationTermAccess().getGroup_6()); | ||
4818 | } | ||
4819 | // InternalAlloyLanguage.g:1446:1: ( rule__ALSBasicRelationTerm__Group_6__0 ) | ||
4820 | // InternalAlloyLanguage.g:1446:2: rule__ALSBasicRelationTerm__Group_6__0 | ||
4821 | { | ||
4822 | pushFollow(FOLLOW_2); | ||
4823 | rule__ALSBasicRelationTerm__Group_6__0(); | ||
4824 | |||
4825 | state._fsp--; | ||
4826 | if (state.failed) return ; | ||
4827 | |||
4828 | } | ||
4829 | |||
4830 | if ( state.backtracking==0 ) { | ||
4831 | after(grammarAccess.getALSBasicRelationTermAccess().getGroup_6()); | ||
4832 | } | ||
4833 | |||
4834 | } | ||
4835 | |||
4836 | |||
4837 | } | ||
4838 | break; | ||
4839 | |||
4840 | } | ||
4841 | } | ||
4842 | catch (RecognitionException re) { | ||
4843 | reportError(re); | ||
4844 | recover(input,re); | ||
4845 | } | ||
4846 | finally { | ||
4847 | |||
4848 | restoreStackSize(stackSize); | ||
4849 | |||
4850 | } | ||
4851 | return ; | ||
4852 | } | ||
4853 | // $ANTLR end "rule__ALSBasicRelationTerm__Alternatives" | ||
4854 | |||
4855 | |||
4856 | // $ANTLR start "rule__ALSTypeScope__Alternatives" | ||
4857 | // InternalAlloyLanguage.g:1455:1: rule__ALSTypeScope__Alternatives : ( ( ruleALSSigScope ) | ( ruleALSIntScope ) ); | ||
4858 | public final void rule__ALSTypeScope__Alternatives() throws RecognitionException { | ||
4859 | |||
4860 | int stackSize = keepStackSize(); | ||
4861 | |||
4862 | try { | ||
4863 | // InternalAlloyLanguage.g:1459:1: ( ( ruleALSSigScope ) | ( ruleALSIntScope ) ) | ||
4864 | int alt14=2; | ||
4865 | int LA14_0 = input.LA(1); | ||
4866 | |||
4867 | if ( (LA14_0==75) ) { | ||
4868 | alt14=1; | ||
4869 | } | ||
4870 | else if ( (LA14_0==RULE_INT) ) { | ||
4871 | int LA14_2 = input.LA(2); | ||
4872 | |||
4873 | if ( (LA14_2==RULE_ID) ) { | ||
4874 | alt14=1; | ||
4875 | } | ||
4876 | else if ( (LA14_2==68) ) { | ||
4877 | alt14=2; | ||
4878 | } | ||
4879 | else { | ||
4880 | if (state.backtracking>0) {state.failed=true; return ;} | ||
4881 | NoViableAltException nvae = | ||
4882 | new NoViableAltException("", 14, 2, input); | ||
4883 | |||
4884 | throw nvae; | ||
4885 | } | ||
4886 | } | ||
4887 | else { | ||
4888 | if (state.backtracking>0) {state.failed=true; return ;} | ||
4889 | NoViableAltException nvae = | ||
4890 | new NoViableAltException("", 14, 0, input); | ||
4891 | |||
4892 | throw nvae; | ||
4893 | } | ||
4894 | switch (alt14) { | ||
4895 | case 1 : | ||
4896 | // InternalAlloyLanguage.g:1460:1: ( ruleALSSigScope ) | ||
4897 | { | ||
4898 | // InternalAlloyLanguage.g:1460:1: ( ruleALSSigScope ) | ||
4899 | // InternalAlloyLanguage.g:1461:1: ruleALSSigScope | ||
4900 | { | ||
4901 | if ( state.backtracking==0 ) { | ||
4902 | before(grammarAccess.getALSTypeScopeAccess().getALSSigScopeParserRuleCall_0()); | ||
4903 | } | ||
4904 | pushFollow(FOLLOW_2); | ||
4905 | ruleALSSigScope(); | ||
4906 | |||
4907 | state._fsp--; | ||
4908 | if (state.failed) return ; | ||
4909 | if ( state.backtracking==0 ) { | ||
4910 | after(grammarAccess.getALSTypeScopeAccess().getALSSigScopeParserRuleCall_0()); | ||
4911 | } | ||
4912 | |||
4913 | } | ||
4914 | |||
4915 | |||
4916 | } | ||
4917 | break; | ||
4918 | case 2 : | ||
4919 | // InternalAlloyLanguage.g:1466:6: ( ruleALSIntScope ) | ||
4920 | { | ||
4921 | // InternalAlloyLanguage.g:1466:6: ( ruleALSIntScope ) | ||
4922 | // InternalAlloyLanguage.g:1467:1: ruleALSIntScope | ||
4923 | { | ||
4924 | if ( state.backtracking==0 ) { | ||
4925 | before(grammarAccess.getALSTypeScopeAccess().getALSIntScopeParserRuleCall_1()); | ||
4926 | } | ||
4927 | pushFollow(FOLLOW_2); | ||
4928 | ruleALSIntScope(); | ||
4929 | |||
4930 | state._fsp--; | ||
4931 | if (state.failed) return ; | ||
4932 | if ( state.backtracking==0 ) { | ||
4933 | after(grammarAccess.getALSTypeScopeAccess().getALSIntScopeParserRuleCall_1()); | ||
4934 | } | ||
4935 | |||
4936 | } | ||
4937 | |||
4938 | |||
4939 | } | ||
4940 | break; | ||
4941 | |||
4942 | } | ||
4943 | } | ||
4944 | catch (RecognitionException re) { | ||
4945 | reportError(re); | ||
4946 | recover(input,re); | ||
4947 | } | ||
4948 | finally { | ||
4949 | |||
4950 | restoreStackSize(stackSize); | ||
4951 | |||
4952 | } | ||
4953 | return ; | ||
4954 | } | ||
4955 | // $ANTLR end "rule__ALSTypeScope__Alternatives" | ||
4956 | |||
4957 | |||
4958 | // $ANTLR start "rule__ALSMultiplicity__Alternatives" | ||
4959 | // InternalAlloyLanguage.g:1477:1: rule__ALSMultiplicity__Alternatives : ( ( ( 'all' ) ) | ( ( 'no' ) ) | ( ( 'some' ) ) | ( ( 'lone' ) ) | ( ( 'one' ) ) | ( ( 'set' ) ) ); | ||
4960 | public final void rule__ALSMultiplicity__Alternatives() throws RecognitionException { | ||
4961 | |||
4962 | int stackSize = keepStackSize(); | ||
4963 | |||
4964 | try { | ||
4965 | // InternalAlloyLanguage.g:1481:1: ( ( ( 'all' ) ) | ( ( 'no' ) ) | ( ( 'some' ) ) | ( ( 'lone' ) ) | ( ( 'one' ) ) | ( ( 'set' ) ) ) | ||
4966 | int alt15=6; | ||
4967 | switch ( input.LA(1) ) { | ||
4968 | case 21: | ||
4969 | { | ||
4970 | alt15=1; | ||
4971 | } | ||
4972 | break; | ||
4973 | case 22: | ||
4974 | { | ||
4975 | alt15=2; | ||
4976 | } | ||
4977 | break; | ||
4978 | case 23: | ||
4979 | { | ||
4980 | alt15=3; | ||
4981 | } | ||
4982 | break; | ||
4983 | case 24: | ||
4984 | { | ||
4985 | alt15=4; | ||
4986 | } | ||
4987 | break; | ||
4988 | case 25: | ||
4989 | { | ||
4990 | alt15=5; | ||
4991 | } | ||
4992 | break; | ||
4993 | case 26: | ||
4994 | { | ||
4995 | alt15=6; | ||
4996 | } | ||
4997 | break; | ||
4998 | default: | ||
4999 | if (state.backtracking>0) {state.failed=true; return ;} | ||
5000 | NoViableAltException nvae = | ||
5001 | new NoViableAltException("", 15, 0, input); | ||
5002 | |||
5003 | throw nvae; | ||
5004 | } | ||
5005 | |||
5006 | switch (alt15) { | ||
5007 | case 1 : | ||
5008 | // InternalAlloyLanguage.g:1482:1: ( ( 'all' ) ) | ||
5009 | { | ||
5010 | // InternalAlloyLanguage.g:1482:1: ( ( 'all' ) ) | ||
5011 | // InternalAlloyLanguage.g:1483:1: ( 'all' ) | ||
5012 | { | ||
5013 | if ( state.backtracking==0 ) { | ||
5014 | before(grammarAccess.getALSMultiplicityAccess().getAllEnumLiteralDeclaration_0()); | ||
5015 | } | ||
5016 | // InternalAlloyLanguage.g:1484:1: ( 'all' ) | ||
5017 | // InternalAlloyLanguage.g:1484:3: 'all' | ||
5018 | { | ||
5019 | match(input,21,FOLLOW_2); if (state.failed) return ; | ||
5020 | |||
5021 | } | ||
5022 | |||
5023 | if ( state.backtracking==0 ) { | ||
5024 | after(grammarAccess.getALSMultiplicityAccess().getAllEnumLiteralDeclaration_0()); | ||
5025 | } | ||
5026 | |||
5027 | } | ||
5028 | |||
5029 | |||
5030 | } | ||
5031 | break; | ||
5032 | case 2 : | ||
5033 | // InternalAlloyLanguage.g:1489:6: ( ( 'no' ) ) | ||
5034 | { | ||
5035 | // InternalAlloyLanguage.g:1489:6: ( ( 'no' ) ) | ||
5036 | // InternalAlloyLanguage.g:1490:1: ( 'no' ) | ||
5037 | { | ||
5038 | if ( state.backtracking==0 ) { | ||
5039 | before(grammarAccess.getALSMultiplicityAccess().getNoEnumLiteralDeclaration_1()); | ||
5040 | } | ||
5041 | // InternalAlloyLanguage.g:1491:1: ( 'no' ) | ||
5042 | // InternalAlloyLanguage.g:1491:3: 'no' | ||
5043 | { | ||
5044 | match(input,22,FOLLOW_2); if (state.failed) return ; | ||
5045 | |||
5046 | } | ||
5047 | |||
5048 | if ( state.backtracking==0 ) { | ||
5049 | after(grammarAccess.getALSMultiplicityAccess().getNoEnumLiteralDeclaration_1()); | ||
5050 | } | ||
5051 | |||
5052 | } | ||
5053 | |||
5054 | |||
5055 | } | ||
5056 | break; | ||
5057 | case 3 : | ||
5058 | // InternalAlloyLanguage.g:1496:6: ( ( 'some' ) ) | ||
5059 | { | ||
5060 | // InternalAlloyLanguage.g:1496:6: ( ( 'some' ) ) | ||
5061 | // InternalAlloyLanguage.g:1497:1: ( 'some' ) | ||
5062 | { | ||
5063 | if ( state.backtracking==0 ) { | ||
5064 | before(grammarAccess.getALSMultiplicityAccess().getSomeEnumLiteralDeclaration_2()); | ||
5065 | } | ||
5066 | // InternalAlloyLanguage.g:1498:1: ( 'some' ) | ||
5067 | // InternalAlloyLanguage.g:1498:3: 'some' | ||
5068 | { | ||
5069 | match(input,23,FOLLOW_2); if (state.failed) return ; | ||
5070 | |||
5071 | } | ||
5072 | |||
5073 | if ( state.backtracking==0 ) { | ||
5074 | after(grammarAccess.getALSMultiplicityAccess().getSomeEnumLiteralDeclaration_2()); | ||
5075 | } | ||
5076 | |||
5077 | } | ||
5078 | |||
5079 | |||
5080 | } | ||
5081 | break; | ||
5082 | case 4 : | ||
5083 | // InternalAlloyLanguage.g:1503:6: ( ( 'lone' ) ) | ||
5084 | { | ||
5085 | // InternalAlloyLanguage.g:1503:6: ( ( 'lone' ) ) | ||
5086 | // InternalAlloyLanguage.g:1504:1: ( 'lone' ) | ||
5087 | { | ||
5088 | if ( state.backtracking==0 ) { | ||
5089 | before(grammarAccess.getALSMultiplicityAccess().getLoneEnumLiteralDeclaration_3()); | ||
5090 | } | ||
5091 | // InternalAlloyLanguage.g:1505:1: ( 'lone' ) | ||
5092 | // InternalAlloyLanguage.g:1505:3: 'lone' | ||
5093 | { | ||
5094 | match(input,24,FOLLOW_2); if (state.failed) return ; | ||
5095 | |||
5096 | } | ||
5097 | |||
5098 | if ( state.backtracking==0 ) { | ||
5099 | after(grammarAccess.getALSMultiplicityAccess().getLoneEnumLiteralDeclaration_3()); | ||
5100 | } | ||
5101 | |||
5102 | } | ||
5103 | |||
5104 | |||
5105 | } | ||
5106 | break; | ||
5107 | case 5 : | ||
5108 | // InternalAlloyLanguage.g:1510:6: ( ( 'one' ) ) | ||
5109 | { | ||
5110 | // InternalAlloyLanguage.g:1510:6: ( ( 'one' ) ) | ||
5111 | // InternalAlloyLanguage.g:1511:1: ( 'one' ) | ||
5112 | { | ||
5113 | if ( state.backtracking==0 ) { | ||
5114 | before(grammarAccess.getALSMultiplicityAccess().getOneEnumLiteralDeclaration_4()); | ||
5115 | } | ||
5116 | // InternalAlloyLanguage.g:1512:1: ( 'one' ) | ||
5117 | // InternalAlloyLanguage.g:1512:3: 'one' | ||
5118 | { | ||
5119 | match(input,25,FOLLOW_2); if (state.failed) return ; | ||
5120 | |||
5121 | } | ||
5122 | |||
5123 | if ( state.backtracking==0 ) { | ||
5124 | after(grammarAccess.getALSMultiplicityAccess().getOneEnumLiteralDeclaration_4()); | ||
5125 | } | ||
5126 | |||
5127 | } | ||
5128 | |||
5129 | |||
5130 | } | ||
5131 | break; | ||
5132 | case 6 : | ||
5133 | // InternalAlloyLanguage.g:1517:6: ( ( 'set' ) ) | ||
5134 | { | ||
5135 | // InternalAlloyLanguage.g:1517:6: ( ( 'set' ) ) | ||
5136 | // InternalAlloyLanguage.g:1518:1: ( 'set' ) | ||
5137 | { | ||
5138 | if ( state.backtracking==0 ) { | ||
5139 | before(grammarAccess.getALSMultiplicityAccess().getSetEnumLiteralDeclaration_5()); | ||
5140 | } | ||
5141 | // InternalAlloyLanguage.g:1519:1: ( 'set' ) | ||
5142 | // InternalAlloyLanguage.g:1519:3: 'set' | ||
5143 | { | ||
5144 | match(input,26,FOLLOW_2); if (state.failed) return ; | ||
5145 | |||
5146 | } | ||
5147 | |||
5148 | if ( state.backtracking==0 ) { | ||
5149 | after(grammarAccess.getALSMultiplicityAccess().getSetEnumLiteralDeclaration_5()); | ||
5150 | } | ||
5151 | |||
5152 | } | ||
5153 | |||
5154 | |||
5155 | } | ||
5156 | break; | ||
5157 | |||
5158 | } | ||
5159 | } | ||
5160 | catch (RecognitionException re) { | ||
5161 | reportError(re); | ||
5162 | recover(input,re); | ||
5163 | } | ||
5164 | finally { | ||
5165 | |||
5166 | restoreStackSize(stackSize); | ||
5167 | |||
5168 | } | ||
5169 | return ; | ||
5170 | } | ||
5171 | // $ANTLR end "rule__ALSMultiplicity__Alternatives" | ||
5172 | |||
5173 | |||
5174 | // $ANTLR start "rule__ALSNumericOperator__Alternatives" | ||
5175 | // InternalAlloyLanguage.g:1529:1: rule__ALSNumericOperator__Alternatives : ( ( ( 'plus' ) ) | ( ( 'sub' ) ) | ( ( 'mul' ) ) | ( ( 'rem' ) ) | ( ( 'div' ) ) ); | ||
5176 | public final void rule__ALSNumericOperator__Alternatives() throws RecognitionException { | ||
5177 | |||
5178 | int stackSize = keepStackSize(); | ||
5179 | |||
5180 | try { | ||
5181 | // InternalAlloyLanguage.g:1533:1: ( ( ( 'plus' ) ) | ( ( 'sub' ) ) | ( ( 'mul' ) ) | ( ( 'rem' ) ) | ( ( 'div' ) ) ) | ||
5182 | int alt16=5; | ||
5183 | switch ( input.LA(1) ) { | ||
5184 | case 27: | ||
5185 | { | ||
5186 | alt16=1; | ||
5187 | } | ||
5188 | break; | ||
5189 | case 28: | ||
5190 | { | ||
5191 | alt16=2; | ||
5192 | } | ||
5193 | break; | ||
5194 | case 29: | ||
5195 | { | ||
5196 | alt16=3; | ||
5197 | } | ||
5198 | break; | ||
5199 | case 30: | ||
5200 | { | ||
5201 | alt16=4; | ||
5202 | } | ||
5203 | break; | ||
5204 | case 31: | ||
5205 | { | ||
5206 | alt16=5; | ||
5207 | } | ||
5208 | break; | ||
5209 | default: | ||
5210 | if (state.backtracking>0) {state.failed=true; return ;} | ||
5211 | NoViableAltException nvae = | ||
5212 | new NoViableAltException("", 16, 0, input); | ||
5213 | |||
5214 | throw nvae; | ||
5215 | } | ||
5216 | |||
5217 | switch (alt16) { | ||
5218 | case 1 : | ||
5219 | // InternalAlloyLanguage.g:1534:1: ( ( 'plus' ) ) | ||
5220 | { | ||
5221 | // InternalAlloyLanguage.g:1534:1: ( ( 'plus' ) ) | ||
5222 | // InternalAlloyLanguage.g:1535:1: ( 'plus' ) | ||
5223 | { | ||
5224 | if ( state.backtracking==0 ) { | ||
5225 | before(grammarAccess.getALSNumericOperatorAccess().getPlusEnumLiteralDeclaration_0()); | ||
5226 | } | ||
5227 | // InternalAlloyLanguage.g:1536:1: ( 'plus' ) | ||
5228 | // InternalAlloyLanguage.g:1536:3: 'plus' | ||
5229 | { | ||
5230 | match(input,27,FOLLOW_2); if (state.failed) return ; | ||
5231 | |||
5232 | } | ||
5233 | |||
5234 | if ( state.backtracking==0 ) { | ||
5235 | after(grammarAccess.getALSNumericOperatorAccess().getPlusEnumLiteralDeclaration_0()); | ||
5236 | } | ||
5237 | |||
5238 | } | ||
5239 | |||
5240 | |||
5241 | } | ||
5242 | break; | ||
5243 | case 2 : | ||
5244 | // InternalAlloyLanguage.g:1541:6: ( ( 'sub' ) ) | ||
5245 | { | ||
5246 | // InternalAlloyLanguage.g:1541:6: ( ( 'sub' ) ) | ||
5247 | // InternalAlloyLanguage.g:1542:1: ( 'sub' ) | ||
5248 | { | ||
5249 | if ( state.backtracking==0 ) { | ||
5250 | before(grammarAccess.getALSNumericOperatorAccess().getSubEnumLiteralDeclaration_1()); | ||
5251 | } | ||
5252 | // InternalAlloyLanguage.g:1543:1: ( 'sub' ) | ||
5253 | // InternalAlloyLanguage.g:1543:3: 'sub' | ||
5254 | { | ||
5255 | match(input,28,FOLLOW_2); if (state.failed) return ; | ||
5256 | |||
5257 | } | ||
5258 | |||
5259 | if ( state.backtracking==0 ) { | ||
5260 | after(grammarAccess.getALSNumericOperatorAccess().getSubEnumLiteralDeclaration_1()); | ||
5261 | } | ||
5262 | |||
5263 | } | ||
5264 | |||
5265 | |||
5266 | } | ||
5267 | break; | ||
5268 | case 3 : | ||
5269 | // InternalAlloyLanguage.g:1548:6: ( ( 'mul' ) ) | ||
5270 | { | ||
5271 | // InternalAlloyLanguage.g:1548:6: ( ( 'mul' ) ) | ||
5272 | // InternalAlloyLanguage.g:1549:1: ( 'mul' ) | ||
5273 | { | ||
5274 | if ( state.backtracking==0 ) { | ||
5275 | before(grammarAccess.getALSNumericOperatorAccess().getMulEnumLiteralDeclaration_2()); | ||
5276 | } | ||
5277 | // InternalAlloyLanguage.g:1550:1: ( 'mul' ) | ||
5278 | // InternalAlloyLanguage.g:1550:3: 'mul' | ||
5279 | { | ||
5280 | match(input,29,FOLLOW_2); if (state.failed) return ; | ||
5281 | |||
5282 | } | ||
5283 | |||
5284 | if ( state.backtracking==0 ) { | ||
5285 | after(grammarAccess.getALSNumericOperatorAccess().getMulEnumLiteralDeclaration_2()); | ||
5286 | } | ||
5287 | |||
5288 | } | ||
5289 | |||
5290 | |||
5291 | } | ||
5292 | break; | ||
5293 | case 4 : | ||
5294 | // InternalAlloyLanguage.g:1555:6: ( ( 'rem' ) ) | ||
5295 | { | ||
5296 | // InternalAlloyLanguage.g:1555:6: ( ( 'rem' ) ) | ||
5297 | // InternalAlloyLanguage.g:1556:1: ( 'rem' ) | ||
5298 | { | ||
5299 | if ( state.backtracking==0 ) { | ||
5300 | before(grammarAccess.getALSNumericOperatorAccess().getRemEnumLiteralDeclaration_3()); | ||
5301 | } | ||
5302 | // InternalAlloyLanguage.g:1557:1: ( 'rem' ) | ||
5303 | // InternalAlloyLanguage.g:1557:3: 'rem' | ||
5304 | { | ||
5305 | match(input,30,FOLLOW_2); if (state.failed) return ; | ||
5306 | |||
5307 | } | ||
5308 | |||
5309 | if ( state.backtracking==0 ) { | ||
5310 | after(grammarAccess.getALSNumericOperatorAccess().getRemEnumLiteralDeclaration_3()); | ||
5311 | } | ||
5312 | |||
5313 | } | ||
5314 | |||
5315 | |||
5316 | } | ||
5317 | break; | ||
5318 | case 5 : | ||
5319 | // InternalAlloyLanguage.g:1562:6: ( ( 'div' ) ) | ||
5320 | { | ||
5321 | // InternalAlloyLanguage.g:1562:6: ( ( 'div' ) ) | ||
5322 | // InternalAlloyLanguage.g:1563:1: ( 'div' ) | ||
5323 | { | ||
5324 | if ( state.backtracking==0 ) { | ||
5325 | before(grammarAccess.getALSNumericOperatorAccess().getDivEnumLiteralDeclaration_4()); | ||
5326 | } | ||
5327 | // InternalAlloyLanguage.g:1564:1: ( 'div' ) | ||
5328 | // InternalAlloyLanguage.g:1564:3: 'div' | ||
5329 | { | ||
5330 | match(input,31,FOLLOW_2); if (state.failed) return ; | ||
5331 | |||
5332 | } | ||
5333 | |||
5334 | if ( state.backtracking==0 ) { | ||
5335 | after(grammarAccess.getALSNumericOperatorAccess().getDivEnumLiteralDeclaration_4()); | ||
5336 | } | ||
5337 | |||
5338 | } | ||
5339 | |||
5340 | |||
5341 | } | ||
5342 | break; | ||
5343 | |||
5344 | } | ||
5345 | } | ||
5346 | catch (RecognitionException re) { | ||
5347 | reportError(re); | ||
5348 | recover(input,re); | ||
5349 | } | ||
5350 | finally { | ||
5351 | |||
5352 | restoreStackSize(stackSize); | ||
5353 | |||
5354 | } | ||
5355 | return ; | ||
5356 | } | ||
5357 | // $ANTLR end "rule__ALSNumericOperator__Alternatives" | ||
5358 | |||
5359 | |||
5360 | // $ANTLR start "rule__ALSDocument__Group__0" | ||
5361 | // InternalAlloyLanguage.g:1576:1: rule__ALSDocument__Group__0 : rule__ALSDocument__Group__0__Impl rule__ALSDocument__Group__1 ; | ||
5362 | public final void rule__ALSDocument__Group__0() throws RecognitionException { | ||
5363 | |||
5364 | int stackSize = keepStackSize(); | ||
5365 | |||
5366 | try { | ||
5367 | // InternalAlloyLanguage.g:1580:1: ( rule__ALSDocument__Group__0__Impl rule__ALSDocument__Group__1 ) | ||
5368 | // InternalAlloyLanguage.g:1581:2: rule__ALSDocument__Group__0__Impl rule__ALSDocument__Group__1 | ||
5369 | { | ||
5370 | pushFollow(FOLLOW_3); | ||
5371 | rule__ALSDocument__Group__0__Impl(); | ||
5372 | |||
5373 | state._fsp--; | ||
5374 | if (state.failed) return ; | ||
5375 | pushFollow(FOLLOW_2); | ||
5376 | rule__ALSDocument__Group__1(); | ||
5377 | |||
5378 | state._fsp--; | ||
5379 | if (state.failed) return ; | ||
5380 | |||
5381 | } | ||
5382 | |||
5383 | } | ||
5384 | catch (RecognitionException re) { | ||
5385 | reportError(re); | ||
5386 | recover(input,re); | ||
5387 | } | ||
5388 | finally { | ||
5389 | |||
5390 | restoreStackSize(stackSize); | ||
5391 | |||
5392 | } | ||
5393 | return ; | ||
5394 | } | ||
5395 | // $ANTLR end "rule__ALSDocument__Group__0" | ||
5396 | |||
5397 | |||
5398 | // $ANTLR start "rule__ALSDocument__Group__0__Impl" | ||
5399 | // InternalAlloyLanguage.g:1588:1: rule__ALSDocument__Group__0__Impl : ( ( ( rule__ALSDocument__Alternatives_0 ) ) ( ( rule__ALSDocument__Alternatives_0 )* ) ) ; | ||
5400 | public final void rule__ALSDocument__Group__0__Impl() throws RecognitionException { | ||
5401 | |||
5402 | int stackSize = keepStackSize(); | ||
5403 | |||
5404 | try { | ||
5405 | // InternalAlloyLanguage.g:1592:1: ( ( ( ( rule__ALSDocument__Alternatives_0 ) ) ( ( rule__ALSDocument__Alternatives_0 )* ) ) ) | ||
5406 | // InternalAlloyLanguage.g:1593:1: ( ( ( rule__ALSDocument__Alternatives_0 ) ) ( ( rule__ALSDocument__Alternatives_0 )* ) ) | ||
5407 | { | ||
5408 | // InternalAlloyLanguage.g:1593:1: ( ( ( rule__ALSDocument__Alternatives_0 ) ) ( ( rule__ALSDocument__Alternatives_0 )* ) ) | ||
5409 | // InternalAlloyLanguage.g:1594:1: ( ( rule__ALSDocument__Alternatives_0 ) ) ( ( rule__ALSDocument__Alternatives_0 )* ) | ||
5410 | { | ||
5411 | // InternalAlloyLanguage.g:1594:1: ( ( rule__ALSDocument__Alternatives_0 ) ) | ||
5412 | // InternalAlloyLanguage.g:1595:1: ( rule__ALSDocument__Alternatives_0 ) | ||
5413 | { | ||
5414 | if ( state.backtracking==0 ) { | ||
5415 | before(grammarAccess.getALSDocumentAccess().getAlternatives_0()); | ||
5416 | } | ||
5417 | // InternalAlloyLanguage.g:1596:1: ( rule__ALSDocument__Alternatives_0 ) | ||
5418 | // InternalAlloyLanguage.g:1596:2: rule__ALSDocument__Alternatives_0 | ||
5419 | { | ||
5420 | pushFollow(FOLLOW_4); | ||
5421 | rule__ALSDocument__Alternatives_0(); | ||
5422 | |||
5423 | state._fsp--; | ||
5424 | if (state.failed) return ; | ||
5425 | |||
5426 | } | ||
5427 | |||
5428 | if ( state.backtracking==0 ) { | ||
5429 | after(grammarAccess.getALSDocumentAccess().getAlternatives_0()); | ||
5430 | } | ||
5431 | |||
5432 | } | ||
5433 | |||
5434 | // InternalAlloyLanguage.g:1599:1: ( ( rule__ALSDocument__Alternatives_0 )* ) | ||
5435 | // InternalAlloyLanguage.g:1600:1: ( rule__ALSDocument__Alternatives_0 )* | ||
5436 | { | ||
5437 | if ( state.backtracking==0 ) { | ||
5438 | before(grammarAccess.getALSDocumentAccess().getAlternatives_0()); | ||
5439 | } | ||
5440 | // InternalAlloyLanguage.g:1601:1: ( rule__ALSDocument__Alternatives_0 )* | ||
5441 | loop17: | ||
5442 | do { | ||
5443 | int alt17=2; | ||
5444 | int LA17_0 = input.LA(1); | ||
5445 | |||
5446 | if ( ((LA17_0>=21 && LA17_0<=26)||LA17_0==32||LA17_0==36||LA17_0==41||(LA17_0>=44 && LA17_0<=45)||LA17_0==73) ) { | ||
5447 | alt17=1; | ||
5448 | } | ||
5449 | |||
5450 | |||
5451 | switch (alt17) { | ||
5452 | case 1 : | ||
5453 | // InternalAlloyLanguage.g:1601:2: rule__ALSDocument__Alternatives_0 | ||
5454 | { | ||
5455 | pushFollow(FOLLOW_4); | ||
5456 | rule__ALSDocument__Alternatives_0(); | ||
5457 | |||
5458 | state._fsp--; | ||
5459 | if (state.failed) return ; | ||
5460 | |||
5461 | } | ||
5462 | break; | ||
5463 | |||
5464 | default : | ||
5465 | break loop17; | ||
5466 | } | ||
5467 | } while (true); | ||
5468 | |||
5469 | if ( state.backtracking==0 ) { | ||
5470 | after(grammarAccess.getALSDocumentAccess().getAlternatives_0()); | ||
5471 | } | ||
5472 | |||
5473 | } | ||
5474 | |||
5475 | |||
5476 | } | ||
5477 | |||
5478 | |||
5479 | } | ||
5480 | |||
5481 | } | ||
5482 | catch (RecognitionException re) { | ||
5483 | reportError(re); | ||
5484 | recover(input,re); | ||
5485 | } | ||
5486 | finally { | ||
5487 | |||
5488 | restoreStackSize(stackSize); | ||
5489 | |||
5490 | } | ||
5491 | return ; | ||
5492 | } | ||
5493 | // $ANTLR end "rule__ALSDocument__Group__0__Impl" | ||
5494 | |||
5495 | |||
5496 | // $ANTLR start "rule__ALSDocument__Group__1" | ||
5497 | // InternalAlloyLanguage.g:1612:1: rule__ALSDocument__Group__1 : rule__ALSDocument__Group__1__Impl ; | ||
5498 | public final void rule__ALSDocument__Group__1() throws RecognitionException { | ||
5499 | |||
5500 | int stackSize = keepStackSize(); | ||
5501 | |||
5502 | try { | ||
5503 | // InternalAlloyLanguage.g:1616:1: ( rule__ALSDocument__Group__1__Impl ) | ||
5504 | // InternalAlloyLanguage.g:1617:2: rule__ALSDocument__Group__1__Impl | ||
5505 | { | ||
5506 | pushFollow(FOLLOW_2); | ||
5507 | rule__ALSDocument__Group__1__Impl(); | ||
5508 | |||
5509 | state._fsp--; | ||
5510 | if (state.failed) return ; | ||
5511 | |||
5512 | } | ||
5513 | |||
5514 | } | ||
5515 | catch (RecognitionException re) { | ||
5516 | reportError(re); | ||
5517 | recover(input,re); | ||
5518 | } | ||
5519 | finally { | ||
5520 | |||
5521 | restoreStackSize(stackSize); | ||
5522 | |||
5523 | } | ||
5524 | return ; | ||
5525 | } | ||
5526 | // $ANTLR end "rule__ALSDocument__Group__1" | ||
5527 | |||
5528 | |||
5529 | // $ANTLR start "rule__ALSDocument__Group__1__Impl" | ||
5530 | // InternalAlloyLanguage.g:1623:1: rule__ALSDocument__Group__1__Impl : ( ( rule__ALSDocument__RunCommandAssignment_1 ) ) ; | ||
5531 | public final void rule__ALSDocument__Group__1__Impl() throws RecognitionException { | ||
5532 | |||
5533 | int stackSize = keepStackSize(); | ||
5534 | |||
5535 | try { | ||
5536 | // InternalAlloyLanguage.g:1627:1: ( ( ( rule__ALSDocument__RunCommandAssignment_1 ) ) ) | ||
5537 | // InternalAlloyLanguage.g:1628:1: ( ( rule__ALSDocument__RunCommandAssignment_1 ) ) | ||
5538 | { | ||
5539 | // InternalAlloyLanguage.g:1628:1: ( ( rule__ALSDocument__RunCommandAssignment_1 ) ) | ||
5540 | // InternalAlloyLanguage.g:1629:1: ( rule__ALSDocument__RunCommandAssignment_1 ) | ||
5541 | { | ||
5542 | if ( state.backtracking==0 ) { | ||
5543 | before(grammarAccess.getALSDocumentAccess().getRunCommandAssignment_1()); | ||
5544 | } | ||
5545 | // InternalAlloyLanguage.g:1630:1: ( rule__ALSDocument__RunCommandAssignment_1 ) | ||
5546 | // InternalAlloyLanguage.g:1630:2: rule__ALSDocument__RunCommandAssignment_1 | ||
5547 | { | ||
5548 | pushFollow(FOLLOW_2); | ||
5549 | rule__ALSDocument__RunCommandAssignment_1(); | ||
5550 | |||
5551 | state._fsp--; | ||
5552 | if (state.failed) return ; | ||
5553 | |||
5554 | } | ||
5555 | |||
5556 | if ( state.backtracking==0 ) { | ||
5557 | after(grammarAccess.getALSDocumentAccess().getRunCommandAssignment_1()); | ||
5558 | } | ||
5559 | |||
5560 | } | ||
5561 | |||
5562 | |||
5563 | } | ||
5564 | |||
5565 | } | ||
5566 | catch (RecognitionException re) { | ||
5567 | reportError(re); | ||
5568 | recover(input,re); | ||
5569 | } | ||
5570 | finally { | ||
5571 | |||
5572 | restoreStackSize(stackSize); | ||
5573 | |||
5574 | } | ||
5575 | return ; | ||
5576 | } | ||
5577 | // $ANTLR end "rule__ALSDocument__Group__1__Impl" | ||
5578 | |||
5579 | |||
5580 | // $ANTLR start "rule__ALSEnumDeclaration__Group__0" | ||
5581 | // InternalAlloyLanguage.g:1644:1: rule__ALSEnumDeclaration__Group__0 : rule__ALSEnumDeclaration__Group__0__Impl rule__ALSEnumDeclaration__Group__1 ; | ||
5582 | public final void rule__ALSEnumDeclaration__Group__0() throws RecognitionException { | ||
5583 | |||
5584 | int stackSize = keepStackSize(); | ||
5585 | |||
5586 | try { | ||
5587 | // InternalAlloyLanguage.g:1648:1: ( rule__ALSEnumDeclaration__Group__0__Impl rule__ALSEnumDeclaration__Group__1 ) | ||
5588 | // InternalAlloyLanguage.g:1649:2: rule__ALSEnumDeclaration__Group__0__Impl rule__ALSEnumDeclaration__Group__1 | ||
5589 | { | ||
5590 | pushFollow(FOLLOW_5); | ||
5591 | rule__ALSEnumDeclaration__Group__0__Impl(); | ||
5592 | |||
5593 | state._fsp--; | ||
5594 | if (state.failed) return ; | ||
5595 | pushFollow(FOLLOW_2); | ||
5596 | rule__ALSEnumDeclaration__Group__1(); | ||
5597 | |||
5598 | state._fsp--; | ||
5599 | if (state.failed) return ; | ||
5600 | |||
5601 | } | ||
5602 | |||
5603 | } | ||
5604 | catch (RecognitionException re) { | ||
5605 | reportError(re); | ||
5606 | recover(input,re); | ||
5607 | } | ||
5608 | finally { | ||
5609 | |||
5610 | restoreStackSize(stackSize); | ||
5611 | |||
5612 | } | ||
5613 | return ; | ||
5614 | } | ||
5615 | // $ANTLR end "rule__ALSEnumDeclaration__Group__0" | ||
5616 | |||
5617 | |||
5618 | // $ANTLR start "rule__ALSEnumDeclaration__Group__0__Impl" | ||
5619 | // InternalAlloyLanguage.g:1656:1: rule__ALSEnumDeclaration__Group__0__Impl : ( 'enum' ) ; | ||
5620 | public final void rule__ALSEnumDeclaration__Group__0__Impl() throws RecognitionException { | ||
5621 | |||
5622 | int stackSize = keepStackSize(); | ||
5623 | |||
5624 | try { | ||
5625 | // InternalAlloyLanguage.g:1660:1: ( ( 'enum' ) ) | ||
5626 | // InternalAlloyLanguage.g:1661:1: ( 'enum' ) | ||
5627 | { | ||
5628 | // InternalAlloyLanguage.g:1661:1: ( 'enum' ) | ||
5629 | // InternalAlloyLanguage.g:1662:1: 'enum' | ||
5630 | { | ||
5631 | if ( state.backtracking==0 ) { | ||
5632 | before(grammarAccess.getALSEnumDeclarationAccess().getEnumKeyword_0()); | ||
5633 | } | ||
5634 | match(input,32,FOLLOW_2); if (state.failed) return ; | ||
5635 | if ( state.backtracking==0 ) { | ||
5636 | after(grammarAccess.getALSEnumDeclarationAccess().getEnumKeyword_0()); | ||
5637 | } | ||
5638 | |||
5639 | } | ||
5640 | |||
5641 | |||
5642 | } | ||
5643 | |||
5644 | } | ||
5645 | catch (RecognitionException re) { | ||
5646 | reportError(re); | ||
5647 | recover(input,re); | ||
5648 | } | ||
5649 | finally { | ||
5650 | |||
5651 | restoreStackSize(stackSize); | ||
5652 | |||
5653 | } | ||
5654 | return ; | ||
5655 | } | ||
5656 | // $ANTLR end "rule__ALSEnumDeclaration__Group__0__Impl" | ||
5657 | |||
5658 | |||
5659 | // $ANTLR start "rule__ALSEnumDeclaration__Group__1" | ||
5660 | // InternalAlloyLanguage.g:1675:1: rule__ALSEnumDeclaration__Group__1 : rule__ALSEnumDeclaration__Group__1__Impl rule__ALSEnumDeclaration__Group__2 ; | ||
5661 | public final void rule__ALSEnumDeclaration__Group__1() throws RecognitionException { | ||
5662 | |||
5663 | int stackSize = keepStackSize(); | ||
5664 | |||
5665 | try { | ||
5666 | // InternalAlloyLanguage.g:1679:1: ( rule__ALSEnumDeclaration__Group__1__Impl rule__ALSEnumDeclaration__Group__2 ) | ||
5667 | // InternalAlloyLanguage.g:1680:2: rule__ALSEnumDeclaration__Group__1__Impl rule__ALSEnumDeclaration__Group__2 | ||
5668 | { | ||
5669 | pushFollow(FOLLOW_6); | ||
5670 | rule__ALSEnumDeclaration__Group__1__Impl(); | ||
5671 | |||
5672 | state._fsp--; | ||
5673 | if (state.failed) return ; | ||
5674 | pushFollow(FOLLOW_2); | ||
5675 | rule__ALSEnumDeclaration__Group__2(); | ||
5676 | |||
5677 | state._fsp--; | ||
5678 | if (state.failed) return ; | ||
5679 | |||
5680 | } | ||
5681 | |||
5682 | } | ||
5683 | catch (RecognitionException re) { | ||
5684 | reportError(re); | ||
5685 | recover(input,re); | ||
5686 | } | ||
5687 | finally { | ||
5688 | |||
5689 | restoreStackSize(stackSize); | ||
5690 | |||
5691 | } | ||
5692 | return ; | ||
5693 | } | ||
5694 | // $ANTLR end "rule__ALSEnumDeclaration__Group__1" | ||
5695 | |||
5696 | |||
5697 | // $ANTLR start "rule__ALSEnumDeclaration__Group__1__Impl" | ||
5698 | // InternalAlloyLanguage.g:1687:1: rule__ALSEnumDeclaration__Group__1__Impl : ( ( rule__ALSEnumDeclaration__NameAssignment_1 ) ) ; | ||
5699 | public final void rule__ALSEnumDeclaration__Group__1__Impl() throws RecognitionException { | ||
5700 | |||
5701 | int stackSize = keepStackSize(); | ||
5702 | |||
5703 | try { | ||
5704 | // InternalAlloyLanguage.g:1691:1: ( ( ( rule__ALSEnumDeclaration__NameAssignment_1 ) ) ) | ||
5705 | // InternalAlloyLanguage.g:1692:1: ( ( rule__ALSEnumDeclaration__NameAssignment_1 ) ) | ||
5706 | { | ||
5707 | // InternalAlloyLanguage.g:1692:1: ( ( rule__ALSEnumDeclaration__NameAssignment_1 ) ) | ||
5708 | // InternalAlloyLanguage.g:1693:1: ( rule__ALSEnumDeclaration__NameAssignment_1 ) | ||
5709 | { | ||
5710 | if ( state.backtracking==0 ) { | ||
5711 | before(grammarAccess.getALSEnumDeclarationAccess().getNameAssignment_1()); | ||
5712 | } | ||
5713 | // InternalAlloyLanguage.g:1694:1: ( rule__ALSEnumDeclaration__NameAssignment_1 ) | ||
5714 | // InternalAlloyLanguage.g:1694:2: rule__ALSEnumDeclaration__NameAssignment_1 | ||
5715 | { | ||
5716 | pushFollow(FOLLOW_2); | ||
5717 | rule__ALSEnumDeclaration__NameAssignment_1(); | ||
5718 | |||
5719 | state._fsp--; | ||
5720 | if (state.failed) return ; | ||
5721 | |||
5722 | } | ||
5723 | |||
5724 | if ( state.backtracking==0 ) { | ||
5725 | after(grammarAccess.getALSEnumDeclarationAccess().getNameAssignment_1()); | ||
5726 | } | ||
5727 | |||
5728 | } | ||
5729 | |||
5730 | |||
5731 | } | ||
5732 | |||
5733 | } | ||
5734 | catch (RecognitionException re) { | ||
5735 | reportError(re); | ||
5736 | recover(input,re); | ||
5737 | } | ||
5738 | finally { | ||
5739 | |||
5740 | restoreStackSize(stackSize); | ||
5741 | |||
5742 | } | ||
5743 | return ; | ||
5744 | } | ||
5745 | // $ANTLR end "rule__ALSEnumDeclaration__Group__1__Impl" | ||
5746 | |||
5747 | |||
5748 | // $ANTLR start "rule__ALSEnumDeclaration__Group__2" | ||
5749 | // InternalAlloyLanguage.g:1704:1: rule__ALSEnumDeclaration__Group__2 : rule__ALSEnumDeclaration__Group__2__Impl rule__ALSEnumDeclaration__Group__3 ; | ||
5750 | public final void rule__ALSEnumDeclaration__Group__2() throws RecognitionException { | ||
5751 | |||
5752 | int stackSize = keepStackSize(); | ||
5753 | |||
5754 | try { | ||
5755 | // InternalAlloyLanguage.g:1708:1: ( rule__ALSEnumDeclaration__Group__2__Impl rule__ALSEnumDeclaration__Group__3 ) | ||
5756 | // InternalAlloyLanguage.g:1709:2: rule__ALSEnumDeclaration__Group__2__Impl rule__ALSEnumDeclaration__Group__3 | ||
5757 | { | ||
5758 | pushFollow(FOLLOW_5); | ||
5759 | rule__ALSEnumDeclaration__Group__2__Impl(); | ||
5760 | |||
5761 | state._fsp--; | ||
5762 | if (state.failed) return ; | ||
5763 | pushFollow(FOLLOW_2); | ||
5764 | rule__ALSEnumDeclaration__Group__3(); | ||
5765 | |||
5766 | state._fsp--; | ||
5767 | if (state.failed) return ; | ||
5768 | |||
5769 | } | ||
5770 | |||
5771 | } | ||
5772 | catch (RecognitionException re) { | ||
5773 | reportError(re); | ||
5774 | recover(input,re); | ||
5775 | } | ||
5776 | finally { | ||
5777 | |||
5778 | restoreStackSize(stackSize); | ||
5779 | |||
5780 | } | ||
5781 | return ; | ||
5782 | } | ||
5783 | // $ANTLR end "rule__ALSEnumDeclaration__Group__2" | ||
5784 | |||
5785 | |||
5786 | // $ANTLR start "rule__ALSEnumDeclaration__Group__2__Impl" | ||
5787 | // InternalAlloyLanguage.g:1716:1: rule__ALSEnumDeclaration__Group__2__Impl : ( '{' ) ; | ||
5788 | public final void rule__ALSEnumDeclaration__Group__2__Impl() throws RecognitionException { | ||
5789 | |||
5790 | int stackSize = keepStackSize(); | ||
5791 | |||
5792 | try { | ||
5793 | // InternalAlloyLanguage.g:1720:1: ( ( '{' ) ) | ||
5794 | // InternalAlloyLanguage.g:1721:1: ( '{' ) | ||
5795 | { | ||
5796 | // InternalAlloyLanguage.g:1721:1: ( '{' ) | ||
5797 | // InternalAlloyLanguage.g:1722:1: '{' | ||
5798 | { | ||
5799 | if ( state.backtracking==0 ) { | ||
5800 | before(grammarAccess.getALSEnumDeclarationAccess().getLeftCurlyBracketKeyword_2()); | ||
5801 | } | ||
5802 | match(input,33,FOLLOW_2); if (state.failed) return ; | ||
5803 | if ( state.backtracking==0 ) { | ||
5804 | after(grammarAccess.getALSEnumDeclarationAccess().getLeftCurlyBracketKeyword_2()); | ||
5805 | } | ||
5806 | |||
5807 | } | ||
5808 | |||
5809 | |||
5810 | } | ||
5811 | |||
5812 | } | ||
5813 | catch (RecognitionException re) { | ||
5814 | reportError(re); | ||
5815 | recover(input,re); | ||
5816 | } | ||
5817 | finally { | ||
5818 | |||
5819 | restoreStackSize(stackSize); | ||
5820 | |||
5821 | } | ||
5822 | return ; | ||
5823 | } | ||
5824 | // $ANTLR end "rule__ALSEnumDeclaration__Group__2__Impl" | ||
5825 | |||
5826 | |||
5827 | // $ANTLR start "rule__ALSEnumDeclaration__Group__3" | ||
5828 | // InternalAlloyLanguage.g:1735:1: rule__ALSEnumDeclaration__Group__3 : rule__ALSEnumDeclaration__Group__3__Impl rule__ALSEnumDeclaration__Group__4 ; | ||
5829 | public final void rule__ALSEnumDeclaration__Group__3() throws RecognitionException { | ||
5830 | |||
5831 | int stackSize = keepStackSize(); | ||
5832 | |||
5833 | try { | ||
5834 | // InternalAlloyLanguage.g:1739:1: ( rule__ALSEnumDeclaration__Group__3__Impl rule__ALSEnumDeclaration__Group__4 ) | ||
5835 | // InternalAlloyLanguage.g:1740:2: rule__ALSEnumDeclaration__Group__3__Impl rule__ALSEnumDeclaration__Group__4 | ||
5836 | { | ||
5837 | pushFollow(FOLLOW_7); | ||
5838 | rule__ALSEnumDeclaration__Group__3__Impl(); | ||
5839 | |||
5840 | state._fsp--; | ||
5841 | if (state.failed) return ; | ||
5842 | pushFollow(FOLLOW_2); | ||
5843 | rule__ALSEnumDeclaration__Group__4(); | ||
5844 | |||
5845 | state._fsp--; | ||
5846 | if (state.failed) return ; | ||
5847 | |||
5848 | } | ||
5849 | |||
5850 | } | ||
5851 | catch (RecognitionException re) { | ||
5852 | reportError(re); | ||
5853 | recover(input,re); | ||
5854 | } | ||
5855 | finally { | ||
5856 | |||
5857 | restoreStackSize(stackSize); | ||
5858 | |||
5859 | } | ||
5860 | return ; | ||
5861 | } | ||
5862 | // $ANTLR end "rule__ALSEnumDeclaration__Group__3" | ||
5863 | |||
5864 | |||
5865 | // $ANTLR start "rule__ALSEnumDeclaration__Group__3__Impl" | ||
5866 | // InternalAlloyLanguage.g:1747:1: rule__ALSEnumDeclaration__Group__3__Impl : ( ( rule__ALSEnumDeclaration__LiteralAssignment_3 ) ) ; | ||
5867 | public final void rule__ALSEnumDeclaration__Group__3__Impl() throws RecognitionException { | ||
5868 | |||
5869 | int stackSize = keepStackSize(); | ||
5870 | |||
5871 | try { | ||
5872 | // InternalAlloyLanguage.g:1751:1: ( ( ( rule__ALSEnumDeclaration__LiteralAssignment_3 ) ) ) | ||
5873 | // InternalAlloyLanguage.g:1752:1: ( ( rule__ALSEnumDeclaration__LiteralAssignment_3 ) ) | ||
5874 | { | ||
5875 | // InternalAlloyLanguage.g:1752:1: ( ( rule__ALSEnumDeclaration__LiteralAssignment_3 ) ) | ||
5876 | // InternalAlloyLanguage.g:1753:1: ( rule__ALSEnumDeclaration__LiteralAssignment_3 ) | ||
5877 | { | ||
5878 | if ( state.backtracking==0 ) { | ||
5879 | before(grammarAccess.getALSEnumDeclarationAccess().getLiteralAssignment_3()); | ||
5880 | } | ||
5881 | // InternalAlloyLanguage.g:1754:1: ( rule__ALSEnumDeclaration__LiteralAssignment_3 ) | ||
5882 | // InternalAlloyLanguage.g:1754:2: rule__ALSEnumDeclaration__LiteralAssignment_3 | ||
5883 | { | ||
5884 | pushFollow(FOLLOW_2); | ||
5885 | rule__ALSEnumDeclaration__LiteralAssignment_3(); | ||
5886 | |||
5887 | state._fsp--; | ||
5888 | if (state.failed) return ; | ||
5889 | |||
5890 | } | ||
5891 | |||
5892 | if ( state.backtracking==0 ) { | ||
5893 | after(grammarAccess.getALSEnumDeclarationAccess().getLiteralAssignment_3()); | ||
5894 | } | ||
5895 | |||
5896 | } | ||
5897 | |||
5898 | |||
5899 | } | ||
5900 | |||
5901 | } | ||
5902 | catch (RecognitionException re) { | ||
5903 | reportError(re); | ||
5904 | recover(input,re); | ||
5905 | } | ||
5906 | finally { | ||
5907 | |||
5908 | restoreStackSize(stackSize); | ||
5909 | |||
5910 | } | ||
5911 | return ; | ||
5912 | } | ||
5913 | // $ANTLR end "rule__ALSEnumDeclaration__Group__3__Impl" | ||
5914 | |||
5915 | |||
5916 | // $ANTLR start "rule__ALSEnumDeclaration__Group__4" | ||
5917 | // InternalAlloyLanguage.g:1764:1: rule__ALSEnumDeclaration__Group__4 : rule__ALSEnumDeclaration__Group__4__Impl rule__ALSEnumDeclaration__Group__5 ; | ||
5918 | public final void rule__ALSEnumDeclaration__Group__4() throws RecognitionException { | ||
5919 | |||
5920 | int stackSize = keepStackSize(); | ||
5921 | |||
5922 | try { | ||
5923 | // InternalAlloyLanguage.g:1768:1: ( rule__ALSEnumDeclaration__Group__4__Impl rule__ALSEnumDeclaration__Group__5 ) | ||
5924 | // InternalAlloyLanguage.g:1769:2: rule__ALSEnumDeclaration__Group__4__Impl rule__ALSEnumDeclaration__Group__5 | ||
5925 | { | ||
5926 | pushFollow(FOLLOW_7); | ||
5927 | rule__ALSEnumDeclaration__Group__4__Impl(); | ||
5928 | |||
5929 | state._fsp--; | ||
5930 | if (state.failed) return ; | ||
5931 | pushFollow(FOLLOW_2); | ||
5932 | rule__ALSEnumDeclaration__Group__5(); | ||
5933 | |||
5934 | state._fsp--; | ||
5935 | if (state.failed) return ; | ||
5936 | |||
5937 | } | ||
5938 | |||
5939 | } | ||
5940 | catch (RecognitionException re) { | ||
5941 | reportError(re); | ||
5942 | recover(input,re); | ||
5943 | } | ||
5944 | finally { | ||
5945 | |||
5946 | restoreStackSize(stackSize); | ||
5947 | |||
5948 | } | ||
5949 | return ; | ||
5950 | } | ||
5951 | // $ANTLR end "rule__ALSEnumDeclaration__Group__4" | ||
5952 | |||
5953 | |||
5954 | // $ANTLR start "rule__ALSEnumDeclaration__Group__4__Impl" | ||
5955 | // InternalAlloyLanguage.g:1776:1: rule__ALSEnumDeclaration__Group__4__Impl : ( ( rule__ALSEnumDeclaration__Group_4__0 )* ) ; | ||
5956 | public final void rule__ALSEnumDeclaration__Group__4__Impl() throws RecognitionException { | ||
5957 | |||
5958 | int stackSize = keepStackSize(); | ||
5959 | |||
5960 | try { | ||
5961 | // InternalAlloyLanguage.g:1780:1: ( ( ( rule__ALSEnumDeclaration__Group_4__0 )* ) ) | ||
5962 | // InternalAlloyLanguage.g:1781:1: ( ( rule__ALSEnumDeclaration__Group_4__0 )* ) | ||
5963 | { | ||
5964 | // InternalAlloyLanguage.g:1781:1: ( ( rule__ALSEnumDeclaration__Group_4__0 )* ) | ||
5965 | // InternalAlloyLanguage.g:1782:1: ( rule__ALSEnumDeclaration__Group_4__0 )* | ||
5966 | { | ||
5967 | if ( state.backtracking==0 ) { | ||
5968 | before(grammarAccess.getALSEnumDeclarationAccess().getGroup_4()); | ||
5969 | } | ||
5970 | // InternalAlloyLanguage.g:1783:1: ( rule__ALSEnumDeclaration__Group_4__0 )* | ||
5971 | loop18: | ||
5972 | do { | ||
5973 | int alt18=2; | ||
5974 | int LA18_0 = input.LA(1); | ||
5975 | |||
5976 | if ( (LA18_0==35) ) { | ||
5977 | alt18=1; | ||
5978 | } | ||
5979 | |||
5980 | |||
5981 | switch (alt18) { | ||
5982 | case 1 : | ||
5983 | // InternalAlloyLanguage.g:1783:2: rule__ALSEnumDeclaration__Group_4__0 | ||
5984 | { | ||
5985 | pushFollow(FOLLOW_8); | ||
5986 | rule__ALSEnumDeclaration__Group_4__0(); | ||
5987 | |||
5988 | state._fsp--; | ||
5989 | if (state.failed) return ; | ||
5990 | |||
5991 | } | ||
5992 | break; | ||
5993 | |||
5994 | default : | ||
5995 | break loop18; | ||
5996 | } | ||
5997 | } while (true); | ||
5998 | |||
5999 | if ( state.backtracking==0 ) { | ||
6000 | after(grammarAccess.getALSEnumDeclarationAccess().getGroup_4()); | ||
6001 | } | ||
6002 | |||
6003 | } | ||
6004 | |||
6005 | |||
6006 | } | ||
6007 | |||
6008 | } | ||
6009 | catch (RecognitionException re) { | ||
6010 | reportError(re); | ||
6011 | recover(input,re); | ||
6012 | } | ||
6013 | finally { | ||
6014 | |||
6015 | restoreStackSize(stackSize); | ||
6016 | |||
6017 | } | ||
6018 | return ; | ||
6019 | } | ||
6020 | // $ANTLR end "rule__ALSEnumDeclaration__Group__4__Impl" | ||
6021 | |||
6022 | |||
6023 | // $ANTLR start "rule__ALSEnumDeclaration__Group__5" | ||
6024 | // InternalAlloyLanguage.g:1793:1: rule__ALSEnumDeclaration__Group__5 : rule__ALSEnumDeclaration__Group__5__Impl ; | ||
6025 | public final void rule__ALSEnumDeclaration__Group__5() throws RecognitionException { | ||
6026 | |||
6027 | int stackSize = keepStackSize(); | ||
6028 | |||
6029 | try { | ||
6030 | // InternalAlloyLanguage.g:1797:1: ( rule__ALSEnumDeclaration__Group__5__Impl ) | ||
6031 | // InternalAlloyLanguage.g:1798:2: rule__ALSEnumDeclaration__Group__5__Impl | ||
6032 | { | ||
6033 | pushFollow(FOLLOW_2); | ||
6034 | rule__ALSEnumDeclaration__Group__5__Impl(); | ||
6035 | |||
6036 | state._fsp--; | ||
6037 | if (state.failed) return ; | ||
6038 | |||
6039 | } | ||
6040 | |||
6041 | } | ||
6042 | catch (RecognitionException re) { | ||
6043 | reportError(re); | ||
6044 | recover(input,re); | ||
6045 | } | ||
6046 | finally { | ||
6047 | |||
6048 | restoreStackSize(stackSize); | ||
6049 | |||
6050 | } | ||
6051 | return ; | ||
6052 | } | ||
6053 | // $ANTLR end "rule__ALSEnumDeclaration__Group__5" | ||
6054 | |||
6055 | |||
6056 | // $ANTLR start "rule__ALSEnumDeclaration__Group__5__Impl" | ||
6057 | // InternalAlloyLanguage.g:1804:1: rule__ALSEnumDeclaration__Group__5__Impl : ( '}' ) ; | ||
6058 | public final void rule__ALSEnumDeclaration__Group__5__Impl() throws RecognitionException { | ||
6059 | |||
6060 | int stackSize = keepStackSize(); | ||
6061 | |||
6062 | try { | ||
6063 | // InternalAlloyLanguage.g:1808:1: ( ( '}' ) ) | ||
6064 | // InternalAlloyLanguage.g:1809:1: ( '}' ) | ||
6065 | { | ||
6066 | // InternalAlloyLanguage.g:1809:1: ( '}' ) | ||
6067 | // InternalAlloyLanguage.g:1810:1: '}' | ||
6068 | { | ||
6069 | if ( state.backtracking==0 ) { | ||
6070 | before(grammarAccess.getALSEnumDeclarationAccess().getRightCurlyBracketKeyword_5()); | ||
6071 | } | ||
6072 | match(input,34,FOLLOW_2); if (state.failed) return ; | ||
6073 | if ( state.backtracking==0 ) { | ||
6074 | after(grammarAccess.getALSEnumDeclarationAccess().getRightCurlyBracketKeyword_5()); | ||
6075 | } | ||
6076 | |||
6077 | } | ||
6078 | |||
6079 | |||
6080 | } | ||
6081 | |||
6082 | } | ||
6083 | catch (RecognitionException re) { | ||
6084 | reportError(re); | ||
6085 | recover(input,re); | ||
6086 | } | ||
6087 | finally { | ||
6088 | |||
6089 | restoreStackSize(stackSize); | ||
6090 | |||
6091 | } | ||
6092 | return ; | ||
6093 | } | ||
6094 | // $ANTLR end "rule__ALSEnumDeclaration__Group__5__Impl" | ||
6095 | |||
6096 | |||
6097 | // $ANTLR start "rule__ALSEnumDeclaration__Group_4__0" | ||
6098 | // InternalAlloyLanguage.g:1835:1: rule__ALSEnumDeclaration__Group_4__0 : rule__ALSEnumDeclaration__Group_4__0__Impl rule__ALSEnumDeclaration__Group_4__1 ; | ||
6099 | public final void rule__ALSEnumDeclaration__Group_4__0() throws RecognitionException { | ||
6100 | |||
6101 | int stackSize = keepStackSize(); | ||
6102 | |||
6103 | try { | ||
6104 | // InternalAlloyLanguage.g:1839:1: ( rule__ALSEnumDeclaration__Group_4__0__Impl rule__ALSEnumDeclaration__Group_4__1 ) | ||
6105 | // InternalAlloyLanguage.g:1840:2: rule__ALSEnumDeclaration__Group_4__0__Impl rule__ALSEnumDeclaration__Group_4__1 | ||
6106 | { | ||
6107 | pushFollow(FOLLOW_5); | ||
6108 | rule__ALSEnumDeclaration__Group_4__0__Impl(); | ||
6109 | |||
6110 | state._fsp--; | ||
6111 | if (state.failed) return ; | ||
6112 | pushFollow(FOLLOW_2); | ||
6113 | rule__ALSEnumDeclaration__Group_4__1(); | ||
6114 | |||
6115 | state._fsp--; | ||
6116 | if (state.failed) return ; | ||
6117 | |||
6118 | } | ||
6119 | |||
6120 | } | ||
6121 | catch (RecognitionException re) { | ||
6122 | reportError(re); | ||
6123 | recover(input,re); | ||
6124 | } | ||
6125 | finally { | ||
6126 | |||
6127 | restoreStackSize(stackSize); | ||
6128 | |||
6129 | } | ||
6130 | return ; | ||
6131 | } | ||
6132 | // $ANTLR end "rule__ALSEnumDeclaration__Group_4__0" | ||
6133 | |||
6134 | |||
6135 | // $ANTLR start "rule__ALSEnumDeclaration__Group_4__0__Impl" | ||
6136 | // InternalAlloyLanguage.g:1847:1: rule__ALSEnumDeclaration__Group_4__0__Impl : ( ',' ) ; | ||
6137 | public final void rule__ALSEnumDeclaration__Group_4__0__Impl() throws RecognitionException { | ||
6138 | |||
6139 | int stackSize = keepStackSize(); | ||
6140 | |||
6141 | try { | ||
6142 | // InternalAlloyLanguage.g:1851:1: ( ( ',' ) ) | ||
6143 | // InternalAlloyLanguage.g:1852:1: ( ',' ) | ||
6144 | { | ||
6145 | // InternalAlloyLanguage.g:1852:1: ( ',' ) | ||
6146 | // InternalAlloyLanguage.g:1853:1: ',' | ||
6147 | { | ||
6148 | if ( state.backtracking==0 ) { | ||
6149 | before(grammarAccess.getALSEnumDeclarationAccess().getCommaKeyword_4_0()); | ||
6150 | } | ||
6151 | match(input,35,FOLLOW_2); if (state.failed) return ; | ||
6152 | if ( state.backtracking==0 ) { | ||
6153 | after(grammarAccess.getALSEnumDeclarationAccess().getCommaKeyword_4_0()); | ||
6154 | } | ||
6155 | |||
6156 | } | ||
6157 | |||
6158 | |||
6159 | } | ||
6160 | |||
6161 | } | ||
6162 | catch (RecognitionException re) { | ||
6163 | reportError(re); | ||
6164 | recover(input,re); | ||
6165 | } | ||
6166 | finally { | ||
6167 | |||
6168 | restoreStackSize(stackSize); | ||
6169 | |||
6170 | } | ||
6171 | return ; | ||
6172 | } | ||
6173 | // $ANTLR end "rule__ALSEnumDeclaration__Group_4__0__Impl" | ||
6174 | |||
6175 | |||
6176 | // $ANTLR start "rule__ALSEnumDeclaration__Group_4__1" | ||
6177 | // InternalAlloyLanguage.g:1866:1: rule__ALSEnumDeclaration__Group_4__1 : rule__ALSEnumDeclaration__Group_4__1__Impl ; | ||
6178 | public final void rule__ALSEnumDeclaration__Group_4__1() throws RecognitionException { | ||
6179 | |||
6180 | int stackSize = keepStackSize(); | ||
6181 | |||
6182 | try { | ||
6183 | // InternalAlloyLanguage.g:1870:1: ( rule__ALSEnumDeclaration__Group_4__1__Impl ) | ||
6184 | // InternalAlloyLanguage.g:1871:2: rule__ALSEnumDeclaration__Group_4__1__Impl | ||
6185 | { | ||
6186 | pushFollow(FOLLOW_2); | ||
6187 | rule__ALSEnumDeclaration__Group_4__1__Impl(); | ||
6188 | |||
6189 | state._fsp--; | ||
6190 | if (state.failed) return ; | ||
6191 | |||
6192 | } | ||
6193 | |||
6194 | } | ||
6195 | catch (RecognitionException re) { | ||
6196 | reportError(re); | ||
6197 | recover(input,re); | ||
6198 | } | ||
6199 | finally { | ||
6200 | |||
6201 | restoreStackSize(stackSize); | ||
6202 | |||
6203 | } | ||
6204 | return ; | ||
6205 | } | ||
6206 | // $ANTLR end "rule__ALSEnumDeclaration__Group_4__1" | ||
6207 | |||
6208 | |||
6209 | // $ANTLR start "rule__ALSEnumDeclaration__Group_4__1__Impl" | ||
6210 | // InternalAlloyLanguage.g:1877:1: rule__ALSEnumDeclaration__Group_4__1__Impl : ( ( rule__ALSEnumDeclaration__LiteralAssignment_4_1 ) ) ; | ||
6211 | public final void rule__ALSEnumDeclaration__Group_4__1__Impl() throws RecognitionException { | ||
6212 | |||
6213 | int stackSize = keepStackSize(); | ||
6214 | |||
6215 | try { | ||
6216 | // InternalAlloyLanguage.g:1881:1: ( ( ( rule__ALSEnumDeclaration__LiteralAssignment_4_1 ) ) ) | ||
6217 | // InternalAlloyLanguage.g:1882:1: ( ( rule__ALSEnumDeclaration__LiteralAssignment_4_1 ) ) | ||
6218 | { | ||
6219 | // InternalAlloyLanguage.g:1882:1: ( ( rule__ALSEnumDeclaration__LiteralAssignment_4_1 ) ) | ||
6220 | // InternalAlloyLanguage.g:1883:1: ( rule__ALSEnumDeclaration__LiteralAssignment_4_1 ) | ||
6221 | { | ||
6222 | if ( state.backtracking==0 ) { | ||
6223 | before(grammarAccess.getALSEnumDeclarationAccess().getLiteralAssignment_4_1()); | ||
6224 | } | ||
6225 | // InternalAlloyLanguage.g:1884:1: ( rule__ALSEnumDeclaration__LiteralAssignment_4_1 ) | ||
6226 | // InternalAlloyLanguage.g:1884:2: rule__ALSEnumDeclaration__LiteralAssignment_4_1 | ||
6227 | { | ||
6228 | pushFollow(FOLLOW_2); | ||
6229 | rule__ALSEnumDeclaration__LiteralAssignment_4_1(); | ||
6230 | |||
6231 | state._fsp--; | ||
6232 | if (state.failed) return ; | ||
6233 | |||
6234 | } | ||
6235 | |||
6236 | if ( state.backtracking==0 ) { | ||
6237 | after(grammarAccess.getALSEnumDeclarationAccess().getLiteralAssignment_4_1()); | ||
6238 | } | ||
6239 | |||
6240 | } | ||
6241 | |||
6242 | |||
6243 | } | ||
6244 | |||
6245 | } | ||
6246 | catch (RecognitionException re) { | ||
6247 | reportError(re); | ||
6248 | recover(input,re); | ||
6249 | } | ||
6250 | finally { | ||
6251 | |||
6252 | restoreStackSize(stackSize); | ||
6253 | |||
6254 | } | ||
6255 | return ; | ||
6256 | } | ||
6257 | // $ANTLR end "rule__ALSEnumDeclaration__Group_4__1__Impl" | ||
6258 | |||
6259 | |||
6260 | // $ANTLR start "rule__ALSSignatureBody__Group__0" | ||
6261 | // InternalAlloyLanguage.g:1898:1: rule__ALSSignatureBody__Group__0 : rule__ALSSignatureBody__Group__0__Impl rule__ALSSignatureBody__Group__1 ; | ||
6262 | public final void rule__ALSSignatureBody__Group__0() throws RecognitionException { | ||
6263 | |||
6264 | int stackSize = keepStackSize(); | ||
6265 | |||
6266 | try { | ||
6267 | // InternalAlloyLanguage.g:1902:1: ( rule__ALSSignatureBody__Group__0__Impl rule__ALSSignatureBody__Group__1 ) | ||
6268 | // InternalAlloyLanguage.g:1903:2: rule__ALSSignatureBody__Group__0__Impl rule__ALSSignatureBody__Group__1 | ||
6269 | { | ||
6270 | pushFollow(FOLLOW_9); | ||
6271 | rule__ALSSignatureBody__Group__0__Impl(); | ||
6272 | |||
6273 | state._fsp--; | ||
6274 | if (state.failed) return ; | ||
6275 | pushFollow(FOLLOW_2); | ||
6276 | rule__ALSSignatureBody__Group__1(); | ||
6277 | |||
6278 | state._fsp--; | ||
6279 | if (state.failed) return ; | ||
6280 | |||
6281 | } | ||
6282 | |||
6283 | } | ||
6284 | catch (RecognitionException re) { | ||
6285 | reportError(re); | ||
6286 | recover(input,re); | ||
6287 | } | ||
6288 | finally { | ||
6289 | |||
6290 | restoreStackSize(stackSize); | ||
6291 | |||
6292 | } | ||
6293 | return ; | ||
6294 | } | ||
6295 | // $ANTLR end "rule__ALSSignatureBody__Group__0" | ||
6296 | |||
6297 | |||
6298 | // $ANTLR start "rule__ALSSignatureBody__Group__0__Impl" | ||
6299 | // InternalAlloyLanguage.g:1910:1: rule__ALSSignatureBody__Group__0__Impl : ( ( rule__ALSSignatureBody__UnorderedGroup_0 ) ) ; | ||
6300 | public final void rule__ALSSignatureBody__Group__0__Impl() throws RecognitionException { | ||
6301 | |||
6302 | int stackSize = keepStackSize(); | ||
6303 | |||
6304 | try { | ||
6305 | // InternalAlloyLanguage.g:1914:1: ( ( ( rule__ALSSignatureBody__UnorderedGroup_0 ) ) ) | ||
6306 | // InternalAlloyLanguage.g:1915:1: ( ( rule__ALSSignatureBody__UnorderedGroup_0 ) ) | ||
6307 | { | ||
6308 | // InternalAlloyLanguage.g:1915:1: ( ( rule__ALSSignatureBody__UnorderedGroup_0 ) ) | ||
6309 | // InternalAlloyLanguage.g:1916:1: ( rule__ALSSignatureBody__UnorderedGroup_0 ) | ||
6310 | { | ||
6311 | if ( state.backtracking==0 ) { | ||
6312 | before(grammarAccess.getALSSignatureBodyAccess().getUnorderedGroup_0()); | ||
6313 | } | ||
6314 | // InternalAlloyLanguage.g:1917:1: ( rule__ALSSignatureBody__UnorderedGroup_0 ) | ||
6315 | // InternalAlloyLanguage.g:1917:2: rule__ALSSignatureBody__UnorderedGroup_0 | ||
6316 | { | ||
6317 | pushFollow(FOLLOW_2); | ||
6318 | rule__ALSSignatureBody__UnorderedGroup_0(); | ||
6319 | |||
6320 | state._fsp--; | ||
6321 | if (state.failed) return ; | ||
6322 | |||
6323 | } | ||
6324 | |||
6325 | if ( state.backtracking==0 ) { | ||
6326 | after(grammarAccess.getALSSignatureBodyAccess().getUnorderedGroup_0()); | ||
6327 | } | ||
6328 | |||
6329 | } | ||
6330 | |||
6331 | |||
6332 | } | ||
6333 | |||
6334 | } | ||
6335 | catch (RecognitionException re) { | ||
6336 | reportError(re); | ||
6337 | recover(input,re); | ||
6338 | } | ||
6339 | finally { | ||
6340 | |||
6341 | restoreStackSize(stackSize); | ||
6342 | |||
6343 | } | ||
6344 | return ; | ||
6345 | } | ||
6346 | // $ANTLR end "rule__ALSSignatureBody__Group__0__Impl" | ||
6347 | |||
6348 | |||
6349 | // $ANTLR start "rule__ALSSignatureBody__Group__1" | ||
6350 | // InternalAlloyLanguage.g:1927:1: rule__ALSSignatureBody__Group__1 : rule__ALSSignatureBody__Group__1__Impl rule__ALSSignatureBody__Group__2 ; | ||
6351 | public final void rule__ALSSignatureBody__Group__1() throws RecognitionException { | ||
6352 | |||
6353 | int stackSize = keepStackSize(); | ||
6354 | |||
6355 | try { | ||
6356 | // InternalAlloyLanguage.g:1931:1: ( rule__ALSSignatureBody__Group__1__Impl rule__ALSSignatureBody__Group__2 ) | ||
6357 | // InternalAlloyLanguage.g:1932:2: rule__ALSSignatureBody__Group__1__Impl rule__ALSSignatureBody__Group__2 | ||
6358 | { | ||
6359 | pushFollow(FOLLOW_5); | ||
6360 | rule__ALSSignatureBody__Group__1__Impl(); | ||
6361 | |||
6362 | state._fsp--; | ||
6363 | if (state.failed) return ; | ||
6364 | pushFollow(FOLLOW_2); | ||
6365 | rule__ALSSignatureBody__Group__2(); | ||
6366 | |||
6367 | state._fsp--; | ||
6368 | if (state.failed) return ; | ||
6369 | |||
6370 | } | ||
6371 | |||
6372 | } | ||
6373 | catch (RecognitionException re) { | ||
6374 | reportError(re); | ||
6375 | recover(input,re); | ||
6376 | } | ||
6377 | finally { | ||
6378 | |||
6379 | restoreStackSize(stackSize); | ||
6380 | |||
6381 | } | ||
6382 | return ; | ||
6383 | } | ||
6384 | // $ANTLR end "rule__ALSSignatureBody__Group__1" | ||
6385 | |||
6386 | |||
6387 | // $ANTLR start "rule__ALSSignatureBody__Group__1__Impl" | ||
6388 | // InternalAlloyLanguage.g:1939:1: rule__ALSSignatureBody__Group__1__Impl : ( 'sig' ) ; | ||
6389 | public final void rule__ALSSignatureBody__Group__1__Impl() throws RecognitionException { | ||
6390 | |||
6391 | int stackSize = keepStackSize(); | ||
6392 | |||
6393 | try { | ||
6394 | // InternalAlloyLanguage.g:1943:1: ( ( 'sig' ) ) | ||
6395 | // InternalAlloyLanguage.g:1944:1: ( 'sig' ) | ||
6396 | { | ||
6397 | // InternalAlloyLanguage.g:1944:1: ( 'sig' ) | ||
6398 | // InternalAlloyLanguage.g:1945:1: 'sig' | ||
6399 | { | ||
6400 | if ( state.backtracking==0 ) { | ||
6401 | before(grammarAccess.getALSSignatureBodyAccess().getSigKeyword_1()); | ||
6402 | } | ||
6403 | match(input,36,FOLLOW_2); if (state.failed) return ; | ||
6404 | if ( state.backtracking==0 ) { | ||
6405 | after(grammarAccess.getALSSignatureBodyAccess().getSigKeyword_1()); | ||
6406 | } | ||
6407 | |||
6408 | } | ||
6409 | |||
6410 | |||
6411 | } | ||
6412 | |||
6413 | } | ||
6414 | catch (RecognitionException re) { | ||
6415 | reportError(re); | ||
6416 | recover(input,re); | ||
6417 | } | ||
6418 | finally { | ||
6419 | |||
6420 | restoreStackSize(stackSize); | ||
6421 | |||
6422 | } | ||
6423 | return ; | ||
6424 | } | ||
6425 | // $ANTLR end "rule__ALSSignatureBody__Group__1__Impl" | ||
6426 | |||
6427 | |||
6428 | // $ANTLR start "rule__ALSSignatureBody__Group__2" | ||
6429 | // InternalAlloyLanguage.g:1958:1: rule__ALSSignatureBody__Group__2 : rule__ALSSignatureBody__Group__2__Impl rule__ALSSignatureBody__Group__3 ; | ||
6430 | public final void rule__ALSSignatureBody__Group__2() throws RecognitionException { | ||
6431 | |||
6432 | int stackSize = keepStackSize(); | ||
6433 | |||
6434 | try { | ||
6435 | // InternalAlloyLanguage.g:1962:1: ( rule__ALSSignatureBody__Group__2__Impl rule__ALSSignatureBody__Group__3 ) | ||
6436 | // InternalAlloyLanguage.g:1963:2: rule__ALSSignatureBody__Group__2__Impl rule__ALSSignatureBody__Group__3 | ||
6437 | { | ||
6438 | pushFollow(FOLLOW_10); | ||
6439 | rule__ALSSignatureBody__Group__2__Impl(); | ||
6440 | |||
6441 | state._fsp--; | ||
6442 | if (state.failed) return ; | ||
6443 | pushFollow(FOLLOW_2); | ||
6444 | rule__ALSSignatureBody__Group__3(); | ||
6445 | |||
6446 | state._fsp--; | ||
6447 | if (state.failed) return ; | ||
6448 | |||
6449 | } | ||
6450 | |||
6451 | } | ||
6452 | catch (RecognitionException re) { | ||
6453 | reportError(re); | ||
6454 | recover(input,re); | ||
6455 | } | ||
6456 | finally { | ||
6457 | |||
6458 | restoreStackSize(stackSize); | ||
6459 | |||
6460 | } | ||
6461 | return ; | ||
6462 | } | ||
6463 | // $ANTLR end "rule__ALSSignatureBody__Group__2" | ||
6464 | |||
6465 | |||
6466 | // $ANTLR start "rule__ALSSignatureBody__Group__2__Impl" | ||
6467 | // InternalAlloyLanguage.g:1970:1: rule__ALSSignatureBody__Group__2__Impl : ( ( rule__ALSSignatureBody__DeclarationsAssignment_2 ) ) ; | ||
6468 | public final void rule__ALSSignatureBody__Group__2__Impl() throws RecognitionException { | ||
6469 | |||
6470 | int stackSize = keepStackSize(); | ||
6471 | |||
6472 | try { | ||
6473 | // InternalAlloyLanguage.g:1974:1: ( ( ( rule__ALSSignatureBody__DeclarationsAssignment_2 ) ) ) | ||
6474 | // InternalAlloyLanguage.g:1975:1: ( ( rule__ALSSignatureBody__DeclarationsAssignment_2 ) ) | ||
6475 | { | ||
6476 | // InternalAlloyLanguage.g:1975:1: ( ( rule__ALSSignatureBody__DeclarationsAssignment_2 ) ) | ||
6477 | // InternalAlloyLanguage.g:1976:1: ( rule__ALSSignatureBody__DeclarationsAssignment_2 ) | ||
6478 | { | ||
6479 | if ( state.backtracking==0 ) { | ||
6480 | before(grammarAccess.getALSSignatureBodyAccess().getDeclarationsAssignment_2()); | ||
6481 | } | ||
6482 | // InternalAlloyLanguage.g:1977:1: ( rule__ALSSignatureBody__DeclarationsAssignment_2 ) | ||
6483 | // InternalAlloyLanguage.g:1977:2: rule__ALSSignatureBody__DeclarationsAssignment_2 | ||
6484 | { | ||
6485 | pushFollow(FOLLOW_2); | ||
6486 | rule__ALSSignatureBody__DeclarationsAssignment_2(); | ||
6487 | |||
6488 | state._fsp--; | ||
6489 | if (state.failed) return ; | ||
6490 | |||
6491 | } | ||
6492 | |||
6493 | if ( state.backtracking==0 ) { | ||
6494 | after(grammarAccess.getALSSignatureBodyAccess().getDeclarationsAssignment_2()); | ||
6495 | } | ||
6496 | |||
6497 | } | ||
6498 | |||
6499 | |||
6500 | } | ||
6501 | |||
6502 | } | ||
6503 | catch (RecognitionException re) { | ||
6504 | reportError(re); | ||
6505 | recover(input,re); | ||
6506 | } | ||
6507 | finally { | ||
6508 | |||
6509 | restoreStackSize(stackSize); | ||
6510 | |||
6511 | } | ||
6512 | return ; | ||
6513 | } | ||
6514 | // $ANTLR end "rule__ALSSignatureBody__Group__2__Impl" | ||
6515 | |||
6516 | |||
6517 | // $ANTLR start "rule__ALSSignatureBody__Group__3" | ||
6518 | // InternalAlloyLanguage.g:1987:1: rule__ALSSignatureBody__Group__3 : rule__ALSSignatureBody__Group__3__Impl rule__ALSSignatureBody__Group__4 ; | ||
6519 | public final void rule__ALSSignatureBody__Group__3() throws RecognitionException { | ||
6520 | |||
6521 | int stackSize = keepStackSize(); | ||
6522 | |||
6523 | try { | ||
6524 | // InternalAlloyLanguage.g:1991:1: ( rule__ALSSignatureBody__Group__3__Impl rule__ALSSignatureBody__Group__4 ) | ||
6525 | // InternalAlloyLanguage.g:1992:2: rule__ALSSignatureBody__Group__3__Impl rule__ALSSignatureBody__Group__4 | ||
6526 | { | ||
6527 | pushFollow(FOLLOW_10); | ||
6528 | rule__ALSSignatureBody__Group__3__Impl(); | ||
6529 | |||
6530 | state._fsp--; | ||
6531 | if (state.failed) return ; | ||
6532 | pushFollow(FOLLOW_2); | ||
6533 | rule__ALSSignatureBody__Group__4(); | ||
6534 | |||
6535 | state._fsp--; | ||
6536 | if (state.failed) return ; | ||
6537 | |||
6538 | } | ||
6539 | |||
6540 | } | ||
6541 | catch (RecognitionException re) { | ||
6542 | reportError(re); | ||
6543 | recover(input,re); | ||
6544 | } | ||
6545 | finally { | ||
6546 | |||
6547 | restoreStackSize(stackSize); | ||
6548 | |||
6549 | } | ||
6550 | return ; | ||
6551 | } | ||
6552 | // $ANTLR end "rule__ALSSignatureBody__Group__3" | ||
6553 | |||
6554 | |||
6555 | // $ANTLR start "rule__ALSSignatureBody__Group__3__Impl" | ||
6556 | // InternalAlloyLanguage.g:1999:1: rule__ALSSignatureBody__Group__3__Impl : ( ( rule__ALSSignatureBody__Group_3__0 )* ) ; | ||
6557 | public final void rule__ALSSignatureBody__Group__3__Impl() throws RecognitionException { | ||
6558 | |||
6559 | int stackSize = keepStackSize(); | ||
6560 | |||
6561 | try { | ||
6562 | // InternalAlloyLanguage.g:2003:1: ( ( ( rule__ALSSignatureBody__Group_3__0 )* ) ) | ||
6563 | // InternalAlloyLanguage.g:2004:1: ( ( rule__ALSSignatureBody__Group_3__0 )* ) | ||
6564 | { | ||
6565 | // InternalAlloyLanguage.g:2004:1: ( ( rule__ALSSignatureBody__Group_3__0 )* ) | ||
6566 | // InternalAlloyLanguage.g:2005:1: ( rule__ALSSignatureBody__Group_3__0 )* | ||
6567 | { | ||
6568 | if ( state.backtracking==0 ) { | ||
6569 | before(grammarAccess.getALSSignatureBodyAccess().getGroup_3()); | ||
6570 | } | ||
6571 | // InternalAlloyLanguage.g:2006:1: ( rule__ALSSignatureBody__Group_3__0 )* | ||
6572 | loop19: | ||
6573 | do { | ||
6574 | int alt19=2; | ||
6575 | int LA19_0 = input.LA(1); | ||
6576 | |||
6577 | if ( (LA19_0==35) ) { | ||
6578 | alt19=1; | ||
6579 | } | ||
6580 | |||
6581 | |||
6582 | switch (alt19) { | ||
6583 | case 1 : | ||
6584 | // InternalAlloyLanguage.g:2006:2: rule__ALSSignatureBody__Group_3__0 | ||
6585 | { | ||
6586 | pushFollow(FOLLOW_8); | ||
6587 | rule__ALSSignatureBody__Group_3__0(); | ||
6588 | |||
6589 | state._fsp--; | ||
6590 | if (state.failed) return ; | ||
6591 | |||
6592 | } | ||
6593 | break; | ||
6594 | |||
6595 | default : | ||
6596 | break loop19; | ||
6597 | } | ||
6598 | } while (true); | ||
6599 | |||
6600 | if ( state.backtracking==0 ) { | ||
6601 | after(grammarAccess.getALSSignatureBodyAccess().getGroup_3()); | ||
6602 | } | ||
6603 | |||
6604 | } | ||
6605 | |||
6606 | |||
6607 | } | ||
6608 | |||
6609 | } | ||
6610 | catch (RecognitionException re) { | ||
6611 | reportError(re); | ||
6612 | recover(input,re); | ||
6613 | } | ||
6614 | finally { | ||
6615 | |||
6616 | restoreStackSize(stackSize); | ||
6617 | |||
6618 | } | ||
6619 | return ; | ||
6620 | } | ||
6621 | // $ANTLR end "rule__ALSSignatureBody__Group__3__Impl" | ||
6622 | |||
6623 | |||
6624 | // $ANTLR start "rule__ALSSignatureBody__Group__4" | ||
6625 | // InternalAlloyLanguage.g:2016:1: rule__ALSSignatureBody__Group__4 : rule__ALSSignatureBody__Group__4__Impl rule__ALSSignatureBody__Group__5 ; | ||
6626 | public final void rule__ALSSignatureBody__Group__4() throws RecognitionException { | ||
6627 | |||
6628 | int stackSize = keepStackSize(); | ||
6629 | |||
6630 | try { | ||
6631 | // InternalAlloyLanguage.g:2020:1: ( rule__ALSSignatureBody__Group__4__Impl rule__ALSSignatureBody__Group__5 ) | ||
6632 | // InternalAlloyLanguage.g:2021:2: rule__ALSSignatureBody__Group__4__Impl rule__ALSSignatureBody__Group__5 | ||
6633 | { | ||
6634 | pushFollow(FOLLOW_10); | ||
6635 | rule__ALSSignatureBody__Group__4__Impl(); | ||
6636 | |||
6637 | state._fsp--; | ||
6638 | if (state.failed) return ; | ||
6639 | pushFollow(FOLLOW_2); | ||
6640 | rule__ALSSignatureBody__Group__5(); | ||
6641 | |||
6642 | state._fsp--; | ||
6643 | if (state.failed) return ; | ||
6644 | |||
6645 | } | ||
6646 | |||
6647 | } | ||
6648 | catch (RecognitionException re) { | ||
6649 | reportError(re); | ||
6650 | recover(input,re); | ||
6651 | } | ||
6652 | finally { | ||
6653 | |||
6654 | restoreStackSize(stackSize); | ||
6655 | |||
6656 | } | ||
6657 | return ; | ||
6658 | } | ||
6659 | // $ANTLR end "rule__ALSSignatureBody__Group__4" | ||
6660 | |||
6661 | |||
6662 | // $ANTLR start "rule__ALSSignatureBody__Group__4__Impl" | ||
6663 | // InternalAlloyLanguage.g:2028:1: rule__ALSSignatureBody__Group__4__Impl : ( ( rule__ALSSignatureBody__Alternatives_4 )? ) ; | ||
6664 | public final void rule__ALSSignatureBody__Group__4__Impl() throws RecognitionException { | ||
6665 | |||
6666 | int stackSize = keepStackSize(); | ||
6667 | |||
6668 | try { | ||
6669 | // InternalAlloyLanguage.g:2032:1: ( ( ( rule__ALSSignatureBody__Alternatives_4 )? ) ) | ||
6670 | // InternalAlloyLanguage.g:2033:1: ( ( rule__ALSSignatureBody__Alternatives_4 )? ) | ||
6671 | { | ||
6672 | // InternalAlloyLanguage.g:2033:1: ( ( rule__ALSSignatureBody__Alternatives_4 )? ) | ||
6673 | // InternalAlloyLanguage.g:2034:1: ( rule__ALSSignatureBody__Alternatives_4 )? | ||
6674 | { | ||
6675 | if ( state.backtracking==0 ) { | ||
6676 | before(grammarAccess.getALSSignatureBodyAccess().getAlternatives_4()); | ||
6677 | } | ||
6678 | // InternalAlloyLanguage.g:2035:1: ( rule__ALSSignatureBody__Alternatives_4 )? | ||
6679 | int alt20=2; | ||
6680 | int LA20_0 = input.LA(1); | ||
6681 | |||
6682 | if ( ((LA20_0>=37 && LA20_0<=38)) ) { | ||
6683 | alt20=1; | ||
6684 | } | ||
6685 | switch (alt20) { | ||
6686 | case 1 : | ||
6687 | // InternalAlloyLanguage.g:2035:2: rule__ALSSignatureBody__Alternatives_4 | ||
6688 | { | ||
6689 | pushFollow(FOLLOW_2); | ||
6690 | rule__ALSSignatureBody__Alternatives_4(); | ||
6691 | |||
6692 | state._fsp--; | ||
6693 | if (state.failed) return ; | ||
6694 | |||
6695 | } | ||
6696 | break; | ||
6697 | |||
6698 | } | ||
6699 | |||
6700 | if ( state.backtracking==0 ) { | ||
6701 | after(grammarAccess.getALSSignatureBodyAccess().getAlternatives_4()); | ||
6702 | } | ||
6703 | |||
6704 | } | ||
6705 | |||
6706 | |||
6707 | } | ||
6708 | |||
6709 | } | ||
6710 | catch (RecognitionException re) { | ||
6711 | reportError(re); | ||
6712 | recover(input,re); | ||
6713 | } | ||
6714 | finally { | ||
6715 | |||
6716 | restoreStackSize(stackSize); | ||
6717 | |||
6718 | } | ||
6719 | return ; | ||
6720 | } | ||
6721 | // $ANTLR end "rule__ALSSignatureBody__Group__4__Impl" | ||
6722 | |||
6723 | |||
6724 | // $ANTLR start "rule__ALSSignatureBody__Group__5" | ||
6725 | // InternalAlloyLanguage.g:2045:1: rule__ALSSignatureBody__Group__5 : rule__ALSSignatureBody__Group__5__Impl rule__ALSSignatureBody__Group__6 ; | ||
6726 | public final void rule__ALSSignatureBody__Group__5() throws RecognitionException { | ||
6727 | |||
6728 | int stackSize = keepStackSize(); | ||
6729 | |||
6730 | try { | ||
6731 | // InternalAlloyLanguage.g:2049:1: ( rule__ALSSignatureBody__Group__5__Impl rule__ALSSignatureBody__Group__6 ) | ||
6732 | // InternalAlloyLanguage.g:2050:2: rule__ALSSignatureBody__Group__5__Impl rule__ALSSignatureBody__Group__6 | ||
6733 | { | ||
6734 | pushFollow(FOLLOW_11); | ||
6735 | rule__ALSSignatureBody__Group__5__Impl(); | ||
6736 | |||
6737 | state._fsp--; | ||
6738 | if (state.failed) return ; | ||
6739 | pushFollow(FOLLOW_2); | ||
6740 | rule__ALSSignatureBody__Group__6(); | ||
6741 | |||
6742 | state._fsp--; | ||
6743 | if (state.failed) return ; | ||
6744 | |||
6745 | } | ||
6746 | |||
6747 | } | ||
6748 | catch (RecognitionException re) { | ||
6749 | reportError(re); | ||
6750 | recover(input,re); | ||
6751 | } | ||
6752 | finally { | ||
6753 | |||
6754 | restoreStackSize(stackSize); | ||
6755 | |||
6756 | } | ||
6757 | return ; | ||
6758 | } | ||
6759 | // $ANTLR end "rule__ALSSignatureBody__Group__5" | ||
6760 | |||
6761 | |||
6762 | // $ANTLR start "rule__ALSSignatureBody__Group__5__Impl" | ||
6763 | // InternalAlloyLanguage.g:2057:1: rule__ALSSignatureBody__Group__5__Impl : ( '{' ) ; | ||
6764 | public final void rule__ALSSignatureBody__Group__5__Impl() throws RecognitionException { | ||
6765 | |||
6766 | int stackSize = keepStackSize(); | ||
6767 | |||
6768 | try { | ||
6769 | // InternalAlloyLanguage.g:2061:1: ( ( '{' ) ) | ||
6770 | // InternalAlloyLanguage.g:2062:1: ( '{' ) | ||
6771 | { | ||
6772 | // InternalAlloyLanguage.g:2062:1: ( '{' ) | ||
6773 | // InternalAlloyLanguage.g:2063:1: '{' | ||
6774 | { | ||
6775 | if ( state.backtracking==0 ) { | ||
6776 | before(grammarAccess.getALSSignatureBodyAccess().getLeftCurlyBracketKeyword_5()); | ||
6777 | } | ||
6778 | match(input,33,FOLLOW_2); if (state.failed) return ; | ||
6779 | if ( state.backtracking==0 ) { | ||
6780 | after(grammarAccess.getALSSignatureBodyAccess().getLeftCurlyBracketKeyword_5()); | ||
6781 | } | ||
6782 | |||
6783 | } | ||
6784 | |||
6785 | |||
6786 | } | ||
6787 | |||
6788 | } | ||
6789 | catch (RecognitionException re) { | ||
6790 | reportError(re); | ||
6791 | recover(input,re); | ||
6792 | } | ||
6793 | finally { | ||
6794 | |||
6795 | restoreStackSize(stackSize); | ||
6796 | |||
6797 | } | ||
6798 | return ; | ||
6799 | } | ||
6800 | // $ANTLR end "rule__ALSSignatureBody__Group__5__Impl" | ||
6801 | |||
6802 | |||
6803 | // $ANTLR start "rule__ALSSignatureBody__Group__6" | ||
6804 | // InternalAlloyLanguage.g:2076:1: rule__ALSSignatureBody__Group__6 : rule__ALSSignatureBody__Group__6__Impl rule__ALSSignatureBody__Group__7 ; | ||
6805 | public final void rule__ALSSignatureBody__Group__6() throws RecognitionException { | ||
6806 | |||
6807 | int stackSize = keepStackSize(); | ||
6808 | |||
6809 | try { | ||
6810 | // InternalAlloyLanguage.g:2080:1: ( rule__ALSSignatureBody__Group__6__Impl rule__ALSSignatureBody__Group__7 ) | ||
6811 | // InternalAlloyLanguage.g:2081:2: rule__ALSSignatureBody__Group__6__Impl rule__ALSSignatureBody__Group__7 | ||
6812 | { | ||
6813 | pushFollow(FOLLOW_11); | ||
6814 | rule__ALSSignatureBody__Group__6__Impl(); | ||
6815 | |||
6816 | state._fsp--; | ||
6817 | if (state.failed) return ; | ||
6818 | pushFollow(FOLLOW_2); | ||
6819 | rule__ALSSignatureBody__Group__7(); | ||
6820 | |||
6821 | state._fsp--; | ||
6822 | if (state.failed) return ; | ||
6823 | |||
6824 | } | ||
6825 | |||
6826 | } | ||
6827 | catch (RecognitionException re) { | ||
6828 | reportError(re); | ||
6829 | recover(input,re); | ||
6830 | } | ||
6831 | finally { | ||
6832 | |||
6833 | restoreStackSize(stackSize); | ||
6834 | |||
6835 | } | ||
6836 | return ; | ||
6837 | } | ||
6838 | // $ANTLR end "rule__ALSSignatureBody__Group__6" | ||
6839 | |||
6840 | |||
6841 | // $ANTLR start "rule__ALSSignatureBody__Group__6__Impl" | ||
6842 | // InternalAlloyLanguage.g:2088:1: rule__ALSSignatureBody__Group__6__Impl : ( ( rule__ALSSignatureBody__Group_6__0 )? ) ; | ||
6843 | public final void rule__ALSSignatureBody__Group__6__Impl() throws RecognitionException { | ||
6844 | |||
6845 | int stackSize = keepStackSize(); | ||
6846 | |||
6847 | try { | ||
6848 | // InternalAlloyLanguage.g:2092:1: ( ( ( rule__ALSSignatureBody__Group_6__0 )? ) ) | ||
6849 | // InternalAlloyLanguage.g:2093:1: ( ( rule__ALSSignatureBody__Group_6__0 )? ) | ||
6850 | { | ||
6851 | // InternalAlloyLanguage.g:2093:1: ( ( rule__ALSSignatureBody__Group_6__0 )? ) | ||
6852 | // InternalAlloyLanguage.g:2094:1: ( rule__ALSSignatureBody__Group_6__0 )? | ||
6853 | { | ||
6854 | if ( state.backtracking==0 ) { | ||
6855 | before(grammarAccess.getALSSignatureBodyAccess().getGroup_6()); | ||
6856 | } | ||
6857 | // InternalAlloyLanguage.g:2095:1: ( rule__ALSSignatureBody__Group_6__0 )? | ||
6858 | int alt21=2; | ||
6859 | int LA21_0 = input.LA(1); | ||
6860 | |||
6861 | if ( (LA21_0==RULE_ID) ) { | ||
6862 | alt21=1; | ||
6863 | } | ||
6864 | switch (alt21) { | ||
6865 | case 1 : | ||
6866 | // InternalAlloyLanguage.g:2095:2: rule__ALSSignatureBody__Group_6__0 | ||
6867 | { | ||
6868 | pushFollow(FOLLOW_2); | ||
6869 | rule__ALSSignatureBody__Group_6__0(); | ||
6870 | |||
6871 | state._fsp--; | ||
6872 | if (state.failed) return ; | ||
6873 | |||
6874 | } | ||
6875 | break; | ||
6876 | |||
6877 | } | ||
6878 | |||
6879 | if ( state.backtracking==0 ) { | ||
6880 | after(grammarAccess.getALSSignatureBodyAccess().getGroup_6()); | ||
6881 | } | ||
6882 | |||
6883 | } | ||
6884 | |||
6885 | |||
6886 | } | ||
6887 | |||
6888 | } | ||
6889 | catch (RecognitionException re) { | ||
6890 | reportError(re); | ||
6891 | recover(input,re); | ||
6892 | } | ||
6893 | finally { | ||
6894 | |||
6895 | restoreStackSize(stackSize); | ||
6896 | |||
6897 | } | ||
6898 | return ; | ||
6899 | } | ||
6900 | // $ANTLR end "rule__ALSSignatureBody__Group__6__Impl" | ||
6901 | |||
6902 | |||
6903 | // $ANTLR start "rule__ALSSignatureBody__Group__7" | ||
6904 | // InternalAlloyLanguage.g:2105:1: rule__ALSSignatureBody__Group__7 : rule__ALSSignatureBody__Group__7__Impl ; | ||
6905 | public final void rule__ALSSignatureBody__Group__7() throws RecognitionException { | ||
6906 | |||
6907 | int stackSize = keepStackSize(); | ||
6908 | |||
6909 | try { | ||
6910 | // InternalAlloyLanguage.g:2109:1: ( rule__ALSSignatureBody__Group__7__Impl ) | ||
6911 | // InternalAlloyLanguage.g:2110:2: rule__ALSSignatureBody__Group__7__Impl | ||
6912 | { | ||
6913 | pushFollow(FOLLOW_2); | ||
6914 | rule__ALSSignatureBody__Group__7__Impl(); | ||
6915 | |||
6916 | state._fsp--; | ||
6917 | if (state.failed) return ; | ||
6918 | |||
6919 | } | ||
6920 | |||
6921 | } | ||
6922 | catch (RecognitionException re) { | ||
6923 | reportError(re); | ||
6924 | recover(input,re); | ||
6925 | } | ||
6926 | finally { | ||
6927 | |||
6928 | restoreStackSize(stackSize); | ||
6929 | |||
6930 | } | ||
6931 | return ; | ||
6932 | } | ||
6933 | // $ANTLR end "rule__ALSSignatureBody__Group__7" | ||
6934 | |||
6935 | |||
6936 | // $ANTLR start "rule__ALSSignatureBody__Group__7__Impl" | ||
6937 | // InternalAlloyLanguage.g:2116:1: rule__ALSSignatureBody__Group__7__Impl : ( '}' ) ; | ||
6938 | public final void rule__ALSSignatureBody__Group__7__Impl() throws RecognitionException { | ||
6939 | |||
6940 | int stackSize = keepStackSize(); | ||
6941 | |||
6942 | try { | ||
6943 | // InternalAlloyLanguage.g:2120:1: ( ( '}' ) ) | ||
6944 | // InternalAlloyLanguage.g:2121:1: ( '}' ) | ||
6945 | { | ||
6946 | // InternalAlloyLanguage.g:2121:1: ( '}' ) | ||
6947 | // InternalAlloyLanguage.g:2122:1: '}' | ||
6948 | { | ||
6949 | if ( state.backtracking==0 ) { | ||
6950 | before(grammarAccess.getALSSignatureBodyAccess().getRightCurlyBracketKeyword_7()); | ||
6951 | } | ||
6952 | match(input,34,FOLLOW_2); if (state.failed) return ; | ||
6953 | if ( state.backtracking==0 ) { | ||
6954 | after(grammarAccess.getALSSignatureBodyAccess().getRightCurlyBracketKeyword_7()); | ||
6955 | } | ||
6956 | |||
6957 | } | ||
6958 | |||
6959 | |||
6960 | } | ||
6961 | |||
6962 | } | ||
6963 | catch (RecognitionException re) { | ||
6964 | reportError(re); | ||
6965 | recover(input,re); | ||
6966 | } | ||
6967 | finally { | ||
6968 | |||
6969 | restoreStackSize(stackSize); | ||
6970 | |||
6971 | } | ||
6972 | return ; | ||
6973 | } | ||
6974 | // $ANTLR end "rule__ALSSignatureBody__Group__7__Impl" | ||
6975 | |||
6976 | |||
6977 | // $ANTLR start "rule__ALSSignatureBody__Group_3__0" | ||
6978 | // InternalAlloyLanguage.g:2151:1: rule__ALSSignatureBody__Group_3__0 : rule__ALSSignatureBody__Group_3__0__Impl rule__ALSSignatureBody__Group_3__1 ; | ||
6979 | public final void rule__ALSSignatureBody__Group_3__0() throws RecognitionException { | ||
6980 | |||
6981 | int stackSize = keepStackSize(); | ||
6982 | |||
6983 | try { | ||
6984 | // InternalAlloyLanguage.g:2155:1: ( rule__ALSSignatureBody__Group_3__0__Impl rule__ALSSignatureBody__Group_3__1 ) | ||
6985 | // InternalAlloyLanguage.g:2156:2: rule__ALSSignatureBody__Group_3__0__Impl rule__ALSSignatureBody__Group_3__1 | ||
6986 | { | ||
6987 | pushFollow(FOLLOW_5); | ||
6988 | rule__ALSSignatureBody__Group_3__0__Impl(); | ||
6989 | |||
6990 | state._fsp--; | ||
6991 | if (state.failed) return ; | ||
6992 | pushFollow(FOLLOW_2); | ||
6993 | rule__ALSSignatureBody__Group_3__1(); | ||
6994 | |||
6995 | state._fsp--; | ||
6996 | if (state.failed) return ; | ||
6997 | |||
6998 | } | ||
6999 | |||
7000 | } | ||
7001 | catch (RecognitionException re) { | ||
7002 | reportError(re); | ||
7003 | recover(input,re); | ||
7004 | } | ||
7005 | finally { | ||
7006 | |||
7007 | restoreStackSize(stackSize); | ||
7008 | |||
7009 | } | ||
7010 | return ; | ||
7011 | } | ||
7012 | // $ANTLR end "rule__ALSSignatureBody__Group_3__0" | ||
7013 | |||
7014 | |||
7015 | // $ANTLR start "rule__ALSSignatureBody__Group_3__0__Impl" | ||
7016 | // InternalAlloyLanguage.g:2163:1: rule__ALSSignatureBody__Group_3__0__Impl : ( ',' ) ; | ||
7017 | public final void rule__ALSSignatureBody__Group_3__0__Impl() throws RecognitionException { | ||
7018 | |||
7019 | int stackSize = keepStackSize(); | ||
7020 | |||
7021 | try { | ||
7022 | // InternalAlloyLanguage.g:2167:1: ( ( ',' ) ) | ||
7023 | // InternalAlloyLanguage.g:2168:1: ( ',' ) | ||
7024 | { | ||
7025 | // InternalAlloyLanguage.g:2168:1: ( ',' ) | ||
7026 | // InternalAlloyLanguage.g:2169:1: ',' | ||
7027 | { | ||
7028 | if ( state.backtracking==0 ) { | ||
7029 | before(grammarAccess.getALSSignatureBodyAccess().getCommaKeyword_3_0()); | ||
7030 | } | ||
7031 | match(input,35,FOLLOW_2); if (state.failed) return ; | ||
7032 | if ( state.backtracking==0 ) { | ||
7033 | after(grammarAccess.getALSSignatureBodyAccess().getCommaKeyword_3_0()); | ||
7034 | } | ||
7035 | |||
7036 | } | ||
7037 | |||
7038 | |||
7039 | } | ||
7040 | |||
7041 | } | ||
7042 | catch (RecognitionException re) { | ||
7043 | reportError(re); | ||
7044 | recover(input,re); | ||
7045 | } | ||
7046 | finally { | ||
7047 | |||
7048 | restoreStackSize(stackSize); | ||
7049 | |||
7050 | } | ||
7051 | return ; | ||
7052 | } | ||
7053 | // $ANTLR end "rule__ALSSignatureBody__Group_3__0__Impl" | ||
7054 | |||
7055 | |||
7056 | // $ANTLR start "rule__ALSSignatureBody__Group_3__1" | ||
7057 | // InternalAlloyLanguage.g:2182:1: rule__ALSSignatureBody__Group_3__1 : rule__ALSSignatureBody__Group_3__1__Impl ; | ||
7058 | public final void rule__ALSSignatureBody__Group_3__1() throws RecognitionException { | ||
7059 | |||
7060 | int stackSize = keepStackSize(); | ||
7061 | |||
7062 | try { | ||
7063 | // InternalAlloyLanguage.g:2186:1: ( rule__ALSSignatureBody__Group_3__1__Impl ) | ||
7064 | // InternalAlloyLanguage.g:2187:2: rule__ALSSignatureBody__Group_3__1__Impl | ||
7065 | { | ||
7066 | pushFollow(FOLLOW_2); | ||
7067 | rule__ALSSignatureBody__Group_3__1__Impl(); | ||
7068 | |||
7069 | state._fsp--; | ||
7070 | if (state.failed) return ; | ||
7071 | |||
7072 | } | ||
7073 | |||
7074 | } | ||
7075 | catch (RecognitionException re) { | ||
7076 | reportError(re); | ||
7077 | recover(input,re); | ||
7078 | } | ||
7079 | finally { | ||
7080 | |||
7081 | restoreStackSize(stackSize); | ||
7082 | |||
7083 | } | ||
7084 | return ; | ||
7085 | } | ||
7086 | // $ANTLR end "rule__ALSSignatureBody__Group_3__1" | ||
7087 | |||
7088 | |||
7089 | // $ANTLR start "rule__ALSSignatureBody__Group_3__1__Impl" | ||
7090 | // InternalAlloyLanguage.g:2193:1: rule__ALSSignatureBody__Group_3__1__Impl : ( ( rule__ALSSignatureBody__DeclarationsAssignment_3_1 ) ) ; | ||
7091 | public final void rule__ALSSignatureBody__Group_3__1__Impl() throws RecognitionException { | ||
7092 | |||
7093 | int stackSize = keepStackSize(); | ||
7094 | |||
7095 | try { | ||
7096 | // InternalAlloyLanguage.g:2197:1: ( ( ( rule__ALSSignatureBody__DeclarationsAssignment_3_1 ) ) ) | ||
7097 | // InternalAlloyLanguage.g:2198:1: ( ( rule__ALSSignatureBody__DeclarationsAssignment_3_1 ) ) | ||
7098 | { | ||
7099 | // InternalAlloyLanguage.g:2198:1: ( ( rule__ALSSignatureBody__DeclarationsAssignment_3_1 ) ) | ||
7100 | // InternalAlloyLanguage.g:2199:1: ( rule__ALSSignatureBody__DeclarationsAssignment_3_1 ) | ||
7101 | { | ||
7102 | if ( state.backtracking==0 ) { | ||
7103 | before(grammarAccess.getALSSignatureBodyAccess().getDeclarationsAssignment_3_1()); | ||
7104 | } | ||
7105 | // InternalAlloyLanguage.g:2200:1: ( rule__ALSSignatureBody__DeclarationsAssignment_3_1 ) | ||
7106 | // InternalAlloyLanguage.g:2200:2: rule__ALSSignatureBody__DeclarationsAssignment_3_1 | ||
7107 | { | ||
7108 | pushFollow(FOLLOW_2); | ||
7109 | rule__ALSSignatureBody__DeclarationsAssignment_3_1(); | ||
7110 | |||
7111 | state._fsp--; | ||
7112 | if (state.failed) return ; | ||
7113 | |||
7114 | } | ||
7115 | |||
7116 | if ( state.backtracking==0 ) { | ||
7117 | after(grammarAccess.getALSSignatureBodyAccess().getDeclarationsAssignment_3_1()); | ||
7118 | } | ||
7119 | |||
7120 | } | ||
7121 | |||
7122 | |||
7123 | } | ||
7124 | |||
7125 | } | ||
7126 | catch (RecognitionException re) { | ||
7127 | reportError(re); | ||
7128 | recover(input,re); | ||
7129 | } | ||
7130 | finally { | ||
7131 | |||
7132 | restoreStackSize(stackSize); | ||
7133 | |||
7134 | } | ||
7135 | return ; | ||
7136 | } | ||
7137 | // $ANTLR end "rule__ALSSignatureBody__Group_3__1__Impl" | ||
7138 | |||
7139 | |||
7140 | // $ANTLR start "rule__ALSSignatureBody__Group_4_0__0" | ||
7141 | // InternalAlloyLanguage.g:2214:1: rule__ALSSignatureBody__Group_4_0__0 : rule__ALSSignatureBody__Group_4_0__0__Impl rule__ALSSignatureBody__Group_4_0__1 ; | ||
7142 | public final void rule__ALSSignatureBody__Group_4_0__0() throws RecognitionException { | ||
7143 | |||
7144 | int stackSize = keepStackSize(); | ||
7145 | |||
7146 | try { | ||
7147 | // InternalAlloyLanguage.g:2218:1: ( rule__ALSSignatureBody__Group_4_0__0__Impl rule__ALSSignatureBody__Group_4_0__1 ) | ||
7148 | // InternalAlloyLanguage.g:2219:2: rule__ALSSignatureBody__Group_4_0__0__Impl rule__ALSSignatureBody__Group_4_0__1 | ||
7149 | { | ||
7150 | pushFollow(FOLLOW_5); | ||
7151 | rule__ALSSignatureBody__Group_4_0__0__Impl(); | ||
7152 | |||
7153 | state._fsp--; | ||
7154 | if (state.failed) return ; | ||
7155 | pushFollow(FOLLOW_2); | ||
7156 | rule__ALSSignatureBody__Group_4_0__1(); | ||
7157 | |||
7158 | state._fsp--; | ||
7159 | if (state.failed) return ; | ||
7160 | |||
7161 | } | ||
7162 | |||
7163 | } | ||
7164 | catch (RecognitionException re) { | ||
7165 | reportError(re); | ||
7166 | recover(input,re); | ||
7167 | } | ||
7168 | finally { | ||
7169 | |||
7170 | restoreStackSize(stackSize); | ||
7171 | |||
7172 | } | ||
7173 | return ; | ||
7174 | } | ||
7175 | // $ANTLR end "rule__ALSSignatureBody__Group_4_0__0" | ||
7176 | |||
7177 | |||
7178 | // $ANTLR start "rule__ALSSignatureBody__Group_4_0__0__Impl" | ||
7179 | // InternalAlloyLanguage.g:2226:1: rule__ALSSignatureBody__Group_4_0__0__Impl : ( 'extends' ) ; | ||
7180 | public final void rule__ALSSignatureBody__Group_4_0__0__Impl() throws RecognitionException { | ||
7181 | |||
7182 | int stackSize = keepStackSize(); | ||
7183 | |||
7184 | try { | ||
7185 | // InternalAlloyLanguage.g:2230:1: ( ( 'extends' ) ) | ||
7186 | // InternalAlloyLanguage.g:2231:1: ( 'extends' ) | ||
7187 | { | ||
7188 | // InternalAlloyLanguage.g:2231:1: ( 'extends' ) | ||
7189 | // InternalAlloyLanguage.g:2232:1: 'extends' | ||
7190 | { | ||
7191 | if ( state.backtracking==0 ) { | ||
7192 | before(grammarAccess.getALSSignatureBodyAccess().getExtendsKeyword_4_0_0()); | ||
7193 | } | ||
7194 | match(input,37,FOLLOW_2); if (state.failed) return ; | ||
7195 | if ( state.backtracking==0 ) { | ||
7196 | after(grammarAccess.getALSSignatureBodyAccess().getExtendsKeyword_4_0_0()); | ||
7197 | } | ||
7198 | |||
7199 | } | ||
7200 | |||
7201 | |||
7202 | } | ||
7203 | |||
7204 | } | ||
7205 | catch (RecognitionException re) { | ||
7206 | reportError(re); | ||
7207 | recover(input,re); | ||
7208 | } | ||
7209 | finally { | ||
7210 | |||
7211 | restoreStackSize(stackSize); | ||
7212 | |||
7213 | } | ||
7214 | return ; | ||
7215 | } | ||
7216 | // $ANTLR end "rule__ALSSignatureBody__Group_4_0__0__Impl" | ||
7217 | |||
7218 | |||
7219 | // $ANTLR start "rule__ALSSignatureBody__Group_4_0__1" | ||
7220 | // InternalAlloyLanguage.g:2245:1: rule__ALSSignatureBody__Group_4_0__1 : rule__ALSSignatureBody__Group_4_0__1__Impl ; | ||
7221 | public final void rule__ALSSignatureBody__Group_4_0__1() throws RecognitionException { | ||
7222 | |||
7223 | int stackSize = keepStackSize(); | ||
7224 | |||
7225 | try { | ||
7226 | // InternalAlloyLanguage.g:2249:1: ( rule__ALSSignatureBody__Group_4_0__1__Impl ) | ||
7227 | // InternalAlloyLanguage.g:2250:2: rule__ALSSignatureBody__Group_4_0__1__Impl | ||
7228 | { | ||
7229 | pushFollow(FOLLOW_2); | ||
7230 | rule__ALSSignatureBody__Group_4_0__1__Impl(); | ||
7231 | |||
7232 | state._fsp--; | ||
7233 | if (state.failed) return ; | ||
7234 | |||
7235 | } | ||
7236 | |||
7237 | } | ||
7238 | catch (RecognitionException re) { | ||
7239 | reportError(re); | ||
7240 | recover(input,re); | ||
7241 | } | ||
7242 | finally { | ||
7243 | |||
7244 | restoreStackSize(stackSize); | ||
7245 | |||
7246 | } | ||
7247 | return ; | ||
7248 | } | ||
7249 | // $ANTLR end "rule__ALSSignatureBody__Group_4_0__1" | ||
7250 | |||
7251 | |||
7252 | // $ANTLR start "rule__ALSSignatureBody__Group_4_0__1__Impl" | ||
7253 | // InternalAlloyLanguage.g:2256:1: rule__ALSSignatureBody__Group_4_0__1__Impl : ( ( rule__ALSSignatureBody__SupertypeAssignment_4_0_1 ) ) ; | ||
7254 | public final void rule__ALSSignatureBody__Group_4_0__1__Impl() throws RecognitionException { | ||
7255 | |||
7256 | int stackSize = keepStackSize(); | ||
7257 | |||
7258 | try { | ||
7259 | // InternalAlloyLanguage.g:2260:1: ( ( ( rule__ALSSignatureBody__SupertypeAssignment_4_0_1 ) ) ) | ||
7260 | // InternalAlloyLanguage.g:2261:1: ( ( rule__ALSSignatureBody__SupertypeAssignment_4_0_1 ) ) | ||
7261 | { | ||
7262 | // InternalAlloyLanguage.g:2261:1: ( ( rule__ALSSignatureBody__SupertypeAssignment_4_0_1 ) ) | ||
7263 | // InternalAlloyLanguage.g:2262:1: ( rule__ALSSignatureBody__SupertypeAssignment_4_0_1 ) | ||
7264 | { | ||
7265 | if ( state.backtracking==0 ) { | ||
7266 | before(grammarAccess.getALSSignatureBodyAccess().getSupertypeAssignment_4_0_1()); | ||
7267 | } | ||
7268 | // InternalAlloyLanguage.g:2263:1: ( rule__ALSSignatureBody__SupertypeAssignment_4_0_1 ) | ||
7269 | // InternalAlloyLanguage.g:2263:2: rule__ALSSignatureBody__SupertypeAssignment_4_0_1 | ||
7270 | { | ||
7271 | pushFollow(FOLLOW_2); | ||
7272 | rule__ALSSignatureBody__SupertypeAssignment_4_0_1(); | ||
7273 | |||
7274 | state._fsp--; | ||
7275 | if (state.failed) return ; | ||
7276 | |||
7277 | } | ||
7278 | |||
7279 | if ( state.backtracking==0 ) { | ||
7280 | after(grammarAccess.getALSSignatureBodyAccess().getSupertypeAssignment_4_0_1()); | ||
7281 | } | ||
7282 | |||
7283 | } | ||
7284 | |||
7285 | |||
7286 | } | ||
7287 | |||
7288 | } | ||
7289 | catch (RecognitionException re) { | ||
7290 | reportError(re); | ||
7291 | recover(input,re); | ||
7292 | } | ||
7293 | finally { | ||
7294 | |||
7295 | restoreStackSize(stackSize); | ||
7296 | |||
7297 | } | ||
7298 | return ; | ||
7299 | } | ||
7300 | // $ANTLR end "rule__ALSSignatureBody__Group_4_0__1__Impl" | ||
7301 | |||
7302 | |||
7303 | // $ANTLR start "rule__ALSSignatureBody__Group_4_1__0" | ||
7304 | // InternalAlloyLanguage.g:2277:1: rule__ALSSignatureBody__Group_4_1__0 : rule__ALSSignatureBody__Group_4_1__0__Impl rule__ALSSignatureBody__Group_4_1__1 ; | ||
7305 | public final void rule__ALSSignatureBody__Group_4_1__0() throws RecognitionException { | ||
7306 | |||
7307 | int stackSize = keepStackSize(); | ||
7308 | |||
7309 | try { | ||
7310 | // InternalAlloyLanguage.g:2281:1: ( rule__ALSSignatureBody__Group_4_1__0__Impl rule__ALSSignatureBody__Group_4_1__1 ) | ||
7311 | // InternalAlloyLanguage.g:2282:2: rule__ALSSignatureBody__Group_4_1__0__Impl rule__ALSSignatureBody__Group_4_1__1 | ||
7312 | { | ||
7313 | pushFollow(FOLLOW_5); | ||
7314 | rule__ALSSignatureBody__Group_4_1__0__Impl(); | ||
7315 | |||
7316 | state._fsp--; | ||
7317 | if (state.failed) return ; | ||
7318 | pushFollow(FOLLOW_2); | ||
7319 | rule__ALSSignatureBody__Group_4_1__1(); | ||
7320 | |||
7321 | state._fsp--; | ||
7322 | if (state.failed) return ; | ||
7323 | |||
7324 | } | ||
7325 | |||
7326 | } | ||
7327 | catch (RecognitionException re) { | ||
7328 | reportError(re); | ||
7329 | recover(input,re); | ||
7330 | } | ||
7331 | finally { | ||
7332 | |||
7333 | restoreStackSize(stackSize); | ||
7334 | |||
7335 | } | ||
7336 | return ; | ||
7337 | } | ||
7338 | // $ANTLR end "rule__ALSSignatureBody__Group_4_1__0" | ||
7339 | |||
7340 | |||
7341 | // $ANTLR start "rule__ALSSignatureBody__Group_4_1__0__Impl" | ||
7342 | // InternalAlloyLanguage.g:2289:1: rule__ALSSignatureBody__Group_4_1__0__Impl : ( 'in' ) ; | ||
7343 | public final void rule__ALSSignatureBody__Group_4_1__0__Impl() throws RecognitionException { | ||
7344 | |||
7345 | int stackSize = keepStackSize(); | ||
7346 | |||
7347 | try { | ||
7348 | // InternalAlloyLanguage.g:2293:1: ( ( 'in' ) ) | ||
7349 | // InternalAlloyLanguage.g:2294:1: ( 'in' ) | ||
7350 | { | ||
7351 | // InternalAlloyLanguage.g:2294:1: ( 'in' ) | ||
7352 | // InternalAlloyLanguage.g:2295:1: 'in' | ||
7353 | { | ||
7354 | if ( state.backtracking==0 ) { | ||
7355 | before(grammarAccess.getALSSignatureBodyAccess().getInKeyword_4_1_0()); | ||
7356 | } | ||
7357 | match(input,38,FOLLOW_2); if (state.failed) return ; | ||
7358 | if ( state.backtracking==0 ) { | ||
7359 | after(grammarAccess.getALSSignatureBodyAccess().getInKeyword_4_1_0()); | ||
7360 | } | ||
7361 | |||
7362 | } | ||
7363 | |||
7364 | |||
7365 | } | ||
7366 | |||
7367 | } | ||
7368 | catch (RecognitionException re) { | ||
7369 | reportError(re); | ||
7370 | recover(input,re); | ||
7371 | } | ||
7372 | finally { | ||
7373 | |||
7374 | restoreStackSize(stackSize); | ||
7375 | |||
7376 | } | ||
7377 | return ; | ||
7378 | } | ||
7379 | // $ANTLR end "rule__ALSSignatureBody__Group_4_1__0__Impl" | ||
7380 | |||
7381 | |||
7382 | // $ANTLR start "rule__ALSSignatureBody__Group_4_1__1" | ||
7383 | // InternalAlloyLanguage.g:2308:1: rule__ALSSignatureBody__Group_4_1__1 : rule__ALSSignatureBody__Group_4_1__1__Impl rule__ALSSignatureBody__Group_4_1__2 ; | ||
7384 | public final void rule__ALSSignatureBody__Group_4_1__1() throws RecognitionException { | ||
7385 | |||
7386 | int stackSize = keepStackSize(); | ||
7387 | |||
7388 | try { | ||
7389 | // InternalAlloyLanguage.g:2312:1: ( rule__ALSSignatureBody__Group_4_1__1__Impl rule__ALSSignatureBody__Group_4_1__2 ) | ||
7390 | // InternalAlloyLanguage.g:2313:2: rule__ALSSignatureBody__Group_4_1__1__Impl rule__ALSSignatureBody__Group_4_1__2 | ||
7391 | { | ||
7392 | pushFollow(FOLLOW_12); | ||
7393 | rule__ALSSignatureBody__Group_4_1__1__Impl(); | ||
7394 | |||
7395 | state._fsp--; | ||
7396 | if (state.failed) return ; | ||
7397 | pushFollow(FOLLOW_2); | ||
7398 | rule__ALSSignatureBody__Group_4_1__2(); | ||
7399 | |||
7400 | state._fsp--; | ||
7401 | if (state.failed) return ; | ||
7402 | |||
7403 | } | ||
7404 | |||
7405 | } | ||
7406 | catch (RecognitionException re) { | ||
7407 | reportError(re); | ||
7408 | recover(input,re); | ||
7409 | } | ||
7410 | finally { | ||
7411 | |||
7412 | restoreStackSize(stackSize); | ||
7413 | |||
7414 | } | ||
7415 | return ; | ||
7416 | } | ||
7417 | // $ANTLR end "rule__ALSSignatureBody__Group_4_1__1" | ||
7418 | |||
7419 | |||
7420 | // $ANTLR start "rule__ALSSignatureBody__Group_4_1__1__Impl" | ||
7421 | // InternalAlloyLanguage.g:2320:1: rule__ALSSignatureBody__Group_4_1__1__Impl : ( ( rule__ALSSignatureBody__SupersetAssignment_4_1_1 ) ) ; | ||
7422 | public final void rule__ALSSignatureBody__Group_4_1__1__Impl() throws RecognitionException { | ||
7423 | |||
7424 | int stackSize = keepStackSize(); | ||
7425 | |||
7426 | try { | ||
7427 | // InternalAlloyLanguage.g:2324:1: ( ( ( rule__ALSSignatureBody__SupersetAssignment_4_1_1 ) ) ) | ||
7428 | // InternalAlloyLanguage.g:2325:1: ( ( rule__ALSSignatureBody__SupersetAssignment_4_1_1 ) ) | ||
7429 | { | ||
7430 | // InternalAlloyLanguage.g:2325:1: ( ( rule__ALSSignatureBody__SupersetAssignment_4_1_1 ) ) | ||
7431 | // InternalAlloyLanguage.g:2326:1: ( rule__ALSSignatureBody__SupersetAssignment_4_1_1 ) | ||
7432 | { | ||
7433 | if ( state.backtracking==0 ) { | ||
7434 | before(grammarAccess.getALSSignatureBodyAccess().getSupersetAssignment_4_1_1()); | ||
7435 | } | ||
7436 | // InternalAlloyLanguage.g:2327:1: ( rule__ALSSignatureBody__SupersetAssignment_4_1_1 ) | ||
7437 | // InternalAlloyLanguage.g:2327:2: rule__ALSSignatureBody__SupersetAssignment_4_1_1 | ||
7438 | { | ||
7439 | pushFollow(FOLLOW_2); | ||
7440 | rule__ALSSignatureBody__SupersetAssignment_4_1_1(); | ||
7441 | |||
7442 | state._fsp--; | ||
7443 | if (state.failed) return ; | ||
7444 | |||
7445 | } | ||
7446 | |||
7447 | if ( state.backtracking==0 ) { | ||
7448 | after(grammarAccess.getALSSignatureBodyAccess().getSupersetAssignment_4_1_1()); | ||
7449 | } | ||
7450 | |||
7451 | } | ||
7452 | |||
7453 | |||
7454 | } | ||
7455 | |||
7456 | } | ||
7457 | catch (RecognitionException re) { | ||
7458 | reportError(re); | ||
7459 | recover(input,re); | ||
7460 | } | ||
7461 | finally { | ||
7462 | |||
7463 | restoreStackSize(stackSize); | ||
7464 | |||
7465 | } | ||
7466 | return ; | ||
7467 | } | ||
7468 | // $ANTLR end "rule__ALSSignatureBody__Group_4_1__1__Impl" | ||
7469 | |||
7470 | |||
7471 | // $ANTLR start "rule__ALSSignatureBody__Group_4_1__2" | ||
7472 | // InternalAlloyLanguage.g:2337:1: rule__ALSSignatureBody__Group_4_1__2 : rule__ALSSignatureBody__Group_4_1__2__Impl ; | ||
7473 | public final void rule__ALSSignatureBody__Group_4_1__2() throws RecognitionException { | ||
7474 | |||
7475 | int stackSize = keepStackSize(); | ||
7476 | |||
7477 | try { | ||
7478 | // InternalAlloyLanguage.g:2341:1: ( rule__ALSSignatureBody__Group_4_1__2__Impl ) | ||
7479 | // InternalAlloyLanguage.g:2342:2: rule__ALSSignatureBody__Group_4_1__2__Impl | ||
7480 | { | ||
7481 | pushFollow(FOLLOW_2); | ||
7482 | rule__ALSSignatureBody__Group_4_1__2__Impl(); | ||
7483 | |||
7484 | state._fsp--; | ||
7485 | if (state.failed) return ; | ||
7486 | |||
7487 | } | ||
7488 | |||
7489 | } | ||
7490 | catch (RecognitionException re) { | ||
7491 | reportError(re); | ||
7492 | recover(input,re); | ||
7493 | } | ||
7494 | finally { | ||
7495 | |||
7496 | restoreStackSize(stackSize); | ||
7497 | |||
7498 | } | ||
7499 | return ; | ||
7500 | } | ||
7501 | // $ANTLR end "rule__ALSSignatureBody__Group_4_1__2" | ||
7502 | |||
7503 | |||
7504 | // $ANTLR start "rule__ALSSignatureBody__Group_4_1__2__Impl" | ||
7505 | // InternalAlloyLanguage.g:2348:1: rule__ALSSignatureBody__Group_4_1__2__Impl : ( ( rule__ALSSignatureBody__Group_4_1_2__0 )* ) ; | ||
7506 | public final void rule__ALSSignatureBody__Group_4_1__2__Impl() throws RecognitionException { | ||
7507 | |||
7508 | int stackSize = keepStackSize(); | ||
7509 | |||
7510 | try { | ||
7511 | // InternalAlloyLanguage.g:2352:1: ( ( ( rule__ALSSignatureBody__Group_4_1_2__0 )* ) ) | ||
7512 | // InternalAlloyLanguage.g:2353:1: ( ( rule__ALSSignatureBody__Group_4_1_2__0 )* ) | ||
7513 | { | ||
7514 | // InternalAlloyLanguage.g:2353:1: ( ( rule__ALSSignatureBody__Group_4_1_2__0 )* ) | ||
7515 | // InternalAlloyLanguage.g:2354:1: ( rule__ALSSignatureBody__Group_4_1_2__0 )* | ||
7516 | { | ||
7517 | if ( state.backtracking==0 ) { | ||
7518 | before(grammarAccess.getALSSignatureBodyAccess().getGroup_4_1_2()); | ||
7519 | } | ||
7520 | // InternalAlloyLanguage.g:2355:1: ( rule__ALSSignatureBody__Group_4_1_2__0 )* | ||
7521 | loop22: | ||
7522 | do { | ||
7523 | int alt22=2; | ||
7524 | int LA22_0 = input.LA(1); | ||
7525 | |||
7526 | if ( (LA22_0==39) ) { | ||
7527 | alt22=1; | ||
7528 | } | ||
7529 | |||
7530 | |||
7531 | switch (alt22) { | ||
7532 | case 1 : | ||
7533 | // InternalAlloyLanguage.g:2355:2: rule__ALSSignatureBody__Group_4_1_2__0 | ||
7534 | { | ||
7535 | pushFollow(FOLLOW_13); | ||
7536 | rule__ALSSignatureBody__Group_4_1_2__0(); | ||
7537 | |||
7538 | state._fsp--; | ||
7539 | if (state.failed) return ; | ||
7540 | |||
7541 | } | ||
7542 | break; | ||
7543 | |||
7544 | default : | ||
7545 | break loop22; | ||
7546 | } | ||
7547 | } while (true); | ||
7548 | |||
7549 | if ( state.backtracking==0 ) { | ||
7550 | after(grammarAccess.getALSSignatureBodyAccess().getGroup_4_1_2()); | ||
7551 | } | ||
7552 | |||
7553 | } | ||
7554 | |||
7555 | |||
7556 | } | ||
7557 | |||
7558 | } | ||
7559 | catch (RecognitionException re) { | ||
7560 | reportError(re); | ||
7561 | recover(input,re); | ||
7562 | } | ||
7563 | finally { | ||
7564 | |||
7565 | restoreStackSize(stackSize); | ||
7566 | |||
7567 | } | ||
7568 | return ; | ||
7569 | } | ||
7570 | // $ANTLR end "rule__ALSSignatureBody__Group_4_1__2__Impl" | ||
7571 | |||
7572 | |||
7573 | // $ANTLR start "rule__ALSSignatureBody__Group_4_1_2__0" | ||
7574 | // InternalAlloyLanguage.g:2371:1: rule__ALSSignatureBody__Group_4_1_2__0 : rule__ALSSignatureBody__Group_4_1_2__0__Impl rule__ALSSignatureBody__Group_4_1_2__1 ; | ||
7575 | public final void rule__ALSSignatureBody__Group_4_1_2__0() throws RecognitionException { | ||
7576 | |||
7577 | int stackSize = keepStackSize(); | ||
7578 | |||
7579 | try { | ||
7580 | // InternalAlloyLanguage.g:2375:1: ( rule__ALSSignatureBody__Group_4_1_2__0__Impl rule__ALSSignatureBody__Group_4_1_2__1 ) | ||
7581 | // InternalAlloyLanguage.g:2376:2: rule__ALSSignatureBody__Group_4_1_2__0__Impl rule__ALSSignatureBody__Group_4_1_2__1 | ||
7582 | { | ||
7583 | pushFollow(FOLLOW_5); | ||
7584 | rule__ALSSignatureBody__Group_4_1_2__0__Impl(); | ||
7585 | |||
7586 | state._fsp--; | ||
7587 | if (state.failed) return ; | ||
7588 | pushFollow(FOLLOW_2); | ||
7589 | rule__ALSSignatureBody__Group_4_1_2__1(); | ||
7590 | |||
7591 | state._fsp--; | ||
7592 | if (state.failed) return ; | ||
7593 | |||
7594 | } | ||
7595 | |||
7596 | } | ||
7597 | catch (RecognitionException re) { | ||
7598 | reportError(re); | ||
7599 | recover(input,re); | ||
7600 | } | ||
7601 | finally { | ||
7602 | |||
7603 | restoreStackSize(stackSize); | ||
7604 | |||
7605 | } | ||
7606 | return ; | ||
7607 | } | ||
7608 | // $ANTLR end "rule__ALSSignatureBody__Group_4_1_2__0" | ||
7609 | |||
7610 | |||
7611 | // $ANTLR start "rule__ALSSignatureBody__Group_4_1_2__0__Impl" | ||
7612 | // InternalAlloyLanguage.g:2383:1: rule__ALSSignatureBody__Group_4_1_2__0__Impl : ( '+' ) ; | ||
7613 | public final void rule__ALSSignatureBody__Group_4_1_2__0__Impl() throws RecognitionException { | ||
7614 | |||
7615 | int stackSize = keepStackSize(); | ||
7616 | |||
7617 | try { | ||
7618 | // InternalAlloyLanguage.g:2387:1: ( ( '+' ) ) | ||
7619 | // InternalAlloyLanguage.g:2388:1: ( '+' ) | ||
7620 | { | ||
7621 | // InternalAlloyLanguage.g:2388:1: ( '+' ) | ||
7622 | // InternalAlloyLanguage.g:2389:1: '+' | ||
7623 | { | ||
7624 | if ( state.backtracking==0 ) { | ||
7625 | before(grammarAccess.getALSSignatureBodyAccess().getPlusSignKeyword_4_1_2_0()); | ||
7626 | } | ||
7627 | match(input,39,FOLLOW_2); if (state.failed) return ; | ||
7628 | if ( state.backtracking==0 ) { | ||
7629 | after(grammarAccess.getALSSignatureBodyAccess().getPlusSignKeyword_4_1_2_0()); | ||
7630 | } | ||
7631 | |||
7632 | } | ||
7633 | |||
7634 | |||
7635 | } | ||
7636 | |||
7637 | } | ||
7638 | catch (RecognitionException re) { | ||
7639 | reportError(re); | ||
7640 | recover(input,re); | ||
7641 | } | ||
7642 | finally { | ||
7643 | |||
7644 | restoreStackSize(stackSize); | ||
7645 | |||
7646 | } | ||
7647 | return ; | ||
7648 | } | ||
7649 | // $ANTLR end "rule__ALSSignatureBody__Group_4_1_2__0__Impl" | ||
7650 | |||
7651 | |||
7652 | // $ANTLR start "rule__ALSSignatureBody__Group_4_1_2__1" | ||
7653 | // InternalAlloyLanguage.g:2402:1: rule__ALSSignatureBody__Group_4_1_2__1 : rule__ALSSignatureBody__Group_4_1_2__1__Impl ; | ||
7654 | public final void rule__ALSSignatureBody__Group_4_1_2__1() throws RecognitionException { | ||
7655 | |||
7656 | int stackSize = keepStackSize(); | ||
7657 | |||
7658 | try { | ||
7659 | // InternalAlloyLanguage.g:2406:1: ( rule__ALSSignatureBody__Group_4_1_2__1__Impl ) | ||
7660 | // InternalAlloyLanguage.g:2407:2: rule__ALSSignatureBody__Group_4_1_2__1__Impl | ||
7661 | { | ||
7662 | pushFollow(FOLLOW_2); | ||
7663 | rule__ALSSignatureBody__Group_4_1_2__1__Impl(); | ||
7664 | |||
7665 | state._fsp--; | ||
7666 | if (state.failed) return ; | ||
7667 | |||
7668 | } | ||
7669 | |||
7670 | } | ||
7671 | catch (RecognitionException re) { | ||
7672 | reportError(re); | ||
7673 | recover(input,re); | ||
7674 | } | ||
7675 | finally { | ||
7676 | |||
7677 | restoreStackSize(stackSize); | ||
7678 | |||
7679 | } | ||
7680 | return ; | ||
7681 | } | ||
7682 | // $ANTLR end "rule__ALSSignatureBody__Group_4_1_2__1" | ||
7683 | |||
7684 | |||
7685 | // $ANTLR start "rule__ALSSignatureBody__Group_4_1_2__1__Impl" | ||
7686 | // InternalAlloyLanguage.g:2413:1: rule__ALSSignatureBody__Group_4_1_2__1__Impl : ( ( rule__ALSSignatureBody__SupersetAssignment_4_1_2_1 ) ) ; | ||
7687 | public final void rule__ALSSignatureBody__Group_4_1_2__1__Impl() throws RecognitionException { | ||
7688 | |||
7689 | int stackSize = keepStackSize(); | ||
7690 | |||
7691 | try { | ||
7692 | // InternalAlloyLanguage.g:2417:1: ( ( ( rule__ALSSignatureBody__SupersetAssignment_4_1_2_1 ) ) ) | ||
7693 | // InternalAlloyLanguage.g:2418:1: ( ( rule__ALSSignatureBody__SupersetAssignment_4_1_2_1 ) ) | ||
7694 | { | ||
7695 | // InternalAlloyLanguage.g:2418:1: ( ( rule__ALSSignatureBody__SupersetAssignment_4_1_2_1 ) ) | ||
7696 | // InternalAlloyLanguage.g:2419:1: ( rule__ALSSignatureBody__SupersetAssignment_4_1_2_1 ) | ||
7697 | { | ||
7698 | if ( state.backtracking==0 ) { | ||
7699 | before(grammarAccess.getALSSignatureBodyAccess().getSupersetAssignment_4_1_2_1()); | ||
7700 | } | ||
7701 | // InternalAlloyLanguage.g:2420:1: ( rule__ALSSignatureBody__SupersetAssignment_4_1_2_1 ) | ||
7702 | // InternalAlloyLanguage.g:2420:2: rule__ALSSignatureBody__SupersetAssignment_4_1_2_1 | ||
7703 | { | ||
7704 | pushFollow(FOLLOW_2); | ||
7705 | rule__ALSSignatureBody__SupersetAssignment_4_1_2_1(); | ||
7706 | |||
7707 | state._fsp--; | ||
7708 | if (state.failed) return ; | ||
7709 | |||
7710 | } | ||
7711 | |||
7712 | if ( state.backtracking==0 ) { | ||
7713 | after(grammarAccess.getALSSignatureBodyAccess().getSupersetAssignment_4_1_2_1()); | ||
7714 | } | ||
7715 | |||
7716 | } | ||
7717 | |||
7718 | |||
7719 | } | ||
7720 | |||
7721 | } | ||
7722 | catch (RecognitionException re) { | ||
7723 | reportError(re); | ||
7724 | recover(input,re); | ||
7725 | } | ||
7726 | finally { | ||
7727 | |||
7728 | restoreStackSize(stackSize); | ||
7729 | |||
7730 | } | ||
7731 | return ; | ||
7732 | } | ||
7733 | // $ANTLR end "rule__ALSSignatureBody__Group_4_1_2__1__Impl" | ||
7734 | |||
7735 | |||
7736 | // $ANTLR start "rule__ALSSignatureBody__Group_6__0" | ||
7737 | // InternalAlloyLanguage.g:2434:1: rule__ALSSignatureBody__Group_6__0 : rule__ALSSignatureBody__Group_6__0__Impl rule__ALSSignatureBody__Group_6__1 ; | ||
7738 | public final void rule__ALSSignatureBody__Group_6__0() throws RecognitionException { | ||
7739 | |||
7740 | int stackSize = keepStackSize(); | ||
7741 | |||
7742 | try { | ||
7743 | // InternalAlloyLanguage.g:2438:1: ( rule__ALSSignatureBody__Group_6__0__Impl rule__ALSSignatureBody__Group_6__1 ) | ||
7744 | // InternalAlloyLanguage.g:2439:2: rule__ALSSignatureBody__Group_6__0__Impl rule__ALSSignatureBody__Group_6__1 | ||
7745 | { | ||
7746 | pushFollow(FOLLOW_14); | ||
7747 | rule__ALSSignatureBody__Group_6__0__Impl(); | ||
7748 | |||
7749 | state._fsp--; | ||
7750 | if (state.failed) return ; | ||
7751 | pushFollow(FOLLOW_2); | ||
7752 | rule__ALSSignatureBody__Group_6__1(); | ||
7753 | |||
7754 | state._fsp--; | ||
7755 | if (state.failed) return ; | ||
7756 | |||
7757 | } | ||
7758 | |||
7759 | } | ||
7760 | catch (RecognitionException re) { | ||
7761 | reportError(re); | ||
7762 | recover(input,re); | ||
7763 | } | ||
7764 | finally { | ||
7765 | |||
7766 | restoreStackSize(stackSize); | ||
7767 | |||
7768 | } | ||
7769 | return ; | ||
7770 | } | ||
7771 | // $ANTLR end "rule__ALSSignatureBody__Group_6__0" | ||
7772 | |||
7773 | |||
7774 | // $ANTLR start "rule__ALSSignatureBody__Group_6__0__Impl" | ||
7775 | // InternalAlloyLanguage.g:2446:1: rule__ALSSignatureBody__Group_6__0__Impl : ( ( rule__ALSSignatureBody__FieldsAssignment_6_0 ) ) ; | ||
7776 | public final void rule__ALSSignatureBody__Group_6__0__Impl() throws RecognitionException { | ||
7777 | |||
7778 | int stackSize = keepStackSize(); | ||
7779 | |||
7780 | try { | ||
7781 | // InternalAlloyLanguage.g:2450:1: ( ( ( rule__ALSSignatureBody__FieldsAssignment_6_0 ) ) ) | ||
7782 | // InternalAlloyLanguage.g:2451:1: ( ( rule__ALSSignatureBody__FieldsAssignment_6_0 ) ) | ||
7783 | { | ||
7784 | // InternalAlloyLanguage.g:2451:1: ( ( rule__ALSSignatureBody__FieldsAssignment_6_0 ) ) | ||
7785 | // InternalAlloyLanguage.g:2452:1: ( rule__ALSSignatureBody__FieldsAssignment_6_0 ) | ||
7786 | { | ||
7787 | if ( state.backtracking==0 ) { | ||
7788 | before(grammarAccess.getALSSignatureBodyAccess().getFieldsAssignment_6_0()); | ||
7789 | } | ||
7790 | // InternalAlloyLanguage.g:2453:1: ( rule__ALSSignatureBody__FieldsAssignment_6_0 ) | ||
7791 | // InternalAlloyLanguage.g:2453:2: rule__ALSSignatureBody__FieldsAssignment_6_0 | ||
7792 | { | ||
7793 | pushFollow(FOLLOW_2); | ||
7794 | rule__ALSSignatureBody__FieldsAssignment_6_0(); | ||
7795 | |||
7796 | state._fsp--; | ||
7797 | if (state.failed) return ; | ||
7798 | |||
7799 | } | ||
7800 | |||
7801 | if ( state.backtracking==0 ) { | ||
7802 | after(grammarAccess.getALSSignatureBodyAccess().getFieldsAssignment_6_0()); | ||
7803 | } | ||
7804 | |||
7805 | } | ||
7806 | |||
7807 | |||
7808 | } | ||
7809 | |||
7810 | } | ||
7811 | catch (RecognitionException re) { | ||
7812 | reportError(re); | ||
7813 | recover(input,re); | ||
7814 | } | ||
7815 | finally { | ||
7816 | |||
7817 | restoreStackSize(stackSize); | ||
7818 | |||
7819 | } | ||
7820 | return ; | ||
7821 | } | ||
7822 | // $ANTLR end "rule__ALSSignatureBody__Group_6__0__Impl" | ||
7823 | |||
7824 | |||
7825 | // $ANTLR start "rule__ALSSignatureBody__Group_6__1" | ||
7826 | // InternalAlloyLanguage.g:2463:1: rule__ALSSignatureBody__Group_6__1 : rule__ALSSignatureBody__Group_6__1__Impl ; | ||
7827 | public final void rule__ALSSignatureBody__Group_6__1() throws RecognitionException { | ||
7828 | |||
7829 | int stackSize = keepStackSize(); | ||
7830 | |||
7831 | try { | ||
7832 | // InternalAlloyLanguage.g:2467:1: ( rule__ALSSignatureBody__Group_6__1__Impl ) | ||
7833 | // InternalAlloyLanguage.g:2468:2: rule__ALSSignatureBody__Group_6__1__Impl | ||
7834 | { | ||
7835 | pushFollow(FOLLOW_2); | ||
7836 | rule__ALSSignatureBody__Group_6__1__Impl(); | ||
7837 | |||
7838 | state._fsp--; | ||
7839 | if (state.failed) return ; | ||
7840 | |||
7841 | } | ||
7842 | |||
7843 | } | ||
7844 | catch (RecognitionException re) { | ||
7845 | reportError(re); | ||
7846 | recover(input,re); | ||
7847 | } | ||
7848 | finally { | ||
7849 | |||
7850 | restoreStackSize(stackSize); | ||
7851 | |||
7852 | } | ||
7853 | return ; | ||
7854 | } | ||
7855 | // $ANTLR end "rule__ALSSignatureBody__Group_6__1" | ||
7856 | |||
7857 | |||
7858 | // $ANTLR start "rule__ALSSignatureBody__Group_6__1__Impl" | ||
7859 | // InternalAlloyLanguage.g:2474:1: rule__ALSSignatureBody__Group_6__1__Impl : ( ( rule__ALSSignatureBody__Group_6_1__0 )* ) ; | ||
7860 | public final void rule__ALSSignatureBody__Group_6__1__Impl() throws RecognitionException { | ||
7861 | |||
7862 | int stackSize = keepStackSize(); | ||
7863 | |||
7864 | try { | ||
7865 | // InternalAlloyLanguage.g:2478:1: ( ( ( rule__ALSSignatureBody__Group_6_1__0 )* ) ) | ||
7866 | // InternalAlloyLanguage.g:2479:1: ( ( rule__ALSSignatureBody__Group_6_1__0 )* ) | ||
7867 | { | ||
7868 | // InternalAlloyLanguage.g:2479:1: ( ( rule__ALSSignatureBody__Group_6_1__0 )* ) | ||
7869 | // InternalAlloyLanguage.g:2480:1: ( rule__ALSSignatureBody__Group_6_1__0 )* | ||
7870 | { | ||
7871 | if ( state.backtracking==0 ) { | ||
7872 | before(grammarAccess.getALSSignatureBodyAccess().getGroup_6_1()); | ||
7873 | } | ||
7874 | // InternalAlloyLanguage.g:2481:1: ( rule__ALSSignatureBody__Group_6_1__0 )* | ||
7875 | loop23: | ||
7876 | do { | ||
7877 | int alt23=2; | ||
7878 | int LA23_0 = input.LA(1); | ||
7879 | |||
7880 | if ( (LA23_0==35) ) { | ||
7881 | alt23=1; | ||
7882 | } | ||
7883 | |||
7884 | |||
7885 | switch (alt23) { | ||
7886 | case 1 : | ||
7887 | // InternalAlloyLanguage.g:2481:2: rule__ALSSignatureBody__Group_6_1__0 | ||
7888 | { | ||
7889 | pushFollow(FOLLOW_8); | ||
7890 | rule__ALSSignatureBody__Group_6_1__0(); | ||
7891 | |||
7892 | state._fsp--; | ||
7893 | if (state.failed) return ; | ||
7894 | |||
7895 | } | ||
7896 | break; | ||
7897 | |||
7898 | default : | ||
7899 | break loop23; | ||
7900 | } | ||
7901 | } while (true); | ||
7902 | |||
7903 | if ( state.backtracking==0 ) { | ||
7904 | after(grammarAccess.getALSSignatureBodyAccess().getGroup_6_1()); | ||
7905 | } | ||
7906 | |||
7907 | } | ||
7908 | |||
7909 | |||
7910 | } | ||
7911 | |||
7912 | } | ||
7913 | catch (RecognitionException re) { | ||
7914 | reportError(re); | ||
7915 | recover(input,re); | ||
7916 | } | ||
7917 | finally { | ||
7918 | |||
7919 | restoreStackSize(stackSize); | ||
7920 | |||
7921 | } | ||
7922 | return ; | ||
7923 | } | ||
7924 | // $ANTLR end "rule__ALSSignatureBody__Group_6__1__Impl" | ||
7925 | |||
7926 | |||
7927 | // $ANTLR start "rule__ALSSignatureBody__Group_6_1__0" | ||
7928 | // InternalAlloyLanguage.g:2495:1: rule__ALSSignatureBody__Group_6_1__0 : rule__ALSSignatureBody__Group_6_1__0__Impl rule__ALSSignatureBody__Group_6_1__1 ; | ||
7929 | public final void rule__ALSSignatureBody__Group_6_1__0() throws RecognitionException { | ||
7930 | |||
7931 | int stackSize = keepStackSize(); | ||
7932 | |||
7933 | try { | ||
7934 | // InternalAlloyLanguage.g:2499:1: ( rule__ALSSignatureBody__Group_6_1__0__Impl rule__ALSSignatureBody__Group_6_1__1 ) | ||
7935 | // InternalAlloyLanguage.g:2500:2: rule__ALSSignatureBody__Group_6_1__0__Impl rule__ALSSignatureBody__Group_6_1__1 | ||
7936 | { | ||
7937 | pushFollow(FOLLOW_5); | ||
7938 | rule__ALSSignatureBody__Group_6_1__0__Impl(); | ||
7939 | |||
7940 | state._fsp--; | ||
7941 | if (state.failed) return ; | ||
7942 | pushFollow(FOLLOW_2); | ||
7943 | rule__ALSSignatureBody__Group_6_1__1(); | ||
7944 | |||
7945 | state._fsp--; | ||
7946 | if (state.failed) return ; | ||
7947 | |||
7948 | } | ||
7949 | |||
7950 | } | ||
7951 | catch (RecognitionException re) { | ||
7952 | reportError(re); | ||
7953 | recover(input,re); | ||
7954 | } | ||
7955 | finally { | ||
7956 | |||
7957 | restoreStackSize(stackSize); | ||
7958 | |||
7959 | } | ||
7960 | return ; | ||
7961 | } | ||
7962 | // $ANTLR end "rule__ALSSignatureBody__Group_6_1__0" | ||
7963 | |||
7964 | |||
7965 | // $ANTLR start "rule__ALSSignatureBody__Group_6_1__0__Impl" | ||
7966 | // InternalAlloyLanguage.g:2507:1: rule__ALSSignatureBody__Group_6_1__0__Impl : ( ',' ) ; | ||
7967 | public final void rule__ALSSignatureBody__Group_6_1__0__Impl() throws RecognitionException { | ||
7968 | |||
7969 | int stackSize = keepStackSize(); | ||
7970 | |||
7971 | try { | ||
7972 | // InternalAlloyLanguage.g:2511:1: ( ( ',' ) ) | ||
7973 | // InternalAlloyLanguage.g:2512:1: ( ',' ) | ||
7974 | { | ||
7975 | // InternalAlloyLanguage.g:2512:1: ( ',' ) | ||
7976 | // InternalAlloyLanguage.g:2513:1: ',' | ||
7977 | { | ||
7978 | if ( state.backtracking==0 ) { | ||
7979 | before(grammarAccess.getALSSignatureBodyAccess().getCommaKeyword_6_1_0()); | ||
7980 | } | ||
7981 | match(input,35,FOLLOW_2); if (state.failed) return ; | ||
7982 | if ( state.backtracking==0 ) { | ||
7983 | after(grammarAccess.getALSSignatureBodyAccess().getCommaKeyword_6_1_0()); | ||
7984 | } | ||
7985 | |||
7986 | } | ||
7987 | |||
7988 | |||
7989 | } | ||
7990 | |||
7991 | } | ||
7992 | catch (RecognitionException re) { | ||
7993 | reportError(re); | ||
7994 | recover(input,re); | ||
7995 | } | ||
7996 | finally { | ||
7997 | |||
7998 | restoreStackSize(stackSize); | ||
7999 | |||
8000 | } | ||
8001 | return ; | ||
8002 | } | ||
8003 | // $ANTLR end "rule__ALSSignatureBody__Group_6_1__0__Impl" | ||
8004 | |||
8005 | |||
8006 | // $ANTLR start "rule__ALSSignatureBody__Group_6_1__1" | ||
8007 | // InternalAlloyLanguage.g:2526:1: rule__ALSSignatureBody__Group_6_1__1 : rule__ALSSignatureBody__Group_6_1__1__Impl ; | ||
8008 | public final void rule__ALSSignatureBody__Group_6_1__1() throws RecognitionException { | ||
8009 | |||
8010 | int stackSize = keepStackSize(); | ||
8011 | |||
8012 | try { | ||
8013 | // InternalAlloyLanguage.g:2530:1: ( rule__ALSSignatureBody__Group_6_1__1__Impl ) | ||
8014 | // InternalAlloyLanguage.g:2531:2: rule__ALSSignatureBody__Group_6_1__1__Impl | ||
8015 | { | ||
8016 | pushFollow(FOLLOW_2); | ||
8017 | rule__ALSSignatureBody__Group_6_1__1__Impl(); | ||
8018 | |||
8019 | state._fsp--; | ||
8020 | if (state.failed) return ; | ||
8021 | |||
8022 | } | ||
8023 | |||
8024 | } | ||
8025 | catch (RecognitionException re) { | ||
8026 | reportError(re); | ||
8027 | recover(input,re); | ||
8028 | } | ||
8029 | finally { | ||
8030 | |||
8031 | restoreStackSize(stackSize); | ||
8032 | |||
8033 | } | ||
8034 | return ; | ||
8035 | } | ||
8036 | // $ANTLR end "rule__ALSSignatureBody__Group_6_1__1" | ||
8037 | |||
8038 | |||
8039 | // $ANTLR start "rule__ALSSignatureBody__Group_6_1__1__Impl" | ||
8040 | // InternalAlloyLanguage.g:2537:1: rule__ALSSignatureBody__Group_6_1__1__Impl : ( ( rule__ALSSignatureBody__FieldsAssignment_6_1_1 ) ) ; | ||
8041 | public final void rule__ALSSignatureBody__Group_6_1__1__Impl() throws RecognitionException { | ||
8042 | |||
8043 | int stackSize = keepStackSize(); | ||
8044 | |||
8045 | try { | ||
8046 | // InternalAlloyLanguage.g:2541:1: ( ( ( rule__ALSSignatureBody__FieldsAssignment_6_1_1 ) ) ) | ||
8047 | // InternalAlloyLanguage.g:2542:1: ( ( rule__ALSSignatureBody__FieldsAssignment_6_1_1 ) ) | ||
8048 | { | ||
8049 | // InternalAlloyLanguage.g:2542:1: ( ( rule__ALSSignatureBody__FieldsAssignment_6_1_1 ) ) | ||
8050 | // InternalAlloyLanguage.g:2543:1: ( rule__ALSSignatureBody__FieldsAssignment_6_1_1 ) | ||
8051 | { | ||
8052 | if ( state.backtracking==0 ) { | ||
8053 | before(grammarAccess.getALSSignatureBodyAccess().getFieldsAssignment_6_1_1()); | ||
8054 | } | ||
8055 | // InternalAlloyLanguage.g:2544:1: ( rule__ALSSignatureBody__FieldsAssignment_6_1_1 ) | ||
8056 | // InternalAlloyLanguage.g:2544:2: rule__ALSSignatureBody__FieldsAssignment_6_1_1 | ||
8057 | { | ||
8058 | pushFollow(FOLLOW_2); | ||
8059 | rule__ALSSignatureBody__FieldsAssignment_6_1_1(); | ||
8060 | |||
8061 | state._fsp--; | ||
8062 | if (state.failed) return ; | ||
8063 | |||
8064 | } | ||
8065 | |||
8066 | if ( state.backtracking==0 ) { | ||
8067 | after(grammarAccess.getALSSignatureBodyAccess().getFieldsAssignment_6_1_1()); | ||
8068 | } | ||
8069 | |||
8070 | } | ||
8071 | |||
8072 | |||
8073 | } | ||
8074 | |||
8075 | } | ||
8076 | catch (RecognitionException re) { | ||
8077 | reportError(re); | ||
8078 | recover(input,re); | ||
8079 | } | ||
8080 | finally { | ||
8081 | |||
8082 | restoreStackSize(stackSize); | ||
8083 | |||
8084 | } | ||
8085 | return ; | ||
8086 | } | ||
8087 | // $ANTLR end "rule__ALSSignatureBody__Group_6_1__1__Impl" | ||
8088 | |||
8089 | |||
8090 | // $ANTLR start "rule__ALSFieldDeclaration__Group__0" | ||
8091 | // InternalAlloyLanguage.g:2558:1: rule__ALSFieldDeclaration__Group__0 : rule__ALSFieldDeclaration__Group__0__Impl rule__ALSFieldDeclaration__Group__1 ; | ||
8092 | public final void rule__ALSFieldDeclaration__Group__0() throws RecognitionException { | ||
8093 | |||
8094 | int stackSize = keepStackSize(); | ||
8095 | |||
8096 | try { | ||
8097 | // InternalAlloyLanguage.g:2562:1: ( rule__ALSFieldDeclaration__Group__0__Impl rule__ALSFieldDeclaration__Group__1 ) | ||
8098 | // InternalAlloyLanguage.g:2563:2: rule__ALSFieldDeclaration__Group__0__Impl rule__ALSFieldDeclaration__Group__1 | ||
8099 | { | ||
8100 | pushFollow(FOLLOW_15); | ||
8101 | rule__ALSFieldDeclaration__Group__0__Impl(); | ||
8102 | |||
8103 | state._fsp--; | ||
8104 | if (state.failed) return ; | ||
8105 | pushFollow(FOLLOW_2); | ||
8106 | rule__ALSFieldDeclaration__Group__1(); | ||
8107 | |||
8108 | state._fsp--; | ||
8109 | if (state.failed) return ; | ||
8110 | |||
8111 | } | ||
8112 | |||
8113 | } | ||
8114 | catch (RecognitionException re) { | ||
8115 | reportError(re); | ||
8116 | recover(input,re); | ||
8117 | } | ||
8118 | finally { | ||
8119 | |||
8120 | restoreStackSize(stackSize); | ||
8121 | |||
8122 | } | ||
8123 | return ; | ||
8124 | } | ||
8125 | // $ANTLR end "rule__ALSFieldDeclaration__Group__0" | ||
8126 | |||
8127 | |||
8128 | // $ANTLR start "rule__ALSFieldDeclaration__Group__0__Impl" | ||
8129 | // InternalAlloyLanguage.g:2570:1: rule__ALSFieldDeclaration__Group__0__Impl : ( ( rule__ALSFieldDeclaration__NameAssignment_0 ) ) ; | ||
8130 | public final void rule__ALSFieldDeclaration__Group__0__Impl() throws RecognitionException { | ||
8131 | |||
8132 | int stackSize = keepStackSize(); | ||
8133 | |||
8134 | try { | ||
8135 | // InternalAlloyLanguage.g:2574:1: ( ( ( rule__ALSFieldDeclaration__NameAssignment_0 ) ) ) | ||
8136 | // InternalAlloyLanguage.g:2575:1: ( ( rule__ALSFieldDeclaration__NameAssignment_0 ) ) | ||
8137 | { | ||
8138 | // InternalAlloyLanguage.g:2575:1: ( ( rule__ALSFieldDeclaration__NameAssignment_0 ) ) | ||
8139 | // InternalAlloyLanguage.g:2576:1: ( rule__ALSFieldDeclaration__NameAssignment_0 ) | ||
8140 | { | ||
8141 | if ( state.backtracking==0 ) { | ||
8142 | before(grammarAccess.getALSFieldDeclarationAccess().getNameAssignment_0()); | ||
8143 | } | ||
8144 | // InternalAlloyLanguage.g:2577:1: ( rule__ALSFieldDeclaration__NameAssignment_0 ) | ||
8145 | // InternalAlloyLanguage.g:2577:2: rule__ALSFieldDeclaration__NameAssignment_0 | ||
8146 | { | ||
8147 | pushFollow(FOLLOW_2); | ||
8148 | rule__ALSFieldDeclaration__NameAssignment_0(); | ||
8149 | |||
8150 | state._fsp--; | ||
8151 | if (state.failed) return ; | ||
8152 | |||
8153 | } | ||
8154 | |||
8155 | if ( state.backtracking==0 ) { | ||
8156 | after(grammarAccess.getALSFieldDeclarationAccess().getNameAssignment_0()); | ||
8157 | } | ||
8158 | |||
8159 | } | ||
8160 | |||
8161 | |||
8162 | } | ||
8163 | |||
8164 | } | ||
8165 | catch (RecognitionException re) { | ||
8166 | reportError(re); | ||
8167 | recover(input,re); | ||
8168 | } | ||
8169 | finally { | ||
8170 | |||
8171 | restoreStackSize(stackSize); | ||
8172 | |||
8173 | } | ||
8174 | return ; | ||
8175 | } | ||
8176 | // $ANTLR end "rule__ALSFieldDeclaration__Group__0__Impl" | ||
8177 | |||
8178 | |||
8179 | // $ANTLR start "rule__ALSFieldDeclaration__Group__1" | ||
8180 | // InternalAlloyLanguage.g:2587:1: rule__ALSFieldDeclaration__Group__1 : rule__ALSFieldDeclaration__Group__1__Impl rule__ALSFieldDeclaration__Group__2 ; | ||
8181 | public final void rule__ALSFieldDeclaration__Group__1() throws RecognitionException { | ||
8182 | |||
8183 | int stackSize = keepStackSize(); | ||
8184 | |||
8185 | try { | ||
8186 | // InternalAlloyLanguage.g:2591:1: ( rule__ALSFieldDeclaration__Group__1__Impl rule__ALSFieldDeclaration__Group__2 ) | ||
8187 | // InternalAlloyLanguage.g:2592:2: rule__ALSFieldDeclaration__Group__1__Impl rule__ALSFieldDeclaration__Group__2 | ||
8188 | { | ||
8189 | pushFollow(FOLLOW_16); | ||
8190 | rule__ALSFieldDeclaration__Group__1__Impl(); | ||
8191 | |||
8192 | state._fsp--; | ||
8193 | if (state.failed) return ; | ||
8194 | pushFollow(FOLLOW_2); | ||
8195 | rule__ALSFieldDeclaration__Group__2(); | ||
8196 | |||
8197 | state._fsp--; | ||
8198 | if (state.failed) return ; | ||
8199 | |||
8200 | } | ||
8201 | |||
8202 | } | ||
8203 | catch (RecognitionException re) { | ||
8204 | reportError(re); | ||
8205 | recover(input,re); | ||
8206 | } | ||
8207 | finally { | ||
8208 | |||
8209 | restoreStackSize(stackSize); | ||
8210 | |||
8211 | } | ||
8212 | return ; | ||
8213 | } | ||
8214 | // $ANTLR end "rule__ALSFieldDeclaration__Group__1" | ||
8215 | |||
8216 | |||
8217 | // $ANTLR start "rule__ALSFieldDeclaration__Group__1__Impl" | ||
8218 | // InternalAlloyLanguage.g:2599:1: rule__ALSFieldDeclaration__Group__1__Impl : ( ':' ) ; | ||
8219 | public final void rule__ALSFieldDeclaration__Group__1__Impl() throws RecognitionException { | ||
8220 | |||
8221 | int stackSize = keepStackSize(); | ||
8222 | |||
8223 | try { | ||
8224 | // InternalAlloyLanguage.g:2603:1: ( ( ':' ) ) | ||
8225 | // InternalAlloyLanguage.g:2604:1: ( ':' ) | ||
8226 | { | ||
8227 | // InternalAlloyLanguage.g:2604:1: ( ':' ) | ||
8228 | // InternalAlloyLanguage.g:2605:1: ':' | ||
8229 | { | ||
8230 | if ( state.backtracking==0 ) { | ||
8231 | before(grammarAccess.getALSFieldDeclarationAccess().getColonKeyword_1()); | ||
8232 | } | ||
8233 | match(input,40,FOLLOW_2); if (state.failed) return ; | ||
8234 | if ( state.backtracking==0 ) { | ||
8235 | after(grammarAccess.getALSFieldDeclarationAccess().getColonKeyword_1()); | ||
8236 | } | ||
8237 | |||
8238 | } | ||
8239 | |||
8240 | |||
8241 | } | ||
8242 | |||
8243 | } | ||
8244 | catch (RecognitionException re) { | ||
8245 | reportError(re); | ||
8246 | recover(input,re); | ||
8247 | } | ||
8248 | finally { | ||
8249 | |||
8250 | restoreStackSize(stackSize); | ||
8251 | |||
8252 | } | ||
8253 | return ; | ||
8254 | } | ||
8255 | // $ANTLR end "rule__ALSFieldDeclaration__Group__1__Impl" | ||
8256 | |||
8257 | |||
8258 | // $ANTLR start "rule__ALSFieldDeclaration__Group__2" | ||
8259 | // InternalAlloyLanguage.g:2618:1: rule__ALSFieldDeclaration__Group__2 : rule__ALSFieldDeclaration__Group__2__Impl rule__ALSFieldDeclaration__Group__3 ; | ||
8260 | public final void rule__ALSFieldDeclaration__Group__2() throws RecognitionException { | ||
8261 | |||
8262 | int stackSize = keepStackSize(); | ||
8263 | |||
8264 | try { | ||
8265 | // InternalAlloyLanguage.g:2622:1: ( rule__ALSFieldDeclaration__Group__2__Impl rule__ALSFieldDeclaration__Group__3 ) | ||
8266 | // InternalAlloyLanguage.g:2623:2: rule__ALSFieldDeclaration__Group__2__Impl rule__ALSFieldDeclaration__Group__3 | ||
8267 | { | ||
8268 | pushFollow(FOLLOW_16); | ||
8269 | rule__ALSFieldDeclaration__Group__2__Impl(); | ||
8270 | |||
8271 | state._fsp--; | ||
8272 | if (state.failed) return ; | ||
8273 | pushFollow(FOLLOW_2); | ||
8274 | rule__ALSFieldDeclaration__Group__3(); | ||
8275 | |||
8276 | state._fsp--; | ||
8277 | if (state.failed) return ; | ||
8278 | |||
8279 | } | ||
8280 | |||
8281 | } | ||
8282 | catch (RecognitionException re) { | ||
8283 | reportError(re); | ||
8284 | recover(input,re); | ||
8285 | } | ||
8286 | finally { | ||
8287 | |||
8288 | restoreStackSize(stackSize); | ||
8289 | |||
8290 | } | ||
8291 | return ; | ||
8292 | } | ||
8293 | // $ANTLR end "rule__ALSFieldDeclaration__Group__2" | ||
8294 | |||
8295 | |||
8296 | // $ANTLR start "rule__ALSFieldDeclaration__Group__2__Impl" | ||
8297 | // InternalAlloyLanguage.g:2630:1: rule__ALSFieldDeclaration__Group__2__Impl : ( ( rule__ALSFieldDeclaration__MultiplicityAssignment_2 )? ) ; | ||
8298 | public final void rule__ALSFieldDeclaration__Group__2__Impl() throws RecognitionException { | ||
8299 | |||
8300 | int stackSize = keepStackSize(); | ||
8301 | |||
8302 | try { | ||
8303 | // InternalAlloyLanguage.g:2634:1: ( ( ( rule__ALSFieldDeclaration__MultiplicityAssignment_2 )? ) ) | ||
8304 | // InternalAlloyLanguage.g:2635:1: ( ( rule__ALSFieldDeclaration__MultiplicityAssignment_2 )? ) | ||
8305 | { | ||
8306 | // InternalAlloyLanguage.g:2635:1: ( ( rule__ALSFieldDeclaration__MultiplicityAssignment_2 )? ) | ||
8307 | // InternalAlloyLanguage.g:2636:1: ( rule__ALSFieldDeclaration__MultiplicityAssignment_2 )? | ||
8308 | { | ||
8309 | if ( state.backtracking==0 ) { | ||
8310 | before(grammarAccess.getALSFieldDeclarationAccess().getMultiplicityAssignment_2()); | ||
8311 | } | ||
8312 | // InternalAlloyLanguage.g:2637:1: ( rule__ALSFieldDeclaration__MultiplicityAssignment_2 )? | ||
8313 | int alt24=2; | ||
8314 | alt24 = dfa24.predict(input); | ||
8315 | switch (alt24) { | ||
8316 | case 1 : | ||
8317 | // InternalAlloyLanguage.g:2637:2: rule__ALSFieldDeclaration__MultiplicityAssignment_2 | ||
8318 | { | ||
8319 | pushFollow(FOLLOW_2); | ||
8320 | rule__ALSFieldDeclaration__MultiplicityAssignment_2(); | ||
8321 | |||
8322 | state._fsp--; | ||
8323 | if (state.failed) return ; | ||
8324 | |||
8325 | } | ||
8326 | break; | ||
8327 | |||
8328 | } | ||
8329 | |||
8330 | if ( state.backtracking==0 ) { | ||
8331 | after(grammarAccess.getALSFieldDeclarationAccess().getMultiplicityAssignment_2()); | ||
8332 | } | ||
8333 | |||
8334 | } | ||
8335 | |||
8336 | |||
8337 | } | ||
8338 | |||
8339 | } | ||
8340 | catch (RecognitionException re) { | ||
8341 | reportError(re); | ||
8342 | recover(input,re); | ||
8343 | } | ||
8344 | finally { | ||
8345 | |||
8346 | restoreStackSize(stackSize); | ||
8347 | |||
8348 | } | ||
8349 | return ; | ||
8350 | } | ||
8351 | // $ANTLR end "rule__ALSFieldDeclaration__Group__2__Impl" | ||
8352 | |||
8353 | |||
8354 | // $ANTLR start "rule__ALSFieldDeclaration__Group__3" | ||
8355 | // InternalAlloyLanguage.g:2647:1: rule__ALSFieldDeclaration__Group__3 : rule__ALSFieldDeclaration__Group__3__Impl ; | ||
8356 | public final void rule__ALSFieldDeclaration__Group__3() throws RecognitionException { | ||
8357 | |||
8358 | int stackSize = keepStackSize(); | ||
8359 | |||
8360 | try { | ||
8361 | // InternalAlloyLanguage.g:2651:1: ( rule__ALSFieldDeclaration__Group__3__Impl ) | ||
8362 | // InternalAlloyLanguage.g:2652:2: rule__ALSFieldDeclaration__Group__3__Impl | ||
8363 | { | ||
8364 | pushFollow(FOLLOW_2); | ||
8365 | rule__ALSFieldDeclaration__Group__3__Impl(); | ||
8366 | |||
8367 | state._fsp--; | ||
8368 | if (state.failed) return ; | ||
8369 | |||
8370 | } | ||
8371 | |||
8372 | } | ||
8373 | catch (RecognitionException re) { | ||
8374 | reportError(re); | ||
8375 | recover(input,re); | ||
8376 | } | ||
8377 | finally { | ||
8378 | |||
8379 | restoreStackSize(stackSize); | ||
8380 | |||
8381 | } | ||
8382 | return ; | ||
8383 | } | ||
8384 | // $ANTLR end "rule__ALSFieldDeclaration__Group__3" | ||
8385 | |||
8386 | |||
8387 | // $ANTLR start "rule__ALSFieldDeclaration__Group__3__Impl" | ||
8388 | // InternalAlloyLanguage.g:2658:1: rule__ALSFieldDeclaration__Group__3__Impl : ( ( rule__ALSFieldDeclaration__TypeAssignment_3 ) ) ; | ||
8389 | public final void rule__ALSFieldDeclaration__Group__3__Impl() throws RecognitionException { | ||
8390 | |||
8391 | int stackSize = keepStackSize(); | ||
8392 | |||
8393 | try { | ||
8394 | // InternalAlloyLanguage.g:2662:1: ( ( ( rule__ALSFieldDeclaration__TypeAssignment_3 ) ) ) | ||
8395 | // InternalAlloyLanguage.g:2663:1: ( ( rule__ALSFieldDeclaration__TypeAssignment_3 ) ) | ||
8396 | { | ||
8397 | // InternalAlloyLanguage.g:2663:1: ( ( rule__ALSFieldDeclaration__TypeAssignment_3 ) ) | ||
8398 | // InternalAlloyLanguage.g:2664:1: ( rule__ALSFieldDeclaration__TypeAssignment_3 ) | ||
8399 | { | ||
8400 | if ( state.backtracking==0 ) { | ||
8401 | before(grammarAccess.getALSFieldDeclarationAccess().getTypeAssignment_3()); | ||
8402 | } | ||
8403 | // InternalAlloyLanguage.g:2665:1: ( rule__ALSFieldDeclaration__TypeAssignment_3 ) | ||
8404 | // InternalAlloyLanguage.g:2665:2: rule__ALSFieldDeclaration__TypeAssignment_3 | ||
8405 | { | ||
8406 | pushFollow(FOLLOW_2); | ||
8407 | rule__ALSFieldDeclaration__TypeAssignment_3(); | ||
8408 | |||
8409 | state._fsp--; | ||
8410 | if (state.failed) return ; | ||
8411 | |||
8412 | } | ||
8413 | |||
8414 | if ( state.backtracking==0 ) { | ||
8415 | after(grammarAccess.getALSFieldDeclarationAccess().getTypeAssignment_3()); | ||
8416 | } | ||
8417 | |||
8418 | } | ||
8419 | |||
8420 | |||
8421 | } | ||
8422 | |||
8423 | } | ||
8424 | catch (RecognitionException re) { | ||
8425 | reportError(re); | ||
8426 | recover(input,re); | ||
8427 | } | ||
8428 | finally { | ||
8429 | |||
8430 | restoreStackSize(stackSize); | ||
8431 | |||
8432 | } | ||
8433 | return ; | ||
8434 | } | ||
8435 | // $ANTLR end "rule__ALSFieldDeclaration__Group__3__Impl" | ||
8436 | |||
8437 | |||
8438 | // $ANTLR start "rule__ALSFunctionDefinition__Group__0" | ||
8439 | // InternalAlloyLanguage.g:2683:1: rule__ALSFunctionDefinition__Group__0 : rule__ALSFunctionDefinition__Group__0__Impl rule__ALSFunctionDefinition__Group__1 ; | ||
8440 | public final void rule__ALSFunctionDefinition__Group__0() throws RecognitionException { | ||
8441 | |||
8442 | int stackSize = keepStackSize(); | ||
8443 | |||
8444 | try { | ||
8445 | // InternalAlloyLanguage.g:2687:1: ( rule__ALSFunctionDefinition__Group__0__Impl rule__ALSFunctionDefinition__Group__1 ) | ||
8446 | // InternalAlloyLanguage.g:2688:2: rule__ALSFunctionDefinition__Group__0__Impl rule__ALSFunctionDefinition__Group__1 | ||
8447 | { | ||
8448 | pushFollow(FOLLOW_5); | ||
8449 | rule__ALSFunctionDefinition__Group__0__Impl(); | ||
8450 | |||
8451 | state._fsp--; | ||
8452 | if (state.failed) return ; | ||
8453 | pushFollow(FOLLOW_2); | ||
8454 | rule__ALSFunctionDefinition__Group__1(); | ||
8455 | |||
8456 | state._fsp--; | ||
8457 | if (state.failed) return ; | ||
8458 | |||
8459 | } | ||
8460 | |||
8461 | } | ||
8462 | catch (RecognitionException re) { | ||
8463 | reportError(re); | ||
8464 | recover(input,re); | ||
8465 | } | ||
8466 | finally { | ||
8467 | |||
8468 | restoreStackSize(stackSize); | ||
8469 | |||
8470 | } | ||
8471 | return ; | ||
8472 | } | ||
8473 | // $ANTLR end "rule__ALSFunctionDefinition__Group__0" | ||
8474 | |||
8475 | |||
8476 | // $ANTLR start "rule__ALSFunctionDefinition__Group__0__Impl" | ||
8477 | // InternalAlloyLanguage.g:2695:1: rule__ALSFunctionDefinition__Group__0__Impl : ( 'fun' ) ; | ||
8478 | public final void rule__ALSFunctionDefinition__Group__0__Impl() throws RecognitionException { | ||
8479 | |||
8480 | int stackSize = keepStackSize(); | ||
8481 | |||
8482 | try { | ||
8483 | // InternalAlloyLanguage.g:2699:1: ( ( 'fun' ) ) | ||
8484 | // InternalAlloyLanguage.g:2700:1: ( 'fun' ) | ||
8485 | { | ||
8486 | // InternalAlloyLanguage.g:2700:1: ( 'fun' ) | ||
8487 | // InternalAlloyLanguage.g:2701:1: 'fun' | ||
8488 | { | ||
8489 | if ( state.backtracking==0 ) { | ||
8490 | before(grammarAccess.getALSFunctionDefinitionAccess().getFunKeyword_0()); | ||
8491 | } | ||
8492 | match(input,41,FOLLOW_2); if (state.failed) return ; | ||
8493 | if ( state.backtracking==0 ) { | ||
8494 | after(grammarAccess.getALSFunctionDefinitionAccess().getFunKeyword_0()); | ||
8495 | } | ||
8496 | |||
8497 | } | ||
8498 | |||
8499 | |||
8500 | } | ||
8501 | |||
8502 | } | ||
8503 | catch (RecognitionException re) { | ||
8504 | reportError(re); | ||
8505 | recover(input,re); | ||
8506 | } | ||
8507 | finally { | ||
8508 | |||
8509 | restoreStackSize(stackSize); | ||
8510 | |||
8511 | } | ||
8512 | return ; | ||
8513 | } | ||
8514 | // $ANTLR end "rule__ALSFunctionDefinition__Group__0__Impl" | ||
8515 | |||
8516 | |||
8517 | // $ANTLR start "rule__ALSFunctionDefinition__Group__1" | ||
8518 | // InternalAlloyLanguage.g:2714:1: rule__ALSFunctionDefinition__Group__1 : rule__ALSFunctionDefinition__Group__1__Impl rule__ALSFunctionDefinition__Group__2 ; | ||
8519 | public final void rule__ALSFunctionDefinition__Group__1() throws RecognitionException { | ||
8520 | |||
8521 | int stackSize = keepStackSize(); | ||
8522 | |||
8523 | try { | ||
8524 | // InternalAlloyLanguage.g:2718:1: ( rule__ALSFunctionDefinition__Group__1__Impl rule__ALSFunctionDefinition__Group__2 ) | ||
8525 | // InternalAlloyLanguage.g:2719:2: rule__ALSFunctionDefinition__Group__1__Impl rule__ALSFunctionDefinition__Group__2 | ||
8526 | { | ||
8527 | pushFollow(FOLLOW_17); | ||
8528 | rule__ALSFunctionDefinition__Group__1__Impl(); | ||
8529 | |||
8530 | state._fsp--; | ||
8531 | if (state.failed) return ; | ||
8532 | pushFollow(FOLLOW_2); | ||
8533 | rule__ALSFunctionDefinition__Group__2(); | ||
8534 | |||
8535 | state._fsp--; | ||
8536 | if (state.failed) return ; | ||
8537 | |||
8538 | } | ||
8539 | |||
8540 | } | ||
8541 | catch (RecognitionException re) { | ||
8542 | reportError(re); | ||
8543 | recover(input,re); | ||
8544 | } | ||
8545 | finally { | ||
8546 | |||
8547 | restoreStackSize(stackSize); | ||
8548 | |||
8549 | } | ||
8550 | return ; | ||
8551 | } | ||
8552 | // $ANTLR end "rule__ALSFunctionDefinition__Group__1" | ||
8553 | |||
8554 | |||
8555 | // $ANTLR start "rule__ALSFunctionDefinition__Group__1__Impl" | ||
8556 | // InternalAlloyLanguage.g:2726:1: rule__ALSFunctionDefinition__Group__1__Impl : ( ( rule__ALSFunctionDefinition__NameAssignment_1 ) ) ; | ||
8557 | public final void rule__ALSFunctionDefinition__Group__1__Impl() throws RecognitionException { | ||
8558 | |||
8559 | int stackSize = keepStackSize(); | ||
8560 | |||
8561 | try { | ||
8562 | // InternalAlloyLanguage.g:2730:1: ( ( ( rule__ALSFunctionDefinition__NameAssignment_1 ) ) ) | ||
8563 | // InternalAlloyLanguage.g:2731:1: ( ( rule__ALSFunctionDefinition__NameAssignment_1 ) ) | ||
8564 | { | ||
8565 | // InternalAlloyLanguage.g:2731:1: ( ( rule__ALSFunctionDefinition__NameAssignment_1 ) ) | ||
8566 | // InternalAlloyLanguage.g:2732:1: ( rule__ALSFunctionDefinition__NameAssignment_1 ) | ||
8567 | { | ||
8568 | if ( state.backtracking==0 ) { | ||
8569 | before(grammarAccess.getALSFunctionDefinitionAccess().getNameAssignment_1()); | ||
8570 | } | ||
8571 | // InternalAlloyLanguage.g:2733:1: ( rule__ALSFunctionDefinition__NameAssignment_1 ) | ||
8572 | // InternalAlloyLanguage.g:2733:2: rule__ALSFunctionDefinition__NameAssignment_1 | ||
8573 | { | ||
8574 | pushFollow(FOLLOW_2); | ||
8575 | rule__ALSFunctionDefinition__NameAssignment_1(); | ||
8576 | |||
8577 | state._fsp--; | ||
8578 | if (state.failed) return ; | ||
8579 | |||
8580 | } | ||
8581 | |||
8582 | if ( state.backtracking==0 ) { | ||
8583 | after(grammarAccess.getALSFunctionDefinitionAccess().getNameAssignment_1()); | ||
8584 | } | ||
8585 | |||
8586 | } | ||
8587 | |||
8588 | |||
8589 | } | ||
8590 | |||
8591 | } | ||
8592 | catch (RecognitionException re) { | ||
8593 | reportError(re); | ||
8594 | recover(input,re); | ||
8595 | } | ||
8596 | finally { | ||
8597 | |||
8598 | restoreStackSize(stackSize); | ||
8599 | |||
8600 | } | ||
8601 | return ; | ||
8602 | } | ||
8603 | // $ANTLR end "rule__ALSFunctionDefinition__Group__1__Impl" | ||
8604 | |||
8605 | |||
8606 | // $ANTLR start "rule__ALSFunctionDefinition__Group__2" | ||
8607 | // InternalAlloyLanguage.g:2743:1: rule__ALSFunctionDefinition__Group__2 : rule__ALSFunctionDefinition__Group__2__Impl rule__ALSFunctionDefinition__Group__3 ; | ||
8608 | public final void rule__ALSFunctionDefinition__Group__2() throws RecognitionException { | ||
8609 | |||
8610 | int stackSize = keepStackSize(); | ||
8611 | |||
8612 | try { | ||
8613 | // InternalAlloyLanguage.g:2747:1: ( rule__ALSFunctionDefinition__Group__2__Impl rule__ALSFunctionDefinition__Group__3 ) | ||
8614 | // InternalAlloyLanguage.g:2748:2: rule__ALSFunctionDefinition__Group__2__Impl rule__ALSFunctionDefinition__Group__3 | ||
8615 | { | ||
8616 | pushFollow(FOLLOW_5); | ||
8617 | rule__ALSFunctionDefinition__Group__2__Impl(); | ||
8618 | |||
8619 | state._fsp--; | ||
8620 | if (state.failed) return ; | ||
8621 | pushFollow(FOLLOW_2); | ||
8622 | rule__ALSFunctionDefinition__Group__3(); | ||
8623 | |||
8624 | state._fsp--; | ||
8625 | if (state.failed) return ; | ||
8626 | |||
8627 | } | ||
8628 | |||
8629 | } | ||
8630 | catch (RecognitionException re) { | ||
8631 | reportError(re); | ||
8632 | recover(input,re); | ||
8633 | } | ||
8634 | finally { | ||
8635 | |||
8636 | restoreStackSize(stackSize); | ||
8637 | |||
8638 | } | ||
8639 | return ; | ||
8640 | } | ||
8641 | // $ANTLR end "rule__ALSFunctionDefinition__Group__2" | ||
8642 | |||
8643 | |||
8644 | // $ANTLR start "rule__ALSFunctionDefinition__Group__2__Impl" | ||
8645 | // InternalAlloyLanguage.g:2755:1: rule__ALSFunctionDefinition__Group__2__Impl : ( '[' ) ; | ||
8646 | public final void rule__ALSFunctionDefinition__Group__2__Impl() throws RecognitionException { | ||
8647 | |||
8648 | int stackSize = keepStackSize(); | ||
8649 | |||
8650 | try { | ||
8651 | // InternalAlloyLanguage.g:2759:1: ( ( '[' ) ) | ||
8652 | // InternalAlloyLanguage.g:2760:1: ( '[' ) | ||
8653 | { | ||
8654 | // InternalAlloyLanguage.g:2760:1: ( '[' ) | ||
8655 | // InternalAlloyLanguage.g:2761:1: '[' | ||
8656 | { | ||
8657 | if ( state.backtracking==0 ) { | ||
8658 | before(grammarAccess.getALSFunctionDefinitionAccess().getLeftSquareBracketKeyword_2()); | ||
8659 | } | ||
8660 | match(input,42,FOLLOW_2); if (state.failed) return ; | ||
8661 | if ( state.backtracking==0 ) { | ||
8662 | after(grammarAccess.getALSFunctionDefinitionAccess().getLeftSquareBracketKeyword_2()); | ||
8663 | } | ||
8664 | |||
8665 | } | ||
8666 | |||
8667 | |||
8668 | } | ||
8669 | |||
8670 | } | ||
8671 | catch (RecognitionException re) { | ||
8672 | reportError(re); | ||
8673 | recover(input,re); | ||
8674 | } | ||
8675 | finally { | ||
8676 | |||
8677 | restoreStackSize(stackSize); | ||
8678 | |||
8679 | } | ||
8680 | return ; | ||
8681 | } | ||
8682 | // $ANTLR end "rule__ALSFunctionDefinition__Group__2__Impl" | ||
8683 | |||
8684 | |||
8685 | // $ANTLR start "rule__ALSFunctionDefinition__Group__3" | ||
8686 | // InternalAlloyLanguage.g:2774:1: rule__ALSFunctionDefinition__Group__3 : rule__ALSFunctionDefinition__Group__3__Impl rule__ALSFunctionDefinition__Group__4 ; | ||
8687 | public final void rule__ALSFunctionDefinition__Group__3() throws RecognitionException { | ||
8688 | |||
8689 | int stackSize = keepStackSize(); | ||
8690 | |||
8691 | try { | ||
8692 | // InternalAlloyLanguage.g:2778:1: ( rule__ALSFunctionDefinition__Group__3__Impl rule__ALSFunctionDefinition__Group__4 ) | ||
8693 | // InternalAlloyLanguage.g:2779:2: rule__ALSFunctionDefinition__Group__3__Impl rule__ALSFunctionDefinition__Group__4 | ||
8694 | { | ||
8695 | pushFollow(FOLLOW_18); | ||
8696 | rule__ALSFunctionDefinition__Group__3__Impl(); | ||
8697 | |||
8698 | state._fsp--; | ||
8699 | if (state.failed) return ; | ||
8700 | pushFollow(FOLLOW_2); | ||
8701 | rule__ALSFunctionDefinition__Group__4(); | ||
8702 | |||
8703 | state._fsp--; | ||
8704 | if (state.failed) return ; | ||
8705 | |||
8706 | } | ||
8707 | |||
8708 | } | ||
8709 | catch (RecognitionException re) { | ||
8710 | reportError(re); | ||
8711 | recover(input,re); | ||
8712 | } | ||
8713 | finally { | ||
8714 | |||
8715 | restoreStackSize(stackSize); | ||
8716 | |||
8717 | } | ||
8718 | return ; | ||
8719 | } | ||
8720 | // $ANTLR end "rule__ALSFunctionDefinition__Group__3" | ||
8721 | |||
8722 | |||
8723 | // $ANTLR start "rule__ALSFunctionDefinition__Group__3__Impl" | ||
8724 | // InternalAlloyLanguage.g:2786:1: rule__ALSFunctionDefinition__Group__3__Impl : ( ( rule__ALSFunctionDefinition__VariablesAssignment_3 ) ) ; | ||
8725 | public final void rule__ALSFunctionDefinition__Group__3__Impl() throws RecognitionException { | ||
8726 | |||
8727 | int stackSize = keepStackSize(); | ||
8728 | |||
8729 | try { | ||
8730 | // InternalAlloyLanguage.g:2790:1: ( ( ( rule__ALSFunctionDefinition__VariablesAssignment_3 ) ) ) | ||
8731 | // InternalAlloyLanguage.g:2791:1: ( ( rule__ALSFunctionDefinition__VariablesAssignment_3 ) ) | ||
8732 | { | ||
8733 | // InternalAlloyLanguage.g:2791:1: ( ( rule__ALSFunctionDefinition__VariablesAssignment_3 ) ) | ||
8734 | // InternalAlloyLanguage.g:2792:1: ( rule__ALSFunctionDefinition__VariablesAssignment_3 ) | ||
8735 | { | ||
8736 | if ( state.backtracking==0 ) { | ||
8737 | before(grammarAccess.getALSFunctionDefinitionAccess().getVariablesAssignment_3()); | ||
8738 | } | ||
8739 | // InternalAlloyLanguage.g:2793:1: ( rule__ALSFunctionDefinition__VariablesAssignment_3 ) | ||
8740 | // InternalAlloyLanguage.g:2793:2: rule__ALSFunctionDefinition__VariablesAssignment_3 | ||
8741 | { | ||
8742 | pushFollow(FOLLOW_2); | ||
8743 | rule__ALSFunctionDefinition__VariablesAssignment_3(); | ||
8744 | |||
8745 | state._fsp--; | ||
8746 | if (state.failed) return ; | ||
8747 | |||
8748 | } | ||
8749 | |||
8750 | if ( state.backtracking==0 ) { | ||
8751 | after(grammarAccess.getALSFunctionDefinitionAccess().getVariablesAssignment_3()); | ||
8752 | } | ||
8753 | |||
8754 | } | ||
8755 | |||
8756 | |||
8757 | } | ||
8758 | |||
8759 | } | ||
8760 | catch (RecognitionException re) { | ||
8761 | reportError(re); | ||
8762 | recover(input,re); | ||
8763 | } | ||
8764 | finally { | ||
8765 | |||
8766 | restoreStackSize(stackSize); | ||
8767 | |||
8768 | } | ||
8769 | return ; | ||
8770 | } | ||
8771 | // $ANTLR end "rule__ALSFunctionDefinition__Group__3__Impl" | ||
8772 | |||
8773 | |||
8774 | // $ANTLR start "rule__ALSFunctionDefinition__Group__4" | ||
8775 | // InternalAlloyLanguage.g:2803:1: rule__ALSFunctionDefinition__Group__4 : rule__ALSFunctionDefinition__Group__4__Impl rule__ALSFunctionDefinition__Group__5 ; | ||
8776 | public final void rule__ALSFunctionDefinition__Group__4() throws RecognitionException { | ||
8777 | |||
8778 | int stackSize = keepStackSize(); | ||
8779 | |||
8780 | try { | ||
8781 | // InternalAlloyLanguage.g:2807:1: ( rule__ALSFunctionDefinition__Group__4__Impl rule__ALSFunctionDefinition__Group__5 ) | ||
8782 | // InternalAlloyLanguage.g:2808:2: rule__ALSFunctionDefinition__Group__4__Impl rule__ALSFunctionDefinition__Group__5 | ||
8783 | { | ||
8784 | pushFollow(FOLLOW_18); | ||
8785 | rule__ALSFunctionDefinition__Group__4__Impl(); | ||
8786 | |||
8787 | state._fsp--; | ||
8788 | if (state.failed) return ; | ||
8789 | pushFollow(FOLLOW_2); | ||
8790 | rule__ALSFunctionDefinition__Group__5(); | ||
8791 | |||
8792 | state._fsp--; | ||
8793 | if (state.failed) return ; | ||
8794 | |||
8795 | } | ||
8796 | |||
8797 | } | ||
8798 | catch (RecognitionException re) { | ||
8799 | reportError(re); | ||
8800 | recover(input,re); | ||
8801 | } | ||
8802 | finally { | ||
8803 | |||
8804 | restoreStackSize(stackSize); | ||
8805 | |||
8806 | } | ||
8807 | return ; | ||
8808 | } | ||
8809 | // $ANTLR end "rule__ALSFunctionDefinition__Group__4" | ||
8810 | |||
8811 | |||
8812 | // $ANTLR start "rule__ALSFunctionDefinition__Group__4__Impl" | ||
8813 | // InternalAlloyLanguage.g:2815:1: rule__ALSFunctionDefinition__Group__4__Impl : ( ( rule__ALSFunctionDefinition__Group_4__0 )* ) ; | ||
8814 | public final void rule__ALSFunctionDefinition__Group__4__Impl() throws RecognitionException { | ||
8815 | |||
8816 | int stackSize = keepStackSize(); | ||
8817 | |||
8818 | try { | ||
8819 | // InternalAlloyLanguage.g:2819:1: ( ( ( rule__ALSFunctionDefinition__Group_4__0 )* ) ) | ||
8820 | // InternalAlloyLanguage.g:2820:1: ( ( rule__ALSFunctionDefinition__Group_4__0 )* ) | ||
8821 | { | ||
8822 | // InternalAlloyLanguage.g:2820:1: ( ( rule__ALSFunctionDefinition__Group_4__0 )* ) | ||
8823 | // InternalAlloyLanguage.g:2821:1: ( rule__ALSFunctionDefinition__Group_4__0 )* | ||
8824 | { | ||
8825 | if ( state.backtracking==0 ) { | ||
8826 | before(grammarAccess.getALSFunctionDefinitionAccess().getGroup_4()); | ||
8827 | } | ||
8828 | // InternalAlloyLanguage.g:2822:1: ( rule__ALSFunctionDefinition__Group_4__0 )* | ||
8829 | loop25: | ||
8830 | do { | ||
8831 | int alt25=2; | ||
8832 | int LA25_0 = input.LA(1); | ||
8833 | |||
8834 | if ( (LA25_0==35) ) { | ||
8835 | alt25=1; | ||
8836 | } | ||
8837 | |||
8838 | |||
8839 | switch (alt25) { | ||
8840 | case 1 : | ||
8841 | // InternalAlloyLanguage.g:2822:2: rule__ALSFunctionDefinition__Group_4__0 | ||
8842 | { | ||
8843 | pushFollow(FOLLOW_8); | ||
8844 | rule__ALSFunctionDefinition__Group_4__0(); | ||
8845 | |||
8846 | state._fsp--; | ||
8847 | if (state.failed) return ; | ||
8848 | |||
8849 | } | ||
8850 | break; | ||
8851 | |||
8852 | default : | ||
8853 | break loop25; | ||
8854 | } | ||
8855 | } while (true); | ||
8856 | |||
8857 | if ( state.backtracking==0 ) { | ||
8858 | after(grammarAccess.getALSFunctionDefinitionAccess().getGroup_4()); | ||
8859 | } | ||
8860 | |||
8861 | } | ||
8862 | |||
8863 | |||
8864 | } | ||
8865 | |||
8866 | } | ||
8867 | catch (RecognitionException re) { | ||
8868 | reportError(re); | ||
8869 | recover(input,re); | ||
8870 | } | ||
8871 | finally { | ||
8872 | |||
8873 | restoreStackSize(stackSize); | ||
8874 | |||
8875 | } | ||
8876 | return ; | ||
8877 | } | ||
8878 | // $ANTLR end "rule__ALSFunctionDefinition__Group__4__Impl" | ||
8879 | |||
8880 | |||
8881 | // $ANTLR start "rule__ALSFunctionDefinition__Group__5" | ||
8882 | // InternalAlloyLanguage.g:2832:1: rule__ALSFunctionDefinition__Group__5 : rule__ALSFunctionDefinition__Group__5__Impl rule__ALSFunctionDefinition__Group__6 ; | ||
8883 | public final void rule__ALSFunctionDefinition__Group__5() throws RecognitionException { | ||
8884 | |||
8885 | int stackSize = keepStackSize(); | ||
8886 | |||
8887 | try { | ||
8888 | // InternalAlloyLanguage.g:2836:1: ( rule__ALSFunctionDefinition__Group__5__Impl rule__ALSFunctionDefinition__Group__6 ) | ||
8889 | // InternalAlloyLanguage.g:2837:2: rule__ALSFunctionDefinition__Group__5__Impl rule__ALSFunctionDefinition__Group__6 | ||
8890 | { | ||
8891 | pushFollow(FOLLOW_15); | ||
8892 | rule__ALSFunctionDefinition__Group__5__Impl(); | ||
8893 | |||
8894 | state._fsp--; | ||
8895 | if (state.failed) return ; | ||
8896 | pushFollow(FOLLOW_2); | ||
8897 | rule__ALSFunctionDefinition__Group__6(); | ||
8898 | |||
8899 | state._fsp--; | ||
8900 | if (state.failed) return ; | ||
8901 | |||
8902 | } | ||
8903 | |||
8904 | } | ||
8905 | catch (RecognitionException re) { | ||
8906 | reportError(re); | ||
8907 | recover(input,re); | ||
8908 | } | ||
8909 | finally { | ||
8910 | |||
8911 | restoreStackSize(stackSize); | ||
8912 | |||
8913 | } | ||
8914 | return ; | ||
8915 | } | ||
8916 | // $ANTLR end "rule__ALSFunctionDefinition__Group__5" | ||
8917 | |||
8918 | |||
8919 | // $ANTLR start "rule__ALSFunctionDefinition__Group__5__Impl" | ||
8920 | // InternalAlloyLanguage.g:2844:1: rule__ALSFunctionDefinition__Group__5__Impl : ( ']' ) ; | ||
8921 | public final void rule__ALSFunctionDefinition__Group__5__Impl() throws RecognitionException { | ||
8922 | |||
8923 | int stackSize = keepStackSize(); | ||
8924 | |||
8925 | try { | ||
8926 | // InternalAlloyLanguage.g:2848:1: ( ( ']' ) ) | ||
8927 | // InternalAlloyLanguage.g:2849:1: ( ']' ) | ||
8928 | { | ||
8929 | // InternalAlloyLanguage.g:2849:1: ( ']' ) | ||
8930 | // InternalAlloyLanguage.g:2850:1: ']' | ||
8931 | { | ||
8932 | if ( state.backtracking==0 ) { | ||
8933 | before(grammarAccess.getALSFunctionDefinitionAccess().getRightSquareBracketKeyword_5()); | ||
8934 | } | ||
8935 | match(input,43,FOLLOW_2); if (state.failed) return ; | ||
8936 | if ( state.backtracking==0 ) { | ||
8937 | after(grammarAccess.getALSFunctionDefinitionAccess().getRightSquareBracketKeyword_5()); | ||
8938 | } | ||
8939 | |||
8940 | } | ||
8941 | |||
8942 | |||
8943 | } | ||
8944 | |||
8945 | } | ||
8946 | catch (RecognitionException re) { | ||
8947 | reportError(re); | ||
8948 | recover(input,re); | ||
8949 | } | ||
8950 | finally { | ||
8951 | |||
8952 | restoreStackSize(stackSize); | ||
8953 | |||
8954 | } | ||
8955 | return ; | ||
8956 | } | ||
8957 | // $ANTLR end "rule__ALSFunctionDefinition__Group__5__Impl" | ||
8958 | |||
8959 | |||
8960 | // $ANTLR start "rule__ALSFunctionDefinition__Group__6" | ||
8961 | // InternalAlloyLanguage.g:2863:1: rule__ALSFunctionDefinition__Group__6 : rule__ALSFunctionDefinition__Group__6__Impl rule__ALSFunctionDefinition__Group__7 ; | ||
8962 | public final void rule__ALSFunctionDefinition__Group__6() throws RecognitionException { | ||
8963 | |||
8964 | int stackSize = keepStackSize(); | ||
8965 | |||
8966 | try { | ||
8967 | // InternalAlloyLanguage.g:2867:1: ( rule__ALSFunctionDefinition__Group__6__Impl rule__ALSFunctionDefinition__Group__7 ) | ||
8968 | // InternalAlloyLanguage.g:2868:2: rule__ALSFunctionDefinition__Group__6__Impl rule__ALSFunctionDefinition__Group__7 | ||
8969 | { | ||
8970 | pushFollow(FOLLOW_16); | ||
8971 | rule__ALSFunctionDefinition__Group__6__Impl(); | ||
8972 | |||
8973 | state._fsp--; | ||
8974 | if (state.failed) return ; | ||
8975 | pushFollow(FOLLOW_2); | ||
8976 | rule__ALSFunctionDefinition__Group__7(); | ||
8977 | |||
8978 | state._fsp--; | ||
8979 | if (state.failed) return ; | ||
8980 | |||
8981 | } | ||
8982 | |||
8983 | } | ||
8984 | catch (RecognitionException re) { | ||
8985 | reportError(re); | ||
8986 | recover(input,re); | ||
8987 | } | ||
8988 | finally { | ||
8989 | |||
8990 | restoreStackSize(stackSize); | ||
8991 | |||
8992 | } | ||
8993 | return ; | ||
8994 | } | ||
8995 | // $ANTLR end "rule__ALSFunctionDefinition__Group__6" | ||
8996 | |||
8997 | |||
8998 | // $ANTLR start "rule__ALSFunctionDefinition__Group__6__Impl" | ||
8999 | // InternalAlloyLanguage.g:2875:1: rule__ALSFunctionDefinition__Group__6__Impl : ( ':' ) ; | ||
9000 | public final void rule__ALSFunctionDefinition__Group__6__Impl() throws RecognitionException { | ||
9001 | |||
9002 | int stackSize = keepStackSize(); | ||
9003 | |||
9004 | try { | ||
9005 | // InternalAlloyLanguage.g:2879:1: ( ( ':' ) ) | ||
9006 | // InternalAlloyLanguage.g:2880:1: ( ':' ) | ||
9007 | { | ||
9008 | // InternalAlloyLanguage.g:2880:1: ( ':' ) | ||
9009 | // InternalAlloyLanguage.g:2881:1: ':' | ||
9010 | { | ||
9011 | if ( state.backtracking==0 ) { | ||
9012 | before(grammarAccess.getALSFunctionDefinitionAccess().getColonKeyword_6()); | ||
9013 | } | ||
9014 | match(input,40,FOLLOW_2); if (state.failed) return ; | ||
9015 | if ( state.backtracking==0 ) { | ||
9016 | after(grammarAccess.getALSFunctionDefinitionAccess().getColonKeyword_6()); | ||
9017 | } | ||
9018 | |||
9019 | } | ||
9020 | |||
9021 | |||
9022 | } | ||
9023 | |||
9024 | } | ||
9025 | catch (RecognitionException re) { | ||
9026 | reportError(re); | ||
9027 | recover(input,re); | ||
9028 | } | ||
9029 | finally { | ||
9030 | |||
9031 | restoreStackSize(stackSize); | ||
9032 | |||
9033 | } | ||
9034 | return ; | ||
9035 | } | ||
9036 | // $ANTLR end "rule__ALSFunctionDefinition__Group__6__Impl" | ||
9037 | |||
9038 | |||
9039 | // $ANTLR start "rule__ALSFunctionDefinition__Group__7" | ||
9040 | // InternalAlloyLanguage.g:2894:1: rule__ALSFunctionDefinition__Group__7 : rule__ALSFunctionDefinition__Group__7__Impl rule__ALSFunctionDefinition__Group__8 ; | ||
9041 | public final void rule__ALSFunctionDefinition__Group__7() throws RecognitionException { | ||
9042 | |||
9043 | int stackSize = keepStackSize(); | ||
9044 | |||
9045 | try { | ||
9046 | // InternalAlloyLanguage.g:2898:1: ( rule__ALSFunctionDefinition__Group__7__Impl rule__ALSFunctionDefinition__Group__8 ) | ||
9047 | // InternalAlloyLanguage.g:2899:2: rule__ALSFunctionDefinition__Group__7__Impl rule__ALSFunctionDefinition__Group__8 | ||
9048 | { | ||
9049 | pushFollow(FOLLOW_6); | ||
9050 | rule__ALSFunctionDefinition__Group__7__Impl(); | ||
9051 | |||
9052 | state._fsp--; | ||
9053 | if (state.failed) return ; | ||
9054 | pushFollow(FOLLOW_2); | ||
9055 | rule__ALSFunctionDefinition__Group__8(); | ||
9056 | |||
9057 | state._fsp--; | ||
9058 | if (state.failed) return ; | ||
9059 | |||
9060 | } | ||
9061 | |||
9062 | } | ||
9063 | catch (RecognitionException re) { | ||
9064 | reportError(re); | ||
9065 | recover(input,re); | ||
9066 | } | ||
9067 | finally { | ||
9068 | |||
9069 | restoreStackSize(stackSize); | ||
9070 | |||
9071 | } | ||
9072 | return ; | ||
9073 | } | ||
9074 | // $ANTLR end "rule__ALSFunctionDefinition__Group__7" | ||
9075 | |||
9076 | |||
9077 | // $ANTLR start "rule__ALSFunctionDefinition__Group__7__Impl" | ||
9078 | // InternalAlloyLanguage.g:2906:1: rule__ALSFunctionDefinition__Group__7__Impl : ( ( rule__ALSFunctionDefinition__TypeAssignment_7 ) ) ; | ||
9079 | public final void rule__ALSFunctionDefinition__Group__7__Impl() throws RecognitionException { | ||
9080 | |||
9081 | int stackSize = keepStackSize(); | ||
9082 | |||
9083 | try { | ||
9084 | // InternalAlloyLanguage.g:2910:1: ( ( ( rule__ALSFunctionDefinition__TypeAssignment_7 ) ) ) | ||
9085 | // InternalAlloyLanguage.g:2911:1: ( ( rule__ALSFunctionDefinition__TypeAssignment_7 ) ) | ||
9086 | { | ||
9087 | // InternalAlloyLanguage.g:2911:1: ( ( rule__ALSFunctionDefinition__TypeAssignment_7 ) ) | ||
9088 | // InternalAlloyLanguage.g:2912:1: ( rule__ALSFunctionDefinition__TypeAssignment_7 ) | ||
9089 | { | ||
9090 | if ( state.backtracking==0 ) { | ||
9091 | before(grammarAccess.getALSFunctionDefinitionAccess().getTypeAssignment_7()); | ||
9092 | } | ||
9093 | // InternalAlloyLanguage.g:2913:1: ( rule__ALSFunctionDefinition__TypeAssignment_7 ) | ||
9094 | // InternalAlloyLanguage.g:2913:2: rule__ALSFunctionDefinition__TypeAssignment_7 | ||
9095 | { | ||
9096 | pushFollow(FOLLOW_2); | ||
9097 | rule__ALSFunctionDefinition__TypeAssignment_7(); | ||
9098 | |||
9099 | state._fsp--; | ||
9100 | if (state.failed) return ; | ||
9101 | |||
9102 | } | ||
9103 | |||
9104 | if ( state.backtracking==0 ) { | ||
9105 | after(grammarAccess.getALSFunctionDefinitionAccess().getTypeAssignment_7()); | ||
9106 | } | ||
9107 | |||
9108 | } | ||
9109 | |||
9110 | |||
9111 | } | ||
9112 | |||
9113 | } | ||
9114 | catch (RecognitionException re) { | ||
9115 | reportError(re); | ||
9116 | recover(input,re); | ||
9117 | } | ||
9118 | finally { | ||
9119 | |||
9120 | restoreStackSize(stackSize); | ||
9121 | |||
9122 | } | ||
9123 | return ; | ||
9124 | } | ||
9125 | // $ANTLR end "rule__ALSFunctionDefinition__Group__7__Impl" | ||
9126 | |||
9127 | |||
9128 | // $ANTLR start "rule__ALSFunctionDefinition__Group__8" | ||
9129 | // InternalAlloyLanguage.g:2923:1: rule__ALSFunctionDefinition__Group__8 : rule__ALSFunctionDefinition__Group__8__Impl rule__ALSFunctionDefinition__Group__9 ; | ||
9130 | public final void rule__ALSFunctionDefinition__Group__8() throws RecognitionException { | ||
9131 | |||
9132 | int stackSize = keepStackSize(); | ||
9133 | |||
9134 | try { | ||
9135 | // InternalAlloyLanguage.g:2927:1: ( rule__ALSFunctionDefinition__Group__8__Impl rule__ALSFunctionDefinition__Group__9 ) | ||
9136 | // InternalAlloyLanguage.g:2928:2: rule__ALSFunctionDefinition__Group__8__Impl rule__ALSFunctionDefinition__Group__9 | ||
9137 | { | ||
9138 | pushFollow(FOLLOW_16); | ||
9139 | rule__ALSFunctionDefinition__Group__8__Impl(); | ||
9140 | |||
9141 | state._fsp--; | ||
9142 | if (state.failed) return ; | ||
9143 | pushFollow(FOLLOW_2); | ||
9144 | rule__ALSFunctionDefinition__Group__9(); | ||
9145 | |||
9146 | state._fsp--; | ||
9147 | if (state.failed) return ; | ||
9148 | |||
9149 | } | ||
9150 | |||
9151 | } | ||
9152 | catch (RecognitionException re) { | ||
9153 | reportError(re); | ||
9154 | recover(input,re); | ||
9155 | } | ||
9156 | finally { | ||
9157 | |||
9158 | restoreStackSize(stackSize); | ||
9159 | |||
9160 | } | ||
9161 | return ; | ||
9162 | } | ||
9163 | // $ANTLR end "rule__ALSFunctionDefinition__Group__8" | ||
9164 | |||
9165 | |||
9166 | // $ANTLR start "rule__ALSFunctionDefinition__Group__8__Impl" | ||
9167 | // InternalAlloyLanguage.g:2935:1: rule__ALSFunctionDefinition__Group__8__Impl : ( '{' ) ; | ||
9168 | public final void rule__ALSFunctionDefinition__Group__8__Impl() throws RecognitionException { | ||
9169 | |||
9170 | int stackSize = keepStackSize(); | ||
9171 | |||
9172 | try { | ||
9173 | // InternalAlloyLanguage.g:2939:1: ( ( '{' ) ) | ||
9174 | // InternalAlloyLanguage.g:2940:1: ( '{' ) | ||
9175 | { | ||
9176 | // InternalAlloyLanguage.g:2940:1: ( '{' ) | ||
9177 | // InternalAlloyLanguage.g:2941:1: '{' | ||
9178 | { | ||
9179 | if ( state.backtracking==0 ) { | ||
9180 | before(grammarAccess.getALSFunctionDefinitionAccess().getLeftCurlyBracketKeyword_8()); | ||
9181 | } | ||
9182 | match(input,33,FOLLOW_2); if (state.failed) return ; | ||
9183 | if ( state.backtracking==0 ) { | ||
9184 | after(grammarAccess.getALSFunctionDefinitionAccess().getLeftCurlyBracketKeyword_8()); | ||
9185 | } | ||
9186 | |||
9187 | } | ||
9188 | |||
9189 | |||
9190 | } | ||
9191 | |||
9192 | } | ||
9193 | catch (RecognitionException re) { | ||
9194 | reportError(re); | ||
9195 | recover(input,re); | ||
9196 | } | ||
9197 | finally { | ||
9198 | |||
9199 | restoreStackSize(stackSize); | ||
9200 | |||
9201 | } | ||
9202 | return ; | ||
9203 | } | ||
9204 | // $ANTLR end "rule__ALSFunctionDefinition__Group__8__Impl" | ||
9205 | |||
9206 | |||
9207 | // $ANTLR start "rule__ALSFunctionDefinition__Group__9" | ||
9208 | // InternalAlloyLanguage.g:2954:1: rule__ALSFunctionDefinition__Group__9 : rule__ALSFunctionDefinition__Group__9__Impl rule__ALSFunctionDefinition__Group__10 ; | ||
9209 | public final void rule__ALSFunctionDefinition__Group__9() throws RecognitionException { | ||
9210 | |||
9211 | int stackSize = keepStackSize(); | ||
9212 | |||
9213 | try { | ||
9214 | // InternalAlloyLanguage.g:2958:1: ( rule__ALSFunctionDefinition__Group__9__Impl rule__ALSFunctionDefinition__Group__10 ) | ||
9215 | // InternalAlloyLanguage.g:2959:2: rule__ALSFunctionDefinition__Group__9__Impl rule__ALSFunctionDefinition__Group__10 | ||
9216 | { | ||
9217 | pushFollow(FOLLOW_19); | ||
9218 | rule__ALSFunctionDefinition__Group__9__Impl(); | ||
9219 | |||
9220 | state._fsp--; | ||
9221 | if (state.failed) return ; | ||
9222 | pushFollow(FOLLOW_2); | ||
9223 | rule__ALSFunctionDefinition__Group__10(); | ||
9224 | |||
9225 | state._fsp--; | ||
9226 | if (state.failed) return ; | ||
9227 | |||
9228 | } | ||
9229 | |||
9230 | } | ||
9231 | catch (RecognitionException re) { | ||
9232 | reportError(re); | ||
9233 | recover(input,re); | ||
9234 | } | ||
9235 | finally { | ||
9236 | |||
9237 | restoreStackSize(stackSize); | ||
9238 | |||
9239 | } | ||
9240 | return ; | ||
9241 | } | ||
9242 | // $ANTLR end "rule__ALSFunctionDefinition__Group__9" | ||
9243 | |||
9244 | |||
9245 | // $ANTLR start "rule__ALSFunctionDefinition__Group__9__Impl" | ||
9246 | // InternalAlloyLanguage.g:2966:1: rule__ALSFunctionDefinition__Group__9__Impl : ( ( rule__ALSFunctionDefinition__ValueAssignment_9 ) ) ; | ||
9247 | public final void rule__ALSFunctionDefinition__Group__9__Impl() throws RecognitionException { | ||
9248 | |||
9249 | int stackSize = keepStackSize(); | ||
9250 | |||
9251 | try { | ||
9252 | // InternalAlloyLanguage.g:2970:1: ( ( ( rule__ALSFunctionDefinition__ValueAssignment_9 ) ) ) | ||
9253 | // InternalAlloyLanguage.g:2971:1: ( ( rule__ALSFunctionDefinition__ValueAssignment_9 ) ) | ||
9254 | { | ||
9255 | // InternalAlloyLanguage.g:2971:1: ( ( rule__ALSFunctionDefinition__ValueAssignment_9 ) ) | ||
9256 | // InternalAlloyLanguage.g:2972:1: ( rule__ALSFunctionDefinition__ValueAssignment_9 ) | ||
9257 | { | ||
9258 | if ( state.backtracking==0 ) { | ||
9259 | before(grammarAccess.getALSFunctionDefinitionAccess().getValueAssignment_9()); | ||
9260 | } | ||
9261 | // InternalAlloyLanguage.g:2973:1: ( rule__ALSFunctionDefinition__ValueAssignment_9 ) | ||
9262 | // InternalAlloyLanguage.g:2973:2: rule__ALSFunctionDefinition__ValueAssignment_9 | ||
9263 | { | ||
9264 | pushFollow(FOLLOW_2); | ||
9265 | rule__ALSFunctionDefinition__ValueAssignment_9(); | ||
9266 | |||
9267 | state._fsp--; | ||
9268 | if (state.failed) return ; | ||
9269 | |||
9270 | } | ||
9271 | |||
9272 | if ( state.backtracking==0 ) { | ||
9273 | after(grammarAccess.getALSFunctionDefinitionAccess().getValueAssignment_9()); | ||
9274 | } | ||
9275 | |||
9276 | } | ||
9277 | |||
9278 | |||
9279 | } | ||
9280 | |||
9281 | } | ||
9282 | catch (RecognitionException re) { | ||
9283 | reportError(re); | ||
9284 | recover(input,re); | ||
9285 | } | ||
9286 | finally { | ||
9287 | |||
9288 | restoreStackSize(stackSize); | ||
9289 | |||
9290 | } | ||
9291 | return ; | ||
9292 | } | ||
9293 | // $ANTLR end "rule__ALSFunctionDefinition__Group__9__Impl" | ||
9294 | |||
9295 | |||
9296 | // $ANTLR start "rule__ALSFunctionDefinition__Group__10" | ||
9297 | // InternalAlloyLanguage.g:2983:1: rule__ALSFunctionDefinition__Group__10 : rule__ALSFunctionDefinition__Group__10__Impl ; | ||
9298 | public final void rule__ALSFunctionDefinition__Group__10() throws RecognitionException { | ||
9299 | |||
9300 | int stackSize = keepStackSize(); | ||
9301 | |||
9302 | try { | ||
9303 | // InternalAlloyLanguage.g:2987:1: ( rule__ALSFunctionDefinition__Group__10__Impl ) | ||
9304 | // InternalAlloyLanguage.g:2988:2: rule__ALSFunctionDefinition__Group__10__Impl | ||
9305 | { | ||
9306 | pushFollow(FOLLOW_2); | ||
9307 | rule__ALSFunctionDefinition__Group__10__Impl(); | ||
9308 | |||
9309 | state._fsp--; | ||
9310 | if (state.failed) return ; | ||
9311 | |||
9312 | } | ||
9313 | |||
9314 | } | ||
9315 | catch (RecognitionException re) { | ||
9316 | reportError(re); | ||
9317 | recover(input,re); | ||
9318 | } | ||
9319 | finally { | ||
9320 | |||
9321 | restoreStackSize(stackSize); | ||
9322 | |||
9323 | } | ||
9324 | return ; | ||
9325 | } | ||
9326 | // $ANTLR end "rule__ALSFunctionDefinition__Group__10" | ||
9327 | |||
9328 | |||
9329 | // $ANTLR start "rule__ALSFunctionDefinition__Group__10__Impl" | ||
9330 | // InternalAlloyLanguage.g:2994:1: rule__ALSFunctionDefinition__Group__10__Impl : ( '}' ) ; | ||
9331 | public final void rule__ALSFunctionDefinition__Group__10__Impl() throws RecognitionException { | ||
9332 | |||
9333 | int stackSize = keepStackSize(); | ||
9334 | |||
9335 | try { | ||
9336 | // InternalAlloyLanguage.g:2998:1: ( ( '}' ) ) | ||
9337 | // InternalAlloyLanguage.g:2999:1: ( '}' ) | ||
9338 | { | ||
9339 | // InternalAlloyLanguage.g:2999:1: ( '}' ) | ||
9340 | // InternalAlloyLanguage.g:3000:1: '}' | ||
9341 | { | ||
9342 | if ( state.backtracking==0 ) { | ||
9343 | before(grammarAccess.getALSFunctionDefinitionAccess().getRightCurlyBracketKeyword_10()); | ||
9344 | } | ||
9345 | match(input,34,FOLLOW_2); if (state.failed) return ; | ||
9346 | if ( state.backtracking==0 ) { | ||
9347 | after(grammarAccess.getALSFunctionDefinitionAccess().getRightCurlyBracketKeyword_10()); | ||
9348 | } | ||
9349 | |||
9350 | } | ||
9351 | |||
9352 | |||
9353 | } | ||
9354 | |||
9355 | } | ||
9356 | catch (RecognitionException re) { | ||
9357 | reportError(re); | ||
9358 | recover(input,re); | ||
9359 | } | ||
9360 | finally { | ||
9361 | |||
9362 | restoreStackSize(stackSize); | ||
9363 | |||
9364 | } | ||
9365 | return ; | ||
9366 | } | ||
9367 | // $ANTLR end "rule__ALSFunctionDefinition__Group__10__Impl" | ||
9368 | |||
9369 | |||
9370 | // $ANTLR start "rule__ALSFunctionDefinition__Group_4__0" | ||
9371 | // InternalAlloyLanguage.g:3035:1: rule__ALSFunctionDefinition__Group_4__0 : rule__ALSFunctionDefinition__Group_4__0__Impl rule__ALSFunctionDefinition__Group_4__1 ; | ||
9372 | public final void rule__ALSFunctionDefinition__Group_4__0() throws RecognitionException { | ||
9373 | |||
9374 | int stackSize = keepStackSize(); | ||
9375 | |||
9376 | try { | ||
9377 | // InternalAlloyLanguage.g:3039:1: ( rule__ALSFunctionDefinition__Group_4__0__Impl rule__ALSFunctionDefinition__Group_4__1 ) | ||
9378 | // InternalAlloyLanguage.g:3040:2: rule__ALSFunctionDefinition__Group_4__0__Impl rule__ALSFunctionDefinition__Group_4__1 | ||
9379 | { | ||
9380 | pushFollow(FOLLOW_5); | ||
9381 | rule__ALSFunctionDefinition__Group_4__0__Impl(); | ||
9382 | |||
9383 | state._fsp--; | ||
9384 | if (state.failed) return ; | ||
9385 | pushFollow(FOLLOW_2); | ||
9386 | rule__ALSFunctionDefinition__Group_4__1(); | ||
9387 | |||
9388 | state._fsp--; | ||
9389 | if (state.failed) return ; | ||
9390 | |||
9391 | } | ||
9392 | |||
9393 | } | ||
9394 | catch (RecognitionException re) { | ||
9395 | reportError(re); | ||
9396 | recover(input,re); | ||
9397 | } | ||
9398 | finally { | ||
9399 | |||
9400 | restoreStackSize(stackSize); | ||
9401 | |||
9402 | } | ||
9403 | return ; | ||
9404 | } | ||
9405 | // $ANTLR end "rule__ALSFunctionDefinition__Group_4__0" | ||
9406 | |||
9407 | |||
9408 | // $ANTLR start "rule__ALSFunctionDefinition__Group_4__0__Impl" | ||
9409 | // InternalAlloyLanguage.g:3047:1: rule__ALSFunctionDefinition__Group_4__0__Impl : ( ',' ) ; | ||
9410 | public final void rule__ALSFunctionDefinition__Group_4__0__Impl() throws RecognitionException { | ||
9411 | |||
9412 | int stackSize = keepStackSize(); | ||
9413 | |||
9414 | try { | ||
9415 | // InternalAlloyLanguage.g:3051:1: ( ( ',' ) ) | ||
9416 | // InternalAlloyLanguage.g:3052:1: ( ',' ) | ||
9417 | { | ||
9418 | // InternalAlloyLanguage.g:3052:1: ( ',' ) | ||
9419 | // InternalAlloyLanguage.g:3053:1: ',' | ||
9420 | { | ||
9421 | if ( state.backtracking==0 ) { | ||
9422 | before(grammarAccess.getALSFunctionDefinitionAccess().getCommaKeyword_4_0()); | ||
9423 | } | ||
9424 | match(input,35,FOLLOW_2); if (state.failed) return ; | ||
9425 | if ( state.backtracking==0 ) { | ||
9426 | after(grammarAccess.getALSFunctionDefinitionAccess().getCommaKeyword_4_0()); | ||
9427 | } | ||
9428 | |||
9429 | } | ||
9430 | |||
9431 | |||
9432 | } | ||
9433 | |||
9434 | } | ||
9435 | catch (RecognitionException re) { | ||
9436 | reportError(re); | ||
9437 | recover(input,re); | ||
9438 | } | ||
9439 | finally { | ||
9440 | |||
9441 | restoreStackSize(stackSize); | ||
9442 | |||
9443 | } | ||
9444 | return ; | ||
9445 | } | ||
9446 | // $ANTLR end "rule__ALSFunctionDefinition__Group_4__0__Impl" | ||
9447 | |||
9448 | |||
9449 | // $ANTLR start "rule__ALSFunctionDefinition__Group_4__1" | ||
9450 | // InternalAlloyLanguage.g:3066:1: rule__ALSFunctionDefinition__Group_4__1 : rule__ALSFunctionDefinition__Group_4__1__Impl ; | ||
9451 | public final void rule__ALSFunctionDefinition__Group_4__1() throws RecognitionException { | ||
9452 | |||
9453 | int stackSize = keepStackSize(); | ||
9454 | |||
9455 | try { | ||
9456 | // InternalAlloyLanguage.g:3070:1: ( rule__ALSFunctionDefinition__Group_4__1__Impl ) | ||
9457 | // InternalAlloyLanguage.g:3071:2: rule__ALSFunctionDefinition__Group_4__1__Impl | ||
9458 | { | ||
9459 | pushFollow(FOLLOW_2); | ||
9460 | rule__ALSFunctionDefinition__Group_4__1__Impl(); | ||
9461 | |||
9462 | state._fsp--; | ||
9463 | if (state.failed) return ; | ||
9464 | |||
9465 | } | ||
9466 | |||
9467 | } | ||
9468 | catch (RecognitionException re) { | ||
9469 | reportError(re); | ||
9470 | recover(input,re); | ||
9471 | } | ||
9472 | finally { | ||
9473 | |||
9474 | restoreStackSize(stackSize); | ||
9475 | |||
9476 | } | ||
9477 | return ; | ||
9478 | } | ||
9479 | // $ANTLR end "rule__ALSFunctionDefinition__Group_4__1" | ||
9480 | |||
9481 | |||
9482 | // $ANTLR start "rule__ALSFunctionDefinition__Group_4__1__Impl" | ||
9483 | // InternalAlloyLanguage.g:3077:1: rule__ALSFunctionDefinition__Group_4__1__Impl : ( ( rule__ALSFunctionDefinition__VariablesAssignment_4_1 ) ) ; | ||
9484 | public final void rule__ALSFunctionDefinition__Group_4__1__Impl() throws RecognitionException { | ||
9485 | |||
9486 | int stackSize = keepStackSize(); | ||
9487 | |||
9488 | try { | ||
9489 | // InternalAlloyLanguage.g:3081:1: ( ( ( rule__ALSFunctionDefinition__VariablesAssignment_4_1 ) ) ) | ||
9490 | // InternalAlloyLanguage.g:3082:1: ( ( rule__ALSFunctionDefinition__VariablesAssignment_4_1 ) ) | ||
9491 | { | ||
9492 | // InternalAlloyLanguage.g:3082:1: ( ( rule__ALSFunctionDefinition__VariablesAssignment_4_1 ) ) | ||
9493 | // InternalAlloyLanguage.g:3083:1: ( rule__ALSFunctionDefinition__VariablesAssignment_4_1 ) | ||
9494 | { | ||
9495 | if ( state.backtracking==0 ) { | ||
9496 | before(grammarAccess.getALSFunctionDefinitionAccess().getVariablesAssignment_4_1()); | ||
9497 | } | ||
9498 | // InternalAlloyLanguage.g:3084:1: ( rule__ALSFunctionDefinition__VariablesAssignment_4_1 ) | ||
9499 | // InternalAlloyLanguage.g:3084:2: rule__ALSFunctionDefinition__VariablesAssignment_4_1 | ||
9500 | { | ||
9501 | pushFollow(FOLLOW_2); | ||
9502 | rule__ALSFunctionDefinition__VariablesAssignment_4_1(); | ||
9503 | |||
9504 | state._fsp--; | ||
9505 | if (state.failed) return ; | ||
9506 | |||
9507 | } | ||
9508 | |||
9509 | if ( state.backtracking==0 ) { | ||
9510 | after(grammarAccess.getALSFunctionDefinitionAccess().getVariablesAssignment_4_1()); | ||
9511 | } | ||
9512 | |||
9513 | } | ||
9514 | |||
9515 | |||
9516 | } | ||
9517 | |||
9518 | } | ||
9519 | catch (RecognitionException re) { | ||
9520 | reportError(re); | ||
9521 | recover(input,re); | ||
9522 | } | ||
9523 | finally { | ||
9524 | |||
9525 | restoreStackSize(stackSize); | ||
9526 | |||
9527 | } | ||
9528 | return ; | ||
9529 | } | ||
9530 | // $ANTLR end "rule__ALSFunctionDefinition__Group_4__1__Impl" | ||
9531 | |||
9532 | |||
9533 | // $ANTLR start "rule__ALSRelationDefinition__Group__0" | ||
9534 | // InternalAlloyLanguage.g:3098:1: rule__ALSRelationDefinition__Group__0 : rule__ALSRelationDefinition__Group__0__Impl rule__ALSRelationDefinition__Group__1 ; | ||
9535 | public final void rule__ALSRelationDefinition__Group__0() throws RecognitionException { | ||
9536 | |||
9537 | int stackSize = keepStackSize(); | ||
9538 | |||
9539 | try { | ||
9540 | // InternalAlloyLanguage.g:3102:1: ( rule__ALSRelationDefinition__Group__0__Impl rule__ALSRelationDefinition__Group__1 ) | ||
9541 | // InternalAlloyLanguage.g:3103:2: rule__ALSRelationDefinition__Group__0__Impl rule__ALSRelationDefinition__Group__1 | ||
9542 | { | ||
9543 | pushFollow(FOLLOW_5); | ||
9544 | rule__ALSRelationDefinition__Group__0__Impl(); | ||
9545 | |||
9546 | state._fsp--; | ||
9547 | if (state.failed) return ; | ||
9548 | pushFollow(FOLLOW_2); | ||
9549 | rule__ALSRelationDefinition__Group__1(); | ||
9550 | |||
9551 | state._fsp--; | ||
9552 | if (state.failed) return ; | ||
9553 | |||
9554 | } | ||
9555 | |||
9556 | } | ||
9557 | catch (RecognitionException re) { | ||
9558 | reportError(re); | ||
9559 | recover(input,re); | ||
9560 | } | ||
9561 | finally { | ||
9562 | |||
9563 | restoreStackSize(stackSize); | ||
9564 | |||
9565 | } | ||
9566 | return ; | ||
9567 | } | ||
9568 | // $ANTLR end "rule__ALSRelationDefinition__Group__0" | ||
9569 | |||
9570 | |||
9571 | // $ANTLR start "rule__ALSRelationDefinition__Group__0__Impl" | ||
9572 | // InternalAlloyLanguage.g:3110:1: rule__ALSRelationDefinition__Group__0__Impl : ( 'pred' ) ; | ||
9573 | public final void rule__ALSRelationDefinition__Group__0__Impl() throws RecognitionException { | ||
9574 | |||
9575 | int stackSize = keepStackSize(); | ||
9576 | |||
9577 | try { | ||
9578 | // InternalAlloyLanguage.g:3114:1: ( ( 'pred' ) ) | ||
9579 | // InternalAlloyLanguage.g:3115:1: ( 'pred' ) | ||
9580 | { | ||
9581 | // InternalAlloyLanguage.g:3115:1: ( 'pred' ) | ||
9582 | // InternalAlloyLanguage.g:3116:1: 'pred' | ||
9583 | { | ||
9584 | if ( state.backtracking==0 ) { | ||
9585 | before(grammarAccess.getALSRelationDefinitionAccess().getPredKeyword_0()); | ||
9586 | } | ||
9587 | match(input,44,FOLLOW_2); if (state.failed) return ; | ||
9588 | if ( state.backtracking==0 ) { | ||
9589 | after(grammarAccess.getALSRelationDefinitionAccess().getPredKeyword_0()); | ||
9590 | } | ||
9591 | |||
9592 | } | ||
9593 | |||
9594 | |||
9595 | } | ||
9596 | |||
9597 | } | ||
9598 | catch (RecognitionException re) { | ||
9599 | reportError(re); | ||
9600 | recover(input,re); | ||
9601 | } | ||
9602 | finally { | ||
9603 | |||
9604 | restoreStackSize(stackSize); | ||
9605 | |||
9606 | } | ||
9607 | return ; | ||
9608 | } | ||
9609 | // $ANTLR end "rule__ALSRelationDefinition__Group__0__Impl" | ||
9610 | |||
9611 | |||
9612 | // $ANTLR start "rule__ALSRelationDefinition__Group__1" | ||
9613 | // InternalAlloyLanguage.g:3129:1: rule__ALSRelationDefinition__Group__1 : rule__ALSRelationDefinition__Group__1__Impl rule__ALSRelationDefinition__Group__2 ; | ||
9614 | public final void rule__ALSRelationDefinition__Group__1() throws RecognitionException { | ||
9615 | |||
9616 | int stackSize = keepStackSize(); | ||
9617 | |||
9618 | try { | ||
9619 | // InternalAlloyLanguage.g:3133:1: ( rule__ALSRelationDefinition__Group__1__Impl rule__ALSRelationDefinition__Group__2 ) | ||
9620 | // InternalAlloyLanguage.g:3134:2: rule__ALSRelationDefinition__Group__1__Impl rule__ALSRelationDefinition__Group__2 | ||
9621 | { | ||
9622 | pushFollow(FOLLOW_17); | ||
9623 | rule__ALSRelationDefinition__Group__1__Impl(); | ||
9624 | |||
9625 | state._fsp--; | ||
9626 | if (state.failed) return ; | ||
9627 | pushFollow(FOLLOW_2); | ||
9628 | rule__ALSRelationDefinition__Group__2(); | ||
9629 | |||
9630 | state._fsp--; | ||
9631 | if (state.failed) return ; | ||
9632 | |||
9633 | } | ||
9634 | |||
9635 | } | ||
9636 | catch (RecognitionException re) { | ||
9637 | reportError(re); | ||
9638 | recover(input,re); | ||
9639 | } | ||
9640 | finally { | ||
9641 | |||
9642 | restoreStackSize(stackSize); | ||
9643 | |||
9644 | } | ||
9645 | return ; | ||
9646 | } | ||
9647 | // $ANTLR end "rule__ALSRelationDefinition__Group__1" | ||
9648 | |||
9649 | |||
9650 | // $ANTLR start "rule__ALSRelationDefinition__Group__1__Impl" | ||
9651 | // InternalAlloyLanguage.g:3141:1: rule__ALSRelationDefinition__Group__1__Impl : ( ( rule__ALSRelationDefinition__NameAssignment_1 ) ) ; | ||
9652 | public final void rule__ALSRelationDefinition__Group__1__Impl() throws RecognitionException { | ||
9653 | |||
9654 | int stackSize = keepStackSize(); | ||
9655 | |||
9656 | try { | ||
9657 | // InternalAlloyLanguage.g:3145:1: ( ( ( rule__ALSRelationDefinition__NameAssignment_1 ) ) ) | ||
9658 | // InternalAlloyLanguage.g:3146:1: ( ( rule__ALSRelationDefinition__NameAssignment_1 ) ) | ||
9659 | { | ||
9660 | // InternalAlloyLanguage.g:3146:1: ( ( rule__ALSRelationDefinition__NameAssignment_1 ) ) | ||
9661 | // InternalAlloyLanguage.g:3147:1: ( rule__ALSRelationDefinition__NameAssignment_1 ) | ||
9662 | { | ||
9663 | if ( state.backtracking==0 ) { | ||
9664 | before(grammarAccess.getALSRelationDefinitionAccess().getNameAssignment_1()); | ||
9665 | } | ||
9666 | // InternalAlloyLanguage.g:3148:1: ( rule__ALSRelationDefinition__NameAssignment_1 ) | ||
9667 | // InternalAlloyLanguage.g:3148:2: rule__ALSRelationDefinition__NameAssignment_1 | ||
9668 | { | ||
9669 | pushFollow(FOLLOW_2); | ||
9670 | rule__ALSRelationDefinition__NameAssignment_1(); | ||
9671 | |||
9672 | state._fsp--; | ||
9673 | if (state.failed) return ; | ||
9674 | |||
9675 | } | ||
9676 | |||
9677 | if ( state.backtracking==0 ) { | ||
9678 | after(grammarAccess.getALSRelationDefinitionAccess().getNameAssignment_1()); | ||
9679 | } | ||
9680 | |||
9681 | } | ||
9682 | |||
9683 | |||
9684 | } | ||
9685 | |||
9686 | } | ||
9687 | catch (RecognitionException re) { | ||
9688 | reportError(re); | ||
9689 | recover(input,re); | ||
9690 | } | ||
9691 | finally { | ||
9692 | |||
9693 | restoreStackSize(stackSize); | ||
9694 | |||
9695 | } | ||
9696 | return ; | ||
9697 | } | ||
9698 | // $ANTLR end "rule__ALSRelationDefinition__Group__1__Impl" | ||
9699 | |||
9700 | |||
9701 | // $ANTLR start "rule__ALSRelationDefinition__Group__2" | ||
9702 | // InternalAlloyLanguage.g:3158:1: rule__ALSRelationDefinition__Group__2 : rule__ALSRelationDefinition__Group__2__Impl rule__ALSRelationDefinition__Group__3 ; | ||
9703 | public final void rule__ALSRelationDefinition__Group__2() throws RecognitionException { | ||
9704 | |||
9705 | int stackSize = keepStackSize(); | ||
9706 | |||
9707 | try { | ||
9708 | // InternalAlloyLanguage.g:3162:1: ( rule__ALSRelationDefinition__Group__2__Impl rule__ALSRelationDefinition__Group__3 ) | ||
9709 | // InternalAlloyLanguage.g:3163:2: rule__ALSRelationDefinition__Group__2__Impl rule__ALSRelationDefinition__Group__3 | ||
9710 | { | ||
9711 | pushFollow(FOLLOW_5); | ||
9712 | rule__ALSRelationDefinition__Group__2__Impl(); | ||
9713 | |||
9714 | state._fsp--; | ||
9715 | if (state.failed) return ; | ||
9716 | pushFollow(FOLLOW_2); | ||
9717 | rule__ALSRelationDefinition__Group__3(); | ||
9718 | |||
9719 | state._fsp--; | ||
9720 | if (state.failed) return ; | ||
9721 | |||
9722 | } | ||
9723 | |||
9724 | } | ||
9725 | catch (RecognitionException re) { | ||
9726 | reportError(re); | ||
9727 | recover(input,re); | ||
9728 | } | ||
9729 | finally { | ||
9730 | |||
9731 | restoreStackSize(stackSize); | ||
9732 | |||
9733 | } | ||
9734 | return ; | ||
9735 | } | ||
9736 | // $ANTLR end "rule__ALSRelationDefinition__Group__2" | ||
9737 | |||
9738 | |||
9739 | // $ANTLR start "rule__ALSRelationDefinition__Group__2__Impl" | ||
9740 | // InternalAlloyLanguage.g:3170:1: rule__ALSRelationDefinition__Group__2__Impl : ( '[' ) ; | ||
9741 | public final void rule__ALSRelationDefinition__Group__2__Impl() throws RecognitionException { | ||
9742 | |||
9743 | int stackSize = keepStackSize(); | ||
9744 | |||
9745 | try { | ||
9746 | // InternalAlloyLanguage.g:3174:1: ( ( '[' ) ) | ||
9747 | // InternalAlloyLanguage.g:3175:1: ( '[' ) | ||
9748 | { | ||
9749 | // InternalAlloyLanguage.g:3175:1: ( '[' ) | ||
9750 | // InternalAlloyLanguage.g:3176:1: '[' | ||
9751 | { | ||
9752 | if ( state.backtracking==0 ) { | ||
9753 | before(grammarAccess.getALSRelationDefinitionAccess().getLeftSquareBracketKeyword_2()); | ||
9754 | } | ||
9755 | match(input,42,FOLLOW_2); if (state.failed) return ; | ||
9756 | if ( state.backtracking==0 ) { | ||
9757 | after(grammarAccess.getALSRelationDefinitionAccess().getLeftSquareBracketKeyword_2()); | ||
9758 | } | ||
9759 | |||
9760 | } | ||
9761 | |||
9762 | |||
9763 | } | ||
9764 | |||
9765 | } | ||
9766 | catch (RecognitionException re) { | ||
9767 | reportError(re); | ||
9768 | recover(input,re); | ||
9769 | } | ||
9770 | finally { | ||
9771 | |||
9772 | restoreStackSize(stackSize); | ||
9773 | |||
9774 | } | ||
9775 | return ; | ||
9776 | } | ||
9777 | // $ANTLR end "rule__ALSRelationDefinition__Group__2__Impl" | ||
9778 | |||
9779 | |||
9780 | // $ANTLR start "rule__ALSRelationDefinition__Group__3" | ||
9781 | // InternalAlloyLanguage.g:3189:1: rule__ALSRelationDefinition__Group__3 : rule__ALSRelationDefinition__Group__3__Impl rule__ALSRelationDefinition__Group__4 ; | ||
9782 | public final void rule__ALSRelationDefinition__Group__3() throws RecognitionException { | ||
9783 | |||
9784 | int stackSize = keepStackSize(); | ||
9785 | |||
9786 | try { | ||
9787 | // InternalAlloyLanguage.g:3193:1: ( rule__ALSRelationDefinition__Group__3__Impl rule__ALSRelationDefinition__Group__4 ) | ||
9788 | // InternalAlloyLanguage.g:3194:2: rule__ALSRelationDefinition__Group__3__Impl rule__ALSRelationDefinition__Group__4 | ||
9789 | { | ||
9790 | pushFollow(FOLLOW_18); | ||
9791 | rule__ALSRelationDefinition__Group__3__Impl(); | ||
9792 | |||
9793 | state._fsp--; | ||
9794 | if (state.failed) return ; | ||
9795 | pushFollow(FOLLOW_2); | ||
9796 | rule__ALSRelationDefinition__Group__4(); | ||
9797 | |||
9798 | state._fsp--; | ||
9799 | if (state.failed) return ; | ||
9800 | |||
9801 | } | ||
9802 | |||
9803 | } | ||
9804 | catch (RecognitionException re) { | ||
9805 | reportError(re); | ||
9806 | recover(input,re); | ||
9807 | } | ||
9808 | finally { | ||
9809 | |||
9810 | restoreStackSize(stackSize); | ||
9811 | |||
9812 | } | ||
9813 | return ; | ||
9814 | } | ||
9815 | // $ANTLR end "rule__ALSRelationDefinition__Group__3" | ||
9816 | |||
9817 | |||
9818 | // $ANTLR start "rule__ALSRelationDefinition__Group__3__Impl" | ||
9819 | // InternalAlloyLanguage.g:3201:1: rule__ALSRelationDefinition__Group__3__Impl : ( ( rule__ALSRelationDefinition__VariablesAssignment_3 ) ) ; | ||
9820 | public final void rule__ALSRelationDefinition__Group__3__Impl() throws RecognitionException { | ||
9821 | |||
9822 | int stackSize = keepStackSize(); | ||
9823 | |||
9824 | try { | ||
9825 | // InternalAlloyLanguage.g:3205:1: ( ( ( rule__ALSRelationDefinition__VariablesAssignment_3 ) ) ) | ||
9826 | // InternalAlloyLanguage.g:3206:1: ( ( rule__ALSRelationDefinition__VariablesAssignment_3 ) ) | ||
9827 | { | ||
9828 | // InternalAlloyLanguage.g:3206:1: ( ( rule__ALSRelationDefinition__VariablesAssignment_3 ) ) | ||
9829 | // InternalAlloyLanguage.g:3207:1: ( rule__ALSRelationDefinition__VariablesAssignment_3 ) | ||
9830 | { | ||
9831 | if ( state.backtracking==0 ) { | ||
9832 | before(grammarAccess.getALSRelationDefinitionAccess().getVariablesAssignment_3()); | ||
9833 | } | ||
9834 | // InternalAlloyLanguage.g:3208:1: ( rule__ALSRelationDefinition__VariablesAssignment_3 ) | ||
9835 | // InternalAlloyLanguage.g:3208:2: rule__ALSRelationDefinition__VariablesAssignment_3 | ||
9836 | { | ||
9837 | pushFollow(FOLLOW_2); | ||
9838 | rule__ALSRelationDefinition__VariablesAssignment_3(); | ||
9839 | |||
9840 | state._fsp--; | ||
9841 | if (state.failed) return ; | ||
9842 | |||
9843 | } | ||
9844 | |||
9845 | if ( state.backtracking==0 ) { | ||
9846 | after(grammarAccess.getALSRelationDefinitionAccess().getVariablesAssignment_3()); | ||
9847 | } | ||
9848 | |||
9849 | } | ||
9850 | |||
9851 | |||
9852 | } | ||
9853 | |||
9854 | } | ||
9855 | catch (RecognitionException re) { | ||
9856 | reportError(re); | ||
9857 | recover(input,re); | ||
9858 | } | ||
9859 | finally { | ||
9860 | |||
9861 | restoreStackSize(stackSize); | ||
9862 | |||
9863 | } | ||
9864 | return ; | ||
9865 | } | ||
9866 | // $ANTLR end "rule__ALSRelationDefinition__Group__3__Impl" | ||
9867 | |||
9868 | |||
9869 | // $ANTLR start "rule__ALSRelationDefinition__Group__4" | ||
9870 | // InternalAlloyLanguage.g:3218:1: rule__ALSRelationDefinition__Group__4 : rule__ALSRelationDefinition__Group__4__Impl rule__ALSRelationDefinition__Group__5 ; | ||
9871 | public final void rule__ALSRelationDefinition__Group__4() throws RecognitionException { | ||
9872 | |||
9873 | int stackSize = keepStackSize(); | ||
9874 | |||
9875 | try { | ||
9876 | // InternalAlloyLanguage.g:3222:1: ( rule__ALSRelationDefinition__Group__4__Impl rule__ALSRelationDefinition__Group__5 ) | ||
9877 | // InternalAlloyLanguage.g:3223:2: rule__ALSRelationDefinition__Group__4__Impl rule__ALSRelationDefinition__Group__5 | ||
9878 | { | ||
9879 | pushFollow(FOLLOW_18); | ||
9880 | rule__ALSRelationDefinition__Group__4__Impl(); | ||
9881 | |||
9882 | state._fsp--; | ||
9883 | if (state.failed) return ; | ||
9884 | pushFollow(FOLLOW_2); | ||
9885 | rule__ALSRelationDefinition__Group__5(); | ||
9886 | |||
9887 | state._fsp--; | ||
9888 | if (state.failed) return ; | ||
9889 | |||
9890 | } | ||
9891 | |||
9892 | } | ||
9893 | catch (RecognitionException re) { | ||
9894 | reportError(re); | ||
9895 | recover(input,re); | ||
9896 | } | ||
9897 | finally { | ||
9898 | |||
9899 | restoreStackSize(stackSize); | ||
9900 | |||
9901 | } | ||
9902 | return ; | ||
9903 | } | ||
9904 | // $ANTLR end "rule__ALSRelationDefinition__Group__4" | ||
9905 | |||
9906 | |||
9907 | // $ANTLR start "rule__ALSRelationDefinition__Group__4__Impl" | ||
9908 | // InternalAlloyLanguage.g:3230:1: rule__ALSRelationDefinition__Group__4__Impl : ( ( rule__ALSRelationDefinition__Group_4__0 )* ) ; | ||
9909 | public final void rule__ALSRelationDefinition__Group__4__Impl() throws RecognitionException { | ||
9910 | |||
9911 | int stackSize = keepStackSize(); | ||
9912 | |||
9913 | try { | ||
9914 | // InternalAlloyLanguage.g:3234:1: ( ( ( rule__ALSRelationDefinition__Group_4__0 )* ) ) | ||
9915 | // InternalAlloyLanguage.g:3235:1: ( ( rule__ALSRelationDefinition__Group_4__0 )* ) | ||
9916 | { | ||
9917 | // InternalAlloyLanguage.g:3235:1: ( ( rule__ALSRelationDefinition__Group_4__0 )* ) | ||
9918 | // InternalAlloyLanguage.g:3236:1: ( rule__ALSRelationDefinition__Group_4__0 )* | ||
9919 | { | ||
9920 | if ( state.backtracking==0 ) { | ||
9921 | before(grammarAccess.getALSRelationDefinitionAccess().getGroup_4()); | ||
9922 | } | ||
9923 | // InternalAlloyLanguage.g:3237:1: ( rule__ALSRelationDefinition__Group_4__0 )* | ||
9924 | loop26: | ||
9925 | do { | ||
9926 | int alt26=2; | ||
9927 | int LA26_0 = input.LA(1); | ||
9928 | |||
9929 | if ( (LA26_0==35) ) { | ||
9930 | alt26=1; | ||
9931 | } | ||
9932 | |||
9933 | |||
9934 | switch (alt26) { | ||
9935 | case 1 : | ||
9936 | // InternalAlloyLanguage.g:3237:2: rule__ALSRelationDefinition__Group_4__0 | ||
9937 | { | ||
9938 | pushFollow(FOLLOW_8); | ||
9939 | rule__ALSRelationDefinition__Group_4__0(); | ||
9940 | |||
9941 | state._fsp--; | ||
9942 | if (state.failed) return ; | ||
9943 | |||
9944 | } | ||
9945 | break; | ||
9946 | |||
9947 | default : | ||
9948 | break loop26; | ||
9949 | } | ||
9950 | } while (true); | ||
9951 | |||
9952 | if ( state.backtracking==0 ) { | ||
9953 | after(grammarAccess.getALSRelationDefinitionAccess().getGroup_4()); | ||
9954 | } | ||
9955 | |||
9956 | } | ||
9957 | |||
9958 | |||
9959 | } | ||
9960 | |||
9961 | } | ||
9962 | catch (RecognitionException re) { | ||
9963 | reportError(re); | ||
9964 | recover(input,re); | ||
9965 | } | ||
9966 | finally { | ||
9967 | |||
9968 | restoreStackSize(stackSize); | ||
9969 | |||
9970 | } | ||
9971 | return ; | ||
9972 | } | ||
9973 | // $ANTLR end "rule__ALSRelationDefinition__Group__4__Impl" | ||
9974 | |||
9975 | |||
9976 | // $ANTLR start "rule__ALSRelationDefinition__Group__5" | ||
9977 | // InternalAlloyLanguage.g:3247:1: rule__ALSRelationDefinition__Group__5 : rule__ALSRelationDefinition__Group__5__Impl rule__ALSRelationDefinition__Group__6 ; | ||
9978 | public final void rule__ALSRelationDefinition__Group__5() throws RecognitionException { | ||
9979 | |||
9980 | int stackSize = keepStackSize(); | ||
9981 | |||
9982 | try { | ||
9983 | // InternalAlloyLanguage.g:3251:1: ( rule__ALSRelationDefinition__Group__5__Impl rule__ALSRelationDefinition__Group__6 ) | ||
9984 | // InternalAlloyLanguage.g:3252:2: rule__ALSRelationDefinition__Group__5__Impl rule__ALSRelationDefinition__Group__6 | ||
9985 | { | ||
9986 | pushFollow(FOLLOW_6); | ||
9987 | rule__ALSRelationDefinition__Group__5__Impl(); | ||
9988 | |||
9989 | state._fsp--; | ||
9990 | if (state.failed) return ; | ||
9991 | pushFollow(FOLLOW_2); | ||
9992 | rule__ALSRelationDefinition__Group__6(); | ||
9993 | |||
9994 | state._fsp--; | ||
9995 | if (state.failed) return ; | ||
9996 | |||
9997 | } | ||
9998 | |||
9999 | } | ||
10000 | catch (RecognitionException re) { | ||
10001 | reportError(re); | ||
10002 | recover(input,re); | ||
10003 | } | ||
10004 | finally { | ||
10005 | |||
10006 | restoreStackSize(stackSize); | ||
10007 | |||
10008 | } | ||
10009 | return ; | ||
10010 | } | ||
10011 | // $ANTLR end "rule__ALSRelationDefinition__Group__5" | ||
10012 | |||
10013 | |||
10014 | // $ANTLR start "rule__ALSRelationDefinition__Group__5__Impl" | ||
10015 | // InternalAlloyLanguage.g:3259:1: rule__ALSRelationDefinition__Group__5__Impl : ( ']' ) ; | ||
10016 | public final void rule__ALSRelationDefinition__Group__5__Impl() throws RecognitionException { | ||
10017 | |||
10018 | int stackSize = keepStackSize(); | ||
10019 | |||
10020 | try { | ||
10021 | // InternalAlloyLanguage.g:3263:1: ( ( ']' ) ) | ||
10022 | // InternalAlloyLanguage.g:3264:1: ( ']' ) | ||
10023 | { | ||
10024 | // InternalAlloyLanguage.g:3264:1: ( ']' ) | ||
10025 | // InternalAlloyLanguage.g:3265:1: ']' | ||
10026 | { | ||
10027 | if ( state.backtracking==0 ) { | ||
10028 | before(grammarAccess.getALSRelationDefinitionAccess().getRightSquareBracketKeyword_5()); | ||
10029 | } | ||
10030 | match(input,43,FOLLOW_2); if (state.failed) return ; | ||
10031 | if ( state.backtracking==0 ) { | ||
10032 | after(grammarAccess.getALSRelationDefinitionAccess().getRightSquareBracketKeyword_5()); | ||
10033 | } | ||
10034 | |||
10035 | } | ||
10036 | |||
10037 | |||
10038 | } | ||
10039 | |||
10040 | } | ||
10041 | catch (RecognitionException re) { | ||
10042 | reportError(re); | ||
10043 | recover(input,re); | ||
10044 | } | ||
10045 | finally { | ||
10046 | |||
10047 | restoreStackSize(stackSize); | ||
10048 | |||
10049 | } | ||
10050 | return ; | ||
10051 | } | ||
10052 | // $ANTLR end "rule__ALSRelationDefinition__Group__5__Impl" | ||
10053 | |||
10054 | |||
10055 | // $ANTLR start "rule__ALSRelationDefinition__Group__6" | ||
10056 | // InternalAlloyLanguage.g:3278:1: rule__ALSRelationDefinition__Group__6 : rule__ALSRelationDefinition__Group__6__Impl rule__ALSRelationDefinition__Group__7 ; | ||
10057 | public final void rule__ALSRelationDefinition__Group__6() throws RecognitionException { | ||
10058 | |||
10059 | int stackSize = keepStackSize(); | ||
10060 | |||
10061 | try { | ||
10062 | // InternalAlloyLanguage.g:3282:1: ( rule__ALSRelationDefinition__Group__6__Impl rule__ALSRelationDefinition__Group__7 ) | ||
10063 | // InternalAlloyLanguage.g:3283:2: rule__ALSRelationDefinition__Group__6__Impl rule__ALSRelationDefinition__Group__7 | ||
10064 | { | ||
10065 | pushFollow(FOLLOW_16); | ||
10066 | rule__ALSRelationDefinition__Group__6__Impl(); | ||
10067 | |||
10068 | state._fsp--; | ||
10069 | if (state.failed) return ; | ||
10070 | pushFollow(FOLLOW_2); | ||
10071 | rule__ALSRelationDefinition__Group__7(); | ||
10072 | |||
10073 | state._fsp--; | ||
10074 | if (state.failed) return ; | ||
10075 | |||
10076 | } | ||
10077 | |||
10078 | } | ||
10079 | catch (RecognitionException re) { | ||
10080 | reportError(re); | ||
10081 | recover(input,re); | ||
10082 | } | ||
10083 | finally { | ||
10084 | |||
10085 | restoreStackSize(stackSize); | ||
10086 | |||
10087 | } | ||
10088 | return ; | ||
10089 | } | ||
10090 | // $ANTLR end "rule__ALSRelationDefinition__Group__6" | ||
10091 | |||
10092 | |||
10093 | // $ANTLR start "rule__ALSRelationDefinition__Group__6__Impl" | ||
10094 | // InternalAlloyLanguage.g:3290:1: rule__ALSRelationDefinition__Group__6__Impl : ( '{' ) ; | ||
10095 | public final void rule__ALSRelationDefinition__Group__6__Impl() throws RecognitionException { | ||
10096 | |||
10097 | int stackSize = keepStackSize(); | ||
10098 | |||
10099 | try { | ||
10100 | // InternalAlloyLanguage.g:3294:1: ( ( '{' ) ) | ||
10101 | // InternalAlloyLanguage.g:3295:1: ( '{' ) | ||
10102 | { | ||
10103 | // InternalAlloyLanguage.g:3295:1: ( '{' ) | ||
10104 | // InternalAlloyLanguage.g:3296:1: '{' | ||
10105 | { | ||
10106 | if ( state.backtracking==0 ) { | ||
10107 | before(grammarAccess.getALSRelationDefinitionAccess().getLeftCurlyBracketKeyword_6()); | ||
10108 | } | ||
10109 | match(input,33,FOLLOW_2); if (state.failed) return ; | ||
10110 | if ( state.backtracking==0 ) { | ||
10111 | after(grammarAccess.getALSRelationDefinitionAccess().getLeftCurlyBracketKeyword_6()); | ||
10112 | } | ||
10113 | |||
10114 | } | ||
10115 | |||
10116 | |||
10117 | } | ||
10118 | |||
10119 | } | ||
10120 | catch (RecognitionException re) { | ||
10121 | reportError(re); | ||
10122 | recover(input,re); | ||
10123 | } | ||
10124 | finally { | ||
10125 | |||
10126 | restoreStackSize(stackSize); | ||
10127 | |||
10128 | } | ||
10129 | return ; | ||
10130 | } | ||
10131 | // $ANTLR end "rule__ALSRelationDefinition__Group__6__Impl" | ||
10132 | |||
10133 | |||
10134 | // $ANTLR start "rule__ALSRelationDefinition__Group__7" | ||
10135 | // InternalAlloyLanguage.g:3309:1: rule__ALSRelationDefinition__Group__7 : rule__ALSRelationDefinition__Group__7__Impl rule__ALSRelationDefinition__Group__8 ; | ||
10136 | public final void rule__ALSRelationDefinition__Group__7() throws RecognitionException { | ||
10137 | |||
10138 | int stackSize = keepStackSize(); | ||
10139 | |||
10140 | try { | ||
10141 | // InternalAlloyLanguage.g:3313:1: ( rule__ALSRelationDefinition__Group__7__Impl rule__ALSRelationDefinition__Group__8 ) | ||
10142 | // InternalAlloyLanguage.g:3314:2: rule__ALSRelationDefinition__Group__7__Impl rule__ALSRelationDefinition__Group__8 | ||
10143 | { | ||
10144 | pushFollow(FOLLOW_19); | ||
10145 | rule__ALSRelationDefinition__Group__7__Impl(); | ||
10146 | |||
10147 | state._fsp--; | ||
10148 | if (state.failed) return ; | ||
10149 | pushFollow(FOLLOW_2); | ||
10150 | rule__ALSRelationDefinition__Group__8(); | ||
10151 | |||
10152 | state._fsp--; | ||
10153 | if (state.failed) return ; | ||
10154 | |||
10155 | } | ||
10156 | |||
10157 | } | ||
10158 | catch (RecognitionException re) { | ||
10159 | reportError(re); | ||
10160 | recover(input,re); | ||
10161 | } | ||
10162 | finally { | ||
10163 | |||
10164 | restoreStackSize(stackSize); | ||
10165 | |||
10166 | } | ||
10167 | return ; | ||
10168 | } | ||
10169 | // $ANTLR end "rule__ALSRelationDefinition__Group__7" | ||
10170 | |||
10171 | |||
10172 | // $ANTLR start "rule__ALSRelationDefinition__Group__7__Impl" | ||
10173 | // InternalAlloyLanguage.g:3321:1: rule__ALSRelationDefinition__Group__7__Impl : ( ( rule__ALSRelationDefinition__ValueAssignment_7 ) ) ; | ||
10174 | public final void rule__ALSRelationDefinition__Group__7__Impl() throws RecognitionException { | ||
10175 | |||
10176 | int stackSize = keepStackSize(); | ||
10177 | |||
10178 | try { | ||
10179 | // InternalAlloyLanguage.g:3325:1: ( ( ( rule__ALSRelationDefinition__ValueAssignment_7 ) ) ) | ||
10180 | // InternalAlloyLanguage.g:3326:1: ( ( rule__ALSRelationDefinition__ValueAssignment_7 ) ) | ||
10181 | { | ||
10182 | // InternalAlloyLanguage.g:3326:1: ( ( rule__ALSRelationDefinition__ValueAssignment_7 ) ) | ||
10183 | // InternalAlloyLanguage.g:3327:1: ( rule__ALSRelationDefinition__ValueAssignment_7 ) | ||
10184 | { | ||
10185 | if ( state.backtracking==0 ) { | ||
10186 | before(grammarAccess.getALSRelationDefinitionAccess().getValueAssignment_7()); | ||
10187 | } | ||
10188 | // InternalAlloyLanguage.g:3328:1: ( rule__ALSRelationDefinition__ValueAssignment_7 ) | ||
10189 | // InternalAlloyLanguage.g:3328:2: rule__ALSRelationDefinition__ValueAssignment_7 | ||
10190 | { | ||
10191 | pushFollow(FOLLOW_2); | ||
10192 | rule__ALSRelationDefinition__ValueAssignment_7(); | ||
10193 | |||
10194 | state._fsp--; | ||
10195 | if (state.failed) return ; | ||
10196 | |||
10197 | } | ||
10198 | |||
10199 | if ( state.backtracking==0 ) { | ||
10200 | after(grammarAccess.getALSRelationDefinitionAccess().getValueAssignment_7()); | ||
10201 | } | ||
10202 | |||
10203 | } | ||
10204 | |||
10205 | |||
10206 | } | ||
10207 | |||
10208 | } | ||
10209 | catch (RecognitionException re) { | ||
10210 | reportError(re); | ||
10211 | recover(input,re); | ||
10212 | } | ||
10213 | finally { | ||
10214 | |||
10215 | restoreStackSize(stackSize); | ||
10216 | |||
10217 | } | ||
10218 | return ; | ||
10219 | } | ||
10220 | // $ANTLR end "rule__ALSRelationDefinition__Group__7__Impl" | ||
10221 | |||
10222 | |||
10223 | // $ANTLR start "rule__ALSRelationDefinition__Group__8" | ||
10224 | // InternalAlloyLanguage.g:3338:1: rule__ALSRelationDefinition__Group__8 : rule__ALSRelationDefinition__Group__8__Impl ; | ||
10225 | public final void rule__ALSRelationDefinition__Group__8() throws RecognitionException { | ||
10226 | |||
10227 | int stackSize = keepStackSize(); | ||
10228 | |||
10229 | try { | ||
10230 | // InternalAlloyLanguage.g:3342:1: ( rule__ALSRelationDefinition__Group__8__Impl ) | ||
10231 | // InternalAlloyLanguage.g:3343:2: rule__ALSRelationDefinition__Group__8__Impl | ||
10232 | { | ||
10233 | pushFollow(FOLLOW_2); | ||
10234 | rule__ALSRelationDefinition__Group__8__Impl(); | ||
10235 | |||
10236 | state._fsp--; | ||
10237 | if (state.failed) return ; | ||
10238 | |||
10239 | } | ||
10240 | |||
10241 | } | ||
10242 | catch (RecognitionException re) { | ||
10243 | reportError(re); | ||
10244 | recover(input,re); | ||
10245 | } | ||
10246 | finally { | ||
10247 | |||
10248 | restoreStackSize(stackSize); | ||
10249 | |||
10250 | } | ||
10251 | return ; | ||
10252 | } | ||
10253 | // $ANTLR end "rule__ALSRelationDefinition__Group__8" | ||
10254 | |||
10255 | |||
10256 | // $ANTLR start "rule__ALSRelationDefinition__Group__8__Impl" | ||
10257 | // InternalAlloyLanguage.g:3349:1: rule__ALSRelationDefinition__Group__8__Impl : ( '}' ) ; | ||
10258 | public final void rule__ALSRelationDefinition__Group__8__Impl() throws RecognitionException { | ||
10259 | |||
10260 | int stackSize = keepStackSize(); | ||
10261 | |||
10262 | try { | ||
10263 | // InternalAlloyLanguage.g:3353:1: ( ( '}' ) ) | ||
10264 | // InternalAlloyLanguage.g:3354:1: ( '}' ) | ||
10265 | { | ||
10266 | // InternalAlloyLanguage.g:3354:1: ( '}' ) | ||
10267 | // InternalAlloyLanguage.g:3355:1: '}' | ||
10268 | { | ||
10269 | if ( state.backtracking==0 ) { | ||
10270 | before(grammarAccess.getALSRelationDefinitionAccess().getRightCurlyBracketKeyword_8()); | ||
10271 | } | ||
10272 | match(input,34,FOLLOW_2); if (state.failed) return ; | ||
10273 | if ( state.backtracking==0 ) { | ||
10274 | after(grammarAccess.getALSRelationDefinitionAccess().getRightCurlyBracketKeyword_8()); | ||
10275 | } | ||
10276 | |||
10277 | } | ||
10278 | |||
10279 | |||
10280 | } | ||
10281 | |||
10282 | } | ||
10283 | catch (RecognitionException re) { | ||
10284 | reportError(re); | ||
10285 | recover(input,re); | ||
10286 | } | ||
10287 | finally { | ||
10288 | |||
10289 | restoreStackSize(stackSize); | ||
10290 | |||
10291 | } | ||
10292 | return ; | ||
10293 | } | ||
10294 | // $ANTLR end "rule__ALSRelationDefinition__Group__8__Impl" | ||
10295 | |||
10296 | |||
10297 | // $ANTLR start "rule__ALSRelationDefinition__Group_4__0" | ||
10298 | // InternalAlloyLanguage.g:3386:1: rule__ALSRelationDefinition__Group_4__0 : rule__ALSRelationDefinition__Group_4__0__Impl rule__ALSRelationDefinition__Group_4__1 ; | ||
10299 | public final void rule__ALSRelationDefinition__Group_4__0() throws RecognitionException { | ||
10300 | |||
10301 | int stackSize = keepStackSize(); | ||
10302 | |||
10303 | try { | ||
10304 | // InternalAlloyLanguage.g:3390:1: ( rule__ALSRelationDefinition__Group_4__0__Impl rule__ALSRelationDefinition__Group_4__1 ) | ||
10305 | // InternalAlloyLanguage.g:3391:2: rule__ALSRelationDefinition__Group_4__0__Impl rule__ALSRelationDefinition__Group_4__1 | ||
10306 | { | ||
10307 | pushFollow(FOLLOW_5); | ||
10308 | rule__ALSRelationDefinition__Group_4__0__Impl(); | ||
10309 | |||
10310 | state._fsp--; | ||
10311 | if (state.failed) return ; | ||
10312 | pushFollow(FOLLOW_2); | ||
10313 | rule__ALSRelationDefinition__Group_4__1(); | ||
10314 | |||
10315 | state._fsp--; | ||
10316 | if (state.failed) return ; | ||
10317 | |||
10318 | } | ||
10319 | |||
10320 | } | ||
10321 | catch (RecognitionException re) { | ||
10322 | reportError(re); | ||
10323 | recover(input,re); | ||
10324 | } | ||
10325 | finally { | ||
10326 | |||
10327 | restoreStackSize(stackSize); | ||
10328 | |||
10329 | } | ||
10330 | return ; | ||
10331 | } | ||
10332 | // $ANTLR end "rule__ALSRelationDefinition__Group_4__0" | ||
10333 | |||
10334 | |||
10335 | // $ANTLR start "rule__ALSRelationDefinition__Group_4__0__Impl" | ||
10336 | // InternalAlloyLanguage.g:3398:1: rule__ALSRelationDefinition__Group_4__0__Impl : ( ',' ) ; | ||
10337 | public final void rule__ALSRelationDefinition__Group_4__0__Impl() throws RecognitionException { | ||
10338 | |||
10339 | int stackSize = keepStackSize(); | ||
10340 | |||
10341 | try { | ||
10342 | // InternalAlloyLanguage.g:3402:1: ( ( ',' ) ) | ||
10343 | // InternalAlloyLanguage.g:3403:1: ( ',' ) | ||
10344 | { | ||
10345 | // InternalAlloyLanguage.g:3403:1: ( ',' ) | ||
10346 | // InternalAlloyLanguage.g:3404:1: ',' | ||
10347 | { | ||
10348 | if ( state.backtracking==0 ) { | ||
10349 | before(grammarAccess.getALSRelationDefinitionAccess().getCommaKeyword_4_0()); | ||
10350 | } | ||
10351 | match(input,35,FOLLOW_2); if (state.failed) return ; | ||
10352 | if ( state.backtracking==0 ) { | ||
10353 | after(grammarAccess.getALSRelationDefinitionAccess().getCommaKeyword_4_0()); | ||
10354 | } | ||
10355 | |||
10356 | } | ||
10357 | |||
10358 | |||
10359 | } | ||
10360 | |||
10361 | } | ||
10362 | catch (RecognitionException re) { | ||
10363 | reportError(re); | ||
10364 | recover(input,re); | ||
10365 | } | ||
10366 | finally { | ||
10367 | |||
10368 | restoreStackSize(stackSize); | ||
10369 | |||
10370 | } | ||
10371 | return ; | ||
10372 | } | ||
10373 | // $ANTLR end "rule__ALSRelationDefinition__Group_4__0__Impl" | ||
10374 | |||
10375 | |||
10376 | // $ANTLR start "rule__ALSRelationDefinition__Group_4__1" | ||
10377 | // InternalAlloyLanguage.g:3417:1: rule__ALSRelationDefinition__Group_4__1 : rule__ALSRelationDefinition__Group_4__1__Impl ; | ||
10378 | public final void rule__ALSRelationDefinition__Group_4__1() throws RecognitionException { | ||
10379 | |||
10380 | int stackSize = keepStackSize(); | ||
10381 | |||
10382 | try { | ||
10383 | // InternalAlloyLanguage.g:3421:1: ( rule__ALSRelationDefinition__Group_4__1__Impl ) | ||
10384 | // InternalAlloyLanguage.g:3422:2: rule__ALSRelationDefinition__Group_4__1__Impl | ||
10385 | { | ||
10386 | pushFollow(FOLLOW_2); | ||
10387 | rule__ALSRelationDefinition__Group_4__1__Impl(); | ||
10388 | |||
10389 | state._fsp--; | ||
10390 | if (state.failed) return ; | ||
10391 | |||
10392 | } | ||
10393 | |||
10394 | } | ||
10395 | catch (RecognitionException re) { | ||
10396 | reportError(re); | ||
10397 | recover(input,re); | ||
10398 | } | ||
10399 | finally { | ||
10400 | |||
10401 | restoreStackSize(stackSize); | ||
10402 | |||
10403 | } | ||
10404 | return ; | ||
10405 | } | ||
10406 | // $ANTLR end "rule__ALSRelationDefinition__Group_4__1" | ||
10407 | |||
10408 | |||
10409 | // $ANTLR start "rule__ALSRelationDefinition__Group_4__1__Impl" | ||
10410 | // InternalAlloyLanguage.g:3428:1: rule__ALSRelationDefinition__Group_4__1__Impl : ( ( rule__ALSRelationDefinition__VariablesAssignment_4_1 ) ) ; | ||
10411 | public final void rule__ALSRelationDefinition__Group_4__1__Impl() throws RecognitionException { | ||
10412 | |||
10413 | int stackSize = keepStackSize(); | ||
10414 | |||
10415 | try { | ||
10416 | // InternalAlloyLanguage.g:3432:1: ( ( ( rule__ALSRelationDefinition__VariablesAssignment_4_1 ) ) ) | ||
10417 | // InternalAlloyLanguage.g:3433:1: ( ( rule__ALSRelationDefinition__VariablesAssignment_4_1 ) ) | ||
10418 | { | ||
10419 | // InternalAlloyLanguage.g:3433:1: ( ( rule__ALSRelationDefinition__VariablesAssignment_4_1 ) ) | ||
10420 | // InternalAlloyLanguage.g:3434:1: ( rule__ALSRelationDefinition__VariablesAssignment_4_1 ) | ||
10421 | { | ||
10422 | if ( state.backtracking==0 ) { | ||
10423 | before(grammarAccess.getALSRelationDefinitionAccess().getVariablesAssignment_4_1()); | ||
10424 | } | ||
10425 | // InternalAlloyLanguage.g:3435:1: ( rule__ALSRelationDefinition__VariablesAssignment_4_1 ) | ||
10426 | // InternalAlloyLanguage.g:3435:2: rule__ALSRelationDefinition__VariablesAssignment_4_1 | ||
10427 | { | ||
10428 | pushFollow(FOLLOW_2); | ||
10429 | rule__ALSRelationDefinition__VariablesAssignment_4_1(); | ||
10430 | |||
10431 | state._fsp--; | ||
10432 | if (state.failed) return ; | ||
10433 | |||
10434 | } | ||
10435 | |||
10436 | if ( state.backtracking==0 ) { | ||
10437 | after(grammarAccess.getALSRelationDefinitionAccess().getVariablesAssignment_4_1()); | ||
10438 | } | ||
10439 | |||
10440 | } | ||
10441 | |||
10442 | |||
10443 | } | ||
10444 | |||
10445 | } | ||
10446 | catch (RecognitionException re) { | ||
10447 | reportError(re); | ||
10448 | recover(input,re); | ||
10449 | } | ||
10450 | finally { | ||
10451 | |||
10452 | restoreStackSize(stackSize); | ||
10453 | |||
10454 | } | ||
10455 | return ; | ||
10456 | } | ||
10457 | // $ANTLR end "rule__ALSRelationDefinition__Group_4__1__Impl" | ||
10458 | |||
10459 | |||
10460 | // $ANTLR start "rule__ALSFactDeclaration__Group__0" | ||
10461 | // InternalAlloyLanguage.g:3449:1: rule__ALSFactDeclaration__Group__0 : rule__ALSFactDeclaration__Group__0__Impl rule__ALSFactDeclaration__Group__1 ; | ||
10462 | public final void rule__ALSFactDeclaration__Group__0() throws RecognitionException { | ||
10463 | |||
10464 | int stackSize = keepStackSize(); | ||
10465 | |||
10466 | try { | ||
10467 | // InternalAlloyLanguage.g:3453:1: ( rule__ALSFactDeclaration__Group__0__Impl rule__ALSFactDeclaration__Group__1 ) | ||
10468 | // InternalAlloyLanguage.g:3454:2: rule__ALSFactDeclaration__Group__0__Impl rule__ALSFactDeclaration__Group__1 | ||
10469 | { | ||
10470 | pushFollow(FOLLOW_20); | ||
10471 | rule__ALSFactDeclaration__Group__0__Impl(); | ||
10472 | |||
10473 | state._fsp--; | ||
10474 | if (state.failed) return ; | ||
10475 | pushFollow(FOLLOW_2); | ||
10476 | rule__ALSFactDeclaration__Group__1(); | ||
10477 | |||
10478 | state._fsp--; | ||
10479 | if (state.failed) return ; | ||
10480 | |||
10481 | } | ||
10482 | |||
10483 | } | ||
10484 | catch (RecognitionException re) { | ||
10485 | reportError(re); | ||
10486 | recover(input,re); | ||
10487 | } | ||
10488 | finally { | ||
10489 | |||
10490 | restoreStackSize(stackSize); | ||
10491 | |||
10492 | } | ||
10493 | return ; | ||
10494 | } | ||
10495 | // $ANTLR end "rule__ALSFactDeclaration__Group__0" | ||
10496 | |||
10497 | |||
10498 | // $ANTLR start "rule__ALSFactDeclaration__Group__0__Impl" | ||
10499 | // InternalAlloyLanguage.g:3461:1: rule__ALSFactDeclaration__Group__0__Impl : ( () ) ; | ||
10500 | public final void rule__ALSFactDeclaration__Group__0__Impl() throws RecognitionException { | ||
10501 | |||
10502 | int stackSize = keepStackSize(); | ||
10503 | |||
10504 | try { | ||
10505 | // InternalAlloyLanguage.g:3465:1: ( ( () ) ) | ||
10506 | // InternalAlloyLanguage.g:3466:1: ( () ) | ||
10507 | { | ||
10508 | // InternalAlloyLanguage.g:3466:1: ( () ) | ||
10509 | // InternalAlloyLanguage.g:3467:1: () | ||
10510 | { | ||
10511 | if ( state.backtracking==0 ) { | ||
10512 | before(grammarAccess.getALSFactDeclarationAccess().getALSFactDeclarationAction_0()); | ||
10513 | } | ||
10514 | // InternalAlloyLanguage.g:3468:1: () | ||
10515 | // InternalAlloyLanguage.g:3470:1: | ||
10516 | { | ||
10517 | } | ||
10518 | |||
10519 | if ( state.backtracking==0 ) { | ||
10520 | after(grammarAccess.getALSFactDeclarationAccess().getALSFactDeclarationAction_0()); | ||
10521 | } | ||
10522 | |||
10523 | } | ||
10524 | |||
10525 | |||
10526 | } | ||
10527 | |||
10528 | } | ||
10529 | finally { | ||
10530 | |||
10531 | restoreStackSize(stackSize); | ||
10532 | |||
10533 | } | ||
10534 | return ; | ||
10535 | } | ||
10536 | // $ANTLR end "rule__ALSFactDeclaration__Group__0__Impl" | ||
10537 | |||
10538 | |||
10539 | // $ANTLR start "rule__ALSFactDeclaration__Group__1" | ||
10540 | // InternalAlloyLanguage.g:3480:1: rule__ALSFactDeclaration__Group__1 : rule__ALSFactDeclaration__Group__1__Impl rule__ALSFactDeclaration__Group__2 ; | ||
10541 | public final void rule__ALSFactDeclaration__Group__1() throws RecognitionException { | ||
10542 | |||
10543 | int stackSize = keepStackSize(); | ||
10544 | |||
10545 | try { | ||
10546 | // InternalAlloyLanguage.g:3484:1: ( rule__ALSFactDeclaration__Group__1__Impl rule__ALSFactDeclaration__Group__2 ) | ||
10547 | // InternalAlloyLanguage.g:3485:2: rule__ALSFactDeclaration__Group__1__Impl rule__ALSFactDeclaration__Group__2 | ||
10548 | { | ||
10549 | pushFollow(FOLLOW_21); | ||
10550 | rule__ALSFactDeclaration__Group__1__Impl(); | ||
10551 | |||
10552 | state._fsp--; | ||
10553 | if (state.failed) return ; | ||
10554 | pushFollow(FOLLOW_2); | ||
10555 | rule__ALSFactDeclaration__Group__2(); | ||
10556 | |||
10557 | state._fsp--; | ||
10558 | if (state.failed) return ; | ||
10559 | |||
10560 | } | ||
10561 | |||
10562 | } | ||
10563 | catch (RecognitionException re) { | ||
10564 | reportError(re); | ||
10565 | recover(input,re); | ||
10566 | } | ||
10567 | finally { | ||
10568 | |||
10569 | restoreStackSize(stackSize); | ||
10570 | |||
10571 | } | ||
10572 | return ; | ||
10573 | } | ||
10574 | // $ANTLR end "rule__ALSFactDeclaration__Group__1" | ||
10575 | |||
10576 | |||
10577 | // $ANTLR start "rule__ALSFactDeclaration__Group__1__Impl" | ||
10578 | // InternalAlloyLanguage.g:3492:1: rule__ALSFactDeclaration__Group__1__Impl : ( 'fact' ) ; | ||
10579 | public final void rule__ALSFactDeclaration__Group__1__Impl() throws RecognitionException { | ||
10580 | |||
10581 | int stackSize = keepStackSize(); | ||
10582 | |||
10583 | try { | ||
10584 | // InternalAlloyLanguage.g:3496:1: ( ( 'fact' ) ) | ||
10585 | // InternalAlloyLanguage.g:3497:1: ( 'fact' ) | ||
10586 | { | ||
10587 | // InternalAlloyLanguage.g:3497:1: ( 'fact' ) | ||
10588 | // InternalAlloyLanguage.g:3498:1: 'fact' | ||
10589 | { | ||
10590 | if ( state.backtracking==0 ) { | ||
10591 | before(grammarAccess.getALSFactDeclarationAccess().getFactKeyword_1()); | ||
10592 | } | ||
10593 | match(input,45,FOLLOW_2); if (state.failed) return ; | ||
10594 | if ( state.backtracking==0 ) { | ||
10595 | after(grammarAccess.getALSFactDeclarationAccess().getFactKeyword_1()); | ||
10596 | } | ||
10597 | |||
10598 | } | ||
10599 | |||
10600 | |||
10601 | } | ||
10602 | |||
10603 | } | ||
10604 | catch (RecognitionException re) { | ||
10605 | reportError(re); | ||
10606 | recover(input,re); | ||
10607 | } | ||
10608 | finally { | ||
10609 | |||
10610 | restoreStackSize(stackSize); | ||
10611 | |||
10612 | } | ||
10613 | return ; | ||
10614 | } | ||
10615 | // $ANTLR end "rule__ALSFactDeclaration__Group__1__Impl" | ||
10616 | |||
10617 | |||
10618 | // $ANTLR start "rule__ALSFactDeclaration__Group__2" | ||
10619 | // InternalAlloyLanguage.g:3511:1: rule__ALSFactDeclaration__Group__2 : rule__ALSFactDeclaration__Group__2__Impl rule__ALSFactDeclaration__Group__3 ; | ||
10620 | public final void rule__ALSFactDeclaration__Group__2() throws RecognitionException { | ||
10621 | |||
10622 | int stackSize = keepStackSize(); | ||
10623 | |||
10624 | try { | ||
10625 | // InternalAlloyLanguage.g:3515:1: ( rule__ALSFactDeclaration__Group__2__Impl rule__ALSFactDeclaration__Group__3 ) | ||
10626 | // InternalAlloyLanguage.g:3516:2: rule__ALSFactDeclaration__Group__2__Impl rule__ALSFactDeclaration__Group__3 | ||
10627 | { | ||
10628 | pushFollow(FOLLOW_21); | ||
10629 | rule__ALSFactDeclaration__Group__2__Impl(); | ||
10630 | |||
10631 | state._fsp--; | ||
10632 | if (state.failed) return ; | ||
10633 | pushFollow(FOLLOW_2); | ||
10634 | rule__ALSFactDeclaration__Group__3(); | ||
10635 | |||
10636 | state._fsp--; | ||
10637 | if (state.failed) return ; | ||
10638 | |||
10639 | } | ||
10640 | |||
10641 | } | ||
10642 | catch (RecognitionException re) { | ||
10643 | reportError(re); | ||
10644 | recover(input,re); | ||
10645 | } | ||
10646 | finally { | ||
10647 | |||
10648 | restoreStackSize(stackSize); | ||
10649 | |||
10650 | } | ||
10651 | return ; | ||
10652 | } | ||
10653 | // $ANTLR end "rule__ALSFactDeclaration__Group__2" | ||
10654 | |||
10655 | |||
10656 | // $ANTLR start "rule__ALSFactDeclaration__Group__2__Impl" | ||
10657 | // InternalAlloyLanguage.g:3523:1: rule__ALSFactDeclaration__Group__2__Impl : ( ( rule__ALSFactDeclaration__NameAssignment_2 )? ) ; | ||
10658 | public final void rule__ALSFactDeclaration__Group__2__Impl() throws RecognitionException { | ||
10659 | |||
10660 | int stackSize = keepStackSize(); | ||
10661 | |||
10662 | try { | ||
10663 | // InternalAlloyLanguage.g:3527:1: ( ( ( rule__ALSFactDeclaration__NameAssignment_2 )? ) ) | ||
10664 | // InternalAlloyLanguage.g:3528:1: ( ( rule__ALSFactDeclaration__NameAssignment_2 )? ) | ||
10665 | { | ||
10666 | // InternalAlloyLanguage.g:3528:1: ( ( rule__ALSFactDeclaration__NameAssignment_2 )? ) | ||
10667 | // InternalAlloyLanguage.g:3529:1: ( rule__ALSFactDeclaration__NameAssignment_2 )? | ||
10668 | { | ||
10669 | if ( state.backtracking==0 ) { | ||
10670 | before(grammarAccess.getALSFactDeclarationAccess().getNameAssignment_2()); | ||
10671 | } | ||
10672 | // InternalAlloyLanguage.g:3530:1: ( rule__ALSFactDeclaration__NameAssignment_2 )? | ||
10673 | int alt27=2; | ||
10674 | int LA27_0 = input.LA(1); | ||
10675 | |||
10676 | if ( (LA27_0==RULE_ID) ) { | ||
10677 | alt27=1; | ||
10678 | } | ||
10679 | switch (alt27) { | ||
10680 | case 1 : | ||
10681 | // InternalAlloyLanguage.g:3530:2: rule__ALSFactDeclaration__NameAssignment_2 | ||
10682 | { | ||
10683 | pushFollow(FOLLOW_2); | ||
10684 | rule__ALSFactDeclaration__NameAssignment_2(); | ||
10685 | |||
10686 | state._fsp--; | ||
10687 | if (state.failed) return ; | ||
10688 | |||
10689 | } | ||
10690 | break; | ||
10691 | |||
10692 | } | ||
10693 | |||
10694 | if ( state.backtracking==0 ) { | ||
10695 | after(grammarAccess.getALSFactDeclarationAccess().getNameAssignment_2()); | ||
10696 | } | ||
10697 | |||
10698 | } | ||
10699 | |||
10700 | |||
10701 | } | ||
10702 | |||
10703 | } | ||
10704 | catch (RecognitionException re) { | ||
10705 | reportError(re); | ||
10706 | recover(input,re); | ||
10707 | } | ||
10708 | finally { | ||
10709 | |||
10710 | restoreStackSize(stackSize); | ||
10711 | |||
10712 | } | ||
10713 | return ; | ||
10714 | } | ||
10715 | // $ANTLR end "rule__ALSFactDeclaration__Group__2__Impl" | ||
10716 | |||
10717 | |||
10718 | // $ANTLR start "rule__ALSFactDeclaration__Group__3" | ||
10719 | // InternalAlloyLanguage.g:3540:1: rule__ALSFactDeclaration__Group__3 : rule__ALSFactDeclaration__Group__3__Impl rule__ALSFactDeclaration__Group__4 ; | ||
10720 | public final void rule__ALSFactDeclaration__Group__3() throws RecognitionException { | ||
10721 | |||
10722 | int stackSize = keepStackSize(); | ||
10723 | |||
10724 | try { | ||
10725 | // InternalAlloyLanguage.g:3544:1: ( rule__ALSFactDeclaration__Group__3__Impl rule__ALSFactDeclaration__Group__4 ) | ||
10726 | // InternalAlloyLanguage.g:3545:2: rule__ALSFactDeclaration__Group__3__Impl rule__ALSFactDeclaration__Group__4 | ||
10727 | { | ||
10728 | pushFollow(FOLLOW_16); | ||
10729 | rule__ALSFactDeclaration__Group__3__Impl(); | ||
10730 | |||
10731 | state._fsp--; | ||
10732 | if (state.failed) return ; | ||
10733 | pushFollow(FOLLOW_2); | ||
10734 | rule__ALSFactDeclaration__Group__4(); | ||
10735 | |||
10736 | state._fsp--; | ||
10737 | if (state.failed) return ; | ||
10738 | |||
10739 | } | ||
10740 | |||
10741 | } | ||
10742 | catch (RecognitionException re) { | ||
10743 | reportError(re); | ||
10744 | recover(input,re); | ||
10745 | } | ||
10746 | finally { | ||
10747 | |||
10748 | restoreStackSize(stackSize); | ||
10749 | |||
10750 | } | ||
10751 | return ; | ||
10752 | } | ||
10753 | // $ANTLR end "rule__ALSFactDeclaration__Group__3" | ||
10754 | |||
10755 | |||
10756 | // $ANTLR start "rule__ALSFactDeclaration__Group__3__Impl" | ||
10757 | // InternalAlloyLanguage.g:3552:1: rule__ALSFactDeclaration__Group__3__Impl : ( '{' ) ; | ||
10758 | public final void rule__ALSFactDeclaration__Group__3__Impl() throws RecognitionException { | ||
10759 | |||
10760 | int stackSize = keepStackSize(); | ||
10761 | |||
10762 | try { | ||
10763 | // InternalAlloyLanguage.g:3556:1: ( ( '{' ) ) | ||
10764 | // InternalAlloyLanguage.g:3557:1: ( '{' ) | ||
10765 | { | ||
10766 | // InternalAlloyLanguage.g:3557:1: ( '{' ) | ||
10767 | // InternalAlloyLanguage.g:3558:1: '{' | ||
10768 | { | ||
10769 | if ( state.backtracking==0 ) { | ||
10770 | before(grammarAccess.getALSFactDeclarationAccess().getLeftCurlyBracketKeyword_3()); | ||
10771 | } | ||
10772 | match(input,33,FOLLOW_2); if (state.failed) return ; | ||
10773 | if ( state.backtracking==0 ) { | ||
10774 | after(grammarAccess.getALSFactDeclarationAccess().getLeftCurlyBracketKeyword_3()); | ||
10775 | } | ||
10776 | |||
10777 | } | ||
10778 | |||
10779 | |||
10780 | } | ||
10781 | |||
10782 | } | ||
10783 | catch (RecognitionException re) { | ||
10784 | reportError(re); | ||
10785 | recover(input,re); | ||
10786 | } | ||
10787 | finally { | ||
10788 | |||
10789 | restoreStackSize(stackSize); | ||
10790 | |||
10791 | } | ||
10792 | return ; | ||
10793 | } | ||
10794 | // $ANTLR end "rule__ALSFactDeclaration__Group__3__Impl" | ||
10795 | |||
10796 | |||
10797 | // $ANTLR start "rule__ALSFactDeclaration__Group__4" | ||
10798 | // InternalAlloyLanguage.g:3571:1: rule__ALSFactDeclaration__Group__4 : rule__ALSFactDeclaration__Group__4__Impl rule__ALSFactDeclaration__Group__5 ; | ||
10799 | public final void rule__ALSFactDeclaration__Group__4() throws RecognitionException { | ||
10800 | |||
10801 | int stackSize = keepStackSize(); | ||
10802 | |||
10803 | try { | ||
10804 | // InternalAlloyLanguage.g:3575:1: ( rule__ALSFactDeclaration__Group__4__Impl rule__ALSFactDeclaration__Group__5 ) | ||
10805 | // InternalAlloyLanguage.g:3576:2: rule__ALSFactDeclaration__Group__4__Impl rule__ALSFactDeclaration__Group__5 | ||
10806 | { | ||
10807 | pushFollow(FOLLOW_19); | ||
10808 | rule__ALSFactDeclaration__Group__4__Impl(); | ||
10809 | |||
10810 | state._fsp--; | ||
10811 | if (state.failed) return ; | ||
10812 | pushFollow(FOLLOW_2); | ||
10813 | rule__ALSFactDeclaration__Group__5(); | ||
10814 | |||
10815 | state._fsp--; | ||
10816 | if (state.failed) return ; | ||
10817 | |||
10818 | } | ||
10819 | |||
10820 | } | ||
10821 | catch (RecognitionException re) { | ||
10822 | reportError(re); | ||
10823 | recover(input,re); | ||
10824 | } | ||
10825 | finally { | ||
10826 | |||
10827 | restoreStackSize(stackSize); | ||
10828 | |||
10829 | } | ||
10830 | return ; | ||
10831 | } | ||
10832 | // $ANTLR end "rule__ALSFactDeclaration__Group__4" | ||
10833 | |||
10834 | |||
10835 | // $ANTLR start "rule__ALSFactDeclaration__Group__4__Impl" | ||
10836 | // InternalAlloyLanguage.g:3583:1: rule__ALSFactDeclaration__Group__4__Impl : ( ( rule__ALSFactDeclaration__TermAssignment_4 ) ) ; | ||
10837 | public final void rule__ALSFactDeclaration__Group__4__Impl() throws RecognitionException { | ||
10838 | |||
10839 | int stackSize = keepStackSize(); | ||
10840 | |||
10841 | try { | ||
10842 | // InternalAlloyLanguage.g:3587:1: ( ( ( rule__ALSFactDeclaration__TermAssignment_4 ) ) ) | ||
10843 | // InternalAlloyLanguage.g:3588:1: ( ( rule__ALSFactDeclaration__TermAssignment_4 ) ) | ||
10844 | { | ||
10845 | // InternalAlloyLanguage.g:3588:1: ( ( rule__ALSFactDeclaration__TermAssignment_4 ) ) | ||
10846 | // InternalAlloyLanguage.g:3589:1: ( rule__ALSFactDeclaration__TermAssignment_4 ) | ||
10847 | { | ||
10848 | if ( state.backtracking==0 ) { | ||
10849 | before(grammarAccess.getALSFactDeclarationAccess().getTermAssignment_4()); | ||
10850 | } | ||
10851 | // InternalAlloyLanguage.g:3590:1: ( rule__ALSFactDeclaration__TermAssignment_4 ) | ||
10852 | // InternalAlloyLanguage.g:3590:2: rule__ALSFactDeclaration__TermAssignment_4 | ||
10853 | { | ||
10854 | pushFollow(FOLLOW_2); | ||
10855 | rule__ALSFactDeclaration__TermAssignment_4(); | ||
10856 | |||
10857 | state._fsp--; | ||
10858 | if (state.failed) return ; | ||
10859 | |||
10860 | } | ||
10861 | |||
10862 | if ( state.backtracking==0 ) { | ||
10863 | after(grammarAccess.getALSFactDeclarationAccess().getTermAssignment_4()); | ||
10864 | } | ||
10865 | |||
10866 | } | ||
10867 | |||
10868 | |||
10869 | } | ||
10870 | |||
10871 | } | ||
10872 | catch (RecognitionException re) { | ||
10873 | reportError(re); | ||
10874 | recover(input,re); | ||
10875 | } | ||
10876 | finally { | ||
10877 | |||
10878 | restoreStackSize(stackSize); | ||
10879 | |||
10880 | } | ||
10881 | return ; | ||
10882 | } | ||
10883 | // $ANTLR end "rule__ALSFactDeclaration__Group__4__Impl" | ||
10884 | |||
10885 | |||
10886 | // $ANTLR start "rule__ALSFactDeclaration__Group__5" | ||
10887 | // InternalAlloyLanguage.g:3600:1: rule__ALSFactDeclaration__Group__5 : rule__ALSFactDeclaration__Group__5__Impl ; | ||
10888 | public final void rule__ALSFactDeclaration__Group__5() throws RecognitionException { | ||
10889 | |||
10890 | int stackSize = keepStackSize(); | ||
10891 | |||
10892 | try { | ||
10893 | // InternalAlloyLanguage.g:3604:1: ( rule__ALSFactDeclaration__Group__5__Impl ) | ||
10894 | // InternalAlloyLanguage.g:3605:2: rule__ALSFactDeclaration__Group__5__Impl | ||
10895 | { | ||
10896 | pushFollow(FOLLOW_2); | ||
10897 | rule__ALSFactDeclaration__Group__5__Impl(); | ||
10898 | |||
10899 | state._fsp--; | ||
10900 | if (state.failed) return ; | ||
10901 | |||
10902 | } | ||
10903 | |||
10904 | } | ||
10905 | catch (RecognitionException re) { | ||
10906 | reportError(re); | ||
10907 | recover(input,re); | ||
10908 | } | ||
10909 | finally { | ||
10910 | |||
10911 | restoreStackSize(stackSize); | ||
10912 | |||
10913 | } | ||
10914 | return ; | ||
10915 | } | ||
10916 | // $ANTLR end "rule__ALSFactDeclaration__Group__5" | ||
10917 | |||
10918 | |||
10919 | // $ANTLR start "rule__ALSFactDeclaration__Group__5__Impl" | ||
10920 | // InternalAlloyLanguage.g:3611:1: rule__ALSFactDeclaration__Group__5__Impl : ( '}' ) ; | ||
10921 | public final void rule__ALSFactDeclaration__Group__5__Impl() throws RecognitionException { | ||
10922 | |||
10923 | int stackSize = keepStackSize(); | ||
10924 | |||
10925 | try { | ||
10926 | // InternalAlloyLanguage.g:3615:1: ( ( '}' ) ) | ||
10927 | // InternalAlloyLanguage.g:3616:1: ( '}' ) | ||
10928 | { | ||
10929 | // InternalAlloyLanguage.g:3616:1: ( '}' ) | ||
10930 | // InternalAlloyLanguage.g:3617:1: '}' | ||
10931 | { | ||
10932 | if ( state.backtracking==0 ) { | ||
10933 | before(grammarAccess.getALSFactDeclarationAccess().getRightCurlyBracketKeyword_5()); | ||
10934 | } | ||
10935 | match(input,34,FOLLOW_2); if (state.failed) return ; | ||
10936 | if ( state.backtracking==0 ) { | ||
10937 | after(grammarAccess.getALSFactDeclarationAccess().getRightCurlyBracketKeyword_5()); | ||
10938 | } | ||
10939 | |||
10940 | } | ||
10941 | |||
10942 | |||
10943 | } | ||
10944 | |||
10945 | } | ||
10946 | catch (RecognitionException re) { | ||
10947 | reportError(re); | ||
10948 | recover(input,re); | ||
10949 | } | ||
10950 | finally { | ||
10951 | |||
10952 | restoreStackSize(stackSize); | ||
10953 | |||
10954 | } | ||
10955 | return ; | ||
10956 | } | ||
10957 | // $ANTLR end "rule__ALSFactDeclaration__Group__5__Impl" | ||
10958 | |||
10959 | |||
10960 | // $ANTLR start "rule__ALSQuantified__Group_0__0" | ||
10961 | // InternalAlloyLanguage.g:3642:1: rule__ALSQuantified__Group_0__0 : rule__ALSQuantified__Group_0__0__Impl rule__ALSQuantified__Group_0__1 ; | ||
10962 | public final void rule__ALSQuantified__Group_0__0() throws RecognitionException { | ||
10963 | |||
10964 | int stackSize = keepStackSize(); | ||
10965 | |||
10966 | try { | ||
10967 | // InternalAlloyLanguage.g:3646:1: ( rule__ALSQuantified__Group_0__0__Impl rule__ALSQuantified__Group_0__1 ) | ||
10968 | // InternalAlloyLanguage.g:3647:2: rule__ALSQuantified__Group_0__0__Impl rule__ALSQuantified__Group_0__1 | ||
10969 | { | ||
10970 | pushFollow(FOLLOW_22); | ||
10971 | rule__ALSQuantified__Group_0__0__Impl(); | ||
10972 | |||
10973 | state._fsp--; | ||
10974 | if (state.failed) return ; | ||
10975 | pushFollow(FOLLOW_2); | ||
10976 | rule__ALSQuantified__Group_0__1(); | ||
10977 | |||
10978 | state._fsp--; | ||
10979 | if (state.failed) return ; | ||
10980 | |||
10981 | } | ||
10982 | |||
10983 | } | ||
10984 | catch (RecognitionException re) { | ||
10985 | reportError(re); | ||
10986 | recover(input,re); | ||
10987 | } | ||
10988 | finally { | ||
10989 | |||
10990 | restoreStackSize(stackSize); | ||
10991 | |||
10992 | } | ||
10993 | return ; | ||
10994 | } | ||
10995 | // $ANTLR end "rule__ALSQuantified__Group_0__0" | ||
10996 | |||
10997 | |||
10998 | // $ANTLR start "rule__ALSQuantified__Group_0__0__Impl" | ||
10999 | // InternalAlloyLanguage.g:3654:1: rule__ALSQuantified__Group_0__0__Impl : ( () ) ; | ||
11000 | public final void rule__ALSQuantified__Group_0__0__Impl() throws RecognitionException { | ||
11001 | |||
11002 | int stackSize = keepStackSize(); | ||
11003 | |||
11004 | try { | ||
11005 | // InternalAlloyLanguage.g:3658:1: ( ( () ) ) | ||
11006 | // InternalAlloyLanguage.g:3659:1: ( () ) | ||
11007 | { | ||
11008 | // InternalAlloyLanguage.g:3659:1: ( () ) | ||
11009 | // InternalAlloyLanguage.g:3660:1: () | ||
11010 | { | ||
11011 | if ( state.backtracking==0 ) { | ||
11012 | before(grammarAccess.getALSQuantifiedAccess().getALSQuantifiedExAction_0_0()); | ||
11013 | } | ||
11014 | // InternalAlloyLanguage.g:3661:1: () | ||
11015 | // InternalAlloyLanguage.g:3663:1: | ||
11016 | { | ||
11017 | } | ||
11018 | |||
11019 | if ( state.backtracking==0 ) { | ||
11020 | after(grammarAccess.getALSQuantifiedAccess().getALSQuantifiedExAction_0_0()); | ||
11021 | } | ||
11022 | |||
11023 | } | ||
11024 | |||
11025 | |||
11026 | } | ||
11027 | |||
11028 | } | ||
11029 | finally { | ||
11030 | |||
11031 | restoreStackSize(stackSize); | ||
11032 | |||
11033 | } | ||
11034 | return ; | ||
11035 | } | ||
11036 | // $ANTLR end "rule__ALSQuantified__Group_0__0__Impl" | ||
11037 | |||
11038 | |||
11039 | // $ANTLR start "rule__ALSQuantified__Group_0__1" | ||
11040 | // InternalAlloyLanguage.g:3673:1: rule__ALSQuantified__Group_0__1 : rule__ALSQuantified__Group_0__1__Impl rule__ALSQuantified__Group_0__2 ; | ||
11041 | public final void rule__ALSQuantified__Group_0__1() throws RecognitionException { | ||
11042 | |||
11043 | int stackSize = keepStackSize(); | ||
11044 | |||
11045 | try { | ||
11046 | // InternalAlloyLanguage.g:3677:1: ( rule__ALSQuantified__Group_0__1__Impl rule__ALSQuantified__Group_0__2 ) | ||
11047 | // InternalAlloyLanguage.g:3678:2: rule__ALSQuantified__Group_0__1__Impl rule__ALSQuantified__Group_0__2 | ||
11048 | { | ||
11049 | pushFollow(FOLLOW_23); | ||
11050 | rule__ALSQuantified__Group_0__1__Impl(); | ||
11051 | |||
11052 | state._fsp--; | ||
11053 | if (state.failed) return ; | ||
11054 | pushFollow(FOLLOW_2); | ||
11055 | rule__ALSQuantified__Group_0__2(); | ||
11056 | |||
11057 | state._fsp--; | ||
11058 | if (state.failed) return ; | ||
11059 | |||
11060 | } | ||
11061 | |||
11062 | } | ||
11063 | catch (RecognitionException re) { | ||
11064 | reportError(re); | ||
11065 | recover(input,re); | ||
11066 | } | ||
11067 | finally { | ||
11068 | |||
11069 | restoreStackSize(stackSize); | ||
11070 | |||
11071 | } | ||
11072 | return ; | ||
11073 | } | ||
11074 | // $ANTLR end "rule__ALSQuantified__Group_0__1" | ||
11075 | |||
11076 | |||
11077 | // $ANTLR start "rule__ALSQuantified__Group_0__1__Impl" | ||
11078 | // InternalAlloyLanguage.g:3685:1: rule__ALSQuantified__Group_0__1__Impl : ( ( rule__ALSQuantified__TypeAssignment_0_1 ) ) ; | ||
11079 | public final void rule__ALSQuantified__Group_0__1__Impl() throws RecognitionException { | ||
11080 | |||
11081 | int stackSize = keepStackSize(); | ||
11082 | |||
11083 | try { | ||
11084 | // InternalAlloyLanguage.g:3689:1: ( ( ( rule__ALSQuantified__TypeAssignment_0_1 ) ) ) | ||
11085 | // InternalAlloyLanguage.g:3690:1: ( ( rule__ALSQuantified__TypeAssignment_0_1 ) ) | ||
11086 | { | ||
11087 | // InternalAlloyLanguage.g:3690:1: ( ( rule__ALSQuantified__TypeAssignment_0_1 ) ) | ||
11088 | // InternalAlloyLanguage.g:3691:1: ( rule__ALSQuantified__TypeAssignment_0_1 ) | ||
11089 | { | ||
11090 | if ( state.backtracking==0 ) { | ||
11091 | before(grammarAccess.getALSQuantifiedAccess().getTypeAssignment_0_1()); | ||
11092 | } | ||
11093 | // InternalAlloyLanguage.g:3692:1: ( rule__ALSQuantified__TypeAssignment_0_1 ) | ||
11094 | // InternalAlloyLanguage.g:3692:2: rule__ALSQuantified__TypeAssignment_0_1 | ||
11095 | { | ||
11096 | pushFollow(FOLLOW_2); | ||
11097 | rule__ALSQuantified__TypeAssignment_0_1(); | ||
11098 | |||
11099 | state._fsp--; | ||
11100 | if (state.failed) return ; | ||
11101 | |||
11102 | } | ||
11103 | |||
11104 | if ( state.backtracking==0 ) { | ||
11105 | after(grammarAccess.getALSQuantifiedAccess().getTypeAssignment_0_1()); | ||
11106 | } | ||
11107 | |||
11108 | } | ||
11109 | |||
11110 | |||
11111 | } | ||
11112 | |||
11113 | } | ||
11114 | catch (RecognitionException re) { | ||
11115 | reportError(re); | ||
11116 | recover(input,re); | ||
11117 | } | ||
11118 | finally { | ||
11119 | |||
11120 | restoreStackSize(stackSize); | ||
11121 | |||
11122 | } | ||
11123 | return ; | ||
11124 | } | ||
11125 | // $ANTLR end "rule__ALSQuantified__Group_0__1__Impl" | ||
11126 | |||
11127 | |||
11128 | // $ANTLR start "rule__ALSQuantified__Group_0__2" | ||
11129 | // InternalAlloyLanguage.g:3702:1: rule__ALSQuantified__Group_0__2 : rule__ALSQuantified__Group_0__2__Impl rule__ALSQuantified__Group_0__3 ; | ||
11130 | public final void rule__ALSQuantified__Group_0__2() throws RecognitionException { | ||
11131 | |||
11132 | int stackSize = keepStackSize(); | ||
11133 | |||
11134 | try { | ||
11135 | // InternalAlloyLanguage.g:3706:1: ( rule__ALSQuantified__Group_0__2__Impl rule__ALSQuantified__Group_0__3 ) | ||
11136 | // InternalAlloyLanguage.g:3707:2: rule__ALSQuantified__Group_0__2__Impl rule__ALSQuantified__Group_0__3 | ||
11137 | { | ||
11138 | pushFollow(FOLLOW_23); | ||
11139 | rule__ALSQuantified__Group_0__2__Impl(); | ||
11140 | |||
11141 | state._fsp--; | ||
11142 | if (state.failed) return ; | ||
11143 | pushFollow(FOLLOW_2); | ||
11144 | rule__ALSQuantified__Group_0__3(); | ||
11145 | |||
11146 | state._fsp--; | ||
11147 | if (state.failed) return ; | ||
11148 | |||
11149 | } | ||
11150 | |||
11151 | } | ||
11152 | catch (RecognitionException re) { | ||
11153 | reportError(re); | ||
11154 | recover(input,re); | ||
11155 | } | ||
11156 | finally { | ||
11157 | |||
11158 | restoreStackSize(stackSize); | ||
11159 | |||
11160 | } | ||
11161 | return ; | ||
11162 | } | ||
11163 | // $ANTLR end "rule__ALSQuantified__Group_0__2" | ||
11164 | |||
11165 | |||
11166 | // $ANTLR start "rule__ALSQuantified__Group_0__2__Impl" | ||
11167 | // InternalAlloyLanguage.g:3714:1: rule__ALSQuantified__Group_0__2__Impl : ( ( rule__ALSQuantified__DisjAssignment_0_2 )? ) ; | ||
11168 | public final void rule__ALSQuantified__Group_0__2__Impl() throws RecognitionException { | ||
11169 | |||
11170 | int stackSize = keepStackSize(); | ||
11171 | |||
11172 | try { | ||
11173 | // InternalAlloyLanguage.g:3718:1: ( ( ( rule__ALSQuantified__DisjAssignment_0_2 )? ) ) | ||
11174 | // InternalAlloyLanguage.g:3719:1: ( ( rule__ALSQuantified__DisjAssignment_0_2 )? ) | ||
11175 | { | ||
11176 | // InternalAlloyLanguage.g:3719:1: ( ( rule__ALSQuantified__DisjAssignment_0_2 )? ) | ||
11177 | // InternalAlloyLanguage.g:3720:1: ( rule__ALSQuantified__DisjAssignment_0_2 )? | ||
11178 | { | ||
11179 | if ( state.backtracking==0 ) { | ||
11180 | before(grammarAccess.getALSQuantifiedAccess().getDisjAssignment_0_2()); | ||
11181 | } | ||
11182 | // InternalAlloyLanguage.g:3721:1: ( rule__ALSQuantified__DisjAssignment_0_2 )? | ||
11183 | int alt28=2; | ||
11184 | int LA28_0 = input.LA(1); | ||
11185 | |||
11186 | if ( (LA28_0==74) ) { | ||
11187 | alt28=1; | ||
11188 | } | ||
11189 | switch (alt28) { | ||
11190 | case 1 : | ||
11191 | // InternalAlloyLanguage.g:3721:2: rule__ALSQuantified__DisjAssignment_0_2 | ||
11192 | { | ||
11193 | pushFollow(FOLLOW_2); | ||
11194 | rule__ALSQuantified__DisjAssignment_0_2(); | ||
11195 | |||
11196 | state._fsp--; | ||
11197 | if (state.failed) return ; | ||
11198 | |||
11199 | } | ||
11200 | break; | ||
11201 | |||
11202 | } | ||
11203 | |||
11204 | if ( state.backtracking==0 ) { | ||
11205 | after(grammarAccess.getALSQuantifiedAccess().getDisjAssignment_0_2()); | ||
11206 | } | ||
11207 | |||
11208 | } | ||
11209 | |||
11210 | |||
11211 | } | ||
11212 | |||
11213 | } | ||
11214 | catch (RecognitionException re) { | ||
11215 | reportError(re); | ||
11216 | recover(input,re); | ||
11217 | } | ||
11218 | finally { | ||
11219 | |||
11220 | restoreStackSize(stackSize); | ||
11221 | |||
11222 | } | ||
11223 | return ; | ||
11224 | } | ||
11225 | // $ANTLR end "rule__ALSQuantified__Group_0__2__Impl" | ||
11226 | |||
11227 | |||
11228 | // $ANTLR start "rule__ALSQuantified__Group_0__3" | ||
11229 | // InternalAlloyLanguage.g:3731:1: rule__ALSQuantified__Group_0__3 : rule__ALSQuantified__Group_0__3__Impl rule__ALSQuantified__Group_0__4 ; | ||
11230 | public final void rule__ALSQuantified__Group_0__3() throws RecognitionException { | ||
11231 | |||
11232 | int stackSize = keepStackSize(); | ||
11233 | |||
11234 | try { | ||
11235 | // InternalAlloyLanguage.g:3735:1: ( rule__ALSQuantified__Group_0__3__Impl rule__ALSQuantified__Group_0__4 ) | ||
11236 | // InternalAlloyLanguage.g:3736:2: rule__ALSQuantified__Group_0__3__Impl rule__ALSQuantified__Group_0__4 | ||
11237 | { | ||
11238 | pushFollow(FOLLOW_24); | ||
11239 | rule__ALSQuantified__Group_0__3__Impl(); | ||
11240 | |||
11241 | state._fsp--; | ||
11242 | if (state.failed) return ; | ||
11243 | pushFollow(FOLLOW_2); | ||
11244 | rule__ALSQuantified__Group_0__4(); | ||
11245 | |||
11246 | state._fsp--; | ||
11247 | if (state.failed) return ; | ||
11248 | |||
11249 | } | ||
11250 | |||
11251 | } | ||
11252 | catch (RecognitionException re) { | ||
11253 | reportError(re); | ||
11254 | recover(input,re); | ||
11255 | } | ||
11256 | finally { | ||
11257 | |||
11258 | restoreStackSize(stackSize); | ||
11259 | |||
11260 | } | ||
11261 | return ; | ||
11262 | } | ||
11263 | // $ANTLR end "rule__ALSQuantified__Group_0__3" | ||
11264 | |||
11265 | |||
11266 | // $ANTLR start "rule__ALSQuantified__Group_0__3__Impl" | ||
11267 | // InternalAlloyLanguage.g:3743:1: rule__ALSQuantified__Group_0__3__Impl : ( ( rule__ALSQuantified__VariablesAssignment_0_3 ) ) ; | ||
11268 | public final void rule__ALSQuantified__Group_0__3__Impl() throws RecognitionException { | ||
11269 | |||
11270 | int stackSize = keepStackSize(); | ||
11271 | |||
11272 | try { | ||
11273 | // InternalAlloyLanguage.g:3747:1: ( ( ( rule__ALSQuantified__VariablesAssignment_0_3 ) ) ) | ||
11274 | // InternalAlloyLanguage.g:3748:1: ( ( rule__ALSQuantified__VariablesAssignment_0_3 ) ) | ||
11275 | { | ||
11276 | // InternalAlloyLanguage.g:3748:1: ( ( rule__ALSQuantified__VariablesAssignment_0_3 ) ) | ||
11277 | // InternalAlloyLanguage.g:3749:1: ( rule__ALSQuantified__VariablesAssignment_0_3 ) | ||
11278 | { | ||
11279 | if ( state.backtracking==0 ) { | ||
11280 | before(grammarAccess.getALSQuantifiedAccess().getVariablesAssignment_0_3()); | ||
11281 | } | ||
11282 | // InternalAlloyLanguage.g:3750:1: ( rule__ALSQuantified__VariablesAssignment_0_3 ) | ||
11283 | // InternalAlloyLanguage.g:3750:2: rule__ALSQuantified__VariablesAssignment_0_3 | ||
11284 | { | ||
11285 | pushFollow(FOLLOW_2); | ||
11286 | rule__ALSQuantified__VariablesAssignment_0_3(); | ||
11287 | |||
11288 | state._fsp--; | ||
11289 | if (state.failed) return ; | ||
11290 | |||
11291 | } | ||
11292 | |||
11293 | if ( state.backtracking==0 ) { | ||
11294 | after(grammarAccess.getALSQuantifiedAccess().getVariablesAssignment_0_3()); | ||
11295 | } | ||
11296 | |||
11297 | } | ||
11298 | |||
11299 | |||
11300 | } | ||
11301 | |||
11302 | } | ||
11303 | catch (RecognitionException re) { | ||
11304 | reportError(re); | ||
11305 | recover(input,re); | ||
11306 | } | ||
11307 | finally { | ||
11308 | |||
11309 | restoreStackSize(stackSize); | ||
11310 | |||
11311 | } | ||
11312 | return ; | ||
11313 | } | ||
11314 | // $ANTLR end "rule__ALSQuantified__Group_0__3__Impl" | ||
11315 | |||
11316 | |||
11317 | // $ANTLR start "rule__ALSQuantified__Group_0__4" | ||
11318 | // InternalAlloyLanguage.g:3760:1: rule__ALSQuantified__Group_0__4 : rule__ALSQuantified__Group_0__4__Impl rule__ALSQuantified__Group_0__5 ; | ||
11319 | public final void rule__ALSQuantified__Group_0__4() throws RecognitionException { | ||
11320 | |||
11321 | int stackSize = keepStackSize(); | ||
11322 | |||
11323 | try { | ||
11324 | // InternalAlloyLanguage.g:3764:1: ( rule__ALSQuantified__Group_0__4__Impl rule__ALSQuantified__Group_0__5 ) | ||
11325 | // InternalAlloyLanguage.g:3765:2: rule__ALSQuantified__Group_0__4__Impl rule__ALSQuantified__Group_0__5 | ||
11326 | { | ||
11327 | pushFollow(FOLLOW_24); | ||
11328 | rule__ALSQuantified__Group_0__4__Impl(); | ||
11329 | |||
11330 | state._fsp--; | ||
11331 | if (state.failed) return ; | ||
11332 | pushFollow(FOLLOW_2); | ||
11333 | rule__ALSQuantified__Group_0__5(); | ||
11334 | |||
11335 | state._fsp--; | ||
11336 | if (state.failed) return ; | ||
11337 | |||
11338 | } | ||
11339 | |||
11340 | } | ||
11341 | catch (RecognitionException re) { | ||
11342 | reportError(re); | ||
11343 | recover(input,re); | ||
11344 | } | ||
11345 | finally { | ||
11346 | |||
11347 | restoreStackSize(stackSize); | ||
11348 | |||
11349 | } | ||
11350 | return ; | ||
11351 | } | ||
11352 | // $ANTLR end "rule__ALSQuantified__Group_0__4" | ||
11353 | |||
11354 | |||
11355 | // $ANTLR start "rule__ALSQuantified__Group_0__4__Impl" | ||
11356 | // InternalAlloyLanguage.g:3772:1: rule__ALSQuantified__Group_0__4__Impl : ( ( rule__ALSQuantified__Group_0_4__0 )* ) ; | ||
11357 | public final void rule__ALSQuantified__Group_0__4__Impl() throws RecognitionException { | ||
11358 | |||
11359 | int stackSize = keepStackSize(); | ||
11360 | |||
11361 | try { | ||
11362 | // InternalAlloyLanguage.g:3776:1: ( ( ( rule__ALSQuantified__Group_0_4__0 )* ) ) | ||
11363 | // InternalAlloyLanguage.g:3777:1: ( ( rule__ALSQuantified__Group_0_4__0 )* ) | ||
11364 | { | ||
11365 | // InternalAlloyLanguage.g:3777:1: ( ( rule__ALSQuantified__Group_0_4__0 )* ) | ||
11366 | // InternalAlloyLanguage.g:3778:1: ( rule__ALSQuantified__Group_0_4__0 )* | ||
11367 | { | ||
11368 | if ( state.backtracking==0 ) { | ||
11369 | before(grammarAccess.getALSQuantifiedAccess().getGroup_0_4()); | ||
11370 | } | ||
11371 | // InternalAlloyLanguage.g:3779:1: ( rule__ALSQuantified__Group_0_4__0 )* | ||
11372 | loop29: | ||
11373 | do { | ||
11374 | int alt29=2; | ||
11375 | int LA29_0 = input.LA(1); | ||
11376 | |||
11377 | if ( (LA29_0==35) ) { | ||
11378 | alt29=1; | ||
11379 | } | ||
11380 | |||
11381 | |||
11382 | switch (alt29) { | ||
11383 | case 1 : | ||
11384 | // InternalAlloyLanguage.g:3779:2: rule__ALSQuantified__Group_0_4__0 | ||
11385 | { | ||
11386 | pushFollow(FOLLOW_8); | ||
11387 | rule__ALSQuantified__Group_0_4__0(); | ||
11388 | |||
11389 | state._fsp--; | ||
11390 | if (state.failed) return ; | ||
11391 | |||
11392 | } | ||
11393 | break; | ||
11394 | |||
11395 | default : | ||
11396 | break loop29; | ||
11397 | } | ||
11398 | } while (true); | ||
11399 | |||
11400 | if ( state.backtracking==0 ) { | ||
11401 | after(grammarAccess.getALSQuantifiedAccess().getGroup_0_4()); | ||
11402 | } | ||
11403 | |||
11404 | } | ||
11405 | |||
11406 | |||
11407 | } | ||
11408 | |||
11409 | } | ||
11410 | catch (RecognitionException re) { | ||
11411 | reportError(re); | ||
11412 | recover(input,re); | ||
11413 | } | ||
11414 | finally { | ||
11415 | |||
11416 | restoreStackSize(stackSize); | ||
11417 | |||
11418 | } | ||
11419 | return ; | ||
11420 | } | ||
11421 | // $ANTLR end "rule__ALSQuantified__Group_0__4__Impl" | ||
11422 | |||
11423 | |||
11424 | // $ANTLR start "rule__ALSQuantified__Group_0__5" | ||
11425 | // InternalAlloyLanguage.g:3789:1: rule__ALSQuantified__Group_0__5 : rule__ALSQuantified__Group_0__5__Impl rule__ALSQuantified__Group_0__6 ; | ||
11426 | public final void rule__ALSQuantified__Group_0__5() throws RecognitionException { | ||
11427 | |||
11428 | int stackSize = keepStackSize(); | ||
11429 | |||
11430 | try { | ||
11431 | // InternalAlloyLanguage.g:3793:1: ( rule__ALSQuantified__Group_0__5__Impl rule__ALSQuantified__Group_0__6 ) | ||
11432 | // InternalAlloyLanguage.g:3794:2: rule__ALSQuantified__Group_0__5__Impl rule__ALSQuantified__Group_0__6 | ||
11433 | { | ||
11434 | pushFollow(FOLLOW_16); | ||
11435 | rule__ALSQuantified__Group_0__5__Impl(); | ||
11436 | |||
11437 | state._fsp--; | ||
11438 | if (state.failed) return ; | ||
11439 | pushFollow(FOLLOW_2); | ||
11440 | rule__ALSQuantified__Group_0__6(); | ||
11441 | |||
11442 | state._fsp--; | ||
11443 | if (state.failed) return ; | ||
11444 | |||
11445 | } | ||
11446 | |||
11447 | } | ||
11448 | catch (RecognitionException re) { | ||
11449 | reportError(re); | ||
11450 | recover(input,re); | ||
11451 | } | ||
11452 | finally { | ||
11453 | |||
11454 | restoreStackSize(stackSize); | ||
11455 | |||
11456 | } | ||
11457 | return ; | ||
11458 | } | ||
11459 | // $ANTLR end "rule__ALSQuantified__Group_0__5" | ||
11460 | |||
11461 | |||
11462 | // $ANTLR start "rule__ALSQuantified__Group_0__5__Impl" | ||
11463 | // InternalAlloyLanguage.g:3801:1: rule__ALSQuantified__Group_0__5__Impl : ( '{' ) ; | ||
11464 | public final void rule__ALSQuantified__Group_0__5__Impl() throws RecognitionException { | ||
11465 | |||
11466 | int stackSize = keepStackSize(); | ||
11467 | |||
11468 | try { | ||
11469 | // InternalAlloyLanguage.g:3805:1: ( ( '{' ) ) | ||
11470 | // InternalAlloyLanguage.g:3806:1: ( '{' ) | ||
11471 | { | ||
11472 | // InternalAlloyLanguage.g:3806:1: ( '{' ) | ||
11473 | // InternalAlloyLanguage.g:3807:1: '{' | ||
11474 | { | ||
11475 | if ( state.backtracking==0 ) { | ||
11476 | before(grammarAccess.getALSQuantifiedAccess().getLeftCurlyBracketKeyword_0_5()); | ||
11477 | } | ||
11478 | match(input,33,FOLLOW_2); if (state.failed) return ; | ||
11479 | if ( state.backtracking==0 ) { | ||
11480 | after(grammarAccess.getALSQuantifiedAccess().getLeftCurlyBracketKeyword_0_5()); | ||
11481 | } | ||
11482 | |||
11483 | } | ||
11484 | |||
11485 | |||
11486 | } | ||
11487 | |||
11488 | } | ||
11489 | catch (RecognitionException re) { | ||
11490 | reportError(re); | ||
11491 | recover(input,re); | ||
11492 | } | ||
11493 | finally { | ||
11494 | |||
11495 | restoreStackSize(stackSize); | ||
11496 | |||
11497 | } | ||
11498 | return ; | ||
11499 | } | ||
11500 | // $ANTLR end "rule__ALSQuantified__Group_0__5__Impl" | ||
11501 | |||
11502 | |||
11503 | // $ANTLR start "rule__ALSQuantified__Group_0__6" | ||
11504 | // InternalAlloyLanguage.g:3820:1: rule__ALSQuantified__Group_0__6 : rule__ALSQuantified__Group_0__6__Impl rule__ALSQuantified__Group_0__7 ; | ||
11505 | public final void rule__ALSQuantified__Group_0__6() throws RecognitionException { | ||
11506 | |||
11507 | int stackSize = keepStackSize(); | ||
11508 | |||
11509 | try { | ||
11510 | // InternalAlloyLanguage.g:3824:1: ( rule__ALSQuantified__Group_0__6__Impl rule__ALSQuantified__Group_0__7 ) | ||
11511 | // InternalAlloyLanguage.g:3825:2: rule__ALSQuantified__Group_0__6__Impl rule__ALSQuantified__Group_0__7 | ||
11512 | { | ||
11513 | pushFollow(FOLLOW_19); | ||
11514 | rule__ALSQuantified__Group_0__6__Impl(); | ||
11515 | |||
11516 | state._fsp--; | ||
11517 | if (state.failed) return ; | ||
11518 | pushFollow(FOLLOW_2); | ||
11519 | rule__ALSQuantified__Group_0__7(); | ||
11520 | |||
11521 | state._fsp--; | ||
11522 | if (state.failed) return ; | ||
11523 | |||
11524 | } | ||
11525 | |||
11526 | } | ||
11527 | catch (RecognitionException re) { | ||
11528 | reportError(re); | ||
11529 | recover(input,re); | ||
11530 | } | ||
11531 | finally { | ||
11532 | |||
11533 | restoreStackSize(stackSize); | ||
11534 | |||
11535 | } | ||
11536 | return ; | ||
11537 | } | ||
11538 | // $ANTLR end "rule__ALSQuantified__Group_0__6" | ||
11539 | |||
11540 | |||
11541 | // $ANTLR start "rule__ALSQuantified__Group_0__6__Impl" | ||
11542 | // InternalAlloyLanguage.g:3832:1: rule__ALSQuantified__Group_0__6__Impl : ( ( rule__ALSQuantified__ExpressionAssignment_0_6 ) ) ; | ||
11543 | public final void rule__ALSQuantified__Group_0__6__Impl() throws RecognitionException { | ||
11544 | |||
11545 | int stackSize = keepStackSize(); | ||
11546 | |||
11547 | try { | ||
11548 | // InternalAlloyLanguage.g:3836:1: ( ( ( rule__ALSQuantified__ExpressionAssignment_0_6 ) ) ) | ||
11549 | // InternalAlloyLanguage.g:3837:1: ( ( rule__ALSQuantified__ExpressionAssignment_0_6 ) ) | ||
11550 | { | ||
11551 | // InternalAlloyLanguage.g:3837:1: ( ( rule__ALSQuantified__ExpressionAssignment_0_6 ) ) | ||
11552 | // InternalAlloyLanguage.g:3838:1: ( rule__ALSQuantified__ExpressionAssignment_0_6 ) | ||
11553 | { | ||
11554 | if ( state.backtracking==0 ) { | ||
11555 | before(grammarAccess.getALSQuantifiedAccess().getExpressionAssignment_0_6()); | ||
11556 | } | ||
11557 | // InternalAlloyLanguage.g:3839:1: ( rule__ALSQuantified__ExpressionAssignment_0_6 ) | ||
11558 | // InternalAlloyLanguage.g:3839:2: rule__ALSQuantified__ExpressionAssignment_0_6 | ||
11559 | { | ||
11560 | pushFollow(FOLLOW_2); | ||
11561 | rule__ALSQuantified__ExpressionAssignment_0_6(); | ||
11562 | |||
11563 | state._fsp--; | ||
11564 | if (state.failed) return ; | ||
11565 | |||
11566 | } | ||
11567 | |||
11568 | if ( state.backtracking==0 ) { | ||
11569 | after(grammarAccess.getALSQuantifiedAccess().getExpressionAssignment_0_6()); | ||
11570 | } | ||
11571 | |||
11572 | } | ||
11573 | |||
11574 | |||
11575 | } | ||
11576 | |||
11577 | } | ||
11578 | catch (RecognitionException re) { | ||
11579 | reportError(re); | ||
11580 | recover(input,re); | ||
11581 | } | ||
11582 | finally { | ||
11583 | |||
11584 | restoreStackSize(stackSize); | ||
11585 | |||
11586 | } | ||
11587 | return ; | ||
11588 | } | ||
11589 | // $ANTLR end "rule__ALSQuantified__Group_0__6__Impl" | ||
11590 | |||
11591 | |||
11592 | // $ANTLR start "rule__ALSQuantified__Group_0__7" | ||
11593 | // InternalAlloyLanguage.g:3849:1: rule__ALSQuantified__Group_0__7 : rule__ALSQuantified__Group_0__7__Impl ; | ||
11594 | public final void rule__ALSQuantified__Group_0__7() throws RecognitionException { | ||
11595 | |||
11596 | int stackSize = keepStackSize(); | ||
11597 | |||
11598 | try { | ||
11599 | // InternalAlloyLanguage.g:3853:1: ( rule__ALSQuantified__Group_0__7__Impl ) | ||
11600 | // InternalAlloyLanguage.g:3854:2: rule__ALSQuantified__Group_0__7__Impl | ||
11601 | { | ||
11602 | pushFollow(FOLLOW_2); | ||
11603 | rule__ALSQuantified__Group_0__7__Impl(); | ||
11604 | |||
11605 | state._fsp--; | ||
11606 | if (state.failed) return ; | ||
11607 | |||
11608 | } | ||
11609 | |||
11610 | } | ||
11611 | catch (RecognitionException re) { | ||
11612 | reportError(re); | ||
11613 | recover(input,re); | ||
11614 | } | ||
11615 | finally { | ||
11616 | |||
11617 | restoreStackSize(stackSize); | ||
11618 | |||
11619 | } | ||
11620 | return ; | ||
11621 | } | ||
11622 | // $ANTLR end "rule__ALSQuantified__Group_0__7" | ||
11623 | |||
11624 | |||
11625 | // $ANTLR start "rule__ALSQuantified__Group_0__7__Impl" | ||
11626 | // InternalAlloyLanguage.g:3860:1: rule__ALSQuantified__Group_0__7__Impl : ( '}' ) ; | ||
11627 | public final void rule__ALSQuantified__Group_0__7__Impl() throws RecognitionException { | ||
11628 | |||
11629 | int stackSize = keepStackSize(); | ||
11630 | |||
11631 | try { | ||
11632 | // InternalAlloyLanguage.g:3864:1: ( ( '}' ) ) | ||
11633 | // InternalAlloyLanguage.g:3865:1: ( '}' ) | ||
11634 | { | ||
11635 | // InternalAlloyLanguage.g:3865:1: ( '}' ) | ||
11636 | // InternalAlloyLanguage.g:3866:1: '}' | ||
11637 | { | ||
11638 | if ( state.backtracking==0 ) { | ||
11639 | before(grammarAccess.getALSQuantifiedAccess().getRightCurlyBracketKeyword_0_7()); | ||
11640 | } | ||
11641 | match(input,34,FOLLOW_2); if (state.failed) return ; | ||
11642 | if ( state.backtracking==0 ) { | ||
11643 | after(grammarAccess.getALSQuantifiedAccess().getRightCurlyBracketKeyword_0_7()); | ||
11644 | } | ||
11645 | |||
11646 | } | ||
11647 | |||
11648 | |||
11649 | } | ||
11650 | |||
11651 | } | ||
11652 | catch (RecognitionException re) { | ||
11653 | reportError(re); | ||
11654 | recover(input,re); | ||
11655 | } | ||
11656 | finally { | ||
11657 | |||
11658 | restoreStackSize(stackSize); | ||
11659 | |||
11660 | } | ||
11661 | return ; | ||
11662 | } | ||
11663 | // $ANTLR end "rule__ALSQuantified__Group_0__7__Impl" | ||
11664 | |||
11665 | |||
11666 | // $ANTLR start "rule__ALSQuantified__Group_0_4__0" | ||
11667 | // InternalAlloyLanguage.g:3895:1: rule__ALSQuantified__Group_0_4__0 : rule__ALSQuantified__Group_0_4__0__Impl rule__ALSQuantified__Group_0_4__1 ; | ||
11668 | public final void rule__ALSQuantified__Group_0_4__0() throws RecognitionException { | ||
11669 | |||
11670 | int stackSize = keepStackSize(); | ||
11671 | |||
11672 | try { | ||
11673 | // InternalAlloyLanguage.g:3899:1: ( rule__ALSQuantified__Group_0_4__0__Impl rule__ALSQuantified__Group_0_4__1 ) | ||
11674 | // InternalAlloyLanguage.g:3900:2: rule__ALSQuantified__Group_0_4__0__Impl rule__ALSQuantified__Group_0_4__1 | ||
11675 | { | ||
11676 | pushFollow(FOLLOW_5); | ||
11677 | rule__ALSQuantified__Group_0_4__0__Impl(); | ||
11678 | |||
11679 | state._fsp--; | ||
11680 | if (state.failed) return ; | ||
11681 | pushFollow(FOLLOW_2); | ||
11682 | rule__ALSQuantified__Group_0_4__1(); | ||
11683 | |||
11684 | state._fsp--; | ||
11685 | if (state.failed) return ; | ||
11686 | |||
11687 | } | ||
11688 | |||
11689 | } | ||
11690 | catch (RecognitionException re) { | ||
11691 | reportError(re); | ||
11692 | recover(input,re); | ||
11693 | } | ||
11694 | finally { | ||
11695 | |||
11696 | restoreStackSize(stackSize); | ||
11697 | |||
11698 | } | ||
11699 | return ; | ||
11700 | } | ||
11701 | // $ANTLR end "rule__ALSQuantified__Group_0_4__0" | ||
11702 | |||
11703 | |||
11704 | // $ANTLR start "rule__ALSQuantified__Group_0_4__0__Impl" | ||
11705 | // InternalAlloyLanguage.g:3907:1: rule__ALSQuantified__Group_0_4__0__Impl : ( ',' ) ; | ||
11706 | public final void rule__ALSQuantified__Group_0_4__0__Impl() throws RecognitionException { | ||
11707 | |||
11708 | int stackSize = keepStackSize(); | ||
11709 | |||
11710 | try { | ||
11711 | // InternalAlloyLanguage.g:3911:1: ( ( ',' ) ) | ||
11712 | // InternalAlloyLanguage.g:3912:1: ( ',' ) | ||
11713 | { | ||
11714 | // InternalAlloyLanguage.g:3912:1: ( ',' ) | ||
11715 | // InternalAlloyLanguage.g:3913:1: ',' | ||
11716 | { | ||
11717 | if ( state.backtracking==0 ) { | ||
11718 | before(grammarAccess.getALSQuantifiedAccess().getCommaKeyword_0_4_0()); | ||
11719 | } | ||
11720 | match(input,35,FOLLOW_2); if (state.failed) return ; | ||
11721 | if ( state.backtracking==0 ) { | ||
11722 | after(grammarAccess.getALSQuantifiedAccess().getCommaKeyword_0_4_0()); | ||
11723 | } | ||
11724 | |||
11725 | } | ||
11726 | |||
11727 | |||
11728 | } | ||
11729 | |||
11730 | } | ||
11731 | catch (RecognitionException re) { | ||
11732 | reportError(re); | ||
11733 | recover(input,re); | ||
11734 | } | ||
11735 | finally { | ||
11736 | |||
11737 | restoreStackSize(stackSize); | ||
11738 | |||
11739 | } | ||
11740 | return ; | ||
11741 | } | ||
11742 | // $ANTLR end "rule__ALSQuantified__Group_0_4__0__Impl" | ||
11743 | |||
11744 | |||
11745 | // $ANTLR start "rule__ALSQuantified__Group_0_4__1" | ||
11746 | // InternalAlloyLanguage.g:3926:1: rule__ALSQuantified__Group_0_4__1 : rule__ALSQuantified__Group_0_4__1__Impl ; | ||
11747 | public final void rule__ALSQuantified__Group_0_4__1() throws RecognitionException { | ||
11748 | |||
11749 | int stackSize = keepStackSize(); | ||
11750 | |||
11751 | try { | ||
11752 | // InternalAlloyLanguage.g:3930:1: ( rule__ALSQuantified__Group_0_4__1__Impl ) | ||
11753 | // InternalAlloyLanguage.g:3931:2: rule__ALSQuantified__Group_0_4__1__Impl | ||
11754 | { | ||
11755 | pushFollow(FOLLOW_2); | ||
11756 | rule__ALSQuantified__Group_0_4__1__Impl(); | ||
11757 | |||
11758 | state._fsp--; | ||
11759 | if (state.failed) return ; | ||
11760 | |||
11761 | } | ||
11762 | |||
11763 | } | ||
11764 | catch (RecognitionException re) { | ||
11765 | reportError(re); | ||
11766 | recover(input,re); | ||
11767 | } | ||
11768 | finally { | ||
11769 | |||
11770 | restoreStackSize(stackSize); | ||
11771 | |||
11772 | } | ||
11773 | return ; | ||
11774 | } | ||
11775 | // $ANTLR end "rule__ALSQuantified__Group_0_4__1" | ||
11776 | |||
11777 | |||
11778 | // $ANTLR start "rule__ALSQuantified__Group_0_4__1__Impl" | ||
11779 | // InternalAlloyLanguage.g:3937:1: rule__ALSQuantified__Group_0_4__1__Impl : ( ( rule__ALSQuantified__VariablesAssignment_0_4_1 ) ) ; | ||
11780 | public final void rule__ALSQuantified__Group_0_4__1__Impl() throws RecognitionException { | ||
11781 | |||
11782 | int stackSize = keepStackSize(); | ||
11783 | |||
11784 | try { | ||
11785 | // InternalAlloyLanguage.g:3941:1: ( ( ( rule__ALSQuantified__VariablesAssignment_0_4_1 ) ) ) | ||
11786 | // InternalAlloyLanguage.g:3942:1: ( ( rule__ALSQuantified__VariablesAssignment_0_4_1 ) ) | ||
11787 | { | ||
11788 | // InternalAlloyLanguage.g:3942:1: ( ( rule__ALSQuantified__VariablesAssignment_0_4_1 ) ) | ||
11789 | // InternalAlloyLanguage.g:3943:1: ( rule__ALSQuantified__VariablesAssignment_0_4_1 ) | ||
11790 | { | ||
11791 | if ( state.backtracking==0 ) { | ||
11792 | before(grammarAccess.getALSQuantifiedAccess().getVariablesAssignment_0_4_1()); | ||
11793 | } | ||
11794 | // InternalAlloyLanguage.g:3944:1: ( rule__ALSQuantified__VariablesAssignment_0_4_1 ) | ||
11795 | // InternalAlloyLanguage.g:3944:2: rule__ALSQuantified__VariablesAssignment_0_4_1 | ||
11796 | { | ||
11797 | pushFollow(FOLLOW_2); | ||
11798 | rule__ALSQuantified__VariablesAssignment_0_4_1(); | ||
11799 | |||
11800 | state._fsp--; | ||
11801 | if (state.failed) return ; | ||
11802 | |||
11803 | } | ||
11804 | |||
11805 | if ( state.backtracking==0 ) { | ||
11806 | after(grammarAccess.getALSQuantifiedAccess().getVariablesAssignment_0_4_1()); | ||
11807 | } | ||
11808 | |||
11809 | } | ||
11810 | |||
11811 | |||
11812 | } | ||
11813 | |||
11814 | } | ||
11815 | catch (RecognitionException re) { | ||
11816 | reportError(re); | ||
11817 | recover(input,re); | ||
11818 | } | ||
11819 | finally { | ||
11820 | |||
11821 | restoreStackSize(stackSize); | ||
11822 | |||
11823 | } | ||
11824 | return ; | ||
11825 | } | ||
11826 | // $ANTLR end "rule__ALSQuantified__Group_0_4__1__Impl" | ||
11827 | |||
11828 | |||
11829 | // $ANTLR start "rule__ALSOr__Group__0" | ||
11830 | // InternalAlloyLanguage.g:3958:1: rule__ALSOr__Group__0 : rule__ALSOr__Group__0__Impl rule__ALSOr__Group__1 ; | ||
11831 | public final void rule__ALSOr__Group__0() throws RecognitionException { | ||
11832 | |||
11833 | int stackSize = keepStackSize(); | ||
11834 | |||
11835 | try { | ||
11836 | // InternalAlloyLanguage.g:3962:1: ( rule__ALSOr__Group__0__Impl rule__ALSOr__Group__1 ) | ||
11837 | // InternalAlloyLanguage.g:3963:2: rule__ALSOr__Group__0__Impl rule__ALSOr__Group__1 | ||
11838 | { | ||
11839 | pushFollow(FOLLOW_25); | ||
11840 | rule__ALSOr__Group__0__Impl(); | ||
11841 | |||
11842 | state._fsp--; | ||
11843 | if (state.failed) return ; | ||
11844 | pushFollow(FOLLOW_2); | ||
11845 | rule__ALSOr__Group__1(); | ||
11846 | |||
11847 | state._fsp--; | ||
11848 | if (state.failed) return ; | ||
11849 | |||
11850 | } | ||
11851 | |||
11852 | } | ||
11853 | catch (RecognitionException re) { | ||
11854 | reportError(re); | ||
11855 | recover(input,re); | ||
11856 | } | ||
11857 | finally { | ||
11858 | |||
11859 | restoreStackSize(stackSize); | ||
11860 | |||
11861 | } | ||
11862 | return ; | ||
11863 | } | ||
11864 | // $ANTLR end "rule__ALSOr__Group__0" | ||
11865 | |||
11866 | |||
11867 | // $ANTLR start "rule__ALSOr__Group__0__Impl" | ||
11868 | // InternalAlloyLanguage.g:3970:1: rule__ALSOr__Group__0__Impl : ( ruleALSIff ) ; | ||
11869 | public final void rule__ALSOr__Group__0__Impl() throws RecognitionException { | ||
11870 | |||
11871 | int stackSize = keepStackSize(); | ||
11872 | |||
11873 | try { | ||
11874 | // InternalAlloyLanguage.g:3974:1: ( ( ruleALSIff ) ) | ||
11875 | // InternalAlloyLanguage.g:3975:1: ( ruleALSIff ) | ||
11876 | { | ||
11877 | // InternalAlloyLanguage.g:3975:1: ( ruleALSIff ) | ||
11878 | // InternalAlloyLanguage.g:3976:1: ruleALSIff | ||
11879 | { | ||
11880 | if ( state.backtracking==0 ) { | ||
11881 | before(grammarAccess.getALSOrAccess().getALSIffParserRuleCall_0()); | ||
11882 | } | ||
11883 | pushFollow(FOLLOW_2); | ||
11884 | ruleALSIff(); | ||
11885 | |||
11886 | state._fsp--; | ||
11887 | if (state.failed) return ; | ||
11888 | if ( state.backtracking==0 ) { | ||
11889 | after(grammarAccess.getALSOrAccess().getALSIffParserRuleCall_0()); | ||
11890 | } | ||
11891 | |||
11892 | } | ||
11893 | |||
11894 | |||
11895 | } | ||
11896 | |||
11897 | } | ||
11898 | catch (RecognitionException re) { | ||
11899 | reportError(re); | ||
11900 | recover(input,re); | ||
11901 | } | ||
11902 | finally { | ||
11903 | |||
11904 | restoreStackSize(stackSize); | ||
11905 | |||
11906 | } | ||
11907 | return ; | ||
11908 | } | ||
11909 | // $ANTLR end "rule__ALSOr__Group__0__Impl" | ||
11910 | |||
11911 | |||
11912 | // $ANTLR start "rule__ALSOr__Group__1" | ||
11913 | // InternalAlloyLanguage.g:3987:1: rule__ALSOr__Group__1 : rule__ALSOr__Group__1__Impl ; | ||
11914 | public final void rule__ALSOr__Group__1() throws RecognitionException { | ||
11915 | |||
11916 | int stackSize = keepStackSize(); | ||
11917 | |||
11918 | try { | ||
11919 | // InternalAlloyLanguage.g:3991:1: ( rule__ALSOr__Group__1__Impl ) | ||
11920 | // InternalAlloyLanguage.g:3992:2: rule__ALSOr__Group__1__Impl | ||
11921 | { | ||
11922 | pushFollow(FOLLOW_2); | ||
11923 | rule__ALSOr__Group__1__Impl(); | ||
11924 | |||
11925 | state._fsp--; | ||
11926 | if (state.failed) return ; | ||
11927 | |||
11928 | } | ||
11929 | |||
11930 | } | ||
11931 | catch (RecognitionException re) { | ||
11932 | reportError(re); | ||
11933 | recover(input,re); | ||
11934 | } | ||
11935 | finally { | ||
11936 | |||
11937 | restoreStackSize(stackSize); | ||
11938 | |||
11939 | } | ||
11940 | return ; | ||
11941 | } | ||
11942 | // $ANTLR end "rule__ALSOr__Group__1" | ||
11943 | |||
11944 | |||
11945 | // $ANTLR start "rule__ALSOr__Group__1__Impl" | ||
11946 | // InternalAlloyLanguage.g:3998:1: rule__ALSOr__Group__1__Impl : ( ( rule__ALSOr__Group_1__0 )? ) ; | ||
11947 | public final void rule__ALSOr__Group__1__Impl() throws RecognitionException { | ||
11948 | |||
11949 | int stackSize = keepStackSize(); | ||
11950 | |||
11951 | try { | ||
11952 | // InternalAlloyLanguage.g:4002:1: ( ( ( rule__ALSOr__Group_1__0 )? ) ) | ||
11953 | // InternalAlloyLanguage.g:4003:1: ( ( rule__ALSOr__Group_1__0 )? ) | ||
11954 | { | ||
11955 | // InternalAlloyLanguage.g:4003:1: ( ( rule__ALSOr__Group_1__0 )? ) | ||
11956 | // InternalAlloyLanguage.g:4004:1: ( rule__ALSOr__Group_1__0 )? | ||
11957 | { | ||
11958 | if ( state.backtracking==0 ) { | ||
11959 | before(grammarAccess.getALSOrAccess().getGroup_1()); | ||
11960 | } | ||
11961 | // InternalAlloyLanguage.g:4005:1: ( rule__ALSOr__Group_1__0 )? | ||
11962 | int alt30=2; | ||
11963 | int LA30_0 = input.LA(1); | ||
11964 | |||
11965 | if ( ((LA30_0>=11 && LA30_0<=12)) ) { | ||
11966 | alt30=1; | ||
11967 | } | ||
11968 | switch (alt30) { | ||
11969 | case 1 : | ||
11970 | // InternalAlloyLanguage.g:4005:2: rule__ALSOr__Group_1__0 | ||
11971 | { | ||
11972 | pushFollow(FOLLOW_2); | ||
11973 | rule__ALSOr__Group_1__0(); | ||
11974 | |||
11975 | state._fsp--; | ||
11976 | if (state.failed) return ; | ||
11977 | |||
11978 | } | ||
11979 | break; | ||
11980 | |||
11981 | } | ||
11982 | |||
11983 | if ( state.backtracking==0 ) { | ||
11984 | after(grammarAccess.getALSOrAccess().getGroup_1()); | ||
11985 | } | ||
11986 | |||
11987 | } | ||
11988 | |||
11989 | |||
11990 | } | ||
11991 | |||
11992 | } | ||
11993 | catch (RecognitionException re) { | ||
11994 | reportError(re); | ||
11995 | recover(input,re); | ||
11996 | } | ||
11997 | finally { | ||
11998 | |||
11999 | restoreStackSize(stackSize); | ||
12000 | |||
12001 | } | ||
12002 | return ; | ||
12003 | } | ||
12004 | // $ANTLR end "rule__ALSOr__Group__1__Impl" | ||
12005 | |||
12006 | |||
12007 | // $ANTLR start "rule__ALSOr__Group_1__0" | ||
12008 | // InternalAlloyLanguage.g:4019:1: rule__ALSOr__Group_1__0 : rule__ALSOr__Group_1__0__Impl rule__ALSOr__Group_1__1 ; | ||
12009 | public final void rule__ALSOr__Group_1__0() throws RecognitionException { | ||
12010 | |||
12011 | int stackSize = keepStackSize(); | ||
12012 | |||
12013 | try { | ||
12014 | // InternalAlloyLanguage.g:4023:1: ( rule__ALSOr__Group_1__0__Impl rule__ALSOr__Group_1__1 ) | ||
12015 | // InternalAlloyLanguage.g:4024:2: rule__ALSOr__Group_1__0__Impl rule__ALSOr__Group_1__1 | ||
12016 | { | ||
12017 | pushFollow(FOLLOW_25); | ||
12018 | rule__ALSOr__Group_1__0__Impl(); | ||
12019 | |||
12020 | state._fsp--; | ||
12021 | if (state.failed) return ; | ||
12022 | pushFollow(FOLLOW_2); | ||
12023 | rule__ALSOr__Group_1__1(); | ||
12024 | |||
12025 | state._fsp--; | ||
12026 | if (state.failed) return ; | ||
12027 | |||
12028 | } | ||
12029 | |||
12030 | } | ||
12031 | catch (RecognitionException re) { | ||
12032 | reportError(re); | ||
12033 | recover(input,re); | ||
12034 | } | ||
12035 | finally { | ||
12036 | |||
12037 | restoreStackSize(stackSize); | ||
12038 | |||
12039 | } | ||
12040 | return ; | ||
12041 | } | ||
12042 | // $ANTLR end "rule__ALSOr__Group_1__0" | ||
12043 | |||
12044 | |||
12045 | // $ANTLR start "rule__ALSOr__Group_1__0__Impl" | ||
12046 | // InternalAlloyLanguage.g:4031:1: rule__ALSOr__Group_1__0__Impl : ( () ) ; | ||
12047 | public final void rule__ALSOr__Group_1__0__Impl() throws RecognitionException { | ||
12048 | |||
12049 | int stackSize = keepStackSize(); | ||
12050 | |||
12051 | try { | ||
12052 | // InternalAlloyLanguage.g:4035:1: ( ( () ) ) | ||
12053 | // InternalAlloyLanguage.g:4036:1: ( () ) | ||
12054 | { | ||
12055 | // InternalAlloyLanguage.g:4036:1: ( () ) | ||
12056 | // InternalAlloyLanguage.g:4037:1: () | ||
12057 | { | ||
12058 | if ( state.backtracking==0 ) { | ||
12059 | before(grammarAccess.getALSOrAccess().getALSOrLeftOperandAction_1_0()); | ||
12060 | } | ||
12061 | // InternalAlloyLanguage.g:4038:1: () | ||
12062 | // InternalAlloyLanguage.g:4040:1: | ||
12063 | { | ||
12064 | } | ||
12065 | |||
12066 | if ( state.backtracking==0 ) { | ||
12067 | after(grammarAccess.getALSOrAccess().getALSOrLeftOperandAction_1_0()); | ||
12068 | } | ||
12069 | |||
12070 | } | ||
12071 | |||
12072 | |||
12073 | } | ||
12074 | |||
12075 | } | ||
12076 | finally { | ||
12077 | |||
12078 | restoreStackSize(stackSize); | ||
12079 | |||
12080 | } | ||
12081 | return ; | ||
12082 | } | ||
12083 | // $ANTLR end "rule__ALSOr__Group_1__0__Impl" | ||
12084 | |||
12085 | |||
12086 | // $ANTLR start "rule__ALSOr__Group_1__1" | ||
12087 | // InternalAlloyLanguage.g:4050:1: rule__ALSOr__Group_1__1 : rule__ALSOr__Group_1__1__Impl rule__ALSOr__Group_1__2 ; | ||
12088 | public final void rule__ALSOr__Group_1__1() throws RecognitionException { | ||
12089 | |||
12090 | int stackSize = keepStackSize(); | ||
12091 | |||
12092 | try { | ||
12093 | // InternalAlloyLanguage.g:4054:1: ( rule__ALSOr__Group_1__1__Impl rule__ALSOr__Group_1__2 ) | ||
12094 | // InternalAlloyLanguage.g:4055:2: rule__ALSOr__Group_1__1__Impl rule__ALSOr__Group_1__2 | ||
12095 | { | ||
12096 | pushFollow(FOLLOW_16); | ||
12097 | rule__ALSOr__Group_1__1__Impl(); | ||
12098 | |||
12099 | state._fsp--; | ||
12100 | if (state.failed) return ; | ||
12101 | pushFollow(FOLLOW_2); | ||
12102 | rule__ALSOr__Group_1__2(); | ||
12103 | |||
12104 | state._fsp--; | ||
12105 | if (state.failed) return ; | ||
12106 | |||
12107 | } | ||
12108 | |||
12109 | } | ||
12110 | catch (RecognitionException re) { | ||
12111 | reportError(re); | ||
12112 | recover(input,re); | ||
12113 | } | ||
12114 | finally { | ||
12115 | |||
12116 | restoreStackSize(stackSize); | ||
12117 | |||
12118 | } | ||
12119 | return ; | ||
12120 | } | ||
12121 | // $ANTLR end "rule__ALSOr__Group_1__1" | ||
12122 | |||
12123 | |||
12124 | // $ANTLR start "rule__ALSOr__Group_1__1__Impl" | ||
12125 | // InternalAlloyLanguage.g:4062:1: rule__ALSOr__Group_1__1__Impl : ( ( rule__ALSOr__Alternatives_1_1 ) ) ; | ||
12126 | public final void rule__ALSOr__Group_1__1__Impl() throws RecognitionException { | ||
12127 | |||
12128 | int stackSize = keepStackSize(); | ||
12129 | |||
12130 | try { | ||
12131 | // InternalAlloyLanguage.g:4066:1: ( ( ( rule__ALSOr__Alternatives_1_1 ) ) ) | ||
12132 | // InternalAlloyLanguage.g:4067:1: ( ( rule__ALSOr__Alternatives_1_1 ) ) | ||
12133 | { | ||
12134 | // InternalAlloyLanguage.g:4067:1: ( ( rule__ALSOr__Alternatives_1_1 ) ) | ||
12135 | // InternalAlloyLanguage.g:4068:1: ( rule__ALSOr__Alternatives_1_1 ) | ||
12136 | { | ||
12137 | if ( state.backtracking==0 ) { | ||
12138 | before(grammarAccess.getALSOrAccess().getAlternatives_1_1()); | ||
12139 | } | ||
12140 | // InternalAlloyLanguage.g:4069:1: ( rule__ALSOr__Alternatives_1_1 ) | ||
12141 | // InternalAlloyLanguage.g:4069:2: rule__ALSOr__Alternatives_1_1 | ||
12142 | { | ||
12143 | pushFollow(FOLLOW_2); | ||
12144 | rule__ALSOr__Alternatives_1_1(); | ||
12145 | |||
12146 | state._fsp--; | ||
12147 | if (state.failed) return ; | ||
12148 | |||
12149 | } | ||
12150 | |||
12151 | if ( state.backtracking==0 ) { | ||
12152 | after(grammarAccess.getALSOrAccess().getAlternatives_1_1()); | ||
12153 | } | ||
12154 | |||
12155 | } | ||
12156 | |||
12157 | |||
12158 | } | ||
12159 | |||
12160 | } | ||
12161 | catch (RecognitionException re) { | ||
12162 | reportError(re); | ||
12163 | recover(input,re); | ||
12164 | } | ||
12165 | finally { | ||
12166 | |||
12167 | restoreStackSize(stackSize); | ||
12168 | |||
12169 | } | ||
12170 | return ; | ||
12171 | } | ||
12172 | // $ANTLR end "rule__ALSOr__Group_1__1__Impl" | ||
12173 | |||
12174 | |||
12175 | // $ANTLR start "rule__ALSOr__Group_1__2" | ||
12176 | // InternalAlloyLanguage.g:4079:1: rule__ALSOr__Group_1__2 : rule__ALSOr__Group_1__2__Impl ; | ||
12177 | public final void rule__ALSOr__Group_1__2() throws RecognitionException { | ||
12178 | |||
12179 | int stackSize = keepStackSize(); | ||
12180 | |||
12181 | try { | ||
12182 | // InternalAlloyLanguage.g:4083:1: ( rule__ALSOr__Group_1__2__Impl ) | ||
12183 | // InternalAlloyLanguage.g:4084:2: rule__ALSOr__Group_1__2__Impl | ||
12184 | { | ||
12185 | pushFollow(FOLLOW_2); | ||
12186 | rule__ALSOr__Group_1__2__Impl(); | ||
12187 | |||
12188 | state._fsp--; | ||
12189 | if (state.failed) return ; | ||
12190 | |||
12191 | } | ||
12192 | |||
12193 | } | ||
12194 | catch (RecognitionException re) { | ||
12195 | reportError(re); | ||
12196 | recover(input,re); | ||
12197 | } | ||
12198 | finally { | ||
12199 | |||
12200 | restoreStackSize(stackSize); | ||
12201 | |||
12202 | } | ||
12203 | return ; | ||
12204 | } | ||
12205 | // $ANTLR end "rule__ALSOr__Group_1__2" | ||
12206 | |||
12207 | |||
12208 | // $ANTLR start "rule__ALSOr__Group_1__2__Impl" | ||
12209 | // InternalAlloyLanguage.g:4090:1: rule__ALSOr__Group_1__2__Impl : ( ( rule__ALSOr__RightOperandAssignment_1_2 ) ) ; | ||
12210 | public final void rule__ALSOr__Group_1__2__Impl() throws RecognitionException { | ||
12211 | |||
12212 | int stackSize = keepStackSize(); | ||
12213 | |||
12214 | try { | ||
12215 | // InternalAlloyLanguage.g:4094:1: ( ( ( rule__ALSOr__RightOperandAssignment_1_2 ) ) ) | ||
12216 | // InternalAlloyLanguage.g:4095:1: ( ( rule__ALSOr__RightOperandAssignment_1_2 ) ) | ||
12217 | { | ||
12218 | // InternalAlloyLanguage.g:4095:1: ( ( rule__ALSOr__RightOperandAssignment_1_2 ) ) | ||
12219 | // InternalAlloyLanguage.g:4096:1: ( rule__ALSOr__RightOperandAssignment_1_2 ) | ||
12220 | { | ||
12221 | if ( state.backtracking==0 ) { | ||
12222 | before(grammarAccess.getALSOrAccess().getRightOperandAssignment_1_2()); | ||
12223 | } | ||
12224 | // InternalAlloyLanguage.g:4097:1: ( rule__ALSOr__RightOperandAssignment_1_2 ) | ||
12225 | // InternalAlloyLanguage.g:4097:2: rule__ALSOr__RightOperandAssignment_1_2 | ||
12226 | { | ||
12227 | pushFollow(FOLLOW_2); | ||
12228 | rule__ALSOr__RightOperandAssignment_1_2(); | ||
12229 | |||
12230 | state._fsp--; | ||
12231 | if (state.failed) return ; | ||
12232 | |||
12233 | } | ||
12234 | |||
12235 | if ( state.backtracking==0 ) { | ||
12236 | after(grammarAccess.getALSOrAccess().getRightOperandAssignment_1_2()); | ||
12237 | } | ||
12238 | |||
12239 | } | ||
12240 | |||
12241 | |||
12242 | } | ||
12243 | |||
12244 | } | ||
12245 | catch (RecognitionException re) { | ||
12246 | reportError(re); | ||
12247 | recover(input,re); | ||
12248 | } | ||
12249 | finally { | ||
12250 | |||
12251 | restoreStackSize(stackSize); | ||
12252 | |||
12253 | } | ||
12254 | return ; | ||
12255 | } | ||
12256 | // $ANTLR end "rule__ALSOr__Group_1__2__Impl" | ||
12257 | |||
12258 | |||
12259 | // $ANTLR start "rule__ALSIff__Group__0" | ||
12260 | // InternalAlloyLanguage.g:4113:1: rule__ALSIff__Group__0 : rule__ALSIff__Group__0__Impl rule__ALSIff__Group__1 ; | ||
12261 | public final void rule__ALSIff__Group__0() throws RecognitionException { | ||
12262 | |||
12263 | int stackSize = keepStackSize(); | ||
12264 | |||
12265 | try { | ||
12266 | // InternalAlloyLanguage.g:4117:1: ( rule__ALSIff__Group__0__Impl rule__ALSIff__Group__1 ) | ||
12267 | // InternalAlloyLanguage.g:4118:2: rule__ALSIff__Group__0__Impl rule__ALSIff__Group__1 | ||
12268 | { | ||
12269 | pushFollow(FOLLOW_26); | ||
12270 | rule__ALSIff__Group__0__Impl(); | ||
12271 | |||
12272 | state._fsp--; | ||
12273 | if (state.failed) return ; | ||
12274 | pushFollow(FOLLOW_2); | ||
12275 | rule__ALSIff__Group__1(); | ||
12276 | |||
12277 | state._fsp--; | ||
12278 | if (state.failed) return ; | ||
12279 | |||
12280 | } | ||
12281 | |||
12282 | } | ||
12283 | catch (RecognitionException re) { | ||
12284 | reportError(re); | ||
12285 | recover(input,re); | ||
12286 | } | ||
12287 | finally { | ||
12288 | |||
12289 | restoreStackSize(stackSize); | ||
12290 | |||
12291 | } | ||
12292 | return ; | ||
12293 | } | ||
12294 | // $ANTLR end "rule__ALSIff__Group__0" | ||
12295 | |||
12296 | |||
12297 | // $ANTLR start "rule__ALSIff__Group__0__Impl" | ||
12298 | // InternalAlloyLanguage.g:4125:1: rule__ALSIff__Group__0__Impl : ( ruleALSImpl ) ; | ||
12299 | public final void rule__ALSIff__Group__0__Impl() throws RecognitionException { | ||
12300 | |||
12301 | int stackSize = keepStackSize(); | ||
12302 | |||
12303 | try { | ||
12304 | // InternalAlloyLanguage.g:4129:1: ( ( ruleALSImpl ) ) | ||
12305 | // InternalAlloyLanguage.g:4130:1: ( ruleALSImpl ) | ||
12306 | { | ||
12307 | // InternalAlloyLanguage.g:4130:1: ( ruleALSImpl ) | ||
12308 | // InternalAlloyLanguage.g:4131:1: ruleALSImpl | ||
12309 | { | ||
12310 | if ( state.backtracking==0 ) { | ||
12311 | before(grammarAccess.getALSIffAccess().getALSImplParserRuleCall_0()); | ||
12312 | } | ||
12313 | pushFollow(FOLLOW_2); | ||
12314 | ruleALSImpl(); | ||
12315 | |||
12316 | state._fsp--; | ||
12317 | if (state.failed) return ; | ||
12318 | if ( state.backtracking==0 ) { | ||
12319 | after(grammarAccess.getALSIffAccess().getALSImplParserRuleCall_0()); | ||
12320 | } | ||
12321 | |||
12322 | } | ||
12323 | |||
12324 | |||
12325 | } | ||
12326 | |||
12327 | } | ||
12328 | catch (RecognitionException re) { | ||
12329 | reportError(re); | ||
12330 | recover(input,re); | ||
12331 | } | ||
12332 | finally { | ||
12333 | |||
12334 | restoreStackSize(stackSize); | ||
12335 | |||
12336 | } | ||
12337 | return ; | ||
12338 | } | ||
12339 | // $ANTLR end "rule__ALSIff__Group__0__Impl" | ||
12340 | |||
12341 | |||
12342 | // $ANTLR start "rule__ALSIff__Group__1" | ||
12343 | // InternalAlloyLanguage.g:4142:1: rule__ALSIff__Group__1 : rule__ALSIff__Group__1__Impl ; | ||
12344 | public final void rule__ALSIff__Group__1() throws RecognitionException { | ||
12345 | |||
12346 | int stackSize = keepStackSize(); | ||
12347 | |||
12348 | try { | ||
12349 | // InternalAlloyLanguage.g:4146:1: ( rule__ALSIff__Group__1__Impl ) | ||
12350 | // InternalAlloyLanguage.g:4147:2: rule__ALSIff__Group__1__Impl | ||
12351 | { | ||
12352 | pushFollow(FOLLOW_2); | ||
12353 | rule__ALSIff__Group__1__Impl(); | ||
12354 | |||
12355 | state._fsp--; | ||
12356 | if (state.failed) return ; | ||
12357 | |||
12358 | } | ||
12359 | |||
12360 | } | ||
12361 | catch (RecognitionException re) { | ||
12362 | reportError(re); | ||
12363 | recover(input,re); | ||
12364 | } | ||
12365 | finally { | ||
12366 | |||
12367 | restoreStackSize(stackSize); | ||
12368 | |||
12369 | } | ||
12370 | return ; | ||
12371 | } | ||
12372 | // $ANTLR end "rule__ALSIff__Group__1" | ||
12373 | |||
12374 | |||
12375 | // $ANTLR start "rule__ALSIff__Group__1__Impl" | ||
12376 | // InternalAlloyLanguage.g:4153:1: rule__ALSIff__Group__1__Impl : ( ( rule__ALSIff__Group_1__0 )? ) ; | ||
12377 | public final void rule__ALSIff__Group__1__Impl() throws RecognitionException { | ||
12378 | |||
12379 | int stackSize = keepStackSize(); | ||
12380 | |||
12381 | try { | ||
12382 | // InternalAlloyLanguage.g:4157:1: ( ( ( rule__ALSIff__Group_1__0 )? ) ) | ||
12383 | // InternalAlloyLanguage.g:4158:1: ( ( rule__ALSIff__Group_1__0 )? ) | ||
12384 | { | ||
12385 | // InternalAlloyLanguage.g:4158:1: ( ( rule__ALSIff__Group_1__0 )? ) | ||
12386 | // InternalAlloyLanguage.g:4159:1: ( rule__ALSIff__Group_1__0 )? | ||
12387 | { | ||
12388 | if ( state.backtracking==0 ) { | ||
12389 | before(grammarAccess.getALSIffAccess().getGroup_1()); | ||
12390 | } | ||
12391 | // InternalAlloyLanguage.g:4160:1: ( rule__ALSIff__Group_1__0 )? | ||
12392 | int alt31=2; | ||
12393 | int LA31_0 = input.LA(1); | ||
12394 | |||
12395 | if ( ((LA31_0>=13 && LA31_0<=14)) ) { | ||
12396 | alt31=1; | ||
12397 | } | ||
12398 | switch (alt31) { | ||
12399 | case 1 : | ||
12400 | // InternalAlloyLanguage.g:4160:2: rule__ALSIff__Group_1__0 | ||
12401 | { | ||
12402 | pushFollow(FOLLOW_2); | ||
12403 | rule__ALSIff__Group_1__0(); | ||
12404 | |||
12405 | state._fsp--; | ||
12406 | if (state.failed) return ; | ||
12407 | |||
12408 | } | ||
12409 | break; | ||
12410 | |||
12411 | } | ||
12412 | |||
12413 | if ( state.backtracking==0 ) { | ||
12414 | after(grammarAccess.getALSIffAccess().getGroup_1()); | ||
12415 | } | ||
12416 | |||
12417 | } | ||
12418 | |||
12419 | |||
12420 | } | ||
12421 | |||
12422 | } | ||
12423 | catch (RecognitionException re) { | ||
12424 | reportError(re); | ||
12425 | recover(input,re); | ||
12426 | } | ||
12427 | finally { | ||
12428 | |||
12429 | restoreStackSize(stackSize); | ||
12430 | |||
12431 | } | ||
12432 | return ; | ||
12433 | } | ||
12434 | // $ANTLR end "rule__ALSIff__Group__1__Impl" | ||
12435 | |||
12436 | |||
12437 | // $ANTLR start "rule__ALSIff__Group_1__0" | ||
12438 | // InternalAlloyLanguage.g:4174:1: rule__ALSIff__Group_1__0 : rule__ALSIff__Group_1__0__Impl rule__ALSIff__Group_1__1 ; | ||
12439 | public final void rule__ALSIff__Group_1__0() throws RecognitionException { | ||
12440 | |||
12441 | int stackSize = keepStackSize(); | ||
12442 | |||
12443 | try { | ||
12444 | // InternalAlloyLanguage.g:4178:1: ( rule__ALSIff__Group_1__0__Impl rule__ALSIff__Group_1__1 ) | ||
12445 | // InternalAlloyLanguage.g:4179:2: rule__ALSIff__Group_1__0__Impl rule__ALSIff__Group_1__1 | ||
12446 | { | ||
12447 | pushFollow(FOLLOW_26); | ||
12448 | rule__ALSIff__Group_1__0__Impl(); | ||
12449 | |||
12450 | state._fsp--; | ||
12451 | if (state.failed) return ; | ||
12452 | pushFollow(FOLLOW_2); | ||
12453 | rule__ALSIff__Group_1__1(); | ||
12454 | |||
12455 | state._fsp--; | ||
12456 | if (state.failed) return ; | ||
12457 | |||
12458 | } | ||
12459 | |||
12460 | } | ||
12461 | catch (RecognitionException re) { | ||
12462 | reportError(re); | ||
12463 | recover(input,re); | ||
12464 | } | ||
12465 | finally { | ||
12466 | |||
12467 | restoreStackSize(stackSize); | ||
12468 | |||
12469 | } | ||
12470 | return ; | ||
12471 | } | ||
12472 | // $ANTLR end "rule__ALSIff__Group_1__0" | ||
12473 | |||
12474 | |||
12475 | // $ANTLR start "rule__ALSIff__Group_1__0__Impl" | ||
12476 | // InternalAlloyLanguage.g:4186:1: rule__ALSIff__Group_1__0__Impl : ( () ) ; | ||
12477 | public final void rule__ALSIff__Group_1__0__Impl() throws RecognitionException { | ||
12478 | |||
12479 | int stackSize = keepStackSize(); | ||
12480 | |||
12481 | try { | ||
12482 | // InternalAlloyLanguage.g:4190:1: ( ( () ) ) | ||
12483 | // InternalAlloyLanguage.g:4191:1: ( () ) | ||
12484 | { | ||
12485 | // InternalAlloyLanguage.g:4191:1: ( () ) | ||
12486 | // InternalAlloyLanguage.g:4192:1: () | ||
12487 | { | ||
12488 | if ( state.backtracking==0 ) { | ||
12489 | before(grammarAccess.getALSIffAccess().getALSIffLeftOperandAction_1_0()); | ||
12490 | } | ||
12491 | // InternalAlloyLanguage.g:4193:1: () | ||
12492 | // InternalAlloyLanguage.g:4195:1: | ||
12493 | { | ||
12494 | } | ||
12495 | |||
12496 | if ( state.backtracking==0 ) { | ||
12497 | after(grammarAccess.getALSIffAccess().getALSIffLeftOperandAction_1_0()); | ||
12498 | } | ||
12499 | |||
12500 | } | ||
12501 | |||
12502 | |||
12503 | } | ||
12504 | |||
12505 | } | ||
12506 | finally { | ||
12507 | |||
12508 | restoreStackSize(stackSize); | ||
12509 | |||
12510 | } | ||
12511 | return ; | ||
12512 | } | ||
12513 | // $ANTLR end "rule__ALSIff__Group_1__0__Impl" | ||
12514 | |||
12515 | |||
12516 | // $ANTLR start "rule__ALSIff__Group_1__1" | ||
12517 | // InternalAlloyLanguage.g:4205:1: rule__ALSIff__Group_1__1 : rule__ALSIff__Group_1__1__Impl rule__ALSIff__Group_1__2 ; | ||
12518 | public final void rule__ALSIff__Group_1__1() throws RecognitionException { | ||
12519 | |||
12520 | int stackSize = keepStackSize(); | ||
12521 | |||
12522 | try { | ||
12523 | // InternalAlloyLanguage.g:4209:1: ( rule__ALSIff__Group_1__1__Impl rule__ALSIff__Group_1__2 ) | ||
12524 | // InternalAlloyLanguage.g:4210:2: rule__ALSIff__Group_1__1__Impl rule__ALSIff__Group_1__2 | ||
12525 | { | ||
12526 | pushFollow(FOLLOW_16); | ||
12527 | rule__ALSIff__Group_1__1__Impl(); | ||
12528 | |||
12529 | state._fsp--; | ||
12530 | if (state.failed) return ; | ||
12531 | pushFollow(FOLLOW_2); | ||
12532 | rule__ALSIff__Group_1__2(); | ||
12533 | |||
12534 | state._fsp--; | ||
12535 | if (state.failed) return ; | ||
12536 | |||
12537 | } | ||
12538 | |||
12539 | } | ||
12540 | catch (RecognitionException re) { | ||
12541 | reportError(re); | ||
12542 | recover(input,re); | ||
12543 | } | ||
12544 | finally { | ||
12545 | |||
12546 | restoreStackSize(stackSize); | ||
12547 | |||
12548 | } | ||
12549 | return ; | ||
12550 | } | ||
12551 | // $ANTLR end "rule__ALSIff__Group_1__1" | ||
12552 | |||
12553 | |||
12554 | // $ANTLR start "rule__ALSIff__Group_1__1__Impl" | ||
12555 | // InternalAlloyLanguage.g:4217:1: rule__ALSIff__Group_1__1__Impl : ( ( rule__ALSIff__Alternatives_1_1 ) ) ; | ||
12556 | public final void rule__ALSIff__Group_1__1__Impl() throws RecognitionException { | ||
12557 | |||
12558 | int stackSize = keepStackSize(); | ||
12559 | |||
12560 | try { | ||
12561 | // InternalAlloyLanguage.g:4221:1: ( ( ( rule__ALSIff__Alternatives_1_1 ) ) ) | ||
12562 | // InternalAlloyLanguage.g:4222:1: ( ( rule__ALSIff__Alternatives_1_1 ) ) | ||
12563 | { | ||
12564 | // InternalAlloyLanguage.g:4222:1: ( ( rule__ALSIff__Alternatives_1_1 ) ) | ||
12565 | // InternalAlloyLanguage.g:4223:1: ( rule__ALSIff__Alternatives_1_1 ) | ||
12566 | { | ||
12567 | if ( state.backtracking==0 ) { | ||
12568 | before(grammarAccess.getALSIffAccess().getAlternatives_1_1()); | ||
12569 | } | ||
12570 | // InternalAlloyLanguage.g:4224:1: ( rule__ALSIff__Alternatives_1_1 ) | ||
12571 | // InternalAlloyLanguage.g:4224:2: rule__ALSIff__Alternatives_1_1 | ||
12572 | { | ||
12573 | pushFollow(FOLLOW_2); | ||
12574 | rule__ALSIff__Alternatives_1_1(); | ||
12575 | |||
12576 | state._fsp--; | ||
12577 | if (state.failed) return ; | ||
12578 | |||
12579 | } | ||
12580 | |||
12581 | if ( state.backtracking==0 ) { | ||
12582 | after(grammarAccess.getALSIffAccess().getAlternatives_1_1()); | ||
12583 | } | ||
12584 | |||
12585 | } | ||
12586 | |||
12587 | |||
12588 | } | ||
12589 | |||
12590 | } | ||
12591 | catch (RecognitionException re) { | ||
12592 | reportError(re); | ||
12593 | recover(input,re); | ||
12594 | } | ||
12595 | finally { | ||
12596 | |||
12597 | restoreStackSize(stackSize); | ||
12598 | |||
12599 | } | ||
12600 | return ; | ||
12601 | } | ||
12602 | // $ANTLR end "rule__ALSIff__Group_1__1__Impl" | ||
12603 | |||
12604 | |||
12605 | // $ANTLR start "rule__ALSIff__Group_1__2" | ||
12606 | // InternalAlloyLanguage.g:4234:1: rule__ALSIff__Group_1__2 : rule__ALSIff__Group_1__2__Impl ; | ||
12607 | public final void rule__ALSIff__Group_1__2() throws RecognitionException { | ||
12608 | |||
12609 | int stackSize = keepStackSize(); | ||
12610 | |||
12611 | try { | ||
12612 | // InternalAlloyLanguage.g:4238:1: ( rule__ALSIff__Group_1__2__Impl ) | ||
12613 | // InternalAlloyLanguage.g:4239:2: rule__ALSIff__Group_1__2__Impl | ||
12614 | { | ||
12615 | pushFollow(FOLLOW_2); | ||
12616 | rule__ALSIff__Group_1__2__Impl(); | ||
12617 | |||
12618 | state._fsp--; | ||
12619 | if (state.failed) return ; | ||
12620 | |||
12621 | } | ||
12622 | |||
12623 | } | ||
12624 | catch (RecognitionException re) { | ||
12625 | reportError(re); | ||
12626 | recover(input,re); | ||
12627 | } | ||
12628 | finally { | ||
12629 | |||
12630 | restoreStackSize(stackSize); | ||
12631 | |||
12632 | } | ||
12633 | return ; | ||
12634 | } | ||
12635 | // $ANTLR end "rule__ALSIff__Group_1__2" | ||
12636 | |||
12637 | |||
12638 | // $ANTLR start "rule__ALSIff__Group_1__2__Impl" | ||
12639 | // InternalAlloyLanguage.g:4245:1: rule__ALSIff__Group_1__2__Impl : ( ( rule__ALSIff__RightOperandAssignment_1_2 ) ) ; | ||
12640 | public final void rule__ALSIff__Group_1__2__Impl() throws RecognitionException { | ||
12641 | |||
12642 | int stackSize = keepStackSize(); | ||
12643 | |||
12644 | try { | ||
12645 | // InternalAlloyLanguage.g:4249:1: ( ( ( rule__ALSIff__RightOperandAssignment_1_2 ) ) ) | ||
12646 | // InternalAlloyLanguage.g:4250:1: ( ( rule__ALSIff__RightOperandAssignment_1_2 ) ) | ||
12647 | { | ||
12648 | // InternalAlloyLanguage.g:4250:1: ( ( rule__ALSIff__RightOperandAssignment_1_2 ) ) | ||
12649 | // InternalAlloyLanguage.g:4251:1: ( rule__ALSIff__RightOperandAssignment_1_2 ) | ||
12650 | { | ||
12651 | if ( state.backtracking==0 ) { | ||
12652 | before(grammarAccess.getALSIffAccess().getRightOperandAssignment_1_2()); | ||
12653 | } | ||
12654 | // InternalAlloyLanguage.g:4252:1: ( rule__ALSIff__RightOperandAssignment_1_2 ) | ||
12655 | // InternalAlloyLanguage.g:4252:2: rule__ALSIff__RightOperandAssignment_1_2 | ||
12656 | { | ||
12657 | pushFollow(FOLLOW_2); | ||
12658 | rule__ALSIff__RightOperandAssignment_1_2(); | ||
12659 | |||
12660 | state._fsp--; | ||
12661 | if (state.failed) return ; | ||
12662 | |||
12663 | } | ||
12664 | |||
12665 | if ( state.backtracking==0 ) { | ||
12666 | after(grammarAccess.getALSIffAccess().getRightOperandAssignment_1_2()); | ||
12667 | } | ||
12668 | |||
12669 | } | ||
12670 | |||
12671 | |||
12672 | } | ||
12673 | |||
12674 | } | ||
12675 | catch (RecognitionException re) { | ||
12676 | reportError(re); | ||
12677 | recover(input,re); | ||
12678 | } | ||
12679 | finally { | ||
12680 | |||
12681 | restoreStackSize(stackSize); | ||
12682 | |||
12683 | } | ||
12684 | return ; | ||
12685 | } | ||
12686 | // $ANTLR end "rule__ALSIff__Group_1__2__Impl" | ||
12687 | |||
12688 | |||
12689 | // $ANTLR start "rule__ALSImpl__Group__0" | ||
12690 | // InternalAlloyLanguage.g:4268:1: rule__ALSImpl__Group__0 : rule__ALSImpl__Group__0__Impl rule__ALSImpl__Group__1 ; | ||
12691 | public final void rule__ALSImpl__Group__0() throws RecognitionException { | ||
12692 | |||
12693 | int stackSize = keepStackSize(); | ||
12694 | |||
12695 | try { | ||
12696 | // InternalAlloyLanguage.g:4272:1: ( rule__ALSImpl__Group__0__Impl rule__ALSImpl__Group__1 ) | ||
12697 | // InternalAlloyLanguage.g:4273:2: rule__ALSImpl__Group__0__Impl rule__ALSImpl__Group__1 | ||
12698 | { | ||
12699 | pushFollow(FOLLOW_27); | ||
12700 | rule__ALSImpl__Group__0__Impl(); | ||
12701 | |||
12702 | state._fsp--; | ||
12703 | if (state.failed) return ; | ||
12704 | pushFollow(FOLLOW_2); | ||
12705 | rule__ALSImpl__Group__1(); | ||
12706 | |||
12707 | state._fsp--; | ||
12708 | if (state.failed) return ; | ||
12709 | |||
12710 | } | ||
12711 | |||
12712 | } | ||
12713 | catch (RecognitionException re) { | ||
12714 | reportError(re); | ||
12715 | recover(input,re); | ||
12716 | } | ||
12717 | finally { | ||
12718 | |||
12719 | restoreStackSize(stackSize); | ||
12720 | |||
12721 | } | ||
12722 | return ; | ||
12723 | } | ||
12724 | // $ANTLR end "rule__ALSImpl__Group__0" | ||
12725 | |||
12726 | |||
12727 | // $ANTLR start "rule__ALSImpl__Group__0__Impl" | ||
12728 | // InternalAlloyLanguage.g:4280:1: rule__ALSImpl__Group__0__Impl : ( ruleALSAnd ) ; | ||
12729 | public final void rule__ALSImpl__Group__0__Impl() throws RecognitionException { | ||
12730 | |||
12731 | int stackSize = keepStackSize(); | ||
12732 | |||
12733 | try { | ||
12734 | // InternalAlloyLanguage.g:4284:1: ( ( ruleALSAnd ) ) | ||
12735 | // InternalAlloyLanguage.g:4285:1: ( ruleALSAnd ) | ||
12736 | { | ||
12737 | // InternalAlloyLanguage.g:4285:1: ( ruleALSAnd ) | ||
12738 | // InternalAlloyLanguage.g:4286:1: ruleALSAnd | ||
12739 | { | ||
12740 | if ( state.backtracking==0 ) { | ||
12741 | before(grammarAccess.getALSImplAccess().getALSAndParserRuleCall_0()); | ||
12742 | } | ||
12743 | pushFollow(FOLLOW_2); | ||
12744 | ruleALSAnd(); | ||
12745 | |||
12746 | state._fsp--; | ||
12747 | if (state.failed) return ; | ||
12748 | if ( state.backtracking==0 ) { | ||
12749 | after(grammarAccess.getALSImplAccess().getALSAndParserRuleCall_0()); | ||
12750 | } | ||
12751 | |||
12752 | } | ||
12753 | |||
12754 | |||
12755 | } | ||
12756 | |||
12757 | } | ||
12758 | catch (RecognitionException re) { | ||
12759 | reportError(re); | ||
12760 | recover(input,re); | ||
12761 | } | ||
12762 | finally { | ||
12763 | |||
12764 | restoreStackSize(stackSize); | ||
12765 | |||
12766 | } | ||
12767 | return ; | ||
12768 | } | ||
12769 | // $ANTLR end "rule__ALSImpl__Group__0__Impl" | ||
12770 | |||
12771 | |||
12772 | // $ANTLR start "rule__ALSImpl__Group__1" | ||
12773 | // InternalAlloyLanguage.g:4297:1: rule__ALSImpl__Group__1 : rule__ALSImpl__Group__1__Impl ; | ||
12774 | public final void rule__ALSImpl__Group__1() throws RecognitionException { | ||
12775 | |||
12776 | int stackSize = keepStackSize(); | ||
12777 | |||
12778 | try { | ||
12779 | // InternalAlloyLanguage.g:4301:1: ( rule__ALSImpl__Group__1__Impl ) | ||
12780 | // InternalAlloyLanguage.g:4302:2: rule__ALSImpl__Group__1__Impl | ||
12781 | { | ||
12782 | pushFollow(FOLLOW_2); | ||
12783 | rule__ALSImpl__Group__1__Impl(); | ||
12784 | |||
12785 | state._fsp--; | ||
12786 | if (state.failed) return ; | ||
12787 | |||
12788 | } | ||
12789 | |||
12790 | } | ||
12791 | catch (RecognitionException re) { | ||
12792 | reportError(re); | ||
12793 | recover(input,re); | ||
12794 | } | ||
12795 | finally { | ||
12796 | |||
12797 | restoreStackSize(stackSize); | ||
12798 | |||
12799 | } | ||
12800 | return ; | ||
12801 | } | ||
12802 | // $ANTLR end "rule__ALSImpl__Group__1" | ||
12803 | |||
12804 | |||
12805 | // $ANTLR start "rule__ALSImpl__Group__1__Impl" | ||
12806 | // InternalAlloyLanguage.g:4308:1: rule__ALSImpl__Group__1__Impl : ( ( rule__ALSImpl__Group_1__0 )? ) ; | ||
12807 | public final void rule__ALSImpl__Group__1__Impl() throws RecognitionException { | ||
12808 | |||
12809 | int stackSize = keepStackSize(); | ||
12810 | |||
12811 | try { | ||
12812 | // InternalAlloyLanguage.g:4312:1: ( ( ( rule__ALSImpl__Group_1__0 )? ) ) | ||
12813 | // InternalAlloyLanguage.g:4313:1: ( ( rule__ALSImpl__Group_1__0 )? ) | ||
12814 | { | ||
12815 | // InternalAlloyLanguage.g:4313:1: ( ( rule__ALSImpl__Group_1__0 )? ) | ||
12816 | // InternalAlloyLanguage.g:4314:1: ( rule__ALSImpl__Group_1__0 )? | ||
12817 | { | ||
12818 | if ( state.backtracking==0 ) { | ||
12819 | before(grammarAccess.getALSImplAccess().getGroup_1()); | ||
12820 | } | ||
12821 | // InternalAlloyLanguage.g:4315:1: ( rule__ALSImpl__Group_1__0 )? | ||
12822 | int alt32=2; | ||
12823 | int LA32_0 = input.LA(1); | ||
12824 | |||
12825 | if ( ((LA32_0>=15 && LA32_0<=16)) ) { | ||
12826 | alt32=1; | ||
12827 | } | ||
12828 | switch (alt32) { | ||
12829 | case 1 : | ||
12830 | // InternalAlloyLanguage.g:4315:2: rule__ALSImpl__Group_1__0 | ||
12831 | { | ||
12832 | pushFollow(FOLLOW_2); | ||
12833 | rule__ALSImpl__Group_1__0(); | ||
12834 | |||
12835 | state._fsp--; | ||
12836 | if (state.failed) return ; | ||
12837 | |||
12838 | } | ||
12839 | break; | ||
12840 | |||
12841 | } | ||
12842 | |||
12843 | if ( state.backtracking==0 ) { | ||
12844 | after(grammarAccess.getALSImplAccess().getGroup_1()); | ||
12845 | } | ||
12846 | |||
12847 | } | ||
12848 | |||
12849 | |||
12850 | } | ||
12851 | |||
12852 | } | ||
12853 | catch (RecognitionException re) { | ||
12854 | reportError(re); | ||
12855 | recover(input,re); | ||
12856 | } | ||
12857 | finally { | ||
12858 | |||
12859 | restoreStackSize(stackSize); | ||
12860 | |||
12861 | } | ||
12862 | return ; | ||
12863 | } | ||
12864 | // $ANTLR end "rule__ALSImpl__Group__1__Impl" | ||
12865 | |||
12866 | |||
12867 | // $ANTLR start "rule__ALSImpl__Group_1__0" | ||
12868 | // InternalAlloyLanguage.g:4329:1: rule__ALSImpl__Group_1__0 : rule__ALSImpl__Group_1__0__Impl rule__ALSImpl__Group_1__1 ; | ||
12869 | public final void rule__ALSImpl__Group_1__0() throws RecognitionException { | ||
12870 | |||
12871 | int stackSize = keepStackSize(); | ||
12872 | |||
12873 | try { | ||
12874 | // InternalAlloyLanguage.g:4333:1: ( rule__ALSImpl__Group_1__0__Impl rule__ALSImpl__Group_1__1 ) | ||
12875 | // InternalAlloyLanguage.g:4334:2: rule__ALSImpl__Group_1__0__Impl rule__ALSImpl__Group_1__1 | ||
12876 | { | ||
12877 | pushFollow(FOLLOW_27); | ||
12878 | rule__ALSImpl__Group_1__0__Impl(); | ||
12879 | |||
12880 | state._fsp--; | ||
12881 | if (state.failed) return ; | ||
12882 | pushFollow(FOLLOW_2); | ||
12883 | rule__ALSImpl__Group_1__1(); | ||
12884 | |||
12885 | state._fsp--; | ||
12886 | if (state.failed) return ; | ||
12887 | |||
12888 | } | ||
12889 | |||
12890 | } | ||
12891 | catch (RecognitionException re) { | ||
12892 | reportError(re); | ||
12893 | recover(input,re); | ||
12894 | } | ||
12895 | finally { | ||
12896 | |||
12897 | restoreStackSize(stackSize); | ||
12898 | |||
12899 | } | ||
12900 | return ; | ||
12901 | } | ||
12902 | // $ANTLR end "rule__ALSImpl__Group_1__0" | ||
12903 | |||
12904 | |||
12905 | // $ANTLR start "rule__ALSImpl__Group_1__0__Impl" | ||
12906 | // InternalAlloyLanguage.g:4341:1: rule__ALSImpl__Group_1__0__Impl : ( () ) ; | ||
12907 | public final void rule__ALSImpl__Group_1__0__Impl() throws RecognitionException { | ||
12908 | |||
12909 | int stackSize = keepStackSize(); | ||
12910 | |||
12911 | try { | ||
12912 | // InternalAlloyLanguage.g:4345:1: ( ( () ) ) | ||
12913 | // InternalAlloyLanguage.g:4346:1: ( () ) | ||
12914 | { | ||
12915 | // InternalAlloyLanguage.g:4346:1: ( () ) | ||
12916 | // InternalAlloyLanguage.g:4347:1: () | ||
12917 | { | ||
12918 | if ( state.backtracking==0 ) { | ||
12919 | before(grammarAccess.getALSImplAccess().getALSImplLeftOperandAction_1_0()); | ||
12920 | } | ||
12921 | // InternalAlloyLanguage.g:4348:1: () | ||
12922 | // InternalAlloyLanguage.g:4350:1: | ||
12923 | { | ||
12924 | } | ||
12925 | |||
12926 | if ( state.backtracking==0 ) { | ||
12927 | after(grammarAccess.getALSImplAccess().getALSImplLeftOperandAction_1_0()); | ||
12928 | } | ||
12929 | |||
12930 | } | ||
12931 | |||
12932 | |||
12933 | } | ||
12934 | |||
12935 | } | ||
12936 | finally { | ||
12937 | |||
12938 | restoreStackSize(stackSize); | ||
12939 | |||
12940 | } | ||
12941 | return ; | ||
12942 | } | ||
12943 | // $ANTLR end "rule__ALSImpl__Group_1__0__Impl" | ||
12944 | |||
12945 | |||
12946 | // $ANTLR start "rule__ALSImpl__Group_1__1" | ||
12947 | // InternalAlloyLanguage.g:4360:1: rule__ALSImpl__Group_1__1 : rule__ALSImpl__Group_1__1__Impl rule__ALSImpl__Group_1__2 ; | ||
12948 | public final void rule__ALSImpl__Group_1__1() throws RecognitionException { | ||
12949 | |||
12950 | int stackSize = keepStackSize(); | ||
12951 | |||
12952 | try { | ||
12953 | // InternalAlloyLanguage.g:4364:1: ( rule__ALSImpl__Group_1__1__Impl rule__ALSImpl__Group_1__2 ) | ||
12954 | // InternalAlloyLanguage.g:4365:2: rule__ALSImpl__Group_1__1__Impl rule__ALSImpl__Group_1__2 | ||
12955 | { | ||
12956 | pushFollow(FOLLOW_16); | ||
12957 | rule__ALSImpl__Group_1__1__Impl(); | ||
12958 | |||
12959 | state._fsp--; | ||
12960 | if (state.failed) return ; | ||
12961 | pushFollow(FOLLOW_2); | ||
12962 | rule__ALSImpl__Group_1__2(); | ||
12963 | |||
12964 | state._fsp--; | ||
12965 | if (state.failed) return ; | ||
12966 | |||
12967 | } | ||
12968 | |||
12969 | } | ||
12970 | catch (RecognitionException re) { | ||
12971 | reportError(re); | ||
12972 | recover(input,re); | ||
12973 | } | ||
12974 | finally { | ||
12975 | |||
12976 | restoreStackSize(stackSize); | ||
12977 | |||
12978 | } | ||
12979 | return ; | ||
12980 | } | ||
12981 | // $ANTLR end "rule__ALSImpl__Group_1__1" | ||
12982 | |||
12983 | |||
12984 | // $ANTLR start "rule__ALSImpl__Group_1__1__Impl" | ||
12985 | // InternalAlloyLanguage.g:4372:1: rule__ALSImpl__Group_1__1__Impl : ( ( rule__ALSImpl__Alternatives_1_1 ) ) ; | ||
12986 | public final void rule__ALSImpl__Group_1__1__Impl() throws RecognitionException { | ||
12987 | |||
12988 | int stackSize = keepStackSize(); | ||
12989 | |||
12990 | try { | ||
12991 | // InternalAlloyLanguage.g:4376:1: ( ( ( rule__ALSImpl__Alternatives_1_1 ) ) ) | ||
12992 | // InternalAlloyLanguage.g:4377:1: ( ( rule__ALSImpl__Alternatives_1_1 ) ) | ||
12993 | { | ||
12994 | // InternalAlloyLanguage.g:4377:1: ( ( rule__ALSImpl__Alternatives_1_1 ) ) | ||
12995 | // InternalAlloyLanguage.g:4378:1: ( rule__ALSImpl__Alternatives_1_1 ) | ||
12996 | { | ||
12997 | if ( state.backtracking==0 ) { | ||
12998 | before(grammarAccess.getALSImplAccess().getAlternatives_1_1()); | ||
12999 | } | ||
13000 | // InternalAlloyLanguage.g:4379:1: ( rule__ALSImpl__Alternatives_1_1 ) | ||
13001 | // InternalAlloyLanguage.g:4379:2: rule__ALSImpl__Alternatives_1_1 | ||
13002 | { | ||
13003 | pushFollow(FOLLOW_2); | ||
13004 | rule__ALSImpl__Alternatives_1_1(); | ||
13005 | |||
13006 | state._fsp--; | ||
13007 | if (state.failed) return ; | ||
13008 | |||
13009 | } | ||
13010 | |||
13011 | if ( state.backtracking==0 ) { | ||
13012 | after(grammarAccess.getALSImplAccess().getAlternatives_1_1()); | ||
13013 | } | ||
13014 | |||
13015 | } | ||
13016 | |||
13017 | |||
13018 | } | ||
13019 | |||
13020 | } | ||
13021 | catch (RecognitionException re) { | ||
13022 | reportError(re); | ||
13023 | recover(input,re); | ||
13024 | } | ||
13025 | finally { | ||
13026 | |||
13027 | restoreStackSize(stackSize); | ||
13028 | |||
13029 | } | ||
13030 | return ; | ||
13031 | } | ||
13032 | // $ANTLR end "rule__ALSImpl__Group_1__1__Impl" | ||
13033 | |||
13034 | |||
13035 | // $ANTLR start "rule__ALSImpl__Group_1__2" | ||
13036 | // InternalAlloyLanguage.g:4389:1: rule__ALSImpl__Group_1__2 : rule__ALSImpl__Group_1__2__Impl rule__ALSImpl__Group_1__3 ; | ||
13037 | public final void rule__ALSImpl__Group_1__2() throws RecognitionException { | ||
13038 | |||
13039 | int stackSize = keepStackSize(); | ||
13040 | |||
13041 | try { | ||
13042 | // InternalAlloyLanguage.g:4393:1: ( rule__ALSImpl__Group_1__2__Impl rule__ALSImpl__Group_1__3 ) | ||
13043 | // InternalAlloyLanguage.g:4394:2: rule__ALSImpl__Group_1__2__Impl rule__ALSImpl__Group_1__3 | ||
13044 | { | ||
13045 | pushFollow(FOLLOW_28); | ||
13046 | rule__ALSImpl__Group_1__2__Impl(); | ||
13047 | |||
13048 | state._fsp--; | ||
13049 | if (state.failed) return ; | ||
13050 | pushFollow(FOLLOW_2); | ||
13051 | rule__ALSImpl__Group_1__3(); | ||
13052 | |||
13053 | state._fsp--; | ||
13054 | if (state.failed) return ; | ||
13055 | |||
13056 | } | ||
13057 | |||
13058 | } | ||
13059 | catch (RecognitionException re) { | ||
13060 | reportError(re); | ||
13061 | recover(input,re); | ||
13062 | } | ||
13063 | finally { | ||
13064 | |||
13065 | restoreStackSize(stackSize); | ||
13066 | |||
13067 | } | ||
13068 | return ; | ||
13069 | } | ||
13070 | // $ANTLR end "rule__ALSImpl__Group_1__2" | ||
13071 | |||
13072 | |||
13073 | // $ANTLR start "rule__ALSImpl__Group_1__2__Impl" | ||
13074 | // InternalAlloyLanguage.g:4401:1: rule__ALSImpl__Group_1__2__Impl : ( ( rule__ALSImpl__RightOperandAssignment_1_2 ) ) ; | ||
13075 | public final void rule__ALSImpl__Group_1__2__Impl() throws RecognitionException { | ||
13076 | |||
13077 | int stackSize = keepStackSize(); | ||
13078 | |||
13079 | try { | ||
13080 | // InternalAlloyLanguage.g:4405:1: ( ( ( rule__ALSImpl__RightOperandAssignment_1_2 ) ) ) | ||
13081 | // InternalAlloyLanguage.g:4406:1: ( ( rule__ALSImpl__RightOperandAssignment_1_2 ) ) | ||
13082 | { | ||
13083 | // InternalAlloyLanguage.g:4406:1: ( ( rule__ALSImpl__RightOperandAssignment_1_2 ) ) | ||
13084 | // InternalAlloyLanguage.g:4407:1: ( rule__ALSImpl__RightOperandAssignment_1_2 ) | ||
13085 | { | ||
13086 | if ( state.backtracking==0 ) { | ||
13087 | before(grammarAccess.getALSImplAccess().getRightOperandAssignment_1_2()); | ||
13088 | } | ||
13089 | // InternalAlloyLanguage.g:4408:1: ( rule__ALSImpl__RightOperandAssignment_1_2 ) | ||
13090 | // InternalAlloyLanguage.g:4408:2: rule__ALSImpl__RightOperandAssignment_1_2 | ||
13091 | { | ||
13092 | pushFollow(FOLLOW_2); | ||
13093 | rule__ALSImpl__RightOperandAssignment_1_2(); | ||
13094 | |||
13095 | state._fsp--; | ||
13096 | if (state.failed) return ; | ||
13097 | |||
13098 | } | ||
13099 | |||
13100 | if ( state.backtracking==0 ) { | ||
13101 | after(grammarAccess.getALSImplAccess().getRightOperandAssignment_1_2()); | ||
13102 | } | ||
13103 | |||
13104 | } | ||
13105 | |||
13106 | |||
13107 | } | ||
13108 | |||
13109 | } | ||
13110 | catch (RecognitionException re) { | ||
13111 | reportError(re); | ||
13112 | recover(input,re); | ||
13113 | } | ||
13114 | finally { | ||
13115 | |||
13116 | restoreStackSize(stackSize); | ||
13117 | |||
13118 | } | ||
13119 | return ; | ||
13120 | } | ||
13121 | // $ANTLR end "rule__ALSImpl__Group_1__2__Impl" | ||
13122 | |||
13123 | |||
13124 | // $ANTLR start "rule__ALSImpl__Group_1__3" | ||
13125 | // InternalAlloyLanguage.g:4418:1: rule__ALSImpl__Group_1__3 : rule__ALSImpl__Group_1__3__Impl ; | ||
13126 | public final void rule__ALSImpl__Group_1__3() throws RecognitionException { | ||
13127 | |||
13128 | int stackSize = keepStackSize(); | ||
13129 | |||
13130 | try { | ||
13131 | // InternalAlloyLanguage.g:4422:1: ( rule__ALSImpl__Group_1__3__Impl ) | ||
13132 | // InternalAlloyLanguage.g:4423:2: rule__ALSImpl__Group_1__3__Impl | ||
13133 | { | ||
13134 | pushFollow(FOLLOW_2); | ||
13135 | rule__ALSImpl__Group_1__3__Impl(); | ||
13136 | |||
13137 | state._fsp--; | ||
13138 | if (state.failed) return ; | ||
13139 | |||
13140 | } | ||
13141 | |||
13142 | } | ||
13143 | catch (RecognitionException re) { | ||
13144 | reportError(re); | ||
13145 | recover(input,re); | ||
13146 | } | ||
13147 | finally { | ||
13148 | |||
13149 | restoreStackSize(stackSize); | ||
13150 | |||
13151 | } | ||
13152 | return ; | ||
13153 | } | ||
13154 | // $ANTLR end "rule__ALSImpl__Group_1__3" | ||
13155 | |||
13156 | |||
13157 | // $ANTLR start "rule__ALSImpl__Group_1__3__Impl" | ||
13158 | // InternalAlloyLanguage.g:4429:1: rule__ALSImpl__Group_1__3__Impl : ( ( rule__ALSImpl__Group_1_3__0 )? ) ; | ||
13159 | public final void rule__ALSImpl__Group_1__3__Impl() throws RecognitionException { | ||
13160 | |||
13161 | int stackSize = keepStackSize(); | ||
13162 | |||
13163 | try { | ||
13164 | // InternalAlloyLanguage.g:4433:1: ( ( ( rule__ALSImpl__Group_1_3__0 )? ) ) | ||
13165 | // InternalAlloyLanguage.g:4434:1: ( ( rule__ALSImpl__Group_1_3__0 )? ) | ||
13166 | { | ||
13167 | // InternalAlloyLanguage.g:4434:1: ( ( rule__ALSImpl__Group_1_3__0 )? ) | ||
13168 | // InternalAlloyLanguage.g:4435:1: ( rule__ALSImpl__Group_1_3__0 )? | ||
13169 | { | ||
13170 | if ( state.backtracking==0 ) { | ||
13171 | before(grammarAccess.getALSImplAccess().getGroup_1_3()); | ||
13172 | } | ||
13173 | // InternalAlloyLanguage.g:4436:1: ( rule__ALSImpl__Group_1_3__0 )? | ||
13174 | int alt33=2; | ||
13175 | int LA33_0 = input.LA(1); | ||
13176 | |||
13177 | if ( (LA33_0==46) ) { | ||
13178 | alt33=1; | ||
13179 | } | ||
13180 | switch (alt33) { | ||
13181 | case 1 : | ||
13182 | // InternalAlloyLanguage.g:4436:2: rule__ALSImpl__Group_1_3__0 | ||
13183 | { | ||
13184 | pushFollow(FOLLOW_2); | ||
13185 | rule__ALSImpl__Group_1_3__0(); | ||
13186 | |||
13187 | state._fsp--; | ||
13188 | if (state.failed) return ; | ||
13189 | |||
13190 | } | ||
13191 | break; | ||
13192 | |||
13193 | } | ||
13194 | |||
13195 | if ( state.backtracking==0 ) { | ||
13196 | after(grammarAccess.getALSImplAccess().getGroup_1_3()); | ||
13197 | } | ||
13198 | |||
13199 | } | ||
13200 | |||
13201 | |||
13202 | } | ||
13203 | |||
13204 | } | ||
13205 | catch (RecognitionException re) { | ||
13206 | reportError(re); | ||
13207 | recover(input,re); | ||
13208 | } | ||
13209 | finally { | ||
13210 | |||
13211 | restoreStackSize(stackSize); | ||
13212 | |||
13213 | } | ||
13214 | return ; | ||
13215 | } | ||
13216 | // $ANTLR end "rule__ALSImpl__Group_1__3__Impl" | ||
13217 | |||
13218 | |||
13219 | // $ANTLR start "rule__ALSImpl__Group_1_3__0" | ||
13220 | // InternalAlloyLanguage.g:4454:1: rule__ALSImpl__Group_1_3__0 : rule__ALSImpl__Group_1_3__0__Impl rule__ALSImpl__Group_1_3__1 ; | ||
13221 | public final void rule__ALSImpl__Group_1_3__0() throws RecognitionException { | ||
13222 | |||
13223 | int stackSize = keepStackSize(); | ||
13224 | |||
13225 | try { | ||
13226 | // InternalAlloyLanguage.g:4458:1: ( rule__ALSImpl__Group_1_3__0__Impl rule__ALSImpl__Group_1_3__1 ) | ||
13227 | // InternalAlloyLanguage.g:4459:2: rule__ALSImpl__Group_1_3__0__Impl rule__ALSImpl__Group_1_3__1 | ||
13228 | { | ||
13229 | pushFollow(FOLLOW_16); | ||
13230 | rule__ALSImpl__Group_1_3__0__Impl(); | ||
13231 | |||
13232 | state._fsp--; | ||
13233 | if (state.failed) return ; | ||
13234 | pushFollow(FOLLOW_2); | ||
13235 | rule__ALSImpl__Group_1_3__1(); | ||
13236 | |||
13237 | state._fsp--; | ||
13238 | if (state.failed) return ; | ||
13239 | |||
13240 | } | ||
13241 | |||
13242 | } | ||
13243 | catch (RecognitionException re) { | ||
13244 | reportError(re); | ||
13245 | recover(input,re); | ||
13246 | } | ||
13247 | finally { | ||
13248 | |||
13249 | restoreStackSize(stackSize); | ||
13250 | |||
13251 | } | ||
13252 | return ; | ||
13253 | } | ||
13254 | // $ANTLR end "rule__ALSImpl__Group_1_3__0" | ||
13255 | |||
13256 | |||
13257 | // $ANTLR start "rule__ALSImpl__Group_1_3__0__Impl" | ||
13258 | // InternalAlloyLanguage.g:4466:1: rule__ALSImpl__Group_1_3__0__Impl : ( 'else' ) ; | ||
13259 | public final void rule__ALSImpl__Group_1_3__0__Impl() throws RecognitionException { | ||
13260 | |||
13261 | int stackSize = keepStackSize(); | ||
13262 | |||
13263 | try { | ||
13264 | // InternalAlloyLanguage.g:4470:1: ( ( 'else' ) ) | ||
13265 | // InternalAlloyLanguage.g:4471:1: ( 'else' ) | ||
13266 | { | ||
13267 | // InternalAlloyLanguage.g:4471:1: ( 'else' ) | ||
13268 | // InternalAlloyLanguage.g:4472:1: 'else' | ||
13269 | { | ||
13270 | if ( state.backtracking==0 ) { | ||
13271 | before(grammarAccess.getALSImplAccess().getElseKeyword_1_3_0()); | ||
13272 | } | ||
13273 | match(input,46,FOLLOW_2); if (state.failed) return ; | ||
13274 | if ( state.backtracking==0 ) { | ||
13275 | after(grammarAccess.getALSImplAccess().getElseKeyword_1_3_0()); | ||
13276 | } | ||
13277 | |||
13278 | } | ||
13279 | |||
13280 | |||
13281 | } | ||
13282 | |||
13283 | } | ||
13284 | catch (RecognitionException re) { | ||
13285 | reportError(re); | ||
13286 | recover(input,re); | ||
13287 | } | ||
13288 | finally { | ||
13289 | |||
13290 | restoreStackSize(stackSize); | ||
13291 | |||
13292 | } | ||
13293 | return ; | ||
13294 | } | ||
13295 | // $ANTLR end "rule__ALSImpl__Group_1_3__0__Impl" | ||
13296 | |||
13297 | |||
13298 | // $ANTLR start "rule__ALSImpl__Group_1_3__1" | ||
13299 | // InternalAlloyLanguage.g:4485:1: rule__ALSImpl__Group_1_3__1 : rule__ALSImpl__Group_1_3__1__Impl ; | ||
13300 | public final void rule__ALSImpl__Group_1_3__1() throws RecognitionException { | ||
13301 | |||
13302 | int stackSize = keepStackSize(); | ||
13303 | |||
13304 | try { | ||
13305 | // InternalAlloyLanguage.g:4489:1: ( rule__ALSImpl__Group_1_3__1__Impl ) | ||
13306 | // InternalAlloyLanguage.g:4490:2: rule__ALSImpl__Group_1_3__1__Impl | ||
13307 | { | ||
13308 | pushFollow(FOLLOW_2); | ||
13309 | rule__ALSImpl__Group_1_3__1__Impl(); | ||
13310 | |||
13311 | state._fsp--; | ||
13312 | if (state.failed) return ; | ||
13313 | |||
13314 | } | ||
13315 | |||
13316 | } | ||
13317 | catch (RecognitionException re) { | ||
13318 | reportError(re); | ||
13319 | recover(input,re); | ||
13320 | } | ||
13321 | finally { | ||
13322 | |||
13323 | restoreStackSize(stackSize); | ||
13324 | |||
13325 | } | ||
13326 | return ; | ||
13327 | } | ||
13328 | // $ANTLR end "rule__ALSImpl__Group_1_3__1" | ||
13329 | |||
13330 | |||
13331 | // $ANTLR start "rule__ALSImpl__Group_1_3__1__Impl" | ||
13332 | // InternalAlloyLanguage.g:4496:1: rule__ALSImpl__Group_1_3__1__Impl : ( ( rule__ALSImpl__ElseOperandAssignment_1_3_1 ) ) ; | ||
13333 | public final void rule__ALSImpl__Group_1_3__1__Impl() throws RecognitionException { | ||
13334 | |||
13335 | int stackSize = keepStackSize(); | ||
13336 | |||
13337 | try { | ||
13338 | // InternalAlloyLanguage.g:4500:1: ( ( ( rule__ALSImpl__ElseOperandAssignment_1_3_1 ) ) ) | ||
13339 | // InternalAlloyLanguage.g:4501:1: ( ( rule__ALSImpl__ElseOperandAssignment_1_3_1 ) ) | ||
13340 | { | ||
13341 | // InternalAlloyLanguage.g:4501:1: ( ( rule__ALSImpl__ElseOperandAssignment_1_3_1 ) ) | ||
13342 | // InternalAlloyLanguage.g:4502:1: ( rule__ALSImpl__ElseOperandAssignment_1_3_1 ) | ||
13343 | { | ||
13344 | if ( state.backtracking==0 ) { | ||
13345 | before(grammarAccess.getALSImplAccess().getElseOperandAssignment_1_3_1()); | ||
13346 | } | ||
13347 | // InternalAlloyLanguage.g:4503:1: ( rule__ALSImpl__ElseOperandAssignment_1_3_1 ) | ||
13348 | // InternalAlloyLanguage.g:4503:2: rule__ALSImpl__ElseOperandAssignment_1_3_1 | ||
13349 | { | ||
13350 | pushFollow(FOLLOW_2); | ||
13351 | rule__ALSImpl__ElseOperandAssignment_1_3_1(); | ||
13352 | |||
13353 | state._fsp--; | ||
13354 | if (state.failed) return ; | ||
13355 | |||
13356 | } | ||
13357 | |||
13358 | if ( state.backtracking==0 ) { | ||
13359 | after(grammarAccess.getALSImplAccess().getElseOperandAssignment_1_3_1()); | ||
13360 | } | ||
13361 | |||
13362 | } | ||
13363 | |||
13364 | |||
13365 | } | ||
13366 | |||
13367 | } | ||
13368 | catch (RecognitionException re) { | ||
13369 | reportError(re); | ||
13370 | recover(input,re); | ||
13371 | } | ||
13372 | finally { | ||
13373 | |||
13374 | restoreStackSize(stackSize); | ||
13375 | |||
13376 | } | ||
13377 | return ; | ||
13378 | } | ||
13379 | // $ANTLR end "rule__ALSImpl__Group_1_3__1__Impl" | ||
13380 | |||
13381 | |||
13382 | // $ANTLR start "rule__ALSAnd__Group__0" | ||
13383 | // InternalAlloyLanguage.g:4517:1: rule__ALSAnd__Group__0 : rule__ALSAnd__Group__0__Impl rule__ALSAnd__Group__1 ; | ||
13384 | public final void rule__ALSAnd__Group__0() throws RecognitionException { | ||
13385 | |||
13386 | int stackSize = keepStackSize(); | ||
13387 | |||
13388 | try { | ||
13389 | // InternalAlloyLanguage.g:4521:1: ( rule__ALSAnd__Group__0__Impl rule__ALSAnd__Group__1 ) | ||
13390 | // InternalAlloyLanguage.g:4522:2: rule__ALSAnd__Group__0__Impl rule__ALSAnd__Group__1 | ||
13391 | { | ||
13392 | pushFollow(FOLLOW_29); | ||
13393 | rule__ALSAnd__Group__0__Impl(); | ||
13394 | |||
13395 | state._fsp--; | ||
13396 | if (state.failed) return ; | ||
13397 | pushFollow(FOLLOW_2); | ||
13398 | rule__ALSAnd__Group__1(); | ||
13399 | |||
13400 | state._fsp--; | ||
13401 | if (state.failed) return ; | ||
13402 | |||
13403 | } | ||
13404 | |||
13405 | } | ||
13406 | catch (RecognitionException re) { | ||
13407 | reportError(re); | ||
13408 | recover(input,re); | ||
13409 | } | ||
13410 | finally { | ||
13411 | |||
13412 | restoreStackSize(stackSize); | ||
13413 | |||
13414 | } | ||
13415 | return ; | ||
13416 | } | ||
13417 | // $ANTLR end "rule__ALSAnd__Group__0" | ||
13418 | |||
13419 | |||
13420 | // $ANTLR start "rule__ALSAnd__Group__0__Impl" | ||
13421 | // InternalAlloyLanguage.g:4529:1: rule__ALSAnd__Group__0__Impl : ( ruleALSComparison ) ; | ||
13422 | public final void rule__ALSAnd__Group__0__Impl() throws RecognitionException { | ||
13423 | |||
13424 | int stackSize = keepStackSize(); | ||
13425 | |||
13426 | try { | ||
13427 | // InternalAlloyLanguage.g:4533:1: ( ( ruleALSComparison ) ) | ||
13428 | // InternalAlloyLanguage.g:4534:1: ( ruleALSComparison ) | ||
13429 | { | ||
13430 | // InternalAlloyLanguage.g:4534:1: ( ruleALSComparison ) | ||
13431 | // InternalAlloyLanguage.g:4535:1: ruleALSComparison | ||
13432 | { | ||
13433 | if ( state.backtracking==0 ) { | ||
13434 | before(grammarAccess.getALSAndAccess().getALSComparisonParserRuleCall_0()); | ||
13435 | } | ||
13436 | pushFollow(FOLLOW_2); | ||
13437 | ruleALSComparison(); | ||
13438 | |||
13439 | state._fsp--; | ||
13440 | if (state.failed) return ; | ||
13441 | if ( state.backtracking==0 ) { | ||
13442 | after(grammarAccess.getALSAndAccess().getALSComparisonParserRuleCall_0()); | ||
13443 | } | ||
13444 | |||
13445 | } | ||
13446 | |||
13447 | |||
13448 | } | ||
13449 | |||
13450 | } | ||
13451 | catch (RecognitionException re) { | ||
13452 | reportError(re); | ||
13453 | recover(input,re); | ||
13454 | } | ||
13455 | finally { | ||
13456 | |||
13457 | restoreStackSize(stackSize); | ||
13458 | |||
13459 | } | ||
13460 | return ; | ||
13461 | } | ||
13462 | // $ANTLR end "rule__ALSAnd__Group__0__Impl" | ||
13463 | |||
13464 | |||
13465 | // $ANTLR start "rule__ALSAnd__Group__1" | ||
13466 | // InternalAlloyLanguage.g:4546:1: rule__ALSAnd__Group__1 : rule__ALSAnd__Group__1__Impl ; | ||
13467 | public final void rule__ALSAnd__Group__1() throws RecognitionException { | ||
13468 | |||
13469 | int stackSize = keepStackSize(); | ||
13470 | |||
13471 | try { | ||
13472 | // InternalAlloyLanguage.g:4550:1: ( rule__ALSAnd__Group__1__Impl ) | ||
13473 | // InternalAlloyLanguage.g:4551:2: rule__ALSAnd__Group__1__Impl | ||
13474 | { | ||
13475 | pushFollow(FOLLOW_2); | ||
13476 | rule__ALSAnd__Group__1__Impl(); | ||
13477 | |||
13478 | state._fsp--; | ||
13479 | if (state.failed) return ; | ||
13480 | |||
13481 | } | ||
13482 | |||
13483 | } | ||
13484 | catch (RecognitionException re) { | ||
13485 | reportError(re); | ||
13486 | recover(input,re); | ||
13487 | } | ||
13488 | finally { | ||
13489 | |||
13490 | restoreStackSize(stackSize); | ||
13491 | |||
13492 | } | ||
13493 | return ; | ||
13494 | } | ||
13495 | // $ANTLR end "rule__ALSAnd__Group__1" | ||
13496 | |||
13497 | |||
13498 | // $ANTLR start "rule__ALSAnd__Group__1__Impl" | ||
13499 | // InternalAlloyLanguage.g:4557:1: rule__ALSAnd__Group__1__Impl : ( ( rule__ALSAnd__Group_1__0 )? ) ; | ||
13500 | public final void rule__ALSAnd__Group__1__Impl() throws RecognitionException { | ||
13501 | |||
13502 | int stackSize = keepStackSize(); | ||
13503 | |||
13504 | try { | ||
13505 | // InternalAlloyLanguage.g:4561:1: ( ( ( rule__ALSAnd__Group_1__0 )? ) ) | ||
13506 | // InternalAlloyLanguage.g:4562:1: ( ( rule__ALSAnd__Group_1__0 )? ) | ||
13507 | { | ||
13508 | // InternalAlloyLanguage.g:4562:1: ( ( rule__ALSAnd__Group_1__0 )? ) | ||
13509 | // InternalAlloyLanguage.g:4563:1: ( rule__ALSAnd__Group_1__0 )? | ||
13510 | { | ||
13511 | if ( state.backtracking==0 ) { | ||
13512 | before(grammarAccess.getALSAndAccess().getGroup_1()); | ||
13513 | } | ||
13514 | // InternalAlloyLanguage.g:4564:1: ( rule__ALSAnd__Group_1__0 )? | ||
13515 | int alt34=2; | ||
13516 | int LA34_0 = input.LA(1); | ||
13517 | |||
13518 | if ( ((LA34_0>=17 && LA34_0<=18)) ) { | ||
13519 | alt34=1; | ||
13520 | } | ||
13521 | switch (alt34) { | ||
13522 | case 1 : | ||
13523 | // InternalAlloyLanguage.g:4564:2: rule__ALSAnd__Group_1__0 | ||
13524 | { | ||
13525 | pushFollow(FOLLOW_2); | ||
13526 | rule__ALSAnd__Group_1__0(); | ||
13527 | |||
13528 | state._fsp--; | ||
13529 | if (state.failed) return ; | ||
13530 | |||
13531 | } | ||
13532 | break; | ||
13533 | |||
13534 | } | ||
13535 | |||
13536 | if ( state.backtracking==0 ) { | ||
13537 | after(grammarAccess.getALSAndAccess().getGroup_1()); | ||
13538 | } | ||
13539 | |||
13540 | } | ||
13541 | |||
13542 | |||
13543 | } | ||
13544 | |||
13545 | } | ||
13546 | catch (RecognitionException re) { | ||
13547 | reportError(re); | ||
13548 | recover(input,re); | ||
13549 | } | ||
13550 | finally { | ||
13551 | |||
13552 | restoreStackSize(stackSize); | ||
13553 | |||
13554 | } | ||
13555 | return ; | ||
13556 | } | ||
13557 | // $ANTLR end "rule__ALSAnd__Group__1__Impl" | ||
13558 | |||
13559 | |||
13560 | // $ANTLR start "rule__ALSAnd__Group_1__0" | ||
13561 | // InternalAlloyLanguage.g:4578:1: rule__ALSAnd__Group_1__0 : rule__ALSAnd__Group_1__0__Impl rule__ALSAnd__Group_1__1 ; | ||
13562 | public final void rule__ALSAnd__Group_1__0() throws RecognitionException { | ||
13563 | |||
13564 | int stackSize = keepStackSize(); | ||
13565 | |||
13566 | try { | ||
13567 | // InternalAlloyLanguage.g:4582:1: ( rule__ALSAnd__Group_1__0__Impl rule__ALSAnd__Group_1__1 ) | ||
13568 | // InternalAlloyLanguage.g:4583:2: rule__ALSAnd__Group_1__0__Impl rule__ALSAnd__Group_1__1 | ||
13569 | { | ||
13570 | pushFollow(FOLLOW_29); | ||
13571 | rule__ALSAnd__Group_1__0__Impl(); | ||
13572 | |||
13573 | state._fsp--; | ||
13574 | if (state.failed) return ; | ||
13575 | pushFollow(FOLLOW_2); | ||
13576 | rule__ALSAnd__Group_1__1(); | ||
13577 | |||
13578 | state._fsp--; | ||
13579 | if (state.failed) return ; | ||
13580 | |||
13581 | } | ||
13582 | |||
13583 | } | ||
13584 | catch (RecognitionException re) { | ||
13585 | reportError(re); | ||
13586 | recover(input,re); | ||
13587 | } | ||
13588 | finally { | ||
13589 | |||
13590 | restoreStackSize(stackSize); | ||
13591 | |||
13592 | } | ||
13593 | return ; | ||
13594 | } | ||
13595 | // $ANTLR end "rule__ALSAnd__Group_1__0" | ||
13596 | |||
13597 | |||
13598 | // $ANTLR start "rule__ALSAnd__Group_1__0__Impl" | ||
13599 | // InternalAlloyLanguage.g:4590:1: rule__ALSAnd__Group_1__0__Impl : ( () ) ; | ||
13600 | public final void rule__ALSAnd__Group_1__0__Impl() throws RecognitionException { | ||
13601 | |||
13602 | int stackSize = keepStackSize(); | ||
13603 | |||
13604 | try { | ||
13605 | // InternalAlloyLanguage.g:4594:1: ( ( () ) ) | ||
13606 | // InternalAlloyLanguage.g:4595:1: ( () ) | ||
13607 | { | ||
13608 | // InternalAlloyLanguage.g:4595:1: ( () ) | ||
13609 | // InternalAlloyLanguage.g:4596:1: () | ||
13610 | { | ||
13611 | if ( state.backtracking==0 ) { | ||
13612 | before(grammarAccess.getALSAndAccess().getALSAndLeftOperandAction_1_0()); | ||
13613 | } | ||
13614 | // InternalAlloyLanguage.g:4597:1: () | ||
13615 | // InternalAlloyLanguage.g:4599:1: | ||
13616 | { | ||
13617 | } | ||
13618 | |||
13619 | if ( state.backtracking==0 ) { | ||
13620 | after(grammarAccess.getALSAndAccess().getALSAndLeftOperandAction_1_0()); | ||
13621 | } | ||
13622 | |||
13623 | } | ||
13624 | |||
13625 | |||
13626 | } | ||
13627 | |||
13628 | } | ||
13629 | finally { | ||
13630 | |||
13631 | restoreStackSize(stackSize); | ||
13632 | |||
13633 | } | ||
13634 | return ; | ||
13635 | } | ||
13636 | // $ANTLR end "rule__ALSAnd__Group_1__0__Impl" | ||
13637 | |||
13638 | |||
13639 | // $ANTLR start "rule__ALSAnd__Group_1__1" | ||
13640 | // InternalAlloyLanguage.g:4609:1: rule__ALSAnd__Group_1__1 : rule__ALSAnd__Group_1__1__Impl rule__ALSAnd__Group_1__2 ; | ||
13641 | public final void rule__ALSAnd__Group_1__1() throws RecognitionException { | ||
13642 | |||
13643 | int stackSize = keepStackSize(); | ||
13644 | |||
13645 | try { | ||
13646 | // InternalAlloyLanguage.g:4613:1: ( rule__ALSAnd__Group_1__1__Impl rule__ALSAnd__Group_1__2 ) | ||
13647 | // InternalAlloyLanguage.g:4614:2: rule__ALSAnd__Group_1__1__Impl rule__ALSAnd__Group_1__2 | ||
13648 | { | ||
13649 | pushFollow(FOLLOW_16); | ||
13650 | rule__ALSAnd__Group_1__1__Impl(); | ||
13651 | |||
13652 | state._fsp--; | ||
13653 | if (state.failed) return ; | ||
13654 | pushFollow(FOLLOW_2); | ||
13655 | rule__ALSAnd__Group_1__2(); | ||
13656 | |||
13657 | state._fsp--; | ||
13658 | if (state.failed) return ; | ||
13659 | |||
13660 | } | ||
13661 | |||
13662 | } | ||
13663 | catch (RecognitionException re) { | ||
13664 | reportError(re); | ||
13665 | recover(input,re); | ||
13666 | } | ||
13667 | finally { | ||
13668 | |||
13669 | restoreStackSize(stackSize); | ||
13670 | |||
13671 | } | ||
13672 | return ; | ||
13673 | } | ||
13674 | // $ANTLR end "rule__ALSAnd__Group_1__1" | ||
13675 | |||
13676 | |||
13677 | // $ANTLR start "rule__ALSAnd__Group_1__1__Impl" | ||
13678 | // InternalAlloyLanguage.g:4621:1: rule__ALSAnd__Group_1__1__Impl : ( ( rule__ALSAnd__Alternatives_1_1 ) ) ; | ||
13679 | public final void rule__ALSAnd__Group_1__1__Impl() throws RecognitionException { | ||
13680 | |||
13681 | int stackSize = keepStackSize(); | ||
13682 | |||
13683 | try { | ||
13684 | // InternalAlloyLanguage.g:4625:1: ( ( ( rule__ALSAnd__Alternatives_1_1 ) ) ) | ||
13685 | // InternalAlloyLanguage.g:4626:1: ( ( rule__ALSAnd__Alternatives_1_1 ) ) | ||
13686 | { | ||
13687 | // InternalAlloyLanguage.g:4626:1: ( ( rule__ALSAnd__Alternatives_1_1 ) ) | ||
13688 | // InternalAlloyLanguage.g:4627:1: ( rule__ALSAnd__Alternatives_1_1 ) | ||
13689 | { | ||
13690 | if ( state.backtracking==0 ) { | ||
13691 | before(grammarAccess.getALSAndAccess().getAlternatives_1_1()); | ||
13692 | } | ||
13693 | // InternalAlloyLanguage.g:4628:1: ( rule__ALSAnd__Alternatives_1_1 ) | ||
13694 | // InternalAlloyLanguage.g:4628:2: rule__ALSAnd__Alternatives_1_1 | ||
13695 | { | ||
13696 | pushFollow(FOLLOW_2); | ||
13697 | rule__ALSAnd__Alternatives_1_1(); | ||
13698 | |||
13699 | state._fsp--; | ||
13700 | if (state.failed) return ; | ||
13701 | |||
13702 | } | ||
13703 | |||
13704 | if ( state.backtracking==0 ) { | ||
13705 | after(grammarAccess.getALSAndAccess().getAlternatives_1_1()); | ||
13706 | } | ||
13707 | |||
13708 | } | ||
13709 | |||
13710 | |||
13711 | } | ||
13712 | |||
13713 | } | ||
13714 | catch (RecognitionException re) { | ||
13715 | reportError(re); | ||
13716 | recover(input,re); | ||
13717 | } | ||
13718 | finally { | ||
13719 | |||
13720 | restoreStackSize(stackSize); | ||
13721 | |||
13722 | } | ||
13723 | return ; | ||
13724 | } | ||
13725 | // $ANTLR end "rule__ALSAnd__Group_1__1__Impl" | ||
13726 | |||
13727 | |||
13728 | // $ANTLR start "rule__ALSAnd__Group_1__2" | ||
13729 | // InternalAlloyLanguage.g:4638:1: rule__ALSAnd__Group_1__2 : rule__ALSAnd__Group_1__2__Impl ; | ||
13730 | public final void rule__ALSAnd__Group_1__2() throws RecognitionException { | ||
13731 | |||
13732 | int stackSize = keepStackSize(); | ||
13733 | |||
13734 | try { | ||
13735 | // InternalAlloyLanguage.g:4642:1: ( rule__ALSAnd__Group_1__2__Impl ) | ||
13736 | // InternalAlloyLanguage.g:4643:2: rule__ALSAnd__Group_1__2__Impl | ||
13737 | { | ||
13738 | pushFollow(FOLLOW_2); | ||
13739 | rule__ALSAnd__Group_1__2__Impl(); | ||
13740 | |||
13741 | state._fsp--; | ||
13742 | if (state.failed) return ; | ||
13743 | |||
13744 | } | ||
13745 | |||
13746 | } | ||
13747 | catch (RecognitionException re) { | ||
13748 | reportError(re); | ||
13749 | recover(input,re); | ||
13750 | } | ||
13751 | finally { | ||
13752 | |||
13753 | restoreStackSize(stackSize); | ||
13754 | |||
13755 | } | ||
13756 | return ; | ||
13757 | } | ||
13758 | // $ANTLR end "rule__ALSAnd__Group_1__2" | ||
13759 | |||
13760 | |||
13761 | // $ANTLR start "rule__ALSAnd__Group_1__2__Impl" | ||
13762 | // InternalAlloyLanguage.g:4649:1: rule__ALSAnd__Group_1__2__Impl : ( ( rule__ALSAnd__RightOperandAssignment_1_2 ) ) ; | ||
13763 | public final void rule__ALSAnd__Group_1__2__Impl() throws RecognitionException { | ||
13764 | |||
13765 | int stackSize = keepStackSize(); | ||
13766 | |||
13767 | try { | ||
13768 | // InternalAlloyLanguage.g:4653:1: ( ( ( rule__ALSAnd__RightOperandAssignment_1_2 ) ) ) | ||
13769 | // InternalAlloyLanguage.g:4654:1: ( ( rule__ALSAnd__RightOperandAssignment_1_2 ) ) | ||
13770 | { | ||
13771 | // InternalAlloyLanguage.g:4654:1: ( ( rule__ALSAnd__RightOperandAssignment_1_2 ) ) | ||
13772 | // InternalAlloyLanguage.g:4655:1: ( rule__ALSAnd__RightOperandAssignment_1_2 ) | ||
13773 | { | ||
13774 | if ( state.backtracking==0 ) { | ||
13775 | before(grammarAccess.getALSAndAccess().getRightOperandAssignment_1_2()); | ||
13776 | } | ||
13777 | // InternalAlloyLanguage.g:4656:1: ( rule__ALSAnd__RightOperandAssignment_1_2 ) | ||
13778 | // InternalAlloyLanguage.g:4656:2: rule__ALSAnd__RightOperandAssignment_1_2 | ||
13779 | { | ||
13780 | pushFollow(FOLLOW_2); | ||
13781 | rule__ALSAnd__RightOperandAssignment_1_2(); | ||
13782 | |||
13783 | state._fsp--; | ||
13784 | if (state.failed) return ; | ||
13785 | |||
13786 | } | ||
13787 | |||
13788 | if ( state.backtracking==0 ) { | ||
13789 | after(grammarAccess.getALSAndAccess().getRightOperandAssignment_1_2()); | ||
13790 | } | ||
13791 | |||
13792 | } | ||
13793 | |||
13794 | |||
13795 | } | ||
13796 | |||
13797 | } | ||
13798 | catch (RecognitionException re) { | ||
13799 | reportError(re); | ||
13800 | recover(input,re); | ||
13801 | } | ||
13802 | finally { | ||
13803 | |||
13804 | restoreStackSize(stackSize); | ||
13805 | |||
13806 | } | ||
13807 | return ; | ||
13808 | } | ||
13809 | // $ANTLR end "rule__ALSAnd__Group_1__2__Impl" | ||
13810 | |||
13811 | |||
13812 | // $ANTLR start "rule__ALSComparison__Group__0" | ||
13813 | // InternalAlloyLanguage.g:4672:1: rule__ALSComparison__Group__0 : rule__ALSComparison__Group__0__Impl rule__ALSComparison__Group__1 ; | ||
13814 | public final void rule__ALSComparison__Group__0() throws RecognitionException { | ||
13815 | |||
13816 | int stackSize = keepStackSize(); | ||
13817 | |||
13818 | try { | ||
13819 | // InternalAlloyLanguage.g:4676:1: ( rule__ALSComparison__Group__0__Impl rule__ALSComparison__Group__1 ) | ||
13820 | // InternalAlloyLanguage.g:4677:2: rule__ALSComparison__Group__0__Impl rule__ALSComparison__Group__1 | ||
13821 | { | ||
13822 | pushFollow(FOLLOW_30); | ||
13823 | rule__ALSComparison__Group__0__Impl(); | ||
13824 | |||
13825 | state._fsp--; | ||
13826 | if (state.failed) return ; | ||
13827 | pushFollow(FOLLOW_2); | ||
13828 | rule__ALSComparison__Group__1(); | ||
13829 | |||
13830 | state._fsp--; | ||
13831 | if (state.failed) return ; | ||
13832 | |||
13833 | } | ||
13834 | |||
13835 | } | ||
13836 | catch (RecognitionException re) { | ||
13837 | reportError(re); | ||
13838 | recover(input,re); | ||
13839 | } | ||
13840 | finally { | ||
13841 | |||
13842 | restoreStackSize(stackSize); | ||
13843 | |||
13844 | } | ||
13845 | return ; | ||
13846 | } | ||
13847 | // $ANTLR end "rule__ALSComparison__Group__0" | ||
13848 | |||
13849 | |||
13850 | // $ANTLR start "rule__ALSComparison__Group__0__Impl" | ||
13851 | // InternalAlloyLanguage.g:4684:1: rule__ALSComparison__Group__0__Impl : ( ruleALSOverride ) ; | ||
13852 | public final void rule__ALSComparison__Group__0__Impl() throws RecognitionException { | ||
13853 | |||
13854 | int stackSize = keepStackSize(); | ||
13855 | |||
13856 | try { | ||
13857 | // InternalAlloyLanguage.g:4688:1: ( ( ruleALSOverride ) ) | ||
13858 | // InternalAlloyLanguage.g:4689:1: ( ruleALSOverride ) | ||
13859 | { | ||
13860 | // InternalAlloyLanguage.g:4689:1: ( ruleALSOverride ) | ||
13861 | // InternalAlloyLanguage.g:4690:1: ruleALSOverride | ||
13862 | { | ||
13863 | if ( state.backtracking==0 ) { | ||
13864 | before(grammarAccess.getALSComparisonAccess().getALSOverrideParserRuleCall_0()); | ||
13865 | } | ||
13866 | pushFollow(FOLLOW_2); | ||
13867 | ruleALSOverride(); | ||
13868 | |||
13869 | state._fsp--; | ||
13870 | if (state.failed) return ; | ||
13871 | if ( state.backtracking==0 ) { | ||
13872 | after(grammarAccess.getALSComparisonAccess().getALSOverrideParserRuleCall_0()); | ||
13873 | } | ||
13874 | |||
13875 | } | ||
13876 | |||
13877 | |||
13878 | } | ||
13879 | |||
13880 | } | ||
13881 | catch (RecognitionException re) { | ||
13882 | reportError(re); | ||
13883 | recover(input,re); | ||
13884 | } | ||
13885 | finally { | ||
13886 | |||
13887 | restoreStackSize(stackSize); | ||
13888 | |||
13889 | } | ||
13890 | return ; | ||
13891 | } | ||
13892 | // $ANTLR end "rule__ALSComparison__Group__0__Impl" | ||
13893 | |||
13894 | |||
13895 | // $ANTLR start "rule__ALSComparison__Group__1" | ||
13896 | // InternalAlloyLanguage.g:4701:1: rule__ALSComparison__Group__1 : rule__ALSComparison__Group__1__Impl ; | ||
13897 | public final void rule__ALSComparison__Group__1() throws RecognitionException { | ||
13898 | |||
13899 | int stackSize = keepStackSize(); | ||
13900 | |||
13901 | try { | ||
13902 | // InternalAlloyLanguage.g:4705:1: ( rule__ALSComparison__Group__1__Impl ) | ||
13903 | // InternalAlloyLanguage.g:4706:2: rule__ALSComparison__Group__1__Impl | ||
13904 | { | ||
13905 | pushFollow(FOLLOW_2); | ||
13906 | rule__ALSComparison__Group__1__Impl(); | ||
13907 | |||
13908 | state._fsp--; | ||
13909 | if (state.failed) return ; | ||
13910 | |||
13911 | } | ||
13912 | |||
13913 | } | ||
13914 | catch (RecognitionException re) { | ||
13915 | reportError(re); | ||
13916 | recover(input,re); | ||
13917 | } | ||
13918 | finally { | ||
13919 | |||
13920 | restoreStackSize(stackSize); | ||
13921 | |||
13922 | } | ||
13923 | return ; | ||
13924 | } | ||
13925 | // $ANTLR end "rule__ALSComparison__Group__1" | ||
13926 | |||
13927 | |||
13928 | // $ANTLR start "rule__ALSComparison__Group__1__Impl" | ||
13929 | // InternalAlloyLanguage.g:4712:1: rule__ALSComparison__Group__1__Impl : ( ( rule__ALSComparison__Group_1__0 )? ) ; | ||
13930 | public final void rule__ALSComparison__Group__1__Impl() throws RecognitionException { | ||
13931 | |||
13932 | int stackSize = keepStackSize(); | ||
13933 | |||
13934 | try { | ||
13935 | // InternalAlloyLanguage.g:4716:1: ( ( ( rule__ALSComparison__Group_1__0 )? ) ) | ||
13936 | // InternalAlloyLanguage.g:4717:1: ( ( rule__ALSComparison__Group_1__0 )? ) | ||
13937 | { | ||
13938 | // InternalAlloyLanguage.g:4717:1: ( ( rule__ALSComparison__Group_1__0 )? ) | ||
13939 | // InternalAlloyLanguage.g:4718:1: ( rule__ALSComparison__Group_1__0 )? | ||
13940 | { | ||
13941 | if ( state.backtracking==0 ) { | ||
13942 | before(grammarAccess.getALSComparisonAccess().getGroup_1()); | ||
13943 | } | ||
13944 | // InternalAlloyLanguage.g:4719:1: ( rule__ALSComparison__Group_1__0 )? | ||
13945 | int alt35=2; | ||
13946 | int LA35_0 = input.LA(1); | ||
13947 | |||
13948 | if ( (LA35_0==38||(LA35_0>=47 && LA35_0<=52)) ) { | ||
13949 | alt35=1; | ||
13950 | } | ||
13951 | switch (alt35) { | ||
13952 | case 1 : | ||
13953 | // InternalAlloyLanguage.g:4719:2: rule__ALSComparison__Group_1__0 | ||
13954 | { | ||
13955 | pushFollow(FOLLOW_2); | ||
13956 | rule__ALSComparison__Group_1__0(); | ||
13957 | |||
13958 | state._fsp--; | ||
13959 | if (state.failed) return ; | ||
13960 | |||
13961 | } | ||
13962 | break; | ||
13963 | |||
13964 | } | ||
13965 | |||
13966 | if ( state.backtracking==0 ) { | ||
13967 | after(grammarAccess.getALSComparisonAccess().getGroup_1()); | ||
13968 | } | ||
13969 | |||
13970 | } | ||
13971 | |||
13972 | |||
13973 | } | ||
13974 | |||
13975 | } | ||
13976 | catch (RecognitionException re) { | ||
13977 | reportError(re); | ||
13978 | recover(input,re); | ||
13979 | } | ||
13980 | finally { | ||
13981 | |||
13982 | restoreStackSize(stackSize); | ||
13983 | |||
13984 | } | ||
13985 | return ; | ||
13986 | } | ||
13987 | // $ANTLR end "rule__ALSComparison__Group__1__Impl" | ||
13988 | |||
13989 | |||
13990 | // $ANTLR start "rule__ALSComparison__Group_1__0" | ||
13991 | // InternalAlloyLanguage.g:4733:1: rule__ALSComparison__Group_1__0 : rule__ALSComparison__Group_1__0__Impl rule__ALSComparison__Group_1__1 ; | ||
13992 | public final void rule__ALSComparison__Group_1__0() throws RecognitionException { | ||
13993 | |||
13994 | int stackSize = keepStackSize(); | ||
13995 | |||
13996 | try { | ||
13997 | // InternalAlloyLanguage.g:4737:1: ( rule__ALSComparison__Group_1__0__Impl rule__ALSComparison__Group_1__1 ) | ||
13998 | // InternalAlloyLanguage.g:4738:2: rule__ALSComparison__Group_1__0__Impl rule__ALSComparison__Group_1__1 | ||
13999 | { | ||
14000 | pushFollow(FOLLOW_16); | ||
14001 | rule__ALSComparison__Group_1__0__Impl(); | ||
14002 | |||
14003 | state._fsp--; | ||
14004 | if (state.failed) return ; | ||
14005 | pushFollow(FOLLOW_2); | ||
14006 | rule__ALSComparison__Group_1__1(); | ||
14007 | |||
14008 | state._fsp--; | ||
14009 | if (state.failed) return ; | ||
14010 | |||
14011 | } | ||
14012 | |||
14013 | } | ||
14014 | catch (RecognitionException re) { | ||
14015 | reportError(re); | ||
14016 | recover(input,re); | ||
14017 | } | ||
14018 | finally { | ||
14019 | |||
14020 | restoreStackSize(stackSize); | ||
14021 | |||
14022 | } | ||
14023 | return ; | ||
14024 | } | ||
14025 | // $ANTLR end "rule__ALSComparison__Group_1__0" | ||
14026 | |||
14027 | |||
14028 | // $ANTLR start "rule__ALSComparison__Group_1__0__Impl" | ||
14029 | // InternalAlloyLanguage.g:4745:1: rule__ALSComparison__Group_1__0__Impl : ( ( rule__ALSComparison__Alternatives_1_0 ) ) ; | ||
14030 | public final void rule__ALSComparison__Group_1__0__Impl() throws RecognitionException { | ||
14031 | |||
14032 | int stackSize = keepStackSize(); | ||
14033 | |||
14034 | try { | ||
14035 | // InternalAlloyLanguage.g:4749:1: ( ( ( rule__ALSComparison__Alternatives_1_0 ) ) ) | ||
14036 | // InternalAlloyLanguage.g:4750:1: ( ( rule__ALSComparison__Alternatives_1_0 ) ) | ||
14037 | { | ||
14038 | // InternalAlloyLanguage.g:4750:1: ( ( rule__ALSComparison__Alternatives_1_0 ) ) | ||
14039 | // InternalAlloyLanguage.g:4751:1: ( rule__ALSComparison__Alternatives_1_0 ) | ||
14040 | { | ||
14041 | if ( state.backtracking==0 ) { | ||
14042 | before(grammarAccess.getALSComparisonAccess().getAlternatives_1_0()); | ||
14043 | } | ||
14044 | // InternalAlloyLanguage.g:4752:1: ( rule__ALSComparison__Alternatives_1_0 ) | ||
14045 | // InternalAlloyLanguage.g:4752:2: rule__ALSComparison__Alternatives_1_0 | ||
14046 | { | ||
14047 | pushFollow(FOLLOW_2); | ||
14048 | rule__ALSComparison__Alternatives_1_0(); | ||
14049 | |||
14050 | state._fsp--; | ||
14051 | if (state.failed) return ; | ||
14052 | |||
14053 | } | ||
14054 | |||
14055 | if ( state.backtracking==0 ) { | ||
14056 | after(grammarAccess.getALSComparisonAccess().getAlternatives_1_0()); | ||
14057 | } | ||
14058 | |||
14059 | } | ||
14060 | |||
14061 | |||
14062 | } | ||
14063 | |||
14064 | } | ||
14065 | catch (RecognitionException re) { | ||
14066 | reportError(re); | ||
14067 | recover(input,re); | ||
14068 | } | ||
14069 | finally { | ||
14070 | |||
14071 | restoreStackSize(stackSize); | ||
14072 | |||
14073 | } | ||
14074 | return ; | ||
14075 | } | ||
14076 | // $ANTLR end "rule__ALSComparison__Group_1__0__Impl" | ||
14077 | |||
14078 | |||
14079 | // $ANTLR start "rule__ALSComparison__Group_1__1" | ||
14080 | // InternalAlloyLanguage.g:4762:1: rule__ALSComparison__Group_1__1 : rule__ALSComparison__Group_1__1__Impl ; | ||
14081 | public final void rule__ALSComparison__Group_1__1() throws RecognitionException { | ||
14082 | |||
14083 | int stackSize = keepStackSize(); | ||
14084 | |||
14085 | try { | ||
14086 | // InternalAlloyLanguage.g:4766:1: ( rule__ALSComparison__Group_1__1__Impl ) | ||
14087 | // InternalAlloyLanguage.g:4767:2: rule__ALSComparison__Group_1__1__Impl | ||
14088 | { | ||
14089 | pushFollow(FOLLOW_2); | ||
14090 | rule__ALSComparison__Group_1__1__Impl(); | ||
14091 | |||
14092 | state._fsp--; | ||
14093 | if (state.failed) return ; | ||
14094 | |||
14095 | } | ||
14096 | |||
14097 | } | ||
14098 | catch (RecognitionException re) { | ||
14099 | reportError(re); | ||
14100 | recover(input,re); | ||
14101 | } | ||
14102 | finally { | ||
14103 | |||
14104 | restoreStackSize(stackSize); | ||
14105 | |||
14106 | } | ||
14107 | return ; | ||
14108 | } | ||
14109 | // $ANTLR end "rule__ALSComparison__Group_1__1" | ||
14110 | |||
14111 | |||
14112 | // $ANTLR start "rule__ALSComparison__Group_1__1__Impl" | ||
14113 | // InternalAlloyLanguage.g:4773:1: rule__ALSComparison__Group_1__1__Impl : ( ( rule__ALSComparison__RightOperandAssignment_1_1 ) ) ; | ||
14114 | public final void rule__ALSComparison__Group_1__1__Impl() throws RecognitionException { | ||
14115 | |||
14116 | int stackSize = keepStackSize(); | ||
14117 | |||
14118 | try { | ||
14119 | // InternalAlloyLanguage.g:4777:1: ( ( ( rule__ALSComparison__RightOperandAssignment_1_1 ) ) ) | ||
14120 | // InternalAlloyLanguage.g:4778:1: ( ( rule__ALSComparison__RightOperandAssignment_1_1 ) ) | ||
14121 | { | ||
14122 | // InternalAlloyLanguage.g:4778:1: ( ( rule__ALSComparison__RightOperandAssignment_1_1 ) ) | ||
14123 | // InternalAlloyLanguage.g:4779:1: ( rule__ALSComparison__RightOperandAssignment_1_1 ) | ||
14124 | { | ||
14125 | if ( state.backtracking==0 ) { | ||
14126 | before(grammarAccess.getALSComparisonAccess().getRightOperandAssignment_1_1()); | ||
14127 | } | ||
14128 | // InternalAlloyLanguage.g:4780:1: ( rule__ALSComparison__RightOperandAssignment_1_1 ) | ||
14129 | // InternalAlloyLanguage.g:4780:2: rule__ALSComparison__RightOperandAssignment_1_1 | ||
14130 | { | ||
14131 | pushFollow(FOLLOW_2); | ||
14132 | rule__ALSComparison__RightOperandAssignment_1_1(); | ||
14133 | |||
14134 | state._fsp--; | ||
14135 | if (state.failed) return ; | ||
14136 | |||
14137 | } | ||
14138 | |||
14139 | if ( state.backtracking==0 ) { | ||
14140 | after(grammarAccess.getALSComparisonAccess().getRightOperandAssignment_1_1()); | ||
14141 | } | ||
14142 | |||
14143 | } | ||
14144 | |||
14145 | |||
14146 | } | ||
14147 | |||
14148 | } | ||
14149 | catch (RecognitionException re) { | ||
14150 | reportError(re); | ||
14151 | recover(input,re); | ||
14152 | } | ||
14153 | finally { | ||
14154 | |||
14155 | restoreStackSize(stackSize); | ||
14156 | |||
14157 | } | ||
14158 | return ; | ||
14159 | } | ||
14160 | // $ANTLR end "rule__ALSComparison__Group_1__1__Impl" | ||
14161 | |||
14162 | |||
14163 | // $ANTLR start "rule__ALSComparison__Group_1_0_0__0" | ||
14164 | // InternalAlloyLanguage.g:4794:1: rule__ALSComparison__Group_1_0_0__0 : rule__ALSComparison__Group_1_0_0__0__Impl rule__ALSComparison__Group_1_0_0__1 ; | ||
14165 | public final void rule__ALSComparison__Group_1_0_0__0() throws RecognitionException { | ||
14166 | |||
14167 | int stackSize = keepStackSize(); | ||
14168 | |||
14169 | try { | ||
14170 | // InternalAlloyLanguage.g:4798:1: ( rule__ALSComparison__Group_1_0_0__0__Impl rule__ALSComparison__Group_1_0_0__1 ) | ||
14171 | // InternalAlloyLanguage.g:4799:2: rule__ALSComparison__Group_1_0_0__0__Impl rule__ALSComparison__Group_1_0_0__1 | ||
14172 | { | ||
14173 | pushFollow(FOLLOW_31); | ||
14174 | rule__ALSComparison__Group_1_0_0__0__Impl(); | ||
14175 | |||
14176 | state._fsp--; | ||
14177 | if (state.failed) return ; | ||
14178 | pushFollow(FOLLOW_2); | ||
14179 | rule__ALSComparison__Group_1_0_0__1(); | ||
14180 | |||
14181 | state._fsp--; | ||
14182 | if (state.failed) return ; | ||
14183 | |||
14184 | } | ||
14185 | |||
14186 | } | ||
14187 | catch (RecognitionException re) { | ||
14188 | reportError(re); | ||
14189 | recover(input,re); | ||
14190 | } | ||
14191 | finally { | ||
14192 | |||
14193 | restoreStackSize(stackSize); | ||
14194 | |||
14195 | } | ||
14196 | return ; | ||
14197 | } | ||
14198 | // $ANTLR end "rule__ALSComparison__Group_1_0_0__0" | ||
14199 | |||
14200 | |||
14201 | // $ANTLR start "rule__ALSComparison__Group_1_0_0__0__Impl" | ||
14202 | // InternalAlloyLanguage.g:4806:1: rule__ALSComparison__Group_1_0_0__0__Impl : ( () ) ; | ||
14203 | public final void rule__ALSComparison__Group_1_0_0__0__Impl() throws RecognitionException { | ||
14204 | |||
14205 | int stackSize = keepStackSize(); | ||
14206 | |||
14207 | try { | ||
14208 | // InternalAlloyLanguage.g:4810:1: ( ( () ) ) | ||
14209 | // InternalAlloyLanguage.g:4811:1: ( () ) | ||
14210 | { | ||
14211 | // InternalAlloyLanguage.g:4811:1: ( () ) | ||
14212 | // InternalAlloyLanguage.g:4812:1: () | ||
14213 | { | ||
14214 | if ( state.backtracking==0 ) { | ||
14215 | before(grammarAccess.getALSComparisonAccess().getALSEqualsLeftOperandAction_1_0_0_0()); | ||
14216 | } | ||
14217 | // InternalAlloyLanguage.g:4813:1: () | ||
14218 | // InternalAlloyLanguage.g:4815:1: | ||
14219 | { | ||
14220 | } | ||
14221 | |||
14222 | if ( state.backtracking==0 ) { | ||
14223 | after(grammarAccess.getALSComparisonAccess().getALSEqualsLeftOperandAction_1_0_0_0()); | ||
14224 | } | ||
14225 | |||
14226 | } | ||
14227 | |||
14228 | |||
14229 | } | ||
14230 | |||
14231 | } | ||
14232 | finally { | ||
14233 | |||
14234 | restoreStackSize(stackSize); | ||
14235 | |||
14236 | } | ||
14237 | return ; | ||
14238 | } | ||
14239 | // $ANTLR end "rule__ALSComparison__Group_1_0_0__0__Impl" | ||
14240 | |||
14241 | |||
14242 | // $ANTLR start "rule__ALSComparison__Group_1_0_0__1" | ||
14243 | // InternalAlloyLanguage.g:4825:1: rule__ALSComparison__Group_1_0_0__1 : rule__ALSComparison__Group_1_0_0__1__Impl ; | ||
14244 | public final void rule__ALSComparison__Group_1_0_0__1() throws RecognitionException { | ||
14245 | |||
14246 | int stackSize = keepStackSize(); | ||
14247 | |||
14248 | try { | ||
14249 | // InternalAlloyLanguage.g:4829:1: ( rule__ALSComparison__Group_1_0_0__1__Impl ) | ||
14250 | // InternalAlloyLanguage.g:4830:2: rule__ALSComparison__Group_1_0_0__1__Impl | ||
14251 | { | ||
14252 | pushFollow(FOLLOW_2); | ||
14253 | rule__ALSComparison__Group_1_0_0__1__Impl(); | ||
14254 | |||
14255 | state._fsp--; | ||
14256 | if (state.failed) return ; | ||
14257 | |||
14258 | } | ||
14259 | |||
14260 | } | ||
14261 | catch (RecognitionException re) { | ||
14262 | reportError(re); | ||
14263 | recover(input,re); | ||
14264 | } | ||
14265 | finally { | ||
14266 | |||
14267 | restoreStackSize(stackSize); | ||
14268 | |||
14269 | } | ||
14270 | return ; | ||
14271 | } | ||
14272 | // $ANTLR end "rule__ALSComparison__Group_1_0_0__1" | ||
14273 | |||
14274 | |||
14275 | // $ANTLR start "rule__ALSComparison__Group_1_0_0__1__Impl" | ||
14276 | // InternalAlloyLanguage.g:4836:1: rule__ALSComparison__Group_1_0_0__1__Impl : ( '=' ) ; | ||
14277 | public final void rule__ALSComparison__Group_1_0_0__1__Impl() throws RecognitionException { | ||
14278 | |||
14279 | int stackSize = keepStackSize(); | ||
14280 | |||
14281 | try { | ||
14282 | // InternalAlloyLanguage.g:4840:1: ( ( '=' ) ) | ||
14283 | // InternalAlloyLanguage.g:4841:1: ( '=' ) | ||
14284 | { | ||
14285 | // InternalAlloyLanguage.g:4841:1: ( '=' ) | ||
14286 | // InternalAlloyLanguage.g:4842:1: '=' | ||
14287 | { | ||
14288 | if ( state.backtracking==0 ) { | ||
14289 | before(grammarAccess.getALSComparisonAccess().getEqualsSignKeyword_1_0_0_1()); | ||
14290 | } | ||
14291 | match(input,47,FOLLOW_2); if (state.failed) return ; | ||
14292 | if ( state.backtracking==0 ) { | ||
14293 | after(grammarAccess.getALSComparisonAccess().getEqualsSignKeyword_1_0_0_1()); | ||
14294 | } | ||
14295 | |||
14296 | } | ||
14297 | |||
14298 | |||
14299 | } | ||
14300 | |||
14301 | } | ||
14302 | catch (RecognitionException re) { | ||
14303 | reportError(re); | ||
14304 | recover(input,re); | ||
14305 | } | ||
14306 | finally { | ||
14307 | |||
14308 | restoreStackSize(stackSize); | ||
14309 | |||
14310 | } | ||
14311 | return ; | ||
14312 | } | ||
14313 | // $ANTLR end "rule__ALSComparison__Group_1_0_0__1__Impl" | ||
14314 | |||
14315 | |||
14316 | // $ANTLR start "rule__ALSComparison__Group_1_0_1__0" | ||
14317 | // InternalAlloyLanguage.g:4859:1: rule__ALSComparison__Group_1_0_1__0 : rule__ALSComparison__Group_1_0_1__0__Impl rule__ALSComparison__Group_1_0_1__1 ; | ||
14318 | public final void rule__ALSComparison__Group_1_0_1__0() throws RecognitionException { | ||
14319 | |||
14320 | int stackSize = keepStackSize(); | ||
14321 | |||
14322 | try { | ||
14323 | // InternalAlloyLanguage.g:4863:1: ( rule__ALSComparison__Group_1_0_1__0__Impl rule__ALSComparison__Group_1_0_1__1 ) | ||
14324 | // InternalAlloyLanguage.g:4864:2: rule__ALSComparison__Group_1_0_1__0__Impl rule__ALSComparison__Group_1_0_1__1 | ||
14325 | { | ||
14326 | pushFollow(FOLLOW_32); | ||
14327 | rule__ALSComparison__Group_1_0_1__0__Impl(); | ||
14328 | |||
14329 | state._fsp--; | ||
14330 | if (state.failed) return ; | ||
14331 | pushFollow(FOLLOW_2); | ||
14332 | rule__ALSComparison__Group_1_0_1__1(); | ||
14333 | |||
14334 | state._fsp--; | ||
14335 | if (state.failed) return ; | ||
14336 | |||
14337 | } | ||
14338 | |||
14339 | } | ||
14340 | catch (RecognitionException re) { | ||
14341 | reportError(re); | ||
14342 | recover(input,re); | ||
14343 | } | ||
14344 | finally { | ||
14345 | |||
14346 | restoreStackSize(stackSize); | ||
14347 | |||
14348 | } | ||
14349 | return ; | ||
14350 | } | ||
14351 | // $ANTLR end "rule__ALSComparison__Group_1_0_1__0" | ||
14352 | |||
14353 | |||
14354 | // $ANTLR start "rule__ALSComparison__Group_1_0_1__0__Impl" | ||
14355 | // InternalAlloyLanguage.g:4871:1: rule__ALSComparison__Group_1_0_1__0__Impl : ( () ) ; | ||
14356 | public final void rule__ALSComparison__Group_1_0_1__0__Impl() throws RecognitionException { | ||
14357 | |||
14358 | int stackSize = keepStackSize(); | ||
14359 | |||
14360 | try { | ||
14361 | // InternalAlloyLanguage.g:4875:1: ( ( () ) ) | ||
14362 | // InternalAlloyLanguage.g:4876:1: ( () ) | ||
14363 | { | ||
14364 | // InternalAlloyLanguage.g:4876:1: ( () ) | ||
14365 | // InternalAlloyLanguage.g:4877:1: () | ||
14366 | { | ||
14367 | if ( state.backtracking==0 ) { | ||
14368 | before(grammarAccess.getALSComparisonAccess().getALSNotEqualsLeftOperandAction_1_0_1_0()); | ||
14369 | } | ||
14370 | // InternalAlloyLanguage.g:4878:1: () | ||
14371 | // InternalAlloyLanguage.g:4880:1: | ||
14372 | { | ||
14373 | } | ||
14374 | |||
14375 | if ( state.backtracking==0 ) { | ||
14376 | after(grammarAccess.getALSComparisonAccess().getALSNotEqualsLeftOperandAction_1_0_1_0()); | ||
14377 | } | ||
14378 | |||
14379 | } | ||
14380 | |||
14381 | |||
14382 | } | ||
14383 | |||
14384 | } | ||
14385 | finally { | ||
14386 | |||
14387 | restoreStackSize(stackSize); | ||
14388 | |||
14389 | } | ||
14390 | return ; | ||
14391 | } | ||
14392 | // $ANTLR end "rule__ALSComparison__Group_1_0_1__0__Impl" | ||
14393 | |||
14394 | |||
14395 | // $ANTLR start "rule__ALSComparison__Group_1_0_1__1" | ||
14396 | // InternalAlloyLanguage.g:4890:1: rule__ALSComparison__Group_1_0_1__1 : rule__ALSComparison__Group_1_0_1__1__Impl ; | ||
14397 | public final void rule__ALSComparison__Group_1_0_1__1() throws RecognitionException { | ||
14398 | |||
14399 | int stackSize = keepStackSize(); | ||
14400 | |||
14401 | try { | ||
14402 | // InternalAlloyLanguage.g:4894:1: ( rule__ALSComparison__Group_1_0_1__1__Impl ) | ||
14403 | // InternalAlloyLanguage.g:4895:2: rule__ALSComparison__Group_1_0_1__1__Impl | ||
14404 | { | ||
14405 | pushFollow(FOLLOW_2); | ||
14406 | rule__ALSComparison__Group_1_0_1__1__Impl(); | ||
14407 | |||
14408 | state._fsp--; | ||
14409 | if (state.failed) return ; | ||
14410 | |||
14411 | } | ||
14412 | |||
14413 | } | ||
14414 | catch (RecognitionException re) { | ||
14415 | reportError(re); | ||
14416 | recover(input,re); | ||
14417 | } | ||
14418 | finally { | ||
14419 | |||
14420 | restoreStackSize(stackSize); | ||
14421 | |||
14422 | } | ||
14423 | return ; | ||
14424 | } | ||
14425 | // $ANTLR end "rule__ALSComparison__Group_1_0_1__1" | ||
14426 | |||
14427 | |||
14428 | // $ANTLR start "rule__ALSComparison__Group_1_0_1__1__Impl" | ||
14429 | // InternalAlloyLanguage.g:4901:1: rule__ALSComparison__Group_1_0_1__1__Impl : ( '!=' ) ; | ||
14430 | public final void rule__ALSComparison__Group_1_0_1__1__Impl() throws RecognitionException { | ||
14431 | |||
14432 | int stackSize = keepStackSize(); | ||
14433 | |||
14434 | try { | ||
14435 | // InternalAlloyLanguage.g:4905:1: ( ( '!=' ) ) | ||
14436 | // InternalAlloyLanguage.g:4906:1: ( '!=' ) | ||
14437 | { | ||
14438 | // InternalAlloyLanguage.g:4906:1: ( '!=' ) | ||
14439 | // InternalAlloyLanguage.g:4907:1: '!=' | ||
14440 | { | ||
14441 | if ( state.backtracking==0 ) { | ||
14442 | before(grammarAccess.getALSComparisonAccess().getExclamationMarkEqualsSignKeyword_1_0_1_1()); | ||
14443 | } | ||
14444 | match(input,48,FOLLOW_2); if (state.failed) return ; | ||
14445 | if ( state.backtracking==0 ) { | ||
14446 | after(grammarAccess.getALSComparisonAccess().getExclamationMarkEqualsSignKeyword_1_0_1_1()); | ||
14447 | } | ||
14448 | |||
14449 | } | ||
14450 | |||
14451 | |||
14452 | } | ||
14453 | |||
14454 | } | ||
14455 | catch (RecognitionException re) { | ||
14456 | reportError(re); | ||
14457 | recover(input,re); | ||
14458 | } | ||
14459 | finally { | ||
14460 | |||
14461 | restoreStackSize(stackSize); | ||
14462 | |||
14463 | } | ||
14464 | return ; | ||
14465 | } | ||
14466 | // $ANTLR end "rule__ALSComparison__Group_1_0_1__1__Impl" | ||
14467 | |||
14468 | |||
14469 | // $ANTLR start "rule__ALSComparison__Group_1_0_2__0" | ||
14470 | // InternalAlloyLanguage.g:4924:1: rule__ALSComparison__Group_1_0_2__0 : rule__ALSComparison__Group_1_0_2__0__Impl rule__ALSComparison__Group_1_0_2__1 ; | ||
14471 | public final void rule__ALSComparison__Group_1_0_2__0() throws RecognitionException { | ||
14472 | |||
14473 | int stackSize = keepStackSize(); | ||
14474 | |||
14475 | try { | ||
14476 | // InternalAlloyLanguage.g:4928:1: ( rule__ALSComparison__Group_1_0_2__0__Impl rule__ALSComparison__Group_1_0_2__1 ) | ||
14477 | // InternalAlloyLanguage.g:4929:2: rule__ALSComparison__Group_1_0_2__0__Impl rule__ALSComparison__Group_1_0_2__1 | ||
14478 | { | ||
14479 | pushFollow(FOLLOW_33); | ||
14480 | rule__ALSComparison__Group_1_0_2__0__Impl(); | ||
14481 | |||
14482 | state._fsp--; | ||
14483 | if (state.failed) return ; | ||
14484 | pushFollow(FOLLOW_2); | ||
14485 | rule__ALSComparison__Group_1_0_2__1(); | ||
14486 | |||
14487 | state._fsp--; | ||
14488 | if (state.failed) return ; | ||
14489 | |||
14490 | } | ||
14491 | |||
14492 | } | ||
14493 | catch (RecognitionException re) { | ||
14494 | reportError(re); | ||
14495 | recover(input,re); | ||
14496 | } | ||
14497 | finally { | ||
14498 | |||
14499 | restoreStackSize(stackSize); | ||
14500 | |||
14501 | } | ||
14502 | return ; | ||
14503 | } | ||
14504 | // $ANTLR end "rule__ALSComparison__Group_1_0_2__0" | ||
14505 | |||
14506 | |||
14507 | // $ANTLR start "rule__ALSComparison__Group_1_0_2__0__Impl" | ||
14508 | // InternalAlloyLanguage.g:4936:1: rule__ALSComparison__Group_1_0_2__0__Impl : ( () ) ; | ||
14509 | public final void rule__ALSComparison__Group_1_0_2__0__Impl() throws RecognitionException { | ||
14510 | |||
14511 | int stackSize = keepStackSize(); | ||
14512 | |||
14513 | try { | ||
14514 | // InternalAlloyLanguage.g:4940:1: ( ( () ) ) | ||
14515 | // InternalAlloyLanguage.g:4941:1: ( () ) | ||
14516 | { | ||
14517 | // InternalAlloyLanguage.g:4941:1: ( () ) | ||
14518 | // InternalAlloyLanguage.g:4942:1: () | ||
14519 | { | ||
14520 | if ( state.backtracking==0 ) { | ||
14521 | before(grammarAccess.getALSComparisonAccess().getALSSubsetLeftOperandAction_1_0_2_0()); | ||
14522 | } | ||
14523 | // InternalAlloyLanguage.g:4943:1: () | ||
14524 | // InternalAlloyLanguage.g:4945:1: | ||
14525 | { | ||
14526 | } | ||
14527 | |||
14528 | if ( state.backtracking==0 ) { | ||
14529 | after(grammarAccess.getALSComparisonAccess().getALSSubsetLeftOperandAction_1_0_2_0()); | ||
14530 | } | ||
14531 | |||
14532 | } | ||
14533 | |||
14534 | |||
14535 | } | ||
14536 | |||
14537 | } | ||
14538 | finally { | ||
14539 | |||
14540 | restoreStackSize(stackSize); | ||
14541 | |||
14542 | } | ||
14543 | return ; | ||
14544 | } | ||
14545 | // $ANTLR end "rule__ALSComparison__Group_1_0_2__0__Impl" | ||
14546 | |||
14547 | |||
14548 | // $ANTLR start "rule__ALSComparison__Group_1_0_2__1" | ||
14549 | // InternalAlloyLanguage.g:4955:1: rule__ALSComparison__Group_1_0_2__1 : rule__ALSComparison__Group_1_0_2__1__Impl ; | ||
14550 | public final void rule__ALSComparison__Group_1_0_2__1() throws RecognitionException { | ||
14551 | |||
14552 | int stackSize = keepStackSize(); | ||
14553 | |||
14554 | try { | ||
14555 | // InternalAlloyLanguage.g:4959:1: ( rule__ALSComparison__Group_1_0_2__1__Impl ) | ||
14556 | // InternalAlloyLanguage.g:4960:2: rule__ALSComparison__Group_1_0_2__1__Impl | ||
14557 | { | ||
14558 | pushFollow(FOLLOW_2); | ||
14559 | rule__ALSComparison__Group_1_0_2__1__Impl(); | ||
14560 | |||
14561 | state._fsp--; | ||
14562 | if (state.failed) return ; | ||
14563 | |||
14564 | } | ||
14565 | |||
14566 | } | ||
14567 | catch (RecognitionException re) { | ||
14568 | reportError(re); | ||
14569 | recover(input,re); | ||
14570 | } | ||
14571 | finally { | ||
14572 | |||
14573 | restoreStackSize(stackSize); | ||
14574 | |||
14575 | } | ||
14576 | return ; | ||
14577 | } | ||
14578 | // $ANTLR end "rule__ALSComparison__Group_1_0_2__1" | ||
14579 | |||
14580 | |||
14581 | // $ANTLR start "rule__ALSComparison__Group_1_0_2__1__Impl" | ||
14582 | // InternalAlloyLanguage.g:4966:1: rule__ALSComparison__Group_1_0_2__1__Impl : ( 'in' ) ; | ||
14583 | public final void rule__ALSComparison__Group_1_0_2__1__Impl() throws RecognitionException { | ||
14584 | |||
14585 | int stackSize = keepStackSize(); | ||
14586 | |||
14587 | try { | ||
14588 | // InternalAlloyLanguage.g:4970:1: ( ( 'in' ) ) | ||
14589 | // InternalAlloyLanguage.g:4971:1: ( 'in' ) | ||
14590 | { | ||
14591 | // InternalAlloyLanguage.g:4971:1: ( 'in' ) | ||
14592 | // InternalAlloyLanguage.g:4972:1: 'in' | ||
14593 | { | ||
14594 | if ( state.backtracking==0 ) { | ||
14595 | before(grammarAccess.getALSComparisonAccess().getInKeyword_1_0_2_1()); | ||
14596 | } | ||
14597 | match(input,38,FOLLOW_2); if (state.failed) return ; | ||
14598 | if ( state.backtracking==0 ) { | ||
14599 | after(grammarAccess.getALSComparisonAccess().getInKeyword_1_0_2_1()); | ||
14600 | } | ||
14601 | |||
14602 | } | ||
14603 | |||
14604 | |||
14605 | } | ||
14606 | |||
14607 | } | ||
14608 | catch (RecognitionException re) { | ||
14609 | reportError(re); | ||
14610 | recover(input,re); | ||
14611 | } | ||
14612 | finally { | ||
14613 | |||
14614 | restoreStackSize(stackSize); | ||
14615 | |||
14616 | } | ||
14617 | return ; | ||
14618 | } | ||
14619 | // $ANTLR end "rule__ALSComparison__Group_1_0_2__1__Impl" | ||
14620 | |||
14621 | |||
14622 | // $ANTLR start "rule__ALSComparison__Group_1_0_3__0" | ||
14623 | // InternalAlloyLanguage.g:4989:1: rule__ALSComparison__Group_1_0_3__0 : rule__ALSComparison__Group_1_0_3__0__Impl rule__ALSComparison__Group_1_0_3__1 ; | ||
14624 | public final void rule__ALSComparison__Group_1_0_3__0() throws RecognitionException { | ||
14625 | |||
14626 | int stackSize = keepStackSize(); | ||
14627 | |||
14628 | try { | ||
14629 | // InternalAlloyLanguage.g:4993:1: ( rule__ALSComparison__Group_1_0_3__0__Impl rule__ALSComparison__Group_1_0_3__1 ) | ||
14630 | // InternalAlloyLanguage.g:4994:2: rule__ALSComparison__Group_1_0_3__0__Impl rule__ALSComparison__Group_1_0_3__1 | ||
14631 | { | ||
14632 | pushFollow(FOLLOW_34); | ||
14633 | rule__ALSComparison__Group_1_0_3__0__Impl(); | ||
14634 | |||
14635 | state._fsp--; | ||
14636 | if (state.failed) return ; | ||
14637 | pushFollow(FOLLOW_2); | ||
14638 | rule__ALSComparison__Group_1_0_3__1(); | ||
14639 | |||
14640 | state._fsp--; | ||
14641 | if (state.failed) return ; | ||
14642 | |||
14643 | } | ||
14644 | |||
14645 | } | ||
14646 | catch (RecognitionException re) { | ||
14647 | reportError(re); | ||
14648 | recover(input,re); | ||
14649 | } | ||
14650 | finally { | ||
14651 | |||
14652 | restoreStackSize(stackSize); | ||
14653 | |||
14654 | } | ||
14655 | return ; | ||
14656 | } | ||
14657 | // $ANTLR end "rule__ALSComparison__Group_1_0_3__0" | ||
14658 | |||
14659 | |||
14660 | // $ANTLR start "rule__ALSComparison__Group_1_0_3__0__Impl" | ||
14661 | // InternalAlloyLanguage.g:5001:1: rule__ALSComparison__Group_1_0_3__0__Impl : ( () ) ; | ||
14662 | public final void rule__ALSComparison__Group_1_0_3__0__Impl() throws RecognitionException { | ||
14663 | |||
14664 | int stackSize = keepStackSize(); | ||
14665 | |||
14666 | try { | ||
14667 | // InternalAlloyLanguage.g:5005:1: ( ( () ) ) | ||
14668 | // InternalAlloyLanguage.g:5006:1: ( () ) | ||
14669 | { | ||
14670 | // InternalAlloyLanguage.g:5006:1: ( () ) | ||
14671 | // InternalAlloyLanguage.g:5007:1: () | ||
14672 | { | ||
14673 | if ( state.backtracking==0 ) { | ||
14674 | before(grammarAccess.getALSComparisonAccess().getALSLessLeftOperandAction_1_0_3_0()); | ||
14675 | } | ||
14676 | // InternalAlloyLanguage.g:5008:1: () | ||
14677 | // InternalAlloyLanguage.g:5010:1: | ||
14678 | { | ||
14679 | } | ||
14680 | |||
14681 | if ( state.backtracking==0 ) { | ||
14682 | after(grammarAccess.getALSComparisonAccess().getALSLessLeftOperandAction_1_0_3_0()); | ||
14683 | } | ||
14684 | |||
14685 | } | ||
14686 | |||
14687 | |||
14688 | } | ||
14689 | |||
14690 | } | ||
14691 | finally { | ||
14692 | |||
14693 | restoreStackSize(stackSize); | ||
14694 | |||
14695 | } | ||
14696 | return ; | ||
14697 | } | ||
14698 | // $ANTLR end "rule__ALSComparison__Group_1_0_3__0__Impl" | ||
14699 | |||
14700 | |||
14701 | // $ANTLR start "rule__ALSComparison__Group_1_0_3__1" | ||
14702 | // InternalAlloyLanguage.g:5020:1: rule__ALSComparison__Group_1_0_3__1 : rule__ALSComparison__Group_1_0_3__1__Impl ; | ||
14703 | public final void rule__ALSComparison__Group_1_0_3__1() throws RecognitionException { | ||
14704 | |||
14705 | int stackSize = keepStackSize(); | ||
14706 | |||
14707 | try { | ||
14708 | // InternalAlloyLanguage.g:5024:1: ( rule__ALSComparison__Group_1_0_3__1__Impl ) | ||
14709 | // InternalAlloyLanguage.g:5025:2: rule__ALSComparison__Group_1_0_3__1__Impl | ||
14710 | { | ||
14711 | pushFollow(FOLLOW_2); | ||
14712 | rule__ALSComparison__Group_1_0_3__1__Impl(); | ||
14713 | |||
14714 | state._fsp--; | ||
14715 | if (state.failed) return ; | ||
14716 | |||
14717 | } | ||
14718 | |||
14719 | } | ||
14720 | catch (RecognitionException re) { | ||
14721 | reportError(re); | ||
14722 | recover(input,re); | ||
14723 | } | ||
14724 | finally { | ||
14725 | |||
14726 | restoreStackSize(stackSize); | ||
14727 | |||
14728 | } | ||
14729 | return ; | ||
14730 | } | ||
14731 | // $ANTLR end "rule__ALSComparison__Group_1_0_3__1" | ||
14732 | |||
14733 | |||
14734 | // $ANTLR start "rule__ALSComparison__Group_1_0_3__1__Impl" | ||
14735 | // InternalAlloyLanguage.g:5031:1: rule__ALSComparison__Group_1_0_3__1__Impl : ( '>' ) ; | ||
14736 | public final void rule__ALSComparison__Group_1_0_3__1__Impl() throws RecognitionException { | ||
14737 | |||
14738 | int stackSize = keepStackSize(); | ||
14739 | |||
14740 | try { | ||
14741 | // InternalAlloyLanguage.g:5035:1: ( ( '>' ) ) | ||
14742 | // InternalAlloyLanguage.g:5036:1: ( '>' ) | ||
14743 | { | ||
14744 | // InternalAlloyLanguage.g:5036:1: ( '>' ) | ||
14745 | // InternalAlloyLanguage.g:5037:1: '>' | ||
14746 | { | ||
14747 | if ( state.backtracking==0 ) { | ||
14748 | before(grammarAccess.getALSComparisonAccess().getGreaterThanSignKeyword_1_0_3_1()); | ||
14749 | } | ||
14750 | match(input,49,FOLLOW_2); if (state.failed) return ; | ||
14751 | if ( state.backtracking==0 ) { | ||
14752 | after(grammarAccess.getALSComparisonAccess().getGreaterThanSignKeyword_1_0_3_1()); | ||
14753 | } | ||
14754 | |||
14755 | } | ||
14756 | |||
14757 | |||
14758 | } | ||
14759 | |||
14760 | } | ||
14761 | catch (RecognitionException re) { | ||
14762 | reportError(re); | ||
14763 | recover(input,re); | ||
14764 | } | ||
14765 | finally { | ||
14766 | |||
14767 | restoreStackSize(stackSize); | ||
14768 | |||
14769 | } | ||
14770 | return ; | ||
14771 | } | ||
14772 | // $ANTLR end "rule__ALSComparison__Group_1_0_3__1__Impl" | ||
14773 | |||
14774 | |||
14775 | // $ANTLR start "rule__ALSComparison__Group_1_0_4__0" | ||
14776 | // InternalAlloyLanguage.g:5054:1: rule__ALSComparison__Group_1_0_4__0 : rule__ALSComparison__Group_1_0_4__0__Impl rule__ALSComparison__Group_1_0_4__1 ; | ||
14777 | public final void rule__ALSComparison__Group_1_0_4__0() throws RecognitionException { | ||
14778 | |||
14779 | int stackSize = keepStackSize(); | ||
14780 | |||
14781 | try { | ||
14782 | // InternalAlloyLanguage.g:5058:1: ( rule__ALSComparison__Group_1_0_4__0__Impl rule__ALSComparison__Group_1_0_4__1 ) | ||
14783 | // InternalAlloyLanguage.g:5059:2: rule__ALSComparison__Group_1_0_4__0__Impl rule__ALSComparison__Group_1_0_4__1 | ||
14784 | { | ||
14785 | pushFollow(FOLLOW_35); | ||
14786 | rule__ALSComparison__Group_1_0_4__0__Impl(); | ||
14787 | |||
14788 | state._fsp--; | ||
14789 | if (state.failed) return ; | ||
14790 | pushFollow(FOLLOW_2); | ||
14791 | rule__ALSComparison__Group_1_0_4__1(); | ||
14792 | |||
14793 | state._fsp--; | ||
14794 | if (state.failed) return ; | ||
14795 | |||
14796 | } | ||
14797 | |||
14798 | } | ||
14799 | catch (RecognitionException re) { | ||
14800 | reportError(re); | ||
14801 | recover(input,re); | ||
14802 | } | ||
14803 | finally { | ||
14804 | |||
14805 | restoreStackSize(stackSize); | ||
14806 | |||
14807 | } | ||
14808 | return ; | ||
14809 | } | ||
14810 | // $ANTLR end "rule__ALSComparison__Group_1_0_4__0" | ||
14811 | |||
14812 | |||
14813 | // $ANTLR start "rule__ALSComparison__Group_1_0_4__0__Impl" | ||
14814 | // InternalAlloyLanguage.g:5066:1: rule__ALSComparison__Group_1_0_4__0__Impl : ( () ) ; | ||
14815 | public final void rule__ALSComparison__Group_1_0_4__0__Impl() throws RecognitionException { | ||
14816 | |||
14817 | int stackSize = keepStackSize(); | ||
14818 | |||
14819 | try { | ||
14820 | // InternalAlloyLanguage.g:5070:1: ( ( () ) ) | ||
14821 | // InternalAlloyLanguage.g:5071:1: ( () ) | ||
14822 | { | ||
14823 | // InternalAlloyLanguage.g:5071:1: ( () ) | ||
14824 | // InternalAlloyLanguage.g:5072:1: () | ||
14825 | { | ||
14826 | if ( state.backtracking==0 ) { | ||
14827 | before(grammarAccess.getALSComparisonAccess().getALSLeqLeftOperandAction_1_0_4_0()); | ||
14828 | } | ||
14829 | // InternalAlloyLanguage.g:5073:1: () | ||
14830 | // InternalAlloyLanguage.g:5075:1: | ||
14831 | { | ||
14832 | } | ||
14833 | |||
14834 | if ( state.backtracking==0 ) { | ||
14835 | after(grammarAccess.getALSComparisonAccess().getALSLeqLeftOperandAction_1_0_4_0()); | ||
14836 | } | ||
14837 | |||
14838 | } | ||
14839 | |||
14840 | |||
14841 | } | ||
14842 | |||
14843 | } | ||
14844 | finally { | ||
14845 | |||
14846 | restoreStackSize(stackSize); | ||
14847 | |||
14848 | } | ||
14849 | return ; | ||
14850 | } | ||
14851 | // $ANTLR end "rule__ALSComparison__Group_1_0_4__0__Impl" | ||
14852 | |||
14853 | |||
14854 | // $ANTLR start "rule__ALSComparison__Group_1_0_4__1" | ||
14855 | // InternalAlloyLanguage.g:5085:1: rule__ALSComparison__Group_1_0_4__1 : rule__ALSComparison__Group_1_0_4__1__Impl ; | ||
14856 | public final void rule__ALSComparison__Group_1_0_4__1() throws RecognitionException { | ||
14857 | |||
14858 | int stackSize = keepStackSize(); | ||
14859 | |||
14860 | try { | ||
14861 | // InternalAlloyLanguage.g:5089:1: ( rule__ALSComparison__Group_1_0_4__1__Impl ) | ||
14862 | // InternalAlloyLanguage.g:5090:2: rule__ALSComparison__Group_1_0_4__1__Impl | ||
14863 | { | ||
14864 | pushFollow(FOLLOW_2); | ||
14865 | rule__ALSComparison__Group_1_0_4__1__Impl(); | ||
14866 | |||
14867 | state._fsp--; | ||
14868 | if (state.failed) return ; | ||
14869 | |||
14870 | } | ||
14871 | |||
14872 | } | ||
14873 | catch (RecognitionException re) { | ||
14874 | reportError(re); | ||
14875 | recover(input,re); | ||
14876 | } | ||
14877 | finally { | ||
14878 | |||
14879 | restoreStackSize(stackSize); | ||
14880 | |||
14881 | } | ||
14882 | return ; | ||
14883 | } | ||
14884 | // $ANTLR end "rule__ALSComparison__Group_1_0_4__1" | ||
14885 | |||
14886 | |||
14887 | // $ANTLR start "rule__ALSComparison__Group_1_0_4__1__Impl" | ||
14888 | // InternalAlloyLanguage.g:5096:1: rule__ALSComparison__Group_1_0_4__1__Impl : ( '>=' ) ; | ||
14889 | public final void rule__ALSComparison__Group_1_0_4__1__Impl() throws RecognitionException { | ||
14890 | |||
14891 | int stackSize = keepStackSize(); | ||
14892 | |||
14893 | try { | ||
14894 | // InternalAlloyLanguage.g:5100:1: ( ( '>=' ) ) | ||
14895 | // InternalAlloyLanguage.g:5101:1: ( '>=' ) | ||
14896 | { | ||
14897 | // InternalAlloyLanguage.g:5101:1: ( '>=' ) | ||
14898 | // InternalAlloyLanguage.g:5102:1: '>=' | ||
14899 | { | ||
14900 | if ( state.backtracking==0 ) { | ||
14901 | before(grammarAccess.getALSComparisonAccess().getGreaterThanSignEqualsSignKeyword_1_0_4_1()); | ||
14902 | } | ||
14903 | match(input,50,FOLLOW_2); if (state.failed) return ; | ||
14904 | if ( state.backtracking==0 ) { | ||
14905 | after(grammarAccess.getALSComparisonAccess().getGreaterThanSignEqualsSignKeyword_1_0_4_1()); | ||
14906 | } | ||
14907 | |||
14908 | } | ||
14909 | |||
14910 | |||
14911 | } | ||
14912 | |||
14913 | } | ||
14914 | catch (RecognitionException re) { | ||
14915 | reportError(re); | ||
14916 | recover(input,re); | ||
14917 | } | ||
14918 | finally { | ||
14919 | |||
14920 | restoreStackSize(stackSize); | ||
14921 | |||
14922 | } | ||
14923 | return ; | ||
14924 | } | ||
14925 | // $ANTLR end "rule__ALSComparison__Group_1_0_4__1__Impl" | ||
14926 | |||
14927 | |||
14928 | // $ANTLR start "rule__ALSComparison__Group_1_0_5__0" | ||
14929 | // InternalAlloyLanguage.g:5119:1: rule__ALSComparison__Group_1_0_5__0 : rule__ALSComparison__Group_1_0_5__0__Impl rule__ALSComparison__Group_1_0_5__1 ; | ||
14930 | public final void rule__ALSComparison__Group_1_0_5__0() throws RecognitionException { | ||
14931 | |||
14932 | int stackSize = keepStackSize(); | ||
14933 | |||
14934 | try { | ||
14935 | // InternalAlloyLanguage.g:5123:1: ( rule__ALSComparison__Group_1_0_5__0__Impl rule__ALSComparison__Group_1_0_5__1 ) | ||
14936 | // InternalAlloyLanguage.g:5124:2: rule__ALSComparison__Group_1_0_5__0__Impl rule__ALSComparison__Group_1_0_5__1 | ||
14937 | { | ||
14938 | pushFollow(FOLLOW_36); | ||
14939 | rule__ALSComparison__Group_1_0_5__0__Impl(); | ||
14940 | |||
14941 | state._fsp--; | ||
14942 | if (state.failed) return ; | ||
14943 | pushFollow(FOLLOW_2); | ||
14944 | rule__ALSComparison__Group_1_0_5__1(); | ||
14945 | |||
14946 | state._fsp--; | ||
14947 | if (state.failed) return ; | ||
14948 | |||
14949 | } | ||
14950 | |||
14951 | } | ||
14952 | catch (RecognitionException re) { | ||
14953 | reportError(re); | ||
14954 | recover(input,re); | ||
14955 | } | ||
14956 | finally { | ||
14957 | |||
14958 | restoreStackSize(stackSize); | ||
14959 | |||
14960 | } | ||
14961 | return ; | ||
14962 | } | ||
14963 | // $ANTLR end "rule__ALSComparison__Group_1_0_5__0" | ||
14964 | |||
14965 | |||
14966 | // $ANTLR start "rule__ALSComparison__Group_1_0_5__0__Impl" | ||
14967 | // InternalAlloyLanguage.g:5131:1: rule__ALSComparison__Group_1_0_5__0__Impl : ( () ) ; | ||
14968 | public final void rule__ALSComparison__Group_1_0_5__0__Impl() throws RecognitionException { | ||
14969 | |||
14970 | int stackSize = keepStackSize(); | ||
14971 | |||
14972 | try { | ||
14973 | // InternalAlloyLanguage.g:5135:1: ( ( () ) ) | ||
14974 | // InternalAlloyLanguage.g:5136:1: ( () ) | ||
14975 | { | ||
14976 | // InternalAlloyLanguage.g:5136:1: ( () ) | ||
14977 | // InternalAlloyLanguage.g:5137:1: () | ||
14978 | { | ||
14979 | if ( state.backtracking==0 ) { | ||
14980 | before(grammarAccess.getALSComparisonAccess().getALSMoreLeftOperandAction_1_0_5_0()); | ||
14981 | } | ||
14982 | // InternalAlloyLanguage.g:5138:1: () | ||
14983 | // InternalAlloyLanguage.g:5140:1: | ||
14984 | { | ||
14985 | } | ||
14986 | |||
14987 | if ( state.backtracking==0 ) { | ||
14988 | after(grammarAccess.getALSComparisonAccess().getALSMoreLeftOperandAction_1_0_5_0()); | ||
14989 | } | ||
14990 | |||
14991 | } | ||
14992 | |||
14993 | |||
14994 | } | ||
14995 | |||
14996 | } | ||
14997 | finally { | ||
14998 | |||
14999 | restoreStackSize(stackSize); | ||
15000 | |||
15001 | } | ||
15002 | return ; | ||
15003 | } | ||
15004 | // $ANTLR end "rule__ALSComparison__Group_1_0_5__0__Impl" | ||
15005 | |||
15006 | |||
15007 | // $ANTLR start "rule__ALSComparison__Group_1_0_5__1" | ||
15008 | // InternalAlloyLanguage.g:5150:1: rule__ALSComparison__Group_1_0_5__1 : rule__ALSComparison__Group_1_0_5__1__Impl ; | ||
15009 | public final void rule__ALSComparison__Group_1_0_5__1() throws RecognitionException { | ||
15010 | |||
15011 | int stackSize = keepStackSize(); | ||
15012 | |||
15013 | try { | ||
15014 | // InternalAlloyLanguage.g:5154:1: ( rule__ALSComparison__Group_1_0_5__1__Impl ) | ||
15015 | // InternalAlloyLanguage.g:5155:2: rule__ALSComparison__Group_1_0_5__1__Impl | ||
15016 | { | ||
15017 | pushFollow(FOLLOW_2); | ||
15018 | rule__ALSComparison__Group_1_0_5__1__Impl(); | ||
15019 | |||
15020 | state._fsp--; | ||
15021 | if (state.failed) return ; | ||
15022 | |||
15023 | } | ||
15024 | |||
15025 | } | ||
15026 | catch (RecognitionException re) { | ||
15027 | reportError(re); | ||
15028 | recover(input,re); | ||
15029 | } | ||
15030 | finally { | ||
15031 | |||
15032 | restoreStackSize(stackSize); | ||
15033 | |||
15034 | } | ||
15035 | return ; | ||
15036 | } | ||
15037 | // $ANTLR end "rule__ALSComparison__Group_1_0_5__1" | ||
15038 | |||
15039 | |||
15040 | // $ANTLR start "rule__ALSComparison__Group_1_0_5__1__Impl" | ||
15041 | // InternalAlloyLanguage.g:5161:1: rule__ALSComparison__Group_1_0_5__1__Impl : ( '<' ) ; | ||
15042 | public final void rule__ALSComparison__Group_1_0_5__1__Impl() throws RecognitionException { | ||
15043 | |||
15044 | int stackSize = keepStackSize(); | ||
15045 | |||
15046 | try { | ||
15047 | // InternalAlloyLanguage.g:5165:1: ( ( '<' ) ) | ||
15048 | // InternalAlloyLanguage.g:5166:1: ( '<' ) | ||
15049 | { | ||
15050 | // InternalAlloyLanguage.g:5166:1: ( '<' ) | ||
15051 | // InternalAlloyLanguage.g:5167:1: '<' | ||
15052 | { | ||
15053 | if ( state.backtracking==0 ) { | ||
15054 | before(grammarAccess.getALSComparisonAccess().getLessThanSignKeyword_1_0_5_1()); | ||
15055 | } | ||
15056 | match(input,51,FOLLOW_2); if (state.failed) return ; | ||
15057 | if ( state.backtracking==0 ) { | ||
15058 | after(grammarAccess.getALSComparisonAccess().getLessThanSignKeyword_1_0_5_1()); | ||
15059 | } | ||
15060 | |||
15061 | } | ||
15062 | |||
15063 | |||
15064 | } | ||
15065 | |||
15066 | } | ||
15067 | catch (RecognitionException re) { | ||
15068 | reportError(re); | ||
15069 | recover(input,re); | ||
15070 | } | ||
15071 | finally { | ||
15072 | |||
15073 | restoreStackSize(stackSize); | ||
15074 | |||
15075 | } | ||
15076 | return ; | ||
15077 | } | ||
15078 | // $ANTLR end "rule__ALSComparison__Group_1_0_5__1__Impl" | ||
15079 | |||
15080 | |||
15081 | // $ANTLR start "rule__ALSComparison__Group_1_0_6__0" | ||
15082 | // InternalAlloyLanguage.g:5184:1: rule__ALSComparison__Group_1_0_6__0 : rule__ALSComparison__Group_1_0_6__0__Impl rule__ALSComparison__Group_1_0_6__1 ; | ||
15083 | public final void rule__ALSComparison__Group_1_0_6__0() throws RecognitionException { | ||
15084 | |||
15085 | int stackSize = keepStackSize(); | ||
15086 | |||
15087 | try { | ||
15088 | // InternalAlloyLanguage.g:5188:1: ( rule__ALSComparison__Group_1_0_6__0__Impl rule__ALSComparison__Group_1_0_6__1 ) | ||
15089 | // InternalAlloyLanguage.g:5189:2: rule__ALSComparison__Group_1_0_6__0__Impl rule__ALSComparison__Group_1_0_6__1 | ||
15090 | { | ||
15091 | pushFollow(FOLLOW_30); | ||
15092 | rule__ALSComparison__Group_1_0_6__0__Impl(); | ||
15093 | |||
15094 | state._fsp--; | ||
15095 | if (state.failed) return ; | ||
15096 | pushFollow(FOLLOW_2); | ||
15097 | rule__ALSComparison__Group_1_0_6__1(); | ||
15098 | |||
15099 | state._fsp--; | ||
15100 | if (state.failed) return ; | ||
15101 | |||
15102 | } | ||
15103 | |||
15104 | } | ||
15105 | catch (RecognitionException re) { | ||
15106 | reportError(re); | ||
15107 | recover(input,re); | ||
15108 | } | ||
15109 | finally { | ||
15110 | |||
15111 | restoreStackSize(stackSize); | ||
15112 | |||
15113 | } | ||
15114 | return ; | ||
15115 | } | ||
15116 | // $ANTLR end "rule__ALSComparison__Group_1_0_6__0" | ||
15117 | |||
15118 | |||
15119 | // $ANTLR start "rule__ALSComparison__Group_1_0_6__0__Impl" | ||
15120 | // InternalAlloyLanguage.g:5196:1: rule__ALSComparison__Group_1_0_6__0__Impl : ( () ) ; | ||
15121 | public final void rule__ALSComparison__Group_1_0_6__0__Impl() throws RecognitionException { | ||
15122 | |||
15123 | int stackSize = keepStackSize(); | ||
15124 | |||
15125 | try { | ||
15126 | // InternalAlloyLanguage.g:5200:1: ( ( () ) ) | ||
15127 | // InternalAlloyLanguage.g:5201:1: ( () ) | ||
15128 | { | ||
15129 | // InternalAlloyLanguage.g:5201:1: ( () ) | ||
15130 | // InternalAlloyLanguage.g:5202:1: () | ||
15131 | { | ||
15132 | if ( state.backtracking==0 ) { | ||
15133 | before(grammarAccess.getALSComparisonAccess().getALSMeqLeftOperandAction_1_0_6_0()); | ||
15134 | } | ||
15135 | // InternalAlloyLanguage.g:5203:1: () | ||
15136 | // InternalAlloyLanguage.g:5205:1: | ||
15137 | { | ||
15138 | } | ||
15139 | |||
15140 | if ( state.backtracking==0 ) { | ||
15141 | after(grammarAccess.getALSComparisonAccess().getALSMeqLeftOperandAction_1_0_6_0()); | ||
15142 | } | ||
15143 | |||
15144 | } | ||
15145 | |||
15146 | |||
15147 | } | ||
15148 | |||
15149 | } | ||
15150 | finally { | ||
15151 | |||
15152 | restoreStackSize(stackSize); | ||
15153 | |||
15154 | } | ||
15155 | return ; | ||
15156 | } | ||
15157 | // $ANTLR end "rule__ALSComparison__Group_1_0_6__0__Impl" | ||
15158 | |||
15159 | |||
15160 | // $ANTLR start "rule__ALSComparison__Group_1_0_6__1" | ||
15161 | // InternalAlloyLanguage.g:5215:1: rule__ALSComparison__Group_1_0_6__1 : rule__ALSComparison__Group_1_0_6__1__Impl ; | ||
15162 | public final void rule__ALSComparison__Group_1_0_6__1() throws RecognitionException { | ||
15163 | |||
15164 | int stackSize = keepStackSize(); | ||
15165 | |||
15166 | try { | ||
15167 | // InternalAlloyLanguage.g:5219:1: ( rule__ALSComparison__Group_1_0_6__1__Impl ) | ||
15168 | // InternalAlloyLanguage.g:5220:2: rule__ALSComparison__Group_1_0_6__1__Impl | ||
15169 | { | ||
15170 | pushFollow(FOLLOW_2); | ||
15171 | rule__ALSComparison__Group_1_0_6__1__Impl(); | ||
15172 | |||
15173 | state._fsp--; | ||
15174 | if (state.failed) return ; | ||
15175 | |||
15176 | } | ||
15177 | |||
15178 | } | ||
15179 | catch (RecognitionException re) { | ||
15180 | reportError(re); | ||
15181 | recover(input,re); | ||
15182 | } | ||
15183 | finally { | ||
15184 | |||
15185 | restoreStackSize(stackSize); | ||
15186 | |||
15187 | } | ||
15188 | return ; | ||
15189 | } | ||
15190 | // $ANTLR end "rule__ALSComparison__Group_1_0_6__1" | ||
15191 | |||
15192 | |||
15193 | // $ANTLR start "rule__ALSComparison__Group_1_0_6__1__Impl" | ||
15194 | // InternalAlloyLanguage.g:5226:1: rule__ALSComparison__Group_1_0_6__1__Impl : ( '<=' ) ; | ||
15195 | public final void rule__ALSComparison__Group_1_0_6__1__Impl() throws RecognitionException { | ||
15196 | |||
15197 | int stackSize = keepStackSize(); | ||
15198 | |||
15199 | try { | ||
15200 | // InternalAlloyLanguage.g:5230:1: ( ( '<=' ) ) | ||
15201 | // InternalAlloyLanguage.g:5231:1: ( '<=' ) | ||
15202 | { | ||
15203 | // InternalAlloyLanguage.g:5231:1: ( '<=' ) | ||
15204 | // InternalAlloyLanguage.g:5232:1: '<=' | ||
15205 | { | ||
15206 | if ( state.backtracking==0 ) { | ||
15207 | before(grammarAccess.getALSComparisonAccess().getLessThanSignEqualsSignKeyword_1_0_6_1()); | ||
15208 | } | ||
15209 | match(input,52,FOLLOW_2); if (state.failed) return ; | ||
15210 | if ( state.backtracking==0 ) { | ||
15211 | after(grammarAccess.getALSComparisonAccess().getLessThanSignEqualsSignKeyword_1_0_6_1()); | ||
15212 | } | ||
15213 | |||
15214 | } | ||
15215 | |||
15216 | |||
15217 | } | ||
15218 | |||
15219 | } | ||
15220 | catch (RecognitionException re) { | ||
15221 | reportError(re); | ||
15222 | recover(input,re); | ||
15223 | } | ||
15224 | finally { | ||
15225 | |||
15226 | restoreStackSize(stackSize); | ||
15227 | |||
15228 | } | ||
15229 | return ; | ||
15230 | } | ||
15231 | // $ANTLR end "rule__ALSComparison__Group_1_0_6__1__Impl" | ||
15232 | |||
15233 | |||
15234 | // $ANTLR start "rule__ALSOverride__Group__0" | ||
15235 | // InternalAlloyLanguage.g:5249:1: rule__ALSOverride__Group__0 : rule__ALSOverride__Group__0__Impl rule__ALSOverride__Group__1 ; | ||
15236 | public final void rule__ALSOverride__Group__0() throws RecognitionException { | ||
15237 | |||
15238 | int stackSize = keepStackSize(); | ||
15239 | |||
15240 | try { | ||
15241 | // InternalAlloyLanguage.g:5253:1: ( rule__ALSOverride__Group__0__Impl rule__ALSOverride__Group__1 ) | ||
15242 | // InternalAlloyLanguage.g:5254:2: rule__ALSOverride__Group__0__Impl rule__ALSOverride__Group__1 | ||
15243 | { | ||
15244 | pushFollow(FOLLOW_37); | ||
15245 | rule__ALSOverride__Group__0__Impl(); | ||
15246 | |||
15247 | state._fsp--; | ||
15248 | if (state.failed) return ; | ||
15249 | pushFollow(FOLLOW_2); | ||
15250 | rule__ALSOverride__Group__1(); | ||
15251 | |||
15252 | state._fsp--; | ||
15253 | if (state.failed) return ; | ||
15254 | |||
15255 | } | ||
15256 | |||
15257 | } | ||
15258 | catch (RecognitionException re) { | ||
15259 | reportError(re); | ||
15260 | recover(input,re); | ||
15261 | } | ||
15262 | finally { | ||
15263 | |||
15264 | restoreStackSize(stackSize); | ||
15265 | |||
15266 | } | ||
15267 | return ; | ||
15268 | } | ||
15269 | // $ANTLR end "rule__ALSOverride__Group__0" | ||
15270 | |||
15271 | |||
15272 | // $ANTLR start "rule__ALSOverride__Group__0__Impl" | ||
15273 | // InternalAlloyLanguage.g:5261:1: rule__ALSOverride__Group__0__Impl : ( ruleALSRangeRestrictionRight ) ; | ||
15274 | public final void rule__ALSOverride__Group__0__Impl() throws RecognitionException { | ||
15275 | |||
15276 | int stackSize = keepStackSize(); | ||
15277 | |||
15278 | try { | ||
15279 | // InternalAlloyLanguage.g:5265:1: ( ( ruleALSRangeRestrictionRight ) ) | ||
15280 | // InternalAlloyLanguage.g:5266:1: ( ruleALSRangeRestrictionRight ) | ||
15281 | { | ||
15282 | // InternalAlloyLanguage.g:5266:1: ( ruleALSRangeRestrictionRight ) | ||
15283 | // InternalAlloyLanguage.g:5267:1: ruleALSRangeRestrictionRight | ||
15284 | { | ||
15285 | if ( state.backtracking==0 ) { | ||
15286 | before(grammarAccess.getALSOverrideAccess().getALSRangeRestrictionRightParserRuleCall_0()); | ||
15287 | } | ||
15288 | pushFollow(FOLLOW_2); | ||
15289 | ruleALSRangeRestrictionRight(); | ||
15290 | |||
15291 | state._fsp--; | ||
15292 | if (state.failed) return ; | ||
15293 | if ( state.backtracking==0 ) { | ||
15294 | after(grammarAccess.getALSOverrideAccess().getALSRangeRestrictionRightParserRuleCall_0()); | ||
15295 | } | ||
15296 | |||
15297 | } | ||
15298 | |||
15299 | |||
15300 | } | ||
15301 | |||
15302 | } | ||
15303 | catch (RecognitionException re) { | ||
15304 | reportError(re); | ||
15305 | recover(input,re); | ||
15306 | } | ||
15307 | finally { | ||
15308 | |||
15309 | restoreStackSize(stackSize); | ||
15310 | |||
15311 | } | ||
15312 | return ; | ||
15313 | } | ||
15314 | // $ANTLR end "rule__ALSOverride__Group__0__Impl" | ||
15315 | |||
15316 | |||
15317 | // $ANTLR start "rule__ALSOverride__Group__1" | ||
15318 | // InternalAlloyLanguage.g:5278:1: rule__ALSOverride__Group__1 : rule__ALSOverride__Group__1__Impl ; | ||
15319 | public final void rule__ALSOverride__Group__1() throws RecognitionException { | ||
15320 | |||
15321 | int stackSize = keepStackSize(); | ||
15322 | |||
15323 | try { | ||
15324 | // InternalAlloyLanguage.g:5282:1: ( rule__ALSOverride__Group__1__Impl ) | ||
15325 | // InternalAlloyLanguage.g:5283:2: rule__ALSOverride__Group__1__Impl | ||
15326 | { | ||
15327 | pushFollow(FOLLOW_2); | ||
15328 | rule__ALSOverride__Group__1__Impl(); | ||
15329 | |||
15330 | state._fsp--; | ||
15331 | if (state.failed) return ; | ||
15332 | |||
15333 | } | ||
15334 | |||
15335 | } | ||
15336 | catch (RecognitionException re) { | ||
15337 | reportError(re); | ||
15338 | recover(input,re); | ||
15339 | } | ||
15340 | finally { | ||
15341 | |||
15342 | restoreStackSize(stackSize); | ||
15343 | |||
15344 | } | ||
15345 | return ; | ||
15346 | } | ||
15347 | // $ANTLR end "rule__ALSOverride__Group__1" | ||
15348 | |||
15349 | |||
15350 | // $ANTLR start "rule__ALSOverride__Group__1__Impl" | ||
15351 | // InternalAlloyLanguage.g:5289:1: rule__ALSOverride__Group__1__Impl : ( ( rule__ALSOverride__Group_1__0 )? ) ; | ||
15352 | public final void rule__ALSOverride__Group__1__Impl() throws RecognitionException { | ||
15353 | |||
15354 | int stackSize = keepStackSize(); | ||
15355 | |||
15356 | try { | ||
15357 | // InternalAlloyLanguage.g:5293:1: ( ( ( rule__ALSOverride__Group_1__0 )? ) ) | ||
15358 | // InternalAlloyLanguage.g:5294:1: ( ( rule__ALSOverride__Group_1__0 )? ) | ||
15359 | { | ||
15360 | // InternalAlloyLanguage.g:5294:1: ( ( rule__ALSOverride__Group_1__0 )? ) | ||
15361 | // InternalAlloyLanguage.g:5295:1: ( rule__ALSOverride__Group_1__0 )? | ||
15362 | { | ||
15363 | if ( state.backtracking==0 ) { | ||
15364 | before(grammarAccess.getALSOverrideAccess().getGroup_1()); | ||
15365 | } | ||
15366 | // InternalAlloyLanguage.g:5296:1: ( rule__ALSOverride__Group_1__0 )? | ||
15367 | int alt36=2; | ||
15368 | int LA36_0 = input.LA(1); | ||
15369 | |||
15370 | if ( (LA36_0==53) ) { | ||
15371 | alt36=1; | ||
15372 | } | ||
15373 | switch (alt36) { | ||
15374 | case 1 : | ||
15375 | // InternalAlloyLanguage.g:5296:2: rule__ALSOverride__Group_1__0 | ||
15376 | { | ||
15377 | pushFollow(FOLLOW_2); | ||
15378 | rule__ALSOverride__Group_1__0(); | ||
15379 | |||
15380 | state._fsp--; | ||
15381 | if (state.failed) return ; | ||
15382 | |||
15383 | } | ||
15384 | break; | ||
15385 | |||
15386 | } | ||
15387 | |||
15388 | if ( state.backtracking==0 ) { | ||
15389 | after(grammarAccess.getALSOverrideAccess().getGroup_1()); | ||
15390 | } | ||
15391 | |||
15392 | } | ||
15393 | |||
15394 | |||
15395 | } | ||
15396 | |||
15397 | } | ||
15398 | catch (RecognitionException re) { | ||
15399 | reportError(re); | ||
15400 | recover(input,re); | ||
15401 | } | ||
15402 | finally { | ||
15403 | |||
15404 | restoreStackSize(stackSize); | ||
15405 | |||
15406 | } | ||
15407 | return ; | ||
15408 | } | ||
15409 | // $ANTLR end "rule__ALSOverride__Group__1__Impl" | ||
15410 | |||
15411 | |||
15412 | // $ANTLR start "rule__ALSOverride__Group_1__0" | ||
15413 | // InternalAlloyLanguage.g:5310:1: rule__ALSOverride__Group_1__0 : rule__ALSOverride__Group_1__0__Impl rule__ALSOverride__Group_1__1 ; | ||
15414 | public final void rule__ALSOverride__Group_1__0() throws RecognitionException { | ||
15415 | |||
15416 | int stackSize = keepStackSize(); | ||
15417 | |||
15418 | try { | ||
15419 | // InternalAlloyLanguage.g:5314:1: ( rule__ALSOverride__Group_1__0__Impl rule__ALSOverride__Group_1__1 ) | ||
15420 | // InternalAlloyLanguage.g:5315:2: rule__ALSOverride__Group_1__0__Impl rule__ALSOverride__Group_1__1 | ||
15421 | { | ||
15422 | pushFollow(FOLLOW_37); | ||
15423 | rule__ALSOverride__Group_1__0__Impl(); | ||
15424 | |||
15425 | state._fsp--; | ||
15426 | if (state.failed) return ; | ||
15427 | pushFollow(FOLLOW_2); | ||
15428 | rule__ALSOverride__Group_1__1(); | ||
15429 | |||
15430 | state._fsp--; | ||
15431 | if (state.failed) return ; | ||
15432 | |||
15433 | } | ||
15434 | |||
15435 | } | ||
15436 | catch (RecognitionException re) { | ||
15437 | reportError(re); | ||
15438 | recover(input,re); | ||
15439 | } | ||
15440 | finally { | ||
15441 | |||
15442 | restoreStackSize(stackSize); | ||
15443 | |||
15444 | } | ||
15445 | return ; | ||
15446 | } | ||
15447 | // $ANTLR end "rule__ALSOverride__Group_1__0" | ||
15448 | |||
15449 | |||
15450 | // $ANTLR start "rule__ALSOverride__Group_1__0__Impl" | ||
15451 | // InternalAlloyLanguage.g:5322:1: rule__ALSOverride__Group_1__0__Impl : ( () ) ; | ||
15452 | public final void rule__ALSOverride__Group_1__0__Impl() throws RecognitionException { | ||
15453 | |||
15454 | int stackSize = keepStackSize(); | ||
15455 | |||
15456 | try { | ||
15457 | // InternalAlloyLanguage.g:5326:1: ( ( () ) ) | ||
15458 | // InternalAlloyLanguage.g:5327:1: ( () ) | ||
15459 | { | ||
15460 | // InternalAlloyLanguage.g:5327:1: ( () ) | ||
15461 | // InternalAlloyLanguage.g:5328:1: () | ||
15462 | { | ||
15463 | if ( state.backtracking==0 ) { | ||
15464 | before(grammarAccess.getALSOverrideAccess().getALSOverrideLeftOperandAction_1_0()); | ||
15465 | } | ||
15466 | // InternalAlloyLanguage.g:5329:1: () | ||
15467 | // InternalAlloyLanguage.g:5331:1: | ||
15468 | { | ||
15469 | } | ||
15470 | |||
15471 | if ( state.backtracking==0 ) { | ||
15472 | after(grammarAccess.getALSOverrideAccess().getALSOverrideLeftOperandAction_1_0()); | ||
15473 | } | ||
15474 | |||
15475 | } | ||
15476 | |||
15477 | |||
15478 | } | ||
15479 | |||
15480 | } | ||
15481 | finally { | ||
15482 | |||
15483 | restoreStackSize(stackSize); | ||
15484 | |||
15485 | } | ||
15486 | return ; | ||
15487 | } | ||
15488 | // $ANTLR end "rule__ALSOverride__Group_1__0__Impl" | ||
15489 | |||
15490 | |||
15491 | // $ANTLR start "rule__ALSOverride__Group_1__1" | ||
15492 | // InternalAlloyLanguage.g:5341:1: rule__ALSOverride__Group_1__1 : rule__ALSOverride__Group_1__1__Impl rule__ALSOverride__Group_1__2 ; | ||
15493 | public final void rule__ALSOverride__Group_1__1() throws RecognitionException { | ||
15494 | |||
15495 | int stackSize = keepStackSize(); | ||
15496 | |||
15497 | try { | ||
15498 | // InternalAlloyLanguage.g:5345:1: ( rule__ALSOverride__Group_1__1__Impl rule__ALSOverride__Group_1__2 ) | ||
15499 | // InternalAlloyLanguage.g:5346:2: rule__ALSOverride__Group_1__1__Impl rule__ALSOverride__Group_1__2 | ||
15500 | { | ||
15501 | pushFollow(FOLLOW_16); | ||
15502 | rule__ALSOverride__Group_1__1__Impl(); | ||
15503 | |||
15504 | state._fsp--; | ||
15505 | if (state.failed) return ; | ||
15506 | pushFollow(FOLLOW_2); | ||
15507 | rule__ALSOverride__Group_1__2(); | ||
15508 | |||
15509 | state._fsp--; | ||
15510 | if (state.failed) return ; | ||
15511 | |||
15512 | } | ||
15513 | |||
15514 | } | ||
15515 | catch (RecognitionException re) { | ||
15516 | reportError(re); | ||
15517 | recover(input,re); | ||
15518 | } | ||
15519 | finally { | ||
15520 | |||
15521 | restoreStackSize(stackSize); | ||
15522 | |||
15523 | } | ||
15524 | return ; | ||
15525 | } | ||
15526 | // $ANTLR end "rule__ALSOverride__Group_1__1" | ||
15527 | |||
15528 | |||
15529 | // $ANTLR start "rule__ALSOverride__Group_1__1__Impl" | ||
15530 | // InternalAlloyLanguage.g:5353:1: rule__ALSOverride__Group_1__1__Impl : ( '++' ) ; | ||
15531 | public final void rule__ALSOverride__Group_1__1__Impl() throws RecognitionException { | ||
15532 | |||
15533 | int stackSize = keepStackSize(); | ||
15534 | |||
15535 | try { | ||
15536 | // InternalAlloyLanguage.g:5357:1: ( ( '++' ) ) | ||
15537 | // InternalAlloyLanguage.g:5358:1: ( '++' ) | ||
15538 | { | ||
15539 | // InternalAlloyLanguage.g:5358:1: ( '++' ) | ||
15540 | // InternalAlloyLanguage.g:5359:1: '++' | ||
15541 | { | ||
15542 | if ( state.backtracking==0 ) { | ||
15543 | before(grammarAccess.getALSOverrideAccess().getPlusSignPlusSignKeyword_1_1()); | ||
15544 | } | ||
15545 | match(input,53,FOLLOW_2); if (state.failed) return ; | ||
15546 | if ( state.backtracking==0 ) { | ||
15547 | after(grammarAccess.getALSOverrideAccess().getPlusSignPlusSignKeyword_1_1()); | ||
15548 | } | ||
15549 | |||
15550 | } | ||
15551 | |||
15552 | |||
15553 | } | ||
15554 | |||
15555 | } | ||
15556 | catch (RecognitionException re) { | ||
15557 | reportError(re); | ||
15558 | recover(input,re); | ||
15559 | } | ||
15560 | finally { | ||
15561 | |||
15562 | restoreStackSize(stackSize); | ||
15563 | |||
15564 | } | ||
15565 | return ; | ||
15566 | } | ||
15567 | // $ANTLR end "rule__ALSOverride__Group_1__1__Impl" | ||
15568 | |||
15569 | |||
15570 | // $ANTLR start "rule__ALSOverride__Group_1__2" | ||
15571 | // InternalAlloyLanguage.g:5372:1: rule__ALSOverride__Group_1__2 : rule__ALSOverride__Group_1__2__Impl ; | ||
15572 | public final void rule__ALSOverride__Group_1__2() throws RecognitionException { | ||
15573 | |||
15574 | int stackSize = keepStackSize(); | ||
15575 | |||
15576 | try { | ||
15577 | // InternalAlloyLanguage.g:5376:1: ( rule__ALSOverride__Group_1__2__Impl ) | ||
15578 | // InternalAlloyLanguage.g:5377:2: rule__ALSOverride__Group_1__2__Impl | ||
15579 | { | ||
15580 | pushFollow(FOLLOW_2); | ||
15581 | rule__ALSOverride__Group_1__2__Impl(); | ||
15582 | |||
15583 | state._fsp--; | ||
15584 | if (state.failed) return ; | ||
15585 | |||
15586 | } | ||
15587 | |||
15588 | } | ||
15589 | catch (RecognitionException re) { | ||
15590 | reportError(re); | ||
15591 | recover(input,re); | ||
15592 | } | ||
15593 | finally { | ||
15594 | |||
15595 | restoreStackSize(stackSize); | ||
15596 | |||
15597 | } | ||
15598 | return ; | ||
15599 | } | ||
15600 | // $ANTLR end "rule__ALSOverride__Group_1__2" | ||
15601 | |||
15602 | |||
15603 | // $ANTLR start "rule__ALSOverride__Group_1__2__Impl" | ||
15604 | // InternalAlloyLanguage.g:5383:1: rule__ALSOverride__Group_1__2__Impl : ( ( rule__ALSOverride__RightOperandAssignment_1_2 ) ) ; | ||
15605 | public final void rule__ALSOverride__Group_1__2__Impl() throws RecognitionException { | ||
15606 | |||
15607 | int stackSize = keepStackSize(); | ||
15608 | |||
15609 | try { | ||
15610 | // InternalAlloyLanguage.g:5387:1: ( ( ( rule__ALSOverride__RightOperandAssignment_1_2 ) ) ) | ||
15611 | // InternalAlloyLanguage.g:5388:1: ( ( rule__ALSOverride__RightOperandAssignment_1_2 ) ) | ||
15612 | { | ||
15613 | // InternalAlloyLanguage.g:5388:1: ( ( rule__ALSOverride__RightOperandAssignment_1_2 ) ) | ||
15614 | // InternalAlloyLanguage.g:5389:1: ( rule__ALSOverride__RightOperandAssignment_1_2 ) | ||
15615 | { | ||
15616 | if ( state.backtracking==0 ) { | ||
15617 | before(grammarAccess.getALSOverrideAccess().getRightOperandAssignment_1_2()); | ||
15618 | } | ||
15619 | // InternalAlloyLanguage.g:5390:1: ( rule__ALSOverride__RightOperandAssignment_1_2 ) | ||
15620 | // InternalAlloyLanguage.g:5390:2: rule__ALSOverride__RightOperandAssignment_1_2 | ||
15621 | { | ||
15622 | pushFollow(FOLLOW_2); | ||
15623 | rule__ALSOverride__RightOperandAssignment_1_2(); | ||
15624 | |||
15625 | state._fsp--; | ||
15626 | if (state.failed) return ; | ||
15627 | |||
15628 | } | ||
15629 | |||
15630 | if ( state.backtracking==0 ) { | ||
15631 | after(grammarAccess.getALSOverrideAccess().getRightOperandAssignment_1_2()); | ||
15632 | } | ||
15633 | |||
15634 | } | ||
15635 | |||
15636 | |||
15637 | } | ||
15638 | |||
15639 | } | ||
15640 | catch (RecognitionException re) { | ||
15641 | reportError(re); | ||
15642 | recover(input,re); | ||
15643 | } | ||
15644 | finally { | ||
15645 | |||
15646 | restoreStackSize(stackSize); | ||
15647 | |||
15648 | } | ||
15649 | return ; | ||
15650 | } | ||
15651 | // $ANTLR end "rule__ALSOverride__Group_1__2__Impl" | ||
15652 | |||
15653 | |||
15654 | // $ANTLR start "rule__ALSRangeRestrictionRight__Group__0" | ||
15655 | // InternalAlloyLanguage.g:5406:1: rule__ALSRangeRestrictionRight__Group__0 : rule__ALSRangeRestrictionRight__Group__0__Impl rule__ALSRangeRestrictionRight__Group__1 ; | ||
15656 | public final void rule__ALSRangeRestrictionRight__Group__0() throws RecognitionException { | ||
15657 | |||
15658 | int stackSize = keepStackSize(); | ||
15659 | |||
15660 | try { | ||
15661 | // InternalAlloyLanguage.g:5410:1: ( rule__ALSRangeRestrictionRight__Group__0__Impl rule__ALSRangeRestrictionRight__Group__1 ) | ||
15662 | // InternalAlloyLanguage.g:5411:2: rule__ALSRangeRestrictionRight__Group__0__Impl rule__ALSRangeRestrictionRight__Group__1 | ||
15663 | { | ||
15664 | pushFollow(FOLLOW_38); | ||
15665 | rule__ALSRangeRestrictionRight__Group__0__Impl(); | ||
15666 | |||
15667 | state._fsp--; | ||
15668 | if (state.failed) return ; | ||
15669 | pushFollow(FOLLOW_2); | ||
15670 | rule__ALSRangeRestrictionRight__Group__1(); | ||
15671 | |||
15672 | state._fsp--; | ||
15673 | if (state.failed) return ; | ||
15674 | |||
15675 | } | ||
15676 | |||
15677 | } | ||
15678 | catch (RecognitionException re) { | ||
15679 | reportError(re); | ||
15680 | recover(input,re); | ||
15681 | } | ||
15682 | finally { | ||
15683 | |||
15684 | restoreStackSize(stackSize); | ||
15685 | |||
15686 | } | ||
15687 | return ; | ||
15688 | } | ||
15689 | // $ANTLR end "rule__ALSRangeRestrictionRight__Group__0" | ||
15690 | |||
15691 | |||
15692 | // $ANTLR start "rule__ALSRangeRestrictionRight__Group__0__Impl" | ||
15693 | // InternalAlloyLanguage.g:5418:1: rule__ALSRangeRestrictionRight__Group__0__Impl : ( ruleALSRangeRestrictionLeft ) ; | ||
15694 | public final void rule__ALSRangeRestrictionRight__Group__0__Impl() throws RecognitionException { | ||
15695 | |||
15696 | int stackSize = keepStackSize(); | ||
15697 | |||
15698 | try { | ||
15699 | // InternalAlloyLanguage.g:5422:1: ( ( ruleALSRangeRestrictionLeft ) ) | ||
15700 | // InternalAlloyLanguage.g:5423:1: ( ruleALSRangeRestrictionLeft ) | ||
15701 | { | ||
15702 | // InternalAlloyLanguage.g:5423:1: ( ruleALSRangeRestrictionLeft ) | ||
15703 | // InternalAlloyLanguage.g:5424:1: ruleALSRangeRestrictionLeft | ||
15704 | { | ||
15705 | if ( state.backtracking==0 ) { | ||
15706 | before(grammarAccess.getALSRangeRestrictionRightAccess().getALSRangeRestrictionLeftParserRuleCall_0()); | ||
15707 | } | ||
15708 | pushFollow(FOLLOW_2); | ||
15709 | ruleALSRangeRestrictionLeft(); | ||
15710 | |||
15711 | state._fsp--; | ||
15712 | if (state.failed) return ; | ||
15713 | if ( state.backtracking==0 ) { | ||
15714 | after(grammarAccess.getALSRangeRestrictionRightAccess().getALSRangeRestrictionLeftParserRuleCall_0()); | ||
15715 | } | ||
15716 | |||
15717 | } | ||
15718 | |||
15719 | |||
15720 | } | ||
15721 | |||
15722 | } | ||
15723 | catch (RecognitionException re) { | ||
15724 | reportError(re); | ||
15725 | recover(input,re); | ||
15726 | } | ||
15727 | finally { | ||
15728 | |||
15729 | restoreStackSize(stackSize); | ||
15730 | |||
15731 | } | ||
15732 | return ; | ||
15733 | } | ||
15734 | // $ANTLR end "rule__ALSRangeRestrictionRight__Group__0__Impl" | ||
15735 | |||
15736 | |||
15737 | // $ANTLR start "rule__ALSRangeRestrictionRight__Group__1" | ||
15738 | // InternalAlloyLanguage.g:5435:1: rule__ALSRangeRestrictionRight__Group__1 : rule__ALSRangeRestrictionRight__Group__1__Impl ; | ||
15739 | public final void rule__ALSRangeRestrictionRight__Group__1() throws RecognitionException { | ||
15740 | |||
15741 | int stackSize = keepStackSize(); | ||
15742 | |||
15743 | try { | ||
15744 | // InternalAlloyLanguage.g:5439:1: ( rule__ALSRangeRestrictionRight__Group__1__Impl ) | ||
15745 | // InternalAlloyLanguage.g:5440:2: rule__ALSRangeRestrictionRight__Group__1__Impl | ||
15746 | { | ||
15747 | pushFollow(FOLLOW_2); | ||
15748 | rule__ALSRangeRestrictionRight__Group__1__Impl(); | ||
15749 | |||
15750 | state._fsp--; | ||
15751 | if (state.failed) return ; | ||
15752 | |||
15753 | } | ||
15754 | |||
15755 | } | ||
15756 | catch (RecognitionException re) { | ||
15757 | reportError(re); | ||
15758 | recover(input,re); | ||
15759 | } | ||
15760 | finally { | ||
15761 | |||
15762 | restoreStackSize(stackSize); | ||
15763 | |||
15764 | } | ||
15765 | return ; | ||
15766 | } | ||
15767 | // $ANTLR end "rule__ALSRangeRestrictionRight__Group__1" | ||
15768 | |||
15769 | |||
15770 | // $ANTLR start "rule__ALSRangeRestrictionRight__Group__1__Impl" | ||
15771 | // InternalAlloyLanguage.g:5446:1: rule__ALSRangeRestrictionRight__Group__1__Impl : ( ( rule__ALSRangeRestrictionRight__Group_1__0 )? ) ; | ||
15772 | public final void rule__ALSRangeRestrictionRight__Group__1__Impl() throws RecognitionException { | ||
15773 | |||
15774 | int stackSize = keepStackSize(); | ||
15775 | |||
15776 | try { | ||
15777 | // InternalAlloyLanguage.g:5450:1: ( ( ( rule__ALSRangeRestrictionRight__Group_1__0 )? ) ) | ||
15778 | // InternalAlloyLanguage.g:5451:1: ( ( rule__ALSRangeRestrictionRight__Group_1__0 )? ) | ||
15779 | { | ||
15780 | // InternalAlloyLanguage.g:5451:1: ( ( rule__ALSRangeRestrictionRight__Group_1__0 )? ) | ||
15781 | // InternalAlloyLanguage.g:5452:1: ( rule__ALSRangeRestrictionRight__Group_1__0 )? | ||
15782 | { | ||
15783 | if ( state.backtracking==0 ) { | ||
15784 | before(grammarAccess.getALSRangeRestrictionRightAccess().getGroup_1()); | ||
15785 | } | ||
15786 | // InternalAlloyLanguage.g:5453:1: ( rule__ALSRangeRestrictionRight__Group_1__0 )? | ||
15787 | int alt37=2; | ||
15788 | int LA37_0 = input.LA(1); | ||
15789 | |||
15790 | if ( (LA37_0==54) ) { | ||
15791 | alt37=1; | ||
15792 | } | ||
15793 | switch (alt37) { | ||
15794 | case 1 : | ||
15795 | // InternalAlloyLanguage.g:5453:2: rule__ALSRangeRestrictionRight__Group_1__0 | ||
15796 | { | ||
15797 | pushFollow(FOLLOW_2); | ||
15798 | rule__ALSRangeRestrictionRight__Group_1__0(); | ||
15799 | |||
15800 | state._fsp--; | ||
15801 | if (state.failed) return ; | ||
15802 | |||
15803 | } | ||
15804 | break; | ||
15805 | |||
15806 | } | ||
15807 | |||
15808 | if ( state.backtracking==0 ) { | ||
15809 | after(grammarAccess.getALSRangeRestrictionRightAccess().getGroup_1()); | ||
15810 | } | ||
15811 | |||
15812 | } | ||
15813 | |||
15814 | |||
15815 | } | ||
15816 | |||
15817 | } | ||
15818 | catch (RecognitionException re) { | ||
15819 | reportError(re); | ||
15820 | recover(input,re); | ||
15821 | } | ||
15822 | finally { | ||
15823 | |||
15824 | restoreStackSize(stackSize); | ||
15825 | |||
15826 | } | ||
15827 | return ; | ||
15828 | } | ||
15829 | // $ANTLR end "rule__ALSRangeRestrictionRight__Group__1__Impl" | ||
15830 | |||
15831 | |||
15832 | // $ANTLR start "rule__ALSRangeRestrictionRight__Group_1__0" | ||
15833 | // InternalAlloyLanguage.g:5467:1: rule__ALSRangeRestrictionRight__Group_1__0 : rule__ALSRangeRestrictionRight__Group_1__0__Impl rule__ALSRangeRestrictionRight__Group_1__1 ; | ||
15834 | public final void rule__ALSRangeRestrictionRight__Group_1__0() throws RecognitionException { | ||
15835 | |||
15836 | int stackSize = keepStackSize(); | ||
15837 | |||
15838 | try { | ||
15839 | // InternalAlloyLanguage.g:5471:1: ( rule__ALSRangeRestrictionRight__Group_1__0__Impl rule__ALSRangeRestrictionRight__Group_1__1 ) | ||
15840 | // InternalAlloyLanguage.g:5472:2: rule__ALSRangeRestrictionRight__Group_1__0__Impl rule__ALSRangeRestrictionRight__Group_1__1 | ||
15841 | { | ||
15842 | pushFollow(FOLLOW_38); | ||
15843 | rule__ALSRangeRestrictionRight__Group_1__0__Impl(); | ||
15844 | |||
15845 | state._fsp--; | ||
15846 | if (state.failed) return ; | ||
15847 | pushFollow(FOLLOW_2); | ||
15848 | rule__ALSRangeRestrictionRight__Group_1__1(); | ||
15849 | |||
15850 | state._fsp--; | ||
15851 | if (state.failed) return ; | ||
15852 | |||
15853 | } | ||
15854 | |||
15855 | } | ||
15856 | catch (RecognitionException re) { | ||
15857 | reportError(re); | ||
15858 | recover(input,re); | ||
15859 | } | ||
15860 | finally { | ||
15861 | |||
15862 | restoreStackSize(stackSize); | ||
15863 | |||
15864 | } | ||
15865 | return ; | ||
15866 | } | ||
15867 | // $ANTLR end "rule__ALSRangeRestrictionRight__Group_1__0" | ||
15868 | |||
15869 | |||
15870 | // $ANTLR start "rule__ALSRangeRestrictionRight__Group_1__0__Impl" | ||
15871 | // InternalAlloyLanguage.g:5479:1: rule__ALSRangeRestrictionRight__Group_1__0__Impl : ( () ) ; | ||
15872 | public final void rule__ALSRangeRestrictionRight__Group_1__0__Impl() throws RecognitionException { | ||
15873 | |||
15874 | int stackSize = keepStackSize(); | ||
15875 | |||
15876 | try { | ||
15877 | // InternalAlloyLanguage.g:5483:1: ( ( () ) ) | ||
15878 | // InternalAlloyLanguage.g:5484:1: ( () ) | ||
15879 | { | ||
15880 | // InternalAlloyLanguage.g:5484:1: ( () ) | ||
15881 | // InternalAlloyLanguage.g:5485:1: () | ||
15882 | { | ||
15883 | if ( state.backtracking==0 ) { | ||
15884 | before(grammarAccess.getALSRangeRestrictionRightAccess().getALSRangeRestrictionRightRelationAction_1_0()); | ||
15885 | } | ||
15886 | // InternalAlloyLanguage.g:5486:1: () | ||
15887 | // InternalAlloyLanguage.g:5488:1: | ||
15888 | { | ||
15889 | } | ||
15890 | |||
15891 | if ( state.backtracking==0 ) { | ||
15892 | after(grammarAccess.getALSRangeRestrictionRightAccess().getALSRangeRestrictionRightRelationAction_1_0()); | ||
15893 | } | ||
15894 | |||
15895 | } | ||
15896 | |||
15897 | |||
15898 | } | ||
15899 | |||
15900 | } | ||
15901 | finally { | ||
15902 | |||
15903 | restoreStackSize(stackSize); | ||
15904 | |||
15905 | } | ||
15906 | return ; | ||
15907 | } | ||
15908 | // $ANTLR end "rule__ALSRangeRestrictionRight__Group_1__0__Impl" | ||
15909 | |||
15910 | |||
15911 | // $ANTLR start "rule__ALSRangeRestrictionRight__Group_1__1" | ||
15912 | // InternalAlloyLanguage.g:5498:1: rule__ALSRangeRestrictionRight__Group_1__1 : rule__ALSRangeRestrictionRight__Group_1__1__Impl rule__ALSRangeRestrictionRight__Group_1__2 ; | ||
15913 | public final void rule__ALSRangeRestrictionRight__Group_1__1() throws RecognitionException { | ||
15914 | |||
15915 | int stackSize = keepStackSize(); | ||
15916 | |||
15917 | try { | ||
15918 | // InternalAlloyLanguage.g:5502:1: ( rule__ALSRangeRestrictionRight__Group_1__1__Impl rule__ALSRangeRestrictionRight__Group_1__2 ) | ||
15919 | // InternalAlloyLanguage.g:5503:2: rule__ALSRangeRestrictionRight__Group_1__1__Impl rule__ALSRangeRestrictionRight__Group_1__2 | ||
15920 | { | ||
15921 | pushFollow(FOLLOW_16); | ||
15922 | rule__ALSRangeRestrictionRight__Group_1__1__Impl(); | ||
15923 | |||
15924 | state._fsp--; | ||
15925 | if (state.failed) return ; | ||
15926 | pushFollow(FOLLOW_2); | ||
15927 | rule__ALSRangeRestrictionRight__Group_1__2(); | ||
15928 | |||
15929 | state._fsp--; | ||
15930 | if (state.failed) return ; | ||
15931 | |||
15932 | } | ||
15933 | |||
15934 | } | ||
15935 | catch (RecognitionException re) { | ||
15936 | reportError(re); | ||
15937 | recover(input,re); | ||
15938 | } | ||
15939 | finally { | ||
15940 | |||
15941 | restoreStackSize(stackSize); | ||
15942 | |||
15943 | } | ||
15944 | return ; | ||
15945 | } | ||
15946 | // $ANTLR end "rule__ALSRangeRestrictionRight__Group_1__1" | ||
15947 | |||
15948 | |||
15949 | // $ANTLR start "rule__ALSRangeRestrictionRight__Group_1__1__Impl" | ||
15950 | // InternalAlloyLanguage.g:5510:1: rule__ALSRangeRestrictionRight__Group_1__1__Impl : ( ':>' ) ; | ||
15951 | public final void rule__ALSRangeRestrictionRight__Group_1__1__Impl() throws RecognitionException { | ||
15952 | |||
15953 | int stackSize = keepStackSize(); | ||
15954 | |||
15955 | try { | ||
15956 | // InternalAlloyLanguage.g:5514:1: ( ( ':>' ) ) | ||
15957 | // InternalAlloyLanguage.g:5515:1: ( ':>' ) | ||
15958 | { | ||
15959 | // InternalAlloyLanguage.g:5515:1: ( ':>' ) | ||
15960 | // InternalAlloyLanguage.g:5516:1: ':>' | ||
15961 | { | ||
15962 | if ( state.backtracking==0 ) { | ||
15963 | before(grammarAccess.getALSRangeRestrictionRightAccess().getColonGreaterThanSignKeyword_1_1()); | ||
15964 | } | ||
15965 | match(input,54,FOLLOW_2); if (state.failed) return ; | ||
15966 | if ( state.backtracking==0 ) { | ||
15967 | after(grammarAccess.getALSRangeRestrictionRightAccess().getColonGreaterThanSignKeyword_1_1()); | ||
15968 | } | ||
15969 | |||
15970 | } | ||
15971 | |||
15972 | |||
15973 | } | ||
15974 | |||
15975 | } | ||
15976 | catch (RecognitionException re) { | ||
15977 | reportError(re); | ||
15978 | recover(input,re); | ||
15979 | } | ||
15980 | finally { | ||
15981 | |||
15982 | restoreStackSize(stackSize); | ||
15983 | |||
15984 | } | ||
15985 | return ; | ||
15986 | } | ||
15987 | // $ANTLR end "rule__ALSRangeRestrictionRight__Group_1__1__Impl" | ||
15988 | |||
15989 | |||
15990 | // $ANTLR start "rule__ALSRangeRestrictionRight__Group_1__2" | ||
15991 | // InternalAlloyLanguage.g:5529:1: rule__ALSRangeRestrictionRight__Group_1__2 : rule__ALSRangeRestrictionRight__Group_1__2__Impl ; | ||
15992 | public final void rule__ALSRangeRestrictionRight__Group_1__2() throws RecognitionException { | ||
15993 | |||
15994 | int stackSize = keepStackSize(); | ||
15995 | |||
15996 | try { | ||
15997 | // InternalAlloyLanguage.g:5533:1: ( rule__ALSRangeRestrictionRight__Group_1__2__Impl ) | ||
15998 | // InternalAlloyLanguage.g:5534:2: rule__ALSRangeRestrictionRight__Group_1__2__Impl | ||
15999 | { | ||
16000 | pushFollow(FOLLOW_2); | ||
16001 | rule__ALSRangeRestrictionRight__Group_1__2__Impl(); | ||
16002 | |||
16003 | state._fsp--; | ||
16004 | if (state.failed) return ; | ||
16005 | |||
16006 | } | ||
16007 | |||
16008 | } | ||
16009 | catch (RecognitionException re) { | ||
16010 | reportError(re); | ||
16011 | recover(input,re); | ||
16012 | } | ||
16013 | finally { | ||
16014 | |||
16015 | restoreStackSize(stackSize); | ||
16016 | |||
16017 | } | ||
16018 | return ; | ||
16019 | } | ||
16020 | // $ANTLR end "rule__ALSRangeRestrictionRight__Group_1__2" | ||
16021 | |||
16022 | |||
16023 | // $ANTLR start "rule__ALSRangeRestrictionRight__Group_1__2__Impl" | ||
16024 | // InternalAlloyLanguage.g:5540:1: rule__ALSRangeRestrictionRight__Group_1__2__Impl : ( ( rule__ALSRangeRestrictionRight__FilterAssignment_1_2 ) ) ; | ||
16025 | public final void rule__ALSRangeRestrictionRight__Group_1__2__Impl() throws RecognitionException { | ||
16026 | |||
16027 | int stackSize = keepStackSize(); | ||
16028 | |||
16029 | try { | ||
16030 | // InternalAlloyLanguage.g:5544:1: ( ( ( rule__ALSRangeRestrictionRight__FilterAssignment_1_2 ) ) ) | ||
16031 | // InternalAlloyLanguage.g:5545:1: ( ( rule__ALSRangeRestrictionRight__FilterAssignment_1_2 ) ) | ||
16032 | { | ||
16033 | // InternalAlloyLanguage.g:5545:1: ( ( rule__ALSRangeRestrictionRight__FilterAssignment_1_2 ) ) | ||
16034 | // InternalAlloyLanguage.g:5546:1: ( rule__ALSRangeRestrictionRight__FilterAssignment_1_2 ) | ||
16035 | { | ||
16036 | if ( state.backtracking==0 ) { | ||
16037 | before(grammarAccess.getALSRangeRestrictionRightAccess().getFilterAssignment_1_2()); | ||
16038 | } | ||
16039 | // InternalAlloyLanguage.g:5547:1: ( rule__ALSRangeRestrictionRight__FilterAssignment_1_2 ) | ||
16040 | // InternalAlloyLanguage.g:5547:2: rule__ALSRangeRestrictionRight__FilterAssignment_1_2 | ||
16041 | { | ||
16042 | pushFollow(FOLLOW_2); | ||
16043 | rule__ALSRangeRestrictionRight__FilterAssignment_1_2(); | ||
16044 | |||
16045 | state._fsp--; | ||
16046 | if (state.failed) return ; | ||
16047 | |||
16048 | } | ||
16049 | |||
16050 | if ( state.backtracking==0 ) { | ||
16051 | after(grammarAccess.getALSRangeRestrictionRightAccess().getFilterAssignment_1_2()); | ||
16052 | } | ||
16053 | |||
16054 | } | ||
16055 | |||
16056 | |||
16057 | } | ||
16058 | |||
16059 | } | ||
16060 | catch (RecognitionException re) { | ||
16061 | reportError(re); | ||
16062 | recover(input,re); | ||
16063 | } | ||
16064 | finally { | ||
16065 | |||
16066 | restoreStackSize(stackSize); | ||
16067 | |||
16068 | } | ||
16069 | return ; | ||
16070 | } | ||
16071 | // $ANTLR end "rule__ALSRangeRestrictionRight__Group_1__2__Impl" | ||
16072 | |||
16073 | |||
16074 | // $ANTLR start "rule__ALSRangeRestrictionLeft__Group__0" | ||
16075 | // InternalAlloyLanguage.g:5563:1: rule__ALSRangeRestrictionLeft__Group__0 : rule__ALSRangeRestrictionLeft__Group__0__Impl rule__ALSRangeRestrictionLeft__Group__1 ; | ||
16076 | public final void rule__ALSRangeRestrictionLeft__Group__0() throws RecognitionException { | ||
16077 | |||
16078 | int stackSize = keepStackSize(); | ||
16079 | |||
16080 | try { | ||
16081 | // InternalAlloyLanguage.g:5567:1: ( rule__ALSRangeRestrictionLeft__Group__0__Impl rule__ALSRangeRestrictionLeft__Group__1 ) | ||
16082 | // InternalAlloyLanguage.g:5568:2: rule__ALSRangeRestrictionLeft__Group__0__Impl rule__ALSRangeRestrictionLeft__Group__1 | ||
16083 | { | ||
16084 | pushFollow(FOLLOW_39); | ||
16085 | rule__ALSRangeRestrictionLeft__Group__0__Impl(); | ||
16086 | |||
16087 | state._fsp--; | ||
16088 | if (state.failed) return ; | ||
16089 | pushFollow(FOLLOW_2); | ||
16090 | rule__ALSRangeRestrictionLeft__Group__1(); | ||
16091 | |||
16092 | state._fsp--; | ||
16093 | if (state.failed) return ; | ||
16094 | |||
16095 | } | ||
16096 | |||
16097 | } | ||
16098 | catch (RecognitionException re) { | ||
16099 | reportError(re); | ||
16100 | recover(input,re); | ||
16101 | } | ||
16102 | finally { | ||
16103 | |||
16104 | restoreStackSize(stackSize); | ||
16105 | |||
16106 | } | ||
16107 | return ; | ||
16108 | } | ||
16109 | // $ANTLR end "rule__ALSRangeRestrictionLeft__Group__0" | ||
16110 | |||
16111 | |||
16112 | // $ANTLR start "rule__ALSRangeRestrictionLeft__Group__0__Impl" | ||
16113 | // InternalAlloyLanguage.g:5575:1: rule__ALSRangeRestrictionLeft__Group__0__Impl : ( ruleALSJoin ) ; | ||
16114 | public final void rule__ALSRangeRestrictionLeft__Group__0__Impl() throws RecognitionException { | ||
16115 | |||
16116 | int stackSize = keepStackSize(); | ||
16117 | |||
16118 | try { | ||
16119 | // InternalAlloyLanguage.g:5579:1: ( ( ruleALSJoin ) ) | ||
16120 | // InternalAlloyLanguage.g:5580:1: ( ruleALSJoin ) | ||
16121 | { | ||
16122 | // InternalAlloyLanguage.g:5580:1: ( ruleALSJoin ) | ||
16123 | // InternalAlloyLanguage.g:5581:1: ruleALSJoin | ||
16124 | { | ||
16125 | if ( state.backtracking==0 ) { | ||
16126 | before(grammarAccess.getALSRangeRestrictionLeftAccess().getALSJoinParserRuleCall_0()); | ||
16127 | } | ||
16128 | pushFollow(FOLLOW_2); | ||
16129 | ruleALSJoin(); | ||
16130 | |||
16131 | state._fsp--; | ||
16132 | if (state.failed) return ; | ||
16133 | if ( state.backtracking==0 ) { | ||
16134 | after(grammarAccess.getALSRangeRestrictionLeftAccess().getALSJoinParserRuleCall_0()); | ||
16135 | } | ||
16136 | |||
16137 | } | ||
16138 | |||
16139 | |||
16140 | } | ||
16141 | |||
16142 | } | ||
16143 | catch (RecognitionException re) { | ||
16144 | reportError(re); | ||
16145 | recover(input,re); | ||
16146 | } | ||
16147 | finally { | ||
16148 | |||
16149 | restoreStackSize(stackSize); | ||
16150 | |||
16151 | } | ||
16152 | return ; | ||
16153 | } | ||
16154 | // $ANTLR end "rule__ALSRangeRestrictionLeft__Group__0__Impl" | ||
16155 | |||
16156 | |||
16157 | // $ANTLR start "rule__ALSRangeRestrictionLeft__Group__1" | ||
16158 | // InternalAlloyLanguage.g:5592:1: rule__ALSRangeRestrictionLeft__Group__1 : rule__ALSRangeRestrictionLeft__Group__1__Impl ; | ||
16159 | public final void rule__ALSRangeRestrictionLeft__Group__1() throws RecognitionException { | ||
16160 | |||
16161 | int stackSize = keepStackSize(); | ||
16162 | |||
16163 | try { | ||
16164 | // InternalAlloyLanguage.g:5596:1: ( rule__ALSRangeRestrictionLeft__Group__1__Impl ) | ||
16165 | // InternalAlloyLanguage.g:5597:2: rule__ALSRangeRestrictionLeft__Group__1__Impl | ||
16166 | { | ||
16167 | pushFollow(FOLLOW_2); | ||
16168 | rule__ALSRangeRestrictionLeft__Group__1__Impl(); | ||
16169 | |||
16170 | state._fsp--; | ||
16171 | if (state.failed) return ; | ||
16172 | |||
16173 | } | ||
16174 | |||
16175 | } | ||
16176 | catch (RecognitionException re) { | ||
16177 | reportError(re); | ||
16178 | recover(input,re); | ||
16179 | } | ||
16180 | finally { | ||
16181 | |||
16182 | restoreStackSize(stackSize); | ||
16183 | |||
16184 | } | ||
16185 | return ; | ||
16186 | } | ||
16187 | // $ANTLR end "rule__ALSRangeRestrictionLeft__Group__1" | ||
16188 | |||
16189 | |||
16190 | // $ANTLR start "rule__ALSRangeRestrictionLeft__Group__1__Impl" | ||
16191 | // InternalAlloyLanguage.g:5603:1: rule__ALSRangeRestrictionLeft__Group__1__Impl : ( ( rule__ALSRangeRestrictionLeft__Group_1__0 )? ) ; | ||
16192 | public final void rule__ALSRangeRestrictionLeft__Group__1__Impl() throws RecognitionException { | ||
16193 | |||
16194 | int stackSize = keepStackSize(); | ||
16195 | |||
16196 | try { | ||
16197 | // InternalAlloyLanguage.g:5607:1: ( ( ( rule__ALSRangeRestrictionLeft__Group_1__0 )? ) ) | ||
16198 | // InternalAlloyLanguage.g:5608:1: ( ( rule__ALSRangeRestrictionLeft__Group_1__0 )? ) | ||
16199 | { | ||
16200 | // InternalAlloyLanguage.g:5608:1: ( ( rule__ALSRangeRestrictionLeft__Group_1__0 )? ) | ||
16201 | // InternalAlloyLanguage.g:5609:1: ( rule__ALSRangeRestrictionLeft__Group_1__0 )? | ||
16202 | { | ||
16203 | if ( state.backtracking==0 ) { | ||
16204 | before(grammarAccess.getALSRangeRestrictionLeftAccess().getGroup_1()); | ||
16205 | } | ||
16206 | // InternalAlloyLanguage.g:5610:1: ( rule__ALSRangeRestrictionLeft__Group_1__0 )? | ||
16207 | int alt38=2; | ||
16208 | int LA38_0 = input.LA(1); | ||
16209 | |||
16210 | if ( (LA38_0==55) ) { | ||
16211 | alt38=1; | ||
16212 | } | ||
16213 | switch (alt38) { | ||
16214 | case 1 : | ||
16215 | // InternalAlloyLanguage.g:5610:2: rule__ALSRangeRestrictionLeft__Group_1__0 | ||
16216 | { | ||
16217 | pushFollow(FOLLOW_2); | ||
16218 | rule__ALSRangeRestrictionLeft__Group_1__0(); | ||
16219 | |||
16220 | state._fsp--; | ||
16221 | if (state.failed) return ; | ||
16222 | |||
16223 | } | ||
16224 | break; | ||
16225 | |||
16226 | } | ||
16227 | |||
16228 | if ( state.backtracking==0 ) { | ||
16229 | after(grammarAccess.getALSRangeRestrictionLeftAccess().getGroup_1()); | ||
16230 | } | ||
16231 | |||
16232 | } | ||
16233 | |||
16234 | |||
16235 | } | ||
16236 | |||
16237 | } | ||
16238 | catch (RecognitionException re) { | ||
16239 | reportError(re); | ||
16240 | recover(input,re); | ||
16241 | } | ||
16242 | finally { | ||
16243 | |||
16244 | restoreStackSize(stackSize); | ||
16245 | |||
16246 | } | ||
16247 | return ; | ||
16248 | } | ||
16249 | // $ANTLR end "rule__ALSRangeRestrictionLeft__Group__1__Impl" | ||
16250 | |||
16251 | |||
16252 | // $ANTLR start "rule__ALSRangeRestrictionLeft__Group_1__0" | ||
16253 | // InternalAlloyLanguage.g:5624:1: rule__ALSRangeRestrictionLeft__Group_1__0 : rule__ALSRangeRestrictionLeft__Group_1__0__Impl rule__ALSRangeRestrictionLeft__Group_1__1 ; | ||
16254 | public final void rule__ALSRangeRestrictionLeft__Group_1__0() throws RecognitionException { | ||
16255 | |||
16256 | int stackSize = keepStackSize(); | ||
16257 | |||
16258 | try { | ||
16259 | // InternalAlloyLanguage.g:5628:1: ( rule__ALSRangeRestrictionLeft__Group_1__0__Impl rule__ALSRangeRestrictionLeft__Group_1__1 ) | ||
16260 | // InternalAlloyLanguage.g:5629:2: rule__ALSRangeRestrictionLeft__Group_1__0__Impl rule__ALSRangeRestrictionLeft__Group_1__1 | ||
16261 | { | ||
16262 | pushFollow(FOLLOW_39); | ||
16263 | rule__ALSRangeRestrictionLeft__Group_1__0__Impl(); | ||
16264 | |||
16265 | state._fsp--; | ||
16266 | if (state.failed) return ; | ||
16267 | pushFollow(FOLLOW_2); | ||
16268 | rule__ALSRangeRestrictionLeft__Group_1__1(); | ||
16269 | |||
16270 | state._fsp--; | ||
16271 | if (state.failed) return ; | ||
16272 | |||
16273 | } | ||
16274 | |||
16275 | } | ||
16276 | catch (RecognitionException re) { | ||
16277 | reportError(re); | ||
16278 | recover(input,re); | ||
16279 | } | ||
16280 | finally { | ||
16281 | |||
16282 | restoreStackSize(stackSize); | ||
16283 | |||
16284 | } | ||
16285 | return ; | ||
16286 | } | ||
16287 | // $ANTLR end "rule__ALSRangeRestrictionLeft__Group_1__0" | ||
16288 | |||
16289 | |||
16290 | // $ANTLR start "rule__ALSRangeRestrictionLeft__Group_1__0__Impl" | ||
16291 | // InternalAlloyLanguage.g:5636:1: rule__ALSRangeRestrictionLeft__Group_1__0__Impl : ( () ) ; | ||
16292 | public final void rule__ALSRangeRestrictionLeft__Group_1__0__Impl() throws RecognitionException { | ||
16293 | |||
16294 | int stackSize = keepStackSize(); | ||
16295 | |||
16296 | try { | ||
16297 | // InternalAlloyLanguage.g:5640:1: ( ( () ) ) | ||
16298 | // InternalAlloyLanguage.g:5641:1: ( () ) | ||
16299 | { | ||
16300 | // InternalAlloyLanguage.g:5641:1: ( () ) | ||
16301 | // InternalAlloyLanguage.g:5642:1: () | ||
16302 | { | ||
16303 | if ( state.backtracking==0 ) { | ||
16304 | before(grammarAccess.getALSRangeRestrictionLeftAccess().getALSRangeRestrictionLeftFilterAction_1_0()); | ||
16305 | } | ||
16306 | // InternalAlloyLanguage.g:5643:1: () | ||
16307 | // InternalAlloyLanguage.g:5645:1: | ||
16308 | { | ||
16309 | } | ||
16310 | |||
16311 | if ( state.backtracking==0 ) { | ||
16312 | after(grammarAccess.getALSRangeRestrictionLeftAccess().getALSRangeRestrictionLeftFilterAction_1_0()); | ||
16313 | } | ||
16314 | |||
16315 | } | ||
16316 | |||
16317 | |||
16318 | } | ||
16319 | |||
16320 | } | ||
16321 | finally { | ||
16322 | |||
16323 | restoreStackSize(stackSize); | ||
16324 | |||
16325 | } | ||
16326 | return ; | ||
16327 | } | ||
16328 | // $ANTLR end "rule__ALSRangeRestrictionLeft__Group_1__0__Impl" | ||
16329 | |||
16330 | |||
16331 | // $ANTLR start "rule__ALSRangeRestrictionLeft__Group_1__1" | ||
16332 | // InternalAlloyLanguage.g:5655:1: rule__ALSRangeRestrictionLeft__Group_1__1 : rule__ALSRangeRestrictionLeft__Group_1__1__Impl rule__ALSRangeRestrictionLeft__Group_1__2 ; | ||
16333 | public final void rule__ALSRangeRestrictionLeft__Group_1__1() throws RecognitionException { | ||
16334 | |||
16335 | int stackSize = keepStackSize(); | ||
16336 | |||
16337 | try { | ||
16338 | // InternalAlloyLanguage.g:5659:1: ( rule__ALSRangeRestrictionLeft__Group_1__1__Impl rule__ALSRangeRestrictionLeft__Group_1__2 ) | ||
16339 | // InternalAlloyLanguage.g:5660:2: rule__ALSRangeRestrictionLeft__Group_1__1__Impl rule__ALSRangeRestrictionLeft__Group_1__2 | ||
16340 | { | ||
16341 | pushFollow(FOLLOW_16); | ||
16342 | rule__ALSRangeRestrictionLeft__Group_1__1__Impl(); | ||
16343 | |||
16344 | state._fsp--; | ||
16345 | if (state.failed) return ; | ||
16346 | pushFollow(FOLLOW_2); | ||
16347 | rule__ALSRangeRestrictionLeft__Group_1__2(); | ||
16348 | |||
16349 | state._fsp--; | ||
16350 | if (state.failed) return ; | ||
16351 | |||
16352 | } | ||
16353 | |||
16354 | } | ||
16355 | catch (RecognitionException re) { | ||
16356 | reportError(re); | ||
16357 | recover(input,re); | ||
16358 | } | ||
16359 | finally { | ||
16360 | |||
16361 | restoreStackSize(stackSize); | ||
16362 | |||
16363 | } | ||
16364 | return ; | ||
16365 | } | ||
16366 | // $ANTLR end "rule__ALSRangeRestrictionLeft__Group_1__1" | ||
16367 | |||
16368 | |||
16369 | // $ANTLR start "rule__ALSRangeRestrictionLeft__Group_1__1__Impl" | ||
16370 | // InternalAlloyLanguage.g:5667:1: rule__ALSRangeRestrictionLeft__Group_1__1__Impl : ( '<:' ) ; | ||
16371 | public final void rule__ALSRangeRestrictionLeft__Group_1__1__Impl() throws RecognitionException { | ||
16372 | |||
16373 | int stackSize = keepStackSize(); | ||
16374 | |||
16375 | try { | ||
16376 | // InternalAlloyLanguage.g:5671:1: ( ( '<:' ) ) | ||
16377 | // InternalAlloyLanguage.g:5672:1: ( '<:' ) | ||
16378 | { | ||
16379 | // InternalAlloyLanguage.g:5672:1: ( '<:' ) | ||
16380 | // InternalAlloyLanguage.g:5673:1: '<:' | ||
16381 | { | ||
16382 | if ( state.backtracking==0 ) { | ||
16383 | before(grammarAccess.getALSRangeRestrictionLeftAccess().getLessThanSignColonKeyword_1_1()); | ||
16384 | } | ||
16385 | match(input,55,FOLLOW_2); if (state.failed) return ; | ||
16386 | if ( state.backtracking==0 ) { | ||
16387 | after(grammarAccess.getALSRangeRestrictionLeftAccess().getLessThanSignColonKeyword_1_1()); | ||
16388 | } | ||
16389 | |||
16390 | } | ||
16391 | |||
16392 | |||
16393 | } | ||
16394 | |||
16395 | } | ||
16396 | catch (RecognitionException re) { | ||
16397 | reportError(re); | ||
16398 | recover(input,re); | ||
16399 | } | ||
16400 | finally { | ||
16401 | |||
16402 | restoreStackSize(stackSize); | ||
16403 | |||
16404 | } | ||
16405 | return ; | ||
16406 | } | ||
16407 | // $ANTLR end "rule__ALSRangeRestrictionLeft__Group_1__1__Impl" | ||
16408 | |||
16409 | |||
16410 | // $ANTLR start "rule__ALSRangeRestrictionLeft__Group_1__2" | ||
16411 | // InternalAlloyLanguage.g:5686:1: rule__ALSRangeRestrictionLeft__Group_1__2 : rule__ALSRangeRestrictionLeft__Group_1__2__Impl ; | ||
16412 | public final void rule__ALSRangeRestrictionLeft__Group_1__2() throws RecognitionException { | ||
16413 | |||
16414 | int stackSize = keepStackSize(); | ||
16415 | |||
16416 | try { | ||
16417 | // InternalAlloyLanguage.g:5690:1: ( rule__ALSRangeRestrictionLeft__Group_1__2__Impl ) | ||
16418 | // InternalAlloyLanguage.g:5691:2: rule__ALSRangeRestrictionLeft__Group_1__2__Impl | ||
16419 | { | ||
16420 | pushFollow(FOLLOW_2); | ||
16421 | rule__ALSRangeRestrictionLeft__Group_1__2__Impl(); | ||
16422 | |||
16423 | state._fsp--; | ||
16424 | if (state.failed) return ; | ||
16425 | |||
16426 | } | ||
16427 | |||
16428 | } | ||
16429 | catch (RecognitionException re) { | ||
16430 | reportError(re); | ||
16431 | recover(input,re); | ||
16432 | } | ||
16433 | finally { | ||
16434 | |||
16435 | restoreStackSize(stackSize); | ||
16436 | |||
16437 | } | ||
16438 | return ; | ||
16439 | } | ||
16440 | // $ANTLR end "rule__ALSRangeRestrictionLeft__Group_1__2" | ||
16441 | |||
16442 | |||
16443 | // $ANTLR start "rule__ALSRangeRestrictionLeft__Group_1__2__Impl" | ||
16444 | // InternalAlloyLanguage.g:5697:1: rule__ALSRangeRestrictionLeft__Group_1__2__Impl : ( ( rule__ALSRangeRestrictionLeft__RelationAssignment_1_2 ) ) ; | ||
16445 | public final void rule__ALSRangeRestrictionLeft__Group_1__2__Impl() throws RecognitionException { | ||
16446 | |||
16447 | int stackSize = keepStackSize(); | ||
16448 | |||
16449 | try { | ||
16450 | // InternalAlloyLanguage.g:5701:1: ( ( ( rule__ALSRangeRestrictionLeft__RelationAssignment_1_2 ) ) ) | ||
16451 | // InternalAlloyLanguage.g:5702:1: ( ( rule__ALSRangeRestrictionLeft__RelationAssignment_1_2 ) ) | ||
16452 | { | ||
16453 | // InternalAlloyLanguage.g:5702:1: ( ( rule__ALSRangeRestrictionLeft__RelationAssignment_1_2 ) ) | ||
16454 | // InternalAlloyLanguage.g:5703:1: ( rule__ALSRangeRestrictionLeft__RelationAssignment_1_2 ) | ||
16455 | { | ||
16456 | if ( state.backtracking==0 ) { | ||
16457 | before(grammarAccess.getALSRangeRestrictionLeftAccess().getRelationAssignment_1_2()); | ||
16458 | } | ||
16459 | // InternalAlloyLanguage.g:5704:1: ( rule__ALSRangeRestrictionLeft__RelationAssignment_1_2 ) | ||
16460 | // InternalAlloyLanguage.g:5704:2: rule__ALSRangeRestrictionLeft__RelationAssignment_1_2 | ||
16461 | { | ||
16462 | pushFollow(FOLLOW_2); | ||
16463 | rule__ALSRangeRestrictionLeft__RelationAssignment_1_2(); | ||
16464 | |||
16465 | state._fsp--; | ||
16466 | if (state.failed) return ; | ||
16467 | |||
16468 | } | ||
16469 | |||
16470 | if ( state.backtracking==0 ) { | ||
16471 | after(grammarAccess.getALSRangeRestrictionLeftAccess().getRelationAssignment_1_2()); | ||
16472 | } | ||
16473 | |||
16474 | } | ||
16475 | |||
16476 | |||
16477 | } | ||
16478 | |||
16479 | } | ||
16480 | catch (RecognitionException re) { | ||
16481 | reportError(re); | ||
16482 | recover(input,re); | ||
16483 | } | ||
16484 | finally { | ||
16485 | |||
16486 | restoreStackSize(stackSize); | ||
16487 | |||
16488 | } | ||
16489 | return ; | ||
16490 | } | ||
16491 | // $ANTLR end "rule__ALSRangeRestrictionLeft__Group_1__2__Impl" | ||
16492 | |||
16493 | |||
16494 | // $ANTLR start "rule__ALSJoin__Group__0" | ||
16495 | // InternalAlloyLanguage.g:5720:1: rule__ALSJoin__Group__0 : rule__ALSJoin__Group__0__Impl rule__ALSJoin__Group__1 ; | ||
16496 | public final void rule__ALSJoin__Group__0() throws RecognitionException { | ||
16497 | |||
16498 | int stackSize = keepStackSize(); | ||
16499 | |||
16500 | try { | ||
16501 | // InternalAlloyLanguage.g:5724:1: ( rule__ALSJoin__Group__0__Impl rule__ALSJoin__Group__1 ) | ||
16502 | // InternalAlloyLanguage.g:5725:2: rule__ALSJoin__Group__0__Impl rule__ALSJoin__Group__1 | ||
16503 | { | ||
16504 | pushFollow(FOLLOW_40); | ||
16505 | rule__ALSJoin__Group__0__Impl(); | ||
16506 | |||
16507 | state._fsp--; | ||
16508 | if (state.failed) return ; | ||
16509 | pushFollow(FOLLOW_2); | ||
16510 | rule__ALSJoin__Group__1(); | ||
16511 | |||
16512 | state._fsp--; | ||
16513 | if (state.failed) return ; | ||
16514 | |||
16515 | } | ||
16516 | |||
16517 | } | ||
16518 | catch (RecognitionException re) { | ||
16519 | reportError(re); | ||
16520 | recover(input,re); | ||
16521 | } | ||
16522 | finally { | ||
16523 | |||
16524 | restoreStackSize(stackSize); | ||
16525 | |||
16526 | } | ||
16527 | return ; | ||
16528 | } | ||
16529 | // $ANTLR end "rule__ALSJoin__Group__0" | ||
16530 | |||
16531 | |||
16532 | // $ANTLR start "rule__ALSJoin__Group__0__Impl" | ||
16533 | // InternalAlloyLanguage.g:5732:1: rule__ALSJoin__Group__0__Impl : ( ruleALSMinus ) ; | ||
16534 | public final void rule__ALSJoin__Group__0__Impl() throws RecognitionException { | ||
16535 | |||
16536 | int stackSize = keepStackSize(); | ||
16537 | |||
16538 | try { | ||
16539 | // InternalAlloyLanguage.g:5736:1: ( ( ruleALSMinus ) ) | ||
16540 | // InternalAlloyLanguage.g:5737:1: ( ruleALSMinus ) | ||
16541 | { | ||
16542 | // InternalAlloyLanguage.g:5737:1: ( ruleALSMinus ) | ||
16543 | // InternalAlloyLanguage.g:5738:1: ruleALSMinus | ||
16544 | { | ||
16545 | if ( state.backtracking==0 ) { | ||
16546 | before(grammarAccess.getALSJoinAccess().getALSMinusParserRuleCall_0()); | ||
16547 | } | ||
16548 | pushFollow(FOLLOW_2); | ||
16549 | ruleALSMinus(); | ||
16550 | |||
16551 | state._fsp--; | ||
16552 | if (state.failed) return ; | ||
16553 | if ( state.backtracking==0 ) { | ||
16554 | after(grammarAccess.getALSJoinAccess().getALSMinusParserRuleCall_0()); | ||
16555 | } | ||
16556 | |||
16557 | } | ||
16558 | |||
16559 | |||
16560 | } | ||
16561 | |||
16562 | } | ||
16563 | catch (RecognitionException re) { | ||
16564 | reportError(re); | ||
16565 | recover(input,re); | ||
16566 | } | ||
16567 | finally { | ||
16568 | |||
16569 | restoreStackSize(stackSize); | ||
16570 | |||
16571 | } | ||
16572 | return ; | ||
16573 | } | ||
16574 | // $ANTLR end "rule__ALSJoin__Group__0__Impl" | ||
16575 | |||
16576 | |||
16577 | // $ANTLR start "rule__ALSJoin__Group__1" | ||
16578 | // InternalAlloyLanguage.g:5749:1: rule__ALSJoin__Group__1 : rule__ALSJoin__Group__1__Impl ; | ||
16579 | public final void rule__ALSJoin__Group__1() throws RecognitionException { | ||
16580 | |||
16581 | int stackSize = keepStackSize(); | ||
16582 | |||
16583 | try { | ||
16584 | // InternalAlloyLanguage.g:5753:1: ( rule__ALSJoin__Group__1__Impl ) | ||
16585 | // InternalAlloyLanguage.g:5754:2: rule__ALSJoin__Group__1__Impl | ||
16586 | { | ||
16587 | pushFollow(FOLLOW_2); | ||
16588 | rule__ALSJoin__Group__1__Impl(); | ||
16589 | |||
16590 | state._fsp--; | ||
16591 | if (state.failed) return ; | ||
16592 | |||
16593 | } | ||
16594 | |||
16595 | } | ||
16596 | catch (RecognitionException re) { | ||
16597 | reportError(re); | ||
16598 | recover(input,re); | ||
16599 | } | ||
16600 | finally { | ||
16601 | |||
16602 | restoreStackSize(stackSize); | ||
16603 | |||
16604 | } | ||
16605 | return ; | ||
16606 | } | ||
16607 | // $ANTLR end "rule__ALSJoin__Group__1" | ||
16608 | |||
16609 | |||
16610 | // $ANTLR start "rule__ALSJoin__Group__1__Impl" | ||
16611 | // InternalAlloyLanguage.g:5760:1: rule__ALSJoin__Group__1__Impl : ( ( rule__ALSJoin__Group_1__0 )* ) ; | ||
16612 | public final void rule__ALSJoin__Group__1__Impl() throws RecognitionException { | ||
16613 | |||
16614 | int stackSize = keepStackSize(); | ||
16615 | |||
16616 | try { | ||
16617 | // InternalAlloyLanguage.g:5764:1: ( ( ( rule__ALSJoin__Group_1__0 )* ) ) | ||
16618 | // InternalAlloyLanguage.g:5765:1: ( ( rule__ALSJoin__Group_1__0 )* ) | ||
16619 | { | ||
16620 | // InternalAlloyLanguage.g:5765:1: ( ( rule__ALSJoin__Group_1__0 )* ) | ||
16621 | // InternalAlloyLanguage.g:5766:1: ( rule__ALSJoin__Group_1__0 )* | ||
16622 | { | ||
16623 | if ( state.backtracking==0 ) { | ||
16624 | before(grammarAccess.getALSJoinAccess().getGroup_1()); | ||
16625 | } | ||
16626 | // InternalAlloyLanguage.g:5767:1: ( rule__ALSJoin__Group_1__0 )* | ||
16627 | loop39: | ||
16628 | do { | ||
16629 | int alt39=2; | ||
16630 | int LA39_0 = input.LA(1); | ||
16631 | |||
16632 | if ( (LA39_0==56) ) { | ||
16633 | alt39=1; | ||
16634 | } | ||
16635 | |||
16636 | |||
16637 | switch (alt39) { | ||
16638 | case 1 : | ||
16639 | // InternalAlloyLanguage.g:5767:2: rule__ALSJoin__Group_1__0 | ||
16640 | { | ||
16641 | pushFollow(FOLLOW_41); | ||
16642 | rule__ALSJoin__Group_1__0(); | ||
16643 | |||
16644 | state._fsp--; | ||
16645 | if (state.failed) return ; | ||
16646 | |||
16647 | } | ||
16648 | break; | ||
16649 | |||
16650 | default : | ||
16651 | break loop39; | ||
16652 | } | ||
16653 | } while (true); | ||
16654 | |||
16655 | if ( state.backtracking==0 ) { | ||
16656 | after(grammarAccess.getALSJoinAccess().getGroup_1()); | ||
16657 | } | ||
16658 | |||
16659 | } | ||
16660 | |||
16661 | |||
16662 | } | ||
16663 | |||
16664 | } | ||
16665 | catch (RecognitionException re) { | ||
16666 | reportError(re); | ||
16667 | recover(input,re); | ||
16668 | } | ||
16669 | finally { | ||
16670 | |||
16671 | restoreStackSize(stackSize); | ||
16672 | |||
16673 | } | ||
16674 | return ; | ||
16675 | } | ||
16676 | // $ANTLR end "rule__ALSJoin__Group__1__Impl" | ||
16677 | |||
16678 | |||
16679 | // $ANTLR start "rule__ALSJoin__Group_1__0" | ||
16680 | // InternalAlloyLanguage.g:5781:1: rule__ALSJoin__Group_1__0 : rule__ALSJoin__Group_1__0__Impl rule__ALSJoin__Group_1__1 ; | ||
16681 | public final void rule__ALSJoin__Group_1__0() throws RecognitionException { | ||
16682 | |||
16683 | int stackSize = keepStackSize(); | ||
16684 | |||
16685 | try { | ||
16686 | // InternalAlloyLanguage.g:5785:1: ( rule__ALSJoin__Group_1__0__Impl rule__ALSJoin__Group_1__1 ) | ||
16687 | // InternalAlloyLanguage.g:5786:2: rule__ALSJoin__Group_1__0__Impl rule__ALSJoin__Group_1__1 | ||
16688 | { | ||
16689 | pushFollow(FOLLOW_40); | ||
16690 | rule__ALSJoin__Group_1__0__Impl(); | ||
16691 | |||
16692 | state._fsp--; | ||
16693 | if (state.failed) return ; | ||
16694 | pushFollow(FOLLOW_2); | ||
16695 | rule__ALSJoin__Group_1__1(); | ||
16696 | |||
16697 | state._fsp--; | ||
16698 | if (state.failed) return ; | ||
16699 | |||
16700 | } | ||
16701 | |||
16702 | } | ||
16703 | catch (RecognitionException re) { | ||
16704 | reportError(re); | ||
16705 | recover(input,re); | ||
16706 | } | ||
16707 | finally { | ||
16708 | |||
16709 | restoreStackSize(stackSize); | ||
16710 | |||
16711 | } | ||
16712 | return ; | ||
16713 | } | ||
16714 | // $ANTLR end "rule__ALSJoin__Group_1__0" | ||
16715 | |||
16716 | |||
16717 | // $ANTLR start "rule__ALSJoin__Group_1__0__Impl" | ||
16718 | // InternalAlloyLanguage.g:5793:1: rule__ALSJoin__Group_1__0__Impl : ( () ) ; | ||
16719 | public final void rule__ALSJoin__Group_1__0__Impl() throws RecognitionException { | ||
16720 | |||
16721 | int stackSize = keepStackSize(); | ||
16722 | |||
16723 | try { | ||
16724 | // InternalAlloyLanguage.g:5797:1: ( ( () ) ) | ||
16725 | // InternalAlloyLanguage.g:5798:1: ( () ) | ||
16726 | { | ||
16727 | // InternalAlloyLanguage.g:5798:1: ( () ) | ||
16728 | // InternalAlloyLanguage.g:5799:1: () | ||
16729 | { | ||
16730 | if ( state.backtracking==0 ) { | ||
16731 | before(grammarAccess.getALSJoinAccess().getALSJoinLeftOperandAction_1_0()); | ||
16732 | } | ||
16733 | // InternalAlloyLanguage.g:5800:1: () | ||
16734 | // InternalAlloyLanguage.g:5802:1: | ||
16735 | { | ||
16736 | } | ||
16737 | |||
16738 | if ( state.backtracking==0 ) { | ||
16739 | after(grammarAccess.getALSJoinAccess().getALSJoinLeftOperandAction_1_0()); | ||
16740 | } | ||
16741 | |||
16742 | } | ||
16743 | |||
16744 | |||
16745 | } | ||
16746 | |||
16747 | } | ||
16748 | finally { | ||
16749 | |||
16750 | restoreStackSize(stackSize); | ||
16751 | |||
16752 | } | ||
16753 | return ; | ||
16754 | } | ||
16755 | // $ANTLR end "rule__ALSJoin__Group_1__0__Impl" | ||
16756 | |||
16757 | |||
16758 | // $ANTLR start "rule__ALSJoin__Group_1__1" | ||
16759 | // InternalAlloyLanguage.g:5812:1: rule__ALSJoin__Group_1__1 : rule__ALSJoin__Group_1__1__Impl rule__ALSJoin__Group_1__2 ; | ||
16760 | public final void rule__ALSJoin__Group_1__1() throws RecognitionException { | ||
16761 | |||
16762 | int stackSize = keepStackSize(); | ||
16763 | |||
16764 | try { | ||
16765 | // InternalAlloyLanguage.g:5816:1: ( rule__ALSJoin__Group_1__1__Impl rule__ALSJoin__Group_1__2 ) | ||
16766 | // InternalAlloyLanguage.g:5817:2: rule__ALSJoin__Group_1__1__Impl rule__ALSJoin__Group_1__2 | ||
16767 | { | ||
16768 | pushFollow(FOLLOW_16); | ||
16769 | rule__ALSJoin__Group_1__1__Impl(); | ||
16770 | |||
16771 | state._fsp--; | ||
16772 | if (state.failed) return ; | ||
16773 | pushFollow(FOLLOW_2); | ||
16774 | rule__ALSJoin__Group_1__2(); | ||
16775 | |||
16776 | state._fsp--; | ||
16777 | if (state.failed) return ; | ||
16778 | |||
16779 | } | ||
16780 | |||
16781 | } | ||
16782 | catch (RecognitionException re) { | ||
16783 | reportError(re); | ||
16784 | recover(input,re); | ||
16785 | } | ||
16786 | finally { | ||
16787 | |||
16788 | restoreStackSize(stackSize); | ||
16789 | |||
16790 | } | ||
16791 | return ; | ||
16792 | } | ||
16793 | // $ANTLR end "rule__ALSJoin__Group_1__1" | ||
16794 | |||
16795 | |||
16796 | // $ANTLR start "rule__ALSJoin__Group_1__1__Impl" | ||
16797 | // InternalAlloyLanguage.g:5824:1: rule__ALSJoin__Group_1__1__Impl : ( '.' ) ; | ||
16798 | public final void rule__ALSJoin__Group_1__1__Impl() throws RecognitionException { | ||
16799 | |||
16800 | int stackSize = keepStackSize(); | ||
16801 | |||
16802 | try { | ||
16803 | // InternalAlloyLanguage.g:5828:1: ( ( '.' ) ) | ||
16804 | // InternalAlloyLanguage.g:5829:1: ( '.' ) | ||
16805 | { | ||
16806 | // InternalAlloyLanguage.g:5829:1: ( '.' ) | ||
16807 | // InternalAlloyLanguage.g:5830:1: '.' | ||
16808 | { | ||
16809 | if ( state.backtracking==0 ) { | ||
16810 | before(grammarAccess.getALSJoinAccess().getFullStopKeyword_1_1()); | ||
16811 | } | ||
16812 | match(input,56,FOLLOW_2); if (state.failed) return ; | ||
16813 | if ( state.backtracking==0 ) { | ||
16814 | after(grammarAccess.getALSJoinAccess().getFullStopKeyword_1_1()); | ||
16815 | } | ||
16816 | |||
16817 | } | ||
16818 | |||
16819 | |||
16820 | } | ||
16821 | |||
16822 | } | ||
16823 | catch (RecognitionException re) { | ||
16824 | reportError(re); | ||
16825 | recover(input,re); | ||
16826 | } | ||
16827 | finally { | ||
16828 | |||
16829 | restoreStackSize(stackSize); | ||
16830 | |||
16831 | } | ||
16832 | return ; | ||
16833 | } | ||
16834 | // $ANTLR end "rule__ALSJoin__Group_1__1__Impl" | ||
16835 | |||
16836 | |||
16837 | // $ANTLR start "rule__ALSJoin__Group_1__2" | ||
16838 | // InternalAlloyLanguage.g:5843:1: rule__ALSJoin__Group_1__2 : rule__ALSJoin__Group_1__2__Impl ; | ||
16839 | public final void rule__ALSJoin__Group_1__2() throws RecognitionException { | ||
16840 | |||
16841 | int stackSize = keepStackSize(); | ||
16842 | |||
16843 | try { | ||
16844 | // InternalAlloyLanguage.g:5847:1: ( rule__ALSJoin__Group_1__2__Impl ) | ||
16845 | // InternalAlloyLanguage.g:5848:2: rule__ALSJoin__Group_1__2__Impl | ||
16846 | { | ||
16847 | pushFollow(FOLLOW_2); | ||
16848 | rule__ALSJoin__Group_1__2__Impl(); | ||
16849 | |||
16850 | state._fsp--; | ||
16851 | if (state.failed) return ; | ||
16852 | |||
16853 | } | ||
16854 | |||
16855 | } | ||
16856 | catch (RecognitionException re) { | ||
16857 | reportError(re); | ||
16858 | recover(input,re); | ||
16859 | } | ||
16860 | finally { | ||
16861 | |||
16862 | restoreStackSize(stackSize); | ||
16863 | |||
16864 | } | ||
16865 | return ; | ||
16866 | } | ||
16867 | // $ANTLR end "rule__ALSJoin__Group_1__2" | ||
16868 | |||
16869 | |||
16870 | // $ANTLR start "rule__ALSJoin__Group_1__2__Impl" | ||
16871 | // InternalAlloyLanguage.g:5854:1: rule__ALSJoin__Group_1__2__Impl : ( ( rule__ALSJoin__RightOperandAssignment_1_2 ) ) ; | ||
16872 | public final void rule__ALSJoin__Group_1__2__Impl() throws RecognitionException { | ||
16873 | |||
16874 | int stackSize = keepStackSize(); | ||
16875 | |||
16876 | try { | ||
16877 | // InternalAlloyLanguage.g:5858:1: ( ( ( rule__ALSJoin__RightOperandAssignment_1_2 ) ) ) | ||
16878 | // InternalAlloyLanguage.g:5859:1: ( ( rule__ALSJoin__RightOperandAssignment_1_2 ) ) | ||
16879 | { | ||
16880 | // InternalAlloyLanguage.g:5859:1: ( ( rule__ALSJoin__RightOperandAssignment_1_2 ) ) | ||
16881 | // InternalAlloyLanguage.g:5860:1: ( rule__ALSJoin__RightOperandAssignment_1_2 ) | ||
16882 | { | ||
16883 | if ( state.backtracking==0 ) { | ||
16884 | before(grammarAccess.getALSJoinAccess().getRightOperandAssignment_1_2()); | ||
16885 | } | ||
16886 | // InternalAlloyLanguage.g:5861:1: ( rule__ALSJoin__RightOperandAssignment_1_2 ) | ||
16887 | // InternalAlloyLanguage.g:5861:2: rule__ALSJoin__RightOperandAssignment_1_2 | ||
16888 | { | ||
16889 | pushFollow(FOLLOW_2); | ||
16890 | rule__ALSJoin__RightOperandAssignment_1_2(); | ||
16891 | |||
16892 | state._fsp--; | ||
16893 | if (state.failed) return ; | ||
16894 | |||
16895 | } | ||
16896 | |||
16897 | if ( state.backtracking==0 ) { | ||
16898 | after(grammarAccess.getALSJoinAccess().getRightOperandAssignment_1_2()); | ||
16899 | } | ||
16900 | |||
16901 | } | ||
16902 | |||
16903 | |||
16904 | } | ||
16905 | |||
16906 | } | ||
16907 | catch (RecognitionException re) { | ||
16908 | reportError(re); | ||
16909 | recover(input,re); | ||
16910 | } | ||
16911 | finally { | ||
16912 | |||
16913 | restoreStackSize(stackSize); | ||
16914 | |||
16915 | } | ||
16916 | return ; | ||
16917 | } | ||
16918 | // $ANTLR end "rule__ALSJoin__Group_1__2__Impl" | ||
16919 | |||
16920 | |||
16921 | // $ANTLR start "rule__ALSMinus__Group__0" | ||
16922 | // InternalAlloyLanguage.g:5877:1: rule__ALSMinus__Group__0 : rule__ALSMinus__Group__0__Impl rule__ALSMinus__Group__1 ; | ||
16923 | public final void rule__ALSMinus__Group__0() throws RecognitionException { | ||
16924 | |||
16925 | int stackSize = keepStackSize(); | ||
16926 | |||
16927 | try { | ||
16928 | // InternalAlloyLanguage.g:5881:1: ( rule__ALSMinus__Group__0__Impl rule__ALSMinus__Group__1 ) | ||
16929 | // InternalAlloyLanguage.g:5882:2: rule__ALSMinus__Group__0__Impl rule__ALSMinus__Group__1 | ||
16930 | { | ||
16931 | pushFollow(FOLLOW_42); | ||
16932 | rule__ALSMinus__Group__0__Impl(); | ||
16933 | |||
16934 | state._fsp--; | ||
16935 | if (state.failed) return ; | ||
16936 | pushFollow(FOLLOW_2); | ||
16937 | rule__ALSMinus__Group__1(); | ||
16938 | |||
16939 | state._fsp--; | ||
16940 | if (state.failed) return ; | ||
16941 | |||
16942 | } | ||
16943 | |||
16944 | } | ||
16945 | catch (RecognitionException re) { | ||
16946 | reportError(re); | ||
16947 | recover(input,re); | ||
16948 | } | ||
16949 | finally { | ||
16950 | |||
16951 | restoreStackSize(stackSize); | ||
16952 | |||
16953 | } | ||
16954 | return ; | ||
16955 | } | ||
16956 | // $ANTLR end "rule__ALSMinus__Group__0" | ||
16957 | |||
16958 | |||
16959 | // $ANTLR start "rule__ALSMinus__Group__0__Impl" | ||
16960 | // InternalAlloyLanguage.g:5889:1: rule__ALSMinus__Group__0__Impl : ( ruleALSPlus ) ; | ||
16961 | public final void rule__ALSMinus__Group__0__Impl() throws RecognitionException { | ||
16962 | |||
16963 | int stackSize = keepStackSize(); | ||
16964 | |||
16965 | try { | ||
16966 | // InternalAlloyLanguage.g:5893:1: ( ( ruleALSPlus ) ) | ||
16967 | // InternalAlloyLanguage.g:5894:1: ( ruleALSPlus ) | ||
16968 | { | ||
16969 | // InternalAlloyLanguage.g:5894:1: ( ruleALSPlus ) | ||
16970 | // InternalAlloyLanguage.g:5895:1: ruleALSPlus | ||
16971 | { | ||
16972 | if ( state.backtracking==0 ) { | ||
16973 | before(grammarAccess.getALSMinusAccess().getALSPlusParserRuleCall_0()); | ||
16974 | } | ||
16975 | pushFollow(FOLLOW_2); | ||
16976 | ruleALSPlus(); | ||
16977 | |||
16978 | state._fsp--; | ||
16979 | if (state.failed) return ; | ||
16980 | if ( state.backtracking==0 ) { | ||
16981 | after(grammarAccess.getALSMinusAccess().getALSPlusParserRuleCall_0()); | ||
16982 | } | ||
16983 | |||
16984 | } | ||
16985 | |||
16986 | |||
16987 | } | ||
16988 | |||
16989 | } | ||
16990 | catch (RecognitionException re) { | ||
16991 | reportError(re); | ||
16992 | recover(input,re); | ||
16993 | } | ||
16994 | finally { | ||
16995 | |||
16996 | restoreStackSize(stackSize); | ||
16997 | |||
16998 | } | ||
16999 | return ; | ||
17000 | } | ||
17001 | // $ANTLR end "rule__ALSMinus__Group__0__Impl" | ||
17002 | |||
17003 | |||
17004 | // $ANTLR start "rule__ALSMinus__Group__1" | ||
17005 | // InternalAlloyLanguage.g:5906:1: rule__ALSMinus__Group__1 : rule__ALSMinus__Group__1__Impl ; | ||
17006 | public final void rule__ALSMinus__Group__1() throws RecognitionException { | ||
17007 | |||
17008 | int stackSize = keepStackSize(); | ||
17009 | |||
17010 | try { | ||
17011 | // InternalAlloyLanguage.g:5910:1: ( rule__ALSMinus__Group__1__Impl ) | ||
17012 | // InternalAlloyLanguage.g:5911:2: rule__ALSMinus__Group__1__Impl | ||
17013 | { | ||
17014 | pushFollow(FOLLOW_2); | ||
17015 | rule__ALSMinus__Group__1__Impl(); | ||
17016 | |||
17017 | state._fsp--; | ||
17018 | if (state.failed) return ; | ||
17019 | |||
17020 | } | ||
17021 | |||
17022 | } | ||
17023 | catch (RecognitionException re) { | ||
17024 | reportError(re); | ||
17025 | recover(input,re); | ||
17026 | } | ||
17027 | finally { | ||
17028 | |||
17029 | restoreStackSize(stackSize); | ||
17030 | |||
17031 | } | ||
17032 | return ; | ||
17033 | } | ||
17034 | // $ANTLR end "rule__ALSMinus__Group__1" | ||
17035 | |||
17036 | |||
17037 | // $ANTLR start "rule__ALSMinus__Group__1__Impl" | ||
17038 | // InternalAlloyLanguage.g:5917:1: rule__ALSMinus__Group__1__Impl : ( ( rule__ALSMinus__Group_1__0 )* ) ; | ||
17039 | public final void rule__ALSMinus__Group__1__Impl() throws RecognitionException { | ||
17040 | |||
17041 | int stackSize = keepStackSize(); | ||
17042 | |||
17043 | try { | ||
17044 | // InternalAlloyLanguage.g:5921:1: ( ( ( rule__ALSMinus__Group_1__0 )* ) ) | ||
17045 | // InternalAlloyLanguage.g:5922:1: ( ( rule__ALSMinus__Group_1__0 )* ) | ||
17046 | { | ||
17047 | // InternalAlloyLanguage.g:5922:1: ( ( rule__ALSMinus__Group_1__0 )* ) | ||
17048 | // InternalAlloyLanguage.g:5923:1: ( rule__ALSMinus__Group_1__0 )* | ||
17049 | { | ||
17050 | if ( state.backtracking==0 ) { | ||
17051 | before(grammarAccess.getALSMinusAccess().getGroup_1()); | ||
17052 | } | ||
17053 | // InternalAlloyLanguage.g:5924:1: ( rule__ALSMinus__Group_1__0 )* | ||
17054 | loop40: | ||
17055 | do { | ||
17056 | int alt40=2; | ||
17057 | int LA40_0 = input.LA(1); | ||
17058 | |||
17059 | if ( (LA40_0==57) ) { | ||
17060 | alt40=1; | ||
17061 | } | ||
17062 | |||
17063 | |||
17064 | switch (alt40) { | ||
17065 | case 1 : | ||
17066 | // InternalAlloyLanguage.g:5924:2: rule__ALSMinus__Group_1__0 | ||
17067 | { | ||
17068 | pushFollow(FOLLOW_43); | ||
17069 | rule__ALSMinus__Group_1__0(); | ||
17070 | |||
17071 | state._fsp--; | ||
17072 | if (state.failed) return ; | ||
17073 | |||
17074 | } | ||
17075 | break; | ||
17076 | |||
17077 | default : | ||
17078 | break loop40; | ||
17079 | } | ||
17080 | } while (true); | ||
17081 | |||
17082 | if ( state.backtracking==0 ) { | ||
17083 | after(grammarAccess.getALSMinusAccess().getGroup_1()); | ||
17084 | } | ||
17085 | |||
17086 | } | ||
17087 | |||
17088 | |||
17089 | } | ||
17090 | |||
17091 | } | ||
17092 | catch (RecognitionException re) { | ||
17093 | reportError(re); | ||
17094 | recover(input,re); | ||
17095 | } | ||
17096 | finally { | ||
17097 | |||
17098 | restoreStackSize(stackSize); | ||
17099 | |||
17100 | } | ||
17101 | return ; | ||
17102 | } | ||
17103 | // $ANTLR end "rule__ALSMinus__Group__1__Impl" | ||
17104 | |||
17105 | |||
17106 | // $ANTLR start "rule__ALSMinus__Group_1__0" | ||
17107 | // InternalAlloyLanguage.g:5938:1: rule__ALSMinus__Group_1__0 : rule__ALSMinus__Group_1__0__Impl rule__ALSMinus__Group_1__1 ; | ||
17108 | public final void rule__ALSMinus__Group_1__0() throws RecognitionException { | ||
17109 | |||
17110 | int stackSize = keepStackSize(); | ||
17111 | |||
17112 | try { | ||
17113 | // InternalAlloyLanguage.g:5942:1: ( rule__ALSMinus__Group_1__0__Impl rule__ALSMinus__Group_1__1 ) | ||
17114 | // InternalAlloyLanguage.g:5943:2: rule__ALSMinus__Group_1__0__Impl rule__ALSMinus__Group_1__1 | ||
17115 | { | ||
17116 | pushFollow(FOLLOW_42); | ||
17117 | rule__ALSMinus__Group_1__0__Impl(); | ||
17118 | |||
17119 | state._fsp--; | ||
17120 | if (state.failed) return ; | ||
17121 | pushFollow(FOLLOW_2); | ||
17122 | rule__ALSMinus__Group_1__1(); | ||
17123 | |||
17124 | state._fsp--; | ||
17125 | if (state.failed) return ; | ||
17126 | |||
17127 | } | ||
17128 | |||
17129 | } | ||
17130 | catch (RecognitionException re) { | ||
17131 | reportError(re); | ||
17132 | recover(input,re); | ||
17133 | } | ||
17134 | finally { | ||
17135 | |||
17136 | restoreStackSize(stackSize); | ||
17137 | |||
17138 | } | ||
17139 | return ; | ||
17140 | } | ||
17141 | // $ANTLR end "rule__ALSMinus__Group_1__0" | ||
17142 | |||
17143 | |||
17144 | // $ANTLR start "rule__ALSMinus__Group_1__0__Impl" | ||
17145 | // InternalAlloyLanguage.g:5950:1: rule__ALSMinus__Group_1__0__Impl : ( () ) ; | ||
17146 | public final void rule__ALSMinus__Group_1__0__Impl() throws RecognitionException { | ||
17147 | |||
17148 | int stackSize = keepStackSize(); | ||
17149 | |||
17150 | try { | ||
17151 | // InternalAlloyLanguage.g:5954:1: ( ( () ) ) | ||
17152 | // InternalAlloyLanguage.g:5955:1: ( () ) | ||
17153 | { | ||
17154 | // InternalAlloyLanguage.g:5955:1: ( () ) | ||
17155 | // InternalAlloyLanguage.g:5956:1: () | ||
17156 | { | ||
17157 | if ( state.backtracking==0 ) { | ||
17158 | before(grammarAccess.getALSMinusAccess().getALSMinusLeftOperandAction_1_0()); | ||
17159 | } | ||
17160 | // InternalAlloyLanguage.g:5957:1: () | ||
17161 | // InternalAlloyLanguage.g:5959:1: | ||
17162 | { | ||
17163 | } | ||
17164 | |||
17165 | if ( state.backtracking==0 ) { | ||
17166 | after(grammarAccess.getALSMinusAccess().getALSMinusLeftOperandAction_1_0()); | ||
17167 | } | ||
17168 | |||
17169 | } | ||
17170 | |||
17171 | |||
17172 | } | ||
17173 | |||
17174 | } | ||
17175 | finally { | ||
17176 | |||
17177 | restoreStackSize(stackSize); | ||
17178 | |||
17179 | } | ||
17180 | return ; | ||
17181 | } | ||
17182 | // $ANTLR end "rule__ALSMinus__Group_1__0__Impl" | ||
17183 | |||
17184 | |||
17185 | // $ANTLR start "rule__ALSMinus__Group_1__1" | ||
17186 | // InternalAlloyLanguage.g:5969:1: rule__ALSMinus__Group_1__1 : rule__ALSMinus__Group_1__1__Impl rule__ALSMinus__Group_1__2 ; | ||
17187 | public final void rule__ALSMinus__Group_1__1() throws RecognitionException { | ||
17188 | |||
17189 | int stackSize = keepStackSize(); | ||
17190 | |||
17191 | try { | ||
17192 | // InternalAlloyLanguage.g:5973:1: ( rule__ALSMinus__Group_1__1__Impl rule__ALSMinus__Group_1__2 ) | ||
17193 | // InternalAlloyLanguage.g:5974:2: rule__ALSMinus__Group_1__1__Impl rule__ALSMinus__Group_1__2 | ||
17194 | { | ||
17195 | pushFollow(FOLLOW_16); | ||
17196 | rule__ALSMinus__Group_1__1__Impl(); | ||
17197 | |||
17198 | state._fsp--; | ||
17199 | if (state.failed) return ; | ||
17200 | pushFollow(FOLLOW_2); | ||
17201 | rule__ALSMinus__Group_1__2(); | ||
17202 | |||
17203 | state._fsp--; | ||
17204 | if (state.failed) return ; | ||
17205 | |||
17206 | } | ||
17207 | |||
17208 | } | ||
17209 | catch (RecognitionException re) { | ||
17210 | reportError(re); | ||
17211 | recover(input,re); | ||
17212 | } | ||
17213 | finally { | ||
17214 | |||
17215 | restoreStackSize(stackSize); | ||
17216 | |||
17217 | } | ||
17218 | return ; | ||
17219 | } | ||
17220 | // $ANTLR end "rule__ALSMinus__Group_1__1" | ||
17221 | |||
17222 | |||
17223 | // $ANTLR start "rule__ALSMinus__Group_1__1__Impl" | ||
17224 | // InternalAlloyLanguage.g:5981:1: rule__ALSMinus__Group_1__1__Impl : ( '-' ) ; | ||
17225 | public final void rule__ALSMinus__Group_1__1__Impl() throws RecognitionException { | ||
17226 | |||
17227 | int stackSize = keepStackSize(); | ||
17228 | |||
17229 | try { | ||
17230 | // InternalAlloyLanguage.g:5985:1: ( ( '-' ) ) | ||
17231 | // InternalAlloyLanguage.g:5986:1: ( '-' ) | ||
17232 | { | ||
17233 | // InternalAlloyLanguage.g:5986:1: ( '-' ) | ||
17234 | // InternalAlloyLanguage.g:5987:1: '-' | ||
17235 | { | ||
17236 | if ( state.backtracking==0 ) { | ||
17237 | before(grammarAccess.getALSMinusAccess().getHyphenMinusKeyword_1_1()); | ||
17238 | } | ||
17239 | match(input,57,FOLLOW_2); if (state.failed) return ; | ||
17240 | if ( state.backtracking==0 ) { | ||
17241 | after(grammarAccess.getALSMinusAccess().getHyphenMinusKeyword_1_1()); | ||
17242 | } | ||
17243 | |||
17244 | } | ||
17245 | |||
17246 | |||
17247 | } | ||
17248 | |||
17249 | } | ||
17250 | catch (RecognitionException re) { | ||
17251 | reportError(re); | ||
17252 | recover(input,re); | ||
17253 | } | ||
17254 | finally { | ||
17255 | |||
17256 | restoreStackSize(stackSize); | ||
17257 | |||
17258 | } | ||
17259 | return ; | ||
17260 | } | ||
17261 | // $ANTLR end "rule__ALSMinus__Group_1__1__Impl" | ||
17262 | |||
17263 | |||
17264 | // $ANTLR start "rule__ALSMinus__Group_1__2" | ||
17265 | // InternalAlloyLanguage.g:6000:1: rule__ALSMinus__Group_1__2 : rule__ALSMinus__Group_1__2__Impl ; | ||
17266 | public final void rule__ALSMinus__Group_1__2() throws RecognitionException { | ||
17267 | |||
17268 | int stackSize = keepStackSize(); | ||
17269 | |||
17270 | try { | ||
17271 | // InternalAlloyLanguage.g:6004:1: ( rule__ALSMinus__Group_1__2__Impl ) | ||
17272 | // InternalAlloyLanguage.g:6005:2: rule__ALSMinus__Group_1__2__Impl | ||
17273 | { | ||
17274 | pushFollow(FOLLOW_2); | ||
17275 | rule__ALSMinus__Group_1__2__Impl(); | ||
17276 | |||
17277 | state._fsp--; | ||
17278 | if (state.failed) return ; | ||
17279 | |||
17280 | } | ||
17281 | |||
17282 | } | ||
17283 | catch (RecognitionException re) { | ||
17284 | reportError(re); | ||
17285 | recover(input,re); | ||
17286 | } | ||
17287 | finally { | ||
17288 | |||
17289 | restoreStackSize(stackSize); | ||
17290 | |||
17291 | } | ||
17292 | return ; | ||
17293 | } | ||
17294 | // $ANTLR end "rule__ALSMinus__Group_1__2" | ||
17295 | |||
17296 | |||
17297 | // $ANTLR start "rule__ALSMinus__Group_1__2__Impl" | ||
17298 | // InternalAlloyLanguage.g:6011:1: rule__ALSMinus__Group_1__2__Impl : ( ( rule__ALSMinus__RightOperandAssignment_1_2 ) ) ; | ||
17299 | public final void rule__ALSMinus__Group_1__2__Impl() throws RecognitionException { | ||
17300 | |||
17301 | int stackSize = keepStackSize(); | ||
17302 | |||
17303 | try { | ||
17304 | // InternalAlloyLanguage.g:6015:1: ( ( ( rule__ALSMinus__RightOperandAssignment_1_2 ) ) ) | ||
17305 | // InternalAlloyLanguage.g:6016:1: ( ( rule__ALSMinus__RightOperandAssignment_1_2 ) ) | ||
17306 | { | ||
17307 | // InternalAlloyLanguage.g:6016:1: ( ( rule__ALSMinus__RightOperandAssignment_1_2 ) ) | ||
17308 | // InternalAlloyLanguage.g:6017:1: ( rule__ALSMinus__RightOperandAssignment_1_2 ) | ||
17309 | { | ||
17310 | if ( state.backtracking==0 ) { | ||
17311 | before(grammarAccess.getALSMinusAccess().getRightOperandAssignment_1_2()); | ||
17312 | } | ||
17313 | // InternalAlloyLanguage.g:6018:1: ( rule__ALSMinus__RightOperandAssignment_1_2 ) | ||
17314 | // InternalAlloyLanguage.g:6018:2: rule__ALSMinus__RightOperandAssignment_1_2 | ||
17315 | { | ||
17316 | pushFollow(FOLLOW_2); | ||
17317 | rule__ALSMinus__RightOperandAssignment_1_2(); | ||
17318 | |||
17319 | state._fsp--; | ||
17320 | if (state.failed) return ; | ||
17321 | |||
17322 | } | ||
17323 | |||
17324 | if ( state.backtracking==0 ) { | ||
17325 | after(grammarAccess.getALSMinusAccess().getRightOperandAssignment_1_2()); | ||
17326 | } | ||
17327 | |||
17328 | } | ||
17329 | |||
17330 | |||
17331 | } | ||
17332 | |||
17333 | } | ||
17334 | catch (RecognitionException re) { | ||
17335 | reportError(re); | ||
17336 | recover(input,re); | ||
17337 | } | ||
17338 | finally { | ||
17339 | |||
17340 | restoreStackSize(stackSize); | ||
17341 | |||
17342 | } | ||
17343 | return ; | ||
17344 | } | ||
17345 | // $ANTLR end "rule__ALSMinus__Group_1__2__Impl" | ||
17346 | |||
17347 | |||
17348 | // $ANTLR start "rule__ALSPlus__Group__0" | ||
17349 | // InternalAlloyLanguage.g:6034:1: rule__ALSPlus__Group__0 : rule__ALSPlus__Group__0__Impl rule__ALSPlus__Group__1 ; | ||
17350 | public final void rule__ALSPlus__Group__0() throws RecognitionException { | ||
17351 | |||
17352 | int stackSize = keepStackSize(); | ||
17353 | |||
17354 | try { | ||
17355 | // InternalAlloyLanguage.g:6038:1: ( rule__ALSPlus__Group__0__Impl rule__ALSPlus__Group__1 ) | ||
17356 | // InternalAlloyLanguage.g:6039:2: rule__ALSPlus__Group__0__Impl rule__ALSPlus__Group__1 | ||
17357 | { | ||
17358 | pushFollow(FOLLOW_12); | ||
17359 | rule__ALSPlus__Group__0__Impl(); | ||
17360 | |||
17361 | state._fsp--; | ||
17362 | if (state.failed) return ; | ||
17363 | pushFollow(FOLLOW_2); | ||
17364 | rule__ALSPlus__Group__1(); | ||
17365 | |||
17366 | state._fsp--; | ||
17367 | if (state.failed) return ; | ||
17368 | |||
17369 | } | ||
17370 | |||
17371 | } | ||
17372 | catch (RecognitionException re) { | ||
17373 | reportError(re); | ||
17374 | recover(input,re); | ||
17375 | } | ||
17376 | finally { | ||
17377 | |||
17378 | restoreStackSize(stackSize); | ||
17379 | |||
17380 | } | ||
17381 | return ; | ||
17382 | } | ||
17383 | // $ANTLR end "rule__ALSPlus__Group__0" | ||
17384 | |||
17385 | |||
17386 | // $ANTLR start "rule__ALSPlus__Group__0__Impl" | ||
17387 | // InternalAlloyLanguage.g:6046:1: rule__ALSPlus__Group__0__Impl : ( ruleALSIntersection ) ; | ||
17388 | public final void rule__ALSPlus__Group__0__Impl() throws RecognitionException { | ||
17389 | |||
17390 | int stackSize = keepStackSize(); | ||
17391 | |||
17392 | try { | ||
17393 | // InternalAlloyLanguage.g:6050:1: ( ( ruleALSIntersection ) ) | ||
17394 | // InternalAlloyLanguage.g:6051:1: ( ruleALSIntersection ) | ||
17395 | { | ||
17396 | // InternalAlloyLanguage.g:6051:1: ( ruleALSIntersection ) | ||
17397 | // InternalAlloyLanguage.g:6052:1: ruleALSIntersection | ||
17398 | { | ||
17399 | if ( state.backtracking==0 ) { | ||
17400 | before(grammarAccess.getALSPlusAccess().getALSIntersectionParserRuleCall_0()); | ||
17401 | } | ||
17402 | pushFollow(FOLLOW_2); | ||
17403 | ruleALSIntersection(); | ||
17404 | |||
17405 | state._fsp--; | ||
17406 | if (state.failed) return ; | ||
17407 | if ( state.backtracking==0 ) { | ||
17408 | after(grammarAccess.getALSPlusAccess().getALSIntersectionParserRuleCall_0()); | ||
17409 | } | ||
17410 | |||
17411 | } | ||
17412 | |||
17413 | |||
17414 | } | ||
17415 | |||
17416 | } | ||
17417 | catch (RecognitionException re) { | ||
17418 | reportError(re); | ||
17419 | recover(input,re); | ||
17420 | } | ||
17421 | finally { | ||
17422 | |||
17423 | restoreStackSize(stackSize); | ||
17424 | |||
17425 | } | ||
17426 | return ; | ||
17427 | } | ||
17428 | // $ANTLR end "rule__ALSPlus__Group__0__Impl" | ||
17429 | |||
17430 | |||
17431 | // $ANTLR start "rule__ALSPlus__Group__1" | ||
17432 | // InternalAlloyLanguage.g:6063:1: rule__ALSPlus__Group__1 : rule__ALSPlus__Group__1__Impl ; | ||
17433 | public final void rule__ALSPlus__Group__1() throws RecognitionException { | ||
17434 | |||
17435 | int stackSize = keepStackSize(); | ||
17436 | |||
17437 | try { | ||
17438 | // InternalAlloyLanguage.g:6067:1: ( rule__ALSPlus__Group__1__Impl ) | ||
17439 | // InternalAlloyLanguage.g:6068:2: rule__ALSPlus__Group__1__Impl | ||
17440 | { | ||
17441 | pushFollow(FOLLOW_2); | ||
17442 | rule__ALSPlus__Group__1__Impl(); | ||
17443 | |||
17444 | state._fsp--; | ||
17445 | if (state.failed) return ; | ||
17446 | |||
17447 | } | ||
17448 | |||
17449 | } | ||
17450 | catch (RecognitionException re) { | ||
17451 | reportError(re); | ||
17452 | recover(input,re); | ||
17453 | } | ||
17454 | finally { | ||
17455 | |||
17456 | restoreStackSize(stackSize); | ||
17457 | |||
17458 | } | ||
17459 | return ; | ||
17460 | } | ||
17461 | // $ANTLR end "rule__ALSPlus__Group__1" | ||
17462 | |||
17463 | |||
17464 | // $ANTLR start "rule__ALSPlus__Group__1__Impl" | ||
17465 | // InternalAlloyLanguage.g:6074:1: rule__ALSPlus__Group__1__Impl : ( ( rule__ALSPlus__Group_1__0 )* ) ; | ||
17466 | public final void rule__ALSPlus__Group__1__Impl() throws RecognitionException { | ||
17467 | |||
17468 | int stackSize = keepStackSize(); | ||
17469 | |||
17470 | try { | ||
17471 | // InternalAlloyLanguage.g:6078:1: ( ( ( rule__ALSPlus__Group_1__0 )* ) ) | ||
17472 | // InternalAlloyLanguage.g:6079:1: ( ( rule__ALSPlus__Group_1__0 )* ) | ||
17473 | { | ||
17474 | // InternalAlloyLanguage.g:6079:1: ( ( rule__ALSPlus__Group_1__0 )* ) | ||
17475 | // InternalAlloyLanguage.g:6080:1: ( rule__ALSPlus__Group_1__0 )* | ||
17476 | { | ||
17477 | if ( state.backtracking==0 ) { | ||
17478 | before(grammarAccess.getALSPlusAccess().getGroup_1()); | ||
17479 | } | ||
17480 | // InternalAlloyLanguage.g:6081:1: ( rule__ALSPlus__Group_1__0 )* | ||
17481 | loop41: | ||
17482 | do { | ||
17483 | int alt41=2; | ||
17484 | int LA41_0 = input.LA(1); | ||
17485 | |||
17486 | if ( (LA41_0==39) ) { | ||
17487 | alt41=1; | ||
17488 | } | ||
17489 | |||
17490 | |||
17491 | switch (alt41) { | ||
17492 | case 1 : | ||
17493 | // InternalAlloyLanguage.g:6081:2: rule__ALSPlus__Group_1__0 | ||
17494 | { | ||
17495 | pushFollow(FOLLOW_13); | ||
17496 | rule__ALSPlus__Group_1__0(); | ||
17497 | |||
17498 | state._fsp--; | ||
17499 | if (state.failed) return ; | ||
17500 | |||
17501 | } | ||
17502 | break; | ||
17503 | |||
17504 | default : | ||
17505 | break loop41; | ||
17506 | } | ||
17507 | } while (true); | ||
17508 | |||
17509 | if ( state.backtracking==0 ) { | ||
17510 | after(grammarAccess.getALSPlusAccess().getGroup_1()); | ||
17511 | } | ||
17512 | |||
17513 | } | ||
17514 | |||
17515 | |||
17516 | } | ||
17517 | |||
17518 | } | ||
17519 | catch (RecognitionException re) { | ||
17520 | reportError(re); | ||
17521 | recover(input,re); | ||
17522 | } | ||
17523 | finally { | ||
17524 | |||
17525 | restoreStackSize(stackSize); | ||
17526 | |||
17527 | } | ||
17528 | return ; | ||
17529 | } | ||
17530 | // $ANTLR end "rule__ALSPlus__Group__1__Impl" | ||
17531 | |||
17532 | |||
17533 | // $ANTLR start "rule__ALSPlus__Group_1__0" | ||
17534 | // InternalAlloyLanguage.g:6095:1: rule__ALSPlus__Group_1__0 : rule__ALSPlus__Group_1__0__Impl rule__ALSPlus__Group_1__1 ; | ||
17535 | public final void rule__ALSPlus__Group_1__0() throws RecognitionException { | ||
17536 | |||
17537 | int stackSize = keepStackSize(); | ||
17538 | |||
17539 | try { | ||
17540 | // InternalAlloyLanguage.g:6099:1: ( rule__ALSPlus__Group_1__0__Impl rule__ALSPlus__Group_1__1 ) | ||
17541 | // InternalAlloyLanguage.g:6100:2: rule__ALSPlus__Group_1__0__Impl rule__ALSPlus__Group_1__1 | ||
17542 | { | ||
17543 | pushFollow(FOLLOW_12); | ||
17544 | rule__ALSPlus__Group_1__0__Impl(); | ||
17545 | |||
17546 | state._fsp--; | ||
17547 | if (state.failed) return ; | ||
17548 | pushFollow(FOLLOW_2); | ||
17549 | rule__ALSPlus__Group_1__1(); | ||
17550 | |||
17551 | state._fsp--; | ||
17552 | if (state.failed) return ; | ||
17553 | |||
17554 | } | ||
17555 | |||
17556 | } | ||
17557 | catch (RecognitionException re) { | ||
17558 | reportError(re); | ||
17559 | recover(input,re); | ||
17560 | } | ||
17561 | finally { | ||
17562 | |||
17563 | restoreStackSize(stackSize); | ||
17564 | |||
17565 | } | ||
17566 | return ; | ||
17567 | } | ||
17568 | // $ANTLR end "rule__ALSPlus__Group_1__0" | ||
17569 | |||
17570 | |||
17571 | // $ANTLR start "rule__ALSPlus__Group_1__0__Impl" | ||
17572 | // InternalAlloyLanguage.g:6107:1: rule__ALSPlus__Group_1__0__Impl : ( () ) ; | ||
17573 | public final void rule__ALSPlus__Group_1__0__Impl() throws RecognitionException { | ||
17574 | |||
17575 | int stackSize = keepStackSize(); | ||
17576 | |||
17577 | try { | ||
17578 | // InternalAlloyLanguage.g:6111:1: ( ( () ) ) | ||
17579 | // InternalAlloyLanguage.g:6112:1: ( () ) | ||
17580 | { | ||
17581 | // InternalAlloyLanguage.g:6112:1: ( () ) | ||
17582 | // InternalAlloyLanguage.g:6113:1: () | ||
17583 | { | ||
17584 | if ( state.backtracking==0 ) { | ||
17585 | before(grammarAccess.getALSPlusAccess().getALSPlusLeftOperandAction_1_0()); | ||
17586 | } | ||
17587 | // InternalAlloyLanguage.g:6114:1: () | ||
17588 | // InternalAlloyLanguage.g:6116:1: | ||
17589 | { | ||
17590 | } | ||
17591 | |||
17592 | if ( state.backtracking==0 ) { | ||
17593 | after(grammarAccess.getALSPlusAccess().getALSPlusLeftOperandAction_1_0()); | ||
17594 | } | ||
17595 | |||
17596 | } | ||
17597 | |||
17598 | |||
17599 | } | ||
17600 | |||
17601 | } | ||
17602 | finally { | ||
17603 | |||
17604 | restoreStackSize(stackSize); | ||
17605 | |||
17606 | } | ||
17607 | return ; | ||
17608 | } | ||
17609 | // $ANTLR end "rule__ALSPlus__Group_1__0__Impl" | ||
17610 | |||
17611 | |||
17612 | // $ANTLR start "rule__ALSPlus__Group_1__1" | ||
17613 | // InternalAlloyLanguage.g:6126:1: rule__ALSPlus__Group_1__1 : rule__ALSPlus__Group_1__1__Impl rule__ALSPlus__Group_1__2 ; | ||
17614 | public final void rule__ALSPlus__Group_1__1() throws RecognitionException { | ||
17615 | |||
17616 | int stackSize = keepStackSize(); | ||
17617 | |||
17618 | try { | ||
17619 | // InternalAlloyLanguage.g:6130:1: ( rule__ALSPlus__Group_1__1__Impl rule__ALSPlus__Group_1__2 ) | ||
17620 | // InternalAlloyLanguage.g:6131:2: rule__ALSPlus__Group_1__1__Impl rule__ALSPlus__Group_1__2 | ||
17621 | { | ||
17622 | pushFollow(FOLLOW_16); | ||
17623 | rule__ALSPlus__Group_1__1__Impl(); | ||
17624 | |||
17625 | state._fsp--; | ||
17626 | if (state.failed) return ; | ||
17627 | pushFollow(FOLLOW_2); | ||
17628 | rule__ALSPlus__Group_1__2(); | ||
17629 | |||
17630 | state._fsp--; | ||
17631 | if (state.failed) return ; | ||
17632 | |||
17633 | } | ||
17634 | |||
17635 | } | ||
17636 | catch (RecognitionException re) { | ||
17637 | reportError(re); | ||
17638 | recover(input,re); | ||
17639 | } | ||
17640 | finally { | ||
17641 | |||
17642 | restoreStackSize(stackSize); | ||
17643 | |||
17644 | } | ||
17645 | return ; | ||
17646 | } | ||
17647 | // $ANTLR end "rule__ALSPlus__Group_1__1" | ||
17648 | |||
17649 | |||
17650 | // $ANTLR start "rule__ALSPlus__Group_1__1__Impl" | ||
17651 | // InternalAlloyLanguage.g:6138:1: rule__ALSPlus__Group_1__1__Impl : ( '+' ) ; | ||
17652 | public final void rule__ALSPlus__Group_1__1__Impl() throws RecognitionException { | ||
17653 | |||
17654 | int stackSize = keepStackSize(); | ||
17655 | |||
17656 | try { | ||
17657 | // InternalAlloyLanguage.g:6142:1: ( ( '+' ) ) | ||
17658 | // InternalAlloyLanguage.g:6143:1: ( '+' ) | ||
17659 | { | ||
17660 | // InternalAlloyLanguage.g:6143:1: ( '+' ) | ||
17661 | // InternalAlloyLanguage.g:6144:1: '+' | ||
17662 | { | ||
17663 | if ( state.backtracking==0 ) { | ||
17664 | before(grammarAccess.getALSPlusAccess().getPlusSignKeyword_1_1()); | ||
17665 | } | ||
17666 | match(input,39,FOLLOW_2); if (state.failed) return ; | ||
17667 | if ( state.backtracking==0 ) { | ||
17668 | after(grammarAccess.getALSPlusAccess().getPlusSignKeyword_1_1()); | ||
17669 | } | ||
17670 | |||
17671 | } | ||
17672 | |||
17673 | |||
17674 | } | ||
17675 | |||
17676 | } | ||
17677 | catch (RecognitionException re) { | ||
17678 | reportError(re); | ||
17679 | recover(input,re); | ||
17680 | } | ||
17681 | finally { | ||
17682 | |||
17683 | restoreStackSize(stackSize); | ||
17684 | |||
17685 | } | ||
17686 | return ; | ||
17687 | } | ||
17688 | // $ANTLR end "rule__ALSPlus__Group_1__1__Impl" | ||
17689 | |||
17690 | |||
17691 | // $ANTLR start "rule__ALSPlus__Group_1__2" | ||
17692 | // InternalAlloyLanguage.g:6157:1: rule__ALSPlus__Group_1__2 : rule__ALSPlus__Group_1__2__Impl ; | ||
17693 | public final void rule__ALSPlus__Group_1__2() throws RecognitionException { | ||
17694 | |||
17695 | int stackSize = keepStackSize(); | ||
17696 | |||
17697 | try { | ||
17698 | // InternalAlloyLanguage.g:6161:1: ( rule__ALSPlus__Group_1__2__Impl ) | ||
17699 | // InternalAlloyLanguage.g:6162:2: rule__ALSPlus__Group_1__2__Impl | ||
17700 | { | ||
17701 | pushFollow(FOLLOW_2); | ||
17702 | rule__ALSPlus__Group_1__2__Impl(); | ||
17703 | |||
17704 | state._fsp--; | ||
17705 | if (state.failed) return ; | ||
17706 | |||
17707 | } | ||
17708 | |||
17709 | } | ||
17710 | catch (RecognitionException re) { | ||
17711 | reportError(re); | ||
17712 | recover(input,re); | ||
17713 | } | ||
17714 | finally { | ||
17715 | |||
17716 | restoreStackSize(stackSize); | ||
17717 | |||
17718 | } | ||
17719 | return ; | ||
17720 | } | ||
17721 | // $ANTLR end "rule__ALSPlus__Group_1__2" | ||
17722 | |||
17723 | |||
17724 | // $ANTLR start "rule__ALSPlus__Group_1__2__Impl" | ||
17725 | // InternalAlloyLanguage.g:6168:1: rule__ALSPlus__Group_1__2__Impl : ( ( rule__ALSPlus__RightOperandAssignment_1_2 ) ) ; | ||
17726 | public final void rule__ALSPlus__Group_1__2__Impl() throws RecognitionException { | ||
17727 | |||
17728 | int stackSize = keepStackSize(); | ||
17729 | |||
17730 | try { | ||
17731 | // InternalAlloyLanguage.g:6172:1: ( ( ( rule__ALSPlus__RightOperandAssignment_1_2 ) ) ) | ||
17732 | // InternalAlloyLanguage.g:6173:1: ( ( rule__ALSPlus__RightOperandAssignment_1_2 ) ) | ||
17733 | { | ||
17734 | // InternalAlloyLanguage.g:6173:1: ( ( rule__ALSPlus__RightOperandAssignment_1_2 ) ) | ||
17735 | // InternalAlloyLanguage.g:6174:1: ( rule__ALSPlus__RightOperandAssignment_1_2 ) | ||
17736 | { | ||
17737 | if ( state.backtracking==0 ) { | ||
17738 | before(grammarAccess.getALSPlusAccess().getRightOperandAssignment_1_2()); | ||
17739 | } | ||
17740 | // InternalAlloyLanguage.g:6175:1: ( rule__ALSPlus__RightOperandAssignment_1_2 ) | ||
17741 | // InternalAlloyLanguage.g:6175:2: rule__ALSPlus__RightOperandAssignment_1_2 | ||
17742 | { | ||
17743 | pushFollow(FOLLOW_2); | ||
17744 | rule__ALSPlus__RightOperandAssignment_1_2(); | ||
17745 | |||
17746 | state._fsp--; | ||
17747 | if (state.failed) return ; | ||
17748 | |||
17749 | } | ||
17750 | |||
17751 | if ( state.backtracking==0 ) { | ||
17752 | after(grammarAccess.getALSPlusAccess().getRightOperandAssignment_1_2()); | ||
17753 | } | ||
17754 | |||
17755 | } | ||
17756 | |||
17757 | |||
17758 | } | ||
17759 | |||
17760 | } | ||
17761 | catch (RecognitionException re) { | ||
17762 | reportError(re); | ||
17763 | recover(input,re); | ||
17764 | } | ||
17765 | finally { | ||
17766 | |||
17767 | restoreStackSize(stackSize); | ||
17768 | |||
17769 | } | ||
17770 | return ; | ||
17771 | } | ||
17772 | // $ANTLR end "rule__ALSPlus__Group_1__2__Impl" | ||
17773 | |||
17774 | |||
17775 | // $ANTLR start "rule__ALSIntersection__Group__0" | ||
17776 | // InternalAlloyLanguage.g:6191:1: rule__ALSIntersection__Group__0 : rule__ALSIntersection__Group__0__Impl rule__ALSIntersection__Group__1 ; | ||
17777 | public final void rule__ALSIntersection__Group__0() throws RecognitionException { | ||
17778 | |||
17779 | int stackSize = keepStackSize(); | ||
17780 | |||
17781 | try { | ||
17782 | // InternalAlloyLanguage.g:6195:1: ( rule__ALSIntersection__Group__0__Impl rule__ALSIntersection__Group__1 ) | ||
17783 | // InternalAlloyLanguage.g:6196:2: rule__ALSIntersection__Group__0__Impl rule__ALSIntersection__Group__1 | ||
17784 | { | ||
17785 | pushFollow(FOLLOW_44); | ||
17786 | rule__ALSIntersection__Group__0__Impl(); | ||
17787 | |||
17788 | state._fsp--; | ||
17789 | if (state.failed) return ; | ||
17790 | pushFollow(FOLLOW_2); | ||
17791 | rule__ALSIntersection__Group__1(); | ||
17792 | |||
17793 | state._fsp--; | ||
17794 | if (state.failed) return ; | ||
17795 | |||
17796 | } | ||
17797 | |||
17798 | } | ||
17799 | catch (RecognitionException re) { | ||
17800 | reportError(re); | ||
17801 | recover(input,re); | ||
17802 | } | ||
17803 | finally { | ||
17804 | |||
17805 | restoreStackSize(stackSize); | ||
17806 | |||
17807 | } | ||
17808 | return ; | ||
17809 | } | ||
17810 | // $ANTLR end "rule__ALSIntersection__Group__0" | ||
17811 | |||
17812 | |||
17813 | // $ANTLR start "rule__ALSIntersection__Group__0__Impl" | ||
17814 | // InternalAlloyLanguage.g:6203:1: rule__ALSIntersection__Group__0__Impl : ( ruleALSDirectProduct ) ; | ||
17815 | public final void rule__ALSIntersection__Group__0__Impl() throws RecognitionException { | ||
17816 | |||
17817 | int stackSize = keepStackSize(); | ||
17818 | |||
17819 | try { | ||
17820 | // InternalAlloyLanguage.g:6207:1: ( ( ruleALSDirectProduct ) ) | ||
17821 | // InternalAlloyLanguage.g:6208:1: ( ruleALSDirectProduct ) | ||
17822 | { | ||
17823 | // InternalAlloyLanguage.g:6208:1: ( ruleALSDirectProduct ) | ||
17824 | // InternalAlloyLanguage.g:6209:1: ruleALSDirectProduct | ||
17825 | { | ||
17826 | if ( state.backtracking==0 ) { | ||
17827 | before(grammarAccess.getALSIntersectionAccess().getALSDirectProductParserRuleCall_0()); | ||
17828 | } | ||
17829 | pushFollow(FOLLOW_2); | ||
17830 | ruleALSDirectProduct(); | ||
17831 | |||
17832 | state._fsp--; | ||
17833 | if (state.failed) return ; | ||
17834 | if ( state.backtracking==0 ) { | ||
17835 | after(grammarAccess.getALSIntersectionAccess().getALSDirectProductParserRuleCall_0()); | ||
17836 | } | ||
17837 | |||
17838 | } | ||
17839 | |||
17840 | |||
17841 | } | ||
17842 | |||
17843 | } | ||
17844 | catch (RecognitionException re) { | ||
17845 | reportError(re); | ||
17846 | recover(input,re); | ||
17847 | } | ||
17848 | finally { | ||
17849 | |||
17850 | restoreStackSize(stackSize); | ||
17851 | |||
17852 | } | ||
17853 | return ; | ||
17854 | } | ||
17855 | // $ANTLR end "rule__ALSIntersection__Group__0__Impl" | ||
17856 | |||
17857 | |||
17858 | // $ANTLR start "rule__ALSIntersection__Group__1" | ||
17859 | // InternalAlloyLanguage.g:6220:1: rule__ALSIntersection__Group__1 : rule__ALSIntersection__Group__1__Impl ; | ||
17860 | public final void rule__ALSIntersection__Group__1() throws RecognitionException { | ||
17861 | |||
17862 | int stackSize = keepStackSize(); | ||
17863 | |||
17864 | try { | ||
17865 | // InternalAlloyLanguage.g:6224:1: ( rule__ALSIntersection__Group__1__Impl ) | ||
17866 | // InternalAlloyLanguage.g:6225:2: rule__ALSIntersection__Group__1__Impl | ||
17867 | { | ||
17868 | pushFollow(FOLLOW_2); | ||
17869 | rule__ALSIntersection__Group__1__Impl(); | ||
17870 | |||
17871 | state._fsp--; | ||
17872 | if (state.failed) return ; | ||
17873 | |||
17874 | } | ||
17875 | |||
17876 | } | ||
17877 | catch (RecognitionException re) { | ||
17878 | reportError(re); | ||
17879 | recover(input,re); | ||
17880 | } | ||
17881 | finally { | ||
17882 | |||
17883 | restoreStackSize(stackSize); | ||
17884 | |||
17885 | } | ||
17886 | return ; | ||
17887 | } | ||
17888 | // $ANTLR end "rule__ALSIntersection__Group__1" | ||
17889 | |||
17890 | |||
17891 | // $ANTLR start "rule__ALSIntersection__Group__1__Impl" | ||
17892 | // InternalAlloyLanguage.g:6231:1: rule__ALSIntersection__Group__1__Impl : ( ( rule__ALSIntersection__Group_1__0 )* ) ; | ||
17893 | public final void rule__ALSIntersection__Group__1__Impl() throws RecognitionException { | ||
17894 | |||
17895 | int stackSize = keepStackSize(); | ||
17896 | |||
17897 | try { | ||
17898 | // InternalAlloyLanguage.g:6235:1: ( ( ( rule__ALSIntersection__Group_1__0 )* ) ) | ||
17899 | // InternalAlloyLanguage.g:6236:1: ( ( rule__ALSIntersection__Group_1__0 )* ) | ||
17900 | { | ||
17901 | // InternalAlloyLanguage.g:6236:1: ( ( rule__ALSIntersection__Group_1__0 )* ) | ||
17902 | // InternalAlloyLanguage.g:6237:1: ( rule__ALSIntersection__Group_1__0 )* | ||
17903 | { | ||
17904 | if ( state.backtracking==0 ) { | ||
17905 | before(grammarAccess.getALSIntersectionAccess().getGroup_1()); | ||
17906 | } | ||
17907 | // InternalAlloyLanguage.g:6238:1: ( rule__ALSIntersection__Group_1__0 )* | ||
17908 | loop42: | ||
17909 | do { | ||
17910 | int alt42=2; | ||
17911 | int LA42_0 = input.LA(1); | ||
17912 | |||
17913 | if ( (LA42_0==58) ) { | ||
17914 | alt42=1; | ||
17915 | } | ||
17916 | |||
17917 | |||
17918 | switch (alt42) { | ||
17919 | case 1 : | ||
17920 | // InternalAlloyLanguage.g:6238:2: rule__ALSIntersection__Group_1__0 | ||
17921 | { | ||
17922 | pushFollow(FOLLOW_45); | ||
17923 | rule__ALSIntersection__Group_1__0(); | ||
17924 | |||
17925 | state._fsp--; | ||
17926 | if (state.failed) return ; | ||
17927 | |||
17928 | } | ||
17929 | break; | ||
17930 | |||
17931 | default : | ||
17932 | break loop42; | ||
17933 | } | ||
17934 | } while (true); | ||
17935 | |||
17936 | if ( state.backtracking==0 ) { | ||
17937 | after(grammarAccess.getALSIntersectionAccess().getGroup_1()); | ||
17938 | } | ||
17939 | |||
17940 | } | ||
17941 | |||
17942 | |||
17943 | } | ||
17944 | |||
17945 | } | ||
17946 | catch (RecognitionException re) { | ||
17947 | reportError(re); | ||
17948 | recover(input,re); | ||
17949 | } | ||
17950 | finally { | ||
17951 | |||
17952 | restoreStackSize(stackSize); | ||
17953 | |||
17954 | } | ||
17955 | return ; | ||
17956 | } | ||
17957 | // $ANTLR end "rule__ALSIntersection__Group__1__Impl" | ||
17958 | |||
17959 | |||
17960 | // $ANTLR start "rule__ALSIntersection__Group_1__0" | ||
17961 | // InternalAlloyLanguage.g:6252:1: rule__ALSIntersection__Group_1__0 : rule__ALSIntersection__Group_1__0__Impl rule__ALSIntersection__Group_1__1 ; | ||
17962 | public final void rule__ALSIntersection__Group_1__0() throws RecognitionException { | ||
17963 | |||
17964 | int stackSize = keepStackSize(); | ||
17965 | |||
17966 | try { | ||
17967 | // InternalAlloyLanguage.g:6256:1: ( rule__ALSIntersection__Group_1__0__Impl rule__ALSIntersection__Group_1__1 ) | ||
17968 | // InternalAlloyLanguage.g:6257:2: rule__ALSIntersection__Group_1__0__Impl rule__ALSIntersection__Group_1__1 | ||
17969 | { | ||
17970 | pushFollow(FOLLOW_44); | ||
17971 | rule__ALSIntersection__Group_1__0__Impl(); | ||
17972 | |||
17973 | state._fsp--; | ||
17974 | if (state.failed) return ; | ||
17975 | pushFollow(FOLLOW_2); | ||
17976 | rule__ALSIntersection__Group_1__1(); | ||
17977 | |||
17978 | state._fsp--; | ||
17979 | if (state.failed) return ; | ||
17980 | |||
17981 | } | ||
17982 | |||
17983 | } | ||
17984 | catch (RecognitionException re) { | ||
17985 | reportError(re); | ||
17986 | recover(input,re); | ||
17987 | } | ||
17988 | finally { | ||
17989 | |||
17990 | restoreStackSize(stackSize); | ||
17991 | |||
17992 | } | ||
17993 | return ; | ||
17994 | } | ||
17995 | // $ANTLR end "rule__ALSIntersection__Group_1__0" | ||
17996 | |||
17997 | |||
17998 | // $ANTLR start "rule__ALSIntersection__Group_1__0__Impl" | ||
17999 | // InternalAlloyLanguage.g:6264:1: rule__ALSIntersection__Group_1__0__Impl : ( () ) ; | ||
18000 | public final void rule__ALSIntersection__Group_1__0__Impl() throws RecognitionException { | ||
18001 | |||
18002 | int stackSize = keepStackSize(); | ||
18003 | |||
18004 | try { | ||
18005 | // InternalAlloyLanguage.g:6268:1: ( ( () ) ) | ||
18006 | // InternalAlloyLanguage.g:6269:1: ( () ) | ||
18007 | { | ||
18008 | // InternalAlloyLanguage.g:6269:1: ( () ) | ||
18009 | // InternalAlloyLanguage.g:6270:1: () | ||
18010 | { | ||
18011 | if ( state.backtracking==0 ) { | ||
18012 | before(grammarAccess.getALSIntersectionAccess().getALSIntersectionLeftOperandAction_1_0()); | ||
18013 | } | ||
18014 | // InternalAlloyLanguage.g:6271:1: () | ||
18015 | // InternalAlloyLanguage.g:6273:1: | ||
18016 | { | ||
18017 | } | ||
18018 | |||
18019 | if ( state.backtracking==0 ) { | ||
18020 | after(grammarAccess.getALSIntersectionAccess().getALSIntersectionLeftOperandAction_1_0()); | ||
18021 | } | ||
18022 | |||
18023 | } | ||
18024 | |||
18025 | |||
18026 | } | ||
18027 | |||
18028 | } | ||
18029 | finally { | ||
18030 | |||
18031 | restoreStackSize(stackSize); | ||
18032 | |||
18033 | } | ||
18034 | return ; | ||
18035 | } | ||
18036 | // $ANTLR end "rule__ALSIntersection__Group_1__0__Impl" | ||
18037 | |||
18038 | |||
18039 | // $ANTLR start "rule__ALSIntersection__Group_1__1" | ||
18040 | // InternalAlloyLanguage.g:6283:1: rule__ALSIntersection__Group_1__1 : rule__ALSIntersection__Group_1__1__Impl rule__ALSIntersection__Group_1__2 ; | ||
18041 | public final void rule__ALSIntersection__Group_1__1() throws RecognitionException { | ||
18042 | |||
18043 | int stackSize = keepStackSize(); | ||
18044 | |||
18045 | try { | ||
18046 | // InternalAlloyLanguage.g:6287:1: ( rule__ALSIntersection__Group_1__1__Impl rule__ALSIntersection__Group_1__2 ) | ||
18047 | // InternalAlloyLanguage.g:6288:2: rule__ALSIntersection__Group_1__1__Impl rule__ALSIntersection__Group_1__2 | ||
18048 | { | ||
18049 | pushFollow(FOLLOW_16); | ||
18050 | rule__ALSIntersection__Group_1__1__Impl(); | ||
18051 | |||
18052 | state._fsp--; | ||
18053 | if (state.failed) return ; | ||
18054 | pushFollow(FOLLOW_2); | ||
18055 | rule__ALSIntersection__Group_1__2(); | ||
18056 | |||
18057 | state._fsp--; | ||
18058 | if (state.failed) return ; | ||
18059 | |||
18060 | } | ||
18061 | |||
18062 | } | ||
18063 | catch (RecognitionException re) { | ||
18064 | reportError(re); | ||
18065 | recover(input,re); | ||
18066 | } | ||
18067 | finally { | ||
18068 | |||
18069 | restoreStackSize(stackSize); | ||
18070 | |||
18071 | } | ||
18072 | return ; | ||
18073 | } | ||
18074 | // $ANTLR end "rule__ALSIntersection__Group_1__1" | ||
18075 | |||
18076 | |||
18077 | // $ANTLR start "rule__ALSIntersection__Group_1__1__Impl" | ||
18078 | // InternalAlloyLanguage.g:6295:1: rule__ALSIntersection__Group_1__1__Impl : ( '&' ) ; | ||
18079 | public final void rule__ALSIntersection__Group_1__1__Impl() throws RecognitionException { | ||
18080 | |||
18081 | int stackSize = keepStackSize(); | ||
18082 | |||
18083 | try { | ||
18084 | // InternalAlloyLanguage.g:6299:1: ( ( '&' ) ) | ||
18085 | // InternalAlloyLanguage.g:6300:1: ( '&' ) | ||
18086 | { | ||
18087 | // InternalAlloyLanguage.g:6300:1: ( '&' ) | ||
18088 | // InternalAlloyLanguage.g:6301:1: '&' | ||
18089 | { | ||
18090 | if ( state.backtracking==0 ) { | ||
18091 | before(grammarAccess.getALSIntersectionAccess().getAmpersandKeyword_1_1()); | ||
18092 | } | ||
18093 | match(input,58,FOLLOW_2); if (state.failed) return ; | ||
18094 | if ( state.backtracking==0 ) { | ||
18095 | after(grammarAccess.getALSIntersectionAccess().getAmpersandKeyword_1_1()); | ||
18096 | } | ||
18097 | |||
18098 | } | ||
18099 | |||
18100 | |||
18101 | } | ||
18102 | |||
18103 | } | ||
18104 | catch (RecognitionException re) { | ||
18105 | reportError(re); | ||
18106 | recover(input,re); | ||
18107 | } | ||
18108 | finally { | ||
18109 | |||
18110 | restoreStackSize(stackSize); | ||
18111 | |||
18112 | } | ||
18113 | return ; | ||
18114 | } | ||
18115 | // $ANTLR end "rule__ALSIntersection__Group_1__1__Impl" | ||
18116 | |||
18117 | |||
18118 | // $ANTLR start "rule__ALSIntersection__Group_1__2" | ||
18119 | // InternalAlloyLanguage.g:6314:1: rule__ALSIntersection__Group_1__2 : rule__ALSIntersection__Group_1__2__Impl ; | ||
18120 | public final void rule__ALSIntersection__Group_1__2() throws RecognitionException { | ||
18121 | |||
18122 | int stackSize = keepStackSize(); | ||
18123 | |||
18124 | try { | ||
18125 | // InternalAlloyLanguage.g:6318:1: ( rule__ALSIntersection__Group_1__2__Impl ) | ||
18126 | // InternalAlloyLanguage.g:6319:2: rule__ALSIntersection__Group_1__2__Impl | ||
18127 | { | ||
18128 | pushFollow(FOLLOW_2); | ||
18129 | rule__ALSIntersection__Group_1__2__Impl(); | ||
18130 | |||
18131 | state._fsp--; | ||
18132 | if (state.failed) return ; | ||
18133 | |||
18134 | } | ||
18135 | |||
18136 | } | ||
18137 | catch (RecognitionException re) { | ||
18138 | reportError(re); | ||
18139 | recover(input,re); | ||
18140 | } | ||
18141 | finally { | ||
18142 | |||
18143 | restoreStackSize(stackSize); | ||
18144 | |||
18145 | } | ||
18146 | return ; | ||
18147 | } | ||
18148 | // $ANTLR end "rule__ALSIntersection__Group_1__2" | ||
18149 | |||
18150 | |||
18151 | // $ANTLR start "rule__ALSIntersection__Group_1__2__Impl" | ||
18152 | // InternalAlloyLanguage.g:6325:1: rule__ALSIntersection__Group_1__2__Impl : ( ( rule__ALSIntersection__RightOperandAssignment_1_2 ) ) ; | ||
18153 | public final void rule__ALSIntersection__Group_1__2__Impl() throws RecognitionException { | ||
18154 | |||
18155 | int stackSize = keepStackSize(); | ||
18156 | |||
18157 | try { | ||
18158 | // InternalAlloyLanguage.g:6329:1: ( ( ( rule__ALSIntersection__RightOperandAssignment_1_2 ) ) ) | ||
18159 | // InternalAlloyLanguage.g:6330:1: ( ( rule__ALSIntersection__RightOperandAssignment_1_2 ) ) | ||
18160 | { | ||
18161 | // InternalAlloyLanguage.g:6330:1: ( ( rule__ALSIntersection__RightOperandAssignment_1_2 ) ) | ||
18162 | // InternalAlloyLanguage.g:6331:1: ( rule__ALSIntersection__RightOperandAssignment_1_2 ) | ||
18163 | { | ||
18164 | if ( state.backtracking==0 ) { | ||
18165 | before(grammarAccess.getALSIntersectionAccess().getRightOperandAssignment_1_2()); | ||
18166 | } | ||
18167 | // InternalAlloyLanguage.g:6332:1: ( rule__ALSIntersection__RightOperandAssignment_1_2 ) | ||
18168 | // InternalAlloyLanguage.g:6332:2: rule__ALSIntersection__RightOperandAssignment_1_2 | ||
18169 | { | ||
18170 | pushFollow(FOLLOW_2); | ||
18171 | rule__ALSIntersection__RightOperandAssignment_1_2(); | ||
18172 | |||
18173 | state._fsp--; | ||
18174 | if (state.failed) return ; | ||
18175 | |||
18176 | } | ||
18177 | |||
18178 | if ( state.backtracking==0 ) { | ||
18179 | after(grammarAccess.getALSIntersectionAccess().getRightOperandAssignment_1_2()); | ||
18180 | } | ||
18181 | |||
18182 | } | ||
18183 | |||
18184 | |||
18185 | } | ||
18186 | |||
18187 | } | ||
18188 | catch (RecognitionException re) { | ||
18189 | reportError(re); | ||
18190 | recover(input,re); | ||
18191 | } | ||
18192 | finally { | ||
18193 | |||
18194 | restoreStackSize(stackSize); | ||
18195 | |||
18196 | } | ||
18197 | return ; | ||
18198 | } | ||
18199 | // $ANTLR end "rule__ALSIntersection__Group_1__2__Impl" | ||
18200 | |||
18201 | |||
18202 | // $ANTLR start "rule__ALSDirectProduct__Group__0" | ||
18203 | // InternalAlloyLanguage.g:6348:1: rule__ALSDirectProduct__Group__0 : rule__ALSDirectProduct__Group__0__Impl rule__ALSDirectProduct__Group__1 ; | ||
18204 | public final void rule__ALSDirectProduct__Group__0() throws RecognitionException { | ||
18205 | |||
18206 | int stackSize = keepStackSize(); | ||
18207 | |||
18208 | try { | ||
18209 | // InternalAlloyLanguage.g:6352:1: ( rule__ALSDirectProduct__Group__0__Impl rule__ALSDirectProduct__Group__1 ) | ||
18210 | // InternalAlloyLanguage.g:6353:2: rule__ALSDirectProduct__Group__0__Impl rule__ALSDirectProduct__Group__1 | ||
18211 | { | ||
18212 | pushFollow(FOLLOW_46); | ||
18213 | rule__ALSDirectProduct__Group__0__Impl(); | ||
18214 | |||
18215 | state._fsp--; | ||
18216 | if (state.failed) return ; | ||
18217 | pushFollow(FOLLOW_2); | ||
18218 | rule__ALSDirectProduct__Group__1(); | ||
18219 | |||
18220 | state._fsp--; | ||
18221 | if (state.failed) return ; | ||
18222 | |||
18223 | } | ||
18224 | |||
18225 | } | ||
18226 | catch (RecognitionException re) { | ||
18227 | reportError(re); | ||
18228 | recover(input,re); | ||
18229 | } | ||
18230 | finally { | ||
18231 | |||
18232 | restoreStackSize(stackSize); | ||
18233 | |||
18234 | } | ||
18235 | return ; | ||
18236 | } | ||
18237 | // $ANTLR end "rule__ALSDirectProduct__Group__0" | ||
18238 | |||
18239 | |||
18240 | // $ANTLR start "rule__ALSDirectProduct__Group__0__Impl" | ||
18241 | // InternalAlloyLanguage.g:6360:1: rule__ALSDirectProduct__Group__0__Impl : ( ruleALSPreficed ) ; | ||
18242 | public final void rule__ALSDirectProduct__Group__0__Impl() throws RecognitionException { | ||
18243 | |||
18244 | int stackSize = keepStackSize(); | ||
18245 | |||
18246 | try { | ||
18247 | // InternalAlloyLanguage.g:6364:1: ( ( ruleALSPreficed ) ) | ||
18248 | // InternalAlloyLanguage.g:6365:1: ( ruleALSPreficed ) | ||
18249 | { | ||
18250 | // InternalAlloyLanguage.g:6365:1: ( ruleALSPreficed ) | ||
18251 | // InternalAlloyLanguage.g:6366:1: ruleALSPreficed | ||
18252 | { | ||
18253 | if ( state.backtracking==0 ) { | ||
18254 | before(grammarAccess.getALSDirectProductAccess().getALSPreficedParserRuleCall_0()); | ||
18255 | } | ||
18256 | pushFollow(FOLLOW_2); | ||
18257 | ruleALSPreficed(); | ||
18258 | |||
18259 | state._fsp--; | ||
18260 | if (state.failed) return ; | ||
18261 | if ( state.backtracking==0 ) { | ||
18262 | after(grammarAccess.getALSDirectProductAccess().getALSPreficedParserRuleCall_0()); | ||
18263 | } | ||
18264 | |||
18265 | } | ||
18266 | |||
18267 | |||
18268 | } | ||
18269 | |||
18270 | } | ||
18271 | catch (RecognitionException re) { | ||
18272 | reportError(re); | ||
18273 | recover(input,re); | ||
18274 | } | ||
18275 | finally { | ||
18276 | |||
18277 | restoreStackSize(stackSize); | ||
18278 | |||
18279 | } | ||
18280 | return ; | ||
18281 | } | ||
18282 | // $ANTLR end "rule__ALSDirectProduct__Group__0__Impl" | ||
18283 | |||
18284 | |||
18285 | // $ANTLR start "rule__ALSDirectProduct__Group__1" | ||
18286 | // InternalAlloyLanguage.g:6377:1: rule__ALSDirectProduct__Group__1 : rule__ALSDirectProduct__Group__1__Impl ; | ||
18287 | public final void rule__ALSDirectProduct__Group__1() throws RecognitionException { | ||
18288 | |||
18289 | int stackSize = keepStackSize(); | ||
18290 | |||
18291 | try { | ||
18292 | // InternalAlloyLanguage.g:6381:1: ( rule__ALSDirectProduct__Group__1__Impl ) | ||
18293 | // InternalAlloyLanguage.g:6382:2: rule__ALSDirectProduct__Group__1__Impl | ||
18294 | { | ||
18295 | pushFollow(FOLLOW_2); | ||
18296 | rule__ALSDirectProduct__Group__1__Impl(); | ||
18297 | |||
18298 | state._fsp--; | ||
18299 | if (state.failed) return ; | ||
18300 | |||
18301 | } | ||
18302 | |||
18303 | } | ||
18304 | catch (RecognitionException re) { | ||
18305 | reportError(re); | ||
18306 | recover(input,re); | ||
18307 | } | ||
18308 | finally { | ||
18309 | |||
18310 | restoreStackSize(stackSize); | ||
18311 | |||
18312 | } | ||
18313 | return ; | ||
18314 | } | ||
18315 | // $ANTLR end "rule__ALSDirectProduct__Group__1" | ||
18316 | |||
18317 | |||
18318 | // $ANTLR start "rule__ALSDirectProduct__Group__1__Impl" | ||
18319 | // InternalAlloyLanguage.g:6388:1: rule__ALSDirectProduct__Group__1__Impl : ( ( rule__ALSDirectProduct__Group_1__0 )? ) ; | ||
18320 | public final void rule__ALSDirectProduct__Group__1__Impl() throws RecognitionException { | ||
18321 | |||
18322 | int stackSize = keepStackSize(); | ||
18323 | |||
18324 | try { | ||
18325 | // InternalAlloyLanguage.g:6392:1: ( ( ( rule__ALSDirectProduct__Group_1__0 )? ) ) | ||
18326 | // InternalAlloyLanguage.g:6393:1: ( ( rule__ALSDirectProduct__Group_1__0 )? ) | ||
18327 | { | ||
18328 | // InternalAlloyLanguage.g:6393:1: ( ( rule__ALSDirectProduct__Group_1__0 )? ) | ||
18329 | // InternalAlloyLanguage.g:6394:1: ( rule__ALSDirectProduct__Group_1__0 )? | ||
18330 | { | ||
18331 | if ( state.backtracking==0 ) { | ||
18332 | before(grammarAccess.getALSDirectProductAccess().getGroup_1()); | ||
18333 | } | ||
18334 | // InternalAlloyLanguage.g:6395:1: ( rule__ALSDirectProduct__Group_1__0 )? | ||
18335 | int alt43=2; | ||
18336 | int LA43_0 = input.LA(1); | ||
18337 | |||
18338 | if ( ((LA43_0>=21 && LA43_0<=26)||LA43_0==59) ) { | ||
18339 | alt43=1; | ||
18340 | } | ||
18341 | switch (alt43) { | ||
18342 | case 1 : | ||
18343 | // InternalAlloyLanguage.g:6395:2: rule__ALSDirectProduct__Group_1__0 | ||
18344 | { | ||
18345 | pushFollow(FOLLOW_2); | ||
18346 | rule__ALSDirectProduct__Group_1__0(); | ||
18347 | |||
18348 | state._fsp--; | ||
18349 | if (state.failed) return ; | ||
18350 | |||
18351 | } | ||
18352 | break; | ||
18353 | |||
18354 | } | ||
18355 | |||
18356 | if ( state.backtracking==0 ) { | ||
18357 | after(grammarAccess.getALSDirectProductAccess().getGroup_1()); | ||
18358 | } | ||
18359 | |||
18360 | } | ||
18361 | |||
18362 | |||
18363 | } | ||
18364 | |||
18365 | } | ||
18366 | catch (RecognitionException re) { | ||
18367 | reportError(re); | ||
18368 | recover(input,re); | ||
18369 | } | ||
18370 | finally { | ||
18371 | |||
18372 | restoreStackSize(stackSize); | ||
18373 | |||
18374 | } | ||
18375 | return ; | ||
18376 | } | ||
18377 | // $ANTLR end "rule__ALSDirectProduct__Group__1__Impl" | ||
18378 | |||
18379 | |||
18380 | // $ANTLR start "rule__ALSDirectProduct__Group_1__0" | ||
18381 | // InternalAlloyLanguage.g:6409:1: rule__ALSDirectProduct__Group_1__0 : rule__ALSDirectProduct__Group_1__0__Impl rule__ALSDirectProduct__Group_1__1 ; | ||
18382 | public final void rule__ALSDirectProduct__Group_1__0() throws RecognitionException { | ||
18383 | |||
18384 | int stackSize = keepStackSize(); | ||
18385 | |||
18386 | try { | ||
18387 | // InternalAlloyLanguage.g:6413:1: ( rule__ALSDirectProduct__Group_1__0__Impl rule__ALSDirectProduct__Group_1__1 ) | ||
18388 | // InternalAlloyLanguage.g:6414:2: rule__ALSDirectProduct__Group_1__0__Impl rule__ALSDirectProduct__Group_1__1 | ||
18389 | { | ||
18390 | pushFollow(FOLLOW_46); | ||
18391 | rule__ALSDirectProduct__Group_1__0__Impl(); | ||
18392 | |||
18393 | state._fsp--; | ||
18394 | if (state.failed) return ; | ||
18395 | pushFollow(FOLLOW_2); | ||
18396 | rule__ALSDirectProduct__Group_1__1(); | ||
18397 | |||
18398 | state._fsp--; | ||
18399 | if (state.failed) return ; | ||
18400 | |||
18401 | } | ||
18402 | |||
18403 | } | ||
18404 | catch (RecognitionException re) { | ||
18405 | reportError(re); | ||
18406 | recover(input,re); | ||
18407 | } | ||
18408 | finally { | ||
18409 | |||
18410 | restoreStackSize(stackSize); | ||
18411 | |||
18412 | } | ||
18413 | return ; | ||
18414 | } | ||
18415 | // $ANTLR end "rule__ALSDirectProduct__Group_1__0" | ||
18416 | |||
18417 | |||
18418 | // $ANTLR start "rule__ALSDirectProduct__Group_1__0__Impl" | ||
18419 | // InternalAlloyLanguage.g:6421:1: rule__ALSDirectProduct__Group_1__0__Impl : ( () ) ; | ||
18420 | public final void rule__ALSDirectProduct__Group_1__0__Impl() throws RecognitionException { | ||
18421 | |||
18422 | int stackSize = keepStackSize(); | ||
18423 | |||
18424 | try { | ||
18425 | // InternalAlloyLanguage.g:6425:1: ( ( () ) ) | ||
18426 | // InternalAlloyLanguage.g:6426:1: ( () ) | ||
18427 | { | ||
18428 | // InternalAlloyLanguage.g:6426:1: ( () ) | ||
18429 | // InternalAlloyLanguage.g:6427:1: () | ||
18430 | { | ||
18431 | if ( state.backtracking==0 ) { | ||
18432 | before(grammarAccess.getALSDirectProductAccess().getALSDirectProductLeftOperandAction_1_0()); | ||
18433 | } | ||
18434 | // InternalAlloyLanguage.g:6428:1: () | ||
18435 | // InternalAlloyLanguage.g:6430:1: | ||
18436 | { | ||
18437 | } | ||
18438 | |||
18439 | if ( state.backtracking==0 ) { | ||
18440 | after(grammarAccess.getALSDirectProductAccess().getALSDirectProductLeftOperandAction_1_0()); | ||
18441 | } | ||
18442 | |||
18443 | } | ||
18444 | |||
18445 | |||
18446 | } | ||
18447 | |||
18448 | } | ||
18449 | finally { | ||
18450 | |||
18451 | restoreStackSize(stackSize); | ||
18452 | |||
18453 | } | ||
18454 | return ; | ||
18455 | } | ||
18456 | // $ANTLR end "rule__ALSDirectProduct__Group_1__0__Impl" | ||
18457 | |||
18458 | |||
18459 | // $ANTLR start "rule__ALSDirectProduct__Group_1__1" | ||
18460 | // InternalAlloyLanguage.g:6440:1: rule__ALSDirectProduct__Group_1__1 : rule__ALSDirectProduct__Group_1__1__Impl rule__ALSDirectProduct__Group_1__2 ; | ||
18461 | public final void rule__ALSDirectProduct__Group_1__1() throws RecognitionException { | ||
18462 | |||
18463 | int stackSize = keepStackSize(); | ||
18464 | |||
18465 | try { | ||
18466 | // InternalAlloyLanguage.g:6444:1: ( rule__ALSDirectProduct__Group_1__1__Impl rule__ALSDirectProduct__Group_1__2 ) | ||
18467 | // InternalAlloyLanguage.g:6445:2: rule__ALSDirectProduct__Group_1__1__Impl rule__ALSDirectProduct__Group_1__2 | ||
18468 | { | ||
18469 | pushFollow(FOLLOW_46); | ||
18470 | rule__ALSDirectProduct__Group_1__1__Impl(); | ||
18471 | |||
18472 | state._fsp--; | ||
18473 | if (state.failed) return ; | ||
18474 | pushFollow(FOLLOW_2); | ||
18475 | rule__ALSDirectProduct__Group_1__2(); | ||
18476 | |||
18477 | state._fsp--; | ||
18478 | if (state.failed) return ; | ||
18479 | |||
18480 | } | ||
18481 | |||
18482 | } | ||
18483 | catch (RecognitionException re) { | ||
18484 | reportError(re); | ||
18485 | recover(input,re); | ||
18486 | } | ||
18487 | finally { | ||
18488 | |||
18489 | restoreStackSize(stackSize); | ||
18490 | |||
18491 | } | ||
18492 | return ; | ||
18493 | } | ||
18494 | // $ANTLR end "rule__ALSDirectProduct__Group_1__1" | ||
18495 | |||
18496 | |||
18497 | // $ANTLR start "rule__ALSDirectProduct__Group_1__1__Impl" | ||
18498 | // InternalAlloyLanguage.g:6452:1: rule__ALSDirectProduct__Group_1__1__Impl : ( ( rule__ALSDirectProduct__LeftMultiplicitAssignment_1_1 )? ) ; | ||
18499 | public final void rule__ALSDirectProduct__Group_1__1__Impl() throws RecognitionException { | ||
18500 | |||
18501 | int stackSize = keepStackSize(); | ||
18502 | |||
18503 | try { | ||
18504 | // InternalAlloyLanguage.g:6456:1: ( ( ( rule__ALSDirectProduct__LeftMultiplicitAssignment_1_1 )? ) ) | ||
18505 | // InternalAlloyLanguage.g:6457:1: ( ( rule__ALSDirectProduct__LeftMultiplicitAssignment_1_1 )? ) | ||
18506 | { | ||
18507 | // InternalAlloyLanguage.g:6457:1: ( ( rule__ALSDirectProduct__LeftMultiplicitAssignment_1_1 )? ) | ||
18508 | // InternalAlloyLanguage.g:6458:1: ( rule__ALSDirectProduct__LeftMultiplicitAssignment_1_1 )? | ||
18509 | { | ||
18510 | if ( state.backtracking==0 ) { | ||
18511 | before(grammarAccess.getALSDirectProductAccess().getLeftMultiplicitAssignment_1_1()); | ||
18512 | } | ||
18513 | // InternalAlloyLanguage.g:6459:1: ( rule__ALSDirectProduct__LeftMultiplicitAssignment_1_1 )? | ||
18514 | int alt44=2; | ||
18515 | int LA44_0 = input.LA(1); | ||
18516 | |||
18517 | if ( ((LA44_0>=21 && LA44_0<=26)) ) { | ||
18518 | alt44=1; | ||
18519 | } | ||
18520 | switch (alt44) { | ||
18521 | case 1 : | ||
18522 | // InternalAlloyLanguage.g:6459:2: rule__ALSDirectProduct__LeftMultiplicitAssignment_1_1 | ||
18523 | { | ||
18524 | pushFollow(FOLLOW_2); | ||
18525 | rule__ALSDirectProduct__LeftMultiplicitAssignment_1_1(); | ||
18526 | |||
18527 | state._fsp--; | ||
18528 | if (state.failed) return ; | ||
18529 | |||
18530 | } | ||
18531 | break; | ||
18532 | |||
18533 | } | ||
18534 | |||
18535 | if ( state.backtracking==0 ) { | ||
18536 | after(grammarAccess.getALSDirectProductAccess().getLeftMultiplicitAssignment_1_1()); | ||
18537 | } | ||
18538 | |||
18539 | } | ||
18540 | |||
18541 | |||
18542 | } | ||
18543 | |||
18544 | } | ||
18545 | catch (RecognitionException re) { | ||
18546 | reportError(re); | ||
18547 | recover(input,re); | ||
18548 | } | ||
18549 | finally { | ||
18550 | |||
18551 | restoreStackSize(stackSize); | ||
18552 | |||
18553 | } | ||
18554 | return ; | ||
18555 | } | ||
18556 | // $ANTLR end "rule__ALSDirectProduct__Group_1__1__Impl" | ||
18557 | |||
18558 | |||
18559 | // $ANTLR start "rule__ALSDirectProduct__Group_1__2" | ||
18560 | // InternalAlloyLanguage.g:6469:1: rule__ALSDirectProduct__Group_1__2 : rule__ALSDirectProduct__Group_1__2__Impl rule__ALSDirectProduct__Group_1__3 ; | ||
18561 | public final void rule__ALSDirectProduct__Group_1__2() throws RecognitionException { | ||
18562 | |||
18563 | int stackSize = keepStackSize(); | ||
18564 | |||
18565 | try { | ||
18566 | // InternalAlloyLanguage.g:6473:1: ( rule__ALSDirectProduct__Group_1__2__Impl rule__ALSDirectProduct__Group_1__3 ) | ||
18567 | // InternalAlloyLanguage.g:6474:2: rule__ALSDirectProduct__Group_1__2__Impl rule__ALSDirectProduct__Group_1__3 | ||
18568 | { | ||
18569 | pushFollow(FOLLOW_16); | ||
18570 | rule__ALSDirectProduct__Group_1__2__Impl(); | ||
18571 | |||
18572 | state._fsp--; | ||
18573 | if (state.failed) return ; | ||
18574 | pushFollow(FOLLOW_2); | ||
18575 | rule__ALSDirectProduct__Group_1__3(); | ||
18576 | |||
18577 | state._fsp--; | ||
18578 | if (state.failed) return ; | ||
18579 | |||
18580 | } | ||
18581 | |||
18582 | } | ||
18583 | catch (RecognitionException re) { | ||
18584 | reportError(re); | ||
18585 | recover(input,re); | ||
18586 | } | ||
18587 | finally { | ||
18588 | |||
18589 | restoreStackSize(stackSize); | ||
18590 | |||
18591 | } | ||
18592 | return ; | ||
18593 | } | ||
18594 | // $ANTLR end "rule__ALSDirectProduct__Group_1__2" | ||
18595 | |||
18596 | |||
18597 | // $ANTLR start "rule__ALSDirectProduct__Group_1__2__Impl" | ||
18598 | // InternalAlloyLanguage.g:6481:1: rule__ALSDirectProduct__Group_1__2__Impl : ( '->' ) ; | ||
18599 | public final void rule__ALSDirectProduct__Group_1__2__Impl() throws RecognitionException { | ||
18600 | |||
18601 | int stackSize = keepStackSize(); | ||
18602 | |||
18603 | try { | ||
18604 | // InternalAlloyLanguage.g:6485:1: ( ( '->' ) ) | ||
18605 | // InternalAlloyLanguage.g:6486:1: ( '->' ) | ||
18606 | { | ||
18607 | // InternalAlloyLanguage.g:6486:1: ( '->' ) | ||
18608 | // InternalAlloyLanguage.g:6487:1: '->' | ||
18609 | { | ||
18610 | if ( state.backtracking==0 ) { | ||
18611 | before(grammarAccess.getALSDirectProductAccess().getHyphenMinusGreaterThanSignKeyword_1_2()); | ||
18612 | } | ||
18613 | match(input,59,FOLLOW_2); if (state.failed) return ; | ||
18614 | if ( state.backtracking==0 ) { | ||
18615 | after(grammarAccess.getALSDirectProductAccess().getHyphenMinusGreaterThanSignKeyword_1_2()); | ||
18616 | } | ||
18617 | |||
18618 | } | ||
18619 | |||
18620 | |||
18621 | } | ||
18622 | |||
18623 | } | ||
18624 | catch (RecognitionException re) { | ||
18625 | reportError(re); | ||
18626 | recover(input,re); | ||
18627 | } | ||
18628 | finally { | ||
18629 | |||
18630 | restoreStackSize(stackSize); | ||
18631 | |||
18632 | } | ||
18633 | return ; | ||
18634 | } | ||
18635 | // $ANTLR end "rule__ALSDirectProduct__Group_1__2__Impl" | ||
18636 | |||
18637 | |||
18638 | // $ANTLR start "rule__ALSDirectProduct__Group_1__3" | ||
18639 | // InternalAlloyLanguage.g:6500:1: rule__ALSDirectProduct__Group_1__3 : rule__ALSDirectProduct__Group_1__3__Impl rule__ALSDirectProduct__Group_1__4 ; | ||
18640 | public final void rule__ALSDirectProduct__Group_1__3() throws RecognitionException { | ||
18641 | |||
18642 | int stackSize = keepStackSize(); | ||
18643 | |||
18644 | try { | ||
18645 | // InternalAlloyLanguage.g:6504:1: ( rule__ALSDirectProduct__Group_1__3__Impl rule__ALSDirectProduct__Group_1__4 ) | ||
18646 | // InternalAlloyLanguage.g:6505:2: rule__ALSDirectProduct__Group_1__3__Impl rule__ALSDirectProduct__Group_1__4 | ||
18647 | { | ||
18648 | pushFollow(FOLLOW_16); | ||
18649 | rule__ALSDirectProduct__Group_1__3__Impl(); | ||
18650 | |||
18651 | state._fsp--; | ||
18652 | if (state.failed) return ; | ||
18653 | pushFollow(FOLLOW_2); | ||
18654 | rule__ALSDirectProduct__Group_1__4(); | ||
18655 | |||
18656 | state._fsp--; | ||
18657 | if (state.failed) return ; | ||
18658 | |||
18659 | } | ||
18660 | |||
18661 | } | ||
18662 | catch (RecognitionException re) { | ||
18663 | reportError(re); | ||
18664 | recover(input,re); | ||
18665 | } | ||
18666 | finally { | ||
18667 | |||
18668 | restoreStackSize(stackSize); | ||
18669 | |||
18670 | } | ||
18671 | return ; | ||
18672 | } | ||
18673 | // $ANTLR end "rule__ALSDirectProduct__Group_1__3" | ||
18674 | |||
18675 | |||
18676 | // $ANTLR start "rule__ALSDirectProduct__Group_1__3__Impl" | ||
18677 | // InternalAlloyLanguage.g:6512:1: rule__ALSDirectProduct__Group_1__3__Impl : ( ( rule__ALSDirectProduct__RightMultiplicitAssignment_1_3 )? ) ; | ||
18678 | public final void rule__ALSDirectProduct__Group_1__3__Impl() throws RecognitionException { | ||
18679 | |||
18680 | int stackSize = keepStackSize(); | ||
18681 | |||
18682 | try { | ||
18683 | // InternalAlloyLanguage.g:6516:1: ( ( ( rule__ALSDirectProduct__RightMultiplicitAssignment_1_3 )? ) ) | ||
18684 | // InternalAlloyLanguage.g:6517:1: ( ( rule__ALSDirectProduct__RightMultiplicitAssignment_1_3 )? ) | ||
18685 | { | ||
18686 | // InternalAlloyLanguage.g:6517:1: ( ( rule__ALSDirectProduct__RightMultiplicitAssignment_1_3 )? ) | ||
18687 | // InternalAlloyLanguage.g:6518:1: ( rule__ALSDirectProduct__RightMultiplicitAssignment_1_3 )? | ||
18688 | { | ||
18689 | if ( state.backtracking==0 ) { | ||
18690 | before(grammarAccess.getALSDirectProductAccess().getRightMultiplicitAssignment_1_3()); | ||
18691 | } | ||
18692 | // InternalAlloyLanguage.g:6519:1: ( rule__ALSDirectProduct__RightMultiplicitAssignment_1_3 )? | ||
18693 | int alt45=2; | ||
18694 | int LA45_0 = input.LA(1); | ||
18695 | |||
18696 | if ( ((LA45_0>=21 && LA45_0<=26)) ) { | ||
18697 | alt45=1; | ||
18698 | } | ||
18699 | switch (alt45) { | ||
18700 | case 1 : | ||
18701 | // InternalAlloyLanguage.g:6519:2: rule__ALSDirectProduct__RightMultiplicitAssignment_1_3 | ||
18702 | { | ||
18703 | pushFollow(FOLLOW_2); | ||
18704 | rule__ALSDirectProduct__RightMultiplicitAssignment_1_3(); | ||
18705 | |||
18706 | state._fsp--; | ||
18707 | if (state.failed) return ; | ||
18708 | |||
18709 | } | ||
18710 | break; | ||
18711 | |||
18712 | } | ||
18713 | |||
18714 | if ( state.backtracking==0 ) { | ||
18715 | after(grammarAccess.getALSDirectProductAccess().getRightMultiplicitAssignment_1_3()); | ||
18716 | } | ||
18717 | |||
18718 | } | ||
18719 | |||
18720 | |||
18721 | } | ||
18722 | |||
18723 | } | ||
18724 | catch (RecognitionException re) { | ||
18725 | reportError(re); | ||
18726 | recover(input,re); | ||
18727 | } | ||
18728 | finally { | ||
18729 | |||
18730 | restoreStackSize(stackSize); | ||
18731 | |||
18732 | } | ||
18733 | return ; | ||
18734 | } | ||
18735 | // $ANTLR end "rule__ALSDirectProduct__Group_1__3__Impl" | ||
18736 | |||
18737 | |||
18738 | // $ANTLR start "rule__ALSDirectProduct__Group_1__4" | ||
18739 | // InternalAlloyLanguage.g:6529:1: rule__ALSDirectProduct__Group_1__4 : rule__ALSDirectProduct__Group_1__4__Impl ; | ||
18740 | public final void rule__ALSDirectProduct__Group_1__4() throws RecognitionException { | ||
18741 | |||
18742 | int stackSize = keepStackSize(); | ||
18743 | |||
18744 | try { | ||
18745 | // InternalAlloyLanguage.g:6533:1: ( rule__ALSDirectProduct__Group_1__4__Impl ) | ||
18746 | // InternalAlloyLanguage.g:6534:2: rule__ALSDirectProduct__Group_1__4__Impl | ||
18747 | { | ||
18748 | pushFollow(FOLLOW_2); | ||
18749 | rule__ALSDirectProduct__Group_1__4__Impl(); | ||
18750 | |||
18751 | state._fsp--; | ||
18752 | if (state.failed) return ; | ||
18753 | |||
18754 | } | ||
18755 | |||
18756 | } | ||
18757 | catch (RecognitionException re) { | ||
18758 | reportError(re); | ||
18759 | recover(input,re); | ||
18760 | } | ||
18761 | finally { | ||
18762 | |||
18763 | restoreStackSize(stackSize); | ||
18764 | |||
18765 | } | ||
18766 | return ; | ||
18767 | } | ||
18768 | // $ANTLR end "rule__ALSDirectProduct__Group_1__4" | ||
18769 | |||
18770 | |||
18771 | // $ANTLR start "rule__ALSDirectProduct__Group_1__4__Impl" | ||
18772 | // InternalAlloyLanguage.g:6540:1: rule__ALSDirectProduct__Group_1__4__Impl : ( ( rule__ALSDirectProduct__RightOperandAssignment_1_4 ) ) ; | ||
18773 | public final void rule__ALSDirectProduct__Group_1__4__Impl() throws RecognitionException { | ||
18774 | |||
18775 | int stackSize = keepStackSize(); | ||
18776 | |||
18777 | try { | ||
18778 | // InternalAlloyLanguage.g:6544:1: ( ( ( rule__ALSDirectProduct__RightOperandAssignment_1_4 ) ) ) | ||
18779 | // InternalAlloyLanguage.g:6545:1: ( ( rule__ALSDirectProduct__RightOperandAssignment_1_4 ) ) | ||
18780 | { | ||
18781 | // InternalAlloyLanguage.g:6545:1: ( ( rule__ALSDirectProduct__RightOperandAssignment_1_4 ) ) | ||
18782 | // InternalAlloyLanguage.g:6546:1: ( rule__ALSDirectProduct__RightOperandAssignment_1_4 ) | ||
18783 | { | ||
18784 | if ( state.backtracking==0 ) { | ||
18785 | before(grammarAccess.getALSDirectProductAccess().getRightOperandAssignment_1_4()); | ||
18786 | } | ||
18787 | // InternalAlloyLanguage.g:6547:1: ( rule__ALSDirectProduct__RightOperandAssignment_1_4 ) | ||
18788 | // InternalAlloyLanguage.g:6547:2: rule__ALSDirectProduct__RightOperandAssignment_1_4 | ||
18789 | { | ||
18790 | pushFollow(FOLLOW_2); | ||
18791 | rule__ALSDirectProduct__RightOperandAssignment_1_4(); | ||
18792 | |||
18793 | state._fsp--; | ||
18794 | if (state.failed) return ; | ||
18795 | |||
18796 | } | ||
18797 | |||
18798 | if ( state.backtracking==0 ) { | ||
18799 | after(grammarAccess.getALSDirectProductAccess().getRightOperandAssignment_1_4()); | ||
18800 | } | ||
18801 | |||
18802 | } | ||
18803 | |||
18804 | |||
18805 | } | ||
18806 | |||
18807 | } | ||
18808 | catch (RecognitionException re) { | ||
18809 | reportError(re); | ||
18810 | recover(input,re); | ||
18811 | } | ||
18812 | finally { | ||
18813 | |||
18814 | restoreStackSize(stackSize); | ||
18815 | |||
18816 | } | ||
18817 | return ; | ||
18818 | } | ||
18819 | // $ANTLR end "rule__ALSDirectProduct__Group_1__4__Impl" | ||
18820 | |||
18821 | |||
18822 | // $ANTLR start "rule__ALSPreficed__Group_0__0" | ||
18823 | // InternalAlloyLanguage.g:6567:1: rule__ALSPreficed__Group_0__0 : rule__ALSPreficed__Group_0__0__Impl rule__ALSPreficed__Group_0__1 ; | ||
18824 | public final void rule__ALSPreficed__Group_0__0() throws RecognitionException { | ||
18825 | |||
18826 | int stackSize = keepStackSize(); | ||
18827 | |||
18828 | try { | ||
18829 | // InternalAlloyLanguage.g:6571:1: ( rule__ALSPreficed__Group_0__0__Impl rule__ALSPreficed__Group_0__1 ) | ||
18830 | // InternalAlloyLanguage.g:6572:2: rule__ALSPreficed__Group_0__0__Impl rule__ALSPreficed__Group_0__1 | ||
18831 | { | ||
18832 | pushFollow(FOLLOW_47); | ||
18833 | rule__ALSPreficed__Group_0__0__Impl(); | ||
18834 | |||
18835 | state._fsp--; | ||
18836 | if (state.failed) return ; | ||
18837 | pushFollow(FOLLOW_2); | ||
18838 | rule__ALSPreficed__Group_0__1(); | ||
18839 | |||
18840 | state._fsp--; | ||
18841 | if (state.failed) return ; | ||
18842 | |||
18843 | } | ||
18844 | |||
18845 | } | ||
18846 | catch (RecognitionException re) { | ||
18847 | reportError(re); | ||
18848 | recover(input,re); | ||
18849 | } | ||
18850 | finally { | ||
18851 | |||
18852 | restoreStackSize(stackSize); | ||
18853 | |||
18854 | } | ||
18855 | return ; | ||
18856 | } | ||
18857 | // $ANTLR end "rule__ALSPreficed__Group_0__0" | ||
18858 | |||
18859 | |||
18860 | // $ANTLR start "rule__ALSPreficed__Group_0__0__Impl" | ||
18861 | // InternalAlloyLanguage.g:6579:1: rule__ALSPreficed__Group_0__0__Impl : ( () ) ; | ||
18862 | public final void rule__ALSPreficed__Group_0__0__Impl() throws RecognitionException { | ||
18863 | |||
18864 | int stackSize = keepStackSize(); | ||
18865 | |||
18866 | try { | ||
18867 | // InternalAlloyLanguage.g:6583:1: ( ( () ) ) | ||
18868 | // InternalAlloyLanguage.g:6584:1: ( () ) | ||
18869 | { | ||
18870 | // InternalAlloyLanguage.g:6584:1: ( () ) | ||
18871 | // InternalAlloyLanguage.g:6585:1: () | ||
18872 | { | ||
18873 | if ( state.backtracking==0 ) { | ||
18874 | before(grammarAccess.getALSPreficedAccess().getALSNotAction_0_0()); | ||
18875 | } | ||
18876 | // InternalAlloyLanguage.g:6586:1: () | ||
18877 | // InternalAlloyLanguage.g:6588:1: | ||
18878 | { | ||
18879 | } | ||
18880 | |||
18881 | if ( state.backtracking==0 ) { | ||
18882 | after(grammarAccess.getALSPreficedAccess().getALSNotAction_0_0()); | ||
18883 | } | ||
18884 | |||
18885 | } | ||
18886 | |||
18887 | |||
18888 | } | ||
18889 | |||
18890 | } | ||
18891 | finally { | ||
18892 | |||
18893 | restoreStackSize(stackSize); | ||
18894 | |||
18895 | } | ||
18896 | return ; | ||
18897 | } | ||
18898 | // $ANTLR end "rule__ALSPreficed__Group_0__0__Impl" | ||
18899 | |||
18900 | |||
18901 | // $ANTLR start "rule__ALSPreficed__Group_0__1" | ||
18902 | // InternalAlloyLanguage.g:6598:1: rule__ALSPreficed__Group_0__1 : rule__ALSPreficed__Group_0__1__Impl rule__ALSPreficed__Group_0__2 ; | ||
18903 | public final void rule__ALSPreficed__Group_0__1() throws RecognitionException { | ||
18904 | |||
18905 | int stackSize = keepStackSize(); | ||
18906 | |||
18907 | try { | ||
18908 | // InternalAlloyLanguage.g:6602:1: ( rule__ALSPreficed__Group_0__1__Impl rule__ALSPreficed__Group_0__2 ) | ||
18909 | // InternalAlloyLanguage.g:6603:2: rule__ALSPreficed__Group_0__1__Impl rule__ALSPreficed__Group_0__2 | ||
18910 | { | ||
18911 | pushFollow(FOLLOW_16); | ||
18912 | rule__ALSPreficed__Group_0__1__Impl(); | ||
18913 | |||
18914 | state._fsp--; | ||
18915 | if (state.failed) return ; | ||
18916 | pushFollow(FOLLOW_2); | ||
18917 | rule__ALSPreficed__Group_0__2(); | ||
18918 | |||
18919 | state._fsp--; | ||
18920 | if (state.failed) return ; | ||
18921 | |||
18922 | } | ||
18923 | |||
18924 | } | ||
18925 | catch (RecognitionException re) { | ||
18926 | reportError(re); | ||
18927 | recover(input,re); | ||
18928 | } | ||
18929 | finally { | ||
18930 | |||
18931 | restoreStackSize(stackSize); | ||
18932 | |||
18933 | } | ||
18934 | return ; | ||
18935 | } | ||
18936 | // $ANTLR end "rule__ALSPreficed__Group_0__1" | ||
18937 | |||
18938 | |||
18939 | // $ANTLR start "rule__ALSPreficed__Group_0__1__Impl" | ||
18940 | // InternalAlloyLanguage.g:6610:1: rule__ALSPreficed__Group_0__1__Impl : ( ( rule__ALSPreficed__Group_0_1__0 ) ) ; | ||
18941 | public final void rule__ALSPreficed__Group_0__1__Impl() throws RecognitionException { | ||
18942 | |||
18943 | int stackSize = keepStackSize(); | ||
18944 | |||
18945 | try { | ||
18946 | // InternalAlloyLanguage.g:6614:1: ( ( ( rule__ALSPreficed__Group_0_1__0 ) ) ) | ||
18947 | // InternalAlloyLanguage.g:6615:1: ( ( rule__ALSPreficed__Group_0_1__0 ) ) | ||
18948 | { | ||
18949 | // InternalAlloyLanguage.g:6615:1: ( ( rule__ALSPreficed__Group_0_1__0 ) ) | ||
18950 | // InternalAlloyLanguage.g:6616:1: ( rule__ALSPreficed__Group_0_1__0 ) | ||
18951 | { | ||
18952 | if ( state.backtracking==0 ) { | ||
18953 | before(grammarAccess.getALSPreficedAccess().getGroup_0_1()); | ||
18954 | } | ||
18955 | // InternalAlloyLanguage.g:6617:1: ( rule__ALSPreficed__Group_0_1__0 ) | ||
18956 | // InternalAlloyLanguage.g:6617:2: rule__ALSPreficed__Group_0_1__0 | ||
18957 | { | ||
18958 | pushFollow(FOLLOW_2); | ||
18959 | rule__ALSPreficed__Group_0_1__0(); | ||
18960 | |||
18961 | state._fsp--; | ||
18962 | if (state.failed) return ; | ||
18963 | |||
18964 | } | ||
18965 | |||
18966 | if ( state.backtracking==0 ) { | ||
18967 | after(grammarAccess.getALSPreficedAccess().getGroup_0_1()); | ||
18968 | } | ||
18969 | |||
18970 | } | ||
18971 | |||
18972 | |||
18973 | } | ||
18974 | |||
18975 | } | ||
18976 | catch (RecognitionException re) { | ||
18977 | reportError(re); | ||
18978 | recover(input,re); | ||
18979 | } | ||
18980 | finally { | ||
18981 | |||
18982 | restoreStackSize(stackSize); | ||
18983 | |||
18984 | } | ||
18985 | return ; | ||
18986 | } | ||
18987 | // $ANTLR end "rule__ALSPreficed__Group_0__1__Impl" | ||
18988 | |||
18989 | |||
18990 | // $ANTLR start "rule__ALSPreficed__Group_0__2" | ||
18991 | // InternalAlloyLanguage.g:6627:1: rule__ALSPreficed__Group_0__2 : rule__ALSPreficed__Group_0__2__Impl ; | ||
18992 | public final void rule__ALSPreficed__Group_0__2() throws RecognitionException { | ||
18993 | |||
18994 | int stackSize = keepStackSize(); | ||
18995 | |||
18996 | try { | ||
18997 | // InternalAlloyLanguage.g:6631:1: ( rule__ALSPreficed__Group_0__2__Impl ) | ||
18998 | // InternalAlloyLanguage.g:6632:2: rule__ALSPreficed__Group_0__2__Impl | ||
18999 | { | ||
19000 | pushFollow(FOLLOW_2); | ||
19001 | rule__ALSPreficed__Group_0__2__Impl(); | ||
19002 | |||
19003 | state._fsp--; | ||
19004 | if (state.failed) return ; | ||
19005 | |||
19006 | } | ||
19007 | |||
19008 | } | ||
19009 | catch (RecognitionException re) { | ||
19010 | reportError(re); | ||
19011 | recover(input,re); | ||
19012 | } | ||
19013 | finally { | ||
19014 | |||
19015 | restoreStackSize(stackSize); | ||
19016 | |||
19017 | } | ||
19018 | return ; | ||
19019 | } | ||
19020 | // $ANTLR end "rule__ALSPreficed__Group_0__2" | ||
19021 | |||
19022 | |||
19023 | // $ANTLR start "rule__ALSPreficed__Group_0__2__Impl" | ||
19024 | // InternalAlloyLanguage.g:6638:1: rule__ALSPreficed__Group_0__2__Impl : ( ( rule__ALSPreficed__OperandAssignment_0_2 ) ) ; | ||
19025 | public final void rule__ALSPreficed__Group_0__2__Impl() throws RecognitionException { | ||
19026 | |||
19027 | int stackSize = keepStackSize(); | ||
19028 | |||
19029 | try { | ||
19030 | // InternalAlloyLanguage.g:6642:1: ( ( ( rule__ALSPreficed__OperandAssignment_0_2 ) ) ) | ||
19031 | // InternalAlloyLanguage.g:6643:1: ( ( rule__ALSPreficed__OperandAssignment_0_2 ) ) | ||
19032 | { | ||
19033 | // InternalAlloyLanguage.g:6643:1: ( ( rule__ALSPreficed__OperandAssignment_0_2 ) ) | ||
19034 | // InternalAlloyLanguage.g:6644:1: ( rule__ALSPreficed__OperandAssignment_0_2 ) | ||
19035 | { | ||
19036 | if ( state.backtracking==0 ) { | ||
19037 | before(grammarAccess.getALSPreficedAccess().getOperandAssignment_0_2()); | ||
19038 | } | ||
19039 | // InternalAlloyLanguage.g:6645:1: ( rule__ALSPreficed__OperandAssignment_0_2 ) | ||
19040 | // InternalAlloyLanguage.g:6645:2: rule__ALSPreficed__OperandAssignment_0_2 | ||
19041 | { | ||
19042 | pushFollow(FOLLOW_2); | ||
19043 | rule__ALSPreficed__OperandAssignment_0_2(); | ||
19044 | |||
19045 | state._fsp--; | ||
19046 | if (state.failed) return ; | ||
19047 | |||
19048 | } | ||
19049 | |||
19050 | if ( state.backtracking==0 ) { | ||
19051 | after(grammarAccess.getALSPreficedAccess().getOperandAssignment_0_2()); | ||
19052 | } | ||
19053 | |||
19054 | } | ||
19055 | |||
19056 | |||
19057 | } | ||
19058 | |||
19059 | } | ||
19060 | catch (RecognitionException re) { | ||
19061 | reportError(re); | ||
19062 | recover(input,re); | ||
19063 | } | ||
19064 | finally { | ||
19065 | |||
19066 | restoreStackSize(stackSize); | ||
19067 | |||
19068 | } | ||
19069 | return ; | ||
19070 | } | ||
19071 | // $ANTLR end "rule__ALSPreficed__Group_0__2__Impl" | ||
19072 | |||
19073 | |||
19074 | // $ANTLR start "rule__ALSPreficed__Group_0_1__0" | ||
19075 | // InternalAlloyLanguage.g:6661:1: rule__ALSPreficed__Group_0_1__0 : rule__ALSPreficed__Group_0_1__0__Impl ; | ||
19076 | public final void rule__ALSPreficed__Group_0_1__0() throws RecognitionException { | ||
19077 | |||
19078 | int stackSize = keepStackSize(); | ||
19079 | |||
19080 | try { | ||
19081 | // InternalAlloyLanguage.g:6665:1: ( rule__ALSPreficed__Group_0_1__0__Impl ) | ||
19082 | // InternalAlloyLanguage.g:6666:2: rule__ALSPreficed__Group_0_1__0__Impl | ||
19083 | { | ||
19084 | pushFollow(FOLLOW_2); | ||
19085 | rule__ALSPreficed__Group_0_1__0__Impl(); | ||
19086 | |||
19087 | state._fsp--; | ||
19088 | if (state.failed) return ; | ||
19089 | |||
19090 | } | ||
19091 | |||
19092 | } | ||
19093 | catch (RecognitionException re) { | ||
19094 | reportError(re); | ||
19095 | recover(input,re); | ||
19096 | } | ||
19097 | finally { | ||
19098 | |||
19099 | restoreStackSize(stackSize); | ||
19100 | |||
19101 | } | ||
19102 | return ; | ||
19103 | } | ||
19104 | // $ANTLR end "rule__ALSPreficed__Group_0_1__0" | ||
19105 | |||
19106 | |||
19107 | // $ANTLR start "rule__ALSPreficed__Group_0_1__0__Impl" | ||
19108 | // InternalAlloyLanguage.g:6672:1: rule__ALSPreficed__Group_0_1__0__Impl : ( ( rule__ALSPreficed__Alternatives_0_1_0 ) ) ; | ||
19109 | public final void rule__ALSPreficed__Group_0_1__0__Impl() throws RecognitionException { | ||
19110 | |||
19111 | int stackSize = keepStackSize(); | ||
19112 | |||
19113 | try { | ||
19114 | // InternalAlloyLanguage.g:6676:1: ( ( ( rule__ALSPreficed__Alternatives_0_1_0 ) ) ) | ||
19115 | // InternalAlloyLanguage.g:6677:1: ( ( rule__ALSPreficed__Alternatives_0_1_0 ) ) | ||
19116 | { | ||
19117 | // InternalAlloyLanguage.g:6677:1: ( ( rule__ALSPreficed__Alternatives_0_1_0 ) ) | ||
19118 | // InternalAlloyLanguage.g:6678:1: ( rule__ALSPreficed__Alternatives_0_1_0 ) | ||
19119 | { | ||
19120 | if ( state.backtracking==0 ) { | ||
19121 | before(grammarAccess.getALSPreficedAccess().getAlternatives_0_1_0()); | ||
19122 | } | ||
19123 | // InternalAlloyLanguage.g:6679:1: ( rule__ALSPreficed__Alternatives_0_1_0 ) | ||
19124 | // InternalAlloyLanguage.g:6679:2: rule__ALSPreficed__Alternatives_0_1_0 | ||
19125 | { | ||
19126 | pushFollow(FOLLOW_2); | ||
19127 | rule__ALSPreficed__Alternatives_0_1_0(); | ||
19128 | |||
19129 | state._fsp--; | ||
19130 | if (state.failed) return ; | ||
19131 | |||
19132 | } | ||
19133 | |||
19134 | if ( state.backtracking==0 ) { | ||
19135 | after(grammarAccess.getALSPreficedAccess().getAlternatives_0_1_0()); | ||
19136 | } | ||
19137 | |||
19138 | } | ||
19139 | |||
19140 | |||
19141 | } | ||
19142 | |||
19143 | } | ||
19144 | catch (RecognitionException re) { | ||
19145 | reportError(re); | ||
19146 | recover(input,re); | ||
19147 | } | ||
19148 | finally { | ||
19149 | |||
19150 | restoreStackSize(stackSize); | ||
19151 | |||
19152 | } | ||
19153 | return ; | ||
19154 | } | ||
19155 | // $ANTLR end "rule__ALSPreficed__Group_0_1__0__Impl" | ||
19156 | |||
19157 | |||
19158 | // $ANTLR start "rule__ALSPreficed__Group_1__0" | ||
19159 | // InternalAlloyLanguage.g:6691:1: rule__ALSPreficed__Group_1__0 : rule__ALSPreficed__Group_1__0__Impl rule__ALSPreficed__Group_1__1 ; | ||
19160 | public final void rule__ALSPreficed__Group_1__0() throws RecognitionException { | ||
19161 | |||
19162 | int stackSize = keepStackSize(); | ||
19163 | |||
19164 | try { | ||
19165 | // InternalAlloyLanguage.g:6695:1: ( rule__ALSPreficed__Group_1__0__Impl rule__ALSPreficed__Group_1__1 ) | ||
19166 | // InternalAlloyLanguage.g:6696:2: rule__ALSPreficed__Group_1__0__Impl rule__ALSPreficed__Group_1__1 | ||
19167 | { | ||
19168 | pushFollow(FOLLOW_48); | ||
19169 | rule__ALSPreficed__Group_1__0__Impl(); | ||
19170 | |||
19171 | state._fsp--; | ||
19172 | if (state.failed) return ; | ||
19173 | pushFollow(FOLLOW_2); | ||
19174 | rule__ALSPreficed__Group_1__1(); | ||
19175 | |||
19176 | state._fsp--; | ||
19177 | if (state.failed) return ; | ||
19178 | |||
19179 | } | ||
19180 | |||
19181 | } | ||
19182 | catch (RecognitionException re) { | ||
19183 | reportError(re); | ||
19184 | recover(input,re); | ||
19185 | } | ||
19186 | finally { | ||
19187 | |||
19188 | restoreStackSize(stackSize); | ||
19189 | |||
19190 | } | ||
19191 | return ; | ||
19192 | } | ||
19193 | // $ANTLR end "rule__ALSPreficed__Group_1__0" | ||
19194 | |||
19195 | |||
19196 | // $ANTLR start "rule__ALSPreficed__Group_1__0__Impl" | ||
19197 | // InternalAlloyLanguage.g:6703:1: rule__ALSPreficed__Group_1__0__Impl : ( () ) ; | ||
19198 | public final void rule__ALSPreficed__Group_1__0__Impl() throws RecognitionException { | ||
19199 | |||
19200 | int stackSize = keepStackSize(); | ||
19201 | |||
19202 | try { | ||
19203 | // InternalAlloyLanguage.g:6707:1: ( ( () ) ) | ||
19204 | // InternalAlloyLanguage.g:6708:1: ( () ) | ||
19205 | { | ||
19206 | // InternalAlloyLanguage.g:6708:1: ( () ) | ||
19207 | // InternalAlloyLanguage.g:6709:1: () | ||
19208 | { | ||
19209 | if ( state.backtracking==0 ) { | ||
19210 | before(grammarAccess.getALSPreficedAccess().getALSInverseRelationAction_1_0()); | ||
19211 | } | ||
19212 | // InternalAlloyLanguage.g:6710:1: () | ||
19213 | // InternalAlloyLanguage.g:6712:1: | ||
19214 | { | ||
19215 | } | ||
19216 | |||
19217 | if ( state.backtracking==0 ) { | ||
19218 | after(grammarAccess.getALSPreficedAccess().getALSInverseRelationAction_1_0()); | ||
19219 | } | ||
19220 | |||
19221 | } | ||
19222 | |||
19223 | |||
19224 | } | ||
19225 | |||
19226 | } | ||
19227 | finally { | ||
19228 | |||
19229 | restoreStackSize(stackSize); | ||
19230 | |||
19231 | } | ||
19232 | return ; | ||
19233 | } | ||
19234 | // $ANTLR end "rule__ALSPreficed__Group_1__0__Impl" | ||
19235 | |||
19236 | |||
19237 | // $ANTLR start "rule__ALSPreficed__Group_1__1" | ||
19238 | // InternalAlloyLanguage.g:6722:1: rule__ALSPreficed__Group_1__1 : rule__ALSPreficed__Group_1__1__Impl rule__ALSPreficed__Group_1__2 ; | ||
19239 | public final void rule__ALSPreficed__Group_1__1() throws RecognitionException { | ||
19240 | |||
19241 | int stackSize = keepStackSize(); | ||
19242 | |||
19243 | try { | ||
19244 | // InternalAlloyLanguage.g:6726:1: ( rule__ALSPreficed__Group_1__1__Impl rule__ALSPreficed__Group_1__2 ) | ||
19245 | // InternalAlloyLanguage.g:6727:2: rule__ALSPreficed__Group_1__1__Impl rule__ALSPreficed__Group_1__2 | ||
19246 | { | ||
19247 | pushFollow(FOLLOW_16); | ||
19248 | rule__ALSPreficed__Group_1__1__Impl(); | ||
19249 | |||
19250 | state._fsp--; | ||
19251 | if (state.failed) return ; | ||
19252 | pushFollow(FOLLOW_2); | ||
19253 | rule__ALSPreficed__Group_1__2(); | ||
19254 | |||
19255 | state._fsp--; | ||
19256 | if (state.failed) return ; | ||
19257 | |||
19258 | } | ||
19259 | |||
19260 | } | ||
19261 | catch (RecognitionException re) { | ||
19262 | reportError(re); | ||
19263 | recover(input,re); | ||
19264 | } | ||
19265 | finally { | ||
19266 | |||
19267 | restoreStackSize(stackSize); | ||
19268 | |||
19269 | } | ||
19270 | return ; | ||
19271 | } | ||
19272 | // $ANTLR end "rule__ALSPreficed__Group_1__1" | ||
19273 | |||
19274 | |||
19275 | // $ANTLR start "rule__ALSPreficed__Group_1__1__Impl" | ||
19276 | // InternalAlloyLanguage.g:6734:1: rule__ALSPreficed__Group_1__1__Impl : ( ( '~' ) ) ; | ||
19277 | public final void rule__ALSPreficed__Group_1__1__Impl() throws RecognitionException { | ||
19278 | |||
19279 | int stackSize = keepStackSize(); | ||
19280 | |||
19281 | try { | ||
19282 | // InternalAlloyLanguage.g:6738:1: ( ( ( '~' ) ) ) | ||
19283 | // InternalAlloyLanguage.g:6739:1: ( ( '~' ) ) | ||
19284 | { | ||
19285 | // InternalAlloyLanguage.g:6739:1: ( ( '~' ) ) | ||
19286 | // InternalAlloyLanguage.g:6740:1: ( '~' ) | ||
19287 | { | ||
19288 | if ( state.backtracking==0 ) { | ||
19289 | before(grammarAccess.getALSPreficedAccess().getTildeKeyword_1_1()); | ||
19290 | } | ||
19291 | // InternalAlloyLanguage.g:6741:1: ( '~' ) | ||
19292 | // InternalAlloyLanguage.g:6742:2: '~' | ||
19293 | { | ||
19294 | match(input,60,FOLLOW_2); if (state.failed) return ; | ||
19295 | |||
19296 | } | ||
19297 | |||
19298 | if ( state.backtracking==0 ) { | ||
19299 | after(grammarAccess.getALSPreficedAccess().getTildeKeyword_1_1()); | ||
19300 | } | ||
19301 | |||
19302 | } | ||
19303 | |||
19304 | |||
19305 | } | ||
19306 | |||
19307 | } | ||
19308 | catch (RecognitionException re) { | ||
19309 | reportError(re); | ||
19310 | recover(input,re); | ||
19311 | } | ||
19312 | finally { | ||
19313 | |||
19314 | restoreStackSize(stackSize); | ||
19315 | |||
19316 | } | ||
19317 | return ; | ||
19318 | } | ||
19319 | // $ANTLR end "rule__ALSPreficed__Group_1__1__Impl" | ||
19320 | |||
19321 | |||
19322 | // $ANTLR start "rule__ALSPreficed__Group_1__2" | ||
19323 | // InternalAlloyLanguage.g:6753:1: rule__ALSPreficed__Group_1__2 : rule__ALSPreficed__Group_1__2__Impl ; | ||
19324 | public final void rule__ALSPreficed__Group_1__2() throws RecognitionException { | ||
19325 | |||
19326 | int stackSize = keepStackSize(); | ||
19327 | |||
19328 | try { | ||
19329 | // InternalAlloyLanguage.g:6757:1: ( rule__ALSPreficed__Group_1__2__Impl ) | ||
19330 | // InternalAlloyLanguage.g:6758:2: rule__ALSPreficed__Group_1__2__Impl | ||
19331 | { | ||
19332 | pushFollow(FOLLOW_2); | ||
19333 | rule__ALSPreficed__Group_1__2__Impl(); | ||
19334 | |||
19335 | state._fsp--; | ||
19336 | if (state.failed) return ; | ||
19337 | |||
19338 | } | ||
19339 | |||
19340 | } | ||
19341 | catch (RecognitionException re) { | ||
19342 | reportError(re); | ||
19343 | recover(input,re); | ||
19344 | } | ||
19345 | finally { | ||
19346 | |||
19347 | restoreStackSize(stackSize); | ||
19348 | |||
19349 | } | ||
19350 | return ; | ||
19351 | } | ||
19352 | // $ANTLR end "rule__ALSPreficed__Group_1__2" | ||
19353 | |||
19354 | |||
19355 | // $ANTLR start "rule__ALSPreficed__Group_1__2__Impl" | ||
19356 | // InternalAlloyLanguage.g:6764:1: rule__ALSPreficed__Group_1__2__Impl : ( ( rule__ALSPreficed__OperandAssignment_1_2 ) ) ; | ||
19357 | public final void rule__ALSPreficed__Group_1__2__Impl() throws RecognitionException { | ||
19358 | |||
19359 | int stackSize = keepStackSize(); | ||
19360 | |||
19361 | try { | ||
19362 | // InternalAlloyLanguage.g:6768:1: ( ( ( rule__ALSPreficed__OperandAssignment_1_2 ) ) ) | ||
19363 | // InternalAlloyLanguage.g:6769:1: ( ( rule__ALSPreficed__OperandAssignment_1_2 ) ) | ||
19364 | { | ||
19365 | // InternalAlloyLanguage.g:6769:1: ( ( rule__ALSPreficed__OperandAssignment_1_2 ) ) | ||
19366 | // InternalAlloyLanguage.g:6770:1: ( rule__ALSPreficed__OperandAssignment_1_2 ) | ||
19367 | { | ||
19368 | if ( state.backtracking==0 ) { | ||
19369 | before(grammarAccess.getALSPreficedAccess().getOperandAssignment_1_2()); | ||
19370 | } | ||
19371 | // InternalAlloyLanguage.g:6771:1: ( rule__ALSPreficed__OperandAssignment_1_2 ) | ||
19372 | // InternalAlloyLanguage.g:6771:2: rule__ALSPreficed__OperandAssignment_1_2 | ||
19373 | { | ||
19374 | pushFollow(FOLLOW_2); | ||
19375 | rule__ALSPreficed__OperandAssignment_1_2(); | ||
19376 | |||
19377 | state._fsp--; | ||
19378 | if (state.failed) return ; | ||
19379 | |||
19380 | } | ||
19381 | |||
19382 | if ( state.backtracking==0 ) { | ||
19383 | after(grammarAccess.getALSPreficedAccess().getOperandAssignment_1_2()); | ||
19384 | } | ||
19385 | |||
19386 | } | ||
19387 | |||
19388 | |||
19389 | } | ||
19390 | |||
19391 | } | ||
19392 | catch (RecognitionException re) { | ||
19393 | reportError(re); | ||
19394 | recover(input,re); | ||
19395 | } | ||
19396 | finally { | ||
19397 | |||
19398 | restoreStackSize(stackSize); | ||
19399 | |||
19400 | } | ||
19401 | return ; | ||
19402 | } | ||
19403 | // $ANTLR end "rule__ALSPreficed__Group_1__2__Impl" | ||
19404 | |||
19405 | |||
19406 | // $ANTLR start "rule__ALSPreficed__Group_2__0" | ||
19407 | // InternalAlloyLanguage.g:6787:1: rule__ALSPreficed__Group_2__0 : rule__ALSPreficed__Group_2__0__Impl rule__ALSPreficed__Group_2__1 ; | ||
19408 | public final void rule__ALSPreficed__Group_2__0() throws RecognitionException { | ||
19409 | |||
19410 | int stackSize = keepStackSize(); | ||
19411 | |||
19412 | try { | ||
19413 | // InternalAlloyLanguage.g:6791:1: ( rule__ALSPreficed__Group_2__0__Impl rule__ALSPreficed__Group_2__1 ) | ||
19414 | // InternalAlloyLanguage.g:6792:2: rule__ALSPreficed__Group_2__0__Impl rule__ALSPreficed__Group_2__1 | ||
19415 | { | ||
19416 | pushFollow(FOLLOW_49); | ||
19417 | rule__ALSPreficed__Group_2__0__Impl(); | ||
19418 | |||
19419 | state._fsp--; | ||
19420 | if (state.failed) return ; | ||
19421 | pushFollow(FOLLOW_2); | ||
19422 | rule__ALSPreficed__Group_2__1(); | ||
19423 | |||
19424 | state._fsp--; | ||
19425 | if (state.failed) return ; | ||
19426 | |||
19427 | } | ||
19428 | |||
19429 | } | ||
19430 | catch (RecognitionException re) { | ||
19431 | reportError(re); | ||
19432 | recover(input,re); | ||
19433 | } | ||
19434 | finally { | ||
19435 | |||
19436 | restoreStackSize(stackSize); | ||
19437 | |||
19438 | } | ||
19439 | return ; | ||
19440 | } | ||
19441 | // $ANTLR end "rule__ALSPreficed__Group_2__0" | ||
19442 | |||
19443 | |||
19444 | // $ANTLR start "rule__ALSPreficed__Group_2__0__Impl" | ||
19445 | // InternalAlloyLanguage.g:6799:1: rule__ALSPreficed__Group_2__0__Impl : ( () ) ; | ||
19446 | public final void rule__ALSPreficed__Group_2__0__Impl() throws RecognitionException { | ||
19447 | |||
19448 | int stackSize = keepStackSize(); | ||
19449 | |||
19450 | try { | ||
19451 | // InternalAlloyLanguage.g:6803:1: ( ( () ) ) | ||
19452 | // InternalAlloyLanguage.g:6804:1: ( () ) | ||
19453 | { | ||
19454 | // InternalAlloyLanguage.g:6804:1: ( () ) | ||
19455 | // InternalAlloyLanguage.g:6805:1: () | ||
19456 | { | ||
19457 | if ( state.backtracking==0 ) { | ||
19458 | before(grammarAccess.getALSPreficedAccess().getAlSTransitiveClosureAction_2_0()); | ||
19459 | } | ||
19460 | // InternalAlloyLanguage.g:6806:1: () | ||
19461 | // InternalAlloyLanguage.g:6808:1: | ||
19462 | { | ||
19463 | } | ||
19464 | |||
19465 | if ( state.backtracking==0 ) { | ||
19466 | after(grammarAccess.getALSPreficedAccess().getAlSTransitiveClosureAction_2_0()); | ||
19467 | } | ||
19468 | |||
19469 | } | ||
19470 | |||
19471 | |||
19472 | } | ||
19473 | |||
19474 | } | ||
19475 | finally { | ||
19476 | |||
19477 | restoreStackSize(stackSize); | ||
19478 | |||
19479 | } | ||
19480 | return ; | ||
19481 | } | ||
19482 | // $ANTLR end "rule__ALSPreficed__Group_2__0__Impl" | ||
19483 | |||
19484 | |||
19485 | // $ANTLR start "rule__ALSPreficed__Group_2__1" | ||
19486 | // InternalAlloyLanguage.g:6818:1: rule__ALSPreficed__Group_2__1 : rule__ALSPreficed__Group_2__1__Impl rule__ALSPreficed__Group_2__2 ; | ||
19487 | public final void rule__ALSPreficed__Group_2__1() throws RecognitionException { | ||
19488 | |||
19489 | int stackSize = keepStackSize(); | ||
19490 | |||
19491 | try { | ||
19492 | // InternalAlloyLanguage.g:6822:1: ( rule__ALSPreficed__Group_2__1__Impl rule__ALSPreficed__Group_2__2 ) | ||
19493 | // InternalAlloyLanguage.g:6823:2: rule__ALSPreficed__Group_2__1__Impl rule__ALSPreficed__Group_2__2 | ||
19494 | { | ||
19495 | pushFollow(FOLLOW_16); | ||
19496 | rule__ALSPreficed__Group_2__1__Impl(); | ||
19497 | |||
19498 | state._fsp--; | ||
19499 | if (state.failed) return ; | ||
19500 | pushFollow(FOLLOW_2); | ||
19501 | rule__ALSPreficed__Group_2__2(); | ||
19502 | |||
19503 | state._fsp--; | ||
19504 | if (state.failed) return ; | ||
19505 | |||
19506 | } | ||
19507 | |||
19508 | } | ||
19509 | catch (RecognitionException re) { | ||
19510 | reportError(re); | ||
19511 | recover(input,re); | ||
19512 | } | ||
19513 | finally { | ||
19514 | |||
19515 | restoreStackSize(stackSize); | ||
19516 | |||
19517 | } | ||
19518 | return ; | ||
19519 | } | ||
19520 | // $ANTLR end "rule__ALSPreficed__Group_2__1" | ||
19521 | |||
19522 | |||
19523 | // $ANTLR start "rule__ALSPreficed__Group_2__1__Impl" | ||
19524 | // InternalAlloyLanguage.g:6830:1: rule__ALSPreficed__Group_2__1__Impl : ( '^' ) ; | ||
19525 | public final void rule__ALSPreficed__Group_2__1__Impl() throws RecognitionException { | ||
19526 | |||
19527 | int stackSize = keepStackSize(); | ||
19528 | |||
19529 | try { | ||
19530 | // InternalAlloyLanguage.g:6834:1: ( ( '^' ) ) | ||
19531 | // InternalAlloyLanguage.g:6835:1: ( '^' ) | ||
19532 | { | ||
19533 | // InternalAlloyLanguage.g:6835:1: ( '^' ) | ||
19534 | // InternalAlloyLanguage.g:6836:1: '^' | ||
19535 | { | ||
19536 | if ( state.backtracking==0 ) { | ||
19537 | before(grammarAccess.getALSPreficedAccess().getCircumflexAccentKeyword_2_1()); | ||
19538 | } | ||
19539 | match(input,61,FOLLOW_2); if (state.failed) return ; | ||
19540 | if ( state.backtracking==0 ) { | ||
19541 | after(grammarAccess.getALSPreficedAccess().getCircumflexAccentKeyword_2_1()); | ||
19542 | } | ||
19543 | |||
19544 | } | ||
19545 | |||
19546 | |||
19547 | } | ||
19548 | |||
19549 | } | ||
19550 | catch (RecognitionException re) { | ||
19551 | reportError(re); | ||
19552 | recover(input,re); | ||
19553 | } | ||
19554 | finally { | ||
19555 | |||
19556 | restoreStackSize(stackSize); | ||
19557 | |||
19558 | } | ||
19559 | return ; | ||
19560 | } | ||
19561 | // $ANTLR end "rule__ALSPreficed__Group_2__1__Impl" | ||
19562 | |||
19563 | |||
19564 | // $ANTLR start "rule__ALSPreficed__Group_2__2" | ||
19565 | // InternalAlloyLanguage.g:6849:1: rule__ALSPreficed__Group_2__2 : rule__ALSPreficed__Group_2__2__Impl ; | ||
19566 | public final void rule__ALSPreficed__Group_2__2() throws RecognitionException { | ||
19567 | |||
19568 | int stackSize = keepStackSize(); | ||
19569 | |||
19570 | try { | ||
19571 | // InternalAlloyLanguage.g:6853:1: ( rule__ALSPreficed__Group_2__2__Impl ) | ||
19572 | // InternalAlloyLanguage.g:6854:2: rule__ALSPreficed__Group_2__2__Impl | ||
19573 | { | ||
19574 | pushFollow(FOLLOW_2); | ||
19575 | rule__ALSPreficed__Group_2__2__Impl(); | ||
19576 | |||
19577 | state._fsp--; | ||
19578 | if (state.failed) return ; | ||
19579 | |||
19580 | } | ||
19581 | |||
19582 | } | ||
19583 | catch (RecognitionException re) { | ||
19584 | reportError(re); | ||
19585 | recover(input,re); | ||
19586 | } | ||
19587 | finally { | ||
19588 | |||
19589 | restoreStackSize(stackSize); | ||
19590 | |||
19591 | } | ||
19592 | return ; | ||
19593 | } | ||
19594 | // $ANTLR end "rule__ALSPreficed__Group_2__2" | ||
19595 | |||
19596 | |||
19597 | // $ANTLR start "rule__ALSPreficed__Group_2__2__Impl" | ||
19598 | // InternalAlloyLanguage.g:6860:1: rule__ALSPreficed__Group_2__2__Impl : ( ( rule__ALSPreficed__OperandAssignment_2_2 ) ) ; | ||
19599 | public final void rule__ALSPreficed__Group_2__2__Impl() throws RecognitionException { | ||
19600 | |||
19601 | int stackSize = keepStackSize(); | ||
19602 | |||
19603 | try { | ||
19604 | // InternalAlloyLanguage.g:6864:1: ( ( ( rule__ALSPreficed__OperandAssignment_2_2 ) ) ) | ||
19605 | // InternalAlloyLanguage.g:6865:1: ( ( rule__ALSPreficed__OperandAssignment_2_2 ) ) | ||
19606 | { | ||
19607 | // InternalAlloyLanguage.g:6865:1: ( ( rule__ALSPreficed__OperandAssignment_2_2 ) ) | ||
19608 | // InternalAlloyLanguage.g:6866:1: ( rule__ALSPreficed__OperandAssignment_2_2 ) | ||
19609 | { | ||
19610 | if ( state.backtracking==0 ) { | ||
19611 | before(grammarAccess.getALSPreficedAccess().getOperandAssignment_2_2()); | ||
19612 | } | ||
19613 | // InternalAlloyLanguage.g:6867:1: ( rule__ALSPreficed__OperandAssignment_2_2 ) | ||
19614 | // InternalAlloyLanguage.g:6867:2: rule__ALSPreficed__OperandAssignment_2_2 | ||
19615 | { | ||
19616 | pushFollow(FOLLOW_2); | ||
19617 | rule__ALSPreficed__OperandAssignment_2_2(); | ||
19618 | |||
19619 | state._fsp--; | ||
19620 | if (state.failed) return ; | ||
19621 | |||
19622 | } | ||
19623 | |||
19624 | if ( state.backtracking==0 ) { | ||
19625 | after(grammarAccess.getALSPreficedAccess().getOperandAssignment_2_2()); | ||
19626 | } | ||
19627 | |||
19628 | } | ||
19629 | |||
19630 | |||
19631 | } | ||
19632 | |||
19633 | } | ||
19634 | catch (RecognitionException re) { | ||
19635 | reportError(re); | ||
19636 | recover(input,re); | ||
19637 | } | ||
19638 | finally { | ||
19639 | |||
19640 | restoreStackSize(stackSize); | ||
19641 | |||
19642 | } | ||
19643 | return ; | ||
19644 | } | ||
19645 | // $ANTLR end "rule__ALSPreficed__Group_2__2__Impl" | ||
19646 | |||
19647 | |||
19648 | // $ANTLR start "rule__ALSPreficed__Group_3__0" | ||
19649 | // InternalAlloyLanguage.g:6883:1: rule__ALSPreficed__Group_3__0 : rule__ALSPreficed__Group_3__0__Impl rule__ALSPreficed__Group_3__1 ; | ||
19650 | public final void rule__ALSPreficed__Group_3__0() throws RecognitionException { | ||
19651 | |||
19652 | int stackSize = keepStackSize(); | ||
19653 | |||
19654 | try { | ||
19655 | // InternalAlloyLanguage.g:6887:1: ( rule__ALSPreficed__Group_3__0__Impl rule__ALSPreficed__Group_3__1 ) | ||
19656 | // InternalAlloyLanguage.g:6888:2: rule__ALSPreficed__Group_3__0__Impl rule__ALSPreficed__Group_3__1 | ||
19657 | { | ||
19658 | pushFollow(FOLLOW_50); | ||
19659 | rule__ALSPreficed__Group_3__0__Impl(); | ||
19660 | |||
19661 | state._fsp--; | ||
19662 | if (state.failed) return ; | ||
19663 | pushFollow(FOLLOW_2); | ||
19664 | rule__ALSPreficed__Group_3__1(); | ||
19665 | |||
19666 | state._fsp--; | ||
19667 | if (state.failed) return ; | ||
19668 | |||
19669 | } | ||
19670 | |||
19671 | } | ||
19672 | catch (RecognitionException re) { | ||
19673 | reportError(re); | ||
19674 | recover(input,re); | ||
19675 | } | ||
19676 | finally { | ||
19677 | |||
19678 | restoreStackSize(stackSize); | ||
19679 | |||
19680 | } | ||
19681 | return ; | ||
19682 | } | ||
19683 | // $ANTLR end "rule__ALSPreficed__Group_3__0" | ||
19684 | |||
19685 | |||
19686 | // $ANTLR start "rule__ALSPreficed__Group_3__0__Impl" | ||
19687 | // InternalAlloyLanguage.g:6895:1: rule__ALSPreficed__Group_3__0__Impl : ( () ) ; | ||
19688 | public final void rule__ALSPreficed__Group_3__0__Impl() throws RecognitionException { | ||
19689 | |||
19690 | int stackSize = keepStackSize(); | ||
19691 | |||
19692 | try { | ||
19693 | // InternalAlloyLanguage.g:6899:1: ( ( () ) ) | ||
19694 | // InternalAlloyLanguage.g:6900:1: ( () ) | ||
19695 | { | ||
19696 | // InternalAlloyLanguage.g:6900:1: ( () ) | ||
19697 | // InternalAlloyLanguage.g:6901:1: () | ||
19698 | { | ||
19699 | if ( state.backtracking==0 ) { | ||
19700 | before(grammarAccess.getALSPreficedAccess().getALSReflectiveTransitiveClosureAction_3_0()); | ||
19701 | } | ||
19702 | // InternalAlloyLanguage.g:6902:1: () | ||
19703 | // InternalAlloyLanguage.g:6904:1: | ||
19704 | { | ||
19705 | } | ||
19706 | |||
19707 | if ( state.backtracking==0 ) { | ||
19708 | after(grammarAccess.getALSPreficedAccess().getALSReflectiveTransitiveClosureAction_3_0()); | ||
19709 | } | ||
19710 | |||
19711 | } | ||
19712 | |||
19713 | |||
19714 | } | ||
19715 | |||
19716 | } | ||
19717 | finally { | ||
19718 | |||
19719 | restoreStackSize(stackSize); | ||
19720 | |||
19721 | } | ||
19722 | return ; | ||
19723 | } | ||
19724 | // $ANTLR end "rule__ALSPreficed__Group_3__0__Impl" | ||
19725 | |||
19726 | |||
19727 | // $ANTLR start "rule__ALSPreficed__Group_3__1" | ||
19728 | // InternalAlloyLanguage.g:6914:1: rule__ALSPreficed__Group_3__1 : rule__ALSPreficed__Group_3__1__Impl rule__ALSPreficed__Group_3__2 ; | ||
19729 | public final void rule__ALSPreficed__Group_3__1() throws RecognitionException { | ||
19730 | |||
19731 | int stackSize = keepStackSize(); | ||
19732 | |||
19733 | try { | ||
19734 | // InternalAlloyLanguage.g:6918:1: ( rule__ALSPreficed__Group_3__1__Impl rule__ALSPreficed__Group_3__2 ) | ||
19735 | // InternalAlloyLanguage.g:6919:2: rule__ALSPreficed__Group_3__1__Impl rule__ALSPreficed__Group_3__2 | ||
19736 | { | ||
19737 | pushFollow(FOLLOW_16); | ||
19738 | rule__ALSPreficed__Group_3__1__Impl(); | ||
19739 | |||
19740 | state._fsp--; | ||
19741 | if (state.failed) return ; | ||
19742 | pushFollow(FOLLOW_2); | ||
19743 | rule__ALSPreficed__Group_3__2(); | ||
19744 | |||
19745 | state._fsp--; | ||
19746 | if (state.failed) return ; | ||
19747 | |||
19748 | } | ||
19749 | |||
19750 | } | ||
19751 | catch (RecognitionException re) { | ||
19752 | reportError(re); | ||
19753 | recover(input,re); | ||
19754 | } | ||
19755 | finally { | ||
19756 | |||
19757 | restoreStackSize(stackSize); | ||
19758 | |||
19759 | } | ||
19760 | return ; | ||
19761 | } | ||
19762 | // $ANTLR end "rule__ALSPreficed__Group_3__1" | ||
19763 | |||
19764 | |||
19765 | // $ANTLR start "rule__ALSPreficed__Group_3__1__Impl" | ||
19766 | // InternalAlloyLanguage.g:6926:1: rule__ALSPreficed__Group_3__1__Impl : ( '*' ) ; | ||
19767 | public final void rule__ALSPreficed__Group_3__1__Impl() throws RecognitionException { | ||
19768 | |||
19769 | int stackSize = keepStackSize(); | ||
19770 | |||
19771 | try { | ||
19772 | // InternalAlloyLanguage.g:6930:1: ( ( '*' ) ) | ||
19773 | // InternalAlloyLanguage.g:6931:1: ( '*' ) | ||
19774 | { | ||
19775 | // InternalAlloyLanguage.g:6931:1: ( '*' ) | ||
19776 | // InternalAlloyLanguage.g:6932:1: '*' | ||
19777 | { | ||
19778 | if ( state.backtracking==0 ) { | ||
19779 | before(grammarAccess.getALSPreficedAccess().getAsteriskKeyword_3_1()); | ||
19780 | } | ||
19781 | match(input,62,FOLLOW_2); if (state.failed) return ; | ||
19782 | if ( state.backtracking==0 ) { | ||
19783 | after(grammarAccess.getALSPreficedAccess().getAsteriskKeyword_3_1()); | ||
19784 | } | ||
19785 | |||
19786 | } | ||
19787 | |||
19788 | |||
19789 | } | ||
19790 | |||
19791 | } | ||
19792 | catch (RecognitionException re) { | ||
19793 | reportError(re); | ||
19794 | recover(input,re); | ||
19795 | } | ||
19796 | finally { | ||
19797 | |||
19798 | restoreStackSize(stackSize); | ||
19799 | |||
19800 | } | ||
19801 | return ; | ||
19802 | } | ||
19803 | // $ANTLR end "rule__ALSPreficed__Group_3__1__Impl" | ||
19804 | |||
19805 | |||
19806 | // $ANTLR start "rule__ALSPreficed__Group_3__2" | ||
19807 | // InternalAlloyLanguage.g:6945:1: rule__ALSPreficed__Group_3__2 : rule__ALSPreficed__Group_3__2__Impl ; | ||
19808 | public final void rule__ALSPreficed__Group_3__2() throws RecognitionException { | ||
19809 | |||
19810 | int stackSize = keepStackSize(); | ||
19811 | |||
19812 | try { | ||
19813 | // InternalAlloyLanguage.g:6949:1: ( rule__ALSPreficed__Group_3__2__Impl ) | ||
19814 | // InternalAlloyLanguage.g:6950:2: rule__ALSPreficed__Group_3__2__Impl | ||
19815 | { | ||
19816 | pushFollow(FOLLOW_2); | ||
19817 | rule__ALSPreficed__Group_3__2__Impl(); | ||
19818 | |||
19819 | state._fsp--; | ||
19820 | if (state.failed) return ; | ||
19821 | |||
19822 | } | ||
19823 | |||
19824 | } | ||
19825 | catch (RecognitionException re) { | ||
19826 | reportError(re); | ||
19827 | recover(input,re); | ||
19828 | } | ||
19829 | finally { | ||
19830 | |||
19831 | restoreStackSize(stackSize); | ||
19832 | |||
19833 | } | ||
19834 | return ; | ||
19835 | } | ||
19836 | // $ANTLR end "rule__ALSPreficed__Group_3__2" | ||
19837 | |||
19838 | |||
19839 | // $ANTLR start "rule__ALSPreficed__Group_3__2__Impl" | ||
19840 | // InternalAlloyLanguage.g:6956:1: rule__ALSPreficed__Group_3__2__Impl : ( ( rule__ALSPreficed__OperandAssignment_3_2 ) ) ; | ||
19841 | public final void rule__ALSPreficed__Group_3__2__Impl() throws RecognitionException { | ||
19842 | |||
19843 | int stackSize = keepStackSize(); | ||
19844 | |||
19845 | try { | ||
19846 | // InternalAlloyLanguage.g:6960:1: ( ( ( rule__ALSPreficed__OperandAssignment_3_2 ) ) ) | ||
19847 | // InternalAlloyLanguage.g:6961:1: ( ( rule__ALSPreficed__OperandAssignment_3_2 ) ) | ||
19848 | { | ||
19849 | // InternalAlloyLanguage.g:6961:1: ( ( rule__ALSPreficed__OperandAssignment_3_2 ) ) | ||
19850 | // InternalAlloyLanguage.g:6962:1: ( rule__ALSPreficed__OperandAssignment_3_2 ) | ||
19851 | { | ||
19852 | if ( state.backtracking==0 ) { | ||
19853 | before(grammarAccess.getALSPreficedAccess().getOperandAssignment_3_2()); | ||
19854 | } | ||
19855 | // InternalAlloyLanguage.g:6963:1: ( rule__ALSPreficed__OperandAssignment_3_2 ) | ||
19856 | // InternalAlloyLanguage.g:6963:2: rule__ALSPreficed__OperandAssignment_3_2 | ||
19857 | { | ||
19858 | pushFollow(FOLLOW_2); | ||
19859 | rule__ALSPreficed__OperandAssignment_3_2(); | ||
19860 | |||
19861 | state._fsp--; | ||
19862 | if (state.failed) return ; | ||
19863 | |||
19864 | } | ||
19865 | |||
19866 | if ( state.backtracking==0 ) { | ||
19867 | after(grammarAccess.getALSPreficedAccess().getOperandAssignment_3_2()); | ||
19868 | } | ||
19869 | |||
19870 | } | ||
19871 | |||
19872 | |||
19873 | } | ||
19874 | |||
19875 | } | ||
19876 | catch (RecognitionException re) { | ||
19877 | reportError(re); | ||
19878 | recover(input,re); | ||
19879 | } | ||
19880 | finally { | ||
19881 | |||
19882 | restoreStackSize(stackSize); | ||
19883 | |||
19884 | } | ||
19885 | return ; | ||
19886 | } | ||
19887 | // $ANTLR end "rule__ALSPreficed__Group_3__2__Impl" | ||
19888 | |||
19889 | |||
19890 | // $ANTLR start "rule__ALSPreficed__Group_4__0" | ||
19891 | // InternalAlloyLanguage.g:6979:1: rule__ALSPreficed__Group_4__0 : rule__ALSPreficed__Group_4__0__Impl rule__ALSPreficed__Group_4__1 ; | ||
19892 | public final void rule__ALSPreficed__Group_4__0() throws RecognitionException { | ||
19893 | |||
19894 | int stackSize = keepStackSize(); | ||
19895 | |||
19896 | try { | ||
19897 | // InternalAlloyLanguage.g:6983:1: ( rule__ALSPreficed__Group_4__0__Impl rule__ALSPreficed__Group_4__1 ) | ||
19898 | // InternalAlloyLanguage.g:6984:2: rule__ALSPreficed__Group_4__0__Impl rule__ALSPreficed__Group_4__1 | ||
19899 | { | ||
19900 | pushFollow(FOLLOW_51); | ||
19901 | rule__ALSPreficed__Group_4__0__Impl(); | ||
19902 | |||
19903 | state._fsp--; | ||
19904 | if (state.failed) return ; | ||
19905 | pushFollow(FOLLOW_2); | ||
19906 | rule__ALSPreficed__Group_4__1(); | ||
19907 | |||
19908 | state._fsp--; | ||
19909 | if (state.failed) return ; | ||
19910 | |||
19911 | } | ||
19912 | |||
19913 | } | ||
19914 | catch (RecognitionException re) { | ||
19915 | reportError(re); | ||
19916 | recover(input,re); | ||
19917 | } | ||
19918 | finally { | ||
19919 | |||
19920 | restoreStackSize(stackSize); | ||
19921 | |||
19922 | } | ||
19923 | return ; | ||
19924 | } | ||
19925 | // $ANTLR end "rule__ALSPreficed__Group_4__0" | ||
19926 | |||
19927 | |||
19928 | // $ANTLR start "rule__ALSPreficed__Group_4__0__Impl" | ||
19929 | // InternalAlloyLanguage.g:6991:1: rule__ALSPreficed__Group_4__0__Impl : ( () ) ; | ||
19930 | public final void rule__ALSPreficed__Group_4__0__Impl() throws RecognitionException { | ||
19931 | |||
19932 | int stackSize = keepStackSize(); | ||
19933 | |||
19934 | try { | ||
19935 | // InternalAlloyLanguage.g:6995:1: ( ( () ) ) | ||
19936 | // InternalAlloyLanguage.g:6996:1: ( () ) | ||
19937 | { | ||
19938 | // InternalAlloyLanguage.g:6996:1: ( () ) | ||
19939 | // InternalAlloyLanguage.g:6997:1: () | ||
19940 | { | ||
19941 | if ( state.backtracking==0 ) { | ||
19942 | before(grammarAccess.getALSPreficedAccess().getALSCardinalityAction_4_0()); | ||
19943 | } | ||
19944 | // InternalAlloyLanguage.g:6998:1: () | ||
19945 | // InternalAlloyLanguage.g:7000:1: | ||
19946 | { | ||
19947 | } | ||
19948 | |||
19949 | if ( state.backtracking==0 ) { | ||
19950 | after(grammarAccess.getALSPreficedAccess().getALSCardinalityAction_4_0()); | ||
19951 | } | ||
19952 | |||
19953 | } | ||
19954 | |||
19955 | |||
19956 | } | ||
19957 | |||
19958 | } | ||
19959 | finally { | ||
19960 | |||
19961 | restoreStackSize(stackSize); | ||
19962 | |||
19963 | } | ||
19964 | return ; | ||
19965 | } | ||
19966 | // $ANTLR end "rule__ALSPreficed__Group_4__0__Impl" | ||
19967 | |||
19968 | |||
19969 | // $ANTLR start "rule__ALSPreficed__Group_4__1" | ||
19970 | // InternalAlloyLanguage.g:7010:1: rule__ALSPreficed__Group_4__1 : rule__ALSPreficed__Group_4__1__Impl rule__ALSPreficed__Group_4__2 ; | ||
19971 | public final void rule__ALSPreficed__Group_4__1() throws RecognitionException { | ||
19972 | |||
19973 | int stackSize = keepStackSize(); | ||
19974 | |||
19975 | try { | ||
19976 | // InternalAlloyLanguage.g:7014:1: ( rule__ALSPreficed__Group_4__1__Impl rule__ALSPreficed__Group_4__2 ) | ||
19977 | // InternalAlloyLanguage.g:7015:2: rule__ALSPreficed__Group_4__1__Impl rule__ALSPreficed__Group_4__2 | ||
19978 | { | ||
19979 | pushFollow(FOLLOW_16); | ||
19980 | rule__ALSPreficed__Group_4__1__Impl(); | ||
19981 | |||
19982 | state._fsp--; | ||
19983 | if (state.failed) return ; | ||
19984 | pushFollow(FOLLOW_2); | ||
19985 | rule__ALSPreficed__Group_4__2(); | ||
19986 | |||
19987 | state._fsp--; | ||
19988 | if (state.failed) return ; | ||
19989 | |||
19990 | } | ||
19991 | |||
19992 | } | ||
19993 | catch (RecognitionException re) { | ||
19994 | reportError(re); | ||
19995 | recover(input,re); | ||
19996 | } | ||
19997 | finally { | ||
19998 | |||
19999 | restoreStackSize(stackSize); | ||
20000 | |||
20001 | } | ||
20002 | return ; | ||
20003 | } | ||
20004 | // $ANTLR end "rule__ALSPreficed__Group_4__1" | ||
20005 | |||
20006 | |||
20007 | // $ANTLR start "rule__ALSPreficed__Group_4__1__Impl" | ||
20008 | // InternalAlloyLanguage.g:7022:1: rule__ALSPreficed__Group_4__1__Impl : ( '#' ) ; | ||
20009 | public final void rule__ALSPreficed__Group_4__1__Impl() throws RecognitionException { | ||
20010 | |||
20011 | int stackSize = keepStackSize(); | ||
20012 | |||
20013 | try { | ||
20014 | // InternalAlloyLanguage.g:7026:1: ( ( '#' ) ) | ||
20015 | // InternalAlloyLanguage.g:7027:1: ( '#' ) | ||
20016 | { | ||
20017 | // InternalAlloyLanguage.g:7027:1: ( '#' ) | ||
20018 | // InternalAlloyLanguage.g:7028:1: '#' | ||
20019 | { | ||
20020 | if ( state.backtracking==0 ) { | ||
20021 | before(grammarAccess.getALSPreficedAccess().getNumberSignKeyword_4_1()); | ||
20022 | } | ||
20023 | match(input,63,FOLLOW_2); if (state.failed) return ; | ||
20024 | if ( state.backtracking==0 ) { | ||
20025 | after(grammarAccess.getALSPreficedAccess().getNumberSignKeyword_4_1()); | ||
20026 | } | ||
20027 | |||
20028 | } | ||
20029 | |||
20030 | |||
20031 | } | ||
20032 | |||
20033 | } | ||
20034 | catch (RecognitionException re) { | ||
20035 | reportError(re); | ||
20036 | recover(input,re); | ||
20037 | } | ||
20038 | finally { | ||
20039 | |||
20040 | restoreStackSize(stackSize); | ||
20041 | |||
20042 | } | ||
20043 | return ; | ||
20044 | } | ||
20045 | // $ANTLR end "rule__ALSPreficed__Group_4__1__Impl" | ||
20046 | |||
20047 | |||
20048 | // $ANTLR start "rule__ALSPreficed__Group_4__2" | ||
20049 | // InternalAlloyLanguage.g:7041:1: rule__ALSPreficed__Group_4__2 : rule__ALSPreficed__Group_4__2__Impl ; | ||
20050 | public final void rule__ALSPreficed__Group_4__2() throws RecognitionException { | ||
20051 | |||
20052 | int stackSize = keepStackSize(); | ||
20053 | |||
20054 | try { | ||
20055 | // InternalAlloyLanguage.g:7045:1: ( rule__ALSPreficed__Group_4__2__Impl ) | ||
20056 | // InternalAlloyLanguage.g:7046:2: rule__ALSPreficed__Group_4__2__Impl | ||
20057 | { | ||
20058 | pushFollow(FOLLOW_2); | ||
20059 | rule__ALSPreficed__Group_4__2__Impl(); | ||
20060 | |||
20061 | state._fsp--; | ||
20062 | if (state.failed) return ; | ||
20063 | |||
20064 | } | ||
20065 | |||
20066 | } | ||
20067 | catch (RecognitionException re) { | ||
20068 | reportError(re); | ||
20069 | recover(input,re); | ||
20070 | } | ||
20071 | finally { | ||
20072 | |||
20073 | restoreStackSize(stackSize); | ||
20074 | |||
20075 | } | ||
20076 | return ; | ||
20077 | } | ||
20078 | // $ANTLR end "rule__ALSPreficed__Group_4__2" | ||
20079 | |||
20080 | |||
20081 | // $ANTLR start "rule__ALSPreficed__Group_4__2__Impl" | ||
20082 | // InternalAlloyLanguage.g:7052:1: rule__ALSPreficed__Group_4__2__Impl : ( ( rule__ALSPreficed__OperandAssignment_4_2 ) ) ; | ||
20083 | public final void rule__ALSPreficed__Group_4__2__Impl() throws RecognitionException { | ||
20084 | |||
20085 | int stackSize = keepStackSize(); | ||
20086 | |||
20087 | try { | ||
20088 | // InternalAlloyLanguage.g:7056:1: ( ( ( rule__ALSPreficed__OperandAssignment_4_2 ) ) ) | ||
20089 | // InternalAlloyLanguage.g:7057:1: ( ( rule__ALSPreficed__OperandAssignment_4_2 ) ) | ||
20090 | { | ||
20091 | // InternalAlloyLanguage.g:7057:1: ( ( rule__ALSPreficed__OperandAssignment_4_2 ) ) | ||
20092 | // InternalAlloyLanguage.g:7058:1: ( rule__ALSPreficed__OperandAssignment_4_2 ) | ||
20093 | { | ||
20094 | if ( state.backtracking==0 ) { | ||
20095 | before(grammarAccess.getALSPreficedAccess().getOperandAssignment_4_2()); | ||
20096 | } | ||
20097 | // InternalAlloyLanguage.g:7059:1: ( rule__ALSPreficed__OperandAssignment_4_2 ) | ||
20098 | // InternalAlloyLanguage.g:7059:2: rule__ALSPreficed__OperandAssignment_4_2 | ||
20099 | { | ||
20100 | pushFollow(FOLLOW_2); | ||
20101 | rule__ALSPreficed__OperandAssignment_4_2(); | ||
20102 | |||
20103 | state._fsp--; | ||
20104 | if (state.failed) return ; | ||
20105 | |||
20106 | } | ||
20107 | |||
20108 | if ( state.backtracking==0 ) { | ||
20109 | after(grammarAccess.getALSPreficedAccess().getOperandAssignment_4_2()); | ||
20110 | } | ||
20111 | |||
20112 | } | ||
20113 | |||
20114 | |||
20115 | } | ||
20116 | |||
20117 | } | ||
20118 | catch (RecognitionException re) { | ||
20119 | reportError(re); | ||
20120 | recover(input,re); | ||
20121 | } | ||
20122 | finally { | ||
20123 | |||
20124 | restoreStackSize(stackSize); | ||
20125 | |||
20126 | } | ||
20127 | return ; | ||
20128 | } | ||
20129 | // $ANTLR end "rule__ALSPreficed__Group_4__2__Impl" | ||
20130 | |||
20131 | |||
20132 | // $ANTLR start "rule__ALSPreficed__Group_5__0" | ||
20133 | // InternalAlloyLanguage.g:7075:1: rule__ALSPreficed__Group_5__0 : rule__ALSPreficed__Group_5__0__Impl rule__ALSPreficed__Group_5__1 ; | ||
20134 | public final void rule__ALSPreficed__Group_5__0() throws RecognitionException { | ||
20135 | |||
20136 | int stackSize = keepStackSize(); | ||
20137 | |||
20138 | try { | ||
20139 | // InternalAlloyLanguage.g:7079:1: ( rule__ALSPreficed__Group_5__0__Impl rule__ALSPreficed__Group_5__1 ) | ||
20140 | // InternalAlloyLanguage.g:7080:2: rule__ALSPreficed__Group_5__0__Impl rule__ALSPreficed__Group_5__1 | ||
20141 | { | ||
20142 | pushFollow(FOLLOW_42); | ||
20143 | rule__ALSPreficed__Group_5__0__Impl(); | ||
20144 | |||
20145 | state._fsp--; | ||
20146 | if (state.failed) return ; | ||
20147 | pushFollow(FOLLOW_2); | ||
20148 | rule__ALSPreficed__Group_5__1(); | ||
20149 | |||
20150 | state._fsp--; | ||
20151 | if (state.failed) return ; | ||
20152 | |||
20153 | } | ||
20154 | |||
20155 | } | ||
20156 | catch (RecognitionException re) { | ||
20157 | reportError(re); | ||
20158 | recover(input,re); | ||
20159 | } | ||
20160 | finally { | ||
20161 | |||
20162 | restoreStackSize(stackSize); | ||
20163 | |||
20164 | } | ||
20165 | return ; | ||
20166 | } | ||
20167 | // $ANTLR end "rule__ALSPreficed__Group_5__0" | ||
20168 | |||
20169 | |||
20170 | // $ANTLR start "rule__ALSPreficed__Group_5__0__Impl" | ||
20171 | // InternalAlloyLanguage.g:7087:1: rule__ALSPreficed__Group_5__0__Impl : ( () ) ; | ||
20172 | public final void rule__ALSPreficed__Group_5__0__Impl() throws RecognitionException { | ||
20173 | |||
20174 | int stackSize = keepStackSize(); | ||
20175 | |||
20176 | try { | ||
20177 | // InternalAlloyLanguage.g:7091:1: ( ( () ) ) | ||
20178 | // InternalAlloyLanguage.g:7092:1: ( () ) | ||
20179 | { | ||
20180 | // InternalAlloyLanguage.g:7092:1: ( () ) | ||
20181 | // InternalAlloyLanguage.g:7093:1: () | ||
20182 | { | ||
20183 | if ( state.backtracking==0 ) { | ||
20184 | before(grammarAccess.getALSPreficedAccess().getALSUnaryMinusAction_5_0()); | ||
20185 | } | ||
20186 | // InternalAlloyLanguage.g:7094:1: () | ||
20187 | // InternalAlloyLanguage.g:7096:1: | ||
20188 | { | ||
20189 | } | ||
20190 | |||
20191 | if ( state.backtracking==0 ) { | ||
20192 | after(grammarAccess.getALSPreficedAccess().getALSUnaryMinusAction_5_0()); | ||
20193 | } | ||
20194 | |||
20195 | } | ||
20196 | |||
20197 | |||
20198 | } | ||
20199 | |||
20200 | } | ||
20201 | finally { | ||
20202 | |||
20203 | restoreStackSize(stackSize); | ||
20204 | |||
20205 | } | ||
20206 | return ; | ||
20207 | } | ||
20208 | // $ANTLR end "rule__ALSPreficed__Group_5__0__Impl" | ||
20209 | |||
20210 | |||
20211 | // $ANTLR start "rule__ALSPreficed__Group_5__1" | ||
20212 | // InternalAlloyLanguage.g:7106:1: rule__ALSPreficed__Group_5__1 : rule__ALSPreficed__Group_5__1__Impl rule__ALSPreficed__Group_5__2 ; | ||
20213 | public final void rule__ALSPreficed__Group_5__1() throws RecognitionException { | ||
20214 | |||
20215 | int stackSize = keepStackSize(); | ||
20216 | |||
20217 | try { | ||
20218 | // InternalAlloyLanguage.g:7110:1: ( rule__ALSPreficed__Group_5__1__Impl rule__ALSPreficed__Group_5__2 ) | ||
20219 | // InternalAlloyLanguage.g:7111:2: rule__ALSPreficed__Group_5__1__Impl rule__ALSPreficed__Group_5__2 | ||
20220 | { | ||
20221 | pushFollow(FOLLOW_16); | ||
20222 | rule__ALSPreficed__Group_5__1__Impl(); | ||
20223 | |||
20224 | state._fsp--; | ||
20225 | if (state.failed) return ; | ||
20226 | pushFollow(FOLLOW_2); | ||
20227 | rule__ALSPreficed__Group_5__2(); | ||
20228 | |||
20229 | state._fsp--; | ||
20230 | if (state.failed) return ; | ||
20231 | |||
20232 | } | ||
20233 | |||
20234 | } | ||
20235 | catch (RecognitionException re) { | ||
20236 | reportError(re); | ||
20237 | recover(input,re); | ||
20238 | } | ||
20239 | finally { | ||
20240 | |||
20241 | restoreStackSize(stackSize); | ||
20242 | |||
20243 | } | ||
20244 | return ; | ||
20245 | } | ||
20246 | // $ANTLR end "rule__ALSPreficed__Group_5__1" | ||
20247 | |||
20248 | |||
20249 | // $ANTLR start "rule__ALSPreficed__Group_5__1__Impl" | ||
20250 | // InternalAlloyLanguage.g:7118:1: rule__ALSPreficed__Group_5__1__Impl : ( ( '-' ) ) ; | ||
20251 | public final void rule__ALSPreficed__Group_5__1__Impl() throws RecognitionException { | ||
20252 | |||
20253 | int stackSize = keepStackSize(); | ||
20254 | |||
20255 | try { | ||
20256 | // InternalAlloyLanguage.g:7122:1: ( ( ( '-' ) ) ) | ||
20257 | // InternalAlloyLanguage.g:7123:1: ( ( '-' ) ) | ||
20258 | { | ||
20259 | // InternalAlloyLanguage.g:7123:1: ( ( '-' ) ) | ||
20260 | // InternalAlloyLanguage.g:7124:1: ( '-' ) | ||
20261 | { | ||
20262 | if ( state.backtracking==0 ) { | ||
20263 | before(grammarAccess.getALSPreficedAccess().getHyphenMinusKeyword_5_1()); | ||
20264 | } | ||
20265 | // InternalAlloyLanguage.g:7125:1: ( '-' ) | ||
20266 | // InternalAlloyLanguage.g:7126:2: '-' | ||
20267 | { | ||
20268 | match(input,57,FOLLOW_2); if (state.failed) return ; | ||
20269 | |||
20270 | } | ||
20271 | |||
20272 | if ( state.backtracking==0 ) { | ||
20273 | after(grammarAccess.getALSPreficedAccess().getHyphenMinusKeyword_5_1()); | ||
20274 | } | ||
20275 | |||
20276 | } | ||
20277 | |||
20278 | |||
20279 | } | ||
20280 | |||
20281 | } | ||
20282 | catch (RecognitionException re) { | ||
20283 | reportError(re); | ||
20284 | recover(input,re); | ||
20285 | } | ||
20286 | finally { | ||
20287 | |||
20288 | restoreStackSize(stackSize); | ||
20289 | |||
20290 | } | ||
20291 | return ; | ||
20292 | } | ||
20293 | // $ANTLR end "rule__ALSPreficed__Group_5__1__Impl" | ||
20294 | |||
20295 | |||
20296 | // $ANTLR start "rule__ALSPreficed__Group_5__2" | ||
20297 | // InternalAlloyLanguage.g:7137:1: rule__ALSPreficed__Group_5__2 : rule__ALSPreficed__Group_5__2__Impl ; | ||
20298 | public final void rule__ALSPreficed__Group_5__2() throws RecognitionException { | ||
20299 | |||
20300 | int stackSize = keepStackSize(); | ||
20301 | |||
20302 | try { | ||
20303 | // InternalAlloyLanguage.g:7141:1: ( rule__ALSPreficed__Group_5__2__Impl ) | ||
20304 | // InternalAlloyLanguage.g:7142:2: rule__ALSPreficed__Group_5__2__Impl | ||
20305 | { | ||
20306 | pushFollow(FOLLOW_2); | ||
20307 | rule__ALSPreficed__Group_5__2__Impl(); | ||
20308 | |||
20309 | state._fsp--; | ||
20310 | if (state.failed) return ; | ||
20311 | |||
20312 | } | ||
20313 | |||
20314 | } | ||
20315 | catch (RecognitionException re) { | ||
20316 | reportError(re); | ||
20317 | recover(input,re); | ||
20318 | } | ||
20319 | finally { | ||
20320 | |||
20321 | restoreStackSize(stackSize); | ||
20322 | |||
20323 | } | ||
20324 | return ; | ||
20325 | } | ||
20326 | // $ANTLR end "rule__ALSPreficed__Group_5__2" | ||
20327 | |||
20328 | |||
20329 | // $ANTLR start "rule__ALSPreficed__Group_5__2__Impl" | ||
20330 | // InternalAlloyLanguage.g:7148:1: rule__ALSPreficed__Group_5__2__Impl : ( ( rule__ALSPreficed__OperandAssignment_5_2 ) ) ; | ||
20331 | public final void rule__ALSPreficed__Group_5__2__Impl() throws RecognitionException { | ||
20332 | |||
20333 | int stackSize = keepStackSize(); | ||
20334 | |||
20335 | try { | ||
20336 | // InternalAlloyLanguage.g:7152:1: ( ( ( rule__ALSPreficed__OperandAssignment_5_2 ) ) ) | ||
20337 | // InternalAlloyLanguage.g:7153:1: ( ( rule__ALSPreficed__OperandAssignment_5_2 ) ) | ||
20338 | { | ||
20339 | // InternalAlloyLanguage.g:7153:1: ( ( rule__ALSPreficed__OperandAssignment_5_2 ) ) | ||
20340 | // InternalAlloyLanguage.g:7154:1: ( rule__ALSPreficed__OperandAssignment_5_2 ) | ||
20341 | { | ||
20342 | if ( state.backtracking==0 ) { | ||
20343 | before(grammarAccess.getALSPreficedAccess().getOperandAssignment_5_2()); | ||
20344 | } | ||
20345 | // InternalAlloyLanguage.g:7155:1: ( rule__ALSPreficed__OperandAssignment_5_2 ) | ||
20346 | // InternalAlloyLanguage.g:7155:2: rule__ALSPreficed__OperandAssignment_5_2 | ||
20347 | { | ||
20348 | pushFollow(FOLLOW_2); | ||
20349 | rule__ALSPreficed__OperandAssignment_5_2(); | ||
20350 | |||
20351 | state._fsp--; | ||
20352 | if (state.failed) return ; | ||
20353 | |||
20354 | } | ||
20355 | |||
20356 | if ( state.backtracking==0 ) { | ||
20357 | after(grammarAccess.getALSPreficedAccess().getOperandAssignment_5_2()); | ||
20358 | } | ||
20359 | |||
20360 | } | ||
20361 | |||
20362 | |||
20363 | } | ||
20364 | |||
20365 | } | ||
20366 | catch (RecognitionException re) { | ||
20367 | reportError(re); | ||
20368 | recover(input,re); | ||
20369 | } | ||
20370 | finally { | ||
20371 | |||
20372 | restoreStackSize(stackSize); | ||
20373 | |||
20374 | } | ||
20375 | return ; | ||
20376 | } | ||
20377 | // $ANTLR end "rule__ALSPreficed__Group_5__2__Impl" | ||
20378 | |||
20379 | |||
20380 | // $ANTLR start "rule__ALSPreficed__Group_6__0" | ||
20381 | // InternalAlloyLanguage.g:7171:1: rule__ALSPreficed__Group_6__0 : rule__ALSPreficed__Group_6__0__Impl rule__ALSPreficed__Group_6__1 ; | ||
20382 | public final void rule__ALSPreficed__Group_6__0() throws RecognitionException { | ||
20383 | |||
20384 | int stackSize = keepStackSize(); | ||
20385 | |||
20386 | try { | ||
20387 | // InternalAlloyLanguage.g:7175:1: ( rule__ALSPreficed__Group_6__0__Impl rule__ALSPreficed__Group_6__1 ) | ||
20388 | // InternalAlloyLanguage.g:7176:2: rule__ALSPreficed__Group_6__0__Impl rule__ALSPreficed__Group_6__1 | ||
20389 | { | ||
20390 | pushFollow(FOLLOW_52); | ||
20391 | rule__ALSPreficed__Group_6__0__Impl(); | ||
20392 | |||
20393 | state._fsp--; | ||
20394 | if (state.failed) return ; | ||
20395 | pushFollow(FOLLOW_2); | ||
20396 | rule__ALSPreficed__Group_6__1(); | ||
20397 | |||
20398 | state._fsp--; | ||
20399 | if (state.failed) return ; | ||
20400 | |||
20401 | } | ||
20402 | |||
20403 | } | ||
20404 | catch (RecognitionException re) { | ||
20405 | reportError(re); | ||
20406 | recover(input,re); | ||
20407 | } | ||
20408 | finally { | ||
20409 | |||
20410 | restoreStackSize(stackSize); | ||
20411 | |||
20412 | } | ||
20413 | return ; | ||
20414 | } | ||
20415 | // $ANTLR end "rule__ALSPreficed__Group_6__0" | ||
20416 | |||
20417 | |||
20418 | // $ANTLR start "rule__ALSPreficed__Group_6__0__Impl" | ||
20419 | // InternalAlloyLanguage.g:7183:1: rule__ALSPreficed__Group_6__0__Impl : ( () ) ; | ||
20420 | public final void rule__ALSPreficed__Group_6__0__Impl() throws RecognitionException { | ||
20421 | |||
20422 | int stackSize = keepStackSize(); | ||
20423 | |||
20424 | try { | ||
20425 | // InternalAlloyLanguage.g:7187:1: ( ( () ) ) | ||
20426 | // InternalAlloyLanguage.g:7188:1: ( () ) | ||
20427 | { | ||
20428 | // InternalAlloyLanguage.g:7188:1: ( () ) | ||
20429 | // InternalAlloyLanguage.g:7189:1: () | ||
20430 | { | ||
20431 | if ( state.backtracking==0 ) { | ||
20432 | before(grammarAccess.getALSPreficedAccess().getALSSumAction_6_0()); | ||
20433 | } | ||
20434 | // InternalAlloyLanguage.g:7190:1: () | ||
20435 | // InternalAlloyLanguage.g:7192:1: | ||
20436 | { | ||
20437 | } | ||
20438 | |||
20439 | if ( state.backtracking==0 ) { | ||
20440 | after(grammarAccess.getALSPreficedAccess().getALSSumAction_6_0()); | ||
20441 | } | ||
20442 | |||
20443 | } | ||
20444 | |||
20445 | |||
20446 | } | ||
20447 | |||
20448 | } | ||
20449 | finally { | ||
20450 | |||
20451 | restoreStackSize(stackSize); | ||
20452 | |||
20453 | } | ||
20454 | return ; | ||
20455 | } | ||
20456 | // $ANTLR end "rule__ALSPreficed__Group_6__0__Impl" | ||
20457 | |||
20458 | |||
20459 | // $ANTLR start "rule__ALSPreficed__Group_6__1" | ||
20460 | // InternalAlloyLanguage.g:7202:1: rule__ALSPreficed__Group_6__1 : rule__ALSPreficed__Group_6__1__Impl rule__ALSPreficed__Group_6__2 ; | ||
20461 | public final void rule__ALSPreficed__Group_6__1() throws RecognitionException { | ||
20462 | |||
20463 | int stackSize = keepStackSize(); | ||
20464 | |||
20465 | try { | ||
20466 | // InternalAlloyLanguage.g:7206:1: ( rule__ALSPreficed__Group_6__1__Impl rule__ALSPreficed__Group_6__2 ) | ||
20467 | // InternalAlloyLanguage.g:7207:2: rule__ALSPreficed__Group_6__1__Impl rule__ALSPreficed__Group_6__2 | ||
20468 | { | ||
20469 | pushFollow(FOLLOW_5); | ||
20470 | rule__ALSPreficed__Group_6__1__Impl(); | ||
20471 | |||
20472 | state._fsp--; | ||
20473 | if (state.failed) return ; | ||
20474 | pushFollow(FOLLOW_2); | ||
20475 | rule__ALSPreficed__Group_6__2(); | ||
20476 | |||
20477 | state._fsp--; | ||
20478 | if (state.failed) return ; | ||
20479 | |||
20480 | } | ||
20481 | |||
20482 | } | ||
20483 | catch (RecognitionException re) { | ||
20484 | reportError(re); | ||
20485 | recover(input,re); | ||
20486 | } | ||
20487 | finally { | ||
20488 | |||
20489 | restoreStackSize(stackSize); | ||
20490 | |||
20491 | } | ||
20492 | return ; | ||
20493 | } | ||
20494 | // $ANTLR end "rule__ALSPreficed__Group_6__1" | ||
20495 | |||
20496 | |||
20497 | // $ANTLR start "rule__ALSPreficed__Group_6__1__Impl" | ||
20498 | // InternalAlloyLanguage.g:7214:1: rule__ALSPreficed__Group_6__1__Impl : ( 'sum' ) ; | ||
20499 | public final void rule__ALSPreficed__Group_6__1__Impl() throws RecognitionException { | ||
20500 | |||
20501 | int stackSize = keepStackSize(); | ||
20502 | |||
20503 | try { | ||
20504 | // InternalAlloyLanguage.g:7218:1: ( ( 'sum' ) ) | ||
20505 | // InternalAlloyLanguage.g:7219:1: ( 'sum' ) | ||
20506 | { | ||
20507 | // InternalAlloyLanguage.g:7219:1: ( 'sum' ) | ||
20508 | // InternalAlloyLanguage.g:7220:1: 'sum' | ||
20509 | { | ||
20510 | if ( state.backtracking==0 ) { | ||
20511 | before(grammarAccess.getALSPreficedAccess().getSumKeyword_6_1()); | ||
20512 | } | ||
20513 | match(input,64,FOLLOW_2); if (state.failed) return ; | ||
20514 | if ( state.backtracking==0 ) { | ||
20515 | after(grammarAccess.getALSPreficedAccess().getSumKeyword_6_1()); | ||
20516 | } | ||
20517 | |||
20518 | } | ||
20519 | |||
20520 | |||
20521 | } | ||
20522 | |||
20523 | } | ||
20524 | catch (RecognitionException re) { | ||
20525 | reportError(re); | ||
20526 | recover(input,re); | ||
20527 | } | ||
20528 | finally { | ||
20529 | |||
20530 | restoreStackSize(stackSize); | ||
20531 | |||
20532 | } | ||
20533 | return ; | ||
20534 | } | ||
20535 | // $ANTLR end "rule__ALSPreficed__Group_6__1__Impl" | ||
20536 | |||
20537 | |||
20538 | // $ANTLR start "rule__ALSPreficed__Group_6__2" | ||
20539 | // InternalAlloyLanguage.g:7233:1: rule__ALSPreficed__Group_6__2 : rule__ALSPreficed__Group_6__2__Impl rule__ALSPreficed__Group_6__3 ; | ||
20540 | public final void rule__ALSPreficed__Group_6__2() throws RecognitionException { | ||
20541 | |||
20542 | int stackSize = keepStackSize(); | ||
20543 | |||
20544 | try { | ||
20545 | // InternalAlloyLanguage.g:7237:1: ( rule__ALSPreficed__Group_6__2__Impl rule__ALSPreficed__Group_6__3 ) | ||
20546 | // InternalAlloyLanguage.g:7238:2: rule__ALSPreficed__Group_6__2__Impl rule__ALSPreficed__Group_6__3 | ||
20547 | { | ||
20548 | pushFollow(FOLLOW_24); | ||
20549 | rule__ALSPreficed__Group_6__2__Impl(); | ||
20550 | |||
20551 | state._fsp--; | ||
20552 | if (state.failed) return ; | ||
20553 | pushFollow(FOLLOW_2); | ||
20554 | rule__ALSPreficed__Group_6__3(); | ||
20555 | |||
20556 | state._fsp--; | ||
20557 | if (state.failed) return ; | ||
20558 | |||
20559 | } | ||
20560 | |||
20561 | } | ||
20562 | catch (RecognitionException re) { | ||
20563 | reportError(re); | ||
20564 | recover(input,re); | ||
20565 | } | ||
20566 | finally { | ||
20567 | |||
20568 | restoreStackSize(stackSize); | ||
20569 | |||
20570 | } | ||
20571 | return ; | ||
20572 | } | ||
20573 | // $ANTLR end "rule__ALSPreficed__Group_6__2" | ||
20574 | |||
20575 | |||
20576 | // $ANTLR start "rule__ALSPreficed__Group_6__2__Impl" | ||
20577 | // InternalAlloyLanguage.g:7245:1: rule__ALSPreficed__Group_6__2__Impl : ( ( rule__ALSPreficed__VariablesAssignment_6_2 ) ) ; | ||
20578 | public final void rule__ALSPreficed__Group_6__2__Impl() throws RecognitionException { | ||
20579 | |||
20580 | int stackSize = keepStackSize(); | ||
20581 | |||
20582 | try { | ||
20583 | // InternalAlloyLanguage.g:7249:1: ( ( ( rule__ALSPreficed__VariablesAssignment_6_2 ) ) ) | ||
20584 | // InternalAlloyLanguage.g:7250:1: ( ( rule__ALSPreficed__VariablesAssignment_6_2 ) ) | ||
20585 | { | ||
20586 | // InternalAlloyLanguage.g:7250:1: ( ( rule__ALSPreficed__VariablesAssignment_6_2 ) ) | ||
20587 | // InternalAlloyLanguage.g:7251:1: ( rule__ALSPreficed__VariablesAssignment_6_2 ) | ||
20588 | { | ||
20589 | if ( state.backtracking==0 ) { | ||
20590 | before(grammarAccess.getALSPreficedAccess().getVariablesAssignment_6_2()); | ||
20591 | } | ||
20592 | // InternalAlloyLanguage.g:7252:1: ( rule__ALSPreficed__VariablesAssignment_6_2 ) | ||
20593 | // InternalAlloyLanguage.g:7252:2: rule__ALSPreficed__VariablesAssignment_6_2 | ||
20594 | { | ||
20595 | pushFollow(FOLLOW_2); | ||
20596 | rule__ALSPreficed__VariablesAssignment_6_2(); | ||
20597 | |||
20598 | state._fsp--; | ||
20599 | if (state.failed) return ; | ||
20600 | |||
20601 | } | ||
20602 | |||
20603 | if ( state.backtracking==0 ) { | ||
20604 | after(grammarAccess.getALSPreficedAccess().getVariablesAssignment_6_2()); | ||
20605 | } | ||
20606 | |||
20607 | } | ||
20608 | |||
20609 | |||
20610 | } | ||
20611 | |||
20612 | } | ||
20613 | catch (RecognitionException re) { | ||
20614 | reportError(re); | ||
20615 | recover(input,re); | ||
20616 | } | ||
20617 | finally { | ||
20618 | |||
20619 | restoreStackSize(stackSize); | ||
20620 | |||
20621 | } | ||
20622 | return ; | ||
20623 | } | ||
20624 | // $ANTLR end "rule__ALSPreficed__Group_6__2__Impl" | ||
20625 | |||
20626 | |||
20627 | // $ANTLR start "rule__ALSPreficed__Group_6__3" | ||
20628 | // InternalAlloyLanguage.g:7262:1: rule__ALSPreficed__Group_6__3 : rule__ALSPreficed__Group_6__3__Impl rule__ALSPreficed__Group_6__4 ; | ||
20629 | public final void rule__ALSPreficed__Group_6__3() throws RecognitionException { | ||
20630 | |||
20631 | int stackSize = keepStackSize(); | ||
20632 | |||
20633 | try { | ||
20634 | // InternalAlloyLanguage.g:7266:1: ( rule__ALSPreficed__Group_6__3__Impl rule__ALSPreficed__Group_6__4 ) | ||
20635 | // InternalAlloyLanguage.g:7267:2: rule__ALSPreficed__Group_6__3__Impl rule__ALSPreficed__Group_6__4 | ||
20636 | { | ||
20637 | pushFollow(FOLLOW_24); | ||
20638 | rule__ALSPreficed__Group_6__3__Impl(); | ||
20639 | |||
20640 | state._fsp--; | ||
20641 | if (state.failed) return ; | ||
20642 | pushFollow(FOLLOW_2); | ||
20643 | rule__ALSPreficed__Group_6__4(); | ||
20644 | |||
20645 | state._fsp--; | ||
20646 | if (state.failed) return ; | ||
20647 | |||
20648 | } | ||
20649 | |||
20650 | } | ||
20651 | catch (RecognitionException re) { | ||
20652 | reportError(re); | ||
20653 | recover(input,re); | ||
20654 | } | ||
20655 | finally { | ||
20656 | |||
20657 | restoreStackSize(stackSize); | ||
20658 | |||
20659 | } | ||
20660 | return ; | ||
20661 | } | ||
20662 | // $ANTLR end "rule__ALSPreficed__Group_6__3" | ||
20663 | |||
20664 | |||
20665 | // $ANTLR start "rule__ALSPreficed__Group_6__3__Impl" | ||
20666 | // InternalAlloyLanguage.g:7274:1: rule__ALSPreficed__Group_6__3__Impl : ( ( rule__ALSPreficed__Group_6_3__0 )* ) ; | ||
20667 | public final void rule__ALSPreficed__Group_6__3__Impl() throws RecognitionException { | ||
20668 | |||
20669 | int stackSize = keepStackSize(); | ||
20670 | |||
20671 | try { | ||
20672 | // InternalAlloyLanguage.g:7278:1: ( ( ( rule__ALSPreficed__Group_6_3__0 )* ) ) | ||
20673 | // InternalAlloyLanguage.g:7279:1: ( ( rule__ALSPreficed__Group_6_3__0 )* ) | ||
20674 | { | ||
20675 | // InternalAlloyLanguage.g:7279:1: ( ( rule__ALSPreficed__Group_6_3__0 )* ) | ||
20676 | // InternalAlloyLanguage.g:7280:1: ( rule__ALSPreficed__Group_6_3__0 )* | ||
20677 | { | ||
20678 | if ( state.backtracking==0 ) { | ||
20679 | before(grammarAccess.getALSPreficedAccess().getGroup_6_3()); | ||
20680 | } | ||
20681 | // InternalAlloyLanguage.g:7281:1: ( rule__ALSPreficed__Group_6_3__0 )* | ||
20682 | loop46: | ||
20683 | do { | ||
20684 | int alt46=2; | ||
20685 | int LA46_0 = input.LA(1); | ||
20686 | |||
20687 | if ( (LA46_0==35) ) { | ||
20688 | alt46=1; | ||
20689 | } | ||
20690 | |||
20691 | |||
20692 | switch (alt46) { | ||
20693 | case 1 : | ||
20694 | // InternalAlloyLanguage.g:7281:2: rule__ALSPreficed__Group_6_3__0 | ||
20695 | { | ||
20696 | pushFollow(FOLLOW_8); | ||
20697 | rule__ALSPreficed__Group_6_3__0(); | ||
20698 | |||
20699 | state._fsp--; | ||
20700 | if (state.failed) return ; | ||
20701 | |||
20702 | } | ||
20703 | break; | ||
20704 | |||
20705 | default : | ||
20706 | break loop46; | ||
20707 | } | ||
20708 | } while (true); | ||
20709 | |||
20710 | if ( state.backtracking==0 ) { | ||
20711 | after(grammarAccess.getALSPreficedAccess().getGroup_6_3()); | ||
20712 | } | ||
20713 | |||
20714 | } | ||
20715 | |||
20716 | |||
20717 | } | ||
20718 | |||
20719 | } | ||
20720 | catch (RecognitionException re) { | ||
20721 | reportError(re); | ||
20722 | recover(input,re); | ||
20723 | } | ||
20724 | finally { | ||
20725 | |||
20726 | restoreStackSize(stackSize); | ||
20727 | |||
20728 | } | ||
20729 | return ; | ||
20730 | } | ||
20731 | // $ANTLR end "rule__ALSPreficed__Group_6__3__Impl" | ||
20732 | |||
20733 | |||
20734 | // $ANTLR start "rule__ALSPreficed__Group_6__4" | ||
20735 | // InternalAlloyLanguage.g:7291:1: rule__ALSPreficed__Group_6__4 : rule__ALSPreficed__Group_6__4__Impl rule__ALSPreficed__Group_6__5 ; | ||
20736 | public final void rule__ALSPreficed__Group_6__4() throws RecognitionException { | ||
20737 | |||
20738 | int stackSize = keepStackSize(); | ||
20739 | |||
20740 | try { | ||
20741 | // InternalAlloyLanguage.g:7295:1: ( rule__ALSPreficed__Group_6__4__Impl rule__ALSPreficed__Group_6__5 ) | ||
20742 | // InternalAlloyLanguage.g:7296:2: rule__ALSPreficed__Group_6__4__Impl rule__ALSPreficed__Group_6__5 | ||
20743 | { | ||
20744 | pushFollow(FOLLOW_16); | ||
20745 | rule__ALSPreficed__Group_6__4__Impl(); | ||
20746 | |||
20747 | state._fsp--; | ||
20748 | if (state.failed) return ; | ||
20749 | pushFollow(FOLLOW_2); | ||
20750 | rule__ALSPreficed__Group_6__5(); | ||
20751 | |||
20752 | state._fsp--; | ||
20753 | if (state.failed) return ; | ||
20754 | |||
20755 | } | ||
20756 | |||
20757 | } | ||
20758 | catch (RecognitionException re) { | ||
20759 | reportError(re); | ||
20760 | recover(input,re); | ||
20761 | } | ||
20762 | finally { | ||
20763 | |||
20764 | restoreStackSize(stackSize); | ||
20765 | |||
20766 | } | ||
20767 | return ; | ||
20768 | } | ||
20769 | // $ANTLR end "rule__ALSPreficed__Group_6__4" | ||
20770 | |||
20771 | |||
20772 | // $ANTLR start "rule__ALSPreficed__Group_6__4__Impl" | ||
20773 | // InternalAlloyLanguage.g:7303:1: rule__ALSPreficed__Group_6__4__Impl : ( '{' ) ; | ||
20774 | public final void rule__ALSPreficed__Group_6__4__Impl() throws RecognitionException { | ||
20775 | |||
20776 | int stackSize = keepStackSize(); | ||
20777 | |||
20778 | try { | ||
20779 | // InternalAlloyLanguage.g:7307:1: ( ( '{' ) ) | ||
20780 | // InternalAlloyLanguage.g:7308:1: ( '{' ) | ||
20781 | { | ||
20782 | // InternalAlloyLanguage.g:7308:1: ( '{' ) | ||
20783 | // InternalAlloyLanguage.g:7309:1: '{' | ||
20784 | { | ||
20785 | if ( state.backtracking==0 ) { | ||
20786 | before(grammarAccess.getALSPreficedAccess().getLeftCurlyBracketKeyword_6_4()); | ||
20787 | } | ||
20788 | match(input,33,FOLLOW_2); if (state.failed) return ; | ||
20789 | if ( state.backtracking==0 ) { | ||
20790 | after(grammarAccess.getALSPreficedAccess().getLeftCurlyBracketKeyword_6_4()); | ||
20791 | } | ||
20792 | |||
20793 | } | ||
20794 | |||
20795 | |||
20796 | } | ||
20797 | |||
20798 | } | ||
20799 | catch (RecognitionException re) { | ||
20800 | reportError(re); | ||
20801 | recover(input,re); | ||
20802 | } | ||
20803 | finally { | ||
20804 | |||
20805 | restoreStackSize(stackSize); | ||
20806 | |||
20807 | } | ||
20808 | return ; | ||
20809 | } | ||
20810 | // $ANTLR end "rule__ALSPreficed__Group_6__4__Impl" | ||
20811 | |||
20812 | |||
20813 | // $ANTLR start "rule__ALSPreficed__Group_6__5" | ||
20814 | // InternalAlloyLanguage.g:7322:1: rule__ALSPreficed__Group_6__5 : rule__ALSPreficed__Group_6__5__Impl rule__ALSPreficed__Group_6__6 ; | ||
20815 | public final void rule__ALSPreficed__Group_6__5() throws RecognitionException { | ||
20816 | |||
20817 | int stackSize = keepStackSize(); | ||
20818 | |||
20819 | try { | ||
20820 | // InternalAlloyLanguage.g:7326:1: ( rule__ALSPreficed__Group_6__5__Impl rule__ALSPreficed__Group_6__6 ) | ||
20821 | // InternalAlloyLanguage.g:7327:2: rule__ALSPreficed__Group_6__5__Impl rule__ALSPreficed__Group_6__6 | ||
20822 | { | ||
20823 | pushFollow(FOLLOW_19); | ||
20824 | rule__ALSPreficed__Group_6__5__Impl(); | ||
20825 | |||
20826 | state._fsp--; | ||
20827 | if (state.failed) return ; | ||
20828 | pushFollow(FOLLOW_2); | ||
20829 | rule__ALSPreficed__Group_6__6(); | ||
20830 | |||
20831 | state._fsp--; | ||
20832 | if (state.failed) return ; | ||
20833 | |||
20834 | } | ||
20835 | |||
20836 | } | ||
20837 | catch (RecognitionException re) { | ||
20838 | reportError(re); | ||
20839 | recover(input,re); | ||
20840 | } | ||
20841 | finally { | ||
20842 | |||
20843 | restoreStackSize(stackSize); | ||
20844 | |||
20845 | } | ||
20846 | return ; | ||
20847 | } | ||
20848 | // $ANTLR end "rule__ALSPreficed__Group_6__5" | ||
20849 | |||
20850 | |||
20851 | // $ANTLR start "rule__ALSPreficed__Group_6__5__Impl" | ||
20852 | // InternalAlloyLanguage.g:7334:1: rule__ALSPreficed__Group_6__5__Impl : ( ( rule__ALSPreficed__ExpressionAssignment_6_5 ) ) ; | ||
20853 | public final void rule__ALSPreficed__Group_6__5__Impl() throws RecognitionException { | ||
20854 | |||
20855 | int stackSize = keepStackSize(); | ||
20856 | |||
20857 | try { | ||
20858 | // InternalAlloyLanguage.g:7338:1: ( ( ( rule__ALSPreficed__ExpressionAssignment_6_5 ) ) ) | ||
20859 | // InternalAlloyLanguage.g:7339:1: ( ( rule__ALSPreficed__ExpressionAssignment_6_5 ) ) | ||
20860 | { | ||
20861 | // InternalAlloyLanguage.g:7339:1: ( ( rule__ALSPreficed__ExpressionAssignment_6_5 ) ) | ||
20862 | // InternalAlloyLanguage.g:7340:1: ( rule__ALSPreficed__ExpressionAssignment_6_5 ) | ||
20863 | { | ||
20864 | if ( state.backtracking==0 ) { | ||
20865 | before(grammarAccess.getALSPreficedAccess().getExpressionAssignment_6_5()); | ||
20866 | } | ||
20867 | // InternalAlloyLanguage.g:7341:1: ( rule__ALSPreficed__ExpressionAssignment_6_5 ) | ||
20868 | // InternalAlloyLanguage.g:7341:2: rule__ALSPreficed__ExpressionAssignment_6_5 | ||
20869 | { | ||
20870 | pushFollow(FOLLOW_2); | ||
20871 | rule__ALSPreficed__ExpressionAssignment_6_5(); | ||
20872 | |||
20873 | state._fsp--; | ||
20874 | if (state.failed) return ; | ||
20875 | |||
20876 | } | ||
20877 | |||
20878 | if ( state.backtracking==0 ) { | ||
20879 | after(grammarAccess.getALSPreficedAccess().getExpressionAssignment_6_5()); | ||
20880 | } | ||
20881 | |||
20882 | } | ||
20883 | |||
20884 | |||
20885 | } | ||
20886 | |||
20887 | } | ||
20888 | catch (RecognitionException re) { | ||
20889 | reportError(re); | ||
20890 | recover(input,re); | ||
20891 | } | ||
20892 | finally { | ||
20893 | |||
20894 | restoreStackSize(stackSize); | ||
20895 | |||
20896 | } | ||
20897 | return ; | ||
20898 | } | ||
20899 | // $ANTLR end "rule__ALSPreficed__Group_6__5__Impl" | ||
20900 | |||
20901 | |||
20902 | // $ANTLR start "rule__ALSPreficed__Group_6__6" | ||
20903 | // InternalAlloyLanguage.g:7351:1: rule__ALSPreficed__Group_6__6 : rule__ALSPreficed__Group_6__6__Impl ; | ||
20904 | public final void rule__ALSPreficed__Group_6__6() throws RecognitionException { | ||
20905 | |||
20906 | int stackSize = keepStackSize(); | ||
20907 | |||
20908 | try { | ||
20909 | // InternalAlloyLanguage.g:7355:1: ( rule__ALSPreficed__Group_6__6__Impl ) | ||
20910 | // InternalAlloyLanguage.g:7356:2: rule__ALSPreficed__Group_6__6__Impl | ||
20911 | { | ||
20912 | pushFollow(FOLLOW_2); | ||
20913 | rule__ALSPreficed__Group_6__6__Impl(); | ||
20914 | |||
20915 | state._fsp--; | ||
20916 | if (state.failed) return ; | ||
20917 | |||
20918 | } | ||
20919 | |||
20920 | } | ||
20921 | catch (RecognitionException re) { | ||
20922 | reportError(re); | ||
20923 | recover(input,re); | ||
20924 | } | ||
20925 | finally { | ||
20926 | |||
20927 | restoreStackSize(stackSize); | ||
20928 | |||
20929 | } | ||
20930 | return ; | ||
20931 | } | ||
20932 | // $ANTLR end "rule__ALSPreficed__Group_6__6" | ||
20933 | |||
20934 | |||
20935 | // $ANTLR start "rule__ALSPreficed__Group_6__6__Impl" | ||
20936 | // InternalAlloyLanguage.g:7362:1: rule__ALSPreficed__Group_6__6__Impl : ( '}' ) ; | ||
20937 | public final void rule__ALSPreficed__Group_6__6__Impl() throws RecognitionException { | ||
20938 | |||
20939 | int stackSize = keepStackSize(); | ||
20940 | |||
20941 | try { | ||
20942 | // InternalAlloyLanguage.g:7366:1: ( ( '}' ) ) | ||
20943 | // InternalAlloyLanguage.g:7367:1: ( '}' ) | ||
20944 | { | ||
20945 | // InternalAlloyLanguage.g:7367:1: ( '}' ) | ||
20946 | // InternalAlloyLanguage.g:7368:1: '}' | ||
20947 | { | ||
20948 | if ( state.backtracking==0 ) { | ||
20949 | before(grammarAccess.getALSPreficedAccess().getRightCurlyBracketKeyword_6_6()); | ||
20950 | } | ||
20951 | match(input,34,FOLLOW_2); if (state.failed) return ; | ||
20952 | if ( state.backtracking==0 ) { | ||
20953 | after(grammarAccess.getALSPreficedAccess().getRightCurlyBracketKeyword_6_6()); | ||
20954 | } | ||
20955 | |||
20956 | } | ||
20957 | |||
20958 | |||
20959 | } | ||
20960 | |||
20961 | } | ||
20962 | catch (RecognitionException re) { | ||
20963 | reportError(re); | ||
20964 | recover(input,re); | ||
20965 | } | ||
20966 | finally { | ||
20967 | |||
20968 | restoreStackSize(stackSize); | ||
20969 | |||
20970 | } | ||
20971 | return ; | ||
20972 | } | ||
20973 | // $ANTLR end "rule__ALSPreficed__Group_6__6__Impl" | ||
20974 | |||
20975 | |||
20976 | // $ANTLR start "rule__ALSPreficed__Group_6_3__0" | ||
20977 | // InternalAlloyLanguage.g:7395:1: rule__ALSPreficed__Group_6_3__0 : rule__ALSPreficed__Group_6_3__0__Impl rule__ALSPreficed__Group_6_3__1 ; | ||
20978 | public final void rule__ALSPreficed__Group_6_3__0() throws RecognitionException { | ||
20979 | |||
20980 | int stackSize = keepStackSize(); | ||
20981 | |||
20982 | try { | ||
20983 | // InternalAlloyLanguage.g:7399:1: ( rule__ALSPreficed__Group_6_3__0__Impl rule__ALSPreficed__Group_6_3__1 ) | ||
20984 | // InternalAlloyLanguage.g:7400:2: rule__ALSPreficed__Group_6_3__0__Impl rule__ALSPreficed__Group_6_3__1 | ||
20985 | { | ||
20986 | pushFollow(FOLLOW_5); | ||
20987 | rule__ALSPreficed__Group_6_3__0__Impl(); | ||
20988 | |||
20989 | state._fsp--; | ||
20990 | if (state.failed) return ; | ||
20991 | pushFollow(FOLLOW_2); | ||
20992 | rule__ALSPreficed__Group_6_3__1(); | ||
20993 | |||
20994 | state._fsp--; | ||
20995 | if (state.failed) return ; | ||
20996 | |||
20997 | } | ||
20998 | |||
20999 | } | ||
21000 | catch (RecognitionException re) { | ||
21001 | reportError(re); | ||
21002 | recover(input,re); | ||
21003 | } | ||
21004 | finally { | ||
21005 | |||
21006 | restoreStackSize(stackSize); | ||
21007 | |||
21008 | } | ||
21009 | return ; | ||
21010 | } | ||
21011 | // $ANTLR end "rule__ALSPreficed__Group_6_3__0" | ||
21012 | |||
21013 | |||
21014 | // $ANTLR start "rule__ALSPreficed__Group_6_3__0__Impl" | ||
21015 | // InternalAlloyLanguage.g:7407:1: rule__ALSPreficed__Group_6_3__0__Impl : ( ',' ) ; | ||
21016 | public final void rule__ALSPreficed__Group_6_3__0__Impl() throws RecognitionException { | ||
21017 | |||
21018 | int stackSize = keepStackSize(); | ||
21019 | |||
21020 | try { | ||
21021 | // InternalAlloyLanguage.g:7411:1: ( ( ',' ) ) | ||
21022 | // InternalAlloyLanguage.g:7412:1: ( ',' ) | ||
21023 | { | ||
21024 | // InternalAlloyLanguage.g:7412:1: ( ',' ) | ||
21025 | // InternalAlloyLanguage.g:7413:1: ',' | ||
21026 | { | ||
21027 | if ( state.backtracking==0 ) { | ||
21028 | before(grammarAccess.getALSPreficedAccess().getCommaKeyword_6_3_0()); | ||
21029 | } | ||
21030 | match(input,35,FOLLOW_2); if (state.failed) return ; | ||
21031 | if ( state.backtracking==0 ) { | ||
21032 | after(grammarAccess.getALSPreficedAccess().getCommaKeyword_6_3_0()); | ||
21033 | } | ||
21034 | |||
21035 | } | ||
21036 | |||
21037 | |||
21038 | } | ||
21039 | |||
21040 | } | ||
21041 | catch (RecognitionException re) { | ||
21042 | reportError(re); | ||
21043 | recover(input,re); | ||
21044 | } | ||
21045 | finally { | ||
21046 | |||
21047 | restoreStackSize(stackSize); | ||
21048 | |||
21049 | } | ||
21050 | return ; | ||
21051 | } | ||
21052 | // $ANTLR end "rule__ALSPreficed__Group_6_3__0__Impl" | ||
21053 | |||
21054 | |||
21055 | // $ANTLR start "rule__ALSPreficed__Group_6_3__1" | ||
21056 | // InternalAlloyLanguage.g:7426:1: rule__ALSPreficed__Group_6_3__1 : rule__ALSPreficed__Group_6_3__1__Impl ; | ||
21057 | public final void rule__ALSPreficed__Group_6_3__1() throws RecognitionException { | ||
21058 | |||
21059 | int stackSize = keepStackSize(); | ||
21060 | |||
21061 | try { | ||
21062 | // InternalAlloyLanguage.g:7430:1: ( rule__ALSPreficed__Group_6_3__1__Impl ) | ||
21063 | // InternalAlloyLanguage.g:7431:2: rule__ALSPreficed__Group_6_3__1__Impl | ||
21064 | { | ||
21065 | pushFollow(FOLLOW_2); | ||
21066 | rule__ALSPreficed__Group_6_3__1__Impl(); | ||
21067 | |||
21068 | state._fsp--; | ||
21069 | if (state.failed) return ; | ||
21070 | |||
21071 | } | ||
21072 | |||
21073 | } | ||
21074 | catch (RecognitionException re) { | ||
21075 | reportError(re); | ||
21076 | recover(input,re); | ||
21077 | } | ||
21078 | finally { | ||
21079 | |||
21080 | restoreStackSize(stackSize); | ||
21081 | |||
21082 | } | ||
21083 | return ; | ||
21084 | } | ||
21085 | // $ANTLR end "rule__ALSPreficed__Group_6_3__1" | ||
21086 | |||
21087 | |||
21088 | // $ANTLR start "rule__ALSPreficed__Group_6_3__1__Impl" | ||
21089 | // InternalAlloyLanguage.g:7437:1: rule__ALSPreficed__Group_6_3__1__Impl : ( ( rule__ALSPreficed__VariablesAssignment_6_3_1 ) ) ; | ||
21090 | public final void rule__ALSPreficed__Group_6_3__1__Impl() throws RecognitionException { | ||
21091 | |||
21092 | int stackSize = keepStackSize(); | ||
21093 | |||
21094 | try { | ||
21095 | // InternalAlloyLanguage.g:7441:1: ( ( ( rule__ALSPreficed__VariablesAssignment_6_3_1 ) ) ) | ||
21096 | // InternalAlloyLanguage.g:7442:1: ( ( rule__ALSPreficed__VariablesAssignment_6_3_1 ) ) | ||
21097 | { | ||
21098 | // InternalAlloyLanguage.g:7442:1: ( ( rule__ALSPreficed__VariablesAssignment_6_3_1 ) ) | ||
21099 | // InternalAlloyLanguage.g:7443:1: ( rule__ALSPreficed__VariablesAssignment_6_3_1 ) | ||
21100 | { | ||
21101 | if ( state.backtracking==0 ) { | ||
21102 | before(grammarAccess.getALSPreficedAccess().getVariablesAssignment_6_3_1()); | ||
21103 | } | ||
21104 | // InternalAlloyLanguage.g:7444:1: ( rule__ALSPreficed__VariablesAssignment_6_3_1 ) | ||
21105 | // InternalAlloyLanguage.g:7444:2: rule__ALSPreficed__VariablesAssignment_6_3_1 | ||
21106 | { | ||
21107 | pushFollow(FOLLOW_2); | ||
21108 | rule__ALSPreficed__VariablesAssignment_6_3_1(); | ||
21109 | |||
21110 | state._fsp--; | ||
21111 | if (state.failed) return ; | ||
21112 | |||
21113 | } | ||
21114 | |||
21115 | if ( state.backtracking==0 ) { | ||
21116 | after(grammarAccess.getALSPreficedAccess().getVariablesAssignment_6_3_1()); | ||
21117 | } | ||
21118 | |||
21119 | } | ||
21120 | |||
21121 | |||
21122 | } | ||
21123 | |||
21124 | } | ||
21125 | catch (RecognitionException re) { | ||
21126 | reportError(re); | ||
21127 | recover(input,re); | ||
21128 | } | ||
21129 | finally { | ||
21130 | |||
21131 | restoreStackSize(stackSize); | ||
21132 | |||
21133 | } | ||
21134 | return ; | ||
21135 | } | ||
21136 | // $ANTLR end "rule__ALSPreficed__Group_6_3__1__Impl" | ||
21137 | |||
21138 | |||
21139 | // $ANTLR start "rule__ALSPreficed__Group_7__0" | ||
21140 | // InternalAlloyLanguage.g:7458:1: rule__ALSPreficed__Group_7__0 : rule__ALSPreficed__Group_7__0__Impl rule__ALSPreficed__Group_7__1 ; | ||
21141 | public final void rule__ALSPreficed__Group_7__0() throws RecognitionException { | ||
21142 | |||
21143 | int stackSize = keepStackSize(); | ||
21144 | |||
21145 | try { | ||
21146 | // InternalAlloyLanguage.g:7462:1: ( rule__ALSPreficed__Group_7__0__Impl rule__ALSPreficed__Group_7__1 ) | ||
21147 | // InternalAlloyLanguage.g:7463:2: rule__ALSPreficed__Group_7__0__Impl rule__ALSPreficed__Group_7__1 | ||
21148 | { | ||
21149 | pushFollow(FOLLOW_53); | ||
21150 | rule__ALSPreficed__Group_7__0__Impl(); | ||
21151 | |||
21152 | state._fsp--; | ||
21153 | if (state.failed) return ; | ||
21154 | pushFollow(FOLLOW_2); | ||
21155 | rule__ALSPreficed__Group_7__1(); | ||
21156 | |||
21157 | state._fsp--; | ||
21158 | if (state.failed) return ; | ||
21159 | |||
21160 | } | ||
21161 | |||
21162 | } | ||
21163 | catch (RecognitionException re) { | ||
21164 | reportError(re); | ||
21165 | recover(input,re); | ||
21166 | } | ||
21167 | finally { | ||
21168 | |||
21169 | restoreStackSize(stackSize); | ||
21170 | |||
21171 | } | ||
21172 | return ; | ||
21173 | } | ||
21174 | // $ANTLR end "rule__ALSPreficed__Group_7__0" | ||
21175 | |||
21176 | |||
21177 | // $ANTLR start "rule__ALSPreficed__Group_7__0__Impl" | ||
21178 | // InternalAlloyLanguage.g:7470:1: rule__ALSPreficed__Group_7__0__Impl : ( () ) ; | ||
21179 | public final void rule__ALSPreficed__Group_7__0__Impl() throws RecognitionException { | ||
21180 | |||
21181 | int stackSize = keepStackSize(); | ||
21182 | |||
21183 | try { | ||
21184 | // InternalAlloyLanguage.g:7474:1: ( ( () ) ) | ||
21185 | // InternalAlloyLanguage.g:7475:1: ( () ) | ||
21186 | { | ||
21187 | // InternalAlloyLanguage.g:7475:1: ( () ) | ||
21188 | // InternalAlloyLanguage.g:7476:1: () | ||
21189 | { | ||
21190 | if ( state.backtracking==0 ) { | ||
21191 | before(grammarAccess.getALSPreficedAccess().getALSFunctionCallAction_7_0()); | ||
21192 | } | ||
21193 | // InternalAlloyLanguage.g:7477:1: () | ||
21194 | // InternalAlloyLanguage.g:7479:1: | ||
21195 | { | ||
21196 | } | ||
21197 | |||
21198 | if ( state.backtracking==0 ) { | ||
21199 | after(grammarAccess.getALSPreficedAccess().getALSFunctionCallAction_7_0()); | ||
21200 | } | ||
21201 | |||
21202 | } | ||
21203 | |||
21204 | |||
21205 | } | ||
21206 | |||
21207 | } | ||
21208 | finally { | ||
21209 | |||
21210 | restoreStackSize(stackSize); | ||
21211 | |||
21212 | } | ||
21213 | return ; | ||
21214 | } | ||
21215 | // $ANTLR end "rule__ALSPreficed__Group_7__0__Impl" | ||
21216 | |||
21217 | |||
21218 | // $ANTLR start "rule__ALSPreficed__Group_7__1" | ||
21219 | // InternalAlloyLanguage.g:7489:1: rule__ALSPreficed__Group_7__1 : rule__ALSPreficed__Group_7__1__Impl rule__ALSPreficed__Group_7__2 ; | ||
21220 | public final void rule__ALSPreficed__Group_7__1() throws RecognitionException { | ||
21221 | |||
21222 | int stackSize = keepStackSize(); | ||
21223 | |||
21224 | try { | ||
21225 | // InternalAlloyLanguage.g:7493:1: ( rule__ALSPreficed__Group_7__1__Impl rule__ALSPreficed__Group_7__2 ) | ||
21226 | // InternalAlloyLanguage.g:7494:2: rule__ALSPreficed__Group_7__1__Impl rule__ALSPreficed__Group_7__2 | ||
21227 | { | ||
21228 | pushFollow(FOLLOW_17); | ||
21229 | rule__ALSPreficed__Group_7__1__Impl(); | ||
21230 | |||
21231 | state._fsp--; | ||
21232 | if (state.failed) return ; | ||
21233 | pushFollow(FOLLOW_2); | ||
21234 | rule__ALSPreficed__Group_7__2(); | ||
21235 | |||
21236 | state._fsp--; | ||
21237 | if (state.failed) return ; | ||
21238 | |||
21239 | } | ||
21240 | |||
21241 | } | ||
21242 | catch (RecognitionException re) { | ||
21243 | reportError(re); | ||
21244 | recover(input,re); | ||
21245 | } | ||
21246 | finally { | ||
21247 | |||
21248 | restoreStackSize(stackSize); | ||
21249 | |||
21250 | } | ||
21251 | return ; | ||
21252 | } | ||
21253 | // $ANTLR end "rule__ALSPreficed__Group_7__1" | ||
21254 | |||
21255 | |||
21256 | // $ANTLR start "rule__ALSPreficed__Group_7__1__Impl" | ||
21257 | // InternalAlloyLanguage.g:7501:1: rule__ALSPreficed__Group_7__1__Impl : ( ( rule__ALSPreficed__Alternatives_7_1 ) ) ; | ||
21258 | public final void rule__ALSPreficed__Group_7__1__Impl() throws RecognitionException { | ||
21259 | |||
21260 | int stackSize = keepStackSize(); | ||
21261 | |||
21262 | try { | ||
21263 | // InternalAlloyLanguage.g:7505:1: ( ( ( rule__ALSPreficed__Alternatives_7_1 ) ) ) | ||
21264 | // InternalAlloyLanguage.g:7506:1: ( ( rule__ALSPreficed__Alternatives_7_1 ) ) | ||
21265 | { | ||
21266 | // InternalAlloyLanguage.g:7506:1: ( ( rule__ALSPreficed__Alternatives_7_1 ) ) | ||
21267 | // InternalAlloyLanguage.g:7507:1: ( rule__ALSPreficed__Alternatives_7_1 ) | ||
21268 | { | ||
21269 | if ( state.backtracking==0 ) { | ||
21270 | before(grammarAccess.getALSPreficedAccess().getAlternatives_7_1()); | ||
21271 | } | ||
21272 | // InternalAlloyLanguage.g:7508:1: ( rule__ALSPreficed__Alternatives_7_1 ) | ||
21273 | // InternalAlloyLanguage.g:7508:2: rule__ALSPreficed__Alternatives_7_1 | ||
21274 | { | ||
21275 | pushFollow(FOLLOW_2); | ||
21276 | rule__ALSPreficed__Alternatives_7_1(); | ||
21277 | |||
21278 | state._fsp--; | ||
21279 | if (state.failed) return ; | ||
21280 | |||
21281 | } | ||
21282 | |||
21283 | if ( state.backtracking==0 ) { | ||
21284 | after(grammarAccess.getALSPreficedAccess().getAlternatives_7_1()); | ||
21285 | } | ||
21286 | |||
21287 | } | ||
21288 | |||
21289 | |||
21290 | } | ||
21291 | |||
21292 | } | ||
21293 | catch (RecognitionException re) { | ||
21294 | reportError(re); | ||
21295 | recover(input,re); | ||
21296 | } | ||
21297 | finally { | ||
21298 | |||
21299 | restoreStackSize(stackSize); | ||
21300 | |||
21301 | } | ||
21302 | return ; | ||
21303 | } | ||
21304 | // $ANTLR end "rule__ALSPreficed__Group_7__1__Impl" | ||
21305 | |||
21306 | |||
21307 | // $ANTLR start "rule__ALSPreficed__Group_7__2" | ||
21308 | // InternalAlloyLanguage.g:7518:1: rule__ALSPreficed__Group_7__2 : rule__ALSPreficed__Group_7__2__Impl rule__ALSPreficed__Group_7__3 ; | ||
21309 | public final void rule__ALSPreficed__Group_7__2() throws RecognitionException { | ||
21310 | |||
21311 | int stackSize = keepStackSize(); | ||
21312 | |||
21313 | try { | ||
21314 | // InternalAlloyLanguage.g:7522:1: ( rule__ALSPreficed__Group_7__2__Impl rule__ALSPreficed__Group_7__3 ) | ||
21315 | // InternalAlloyLanguage.g:7523:2: rule__ALSPreficed__Group_7__2__Impl rule__ALSPreficed__Group_7__3 | ||
21316 | { | ||
21317 | pushFollow(FOLLOW_16); | ||
21318 | rule__ALSPreficed__Group_7__2__Impl(); | ||
21319 | |||
21320 | state._fsp--; | ||
21321 | if (state.failed) return ; | ||
21322 | pushFollow(FOLLOW_2); | ||
21323 | rule__ALSPreficed__Group_7__3(); | ||
21324 | |||
21325 | state._fsp--; | ||
21326 | if (state.failed) return ; | ||
21327 | |||
21328 | } | ||
21329 | |||
21330 | } | ||
21331 | catch (RecognitionException re) { | ||
21332 | reportError(re); | ||
21333 | recover(input,re); | ||
21334 | } | ||
21335 | finally { | ||
21336 | |||
21337 | restoreStackSize(stackSize); | ||
21338 | |||
21339 | } | ||
21340 | return ; | ||
21341 | } | ||
21342 | // $ANTLR end "rule__ALSPreficed__Group_7__2" | ||
21343 | |||
21344 | |||
21345 | // $ANTLR start "rule__ALSPreficed__Group_7__2__Impl" | ||
21346 | // InternalAlloyLanguage.g:7530:1: rule__ALSPreficed__Group_7__2__Impl : ( '[' ) ; | ||
21347 | public final void rule__ALSPreficed__Group_7__2__Impl() throws RecognitionException { | ||
21348 | |||
21349 | int stackSize = keepStackSize(); | ||
21350 | |||
21351 | try { | ||
21352 | // InternalAlloyLanguage.g:7534:1: ( ( '[' ) ) | ||
21353 | // InternalAlloyLanguage.g:7535:1: ( '[' ) | ||
21354 | { | ||
21355 | // InternalAlloyLanguage.g:7535:1: ( '[' ) | ||
21356 | // InternalAlloyLanguage.g:7536:1: '[' | ||
21357 | { | ||
21358 | if ( state.backtracking==0 ) { | ||
21359 | before(grammarAccess.getALSPreficedAccess().getLeftSquareBracketKeyword_7_2()); | ||
21360 | } | ||
21361 | match(input,42,FOLLOW_2); if (state.failed) return ; | ||
21362 | if ( state.backtracking==0 ) { | ||
21363 | after(grammarAccess.getALSPreficedAccess().getLeftSquareBracketKeyword_7_2()); | ||
21364 | } | ||
21365 | |||
21366 | } | ||
21367 | |||
21368 | |||
21369 | } | ||
21370 | |||
21371 | } | ||
21372 | catch (RecognitionException re) { | ||
21373 | reportError(re); | ||
21374 | recover(input,re); | ||
21375 | } | ||
21376 | finally { | ||
21377 | |||
21378 | restoreStackSize(stackSize); | ||
21379 | |||
21380 | } | ||
21381 | return ; | ||
21382 | } | ||
21383 | // $ANTLR end "rule__ALSPreficed__Group_7__2__Impl" | ||
21384 | |||
21385 | |||
21386 | // $ANTLR start "rule__ALSPreficed__Group_7__3" | ||
21387 | // InternalAlloyLanguage.g:7549:1: rule__ALSPreficed__Group_7__3 : rule__ALSPreficed__Group_7__3__Impl rule__ALSPreficed__Group_7__4 ; | ||
21388 | public final void rule__ALSPreficed__Group_7__3() throws RecognitionException { | ||
21389 | |||
21390 | int stackSize = keepStackSize(); | ||
21391 | |||
21392 | try { | ||
21393 | // InternalAlloyLanguage.g:7553:1: ( rule__ALSPreficed__Group_7__3__Impl rule__ALSPreficed__Group_7__4 ) | ||
21394 | // InternalAlloyLanguage.g:7554:2: rule__ALSPreficed__Group_7__3__Impl rule__ALSPreficed__Group_7__4 | ||
21395 | { | ||
21396 | pushFollow(FOLLOW_18); | ||
21397 | rule__ALSPreficed__Group_7__3__Impl(); | ||
21398 | |||
21399 | state._fsp--; | ||
21400 | if (state.failed) return ; | ||
21401 | pushFollow(FOLLOW_2); | ||
21402 | rule__ALSPreficed__Group_7__4(); | ||
21403 | |||
21404 | state._fsp--; | ||
21405 | if (state.failed) return ; | ||
21406 | |||
21407 | } | ||
21408 | |||
21409 | } | ||
21410 | catch (RecognitionException re) { | ||
21411 | reportError(re); | ||
21412 | recover(input,re); | ||
21413 | } | ||
21414 | finally { | ||
21415 | |||
21416 | restoreStackSize(stackSize); | ||
21417 | |||
21418 | } | ||
21419 | return ; | ||
21420 | } | ||
21421 | // $ANTLR end "rule__ALSPreficed__Group_7__3" | ||
21422 | |||
21423 | |||
21424 | // $ANTLR start "rule__ALSPreficed__Group_7__3__Impl" | ||
21425 | // InternalAlloyLanguage.g:7561:1: rule__ALSPreficed__Group_7__3__Impl : ( ( rule__ALSPreficed__ParamsAssignment_7_3 ) ) ; | ||
21426 | public final void rule__ALSPreficed__Group_7__3__Impl() throws RecognitionException { | ||
21427 | |||
21428 | int stackSize = keepStackSize(); | ||
21429 | |||
21430 | try { | ||
21431 | // InternalAlloyLanguage.g:7565:1: ( ( ( rule__ALSPreficed__ParamsAssignment_7_3 ) ) ) | ||
21432 | // InternalAlloyLanguage.g:7566:1: ( ( rule__ALSPreficed__ParamsAssignment_7_3 ) ) | ||
21433 | { | ||
21434 | // InternalAlloyLanguage.g:7566:1: ( ( rule__ALSPreficed__ParamsAssignment_7_3 ) ) | ||
21435 | // InternalAlloyLanguage.g:7567:1: ( rule__ALSPreficed__ParamsAssignment_7_3 ) | ||
21436 | { | ||
21437 | if ( state.backtracking==0 ) { | ||
21438 | before(grammarAccess.getALSPreficedAccess().getParamsAssignment_7_3()); | ||
21439 | } | ||
21440 | // InternalAlloyLanguage.g:7568:1: ( rule__ALSPreficed__ParamsAssignment_7_3 ) | ||
21441 | // InternalAlloyLanguage.g:7568:2: rule__ALSPreficed__ParamsAssignment_7_3 | ||
21442 | { | ||
21443 | pushFollow(FOLLOW_2); | ||
21444 | rule__ALSPreficed__ParamsAssignment_7_3(); | ||
21445 | |||
21446 | state._fsp--; | ||
21447 | if (state.failed) return ; | ||
21448 | |||
21449 | } | ||
21450 | |||
21451 | if ( state.backtracking==0 ) { | ||
21452 | after(grammarAccess.getALSPreficedAccess().getParamsAssignment_7_3()); | ||
21453 | } | ||
21454 | |||
21455 | } | ||
21456 | |||
21457 | |||
21458 | } | ||
21459 | |||
21460 | } | ||
21461 | catch (RecognitionException re) { | ||
21462 | reportError(re); | ||
21463 | recover(input,re); | ||
21464 | } | ||
21465 | finally { | ||
21466 | |||
21467 | restoreStackSize(stackSize); | ||
21468 | |||
21469 | } | ||
21470 | return ; | ||
21471 | } | ||
21472 | // $ANTLR end "rule__ALSPreficed__Group_7__3__Impl" | ||
21473 | |||
21474 | |||
21475 | // $ANTLR start "rule__ALSPreficed__Group_7__4" | ||
21476 | // InternalAlloyLanguage.g:7578:1: rule__ALSPreficed__Group_7__4 : rule__ALSPreficed__Group_7__4__Impl rule__ALSPreficed__Group_7__5 ; | ||
21477 | public final void rule__ALSPreficed__Group_7__4() throws RecognitionException { | ||
21478 | |||
21479 | int stackSize = keepStackSize(); | ||
21480 | |||
21481 | try { | ||
21482 | // InternalAlloyLanguage.g:7582:1: ( rule__ALSPreficed__Group_7__4__Impl rule__ALSPreficed__Group_7__5 ) | ||
21483 | // InternalAlloyLanguage.g:7583:2: rule__ALSPreficed__Group_7__4__Impl rule__ALSPreficed__Group_7__5 | ||
21484 | { | ||
21485 | pushFollow(FOLLOW_18); | ||
21486 | rule__ALSPreficed__Group_7__4__Impl(); | ||
21487 | |||
21488 | state._fsp--; | ||
21489 | if (state.failed) return ; | ||
21490 | pushFollow(FOLLOW_2); | ||
21491 | rule__ALSPreficed__Group_7__5(); | ||
21492 | |||
21493 | state._fsp--; | ||
21494 | if (state.failed) return ; | ||
21495 | |||
21496 | } | ||
21497 | |||
21498 | } | ||
21499 | catch (RecognitionException re) { | ||
21500 | reportError(re); | ||
21501 | recover(input,re); | ||
21502 | } | ||
21503 | finally { | ||
21504 | |||
21505 | restoreStackSize(stackSize); | ||
21506 | |||
21507 | } | ||
21508 | return ; | ||
21509 | } | ||
21510 | // $ANTLR end "rule__ALSPreficed__Group_7__4" | ||
21511 | |||
21512 | |||
21513 | // $ANTLR start "rule__ALSPreficed__Group_7__4__Impl" | ||
21514 | // InternalAlloyLanguage.g:7590:1: rule__ALSPreficed__Group_7__4__Impl : ( ( rule__ALSPreficed__Group_7_4__0 )* ) ; | ||
21515 | public final void rule__ALSPreficed__Group_7__4__Impl() throws RecognitionException { | ||
21516 | |||
21517 | int stackSize = keepStackSize(); | ||
21518 | |||
21519 | try { | ||
21520 | // InternalAlloyLanguage.g:7594:1: ( ( ( rule__ALSPreficed__Group_7_4__0 )* ) ) | ||
21521 | // InternalAlloyLanguage.g:7595:1: ( ( rule__ALSPreficed__Group_7_4__0 )* ) | ||
21522 | { | ||
21523 | // InternalAlloyLanguage.g:7595:1: ( ( rule__ALSPreficed__Group_7_4__0 )* ) | ||
21524 | // InternalAlloyLanguage.g:7596:1: ( rule__ALSPreficed__Group_7_4__0 )* | ||
21525 | { | ||
21526 | if ( state.backtracking==0 ) { | ||
21527 | before(grammarAccess.getALSPreficedAccess().getGroup_7_4()); | ||
21528 | } | ||
21529 | // InternalAlloyLanguage.g:7597:1: ( rule__ALSPreficed__Group_7_4__0 )* | ||
21530 | loop47: | ||
21531 | do { | ||
21532 | int alt47=2; | ||
21533 | int LA47_0 = input.LA(1); | ||
21534 | |||
21535 | if ( (LA47_0==35) ) { | ||
21536 | alt47=1; | ||
21537 | } | ||
21538 | |||
21539 | |||
21540 | switch (alt47) { | ||
21541 | case 1 : | ||
21542 | // InternalAlloyLanguage.g:7597:2: rule__ALSPreficed__Group_7_4__0 | ||
21543 | { | ||
21544 | pushFollow(FOLLOW_8); | ||
21545 | rule__ALSPreficed__Group_7_4__0(); | ||
21546 | |||
21547 | state._fsp--; | ||
21548 | if (state.failed) return ; | ||
21549 | |||
21550 | } | ||
21551 | break; | ||
21552 | |||
21553 | default : | ||
21554 | break loop47; | ||
21555 | } | ||
21556 | } while (true); | ||
21557 | |||
21558 | if ( state.backtracking==0 ) { | ||
21559 | after(grammarAccess.getALSPreficedAccess().getGroup_7_4()); | ||
21560 | } | ||
21561 | |||
21562 | } | ||
21563 | |||
21564 | |||
21565 | } | ||
21566 | |||
21567 | } | ||
21568 | catch (RecognitionException re) { | ||
21569 | reportError(re); | ||
21570 | recover(input,re); | ||
21571 | } | ||
21572 | finally { | ||
21573 | |||
21574 | restoreStackSize(stackSize); | ||
21575 | |||
21576 | } | ||
21577 | return ; | ||
21578 | } | ||
21579 | // $ANTLR end "rule__ALSPreficed__Group_7__4__Impl" | ||
21580 | |||
21581 | |||
21582 | // $ANTLR start "rule__ALSPreficed__Group_7__5" | ||
21583 | // InternalAlloyLanguage.g:7607:1: rule__ALSPreficed__Group_7__5 : rule__ALSPreficed__Group_7__5__Impl ; | ||
21584 | public final void rule__ALSPreficed__Group_7__5() throws RecognitionException { | ||
21585 | |||
21586 | int stackSize = keepStackSize(); | ||
21587 | |||
21588 | try { | ||
21589 | // InternalAlloyLanguage.g:7611:1: ( rule__ALSPreficed__Group_7__5__Impl ) | ||
21590 | // InternalAlloyLanguage.g:7612:2: rule__ALSPreficed__Group_7__5__Impl | ||
21591 | { | ||
21592 | pushFollow(FOLLOW_2); | ||
21593 | rule__ALSPreficed__Group_7__5__Impl(); | ||
21594 | |||
21595 | state._fsp--; | ||
21596 | if (state.failed) return ; | ||
21597 | |||
21598 | } | ||
21599 | |||
21600 | } | ||
21601 | catch (RecognitionException re) { | ||
21602 | reportError(re); | ||
21603 | recover(input,re); | ||
21604 | } | ||
21605 | finally { | ||
21606 | |||
21607 | restoreStackSize(stackSize); | ||
21608 | |||
21609 | } | ||
21610 | return ; | ||
21611 | } | ||
21612 | // $ANTLR end "rule__ALSPreficed__Group_7__5" | ||
21613 | |||
21614 | |||
21615 | // $ANTLR start "rule__ALSPreficed__Group_7__5__Impl" | ||
21616 | // InternalAlloyLanguage.g:7618:1: rule__ALSPreficed__Group_7__5__Impl : ( ']' ) ; | ||
21617 | public final void rule__ALSPreficed__Group_7__5__Impl() throws RecognitionException { | ||
21618 | |||
21619 | int stackSize = keepStackSize(); | ||
21620 | |||
21621 | try { | ||
21622 | // InternalAlloyLanguage.g:7622:1: ( ( ']' ) ) | ||
21623 | // InternalAlloyLanguage.g:7623:1: ( ']' ) | ||
21624 | { | ||
21625 | // InternalAlloyLanguage.g:7623:1: ( ']' ) | ||
21626 | // InternalAlloyLanguage.g:7624:1: ']' | ||
21627 | { | ||
21628 | if ( state.backtracking==0 ) { | ||
21629 | before(grammarAccess.getALSPreficedAccess().getRightSquareBracketKeyword_7_5()); | ||
21630 | } | ||
21631 | match(input,43,FOLLOW_2); if (state.failed) return ; | ||
21632 | if ( state.backtracking==0 ) { | ||
21633 | after(grammarAccess.getALSPreficedAccess().getRightSquareBracketKeyword_7_5()); | ||
21634 | } | ||
21635 | |||
21636 | } | ||
21637 | |||
21638 | |||
21639 | } | ||
21640 | |||
21641 | } | ||
21642 | catch (RecognitionException re) { | ||
21643 | reportError(re); | ||
21644 | recover(input,re); | ||
21645 | } | ||
21646 | finally { | ||
21647 | |||
21648 | restoreStackSize(stackSize); | ||
21649 | |||
21650 | } | ||
21651 | return ; | ||
21652 | } | ||
21653 | // $ANTLR end "rule__ALSPreficed__Group_7__5__Impl" | ||
21654 | |||
21655 | |||
21656 | // $ANTLR start "rule__ALSPreficed__Group_7_4__0" | ||
21657 | // InternalAlloyLanguage.g:7649:1: rule__ALSPreficed__Group_7_4__0 : rule__ALSPreficed__Group_7_4__0__Impl rule__ALSPreficed__Group_7_4__1 ; | ||
21658 | public final void rule__ALSPreficed__Group_7_4__0() throws RecognitionException { | ||
21659 | |||
21660 | int stackSize = keepStackSize(); | ||
21661 | |||
21662 | try { | ||
21663 | // InternalAlloyLanguage.g:7653:1: ( rule__ALSPreficed__Group_7_4__0__Impl rule__ALSPreficed__Group_7_4__1 ) | ||
21664 | // InternalAlloyLanguage.g:7654:2: rule__ALSPreficed__Group_7_4__0__Impl rule__ALSPreficed__Group_7_4__1 | ||
21665 | { | ||
21666 | pushFollow(FOLLOW_16); | ||
21667 | rule__ALSPreficed__Group_7_4__0__Impl(); | ||
21668 | |||
21669 | state._fsp--; | ||
21670 | if (state.failed) return ; | ||
21671 | pushFollow(FOLLOW_2); | ||
21672 | rule__ALSPreficed__Group_7_4__1(); | ||
21673 | |||
21674 | state._fsp--; | ||
21675 | if (state.failed) return ; | ||
21676 | |||
21677 | } | ||
21678 | |||
21679 | } | ||
21680 | catch (RecognitionException re) { | ||
21681 | reportError(re); | ||
21682 | recover(input,re); | ||
21683 | } | ||
21684 | finally { | ||
21685 | |||
21686 | restoreStackSize(stackSize); | ||
21687 | |||
21688 | } | ||
21689 | return ; | ||
21690 | } | ||
21691 | // $ANTLR end "rule__ALSPreficed__Group_7_4__0" | ||
21692 | |||
21693 | |||
21694 | // $ANTLR start "rule__ALSPreficed__Group_7_4__0__Impl" | ||
21695 | // InternalAlloyLanguage.g:7661:1: rule__ALSPreficed__Group_7_4__0__Impl : ( ',' ) ; | ||
21696 | public final void rule__ALSPreficed__Group_7_4__0__Impl() throws RecognitionException { | ||
21697 | |||
21698 | int stackSize = keepStackSize(); | ||
21699 | |||
21700 | try { | ||
21701 | // InternalAlloyLanguage.g:7665:1: ( ( ',' ) ) | ||
21702 | // InternalAlloyLanguage.g:7666:1: ( ',' ) | ||
21703 | { | ||
21704 | // InternalAlloyLanguage.g:7666:1: ( ',' ) | ||
21705 | // InternalAlloyLanguage.g:7667:1: ',' | ||
21706 | { | ||
21707 | if ( state.backtracking==0 ) { | ||
21708 | before(grammarAccess.getALSPreficedAccess().getCommaKeyword_7_4_0()); | ||
21709 | } | ||
21710 | match(input,35,FOLLOW_2); if (state.failed) return ; | ||
21711 | if ( state.backtracking==0 ) { | ||
21712 | after(grammarAccess.getALSPreficedAccess().getCommaKeyword_7_4_0()); | ||
21713 | } | ||
21714 | |||
21715 | } | ||
21716 | |||
21717 | |||
21718 | } | ||
21719 | |||
21720 | } | ||
21721 | catch (RecognitionException re) { | ||
21722 | reportError(re); | ||
21723 | recover(input,re); | ||
21724 | } | ||
21725 | finally { | ||
21726 | |||
21727 | restoreStackSize(stackSize); | ||
21728 | |||
21729 | } | ||
21730 | return ; | ||
21731 | } | ||
21732 | // $ANTLR end "rule__ALSPreficed__Group_7_4__0__Impl" | ||
21733 | |||
21734 | |||
21735 | // $ANTLR start "rule__ALSPreficed__Group_7_4__1" | ||
21736 | // InternalAlloyLanguage.g:7680:1: rule__ALSPreficed__Group_7_4__1 : rule__ALSPreficed__Group_7_4__1__Impl ; | ||
21737 | public final void rule__ALSPreficed__Group_7_4__1() throws RecognitionException { | ||
21738 | |||
21739 | int stackSize = keepStackSize(); | ||
21740 | |||
21741 | try { | ||
21742 | // InternalAlloyLanguage.g:7684:1: ( rule__ALSPreficed__Group_7_4__1__Impl ) | ||
21743 | // InternalAlloyLanguage.g:7685:2: rule__ALSPreficed__Group_7_4__1__Impl | ||
21744 | { | ||
21745 | pushFollow(FOLLOW_2); | ||
21746 | rule__ALSPreficed__Group_7_4__1__Impl(); | ||
21747 | |||
21748 | state._fsp--; | ||
21749 | if (state.failed) return ; | ||
21750 | |||
21751 | } | ||
21752 | |||
21753 | } | ||
21754 | catch (RecognitionException re) { | ||
21755 | reportError(re); | ||
21756 | recover(input,re); | ||
21757 | } | ||
21758 | finally { | ||
21759 | |||
21760 | restoreStackSize(stackSize); | ||
21761 | |||
21762 | } | ||
21763 | return ; | ||
21764 | } | ||
21765 | // $ANTLR end "rule__ALSPreficed__Group_7_4__1" | ||
21766 | |||
21767 | |||
21768 | // $ANTLR start "rule__ALSPreficed__Group_7_4__1__Impl" | ||
21769 | // InternalAlloyLanguage.g:7691:1: rule__ALSPreficed__Group_7_4__1__Impl : ( ( rule__ALSPreficed__ParamsAssignment_7_4_1 ) ) ; | ||
21770 | public final void rule__ALSPreficed__Group_7_4__1__Impl() throws RecognitionException { | ||
21771 | |||
21772 | int stackSize = keepStackSize(); | ||
21773 | |||
21774 | try { | ||
21775 | // InternalAlloyLanguage.g:7695:1: ( ( ( rule__ALSPreficed__ParamsAssignment_7_4_1 ) ) ) | ||
21776 | // InternalAlloyLanguage.g:7696:1: ( ( rule__ALSPreficed__ParamsAssignment_7_4_1 ) ) | ||
21777 | { | ||
21778 | // InternalAlloyLanguage.g:7696:1: ( ( rule__ALSPreficed__ParamsAssignment_7_4_1 ) ) | ||
21779 | // InternalAlloyLanguage.g:7697:1: ( rule__ALSPreficed__ParamsAssignment_7_4_1 ) | ||
21780 | { | ||
21781 | if ( state.backtracking==0 ) { | ||
21782 | before(grammarAccess.getALSPreficedAccess().getParamsAssignment_7_4_1()); | ||
21783 | } | ||
21784 | // InternalAlloyLanguage.g:7698:1: ( rule__ALSPreficed__ParamsAssignment_7_4_1 ) | ||
21785 | // InternalAlloyLanguage.g:7698:2: rule__ALSPreficed__ParamsAssignment_7_4_1 | ||
21786 | { | ||
21787 | pushFollow(FOLLOW_2); | ||
21788 | rule__ALSPreficed__ParamsAssignment_7_4_1(); | ||
21789 | |||
21790 | state._fsp--; | ||
21791 | if (state.failed) return ; | ||
21792 | |||
21793 | } | ||
21794 | |||
21795 | if ( state.backtracking==0 ) { | ||
21796 | after(grammarAccess.getALSPreficedAccess().getParamsAssignment_7_4_1()); | ||
21797 | } | ||
21798 | |||
21799 | } | ||
21800 | |||
21801 | |||
21802 | } | ||
21803 | |||
21804 | } | ||
21805 | catch (RecognitionException re) { | ||
21806 | reportError(re); | ||
21807 | recover(input,re); | ||
21808 | } | ||
21809 | finally { | ||
21810 | |||
21811 | restoreStackSize(stackSize); | ||
21812 | |||
21813 | } | ||
21814 | return ; | ||
21815 | } | ||
21816 | // $ANTLR end "rule__ALSPreficed__Group_7_4__1__Impl" | ||
21817 | |||
21818 | |||
21819 | // $ANTLR start "rule__ALSVariableDeclaration__Group__0" | ||
21820 | // InternalAlloyLanguage.g:7712:1: rule__ALSVariableDeclaration__Group__0 : rule__ALSVariableDeclaration__Group__0__Impl rule__ALSVariableDeclaration__Group__1 ; | ||
21821 | public final void rule__ALSVariableDeclaration__Group__0() throws RecognitionException { | ||
21822 | |||
21823 | int stackSize = keepStackSize(); | ||
21824 | |||
21825 | try { | ||
21826 | // InternalAlloyLanguage.g:7716:1: ( rule__ALSVariableDeclaration__Group__0__Impl rule__ALSVariableDeclaration__Group__1 ) | ||
21827 | // InternalAlloyLanguage.g:7717:2: rule__ALSVariableDeclaration__Group__0__Impl rule__ALSVariableDeclaration__Group__1 | ||
21828 | { | ||
21829 | pushFollow(FOLLOW_15); | ||
21830 | rule__ALSVariableDeclaration__Group__0__Impl(); | ||
21831 | |||
21832 | state._fsp--; | ||
21833 | if (state.failed) return ; | ||
21834 | pushFollow(FOLLOW_2); | ||
21835 | rule__ALSVariableDeclaration__Group__1(); | ||
21836 | |||
21837 | state._fsp--; | ||
21838 | if (state.failed) return ; | ||
21839 | |||
21840 | } | ||
21841 | |||
21842 | } | ||
21843 | catch (RecognitionException re) { | ||
21844 | reportError(re); | ||
21845 | recover(input,re); | ||
21846 | } | ||
21847 | finally { | ||
21848 | |||
21849 | restoreStackSize(stackSize); | ||
21850 | |||
21851 | } | ||
21852 | return ; | ||
21853 | } | ||
21854 | // $ANTLR end "rule__ALSVariableDeclaration__Group__0" | ||
21855 | |||
21856 | |||
21857 | // $ANTLR start "rule__ALSVariableDeclaration__Group__0__Impl" | ||
21858 | // InternalAlloyLanguage.g:7724:1: rule__ALSVariableDeclaration__Group__0__Impl : ( ( rule__ALSVariableDeclaration__NameAssignment_0 ) ) ; | ||
21859 | public final void rule__ALSVariableDeclaration__Group__0__Impl() throws RecognitionException { | ||
21860 | |||
21861 | int stackSize = keepStackSize(); | ||
21862 | |||
21863 | try { | ||
21864 | // InternalAlloyLanguage.g:7728:1: ( ( ( rule__ALSVariableDeclaration__NameAssignment_0 ) ) ) | ||
21865 | // InternalAlloyLanguage.g:7729:1: ( ( rule__ALSVariableDeclaration__NameAssignment_0 ) ) | ||
21866 | { | ||
21867 | // InternalAlloyLanguage.g:7729:1: ( ( rule__ALSVariableDeclaration__NameAssignment_0 ) ) | ||
21868 | // InternalAlloyLanguage.g:7730:1: ( rule__ALSVariableDeclaration__NameAssignment_0 ) | ||
21869 | { | ||
21870 | if ( state.backtracking==0 ) { | ||
21871 | before(grammarAccess.getALSVariableDeclarationAccess().getNameAssignment_0()); | ||
21872 | } | ||
21873 | // InternalAlloyLanguage.g:7731:1: ( rule__ALSVariableDeclaration__NameAssignment_0 ) | ||
21874 | // InternalAlloyLanguage.g:7731:2: rule__ALSVariableDeclaration__NameAssignment_0 | ||
21875 | { | ||
21876 | pushFollow(FOLLOW_2); | ||
21877 | rule__ALSVariableDeclaration__NameAssignment_0(); | ||
21878 | |||
21879 | state._fsp--; | ||
21880 | if (state.failed) return ; | ||
21881 | |||
21882 | } | ||
21883 | |||
21884 | if ( state.backtracking==0 ) { | ||
21885 | after(grammarAccess.getALSVariableDeclarationAccess().getNameAssignment_0()); | ||
21886 | } | ||
21887 | |||
21888 | } | ||
21889 | |||
21890 | |||
21891 | } | ||
21892 | |||
21893 | } | ||
21894 | catch (RecognitionException re) { | ||
21895 | reportError(re); | ||
21896 | recover(input,re); | ||
21897 | } | ||
21898 | finally { | ||
21899 | |||
21900 | restoreStackSize(stackSize); | ||
21901 | |||
21902 | } | ||
21903 | return ; | ||
21904 | } | ||
21905 | // $ANTLR end "rule__ALSVariableDeclaration__Group__0__Impl" | ||
21906 | |||
21907 | |||
21908 | // $ANTLR start "rule__ALSVariableDeclaration__Group__1" | ||
21909 | // InternalAlloyLanguage.g:7741:1: rule__ALSVariableDeclaration__Group__1 : rule__ALSVariableDeclaration__Group__1__Impl rule__ALSVariableDeclaration__Group__2 ; | ||
21910 | public final void rule__ALSVariableDeclaration__Group__1() throws RecognitionException { | ||
21911 | |||
21912 | int stackSize = keepStackSize(); | ||
21913 | |||
21914 | try { | ||
21915 | // InternalAlloyLanguage.g:7745:1: ( rule__ALSVariableDeclaration__Group__1__Impl rule__ALSVariableDeclaration__Group__2 ) | ||
21916 | // InternalAlloyLanguage.g:7746:2: rule__ALSVariableDeclaration__Group__1__Impl rule__ALSVariableDeclaration__Group__2 | ||
21917 | { | ||
21918 | pushFollow(FOLLOW_16); | ||
21919 | rule__ALSVariableDeclaration__Group__1__Impl(); | ||
21920 | |||
21921 | state._fsp--; | ||
21922 | if (state.failed) return ; | ||
21923 | pushFollow(FOLLOW_2); | ||
21924 | rule__ALSVariableDeclaration__Group__2(); | ||
21925 | |||
21926 | state._fsp--; | ||
21927 | if (state.failed) return ; | ||
21928 | |||
21929 | } | ||
21930 | |||
21931 | } | ||
21932 | catch (RecognitionException re) { | ||
21933 | reportError(re); | ||
21934 | recover(input,re); | ||
21935 | } | ||
21936 | finally { | ||
21937 | |||
21938 | restoreStackSize(stackSize); | ||
21939 | |||
21940 | } | ||
21941 | return ; | ||
21942 | } | ||
21943 | // $ANTLR end "rule__ALSVariableDeclaration__Group__1" | ||
21944 | |||
21945 | |||
21946 | // $ANTLR start "rule__ALSVariableDeclaration__Group__1__Impl" | ||
21947 | // InternalAlloyLanguage.g:7753:1: rule__ALSVariableDeclaration__Group__1__Impl : ( ':' ) ; | ||
21948 | public final void rule__ALSVariableDeclaration__Group__1__Impl() throws RecognitionException { | ||
21949 | |||
21950 | int stackSize = keepStackSize(); | ||
21951 | |||
21952 | try { | ||
21953 | // InternalAlloyLanguage.g:7757:1: ( ( ':' ) ) | ||
21954 | // InternalAlloyLanguage.g:7758:1: ( ':' ) | ||
21955 | { | ||
21956 | // InternalAlloyLanguage.g:7758:1: ( ':' ) | ||
21957 | // InternalAlloyLanguage.g:7759:1: ':' | ||
21958 | { | ||
21959 | if ( state.backtracking==0 ) { | ||
21960 | before(grammarAccess.getALSVariableDeclarationAccess().getColonKeyword_1()); | ||
21961 | } | ||
21962 | match(input,40,FOLLOW_2); if (state.failed) return ; | ||
21963 | if ( state.backtracking==0 ) { | ||
21964 | after(grammarAccess.getALSVariableDeclarationAccess().getColonKeyword_1()); | ||
21965 | } | ||
21966 | |||
21967 | } | ||
21968 | |||
21969 | |||
21970 | } | ||
21971 | |||
21972 | } | ||
21973 | catch (RecognitionException re) { | ||
21974 | reportError(re); | ||
21975 | recover(input,re); | ||
21976 | } | ||
21977 | finally { | ||
21978 | |||
21979 | restoreStackSize(stackSize); | ||
21980 | |||
21981 | } | ||
21982 | return ; | ||
21983 | } | ||
21984 | // $ANTLR end "rule__ALSVariableDeclaration__Group__1__Impl" | ||
21985 | |||
21986 | |||
21987 | // $ANTLR start "rule__ALSVariableDeclaration__Group__2" | ||
21988 | // InternalAlloyLanguage.g:7772:1: rule__ALSVariableDeclaration__Group__2 : rule__ALSVariableDeclaration__Group__2__Impl ; | ||
21989 | public final void rule__ALSVariableDeclaration__Group__2() throws RecognitionException { | ||
21990 | |||
21991 | int stackSize = keepStackSize(); | ||
21992 | |||
21993 | try { | ||
21994 | // InternalAlloyLanguage.g:7776:1: ( rule__ALSVariableDeclaration__Group__2__Impl ) | ||
21995 | // InternalAlloyLanguage.g:7777:2: rule__ALSVariableDeclaration__Group__2__Impl | ||
21996 | { | ||
21997 | pushFollow(FOLLOW_2); | ||
21998 | rule__ALSVariableDeclaration__Group__2__Impl(); | ||
21999 | |||
22000 | state._fsp--; | ||
22001 | if (state.failed) return ; | ||
22002 | |||
22003 | } | ||
22004 | |||
22005 | } | ||
22006 | catch (RecognitionException re) { | ||
22007 | reportError(re); | ||
22008 | recover(input,re); | ||
22009 | } | ||
22010 | finally { | ||
22011 | |||
22012 | restoreStackSize(stackSize); | ||
22013 | |||
22014 | } | ||
22015 | return ; | ||
22016 | } | ||
22017 | // $ANTLR end "rule__ALSVariableDeclaration__Group__2" | ||
22018 | |||
22019 | |||
22020 | // $ANTLR start "rule__ALSVariableDeclaration__Group__2__Impl" | ||
22021 | // InternalAlloyLanguage.g:7783:1: rule__ALSVariableDeclaration__Group__2__Impl : ( ( rule__ALSVariableDeclaration__RangeAssignment_2 ) ) ; | ||
22022 | public final void rule__ALSVariableDeclaration__Group__2__Impl() throws RecognitionException { | ||
22023 | |||
22024 | int stackSize = keepStackSize(); | ||
22025 | |||
22026 | try { | ||
22027 | // InternalAlloyLanguage.g:7787:1: ( ( ( rule__ALSVariableDeclaration__RangeAssignment_2 ) ) ) | ||
22028 | // InternalAlloyLanguage.g:7788:1: ( ( rule__ALSVariableDeclaration__RangeAssignment_2 ) ) | ||
22029 | { | ||
22030 | // InternalAlloyLanguage.g:7788:1: ( ( rule__ALSVariableDeclaration__RangeAssignment_2 ) ) | ||
22031 | // InternalAlloyLanguage.g:7789:1: ( rule__ALSVariableDeclaration__RangeAssignment_2 ) | ||
22032 | { | ||
22033 | if ( state.backtracking==0 ) { | ||
22034 | before(grammarAccess.getALSVariableDeclarationAccess().getRangeAssignment_2()); | ||
22035 | } | ||
22036 | // InternalAlloyLanguage.g:7790:1: ( rule__ALSVariableDeclaration__RangeAssignment_2 ) | ||
22037 | // InternalAlloyLanguage.g:7790:2: rule__ALSVariableDeclaration__RangeAssignment_2 | ||
22038 | { | ||
22039 | pushFollow(FOLLOW_2); | ||
22040 | rule__ALSVariableDeclaration__RangeAssignment_2(); | ||
22041 | |||
22042 | state._fsp--; | ||
22043 | if (state.failed) return ; | ||
22044 | |||
22045 | } | ||
22046 | |||
22047 | if ( state.backtracking==0 ) { | ||
22048 | after(grammarAccess.getALSVariableDeclarationAccess().getRangeAssignment_2()); | ||
22049 | } | ||
22050 | |||
22051 | } | ||
22052 | |||
22053 | |||
22054 | } | ||
22055 | |||
22056 | } | ||
22057 | catch (RecognitionException re) { | ||
22058 | reportError(re); | ||
22059 | recover(input,re); | ||
22060 | } | ||
22061 | finally { | ||
22062 | |||
22063 | restoreStackSize(stackSize); | ||
22064 | |||
22065 | } | ||
22066 | return ; | ||
22067 | } | ||
22068 | // $ANTLR end "rule__ALSVariableDeclaration__Group__2__Impl" | ||
22069 | |||
22070 | |||
22071 | // $ANTLR start "rule__ALSBasicRelationTerm__Group_0__0" | ||
22072 | // InternalAlloyLanguage.g:7806:1: rule__ALSBasicRelationTerm__Group_0__0 : rule__ALSBasicRelationTerm__Group_0__0__Impl rule__ALSBasicRelationTerm__Group_0__1 ; | ||
22073 | public final void rule__ALSBasicRelationTerm__Group_0__0() throws RecognitionException { | ||
22074 | |||
22075 | int stackSize = keepStackSize(); | ||
22076 | |||
22077 | try { | ||
22078 | // InternalAlloyLanguage.g:7810:1: ( rule__ALSBasicRelationTerm__Group_0__0__Impl rule__ALSBasicRelationTerm__Group_0__1 ) | ||
22079 | // InternalAlloyLanguage.g:7811:2: rule__ALSBasicRelationTerm__Group_0__0__Impl rule__ALSBasicRelationTerm__Group_0__1 | ||
22080 | { | ||
22081 | pushFollow(FOLLOW_54); | ||
22082 | rule__ALSBasicRelationTerm__Group_0__0__Impl(); | ||
22083 | |||
22084 | state._fsp--; | ||
22085 | if (state.failed) return ; | ||
22086 | pushFollow(FOLLOW_2); | ||
22087 | rule__ALSBasicRelationTerm__Group_0__1(); | ||
22088 | |||
22089 | state._fsp--; | ||
22090 | if (state.failed) return ; | ||
22091 | |||
22092 | } | ||
22093 | |||
22094 | } | ||
22095 | catch (RecognitionException re) { | ||
22096 | reportError(re); | ||
22097 | recover(input,re); | ||
22098 | } | ||
22099 | finally { | ||
22100 | |||
22101 | restoreStackSize(stackSize); | ||
22102 | |||
22103 | } | ||
22104 | return ; | ||
22105 | } | ||
22106 | // $ANTLR end "rule__ALSBasicRelationTerm__Group_0__0" | ||
22107 | |||
22108 | |||
22109 | // $ANTLR start "rule__ALSBasicRelationTerm__Group_0__0__Impl" | ||
22110 | // InternalAlloyLanguage.g:7818:1: rule__ALSBasicRelationTerm__Group_0__0__Impl : ( () ) ; | ||
22111 | public final void rule__ALSBasicRelationTerm__Group_0__0__Impl() throws RecognitionException { | ||
22112 | |||
22113 | int stackSize = keepStackSize(); | ||
22114 | |||
22115 | try { | ||
22116 | // InternalAlloyLanguage.g:7822:1: ( ( () ) ) | ||
22117 | // InternalAlloyLanguage.g:7823:1: ( () ) | ||
22118 | { | ||
22119 | // InternalAlloyLanguage.g:7823:1: ( () ) | ||
22120 | // InternalAlloyLanguage.g:7824:1: () | ||
22121 | { | ||
22122 | if ( state.backtracking==0 ) { | ||
22123 | before(grammarAccess.getALSBasicRelationTermAccess().getALSNoneAction_0_0()); | ||
22124 | } | ||
22125 | // InternalAlloyLanguage.g:7825:1: () | ||
22126 | // InternalAlloyLanguage.g:7827:1: | ||
22127 | { | ||
22128 | } | ||
22129 | |||
22130 | if ( state.backtracking==0 ) { | ||
22131 | after(grammarAccess.getALSBasicRelationTermAccess().getALSNoneAction_0_0()); | ||
22132 | } | ||
22133 | |||
22134 | } | ||
22135 | |||
22136 | |||
22137 | } | ||
22138 | |||
22139 | } | ||
22140 | finally { | ||
22141 | |||
22142 | restoreStackSize(stackSize); | ||
22143 | |||
22144 | } | ||
22145 | return ; | ||
22146 | } | ||
22147 | // $ANTLR end "rule__ALSBasicRelationTerm__Group_0__0__Impl" | ||
22148 | |||
22149 | |||
22150 | // $ANTLR start "rule__ALSBasicRelationTerm__Group_0__1" | ||
22151 | // InternalAlloyLanguage.g:7837:1: rule__ALSBasicRelationTerm__Group_0__1 : rule__ALSBasicRelationTerm__Group_0__1__Impl ; | ||
22152 | public final void rule__ALSBasicRelationTerm__Group_0__1() throws RecognitionException { | ||
22153 | |||
22154 | int stackSize = keepStackSize(); | ||
22155 | |||
22156 | try { | ||
22157 | // InternalAlloyLanguage.g:7841:1: ( rule__ALSBasicRelationTerm__Group_0__1__Impl ) | ||
22158 | // InternalAlloyLanguage.g:7842:2: rule__ALSBasicRelationTerm__Group_0__1__Impl | ||
22159 | { | ||
22160 | pushFollow(FOLLOW_2); | ||
22161 | rule__ALSBasicRelationTerm__Group_0__1__Impl(); | ||
22162 | |||
22163 | state._fsp--; | ||
22164 | if (state.failed) return ; | ||
22165 | |||
22166 | } | ||
22167 | |||
22168 | } | ||
22169 | catch (RecognitionException re) { | ||
22170 | reportError(re); | ||
22171 | recover(input,re); | ||
22172 | } | ||
22173 | finally { | ||
22174 | |||
22175 | restoreStackSize(stackSize); | ||
22176 | |||
22177 | } | ||
22178 | return ; | ||
22179 | } | ||
22180 | // $ANTLR end "rule__ALSBasicRelationTerm__Group_0__1" | ||
22181 | |||
22182 | |||
22183 | // $ANTLR start "rule__ALSBasicRelationTerm__Group_0__1__Impl" | ||
22184 | // InternalAlloyLanguage.g:7848:1: rule__ALSBasicRelationTerm__Group_0__1__Impl : ( 'none' ) ; | ||
22185 | public final void rule__ALSBasicRelationTerm__Group_0__1__Impl() throws RecognitionException { | ||
22186 | |||
22187 | int stackSize = keepStackSize(); | ||
22188 | |||
22189 | try { | ||
22190 | // InternalAlloyLanguage.g:7852:1: ( ( 'none' ) ) | ||
22191 | // InternalAlloyLanguage.g:7853:1: ( 'none' ) | ||
22192 | { | ||
22193 | // InternalAlloyLanguage.g:7853:1: ( 'none' ) | ||
22194 | // InternalAlloyLanguage.g:7854:1: 'none' | ||
22195 | { | ||
22196 | if ( state.backtracking==0 ) { | ||
22197 | before(grammarAccess.getALSBasicRelationTermAccess().getNoneKeyword_0_1()); | ||
22198 | } | ||
22199 | match(input,65,FOLLOW_2); if (state.failed) return ; | ||
22200 | if ( state.backtracking==0 ) { | ||
22201 | after(grammarAccess.getALSBasicRelationTermAccess().getNoneKeyword_0_1()); | ||
22202 | } | ||
22203 | |||
22204 | } | ||
22205 | |||
22206 | |||
22207 | } | ||
22208 | |||
22209 | } | ||
22210 | catch (RecognitionException re) { | ||
22211 | reportError(re); | ||
22212 | recover(input,re); | ||
22213 | } | ||
22214 | finally { | ||
22215 | |||
22216 | restoreStackSize(stackSize); | ||
22217 | |||
22218 | } | ||
22219 | return ; | ||
22220 | } | ||
22221 | // $ANTLR end "rule__ALSBasicRelationTerm__Group_0__1__Impl" | ||
22222 | |||
22223 | |||
22224 | // $ANTLR start "rule__ALSBasicRelationTerm__Group_1__0" | ||
22225 | // InternalAlloyLanguage.g:7871:1: rule__ALSBasicRelationTerm__Group_1__0 : rule__ALSBasicRelationTerm__Group_1__0__Impl rule__ALSBasicRelationTerm__Group_1__1 ; | ||
22226 | public final void rule__ALSBasicRelationTerm__Group_1__0() throws RecognitionException { | ||
22227 | |||
22228 | int stackSize = keepStackSize(); | ||
22229 | |||
22230 | try { | ||
22231 | // InternalAlloyLanguage.g:7875:1: ( rule__ALSBasicRelationTerm__Group_1__0__Impl rule__ALSBasicRelationTerm__Group_1__1 ) | ||
22232 | // InternalAlloyLanguage.g:7876:2: rule__ALSBasicRelationTerm__Group_1__0__Impl rule__ALSBasicRelationTerm__Group_1__1 | ||
22233 | { | ||
22234 | pushFollow(FOLLOW_55); | ||
22235 | rule__ALSBasicRelationTerm__Group_1__0__Impl(); | ||
22236 | |||
22237 | state._fsp--; | ||
22238 | if (state.failed) return ; | ||
22239 | pushFollow(FOLLOW_2); | ||
22240 | rule__ALSBasicRelationTerm__Group_1__1(); | ||
22241 | |||
22242 | state._fsp--; | ||
22243 | if (state.failed) return ; | ||
22244 | |||
22245 | } | ||
22246 | |||
22247 | } | ||
22248 | catch (RecognitionException re) { | ||
22249 | reportError(re); | ||
22250 | recover(input,re); | ||
22251 | } | ||
22252 | finally { | ||
22253 | |||
22254 | restoreStackSize(stackSize); | ||
22255 | |||
22256 | } | ||
22257 | return ; | ||
22258 | } | ||
22259 | // $ANTLR end "rule__ALSBasicRelationTerm__Group_1__0" | ||
22260 | |||
22261 | |||
22262 | // $ANTLR start "rule__ALSBasicRelationTerm__Group_1__0__Impl" | ||
22263 | // InternalAlloyLanguage.g:7883:1: rule__ALSBasicRelationTerm__Group_1__0__Impl : ( () ) ; | ||
22264 | public final void rule__ALSBasicRelationTerm__Group_1__0__Impl() throws RecognitionException { | ||
22265 | |||
22266 | int stackSize = keepStackSize(); | ||
22267 | |||
22268 | try { | ||
22269 | // InternalAlloyLanguage.g:7887:1: ( ( () ) ) | ||
22270 | // InternalAlloyLanguage.g:7888:1: ( () ) | ||
22271 | { | ||
22272 | // InternalAlloyLanguage.g:7888:1: ( () ) | ||
22273 | // InternalAlloyLanguage.g:7889:1: () | ||
22274 | { | ||
22275 | if ( state.backtracking==0 ) { | ||
22276 | before(grammarAccess.getALSBasicRelationTermAccess().getALSIdenAction_1_0()); | ||
22277 | } | ||
22278 | // InternalAlloyLanguage.g:7890:1: () | ||
22279 | // InternalAlloyLanguage.g:7892:1: | ||
22280 | { | ||
22281 | } | ||
22282 | |||
22283 | if ( state.backtracking==0 ) { | ||
22284 | after(grammarAccess.getALSBasicRelationTermAccess().getALSIdenAction_1_0()); | ||
22285 | } | ||
22286 | |||
22287 | } | ||
22288 | |||
22289 | |||
22290 | } | ||
22291 | |||
22292 | } | ||
22293 | finally { | ||
22294 | |||
22295 | restoreStackSize(stackSize); | ||
22296 | |||
22297 | } | ||
22298 | return ; | ||
22299 | } | ||
22300 | // $ANTLR end "rule__ALSBasicRelationTerm__Group_1__0__Impl" | ||
22301 | |||
22302 | |||
22303 | // $ANTLR start "rule__ALSBasicRelationTerm__Group_1__1" | ||
22304 | // InternalAlloyLanguage.g:7902:1: rule__ALSBasicRelationTerm__Group_1__1 : rule__ALSBasicRelationTerm__Group_1__1__Impl ; | ||
22305 | public final void rule__ALSBasicRelationTerm__Group_1__1() throws RecognitionException { | ||
22306 | |||
22307 | int stackSize = keepStackSize(); | ||
22308 | |||
22309 | try { | ||
22310 | // InternalAlloyLanguage.g:7906:1: ( rule__ALSBasicRelationTerm__Group_1__1__Impl ) | ||
22311 | // InternalAlloyLanguage.g:7907:2: rule__ALSBasicRelationTerm__Group_1__1__Impl | ||
22312 | { | ||
22313 | pushFollow(FOLLOW_2); | ||
22314 | rule__ALSBasicRelationTerm__Group_1__1__Impl(); | ||
22315 | |||
22316 | state._fsp--; | ||
22317 | if (state.failed) return ; | ||
22318 | |||
22319 | } | ||
22320 | |||
22321 | } | ||
22322 | catch (RecognitionException re) { | ||
22323 | reportError(re); | ||
22324 | recover(input,re); | ||
22325 | } | ||
22326 | finally { | ||
22327 | |||
22328 | restoreStackSize(stackSize); | ||
22329 | |||
22330 | } | ||
22331 | return ; | ||
22332 | } | ||
22333 | // $ANTLR end "rule__ALSBasicRelationTerm__Group_1__1" | ||
22334 | |||
22335 | |||
22336 | // $ANTLR start "rule__ALSBasicRelationTerm__Group_1__1__Impl" | ||
22337 | // InternalAlloyLanguage.g:7913:1: rule__ALSBasicRelationTerm__Group_1__1__Impl : ( 'iden' ) ; | ||
22338 | public final void rule__ALSBasicRelationTerm__Group_1__1__Impl() throws RecognitionException { | ||
22339 | |||
22340 | int stackSize = keepStackSize(); | ||
22341 | |||
22342 | try { | ||
22343 | // InternalAlloyLanguage.g:7917:1: ( ( 'iden' ) ) | ||
22344 | // InternalAlloyLanguage.g:7918:1: ( 'iden' ) | ||
22345 | { | ||
22346 | // InternalAlloyLanguage.g:7918:1: ( 'iden' ) | ||
22347 | // InternalAlloyLanguage.g:7919:1: 'iden' | ||
22348 | { | ||
22349 | if ( state.backtracking==0 ) { | ||
22350 | before(grammarAccess.getALSBasicRelationTermAccess().getIdenKeyword_1_1()); | ||
22351 | } | ||
22352 | match(input,66,FOLLOW_2); if (state.failed) return ; | ||
22353 | if ( state.backtracking==0 ) { | ||
22354 | after(grammarAccess.getALSBasicRelationTermAccess().getIdenKeyword_1_1()); | ||
22355 | } | ||
22356 | |||
22357 | } | ||
22358 | |||
22359 | |||
22360 | } | ||
22361 | |||
22362 | } | ||
22363 | catch (RecognitionException re) { | ||
22364 | reportError(re); | ||
22365 | recover(input,re); | ||
22366 | } | ||
22367 | finally { | ||
22368 | |||
22369 | restoreStackSize(stackSize); | ||
22370 | |||
22371 | } | ||
22372 | return ; | ||
22373 | } | ||
22374 | // $ANTLR end "rule__ALSBasicRelationTerm__Group_1__1__Impl" | ||
22375 | |||
22376 | |||
22377 | // $ANTLR start "rule__ALSBasicRelationTerm__Group_2__0" | ||
22378 | // InternalAlloyLanguage.g:7936:1: rule__ALSBasicRelationTerm__Group_2__0 : rule__ALSBasicRelationTerm__Group_2__0__Impl rule__ALSBasicRelationTerm__Group_2__1 ; | ||
22379 | public final void rule__ALSBasicRelationTerm__Group_2__0() throws RecognitionException { | ||
22380 | |||
22381 | int stackSize = keepStackSize(); | ||
22382 | |||
22383 | try { | ||
22384 | // InternalAlloyLanguage.g:7940:1: ( rule__ALSBasicRelationTerm__Group_2__0__Impl rule__ALSBasicRelationTerm__Group_2__1 ) | ||
22385 | // InternalAlloyLanguage.g:7941:2: rule__ALSBasicRelationTerm__Group_2__0__Impl rule__ALSBasicRelationTerm__Group_2__1 | ||
22386 | { | ||
22387 | pushFollow(FOLLOW_56); | ||
22388 | rule__ALSBasicRelationTerm__Group_2__0__Impl(); | ||
22389 | |||
22390 | state._fsp--; | ||
22391 | if (state.failed) return ; | ||
22392 | pushFollow(FOLLOW_2); | ||
22393 | rule__ALSBasicRelationTerm__Group_2__1(); | ||
22394 | |||
22395 | state._fsp--; | ||
22396 | if (state.failed) return ; | ||
22397 | |||
22398 | } | ||
22399 | |||
22400 | } | ||
22401 | catch (RecognitionException re) { | ||
22402 | reportError(re); | ||
22403 | recover(input,re); | ||
22404 | } | ||
22405 | finally { | ||
22406 | |||
22407 | restoreStackSize(stackSize); | ||
22408 | |||
22409 | } | ||
22410 | return ; | ||
22411 | } | ||
22412 | // $ANTLR end "rule__ALSBasicRelationTerm__Group_2__0" | ||
22413 | |||
22414 | |||
22415 | // $ANTLR start "rule__ALSBasicRelationTerm__Group_2__0__Impl" | ||
22416 | // InternalAlloyLanguage.g:7948:1: rule__ALSBasicRelationTerm__Group_2__0__Impl : ( () ) ; | ||
22417 | public final void rule__ALSBasicRelationTerm__Group_2__0__Impl() throws RecognitionException { | ||
22418 | |||
22419 | int stackSize = keepStackSize(); | ||
22420 | |||
22421 | try { | ||
22422 | // InternalAlloyLanguage.g:7952:1: ( ( () ) ) | ||
22423 | // InternalAlloyLanguage.g:7953:1: ( () ) | ||
22424 | { | ||
22425 | // InternalAlloyLanguage.g:7953:1: ( () ) | ||
22426 | // InternalAlloyLanguage.g:7954:1: () | ||
22427 | { | ||
22428 | if ( state.backtracking==0 ) { | ||
22429 | before(grammarAccess.getALSBasicRelationTermAccess().getALSUnivAction_2_0()); | ||
22430 | } | ||
22431 | // InternalAlloyLanguage.g:7955:1: () | ||
22432 | // InternalAlloyLanguage.g:7957:1: | ||
22433 | { | ||
22434 | } | ||
22435 | |||
22436 | if ( state.backtracking==0 ) { | ||
22437 | after(grammarAccess.getALSBasicRelationTermAccess().getALSUnivAction_2_0()); | ||
22438 | } | ||
22439 | |||
22440 | } | ||
22441 | |||
22442 | |||
22443 | } | ||
22444 | |||
22445 | } | ||
22446 | finally { | ||
22447 | |||
22448 | restoreStackSize(stackSize); | ||
22449 | |||
22450 | } | ||
22451 | return ; | ||
22452 | } | ||
22453 | // $ANTLR end "rule__ALSBasicRelationTerm__Group_2__0__Impl" | ||
22454 | |||
22455 | |||
22456 | // $ANTLR start "rule__ALSBasicRelationTerm__Group_2__1" | ||
22457 | // InternalAlloyLanguage.g:7967:1: rule__ALSBasicRelationTerm__Group_2__1 : rule__ALSBasicRelationTerm__Group_2__1__Impl ; | ||
22458 | public final void rule__ALSBasicRelationTerm__Group_2__1() throws RecognitionException { | ||
22459 | |||
22460 | int stackSize = keepStackSize(); | ||
22461 | |||
22462 | try { | ||
22463 | // InternalAlloyLanguage.g:7971:1: ( rule__ALSBasicRelationTerm__Group_2__1__Impl ) | ||
22464 | // InternalAlloyLanguage.g:7972:2: rule__ALSBasicRelationTerm__Group_2__1__Impl | ||
22465 | { | ||
22466 | pushFollow(FOLLOW_2); | ||
22467 | rule__ALSBasicRelationTerm__Group_2__1__Impl(); | ||
22468 | |||
22469 | state._fsp--; | ||
22470 | if (state.failed) return ; | ||
22471 | |||
22472 | } | ||
22473 | |||
22474 | } | ||
22475 | catch (RecognitionException re) { | ||
22476 | reportError(re); | ||
22477 | recover(input,re); | ||
22478 | } | ||
22479 | finally { | ||
22480 | |||
22481 | restoreStackSize(stackSize); | ||
22482 | |||
22483 | } | ||
22484 | return ; | ||
22485 | } | ||
22486 | // $ANTLR end "rule__ALSBasicRelationTerm__Group_2__1" | ||
22487 | |||
22488 | |||
22489 | // $ANTLR start "rule__ALSBasicRelationTerm__Group_2__1__Impl" | ||
22490 | // InternalAlloyLanguage.g:7978:1: rule__ALSBasicRelationTerm__Group_2__1__Impl : ( 'univ' ) ; | ||
22491 | public final void rule__ALSBasicRelationTerm__Group_2__1__Impl() throws RecognitionException { | ||
22492 | |||
22493 | int stackSize = keepStackSize(); | ||
22494 | |||
22495 | try { | ||
22496 | // InternalAlloyLanguage.g:7982:1: ( ( 'univ' ) ) | ||
22497 | // InternalAlloyLanguage.g:7983:1: ( 'univ' ) | ||
22498 | { | ||
22499 | // InternalAlloyLanguage.g:7983:1: ( 'univ' ) | ||
22500 | // InternalAlloyLanguage.g:7984:1: 'univ' | ||
22501 | { | ||
22502 | if ( state.backtracking==0 ) { | ||
22503 | before(grammarAccess.getALSBasicRelationTermAccess().getUnivKeyword_2_1()); | ||
22504 | } | ||
22505 | match(input,67,FOLLOW_2); if (state.failed) return ; | ||
22506 | if ( state.backtracking==0 ) { | ||
22507 | after(grammarAccess.getALSBasicRelationTermAccess().getUnivKeyword_2_1()); | ||
22508 | } | ||
22509 | |||
22510 | } | ||
22511 | |||
22512 | |||
22513 | } | ||
22514 | |||
22515 | } | ||
22516 | catch (RecognitionException re) { | ||
22517 | reportError(re); | ||
22518 | recover(input,re); | ||
22519 | } | ||
22520 | finally { | ||
22521 | |||
22522 | restoreStackSize(stackSize); | ||
22523 | |||
22524 | } | ||
22525 | return ; | ||
22526 | } | ||
22527 | // $ANTLR end "rule__ALSBasicRelationTerm__Group_2__1__Impl" | ||
22528 | |||
22529 | |||
22530 | // $ANTLR start "rule__ALSBasicRelationTerm__Group_3__0" | ||
22531 | // InternalAlloyLanguage.g:8001:1: rule__ALSBasicRelationTerm__Group_3__0 : rule__ALSBasicRelationTerm__Group_3__0__Impl rule__ALSBasicRelationTerm__Group_3__1 ; | ||
22532 | public final void rule__ALSBasicRelationTerm__Group_3__0() throws RecognitionException { | ||
22533 | |||
22534 | int stackSize = keepStackSize(); | ||
22535 | |||
22536 | try { | ||
22537 | // InternalAlloyLanguage.g:8005:1: ( rule__ALSBasicRelationTerm__Group_3__0__Impl rule__ALSBasicRelationTerm__Group_3__1 ) | ||
22538 | // InternalAlloyLanguage.g:8006:2: rule__ALSBasicRelationTerm__Group_3__0__Impl rule__ALSBasicRelationTerm__Group_3__1 | ||
22539 | { | ||
22540 | pushFollow(FOLLOW_57); | ||
22541 | rule__ALSBasicRelationTerm__Group_3__0__Impl(); | ||
22542 | |||
22543 | state._fsp--; | ||
22544 | if (state.failed) return ; | ||
22545 | pushFollow(FOLLOW_2); | ||
22546 | rule__ALSBasicRelationTerm__Group_3__1(); | ||
22547 | |||
22548 | state._fsp--; | ||
22549 | if (state.failed) return ; | ||
22550 | |||
22551 | } | ||
22552 | |||
22553 | } | ||
22554 | catch (RecognitionException re) { | ||
22555 | reportError(re); | ||
22556 | recover(input,re); | ||
22557 | } | ||
22558 | finally { | ||
22559 | |||
22560 | restoreStackSize(stackSize); | ||
22561 | |||
22562 | } | ||
22563 | return ; | ||
22564 | } | ||
22565 | // $ANTLR end "rule__ALSBasicRelationTerm__Group_3__0" | ||
22566 | |||
22567 | |||
22568 | // $ANTLR start "rule__ALSBasicRelationTerm__Group_3__0__Impl" | ||
22569 | // InternalAlloyLanguage.g:8013:1: rule__ALSBasicRelationTerm__Group_3__0__Impl : ( () ) ; | ||
22570 | public final void rule__ALSBasicRelationTerm__Group_3__0__Impl() throws RecognitionException { | ||
22571 | |||
22572 | int stackSize = keepStackSize(); | ||
22573 | |||
22574 | try { | ||
22575 | // InternalAlloyLanguage.g:8017:1: ( ( () ) ) | ||
22576 | // InternalAlloyLanguage.g:8018:1: ( () ) | ||
22577 | { | ||
22578 | // InternalAlloyLanguage.g:8018:1: ( () ) | ||
22579 | // InternalAlloyLanguage.g:8019:1: () | ||
22580 | { | ||
22581 | if ( state.backtracking==0 ) { | ||
22582 | before(grammarAccess.getALSBasicRelationTermAccess().getALSIntAction_3_0()); | ||
22583 | } | ||
22584 | // InternalAlloyLanguage.g:8020:1: () | ||
22585 | // InternalAlloyLanguage.g:8022:1: | ||
22586 | { | ||
22587 | } | ||
22588 | |||
22589 | if ( state.backtracking==0 ) { | ||
22590 | after(grammarAccess.getALSBasicRelationTermAccess().getALSIntAction_3_0()); | ||
22591 | } | ||
22592 | |||
22593 | } | ||
22594 | |||
22595 | |||
22596 | } | ||
22597 | |||
22598 | } | ||
22599 | finally { | ||
22600 | |||
22601 | restoreStackSize(stackSize); | ||
22602 | |||
22603 | } | ||
22604 | return ; | ||
22605 | } | ||
22606 | // $ANTLR end "rule__ALSBasicRelationTerm__Group_3__0__Impl" | ||
22607 | |||
22608 | |||
22609 | // $ANTLR start "rule__ALSBasicRelationTerm__Group_3__1" | ||
22610 | // InternalAlloyLanguage.g:8032:1: rule__ALSBasicRelationTerm__Group_3__1 : rule__ALSBasicRelationTerm__Group_3__1__Impl ; | ||
22611 | public final void rule__ALSBasicRelationTerm__Group_3__1() throws RecognitionException { | ||
22612 | |||
22613 | int stackSize = keepStackSize(); | ||
22614 | |||
22615 | try { | ||
22616 | // InternalAlloyLanguage.g:8036:1: ( rule__ALSBasicRelationTerm__Group_3__1__Impl ) | ||
22617 | // InternalAlloyLanguage.g:8037:2: rule__ALSBasicRelationTerm__Group_3__1__Impl | ||
22618 | { | ||
22619 | pushFollow(FOLLOW_2); | ||
22620 | rule__ALSBasicRelationTerm__Group_3__1__Impl(); | ||
22621 | |||
22622 | state._fsp--; | ||
22623 | if (state.failed) return ; | ||
22624 | |||
22625 | } | ||
22626 | |||
22627 | } | ||
22628 | catch (RecognitionException re) { | ||
22629 | reportError(re); | ||
22630 | recover(input,re); | ||
22631 | } | ||
22632 | finally { | ||
22633 | |||
22634 | restoreStackSize(stackSize); | ||
22635 | |||
22636 | } | ||
22637 | return ; | ||
22638 | } | ||
22639 | // $ANTLR end "rule__ALSBasicRelationTerm__Group_3__1" | ||
22640 | |||
22641 | |||
22642 | // $ANTLR start "rule__ALSBasicRelationTerm__Group_3__1__Impl" | ||
22643 | // InternalAlloyLanguage.g:8043:1: rule__ALSBasicRelationTerm__Group_3__1__Impl : ( 'Int' ) ; | ||
22644 | public final void rule__ALSBasicRelationTerm__Group_3__1__Impl() throws RecognitionException { | ||
22645 | |||
22646 | int stackSize = keepStackSize(); | ||
22647 | |||
22648 | try { | ||
22649 | // InternalAlloyLanguage.g:8047:1: ( ( 'Int' ) ) | ||
22650 | // InternalAlloyLanguage.g:8048:1: ( 'Int' ) | ||
22651 | { | ||
22652 | // InternalAlloyLanguage.g:8048:1: ( 'Int' ) | ||
22653 | // InternalAlloyLanguage.g:8049:1: 'Int' | ||
22654 | { | ||
22655 | if ( state.backtracking==0 ) { | ||
22656 | before(grammarAccess.getALSBasicRelationTermAccess().getIntKeyword_3_1()); | ||
22657 | } | ||
22658 | match(input,68,FOLLOW_2); if (state.failed) return ; | ||
22659 | if ( state.backtracking==0 ) { | ||
22660 | after(grammarAccess.getALSBasicRelationTermAccess().getIntKeyword_3_1()); | ||
22661 | } | ||
22662 | |||
22663 | } | ||
22664 | |||
22665 | |||
22666 | } | ||
22667 | |||
22668 | } | ||
22669 | catch (RecognitionException re) { | ||
22670 | reportError(re); | ||
22671 | recover(input,re); | ||
22672 | } | ||
22673 | finally { | ||
22674 | |||
22675 | restoreStackSize(stackSize); | ||
22676 | |||
22677 | } | ||
22678 | return ; | ||
22679 | } | ||
22680 | // $ANTLR end "rule__ALSBasicRelationTerm__Group_3__1__Impl" | ||
22681 | |||
22682 | |||
22683 | // $ANTLR start "rule__ALSBasicRelationTerm__Group_4__0" | ||
22684 | // InternalAlloyLanguage.g:8066:1: rule__ALSBasicRelationTerm__Group_4__0 : rule__ALSBasicRelationTerm__Group_4__0__Impl rule__ALSBasicRelationTerm__Group_4__1 ; | ||
22685 | public final void rule__ALSBasicRelationTerm__Group_4__0() throws RecognitionException { | ||
22686 | |||
22687 | int stackSize = keepStackSize(); | ||
22688 | |||
22689 | try { | ||
22690 | // InternalAlloyLanguage.g:8070:1: ( rule__ALSBasicRelationTerm__Group_4__0__Impl rule__ALSBasicRelationTerm__Group_4__1 ) | ||
22691 | // InternalAlloyLanguage.g:8071:2: rule__ALSBasicRelationTerm__Group_4__0__Impl rule__ALSBasicRelationTerm__Group_4__1 | ||
22692 | { | ||
22693 | pushFollow(FOLLOW_5); | ||
22694 | rule__ALSBasicRelationTerm__Group_4__0__Impl(); | ||
22695 | |||
22696 | state._fsp--; | ||
22697 | if (state.failed) return ; | ||
22698 | pushFollow(FOLLOW_2); | ||
22699 | rule__ALSBasicRelationTerm__Group_4__1(); | ||
22700 | |||
22701 | state._fsp--; | ||
22702 | if (state.failed) return ; | ||
22703 | |||
22704 | } | ||
22705 | |||
22706 | } | ||
22707 | catch (RecognitionException re) { | ||
22708 | reportError(re); | ||
22709 | recover(input,re); | ||
22710 | } | ||
22711 | finally { | ||
22712 | |||
22713 | restoreStackSize(stackSize); | ||
22714 | |||
22715 | } | ||
22716 | return ; | ||
22717 | } | ||
22718 | // $ANTLR end "rule__ALSBasicRelationTerm__Group_4__0" | ||
22719 | |||
22720 | |||
22721 | // $ANTLR start "rule__ALSBasicRelationTerm__Group_4__0__Impl" | ||
22722 | // InternalAlloyLanguage.g:8078:1: rule__ALSBasicRelationTerm__Group_4__0__Impl : ( () ) ; | ||
22723 | public final void rule__ALSBasicRelationTerm__Group_4__0__Impl() throws RecognitionException { | ||
22724 | |||
22725 | int stackSize = keepStackSize(); | ||
22726 | |||
22727 | try { | ||
22728 | // InternalAlloyLanguage.g:8082:1: ( ( () ) ) | ||
22729 | // InternalAlloyLanguage.g:8083:1: ( () ) | ||
22730 | { | ||
22731 | // InternalAlloyLanguage.g:8083:1: ( () ) | ||
22732 | // InternalAlloyLanguage.g:8084:1: () | ||
22733 | { | ||
22734 | if ( state.backtracking==0 ) { | ||
22735 | before(grammarAccess.getALSBasicRelationTermAccess().getALSReferenceAction_4_0()); | ||
22736 | } | ||
22737 | // InternalAlloyLanguage.g:8085:1: () | ||
22738 | // InternalAlloyLanguage.g:8087:1: | ||
22739 | { | ||
22740 | } | ||
22741 | |||
22742 | if ( state.backtracking==0 ) { | ||
22743 | after(grammarAccess.getALSBasicRelationTermAccess().getALSReferenceAction_4_0()); | ||
22744 | } | ||
22745 | |||
22746 | } | ||
22747 | |||
22748 | |||
22749 | } | ||
22750 | |||
22751 | } | ||
22752 | finally { | ||
22753 | |||
22754 | restoreStackSize(stackSize); | ||
22755 | |||
22756 | } | ||
22757 | return ; | ||
22758 | } | ||
22759 | // $ANTLR end "rule__ALSBasicRelationTerm__Group_4__0__Impl" | ||
22760 | |||
22761 | |||
22762 | // $ANTLR start "rule__ALSBasicRelationTerm__Group_4__1" | ||
22763 | // InternalAlloyLanguage.g:8097:1: rule__ALSBasicRelationTerm__Group_4__1 : rule__ALSBasicRelationTerm__Group_4__1__Impl ; | ||
22764 | public final void rule__ALSBasicRelationTerm__Group_4__1() throws RecognitionException { | ||
22765 | |||
22766 | int stackSize = keepStackSize(); | ||
22767 | |||
22768 | try { | ||
22769 | // InternalAlloyLanguage.g:8101:1: ( rule__ALSBasicRelationTerm__Group_4__1__Impl ) | ||
22770 | // InternalAlloyLanguage.g:8102:2: rule__ALSBasicRelationTerm__Group_4__1__Impl | ||
22771 | { | ||
22772 | pushFollow(FOLLOW_2); | ||
22773 | rule__ALSBasicRelationTerm__Group_4__1__Impl(); | ||
22774 | |||
22775 | state._fsp--; | ||
22776 | if (state.failed) return ; | ||
22777 | |||
22778 | } | ||
22779 | |||
22780 | } | ||
22781 | catch (RecognitionException re) { | ||
22782 | reportError(re); | ||
22783 | recover(input,re); | ||
22784 | } | ||
22785 | finally { | ||
22786 | |||
22787 | restoreStackSize(stackSize); | ||
22788 | |||
22789 | } | ||
22790 | return ; | ||
22791 | } | ||
22792 | // $ANTLR end "rule__ALSBasicRelationTerm__Group_4__1" | ||
22793 | |||
22794 | |||
22795 | // $ANTLR start "rule__ALSBasicRelationTerm__Group_4__1__Impl" | ||
22796 | // InternalAlloyLanguage.g:8108:1: rule__ALSBasicRelationTerm__Group_4__1__Impl : ( ( rule__ALSBasicRelationTerm__ReferredAssignment_4_1 ) ) ; | ||
22797 | public final void rule__ALSBasicRelationTerm__Group_4__1__Impl() throws RecognitionException { | ||
22798 | |||
22799 | int stackSize = keepStackSize(); | ||
22800 | |||
22801 | try { | ||
22802 | // InternalAlloyLanguage.g:8112:1: ( ( ( rule__ALSBasicRelationTerm__ReferredAssignment_4_1 ) ) ) | ||
22803 | // InternalAlloyLanguage.g:8113:1: ( ( rule__ALSBasicRelationTerm__ReferredAssignment_4_1 ) ) | ||
22804 | { | ||
22805 | // InternalAlloyLanguage.g:8113:1: ( ( rule__ALSBasicRelationTerm__ReferredAssignment_4_1 ) ) | ||
22806 | // InternalAlloyLanguage.g:8114:1: ( rule__ALSBasicRelationTerm__ReferredAssignment_4_1 ) | ||
22807 | { | ||
22808 | if ( state.backtracking==0 ) { | ||
22809 | before(grammarAccess.getALSBasicRelationTermAccess().getReferredAssignment_4_1()); | ||
22810 | } | ||
22811 | // InternalAlloyLanguage.g:8115:1: ( rule__ALSBasicRelationTerm__ReferredAssignment_4_1 ) | ||
22812 | // InternalAlloyLanguage.g:8115:2: rule__ALSBasicRelationTerm__ReferredAssignment_4_1 | ||
22813 | { | ||
22814 | pushFollow(FOLLOW_2); | ||
22815 | rule__ALSBasicRelationTerm__ReferredAssignment_4_1(); | ||
22816 | |||
22817 | state._fsp--; | ||
22818 | if (state.failed) return ; | ||
22819 | |||
22820 | } | ||
22821 | |||
22822 | if ( state.backtracking==0 ) { | ||
22823 | after(grammarAccess.getALSBasicRelationTermAccess().getReferredAssignment_4_1()); | ||
22824 | } | ||
22825 | |||
22826 | } | ||
22827 | |||
22828 | |||
22829 | } | ||
22830 | |||
22831 | } | ||
22832 | catch (RecognitionException re) { | ||
22833 | reportError(re); | ||
22834 | recover(input,re); | ||
22835 | } | ||
22836 | finally { | ||
22837 | |||
22838 | restoreStackSize(stackSize); | ||
22839 | |||
22840 | } | ||
22841 | return ; | ||
22842 | } | ||
22843 | // $ANTLR end "rule__ALSBasicRelationTerm__Group_4__1__Impl" | ||
22844 | |||
22845 | |||
22846 | // $ANTLR start "rule__ALSBasicRelationTerm__Group_5__0" | ||
22847 | // InternalAlloyLanguage.g:8129:1: rule__ALSBasicRelationTerm__Group_5__0 : rule__ALSBasicRelationTerm__Group_5__0__Impl rule__ALSBasicRelationTerm__Group_5__1 ; | ||
22848 | public final void rule__ALSBasicRelationTerm__Group_5__0() throws RecognitionException { | ||
22849 | |||
22850 | int stackSize = keepStackSize(); | ||
22851 | |||
22852 | try { | ||
22853 | // InternalAlloyLanguage.g:8133:1: ( rule__ALSBasicRelationTerm__Group_5__0__Impl rule__ALSBasicRelationTerm__Group_5__1 ) | ||
22854 | // InternalAlloyLanguage.g:8134:2: rule__ALSBasicRelationTerm__Group_5__0__Impl rule__ALSBasicRelationTerm__Group_5__1 | ||
22855 | { | ||
22856 | pushFollow(FOLLOW_58); | ||
22857 | rule__ALSBasicRelationTerm__Group_5__0__Impl(); | ||
22858 | |||
22859 | state._fsp--; | ||
22860 | if (state.failed) return ; | ||
22861 | pushFollow(FOLLOW_2); | ||
22862 | rule__ALSBasicRelationTerm__Group_5__1(); | ||
22863 | |||
22864 | state._fsp--; | ||
22865 | if (state.failed) return ; | ||
22866 | |||
22867 | } | ||
22868 | |||
22869 | } | ||
22870 | catch (RecognitionException re) { | ||
22871 | reportError(re); | ||
22872 | recover(input,re); | ||
22873 | } | ||
22874 | finally { | ||
22875 | |||
22876 | restoreStackSize(stackSize); | ||
22877 | |||
22878 | } | ||
22879 | return ; | ||
22880 | } | ||
22881 | // $ANTLR end "rule__ALSBasicRelationTerm__Group_5__0" | ||
22882 | |||
22883 | |||
22884 | // $ANTLR start "rule__ALSBasicRelationTerm__Group_5__0__Impl" | ||
22885 | // InternalAlloyLanguage.g:8141:1: rule__ALSBasicRelationTerm__Group_5__0__Impl : ( () ) ; | ||
22886 | public final void rule__ALSBasicRelationTerm__Group_5__0__Impl() throws RecognitionException { | ||
22887 | |||
22888 | int stackSize = keepStackSize(); | ||
22889 | |||
22890 | try { | ||
22891 | // InternalAlloyLanguage.g:8145:1: ( ( () ) ) | ||
22892 | // InternalAlloyLanguage.g:8146:1: ( () ) | ||
22893 | { | ||
22894 | // InternalAlloyLanguage.g:8146:1: ( () ) | ||
22895 | // InternalAlloyLanguage.g:8147:1: () | ||
22896 | { | ||
22897 | if ( state.backtracking==0 ) { | ||
22898 | before(grammarAccess.getALSBasicRelationTermAccess().getALSNumberLiteralAction_5_0()); | ||
22899 | } | ||
22900 | // InternalAlloyLanguage.g:8148:1: () | ||
22901 | // InternalAlloyLanguage.g:8150:1: | ||
22902 | { | ||
22903 | } | ||
22904 | |||
22905 | if ( state.backtracking==0 ) { | ||
22906 | after(grammarAccess.getALSBasicRelationTermAccess().getALSNumberLiteralAction_5_0()); | ||
22907 | } | ||
22908 | |||
22909 | } | ||
22910 | |||
22911 | |||
22912 | } | ||
22913 | |||
22914 | } | ||
22915 | finally { | ||
22916 | |||
22917 | restoreStackSize(stackSize); | ||
22918 | |||
22919 | } | ||
22920 | return ; | ||
22921 | } | ||
22922 | // $ANTLR end "rule__ALSBasicRelationTerm__Group_5__0__Impl" | ||
22923 | |||
22924 | |||
22925 | // $ANTLR start "rule__ALSBasicRelationTerm__Group_5__1" | ||
22926 | // InternalAlloyLanguage.g:8160:1: rule__ALSBasicRelationTerm__Group_5__1 : rule__ALSBasicRelationTerm__Group_5__1__Impl ; | ||
22927 | public final void rule__ALSBasicRelationTerm__Group_5__1() throws RecognitionException { | ||
22928 | |||
22929 | int stackSize = keepStackSize(); | ||
22930 | |||
22931 | try { | ||
22932 | // InternalAlloyLanguage.g:8164:1: ( rule__ALSBasicRelationTerm__Group_5__1__Impl ) | ||
22933 | // InternalAlloyLanguage.g:8165:2: rule__ALSBasicRelationTerm__Group_5__1__Impl | ||
22934 | { | ||
22935 | pushFollow(FOLLOW_2); | ||
22936 | rule__ALSBasicRelationTerm__Group_5__1__Impl(); | ||
22937 | |||
22938 | state._fsp--; | ||
22939 | if (state.failed) return ; | ||
22940 | |||
22941 | } | ||
22942 | |||
22943 | } | ||
22944 | catch (RecognitionException re) { | ||
22945 | reportError(re); | ||
22946 | recover(input,re); | ||
22947 | } | ||
22948 | finally { | ||
22949 | |||
22950 | restoreStackSize(stackSize); | ||
22951 | |||
22952 | } | ||
22953 | return ; | ||
22954 | } | ||
22955 | // $ANTLR end "rule__ALSBasicRelationTerm__Group_5__1" | ||
22956 | |||
22957 | |||
22958 | // $ANTLR start "rule__ALSBasicRelationTerm__Group_5__1__Impl" | ||
22959 | // InternalAlloyLanguage.g:8171:1: rule__ALSBasicRelationTerm__Group_5__1__Impl : ( ( rule__ALSBasicRelationTerm__ValueAssignment_5_1 ) ) ; | ||
22960 | public final void rule__ALSBasicRelationTerm__Group_5__1__Impl() throws RecognitionException { | ||
22961 | |||
22962 | int stackSize = keepStackSize(); | ||
22963 | |||
22964 | try { | ||
22965 | // InternalAlloyLanguage.g:8175:1: ( ( ( rule__ALSBasicRelationTerm__ValueAssignment_5_1 ) ) ) | ||
22966 | // InternalAlloyLanguage.g:8176:1: ( ( rule__ALSBasicRelationTerm__ValueAssignment_5_1 ) ) | ||
22967 | { | ||
22968 | // InternalAlloyLanguage.g:8176:1: ( ( rule__ALSBasicRelationTerm__ValueAssignment_5_1 ) ) | ||
22969 | // InternalAlloyLanguage.g:8177:1: ( rule__ALSBasicRelationTerm__ValueAssignment_5_1 ) | ||
22970 | { | ||
22971 | if ( state.backtracking==0 ) { | ||
22972 | before(grammarAccess.getALSBasicRelationTermAccess().getValueAssignment_5_1()); | ||
22973 | } | ||
22974 | // InternalAlloyLanguage.g:8178:1: ( rule__ALSBasicRelationTerm__ValueAssignment_5_1 ) | ||
22975 | // InternalAlloyLanguage.g:8178:2: rule__ALSBasicRelationTerm__ValueAssignment_5_1 | ||
22976 | { | ||
22977 | pushFollow(FOLLOW_2); | ||
22978 | rule__ALSBasicRelationTerm__ValueAssignment_5_1(); | ||
22979 | |||
22980 | state._fsp--; | ||
22981 | if (state.failed) return ; | ||
22982 | |||
22983 | } | ||
22984 | |||
22985 | if ( state.backtracking==0 ) { | ||
22986 | after(grammarAccess.getALSBasicRelationTermAccess().getValueAssignment_5_1()); | ||
22987 | } | ||
22988 | |||
22989 | } | ||
22990 | |||
22991 | |||
22992 | } | ||
22993 | |||
22994 | } | ||
22995 | catch (RecognitionException re) { | ||
22996 | reportError(re); | ||
22997 | recover(input,re); | ||
22998 | } | ||
22999 | finally { | ||
23000 | |||
23001 | restoreStackSize(stackSize); | ||
23002 | |||
23003 | } | ||
23004 | return ; | ||
23005 | } | ||
23006 | // $ANTLR end "rule__ALSBasicRelationTerm__Group_5__1__Impl" | ||
23007 | |||
23008 | |||
23009 | // $ANTLR start "rule__ALSBasicRelationTerm__Group_6__0" | ||
23010 | // InternalAlloyLanguage.g:8192:1: rule__ALSBasicRelationTerm__Group_6__0 : rule__ALSBasicRelationTerm__Group_6__0__Impl rule__ALSBasicRelationTerm__Group_6__1 ; | ||
23011 | public final void rule__ALSBasicRelationTerm__Group_6__0() throws RecognitionException { | ||
23012 | |||
23013 | int stackSize = keepStackSize(); | ||
23014 | |||
23015 | try { | ||
23016 | // InternalAlloyLanguage.g:8196:1: ( rule__ALSBasicRelationTerm__Group_6__0__Impl rule__ALSBasicRelationTerm__Group_6__1 ) | ||
23017 | // InternalAlloyLanguage.g:8197:2: rule__ALSBasicRelationTerm__Group_6__0__Impl rule__ALSBasicRelationTerm__Group_6__1 | ||
23018 | { | ||
23019 | pushFollow(FOLLOW_16); | ||
23020 | rule__ALSBasicRelationTerm__Group_6__0__Impl(); | ||
23021 | |||
23022 | state._fsp--; | ||
23023 | if (state.failed) return ; | ||
23024 | pushFollow(FOLLOW_2); | ||
23025 | rule__ALSBasicRelationTerm__Group_6__1(); | ||
23026 | |||
23027 | state._fsp--; | ||
23028 | if (state.failed) return ; | ||
23029 | |||
23030 | } | ||
23031 | |||
23032 | } | ||
23033 | catch (RecognitionException re) { | ||
23034 | reportError(re); | ||
23035 | recover(input,re); | ||
23036 | } | ||
23037 | finally { | ||
23038 | |||
23039 | restoreStackSize(stackSize); | ||
23040 | |||
23041 | } | ||
23042 | return ; | ||
23043 | } | ||
23044 | // $ANTLR end "rule__ALSBasicRelationTerm__Group_6__0" | ||
23045 | |||
23046 | |||
23047 | // $ANTLR start "rule__ALSBasicRelationTerm__Group_6__0__Impl" | ||
23048 | // InternalAlloyLanguage.g:8204:1: rule__ALSBasicRelationTerm__Group_6__0__Impl : ( '(' ) ; | ||
23049 | public final void rule__ALSBasicRelationTerm__Group_6__0__Impl() throws RecognitionException { | ||
23050 | |||
23051 | int stackSize = keepStackSize(); | ||
23052 | |||
23053 | try { | ||
23054 | // InternalAlloyLanguage.g:8208:1: ( ( '(' ) ) | ||
23055 | // InternalAlloyLanguage.g:8209:1: ( '(' ) | ||
23056 | { | ||
23057 | // InternalAlloyLanguage.g:8209:1: ( '(' ) | ||
23058 | // InternalAlloyLanguage.g:8210:1: '(' | ||
23059 | { | ||
23060 | if ( state.backtracking==0 ) { | ||
23061 | before(grammarAccess.getALSBasicRelationTermAccess().getLeftParenthesisKeyword_6_0()); | ||
23062 | } | ||
23063 | match(input,69,FOLLOW_2); if (state.failed) return ; | ||
23064 | if ( state.backtracking==0 ) { | ||
23065 | after(grammarAccess.getALSBasicRelationTermAccess().getLeftParenthesisKeyword_6_0()); | ||
23066 | } | ||
23067 | |||
23068 | } | ||
23069 | |||
23070 | |||
23071 | } | ||
23072 | |||
23073 | } | ||
23074 | catch (RecognitionException re) { | ||
23075 | reportError(re); | ||
23076 | recover(input,re); | ||
23077 | } | ||
23078 | finally { | ||
23079 | |||
23080 | restoreStackSize(stackSize); | ||
23081 | |||
23082 | } | ||
23083 | return ; | ||
23084 | } | ||
23085 | // $ANTLR end "rule__ALSBasicRelationTerm__Group_6__0__Impl" | ||
23086 | |||
23087 | |||
23088 | // $ANTLR start "rule__ALSBasicRelationTerm__Group_6__1" | ||
23089 | // InternalAlloyLanguage.g:8223:1: rule__ALSBasicRelationTerm__Group_6__1 : rule__ALSBasicRelationTerm__Group_6__1__Impl rule__ALSBasicRelationTerm__Group_6__2 ; | ||
23090 | public final void rule__ALSBasicRelationTerm__Group_6__1() throws RecognitionException { | ||
23091 | |||
23092 | int stackSize = keepStackSize(); | ||
23093 | |||
23094 | try { | ||
23095 | // InternalAlloyLanguage.g:8227:1: ( rule__ALSBasicRelationTerm__Group_6__1__Impl rule__ALSBasicRelationTerm__Group_6__2 ) | ||
23096 | // InternalAlloyLanguage.g:8228:2: rule__ALSBasicRelationTerm__Group_6__1__Impl rule__ALSBasicRelationTerm__Group_6__2 | ||
23097 | { | ||
23098 | pushFollow(FOLLOW_59); | ||
23099 | rule__ALSBasicRelationTerm__Group_6__1__Impl(); | ||
23100 | |||
23101 | state._fsp--; | ||
23102 | if (state.failed) return ; | ||
23103 | pushFollow(FOLLOW_2); | ||
23104 | rule__ALSBasicRelationTerm__Group_6__2(); | ||
23105 | |||
23106 | state._fsp--; | ||
23107 | if (state.failed) return ; | ||
23108 | |||
23109 | } | ||
23110 | |||
23111 | } | ||
23112 | catch (RecognitionException re) { | ||
23113 | reportError(re); | ||
23114 | recover(input,re); | ||
23115 | } | ||
23116 | finally { | ||
23117 | |||
23118 | restoreStackSize(stackSize); | ||
23119 | |||
23120 | } | ||
23121 | return ; | ||
23122 | } | ||
23123 | // $ANTLR end "rule__ALSBasicRelationTerm__Group_6__1" | ||
23124 | |||
23125 | |||
23126 | // $ANTLR start "rule__ALSBasicRelationTerm__Group_6__1__Impl" | ||
23127 | // InternalAlloyLanguage.g:8235:1: rule__ALSBasicRelationTerm__Group_6__1__Impl : ( ruleALSTerm ) ; | ||
23128 | public final void rule__ALSBasicRelationTerm__Group_6__1__Impl() throws RecognitionException { | ||
23129 | |||
23130 | int stackSize = keepStackSize(); | ||
23131 | |||
23132 | try { | ||
23133 | // InternalAlloyLanguage.g:8239:1: ( ( ruleALSTerm ) ) | ||
23134 | // InternalAlloyLanguage.g:8240:1: ( ruleALSTerm ) | ||
23135 | { | ||
23136 | // InternalAlloyLanguage.g:8240:1: ( ruleALSTerm ) | ||
23137 | // InternalAlloyLanguage.g:8241:1: ruleALSTerm | ||
23138 | { | ||
23139 | if ( state.backtracking==0 ) { | ||
23140 | before(grammarAccess.getALSBasicRelationTermAccess().getALSTermParserRuleCall_6_1()); | ||
23141 | } | ||
23142 | pushFollow(FOLLOW_2); | ||
23143 | ruleALSTerm(); | ||
23144 | |||
23145 | state._fsp--; | ||
23146 | if (state.failed) return ; | ||
23147 | if ( state.backtracking==0 ) { | ||
23148 | after(grammarAccess.getALSBasicRelationTermAccess().getALSTermParserRuleCall_6_1()); | ||
23149 | } | ||
23150 | |||
23151 | } | ||
23152 | |||
23153 | |||
23154 | } | ||
23155 | |||
23156 | } | ||
23157 | catch (RecognitionException re) { | ||
23158 | reportError(re); | ||
23159 | recover(input,re); | ||
23160 | } | ||
23161 | finally { | ||
23162 | |||
23163 | restoreStackSize(stackSize); | ||
23164 | |||
23165 | } | ||
23166 | return ; | ||
23167 | } | ||
23168 | // $ANTLR end "rule__ALSBasicRelationTerm__Group_6__1__Impl" | ||
23169 | |||
23170 | |||
23171 | // $ANTLR start "rule__ALSBasicRelationTerm__Group_6__2" | ||
23172 | // InternalAlloyLanguage.g:8252:1: rule__ALSBasicRelationTerm__Group_6__2 : rule__ALSBasicRelationTerm__Group_6__2__Impl ; | ||
23173 | public final void rule__ALSBasicRelationTerm__Group_6__2() throws RecognitionException { | ||
23174 | |||
23175 | int stackSize = keepStackSize(); | ||
23176 | |||
23177 | try { | ||
23178 | // InternalAlloyLanguage.g:8256:1: ( rule__ALSBasicRelationTerm__Group_6__2__Impl ) | ||
23179 | // InternalAlloyLanguage.g:8257:2: rule__ALSBasicRelationTerm__Group_6__2__Impl | ||
23180 | { | ||
23181 | pushFollow(FOLLOW_2); | ||
23182 | rule__ALSBasicRelationTerm__Group_6__2__Impl(); | ||
23183 | |||
23184 | state._fsp--; | ||
23185 | if (state.failed) return ; | ||
23186 | |||
23187 | } | ||
23188 | |||
23189 | } | ||
23190 | catch (RecognitionException re) { | ||
23191 | reportError(re); | ||
23192 | recover(input,re); | ||
23193 | } | ||
23194 | finally { | ||
23195 | |||
23196 | restoreStackSize(stackSize); | ||
23197 | |||
23198 | } | ||
23199 | return ; | ||
23200 | } | ||
23201 | // $ANTLR end "rule__ALSBasicRelationTerm__Group_6__2" | ||
23202 | |||
23203 | |||
23204 | // $ANTLR start "rule__ALSBasicRelationTerm__Group_6__2__Impl" | ||
23205 | // InternalAlloyLanguage.g:8263:1: rule__ALSBasicRelationTerm__Group_6__2__Impl : ( ')' ) ; | ||
23206 | public final void rule__ALSBasicRelationTerm__Group_6__2__Impl() throws RecognitionException { | ||
23207 | |||
23208 | int stackSize = keepStackSize(); | ||
23209 | |||
23210 | try { | ||
23211 | // InternalAlloyLanguage.g:8267:1: ( ( ')' ) ) | ||
23212 | // InternalAlloyLanguage.g:8268:1: ( ')' ) | ||
23213 | { | ||
23214 | // InternalAlloyLanguage.g:8268:1: ( ')' ) | ||
23215 | // InternalAlloyLanguage.g:8269:1: ')' | ||
23216 | { | ||
23217 | if ( state.backtracking==0 ) { | ||
23218 | before(grammarAccess.getALSBasicRelationTermAccess().getRightParenthesisKeyword_6_2()); | ||
23219 | } | ||
23220 | match(input,70,FOLLOW_2); if (state.failed) return ; | ||
23221 | if ( state.backtracking==0 ) { | ||
23222 | after(grammarAccess.getALSBasicRelationTermAccess().getRightParenthesisKeyword_6_2()); | ||
23223 | } | ||
23224 | |||
23225 | } | ||
23226 | |||
23227 | |||
23228 | } | ||
23229 | |||
23230 | } | ||
23231 | catch (RecognitionException re) { | ||
23232 | reportError(re); | ||
23233 | recover(input,re); | ||
23234 | } | ||
23235 | finally { | ||
23236 | |||
23237 | restoreStackSize(stackSize); | ||
23238 | |||
23239 | } | ||
23240 | return ; | ||
23241 | } | ||
23242 | // $ANTLR end "rule__ALSBasicRelationTerm__Group_6__2__Impl" | ||
23243 | |||
23244 | |||
23245 | // $ANTLR start "rule__ALSRunCommand__Group__0" | ||
23246 | // InternalAlloyLanguage.g:8288:1: rule__ALSRunCommand__Group__0 : rule__ALSRunCommand__Group__0__Impl rule__ALSRunCommand__Group__1 ; | ||
23247 | public final void rule__ALSRunCommand__Group__0() throws RecognitionException { | ||
23248 | |||
23249 | int stackSize = keepStackSize(); | ||
23250 | |||
23251 | try { | ||
23252 | // InternalAlloyLanguage.g:8292:1: ( rule__ALSRunCommand__Group__0__Impl rule__ALSRunCommand__Group__1 ) | ||
23253 | // InternalAlloyLanguage.g:8293:2: rule__ALSRunCommand__Group__0__Impl rule__ALSRunCommand__Group__1 | ||
23254 | { | ||
23255 | pushFollow(FOLLOW_3); | ||
23256 | rule__ALSRunCommand__Group__0__Impl(); | ||
23257 | |||
23258 | state._fsp--; | ||
23259 | if (state.failed) return ; | ||
23260 | pushFollow(FOLLOW_2); | ||
23261 | rule__ALSRunCommand__Group__1(); | ||
23262 | |||
23263 | state._fsp--; | ||
23264 | if (state.failed) return ; | ||
23265 | |||
23266 | } | ||
23267 | |||
23268 | } | ||
23269 | catch (RecognitionException re) { | ||
23270 | reportError(re); | ||
23271 | recover(input,re); | ||
23272 | } | ||
23273 | finally { | ||
23274 | |||
23275 | restoreStackSize(stackSize); | ||
23276 | |||
23277 | } | ||
23278 | return ; | ||
23279 | } | ||
23280 | // $ANTLR end "rule__ALSRunCommand__Group__0" | ||
23281 | |||
23282 | |||
23283 | // $ANTLR start "rule__ALSRunCommand__Group__0__Impl" | ||
23284 | // InternalAlloyLanguage.g:8300:1: rule__ALSRunCommand__Group__0__Impl : ( () ) ; | ||
23285 | public final void rule__ALSRunCommand__Group__0__Impl() throws RecognitionException { | ||
23286 | |||
23287 | int stackSize = keepStackSize(); | ||
23288 | |||
23289 | try { | ||
23290 | // InternalAlloyLanguage.g:8304:1: ( ( () ) ) | ||
23291 | // InternalAlloyLanguage.g:8305:1: ( () ) | ||
23292 | { | ||
23293 | // InternalAlloyLanguage.g:8305:1: ( () ) | ||
23294 | // InternalAlloyLanguage.g:8306:1: () | ||
23295 | { | ||
23296 | if ( state.backtracking==0 ) { | ||
23297 | before(grammarAccess.getALSRunCommandAccess().getALSRunCommandAction_0()); | ||
23298 | } | ||
23299 | // InternalAlloyLanguage.g:8307:1: () | ||
23300 | // InternalAlloyLanguage.g:8309:1: | ||
23301 | { | ||
23302 | } | ||
23303 | |||
23304 | if ( state.backtracking==0 ) { | ||
23305 | after(grammarAccess.getALSRunCommandAccess().getALSRunCommandAction_0()); | ||
23306 | } | ||
23307 | |||
23308 | } | ||
23309 | |||
23310 | |||
23311 | } | ||
23312 | |||
23313 | } | ||
23314 | finally { | ||
23315 | |||
23316 | restoreStackSize(stackSize); | ||
23317 | |||
23318 | } | ||
23319 | return ; | ||
23320 | } | ||
23321 | // $ANTLR end "rule__ALSRunCommand__Group__0__Impl" | ||
23322 | |||
23323 | |||
23324 | // $ANTLR start "rule__ALSRunCommand__Group__1" | ||
23325 | // InternalAlloyLanguage.g:8319:1: rule__ALSRunCommand__Group__1 : rule__ALSRunCommand__Group__1__Impl rule__ALSRunCommand__Group__2 ; | ||
23326 | public final void rule__ALSRunCommand__Group__1() throws RecognitionException { | ||
23327 | |||
23328 | int stackSize = keepStackSize(); | ||
23329 | |||
23330 | try { | ||
23331 | // InternalAlloyLanguage.g:8323:1: ( rule__ALSRunCommand__Group__1__Impl rule__ALSRunCommand__Group__2 ) | ||
23332 | // InternalAlloyLanguage.g:8324:2: rule__ALSRunCommand__Group__1__Impl rule__ALSRunCommand__Group__2 | ||
23333 | { | ||
23334 | pushFollow(FOLLOW_6); | ||
23335 | rule__ALSRunCommand__Group__1__Impl(); | ||
23336 | |||
23337 | state._fsp--; | ||
23338 | if (state.failed) return ; | ||
23339 | pushFollow(FOLLOW_2); | ||
23340 | rule__ALSRunCommand__Group__2(); | ||
23341 | |||
23342 | state._fsp--; | ||
23343 | if (state.failed) return ; | ||
23344 | |||
23345 | } | ||
23346 | |||
23347 | } | ||
23348 | catch (RecognitionException re) { | ||
23349 | reportError(re); | ||
23350 | recover(input,re); | ||
23351 | } | ||
23352 | finally { | ||
23353 | |||
23354 | restoreStackSize(stackSize); | ||
23355 | |||
23356 | } | ||
23357 | return ; | ||
23358 | } | ||
23359 | // $ANTLR end "rule__ALSRunCommand__Group__1" | ||
23360 | |||
23361 | |||
23362 | // $ANTLR start "rule__ALSRunCommand__Group__1__Impl" | ||
23363 | // InternalAlloyLanguage.g:8331:1: rule__ALSRunCommand__Group__1__Impl : ( 'run' ) ; | ||
23364 | public final void rule__ALSRunCommand__Group__1__Impl() throws RecognitionException { | ||
23365 | |||
23366 | int stackSize = keepStackSize(); | ||
23367 | |||
23368 | try { | ||
23369 | // InternalAlloyLanguage.g:8335:1: ( ( 'run' ) ) | ||
23370 | // InternalAlloyLanguage.g:8336:1: ( 'run' ) | ||
23371 | { | ||
23372 | // InternalAlloyLanguage.g:8336:1: ( 'run' ) | ||
23373 | // InternalAlloyLanguage.g:8337:1: 'run' | ||
23374 | { | ||
23375 | if ( state.backtracking==0 ) { | ||
23376 | before(grammarAccess.getALSRunCommandAccess().getRunKeyword_1()); | ||
23377 | } | ||
23378 | match(input,71,FOLLOW_2); if (state.failed) return ; | ||
23379 | if ( state.backtracking==0 ) { | ||
23380 | after(grammarAccess.getALSRunCommandAccess().getRunKeyword_1()); | ||
23381 | } | ||
23382 | |||
23383 | } | ||
23384 | |||
23385 | |||
23386 | } | ||
23387 | |||
23388 | } | ||
23389 | catch (RecognitionException re) { | ||
23390 | reportError(re); | ||
23391 | recover(input,re); | ||
23392 | } | ||
23393 | finally { | ||
23394 | |||
23395 | restoreStackSize(stackSize); | ||
23396 | |||
23397 | } | ||
23398 | return ; | ||
23399 | } | ||
23400 | // $ANTLR end "rule__ALSRunCommand__Group__1__Impl" | ||
23401 | |||
23402 | |||
23403 | // $ANTLR start "rule__ALSRunCommand__Group__2" | ||
23404 | // InternalAlloyLanguage.g:8350:1: rule__ALSRunCommand__Group__2 : rule__ALSRunCommand__Group__2__Impl rule__ALSRunCommand__Group__3 ; | ||
23405 | public final void rule__ALSRunCommand__Group__2() throws RecognitionException { | ||
23406 | |||
23407 | int stackSize = keepStackSize(); | ||
23408 | |||
23409 | try { | ||
23410 | // InternalAlloyLanguage.g:8354:1: ( rule__ALSRunCommand__Group__2__Impl rule__ALSRunCommand__Group__3 ) | ||
23411 | // InternalAlloyLanguage.g:8355:2: rule__ALSRunCommand__Group__2__Impl rule__ALSRunCommand__Group__3 | ||
23412 | { | ||
23413 | pushFollow(FOLLOW_19); | ||
23414 | rule__ALSRunCommand__Group__2__Impl(); | ||
23415 | |||
23416 | state._fsp--; | ||
23417 | if (state.failed) return ; | ||
23418 | pushFollow(FOLLOW_2); | ||
23419 | rule__ALSRunCommand__Group__3(); | ||
23420 | |||
23421 | state._fsp--; | ||
23422 | if (state.failed) return ; | ||
23423 | |||
23424 | } | ||
23425 | |||
23426 | } | ||
23427 | catch (RecognitionException re) { | ||
23428 | reportError(re); | ||
23429 | recover(input,re); | ||
23430 | } | ||
23431 | finally { | ||
23432 | |||
23433 | restoreStackSize(stackSize); | ||
23434 | |||
23435 | } | ||
23436 | return ; | ||
23437 | } | ||
23438 | // $ANTLR end "rule__ALSRunCommand__Group__2" | ||
23439 | |||
23440 | |||
23441 | // $ANTLR start "rule__ALSRunCommand__Group__2__Impl" | ||
23442 | // InternalAlloyLanguage.g:8362:1: rule__ALSRunCommand__Group__2__Impl : ( '{' ) ; | ||
23443 | public final void rule__ALSRunCommand__Group__2__Impl() throws RecognitionException { | ||
23444 | |||
23445 | int stackSize = keepStackSize(); | ||
23446 | |||
23447 | try { | ||
23448 | // InternalAlloyLanguage.g:8366:1: ( ( '{' ) ) | ||
23449 | // InternalAlloyLanguage.g:8367:1: ( '{' ) | ||
23450 | { | ||
23451 | // InternalAlloyLanguage.g:8367:1: ( '{' ) | ||
23452 | // InternalAlloyLanguage.g:8368:1: '{' | ||
23453 | { | ||
23454 | if ( state.backtracking==0 ) { | ||
23455 | before(grammarAccess.getALSRunCommandAccess().getLeftCurlyBracketKeyword_2()); | ||
23456 | } | ||
23457 | match(input,33,FOLLOW_2); if (state.failed) return ; | ||
23458 | if ( state.backtracking==0 ) { | ||
23459 | after(grammarAccess.getALSRunCommandAccess().getLeftCurlyBracketKeyword_2()); | ||
23460 | } | ||
23461 | |||
23462 | } | ||
23463 | |||
23464 | |||
23465 | } | ||
23466 | |||
23467 | } | ||
23468 | catch (RecognitionException re) { | ||
23469 | reportError(re); | ||
23470 | recover(input,re); | ||
23471 | } | ||
23472 | finally { | ||
23473 | |||
23474 | restoreStackSize(stackSize); | ||
23475 | |||
23476 | } | ||
23477 | return ; | ||
23478 | } | ||
23479 | // $ANTLR end "rule__ALSRunCommand__Group__2__Impl" | ||
23480 | |||
23481 | |||
23482 | // $ANTLR start "rule__ALSRunCommand__Group__3" | ||
23483 | // InternalAlloyLanguage.g:8381:1: rule__ALSRunCommand__Group__3 : rule__ALSRunCommand__Group__3__Impl rule__ALSRunCommand__Group__4 ; | ||
23484 | public final void rule__ALSRunCommand__Group__3() throws RecognitionException { | ||
23485 | |||
23486 | int stackSize = keepStackSize(); | ||
23487 | |||
23488 | try { | ||
23489 | // InternalAlloyLanguage.g:8385:1: ( rule__ALSRunCommand__Group__3__Impl rule__ALSRunCommand__Group__4 ) | ||
23490 | // InternalAlloyLanguage.g:8386:2: rule__ALSRunCommand__Group__3__Impl rule__ALSRunCommand__Group__4 | ||
23491 | { | ||
23492 | pushFollow(FOLLOW_60); | ||
23493 | rule__ALSRunCommand__Group__3__Impl(); | ||
23494 | |||
23495 | state._fsp--; | ||
23496 | if (state.failed) return ; | ||
23497 | pushFollow(FOLLOW_2); | ||
23498 | rule__ALSRunCommand__Group__4(); | ||
23499 | |||
23500 | state._fsp--; | ||
23501 | if (state.failed) return ; | ||
23502 | |||
23503 | } | ||
23504 | |||
23505 | } | ||
23506 | catch (RecognitionException re) { | ||
23507 | reportError(re); | ||
23508 | recover(input,re); | ||
23509 | } | ||
23510 | finally { | ||
23511 | |||
23512 | restoreStackSize(stackSize); | ||
23513 | |||
23514 | } | ||
23515 | return ; | ||
23516 | } | ||
23517 | // $ANTLR end "rule__ALSRunCommand__Group__3" | ||
23518 | |||
23519 | |||
23520 | // $ANTLR start "rule__ALSRunCommand__Group__3__Impl" | ||
23521 | // InternalAlloyLanguage.g:8393:1: rule__ALSRunCommand__Group__3__Impl : ( '}' ) ; | ||
23522 | public final void rule__ALSRunCommand__Group__3__Impl() throws RecognitionException { | ||
23523 | |||
23524 | int stackSize = keepStackSize(); | ||
23525 | |||
23526 | try { | ||
23527 | // InternalAlloyLanguage.g:8397:1: ( ( '}' ) ) | ||
23528 | // InternalAlloyLanguage.g:8398:1: ( '}' ) | ||
23529 | { | ||
23530 | // InternalAlloyLanguage.g:8398:1: ( '}' ) | ||
23531 | // InternalAlloyLanguage.g:8399:1: '}' | ||
23532 | { | ||
23533 | if ( state.backtracking==0 ) { | ||
23534 | before(grammarAccess.getALSRunCommandAccess().getRightCurlyBracketKeyword_3()); | ||
23535 | } | ||
23536 | match(input,34,FOLLOW_2); if (state.failed) return ; | ||
23537 | if ( state.backtracking==0 ) { | ||
23538 | after(grammarAccess.getALSRunCommandAccess().getRightCurlyBracketKeyword_3()); | ||
23539 | } | ||
23540 | |||
23541 | } | ||
23542 | |||
23543 | |||
23544 | } | ||
23545 | |||
23546 | } | ||
23547 | catch (RecognitionException re) { | ||
23548 | reportError(re); | ||
23549 | recover(input,re); | ||
23550 | } | ||
23551 | finally { | ||
23552 | |||
23553 | restoreStackSize(stackSize); | ||
23554 | |||
23555 | } | ||
23556 | return ; | ||
23557 | } | ||
23558 | // $ANTLR end "rule__ALSRunCommand__Group__3__Impl" | ||
23559 | |||
23560 | |||
23561 | // $ANTLR start "rule__ALSRunCommand__Group__4" | ||
23562 | // InternalAlloyLanguage.g:8412:1: rule__ALSRunCommand__Group__4 : rule__ALSRunCommand__Group__4__Impl ; | ||
23563 | public final void rule__ALSRunCommand__Group__4() throws RecognitionException { | ||
23564 | |||
23565 | int stackSize = keepStackSize(); | ||
23566 | |||
23567 | try { | ||
23568 | // InternalAlloyLanguage.g:8416:1: ( rule__ALSRunCommand__Group__4__Impl ) | ||
23569 | // InternalAlloyLanguage.g:8417:2: rule__ALSRunCommand__Group__4__Impl | ||
23570 | { | ||
23571 | pushFollow(FOLLOW_2); | ||
23572 | rule__ALSRunCommand__Group__4__Impl(); | ||
23573 | |||
23574 | state._fsp--; | ||
23575 | if (state.failed) return ; | ||
23576 | |||
23577 | } | ||
23578 | |||
23579 | } | ||
23580 | catch (RecognitionException re) { | ||
23581 | reportError(re); | ||
23582 | recover(input,re); | ||
23583 | } | ||
23584 | finally { | ||
23585 | |||
23586 | restoreStackSize(stackSize); | ||
23587 | |||
23588 | } | ||
23589 | return ; | ||
23590 | } | ||
23591 | // $ANTLR end "rule__ALSRunCommand__Group__4" | ||
23592 | |||
23593 | |||
23594 | // $ANTLR start "rule__ALSRunCommand__Group__4__Impl" | ||
23595 | // InternalAlloyLanguage.g:8423:1: rule__ALSRunCommand__Group__4__Impl : ( ( rule__ALSRunCommand__Group_4__0 )? ) ; | ||
23596 | public final void rule__ALSRunCommand__Group__4__Impl() throws RecognitionException { | ||
23597 | |||
23598 | int stackSize = keepStackSize(); | ||
23599 | |||
23600 | try { | ||
23601 | // InternalAlloyLanguage.g:8427:1: ( ( ( rule__ALSRunCommand__Group_4__0 )? ) ) | ||
23602 | // InternalAlloyLanguage.g:8428:1: ( ( rule__ALSRunCommand__Group_4__0 )? ) | ||
23603 | { | ||
23604 | // InternalAlloyLanguage.g:8428:1: ( ( rule__ALSRunCommand__Group_4__0 )? ) | ||
23605 | // InternalAlloyLanguage.g:8429:1: ( rule__ALSRunCommand__Group_4__0 )? | ||
23606 | { | ||
23607 | if ( state.backtracking==0 ) { | ||
23608 | before(grammarAccess.getALSRunCommandAccess().getGroup_4()); | ||
23609 | } | ||
23610 | // InternalAlloyLanguage.g:8430:1: ( rule__ALSRunCommand__Group_4__0 )? | ||
23611 | int alt48=2; | ||
23612 | int LA48_0 = input.LA(1); | ||
23613 | |||
23614 | if ( (LA48_0==72) ) { | ||
23615 | alt48=1; | ||
23616 | } | ||
23617 | switch (alt48) { | ||
23618 | case 1 : | ||
23619 | // InternalAlloyLanguage.g:8430:2: rule__ALSRunCommand__Group_4__0 | ||
23620 | { | ||
23621 | pushFollow(FOLLOW_2); | ||
23622 | rule__ALSRunCommand__Group_4__0(); | ||
23623 | |||
23624 | state._fsp--; | ||
23625 | if (state.failed) return ; | ||
23626 | |||
23627 | } | ||
23628 | break; | ||
23629 | |||
23630 | } | ||
23631 | |||
23632 | if ( state.backtracking==0 ) { | ||
23633 | after(grammarAccess.getALSRunCommandAccess().getGroup_4()); | ||
23634 | } | ||
23635 | |||
23636 | } | ||
23637 | |||
23638 | |||
23639 | } | ||
23640 | |||
23641 | } | ||
23642 | catch (RecognitionException re) { | ||
23643 | reportError(re); | ||
23644 | recover(input,re); | ||
23645 | } | ||
23646 | finally { | ||
23647 | |||
23648 | restoreStackSize(stackSize); | ||
23649 | |||
23650 | } | ||
23651 | return ; | ||
23652 | } | ||
23653 | // $ANTLR end "rule__ALSRunCommand__Group__4__Impl" | ||
23654 | |||
23655 | |||
23656 | // $ANTLR start "rule__ALSRunCommand__Group_4__0" | ||
23657 | // InternalAlloyLanguage.g:8450:1: rule__ALSRunCommand__Group_4__0 : rule__ALSRunCommand__Group_4__0__Impl rule__ALSRunCommand__Group_4__1 ; | ||
23658 | public final void rule__ALSRunCommand__Group_4__0() throws RecognitionException { | ||
23659 | |||
23660 | int stackSize = keepStackSize(); | ||
23661 | |||
23662 | try { | ||
23663 | // InternalAlloyLanguage.g:8454:1: ( rule__ALSRunCommand__Group_4__0__Impl rule__ALSRunCommand__Group_4__1 ) | ||
23664 | // InternalAlloyLanguage.g:8455:2: rule__ALSRunCommand__Group_4__0__Impl rule__ALSRunCommand__Group_4__1 | ||
23665 | { | ||
23666 | pushFollow(FOLLOW_61); | ||
23667 | rule__ALSRunCommand__Group_4__0__Impl(); | ||
23668 | |||
23669 | state._fsp--; | ||
23670 | if (state.failed) return ; | ||
23671 | pushFollow(FOLLOW_2); | ||
23672 | rule__ALSRunCommand__Group_4__1(); | ||
23673 | |||
23674 | state._fsp--; | ||
23675 | if (state.failed) return ; | ||
23676 | |||
23677 | } | ||
23678 | |||
23679 | } | ||
23680 | catch (RecognitionException re) { | ||
23681 | reportError(re); | ||
23682 | recover(input,re); | ||
23683 | } | ||
23684 | finally { | ||
23685 | |||
23686 | restoreStackSize(stackSize); | ||
23687 | |||
23688 | } | ||
23689 | return ; | ||
23690 | } | ||
23691 | // $ANTLR end "rule__ALSRunCommand__Group_4__0" | ||
23692 | |||
23693 | |||
23694 | // $ANTLR start "rule__ALSRunCommand__Group_4__0__Impl" | ||
23695 | // InternalAlloyLanguage.g:8462:1: rule__ALSRunCommand__Group_4__0__Impl : ( 'for' ) ; | ||
23696 | public final void rule__ALSRunCommand__Group_4__0__Impl() throws RecognitionException { | ||
23697 | |||
23698 | int stackSize = keepStackSize(); | ||
23699 | |||
23700 | try { | ||
23701 | // InternalAlloyLanguage.g:8466:1: ( ( 'for' ) ) | ||
23702 | // InternalAlloyLanguage.g:8467:1: ( 'for' ) | ||
23703 | { | ||
23704 | // InternalAlloyLanguage.g:8467:1: ( 'for' ) | ||
23705 | // InternalAlloyLanguage.g:8468:1: 'for' | ||
23706 | { | ||
23707 | if ( state.backtracking==0 ) { | ||
23708 | before(grammarAccess.getALSRunCommandAccess().getForKeyword_4_0()); | ||
23709 | } | ||
23710 | match(input,72,FOLLOW_2); if (state.failed) return ; | ||
23711 | if ( state.backtracking==0 ) { | ||
23712 | after(grammarAccess.getALSRunCommandAccess().getForKeyword_4_0()); | ||
23713 | } | ||
23714 | |||
23715 | } | ||
23716 | |||
23717 | |||
23718 | } | ||
23719 | |||
23720 | } | ||
23721 | catch (RecognitionException re) { | ||
23722 | reportError(re); | ||
23723 | recover(input,re); | ||
23724 | } | ||
23725 | finally { | ||
23726 | |||
23727 | restoreStackSize(stackSize); | ||
23728 | |||
23729 | } | ||
23730 | return ; | ||
23731 | } | ||
23732 | // $ANTLR end "rule__ALSRunCommand__Group_4__0__Impl" | ||
23733 | |||
23734 | |||
23735 | // $ANTLR start "rule__ALSRunCommand__Group_4__1" | ||
23736 | // InternalAlloyLanguage.g:8481:1: rule__ALSRunCommand__Group_4__1 : rule__ALSRunCommand__Group_4__1__Impl rule__ALSRunCommand__Group_4__2 ; | ||
23737 | public final void rule__ALSRunCommand__Group_4__1() throws RecognitionException { | ||
23738 | |||
23739 | int stackSize = keepStackSize(); | ||
23740 | |||
23741 | try { | ||
23742 | // InternalAlloyLanguage.g:8485:1: ( rule__ALSRunCommand__Group_4__1__Impl rule__ALSRunCommand__Group_4__2 ) | ||
23743 | // InternalAlloyLanguage.g:8486:2: rule__ALSRunCommand__Group_4__1__Impl rule__ALSRunCommand__Group_4__2 | ||
23744 | { | ||
23745 | pushFollow(FOLLOW_14); | ||
23746 | rule__ALSRunCommand__Group_4__1__Impl(); | ||
23747 | |||
23748 | state._fsp--; | ||
23749 | if (state.failed) return ; | ||
23750 | pushFollow(FOLLOW_2); | ||
23751 | rule__ALSRunCommand__Group_4__2(); | ||
23752 | |||
23753 | state._fsp--; | ||
23754 | if (state.failed) return ; | ||
23755 | |||
23756 | } | ||
23757 | |||
23758 | } | ||
23759 | catch (RecognitionException re) { | ||
23760 | reportError(re); | ||
23761 | recover(input,re); | ||
23762 | } | ||
23763 | finally { | ||
23764 | |||
23765 | restoreStackSize(stackSize); | ||
23766 | |||
23767 | } | ||
23768 | return ; | ||
23769 | } | ||
23770 | // $ANTLR end "rule__ALSRunCommand__Group_4__1" | ||
23771 | |||
23772 | |||
23773 | // $ANTLR start "rule__ALSRunCommand__Group_4__1__Impl" | ||
23774 | // InternalAlloyLanguage.g:8493:1: rule__ALSRunCommand__Group_4__1__Impl : ( ( rule__ALSRunCommand__TypeScopesAssignment_4_1 ) ) ; | ||
23775 | public final void rule__ALSRunCommand__Group_4__1__Impl() throws RecognitionException { | ||
23776 | |||
23777 | int stackSize = keepStackSize(); | ||
23778 | |||
23779 | try { | ||
23780 | // InternalAlloyLanguage.g:8497:1: ( ( ( rule__ALSRunCommand__TypeScopesAssignment_4_1 ) ) ) | ||
23781 | // InternalAlloyLanguage.g:8498:1: ( ( rule__ALSRunCommand__TypeScopesAssignment_4_1 ) ) | ||
23782 | { | ||
23783 | // InternalAlloyLanguage.g:8498:1: ( ( rule__ALSRunCommand__TypeScopesAssignment_4_1 ) ) | ||
23784 | // InternalAlloyLanguage.g:8499:1: ( rule__ALSRunCommand__TypeScopesAssignment_4_1 ) | ||
23785 | { | ||
23786 | if ( state.backtracking==0 ) { | ||
23787 | before(grammarAccess.getALSRunCommandAccess().getTypeScopesAssignment_4_1()); | ||
23788 | } | ||
23789 | // InternalAlloyLanguage.g:8500:1: ( rule__ALSRunCommand__TypeScopesAssignment_4_1 ) | ||
23790 | // InternalAlloyLanguage.g:8500:2: rule__ALSRunCommand__TypeScopesAssignment_4_1 | ||
23791 | { | ||
23792 | pushFollow(FOLLOW_2); | ||
23793 | rule__ALSRunCommand__TypeScopesAssignment_4_1(); | ||
23794 | |||
23795 | state._fsp--; | ||
23796 | if (state.failed) return ; | ||
23797 | |||
23798 | } | ||
23799 | |||
23800 | if ( state.backtracking==0 ) { | ||
23801 | after(grammarAccess.getALSRunCommandAccess().getTypeScopesAssignment_4_1()); | ||
23802 | } | ||
23803 | |||
23804 | } | ||
23805 | |||
23806 | |||
23807 | } | ||
23808 | |||
23809 | } | ||
23810 | catch (RecognitionException re) { | ||
23811 | reportError(re); | ||
23812 | recover(input,re); | ||
23813 | } | ||
23814 | finally { | ||
23815 | |||
23816 | restoreStackSize(stackSize); | ||
23817 | |||
23818 | } | ||
23819 | return ; | ||
23820 | } | ||
23821 | // $ANTLR end "rule__ALSRunCommand__Group_4__1__Impl" | ||
23822 | |||
23823 | |||
23824 | // $ANTLR start "rule__ALSRunCommand__Group_4__2" | ||
23825 | // InternalAlloyLanguage.g:8510:1: rule__ALSRunCommand__Group_4__2 : rule__ALSRunCommand__Group_4__2__Impl ; | ||
23826 | public final void rule__ALSRunCommand__Group_4__2() throws RecognitionException { | ||
23827 | |||
23828 | int stackSize = keepStackSize(); | ||
23829 | |||
23830 | try { | ||
23831 | // InternalAlloyLanguage.g:8514:1: ( rule__ALSRunCommand__Group_4__2__Impl ) | ||
23832 | // InternalAlloyLanguage.g:8515:2: rule__ALSRunCommand__Group_4__2__Impl | ||
23833 | { | ||
23834 | pushFollow(FOLLOW_2); | ||
23835 | rule__ALSRunCommand__Group_4__2__Impl(); | ||
23836 | |||
23837 | state._fsp--; | ||
23838 | if (state.failed) return ; | ||
23839 | |||
23840 | } | ||
23841 | |||
23842 | } | ||
23843 | catch (RecognitionException re) { | ||
23844 | reportError(re); | ||
23845 | recover(input,re); | ||
23846 | } | ||
23847 | finally { | ||
23848 | |||
23849 | restoreStackSize(stackSize); | ||
23850 | |||
23851 | } | ||
23852 | return ; | ||
23853 | } | ||
23854 | // $ANTLR end "rule__ALSRunCommand__Group_4__2" | ||
23855 | |||
23856 | |||
23857 | // $ANTLR start "rule__ALSRunCommand__Group_4__2__Impl" | ||
23858 | // InternalAlloyLanguage.g:8521:1: rule__ALSRunCommand__Group_4__2__Impl : ( ( rule__ALSRunCommand__Group_4_2__0 )* ) ; | ||
23859 | public final void rule__ALSRunCommand__Group_4__2__Impl() throws RecognitionException { | ||
23860 | |||
23861 | int stackSize = keepStackSize(); | ||
23862 | |||
23863 | try { | ||
23864 | // InternalAlloyLanguage.g:8525:1: ( ( ( rule__ALSRunCommand__Group_4_2__0 )* ) ) | ||
23865 | // InternalAlloyLanguage.g:8526:1: ( ( rule__ALSRunCommand__Group_4_2__0 )* ) | ||
23866 | { | ||
23867 | // InternalAlloyLanguage.g:8526:1: ( ( rule__ALSRunCommand__Group_4_2__0 )* ) | ||
23868 | // InternalAlloyLanguage.g:8527:1: ( rule__ALSRunCommand__Group_4_2__0 )* | ||
23869 | { | ||
23870 | if ( state.backtracking==0 ) { | ||
23871 | before(grammarAccess.getALSRunCommandAccess().getGroup_4_2()); | ||
23872 | } | ||
23873 | // InternalAlloyLanguage.g:8528:1: ( rule__ALSRunCommand__Group_4_2__0 )* | ||
23874 | loop49: | ||
23875 | do { | ||
23876 | int alt49=2; | ||
23877 | int LA49_0 = input.LA(1); | ||
23878 | |||
23879 | if ( (LA49_0==35) ) { | ||
23880 | alt49=1; | ||
23881 | } | ||
23882 | |||
23883 | |||
23884 | switch (alt49) { | ||
23885 | case 1 : | ||
23886 | // InternalAlloyLanguage.g:8528:2: rule__ALSRunCommand__Group_4_2__0 | ||
23887 | { | ||
23888 | pushFollow(FOLLOW_8); | ||
23889 | rule__ALSRunCommand__Group_4_2__0(); | ||
23890 | |||
23891 | state._fsp--; | ||
23892 | if (state.failed) return ; | ||
23893 | |||
23894 | } | ||
23895 | break; | ||
23896 | |||
23897 | default : | ||
23898 | break loop49; | ||
23899 | } | ||
23900 | } while (true); | ||
23901 | |||
23902 | if ( state.backtracking==0 ) { | ||
23903 | after(grammarAccess.getALSRunCommandAccess().getGroup_4_2()); | ||
23904 | } | ||
23905 | |||
23906 | } | ||
23907 | |||
23908 | |||
23909 | } | ||
23910 | |||
23911 | } | ||
23912 | catch (RecognitionException re) { | ||
23913 | reportError(re); | ||
23914 | recover(input,re); | ||
23915 | } | ||
23916 | finally { | ||
23917 | |||
23918 | restoreStackSize(stackSize); | ||
23919 | |||
23920 | } | ||
23921 | return ; | ||
23922 | } | ||
23923 | // $ANTLR end "rule__ALSRunCommand__Group_4__2__Impl" | ||
23924 | |||
23925 | |||
23926 | // $ANTLR start "rule__ALSRunCommand__Group_4_2__0" | ||
23927 | // InternalAlloyLanguage.g:8544:1: rule__ALSRunCommand__Group_4_2__0 : rule__ALSRunCommand__Group_4_2__0__Impl rule__ALSRunCommand__Group_4_2__1 ; | ||
23928 | public final void rule__ALSRunCommand__Group_4_2__0() throws RecognitionException { | ||
23929 | |||
23930 | int stackSize = keepStackSize(); | ||
23931 | |||
23932 | try { | ||
23933 | // InternalAlloyLanguage.g:8548:1: ( rule__ALSRunCommand__Group_4_2__0__Impl rule__ALSRunCommand__Group_4_2__1 ) | ||
23934 | // InternalAlloyLanguage.g:8549:2: rule__ALSRunCommand__Group_4_2__0__Impl rule__ALSRunCommand__Group_4_2__1 | ||
23935 | { | ||
23936 | pushFollow(FOLLOW_61); | ||
23937 | rule__ALSRunCommand__Group_4_2__0__Impl(); | ||
23938 | |||
23939 | state._fsp--; | ||
23940 | if (state.failed) return ; | ||
23941 | pushFollow(FOLLOW_2); | ||
23942 | rule__ALSRunCommand__Group_4_2__1(); | ||
23943 | |||
23944 | state._fsp--; | ||
23945 | if (state.failed) return ; | ||
23946 | |||
23947 | } | ||
23948 | |||
23949 | } | ||
23950 | catch (RecognitionException re) { | ||
23951 | reportError(re); | ||
23952 | recover(input,re); | ||
23953 | } | ||
23954 | finally { | ||
23955 | |||
23956 | restoreStackSize(stackSize); | ||
23957 | |||
23958 | } | ||
23959 | return ; | ||
23960 | } | ||
23961 | // $ANTLR end "rule__ALSRunCommand__Group_4_2__0" | ||
23962 | |||
23963 | |||
23964 | // $ANTLR start "rule__ALSRunCommand__Group_4_2__0__Impl" | ||
23965 | // InternalAlloyLanguage.g:8556:1: rule__ALSRunCommand__Group_4_2__0__Impl : ( ',' ) ; | ||
23966 | public final void rule__ALSRunCommand__Group_4_2__0__Impl() throws RecognitionException { | ||
23967 | |||
23968 | int stackSize = keepStackSize(); | ||
23969 | |||
23970 | try { | ||
23971 | // InternalAlloyLanguage.g:8560:1: ( ( ',' ) ) | ||
23972 | // InternalAlloyLanguage.g:8561:1: ( ',' ) | ||
23973 | { | ||
23974 | // InternalAlloyLanguage.g:8561:1: ( ',' ) | ||
23975 | // InternalAlloyLanguage.g:8562:1: ',' | ||
23976 | { | ||
23977 | if ( state.backtracking==0 ) { | ||
23978 | before(grammarAccess.getALSRunCommandAccess().getCommaKeyword_4_2_0()); | ||
23979 | } | ||
23980 | match(input,35,FOLLOW_2); if (state.failed) return ; | ||
23981 | if ( state.backtracking==0 ) { | ||
23982 | after(grammarAccess.getALSRunCommandAccess().getCommaKeyword_4_2_0()); | ||
23983 | } | ||
23984 | |||
23985 | } | ||
23986 | |||
23987 | |||
23988 | } | ||
23989 | |||
23990 | } | ||
23991 | catch (RecognitionException re) { | ||
23992 | reportError(re); | ||
23993 | recover(input,re); | ||
23994 | } | ||
23995 | finally { | ||
23996 | |||
23997 | restoreStackSize(stackSize); | ||
23998 | |||
23999 | } | ||
24000 | return ; | ||
24001 | } | ||
24002 | // $ANTLR end "rule__ALSRunCommand__Group_4_2__0__Impl" | ||
24003 | |||
24004 | |||
24005 | // $ANTLR start "rule__ALSRunCommand__Group_4_2__1" | ||
24006 | // InternalAlloyLanguage.g:8575:1: rule__ALSRunCommand__Group_4_2__1 : rule__ALSRunCommand__Group_4_2__1__Impl ; | ||
24007 | public final void rule__ALSRunCommand__Group_4_2__1() throws RecognitionException { | ||
24008 | |||
24009 | int stackSize = keepStackSize(); | ||
24010 | |||
24011 | try { | ||
24012 | // InternalAlloyLanguage.g:8579:1: ( rule__ALSRunCommand__Group_4_2__1__Impl ) | ||
24013 | // InternalAlloyLanguage.g:8580:2: rule__ALSRunCommand__Group_4_2__1__Impl | ||
24014 | { | ||
24015 | pushFollow(FOLLOW_2); | ||
24016 | rule__ALSRunCommand__Group_4_2__1__Impl(); | ||
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_4_2__1" | ||
24036 | |||
24037 | |||
24038 | // $ANTLR start "rule__ALSRunCommand__Group_4_2__1__Impl" | ||
24039 | // InternalAlloyLanguage.g:8586:1: rule__ALSRunCommand__Group_4_2__1__Impl : ( ( rule__ALSRunCommand__TypeScopesAssignment_4_2_1 ) ) ; | ||
24040 | public final void rule__ALSRunCommand__Group_4_2__1__Impl() throws RecognitionException { | ||
24041 | |||
24042 | int stackSize = keepStackSize(); | ||
24043 | |||
24044 | try { | ||
24045 | // InternalAlloyLanguage.g:8590:1: ( ( ( rule__ALSRunCommand__TypeScopesAssignment_4_2_1 ) ) ) | ||
24046 | // InternalAlloyLanguage.g:8591:1: ( ( rule__ALSRunCommand__TypeScopesAssignment_4_2_1 ) ) | ||
24047 | { | ||
24048 | // InternalAlloyLanguage.g:8591:1: ( ( rule__ALSRunCommand__TypeScopesAssignment_4_2_1 ) ) | ||
24049 | // InternalAlloyLanguage.g:8592:1: ( rule__ALSRunCommand__TypeScopesAssignment_4_2_1 ) | ||
24050 | { | ||
24051 | if ( state.backtracking==0 ) { | ||
24052 | before(grammarAccess.getALSRunCommandAccess().getTypeScopesAssignment_4_2_1()); | ||
24053 | } | ||
24054 | // InternalAlloyLanguage.g:8593:1: ( rule__ALSRunCommand__TypeScopesAssignment_4_2_1 ) | ||
24055 | // InternalAlloyLanguage.g:8593:2: rule__ALSRunCommand__TypeScopesAssignment_4_2_1 | ||
24056 | { | ||
24057 | pushFollow(FOLLOW_2); | ||
24058 | rule__ALSRunCommand__TypeScopesAssignment_4_2_1(); | ||
24059 | |||
24060 | state._fsp--; | ||
24061 | if (state.failed) return ; | ||
24062 | |||
24063 | } | ||
24064 | |||
24065 | if ( state.backtracking==0 ) { | ||
24066 | after(grammarAccess.getALSRunCommandAccess().getTypeScopesAssignment_4_2_1()); | ||
24067 | } | ||
24068 | |||
24069 | } | ||
24070 | |||
24071 | |||
24072 | } | ||
24073 | |||
24074 | } | ||
24075 | catch (RecognitionException re) { | ||
24076 | reportError(re); | ||
24077 | recover(input,re); | ||
24078 | } | ||
24079 | finally { | ||
24080 | |||
24081 | restoreStackSize(stackSize); | ||
24082 | |||
24083 | } | ||
24084 | return ; | ||
24085 | } | ||
24086 | // $ANTLR end "rule__ALSRunCommand__Group_4_2__1__Impl" | ||
24087 | |||
24088 | |||
24089 | // $ANTLR start "rule__ALSSigScope__Group__0" | ||
24090 | // InternalAlloyLanguage.g:8607:1: rule__ALSSigScope__Group__0 : rule__ALSSigScope__Group__0__Impl rule__ALSSigScope__Group__1 ; | ||
24091 | public final void rule__ALSSigScope__Group__0() throws RecognitionException { | ||
24092 | |||
24093 | int stackSize = keepStackSize(); | ||
24094 | |||
24095 | try { | ||
24096 | // InternalAlloyLanguage.g:8611:1: ( rule__ALSSigScope__Group__0__Impl rule__ALSSigScope__Group__1 ) | ||
24097 | // InternalAlloyLanguage.g:8612:2: rule__ALSSigScope__Group__0__Impl rule__ALSSigScope__Group__1 | ||
24098 | { | ||
24099 | pushFollow(FOLLOW_61); | ||
24100 | rule__ALSSigScope__Group__0__Impl(); | ||
24101 | |||
24102 | state._fsp--; | ||
24103 | if (state.failed) return ; | ||
24104 | pushFollow(FOLLOW_2); | ||
24105 | rule__ALSSigScope__Group__1(); | ||
24106 | |||
24107 | state._fsp--; | ||
24108 | if (state.failed) return ; | ||
24109 | |||
24110 | } | ||
24111 | |||
24112 | } | ||
24113 | catch (RecognitionException re) { | ||
24114 | reportError(re); | ||
24115 | recover(input,re); | ||
24116 | } | ||
24117 | finally { | ||
24118 | |||
24119 | restoreStackSize(stackSize); | ||
24120 | |||
24121 | } | ||
24122 | return ; | ||
24123 | } | ||
24124 | // $ANTLR end "rule__ALSSigScope__Group__0" | ||
24125 | |||
24126 | |||
24127 | // $ANTLR start "rule__ALSSigScope__Group__0__Impl" | ||
24128 | // InternalAlloyLanguage.g:8619:1: rule__ALSSigScope__Group__0__Impl : ( ( rule__ALSSigScope__ExactlyAssignment_0 )? ) ; | ||
24129 | public final void rule__ALSSigScope__Group__0__Impl() throws RecognitionException { | ||
24130 | |||
24131 | int stackSize = keepStackSize(); | ||
24132 | |||
24133 | try { | ||
24134 | // InternalAlloyLanguage.g:8623:1: ( ( ( rule__ALSSigScope__ExactlyAssignment_0 )? ) ) | ||
24135 | // InternalAlloyLanguage.g:8624:1: ( ( rule__ALSSigScope__ExactlyAssignment_0 )? ) | ||
24136 | { | ||
24137 | // InternalAlloyLanguage.g:8624:1: ( ( rule__ALSSigScope__ExactlyAssignment_0 )? ) | ||
24138 | // InternalAlloyLanguage.g:8625:1: ( rule__ALSSigScope__ExactlyAssignment_0 )? | ||
24139 | { | ||
24140 | if ( state.backtracking==0 ) { | ||
24141 | before(grammarAccess.getALSSigScopeAccess().getExactlyAssignment_0()); | ||
24142 | } | ||
24143 | // InternalAlloyLanguage.g:8626:1: ( rule__ALSSigScope__ExactlyAssignment_0 )? | ||
24144 | int alt50=2; | ||
24145 | int LA50_0 = input.LA(1); | ||
24146 | |||
24147 | if ( (LA50_0==75) ) { | ||
24148 | alt50=1; | ||
24149 | } | ||
24150 | switch (alt50) { | ||
24151 | case 1 : | ||
24152 | // InternalAlloyLanguage.g:8626:2: rule__ALSSigScope__ExactlyAssignment_0 | ||
24153 | { | ||
24154 | pushFollow(FOLLOW_2); | ||
24155 | rule__ALSSigScope__ExactlyAssignment_0(); | ||
24156 | |||
24157 | state._fsp--; | ||
24158 | if (state.failed) return ; | ||
24159 | |||
24160 | } | ||
24161 | break; | ||
24162 | |||
24163 | } | ||
24164 | |||
24165 | if ( state.backtracking==0 ) { | ||
24166 | after(grammarAccess.getALSSigScopeAccess().getExactlyAssignment_0()); | ||
24167 | } | ||
24168 | |||
24169 | } | ||
24170 | |||
24171 | |||
24172 | } | ||
24173 | |||
24174 | } | ||
24175 | catch (RecognitionException re) { | ||
24176 | reportError(re); | ||
24177 | recover(input,re); | ||
24178 | } | ||
24179 | finally { | ||
24180 | |||
24181 | restoreStackSize(stackSize); | ||
24182 | |||
24183 | } | ||
24184 | return ; | ||
24185 | } | ||
24186 | // $ANTLR end "rule__ALSSigScope__Group__0__Impl" | ||
24187 | |||
24188 | |||
24189 | // $ANTLR start "rule__ALSSigScope__Group__1" | ||
24190 | // InternalAlloyLanguage.g:8636:1: rule__ALSSigScope__Group__1 : rule__ALSSigScope__Group__1__Impl rule__ALSSigScope__Group__2 ; | ||
24191 | public final void rule__ALSSigScope__Group__1() throws RecognitionException { | ||
24192 | |||
24193 | int stackSize = keepStackSize(); | ||
24194 | |||
24195 | try { | ||
24196 | // InternalAlloyLanguage.g:8640:1: ( rule__ALSSigScope__Group__1__Impl rule__ALSSigScope__Group__2 ) | ||
24197 | // InternalAlloyLanguage.g:8641:2: rule__ALSSigScope__Group__1__Impl rule__ALSSigScope__Group__2 | ||
24198 | { | ||
24199 | pushFollow(FOLLOW_5); | ||
24200 | rule__ALSSigScope__Group__1__Impl(); | ||
24201 | |||
24202 | state._fsp--; | ||
24203 | if (state.failed) return ; | ||
24204 | pushFollow(FOLLOW_2); | ||
24205 | rule__ALSSigScope__Group__2(); | ||
24206 | |||
24207 | state._fsp--; | ||
24208 | if (state.failed) return ; | ||
24209 | |||
24210 | } | ||
24211 | |||
24212 | } | ||
24213 | catch (RecognitionException re) { | ||
24214 | reportError(re); | ||
24215 | recover(input,re); | ||
24216 | } | ||
24217 | finally { | ||
24218 | |||
24219 | restoreStackSize(stackSize); | ||
24220 | |||
24221 | } | ||
24222 | return ; | ||
24223 | } | ||
24224 | // $ANTLR end "rule__ALSSigScope__Group__1" | ||
24225 | |||
24226 | |||
24227 | // $ANTLR start "rule__ALSSigScope__Group__1__Impl" | ||
24228 | // InternalAlloyLanguage.g:8648:1: rule__ALSSigScope__Group__1__Impl : ( ( rule__ALSSigScope__NumberAssignment_1 ) ) ; | ||
24229 | public final void rule__ALSSigScope__Group__1__Impl() throws RecognitionException { | ||
24230 | |||
24231 | int stackSize = keepStackSize(); | ||
24232 | |||
24233 | try { | ||
24234 | // InternalAlloyLanguage.g:8652:1: ( ( ( rule__ALSSigScope__NumberAssignment_1 ) ) ) | ||
24235 | // InternalAlloyLanguage.g:8653:1: ( ( rule__ALSSigScope__NumberAssignment_1 ) ) | ||
24236 | { | ||
24237 | // InternalAlloyLanguage.g:8653:1: ( ( rule__ALSSigScope__NumberAssignment_1 ) ) | ||
24238 | // InternalAlloyLanguage.g:8654:1: ( rule__ALSSigScope__NumberAssignment_1 ) | ||
24239 | { | ||
24240 | if ( state.backtracking==0 ) { | ||
24241 | before(grammarAccess.getALSSigScopeAccess().getNumberAssignment_1()); | ||
24242 | } | ||
24243 | // InternalAlloyLanguage.g:8655:1: ( rule__ALSSigScope__NumberAssignment_1 ) | ||
24244 | // InternalAlloyLanguage.g:8655:2: rule__ALSSigScope__NumberAssignment_1 | ||
24245 | { | ||
24246 | pushFollow(FOLLOW_2); | ||
24247 | rule__ALSSigScope__NumberAssignment_1(); | ||
24248 | |||
24249 | state._fsp--; | ||
24250 | if (state.failed) return ; | ||
24251 | |||
24252 | } | ||
24253 | |||
24254 | if ( state.backtracking==0 ) { | ||
24255 | after(grammarAccess.getALSSigScopeAccess().getNumberAssignment_1()); | ||
24256 | } | ||
24257 | |||
24258 | } | ||
24259 | |||
24260 | |||
24261 | } | ||
24262 | |||
24263 | } | ||
24264 | catch (RecognitionException re) { | ||
24265 | reportError(re); | ||
24266 | recover(input,re); | ||
24267 | } | ||
24268 | finally { | ||
24269 | |||
24270 | restoreStackSize(stackSize); | ||
24271 | |||
24272 | } | ||
24273 | return ; | ||
24274 | } | ||
24275 | // $ANTLR end "rule__ALSSigScope__Group__1__Impl" | ||
24276 | |||
24277 | |||
24278 | // $ANTLR start "rule__ALSSigScope__Group__2" | ||
24279 | // InternalAlloyLanguage.g:8665:1: rule__ALSSigScope__Group__2 : rule__ALSSigScope__Group__2__Impl ; | ||
24280 | public final void rule__ALSSigScope__Group__2() throws RecognitionException { | ||
24281 | |||
24282 | int stackSize = keepStackSize(); | ||
24283 | |||
24284 | try { | ||
24285 | // InternalAlloyLanguage.g:8669:1: ( rule__ALSSigScope__Group__2__Impl ) | ||
24286 | // InternalAlloyLanguage.g:8670:2: rule__ALSSigScope__Group__2__Impl | ||
24287 | { | ||
24288 | pushFollow(FOLLOW_2); | ||
24289 | rule__ALSSigScope__Group__2__Impl(); | ||
24290 | |||
24291 | state._fsp--; | ||
24292 | if (state.failed) return ; | ||
24293 | |||
24294 | } | ||
24295 | |||
24296 | } | ||
24297 | catch (RecognitionException re) { | ||
24298 | reportError(re); | ||
24299 | recover(input,re); | ||
24300 | } | ||
24301 | finally { | ||
24302 | |||
24303 | restoreStackSize(stackSize); | ||
24304 | |||
24305 | } | ||
24306 | return ; | ||
24307 | } | ||
24308 | // $ANTLR end "rule__ALSSigScope__Group__2" | ||
24309 | |||
24310 | |||
24311 | // $ANTLR start "rule__ALSSigScope__Group__2__Impl" | ||
24312 | // InternalAlloyLanguage.g:8676:1: rule__ALSSigScope__Group__2__Impl : ( ( rule__ALSSigScope__TypeAssignment_2 ) ) ; | ||
24313 | public final void rule__ALSSigScope__Group__2__Impl() throws RecognitionException { | ||
24314 | |||
24315 | int stackSize = keepStackSize(); | ||
24316 | |||
24317 | try { | ||
24318 | // InternalAlloyLanguage.g:8680:1: ( ( ( rule__ALSSigScope__TypeAssignment_2 ) ) ) | ||
24319 | // InternalAlloyLanguage.g:8681:1: ( ( rule__ALSSigScope__TypeAssignment_2 ) ) | ||
24320 | { | ||
24321 | // InternalAlloyLanguage.g:8681:1: ( ( rule__ALSSigScope__TypeAssignment_2 ) ) | ||
24322 | // InternalAlloyLanguage.g:8682:1: ( rule__ALSSigScope__TypeAssignment_2 ) | ||
24323 | { | ||
24324 | if ( state.backtracking==0 ) { | ||
24325 | before(grammarAccess.getALSSigScopeAccess().getTypeAssignment_2()); | ||
24326 | } | ||
24327 | // InternalAlloyLanguage.g:8683:1: ( rule__ALSSigScope__TypeAssignment_2 ) | ||
24328 | // InternalAlloyLanguage.g:8683:2: rule__ALSSigScope__TypeAssignment_2 | ||
24329 | { | ||
24330 | pushFollow(FOLLOW_2); | ||
24331 | rule__ALSSigScope__TypeAssignment_2(); | ||
24332 | |||
24333 | state._fsp--; | ||
24334 | if (state.failed) return ; | ||
24335 | |||
24336 | } | ||
24337 | |||
24338 | if ( state.backtracking==0 ) { | ||
24339 | after(grammarAccess.getALSSigScopeAccess().getTypeAssignment_2()); | ||
24340 | } | ||
24341 | |||
24342 | } | ||
24343 | |||
24344 | |||
24345 | } | ||
24346 | |||
24347 | } | ||
24348 | catch (RecognitionException re) { | ||
24349 | reportError(re); | ||
24350 | recover(input,re); | ||
24351 | } | ||
24352 | finally { | ||
24353 | |||
24354 | restoreStackSize(stackSize); | ||
24355 | |||
24356 | } | ||
24357 | return ; | ||
24358 | } | ||
24359 | // $ANTLR end "rule__ALSSigScope__Group__2__Impl" | ||
24360 | |||
24361 | |||
24362 | // $ANTLR start "rule__ALSIntScope__Group__0" | ||
24363 | // InternalAlloyLanguage.g:8699:1: rule__ALSIntScope__Group__0 : rule__ALSIntScope__Group__0__Impl rule__ALSIntScope__Group__1 ; | ||
24364 | public final void rule__ALSIntScope__Group__0() throws RecognitionException { | ||
24365 | |||
24366 | int stackSize = keepStackSize(); | ||
24367 | |||
24368 | try { | ||
24369 | // InternalAlloyLanguage.g:8703:1: ( rule__ALSIntScope__Group__0__Impl rule__ALSIntScope__Group__1 ) | ||
24370 | // InternalAlloyLanguage.g:8704:2: rule__ALSIntScope__Group__0__Impl rule__ALSIntScope__Group__1 | ||
24371 | { | ||
24372 | pushFollow(FOLLOW_57); | ||
24373 | rule__ALSIntScope__Group__0__Impl(); | ||
24374 | |||
24375 | state._fsp--; | ||
24376 | if (state.failed) return ; | ||
24377 | pushFollow(FOLLOW_2); | ||
24378 | rule__ALSIntScope__Group__1(); | ||
24379 | |||
24380 | state._fsp--; | ||
24381 | if (state.failed) return ; | ||
24382 | |||
24383 | } | ||
24384 | |||
24385 | } | ||
24386 | catch (RecognitionException re) { | ||
24387 | reportError(re); | ||
24388 | recover(input,re); | ||
24389 | } | ||
24390 | finally { | ||
24391 | |||
24392 | restoreStackSize(stackSize); | ||
24393 | |||
24394 | } | ||
24395 | return ; | ||
24396 | } | ||
24397 | // $ANTLR end "rule__ALSIntScope__Group__0" | ||
24398 | |||
24399 | |||
24400 | // $ANTLR start "rule__ALSIntScope__Group__0__Impl" | ||
24401 | // InternalAlloyLanguage.g:8711:1: rule__ALSIntScope__Group__0__Impl : ( ( rule__ALSIntScope__NumberAssignment_0 ) ) ; | ||
24402 | public final void rule__ALSIntScope__Group__0__Impl() throws RecognitionException { | ||
24403 | |||
24404 | int stackSize = keepStackSize(); | ||
24405 | |||
24406 | try { | ||
24407 | // InternalAlloyLanguage.g:8715:1: ( ( ( rule__ALSIntScope__NumberAssignment_0 ) ) ) | ||
24408 | // InternalAlloyLanguage.g:8716:1: ( ( rule__ALSIntScope__NumberAssignment_0 ) ) | ||
24409 | { | ||
24410 | // InternalAlloyLanguage.g:8716:1: ( ( rule__ALSIntScope__NumberAssignment_0 ) ) | ||
24411 | // InternalAlloyLanguage.g:8717:1: ( rule__ALSIntScope__NumberAssignment_0 ) | ||
24412 | { | ||
24413 | if ( state.backtracking==0 ) { | ||
24414 | before(grammarAccess.getALSIntScopeAccess().getNumberAssignment_0()); | ||
24415 | } | ||
24416 | // InternalAlloyLanguage.g:8718:1: ( rule__ALSIntScope__NumberAssignment_0 ) | ||
24417 | // InternalAlloyLanguage.g:8718:2: rule__ALSIntScope__NumberAssignment_0 | ||
24418 | { | ||
24419 | pushFollow(FOLLOW_2); | ||
24420 | rule__ALSIntScope__NumberAssignment_0(); | ||
24421 | |||
24422 | state._fsp--; | ||
24423 | if (state.failed) return ; | ||
24424 | |||
24425 | } | ||
24426 | |||
24427 | if ( state.backtracking==0 ) { | ||
24428 | after(grammarAccess.getALSIntScopeAccess().getNumberAssignment_0()); | ||
24429 | } | ||
24430 | |||
24431 | } | ||
24432 | |||
24433 | |||
24434 | } | ||
24435 | |||
24436 | } | ||
24437 | catch (RecognitionException re) { | ||
24438 | reportError(re); | ||
24439 | recover(input,re); | ||
24440 | } | ||
24441 | finally { | ||
24442 | |||
24443 | restoreStackSize(stackSize); | ||
24444 | |||
24445 | } | ||
24446 | return ; | ||
24447 | } | ||
24448 | // $ANTLR end "rule__ALSIntScope__Group__0__Impl" | ||
24449 | |||
24450 | |||
24451 | // $ANTLR start "rule__ALSIntScope__Group__1" | ||
24452 | // InternalAlloyLanguage.g:8728:1: rule__ALSIntScope__Group__1 : rule__ALSIntScope__Group__1__Impl ; | ||
24453 | public final void rule__ALSIntScope__Group__1() throws RecognitionException { | ||
24454 | |||
24455 | int stackSize = keepStackSize(); | ||
24456 | |||
24457 | try { | ||
24458 | // InternalAlloyLanguage.g:8732:1: ( rule__ALSIntScope__Group__1__Impl ) | ||
24459 | // InternalAlloyLanguage.g:8733:2: rule__ALSIntScope__Group__1__Impl | ||
24460 | { | ||
24461 | pushFollow(FOLLOW_2); | ||
24462 | rule__ALSIntScope__Group__1__Impl(); | ||
24463 | |||
24464 | state._fsp--; | ||
24465 | if (state.failed) return ; | ||
24466 | |||
24467 | } | ||
24468 | |||
24469 | } | ||
24470 | catch (RecognitionException re) { | ||
24471 | reportError(re); | ||
24472 | recover(input,re); | ||
24473 | } | ||
24474 | finally { | ||
24475 | |||
24476 | restoreStackSize(stackSize); | ||
24477 | |||
24478 | } | ||
24479 | return ; | ||
24480 | } | ||
24481 | // $ANTLR end "rule__ALSIntScope__Group__1" | ||
24482 | |||
24483 | |||
24484 | // $ANTLR start "rule__ALSIntScope__Group__1__Impl" | ||
24485 | // InternalAlloyLanguage.g:8739:1: rule__ALSIntScope__Group__1__Impl : ( 'Int' ) ; | ||
24486 | public final void rule__ALSIntScope__Group__1__Impl() throws RecognitionException { | ||
24487 | |||
24488 | int stackSize = keepStackSize(); | ||
24489 | |||
24490 | try { | ||
24491 | // InternalAlloyLanguage.g:8743:1: ( ( 'Int' ) ) | ||
24492 | // InternalAlloyLanguage.g:8744:1: ( 'Int' ) | ||
24493 | { | ||
24494 | // InternalAlloyLanguage.g:8744:1: ( 'Int' ) | ||
24495 | // InternalAlloyLanguage.g:8745:1: 'Int' | ||
24496 | { | ||
24497 | if ( state.backtracking==0 ) { | ||
24498 | before(grammarAccess.getALSIntScopeAccess().getIntKeyword_1()); | ||
24499 | } | ||
24500 | match(input,68,FOLLOW_2); if (state.failed) return ; | ||
24501 | if ( state.backtracking==0 ) { | ||
24502 | after(grammarAccess.getALSIntScopeAccess().getIntKeyword_1()); | ||
24503 | } | ||
24504 | |||
24505 | } | ||
24506 | |||
24507 | |||
24508 | } | ||
24509 | |||
24510 | } | ||
24511 | catch (RecognitionException re) { | ||
24512 | reportError(re); | ||
24513 | recover(input,re); | ||
24514 | } | ||
24515 | finally { | ||
24516 | |||
24517 | restoreStackSize(stackSize); | ||
24518 | |||
24519 | } | ||
24520 | return ; | ||
24521 | } | ||
24522 | // $ANTLR end "rule__ALSIntScope__Group__1__Impl" | ||
24523 | |||
24524 | |||
24525 | // $ANTLR start "rule__ALSSignatureBody__UnorderedGroup_0" | ||
24526 | // InternalAlloyLanguage.g:8763:1: rule__ALSSignatureBody__UnorderedGroup_0 : ( rule__ALSSignatureBody__UnorderedGroup_0__0 )? ; | ||
24527 | public final void rule__ALSSignatureBody__UnorderedGroup_0() throws RecognitionException { | ||
24528 | |||
24529 | int stackSize = keepStackSize(); | ||
24530 | getUnorderedGroupHelper().enter(grammarAccess.getALSSignatureBodyAccess().getUnorderedGroup_0()); | ||
24531 | |||
24532 | try { | ||
24533 | // InternalAlloyLanguage.g:8768:1: ( ( rule__ALSSignatureBody__UnorderedGroup_0__0 )? ) | ||
24534 | // InternalAlloyLanguage.g:8769:2: ( rule__ALSSignatureBody__UnorderedGroup_0__0 )? | ||
24535 | { | ||
24536 | // InternalAlloyLanguage.g:8769:2: ( rule__ALSSignatureBody__UnorderedGroup_0__0 )? | ||
24537 | int alt51=2; | ||
24538 | int LA51_0 = input.LA(1); | ||
24539 | |||
24540 | if ( LA51_0 == 21 && getUnorderedGroupHelper().canSelect(grammarAccess.getALSSignatureBodyAccess().getUnorderedGroup_0(), 0) ) { | ||
24541 | alt51=1; | ||
24542 | } | ||
24543 | else if ( LA51_0 == 22 && getUnorderedGroupHelper().canSelect(grammarAccess.getALSSignatureBodyAccess().getUnorderedGroup_0(), 0) ) { | ||
24544 | alt51=1; | ||
24545 | } | ||
24546 | else if ( LA51_0 == 23 && getUnorderedGroupHelper().canSelect(grammarAccess.getALSSignatureBodyAccess().getUnorderedGroup_0(), 0) ) { | ||
24547 | alt51=1; | ||
24548 | } | ||
24549 | else if ( LA51_0 == 24 && getUnorderedGroupHelper().canSelect(grammarAccess.getALSSignatureBodyAccess().getUnorderedGroup_0(), 0) ) { | ||
24550 | alt51=1; | ||
24551 | } | ||
24552 | else if ( LA51_0 == 25 && getUnorderedGroupHelper().canSelect(grammarAccess.getALSSignatureBodyAccess().getUnorderedGroup_0(), 0) ) { | ||
24553 | alt51=1; | ||
24554 | } | ||
24555 | else if ( LA51_0 == 26 && getUnorderedGroupHelper().canSelect(grammarAccess.getALSSignatureBodyAccess().getUnorderedGroup_0(), 0) ) { | ||
24556 | alt51=1; | ||
24557 | } | ||
24558 | else if ( LA51_0 == 73 && getUnorderedGroupHelper().canSelect(grammarAccess.getALSSignatureBodyAccess().getUnorderedGroup_0(), 1) ) { | ||
24559 | alt51=1; | ||
24560 | } | ||
24561 | switch (alt51) { | ||
24562 | case 1 : | ||
24563 | // InternalAlloyLanguage.g:0:0: rule__ALSSignatureBody__UnorderedGroup_0__0 | ||
24564 | { | ||
24565 | pushFollow(FOLLOW_2); | ||
24566 | rule__ALSSignatureBody__UnorderedGroup_0__0(); | ||
24567 | |||
24568 | state._fsp--; | ||
24569 | if (state.failed) return ; | ||
24570 | |||
24571 | } | ||
24572 | break; | ||
24573 | |||
24574 | } | ||
24575 | |||
24576 | |||
24577 | } | ||
24578 | |||
24579 | } | ||
24580 | catch (RecognitionException re) { | ||
24581 | reportError(re); | ||
24582 | recover(input,re); | ||
24583 | } | ||
24584 | finally { | ||
24585 | |||
24586 | getUnorderedGroupHelper().leave(grammarAccess.getALSSignatureBodyAccess().getUnorderedGroup_0()); | ||
24587 | restoreStackSize(stackSize); | ||
24588 | |||
24589 | } | ||
24590 | return ; | ||
24591 | } | ||
24592 | // $ANTLR end "rule__ALSSignatureBody__UnorderedGroup_0" | ||
24593 | |||
24594 | |||
24595 | // $ANTLR start "rule__ALSSignatureBody__UnorderedGroup_0__Impl" | ||
24596 | // InternalAlloyLanguage.g:8779:1: rule__ALSSignatureBody__UnorderedGroup_0__Impl : ( ({...}? => ( ( ( rule__ALSSignatureBody__MultiplicityAssignment_0_0 ) ) ) ) | ({...}? => ( ( ( rule__ALSSignatureBody__AbstractAssignment_0_1 ) ) ) ) ) ; | ||
24597 | public final void rule__ALSSignatureBody__UnorderedGroup_0__Impl() throws RecognitionException { | ||
24598 | |||
24599 | int stackSize = keepStackSize(); | ||
24600 | boolean selected = false; | ||
24601 | |||
24602 | try { | ||
24603 | // InternalAlloyLanguage.g:8784:1: ( ( ({...}? => ( ( ( rule__ALSSignatureBody__MultiplicityAssignment_0_0 ) ) ) ) | ({...}? => ( ( ( rule__ALSSignatureBody__AbstractAssignment_0_1 ) ) ) ) ) ) | ||
24604 | // InternalAlloyLanguage.g:8785:3: ( ({...}? => ( ( ( rule__ALSSignatureBody__MultiplicityAssignment_0_0 ) ) ) ) | ({...}? => ( ( ( rule__ALSSignatureBody__AbstractAssignment_0_1 ) ) ) ) ) | ||
24605 | { | ||
24606 | // InternalAlloyLanguage.g:8785:3: ( ({...}? => ( ( ( rule__ALSSignatureBody__MultiplicityAssignment_0_0 ) ) ) ) | ({...}? => ( ( ( rule__ALSSignatureBody__AbstractAssignment_0_1 ) ) ) ) ) | ||
24607 | int alt52=2; | ||
24608 | int LA52_0 = input.LA(1); | ||
24609 | |||
24610 | if ( LA52_0 == 21 && getUnorderedGroupHelper().canSelect(grammarAccess.getALSSignatureBodyAccess().getUnorderedGroup_0(), 0) ) { | ||
24611 | alt52=1; | ||
24612 | } | ||
24613 | else if ( LA52_0 == 22 && getUnorderedGroupHelper().canSelect(grammarAccess.getALSSignatureBodyAccess().getUnorderedGroup_0(), 0) ) { | ||
24614 | alt52=1; | ||
24615 | } | ||
24616 | else if ( LA52_0 == 23 && getUnorderedGroupHelper().canSelect(grammarAccess.getALSSignatureBodyAccess().getUnorderedGroup_0(), 0) ) { | ||
24617 | alt52=1; | ||
24618 | } | ||
24619 | else if ( LA52_0 == 24 && getUnorderedGroupHelper().canSelect(grammarAccess.getALSSignatureBodyAccess().getUnorderedGroup_0(), 0) ) { | ||
24620 | alt52=1; | ||
24621 | } | ||
24622 | else if ( LA52_0 == 25 && getUnorderedGroupHelper().canSelect(grammarAccess.getALSSignatureBodyAccess().getUnorderedGroup_0(), 0) ) { | ||
24623 | alt52=1; | ||
24624 | } | ||
24625 | else if ( LA52_0 == 26 && getUnorderedGroupHelper().canSelect(grammarAccess.getALSSignatureBodyAccess().getUnorderedGroup_0(), 0) ) { | ||
24626 | alt52=1; | ||
24627 | } | ||
24628 | else if ( LA52_0 == 73 && getUnorderedGroupHelper().canSelect(grammarAccess.getALSSignatureBodyAccess().getUnorderedGroup_0(), 1) ) { | ||
24629 | alt52=2; | ||
24630 | } | ||
24631 | else { | ||
24632 | if (state.backtracking>0) {state.failed=true; return ;} | ||
24633 | NoViableAltException nvae = | ||
24634 | new NoViableAltException("", 52, 0, input); | ||
24635 | |||
24636 | throw nvae; | ||
24637 | } | ||
24638 | switch (alt52) { | ||
24639 | case 1 : | ||
24640 | // InternalAlloyLanguage.g:8787:4: ({...}? => ( ( ( rule__ALSSignatureBody__MultiplicityAssignment_0_0 ) ) ) ) | ||
24641 | { | ||
24642 | // InternalAlloyLanguage.g:8787:4: ({...}? => ( ( ( rule__ALSSignatureBody__MultiplicityAssignment_0_0 ) ) ) ) | ||
24643 | // InternalAlloyLanguage.g:8788:5: {...}? => ( ( ( rule__ALSSignatureBody__MultiplicityAssignment_0_0 ) ) ) | ||
24644 | { | ||
24645 | if ( ! getUnorderedGroupHelper().canSelect(grammarAccess.getALSSignatureBodyAccess().getUnorderedGroup_0(), 0) ) { | ||
24646 | if (state.backtracking>0) {state.failed=true; return ;} | ||
24647 | throw new FailedPredicateException(input, "rule__ALSSignatureBody__UnorderedGroup_0__Impl", "getUnorderedGroupHelper().canSelect(grammarAccess.getALSSignatureBodyAccess().getUnorderedGroup_0(), 0)"); | ||
24648 | } | ||
24649 | // InternalAlloyLanguage.g:8788:113: ( ( ( rule__ALSSignatureBody__MultiplicityAssignment_0_0 ) ) ) | ||
24650 | // InternalAlloyLanguage.g:8789:6: ( ( rule__ALSSignatureBody__MultiplicityAssignment_0_0 ) ) | ||
24651 | { | ||
24652 | getUnorderedGroupHelper().select(grammarAccess.getALSSignatureBodyAccess().getUnorderedGroup_0(), 0); | ||
24653 | selected = true; | ||
24654 | // InternalAlloyLanguage.g:8795:6: ( ( rule__ALSSignatureBody__MultiplicityAssignment_0_0 ) ) | ||
24655 | // InternalAlloyLanguage.g:8797:7: ( rule__ALSSignatureBody__MultiplicityAssignment_0_0 ) | ||
24656 | { | ||
24657 | if ( state.backtracking==0 ) { | ||
24658 | before(grammarAccess.getALSSignatureBodyAccess().getMultiplicityAssignment_0_0()); | ||
24659 | } | ||
24660 | // InternalAlloyLanguage.g:8798:7: ( rule__ALSSignatureBody__MultiplicityAssignment_0_0 ) | ||
24661 | // InternalAlloyLanguage.g:8798:8: rule__ALSSignatureBody__MultiplicityAssignment_0_0 | ||
24662 | { | ||
24663 | pushFollow(FOLLOW_2); | ||
24664 | rule__ALSSignatureBody__MultiplicityAssignment_0_0(); | ||
24665 | |||
24666 | state._fsp--; | ||
24667 | if (state.failed) return ; | ||
24668 | |||
24669 | } | ||
24670 | |||
24671 | if ( state.backtracking==0 ) { | ||
24672 | after(grammarAccess.getALSSignatureBodyAccess().getMultiplicityAssignment_0_0()); | ||
24673 | } | ||
24674 | |||
24675 | } | ||
24676 | |||
24677 | |||
24678 | } | ||
24679 | |||
24680 | |||
24681 | } | ||
24682 | |||
24683 | |||
24684 | } | ||
24685 | break; | ||
24686 | case 2 : | ||
24687 | // InternalAlloyLanguage.g:8804:4: ({...}? => ( ( ( rule__ALSSignatureBody__AbstractAssignment_0_1 ) ) ) ) | ||
24688 | { | ||
24689 | // InternalAlloyLanguage.g:8804:4: ({...}? => ( ( ( rule__ALSSignatureBody__AbstractAssignment_0_1 ) ) ) ) | ||
24690 | // InternalAlloyLanguage.g:8805:5: {...}? => ( ( ( rule__ALSSignatureBody__AbstractAssignment_0_1 ) ) ) | ||
24691 | { | ||
24692 | if ( ! getUnorderedGroupHelper().canSelect(grammarAccess.getALSSignatureBodyAccess().getUnorderedGroup_0(), 1) ) { | ||
24693 | if (state.backtracking>0) {state.failed=true; return ;} | ||
24694 | throw new FailedPredicateException(input, "rule__ALSSignatureBody__UnorderedGroup_0__Impl", "getUnorderedGroupHelper().canSelect(grammarAccess.getALSSignatureBodyAccess().getUnorderedGroup_0(), 1)"); | ||
24695 | } | ||
24696 | // InternalAlloyLanguage.g:8805:113: ( ( ( rule__ALSSignatureBody__AbstractAssignment_0_1 ) ) ) | ||
24697 | // InternalAlloyLanguage.g:8806:6: ( ( rule__ALSSignatureBody__AbstractAssignment_0_1 ) ) | ||
24698 | { | ||
24699 | getUnorderedGroupHelper().select(grammarAccess.getALSSignatureBodyAccess().getUnorderedGroup_0(), 1); | ||
24700 | selected = true; | ||
24701 | // InternalAlloyLanguage.g:8812:6: ( ( rule__ALSSignatureBody__AbstractAssignment_0_1 ) ) | ||
24702 | // InternalAlloyLanguage.g:8814:7: ( rule__ALSSignatureBody__AbstractAssignment_0_1 ) | ||
24703 | { | ||
24704 | if ( state.backtracking==0 ) { | ||
24705 | before(grammarAccess.getALSSignatureBodyAccess().getAbstractAssignment_0_1()); | ||
24706 | } | ||
24707 | // InternalAlloyLanguage.g:8815:7: ( rule__ALSSignatureBody__AbstractAssignment_0_1 ) | ||
24708 | // InternalAlloyLanguage.g:8815:8: rule__ALSSignatureBody__AbstractAssignment_0_1 | ||
24709 | { | ||
24710 | pushFollow(FOLLOW_2); | ||
24711 | rule__ALSSignatureBody__AbstractAssignment_0_1(); | ||
24712 | |||
24713 | state._fsp--; | ||
24714 | if (state.failed) return ; | ||
24715 | |||
24716 | } | ||
24717 | |||
24718 | if ( state.backtracking==0 ) { | ||
24719 | after(grammarAccess.getALSSignatureBodyAccess().getAbstractAssignment_0_1()); | ||
24720 | } | ||
24721 | |||
24722 | } | ||
24723 | |||
24724 | |||
24725 | } | ||
24726 | |||
24727 | |||
24728 | } | ||
24729 | |||
24730 | |||
24731 | } | ||
24732 | break; | ||
24733 | |||
24734 | } | ||
24735 | |||
24736 | |||
24737 | } | ||
24738 | |||
24739 | } | ||
24740 | catch (RecognitionException re) { | ||
24741 | reportError(re); | ||
24742 | recover(input,re); | ||
24743 | } | ||
24744 | finally { | ||
24745 | |||
24746 | if (selected) | ||
24747 | getUnorderedGroupHelper().returnFromSelection(grammarAccess.getALSSignatureBodyAccess().getUnorderedGroup_0()); | ||
24748 | restoreStackSize(stackSize); | ||
24749 | |||
24750 | } | ||
24751 | return ; | ||
24752 | } | ||
24753 | // $ANTLR end "rule__ALSSignatureBody__UnorderedGroup_0__Impl" | ||
24754 | |||
24755 | |||
24756 | // $ANTLR start "rule__ALSSignatureBody__UnorderedGroup_0__0" | ||
24757 | // InternalAlloyLanguage.g:8830:1: rule__ALSSignatureBody__UnorderedGroup_0__0 : rule__ALSSignatureBody__UnorderedGroup_0__Impl ( rule__ALSSignatureBody__UnorderedGroup_0__1 )? ; | ||
24758 | public final void rule__ALSSignatureBody__UnorderedGroup_0__0() throws RecognitionException { | ||
24759 | |||
24760 | int stackSize = keepStackSize(); | ||
24761 | |||
24762 | try { | ||
24763 | // InternalAlloyLanguage.g:8834:1: ( rule__ALSSignatureBody__UnorderedGroup_0__Impl ( rule__ALSSignatureBody__UnorderedGroup_0__1 )? ) | ||
24764 | // InternalAlloyLanguage.g:8835:2: rule__ALSSignatureBody__UnorderedGroup_0__Impl ( rule__ALSSignatureBody__UnorderedGroup_0__1 )? | ||
24765 | { | ||
24766 | pushFollow(FOLLOW_62); | ||
24767 | rule__ALSSignatureBody__UnorderedGroup_0__Impl(); | ||
24768 | |||
24769 | state._fsp--; | ||
24770 | if (state.failed) return ; | ||
24771 | // InternalAlloyLanguage.g:8836:2: ( rule__ALSSignatureBody__UnorderedGroup_0__1 )? | ||
24772 | int alt53=2; | ||
24773 | int LA53_0 = input.LA(1); | ||
24774 | |||
24775 | if ( LA53_0 == 21 && getUnorderedGroupHelper().canSelect(grammarAccess.getALSSignatureBodyAccess().getUnorderedGroup_0(), 0) ) { | ||
24776 | alt53=1; | ||
24777 | } | ||
24778 | else if ( LA53_0 == 22 && getUnorderedGroupHelper().canSelect(grammarAccess.getALSSignatureBodyAccess().getUnorderedGroup_0(), 0) ) { | ||
24779 | alt53=1; | ||
24780 | } | ||
24781 | else if ( LA53_0 == 23 && getUnorderedGroupHelper().canSelect(grammarAccess.getALSSignatureBodyAccess().getUnorderedGroup_0(), 0) ) { | ||
24782 | alt53=1; | ||
24783 | } | ||
24784 | else if ( LA53_0 == 24 && getUnorderedGroupHelper().canSelect(grammarAccess.getALSSignatureBodyAccess().getUnorderedGroup_0(), 0) ) { | ||
24785 | alt53=1; | ||
24786 | } | ||
24787 | else if ( LA53_0 == 25 && getUnorderedGroupHelper().canSelect(grammarAccess.getALSSignatureBodyAccess().getUnorderedGroup_0(), 0) ) { | ||
24788 | alt53=1; | ||
24789 | } | ||
24790 | else if ( LA53_0 == 26 && getUnorderedGroupHelper().canSelect(grammarAccess.getALSSignatureBodyAccess().getUnorderedGroup_0(), 0) ) { | ||
24791 | alt53=1; | ||
24792 | } | ||
24793 | else if ( LA53_0 == 73 && getUnorderedGroupHelper().canSelect(grammarAccess.getALSSignatureBodyAccess().getUnorderedGroup_0(), 1) ) { | ||
24794 | alt53=1; | ||
24795 | } | ||
24796 | switch (alt53) { | ||
24797 | case 1 : | ||
24798 | // InternalAlloyLanguage.g:0:0: rule__ALSSignatureBody__UnorderedGroup_0__1 | ||
24799 | { | ||
24800 | pushFollow(FOLLOW_2); | ||
24801 | rule__ALSSignatureBody__UnorderedGroup_0__1(); | ||
24802 | |||
24803 | state._fsp--; | ||
24804 | if (state.failed) return ; | ||
24805 | |||
24806 | } | ||
24807 | break; | ||
24808 | |||
24809 | } | ||
24810 | |||
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__ALSSignatureBody__UnorderedGroup_0__0" | ||
24827 | |||
24828 | |||
24829 | // $ANTLR start "rule__ALSSignatureBody__UnorderedGroup_0__1" | ||
24830 | // InternalAlloyLanguage.g:8843:1: rule__ALSSignatureBody__UnorderedGroup_0__1 : rule__ALSSignatureBody__UnorderedGroup_0__Impl ; | ||
24831 | public final void rule__ALSSignatureBody__UnorderedGroup_0__1() throws RecognitionException { | ||
24832 | |||
24833 | int stackSize = keepStackSize(); | ||
24834 | |||
24835 | try { | ||
24836 | // InternalAlloyLanguage.g:8847:1: ( rule__ALSSignatureBody__UnorderedGroup_0__Impl ) | ||
24837 | // InternalAlloyLanguage.g:8848:2: rule__ALSSignatureBody__UnorderedGroup_0__Impl | ||
24838 | { | ||
24839 | pushFollow(FOLLOW_2); | ||
24840 | rule__ALSSignatureBody__UnorderedGroup_0__Impl(); | ||
24841 | |||
24842 | state._fsp--; | ||
24843 | if (state.failed) return ; | ||
24844 | |||
24845 | } | ||
24846 | |||
24847 | } | ||
24848 | catch (RecognitionException re) { | ||
24849 | reportError(re); | ||
24850 | recover(input,re); | ||
24851 | } | ||
24852 | finally { | ||
24853 | |||
24854 | restoreStackSize(stackSize); | ||
24855 | |||
24856 | } | ||
24857 | return ; | ||
24858 | } | ||
24859 | // $ANTLR end "rule__ALSSignatureBody__UnorderedGroup_0__1" | ||
24860 | |||
24861 | |||
24862 | // $ANTLR start "rule__ALSDocument__EnumDeclarationsAssignment_0_0" | ||
24863 | // InternalAlloyLanguage.g:8859:1: rule__ALSDocument__EnumDeclarationsAssignment_0_0 : ( ruleALSEnumDeclaration ) ; | ||
24864 | public final void rule__ALSDocument__EnumDeclarationsAssignment_0_0() throws RecognitionException { | ||
24865 | |||
24866 | int stackSize = keepStackSize(); | ||
24867 | |||
24868 | try { | ||
24869 | // InternalAlloyLanguage.g:8863:1: ( ( ruleALSEnumDeclaration ) ) | ||
24870 | // InternalAlloyLanguage.g:8864:1: ( ruleALSEnumDeclaration ) | ||
24871 | { | ||
24872 | // InternalAlloyLanguage.g:8864:1: ( ruleALSEnumDeclaration ) | ||
24873 | // InternalAlloyLanguage.g:8865:1: ruleALSEnumDeclaration | ||
24874 | { | ||
24875 | if ( state.backtracking==0 ) { | ||
24876 | before(grammarAccess.getALSDocumentAccess().getEnumDeclarationsALSEnumDeclarationParserRuleCall_0_0_0()); | ||
24877 | } | ||
24878 | pushFollow(FOLLOW_2); | ||
24879 | ruleALSEnumDeclaration(); | ||
24880 | |||
24881 | state._fsp--; | ||
24882 | if (state.failed) return ; | ||
24883 | if ( state.backtracking==0 ) { | ||
24884 | after(grammarAccess.getALSDocumentAccess().getEnumDeclarationsALSEnumDeclarationParserRuleCall_0_0_0()); | ||
24885 | } | ||
24886 | |||
24887 | } | ||
24888 | |||
24889 | |||
24890 | } | ||
24891 | |||
24892 | } | ||
24893 | catch (RecognitionException re) { | ||
24894 | reportError(re); | ||
24895 | recover(input,re); | ||
24896 | } | ||
24897 | finally { | ||
24898 | |||
24899 | restoreStackSize(stackSize); | ||
24900 | |||
24901 | } | ||
24902 | return ; | ||
24903 | } | ||
24904 | // $ANTLR end "rule__ALSDocument__EnumDeclarationsAssignment_0_0" | ||
24905 | |||
24906 | |||
24907 | // $ANTLR start "rule__ALSDocument__SignatureBodiesAssignment_0_1" | ||
24908 | // InternalAlloyLanguage.g:8874:1: rule__ALSDocument__SignatureBodiesAssignment_0_1 : ( ruleALSSignatureBody ) ; | ||
24909 | public final void rule__ALSDocument__SignatureBodiesAssignment_0_1() throws RecognitionException { | ||
24910 | |||
24911 | int stackSize = keepStackSize(); | ||
24912 | |||
24913 | try { | ||
24914 | // InternalAlloyLanguage.g:8878:1: ( ( ruleALSSignatureBody ) ) | ||
24915 | // InternalAlloyLanguage.g:8879:1: ( ruleALSSignatureBody ) | ||
24916 | { | ||
24917 | // InternalAlloyLanguage.g:8879:1: ( ruleALSSignatureBody ) | ||
24918 | // InternalAlloyLanguage.g:8880:1: ruleALSSignatureBody | ||
24919 | { | ||
24920 | if ( state.backtracking==0 ) { | ||
24921 | before(grammarAccess.getALSDocumentAccess().getSignatureBodiesALSSignatureBodyParserRuleCall_0_1_0()); | ||
24922 | } | ||
24923 | pushFollow(FOLLOW_2); | ||
24924 | ruleALSSignatureBody(); | ||
24925 | |||
24926 | state._fsp--; | ||
24927 | if (state.failed) return ; | ||
24928 | if ( state.backtracking==0 ) { | ||
24929 | after(grammarAccess.getALSDocumentAccess().getSignatureBodiesALSSignatureBodyParserRuleCall_0_1_0()); | ||
24930 | } | ||
24931 | |||
24932 | } | ||
24933 | |||
24934 | |||
24935 | } | ||
24936 | |||
24937 | } | ||
24938 | catch (RecognitionException re) { | ||
24939 | reportError(re); | ||
24940 | recover(input,re); | ||
24941 | } | ||
24942 | finally { | ||
24943 | |||
24944 | restoreStackSize(stackSize); | ||
24945 | |||
24946 | } | ||
24947 | return ; | ||
24948 | } | ||
24949 | // $ANTLR end "rule__ALSDocument__SignatureBodiesAssignment_0_1" | ||
24950 | |||
24951 | |||
24952 | // $ANTLR start "rule__ALSDocument__FunctionDefinitionsAssignment_0_2" | ||
24953 | // InternalAlloyLanguage.g:8889:1: rule__ALSDocument__FunctionDefinitionsAssignment_0_2 : ( ruleALSFunctionDefinition ) ; | ||
24954 | public final void rule__ALSDocument__FunctionDefinitionsAssignment_0_2() throws RecognitionException { | ||
24955 | |||
24956 | int stackSize = keepStackSize(); | ||
24957 | |||
24958 | try { | ||
24959 | // InternalAlloyLanguage.g:8893:1: ( ( ruleALSFunctionDefinition ) ) | ||
24960 | // InternalAlloyLanguage.g:8894:1: ( ruleALSFunctionDefinition ) | ||
24961 | { | ||
24962 | // InternalAlloyLanguage.g:8894:1: ( ruleALSFunctionDefinition ) | ||
24963 | // InternalAlloyLanguage.g:8895:1: ruleALSFunctionDefinition | ||
24964 | { | ||
24965 | if ( state.backtracking==0 ) { | ||
24966 | before(grammarAccess.getALSDocumentAccess().getFunctionDefinitionsALSFunctionDefinitionParserRuleCall_0_2_0()); | ||
24967 | } | ||
24968 | pushFollow(FOLLOW_2); | ||
24969 | ruleALSFunctionDefinition(); | ||
24970 | |||
24971 | state._fsp--; | ||
24972 | if (state.failed) return ; | ||
24973 | if ( state.backtracking==0 ) { | ||
24974 | after(grammarAccess.getALSDocumentAccess().getFunctionDefinitionsALSFunctionDefinitionParserRuleCall_0_2_0()); | ||
24975 | } | ||
24976 | |||
24977 | } | ||
24978 | |||
24979 | |||
24980 | } | ||
24981 | |||
24982 | } | ||
24983 | catch (RecognitionException re) { | ||
24984 | reportError(re); | ||
24985 | recover(input,re); | ||
24986 | } | ||
24987 | finally { | ||
24988 | |||
24989 | restoreStackSize(stackSize); | ||
24990 | |||
24991 | } | ||
24992 | return ; | ||
24993 | } | ||
24994 | // $ANTLR end "rule__ALSDocument__FunctionDefinitionsAssignment_0_2" | ||
24995 | |||
24996 | |||
24997 | // $ANTLR start "rule__ALSDocument__RelationDefinitionsAssignment_0_3" | ||
24998 | // InternalAlloyLanguage.g:8904:1: rule__ALSDocument__RelationDefinitionsAssignment_0_3 : ( ruleALSRelationDefinition ) ; | ||
24999 | public final void rule__ALSDocument__RelationDefinitionsAssignment_0_3() throws RecognitionException { | ||
25000 | |||
25001 | int stackSize = keepStackSize(); | ||
25002 | |||
25003 | try { | ||
25004 | // InternalAlloyLanguage.g:8908:1: ( ( ruleALSRelationDefinition ) ) | ||
25005 | // InternalAlloyLanguage.g:8909:1: ( ruleALSRelationDefinition ) | ||
25006 | { | ||
25007 | // InternalAlloyLanguage.g:8909:1: ( ruleALSRelationDefinition ) | ||
25008 | // InternalAlloyLanguage.g:8910:1: ruleALSRelationDefinition | ||
25009 | { | ||
25010 | if ( state.backtracking==0 ) { | ||
25011 | before(grammarAccess.getALSDocumentAccess().getRelationDefinitionsALSRelationDefinitionParserRuleCall_0_3_0()); | ||
25012 | } | ||
25013 | pushFollow(FOLLOW_2); | ||
25014 | ruleALSRelationDefinition(); | ||
25015 | |||
25016 | state._fsp--; | ||
25017 | if (state.failed) return ; | ||
25018 | if ( state.backtracking==0 ) { | ||
25019 | after(grammarAccess.getALSDocumentAccess().getRelationDefinitionsALSRelationDefinitionParserRuleCall_0_3_0()); | ||
25020 | } | ||
25021 | |||
25022 | } | ||
25023 | |||
25024 | |||
25025 | } | ||
25026 | |||
25027 | } | ||
25028 | catch (RecognitionException re) { | ||
25029 | reportError(re); | ||
25030 | recover(input,re); | ||
25031 | } | ||
25032 | finally { | ||
25033 | |||
25034 | restoreStackSize(stackSize); | ||
25035 | |||
25036 | } | ||
25037 | return ; | ||
25038 | } | ||
25039 | // $ANTLR end "rule__ALSDocument__RelationDefinitionsAssignment_0_3" | ||
25040 | |||
25041 | |||
25042 | // $ANTLR start "rule__ALSDocument__FactDeclarationsAssignment_0_4" | ||
25043 | // InternalAlloyLanguage.g:8919:1: rule__ALSDocument__FactDeclarationsAssignment_0_4 : ( ruleALSFactDeclaration ) ; | ||
25044 | public final void rule__ALSDocument__FactDeclarationsAssignment_0_4() throws RecognitionException { | ||
25045 | |||
25046 | int stackSize = keepStackSize(); | ||
25047 | |||
25048 | try { | ||
25049 | // InternalAlloyLanguage.g:8923:1: ( ( ruleALSFactDeclaration ) ) | ||
25050 | // InternalAlloyLanguage.g:8924:1: ( ruleALSFactDeclaration ) | ||
25051 | { | ||
25052 | // InternalAlloyLanguage.g:8924:1: ( ruleALSFactDeclaration ) | ||
25053 | // InternalAlloyLanguage.g:8925:1: ruleALSFactDeclaration | ||
25054 | { | ||
25055 | if ( state.backtracking==0 ) { | ||
25056 | before(grammarAccess.getALSDocumentAccess().getFactDeclarationsALSFactDeclarationParserRuleCall_0_4_0()); | ||
25057 | } | ||
25058 | pushFollow(FOLLOW_2); | ||
25059 | ruleALSFactDeclaration(); | ||
25060 | |||
25061 | state._fsp--; | ||
25062 | if (state.failed) return ; | ||
25063 | if ( state.backtracking==0 ) { | ||
25064 | after(grammarAccess.getALSDocumentAccess().getFactDeclarationsALSFactDeclarationParserRuleCall_0_4_0()); | ||
25065 | } | ||
25066 | |||
25067 | } | ||
25068 | |||
25069 | |||
25070 | } | ||
25071 | |||
25072 | } | ||
25073 | catch (RecognitionException re) { | ||
25074 | reportError(re); | ||
25075 | recover(input,re); | ||
25076 | } | ||
25077 | finally { | ||
25078 | |||
25079 | restoreStackSize(stackSize); | ||
25080 | |||
25081 | } | ||
25082 | return ; | ||
25083 | } | ||
25084 | // $ANTLR end "rule__ALSDocument__FactDeclarationsAssignment_0_4" | ||
25085 | |||
25086 | |||
25087 | // $ANTLR start "rule__ALSDocument__RunCommandAssignment_1" | ||
25088 | // InternalAlloyLanguage.g:8934:1: rule__ALSDocument__RunCommandAssignment_1 : ( ruleALSRunCommand ) ; | ||
25089 | public final void rule__ALSDocument__RunCommandAssignment_1() throws RecognitionException { | ||
25090 | |||
25091 | int stackSize = keepStackSize(); | ||
25092 | |||
25093 | try { | ||
25094 | // InternalAlloyLanguage.g:8938:1: ( ( ruleALSRunCommand ) ) | ||
25095 | // InternalAlloyLanguage.g:8939:1: ( ruleALSRunCommand ) | ||
25096 | { | ||
25097 | // InternalAlloyLanguage.g:8939:1: ( ruleALSRunCommand ) | ||
25098 | // InternalAlloyLanguage.g:8940:1: ruleALSRunCommand | ||
25099 | { | ||
25100 | if ( state.backtracking==0 ) { | ||
25101 | before(grammarAccess.getALSDocumentAccess().getRunCommandALSRunCommandParserRuleCall_1_0()); | ||
25102 | } | ||
25103 | pushFollow(FOLLOW_2); | ||
25104 | ruleALSRunCommand(); | ||
25105 | |||
25106 | state._fsp--; | ||
25107 | if (state.failed) return ; | ||
25108 | if ( state.backtracking==0 ) { | ||
25109 | after(grammarAccess.getALSDocumentAccess().getRunCommandALSRunCommandParserRuleCall_1_0()); | ||
25110 | } | ||
25111 | |||
25112 | } | ||
25113 | |||
25114 | |||
25115 | } | ||
25116 | |||
25117 | } | ||
25118 | catch (RecognitionException re) { | ||
25119 | reportError(re); | ||
25120 | recover(input,re); | ||
25121 | } | ||
25122 | finally { | ||
25123 | |||
25124 | restoreStackSize(stackSize); | ||
25125 | |||
25126 | } | ||
25127 | return ; | ||
25128 | } | ||
25129 | // $ANTLR end "rule__ALSDocument__RunCommandAssignment_1" | ||
25130 | |||
25131 | |||
25132 | // $ANTLR start "rule__ALSEnumDeclaration__NameAssignment_1" | ||
25133 | // InternalAlloyLanguage.g:8949:1: rule__ALSEnumDeclaration__NameAssignment_1 : ( ruleALSID ) ; | ||
25134 | public final void rule__ALSEnumDeclaration__NameAssignment_1() throws RecognitionException { | ||
25135 | |||
25136 | int stackSize = keepStackSize(); | ||
25137 | |||
25138 | try { | ||
25139 | // InternalAlloyLanguage.g:8953:1: ( ( ruleALSID ) ) | ||
25140 | // InternalAlloyLanguage.g:8954:1: ( ruleALSID ) | ||
25141 | { | ||
25142 | // InternalAlloyLanguage.g:8954:1: ( ruleALSID ) | ||
25143 | // InternalAlloyLanguage.g:8955:1: ruleALSID | ||
25144 | { | ||
25145 | if ( state.backtracking==0 ) { | ||
25146 | before(grammarAccess.getALSEnumDeclarationAccess().getNameALSIDParserRuleCall_1_0()); | ||
25147 | } | ||
25148 | pushFollow(FOLLOW_2); | ||
25149 | ruleALSID(); | ||
25150 | |||
25151 | state._fsp--; | ||
25152 | if (state.failed) return ; | ||
25153 | if ( state.backtracking==0 ) { | ||
25154 | after(grammarAccess.getALSEnumDeclarationAccess().getNameALSIDParserRuleCall_1_0()); | ||
25155 | } | ||
25156 | |||
25157 | } | ||
25158 | |||
25159 | |||
25160 | } | ||
25161 | |||
25162 | } | ||
25163 | catch (RecognitionException re) { | ||
25164 | reportError(re); | ||
25165 | recover(input,re); | ||
25166 | } | ||
25167 | finally { | ||
25168 | |||
25169 | restoreStackSize(stackSize); | ||
25170 | |||
25171 | } | ||
25172 | return ; | ||
25173 | } | ||
25174 | // $ANTLR end "rule__ALSEnumDeclaration__NameAssignment_1" | ||
25175 | |||
25176 | |||
25177 | // $ANTLR start "rule__ALSEnumDeclaration__LiteralAssignment_3" | ||
25178 | // InternalAlloyLanguage.g:8964:1: rule__ALSEnumDeclaration__LiteralAssignment_3 : ( ruleALSEnumLiteral ) ; | ||
25179 | public final void rule__ALSEnumDeclaration__LiteralAssignment_3() throws RecognitionException { | ||
25180 | |||
25181 | int stackSize = keepStackSize(); | ||
25182 | |||
25183 | try { | ||
25184 | // InternalAlloyLanguage.g:8968:1: ( ( ruleALSEnumLiteral ) ) | ||
25185 | // InternalAlloyLanguage.g:8969:1: ( ruleALSEnumLiteral ) | ||
25186 | { | ||
25187 | // InternalAlloyLanguage.g:8969:1: ( ruleALSEnumLiteral ) | ||
25188 | // InternalAlloyLanguage.g:8970:1: ruleALSEnumLiteral | ||
25189 | { | ||
25190 | if ( state.backtracking==0 ) { | ||
25191 | before(grammarAccess.getALSEnumDeclarationAccess().getLiteralALSEnumLiteralParserRuleCall_3_0()); | ||
25192 | } | ||
25193 | pushFollow(FOLLOW_2); | ||
25194 | ruleALSEnumLiteral(); | ||
25195 | |||
25196 | state._fsp--; | ||
25197 | if (state.failed) return ; | ||
25198 | if ( state.backtracking==0 ) { | ||
25199 | after(grammarAccess.getALSEnumDeclarationAccess().getLiteralALSEnumLiteralParserRuleCall_3_0()); | ||
25200 | } | ||
25201 | |||
25202 | } | ||
25203 | |||
25204 | |||
25205 | } | ||
25206 | |||
25207 | } | ||
25208 | catch (RecognitionException re) { | ||
25209 | reportError(re); | ||
25210 | recover(input,re); | ||
25211 | } | ||
25212 | finally { | ||
25213 | |||
25214 | restoreStackSize(stackSize); | ||
25215 | |||
25216 | } | ||
25217 | return ; | ||
25218 | } | ||
25219 | // $ANTLR end "rule__ALSEnumDeclaration__LiteralAssignment_3" | ||
25220 | |||
25221 | |||
25222 | // $ANTLR start "rule__ALSEnumDeclaration__LiteralAssignment_4_1" | ||
25223 | // InternalAlloyLanguage.g:8979:1: rule__ALSEnumDeclaration__LiteralAssignment_4_1 : ( ruleALSEnumLiteral ) ; | ||
25224 | public final void rule__ALSEnumDeclaration__LiteralAssignment_4_1() throws RecognitionException { | ||
25225 | |||
25226 | int stackSize = keepStackSize(); | ||
25227 | |||
25228 | try { | ||
25229 | // InternalAlloyLanguage.g:8983:1: ( ( ruleALSEnumLiteral ) ) | ||
25230 | // InternalAlloyLanguage.g:8984:1: ( ruleALSEnumLiteral ) | ||
25231 | { | ||
25232 | // InternalAlloyLanguage.g:8984:1: ( ruleALSEnumLiteral ) | ||
25233 | // InternalAlloyLanguage.g:8985:1: ruleALSEnumLiteral | ||
25234 | { | ||
25235 | if ( state.backtracking==0 ) { | ||
25236 | before(grammarAccess.getALSEnumDeclarationAccess().getLiteralALSEnumLiteralParserRuleCall_4_1_0()); | ||
25237 | } | ||
25238 | pushFollow(FOLLOW_2); | ||
25239 | ruleALSEnumLiteral(); | ||
25240 | |||
25241 | state._fsp--; | ||
25242 | if (state.failed) return ; | ||
25243 | if ( state.backtracking==0 ) { | ||
25244 | after(grammarAccess.getALSEnumDeclarationAccess().getLiteralALSEnumLiteralParserRuleCall_4_1_0()); | ||
25245 | } | ||
25246 | |||
25247 | } | ||
25248 | |||
25249 | |||
25250 | } | ||
25251 | |||
25252 | } | ||
25253 | catch (RecognitionException re) { | ||
25254 | reportError(re); | ||
25255 | recover(input,re); | ||
25256 | } | ||
25257 | finally { | ||
25258 | |||
25259 | restoreStackSize(stackSize); | ||
25260 | |||
25261 | } | ||
25262 | return ; | ||
25263 | } | ||
25264 | // $ANTLR end "rule__ALSEnumDeclaration__LiteralAssignment_4_1" | ||
25265 | |||
25266 | |||
25267 | // $ANTLR start "rule__ALSEnumLiteral__NameAssignment" | ||
25268 | // InternalAlloyLanguage.g:8994:1: rule__ALSEnumLiteral__NameAssignment : ( ruleALSID ) ; | ||
25269 | public final void rule__ALSEnumLiteral__NameAssignment() throws RecognitionException { | ||
25270 | |||
25271 | int stackSize = keepStackSize(); | ||
25272 | |||
25273 | try { | ||
25274 | // InternalAlloyLanguage.g:8998:1: ( ( ruleALSID ) ) | ||
25275 | // InternalAlloyLanguage.g:8999:1: ( ruleALSID ) | ||
25276 | { | ||
25277 | // InternalAlloyLanguage.g:8999:1: ( ruleALSID ) | ||
25278 | // InternalAlloyLanguage.g:9000:1: ruleALSID | ||
25279 | { | ||
25280 | if ( state.backtracking==0 ) { | ||
25281 | before(grammarAccess.getALSEnumLiteralAccess().getNameALSIDParserRuleCall_0()); | ||
25282 | } | ||
25283 | pushFollow(FOLLOW_2); | ||
25284 | ruleALSID(); | ||
25285 | |||
25286 | state._fsp--; | ||
25287 | if (state.failed) return ; | ||
25288 | if ( state.backtracking==0 ) { | ||
25289 | after(grammarAccess.getALSEnumLiteralAccess().getNameALSIDParserRuleCall_0()); | ||
25290 | } | ||
25291 | |||
25292 | } | ||
25293 | |||
25294 | |||
25295 | } | ||
25296 | |||
25297 | } | ||
25298 | catch (RecognitionException re) { | ||
25299 | reportError(re); | ||
25300 | recover(input,re); | ||
25301 | } | ||
25302 | finally { | ||
25303 | |||
25304 | restoreStackSize(stackSize); | ||
25305 | |||
25306 | } | ||
25307 | return ; | ||
25308 | } | ||
25309 | // $ANTLR end "rule__ALSEnumLiteral__NameAssignment" | ||
25310 | |||
25311 | |||
25312 | // $ANTLR start "rule__ALSSignatureDeclaration__NameAssignment" | ||
25313 | // InternalAlloyLanguage.g:9009:1: rule__ALSSignatureDeclaration__NameAssignment : ( ruleALSID ) ; | ||
25314 | public final void rule__ALSSignatureDeclaration__NameAssignment() throws RecognitionException { | ||
25315 | |||
25316 | int stackSize = keepStackSize(); | ||
25317 | |||
25318 | try { | ||
25319 | // InternalAlloyLanguage.g:9013:1: ( ( ruleALSID ) ) | ||
25320 | // InternalAlloyLanguage.g:9014:1: ( ruleALSID ) | ||
25321 | { | ||
25322 | // InternalAlloyLanguage.g:9014:1: ( ruleALSID ) | ||
25323 | // InternalAlloyLanguage.g:9015:1: ruleALSID | ||
25324 | { | ||
25325 | if ( state.backtracking==0 ) { | ||
25326 | before(grammarAccess.getALSSignatureDeclarationAccess().getNameALSIDParserRuleCall_0()); | ||
25327 | } | ||
25328 | pushFollow(FOLLOW_2); | ||
25329 | ruleALSID(); | ||
25330 | |||
25331 | state._fsp--; | ||
25332 | if (state.failed) return ; | ||
25333 | if ( state.backtracking==0 ) { | ||
25334 | after(grammarAccess.getALSSignatureDeclarationAccess().getNameALSIDParserRuleCall_0()); | ||
25335 | } | ||
25336 | |||
25337 | } | ||
25338 | |||
25339 | |||
25340 | } | ||
25341 | |||
25342 | } | ||
25343 | catch (RecognitionException re) { | ||
25344 | reportError(re); | ||
25345 | recover(input,re); | ||
25346 | } | ||
25347 | finally { | ||
25348 | |||
25349 | restoreStackSize(stackSize); | ||
25350 | |||
25351 | } | ||
25352 | return ; | ||
25353 | } | ||
25354 | // $ANTLR end "rule__ALSSignatureDeclaration__NameAssignment" | ||
25355 | |||
25356 | |||
25357 | // $ANTLR start "rule__ALSSignatureBody__MultiplicityAssignment_0_0" | ||
25358 | // InternalAlloyLanguage.g:9024:1: rule__ALSSignatureBody__MultiplicityAssignment_0_0 : ( ruleALSMultiplicity ) ; | ||
25359 | public final void rule__ALSSignatureBody__MultiplicityAssignment_0_0() throws RecognitionException { | ||
25360 | |||
25361 | int stackSize = keepStackSize(); | ||
25362 | |||
25363 | try { | ||
25364 | // InternalAlloyLanguage.g:9028:1: ( ( ruleALSMultiplicity ) ) | ||
25365 | // InternalAlloyLanguage.g:9029:1: ( ruleALSMultiplicity ) | ||
25366 | { | ||
25367 | // InternalAlloyLanguage.g:9029:1: ( ruleALSMultiplicity ) | ||
25368 | // InternalAlloyLanguage.g:9030:1: ruleALSMultiplicity | ||
25369 | { | ||
25370 | if ( state.backtracking==0 ) { | ||
25371 | before(grammarAccess.getALSSignatureBodyAccess().getMultiplicityALSMultiplicityEnumRuleCall_0_0_0()); | ||
25372 | } | ||
25373 | pushFollow(FOLLOW_2); | ||
25374 | ruleALSMultiplicity(); | ||
25375 | |||
25376 | state._fsp--; | ||
25377 | if (state.failed) return ; | ||
25378 | if ( state.backtracking==0 ) { | ||
25379 | after(grammarAccess.getALSSignatureBodyAccess().getMultiplicityALSMultiplicityEnumRuleCall_0_0_0()); | ||
25380 | } | ||
25381 | |||
25382 | } | ||
25383 | |||
25384 | |||
25385 | } | ||
25386 | |||
25387 | } | ||
25388 | catch (RecognitionException re) { | ||
25389 | reportError(re); | ||
25390 | recover(input,re); | ||
25391 | } | ||
25392 | finally { | ||
25393 | |||
25394 | restoreStackSize(stackSize); | ||
25395 | |||
25396 | } | ||
25397 | return ; | ||
25398 | } | ||
25399 | // $ANTLR end "rule__ALSSignatureBody__MultiplicityAssignment_0_0" | ||
25400 | |||
25401 | |||
25402 | // $ANTLR start "rule__ALSSignatureBody__AbstractAssignment_0_1" | ||
25403 | // InternalAlloyLanguage.g:9039:1: rule__ALSSignatureBody__AbstractAssignment_0_1 : ( ( 'abstract' ) ) ; | ||
25404 | public final void rule__ALSSignatureBody__AbstractAssignment_0_1() throws RecognitionException { | ||
25405 | |||
25406 | int stackSize = keepStackSize(); | ||
25407 | |||
25408 | try { | ||
25409 | // InternalAlloyLanguage.g:9043:1: ( ( ( 'abstract' ) ) ) | ||
25410 | // InternalAlloyLanguage.g:9044:1: ( ( 'abstract' ) ) | ||
25411 | { | ||
25412 | // InternalAlloyLanguage.g:9044:1: ( ( 'abstract' ) ) | ||
25413 | // InternalAlloyLanguage.g:9045:1: ( 'abstract' ) | ||
25414 | { | ||
25415 | if ( state.backtracking==0 ) { | ||
25416 | before(grammarAccess.getALSSignatureBodyAccess().getAbstractAbstractKeyword_0_1_0()); | ||
25417 | } | ||
25418 | // InternalAlloyLanguage.g:9046:1: ( 'abstract' ) | ||
25419 | // InternalAlloyLanguage.g:9047:1: 'abstract' | ||
25420 | { | ||
25421 | if ( state.backtracking==0 ) { | ||
25422 | before(grammarAccess.getALSSignatureBodyAccess().getAbstractAbstractKeyword_0_1_0()); | ||
25423 | } | ||
25424 | match(input,73,FOLLOW_2); if (state.failed) return ; | ||
25425 | if ( state.backtracking==0 ) { | ||
25426 | after(grammarAccess.getALSSignatureBodyAccess().getAbstractAbstractKeyword_0_1_0()); | ||
25427 | } | ||
25428 | |||
25429 | } | ||
25430 | |||
25431 | if ( state.backtracking==0 ) { | ||
25432 | after(grammarAccess.getALSSignatureBodyAccess().getAbstractAbstractKeyword_0_1_0()); | ||
25433 | } | ||
25434 | |||
25435 | } | ||
25436 | |||
25437 | |||
25438 | } | ||
25439 | |||
25440 | } | ||
25441 | catch (RecognitionException re) { | ||
25442 | reportError(re); | ||
25443 | recover(input,re); | ||
25444 | } | ||
25445 | finally { | ||
25446 | |||
25447 | restoreStackSize(stackSize); | ||
25448 | |||
25449 | } | ||
25450 | return ; | ||
25451 | } | ||
25452 | // $ANTLR end "rule__ALSSignatureBody__AbstractAssignment_0_1" | ||
25453 | |||
25454 | |||
25455 | // $ANTLR start "rule__ALSSignatureBody__DeclarationsAssignment_2" | ||
25456 | // InternalAlloyLanguage.g:9062:1: rule__ALSSignatureBody__DeclarationsAssignment_2 : ( ruleALSSignatureDeclaration ) ; | ||
25457 | public final void rule__ALSSignatureBody__DeclarationsAssignment_2() throws RecognitionException { | ||
25458 | |||
25459 | int stackSize = keepStackSize(); | ||
25460 | |||
25461 | try { | ||
25462 | // InternalAlloyLanguage.g:9066:1: ( ( ruleALSSignatureDeclaration ) ) | ||
25463 | // InternalAlloyLanguage.g:9067:1: ( ruleALSSignatureDeclaration ) | ||
25464 | { | ||
25465 | // InternalAlloyLanguage.g:9067:1: ( ruleALSSignatureDeclaration ) | ||
25466 | // InternalAlloyLanguage.g:9068:1: ruleALSSignatureDeclaration | ||
25467 | { | ||
25468 | if ( state.backtracking==0 ) { | ||
25469 | before(grammarAccess.getALSSignatureBodyAccess().getDeclarationsALSSignatureDeclarationParserRuleCall_2_0()); | ||
25470 | } | ||
25471 | pushFollow(FOLLOW_2); | ||
25472 | ruleALSSignatureDeclaration(); | ||
25473 | |||
25474 | state._fsp--; | ||
25475 | if (state.failed) return ; | ||
25476 | if ( state.backtracking==0 ) { | ||
25477 | after(grammarAccess.getALSSignatureBodyAccess().getDeclarationsALSSignatureDeclarationParserRuleCall_2_0()); | ||
25478 | } | ||
25479 | |||
25480 | } | ||
25481 | |||
25482 | |||
25483 | } | ||
25484 | |||
25485 | } | ||
25486 | catch (RecognitionException re) { | ||
25487 | reportError(re); | ||
25488 | recover(input,re); | ||
25489 | } | ||
25490 | finally { | ||
25491 | |||
25492 | restoreStackSize(stackSize); | ||
25493 | |||
25494 | } | ||
25495 | return ; | ||
25496 | } | ||
25497 | // $ANTLR end "rule__ALSSignatureBody__DeclarationsAssignment_2" | ||
25498 | |||
25499 | |||
25500 | // $ANTLR start "rule__ALSSignatureBody__DeclarationsAssignment_3_1" | ||
25501 | // InternalAlloyLanguage.g:9077:1: rule__ALSSignatureBody__DeclarationsAssignment_3_1 : ( ruleALSSignatureDeclaration ) ; | ||
25502 | public final void rule__ALSSignatureBody__DeclarationsAssignment_3_1() throws RecognitionException { | ||
25503 | |||
25504 | int stackSize = keepStackSize(); | ||
25505 | |||
25506 | try { | ||
25507 | // InternalAlloyLanguage.g:9081:1: ( ( ruleALSSignatureDeclaration ) ) | ||
25508 | // InternalAlloyLanguage.g:9082:1: ( ruleALSSignatureDeclaration ) | ||
25509 | { | ||
25510 | // InternalAlloyLanguage.g:9082:1: ( ruleALSSignatureDeclaration ) | ||
25511 | // InternalAlloyLanguage.g:9083:1: ruleALSSignatureDeclaration | ||
25512 | { | ||
25513 | if ( state.backtracking==0 ) { | ||
25514 | before(grammarAccess.getALSSignatureBodyAccess().getDeclarationsALSSignatureDeclarationParserRuleCall_3_1_0()); | ||
25515 | } | ||
25516 | pushFollow(FOLLOW_2); | ||
25517 | ruleALSSignatureDeclaration(); | ||
25518 | |||
25519 | state._fsp--; | ||
25520 | if (state.failed) return ; | ||
25521 | if ( state.backtracking==0 ) { | ||
25522 | after(grammarAccess.getALSSignatureBodyAccess().getDeclarationsALSSignatureDeclarationParserRuleCall_3_1_0()); | ||
25523 | } | ||
25524 | |||
25525 | } | ||
25526 | |||
25527 | |||
25528 | } | ||
25529 | |||
25530 | } | ||
25531 | catch (RecognitionException re) { | ||
25532 | reportError(re); | ||
25533 | recover(input,re); | ||
25534 | } | ||
25535 | finally { | ||
25536 | |||
25537 | restoreStackSize(stackSize); | ||
25538 | |||
25539 | } | ||
25540 | return ; | ||
25541 | } | ||
25542 | // $ANTLR end "rule__ALSSignatureBody__DeclarationsAssignment_3_1" | ||
25543 | |||
25544 | |||
25545 | // $ANTLR start "rule__ALSSignatureBody__SupertypeAssignment_4_0_1" | ||
25546 | // InternalAlloyLanguage.g:9092:1: rule__ALSSignatureBody__SupertypeAssignment_4_0_1 : ( ( RULE_ID ) ) ; | ||
25547 | public final void rule__ALSSignatureBody__SupertypeAssignment_4_0_1() throws RecognitionException { | ||
25548 | |||
25549 | int stackSize = keepStackSize(); | ||
25550 | |||
25551 | try { | ||
25552 | // InternalAlloyLanguage.g:9096:1: ( ( ( RULE_ID ) ) ) | ||
25553 | // InternalAlloyLanguage.g:9097:1: ( ( RULE_ID ) ) | ||
25554 | { | ||
25555 | // InternalAlloyLanguage.g:9097:1: ( ( RULE_ID ) ) | ||
25556 | // InternalAlloyLanguage.g:9098:1: ( RULE_ID ) | ||
25557 | { | ||
25558 | if ( state.backtracking==0 ) { | ||
25559 | before(grammarAccess.getALSSignatureBodyAccess().getSupertypeALSSignatureDeclarationCrossReference_4_0_1_0()); | ||
25560 | } | ||
25561 | // InternalAlloyLanguage.g:9099:1: ( RULE_ID ) | ||
25562 | // InternalAlloyLanguage.g:9100:1: RULE_ID | ||
25563 | { | ||
25564 | if ( state.backtracking==0 ) { | ||
25565 | before(grammarAccess.getALSSignatureBodyAccess().getSupertypeALSSignatureDeclarationIDTerminalRuleCall_4_0_1_0_1()); | ||
25566 | } | ||
25567 | match(input,RULE_ID,FOLLOW_2); if (state.failed) return ; | ||
25568 | if ( state.backtracking==0 ) { | ||
25569 | after(grammarAccess.getALSSignatureBodyAccess().getSupertypeALSSignatureDeclarationIDTerminalRuleCall_4_0_1_0_1()); | ||
25570 | } | ||
25571 | |||
25572 | } | ||
25573 | |||
25574 | if ( state.backtracking==0 ) { | ||
25575 | after(grammarAccess.getALSSignatureBodyAccess().getSupertypeALSSignatureDeclarationCrossReference_4_0_1_0()); | ||
25576 | } | ||
25577 | |||
25578 | } | ||
25579 | |||
25580 | |||
25581 | } | ||
25582 | |||
25583 | } | ||
25584 | catch (RecognitionException re) { | ||
25585 | reportError(re); | ||
25586 | recover(input,re); | ||
25587 | } | ||
25588 | finally { | ||
25589 | |||
25590 | restoreStackSize(stackSize); | ||
25591 | |||
25592 | } | ||
25593 | return ; | ||
25594 | } | ||
25595 | // $ANTLR end "rule__ALSSignatureBody__SupertypeAssignment_4_0_1" | ||
25596 | |||
25597 | |||
25598 | // $ANTLR start "rule__ALSSignatureBody__SupersetAssignment_4_1_1" | ||
25599 | // InternalAlloyLanguage.g:9111:1: rule__ALSSignatureBody__SupersetAssignment_4_1_1 : ( ( RULE_ID ) ) ; | ||
25600 | public final void rule__ALSSignatureBody__SupersetAssignment_4_1_1() throws RecognitionException { | ||
25601 | |||
25602 | int stackSize = keepStackSize(); | ||
25603 | |||
25604 | try { | ||
25605 | // InternalAlloyLanguage.g:9115:1: ( ( ( RULE_ID ) ) ) | ||
25606 | // InternalAlloyLanguage.g:9116:1: ( ( RULE_ID ) ) | ||
25607 | { | ||
25608 | // InternalAlloyLanguage.g:9116:1: ( ( RULE_ID ) ) | ||
25609 | // InternalAlloyLanguage.g:9117:1: ( RULE_ID ) | ||
25610 | { | ||
25611 | if ( state.backtracking==0 ) { | ||
25612 | before(grammarAccess.getALSSignatureBodyAccess().getSupersetALSSignatureDeclarationCrossReference_4_1_1_0()); | ||
25613 | } | ||
25614 | // InternalAlloyLanguage.g:9118:1: ( RULE_ID ) | ||
25615 | // InternalAlloyLanguage.g:9119:1: RULE_ID | ||
25616 | { | ||
25617 | if ( state.backtracking==0 ) { | ||
25618 | before(grammarAccess.getALSSignatureBodyAccess().getSupersetALSSignatureDeclarationIDTerminalRuleCall_4_1_1_0_1()); | ||
25619 | } | ||
25620 | match(input,RULE_ID,FOLLOW_2); if (state.failed) return ; | ||
25621 | if ( state.backtracking==0 ) { | ||
25622 | after(grammarAccess.getALSSignatureBodyAccess().getSupersetALSSignatureDeclarationIDTerminalRuleCall_4_1_1_0_1()); | ||
25623 | } | ||
25624 | |||
25625 | } | ||
25626 | |||
25627 | if ( state.backtracking==0 ) { | ||
25628 | after(grammarAccess.getALSSignatureBodyAccess().getSupersetALSSignatureDeclarationCrossReference_4_1_1_0()); | ||
25629 | } | ||
25630 | |||
25631 | } | ||
25632 | |||
25633 | |||
25634 | } | ||
25635 | |||
25636 | } | ||
25637 | catch (RecognitionException re) { | ||
25638 | reportError(re); | ||
25639 | recover(input,re); | ||
25640 | } | ||
25641 | finally { | ||
25642 | |||
25643 | restoreStackSize(stackSize); | ||
25644 | |||
25645 | } | ||
25646 | return ; | ||
25647 | } | ||
25648 | // $ANTLR end "rule__ALSSignatureBody__SupersetAssignment_4_1_1" | ||
25649 | |||
25650 | |||
25651 | // $ANTLR start "rule__ALSSignatureBody__SupersetAssignment_4_1_2_1" | ||
25652 | // InternalAlloyLanguage.g:9130:1: rule__ALSSignatureBody__SupersetAssignment_4_1_2_1 : ( ( RULE_ID ) ) ; | ||
25653 | public final void rule__ALSSignatureBody__SupersetAssignment_4_1_2_1() throws RecognitionException { | ||
25654 | |||
25655 | int stackSize = keepStackSize(); | ||
25656 | |||
25657 | try { | ||
25658 | // InternalAlloyLanguage.g:9134:1: ( ( ( RULE_ID ) ) ) | ||
25659 | // InternalAlloyLanguage.g:9135:1: ( ( RULE_ID ) ) | ||
25660 | { | ||
25661 | // InternalAlloyLanguage.g:9135:1: ( ( RULE_ID ) ) | ||
25662 | // InternalAlloyLanguage.g:9136:1: ( RULE_ID ) | ||
25663 | { | ||
25664 | if ( state.backtracking==0 ) { | ||
25665 | before(grammarAccess.getALSSignatureBodyAccess().getSupersetALSSignatureDeclarationCrossReference_4_1_2_1_0()); | ||
25666 | } | ||
25667 | // InternalAlloyLanguage.g:9137:1: ( RULE_ID ) | ||
25668 | // InternalAlloyLanguage.g:9138:1: RULE_ID | ||
25669 | { | ||
25670 | if ( state.backtracking==0 ) { | ||
25671 | before(grammarAccess.getALSSignatureBodyAccess().getSupersetALSSignatureDeclarationIDTerminalRuleCall_4_1_2_1_0_1()); | ||
25672 | } | ||
25673 | match(input,RULE_ID,FOLLOW_2); if (state.failed) return ; | ||
25674 | if ( state.backtracking==0 ) { | ||
25675 | after(grammarAccess.getALSSignatureBodyAccess().getSupersetALSSignatureDeclarationIDTerminalRuleCall_4_1_2_1_0_1()); | ||
25676 | } | ||
25677 | |||
25678 | } | ||
25679 | |||
25680 | if ( state.backtracking==0 ) { | ||
25681 | after(grammarAccess.getALSSignatureBodyAccess().getSupersetALSSignatureDeclarationCrossReference_4_1_2_1_0()); | ||
25682 | } | ||
25683 | |||
25684 | } | ||
25685 | |||
25686 | |||
25687 | } | ||
25688 | |||
25689 | } | ||
25690 | catch (RecognitionException re) { | ||
25691 | reportError(re); | ||
25692 | recover(input,re); | ||
25693 | } | ||
25694 | finally { | ||
25695 | |||
25696 | restoreStackSize(stackSize); | ||
25697 | |||
25698 | } | ||
25699 | return ; | ||
25700 | } | ||
25701 | // $ANTLR end "rule__ALSSignatureBody__SupersetAssignment_4_1_2_1" | ||
25702 | |||
25703 | |||
25704 | // $ANTLR start "rule__ALSSignatureBody__FieldsAssignment_6_0" | ||
25705 | // InternalAlloyLanguage.g:9149:1: rule__ALSSignatureBody__FieldsAssignment_6_0 : ( ruleALSFieldDeclaration ) ; | ||
25706 | public final void rule__ALSSignatureBody__FieldsAssignment_6_0() throws RecognitionException { | ||
25707 | |||
25708 | int stackSize = keepStackSize(); | ||
25709 | |||
25710 | try { | ||
25711 | // InternalAlloyLanguage.g:9153:1: ( ( ruleALSFieldDeclaration ) ) | ||
25712 | // InternalAlloyLanguage.g:9154:1: ( ruleALSFieldDeclaration ) | ||
25713 | { | ||
25714 | // InternalAlloyLanguage.g:9154:1: ( ruleALSFieldDeclaration ) | ||
25715 | // InternalAlloyLanguage.g:9155:1: ruleALSFieldDeclaration | ||
25716 | { | ||
25717 | if ( state.backtracking==0 ) { | ||
25718 | before(grammarAccess.getALSSignatureBodyAccess().getFieldsALSFieldDeclarationParserRuleCall_6_0_0()); | ||
25719 | } | ||
25720 | pushFollow(FOLLOW_2); | ||
25721 | ruleALSFieldDeclaration(); | ||
25722 | |||
25723 | state._fsp--; | ||
25724 | if (state.failed) return ; | ||
25725 | if ( state.backtracking==0 ) { | ||
25726 | after(grammarAccess.getALSSignatureBodyAccess().getFieldsALSFieldDeclarationParserRuleCall_6_0_0()); | ||
25727 | } | ||
25728 | |||
25729 | } | ||
25730 | |||
25731 | |||
25732 | } | ||
25733 | |||
25734 | } | ||
25735 | catch (RecognitionException re) { | ||
25736 | reportError(re); | ||
25737 | recover(input,re); | ||
25738 | } | ||
25739 | finally { | ||
25740 | |||
25741 | restoreStackSize(stackSize); | ||
25742 | |||
25743 | } | ||
25744 | return ; | ||
25745 | } | ||
25746 | // $ANTLR end "rule__ALSSignatureBody__FieldsAssignment_6_0" | ||
25747 | |||
25748 | |||
25749 | // $ANTLR start "rule__ALSSignatureBody__FieldsAssignment_6_1_1" | ||
25750 | // InternalAlloyLanguage.g:9164:1: rule__ALSSignatureBody__FieldsAssignment_6_1_1 : ( ruleALSFieldDeclaration ) ; | ||
25751 | public final void rule__ALSSignatureBody__FieldsAssignment_6_1_1() throws RecognitionException { | ||
25752 | |||
25753 | int stackSize = keepStackSize(); | ||
25754 | |||
25755 | try { | ||
25756 | // InternalAlloyLanguage.g:9168:1: ( ( ruleALSFieldDeclaration ) ) | ||
25757 | // InternalAlloyLanguage.g:9169:1: ( ruleALSFieldDeclaration ) | ||
25758 | { | ||
25759 | // InternalAlloyLanguage.g:9169:1: ( ruleALSFieldDeclaration ) | ||
25760 | // InternalAlloyLanguage.g:9170:1: ruleALSFieldDeclaration | ||
25761 | { | ||
25762 | if ( state.backtracking==0 ) { | ||
25763 | before(grammarAccess.getALSSignatureBodyAccess().getFieldsALSFieldDeclarationParserRuleCall_6_1_1_0()); | ||
25764 | } | ||
25765 | pushFollow(FOLLOW_2); | ||
25766 | ruleALSFieldDeclaration(); | ||
25767 | |||
25768 | state._fsp--; | ||
25769 | if (state.failed) return ; | ||
25770 | if ( state.backtracking==0 ) { | ||
25771 | after(grammarAccess.getALSSignatureBodyAccess().getFieldsALSFieldDeclarationParserRuleCall_6_1_1_0()); | ||
25772 | } | ||
25773 | |||
25774 | } | ||
25775 | |||
25776 | |||
25777 | } | ||
25778 | |||
25779 | } | ||
25780 | catch (RecognitionException re) { | ||
25781 | reportError(re); | ||
25782 | recover(input,re); | ||
25783 | } | ||
25784 | finally { | ||
25785 | |||
25786 | restoreStackSize(stackSize); | ||
25787 | |||
25788 | } | ||
25789 | return ; | ||
25790 | } | ||
25791 | // $ANTLR end "rule__ALSSignatureBody__FieldsAssignment_6_1_1" | ||
25792 | |||
25793 | |||
25794 | // $ANTLR start "rule__ALSFieldDeclaration__NameAssignment_0" | ||
25795 | // InternalAlloyLanguage.g:9179:1: rule__ALSFieldDeclaration__NameAssignment_0 : ( ruleALSID ) ; | ||
25796 | public final void rule__ALSFieldDeclaration__NameAssignment_0() throws RecognitionException { | ||
25797 | |||
25798 | int stackSize = keepStackSize(); | ||
25799 | |||
25800 | try { | ||
25801 | // InternalAlloyLanguage.g:9183:1: ( ( ruleALSID ) ) | ||
25802 | // InternalAlloyLanguage.g:9184:1: ( ruleALSID ) | ||
25803 | { | ||
25804 | // InternalAlloyLanguage.g:9184:1: ( ruleALSID ) | ||
25805 | // InternalAlloyLanguage.g:9185:1: ruleALSID | ||
25806 | { | ||
25807 | if ( state.backtracking==0 ) { | ||
25808 | before(grammarAccess.getALSFieldDeclarationAccess().getNameALSIDParserRuleCall_0_0()); | ||
25809 | } | ||
25810 | pushFollow(FOLLOW_2); | ||
25811 | ruleALSID(); | ||
25812 | |||
25813 | state._fsp--; | ||
25814 | if (state.failed) return ; | ||
25815 | if ( state.backtracking==0 ) { | ||
25816 | after(grammarAccess.getALSFieldDeclarationAccess().getNameALSIDParserRuleCall_0_0()); | ||
25817 | } | ||
25818 | |||
25819 | } | ||
25820 | |||
25821 | |||
25822 | } | ||
25823 | |||
25824 | } | ||
25825 | catch (RecognitionException re) { | ||
25826 | reportError(re); | ||
25827 | recover(input,re); | ||
25828 | } | ||
25829 | finally { | ||
25830 | |||
25831 | restoreStackSize(stackSize); | ||
25832 | |||
25833 | } | ||
25834 | return ; | ||
25835 | } | ||
25836 | // $ANTLR end "rule__ALSFieldDeclaration__NameAssignment_0" | ||
25837 | |||
25838 | |||
25839 | // $ANTLR start "rule__ALSFieldDeclaration__MultiplicityAssignment_2" | ||
25840 | // InternalAlloyLanguage.g:9194:1: rule__ALSFieldDeclaration__MultiplicityAssignment_2 : ( ruleALSMultiplicity ) ; | ||
25841 | public final void rule__ALSFieldDeclaration__MultiplicityAssignment_2() throws RecognitionException { | ||
25842 | |||
25843 | int stackSize = keepStackSize(); | ||
25844 | |||
25845 | try { | ||
25846 | // InternalAlloyLanguage.g:9198:1: ( ( ruleALSMultiplicity ) ) | ||
25847 | // InternalAlloyLanguage.g:9199:1: ( ruleALSMultiplicity ) | ||
25848 | { | ||
25849 | // InternalAlloyLanguage.g:9199:1: ( ruleALSMultiplicity ) | ||
25850 | // InternalAlloyLanguage.g:9200:1: ruleALSMultiplicity | ||
25851 | { | ||
25852 | if ( state.backtracking==0 ) { | ||
25853 | before(grammarAccess.getALSFieldDeclarationAccess().getMultiplicityALSMultiplicityEnumRuleCall_2_0()); | ||
25854 | } | ||
25855 | pushFollow(FOLLOW_2); | ||
25856 | ruleALSMultiplicity(); | ||
25857 | |||
25858 | state._fsp--; | ||
25859 | if (state.failed) return ; | ||
25860 | if ( state.backtracking==0 ) { | ||
25861 | after(grammarAccess.getALSFieldDeclarationAccess().getMultiplicityALSMultiplicityEnumRuleCall_2_0()); | ||
25862 | } | ||
25863 | |||
25864 | } | ||
25865 | |||
25866 | |||
25867 | } | ||
25868 | |||
25869 | } | ||
25870 | catch (RecognitionException re) { | ||
25871 | reportError(re); | ||
25872 | recover(input,re); | ||
25873 | } | ||
25874 | finally { | ||
25875 | |||
25876 | restoreStackSize(stackSize); | ||
25877 | |||
25878 | } | ||
25879 | return ; | ||
25880 | } | ||
25881 | // $ANTLR end "rule__ALSFieldDeclaration__MultiplicityAssignment_2" | ||
25882 | |||
25883 | |||
25884 | // $ANTLR start "rule__ALSFieldDeclaration__TypeAssignment_3" | ||
25885 | // InternalAlloyLanguage.g:9209:1: rule__ALSFieldDeclaration__TypeAssignment_3 : ( ruleALSTerm ) ; | ||
25886 | public final void rule__ALSFieldDeclaration__TypeAssignment_3() throws RecognitionException { | ||
25887 | |||
25888 | int stackSize = keepStackSize(); | ||
25889 | |||
25890 | try { | ||
25891 | // InternalAlloyLanguage.g:9213:1: ( ( ruleALSTerm ) ) | ||
25892 | // InternalAlloyLanguage.g:9214:1: ( ruleALSTerm ) | ||
25893 | { | ||
25894 | // InternalAlloyLanguage.g:9214:1: ( ruleALSTerm ) | ||
25895 | // InternalAlloyLanguage.g:9215:1: ruleALSTerm | ||
25896 | { | ||
25897 | if ( state.backtracking==0 ) { | ||
25898 | before(grammarAccess.getALSFieldDeclarationAccess().getTypeALSTermParserRuleCall_3_0()); | ||
25899 | } | ||
25900 | pushFollow(FOLLOW_2); | ||
25901 | ruleALSTerm(); | ||
25902 | |||
25903 | state._fsp--; | ||
25904 | if (state.failed) return ; | ||
25905 | if ( state.backtracking==0 ) { | ||
25906 | after(grammarAccess.getALSFieldDeclarationAccess().getTypeALSTermParserRuleCall_3_0()); | ||
25907 | } | ||
25908 | |||
25909 | } | ||
25910 | |||
25911 | |||
25912 | } | ||
25913 | |||
25914 | } | ||
25915 | catch (RecognitionException re) { | ||
25916 | reportError(re); | ||
25917 | recover(input,re); | ||
25918 | } | ||
25919 | finally { | ||
25920 | |||
25921 | restoreStackSize(stackSize); | ||
25922 | |||
25923 | } | ||
25924 | return ; | ||
25925 | } | ||
25926 | // $ANTLR end "rule__ALSFieldDeclaration__TypeAssignment_3" | ||
25927 | |||
25928 | |||
25929 | // $ANTLR start "rule__ALSFunctionDefinition__NameAssignment_1" | ||
25930 | // InternalAlloyLanguage.g:9224:1: rule__ALSFunctionDefinition__NameAssignment_1 : ( ruleALSID ) ; | ||
25931 | public final void rule__ALSFunctionDefinition__NameAssignment_1() throws RecognitionException { | ||
25932 | |||
25933 | int stackSize = keepStackSize(); | ||
25934 | |||
25935 | try { | ||
25936 | // InternalAlloyLanguage.g:9228:1: ( ( ruleALSID ) ) | ||
25937 | // InternalAlloyLanguage.g:9229:1: ( ruleALSID ) | ||
25938 | { | ||
25939 | // InternalAlloyLanguage.g:9229:1: ( ruleALSID ) | ||
25940 | // InternalAlloyLanguage.g:9230:1: ruleALSID | ||
25941 | { | ||
25942 | if ( state.backtracking==0 ) { | ||
25943 | before(grammarAccess.getALSFunctionDefinitionAccess().getNameALSIDParserRuleCall_1_0()); | ||
25944 | } | ||
25945 | pushFollow(FOLLOW_2); | ||
25946 | ruleALSID(); | ||
25947 | |||
25948 | state._fsp--; | ||
25949 | if (state.failed) return ; | ||
25950 | if ( state.backtracking==0 ) { | ||
25951 | after(grammarAccess.getALSFunctionDefinitionAccess().getNameALSIDParserRuleCall_1_0()); | ||
25952 | } | ||
25953 | |||
25954 | } | ||
25955 | |||
25956 | |||
25957 | } | ||
25958 | |||
25959 | } | ||
25960 | catch (RecognitionException re) { | ||
25961 | reportError(re); | ||
25962 | recover(input,re); | ||
25963 | } | ||
25964 | finally { | ||
25965 | |||
25966 | restoreStackSize(stackSize); | ||
25967 | |||
25968 | } | ||
25969 | return ; | ||
25970 | } | ||
25971 | // $ANTLR end "rule__ALSFunctionDefinition__NameAssignment_1" | ||
25972 | |||
25973 | |||
25974 | // $ANTLR start "rule__ALSFunctionDefinition__VariablesAssignment_3" | ||
25975 | // InternalAlloyLanguage.g:9239:1: rule__ALSFunctionDefinition__VariablesAssignment_3 : ( ruleALSVariableDeclaration ) ; | ||
25976 | public final void rule__ALSFunctionDefinition__VariablesAssignment_3() throws RecognitionException { | ||
25977 | |||
25978 | int stackSize = keepStackSize(); | ||
25979 | |||
25980 | try { | ||
25981 | // InternalAlloyLanguage.g:9243:1: ( ( ruleALSVariableDeclaration ) ) | ||
25982 | // InternalAlloyLanguage.g:9244:1: ( ruleALSVariableDeclaration ) | ||
25983 | { | ||
25984 | // InternalAlloyLanguage.g:9244:1: ( ruleALSVariableDeclaration ) | ||
25985 | // InternalAlloyLanguage.g:9245:1: ruleALSVariableDeclaration | ||
25986 | { | ||
25987 | if ( state.backtracking==0 ) { | ||
25988 | before(grammarAccess.getALSFunctionDefinitionAccess().getVariablesALSVariableDeclarationParserRuleCall_3_0()); | ||
25989 | } | ||
25990 | pushFollow(FOLLOW_2); | ||
25991 | ruleALSVariableDeclaration(); | ||
25992 | |||
25993 | state._fsp--; | ||
25994 | if (state.failed) return ; | ||
25995 | if ( state.backtracking==0 ) { | ||
25996 | after(grammarAccess.getALSFunctionDefinitionAccess().getVariablesALSVariableDeclarationParserRuleCall_3_0()); | ||
25997 | } | ||
25998 | |||
25999 | } | ||
26000 | |||
26001 | |||
26002 | } | ||
26003 | |||
26004 | } | ||
26005 | catch (RecognitionException re) { | ||
26006 | reportError(re); | ||
26007 | recover(input,re); | ||
26008 | } | ||
26009 | finally { | ||
26010 | |||
26011 | restoreStackSize(stackSize); | ||
26012 | |||
26013 | } | ||
26014 | return ; | ||
26015 | } | ||
26016 | // $ANTLR end "rule__ALSFunctionDefinition__VariablesAssignment_3" | ||
26017 | |||
26018 | |||
26019 | // $ANTLR start "rule__ALSFunctionDefinition__VariablesAssignment_4_1" | ||
26020 | // InternalAlloyLanguage.g:9254:1: rule__ALSFunctionDefinition__VariablesAssignment_4_1 : ( ruleALSVariableDeclaration ) ; | ||
26021 | public final void rule__ALSFunctionDefinition__VariablesAssignment_4_1() throws RecognitionException { | ||
26022 | |||
26023 | int stackSize = keepStackSize(); | ||
26024 | |||
26025 | try { | ||
26026 | // InternalAlloyLanguage.g:9258:1: ( ( ruleALSVariableDeclaration ) ) | ||
26027 | // InternalAlloyLanguage.g:9259:1: ( ruleALSVariableDeclaration ) | ||
26028 | { | ||
26029 | // InternalAlloyLanguage.g:9259:1: ( ruleALSVariableDeclaration ) | ||
26030 | // InternalAlloyLanguage.g:9260:1: ruleALSVariableDeclaration | ||
26031 | { | ||
26032 | if ( state.backtracking==0 ) { | ||
26033 | before(grammarAccess.getALSFunctionDefinitionAccess().getVariablesALSVariableDeclarationParserRuleCall_4_1_0()); | ||
26034 | } | ||
26035 | pushFollow(FOLLOW_2); | ||
26036 | ruleALSVariableDeclaration(); | ||
26037 | |||
26038 | state._fsp--; | ||
26039 | if (state.failed) return ; | ||
26040 | if ( state.backtracking==0 ) { | ||
26041 | after(grammarAccess.getALSFunctionDefinitionAccess().getVariablesALSVariableDeclarationParserRuleCall_4_1_0()); | ||
26042 | } | ||
26043 | |||
26044 | } | ||
26045 | |||
26046 | |||
26047 | } | ||
26048 | |||
26049 | } | ||
26050 | catch (RecognitionException re) { | ||
26051 | reportError(re); | ||
26052 | recover(input,re); | ||
26053 | } | ||
26054 | finally { | ||
26055 | |||
26056 | restoreStackSize(stackSize); | ||
26057 | |||
26058 | } | ||
26059 | return ; | ||
26060 | } | ||
26061 | // $ANTLR end "rule__ALSFunctionDefinition__VariablesAssignment_4_1" | ||
26062 | |||
26063 | |||
26064 | // $ANTLR start "rule__ALSFunctionDefinition__TypeAssignment_7" | ||
26065 | // InternalAlloyLanguage.g:9269:1: rule__ALSFunctionDefinition__TypeAssignment_7 : ( ruleALSTerm ) ; | ||
26066 | public final void rule__ALSFunctionDefinition__TypeAssignment_7() throws RecognitionException { | ||
26067 | |||
26068 | int stackSize = keepStackSize(); | ||
26069 | |||
26070 | try { | ||
26071 | // InternalAlloyLanguage.g:9273:1: ( ( ruleALSTerm ) ) | ||
26072 | // InternalAlloyLanguage.g:9274:1: ( ruleALSTerm ) | ||
26073 | { | ||
26074 | // InternalAlloyLanguage.g:9274:1: ( ruleALSTerm ) | ||
26075 | // InternalAlloyLanguage.g:9275:1: ruleALSTerm | ||
26076 | { | ||
26077 | if ( state.backtracking==0 ) { | ||
26078 | before(grammarAccess.getALSFunctionDefinitionAccess().getTypeALSTermParserRuleCall_7_0()); | ||
26079 | } | ||
26080 | pushFollow(FOLLOW_2); | ||
26081 | ruleALSTerm(); | ||
26082 | |||
26083 | state._fsp--; | ||
26084 | if (state.failed) return ; | ||
26085 | if ( state.backtracking==0 ) { | ||
26086 | after(grammarAccess.getALSFunctionDefinitionAccess().getTypeALSTermParserRuleCall_7_0()); | ||
26087 | } | ||
26088 | |||
26089 | } | ||
26090 | |||
26091 | |||
26092 | } | ||
26093 | |||
26094 | } | ||
26095 | catch (RecognitionException re) { | ||
26096 | reportError(re); | ||
26097 | recover(input,re); | ||
26098 | } | ||
26099 | finally { | ||
26100 | |||
26101 | restoreStackSize(stackSize); | ||
26102 | |||
26103 | } | ||
26104 | return ; | ||
26105 | } | ||
26106 | // $ANTLR end "rule__ALSFunctionDefinition__TypeAssignment_7" | ||
26107 | |||
26108 | |||
26109 | // $ANTLR start "rule__ALSFunctionDefinition__ValueAssignment_9" | ||
26110 | // InternalAlloyLanguage.g:9284:1: rule__ALSFunctionDefinition__ValueAssignment_9 : ( ruleALSTerm ) ; | ||
26111 | public final void rule__ALSFunctionDefinition__ValueAssignment_9() throws RecognitionException { | ||
26112 | |||
26113 | int stackSize = keepStackSize(); | ||
26114 | |||
26115 | try { | ||
26116 | // InternalAlloyLanguage.g:9288:1: ( ( ruleALSTerm ) ) | ||
26117 | // InternalAlloyLanguage.g:9289:1: ( ruleALSTerm ) | ||
26118 | { | ||
26119 | // InternalAlloyLanguage.g:9289:1: ( ruleALSTerm ) | ||
26120 | // InternalAlloyLanguage.g:9290:1: ruleALSTerm | ||
26121 | { | ||
26122 | if ( state.backtracking==0 ) { | ||
26123 | before(grammarAccess.getALSFunctionDefinitionAccess().getValueALSTermParserRuleCall_9_0()); | ||
26124 | } | ||
26125 | pushFollow(FOLLOW_2); | ||
26126 | ruleALSTerm(); | ||
26127 | |||
26128 | state._fsp--; | ||
26129 | if (state.failed) return ; | ||
26130 | if ( state.backtracking==0 ) { | ||
26131 | after(grammarAccess.getALSFunctionDefinitionAccess().getValueALSTermParserRuleCall_9_0()); | ||
26132 | } | ||
26133 | |||
26134 | } | ||
26135 | |||
26136 | |||
26137 | } | ||
26138 | |||
26139 | } | ||
26140 | catch (RecognitionException re) { | ||
26141 | reportError(re); | ||
26142 | recover(input,re); | ||
26143 | } | ||
26144 | finally { | ||
26145 | |||
26146 | restoreStackSize(stackSize); | ||
26147 | |||
26148 | } | ||
26149 | return ; | ||
26150 | } | ||
26151 | // $ANTLR end "rule__ALSFunctionDefinition__ValueAssignment_9" | ||
26152 | |||
26153 | |||
26154 | // $ANTLR start "rule__ALSRelationDefinition__NameAssignment_1" | ||
26155 | // InternalAlloyLanguage.g:9299:1: rule__ALSRelationDefinition__NameAssignment_1 : ( ruleALSID ) ; | ||
26156 | public final void rule__ALSRelationDefinition__NameAssignment_1() throws RecognitionException { | ||
26157 | |||
26158 | int stackSize = keepStackSize(); | ||
26159 | |||
26160 | try { | ||
26161 | // InternalAlloyLanguage.g:9303:1: ( ( ruleALSID ) ) | ||
26162 | // InternalAlloyLanguage.g:9304:1: ( ruleALSID ) | ||
26163 | { | ||
26164 | // InternalAlloyLanguage.g:9304:1: ( ruleALSID ) | ||
26165 | // InternalAlloyLanguage.g:9305:1: ruleALSID | ||
26166 | { | ||
26167 | if ( state.backtracking==0 ) { | ||
26168 | before(grammarAccess.getALSRelationDefinitionAccess().getNameALSIDParserRuleCall_1_0()); | ||
26169 | } | ||
26170 | pushFollow(FOLLOW_2); | ||
26171 | ruleALSID(); | ||
26172 | |||
26173 | state._fsp--; | ||
26174 | if (state.failed) return ; | ||
26175 | if ( state.backtracking==0 ) { | ||
26176 | after(grammarAccess.getALSRelationDefinitionAccess().getNameALSIDParserRuleCall_1_0()); | ||
26177 | } | ||
26178 | |||
26179 | } | ||
26180 | |||
26181 | |||
26182 | } | ||
26183 | |||
26184 | } | ||
26185 | catch (RecognitionException re) { | ||
26186 | reportError(re); | ||
26187 | recover(input,re); | ||
26188 | } | ||
26189 | finally { | ||
26190 | |||
26191 | restoreStackSize(stackSize); | ||
26192 | |||
26193 | } | ||
26194 | return ; | ||
26195 | } | ||
26196 | // $ANTLR end "rule__ALSRelationDefinition__NameAssignment_1" | ||
26197 | |||
26198 | |||
26199 | // $ANTLR start "rule__ALSRelationDefinition__VariablesAssignment_3" | ||
26200 | // InternalAlloyLanguage.g:9314:1: rule__ALSRelationDefinition__VariablesAssignment_3 : ( ruleALSVariableDeclaration ) ; | ||
26201 | public final void rule__ALSRelationDefinition__VariablesAssignment_3() throws RecognitionException { | ||
26202 | |||
26203 | int stackSize = keepStackSize(); | ||
26204 | |||
26205 | try { | ||
26206 | // InternalAlloyLanguage.g:9318:1: ( ( ruleALSVariableDeclaration ) ) | ||
26207 | // InternalAlloyLanguage.g:9319:1: ( ruleALSVariableDeclaration ) | ||
26208 | { | ||
26209 | // InternalAlloyLanguage.g:9319:1: ( ruleALSVariableDeclaration ) | ||
26210 | // InternalAlloyLanguage.g:9320:1: ruleALSVariableDeclaration | ||
26211 | { | ||
26212 | if ( state.backtracking==0 ) { | ||
26213 | before(grammarAccess.getALSRelationDefinitionAccess().getVariablesALSVariableDeclarationParserRuleCall_3_0()); | ||
26214 | } | ||
26215 | pushFollow(FOLLOW_2); | ||
26216 | ruleALSVariableDeclaration(); | ||
26217 | |||
26218 | state._fsp--; | ||
26219 | if (state.failed) return ; | ||
26220 | if ( state.backtracking==0 ) { | ||
26221 | after(grammarAccess.getALSRelationDefinitionAccess().getVariablesALSVariableDeclarationParserRuleCall_3_0()); | ||
26222 | } | ||
26223 | |||
26224 | } | ||
26225 | |||
26226 | |||
26227 | } | ||
26228 | |||
26229 | } | ||
26230 | catch (RecognitionException re) { | ||
26231 | reportError(re); | ||
26232 | recover(input,re); | ||
26233 | } | ||
26234 | finally { | ||
26235 | |||
26236 | restoreStackSize(stackSize); | ||
26237 | |||
26238 | } | ||
26239 | return ; | ||
26240 | } | ||
26241 | // $ANTLR end "rule__ALSRelationDefinition__VariablesAssignment_3" | ||
26242 | |||
26243 | |||
26244 | // $ANTLR start "rule__ALSRelationDefinition__VariablesAssignment_4_1" | ||
26245 | // InternalAlloyLanguage.g:9329:1: rule__ALSRelationDefinition__VariablesAssignment_4_1 : ( ruleALSVariableDeclaration ) ; | ||
26246 | public final void rule__ALSRelationDefinition__VariablesAssignment_4_1() throws RecognitionException { | ||
26247 | |||
26248 | int stackSize = keepStackSize(); | ||
26249 | |||
26250 | try { | ||
26251 | // InternalAlloyLanguage.g:9333:1: ( ( ruleALSVariableDeclaration ) ) | ||
26252 | // InternalAlloyLanguage.g:9334:1: ( ruleALSVariableDeclaration ) | ||
26253 | { | ||
26254 | // InternalAlloyLanguage.g:9334:1: ( ruleALSVariableDeclaration ) | ||
26255 | // InternalAlloyLanguage.g:9335:1: ruleALSVariableDeclaration | ||
26256 | { | ||
26257 | if ( state.backtracking==0 ) { | ||
26258 | before(grammarAccess.getALSRelationDefinitionAccess().getVariablesALSVariableDeclarationParserRuleCall_4_1_0()); | ||
26259 | } | ||
26260 | pushFollow(FOLLOW_2); | ||
26261 | ruleALSVariableDeclaration(); | ||
26262 | |||
26263 | state._fsp--; | ||
26264 | if (state.failed) return ; | ||
26265 | if ( state.backtracking==0 ) { | ||
26266 | after(grammarAccess.getALSRelationDefinitionAccess().getVariablesALSVariableDeclarationParserRuleCall_4_1_0()); | ||
26267 | } | ||
26268 | |||
26269 | } | ||
26270 | |||
26271 | |||
26272 | } | ||
26273 | |||
26274 | } | ||
26275 | catch (RecognitionException re) { | ||
26276 | reportError(re); | ||
26277 | recover(input,re); | ||
26278 | } | ||
26279 | finally { | ||
26280 | |||
26281 | restoreStackSize(stackSize); | ||
26282 | |||
26283 | } | ||
26284 | return ; | ||
26285 | } | ||
26286 | // $ANTLR end "rule__ALSRelationDefinition__VariablesAssignment_4_1" | ||
26287 | |||
26288 | |||
26289 | // $ANTLR start "rule__ALSRelationDefinition__ValueAssignment_7" | ||
26290 | // InternalAlloyLanguage.g:9344:1: rule__ALSRelationDefinition__ValueAssignment_7 : ( ruleALSTerm ) ; | ||
26291 | public final void rule__ALSRelationDefinition__ValueAssignment_7() throws RecognitionException { | ||
26292 | |||
26293 | int stackSize = keepStackSize(); | ||
26294 | |||
26295 | try { | ||
26296 | // InternalAlloyLanguage.g:9348:1: ( ( ruleALSTerm ) ) | ||
26297 | // InternalAlloyLanguage.g:9349:1: ( ruleALSTerm ) | ||
26298 | { | ||
26299 | // InternalAlloyLanguage.g:9349:1: ( ruleALSTerm ) | ||
26300 | // InternalAlloyLanguage.g:9350:1: ruleALSTerm | ||
26301 | { | ||
26302 | if ( state.backtracking==0 ) { | ||
26303 | before(grammarAccess.getALSRelationDefinitionAccess().getValueALSTermParserRuleCall_7_0()); | ||
26304 | } | ||
26305 | pushFollow(FOLLOW_2); | ||
26306 | ruleALSTerm(); | ||
26307 | |||
26308 | state._fsp--; | ||
26309 | if (state.failed) return ; | ||
26310 | if ( state.backtracking==0 ) { | ||
26311 | after(grammarAccess.getALSRelationDefinitionAccess().getValueALSTermParserRuleCall_7_0()); | ||
26312 | } | ||
26313 | |||
26314 | } | ||
26315 | |||
26316 | |||
26317 | } | ||
26318 | |||
26319 | } | ||
26320 | catch (RecognitionException re) { | ||
26321 | reportError(re); | ||
26322 | recover(input,re); | ||
26323 | } | ||
26324 | finally { | ||
26325 | |||
26326 | restoreStackSize(stackSize); | ||
26327 | |||
26328 | } | ||
26329 | return ; | ||
26330 | } | ||
26331 | // $ANTLR end "rule__ALSRelationDefinition__ValueAssignment_7" | ||
26332 | |||
26333 | |||
26334 | // $ANTLR start "rule__ALSFactDeclaration__NameAssignment_2" | ||
26335 | // InternalAlloyLanguage.g:9359:1: rule__ALSFactDeclaration__NameAssignment_2 : ( ruleALSID ) ; | ||
26336 | public final void rule__ALSFactDeclaration__NameAssignment_2() throws RecognitionException { | ||
26337 | |||
26338 | int stackSize = keepStackSize(); | ||
26339 | |||
26340 | try { | ||
26341 | // InternalAlloyLanguage.g:9363:1: ( ( ruleALSID ) ) | ||
26342 | // InternalAlloyLanguage.g:9364:1: ( ruleALSID ) | ||
26343 | { | ||
26344 | // InternalAlloyLanguage.g:9364:1: ( ruleALSID ) | ||
26345 | // InternalAlloyLanguage.g:9365:1: ruleALSID | ||
26346 | { | ||
26347 | if ( state.backtracking==0 ) { | ||
26348 | before(grammarAccess.getALSFactDeclarationAccess().getNameALSIDParserRuleCall_2_0()); | ||
26349 | } | ||
26350 | pushFollow(FOLLOW_2); | ||
26351 | ruleALSID(); | ||
26352 | |||
26353 | state._fsp--; | ||
26354 | if (state.failed) return ; | ||
26355 | if ( state.backtracking==0 ) { | ||
26356 | after(grammarAccess.getALSFactDeclarationAccess().getNameALSIDParserRuleCall_2_0()); | ||
26357 | } | ||
26358 | |||
26359 | } | ||
26360 | |||
26361 | |||
26362 | } | ||
26363 | |||
26364 | } | ||
26365 | catch (RecognitionException re) { | ||
26366 | reportError(re); | ||
26367 | recover(input,re); | ||
26368 | } | ||
26369 | finally { | ||
26370 | |||
26371 | restoreStackSize(stackSize); | ||
26372 | |||
26373 | } | ||
26374 | return ; | ||
26375 | } | ||
26376 | // $ANTLR end "rule__ALSFactDeclaration__NameAssignment_2" | ||
26377 | |||
26378 | |||
26379 | // $ANTLR start "rule__ALSFactDeclaration__TermAssignment_4" | ||
26380 | // InternalAlloyLanguage.g:9374:1: rule__ALSFactDeclaration__TermAssignment_4 : ( ruleALSTerm ) ; | ||
26381 | public final void rule__ALSFactDeclaration__TermAssignment_4() throws RecognitionException { | ||
26382 | |||
26383 | int stackSize = keepStackSize(); | ||
26384 | |||
26385 | try { | ||
26386 | // InternalAlloyLanguage.g:9378:1: ( ( ruleALSTerm ) ) | ||
26387 | // InternalAlloyLanguage.g:9379:1: ( ruleALSTerm ) | ||
26388 | { | ||
26389 | // InternalAlloyLanguage.g:9379:1: ( ruleALSTerm ) | ||
26390 | // InternalAlloyLanguage.g:9380:1: ruleALSTerm | ||
26391 | { | ||
26392 | if ( state.backtracking==0 ) { | ||
26393 | before(grammarAccess.getALSFactDeclarationAccess().getTermALSTermParserRuleCall_4_0()); | ||
26394 | } | ||
26395 | pushFollow(FOLLOW_2); | ||
26396 | ruleALSTerm(); | ||
26397 | |||
26398 | state._fsp--; | ||
26399 | if (state.failed) return ; | ||
26400 | if ( state.backtracking==0 ) { | ||
26401 | after(grammarAccess.getALSFactDeclarationAccess().getTermALSTermParserRuleCall_4_0()); | ||
26402 | } | ||
26403 | |||
26404 | } | ||
26405 | |||
26406 | |||
26407 | } | ||
26408 | |||
26409 | } | ||
26410 | catch (RecognitionException re) { | ||
26411 | reportError(re); | ||
26412 | recover(input,re); | ||
26413 | } | ||
26414 | finally { | ||
26415 | |||
26416 | restoreStackSize(stackSize); | ||
26417 | |||
26418 | } | ||
26419 | return ; | ||
26420 | } | ||
26421 | // $ANTLR end "rule__ALSFactDeclaration__TermAssignment_4" | ||
26422 | |||
26423 | |||
26424 | // $ANTLR start "rule__ALSQuantified__TypeAssignment_0_1" | ||
26425 | // InternalAlloyLanguage.g:9389:1: rule__ALSQuantified__TypeAssignment_0_1 : ( ruleALSMultiplicity ) ; | ||
26426 | public final void rule__ALSQuantified__TypeAssignment_0_1() throws RecognitionException { | ||
26427 | |||
26428 | int stackSize = keepStackSize(); | ||
26429 | |||
26430 | try { | ||
26431 | // InternalAlloyLanguage.g:9393:1: ( ( ruleALSMultiplicity ) ) | ||
26432 | // InternalAlloyLanguage.g:9394:1: ( ruleALSMultiplicity ) | ||
26433 | { | ||
26434 | // InternalAlloyLanguage.g:9394:1: ( ruleALSMultiplicity ) | ||
26435 | // InternalAlloyLanguage.g:9395:1: ruleALSMultiplicity | ||
26436 | { | ||
26437 | if ( state.backtracking==0 ) { | ||
26438 | before(grammarAccess.getALSQuantifiedAccess().getTypeALSMultiplicityEnumRuleCall_0_1_0()); | ||
26439 | } | ||
26440 | pushFollow(FOLLOW_2); | ||
26441 | ruleALSMultiplicity(); | ||
26442 | |||
26443 | state._fsp--; | ||
26444 | if (state.failed) return ; | ||
26445 | if ( state.backtracking==0 ) { | ||
26446 | after(grammarAccess.getALSQuantifiedAccess().getTypeALSMultiplicityEnumRuleCall_0_1_0()); | ||
26447 | } | ||
26448 | |||
26449 | } | ||
26450 | |||
26451 | |||
26452 | } | ||
26453 | |||
26454 | } | ||
26455 | catch (RecognitionException re) { | ||
26456 | reportError(re); | ||
26457 | recover(input,re); | ||
26458 | } | ||
26459 | finally { | ||
26460 | |||
26461 | restoreStackSize(stackSize); | ||
26462 | |||
26463 | } | ||
26464 | return ; | ||
26465 | } | ||
26466 | // $ANTLR end "rule__ALSQuantified__TypeAssignment_0_1" | ||
26467 | |||
26468 | |||
26469 | // $ANTLR start "rule__ALSQuantified__DisjAssignment_0_2" | ||
26470 | // InternalAlloyLanguage.g:9404:1: rule__ALSQuantified__DisjAssignment_0_2 : ( ( 'disj' ) ) ; | ||
26471 | public final void rule__ALSQuantified__DisjAssignment_0_2() throws RecognitionException { | ||
26472 | |||
26473 | int stackSize = keepStackSize(); | ||
26474 | |||
26475 | try { | ||
26476 | // InternalAlloyLanguage.g:9408:1: ( ( ( 'disj' ) ) ) | ||
26477 | // InternalAlloyLanguage.g:9409:1: ( ( 'disj' ) ) | ||
26478 | { | ||
26479 | // InternalAlloyLanguage.g:9409:1: ( ( 'disj' ) ) | ||
26480 | // InternalAlloyLanguage.g:9410:1: ( 'disj' ) | ||
26481 | { | ||
26482 | if ( state.backtracking==0 ) { | ||
26483 | before(grammarAccess.getALSQuantifiedAccess().getDisjDisjKeyword_0_2_0()); | ||
26484 | } | ||
26485 | // InternalAlloyLanguage.g:9411:1: ( 'disj' ) | ||
26486 | // InternalAlloyLanguage.g:9412:1: 'disj' | ||
26487 | { | ||
26488 | if ( state.backtracking==0 ) { | ||
26489 | before(grammarAccess.getALSQuantifiedAccess().getDisjDisjKeyword_0_2_0()); | ||
26490 | } | ||
26491 | match(input,74,FOLLOW_2); if (state.failed) return ; | ||
26492 | if ( state.backtracking==0 ) { | ||
26493 | after(grammarAccess.getALSQuantifiedAccess().getDisjDisjKeyword_0_2_0()); | ||
26494 | } | ||
26495 | |||
26496 | } | ||
26497 | |||
26498 | if ( state.backtracking==0 ) { | ||
26499 | after(grammarAccess.getALSQuantifiedAccess().getDisjDisjKeyword_0_2_0()); | ||
26500 | } | ||
26501 | |||
26502 | } | ||
26503 | |||
26504 | |||
26505 | } | ||
26506 | |||
26507 | } | ||
26508 | catch (RecognitionException re) { | ||
26509 | reportError(re); | ||
26510 | recover(input,re); | ||
26511 | } | ||
26512 | finally { | ||
26513 | |||
26514 | restoreStackSize(stackSize); | ||
26515 | |||
26516 | } | ||
26517 | return ; | ||
26518 | } | ||
26519 | // $ANTLR end "rule__ALSQuantified__DisjAssignment_0_2" | ||
26520 | |||
26521 | |||
26522 | // $ANTLR start "rule__ALSQuantified__VariablesAssignment_0_3" | ||
26523 | // InternalAlloyLanguage.g:9427:1: rule__ALSQuantified__VariablesAssignment_0_3 : ( ruleALSVariableDeclaration ) ; | ||
26524 | public final void rule__ALSQuantified__VariablesAssignment_0_3() throws RecognitionException { | ||
26525 | |||
26526 | int stackSize = keepStackSize(); | ||
26527 | |||
26528 | try { | ||
26529 | // InternalAlloyLanguage.g:9431:1: ( ( ruleALSVariableDeclaration ) ) | ||
26530 | // InternalAlloyLanguage.g:9432:1: ( ruleALSVariableDeclaration ) | ||
26531 | { | ||
26532 | // InternalAlloyLanguage.g:9432:1: ( ruleALSVariableDeclaration ) | ||
26533 | // InternalAlloyLanguage.g:9433:1: ruleALSVariableDeclaration | ||
26534 | { | ||
26535 | if ( state.backtracking==0 ) { | ||
26536 | before(grammarAccess.getALSQuantifiedAccess().getVariablesALSVariableDeclarationParserRuleCall_0_3_0()); | ||
26537 | } | ||
26538 | pushFollow(FOLLOW_2); | ||
26539 | ruleALSVariableDeclaration(); | ||
26540 | |||
26541 | state._fsp--; | ||
26542 | if (state.failed) return ; | ||
26543 | if ( state.backtracking==0 ) { | ||
26544 | after(grammarAccess.getALSQuantifiedAccess().getVariablesALSVariableDeclarationParserRuleCall_0_3_0()); | ||
26545 | } | ||
26546 | |||
26547 | } | ||
26548 | |||
26549 | |||
26550 | } | ||
26551 | |||
26552 | } | ||
26553 | catch (RecognitionException re) { | ||
26554 | reportError(re); | ||
26555 | recover(input,re); | ||
26556 | } | ||
26557 | finally { | ||
26558 | |||
26559 | restoreStackSize(stackSize); | ||
26560 | |||
26561 | } | ||
26562 | return ; | ||
26563 | } | ||
26564 | // $ANTLR end "rule__ALSQuantified__VariablesAssignment_0_3" | ||
26565 | |||
26566 | |||
26567 | // $ANTLR start "rule__ALSQuantified__VariablesAssignment_0_4_1" | ||
26568 | // InternalAlloyLanguage.g:9442:1: rule__ALSQuantified__VariablesAssignment_0_4_1 : ( ruleALSVariableDeclaration ) ; | ||
26569 | public final void rule__ALSQuantified__VariablesAssignment_0_4_1() throws RecognitionException { | ||
26570 | |||
26571 | int stackSize = keepStackSize(); | ||
26572 | |||
26573 | try { | ||
26574 | // InternalAlloyLanguage.g:9446:1: ( ( ruleALSVariableDeclaration ) ) | ||
26575 | // InternalAlloyLanguage.g:9447:1: ( ruleALSVariableDeclaration ) | ||
26576 | { | ||
26577 | // InternalAlloyLanguage.g:9447:1: ( ruleALSVariableDeclaration ) | ||
26578 | // InternalAlloyLanguage.g:9448:1: ruleALSVariableDeclaration | ||
26579 | { | ||
26580 | if ( state.backtracking==0 ) { | ||
26581 | before(grammarAccess.getALSQuantifiedAccess().getVariablesALSVariableDeclarationParserRuleCall_0_4_1_0()); | ||
26582 | } | ||
26583 | pushFollow(FOLLOW_2); | ||
26584 | ruleALSVariableDeclaration(); | ||
26585 | |||
26586 | state._fsp--; | ||
26587 | if (state.failed) return ; | ||
26588 | if ( state.backtracking==0 ) { | ||
26589 | after(grammarAccess.getALSQuantifiedAccess().getVariablesALSVariableDeclarationParserRuleCall_0_4_1_0()); | ||
26590 | } | ||
26591 | |||
26592 | } | ||
26593 | |||
26594 | |||
26595 | } | ||
26596 | |||
26597 | } | ||
26598 | catch (RecognitionException re) { | ||
26599 | reportError(re); | ||
26600 | recover(input,re); | ||
26601 | } | ||
26602 | finally { | ||
26603 | |||
26604 | restoreStackSize(stackSize); | ||
26605 | |||
26606 | } | ||
26607 | return ; | ||
26608 | } | ||
26609 | // $ANTLR end "rule__ALSQuantified__VariablesAssignment_0_4_1" | ||
26610 | |||
26611 | |||
26612 | // $ANTLR start "rule__ALSQuantified__ExpressionAssignment_0_6" | ||
26613 | // InternalAlloyLanguage.g:9457:1: rule__ALSQuantified__ExpressionAssignment_0_6 : ( ruleALSTerm ) ; | ||
26614 | public final void rule__ALSQuantified__ExpressionAssignment_0_6() throws RecognitionException { | ||
26615 | |||
26616 | int stackSize = keepStackSize(); | ||
26617 | |||
26618 | try { | ||
26619 | // InternalAlloyLanguage.g:9461:1: ( ( ruleALSTerm ) ) | ||
26620 | // InternalAlloyLanguage.g:9462:1: ( ruleALSTerm ) | ||
26621 | { | ||
26622 | // InternalAlloyLanguage.g:9462:1: ( ruleALSTerm ) | ||
26623 | // InternalAlloyLanguage.g:9463:1: ruleALSTerm | ||
26624 | { | ||
26625 | if ( state.backtracking==0 ) { | ||
26626 | before(grammarAccess.getALSQuantifiedAccess().getExpressionALSTermParserRuleCall_0_6_0()); | ||
26627 | } | ||
26628 | pushFollow(FOLLOW_2); | ||
26629 | ruleALSTerm(); | ||
26630 | |||
26631 | state._fsp--; | ||
26632 | if (state.failed) return ; | ||
26633 | if ( state.backtracking==0 ) { | ||
26634 | after(grammarAccess.getALSQuantifiedAccess().getExpressionALSTermParserRuleCall_0_6_0()); | ||
26635 | } | ||
26636 | |||
26637 | } | ||
26638 | |||
26639 | |||
26640 | } | ||
26641 | |||
26642 | } | ||
26643 | catch (RecognitionException re) { | ||
26644 | reportError(re); | ||
26645 | recover(input,re); | ||
26646 | } | ||
26647 | finally { | ||
26648 | |||
26649 | restoreStackSize(stackSize); | ||
26650 | |||
26651 | } | ||
26652 | return ; | ||
26653 | } | ||
26654 | // $ANTLR end "rule__ALSQuantified__ExpressionAssignment_0_6" | ||
26655 | |||
26656 | |||
26657 | // $ANTLR start "rule__ALSOr__RightOperandAssignment_1_2" | ||
26658 | // InternalAlloyLanguage.g:9472:1: rule__ALSOr__RightOperandAssignment_1_2 : ( ruleALSIff ) ; | ||
26659 | public final void rule__ALSOr__RightOperandAssignment_1_2() throws RecognitionException { | ||
26660 | |||
26661 | int stackSize = keepStackSize(); | ||
26662 | |||
26663 | try { | ||
26664 | // InternalAlloyLanguage.g:9476:1: ( ( ruleALSIff ) ) | ||
26665 | // InternalAlloyLanguage.g:9477:1: ( ruleALSIff ) | ||
26666 | { | ||
26667 | // InternalAlloyLanguage.g:9477:1: ( ruleALSIff ) | ||
26668 | // InternalAlloyLanguage.g:9478:1: ruleALSIff | ||
26669 | { | ||
26670 | if ( state.backtracking==0 ) { | ||
26671 | before(grammarAccess.getALSOrAccess().getRightOperandALSIffParserRuleCall_1_2_0()); | ||
26672 | } | ||
26673 | pushFollow(FOLLOW_2); | ||
26674 | ruleALSIff(); | ||
26675 | |||
26676 | state._fsp--; | ||
26677 | if (state.failed) return ; | ||
26678 | if ( state.backtracking==0 ) { | ||
26679 | after(grammarAccess.getALSOrAccess().getRightOperandALSIffParserRuleCall_1_2_0()); | ||
26680 | } | ||
26681 | |||
26682 | } | ||
26683 | |||
26684 | |||
26685 | } | ||
26686 | |||
26687 | } | ||
26688 | catch (RecognitionException re) { | ||
26689 | reportError(re); | ||
26690 | recover(input,re); | ||
26691 | } | ||
26692 | finally { | ||
26693 | |||
26694 | restoreStackSize(stackSize); | ||
26695 | |||
26696 | } | ||
26697 | return ; | ||
26698 | } | ||
26699 | // $ANTLR end "rule__ALSOr__RightOperandAssignment_1_2" | ||
26700 | |||
26701 | |||
26702 | // $ANTLR start "rule__ALSIff__RightOperandAssignment_1_2" | ||
26703 | // InternalAlloyLanguage.g:9487:1: rule__ALSIff__RightOperandAssignment_1_2 : ( ruleALSImpl ) ; | ||
26704 | public final void rule__ALSIff__RightOperandAssignment_1_2() throws RecognitionException { | ||
26705 | |||
26706 | int stackSize = keepStackSize(); | ||
26707 | |||
26708 | try { | ||
26709 | // InternalAlloyLanguage.g:9491:1: ( ( ruleALSImpl ) ) | ||
26710 | // InternalAlloyLanguage.g:9492:1: ( ruleALSImpl ) | ||
26711 | { | ||
26712 | // InternalAlloyLanguage.g:9492:1: ( ruleALSImpl ) | ||
26713 | // InternalAlloyLanguage.g:9493:1: ruleALSImpl | ||
26714 | { | ||
26715 | if ( state.backtracking==0 ) { | ||
26716 | before(grammarAccess.getALSIffAccess().getRightOperandALSImplParserRuleCall_1_2_0()); | ||
26717 | } | ||
26718 | pushFollow(FOLLOW_2); | ||
26719 | ruleALSImpl(); | ||
26720 | |||
26721 | state._fsp--; | ||
26722 | if (state.failed) return ; | ||
26723 | if ( state.backtracking==0 ) { | ||
26724 | after(grammarAccess.getALSIffAccess().getRightOperandALSImplParserRuleCall_1_2_0()); | ||
26725 | } | ||
26726 | |||
26727 | } | ||
26728 | |||
26729 | |||
26730 | } | ||
26731 | |||
26732 | } | ||
26733 | catch (RecognitionException re) { | ||
26734 | reportError(re); | ||
26735 | recover(input,re); | ||
26736 | } | ||
26737 | finally { | ||
26738 | |||
26739 | restoreStackSize(stackSize); | ||
26740 | |||
26741 | } | ||
26742 | return ; | ||
26743 | } | ||
26744 | // $ANTLR end "rule__ALSIff__RightOperandAssignment_1_2" | ||
26745 | |||
26746 | |||
26747 | // $ANTLR start "rule__ALSImpl__RightOperandAssignment_1_2" | ||
26748 | // InternalAlloyLanguage.g:9502:1: rule__ALSImpl__RightOperandAssignment_1_2 : ( ruleALSAnd ) ; | ||
26749 | public final void rule__ALSImpl__RightOperandAssignment_1_2() throws RecognitionException { | ||
26750 | |||
26751 | int stackSize = keepStackSize(); | ||
26752 | |||
26753 | try { | ||
26754 | // InternalAlloyLanguage.g:9506:1: ( ( ruleALSAnd ) ) | ||
26755 | // InternalAlloyLanguage.g:9507:1: ( ruleALSAnd ) | ||
26756 | { | ||
26757 | // InternalAlloyLanguage.g:9507:1: ( ruleALSAnd ) | ||
26758 | // InternalAlloyLanguage.g:9508:1: ruleALSAnd | ||
26759 | { | ||
26760 | if ( state.backtracking==0 ) { | ||
26761 | before(grammarAccess.getALSImplAccess().getRightOperandALSAndParserRuleCall_1_2_0()); | ||
26762 | } | ||
26763 | pushFollow(FOLLOW_2); | ||
26764 | ruleALSAnd(); | ||
26765 | |||
26766 | state._fsp--; | ||
26767 | if (state.failed) return ; | ||
26768 | if ( state.backtracking==0 ) { | ||
26769 | after(grammarAccess.getALSImplAccess().getRightOperandALSAndParserRuleCall_1_2_0()); | ||
26770 | } | ||
26771 | |||
26772 | } | ||
26773 | |||
26774 | |||
26775 | } | ||
26776 | |||
26777 | } | ||
26778 | catch (RecognitionException re) { | ||
26779 | reportError(re); | ||
26780 | recover(input,re); | ||
26781 | } | ||
26782 | finally { | ||
26783 | |||
26784 | restoreStackSize(stackSize); | ||
26785 | |||
26786 | } | ||
26787 | return ; | ||
26788 | } | ||
26789 | // $ANTLR end "rule__ALSImpl__RightOperandAssignment_1_2" | ||
26790 | |||
26791 | |||
26792 | // $ANTLR start "rule__ALSImpl__ElseOperandAssignment_1_3_1" | ||
26793 | // InternalAlloyLanguage.g:9517:1: rule__ALSImpl__ElseOperandAssignment_1_3_1 : ( ruleALSAnd ) ; | ||
26794 | public final void rule__ALSImpl__ElseOperandAssignment_1_3_1() throws RecognitionException { | ||
26795 | |||
26796 | int stackSize = keepStackSize(); | ||
26797 | |||
26798 | try { | ||
26799 | // InternalAlloyLanguage.g:9521:1: ( ( ruleALSAnd ) ) | ||
26800 | // InternalAlloyLanguage.g:9522:1: ( ruleALSAnd ) | ||
26801 | { | ||
26802 | // InternalAlloyLanguage.g:9522:1: ( ruleALSAnd ) | ||
26803 | // InternalAlloyLanguage.g:9523:1: ruleALSAnd | ||
26804 | { | ||
26805 | if ( state.backtracking==0 ) { | ||
26806 | before(grammarAccess.getALSImplAccess().getElseOperandALSAndParserRuleCall_1_3_1_0()); | ||
26807 | } | ||
26808 | pushFollow(FOLLOW_2); | ||
26809 | ruleALSAnd(); | ||
26810 | |||
26811 | state._fsp--; | ||
26812 | if (state.failed) return ; | ||
26813 | if ( state.backtracking==0 ) { | ||
26814 | after(grammarAccess.getALSImplAccess().getElseOperandALSAndParserRuleCall_1_3_1_0()); | ||
26815 | } | ||
26816 | |||
26817 | } | ||
26818 | |||
26819 | |||
26820 | } | ||
26821 | |||
26822 | } | ||
26823 | catch (RecognitionException re) { | ||
26824 | reportError(re); | ||
26825 | recover(input,re); | ||
26826 | } | ||
26827 | finally { | ||
26828 | |||
26829 | restoreStackSize(stackSize); | ||
26830 | |||
26831 | } | ||
26832 | return ; | ||
26833 | } | ||
26834 | // $ANTLR end "rule__ALSImpl__ElseOperandAssignment_1_3_1" | ||
26835 | |||
26836 | |||
26837 | // $ANTLR start "rule__ALSAnd__RightOperandAssignment_1_2" | ||
26838 | // InternalAlloyLanguage.g:9532:1: rule__ALSAnd__RightOperandAssignment_1_2 : ( ruleALSComparison ) ; | ||
26839 | public final void rule__ALSAnd__RightOperandAssignment_1_2() throws RecognitionException { | ||
26840 | |||
26841 | int stackSize = keepStackSize(); | ||
26842 | |||
26843 | try { | ||
26844 | // InternalAlloyLanguage.g:9536:1: ( ( ruleALSComparison ) ) | ||
26845 | // InternalAlloyLanguage.g:9537:1: ( ruleALSComparison ) | ||
26846 | { | ||
26847 | // InternalAlloyLanguage.g:9537:1: ( ruleALSComparison ) | ||
26848 | // InternalAlloyLanguage.g:9538:1: ruleALSComparison | ||
26849 | { | ||
26850 | if ( state.backtracking==0 ) { | ||
26851 | before(grammarAccess.getALSAndAccess().getRightOperandALSComparisonParserRuleCall_1_2_0()); | ||
26852 | } | ||
26853 | pushFollow(FOLLOW_2); | ||
26854 | ruleALSComparison(); | ||
26855 | |||
26856 | state._fsp--; | ||
26857 | if (state.failed) return ; | ||
26858 | if ( state.backtracking==0 ) { | ||
26859 | after(grammarAccess.getALSAndAccess().getRightOperandALSComparisonParserRuleCall_1_2_0()); | ||
26860 | } | ||
26861 | |||
26862 | } | ||
26863 | |||
26864 | |||
26865 | } | ||
26866 | |||
26867 | } | ||
26868 | catch (RecognitionException re) { | ||
26869 | reportError(re); | ||
26870 | recover(input,re); | ||
26871 | } | ||
26872 | finally { | ||
26873 | |||
26874 | restoreStackSize(stackSize); | ||
26875 | |||
26876 | } | ||
26877 | return ; | ||
26878 | } | ||
26879 | // $ANTLR end "rule__ALSAnd__RightOperandAssignment_1_2" | ||
26880 | |||
26881 | |||
26882 | // $ANTLR start "rule__ALSComparison__RightOperandAssignment_1_1" | ||
26883 | // InternalAlloyLanguage.g:9547:1: rule__ALSComparison__RightOperandAssignment_1_1 : ( ruleALSOverride ) ; | ||
26884 | public final void rule__ALSComparison__RightOperandAssignment_1_1() throws RecognitionException { | ||
26885 | |||
26886 | int stackSize = keepStackSize(); | ||
26887 | |||
26888 | try { | ||
26889 | // InternalAlloyLanguage.g:9551:1: ( ( ruleALSOverride ) ) | ||
26890 | // InternalAlloyLanguage.g:9552:1: ( ruleALSOverride ) | ||
26891 | { | ||
26892 | // InternalAlloyLanguage.g:9552:1: ( ruleALSOverride ) | ||
26893 | // InternalAlloyLanguage.g:9553:1: ruleALSOverride | ||
26894 | { | ||
26895 | if ( state.backtracking==0 ) { | ||
26896 | before(grammarAccess.getALSComparisonAccess().getRightOperandALSOverrideParserRuleCall_1_1_0()); | ||
26897 | } | ||
26898 | pushFollow(FOLLOW_2); | ||
26899 | ruleALSOverride(); | ||
26900 | |||
26901 | state._fsp--; | ||
26902 | if (state.failed) return ; | ||
26903 | if ( state.backtracking==0 ) { | ||
26904 | after(grammarAccess.getALSComparisonAccess().getRightOperandALSOverrideParserRuleCall_1_1_0()); | ||
26905 | } | ||
26906 | |||
26907 | } | ||
26908 | |||
26909 | |||
26910 | } | ||
26911 | |||
26912 | } | ||
26913 | catch (RecognitionException re) { | ||
26914 | reportError(re); | ||
26915 | recover(input,re); | ||
26916 | } | ||
26917 | finally { | ||
26918 | |||
26919 | restoreStackSize(stackSize); | ||
26920 | |||
26921 | } | ||
26922 | return ; | ||
26923 | } | ||
26924 | // $ANTLR end "rule__ALSComparison__RightOperandAssignment_1_1" | ||
26925 | |||
26926 | |||
26927 | // $ANTLR start "rule__ALSOverride__RightOperandAssignment_1_2" | ||
26928 | // InternalAlloyLanguage.g:9562:1: rule__ALSOverride__RightOperandAssignment_1_2 : ( ruleALSRangeRestrictionRight ) ; | ||
26929 | public final void rule__ALSOverride__RightOperandAssignment_1_2() throws RecognitionException { | ||
26930 | |||
26931 | int stackSize = keepStackSize(); | ||
26932 | |||
26933 | try { | ||
26934 | // InternalAlloyLanguage.g:9566:1: ( ( ruleALSRangeRestrictionRight ) ) | ||
26935 | // InternalAlloyLanguage.g:9567:1: ( ruleALSRangeRestrictionRight ) | ||
26936 | { | ||
26937 | // InternalAlloyLanguage.g:9567:1: ( ruleALSRangeRestrictionRight ) | ||
26938 | // InternalAlloyLanguage.g:9568:1: ruleALSRangeRestrictionRight | ||
26939 | { | ||
26940 | if ( state.backtracking==0 ) { | ||
26941 | before(grammarAccess.getALSOverrideAccess().getRightOperandALSRangeRestrictionRightParserRuleCall_1_2_0()); | ||
26942 | } | ||
26943 | pushFollow(FOLLOW_2); | ||
26944 | ruleALSRangeRestrictionRight(); | ||
26945 | |||
26946 | state._fsp--; | ||
26947 | if (state.failed) return ; | ||
26948 | if ( state.backtracking==0 ) { | ||
26949 | after(grammarAccess.getALSOverrideAccess().getRightOperandALSRangeRestrictionRightParserRuleCall_1_2_0()); | ||
26950 | } | ||
26951 | |||
26952 | } | ||
26953 | |||
26954 | |||
26955 | } | ||
26956 | |||
26957 | } | ||
26958 | catch (RecognitionException re) { | ||
26959 | reportError(re); | ||
26960 | recover(input,re); | ||
26961 | } | ||
26962 | finally { | ||
26963 | |||
26964 | restoreStackSize(stackSize); | ||
26965 | |||
26966 | } | ||
26967 | return ; | ||
26968 | } | ||
26969 | // $ANTLR end "rule__ALSOverride__RightOperandAssignment_1_2" | ||
26970 | |||
26971 | |||
26972 | // $ANTLR start "rule__ALSRangeRestrictionRight__FilterAssignment_1_2" | ||
26973 | // InternalAlloyLanguage.g:9577:1: rule__ALSRangeRestrictionRight__FilterAssignment_1_2 : ( ruleALSRangeRestrictionLeft ) ; | ||
26974 | public final void rule__ALSRangeRestrictionRight__FilterAssignment_1_2() throws RecognitionException { | ||
26975 | |||
26976 | int stackSize = keepStackSize(); | ||
26977 | |||
26978 | try { | ||
26979 | // InternalAlloyLanguage.g:9581:1: ( ( ruleALSRangeRestrictionLeft ) ) | ||
26980 | // InternalAlloyLanguage.g:9582:1: ( ruleALSRangeRestrictionLeft ) | ||
26981 | { | ||
26982 | // InternalAlloyLanguage.g:9582:1: ( ruleALSRangeRestrictionLeft ) | ||
26983 | // InternalAlloyLanguage.g:9583:1: ruleALSRangeRestrictionLeft | ||
26984 | { | ||
26985 | if ( state.backtracking==0 ) { | ||
26986 | before(grammarAccess.getALSRangeRestrictionRightAccess().getFilterALSRangeRestrictionLeftParserRuleCall_1_2_0()); | ||
26987 | } | ||
26988 | pushFollow(FOLLOW_2); | ||
26989 | ruleALSRangeRestrictionLeft(); | ||
26990 | |||
26991 | state._fsp--; | ||
26992 | if (state.failed) return ; | ||
26993 | if ( state.backtracking==0 ) { | ||
26994 | after(grammarAccess.getALSRangeRestrictionRightAccess().getFilterALSRangeRestrictionLeftParserRuleCall_1_2_0()); | ||
26995 | } | ||
26996 | |||
26997 | } | ||
26998 | |||
26999 | |||
27000 | } | ||
27001 | |||
27002 | } | ||
27003 | catch (RecognitionException re) { | ||
27004 | reportError(re); | ||
27005 | recover(input,re); | ||
27006 | } | ||
27007 | finally { | ||
27008 | |||
27009 | restoreStackSize(stackSize); | ||
27010 | |||
27011 | } | ||
27012 | return ; | ||
27013 | } | ||
27014 | // $ANTLR end "rule__ALSRangeRestrictionRight__FilterAssignment_1_2" | ||
27015 | |||
27016 | |||
27017 | // $ANTLR start "rule__ALSRangeRestrictionLeft__RelationAssignment_1_2" | ||
27018 | // InternalAlloyLanguage.g:9592:1: rule__ALSRangeRestrictionLeft__RelationAssignment_1_2 : ( ruleALSJoin ) ; | ||
27019 | public final void rule__ALSRangeRestrictionLeft__RelationAssignment_1_2() throws RecognitionException { | ||
27020 | |||
27021 | int stackSize = keepStackSize(); | ||
27022 | |||
27023 | try { | ||
27024 | // InternalAlloyLanguage.g:9596:1: ( ( ruleALSJoin ) ) | ||
27025 | // InternalAlloyLanguage.g:9597:1: ( ruleALSJoin ) | ||
27026 | { | ||
27027 | // InternalAlloyLanguage.g:9597:1: ( ruleALSJoin ) | ||
27028 | // InternalAlloyLanguage.g:9598:1: ruleALSJoin | ||
27029 | { | ||
27030 | if ( state.backtracking==0 ) { | ||
27031 | before(grammarAccess.getALSRangeRestrictionLeftAccess().getRelationALSJoinParserRuleCall_1_2_0()); | ||
27032 | } | ||
27033 | pushFollow(FOLLOW_2); | ||
27034 | ruleALSJoin(); | ||
27035 | |||
27036 | state._fsp--; | ||
27037 | if (state.failed) return ; | ||
27038 | if ( state.backtracking==0 ) { | ||
27039 | after(grammarAccess.getALSRangeRestrictionLeftAccess().getRelationALSJoinParserRuleCall_1_2_0()); | ||
27040 | } | ||
27041 | |||
27042 | } | ||
27043 | |||
27044 | |||
27045 | } | ||
27046 | |||
27047 | } | ||
27048 | catch (RecognitionException re) { | ||
27049 | reportError(re); | ||
27050 | recover(input,re); | ||
27051 | } | ||
27052 | finally { | ||
27053 | |||
27054 | restoreStackSize(stackSize); | ||
27055 | |||
27056 | } | ||
27057 | return ; | ||
27058 | } | ||
27059 | // $ANTLR end "rule__ALSRangeRestrictionLeft__RelationAssignment_1_2" | ||
27060 | |||
27061 | |||
27062 | // $ANTLR start "rule__ALSJoin__RightOperandAssignment_1_2" | ||
27063 | // InternalAlloyLanguage.g:9607:1: rule__ALSJoin__RightOperandAssignment_1_2 : ( ruleALSMinus ) ; | ||
27064 | public final void rule__ALSJoin__RightOperandAssignment_1_2() throws RecognitionException { | ||
27065 | |||
27066 | int stackSize = keepStackSize(); | ||
27067 | |||
27068 | try { | ||
27069 | // InternalAlloyLanguage.g:9611:1: ( ( ruleALSMinus ) ) | ||
27070 | // InternalAlloyLanguage.g:9612:1: ( ruleALSMinus ) | ||
27071 | { | ||
27072 | // InternalAlloyLanguage.g:9612:1: ( ruleALSMinus ) | ||
27073 | // InternalAlloyLanguage.g:9613:1: ruleALSMinus | ||
27074 | { | ||
27075 | if ( state.backtracking==0 ) { | ||
27076 | before(grammarAccess.getALSJoinAccess().getRightOperandALSMinusParserRuleCall_1_2_0()); | ||
27077 | } | ||
27078 | pushFollow(FOLLOW_2); | ||
27079 | ruleALSMinus(); | ||
27080 | |||
27081 | state._fsp--; | ||
27082 | if (state.failed) return ; | ||
27083 | if ( state.backtracking==0 ) { | ||
27084 | after(grammarAccess.getALSJoinAccess().getRightOperandALSMinusParserRuleCall_1_2_0()); | ||
27085 | } | ||
27086 | |||
27087 | } | ||
27088 | |||
27089 | |||
27090 | } | ||
27091 | |||
27092 | } | ||
27093 | catch (RecognitionException re) { | ||
27094 | reportError(re); | ||
27095 | recover(input,re); | ||
27096 | } | ||
27097 | finally { | ||
27098 | |||
27099 | restoreStackSize(stackSize); | ||
27100 | |||
27101 | } | ||
27102 | return ; | ||
27103 | } | ||
27104 | // $ANTLR end "rule__ALSJoin__RightOperandAssignment_1_2" | ||
27105 | |||
27106 | |||
27107 | // $ANTLR start "rule__ALSMinus__RightOperandAssignment_1_2" | ||
27108 | // InternalAlloyLanguage.g:9622:1: rule__ALSMinus__RightOperandAssignment_1_2 : ( ruleALSPlus ) ; | ||
27109 | public final void rule__ALSMinus__RightOperandAssignment_1_2() throws RecognitionException { | ||
27110 | |||
27111 | int stackSize = keepStackSize(); | ||
27112 | |||
27113 | try { | ||
27114 | // InternalAlloyLanguage.g:9626:1: ( ( ruleALSPlus ) ) | ||
27115 | // InternalAlloyLanguage.g:9627:1: ( ruleALSPlus ) | ||
27116 | { | ||
27117 | // InternalAlloyLanguage.g:9627:1: ( ruleALSPlus ) | ||
27118 | // InternalAlloyLanguage.g:9628:1: ruleALSPlus | ||
27119 | { | ||
27120 | if ( state.backtracking==0 ) { | ||
27121 | before(grammarAccess.getALSMinusAccess().getRightOperandALSPlusParserRuleCall_1_2_0()); | ||
27122 | } | ||
27123 | pushFollow(FOLLOW_2); | ||
27124 | ruleALSPlus(); | ||
27125 | |||
27126 | state._fsp--; | ||
27127 | if (state.failed) return ; | ||
27128 | if ( state.backtracking==0 ) { | ||
27129 | after(grammarAccess.getALSMinusAccess().getRightOperandALSPlusParserRuleCall_1_2_0()); | ||
27130 | } | ||
27131 | |||
27132 | } | ||
27133 | |||
27134 | |||
27135 | } | ||
27136 | |||
27137 | } | ||
27138 | catch (RecognitionException re) { | ||
27139 | reportError(re); | ||
27140 | recover(input,re); | ||
27141 | } | ||
27142 | finally { | ||
27143 | |||
27144 | restoreStackSize(stackSize); | ||
27145 | |||
27146 | } | ||
27147 | return ; | ||
27148 | } | ||
27149 | // $ANTLR end "rule__ALSMinus__RightOperandAssignment_1_2" | ||
27150 | |||
27151 | |||
27152 | // $ANTLR start "rule__ALSPlus__RightOperandAssignment_1_2" | ||
27153 | // InternalAlloyLanguage.g:9637:1: rule__ALSPlus__RightOperandAssignment_1_2 : ( ruleALSIntersection ) ; | ||
27154 | public final void rule__ALSPlus__RightOperandAssignment_1_2() throws RecognitionException { | ||
27155 | |||
27156 | int stackSize = keepStackSize(); | ||
27157 | |||
27158 | try { | ||
27159 | // InternalAlloyLanguage.g:9641:1: ( ( ruleALSIntersection ) ) | ||
27160 | // InternalAlloyLanguage.g:9642:1: ( ruleALSIntersection ) | ||
27161 | { | ||
27162 | // InternalAlloyLanguage.g:9642:1: ( ruleALSIntersection ) | ||
27163 | // InternalAlloyLanguage.g:9643:1: ruleALSIntersection | ||
27164 | { | ||
27165 | if ( state.backtracking==0 ) { | ||
27166 | before(grammarAccess.getALSPlusAccess().getRightOperandALSIntersectionParserRuleCall_1_2_0()); | ||
27167 | } | ||
27168 | pushFollow(FOLLOW_2); | ||
27169 | ruleALSIntersection(); | ||
27170 | |||
27171 | state._fsp--; | ||
27172 | if (state.failed) return ; | ||
27173 | if ( state.backtracking==0 ) { | ||
27174 | after(grammarAccess.getALSPlusAccess().getRightOperandALSIntersectionParserRuleCall_1_2_0()); | ||
27175 | } | ||
27176 | |||
27177 | } | ||
27178 | |||
27179 | |||
27180 | } | ||
27181 | |||
27182 | } | ||
27183 | catch (RecognitionException re) { | ||
27184 | reportError(re); | ||
27185 | recover(input,re); | ||
27186 | } | ||
27187 | finally { | ||
27188 | |||
27189 | restoreStackSize(stackSize); | ||
27190 | |||
27191 | } | ||
27192 | return ; | ||
27193 | } | ||
27194 | // $ANTLR end "rule__ALSPlus__RightOperandAssignment_1_2" | ||
27195 | |||
27196 | |||
27197 | // $ANTLR start "rule__ALSIntersection__RightOperandAssignment_1_2" | ||
27198 | // InternalAlloyLanguage.g:9652:1: rule__ALSIntersection__RightOperandAssignment_1_2 : ( ruleALSDirectProduct ) ; | ||
27199 | public final void rule__ALSIntersection__RightOperandAssignment_1_2() throws RecognitionException { | ||
27200 | |||
27201 | int stackSize = keepStackSize(); | ||
27202 | |||
27203 | try { | ||
27204 | // InternalAlloyLanguage.g:9656:1: ( ( ruleALSDirectProduct ) ) | ||
27205 | // InternalAlloyLanguage.g:9657:1: ( ruleALSDirectProduct ) | ||
27206 | { | ||
27207 | // InternalAlloyLanguage.g:9657:1: ( ruleALSDirectProduct ) | ||
27208 | // InternalAlloyLanguage.g:9658:1: ruleALSDirectProduct | ||
27209 | { | ||
27210 | if ( state.backtracking==0 ) { | ||
27211 | before(grammarAccess.getALSIntersectionAccess().getRightOperandALSDirectProductParserRuleCall_1_2_0()); | ||
27212 | } | ||
27213 | pushFollow(FOLLOW_2); | ||
27214 | ruleALSDirectProduct(); | ||
27215 | |||
27216 | state._fsp--; | ||
27217 | if (state.failed) return ; | ||
27218 | if ( state.backtracking==0 ) { | ||
27219 | after(grammarAccess.getALSIntersectionAccess().getRightOperandALSDirectProductParserRuleCall_1_2_0()); | ||
27220 | } | ||
27221 | |||
27222 | } | ||
27223 | |||
27224 | |||
27225 | } | ||
27226 | |||
27227 | } | ||
27228 | catch (RecognitionException re) { | ||
27229 | reportError(re); | ||
27230 | recover(input,re); | ||
27231 | } | ||
27232 | finally { | ||
27233 | |||
27234 | restoreStackSize(stackSize); | ||
27235 | |||
27236 | } | ||
27237 | return ; | ||
27238 | } | ||
27239 | // $ANTLR end "rule__ALSIntersection__RightOperandAssignment_1_2" | ||
27240 | |||
27241 | |||
27242 | // $ANTLR start "rule__ALSDirectProduct__LeftMultiplicitAssignment_1_1" | ||
27243 | // InternalAlloyLanguage.g:9667:1: rule__ALSDirectProduct__LeftMultiplicitAssignment_1_1 : ( ruleALSMultiplicity ) ; | ||
27244 | public final void rule__ALSDirectProduct__LeftMultiplicitAssignment_1_1() throws RecognitionException { | ||
27245 | |||
27246 | int stackSize = keepStackSize(); | ||
27247 | |||
27248 | try { | ||
27249 | // InternalAlloyLanguage.g:9671:1: ( ( ruleALSMultiplicity ) ) | ||
27250 | // InternalAlloyLanguage.g:9672:1: ( ruleALSMultiplicity ) | ||
27251 | { | ||
27252 | // InternalAlloyLanguage.g:9672:1: ( ruleALSMultiplicity ) | ||
27253 | // InternalAlloyLanguage.g:9673:1: ruleALSMultiplicity | ||
27254 | { | ||
27255 | if ( state.backtracking==0 ) { | ||
27256 | before(grammarAccess.getALSDirectProductAccess().getLeftMultiplicitALSMultiplicityEnumRuleCall_1_1_0()); | ||
27257 | } | ||
27258 | pushFollow(FOLLOW_2); | ||
27259 | ruleALSMultiplicity(); | ||
27260 | |||
27261 | state._fsp--; | ||
27262 | if (state.failed) return ; | ||
27263 | if ( state.backtracking==0 ) { | ||
27264 | after(grammarAccess.getALSDirectProductAccess().getLeftMultiplicitALSMultiplicityEnumRuleCall_1_1_0()); | ||
27265 | } | ||
27266 | |||
27267 | } | ||
27268 | |||
27269 | |||
27270 | } | ||
27271 | |||
27272 | } | ||
27273 | catch (RecognitionException re) { | ||
27274 | reportError(re); | ||
27275 | recover(input,re); | ||
27276 | } | ||
27277 | finally { | ||
27278 | |||
27279 | restoreStackSize(stackSize); | ||
27280 | |||
27281 | } | ||
27282 | return ; | ||
27283 | } | ||
27284 | // $ANTLR end "rule__ALSDirectProduct__LeftMultiplicitAssignment_1_1" | ||
27285 | |||
27286 | |||
27287 | // $ANTLR start "rule__ALSDirectProduct__RightMultiplicitAssignment_1_3" | ||
27288 | // InternalAlloyLanguage.g:9682:1: rule__ALSDirectProduct__RightMultiplicitAssignment_1_3 : ( ruleALSMultiplicity ) ; | ||
27289 | public final void rule__ALSDirectProduct__RightMultiplicitAssignment_1_3() throws RecognitionException { | ||
27290 | |||
27291 | int stackSize = keepStackSize(); | ||
27292 | |||
27293 | try { | ||
27294 | // InternalAlloyLanguage.g:9686:1: ( ( ruleALSMultiplicity ) ) | ||
27295 | // InternalAlloyLanguage.g:9687:1: ( ruleALSMultiplicity ) | ||
27296 | { | ||
27297 | // InternalAlloyLanguage.g:9687:1: ( ruleALSMultiplicity ) | ||
27298 | // InternalAlloyLanguage.g:9688:1: ruleALSMultiplicity | ||
27299 | { | ||
27300 | if ( state.backtracking==0 ) { | ||
27301 | before(grammarAccess.getALSDirectProductAccess().getRightMultiplicitALSMultiplicityEnumRuleCall_1_3_0()); | ||
27302 | } | ||
27303 | pushFollow(FOLLOW_2); | ||
27304 | ruleALSMultiplicity(); | ||
27305 | |||
27306 | state._fsp--; | ||
27307 | if (state.failed) return ; | ||
27308 | if ( state.backtracking==0 ) { | ||
27309 | after(grammarAccess.getALSDirectProductAccess().getRightMultiplicitALSMultiplicityEnumRuleCall_1_3_0()); | ||
27310 | } | ||
27311 | |||
27312 | } | ||
27313 | |||
27314 | |||
27315 | } | ||
27316 | |||
27317 | } | ||
27318 | catch (RecognitionException re) { | ||
27319 | reportError(re); | ||
27320 | recover(input,re); | ||
27321 | } | ||
27322 | finally { | ||
27323 | |||
27324 | restoreStackSize(stackSize); | ||
27325 | |||
27326 | } | ||
27327 | return ; | ||
27328 | } | ||
27329 | // $ANTLR end "rule__ALSDirectProduct__RightMultiplicitAssignment_1_3" | ||
27330 | |||
27331 | |||
27332 | // $ANTLR start "rule__ALSDirectProduct__RightOperandAssignment_1_4" | ||
27333 | // InternalAlloyLanguage.g:9697:1: rule__ALSDirectProduct__RightOperandAssignment_1_4 : ( ruleALSPreficed ) ; | ||
27334 | public final void rule__ALSDirectProduct__RightOperandAssignment_1_4() throws RecognitionException { | ||
27335 | |||
27336 | int stackSize = keepStackSize(); | ||
27337 | |||
27338 | try { | ||
27339 | // InternalAlloyLanguage.g:9701:1: ( ( ruleALSPreficed ) ) | ||
27340 | // InternalAlloyLanguage.g:9702:1: ( ruleALSPreficed ) | ||
27341 | { | ||
27342 | // InternalAlloyLanguage.g:9702:1: ( ruleALSPreficed ) | ||
27343 | // InternalAlloyLanguage.g:9703:1: ruleALSPreficed | ||
27344 | { | ||
27345 | if ( state.backtracking==0 ) { | ||
27346 | before(grammarAccess.getALSDirectProductAccess().getRightOperandALSPreficedParserRuleCall_1_4_0()); | ||
27347 | } | ||
27348 | pushFollow(FOLLOW_2); | ||
27349 | ruleALSPreficed(); | ||
27350 | |||
27351 | state._fsp--; | ||
27352 | if (state.failed) return ; | ||
27353 | if ( state.backtracking==0 ) { | ||
27354 | after(grammarAccess.getALSDirectProductAccess().getRightOperandALSPreficedParserRuleCall_1_4_0()); | ||
27355 | } | ||
27356 | |||
27357 | } | ||
27358 | |||
27359 | |||
27360 | } | ||
27361 | |||
27362 | } | ||
27363 | catch (RecognitionException re) { | ||
27364 | reportError(re); | ||
27365 | recover(input,re); | ||
27366 | } | ||
27367 | finally { | ||
27368 | |||
27369 | restoreStackSize(stackSize); | ||
27370 | |||
27371 | } | ||
27372 | return ; | ||
27373 | } | ||
27374 | // $ANTLR end "rule__ALSDirectProduct__RightOperandAssignment_1_4" | ||
27375 | |||
27376 | |||
27377 | // $ANTLR start "rule__ALSPreficed__OperandAssignment_0_2" | ||
27378 | // InternalAlloyLanguage.g:9712:1: rule__ALSPreficed__OperandAssignment_0_2 : ( ruleALSBasicRelationTerm ) ; | ||
27379 | public final void rule__ALSPreficed__OperandAssignment_0_2() throws RecognitionException { | ||
27380 | |||
27381 | int stackSize = keepStackSize(); | ||
27382 | |||
27383 | try { | ||
27384 | // InternalAlloyLanguage.g:9716:1: ( ( ruleALSBasicRelationTerm ) ) | ||
27385 | // InternalAlloyLanguage.g:9717:1: ( ruleALSBasicRelationTerm ) | ||
27386 | { | ||
27387 | // InternalAlloyLanguage.g:9717:1: ( ruleALSBasicRelationTerm ) | ||
27388 | // InternalAlloyLanguage.g:9718:1: ruleALSBasicRelationTerm | ||
27389 | { | ||
27390 | if ( state.backtracking==0 ) { | ||
27391 | before(grammarAccess.getALSPreficedAccess().getOperandALSBasicRelationTermParserRuleCall_0_2_0()); | ||
27392 | } | ||
27393 | pushFollow(FOLLOW_2); | ||
27394 | ruleALSBasicRelationTerm(); | ||
27395 | |||
27396 | state._fsp--; | ||
27397 | if (state.failed) return ; | ||
27398 | if ( state.backtracking==0 ) { | ||
27399 | after(grammarAccess.getALSPreficedAccess().getOperandALSBasicRelationTermParserRuleCall_0_2_0()); | ||
27400 | } | ||
27401 | |||
27402 | } | ||
27403 | |||
27404 | |||
27405 | } | ||
27406 | |||
27407 | } | ||
27408 | catch (RecognitionException re) { | ||
27409 | reportError(re); | ||
27410 | recover(input,re); | ||
27411 | } | ||
27412 | finally { | ||
27413 | |||
27414 | restoreStackSize(stackSize); | ||
27415 | |||
27416 | } | ||
27417 | return ; | ||
27418 | } | ||
27419 | // $ANTLR end "rule__ALSPreficed__OperandAssignment_0_2" | ||
27420 | |||
27421 | |||
27422 | // $ANTLR start "rule__ALSPreficed__OperandAssignment_1_2" | ||
27423 | // InternalAlloyLanguage.g:9727:1: rule__ALSPreficed__OperandAssignment_1_2 : ( ruleALSBasicRelationTerm ) ; | ||
27424 | public final void rule__ALSPreficed__OperandAssignment_1_2() throws RecognitionException { | ||
27425 | |||
27426 | int stackSize = keepStackSize(); | ||
27427 | |||
27428 | try { | ||
27429 | // InternalAlloyLanguage.g:9731:1: ( ( ruleALSBasicRelationTerm ) ) | ||
27430 | // InternalAlloyLanguage.g:9732:1: ( ruleALSBasicRelationTerm ) | ||
27431 | { | ||
27432 | // InternalAlloyLanguage.g:9732:1: ( ruleALSBasicRelationTerm ) | ||
27433 | // InternalAlloyLanguage.g:9733:1: ruleALSBasicRelationTerm | ||
27434 | { | ||
27435 | if ( state.backtracking==0 ) { | ||
27436 | before(grammarAccess.getALSPreficedAccess().getOperandALSBasicRelationTermParserRuleCall_1_2_0()); | ||
27437 | } | ||
27438 | pushFollow(FOLLOW_2); | ||
27439 | ruleALSBasicRelationTerm(); | ||
27440 | |||
27441 | state._fsp--; | ||
27442 | if (state.failed) return ; | ||
27443 | if ( state.backtracking==0 ) { | ||
27444 | after(grammarAccess.getALSPreficedAccess().getOperandALSBasicRelationTermParserRuleCall_1_2_0()); | ||
27445 | } | ||
27446 | |||
27447 | } | ||
27448 | |||
27449 | |||
27450 | } | ||
27451 | |||
27452 | } | ||
27453 | catch (RecognitionException re) { | ||
27454 | reportError(re); | ||
27455 | recover(input,re); | ||
27456 | } | ||
27457 | finally { | ||
27458 | |||
27459 | restoreStackSize(stackSize); | ||
27460 | |||
27461 | } | ||
27462 | return ; | ||
27463 | } | ||
27464 | // $ANTLR end "rule__ALSPreficed__OperandAssignment_1_2" | ||
27465 | |||
27466 | |||
27467 | // $ANTLR start "rule__ALSPreficed__OperandAssignment_2_2" | ||
27468 | // InternalAlloyLanguage.g:9742:1: rule__ALSPreficed__OperandAssignment_2_2 : ( ruleALSBasicRelationTerm ) ; | ||
27469 | public final void rule__ALSPreficed__OperandAssignment_2_2() throws RecognitionException { | ||
27470 | |||
27471 | int stackSize = keepStackSize(); | ||
27472 | |||
27473 | try { | ||
27474 | // InternalAlloyLanguage.g:9746:1: ( ( ruleALSBasicRelationTerm ) ) | ||
27475 | // InternalAlloyLanguage.g:9747:1: ( ruleALSBasicRelationTerm ) | ||
27476 | { | ||
27477 | // InternalAlloyLanguage.g:9747:1: ( ruleALSBasicRelationTerm ) | ||
27478 | // InternalAlloyLanguage.g:9748:1: ruleALSBasicRelationTerm | ||
27479 | { | ||
27480 | if ( state.backtracking==0 ) { | ||
27481 | before(grammarAccess.getALSPreficedAccess().getOperandALSBasicRelationTermParserRuleCall_2_2_0()); | ||
27482 | } | ||
27483 | pushFollow(FOLLOW_2); | ||
27484 | ruleALSBasicRelationTerm(); | ||
27485 | |||
27486 | state._fsp--; | ||
27487 | if (state.failed) return ; | ||
27488 | if ( state.backtracking==0 ) { | ||
27489 | after(grammarAccess.getALSPreficedAccess().getOperandALSBasicRelationTermParserRuleCall_2_2_0()); | ||
27490 | } | ||
27491 | |||
27492 | } | ||
27493 | |||
27494 | |||
27495 | } | ||
27496 | |||
27497 | } | ||
27498 | catch (RecognitionException re) { | ||
27499 | reportError(re); | ||
27500 | recover(input,re); | ||
27501 | } | ||
27502 | finally { | ||
27503 | |||
27504 | restoreStackSize(stackSize); | ||
27505 | |||
27506 | } | ||
27507 | return ; | ||
27508 | } | ||
27509 | // $ANTLR end "rule__ALSPreficed__OperandAssignment_2_2" | ||
27510 | |||
27511 | |||
27512 | // $ANTLR start "rule__ALSPreficed__OperandAssignment_3_2" | ||
27513 | // InternalAlloyLanguage.g:9757:1: rule__ALSPreficed__OperandAssignment_3_2 : ( ruleALSBasicRelationTerm ) ; | ||
27514 | public final void rule__ALSPreficed__OperandAssignment_3_2() throws RecognitionException { | ||
27515 | |||
27516 | int stackSize = keepStackSize(); | ||
27517 | |||
27518 | try { | ||
27519 | // InternalAlloyLanguage.g:9761:1: ( ( ruleALSBasicRelationTerm ) ) | ||
27520 | // InternalAlloyLanguage.g:9762:1: ( ruleALSBasicRelationTerm ) | ||
27521 | { | ||
27522 | // InternalAlloyLanguage.g:9762:1: ( ruleALSBasicRelationTerm ) | ||
27523 | // InternalAlloyLanguage.g:9763:1: ruleALSBasicRelationTerm | ||
27524 | { | ||
27525 | if ( state.backtracking==0 ) { | ||
27526 | before(grammarAccess.getALSPreficedAccess().getOperandALSBasicRelationTermParserRuleCall_3_2_0()); | ||
27527 | } | ||
27528 | pushFollow(FOLLOW_2); | ||
27529 | ruleALSBasicRelationTerm(); | ||
27530 | |||
27531 | state._fsp--; | ||
27532 | if (state.failed) return ; | ||
27533 | if ( state.backtracking==0 ) { | ||
27534 | after(grammarAccess.getALSPreficedAccess().getOperandALSBasicRelationTermParserRuleCall_3_2_0()); | ||
27535 | } | ||
27536 | |||
27537 | } | ||
27538 | |||
27539 | |||
27540 | } | ||
27541 | |||
27542 | } | ||
27543 | catch (RecognitionException re) { | ||
27544 | reportError(re); | ||
27545 | recover(input,re); | ||
27546 | } | ||
27547 | finally { | ||
27548 | |||
27549 | restoreStackSize(stackSize); | ||
27550 | |||
27551 | } | ||
27552 | return ; | ||
27553 | } | ||
27554 | // $ANTLR end "rule__ALSPreficed__OperandAssignment_3_2" | ||
27555 | |||
27556 | |||
27557 | // $ANTLR start "rule__ALSPreficed__OperandAssignment_4_2" | ||
27558 | // InternalAlloyLanguage.g:9772:1: rule__ALSPreficed__OperandAssignment_4_2 : ( ruleALSBasicRelationTerm ) ; | ||
27559 | public final void rule__ALSPreficed__OperandAssignment_4_2() throws RecognitionException { | ||
27560 | |||
27561 | int stackSize = keepStackSize(); | ||
27562 | |||
27563 | try { | ||
27564 | // InternalAlloyLanguage.g:9776:1: ( ( ruleALSBasicRelationTerm ) ) | ||
27565 | // InternalAlloyLanguage.g:9777:1: ( ruleALSBasicRelationTerm ) | ||
27566 | { | ||
27567 | // InternalAlloyLanguage.g:9777:1: ( ruleALSBasicRelationTerm ) | ||
27568 | // InternalAlloyLanguage.g:9778:1: ruleALSBasicRelationTerm | ||
27569 | { | ||
27570 | if ( state.backtracking==0 ) { | ||
27571 | before(grammarAccess.getALSPreficedAccess().getOperandALSBasicRelationTermParserRuleCall_4_2_0()); | ||
27572 | } | ||
27573 | pushFollow(FOLLOW_2); | ||
27574 | ruleALSBasicRelationTerm(); | ||
27575 | |||
27576 | state._fsp--; | ||
27577 | if (state.failed) return ; | ||
27578 | if ( state.backtracking==0 ) { | ||
27579 | after(grammarAccess.getALSPreficedAccess().getOperandALSBasicRelationTermParserRuleCall_4_2_0()); | ||
27580 | } | ||
27581 | |||
27582 | } | ||
27583 | |||
27584 | |||
27585 | } | ||
27586 | |||
27587 | } | ||
27588 | catch (RecognitionException re) { | ||
27589 | reportError(re); | ||
27590 | recover(input,re); | ||
27591 | } | ||
27592 | finally { | ||
27593 | |||
27594 | restoreStackSize(stackSize); | ||
27595 | |||
27596 | } | ||
27597 | return ; | ||
27598 | } | ||
27599 | // $ANTLR end "rule__ALSPreficed__OperandAssignment_4_2" | ||
27600 | |||
27601 | |||
27602 | // $ANTLR start "rule__ALSPreficed__OperandAssignment_5_2" | ||
27603 | // InternalAlloyLanguage.g:9787:1: rule__ALSPreficed__OperandAssignment_5_2 : ( ruleALSBasicRelationTerm ) ; | ||
27604 | public final void rule__ALSPreficed__OperandAssignment_5_2() throws RecognitionException { | ||
27605 | |||
27606 | int stackSize = keepStackSize(); | ||
27607 | |||
27608 | try { | ||
27609 | // InternalAlloyLanguage.g:9791:1: ( ( ruleALSBasicRelationTerm ) ) | ||
27610 | // InternalAlloyLanguage.g:9792:1: ( ruleALSBasicRelationTerm ) | ||
27611 | { | ||
27612 | // InternalAlloyLanguage.g:9792:1: ( ruleALSBasicRelationTerm ) | ||
27613 | // InternalAlloyLanguage.g:9793:1: ruleALSBasicRelationTerm | ||
27614 | { | ||
27615 | if ( state.backtracking==0 ) { | ||
27616 | before(grammarAccess.getALSPreficedAccess().getOperandALSBasicRelationTermParserRuleCall_5_2_0()); | ||
27617 | } | ||
27618 | pushFollow(FOLLOW_2); | ||
27619 | ruleALSBasicRelationTerm(); | ||
27620 | |||
27621 | state._fsp--; | ||
27622 | if (state.failed) return ; | ||
27623 | if ( state.backtracking==0 ) { | ||
27624 | after(grammarAccess.getALSPreficedAccess().getOperandALSBasicRelationTermParserRuleCall_5_2_0()); | ||
27625 | } | ||
27626 | |||
27627 | } | ||
27628 | |||
27629 | |||
27630 | } | ||
27631 | |||
27632 | } | ||
27633 | catch (RecognitionException re) { | ||
27634 | reportError(re); | ||
27635 | recover(input,re); | ||
27636 | } | ||
27637 | finally { | ||
27638 | |||
27639 | restoreStackSize(stackSize); | ||
27640 | |||
27641 | } | ||
27642 | return ; | ||
27643 | } | ||
27644 | // $ANTLR end "rule__ALSPreficed__OperandAssignment_5_2" | ||
27645 | |||
27646 | |||
27647 | // $ANTLR start "rule__ALSPreficed__VariablesAssignment_6_2" | ||
27648 | // InternalAlloyLanguage.g:9802:1: rule__ALSPreficed__VariablesAssignment_6_2 : ( ruleALSVariableDeclaration ) ; | ||
27649 | public final void rule__ALSPreficed__VariablesAssignment_6_2() throws RecognitionException { | ||
27650 | |||
27651 | int stackSize = keepStackSize(); | ||
27652 | |||
27653 | try { | ||
27654 | // InternalAlloyLanguage.g:9806:1: ( ( ruleALSVariableDeclaration ) ) | ||
27655 | // InternalAlloyLanguage.g:9807:1: ( ruleALSVariableDeclaration ) | ||
27656 | { | ||
27657 | // InternalAlloyLanguage.g:9807:1: ( ruleALSVariableDeclaration ) | ||
27658 | // InternalAlloyLanguage.g:9808:1: ruleALSVariableDeclaration | ||
27659 | { | ||
27660 | if ( state.backtracking==0 ) { | ||
27661 | before(grammarAccess.getALSPreficedAccess().getVariablesALSVariableDeclarationParserRuleCall_6_2_0()); | ||
27662 | } | ||
27663 | pushFollow(FOLLOW_2); | ||
27664 | ruleALSVariableDeclaration(); | ||
27665 | |||
27666 | state._fsp--; | ||
27667 | if (state.failed) return ; | ||
27668 | if ( state.backtracking==0 ) { | ||
27669 | after(grammarAccess.getALSPreficedAccess().getVariablesALSVariableDeclarationParserRuleCall_6_2_0()); | ||
27670 | } | ||
27671 | |||
27672 | } | ||
27673 | |||
27674 | |||
27675 | } | ||
27676 | |||
27677 | } | ||
27678 | catch (RecognitionException re) { | ||
27679 | reportError(re); | ||
27680 | recover(input,re); | ||
27681 | } | ||
27682 | finally { | ||
27683 | |||
27684 | restoreStackSize(stackSize); | ||
27685 | |||
27686 | } | ||
27687 | return ; | ||
27688 | } | ||
27689 | // $ANTLR end "rule__ALSPreficed__VariablesAssignment_6_2" | ||
27690 | |||
27691 | |||
27692 | // $ANTLR start "rule__ALSPreficed__VariablesAssignment_6_3_1" | ||
27693 | // InternalAlloyLanguage.g:9817:1: rule__ALSPreficed__VariablesAssignment_6_3_1 : ( ruleALSVariableDeclaration ) ; | ||
27694 | public final void rule__ALSPreficed__VariablesAssignment_6_3_1() throws RecognitionException { | ||
27695 | |||
27696 | int stackSize = keepStackSize(); | ||
27697 | |||
27698 | try { | ||
27699 | // InternalAlloyLanguage.g:9821:1: ( ( ruleALSVariableDeclaration ) ) | ||
27700 | // InternalAlloyLanguage.g:9822:1: ( ruleALSVariableDeclaration ) | ||
27701 | { | ||
27702 | // InternalAlloyLanguage.g:9822:1: ( ruleALSVariableDeclaration ) | ||
27703 | // InternalAlloyLanguage.g:9823:1: ruleALSVariableDeclaration | ||
27704 | { | ||
27705 | if ( state.backtracking==0 ) { | ||
27706 | before(grammarAccess.getALSPreficedAccess().getVariablesALSVariableDeclarationParserRuleCall_6_3_1_0()); | ||
27707 | } | ||
27708 | pushFollow(FOLLOW_2); | ||
27709 | ruleALSVariableDeclaration(); | ||
27710 | |||
27711 | state._fsp--; | ||
27712 | if (state.failed) return ; | ||
27713 | if ( state.backtracking==0 ) { | ||
27714 | after(grammarAccess.getALSPreficedAccess().getVariablesALSVariableDeclarationParserRuleCall_6_3_1_0()); | ||
27715 | } | ||
27716 | |||
27717 | } | ||
27718 | |||
27719 | |||
27720 | } | ||
27721 | |||
27722 | } | ||
27723 | catch (RecognitionException re) { | ||
27724 | reportError(re); | ||
27725 | recover(input,re); | ||
27726 | } | ||
27727 | finally { | ||
27728 | |||
27729 | restoreStackSize(stackSize); | ||
27730 | |||
27731 | } | ||
27732 | return ; | ||
27733 | } | ||
27734 | // $ANTLR end "rule__ALSPreficed__VariablesAssignment_6_3_1" | ||
27735 | |||
27736 | |||
27737 | // $ANTLR start "rule__ALSPreficed__ExpressionAssignment_6_5" | ||
27738 | // InternalAlloyLanguage.g:9832:1: rule__ALSPreficed__ExpressionAssignment_6_5 : ( ruleALSTerm ) ; | ||
27739 | public final void rule__ALSPreficed__ExpressionAssignment_6_5() throws RecognitionException { | ||
27740 | |||
27741 | int stackSize = keepStackSize(); | ||
27742 | |||
27743 | try { | ||
27744 | // InternalAlloyLanguage.g:9836:1: ( ( ruleALSTerm ) ) | ||
27745 | // InternalAlloyLanguage.g:9837:1: ( ruleALSTerm ) | ||
27746 | { | ||
27747 | // InternalAlloyLanguage.g:9837:1: ( ruleALSTerm ) | ||
27748 | // InternalAlloyLanguage.g:9838:1: ruleALSTerm | ||
27749 | { | ||
27750 | if ( state.backtracking==0 ) { | ||
27751 | before(grammarAccess.getALSPreficedAccess().getExpressionALSTermParserRuleCall_6_5_0()); | ||
27752 | } | ||
27753 | pushFollow(FOLLOW_2); | ||
27754 | ruleALSTerm(); | ||
27755 | |||
27756 | state._fsp--; | ||
27757 | if (state.failed) return ; | ||
27758 | if ( state.backtracking==0 ) { | ||
27759 | after(grammarAccess.getALSPreficedAccess().getExpressionALSTermParserRuleCall_6_5_0()); | ||
27760 | } | ||
27761 | |||
27762 | } | ||
27763 | |||
27764 | |||
27765 | } | ||
27766 | |||
27767 | } | ||
27768 | catch (RecognitionException re) { | ||
27769 | reportError(re); | ||
27770 | recover(input,re); | ||
27771 | } | ||
27772 | finally { | ||
27773 | |||
27774 | restoreStackSize(stackSize); | ||
27775 | |||
27776 | } | ||
27777 | return ; | ||
27778 | } | ||
27779 | // $ANTLR end "rule__ALSPreficed__ExpressionAssignment_6_5" | ||
27780 | |||
27781 | |||
27782 | // $ANTLR start "rule__ALSPreficed__ReferredDefinitionAssignment_7_1_0" | ||
27783 | // InternalAlloyLanguage.g:9847:1: rule__ALSPreficed__ReferredDefinitionAssignment_7_1_0 : ( ( RULE_ID ) ) ; | ||
27784 | public final void rule__ALSPreficed__ReferredDefinitionAssignment_7_1_0() throws RecognitionException { | ||
27785 | |||
27786 | int stackSize = keepStackSize(); | ||
27787 | |||
27788 | try { | ||
27789 | // InternalAlloyLanguage.g:9851:1: ( ( ( RULE_ID ) ) ) | ||
27790 | // InternalAlloyLanguage.g:9852:1: ( ( RULE_ID ) ) | ||
27791 | { | ||
27792 | // InternalAlloyLanguage.g:9852:1: ( ( RULE_ID ) ) | ||
27793 | // InternalAlloyLanguage.g:9853:1: ( RULE_ID ) | ||
27794 | { | ||
27795 | if ( state.backtracking==0 ) { | ||
27796 | before(grammarAccess.getALSPreficedAccess().getReferredDefinitionALSDefinitionCrossReference_7_1_0_0()); | ||
27797 | } | ||
27798 | // InternalAlloyLanguage.g:9854:1: ( RULE_ID ) | ||
27799 | // InternalAlloyLanguage.g:9855:1: RULE_ID | ||
27800 | { | ||
27801 | if ( state.backtracking==0 ) { | ||
27802 | before(grammarAccess.getALSPreficedAccess().getReferredDefinitionALSDefinitionIDTerminalRuleCall_7_1_0_0_1()); | ||
27803 | } | ||
27804 | match(input,RULE_ID,FOLLOW_2); if (state.failed) return ; | ||
27805 | if ( state.backtracking==0 ) { | ||
27806 | after(grammarAccess.getALSPreficedAccess().getReferredDefinitionALSDefinitionIDTerminalRuleCall_7_1_0_0_1()); | ||
27807 | } | ||
27808 | |||
27809 | } | ||
27810 | |||
27811 | if ( state.backtracking==0 ) { | ||
27812 | after(grammarAccess.getALSPreficedAccess().getReferredDefinitionALSDefinitionCrossReference_7_1_0_0()); | ||
27813 | } | ||
27814 | |||
27815 | } | ||
27816 | |||
27817 | |||
27818 | } | ||
27819 | |||
27820 | } | ||
27821 | catch (RecognitionException re) { | ||
27822 | reportError(re); | ||
27823 | recover(input,re); | ||
27824 | } | ||
27825 | finally { | ||
27826 | |||
27827 | restoreStackSize(stackSize); | ||
27828 | |||
27829 | } | ||
27830 | return ; | ||
27831 | } | ||
27832 | // $ANTLR end "rule__ALSPreficed__ReferredDefinitionAssignment_7_1_0" | ||
27833 | |||
27834 | |||
27835 | // $ANTLR start "rule__ALSPreficed__ReferredNumericOperatorAssignment_7_1_1" | ||
27836 | // InternalAlloyLanguage.g:9866:1: rule__ALSPreficed__ReferredNumericOperatorAssignment_7_1_1 : ( ruleALSNumericOperator ) ; | ||
27837 | public final void rule__ALSPreficed__ReferredNumericOperatorAssignment_7_1_1() throws RecognitionException { | ||
27838 | |||
27839 | int stackSize = keepStackSize(); | ||
27840 | |||
27841 | try { | ||
27842 | // InternalAlloyLanguage.g:9870:1: ( ( ruleALSNumericOperator ) ) | ||
27843 | // InternalAlloyLanguage.g:9871:1: ( ruleALSNumericOperator ) | ||
27844 | { | ||
27845 | // InternalAlloyLanguage.g:9871:1: ( ruleALSNumericOperator ) | ||
27846 | // InternalAlloyLanguage.g:9872:1: ruleALSNumericOperator | ||
27847 | { | ||
27848 | if ( state.backtracking==0 ) { | ||
27849 | before(grammarAccess.getALSPreficedAccess().getReferredNumericOperatorALSNumericOperatorEnumRuleCall_7_1_1_0()); | ||
27850 | } | ||
27851 | pushFollow(FOLLOW_2); | ||
27852 | ruleALSNumericOperator(); | ||
27853 | |||
27854 | state._fsp--; | ||
27855 | if (state.failed) return ; | ||
27856 | if ( state.backtracking==0 ) { | ||
27857 | after(grammarAccess.getALSPreficedAccess().getReferredNumericOperatorALSNumericOperatorEnumRuleCall_7_1_1_0()); | ||
27858 | } | ||
27859 | |||
27860 | } | ||
27861 | |||
27862 | |||
27863 | } | ||
27864 | |||
27865 | } | ||
27866 | catch (RecognitionException re) { | ||
27867 | reportError(re); | ||
27868 | recover(input,re); | ||
27869 | } | ||
27870 | finally { | ||
27871 | |||
27872 | restoreStackSize(stackSize); | ||
27873 | |||
27874 | } | ||
27875 | return ; | ||
27876 | } | ||
27877 | // $ANTLR end "rule__ALSPreficed__ReferredNumericOperatorAssignment_7_1_1" | ||
27878 | |||
27879 | |||
27880 | // $ANTLR start "rule__ALSPreficed__ParamsAssignment_7_3" | ||
27881 | // InternalAlloyLanguage.g:9881:1: rule__ALSPreficed__ParamsAssignment_7_3 : ( ruleALSTerm ) ; | ||
27882 | public final void rule__ALSPreficed__ParamsAssignment_7_3() throws RecognitionException { | ||
27883 | |||
27884 | int stackSize = keepStackSize(); | ||
27885 | |||
27886 | try { | ||
27887 | // InternalAlloyLanguage.g:9885:1: ( ( ruleALSTerm ) ) | ||
27888 | // InternalAlloyLanguage.g:9886:1: ( ruleALSTerm ) | ||
27889 | { | ||
27890 | // InternalAlloyLanguage.g:9886:1: ( ruleALSTerm ) | ||
27891 | // InternalAlloyLanguage.g:9887:1: ruleALSTerm | ||
27892 | { | ||
27893 | if ( state.backtracking==0 ) { | ||
27894 | before(grammarAccess.getALSPreficedAccess().getParamsALSTermParserRuleCall_7_3_0()); | ||
27895 | } | ||
27896 | pushFollow(FOLLOW_2); | ||
27897 | ruleALSTerm(); | ||
27898 | |||
27899 | state._fsp--; | ||
27900 | if (state.failed) return ; | ||
27901 | if ( state.backtracking==0 ) { | ||
27902 | after(grammarAccess.getALSPreficedAccess().getParamsALSTermParserRuleCall_7_3_0()); | ||
27903 | } | ||
27904 | |||
27905 | } | ||
27906 | |||
27907 | |||
27908 | } | ||
27909 | |||
27910 | } | ||
27911 | catch (RecognitionException re) { | ||
27912 | reportError(re); | ||
27913 | recover(input,re); | ||
27914 | } | ||
27915 | finally { | ||
27916 | |||
27917 | restoreStackSize(stackSize); | ||
27918 | |||
27919 | } | ||
27920 | return ; | ||
27921 | } | ||
27922 | // $ANTLR end "rule__ALSPreficed__ParamsAssignment_7_3" | ||
27923 | |||
27924 | |||
27925 | // $ANTLR start "rule__ALSPreficed__ParamsAssignment_7_4_1" | ||
27926 | // InternalAlloyLanguage.g:9896:1: rule__ALSPreficed__ParamsAssignment_7_4_1 : ( ruleALSTerm ) ; | ||
27927 | public final void rule__ALSPreficed__ParamsAssignment_7_4_1() throws RecognitionException { | ||
27928 | |||
27929 | int stackSize = keepStackSize(); | ||
27930 | |||
27931 | try { | ||
27932 | // InternalAlloyLanguage.g:9900:1: ( ( ruleALSTerm ) ) | ||
27933 | // InternalAlloyLanguage.g:9901:1: ( ruleALSTerm ) | ||
27934 | { | ||
27935 | // InternalAlloyLanguage.g:9901:1: ( ruleALSTerm ) | ||
27936 | // InternalAlloyLanguage.g:9902:1: ruleALSTerm | ||
27937 | { | ||
27938 | if ( state.backtracking==0 ) { | ||
27939 | before(grammarAccess.getALSPreficedAccess().getParamsALSTermParserRuleCall_7_4_1_0()); | ||
27940 | } | ||
27941 | pushFollow(FOLLOW_2); | ||
27942 | ruleALSTerm(); | ||
27943 | |||
27944 | state._fsp--; | ||
27945 | if (state.failed) return ; | ||
27946 | if ( state.backtracking==0 ) { | ||
27947 | after(grammarAccess.getALSPreficedAccess().getParamsALSTermParserRuleCall_7_4_1_0()); | ||
27948 | } | ||
27949 | |||
27950 | } | ||
27951 | |||
27952 | |||
27953 | } | ||
27954 | |||
27955 | } | ||
27956 | catch (RecognitionException re) { | ||
27957 | reportError(re); | ||
27958 | recover(input,re); | ||
27959 | } | ||
27960 | finally { | ||
27961 | |||
27962 | restoreStackSize(stackSize); | ||
27963 | |||
27964 | } | ||
27965 | return ; | ||
27966 | } | ||
27967 | // $ANTLR end "rule__ALSPreficed__ParamsAssignment_7_4_1" | ||
27968 | |||
27969 | |||
27970 | // $ANTLR start "rule__ALSVariableDeclaration__NameAssignment_0" | ||
27971 | // InternalAlloyLanguage.g:9911:1: rule__ALSVariableDeclaration__NameAssignment_0 : ( ruleALSID ) ; | ||
27972 | public final void rule__ALSVariableDeclaration__NameAssignment_0() throws RecognitionException { | ||
27973 | |||
27974 | int stackSize = keepStackSize(); | ||
27975 | |||
27976 | try { | ||
27977 | // InternalAlloyLanguage.g:9915:1: ( ( ruleALSID ) ) | ||
27978 | // InternalAlloyLanguage.g:9916:1: ( ruleALSID ) | ||
27979 | { | ||
27980 | // InternalAlloyLanguage.g:9916:1: ( ruleALSID ) | ||
27981 | // InternalAlloyLanguage.g:9917:1: ruleALSID | ||
27982 | { | ||
27983 | if ( state.backtracking==0 ) { | ||
27984 | before(grammarAccess.getALSVariableDeclarationAccess().getNameALSIDParserRuleCall_0_0()); | ||
27985 | } | ||
27986 | pushFollow(FOLLOW_2); | ||
27987 | ruleALSID(); | ||
27988 | |||
27989 | state._fsp--; | ||
27990 | if (state.failed) return ; | ||
27991 | if ( state.backtracking==0 ) { | ||
27992 | after(grammarAccess.getALSVariableDeclarationAccess().getNameALSIDParserRuleCall_0_0()); | ||
27993 | } | ||
27994 | |||
27995 | } | ||
27996 | |||
27997 | |||
27998 | } | ||
27999 | |||
28000 | } | ||
28001 | catch (RecognitionException re) { | ||
28002 | reportError(re); | ||
28003 | recover(input,re); | ||
28004 | } | ||
28005 | finally { | ||
28006 | |||
28007 | restoreStackSize(stackSize); | ||
28008 | |||
28009 | } | ||
28010 | return ; | ||
28011 | } | ||
28012 | // $ANTLR end "rule__ALSVariableDeclaration__NameAssignment_0" | ||
28013 | |||
28014 | |||
28015 | // $ANTLR start "rule__ALSVariableDeclaration__RangeAssignment_2" | ||
28016 | // InternalAlloyLanguage.g:9926:1: rule__ALSVariableDeclaration__RangeAssignment_2 : ( ruleALSTerm ) ; | ||
28017 | public final void rule__ALSVariableDeclaration__RangeAssignment_2() throws RecognitionException { | ||
28018 | |||
28019 | int stackSize = keepStackSize(); | ||
28020 | |||
28021 | try { | ||
28022 | // InternalAlloyLanguage.g:9930:1: ( ( ruleALSTerm ) ) | ||
28023 | // InternalAlloyLanguage.g:9931:1: ( ruleALSTerm ) | ||
28024 | { | ||
28025 | // InternalAlloyLanguage.g:9931:1: ( ruleALSTerm ) | ||
28026 | // InternalAlloyLanguage.g:9932:1: ruleALSTerm | ||
28027 | { | ||
28028 | if ( state.backtracking==0 ) { | ||
28029 | before(grammarAccess.getALSVariableDeclarationAccess().getRangeALSTermParserRuleCall_2_0()); | ||
28030 | } | ||
28031 | pushFollow(FOLLOW_2); | ||
28032 | ruleALSTerm(); | ||
28033 | |||
28034 | state._fsp--; | ||
28035 | if (state.failed) return ; | ||
28036 | if ( state.backtracking==0 ) { | ||
28037 | after(grammarAccess.getALSVariableDeclarationAccess().getRangeALSTermParserRuleCall_2_0()); | ||
28038 | } | ||
28039 | |||
28040 | } | ||
28041 | |||
28042 | |||
28043 | } | ||
28044 | |||
28045 | } | ||
28046 | catch (RecognitionException re) { | ||
28047 | reportError(re); | ||
28048 | recover(input,re); | ||
28049 | } | ||
28050 | finally { | ||
28051 | |||
28052 | restoreStackSize(stackSize); | ||
28053 | |||
28054 | } | ||
28055 | return ; | ||
28056 | } | ||
28057 | // $ANTLR end "rule__ALSVariableDeclaration__RangeAssignment_2" | ||
28058 | |||
28059 | |||
28060 | // $ANTLR start "rule__ALSBasicRelationTerm__ReferredAssignment_4_1" | ||
28061 | // InternalAlloyLanguage.g:9941:1: rule__ALSBasicRelationTerm__ReferredAssignment_4_1 : ( ( RULE_ID ) ) ; | ||
28062 | public final void rule__ALSBasicRelationTerm__ReferredAssignment_4_1() throws RecognitionException { | ||
28063 | |||
28064 | int stackSize = keepStackSize(); | ||
28065 | |||
28066 | try { | ||
28067 | // InternalAlloyLanguage.g:9945:1: ( ( ( RULE_ID ) ) ) | ||
28068 | // InternalAlloyLanguage.g:9946:1: ( ( RULE_ID ) ) | ||
28069 | { | ||
28070 | // InternalAlloyLanguage.g:9946:1: ( ( RULE_ID ) ) | ||
28071 | // InternalAlloyLanguage.g:9947:1: ( RULE_ID ) | ||
28072 | { | ||
28073 | if ( state.backtracking==0 ) { | ||
28074 | before(grammarAccess.getALSBasicRelationTermAccess().getReferredALSRelationDeclarationCrossReference_4_1_0()); | ||
28075 | } | ||
28076 | // InternalAlloyLanguage.g:9948:1: ( RULE_ID ) | ||
28077 | // InternalAlloyLanguage.g:9949:1: RULE_ID | ||
28078 | { | ||
28079 | if ( state.backtracking==0 ) { | ||
28080 | before(grammarAccess.getALSBasicRelationTermAccess().getReferredALSRelationDeclarationIDTerminalRuleCall_4_1_0_1()); | ||
28081 | } | ||
28082 | match(input,RULE_ID,FOLLOW_2); if (state.failed) return ; | ||
28083 | if ( state.backtracking==0 ) { | ||
28084 | after(grammarAccess.getALSBasicRelationTermAccess().getReferredALSRelationDeclarationIDTerminalRuleCall_4_1_0_1()); | ||
28085 | } | ||
28086 | |||
28087 | } | ||
28088 | |||
28089 | if ( state.backtracking==0 ) { | ||
28090 | after(grammarAccess.getALSBasicRelationTermAccess().getReferredALSRelationDeclarationCrossReference_4_1_0()); | ||
28091 | } | ||
28092 | |||
28093 | } | ||
28094 | |||
28095 | |||
28096 | } | ||
28097 | |||
28098 | } | ||
28099 | catch (RecognitionException re) { | ||
28100 | reportError(re); | ||
28101 | recover(input,re); | ||
28102 | } | ||
28103 | finally { | ||
28104 | |||
28105 | restoreStackSize(stackSize); | ||
28106 | |||
28107 | } | ||
28108 | return ; | ||
28109 | } | ||
28110 | // $ANTLR end "rule__ALSBasicRelationTerm__ReferredAssignment_4_1" | ||
28111 | |||
28112 | |||
28113 | // $ANTLR start "rule__ALSBasicRelationTerm__ValueAssignment_5_1" | ||
28114 | // InternalAlloyLanguage.g:9960:1: rule__ALSBasicRelationTerm__ValueAssignment_5_1 : ( RULE_INT ) ; | ||
28115 | public final void rule__ALSBasicRelationTerm__ValueAssignment_5_1() throws RecognitionException { | ||
28116 | |||
28117 | int stackSize = keepStackSize(); | ||
28118 | |||
28119 | try { | ||
28120 | // InternalAlloyLanguage.g:9964:1: ( ( RULE_INT ) ) | ||
28121 | // InternalAlloyLanguage.g:9965:1: ( RULE_INT ) | ||
28122 | { | ||
28123 | // InternalAlloyLanguage.g:9965:1: ( RULE_INT ) | ||
28124 | // InternalAlloyLanguage.g:9966:1: RULE_INT | ||
28125 | { | ||
28126 | if ( state.backtracking==0 ) { | ||
28127 | before(grammarAccess.getALSBasicRelationTermAccess().getValueINTTerminalRuleCall_5_1_0()); | ||
28128 | } | ||
28129 | match(input,RULE_INT,FOLLOW_2); if (state.failed) return ; | ||
28130 | if ( state.backtracking==0 ) { | ||
28131 | after(grammarAccess.getALSBasicRelationTermAccess().getValueINTTerminalRuleCall_5_1_0()); | ||
28132 | } | ||
28133 | |||
28134 | } | ||
28135 | |||
28136 | |||
28137 | } | ||
28138 | |||
28139 | } | ||
28140 | catch (RecognitionException re) { | ||
28141 | reportError(re); | ||
28142 | recover(input,re); | ||
28143 | } | ||
28144 | finally { | ||
28145 | |||
28146 | restoreStackSize(stackSize); | ||
28147 | |||
28148 | } | ||
28149 | return ; | ||
28150 | } | ||
28151 | // $ANTLR end "rule__ALSBasicRelationTerm__ValueAssignment_5_1" | ||
28152 | |||
28153 | |||
28154 | // $ANTLR start "rule__ALSRunCommand__TypeScopesAssignment_4_1" | ||
28155 | // InternalAlloyLanguage.g:9975:1: rule__ALSRunCommand__TypeScopesAssignment_4_1 : ( ruleALSTypeScope ) ; | ||
28156 | public final void rule__ALSRunCommand__TypeScopesAssignment_4_1() throws RecognitionException { | ||
28157 | |||
28158 | int stackSize = keepStackSize(); | ||
28159 | |||
28160 | try { | ||
28161 | // InternalAlloyLanguage.g:9979:1: ( ( ruleALSTypeScope ) ) | ||
28162 | // InternalAlloyLanguage.g:9980:1: ( ruleALSTypeScope ) | ||
28163 | { | ||
28164 | // InternalAlloyLanguage.g:9980:1: ( ruleALSTypeScope ) | ||
28165 | // InternalAlloyLanguage.g:9981:1: ruleALSTypeScope | ||
28166 | { | ||
28167 | if ( state.backtracking==0 ) { | ||
28168 | before(grammarAccess.getALSRunCommandAccess().getTypeScopesALSTypeScopeParserRuleCall_4_1_0()); | ||
28169 | } | ||
28170 | pushFollow(FOLLOW_2); | ||
28171 | ruleALSTypeScope(); | ||
28172 | |||
28173 | state._fsp--; | ||
28174 | if (state.failed) return ; | ||
28175 | if ( state.backtracking==0 ) { | ||
28176 | after(grammarAccess.getALSRunCommandAccess().getTypeScopesALSTypeScopeParserRuleCall_4_1_0()); | ||
28177 | } | ||
28178 | |||
28179 | } | ||
28180 | |||
28181 | |||
28182 | } | ||
28183 | |||
28184 | } | ||
28185 | catch (RecognitionException re) { | ||
28186 | reportError(re); | ||
28187 | recover(input,re); | ||
28188 | } | ||
28189 | finally { | ||
28190 | |||
28191 | restoreStackSize(stackSize); | ||
28192 | |||
28193 | } | ||
28194 | return ; | ||
28195 | } | ||
28196 | // $ANTLR end "rule__ALSRunCommand__TypeScopesAssignment_4_1" | ||
28197 | |||
28198 | |||
28199 | // $ANTLR start "rule__ALSRunCommand__TypeScopesAssignment_4_2_1" | ||
28200 | // InternalAlloyLanguage.g:9990:1: rule__ALSRunCommand__TypeScopesAssignment_4_2_1 : ( ruleALSTypeScope ) ; | ||
28201 | public final void rule__ALSRunCommand__TypeScopesAssignment_4_2_1() throws RecognitionException { | ||
28202 | |||
28203 | int stackSize = keepStackSize(); | ||
28204 | |||
28205 | try { | ||
28206 | // InternalAlloyLanguage.g:9994:1: ( ( ruleALSTypeScope ) ) | ||
28207 | // InternalAlloyLanguage.g:9995:1: ( ruleALSTypeScope ) | ||
28208 | { | ||
28209 | // InternalAlloyLanguage.g:9995:1: ( ruleALSTypeScope ) | ||
28210 | // InternalAlloyLanguage.g:9996:1: ruleALSTypeScope | ||
28211 | { | ||
28212 | if ( state.backtracking==0 ) { | ||
28213 | before(grammarAccess.getALSRunCommandAccess().getTypeScopesALSTypeScopeParserRuleCall_4_2_1_0()); | ||
28214 | } | ||
28215 | pushFollow(FOLLOW_2); | ||
28216 | ruleALSTypeScope(); | ||
28217 | |||
28218 | state._fsp--; | ||
28219 | if (state.failed) return ; | ||
28220 | if ( state.backtracking==0 ) { | ||
28221 | after(grammarAccess.getALSRunCommandAccess().getTypeScopesALSTypeScopeParserRuleCall_4_2_1_0()); | ||
28222 | } | ||
28223 | |||
28224 | } | ||
28225 | |||
28226 | |||
28227 | } | ||
28228 | |||
28229 | } | ||
28230 | catch (RecognitionException re) { | ||
28231 | reportError(re); | ||
28232 | recover(input,re); | ||
28233 | } | ||
28234 | finally { | ||
28235 | |||
28236 | restoreStackSize(stackSize); | ||
28237 | |||
28238 | } | ||
28239 | return ; | ||
28240 | } | ||
28241 | // $ANTLR end "rule__ALSRunCommand__TypeScopesAssignment_4_2_1" | ||
28242 | |||
28243 | |||
28244 | // $ANTLR start "rule__ALSSigScope__ExactlyAssignment_0" | ||
28245 | // InternalAlloyLanguage.g:10005:1: rule__ALSSigScope__ExactlyAssignment_0 : ( ( 'exactly' ) ) ; | ||
28246 | public final void rule__ALSSigScope__ExactlyAssignment_0() throws RecognitionException { | ||
28247 | |||
28248 | int stackSize = keepStackSize(); | ||
28249 | |||
28250 | try { | ||
28251 | // InternalAlloyLanguage.g:10009:1: ( ( ( 'exactly' ) ) ) | ||
28252 | // InternalAlloyLanguage.g:10010:1: ( ( 'exactly' ) ) | ||
28253 | { | ||
28254 | // InternalAlloyLanguage.g:10010:1: ( ( 'exactly' ) ) | ||
28255 | // InternalAlloyLanguage.g:10011:1: ( 'exactly' ) | ||
28256 | { | ||
28257 | if ( state.backtracking==0 ) { | ||
28258 | before(grammarAccess.getALSSigScopeAccess().getExactlyExactlyKeyword_0_0()); | ||
28259 | } | ||
28260 | // InternalAlloyLanguage.g:10012:1: ( 'exactly' ) | ||
28261 | // InternalAlloyLanguage.g:10013:1: 'exactly' | ||
28262 | { | ||
28263 | if ( state.backtracking==0 ) { | ||
28264 | before(grammarAccess.getALSSigScopeAccess().getExactlyExactlyKeyword_0_0()); | ||
28265 | } | ||
28266 | match(input,75,FOLLOW_2); if (state.failed) return ; | ||
28267 | if ( state.backtracking==0 ) { | ||
28268 | after(grammarAccess.getALSSigScopeAccess().getExactlyExactlyKeyword_0_0()); | ||
28269 | } | ||
28270 | |||
28271 | } | ||
28272 | |||
28273 | if ( state.backtracking==0 ) { | ||
28274 | after(grammarAccess.getALSSigScopeAccess().getExactlyExactlyKeyword_0_0()); | ||
28275 | } | ||
28276 | |||
28277 | } | ||
28278 | |||
28279 | |||
28280 | } | ||
28281 | |||
28282 | } | ||
28283 | catch (RecognitionException re) { | ||
28284 | reportError(re); | ||
28285 | recover(input,re); | ||
28286 | } | ||
28287 | finally { | ||
28288 | |||
28289 | restoreStackSize(stackSize); | ||
28290 | |||
28291 | } | ||
28292 | return ; | ||
28293 | } | ||
28294 | // $ANTLR end "rule__ALSSigScope__ExactlyAssignment_0" | ||
28295 | |||
28296 | |||
28297 | // $ANTLR start "rule__ALSSigScope__NumberAssignment_1" | ||
28298 | // InternalAlloyLanguage.g:10028:1: rule__ALSSigScope__NumberAssignment_1 : ( RULE_INT ) ; | ||
28299 | public final void rule__ALSSigScope__NumberAssignment_1() throws RecognitionException { | ||
28300 | |||
28301 | int stackSize = keepStackSize(); | ||
28302 | |||
28303 | try { | ||
28304 | // InternalAlloyLanguage.g:10032:1: ( ( RULE_INT ) ) | ||
28305 | // InternalAlloyLanguage.g:10033:1: ( RULE_INT ) | ||
28306 | { | ||
28307 | // InternalAlloyLanguage.g:10033:1: ( RULE_INT ) | ||
28308 | // InternalAlloyLanguage.g:10034:1: RULE_INT | ||
28309 | { | ||
28310 | if ( state.backtracking==0 ) { | ||
28311 | before(grammarAccess.getALSSigScopeAccess().getNumberINTTerminalRuleCall_1_0()); | ||
28312 | } | ||
28313 | match(input,RULE_INT,FOLLOW_2); if (state.failed) return ; | ||
28314 | if ( state.backtracking==0 ) { | ||
28315 | after(grammarAccess.getALSSigScopeAccess().getNumberINTTerminalRuleCall_1_0()); | ||
28316 | } | ||
28317 | |||
28318 | } | ||
28319 | |||
28320 | |||
28321 | } | ||
28322 | |||
28323 | } | ||
28324 | catch (RecognitionException re) { | ||
28325 | reportError(re); | ||
28326 | recover(input,re); | ||
28327 | } | ||
28328 | finally { | ||
28329 | |||
28330 | restoreStackSize(stackSize); | ||
28331 | |||
28332 | } | ||
28333 | return ; | ||
28334 | } | ||
28335 | // $ANTLR end "rule__ALSSigScope__NumberAssignment_1" | ||
28336 | |||
28337 | |||
28338 | // $ANTLR start "rule__ALSSigScope__TypeAssignment_2" | ||
28339 | // InternalAlloyLanguage.g:10043:1: rule__ALSSigScope__TypeAssignment_2 : ( ( RULE_ID ) ) ; | ||
28340 | public final void rule__ALSSigScope__TypeAssignment_2() throws RecognitionException { | ||
28341 | |||
28342 | int stackSize = keepStackSize(); | ||
28343 | |||
28344 | try { | ||
28345 | // InternalAlloyLanguage.g:10047:1: ( ( ( RULE_ID ) ) ) | ||
28346 | // InternalAlloyLanguage.g:10048:1: ( ( RULE_ID ) ) | ||
28347 | { | ||
28348 | // InternalAlloyLanguage.g:10048:1: ( ( RULE_ID ) ) | ||
28349 | // InternalAlloyLanguage.g:10049:1: ( RULE_ID ) | ||
28350 | { | ||
28351 | if ( state.backtracking==0 ) { | ||
28352 | before(grammarAccess.getALSSigScopeAccess().getTypeALSSignatureDeclarationCrossReference_2_0()); | ||
28353 | } | ||
28354 | // InternalAlloyLanguage.g:10050:1: ( RULE_ID ) | ||
28355 | // InternalAlloyLanguage.g:10051:1: RULE_ID | ||
28356 | { | ||
28357 | if ( state.backtracking==0 ) { | ||
28358 | before(grammarAccess.getALSSigScopeAccess().getTypeALSSignatureDeclarationIDTerminalRuleCall_2_0_1()); | ||
28359 | } | ||
28360 | match(input,RULE_ID,FOLLOW_2); if (state.failed) return ; | ||
28361 | if ( state.backtracking==0 ) { | ||
28362 | after(grammarAccess.getALSSigScopeAccess().getTypeALSSignatureDeclarationIDTerminalRuleCall_2_0_1()); | ||
28363 | } | ||
28364 | |||
28365 | } | ||
28366 | |||
28367 | if ( state.backtracking==0 ) { | ||
28368 | after(grammarAccess.getALSSigScopeAccess().getTypeALSSignatureDeclarationCrossReference_2_0()); | ||
28369 | } | ||
28370 | |||
28371 | } | ||
28372 | |||
28373 | |||
28374 | } | ||
28375 | |||
28376 | } | ||
28377 | catch (RecognitionException re) { | ||
28378 | reportError(re); | ||
28379 | recover(input,re); | ||
28380 | } | ||
28381 | finally { | ||
28382 | |||
28383 | restoreStackSize(stackSize); | ||
28384 | |||
28385 | } | ||
28386 | return ; | ||
28387 | } | ||
28388 | // $ANTLR end "rule__ALSSigScope__TypeAssignment_2" | ||
28389 | |||
28390 | |||
28391 | // $ANTLR start "rule__ALSIntScope__NumberAssignment_0" | ||
28392 | // InternalAlloyLanguage.g:10062:1: rule__ALSIntScope__NumberAssignment_0 : ( RULE_INT ) ; | ||
28393 | public final void rule__ALSIntScope__NumberAssignment_0() throws RecognitionException { | ||
28394 | |||
28395 | int stackSize = keepStackSize(); | ||
28396 | |||
28397 | try { | ||
28398 | // InternalAlloyLanguage.g:10066:1: ( ( RULE_INT ) ) | ||
28399 | // InternalAlloyLanguage.g:10067:1: ( RULE_INT ) | ||
28400 | { | ||
28401 | // InternalAlloyLanguage.g:10067:1: ( RULE_INT ) | ||
28402 | // InternalAlloyLanguage.g:10068:1: RULE_INT | ||
28403 | { | ||
28404 | if ( state.backtracking==0 ) { | ||
28405 | before(grammarAccess.getALSIntScopeAccess().getNumberINTTerminalRuleCall_0_0()); | ||
28406 | } | ||
28407 | match(input,RULE_INT,FOLLOW_2); if (state.failed) return ; | ||
28408 | if ( state.backtracking==0 ) { | ||
28409 | after(grammarAccess.getALSIntScopeAccess().getNumberINTTerminalRuleCall_0_0()); | ||
28410 | } | ||
28411 | |||
28412 | } | ||
28413 | |||
28414 | |||
28415 | } | ||
28416 | |||
28417 | } | ||
28418 | catch (RecognitionException re) { | ||
28419 | reportError(re); | ||
28420 | recover(input,re); | ||
28421 | } | ||
28422 | finally { | ||
28423 | |||
28424 | restoreStackSize(stackSize); | ||
28425 | |||
28426 | } | ||
28427 | return ; | ||
28428 | } | ||
28429 | // $ANTLR end "rule__ALSIntScope__NumberAssignment_0" | ||
28430 | |||
28431 | // $ANTLR start synpred78_InternalAlloyLanguage | ||
28432 | public final void synpred78_InternalAlloyLanguage_fragment() throws RecognitionException { | ||
28433 | // InternalAlloyLanguage.g:8769:2: ( rule__ALSSignatureBody__UnorderedGroup_0__0 ) | ||
28434 | // InternalAlloyLanguage.g:8769:2: rule__ALSSignatureBody__UnorderedGroup_0__0 | ||
28435 | { | ||
28436 | pushFollow(FOLLOW_2); | ||
28437 | rule__ALSSignatureBody__UnorderedGroup_0__0(); | ||
28438 | |||
28439 | state._fsp--; | ||
28440 | if (state.failed) return ; | ||
28441 | |||
28442 | } | ||
28443 | } | ||
28444 | // $ANTLR end synpred78_InternalAlloyLanguage | ||
28445 | |||
28446 | // $ANTLR start synpred79_InternalAlloyLanguage | ||
28447 | public final void synpred79_InternalAlloyLanguage_fragment() throws RecognitionException { | ||
28448 | // InternalAlloyLanguage.g:8787:4: ( ({...}? => ( ( ( rule__ALSSignatureBody__MultiplicityAssignment_0_0 ) ) ) ) ) | ||
28449 | // InternalAlloyLanguage.g:8787:4: ({...}? => ( ( ( rule__ALSSignatureBody__MultiplicityAssignment_0_0 ) ) ) ) | ||
28450 | { | ||
28451 | // InternalAlloyLanguage.g:8787:4: ({...}? => ( ( ( rule__ALSSignatureBody__MultiplicityAssignment_0_0 ) ) ) ) | ||
28452 | // InternalAlloyLanguage.g:8788:5: {...}? => ( ( ( rule__ALSSignatureBody__MultiplicityAssignment_0_0 ) ) ) | ||
28453 | { | ||
28454 | if ( ! getUnorderedGroupHelper().canSelect(grammarAccess.getALSSignatureBodyAccess().getUnorderedGroup_0(), 0) ) { | ||
28455 | if (state.backtracking>0) {state.failed=true; return ;} | ||
28456 | throw new FailedPredicateException(input, "synpred79_InternalAlloyLanguage", "getUnorderedGroupHelper().canSelect(grammarAccess.getALSSignatureBodyAccess().getUnorderedGroup_0(), 0)"); | ||
28457 | } | ||
28458 | // InternalAlloyLanguage.g:8788:113: ( ( ( rule__ALSSignatureBody__MultiplicityAssignment_0_0 ) ) ) | ||
28459 | // InternalAlloyLanguage.g:8789:6: ( ( rule__ALSSignatureBody__MultiplicityAssignment_0_0 ) ) | ||
28460 | { | ||
28461 | getUnorderedGroupHelper().select(grammarAccess.getALSSignatureBodyAccess().getUnorderedGroup_0(), 0); | ||
28462 | // InternalAlloyLanguage.g:8795:6: ( ( rule__ALSSignatureBody__MultiplicityAssignment_0_0 ) ) | ||
28463 | // InternalAlloyLanguage.g:8797:7: ( rule__ALSSignatureBody__MultiplicityAssignment_0_0 ) | ||
28464 | { | ||
28465 | if ( state.backtracking==0 ) { | ||
28466 | before(grammarAccess.getALSSignatureBodyAccess().getMultiplicityAssignment_0_0()); | ||
28467 | } | ||
28468 | // InternalAlloyLanguage.g:8798:7: ( rule__ALSSignatureBody__MultiplicityAssignment_0_0 ) | ||
28469 | // InternalAlloyLanguage.g:8798:8: rule__ALSSignatureBody__MultiplicityAssignment_0_0 | ||
28470 | { | ||
28471 | pushFollow(FOLLOW_2); | ||
28472 | rule__ALSSignatureBody__MultiplicityAssignment_0_0(); | ||
28473 | |||
28474 | state._fsp--; | ||
28475 | if (state.failed) return ; | ||
28476 | |||
28477 | } | ||
28478 | |||
28479 | |||
28480 | } | ||
28481 | |||
28482 | |||
28483 | } | ||
28484 | |||
28485 | |||
28486 | } | ||
28487 | |||
28488 | |||
28489 | } | ||
28490 | } | ||
28491 | // $ANTLR end synpred79_InternalAlloyLanguage | ||
28492 | |||
28493 | // $ANTLR start synpred80_InternalAlloyLanguage | ||
28494 | public final void synpred80_InternalAlloyLanguage_fragment() throws RecognitionException { | ||
28495 | // InternalAlloyLanguage.g:8836:2: ( rule__ALSSignatureBody__UnorderedGroup_0__1 ) | ||
28496 | // InternalAlloyLanguage.g:8836:2: rule__ALSSignatureBody__UnorderedGroup_0__1 | ||
28497 | { | ||
28498 | pushFollow(FOLLOW_2); | ||
28499 | rule__ALSSignatureBody__UnorderedGroup_0__1(); | ||
28500 | |||
28501 | state._fsp--; | ||
28502 | if (state.failed) return ; | ||
28503 | |||
28504 | } | ||
28505 | } | ||
28506 | // $ANTLR end synpred80_InternalAlloyLanguage | ||
28507 | |||
28508 | // Delegated rules | ||
28509 | |||
28510 | public final boolean synpred80_InternalAlloyLanguage() { | ||
28511 | state.backtracking++; | ||
28512 | int start = input.mark(); | ||
28513 | try { | ||
28514 | synpred80_InternalAlloyLanguage_fragment(); // can never throw exception | ||
28515 | } catch (RecognitionException re) { | ||
28516 | System.err.println("impossible: "+re); | ||
28517 | } | ||
28518 | boolean success = !state.failed; | ||
28519 | input.rewind(start); | ||
28520 | state.backtracking--; | ||
28521 | state.failed=false; | ||
28522 | return success; | ||
28523 | } | ||
28524 | public final boolean synpred78_InternalAlloyLanguage() { | ||
28525 | state.backtracking++; | ||
28526 | int start = input.mark(); | ||
28527 | try { | ||
28528 | synpred78_InternalAlloyLanguage_fragment(); // can never throw exception | ||
28529 | } catch (RecognitionException re) { | ||
28530 | System.err.println("impossible: "+re); | ||
28531 | } | ||
28532 | boolean success = !state.failed; | ||
28533 | input.rewind(start); | ||
28534 | state.backtracking--; | ||
28535 | state.failed=false; | ||
28536 | return success; | ||
28537 | } | ||
28538 | public final boolean synpred79_InternalAlloyLanguage() { | ||
28539 | state.backtracking++; | ||
28540 | int start = input.mark(); | ||
28541 | try { | ||
28542 | synpred79_InternalAlloyLanguage_fragment(); // can never throw exception | ||
28543 | } catch (RecognitionException re) { | ||
28544 | System.err.println("impossible: "+re); | ||
28545 | } | ||
28546 | boolean success = !state.failed; | ||
28547 | input.rewind(start); | ||
28548 | state.backtracking--; | ||
28549 | state.failed=false; | ||
28550 | return success; | ||
28551 | } | ||
28552 | |||
28553 | |||
28554 | protected DFA10 dfa10 = new DFA10(this); | ||
28555 | protected DFA24 dfa24 = new DFA24(this); | ||
28556 | static final String dfa_1s = "\13\uffff"; | ||
28557 | static final String dfa_2s = "\10\uffff\1\12\2\uffff"; | ||
28558 | static final String dfa_3s = "\1\4\7\uffff\1\13\2\uffff"; | ||
28559 | static final String dfa_4s = "\1\105\7\uffff\1\106\2\uffff"; | ||
28560 | 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"; | ||
28561 | static final String dfa_6s = "\13\uffff}>"; | ||
28562 | static final String[] dfa_7s = { | ||
28563 | "\1\10\1\12\15\uffff\2\1\6\uffff\5\11\31\uffff\1\6\2\uffff\1\2\1\3\1\4\1\5\1\7\5\12", | ||
28564 | "", | ||
28565 | "", | ||
28566 | "", | ||
28567 | "", | ||
28568 | "", | ||
28569 | "", | ||
28570 | "", | ||
28571 | "\10\12\2\uffff\6\12\6\uffff\3\12\2\uffff\2\12\2\uffff\1\11\1\12\2\uffff\16\12\12\uffff\1\12", | ||
28572 | "", | ||
28573 | "" | ||
28574 | }; | ||
28575 | |||
28576 | static final short[] dfa_1 = DFA.unpackEncodedString(dfa_1s); | ||
28577 | static final short[] dfa_2 = DFA.unpackEncodedString(dfa_2s); | ||
28578 | static final char[] dfa_3 = DFA.unpackEncodedStringToUnsignedChars(dfa_3s); | ||
28579 | static final char[] dfa_4 = DFA.unpackEncodedStringToUnsignedChars(dfa_4s); | ||
28580 | static final short[] dfa_5 = DFA.unpackEncodedString(dfa_5s); | ||
28581 | static final short[] dfa_6 = DFA.unpackEncodedString(dfa_6s); | ||
28582 | static final short[][] dfa_7 = unpackEncodedStringArray(dfa_7s); | ||
28583 | |||
28584 | class DFA10 extends DFA { | ||
28585 | |||
28586 | public DFA10(BaseRecognizer recognizer) { | ||
28587 | this.recognizer = recognizer; | ||
28588 | this.decisionNumber = 10; | ||
28589 | this.eot = dfa_1; | ||
28590 | this.eof = dfa_2; | ||
28591 | this.min = dfa_3; | ||
28592 | this.max = dfa_4; | ||
28593 | this.accept = dfa_5; | ||
28594 | this.special = dfa_6; | ||
28595 | this.transition = dfa_7; | ||
28596 | } | ||
28597 | public String getDescription() { | ||
28598 | return "1291: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 ) );"; | ||
28599 | } | ||
28600 | } | ||
28601 | static final String dfa_8s = "\12\uffff"; | ||
28602 | static final String dfa_9s = "\10\uffff\1\11\1\uffff"; | ||
28603 | static final String dfa_10s = "\7\4\1\uffff\1\13\1\uffff"; | ||
28604 | static final String dfa_11s = "\1\105\6\112\1\uffff\1\73\1\uffff"; | ||
28605 | static final String dfa_12s = "\7\uffff\1\2\1\uffff\1\1"; | ||
28606 | static final String dfa_13s = "\12\uffff}>"; | ||
28607 | static final String[] dfa_14s = { | ||
28608 | "\2\7\15\uffff\2\7\1\1\1\2\1\3\1\4\1\5\1\6\5\7\31\uffff\1\7\2\uffff\12\7", | ||
28609 | "\1\10\1\11\15\uffff\15\11\31\uffff\1\11\2\uffff\12\11\4\uffff\1\7", | ||
28610 | "\1\10\1\11\15\uffff\15\11\31\uffff\1\11\2\uffff\12\11\4\uffff\1\7", | ||
28611 | "\1\10\1\11\15\uffff\15\11\31\uffff\1\11\2\uffff\12\11\4\uffff\1\7", | ||
28612 | "\1\10\1\11\15\uffff\15\11\31\uffff\1\11\2\uffff\12\11\4\uffff\1\7", | ||
28613 | "\1\10\1\11\15\uffff\15\11\31\uffff\1\11\2\uffff\12\11\4\uffff\1\7", | ||
28614 | "\1\10\1\11\15\uffff\15\11\31\uffff\1\11\2\uffff\12\11\4\uffff\1\7", | ||
28615 | "", | ||
28616 | "\10\11\2\uffff\6\11\7\uffff\2\11\2\uffff\2\11\1\7\1\uffff\1\11\4\uffff\15\11", | ||
28617 | "" | ||
28618 | }; | ||
28619 | |||
28620 | static final short[] dfa_8 = DFA.unpackEncodedString(dfa_8s); | ||
28621 | static final short[] dfa_9 = DFA.unpackEncodedString(dfa_9s); | ||
28622 | static final char[] dfa_10 = DFA.unpackEncodedStringToUnsignedChars(dfa_10s); | ||
28623 | static final char[] dfa_11 = DFA.unpackEncodedStringToUnsignedChars(dfa_11s); | ||
28624 | static final short[] dfa_12 = DFA.unpackEncodedString(dfa_12s); | ||
28625 | static final short[] dfa_13 = DFA.unpackEncodedString(dfa_13s); | ||
28626 | static final short[][] dfa_14 = unpackEncodedStringArray(dfa_14s); | ||
28627 | |||
28628 | class DFA24 extends DFA { | ||
28629 | |||
28630 | public DFA24(BaseRecognizer recognizer) { | ||
28631 | this.recognizer = recognizer; | ||
28632 | this.decisionNumber = 24; | ||
28633 | this.eot = dfa_8; | ||
28634 | this.eof = dfa_9; | ||
28635 | this.min = dfa_10; | ||
28636 | this.max = dfa_11; | ||
28637 | this.accept = dfa_12; | ||
28638 | this.special = dfa_13; | ||
28639 | this.transition = dfa_14; | ||
28640 | } | ||
28641 | public String getDescription() { | ||
28642 | return "2637:1: ( rule__ALSFieldDeclaration__MultiplicityAssignment_2 )?"; | ||
28643 | } | ||
28644 | } | ||
28645 | |||
28646 | |||
28647 | public static final BitSet FOLLOW_1 = new BitSet(new long[]{0x0000000000000000L}); | ||
28648 | public static final BitSet FOLLOW_2 = new BitSet(new long[]{0x0000000000000002L}); | ||
28649 | public static final BitSet FOLLOW_3 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000080L}); | ||
28650 | public static final BitSet FOLLOW_4 = new BitSet(new long[]{0x0000320107E00002L,0x0000000000000200L}); | ||
28651 | public static final BitSet FOLLOW_5 = new BitSet(new long[]{0x0000000000000010L}); | ||
28652 | public static final BitSet FOLLOW_6 = new BitSet(new long[]{0x0000000200000000L}); | ||
28653 | public static final BitSet FOLLOW_7 = new BitSet(new long[]{0x0000000C00000000L}); | ||
28654 | public static final BitSet FOLLOW_8 = new BitSet(new long[]{0x0000000800000002L}); | ||
28655 | public static final BitSet FOLLOW_9 = new BitSet(new long[]{0x0000001000000000L}); | ||
28656 | public static final BitSet FOLLOW_10 = new BitSet(new long[]{0x0000006A00000000L}); | ||
28657 | public static final BitSet FOLLOW_11 = new BitSet(new long[]{0x0000000400000010L}); | ||
28658 | public static final BitSet FOLLOW_12 = new BitSet(new long[]{0x0000008000000000L}); | ||
28659 | public static final BitSet FOLLOW_13 = new BitSet(new long[]{0x0000008000000002L}); | ||
28660 | public static final BitSet FOLLOW_14 = new BitSet(new long[]{0x0000000800000000L}); | ||
28661 | public static final BitSet FOLLOW_15 = new BitSet(new long[]{0x0000010000000000L}); | ||
28662 | public static final BitSet FOLLOW_16 = new BitSet(new long[]{0xF2000000FFF80030L,0x000000000000003FL}); | ||
28663 | public static final BitSet FOLLOW_17 = new BitSet(new long[]{0x0000040000000000L}); | ||
28664 | public static final BitSet FOLLOW_18 = new BitSet(new long[]{0x0000080800000000L}); | ||
28665 | public static final BitSet FOLLOW_19 = new BitSet(new long[]{0x0000000400000000L}); | ||
28666 | public static final BitSet FOLLOW_20 = new BitSet(new long[]{0x0000320107E00000L,0x0000000000000200L}); | ||
28667 | public static final BitSet FOLLOW_21 = new BitSet(new long[]{0x0000000200000010L}); | ||
28668 | public static final BitSet FOLLOW_22 = new BitSet(new long[]{0x0000000007E00000L}); | ||
28669 | public static final BitSet FOLLOW_23 = new BitSet(new long[]{0x0000000000000010L,0x0000000000000400L}); | ||
28670 | public static final BitSet FOLLOW_24 = new BitSet(new long[]{0x0000000A00000000L}); | ||
28671 | public static final BitSet FOLLOW_25 = new BitSet(new long[]{0x0000000000001800L}); | ||
28672 | public static final BitSet FOLLOW_26 = new BitSet(new long[]{0x0000000000006000L}); | ||
28673 | public static final BitSet FOLLOW_27 = new BitSet(new long[]{0x0000000000018000L}); | ||
28674 | public static final BitSet FOLLOW_28 = new BitSet(new long[]{0x0000400000000000L}); | ||
28675 | public static final BitSet FOLLOW_29 = new BitSet(new long[]{0x0000000000060000L}); | ||
28676 | public static final BitSet FOLLOW_30 = new BitSet(new long[]{0x001F804000000000L}); | ||
28677 | public static final BitSet FOLLOW_31 = new BitSet(new long[]{0x0000800000000000L}); | ||
28678 | public static final BitSet FOLLOW_32 = new BitSet(new long[]{0x0001000000000000L}); | ||
28679 | public static final BitSet FOLLOW_33 = new BitSet(new long[]{0x0000004000000000L}); | ||
28680 | public static final BitSet FOLLOW_34 = new BitSet(new long[]{0x0002000000000000L}); | ||
28681 | public static final BitSet FOLLOW_35 = new BitSet(new long[]{0x0004000000000000L}); | ||
28682 | public static final BitSet FOLLOW_36 = new BitSet(new long[]{0x0008000000000000L}); | ||
28683 | public static final BitSet FOLLOW_37 = new BitSet(new long[]{0x0020000000000000L}); | ||
28684 | public static final BitSet FOLLOW_38 = new BitSet(new long[]{0x0040000000000000L}); | ||
28685 | public static final BitSet FOLLOW_39 = new BitSet(new long[]{0x0080000000000000L}); | ||
28686 | public static final BitSet FOLLOW_40 = new BitSet(new long[]{0x0100000000000000L}); | ||
28687 | public static final BitSet FOLLOW_41 = new BitSet(new long[]{0x0100000000000002L}); | ||
28688 | public static final BitSet FOLLOW_42 = new BitSet(new long[]{0x0200000000000000L}); | ||
28689 | public static final BitSet FOLLOW_43 = new BitSet(new long[]{0x0200000000000002L}); | ||
28690 | public static final BitSet FOLLOW_44 = new BitSet(new long[]{0x0400000000000000L}); | ||
28691 | public static final BitSet FOLLOW_45 = new BitSet(new long[]{0x0400000000000002L}); | ||
28692 | public static final BitSet FOLLOW_46 = new BitSet(new long[]{0x0800000007E00000L}); | ||
28693 | public static final BitSet FOLLOW_47 = new BitSet(new long[]{0x0000000000180000L}); | ||
28694 | public static final BitSet FOLLOW_48 = new BitSet(new long[]{0x1000000000000000L}); | ||
28695 | public static final BitSet FOLLOW_49 = new BitSet(new long[]{0x2000000000000000L}); | ||
28696 | public static final BitSet FOLLOW_50 = new BitSet(new long[]{0x4000000000000000L}); | ||
28697 | public static final BitSet FOLLOW_51 = new BitSet(new long[]{0x8000000000000000L}); | ||
28698 | public static final BitSet FOLLOW_52 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000001L}); | ||
28699 | public static final BitSet FOLLOW_53 = new BitSet(new long[]{0x00000000F8000010L}); | ||
28700 | public static final BitSet FOLLOW_54 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000002L}); | ||
28701 | public static final BitSet FOLLOW_55 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000004L}); | ||
28702 | public static final BitSet FOLLOW_56 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000008L}); | ||
28703 | public static final BitSet FOLLOW_57 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000010L}); | ||
28704 | public static final BitSet FOLLOW_58 = new BitSet(new long[]{0x0000000000000020L}); | ||
28705 | public static final BitSet FOLLOW_59 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000040L}); | ||
28706 | public static final BitSet FOLLOW_60 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000100L}); | ||
28707 | public static final BitSet FOLLOW_61 = new BitSet(new long[]{0x0000000000000020L,0x0000000000000800L}); | ||
28708 | public static final BitSet FOLLOW_62 = new BitSet(new long[]{0x0000000007E00002L,0x0000000000000200L}); | ||
28709 | |||
28710 | } | ||
diff --git a/Solvers/Alloy-Solver/hu.bme.mit.inf.dslreasoner.alloy.language.ui/src-gen/hu/bme/mit/inf/dslreasoner/ui/internal/AlloyLanguageActivator.java b/Solvers/Alloy-Solver/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..5f7c26a8 --- /dev/null +++ b/Solvers/Alloy-Solver/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 | } | ||