diff options
author | Kristóf Marussy <marussy@mit.bme.hu> | 2020-05-08 21:02:33 +0200 |
---|---|---|
committer | Kristóf Marussy <marussy@mit.bme.hu> | 2020-05-08 21:02:33 +0200 |
commit | 771e3773bb7ebbf6712724cb2b248467c9cc2e3c (patch) | |
tree | b1724af24b9c583b2780c7a2fe76e76fd174359d /Application/org.eclipse.viatra.solver.language.ide/src-gen/org | |
parent | Update solver language grammar (diff) | |
download | VIATRA-Generator-771e3773bb7ebbf6712724cb2b248467c9cc2e3c.tar.gz VIATRA-Generator-771e3773bb7ebbf6712724cb2b248467c9cc2e3c.tar.zst VIATRA-Generator-771e3773bb7ebbf6712724cb2b248467c9cc2e3c.zip |
Synthetic tokens for solver language
Diffstat (limited to 'Application/org.eclipse.viatra.solver.language.ide/src-gen/org')
10 files changed, 9528 insertions, 11592 deletions
diff --git a/Application/org.eclipse.viatra.solver.language.ide/src-gen/org/eclipse/viatra/solver/language/ide/AbstractSolverLanguageIdeModule.java b/Application/org.eclipse.viatra.solver.language.ide/src-gen/org/eclipse/viatra/solver/language/ide/AbstractSolverLanguageIdeModule.java index 71f91821..3c6c55d8 100644 --- a/Application/org.eclipse.viatra.solver.language.ide/src-gen/org/eclipse/viatra/solver/language/ide/AbstractSolverLanguageIdeModule.java +++ b/Application/org.eclipse.viatra.solver.language.ide/src-gen/org/eclipse/viatra/solver/language/ide/AbstractSolverLanguageIdeModule.java | |||
@@ -6,12 +6,14 @@ package org.eclipse.viatra.solver.language.ide; | |||
6 | import com.google.inject.Binder; | 6 | import com.google.inject.Binder; |
7 | import com.google.inject.name.Names; | 7 | import com.google.inject.name.Names; |
8 | import org.eclipse.viatra.solver.language.ide.contentassist.antlr.SolverLanguageParser; | 8 | import org.eclipse.viatra.solver.language.ide.contentassist.antlr.SolverLanguageParser; |
9 | import org.eclipse.viatra.solver.language.ide.contentassist.antlr.internal.InternalSolverLanguageLexer; | 9 | import org.eclipse.viatra.solver.language.ide.contentassist.antlr.lexer.InternalSolverLanguageLexer; |
10 | import org.eclipse.xtext.ide.DefaultIdeModule; | 10 | import org.eclipse.xtext.ide.DefaultIdeModule; |
11 | import org.eclipse.xtext.ide.LexerIdeBindings; | 11 | import org.eclipse.xtext.ide.LexerIdeBindings; |
12 | import org.eclipse.xtext.ide.editor.contentassist.CompletionPrefixProvider; | ||
12 | import org.eclipse.xtext.ide.editor.contentassist.FQNPrefixMatcher; | 13 | import org.eclipse.xtext.ide.editor.contentassist.FQNPrefixMatcher; |
13 | import org.eclipse.xtext.ide.editor.contentassist.IPrefixMatcher; | 14 | import org.eclipse.xtext.ide.editor.contentassist.IPrefixMatcher; |
14 | import org.eclipse.xtext.ide.editor.contentassist.IProposalConflictHelper; | 15 | import org.eclipse.xtext.ide.editor.contentassist.IProposalConflictHelper; |
16 | import org.eclipse.xtext.ide.editor.contentassist.IndentationAwareCompletionPrefixProvider; | ||
15 | import org.eclipse.xtext.ide.editor.contentassist.antlr.AntlrProposalConflictHelper; | 17 | import org.eclipse.xtext.ide.editor.contentassist.antlr.AntlrProposalConflictHelper; |
16 | import org.eclipse.xtext.ide.editor.contentassist.antlr.IContentAssistParser; | 18 | import org.eclipse.xtext.ide.editor.contentassist.antlr.IContentAssistParser; |
17 | import org.eclipse.xtext.ide.editor.contentassist.antlr.internal.Lexer; | 19 | import org.eclipse.xtext.ide.editor.contentassist.antlr.internal.Lexer; |
@@ -42,6 +44,11 @@ public abstract class AbstractSolverLanguageIdeModule extends DefaultIdeModule { | |||
42 | return AntlrProposalConflictHelper.class; | 44 | return AntlrProposalConflictHelper.class; |
43 | } | 45 | } |
44 | 46 | ||
47 | // contributed by org.eclipse.xtext.xtext.generator.parser.antlr.XtextAntlrGeneratorFragment2 | ||
48 | public Class<? extends CompletionPrefixProvider> bindCompletionPrefixProvider() { | ||
49 | return IndentationAwareCompletionPrefixProvider.class; | ||
50 | } | ||
51 | |||
45 | // contributed by org.eclipse.xtext.xtext.generator.exporting.QualifiedNamesFragment2 | 52 | // contributed by org.eclipse.xtext.xtext.generator.exporting.QualifiedNamesFragment2 |
46 | public Class<? extends IPrefixMatcher> bindIPrefixMatcher() { | 53 | public Class<? extends IPrefixMatcher> bindIPrefixMatcher() { |
47 | return FQNPrefixMatcher.class; | 54 | return FQNPrefixMatcher.class; |
diff --git a/Application/org.eclipse.viatra.solver.language.ide/src-gen/org/eclipse/viatra/solver/language/ide/contentassist/antlr/SolverLanguageParser.java b/Application/org.eclipse.viatra.solver.language.ide/src-gen/org/eclipse/viatra/solver/language/ide/contentassist/antlr/SolverLanguageParser.java index fa130139..e4b2806e 100644 --- a/Application/org.eclipse.viatra.solver.language.ide/src-gen/org/eclipse/viatra/solver/language/ide/contentassist/antlr/SolverLanguageParser.java +++ b/Application/org.eclipse.viatra.solver.language.ide/src-gen/org/eclipse/viatra/solver/language/ide/contentassist/antlr/SolverLanguageParser.java | |||
@@ -7,6 +7,8 @@ import com.google.common.collect.ImmutableMap; | |||
7 | import com.google.inject.Inject; | 7 | import com.google.inject.Inject; |
8 | import com.google.inject.Singleton; | 8 | import com.google.inject.Singleton; |
9 | import java.util.Map; | 9 | import java.util.Map; |
10 | import org.antlr.runtime.CharStream; | ||
11 | import org.antlr.runtime.TokenSource; | ||
10 | import org.eclipse.viatra.solver.language.ide.contentassist.antlr.internal.InternalSolverLanguageParser; | 12 | import org.eclipse.viatra.solver.language.ide.contentassist.antlr.internal.InternalSolverLanguageParser; |
11 | import org.eclipse.viatra.solver.language.services.SolverLanguageGrammarAccess; | 13 | import org.eclipse.viatra.solver.language.services.SolverLanguageGrammarAccess; |
12 | import org.eclipse.xtext.AbstractElement; | 14 | import org.eclipse.xtext.AbstractElement; |
@@ -92,9 +94,7 @@ public class SolverLanguageParser extends AbstractContentAssistParser { | |||
92 | builder.put(grammarAccess.getUnaryExpressionAccess().getGroup_1(), "rule__UnaryExpression__Group_1__0"); | 94 | builder.put(grammarAccess.getUnaryExpressionAccess().getGroup_1(), "rule__UnaryExpression__Group_1__0"); |
93 | builder.put(grammarAccess.getCountAccess().getGroup(), "rule__Count__Group__0"); | 95 | builder.put(grammarAccess.getCountAccess().getGroup(), "rule__Count__Group__0"); |
94 | builder.put(grammarAccess.getAggregationAccess().getGroup(), "rule__Aggregation__Group__0"); | 96 | builder.put(grammarAccess.getAggregationAccess().getGroup(), "rule__Aggregation__Group__0"); |
95 | builder.put(grammarAccess.getAtomicExpressionAccess().getGroup_0(), "rule__AtomicExpression__Group_0__0"); | 97 | builder.put(grammarAccess.getAtomicExpressionAccess().getGroup_4(), "rule__AtomicExpression__Group_4__0"); |
96 | builder.put(grammarAccess.getAtomicExpressionAccess().getGroup_0_1(), "rule__AtomicExpression__Group_0_1__0"); | ||
97 | builder.put(grammarAccess.getAtomicExpressionAccess().getGroup_3(), "rule__AtomicExpression__Group_3__0"); | ||
98 | builder.put(grammarAccess.getCallAccess().getGroup(), "rule__Call__Group__0"); | 98 | builder.put(grammarAccess.getCallAccess().getGroup(), "rule__Call__Group__0"); |
99 | builder.put(grammarAccess.getArgumentListAccess().getGroup(), "rule__ArgumentList__Group__0"); | 99 | builder.put(grammarAccess.getArgumentListAccess().getGroup(), "rule__ArgumentList__Group__0"); |
100 | builder.put(grammarAccess.getArgumentListAccess().getGroup_2(), "rule__ArgumentList__Group_2__0"); | 100 | builder.put(grammarAccess.getArgumentListAccess().getGroup_2(), "rule__ArgumentList__Group_2__0"); |
@@ -170,7 +170,6 @@ public class SolverLanguageParser extends AbstractContentAssistParser { | |||
170 | builder.put(grammarAccess.getAggregationAccess().getOpAssignment_0(), "rule__Aggregation__OpAssignment_0"); | 170 | builder.put(grammarAccess.getAggregationAccess().getOpAssignment_0(), "rule__Aggregation__OpAssignment_0"); |
171 | builder.put(grammarAccess.getAggregationAccess().getBodyAssignment_2(), "rule__Aggregation__BodyAssignment_2"); | 171 | builder.put(grammarAccess.getAggregationAccess().getBodyAssignment_2(), "rule__Aggregation__BodyAssignment_2"); |
172 | builder.put(grammarAccess.getAggregationAccess().getConditionAssignment_4(), "rule__Aggregation__ConditionAssignment_4"); | 172 | builder.put(grammarAccess.getAggregationAccess().getConditionAssignment_4(), "rule__Aggregation__ConditionAssignment_4"); |
173 | builder.put(grammarAccess.getAtomicExpressionAccess().getArgumentListAssignment_0_1_1(), "rule__AtomicExpression__ArgumentListAssignment_0_1_1"); | ||
174 | builder.put(grammarAccess.getCallAccess().getFunctorAssignment_0(), "rule__Call__FunctorAssignment_0"); | 173 | builder.put(grammarAccess.getCallAccess().getFunctorAssignment_0(), "rule__Call__FunctorAssignment_0"); |
175 | builder.put(grammarAccess.getCallAccess().getTransitiveClosureAssignment_1_0(), "rule__Call__TransitiveClosureAssignment_1_0"); | 174 | builder.put(grammarAccess.getCallAccess().getTransitiveClosureAssignment_1_0(), "rule__Call__TransitiveClosureAssignment_1_0"); |
176 | builder.put(grammarAccess.getCallAccess().getReflexiveTransitiveClosureAssignment_1_1(), "rule__Call__ReflexiveTransitiveClosureAssignment_1_1"); | 175 | builder.put(grammarAccess.getCallAccess().getReflexiveTransitiveClosureAssignment_1_1(), "rule__Call__ReflexiveTransitiveClosureAssignment_1_1"); |
@@ -232,6 +231,11 @@ public class SolverLanguageParser extends AbstractContentAssistParser { | |||
232 | } | 231 | } |
233 | 232 | ||
234 | @Override | 233 | @Override |
234 | protected TokenSource createLexer(CharStream stream) { | ||
235 | return new SolverLanguageTokenSource(super.createLexer(stream)); | ||
236 | } | ||
237 | |||
238 | @Override | ||
235 | protected String getRuleName(AbstractElement element) { | 239 | protected String getRuleName(AbstractElement element) { |
236 | return nameMappings.getRuleName(element); | 240 | return nameMappings.getRuleName(element); |
237 | } | 241 | } |
diff --git a/Application/org.eclipse.viatra.solver.language.ide/src-gen/org/eclipse/viatra/solver/language/ide/contentassist/antlr/internal/InternalSolverLanguage.tokens b/Application/org.eclipse.viatra.solver.language.ide/src-gen/org/eclipse/viatra/solver/language/ide/contentassist/antlr/internal/InternalSolverLanguage.tokens deleted file mode 100644 index f5b014ff..00000000 --- a/Application/org.eclipse.viatra.solver.language.ide/src-gen/org/eclipse/viatra/solver/language/ide/contentassist/antlr/internal/InternalSolverLanguage.tokens +++ /dev/null | |||
@@ -1,131 +0,0 @@ | |||
1 | '!'=29 | ||
2 | '!='=20 | ||
3 | '('=61 | ||
4 | ')'=62 | ||
5 | '*'=16 | ||
6 | '+'=26 | ||
7 | ','=56 | ||
8 | '-'=27 | ||
9 | '->'=55 | ||
10 | '.'=50 | ||
11 | '..'=64 | ||
12 | '/'=28 | ||
13 | ':'=45 | ||
14 | ':-'=46 | ||
15 | ';'=54 | ||
16 | '<'=21 | ||
17 | '<='=22 | ||
18 | '='=47 | ||
19 | '=='=19 | ||
20 | '>'=23 | ||
21 | '>='=24 | ||
22 | '['=63 | ||
23 | ']'=65 | ||
24 | '^'=15 | ||
25 | 'abstract'=73 | ||
26 | 'avg'=36 | ||
27 | 'class'=68 | ||
28 | 'contains'=74 | ||
29 | 'count'=57 | ||
30 | 'current'=32 | ||
31 | 'default'=48 | ||
32 | 'else'=53 | ||
33 | 'empty'=67 | ||
34 | 'error'=42 | ||
35 | 'extends'=69 | ||
36 | 'extern'=49 | ||
37 | 'false'=40 | ||
38 | 'functional'=72 | ||
39 | 'if'=51 | ||
40 | 'in'=25 | ||
41 | 'inf'=66 | ||
42 | 'int'=17 | ||
43 | 'max'=38 | ||
44 | 'maximize'=44 | ||
45 | 'may'=30 | ||
46 | 'min'=37 | ||
47 | 'minimize'=43 | ||
48 | 'must'=31 | ||
49 | 'only'=33 | ||
50 | 'opposite'=70 | ||
51 | 'prod'=35 | ||
52 | 'real'=18 | ||
53 | 'scope'=71 | ||
54 | 'sum'=34 | ||
55 | 'then'=52 | ||
56 | 'true'=39 | ||
57 | 'unknown'=41 | ||
58 | '{'=58 | ||
59 | '|'=60 | ||
60 | '}'=59 | ||
61 | RULE_ANY_OTHER=14 | ||
62 | RULE_DOT=6 | ||
63 | RULE_ID=7 | ||
64 | RULE_INT=4 | ||
65 | RULE_ML_COMMENT=11 | ||
66 | RULE_PLUS=9 | ||
67 | RULE_QUOTED_ID=5 | ||
68 | RULE_SL_COMMENT=12 | ||
69 | RULE_STAR=8 | ||
70 | RULE_STRING=10 | ||
71 | RULE_WS=13 | ||
72 | T__15=15 | ||
73 | T__16=16 | ||
74 | T__17=17 | ||
75 | T__18=18 | ||
76 | T__19=19 | ||
77 | T__20=20 | ||
78 | T__21=21 | ||
79 | T__22=22 | ||
80 | T__23=23 | ||
81 | T__24=24 | ||
82 | T__25=25 | ||
83 | T__26=26 | ||
84 | T__27=27 | ||
85 | T__28=28 | ||
86 | T__29=29 | ||
87 | T__30=30 | ||
88 | T__31=31 | ||
89 | T__32=32 | ||
90 | T__33=33 | ||
91 | T__34=34 | ||
92 | T__35=35 | ||
93 | T__36=36 | ||
94 | T__37=37 | ||
95 | T__38=38 | ||
96 | T__39=39 | ||
97 | T__40=40 | ||
98 | T__41=41 | ||
99 | T__42=42 | ||
100 | T__43=43 | ||
101 | T__44=44 | ||
102 | T__45=45 | ||
103 | T__46=46 | ||
104 | T__47=47 | ||
105 | T__48=48 | ||
106 | T__49=49 | ||
107 | T__50=50 | ||
108 | T__51=51 | ||
109 | T__52=52 | ||
110 | T__53=53 | ||
111 | T__54=54 | ||
112 | T__55=55 | ||
113 | T__56=56 | ||
114 | T__57=57 | ||
115 | T__58=58 | ||
116 | T__59=59 | ||
117 | T__60=60 | ||
118 | T__61=61 | ||
119 | T__62=62 | ||
120 | T__63=63 | ||
121 | T__64=64 | ||
122 | T__65=65 | ||
123 | T__66=66 | ||
124 | T__67=67 | ||
125 | T__68=68 | ||
126 | T__69=69 | ||
127 | T__70=70 | ||
128 | T__71=71 | ||
129 | T__72=72 | ||
130 | T__73=73 | ||
131 | T__74=74 | ||
diff --git a/Application/org.eclipse.viatra.solver.language.ide/src-gen/org/eclipse/viatra/solver/language/ide/contentassist/antlr/internal/InternalSolverLanguageLexer.java b/Application/org.eclipse.viatra.solver.language.ide/src-gen/org/eclipse/viatra/solver/language/ide/contentassist/antlr/internal/InternalSolverLanguageLexer.java deleted file mode 100644 index 1c226c96..00000000 --- a/Application/org.eclipse.viatra.solver.language.ide/src-gen/org/eclipse/viatra/solver/language/ide/contentassist/antlr/internal/InternalSolverLanguageLexer.java +++ /dev/null | |||
@@ -1,2805 +0,0 @@ | |||
1 | package org.eclipse.viatra.solver.language.ide.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.ide.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 InternalSolverLanguageLexer 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__55=55; | ||
23 | public static final int T__56=56; | ||
24 | public static final int T__57=57; | ||
25 | public static final int T__58=58; | ||
26 | public static final int T__51=51; | ||
27 | public static final int RULE_STAR=8; | ||
28 | public static final int T__52=52; | ||
29 | public static final int T__53=53; | ||
30 | public static final int T__54=54; | ||
31 | public static final int T__60=60; | ||
32 | public static final int T__61=61; | ||
33 | public static final int RULE_ID=7; | ||
34 | public static final int RULE_QUOTED_ID=5; | ||
35 | public static final int T__26=26; | ||
36 | public static final int T__27=27; | ||
37 | public static final int T__28=28; | ||
38 | public static final int RULE_INT=4; | ||
39 | public static final int T__29=29; | ||
40 | public static final int T__22=22; | ||
41 | public static final int T__66=66; | ||
42 | public static final int RULE_ML_COMMENT=11; | ||
43 | public static final int T__23=23; | ||
44 | public static final int T__67=67; | ||
45 | public static final int T__24=24; | ||
46 | public static final int T__68=68; | ||
47 | public static final int T__25=25; | ||
48 | public static final int T__69=69; | ||
49 | public static final int T__62=62; | ||
50 | public static final int T__63=63; | ||
51 | public static final int T__20=20; | ||
52 | public static final int T__64=64; | ||
53 | public static final int T__21=21; | ||
54 | public static final int T__65=65; | ||
55 | public static final int T__70=70; | ||
56 | public static final int T__71=71; | ||
57 | public static final int T__72=72; | ||
58 | public static final int RULE_STRING=10; | ||
59 | public static final int RULE_SL_COMMENT=12; | ||
60 | public static final int T__37=37; | ||
61 | public static final int T__38=38; | ||
62 | public static final int T__39=39; | ||
63 | public static final int T__33=33; | ||
64 | public static final int T__34=34; | ||
65 | public static final int T__35=35; | ||
66 | public static final int RULE_PLUS=9; | ||
67 | public static final int T__36=36; | ||
68 | public static final int T__73=73; | ||
69 | public static final int RULE_DOT=6; | ||
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__32=32; | ||
75 | public static final int RULE_WS=13; | ||
76 | public static final int RULE_ANY_OTHER=14; | ||
77 | public static final int T__48=48; | ||
78 | public static final int T__49=49; | ||
79 | public static final int T__44=44; | ||
80 | public static final int T__45=45; | ||
81 | public static final int T__46=46; | ||
82 | public static final int T__47=47; | ||
83 | public static final int T__40=40; | ||
84 | public static final int T__41=41; | ||
85 | public static final int T__42=42; | ||
86 | public static final int T__43=43; | ||
87 | |||
88 | // delegates | ||
89 | // delegators | ||
90 | |||
91 | public InternalSolverLanguageLexer() {;} | ||
92 | public InternalSolverLanguageLexer(CharStream input) { | ||
93 | this(input, new RecognizerSharedState()); | ||
94 | } | ||
95 | public InternalSolverLanguageLexer(CharStream input, RecognizerSharedState state) { | ||
96 | super(input,state); | ||
97 | |||
98 | } | ||
99 | public String getGrammarFileName() { return "InternalSolverLanguage.g"; } | ||
100 | |||
101 | // $ANTLR start "T__15" | ||
102 | public final void mT__15() throws RecognitionException { | ||
103 | try { | ||
104 | int _type = T__15; | ||
105 | int _channel = DEFAULT_TOKEN_CHANNEL; | ||
106 | // InternalSolverLanguage.g:11:7: ( '^' ) | ||
107 | // InternalSolverLanguage.g:11:9: '^' | ||
108 | { | ||
109 | match('^'); | ||
110 | |||
111 | } | ||
112 | |||
113 | state.type = _type; | ||
114 | state.channel = _channel; | ||
115 | } | ||
116 | finally { | ||
117 | } | ||
118 | } | ||
119 | // $ANTLR end "T__15" | ||
120 | |||
121 | // $ANTLR start "T__16" | ||
122 | public final void mT__16() throws RecognitionException { | ||
123 | try { | ||
124 | int _type = T__16; | ||
125 | int _channel = DEFAULT_TOKEN_CHANNEL; | ||
126 | // InternalSolverLanguage.g:12:7: ( '*' ) | ||
127 | // InternalSolverLanguage.g:12:9: '*' | ||
128 | { | ||
129 | match('*'); | ||
130 | |||
131 | } | ||
132 | |||
133 | state.type = _type; | ||
134 | state.channel = _channel; | ||
135 | } | ||
136 | finally { | ||
137 | } | ||
138 | } | ||
139 | // $ANTLR end "T__16" | ||
140 | |||
141 | // $ANTLR start "T__17" | ||
142 | public final void mT__17() throws RecognitionException { | ||
143 | try { | ||
144 | int _type = T__17; | ||
145 | int _channel = DEFAULT_TOKEN_CHANNEL; | ||
146 | // InternalSolverLanguage.g:13:7: ( 'int' ) | ||
147 | // InternalSolverLanguage.g:13:9: 'int' | ||
148 | { | ||
149 | match("int"); | ||
150 | |||
151 | |||
152 | } | ||
153 | |||
154 | state.type = _type; | ||
155 | state.channel = _channel; | ||
156 | } | ||
157 | finally { | ||
158 | } | ||
159 | } | ||
160 | // $ANTLR end "T__17" | ||
161 | |||
162 | // $ANTLR start "T__18" | ||
163 | public final void mT__18() throws RecognitionException { | ||
164 | try { | ||
165 | int _type = T__18; | ||
166 | int _channel = DEFAULT_TOKEN_CHANNEL; | ||
167 | // InternalSolverLanguage.g:14:7: ( 'real' ) | ||
168 | // InternalSolverLanguage.g:14:9: 'real' | ||
169 | { | ||
170 | match("real"); | ||
171 | |||
172 | |||
173 | } | ||
174 | |||
175 | state.type = _type; | ||
176 | state.channel = _channel; | ||
177 | } | ||
178 | finally { | ||
179 | } | ||
180 | } | ||
181 | // $ANTLR end "T__18" | ||
182 | |||
183 | // $ANTLR start "T__19" | ||
184 | public final void mT__19() throws RecognitionException { | ||
185 | try { | ||
186 | int _type = T__19; | ||
187 | int _channel = DEFAULT_TOKEN_CHANNEL; | ||
188 | // InternalSolverLanguage.g:15:7: ( '==' ) | ||
189 | // InternalSolverLanguage.g:15:9: '==' | ||
190 | { | ||
191 | match("=="); | ||
192 | |||
193 | |||
194 | } | ||
195 | |||
196 | state.type = _type; | ||
197 | state.channel = _channel; | ||
198 | } | ||
199 | finally { | ||
200 | } | ||
201 | } | ||
202 | // $ANTLR end "T__19" | ||
203 | |||
204 | // $ANTLR start "T__20" | ||
205 | public final void mT__20() throws RecognitionException { | ||
206 | try { | ||
207 | int _type = T__20; | ||
208 | int _channel = DEFAULT_TOKEN_CHANNEL; | ||
209 | // InternalSolverLanguage.g:16:7: ( '!=' ) | ||
210 | // InternalSolverLanguage.g:16:9: '!=' | ||
211 | { | ||
212 | match("!="); | ||
213 | |||
214 | |||
215 | } | ||
216 | |||
217 | state.type = _type; | ||
218 | state.channel = _channel; | ||
219 | } | ||
220 | finally { | ||
221 | } | ||
222 | } | ||
223 | // $ANTLR end "T__20" | ||
224 | |||
225 | // $ANTLR start "T__21" | ||
226 | public final void mT__21() throws RecognitionException { | ||
227 | try { | ||
228 | int _type = T__21; | ||
229 | int _channel = DEFAULT_TOKEN_CHANNEL; | ||
230 | // InternalSolverLanguage.g:17:7: ( '<' ) | ||
231 | // InternalSolverLanguage.g:17:9: '<' | ||
232 | { | ||
233 | match('<'); | ||
234 | |||
235 | } | ||
236 | |||
237 | state.type = _type; | ||
238 | state.channel = _channel; | ||
239 | } | ||
240 | finally { | ||
241 | } | ||
242 | } | ||
243 | // $ANTLR end "T__21" | ||
244 | |||
245 | // $ANTLR start "T__22" | ||
246 | public final void mT__22() throws RecognitionException { | ||
247 | try { | ||
248 | int _type = T__22; | ||
249 | int _channel = DEFAULT_TOKEN_CHANNEL; | ||
250 | // InternalSolverLanguage.g:18:7: ( '<=' ) | ||
251 | // InternalSolverLanguage.g:18:9: '<=' | ||
252 | { | ||
253 | match("<="); | ||
254 | |||
255 | |||
256 | } | ||
257 | |||
258 | state.type = _type; | ||
259 | state.channel = _channel; | ||
260 | } | ||
261 | finally { | ||
262 | } | ||
263 | } | ||
264 | // $ANTLR end "T__22" | ||
265 | |||
266 | // $ANTLR start "T__23" | ||
267 | public final void mT__23() throws RecognitionException { | ||
268 | try { | ||
269 | int _type = T__23; | ||
270 | int _channel = DEFAULT_TOKEN_CHANNEL; | ||
271 | // InternalSolverLanguage.g:19:7: ( '>' ) | ||
272 | // InternalSolverLanguage.g:19:9: '>' | ||
273 | { | ||
274 | match('>'); | ||
275 | |||
276 | } | ||
277 | |||
278 | state.type = _type; | ||
279 | state.channel = _channel; | ||
280 | } | ||
281 | finally { | ||
282 | } | ||
283 | } | ||
284 | // $ANTLR end "T__23" | ||
285 | |||
286 | // $ANTLR start "T__24" | ||
287 | public final void mT__24() throws RecognitionException { | ||
288 | try { | ||
289 | int _type = T__24; | ||
290 | int _channel = DEFAULT_TOKEN_CHANNEL; | ||
291 | // InternalSolverLanguage.g:20:7: ( '>=' ) | ||
292 | // InternalSolverLanguage.g:20:9: '>=' | ||
293 | { | ||
294 | match(">="); | ||
295 | |||
296 | |||
297 | } | ||
298 | |||
299 | state.type = _type; | ||
300 | state.channel = _channel; | ||
301 | } | ||
302 | finally { | ||
303 | } | ||
304 | } | ||
305 | // $ANTLR end "T__24" | ||
306 | |||
307 | // $ANTLR start "T__25" | ||
308 | public final void mT__25() throws RecognitionException { | ||
309 | try { | ||
310 | int _type = T__25; | ||
311 | int _channel = DEFAULT_TOKEN_CHANNEL; | ||
312 | // InternalSolverLanguage.g:21:7: ( 'in' ) | ||
313 | // InternalSolverLanguage.g:21:9: 'in' | ||
314 | { | ||
315 | match("in"); | ||
316 | |||
317 | |||
318 | } | ||
319 | |||
320 | state.type = _type; | ||
321 | state.channel = _channel; | ||
322 | } | ||
323 | finally { | ||
324 | } | ||
325 | } | ||
326 | // $ANTLR end "T__25" | ||
327 | |||
328 | // $ANTLR start "T__26" | ||
329 | public final void mT__26() throws RecognitionException { | ||
330 | try { | ||
331 | int _type = T__26; | ||
332 | int _channel = DEFAULT_TOKEN_CHANNEL; | ||
333 | // InternalSolverLanguage.g:22:7: ( '+' ) | ||
334 | // InternalSolverLanguage.g:22:9: '+' | ||
335 | { | ||
336 | match('+'); | ||
337 | |||
338 | } | ||
339 | |||
340 | state.type = _type; | ||
341 | state.channel = _channel; | ||
342 | } | ||
343 | finally { | ||
344 | } | ||
345 | } | ||
346 | // $ANTLR end "T__26" | ||
347 | |||
348 | // $ANTLR start "T__27" | ||
349 | public final void mT__27() throws RecognitionException { | ||
350 | try { | ||
351 | int _type = T__27; | ||
352 | int _channel = DEFAULT_TOKEN_CHANNEL; | ||
353 | // InternalSolverLanguage.g:23:7: ( '-' ) | ||
354 | // InternalSolverLanguage.g:23:9: '-' | ||
355 | { | ||
356 | match('-'); | ||
357 | |||
358 | } | ||
359 | |||
360 | state.type = _type; | ||
361 | state.channel = _channel; | ||
362 | } | ||
363 | finally { | ||
364 | } | ||
365 | } | ||
366 | // $ANTLR end "T__27" | ||
367 | |||
368 | // $ANTLR start "T__28" | ||
369 | public final void mT__28() throws RecognitionException { | ||
370 | try { | ||
371 | int _type = T__28; | ||
372 | int _channel = DEFAULT_TOKEN_CHANNEL; | ||
373 | // InternalSolverLanguage.g:24:7: ( '/' ) | ||
374 | // InternalSolverLanguage.g:24:9: '/' | ||
375 | { | ||
376 | match('/'); | ||
377 | |||
378 | } | ||
379 | |||
380 | state.type = _type; | ||
381 | state.channel = _channel; | ||
382 | } | ||
383 | finally { | ||
384 | } | ||
385 | } | ||
386 | // $ANTLR end "T__28" | ||
387 | |||
388 | // $ANTLR start "T__29" | ||
389 | public final void mT__29() throws RecognitionException { | ||
390 | try { | ||
391 | int _type = T__29; | ||
392 | int _channel = DEFAULT_TOKEN_CHANNEL; | ||
393 | // InternalSolverLanguage.g:25:7: ( '!' ) | ||
394 | // InternalSolverLanguage.g:25:9: '!' | ||
395 | { | ||
396 | match('!'); | ||
397 | |||
398 | } | ||
399 | |||
400 | state.type = _type; | ||
401 | state.channel = _channel; | ||
402 | } | ||
403 | finally { | ||
404 | } | ||
405 | } | ||
406 | // $ANTLR end "T__29" | ||
407 | |||
408 | // $ANTLR start "T__30" | ||
409 | public final void mT__30() throws RecognitionException { | ||
410 | try { | ||
411 | int _type = T__30; | ||
412 | int _channel = DEFAULT_TOKEN_CHANNEL; | ||
413 | // InternalSolverLanguage.g:26:7: ( 'may' ) | ||
414 | // InternalSolverLanguage.g:26:9: 'may' | ||
415 | { | ||
416 | match("may"); | ||
417 | |||
418 | |||
419 | } | ||
420 | |||
421 | state.type = _type; | ||
422 | state.channel = _channel; | ||
423 | } | ||
424 | finally { | ||
425 | } | ||
426 | } | ||
427 | // $ANTLR end "T__30" | ||
428 | |||
429 | // $ANTLR start "T__31" | ||
430 | public final void mT__31() throws RecognitionException { | ||
431 | try { | ||
432 | int _type = T__31; | ||
433 | int _channel = DEFAULT_TOKEN_CHANNEL; | ||
434 | // InternalSolverLanguage.g:27:7: ( 'must' ) | ||
435 | // InternalSolverLanguage.g:27:9: 'must' | ||
436 | { | ||
437 | match("must"); | ||
438 | |||
439 | |||
440 | } | ||
441 | |||
442 | state.type = _type; | ||
443 | state.channel = _channel; | ||
444 | } | ||
445 | finally { | ||
446 | } | ||
447 | } | ||
448 | // $ANTLR end "T__31" | ||
449 | |||
450 | // $ANTLR start "T__32" | ||
451 | public final void mT__32() throws RecognitionException { | ||
452 | try { | ||
453 | int _type = T__32; | ||
454 | int _channel = DEFAULT_TOKEN_CHANNEL; | ||
455 | // InternalSolverLanguage.g:28:7: ( 'current' ) | ||
456 | // InternalSolverLanguage.g:28:9: 'current' | ||
457 | { | ||
458 | match("current"); | ||
459 | |||
460 | |||
461 | } | ||
462 | |||
463 | state.type = _type; | ||
464 | state.channel = _channel; | ||
465 | } | ||
466 | finally { | ||
467 | } | ||
468 | } | ||
469 | // $ANTLR end "T__32" | ||
470 | |||
471 | // $ANTLR start "T__33" | ||
472 | public final void mT__33() throws RecognitionException { | ||
473 | try { | ||
474 | int _type = T__33; | ||
475 | int _channel = DEFAULT_TOKEN_CHANNEL; | ||
476 | // InternalSolverLanguage.g:29:7: ( 'only' ) | ||
477 | // InternalSolverLanguage.g:29:9: 'only' | ||
478 | { | ||
479 | match("only"); | ||
480 | |||
481 | |||
482 | } | ||
483 | |||
484 | state.type = _type; | ||
485 | state.channel = _channel; | ||
486 | } | ||
487 | finally { | ||
488 | } | ||
489 | } | ||
490 | // $ANTLR end "T__33" | ||
491 | |||
492 | // $ANTLR start "T__34" | ||
493 | public final void mT__34() throws RecognitionException { | ||
494 | try { | ||
495 | int _type = T__34; | ||
496 | int _channel = DEFAULT_TOKEN_CHANNEL; | ||
497 | // InternalSolverLanguage.g:30:7: ( 'sum' ) | ||
498 | // InternalSolverLanguage.g:30:9: 'sum' | ||
499 | { | ||
500 | match("sum"); | ||
501 | |||
502 | |||
503 | } | ||
504 | |||
505 | state.type = _type; | ||
506 | state.channel = _channel; | ||
507 | } | ||
508 | finally { | ||
509 | } | ||
510 | } | ||
511 | // $ANTLR end "T__34" | ||
512 | |||
513 | // $ANTLR start "T__35" | ||
514 | public final void mT__35() throws RecognitionException { | ||
515 | try { | ||
516 | int _type = T__35; | ||
517 | int _channel = DEFAULT_TOKEN_CHANNEL; | ||
518 | // InternalSolverLanguage.g:31:7: ( 'prod' ) | ||
519 | // InternalSolverLanguage.g:31:9: 'prod' | ||
520 | { | ||
521 | match("prod"); | ||
522 | |||
523 | |||
524 | } | ||
525 | |||
526 | state.type = _type; | ||
527 | state.channel = _channel; | ||
528 | } | ||
529 | finally { | ||
530 | } | ||
531 | } | ||
532 | // $ANTLR end "T__35" | ||
533 | |||
534 | // $ANTLR start "T__36" | ||
535 | public final void mT__36() throws RecognitionException { | ||
536 | try { | ||
537 | int _type = T__36; | ||
538 | int _channel = DEFAULT_TOKEN_CHANNEL; | ||
539 | // InternalSolverLanguage.g:32:7: ( 'avg' ) | ||
540 | // InternalSolverLanguage.g:32:9: 'avg' | ||
541 | { | ||
542 | match("avg"); | ||
543 | |||
544 | |||
545 | } | ||
546 | |||
547 | state.type = _type; | ||
548 | state.channel = _channel; | ||
549 | } | ||
550 | finally { | ||
551 | } | ||
552 | } | ||
553 | // $ANTLR end "T__36" | ||
554 | |||
555 | // $ANTLR start "T__37" | ||
556 | public final void mT__37() throws RecognitionException { | ||
557 | try { | ||
558 | int _type = T__37; | ||
559 | int _channel = DEFAULT_TOKEN_CHANNEL; | ||
560 | // InternalSolverLanguage.g:33:7: ( 'min' ) | ||
561 | // InternalSolverLanguage.g:33:9: 'min' | ||
562 | { | ||
563 | match("min"); | ||
564 | |||
565 | |||
566 | } | ||
567 | |||
568 | state.type = _type; | ||
569 | state.channel = _channel; | ||
570 | } | ||
571 | finally { | ||
572 | } | ||
573 | } | ||
574 | // $ANTLR end "T__37" | ||
575 | |||
576 | // $ANTLR start "T__38" | ||
577 | public final void mT__38() throws RecognitionException { | ||
578 | try { | ||
579 | int _type = T__38; | ||
580 | int _channel = DEFAULT_TOKEN_CHANNEL; | ||
581 | // InternalSolverLanguage.g:34:7: ( 'max' ) | ||
582 | // InternalSolverLanguage.g:34:9: 'max' | ||
583 | { | ||
584 | match("max"); | ||
585 | |||
586 | |||
587 | } | ||
588 | |||
589 | state.type = _type; | ||
590 | state.channel = _channel; | ||
591 | } | ||
592 | finally { | ||
593 | } | ||
594 | } | ||
595 | // $ANTLR end "T__38" | ||
596 | |||
597 | // $ANTLR start "T__39" | ||
598 | public final void mT__39() throws RecognitionException { | ||
599 | try { | ||
600 | int _type = T__39; | ||
601 | int _channel = DEFAULT_TOKEN_CHANNEL; | ||
602 | // InternalSolverLanguage.g:35:7: ( 'true' ) | ||
603 | // InternalSolverLanguage.g:35:9: 'true' | ||
604 | { | ||
605 | match("true"); | ||
606 | |||
607 | |||
608 | } | ||
609 | |||
610 | state.type = _type; | ||
611 | state.channel = _channel; | ||
612 | } | ||
613 | finally { | ||
614 | } | ||
615 | } | ||
616 | // $ANTLR end "T__39" | ||
617 | |||
618 | // $ANTLR start "T__40" | ||
619 | public final void mT__40() throws RecognitionException { | ||
620 | try { | ||
621 | int _type = T__40; | ||
622 | int _channel = DEFAULT_TOKEN_CHANNEL; | ||
623 | // InternalSolverLanguage.g:36:7: ( 'false' ) | ||
624 | // InternalSolverLanguage.g:36:9: 'false' | ||
625 | { | ||
626 | match("false"); | ||
627 | |||
628 | |||
629 | } | ||
630 | |||
631 | state.type = _type; | ||
632 | state.channel = _channel; | ||
633 | } | ||
634 | finally { | ||
635 | } | ||
636 | } | ||
637 | // $ANTLR end "T__40" | ||
638 | |||
639 | // $ANTLR start "T__41" | ||
640 | public final void mT__41() throws RecognitionException { | ||
641 | try { | ||
642 | int _type = T__41; | ||
643 | int _channel = DEFAULT_TOKEN_CHANNEL; | ||
644 | // InternalSolverLanguage.g:37:7: ( 'unknown' ) | ||
645 | // InternalSolverLanguage.g:37:9: 'unknown' | ||
646 | { | ||
647 | match("unknown"); | ||
648 | |||
649 | |||
650 | } | ||
651 | |||
652 | state.type = _type; | ||
653 | state.channel = _channel; | ||
654 | } | ||
655 | finally { | ||
656 | } | ||
657 | } | ||
658 | // $ANTLR end "T__41" | ||
659 | |||
660 | // $ANTLR start "T__42" | ||
661 | public final void mT__42() throws RecognitionException { | ||
662 | try { | ||
663 | int _type = T__42; | ||
664 | int _channel = DEFAULT_TOKEN_CHANNEL; | ||
665 | // InternalSolverLanguage.g:38:7: ( 'error' ) | ||
666 | // InternalSolverLanguage.g:38:9: 'error' | ||
667 | { | ||
668 | match("error"); | ||
669 | |||
670 | |||
671 | } | ||
672 | |||
673 | state.type = _type; | ||
674 | state.channel = _channel; | ||
675 | } | ||
676 | finally { | ||
677 | } | ||
678 | } | ||
679 | // $ANTLR end "T__42" | ||
680 | |||
681 | // $ANTLR start "T__43" | ||
682 | public final void mT__43() throws RecognitionException { | ||
683 | try { | ||
684 | int _type = T__43; | ||
685 | int _channel = DEFAULT_TOKEN_CHANNEL; | ||
686 | // InternalSolverLanguage.g:39:7: ( 'minimize' ) | ||
687 | // InternalSolverLanguage.g:39:9: 'minimize' | ||
688 | { | ||
689 | match("minimize"); | ||
690 | |||
691 | |||
692 | } | ||
693 | |||
694 | state.type = _type; | ||
695 | state.channel = _channel; | ||
696 | } | ||
697 | finally { | ||
698 | } | ||
699 | } | ||
700 | // $ANTLR end "T__43" | ||
701 | |||
702 | // $ANTLR start "T__44" | ||
703 | public final void mT__44() throws RecognitionException { | ||
704 | try { | ||
705 | int _type = T__44; | ||
706 | int _channel = DEFAULT_TOKEN_CHANNEL; | ||
707 | // InternalSolverLanguage.g:40:7: ( 'maximize' ) | ||
708 | // InternalSolverLanguage.g:40:9: 'maximize' | ||
709 | { | ||
710 | match("maximize"); | ||
711 | |||
712 | |||
713 | } | ||
714 | |||
715 | state.type = _type; | ||
716 | state.channel = _channel; | ||
717 | } | ||
718 | finally { | ||
719 | } | ||
720 | } | ||
721 | // $ANTLR end "T__44" | ||
722 | |||
723 | // $ANTLR start "T__45" | ||
724 | public final void mT__45() throws RecognitionException { | ||
725 | try { | ||
726 | int _type = T__45; | ||
727 | int _channel = DEFAULT_TOKEN_CHANNEL; | ||
728 | // InternalSolverLanguage.g:41:7: ( ':' ) | ||
729 | // InternalSolverLanguage.g:41:9: ':' | ||
730 | { | ||
731 | match(':'); | ||
732 | |||
733 | } | ||
734 | |||
735 | state.type = _type; | ||
736 | state.channel = _channel; | ||
737 | } | ||
738 | finally { | ||
739 | } | ||
740 | } | ||
741 | // $ANTLR end "T__45" | ||
742 | |||
743 | // $ANTLR start "T__46" | ||
744 | public final void mT__46() throws RecognitionException { | ||
745 | try { | ||
746 | int _type = T__46; | ||
747 | int _channel = DEFAULT_TOKEN_CHANNEL; | ||
748 | // InternalSolverLanguage.g:42:7: ( ':-' ) | ||
749 | // InternalSolverLanguage.g:42:9: ':-' | ||
750 | { | ||
751 | match(":-"); | ||
752 | |||
753 | |||
754 | } | ||
755 | |||
756 | state.type = _type; | ||
757 | state.channel = _channel; | ||
758 | } | ||
759 | finally { | ||
760 | } | ||
761 | } | ||
762 | // $ANTLR end "T__46" | ||
763 | |||
764 | // $ANTLR start "T__47" | ||
765 | public final void mT__47() throws RecognitionException { | ||
766 | try { | ||
767 | int _type = T__47; | ||
768 | int _channel = DEFAULT_TOKEN_CHANNEL; | ||
769 | // InternalSolverLanguage.g:43:7: ( '=' ) | ||
770 | // InternalSolverLanguage.g:43:9: '=' | ||
771 | { | ||
772 | match('='); | ||
773 | |||
774 | } | ||
775 | |||
776 | state.type = _type; | ||
777 | state.channel = _channel; | ||
778 | } | ||
779 | finally { | ||
780 | } | ||
781 | } | ||
782 | // $ANTLR end "T__47" | ||
783 | |||
784 | // $ANTLR start "T__48" | ||
785 | public final void mT__48() throws RecognitionException { | ||
786 | try { | ||
787 | int _type = T__48; | ||
788 | int _channel = DEFAULT_TOKEN_CHANNEL; | ||
789 | // InternalSolverLanguage.g:44:7: ( 'default' ) | ||
790 | // InternalSolverLanguage.g:44:9: 'default' | ||
791 | { | ||
792 | match("default"); | ||
793 | |||
794 | |||
795 | } | ||
796 | |||
797 | state.type = _type; | ||
798 | state.channel = _channel; | ||
799 | } | ||
800 | finally { | ||
801 | } | ||
802 | } | ||
803 | // $ANTLR end "T__48" | ||
804 | |||
805 | // $ANTLR start "T__49" | ||
806 | public final void mT__49() throws RecognitionException { | ||
807 | try { | ||
808 | int _type = T__49; | ||
809 | int _channel = DEFAULT_TOKEN_CHANNEL; | ||
810 | // InternalSolverLanguage.g:45:7: ( 'extern' ) | ||
811 | // InternalSolverLanguage.g:45:9: 'extern' | ||
812 | { | ||
813 | match("extern"); | ||
814 | |||
815 | |||
816 | } | ||
817 | |||
818 | state.type = _type; | ||
819 | state.channel = _channel; | ||
820 | } | ||
821 | finally { | ||
822 | } | ||
823 | } | ||
824 | // $ANTLR end "T__49" | ||
825 | |||
826 | // $ANTLR start "T__50" | ||
827 | public final void mT__50() throws RecognitionException { | ||
828 | try { | ||
829 | int _type = T__50; | ||
830 | int _channel = DEFAULT_TOKEN_CHANNEL; | ||
831 | // InternalSolverLanguage.g:46:7: ( '.' ) | ||
832 | // InternalSolverLanguage.g:46:9: '.' | ||
833 | { | ||
834 | match('.'); | ||
835 | |||
836 | } | ||
837 | |||
838 | state.type = _type; | ||
839 | state.channel = _channel; | ||
840 | } | ||
841 | finally { | ||
842 | } | ||
843 | } | ||
844 | // $ANTLR end "T__50" | ||
845 | |||
846 | // $ANTLR start "T__51" | ||
847 | public final void mT__51() throws RecognitionException { | ||
848 | try { | ||
849 | int _type = T__51; | ||
850 | int _channel = DEFAULT_TOKEN_CHANNEL; | ||
851 | // InternalSolverLanguage.g:47:7: ( 'if' ) | ||
852 | // InternalSolverLanguage.g:47:9: 'if' | ||
853 | { | ||
854 | match("if"); | ||
855 | |||
856 | |||
857 | } | ||
858 | |||
859 | state.type = _type; | ||
860 | state.channel = _channel; | ||
861 | } | ||
862 | finally { | ||
863 | } | ||
864 | } | ||
865 | // $ANTLR end "T__51" | ||
866 | |||
867 | // $ANTLR start "T__52" | ||
868 | public final void mT__52() throws RecognitionException { | ||
869 | try { | ||
870 | int _type = T__52; | ||
871 | int _channel = DEFAULT_TOKEN_CHANNEL; | ||
872 | // InternalSolverLanguage.g:48:7: ( 'then' ) | ||
873 | // InternalSolverLanguage.g:48:9: 'then' | ||
874 | { | ||
875 | match("then"); | ||
876 | |||
877 | |||
878 | } | ||
879 | |||
880 | state.type = _type; | ||
881 | state.channel = _channel; | ||
882 | } | ||
883 | finally { | ||
884 | } | ||
885 | } | ||
886 | // $ANTLR end "T__52" | ||
887 | |||
888 | // $ANTLR start "T__53" | ||
889 | public final void mT__53() throws RecognitionException { | ||
890 | try { | ||
891 | int _type = T__53; | ||
892 | int _channel = DEFAULT_TOKEN_CHANNEL; | ||
893 | // InternalSolverLanguage.g:49:7: ( 'else' ) | ||
894 | // InternalSolverLanguage.g:49:9: 'else' | ||
895 | { | ||
896 | match("else"); | ||
897 | |||
898 | |||
899 | } | ||
900 | |||
901 | state.type = _type; | ||
902 | state.channel = _channel; | ||
903 | } | ||
904 | finally { | ||
905 | } | ||
906 | } | ||
907 | // $ANTLR end "T__53" | ||
908 | |||
909 | // $ANTLR start "T__54" | ||
910 | public final void mT__54() throws RecognitionException { | ||
911 | try { | ||
912 | int _type = T__54; | ||
913 | int _channel = DEFAULT_TOKEN_CHANNEL; | ||
914 | // InternalSolverLanguage.g:50:7: ( ';' ) | ||
915 | // InternalSolverLanguage.g:50:9: ';' | ||
916 | { | ||
917 | match(';'); | ||
918 | |||
919 | } | ||
920 | |||
921 | state.type = _type; | ||
922 | state.channel = _channel; | ||
923 | } | ||
924 | finally { | ||
925 | } | ||
926 | } | ||
927 | // $ANTLR end "T__54" | ||
928 | |||
929 | // $ANTLR start "T__55" | ||
930 | public final void mT__55() throws RecognitionException { | ||
931 | try { | ||
932 | int _type = T__55; | ||
933 | int _channel = DEFAULT_TOKEN_CHANNEL; | ||
934 | // InternalSolverLanguage.g:51:7: ( '->' ) | ||
935 | // InternalSolverLanguage.g:51:9: '->' | ||
936 | { | ||
937 | match("->"); | ||
938 | |||
939 | |||
940 | } | ||
941 | |||
942 | state.type = _type; | ||
943 | state.channel = _channel; | ||
944 | } | ||
945 | finally { | ||
946 | } | ||
947 | } | ||
948 | // $ANTLR end "T__55" | ||
949 | |||
950 | // $ANTLR start "T__56" | ||
951 | public final void mT__56() throws RecognitionException { | ||
952 | try { | ||
953 | int _type = T__56; | ||
954 | int _channel = DEFAULT_TOKEN_CHANNEL; | ||
955 | // InternalSolverLanguage.g:52:7: ( ',' ) | ||
956 | // InternalSolverLanguage.g:52:9: ',' | ||
957 | { | ||
958 | match(','); | ||
959 | |||
960 | } | ||
961 | |||
962 | state.type = _type; | ||
963 | state.channel = _channel; | ||
964 | } | ||
965 | finally { | ||
966 | } | ||
967 | } | ||
968 | // $ANTLR end "T__56" | ||
969 | |||
970 | // $ANTLR start "T__57" | ||
971 | public final void mT__57() throws RecognitionException { | ||
972 | try { | ||
973 | int _type = T__57; | ||
974 | int _channel = DEFAULT_TOKEN_CHANNEL; | ||
975 | // InternalSolverLanguage.g:53:7: ( 'count' ) | ||
976 | // InternalSolverLanguage.g:53:9: 'count' | ||
977 | { | ||
978 | match("count"); | ||
979 | |||
980 | |||
981 | } | ||
982 | |||
983 | state.type = _type; | ||
984 | state.channel = _channel; | ||
985 | } | ||
986 | finally { | ||
987 | } | ||
988 | } | ||
989 | // $ANTLR end "T__57" | ||
990 | |||
991 | // $ANTLR start "T__58" | ||
992 | public final void mT__58() throws RecognitionException { | ||
993 | try { | ||
994 | int _type = T__58; | ||
995 | int _channel = DEFAULT_TOKEN_CHANNEL; | ||
996 | // InternalSolverLanguage.g:54:7: ( '{' ) | ||
997 | // InternalSolverLanguage.g:54:9: '{' | ||
998 | { | ||
999 | match('{'); | ||
1000 | |||
1001 | } | ||
1002 | |||
1003 | state.type = _type; | ||
1004 | state.channel = _channel; | ||
1005 | } | ||
1006 | finally { | ||
1007 | } | ||
1008 | } | ||
1009 | // $ANTLR end "T__58" | ||
1010 | |||
1011 | // $ANTLR start "T__59" | ||
1012 | public final void mT__59() throws RecognitionException { | ||
1013 | try { | ||
1014 | int _type = T__59; | ||
1015 | int _channel = DEFAULT_TOKEN_CHANNEL; | ||
1016 | // InternalSolverLanguage.g:55:7: ( '}' ) | ||
1017 | // InternalSolverLanguage.g:55:9: '}' | ||
1018 | { | ||
1019 | match('}'); | ||
1020 | |||
1021 | } | ||
1022 | |||
1023 | state.type = _type; | ||
1024 | state.channel = _channel; | ||
1025 | } | ||
1026 | finally { | ||
1027 | } | ||
1028 | } | ||
1029 | // $ANTLR end "T__59" | ||
1030 | |||
1031 | // $ANTLR start "T__60" | ||
1032 | public final void mT__60() throws RecognitionException { | ||
1033 | try { | ||
1034 | int _type = T__60; | ||
1035 | int _channel = DEFAULT_TOKEN_CHANNEL; | ||
1036 | // InternalSolverLanguage.g:56:7: ( '|' ) | ||
1037 | // InternalSolverLanguage.g:56:9: '|' | ||
1038 | { | ||
1039 | match('|'); | ||
1040 | |||
1041 | } | ||
1042 | |||
1043 | state.type = _type; | ||
1044 | state.channel = _channel; | ||
1045 | } | ||
1046 | finally { | ||
1047 | } | ||
1048 | } | ||
1049 | // $ANTLR end "T__60" | ||
1050 | |||
1051 | // $ANTLR start "T__61" | ||
1052 | public final void mT__61() throws RecognitionException { | ||
1053 | try { | ||
1054 | int _type = T__61; | ||
1055 | int _channel = DEFAULT_TOKEN_CHANNEL; | ||
1056 | // InternalSolverLanguage.g:57:7: ( '(' ) | ||
1057 | // InternalSolverLanguage.g:57:9: '(' | ||
1058 | { | ||
1059 | match('('); | ||
1060 | |||
1061 | } | ||
1062 | |||
1063 | state.type = _type; | ||
1064 | state.channel = _channel; | ||
1065 | } | ||
1066 | finally { | ||
1067 | } | ||
1068 | } | ||
1069 | // $ANTLR end "T__61" | ||
1070 | |||
1071 | // $ANTLR start "T__62" | ||
1072 | public final void mT__62() throws RecognitionException { | ||
1073 | try { | ||
1074 | int _type = T__62; | ||
1075 | int _channel = DEFAULT_TOKEN_CHANNEL; | ||
1076 | // InternalSolverLanguage.g:58:7: ( ')' ) | ||
1077 | // InternalSolverLanguage.g:58:9: ')' | ||
1078 | { | ||
1079 | match(')'); | ||
1080 | |||
1081 | } | ||
1082 | |||
1083 | state.type = _type; | ||
1084 | state.channel = _channel; | ||
1085 | } | ||
1086 | finally { | ||
1087 | } | ||
1088 | } | ||
1089 | // $ANTLR end "T__62" | ||
1090 | |||
1091 | // $ANTLR start "T__63" | ||
1092 | public final void mT__63() throws RecognitionException { | ||
1093 | try { | ||
1094 | int _type = T__63; | ||
1095 | int _channel = DEFAULT_TOKEN_CHANNEL; | ||
1096 | // InternalSolverLanguage.g:59:7: ( '[' ) | ||
1097 | // InternalSolverLanguage.g:59:9: '[' | ||
1098 | { | ||
1099 | match('['); | ||
1100 | |||
1101 | } | ||
1102 | |||
1103 | state.type = _type; | ||
1104 | state.channel = _channel; | ||
1105 | } | ||
1106 | finally { | ||
1107 | } | ||
1108 | } | ||
1109 | // $ANTLR end "T__63" | ||
1110 | |||
1111 | // $ANTLR start "T__64" | ||
1112 | public final void mT__64() throws RecognitionException { | ||
1113 | try { | ||
1114 | int _type = T__64; | ||
1115 | int _channel = DEFAULT_TOKEN_CHANNEL; | ||
1116 | // InternalSolverLanguage.g:60:7: ( '..' ) | ||
1117 | // InternalSolverLanguage.g:60:9: '..' | ||
1118 | { | ||
1119 | match(".."); | ||
1120 | |||
1121 | |||
1122 | } | ||
1123 | |||
1124 | state.type = _type; | ||
1125 | state.channel = _channel; | ||
1126 | } | ||
1127 | finally { | ||
1128 | } | ||
1129 | } | ||
1130 | // $ANTLR end "T__64" | ||
1131 | |||
1132 | // $ANTLR start "T__65" | ||
1133 | public final void mT__65() throws RecognitionException { | ||
1134 | try { | ||
1135 | int _type = T__65; | ||
1136 | int _channel = DEFAULT_TOKEN_CHANNEL; | ||
1137 | // InternalSolverLanguage.g:61:7: ( ']' ) | ||
1138 | // InternalSolverLanguage.g:61:9: ']' | ||
1139 | { | ||
1140 | match(']'); | ||
1141 | |||
1142 | } | ||
1143 | |||
1144 | state.type = _type; | ||
1145 | state.channel = _channel; | ||
1146 | } | ||
1147 | finally { | ||
1148 | } | ||
1149 | } | ||
1150 | // $ANTLR end "T__65" | ||
1151 | |||
1152 | // $ANTLR start "T__66" | ||
1153 | public final void mT__66() throws RecognitionException { | ||
1154 | try { | ||
1155 | int _type = T__66; | ||
1156 | int _channel = DEFAULT_TOKEN_CHANNEL; | ||
1157 | // InternalSolverLanguage.g:62:7: ( 'inf' ) | ||
1158 | // InternalSolverLanguage.g:62:9: 'inf' | ||
1159 | { | ||
1160 | match("inf"); | ||
1161 | |||
1162 | |||
1163 | } | ||
1164 | |||
1165 | state.type = _type; | ||
1166 | state.channel = _channel; | ||
1167 | } | ||
1168 | finally { | ||
1169 | } | ||
1170 | } | ||
1171 | // $ANTLR end "T__66" | ||
1172 | |||
1173 | // $ANTLR start "T__67" | ||
1174 | public final void mT__67() throws RecognitionException { | ||
1175 | try { | ||
1176 | int _type = T__67; | ||
1177 | int _channel = DEFAULT_TOKEN_CHANNEL; | ||
1178 | // InternalSolverLanguage.g:63:7: ( 'empty' ) | ||
1179 | // InternalSolverLanguage.g:63:9: 'empty' | ||
1180 | { | ||
1181 | match("empty"); | ||
1182 | |||
1183 | |||
1184 | } | ||
1185 | |||
1186 | state.type = _type; | ||
1187 | state.channel = _channel; | ||
1188 | } | ||
1189 | finally { | ||
1190 | } | ||
1191 | } | ||
1192 | // $ANTLR end "T__67" | ||
1193 | |||
1194 | // $ANTLR start "T__68" | ||
1195 | public final void mT__68() throws RecognitionException { | ||
1196 | try { | ||
1197 | int _type = T__68; | ||
1198 | int _channel = DEFAULT_TOKEN_CHANNEL; | ||
1199 | // InternalSolverLanguage.g:64:7: ( 'class' ) | ||
1200 | // InternalSolverLanguage.g:64:9: 'class' | ||
1201 | { | ||
1202 | match("class"); | ||
1203 | |||
1204 | |||
1205 | } | ||
1206 | |||
1207 | state.type = _type; | ||
1208 | state.channel = _channel; | ||
1209 | } | ||
1210 | finally { | ||
1211 | } | ||
1212 | } | ||
1213 | // $ANTLR end "T__68" | ||
1214 | |||
1215 | // $ANTLR start "T__69" | ||
1216 | public final void mT__69() throws RecognitionException { | ||
1217 | try { | ||
1218 | int _type = T__69; | ||
1219 | int _channel = DEFAULT_TOKEN_CHANNEL; | ||
1220 | // InternalSolverLanguage.g:65:7: ( 'extends' ) | ||
1221 | // InternalSolverLanguage.g:65:9: 'extends' | ||
1222 | { | ||
1223 | match("extends"); | ||
1224 | |||
1225 | |||
1226 | } | ||
1227 | |||
1228 | state.type = _type; | ||
1229 | state.channel = _channel; | ||
1230 | } | ||
1231 | finally { | ||
1232 | } | ||
1233 | } | ||
1234 | // $ANTLR end "T__69" | ||
1235 | |||
1236 | // $ANTLR start "T__70" | ||
1237 | public final void mT__70() throws RecognitionException { | ||
1238 | try { | ||
1239 | int _type = T__70; | ||
1240 | int _channel = DEFAULT_TOKEN_CHANNEL; | ||
1241 | // InternalSolverLanguage.g:66:7: ( 'opposite' ) | ||
1242 | // InternalSolverLanguage.g:66:9: 'opposite' | ||
1243 | { | ||
1244 | match("opposite"); | ||
1245 | |||
1246 | |||
1247 | } | ||
1248 | |||
1249 | state.type = _type; | ||
1250 | state.channel = _channel; | ||
1251 | } | ||
1252 | finally { | ||
1253 | } | ||
1254 | } | ||
1255 | // $ANTLR end "T__70" | ||
1256 | |||
1257 | // $ANTLR start "T__71" | ||
1258 | public final void mT__71() throws RecognitionException { | ||
1259 | try { | ||
1260 | int _type = T__71; | ||
1261 | int _channel = DEFAULT_TOKEN_CHANNEL; | ||
1262 | // InternalSolverLanguage.g:67:7: ( 'scope' ) | ||
1263 | // InternalSolverLanguage.g:67:9: 'scope' | ||
1264 | { | ||
1265 | match("scope"); | ||
1266 | |||
1267 | |||
1268 | } | ||
1269 | |||
1270 | state.type = _type; | ||
1271 | state.channel = _channel; | ||
1272 | } | ||
1273 | finally { | ||
1274 | } | ||
1275 | } | ||
1276 | // $ANTLR end "T__71" | ||
1277 | |||
1278 | // $ANTLR start "T__72" | ||
1279 | public final void mT__72() throws RecognitionException { | ||
1280 | try { | ||
1281 | int _type = T__72; | ||
1282 | int _channel = DEFAULT_TOKEN_CHANNEL; | ||
1283 | // InternalSolverLanguage.g:68:7: ( 'functional' ) | ||
1284 | // InternalSolverLanguage.g:68:9: 'functional' | ||
1285 | { | ||
1286 | match("functional"); | ||
1287 | |||
1288 | |||
1289 | } | ||
1290 | |||
1291 | state.type = _type; | ||
1292 | state.channel = _channel; | ||
1293 | } | ||
1294 | finally { | ||
1295 | } | ||
1296 | } | ||
1297 | // $ANTLR end "T__72" | ||
1298 | |||
1299 | // $ANTLR start "T__73" | ||
1300 | public final void mT__73() throws RecognitionException { | ||
1301 | try { | ||
1302 | int _type = T__73; | ||
1303 | int _channel = DEFAULT_TOKEN_CHANNEL; | ||
1304 | // InternalSolverLanguage.g:69:7: ( 'abstract' ) | ||
1305 | // InternalSolverLanguage.g:69:9: 'abstract' | ||
1306 | { | ||
1307 | match("abstract"); | ||
1308 | |||
1309 | |||
1310 | } | ||
1311 | |||
1312 | state.type = _type; | ||
1313 | state.channel = _channel; | ||
1314 | } | ||
1315 | finally { | ||
1316 | } | ||
1317 | } | ||
1318 | // $ANTLR end "T__73" | ||
1319 | |||
1320 | // $ANTLR start "T__74" | ||
1321 | public final void mT__74() throws RecognitionException { | ||
1322 | try { | ||
1323 | int _type = T__74; | ||
1324 | int _channel = DEFAULT_TOKEN_CHANNEL; | ||
1325 | // InternalSolverLanguage.g:70:7: ( 'contains' ) | ||
1326 | // InternalSolverLanguage.g:70:9: 'contains' | ||
1327 | { | ||
1328 | match("contains"); | ||
1329 | |||
1330 | |||
1331 | } | ||
1332 | |||
1333 | state.type = _type; | ||
1334 | state.channel = _channel; | ||
1335 | } | ||
1336 | finally { | ||
1337 | } | ||
1338 | } | ||
1339 | // $ANTLR end "T__74" | ||
1340 | |||
1341 | // $ANTLR start "RULE_STRING" | ||
1342 | public final void mRULE_STRING() throws RecognitionException { | ||
1343 | try { | ||
1344 | int _type = RULE_STRING; | ||
1345 | int _channel = DEFAULT_TOKEN_CHANNEL; | ||
1346 | // InternalSolverLanguage.g:9118:13: ( '\"' ( '\\\\' . | ~ ( ( '\\\\' | '\"' ) ) )* '\"' ) | ||
1347 | // InternalSolverLanguage.g:9118:15: '\"' ( '\\\\' . | ~ ( ( '\\\\' | '\"' ) ) )* '\"' | ||
1348 | { | ||
1349 | match('\"'); | ||
1350 | // InternalSolverLanguage.g:9118:19: ( '\\\\' . | ~ ( ( '\\\\' | '\"' ) ) )* | ||
1351 | loop1: | ||
1352 | do { | ||
1353 | int alt1=3; | ||
1354 | int LA1_0 = input.LA(1); | ||
1355 | |||
1356 | if ( (LA1_0=='\\') ) { | ||
1357 | alt1=1; | ||
1358 | } | ||
1359 | else if ( ((LA1_0>='\u0000' && LA1_0<='!')||(LA1_0>='#' && LA1_0<='[')||(LA1_0>=']' && LA1_0<='\uFFFF')) ) { | ||
1360 | alt1=2; | ||
1361 | } | ||
1362 | |||
1363 | |||
1364 | switch (alt1) { | ||
1365 | case 1 : | ||
1366 | // InternalSolverLanguage.g:9118:20: '\\\\' . | ||
1367 | { | ||
1368 | match('\\'); | ||
1369 | matchAny(); | ||
1370 | |||
1371 | } | ||
1372 | break; | ||
1373 | case 2 : | ||
1374 | // InternalSolverLanguage.g:9118:27: ~ ( ( '\\\\' | '\"' ) ) | ||
1375 | { | ||
1376 | if ( (input.LA(1)>='\u0000' && input.LA(1)<='!')||(input.LA(1)>='#' && input.LA(1)<='[')||(input.LA(1)>=']' && input.LA(1)<='\uFFFF') ) { | ||
1377 | input.consume(); | ||
1378 | |||
1379 | } | ||
1380 | else { | ||
1381 | MismatchedSetException mse = new MismatchedSetException(null,input); | ||
1382 | recover(mse); | ||
1383 | throw mse;} | ||
1384 | |||
1385 | |||
1386 | } | ||
1387 | break; | ||
1388 | |||
1389 | default : | ||
1390 | break loop1; | ||
1391 | } | ||
1392 | } while (true); | ||
1393 | |||
1394 | match('\"'); | ||
1395 | |||
1396 | } | ||
1397 | |||
1398 | state.type = _type; | ||
1399 | state.channel = _channel; | ||
1400 | } | ||
1401 | finally { | ||
1402 | } | ||
1403 | } | ||
1404 | // $ANTLR end "RULE_STRING" | ||
1405 | |||
1406 | // $ANTLR start "RULE_QUOTED_ID" | ||
1407 | public final void mRULE_QUOTED_ID() throws RecognitionException { | ||
1408 | try { | ||
1409 | int _type = RULE_QUOTED_ID; | ||
1410 | int _channel = DEFAULT_TOKEN_CHANNEL; | ||
1411 | // InternalSolverLanguage.g:9120:16: ( '\\'' ( '\\\\' . | ~ ( ( '\\\\' | '\\'' ) ) )* '\\'' ) | ||
1412 | // InternalSolverLanguage.g:9120:18: '\\'' ( '\\\\' . | ~ ( ( '\\\\' | '\\'' ) ) )* '\\'' | ||
1413 | { | ||
1414 | match('\''); | ||
1415 | // InternalSolverLanguage.g:9120:23: ( '\\\\' . | ~ ( ( '\\\\' | '\\'' ) ) )* | ||
1416 | loop2: | ||
1417 | do { | ||
1418 | int alt2=3; | ||
1419 | int LA2_0 = input.LA(1); | ||
1420 | |||
1421 | if ( (LA2_0=='\\') ) { | ||
1422 | alt2=1; | ||
1423 | } | ||
1424 | else if ( ((LA2_0>='\u0000' && LA2_0<='&')||(LA2_0>='(' && LA2_0<='[')||(LA2_0>=']' && LA2_0<='\uFFFF')) ) { | ||
1425 | alt2=2; | ||
1426 | } | ||
1427 | |||
1428 | |||
1429 | switch (alt2) { | ||
1430 | case 1 : | ||
1431 | // InternalSolverLanguage.g:9120:24: '\\\\' . | ||
1432 | { | ||
1433 | match('\\'); | ||
1434 | matchAny(); | ||
1435 | |||
1436 | } | ||
1437 | break; | ||
1438 | case 2 : | ||
1439 | // InternalSolverLanguage.g:9120:31: ~ ( ( '\\\\' | '\\'' ) ) | ||
1440 | { | ||
1441 | if ( (input.LA(1)>='\u0000' && input.LA(1)<='&')||(input.LA(1)>='(' && input.LA(1)<='[')||(input.LA(1)>=']' && input.LA(1)<='\uFFFF') ) { | ||
1442 | input.consume(); | ||
1443 | |||
1444 | } | ||
1445 | else { | ||
1446 | MismatchedSetException mse = new MismatchedSetException(null,input); | ||
1447 | recover(mse); | ||
1448 | throw mse;} | ||
1449 | |||
1450 | |||
1451 | } | ||
1452 | break; | ||
1453 | |||
1454 | default : | ||
1455 | break loop2; | ||
1456 | } | ||
1457 | } while (true); | ||
1458 | |||
1459 | match('\''); | ||
1460 | |||
1461 | } | ||
1462 | |||
1463 | state.type = _type; | ||
1464 | state.channel = _channel; | ||
1465 | } | ||
1466 | finally { | ||
1467 | } | ||
1468 | } | ||
1469 | // $ANTLR end "RULE_QUOTED_ID" | ||
1470 | |||
1471 | // $ANTLR start "RULE_PLUS" | ||
1472 | public final void mRULE_PLUS() throws RecognitionException { | ||
1473 | try { | ||
1474 | int _type = RULE_PLUS; | ||
1475 | int _channel = DEFAULT_TOKEN_CHANNEL; | ||
1476 | // InternalSolverLanguage.g:9122:11: ( 'synthetic::plus' ) | ||
1477 | // InternalSolverLanguage.g:9122:13: 'synthetic::plus' | ||
1478 | { | ||
1479 | match("synthetic::plus"); | ||
1480 | |||
1481 | |||
1482 | } | ||
1483 | |||
1484 | state.type = _type; | ||
1485 | state.channel = _channel; | ||
1486 | } | ||
1487 | finally { | ||
1488 | } | ||
1489 | } | ||
1490 | // $ANTLR end "RULE_PLUS" | ||
1491 | |||
1492 | // $ANTLR start "RULE_STAR" | ||
1493 | public final void mRULE_STAR() throws RecognitionException { | ||
1494 | try { | ||
1495 | int _type = RULE_STAR; | ||
1496 | int _channel = DEFAULT_TOKEN_CHANNEL; | ||
1497 | // InternalSolverLanguage.g:9124:11: ( 'synthetic::star' ) | ||
1498 | // InternalSolverLanguage.g:9124:13: 'synthetic::star' | ||
1499 | { | ||
1500 | match("synthetic::star"); | ||
1501 | |||
1502 | |||
1503 | } | ||
1504 | |||
1505 | state.type = _type; | ||
1506 | state.channel = _channel; | ||
1507 | } | ||
1508 | finally { | ||
1509 | } | ||
1510 | } | ||
1511 | // $ANTLR end "RULE_STAR" | ||
1512 | |||
1513 | // $ANTLR start "RULE_DOT" | ||
1514 | public final void mRULE_DOT() throws RecognitionException { | ||
1515 | try { | ||
1516 | int _type = RULE_DOT; | ||
1517 | int _channel = DEFAULT_TOKEN_CHANNEL; | ||
1518 | // InternalSolverLanguage.g:9126:10: ( 'synthetic::dot' ) | ||
1519 | // InternalSolverLanguage.g:9126:12: 'synthetic::dot' | ||
1520 | { | ||
1521 | match("synthetic::dot"); | ||
1522 | |||
1523 | |||
1524 | } | ||
1525 | |||
1526 | state.type = _type; | ||
1527 | state.channel = _channel; | ||
1528 | } | ||
1529 | finally { | ||
1530 | } | ||
1531 | } | ||
1532 | // $ANTLR end "RULE_DOT" | ||
1533 | |||
1534 | // $ANTLR start "RULE_ID" | ||
1535 | public final void mRULE_ID() throws RecognitionException { | ||
1536 | try { | ||
1537 | int _type = RULE_ID; | ||
1538 | int _channel = DEFAULT_TOKEN_CHANNEL; | ||
1539 | // InternalSolverLanguage.g:9128:9: ( ( '^' )? ( 'a' .. 'z' | 'A' .. 'Z' | '_' ) ( 'a' .. 'z' | 'A' .. 'Z' | '_' | '0' .. '9' )* ) | ||
1540 | // InternalSolverLanguage.g:9128:11: ( '^' )? ( 'a' .. 'z' | 'A' .. 'Z' | '_' ) ( 'a' .. 'z' | 'A' .. 'Z' | '_' | '0' .. '9' )* | ||
1541 | { | ||
1542 | // InternalSolverLanguage.g:9128:11: ( '^' )? | ||
1543 | int alt3=2; | ||
1544 | int LA3_0 = input.LA(1); | ||
1545 | |||
1546 | if ( (LA3_0=='^') ) { | ||
1547 | alt3=1; | ||
1548 | } | ||
1549 | switch (alt3) { | ||
1550 | case 1 : | ||
1551 | // InternalSolverLanguage.g:9128:11: '^' | ||
1552 | { | ||
1553 | match('^'); | ||
1554 | |||
1555 | } | ||
1556 | break; | ||
1557 | |||
1558 | } | ||
1559 | |||
1560 | if ( (input.LA(1)>='A' && input.LA(1)<='Z')||input.LA(1)=='_'||(input.LA(1)>='a' && input.LA(1)<='z') ) { | ||
1561 | input.consume(); | ||
1562 | |||
1563 | } | ||
1564 | else { | ||
1565 | MismatchedSetException mse = new MismatchedSetException(null,input); | ||
1566 | recover(mse); | ||
1567 | throw mse;} | ||
1568 | |||
1569 | // InternalSolverLanguage.g:9128:40: ( 'a' .. 'z' | 'A' .. 'Z' | '_' | '0' .. '9' )* | ||
1570 | loop4: | ||
1571 | do { | ||
1572 | int alt4=2; | ||
1573 | int LA4_0 = input.LA(1); | ||
1574 | |||
1575 | if ( ((LA4_0>='0' && LA4_0<='9')||(LA4_0>='A' && LA4_0<='Z')||LA4_0=='_'||(LA4_0>='a' && LA4_0<='z')) ) { | ||
1576 | alt4=1; | ||
1577 | } | ||
1578 | |||
1579 | |||
1580 | switch (alt4) { | ||
1581 | case 1 : | ||
1582 | // InternalSolverLanguage.g: | ||
1583 | { | ||
1584 | if ( (input.LA(1)>='0' && input.LA(1)<='9')||(input.LA(1)>='A' && input.LA(1)<='Z')||input.LA(1)=='_'||(input.LA(1)>='a' && input.LA(1)<='z') ) { | ||
1585 | input.consume(); | ||
1586 | |||
1587 | } | ||
1588 | else { | ||
1589 | MismatchedSetException mse = new MismatchedSetException(null,input); | ||
1590 | recover(mse); | ||
1591 | throw mse;} | ||
1592 | |||
1593 | |||
1594 | } | ||
1595 | break; | ||
1596 | |||
1597 | default : | ||
1598 | break loop4; | ||
1599 | } | ||
1600 | } while (true); | ||
1601 | |||
1602 | |||
1603 | } | ||
1604 | |||
1605 | state.type = _type; | ||
1606 | state.channel = _channel; | ||
1607 | } | ||
1608 | finally { | ||
1609 | } | ||
1610 | } | ||
1611 | // $ANTLR end "RULE_ID" | ||
1612 | |||
1613 | // $ANTLR start "RULE_INT" | ||
1614 | public final void mRULE_INT() throws RecognitionException { | ||
1615 | try { | ||
1616 | int _type = RULE_INT; | ||
1617 | int _channel = DEFAULT_TOKEN_CHANNEL; | ||
1618 | // InternalSolverLanguage.g:9130:10: ( ( '0' .. '9' )+ ) | ||
1619 | // InternalSolverLanguage.g:9130:12: ( '0' .. '9' )+ | ||
1620 | { | ||
1621 | // InternalSolverLanguage.g:9130:12: ( '0' .. '9' )+ | ||
1622 | int cnt5=0; | ||
1623 | loop5: | ||
1624 | do { | ||
1625 | int alt5=2; | ||
1626 | int LA5_0 = input.LA(1); | ||
1627 | |||
1628 | if ( ((LA5_0>='0' && LA5_0<='9')) ) { | ||
1629 | alt5=1; | ||
1630 | } | ||
1631 | |||
1632 | |||
1633 | switch (alt5) { | ||
1634 | case 1 : | ||
1635 | // InternalSolverLanguage.g:9130:13: '0' .. '9' | ||
1636 | { | ||
1637 | matchRange('0','9'); | ||
1638 | |||
1639 | } | ||
1640 | break; | ||
1641 | |||
1642 | default : | ||
1643 | if ( cnt5 >= 1 ) break loop5; | ||
1644 | EarlyExitException eee = | ||
1645 | new EarlyExitException(5, input); | ||
1646 | throw eee; | ||
1647 | } | ||
1648 | cnt5++; | ||
1649 | } while (true); | ||
1650 | |||
1651 | |||
1652 | } | ||
1653 | |||
1654 | state.type = _type; | ||
1655 | state.channel = _channel; | ||
1656 | } | ||
1657 | finally { | ||
1658 | } | ||
1659 | } | ||
1660 | // $ANTLR end "RULE_INT" | ||
1661 | |||
1662 | // $ANTLR start "RULE_ML_COMMENT" | ||
1663 | public final void mRULE_ML_COMMENT() throws RecognitionException { | ||
1664 | try { | ||
1665 | int _type = RULE_ML_COMMENT; | ||
1666 | int _channel = DEFAULT_TOKEN_CHANNEL; | ||
1667 | // InternalSolverLanguage.g:9132:17: ( '/*' ( options {greedy=false; } : . )* '*/' ) | ||
1668 | // InternalSolverLanguage.g:9132:19: '/*' ( options {greedy=false; } : . )* '*/' | ||
1669 | { | ||
1670 | match("/*"); | ||
1671 | |||
1672 | // InternalSolverLanguage.g:9132:24: ( options {greedy=false; } : . )* | ||
1673 | loop6: | ||
1674 | do { | ||
1675 | int alt6=2; | ||
1676 | int LA6_0 = input.LA(1); | ||
1677 | |||
1678 | if ( (LA6_0=='*') ) { | ||
1679 | int LA6_1 = input.LA(2); | ||
1680 | |||
1681 | if ( (LA6_1=='/') ) { | ||
1682 | alt6=2; | ||
1683 | } | ||
1684 | else if ( ((LA6_1>='\u0000' && LA6_1<='.')||(LA6_1>='0' && LA6_1<='\uFFFF')) ) { | ||
1685 | alt6=1; | ||
1686 | } | ||
1687 | |||
1688 | |||
1689 | } | ||
1690 | else if ( ((LA6_0>='\u0000' && LA6_0<=')')||(LA6_0>='+' && LA6_0<='\uFFFF')) ) { | ||
1691 | alt6=1; | ||
1692 | } | ||
1693 | |||
1694 | |||
1695 | switch (alt6) { | ||
1696 | case 1 : | ||
1697 | // InternalSolverLanguage.g:9132:52: . | ||
1698 | { | ||
1699 | matchAny(); | ||
1700 | |||
1701 | } | ||
1702 | break; | ||
1703 | |||
1704 | default : | ||
1705 | break loop6; | ||
1706 | } | ||
1707 | } while (true); | ||
1708 | |||
1709 | match("*/"); | ||
1710 | |||
1711 | |||
1712 | } | ||
1713 | |||
1714 | state.type = _type; | ||
1715 | state.channel = _channel; | ||
1716 | } | ||
1717 | finally { | ||
1718 | } | ||
1719 | } | ||
1720 | // $ANTLR end "RULE_ML_COMMENT" | ||
1721 | |||
1722 | // $ANTLR start "RULE_SL_COMMENT" | ||
1723 | public final void mRULE_SL_COMMENT() throws RecognitionException { | ||
1724 | try { | ||
1725 | int _type = RULE_SL_COMMENT; | ||
1726 | int _channel = DEFAULT_TOKEN_CHANNEL; | ||
1727 | // InternalSolverLanguage.g:9134:17: ( '//' (~ ( ( '\\n' | '\\r' ) ) )* ( ( '\\r' )? '\\n' )? ) | ||
1728 | // InternalSolverLanguage.g:9134:19: '//' (~ ( ( '\\n' | '\\r' ) ) )* ( ( '\\r' )? '\\n' )? | ||
1729 | { | ||
1730 | match("//"); | ||
1731 | |||
1732 | // InternalSolverLanguage.g:9134:24: (~ ( ( '\\n' | '\\r' ) ) )* | ||
1733 | loop7: | ||
1734 | do { | ||
1735 | int alt7=2; | ||
1736 | int LA7_0 = input.LA(1); | ||
1737 | |||
1738 | if ( ((LA7_0>='\u0000' && LA7_0<='\t')||(LA7_0>='\u000B' && LA7_0<='\f')||(LA7_0>='\u000E' && LA7_0<='\uFFFF')) ) { | ||
1739 | alt7=1; | ||
1740 | } | ||
1741 | |||
1742 | |||
1743 | switch (alt7) { | ||
1744 | case 1 : | ||
1745 | // InternalSolverLanguage.g:9134:24: ~ ( ( '\\n' | '\\r' ) ) | ||
1746 | { | ||
1747 | 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') ) { | ||
1748 | input.consume(); | ||
1749 | |||
1750 | } | ||
1751 | else { | ||
1752 | MismatchedSetException mse = new MismatchedSetException(null,input); | ||
1753 | recover(mse); | ||
1754 | throw mse;} | ||
1755 | |||
1756 | |||
1757 | } | ||
1758 | break; | ||
1759 | |||
1760 | default : | ||
1761 | break loop7; | ||
1762 | } | ||
1763 | } while (true); | ||
1764 | |||
1765 | // InternalSolverLanguage.g:9134:40: ( ( '\\r' )? '\\n' )? | ||
1766 | int alt9=2; | ||
1767 | int LA9_0 = input.LA(1); | ||
1768 | |||
1769 | if ( (LA9_0=='\n'||LA9_0=='\r') ) { | ||
1770 | alt9=1; | ||
1771 | } | ||
1772 | switch (alt9) { | ||
1773 | case 1 : | ||
1774 | // InternalSolverLanguage.g:9134:41: ( '\\r' )? '\\n' | ||
1775 | { | ||
1776 | // InternalSolverLanguage.g:9134:41: ( '\\r' )? | ||
1777 | int alt8=2; | ||
1778 | int LA8_0 = input.LA(1); | ||
1779 | |||
1780 | if ( (LA8_0=='\r') ) { | ||
1781 | alt8=1; | ||
1782 | } | ||
1783 | switch (alt8) { | ||
1784 | case 1 : | ||
1785 | // InternalSolverLanguage.g:9134:41: '\\r' | ||
1786 | { | ||
1787 | match('\r'); | ||
1788 | |||
1789 | } | ||
1790 | break; | ||
1791 | |||
1792 | } | ||
1793 | |||
1794 | match('\n'); | ||
1795 | |||
1796 | } | ||
1797 | break; | ||
1798 | |||
1799 | } | ||
1800 | |||
1801 | |||
1802 | } | ||
1803 | |||
1804 | state.type = _type; | ||
1805 | state.channel = _channel; | ||
1806 | } | ||
1807 | finally { | ||
1808 | } | ||
1809 | } | ||
1810 | // $ANTLR end "RULE_SL_COMMENT" | ||
1811 | |||
1812 | // $ANTLR start "RULE_WS" | ||
1813 | public final void mRULE_WS() throws RecognitionException { | ||
1814 | try { | ||
1815 | int _type = RULE_WS; | ||
1816 | int _channel = DEFAULT_TOKEN_CHANNEL; | ||
1817 | // InternalSolverLanguage.g:9136:9: ( ( ' ' | '\\t' | '\\r' | '\\n' )+ ) | ||
1818 | // InternalSolverLanguage.g:9136:11: ( ' ' | '\\t' | '\\r' | '\\n' )+ | ||
1819 | { | ||
1820 | // InternalSolverLanguage.g:9136:11: ( ' ' | '\\t' | '\\r' | '\\n' )+ | ||
1821 | int cnt10=0; | ||
1822 | loop10: | ||
1823 | do { | ||
1824 | int alt10=2; | ||
1825 | int LA10_0 = input.LA(1); | ||
1826 | |||
1827 | if ( ((LA10_0>='\t' && LA10_0<='\n')||LA10_0=='\r'||LA10_0==' ') ) { | ||
1828 | alt10=1; | ||
1829 | } | ||
1830 | |||
1831 | |||
1832 | switch (alt10) { | ||
1833 | case 1 : | ||
1834 | // InternalSolverLanguage.g: | ||
1835 | { | ||
1836 | if ( (input.LA(1)>='\t' && input.LA(1)<='\n')||input.LA(1)=='\r'||input.LA(1)==' ' ) { | ||
1837 | input.consume(); | ||
1838 | |||
1839 | } | ||
1840 | else { | ||
1841 | MismatchedSetException mse = new MismatchedSetException(null,input); | ||
1842 | recover(mse); | ||
1843 | throw mse;} | ||
1844 | |||
1845 | |||
1846 | } | ||
1847 | break; | ||
1848 | |||
1849 | default : | ||
1850 | if ( cnt10 >= 1 ) break loop10; | ||
1851 | EarlyExitException eee = | ||
1852 | new EarlyExitException(10, input); | ||
1853 | throw eee; | ||
1854 | } | ||
1855 | cnt10++; | ||
1856 | } while (true); | ||
1857 | |||
1858 | |||
1859 | } | ||
1860 | |||
1861 | state.type = _type; | ||
1862 | state.channel = _channel; | ||
1863 | } | ||
1864 | finally { | ||
1865 | } | ||
1866 | } | ||
1867 | // $ANTLR end "RULE_WS" | ||
1868 | |||
1869 | // $ANTLR start "RULE_ANY_OTHER" | ||
1870 | public final void mRULE_ANY_OTHER() throws RecognitionException { | ||
1871 | try { | ||
1872 | int _type = RULE_ANY_OTHER; | ||
1873 | int _channel = DEFAULT_TOKEN_CHANNEL; | ||
1874 | // InternalSolverLanguage.g:9138:16: ( . ) | ||
1875 | // InternalSolverLanguage.g:9138:18: . | ||
1876 | { | ||
1877 | matchAny(); | ||
1878 | |||
1879 | } | ||
1880 | |||
1881 | state.type = _type; | ||
1882 | state.channel = _channel; | ||
1883 | } | ||
1884 | finally { | ||
1885 | } | ||
1886 | } | ||
1887 | // $ANTLR end "RULE_ANY_OTHER" | ||
1888 | |||
1889 | public void mTokens() throws RecognitionException { | ||
1890 | // InternalSolverLanguage.g:1:8: ( 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 | RULE_STRING | RULE_QUOTED_ID | RULE_PLUS | RULE_STAR | RULE_DOT | RULE_ID | RULE_INT | RULE_ML_COMMENT | RULE_SL_COMMENT | RULE_WS | RULE_ANY_OTHER ) | ||
1891 | int alt11=71; | ||
1892 | alt11 = dfa11.predict(input); | ||
1893 | switch (alt11) { | ||
1894 | case 1 : | ||
1895 | // InternalSolverLanguage.g:1:10: T__15 | ||
1896 | { | ||
1897 | mT__15(); | ||
1898 | |||
1899 | } | ||
1900 | break; | ||
1901 | case 2 : | ||
1902 | // InternalSolverLanguage.g:1:16: T__16 | ||
1903 | { | ||
1904 | mT__16(); | ||
1905 | |||
1906 | } | ||
1907 | break; | ||
1908 | case 3 : | ||
1909 | // InternalSolverLanguage.g:1:22: T__17 | ||
1910 | { | ||
1911 | mT__17(); | ||
1912 | |||
1913 | } | ||
1914 | break; | ||
1915 | case 4 : | ||
1916 | // InternalSolverLanguage.g:1:28: T__18 | ||
1917 | { | ||
1918 | mT__18(); | ||
1919 | |||
1920 | } | ||
1921 | break; | ||
1922 | case 5 : | ||
1923 | // InternalSolverLanguage.g:1:34: T__19 | ||
1924 | { | ||
1925 | mT__19(); | ||
1926 | |||
1927 | } | ||
1928 | break; | ||
1929 | case 6 : | ||
1930 | // InternalSolverLanguage.g:1:40: T__20 | ||
1931 | { | ||
1932 | mT__20(); | ||
1933 | |||
1934 | } | ||
1935 | break; | ||
1936 | case 7 : | ||
1937 | // InternalSolverLanguage.g:1:46: T__21 | ||
1938 | { | ||
1939 | mT__21(); | ||
1940 | |||
1941 | } | ||
1942 | break; | ||
1943 | case 8 : | ||
1944 | // InternalSolverLanguage.g:1:52: T__22 | ||
1945 | { | ||
1946 | mT__22(); | ||
1947 | |||
1948 | } | ||
1949 | break; | ||
1950 | case 9 : | ||
1951 | // InternalSolverLanguage.g:1:58: T__23 | ||
1952 | { | ||
1953 | mT__23(); | ||
1954 | |||
1955 | } | ||
1956 | break; | ||
1957 | case 10 : | ||
1958 | // InternalSolverLanguage.g:1:64: T__24 | ||
1959 | { | ||
1960 | mT__24(); | ||
1961 | |||
1962 | } | ||
1963 | break; | ||
1964 | case 11 : | ||
1965 | // InternalSolverLanguage.g:1:70: T__25 | ||
1966 | { | ||
1967 | mT__25(); | ||
1968 | |||
1969 | } | ||
1970 | break; | ||
1971 | case 12 : | ||
1972 | // InternalSolverLanguage.g:1:76: T__26 | ||
1973 | { | ||
1974 | mT__26(); | ||
1975 | |||
1976 | } | ||
1977 | break; | ||
1978 | case 13 : | ||
1979 | // InternalSolverLanguage.g:1:82: T__27 | ||
1980 | { | ||
1981 | mT__27(); | ||
1982 | |||
1983 | } | ||
1984 | break; | ||
1985 | case 14 : | ||
1986 | // InternalSolverLanguage.g:1:88: T__28 | ||
1987 | { | ||
1988 | mT__28(); | ||
1989 | |||
1990 | } | ||
1991 | break; | ||
1992 | case 15 : | ||
1993 | // InternalSolverLanguage.g:1:94: T__29 | ||
1994 | { | ||
1995 | mT__29(); | ||
1996 | |||
1997 | } | ||
1998 | break; | ||
1999 | case 16 : | ||
2000 | // InternalSolverLanguage.g:1:100: T__30 | ||
2001 | { | ||
2002 | mT__30(); | ||
2003 | |||
2004 | } | ||
2005 | break; | ||
2006 | case 17 : | ||
2007 | // InternalSolverLanguage.g:1:106: T__31 | ||
2008 | { | ||
2009 | mT__31(); | ||
2010 | |||
2011 | } | ||
2012 | break; | ||
2013 | case 18 : | ||
2014 | // InternalSolverLanguage.g:1:112: T__32 | ||
2015 | { | ||
2016 | mT__32(); | ||
2017 | |||
2018 | } | ||
2019 | break; | ||
2020 | case 19 : | ||
2021 | // InternalSolverLanguage.g:1:118: T__33 | ||
2022 | { | ||
2023 | mT__33(); | ||
2024 | |||
2025 | } | ||
2026 | break; | ||
2027 | case 20 : | ||
2028 | // InternalSolverLanguage.g:1:124: T__34 | ||
2029 | { | ||
2030 | mT__34(); | ||
2031 | |||
2032 | } | ||
2033 | break; | ||
2034 | case 21 : | ||
2035 | // InternalSolverLanguage.g:1:130: T__35 | ||
2036 | { | ||
2037 | mT__35(); | ||
2038 | |||
2039 | } | ||
2040 | break; | ||
2041 | case 22 : | ||
2042 | // InternalSolverLanguage.g:1:136: T__36 | ||
2043 | { | ||
2044 | mT__36(); | ||
2045 | |||
2046 | } | ||
2047 | break; | ||
2048 | case 23 : | ||
2049 | // InternalSolverLanguage.g:1:142: T__37 | ||
2050 | { | ||
2051 | mT__37(); | ||
2052 | |||
2053 | } | ||
2054 | break; | ||
2055 | case 24 : | ||
2056 | // InternalSolverLanguage.g:1:148: T__38 | ||
2057 | { | ||
2058 | mT__38(); | ||
2059 | |||
2060 | } | ||
2061 | break; | ||
2062 | case 25 : | ||
2063 | // InternalSolverLanguage.g:1:154: T__39 | ||
2064 | { | ||
2065 | mT__39(); | ||
2066 | |||
2067 | } | ||
2068 | break; | ||
2069 | case 26 : | ||
2070 | // InternalSolverLanguage.g:1:160: T__40 | ||
2071 | { | ||
2072 | mT__40(); | ||
2073 | |||
2074 | } | ||
2075 | break; | ||
2076 | case 27 : | ||
2077 | // InternalSolverLanguage.g:1:166: T__41 | ||
2078 | { | ||
2079 | mT__41(); | ||
2080 | |||
2081 | } | ||
2082 | break; | ||
2083 | case 28 : | ||
2084 | // InternalSolverLanguage.g:1:172: T__42 | ||
2085 | { | ||
2086 | mT__42(); | ||
2087 | |||
2088 | } | ||
2089 | break; | ||
2090 | case 29 : | ||
2091 | // InternalSolverLanguage.g:1:178: T__43 | ||
2092 | { | ||
2093 | mT__43(); | ||
2094 | |||
2095 | } | ||
2096 | break; | ||
2097 | case 30 : | ||
2098 | // InternalSolverLanguage.g:1:184: T__44 | ||
2099 | { | ||
2100 | mT__44(); | ||
2101 | |||
2102 | } | ||
2103 | break; | ||
2104 | case 31 : | ||
2105 | // InternalSolverLanguage.g:1:190: T__45 | ||
2106 | { | ||
2107 | mT__45(); | ||
2108 | |||
2109 | } | ||
2110 | break; | ||
2111 | case 32 : | ||
2112 | // InternalSolverLanguage.g:1:196: T__46 | ||
2113 | { | ||
2114 | mT__46(); | ||
2115 | |||
2116 | } | ||
2117 | break; | ||
2118 | case 33 : | ||
2119 | // InternalSolverLanguage.g:1:202: T__47 | ||
2120 | { | ||
2121 | mT__47(); | ||
2122 | |||
2123 | } | ||
2124 | break; | ||
2125 | case 34 : | ||
2126 | // InternalSolverLanguage.g:1:208: T__48 | ||
2127 | { | ||
2128 | mT__48(); | ||
2129 | |||
2130 | } | ||
2131 | break; | ||
2132 | case 35 : | ||
2133 | // InternalSolverLanguage.g:1:214: T__49 | ||
2134 | { | ||
2135 | mT__49(); | ||
2136 | |||
2137 | } | ||
2138 | break; | ||
2139 | case 36 : | ||
2140 | // InternalSolverLanguage.g:1:220: T__50 | ||
2141 | { | ||
2142 | mT__50(); | ||
2143 | |||
2144 | } | ||
2145 | break; | ||
2146 | case 37 : | ||
2147 | // InternalSolverLanguage.g:1:226: T__51 | ||
2148 | { | ||
2149 | mT__51(); | ||
2150 | |||
2151 | } | ||
2152 | break; | ||
2153 | case 38 : | ||
2154 | // InternalSolverLanguage.g:1:232: T__52 | ||
2155 | { | ||
2156 | mT__52(); | ||
2157 | |||
2158 | } | ||
2159 | break; | ||
2160 | case 39 : | ||
2161 | // InternalSolverLanguage.g:1:238: T__53 | ||
2162 | { | ||
2163 | mT__53(); | ||
2164 | |||
2165 | } | ||
2166 | break; | ||
2167 | case 40 : | ||
2168 | // InternalSolverLanguage.g:1:244: T__54 | ||
2169 | { | ||
2170 | mT__54(); | ||
2171 | |||
2172 | } | ||
2173 | break; | ||
2174 | case 41 : | ||
2175 | // InternalSolverLanguage.g:1:250: T__55 | ||
2176 | { | ||
2177 | mT__55(); | ||
2178 | |||
2179 | } | ||
2180 | break; | ||
2181 | case 42 : | ||
2182 | // InternalSolverLanguage.g:1:256: T__56 | ||
2183 | { | ||
2184 | mT__56(); | ||
2185 | |||
2186 | } | ||
2187 | break; | ||
2188 | case 43 : | ||
2189 | // InternalSolverLanguage.g:1:262: T__57 | ||
2190 | { | ||
2191 | mT__57(); | ||
2192 | |||
2193 | } | ||
2194 | break; | ||
2195 | case 44 : | ||
2196 | // InternalSolverLanguage.g:1:268: T__58 | ||
2197 | { | ||
2198 | mT__58(); | ||
2199 | |||
2200 | } | ||
2201 | break; | ||
2202 | case 45 : | ||
2203 | // InternalSolverLanguage.g:1:274: T__59 | ||
2204 | { | ||
2205 | mT__59(); | ||
2206 | |||
2207 | } | ||
2208 | break; | ||
2209 | case 46 : | ||
2210 | // InternalSolverLanguage.g:1:280: T__60 | ||
2211 | { | ||
2212 | mT__60(); | ||
2213 | |||
2214 | } | ||
2215 | break; | ||
2216 | case 47 : | ||
2217 | // InternalSolverLanguage.g:1:286: T__61 | ||
2218 | { | ||
2219 | mT__61(); | ||
2220 | |||
2221 | } | ||
2222 | break; | ||
2223 | case 48 : | ||
2224 | // InternalSolverLanguage.g:1:292: T__62 | ||
2225 | { | ||
2226 | mT__62(); | ||
2227 | |||
2228 | } | ||
2229 | break; | ||
2230 | case 49 : | ||
2231 | // InternalSolverLanguage.g:1:298: T__63 | ||
2232 | { | ||
2233 | mT__63(); | ||
2234 | |||
2235 | } | ||
2236 | break; | ||
2237 | case 50 : | ||
2238 | // InternalSolverLanguage.g:1:304: T__64 | ||
2239 | { | ||
2240 | mT__64(); | ||
2241 | |||
2242 | } | ||
2243 | break; | ||
2244 | case 51 : | ||
2245 | // InternalSolverLanguage.g:1:310: T__65 | ||
2246 | { | ||
2247 | mT__65(); | ||
2248 | |||
2249 | } | ||
2250 | break; | ||
2251 | case 52 : | ||
2252 | // InternalSolverLanguage.g:1:316: T__66 | ||
2253 | { | ||
2254 | mT__66(); | ||
2255 | |||
2256 | } | ||
2257 | break; | ||
2258 | case 53 : | ||
2259 | // InternalSolverLanguage.g:1:322: T__67 | ||
2260 | { | ||
2261 | mT__67(); | ||
2262 | |||
2263 | } | ||
2264 | break; | ||
2265 | case 54 : | ||
2266 | // InternalSolverLanguage.g:1:328: T__68 | ||
2267 | { | ||
2268 | mT__68(); | ||
2269 | |||
2270 | } | ||
2271 | break; | ||
2272 | case 55 : | ||
2273 | // InternalSolverLanguage.g:1:334: T__69 | ||
2274 | { | ||
2275 | mT__69(); | ||
2276 | |||
2277 | } | ||
2278 | break; | ||
2279 | case 56 : | ||
2280 | // InternalSolverLanguage.g:1:340: T__70 | ||
2281 | { | ||
2282 | mT__70(); | ||
2283 | |||
2284 | } | ||
2285 | break; | ||
2286 | case 57 : | ||
2287 | // InternalSolverLanguage.g:1:346: T__71 | ||
2288 | { | ||
2289 | mT__71(); | ||
2290 | |||
2291 | } | ||
2292 | break; | ||
2293 | case 58 : | ||
2294 | // InternalSolverLanguage.g:1:352: T__72 | ||
2295 | { | ||
2296 | mT__72(); | ||
2297 | |||
2298 | } | ||
2299 | break; | ||
2300 | case 59 : | ||
2301 | // InternalSolverLanguage.g:1:358: T__73 | ||
2302 | { | ||
2303 | mT__73(); | ||
2304 | |||
2305 | } | ||
2306 | break; | ||
2307 | case 60 : | ||
2308 | // InternalSolverLanguage.g:1:364: T__74 | ||
2309 | { | ||
2310 | mT__74(); | ||
2311 | |||
2312 | } | ||
2313 | break; | ||
2314 | case 61 : | ||
2315 | // InternalSolverLanguage.g:1:370: RULE_STRING | ||
2316 | { | ||
2317 | mRULE_STRING(); | ||
2318 | |||
2319 | } | ||
2320 | break; | ||
2321 | case 62 : | ||
2322 | // InternalSolverLanguage.g:1:382: RULE_QUOTED_ID | ||
2323 | { | ||
2324 | mRULE_QUOTED_ID(); | ||
2325 | |||
2326 | } | ||
2327 | break; | ||
2328 | case 63 : | ||
2329 | // InternalSolverLanguage.g:1:397: RULE_PLUS | ||
2330 | { | ||
2331 | mRULE_PLUS(); | ||
2332 | |||
2333 | } | ||
2334 | break; | ||
2335 | case 64 : | ||
2336 | // InternalSolverLanguage.g:1:407: RULE_STAR | ||
2337 | { | ||
2338 | mRULE_STAR(); | ||
2339 | |||
2340 | } | ||
2341 | break; | ||
2342 | case 65 : | ||
2343 | // InternalSolverLanguage.g:1:417: RULE_DOT | ||
2344 | { | ||
2345 | mRULE_DOT(); | ||
2346 | |||
2347 | } | ||
2348 | break; | ||
2349 | case 66 : | ||
2350 | // InternalSolverLanguage.g:1:426: RULE_ID | ||
2351 | { | ||
2352 | mRULE_ID(); | ||
2353 | |||
2354 | } | ||
2355 | break; | ||
2356 | case 67 : | ||
2357 | // InternalSolverLanguage.g:1:434: RULE_INT | ||
2358 | { | ||
2359 | mRULE_INT(); | ||
2360 | |||
2361 | } | ||
2362 | break; | ||
2363 | case 68 : | ||
2364 | // InternalSolverLanguage.g:1:443: RULE_ML_COMMENT | ||
2365 | { | ||
2366 | mRULE_ML_COMMENT(); | ||
2367 | |||
2368 | } | ||
2369 | break; | ||
2370 | case 69 : | ||
2371 | // InternalSolverLanguage.g:1:459: RULE_SL_COMMENT | ||
2372 | { | ||
2373 | mRULE_SL_COMMENT(); | ||
2374 | |||
2375 | } | ||
2376 | break; | ||
2377 | case 70 : | ||
2378 | // InternalSolverLanguage.g:1:475: RULE_WS | ||
2379 | { | ||
2380 | mRULE_WS(); | ||
2381 | |||
2382 | } | ||
2383 | break; | ||
2384 | case 71 : | ||
2385 | // InternalSolverLanguage.g:1:483: RULE_ANY_OTHER | ||
2386 | { | ||
2387 | mRULE_ANY_OTHER(); | ||
2388 | |||
2389 | } | ||
2390 | break; | ||
2391 | |||
2392 | } | ||
2393 | |||
2394 | } | ||
2395 | |||
2396 | |||
2397 | protected DFA11 dfa11 = new DFA11(this); | ||
2398 | static final String DFA11_eotS = | ||
2399 | "\1\uffff\1\50\1\uffff\2\51\1\57\1\61\1\63\1\65\1\uffff\1\70\1\73\12\51\1\124\1\51\1\127\11\uffff\2\47\7\uffff\1\147\1\150\1\51\16\uffff\27\51\2\uffff\1\51\17\uffff\1\u0084\1\u0085\2\uffff\1\51\1\u0087\1\u0089\1\51\1\u008c\6\51\1\u0093\3\51\1\u0097\13\51\2\uffff\1\u00a3\1\uffff\1\51\1\uffff\1\u00a5\1\51\1\uffff\4\51\1\u00ab\1\51\1\uffff\2\51\1\u00af\1\uffff\1\51\1\u00b1\1\u00b2\5\51\1\u00b9\2\51\1\uffff\1\51\1\uffff\2\51\1\u00bf\1\51\1\u00c1\1\uffff\1\51\1\u00c3\1\51\1\uffff\1\51\2\uffff\1\u00c6\2\51\1\u00c9\2\51\1\uffff\1\u00cc\4\51\1\uffff\1\51\1\uffff\1\51\1\uffff\2\51\1\uffff\2\51\1\uffff\1\u00d7\1\51\1\uffff\3\51\1\u00dc\5\51\1\u00e2\1\uffff\1\u00e3\1\u00e4\1\u00e5\1\u00e6\1\uffff\1\u00e7\1\u00e8\1\51\1\u00ea\1\51\7\uffff\1\51\1\uffff\1\51\1\uffff\1\u00ef\5\uffff"; | ||
2400 | static final String DFA11_eofS = | ||
2401 | "\u00f3\uffff"; | ||
2402 | static final String DFA11_minS = | ||
2403 | "\1\0\1\101\1\uffff\1\146\1\145\4\75\1\uffff\1\76\1\52\1\141\1\154\1\156\1\143\1\162\1\142\1\150\1\141\1\156\1\154\1\55\1\145\1\56\11\uffff\2\0\7\uffff\2\60\1\141\16\uffff\1\170\1\163\1\156\1\162\1\156\1\141\1\154\1\160\1\155\1\157\1\156\1\157\1\147\1\163\1\165\1\145\1\154\1\156\1\153\1\162\1\164\1\163\1\160\2\uffff\1\146\17\uffff\2\60\2\uffff\1\154\2\60\1\164\1\60\1\162\1\156\1\164\1\163\1\171\1\157\1\60\1\160\1\164\1\144\1\60\1\164\1\145\1\156\1\163\1\143\1\156\1\157\2\145\1\164\1\141\2\uffff\1\60\1\uffff\1\155\1\uffff\1\60\1\155\1\uffff\1\145\1\164\1\141\1\163\1\60\1\163\1\uffff\1\145\1\150\1\60\1\uffff\1\162\2\60\1\145\1\164\1\157\1\162\1\156\1\60\1\171\1\165\1\uffff\1\151\1\uffff\1\151\1\156\1\60\1\151\1\60\1\uffff\1\151\1\60\1\145\1\uffff\1\141\2\uffff\1\60\1\151\1\167\1\60\1\156\1\144\1\uffff\1\60\1\154\2\172\1\164\1\uffff\1\156\1\uffff\1\164\1\uffff\1\164\1\143\1\uffff\1\157\1\156\1\uffff\1\60\1\163\1\uffff\1\164\2\145\1\60\1\163\1\145\1\151\1\164\1\156\1\60\1\uffff\4\60\1\uffff\2\60\1\143\1\60\1\141\7\uffff\1\72\1\uffff\1\154\1\72\1\60\1\144\4\uffff"; | ||
2404 | static final String DFA11_maxS = | ||
2405 | "\1\uffff\1\172\1\uffff\1\156\1\145\4\75\1\uffff\1\76\1\57\2\165\1\160\1\171\1\162\1\166\1\162\1\165\1\156\1\170\1\55\1\145\1\56\11\uffff\2\uffff\7\uffff\2\172\1\141\16\uffff\1\171\1\163\1\156\1\162\1\165\1\141\1\154\1\160\1\155\1\157\1\156\1\157\1\147\1\163\1\165\1\145\1\154\1\156\1\153\1\162\1\164\1\163\1\160\2\uffff\1\146\17\uffff\2\172\2\uffff\1\154\2\172\1\164\1\172\1\162\1\156\1\164\1\163\1\171\1\157\1\172\1\160\1\164\1\144\1\172\1\164\1\145\1\156\1\163\1\143\1\156\1\157\2\145\1\164\1\141\2\uffff\1\172\1\uffff\1\155\1\uffff\1\172\1\155\1\uffff\1\145\1\164\1\141\1\163\1\172\1\163\1\uffff\1\145\1\150\1\172\1\uffff\1\162\2\172\1\145\1\164\1\157\2\162\1\172\1\171\1\165\1\uffff\1\151\1\uffff\1\151\1\156\1\172\1\151\1\172\1\uffff\1\151\1\172\1\145\1\uffff\1\141\2\uffff\1\172\1\151\1\167\1\172\1\156\1\144\1\uffff\1\172\1\154\2\172\1\164\1\uffff\1\156\1\uffff\1\164\1\uffff\1\164\1\143\1\uffff\1\157\1\156\1\uffff\1\172\1\163\1\uffff\1\164\2\145\1\172\1\163\1\145\1\151\1\164\1\156\1\172\1\uffff\4\172\1\uffff\2\172\1\143\1\172\1\141\7\uffff\1\72\1\uffff\1\154\1\72\1\172\1\163\4\uffff"; | ||
2406 | static final String DFA11_acceptS = | ||
2407 | "\2\uffff\1\2\6\uffff\1\14\17\uffff\1\50\1\52\1\54\1\55\1\56\1\57\1\60\1\61\1\63\2\uffff\1\102\1\103\1\106\1\107\1\1\1\102\1\2\3\uffff\1\5\1\41\1\6\1\17\1\10\1\7\1\12\1\11\1\14\1\51\1\15\1\104\1\105\1\16\27\uffff\1\40\1\37\1\uffff\1\62\1\44\1\50\1\52\1\54\1\55\1\56\1\57\1\60\1\61\1\63\1\75\1\76\1\103\1\106\2\uffff\1\13\1\45\33\uffff\1\3\1\64\1\uffff\1\20\1\uffff\1\30\2\uffff\1\27\6\uffff\1\24\3\uffff\1\26\13\uffff\1\4\1\uffff\1\21\5\uffff\1\23\3\uffff\1\25\1\uffff\1\31\1\46\6\uffff\1\47\5\uffff\1\53\1\uffff\1\66\1\uffff\1\71\2\uffff\1\32\2\uffff\1\34\2\uffff\1\65\12\uffff\1\43\4\uffff\1\22\5\uffff\1\33\1\67\1\42\1\36\1\35\1\74\1\70\1\uffff\1\73\4\uffff\1\72\1\77\1\100\1\101"; | ||
2408 | static final String DFA11_specialS = | ||
2409 | "\1\1\41\uffff\1\2\1\0\u00cf\uffff}>"; | ||
2410 | static final String[] DFA11_transitionS = { | ||
2411 | "\11\47\2\46\2\47\1\46\22\47\1\46\1\6\1\42\4\47\1\43\1\36\1\37\1\2\1\11\1\32\1\12\1\30\1\13\12\45\1\26\1\31\1\7\1\5\1\10\2\47\32\44\1\40\1\47\1\41\1\1\1\44\1\47\1\21\1\44\1\15\1\27\1\25\1\23\2\44\1\3\3\44\1\14\1\44\1\16\1\20\1\44\1\4\1\17\1\22\1\24\5\44\1\33\1\35\1\34\uff82\47", | ||
2412 | "\32\51\4\uffff\1\51\1\uffff\32\51", | ||
2413 | "", | ||
2414 | "\1\54\7\uffff\1\53", | ||
2415 | "\1\55", | ||
2416 | "\1\56", | ||
2417 | "\1\60", | ||
2418 | "\1\62", | ||
2419 | "\1\64", | ||
2420 | "", | ||
2421 | "\1\67", | ||
2422 | "\1\71\4\uffff\1\72", | ||
2423 | "\1\74\7\uffff\1\76\13\uffff\1\75", | ||
2424 | "\1\101\2\uffff\1\100\5\uffff\1\77", | ||
2425 | "\1\102\1\uffff\1\103", | ||
2426 | "\1\105\21\uffff\1\104\3\uffff\1\106", | ||
2427 | "\1\107", | ||
2428 | "\1\111\23\uffff\1\110", | ||
2429 | "\1\113\11\uffff\1\112", | ||
2430 | "\1\114\23\uffff\1\115", | ||
2431 | "\1\116", | ||
2432 | "\1\121\1\122\4\uffff\1\117\5\uffff\1\120", | ||
2433 | "\1\123", | ||
2434 | "\1\125", | ||
2435 | "\1\126", | ||
2436 | "", | ||
2437 | "", | ||
2438 | "", | ||
2439 | "", | ||
2440 | "", | ||
2441 | "", | ||
2442 | "", | ||
2443 | "", | ||
2444 | "", | ||
2445 | "\0\141", | ||
2446 | "\0\142", | ||
2447 | "", | ||
2448 | "", | ||
2449 | "", | ||
2450 | "", | ||
2451 | "", | ||
2452 | "", | ||
2453 | "", | ||
2454 | "\12\51\7\uffff\32\51\4\uffff\1\51\1\uffff\5\51\1\146\15\51\1\145\6\51", | ||
2455 | "\12\51\7\uffff\32\51\4\uffff\1\51\1\uffff\32\51", | ||
2456 | "\1\151", | ||
2457 | "", | ||
2458 | "", | ||
2459 | "", | ||
2460 | "", | ||
2461 | "", | ||
2462 | "", | ||
2463 | "", | ||
2464 | "", | ||
2465 | "", | ||
2466 | "", | ||
2467 | "", | ||
2468 | "", | ||
2469 | "", | ||
2470 | "", | ||
2471 | "\1\153\1\152", | ||
2472 | "\1\154", | ||
2473 | "\1\155", | ||
2474 | "\1\156", | ||
2475 | "\1\160\6\uffff\1\157", | ||
2476 | "\1\161", | ||
2477 | "\1\162", | ||
2478 | "\1\163", | ||
2479 | "\1\164", | ||
2480 | "\1\165", | ||
2481 | "\1\166", | ||
2482 | "\1\167", | ||
2483 | "\1\170", | ||
2484 | "\1\171", | ||
2485 | "\1\172", | ||
2486 | "\1\173", | ||
2487 | "\1\174", | ||
2488 | "\1\175", | ||
2489 | "\1\176", | ||
2490 | "\1\177", | ||
2491 | "\1\u0080", | ||
2492 | "\1\u0081", | ||
2493 | "\1\u0082", | ||
2494 | "", | ||
2495 | "", | ||
2496 | "\1\u0083", | ||
2497 | "", | ||
2498 | "", | ||
2499 | "", | ||
2500 | "", | ||
2501 | "", | ||
2502 | "", | ||
2503 | "", | ||
2504 | "", | ||
2505 | "", | ||
2506 | "", | ||
2507 | "", | ||
2508 | "", | ||
2509 | "", | ||
2510 | "", | ||
2511 | "", | ||
2512 | "\12\51\7\uffff\32\51\4\uffff\1\51\1\uffff\32\51", | ||
2513 | "\12\51\7\uffff\32\51\4\uffff\1\51\1\uffff\32\51", | ||
2514 | "", | ||
2515 | "", | ||
2516 | "\1\u0086", | ||
2517 | "\12\51\7\uffff\32\51\4\uffff\1\51\1\uffff\32\51", | ||
2518 | "\12\51\7\uffff\32\51\4\uffff\1\51\1\uffff\10\51\1\u0088\21\51", | ||
2519 | "\1\u008a", | ||
2520 | "\12\51\7\uffff\32\51\4\uffff\1\51\1\uffff\10\51\1\u008b\21\51", | ||
2521 | "\1\u008d", | ||
2522 | "\1\u008e", | ||
2523 | "\1\u008f", | ||
2524 | "\1\u0090", | ||
2525 | "\1\u0091", | ||
2526 | "\1\u0092", | ||
2527 | "\12\51\7\uffff\32\51\4\uffff\1\51\1\uffff\32\51", | ||
2528 | "\1\u0094", | ||
2529 | "\1\u0095", | ||
2530 | "\1\u0096", | ||
2531 | "\12\51\7\uffff\32\51\4\uffff\1\51\1\uffff\32\51", | ||
2532 | "\1\u0098", | ||
2533 | "\1\u0099", | ||
2534 | "\1\u009a", | ||
2535 | "\1\u009b", | ||
2536 | "\1\u009c", | ||
2537 | "\1\u009d", | ||
2538 | "\1\u009e", | ||
2539 | "\1\u009f", | ||
2540 | "\1\u00a0", | ||
2541 | "\1\u00a1", | ||
2542 | "\1\u00a2", | ||
2543 | "", | ||
2544 | "", | ||
2545 | "\12\51\7\uffff\32\51\4\uffff\1\51\1\uffff\32\51", | ||
2546 | "", | ||
2547 | "\1\u00a4", | ||
2548 | "", | ||
2549 | "\12\51\7\uffff\32\51\4\uffff\1\51\1\uffff\32\51", | ||
2550 | "\1\u00a6", | ||
2551 | "", | ||
2552 | "\1\u00a7", | ||
2553 | "\1\u00a8", | ||
2554 | "\1\u00a9", | ||
2555 | "\1\u00aa", | ||
2556 | "\12\51\7\uffff\32\51\4\uffff\1\51\1\uffff\32\51", | ||
2557 | "\1\u00ac", | ||
2558 | "", | ||
2559 | "\1\u00ad", | ||
2560 | "\1\u00ae", | ||
2561 | "\12\51\7\uffff\32\51\4\uffff\1\51\1\uffff\32\51", | ||
2562 | "", | ||
2563 | "\1\u00b0", | ||
2564 | "\12\51\7\uffff\32\51\4\uffff\1\51\1\uffff\32\51", | ||
2565 | "\12\51\7\uffff\32\51\4\uffff\1\51\1\uffff\32\51", | ||
2566 | "\1\u00b3", | ||
2567 | "\1\u00b4", | ||
2568 | "\1\u00b5", | ||
2569 | "\1\u00b6", | ||
2570 | "\1\u00b8\3\uffff\1\u00b7", | ||
2571 | "\12\51\7\uffff\32\51\4\uffff\1\51\1\uffff\32\51", | ||
2572 | "\1\u00ba", | ||
2573 | "\1\u00bb", | ||
2574 | "", | ||
2575 | "\1\u00bc", | ||
2576 | "", | ||
2577 | "\1\u00bd", | ||
2578 | "\1\u00be", | ||
2579 | "\12\51\7\uffff\32\51\4\uffff\1\51\1\uffff\32\51", | ||
2580 | "\1\u00c0", | ||
2581 | "\12\51\7\uffff\32\51\4\uffff\1\51\1\uffff\32\51", | ||
2582 | "", | ||
2583 | "\1\u00c2", | ||
2584 | "\12\51\7\uffff\32\51\4\uffff\1\51\1\uffff\32\51", | ||
2585 | "\1\u00c4", | ||
2586 | "", | ||
2587 | "\1\u00c5", | ||
2588 | "", | ||
2589 | "", | ||
2590 | "\12\51\7\uffff\32\51\4\uffff\1\51\1\uffff\32\51", | ||
2591 | "\1\u00c7", | ||
2592 | "\1\u00c8", | ||
2593 | "\12\51\7\uffff\32\51\4\uffff\1\51\1\uffff\32\51", | ||
2594 | "\1\u00ca", | ||
2595 | "\1\u00cb", | ||
2596 | "", | ||
2597 | "\12\51\7\uffff\32\51\4\uffff\1\51\1\uffff\32\51", | ||
2598 | "\1\u00cd", | ||
2599 | "\1\u00ce", | ||
2600 | "\1\u00cf", | ||
2601 | "\1\u00d0", | ||
2602 | "", | ||
2603 | "\1\u00d1", | ||
2604 | "", | ||
2605 | "\1\u00d2", | ||
2606 | "", | ||
2607 | "\1\u00d3", | ||
2608 | "\1\u00d4", | ||
2609 | "", | ||
2610 | "\1\u00d5", | ||
2611 | "\1\u00d6", | ||
2612 | "", | ||
2613 | "\12\51\7\uffff\32\51\4\uffff\1\51\1\uffff\32\51", | ||
2614 | "\1\u00d8", | ||
2615 | "", | ||
2616 | "\1\u00d9", | ||
2617 | "\1\u00da", | ||
2618 | "\1\u00db", | ||
2619 | "\12\51\7\uffff\32\51\4\uffff\1\51\1\uffff\32\51", | ||
2620 | "\1\u00dd", | ||
2621 | "\1\u00de", | ||
2622 | "\1\u00df", | ||
2623 | "\1\u00e0", | ||
2624 | "\1\u00e1", | ||
2625 | "\12\51\7\uffff\32\51\4\uffff\1\51\1\uffff\32\51", | ||
2626 | "", | ||
2627 | "\12\51\7\uffff\32\51\4\uffff\1\51\1\uffff\32\51", | ||
2628 | "\12\51\7\uffff\32\51\4\uffff\1\51\1\uffff\32\51", | ||
2629 | "\12\51\7\uffff\32\51\4\uffff\1\51\1\uffff\32\51", | ||
2630 | "\12\51\7\uffff\32\51\4\uffff\1\51\1\uffff\32\51", | ||
2631 | "", | ||
2632 | "\12\51\7\uffff\32\51\4\uffff\1\51\1\uffff\32\51", | ||
2633 | "\12\51\7\uffff\32\51\4\uffff\1\51\1\uffff\32\51", | ||
2634 | "\1\u00e9", | ||
2635 | "\12\51\7\uffff\32\51\4\uffff\1\51\1\uffff\32\51", | ||
2636 | "\1\u00eb", | ||
2637 | "", | ||
2638 | "", | ||
2639 | "", | ||
2640 | "", | ||
2641 | "", | ||
2642 | "", | ||
2643 | "", | ||
2644 | "\1\u00ec", | ||
2645 | "", | ||
2646 | "\1\u00ed", | ||
2647 | "\1\u00ee", | ||
2648 | "\12\51\7\uffff\32\51\4\uffff\1\51\1\uffff\32\51", | ||
2649 | "\1\u00f2\13\uffff\1\u00f0\2\uffff\1\u00f1", | ||
2650 | "", | ||
2651 | "", | ||
2652 | "", | ||
2653 | "" | ||
2654 | }; | ||
2655 | |||
2656 | static final short[] DFA11_eot = DFA.unpackEncodedString(DFA11_eotS); | ||
2657 | static final short[] DFA11_eof = DFA.unpackEncodedString(DFA11_eofS); | ||
2658 | static final char[] DFA11_min = DFA.unpackEncodedStringToUnsignedChars(DFA11_minS); | ||
2659 | static final char[] DFA11_max = DFA.unpackEncodedStringToUnsignedChars(DFA11_maxS); | ||
2660 | static final short[] DFA11_accept = DFA.unpackEncodedString(DFA11_acceptS); | ||
2661 | static final short[] DFA11_special = DFA.unpackEncodedString(DFA11_specialS); | ||
2662 | static final short[][] DFA11_transition; | ||
2663 | |||
2664 | static { | ||
2665 | int numStates = DFA11_transitionS.length; | ||
2666 | DFA11_transition = new short[numStates][]; | ||
2667 | for (int i=0; i<numStates; i++) { | ||
2668 | DFA11_transition[i] = DFA.unpackEncodedString(DFA11_transitionS[i]); | ||
2669 | } | ||
2670 | } | ||
2671 | |||
2672 | class DFA11 extends DFA { | ||
2673 | |||
2674 | public DFA11(BaseRecognizer recognizer) { | ||
2675 | this.recognizer = recognizer; | ||
2676 | this.decisionNumber = 11; | ||
2677 | this.eot = DFA11_eot; | ||
2678 | this.eof = DFA11_eof; | ||
2679 | this.min = DFA11_min; | ||
2680 | this.max = DFA11_max; | ||
2681 | this.accept = DFA11_accept; | ||
2682 | this.special = DFA11_special; | ||
2683 | this.transition = DFA11_transition; | ||
2684 | } | ||
2685 | public String getDescription() { | ||
2686 | return "1:1: Tokens : ( 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 | RULE_STRING | RULE_QUOTED_ID | RULE_PLUS | RULE_STAR | RULE_DOT | RULE_ID | RULE_INT | RULE_ML_COMMENT | RULE_SL_COMMENT | RULE_WS | RULE_ANY_OTHER );"; | ||
2687 | } | ||
2688 | public int specialStateTransition(int s, IntStream _input) throws NoViableAltException { | ||
2689 | IntStream input = _input; | ||
2690 | int _s = s; | ||
2691 | switch ( s ) { | ||
2692 | case 0 : | ||
2693 | int LA11_35 = input.LA(1); | ||
2694 | |||
2695 | s = -1; | ||
2696 | if ( ((LA11_35>='\u0000' && LA11_35<='\uFFFF')) ) {s = 98;} | ||
2697 | |||
2698 | else s = 39; | ||
2699 | |||
2700 | if ( s>=0 ) return s; | ||
2701 | break; | ||
2702 | case 1 : | ||
2703 | int LA11_0 = input.LA(1); | ||
2704 | |||
2705 | s = -1; | ||
2706 | if ( (LA11_0=='^') ) {s = 1;} | ||
2707 | |||
2708 | else if ( (LA11_0=='*') ) {s = 2;} | ||
2709 | |||
2710 | else if ( (LA11_0=='i') ) {s = 3;} | ||
2711 | |||
2712 | else if ( (LA11_0=='r') ) {s = 4;} | ||
2713 | |||
2714 | else if ( (LA11_0=='=') ) {s = 5;} | ||
2715 | |||
2716 | else if ( (LA11_0=='!') ) {s = 6;} | ||
2717 | |||
2718 | else if ( (LA11_0=='<') ) {s = 7;} | ||
2719 | |||
2720 | else if ( (LA11_0=='>') ) {s = 8;} | ||
2721 | |||
2722 | else if ( (LA11_0=='+') ) {s = 9;} | ||
2723 | |||
2724 | else if ( (LA11_0=='-') ) {s = 10;} | ||
2725 | |||
2726 | else if ( (LA11_0=='/') ) {s = 11;} | ||
2727 | |||
2728 | else if ( (LA11_0=='m') ) {s = 12;} | ||
2729 | |||
2730 | else if ( (LA11_0=='c') ) {s = 13;} | ||
2731 | |||
2732 | else if ( (LA11_0=='o') ) {s = 14;} | ||
2733 | |||
2734 | else if ( (LA11_0=='s') ) {s = 15;} | ||
2735 | |||
2736 | else if ( (LA11_0=='p') ) {s = 16;} | ||
2737 | |||
2738 | else if ( (LA11_0=='a') ) {s = 17;} | ||
2739 | |||
2740 | else if ( (LA11_0=='t') ) {s = 18;} | ||
2741 | |||
2742 | else if ( (LA11_0=='f') ) {s = 19;} | ||
2743 | |||
2744 | else if ( (LA11_0=='u') ) {s = 20;} | ||
2745 | |||
2746 | else if ( (LA11_0=='e') ) {s = 21;} | ||
2747 | |||
2748 | else if ( (LA11_0==':') ) {s = 22;} | ||
2749 | |||
2750 | else if ( (LA11_0=='d') ) {s = 23;} | ||
2751 | |||
2752 | else if ( (LA11_0=='.') ) {s = 24;} | ||
2753 | |||
2754 | else if ( (LA11_0==';') ) {s = 25;} | ||
2755 | |||
2756 | else if ( (LA11_0==',') ) {s = 26;} | ||
2757 | |||
2758 | else if ( (LA11_0=='{') ) {s = 27;} | ||
2759 | |||
2760 | else if ( (LA11_0=='}') ) {s = 28;} | ||
2761 | |||
2762 | else if ( (LA11_0=='|') ) {s = 29;} | ||
2763 | |||
2764 | else if ( (LA11_0=='(') ) {s = 30;} | ||
2765 | |||
2766 | else if ( (LA11_0==')') ) {s = 31;} | ||
2767 | |||
2768 | else if ( (LA11_0=='[') ) {s = 32;} | ||
2769 | |||
2770 | else if ( (LA11_0==']') ) {s = 33;} | ||
2771 | |||
2772 | else if ( (LA11_0=='\"') ) {s = 34;} | ||
2773 | |||
2774 | else if ( (LA11_0=='\'') ) {s = 35;} | ||
2775 | |||
2776 | else if ( ((LA11_0>='A' && LA11_0<='Z')||LA11_0=='_'||LA11_0=='b'||(LA11_0>='g' && LA11_0<='h')||(LA11_0>='j' && LA11_0<='l')||LA11_0=='n'||LA11_0=='q'||(LA11_0>='v' && LA11_0<='z')) ) {s = 36;} | ||
2777 | |||
2778 | else if ( ((LA11_0>='0' && LA11_0<='9')) ) {s = 37;} | ||
2779 | |||
2780 | else if ( ((LA11_0>='\t' && LA11_0<='\n')||LA11_0=='\r'||LA11_0==' ') ) {s = 38;} | ||
2781 | |||
2782 | 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<='\uFFFF')) ) {s = 39;} | ||
2783 | |||
2784 | if ( s>=0 ) return s; | ||
2785 | break; | ||
2786 | case 2 : | ||
2787 | int LA11_34 = input.LA(1); | ||
2788 | |||
2789 | s = -1; | ||
2790 | if ( ((LA11_34>='\u0000' && LA11_34<='\uFFFF')) ) {s = 97;} | ||
2791 | |||
2792 | else s = 39; | ||
2793 | |||
2794 | if ( s>=0 ) return s; | ||
2795 | break; | ||
2796 | } | ||
2797 | NoViableAltException nvae = | ||
2798 | new NoViableAltException(getDescription(), 11, _s, input); | ||
2799 | error(nvae); | ||
2800 | throw nvae; | ||
2801 | } | ||
2802 | } | ||
2803 | |||
2804 | |||
2805 | } \ No newline at end of file | ||
diff --git a/Application/org.eclipse.viatra.solver.language.ide/src-gen/org/eclipse/viatra/solver/language/ide/contentassist/antlr/internal/InternalSolverLanguage.g b/Application/org.eclipse.viatra.solver.language.ide/src-gen/org/eclipse/viatra/solver/language/ide/contentassist/antlr/internal/InternalSolverLanguageParser.g index 2e277376..f5a473f4 100644 --- a/Application/org.eclipse.viatra.solver.language.ide/src-gen/org/eclipse/viatra/solver/language/ide/contentassist/antlr/internal/InternalSolverLanguage.g +++ b/Application/org.eclipse.viatra.solver.language.ide/src-gen/org/eclipse/viatra/solver/language/ide/contentassist/antlr/internal/InternalSolverLanguageParser.g | |||
@@ -1,23 +1,17 @@ | |||
1 | /* | 1 | /* |
2 | * generated by Xtext 2.21.0 | 2 | * generated by Xtext 2.21.0 |
3 | */ | 3 | */ |
4 | grammar InternalSolverLanguage; | 4 | parser grammar InternalSolverLanguageParser; |
5 | 5 | ||
6 | options { | 6 | options { |
7 | tokenVocab=InternalSolverLanguageLexer; | ||
7 | superClass=AbstractInternalContentAssistParser; | 8 | superClass=AbstractInternalContentAssistParser; |
8 | backtrack=true; | ||
9 | } | 9 | } |
10 | 10 | ||
11 | @lexer::header { | 11 | @header { |
12 | package org.eclipse.viatra.solver.language.ide.contentassist.antlr.internal; | ||
13 | |||
14 | // Hack: Use our own Lexer superclass by means of import. | ||
15 | // Currently there is no other way to specify the superclass for the lexer. | ||
16 | import org.eclipse.xtext.ide.editor.contentassist.antlr.internal.Lexer; | ||
17 | } | ||
18 | |||
19 | @parser::header { | ||
20 | package org.eclipse.viatra.solver.language.ide.contentassist.antlr.internal; | 12 | package org.eclipse.viatra.solver.language.ide.contentassist.antlr.internal; |
13 | import java.util.Map; | ||
14 | import java.util.HashMap; | ||
21 | 15 | ||
22 | import java.io.InputStream; | 16 | import java.io.InputStream; |
23 | import org.eclipse.xtext.*; | 17 | import org.eclipse.xtext.*; |
@@ -32,8 +26,84 @@ import org.eclipse.xtext.ide.editor.contentassist.antlr.internal.DFA; | |||
32 | import org.eclipse.viatra.solver.language.services.SolverLanguageGrammarAccess; | 26 | import org.eclipse.viatra.solver.language.services.SolverLanguageGrammarAccess; |
33 | 27 | ||
34 | } | 28 | } |
35 | @parser::members { | 29 | @members { |
36 | private SolverLanguageGrammarAccess grammarAccess; | 30 | private SolverLanguageGrammarAccess grammarAccess; |
31 | private final Map<String, String> tokenNameToValue = new HashMap<String, String>(); | ||
32 | |||
33 | { | ||
34 | tokenNameToValue.put("ExclamationMark", "'!'"); | ||
35 | tokenNameToValue.put("LeftParenthesis", "'('"); | ||
36 | tokenNameToValue.put("RightParenthesis", "')'"); | ||
37 | tokenNameToValue.put("Asterisk", "'*'"); | ||
38 | tokenNameToValue.put("PlusSign", "'+'"); | ||
39 | tokenNameToValue.put("Comma", "','"); | ||
40 | tokenNameToValue.put("HyphenMinus", "'-'"); | ||
41 | tokenNameToValue.put("FullStop", "'.'"); | ||
42 | tokenNameToValue.put("Solidus", "'/'"); | ||
43 | tokenNameToValue.put("Colon", "':'"); | ||
44 | tokenNameToValue.put("Semicolon", "';'"); | ||
45 | tokenNameToValue.put("LessThanSign", "'<'"); | ||
46 | tokenNameToValue.put("EqualsSign", "'='"); | ||
47 | tokenNameToValue.put("GreaterThanSign", "'>'"); | ||
48 | tokenNameToValue.put("LeftSquareBracket", "'['"); | ||
49 | tokenNameToValue.put("RightSquareBracket", "']'"); | ||
50 | tokenNameToValue.put("CircumflexAccent", "'^'"); | ||
51 | tokenNameToValue.put("LeftCurlyBracket", "'{'"); | ||
52 | tokenNameToValue.put("VerticalLine", "'|'"); | ||
53 | tokenNameToValue.put("RightCurlyBracket", "'}'"); | ||
54 | tokenNameToValue.put("ExclamationMarkEqualsSign", "'!='"); | ||
55 | tokenNameToValue.put("HyphenMinusGreaterThanSign", "'->'"); | ||
56 | tokenNameToValue.put("FullStopFullStop", "'..'"); | ||
57 | tokenNameToValue.put("ColonHyphenMinus", "':-'"); | ||
58 | tokenNameToValue.put("LessThanSignEqualsSign", "'<='"); | ||
59 | tokenNameToValue.put("EqualsSignEqualsSign", "'=='"); | ||
60 | tokenNameToValue.put("GreaterThanSignEqualsSign", "'>='"); | ||
61 | tokenNameToValue.put("EQ", "'EQ'"); | ||
62 | tokenNameToValue.put("IN", "'IN'"); | ||
63 | tokenNameToValue.put("If", "'if'"); | ||
64 | tokenNameToValue.put("In", "'in'"); | ||
65 | tokenNameToValue.put("ADD", "'ADD'"); | ||
66 | tokenNameToValue.put("DIV", "'DIV'"); | ||
67 | tokenNameToValue.put("MUL", "'MUL'"); | ||
68 | tokenNameToValue.put("POW", "'POW'"); | ||
69 | tokenNameToValue.put("SUB", "'SUB'"); | ||
70 | tokenNameToValue.put("Avg", "'avg'"); | ||
71 | tokenNameToValue.put("Inf", "'inf'"); | ||
72 | tokenNameToValue.put("Int", "'int'"); | ||
73 | tokenNameToValue.put("Max", "'max'"); | ||
74 | tokenNameToValue.put("May", "'may'"); | ||
75 | tokenNameToValue.put("Min", "'min'"); | ||
76 | tokenNameToValue.put("Sum", "'sum'"); | ||
77 | tokenNameToValue.put("LESS", "'LESS'"); | ||
78 | tokenNameToValue.put("Else", "'else'"); | ||
79 | tokenNameToValue.put("Must", "'must'"); | ||
80 | tokenNameToValue.put("Only", "'only'"); | ||
81 | tokenNameToValue.put("Prod", "'prod'"); | ||
82 | tokenNameToValue.put("Real", "'real'"); | ||
83 | tokenNameToValue.put("Then", "'then'"); | ||
84 | tokenNameToValue.put("True", "'true'"); | ||
85 | tokenNameToValue.put("Class", "'class'"); | ||
86 | tokenNameToValue.put("Count", "'count'"); | ||
87 | tokenNameToValue.put("Empty", "'empty'"); | ||
88 | tokenNameToValue.put("Error", "'error'"); | ||
89 | tokenNameToValue.put("False", "'false'"); | ||
90 | tokenNameToValue.put("Scope", "'scope'"); | ||
91 | tokenNameToValue.put("NOT_EQ", "'NOT_EQ'"); | ||
92 | tokenNameToValue.put("Extern", "'extern'"); | ||
93 | tokenNameToValue.put("GREATER", "'GREATER'"); | ||
94 | tokenNameToValue.put("LESS_EQ", "'LESS_EQ'"); | ||
95 | tokenNameToValue.put("Current", "'current'"); | ||
96 | tokenNameToValue.put("Default", "'default'"); | ||
97 | tokenNameToValue.put("Extends", "'extends'"); | ||
98 | tokenNameToValue.put("Unknown", "'unknown'"); | ||
99 | tokenNameToValue.put("Abstract", "'abstract'"); | ||
100 | tokenNameToValue.put("Contains", "'contains'"); | ||
101 | tokenNameToValue.put("Maximize", "'maximize'"); | ||
102 | tokenNameToValue.put("Minimize", "'minimize'"); | ||
103 | tokenNameToValue.put("Opposite", "'opposite'"); | ||
104 | tokenNameToValue.put("GREATER_EQ", "'GREATER_EQ'"); | ||
105 | tokenNameToValue.put("Functional", "'functional'"); | ||
106 | } | ||
37 | 107 | ||
38 | public void setGrammarAccess(SolverLanguageGrammarAccess grammarAccess) { | 108 | public void setGrammarAccess(SolverLanguageGrammarAccess grammarAccess) { |
39 | this.grammarAccess = grammarAccess; | 109 | this.grammarAccess = grammarAccess; |
@@ -46,7 +116,10 @@ import org.eclipse.viatra.solver.language.services.SolverLanguageGrammarAccess; | |||
46 | 116 | ||
47 | @Override | 117 | @Override |
48 | protected String getValueForTokenName(String tokenName) { | 118 | protected String getValueForTokenName(String tokenName) { |
49 | return tokenName; | 119 | String result = tokenNameToValue.get(tokenName); |
120 | if (result == null) | ||
121 | result = tokenName; | ||
122 | return result; | ||
50 | } | 123 | } |
51 | } | 124 | } |
52 | 125 | ||
@@ -1438,7 +1511,7 @@ ruleExponentialOp | |||
1438 | : | 1511 | : |
1439 | ( | 1512 | ( |
1440 | { before(grammarAccess.getExponentialOpAccess().getPOWEnumLiteralDeclaration()); } | 1513 | { before(grammarAccess.getExponentialOpAccess().getPOWEnumLiteralDeclaration()); } |
1441 | ('^') | 1514 | (CircumflexAccent) |
1442 | { after(grammarAccess.getExponentialOpAccess().getPOWEnumLiteralDeclaration()); } | 1515 | { after(grammarAccess.getExponentialOpAccess().getPOWEnumLiteralDeclaration()); } |
1443 | ) | 1516 | ) |
1444 | ; | 1517 | ; |
@@ -1723,27 +1796,33 @@ rule__AtomicExpression__Alternatives | |||
1723 | } | 1796 | } |
1724 | : | 1797 | : |
1725 | ( | 1798 | ( |
1726 | { before(grammarAccess.getAtomicExpressionAccess().getGroup_0()); } | 1799 | { before(grammarAccess.getAtomicExpressionAccess().getReferenceParserRuleCall_0()); } |
1727 | (rule__AtomicExpression__Group_0__0) | 1800 | ruleReference |
1728 | { after(grammarAccess.getAtomicExpressionAccess().getGroup_0()); } | 1801 | { after(grammarAccess.getAtomicExpressionAccess().getReferenceParserRuleCall_0()); } |
1729 | ) | 1802 | ) |
1730 | | | 1803 | | |
1731 | ( | 1804 | ( |
1732 | { before(grammarAccess.getAtomicExpressionAccess().getIntervalParserRuleCall_1()); } | 1805 | { before(grammarAccess.getAtomicExpressionAccess().getCallParserRuleCall_1()); } |
1806 | ruleCall | ||
1807 | { after(grammarAccess.getAtomicExpressionAccess().getCallParserRuleCall_1()); } | ||
1808 | ) | ||
1809 | | | ||
1810 | ( | ||
1811 | { before(grammarAccess.getAtomicExpressionAccess().getIntervalParserRuleCall_2()); } | ||
1733 | ruleInterval | 1812 | ruleInterval |
1734 | { after(grammarAccess.getAtomicExpressionAccess().getIntervalParserRuleCall_1()); } | 1813 | { after(grammarAccess.getAtomicExpressionAccess().getIntervalParserRuleCall_2()); } |
1735 | ) | 1814 | ) |
1736 | | | 1815 | | |
1737 | ( | 1816 | ( |
1738 | { before(grammarAccess.getAtomicExpressionAccess().getLiteralParserRuleCall_2()); } | 1817 | { before(grammarAccess.getAtomicExpressionAccess().getLiteralParserRuleCall_3()); } |
1739 | ruleLiteral | 1818 | ruleLiteral |
1740 | { after(grammarAccess.getAtomicExpressionAccess().getLiteralParserRuleCall_2()); } | 1819 | { after(grammarAccess.getAtomicExpressionAccess().getLiteralParserRuleCall_3()); } |
1741 | ) | 1820 | ) |
1742 | | | 1821 | | |
1743 | ( | 1822 | ( |
1744 | { before(grammarAccess.getAtomicExpressionAccess().getGroup_3()); } | 1823 | { before(grammarAccess.getAtomicExpressionAccess().getGroup_4()); } |
1745 | (rule__AtomicExpression__Group_3__0) | 1824 | (rule__AtomicExpression__Group_4__0) |
1746 | { after(grammarAccess.getAtomicExpressionAccess().getGroup_3()); } | 1825 | { after(grammarAccess.getAtomicExpressionAccess().getGroup_4()); } |
1747 | ) | 1826 | ) |
1748 | ; | 1827 | ; |
1749 | finally { | 1828 | finally { |
@@ -1952,7 +2031,7 @@ rule__UpperMultiplicty__Alternatives | |||
1952 | | | 2031 | | |
1953 | ( | 2032 | ( |
1954 | { before(grammarAccess.getUpperMultiplictyAccess().getAsteriskKeyword_1()); } | 2033 | { before(grammarAccess.getUpperMultiplictyAccess().getAsteriskKeyword_1()); } |
1955 | '*' | 2034 | Asterisk |
1956 | { after(grammarAccess.getUpperMultiplictyAccess().getAsteriskKeyword_1()); } | 2035 | { after(grammarAccess.getUpperMultiplictyAccess().getAsteriskKeyword_1()); } |
1957 | ) | 2036 | ) |
1958 | ; | 2037 | ; |
@@ -1988,13 +2067,13 @@ rule__MetricType__Alternatives | |||
1988 | : | 2067 | : |
1989 | ( | 2068 | ( |
1990 | { before(grammarAccess.getMetricTypeAccess().getINTEnumLiteralDeclaration_0()); } | 2069 | { before(grammarAccess.getMetricTypeAccess().getINTEnumLiteralDeclaration_0()); } |
1991 | ('int') | 2070 | (Int) |
1992 | { after(grammarAccess.getMetricTypeAccess().getINTEnumLiteralDeclaration_0()); } | 2071 | { after(grammarAccess.getMetricTypeAccess().getINTEnumLiteralDeclaration_0()); } |
1993 | ) | 2072 | ) |
1994 | | | 2073 | | |
1995 | ( | 2074 | ( |
1996 | { before(grammarAccess.getMetricTypeAccess().getREALEnumLiteralDeclaration_1()); } | 2075 | { before(grammarAccess.getMetricTypeAccess().getREALEnumLiteralDeclaration_1()); } |
1997 | ('real') | 2076 | (Real) |
1998 | { after(grammarAccess.getMetricTypeAccess().getREALEnumLiteralDeclaration_1()); } | 2077 | { after(grammarAccess.getMetricTypeAccess().getREALEnumLiteralDeclaration_1()); } |
1999 | ) | 2078 | ) |
2000 | ; | 2079 | ; |
@@ -2009,43 +2088,43 @@ rule__ComparisonOperator__Alternatives | |||
2009 | : | 2088 | : |
2010 | ( | 2089 | ( |
2011 | { before(grammarAccess.getComparisonOperatorAccess().getEQEnumLiteralDeclaration_0()); } | 2090 | { before(grammarAccess.getComparisonOperatorAccess().getEQEnumLiteralDeclaration_0()); } |
2012 | ('==') | 2091 | (EqualsSignEqualsSign) |
2013 | { after(grammarAccess.getComparisonOperatorAccess().getEQEnumLiteralDeclaration_0()); } | 2092 | { after(grammarAccess.getComparisonOperatorAccess().getEQEnumLiteralDeclaration_0()); } |
2014 | ) | 2093 | ) |
2015 | | | 2094 | | |
2016 | ( | 2095 | ( |
2017 | { before(grammarAccess.getComparisonOperatorAccess().getNOT_EQEnumLiteralDeclaration_1()); } | 2096 | { before(grammarAccess.getComparisonOperatorAccess().getNOT_EQEnumLiteralDeclaration_1()); } |
2018 | ('!=') | 2097 | (ExclamationMarkEqualsSign) |
2019 | { after(grammarAccess.getComparisonOperatorAccess().getNOT_EQEnumLiteralDeclaration_1()); } | 2098 | { after(grammarAccess.getComparisonOperatorAccess().getNOT_EQEnumLiteralDeclaration_1()); } |
2020 | ) | 2099 | ) |
2021 | | | 2100 | | |
2022 | ( | 2101 | ( |
2023 | { before(grammarAccess.getComparisonOperatorAccess().getLESSEnumLiteralDeclaration_2()); } | 2102 | { before(grammarAccess.getComparisonOperatorAccess().getLESSEnumLiteralDeclaration_2()); } |
2024 | ('<') | 2103 | (LessThanSign) |
2025 | { after(grammarAccess.getComparisonOperatorAccess().getLESSEnumLiteralDeclaration_2()); } | 2104 | { after(grammarAccess.getComparisonOperatorAccess().getLESSEnumLiteralDeclaration_2()); } |
2026 | ) | 2105 | ) |
2027 | | | 2106 | | |
2028 | ( | 2107 | ( |
2029 | { before(grammarAccess.getComparisonOperatorAccess().getLESS_EQEnumLiteralDeclaration_3()); } | 2108 | { before(grammarAccess.getComparisonOperatorAccess().getLESS_EQEnumLiteralDeclaration_3()); } |
2030 | ('<=') | 2109 | (LessThanSignEqualsSign) |
2031 | { after(grammarAccess.getComparisonOperatorAccess().getLESS_EQEnumLiteralDeclaration_3()); } | 2110 | { after(grammarAccess.getComparisonOperatorAccess().getLESS_EQEnumLiteralDeclaration_3()); } |
2032 | ) | 2111 | ) |
2033 | | | 2112 | | |
2034 | ( | 2113 | ( |
2035 | { before(grammarAccess.getComparisonOperatorAccess().getGREATEREnumLiteralDeclaration_4()); } | 2114 | { before(grammarAccess.getComparisonOperatorAccess().getGREATEREnumLiteralDeclaration_4()); } |
2036 | ('>') | 2115 | (GreaterThanSign) |
2037 | { after(grammarAccess.getComparisonOperatorAccess().getGREATEREnumLiteralDeclaration_4()); } | 2116 | { after(grammarAccess.getComparisonOperatorAccess().getGREATEREnumLiteralDeclaration_4()); } |
2038 | ) | 2117 | ) |
2039 | | | 2118 | | |
2040 | ( | 2119 | ( |
2041 | { before(grammarAccess.getComparisonOperatorAccess().getGREATER_EQEnumLiteralDeclaration_5()); } | 2120 | { before(grammarAccess.getComparisonOperatorAccess().getGREATER_EQEnumLiteralDeclaration_5()); } |
2042 | ('>=') | 2121 | (GreaterThanSignEqualsSign) |
2043 | { after(grammarAccess.getComparisonOperatorAccess().getGREATER_EQEnumLiteralDeclaration_5()); } | 2122 | { after(grammarAccess.getComparisonOperatorAccess().getGREATER_EQEnumLiteralDeclaration_5()); } |
2044 | ) | 2123 | ) |
2045 | | | 2124 | | |
2046 | ( | 2125 | ( |
2047 | { before(grammarAccess.getComparisonOperatorAccess().getINEnumLiteralDeclaration_6()); } | 2126 | { before(grammarAccess.getComparisonOperatorAccess().getINEnumLiteralDeclaration_6()); } |
2048 | ('in') | 2127 | (In) |
2049 | { after(grammarAccess.getComparisonOperatorAccess().getINEnumLiteralDeclaration_6()); } | 2128 | { after(grammarAccess.getComparisonOperatorAccess().getINEnumLiteralDeclaration_6()); } |
2050 | ) | 2129 | ) |
2051 | ; | 2130 | ; |
@@ -2060,13 +2139,13 @@ rule__AdditiveBinaryOperator__Alternatives | |||
2060 | : | 2139 | : |
2061 | ( | 2140 | ( |
2062 | { before(grammarAccess.getAdditiveBinaryOperatorAccess().getADDEnumLiteralDeclaration_0()); } | 2141 | { before(grammarAccess.getAdditiveBinaryOperatorAccess().getADDEnumLiteralDeclaration_0()); } |
2063 | ('+') | 2142 | (PlusSign) |
2064 | { after(grammarAccess.getAdditiveBinaryOperatorAccess().getADDEnumLiteralDeclaration_0()); } | 2143 | { after(grammarAccess.getAdditiveBinaryOperatorAccess().getADDEnumLiteralDeclaration_0()); } |
2065 | ) | 2144 | ) |
2066 | | | 2145 | | |
2067 | ( | 2146 | ( |
2068 | { before(grammarAccess.getAdditiveBinaryOperatorAccess().getSUBEnumLiteralDeclaration_1()); } | 2147 | { before(grammarAccess.getAdditiveBinaryOperatorAccess().getSUBEnumLiteralDeclaration_1()); } |
2069 | ('-') | 2148 | (HyphenMinus) |
2070 | { after(grammarAccess.getAdditiveBinaryOperatorAccess().getSUBEnumLiteralDeclaration_1()); } | 2149 | { after(grammarAccess.getAdditiveBinaryOperatorAccess().getSUBEnumLiteralDeclaration_1()); } |
2071 | ) | 2150 | ) |
2072 | ; | 2151 | ; |
@@ -2081,13 +2160,13 @@ rule__MultiplicativeBinaryOperator__Alternatives | |||
2081 | : | 2160 | : |
2082 | ( | 2161 | ( |
2083 | { before(grammarAccess.getMultiplicativeBinaryOperatorAccess().getMULEnumLiteralDeclaration_0()); } | 2162 | { before(grammarAccess.getMultiplicativeBinaryOperatorAccess().getMULEnumLiteralDeclaration_0()); } |
2084 | ('*') | 2163 | (Asterisk) |
2085 | { after(grammarAccess.getMultiplicativeBinaryOperatorAccess().getMULEnumLiteralDeclaration_0()); } | 2164 | { after(grammarAccess.getMultiplicativeBinaryOperatorAccess().getMULEnumLiteralDeclaration_0()); } |
2086 | ) | 2165 | ) |
2087 | | | 2166 | | |
2088 | ( | 2167 | ( |
2089 | { before(grammarAccess.getMultiplicativeBinaryOperatorAccess().getDIVEnumLiteralDeclaration_1()); } | 2168 | { before(grammarAccess.getMultiplicativeBinaryOperatorAccess().getDIVEnumLiteralDeclaration_1()); } |
2090 | ('/') | 2169 | (Solidus) |
2091 | { after(grammarAccess.getMultiplicativeBinaryOperatorAccess().getDIVEnumLiteralDeclaration_1()); } | 2170 | { after(grammarAccess.getMultiplicativeBinaryOperatorAccess().getDIVEnumLiteralDeclaration_1()); } |
2092 | ) | 2171 | ) |
2093 | ; | 2172 | ; |
@@ -2102,37 +2181,37 @@ rule__UnaryOp__Alternatives | |||
2102 | : | 2181 | : |
2103 | ( | 2182 | ( |
2104 | { before(grammarAccess.getUnaryOpAccess().getNEGEnumLiteralDeclaration_0()); } | 2183 | { before(grammarAccess.getUnaryOpAccess().getNEGEnumLiteralDeclaration_0()); } |
2105 | ('!') | 2184 | (ExclamationMark) |
2106 | { after(grammarAccess.getUnaryOpAccess().getNEGEnumLiteralDeclaration_0()); } | 2185 | { after(grammarAccess.getUnaryOpAccess().getNEGEnumLiteralDeclaration_0()); } |
2107 | ) | 2186 | ) |
2108 | | | 2187 | | |
2109 | ( | 2188 | ( |
2110 | { before(grammarAccess.getUnaryOpAccess().getPLUSEnumLiteralDeclaration_1()); } | 2189 | { before(grammarAccess.getUnaryOpAccess().getPLUSEnumLiteralDeclaration_1()); } |
2111 | ('+') | 2190 | (PlusSign) |
2112 | { after(grammarAccess.getUnaryOpAccess().getPLUSEnumLiteralDeclaration_1()); } | 2191 | { after(grammarAccess.getUnaryOpAccess().getPLUSEnumLiteralDeclaration_1()); } |
2113 | ) | 2192 | ) |
2114 | | | 2193 | | |
2115 | ( | 2194 | ( |
2116 | { before(grammarAccess.getUnaryOpAccess().getMINUSEnumLiteralDeclaration_2()); } | 2195 | { before(grammarAccess.getUnaryOpAccess().getMINUSEnumLiteralDeclaration_2()); } |
2117 | ('-') | 2196 | (HyphenMinus) |
2118 | { after(grammarAccess.getUnaryOpAccess().getMINUSEnumLiteralDeclaration_2()); } | 2197 | { after(grammarAccess.getUnaryOpAccess().getMINUSEnumLiteralDeclaration_2()); } |
2119 | ) | 2198 | ) |
2120 | | | 2199 | | |
2121 | ( | 2200 | ( |
2122 | { before(grammarAccess.getUnaryOpAccess().getMAYEnumLiteralDeclaration_3()); } | 2201 | { before(grammarAccess.getUnaryOpAccess().getMAYEnumLiteralDeclaration_3()); } |
2123 | ('may') | 2202 | (May) |
2124 | { after(grammarAccess.getUnaryOpAccess().getMAYEnumLiteralDeclaration_3()); } | 2203 | { after(grammarAccess.getUnaryOpAccess().getMAYEnumLiteralDeclaration_3()); } |
2125 | ) | 2204 | ) |
2126 | | | 2205 | | |
2127 | ( | 2206 | ( |
2128 | { before(grammarAccess.getUnaryOpAccess().getMUSTEnumLiteralDeclaration_4()); } | 2207 | { before(grammarAccess.getUnaryOpAccess().getMUSTEnumLiteralDeclaration_4()); } |
2129 | ('must') | 2208 | (Must) |
2130 | { after(grammarAccess.getUnaryOpAccess().getMUSTEnumLiteralDeclaration_4()); } | 2209 | { after(grammarAccess.getUnaryOpAccess().getMUSTEnumLiteralDeclaration_4()); } |
2131 | ) | 2210 | ) |
2132 | | | 2211 | | |
2133 | ( | 2212 | ( |
2134 | { before(grammarAccess.getUnaryOpAccess().getCURRENTEnumLiteralDeclaration_5()); } | 2213 | { before(grammarAccess.getUnaryOpAccess().getCURRENTEnumLiteralDeclaration_5()); } |
2135 | ('current') | 2214 | (Current) |
2136 | { after(grammarAccess.getUnaryOpAccess().getCURRENTEnumLiteralDeclaration_5()); } | 2215 | { after(grammarAccess.getUnaryOpAccess().getCURRENTEnumLiteralDeclaration_5()); } |
2137 | ) | 2216 | ) |
2138 | ; | 2217 | ; |
@@ -2147,37 +2226,37 @@ rule__AggregationOp__Alternatives | |||
2147 | : | 2226 | : |
2148 | ( | 2227 | ( |
2149 | { before(grammarAccess.getAggregationOpAccess().getONLYEnumLiteralDeclaration_0()); } | 2228 | { before(grammarAccess.getAggregationOpAccess().getONLYEnumLiteralDeclaration_0()); } |
2150 | ('only') | 2229 | (Only) |
2151 | { after(grammarAccess.getAggregationOpAccess().getONLYEnumLiteralDeclaration_0()); } | 2230 | { after(grammarAccess.getAggregationOpAccess().getONLYEnumLiteralDeclaration_0()); } |
2152 | ) | 2231 | ) |
2153 | | | 2232 | | |
2154 | ( | 2233 | ( |
2155 | { before(grammarAccess.getAggregationOpAccess().getSUMEnumLiteralDeclaration_1()); } | 2234 | { before(grammarAccess.getAggregationOpAccess().getSUMEnumLiteralDeclaration_1()); } |
2156 | ('sum') | 2235 | (Sum) |
2157 | { after(grammarAccess.getAggregationOpAccess().getSUMEnumLiteralDeclaration_1()); } | 2236 | { after(grammarAccess.getAggregationOpAccess().getSUMEnumLiteralDeclaration_1()); } |
2158 | ) | 2237 | ) |
2159 | | | 2238 | | |
2160 | ( | 2239 | ( |
2161 | { before(grammarAccess.getAggregationOpAccess().getPRODEnumLiteralDeclaration_2()); } | 2240 | { before(grammarAccess.getAggregationOpAccess().getPRODEnumLiteralDeclaration_2()); } |
2162 | ('prod') | 2241 | (Prod) |
2163 | { after(grammarAccess.getAggregationOpAccess().getPRODEnumLiteralDeclaration_2()); } | 2242 | { after(grammarAccess.getAggregationOpAccess().getPRODEnumLiteralDeclaration_2()); } |
2164 | ) | 2243 | ) |
2165 | | | 2244 | | |
2166 | ( | 2245 | ( |
2167 | { before(grammarAccess.getAggregationOpAccess().getAVGEnumLiteralDeclaration_3()); } | 2246 | { before(grammarAccess.getAggregationOpAccess().getAVGEnumLiteralDeclaration_3()); } |
2168 | ('avg') | 2247 | (Avg) |
2169 | { after(grammarAccess.getAggregationOpAccess().getAVGEnumLiteralDeclaration_3()); } | 2248 | { after(grammarAccess.getAggregationOpAccess().getAVGEnumLiteralDeclaration_3()); } |
2170 | ) | 2249 | ) |
2171 | | | 2250 | | |
2172 | ( | 2251 | ( |
2173 | { before(grammarAccess.getAggregationOpAccess().getMINEnumLiteralDeclaration_4()); } | 2252 | { before(grammarAccess.getAggregationOpAccess().getMINEnumLiteralDeclaration_4()); } |
2174 | ('min') | 2253 | (Min) |
2175 | { after(grammarAccess.getAggregationOpAccess().getMINEnumLiteralDeclaration_4()); } | 2254 | { after(grammarAccess.getAggregationOpAccess().getMINEnumLiteralDeclaration_4()); } |
2176 | ) | 2255 | ) |
2177 | | | 2256 | | |
2178 | ( | 2257 | ( |
2179 | { before(grammarAccess.getAggregationOpAccess().getMAXEnumLiteralDeclaration_5()); } | 2258 | { before(grammarAccess.getAggregationOpAccess().getMAXEnumLiteralDeclaration_5()); } |
2180 | ('max') | 2259 | (Max) |
2181 | { after(grammarAccess.getAggregationOpAccess().getMAXEnumLiteralDeclaration_5()); } | 2260 | { after(grammarAccess.getAggregationOpAccess().getMAXEnumLiteralDeclaration_5()); } |
2182 | ) | 2261 | ) |
2183 | ; | 2262 | ; |
@@ -2192,25 +2271,25 @@ rule__LogicValue__Alternatives | |||
2192 | : | 2271 | : |
2193 | ( | 2272 | ( |
2194 | { before(grammarAccess.getLogicValueAccess().getTRUEEnumLiteralDeclaration_0()); } | 2273 | { before(grammarAccess.getLogicValueAccess().getTRUEEnumLiteralDeclaration_0()); } |
2195 | ('true') | 2274 | (True) |
2196 | { after(grammarAccess.getLogicValueAccess().getTRUEEnumLiteralDeclaration_0()); } | 2275 | { after(grammarAccess.getLogicValueAccess().getTRUEEnumLiteralDeclaration_0()); } |
2197 | ) | 2276 | ) |
2198 | | | 2277 | | |
2199 | ( | 2278 | ( |
2200 | { before(grammarAccess.getLogicValueAccess().getFALSEEnumLiteralDeclaration_1()); } | 2279 | { before(grammarAccess.getLogicValueAccess().getFALSEEnumLiteralDeclaration_1()); } |
2201 | ('false') | 2280 | (False) |
2202 | { after(grammarAccess.getLogicValueAccess().getFALSEEnumLiteralDeclaration_1()); } | 2281 | { after(grammarAccess.getLogicValueAccess().getFALSEEnumLiteralDeclaration_1()); } |
2203 | ) | 2282 | ) |
2204 | | | 2283 | | |
2205 | ( | 2284 | ( |
2206 | { before(grammarAccess.getLogicValueAccess().getUNKNOWNEnumLiteralDeclaration_2()); } | 2285 | { before(grammarAccess.getLogicValueAccess().getUNKNOWNEnumLiteralDeclaration_2()); } |
2207 | ('unknown') | 2286 | (Unknown) |
2208 | { after(grammarAccess.getLogicValueAccess().getUNKNOWNEnumLiteralDeclaration_2()); } | 2287 | { after(grammarAccess.getLogicValueAccess().getUNKNOWNEnumLiteralDeclaration_2()); } |
2209 | ) | 2288 | ) |
2210 | | | 2289 | | |
2211 | ( | 2290 | ( |
2212 | { before(grammarAccess.getLogicValueAccess().getERROREnumLiteralDeclaration_3()); } | 2291 | { before(grammarAccess.getLogicValueAccess().getERROREnumLiteralDeclaration_3()); } |
2213 | ('error') | 2292 | (Error) |
2214 | { after(grammarAccess.getLogicValueAccess().getERROREnumLiteralDeclaration_3()); } | 2293 | { after(grammarAccess.getLogicValueAccess().getERROREnumLiteralDeclaration_3()); } |
2215 | ) | 2294 | ) |
2216 | ; | 2295 | ; |
@@ -2225,13 +2304,13 @@ rule__ObjectiveKind__Alternatives | |||
2225 | : | 2304 | : |
2226 | ( | 2305 | ( |
2227 | { before(grammarAccess.getObjectiveKindAccess().getMINIMIZEEnumLiteralDeclaration_0()); } | 2306 | { before(grammarAccess.getObjectiveKindAccess().getMINIMIZEEnumLiteralDeclaration_0()); } |
2228 | ('minimize') | 2307 | (Minimize) |
2229 | { after(grammarAccess.getObjectiveKindAccess().getMINIMIZEEnumLiteralDeclaration_0()); } | 2308 | { after(grammarAccess.getObjectiveKindAccess().getMINIMIZEEnumLiteralDeclaration_0()); } |
2230 | ) | 2309 | ) |
2231 | | | 2310 | | |
2232 | ( | 2311 | ( |
2233 | { before(grammarAccess.getObjectiveKindAccess().getMAXIMIZEEnumLiteralDeclaration_1()); } | 2312 | { before(grammarAccess.getObjectiveKindAccess().getMAXIMIZEEnumLiteralDeclaration_1()); } |
2234 | ('maximize') | 2313 | (Maximize) |
2235 | { after(grammarAccess.getObjectiveKindAccess().getMAXIMIZEEnumLiteralDeclaration_1()); } | 2314 | { after(grammarAccess.getObjectiveKindAccess().getMAXIMIZEEnumLiteralDeclaration_1()); } |
2236 | ) | 2315 | ) |
2237 | ; | 2316 | ; |
@@ -2283,9 +2362,9 @@ rule__Statement__Group__1__Impl | |||
2283 | } | 2362 | } |
2284 | : | 2363 | : |
2285 | ( | 2364 | ( |
2286 | { before(grammarAccess.getStatementAccess().getDOTTerminalRuleCall_1()); } | 2365 | { before(grammarAccess.getStatementAccess().getFULL_STOPTerminalRuleCall_1()); } |
2287 | RULE_DOT | 2366 | RULE_FULL_STOP |
2288 | { after(grammarAccess.getStatementAccess().getDOTTerminalRuleCall_1()); } | 2367 | { after(grammarAccess.getStatementAccess().getFULL_STOPTerminalRuleCall_1()); } |
2289 | ) | 2368 | ) |
2290 | ; | 2369 | ; |
2291 | finally { | 2370 | finally { |
@@ -2420,7 +2499,7 @@ rule__AssertionOrDefinition__Group_1_0_1__0__Impl | |||
2420 | : | 2499 | : |
2421 | ( | 2500 | ( |
2422 | { before(grammarAccess.getAssertionOrDefinitionAccess().getColonKeyword_1_0_1_0()); } | 2501 | { before(grammarAccess.getAssertionOrDefinitionAccess().getColonKeyword_1_0_1_0()); } |
2423 | ':' | 2502 | Colon |
2424 | { after(grammarAccess.getAssertionOrDefinitionAccess().getColonKeyword_1_0_1_0()); } | 2503 | { after(grammarAccess.getAssertionOrDefinitionAccess().getColonKeyword_1_0_1_0()); } |
2425 | ) | 2504 | ) |
2426 | ; | 2505 | ; |
@@ -2501,7 +2580,7 @@ rule__AssertionOrDefinition__Group_1_1__1__Impl | |||
2501 | : | 2580 | : |
2502 | ( | 2581 | ( |
2503 | { before(grammarAccess.getAssertionOrDefinitionAccess().getColonHyphenMinusKeyword_1_1_1()); } | 2582 | { before(grammarAccess.getAssertionOrDefinitionAccess().getColonHyphenMinusKeyword_1_1_1()); } |
2504 | ':-' | 2583 | ColonHyphenMinus |
2505 | { after(grammarAccess.getAssertionOrDefinitionAccess().getColonHyphenMinusKeyword_1_1_1()); } | 2584 | { after(grammarAccess.getAssertionOrDefinitionAccess().getColonHyphenMinusKeyword_1_1_1()); } |
2506 | ) | 2585 | ) |
2507 | ; | 2586 | ; |
@@ -2582,7 +2661,7 @@ rule__AssertionOrDefinition__Group_1_2__1__Impl | |||
2582 | : | 2661 | : |
2583 | ( | 2662 | ( |
2584 | { before(grammarAccess.getAssertionOrDefinitionAccess().getEqualsSignKeyword_1_2_1()); } | 2663 | { before(grammarAccess.getAssertionOrDefinitionAccess().getEqualsSignKeyword_1_2_1()); } |
2585 | '=' | 2664 | EqualsSign |
2586 | { after(grammarAccess.getAssertionOrDefinitionAccess().getEqualsSignKeyword_1_2_1()); } | 2665 | { after(grammarAccess.getAssertionOrDefinitionAccess().getEqualsSignKeyword_1_2_1()); } |
2587 | ) | 2666 | ) |
2588 | ; | 2667 | ; |
@@ -2690,7 +2769,7 @@ rule__PredicateDefinition__Group__2__Impl | |||
2690 | : | 2769 | : |
2691 | ( | 2770 | ( |
2692 | { before(grammarAccess.getPredicateDefinitionAccess().getColonHyphenMinusKeyword_2()); } | 2771 | { before(grammarAccess.getPredicateDefinitionAccess().getColonHyphenMinusKeyword_2()); } |
2693 | ':-' | 2772 | ColonHyphenMinus |
2694 | { after(grammarAccess.getPredicateDefinitionAccess().getColonHyphenMinusKeyword_2()); } | 2773 | { after(grammarAccess.getPredicateDefinitionAccess().getColonHyphenMinusKeyword_2()); } |
2695 | ) | 2774 | ) |
2696 | ; | 2775 | ; |
@@ -2852,7 +2931,7 @@ rule__UnnamedErrorPrediateDefinition__Group__0__Impl | |||
2852 | : | 2931 | : |
2853 | ( | 2932 | ( |
2854 | { before(grammarAccess.getUnnamedErrorPrediateDefinitionAccess().getErrorKeyword_0()); } | 2933 | { before(grammarAccess.getUnnamedErrorPrediateDefinitionAccess().getErrorKeyword_0()); } |
2855 | 'error' | 2934 | Error |
2856 | { after(grammarAccess.getUnnamedErrorPrediateDefinitionAccess().getErrorKeyword_0()); } | 2935 | { after(grammarAccess.getUnnamedErrorPrediateDefinitionAccess().getErrorKeyword_0()); } |
2857 | ) | 2936 | ) |
2858 | ; | 2937 | ; |
@@ -2906,7 +2985,7 @@ rule__UnnamedErrorPrediateDefinition__Group__2__Impl | |||
2906 | : | 2985 | : |
2907 | ( | 2986 | ( |
2908 | { before(grammarAccess.getUnnamedErrorPrediateDefinitionAccess().getColonHyphenMinusKeyword_2()); } | 2987 | { before(grammarAccess.getUnnamedErrorPrediateDefinitionAccess().getColonHyphenMinusKeyword_2()); } |
2909 | ':-' | 2988 | ColonHyphenMinus |
2910 | { after(grammarAccess.getUnnamedErrorPrediateDefinitionAccess().getColonHyphenMinusKeyword_2()); } | 2989 | { after(grammarAccess.getUnnamedErrorPrediateDefinitionAccess().getColonHyphenMinusKeyword_2()); } |
2911 | ) | 2990 | ) |
2912 | ; | 2991 | ; |
@@ -2960,7 +3039,7 @@ rule__DefaultDefinition__Group__0__Impl | |||
2960 | : | 3039 | : |
2961 | ( | 3040 | ( |
2962 | { before(grammarAccess.getDefaultDefinitionAccess().getDefaultKeyword_0()); } | 3041 | { before(grammarAccess.getDefaultDefinitionAccess().getDefaultKeyword_0()); } |
2963 | 'default' | 3042 | Default |
2964 | { after(grammarAccess.getDefaultDefinitionAccess().getDefaultKeyword_0()); } | 3043 | { after(grammarAccess.getDefaultDefinitionAccess().getDefaultKeyword_0()); } |
2965 | ) | 3044 | ) |
2966 | ; | 3045 | ; |
@@ -3014,7 +3093,7 @@ rule__DefaultDefinition__Group__2__Impl | |||
3014 | : | 3093 | : |
3015 | ( | 3094 | ( |
3016 | { before(grammarAccess.getDefaultDefinitionAccess().getColonKeyword_2()); } | 3095 | { before(grammarAccess.getDefaultDefinitionAccess().getColonKeyword_2()); } |
3017 | ':' | 3096 | Colon |
3018 | { after(grammarAccess.getDefaultDefinitionAccess().getColonKeyword_2()); } | 3097 | { after(grammarAccess.getDefaultDefinitionAccess().getColonKeyword_2()); } |
3019 | ) | 3098 | ) |
3020 | ; | 3099 | ; |
@@ -3068,7 +3147,7 @@ rule__ExternPredicateDefinition__Group__0__Impl | |||
3068 | : | 3147 | : |
3069 | ( | 3148 | ( |
3070 | { before(grammarAccess.getExternPredicateDefinitionAccess().getExternKeyword_0()); } | 3149 | { before(grammarAccess.getExternPredicateDefinitionAccess().getExternKeyword_0()); } |
3071 | 'extern' | 3150 | Extern |
3072 | { after(grammarAccess.getExternPredicateDefinitionAccess().getExternKeyword_0()); } | 3151 | { after(grammarAccess.getExternPredicateDefinitionAccess().getExternKeyword_0()); } |
3073 | ) | 3152 | ) |
3074 | ; | 3153 | ; |
@@ -3082,7 +3161,6 @@ rule__ExternPredicateDefinition__Group__1 | |||
3082 | } | 3161 | } |
3083 | : | 3162 | : |
3084 | rule__ExternPredicateDefinition__Group__1__Impl | 3163 | rule__ExternPredicateDefinition__Group__1__Impl |
3085 | rule__ExternPredicateDefinition__Group__2 | ||
3086 | ; | 3164 | ; |
3087 | finally { | 3165 | finally { |
3088 | restoreStackSize(stackSize); | 3166 | restoreStackSize(stackSize); |
@@ -3103,32 +3181,6 @@ finally { | |||
3103 | restoreStackSize(stackSize); | 3181 | restoreStackSize(stackSize); |
3104 | } | 3182 | } |
3105 | 3183 | ||
3106 | rule__ExternPredicateDefinition__Group__2 | ||
3107 | @init { | ||
3108 | int stackSize = keepStackSize(); | ||
3109 | } | ||
3110 | : | ||
3111 | rule__ExternPredicateDefinition__Group__2__Impl | ||
3112 | ; | ||
3113 | finally { | ||
3114 | restoreStackSize(stackSize); | ||
3115 | } | ||
3116 | |||
3117 | rule__ExternPredicateDefinition__Group__2__Impl | ||
3118 | @init { | ||
3119 | int stackSize = keepStackSize(); | ||
3120 | } | ||
3121 | : | ||
3122 | ( | ||
3123 | { before(grammarAccess.getExternPredicateDefinitionAccess().getFullStopKeyword_2()); } | ||
3124 | '.' | ||
3125 | { after(grammarAccess.getExternPredicateDefinitionAccess().getFullStopKeyword_2()); } | ||
3126 | ) | ||
3127 | ; | ||
3128 | finally { | ||
3129 | restoreStackSize(stackSize); | ||
3130 | } | ||
3131 | |||
3132 | 3184 | ||
3133 | rule__MetricDefinition__Group__0 | 3185 | rule__MetricDefinition__Group__0 |
3134 | @init { | 3186 | @init { |
@@ -3203,7 +3255,7 @@ rule__MetricDefinition__Group__2__Impl | |||
3203 | : | 3255 | : |
3204 | ( | 3256 | ( |
3205 | { before(grammarAccess.getMetricDefinitionAccess().getEqualsSignKeyword_2()); } | 3257 | { before(grammarAccess.getMetricDefinitionAccess().getEqualsSignKeyword_2()); } |
3206 | '=' | 3258 | EqualsSign |
3207 | { after(grammarAccess.getMetricDefinitionAccess().getEqualsSignKeyword_2()); } | 3259 | { after(grammarAccess.getMetricDefinitionAccess().getEqualsSignKeyword_2()); } |
3208 | ) | 3260 | ) |
3209 | ; | 3261 | ; |
@@ -3257,7 +3309,7 @@ rule__ExternMetricDefinition__Group__0__Impl | |||
3257 | : | 3309 | : |
3258 | ( | 3310 | ( |
3259 | { before(grammarAccess.getExternMetricDefinitionAccess().getExternKeyword_0()); } | 3311 | { before(grammarAccess.getExternMetricDefinitionAccess().getExternKeyword_0()); } |
3260 | 'extern' | 3312 | Extern |
3261 | { after(grammarAccess.getExternMetricDefinitionAccess().getExternKeyword_0()); } | 3313 | { after(grammarAccess.getExternMetricDefinitionAccess().getExternKeyword_0()); } |
3262 | ) | 3314 | ) |
3263 | ; | 3315 | ; |
@@ -3338,7 +3390,7 @@ rule__IfElse__Group__0__Impl | |||
3338 | : | 3390 | : |
3339 | ( | 3391 | ( |
3340 | { before(grammarAccess.getIfElseAccess().getIfKeyword_0()); } | 3392 | { before(grammarAccess.getIfElseAccess().getIfKeyword_0()); } |
3341 | 'if' | 3393 | If |
3342 | { after(grammarAccess.getIfElseAccess().getIfKeyword_0()); } | 3394 | { after(grammarAccess.getIfElseAccess().getIfKeyword_0()); } |
3343 | ) | 3395 | ) |
3344 | ; | 3396 | ; |
@@ -3392,7 +3444,7 @@ rule__IfElse__Group__2__Impl | |||
3392 | : | 3444 | : |
3393 | ( | 3445 | ( |
3394 | { before(grammarAccess.getIfElseAccess().getThenKeyword_2()); } | 3446 | { before(grammarAccess.getIfElseAccess().getThenKeyword_2()); } |
3395 | 'then' | 3447 | Then |
3396 | { after(grammarAccess.getIfElseAccess().getThenKeyword_2()); } | 3448 | { after(grammarAccess.getIfElseAccess().getThenKeyword_2()); } |
3397 | ) | 3449 | ) |
3398 | ; | 3450 | ; |
@@ -3446,7 +3498,7 @@ rule__IfElse__Group__4__Impl | |||
3446 | : | 3498 | : |
3447 | ( | 3499 | ( |
3448 | { before(grammarAccess.getIfElseAccess().getElseKeyword_4()); } | 3500 | { before(grammarAccess.getIfElseAccess().getElseKeyword_4()); } |
3449 | 'else' | 3501 | Else |
3450 | { after(grammarAccess.getIfElseAccess().getElseKeyword_4()); } | 3502 | { after(grammarAccess.getIfElseAccess().getElseKeyword_4()); } |
3451 | ) | 3503 | ) |
3452 | ; | 3504 | ; |
@@ -3615,7 +3667,7 @@ rule__DisjunctiveExpression__Group_1_0_1__0__Impl | |||
3615 | : | 3667 | : |
3616 | ( | 3668 | ( |
3617 | { before(grammarAccess.getDisjunctiveExpressionAccess().getSemicolonKeyword_1_0_1_0()); } | 3669 | { before(grammarAccess.getDisjunctiveExpressionAccess().getSemicolonKeyword_1_0_1_0()); } |
3618 | ';' | 3670 | Semicolon |
3619 | { after(grammarAccess.getDisjunctiveExpressionAccess().getSemicolonKeyword_1_0_1_0()); } | 3671 | { after(grammarAccess.getDisjunctiveExpressionAccess().getSemicolonKeyword_1_0_1_0()); } |
3620 | ) | 3672 | ) |
3621 | ; | 3673 | ; |
@@ -3696,7 +3748,7 @@ rule__DisjunctiveExpression__Group_1_1__1__Impl | |||
3696 | : | 3748 | : |
3697 | ( | 3749 | ( |
3698 | { before(grammarAccess.getDisjunctiveExpressionAccess().getHyphenMinusGreaterThanSignKeyword_1_1_1()); } | 3750 | { before(grammarAccess.getDisjunctiveExpressionAccess().getHyphenMinusGreaterThanSignKeyword_1_1_1()); } |
3699 | '->' | 3751 | HyphenMinusGreaterThanSign |
3700 | { after(grammarAccess.getDisjunctiveExpressionAccess().getHyphenMinusGreaterThanSignKeyword_1_1_1()); } | 3752 | { after(grammarAccess.getDisjunctiveExpressionAccess().getHyphenMinusGreaterThanSignKeyword_1_1_1()); } |
3701 | ) | 3753 | ) |
3702 | ; | 3754 | ; |
@@ -3804,7 +3856,7 @@ rule__DisjunctiveExpression__Group_1_1_4__0__Impl | |||
3804 | : | 3856 | : |
3805 | ( | 3857 | ( |
3806 | { before(grammarAccess.getDisjunctiveExpressionAccess().getSemicolonKeyword_1_1_4_0()); } | 3858 | { before(grammarAccess.getDisjunctiveExpressionAccess().getSemicolonKeyword_1_1_4_0()); } |
3807 | ';' | 3859 | Semicolon |
3808 | { after(grammarAccess.getDisjunctiveExpressionAccess().getSemicolonKeyword_1_1_4_0()); } | 3860 | { after(grammarAccess.getDisjunctiveExpressionAccess().getSemicolonKeyword_1_1_4_0()); } |
3809 | ) | 3861 | ) |
3810 | ; | 3862 | ; |
@@ -3885,7 +3937,7 @@ rule__Case__Group__1__Impl | |||
3885 | : | 3937 | : |
3886 | ( | 3938 | ( |
3887 | { before(grammarAccess.getCaseAccess().getHyphenMinusGreaterThanSignKeyword_1()); } | 3939 | { before(grammarAccess.getCaseAccess().getHyphenMinusGreaterThanSignKeyword_1()); } |
3888 | '->' | 3940 | HyphenMinusGreaterThanSign |
3889 | { after(grammarAccess.getCaseAccess().getHyphenMinusGreaterThanSignKeyword_1()); } | 3941 | { after(grammarAccess.getCaseAccess().getHyphenMinusGreaterThanSignKeyword_1()); } |
3890 | ) | 3942 | ) |
3891 | ; | 3943 | ; |
@@ -4054,7 +4106,7 @@ rule__ConjunctiveExpression__Group_1_1__0__Impl | |||
4054 | : | 4106 | : |
4055 | ( | 4107 | ( |
4056 | { before(grammarAccess.getConjunctiveExpressionAccess().getCommaKeyword_1_1_0()); } | 4108 | { before(grammarAccess.getConjunctiveExpressionAccess().getCommaKeyword_1_1_0()); } |
4057 | ',' | 4109 | Comma |
4058 | { after(grammarAccess.getConjunctiveExpressionAccess().getCommaKeyword_1_1_0()); } | 4110 | { after(grammarAccess.getConjunctiveExpressionAccess().getCommaKeyword_1_1_0()); } |
4059 | ) | 4111 | ) |
4060 | ; | 4112 | ; |
@@ -4729,7 +4781,7 @@ rule__Count__Group__0__Impl | |||
4729 | : | 4781 | : |
4730 | ( | 4782 | ( |
4731 | { before(grammarAccess.getCountAccess().getCountKeyword_0()); } | 4783 | { before(grammarAccess.getCountAccess().getCountKeyword_0()); } |
4732 | 'count' | 4784 | Count |
4733 | { after(grammarAccess.getCountAccess().getCountKeyword_0()); } | 4785 | { after(grammarAccess.getCountAccess().getCountKeyword_0()); } |
4734 | ) | 4786 | ) |
4735 | ; | 4787 | ; |
@@ -4756,7 +4808,7 @@ rule__Count__Group__1__Impl | |||
4756 | : | 4808 | : |
4757 | ( | 4809 | ( |
4758 | { before(grammarAccess.getCountAccess().getLeftCurlyBracketKeyword_1()); } | 4810 | { before(grammarAccess.getCountAccess().getLeftCurlyBracketKeyword_1()); } |
4759 | '{' | 4811 | LeftCurlyBracket |
4760 | { after(grammarAccess.getCountAccess().getLeftCurlyBracketKeyword_1()); } | 4812 | { after(grammarAccess.getCountAccess().getLeftCurlyBracketKeyword_1()); } |
4761 | ) | 4813 | ) |
4762 | ; | 4814 | ; |
@@ -4809,7 +4861,7 @@ rule__Count__Group__3__Impl | |||
4809 | : | 4861 | : |
4810 | ( | 4862 | ( |
4811 | { before(grammarAccess.getCountAccess().getRightCurlyBracketKeyword_3()); } | 4863 | { before(grammarAccess.getCountAccess().getRightCurlyBracketKeyword_3()); } |
4812 | '}' | 4864 | RightCurlyBracket |
4813 | { after(grammarAccess.getCountAccess().getRightCurlyBracketKeyword_3()); } | 4865 | { after(grammarAccess.getCountAccess().getRightCurlyBracketKeyword_3()); } |
4814 | ) | 4866 | ) |
4815 | ; | 4867 | ; |
@@ -4864,7 +4916,7 @@ rule__Aggregation__Group__1__Impl | |||
4864 | : | 4916 | : |
4865 | ( | 4917 | ( |
4866 | { before(grammarAccess.getAggregationAccess().getLeftCurlyBracketKeyword_1()); } | 4918 | { before(grammarAccess.getAggregationAccess().getLeftCurlyBracketKeyword_1()); } |
4867 | '{' | 4919 | LeftCurlyBracket |
4868 | { after(grammarAccess.getAggregationAccess().getLeftCurlyBracketKeyword_1()); } | 4920 | { after(grammarAccess.getAggregationAccess().getLeftCurlyBracketKeyword_1()); } |
4869 | ) | 4921 | ) |
4870 | ; | 4922 | ; |
@@ -4918,7 +4970,7 @@ rule__Aggregation__Group__3__Impl | |||
4918 | : | 4970 | : |
4919 | ( | 4971 | ( |
4920 | { before(grammarAccess.getAggregationAccess().getVerticalLineKeyword_3()); } | 4972 | { before(grammarAccess.getAggregationAccess().getVerticalLineKeyword_3()); } |
4921 | '|' | 4973 | VerticalLine |
4922 | { after(grammarAccess.getAggregationAccess().getVerticalLineKeyword_3()); } | 4974 | { after(grammarAccess.getAggregationAccess().getVerticalLineKeyword_3()); } |
4923 | ) | 4975 | ) |
4924 | ; | 4976 | ; |
@@ -4971,7 +5023,7 @@ rule__Aggregation__Group__5__Impl | |||
4971 | : | 5023 | : |
4972 | ( | 5024 | ( |
4973 | { before(grammarAccess.getAggregationAccess().getRightCurlyBracketKeyword_5()); } | 5025 | { before(grammarAccess.getAggregationAccess().getRightCurlyBracketKeyword_5()); } |
4974 | '}' | 5026 | RightCurlyBracket |
4975 | { after(grammarAccess.getAggregationAccess().getRightCurlyBracketKeyword_5()); } | 5027 | { after(grammarAccess.getAggregationAccess().getRightCurlyBracketKeyword_5()); } |
4976 | ) | 5028 | ) |
4977 | ; | 5029 | ; |
@@ -4980,188 +5032,80 @@ finally { | |||
4980 | } | 5032 | } |
4981 | 5033 | ||
4982 | 5034 | ||
4983 | rule__AtomicExpression__Group_0__0 | 5035 | rule__AtomicExpression__Group_4__0 |
4984 | @init { | ||
4985 | int stackSize = keepStackSize(); | ||
4986 | } | ||
4987 | : | ||
4988 | rule__AtomicExpression__Group_0__0__Impl | ||
4989 | rule__AtomicExpression__Group_0__1 | ||
4990 | ; | ||
4991 | finally { | ||
4992 | restoreStackSize(stackSize); | ||
4993 | } | ||
4994 | |||
4995 | rule__AtomicExpression__Group_0__0__Impl | ||
4996 | @init { | ||
4997 | int stackSize = keepStackSize(); | ||
4998 | } | ||
4999 | : | ||
5000 | ( | ||
5001 | { before(grammarAccess.getAtomicExpressionAccess().getReferenceParserRuleCall_0_0()); } | ||
5002 | ruleReference | ||
5003 | { after(grammarAccess.getAtomicExpressionAccess().getReferenceParserRuleCall_0_0()); } | ||
5004 | ) | ||
5005 | ; | ||
5006 | finally { | ||
5007 | restoreStackSize(stackSize); | ||
5008 | } | ||
5009 | |||
5010 | rule__AtomicExpression__Group_0__1 | ||
5011 | @init { | ||
5012 | int stackSize = keepStackSize(); | ||
5013 | } | ||
5014 | : | ||
5015 | rule__AtomicExpression__Group_0__1__Impl | ||
5016 | ; | ||
5017 | finally { | ||
5018 | restoreStackSize(stackSize); | ||
5019 | } | ||
5020 | |||
5021 | rule__AtomicExpression__Group_0__1__Impl | ||
5022 | @init { | ||
5023 | int stackSize = keepStackSize(); | ||
5024 | } | ||
5025 | : | ||
5026 | ( | ||
5027 | { before(grammarAccess.getAtomicExpressionAccess().getGroup_0_1()); } | ||
5028 | (rule__AtomicExpression__Group_0_1__0)? | ||
5029 | { after(grammarAccess.getAtomicExpressionAccess().getGroup_0_1()); } | ||
5030 | ) | ||
5031 | ; | ||
5032 | finally { | ||
5033 | restoreStackSize(stackSize); | ||
5034 | } | ||
5035 | |||
5036 | |||
5037 | rule__AtomicExpression__Group_0_1__0 | ||
5038 | @init { | ||
5039 | int stackSize = keepStackSize(); | ||
5040 | } | ||
5041 | : | ||
5042 | rule__AtomicExpression__Group_0_1__0__Impl | ||
5043 | rule__AtomicExpression__Group_0_1__1 | ||
5044 | ; | ||
5045 | finally { | ||
5046 | restoreStackSize(stackSize); | ||
5047 | } | ||
5048 | |||
5049 | rule__AtomicExpression__Group_0_1__0__Impl | ||
5050 | @init { | ||
5051 | int stackSize = keepStackSize(); | ||
5052 | } | ||
5053 | : | ||
5054 | ( | ||
5055 | { before(grammarAccess.getAtomicExpressionAccess().getCallFunctorAction_0_1_0()); } | ||
5056 | () | ||
5057 | { after(grammarAccess.getAtomicExpressionAccess().getCallFunctorAction_0_1_0()); } | ||
5058 | ) | ||
5059 | ; | ||
5060 | finally { | ||
5061 | restoreStackSize(stackSize); | ||
5062 | } | ||
5063 | |||
5064 | rule__AtomicExpression__Group_0_1__1 | ||
5065 | @init { | ||
5066 | int stackSize = keepStackSize(); | ||
5067 | } | ||
5068 | : | ||
5069 | rule__AtomicExpression__Group_0_1__1__Impl | ||
5070 | ; | ||
5071 | finally { | ||
5072 | restoreStackSize(stackSize); | ||
5073 | } | ||
5074 | |||
5075 | rule__AtomicExpression__Group_0_1__1__Impl | ||
5076 | @init { | ||
5077 | int stackSize = keepStackSize(); | ||
5078 | } | ||
5079 | : | ||
5080 | ( | ||
5081 | { before(grammarAccess.getAtomicExpressionAccess().getArgumentListAssignment_0_1_1()); } | ||
5082 | (rule__AtomicExpression__ArgumentListAssignment_0_1_1) | ||
5083 | { after(grammarAccess.getAtomicExpressionAccess().getArgumentListAssignment_0_1_1()); } | ||
5084 | ) | ||
5085 | ; | ||
5086 | finally { | ||
5087 | restoreStackSize(stackSize); | ||
5088 | } | ||
5089 | |||
5090 | |||
5091 | rule__AtomicExpression__Group_3__0 | ||
5092 | @init { | 5036 | @init { |
5093 | int stackSize = keepStackSize(); | 5037 | int stackSize = keepStackSize(); |
5094 | } | 5038 | } |
5095 | : | 5039 | : |
5096 | rule__AtomicExpression__Group_3__0__Impl | 5040 | rule__AtomicExpression__Group_4__0__Impl |
5097 | rule__AtomicExpression__Group_3__1 | 5041 | rule__AtomicExpression__Group_4__1 |
5098 | ; | 5042 | ; |
5099 | finally { | 5043 | finally { |
5100 | restoreStackSize(stackSize); | 5044 | restoreStackSize(stackSize); |
5101 | } | 5045 | } |
5102 | 5046 | ||
5103 | rule__AtomicExpression__Group_3__0__Impl | 5047 | rule__AtomicExpression__Group_4__0__Impl |
5104 | @init { | 5048 | @init { |
5105 | int stackSize = keepStackSize(); | 5049 | int stackSize = keepStackSize(); |
5106 | } | 5050 | } |
5107 | : | 5051 | : |
5108 | ( | 5052 | ( |
5109 | { before(grammarAccess.getAtomicExpressionAccess().getLeftParenthesisKeyword_3_0()); } | 5053 | { before(grammarAccess.getAtomicExpressionAccess().getLeftParenthesisKeyword_4_0()); } |
5110 | '(' | 5054 | LeftParenthesis |
5111 | { after(grammarAccess.getAtomicExpressionAccess().getLeftParenthesisKeyword_3_0()); } | 5055 | { after(grammarAccess.getAtomicExpressionAccess().getLeftParenthesisKeyword_4_0()); } |
5112 | ) | 5056 | ) |
5113 | ; | 5057 | ; |
5114 | finally { | 5058 | finally { |
5115 | restoreStackSize(stackSize); | 5059 | restoreStackSize(stackSize); |
5116 | } | 5060 | } |
5117 | 5061 | ||
5118 | rule__AtomicExpression__Group_3__1 | 5062 | rule__AtomicExpression__Group_4__1 |
5119 | @init { | 5063 | @init { |
5120 | int stackSize = keepStackSize(); | 5064 | int stackSize = keepStackSize(); |
5121 | } | 5065 | } |
5122 | : | 5066 | : |
5123 | rule__AtomicExpression__Group_3__1__Impl | 5067 | rule__AtomicExpression__Group_4__1__Impl |
5124 | rule__AtomicExpression__Group_3__2 | 5068 | rule__AtomicExpression__Group_4__2 |
5125 | ; | 5069 | ; |
5126 | finally { | 5070 | finally { |
5127 | restoreStackSize(stackSize); | 5071 | restoreStackSize(stackSize); |
5128 | } | 5072 | } |
5129 | 5073 | ||
5130 | rule__AtomicExpression__Group_3__1__Impl | 5074 | rule__AtomicExpression__Group_4__1__Impl |
5131 | @init { | 5075 | @init { |
5132 | int stackSize = keepStackSize(); | 5076 | int stackSize = keepStackSize(); |
5133 | } | 5077 | } |
5134 | : | 5078 | : |
5135 | ( | 5079 | ( |
5136 | { before(grammarAccess.getAtomicExpressionAccess().getExpressionParserRuleCall_3_1()); } | 5080 | { before(grammarAccess.getAtomicExpressionAccess().getExpressionParserRuleCall_4_1()); } |
5137 | ruleExpression | 5081 | ruleExpression |
5138 | { after(grammarAccess.getAtomicExpressionAccess().getExpressionParserRuleCall_3_1()); } | 5082 | { after(grammarAccess.getAtomicExpressionAccess().getExpressionParserRuleCall_4_1()); } |
5139 | ) | 5083 | ) |
5140 | ; | 5084 | ; |
5141 | finally { | 5085 | finally { |
5142 | restoreStackSize(stackSize); | 5086 | restoreStackSize(stackSize); |
5143 | } | 5087 | } |
5144 | 5088 | ||
5145 | rule__AtomicExpression__Group_3__2 | 5089 | rule__AtomicExpression__Group_4__2 |
5146 | @init { | 5090 | @init { |
5147 | int stackSize = keepStackSize(); | 5091 | int stackSize = keepStackSize(); |
5148 | } | 5092 | } |
5149 | : | 5093 | : |
5150 | rule__AtomicExpression__Group_3__2__Impl | 5094 | rule__AtomicExpression__Group_4__2__Impl |
5151 | ; | 5095 | ; |
5152 | finally { | 5096 | finally { |
5153 | restoreStackSize(stackSize); | 5097 | restoreStackSize(stackSize); |
5154 | } | 5098 | } |
5155 | 5099 | ||
5156 | rule__AtomicExpression__Group_3__2__Impl | 5100 | rule__AtomicExpression__Group_4__2__Impl |
5157 | @init { | 5101 | @init { |
5158 | int stackSize = keepStackSize(); | 5102 | int stackSize = keepStackSize(); |
5159 | } | 5103 | } |
5160 | : | 5104 | : |
5161 | ( | 5105 | ( |
5162 | { before(grammarAccess.getAtomicExpressionAccess().getRightParenthesisKeyword_3_2()); } | 5106 | { before(grammarAccess.getAtomicExpressionAccess().getRightParenthesisKeyword_4_2()); } |
5163 | ')' | 5107 | RightParenthesis |
5164 | { after(grammarAccess.getAtomicExpressionAccess().getRightParenthesisKeyword_3_2()); } | 5108 | { after(grammarAccess.getAtomicExpressionAccess().getRightParenthesisKeyword_4_2()); } |
5165 | ) | 5109 | ) |
5166 | ; | 5110 | ; |
5167 | finally { | 5111 | finally { |
@@ -5296,7 +5240,7 @@ rule__ArgumentList__Group__1__Impl | |||
5296 | : | 5240 | : |
5297 | ( | 5241 | ( |
5298 | { before(grammarAccess.getArgumentListAccess().getLeftParenthesisKeyword_1()); } | 5242 | { before(grammarAccess.getArgumentListAccess().getLeftParenthesisKeyword_1()); } |
5299 | '(' | 5243 | LeftParenthesis |
5300 | { after(grammarAccess.getArgumentListAccess().getLeftParenthesisKeyword_1()); } | 5244 | { after(grammarAccess.getArgumentListAccess().getLeftParenthesisKeyword_1()); } |
5301 | ) | 5245 | ) |
5302 | ; | 5246 | ; |
@@ -5349,7 +5293,7 @@ rule__ArgumentList__Group__3__Impl | |||
5349 | : | 5293 | : |
5350 | ( | 5294 | ( |
5351 | { before(grammarAccess.getArgumentListAccess().getRightParenthesisKeyword_3()); } | 5295 | { before(grammarAccess.getArgumentListAccess().getRightParenthesisKeyword_3()); } |
5352 | ')' | 5296 | RightParenthesis |
5353 | { after(grammarAccess.getArgumentListAccess().getRightParenthesisKeyword_3()); } | 5297 | { after(grammarAccess.getArgumentListAccess().getRightParenthesisKeyword_3()); } |
5354 | ) | 5298 | ) |
5355 | ; | 5299 | ; |
@@ -5431,7 +5375,7 @@ rule__ArgumentList__Group_2_1__0__Impl | |||
5431 | : | 5375 | : |
5432 | ( | 5376 | ( |
5433 | { before(grammarAccess.getArgumentListAccess().getCommaKeyword_2_1_0()); } | 5377 | { before(grammarAccess.getArgumentListAccess().getCommaKeyword_2_1_0()); } |
5434 | ',' | 5378 | Comma |
5435 | { after(grammarAccess.getArgumentListAccess().getCommaKeyword_2_1_0()); } | 5379 | { after(grammarAccess.getArgumentListAccess().getCommaKeyword_2_1_0()); } |
5436 | ) | 5380 | ) |
5437 | ; | 5381 | ; |
@@ -5511,7 +5455,7 @@ rule__StarArgument__Group__1__Impl | |||
5511 | : | 5455 | : |
5512 | ( | 5456 | ( |
5513 | { before(grammarAccess.getStarArgumentAccess().getAsteriskKeyword_1()); } | 5457 | { before(grammarAccess.getStarArgumentAccess().getAsteriskKeyword_1()); } |
5514 | '*' | 5458 | Asterisk |
5515 | { after(grammarAccess.getStarArgumentAccess().getAsteriskKeyword_1()); } | 5459 | { after(grammarAccess.getStarArgumentAccess().getAsteriskKeyword_1()); } |
5516 | ) | 5460 | ) |
5517 | ; | 5461 | ; |
@@ -5619,7 +5563,7 @@ rule__TypedStarArgument__Group__1__Impl | |||
5619 | : | 5563 | : |
5620 | ( | 5564 | ( |
5621 | { before(grammarAccess.getTypedStarArgumentAccess().getAsteriskKeyword_1()); } | 5565 | { before(grammarAccess.getTypedStarArgumentAccess().getAsteriskKeyword_1()); } |
5622 | '*' | 5566 | Asterisk |
5623 | { after(grammarAccess.getTypedStarArgumentAccess().getAsteriskKeyword_1()); } | 5567 | { after(grammarAccess.getTypedStarArgumentAccess().getAsteriskKeyword_1()); } |
5624 | ) | 5568 | ) |
5625 | ; | 5569 | ; |
@@ -5647,7 +5591,7 @@ rule__Interval__Group__0__Impl | |||
5647 | : | 5591 | : |
5648 | ( | 5592 | ( |
5649 | { before(grammarAccess.getIntervalAccess().getLeftSquareBracketKeyword_0()); } | 5593 | { before(grammarAccess.getIntervalAccess().getLeftSquareBracketKeyword_0()); } |
5650 | '[' | 5594 | LeftSquareBracket |
5651 | { after(grammarAccess.getIntervalAccess().getLeftSquareBracketKeyword_0()); } | 5595 | { after(grammarAccess.getIntervalAccess().getLeftSquareBracketKeyword_0()); } |
5652 | ) | 5596 | ) |
5653 | ; | 5597 | ; |
@@ -5701,7 +5645,7 @@ rule__Interval__Group__2__Impl | |||
5701 | : | 5645 | : |
5702 | ( | 5646 | ( |
5703 | { before(grammarAccess.getIntervalAccess().getFullStopFullStopKeyword_2()); } | 5647 | { before(grammarAccess.getIntervalAccess().getFullStopFullStopKeyword_2()); } |
5704 | '..' | 5648 | FullStopFullStop |
5705 | { after(grammarAccess.getIntervalAccess().getFullStopFullStopKeyword_2()); } | 5649 | { after(grammarAccess.getIntervalAccess().getFullStopFullStopKeyword_2()); } |
5706 | ) | 5650 | ) |
5707 | ; | 5651 | ; |
@@ -5754,7 +5698,7 @@ rule__Interval__Group__4__Impl | |||
5754 | : | 5698 | : |
5755 | ( | 5699 | ( |
5756 | { before(grammarAccess.getIntervalAccess().getRightSquareBracketKeyword_4()); } | 5700 | { before(grammarAccess.getIntervalAccess().getRightSquareBracketKeyword_4()); } |
5757 | ']' | 5701 | RightSquareBracket |
5758 | { after(grammarAccess.getIntervalAccess().getRightSquareBracketKeyword_4()); } | 5702 | { after(grammarAccess.getIntervalAccess().getRightSquareBracketKeyword_4()); } |
5759 | ) | 5703 | ) |
5760 | ; | 5704 | ; |
@@ -5808,7 +5752,7 @@ rule__InfinityLiteral__Group__1__Impl | |||
5808 | : | 5752 | : |
5809 | ( | 5753 | ( |
5810 | { before(grammarAccess.getInfinityLiteralAccess().getInfKeyword_1()); } | 5754 | { before(grammarAccess.getInfinityLiteralAccess().getInfKeyword_1()); } |
5811 | 'inf' | 5755 | Inf |
5812 | { after(grammarAccess.getInfinityLiteralAccess().getInfKeyword_1()); } | 5756 | { after(grammarAccess.getInfinityLiteralAccess().getInfKeyword_1()); } |
5813 | ) | 5757 | ) |
5814 | ; | 5758 | ; |
@@ -5862,7 +5806,7 @@ rule__EmptyIntervalLiteral__Group__1__Impl | |||
5862 | : | 5806 | : |
5863 | ( | 5807 | ( |
5864 | { before(grammarAccess.getEmptyIntervalLiteralAccess().getEmptyKeyword_1()); } | 5808 | { before(grammarAccess.getEmptyIntervalLiteralAccess().getEmptyKeyword_1()); } |
5865 | 'empty' | 5809 | Empty |
5866 | { after(grammarAccess.getEmptyIntervalLiteralAccess().getEmptyKeyword_1()); } | 5810 | { after(grammarAccess.getEmptyIntervalLiteralAccess().getEmptyKeyword_1()); } |
5867 | ) | 5811 | ) |
5868 | ; | 5812 | ; |
@@ -5917,7 +5861,7 @@ rule__ClassDefinition__Group__1__Impl | |||
5917 | : | 5861 | : |
5918 | ( | 5862 | ( |
5919 | { before(grammarAccess.getClassDefinitionAccess().getClassKeyword_1()); } | 5863 | { before(grammarAccess.getClassDefinitionAccess().getClassKeyword_1()); } |
5920 | 'class' | 5864 | Class |
5921 | { after(grammarAccess.getClassDefinitionAccess().getClassKeyword_1()); } | 5865 | { after(grammarAccess.getClassDefinitionAccess().getClassKeyword_1()); } |
5922 | ) | 5866 | ) |
5923 | ; | 5867 | ; |
@@ -5998,7 +5942,7 @@ rule__ClassDefinition__Group__4__Impl | |||
5998 | : | 5942 | : |
5999 | ( | 5943 | ( |
6000 | { before(grammarAccess.getClassDefinitionAccess().getLeftCurlyBracketKeyword_4()); } | 5944 | { before(grammarAccess.getClassDefinitionAccess().getLeftCurlyBracketKeyword_4()); } |
6001 | '{' | 5945 | LeftCurlyBracket |
6002 | { after(grammarAccess.getClassDefinitionAccess().getLeftCurlyBracketKeyword_4()); } | 5946 | { after(grammarAccess.getClassDefinitionAccess().getLeftCurlyBracketKeyword_4()); } |
6003 | ) | 5947 | ) |
6004 | ; | 5948 | ; |
@@ -6051,7 +5995,7 @@ rule__ClassDefinition__Group__6__Impl | |||
6051 | : | 5995 | : |
6052 | ( | 5996 | ( |
6053 | { before(grammarAccess.getClassDefinitionAccess().getRightCurlyBracketKeyword_6()); } | 5997 | { before(grammarAccess.getClassDefinitionAccess().getRightCurlyBracketKeyword_6()); } |
6054 | '}' | 5998 | RightCurlyBracket |
6055 | { after(grammarAccess.getClassDefinitionAccess().getRightCurlyBracketKeyword_6()); } | 5999 | { after(grammarAccess.getClassDefinitionAccess().getRightCurlyBracketKeyword_6()); } |
6056 | ) | 6000 | ) |
6057 | ; | 6001 | ; |
@@ -6079,7 +6023,7 @@ rule__ClassDefinition__Group_3__0__Impl | |||
6079 | : | 6023 | : |
6080 | ( | 6024 | ( |
6081 | { before(grammarAccess.getClassDefinitionAccess().getExtendsKeyword_3_0()); } | 6025 | { before(grammarAccess.getClassDefinitionAccess().getExtendsKeyword_3_0()); } |
6082 | 'extends' | 6026 | Extends |
6083 | { after(grammarAccess.getClassDefinitionAccess().getExtendsKeyword_3_0()); } | 6027 | { after(grammarAccess.getClassDefinitionAccess().getExtendsKeyword_3_0()); } |
6084 | ) | 6028 | ) |
6085 | ; | 6029 | ; |
@@ -6160,7 +6104,7 @@ rule__ClassDefinition__Group_3_2__0__Impl | |||
6160 | : | 6104 | : |
6161 | ( | 6105 | ( |
6162 | { before(grammarAccess.getClassDefinitionAccess().getCommaKeyword_3_2_0()); } | 6106 | { before(grammarAccess.getClassDefinitionAccess().getCommaKeyword_3_2_0()); } |
6163 | ',' | 6107 | Comma |
6164 | { after(grammarAccess.getClassDefinitionAccess().getCommaKeyword_3_2_0()); } | 6108 | { after(grammarAccess.getClassDefinitionAccess().getCommaKeyword_3_2_0()); } |
6165 | ) | 6109 | ) |
6166 | ; | 6110 | ; |
@@ -6348,7 +6292,7 @@ rule__MemberDefinition__Group__5__Impl | |||
6348 | : | 6292 | : |
6349 | ( | 6293 | ( |
6350 | { before(grammarAccess.getMemberDefinitionAccess().getSemicolonKeyword_5()); } | 6294 | { before(grammarAccess.getMemberDefinitionAccess().getSemicolonKeyword_5()); } |
6351 | (';')? | 6295 | (Semicolon)? |
6352 | { after(grammarAccess.getMemberDefinitionAccess().getSemicolonKeyword_5()); } | 6296 | { after(grammarAccess.getMemberDefinitionAccess().getSemicolonKeyword_5()); } |
6353 | ) | 6297 | ) |
6354 | ; | 6298 | ; |
@@ -6376,7 +6320,7 @@ rule__MemberDefinition__Group_4__0__Impl | |||
6376 | : | 6320 | : |
6377 | ( | 6321 | ( |
6378 | { before(grammarAccess.getMemberDefinitionAccess().getOppositeKeyword_4_0()); } | 6322 | { before(grammarAccess.getMemberDefinitionAccess().getOppositeKeyword_4_0()); } |
6379 | 'opposite' | 6323 | Opposite |
6380 | { after(grammarAccess.getMemberDefinitionAccess().getOppositeKeyword_4_0()); } | 6324 | { after(grammarAccess.getMemberDefinitionAccess().getOppositeKeyword_4_0()); } |
6381 | ) | 6325 | ) |
6382 | ; | 6326 | ; |
@@ -6457,7 +6401,7 @@ rule__ManyMultiplicity__Group__1__Impl | |||
6457 | : | 6401 | : |
6458 | ( | 6402 | ( |
6459 | { before(grammarAccess.getManyMultiplicityAccess().getLeftSquareBracketKeyword_1()); } | 6403 | { before(grammarAccess.getManyMultiplicityAccess().getLeftSquareBracketKeyword_1()); } |
6460 | '[' | 6404 | LeftSquareBracket |
6461 | { after(grammarAccess.getManyMultiplicityAccess().getLeftSquareBracketKeyword_1()); } | 6405 | { after(grammarAccess.getManyMultiplicityAccess().getLeftSquareBracketKeyword_1()); } |
6462 | ) | 6406 | ) |
6463 | ; | 6407 | ; |
@@ -6483,7 +6427,7 @@ rule__ManyMultiplicity__Group__2__Impl | |||
6483 | : | 6427 | : |
6484 | ( | 6428 | ( |
6485 | { before(grammarAccess.getManyMultiplicityAccess().getRightSquareBracketKeyword_2()); } | 6429 | { before(grammarAccess.getManyMultiplicityAccess().getRightSquareBracketKeyword_2()); } |
6486 | ']' | 6430 | RightSquareBracket |
6487 | { after(grammarAccess.getManyMultiplicityAccess().getRightSquareBracketKeyword_2()); } | 6431 | { after(grammarAccess.getManyMultiplicityAccess().getRightSquareBracketKeyword_2()); } |
6488 | ) | 6432 | ) |
6489 | ; | 6433 | ; |
@@ -6511,7 +6455,7 @@ rule__ExactMultiplicity__Group__0__Impl | |||
6511 | : | 6455 | : |
6512 | ( | 6456 | ( |
6513 | { before(grammarAccess.getExactMultiplicityAccess().getLeftSquareBracketKeyword_0()); } | 6457 | { before(grammarAccess.getExactMultiplicityAccess().getLeftSquareBracketKeyword_0()); } |
6514 | '[' | 6458 | LeftSquareBracket |
6515 | { after(grammarAccess.getExactMultiplicityAccess().getLeftSquareBracketKeyword_0()); } | 6459 | { after(grammarAccess.getExactMultiplicityAccess().getLeftSquareBracketKeyword_0()); } |
6516 | ) | 6460 | ) |
6517 | ; | 6461 | ; |
@@ -6564,7 +6508,7 @@ rule__ExactMultiplicity__Group__2__Impl | |||
6564 | : | 6508 | : |
6565 | ( | 6509 | ( |
6566 | { before(grammarAccess.getExactMultiplicityAccess().getRightSquareBracketKeyword_2()); } | 6510 | { before(grammarAccess.getExactMultiplicityAccess().getRightSquareBracketKeyword_2()); } |
6567 | ']' | 6511 | RightSquareBracket |
6568 | { after(grammarAccess.getExactMultiplicityAccess().getRightSquareBracketKeyword_2()); } | 6512 | { after(grammarAccess.getExactMultiplicityAccess().getRightSquareBracketKeyword_2()); } |
6569 | ) | 6513 | ) |
6570 | ; | 6514 | ; |
@@ -6592,7 +6536,7 @@ rule__BoundedMultiplicity__Group__0__Impl | |||
6592 | : | 6536 | : |
6593 | ( | 6537 | ( |
6594 | { before(grammarAccess.getBoundedMultiplicityAccess().getLeftSquareBracketKeyword_0()); } | 6538 | { before(grammarAccess.getBoundedMultiplicityAccess().getLeftSquareBracketKeyword_0()); } |
6595 | '[' | 6539 | LeftSquareBracket |
6596 | { after(grammarAccess.getBoundedMultiplicityAccess().getLeftSquareBracketKeyword_0()); } | 6540 | { after(grammarAccess.getBoundedMultiplicityAccess().getLeftSquareBracketKeyword_0()); } |
6597 | ) | 6541 | ) |
6598 | ; | 6542 | ; |
@@ -6646,7 +6590,7 @@ rule__BoundedMultiplicity__Group__2__Impl | |||
6646 | : | 6590 | : |
6647 | ( | 6591 | ( |
6648 | { before(grammarAccess.getBoundedMultiplicityAccess().getFullStopFullStopKeyword_2()); } | 6592 | { before(grammarAccess.getBoundedMultiplicityAccess().getFullStopFullStopKeyword_2()); } |
6649 | '..' | 6593 | FullStopFullStop |
6650 | { after(grammarAccess.getBoundedMultiplicityAccess().getFullStopFullStopKeyword_2()); } | 6594 | { after(grammarAccess.getBoundedMultiplicityAccess().getFullStopFullStopKeyword_2()); } |
6651 | ) | 6595 | ) |
6652 | ; | 6596 | ; |
@@ -6699,7 +6643,7 @@ rule__BoundedMultiplicity__Group__4__Impl | |||
6699 | : | 6643 | : |
6700 | ( | 6644 | ( |
6701 | { before(grammarAccess.getBoundedMultiplicityAccess().getRightSquareBracketKeyword_4()); } | 6645 | { before(grammarAccess.getBoundedMultiplicityAccess().getRightSquareBracketKeyword_4()); } |
6702 | ']' | 6646 | RightSquareBracket |
6703 | { after(grammarAccess.getBoundedMultiplicityAccess().getRightSquareBracketKeyword_4()); } | 6647 | { after(grammarAccess.getBoundedMultiplicityAccess().getRightSquareBracketKeyword_4()); } |
6704 | ) | 6648 | ) |
6705 | ; | 6649 | ; |
@@ -6727,7 +6671,7 @@ rule__ExactScopeDefinition__Group__0__Impl | |||
6727 | : | 6671 | : |
6728 | ( | 6672 | ( |
6729 | { before(grammarAccess.getExactScopeDefinitionAccess().getScopeKeyword_0()); } | 6673 | { before(grammarAccess.getExactScopeDefinitionAccess().getScopeKeyword_0()); } |
6730 | 'scope' | 6674 | Scope |
6731 | { after(grammarAccess.getExactScopeDefinitionAccess().getScopeKeyword_0()); } | 6675 | { after(grammarAccess.getExactScopeDefinitionAccess().getScopeKeyword_0()); } |
6732 | ) | 6676 | ) |
6733 | ; | 6677 | ; |
@@ -6781,7 +6725,7 @@ rule__ExactScopeDefinition__Group__2__Impl | |||
6781 | : | 6725 | : |
6782 | ( | 6726 | ( |
6783 | { before(grammarAccess.getExactScopeDefinitionAccess().getEqualsSignEqualsSignKeyword_2()); } | 6727 | { before(grammarAccess.getExactScopeDefinitionAccess().getEqualsSignEqualsSignKeyword_2()); } |
6784 | '==' | 6728 | EqualsSignEqualsSign |
6785 | { after(grammarAccess.getExactScopeDefinitionAccess().getEqualsSignEqualsSignKeyword_2()); } | 6729 | { after(grammarAccess.getExactScopeDefinitionAccess().getEqualsSignEqualsSignKeyword_2()); } |
6786 | ) | 6730 | ) |
6787 | ; | 6731 | ; |
@@ -6835,7 +6779,7 @@ rule__BoundedScopeDefinition__Group__0__Impl | |||
6835 | : | 6779 | : |
6836 | ( | 6780 | ( |
6837 | { before(grammarAccess.getBoundedScopeDefinitionAccess().getScopeKeyword_0()); } | 6781 | { before(grammarAccess.getBoundedScopeDefinitionAccess().getScopeKeyword_0()); } |
6838 | 'scope' | 6782 | Scope |
6839 | { after(grammarAccess.getBoundedScopeDefinitionAccess().getScopeKeyword_0()); } | 6783 | { after(grammarAccess.getBoundedScopeDefinitionAccess().getScopeKeyword_0()); } |
6840 | ) | 6784 | ) |
6841 | ; | 6785 | ; |
@@ -6849,7 +6793,6 @@ rule__BoundedScopeDefinition__Group__1 | |||
6849 | } | 6793 | } |
6850 | : | 6794 | : |
6851 | rule__BoundedScopeDefinition__Group__1__Impl | 6795 | rule__BoundedScopeDefinition__Group__1__Impl |
6852 | rule__BoundedScopeDefinition__Group__2 | ||
6853 | ; | 6796 | ; |
6854 | finally { | 6797 | finally { |
6855 | restoreStackSize(stackSize); | 6798 | restoreStackSize(stackSize); |
@@ -6870,32 +6813,6 @@ finally { | |||
6870 | restoreStackSize(stackSize); | 6813 | restoreStackSize(stackSize); |
6871 | } | 6814 | } |
6872 | 6815 | ||
6873 | rule__BoundedScopeDefinition__Group__2 | ||
6874 | @init { | ||
6875 | int stackSize = keepStackSize(); | ||
6876 | } | ||
6877 | : | ||
6878 | rule__BoundedScopeDefinition__Group__2__Impl | ||
6879 | ; | ||
6880 | finally { | ||
6881 | restoreStackSize(stackSize); | ||
6882 | } | ||
6883 | |||
6884 | rule__BoundedScopeDefinition__Group__2__Impl | ||
6885 | @init { | ||
6886 | int stackSize = keepStackSize(); | ||
6887 | } | ||
6888 | : | ||
6889 | ( | ||
6890 | { before(grammarAccess.getBoundedScopeDefinitionAccess().getFullStopKeyword_2()); } | ||
6891 | '.' | ||
6892 | { after(grammarAccess.getBoundedScopeDefinitionAccess().getFullStopKeyword_2()); } | ||
6893 | ) | ||
6894 | ; | ||
6895 | finally { | ||
6896 | restoreStackSize(stackSize); | ||
6897 | } | ||
6898 | |||
6899 | 6816 | ||
6900 | rule__BoundedScopeDefinition__Group_1_0__0 | 6817 | rule__BoundedScopeDefinition__Group_1_0__0 |
6901 | @init { | 6818 | @init { |
@@ -6970,7 +6887,7 @@ rule__BoundedScopeDefinition__Group_1_0__2__Impl | |||
6970 | : | 6887 | : |
6971 | ( | 6888 | ( |
6972 | { before(grammarAccess.getBoundedScopeDefinitionAccess().getLessThanSignEqualsSignKeyword_1_0_2()); } | 6889 | { before(grammarAccess.getBoundedScopeDefinitionAccess().getLessThanSignEqualsSignKeyword_1_0_2()); } |
6973 | '<=' | 6890 | LessThanSignEqualsSign |
6974 | { after(grammarAccess.getBoundedScopeDefinitionAccess().getLessThanSignEqualsSignKeyword_1_0_2()); } | 6891 | { after(grammarAccess.getBoundedScopeDefinitionAccess().getLessThanSignEqualsSignKeyword_1_0_2()); } |
6975 | ) | 6892 | ) |
6976 | ; | 6893 | ; |
@@ -7050,7 +6967,7 @@ rule__BoundedScopeDefinition__Group_1_0_0__1__Impl | |||
7050 | : | 6967 | : |
7051 | ( | 6968 | ( |
7052 | { before(grammarAccess.getBoundedScopeDefinitionAccess().getLessThanSignEqualsSignKeyword_1_0_0_1()); } | 6969 | { before(grammarAccess.getBoundedScopeDefinitionAccess().getLessThanSignEqualsSignKeyword_1_0_0_1()); } |
7053 | '<=' | 6970 | LessThanSignEqualsSign |
7054 | { after(grammarAccess.getBoundedScopeDefinitionAccess().getLessThanSignEqualsSignKeyword_1_0_0_1()); } | 6971 | { after(grammarAccess.getBoundedScopeDefinitionAccess().getLessThanSignEqualsSignKeyword_1_0_0_1()); } |
7055 | ) | 6972 | ) |
7056 | ; | 6973 | ; |
@@ -7105,7 +7022,7 @@ rule__BoundedScopeDefinition__Group_1_1__1__Impl | |||
7105 | : | 7022 | : |
7106 | ( | 7023 | ( |
7107 | { before(grammarAccess.getBoundedScopeDefinitionAccess().getGreaterThanSignEqualsSignKeyword_1_1_1()); } | 7024 | { before(grammarAccess.getBoundedScopeDefinitionAccess().getGreaterThanSignEqualsSignKeyword_1_1_1()); } |
7108 | '>=' | 7025 | GreaterThanSignEqualsSign |
7109 | { after(grammarAccess.getBoundedScopeDefinitionAccess().getGreaterThanSignEqualsSignKeyword_1_1_1()); } | 7026 | { after(grammarAccess.getBoundedScopeDefinitionAccess().getGreaterThanSignEqualsSignKeyword_1_1_1()); } |
7110 | ) | 7027 | ) |
7111 | ; | 7028 | ; |
@@ -7186,7 +7103,7 @@ rule__BoundedScopeDefinition__Group_1_1_3__0__Impl | |||
7186 | : | 7103 | : |
7187 | ( | 7104 | ( |
7188 | { before(grammarAccess.getBoundedScopeDefinitionAccess().getGreaterThanSignEqualsSignKeyword_1_1_3_0()); } | 7105 | { before(grammarAccess.getBoundedScopeDefinitionAccess().getGreaterThanSignEqualsSignKeyword_1_1_3_0()); } |
7189 | '>=' | 7106 | GreaterThanSignEqualsSign |
7190 | { after(grammarAccess.getBoundedScopeDefinitionAccess().getGreaterThanSignEqualsSignKeyword_1_1_3_0()); } | 7107 | { after(grammarAccess.getBoundedScopeDefinitionAccess().getGreaterThanSignEqualsSignKeyword_1_1_3_0()); } |
7191 | ) | 7108 | ) |
7192 | ; | 7109 | ; |
@@ -7240,7 +7157,7 @@ rule__LowerBoundedScopeDefinition__Group__0__Impl | |||
7240 | : | 7157 | : |
7241 | ( | 7158 | ( |
7242 | { before(grammarAccess.getLowerBoundedScopeDefinitionAccess().getScopeKeyword_0()); } | 7159 | { before(grammarAccess.getLowerBoundedScopeDefinitionAccess().getScopeKeyword_0()); } |
7243 | 'scope' | 7160 | Scope |
7244 | { after(grammarAccess.getLowerBoundedScopeDefinitionAccess().getScopeKeyword_0()); } | 7161 | { after(grammarAccess.getLowerBoundedScopeDefinitionAccess().getScopeKeyword_0()); } |
7245 | ) | 7162 | ) |
7246 | ; | 7163 | ; |
@@ -7254,7 +7171,6 @@ rule__LowerBoundedScopeDefinition__Group__1 | |||
7254 | } | 7171 | } |
7255 | : | 7172 | : |
7256 | rule__LowerBoundedScopeDefinition__Group__1__Impl | 7173 | rule__LowerBoundedScopeDefinition__Group__1__Impl |
7257 | rule__LowerBoundedScopeDefinition__Group__2 | ||
7258 | ; | 7174 | ; |
7259 | finally { | 7175 | finally { |
7260 | restoreStackSize(stackSize); | 7176 | restoreStackSize(stackSize); |
@@ -7275,32 +7191,6 @@ finally { | |||
7275 | restoreStackSize(stackSize); | 7191 | restoreStackSize(stackSize); |
7276 | } | 7192 | } |
7277 | 7193 | ||
7278 | rule__LowerBoundedScopeDefinition__Group__2 | ||
7279 | @init { | ||
7280 | int stackSize = keepStackSize(); | ||
7281 | } | ||
7282 | : | ||
7283 | rule__LowerBoundedScopeDefinition__Group__2__Impl | ||
7284 | ; | ||
7285 | finally { | ||
7286 | restoreStackSize(stackSize); | ||
7287 | } | ||
7288 | |||
7289 | rule__LowerBoundedScopeDefinition__Group__2__Impl | ||
7290 | @init { | ||
7291 | int stackSize = keepStackSize(); | ||
7292 | } | ||
7293 | : | ||
7294 | ( | ||
7295 | { before(grammarAccess.getLowerBoundedScopeDefinitionAccess().getFullStopKeyword_2()); } | ||
7296 | '.' | ||
7297 | { after(grammarAccess.getLowerBoundedScopeDefinitionAccess().getFullStopKeyword_2()); } | ||
7298 | ) | ||
7299 | ; | ||
7300 | finally { | ||
7301 | restoreStackSize(stackSize); | ||
7302 | } | ||
7303 | |||
7304 | 7194 | ||
7305 | rule__LowerBoundedScopeDefinition__Group_1_0__0 | 7195 | rule__LowerBoundedScopeDefinition__Group_1_0__0 |
7306 | @init { | 7196 | @init { |
@@ -7348,7 +7238,7 @@ rule__LowerBoundedScopeDefinition__Group_1_0__1__Impl | |||
7348 | : | 7238 | : |
7349 | ( | 7239 | ( |
7350 | { before(grammarAccess.getLowerBoundedScopeDefinitionAccess().getLessThanSignEqualsSignKeyword_1_0_1()); } | 7240 | { before(grammarAccess.getLowerBoundedScopeDefinitionAccess().getLessThanSignEqualsSignKeyword_1_0_1()); } |
7351 | '<=' | 7241 | LessThanSignEqualsSign |
7352 | { after(grammarAccess.getLowerBoundedScopeDefinitionAccess().getLessThanSignEqualsSignKeyword_1_0_1()); } | 7242 | { after(grammarAccess.getLowerBoundedScopeDefinitionAccess().getLessThanSignEqualsSignKeyword_1_0_1()); } |
7353 | ) | 7243 | ) |
7354 | ; | 7244 | ; |
@@ -7429,7 +7319,7 @@ rule__LowerBoundedScopeDefinition__Group_1_1__1__Impl | |||
7429 | : | 7319 | : |
7430 | ( | 7320 | ( |
7431 | { before(grammarAccess.getLowerBoundedScopeDefinitionAccess().getGreaterThanSignEqualsSignKeyword_1_1_1()); } | 7321 | { before(grammarAccess.getLowerBoundedScopeDefinitionAccess().getGreaterThanSignEqualsSignKeyword_1_1_1()); } |
7432 | '>=' | 7322 | GreaterThanSignEqualsSign |
7433 | { after(grammarAccess.getLowerBoundedScopeDefinitionAccess().getGreaterThanSignEqualsSignKeyword_1_1_1()); } | 7323 | { after(grammarAccess.getLowerBoundedScopeDefinitionAccess().getGreaterThanSignEqualsSignKeyword_1_1_1()); } |
7434 | ) | 7324 | ) |
7435 | ; | 7325 | ; |
@@ -7591,7 +7481,7 @@ rule__Real__Group_1__0__Impl | |||
7591 | : | 7481 | : |
7592 | ( | 7482 | ( |
7593 | { before(grammarAccess.getRealAccess().getFullStopKeyword_1_0()); } | 7483 | { before(grammarAccess.getRealAccess().getFullStopKeyword_1_0()); } |
7594 | '.' | 7484 | FullStop |
7595 | { after(grammarAccess.getRealAccess().getFullStopKeyword_1_0()); } | 7485 | { after(grammarAccess.getRealAccess().getFullStopKeyword_1_0()); } |
7596 | ) | 7486 | ) |
7597 | ; | 7487 | ; |
@@ -7699,7 +7589,7 @@ rule__QualifiedName__Group_0_1__0__Impl | |||
7699 | : | 7589 | : |
7700 | ( | 7590 | ( |
7701 | { before(grammarAccess.getQualifiedNameAccess().getFullStopKeyword_0_1_0()); } | 7591 | { before(grammarAccess.getQualifiedNameAccess().getFullStopKeyword_0_1_0()); } |
7702 | '.' | 7592 | FullStop |
7703 | { after(grammarAccess.getQualifiedNameAccess().getFullStopKeyword_0_1_0()); } | 7593 | { after(grammarAccess.getQualifiedNameAccess().getFullStopKeyword_0_1_0()); } |
7704 | ) | 7594 | ) |
7705 | ; | 7595 | ; |
@@ -7803,7 +7693,7 @@ rule__PredicateDefinition__FunctionalAssignment_0_0_0 | |||
7803 | { before(grammarAccess.getPredicateDefinitionAccess().getFunctionalFunctionalKeyword_0_0_0_0()); } | 7693 | { before(grammarAccess.getPredicateDefinitionAccess().getFunctionalFunctionalKeyword_0_0_0_0()); } |
7804 | ( | 7694 | ( |
7805 | { before(grammarAccess.getPredicateDefinitionAccess().getFunctionalFunctionalKeyword_0_0_0_0()); } | 7695 | { before(grammarAccess.getPredicateDefinitionAccess().getFunctionalFunctionalKeyword_0_0_0_0()); } |
7806 | 'functional' | 7696 | Functional |
7807 | { after(grammarAccess.getPredicateDefinitionAccess().getFunctionalFunctionalKeyword_0_0_0_0()); } | 7697 | { after(grammarAccess.getPredicateDefinitionAccess().getFunctionalFunctionalKeyword_0_0_0_0()); } |
7808 | ) | 7698 | ) |
7809 | { after(grammarAccess.getPredicateDefinitionAccess().getFunctionalFunctionalKeyword_0_0_0_0()); } | 7699 | { after(grammarAccess.getPredicateDefinitionAccess().getFunctionalFunctionalKeyword_0_0_0_0()); } |
@@ -7822,7 +7712,7 @@ rule__PredicateDefinition__ErrorAssignment_0_0_1 | |||
7822 | { before(grammarAccess.getPredicateDefinitionAccess().getErrorErrorKeyword_0_0_1_0()); } | 7712 | { before(grammarAccess.getPredicateDefinitionAccess().getErrorErrorKeyword_0_0_1_0()); } |
7823 | ( | 7713 | ( |
7824 | { before(grammarAccess.getPredicateDefinitionAccess().getErrorErrorKeyword_0_0_1_0()); } | 7714 | { before(grammarAccess.getPredicateDefinitionAccess().getErrorErrorKeyword_0_0_1_0()); } |
7825 | 'error' | 7715 | Error |
7826 | { after(grammarAccess.getPredicateDefinitionAccess().getErrorErrorKeyword_0_0_1_0()); } | 7716 | { after(grammarAccess.getPredicateDefinitionAccess().getErrorErrorKeyword_0_0_1_0()); } |
7827 | ) | 7717 | ) |
7828 | { after(grammarAccess.getPredicateDefinitionAccess().getErrorErrorKeyword_0_0_1_0()); } | 7718 | { after(grammarAccess.getPredicateDefinitionAccess().getErrorErrorKeyword_0_0_1_0()); } |
@@ -7841,7 +7731,7 @@ rule__PredicateDefinition__ErrorAssignment_0_1_0 | |||
7841 | { before(grammarAccess.getPredicateDefinitionAccess().getErrorErrorKeyword_0_1_0_0()); } | 7731 | { before(grammarAccess.getPredicateDefinitionAccess().getErrorErrorKeyword_0_1_0_0()); } |
7842 | ( | 7732 | ( |
7843 | { before(grammarAccess.getPredicateDefinitionAccess().getErrorErrorKeyword_0_1_0_0()); } | 7733 | { before(grammarAccess.getPredicateDefinitionAccess().getErrorErrorKeyword_0_1_0_0()); } |
7844 | 'error' | 7734 | Error |
7845 | { after(grammarAccess.getPredicateDefinitionAccess().getErrorErrorKeyword_0_1_0_0()); } | 7735 | { after(grammarAccess.getPredicateDefinitionAccess().getErrorErrorKeyword_0_1_0_0()); } |
7846 | ) | 7736 | ) |
7847 | { after(grammarAccess.getPredicateDefinitionAccess().getErrorErrorKeyword_0_1_0_0()); } | 7737 | { after(grammarAccess.getPredicateDefinitionAccess().getErrorErrorKeyword_0_1_0_0()); } |
@@ -7860,7 +7750,7 @@ rule__PredicateDefinition__FunctionalAssignment_0_1_1 | |||
7860 | { before(grammarAccess.getPredicateDefinitionAccess().getFunctionalFunctionalKeyword_0_1_1_0()); } | 7750 | { before(grammarAccess.getPredicateDefinitionAccess().getFunctionalFunctionalKeyword_0_1_1_0()); } |
7861 | ( | 7751 | ( |
7862 | { before(grammarAccess.getPredicateDefinitionAccess().getFunctionalFunctionalKeyword_0_1_1_0()); } | 7752 | { before(grammarAccess.getPredicateDefinitionAccess().getFunctionalFunctionalKeyword_0_1_1_0()); } |
7863 | 'functional' | 7753 | Functional |
7864 | { after(grammarAccess.getPredicateDefinitionAccess().getFunctionalFunctionalKeyword_0_1_1_0()); } | 7754 | { after(grammarAccess.getPredicateDefinitionAccess().getFunctionalFunctionalKeyword_0_1_1_0()); } |
7865 | ) | 7755 | ) |
7866 | { after(grammarAccess.getPredicateDefinitionAccess().getFunctionalFunctionalKeyword_0_1_1_0()); } | 7756 | { after(grammarAccess.getPredicateDefinitionAccess().getFunctionalFunctionalKeyword_0_1_1_0()); } |
@@ -8395,21 +8285,6 @@ finally { | |||
8395 | restoreStackSize(stackSize); | 8285 | restoreStackSize(stackSize); |
8396 | } | 8286 | } |
8397 | 8287 | ||
8398 | rule__AtomicExpression__ArgumentListAssignment_0_1_1 | ||
8399 | @init { | ||
8400 | int stackSize = keepStackSize(); | ||
8401 | } | ||
8402 | : | ||
8403 | ( | ||
8404 | { before(grammarAccess.getAtomicExpressionAccess().getArgumentListArgumentListParserRuleCall_0_1_1_0()); } | ||
8405 | ruleArgumentList | ||
8406 | { after(grammarAccess.getAtomicExpressionAccess().getArgumentListArgumentListParserRuleCall_0_1_1_0()); } | ||
8407 | ) | ||
8408 | ; | ||
8409 | finally { | ||
8410 | restoreStackSize(stackSize); | ||
8411 | } | ||
8412 | |||
8413 | rule__Call__FunctorAssignment_0 | 8288 | rule__Call__FunctorAssignment_0 |
8414 | @init { | 8289 | @init { |
8415 | int stackSize = keepStackSize(); | 8290 | int stackSize = keepStackSize(); |
@@ -8431,9 +8306,9 @@ rule__Call__TransitiveClosureAssignment_1_0 | |||
8431 | } | 8306 | } |
8432 | : | 8307 | : |
8433 | ( | 8308 | ( |
8434 | { before(grammarAccess.getCallAccess().getTransitiveClosureSTARTerminalRuleCall_1_0_0()); } | 8309 | { before(grammarAccess.getCallAccess().getTransitiveClosureTRANSITIVE_CLOSURETerminalRuleCall_1_0_0()); } |
8435 | RULE_STAR | 8310 | RULE_TRANSITIVE_CLOSURE |
8436 | { after(grammarAccess.getCallAccess().getTransitiveClosureSTARTerminalRuleCall_1_0_0()); } | 8311 | { after(grammarAccess.getCallAccess().getTransitiveClosureTRANSITIVE_CLOSURETerminalRuleCall_1_0_0()); } |
8437 | ) | 8312 | ) |
8438 | ; | 8313 | ; |
8439 | finally { | 8314 | finally { |
@@ -8446,9 +8321,9 @@ rule__Call__ReflexiveTransitiveClosureAssignment_1_1 | |||
8446 | } | 8321 | } |
8447 | : | 8322 | : |
8448 | ( | 8323 | ( |
8449 | { before(grammarAccess.getCallAccess().getReflexiveTransitiveClosurePLUSTerminalRuleCall_1_1_0()); } | 8324 | { before(grammarAccess.getCallAccess().getReflexiveTransitiveClosureREFLEXIVE_TRANSITIVE_CLOSURETerminalRuleCall_1_1_0()); } |
8450 | RULE_PLUS | 8325 | RULE_REFLEXIVE_TRANSITIVE_CLOSURE |
8451 | { after(grammarAccess.getCallAccess().getReflexiveTransitiveClosurePLUSTerminalRuleCall_1_1_0()); } | 8326 | { after(grammarAccess.getCallAccess().getReflexiveTransitiveClosureREFLEXIVE_TRANSITIVE_CLOSURETerminalRuleCall_1_1_0()); } |
8452 | ) | 8327 | ) |
8453 | ; | 8328 | ; |
8454 | finally { | 8329 | finally { |
@@ -8675,7 +8550,7 @@ rule__ClassDefinition__AbstractAssignment_0 | |||
8675 | { before(grammarAccess.getClassDefinitionAccess().getAbstractAbstractKeyword_0_0()); } | 8550 | { before(grammarAccess.getClassDefinitionAccess().getAbstractAbstractKeyword_0_0()); } |
8676 | ( | 8551 | ( |
8677 | { before(grammarAccess.getClassDefinitionAccess().getAbstractAbstractKeyword_0_0()); } | 8552 | { before(grammarAccess.getClassDefinitionAccess().getAbstractAbstractKeyword_0_0()); } |
8678 | 'abstract' | 8553 | Abstract |
8679 | { after(grammarAccess.getClassDefinitionAccess().getAbstractAbstractKeyword_0_0()); } | 8554 | { after(grammarAccess.getClassDefinitionAccess().getAbstractAbstractKeyword_0_0()); } |
8680 | ) | 8555 | ) |
8681 | { after(grammarAccess.getClassDefinitionAccess().getAbstractAbstractKeyword_0_0()); } | 8556 | { after(grammarAccess.getClassDefinitionAccess().getAbstractAbstractKeyword_0_0()); } |
@@ -8762,7 +8637,7 @@ rule__MemberDefinition__ContainmentAssignment_0 | |||
8762 | { before(grammarAccess.getMemberDefinitionAccess().getContainmentContainsKeyword_0_0()); } | 8637 | { before(grammarAccess.getMemberDefinitionAccess().getContainmentContainsKeyword_0_0()); } |
8763 | ( | 8638 | ( |
8764 | { before(grammarAccess.getMemberDefinitionAccess().getContainmentContainsKeyword_0_0()); } | 8639 | { before(grammarAccess.getMemberDefinitionAccess().getContainmentContainsKeyword_0_0()); } |
8765 | 'contains' | 8640 | Contains |
8766 | { after(grammarAccess.getMemberDefinitionAccess().getContainmentContainsKeyword_0_0()); } | 8641 | { after(grammarAccess.getMemberDefinitionAccess().getContainmentContainsKeyword_0_0()); } |
8767 | ) | 8642 | ) |
8768 | { after(grammarAccess.getMemberDefinitionAccess().getContainmentContainsKeyword_0_0()); } | 8643 | { after(grammarAccess.getMemberDefinitionAccess().getContainmentContainsKeyword_0_0()); } |
@@ -9114,25 +8989,3 @@ rule__ObjectiveDefinition__ObjectiveAssignment_1 | |||
9114 | finally { | 8989 | finally { |
9115 | restoreStackSize(stackSize); | 8990 | restoreStackSize(stackSize); |
9116 | } | 8991 | } |
9117 | |||
9118 | RULE_STRING : '"' ('\\' .|~(('\\'|'"')))* '"'; | ||
9119 | |||
9120 | RULE_QUOTED_ID : '\'' ('\\' .|~(('\\'|'\'')))* '\''; | ||
9121 | |||
9122 | RULE_PLUS : 'synthetic::plus'; | ||
9123 | |||
9124 | RULE_STAR : 'synthetic::star'; | ||
9125 | |||
9126 | RULE_DOT : 'synthetic::dot'; | ||
9127 | |||
9128 | RULE_ID : '^'? ('a'..'z'|'A'..'Z'|'_') ('a'..'z'|'A'..'Z'|'_'|'0'..'9')*; | ||
9129 | |||
9130 | RULE_INT : ('0'..'9')+; | ||
9131 | |||
9132 | RULE_ML_COMMENT : '/*' ( options {greedy=false;} : . )*'*/'; | ||
9133 | |||
9134 | RULE_SL_COMMENT : '//' ~(('\n'|'\r'))* ('\r'? '\n')?; | ||
9135 | |||
9136 | RULE_WS : (' '|'\t'|'\r'|'\n')+; | ||
9137 | |||
9138 | RULE_ANY_OTHER : .; | ||
diff --git a/Application/org.eclipse.viatra.solver.language.ide/src-gen/org/eclipse/viatra/solver/language/ide/contentassist/antlr/internal/InternalSolverLanguageParser.java b/Application/org.eclipse.viatra.solver.language.ide/src-gen/org/eclipse/viatra/solver/language/ide/contentassist/antlr/internal/InternalSolverLanguageParser.java index 2da6b7d6..8664bb6d 100644 --- a/Application/org.eclipse.viatra.solver.language.ide/src-gen/org/eclipse/viatra/solver/language/ide/contentassist/antlr/internal/InternalSolverLanguageParser.java +++ b/Application/org.eclipse.viatra.solver.language.ide/src-gen/org/eclipse/viatra/solver/language/ide/contentassist/antlr/internal/InternalSolverLanguageParser.java | |||
@@ -1,4 +1,6 @@ | |||
1 | package org.eclipse.viatra.solver.language.ide.contentassist.antlr.internal; | 1 | package org.eclipse.viatra.solver.language.ide.contentassist.antlr.internal; |
2 | import java.util.Map; | ||
3 | import java.util.HashMap; | ||
2 | 4 | ||
3 | import java.io.InputStream; | 5 | import java.io.InputStream; |
4 | import org.eclipse.xtext.*; | 6 | import org.eclipse.xtext.*; |
@@ -18,85 +20,96 @@ import org.antlr.runtime.*; | |||
18 | import java.util.Stack; | 20 | import java.util.Stack; |
19 | import java.util.List; | 21 | import java.util.List; |
20 | import java.util.ArrayList; | 22 | import java.util.ArrayList; |
21 | import java.util.Map; | 23 | |
22 | import java.util.HashMap; | ||
23 | @SuppressWarnings("all") | 24 | @SuppressWarnings("all") |
24 | public class InternalSolverLanguageParser extends AbstractInternalContentAssistParser { | 25 | public class InternalSolverLanguageParser extends AbstractInternalContentAssistParser { |
25 | public static final String[] tokenNames = new String[] { | 26 | public static final String[] tokenNames = new String[] { |
26 | "<invalid>", "<EOR>", "<DOWN>", "<UP>", "RULE_INT", "RULE_QUOTED_ID", "RULE_DOT", "RULE_ID", "RULE_STAR", "RULE_PLUS", "RULE_STRING", "RULE_ML_COMMENT", "RULE_SL_COMMENT", "RULE_WS", "RULE_ANY_OTHER", "'^'", "'*'", "'int'", "'real'", "'=='", "'!='", "'<'", "'<='", "'>'", "'>='", "'in'", "'+'", "'-'", "'/'", "'!'", "'may'", "'must'", "'current'", "'only'", "'sum'", "'prod'", "'avg'", "'min'", "'max'", "'true'", "'false'", "'unknown'", "'error'", "'minimize'", "'maximize'", "':'", "':-'", "'='", "'default'", "'extern'", "'.'", "'if'", "'then'", "'else'", "';'", "'->'", "','", "'count'", "'{'", "'}'", "'|'", "'('", "')'", "'['", "'..'", "']'", "'inf'", "'empty'", "'class'", "'extends'", "'opposite'", "'scope'", "'functional'", "'abstract'", "'contains'" | 27 | "<invalid>", "<EOR>", "<DOWN>", "<UP>", "GREATER_EQ", "Functional", "Abstract", "Contains", "Maximize", "Minimize", "Opposite", "GREATER", "LESS_EQ", "Current", "Default", "Extends", "Unknown", "NOT_EQ", "Extern", "Class", "Count", "Empty", "Error", "False", "Scope", "LESS", "Else", "Must", "Only", "Prod", "Real", "Then", "True", "ADD", "DIV", "MUL", "POW", "SUB", "Avg", "Inf", "Int", "Max", "May", "Min", "Sum", "ExclamationMarkEqualsSign", "HyphenMinusGreaterThanSign", "FullStopFullStop", "ColonHyphenMinus", "LessThanSignEqualsSign", "EqualsSignEqualsSign", "GreaterThanSignEqualsSign", "EQ", "IN", "If", "In", "ExclamationMark", "LeftParenthesis", "RightParenthesis", "Asterisk", "PlusSign", "Comma", "HyphenMinus", "FullStop", "Solidus", "Colon", "Semicolon", "LessThanSign", "EqualsSign", "GreaterThanSign", "LeftSquareBracket", "RightSquareBracket", "CircumflexAccent", "LeftCurlyBracket", "VerticalLine", "RightCurlyBracket", "RULE_STRING", "RULE_QUOTED_ID", "RULE_SL_COMMENT", "RULE_TRANSITIVE_CLOSURE", "RULE_REFLEXIVE_TRANSITIVE_CLOSURE", "RULE_FULL_STOP", "RULE_ID", "RULE_INT", "RULE_ML_COMMENT", "RULE_WS", "RULE_ANY_OTHER" |
27 | }; | 28 | }; |
28 | public static final int T__50=50; | 29 | public static final int ADD=33; |
29 | public static final int T__19=19; | 30 | public static final int True=32; |
30 | public static final int T__15=15; | 31 | public static final int GREATER_EQ=4; |
31 | public static final int T__59=59; | 32 | public static final int Count=20; |
32 | public static final int T__16=16; | 33 | public static final int False=23; |
33 | public static final int T__17=17; | 34 | public static final int Must=27; |
34 | public static final int T__18=18; | 35 | public static final int LessThanSign=67; |
35 | public static final int T__55=55; | 36 | public static final int LeftParenthesis=57; |
36 | public static final int T__56=56; | 37 | public static final int Unknown=16; |
37 | public static final int T__57=57; | 38 | public static final int RULE_REFLEXIVE_TRANSITIVE_CLOSURE=80; |
38 | public static final int T__58=58; | 39 | public static final int FullStopFullStop=47; |
39 | public static final int T__51=51; | 40 | public static final int Real=30; |
40 | public static final int RULE_STAR=8; | 41 | public static final int Then=31; |
41 | public static final int T__52=52; | 42 | public static final int Extends=15; |
42 | public static final int T__53=53; | 43 | public static final int RightSquareBracket=71; |
43 | public static final int T__54=54; | 44 | public static final int ExclamationMark=56; |
44 | public static final int T__60=60; | 45 | public static final int Opposite=10; |
45 | public static final int T__61=61; | 46 | public static final int SUB=37; |
46 | public static final int RULE_ID=7; | 47 | public static final int GreaterThanSign=69; |
47 | public static final int RULE_QUOTED_ID=5; | 48 | public static final int NOT_EQ=17; |
48 | public static final int T__26=26; | 49 | public static final int RULE_ID=82; |
49 | public static final int T__27=27; | 50 | public static final int MUL=35; |
50 | public static final int T__28=28; | 51 | public static final int IN=53; |
51 | public static final int RULE_INT=4; | 52 | public static final int RULE_QUOTED_ID=77; |
52 | public static final int T__29=29; | 53 | public static final int RightParenthesis=58; |
53 | public static final int T__22=22; | 54 | public static final int Sum=44; |
54 | public static final int T__66=66; | 55 | public static final int EQ=52; |
55 | public static final int RULE_ML_COMMENT=11; | 56 | public static final int GreaterThanSignEqualsSign=51; |
56 | public static final int T__23=23; | 57 | public static final int Functional=5; |
57 | public static final int T__67=67; | 58 | public static final int EqualsSignEqualsSign=50; |
58 | public static final int T__24=24; | 59 | public static final int Avg=38; |
59 | public static final int T__68=68; | 60 | public static final int Min=43; |
60 | public static final int T__25=25; | 61 | public static final int VerticalLine=74; |
61 | public static final int T__69=69; | 62 | public static final int PlusSign=60; |
62 | public static final int T__62=62; | 63 | public static final int RULE_INT=83; |
63 | public static final int T__63=63; | 64 | public static final int Contains=7; |
64 | public static final int T__20=20; | 65 | public static final int RULE_ML_COMMENT=84; |
65 | public static final int T__64=64; | 66 | public static final int POW=36; |
66 | public static final int T__21=21; | 67 | public static final int RULE_TRANSITIVE_CLOSURE=79; |
67 | public static final int T__65=65; | 68 | public static final int Class=19; |
68 | public static final int T__70=70; | 69 | public static final int LESS=25; |
69 | public static final int T__71=71; | 70 | public static final int LeftSquareBracket=70; |
70 | public static final int T__72=72; | 71 | public static final int RULE_FULL_STOP=81; |
71 | public static final int RULE_STRING=10; | 72 | public static final int Current=13; |
72 | public static final int RULE_SL_COMMENT=12; | 73 | public static final int If=54; |
73 | public static final int T__37=37; | 74 | public static final int Inf=39; |
74 | public static final int T__38=38; | 75 | public static final int LESS_EQ=12; |
75 | public static final int T__39=39; | 76 | public static final int May=42; |
76 | public static final int T__33=33; | 77 | public static final int Max=41; |
77 | public static final int T__34=34; | 78 | public static final int In=55; |
78 | public static final int T__35=35; | 79 | public static final int RULE_STRING=76; |
79 | public static final int RULE_PLUS=9; | 80 | public static final int Int=40; |
80 | public static final int T__36=36; | 81 | public static final int Extern=18; |
81 | public static final int T__73=73; | 82 | public static final int RULE_SL_COMMENT=78; |
82 | public static final int RULE_DOT=6; | 83 | public static final int Prod=29; |
84 | public static final int Comma=61; | ||
85 | public static final int EqualsSign=68; | ||
86 | public static final int Empty=21; | ||
87 | public static final int HyphenMinus=62; | ||
88 | public static final int Maximize=8; | ||
89 | public static final int LessThanSignEqualsSign=49; | ||
90 | public static final int Solidus=64; | ||
91 | public static final int Colon=65; | ||
92 | public static final int RightCurlyBracket=75; | ||
83 | public static final int EOF=-1; | 93 | public static final int EOF=-1; |
84 | public static final int T__30=30; | 94 | public static final int Asterisk=59; |
85 | public static final int T__74=74; | 95 | public static final int FullStop=63; |
86 | public static final int T__31=31; | 96 | public static final int RULE_WS=85; |
87 | public static final int T__32=32; | 97 | public static final int Abstract=6; |
88 | public static final int RULE_WS=13; | 98 | public static final int Minimize=9; |
89 | public static final int RULE_ANY_OTHER=14; | 99 | public static final int GREATER=11; |
90 | public static final int T__48=48; | 100 | public static final int LeftCurlyBracket=73; |
91 | public static final int T__49=49; | 101 | public static final int Error=22; |
92 | public static final int T__44=44; | 102 | public static final int Only=28; |
93 | public static final int T__45=45; | 103 | public static final int RULE_ANY_OTHER=86; |
94 | public static final int T__46=46; | 104 | public static final int Default=14; |
95 | public static final int T__47=47; | 105 | public static final int ColonHyphenMinus=48; |
96 | public static final int T__40=40; | 106 | public static final int CircumflexAccent=72; |
97 | public static final int T__41=41; | 107 | public static final int DIV=34; |
98 | public static final int T__42=42; | 108 | public static final int Semicolon=66; |
99 | public static final int T__43=43; | 109 | public static final int Scope=24; |
110 | public static final int Else=26; | ||
111 | public static final int ExclamationMarkEqualsSign=45; | ||
112 | public static final int HyphenMinusGreaterThanSign=46; | ||
100 | 113 | ||
101 | // delegates | 114 | // delegates |
102 | // delegators | 115 | // delegators |
@@ -112,10 +125,86 @@ public class InternalSolverLanguageParser extends AbstractInternalContentAssistP | |||
112 | 125 | ||
113 | 126 | ||
114 | public String[] getTokenNames() { return InternalSolverLanguageParser.tokenNames; } | 127 | public String[] getTokenNames() { return InternalSolverLanguageParser.tokenNames; } |
115 | public String getGrammarFileName() { return "InternalSolverLanguage.g"; } | 128 | public String getGrammarFileName() { return "InternalSolverLanguageParser.g"; } |
116 | 129 | ||
117 | 130 | ||
118 | private SolverLanguageGrammarAccess grammarAccess; | 131 | private SolverLanguageGrammarAccess grammarAccess; |
132 | private final Map<String, String> tokenNameToValue = new HashMap<String, String>(); | ||
133 | |||
134 | { | ||
135 | tokenNameToValue.put("ExclamationMark", "'!'"); | ||
136 | tokenNameToValue.put("LeftParenthesis", "'('"); | ||
137 | tokenNameToValue.put("RightParenthesis", "')'"); | ||
138 | tokenNameToValue.put("Asterisk", "'*'"); | ||
139 | tokenNameToValue.put("PlusSign", "'+'"); | ||
140 | tokenNameToValue.put("Comma", "','"); | ||
141 | tokenNameToValue.put("HyphenMinus", "'-'"); | ||
142 | tokenNameToValue.put("FullStop", "'.'"); | ||
143 | tokenNameToValue.put("Solidus", "'/'"); | ||
144 | tokenNameToValue.put("Colon", "':'"); | ||
145 | tokenNameToValue.put("Semicolon", "';'"); | ||
146 | tokenNameToValue.put("LessThanSign", "'<'"); | ||
147 | tokenNameToValue.put("EqualsSign", "'='"); | ||
148 | tokenNameToValue.put("GreaterThanSign", "'>'"); | ||
149 | tokenNameToValue.put("LeftSquareBracket", "'['"); | ||
150 | tokenNameToValue.put("RightSquareBracket", "']'"); | ||
151 | tokenNameToValue.put("CircumflexAccent", "'^'"); | ||
152 | tokenNameToValue.put("LeftCurlyBracket", "'{'"); | ||
153 | tokenNameToValue.put("VerticalLine", "'|'"); | ||
154 | tokenNameToValue.put("RightCurlyBracket", "'}'"); | ||
155 | tokenNameToValue.put("ExclamationMarkEqualsSign", "'!='"); | ||
156 | tokenNameToValue.put("HyphenMinusGreaterThanSign", "'->'"); | ||
157 | tokenNameToValue.put("FullStopFullStop", "'..'"); | ||
158 | tokenNameToValue.put("ColonHyphenMinus", "':-'"); | ||
159 | tokenNameToValue.put("LessThanSignEqualsSign", "'<='"); | ||
160 | tokenNameToValue.put("EqualsSignEqualsSign", "'=='"); | ||
161 | tokenNameToValue.put("GreaterThanSignEqualsSign", "'>='"); | ||
162 | tokenNameToValue.put("EQ", "'EQ'"); | ||
163 | tokenNameToValue.put("IN", "'IN'"); | ||
164 | tokenNameToValue.put("If", "'if'"); | ||
165 | tokenNameToValue.put("In", "'in'"); | ||
166 | tokenNameToValue.put("ADD", "'ADD'"); | ||
167 | tokenNameToValue.put("DIV", "'DIV'"); | ||
168 | tokenNameToValue.put("MUL", "'MUL'"); | ||
169 | tokenNameToValue.put("POW", "'POW'"); | ||
170 | tokenNameToValue.put("SUB", "'SUB'"); | ||
171 | tokenNameToValue.put("Avg", "'avg'"); | ||
172 | tokenNameToValue.put("Inf", "'inf'"); | ||
173 | tokenNameToValue.put("Int", "'int'"); | ||
174 | tokenNameToValue.put("Max", "'max'"); | ||
175 | tokenNameToValue.put("May", "'may'"); | ||
176 | tokenNameToValue.put("Min", "'min'"); | ||
177 | tokenNameToValue.put("Sum", "'sum'"); | ||
178 | tokenNameToValue.put("LESS", "'LESS'"); | ||
179 | tokenNameToValue.put("Else", "'else'"); | ||
180 | tokenNameToValue.put("Must", "'must'"); | ||
181 | tokenNameToValue.put("Only", "'only'"); | ||
182 | tokenNameToValue.put("Prod", "'prod'"); | ||
183 | tokenNameToValue.put("Real", "'real'"); | ||
184 | tokenNameToValue.put("Then", "'then'"); | ||
185 | tokenNameToValue.put("True", "'true'"); | ||
186 | tokenNameToValue.put("Class", "'class'"); | ||
187 | tokenNameToValue.put("Count", "'count'"); | ||
188 | tokenNameToValue.put("Empty", "'empty'"); | ||
189 | tokenNameToValue.put("Error", "'error'"); | ||
190 | tokenNameToValue.put("False", "'false'"); | ||
191 | tokenNameToValue.put("Scope", "'scope'"); | ||
192 | tokenNameToValue.put("NOT_EQ", "'NOT_EQ'"); | ||
193 | tokenNameToValue.put("Extern", "'extern'"); | ||
194 | tokenNameToValue.put("GREATER", "'GREATER'"); | ||
195 | tokenNameToValue.put("LESS_EQ", "'LESS_EQ'"); | ||
196 | tokenNameToValue.put("Current", "'current'"); | ||
197 | tokenNameToValue.put("Default", "'default'"); | ||
198 | tokenNameToValue.put("Extends", "'extends'"); | ||
199 | tokenNameToValue.put("Unknown", "'unknown'"); | ||
200 | tokenNameToValue.put("Abstract", "'abstract'"); | ||
201 | tokenNameToValue.put("Contains", "'contains'"); | ||
202 | tokenNameToValue.put("Maximize", "'maximize'"); | ||
203 | tokenNameToValue.put("Minimize", "'minimize'"); | ||
204 | tokenNameToValue.put("Opposite", "'opposite'"); | ||
205 | tokenNameToValue.put("GREATER_EQ", "'GREATER_EQ'"); | ||
206 | tokenNameToValue.put("Functional", "'functional'"); | ||
207 | } | ||
119 | 208 | ||
120 | public void setGrammarAccess(SolverLanguageGrammarAccess grammarAccess) { | 209 | public void setGrammarAccess(SolverLanguageGrammarAccess grammarAccess) { |
121 | this.grammarAccess = grammarAccess; | 210 | this.grammarAccess = grammarAccess; |
@@ -128,30 +217,29 @@ public class InternalSolverLanguageParser extends AbstractInternalContentAssistP | |||
128 | 217 | ||
129 | @Override | 218 | @Override |
130 | protected String getValueForTokenName(String tokenName) { | 219 | protected String getValueForTokenName(String tokenName) { |
131 | return tokenName; | 220 | String result = tokenNameToValue.get(tokenName); |
221 | if (result == null) | ||
222 | result = tokenName; | ||
223 | return result; | ||
132 | } | 224 | } |
133 | 225 | ||
134 | 226 | ||
135 | 227 | ||
136 | // $ANTLR start "entryRuleProblem" | 228 | // $ANTLR start "entryRuleProblem" |
137 | // InternalSolverLanguage.g:54:1: entryRuleProblem : ruleProblem EOF ; | 229 | // InternalSolverLanguageParser.g:127:1: entryRuleProblem : ruleProblem EOF ; |
138 | public final void entryRuleProblem() throws RecognitionException { | 230 | public final void entryRuleProblem() throws RecognitionException { |
139 | try { | 231 | try { |
140 | // InternalSolverLanguage.g:55:1: ( ruleProblem EOF ) | 232 | // InternalSolverLanguageParser.g:128:1: ( ruleProblem EOF ) |
141 | // InternalSolverLanguage.g:56:1: ruleProblem EOF | 233 | // InternalSolverLanguageParser.g:129:1: ruleProblem EOF |
142 | { | 234 | { |
143 | if ( state.backtracking==0 ) { | 235 | before(grammarAccess.getProblemRule()); |
144 | before(grammarAccess.getProblemRule()); | ||
145 | } | ||
146 | pushFollow(FOLLOW_1); | 236 | pushFollow(FOLLOW_1); |
147 | ruleProblem(); | 237 | ruleProblem(); |
148 | 238 | ||
149 | state._fsp--; | 239 | state._fsp--; |
150 | if (state.failed) return ; | 240 | |
151 | if ( state.backtracking==0 ) { | 241 | after(grammarAccess.getProblemRule()); |
152 | after(grammarAccess.getProblemRule()); | 242 | match(input,EOF,FOLLOW_2); |
153 | } | ||
154 | match(input,EOF,FOLLOW_2); if (state.failed) return ; | ||
155 | 243 | ||
156 | } | 244 | } |
157 | 245 | ||
@@ -168,41 +256,39 @@ public class InternalSolverLanguageParser extends AbstractInternalContentAssistP | |||
168 | 256 | ||
169 | 257 | ||
170 | // $ANTLR start "ruleProblem" | 258 | // $ANTLR start "ruleProblem" |
171 | // InternalSolverLanguage.g:63:1: ruleProblem : ( ( rule__Problem__StatementsAssignment )* ) ; | 259 | // InternalSolverLanguageParser.g:136:1: ruleProblem : ( ( rule__Problem__StatementsAssignment )* ) ; |
172 | public final void ruleProblem() throws RecognitionException { | 260 | public final void ruleProblem() throws RecognitionException { |
173 | 261 | ||
174 | int stackSize = keepStackSize(); | 262 | int stackSize = keepStackSize(); |
175 | 263 | ||
176 | try { | 264 | try { |
177 | // InternalSolverLanguage.g:67:2: ( ( ( rule__Problem__StatementsAssignment )* ) ) | 265 | // InternalSolverLanguageParser.g:140:2: ( ( ( rule__Problem__StatementsAssignment )* ) ) |
178 | // InternalSolverLanguage.g:68:2: ( ( rule__Problem__StatementsAssignment )* ) | 266 | // InternalSolverLanguageParser.g:141:2: ( ( rule__Problem__StatementsAssignment )* ) |
179 | { | 267 | { |
180 | // InternalSolverLanguage.g:68:2: ( ( rule__Problem__StatementsAssignment )* ) | 268 | // InternalSolverLanguageParser.g:141:2: ( ( rule__Problem__StatementsAssignment )* ) |
181 | // InternalSolverLanguage.g:69:3: ( rule__Problem__StatementsAssignment )* | 269 | // InternalSolverLanguageParser.g:142:3: ( rule__Problem__StatementsAssignment )* |
182 | { | 270 | { |
183 | if ( state.backtracking==0 ) { | 271 | before(grammarAccess.getProblemAccess().getStatementsAssignment()); |
184 | before(grammarAccess.getProblemAccess().getStatementsAssignment()); | 272 | // InternalSolverLanguageParser.g:143:3: ( rule__Problem__StatementsAssignment )* |
185 | } | ||
186 | // InternalSolverLanguage.g:70:3: ( rule__Problem__StatementsAssignment )* | ||
187 | loop1: | 273 | loop1: |
188 | do { | 274 | do { |
189 | int alt1=2; | 275 | int alt1=2; |
190 | int LA1_0 = input.LA(1); | 276 | int LA1_0 = input.LA(1); |
191 | 277 | ||
192 | if ( ((LA1_0>=RULE_INT && LA1_0<=RULE_QUOTED_ID)||LA1_0==RULE_ID||LA1_0==RULE_STRING||(LA1_0>=17 && LA1_0<=18)||(LA1_0>=26 && LA1_0<=27)||(LA1_0>=29 && LA1_0<=44)||(LA1_0>=48 && LA1_0<=49)||LA1_0==51||LA1_0==57||LA1_0==61||LA1_0==63||(LA1_0>=66 && LA1_0<=68)||(LA1_0>=71 && LA1_0<=73)) ) { | 278 | if ( ((LA1_0>=Functional && LA1_0<=Abstract)||(LA1_0>=Maximize && LA1_0<=Minimize)||(LA1_0>=Current && LA1_0<=Default)||LA1_0==Unknown||(LA1_0>=Extern && LA1_0<=False)||LA1_0==Scope||(LA1_0>=Must && LA1_0<=Real)||LA1_0==True||(LA1_0>=Avg && LA1_0<=Sum)||LA1_0==If||(LA1_0>=ExclamationMark && LA1_0<=LeftParenthesis)||LA1_0==PlusSign||LA1_0==HyphenMinus||LA1_0==LeftSquareBracket||(LA1_0>=RULE_STRING && LA1_0<=RULE_QUOTED_ID)||(LA1_0>=RULE_ID && LA1_0<=RULE_INT)) ) { |
193 | alt1=1; | 279 | alt1=1; |
194 | } | 280 | } |
195 | 281 | ||
196 | 282 | ||
197 | switch (alt1) { | 283 | switch (alt1) { |
198 | case 1 : | 284 | case 1 : |
199 | // InternalSolverLanguage.g:70:4: rule__Problem__StatementsAssignment | 285 | // InternalSolverLanguageParser.g:143:4: rule__Problem__StatementsAssignment |
200 | { | 286 | { |
201 | pushFollow(FOLLOW_3); | 287 | pushFollow(FOLLOW_3); |
202 | rule__Problem__StatementsAssignment(); | 288 | rule__Problem__StatementsAssignment(); |
203 | 289 | ||
204 | state._fsp--; | 290 | state._fsp--; |
205 | if (state.failed) return ; | 291 | |
206 | 292 | ||
207 | } | 293 | } |
208 | break; | 294 | break; |
@@ -212,9 +298,7 @@ public class InternalSolverLanguageParser extends AbstractInternalContentAssistP | |||
212 | } | 298 | } |
213 | } while (true); | 299 | } while (true); |
214 | 300 | ||
215 | if ( state.backtracking==0 ) { | 301 | after(grammarAccess.getProblemAccess().getStatementsAssignment()); |
216 | after(grammarAccess.getProblemAccess().getStatementsAssignment()); | ||
217 | } | ||
218 | 302 | ||
219 | } | 303 | } |
220 | 304 | ||
@@ -237,24 +321,20 @@ public class InternalSolverLanguageParser extends AbstractInternalContentAssistP | |||
237 | 321 | ||
238 | 322 | ||
239 | // $ANTLR start "entryRuleStatement" | 323 | // $ANTLR start "entryRuleStatement" |
240 | // InternalSolverLanguage.g:79:1: entryRuleStatement : ruleStatement EOF ; | 324 | // InternalSolverLanguageParser.g:152:1: entryRuleStatement : ruleStatement EOF ; |
241 | public final void entryRuleStatement() throws RecognitionException { | 325 | public final void entryRuleStatement() throws RecognitionException { |
242 | try { | 326 | try { |
243 | // InternalSolverLanguage.g:80:1: ( ruleStatement EOF ) | 327 | // InternalSolverLanguageParser.g:153:1: ( ruleStatement EOF ) |
244 | // InternalSolverLanguage.g:81:1: ruleStatement EOF | 328 | // InternalSolverLanguageParser.g:154:1: ruleStatement EOF |
245 | { | 329 | { |
246 | if ( state.backtracking==0 ) { | 330 | before(grammarAccess.getStatementRule()); |
247 | before(grammarAccess.getStatementRule()); | ||
248 | } | ||
249 | pushFollow(FOLLOW_1); | 331 | pushFollow(FOLLOW_1); |
250 | ruleStatement(); | 332 | ruleStatement(); |
251 | 333 | ||
252 | state._fsp--; | 334 | state._fsp--; |
253 | if (state.failed) return ; | 335 | |
254 | if ( state.backtracking==0 ) { | 336 | after(grammarAccess.getStatementRule()); |
255 | after(grammarAccess.getStatementRule()); | 337 | match(input,EOF,FOLLOW_2); |
256 | } | ||
257 | match(input,EOF,FOLLOW_2); if (state.failed) return ; | ||
258 | 338 | ||
259 | } | 339 | } |
260 | 340 | ||
@@ -271,36 +351,32 @@ public class InternalSolverLanguageParser extends AbstractInternalContentAssistP | |||
271 | 351 | ||
272 | 352 | ||
273 | // $ANTLR start "ruleStatement" | 353 | // $ANTLR start "ruleStatement" |
274 | // InternalSolverLanguage.g:88:1: ruleStatement : ( ( rule__Statement__Group__0 ) ) ; | 354 | // InternalSolverLanguageParser.g:161:1: ruleStatement : ( ( rule__Statement__Group__0 ) ) ; |
275 | public final void ruleStatement() throws RecognitionException { | 355 | public final void ruleStatement() throws RecognitionException { |
276 | 356 | ||
277 | int stackSize = keepStackSize(); | 357 | int stackSize = keepStackSize(); |
278 | 358 | ||
279 | try { | 359 | try { |
280 | // InternalSolverLanguage.g:92:2: ( ( ( rule__Statement__Group__0 ) ) ) | 360 | // InternalSolverLanguageParser.g:165:2: ( ( ( rule__Statement__Group__0 ) ) ) |
281 | // InternalSolverLanguage.g:93:2: ( ( rule__Statement__Group__0 ) ) | 361 | // InternalSolverLanguageParser.g:166:2: ( ( rule__Statement__Group__0 ) ) |
282 | { | 362 | { |
283 | // InternalSolverLanguage.g:93:2: ( ( rule__Statement__Group__0 ) ) | 363 | // InternalSolverLanguageParser.g:166:2: ( ( rule__Statement__Group__0 ) ) |
284 | // InternalSolverLanguage.g:94:3: ( rule__Statement__Group__0 ) | 364 | // InternalSolverLanguageParser.g:167:3: ( rule__Statement__Group__0 ) |
285 | { | 365 | { |
286 | if ( state.backtracking==0 ) { | 366 | before(grammarAccess.getStatementAccess().getGroup()); |
287 | before(grammarAccess.getStatementAccess().getGroup()); | 367 | // InternalSolverLanguageParser.g:168:3: ( rule__Statement__Group__0 ) |
288 | } | 368 | // InternalSolverLanguageParser.g:168:4: rule__Statement__Group__0 |
289 | // InternalSolverLanguage.g:95:3: ( rule__Statement__Group__0 ) | ||
290 | // InternalSolverLanguage.g:95:4: rule__Statement__Group__0 | ||
291 | { | 369 | { |
292 | pushFollow(FOLLOW_2); | 370 | pushFollow(FOLLOW_2); |
293 | rule__Statement__Group__0(); | 371 | rule__Statement__Group__0(); |
294 | 372 | ||
295 | state._fsp--; | 373 | state._fsp--; |
296 | if (state.failed) return ; | ||
297 | 374 | ||
298 | } | ||
299 | 375 | ||
300 | if ( state.backtracking==0 ) { | ||
301 | after(grammarAccess.getStatementAccess().getGroup()); | ||
302 | } | 376 | } |
303 | 377 | ||
378 | after(grammarAccess.getStatementAccess().getGroup()); | ||
379 | |||
304 | } | 380 | } |
305 | 381 | ||
306 | 382 | ||
@@ -322,24 +398,20 @@ public class InternalSolverLanguageParser extends AbstractInternalContentAssistP | |||
322 | 398 | ||
323 | 399 | ||
324 | // $ANTLR start "entryRuleAssertionOrDefinition" | 400 | // $ANTLR start "entryRuleAssertionOrDefinition" |
325 | // InternalSolverLanguage.g:104:1: entryRuleAssertionOrDefinition : ruleAssertionOrDefinition EOF ; | 401 | // InternalSolverLanguageParser.g:177:1: entryRuleAssertionOrDefinition : ruleAssertionOrDefinition EOF ; |
326 | public final void entryRuleAssertionOrDefinition() throws RecognitionException { | 402 | public final void entryRuleAssertionOrDefinition() throws RecognitionException { |
327 | try { | 403 | try { |
328 | // InternalSolverLanguage.g:105:1: ( ruleAssertionOrDefinition EOF ) | 404 | // InternalSolverLanguageParser.g:178:1: ( ruleAssertionOrDefinition EOF ) |
329 | // InternalSolverLanguage.g:106:1: ruleAssertionOrDefinition EOF | 405 | // InternalSolverLanguageParser.g:179:1: ruleAssertionOrDefinition EOF |
330 | { | 406 | { |
331 | if ( state.backtracking==0 ) { | 407 | before(grammarAccess.getAssertionOrDefinitionRule()); |
332 | before(grammarAccess.getAssertionOrDefinitionRule()); | ||
333 | } | ||
334 | pushFollow(FOLLOW_1); | 408 | pushFollow(FOLLOW_1); |
335 | ruleAssertionOrDefinition(); | 409 | ruleAssertionOrDefinition(); |
336 | 410 | ||
337 | state._fsp--; | 411 | state._fsp--; |
338 | if (state.failed) return ; | 412 | |
339 | if ( state.backtracking==0 ) { | 413 | after(grammarAccess.getAssertionOrDefinitionRule()); |
340 | after(grammarAccess.getAssertionOrDefinitionRule()); | 414 | match(input,EOF,FOLLOW_2); |
341 | } | ||
342 | match(input,EOF,FOLLOW_2); if (state.failed) return ; | ||
343 | 415 | ||
344 | } | 416 | } |
345 | 417 | ||
@@ -356,36 +428,32 @@ public class InternalSolverLanguageParser extends AbstractInternalContentAssistP | |||
356 | 428 | ||
357 | 429 | ||
358 | // $ANTLR start "ruleAssertionOrDefinition" | 430 | // $ANTLR start "ruleAssertionOrDefinition" |
359 | // InternalSolverLanguage.g:113:1: ruleAssertionOrDefinition : ( ( rule__AssertionOrDefinition__Group__0 ) ) ; | 431 | // InternalSolverLanguageParser.g:186:1: ruleAssertionOrDefinition : ( ( rule__AssertionOrDefinition__Group__0 ) ) ; |
360 | public final void ruleAssertionOrDefinition() throws RecognitionException { | 432 | public final void ruleAssertionOrDefinition() throws RecognitionException { |
361 | 433 | ||
362 | int stackSize = keepStackSize(); | 434 | int stackSize = keepStackSize(); |
363 | 435 | ||
364 | try { | 436 | try { |
365 | // InternalSolverLanguage.g:117:2: ( ( ( rule__AssertionOrDefinition__Group__0 ) ) ) | 437 | // InternalSolverLanguageParser.g:190:2: ( ( ( rule__AssertionOrDefinition__Group__0 ) ) ) |
366 | // InternalSolverLanguage.g:118:2: ( ( rule__AssertionOrDefinition__Group__0 ) ) | 438 | // InternalSolverLanguageParser.g:191:2: ( ( rule__AssertionOrDefinition__Group__0 ) ) |
367 | { | 439 | { |
368 | // InternalSolverLanguage.g:118:2: ( ( rule__AssertionOrDefinition__Group__0 ) ) | 440 | // InternalSolverLanguageParser.g:191:2: ( ( rule__AssertionOrDefinition__Group__0 ) ) |
369 | // InternalSolverLanguage.g:119:3: ( rule__AssertionOrDefinition__Group__0 ) | 441 | // InternalSolverLanguageParser.g:192:3: ( rule__AssertionOrDefinition__Group__0 ) |
370 | { | 442 | { |
371 | if ( state.backtracking==0 ) { | 443 | before(grammarAccess.getAssertionOrDefinitionAccess().getGroup()); |
372 | before(grammarAccess.getAssertionOrDefinitionAccess().getGroup()); | 444 | // InternalSolverLanguageParser.g:193:3: ( rule__AssertionOrDefinition__Group__0 ) |
373 | } | 445 | // InternalSolverLanguageParser.g:193:4: rule__AssertionOrDefinition__Group__0 |
374 | // InternalSolverLanguage.g:120:3: ( rule__AssertionOrDefinition__Group__0 ) | ||
375 | // InternalSolverLanguage.g:120:4: rule__AssertionOrDefinition__Group__0 | ||
376 | { | 446 | { |
377 | pushFollow(FOLLOW_2); | 447 | pushFollow(FOLLOW_2); |
378 | rule__AssertionOrDefinition__Group__0(); | 448 | rule__AssertionOrDefinition__Group__0(); |
379 | 449 | ||
380 | state._fsp--; | 450 | state._fsp--; |
381 | if (state.failed) return ; | ||
382 | 451 | ||
383 | } | ||
384 | 452 | ||
385 | if ( state.backtracking==0 ) { | ||
386 | after(grammarAccess.getAssertionOrDefinitionAccess().getGroup()); | ||
387 | } | 453 | } |
388 | 454 | ||
455 | after(grammarAccess.getAssertionOrDefinitionAccess().getGroup()); | ||
456 | |||
389 | } | 457 | } |
390 | 458 | ||
391 | 459 | ||
@@ -407,24 +475,20 @@ public class InternalSolverLanguageParser extends AbstractInternalContentAssistP | |||
407 | 475 | ||
408 | 476 | ||
409 | // $ANTLR start "entryRulePredicateDefinition" | 477 | // $ANTLR start "entryRulePredicateDefinition" |
410 | // InternalSolverLanguage.g:129:1: entryRulePredicateDefinition : rulePredicateDefinition EOF ; | 478 | // InternalSolverLanguageParser.g:202:1: entryRulePredicateDefinition : rulePredicateDefinition EOF ; |
411 | public final void entryRulePredicateDefinition() throws RecognitionException { | 479 | public final void entryRulePredicateDefinition() throws RecognitionException { |
412 | try { | 480 | try { |
413 | // InternalSolverLanguage.g:130:1: ( rulePredicateDefinition EOF ) | 481 | // InternalSolverLanguageParser.g:203:1: ( rulePredicateDefinition EOF ) |
414 | // InternalSolverLanguage.g:131:1: rulePredicateDefinition EOF | 482 | // InternalSolverLanguageParser.g:204:1: rulePredicateDefinition EOF |
415 | { | 483 | { |
416 | if ( state.backtracking==0 ) { | 484 | before(grammarAccess.getPredicateDefinitionRule()); |
417 | before(grammarAccess.getPredicateDefinitionRule()); | ||
418 | } | ||
419 | pushFollow(FOLLOW_1); | 485 | pushFollow(FOLLOW_1); |
420 | rulePredicateDefinition(); | 486 | rulePredicateDefinition(); |
421 | 487 | ||
422 | state._fsp--; | 488 | state._fsp--; |
423 | if (state.failed) return ; | 489 | |
424 | if ( state.backtracking==0 ) { | 490 | after(grammarAccess.getPredicateDefinitionRule()); |
425 | after(grammarAccess.getPredicateDefinitionRule()); | 491 | match(input,EOF,FOLLOW_2); |
426 | } | ||
427 | match(input,EOF,FOLLOW_2); if (state.failed) return ; | ||
428 | 492 | ||
429 | } | 493 | } |
430 | 494 | ||
@@ -441,36 +505,32 @@ public class InternalSolverLanguageParser extends AbstractInternalContentAssistP | |||
441 | 505 | ||
442 | 506 | ||
443 | // $ANTLR start "rulePredicateDefinition" | 507 | // $ANTLR start "rulePredicateDefinition" |
444 | // InternalSolverLanguage.g:138:1: rulePredicateDefinition : ( ( rule__PredicateDefinition__Group__0 ) ) ; | 508 | // InternalSolverLanguageParser.g:211:1: rulePredicateDefinition : ( ( rule__PredicateDefinition__Group__0 ) ) ; |
445 | public final void rulePredicateDefinition() throws RecognitionException { | 509 | public final void rulePredicateDefinition() throws RecognitionException { |
446 | 510 | ||
447 | int stackSize = keepStackSize(); | 511 | int stackSize = keepStackSize(); |
448 | 512 | ||
449 | try { | 513 | try { |
450 | // InternalSolverLanguage.g:142:2: ( ( ( rule__PredicateDefinition__Group__0 ) ) ) | 514 | // InternalSolverLanguageParser.g:215:2: ( ( ( rule__PredicateDefinition__Group__0 ) ) ) |
451 | // InternalSolverLanguage.g:143:2: ( ( rule__PredicateDefinition__Group__0 ) ) | 515 | // InternalSolverLanguageParser.g:216:2: ( ( rule__PredicateDefinition__Group__0 ) ) |
452 | { | 516 | { |
453 | // InternalSolverLanguage.g:143:2: ( ( rule__PredicateDefinition__Group__0 ) ) | 517 | // InternalSolverLanguageParser.g:216:2: ( ( rule__PredicateDefinition__Group__0 ) ) |
454 | // InternalSolverLanguage.g:144:3: ( rule__PredicateDefinition__Group__0 ) | 518 | // InternalSolverLanguageParser.g:217:3: ( rule__PredicateDefinition__Group__0 ) |
455 | { | 519 | { |
456 | if ( state.backtracking==0 ) { | 520 | before(grammarAccess.getPredicateDefinitionAccess().getGroup()); |
457 | before(grammarAccess.getPredicateDefinitionAccess().getGroup()); | 521 | // InternalSolverLanguageParser.g:218:3: ( rule__PredicateDefinition__Group__0 ) |
458 | } | 522 | // InternalSolverLanguageParser.g:218:4: rule__PredicateDefinition__Group__0 |
459 | // InternalSolverLanguage.g:145:3: ( rule__PredicateDefinition__Group__0 ) | ||
460 | // InternalSolverLanguage.g:145:4: rule__PredicateDefinition__Group__0 | ||
461 | { | 523 | { |
462 | pushFollow(FOLLOW_2); | 524 | pushFollow(FOLLOW_2); |
463 | rule__PredicateDefinition__Group__0(); | 525 | rule__PredicateDefinition__Group__0(); |
464 | 526 | ||
465 | state._fsp--; | 527 | state._fsp--; |
466 | if (state.failed) return ; | ||
467 | 528 | ||
468 | } | ||
469 | 529 | ||
470 | if ( state.backtracking==0 ) { | ||
471 | after(grammarAccess.getPredicateDefinitionAccess().getGroup()); | ||
472 | } | 530 | } |
473 | 531 | ||
532 | after(grammarAccess.getPredicateDefinitionAccess().getGroup()); | ||
533 | |||
474 | } | 534 | } |
475 | 535 | ||
476 | 536 | ||
@@ -492,24 +552,20 @@ public class InternalSolverLanguageParser extends AbstractInternalContentAssistP | |||
492 | 552 | ||
493 | 553 | ||
494 | // $ANTLR start "entryRuleUnnamedErrorPrediateDefinition" | 554 | // $ANTLR start "entryRuleUnnamedErrorPrediateDefinition" |
495 | // InternalSolverLanguage.g:154:1: entryRuleUnnamedErrorPrediateDefinition : ruleUnnamedErrorPrediateDefinition EOF ; | 555 | // InternalSolverLanguageParser.g:227:1: entryRuleUnnamedErrorPrediateDefinition : ruleUnnamedErrorPrediateDefinition EOF ; |
496 | public final void entryRuleUnnamedErrorPrediateDefinition() throws RecognitionException { | 556 | public final void entryRuleUnnamedErrorPrediateDefinition() throws RecognitionException { |
497 | try { | 557 | try { |
498 | // InternalSolverLanguage.g:155:1: ( ruleUnnamedErrorPrediateDefinition EOF ) | 558 | // InternalSolverLanguageParser.g:228:1: ( ruleUnnamedErrorPrediateDefinition EOF ) |
499 | // InternalSolverLanguage.g:156:1: ruleUnnamedErrorPrediateDefinition EOF | 559 | // InternalSolverLanguageParser.g:229:1: ruleUnnamedErrorPrediateDefinition EOF |
500 | { | 560 | { |
501 | if ( state.backtracking==0 ) { | 561 | before(grammarAccess.getUnnamedErrorPrediateDefinitionRule()); |
502 | before(grammarAccess.getUnnamedErrorPrediateDefinitionRule()); | ||
503 | } | ||
504 | pushFollow(FOLLOW_1); | 562 | pushFollow(FOLLOW_1); |
505 | ruleUnnamedErrorPrediateDefinition(); | 563 | ruleUnnamedErrorPrediateDefinition(); |
506 | 564 | ||
507 | state._fsp--; | 565 | state._fsp--; |
508 | if (state.failed) return ; | 566 | |
509 | if ( state.backtracking==0 ) { | 567 | after(grammarAccess.getUnnamedErrorPrediateDefinitionRule()); |
510 | after(grammarAccess.getUnnamedErrorPrediateDefinitionRule()); | 568 | match(input,EOF,FOLLOW_2); |
511 | } | ||
512 | match(input,EOF,FOLLOW_2); if (state.failed) return ; | ||
513 | 569 | ||
514 | } | 570 | } |
515 | 571 | ||
@@ -526,36 +582,32 @@ public class InternalSolverLanguageParser extends AbstractInternalContentAssistP | |||
526 | 582 | ||
527 | 583 | ||
528 | // $ANTLR start "ruleUnnamedErrorPrediateDefinition" | 584 | // $ANTLR start "ruleUnnamedErrorPrediateDefinition" |
529 | // InternalSolverLanguage.g:163:1: ruleUnnamedErrorPrediateDefinition : ( ( rule__UnnamedErrorPrediateDefinition__Group__0 ) ) ; | 585 | // InternalSolverLanguageParser.g:236:1: ruleUnnamedErrorPrediateDefinition : ( ( rule__UnnamedErrorPrediateDefinition__Group__0 ) ) ; |
530 | public final void ruleUnnamedErrorPrediateDefinition() throws RecognitionException { | 586 | public final void ruleUnnamedErrorPrediateDefinition() throws RecognitionException { |
531 | 587 | ||
532 | int stackSize = keepStackSize(); | 588 | int stackSize = keepStackSize(); |
533 | 589 | ||
534 | try { | 590 | try { |
535 | // InternalSolverLanguage.g:167:2: ( ( ( rule__UnnamedErrorPrediateDefinition__Group__0 ) ) ) | 591 | // InternalSolverLanguageParser.g:240:2: ( ( ( rule__UnnamedErrorPrediateDefinition__Group__0 ) ) ) |
536 | // InternalSolverLanguage.g:168:2: ( ( rule__UnnamedErrorPrediateDefinition__Group__0 ) ) | 592 | // InternalSolverLanguageParser.g:241:2: ( ( rule__UnnamedErrorPrediateDefinition__Group__0 ) ) |
537 | { | 593 | { |
538 | // InternalSolverLanguage.g:168:2: ( ( rule__UnnamedErrorPrediateDefinition__Group__0 ) ) | 594 | // InternalSolverLanguageParser.g:241:2: ( ( rule__UnnamedErrorPrediateDefinition__Group__0 ) ) |
539 | // InternalSolverLanguage.g:169:3: ( rule__UnnamedErrorPrediateDefinition__Group__0 ) | 595 | // InternalSolverLanguageParser.g:242:3: ( rule__UnnamedErrorPrediateDefinition__Group__0 ) |
540 | { | 596 | { |
541 | if ( state.backtracking==0 ) { | 597 | before(grammarAccess.getUnnamedErrorPrediateDefinitionAccess().getGroup()); |
542 | before(grammarAccess.getUnnamedErrorPrediateDefinitionAccess().getGroup()); | 598 | // InternalSolverLanguageParser.g:243:3: ( rule__UnnamedErrorPrediateDefinition__Group__0 ) |
543 | } | 599 | // InternalSolverLanguageParser.g:243:4: rule__UnnamedErrorPrediateDefinition__Group__0 |
544 | // InternalSolverLanguage.g:170:3: ( rule__UnnamedErrorPrediateDefinition__Group__0 ) | ||
545 | // InternalSolverLanguage.g:170:4: rule__UnnamedErrorPrediateDefinition__Group__0 | ||
546 | { | 600 | { |
547 | pushFollow(FOLLOW_2); | 601 | pushFollow(FOLLOW_2); |
548 | rule__UnnamedErrorPrediateDefinition__Group__0(); | 602 | rule__UnnamedErrorPrediateDefinition__Group__0(); |
549 | 603 | ||
550 | state._fsp--; | 604 | state._fsp--; |
551 | if (state.failed) return ; | ||
552 | 605 | ||
553 | } | ||
554 | 606 | ||
555 | if ( state.backtracking==0 ) { | ||
556 | after(grammarAccess.getUnnamedErrorPrediateDefinitionAccess().getGroup()); | ||
557 | } | 607 | } |
558 | 608 | ||
609 | after(grammarAccess.getUnnamedErrorPrediateDefinitionAccess().getGroup()); | ||
610 | |||
559 | } | 611 | } |
560 | 612 | ||
561 | 613 | ||
@@ -577,24 +629,20 @@ public class InternalSolverLanguageParser extends AbstractInternalContentAssistP | |||
577 | 629 | ||
578 | 630 | ||
579 | // $ANTLR start "entryRuleDefaultDefinition" | 631 | // $ANTLR start "entryRuleDefaultDefinition" |
580 | // InternalSolverLanguage.g:179:1: entryRuleDefaultDefinition : ruleDefaultDefinition EOF ; | 632 | // InternalSolverLanguageParser.g:252:1: entryRuleDefaultDefinition : ruleDefaultDefinition EOF ; |
581 | public final void entryRuleDefaultDefinition() throws RecognitionException { | 633 | public final void entryRuleDefaultDefinition() throws RecognitionException { |
582 | try { | 634 | try { |
583 | // InternalSolverLanguage.g:180:1: ( ruleDefaultDefinition EOF ) | 635 | // InternalSolverLanguageParser.g:253:1: ( ruleDefaultDefinition EOF ) |
584 | // InternalSolverLanguage.g:181:1: ruleDefaultDefinition EOF | 636 | // InternalSolverLanguageParser.g:254:1: ruleDefaultDefinition EOF |
585 | { | 637 | { |
586 | if ( state.backtracking==0 ) { | 638 | before(grammarAccess.getDefaultDefinitionRule()); |
587 | before(grammarAccess.getDefaultDefinitionRule()); | ||
588 | } | ||
589 | pushFollow(FOLLOW_1); | 639 | pushFollow(FOLLOW_1); |
590 | ruleDefaultDefinition(); | 640 | ruleDefaultDefinition(); |
591 | 641 | ||
592 | state._fsp--; | 642 | state._fsp--; |
593 | if (state.failed) return ; | 643 | |
594 | if ( state.backtracking==0 ) { | 644 | after(grammarAccess.getDefaultDefinitionRule()); |
595 | after(grammarAccess.getDefaultDefinitionRule()); | 645 | match(input,EOF,FOLLOW_2); |
596 | } | ||
597 | match(input,EOF,FOLLOW_2); if (state.failed) return ; | ||
598 | 646 | ||
599 | } | 647 | } |
600 | 648 | ||
@@ -611,36 +659,32 @@ public class InternalSolverLanguageParser extends AbstractInternalContentAssistP | |||
611 | 659 | ||
612 | 660 | ||
613 | // $ANTLR start "ruleDefaultDefinition" | 661 | // $ANTLR start "ruleDefaultDefinition" |
614 | // InternalSolverLanguage.g:188:1: ruleDefaultDefinition : ( ( rule__DefaultDefinition__Group__0 ) ) ; | 662 | // InternalSolverLanguageParser.g:261:1: ruleDefaultDefinition : ( ( rule__DefaultDefinition__Group__0 ) ) ; |
615 | public final void ruleDefaultDefinition() throws RecognitionException { | 663 | public final void ruleDefaultDefinition() throws RecognitionException { |
616 | 664 | ||
617 | int stackSize = keepStackSize(); | 665 | int stackSize = keepStackSize(); |
618 | 666 | ||
619 | try { | 667 | try { |
620 | // InternalSolverLanguage.g:192:2: ( ( ( rule__DefaultDefinition__Group__0 ) ) ) | 668 | // InternalSolverLanguageParser.g:265:2: ( ( ( rule__DefaultDefinition__Group__0 ) ) ) |
621 | // InternalSolverLanguage.g:193:2: ( ( rule__DefaultDefinition__Group__0 ) ) | 669 | // InternalSolverLanguageParser.g:266:2: ( ( rule__DefaultDefinition__Group__0 ) ) |
622 | { | 670 | { |
623 | // InternalSolverLanguage.g:193:2: ( ( rule__DefaultDefinition__Group__0 ) ) | 671 | // InternalSolverLanguageParser.g:266:2: ( ( rule__DefaultDefinition__Group__0 ) ) |
624 | // InternalSolverLanguage.g:194:3: ( rule__DefaultDefinition__Group__0 ) | 672 | // InternalSolverLanguageParser.g:267:3: ( rule__DefaultDefinition__Group__0 ) |
625 | { | 673 | { |
626 | if ( state.backtracking==0 ) { | 674 | before(grammarAccess.getDefaultDefinitionAccess().getGroup()); |
627 | before(grammarAccess.getDefaultDefinitionAccess().getGroup()); | 675 | // InternalSolverLanguageParser.g:268:3: ( rule__DefaultDefinition__Group__0 ) |
628 | } | 676 | // InternalSolverLanguageParser.g:268:4: rule__DefaultDefinition__Group__0 |
629 | // InternalSolverLanguage.g:195:3: ( rule__DefaultDefinition__Group__0 ) | ||
630 | // InternalSolverLanguage.g:195:4: rule__DefaultDefinition__Group__0 | ||
631 | { | 677 | { |
632 | pushFollow(FOLLOW_2); | 678 | pushFollow(FOLLOW_2); |
633 | rule__DefaultDefinition__Group__0(); | 679 | rule__DefaultDefinition__Group__0(); |
634 | 680 | ||
635 | state._fsp--; | 681 | state._fsp--; |
636 | if (state.failed) return ; | ||
637 | 682 | ||
638 | } | ||
639 | 683 | ||
640 | if ( state.backtracking==0 ) { | ||
641 | after(grammarAccess.getDefaultDefinitionAccess().getGroup()); | ||
642 | } | 684 | } |
643 | 685 | ||
686 | after(grammarAccess.getDefaultDefinitionAccess().getGroup()); | ||
687 | |||
644 | } | 688 | } |
645 | 689 | ||
646 | 690 | ||
@@ -662,24 +706,20 @@ public class InternalSolverLanguageParser extends AbstractInternalContentAssistP | |||
662 | 706 | ||
663 | 707 | ||
664 | // $ANTLR start "entryRuleExternPredicateDefinition" | 708 | // $ANTLR start "entryRuleExternPredicateDefinition" |
665 | // InternalSolverLanguage.g:204:1: entryRuleExternPredicateDefinition : ruleExternPredicateDefinition EOF ; | 709 | // InternalSolverLanguageParser.g:277:1: entryRuleExternPredicateDefinition : ruleExternPredicateDefinition EOF ; |
666 | public final void entryRuleExternPredicateDefinition() throws RecognitionException { | 710 | public final void entryRuleExternPredicateDefinition() throws RecognitionException { |
667 | try { | 711 | try { |
668 | // InternalSolverLanguage.g:205:1: ( ruleExternPredicateDefinition EOF ) | 712 | // InternalSolverLanguageParser.g:278:1: ( ruleExternPredicateDefinition EOF ) |
669 | // InternalSolverLanguage.g:206:1: ruleExternPredicateDefinition EOF | 713 | // InternalSolverLanguageParser.g:279:1: ruleExternPredicateDefinition EOF |
670 | { | 714 | { |
671 | if ( state.backtracking==0 ) { | 715 | before(grammarAccess.getExternPredicateDefinitionRule()); |
672 | before(grammarAccess.getExternPredicateDefinitionRule()); | ||
673 | } | ||
674 | pushFollow(FOLLOW_1); | 716 | pushFollow(FOLLOW_1); |
675 | ruleExternPredicateDefinition(); | 717 | ruleExternPredicateDefinition(); |
676 | 718 | ||
677 | state._fsp--; | 719 | state._fsp--; |
678 | if (state.failed) return ; | 720 | |
679 | if ( state.backtracking==0 ) { | 721 | after(grammarAccess.getExternPredicateDefinitionRule()); |
680 | after(grammarAccess.getExternPredicateDefinitionRule()); | 722 | match(input,EOF,FOLLOW_2); |
681 | } | ||
682 | match(input,EOF,FOLLOW_2); if (state.failed) return ; | ||
683 | 723 | ||
684 | } | 724 | } |
685 | 725 | ||
@@ -696,36 +736,32 @@ public class InternalSolverLanguageParser extends AbstractInternalContentAssistP | |||
696 | 736 | ||
697 | 737 | ||
698 | // $ANTLR start "ruleExternPredicateDefinition" | 738 | // $ANTLR start "ruleExternPredicateDefinition" |
699 | // InternalSolverLanguage.g:213:1: ruleExternPredicateDefinition : ( ( rule__ExternPredicateDefinition__Group__0 ) ) ; | 739 | // InternalSolverLanguageParser.g:286:1: ruleExternPredicateDefinition : ( ( rule__ExternPredicateDefinition__Group__0 ) ) ; |
700 | public final void ruleExternPredicateDefinition() throws RecognitionException { | 740 | public final void ruleExternPredicateDefinition() throws RecognitionException { |
701 | 741 | ||
702 | int stackSize = keepStackSize(); | 742 | int stackSize = keepStackSize(); |
703 | 743 | ||
704 | try { | 744 | try { |
705 | // InternalSolverLanguage.g:217:2: ( ( ( rule__ExternPredicateDefinition__Group__0 ) ) ) | 745 | // InternalSolverLanguageParser.g:290:2: ( ( ( rule__ExternPredicateDefinition__Group__0 ) ) ) |
706 | // InternalSolverLanguage.g:218:2: ( ( rule__ExternPredicateDefinition__Group__0 ) ) | 746 | // InternalSolverLanguageParser.g:291:2: ( ( rule__ExternPredicateDefinition__Group__0 ) ) |
707 | { | 747 | { |
708 | // InternalSolverLanguage.g:218:2: ( ( rule__ExternPredicateDefinition__Group__0 ) ) | 748 | // InternalSolverLanguageParser.g:291:2: ( ( rule__ExternPredicateDefinition__Group__0 ) ) |
709 | // InternalSolverLanguage.g:219:3: ( rule__ExternPredicateDefinition__Group__0 ) | 749 | // InternalSolverLanguageParser.g:292:3: ( rule__ExternPredicateDefinition__Group__0 ) |
710 | { | 750 | { |
711 | if ( state.backtracking==0 ) { | 751 | before(grammarAccess.getExternPredicateDefinitionAccess().getGroup()); |
712 | before(grammarAccess.getExternPredicateDefinitionAccess().getGroup()); | 752 | // InternalSolverLanguageParser.g:293:3: ( rule__ExternPredicateDefinition__Group__0 ) |
713 | } | 753 | // InternalSolverLanguageParser.g:293:4: rule__ExternPredicateDefinition__Group__0 |
714 | // InternalSolverLanguage.g:220:3: ( rule__ExternPredicateDefinition__Group__0 ) | ||
715 | // InternalSolverLanguage.g:220:4: rule__ExternPredicateDefinition__Group__0 | ||
716 | { | 754 | { |
717 | pushFollow(FOLLOW_2); | 755 | pushFollow(FOLLOW_2); |
718 | rule__ExternPredicateDefinition__Group__0(); | 756 | rule__ExternPredicateDefinition__Group__0(); |
719 | 757 | ||
720 | state._fsp--; | 758 | state._fsp--; |
721 | if (state.failed) return ; | ||
722 | 759 | ||
723 | } | ||
724 | 760 | ||
725 | if ( state.backtracking==0 ) { | ||
726 | after(grammarAccess.getExternPredicateDefinitionAccess().getGroup()); | ||
727 | } | 761 | } |
728 | 762 | ||
763 | after(grammarAccess.getExternPredicateDefinitionAccess().getGroup()); | ||
764 | |||
729 | } | 765 | } |
730 | 766 | ||
731 | 767 | ||
@@ -747,24 +783,20 @@ public class InternalSolverLanguageParser extends AbstractInternalContentAssistP | |||
747 | 783 | ||
748 | 784 | ||
749 | // $ANTLR start "entryRuleMetricDefinition" | 785 | // $ANTLR start "entryRuleMetricDefinition" |
750 | // InternalSolverLanguage.g:229:1: entryRuleMetricDefinition : ruleMetricDefinition EOF ; | 786 | // InternalSolverLanguageParser.g:302:1: entryRuleMetricDefinition : ruleMetricDefinition EOF ; |
751 | public final void entryRuleMetricDefinition() throws RecognitionException { | 787 | public final void entryRuleMetricDefinition() throws RecognitionException { |
752 | try { | 788 | try { |
753 | // InternalSolverLanguage.g:230:1: ( ruleMetricDefinition EOF ) | 789 | // InternalSolverLanguageParser.g:303:1: ( ruleMetricDefinition EOF ) |
754 | // InternalSolverLanguage.g:231:1: ruleMetricDefinition EOF | 790 | // InternalSolverLanguageParser.g:304:1: ruleMetricDefinition EOF |
755 | { | 791 | { |
756 | if ( state.backtracking==0 ) { | 792 | before(grammarAccess.getMetricDefinitionRule()); |
757 | before(grammarAccess.getMetricDefinitionRule()); | ||
758 | } | ||
759 | pushFollow(FOLLOW_1); | 793 | pushFollow(FOLLOW_1); |
760 | ruleMetricDefinition(); | 794 | ruleMetricDefinition(); |
761 | 795 | ||
762 | state._fsp--; | 796 | state._fsp--; |
763 | if (state.failed) return ; | 797 | |
764 | if ( state.backtracking==0 ) { | 798 | after(grammarAccess.getMetricDefinitionRule()); |
765 | after(grammarAccess.getMetricDefinitionRule()); | 799 | match(input,EOF,FOLLOW_2); |
766 | } | ||
767 | match(input,EOF,FOLLOW_2); if (state.failed) return ; | ||
768 | 800 | ||
769 | } | 801 | } |
770 | 802 | ||
@@ -781,36 +813,32 @@ public class InternalSolverLanguageParser extends AbstractInternalContentAssistP | |||
781 | 813 | ||
782 | 814 | ||
783 | // $ANTLR start "ruleMetricDefinition" | 815 | // $ANTLR start "ruleMetricDefinition" |
784 | // InternalSolverLanguage.g:238:1: ruleMetricDefinition : ( ( rule__MetricDefinition__Group__0 ) ) ; | 816 | // InternalSolverLanguageParser.g:311:1: ruleMetricDefinition : ( ( rule__MetricDefinition__Group__0 ) ) ; |
785 | public final void ruleMetricDefinition() throws RecognitionException { | 817 | public final void ruleMetricDefinition() throws RecognitionException { |
786 | 818 | ||
787 | int stackSize = keepStackSize(); | 819 | int stackSize = keepStackSize(); |
788 | 820 | ||
789 | try { | 821 | try { |
790 | // InternalSolverLanguage.g:242:2: ( ( ( rule__MetricDefinition__Group__0 ) ) ) | 822 | // InternalSolverLanguageParser.g:315:2: ( ( ( rule__MetricDefinition__Group__0 ) ) ) |
791 | // InternalSolverLanguage.g:243:2: ( ( rule__MetricDefinition__Group__0 ) ) | 823 | // InternalSolverLanguageParser.g:316:2: ( ( rule__MetricDefinition__Group__0 ) ) |
792 | { | 824 | { |
793 | // InternalSolverLanguage.g:243:2: ( ( rule__MetricDefinition__Group__0 ) ) | 825 | // InternalSolverLanguageParser.g:316:2: ( ( rule__MetricDefinition__Group__0 ) ) |
794 | // InternalSolverLanguage.g:244:3: ( rule__MetricDefinition__Group__0 ) | 826 | // InternalSolverLanguageParser.g:317:3: ( rule__MetricDefinition__Group__0 ) |
795 | { | 827 | { |
796 | if ( state.backtracking==0 ) { | 828 | before(grammarAccess.getMetricDefinitionAccess().getGroup()); |
797 | before(grammarAccess.getMetricDefinitionAccess().getGroup()); | 829 | // InternalSolverLanguageParser.g:318:3: ( rule__MetricDefinition__Group__0 ) |
798 | } | 830 | // InternalSolverLanguageParser.g:318:4: rule__MetricDefinition__Group__0 |
799 | // InternalSolverLanguage.g:245:3: ( rule__MetricDefinition__Group__0 ) | ||
800 | // InternalSolverLanguage.g:245:4: rule__MetricDefinition__Group__0 | ||
801 | { | 831 | { |
802 | pushFollow(FOLLOW_2); | 832 | pushFollow(FOLLOW_2); |
803 | rule__MetricDefinition__Group__0(); | 833 | rule__MetricDefinition__Group__0(); |
804 | 834 | ||
805 | state._fsp--; | 835 | state._fsp--; |
806 | if (state.failed) return ; | ||
807 | 836 | ||
808 | } | ||
809 | 837 | ||
810 | if ( state.backtracking==0 ) { | ||
811 | after(grammarAccess.getMetricDefinitionAccess().getGroup()); | ||
812 | } | 838 | } |
813 | 839 | ||
840 | after(grammarAccess.getMetricDefinitionAccess().getGroup()); | ||
841 | |||
814 | } | 842 | } |
815 | 843 | ||
816 | 844 | ||
@@ -832,24 +860,20 @@ public class InternalSolverLanguageParser extends AbstractInternalContentAssistP | |||
832 | 860 | ||
833 | 861 | ||
834 | // $ANTLR start "entryRuleExternMetricDefinition" | 862 | // $ANTLR start "entryRuleExternMetricDefinition" |
835 | // InternalSolverLanguage.g:254:1: entryRuleExternMetricDefinition : ruleExternMetricDefinition EOF ; | 863 | // InternalSolverLanguageParser.g:327:1: entryRuleExternMetricDefinition : ruleExternMetricDefinition EOF ; |
836 | public final void entryRuleExternMetricDefinition() throws RecognitionException { | 864 | public final void entryRuleExternMetricDefinition() throws RecognitionException { |
837 | try { | 865 | try { |
838 | // InternalSolverLanguage.g:255:1: ( ruleExternMetricDefinition EOF ) | 866 | // InternalSolverLanguageParser.g:328:1: ( ruleExternMetricDefinition EOF ) |
839 | // InternalSolverLanguage.g:256:1: ruleExternMetricDefinition EOF | 867 | // InternalSolverLanguageParser.g:329:1: ruleExternMetricDefinition EOF |
840 | { | 868 | { |
841 | if ( state.backtracking==0 ) { | 869 | before(grammarAccess.getExternMetricDefinitionRule()); |
842 | before(grammarAccess.getExternMetricDefinitionRule()); | ||
843 | } | ||
844 | pushFollow(FOLLOW_1); | 870 | pushFollow(FOLLOW_1); |
845 | ruleExternMetricDefinition(); | 871 | ruleExternMetricDefinition(); |
846 | 872 | ||
847 | state._fsp--; | 873 | state._fsp--; |
848 | if (state.failed) return ; | 874 | |
849 | if ( state.backtracking==0 ) { | 875 | after(grammarAccess.getExternMetricDefinitionRule()); |
850 | after(grammarAccess.getExternMetricDefinitionRule()); | 876 | match(input,EOF,FOLLOW_2); |
851 | } | ||
852 | match(input,EOF,FOLLOW_2); if (state.failed) return ; | ||
853 | 877 | ||
854 | } | 878 | } |
855 | 879 | ||
@@ -866,36 +890,32 @@ public class InternalSolverLanguageParser extends AbstractInternalContentAssistP | |||
866 | 890 | ||
867 | 891 | ||
868 | // $ANTLR start "ruleExternMetricDefinition" | 892 | // $ANTLR start "ruleExternMetricDefinition" |
869 | // InternalSolverLanguage.g:263:1: ruleExternMetricDefinition : ( ( rule__ExternMetricDefinition__Group__0 ) ) ; | 893 | // InternalSolverLanguageParser.g:336:1: ruleExternMetricDefinition : ( ( rule__ExternMetricDefinition__Group__0 ) ) ; |
870 | public final void ruleExternMetricDefinition() throws RecognitionException { | 894 | public final void ruleExternMetricDefinition() throws RecognitionException { |
871 | 895 | ||
872 | int stackSize = keepStackSize(); | 896 | int stackSize = keepStackSize(); |
873 | 897 | ||
874 | try { | 898 | try { |
875 | // InternalSolverLanguage.g:267:2: ( ( ( rule__ExternMetricDefinition__Group__0 ) ) ) | 899 | // InternalSolverLanguageParser.g:340:2: ( ( ( rule__ExternMetricDefinition__Group__0 ) ) ) |
876 | // InternalSolverLanguage.g:268:2: ( ( rule__ExternMetricDefinition__Group__0 ) ) | 900 | // InternalSolverLanguageParser.g:341:2: ( ( rule__ExternMetricDefinition__Group__0 ) ) |
877 | { | 901 | { |
878 | // InternalSolverLanguage.g:268:2: ( ( rule__ExternMetricDefinition__Group__0 ) ) | 902 | // InternalSolverLanguageParser.g:341:2: ( ( rule__ExternMetricDefinition__Group__0 ) ) |
879 | // InternalSolverLanguage.g:269:3: ( rule__ExternMetricDefinition__Group__0 ) | 903 | // InternalSolverLanguageParser.g:342:3: ( rule__ExternMetricDefinition__Group__0 ) |
880 | { | 904 | { |
881 | if ( state.backtracking==0 ) { | 905 | before(grammarAccess.getExternMetricDefinitionAccess().getGroup()); |
882 | before(grammarAccess.getExternMetricDefinitionAccess().getGroup()); | 906 | // InternalSolverLanguageParser.g:343:3: ( rule__ExternMetricDefinition__Group__0 ) |
883 | } | 907 | // InternalSolverLanguageParser.g:343:4: rule__ExternMetricDefinition__Group__0 |
884 | // InternalSolverLanguage.g:270:3: ( rule__ExternMetricDefinition__Group__0 ) | ||
885 | // InternalSolverLanguage.g:270:4: rule__ExternMetricDefinition__Group__0 | ||
886 | { | 908 | { |
887 | pushFollow(FOLLOW_2); | 909 | pushFollow(FOLLOW_2); |
888 | rule__ExternMetricDefinition__Group__0(); | 910 | rule__ExternMetricDefinition__Group__0(); |
889 | 911 | ||
890 | state._fsp--; | 912 | state._fsp--; |
891 | if (state.failed) return ; | ||
892 | 913 | ||
893 | } | ||
894 | 914 | ||
895 | if ( state.backtracking==0 ) { | ||
896 | after(grammarAccess.getExternMetricDefinitionAccess().getGroup()); | ||
897 | } | 915 | } |
898 | 916 | ||
917 | after(grammarAccess.getExternMetricDefinitionAccess().getGroup()); | ||
918 | |||
899 | } | 919 | } |
900 | 920 | ||
901 | 921 | ||
@@ -917,24 +937,20 @@ public class InternalSolverLanguageParser extends AbstractInternalContentAssistP | |||
917 | 937 | ||
918 | 938 | ||
919 | // $ANTLR start "entryRuleExpression" | 939 | // $ANTLR start "entryRuleExpression" |
920 | // InternalSolverLanguage.g:279:1: entryRuleExpression : ruleExpression EOF ; | 940 | // InternalSolverLanguageParser.g:352:1: entryRuleExpression : ruleExpression EOF ; |
921 | public final void entryRuleExpression() throws RecognitionException { | 941 | public final void entryRuleExpression() throws RecognitionException { |
922 | try { | 942 | try { |
923 | // InternalSolverLanguage.g:280:1: ( ruleExpression EOF ) | 943 | // InternalSolverLanguageParser.g:353:1: ( ruleExpression EOF ) |
924 | // InternalSolverLanguage.g:281:1: ruleExpression EOF | 944 | // InternalSolverLanguageParser.g:354:1: ruleExpression EOF |
925 | { | 945 | { |
926 | if ( state.backtracking==0 ) { | 946 | before(grammarAccess.getExpressionRule()); |
927 | before(grammarAccess.getExpressionRule()); | ||
928 | } | ||
929 | pushFollow(FOLLOW_1); | 947 | pushFollow(FOLLOW_1); |
930 | ruleExpression(); | 948 | ruleExpression(); |
931 | 949 | ||
932 | state._fsp--; | 950 | state._fsp--; |
933 | if (state.failed) return ; | 951 | |
934 | if ( state.backtracking==0 ) { | 952 | after(grammarAccess.getExpressionRule()); |
935 | after(grammarAccess.getExpressionRule()); | 953 | match(input,EOF,FOLLOW_2); |
936 | } | ||
937 | match(input,EOF,FOLLOW_2); if (state.failed) return ; | ||
938 | 954 | ||
939 | } | 955 | } |
940 | 956 | ||
@@ -951,36 +967,32 @@ public class InternalSolverLanguageParser extends AbstractInternalContentAssistP | |||
951 | 967 | ||
952 | 968 | ||
953 | // $ANTLR start "ruleExpression" | 969 | // $ANTLR start "ruleExpression" |
954 | // InternalSolverLanguage.g:288:1: ruleExpression : ( ( rule__Expression__Alternatives ) ) ; | 970 | // InternalSolverLanguageParser.g:361:1: ruleExpression : ( ( rule__Expression__Alternatives ) ) ; |
955 | public final void ruleExpression() throws RecognitionException { | 971 | public final void ruleExpression() throws RecognitionException { |
956 | 972 | ||
957 | int stackSize = keepStackSize(); | 973 | int stackSize = keepStackSize(); |
958 | 974 | ||
959 | try { | 975 | try { |
960 | // InternalSolverLanguage.g:292:2: ( ( ( rule__Expression__Alternatives ) ) ) | 976 | // InternalSolverLanguageParser.g:365:2: ( ( ( rule__Expression__Alternatives ) ) ) |
961 | // InternalSolverLanguage.g:293:2: ( ( rule__Expression__Alternatives ) ) | 977 | // InternalSolverLanguageParser.g:366:2: ( ( rule__Expression__Alternatives ) ) |
962 | { | 978 | { |
963 | // InternalSolverLanguage.g:293:2: ( ( rule__Expression__Alternatives ) ) | 979 | // InternalSolverLanguageParser.g:366:2: ( ( rule__Expression__Alternatives ) ) |
964 | // InternalSolverLanguage.g:294:3: ( rule__Expression__Alternatives ) | 980 | // InternalSolverLanguageParser.g:367:3: ( rule__Expression__Alternatives ) |
965 | { | 981 | { |
966 | if ( state.backtracking==0 ) { | 982 | before(grammarAccess.getExpressionAccess().getAlternatives()); |
967 | before(grammarAccess.getExpressionAccess().getAlternatives()); | 983 | // InternalSolverLanguageParser.g:368:3: ( rule__Expression__Alternatives ) |
968 | } | 984 | // InternalSolverLanguageParser.g:368:4: rule__Expression__Alternatives |
969 | // InternalSolverLanguage.g:295:3: ( rule__Expression__Alternatives ) | ||
970 | // InternalSolverLanguage.g:295:4: rule__Expression__Alternatives | ||
971 | { | 985 | { |
972 | pushFollow(FOLLOW_2); | 986 | pushFollow(FOLLOW_2); |
973 | rule__Expression__Alternatives(); | 987 | rule__Expression__Alternatives(); |
974 | 988 | ||
975 | state._fsp--; | 989 | state._fsp--; |
976 | if (state.failed) return ; | ||
977 | 990 | ||
978 | } | ||
979 | 991 | ||
980 | if ( state.backtracking==0 ) { | ||
981 | after(grammarAccess.getExpressionAccess().getAlternatives()); | ||
982 | } | 992 | } |
983 | 993 | ||
994 | after(grammarAccess.getExpressionAccess().getAlternatives()); | ||
995 | |||
984 | } | 996 | } |
985 | 997 | ||
986 | 998 | ||
@@ -1002,24 +1014,20 @@ public class InternalSolverLanguageParser extends AbstractInternalContentAssistP | |||
1002 | 1014 | ||
1003 | 1015 | ||
1004 | // $ANTLR start "entryRuleIfElse" | 1016 | // $ANTLR start "entryRuleIfElse" |
1005 | // InternalSolverLanguage.g:304:1: entryRuleIfElse : ruleIfElse EOF ; | 1017 | // InternalSolverLanguageParser.g:377:1: entryRuleIfElse : ruleIfElse EOF ; |
1006 | public final void entryRuleIfElse() throws RecognitionException { | 1018 | public final void entryRuleIfElse() throws RecognitionException { |
1007 | try { | 1019 | try { |
1008 | // InternalSolverLanguage.g:305:1: ( ruleIfElse EOF ) | 1020 | // InternalSolverLanguageParser.g:378:1: ( ruleIfElse EOF ) |
1009 | // InternalSolverLanguage.g:306:1: ruleIfElse EOF | 1021 | // InternalSolverLanguageParser.g:379:1: ruleIfElse EOF |
1010 | { | 1022 | { |
1011 | if ( state.backtracking==0 ) { | 1023 | before(grammarAccess.getIfElseRule()); |
1012 | before(grammarAccess.getIfElseRule()); | ||
1013 | } | ||
1014 | pushFollow(FOLLOW_1); | 1024 | pushFollow(FOLLOW_1); |
1015 | ruleIfElse(); | 1025 | ruleIfElse(); |
1016 | 1026 | ||
1017 | state._fsp--; | 1027 | state._fsp--; |
1018 | if (state.failed) return ; | 1028 | |
1019 | if ( state.backtracking==0 ) { | 1029 | after(grammarAccess.getIfElseRule()); |
1020 | after(grammarAccess.getIfElseRule()); | 1030 | match(input,EOF,FOLLOW_2); |
1021 | } | ||
1022 | match(input,EOF,FOLLOW_2); if (state.failed) return ; | ||
1023 | 1031 | ||
1024 | } | 1032 | } |
1025 | 1033 | ||
@@ -1036,36 +1044,32 @@ public class InternalSolverLanguageParser extends AbstractInternalContentAssistP | |||
1036 | 1044 | ||
1037 | 1045 | ||
1038 | // $ANTLR start "ruleIfElse" | 1046 | // $ANTLR start "ruleIfElse" |
1039 | // InternalSolverLanguage.g:313:1: ruleIfElse : ( ( rule__IfElse__Group__0 ) ) ; | 1047 | // InternalSolverLanguageParser.g:386:1: ruleIfElse : ( ( rule__IfElse__Group__0 ) ) ; |
1040 | public final void ruleIfElse() throws RecognitionException { | 1048 | public final void ruleIfElse() throws RecognitionException { |
1041 | 1049 | ||
1042 | int stackSize = keepStackSize(); | 1050 | int stackSize = keepStackSize(); |
1043 | 1051 | ||
1044 | try { | 1052 | try { |
1045 | // InternalSolverLanguage.g:317:2: ( ( ( rule__IfElse__Group__0 ) ) ) | 1053 | // InternalSolverLanguageParser.g:390:2: ( ( ( rule__IfElse__Group__0 ) ) ) |
1046 | // InternalSolverLanguage.g:318:2: ( ( rule__IfElse__Group__0 ) ) | 1054 | // InternalSolverLanguageParser.g:391:2: ( ( rule__IfElse__Group__0 ) ) |
1047 | { | 1055 | { |
1048 | // InternalSolverLanguage.g:318:2: ( ( rule__IfElse__Group__0 ) ) | 1056 | // InternalSolverLanguageParser.g:391:2: ( ( rule__IfElse__Group__0 ) ) |
1049 | // InternalSolverLanguage.g:319:3: ( rule__IfElse__Group__0 ) | 1057 | // InternalSolverLanguageParser.g:392:3: ( rule__IfElse__Group__0 ) |
1050 | { | 1058 | { |
1051 | if ( state.backtracking==0 ) { | 1059 | before(grammarAccess.getIfElseAccess().getGroup()); |
1052 | before(grammarAccess.getIfElseAccess().getGroup()); | 1060 | // InternalSolverLanguageParser.g:393:3: ( rule__IfElse__Group__0 ) |
1053 | } | 1061 | // InternalSolverLanguageParser.g:393:4: rule__IfElse__Group__0 |
1054 | // InternalSolverLanguage.g:320:3: ( rule__IfElse__Group__0 ) | ||
1055 | // InternalSolverLanguage.g:320:4: rule__IfElse__Group__0 | ||
1056 | { | 1062 | { |
1057 | pushFollow(FOLLOW_2); | 1063 | pushFollow(FOLLOW_2); |
1058 | rule__IfElse__Group__0(); | 1064 | rule__IfElse__Group__0(); |
1059 | 1065 | ||
1060 | state._fsp--; | 1066 | state._fsp--; |
1061 | if (state.failed) return ; | ||
1062 | 1067 | ||
1063 | } | ||
1064 | 1068 | ||
1065 | if ( state.backtracking==0 ) { | ||
1066 | after(grammarAccess.getIfElseAccess().getGroup()); | ||
1067 | } | 1069 | } |
1068 | 1070 | ||
1071 | after(grammarAccess.getIfElseAccess().getGroup()); | ||
1072 | |||
1069 | } | 1073 | } |
1070 | 1074 | ||
1071 | 1075 | ||
@@ -1087,24 +1091,20 @@ public class InternalSolverLanguageParser extends AbstractInternalContentAssistP | |||
1087 | 1091 | ||
1088 | 1092 | ||
1089 | // $ANTLR start "entryRuleDisjunctiveExpression" | 1093 | // $ANTLR start "entryRuleDisjunctiveExpression" |
1090 | // InternalSolverLanguage.g:329:1: entryRuleDisjunctiveExpression : ruleDisjunctiveExpression EOF ; | 1094 | // InternalSolverLanguageParser.g:402:1: entryRuleDisjunctiveExpression : ruleDisjunctiveExpression EOF ; |
1091 | public final void entryRuleDisjunctiveExpression() throws RecognitionException { | 1095 | public final void entryRuleDisjunctiveExpression() throws RecognitionException { |
1092 | try { | 1096 | try { |
1093 | // InternalSolverLanguage.g:330:1: ( ruleDisjunctiveExpression EOF ) | 1097 | // InternalSolverLanguageParser.g:403:1: ( ruleDisjunctiveExpression EOF ) |
1094 | // InternalSolverLanguage.g:331:1: ruleDisjunctiveExpression EOF | 1098 | // InternalSolverLanguageParser.g:404:1: ruleDisjunctiveExpression EOF |
1095 | { | 1099 | { |
1096 | if ( state.backtracking==0 ) { | 1100 | before(grammarAccess.getDisjunctiveExpressionRule()); |
1097 | before(grammarAccess.getDisjunctiveExpressionRule()); | ||
1098 | } | ||
1099 | pushFollow(FOLLOW_1); | 1101 | pushFollow(FOLLOW_1); |
1100 | ruleDisjunctiveExpression(); | 1102 | ruleDisjunctiveExpression(); |
1101 | 1103 | ||
1102 | state._fsp--; | 1104 | state._fsp--; |
1103 | if (state.failed) return ; | 1105 | |
1104 | if ( state.backtracking==0 ) { | 1106 | after(grammarAccess.getDisjunctiveExpressionRule()); |
1105 | after(grammarAccess.getDisjunctiveExpressionRule()); | 1107 | match(input,EOF,FOLLOW_2); |
1106 | } | ||
1107 | match(input,EOF,FOLLOW_2); if (state.failed) return ; | ||
1108 | 1108 | ||
1109 | } | 1109 | } |
1110 | 1110 | ||
@@ -1121,36 +1121,32 @@ public class InternalSolverLanguageParser extends AbstractInternalContentAssistP | |||
1121 | 1121 | ||
1122 | 1122 | ||
1123 | // $ANTLR start "ruleDisjunctiveExpression" | 1123 | // $ANTLR start "ruleDisjunctiveExpression" |
1124 | // InternalSolverLanguage.g:338:1: ruleDisjunctiveExpression : ( ( rule__DisjunctiveExpression__Group__0 ) ) ; | 1124 | // InternalSolverLanguageParser.g:411:1: ruleDisjunctiveExpression : ( ( rule__DisjunctiveExpression__Group__0 ) ) ; |
1125 | public final void ruleDisjunctiveExpression() throws RecognitionException { | 1125 | public final void ruleDisjunctiveExpression() throws RecognitionException { |
1126 | 1126 | ||
1127 | int stackSize = keepStackSize(); | 1127 | int stackSize = keepStackSize(); |
1128 | 1128 | ||
1129 | try { | 1129 | try { |
1130 | // InternalSolverLanguage.g:342:2: ( ( ( rule__DisjunctiveExpression__Group__0 ) ) ) | 1130 | // InternalSolverLanguageParser.g:415:2: ( ( ( rule__DisjunctiveExpression__Group__0 ) ) ) |
1131 | // InternalSolverLanguage.g:343:2: ( ( rule__DisjunctiveExpression__Group__0 ) ) | 1131 | // InternalSolverLanguageParser.g:416:2: ( ( rule__DisjunctiveExpression__Group__0 ) ) |
1132 | { | 1132 | { |
1133 | // InternalSolverLanguage.g:343:2: ( ( rule__DisjunctiveExpression__Group__0 ) ) | 1133 | // InternalSolverLanguageParser.g:416:2: ( ( rule__DisjunctiveExpression__Group__0 ) ) |
1134 | // InternalSolverLanguage.g:344:3: ( rule__DisjunctiveExpression__Group__0 ) | 1134 | // InternalSolverLanguageParser.g:417:3: ( rule__DisjunctiveExpression__Group__0 ) |
1135 | { | 1135 | { |
1136 | if ( state.backtracking==0 ) { | 1136 | before(grammarAccess.getDisjunctiveExpressionAccess().getGroup()); |
1137 | before(grammarAccess.getDisjunctiveExpressionAccess().getGroup()); | 1137 | // InternalSolverLanguageParser.g:418:3: ( rule__DisjunctiveExpression__Group__0 ) |
1138 | } | 1138 | // InternalSolverLanguageParser.g:418:4: rule__DisjunctiveExpression__Group__0 |
1139 | // InternalSolverLanguage.g:345:3: ( rule__DisjunctiveExpression__Group__0 ) | ||
1140 | // InternalSolverLanguage.g:345:4: rule__DisjunctiveExpression__Group__0 | ||
1141 | { | 1139 | { |
1142 | pushFollow(FOLLOW_2); | 1140 | pushFollow(FOLLOW_2); |
1143 | rule__DisjunctiveExpression__Group__0(); | 1141 | rule__DisjunctiveExpression__Group__0(); |
1144 | 1142 | ||
1145 | state._fsp--; | 1143 | state._fsp--; |
1146 | if (state.failed) return ; | ||
1147 | 1144 | ||
1148 | } | ||
1149 | 1145 | ||
1150 | if ( state.backtracking==0 ) { | ||
1151 | after(grammarAccess.getDisjunctiveExpressionAccess().getGroup()); | ||
1152 | } | 1146 | } |
1153 | 1147 | ||
1148 | after(grammarAccess.getDisjunctiveExpressionAccess().getGroup()); | ||
1149 | |||
1154 | } | 1150 | } |
1155 | 1151 | ||
1156 | 1152 | ||
@@ -1172,24 +1168,20 @@ public class InternalSolverLanguageParser extends AbstractInternalContentAssistP | |||
1172 | 1168 | ||
1173 | 1169 | ||
1174 | // $ANTLR start "entryRuleCase" | 1170 | // $ANTLR start "entryRuleCase" |
1175 | // InternalSolverLanguage.g:354:1: entryRuleCase : ruleCase EOF ; | 1171 | // InternalSolverLanguageParser.g:427:1: entryRuleCase : ruleCase EOF ; |
1176 | public final void entryRuleCase() throws RecognitionException { | 1172 | public final void entryRuleCase() throws RecognitionException { |
1177 | try { | 1173 | try { |
1178 | // InternalSolverLanguage.g:355:1: ( ruleCase EOF ) | 1174 | // InternalSolverLanguageParser.g:428:1: ( ruleCase EOF ) |
1179 | // InternalSolverLanguage.g:356:1: ruleCase EOF | 1175 | // InternalSolverLanguageParser.g:429:1: ruleCase EOF |
1180 | { | 1176 | { |
1181 | if ( state.backtracking==0 ) { | 1177 | before(grammarAccess.getCaseRule()); |
1182 | before(grammarAccess.getCaseRule()); | ||
1183 | } | ||
1184 | pushFollow(FOLLOW_1); | 1178 | pushFollow(FOLLOW_1); |
1185 | ruleCase(); | 1179 | ruleCase(); |
1186 | 1180 | ||
1187 | state._fsp--; | 1181 | state._fsp--; |
1188 | if (state.failed) return ; | 1182 | |
1189 | if ( state.backtracking==0 ) { | 1183 | after(grammarAccess.getCaseRule()); |
1190 | after(grammarAccess.getCaseRule()); | 1184 | match(input,EOF,FOLLOW_2); |
1191 | } | ||
1192 | match(input,EOF,FOLLOW_2); if (state.failed) return ; | ||
1193 | 1185 | ||
1194 | } | 1186 | } |
1195 | 1187 | ||
@@ -1206,36 +1198,32 @@ public class InternalSolverLanguageParser extends AbstractInternalContentAssistP | |||
1206 | 1198 | ||
1207 | 1199 | ||
1208 | // $ANTLR start "ruleCase" | 1200 | // $ANTLR start "ruleCase" |
1209 | // InternalSolverLanguage.g:363:1: ruleCase : ( ( rule__Case__Group__0 ) ) ; | 1201 | // InternalSolverLanguageParser.g:436:1: ruleCase : ( ( rule__Case__Group__0 ) ) ; |
1210 | public final void ruleCase() throws RecognitionException { | 1202 | public final void ruleCase() throws RecognitionException { |
1211 | 1203 | ||
1212 | int stackSize = keepStackSize(); | 1204 | int stackSize = keepStackSize(); |
1213 | 1205 | ||
1214 | try { | 1206 | try { |
1215 | // InternalSolverLanguage.g:367:2: ( ( ( rule__Case__Group__0 ) ) ) | 1207 | // InternalSolverLanguageParser.g:440:2: ( ( ( rule__Case__Group__0 ) ) ) |
1216 | // InternalSolverLanguage.g:368:2: ( ( rule__Case__Group__0 ) ) | 1208 | // InternalSolverLanguageParser.g:441:2: ( ( rule__Case__Group__0 ) ) |
1217 | { | 1209 | { |
1218 | // InternalSolverLanguage.g:368:2: ( ( rule__Case__Group__0 ) ) | 1210 | // InternalSolverLanguageParser.g:441:2: ( ( rule__Case__Group__0 ) ) |
1219 | // InternalSolverLanguage.g:369:3: ( rule__Case__Group__0 ) | 1211 | // InternalSolverLanguageParser.g:442:3: ( rule__Case__Group__0 ) |
1220 | { | 1212 | { |
1221 | if ( state.backtracking==0 ) { | 1213 | before(grammarAccess.getCaseAccess().getGroup()); |
1222 | before(grammarAccess.getCaseAccess().getGroup()); | 1214 | // InternalSolverLanguageParser.g:443:3: ( rule__Case__Group__0 ) |
1223 | } | 1215 | // InternalSolverLanguageParser.g:443:4: rule__Case__Group__0 |
1224 | // InternalSolverLanguage.g:370:3: ( rule__Case__Group__0 ) | ||
1225 | // InternalSolverLanguage.g:370:4: rule__Case__Group__0 | ||
1226 | { | 1216 | { |
1227 | pushFollow(FOLLOW_2); | 1217 | pushFollow(FOLLOW_2); |
1228 | rule__Case__Group__0(); | 1218 | rule__Case__Group__0(); |
1229 | 1219 | ||
1230 | state._fsp--; | 1220 | state._fsp--; |
1231 | if (state.failed) return ; | ||
1232 | 1221 | ||
1233 | } | ||
1234 | 1222 | ||
1235 | if ( state.backtracking==0 ) { | ||
1236 | after(grammarAccess.getCaseAccess().getGroup()); | ||
1237 | } | 1223 | } |
1238 | 1224 | ||
1225 | after(grammarAccess.getCaseAccess().getGroup()); | ||
1226 | |||
1239 | } | 1227 | } |
1240 | 1228 | ||
1241 | 1229 | ||
@@ -1257,24 +1245,20 @@ public class InternalSolverLanguageParser extends AbstractInternalContentAssistP | |||
1257 | 1245 | ||
1258 | 1246 | ||
1259 | // $ANTLR start "entryRuleConjunctiveExpression" | 1247 | // $ANTLR start "entryRuleConjunctiveExpression" |
1260 | // InternalSolverLanguage.g:379:1: entryRuleConjunctiveExpression : ruleConjunctiveExpression EOF ; | 1248 | // InternalSolverLanguageParser.g:452:1: entryRuleConjunctiveExpression : ruleConjunctiveExpression EOF ; |
1261 | public final void entryRuleConjunctiveExpression() throws RecognitionException { | 1249 | public final void entryRuleConjunctiveExpression() throws RecognitionException { |
1262 | try { | 1250 | try { |
1263 | // InternalSolverLanguage.g:380:1: ( ruleConjunctiveExpression EOF ) | 1251 | // InternalSolverLanguageParser.g:453:1: ( ruleConjunctiveExpression EOF ) |
1264 | // InternalSolverLanguage.g:381:1: ruleConjunctiveExpression EOF | 1252 | // InternalSolverLanguageParser.g:454:1: ruleConjunctiveExpression EOF |
1265 | { | 1253 | { |
1266 | if ( state.backtracking==0 ) { | 1254 | before(grammarAccess.getConjunctiveExpressionRule()); |
1267 | before(grammarAccess.getConjunctiveExpressionRule()); | ||
1268 | } | ||
1269 | pushFollow(FOLLOW_1); | 1255 | pushFollow(FOLLOW_1); |
1270 | ruleConjunctiveExpression(); | 1256 | ruleConjunctiveExpression(); |
1271 | 1257 | ||
1272 | state._fsp--; | 1258 | state._fsp--; |
1273 | if (state.failed) return ; | 1259 | |
1274 | if ( state.backtracking==0 ) { | 1260 | after(grammarAccess.getConjunctiveExpressionRule()); |
1275 | after(grammarAccess.getConjunctiveExpressionRule()); | 1261 | match(input,EOF,FOLLOW_2); |
1276 | } | ||
1277 | match(input,EOF,FOLLOW_2); if (state.failed) return ; | ||
1278 | 1262 | ||
1279 | } | 1263 | } |
1280 | 1264 | ||
@@ -1291,36 +1275,32 @@ public class InternalSolverLanguageParser extends AbstractInternalContentAssistP | |||
1291 | 1275 | ||
1292 | 1276 | ||
1293 | // $ANTLR start "ruleConjunctiveExpression" | 1277 | // $ANTLR start "ruleConjunctiveExpression" |
1294 | // InternalSolverLanguage.g:388:1: ruleConjunctiveExpression : ( ( rule__ConjunctiveExpression__Group__0 ) ) ; | 1278 | // InternalSolverLanguageParser.g:461:1: ruleConjunctiveExpression : ( ( rule__ConjunctiveExpression__Group__0 ) ) ; |
1295 | public final void ruleConjunctiveExpression() throws RecognitionException { | 1279 | public final void ruleConjunctiveExpression() throws RecognitionException { |
1296 | 1280 | ||
1297 | int stackSize = keepStackSize(); | 1281 | int stackSize = keepStackSize(); |
1298 | 1282 | ||
1299 | try { | 1283 | try { |
1300 | // InternalSolverLanguage.g:392:2: ( ( ( rule__ConjunctiveExpression__Group__0 ) ) ) | 1284 | // InternalSolverLanguageParser.g:465:2: ( ( ( rule__ConjunctiveExpression__Group__0 ) ) ) |
1301 | // InternalSolverLanguage.g:393:2: ( ( rule__ConjunctiveExpression__Group__0 ) ) | 1285 | // InternalSolverLanguageParser.g:466:2: ( ( rule__ConjunctiveExpression__Group__0 ) ) |
1302 | { | 1286 | { |
1303 | // InternalSolverLanguage.g:393:2: ( ( rule__ConjunctiveExpression__Group__0 ) ) | 1287 | // InternalSolverLanguageParser.g:466:2: ( ( rule__ConjunctiveExpression__Group__0 ) ) |
1304 | // InternalSolverLanguage.g:394:3: ( rule__ConjunctiveExpression__Group__0 ) | 1288 | // InternalSolverLanguageParser.g:467:3: ( rule__ConjunctiveExpression__Group__0 ) |
1305 | { | 1289 | { |
1306 | if ( state.backtracking==0 ) { | 1290 | before(grammarAccess.getConjunctiveExpressionAccess().getGroup()); |
1307 | before(grammarAccess.getConjunctiveExpressionAccess().getGroup()); | 1291 | // InternalSolverLanguageParser.g:468:3: ( rule__ConjunctiveExpression__Group__0 ) |
1308 | } | 1292 | // InternalSolverLanguageParser.g:468:4: rule__ConjunctiveExpression__Group__0 |
1309 | // InternalSolverLanguage.g:395:3: ( rule__ConjunctiveExpression__Group__0 ) | ||
1310 | // InternalSolverLanguage.g:395:4: rule__ConjunctiveExpression__Group__0 | ||
1311 | { | 1293 | { |
1312 | pushFollow(FOLLOW_2); | 1294 | pushFollow(FOLLOW_2); |
1313 | rule__ConjunctiveExpression__Group__0(); | 1295 | rule__ConjunctiveExpression__Group__0(); |
1314 | 1296 | ||
1315 | state._fsp--; | 1297 | state._fsp--; |
1316 | if (state.failed) return ; | ||
1317 | 1298 | ||
1318 | } | ||
1319 | 1299 | ||
1320 | if ( state.backtracking==0 ) { | ||
1321 | after(grammarAccess.getConjunctiveExpressionAccess().getGroup()); | ||
1322 | } | 1300 | } |
1323 | 1301 | ||
1302 | after(grammarAccess.getConjunctiveExpressionAccess().getGroup()); | ||
1303 | |||
1324 | } | 1304 | } |
1325 | 1305 | ||
1326 | 1306 | ||
@@ -1342,24 +1322,20 @@ public class InternalSolverLanguageParser extends AbstractInternalContentAssistP | |||
1342 | 1322 | ||
1343 | 1323 | ||
1344 | // $ANTLR start "entryRuleComparisonExpression" | 1324 | // $ANTLR start "entryRuleComparisonExpression" |
1345 | // InternalSolverLanguage.g:404:1: entryRuleComparisonExpression : ruleComparisonExpression EOF ; | 1325 | // InternalSolverLanguageParser.g:477:1: entryRuleComparisonExpression : ruleComparisonExpression EOF ; |
1346 | public final void entryRuleComparisonExpression() throws RecognitionException { | 1326 | public final void entryRuleComparisonExpression() throws RecognitionException { |
1347 | try { | 1327 | try { |
1348 | // InternalSolverLanguage.g:405:1: ( ruleComparisonExpression EOF ) | 1328 | // InternalSolverLanguageParser.g:478:1: ( ruleComparisonExpression EOF ) |
1349 | // InternalSolverLanguage.g:406:1: ruleComparisonExpression EOF | 1329 | // InternalSolverLanguageParser.g:479:1: ruleComparisonExpression EOF |
1350 | { | 1330 | { |
1351 | if ( state.backtracking==0 ) { | 1331 | before(grammarAccess.getComparisonExpressionRule()); |
1352 | before(grammarAccess.getComparisonExpressionRule()); | ||
1353 | } | ||
1354 | pushFollow(FOLLOW_1); | 1332 | pushFollow(FOLLOW_1); |
1355 | ruleComparisonExpression(); | 1333 | ruleComparisonExpression(); |
1356 | 1334 | ||
1357 | state._fsp--; | 1335 | state._fsp--; |
1358 | if (state.failed) return ; | 1336 | |
1359 | if ( state.backtracking==0 ) { | 1337 | after(grammarAccess.getComparisonExpressionRule()); |
1360 | after(grammarAccess.getComparisonExpressionRule()); | 1338 | match(input,EOF,FOLLOW_2); |
1361 | } | ||
1362 | match(input,EOF,FOLLOW_2); if (state.failed) return ; | ||
1363 | 1339 | ||
1364 | } | 1340 | } |
1365 | 1341 | ||
@@ -1376,36 +1352,32 @@ public class InternalSolverLanguageParser extends AbstractInternalContentAssistP | |||
1376 | 1352 | ||
1377 | 1353 | ||
1378 | // $ANTLR start "ruleComparisonExpression" | 1354 | // $ANTLR start "ruleComparisonExpression" |
1379 | // InternalSolverLanguage.g:413:1: ruleComparisonExpression : ( ( rule__ComparisonExpression__Group__0 ) ) ; | 1355 | // InternalSolverLanguageParser.g:486:1: ruleComparisonExpression : ( ( rule__ComparisonExpression__Group__0 ) ) ; |
1380 | public final void ruleComparisonExpression() throws RecognitionException { | 1356 | public final void ruleComparisonExpression() throws RecognitionException { |
1381 | 1357 | ||
1382 | int stackSize = keepStackSize(); | 1358 | int stackSize = keepStackSize(); |
1383 | 1359 | ||
1384 | try { | 1360 | try { |
1385 | // InternalSolverLanguage.g:417:2: ( ( ( rule__ComparisonExpression__Group__0 ) ) ) | 1361 | // InternalSolverLanguageParser.g:490:2: ( ( ( rule__ComparisonExpression__Group__0 ) ) ) |
1386 | // InternalSolverLanguage.g:418:2: ( ( rule__ComparisonExpression__Group__0 ) ) | 1362 | // InternalSolverLanguageParser.g:491:2: ( ( rule__ComparisonExpression__Group__0 ) ) |
1387 | { | 1363 | { |
1388 | // InternalSolverLanguage.g:418:2: ( ( rule__ComparisonExpression__Group__0 ) ) | 1364 | // InternalSolverLanguageParser.g:491:2: ( ( rule__ComparisonExpression__Group__0 ) ) |
1389 | // InternalSolverLanguage.g:419:3: ( rule__ComparisonExpression__Group__0 ) | 1365 | // InternalSolverLanguageParser.g:492:3: ( rule__ComparisonExpression__Group__0 ) |
1390 | { | 1366 | { |
1391 | if ( state.backtracking==0 ) { | 1367 | before(grammarAccess.getComparisonExpressionAccess().getGroup()); |
1392 | before(grammarAccess.getComparisonExpressionAccess().getGroup()); | 1368 | // InternalSolverLanguageParser.g:493:3: ( rule__ComparisonExpression__Group__0 ) |
1393 | } | 1369 | // InternalSolverLanguageParser.g:493:4: rule__ComparisonExpression__Group__0 |
1394 | // InternalSolverLanguage.g:420:3: ( rule__ComparisonExpression__Group__0 ) | ||
1395 | // InternalSolverLanguage.g:420:4: rule__ComparisonExpression__Group__0 | ||
1396 | { | 1370 | { |
1397 | pushFollow(FOLLOW_2); | 1371 | pushFollow(FOLLOW_2); |
1398 | rule__ComparisonExpression__Group__0(); | 1372 | rule__ComparisonExpression__Group__0(); |
1399 | 1373 | ||
1400 | state._fsp--; | 1374 | state._fsp--; |
1401 | if (state.failed) return ; | ||
1402 | 1375 | ||
1403 | } | ||
1404 | 1376 | ||
1405 | if ( state.backtracking==0 ) { | ||
1406 | after(grammarAccess.getComparisonExpressionAccess().getGroup()); | ||
1407 | } | 1377 | } |
1408 | 1378 | ||
1379 | after(grammarAccess.getComparisonExpressionAccess().getGroup()); | ||
1380 | |||
1409 | } | 1381 | } |
1410 | 1382 | ||
1411 | 1383 | ||
@@ -1427,24 +1399,20 @@ public class InternalSolverLanguageParser extends AbstractInternalContentAssistP | |||
1427 | 1399 | ||
1428 | 1400 | ||
1429 | // $ANTLR start "entryRuleAdditiveExpression" | 1401 | // $ANTLR start "entryRuleAdditiveExpression" |
1430 | // InternalSolverLanguage.g:429:1: entryRuleAdditiveExpression : ruleAdditiveExpression EOF ; | 1402 | // InternalSolverLanguageParser.g:502:1: entryRuleAdditiveExpression : ruleAdditiveExpression EOF ; |
1431 | public final void entryRuleAdditiveExpression() throws RecognitionException { | 1403 | public final void entryRuleAdditiveExpression() throws RecognitionException { |
1432 | try { | 1404 | try { |
1433 | // InternalSolverLanguage.g:430:1: ( ruleAdditiveExpression EOF ) | 1405 | // InternalSolverLanguageParser.g:503:1: ( ruleAdditiveExpression EOF ) |
1434 | // InternalSolverLanguage.g:431:1: ruleAdditiveExpression EOF | 1406 | // InternalSolverLanguageParser.g:504:1: ruleAdditiveExpression EOF |
1435 | { | 1407 | { |
1436 | if ( state.backtracking==0 ) { | 1408 | before(grammarAccess.getAdditiveExpressionRule()); |
1437 | before(grammarAccess.getAdditiveExpressionRule()); | ||
1438 | } | ||
1439 | pushFollow(FOLLOW_1); | 1409 | pushFollow(FOLLOW_1); |
1440 | ruleAdditiveExpression(); | 1410 | ruleAdditiveExpression(); |
1441 | 1411 | ||
1442 | state._fsp--; | 1412 | state._fsp--; |
1443 | if (state.failed) return ; | 1413 | |
1444 | if ( state.backtracking==0 ) { | 1414 | after(grammarAccess.getAdditiveExpressionRule()); |
1445 | after(grammarAccess.getAdditiveExpressionRule()); | 1415 | match(input,EOF,FOLLOW_2); |
1446 | } | ||
1447 | match(input,EOF,FOLLOW_2); if (state.failed) return ; | ||
1448 | 1416 | ||
1449 | } | 1417 | } |
1450 | 1418 | ||
@@ -1461,36 +1429,32 @@ public class InternalSolverLanguageParser extends AbstractInternalContentAssistP | |||
1461 | 1429 | ||
1462 | 1430 | ||
1463 | // $ANTLR start "ruleAdditiveExpression" | 1431 | // $ANTLR start "ruleAdditiveExpression" |
1464 | // InternalSolverLanguage.g:438:1: ruleAdditiveExpression : ( ( rule__AdditiveExpression__Group__0 ) ) ; | 1432 | // InternalSolverLanguageParser.g:511:1: ruleAdditiveExpression : ( ( rule__AdditiveExpression__Group__0 ) ) ; |
1465 | public final void ruleAdditiveExpression() throws RecognitionException { | 1433 | public final void ruleAdditiveExpression() throws RecognitionException { |
1466 | 1434 | ||
1467 | int stackSize = keepStackSize(); | 1435 | int stackSize = keepStackSize(); |
1468 | 1436 | ||
1469 | try { | 1437 | try { |
1470 | // InternalSolverLanguage.g:442:2: ( ( ( rule__AdditiveExpression__Group__0 ) ) ) | 1438 | // InternalSolverLanguageParser.g:515:2: ( ( ( rule__AdditiveExpression__Group__0 ) ) ) |
1471 | // InternalSolverLanguage.g:443:2: ( ( rule__AdditiveExpression__Group__0 ) ) | 1439 | // InternalSolverLanguageParser.g:516:2: ( ( rule__AdditiveExpression__Group__0 ) ) |
1472 | { | 1440 | { |
1473 | // InternalSolverLanguage.g:443:2: ( ( rule__AdditiveExpression__Group__0 ) ) | 1441 | // InternalSolverLanguageParser.g:516:2: ( ( rule__AdditiveExpression__Group__0 ) ) |
1474 | // InternalSolverLanguage.g:444:3: ( rule__AdditiveExpression__Group__0 ) | 1442 | // InternalSolverLanguageParser.g:517:3: ( rule__AdditiveExpression__Group__0 ) |
1475 | { | 1443 | { |
1476 | if ( state.backtracking==0 ) { | 1444 | before(grammarAccess.getAdditiveExpressionAccess().getGroup()); |
1477 | before(grammarAccess.getAdditiveExpressionAccess().getGroup()); | 1445 | // InternalSolverLanguageParser.g:518:3: ( rule__AdditiveExpression__Group__0 ) |
1478 | } | 1446 | // InternalSolverLanguageParser.g:518:4: rule__AdditiveExpression__Group__0 |
1479 | // InternalSolverLanguage.g:445:3: ( rule__AdditiveExpression__Group__0 ) | ||
1480 | // InternalSolverLanguage.g:445:4: rule__AdditiveExpression__Group__0 | ||
1481 | { | 1447 | { |
1482 | pushFollow(FOLLOW_2); | 1448 | pushFollow(FOLLOW_2); |
1483 | rule__AdditiveExpression__Group__0(); | 1449 | rule__AdditiveExpression__Group__0(); |
1484 | 1450 | ||
1485 | state._fsp--; | 1451 | state._fsp--; |
1486 | if (state.failed) return ; | ||
1487 | 1452 | ||
1488 | } | ||
1489 | 1453 | ||
1490 | if ( state.backtracking==0 ) { | ||
1491 | after(grammarAccess.getAdditiveExpressionAccess().getGroup()); | ||
1492 | } | 1454 | } |
1493 | 1455 | ||
1456 | after(grammarAccess.getAdditiveExpressionAccess().getGroup()); | ||
1457 | |||
1494 | } | 1458 | } |
1495 | 1459 | ||
1496 | 1460 | ||
@@ -1512,24 +1476,20 @@ public class InternalSolverLanguageParser extends AbstractInternalContentAssistP | |||
1512 | 1476 | ||
1513 | 1477 | ||
1514 | // $ANTLR start "entryRuleMultiplicativeExpression" | 1478 | // $ANTLR start "entryRuleMultiplicativeExpression" |
1515 | // InternalSolverLanguage.g:454:1: entryRuleMultiplicativeExpression : ruleMultiplicativeExpression EOF ; | 1479 | // InternalSolverLanguageParser.g:527:1: entryRuleMultiplicativeExpression : ruleMultiplicativeExpression EOF ; |
1516 | public final void entryRuleMultiplicativeExpression() throws RecognitionException { | 1480 | public final void entryRuleMultiplicativeExpression() throws RecognitionException { |
1517 | try { | 1481 | try { |
1518 | // InternalSolverLanguage.g:455:1: ( ruleMultiplicativeExpression EOF ) | 1482 | // InternalSolverLanguageParser.g:528:1: ( ruleMultiplicativeExpression EOF ) |
1519 | // InternalSolverLanguage.g:456:1: ruleMultiplicativeExpression EOF | 1483 | // InternalSolverLanguageParser.g:529:1: ruleMultiplicativeExpression EOF |
1520 | { | 1484 | { |
1521 | if ( state.backtracking==0 ) { | 1485 | before(grammarAccess.getMultiplicativeExpressionRule()); |
1522 | before(grammarAccess.getMultiplicativeExpressionRule()); | ||
1523 | } | ||
1524 | pushFollow(FOLLOW_1); | 1486 | pushFollow(FOLLOW_1); |
1525 | ruleMultiplicativeExpression(); | 1487 | ruleMultiplicativeExpression(); |
1526 | 1488 | ||
1527 | state._fsp--; | 1489 | state._fsp--; |
1528 | if (state.failed) return ; | 1490 | |
1529 | if ( state.backtracking==0 ) { | 1491 | after(grammarAccess.getMultiplicativeExpressionRule()); |
1530 | after(grammarAccess.getMultiplicativeExpressionRule()); | 1492 | match(input,EOF,FOLLOW_2); |
1531 | } | ||
1532 | match(input,EOF,FOLLOW_2); if (state.failed) return ; | ||
1533 | 1493 | ||
1534 | } | 1494 | } |
1535 | 1495 | ||
@@ -1546,36 +1506,32 @@ public class InternalSolverLanguageParser extends AbstractInternalContentAssistP | |||
1546 | 1506 | ||
1547 | 1507 | ||
1548 | // $ANTLR start "ruleMultiplicativeExpression" | 1508 | // $ANTLR start "ruleMultiplicativeExpression" |
1549 | // InternalSolverLanguage.g:463:1: ruleMultiplicativeExpression : ( ( rule__MultiplicativeExpression__Group__0 ) ) ; | 1509 | // InternalSolverLanguageParser.g:536:1: ruleMultiplicativeExpression : ( ( rule__MultiplicativeExpression__Group__0 ) ) ; |
1550 | public final void ruleMultiplicativeExpression() throws RecognitionException { | 1510 | public final void ruleMultiplicativeExpression() throws RecognitionException { |
1551 | 1511 | ||
1552 | int stackSize = keepStackSize(); | 1512 | int stackSize = keepStackSize(); |
1553 | 1513 | ||
1554 | try { | 1514 | try { |
1555 | // InternalSolverLanguage.g:467:2: ( ( ( rule__MultiplicativeExpression__Group__0 ) ) ) | 1515 | // InternalSolverLanguageParser.g:540:2: ( ( ( rule__MultiplicativeExpression__Group__0 ) ) ) |
1556 | // InternalSolverLanguage.g:468:2: ( ( rule__MultiplicativeExpression__Group__0 ) ) | 1516 | // InternalSolverLanguageParser.g:541:2: ( ( rule__MultiplicativeExpression__Group__0 ) ) |
1557 | { | 1517 | { |
1558 | // InternalSolverLanguage.g:468:2: ( ( rule__MultiplicativeExpression__Group__0 ) ) | 1518 | // InternalSolverLanguageParser.g:541:2: ( ( rule__MultiplicativeExpression__Group__0 ) ) |
1559 | // InternalSolverLanguage.g:469:3: ( rule__MultiplicativeExpression__Group__0 ) | 1519 | // InternalSolverLanguageParser.g:542:3: ( rule__MultiplicativeExpression__Group__0 ) |
1560 | { | 1520 | { |
1561 | if ( state.backtracking==0 ) { | 1521 | before(grammarAccess.getMultiplicativeExpressionAccess().getGroup()); |
1562 | before(grammarAccess.getMultiplicativeExpressionAccess().getGroup()); | 1522 | // InternalSolverLanguageParser.g:543:3: ( rule__MultiplicativeExpression__Group__0 ) |
1563 | } | 1523 | // InternalSolverLanguageParser.g:543:4: rule__MultiplicativeExpression__Group__0 |
1564 | // InternalSolverLanguage.g:470:3: ( rule__MultiplicativeExpression__Group__0 ) | ||
1565 | // InternalSolverLanguage.g:470:4: rule__MultiplicativeExpression__Group__0 | ||
1566 | { | 1524 | { |
1567 | pushFollow(FOLLOW_2); | 1525 | pushFollow(FOLLOW_2); |
1568 | rule__MultiplicativeExpression__Group__0(); | 1526 | rule__MultiplicativeExpression__Group__0(); |
1569 | 1527 | ||
1570 | state._fsp--; | 1528 | state._fsp--; |
1571 | if (state.failed) return ; | ||
1572 | 1529 | ||
1573 | } | ||
1574 | 1530 | ||
1575 | if ( state.backtracking==0 ) { | ||
1576 | after(grammarAccess.getMultiplicativeExpressionAccess().getGroup()); | ||
1577 | } | 1531 | } |
1578 | 1532 | ||
1533 | after(grammarAccess.getMultiplicativeExpressionAccess().getGroup()); | ||
1534 | |||
1579 | } | 1535 | } |
1580 | 1536 | ||
1581 | 1537 | ||
@@ -1597,24 +1553,20 @@ public class InternalSolverLanguageParser extends AbstractInternalContentAssistP | |||
1597 | 1553 | ||
1598 | 1554 | ||
1599 | // $ANTLR start "entryRuleExponentialExpression" | 1555 | // $ANTLR start "entryRuleExponentialExpression" |
1600 | // InternalSolverLanguage.g:479:1: entryRuleExponentialExpression : ruleExponentialExpression EOF ; | 1556 | // InternalSolverLanguageParser.g:552:1: entryRuleExponentialExpression : ruleExponentialExpression EOF ; |
1601 | public final void entryRuleExponentialExpression() throws RecognitionException { | 1557 | public final void entryRuleExponentialExpression() throws RecognitionException { |
1602 | try { | 1558 | try { |
1603 | // InternalSolverLanguage.g:480:1: ( ruleExponentialExpression EOF ) | 1559 | // InternalSolverLanguageParser.g:553:1: ( ruleExponentialExpression EOF ) |
1604 | // InternalSolverLanguage.g:481:1: ruleExponentialExpression EOF | 1560 | // InternalSolverLanguageParser.g:554:1: ruleExponentialExpression EOF |
1605 | { | 1561 | { |
1606 | if ( state.backtracking==0 ) { | 1562 | before(grammarAccess.getExponentialExpressionRule()); |
1607 | before(grammarAccess.getExponentialExpressionRule()); | ||
1608 | } | ||
1609 | pushFollow(FOLLOW_1); | 1563 | pushFollow(FOLLOW_1); |
1610 | ruleExponentialExpression(); | 1564 | ruleExponentialExpression(); |
1611 | 1565 | ||
1612 | state._fsp--; | 1566 | state._fsp--; |
1613 | if (state.failed) return ; | 1567 | |
1614 | if ( state.backtracking==0 ) { | 1568 | after(grammarAccess.getExponentialExpressionRule()); |
1615 | after(grammarAccess.getExponentialExpressionRule()); | 1569 | match(input,EOF,FOLLOW_2); |
1616 | } | ||
1617 | match(input,EOF,FOLLOW_2); if (state.failed) return ; | ||
1618 | 1570 | ||
1619 | } | 1571 | } |
1620 | 1572 | ||
@@ -1631,36 +1583,32 @@ public class InternalSolverLanguageParser extends AbstractInternalContentAssistP | |||
1631 | 1583 | ||
1632 | 1584 | ||
1633 | // $ANTLR start "ruleExponentialExpression" | 1585 | // $ANTLR start "ruleExponentialExpression" |
1634 | // InternalSolverLanguage.g:488:1: ruleExponentialExpression : ( ( rule__ExponentialExpression__Group__0 ) ) ; | 1586 | // InternalSolverLanguageParser.g:561:1: ruleExponentialExpression : ( ( rule__ExponentialExpression__Group__0 ) ) ; |
1635 | public final void ruleExponentialExpression() throws RecognitionException { | 1587 | public final void ruleExponentialExpression() throws RecognitionException { |
1636 | 1588 | ||
1637 | int stackSize = keepStackSize(); | 1589 | int stackSize = keepStackSize(); |
1638 | 1590 | ||
1639 | try { | 1591 | try { |
1640 | // InternalSolverLanguage.g:492:2: ( ( ( rule__ExponentialExpression__Group__0 ) ) ) | 1592 | // InternalSolverLanguageParser.g:565:2: ( ( ( rule__ExponentialExpression__Group__0 ) ) ) |
1641 | // InternalSolverLanguage.g:493:2: ( ( rule__ExponentialExpression__Group__0 ) ) | 1593 | // InternalSolverLanguageParser.g:566:2: ( ( rule__ExponentialExpression__Group__0 ) ) |
1642 | { | 1594 | { |
1643 | // InternalSolverLanguage.g:493:2: ( ( rule__ExponentialExpression__Group__0 ) ) | 1595 | // InternalSolverLanguageParser.g:566:2: ( ( rule__ExponentialExpression__Group__0 ) ) |
1644 | // InternalSolverLanguage.g:494:3: ( rule__ExponentialExpression__Group__0 ) | 1596 | // InternalSolverLanguageParser.g:567:3: ( rule__ExponentialExpression__Group__0 ) |
1645 | { | 1597 | { |
1646 | if ( state.backtracking==0 ) { | 1598 | before(grammarAccess.getExponentialExpressionAccess().getGroup()); |
1647 | before(grammarAccess.getExponentialExpressionAccess().getGroup()); | 1599 | // InternalSolverLanguageParser.g:568:3: ( rule__ExponentialExpression__Group__0 ) |
1648 | } | 1600 | // InternalSolverLanguageParser.g:568:4: rule__ExponentialExpression__Group__0 |
1649 | // InternalSolverLanguage.g:495:3: ( rule__ExponentialExpression__Group__0 ) | ||
1650 | // InternalSolverLanguage.g:495:4: rule__ExponentialExpression__Group__0 | ||
1651 | { | 1601 | { |
1652 | pushFollow(FOLLOW_2); | 1602 | pushFollow(FOLLOW_2); |
1653 | rule__ExponentialExpression__Group__0(); | 1603 | rule__ExponentialExpression__Group__0(); |
1654 | 1604 | ||
1655 | state._fsp--; | 1605 | state._fsp--; |
1656 | if (state.failed) return ; | ||
1657 | 1606 | ||
1658 | } | ||
1659 | 1607 | ||
1660 | if ( state.backtracking==0 ) { | ||
1661 | after(grammarAccess.getExponentialExpressionAccess().getGroup()); | ||
1662 | } | 1608 | } |
1663 | 1609 | ||
1610 | after(grammarAccess.getExponentialExpressionAccess().getGroup()); | ||
1611 | |||
1664 | } | 1612 | } |
1665 | 1613 | ||
1666 | 1614 | ||
@@ -1682,24 +1630,20 @@ public class InternalSolverLanguageParser extends AbstractInternalContentAssistP | |||
1682 | 1630 | ||
1683 | 1631 | ||
1684 | // $ANTLR start "entryRuleUnaryExpression" | 1632 | // $ANTLR start "entryRuleUnaryExpression" |
1685 | // InternalSolverLanguage.g:504:1: entryRuleUnaryExpression : ruleUnaryExpression EOF ; | 1633 | // InternalSolverLanguageParser.g:577:1: entryRuleUnaryExpression : ruleUnaryExpression EOF ; |
1686 | public final void entryRuleUnaryExpression() throws RecognitionException { | 1634 | public final void entryRuleUnaryExpression() throws RecognitionException { |
1687 | try { | 1635 | try { |
1688 | // InternalSolverLanguage.g:505:1: ( ruleUnaryExpression EOF ) | 1636 | // InternalSolverLanguageParser.g:578:1: ( ruleUnaryExpression EOF ) |
1689 | // InternalSolverLanguage.g:506:1: ruleUnaryExpression EOF | 1637 | // InternalSolverLanguageParser.g:579:1: ruleUnaryExpression EOF |
1690 | { | 1638 | { |
1691 | if ( state.backtracking==0 ) { | 1639 | before(grammarAccess.getUnaryExpressionRule()); |
1692 | before(grammarAccess.getUnaryExpressionRule()); | ||
1693 | } | ||
1694 | pushFollow(FOLLOW_1); | 1640 | pushFollow(FOLLOW_1); |
1695 | ruleUnaryExpression(); | 1641 | ruleUnaryExpression(); |
1696 | 1642 | ||
1697 | state._fsp--; | 1643 | state._fsp--; |
1698 | if (state.failed) return ; | 1644 | |
1699 | if ( state.backtracking==0 ) { | 1645 | after(grammarAccess.getUnaryExpressionRule()); |
1700 | after(grammarAccess.getUnaryExpressionRule()); | 1646 | match(input,EOF,FOLLOW_2); |
1701 | } | ||
1702 | match(input,EOF,FOLLOW_2); if (state.failed) return ; | ||
1703 | 1647 | ||
1704 | } | 1648 | } |
1705 | 1649 | ||
@@ -1716,36 +1660,32 @@ public class InternalSolverLanguageParser extends AbstractInternalContentAssistP | |||
1716 | 1660 | ||
1717 | 1661 | ||
1718 | // $ANTLR start "ruleUnaryExpression" | 1662 | // $ANTLR start "ruleUnaryExpression" |
1719 | // InternalSolverLanguage.g:513:1: ruleUnaryExpression : ( ( rule__UnaryExpression__Alternatives ) ) ; | 1663 | // InternalSolverLanguageParser.g:586:1: ruleUnaryExpression : ( ( rule__UnaryExpression__Alternatives ) ) ; |
1720 | public final void ruleUnaryExpression() throws RecognitionException { | 1664 | public final void ruleUnaryExpression() throws RecognitionException { |
1721 | 1665 | ||
1722 | int stackSize = keepStackSize(); | 1666 | int stackSize = keepStackSize(); |
1723 | 1667 | ||
1724 | try { | 1668 | try { |
1725 | // InternalSolverLanguage.g:517:2: ( ( ( rule__UnaryExpression__Alternatives ) ) ) | 1669 | // InternalSolverLanguageParser.g:590:2: ( ( ( rule__UnaryExpression__Alternatives ) ) ) |
1726 | // InternalSolverLanguage.g:518:2: ( ( rule__UnaryExpression__Alternatives ) ) | 1670 | // InternalSolverLanguageParser.g:591:2: ( ( rule__UnaryExpression__Alternatives ) ) |
1727 | { | 1671 | { |
1728 | // InternalSolverLanguage.g:518:2: ( ( rule__UnaryExpression__Alternatives ) ) | 1672 | // InternalSolverLanguageParser.g:591:2: ( ( rule__UnaryExpression__Alternatives ) ) |
1729 | // InternalSolverLanguage.g:519:3: ( rule__UnaryExpression__Alternatives ) | 1673 | // InternalSolverLanguageParser.g:592:3: ( rule__UnaryExpression__Alternatives ) |
1730 | { | 1674 | { |
1731 | if ( state.backtracking==0 ) { | 1675 | before(grammarAccess.getUnaryExpressionAccess().getAlternatives()); |
1732 | before(grammarAccess.getUnaryExpressionAccess().getAlternatives()); | 1676 | // InternalSolverLanguageParser.g:593:3: ( rule__UnaryExpression__Alternatives ) |
1733 | } | 1677 | // InternalSolverLanguageParser.g:593:4: rule__UnaryExpression__Alternatives |
1734 | // InternalSolverLanguage.g:520:3: ( rule__UnaryExpression__Alternatives ) | ||
1735 | // InternalSolverLanguage.g:520:4: rule__UnaryExpression__Alternatives | ||
1736 | { | 1678 | { |
1737 | pushFollow(FOLLOW_2); | 1679 | pushFollow(FOLLOW_2); |
1738 | rule__UnaryExpression__Alternatives(); | 1680 | rule__UnaryExpression__Alternatives(); |
1739 | 1681 | ||
1740 | state._fsp--; | 1682 | state._fsp--; |
1741 | if (state.failed) return ; | ||
1742 | 1683 | ||
1743 | } | ||
1744 | 1684 | ||
1745 | if ( state.backtracking==0 ) { | ||
1746 | after(grammarAccess.getUnaryExpressionAccess().getAlternatives()); | ||
1747 | } | 1685 | } |
1748 | 1686 | ||
1687 | after(grammarAccess.getUnaryExpressionAccess().getAlternatives()); | ||
1688 | |||
1749 | } | 1689 | } |
1750 | 1690 | ||
1751 | 1691 | ||
@@ -1767,24 +1707,20 @@ public class InternalSolverLanguageParser extends AbstractInternalContentAssistP | |||
1767 | 1707 | ||
1768 | 1708 | ||
1769 | // $ANTLR start "entryRuleAggregationExpression" | 1709 | // $ANTLR start "entryRuleAggregationExpression" |
1770 | // InternalSolverLanguage.g:529:1: entryRuleAggregationExpression : ruleAggregationExpression EOF ; | 1710 | // InternalSolverLanguageParser.g:602:1: entryRuleAggregationExpression : ruleAggregationExpression EOF ; |
1771 | public final void entryRuleAggregationExpression() throws RecognitionException { | 1711 | public final void entryRuleAggregationExpression() throws RecognitionException { |
1772 | try { | 1712 | try { |
1773 | // InternalSolverLanguage.g:530:1: ( ruleAggregationExpression EOF ) | 1713 | // InternalSolverLanguageParser.g:603:1: ( ruleAggregationExpression EOF ) |
1774 | // InternalSolverLanguage.g:531:1: ruleAggregationExpression EOF | 1714 | // InternalSolverLanguageParser.g:604:1: ruleAggregationExpression EOF |
1775 | { | 1715 | { |
1776 | if ( state.backtracking==0 ) { | 1716 | before(grammarAccess.getAggregationExpressionRule()); |
1777 | before(grammarAccess.getAggregationExpressionRule()); | ||
1778 | } | ||
1779 | pushFollow(FOLLOW_1); | 1717 | pushFollow(FOLLOW_1); |
1780 | ruleAggregationExpression(); | 1718 | ruleAggregationExpression(); |
1781 | 1719 | ||
1782 | state._fsp--; | 1720 | state._fsp--; |
1783 | if (state.failed) return ; | 1721 | |
1784 | if ( state.backtracking==0 ) { | 1722 | after(grammarAccess.getAggregationExpressionRule()); |
1785 | after(grammarAccess.getAggregationExpressionRule()); | 1723 | match(input,EOF,FOLLOW_2); |
1786 | } | ||
1787 | match(input,EOF,FOLLOW_2); if (state.failed) return ; | ||
1788 | 1724 | ||
1789 | } | 1725 | } |
1790 | 1726 | ||
@@ -1801,36 +1737,32 @@ public class InternalSolverLanguageParser extends AbstractInternalContentAssistP | |||
1801 | 1737 | ||
1802 | 1738 | ||
1803 | // $ANTLR start "ruleAggregationExpression" | 1739 | // $ANTLR start "ruleAggregationExpression" |
1804 | // InternalSolverLanguage.g:538:1: ruleAggregationExpression : ( ( rule__AggregationExpression__Alternatives ) ) ; | 1740 | // InternalSolverLanguageParser.g:611:1: ruleAggregationExpression : ( ( rule__AggregationExpression__Alternatives ) ) ; |
1805 | public final void ruleAggregationExpression() throws RecognitionException { | 1741 | public final void ruleAggregationExpression() throws RecognitionException { |
1806 | 1742 | ||
1807 | int stackSize = keepStackSize(); | 1743 | int stackSize = keepStackSize(); |
1808 | 1744 | ||
1809 | try { | 1745 | try { |
1810 | // InternalSolverLanguage.g:542:2: ( ( ( rule__AggregationExpression__Alternatives ) ) ) | 1746 | // InternalSolverLanguageParser.g:615:2: ( ( ( rule__AggregationExpression__Alternatives ) ) ) |
1811 | // InternalSolverLanguage.g:543:2: ( ( rule__AggregationExpression__Alternatives ) ) | 1747 | // InternalSolverLanguageParser.g:616:2: ( ( rule__AggregationExpression__Alternatives ) ) |
1812 | { | 1748 | { |
1813 | // InternalSolverLanguage.g:543:2: ( ( rule__AggregationExpression__Alternatives ) ) | 1749 | // InternalSolverLanguageParser.g:616:2: ( ( rule__AggregationExpression__Alternatives ) ) |
1814 | // InternalSolverLanguage.g:544:3: ( rule__AggregationExpression__Alternatives ) | 1750 | // InternalSolverLanguageParser.g:617:3: ( rule__AggregationExpression__Alternatives ) |
1815 | { | 1751 | { |
1816 | if ( state.backtracking==0 ) { | 1752 | before(grammarAccess.getAggregationExpressionAccess().getAlternatives()); |
1817 | before(grammarAccess.getAggregationExpressionAccess().getAlternatives()); | 1753 | // InternalSolverLanguageParser.g:618:3: ( rule__AggregationExpression__Alternatives ) |
1818 | } | 1754 | // InternalSolverLanguageParser.g:618:4: rule__AggregationExpression__Alternatives |
1819 | // InternalSolverLanguage.g:545:3: ( rule__AggregationExpression__Alternatives ) | ||
1820 | // InternalSolverLanguage.g:545:4: rule__AggregationExpression__Alternatives | ||
1821 | { | 1755 | { |
1822 | pushFollow(FOLLOW_2); | 1756 | pushFollow(FOLLOW_2); |
1823 | rule__AggregationExpression__Alternatives(); | 1757 | rule__AggregationExpression__Alternatives(); |
1824 | 1758 | ||
1825 | state._fsp--; | 1759 | state._fsp--; |
1826 | if (state.failed) return ; | ||
1827 | 1760 | ||
1828 | } | ||
1829 | 1761 | ||
1830 | if ( state.backtracking==0 ) { | ||
1831 | after(grammarAccess.getAggregationExpressionAccess().getAlternatives()); | ||
1832 | } | 1762 | } |
1833 | 1763 | ||
1764 | after(grammarAccess.getAggregationExpressionAccess().getAlternatives()); | ||
1765 | |||
1834 | } | 1766 | } |
1835 | 1767 | ||
1836 | 1768 | ||
@@ -1852,24 +1784,20 @@ public class InternalSolverLanguageParser extends AbstractInternalContentAssistP | |||
1852 | 1784 | ||
1853 | 1785 | ||
1854 | // $ANTLR start "entryRuleCount" | 1786 | // $ANTLR start "entryRuleCount" |
1855 | // InternalSolverLanguage.g:554:1: entryRuleCount : ruleCount EOF ; | 1787 | // InternalSolverLanguageParser.g:627:1: entryRuleCount : ruleCount EOF ; |
1856 | public final void entryRuleCount() throws RecognitionException { | 1788 | public final void entryRuleCount() throws RecognitionException { |
1857 | try { | 1789 | try { |
1858 | // InternalSolverLanguage.g:555:1: ( ruleCount EOF ) | 1790 | // InternalSolverLanguageParser.g:628:1: ( ruleCount EOF ) |
1859 | // InternalSolverLanguage.g:556:1: ruleCount EOF | 1791 | // InternalSolverLanguageParser.g:629:1: ruleCount EOF |
1860 | { | 1792 | { |
1861 | if ( state.backtracking==0 ) { | 1793 | before(grammarAccess.getCountRule()); |
1862 | before(grammarAccess.getCountRule()); | ||
1863 | } | ||
1864 | pushFollow(FOLLOW_1); | 1794 | pushFollow(FOLLOW_1); |
1865 | ruleCount(); | 1795 | ruleCount(); |
1866 | 1796 | ||
1867 | state._fsp--; | 1797 | state._fsp--; |
1868 | if (state.failed) return ; | 1798 | |
1869 | if ( state.backtracking==0 ) { | 1799 | after(grammarAccess.getCountRule()); |
1870 | after(grammarAccess.getCountRule()); | 1800 | match(input,EOF,FOLLOW_2); |
1871 | } | ||
1872 | match(input,EOF,FOLLOW_2); if (state.failed) return ; | ||
1873 | 1801 | ||
1874 | } | 1802 | } |
1875 | 1803 | ||
@@ -1886,36 +1814,32 @@ public class InternalSolverLanguageParser extends AbstractInternalContentAssistP | |||
1886 | 1814 | ||
1887 | 1815 | ||
1888 | // $ANTLR start "ruleCount" | 1816 | // $ANTLR start "ruleCount" |
1889 | // InternalSolverLanguage.g:563:1: ruleCount : ( ( rule__Count__Group__0 ) ) ; | 1817 | // InternalSolverLanguageParser.g:636:1: ruleCount : ( ( rule__Count__Group__0 ) ) ; |
1890 | public final void ruleCount() throws RecognitionException { | 1818 | public final void ruleCount() throws RecognitionException { |
1891 | 1819 | ||
1892 | int stackSize = keepStackSize(); | 1820 | int stackSize = keepStackSize(); |
1893 | 1821 | ||
1894 | try { | 1822 | try { |
1895 | // InternalSolverLanguage.g:567:2: ( ( ( rule__Count__Group__0 ) ) ) | 1823 | // InternalSolverLanguageParser.g:640:2: ( ( ( rule__Count__Group__0 ) ) ) |
1896 | // InternalSolverLanguage.g:568:2: ( ( rule__Count__Group__0 ) ) | 1824 | // InternalSolverLanguageParser.g:641:2: ( ( rule__Count__Group__0 ) ) |
1897 | { | 1825 | { |
1898 | // InternalSolverLanguage.g:568:2: ( ( rule__Count__Group__0 ) ) | 1826 | // InternalSolverLanguageParser.g:641:2: ( ( rule__Count__Group__0 ) ) |
1899 | // InternalSolverLanguage.g:569:3: ( rule__Count__Group__0 ) | 1827 | // InternalSolverLanguageParser.g:642:3: ( rule__Count__Group__0 ) |
1900 | { | 1828 | { |
1901 | if ( state.backtracking==0 ) { | 1829 | before(grammarAccess.getCountAccess().getGroup()); |
1902 | before(grammarAccess.getCountAccess().getGroup()); | 1830 | // InternalSolverLanguageParser.g:643:3: ( rule__Count__Group__0 ) |
1903 | } | 1831 | // InternalSolverLanguageParser.g:643:4: rule__Count__Group__0 |
1904 | // InternalSolverLanguage.g:570:3: ( rule__Count__Group__0 ) | ||
1905 | // InternalSolverLanguage.g:570:4: rule__Count__Group__0 | ||
1906 | { | 1832 | { |
1907 | pushFollow(FOLLOW_2); | 1833 | pushFollow(FOLLOW_2); |
1908 | rule__Count__Group__0(); | 1834 | rule__Count__Group__0(); |
1909 | 1835 | ||
1910 | state._fsp--; | 1836 | state._fsp--; |
1911 | if (state.failed) return ; | ||
1912 | 1837 | ||
1913 | } | ||
1914 | 1838 | ||
1915 | if ( state.backtracking==0 ) { | ||
1916 | after(grammarAccess.getCountAccess().getGroup()); | ||
1917 | } | 1839 | } |
1918 | 1840 | ||
1841 | after(grammarAccess.getCountAccess().getGroup()); | ||
1842 | |||
1919 | } | 1843 | } |
1920 | 1844 | ||
1921 | 1845 | ||
@@ -1937,24 +1861,20 @@ public class InternalSolverLanguageParser extends AbstractInternalContentAssistP | |||
1937 | 1861 | ||
1938 | 1862 | ||
1939 | // $ANTLR start "entryRuleAggregation" | 1863 | // $ANTLR start "entryRuleAggregation" |
1940 | // InternalSolverLanguage.g:579:1: entryRuleAggregation : ruleAggregation EOF ; | 1864 | // InternalSolverLanguageParser.g:652:1: entryRuleAggregation : ruleAggregation EOF ; |
1941 | public final void entryRuleAggregation() throws RecognitionException { | 1865 | public final void entryRuleAggregation() throws RecognitionException { |
1942 | try { | 1866 | try { |
1943 | // InternalSolverLanguage.g:580:1: ( ruleAggregation EOF ) | 1867 | // InternalSolverLanguageParser.g:653:1: ( ruleAggregation EOF ) |
1944 | // InternalSolverLanguage.g:581:1: ruleAggregation EOF | 1868 | // InternalSolverLanguageParser.g:654:1: ruleAggregation EOF |
1945 | { | 1869 | { |
1946 | if ( state.backtracking==0 ) { | 1870 | before(grammarAccess.getAggregationRule()); |
1947 | before(grammarAccess.getAggregationRule()); | ||
1948 | } | ||
1949 | pushFollow(FOLLOW_1); | 1871 | pushFollow(FOLLOW_1); |
1950 | ruleAggregation(); | 1872 | ruleAggregation(); |
1951 | 1873 | ||
1952 | state._fsp--; | 1874 | state._fsp--; |
1953 | if (state.failed) return ; | 1875 | |
1954 | if ( state.backtracking==0 ) { | 1876 | after(grammarAccess.getAggregationRule()); |
1955 | after(grammarAccess.getAggregationRule()); | 1877 | match(input,EOF,FOLLOW_2); |
1956 | } | ||
1957 | match(input,EOF,FOLLOW_2); if (state.failed) return ; | ||
1958 | 1878 | ||
1959 | } | 1879 | } |
1960 | 1880 | ||
@@ -1971,36 +1891,32 @@ public class InternalSolverLanguageParser extends AbstractInternalContentAssistP | |||
1971 | 1891 | ||
1972 | 1892 | ||
1973 | // $ANTLR start "ruleAggregation" | 1893 | // $ANTLR start "ruleAggregation" |
1974 | // InternalSolverLanguage.g:588:1: ruleAggregation : ( ( rule__Aggregation__Group__0 ) ) ; | 1894 | // InternalSolverLanguageParser.g:661:1: ruleAggregation : ( ( rule__Aggregation__Group__0 ) ) ; |
1975 | public final void ruleAggregation() throws RecognitionException { | 1895 | public final void ruleAggregation() throws RecognitionException { |
1976 | 1896 | ||
1977 | int stackSize = keepStackSize(); | 1897 | int stackSize = keepStackSize(); |
1978 | 1898 | ||
1979 | try { | 1899 | try { |
1980 | // InternalSolverLanguage.g:592:2: ( ( ( rule__Aggregation__Group__0 ) ) ) | 1900 | // InternalSolverLanguageParser.g:665:2: ( ( ( rule__Aggregation__Group__0 ) ) ) |
1981 | // InternalSolverLanguage.g:593:2: ( ( rule__Aggregation__Group__0 ) ) | 1901 | // InternalSolverLanguageParser.g:666:2: ( ( rule__Aggregation__Group__0 ) ) |
1982 | { | 1902 | { |
1983 | // InternalSolverLanguage.g:593:2: ( ( rule__Aggregation__Group__0 ) ) | 1903 | // InternalSolverLanguageParser.g:666:2: ( ( rule__Aggregation__Group__0 ) ) |
1984 | // InternalSolverLanguage.g:594:3: ( rule__Aggregation__Group__0 ) | 1904 | // InternalSolverLanguageParser.g:667:3: ( rule__Aggregation__Group__0 ) |
1985 | { | 1905 | { |
1986 | if ( state.backtracking==0 ) { | 1906 | before(grammarAccess.getAggregationAccess().getGroup()); |
1987 | before(grammarAccess.getAggregationAccess().getGroup()); | 1907 | // InternalSolverLanguageParser.g:668:3: ( rule__Aggregation__Group__0 ) |
1988 | } | 1908 | // InternalSolverLanguageParser.g:668:4: rule__Aggregation__Group__0 |
1989 | // InternalSolverLanguage.g:595:3: ( rule__Aggregation__Group__0 ) | ||
1990 | // InternalSolverLanguage.g:595:4: rule__Aggregation__Group__0 | ||
1991 | { | 1909 | { |
1992 | pushFollow(FOLLOW_2); | 1910 | pushFollow(FOLLOW_2); |
1993 | rule__Aggregation__Group__0(); | 1911 | rule__Aggregation__Group__0(); |
1994 | 1912 | ||
1995 | state._fsp--; | 1913 | state._fsp--; |
1996 | if (state.failed) return ; | ||
1997 | 1914 | ||
1998 | } | ||
1999 | 1915 | ||
2000 | if ( state.backtracking==0 ) { | ||
2001 | after(grammarAccess.getAggregationAccess().getGroup()); | ||
2002 | } | 1916 | } |
2003 | 1917 | ||
1918 | after(grammarAccess.getAggregationAccess().getGroup()); | ||
1919 | |||
2004 | } | 1920 | } |
2005 | 1921 | ||
2006 | 1922 | ||
@@ -2022,24 +1938,20 @@ public class InternalSolverLanguageParser extends AbstractInternalContentAssistP | |||
2022 | 1938 | ||
2023 | 1939 | ||
2024 | // $ANTLR start "entryRuleAtomicExpression" | 1940 | // $ANTLR start "entryRuleAtomicExpression" |
2025 | // InternalSolverLanguage.g:604:1: entryRuleAtomicExpression : ruleAtomicExpression EOF ; | 1941 | // InternalSolverLanguageParser.g:677:1: entryRuleAtomicExpression : ruleAtomicExpression EOF ; |
2026 | public final void entryRuleAtomicExpression() throws RecognitionException { | 1942 | public final void entryRuleAtomicExpression() throws RecognitionException { |
2027 | try { | 1943 | try { |
2028 | // InternalSolverLanguage.g:605:1: ( ruleAtomicExpression EOF ) | 1944 | // InternalSolverLanguageParser.g:678:1: ( ruleAtomicExpression EOF ) |
2029 | // InternalSolverLanguage.g:606:1: ruleAtomicExpression EOF | 1945 | // InternalSolverLanguageParser.g:679:1: ruleAtomicExpression EOF |
2030 | { | 1946 | { |
2031 | if ( state.backtracking==0 ) { | 1947 | before(grammarAccess.getAtomicExpressionRule()); |
2032 | before(grammarAccess.getAtomicExpressionRule()); | ||
2033 | } | ||
2034 | pushFollow(FOLLOW_1); | 1948 | pushFollow(FOLLOW_1); |
2035 | ruleAtomicExpression(); | 1949 | ruleAtomicExpression(); |
2036 | 1950 | ||
2037 | state._fsp--; | 1951 | state._fsp--; |
2038 | if (state.failed) return ; | 1952 | |
2039 | if ( state.backtracking==0 ) { | 1953 | after(grammarAccess.getAtomicExpressionRule()); |
2040 | after(grammarAccess.getAtomicExpressionRule()); | 1954 | match(input,EOF,FOLLOW_2); |
2041 | } | ||
2042 | match(input,EOF,FOLLOW_2); if (state.failed) return ; | ||
2043 | 1955 | ||
2044 | } | 1956 | } |
2045 | 1957 | ||
@@ -2056,36 +1968,32 @@ public class InternalSolverLanguageParser extends AbstractInternalContentAssistP | |||
2056 | 1968 | ||
2057 | 1969 | ||
2058 | // $ANTLR start "ruleAtomicExpression" | 1970 | // $ANTLR start "ruleAtomicExpression" |
2059 | // InternalSolverLanguage.g:613:1: ruleAtomicExpression : ( ( rule__AtomicExpression__Alternatives ) ) ; | 1971 | // InternalSolverLanguageParser.g:686:1: ruleAtomicExpression : ( ( rule__AtomicExpression__Alternatives ) ) ; |
2060 | public final void ruleAtomicExpression() throws RecognitionException { | 1972 | public final void ruleAtomicExpression() throws RecognitionException { |
2061 | 1973 | ||
2062 | int stackSize = keepStackSize(); | 1974 | int stackSize = keepStackSize(); |
2063 | 1975 | ||
2064 | try { | 1976 | try { |
2065 | // InternalSolverLanguage.g:617:2: ( ( ( rule__AtomicExpression__Alternatives ) ) ) | 1977 | // InternalSolverLanguageParser.g:690:2: ( ( ( rule__AtomicExpression__Alternatives ) ) ) |
2066 | // InternalSolverLanguage.g:618:2: ( ( rule__AtomicExpression__Alternatives ) ) | 1978 | // InternalSolverLanguageParser.g:691:2: ( ( rule__AtomicExpression__Alternatives ) ) |
2067 | { | 1979 | { |
2068 | // InternalSolverLanguage.g:618:2: ( ( rule__AtomicExpression__Alternatives ) ) | 1980 | // InternalSolverLanguageParser.g:691:2: ( ( rule__AtomicExpression__Alternatives ) ) |
2069 | // InternalSolverLanguage.g:619:3: ( rule__AtomicExpression__Alternatives ) | 1981 | // InternalSolverLanguageParser.g:692:3: ( rule__AtomicExpression__Alternatives ) |
2070 | { | 1982 | { |
2071 | if ( state.backtracking==0 ) { | 1983 | before(grammarAccess.getAtomicExpressionAccess().getAlternatives()); |
2072 | before(grammarAccess.getAtomicExpressionAccess().getAlternatives()); | 1984 | // InternalSolverLanguageParser.g:693:3: ( rule__AtomicExpression__Alternatives ) |
2073 | } | 1985 | // InternalSolverLanguageParser.g:693:4: rule__AtomicExpression__Alternatives |
2074 | // InternalSolverLanguage.g:620:3: ( rule__AtomicExpression__Alternatives ) | ||
2075 | // InternalSolverLanguage.g:620:4: rule__AtomicExpression__Alternatives | ||
2076 | { | 1986 | { |
2077 | pushFollow(FOLLOW_2); | 1987 | pushFollow(FOLLOW_2); |
2078 | rule__AtomicExpression__Alternatives(); | 1988 | rule__AtomicExpression__Alternatives(); |
2079 | 1989 | ||
2080 | state._fsp--; | 1990 | state._fsp--; |
2081 | if (state.failed) return ; | ||
2082 | 1991 | ||
2083 | } | ||
2084 | 1992 | ||
2085 | if ( state.backtracking==0 ) { | ||
2086 | after(grammarAccess.getAtomicExpressionAccess().getAlternatives()); | ||
2087 | } | 1993 | } |
2088 | 1994 | ||
1995 | after(grammarAccess.getAtomicExpressionAccess().getAlternatives()); | ||
1996 | |||
2089 | } | 1997 | } |
2090 | 1998 | ||
2091 | 1999 | ||
@@ -2107,24 +2015,20 @@ public class InternalSolverLanguageParser extends AbstractInternalContentAssistP | |||
2107 | 2015 | ||
2108 | 2016 | ||
2109 | // $ANTLR start "entryRuleCall" | 2017 | // $ANTLR start "entryRuleCall" |
2110 | // InternalSolverLanguage.g:629:1: entryRuleCall : ruleCall EOF ; | 2018 | // InternalSolverLanguageParser.g:702:1: entryRuleCall : ruleCall EOF ; |
2111 | public final void entryRuleCall() throws RecognitionException { | 2019 | public final void entryRuleCall() throws RecognitionException { |
2112 | try { | 2020 | try { |
2113 | // InternalSolverLanguage.g:630:1: ( ruleCall EOF ) | 2021 | // InternalSolverLanguageParser.g:703:1: ( ruleCall EOF ) |
2114 | // InternalSolverLanguage.g:631:1: ruleCall EOF | 2022 | // InternalSolverLanguageParser.g:704:1: ruleCall EOF |
2115 | { | 2023 | { |
2116 | if ( state.backtracking==0 ) { | 2024 | before(grammarAccess.getCallRule()); |
2117 | before(grammarAccess.getCallRule()); | ||
2118 | } | ||
2119 | pushFollow(FOLLOW_1); | 2025 | pushFollow(FOLLOW_1); |
2120 | ruleCall(); | 2026 | ruleCall(); |
2121 | 2027 | ||
2122 | state._fsp--; | 2028 | state._fsp--; |
2123 | if (state.failed) return ; | 2029 | |
2124 | if ( state.backtracking==0 ) { | 2030 | after(grammarAccess.getCallRule()); |
2125 | after(grammarAccess.getCallRule()); | 2031 | match(input,EOF,FOLLOW_2); |
2126 | } | ||
2127 | match(input,EOF,FOLLOW_2); if (state.failed) return ; | ||
2128 | 2032 | ||
2129 | } | 2033 | } |
2130 | 2034 | ||
@@ -2141,36 +2045,32 @@ public class InternalSolverLanguageParser extends AbstractInternalContentAssistP | |||
2141 | 2045 | ||
2142 | 2046 | ||
2143 | // $ANTLR start "ruleCall" | 2047 | // $ANTLR start "ruleCall" |
2144 | // InternalSolverLanguage.g:638:1: ruleCall : ( ( rule__Call__Group__0 ) ) ; | 2048 | // InternalSolverLanguageParser.g:711:1: ruleCall : ( ( rule__Call__Group__0 ) ) ; |
2145 | public final void ruleCall() throws RecognitionException { | 2049 | public final void ruleCall() throws RecognitionException { |
2146 | 2050 | ||
2147 | int stackSize = keepStackSize(); | 2051 | int stackSize = keepStackSize(); |
2148 | 2052 | ||
2149 | try { | 2053 | try { |
2150 | // InternalSolverLanguage.g:642:2: ( ( ( rule__Call__Group__0 ) ) ) | 2054 | // InternalSolverLanguageParser.g:715:2: ( ( ( rule__Call__Group__0 ) ) ) |
2151 | // InternalSolverLanguage.g:643:2: ( ( rule__Call__Group__0 ) ) | 2055 | // InternalSolverLanguageParser.g:716:2: ( ( rule__Call__Group__0 ) ) |
2152 | { | 2056 | { |
2153 | // InternalSolverLanguage.g:643:2: ( ( rule__Call__Group__0 ) ) | 2057 | // InternalSolverLanguageParser.g:716:2: ( ( rule__Call__Group__0 ) ) |
2154 | // InternalSolverLanguage.g:644:3: ( rule__Call__Group__0 ) | 2058 | // InternalSolverLanguageParser.g:717:3: ( rule__Call__Group__0 ) |
2155 | { | 2059 | { |
2156 | if ( state.backtracking==0 ) { | 2060 | before(grammarAccess.getCallAccess().getGroup()); |
2157 | before(grammarAccess.getCallAccess().getGroup()); | 2061 | // InternalSolverLanguageParser.g:718:3: ( rule__Call__Group__0 ) |
2158 | } | 2062 | // InternalSolverLanguageParser.g:718:4: rule__Call__Group__0 |
2159 | // InternalSolverLanguage.g:645:3: ( rule__Call__Group__0 ) | ||
2160 | // InternalSolverLanguage.g:645:4: rule__Call__Group__0 | ||
2161 | { | 2063 | { |
2162 | pushFollow(FOLLOW_2); | 2064 | pushFollow(FOLLOW_2); |
2163 | rule__Call__Group__0(); | 2065 | rule__Call__Group__0(); |
2164 | 2066 | ||
2165 | state._fsp--; | 2067 | state._fsp--; |
2166 | if (state.failed) return ; | ||
2167 | 2068 | ||
2168 | } | ||
2169 | 2069 | ||
2170 | if ( state.backtracking==0 ) { | ||
2171 | after(grammarAccess.getCallAccess().getGroup()); | ||
2172 | } | 2070 | } |
2173 | 2071 | ||
2072 | after(grammarAccess.getCallAccess().getGroup()); | ||
2073 | |||
2174 | } | 2074 | } |
2175 | 2075 | ||
2176 | 2076 | ||
@@ -2192,24 +2092,20 @@ public class InternalSolverLanguageParser extends AbstractInternalContentAssistP | |||
2192 | 2092 | ||
2193 | 2093 | ||
2194 | // $ANTLR start "entryRuleArgumentList" | 2094 | // $ANTLR start "entryRuleArgumentList" |
2195 | // InternalSolverLanguage.g:654:1: entryRuleArgumentList : ruleArgumentList EOF ; | 2095 | // InternalSolverLanguageParser.g:727:1: entryRuleArgumentList : ruleArgumentList EOF ; |
2196 | public final void entryRuleArgumentList() throws RecognitionException { | 2096 | public final void entryRuleArgumentList() throws RecognitionException { |
2197 | try { | 2097 | try { |
2198 | // InternalSolverLanguage.g:655:1: ( ruleArgumentList EOF ) | 2098 | // InternalSolverLanguageParser.g:728:1: ( ruleArgumentList EOF ) |
2199 | // InternalSolverLanguage.g:656:1: ruleArgumentList EOF | 2099 | // InternalSolverLanguageParser.g:729:1: ruleArgumentList EOF |
2200 | { | 2100 | { |
2201 | if ( state.backtracking==0 ) { | 2101 | before(grammarAccess.getArgumentListRule()); |
2202 | before(grammarAccess.getArgumentListRule()); | ||
2203 | } | ||
2204 | pushFollow(FOLLOW_1); | 2102 | pushFollow(FOLLOW_1); |
2205 | ruleArgumentList(); | 2103 | ruleArgumentList(); |
2206 | 2104 | ||
2207 | state._fsp--; | 2105 | state._fsp--; |
2208 | if (state.failed) return ; | 2106 | |
2209 | if ( state.backtracking==0 ) { | 2107 | after(grammarAccess.getArgumentListRule()); |
2210 | after(grammarAccess.getArgumentListRule()); | 2108 | match(input,EOF,FOLLOW_2); |
2211 | } | ||
2212 | match(input,EOF,FOLLOW_2); if (state.failed) return ; | ||
2213 | 2109 | ||
2214 | } | 2110 | } |
2215 | 2111 | ||
@@ -2226,36 +2122,32 @@ public class InternalSolverLanguageParser extends AbstractInternalContentAssistP | |||
2226 | 2122 | ||
2227 | 2123 | ||
2228 | // $ANTLR start "ruleArgumentList" | 2124 | // $ANTLR start "ruleArgumentList" |
2229 | // InternalSolverLanguage.g:663:1: ruleArgumentList : ( ( rule__ArgumentList__Group__0 ) ) ; | 2125 | // InternalSolverLanguageParser.g:736:1: ruleArgumentList : ( ( rule__ArgumentList__Group__0 ) ) ; |
2230 | public final void ruleArgumentList() throws RecognitionException { | 2126 | public final void ruleArgumentList() throws RecognitionException { |
2231 | 2127 | ||
2232 | int stackSize = keepStackSize(); | 2128 | int stackSize = keepStackSize(); |
2233 | 2129 | ||
2234 | try { | 2130 | try { |
2235 | // InternalSolverLanguage.g:667:2: ( ( ( rule__ArgumentList__Group__0 ) ) ) | 2131 | // InternalSolverLanguageParser.g:740:2: ( ( ( rule__ArgumentList__Group__0 ) ) ) |
2236 | // InternalSolverLanguage.g:668:2: ( ( rule__ArgumentList__Group__0 ) ) | 2132 | // InternalSolverLanguageParser.g:741:2: ( ( rule__ArgumentList__Group__0 ) ) |
2237 | { | 2133 | { |
2238 | // InternalSolverLanguage.g:668:2: ( ( rule__ArgumentList__Group__0 ) ) | 2134 | // InternalSolverLanguageParser.g:741:2: ( ( rule__ArgumentList__Group__0 ) ) |
2239 | // InternalSolverLanguage.g:669:3: ( rule__ArgumentList__Group__0 ) | 2135 | // InternalSolverLanguageParser.g:742:3: ( rule__ArgumentList__Group__0 ) |
2240 | { | 2136 | { |
2241 | if ( state.backtracking==0 ) { | 2137 | before(grammarAccess.getArgumentListAccess().getGroup()); |
2242 | before(grammarAccess.getArgumentListAccess().getGroup()); | 2138 | // InternalSolverLanguageParser.g:743:3: ( rule__ArgumentList__Group__0 ) |
2243 | } | 2139 | // InternalSolverLanguageParser.g:743:4: rule__ArgumentList__Group__0 |
2244 | // InternalSolverLanguage.g:670:3: ( rule__ArgumentList__Group__0 ) | ||
2245 | // InternalSolverLanguage.g:670:4: rule__ArgumentList__Group__0 | ||
2246 | { | 2140 | { |
2247 | pushFollow(FOLLOW_2); | 2141 | pushFollow(FOLLOW_2); |
2248 | rule__ArgumentList__Group__0(); | 2142 | rule__ArgumentList__Group__0(); |
2249 | 2143 | ||
2250 | state._fsp--; | 2144 | state._fsp--; |
2251 | if (state.failed) return ; | ||
2252 | 2145 | ||
2253 | } | ||
2254 | 2146 | ||
2255 | if ( state.backtracking==0 ) { | ||
2256 | after(grammarAccess.getArgumentListAccess().getGroup()); | ||
2257 | } | 2147 | } |
2258 | 2148 | ||
2149 | after(grammarAccess.getArgumentListAccess().getGroup()); | ||
2150 | |||
2259 | } | 2151 | } |
2260 | 2152 | ||
2261 | 2153 | ||
@@ -2277,24 +2169,20 @@ public class InternalSolverLanguageParser extends AbstractInternalContentAssistP | |||
2277 | 2169 | ||
2278 | 2170 | ||
2279 | // $ANTLR start "entryRuleArgument" | 2171 | // $ANTLR start "entryRuleArgument" |
2280 | // InternalSolverLanguage.g:679:1: entryRuleArgument : ruleArgument EOF ; | 2172 | // InternalSolverLanguageParser.g:752:1: entryRuleArgument : ruleArgument EOF ; |
2281 | public final void entryRuleArgument() throws RecognitionException { | 2173 | public final void entryRuleArgument() throws RecognitionException { |
2282 | try { | 2174 | try { |
2283 | // InternalSolverLanguage.g:680:1: ( ruleArgument EOF ) | 2175 | // InternalSolverLanguageParser.g:753:1: ( ruleArgument EOF ) |
2284 | // InternalSolverLanguage.g:681:1: ruleArgument EOF | 2176 | // InternalSolverLanguageParser.g:754:1: ruleArgument EOF |
2285 | { | 2177 | { |
2286 | if ( state.backtracking==0 ) { | 2178 | before(grammarAccess.getArgumentRule()); |
2287 | before(grammarAccess.getArgumentRule()); | ||
2288 | } | ||
2289 | pushFollow(FOLLOW_1); | 2179 | pushFollow(FOLLOW_1); |
2290 | ruleArgument(); | 2180 | ruleArgument(); |
2291 | 2181 | ||
2292 | state._fsp--; | 2182 | state._fsp--; |
2293 | if (state.failed) return ; | 2183 | |
2294 | if ( state.backtracking==0 ) { | 2184 | after(grammarAccess.getArgumentRule()); |
2295 | after(grammarAccess.getArgumentRule()); | 2185 | match(input,EOF,FOLLOW_2); |
2296 | } | ||
2297 | match(input,EOF,FOLLOW_2); if (state.failed) return ; | ||
2298 | 2186 | ||
2299 | } | 2187 | } |
2300 | 2188 | ||
@@ -2311,36 +2199,32 @@ public class InternalSolverLanguageParser extends AbstractInternalContentAssistP | |||
2311 | 2199 | ||
2312 | 2200 | ||
2313 | // $ANTLR start "ruleArgument" | 2201 | // $ANTLR start "ruleArgument" |
2314 | // InternalSolverLanguage.g:688:1: ruleArgument : ( ( rule__Argument__Alternatives ) ) ; | 2202 | // InternalSolverLanguageParser.g:761:1: ruleArgument : ( ( rule__Argument__Alternatives ) ) ; |
2315 | public final void ruleArgument() throws RecognitionException { | 2203 | public final void ruleArgument() throws RecognitionException { |
2316 | 2204 | ||
2317 | int stackSize = keepStackSize(); | 2205 | int stackSize = keepStackSize(); |
2318 | 2206 | ||
2319 | try { | 2207 | try { |
2320 | // InternalSolverLanguage.g:692:2: ( ( ( rule__Argument__Alternatives ) ) ) | 2208 | // InternalSolverLanguageParser.g:765:2: ( ( ( rule__Argument__Alternatives ) ) ) |
2321 | // InternalSolverLanguage.g:693:2: ( ( rule__Argument__Alternatives ) ) | 2209 | // InternalSolverLanguageParser.g:766:2: ( ( rule__Argument__Alternatives ) ) |
2322 | { | 2210 | { |
2323 | // InternalSolverLanguage.g:693:2: ( ( rule__Argument__Alternatives ) ) | 2211 | // InternalSolverLanguageParser.g:766:2: ( ( rule__Argument__Alternatives ) ) |
2324 | // InternalSolverLanguage.g:694:3: ( rule__Argument__Alternatives ) | 2212 | // InternalSolverLanguageParser.g:767:3: ( rule__Argument__Alternatives ) |
2325 | { | 2213 | { |
2326 | if ( state.backtracking==0 ) { | 2214 | before(grammarAccess.getArgumentAccess().getAlternatives()); |
2327 | before(grammarAccess.getArgumentAccess().getAlternatives()); | 2215 | // InternalSolverLanguageParser.g:768:3: ( rule__Argument__Alternatives ) |
2328 | } | 2216 | // InternalSolverLanguageParser.g:768:4: rule__Argument__Alternatives |
2329 | // InternalSolverLanguage.g:695:3: ( rule__Argument__Alternatives ) | ||
2330 | // InternalSolverLanguage.g:695:4: rule__Argument__Alternatives | ||
2331 | { | 2217 | { |
2332 | pushFollow(FOLLOW_2); | 2218 | pushFollow(FOLLOW_2); |
2333 | rule__Argument__Alternatives(); | 2219 | rule__Argument__Alternatives(); |
2334 | 2220 | ||
2335 | state._fsp--; | 2221 | state._fsp--; |
2336 | if (state.failed) return ; | ||
2337 | 2222 | ||
2338 | } | ||
2339 | 2223 | ||
2340 | if ( state.backtracking==0 ) { | ||
2341 | after(grammarAccess.getArgumentAccess().getAlternatives()); | ||
2342 | } | 2224 | } |
2343 | 2225 | ||
2226 | after(grammarAccess.getArgumentAccess().getAlternatives()); | ||
2227 | |||
2344 | } | 2228 | } |
2345 | 2229 | ||
2346 | 2230 | ||
@@ -2362,24 +2246,20 @@ public class InternalSolverLanguageParser extends AbstractInternalContentAssistP | |||
2362 | 2246 | ||
2363 | 2247 | ||
2364 | // $ANTLR start "entryRuleExpressionArgument" | 2248 | // $ANTLR start "entryRuleExpressionArgument" |
2365 | // InternalSolverLanguage.g:704:1: entryRuleExpressionArgument : ruleExpressionArgument EOF ; | 2249 | // InternalSolverLanguageParser.g:777:1: entryRuleExpressionArgument : ruleExpressionArgument EOF ; |
2366 | public final void entryRuleExpressionArgument() throws RecognitionException { | 2250 | public final void entryRuleExpressionArgument() throws RecognitionException { |
2367 | try { | 2251 | try { |
2368 | // InternalSolverLanguage.g:705:1: ( ruleExpressionArgument EOF ) | 2252 | // InternalSolverLanguageParser.g:778:1: ( ruleExpressionArgument EOF ) |
2369 | // InternalSolverLanguage.g:706:1: ruleExpressionArgument EOF | 2253 | // InternalSolverLanguageParser.g:779:1: ruleExpressionArgument EOF |
2370 | { | 2254 | { |
2371 | if ( state.backtracking==0 ) { | 2255 | before(grammarAccess.getExpressionArgumentRule()); |
2372 | before(grammarAccess.getExpressionArgumentRule()); | ||
2373 | } | ||
2374 | pushFollow(FOLLOW_1); | 2256 | pushFollow(FOLLOW_1); |
2375 | ruleExpressionArgument(); | 2257 | ruleExpressionArgument(); |
2376 | 2258 | ||
2377 | state._fsp--; | 2259 | state._fsp--; |
2378 | if (state.failed) return ; | 2260 | |
2379 | if ( state.backtracking==0 ) { | 2261 | after(grammarAccess.getExpressionArgumentRule()); |
2380 | after(grammarAccess.getExpressionArgumentRule()); | 2262 | match(input,EOF,FOLLOW_2); |
2381 | } | ||
2382 | match(input,EOF,FOLLOW_2); if (state.failed) return ; | ||
2383 | 2263 | ||
2384 | } | 2264 | } |
2385 | 2265 | ||
@@ -2396,36 +2276,32 @@ public class InternalSolverLanguageParser extends AbstractInternalContentAssistP | |||
2396 | 2276 | ||
2397 | 2277 | ||
2398 | // $ANTLR start "ruleExpressionArgument" | 2278 | // $ANTLR start "ruleExpressionArgument" |
2399 | // InternalSolverLanguage.g:713:1: ruleExpressionArgument : ( ( rule__ExpressionArgument__BodyAssignment ) ) ; | 2279 | // InternalSolverLanguageParser.g:786:1: ruleExpressionArgument : ( ( rule__ExpressionArgument__BodyAssignment ) ) ; |
2400 | public final void ruleExpressionArgument() throws RecognitionException { | 2280 | public final void ruleExpressionArgument() throws RecognitionException { |
2401 | 2281 | ||
2402 | int stackSize = keepStackSize(); | 2282 | int stackSize = keepStackSize(); |
2403 | 2283 | ||
2404 | try { | 2284 | try { |
2405 | // InternalSolverLanguage.g:717:2: ( ( ( rule__ExpressionArgument__BodyAssignment ) ) ) | 2285 | // InternalSolverLanguageParser.g:790:2: ( ( ( rule__ExpressionArgument__BodyAssignment ) ) ) |
2406 | // InternalSolverLanguage.g:718:2: ( ( rule__ExpressionArgument__BodyAssignment ) ) | 2286 | // InternalSolverLanguageParser.g:791:2: ( ( rule__ExpressionArgument__BodyAssignment ) ) |
2407 | { | 2287 | { |
2408 | // InternalSolverLanguage.g:718:2: ( ( rule__ExpressionArgument__BodyAssignment ) ) | 2288 | // InternalSolverLanguageParser.g:791:2: ( ( rule__ExpressionArgument__BodyAssignment ) ) |
2409 | // InternalSolverLanguage.g:719:3: ( rule__ExpressionArgument__BodyAssignment ) | 2289 | // InternalSolverLanguageParser.g:792:3: ( rule__ExpressionArgument__BodyAssignment ) |
2410 | { | 2290 | { |
2411 | if ( state.backtracking==0 ) { | 2291 | before(grammarAccess.getExpressionArgumentAccess().getBodyAssignment()); |
2412 | before(grammarAccess.getExpressionArgumentAccess().getBodyAssignment()); | 2292 | // InternalSolverLanguageParser.g:793:3: ( rule__ExpressionArgument__BodyAssignment ) |
2413 | } | 2293 | // InternalSolverLanguageParser.g:793:4: rule__ExpressionArgument__BodyAssignment |
2414 | // InternalSolverLanguage.g:720:3: ( rule__ExpressionArgument__BodyAssignment ) | ||
2415 | // InternalSolverLanguage.g:720:4: rule__ExpressionArgument__BodyAssignment | ||
2416 | { | 2294 | { |
2417 | pushFollow(FOLLOW_2); | 2295 | pushFollow(FOLLOW_2); |
2418 | rule__ExpressionArgument__BodyAssignment(); | 2296 | rule__ExpressionArgument__BodyAssignment(); |
2419 | 2297 | ||
2420 | state._fsp--; | 2298 | state._fsp--; |
2421 | if (state.failed) return ; | ||
2422 | 2299 | ||
2423 | } | ||
2424 | 2300 | ||
2425 | if ( state.backtracking==0 ) { | ||
2426 | after(grammarAccess.getExpressionArgumentAccess().getBodyAssignment()); | ||
2427 | } | 2301 | } |
2428 | 2302 | ||
2303 | after(grammarAccess.getExpressionArgumentAccess().getBodyAssignment()); | ||
2304 | |||
2429 | } | 2305 | } |
2430 | 2306 | ||
2431 | 2307 | ||
@@ -2447,24 +2323,20 @@ public class InternalSolverLanguageParser extends AbstractInternalContentAssistP | |||
2447 | 2323 | ||
2448 | 2324 | ||
2449 | // $ANTLR start "entryRuleStarArgument" | 2325 | // $ANTLR start "entryRuleStarArgument" |
2450 | // InternalSolverLanguage.g:729:1: entryRuleStarArgument : ruleStarArgument EOF ; | 2326 | // InternalSolverLanguageParser.g:802:1: entryRuleStarArgument : ruleStarArgument EOF ; |
2451 | public final void entryRuleStarArgument() throws RecognitionException { | 2327 | public final void entryRuleStarArgument() throws RecognitionException { |
2452 | try { | 2328 | try { |
2453 | // InternalSolverLanguage.g:730:1: ( ruleStarArgument EOF ) | 2329 | // InternalSolverLanguageParser.g:803:1: ( ruleStarArgument EOF ) |
2454 | // InternalSolverLanguage.g:731:1: ruleStarArgument EOF | 2330 | // InternalSolverLanguageParser.g:804:1: ruleStarArgument EOF |
2455 | { | 2331 | { |
2456 | if ( state.backtracking==0 ) { | 2332 | before(grammarAccess.getStarArgumentRule()); |
2457 | before(grammarAccess.getStarArgumentRule()); | ||
2458 | } | ||
2459 | pushFollow(FOLLOW_1); | 2333 | pushFollow(FOLLOW_1); |
2460 | ruleStarArgument(); | 2334 | ruleStarArgument(); |
2461 | 2335 | ||
2462 | state._fsp--; | 2336 | state._fsp--; |
2463 | if (state.failed) return ; | 2337 | |
2464 | if ( state.backtracking==0 ) { | 2338 | after(grammarAccess.getStarArgumentRule()); |
2465 | after(grammarAccess.getStarArgumentRule()); | 2339 | match(input,EOF,FOLLOW_2); |
2466 | } | ||
2467 | match(input,EOF,FOLLOW_2); if (state.failed) return ; | ||
2468 | 2340 | ||
2469 | } | 2341 | } |
2470 | 2342 | ||
@@ -2481,36 +2353,32 @@ public class InternalSolverLanguageParser extends AbstractInternalContentAssistP | |||
2481 | 2353 | ||
2482 | 2354 | ||
2483 | // $ANTLR start "ruleStarArgument" | 2355 | // $ANTLR start "ruleStarArgument" |
2484 | // InternalSolverLanguage.g:738:1: ruleStarArgument : ( ( rule__StarArgument__Group__0 ) ) ; | 2356 | // InternalSolverLanguageParser.g:811:1: ruleStarArgument : ( ( rule__StarArgument__Group__0 ) ) ; |
2485 | public final void ruleStarArgument() throws RecognitionException { | 2357 | public final void ruleStarArgument() throws RecognitionException { |
2486 | 2358 | ||
2487 | int stackSize = keepStackSize(); | 2359 | int stackSize = keepStackSize(); |
2488 | 2360 | ||
2489 | try { | 2361 | try { |
2490 | // InternalSolverLanguage.g:742:2: ( ( ( rule__StarArgument__Group__0 ) ) ) | 2362 | // InternalSolverLanguageParser.g:815:2: ( ( ( rule__StarArgument__Group__0 ) ) ) |
2491 | // InternalSolverLanguage.g:743:2: ( ( rule__StarArgument__Group__0 ) ) | 2363 | // InternalSolverLanguageParser.g:816:2: ( ( rule__StarArgument__Group__0 ) ) |
2492 | { | 2364 | { |
2493 | // InternalSolverLanguage.g:743:2: ( ( rule__StarArgument__Group__0 ) ) | 2365 | // InternalSolverLanguageParser.g:816:2: ( ( rule__StarArgument__Group__0 ) ) |
2494 | // InternalSolverLanguage.g:744:3: ( rule__StarArgument__Group__0 ) | 2366 | // InternalSolverLanguageParser.g:817:3: ( rule__StarArgument__Group__0 ) |
2495 | { | 2367 | { |
2496 | if ( state.backtracking==0 ) { | 2368 | before(grammarAccess.getStarArgumentAccess().getGroup()); |
2497 | before(grammarAccess.getStarArgumentAccess().getGroup()); | 2369 | // InternalSolverLanguageParser.g:818:3: ( rule__StarArgument__Group__0 ) |
2498 | } | 2370 | // InternalSolverLanguageParser.g:818:4: rule__StarArgument__Group__0 |
2499 | // InternalSolverLanguage.g:745:3: ( rule__StarArgument__Group__0 ) | ||
2500 | // InternalSolverLanguage.g:745:4: rule__StarArgument__Group__0 | ||
2501 | { | 2371 | { |
2502 | pushFollow(FOLLOW_2); | 2372 | pushFollow(FOLLOW_2); |
2503 | rule__StarArgument__Group__0(); | 2373 | rule__StarArgument__Group__0(); |
2504 | 2374 | ||
2505 | state._fsp--; | 2375 | state._fsp--; |
2506 | if (state.failed) return ; | ||
2507 | 2376 | ||
2508 | } | ||
2509 | 2377 | ||
2510 | if ( state.backtracking==0 ) { | ||
2511 | after(grammarAccess.getStarArgumentAccess().getGroup()); | ||
2512 | } | 2378 | } |
2513 | 2379 | ||
2380 | after(grammarAccess.getStarArgumentAccess().getGroup()); | ||
2381 | |||
2514 | } | 2382 | } |
2515 | 2383 | ||
2516 | 2384 | ||
@@ -2532,24 +2400,20 @@ public class InternalSolverLanguageParser extends AbstractInternalContentAssistP | |||
2532 | 2400 | ||
2533 | 2401 | ||
2534 | // $ANTLR start "entryRuleTypedArgument" | 2402 | // $ANTLR start "entryRuleTypedArgument" |
2535 | // InternalSolverLanguage.g:754:1: entryRuleTypedArgument : ruleTypedArgument EOF ; | 2403 | // InternalSolverLanguageParser.g:827:1: entryRuleTypedArgument : ruleTypedArgument EOF ; |
2536 | public final void entryRuleTypedArgument() throws RecognitionException { | 2404 | public final void entryRuleTypedArgument() throws RecognitionException { |
2537 | try { | 2405 | try { |
2538 | // InternalSolverLanguage.g:755:1: ( ruleTypedArgument EOF ) | 2406 | // InternalSolverLanguageParser.g:828:1: ( ruleTypedArgument EOF ) |
2539 | // InternalSolverLanguage.g:756:1: ruleTypedArgument EOF | 2407 | // InternalSolverLanguageParser.g:829:1: ruleTypedArgument EOF |
2540 | { | 2408 | { |
2541 | if ( state.backtracking==0 ) { | 2409 | before(grammarAccess.getTypedArgumentRule()); |
2542 | before(grammarAccess.getTypedArgumentRule()); | ||
2543 | } | ||
2544 | pushFollow(FOLLOW_1); | 2410 | pushFollow(FOLLOW_1); |
2545 | ruleTypedArgument(); | 2411 | ruleTypedArgument(); |
2546 | 2412 | ||
2547 | state._fsp--; | 2413 | state._fsp--; |
2548 | if (state.failed) return ; | 2414 | |
2549 | if ( state.backtracking==0 ) { | 2415 | after(grammarAccess.getTypedArgumentRule()); |
2550 | after(grammarAccess.getTypedArgumentRule()); | 2416 | match(input,EOF,FOLLOW_2); |
2551 | } | ||
2552 | match(input,EOF,FOLLOW_2); if (state.failed) return ; | ||
2553 | 2417 | ||
2554 | } | 2418 | } |
2555 | 2419 | ||
@@ -2566,36 +2430,32 @@ public class InternalSolverLanguageParser extends AbstractInternalContentAssistP | |||
2566 | 2430 | ||
2567 | 2431 | ||
2568 | // $ANTLR start "ruleTypedArgument" | 2432 | // $ANTLR start "ruleTypedArgument" |
2569 | // InternalSolverLanguage.g:763:1: ruleTypedArgument : ( ( rule__TypedArgument__Group__0 ) ) ; | 2433 | // InternalSolverLanguageParser.g:836:1: ruleTypedArgument : ( ( rule__TypedArgument__Group__0 ) ) ; |
2570 | public final void ruleTypedArgument() throws RecognitionException { | 2434 | public final void ruleTypedArgument() throws RecognitionException { |
2571 | 2435 | ||
2572 | int stackSize = keepStackSize(); | 2436 | int stackSize = keepStackSize(); |
2573 | 2437 | ||
2574 | try { | 2438 | try { |
2575 | // InternalSolverLanguage.g:767:2: ( ( ( rule__TypedArgument__Group__0 ) ) ) | 2439 | // InternalSolverLanguageParser.g:840:2: ( ( ( rule__TypedArgument__Group__0 ) ) ) |
2576 | // InternalSolverLanguage.g:768:2: ( ( rule__TypedArgument__Group__0 ) ) | 2440 | // InternalSolverLanguageParser.g:841:2: ( ( rule__TypedArgument__Group__0 ) ) |
2577 | { | 2441 | { |
2578 | // InternalSolverLanguage.g:768:2: ( ( rule__TypedArgument__Group__0 ) ) | 2442 | // InternalSolverLanguageParser.g:841:2: ( ( rule__TypedArgument__Group__0 ) ) |
2579 | // InternalSolverLanguage.g:769:3: ( rule__TypedArgument__Group__0 ) | 2443 | // InternalSolverLanguageParser.g:842:3: ( rule__TypedArgument__Group__0 ) |
2580 | { | 2444 | { |
2581 | if ( state.backtracking==0 ) { | 2445 | before(grammarAccess.getTypedArgumentAccess().getGroup()); |
2582 | before(grammarAccess.getTypedArgumentAccess().getGroup()); | 2446 | // InternalSolverLanguageParser.g:843:3: ( rule__TypedArgument__Group__0 ) |
2583 | } | 2447 | // InternalSolverLanguageParser.g:843:4: rule__TypedArgument__Group__0 |
2584 | // InternalSolverLanguage.g:770:3: ( rule__TypedArgument__Group__0 ) | ||
2585 | // InternalSolverLanguage.g:770:4: rule__TypedArgument__Group__0 | ||
2586 | { | 2448 | { |
2587 | pushFollow(FOLLOW_2); | 2449 | pushFollow(FOLLOW_2); |
2588 | rule__TypedArgument__Group__0(); | 2450 | rule__TypedArgument__Group__0(); |
2589 | 2451 | ||
2590 | state._fsp--; | 2452 | state._fsp--; |
2591 | if (state.failed) return ; | ||
2592 | 2453 | ||
2593 | } | ||
2594 | 2454 | ||
2595 | if ( state.backtracking==0 ) { | ||
2596 | after(grammarAccess.getTypedArgumentAccess().getGroup()); | ||
2597 | } | 2455 | } |
2598 | 2456 | ||
2457 | after(grammarAccess.getTypedArgumentAccess().getGroup()); | ||
2458 | |||
2599 | } | 2459 | } |
2600 | 2460 | ||
2601 | 2461 | ||
@@ -2617,24 +2477,20 @@ public class InternalSolverLanguageParser extends AbstractInternalContentAssistP | |||
2617 | 2477 | ||
2618 | 2478 | ||
2619 | // $ANTLR start "entryRuleTypedStarArgument" | 2479 | // $ANTLR start "entryRuleTypedStarArgument" |
2620 | // InternalSolverLanguage.g:779:1: entryRuleTypedStarArgument : ruleTypedStarArgument EOF ; | 2480 | // InternalSolverLanguageParser.g:852:1: entryRuleTypedStarArgument : ruleTypedStarArgument EOF ; |
2621 | public final void entryRuleTypedStarArgument() throws RecognitionException { | 2481 | public final void entryRuleTypedStarArgument() throws RecognitionException { |
2622 | try { | 2482 | try { |
2623 | // InternalSolverLanguage.g:780:1: ( ruleTypedStarArgument EOF ) | 2483 | // InternalSolverLanguageParser.g:853:1: ( ruleTypedStarArgument EOF ) |
2624 | // InternalSolverLanguage.g:781:1: ruleTypedStarArgument EOF | 2484 | // InternalSolverLanguageParser.g:854:1: ruleTypedStarArgument EOF |
2625 | { | 2485 | { |
2626 | if ( state.backtracking==0 ) { | 2486 | before(grammarAccess.getTypedStarArgumentRule()); |
2627 | before(grammarAccess.getTypedStarArgumentRule()); | ||
2628 | } | ||
2629 | pushFollow(FOLLOW_1); | 2487 | pushFollow(FOLLOW_1); |
2630 | ruleTypedStarArgument(); | 2488 | ruleTypedStarArgument(); |
2631 | 2489 | ||
2632 | state._fsp--; | 2490 | state._fsp--; |
2633 | if (state.failed) return ; | 2491 | |
2634 | if ( state.backtracking==0 ) { | 2492 | after(grammarAccess.getTypedStarArgumentRule()); |
2635 | after(grammarAccess.getTypedStarArgumentRule()); | 2493 | match(input,EOF,FOLLOW_2); |
2636 | } | ||
2637 | match(input,EOF,FOLLOW_2); if (state.failed) return ; | ||
2638 | 2494 | ||
2639 | } | 2495 | } |
2640 | 2496 | ||
@@ -2651,36 +2507,32 @@ public class InternalSolverLanguageParser extends AbstractInternalContentAssistP | |||
2651 | 2507 | ||
2652 | 2508 | ||
2653 | // $ANTLR start "ruleTypedStarArgument" | 2509 | // $ANTLR start "ruleTypedStarArgument" |
2654 | // InternalSolverLanguage.g:788:1: ruleTypedStarArgument : ( ( rule__TypedStarArgument__Group__0 ) ) ; | 2510 | // InternalSolverLanguageParser.g:861:1: ruleTypedStarArgument : ( ( rule__TypedStarArgument__Group__0 ) ) ; |
2655 | public final void ruleTypedStarArgument() throws RecognitionException { | 2511 | public final void ruleTypedStarArgument() throws RecognitionException { |
2656 | 2512 | ||
2657 | int stackSize = keepStackSize(); | 2513 | int stackSize = keepStackSize(); |
2658 | 2514 | ||
2659 | try { | 2515 | try { |
2660 | // InternalSolverLanguage.g:792:2: ( ( ( rule__TypedStarArgument__Group__0 ) ) ) | 2516 | // InternalSolverLanguageParser.g:865:2: ( ( ( rule__TypedStarArgument__Group__0 ) ) ) |
2661 | // InternalSolverLanguage.g:793:2: ( ( rule__TypedStarArgument__Group__0 ) ) | 2517 | // InternalSolverLanguageParser.g:866:2: ( ( rule__TypedStarArgument__Group__0 ) ) |
2662 | { | 2518 | { |
2663 | // InternalSolverLanguage.g:793:2: ( ( rule__TypedStarArgument__Group__0 ) ) | 2519 | // InternalSolverLanguageParser.g:866:2: ( ( rule__TypedStarArgument__Group__0 ) ) |
2664 | // InternalSolverLanguage.g:794:3: ( rule__TypedStarArgument__Group__0 ) | 2520 | // InternalSolverLanguageParser.g:867:3: ( rule__TypedStarArgument__Group__0 ) |
2665 | { | 2521 | { |
2666 | if ( state.backtracking==0 ) { | 2522 | before(grammarAccess.getTypedStarArgumentAccess().getGroup()); |
2667 | before(grammarAccess.getTypedStarArgumentAccess().getGroup()); | 2523 | // InternalSolverLanguageParser.g:868:3: ( rule__TypedStarArgument__Group__0 ) |
2668 | } | 2524 | // InternalSolverLanguageParser.g:868:4: rule__TypedStarArgument__Group__0 |
2669 | // InternalSolverLanguage.g:795:3: ( rule__TypedStarArgument__Group__0 ) | ||
2670 | // InternalSolverLanguage.g:795:4: rule__TypedStarArgument__Group__0 | ||
2671 | { | 2525 | { |
2672 | pushFollow(FOLLOW_2); | 2526 | pushFollow(FOLLOW_2); |
2673 | rule__TypedStarArgument__Group__0(); | 2527 | rule__TypedStarArgument__Group__0(); |
2674 | 2528 | ||
2675 | state._fsp--; | 2529 | state._fsp--; |
2676 | if (state.failed) return ; | ||
2677 | 2530 | ||
2678 | } | ||
2679 | 2531 | ||
2680 | if ( state.backtracking==0 ) { | ||
2681 | after(grammarAccess.getTypedStarArgumentAccess().getGroup()); | ||
2682 | } | 2532 | } |
2683 | 2533 | ||
2534 | after(grammarAccess.getTypedStarArgumentAccess().getGroup()); | ||
2535 | |||
2684 | } | 2536 | } |
2685 | 2537 | ||
2686 | 2538 | ||
@@ -2702,24 +2554,20 @@ public class InternalSolverLanguageParser extends AbstractInternalContentAssistP | |||
2702 | 2554 | ||
2703 | 2555 | ||
2704 | // $ANTLR start "entryRuleReference" | 2556 | // $ANTLR start "entryRuleReference" |
2705 | // InternalSolverLanguage.g:804:1: entryRuleReference : ruleReference EOF ; | 2557 | // InternalSolverLanguageParser.g:877:1: entryRuleReference : ruleReference EOF ; |
2706 | public final void entryRuleReference() throws RecognitionException { | 2558 | public final void entryRuleReference() throws RecognitionException { |
2707 | try { | 2559 | try { |
2708 | // InternalSolverLanguage.g:805:1: ( ruleReference EOF ) | 2560 | // InternalSolverLanguageParser.g:878:1: ( ruleReference EOF ) |
2709 | // InternalSolverLanguage.g:806:1: ruleReference EOF | 2561 | // InternalSolverLanguageParser.g:879:1: ruleReference EOF |
2710 | { | 2562 | { |
2711 | if ( state.backtracking==0 ) { | 2563 | before(grammarAccess.getReferenceRule()); |
2712 | before(grammarAccess.getReferenceRule()); | ||
2713 | } | ||
2714 | pushFollow(FOLLOW_1); | 2564 | pushFollow(FOLLOW_1); |
2715 | ruleReference(); | 2565 | ruleReference(); |
2716 | 2566 | ||
2717 | state._fsp--; | 2567 | state._fsp--; |
2718 | if (state.failed) return ; | 2568 | |
2719 | if ( state.backtracking==0 ) { | 2569 | after(grammarAccess.getReferenceRule()); |
2720 | after(grammarAccess.getReferenceRule()); | 2570 | match(input,EOF,FOLLOW_2); |
2721 | } | ||
2722 | match(input,EOF,FOLLOW_2); if (state.failed) return ; | ||
2723 | 2571 | ||
2724 | } | 2572 | } |
2725 | 2573 | ||
@@ -2736,36 +2584,32 @@ public class InternalSolverLanguageParser extends AbstractInternalContentAssistP | |||
2736 | 2584 | ||
2737 | 2585 | ||
2738 | // $ANTLR start "ruleReference" | 2586 | // $ANTLR start "ruleReference" |
2739 | // InternalSolverLanguage.g:813:1: ruleReference : ( ( rule__Reference__ReferredAssignment ) ) ; | 2587 | // InternalSolverLanguageParser.g:886:1: ruleReference : ( ( rule__Reference__ReferredAssignment ) ) ; |
2740 | public final void ruleReference() throws RecognitionException { | 2588 | public final void ruleReference() throws RecognitionException { |
2741 | 2589 | ||
2742 | int stackSize = keepStackSize(); | 2590 | int stackSize = keepStackSize(); |
2743 | 2591 | ||
2744 | try { | 2592 | try { |
2745 | // InternalSolverLanguage.g:817:2: ( ( ( rule__Reference__ReferredAssignment ) ) ) | 2593 | // InternalSolverLanguageParser.g:890:2: ( ( ( rule__Reference__ReferredAssignment ) ) ) |
2746 | // InternalSolverLanguage.g:818:2: ( ( rule__Reference__ReferredAssignment ) ) | 2594 | // InternalSolverLanguageParser.g:891:2: ( ( rule__Reference__ReferredAssignment ) ) |
2747 | { | 2595 | { |
2748 | // InternalSolverLanguage.g:818:2: ( ( rule__Reference__ReferredAssignment ) ) | 2596 | // InternalSolverLanguageParser.g:891:2: ( ( rule__Reference__ReferredAssignment ) ) |
2749 | // InternalSolverLanguage.g:819:3: ( rule__Reference__ReferredAssignment ) | 2597 | // InternalSolverLanguageParser.g:892:3: ( rule__Reference__ReferredAssignment ) |
2750 | { | 2598 | { |
2751 | if ( state.backtracking==0 ) { | 2599 | before(grammarAccess.getReferenceAccess().getReferredAssignment()); |
2752 | before(grammarAccess.getReferenceAccess().getReferredAssignment()); | 2600 | // InternalSolverLanguageParser.g:893:3: ( rule__Reference__ReferredAssignment ) |
2753 | } | 2601 | // InternalSolverLanguageParser.g:893:4: rule__Reference__ReferredAssignment |
2754 | // InternalSolverLanguage.g:820:3: ( rule__Reference__ReferredAssignment ) | ||
2755 | // InternalSolverLanguage.g:820:4: rule__Reference__ReferredAssignment | ||
2756 | { | 2602 | { |
2757 | pushFollow(FOLLOW_2); | 2603 | pushFollow(FOLLOW_2); |
2758 | rule__Reference__ReferredAssignment(); | 2604 | rule__Reference__ReferredAssignment(); |
2759 | 2605 | ||
2760 | state._fsp--; | 2606 | state._fsp--; |
2761 | if (state.failed) return ; | ||
2762 | 2607 | ||
2763 | } | ||
2764 | 2608 | ||
2765 | if ( state.backtracking==0 ) { | ||
2766 | after(grammarAccess.getReferenceAccess().getReferredAssignment()); | ||
2767 | } | 2609 | } |
2768 | 2610 | ||
2611 | after(grammarAccess.getReferenceAccess().getReferredAssignment()); | ||
2612 | |||
2769 | } | 2613 | } |
2770 | 2614 | ||
2771 | 2615 | ||
@@ -2787,24 +2631,20 @@ public class InternalSolverLanguageParser extends AbstractInternalContentAssistP | |||
2787 | 2631 | ||
2788 | 2632 | ||
2789 | // $ANTLR start "entryRuleInterval" | 2633 | // $ANTLR start "entryRuleInterval" |
2790 | // InternalSolverLanguage.g:829:1: entryRuleInterval : ruleInterval EOF ; | 2634 | // InternalSolverLanguageParser.g:902:1: entryRuleInterval : ruleInterval EOF ; |
2791 | public final void entryRuleInterval() throws RecognitionException { | 2635 | public final void entryRuleInterval() throws RecognitionException { |
2792 | try { | 2636 | try { |
2793 | // InternalSolverLanguage.g:830:1: ( ruleInterval EOF ) | 2637 | // InternalSolverLanguageParser.g:903:1: ( ruleInterval EOF ) |
2794 | // InternalSolverLanguage.g:831:1: ruleInterval EOF | 2638 | // InternalSolverLanguageParser.g:904:1: ruleInterval EOF |
2795 | { | 2639 | { |
2796 | if ( state.backtracking==0 ) { | 2640 | before(grammarAccess.getIntervalRule()); |
2797 | before(grammarAccess.getIntervalRule()); | ||
2798 | } | ||
2799 | pushFollow(FOLLOW_1); | 2641 | pushFollow(FOLLOW_1); |
2800 | ruleInterval(); | 2642 | ruleInterval(); |
2801 | 2643 | ||
2802 | state._fsp--; | 2644 | state._fsp--; |
2803 | if (state.failed) return ; | 2645 | |
2804 | if ( state.backtracking==0 ) { | 2646 | after(grammarAccess.getIntervalRule()); |
2805 | after(grammarAccess.getIntervalRule()); | 2647 | match(input,EOF,FOLLOW_2); |
2806 | } | ||
2807 | match(input,EOF,FOLLOW_2); if (state.failed) return ; | ||
2808 | 2648 | ||
2809 | } | 2649 | } |
2810 | 2650 | ||
@@ -2821,36 +2661,32 @@ public class InternalSolverLanguageParser extends AbstractInternalContentAssistP | |||
2821 | 2661 | ||
2822 | 2662 | ||
2823 | // $ANTLR start "ruleInterval" | 2663 | // $ANTLR start "ruleInterval" |
2824 | // InternalSolverLanguage.g:838:1: ruleInterval : ( ( rule__Interval__Group__0 ) ) ; | 2664 | // InternalSolverLanguageParser.g:911:1: ruleInterval : ( ( rule__Interval__Group__0 ) ) ; |
2825 | public final void ruleInterval() throws RecognitionException { | 2665 | public final void ruleInterval() throws RecognitionException { |
2826 | 2666 | ||
2827 | int stackSize = keepStackSize(); | 2667 | int stackSize = keepStackSize(); |
2828 | 2668 | ||
2829 | try { | 2669 | try { |
2830 | // InternalSolverLanguage.g:842:2: ( ( ( rule__Interval__Group__0 ) ) ) | 2670 | // InternalSolverLanguageParser.g:915:2: ( ( ( rule__Interval__Group__0 ) ) ) |
2831 | // InternalSolverLanguage.g:843:2: ( ( rule__Interval__Group__0 ) ) | 2671 | // InternalSolverLanguageParser.g:916:2: ( ( rule__Interval__Group__0 ) ) |
2832 | { | 2672 | { |
2833 | // InternalSolverLanguage.g:843:2: ( ( rule__Interval__Group__0 ) ) | 2673 | // InternalSolverLanguageParser.g:916:2: ( ( rule__Interval__Group__0 ) ) |
2834 | // InternalSolverLanguage.g:844:3: ( rule__Interval__Group__0 ) | 2674 | // InternalSolverLanguageParser.g:917:3: ( rule__Interval__Group__0 ) |
2835 | { | 2675 | { |
2836 | if ( state.backtracking==0 ) { | 2676 | before(grammarAccess.getIntervalAccess().getGroup()); |
2837 | before(grammarAccess.getIntervalAccess().getGroup()); | 2677 | // InternalSolverLanguageParser.g:918:3: ( rule__Interval__Group__0 ) |
2838 | } | 2678 | // InternalSolverLanguageParser.g:918:4: rule__Interval__Group__0 |
2839 | // InternalSolverLanguage.g:845:3: ( rule__Interval__Group__0 ) | ||
2840 | // InternalSolverLanguage.g:845:4: rule__Interval__Group__0 | ||
2841 | { | 2679 | { |
2842 | pushFollow(FOLLOW_2); | 2680 | pushFollow(FOLLOW_2); |
2843 | rule__Interval__Group__0(); | 2681 | rule__Interval__Group__0(); |
2844 | 2682 | ||
2845 | state._fsp--; | 2683 | state._fsp--; |
2846 | if (state.failed) return ; | ||
2847 | 2684 | ||
2848 | } | ||
2849 | 2685 | ||
2850 | if ( state.backtracking==0 ) { | ||
2851 | after(grammarAccess.getIntervalAccess().getGroup()); | ||
2852 | } | 2686 | } |
2853 | 2687 | ||
2688 | after(grammarAccess.getIntervalAccess().getGroup()); | ||
2689 | |||
2854 | } | 2690 | } |
2855 | 2691 | ||
2856 | 2692 | ||
@@ -2872,24 +2708,20 @@ public class InternalSolverLanguageParser extends AbstractInternalContentAssistP | |||
2872 | 2708 | ||
2873 | 2709 | ||
2874 | // $ANTLR start "entryRuleLiteral" | 2710 | // $ANTLR start "entryRuleLiteral" |
2875 | // InternalSolverLanguage.g:854:1: entryRuleLiteral : ruleLiteral EOF ; | 2711 | // InternalSolverLanguageParser.g:927:1: entryRuleLiteral : ruleLiteral EOF ; |
2876 | public final void entryRuleLiteral() throws RecognitionException { | 2712 | public final void entryRuleLiteral() throws RecognitionException { |
2877 | try { | 2713 | try { |
2878 | // InternalSolverLanguage.g:855:1: ( ruleLiteral EOF ) | 2714 | // InternalSolverLanguageParser.g:928:1: ( ruleLiteral EOF ) |
2879 | // InternalSolverLanguage.g:856:1: ruleLiteral EOF | 2715 | // InternalSolverLanguageParser.g:929:1: ruleLiteral EOF |
2880 | { | 2716 | { |
2881 | if ( state.backtracking==0 ) { | 2717 | before(grammarAccess.getLiteralRule()); |
2882 | before(grammarAccess.getLiteralRule()); | ||
2883 | } | ||
2884 | pushFollow(FOLLOW_1); | 2718 | pushFollow(FOLLOW_1); |
2885 | ruleLiteral(); | 2719 | ruleLiteral(); |
2886 | 2720 | ||
2887 | state._fsp--; | 2721 | state._fsp--; |
2888 | if (state.failed) return ; | 2722 | |
2889 | if ( state.backtracking==0 ) { | 2723 | after(grammarAccess.getLiteralRule()); |
2890 | after(grammarAccess.getLiteralRule()); | 2724 | match(input,EOF,FOLLOW_2); |
2891 | } | ||
2892 | match(input,EOF,FOLLOW_2); if (state.failed) return ; | ||
2893 | 2725 | ||
2894 | } | 2726 | } |
2895 | 2727 | ||
@@ -2906,36 +2738,32 @@ public class InternalSolverLanguageParser extends AbstractInternalContentAssistP | |||
2906 | 2738 | ||
2907 | 2739 | ||
2908 | // $ANTLR start "ruleLiteral" | 2740 | // $ANTLR start "ruleLiteral" |
2909 | // InternalSolverLanguage.g:863:1: ruleLiteral : ( ( rule__Literal__Alternatives ) ) ; | 2741 | // InternalSolverLanguageParser.g:936:1: ruleLiteral : ( ( rule__Literal__Alternatives ) ) ; |
2910 | public final void ruleLiteral() throws RecognitionException { | 2742 | public final void ruleLiteral() throws RecognitionException { |
2911 | 2743 | ||
2912 | int stackSize = keepStackSize(); | 2744 | int stackSize = keepStackSize(); |
2913 | 2745 | ||
2914 | try { | 2746 | try { |
2915 | // InternalSolverLanguage.g:867:2: ( ( ( rule__Literal__Alternatives ) ) ) | 2747 | // InternalSolverLanguageParser.g:940:2: ( ( ( rule__Literal__Alternatives ) ) ) |
2916 | // InternalSolverLanguage.g:868:2: ( ( rule__Literal__Alternatives ) ) | 2748 | // InternalSolverLanguageParser.g:941:2: ( ( rule__Literal__Alternatives ) ) |
2917 | { | 2749 | { |
2918 | // InternalSolverLanguage.g:868:2: ( ( rule__Literal__Alternatives ) ) | 2750 | // InternalSolverLanguageParser.g:941:2: ( ( rule__Literal__Alternatives ) ) |
2919 | // InternalSolverLanguage.g:869:3: ( rule__Literal__Alternatives ) | 2751 | // InternalSolverLanguageParser.g:942:3: ( rule__Literal__Alternatives ) |
2920 | { | 2752 | { |
2921 | if ( state.backtracking==0 ) { | 2753 | before(grammarAccess.getLiteralAccess().getAlternatives()); |
2922 | before(grammarAccess.getLiteralAccess().getAlternatives()); | 2754 | // InternalSolverLanguageParser.g:943:3: ( rule__Literal__Alternatives ) |
2923 | } | 2755 | // InternalSolverLanguageParser.g:943:4: rule__Literal__Alternatives |
2924 | // InternalSolverLanguage.g:870:3: ( rule__Literal__Alternatives ) | ||
2925 | // InternalSolverLanguage.g:870:4: rule__Literal__Alternatives | ||
2926 | { | 2756 | { |
2927 | pushFollow(FOLLOW_2); | 2757 | pushFollow(FOLLOW_2); |
2928 | rule__Literal__Alternatives(); | 2758 | rule__Literal__Alternatives(); |
2929 | 2759 | ||
2930 | state._fsp--; | 2760 | state._fsp--; |
2931 | if (state.failed) return ; | ||
2932 | 2761 | ||
2933 | } | ||
2934 | 2762 | ||
2935 | if ( state.backtracking==0 ) { | ||
2936 | after(grammarAccess.getLiteralAccess().getAlternatives()); | ||
2937 | } | 2763 | } |
2938 | 2764 | ||
2765 | after(grammarAccess.getLiteralAccess().getAlternatives()); | ||
2766 | |||
2939 | } | 2767 | } |
2940 | 2768 | ||
2941 | 2769 | ||
@@ -2957,24 +2785,20 @@ public class InternalSolverLanguageParser extends AbstractInternalContentAssistP | |||
2957 | 2785 | ||
2958 | 2786 | ||
2959 | // $ANTLR start "entryRuleLogicLiteral" | 2787 | // $ANTLR start "entryRuleLogicLiteral" |
2960 | // InternalSolverLanguage.g:879:1: entryRuleLogicLiteral : ruleLogicLiteral EOF ; | 2788 | // InternalSolverLanguageParser.g:952:1: entryRuleLogicLiteral : ruleLogicLiteral EOF ; |
2961 | public final void entryRuleLogicLiteral() throws RecognitionException { | 2789 | public final void entryRuleLogicLiteral() throws RecognitionException { |
2962 | try { | 2790 | try { |
2963 | // InternalSolverLanguage.g:880:1: ( ruleLogicLiteral EOF ) | 2791 | // InternalSolverLanguageParser.g:953:1: ( ruleLogicLiteral EOF ) |
2964 | // InternalSolverLanguage.g:881:1: ruleLogicLiteral EOF | 2792 | // InternalSolverLanguageParser.g:954:1: ruleLogicLiteral EOF |
2965 | { | 2793 | { |
2966 | if ( state.backtracking==0 ) { | 2794 | before(grammarAccess.getLogicLiteralRule()); |
2967 | before(grammarAccess.getLogicLiteralRule()); | ||
2968 | } | ||
2969 | pushFollow(FOLLOW_1); | 2795 | pushFollow(FOLLOW_1); |
2970 | ruleLogicLiteral(); | 2796 | ruleLogicLiteral(); |
2971 | 2797 | ||
2972 | state._fsp--; | 2798 | state._fsp--; |
2973 | if (state.failed) return ; | 2799 | |
2974 | if ( state.backtracking==0 ) { | 2800 | after(grammarAccess.getLogicLiteralRule()); |
2975 | after(grammarAccess.getLogicLiteralRule()); | 2801 | match(input,EOF,FOLLOW_2); |
2976 | } | ||
2977 | match(input,EOF,FOLLOW_2); if (state.failed) return ; | ||
2978 | 2802 | ||
2979 | } | 2803 | } |
2980 | 2804 | ||
@@ -2991,36 +2815,32 @@ public class InternalSolverLanguageParser extends AbstractInternalContentAssistP | |||
2991 | 2815 | ||
2992 | 2816 | ||
2993 | // $ANTLR start "ruleLogicLiteral" | 2817 | // $ANTLR start "ruleLogicLiteral" |
2994 | // InternalSolverLanguage.g:888:1: ruleLogicLiteral : ( ( rule__LogicLiteral__ValueAssignment ) ) ; | 2818 | // InternalSolverLanguageParser.g:961:1: ruleLogicLiteral : ( ( rule__LogicLiteral__ValueAssignment ) ) ; |
2995 | public final void ruleLogicLiteral() throws RecognitionException { | 2819 | public final void ruleLogicLiteral() throws RecognitionException { |
2996 | 2820 | ||
2997 | int stackSize = keepStackSize(); | 2821 | int stackSize = keepStackSize(); |
2998 | 2822 | ||
2999 | try { | 2823 | try { |
3000 | // InternalSolverLanguage.g:892:2: ( ( ( rule__LogicLiteral__ValueAssignment ) ) ) | 2824 | // InternalSolverLanguageParser.g:965:2: ( ( ( rule__LogicLiteral__ValueAssignment ) ) ) |
3001 | // InternalSolverLanguage.g:893:2: ( ( rule__LogicLiteral__ValueAssignment ) ) | 2825 | // InternalSolverLanguageParser.g:966:2: ( ( rule__LogicLiteral__ValueAssignment ) ) |
3002 | { | 2826 | { |
3003 | // InternalSolverLanguage.g:893:2: ( ( rule__LogicLiteral__ValueAssignment ) ) | 2827 | // InternalSolverLanguageParser.g:966:2: ( ( rule__LogicLiteral__ValueAssignment ) ) |
3004 | // InternalSolverLanguage.g:894:3: ( rule__LogicLiteral__ValueAssignment ) | 2828 | // InternalSolverLanguageParser.g:967:3: ( rule__LogicLiteral__ValueAssignment ) |
3005 | { | 2829 | { |
3006 | if ( state.backtracking==0 ) { | 2830 | before(grammarAccess.getLogicLiteralAccess().getValueAssignment()); |
3007 | before(grammarAccess.getLogicLiteralAccess().getValueAssignment()); | 2831 | // InternalSolverLanguageParser.g:968:3: ( rule__LogicLiteral__ValueAssignment ) |
3008 | } | 2832 | // InternalSolverLanguageParser.g:968:4: rule__LogicLiteral__ValueAssignment |
3009 | // InternalSolverLanguage.g:895:3: ( rule__LogicLiteral__ValueAssignment ) | ||
3010 | // InternalSolverLanguage.g:895:4: rule__LogicLiteral__ValueAssignment | ||
3011 | { | 2833 | { |
3012 | pushFollow(FOLLOW_2); | 2834 | pushFollow(FOLLOW_2); |
3013 | rule__LogicLiteral__ValueAssignment(); | 2835 | rule__LogicLiteral__ValueAssignment(); |
3014 | 2836 | ||
3015 | state._fsp--; | 2837 | state._fsp--; |
3016 | if (state.failed) return ; | ||
3017 | 2838 | ||
3018 | } | ||
3019 | 2839 | ||
3020 | if ( state.backtracking==0 ) { | ||
3021 | after(grammarAccess.getLogicLiteralAccess().getValueAssignment()); | ||
3022 | } | 2840 | } |
3023 | 2841 | ||
2842 | after(grammarAccess.getLogicLiteralAccess().getValueAssignment()); | ||
2843 | |||
3024 | } | 2844 | } |
3025 | 2845 | ||
3026 | 2846 | ||
@@ -3042,24 +2862,20 @@ public class InternalSolverLanguageParser extends AbstractInternalContentAssistP | |||
3042 | 2862 | ||
3043 | 2863 | ||
3044 | // $ANTLR start "entryRuleNumericLiteral" | 2864 | // $ANTLR start "entryRuleNumericLiteral" |
3045 | // InternalSolverLanguage.g:904:1: entryRuleNumericLiteral : ruleNumericLiteral EOF ; | 2865 | // InternalSolverLanguageParser.g:977:1: entryRuleNumericLiteral : ruleNumericLiteral EOF ; |
3046 | public final void entryRuleNumericLiteral() throws RecognitionException { | 2866 | public final void entryRuleNumericLiteral() throws RecognitionException { |
3047 | try { | 2867 | try { |
3048 | // InternalSolverLanguage.g:905:1: ( ruleNumericLiteral EOF ) | 2868 | // InternalSolverLanguageParser.g:978:1: ( ruleNumericLiteral EOF ) |
3049 | // InternalSolverLanguage.g:906:1: ruleNumericLiteral EOF | 2869 | // InternalSolverLanguageParser.g:979:1: ruleNumericLiteral EOF |
3050 | { | 2870 | { |
3051 | if ( state.backtracking==0 ) { | 2871 | before(grammarAccess.getNumericLiteralRule()); |
3052 | before(grammarAccess.getNumericLiteralRule()); | ||
3053 | } | ||
3054 | pushFollow(FOLLOW_1); | 2872 | pushFollow(FOLLOW_1); |
3055 | ruleNumericLiteral(); | 2873 | ruleNumericLiteral(); |
3056 | 2874 | ||
3057 | state._fsp--; | 2875 | state._fsp--; |
3058 | if (state.failed) return ; | 2876 | |
3059 | if ( state.backtracking==0 ) { | 2877 | after(grammarAccess.getNumericLiteralRule()); |
3060 | after(grammarAccess.getNumericLiteralRule()); | 2878 | match(input,EOF,FOLLOW_2); |
3061 | } | ||
3062 | match(input,EOF,FOLLOW_2); if (state.failed) return ; | ||
3063 | 2879 | ||
3064 | } | 2880 | } |
3065 | 2881 | ||
@@ -3076,36 +2892,32 @@ public class InternalSolverLanguageParser extends AbstractInternalContentAssistP | |||
3076 | 2892 | ||
3077 | 2893 | ||
3078 | // $ANTLR start "ruleNumericLiteral" | 2894 | // $ANTLR start "ruleNumericLiteral" |
3079 | // InternalSolverLanguage.g:913:1: ruleNumericLiteral : ( ( rule__NumericLiteral__ValueAssignment ) ) ; | 2895 | // InternalSolverLanguageParser.g:986:1: ruleNumericLiteral : ( ( rule__NumericLiteral__ValueAssignment ) ) ; |
3080 | public final void ruleNumericLiteral() throws RecognitionException { | 2896 | public final void ruleNumericLiteral() throws RecognitionException { |
3081 | 2897 | ||
3082 | int stackSize = keepStackSize(); | 2898 | int stackSize = keepStackSize(); |
3083 | 2899 | ||
3084 | try { | 2900 | try { |
3085 | // InternalSolverLanguage.g:917:2: ( ( ( rule__NumericLiteral__ValueAssignment ) ) ) | 2901 | // InternalSolverLanguageParser.g:990:2: ( ( ( rule__NumericLiteral__ValueAssignment ) ) ) |
3086 | // InternalSolverLanguage.g:918:2: ( ( rule__NumericLiteral__ValueAssignment ) ) | 2902 | // InternalSolverLanguageParser.g:991:2: ( ( rule__NumericLiteral__ValueAssignment ) ) |
3087 | { | 2903 | { |
3088 | // InternalSolverLanguage.g:918:2: ( ( rule__NumericLiteral__ValueAssignment ) ) | 2904 | // InternalSolverLanguageParser.g:991:2: ( ( rule__NumericLiteral__ValueAssignment ) ) |
3089 | // InternalSolverLanguage.g:919:3: ( rule__NumericLiteral__ValueAssignment ) | 2905 | // InternalSolverLanguageParser.g:992:3: ( rule__NumericLiteral__ValueAssignment ) |
3090 | { | 2906 | { |
3091 | if ( state.backtracking==0 ) { | 2907 | before(grammarAccess.getNumericLiteralAccess().getValueAssignment()); |
3092 | before(grammarAccess.getNumericLiteralAccess().getValueAssignment()); | 2908 | // InternalSolverLanguageParser.g:993:3: ( rule__NumericLiteral__ValueAssignment ) |
3093 | } | 2909 | // InternalSolverLanguageParser.g:993:4: rule__NumericLiteral__ValueAssignment |
3094 | // InternalSolverLanguage.g:920:3: ( rule__NumericLiteral__ValueAssignment ) | ||
3095 | // InternalSolverLanguage.g:920:4: rule__NumericLiteral__ValueAssignment | ||
3096 | { | 2910 | { |
3097 | pushFollow(FOLLOW_2); | 2911 | pushFollow(FOLLOW_2); |
3098 | rule__NumericLiteral__ValueAssignment(); | 2912 | rule__NumericLiteral__ValueAssignment(); |
3099 | 2913 | ||
3100 | state._fsp--; | 2914 | state._fsp--; |
3101 | if (state.failed) return ; | ||
3102 | 2915 | ||
3103 | } | ||
3104 | 2916 | ||
3105 | if ( state.backtracking==0 ) { | ||
3106 | after(grammarAccess.getNumericLiteralAccess().getValueAssignment()); | ||
3107 | } | 2917 | } |
3108 | 2918 | ||
2919 | after(grammarAccess.getNumericLiteralAccess().getValueAssignment()); | ||
2920 | |||
3109 | } | 2921 | } |
3110 | 2922 | ||
3111 | 2923 | ||
@@ -3127,24 +2939,20 @@ public class InternalSolverLanguageParser extends AbstractInternalContentAssistP | |||
3127 | 2939 | ||
3128 | 2940 | ||
3129 | // $ANTLR start "entryRuleInfinityLiteral" | 2941 | // $ANTLR start "entryRuleInfinityLiteral" |
3130 | // InternalSolverLanguage.g:929:1: entryRuleInfinityLiteral : ruleInfinityLiteral EOF ; | 2942 | // InternalSolverLanguageParser.g:1002:1: entryRuleInfinityLiteral : ruleInfinityLiteral EOF ; |
3131 | public final void entryRuleInfinityLiteral() throws RecognitionException { | 2943 | public final void entryRuleInfinityLiteral() throws RecognitionException { |
3132 | try { | 2944 | try { |
3133 | // InternalSolverLanguage.g:930:1: ( ruleInfinityLiteral EOF ) | 2945 | // InternalSolverLanguageParser.g:1003:1: ( ruleInfinityLiteral EOF ) |
3134 | // InternalSolverLanguage.g:931:1: ruleInfinityLiteral EOF | 2946 | // InternalSolverLanguageParser.g:1004:1: ruleInfinityLiteral EOF |
3135 | { | 2947 | { |
3136 | if ( state.backtracking==0 ) { | 2948 | before(grammarAccess.getInfinityLiteralRule()); |
3137 | before(grammarAccess.getInfinityLiteralRule()); | ||
3138 | } | ||
3139 | pushFollow(FOLLOW_1); | 2949 | pushFollow(FOLLOW_1); |
3140 | ruleInfinityLiteral(); | 2950 | ruleInfinityLiteral(); |
3141 | 2951 | ||
3142 | state._fsp--; | 2952 | state._fsp--; |
3143 | if (state.failed) return ; | 2953 | |
3144 | if ( state.backtracking==0 ) { | 2954 | after(grammarAccess.getInfinityLiteralRule()); |
3145 | after(grammarAccess.getInfinityLiteralRule()); | 2955 | match(input,EOF,FOLLOW_2); |
3146 | } | ||
3147 | match(input,EOF,FOLLOW_2); if (state.failed) return ; | ||
3148 | 2956 | ||
3149 | } | 2957 | } |
3150 | 2958 | ||
@@ -3161,36 +2969,32 @@ public class InternalSolverLanguageParser extends AbstractInternalContentAssistP | |||
3161 | 2969 | ||
3162 | 2970 | ||
3163 | // $ANTLR start "ruleInfinityLiteral" | 2971 | // $ANTLR start "ruleInfinityLiteral" |
3164 | // InternalSolverLanguage.g:938:1: ruleInfinityLiteral : ( ( rule__InfinityLiteral__Group__0 ) ) ; | 2972 | // InternalSolverLanguageParser.g:1011:1: ruleInfinityLiteral : ( ( rule__InfinityLiteral__Group__0 ) ) ; |
3165 | public final void ruleInfinityLiteral() throws RecognitionException { | 2973 | public final void ruleInfinityLiteral() throws RecognitionException { |
3166 | 2974 | ||
3167 | int stackSize = keepStackSize(); | 2975 | int stackSize = keepStackSize(); |
3168 | 2976 | ||
3169 | try { | 2977 | try { |
3170 | // InternalSolverLanguage.g:942:2: ( ( ( rule__InfinityLiteral__Group__0 ) ) ) | 2978 | // InternalSolverLanguageParser.g:1015:2: ( ( ( rule__InfinityLiteral__Group__0 ) ) ) |
3171 | // InternalSolverLanguage.g:943:2: ( ( rule__InfinityLiteral__Group__0 ) ) | 2979 | // InternalSolverLanguageParser.g:1016:2: ( ( rule__InfinityLiteral__Group__0 ) ) |
3172 | { | 2980 | { |
3173 | // InternalSolverLanguage.g:943:2: ( ( rule__InfinityLiteral__Group__0 ) ) | 2981 | // InternalSolverLanguageParser.g:1016:2: ( ( rule__InfinityLiteral__Group__0 ) ) |
3174 | // InternalSolverLanguage.g:944:3: ( rule__InfinityLiteral__Group__0 ) | 2982 | // InternalSolverLanguageParser.g:1017:3: ( rule__InfinityLiteral__Group__0 ) |
3175 | { | 2983 | { |
3176 | if ( state.backtracking==0 ) { | 2984 | before(grammarAccess.getInfinityLiteralAccess().getGroup()); |
3177 | before(grammarAccess.getInfinityLiteralAccess().getGroup()); | 2985 | // InternalSolverLanguageParser.g:1018:3: ( rule__InfinityLiteral__Group__0 ) |
3178 | } | 2986 | // InternalSolverLanguageParser.g:1018:4: rule__InfinityLiteral__Group__0 |
3179 | // InternalSolverLanguage.g:945:3: ( rule__InfinityLiteral__Group__0 ) | ||
3180 | // InternalSolverLanguage.g:945:4: rule__InfinityLiteral__Group__0 | ||
3181 | { | 2987 | { |
3182 | pushFollow(FOLLOW_2); | 2988 | pushFollow(FOLLOW_2); |
3183 | rule__InfinityLiteral__Group__0(); | 2989 | rule__InfinityLiteral__Group__0(); |
3184 | 2990 | ||
3185 | state._fsp--; | 2991 | state._fsp--; |
3186 | if (state.failed) return ; | ||
3187 | 2992 | ||
3188 | } | ||
3189 | 2993 | ||
3190 | if ( state.backtracking==0 ) { | ||
3191 | after(grammarAccess.getInfinityLiteralAccess().getGroup()); | ||
3192 | } | 2994 | } |
3193 | 2995 | ||
2996 | after(grammarAccess.getInfinityLiteralAccess().getGroup()); | ||
2997 | |||
3194 | } | 2998 | } |
3195 | 2999 | ||
3196 | 3000 | ||
@@ -3212,24 +3016,20 @@ public class InternalSolverLanguageParser extends AbstractInternalContentAssistP | |||
3212 | 3016 | ||
3213 | 3017 | ||
3214 | // $ANTLR start "entryRuleEmptyIntervalLiteral" | 3018 | // $ANTLR start "entryRuleEmptyIntervalLiteral" |
3215 | // InternalSolverLanguage.g:954:1: entryRuleEmptyIntervalLiteral : ruleEmptyIntervalLiteral EOF ; | 3019 | // InternalSolverLanguageParser.g:1027:1: entryRuleEmptyIntervalLiteral : ruleEmptyIntervalLiteral EOF ; |
3216 | public final void entryRuleEmptyIntervalLiteral() throws RecognitionException { | 3020 | public final void entryRuleEmptyIntervalLiteral() throws RecognitionException { |
3217 | try { | 3021 | try { |
3218 | // InternalSolverLanguage.g:955:1: ( ruleEmptyIntervalLiteral EOF ) | 3022 | // InternalSolverLanguageParser.g:1028:1: ( ruleEmptyIntervalLiteral EOF ) |
3219 | // InternalSolverLanguage.g:956:1: ruleEmptyIntervalLiteral EOF | 3023 | // InternalSolverLanguageParser.g:1029:1: ruleEmptyIntervalLiteral EOF |
3220 | { | 3024 | { |
3221 | if ( state.backtracking==0 ) { | 3025 | before(grammarAccess.getEmptyIntervalLiteralRule()); |
3222 | before(grammarAccess.getEmptyIntervalLiteralRule()); | ||
3223 | } | ||
3224 | pushFollow(FOLLOW_1); | 3026 | pushFollow(FOLLOW_1); |
3225 | ruleEmptyIntervalLiteral(); | 3027 | ruleEmptyIntervalLiteral(); |
3226 | 3028 | ||
3227 | state._fsp--; | 3029 | state._fsp--; |
3228 | if (state.failed) return ; | 3030 | |
3229 | if ( state.backtracking==0 ) { | 3031 | after(grammarAccess.getEmptyIntervalLiteralRule()); |
3230 | after(grammarAccess.getEmptyIntervalLiteralRule()); | 3032 | match(input,EOF,FOLLOW_2); |
3231 | } | ||
3232 | match(input,EOF,FOLLOW_2); if (state.failed) return ; | ||
3233 | 3033 | ||
3234 | } | 3034 | } |
3235 | 3035 | ||
@@ -3246,36 +3046,32 @@ public class InternalSolverLanguageParser extends AbstractInternalContentAssistP | |||
3246 | 3046 | ||
3247 | 3047 | ||
3248 | // $ANTLR start "ruleEmptyIntervalLiteral" | 3048 | // $ANTLR start "ruleEmptyIntervalLiteral" |
3249 | // InternalSolverLanguage.g:963:1: ruleEmptyIntervalLiteral : ( ( rule__EmptyIntervalLiteral__Group__0 ) ) ; | 3049 | // InternalSolverLanguageParser.g:1036:1: ruleEmptyIntervalLiteral : ( ( rule__EmptyIntervalLiteral__Group__0 ) ) ; |
3250 | public final void ruleEmptyIntervalLiteral() throws RecognitionException { | 3050 | public final void ruleEmptyIntervalLiteral() throws RecognitionException { |
3251 | 3051 | ||
3252 | int stackSize = keepStackSize(); | 3052 | int stackSize = keepStackSize(); |
3253 | 3053 | ||
3254 | try { | 3054 | try { |
3255 | // InternalSolverLanguage.g:967:2: ( ( ( rule__EmptyIntervalLiteral__Group__0 ) ) ) | 3055 | // InternalSolverLanguageParser.g:1040:2: ( ( ( rule__EmptyIntervalLiteral__Group__0 ) ) ) |
3256 | // InternalSolverLanguage.g:968:2: ( ( rule__EmptyIntervalLiteral__Group__0 ) ) | 3056 | // InternalSolverLanguageParser.g:1041:2: ( ( rule__EmptyIntervalLiteral__Group__0 ) ) |
3257 | { | 3057 | { |
3258 | // InternalSolverLanguage.g:968:2: ( ( rule__EmptyIntervalLiteral__Group__0 ) ) | 3058 | // InternalSolverLanguageParser.g:1041:2: ( ( rule__EmptyIntervalLiteral__Group__0 ) ) |
3259 | // InternalSolverLanguage.g:969:3: ( rule__EmptyIntervalLiteral__Group__0 ) | 3059 | // InternalSolverLanguageParser.g:1042:3: ( rule__EmptyIntervalLiteral__Group__0 ) |
3260 | { | 3060 | { |
3261 | if ( state.backtracking==0 ) { | 3061 | before(grammarAccess.getEmptyIntervalLiteralAccess().getGroup()); |
3262 | before(grammarAccess.getEmptyIntervalLiteralAccess().getGroup()); | 3062 | // InternalSolverLanguageParser.g:1043:3: ( rule__EmptyIntervalLiteral__Group__0 ) |
3263 | } | 3063 | // InternalSolverLanguageParser.g:1043:4: rule__EmptyIntervalLiteral__Group__0 |
3264 | // InternalSolverLanguage.g:970:3: ( rule__EmptyIntervalLiteral__Group__0 ) | ||
3265 | // InternalSolverLanguage.g:970:4: rule__EmptyIntervalLiteral__Group__0 | ||
3266 | { | 3064 | { |
3267 | pushFollow(FOLLOW_2); | 3065 | pushFollow(FOLLOW_2); |
3268 | rule__EmptyIntervalLiteral__Group__0(); | 3066 | rule__EmptyIntervalLiteral__Group__0(); |
3269 | 3067 | ||
3270 | state._fsp--; | 3068 | state._fsp--; |
3271 | if (state.failed) return ; | ||
3272 | 3069 | ||
3273 | } | ||
3274 | 3070 | ||
3275 | if ( state.backtracking==0 ) { | ||
3276 | after(grammarAccess.getEmptyIntervalLiteralAccess().getGroup()); | ||
3277 | } | 3071 | } |
3278 | 3072 | ||
3073 | after(grammarAccess.getEmptyIntervalLiteralAccess().getGroup()); | ||
3074 | |||
3279 | } | 3075 | } |
3280 | 3076 | ||
3281 | 3077 | ||
@@ -3297,24 +3093,20 @@ public class InternalSolverLanguageParser extends AbstractInternalContentAssistP | |||
3297 | 3093 | ||
3298 | 3094 | ||
3299 | // $ANTLR start "entryRuleStringLiteral" | 3095 | // $ANTLR start "entryRuleStringLiteral" |
3300 | // InternalSolverLanguage.g:979:1: entryRuleStringLiteral : ruleStringLiteral EOF ; | 3096 | // InternalSolverLanguageParser.g:1052:1: entryRuleStringLiteral : ruleStringLiteral EOF ; |
3301 | public final void entryRuleStringLiteral() throws RecognitionException { | 3097 | public final void entryRuleStringLiteral() throws RecognitionException { |
3302 | try { | 3098 | try { |
3303 | // InternalSolverLanguage.g:980:1: ( ruleStringLiteral EOF ) | 3099 | // InternalSolverLanguageParser.g:1053:1: ( ruleStringLiteral EOF ) |
3304 | // InternalSolverLanguage.g:981:1: ruleStringLiteral EOF | 3100 | // InternalSolverLanguageParser.g:1054:1: ruleStringLiteral EOF |
3305 | { | 3101 | { |
3306 | if ( state.backtracking==0 ) { | 3102 | before(grammarAccess.getStringLiteralRule()); |
3307 | before(grammarAccess.getStringLiteralRule()); | ||
3308 | } | ||
3309 | pushFollow(FOLLOW_1); | 3103 | pushFollow(FOLLOW_1); |
3310 | ruleStringLiteral(); | 3104 | ruleStringLiteral(); |
3311 | 3105 | ||
3312 | state._fsp--; | 3106 | state._fsp--; |
3313 | if (state.failed) return ; | 3107 | |
3314 | if ( state.backtracking==0 ) { | 3108 | after(grammarAccess.getStringLiteralRule()); |
3315 | after(grammarAccess.getStringLiteralRule()); | 3109 | match(input,EOF,FOLLOW_2); |
3316 | } | ||
3317 | match(input,EOF,FOLLOW_2); if (state.failed) return ; | ||
3318 | 3110 | ||
3319 | } | 3111 | } |
3320 | 3112 | ||
@@ -3331,36 +3123,32 @@ public class InternalSolverLanguageParser extends AbstractInternalContentAssistP | |||
3331 | 3123 | ||
3332 | 3124 | ||
3333 | // $ANTLR start "ruleStringLiteral" | 3125 | // $ANTLR start "ruleStringLiteral" |
3334 | // InternalSolverLanguage.g:988:1: ruleStringLiteral : ( ( rule__StringLiteral__ValueAssignment ) ) ; | 3126 | // InternalSolverLanguageParser.g:1061:1: ruleStringLiteral : ( ( rule__StringLiteral__ValueAssignment ) ) ; |
3335 | public final void ruleStringLiteral() throws RecognitionException { | 3127 | public final void ruleStringLiteral() throws RecognitionException { |
3336 | 3128 | ||
3337 | int stackSize = keepStackSize(); | 3129 | int stackSize = keepStackSize(); |
3338 | 3130 | ||
3339 | try { | 3131 | try { |
3340 | // InternalSolverLanguage.g:992:2: ( ( ( rule__StringLiteral__ValueAssignment ) ) ) | 3132 | // InternalSolverLanguageParser.g:1065:2: ( ( ( rule__StringLiteral__ValueAssignment ) ) ) |
3341 | // InternalSolverLanguage.g:993:2: ( ( rule__StringLiteral__ValueAssignment ) ) | 3133 | // InternalSolverLanguageParser.g:1066:2: ( ( rule__StringLiteral__ValueAssignment ) ) |
3342 | { | 3134 | { |
3343 | // InternalSolverLanguage.g:993:2: ( ( rule__StringLiteral__ValueAssignment ) ) | 3135 | // InternalSolverLanguageParser.g:1066:2: ( ( rule__StringLiteral__ValueAssignment ) ) |
3344 | // InternalSolverLanguage.g:994:3: ( rule__StringLiteral__ValueAssignment ) | 3136 | // InternalSolverLanguageParser.g:1067:3: ( rule__StringLiteral__ValueAssignment ) |
3345 | { | 3137 | { |
3346 | if ( state.backtracking==0 ) { | 3138 | before(grammarAccess.getStringLiteralAccess().getValueAssignment()); |
3347 | before(grammarAccess.getStringLiteralAccess().getValueAssignment()); | 3139 | // InternalSolverLanguageParser.g:1068:3: ( rule__StringLiteral__ValueAssignment ) |
3348 | } | 3140 | // InternalSolverLanguageParser.g:1068:4: rule__StringLiteral__ValueAssignment |
3349 | // InternalSolverLanguage.g:995:3: ( rule__StringLiteral__ValueAssignment ) | ||
3350 | // InternalSolverLanguage.g:995:4: rule__StringLiteral__ValueAssignment | ||
3351 | { | 3141 | { |
3352 | pushFollow(FOLLOW_2); | 3142 | pushFollow(FOLLOW_2); |
3353 | rule__StringLiteral__ValueAssignment(); | 3143 | rule__StringLiteral__ValueAssignment(); |
3354 | 3144 | ||
3355 | state._fsp--; | 3145 | state._fsp--; |
3356 | if (state.failed) return ; | ||
3357 | 3146 | ||
3358 | } | ||
3359 | 3147 | ||
3360 | if ( state.backtracking==0 ) { | ||
3361 | after(grammarAccess.getStringLiteralAccess().getValueAssignment()); | ||
3362 | } | 3148 | } |
3363 | 3149 | ||
3150 | after(grammarAccess.getStringLiteralAccess().getValueAssignment()); | ||
3151 | |||
3364 | } | 3152 | } |
3365 | 3153 | ||
3366 | 3154 | ||
@@ -3382,24 +3170,20 @@ public class InternalSolverLanguageParser extends AbstractInternalContentAssistP | |||
3382 | 3170 | ||
3383 | 3171 | ||
3384 | // $ANTLR start "entryRuleClassDefinition" | 3172 | // $ANTLR start "entryRuleClassDefinition" |
3385 | // InternalSolverLanguage.g:1004:1: entryRuleClassDefinition : ruleClassDefinition EOF ; | 3173 | // InternalSolverLanguageParser.g:1077:1: entryRuleClassDefinition : ruleClassDefinition EOF ; |
3386 | public final void entryRuleClassDefinition() throws RecognitionException { | 3174 | public final void entryRuleClassDefinition() throws RecognitionException { |
3387 | try { | 3175 | try { |
3388 | // InternalSolverLanguage.g:1005:1: ( ruleClassDefinition EOF ) | 3176 | // InternalSolverLanguageParser.g:1078:1: ( ruleClassDefinition EOF ) |
3389 | // InternalSolverLanguage.g:1006:1: ruleClassDefinition EOF | 3177 | // InternalSolverLanguageParser.g:1079:1: ruleClassDefinition EOF |
3390 | { | 3178 | { |
3391 | if ( state.backtracking==0 ) { | 3179 | before(grammarAccess.getClassDefinitionRule()); |
3392 | before(grammarAccess.getClassDefinitionRule()); | ||
3393 | } | ||
3394 | pushFollow(FOLLOW_1); | 3180 | pushFollow(FOLLOW_1); |
3395 | ruleClassDefinition(); | 3181 | ruleClassDefinition(); |
3396 | 3182 | ||
3397 | state._fsp--; | 3183 | state._fsp--; |
3398 | if (state.failed) return ; | 3184 | |
3399 | if ( state.backtracking==0 ) { | 3185 | after(grammarAccess.getClassDefinitionRule()); |
3400 | after(grammarAccess.getClassDefinitionRule()); | 3186 | match(input,EOF,FOLLOW_2); |
3401 | } | ||
3402 | match(input,EOF,FOLLOW_2); if (state.failed) return ; | ||
3403 | 3187 | ||
3404 | } | 3188 | } |
3405 | 3189 | ||
@@ -3416,36 +3200,32 @@ public class InternalSolverLanguageParser extends AbstractInternalContentAssistP | |||
3416 | 3200 | ||
3417 | 3201 | ||
3418 | // $ANTLR start "ruleClassDefinition" | 3202 | // $ANTLR start "ruleClassDefinition" |
3419 | // InternalSolverLanguage.g:1013:1: ruleClassDefinition : ( ( rule__ClassDefinition__Group__0 ) ) ; | 3203 | // InternalSolverLanguageParser.g:1086:1: ruleClassDefinition : ( ( rule__ClassDefinition__Group__0 ) ) ; |
3420 | public final void ruleClassDefinition() throws RecognitionException { | 3204 | public final void ruleClassDefinition() throws RecognitionException { |
3421 | 3205 | ||
3422 | int stackSize = keepStackSize(); | 3206 | int stackSize = keepStackSize(); |
3423 | 3207 | ||
3424 | try { | 3208 | try { |
3425 | // InternalSolverLanguage.g:1017:2: ( ( ( rule__ClassDefinition__Group__0 ) ) ) | 3209 | // InternalSolverLanguageParser.g:1090:2: ( ( ( rule__ClassDefinition__Group__0 ) ) ) |
3426 | // InternalSolverLanguage.g:1018:2: ( ( rule__ClassDefinition__Group__0 ) ) | 3210 | // InternalSolverLanguageParser.g:1091:2: ( ( rule__ClassDefinition__Group__0 ) ) |
3427 | { | 3211 | { |
3428 | // InternalSolverLanguage.g:1018:2: ( ( rule__ClassDefinition__Group__0 ) ) | 3212 | // InternalSolverLanguageParser.g:1091:2: ( ( rule__ClassDefinition__Group__0 ) ) |
3429 | // InternalSolverLanguage.g:1019:3: ( rule__ClassDefinition__Group__0 ) | 3213 | // InternalSolverLanguageParser.g:1092:3: ( rule__ClassDefinition__Group__0 ) |
3430 | { | 3214 | { |
3431 | if ( state.backtracking==0 ) { | 3215 | before(grammarAccess.getClassDefinitionAccess().getGroup()); |
3432 | before(grammarAccess.getClassDefinitionAccess().getGroup()); | 3216 | // InternalSolverLanguageParser.g:1093:3: ( rule__ClassDefinition__Group__0 ) |
3433 | } | 3217 | // InternalSolverLanguageParser.g:1093:4: rule__ClassDefinition__Group__0 |
3434 | // InternalSolverLanguage.g:1020:3: ( rule__ClassDefinition__Group__0 ) | ||
3435 | // InternalSolverLanguage.g:1020:4: rule__ClassDefinition__Group__0 | ||
3436 | { | 3218 | { |
3437 | pushFollow(FOLLOW_2); | 3219 | pushFollow(FOLLOW_2); |
3438 | rule__ClassDefinition__Group__0(); | 3220 | rule__ClassDefinition__Group__0(); |
3439 | 3221 | ||
3440 | state._fsp--; | 3222 | state._fsp--; |
3441 | if (state.failed) return ; | ||
3442 | 3223 | ||
3443 | } | ||
3444 | 3224 | ||
3445 | if ( state.backtracking==0 ) { | ||
3446 | after(grammarAccess.getClassDefinitionAccess().getGroup()); | ||
3447 | } | 3225 | } |
3448 | 3226 | ||
3227 | after(grammarAccess.getClassDefinitionAccess().getGroup()); | ||
3228 | |||
3449 | } | 3229 | } |
3450 | 3230 | ||
3451 | 3231 | ||
@@ -3467,24 +3247,20 @@ public class InternalSolverLanguageParser extends AbstractInternalContentAssistP | |||
3467 | 3247 | ||
3468 | 3248 | ||
3469 | // $ANTLR start "entryRuleMemberDefinition" | 3249 | // $ANTLR start "entryRuleMemberDefinition" |
3470 | // InternalSolverLanguage.g:1029:1: entryRuleMemberDefinition : ruleMemberDefinition EOF ; | 3250 | // InternalSolverLanguageParser.g:1102:1: entryRuleMemberDefinition : ruleMemberDefinition EOF ; |
3471 | public final void entryRuleMemberDefinition() throws RecognitionException { | 3251 | public final void entryRuleMemberDefinition() throws RecognitionException { |
3472 | try { | 3252 | try { |
3473 | // InternalSolverLanguage.g:1030:1: ( ruleMemberDefinition EOF ) | 3253 | // InternalSolverLanguageParser.g:1103:1: ( ruleMemberDefinition EOF ) |
3474 | // InternalSolverLanguage.g:1031:1: ruleMemberDefinition EOF | 3254 | // InternalSolverLanguageParser.g:1104:1: ruleMemberDefinition EOF |
3475 | { | 3255 | { |
3476 | if ( state.backtracking==0 ) { | 3256 | before(grammarAccess.getMemberDefinitionRule()); |
3477 | before(grammarAccess.getMemberDefinitionRule()); | ||
3478 | } | ||
3479 | pushFollow(FOLLOW_1); | 3257 | pushFollow(FOLLOW_1); |
3480 | ruleMemberDefinition(); | 3258 | ruleMemberDefinition(); |
3481 | 3259 | ||
3482 | state._fsp--; | 3260 | state._fsp--; |
3483 | if (state.failed) return ; | 3261 | |
3484 | if ( state.backtracking==0 ) { | 3262 | after(grammarAccess.getMemberDefinitionRule()); |
3485 | after(grammarAccess.getMemberDefinitionRule()); | 3263 | match(input,EOF,FOLLOW_2); |
3486 | } | ||
3487 | match(input,EOF,FOLLOW_2); if (state.failed) return ; | ||
3488 | 3264 | ||
3489 | } | 3265 | } |
3490 | 3266 | ||
@@ -3501,36 +3277,32 @@ public class InternalSolverLanguageParser extends AbstractInternalContentAssistP | |||
3501 | 3277 | ||
3502 | 3278 | ||
3503 | // $ANTLR start "ruleMemberDefinition" | 3279 | // $ANTLR start "ruleMemberDefinition" |
3504 | // InternalSolverLanguage.g:1038:1: ruleMemberDefinition : ( ( rule__MemberDefinition__Group__0 ) ) ; | 3280 | // InternalSolverLanguageParser.g:1111:1: ruleMemberDefinition : ( ( rule__MemberDefinition__Group__0 ) ) ; |
3505 | public final void ruleMemberDefinition() throws RecognitionException { | 3281 | public final void ruleMemberDefinition() throws RecognitionException { |
3506 | 3282 | ||
3507 | int stackSize = keepStackSize(); | 3283 | int stackSize = keepStackSize(); |
3508 | 3284 | ||
3509 | try { | 3285 | try { |
3510 | // InternalSolverLanguage.g:1042:2: ( ( ( rule__MemberDefinition__Group__0 ) ) ) | 3286 | // InternalSolverLanguageParser.g:1115:2: ( ( ( rule__MemberDefinition__Group__0 ) ) ) |
3511 | // InternalSolverLanguage.g:1043:2: ( ( rule__MemberDefinition__Group__0 ) ) | 3287 | // InternalSolverLanguageParser.g:1116:2: ( ( rule__MemberDefinition__Group__0 ) ) |
3512 | { | 3288 | { |
3513 | // InternalSolverLanguage.g:1043:2: ( ( rule__MemberDefinition__Group__0 ) ) | 3289 | // InternalSolverLanguageParser.g:1116:2: ( ( rule__MemberDefinition__Group__0 ) ) |
3514 | // InternalSolverLanguage.g:1044:3: ( rule__MemberDefinition__Group__0 ) | 3290 | // InternalSolverLanguageParser.g:1117:3: ( rule__MemberDefinition__Group__0 ) |
3515 | { | 3291 | { |
3516 | if ( state.backtracking==0 ) { | 3292 | before(grammarAccess.getMemberDefinitionAccess().getGroup()); |
3517 | before(grammarAccess.getMemberDefinitionAccess().getGroup()); | 3293 | // InternalSolverLanguageParser.g:1118:3: ( rule__MemberDefinition__Group__0 ) |
3518 | } | 3294 | // InternalSolverLanguageParser.g:1118:4: rule__MemberDefinition__Group__0 |
3519 | // InternalSolverLanguage.g:1045:3: ( rule__MemberDefinition__Group__0 ) | ||
3520 | // InternalSolverLanguage.g:1045:4: rule__MemberDefinition__Group__0 | ||
3521 | { | 3295 | { |
3522 | pushFollow(FOLLOW_2); | 3296 | pushFollow(FOLLOW_2); |
3523 | rule__MemberDefinition__Group__0(); | 3297 | rule__MemberDefinition__Group__0(); |
3524 | 3298 | ||
3525 | state._fsp--; | 3299 | state._fsp--; |
3526 | if (state.failed) return ; | ||
3527 | 3300 | ||
3528 | } | ||
3529 | 3301 | ||
3530 | if ( state.backtracking==0 ) { | ||
3531 | after(grammarAccess.getMemberDefinitionAccess().getGroup()); | ||
3532 | } | 3302 | } |
3533 | 3303 | ||
3304 | after(grammarAccess.getMemberDefinitionAccess().getGroup()); | ||
3305 | |||
3534 | } | 3306 | } |
3535 | 3307 | ||
3536 | 3308 | ||
@@ -3552,24 +3324,20 @@ public class InternalSolverLanguageParser extends AbstractInternalContentAssistP | |||
3552 | 3324 | ||
3553 | 3325 | ||
3554 | // $ANTLR start "entryRuleMultiplicity" | 3326 | // $ANTLR start "entryRuleMultiplicity" |
3555 | // InternalSolverLanguage.g:1054:1: entryRuleMultiplicity : ruleMultiplicity EOF ; | 3327 | // InternalSolverLanguageParser.g:1127:1: entryRuleMultiplicity : ruleMultiplicity EOF ; |
3556 | public final void entryRuleMultiplicity() throws RecognitionException { | 3328 | public final void entryRuleMultiplicity() throws RecognitionException { |
3557 | try { | 3329 | try { |
3558 | // InternalSolverLanguage.g:1055:1: ( ruleMultiplicity EOF ) | 3330 | // InternalSolverLanguageParser.g:1128:1: ( ruleMultiplicity EOF ) |
3559 | // InternalSolverLanguage.g:1056:1: ruleMultiplicity EOF | 3331 | // InternalSolverLanguageParser.g:1129:1: ruleMultiplicity EOF |
3560 | { | 3332 | { |
3561 | if ( state.backtracking==0 ) { | 3333 | before(grammarAccess.getMultiplicityRule()); |
3562 | before(grammarAccess.getMultiplicityRule()); | ||
3563 | } | ||
3564 | pushFollow(FOLLOW_1); | 3334 | pushFollow(FOLLOW_1); |
3565 | ruleMultiplicity(); | 3335 | ruleMultiplicity(); |
3566 | 3336 | ||
3567 | state._fsp--; | 3337 | state._fsp--; |
3568 | if (state.failed) return ; | 3338 | |
3569 | if ( state.backtracking==0 ) { | 3339 | after(grammarAccess.getMultiplicityRule()); |
3570 | after(grammarAccess.getMultiplicityRule()); | 3340 | match(input,EOF,FOLLOW_2); |
3571 | } | ||
3572 | match(input,EOF,FOLLOW_2); if (state.failed) return ; | ||
3573 | 3341 | ||
3574 | } | 3342 | } |
3575 | 3343 | ||
@@ -3586,36 +3354,32 @@ public class InternalSolverLanguageParser extends AbstractInternalContentAssistP | |||
3586 | 3354 | ||
3587 | 3355 | ||
3588 | // $ANTLR start "ruleMultiplicity" | 3356 | // $ANTLR start "ruleMultiplicity" |
3589 | // InternalSolverLanguage.g:1063:1: ruleMultiplicity : ( ( rule__Multiplicity__Alternatives ) ) ; | 3357 | // InternalSolverLanguageParser.g:1136:1: ruleMultiplicity : ( ( rule__Multiplicity__Alternatives ) ) ; |
3590 | public final void ruleMultiplicity() throws RecognitionException { | 3358 | public final void ruleMultiplicity() throws RecognitionException { |
3591 | 3359 | ||
3592 | int stackSize = keepStackSize(); | 3360 | int stackSize = keepStackSize(); |
3593 | 3361 | ||
3594 | try { | 3362 | try { |
3595 | // InternalSolverLanguage.g:1067:2: ( ( ( rule__Multiplicity__Alternatives ) ) ) | 3363 | // InternalSolverLanguageParser.g:1140:2: ( ( ( rule__Multiplicity__Alternatives ) ) ) |
3596 | // InternalSolverLanguage.g:1068:2: ( ( rule__Multiplicity__Alternatives ) ) | 3364 | // InternalSolverLanguageParser.g:1141:2: ( ( rule__Multiplicity__Alternatives ) ) |
3597 | { | 3365 | { |
3598 | // InternalSolverLanguage.g:1068:2: ( ( rule__Multiplicity__Alternatives ) ) | 3366 | // InternalSolverLanguageParser.g:1141:2: ( ( rule__Multiplicity__Alternatives ) ) |
3599 | // InternalSolverLanguage.g:1069:3: ( rule__Multiplicity__Alternatives ) | 3367 | // InternalSolverLanguageParser.g:1142:3: ( rule__Multiplicity__Alternatives ) |
3600 | { | 3368 | { |
3601 | if ( state.backtracking==0 ) { | 3369 | before(grammarAccess.getMultiplicityAccess().getAlternatives()); |
3602 | before(grammarAccess.getMultiplicityAccess().getAlternatives()); | 3370 | // InternalSolverLanguageParser.g:1143:3: ( rule__Multiplicity__Alternatives ) |
3603 | } | 3371 | // InternalSolverLanguageParser.g:1143:4: rule__Multiplicity__Alternatives |
3604 | // InternalSolverLanguage.g:1070:3: ( rule__Multiplicity__Alternatives ) | ||
3605 | // InternalSolverLanguage.g:1070:4: rule__Multiplicity__Alternatives | ||
3606 | { | 3372 | { |
3607 | pushFollow(FOLLOW_2); | 3373 | pushFollow(FOLLOW_2); |
3608 | rule__Multiplicity__Alternatives(); | 3374 | rule__Multiplicity__Alternatives(); |
3609 | 3375 | ||
3610 | state._fsp--; | 3376 | state._fsp--; |
3611 | if (state.failed) return ; | ||
3612 | 3377 | ||
3613 | } | ||
3614 | 3378 | ||
3615 | if ( state.backtracking==0 ) { | ||
3616 | after(grammarAccess.getMultiplicityAccess().getAlternatives()); | ||
3617 | } | 3379 | } |
3618 | 3380 | ||
3381 | after(grammarAccess.getMultiplicityAccess().getAlternatives()); | ||
3382 | |||
3619 | } | 3383 | } |
3620 | 3384 | ||
3621 | 3385 | ||
@@ -3637,24 +3401,20 @@ public class InternalSolverLanguageParser extends AbstractInternalContentAssistP | |||
3637 | 3401 | ||
3638 | 3402 | ||
3639 | // $ANTLR start "entryRuleManyMultiplicity" | 3403 | // $ANTLR start "entryRuleManyMultiplicity" |
3640 | // InternalSolverLanguage.g:1079:1: entryRuleManyMultiplicity : ruleManyMultiplicity EOF ; | 3404 | // InternalSolverLanguageParser.g:1152:1: entryRuleManyMultiplicity : ruleManyMultiplicity EOF ; |
3641 | public final void entryRuleManyMultiplicity() throws RecognitionException { | 3405 | public final void entryRuleManyMultiplicity() throws RecognitionException { |
3642 | try { | 3406 | try { |
3643 | // InternalSolverLanguage.g:1080:1: ( ruleManyMultiplicity EOF ) | 3407 | // InternalSolverLanguageParser.g:1153:1: ( ruleManyMultiplicity EOF ) |
3644 | // InternalSolverLanguage.g:1081:1: ruleManyMultiplicity EOF | 3408 | // InternalSolverLanguageParser.g:1154:1: ruleManyMultiplicity EOF |
3645 | { | 3409 | { |
3646 | if ( state.backtracking==0 ) { | 3410 | before(grammarAccess.getManyMultiplicityRule()); |
3647 | before(grammarAccess.getManyMultiplicityRule()); | ||
3648 | } | ||
3649 | pushFollow(FOLLOW_1); | 3411 | pushFollow(FOLLOW_1); |
3650 | ruleManyMultiplicity(); | 3412 | ruleManyMultiplicity(); |
3651 | 3413 | ||
3652 | state._fsp--; | 3414 | state._fsp--; |
3653 | if (state.failed) return ; | 3415 | |
3654 | if ( state.backtracking==0 ) { | 3416 | after(grammarAccess.getManyMultiplicityRule()); |
3655 | after(grammarAccess.getManyMultiplicityRule()); | 3417 | match(input,EOF,FOLLOW_2); |
3656 | } | ||
3657 | match(input,EOF,FOLLOW_2); if (state.failed) return ; | ||
3658 | 3418 | ||
3659 | } | 3419 | } |
3660 | 3420 | ||
@@ -3671,36 +3431,32 @@ public class InternalSolverLanguageParser extends AbstractInternalContentAssistP | |||
3671 | 3431 | ||
3672 | 3432 | ||
3673 | // $ANTLR start "ruleManyMultiplicity" | 3433 | // $ANTLR start "ruleManyMultiplicity" |
3674 | // InternalSolverLanguage.g:1088:1: ruleManyMultiplicity : ( ( rule__ManyMultiplicity__Group__0 ) ) ; | 3434 | // InternalSolverLanguageParser.g:1161:1: ruleManyMultiplicity : ( ( rule__ManyMultiplicity__Group__0 ) ) ; |
3675 | public final void ruleManyMultiplicity() throws RecognitionException { | 3435 | public final void ruleManyMultiplicity() throws RecognitionException { |
3676 | 3436 | ||
3677 | int stackSize = keepStackSize(); | 3437 | int stackSize = keepStackSize(); |
3678 | 3438 | ||
3679 | try { | 3439 | try { |
3680 | // InternalSolverLanguage.g:1092:2: ( ( ( rule__ManyMultiplicity__Group__0 ) ) ) | 3440 | // InternalSolverLanguageParser.g:1165:2: ( ( ( rule__ManyMultiplicity__Group__0 ) ) ) |
3681 | // InternalSolverLanguage.g:1093:2: ( ( rule__ManyMultiplicity__Group__0 ) ) | 3441 | // InternalSolverLanguageParser.g:1166:2: ( ( rule__ManyMultiplicity__Group__0 ) ) |
3682 | { | 3442 | { |
3683 | // InternalSolverLanguage.g:1093:2: ( ( rule__ManyMultiplicity__Group__0 ) ) | 3443 | // InternalSolverLanguageParser.g:1166:2: ( ( rule__ManyMultiplicity__Group__0 ) ) |
3684 | // InternalSolverLanguage.g:1094:3: ( rule__ManyMultiplicity__Group__0 ) | 3444 | // InternalSolverLanguageParser.g:1167:3: ( rule__ManyMultiplicity__Group__0 ) |
3685 | { | 3445 | { |
3686 | if ( state.backtracking==0 ) { | 3446 | before(grammarAccess.getManyMultiplicityAccess().getGroup()); |
3687 | before(grammarAccess.getManyMultiplicityAccess().getGroup()); | 3447 | // InternalSolverLanguageParser.g:1168:3: ( rule__ManyMultiplicity__Group__0 ) |
3688 | } | 3448 | // InternalSolverLanguageParser.g:1168:4: rule__ManyMultiplicity__Group__0 |
3689 | // InternalSolverLanguage.g:1095:3: ( rule__ManyMultiplicity__Group__0 ) | ||
3690 | // InternalSolverLanguage.g:1095:4: rule__ManyMultiplicity__Group__0 | ||
3691 | { | 3449 | { |
3692 | pushFollow(FOLLOW_2); | 3450 | pushFollow(FOLLOW_2); |
3693 | rule__ManyMultiplicity__Group__0(); | 3451 | rule__ManyMultiplicity__Group__0(); |
3694 | 3452 | ||
3695 | state._fsp--; | 3453 | state._fsp--; |
3696 | if (state.failed) return ; | ||
3697 | 3454 | ||
3698 | } | ||
3699 | 3455 | ||
3700 | if ( state.backtracking==0 ) { | ||
3701 | after(grammarAccess.getManyMultiplicityAccess().getGroup()); | ||
3702 | } | 3456 | } |
3703 | 3457 | ||
3458 | after(grammarAccess.getManyMultiplicityAccess().getGroup()); | ||
3459 | |||
3704 | } | 3460 | } |
3705 | 3461 | ||
3706 | 3462 | ||
@@ -3722,24 +3478,20 @@ public class InternalSolverLanguageParser extends AbstractInternalContentAssistP | |||
3722 | 3478 | ||
3723 | 3479 | ||
3724 | // $ANTLR start "entryRuleExactMultiplicity" | 3480 | // $ANTLR start "entryRuleExactMultiplicity" |
3725 | // InternalSolverLanguage.g:1104:1: entryRuleExactMultiplicity : ruleExactMultiplicity EOF ; | 3481 | // InternalSolverLanguageParser.g:1177:1: entryRuleExactMultiplicity : ruleExactMultiplicity EOF ; |
3726 | public final void entryRuleExactMultiplicity() throws RecognitionException { | 3482 | public final void entryRuleExactMultiplicity() throws RecognitionException { |
3727 | try { | 3483 | try { |
3728 | // InternalSolverLanguage.g:1105:1: ( ruleExactMultiplicity EOF ) | 3484 | // InternalSolverLanguageParser.g:1178:1: ( ruleExactMultiplicity EOF ) |
3729 | // InternalSolverLanguage.g:1106:1: ruleExactMultiplicity EOF | 3485 | // InternalSolverLanguageParser.g:1179:1: ruleExactMultiplicity EOF |
3730 | { | 3486 | { |
3731 | if ( state.backtracking==0 ) { | 3487 | before(grammarAccess.getExactMultiplicityRule()); |
3732 | before(grammarAccess.getExactMultiplicityRule()); | ||
3733 | } | ||
3734 | pushFollow(FOLLOW_1); | 3488 | pushFollow(FOLLOW_1); |
3735 | ruleExactMultiplicity(); | 3489 | ruleExactMultiplicity(); |
3736 | 3490 | ||
3737 | state._fsp--; | 3491 | state._fsp--; |
3738 | if (state.failed) return ; | 3492 | |
3739 | if ( state.backtracking==0 ) { | 3493 | after(grammarAccess.getExactMultiplicityRule()); |
3740 | after(grammarAccess.getExactMultiplicityRule()); | 3494 | match(input,EOF,FOLLOW_2); |
3741 | } | ||
3742 | match(input,EOF,FOLLOW_2); if (state.failed) return ; | ||
3743 | 3495 | ||
3744 | } | 3496 | } |
3745 | 3497 | ||
@@ -3756,36 +3508,32 @@ public class InternalSolverLanguageParser extends AbstractInternalContentAssistP | |||
3756 | 3508 | ||
3757 | 3509 | ||
3758 | // $ANTLR start "ruleExactMultiplicity" | 3510 | // $ANTLR start "ruleExactMultiplicity" |
3759 | // InternalSolverLanguage.g:1113:1: ruleExactMultiplicity : ( ( rule__ExactMultiplicity__Group__0 ) ) ; | 3511 | // InternalSolverLanguageParser.g:1186:1: ruleExactMultiplicity : ( ( rule__ExactMultiplicity__Group__0 ) ) ; |
3760 | public final void ruleExactMultiplicity() throws RecognitionException { | 3512 | public final void ruleExactMultiplicity() throws RecognitionException { |
3761 | 3513 | ||
3762 | int stackSize = keepStackSize(); | 3514 | int stackSize = keepStackSize(); |
3763 | 3515 | ||
3764 | try { | 3516 | try { |
3765 | // InternalSolverLanguage.g:1117:2: ( ( ( rule__ExactMultiplicity__Group__0 ) ) ) | 3517 | // InternalSolverLanguageParser.g:1190:2: ( ( ( rule__ExactMultiplicity__Group__0 ) ) ) |
3766 | // InternalSolverLanguage.g:1118:2: ( ( rule__ExactMultiplicity__Group__0 ) ) | 3518 | // InternalSolverLanguageParser.g:1191:2: ( ( rule__ExactMultiplicity__Group__0 ) ) |
3767 | { | 3519 | { |
3768 | // InternalSolverLanguage.g:1118:2: ( ( rule__ExactMultiplicity__Group__0 ) ) | 3520 | // InternalSolverLanguageParser.g:1191:2: ( ( rule__ExactMultiplicity__Group__0 ) ) |
3769 | // InternalSolverLanguage.g:1119:3: ( rule__ExactMultiplicity__Group__0 ) | 3521 | // InternalSolverLanguageParser.g:1192:3: ( rule__ExactMultiplicity__Group__0 ) |
3770 | { | 3522 | { |
3771 | if ( state.backtracking==0 ) { | 3523 | before(grammarAccess.getExactMultiplicityAccess().getGroup()); |
3772 | before(grammarAccess.getExactMultiplicityAccess().getGroup()); | 3524 | // InternalSolverLanguageParser.g:1193:3: ( rule__ExactMultiplicity__Group__0 ) |
3773 | } | 3525 | // InternalSolverLanguageParser.g:1193:4: rule__ExactMultiplicity__Group__0 |
3774 | // InternalSolverLanguage.g:1120:3: ( rule__ExactMultiplicity__Group__0 ) | ||
3775 | // InternalSolverLanguage.g:1120:4: rule__ExactMultiplicity__Group__0 | ||
3776 | { | 3526 | { |
3777 | pushFollow(FOLLOW_2); | 3527 | pushFollow(FOLLOW_2); |
3778 | rule__ExactMultiplicity__Group__0(); | 3528 | rule__ExactMultiplicity__Group__0(); |
3779 | 3529 | ||
3780 | state._fsp--; | 3530 | state._fsp--; |
3781 | if (state.failed) return ; | ||
3782 | 3531 | ||
3783 | } | ||
3784 | 3532 | ||
3785 | if ( state.backtracking==0 ) { | ||
3786 | after(grammarAccess.getExactMultiplicityAccess().getGroup()); | ||
3787 | } | 3533 | } |
3788 | 3534 | ||
3535 | after(grammarAccess.getExactMultiplicityAccess().getGroup()); | ||
3536 | |||
3789 | } | 3537 | } |
3790 | 3538 | ||
3791 | 3539 | ||
@@ -3807,24 +3555,20 @@ public class InternalSolverLanguageParser extends AbstractInternalContentAssistP | |||
3807 | 3555 | ||
3808 | 3556 | ||
3809 | // $ANTLR start "entryRuleBoundedMultiplicity" | 3557 | // $ANTLR start "entryRuleBoundedMultiplicity" |
3810 | // InternalSolverLanguage.g:1129:1: entryRuleBoundedMultiplicity : ruleBoundedMultiplicity EOF ; | 3558 | // InternalSolverLanguageParser.g:1202:1: entryRuleBoundedMultiplicity : ruleBoundedMultiplicity EOF ; |
3811 | public final void entryRuleBoundedMultiplicity() throws RecognitionException { | 3559 | public final void entryRuleBoundedMultiplicity() throws RecognitionException { |
3812 | try { | 3560 | try { |
3813 | // InternalSolverLanguage.g:1130:1: ( ruleBoundedMultiplicity EOF ) | 3561 | // InternalSolverLanguageParser.g:1203:1: ( ruleBoundedMultiplicity EOF ) |
3814 | // InternalSolverLanguage.g:1131:1: ruleBoundedMultiplicity EOF | 3562 | // InternalSolverLanguageParser.g:1204:1: ruleBoundedMultiplicity EOF |
3815 | { | 3563 | { |
3816 | if ( state.backtracking==0 ) { | 3564 | before(grammarAccess.getBoundedMultiplicityRule()); |
3817 | before(grammarAccess.getBoundedMultiplicityRule()); | ||
3818 | } | ||
3819 | pushFollow(FOLLOW_1); | 3565 | pushFollow(FOLLOW_1); |
3820 | ruleBoundedMultiplicity(); | 3566 | ruleBoundedMultiplicity(); |
3821 | 3567 | ||
3822 | state._fsp--; | 3568 | state._fsp--; |
3823 | if (state.failed) return ; | 3569 | |
3824 | if ( state.backtracking==0 ) { | 3570 | after(grammarAccess.getBoundedMultiplicityRule()); |
3825 | after(grammarAccess.getBoundedMultiplicityRule()); | 3571 | match(input,EOF,FOLLOW_2); |
3826 | } | ||
3827 | match(input,EOF,FOLLOW_2); if (state.failed) return ; | ||
3828 | 3572 | ||
3829 | } | 3573 | } |
3830 | 3574 | ||
@@ -3841,36 +3585,32 @@ public class InternalSolverLanguageParser extends AbstractInternalContentAssistP | |||
3841 | 3585 | ||
3842 | 3586 | ||
3843 | // $ANTLR start "ruleBoundedMultiplicity" | 3587 | // $ANTLR start "ruleBoundedMultiplicity" |
3844 | // InternalSolverLanguage.g:1138:1: ruleBoundedMultiplicity : ( ( rule__BoundedMultiplicity__Group__0 ) ) ; | 3588 | // InternalSolverLanguageParser.g:1211:1: ruleBoundedMultiplicity : ( ( rule__BoundedMultiplicity__Group__0 ) ) ; |
3845 | public final void ruleBoundedMultiplicity() throws RecognitionException { | 3589 | public final void ruleBoundedMultiplicity() throws RecognitionException { |
3846 | 3590 | ||
3847 | int stackSize = keepStackSize(); | 3591 | int stackSize = keepStackSize(); |
3848 | 3592 | ||
3849 | try { | 3593 | try { |
3850 | // InternalSolverLanguage.g:1142:2: ( ( ( rule__BoundedMultiplicity__Group__0 ) ) ) | 3594 | // InternalSolverLanguageParser.g:1215:2: ( ( ( rule__BoundedMultiplicity__Group__0 ) ) ) |
3851 | // InternalSolverLanguage.g:1143:2: ( ( rule__BoundedMultiplicity__Group__0 ) ) | 3595 | // InternalSolverLanguageParser.g:1216:2: ( ( rule__BoundedMultiplicity__Group__0 ) ) |
3852 | { | 3596 | { |
3853 | // InternalSolverLanguage.g:1143:2: ( ( rule__BoundedMultiplicity__Group__0 ) ) | 3597 | // InternalSolverLanguageParser.g:1216:2: ( ( rule__BoundedMultiplicity__Group__0 ) ) |
3854 | // InternalSolverLanguage.g:1144:3: ( rule__BoundedMultiplicity__Group__0 ) | 3598 | // InternalSolverLanguageParser.g:1217:3: ( rule__BoundedMultiplicity__Group__0 ) |
3855 | { | 3599 | { |
3856 | if ( state.backtracking==0 ) { | 3600 | before(grammarAccess.getBoundedMultiplicityAccess().getGroup()); |
3857 | before(grammarAccess.getBoundedMultiplicityAccess().getGroup()); | 3601 | // InternalSolverLanguageParser.g:1218:3: ( rule__BoundedMultiplicity__Group__0 ) |
3858 | } | 3602 | // InternalSolverLanguageParser.g:1218:4: rule__BoundedMultiplicity__Group__0 |
3859 | // InternalSolverLanguage.g:1145:3: ( rule__BoundedMultiplicity__Group__0 ) | ||
3860 | // InternalSolverLanguage.g:1145:4: rule__BoundedMultiplicity__Group__0 | ||
3861 | { | 3603 | { |
3862 | pushFollow(FOLLOW_2); | 3604 | pushFollow(FOLLOW_2); |
3863 | rule__BoundedMultiplicity__Group__0(); | 3605 | rule__BoundedMultiplicity__Group__0(); |
3864 | 3606 | ||
3865 | state._fsp--; | 3607 | state._fsp--; |
3866 | if (state.failed) return ; | ||
3867 | 3608 | ||
3868 | } | ||
3869 | 3609 | ||
3870 | if ( state.backtracking==0 ) { | ||
3871 | after(grammarAccess.getBoundedMultiplicityAccess().getGroup()); | ||
3872 | } | 3610 | } |
3873 | 3611 | ||
3612 | after(grammarAccess.getBoundedMultiplicityAccess().getGroup()); | ||
3613 | |||
3874 | } | 3614 | } |
3875 | 3615 | ||
3876 | 3616 | ||
@@ -3892,24 +3632,20 @@ public class InternalSolverLanguageParser extends AbstractInternalContentAssistP | |||
3892 | 3632 | ||
3893 | 3633 | ||
3894 | // $ANTLR start "entryRuleScopeDefinition" | 3634 | // $ANTLR start "entryRuleScopeDefinition" |
3895 | // InternalSolverLanguage.g:1154:1: entryRuleScopeDefinition : ruleScopeDefinition EOF ; | 3635 | // InternalSolverLanguageParser.g:1227:1: entryRuleScopeDefinition : ruleScopeDefinition EOF ; |
3896 | public final void entryRuleScopeDefinition() throws RecognitionException { | 3636 | public final void entryRuleScopeDefinition() throws RecognitionException { |
3897 | try { | 3637 | try { |
3898 | // InternalSolverLanguage.g:1155:1: ( ruleScopeDefinition EOF ) | 3638 | // InternalSolverLanguageParser.g:1228:1: ( ruleScopeDefinition EOF ) |
3899 | // InternalSolverLanguage.g:1156:1: ruleScopeDefinition EOF | 3639 | // InternalSolverLanguageParser.g:1229:1: ruleScopeDefinition EOF |
3900 | { | 3640 | { |
3901 | if ( state.backtracking==0 ) { | 3641 | before(grammarAccess.getScopeDefinitionRule()); |
3902 | before(grammarAccess.getScopeDefinitionRule()); | ||
3903 | } | ||
3904 | pushFollow(FOLLOW_1); | 3642 | pushFollow(FOLLOW_1); |
3905 | ruleScopeDefinition(); | 3643 | ruleScopeDefinition(); |
3906 | 3644 | ||
3907 | state._fsp--; | 3645 | state._fsp--; |
3908 | if (state.failed) return ; | 3646 | |
3909 | if ( state.backtracking==0 ) { | 3647 | after(grammarAccess.getScopeDefinitionRule()); |
3910 | after(grammarAccess.getScopeDefinitionRule()); | 3648 | match(input,EOF,FOLLOW_2); |
3911 | } | ||
3912 | match(input,EOF,FOLLOW_2); if (state.failed) return ; | ||
3913 | 3649 | ||
3914 | } | 3650 | } |
3915 | 3651 | ||
@@ -3926,36 +3662,32 @@ public class InternalSolverLanguageParser extends AbstractInternalContentAssistP | |||
3926 | 3662 | ||
3927 | 3663 | ||
3928 | // $ANTLR start "ruleScopeDefinition" | 3664 | // $ANTLR start "ruleScopeDefinition" |
3929 | // InternalSolverLanguage.g:1163:1: ruleScopeDefinition : ( ( rule__ScopeDefinition__Alternatives ) ) ; | 3665 | // InternalSolverLanguageParser.g:1236:1: ruleScopeDefinition : ( ( rule__ScopeDefinition__Alternatives ) ) ; |
3930 | public final void ruleScopeDefinition() throws RecognitionException { | 3666 | public final void ruleScopeDefinition() throws RecognitionException { |
3931 | 3667 | ||
3932 | int stackSize = keepStackSize(); | 3668 | int stackSize = keepStackSize(); |
3933 | 3669 | ||
3934 | try { | 3670 | try { |
3935 | // InternalSolverLanguage.g:1167:2: ( ( ( rule__ScopeDefinition__Alternatives ) ) ) | 3671 | // InternalSolverLanguageParser.g:1240:2: ( ( ( rule__ScopeDefinition__Alternatives ) ) ) |
3936 | // InternalSolverLanguage.g:1168:2: ( ( rule__ScopeDefinition__Alternatives ) ) | 3672 | // InternalSolverLanguageParser.g:1241:2: ( ( rule__ScopeDefinition__Alternatives ) ) |
3937 | { | 3673 | { |
3938 | // InternalSolverLanguage.g:1168:2: ( ( rule__ScopeDefinition__Alternatives ) ) | 3674 | // InternalSolverLanguageParser.g:1241:2: ( ( rule__ScopeDefinition__Alternatives ) ) |
3939 | // InternalSolverLanguage.g:1169:3: ( rule__ScopeDefinition__Alternatives ) | 3675 | // InternalSolverLanguageParser.g:1242:3: ( rule__ScopeDefinition__Alternatives ) |
3940 | { | 3676 | { |
3941 | if ( state.backtracking==0 ) { | 3677 | before(grammarAccess.getScopeDefinitionAccess().getAlternatives()); |
3942 | before(grammarAccess.getScopeDefinitionAccess().getAlternatives()); | 3678 | // InternalSolverLanguageParser.g:1243:3: ( rule__ScopeDefinition__Alternatives ) |
3943 | } | 3679 | // InternalSolverLanguageParser.g:1243:4: rule__ScopeDefinition__Alternatives |
3944 | // InternalSolverLanguage.g:1170:3: ( rule__ScopeDefinition__Alternatives ) | ||
3945 | // InternalSolverLanguage.g:1170:4: rule__ScopeDefinition__Alternatives | ||
3946 | { | 3680 | { |
3947 | pushFollow(FOLLOW_2); | 3681 | pushFollow(FOLLOW_2); |
3948 | rule__ScopeDefinition__Alternatives(); | 3682 | rule__ScopeDefinition__Alternatives(); |
3949 | 3683 | ||
3950 | state._fsp--; | 3684 | state._fsp--; |
3951 | if (state.failed) return ; | ||
3952 | 3685 | ||
3953 | } | ||
3954 | 3686 | ||
3955 | if ( state.backtracking==0 ) { | ||
3956 | after(grammarAccess.getScopeDefinitionAccess().getAlternatives()); | ||
3957 | } | 3687 | } |
3958 | 3688 | ||
3689 | after(grammarAccess.getScopeDefinitionAccess().getAlternatives()); | ||
3690 | |||
3959 | } | 3691 | } |
3960 | 3692 | ||
3961 | 3693 | ||
@@ -3977,24 +3709,20 @@ public class InternalSolverLanguageParser extends AbstractInternalContentAssistP | |||
3977 | 3709 | ||
3978 | 3710 | ||
3979 | // $ANTLR start "entryRuleExactScopeDefinition" | 3711 | // $ANTLR start "entryRuleExactScopeDefinition" |
3980 | // InternalSolverLanguage.g:1179:1: entryRuleExactScopeDefinition : ruleExactScopeDefinition EOF ; | 3712 | // InternalSolverLanguageParser.g:1252:1: entryRuleExactScopeDefinition : ruleExactScopeDefinition EOF ; |
3981 | public final void entryRuleExactScopeDefinition() throws RecognitionException { | 3713 | public final void entryRuleExactScopeDefinition() throws RecognitionException { |
3982 | try { | 3714 | try { |
3983 | // InternalSolverLanguage.g:1180:1: ( ruleExactScopeDefinition EOF ) | 3715 | // InternalSolverLanguageParser.g:1253:1: ( ruleExactScopeDefinition EOF ) |
3984 | // InternalSolverLanguage.g:1181:1: ruleExactScopeDefinition EOF | 3716 | // InternalSolverLanguageParser.g:1254:1: ruleExactScopeDefinition EOF |
3985 | { | 3717 | { |
3986 | if ( state.backtracking==0 ) { | 3718 | before(grammarAccess.getExactScopeDefinitionRule()); |
3987 | before(grammarAccess.getExactScopeDefinitionRule()); | ||
3988 | } | ||
3989 | pushFollow(FOLLOW_1); | 3719 | pushFollow(FOLLOW_1); |
3990 | ruleExactScopeDefinition(); | 3720 | ruleExactScopeDefinition(); |
3991 | 3721 | ||
3992 | state._fsp--; | 3722 | state._fsp--; |
3993 | if (state.failed) return ; | 3723 | |
3994 | if ( state.backtracking==0 ) { | 3724 | after(grammarAccess.getExactScopeDefinitionRule()); |
3995 | after(grammarAccess.getExactScopeDefinitionRule()); | 3725 | match(input,EOF,FOLLOW_2); |
3996 | } | ||
3997 | match(input,EOF,FOLLOW_2); if (state.failed) return ; | ||
3998 | 3726 | ||
3999 | } | 3727 | } |
4000 | 3728 | ||
@@ -4011,36 +3739,32 @@ public class InternalSolverLanguageParser extends AbstractInternalContentAssistP | |||
4011 | 3739 | ||
4012 | 3740 | ||
4013 | // $ANTLR start "ruleExactScopeDefinition" | 3741 | // $ANTLR start "ruleExactScopeDefinition" |
4014 | // InternalSolverLanguage.g:1188:1: ruleExactScopeDefinition : ( ( rule__ExactScopeDefinition__Group__0 ) ) ; | 3742 | // InternalSolverLanguageParser.g:1261:1: ruleExactScopeDefinition : ( ( rule__ExactScopeDefinition__Group__0 ) ) ; |
4015 | public final void ruleExactScopeDefinition() throws RecognitionException { | 3743 | public final void ruleExactScopeDefinition() throws RecognitionException { |
4016 | 3744 | ||
4017 | int stackSize = keepStackSize(); | 3745 | int stackSize = keepStackSize(); |
4018 | 3746 | ||
4019 | try { | 3747 | try { |
4020 | // InternalSolverLanguage.g:1192:2: ( ( ( rule__ExactScopeDefinition__Group__0 ) ) ) | 3748 | // InternalSolverLanguageParser.g:1265:2: ( ( ( rule__ExactScopeDefinition__Group__0 ) ) ) |
4021 | // InternalSolverLanguage.g:1193:2: ( ( rule__ExactScopeDefinition__Group__0 ) ) | 3749 | // InternalSolverLanguageParser.g:1266:2: ( ( rule__ExactScopeDefinition__Group__0 ) ) |
4022 | { | 3750 | { |
4023 | // InternalSolverLanguage.g:1193:2: ( ( rule__ExactScopeDefinition__Group__0 ) ) | 3751 | // InternalSolverLanguageParser.g:1266:2: ( ( rule__ExactScopeDefinition__Group__0 ) ) |
4024 | // InternalSolverLanguage.g:1194:3: ( rule__ExactScopeDefinition__Group__0 ) | 3752 | // InternalSolverLanguageParser.g:1267:3: ( rule__ExactScopeDefinition__Group__0 ) |
4025 | { | 3753 | { |
4026 | if ( state.backtracking==0 ) { | 3754 | before(grammarAccess.getExactScopeDefinitionAccess().getGroup()); |
4027 | before(grammarAccess.getExactScopeDefinitionAccess().getGroup()); | 3755 | // InternalSolverLanguageParser.g:1268:3: ( rule__ExactScopeDefinition__Group__0 ) |
4028 | } | 3756 | // InternalSolverLanguageParser.g:1268:4: rule__ExactScopeDefinition__Group__0 |
4029 | // InternalSolverLanguage.g:1195:3: ( rule__ExactScopeDefinition__Group__0 ) | ||
4030 | // InternalSolverLanguage.g:1195:4: rule__ExactScopeDefinition__Group__0 | ||
4031 | { | 3757 | { |
4032 | pushFollow(FOLLOW_2); | 3758 | pushFollow(FOLLOW_2); |
4033 | rule__ExactScopeDefinition__Group__0(); | 3759 | rule__ExactScopeDefinition__Group__0(); |
4034 | 3760 | ||
4035 | state._fsp--; | 3761 | state._fsp--; |
4036 | if (state.failed) return ; | ||
4037 | 3762 | ||
4038 | } | ||
4039 | 3763 | ||
4040 | if ( state.backtracking==0 ) { | ||
4041 | after(grammarAccess.getExactScopeDefinitionAccess().getGroup()); | ||
4042 | } | 3764 | } |
4043 | 3765 | ||
3766 | after(grammarAccess.getExactScopeDefinitionAccess().getGroup()); | ||
3767 | |||
4044 | } | 3768 | } |
4045 | 3769 | ||
4046 | 3770 | ||
@@ -4062,24 +3786,20 @@ public class InternalSolverLanguageParser extends AbstractInternalContentAssistP | |||
4062 | 3786 | ||
4063 | 3787 | ||
4064 | // $ANTLR start "entryRuleBoundedScopeDefinition" | 3788 | // $ANTLR start "entryRuleBoundedScopeDefinition" |
4065 | // InternalSolverLanguage.g:1204:1: entryRuleBoundedScopeDefinition : ruleBoundedScopeDefinition EOF ; | 3789 | // InternalSolverLanguageParser.g:1277:1: entryRuleBoundedScopeDefinition : ruleBoundedScopeDefinition EOF ; |
4066 | public final void entryRuleBoundedScopeDefinition() throws RecognitionException { | 3790 | public final void entryRuleBoundedScopeDefinition() throws RecognitionException { |
4067 | try { | 3791 | try { |
4068 | // InternalSolverLanguage.g:1205:1: ( ruleBoundedScopeDefinition EOF ) | 3792 | // InternalSolverLanguageParser.g:1278:1: ( ruleBoundedScopeDefinition EOF ) |
4069 | // InternalSolverLanguage.g:1206:1: ruleBoundedScopeDefinition EOF | 3793 | // InternalSolverLanguageParser.g:1279:1: ruleBoundedScopeDefinition EOF |
4070 | { | 3794 | { |
4071 | if ( state.backtracking==0 ) { | 3795 | before(grammarAccess.getBoundedScopeDefinitionRule()); |
4072 | before(grammarAccess.getBoundedScopeDefinitionRule()); | ||
4073 | } | ||
4074 | pushFollow(FOLLOW_1); | 3796 | pushFollow(FOLLOW_1); |
4075 | ruleBoundedScopeDefinition(); | 3797 | ruleBoundedScopeDefinition(); |
4076 | 3798 | ||
4077 | state._fsp--; | 3799 | state._fsp--; |
4078 | if (state.failed) return ; | 3800 | |
4079 | if ( state.backtracking==0 ) { | 3801 | after(grammarAccess.getBoundedScopeDefinitionRule()); |
4080 | after(grammarAccess.getBoundedScopeDefinitionRule()); | 3802 | match(input,EOF,FOLLOW_2); |
4081 | } | ||
4082 | match(input,EOF,FOLLOW_2); if (state.failed) return ; | ||
4083 | 3803 | ||
4084 | } | 3804 | } |
4085 | 3805 | ||
@@ -4096,36 +3816,32 @@ public class InternalSolverLanguageParser extends AbstractInternalContentAssistP | |||
4096 | 3816 | ||
4097 | 3817 | ||
4098 | // $ANTLR start "ruleBoundedScopeDefinition" | 3818 | // $ANTLR start "ruleBoundedScopeDefinition" |
4099 | // InternalSolverLanguage.g:1213:1: ruleBoundedScopeDefinition : ( ( rule__BoundedScopeDefinition__Group__0 ) ) ; | 3819 | // InternalSolverLanguageParser.g:1286:1: ruleBoundedScopeDefinition : ( ( rule__BoundedScopeDefinition__Group__0 ) ) ; |
4100 | public final void ruleBoundedScopeDefinition() throws RecognitionException { | 3820 | public final void ruleBoundedScopeDefinition() throws RecognitionException { |
4101 | 3821 | ||
4102 | int stackSize = keepStackSize(); | 3822 | int stackSize = keepStackSize(); |
4103 | 3823 | ||
4104 | try { | 3824 | try { |
4105 | // InternalSolverLanguage.g:1217:2: ( ( ( rule__BoundedScopeDefinition__Group__0 ) ) ) | 3825 | // InternalSolverLanguageParser.g:1290:2: ( ( ( rule__BoundedScopeDefinition__Group__0 ) ) ) |
4106 | // InternalSolverLanguage.g:1218:2: ( ( rule__BoundedScopeDefinition__Group__0 ) ) | 3826 | // InternalSolverLanguageParser.g:1291:2: ( ( rule__BoundedScopeDefinition__Group__0 ) ) |
4107 | { | 3827 | { |
4108 | // InternalSolverLanguage.g:1218:2: ( ( rule__BoundedScopeDefinition__Group__0 ) ) | 3828 | // InternalSolverLanguageParser.g:1291:2: ( ( rule__BoundedScopeDefinition__Group__0 ) ) |
4109 | // InternalSolverLanguage.g:1219:3: ( rule__BoundedScopeDefinition__Group__0 ) | 3829 | // InternalSolverLanguageParser.g:1292:3: ( rule__BoundedScopeDefinition__Group__0 ) |
4110 | { | 3830 | { |
4111 | if ( state.backtracking==0 ) { | 3831 | before(grammarAccess.getBoundedScopeDefinitionAccess().getGroup()); |
4112 | before(grammarAccess.getBoundedScopeDefinitionAccess().getGroup()); | 3832 | // InternalSolverLanguageParser.g:1293:3: ( rule__BoundedScopeDefinition__Group__0 ) |
4113 | } | 3833 | // InternalSolverLanguageParser.g:1293:4: rule__BoundedScopeDefinition__Group__0 |
4114 | // InternalSolverLanguage.g:1220:3: ( rule__BoundedScopeDefinition__Group__0 ) | ||
4115 | // InternalSolverLanguage.g:1220:4: rule__BoundedScopeDefinition__Group__0 | ||
4116 | { | 3834 | { |
4117 | pushFollow(FOLLOW_2); | 3835 | pushFollow(FOLLOW_2); |
4118 | rule__BoundedScopeDefinition__Group__0(); | 3836 | rule__BoundedScopeDefinition__Group__0(); |
4119 | 3837 | ||
4120 | state._fsp--; | 3838 | state._fsp--; |
4121 | if (state.failed) return ; | ||
4122 | 3839 | ||
4123 | } | ||
4124 | 3840 | ||
4125 | if ( state.backtracking==0 ) { | ||
4126 | after(grammarAccess.getBoundedScopeDefinitionAccess().getGroup()); | ||
4127 | } | 3841 | } |
4128 | 3842 | ||
3843 | after(grammarAccess.getBoundedScopeDefinitionAccess().getGroup()); | ||
3844 | |||
4129 | } | 3845 | } |
4130 | 3846 | ||
4131 | 3847 | ||
@@ -4147,24 +3863,20 @@ public class InternalSolverLanguageParser extends AbstractInternalContentAssistP | |||
4147 | 3863 | ||
4148 | 3864 | ||
4149 | // $ANTLR start "entryRuleLowerBoundedScopeDefinition" | 3865 | // $ANTLR start "entryRuleLowerBoundedScopeDefinition" |
4150 | // InternalSolverLanguage.g:1229:1: entryRuleLowerBoundedScopeDefinition : ruleLowerBoundedScopeDefinition EOF ; | 3866 | // InternalSolverLanguageParser.g:1302:1: entryRuleLowerBoundedScopeDefinition : ruleLowerBoundedScopeDefinition EOF ; |
4151 | public final void entryRuleLowerBoundedScopeDefinition() throws RecognitionException { | 3867 | public final void entryRuleLowerBoundedScopeDefinition() throws RecognitionException { |
4152 | try { | 3868 | try { |
4153 | // InternalSolverLanguage.g:1230:1: ( ruleLowerBoundedScopeDefinition EOF ) | 3869 | // InternalSolverLanguageParser.g:1303:1: ( ruleLowerBoundedScopeDefinition EOF ) |
4154 | // InternalSolverLanguage.g:1231:1: ruleLowerBoundedScopeDefinition EOF | 3870 | // InternalSolverLanguageParser.g:1304:1: ruleLowerBoundedScopeDefinition EOF |
4155 | { | 3871 | { |
4156 | if ( state.backtracking==0 ) { | 3872 | before(grammarAccess.getLowerBoundedScopeDefinitionRule()); |
4157 | before(grammarAccess.getLowerBoundedScopeDefinitionRule()); | ||
4158 | } | ||
4159 | pushFollow(FOLLOW_1); | 3873 | pushFollow(FOLLOW_1); |
4160 | ruleLowerBoundedScopeDefinition(); | 3874 | ruleLowerBoundedScopeDefinition(); |
4161 | 3875 | ||
4162 | state._fsp--; | 3876 | state._fsp--; |
4163 | if (state.failed) return ; | 3877 | |
4164 | if ( state.backtracking==0 ) { | 3878 | after(grammarAccess.getLowerBoundedScopeDefinitionRule()); |
4165 | after(grammarAccess.getLowerBoundedScopeDefinitionRule()); | 3879 | match(input,EOF,FOLLOW_2); |
4166 | } | ||
4167 | match(input,EOF,FOLLOW_2); if (state.failed) return ; | ||
4168 | 3880 | ||
4169 | } | 3881 | } |
4170 | 3882 | ||
@@ -4181,36 +3893,32 @@ public class InternalSolverLanguageParser extends AbstractInternalContentAssistP | |||
4181 | 3893 | ||
4182 | 3894 | ||
4183 | // $ANTLR start "ruleLowerBoundedScopeDefinition" | 3895 | // $ANTLR start "ruleLowerBoundedScopeDefinition" |
4184 | // InternalSolverLanguage.g:1238:1: ruleLowerBoundedScopeDefinition : ( ( rule__LowerBoundedScopeDefinition__Group__0 ) ) ; | 3896 | // InternalSolverLanguageParser.g:1311:1: ruleLowerBoundedScopeDefinition : ( ( rule__LowerBoundedScopeDefinition__Group__0 ) ) ; |
4185 | public final void ruleLowerBoundedScopeDefinition() throws RecognitionException { | 3897 | public final void ruleLowerBoundedScopeDefinition() throws RecognitionException { |
4186 | 3898 | ||
4187 | int stackSize = keepStackSize(); | 3899 | int stackSize = keepStackSize(); |
4188 | 3900 | ||
4189 | try { | 3901 | try { |
4190 | // InternalSolverLanguage.g:1242:2: ( ( ( rule__LowerBoundedScopeDefinition__Group__0 ) ) ) | 3902 | // InternalSolverLanguageParser.g:1315:2: ( ( ( rule__LowerBoundedScopeDefinition__Group__0 ) ) ) |
4191 | // InternalSolverLanguage.g:1243:2: ( ( rule__LowerBoundedScopeDefinition__Group__0 ) ) | 3903 | // InternalSolverLanguageParser.g:1316:2: ( ( rule__LowerBoundedScopeDefinition__Group__0 ) ) |
4192 | { | 3904 | { |
4193 | // InternalSolverLanguage.g:1243:2: ( ( rule__LowerBoundedScopeDefinition__Group__0 ) ) | 3905 | // InternalSolverLanguageParser.g:1316:2: ( ( rule__LowerBoundedScopeDefinition__Group__0 ) ) |
4194 | // InternalSolverLanguage.g:1244:3: ( rule__LowerBoundedScopeDefinition__Group__0 ) | 3906 | // InternalSolverLanguageParser.g:1317:3: ( rule__LowerBoundedScopeDefinition__Group__0 ) |
4195 | { | 3907 | { |
4196 | if ( state.backtracking==0 ) { | 3908 | before(grammarAccess.getLowerBoundedScopeDefinitionAccess().getGroup()); |
4197 | before(grammarAccess.getLowerBoundedScopeDefinitionAccess().getGroup()); | 3909 | // InternalSolverLanguageParser.g:1318:3: ( rule__LowerBoundedScopeDefinition__Group__0 ) |
4198 | } | 3910 | // InternalSolverLanguageParser.g:1318:4: rule__LowerBoundedScopeDefinition__Group__0 |
4199 | // InternalSolverLanguage.g:1245:3: ( rule__LowerBoundedScopeDefinition__Group__0 ) | ||
4200 | // InternalSolverLanguage.g:1245:4: rule__LowerBoundedScopeDefinition__Group__0 | ||
4201 | { | 3911 | { |
4202 | pushFollow(FOLLOW_2); | 3912 | pushFollow(FOLLOW_2); |
4203 | rule__LowerBoundedScopeDefinition__Group__0(); | 3913 | rule__LowerBoundedScopeDefinition__Group__0(); |
4204 | 3914 | ||
4205 | state._fsp--; | 3915 | state._fsp--; |
4206 | if (state.failed) return ; | ||
4207 | 3916 | ||
4208 | } | ||
4209 | 3917 | ||
4210 | if ( state.backtracking==0 ) { | ||
4211 | after(grammarAccess.getLowerBoundedScopeDefinitionAccess().getGroup()); | ||
4212 | } | 3918 | } |
4213 | 3919 | ||
3920 | after(grammarAccess.getLowerBoundedScopeDefinitionAccess().getGroup()); | ||
3921 | |||
4214 | } | 3922 | } |
4215 | 3923 | ||
4216 | 3924 | ||
@@ -4232,24 +3940,20 @@ public class InternalSolverLanguageParser extends AbstractInternalContentAssistP | |||
4232 | 3940 | ||
4233 | 3941 | ||
4234 | // $ANTLR start "entryRuleObjectiveDefinition" | 3942 | // $ANTLR start "entryRuleObjectiveDefinition" |
4235 | // InternalSolverLanguage.g:1254:1: entryRuleObjectiveDefinition : ruleObjectiveDefinition EOF ; | 3943 | // InternalSolverLanguageParser.g:1327:1: entryRuleObjectiveDefinition : ruleObjectiveDefinition EOF ; |
4236 | public final void entryRuleObjectiveDefinition() throws RecognitionException { | 3944 | public final void entryRuleObjectiveDefinition() throws RecognitionException { |
4237 | try { | 3945 | try { |
4238 | // InternalSolverLanguage.g:1255:1: ( ruleObjectiveDefinition EOF ) | 3946 | // InternalSolverLanguageParser.g:1328:1: ( ruleObjectiveDefinition EOF ) |
4239 | // InternalSolverLanguage.g:1256:1: ruleObjectiveDefinition EOF | 3947 | // InternalSolverLanguageParser.g:1329:1: ruleObjectiveDefinition EOF |
4240 | { | 3948 | { |
4241 | if ( state.backtracking==0 ) { | 3949 | before(grammarAccess.getObjectiveDefinitionRule()); |
4242 | before(grammarAccess.getObjectiveDefinitionRule()); | ||
4243 | } | ||
4244 | pushFollow(FOLLOW_1); | 3950 | pushFollow(FOLLOW_1); |
4245 | ruleObjectiveDefinition(); | 3951 | ruleObjectiveDefinition(); |
4246 | 3952 | ||
4247 | state._fsp--; | 3953 | state._fsp--; |
4248 | if (state.failed) return ; | 3954 | |
4249 | if ( state.backtracking==0 ) { | 3955 | after(grammarAccess.getObjectiveDefinitionRule()); |
4250 | after(grammarAccess.getObjectiveDefinitionRule()); | 3956 | match(input,EOF,FOLLOW_2); |
4251 | } | ||
4252 | match(input,EOF,FOLLOW_2); if (state.failed) return ; | ||
4253 | 3957 | ||
4254 | } | 3958 | } |
4255 | 3959 | ||
@@ -4266,36 +3970,32 @@ public class InternalSolverLanguageParser extends AbstractInternalContentAssistP | |||
4266 | 3970 | ||
4267 | 3971 | ||
4268 | // $ANTLR start "ruleObjectiveDefinition" | 3972 | // $ANTLR start "ruleObjectiveDefinition" |
4269 | // InternalSolverLanguage.g:1263:1: ruleObjectiveDefinition : ( ( rule__ObjectiveDefinition__Group__0 ) ) ; | 3973 | // InternalSolverLanguageParser.g:1336:1: ruleObjectiveDefinition : ( ( rule__ObjectiveDefinition__Group__0 ) ) ; |
4270 | public final void ruleObjectiveDefinition() throws RecognitionException { | 3974 | public final void ruleObjectiveDefinition() throws RecognitionException { |
4271 | 3975 | ||
4272 | int stackSize = keepStackSize(); | 3976 | int stackSize = keepStackSize(); |
4273 | 3977 | ||
4274 | try { | 3978 | try { |
4275 | // InternalSolverLanguage.g:1267:2: ( ( ( rule__ObjectiveDefinition__Group__0 ) ) ) | 3979 | // InternalSolverLanguageParser.g:1340:2: ( ( ( rule__ObjectiveDefinition__Group__0 ) ) ) |
4276 | // InternalSolverLanguage.g:1268:2: ( ( rule__ObjectiveDefinition__Group__0 ) ) | 3980 | // InternalSolverLanguageParser.g:1341:2: ( ( rule__ObjectiveDefinition__Group__0 ) ) |
4277 | { | 3981 | { |
4278 | // InternalSolverLanguage.g:1268:2: ( ( rule__ObjectiveDefinition__Group__0 ) ) | 3982 | // InternalSolverLanguageParser.g:1341:2: ( ( rule__ObjectiveDefinition__Group__0 ) ) |
4279 | // InternalSolverLanguage.g:1269:3: ( rule__ObjectiveDefinition__Group__0 ) | 3983 | // InternalSolverLanguageParser.g:1342:3: ( rule__ObjectiveDefinition__Group__0 ) |
4280 | { | 3984 | { |
4281 | if ( state.backtracking==0 ) { | 3985 | before(grammarAccess.getObjectiveDefinitionAccess().getGroup()); |
4282 | before(grammarAccess.getObjectiveDefinitionAccess().getGroup()); | 3986 | // InternalSolverLanguageParser.g:1343:3: ( rule__ObjectiveDefinition__Group__0 ) |
4283 | } | 3987 | // InternalSolverLanguageParser.g:1343:4: rule__ObjectiveDefinition__Group__0 |
4284 | // InternalSolverLanguage.g:1270:3: ( rule__ObjectiveDefinition__Group__0 ) | ||
4285 | // InternalSolverLanguage.g:1270:4: rule__ObjectiveDefinition__Group__0 | ||
4286 | { | 3988 | { |
4287 | pushFollow(FOLLOW_2); | 3989 | pushFollow(FOLLOW_2); |
4288 | rule__ObjectiveDefinition__Group__0(); | 3990 | rule__ObjectiveDefinition__Group__0(); |
4289 | 3991 | ||
4290 | state._fsp--; | 3992 | state._fsp--; |
4291 | if (state.failed) return ; | ||
4292 | 3993 | ||
4293 | } | ||
4294 | 3994 | ||
4295 | if ( state.backtracking==0 ) { | ||
4296 | after(grammarAccess.getObjectiveDefinitionAccess().getGroup()); | ||
4297 | } | 3995 | } |
4298 | 3996 | ||
3997 | after(grammarAccess.getObjectiveDefinitionAccess().getGroup()); | ||
3998 | |||
4299 | } | 3999 | } |
4300 | 4000 | ||
4301 | 4001 | ||
@@ -4317,24 +4017,20 @@ public class InternalSolverLanguageParser extends AbstractInternalContentAssistP | |||
4317 | 4017 | ||
4318 | 4018 | ||
4319 | // $ANTLR start "entryRuleUpperMultiplicty" | 4019 | // $ANTLR start "entryRuleUpperMultiplicty" |
4320 | // InternalSolverLanguage.g:1279:1: entryRuleUpperMultiplicty : ruleUpperMultiplicty EOF ; | 4020 | // InternalSolverLanguageParser.g:1352:1: entryRuleUpperMultiplicty : ruleUpperMultiplicty EOF ; |
4321 | public final void entryRuleUpperMultiplicty() throws RecognitionException { | 4021 | public final void entryRuleUpperMultiplicty() throws RecognitionException { |
4322 | try { | 4022 | try { |
4323 | // InternalSolverLanguage.g:1280:1: ( ruleUpperMultiplicty EOF ) | 4023 | // InternalSolverLanguageParser.g:1353:1: ( ruleUpperMultiplicty EOF ) |
4324 | // InternalSolverLanguage.g:1281:1: ruleUpperMultiplicty EOF | 4024 | // InternalSolverLanguageParser.g:1354:1: ruleUpperMultiplicty EOF |
4325 | { | 4025 | { |
4326 | if ( state.backtracking==0 ) { | 4026 | before(grammarAccess.getUpperMultiplictyRule()); |
4327 | before(grammarAccess.getUpperMultiplictyRule()); | ||
4328 | } | ||
4329 | pushFollow(FOLLOW_1); | 4027 | pushFollow(FOLLOW_1); |
4330 | ruleUpperMultiplicty(); | 4028 | ruleUpperMultiplicty(); |
4331 | 4029 | ||
4332 | state._fsp--; | 4030 | state._fsp--; |
4333 | if (state.failed) return ; | 4031 | |
4334 | if ( state.backtracking==0 ) { | 4032 | after(grammarAccess.getUpperMultiplictyRule()); |
4335 | after(grammarAccess.getUpperMultiplictyRule()); | 4033 | match(input,EOF,FOLLOW_2); |
4336 | } | ||
4337 | match(input,EOF,FOLLOW_2); if (state.failed) return ; | ||
4338 | 4034 | ||
4339 | } | 4035 | } |
4340 | 4036 | ||
@@ -4351,36 +4047,32 @@ public class InternalSolverLanguageParser extends AbstractInternalContentAssistP | |||
4351 | 4047 | ||
4352 | 4048 | ||
4353 | // $ANTLR start "ruleUpperMultiplicty" | 4049 | // $ANTLR start "ruleUpperMultiplicty" |
4354 | // InternalSolverLanguage.g:1288:1: ruleUpperMultiplicty : ( ( rule__UpperMultiplicty__Alternatives ) ) ; | 4050 | // InternalSolverLanguageParser.g:1361:1: ruleUpperMultiplicty : ( ( rule__UpperMultiplicty__Alternatives ) ) ; |
4355 | public final void ruleUpperMultiplicty() throws RecognitionException { | 4051 | public final void ruleUpperMultiplicty() throws RecognitionException { |
4356 | 4052 | ||
4357 | int stackSize = keepStackSize(); | 4053 | int stackSize = keepStackSize(); |
4358 | 4054 | ||
4359 | try { | 4055 | try { |
4360 | // InternalSolverLanguage.g:1292:2: ( ( ( rule__UpperMultiplicty__Alternatives ) ) ) | 4056 | // InternalSolverLanguageParser.g:1365:2: ( ( ( rule__UpperMultiplicty__Alternatives ) ) ) |
4361 | // InternalSolverLanguage.g:1293:2: ( ( rule__UpperMultiplicty__Alternatives ) ) | 4057 | // InternalSolverLanguageParser.g:1366:2: ( ( rule__UpperMultiplicty__Alternatives ) ) |
4362 | { | 4058 | { |
4363 | // InternalSolverLanguage.g:1293:2: ( ( rule__UpperMultiplicty__Alternatives ) ) | 4059 | // InternalSolverLanguageParser.g:1366:2: ( ( rule__UpperMultiplicty__Alternatives ) ) |
4364 | // InternalSolverLanguage.g:1294:3: ( rule__UpperMultiplicty__Alternatives ) | 4060 | // InternalSolverLanguageParser.g:1367:3: ( rule__UpperMultiplicty__Alternatives ) |
4365 | { | 4061 | { |
4366 | if ( state.backtracking==0 ) { | 4062 | before(grammarAccess.getUpperMultiplictyAccess().getAlternatives()); |
4367 | before(grammarAccess.getUpperMultiplictyAccess().getAlternatives()); | 4063 | // InternalSolverLanguageParser.g:1368:3: ( rule__UpperMultiplicty__Alternatives ) |
4368 | } | 4064 | // InternalSolverLanguageParser.g:1368:4: rule__UpperMultiplicty__Alternatives |
4369 | // InternalSolverLanguage.g:1295:3: ( rule__UpperMultiplicty__Alternatives ) | ||
4370 | // InternalSolverLanguage.g:1295:4: rule__UpperMultiplicty__Alternatives | ||
4371 | { | 4065 | { |
4372 | pushFollow(FOLLOW_2); | 4066 | pushFollow(FOLLOW_2); |
4373 | rule__UpperMultiplicty__Alternatives(); | 4067 | rule__UpperMultiplicty__Alternatives(); |
4374 | 4068 | ||
4375 | state._fsp--; | 4069 | state._fsp--; |
4376 | if (state.failed) return ; | ||
4377 | 4070 | ||
4378 | } | ||
4379 | 4071 | ||
4380 | if ( state.backtracking==0 ) { | ||
4381 | after(grammarAccess.getUpperMultiplictyAccess().getAlternatives()); | ||
4382 | } | 4072 | } |
4383 | 4073 | ||
4074 | after(grammarAccess.getUpperMultiplictyAccess().getAlternatives()); | ||
4075 | |||
4384 | } | 4076 | } |
4385 | 4077 | ||
4386 | 4078 | ||
@@ -4402,27 +4094,23 @@ public class InternalSolverLanguageParser extends AbstractInternalContentAssistP | |||
4402 | 4094 | ||
4403 | 4095 | ||
4404 | // $ANTLR start "entryRuleReal" | 4096 | // $ANTLR start "entryRuleReal" |
4405 | // InternalSolverLanguage.g:1304:1: entryRuleReal : ruleReal EOF ; | 4097 | // InternalSolverLanguageParser.g:1377:1: entryRuleReal : ruleReal EOF ; |
4406 | public final void entryRuleReal() throws RecognitionException { | 4098 | public final void entryRuleReal() throws RecognitionException { |
4407 | 4099 | ||
4408 | HiddenTokens myHiddenTokenState = ((XtextTokenStream)input).setHiddenTokens(); | 4100 | HiddenTokens myHiddenTokenState = ((XtextTokenStream)input).setHiddenTokens(); |
4409 | 4101 | ||
4410 | try { | 4102 | try { |
4411 | // InternalSolverLanguage.g:1308:1: ( ruleReal EOF ) | 4103 | // InternalSolverLanguageParser.g:1381:1: ( ruleReal EOF ) |
4412 | // InternalSolverLanguage.g:1309:1: ruleReal EOF | 4104 | // InternalSolverLanguageParser.g:1382:1: ruleReal EOF |
4413 | { | 4105 | { |
4414 | if ( state.backtracking==0 ) { | 4106 | before(grammarAccess.getRealRule()); |
4415 | before(grammarAccess.getRealRule()); | ||
4416 | } | ||
4417 | pushFollow(FOLLOW_1); | 4107 | pushFollow(FOLLOW_1); |
4418 | ruleReal(); | 4108 | ruleReal(); |
4419 | 4109 | ||
4420 | state._fsp--; | 4110 | state._fsp--; |
4421 | if (state.failed) return ; | 4111 | |
4422 | if ( state.backtracking==0 ) { | 4112 | after(grammarAccess.getRealRule()); |
4423 | after(grammarAccess.getRealRule()); | 4113 | match(input,EOF,FOLLOW_2); |
4424 | } | ||
4425 | match(input,EOF,FOLLOW_2); if (state.failed) return ; | ||
4426 | 4114 | ||
4427 | } | 4115 | } |
4428 | 4116 | ||
@@ -4442,37 +4130,33 @@ public class InternalSolverLanguageParser extends AbstractInternalContentAssistP | |||
4442 | 4130 | ||
4443 | 4131 | ||
4444 | // $ANTLR start "ruleReal" | 4132 | // $ANTLR start "ruleReal" |
4445 | // InternalSolverLanguage.g:1319:1: ruleReal : ( ( rule__Real__Group__0 ) ) ; | 4133 | // InternalSolverLanguageParser.g:1392:1: ruleReal : ( ( rule__Real__Group__0 ) ) ; |
4446 | public final void ruleReal() throws RecognitionException { | 4134 | public final void ruleReal() throws RecognitionException { |
4447 | 4135 | ||
4448 | HiddenTokens myHiddenTokenState = ((XtextTokenStream)input).setHiddenTokens(); | 4136 | HiddenTokens myHiddenTokenState = ((XtextTokenStream)input).setHiddenTokens(); |
4449 | int stackSize = keepStackSize(); | 4137 | int stackSize = keepStackSize(); |
4450 | 4138 | ||
4451 | try { | 4139 | try { |
4452 | // InternalSolverLanguage.g:1324:2: ( ( ( rule__Real__Group__0 ) ) ) | 4140 | // InternalSolverLanguageParser.g:1397:2: ( ( ( rule__Real__Group__0 ) ) ) |
4453 | // InternalSolverLanguage.g:1325:2: ( ( rule__Real__Group__0 ) ) | 4141 | // InternalSolverLanguageParser.g:1398:2: ( ( rule__Real__Group__0 ) ) |
4454 | { | 4142 | { |
4455 | // InternalSolverLanguage.g:1325:2: ( ( rule__Real__Group__0 ) ) | 4143 | // InternalSolverLanguageParser.g:1398:2: ( ( rule__Real__Group__0 ) ) |
4456 | // InternalSolverLanguage.g:1326:3: ( rule__Real__Group__0 ) | 4144 | // InternalSolverLanguageParser.g:1399:3: ( rule__Real__Group__0 ) |
4457 | { | 4145 | { |
4458 | if ( state.backtracking==0 ) { | 4146 | before(grammarAccess.getRealAccess().getGroup()); |
4459 | before(grammarAccess.getRealAccess().getGroup()); | 4147 | // InternalSolverLanguageParser.g:1400:3: ( rule__Real__Group__0 ) |
4460 | } | 4148 | // InternalSolverLanguageParser.g:1400:4: rule__Real__Group__0 |
4461 | // InternalSolverLanguage.g:1327:3: ( rule__Real__Group__0 ) | ||
4462 | // InternalSolverLanguage.g:1327:4: rule__Real__Group__0 | ||
4463 | { | 4149 | { |
4464 | pushFollow(FOLLOW_2); | 4150 | pushFollow(FOLLOW_2); |
4465 | rule__Real__Group__0(); | 4151 | rule__Real__Group__0(); |
4466 | 4152 | ||
4467 | state._fsp--; | 4153 | state._fsp--; |
4468 | if (state.failed) return ; | ||
4469 | 4154 | ||
4470 | } | ||
4471 | 4155 | ||
4472 | if ( state.backtracking==0 ) { | ||
4473 | after(grammarAccess.getRealAccess().getGroup()); | ||
4474 | } | 4156 | } |
4475 | 4157 | ||
4158 | after(grammarAccess.getRealAccess().getGroup()); | ||
4159 | |||
4476 | } | 4160 | } |
4477 | 4161 | ||
4478 | 4162 | ||
@@ -4495,27 +4179,23 @@ public class InternalSolverLanguageParser extends AbstractInternalContentAssistP | |||
4495 | 4179 | ||
4496 | 4180 | ||
4497 | // $ANTLR start "entryRuleQualifiedName" | 4181 | // $ANTLR start "entryRuleQualifiedName" |
4498 | // InternalSolverLanguage.g:1337:1: entryRuleQualifiedName : ruleQualifiedName EOF ; | 4182 | // InternalSolverLanguageParser.g:1410:1: entryRuleQualifiedName : ruleQualifiedName EOF ; |
4499 | public final void entryRuleQualifiedName() throws RecognitionException { | 4183 | public final void entryRuleQualifiedName() throws RecognitionException { |
4500 | 4184 | ||
4501 | HiddenTokens myHiddenTokenState = ((XtextTokenStream)input).setHiddenTokens(); | 4185 | HiddenTokens myHiddenTokenState = ((XtextTokenStream)input).setHiddenTokens(); |
4502 | 4186 | ||
4503 | try { | 4187 | try { |
4504 | // InternalSolverLanguage.g:1341:1: ( ruleQualifiedName EOF ) | 4188 | // InternalSolverLanguageParser.g:1414:1: ( ruleQualifiedName EOF ) |
4505 | // InternalSolverLanguage.g:1342:1: ruleQualifiedName EOF | 4189 | // InternalSolverLanguageParser.g:1415:1: ruleQualifiedName EOF |
4506 | { | 4190 | { |
4507 | if ( state.backtracking==0 ) { | 4191 | before(grammarAccess.getQualifiedNameRule()); |
4508 | before(grammarAccess.getQualifiedNameRule()); | ||
4509 | } | ||
4510 | pushFollow(FOLLOW_1); | 4192 | pushFollow(FOLLOW_1); |
4511 | ruleQualifiedName(); | 4193 | ruleQualifiedName(); |
4512 | 4194 | ||
4513 | state._fsp--; | 4195 | state._fsp--; |
4514 | if (state.failed) return ; | 4196 | |
4515 | if ( state.backtracking==0 ) { | 4197 | after(grammarAccess.getQualifiedNameRule()); |
4516 | after(grammarAccess.getQualifiedNameRule()); | 4198 | match(input,EOF,FOLLOW_2); |
4517 | } | ||
4518 | match(input,EOF,FOLLOW_2); if (state.failed) return ; | ||
4519 | 4199 | ||
4520 | } | 4200 | } |
4521 | 4201 | ||
@@ -4535,37 +4215,33 @@ public class InternalSolverLanguageParser extends AbstractInternalContentAssistP | |||
4535 | 4215 | ||
4536 | 4216 | ||
4537 | // $ANTLR start "ruleQualifiedName" | 4217 | // $ANTLR start "ruleQualifiedName" |
4538 | // InternalSolverLanguage.g:1352:1: ruleQualifiedName : ( ( rule__QualifiedName__Alternatives ) ) ; | 4218 | // InternalSolverLanguageParser.g:1425:1: ruleQualifiedName : ( ( rule__QualifiedName__Alternatives ) ) ; |
4539 | public final void ruleQualifiedName() throws RecognitionException { | 4219 | public final void ruleQualifiedName() throws RecognitionException { |
4540 | 4220 | ||
4541 | HiddenTokens myHiddenTokenState = ((XtextTokenStream)input).setHiddenTokens(); | 4221 | HiddenTokens myHiddenTokenState = ((XtextTokenStream)input).setHiddenTokens(); |
4542 | int stackSize = keepStackSize(); | 4222 | int stackSize = keepStackSize(); |
4543 | 4223 | ||
4544 | try { | 4224 | try { |
4545 | // InternalSolverLanguage.g:1357:2: ( ( ( rule__QualifiedName__Alternatives ) ) ) | 4225 | // InternalSolverLanguageParser.g:1430:2: ( ( ( rule__QualifiedName__Alternatives ) ) ) |
4546 | // InternalSolverLanguage.g:1358:2: ( ( rule__QualifiedName__Alternatives ) ) | 4226 | // InternalSolverLanguageParser.g:1431:2: ( ( rule__QualifiedName__Alternatives ) ) |
4547 | { | 4227 | { |
4548 | // InternalSolverLanguage.g:1358:2: ( ( rule__QualifiedName__Alternatives ) ) | 4228 | // InternalSolverLanguageParser.g:1431:2: ( ( rule__QualifiedName__Alternatives ) ) |
4549 | // InternalSolverLanguage.g:1359:3: ( rule__QualifiedName__Alternatives ) | 4229 | // InternalSolverLanguageParser.g:1432:3: ( rule__QualifiedName__Alternatives ) |
4550 | { | 4230 | { |
4551 | if ( state.backtracking==0 ) { | 4231 | before(grammarAccess.getQualifiedNameAccess().getAlternatives()); |
4552 | before(grammarAccess.getQualifiedNameAccess().getAlternatives()); | 4232 | // InternalSolverLanguageParser.g:1433:3: ( rule__QualifiedName__Alternatives ) |
4553 | } | 4233 | // InternalSolverLanguageParser.g:1433:4: rule__QualifiedName__Alternatives |
4554 | // InternalSolverLanguage.g:1360:3: ( rule__QualifiedName__Alternatives ) | ||
4555 | // InternalSolverLanguage.g:1360:4: rule__QualifiedName__Alternatives | ||
4556 | { | 4234 | { |
4557 | pushFollow(FOLLOW_2); | 4235 | pushFollow(FOLLOW_2); |
4558 | rule__QualifiedName__Alternatives(); | 4236 | rule__QualifiedName__Alternatives(); |
4559 | 4237 | ||
4560 | state._fsp--; | 4238 | state._fsp--; |
4561 | if (state.failed) return ; | ||
4562 | 4239 | ||
4563 | } | ||
4564 | 4240 | ||
4565 | if ( state.backtracking==0 ) { | ||
4566 | after(grammarAccess.getQualifiedNameAccess().getAlternatives()); | ||
4567 | } | 4241 | } |
4568 | 4242 | ||
4243 | after(grammarAccess.getQualifiedNameAccess().getAlternatives()); | ||
4244 | |||
4569 | } | 4245 | } |
4570 | 4246 | ||
4571 | 4247 | ||
@@ -4588,36 +4264,32 @@ public class InternalSolverLanguageParser extends AbstractInternalContentAssistP | |||
4588 | 4264 | ||
4589 | 4265 | ||
4590 | // $ANTLR start "ruleMetricType" | 4266 | // $ANTLR start "ruleMetricType" |
4591 | // InternalSolverLanguage.g:1370:1: ruleMetricType : ( ( rule__MetricType__Alternatives ) ) ; | 4267 | // InternalSolverLanguageParser.g:1443:1: ruleMetricType : ( ( rule__MetricType__Alternatives ) ) ; |
4592 | public final void ruleMetricType() throws RecognitionException { | 4268 | public final void ruleMetricType() throws RecognitionException { |
4593 | 4269 | ||
4594 | int stackSize = keepStackSize(); | 4270 | int stackSize = keepStackSize(); |
4595 | 4271 | ||
4596 | try { | 4272 | try { |
4597 | // InternalSolverLanguage.g:1374:1: ( ( ( rule__MetricType__Alternatives ) ) ) | 4273 | // InternalSolverLanguageParser.g:1447:1: ( ( ( rule__MetricType__Alternatives ) ) ) |
4598 | // InternalSolverLanguage.g:1375:2: ( ( rule__MetricType__Alternatives ) ) | 4274 | // InternalSolverLanguageParser.g:1448:2: ( ( rule__MetricType__Alternatives ) ) |
4599 | { | 4275 | { |
4600 | // InternalSolverLanguage.g:1375:2: ( ( rule__MetricType__Alternatives ) ) | 4276 | // InternalSolverLanguageParser.g:1448:2: ( ( rule__MetricType__Alternatives ) ) |
4601 | // InternalSolverLanguage.g:1376:3: ( rule__MetricType__Alternatives ) | 4277 | // InternalSolverLanguageParser.g:1449:3: ( rule__MetricType__Alternatives ) |
4602 | { | 4278 | { |
4603 | if ( state.backtracking==0 ) { | 4279 | before(grammarAccess.getMetricTypeAccess().getAlternatives()); |
4604 | before(grammarAccess.getMetricTypeAccess().getAlternatives()); | 4280 | // InternalSolverLanguageParser.g:1450:3: ( rule__MetricType__Alternatives ) |
4605 | } | 4281 | // InternalSolverLanguageParser.g:1450:4: rule__MetricType__Alternatives |
4606 | // InternalSolverLanguage.g:1377:3: ( rule__MetricType__Alternatives ) | ||
4607 | // InternalSolverLanguage.g:1377:4: rule__MetricType__Alternatives | ||
4608 | { | 4282 | { |
4609 | pushFollow(FOLLOW_2); | 4283 | pushFollow(FOLLOW_2); |
4610 | rule__MetricType__Alternatives(); | 4284 | rule__MetricType__Alternatives(); |
4611 | 4285 | ||
4612 | state._fsp--; | 4286 | state._fsp--; |
4613 | if (state.failed) return ; | ||
4614 | 4287 | ||
4615 | } | ||
4616 | 4288 | ||
4617 | if ( state.backtracking==0 ) { | ||
4618 | after(grammarAccess.getMetricTypeAccess().getAlternatives()); | ||
4619 | } | 4289 | } |
4620 | 4290 | ||
4291 | after(grammarAccess.getMetricTypeAccess().getAlternatives()); | ||
4292 | |||
4621 | } | 4293 | } |
4622 | 4294 | ||
4623 | 4295 | ||
@@ -4639,36 +4311,32 @@ public class InternalSolverLanguageParser extends AbstractInternalContentAssistP | |||
4639 | 4311 | ||
4640 | 4312 | ||
4641 | // $ANTLR start "ruleComparisonOperator" | 4313 | // $ANTLR start "ruleComparisonOperator" |
4642 | // InternalSolverLanguage.g:1386:1: ruleComparisonOperator : ( ( rule__ComparisonOperator__Alternatives ) ) ; | 4314 | // InternalSolverLanguageParser.g:1459:1: ruleComparisonOperator : ( ( rule__ComparisonOperator__Alternatives ) ) ; |
4643 | public final void ruleComparisonOperator() throws RecognitionException { | 4315 | public final void ruleComparisonOperator() throws RecognitionException { |
4644 | 4316 | ||
4645 | int stackSize = keepStackSize(); | 4317 | int stackSize = keepStackSize(); |
4646 | 4318 | ||
4647 | try { | 4319 | try { |
4648 | // InternalSolverLanguage.g:1390:1: ( ( ( rule__ComparisonOperator__Alternatives ) ) ) | 4320 | // InternalSolverLanguageParser.g:1463:1: ( ( ( rule__ComparisonOperator__Alternatives ) ) ) |
4649 | // InternalSolverLanguage.g:1391:2: ( ( rule__ComparisonOperator__Alternatives ) ) | 4321 | // InternalSolverLanguageParser.g:1464:2: ( ( rule__ComparisonOperator__Alternatives ) ) |
4650 | { | 4322 | { |
4651 | // InternalSolverLanguage.g:1391:2: ( ( rule__ComparisonOperator__Alternatives ) ) | 4323 | // InternalSolverLanguageParser.g:1464:2: ( ( rule__ComparisonOperator__Alternatives ) ) |
4652 | // InternalSolverLanguage.g:1392:3: ( rule__ComparisonOperator__Alternatives ) | 4324 | // InternalSolverLanguageParser.g:1465:3: ( rule__ComparisonOperator__Alternatives ) |
4653 | { | 4325 | { |
4654 | if ( state.backtracking==0 ) { | 4326 | before(grammarAccess.getComparisonOperatorAccess().getAlternatives()); |
4655 | before(grammarAccess.getComparisonOperatorAccess().getAlternatives()); | 4327 | // InternalSolverLanguageParser.g:1466:3: ( rule__ComparisonOperator__Alternatives ) |
4656 | } | 4328 | // InternalSolverLanguageParser.g:1466:4: rule__ComparisonOperator__Alternatives |
4657 | // InternalSolverLanguage.g:1393:3: ( rule__ComparisonOperator__Alternatives ) | ||
4658 | // InternalSolverLanguage.g:1393:4: rule__ComparisonOperator__Alternatives | ||
4659 | { | 4329 | { |
4660 | pushFollow(FOLLOW_2); | 4330 | pushFollow(FOLLOW_2); |
4661 | rule__ComparisonOperator__Alternatives(); | 4331 | rule__ComparisonOperator__Alternatives(); |
4662 | 4332 | ||
4663 | state._fsp--; | 4333 | state._fsp--; |
4664 | if (state.failed) return ; | ||
4665 | 4334 | ||
4666 | } | ||
4667 | 4335 | ||
4668 | if ( state.backtracking==0 ) { | ||
4669 | after(grammarAccess.getComparisonOperatorAccess().getAlternatives()); | ||
4670 | } | 4336 | } |
4671 | 4337 | ||
4338 | after(grammarAccess.getComparisonOperatorAccess().getAlternatives()); | ||
4339 | |||
4672 | } | 4340 | } |
4673 | 4341 | ||
4674 | 4342 | ||
@@ -4690,36 +4358,32 @@ public class InternalSolverLanguageParser extends AbstractInternalContentAssistP | |||
4690 | 4358 | ||
4691 | 4359 | ||
4692 | // $ANTLR start "ruleAdditiveBinaryOperator" | 4360 | // $ANTLR start "ruleAdditiveBinaryOperator" |
4693 | // InternalSolverLanguage.g:1402:1: ruleAdditiveBinaryOperator : ( ( rule__AdditiveBinaryOperator__Alternatives ) ) ; | 4361 | // InternalSolverLanguageParser.g:1475:1: ruleAdditiveBinaryOperator : ( ( rule__AdditiveBinaryOperator__Alternatives ) ) ; |
4694 | public final void ruleAdditiveBinaryOperator() throws RecognitionException { | 4362 | public final void ruleAdditiveBinaryOperator() throws RecognitionException { |
4695 | 4363 | ||
4696 | int stackSize = keepStackSize(); | 4364 | int stackSize = keepStackSize(); |
4697 | 4365 | ||
4698 | try { | 4366 | try { |
4699 | // InternalSolverLanguage.g:1406:1: ( ( ( rule__AdditiveBinaryOperator__Alternatives ) ) ) | 4367 | // InternalSolverLanguageParser.g:1479:1: ( ( ( rule__AdditiveBinaryOperator__Alternatives ) ) ) |
4700 | // InternalSolverLanguage.g:1407:2: ( ( rule__AdditiveBinaryOperator__Alternatives ) ) | 4368 | // InternalSolverLanguageParser.g:1480:2: ( ( rule__AdditiveBinaryOperator__Alternatives ) ) |
4701 | { | 4369 | { |
4702 | // InternalSolverLanguage.g:1407:2: ( ( rule__AdditiveBinaryOperator__Alternatives ) ) | 4370 | // InternalSolverLanguageParser.g:1480:2: ( ( rule__AdditiveBinaryOperator__Alternatives ) ) |
4703 | // InternalSolverLanguage.g:1408:3: ( rule__AdditiveBinaryOperator__Alternatives ) | 4371 | // InternalSolverLanguageParser.g:1481:3: ( rule__AdditiveBinaryOperator__Alternatives ) |
4704 | { | 4372 | { |
4705 | if ( state.backtracking==0 ) { | 4373 | before(grammarAccess.getAdditiveBinaryOperatorAccess().getAlternatives()); |
4706 | before(grammarAccess.getAdditiveBinaryOperatorAccess().getAlternatives()); | 4374 | // InternalSolverLanguageParser.g:1482:3: ( rule__AdditiveBinaryOperator__Alternatives ) |
4707 | } | 4375 | // InternalSolverLanguageParser.g:1482:4: rule__AdditiveBinaryOperator__Alternatives |
4708 | // InternalSolverLanguage.g:1409:3: ( rule__AdditiveBinaryOperator__Alternatives ) | ||
4709 | // InternalSolverLanguage.g:1409:4: rule__AdditiveBinaryOperator__Alternatives | ||
4710 | { | 4376 | { |
4711 | pushFollow(FOLLOW_2); | 4377 | pushFollow(FOLLOW_2); |
4712 | rule__AdditiveBinaryOperator__Alternatives(); | 4378 | rule__AdditiveBinaryOperator__Alternatives(); |
4713 | 4379 | ||
4714 | state._fsp--; | 4380 | state._fsp--; |
4715 | if (state.failed) return ; | ||
4716 | 4381 | ||
4717 | } | ||
4718 | 4382 | ||
4719 | if ( state.backtracking==0 ) { | ||
4720 | after(grammarAccess.getAdditiveBinaryOperatorAccess().getAlternatives()); | ||
4721 | } | 4383 | } |
4722 | 4384 | ||
4385 | after(grammarAccess.getAdditiveBinaryOperatorAccess().getAlternatives()); | ||
4386 | |||
4723 | } | 4387 | } |
4724 | 4388 | ||
4725 | 4389 | ||
@@ -4741,36 +4405,32 @@ public class InternalSolverLanguageParser extends AbstractInternalContentAssistP | |||
4741 | 4405 | ||
4742 | 4406 | ||
4743 | // $ANTLR start "ruleMultiplicativeBinaryOperator" | 4407 | // $ANTLR start "ruleMultiplicativeBinaryOperator" |
4744 | // InternalSolverLanguage.g:1418:1: ruleMultiplicativeBinaryOperator : ( ( rule__MultiplicativeBinaryOperator__Alternatives ) ) ; | 4408 | // InternalSolverLanguageParser.g:1491:1: ruleMultiplicativeBinaryOperator : ( ( rule__MultiplicativeBinaryOperator__Alternatives ) ) ; |
4745 | public final void ruleMultiplicativeBinaryOperator() throws RecognitionException { | 4409 | public final void ruleMultiplicativeBinaryOperator() throws RecognitionException { |
4746 | 4410 | ||
4747 | int stackSize = keepStackSize(); | 4411 | int stackSize = keepStackSize(); |
4748 | 4412 | ||
4749 | try { | 4413 | try { |
4750 | // InternalSolverLanguage.g:1422:1: ( ( ( rule__MultiplicativeBinaryOperator__Alternatives ) ) ) | 4414 | // InternalSolverLanguageParser.g:1495:1: ( ( ( rule__MultiplicativeBinaryOperator__Alternatives ) ) ) |
4751 | // InternalSolverLanguage.g:1423:2: ( ( rule__MultiplicativeBinaryOperator__Alternatives ) ) | 4415 | // InternalSolverLanguageParser.g:1496:2: ( ( rule__MultiplicativeBinaryOperator__Alternatives ) ) |
4752 | { | 4416 | { |
4753 | // InternalSolverLanguage.g:1423:2: ( ( rule__MultiplicativeBinaryOperator__Alternatives ) ) | 4417 | // InternalSolverLanguageParser.g:1496:2: ( ( rule__MultiplicativeBinaryOperator__Alternatives ) ) |
4754 | // InternalSolverLanguage.g:1424:3: ( rule__MultiplicativeBinaryOperator__Alternatives ) | 4418 | // InternalSolverLanguageParser.g:1497:3: ( rule__MultiplicativeBinaryOperator__Alternatives ) |
4755 | { | 4419 | { |
4756 | if ( state.backtracking==0 ) { | 4420 | before(grammarAccess.getMultiplicativeBinaryOperatorAccess().getAlternatives()); |
4757 | before(grammarAccess.getMultiplicativeBinaryOperatorAccess().getAlternatives()); | 4421 | // InternalSolverLanguageParser.g:1498:3: ( rule__MultiplicativeBinaryOperator__Alternatives ) |
4758 | } | 4422 | // InternalSolverLanguageParser.g:1498:4: rule__MultiplicativeBinaryOperator__Alternatives |
4759 | // InternalSolverLanguage.g:1425:3: ( rule__MultiplicativeBinaryOperator__Alternatives ) | ||
4760 | // InternalSolverLanguage.g:1425:4: rule__MultiplicativeBinaryOperator__Alternatives | ||
4761 | { | 4423 | { |
4762 | pushFollow(FOLLOW_2); | 4424 | pushFollow(FOLLOW_2); |
4763 | rule__MultiplicativeBinaryOperator__Alternatives(); | 4425 | rule__MultiplicativeBinaryOperator__Alternatives(); |
4764 | 4426 | ||
4765 | state._fsp--; | 4427 | state._fsp--; |
4766 | if (state.failed) return ; | ||
4767 | 4428 | ||
4768 | } | ||
4769 | 4429 | ||
4770 | if ( state.backtracking==0 ) { | ||
4771 | after(grammarAccess.getMultiplicativeBinaryOperatorAccess().getAlternatives()); | ||
4772 | } | 4430 | } |
4773 | 4431 | ||
4432 | after(grammarAccess.getMultiplicativeBinaryOperatorAccess().getAlternatives()); | ||
4433 | |||
4774 | } | 4434 | } |
4775 | 4435 | ||
4776 | 4436 | ||
@@ -4792,31 +4452,27 @@ public class InternalSolverLanguageParser extends AbstractInternalContentAssistP | |||
4792 | 4452 | ||
4793 | 4453 | ||
4794 | // $ANTLR start "ruleExponentialOp" | 4454 | // $ANTLR start "ruleExponentialOp" |
4795 | // InternalSolverLanguage.g:1434:1: ruleExponentialOp : ( ( '^' ) ) ; | 4455 | // InternalSolverLanguageParser.g:1507:1: ruleExponentialOp : ( ( CircumflexAccent ) ) ; |
4796 | public final void ruleExponentialOp() throws RecognitionException { | 4456 | public final void ruleExponentialOp() throws RecognitionException { |
4797 | 4457 | ||
4798 | int stackSize = keepStackSize(); | 4458 | int stackSize = keepStackSize(); |
4799 | 4459 | ||
4800 | try { | 4460 | try { |
4801 | // InternalSolverLanguage.g:1438:1: ( ( ( '^' ) ) ) | 4461 | // InternalSolverLanguageParser.g:1511:1: ( ( ( CircumflexAccent ) ) ) |
4802 | // InternalSolverLanguage.g:1439:2: ( ( '^' ) ) | 4462 | // InternalSolverLanguageParser.g:1512:2: ( ( CircumflexAccent ) ) |
4803 | { | 4463 | { |
4804 | // InternalSolverLanguage.g:1439:2: ( ( '^' ) ) | 4464 | // InternalSolverLanguageParser.g:1512:2: ( ( CircumflexAccent ) ) |
4805 | // InternalSolverLanguage.g:1440:3: ( '^' ) | 4465 | // InternalSolverLanguageParser.g:1513:3: ( CircumflexAccent ) |
4806 | { | 4466 | { |
4807 | if ( state.backtracking==0 ) { | 4467 | before(grammarAccess.getExponentialOpAccess().getPOWEnumLiteralDeclaration()); |
4808 | before(grammarAccess.getExponentialOpAccess().getPOWEnumLiteralDeclaration()); | 4468 | // InternalSolverLanguageParser.g:1514:3: ( CircumflexAccent ) |
4809 | } | 4469 | // InternalSolverLanguageParser.g:1514:4: CircumflexAccent |
4810 | // InternalSolverLanguage.g:1441:3: ( '^' ) | ||
4811 | // InternalSolverLanguage.g:1441:4: '^' | ||
4812 | { | 4470 | { |
4813 | match(input,15,FOLLOW_2); if (state.failed) return ; | 4471 | match(input,CircumflexAccent,FOLLOW_2); |
4814 | 4472 | ||
4815 | } | 4473 | } |
4816 | 4474 | ||
4817 | if ( state.backtracking==0 ) { | 4475 | after(grammarAccess.getExponentialOpAccess().getPOWEnumLiteralDeclaration()); |
4818 | after(grammarAccess.getExponentialOpAccess().getPOWEnumLiteralDeclaration()); | ||
4819 | } | ||
4820 | 4476 | ||
4821 | } | 4477 | } |
4822 | 4478 | ||
@@ -4839,36 +4495,32 @@ public class InternalSolverLanguageParser extends AbstractInternalContentAssistP | |||
4839 | 4495 | ||
4840 | 4496 | ||
4841 | // $ANTLR start "ruleUnaryOp" | 4497 | // $ANTLR start "ruleUnaryOp" |
4842 | // InternalSolverLanguage.g:1450:1: ruleUnaryOp : ( ( rule__UnaryOp__Alternatives ) ) ; | 4498 | // InternalSolverLanguageParser.g:1523:1: ruleUnaryOp : ( ( rule__UnaryOp__Alternatives ) ) ; |
4843 | public final void ruleUnaryOp() throws RecognitionException { | 4499 | public final void ruleUnaryOp() throws RecognitionException { |
4844 | 4500 | ||
4845 | int stackSize = keepStackSize(); | 4501 | int stackSize = keepStackSize(); |
4846 | 4502 | ||
4847 | try { | 4503 | try { |
4848 | // InternalSolverLanguage.g:1454:1: ( ( ( rule__UnaryOp__Alternatives ) ) ) | 4504 | // InternalSolverLanguageParser.g:1527:1: ( ( ( rule__UnaryOp__Alternatives ) ) ) |
4849 | // InternalSolverLanguage.g:1455:2: ( ( rule__UnaryOp__Alternatives ) ) | 4505 | // InternalSolverLanguageParser.g:1528:2: ( ( rule__UnaryOp__Alternatives ) ) |
4850 | { | 4506 | { |
4851 | // InternalSolverLanguage.g:1455:2: ( ( rule__UnaryOp__Alternatives ) ) | 4507 | // InternalSolverLanguageParser.g:1528:2: ( ( rule__UnaryOp__Alternatives ) ) |
4852 | // InternalSolverLanguage.g:1456:3: ( rule__UnaryOp__Alternatives ) | 4508 | // InternalSolverLanguageParser.g:1529:3: ( rule__UnaryOp__Alternatives ) |
4853 | { | 4509 | { |
4854 | if ( state.backtracking==0 ) { | 4510 | before(grammarAccess.getUnaryOpAccess().getAlternatives()); |
4855 | before(grammarAccess.getUnaryOpAccess().getAlternatives()); | 4511 | // InternalSolverLanguageParser.g:1530:3: ( rule__UnaryOp__Alternatives ) |
4856 | } | 4512 | // InternalSolverLanguageParser.g:1530:4: rule__UnaryOp__Alternatives |
4857 | // InternalSolverLanguage.g:1457:3: ( rule__UnaryOp__Alternatives ) | ||
4858 | // InternalSolverLanguage.g:1457:4: rule__UnaryOp__Alternatives | ||
4859 | { | 4513 | { |
4860 | pushFollow(FOLLOW_2); | 4514 | pushFollow(FOLLOW_2); |
4861 | rule__UnaryOp__Alternatives(); | 4515 | rule__UnaryOp__Alternatives(); |
4862 | 4516 | ||
4863 | state._fsp--; | 4517 | state._fsp--; |
4864 | if (state.failed) return ; | ||
4865 | 4518 | ||
4866 | } | ||
4867 | 4519 | ||
4868 | if ( state.backtracking==0 ) { | ||
4869 | after(grammarAccess.getUnaryOpAccess().getAlternatives()); | ||
4870 | } | 4520 | } |
4871 | 4521 | ||
4522 | after(grammarAccess.getUnaryOpAccess().getAlternatives()); | ||
4523 | |||
4872 | } | 4524 | } |
4873 | 4525 | ||
4874 | 4526 | ||
@@ -4890,36 +4542,32 @@ public class InternalSolverLanguageParser extends AbstractInternalContentAssistP | |||
4890 | 4542 | ||
4891 | 4543 | ||
4892 | // $ANTLR start "ruleAggregationOp" | 4544 | // $ANTLR start "ruleAggregationOp" |
4893 | // InternalSolverLanguage.g:1466:1: ruleAggregationOp : ( ( rule__AggregationOp__Alternatives ) ) ; | 4545 | // InternalSolverLanguageParser.g:1539:1: ruleAggregationOp : ( ( rule__AggregationOp__Alternatives ) ) ; |
4894 | public final void ruleAggregationOp() throws RecognitionException { | 4546 | public final void ruleAggregationOp() throws RecognitionException { |
4895 | 4547 | ||
4896 | int stackSize = keepStackSize(); | 4548 | int stackSize = keepStackSize(); |
4897 | 4549 | ||
4898 | try { | 4550 | try { |
4899 | // InternalSolverLanguage.g:1470:1: ( ( ( rule__AggregationOp__Alternatives ) ) ) | 4551 | // InternalSolverLanguageParser.g:1543:1: ( ( ( rule__AggregationOp__Alternatives ) ) ) |
4900 | // InternalSolverLanguage.g:1471:2: ( ( rule__AggregationOp__Alternatives ) ) | 4552 | // InternalSolverLanguageParser.g:1544:2: ( ( rule__AggregationOp__Alternatives ) ) |
4901 | { | 4553 | { |
4902 | // InternalSolverLanguage.g:1471:2: ( ( rule__AggregationOp__Alternatives ) ) | 4554 | // InternalSolverLanguageParser.g:1544:2: ( ( rule__AggregationOp__Alternatives ) ) |
4903 | // InternalSolverLanguage.g:1472:3: ( rule__AggregationOp__Alternatives ) | 4555 | // InternalSolverLanguageParser.g:1545:3: ( rule__AggregationOp__Alternatives ) |
4904 | { | 4556 | { |
4905 | if ( state.backtracking==0 ) { | 4557 | before(grammarAccess.getAggregationOpAccess().getAlternatives()); |
4906 | before(grammarAccess.getAggregationOpAccess().getAlternatives()); | 4558 | // InternalSolverLanguageParser.g:1546:3: ( rule__AggregationOp__Alternatives ) |
4907 | } | 4559 | // InternalSolverLanguageParser.g:1546:4: rule__AggregationOp__Alternatives |
4908 | // InternalSolverLanguage.g:1473:3: ( rule__AggregationOp__Alternatives ) | ||
4909 | // InternalSolverLanguage.g:1473:4: rule__AggregationOp__Alternatives | ||
4910 | { | 4560 | { |
4911 | pushFollow(FOLLOW_2); | 4561 | pushFollow(FOLLOW_2); |
4912 | rule__AggregationOp__Alternatives(); | 4562 | rule__AggregationOp__Alternatives(); |
4913 | 4563 | ||
4914 | state._fsp--; | 4564 | state._fsp--; |
4915 | if (state.failed) return ; | ||
4916 | 4565 | ||
4917 | } | ||
4918 | 4566 | ||
4919 | if ( state.backtracking==0 ) { | ||
4920 | after(grammarAccess.getAggregationOpAccess().getAlternatives()); | ||
4921 | } | 4567 | } |
4922 | 4568 | ||
4569 | after(grammarAccess.getAggregationOpAccess().getAlternatives()); | ||
4570 | |||
4923 | } | 4571 | } |
4924 | 4572 | ||
4925 | 4573 | ||
@@ -4941,36 +4589,32 @@ public class InternalSolverLanguageParser extends AbstractInternalContentAssistP | |||
4941 | 4589 | ||
4942 | 4590 | ||
4943 | // $ANTLR start "ruleLogicValue" | 4591 | // $ANTLR start "ruleLogicValue" |
4944 | // InternalSolverLanguage.g:1482:1: ruleLogicValue : ( ( rule__LogicValue__Alternatives ) ) ; | 4592 | // InternalSolverLanguageParser.g:1555:1: ruleLogicValue : ( ( rule__LogicValue__Alternatives ) ) ; |
4945 | public final void ruleLogicValue() throws RecognitionException { | 4593 | public final void ruleLogicValue() throws RecognitionException { |
4946 | 4594 | ||
4947 | int stackSize = keepStackSize(); | 4595 | int stackSize = keepStackSize(); |
4948 | 4596 | ||
4949 | try { | 4597 | try { |
4950 | // InternalSolverLanguage.g:1486:1: ( ( ( rule__LogicValue__Alternatives ) ) ) | 4598 | // InternalSolverLanguageParser.g:1559:1: ( ( ( rule__LogicValue__Alternatives ) ) ) |
4951 | // InternalSolverLanguage.g:1487:2: ( ( rule__LogicValue__Alternatives ) ) | 4599 | // InternalSolverLanguageParser.g:1560:2: ( ( rule__LogicValue__Alternatives ) ) |
4952 | { | 4600 | { |
4953 | // InternalSolverLanguage.g:1487:2: ( ( rule__LogicValue__Alternatives ) ) | 4601 | // InternalSolverLanguageParser.g:1560:2: ( ( rule__LogicValue__Alternatives ) ) |
4954 | // InternalSolverLanguage.g:1488:3: ( rule__LogicValue__Alternatives ) | 4602 | // InternalSolverLanguageParser.g:1561:3: ( rule__LogicValue__Alternatives ) |
4955 | { | 4603 | { |
4956 | if ( state.backtracking==0 ) { | 4604 | before(grammarAccess.getLogicValueAccess().getAlternatives()); |
4957 | before(grammarAccess.getLogicValueAccess().getAlternatives()); | 4605 | // InternalSolverLanguageParser.g:1562:3: ( rule__LogicValue__Alternatives ) |
4958 | } | 4606 | // InternalSolverLanguageParser.g:1562:4: rule__LogicValue__Alternatives |
4959 | // InternalSolverLanguage.g:1489:3: ( rule__LogicValue__Alternatives ) | ||
4960 | // InternalSolverLanguage.g:1489:4: rule__LogicValue__Alternatives | ||
4961 | { | 4607 | { |
4962 | pushFollow(FOLLOW_2); | 4608 | pushFollow(FOLLOW_2); |
4963 | rule__LogicValue__Alternatives(); | 4609 | rule__LogicValue__Alternatives(); |
4964 | 4610 | ||
4965 | state._fsp--; | 4611 | state._fsp--; |
4966 | if (state.failed) return ; | ||
4967 | 4612 | ||
4968 | } | ||
4969 | 4613 | ||
4970 | if ( state.backtracking==0 ) { | ||
4971 | after(grammarAccess.getLogicValueAccess().getAlternatives()); | ||
4972 | } | 4614 | } |
4973 | 4615 | ||
4616 | after(grammarAccess.getLogicValueAccess().getAlternatives()); | ||
4617 | |||
4974 | } | 4618 | } |
4975 | 4619 | ||
4976 | 4620 | ||
@@ -4992,36 +4636,32 @@ public class InternalSolverLanguageParser extends AbstractInternalContentAssistP | |||
4992 | 4636 | ||
4993 | 4637 | ||
4994 | // $ANTLR start "ruleObjectiveKind" | 4638 | // $ANTLR start "ruleObjectiveKind" |
4995 | // InternalSolverLanguage.g:1498:1: ruleObjectiveKind : ( ( rule__ObjectiveKind__Alternatives ) ) ; | 4639 | // InternalSolverLanguageParser.g:1571:1: ruleObjectiveKind : ( ( rule__ObjectiveKind__Alternatives ) ) ; |
4996 | public final void ruleObjectiveKind() throws RecognitionException { | 4640 | public final void ruleObjectiveKind() throws RecognitionException { |
4997 | 4641 | ||
4998 | int stackSize = keepStackSize(); | 4642 | int stackSize = keepStackSize(); |
4999 | 4643 | ||
5000 | try { | 4644 | try { |
5001 | // InternalSolverLanguage.g:1502:1: ( ( ( rule__ObjectiveKind__Alternatives ) ) ) | 4645 | // InternalSolverLanguageParser.g:1575:1: ( ( ( rule__ObjectiveKind__Alternatives ) ) ) |
5002 | // InternalSolverLanguage.g:1503:2: ( ( rule__ObjectiveKind__Alternatives ) ) | 4646 | // InternalSolverLanguageParser.g:1576:2: ( ( rule__ObjectiveKind__Alternatives ) ) |
5003 | { | 4647 | { |
5004 | // InternalSolverLanguage.g:1503:2: ( ( rule__ObjectiveKind__Alternatives ) ) | 4648 | // InternalSolverLanguageParser.g:1576:2: ( ( rule__ObjectiveKind__Alternatives ) ) |
5005 | // InternalSolverLanguage.g:1504:3: ( rule__ObjectiveKind__Alternatives ) | 4649 | // InternalSolverLanguageParser.g:1577:3: ( rule__ObjectiveKind__Alternatives ) |
5006 | { | 4650 | { |
5007 | if ( state.backtracking==0 ) { | 4651 | before(grammarAccess.getObjectiveKindAccess().getAlternatives()); |
5008 | before(grammarAccess.getObjectiveKindAccess().getAlternatives()); | 4652 | // InternalSolverLanguageParser.g:1578:3: ( rule__ObjectiveKind__Alternatives ) |
5009 | } | 4653 | // InternalSolverLanguageParser.g:1578:4: rule__ObjectiveKind__Alternatives |
5010 | // InternalSolverLanguage.g:1505:3: ( rule__ObjectiveKind__Alternatives ) | ||
5011 | // InternalSolverLanguage.g:1505:4: rule__ObjectiveKind__Alternatives | ||
5012 | { | 4654 | { |
5013 | pushFollow(FOLLOW_2); | 4655 | pushFollow(FOLLOW_2); |
5014 | rule__ObjectiveKind__Alternatives(); | 4656 | rule__ObjectiveKind__Alternatives(); |
5015 | 4657 | ||
5016 | state._fsp--; | 4658 | state._fsp--; |
5017 | if (state.failed) return ; | ||
5018 | 4659 | ||
5019 | } | ||
5020 | 4660 | ||
5021 | if ( state.backtracking==0 ) { | ||
5022 | after(grammarAccess.getObjectiveKindAccess().getAlternatives()); | ||
5023 | } | 4661 | } |
5024 | 4662 | ||
4663 | after(grammarAccess.getObjectiveKindAccess().getAlternatives()); | ||
4664 | |||
5025 | } | 4665 | } |
5026 | 4666 | ||
5027 | 4667 | ||
@@ -5043,33 +4683,29 @@ public class InternalSolverLanguageParser extends AbstractInternalContentAssistP | |||
5043 | 4683 | ||
5044 | 4684 | ||
5045 | // $ANTLR start "rule__Statement__Alternatives_0" | 4685 | // $ANTLR start "rule__Statement__Alternatives_0" |
5046 | // InternalSolverLanguage.g:1513:1: rule__Statement__Alternatives_0 : ( ( ruleAssertionOrDefinition ) | ( rulePredicateDefinition ) | ( ruleUnnamedErrorPrediateDefinition ) | ( ruleDefaultDefinition ) | ( ruleExternPredicateDefinition ) | ( ruleMetricDefinition ) | ( ruleExternMetricDefinition ) | ( ruleClassDefinition ) | ( ruleScopeDefinition ) | ( ruleObjectiveDefinition ) ); | 4686 | // InternalSolverLanguageParser.g:1586:1: rule__Statement__Alternatives_0 : ( ( ruleAssertionOrDefinition ) | ( rulePredicateDefinition ) | ( ruleUnnamedErrorPrediateDefinition ) | ( ruleDefaultDefinition ) | ( ruleExternPredicateDefinition ) | ( ruleMetricDefinition ) | ( ruleExternMetricDefinition ) | ( ruleClassDefinition ) | ( ruleScopeDefinition ) | ( ruleObjectiveDefinition ) ); |
5047 | public final void rule__Statement__Alternatives_0() throws RecognitionException { | 4687 | public final void rule__Statement__Alternatives_0() throws RecognitionException { |
5048 | 4688 | ||
5049 | int stackSize = keepStackSize(); | 4689 | int stackSize = keepStackSize(); |
5050 | 4690 | ||
5051 | try { | 4691 | try { |
5052 | // InternalSolverLanguage.g:1517:1: ( ( ruleAssertionOrDefinition ) | ( rulePredicateDefinition ) | ( ruleUnnamedErrorPrediateDefinition ) | ( ruleDefaultDefinition ) | ( ruleExternPredicateDefinition ) | ( ruleMetricDefinition ) | ( ruleExternMetricDefinition ) | ( ruleClassDefinition ) | ( ruleScopeDefinition ) | ( ruleObjectiveDefinition ) ) | 4692 | // InternalSolverLanguageParser.g:1590:1: ( ( ruleAssertionOrDefinition ) | ( rulePredicateDefinition ) | ( ruleUnnamedErrorPrediateDefinition ) | ( ruleDefaultDefinition ) | ( ruleExternPredicateDefinition ) | ( ruleMetricDefinition ) | ( ruleExternMetricDefinition ) | ( ruleClassDefinition ) | ( ruleScopeDefinition ) | ( ruleObjectiveDefinition ) ) |
5053 | int alt2=10; | 4693 | int alt2=10; |
5054 | alt2 = dfa2.predict(input); | 4694 | alt2 = dfa2.predict(input); |
5055 | switch (alt2) { | 4695 | switch (alt2) { |
5056 | case 1 : | 4696 | case 1 : |
5057 | // InternalSolverLanguage.g:1518:2: ( ruleAssertionOrDefinition ) | 4697 | // InternalSolverLanguageParser.g:1591:2: ( ruleAssertionOrDefinition ) |
5058 | { | 4698 | { |
5059 | // InternalSolverLanguage.g:1518:2: ( ruleAssertionOrDefinition ) | 4699 | // InternalSolverLanguageParser.g:1591:2: ( ruleAssertionOrDefinition ) |
5060 | // InternalSolverLanguage.g:1519:3: ruleAssertionOrDefinition | 4700 | // InternalSolverLanguageParser.g:1592:3: ruleAssertionOrDefinition |
5061 | { | 4701 | { |
5062 | if ( state.backtracking==0 ) { | 4702 | before(grammarAccess.getStatementAccess().getAssertionOrDefinitionParserRuleCall_0_0()); |
5063 | before(grammarAccess.getStatementAccess().getAssertionOrDefinitionParserRuleCall_0_0()); | ||
5064 | } | ||
5065 | pushFollow(FOLLOW_2); | 4703 | pushFollow(FOLLOW_2); |
5066 | ruleAssertionOrDefinition(); | 4704 | ruleAssertionOrDefinition(); |
5067 | 4705 | ||
5068 | state._fsp--; | 4706 | state._fsp--; |
5069 | if (state.failed) return ; | 4707 | |
5070 | if ( state.backtracking==0 ) { | 4708 | after(grammarAccess.getStatementAccess().getAssertionOrDefinitionParserRuleCall_0_0()); |
5071 | after(grammarAccess.getStatementAccess().getAssertionOrDefinitionParserRuleCall_0_0()); | ||
5072 | } | ||
5073 | 4709 | ||
5074 | } | 4710 | } |
5075 | 4711 | ||
@@ -5077,22 +4713,18 @@ public class InternalSolverLanguageParser extends AbstractInternalContentAssistP | |||
5077 | } | 4713 | } |
5078 | break; | 4714 | break; |
5079 | case 2 : | 4715 | case 2 : |
5080 | // InternalSolverLanguage.g:1524:2: ( rulePredicateDefinition ) | 4716 | // InternalSolverLanguageParser.g:1597:2: ( rulePredicateDefinition ) |
5081 | { | 4717 | { |
5082 | // InternalSolverLanguage.g:1524:2: ( rulePredicateDefinition ) | 4718 | // InternalSolverLanguageParser.g:1597:2: ( rulePredicateDefinition ) |
5083 | // InternalSolverLanguage.g:1525:3: rulePredicateDefinition | 4719 | // InternalSolverLanguageParser.g:1598:3: rulePredicateDefinition |
5084 | { | 4720 | { |
5085 | if ( state.backtracking==0 ) { | 4721 | before(grammarAccess.getStatementAccess().getPredicateDefinitionParserRuleCall_0_1()); |
5086 | before(grammarAccess.getStatementAccess().getPredicateDefinitionParserRuleCall_0_1()); | ||
5087 | } | ||
5088 | pushFollow(FOLLOW_2); | 4722 | pushFollow(FOLLOW_2); |
5089 | rulePredicateDefinition(); | 4723 | rulePredicateDefinition(); |
5090 | 4724 | ||
5091 | state._fsp--; | 4725 | state._fsp--; |
5092 | if (state.failed) return ; | 4726 | |
5093 | if ( state.backtracking==0 ) { | 4727 | after(grammarAccess.getStatementAccess().getPredicateDefinitionParserRuleCall_0_1()); |
5094 | after(grammarAccess.getStatementAccess().getPredicateDefinitionParserRuleCall_0_1()); | ||
5095 | } | ||
5096 | 4728 | ||
5097 | } | 4729 | } |
5098 | 4730 | ||
@@ -5100,22 +4732,18 @@ public class InternalSolverLanguageParser extends AbstractInternalContentAssistP | |||
5100 | } | 4732 | } |
5101 | break; | 4733 | break; |
5102 | case 3 : | 4734 | case 3 : |
5103 | // InternalSolverLanguage.g:1530:2: ( ruleUnnamedErrorPrediateDefinition ) | 4735 | // InternalSolverLanguageParser.g:1603:2: ( ruleUnnamedErrorPrediateDefinition ) |
5104 | { | 4736 | { |
5105 | // InternalSolverLanguage.g:1530:2: ( ruleUnnamedErrorPrediateDefinition ) | 4737 | // InternalSolverLanguageParser.g:1603:2: ( ruleUnnamedErrorPrediateDefinition ) |
5106 | // InternalSolverLanguage.g:1531:3: ruleUnnamedErrorPrediateDefinition | 4738 | // InternalSolverLanguageParser.g:1604:3: ruleUnnamedErrorPrediateDefinition |
5107 | { | 4739 | { |
5108 | if ( state.backtracking==0 ) { | 4740 | before(grammarAccess.getStatementAccess().getUnnamedErrorPrediateDefinitionParserRuleCall_0_2()); |
5109 | before(grammarAccess.getStatementAccess().getUnnamedErrorPrediateDefinitionParserRuleCall_0_2()); | ||
5110 | } | ||
5111 | pushFollow(FOLLOW_2); | 4741 | pushFollow(FOLLOW_2); |
5112 | ruleUnnamedErrorPrediateDefinition(); | 4742 | ruleUnnamedErrorPrediateDefinition(); |
5113 | 4743 | ||
5114 | state._fsp--; | 4744 | state._fsp--; |
5115 | if (state.failed) return ; | 4745 | |
5116 | if ( state.backtracking==0 ) { | 4746 | after(grammarAccess.getStatementAccess().getUnnamedErrorPrediateDefinitionParserRuleCall_0_2()); |
5117 | after(grammarAccess.getStatementAccess().getUnnamedErrorPrediateDefinitionParserRuleCall_0_2()); | ||
5118 | } | ||
5119 | 4747 | ||
5120 | } | 4748 | } |
5121 | 4749 | ||
@@ -5123,22 +4751,18 @@ public class InternalSolverLanguageParser extends AbstractInternalContentAssistP | |||
5123 | } | 4751 | } |
5124 | break; | 4752 | break; |
5125 | case 4 : | 4753 | case 4 : |
5126 | // InternalSolverLanguage.g:1536:2: ( ruleDefaultDefinition ) | 4754 | // InternalSolverLanguageParser.g:1609:2: ( ruleDefaultDefinition ) |
5127 | { | 4755 | { |
5128 | // InternalSolverLanguage.g:1536:2: ( ruleDefaultDefinition ) | 4756 | // InternalSolverLanguageParser.g:1609:2: ( ruleDefaultDefinition ) |
5129 | // InternalSolverLanguage.g:1537:3: ruleDefaultDefinition | 4757 | // InternalSolverLanguageParser.g:1610:3: ruleDefaultDefinition |
5130 | { | 4758 | { |
5131 | if ( state.backtracking==0 ) { | 4759 | before(grammarAccess.getStatementAccess().getDefaultDefinitionParserRuleCall_0_3()); |
5132 | before(grammarAccess.getStatementAccess().getDefaultDefinitionParserRuleCall_0_3()); | ||
5133 | } | ||
5134 | pushFollow(FOLLOW_2); | 4760 | pushFollow(FOLLOW_2); |
5135 | ruleDefaultDefinition(); | 4761 | ruleDefaultDefinition(); |
5136 | 4762 | ||
5137 | state._fsp--; | 4763 | state._fsp--; |
5138 | if (state.failed) return ; | 4764 | |
5139 | if ( state.backtracking==0 ) { | 4765 | after(grammarAccess.getStatementAccess().getDefaultDefinitionParserRuleCall_0_3()); |
5140 | after(grammarAccess.getStatementAccess().getDefaultDefinitionParserRuleCall_0_3()); | ||
5141 | } | ||
5142 | 4766 | ||
5143 | } | 4767 | } |
5144 | 4768 | ||
@@ -5146,22 +4770,18 @@ public class InternalSolverLanguageParser extends AbstractInternalContentAssistP | |||
5146 | } | 4770 | } |
5147 | break; | 4771 | break; |
5148 | case 5 : | 4772 | case 5 : |
5149 | // InternalSolverLanguage.g:1542:2: ( ruleExternPredicateDefinition ) | 4773 | // InternalSolverLanguageParser.g:1615:2: ( ruleExternPredicateDefinition ) |
5150 | { | 4774 | { |
5151 | // InternalSolverLanguage.g:1542:2: ( ruleExternPredicateDefinition ) | 4775 | // InternalSolverLanguageParser.g:1615:2: ( ruleExternPredicateDefinition ) |
5152 | // InternalSolverLanguage.g:1543:3: ruleExternPredicateDefinition | 4776 | // InternalSolverLanguageParser.g:1616:3: ruleExternPredicateDefinition |
5153 | { | 4777 | { |
5154 | if ( state.backtracking==0 ) { | 4778 | before(grammarAccess.getStatementAccess().getExternPredicateDefinitionParserRuleCall_0_4()); |
5155 | before(grammarAccess.getStatementAccess().getExternPredicateDefinitionParserRuleCall_0_4()); | ||
5156 | } | ||
5157 | pushFollow(FOLLOW_2); | 4779 | pushFollow(FOLLOW_2); |
5158 | ruleExternPredicateDefinition(); | 4780 | ruleExternPredicateDefinition(); |
5159 | 4781 | ||
5160 | state._fsp--; | 4782 | state._fsp--; |
5161 | if (state.failed) return ; | 4783 | |
5162 | if ( state.backtracking==0 ) { | 4784 | after(grammarAccess.getStatementAccess().getExternPredicateDefinitionParserRuleCall_0_4()); |
5163 | after(grammarAccess.getStatementAccess().getExternPredicateDefinitionParserRuleCall_0_4()); | ||
5164 | } | ||
5165 | 4785 | ||
5166 | } | 4786 | } |
5167 | 4787 | ||
@@ -5169,22 +4789,18 @@ public class InternalSolverLanguageParser extends AbstractInternalContentAssistP | |||
5169 | } | 4789 | } |
5170 | break; | 4790 | break; |
5171 | case 6 : | 4791 | case 6 : |
5172 | // InternalSolverLanguage.g:1548:2: ( ruleMetricDefinition ) | 4792 | // InternalSolverLanguageParser.g:1621:2: ( ruleMetricDefinition ) |
5173 | { | 4793 | { |
5174 | // InternalSolverLanguage.g:1548:2: ( ruleMetricDefinition ) | 4794 | // InternalSolverLanguageParser.g:1621:2: ( ruleMetricDefinition ) |
5175 | // InternalSolverLanguage.g:1549:3: ruleMetricDefinition | 4795 | // InternalSolverLanguageParser.g:1622:3: ruleMetricDefinition |
5176 | { | 4796 | { |
5177 | if ( state.backtracking==0 ) { | 4797 | before(grammarAccess.getStatementAccess().getMetricDefinitionParserRuleCall_0_5()); |
5178 | before(grammarAccess.getStatementAccess().getMetricDefinitionParserRuleCall_0_5()); | ||
5179 | } | ||
5180 | pushFollow(FOLLOW_2); | 4798 | pushFollow(FOLLOW_2); |
5181 | ruleMetricDefinition(); | 4799 | ruleMetricDefinition(); |
5182 | 4800 | ||
5183 | state._fsp--; | 4801 | state._fsp--; |
5184 | if (state.failed) return ; | 4802 | |
5185 | if ( state.backtracking==0 ) { | 4803 | after(grammarAccess.getStatementAccess().getMetricDefinitionParserRuleCall_0_5()); |
5186 | after(grammarAccess.getStatementAccess().getMetricDefinitionParserRuleCall_0_5()); | ||
5187 | } | ||
5188 | 4804 | ||
5189 | } | 4805 | } |
5190 | 4806 | ||
@@ -5192,22 +4808,18 @@ public class InternalSolverLanguageParser extends AbstractInternalContentAssistP | |||
5192 | } | 4808 | } |
5193 | break; | 4809 | break; |
5194 | case 7 : | 4810 | case 7 : |
5195 | // InternalSolverLanguage.g:1554:2: ( ruleExternMetricDefinition ) | 4811 | // InternalSolverLanguageParser.g:1627:2: ( ruleExternMetricDefinition ) |
5196 | { | 4812 | { |
5197 | // InternalSolverLanguage.g:1554:2: ( ruleExternMetricDefinition ) | 4813 | // InternalSolverLanguageParser.g:1627:2: ( ruleExternMetricDefinition ) |
5198 | // InternalSolverLanguage.g:1555:3: ruleExternMetricDefinition | 4814 | // InternalSolverLanguageParser.g:1628:3: ruleExternMetricDefinition |
5199 | { | 4815 | { |
5200 | if ( state.backtracking==0 ) { | 4816 | before(grammarAccess.getStatementAccess().getExternMetricDefinitionParserRuleCall_0_6()); |
5201 | before(grammarAccess.getStatementAccess().getExternMetricDefinitionParserRuleCall_0_6()); | ||
5202 | } | ||
5203 | pushFollow(FOLLOW_2); | 4817 | pushFollow(FOLLOW_2); |
5204 | ruleExternMetricDefinition(); | 4818 | ruleExternMetricDefinition(); |
5205 | 4819 | ||
5206 | state._fsp--; | 4820 | state._fsp--; |
5207 | if (state.failed) return ; | 4821 | |
5208 | if ( state.backtracking==0 ) { | 4822 | after(grammarAccess.getStatementAccess().getExternMetricDefinitionParserRuleCall_0_6()); |
5209 | after(grammarAccess.getStatementAccess().getExternMetricDefinitionParserRuleCall_0_6()); | ||
5210 | } | ||
5211 | 4823 | ||
5212 | } | 4824 | } |
5213 | 4825 | ||
@@ -5215,22 +4827,18 @@ public class InternalSolverLanguageParser extends AbstractInternalContentAssistP | |||
5215 | } | 4827 | } |
5216 | break; | 4828 | break; |
5217 | case 8 : | 4829 | case 8 : |
5218 | // InternalSolverLanguage.g:1560:2: ( ruleClassDefinition ) | 4830 | // InternalSolverLanguageParser.g:1633:2: ( ruleClassDefinition ) |
5219 | { | 4831 | { |
5220 | // InternalSolverLanguage.g:1560:2: ( ruleClassDefinition ) | 4832 | // InternalSolverLanguageParser.g:1633:2: ( ruleClassDefinition ) |
5221 | // InternalSolverLanguage.g:1561:3: ruleClassDefinition | 4833 | // InternalSolverLanguageParser.g:1634:3: ruleClassDefinition |
5222 | { | 4834 | { |
5223 | if ( state.backtracking==0 ) { | 4835 | before(grammarAccess.getStatementAccess().getClassDefinitionParserRuleCall_0_7()); |
5224 | before(grammarAccess.getStatementAccess().getClassDefinitionParserRuleCall_0_7()); | ||
5225 | } | ||
5226 | pushFollow(FOLLOW_2); | 4836 | pushFollow(FOLLOW_2); |
5227 | ruleClassDefinition(); | 4837 | ruleClassDefinition(); |
5228 | 4838 | ||
5229 | state._fsp--; | 4839 | state._fsp--; |
5230 | if (state.failed) return ; | 4840 | |
5231 | if ( state.backtracking==0 ) { | 4841 | after(grammarAccess.getStatementAccess().getClassDefinitionParserRuleCall_0_7()); |
5232 | after(grammarAccess.getStatementAccess().getClassDefinitionParserRuleCall_0_7()); | ||
5233 | } | ||
5234 | 4842 | ||
5235 | } | 4843 | } |
5236 | 4844 | ||
@@ -5238,22 +4846,18 @@ public class InternalSolverLanguageParser extends AbstractInternalContentAssistP | |||
5238 | } | 4846 | } |
5239 | break; | 4847 | break; |
5240 | case 9 : | 4848 | case 9 : |
5241 | // InternalSolverLanguage.g:1566:2: ( ruleScopeDefinition ) | 4849 | // InternalSolverLanguageParser.g:1639:2: ( ruleScopeDefinition ) |
5242 | { | 4850 | { |
5243 | // InternalSolverLanguage.g:1566:2: ( ruleScopeDefinition ) | 4851 | // InternalSolverLanguageParser.g:1639:2: ( ruleScopeDefinition ) |
5244 | // InternalSolverLanguage.g:1567:3: ruleScopeDefinition | 4852 | // InternalSolverLanguageParser.g:1640:3: ruleScopeDefinition |
5245 | { | 4853 | { |
5246 | if ( state.backtracking==0 ) { | 4854 | before(grammarAccess.getStatementAccess().getScopeDefinitionParserRuleCall_0_8()); |
5247 | before(grammarAccess.getStatementAccess().getScopeDefinitionParserRuleCall_0_8()); | ||
5248 | } | ||
5249 | pushFollow(FOLLOW_2); | 4855 | pushFollow(FOLLOW_2); |
5250 | ruleScopeDefinition(); | 4856 | ruleScopeDefinition(); |
5251 | 4857 | ||
5252 | state._fsp--; | 4858 | state._fsp--; |
5253 | if (state.failed) return ; | 4859 | |
5254 | if ( state.backtracking==0 ) { | 4860 | after(grammarAccess.getStatementAccess().getScopeDefinitionParserRuleCall_0_8()); |
5255 | after(grammarAccess.getStatementAccess().getScopeDefinitionParserRuleCall_0_8()); | ||
5256 | } | ||
5257 | 4861 | ||
5258 | } | 4862 | } |
5259 | 4863 | ||
@@ -5261,22 +4865,18 @@ public class InternalSolverLanguageParser extends AbstractInternalContentAssistP | |||
5261 | } | 4865 | } |
5262 | break; | 4866 | break; |
5263 | case 10 : | 4867 | case 10 : |
5264 | // InternalSolverLanguage.g:1572:2: ( ruleObjectiveDefinition ) | 4868 | // InternalSolverLanguageParser.g:1645:2: ( ruleObjectiveDefinition ) |
5265 | { | 4869 | { |
5266 | // InternalSolverLanguage.g:1572:2: ( ruleObjectiveDefinition ) | 4870 | // InternalSolverLanguageParser.g:1645:2: ( ruleObjectiveDefinition ) |
5267 | // InternalSolverLanguage.g:1573:3: ruleObjectiveDefinition | 4871 | // InternalSolverLanguageParser.g:1646:3: ruleObjectiveDefinition |
5268 | { | 4872 | { |
5269 | if ( state.backtracking==0 ) { | 4873 | before(grammarAccess.getStatementAccess().getObjectiveDefinitionParserRuleCall_0_9()); |
5270 | before(grammarAccess.getStatementAccess().getObjectiveDefinitionParserRuleCall_0_9()); | ||
5271 | } | ||
5272 | pushFollow(FOLLOW_2); | 4874 | pushFollow(FOLLOW_2); |
5273 | ruleObjectiveDefinition(); | 4875 | ruleObjectiveDefinition(); |
5274 | 4876 | ||
5275 | state._fsp--; | 4877 | state._fsp--; |
5276 | if (state.failed) return ; | 4878 | |
5277 | if ( state.backtracking==0 ) { | 4879 | after(grammarAccess.getStatementAccess().getObjectiveDefinitionParserRuleCall_0_9()); |
5278 | after(grammarAccess.getStatementAccess().getObjectiveDefinitionParserRuleCall_0_9()); | ||
5279 | } | ||
5280 | 4880 | ||
5281 | } | 4881 | } |
5282 | 4882 | ||
@@ -5301,34 +4901,33 @@ public class InternalSolverLanguageParser extends AbstractInternalContentAssistP | |||
5301 | 4901 | ||
5302 | 4902 | ||
5303 | // $ANTLR start "rule__AssertionOrDefinition__Alternatives_1" | 4903 | // $ANTLR start "rule__AssertionOrDefinition__Alternatives_1" |
5304 | // InternalSolverLanguage.g:1582:1: rule__AssertionOrDefinition__Alternatives_1 : ( ( ( rule__AssertionOrDefinition__Group_1_0__0 ) ) | ( ( rule__AssertionOrDefinition__Group_1_1__0 ) ) | ( ( rule__AssertionOrDefinition__Group_1_2__0 ) ) ); | 4904 | // InternalSolverLanguageParser.g:1655:1: rule__AssertionOrDefinition__Alternatives_1 : ( ( ( rule__AssertionOrDefinition__Group_1_0__0 ) ) | ( ( rule__AssertionOrDefinition__Group_1_1__0 ) ) | ( ( rule__AssertionOrDefinition__Group_1_2__0 ) ) ); |
5305 | public final void rule__AssertionOrDefinition__Alternatives_1() throws RecognitionException { | 4905 | public final void rule__AssertionOrDefinition__Alternatives_1() throws RecognitionException { |
5306 | 4906 | ||
5307 | int stackSize = keepStackSize(); | 4907 | int stackSize = keepStackSize(); |
5308 | 4908 | ||
5309 | try { | 4909 | try { |
5310 | // InternalSolverLanguage.g:1586:1: ( ( ( rule__AssertionOrDefinition__Group_1_0__0 ) ) | ( ( rule__AssertionOrDefinition__Group_1_1__0 ) ) | ( ( rule__AssertionOrDefinition__Group_1_2__0 ) ) ) | 4910 | // InternalSolverLanguageParser.g:1659:1: ( ( ( rule__AssertionOrDefinition__Group_1_0__0 ) ) | ( ( rule__AssertionOrDefinition__Group_1_1__0 ) ) | ( ( rule__AssertionOrDefinition__Group_1_2__0 ) ) ) |
5311 | int alt3=3; | 4911 | int alt3=3; |
5312 | switch ( input.LA(1) ) { | 4912 | switch ( input.LA(1) ) { |
5313 | case EOF: | 4913 | case EOF: |
5314 | case RULE_DOT: | 4914 | case Colon: |
5315 | case 45: | 4915 | case RULE_FULL_STOP: |
5316 | { | 4916 | { |
5317 | alt3=1; | 4917 | alt3=1; |
5318 | } | 4918 | } |
5319 | break; | 4919 | break; |
5320 | case 46: | 4920 | case ColonHyphenMinus: |
5321 | { | 4921 | { |
5322 | alt3=2; | 4922 | alt3=2; |
5323 | } | 4923 | } |
5324 | break; | 4924 | break; |
5325 | case 47: | 4925 | case EqualsSign: |
5326 | { | 4926 | { |
5327 | alt3=3; | 4927 | alt3=3; |
5328 | } | 4928 | } |
5329 | break; | 4929 | break; |
5330 | default: | 4930 | default: |
5331 | if (state.backtracking>0) {state.failed=true; return ;} | ||
5332 | NoViableAltException nvae = | 4931 | NoViableAltException nvae = |
5333 | new NoViableAltException("", 3, 0, input); | 4932 | new NoViableAltException("", 3, 0, input); |
5334 | 4933 | ||
@@ -5337,87 +4936,75 @@ public class InternalSolverLanguageParser extends AbstractInternalContentAssistP | |||
5337 | 4936 | ||
5338 | switch (alt3) { | 4937 | switch (alt3) { |
5339 | case 1 : | 4938 | case 1 : |
5340 | // InternalSolverLanguage.g:1587:2: ( ( rule__AssertionOrDefinition__Group_1_0__0 ) ) | 4939 | // InternalSolverLanguageParser.g:1660:2: ( ( rule__AssertionOrDefinition__Group_1_0__0 ) ) |
5341 | { | 4940 | { |
5342 | // InternalSolverLanguage.g:1587:2: ( ( rule__AssertionOrDefinition__Group_1_0__0 ) ) | 4941 | // InternalSolverLanguageParser.g:1660:2: ( ( rule__AssertionOrDefinition__Group_1_0__0 ) ) |
5343 | // InternalSolverLanguage.g:1588:3: ( rule__AssertionOrDefinition__Group_1_0__0 ) | 4942 | // InternalSolverLanguageParser.g:1661:3: ( rule__AssertionOrDefinition__Group_1_0__0 ) |
5344 | { | 4943 | { |
5345 | if ( state.backtracking==0 ) { | 4944 | before(grammarAccess.getAssertionOrDefinitionAccess().getGroup_1_0()); |
5346 | before(grammarAccess.getAssertionOrDefinitionAccess().getGroup_1_0()); | 4945 | // InternalSolverLanguageParser.g:1662:3: ( rule__AssertionOrDefinition__Group_1_0__0 ) |
5347 | } | 4946 | // InternalSolverLanguageParser.g:1662:4: rule__AssertionOrDefinition__Group_1_0__0 |
5348 | // InternalSolverLanguage.g:1589:3: ( rule__AssertionOrDefinition__Group_1_0__0 ) | ||
5349 | // InternalSolverLanguage.g:1589:4: rule__AssertionOrDefinition__Group_1_0__0 | ||
5350 | { | 4947 | { |
5351 | pushFollow(FOLLOW_2); | 4948 | pushFollow(FOLLOW_2); |
5352 | rule__AssertionOrDefinition__Group_1_0__0(); | 4949 | rule__AssertionOrDefinition__Group_1_0__0(); |
5353 | 4950 | ||
5354 | state._fsp--; | 4951 | state._fsp--; |
5355 | if (state.failed) return ; | ||
5356 | 4952 | ||
5357 | } | ||
5358 | 4953 | ||
5359 | if ( state.backtracking==0 ) { | ||
5360 | after(grammarAccess.getAssertionOrDefinitionAccess().getGroup_1_0()); | ||
5361 | } | 4954 | } |
5362 | 4955 | ||
4956 | after(grammarAccess.getAssertionOrDefinitionAccess().getGroup_1_0()); | ||
4957 | |||
5363 | } | 4958 | } |
5364 | 4959 | ||
5365 | 4960 | ||
5366 | } | 4961 | } |
5367 | break; | 4962 | break; |
5368 | case 2 : | 4963 | case 2 : |
5369 | // InternalSolverLanguage.g:1593:2: ( ( rule__AssertionOrDefinition__Group_1_1__0 ) ) | 4964 | // InternalSolverLanguageParser.g:1666:2: ( ( rule__AssertionOrDefinition__Group_1_1__0 ) ) |
5370 | { | 4965 | { |
5371 | // InternalSolverLanguage.g:1593:2: ( ( rule__AssertionOrDefinition__Group_1_1__0 ) ) | 4966 | // InternalSolverLanguageParser.g:1666:2: ( ( rule__AssertionOrDefinition__Group_1_1__0 ) ) |
5372 | // InternalSolverLanguage.g:1594:3: ( rule__AssertionOrDefinition__Group_1_1__0 ) | 4967 | // InternalSolverLanguageParser.g:1667:3: ( rule__AssertionOrDefinition__Group_1_1__0 ) |
5373 | { | 4968 | { |
5374 | if ( state.backtracking==0 ) { | 4969 | before(grammarAccess.getAssertionOrDefinitionAccess().getGroup_1_1()); |
5375 | before(grammarAccess.getAssertionOrDefinitionAccess().getGroup_1_1()); | 4970 | // InternalSolverLanguageParser.g:1668:3: ( rule__AssertionOrDefinition__Group_1_1__0 ) |
5376 | } | 4971 | // InternalSolverLanguageParser.g:1668:4: rule__AssertionOrDefinition__Group_1_1__0 |
5377 | // InternalSolverLanguage.g:1595:3: ( rule__AssertionOrDefinition__Group_1_1__0 ) | ||
5378 | // InternalSolverLanguage.g:1595:4: rule__AssertionOrDefinition__Group_1_1__0 | ||
5379 | { | 4972 | { |
5380 | pushFollow(FOLLOW_2); | 4973 | pushFollow(FOLLOW_2); |
5381 | rule__AssertionOrDefinition__Group_1_1__0(); | 4974 | rule__AssertionOrDefinition__Group_1_1__0(); |
5382 | 4975 | ||
5383 | state._fsp--; | 4976 | state._fsp--; |
5384 | if (state.failed) return ; | ||
5385 | 4977 | ||
5386 | } | ||
5387 | 4978 | ||
5388 | if ( state.backtracking==0 ) { | ||
5389 | after(grammarAccess.getAssertionOrDefinitionAccess().getGroup_1_1()); | ||
5390 | } | 4979 | } |
5391 | 4980 | ||
4981 | after(grammarAccess.getAssertionOrDefinitionAccess().getGroup_1_1()); | ||
4982 | |||
5392 | } | 4983 | } |
5393 | 4984 | ||
5394 | 4985 | ||
5395 | } | 4986 | } |
5396 | break; | 4987 | break; |
5397 | case 3 : | 4988 | case 3 : |
5398 | // InternalSolverLanguage.g:1599:2: ( ( rule__AssertionOrDefinition__Group_1_2__0 ) ) | 4989 | // InternalSolverLanguageParser.g:1672:2: ( ( rule__AssertionOrDefinition__Group_1_2__0 ) ) |
5399 | { | 4990 | { |
5400 | // InternalSolverLanguage.g:1599:2: ( ( rule__AssertionOrDefinition__Group_1_2__0 ) ) | 4991 | // InternalSolverLanguageParser.g:1672:2: ( ( rule__AssertionOrDefinition__Group_1_2__0 ) ) |
5401 | // InternalSolverLanguage.g:1600:3: ( rule__AssertionOrDefinition__Group_1_2__0 ) | 4992 | // InternalSolverLanguageParser.g:1673:3: ( rule__AssertionOrDefinition__Group_1_2__0 ) |
5402 | { | 4993 | { |
5403 | if ( state.backtracking==0 ) { | 4994 | before(grammarAccess.getAssertionOrDefinitionAccess().getGroup_1_2()); |
5404 | before(grammarAccess.getAssertionOrDefinitionAccess().getGroup_1_2()); | 4995 | // InternalSolverLanguageParser.g:1674:3: ( rule__AssertionOrDefinition__Group_1_2__0 ) |
5405 | } | 4996 | // InternalSolverLanguageParser.g:1674:4: rule__AssertionOrDefinition__Group_1_2__0 |
5406 | // InternalSolverLanguage.g:1601:3: ( rule__AssertionOrDefinition__Group_1_2__0 ) | ||
5407 | // InternalSolverLanguage.g:1601:4: rule__AssertionOrDefinition__Group_1_2__0 | ||
5408 | { | 4997 | { |
5409 | pushFollow(FOLLOW_2); | 4998 | pushFollow(FOLLOW_2); |
5410 | rule__AssertionOrDefinition__Group_1_2__0(); | 4999 | rule__AssertionOrDefinition__Group_1_2__0(); |
5411 | 5000 | ||
5412 | state._fsp--; | 5001 | state._fsp--; |
5413 | if (state.failed) return ; | ||
5414 | 5002 | ||
5415 | } | ||
5416 | 5003 | ||
5417 | if ( state.backtracking==0 ) { | ||
5418 | after(grammarAccess.getAssertionOrDefinitionAccess().getGroup_1_2()); | ||
5419 | } | 5004 | } |
5420 | 5005 | ||
5006 | after(grammarAccess.getAssertionOrDefinitionAccess().getGroup_1_2()); | ||
5007 | |||
5421 | } | 5008 | } |
5422 | 5009 | ||
5423 | 5010 | ||
@@ -5441,24 +5028,23 @@ public class InternalSolverLanguageParser extends AbstractInternalContentAssistP | |||
5441 | 5028 | ||
5442 | 5029 | ||
5443 | // $ANTLR start "rule__PredicateDefinition__Alternatives_0" | 5030 | // $ANTLR start "rule__PredicateDefinition__Alternatives_0" |
5444 | // InternalSolverLanguage.g:1609:1: rule__PredicateDefinition__Alternatives_0 : ( ( ( rule__PredicateDefinition__Group_0_0__0 ) ) | ( ( rule__PredicateDefinition__Group_0_1__0 ) ) ); | 5031 | // InternalSolverLanguageParser.g:1682:1: rule__PredicateDefinition__Alternatives_0 : ( ( ( rule__PredicateDefinition__Group_0_0__0 ) ) | ( ( rule__PredicateDefinition__Group_0_1__0 ) ) ); |
5445 | public final void rule__PredicateDefinition__Alternatives_0() throws RecognitionException { | 5032 | public final void rule__PredicateDefinition__Alternatives_0() throws RecognitionException { |
5446 | 5033 | ||
5447 | int stackSize = keepStackSize(); | 5034 | int stackSize = keepStackSize(); |
5448 | 5035 | ||
5449 | try { | 5036 | try { |
5450 | // InternalSolverLanguage.g:1613:1: ( ( ( rule__PredicateDefinition__Group_0_0__0 ) ) | ( ( rule__PredicateDefinition__Group_0_1__0 ) ) ) | 5037 | // InternalSolverLanguageParser.g:1686:1: ( ( ( rule__PredicateDefinition__Group_0_0__0 ) ) | ( ( rule__PredicateDefinition__Group_0_1__0 ) ) ) |
5451 | int alt4=2; | 5038 | int alt4=2; |
5452 | int LA4_0 = input.LA(1); | 5039 | int LA4_0 = input.LA(1); |
5453 | 5040 | ||
5454 | if ( (LA4_0==72) ) { | 5041 | if ( (LA4_0==Functional) ) { |
5455 | alt4=1; | 5042 | alt4=1; |
5456 | } | 5043 | } |
5457 | else if ( (LA4_0==42) ) { | 5044 | else if ( (LA4_0==Error) ) { |
5458 | alt4=2; | 5045 | alt4=2; |
5459 | } | 5046 | } |
5460 | else { | 5047 | else { |
5461 | if (state.backtracking>0) {state.failed=true; return ;} | ||
5462 | NoViableAltException nvae = | 5048 | NoViableAltException nvae = |
5463 | new NoViableAltException("", 4, 0, input); | 5049 | new NoViableAltException("", 4, 0, input); |
5464 | 5050 | ||
@@ -5466,58 +5052,50 @@ public class InternalSolverLanguageParser extends AbstractInternalContentAssistP | |||
5466 | } | 5052 | } |
5467 | switch (alt4) { | 5053 | switch (alt4) { |
5468 | case 1 : | 5054 | case 1 : |
5469 | // InternalSolverLanguage.g:1614:2: ( ( rule__PredicateDefinition__Group_0_0__0 ) ) | 5055 | // InternalSolverLanguageParser.g:1687:2: ( ( rule__PredicateDefinition__Group_0_0__0 ) ) |
5470 | { | 5056 | { |
5471 | // InternalSolverLanguage.g:1614:2: ( ( rule__PredicateDefinition__Group_0_0__0 ) ) | 5057 | // InternalSolverLanguageParser.g:1687:2: ( ( rule__PredicateDefinition__Group_0_0__0 ) ) |
5472 | // InternalSolverLanguage.g:1615:3: ( rule__PredicateDefinition__Group_0_0__0 ) | 5058 | // InternalSolverLanguageParser.g:1688:3: ( rule__PredicateDefinition__Group_0_0__0 ) |
5473 | { | 5059 | { |
5474 | if ( state.backtracking==0 ) { | 5060 | before(grammarAccess.getPredicateDefinitionAccess().getGroup_0_0()); |
5475 | before(grammarAccess.getPredicateDefinitionAccess().getGroup_0_0()); | 5061 | // InternalSolverLanguageParser.g:1689:3: ( rule__PredicateDefinition__Group_0_0__0 ) |
5476 | } | 5062 | // InternalSolverLanguageParser.g:1689:4: rule__PredicateDefinition__Group_0_0__0 |
5477 | // InternalSolverLanguage.g:1616:3: ( rule__PredicateDefinition__Group_0_0__0 ) | ||
5478 | // InternalSolverLanguage.g:1616:4: rule__PredicateDefinition__Group_0_0__0 | ||
5479 | { | 5063 | { |
5480 | pushFollow(FOLLOW_2); | 5064 | pushFollow(FOLLOW_2); |
5481 | rule__PredicateDefinition__Group_0_0__0(); | 5065 | rule__PredicateDefinition__Group_0_0__0(); |
5482 | 5066 | ||
5483 | state._fsp--; | 5067 | state._fsp--; |
5484 | if (state.failed) return ; | ||
5485 | 5068 | ||
5486 | } | ||
5487 | 5069 | ||
5488 | if ( state.backtracking==0 ) { | ||
5489 | after(grammarAccess.getPredicateDefinitionAccess().getGroup_0_0()); | ||
5490 | } | 5070 | } |
5491 | 5071 | ||
5072 | after(grammarAccess.getPredicateDefinitionAccess().getGroup_0_0()); | ||
5073 | |||
5492 | } | 5074 | } |
5493 | 5075 | ||
5494 | 5076 | ||
5495 | } | 5077 | } |
5496 | break; | 5078 | break; |
5497 | case 2 : | 5079 | case 2 : |
5498 | // InternalSolverLanguage.g:1620:2: ( ( rule__PredicateDefinition__Group_0_1__0 ) ) | 5080 | // InternalSolverLanguageParser.g:1693:2: ( ( rule__PredicateDefinition__Group_0_1__0 ) ) |
5499 | { | 5081 | { |
5500 | // InternalSolverLanguage.g:1620:2: ( ( rule__PredicateDefinition__Group_0_1__0 ) ) | 5082 | // InternalSolverLanguageParser.g:1693:2: ( ( rule__PredicateDefinition__Group_0_1__0 ) ) |
5501 | // InternalSolverLanguage.g:1621:3: ( rule__PredicateDefinition__Group_0_1__0 ) | 5083 | // InternalSolverLanguageParser.g:1694:3: ( rule__PredicateDefinition__Group_0_1__0 ) |
5502 | { | 5084 | { |
5503 | if ( state.backtracking==0 ) { | 5085 | before(grammarAccess.getPredicateDefinitionAccess().getGroup_0_1()); |
5504 | before(grammarAccess.getPredicateDefinitionAccess().getGroup_0_1()); | 5086 | // InternalSolverLanguageParser.g:1695:3: ( rule__PredicateDefinition__Group_0_1__0 ) |
5505 | } | 5087 | // InternalSolverLanguageParser.g:1695:4: rule__PredicateDefinition__Group_0_1__0 |
5506 | // InternalSolverLanguage.g:1622:3: ( rule__PredicateDefinition__Group_0_1__0 ) | ||
5507 | // InternalSolverLanguage.g:1622:4: rule__PredicateDefinition__Group_0_1__0 | ||
5508 | { | 5088 | { |
5509 | pushFollow(FOLLOW_2); | 5089 | pushFollow(FOLLOW_2); |
5510 | rule__PredicateDefinition__Group_0_1__0(); | 5090 | rule__PredicateDefinition__Group_0_1__0(); |
5511 | 5091 | ||
5512 | state._fsp--; | 5092 | state._fsp--; |
5513 | if (state.failed) return ; | ||
5514 | 5093 | ||
5515 | } | ||
5516 | 5094 | ||
5517 | if ( state.backtracking==0 ) { | ||
5518 | after(grammarAccess.getPredicateDefinitionAccess().getGroup_0_1()); | ||
5519 | } | 5095 | } |
5520 | 5096 | ||
5097 | after(grammarAccess.getPredicateDefinitionAccess().getGroup_0_1()); | ||
5098 | |||
5521 | } | 5099 | } |
5522 | 5100 | ||
5523 | 5101 | ||
@@ -5541,24 +5119,23 @@ public class InternalSolverLanguageParser extends AbstractInternalContentAssistP | |||
5541 | 5119 | ||
5542 | 5120 | ||
5543 | // $ANTLR start "rule__Expression__Alternatives" | 5121 | // $ANTLR start "rule__Expression__Alternatives" |
5544 | // InternalSolverLanguage.g:1630:1: rule__Expression__Alternatives : ( ( ruleIfElse ) | ( ruleDisjunctiveExpression ) ); | 5122 | // InternalSolverLanguageParser.g:1703:1: rule__Expression__Alternatives : ( ( ruleIfElse ) | ( ruleDisjunctiveExpression ) ); |
5545 | public final void rule__Expression__Alternatives() throws RecognitionException { | 5123 | public final void rule__Expression__Alternatives() throws RecognitionException { |
5546 | 5124 | ||
5547 | int stackSize = keepStackSize(); | 5125 | int stackSize = keepStackSize(); |
5548 | 5126 | ||
5549 | try { | 5127 | try { |
5550 | // InternalSolverLanguage.g:1634:1: ( ( ruleIfElse ) | ( ruleDisjunctiveExpression ) ) | 5128 | // InternalSolverLanguageParser.g:1707:1: ( ( ruleIfElse ) | ( ruleDisjunctiveExpression ) ) |
5551 | int alt5=2; | 5129 | int alt5=2; |
5552 | int LA5_0 = input.LA(1); | 5130 | int LA5_0 = input.LA(1); |
5553 | 5131 | ||
5554 | if ( (LA5_0==51) ) { | 5132 | if ( (LA5_0==If) ) { |
5555 | alt5=1; | 5133 | alt5=1; |
5556 | } | 5134 | } |
5557 | else if ( ((LA5_0>=RULE_INT && LA5_0<=RULE_QUOTED_ID)||LA5_0==RULE_ID||LA5_0==RULE_STRING||(LA5_0>=26 && LA5_0<=27)||(LA5_0>=29 && LA5_0<=42)||LA5_0==57||LA5_0==61||LA5_0==63||(LA5_0>=66 && LA5_0<=67)) ) { | 5135 | else if ( (LA5_0==Current||LA5_0==Unknown||(LA5_0>=Count && LA5_0<=False)||(LA5_0>=Must && LA5_0<=Prod)||LA5_0==True||(LA5_0>=Avg && LA5_0<=Inf)||(LA5_0>=Max && LA5_0<=Sum)||(LA5_0>=ExclamationMark && LA5_0<=LeftParenthesis)||LA5_0==PlusSign||LA5_0==HyphenMinus||LA5_0==LeftSquareBracket||(LA5_0>=RULE_STRING && LA5_0<=RULE_QUOTED_ID)||(LA5_0>=RULE_ID && LA5_0<=RULE_INT)) ) { |
5558 | alt5=2; | 5136 | alt5=2; |
5559 | } | 5137 | } |
5560 | else { | 5138 | else { |
5561 | if (state.backtracking>0) {state.failed=true; return ;} | ||
5562 | NoViableAltException nvae = | 5139 | NoViableAltException nvae = |
5563 | new NoViableAltException("", 5, 0, input); | 5140 | new NoViableAltException("", 5, 0, input); |
5564 | 5141 | ||
@@ -5566,22 +5143,18 @@ public class InternalSolverLanguageParser extends AbstractInternalContentAssistP | |||
5566 | } | 5143 | } |
5567 | switch (alt5) { | 5144 | switch (alt5) { |
5568 | case 1 : | 5145 | case 1 : |
5569 | // InternalSolverLanguage.g:1635:2: ( ruleIfElse ) | 5146 | // InternalSolverLanguageParser.g:1708:2: ( ruleIfElse ) |
5570 | { | 5147 | { |
5571 | // InternalSolverLanguage.g:1635:2: ( ruleIfElse ) | 5148 | // InternalSolverLanguageParser.g:1708:2: ( ruleIfElse ) |
5572 | // InternalSolverLanguage.g:1636:3: ruleIfElse | 5149 | // InternalSolverLanguageParser.g:1709:3: ruleIfElse |
5573 | { | 5150 | { |
5574 | if ( state.backtracking==0 ) { | 5151 | before(grammarAccess.getExpressionAccess().getIfElseParserRuleCall_0()); |
5575 | before(grammarAccess.getExpressionAccess().getIfElseParserRuleCall_0()); | ||
5576 | } | ||
5577 | pushFollow(FOLLOW_2); | 5152 | pushFollow(FOLLOW_2); |
5578 | ruleIfElse(); | 5153 | ruleIfElse(); |
5579 | 5154 | ||
5580 | state._fsp--; | 5155 | state._fsp--; |
5581 | if (state.failed) return ; | 5156 | |
5582 | if ( state.backtracking==0 ) { | 5157 | after(grammarAccess.getExpressionAccess().getIfElseParserRuleCall_0()); |
5583 | after(grammarAccess.getExpressionAccess().getIfElseParserRuleCall_0()); | ||
5584 | } | ||
5585 | 5158 | ||
5586 | } | 5159 | } |
5587 | 5160 | ||
@@ -5589,22 +5162,18 @@ public class InternalSolverLanguageParser extends AbstractInternalContentAssistP | |||
5589 | } | 5162 | } |
5590 | break; | 5163 | break; |
5591 | case 2 : | 5164 | case 2 : |
5592 | // InternalSolverLanguage.g:1641:2: ( ruleDisjunctiveExpression ) | 5165 | // InternalSolverLanguageParser.g:1714:2: ( ruleDisjunctiveExpression ) |
5593 | { | 5166 | { |
5594 | // InternalSolverLanguage.g:1641:2: ( ruleDisjunctiveExpression ) | 5167 | // InternalSolverLanguageParser.g:1714:2: ( ruleDisjunctiveExpression ) |
5595 | // InternalSolverLanguage.g:1642:3: ruleDisjunctiveExpression | 5168 | // InternalSolverLanguageParser.g:1715:3: ruleDisjunctiveExpression |
5596 | { | 5169 | { |
5597 | if ( state.backtracking==0 ) { | 5170 | before(grammarAccess.getExpressionAccess().getDisjunctiveExpressionParserRuleCall_1()); |
5598 | before(grammarAccess.getExpressionAccess().getDisjunctiveExpressionParserRuleCall_1()); | ||
5599 | } | ||
5600 | pushFollow(FOLLOW_2); | 5171 | pushFollow(FOLLOW_2); |
5601 | ruleDisjunctiveExpression(); | 5172 | ruleDisjunctiveExpression(); |
5602 | 5173 | ||
5603 | state._fsp--; | 5174 | state._fsp--; |
5604 | if (state.failed) return ; | 5175 | |
5605 | if ( state.backtracking==0 ) { | 5176 | after(grammarAccess.getExpressionAccess().getDisjunctiveExpressionParserRuleCall_1()); |
5606 | after(grammarAccess.getExpressionAccess().getDisjunctiveExpressionParserRuleCall_1()); | ||
5607 | } | ||
5608 | 5177 | ||
5609 | } | 5178 | } |
5610 | 5179 | ||
@@ -5629,24 +5198,23 @@ public class InternalSolverLanguageParser extends AbstractInternalContentAssistP | |||
5629 | 5198 | ||
5630 | 5199 | ||
5631 | // $ANTLR start "rule__DisjunctiveExpression__Alternatives_1" | 5200 | // $ANTLR start "rule__DisjunctiveExpression__Alternatives_1" |
5632 | // InternalSolverLanguage.g:1651:1: rule__DisjunctiveExpression__Alternatives_1 : ( ( ( rule__DisjunctiveExpression__Group_1_0__0 ) ) | ( ( rule__DisjunctiveExpression__Group_1_1__0 ) ) ); | 5201 | // InternalSolverLanguageParser.g:1724:1: rule__DisjunctiveExpression__Alternatives_1 : ( ( ( rule__DisjunctiveExpression__Group_1_0__0 ) ) | ( ( rule__DisjunctiveExpression__Group_1_1__0 ) ) ); |
5633 | public final void rule__DisjunctiveExpression__Alternatives_1() throws RecognitionException { | 5202 | public final void rule__DisjunctiveExpression__Alternatives_1() throws RecognitionException { |
5634 | 5203 | ||
5635 | int stackSize = keepStackSize(); | 5204 | int stackSize = keepStackSize(); |
5636 | 5205 | ||
5637 | try { | 5206 | try { |
5638 | // InternalSolverLanguage.g:1655:1: ( ( ( rule__DisjunctiveExpression__Group_1_0__0 ) ) | ( ( rule__DisjunctiveExpression__Group_1_1__0 ) ) ) | 5207 | // InternalSolverLanguageParser.g:1728:1: ( ( ( rule__DisjunctiveExpression__Group_1_0__0 ) ) | ( ( rule__DisjunctiveExpression__Group_1_1__0 ) ) ) |
5639 | int alt6=2; | 5208 | int alt6=2; |
5640 | int LA6_0 = input.LA(1); | 5209 | int LA6_0 = input.LA(1); |
5641 | 5210 | ||
5642 | if ( (LA6_0==54) ) { | 5211 | if ( (LA6_0==Semicolon) ) { |
5643 | alt6=1; | 5212 | alt6=1; |
5644 | } | 5213 | } |
5645 | else if ( (LA6_0==55) ) { | 5214 | else if ( (LA6_0==HyphenMinusGreaterThanSign) ) { |
5646 | alt6=2; | 5215 | alt6=2; |
5647 | } | 5216 | } |
5648 | else { | 5217 | else { |
5649 | if (state.backtracking>0) {state.failed=true; return ;} | ||
5650 | NoViableAltException nvae = | 5218 | NoViableAltException nvae = |
5651 | new NoViableAltException("", 6, 0, input); | 5219 | new NoViableAltException("", 6, 0, input); |
5652 | 5220 | ||
@@ -5654,58 +5222,50 @@ public class InternalSolverLanguageParser extends AbstractInternalContentAssistP | |||
5654 | } | 5222 | } |
5655 | switch (alt6) { | 5223 | switch (alt6) { |
5656 | case 1 : | 5224 | case 1 : |
5657 | // InternalSolverLanguage.g:1656:2: ( ( rule__DisjunctiveExpression__Group_1_0__0 ) ) | 5225 | // InternalSolverLanguageParser.g:1729:2: ( ( rule__DisjunctiveExpression__Group_1_0__0 ) ) |
5658 | { | 5226 | { |
5659 | // InternalSolverLanguage.g:1656:2: ( ( rule__DisjunctiveExpression__Group_1_0__0 ) ) | 5227 | // InternalSolverLanguageParser.g:1729:2: ( ( rule__DisjunctiveExpression__Group_1_0__0 ) ) |
5660 | // InternalSolverLanguage.g:1657:3: ( rule__DisjunctiveExpression__Group_1_0__0 ) | 5228 | // InternalSolverLanguageParser.g:1730:3: ( rule__DisjunctiveExpression__Group_1_0__0 ) |
5661 | { | 5229 | { |
5662 | if ( state.backtracking==0 ) { | 5230 | before(grammarAccess.getDisjunctiveExpressionAccess().getGroup_1_0()); |
5663 | before(grammarAccess.getDisjunctiveExpressionAccess().getGroup_1_0()); | 5231 | // InternalSolverLanguageParser.g:1731:3: ( rule__DisjunctiveExpression__Group_1_0__0 ) |
5664 | } | 5232 | // InternalSolverLanguageParser.g:1731:4: rule__DisjunctiveExpression__Group_1_0__0 |
5665 | // InternalSolverLanguage.g:1658:3: ( rule__DisjunctiveExpression__Group_1_0__0 ) | ||
5666 | // InternalSolverLanguage.g:1658:4: rule__DisjunctiveExpression__Group_1_0__0 | ||
5667 | { | 5233 | { |
5668 | pushFollow(FOLLOW_2); | 5234 | pushFollow(FOLLOW_2); |
5669 | rule__DisjunctiveExpression__Group_1_0__0(); | 5235 | rule__DisjunctiveExpression__Group_1_0__0(); |
5670 | 5236 | ||
5671 | state._fsp--; | 5237 | state._fsp--; |
5672 | if (state.failed) return ; | ||
5673 | 5238 | ||
5674 | } | ||
5675 | 5239 | ||
5676 | if ( state.backtracking==0 ) { | ||
5677 | after(grammarAccess.getDisjunctiveExpressionAccess().getGroup_1_0()); | ||
5678 | } | 5240 | } |
5679 | 5241 | ||
5242 | after(grammarAccess.getDisjunctiveExpressionAccess().getGroup_1_0()); | ||
5243 | |||
5680 | } | 5244 | } |
5681 | 5245 | ||
5682 | 5246 | ||
5683 | } | 5247 | } |
5684 | break; | 5248 | break; |
5685 | case 2 : | 5249 | case 2 : |
5686 | // InternalSolverLanguage.g:1662:2: ( ( rule__DisjunctiveExpression__Group_1_1__0 ) ) | 5250 | // InternalSolverLanguageParser.g:1735:2: ( ( rule__DisjunctiveExpression__Group_1_1__0 ) ) |
5687 | { | 5251 | { |
5688 | // InternalSolverLanguage.g:1662:2: ( ( rule__DisjunctiveExpression__Group_1_1__0 ) ) | 5252 | // InternalSolverLanguageParser.g:1735:2: ( ( rule__DisjunctiveExpression__Group_1_1__0 ) ) |
5689 | // InternalSolverLanguage.g:1663:3: ( rule__DisjunctiveExpression__Group_1_1__0 ) | 5253 | // InternalSolverLanguageParser.g:1736:3: ( rule__DisjunctiveExpression__Group_1_1__0 ) |
5690 | { | 5254 | { |
5691 | if ( state.backtracking==0 ) { | 5255 | before(grammarAccess.getDisjunctiveExpressionAccess().getGroup_1_1()); |
5692 | before(grammarAccess.getDisjunctiveExpressionAccess().getGroup_1_1()); | 5256 | // InternalSolverLanguageParser.g:1737:3: ( rule__DisjunctiveExpression__Group_1_1__0 ) |
5693 | } | 5257 | // InternalSolverLanguageParser.g:1737:4: rule__DisjunctiveExpression__Group_1_1__0 |
5694 | // InternalSolverLanguage.g:1664:3: ( rule__DisjunctiveExpression__Group_1_1__0 ) | ||
5695 | // InternalSolverLanguage.g:1664:4: rule__DisjunctiveExpression__Group_1_1__0 | ||
5696 | { | 5258 | { |
5697 | pushFollow(FOLLOW_2); | 5259 | pushFollow(FOLLOW_2); |
5698 | rule__DisjunctiveExpression__Group_1_1__0(); | 5260 | rule__DisjunctiveExpression__Group_1_1__0(); |
5699 | 5261 | ||
5700 | state._fsp--; | 5262 | state._fsp--; |
5701 | if (state.failed) return ; | ||
5702 | 5263 | ||
5703 | } | ||
5704 | 5264 | ||
5705 | if ( state.backtracking==0 ) { | ||
5706 | after(grammarAccess.getDisjunctiveExpressionAccess().getGroup_1_1()); | ||
5707 | } | 5265 | } |
5708 | 5266 | ||
5267 | after(grammarAccess.getDisjunctiveExpressionAccess().getGroup_1_1()); | ||
5268 | |||
5709 | } | 5269 | } |
5710 | 5270 | ||
5711 | 5271 | ||
@@ -5729,24 +5289,23 @@ public class InternalSolverLanguageParser extends AbstractInternalContentAssistP | |||
5729 | 5289 | ||
5730 | 5290 | ||
5731 | // $ANTLR start "rule__UnaryExpression__Alternatives" | 5291 | // $ANTLR start "rule__UnaryExpression__Alternatives" |
5732 | // InternalSolverLanguage.g:1672:1: rule__UnaryExpression__Alternatives : ( ( ruleAggregationExpression ) | ( ( rule__UnaryExpression__Group_1__0 ) ) ); | 5292 | // InternalSolverLanguageParser.g:1745:1: rule__UnaryExpression__Alternatives : ( ( ruleAggregationExpression ) | ( ( rule__UnaryExpression__Group_1__0 ) ) ); |
5733 | public final void rule__UnaryExpression__Alternatives() throws RecognitionException { | 5293 | public final void rule__UnaryExpression__Alternatives() throws RecognitionException { |
5734 | 5294 | ||
5735 | int stackSize = keepStackSize(); | 5295 | int stackSize = keepStackSize(); |
5736 | 5296 | ||
5737 | try { | 5297 | try { |
5738 | // InternalSolverLanguage.g:1676:1: ( ( ruleAggregationExpression ) | ( ( rule__UnaryExpression__Group_1__0 ) ) ) | 5298 | // InternalSolverLanguageParser.g:1749:1: ( ( ruleAggregationExpression ) | ( ( rule__UnaryExpression__Group_1__0 ) ) ) |
5739 | int alt7=2; | 5299 | int alt7=2; |
5740 | int LA7_0 = input.LA(1); | 5300 | int LA7_0 = input.LA(1); |
5741 | 5301 | ||
5742 | if ( ((LA7_0>=RULE_INT && LA7_0<=RULE_QUOTED_ID)||LA7_0==RULE_ID||LA7_0==RULE_STRING||(LA7_0>=33 && LA7_0<=42)||LA7_0==57||LA7_0==61||LA7_0==63||(LA7_0>=66 && LA7_0<=67)) ) { | 5302 | if ( (LA7_0==Unknown||(LA7_0>=Count && LA7_0<=False)||(LA7_0>=Only && LA7_0<=Prod)||LA7_0==True||(LA7_0>=Avg && LA7_0<=Inf)||LA7_0==Max||(LA7_0>=Min && LA7_0<=Sum)||LA7_0==LeftParenthesis||LA7_0==LeftSquareBracket||(LA7_0>=RULE_STRING && LA7_0<=RULE_QUOTED_ID)||(LA7_0>=RULE_ID && LA7_0<=RULE_INT)) ) { |
5743 | alt7=1; | 5303 | alt7=1; |
5744 | } | 5304 | } |
5745 | else if ( ((LA7_0>=26 && LA7_0<=27)||(LA7_0>=29 && LA7_0<=32)) ) { | 5305 | else if ( (LA7_0==Current||LA7_0==Must||LA7_0==May||LA7_0==ExclamationMark||LA7_0==PlusSign||LA7_0==HyphenMinus) ) { |
5746 | alt7=2; | 5306 | alt7=2; |
5747 | } | 5307 | } |
5748 | else { | 5308 | else { |
5749 | if (state.backtracking>0) {state.failed=true; return ;} | ||
5750 | NoViableAltException nvae = | 5309 | NoViableAltException nvae = |
5751 | new NoViableAltException("", 7, 0, input); | 5310 | new NoViableAltException("", 7, 0, input); |
5752 | 5311 | ||
@@ -5754,22 +5313,18 @@ public class InternalSolverLanguageParser extends AbstractInternalContentAssistP | |||
5754 | } | 5313 | } |
5755 | switch (alt7) { | 5314 | switch (alt7) { |
5756 | case 1 : | 5315 | case 1 : |
5757 | // InternalSolverLanguage.g:1677:2: ( ruleAggregationExpression ) | 5316 | // InternalSolverLanguageParser.g:1750:2: ( ruleAggregationExpression ) |
5758 | { | 5317 | { |
5759 | // InternalSolverLanguage.g:1677:2: ( ruleAggregationExpression ) | 5318 | // InternalSolverLanguageParser.g:1750:2: ( ruleAggregationExpression ) |
5760 | // InternalSolverLanguage.g:1678:3: ruleAggregationExpression | 5319 | // InternalSolverLanguageParser.g:1751:3: ruleAggregationExpression |
5761 | { | 5320 | { |
5762 | if ( state.backtracking==0 ) { | 5321 | before(grammarAccess.getUnaryExpressionAccess().getAggregationExpressionParserRuleCall_0()); |
5763 | before(grammarAccess.getUnaryExpressionAccess().getAggregationExpressionParserRuleCall_0()); | ||
5764 | } | ||
5765 | pushFollow(FOLLOW_2); | 5322 | pushFollow(FOLLOW_2); |
5766 | ruleAggregationExpression(); | 5323 | ruleAggregationExpression(); |
5767 | 5324 | ||
5768 | state._fsp--; | 5325 | state._fsp--; |
5769 | if (state.failed) return ; | 5326 | |
5770 | if ( state.backtracking==0 ) { | 5327 | after(grammarAccess.getUnaryExpressionAccess().getAggregationExpressionParserRuleCall_0()); |
5771 | after(grammarAccess.getUnaryExpressionAccess().getAggregationExpressionParserRuleCall_0()); | ||
5772 | } | ||
5773 | 5328 | ||
5774 | } | 5329 | } |
5775 | 5330 | ||
@@ -5777,29 +5332,25 @@ public class InternalSolverLanguageParser extends AbstractInternalContentAssistP | |||
5777 | } | 5332 | } |
5778 | break; | 5333 | break; |
5779 | case 2 : | 5334 | case 2 : |
5780 | // InternalSolverLanguage.g:1683:2: ( ( rule__UnaryExpression__Group_1__0 ) ) | 5335 | // InternalSolverLanguageParser.g:1756:2: ( ( rule__UnaryExpression__Group_1__0 ) ) |
5781 | { | 5336 | { |
5782 | // InternalSolverLanguage.g:1683:2: ( ( rule__UnaryExpression__Group_1__0 ) ) | 5337 | // InternalSolverLanguageParser.g:1756:2: ( ( rule__UnaryExpression__Group_1__0 ) ) |
5783 | // InternalSolverLanguage.g:1684:3: ( rule__UnaryExpression__Group_1__0 ) | 5338 | // InternalSolverLanguageParser.g:1757:3: ( rule__UnaryExpression__Group_1__0 ) |
5784 | { | 5339 | { |
5785 | if ( state.backtracking==0 ) { | 5340 | before(grammarAccess.getUnaryExpressionAccess().getGroup_1()); |
5786 | before(grammarAccess.getUnaryExpressionAccess().getGroup_1()); | 5341 | // InternalSolverLanguageParser.g:1758:3: ( rule__UnaryExpression__Group_1__0 ) |
5787 | } | 5342 | // InternalSolverLanguageParser.g:1758:4: rule__UnaryExpression__Group_1__0 |
5788 | // InternalSolverLanguage.g:1685:3: ( rule__UnaryExpression__Group_1__0 ) | ||
5789 | // InternalSolverLanguage.g:1685:4: rule__UnaryExpression__Group_1__0 | ||
5790 | { | 5343 | { |
5791 | pushFollow(FOLLOW_2); | 5344 | pushFollow(FOLLOW_2); |
5792 | rule__UnaryExpression__Group_1__0(); | 5345 | rule__UnaryExpression__Group_1__0(); |
5793 | 5346 | ||
5794 | state._fsp--; | 5347 | state._fsp--; |
5795 | if (state.failed) return ; | ||
5796 | 5348 | ||
5797 | } | ||
5798 | 5349 | ||
5799 | if ( state.backtracking==0 ) { | ||
5800 | after(grammarAccess.getUnaryExpressionAccess().getGroup_1()); | ||
5801 | } | 5350 | } |
5802 | 5351 | ||
5352 | after(grammarAccess.getUnaryExpressionAccess().getGroup_1()); | ||
5353 | |||
5803 | } | 5354 | } |
5804 | 5355 | ||
5805 | 5356 | ||
@@ -5823,48 +5374,47 @@ public class InternalSolverLanguageParser extends AbstractInternalContentAssistP | |||
5823 | 5374 | ||
5824 | 5375 | ||
5825 | // $ANTLR start "rule__AggregationExpression__Alternatives" | 5376 | // $ANTLR start "rule__AggregationExpression__Alternatives" |
5826 | // InternalSolverLanguage.g:1693:1: rule__AggregationExpression__Alternatives : ( ( ruleAtomicExpression ) | ( ruleCount ) | ( ruleAggregation ) ); | 5377 | // InternalSolverLanguageParser.g:1766:1: rule__AggregationExpression__Alternatives : ( ( ruleAtomicExpression ) | ( ruleCount ) | ( ruleAggregation ) ); |
5827 | public final void rule__AggregationExpression__Alternatives() throws RecognitionException { | 5378 | public final void rule__AggregationExpression__Alternatives() throws RecognitionException { |
5828 | 5379 | ||
5829 | int stackSize = keepStackSize(); | 5380 | int stackSize = keepStackSize(); |
5830 | 5381 | ||
5831 | try { | 5382 | try { |
5832 | // InternalSolverLanguage.g:1697:1: ( ( ruleAtomicExpression ) | ( ruleCount ) | ( ruleAggregation ) ) | 5383 | // InternalSolverLanguageParser.g:1770:1: ( ( ruleAtomicExpression ) | ( ruleCount ) | ( ruleAggregation ) ) |
5833 | int alt8=3; | 5384 | int alt8=3; |
5834 | switch ( input.LA(1) ) { | 5385 | switch ( input.LA(1) ) { |
5835 | case RULE_INT: | 5386 | case Unknown: |
5387 | case Empty: | ||
5388 | case Error: | ||
5389 | case False: | ||
5390 | case True: | ||
5391 | case Inf: | ||
5392 | case LeftParenthesis: | ||
5393 | case LeftSquareBracket: | ||
5394 | case RULE_STRING: | ||
5836 | case RULE_QUOTED_ID: | 5395 | case RULE_QUOTED_ID: |
5837 | case RULE_ID: | 5396 | case RULE_ID: |
5838 | case RULE_STRING: | 5397 | case RULE_INT: |
5839 | case 39: | ||
5840 | case 40: | ||
5841 | case 41: | ||
5842 | case 42: | ||
5843 | case 61: | ||
5844 | case 63: | ||
5845 | case 66: | ||
5846 | case 67: | ||
5847 | { | 5398 | { |
5848 | alt8=1; | 5399 | alt8=1; |
5849 | } | 5400 | } |
5850 | break; | 5401 | break; |
5851 | case 57: | 5402 | case Count: |
5852 | { | 5403 | { |
5853 | alt8=2; | 5404 | alt8=2; |
5854 | } | 5405 | } |
5855 | break; | 5406 | break; |
5856 | case 33: | 5407 | case Only: |
5857 | case 34: | 5408 | case Prod: |
5858 | case 35: | 5409 | case Avg: |
5859 | case 36: | 5410 | case Max: |
5860 | case 37: | 5411 | case Min: |
5861 | case 38: | 5412 | case Sum: |
5862 | { | 5413 | { |
5863 | alt8=3; | 5414 | alt8=3; |
5864 | } | 5415 | } |
5865 | break; | 5416 | break; |
5866 | default: | 5417 | default: |
5867 | if (state.backtracking>0) {state.failed=true; return ;} | ||
5868 | NoViableAltException nvae = | 5418 | NoViableAltException nvae = |
5869 | new NoViableAltException("", 8, 0, input); | 5419 | new NoViableAltException("", 8, 0, input); |
5870 | 5420 | ||
@@ -5873,22 +5423,18 @@ public class InternalSolverLanguageParser extends AbstractInternalContentAssistP | |||
5873 | 5423 | ||
5874 | switch (alt8) { | 5424 | switch (alt8) { |
5875 | case 1 : | 5425 | case 1 : |
5876 | // InternalSolverLanguage.g:1698:2: ( ruleAtomicExpression ) | 5426 | // InternalSolverLanguageParser.g:1771:2: ( ruleAtomicExpression ) |
5877 | { | 5427 | { |
5878 | // InternalSolverLanguage.g:1698:2: ( ruleAtomicExpression ) | 5428 | // InternalSolverLanguageParser.g:1771:2: ( ruleAtomicExpression ) |
5879 | // InternalSolverLanguage.g:1699:3: ruleAtomicExpression | 5429 | // InternalSolverLanguageParser.g:1772:3: ruleAtomicExpression |
5880 | { | 5430 | { |
5881 | if ( state.backtracking==0 ) { | 5431 | before(grammarAccess.getAggregationExpressionAccess().getAtomicExpressionParserRuleCall_0()); |
5882 | before(grammarAccess.getAggregationExpressionAccess().getAtomicExpressionParserRuleCall_0()); | ||
5883 | } | ||
5884 | pushFollow(FOLLOW_2); | 5432 | pushFollow(FOLLOW_2); |
5885 | ruleAtomicExpression(); | 5433 | ruleAtomicExpression(); |
5886 | 5434 | ||
5887 | state._fsp--; | 5435 | state._fsp--; |
5888 | if (state.failed) return ; | 5436 | |
5889 | if ( state.backtracking==0 ) { | 5437 | after(grammarAccess.getAggregationExpressionAccess().getAtomicExpressionParserRuleCall_0()); |
5890 | after(grammarAccess.getAggregationExpressionAccess().getAtomicExpressionParserRuleCall_0()); | ||
5891 | } | ||
5892 | 5438 | ||
5893 | } | 5439 | } |
5894 | 5440 | ||
@@ -5896,22 +5442,18 @@ public class InternalSolverLanguageParser extends AbstractInternalContentAssistP | |||
5896 | } | 5442 | } |
5897 | break; | 5443 | break; |
5898 | case 2 : | 5444 | case 2 : |
5899 | // InternalSolverLanguage.g:1704:2: ( ruleCount ) | 5445 | // InternalSolverLanguageParser.g:1777:2: ( ruleCount ) |
5900 | { | 5446 | { |
5901 | // InternalSolverLanguage.g:1704:2: ( ruleCount ) | 5447 | // InternalSolverLanguageParser.g:1777:2: ( ruleCount ) |
5902 | // InternalSolverLanguage.g:1705:3: ruleCount | 5448 | // InternalSolverLanguageParser.g:1778:3: ruleCount |
5903 | { | 5449 | { |
5904 | if ( state.backtracking==0 ) { | 5450 | before(grammarAccess.getAggregationExpressionAccess().getCountParserRuleCall_1()); |
5905 | before(grammarAccess.getAggregationExpressionAccess().getCountParserRuleCall_1()); | ||
5906 | } | ||
5907 | pushFollow(FOLLOW_2); | 5451 | pushFollow(FOLLOW_2); |
5908 | ruleCount(); | 5452 | ruleCount(); |
5909 | 5453 | ||
5910 | state._fsp--; | 5454 | state._fsp--; |
5911 | if (state.failed) return ; | 5455 | |
5912 | if ( state.backtracking==0 ) { | 5456 | after(grammarAccess.getAggregationExpressionAccess().getCountParserRuleCall_1()); |
5913 | after(grammarAccess.getAggregationExpressionAccess().getCountParserRuleCall_1()); | ||
5914 | } | ||
5915 | 5457 | ||
5916 | } | 5458 | } |
5917 | 5459 | ||
@@ -5919,22 +5461,18 @@ public class InternalSolverLanguageParser extends AbstractInternalContentAssistP | |||
5919 | } | 5461 | } |
5920 | break; | 5462 | break; |
5921 | case 3 : | 5463 | case 3 : |
5922 | // InternalSolverLanguage.g:1710:2: ( ruleAggregation ) | 5464 | // InternalSolverLanguageParser.g:1783:2: ( ruleAggregation ) |
5923 | { | 5465 | { |
5924 | // InternalSolverLanguage.g:1710:2: ( ruleAggregation ) | 5466 | // InternalSolverLanguageParser.g:1783:2: ( ruleAggregation ) |
5925 | // InternalSolverLanguage.g:1711:3: ruleAggregation | 5467 | // InternalSolverLanguageParser.g:1784:3: ruleAggregation |
5926 | { | 5468 | { |
5927 | if ( state.backtracking==0 ) { | 5469 | before(grammarAccess.getAggregationExpressionAccess().getAggregationParserRuleCall_2()); |
5928 | before(grammarAccess.getAggregationExpressionAccess().getAggregationParserRuleCall_2()); | ||
5929 | } | ||
5930 | pushFollow(FOLLOW_2); | 5470 | pushFollow(FOLLOW_2); |
5931 | ruleAggregation(); | 5471 | ruleAggregation(); |
5932 | 5472 | ||
5933 | state._fsp--; | 5473 | state._fsp--; |
5934 | if (state.failed) return ; | 5474 | |
5935 | if ( state.backtracking==0 ) { | 5475 | after(grammarAccess.getAggregationExpressionAccess().getAggregationParserRuleCall_2()); |
5936 | after(grammarAccess.getAggregationExpressionAccess().getAggregationParserRuleCall_2()); | ||
5937 | } | ||
5938 | 5476 | ||
5939 | } | 5477 | } |
5940 | 5478 | ||
@@ -5959,151 +5497,112 @@ public class InternalSolverLanguageParser extends AbstractInternalContentAssistP | |||
5959 | 5497 | ||
5960 | 5498 | ||
5961 | // $ANTLR start "rule__AtomicExpression__Alternatives" | 5499 | // $ANTLR start "rule__AtomicExpression__Alternatives" |
5962 | // InternalSolverLanguage.g:1720:1: rule__AtomicExpression__Alternatives : ( ( ( rule__AtomicExpression__Group_0__0 ) ) | ( ruleInterval ) | ( ruleLiteral ) | ( ( rule__AtomicExpression__Group_3__0 ) ) ); | 5500 | // InternalSolverLanguageParser.g:1793:1: rule__AtomicExpression__Alternatives : ( ( ruleReference ) | ( ruleCall ) | ( ruleInterval ) | ( ruleLiteral ) | ( ( rule__AtomicExpression__Group_4__0 ) ) ); |
5963 | public final void rule__AtomicExpression__Alternatives() throws RecognitionException { | 5501 | public final void rule__AtomicExpression__Alternatives() throws RecognitionException { |
5964 | 5502 | ||
5965 | int stackSize = keepStackSize(); | 5503 | int stackSize = keepStackSize(); |
5966 | 5504 | ||
5967 | try { | 5505 | try { |
5968 | // InternalSolverLanguage.g:1724:1: ( ( ( rule__AtomicExpression__Group_0__0 ) ) | ( ruleInterval ) | ( ruleLiteral ) | ( ( rule__AtomicExpression__Group_3__0 ) ) ) | 5506 | // InternalSolverLanguageParser.g:1797:1: ( ( ruleReference ) | ( ruleCall ) | ( ruleInterval ) | ( ruleLiteral ) | ( ( rule__AtomicExpression__Group_4__0 ) ) ) |
5969 | int alt9=4; | 5507 | int alt9=5; |
5970 | switch ( input.LA(1) ) { | 5508 | alt9 = dfa9.predict(input); |
5971 | case RULE_QUOTED_ID: | ||
5972 | case RULE_ID: | ||
5973 | { | ||
5974 | alt9=1; | ||
5975 | } | ||
5976 | break; | ||
5977 | case 63: | ||
5978 | { | ||
5979 | alt9=2; | ||
5980 | } | ||
5981 | break; | ||
5982 | case RULE_INT: | ||
5983 | case RULE_STRING: | ||
5984 | case 39: | ||
5985 | case 40: | ||
5986 | case 41: | ||
5987 | case 42: | ||
5988 | case 66: | ||
5989 | case 67: | ||
5990 | { | ||
5991 | alt9=3; | ||
5992 | } | ||
5993 | break; | ||
5994 | case 61: | ||
5995 | { | ||
5996 | alt9=4; | ||
5997 | } | ||
5998 | break; | ||
5999 | default: | ||
6000 | if (state.backtracking>0) {state.failed=true; return ;} | ||
6001 | NoViableAltException nvae = | ||
6002 | new NoViableAltException("", 9, 0, input); | ||
6003 | |||
6004 | throw nvae; | ||
6005 | } | ||
6006 | |||
6007 | switch (alt9) { | 5509 | switch (alt9) { |
6008 | case 1 : | 5510 | case 1 : |
6009 | // InternalSolverLanguage.g:1725:2: ( ( rule__AtomicExpression__Group_0__0 ) ) | 5511 | // InternalSolverLanguageParser.g:1798:2: ( ruleReference ) |
6010 | { | 5512 | { |
6011 | // InternalSolverLanguage.g:1725:2: ( ( rule__AtomicExpression__Group_0__0 ) ) | 5513 | // InternalSolverLanguageParser.g:1798:2: ( ruleReference ) |
6012 | // InternalSolverLanguage.g:1726:3: ( rule__AtomicExpression__Group_0__0 ) | 5514 | // InternalSolverLanguageParser.g:1799:3: ruleReference |
6013 | { | ||
6014 | if ( state.backtracking==0 ) { | ||
6015 | before(grammarAccess.getAtomicExpressionAccess().getGroup_0()); | ||
6016 | } | ||
6017 | // InternalSolverLanguage.g:1727:3: ( rule__AtomicExpression__Group_0__0 ) | ||
6018 | // InternalSolverLanguage.g:1727:4: rule__AtomicExpression__Group_0__0 | ||
6019 | { | 5515 | { |
5516 | before(grammarAccess.getAtomicExpressionAccess().getReferenceParserRuleCall_0()); | ||
6020 | pushFollow(FOLLOW_2); | 5517 | pushFollow(FOLLOW_2); |
6021 | rule__AtomicExpression__Group_0__0(); | 5518 | ruleReference(); |
6022 | 5519 | ||
6023 | state._fsp--; | 5520 | state._fsp--; |
6024 | if (state.failed) return ; | 5521 | |
5522 | after(grammarAccess.getAtomicExpressionAccess().getReferenceParserRuleCall_0()); | ||
6025 | 5523 | ||
6026 | } | 5524 | } |
6027 | 5525 | ||
6028 | if ( state.backtracking==0 ) { | 5526 | |
6029 | after(grammarAccess.getAtomicExpressionAccess().getGroup_0()); | ||
6030 | } | 5527 | } |
5528 | break; | ||
5529 | case 2 : | ||
5530 | // InternalSolverLanguageParser.g:1804:2: ( ruleCall ) | ||
5531 | { | ||
5532 | // InternalSolverLanguageParser.g:1804:2: ( ruleCall ) | ||
5533 | // InternalSolverLanguageParser.g:1805:3: ruleCall | ||
5534 | { | ||
5535 | before(grammarAccess.getAtomicExpressionAccess().getCallParserRuleCall_1()); | ||
5536 | pushFollow(FOLLOW_2); | ||
5537 | ruleCall(); | ||
5538 | |||
5539 | state._fsp--; | ||
5540 | |||
5541 | after(grammarAccess.getAtomicExpressionAccess().getCallParserRuleCall_1()); | ||
6031 | 5542 | ||
6032 | } | 5543 | } |
6033 | 5544 | ||
6034 | 5545 | ||
6035 | } | 5546 | } |
6036 | break; | 5547 | break; |
6037 | case 2 : | 5548 | case 3 : |
6038 | // InternalSolverLanguage.g:1731:2: ( ruleInterval ) | 5549 | // InternalSolverLanguageParser.g:1810:2: ( ruleInterval ) |
6039 | { | 5550 | { |
6040 | // InternalSolverLanguage.g:1731:2: ( ruleInterval ) | 5551 | // InternalSolverLanguageParser.g:1810:2: ( ruleInterval ) |
6041 | // InternalSolverLanguage.g:1732:3: ruleInterval | 5552 | // InternalSolverLanguageParser.g:1811:3: ruleInterval |
6042 | { | 5553 | { |
6043 | if ( state.backtracking==0 ) { | 5554 | before(grammarAccess.getAtomicExpressionAccess().getIntervalParserRuleCall_2()); |
6044 | before(grammarAccess.getAtomicExpressionAccess().getIntervalParserRuleCall_1()); | ||
6045 | } | ||
6046 | pushFollow(FOLLOW_2); | 5555 | pushFollow(FOLLOW_2); |
6047 | ruleInterval(); | 5556 | ruleInterval(); |
6048 | 5557 | ||
6049 | state._fsp--; | 5558 | state._fsp--; |
6050 | if (state.failed) return ; | 5559 | |
6051 | if ( state.backtracking==0 ) { | 5560 | after(grammarAccess.getAtomicExpressionAccess().getIntervalParserRuleCall_2()); |
6052 | after(grammarAccess.getAtomicExpressionAccess().getIntervalParserRuleCall_1()); | ||
6053 | } | ||
6054 | 5561 | ||
6055 | } | 5562 | } |
6056 | 5563 | ||
6057 | 5564 | ||
6058 | } | 5565 | } |
6059 | break; | 5566 | break; |
6060 | case 3 : | 5567 | case 4 : |
6061 | // InternalSolverLanguage.g:1737:2: ( ruleLiteral ) | 5568 | // InternalSolverLanguageParser.g:1816:2: ( ruleLiteral ) |
6062 | { | 5569 | { |
6063 | // InternalSolverLanguage.g:1737:2: ( ruleLiteral ) | 5570 | // InternalSolverLanguageParser.g:1816:2: ( ruleLiteral ) |
6064 | // InternalSolverLanguage.g:1738:3: ruleLiteral | 5571 | // InternalSolverLanguageParser.g:1817:3: ruleLiteral |
6065 | { | 5572 | { |
6066 | if ( state.backtracking==0 ) { | 5573 | before(grammarAccess.getAtomicExpressionAccess().getLiteralParserRuleCall_3()); |
6067 | before(grammarAccess.getAtomicExpressionAccess().getLiteralParserRuleCall_2()); | ||
6068 | } | ||
6069 | pushFollow(FOLLOW_2); | 5574 | pushFollow(FOLLOW_2); |
6070 | ruleLiteral(); | 5575 | ruleLiteral(); |
6071 | 5576 | ||
6072 | state._fsp--; | 5577 | state._fsp--; |
6073 | if (state.failed) return ; | 5578 | |
6074 | if ( state.backtracking==0 ) { | 5579 | after(grammarAccess.getAtomicExpressionAccess().getLiteralParserRuleCall_3()); |
6075 | after(grammarAccess.getAtomicExpressionAccess().getLiteralParserRuleCall_2()); | ||
6076 | } | ||
6077 | 5580 | ||
6078 | } | 5581 | } |
6079 | 5582 | ||
6080 | 5583 | ||
6081 | } | 5584 | } |
6082 | break; | 5585 | break; |
6083 | case 4 : | 5586 | case 5 : |
6084 | // InternalSolverLanguage.g:1743:2: ( ( rule__AtomicExpression__Group_3__0 ) ) | 5587 | // InternalSolverLanguageParser.g:1822:2: ( ( rule__AtomicExpression__Group_4__0 ) ) |
6085 | { | 5588 | { |
6086 | // InternalSolverLanguage.g:1743:2: ( ( rule__AtomicExpression__Group_3__0 ) ) | 5589 | // InternalSolverLanguageParser.g:1822:2: ( ( rule__AtomicExpression__Group_4__0 ) ) |
6087 | // InternalSolverLanguage.g:1744:3: ( rule__AtomicExpression__Group_3__0 ) | 5590 | // InternalSolverLanguageParser.g:1823:3: ( rule__AtomicExpression__Group_4__0 ) |
6088 | { | 5591 | { |
6089 | if ( state.backtracking==0 ) { | 5592 | before(grammarAccess.getAtomicExpressionAccess().getGroup_4()); |
6090 | before(grammarAccess.getAtomicExpressionAccess().getGroup_3()); | 5593 | // InternalSolverLanguageParser.g:1824:3: ( rule__AtomicExpression__Group_4__0 ) |
6091 | } | 5594 | // InternalSolverLanguageParser.g:1824:4: rule__AtomicExpression__Group_4__0 |
6092 | // InternalSolverLanguage.g:1745:3: ( rule__AtomicExpression__Group_3__0 ) | ||
6093 | // InternalSolverLanguage.g:1745:4: rule__AtomicExpression__Group_3__0 | ||
6094 | { | 5595 | { |
6095 | pushFollow(FOLLOW_2); | 5596 | pushFollow(FOLLOW_2); |
6096 | rule__AtomicExpression__Group_3__0(); | 5597 | rule__AtomicExpression__Group_4__0(); |
6097 | 5598 | ||
6098 | state._fsp--; | 5599 | state._fsp--; |
6099 | if (state.failed) return ; | ||
6100 | 5600 | ||
6101 | } | ||
6102 | 5601 | ||
6103 | if ( state.backtracking==0 ) { | ||
6104 | after(grammarAccess.getAtomicExpressionAccess().getGroup_3()); | ||
6105 | } | 5602 | } |
6106 | 5603 | ||
5604 | after(grammarAccess.getAtomicExpressionAccess().getGroup_4()); | ||
5605 | |||
6107 | } | 5606 | } |
6108 | 5607 | ||
6109 | 5608 | ||
@@ -6127,24 +5626,23 @@ public class InternalSolverLanguageParser extends AbstractInternalContentAssistP | |||
6127 | 5626 | ||
6128 | 5627 | ||
6129 | // $ANTLR start "rule__Call__Alternatives_1" | 5628 | // $ANTLR start "rule__Call__Alternatives_1" |
6130 | // InternalSolverLanguage.g:1753:1: rule__Call__Alternatives_1 : ( ( ( rule__Call__TransitiveClosureAssignment_1_0 ) ) | ( ( rule__Call__ReflexiveTransitiveClosureAssignment_1_1 ) ) ); | 5629 | // InternalSolverLanguageParser.g:1832:1: rule__Call__Alternatives_1 : ( ( ( rule__Call__TransitiveClosureAssignment_1_0 ) ) | ( ( rule__Call__ReflexiveTransitiveClosureAssignment_1_1 ) ) ); |
6131 | public final void rule__Call__Alternatives_1() throws RecognitionException { | 5630 | public final void rule__Call__Alternatives_1() throws RecognitionException { |
6132 | 5631 | ||
6133 | int stackSize = keepStackSize(); | 5632 | int stackSize = keepStackSize(); |
6134 | 5633 | ||
6135 | try { | 5634 | try { |
6136 | // InternalSolverLanguage.g:1757:1: ( ( ( rule__Call__TransitiveClosureAssignment_1_0 ) ) | ( ( rule__Call__ReflexiveTransitiveClosureAssignment_1_1 ) ) ) | 5635 | // InternalSolverLanguageParser.g:1836:1: ( ( ( rule__Call__TransitiveClosureAssignment_1_0 ) ) | ( ( rule__Call__ReflexiveTransitiveClosureAssignment_1_1 ) ) ) |
6137 | int alt10=2; | 5636 | int alt10=2; |
6138 | int LA10_0 = input.LA(1); | 5637 | int LA10_0 = input.LA(1); |
6139 | 5638 | ||
6140 | if ( (LA10_0==RULE_STAR) ) { | 5639 | if ( (LA10_0==RULE_TRANSITIVE_CLOSURE) ) { |
6141 | alt10=1; | 5640 | alt10=1; |
6142 | } | 5641 | } |
6143 | else if ( (LA10_0==RULE_PLUS) ) { | 5642 | else if ( (LA10_0==RULE_REFLEXIVE_TRANSITIVE_CLOSURE) ) { |
6144 | alt10=2; | 5643 | alt10=2; |
6145 | } | 5644 | } |
6146 | else { | 5645 | else { |
6147 | if (state.backtracking>0) {state.failed=true; return ;} | ||
6148 | NoViableAltException nvae = | 5646 | NoViableAltException nvae = |
6149 | new NoViableAltException("", 10, 0, input); | 5647 | new NoViableAltException("", 10, 0, input); |
6150 | 5648 | ||
@@ -6152,58 +5650,50 @@ public class InternalSolverLanguageParser extends AbstractInternalContentAssistP | |||
6152 | } | 5650 | } |
6153 | switch (alt10) { | 5651 | switch (alt10) { |
6154 | case 1 : | 5652 | case 1 : |
6155 | // InternalSolverLanguage.g:1758:2: ( ( rule__Call__TransitiveClosureAssignment_1_0 ) ) | 5653 | // InternalSolverLanguageParser.g:1837:2: ( ( rule__Call__TransitiveClosureAssignment_1_0 ) ) |
6156 | { | 5654 | { |
6157 | // InternalSolverLanguage.g:1758:2: ( ( rule__Call__TransitiveClosureAssignment_1_0 ) ) | 5655 | // InternalSolverLanguageParser.g:1837:2: ( ( rule__Call__TransitiveClosureAssignment_1_0 ) ) |
6158 | // InternalSolverLanguage.g:1759:3: ( rule__Call__TransitiveClosureAssignment_1_0 ) | 5656 | // InternalSolverLanguageParser.g:1838:3: ( rule__Call__TransitiveClosureAssignment_1_0 ) |
6159 | { | 5657 | { |
6160 | if ( state.backtracking==0 ) { | 5658 | before(grammarAccess.getCallAccess().getTransitiveClosureAssignment_1_0()); |
6161 | before(grammarAccess.getCallAccess().getTransitiveClosureAssignment_1_0()); | 5659 | // InternalSolverLanguageParser.g:1839:3: ( rule__Call__TransitiveClosureAssignment_1_0 ) |
6162 | } | 5660 | // InternalSolverLanguageParser.g:1839:4: rule__Call__TransitiveClosureAssignment_1_0 |
6163 | // InternalSolverLanguage.g:1760:3: ( rule__Call__TransitiveClosureAssignment_1_0 ) | ||
6164 | // InternalSolverLanguage.g:1760:4: rule__Call__TransitiveClosureAssignment_1_0 | ||
6165 | { | 5661 | { |
6166 | pushFollow(FOLLOW_2); | 5662 | pushFollow(FOLLOW_2); |
6167 | rule__Call__TransitiveClosureAssignment_1_0(); | 5663 | rule__Call__TransitiveClosureAssignment_1_0(); |
6168 | 5664 | ||
6169 | state._fsp--; | 5665 | state._fsp--; |
6170 | if (state.failed) return ; | ||
6171 | 5666 | ||
6172 | } | ||
6173 | 5667 | ||
6174 | if ( state.backtracking==0 ) { | ||
6175 | after(grammarAccess.getCallAccess().getTransitiveClosureAssignment_1_0()); | ||
6176 | } | 5668 | } |
6177 | 5669 | ||
5670 | after(grammarAccess.getCallAccess().getTransitiveClosureAssignment_1_0()); | ||
5671 | |||
6178 | } | 5672 | } |
6179 | 5673 | ||
6180 | 5674 | ||
6181 | } | 5675 | } |
6182 | break; | 5676 | break; |
6183 | case 2 : | 5677 | case 2 : |
6184 | // InternalSolverLanguage.g:1764:2: ( ( rule__Call__ReflexiveTransitiveClosureAssignment_1_1 ) ) | 5678 | // InternalSolverLanguageParser.g:1843:2: ( ( rule__Call__ReflexiveTransitiveClosureAssignment_1_1 ) ) |
6185 | { | 5679 | { |
6186 | // InternalSolverLanguage.g:1764:2: ( ( rule__Call__ReflexiveTransitiveClosureAssignment_1_1 ) ) | 5680 | // InternalSolverLanguageParser.g:1843:2: ( ( rule__Call__ReflexiveTransitiveClosureAssignment_1_1 ) ) |
6187 | // InternalSolverLanguage.g:1765:3: ( rule__Call__ReflexiveTransitiveClosureAssignment_1_1 ) | 5681 | // InternalSolverLanguageParser.g:1844:3: ( rule__Call__ReflexiveTransitiveClosureAssignment_1_1 ) |
6188 | { | 5682 | { |
6189 | if ( state.backtracking==0 ) { | 5683 | before(grammarAccess.getCallAccess().getReflexiveTransitiveClosureAssignment_1_1()); |
6190 | before(grammarAccess.getCallAccess().getReflexiveTransitiveClosureAssignment_1_1()); | 5684 | // InternalSolverLanguageParser.g:1845:3: ( rule__Call__ReflexiveTransitiveClosureAssignment_1_1 ) |
6191 | } | 5685 | // InternalSolverLanguageParser.g:1845:4: rule__Call__ReflexiveTransitiveClosureAssignment_1_1 |
6192 | // InternalSolverLanguage.g:1766:3: ( rule__Call__ReflexiveTransitiveClosureAssignment_1_1 ) | ||
6193 | // InternalSolverLanguage.g:1766:4: rule__Call__ReflexiveTransitiveClosureAssignment_1_1 | ||
6194 | { | 5686 | { |
6195 | pushFollow(FOLLOW_2); | 5687 | pushFollow(FOLLOW_2); |
6196 | rule__Call__ReflexiveTransitiveClosureAssignment_1_1(); | 5688 | rule__Call__ReflexiveTransitiveClosureAssignment_1_1(); |
6197 | 5689 | ||
6198 | state._fsp--; | 5690 | state._fsp--; |
6199 | if (state.failed) return ; | ||
6200 | 5691 | ||
6201 | } | ||
6202 | 5692 | ||
6203 | if ( state.backtracking==0 ) { | ||
6204 | after(grammarAccess.getCallAccess().getReflexiveTransitiveClosureAssignment_1_1()); | ||
6205 | } | 5693 | } |
6206 | 5694 | ||
5695 | after(grammarAccess.getCallAccess().getReflexiveTransitiveClosureAssignment_1_1()); | ||
5696 | |||
6207 | } | 5697 | } |
6208 | 5698 | ||
6209 | 5699 | ||
@@ -6227,33 +5717,29 @@ public class InternalSolverLanguageParser extends AbstractInternalContentAssistP | |||
6227 | 5717 | ||
6228 | 5718 | ||
6229 | // $ANTLR start "rule__Argument__Alternatives" | 5719 | // $ANTLR start "rule__Argument__Alternatives" |
6230 | // InternalSolverLanguage.g:1774:1: rule__Argument__Alternatives : ( ( ruleExpressionArgument ) | ( ruleStarArgument ) | ( ruleTypedArgument ) | ( ruleTypedStarArgument ) ); | 5720 | // InternalSolverLanguageParser.g:1853:1: rule__Argument__Alternatives : ( ( ruleExpressionArgument ) | ( ruleStarArgument ) | ( ruleTypedArgument ) | ( ruleTypedStarArgument ) ); |
6231 | public final void rule__Argument__Alternatives() throws RecognitionException { | 5721 | public final void rule__Argument__Alternatives() throws RecognitionException { |
6232 | 5722 | ||
6233 | int stackSize = keepStackSize(); | 5723 | int stackSize = keepStackSize(); |
6234 | 5724 | ||
6235 | try { | 5725 | try { |
6236 | // InternalSolverLanguage.g:1778:1: ( ( ruleExpressionArgument ) | ( ruleStarArgument ) | ( ruleTypedArgument ) | ( ruleTypedStarArgument ) ) | 5726 | // InternalSolverLanguageParser.g:1857:1: ( ( ruleExpressionArgument ) | ( ruleStarArgument ) | ( ruleTypedArgument ) | ( ruleTypedStarArgument ) ) |
6237 | int alt11=4; | 5727 | int alt11=4; |
6238 | alt11 = dfa11.predict(input); | 5728 | alt11 = dfa11.predict(input); |
6239 | switch (alt11) { | 5729 | switch (alt11) { |
6240 | case 1 : | 5730 | case 1 : |
6241 | // InternalSolverLanguage.g:1779:2: ( ruleExpressionArgument ) | 5731 | // InternalSolverLanguageParser.g:1858:2: ( ruleExpressionArgument ) |
6242 | { | 5732 | { |
6243 | // InternalSolverLanguage.g:1779:2: ( ruleExpressionArgument ) | 5733 | // InternalSolverLanguageParser.g:1858:2: ( ruleExpressionArgument ) |
6244 | // InternalSolverLanguage.g:1780:3: ruleExpressionArgument | 5734 | // InternalSolverLanguageParser.g:1859:3: ruleExpressionArgument |
6245 | { | 5735 | { |
6246 | if ( state.backtracking==0 ) { | 5736 | before(grammarAccess.getArgumentAccess().getExpressionArgumentParserRuleCall_0()); |
6247 | before(grammarAccess.getArgumentAccess().getExpressionArgumentParserRuleCall_0()); | ||
6248 | } | ||
6249 | pushFollow(FOLLOW_2); | 5737 | pushFollow(FOLLOW_2); |
6250 | ruleExpressionArgument(); | 5738 | ruleExpressionArgument(); |
6251 | 5739 | ||
6252 | state._fsp--; | 5740 | state._fsp--; |
6253 | if (state.failed) return ; | 5741 | |
6254 | if ( state.backtracking==0 ) { | 5742 | after(grammarAccess.getArgumentAccess().getExpressionArgumentParserRuleCall_0()); |
6255 | after(grammarAccess.getArgumentAccess().getExpressionArgumentParserRuleCall_0()); | ||
6256 | } | ||
6257 | 5743 | ||
6258 | } | 5744 | } |
6259 | 5745 | ||
@@ -6261,22 +5747,18 @@ public class InternalSolverLanguageParser extends AbstractInternalContentAssistP | |||
6261 | } | 5747 | } |
6262 | break; | 5748 | break; |
6263 | case 2 : | 5749 | case 2 : |
6264 | // InternalSolverLanguage.g:1785:2: ( ruleStarArgument ) | 5750 | // InternalSolverLanguageParser.g:1864:2: ( ruleStarArgument ) |
6265 | { | 5751 | { |
6266 | // InternalSolverLanguage.g:1785:2: ( ruleStarArgument ) | 5752 | // InternalSolverLanguageParser.g:1864:2: ( ruleStarArgument ) |
6267 | // InternalSolverLanguage.g:1786:3: ruleStarArgument | 5753 | // InternalSolverLanguageParser.g:1865:3: ruleStarArgument |
6268 | { | 5754 | { |
6269 | if ( state.backtracking==0 ) { | 5755 | before(grammarAccess.getArgumentAccess().getStarArgumentParserRuleCall_1()); |
6270 | before(grammarAccess.getArgumentAccess().getStarArgumentParserRuleCall_1()); | ||
6271 | } | ||
6272 | pushFollow(FOLLOW_2); | 5756 | pushFollow(FOLLOW_2); |
6273 | ruleStarArgument(); | 5757 | ruleStarArgument(); |
6274 | 5758 | ||
6275 | state._fsp--; | 5759 | state._fsp--; |
6276 | if (state.failed) return ; | 5760 | |
6277 | if ( state.backtracking==0 ) { | 5761 | after(grammarAccess.getArgumentAccess().getStarArgumentParserRuleCall_1()); |
6278 | after(grammarAccess.getArgumentAccess().getStarArgumentParserRuleCall_1()); | ||
6279 | } | ||
6280 | 5762 | ||
6281 | } | 5763 | } |
6282 | 5764 | ||
@@ -6284,22 +5766,18 @@ public class InternalSolverLanguageParser extends AbstractInternalContentAssistP | |||
6284 | } | 5766 | } |
6285 | break; | 5767 | break; |
6286 | case 3 : | 5768 | case 3 : |
6287 | // InternalSolverLanguage.g:1791:2: ( ruleTypedArgument ) | 5769 | // InternalSolverLanguageParser.g:1870:2: ( ruleTypedArgument ) |
6288 | { | 5770 | { |
6289 | // InternalSolverLanguage.g:1791:2: ( ruleTypedArgument ) | 5771 | // InternalSolverLanguageParser.g:1870:2: ( ruleTypedArgument ) |
6290 | // InternalSolverLanguage.g:1792:3: ruleTypedArgument | 5772 | // InternalSolverLanguageParser.g:1871:3: ruleTypedArgument |
6291 | { | 5773 | { |
6292 | if ( state.backtracking==0 ) { | 5774 | before(grammarAccess.getArgumentAccess().getTypedArgumentParserRuleCall_2()); |
6293 | before(grammarAccess.getArgumentAccess().getTypedArgumentParserRuleCall_2()); | ||
6294 | } | ||
6295 | pushFollow(FOLLOW_2); | 5775 | pushFollow(FOLLOW_2); |
6296 | ruleTypedArgument(); | 5776 | ruleTypedArgument(); |
6297 | 5777 | ||
6298 | state._fsp--; | 5778 | state._fsp--; |
6299 | if (state.failed) return ; | 5779 | |
6300 | if ( state.backtracking==0 ) { | 5780 | after(grammarAccess.getArgumentAccess().getTypedArgumentParserRuleCall_2()); |
6301 | after(grammarAccess.getArgumentAccess().getTypedArgumentParserRuleCall_2()); | ||
6302 | } | ||
6303 | 5781 | ||
6304 | } | 5782 | } |
6305 | 5783 | ||
@@ -6307,22 +5785,18 @@ public class InternalSolverLanguageParser extends AbstractInternalContentAssistP | |||
6307 | } | 5785 | } |
6308 | break; | 5786 | break; |
6309 | case 4 : | 5787 | case 4 : |
6310 | // InternalSolverLanguage.g:1797:2: ( ruleTypedStarArgument ) | 5788 | // InternalSolverLanguageParser.g:1876:2: ( ruleTypedStarArgument ) |
6311 | { | 5789 | { |
6312 | // InternalSolverLanguage.g:1797:2: ( ruleTypedStarArgument ) | 5790 | // InternalSolverLanguageParser.g:1876:2: ( ruleTypedStarArgument ) |
6313 | // InternalSolverLanguage.g:1798:3: ruleTypedStarArgument | 5791 | // InternalSolverLanguageParser.g:1877:3: ruleTypedStarArgument |
6314 | { | 5792 | { |
6315 | if ( state.backtracking==0 ) { | 5793 | before(grammarAccess.getArgumentAccess().getTypedStarArgumentParserRuleCall_3()); |
6316 | before(grammarAccess.getArgumentAccess().getTypedStarArgumentParserRuleCall_3()); | ||
6317 | } | ||
6318 | pushFollow(FOLLOW_2); | 5794 | pushFollow(FOLLOW_2); |
6319 | ruleTypedStarArgument(); | 5795 | ruleTypedStarArgument(); |
6320 | 5796 | ||
6321 | state._fsp--; | 5797 | state._fsp--; |
6322 | if (state.failed) return ; | 5798 | |
6323 | if ( state.backtracking==0 ) { | 5799 | after(grammarAccess.getArgumentAccess().getTypedStarArgumentParserRuleCall_3()); |
6324 | after(grammarAccess.getArgumentAccess().getTypedStarArgumentParserRuleCall_3()); | ||
6325 | } | ||
6326 | 5800 | ||
6327 | } | 5801 | } |
6328 | 5802 | ||
@@ -6347,19 +5821,19 @@ public class InternalSolverLanguageParser extends AbstractInternalContentAssistP | |||
6347 | 5821 | ||
6348 | 5822 | ||
6349 | // $ANTLR start "rule__Literal__Alternatives" | 5823 | // $ANTLR start "rule__Literal__Alternatives" |
6350 | // InternalSolverLanguage.g:1807:1: rule__Literal__Alternatives : ( ( ruleLogicLiteral ) | ( ruleNumericLiteral ) | ( ruleInfinityLiteral ) | ( ruleEmptyIntervalLiteral ) | ( ruleStringLiteral ) ); | 5824 | // InternalSolverLanguageParser.g:1886:1: rule__Literal__Alternatives : ( ( ruleLogicLiteral ) | ( ruleNumericLiteral ) | ( ruleInfinityLiteral ) | ( ruleEmptyIntervalLiteral ) | ( ruleStringLiteral ) ); |
6351 | public final void rule__Literal__Alternatives() throws RecognitionException { | 5825 | public final void rule__Literal__Alternatives() throws RecognitionException { |
6352 | 5826 | ||
6353 | int stackSize = keepStackSize(); | 5827 | int stackSize = keepStackSize(); |
6354 | 5828 | ||
6355 | try { | 5829 | try { |
6356 | // InternalSolverLanguage.g:1811:1: ( ( ruleLogicLiteral ) | ( ruleNumericLiteral ) | ( ruleInfinityLiteral ) | ( ruleEmptyIntervalLiteral ) | ( ruleStringLiteral ) ) | 5830 | // InternalSolverLanguageParser.g:1890:1: ( ( ruleLogicLiteral ) | ( ruleNumericLiteral ) | ( ruleInfinityLiteral ) | ( ruleEmptyIntervalLiteral ) | ( ruleStringLiteral ) ) |
6357 | int alt12=5; | 5831 | int alt12=5; |
6358 | switch ( input.LA(1) ) { | 5832 | switch ( input.LA(1) ) { |
6359 | case 39: | 5833 | case Unknown: |
6360 | case 40: | 5834 | case Error: |
6361 | case 41: | 5835 | case False: |
6362 | case 42: | 5836 | case True: |
6363 | { | 5837 | { |
6364 | alt12=1; | 5838 | alt12=1; |
6365 | } | 5839 | } |
@@ -6369,12 +5843,12 @@ public class InternalSolverLanguageParser extends AbstractInternalContentAssistP | |||
6369 | alt12=2; | 5843 | alt12=2; |
6370 | } | 5844 | } |
6371 | break; | 5845 | break; |
6372 | case 66: | 5846 | case Inf: |
6373 | { | 5847 | { |
6374 | alt12=3; | 5848 | alt12=3; |
6375 | } | 5849 | } |
6376 | break; | 5850 | break; |
6377 | case 67: | 5851 | case Empty: |
6378 | { | 5852 | { |
6379 | alt12=4; | 5853 | alt12=4; |
6380 | } | 5854 | } |
@@ -6385,7 +5859,6 @@ public class InternalSolverLanguageParser extends AbstractInternalContentAssistP | |||
6385 | } | 5859 | } |
6386 | break; | 5860 | break; |
6387 | default: | 5861 | default: |
6388 | if (state.backtracking>0) {state.failed=true; return ;} | ||
6389 | NoViableAltException nvae = | 5862 | NoViableAltException nvae = |
6390 | new NoViableAltException("", 12, 0, input); | 5863 | new NoViableAltException("", 12, 0, input); |
6391 | 5864 | ||
@@ -6394,22 +5867,18 @@ public class InternalSolverLanguageParser extends AbstractInternalContentAssistP | |||
6394 | 5867 | ||
6395 | switch (alt12) { | 5868 | switch (alt12) { |
6396 | case 1 : | 5869 | case 1 : |
6397 | // InternalSolverLanguage.g:1812:2: ( ruleLogicLiteral ) | 5870 | // InternalSolverLanguageParser.g:1891:2: ( ruleLogicLiteral ) |
6398 | { | 5871 | { |
6399 | // InternalSolverLanguage.g:1812:2: ( ruleLogicLiteral ) | 5872 | // InternalSolverLanguageParser.g:1891:2: ( ruleLogicLiteral ) |
6400 | // InternalSolverLanguage.g:1813:3: ruleLogicLiteral | 5873 | // InternalSolverLanguageParser.g:1892:3: ruleLogicLiteral |
6401 | { | 5874 | { |
6402 | if ( state.backtracking==0 ) { | 5875 | before(grammarAccess.getLiteralAccess().getLogicLiteralParserRuleCall_0()); |
6403 | before(grammarAccess.getLiteralAccess().getLogicLiteralParserRuleCall_0()); | ||
6404 | } | ||
6405 | pushFollow(FOLLOW_2); | 5876 | pushFollow(FOLLOW_2); |
6406 | ruleLogicLiteral(); | 5877 | ruleLogicLiteral(); |
6407 | 5878 | ||
6408 | state._fsp--; | 5879 | state._fsp--; |
6409 | if (state.failed) return ; | 5880 | |
6410 | if ( state.backtracking==0 ) { | 5881 | after(grammarAccess.getLiteralAccess().getLogicLiteralParserRuleCall_0()); |
6411 | after(grammarAccess.getLiteralAccess().getLogicLiteralParserRuleCall_0()); | ||
6412 | } | ||
6413 | 5882 | ||
6414 | } | 5883 | } |
6415 | 5884 | ||
@@ -6417,22 +5886,18 @@ public class InternalSolverLanguageParser extends AbstractInternalContentAssistP | |||
6417 | } | 5886 | } |
6418 | break; | 5887 | break; |
6419 | case 2 : | 5888 | case 2 : |
6420 | // InternalSolverLanguage.g:1818:2: ( ruleNumericLiteral ) | 5889 | // InternalSolverLanguageParser.g:1897:2: ( ruleNumericLiteral ) |
6421 | { | 5890 | { |
6422 | // InternalSolverLanguage.g:1818:2: ( ruleNumericLiteral ) | 5891 | // InternalSolverLanguageParser.g:1897:2: ( ruleNumericLiteral ) |
6423 | // InternalSolverLanguage.g:1819:3: ruleNumericLiteral | 5892 | // InternalSolverLanguageParser.g:1898:3: ruleNumericLiteral |
6424 | { | 5893 | { |
6425 | if ( state.backtracking==0 ) { | 5894 | before(grammarAccess.getLiteralAccess().getNumericLiteralParserRuleCall_1()); |
6426 | before(grammarAccess.getLiteralAccess().getNumericLiteralParserRuleCall_1()); | ||
6427 | } | ||
6428 | pushFollow(FOLLOW_2); | 5895 | pushFollow(FOLLOW_2); |
6429 | ruleNumericLiteral(); | 5896 | ruleNumericLiteral(); |
6430 | 5897 | ||
6431 | state._fsp--; | 5898 | state._fsp--; |
6432 | if (state.failed) return ; | 5899 | |
6433 | if ( state.backtracking==0 ) { | 5900 | after(grammarAccess.getLiteralAccess().getNumericLiteralParserRuleCall_1()); |
6434 | after(grammarAccess.getLiteralAccess().getNumericLiteralParserRuleCall_1()); | ||
6435 | } | ||
6436 | 5901 | ||
6437 | } | 5902 | } |
6438 | 5903 | ||
@@ -6440,22 +5905,18 @@ public class InternalSolverLanguageParser extends AbstractInternalContentAssistP | |||
6440 | } | 5905 | } |
6441 | break; | 5906 | break; |
6442 | case 3 : | 5907 | case 3 : |
6443 | // InternalSolverLanguage.g:1824:2: ( ruleInfinityLiteral ) | 5908 | // InternalSolverLanguageParser.g:1903:2: ( ruleInfinityLiteral ) |
6444 | { | 5909 | { |
6445 | // InternalSolverLanguage.g:1824:2: ( ruleInfinityLiteral ) | 5910 | // InternalSolverLanguageParser.g:1903:2: ( ruleInfinityLiteral ) |
6446 | // InternalSolverLanguage.g:1825:3: ruleInfinityLiteral | 5911 | // InternalSolverLanguageParser.g:1904:3: ruleInfinityLiteral |
6447 | { | 5912 | { |
6448 | if ( state.backtracking==0 ) { | 5913 | before(grammarAccess.getLiteralAccess().getInfinityLiteralParserRuleCall_2()); |
6449 | before(grammarAccess.getLiteralAccess().getInfinityLiteralParserRuleCall_2()); | ||
6450 | } | ||
6451 | pushFollow(FOLLOW_2); | 5914 | pushFollow(FOLLOW_2); |
6452 | ruleInfinityLiteral(); | 5915 | ruleInfinityLiteral(); |
6453 | 5916 | ||
6454 | state._fsp--; | 5917 | state._fsp--; |
6455 | if (state.failed) return ; | 5918 | |
6456 | if ( state.backtracking==0 ) { | 5919 | after(grammarAccess.getLiteralAccess().getInfinityLiteralParserRuleCall_2()); |
6457 | after(grammarAccess.getLiteralAccess().getInfinityLiteralParserRuleCall_2()); | ||
6458 | } | ||
6459 | 5920 | ||
6460 | } | 5921 | } |
6461 | 5922 | ||
@@ -6463,22 +5924,18 @@ public class InternalSolverLanguageParser extends AbstractInternalContentAssistP | |||
6463 | } | 5924 | } |
6464 | break; | 5925 | break; |
6465 | case 4 : | 5926 | case 4 : |
6466 | // InternalSolverLanguage.g:1830:2: ( ruleEmptyIntervalLiteral ) | 5927 | // InternalSolverLanguageParser.g:1909:2: ( ruleEmptyIntervalLiteral ) |
6467 | { | 5928 | { |
6468 | // InternalSolverLanguage.g:1830:2: ( ruleEmptyIntervalLiteral ) | 5929 | // InternalSolverLanguageParser.g:1909:2: ( ruleEmptyIntervalLiteral ) |
6469 | // InternalSolverLanguage.g:1831:3: ruleEmptyIntervalLiteral | 5930 | // InternalSolverLanguageParser.g:1910:3: ruleEmptyIntervalLiteral |
6470 | { | 5931 | { |
6471 | if ( state.backtracking==0 ) { | 5932 | before(grammarAccess.getLiteralAccess().getEmptyIntervalLiteralParserRuleCall_3()); |
6472 | before(grammarAccess.getLiteralAccess().getEmptyIntervalLiteralParserRuleCall_3()); | ||
6473 | } | ||
6474 | pushFollow(FOLLOW_2); | 5933 | pushFollow(FOLLOW_2); |
6475 | ruleEmptyIntervalLiteral(); | 5934 | ruleEmptyIntervalLiteral(); |
6476 | 5935 | ||
6477 | state._fsp--; | 5936 | state._fsp--; |
6478 | if (state.failed) return ; | 5937 | |
6479 | if ( state.backtracking==0 ) { | 5938 | after(grammarAccess.getLiteralAccess().getEmptyIntervalLiteralParserRuleCall_3()); |
6480 | after(grammarAccess.getLiteralAccess().getEmptyIntervalLiteralParserRuleCall_3()); | ||
6481 | } | ||
6482 | 5939 | ||
6483 | } | 5940 | } |
6484 | 5941 | ||
@@ -6486,22 +5943,18 @@ public class InternalSolverLanguageParser extends AbstractInternalContentAssistP | |||
6486 | } | 5943 | } |
6487 | break; | 5944 | break; |
6488 | case 5 : | 5945 | case 5 : |
6489 | // InternalSolverLanguage.g:1836:2: ( ruleStringLiteral ) | 5946 | // InternalSolverLanguageParser.g:1915:2: ( ruleStringLiteral ) |
6490 | { | 5947 | { |
6491 | // InternalSolverLanguage.g:1836:2: ( ruleStringLiteral ) | 5948 | // InternalSolverLanguageParser.g:1915:2: ( ruleStringLiteral ) |
6492 | // InternalSolverLanguage.g:1837:3: ruleStringLiteral | 5949 | // InternalSolverLanguageParser.g:1916:3: ruleStringLiteral |
6493 | { | 5950 | { |
6494 | if ( state.backtracking==0 ) { | 5951 | before(grammarAccess.getLiteralAccess().getStringLiteralParserRuleCall_4()); |
6495 | before(grammarAccess.getLiteralAccess().getStringLiteralParserRuleCall_4()); | ||
6496 | } | ||
6497 | pushFollow(FOLLOW_2); | 5952 | pushFollow(FOLLOW_2); |
6498 | ruleStringLiteral(); | 5953 | ruleStringLiteral(); |
6499 | 5954 | ||
6500 | state._fsp--; | 5955 | state._fsp--; |
6501 | if (state.failed) return ; | 5956 | |
6502 | if ( state.backtracking==0 ) { | 5957 | after(grammarAccess.getLiteralAccess().getStringLiteralParserRuleCall_4()); |
6503 | after(grammarAccess.getLiteralAccess().getStringLiteralParserRuleCall_4()); | ||
6504 | } | ||
6505 | 5958 | ||
6506 | } | 5959 | } |
6507 | 5960 | ||
@@ -6526,30 +5979,29 @@ public class InternalSolverLanguageParser extends AbstractInternalContentAssistP | |||
6526 | 5979 | ||
6527 | 5980 | ||
6528 | // $ANTLR start "rule__Multiplicity__Alternatives" | 5981 | // $ANTLR start "rule__Multiplicity__Alternatives" |
6529 | // InternalSolverLanguage.g:1846:1: rule__Multiplicity__Alternatives : ( ( ruleManyMultiplicity ) | ( ruleExactMultiplicity ) | ( ruleBoundedMultiplicity ) ); | 5982 | // InternalSolverLanguageParser.g:1925:1: rule__Multiplicity__Alternatives : ( ( ruleManyMultiplicity ) | ( ruleExactMultiplicity ) | ( ruleBoundedMultiplicity ) ); |
6530 | public final void rule__Multiplicity__Alternatives() throws RecognitionException { | 5983 | public final void rule__Multiplicity__Alternatives() throws RecognitionException { |
6531 | 5984 | ||
6532 | int stackSize = keepStackSize(); | 5985 | int stackSize = keepStackSize(); |
6533 | 5986 | ||
6534 | try { | 5987 | try { |
6535 | // InternalSolverLanguage.g:1850:1: ( ( ruleManyMultiplicity ) | ( ruleExactMultiplicity ) | ( ruleBoundedMultiplicity ) ) | 5988 | // InternalSolverLanguageParser.g:1929:1: ( ( ruleManyMultiplicity ) | ( ruleExactMultiplicity ) | ( ruleBoundedMultiplicity ) ) |
6536 | int alt13=3; | 5989 | int alt13=3; |
6537 | int LA13_0 = input.LA(1); | 5990 | int LA13_0 = input.LA(1); |
6538 | 5991 | ||
6539 | if ( (LA13_0==63) ) { | 5992 | if ( (LA13_0==LeftSquareBracket) ) { |
6540 | switch ( input.LA(2) ) { | 5993 | switch ( input.LA(2) ) { |
6541 | case RULE_INT: | 5994 | case RULE_INT: |
6542 | { | 5995 | { |
6543 | int LA13_2 = input.LA(3); | 5996 | int LA13_2 = input.LA(3); |
6544 | 5997 | ||
6545 | if ( (LA13_2==64) ) { | 5998 | if ( (LA13_2==RightSquareBracket) ) { |
6546 | alt13=3; | ||
6547 | } | ||
6548 | else if ( (LA13_2==65) ) { | ||
6549 | alt13=2; | 5999 | alt13=2; |
6550 | } | 6000 | } |
6001 | else if ( (LA13_2==FullStopFullStop) ) { | ||
6002 | alt13=3; | ||
6003 | } | ||
6551 | else { | 6004 | else { |
6552 | if (state.backtracking>0) {state.failed=true; return ;} | ||
6553 | NoViableAltException nvae = | 6005 | NoViableAltException nvae = |
6554 | new NoViableAltException("", 13, 2, input); | 6006 | new NoViableAltException("", 13, 2, input); |
6555 | 6007 | ||
@@ -6557,18 +6009,17 @@ public class InternalSolverLanguageParser extends AbstractInternalContentAssistP | |||
6557 | } | 6009 | } |
6558 | } | 6010 | } |
6559 | break; | 6011 | break; |
6560 | case 16: | 6012 | case Asterisk: |
6561 | { | 6013 | { |
6562 | alt13=2; | 6014 | alt13=2; |
6563 | } | 6015 | } |
6564 | break; | 6016 | break; |
6565 | case 65: | 6017 | case RightSquareBracket: |
6566 | { | 6018 | { |
6567 | alt13=1; | 6019 | alt13=1; |
6568 | } | 6020 | } |
6569 | break; | 6021 | break; |
6570 | default: | 6022 | default: |
6571 | if (state.backtracking>0) {state.failed=true; return ;} | ||
6572 | NoViableAltException nvae = | 6023 | NoViableAltException nvae = |
6573 | new NoViableAltException("", 13, 1, input); | 6024 | new NoViableAltException("", 13, 1, input); |
6574 | 6025 | ||
@@ -6577,7 +6028,6 @@ public class InternalSolverLanguageParser extends AbstractInternalContentAssistP | |||
6577 | 6028 | ||
6578 | } | 6029 | } |
6579 | else { | 6030 | else { |
6580 | if (state.backtracking>0) {state.failed=true; return ;} | ||
6581 | NoViableAltException nvae = | 6031 | NoViableAltException nvae = |
6582 | new NoViableAltException("", 13, 0, input); | 6032 | new NoViableAltException("", 13, 0, input); |
6583 | 6033 | ||
@@ -6585,22 +6035,18 @@ public class InternalSolverLanguageParser extends AbstractInternalContentAssistP | |||
6585 | } | 6035 | } |
6586 | switch (alt13) { | 6036 | switch (alt13) { |
6587 | case 1 : | 6037 | case 1 : |
6588 | // InternalSolverLanguage.g:1851:2: ( ruleManyMultiplicity ) | 6038 | // InternalSolverLanguageParser.g:1930:2: ( ruleManyMultiplicity ) |
6589 | { | 6039 | { |
6590 | // InternalSolverLanguage.g:1851:2: ( ruleManyMultiplicity ) | 6040 | // InternalSolverLanguageParser.g:1930:2: ( ruleManyMultiplicity ) |
6591 | // InternalSolverLanguage.g:1852:3: ruleManyMultiplicity | 6041 | // InternalSolverLanguageParser.g:1931:3: ruleManyMultiplicity |
6592 | { | 6042 | { |
6593 | if ( state.backtracking==0 ) { | 6043 | before(grammarAccess.getMultiplicityAccess().getManyMultiplicityParserRuleCall_0()); |
6594 | before(grammarAccess.getMultiplicityAccess().getManyMultiplicityParserRuleCall_0()); | ||
6595 | } | ||
6596 | pushFollow(FOLLOW_2); | 6044 | pushFollow(FOLLOW_2); |
6597 | ruleManyMultiplicity(); | 6045 | ruleManyMultiplicity(); |
6598 | 6046 | ||
6599 | state._fsp--; | 6047 | state._fsp--; |
6600 | if (state.failed) return ; | 6048 | |
6601 | if ( state.backtracking==0 ) { | 6049 | after(grammarAccess.getMultiplicityAccess().getManyMultiplicityParserRuleCall_0()); |
6602 | after(grammarAccess.getMultiplicityAccess().getManyMultiplicityParserRuleCall_0()); | ||
6603 | } | ||
6604 | 6050 | ||
6605 | } | 6051 | } |
6606 | 6052 | ||
@@ -6608,22 +6054,18 @@ public class InternalSolverLanguageParser extends AbstractInternalContentAssistP | |||
6608 | } | 6054 | } |
6609 | break; | 6055 | break; |
6610 | case 2 : | 6056 | case 2 : |
6611 | // InternalSolverLanguage.g:1857:2: ( ruleExactMultiplicity ) | 6057 | // InternalSolverLanguageParser.g:1936:2: ( ruleExactMultiplicity ) |
6612 | { | 6058 | { |
6613 | // InternalSolverLanguage.g:1857:2: ( ruleExactMultiplicity ) | 6059 | // InternalSolverLanguageParser.g:1936:2: ( ruleExactMultiplicity ) |
6614 | // InternalSolverLanguage.g:1858:3: ruleExactMultiplicity | 6060 | // InternalSolverLanguageParser.g:1937:3: ruleExactMultiplicity |
6615 | { | 6061 | { |
6616 | if ( state.backtracking==0 ) { | 6062 | before(grammarAccess.getMultiplicityAccess().getExactMultiplicityParserRuleCall_1()); |
6617 | before(grammarAccess.getMultiplicityAccess().getExactMultiplicityParserRuleCall_1()); | ||
6618 | } | ||
6619 | pushFollow(FOLLOW_2); | 6063 | pushFollow(FOLLOW_2); |
6620 | ruleExactMultiplicity(); | 6064 | ruleExactMultiplicity(); |
6621 | 6065 | ||
6622 | state._fsp--; | 6066 | state._fsp--; |
6623 | if (state.failed) return ; | 6067 | |
6624 | if ( state.backtracking==0 ) { | 6068 | after(grammarAccess.getMultiplicityAccess().getExactMultiplicityParserRuleCall_1()); |
6625 | after(grammarAccess.getMultiplicityAccess().getExactMultiplicityParserRuleCall_1()); | ||
6626 | } | ||
6627 | 6069 | ||
6628 | } | 6070 | } |
6629 | 6071 | ||
@@ -6631,22 +6073,18 @@ public class InternalSolverLanguageParser extends AbstractInternalContentAssistP | |||
6631 | } | 6073 | } |
6632 | break; | 6074 | break; |
6633 | case 3 : | 6075 | case 3 : |
6634 | // InternalSolverLanguage.g:1863:2: ( ruleBoundedMultiplicity ) | 6076 | // InternalSolverLanguageParser.g:1942:2: ( ruleBoundedMultiplicity ) |
6635 | { | 6077 | { |
6636 | // InternalSolverLanguage.g:1863:2: ( ruleBoundedMultiplicity ) | 6078 | // InternalSolverLanguageParser.g:1942:2: ( ruleBoundedMultiplicity ) |
6637 | // InternalSolverLanguage.g:1864:3: ruleBoundedMultiplicity | 6079 | // InternalSolverLanguageParser.g:1943:3: ruleBoundedMultiplicity |
6638 | { | 6080 | { |
6639 | if ( state.backtracking==0 ) { | 6081 | before(grammarAccess.getMultiplicityAccess().getBoundedMultiplicityParserRuleCall_2()); |
6640 | before(grammarAccess.getMultiplicityAccess().getBoundedMultiplicityParserRuleCall_2()); | ||
6641 | } | ||
6642 | pushFollow(FOLLOW_2); | 6082 | pushFollow(FOLLOW_2); |
6643 | ruleBoundedMultiplicity(); | 6083 | ruleBoundedMultiplicity(); |
6644 | 6084 | ||
6645 | state._fsp--; | 6085 | state._fsp--; |
6646 | if (state.failed) return ; | 6086 | |
6647 | if ( state.backtracking==0 ) { | 6087 | after(grammarAccess.getMultiplicityAccess().getBoundedMultiplicityParserRuleCall_2()); |
6648 | after(grammarAccess.getMultiplicityAccess().getBoundedMultiplicityParserRuleCall_2()); | ||
6649 | } | ||
6650 | 6088 | ||
6651 | } | 6089 | } |
6652 | 6090 | ||
@@ -6671,33 +6109,29 @@ public class InternalSolverLanguageParser extends AbstractInternalContentAssistP | |||
6671 | 6109 | ||
6672 | 6110 | ||
6673 | // $ANTLR start "rule__ScopeDefinition__Alternatives" | 6111 | // $ANTLR start "rule__ScopeDefinition__Alternatives" |
6674 | // InternalSolverLanguage.g:1873:1: rule__ScopeDefinition__Alternatives : ( ( ruleExactScopeDefinition ) | ( ruleBoundedScopeDefinition ) | ( ruleLowerBoundedScopeDefinition ) ); | 6112 | // InternalSolverLanguageParser.g:1952:1: rule__ScopeDefinition__Alternatives : ( ( ruleExactScopeDefinition ) | ( ruleBoundedScopeDefinition ) | ( ruleLowerBoundedScopeDefinition ) ); |
6675 | public final void rule__ScopeDefinition__Alternatives() throws RecognitionException { | 6113 | public final void rule__ScopeDefinition__Alternatives() throws RecognitionException { |
6676 | 6114 | ||
6677 | int stackSize = keepStackSize(); | 6115 | int stackSize = keepStackSize(); |
6678 | 6116 | ||
6679 | try { | 6117 | try { |
6680 | // InternalSolverLanguage.g:1877:1: ( ( ruleExactScopeDefinition ) | ( ruleBoundedScopeDefinition ) | ( ruleLowerBoundedScopeDefinition ) ) | 6118 | // InternalSolverLanguageParser.g:1956:1: ( ( ruleExactScopeDefinition ) | ( ruleBoundedScopeDefinition ) | ( ruleLowerBoundedScopeDefinition ) ) |
6681 | int alt14=3; | 6119 | int alt14=3; |
6682 | alt14 = dfa14.predict(input); | 6120 | alt14 = dfa14.predict(input); |
6683 | switch (alt14) { | 6121 | switch (alt14) { |
6684 | case 1 : | 6122 | case 1 : |
6685 | // InternalSolverLanguage.g:1878:2: ( ruleExactScopeDefinition ) | 6123 | // InternalSolverLanguageParser.g:1957:2: ( ruleExactScopeDefinition ) |
6686 | { | 6124 | { |
6687 | // InternalSolverLanguage.g:1878:2: ( ruleExactScopeDefinition ) | 6125 | // InternalSolverLanguageParser.g:1957:2: ( ruleExactScopeDefinition ) |
6688 | // InternalSolverLanguage.g:1879:3: ruleExactScopeDefinition | 6126 | // InternalSolverLanguageParser.g:1958:3: ruleExactScopeDefinition |
6689 | { | 6127 | { |
6690 | if ( state.backtracking==0 ) { | 6128 | before(grammarAccess.getScopeDefinitionAccess().getExactScopeDefinitionParserRuleCall_0()); |
6691 | before(grammarAccess.getScopeDefinitionAccess().getExactScopeDefinitionParserRuleCall_0()); | ||
6692 | } | ||
6693 | pushFollow(FOLLOW_2); | 6129 | pushFollow(FOLLOW_2); |
6694 | ruleExactScopeDefinition(); | 6130 | ruleExactScopeDefinition(); |
6695 | 6131 | ||
6696 | state._fsp--; | 6132 | state._fsp--; |
6697 | if (state.failed) return ; | 6133 | |
6698 | if ( state.backtracking==0 ) { | 6134 | after(grammarAccess.getScopeDefinitionAccess().getExactScopeDefinitionParserRuleCall_0()); |
6699 | after(grammarAccess.getScopeDefinitionAccess().getExactScopeDefinitionParserRuleCall_0()); | ||
6700 | } | ||
6701 | 6135 | ||
6702 | } | 6136 | } |
6703 | 6137 | ||
@@ -6705,22 +6139,18 @@ public class InternalSolverLanguageParser extends AbstractInternalContentAssistP | |||
6705 | } | 6139 | } |
6706 | break; | 6140 | break; |
6707 | case 2 : | 6141 | case 2 : |
6708 | // InternalSolverLanguage.g:1884:2: ( ruleBoundedScopeDefinition ) | 6142 | // InternalSolverLanguageParser.g:1963:2: ( ruleBoundedScopeDefinition ) |
6709 | { | 6143 | { |
6710 | // InternalSolverLanguage.g:1884:2: ( ruleBoundedScopeDefinition ) | 6144 | // InternalSolverLanguageParser.g:1963:2: ( ruleBoundedScopeDefinition ) |
6711 | // InternalSolverLanguage.g:1885:3: ruleBoundedScopeDefinition | 6145 | // InternalSolverLanguageParser.g:1964:3: ruleBoundedScopeDefinition |
6712 | { | 6146 | { |
6713 | if ( state.backtracking==0 ) { | 6147 | before(grammarAccess.getScopeDefinitionAccess().getBoundedScopeDefinitionParserRuleCall_1()); |
6714 | before(grammarAccess.getScopeDefinitionAccess().getBoundedScopeDefinitionParserRuleCall_1()); | ||
6715 | } | ||
6716 | pushFollow(FOLLOW_2); | 6148 | pushFollow(FOLLOW_2); |
6717 | ruleBoundedScopeDefinition(); | 6149 | ruleBoundedScopeDefinition(); |
6718 | 6150 | ||
6719 | state._fsp--; | 6151 | state._fsp--; |
6720 | if (state.failed) return ; | 6152 | |
6721 | if ( state.backtracking==0 ) { | 6153 | after(grammarAccess.getScopeDefinitionAccess().getBoundedScopeDefinitionParserRuleCall_1()); |
6722 | after(grammarAccess.getScopeDefinitionAccess().getBoundedScopeDefinitionParserRuleCall_1()); | ||
6723 | } | ||
6724 | 6154 | ||
6725 | } | 6155 | } |
6726 | 6156 | ||
@@ -6728,22 +6158,18 @@ public class InternalSolverLanguageParser extends AbstractInternalContentAssistP | |||
6728 | } | 6158 | } |
6729 | break; | 6159 | break; |
6730 | case 3 : | 6160 | case 3 : |
6731 | // InternalSolverLanguage.g:1890:2: ( ruleLowerBoundedScopeDefinition ) | 6161 | // InternalSolverLanguageParser.g:1969:2: ( ruleLowerBoundedScopeDefinition ) |
6732 | { | 6162 | { |
6733 | // InternalSolverLanguage.g:1890:2: ( ruleLowerBoundedScopeDefinition ) | 6163 | // InternalSolverLanguageParser.g:1969:2: ( ruleLowerBoundedScopeDefinition ) |
6734 | // InternalSolverLanguage.g:1891:3: ruleLowerBoundedScopeDefinition | 6164 | // InternalSolverLanguageParser.g:1970:3: ruleLowerBoundedScopeDefinition |
6735 | { | 6165 | { |
6736 | if ( state.backtracking==0 ) { | 6166 | before(grammarAccess.getScopeDefinitionAccess().getLowerBoundedScopeDefinitionParserRuleCall_2()); |
6737 | before(grammarAccess.getScopeDefinitionAccess().getLowerBoundedScopeDefinitionParserRuleCall_2()); | ||
6738 | } | ||
6739 | pushFollow(FOLLOW_2); | 6167 | pushFollow(FOLLOW_2); |
6740 | ruleLowerBoundedScopeDefinition(); | 6168 | ruleLowerBoundedScopeDefinition(); |
6741 | 6169 | ||
6742 | state._fsp--; | 6170 | state._fsp--; |
6743 | if (state.failed) return ; | 6171 | |
6744 | if ( state.backtracking==0 ) { | 6172 | after(grammarAccess.getScopeDefinitionAccess().getLowerBoundedScopeDefinitionParserRuleCall_2()); |
6745 | after(grammarAccess.getScopeDefinitionAccess().getLowerBoundedScopeDefinitionParserRuleCall_2()); | ||
6746 | } | ||
6747 | 6173 | ||
6748 | } | 6174 | } |
6749 | 6175 | ||
@@ -6768,27 +6194,26 @@ public class InternalSolverLanguageParser extends AbstractInternalContentAssistP | |||
6768 | 6194 | ||
6769 | 6195 | ||
6770 | // $ANTLR start "rule__BoundedScopeDefinition__Alternatives_1" | 6196 | // $ANTLR start "rule__BoundedScopeDefinition__Alternatives_1" |
6771 | // InternalSolverLanguage.g:1900:1: rule__BoundedScopeDefinition__Alternatives_1 : ( ( ( rule__BoundedScopeDefinition__Group_1_0__0 ) ) | ( ( rule__BoundedScopeDefinition__Group_1_1__0 ) ) ); | 6197 | // InternalSolverLanguageParser.g:1979:1: rule__BoundedScopeDefinition__Alternatives_1 : ( ( ( rule__BoundedScopeDefinition__Group_1_0__0 ) ) | ( ( rule__BoundedScopeDefinition__Group_1_1__0 ) ) ); |
6772 | public final void rule__BoundedScopeDefinition__Alternatives_1() throws RecognitionException { | 6198 | public final void rule__BoundedScopeDefinition__Alternatives_1() throws RecognitionException { |
6773 | 6199 | ||
6774 | int stackSize = keepStackSize(); | 6200 | int stackSize = keepStackSize(); |
6775 | 6201 | ||
6776 | try { | 6202 | try { |
6777 | // InternalSolverLanguage.g:1904:1: ( ( ( rule__BoundedScopeDefinition__Group_1_0__0 ) ) | ( ( rule__BoundedScopeDefinition__Group_1_1__0 ) ) ) | 6203 | // InternalSolverLanguageParser.g:1983:1: ( ( ( rule__BoundedScopeDefinition__Group_1_0__0 ) ) | ( ( rule__BoundedScopeDefinition__Group_1_1__0 ) ) ) |
6778 | int alt15=2; | 6204 | int alt15=2; |
6779 | int LA15_0 = input.LA(1); | 6205 | int LA15_0 = input.LA(1); |
6780 | 6206 | ||
6781 | if ( (LA15_0==RULE_INT) ) { | 6207 | if ( (LA15_0==RULE_INT) ) { |
6782 | int LA15_1 = input.LA(2); | 6208 | int LA15_1 = input.LA(2); |
6783 | 6209 | ||
6784 | if ( (LA15_1==24) ) { | 6210 | if ( (LA15_1==LessThanSignEqualsSign) ) { |
6785 | alt15=2; | ||
6786 | } | ||
6787 | else if ( (LA15_1==22) ) { | ||
6788 | alt15=1; | 6211 | alt15=1; |
6789 | } | 6212 | } |
6213 | else if ( (LA15_1==GreaterThanSignEqualsSign) ) { | ||
6214 | alt15=2; | ||
6215 | } | ||
6790 | else { | 6216 | else { |
6791 | if (state.backtracking>0) {state.failed=true; return ;} | ||
6792 | NoViableAltException nvae = | 6217 | NoViableAltException nvae = |
6793 | new NoViableAltException("", 15, 1, input); | 6218 | new NoViableAltException("", 15, 1, input); |
6794 | 6219 | ||
@@ -6799,7 +6224,6 @@ public class InternalSolverLanguageParser extends AbstractInternalContentAssistP | |||
6799 | alt15=1; | 6224 | alt15=1; |
6800 | } | 6225 | } |
6801 | else { | 6226 | else { |
6802 | if (state.backtracking>0) {state.failed=true; return ;} | ||
6803 | NoViableAltException nvae = | 6227 | NoViableAltException nvae = |
6804 | new NoViableAltException("", 15, 0, input); | 6228 | new NoViableAltException("", 15, 0, input); |
6805 | 6229 | ||
@@ -6807,58 +6231,50 @@ public class InternalSolverLanguageParser extends AbstractInternalContentAssistP | |||
6807 | } | 6231 | } |
6808 | switch (alt15) { | 6232 | switch (alt15) { |
6809 | case 1 : | 6233 | case 1 : |
6810 | // InternalSolverLanguage.g:1905:2: ( ( rule__BoundedScopeDefinition__Group_1_0__0 ) ) | 6234 | // InternalSolverLanguageParser.g:1984:2: ( ( rule__BoundedScopeDefinition__Group_1_0__0 ) ) |
6811 | { | 6235 | { |
6812 | // InternalSolverLanguage.g:1905:2: ( ( rule__BoundedScopeDefinition__Group_1_0__0 ) ) | 6236 | // InternalSolverLanguageParser.g:1984:2: ( ( rule__BoundedScopeDefinition__Group_1_0__0 ) ) |
6813 | // InternalSolverLanguage.g:1906:3: ( rule__BoundedScopeDefinition__Group_1_0__0 ) | 6237 | // InternalSolverLanguageParser.g:1985:3: ( rule__BoundedScopeDefinition__Group_1_0__0 ) |
6814 | { | 6238 | { |
6815 | if ( state.backtracking==0 ) { | 6239 | before(grammarAccess.getBoundedScopeDefinitionAccess().getGroup_1_0()); |
6816 | before(grammarAccess.getBoundedScopeDefinitionAccess().getGroup_1_0()); | 6240 | // InternalSolverLanguageParser.g:1986:3: ( rule__BoundedScopeDefinition__Group_1_0__0 ) |
6817 | } | 6241 | // InternalSolverLanguageParser.g:1986:4: rule__BoundedScopeDefinition__Group_1_0__0 |
6818 | // InternalSolverLanguage.g:1907:3: ( rule__BoundedScopeDefinition__Group_1_0__0 ) | ||
6819 | // InternalSolverLanguage.g:1907:4: rule__BoundedScopeDefinition__Group_1_0__0 | ||
6820 | { | 6242 | { |
6821 | pushFollow(FOLLOW_2); | 6243 | pushFollow(FOLLOW_2); |
6822 | rule__BoundedScopeDefinition__Group_1_0__0(); | 6244 | rule__BoundedScopeDefinition__Group_1_0__0(); |
6823 | 6245 | ||
6824 | state._fsp--; | 6246 | state._fsp--; |
6825 | if (state.failed) return ; | ||
6826 | 6247 | ||
6827 | } | ||
6828 | 6248 | ||
6829 | if ( state.backtracking==0 ) { | ||
6830 | after(grammarAccess.getBoundedScopeDefinitionAccess().getGroup_1_0()); | ||
6831 | } | 6249 | } |
6832 | 6250 | ||
6251 | after(grammarAccess.getBoundedScopeDefinitionAccess().getGroup_1_0()); | ||
6252 | |||
6833 | } | 6253 | } |
6834 | 6254 | ||
6835 | 6255 | ||
6836 | } | 6256 | } |
6837 | break; | 6257 | break; |
6838 | case 2 : | 6258 | case 2 : |
6839 | // InternalSolverLanguage.g:1911:2: ( ( rule__BoundedScopeDefinition__Group_1_1__0 ) ) | 6259 | // InternalSolverLanguageParser.g:1990:2: ( ( rule__BoundedScopeDefinition__Group_1_1__0 ) ) |
6840 | { | 6260 | { |
6841 | // InternalSolverLanguage.g:1911:2: ( ( rule__BoundedScopeDefinition__Group_1_1__0 ) ) | 6261 | // InternalSolverLanguageParser.g:1990:2: ( ( rule__BoundedScopeDefinition__Group_1_1__0 ) ) |
6842 | // InternalSolverLanguage.g:1912:3: ( rule__BoundedScopeDefinition__Group_1_1__0 ) | 6262 | // InternalSolverLanguageParser.g:1991:3: ( rule__BoundedScopeDefinition__Group_1_1__0 ) |
6843 | { | 6263 | { |
6844 | if ( state.backtracking==0 ) { | 6264 | before(grammarAccess.getBoundedScopeDefinitionAccess().getGroup_1_1()); |
6845 | before(grammarAccess.getBoundedScopeDefinitionAccess().getGroup_1_1()); | 6265 | // InternalSolverLanguageParser.g:1992:3: ( rule__BoundedScopeDefinition__Group_1_1__0 ) |
6846 | } | 6266 | // InternalSolverLanguageParser.g:1992:4: rule__BoundedScopeDefinition__Group_1_1__0 |
6847 | // InternalSolverLanguage.g:1913:3: ( rule__BoundedScopeDefinition__Group_1_1__0 ) | ||
6848 | // InternalSolverLanguage.g:1913:4: rule__BoundedScopeDefinition__Group_1_1__0 | ||
6849 | { | 6267 | { |
6850 | pushFollow(FOLLOW_2); | 6268 | pushFollow(FOLLOW_2); |
6851 | rule__BoundedScopeDefinition__Group_1_1__0(); | 6269 | rule__BoundedScopeDefinition__Group_1_1__0(); |
6852 | 6270 | ||
6853 | state._fsp--; | 6271 | state._fsp--; |
6854 | if (state.failed) return ; | ||
6855 | 6272 | ||
6856 | } | ||
6857 | 6273 | ||
6858 | if ( state.backtracking==0 ) { | ||
6859 | after(grammarAccess.getBoundedScopeDefinitionAccess().getGroup_1_1()); | ||
6860 | } | 6274 | } |
6861 | 6275 | ||
6276 | after(grammarAccess.getBoundedScopeDefinitionAccess().getGroup_1_1()); | ||
6277 | |||
6862 | } | 6278 | } |
6863 | 6279 | ||
6864 | 6280 | ||
@@ -6882,13 +6298,13 @@ public class InternalSolverLanguageParser extends AbstractInternalContentAssistP | |||
6882 | 6298 | ||
6883 | 6299 | ||
6884 | // $ANTLR start "rule__LowerBoundedScopeDefinition__Alternatives_1" | 6300 | // $ANTLR start "rule__LowerBoundedScopeDefinition__Alternatives_1" |
6885 | // InternalSolverLanguage.g:1921:1: rule__LowerBoundedScopeDefinition__Alternatives_1 : ( ( ( rule__LowerBoundedScopeDefinition__Group_1_0__0 ) ) | ( ( rule__LowerBoundedScopeDefinition__Group_1_1__0 ) ) ); | 6301 | // InternalSolverLanguageParser.g:2000:1: rule__LowerBoundedScopeDefinition__Alternatives_1 : ( ( ( rule__LowerBoundedScopeDefinition__Group_1_0__0 ) ) | ( ( rule__LowerBoundedScopeDefinition__Group_1_1__0 ) ) ); |
6886 | public final void rule__LowerBoundedScopeDefinition__Alternatives_1() throws RecognitionException { | 6302 | public final void rule__LowerBoundedScopeDefinition__Alternatives_1() throws RecognitionException { |
6887 | 6303 | ||
6888 | int stackSize = keepStackSize(); | 6304 | int stackSize = keepStackSize(); |
6889 | 6305 | ||
6890 | try { | 6306 | try { |
6891 | // InternalSolverLanguage.g:1925:1: ( ( ( rule__LowerBoundedScopeDefinition__Group_1_0__0 ) ) | ( ( rule__LowerBoundedScopeDefinition__Group_1_1__0 ) ) ) | 6307 | // InternalSolverLanguageParser.g:2004:1: ( ( ( rule__LowerBoundedScopeDefinition__Group_1_0__0 ) ) | ( ( rule__LowerBoundedScopeDefinition__Group_1_1__0 ) ) ) |
6892 | int alt16=2; | 6308 | int alt16=2; |
6893 | int LA16_0 = input.LA(1); | 6309 | int LA16_0 = input.LA(1); |
6894 | 6310 | ||
@@ -6899,7 +6315,6 @@ public class InternalSolverLanguageParser extends AbstractInternalContentAssistP | |||
6899 | alt16=2; | 6315 | alt16=2; |
6900 | } | 6316 | } |
6901 | else { | 6317 | else { |
6902 | if (state.backtracking>0) {state.failed=true; return ;} | ||
6903 | NoViableAltException nvae = | 6318 | NoViableAltException nvae = |
6904 | new NoViableAltException("", 16, 0, input); | 6319 | new NoViableAltException("", 16, 0, input); |
6905 | 6320 | ||
@@ -6907,58 +6322,50 @@ public class InternalSolverLanguageParser extends AbstractInternalContentAssistP | |||
6907 | } | 6322 | } |
6908 | switch (alt16) { | 6323 | switch (alt16) { |
6909 | case 1 : | 6324 | case 1 : |
6910 | // InternalSolverLanguage.g:1926:2: ( ( rule__LowerBoundedScopeDefinition__Group_1_0__0 ) ) | 6325 | // InternalSolverLanguageParser.g:2005:2: ( ( rule__LowerBoundedScopeDefinition__Group_1_0__0 ) ) |
6911 | { | 6326 | { |
6912 | // InternalSolverLanguage.g:1926:2: ( ( rule__LowerBoundedScopeDefinition__Group_1_0__0 ) ) | 6327 | // InternalSolverLanguageParser.g:2005:2: ( ( rule__LowerBoundedScopeDefinition__Group_1_0__0 ) ) |
6913 | // InternalSolverLanguage.g:1927:3: ( rule__LowerBoundedScopeDefinition__Group_1_0__0 ) | 6328 | // InternalSolverLanguageParser.g:2006:3: ( rule__LowerBoundedScopeDefinition__Group_1_0__0 ) |
6914 | { | 6329 | { |
6915 | if ( state.backtracking==0 ) { | 6330 | before(grammarAccess.getLowerBoundedScopeDefinitionAccess().getGroup_1_0()); |
6916 | before(grammarAccess.getLowerBoundedScopeDefinitionAccess().getGroup_1_0()); | 6331 | // InternalSolverLanguageParser.g:2007:3: ( rule__LowerBoundedScopeDefinition__Group_1_0__0 ) |
6917 | } | 6332 | // InternalSolverLanguageParser.g:2007:4: rule__LowerBoundedScopeDefinition__Group_1_0__0 |
6918 | // InternalSolverLanguage.g:1928:3: ( rule__LowerBoundedScopeDefinition__Group_1_0__0 ) | ||
6919 | // InternalSolverLanguage.g:1928:4: rule__LowerBoundedScopeDefinition__Group_1_0__0 | ||
6920 | { | 6333 | { |
6921 | pushFollow(FOLLOW_2); | 6334 | pushFollow(FOLLOW_2); |
6922 | rule__LowerBoundedScopeDefinition__Group_1_0__0(); | 6335 | rule__LowerBoundedScopeDefinition__Group_1_0__0(); |
6923 | 6336 | ||
6924 | state._fsp--; | 6337 | state._fsp--; |
6925 | if (state.failed) return ; | ||
6926 | 6338 | ||
6927 | } | ||
6928 | 6339 | ||
6929 | if ( state.backtracking==0 ) { | ||
6930 | after(grammarAccess.getLowerBoundedScopeDefinitionAccess().getGroup_1_0()); | ||
6931 | } | 6340 | } |
6932 | 6341 | ||
6342 | after(grammarAccess.getLowerBoundedScopeDefinitionAccess().getGroup_1_0()); | ||
6343 | |||
6933 | } | 6344 | } |
6934 | 6345 | ||
6935 | 6346 | ||
6936 | } | 6347 | } |
6937 | break; | 6348 | break; |
6938 | case 2 : | 6349 | case 2 : |
6939 | // InternalSolverLanguage.g:1932:2: ( ( rule__LowerBoundedScopeDefinition__Group_1_1__0 ) ) | 6350 | // InternalSolverLanguageParser.g:2011:2: ( ( rule__LowerBoundedScopeDefinition__Group_1_1__0 ) ) |
6940 | { | 6351 | { |
6941 | // InternalSolverLanguage.g:1932:2: ( ( rule__LowerBoundedScopeDefinition__Group_1_1__0 ) ) | 6352 | // InternalSolverLanguageParser.g:2011:2: ( ( rule__LowerBoundedScopeDefinition__Group_1_1__0 ) ) |
6942 | // InternalSolverLanguage.g:1933:3: ( rule__LowerBoundedScopeDefinition__Group_1_1__0 ) | 6353 | // InternalSolverLanguageParser.g:2012:3: ( rule__LowerBoundedScopeDefinition__Group_1_1__0 ) |
6943 | { | 6354 | { |
6944 | if ( state.backtracking==0 ) { | 6355 | before(grammarAccess.getLowerBoundedScopeDefinitionAccess().getGroup_1_1()); |
6945 | before(grammarAccess.getLowerBoundedScopeDefinitionAccess().getGroup_1_1()); | 6356 | // InternalSolverLanguageParser.g:2013:3: ( rule__LowerBoundedScopeDefinition__Group_1_1__0 ) |
6946 | } | 6357 | // InternalSolverLanguageParser.g:2013:4: rule__LowerBoundedScopeDefinition__Group_1_1__0 |
6947 | // InternalSolverLanguage.g:1934:3: ( rule__LowerBoundedScopeDefinition__Group_1_1__0 ) | ||
6948 | // InternalSolverLanguage.g:1934:4: rule__LowerBoundedScopeDefinition__Group_1_1__0 | ||
6949 | { | 6358 | { |
6950 | pushFollow(FOLLOW_2); | 6359 | pushFollow(FOLLOW_2); |
6951 | rule__LowerBoundedScopeDefinition__Group_1_1__0(); | 6360 | rule__LowerBoundedScopeDefinition__Group_1_1__0(); |
6952 | 6361 | ||
6953 | state._fsp--; | 6362 | state._fsp--; |
6954 | if (state.failed) return ; | ||
6955 | 6363 | ||
6956 | } | ||
6957 | 6364 | ||
6958 | if ( state.backtracking==0 ) { | ||
6959 | after(grammarAccess.getLowerBoundedScopeDefinitionAccess().getGroup_1_1()); | ||
6960 | } | 6365 | } |
6961 | 6366 | ||
6367 | after(grammarAccess.getLowerBoundedScopeDefinitionAccess().getGroup_1_1()); | ||
6368 | |||
6962 | } | 6369 | } |
6963 | 6370 | ||
6964 | 6371 | ||
@@ -6982,24 +6389,23 @@ public class InternalSolverLanguageParser extends AbstractInternalContentAssistP | |||
6982 | 6389 | ||
6983 | 6390 | ||
6984 | // $ANTLR start "rule__UpperMultiplicty__Alternatives" | 6391 | // $ANTLR start "rule__UpperMultiplicty__Alternatives" |
6985 | // InternalSolverLanguage.g:1942:1: rule__UpperMultiplicty__Alternatives : ( ( RULE_INT ) | ( '*' ) ); | 6392 | // InternalSolverLanguageParser.g:2021:1: rule__UpperMultiplicty__Alternatives : ( ( RULE_INT ) | ( Asterisk ) ); |
6986 | public final void rule__UpperMultiplicty__Alternatives() throws RecognitionException { | 6393 | public final void rule__UpperMultiplicty__Alternatives() throws RecognitionException { |
6987 | 6394 | ||
6988 | int stackSize = keepStackSize(); | 6395 | int stackSize = keepStackSize(); |
6989 | 6396 | ||
6990 | try { | 6397 | try { |
6991 | // InternalSolverLanguage.g:1946:1: ( ( RULE_INT ) | ( '*' ) ) | 6398 | // InternalSolverLanguageParser.g:2025:1: ( ( RULE_INT ) | ( Asterisk ) ) |
6992 | int alt17=2; | 6399 | int alt17=2; |
6993 | int LA17_0 = input.LA(1); | 6400 | int LA17_0 = input.LA(1); |
6994 | 6401 | ||
6995 | if ( (LA17_0==RULE_INT) ) { | 6402 | if ( (LA17_0==RULE_INT) ) { |
6996 | alt17=1; | 6403 | alt17=1; |
6997 | } | 6404 | } |
6998 | else if ( (LA17_0==16) ) { | 6405 | else if ( (LA17_0==Asterisk) ) { |
6999 | alt17=2; | 6406 | alt17=2; |
7000 | } | 6407 | } |
7001 | else { | 6408 | else { |
7002 | if (state.backtracking>0) {state.failed=true; return ;} | ||
7003 | NoViableAltException nvae = | 6409 | NoViableAltException nvae = |
7004 | new NoViableAltException("", 17, 0, input); | 6410 | new NoViableAltException("", 17, 0, input); |
7005 | 6411 | ||
@@ -7007,18 +6413,14 @@ public class InternalSolverLanguageParser extends AbstractInternalContentAssistP | |||
7007 | } | 6413 | } |
7008 | switch (alt17) { | 6414 | switch (alt17) { |
7009 | case 1 : | 6415 | case 1 : |
7010 | // InternalSolverLanguage.g:1947:2: ( RULE_INT ) | 6416 | // InternalSolverLanguageParser.g:2026:2: ( RULE_INT ) |
7011 | { | 6417 | { |
7012 | // InternalSolverLanguage.g:1947:2: ( RULE_INT ) | 6418 | // InternalSolverLanguageParser.g:2026:2: ( RULE_INT ) |
7013 | // InternalSolverLanguage.g:1948:3: RULE_INT | 6419 | // InternalSolverLanguageParser.g:2027:3: RULE_INT |
7014 | { | 6420 | { |
7015 | if ( state.backtracking==0 ) { | 6421 | before(grammarAccess.getUpperMultiplictyAccess().getINTTerminalRuleCall_0()); |
7016 | before(grammarAccess.getUpperMultiplictyAccess().getINTTerminalRuleCall_0()); | 6422 | match(input,RULE_INT,FOLLOW_2); |
7017 | } | 6423 | after(grammarAccess.getUpperMultiplictyAccess().getINTTerminalRuleCall_0()); |
7018 | match(input,RULE_INT,FOLLOW_2); if (state.failed) return ; | ||
7019 | if ( state.backtracking==0 ) { | ||
7020 | after(grammarAccess.getUpperMultiplictyAccess().getINTTerminalRuleCall_0()); | ||
7021 | } | ||
7022 | 6424 | ||
7023 | } | 6425 | } |
7024 | 6426 | ||
@@ -7026,18 +6428,14 @@ public class InternalSolverLanguageParser extends AbstractInternalContentAssistP | |||
7026 | } | 6428 | } |
7027 | break; | 6429 | break; |
7028 | case 2 : | 6430 | case 2 : |
7029 | // InternalSolverLanguage.g:1953:2: ( '*' ) | 6431 | // InternalSolverLanguageParser.g:2032:2: ( Asterisk ) |
7030 | { | 6432 | { |
7031 | // InternalSolverLanguage.g:1953:2: ( '*' ) | 6433 | // InternalSolverLanguageParser.g:2032:2: ( Asterisk ) |
7032 | // InternalSolverLanguage.g:1954:3: '*' | 6434 | // InternalSolverLanguageParser.g:2033:3: Asterisk |
7033 | { | 6435 | { |
7034 | if ( state.backtracking==0 ) { | 6436 | before(grammarAccess.getUpperMultiplictyAccess().getAsteriskKeyword_1()); |
7035 | before(grammarAccess.getUpperMultiplictyAccess().getAsteriskKeyword_1()); | 6437 | match(input,Asterisk,FOLLOW_2); |
7036 | } | 6438 | after(grammarAccess.getUpperMultiplictyAccess().getAsteriskKeyword_1()); |
7037 | match(input,16,FOLLOW_2); if (state.failed) return ; | ||
7038 | if ( state.backtracking==0 ) { | ||
7039 | after(grammarAccess.getUpperMultiplictyAccess().getAsteriskKeyword_1()); | ||
7040 | } | ||
7041 | 6439 | ||
7042 | } | 6440 | } |
7043 | 6441 | ||
@@ -7062,13 +6460,13 @@ public class InternalSolverLanguageParser extends AbstractInternalContentAssistP | |||
7062 | 6460 | ||
7063 | 6461 | ||
7064 | // $ANTLR start "rule__QualifiedName__Alternatives" | 6462 | // $ANTLR start "rule__QualifiedName__Alternatives" |
7065 | // InternalSolverLanguage.g:1963:1: rule__QualifiedName__Alternatives : ( ( ( rule__QualifiedName__Group_0__0 ) ) | ( RULE_QUOTED_ID ) ); | 6463 | // InternalSolverLanguageParser.g:2042:1: rule__QualifiedName__Alternatives : ( ( ( rule__QualifiedName__Group_0__0 ) ) | ( RULE_QUOTED_ID ) ); |
7066 | public final void rule__QualifiedName__Alternatives() throws RecognitionException { | 6464 | public final void rule__QualifiedName__Alternatives() throws RecognitionException { |
7067 | 6465 | ||
7068 | int stackSize = keepStackSize(); | 6466 | int stackSize = keepStackSize(); |
7069 | 6467 | ||
7070 | try { | 6468 | try { |
7071 | // InternalSolverLanguage.g:1967:1: ( ( ( rule__QualifiedName__Group_0__0 ) ) | ( RULE_QUOTED_ID ) ) | 6469 | // InternalSolverLanguageParser.g:2046:1: ( ( ( rule__QualifiedName__Group_0__0 ) ) | ( RULE_QUOTED_ID ) ) |
7072 | int alt18=2; | 6470 | int alt18=2; |
7073 | int LA18_0 = input.LA(1); | 6471 | int LA18_0 = input.LA(1); |
7074 | 6472 | ||
@@ -7079,7 +6477,6 @@ public class InternalSolverLanguageParser extends AbstractInternalContentAssistP | |||
7079 | alt18=2; | 6477 | alt18=2; |
7080 | } | 6478 | } |
7081 | else { | 6479 | else { |
7082 | if (state.backtracking>0) {state.failed=true; return ;} | ||
7083 | NoViableAltException nvae = | 6480 | NoViableAltException nvae = |
7084 | new NoViableAltException("", 18, 0, input); | 6481 | new NoViableAltException("", 18, 0, input); |
7085 | 6482 | ||
@@ -7087,47 +6484,39 @@ public class InternalSolverLanguageParser extends AbstractInternalContentAssistP | |||
7087 | } | 6484 | } |
7088 | switch (alt18) { | 6485 | switch (alt18) { |
7089 | case 1 : | 6486 | case 1 : |
7090 | // InternalSolverLanguage.g:1968:2: ( ( rule__QualifiedName__Group_0__0 ) ) | 6487 | // InternalSolverLanguageParser.g:2047:2: ( ( rule__QualifiedName__Group_0__0 ) ) |
7091 | { | 6488 | { |
7092 | // InternalSolverLanguage.g:1968:2: ( ( rule__QualifiedName__Group_0__0 ) ) | 6489 | // InternalSolverLanguageParser.g:2047:2: ( ( rule__QualifiedName__Group_0__0 ) ) |
7093 | // InternalSolverLanguage.g:1969:3: ( rule__QualifiedName__Group_0__0 ) | 6490 | // InternalSolverLanguageParser.g:2048:3: ( rule__QualifiedName__Group_0__0 ) |
7094 | { | 6491 | { |
7095 | if ( state.backtracking==0 ) { | 6492 | before(grammarAccess.getQualifiedNameAccess().getGroup_0()); |
7096 | before(grammarAccess.getQualifiedNameAccess().getGroup_0()); | 6493 | // InternalSolverLanguageParser.g:2049:3: ( rule__QualifiedName__Group_0__0 ) |
7097 | } | 6494 | // InternalSolverLanguageParser.g:2049:4: rule__QualifiedName__Group_0__0 |
7098 | // InternalSolverLanguage.g:1970:3: ( rule__QualifiedName__Group_0__0 ) | ||
7099 | // InternalSolverLanguage.g:1970:4: rule__QualifiedName__Group_0__0 | ||
7100 | { | 6495 | { |
7101 | pushFollow(FOLLOW_2); | 6496 | pushFollow(FOLLOW_2); |
7102 | rule__QualifiedName__Group_0__0(); | 6497 | rule__QualifiedName__Group_0__0(); |
7103 | 6498 | ||
7104 | state._fsp--; | 6499 | state._fsp--; |
7105 | if (state.failed) return ; | ||
7106 | 6500 | ||
7107 | } | ||
7108 | 6501 | ||
7109 | if ( state.backtracking==0 ) { | ||
7110 | after(grammarAccess.getQualifiedNameAccess().getGroup_0()); | ||
7111 | } | 6502 | } |
7112 | 6503 | ||
6504 | after(grammarAccess.getQualifiedNameAccess().getGroup_0()); | ||
6505 | |||
7113 | } | 6506 | } |
7114 | 6507 | ||
7115 | 6508 | ||
7116 | } | 6509 | } |
7117 | break; | 6510 | break; |
7118 | case 2 : | 6511 | case 2 : |
7119 | // InternalSolverLanguage.g:1974:2: ( RULE_QUOTED_ID ) | 6512 | // InternalSolverLanguageParser.g:2053:2: ( RULE_QUOTED_ID ) |
7120 | { | 6513 | { |
7121 | // InternalSolverLanguage.g:1974:2: ( RULE_QUOTED_ID ) | 6514 | // InternalSolverLanguageParser.g:2053:2: ( RULE_QUOTED_ID ) |
7122 | // InternalSolverLanguage.g:1975:3: RULE_QUOTED_ID | 6515 | // InternalSolverLanguageParser.g:2054:3: RULE_QUOTED_ID |
7123 | { | 6516 | { |
7124 | if ( state.backtracking==0 ) { | 6517 | before(grammarAccess.getQualifiedNameAccess().getQUOTED_IDTerminalRuleCall_1()); |
7125 | before(grammarAccess.getQualifiedNameAccess().getQUOTED_IDTerminalRuleCall_1()); | 6518 | match(input,RULE_QUOTED_ID,FOLLOW_2); |
7126 | } | 6519 | after(grammarAccess.getQualifiedNameAccess().getQUOTED_IDTerminalRuleCall_1()); |
7127 | match(input,RULE_QUOTED_ID,FOLLOW_2); if (state.failed) return ; | ||
7128 | if ( state.backtracking==0 ) { | ||
7129 | after(grammarAccess.getQualifiedNameAccess().getQUOTED_IDTerminalRuleCall_1()); | ||
7130 | } | ||
7131 | 6520 | ||
7132 | } | 6521 | } |
7133 | 6522 | ||
@@ -7152,24 +6541,23 @@ public class InternalSolverLanguageParser extends AbstractInternalContentAssistP | |||
7152 | 6541 | ||
7153 | 6542 | ||
7154 | // $ANTLR start "rule__MetricType__Alternatives" | 6543 | // $ANTLR start "rule__MetricType__Alternatives" |
7155 | // InternalSolverLanguage.g:1984:1: rule__MetricType__Alternatives : ( ( ( 'int' ) ) | ( ( 'real' ) ) ); | 6544 | // InternalSolverLanguageParser.g:2063:1: rule__MetricType__Alternatives : ( ( ( Int ) ) | ( ( Real ) ) ); |
7156 | public final void rule__MetricType__Alternatives() throws RecognitionException { | 6545 | public final void rule__MetricType__Alternatives() throws RecognitionException { |
7157 | 6546 | ||
7158 | int stackSize = keepStackSize(); | 6547 | int stackSize = keepStackSize(); |
7159 | 6548 | ||
7160 | try { | 6549 | try { |
7161 | // InternalSolverLanguage.g:1988:1: ( ( ( 'int' ) ) | ( ( 'real' ) ) ) | 6550 | // InternalSolverLanguageParser.g:2067:1: ( ( ( Int ) ) | ( ( Real ) ) ) |
7162 | int alt19=2; | 6551 | int alt19=2; |
7163 | int LA19_0 = input.LA(1); | 6552 | int LA19_0 = input.LA(1); |
7164 | 6553 | ||
7165 | if ( (LA19_0==17) ) { | 6554 | if ( (LA19_0==Int) ) { |
7166 | alt19=1; | 6555 | alt19=1; |
7167 | } | 6556 | } |
7168 | else if ( (LA19_0==18) ) { | 6557 | else if ( (LA19_0==Real) ) { |
7169 | alt19=2; | 6558 | alt19=2; |
7170 | } | 6559 | } |
7171 | else { | 6560 | else { |
7172 | if (state.backtracking>0) {state.failed=true; return ;} | ||
7173 | NoViableAltException nvae = | 6561 | NoViableAltException nvae = |
7174 | new NoViableAltException("", 19, 0, input); | 6562 | new NoViableAltException("", 19, 0, input); |
7175 | 6563 | ||
@@ -7177,24 +6565,20 @@ public class InternalSolverLanguageParser extends AbstractInternalContentAssistP | |||
7177 | } | 6565 | } |
7178 | switch (alt19) { | 6566 | switch (alt19) { |
7179 | case 1 : | 6567 | case 1 : |
7180 | // InternalSolverLanguage.g:1989:2: ( ( 'int' ) ) | 6568 | // InternalSolverLanguageParser.g:2068:2: ( ( Int ) ) |
7181 | { | 6569 | { |
7182 | // InternalSolverLanguage.g:1989:2: ( ( 'int' ) ) | 6570 | // InternalSolverLanguageParser.g:2068:2: ( ( Int ) ) |
7183 | // InternalSolverLanguage.g:1990:3: ( 'int' ) | 6571 | // InternalSolverLanguageParser.g:2069:3: ( Int ) |
7184 | { | 6572 | { |
7185 | if ( state.backtracking==0 ) { | 6573 | before(grammarAccess.getMetricTypeAccess().getINTEnumLiteralDeclaration_0()); |
7186 | before(grammarAccess.getMetricTypeAccess().getINTEnumLiteralDeclaration_0()); | 6574 | // InternalSolverLanguageParser.g:2070:3: ( Int ) |
7187 | } | 6575 | // InternalSolverLanguageParser.g:2070:4: Int |
7188 | // InternalSolverLanguage.g:1991:3: ( 'int' ) | ||
7189 | // InternalSolverLanguage.g:1991:4: 'int' | ||
7190 | { | 6576 | { |
7191 | match(input,17,FOLLOW_2); if (state.failed) return ; | 6577 | match(input,Int,FOLLOW_2); |
7192 | 6578 | ||
7193 | } | 6579 | } |
7194 | 6580 | ||
7195 | if ( state.backtracking==0 ) { | 6581 | after(grammarAccess.getMetricTypeAccess().getINTEnumLiteralDeclaration_0()); |
7196 | after(grammarAccess.getMetricTypeAccess().getINTEnumLiteralDeclaration_0()); | ||
7197 | } | ||
7198 | 6582 | ||
7199 | } | 6583 | } |
7200 | 6584 | ||
@@ -7202,24 +6586,20 @@ public class InternalSolverLanguageParser extends AbstractInternalContentAssistP | |||
7202 | } | 6586 | } |
7203 | break; | 6587 | break; |
7204 | case 2 : | 6588 | case 2 : |
7205 | // InternalSolverLanguage.g:1995:2: ( ( 'real' ) ) | 6589 | // InternalSolverLanguageParser.g:2074:2: ( ( Real ) ) |
7206 | { | 6590 | { |
7207 | // InternalSolverLanguage.g:1995:2: ( ( 'real' ) ) | 6591 | // InternalSolverLanguageParser.g:2074:2: ( ( Real ) ) |
7208 | // InternalSolverLanguage.g:1996:3: ( 'real' ) | 6592 | // InternalSolverLanguageParser.g:2075:3: ( Real ) |
7209 | { | 6593 | { |
7210 | if ( state.backtracking==0 ) { | 6594 | before(grammarAccess.getMetricTypeAccess().getREALEnumLiteralDeclaration_1()); |
7211 | before(grammarAccess.getMetricTypeAccess().getREALEnumLiteralDeclaration_1()); | 6595 | // InternalSolverLanguageParser.g:2076:3: ( Real ) |
7212 | } | 6596 | // InternalSolverLanguageParser.g:2076:4: Real |
7213 | // InternalSolverLanguage.g:1997:3: ( 'real' ) | ||
7214 | // InternalSolverLanguage.g:1997:4: 'real' | ||
7215 | { | 6597 | { |
7216 | match(input,18,FOLLOW_2); if (state.failed) return ; | 6598 | match(input,Real,FOLLOW_2); |
7217 | 6599 | ||
7218 | } | 6600 | } |
7219 | 6601 | ||
7220 | if ( state.backtracking==0 ) { | 6602 | after(grammarAccess.getMetricTypeAccess().getREALEnumLiteralDeclaration_1()); |
7221 | after(grammarAccess.getMetricTypeAccess().getREALEnumLiteralDeclaration_1()); | ||
7222 | } | ||
7223 | 6603 | ||
7224 | } | 6604 | } |
7225 | 6605 | ||
@@ -7244,52 +6624,51 @@ public class InternalSolverLanguageParser extends AbstractInternalContentAssistP | |||
7244 | 6624 | ||
7245 | 6625 | ||
7246 | // $ANTLR start "rule__ComparisonOperator__Alternatives" | 6626 | // $ANTLR start "rule__ComparisonOperator__Alternatives" |
7247 | // InternalSolverLanguage.g:2005:1: rule__ComparisonOperator__Alternatives : ( ( ( '==' ) ) | ( ( '!=' ) ) | ( ( '<' ) ) | ( ( '<=' ) ) | ( ( '>' ) ) | ( ( '>=' ) ) | ( ( 'in' ) ) ); | 6627 | // InternalSolverLanguageParser.g:2084:1: rule__ComparisonOperator__Alternatives : ( ( ( EqualsSignEqualsSign ) ) | ( ( ExclamationMarkEqualsSign ) ) | ( ( LessThanSign ) ) | ( ( LessThanSignEqualsSign ) ) | ( ( GreaterThanSign ) ) | ( ( GreaterThanSignEqualsSign ) ) | ( ( In ) ) ); |
7248 | public final void rule__ComparisonOperator__Alternatives() throws RecognitionException { | 6628 | public final void rule__ComparisonOperator__Alternatives() throws RecognitionException { |
7249 | 6629 | ||
7250 | int stackSize = keepStackSize(); | 6630 | int stackSize = keepStackSize(); |
7251 | 6631 | ||
7252 | try { | 6632 | try { |
7253 | // InternalSolverLanguage.g:2009:1: ( ( ( '==' ) ) | ( ( '!=' ) ) | ( ( '<' ) ) | ( ( '<=' ) ) | ( ( '>' ) ) | ( ( '>=' ) ) | ( ( 'in' ) ) ) | 6633 | // InternalSolverLanguageParser.g:2088:1: ( ( ( EqualsSignEqualsSign ) ) | ( ( ExclamationMarkEqualsSign ) ) | ( ( LessThanSign ) ) | ( ( LessThanSignEqualsSign ) ) | ( ( GreaterThanSign ) ) | ( ( GreaterThanSignEqualsSign ) ) | ( ( In ) ) ) |
7254 | int alt20=7; | 6634 | int alt20=7; |
7255 | switch ( input.LA(1) ) { | 6635 | switch ( input.LA(1) ) { |
7256 | case 19: | 6636 | case EqualsSignEqualsSign: |
7257 | { | 6637 | { |
7258 | alt20=1; | 6638 | alt20=1; |
7259 | } | 6639 | } |
7260 | break; | 6640 | break; |
7261 | case 20: | 6641 | case ExclamationMarkEqualsSign: |
7262 | { | 6642 | { |
7263 | alt20=2; | 6643 | alt20=2; |
7264 | } | 6644 | } |
7265 | break; | 6645 | break; |
7266 | case 21: | 6646 | case LessThanSign: |
7267 | { | 6647 | { |
7268 | alt20=3; | 6648 | alt20=3; |
7269 | } | 6649 | } |
7270 | break; | 6650 | break; |
7271 | case 22: | 6651 | case LessThanSignEqualsSign: |
7272 | { | 6652 | { |
7273 | alt20=4; | 6653 | alt20=4; |
7274 | } | 6654 | } |
7275 | break; | 6655 | break; |
7276 | case 23: | 6656 | case GreaterThanSign: |
7277 | { | 6657 | { |
7278 | alt20=5; | 6658 | alt20=5; |
7279 | } | 6659 | } |
7280 | break; | 6660 | break; |
7281 | case 24: | 6661 | case GreaterThanSignEqualsSign: |
7282 | { | 6662 | { |
7283 | alt20=6; | 6663 | alt20=6; |
7284 | } | 6664 | } |
7285 | break; | 6665 | break; |
7286 | case 25: | 6666 | case In: |
7287 | { | 6667 | { |
7288 | alt20=7; | 6668 | alt20=7; |
7289 | } | 6669 | } |
7290 | break; | 6670 | break; |
7291 | default: | 6671 | default: |
7292 | if (state.backtracking>0) {state.failed=true; return ;} | ||
7293 | NoViableAltException nvae = | 6672 | NoViableAltException nvae = |
7294 | new NoViableAltException("", 20, 0, input); | 6673 | new NoViableAltException("", 20, 0, input); |
7295 | 6674 | ||
@@ -7298,24 +6677,20 @@ public class InternalSolverLanguageParser extends AbstractInternalContentAssistP | |||
7298 | 6677 | ||
7299 | switch (alt20) { | 6678 | switch (alt20) { |
7300 | case 1 : | 6679 | case 1 : |
7301 | // InternalSolverLanguage.g:2010:2: ( ( '==' ) ) | 6680 | // InternalSolverLanguageParser.g:2089:2: ( ( EqualsSignEqualsSign ) ) |
7302 | { | 6681 | { |
7303 | // InternalSolverLanguage.g:2010:2: ( ( '==' ) ) | 6682 | // InternalSolverLanguageParser.g:2089:2: ( ( EqualsSignEqualsSign ) ) |
7304 | // InternalSolverLanguage.g:2011:3: ( '==' ) | 6683 | // InternalSolverLanguageParser.g:2090:3: ( EqualsSignEqualsSign ) |
7305 | { | 6684 | { |
7306 | if ( state.backtracking==0 ) { | 6685 | before(grammarAccess.getComparisonOperatorAccess().getEQEnumLiteralDeclaration_0()); |
7307 | before(grammarAccess.getComparisonOperatorAccess().getEQEnumLiteralDeclaration_0()); | 6686 | // InternalSolverLanguageParser.g:2091:3: ( EqualsSignEqualsSign ) |
7308 | } | 6687 | // InternalSolverLanguageParser.g:2091:4: EqualsSignEqualsSign |
7309 | // InternalSolverLanguage.g:2012:3: ( '==' ) | ||
7310 | // InternalSolverLanguage.g:2012:4: '==' | ||
7311 | { | 6688 | { |
7312 | match(input,19,FOLLOW_2); if (state.failed) return ; | 6689 | match(input,EqualsSignEqualsSign,FOLLOW_2); |
7313 | 6690 | ||
7314 | } | 6691 | } |
7315 | 6692 | ||
7316 | if ( state.backtracking==0 ) { | 6693 | after(grammarAccess.getComparisonOperatorAccess().getEQEnumLiteralDeclaration_0()); |
7317 | after(grammarAccess.getComparisonOperatorAccess().getEQEnumLiteralDeclaration_0()); | ||
7318 | } | ||
7319 | 6694 | ||
7320 | } | 6695 | } |
7321 | 6696 | ||
@@ -7323,24 +6698,20 @@ public class InternalSolverLanguageParser extends AbstractInternalContentAssistP | |||
7323 | } | 6698 | } |
7324 | break; | 6699 | break; |
7325 | case 2 : | 6700 | case 2 : |
7326 | // InternalSolverLanguage.g:2016:2: ( ( '!=' ) ) | 6701 | // InternalSolverLanguageParser.g:2095:2: ( ( ExclamationMarkEqualsSign ) ) |
7327 | { | 6702 | { |
7328 | // InternalSolverLanguage.g:2016:2: ( ( '!=' ) ) | 6703 | // InternalSolverLanguageParser.g:2095:2: ( ( ExclamationMarkEqualsSign ) ) |
7329 | // InternalSolverLanguage.g:2017:3: ( '!=' ) | 6704 | // InternalSolverLanguageParser.g:2096:3: ( ExclamationMarkEqualsSign ) |
7330 | { | 6705 | { |
7331 | if ( state.backtracking==0 ) { | 6706 | before(grammarAccess.getComparisonOperatorAccess().getNOT_EQEnumLiteralDeclaration_1()); |
7332 | before(grammarAccess.getComparisonOperatorAccess().getNOT_EQEnumLiteralDeclaration_1()); | 6707 | // InternalSolverLanguageParser.g:2097:3: ( ExclamationMarkEqualsSign ) |
7333 | } | 6708 | // InternalSolverLanguageParser.g:2097:4: ExclamationMarkEqualsSign |
7334 | // InternalSolverLanguage.g:2018:3: ( '!=' ) | ||
7335 | // InternalSolverLanguage.g:2018:4: '!=' | ||
7336 | { | 6709 | { |
7337 | match(input,20,FOLLOW_2); if (state.failed) return ; | 6710 | match(input,ExclamationMarkEqualsSign,FOLLOW_2); |
7338 | 6711 | ||
7339 | } | 6712 | } |
7340 | 6713 | ||
7341 | if ( state.backtracking==0 ) { | 6714 | after(grammarAccess.getComparisonOperatorAccess().getNOT_EQEnumLiteralDeclaration_1()); |
7342 | after(grammarAccess.getComparisonOperatorAccess().getNOT_EQEnumLiteralDeclaration_1()); | ||
7343 | } | ||
7344 | 6715 | ||
7345 | } | 6716 | } |
7346 | 6717 | ||
@@ -7348,24 +6719,20 @@ public class InternalSolverLanguageParser extends AbstractInternalContentAssistP | |||
7348 | } | 6719 | } |
7349 | break; | 6720 | break; |
7350 | case 3 : | 6721 | case 3 : |
7351 | // InternalSolverLanguage.g:2022:2: ( ( '<' ) ) | 6722 | // InternalSolverLanguageParser.g:2101:2: ( ( LessThanSign ) ) |
7352 | { | 6723 | { |
7353 | // InternalSolverLanguage.g:2022:2: ( ( '<' ) ) | 6724 | // InternalSolverLanguageParser.g:2101:2: ( ( LessThanSign ) ) |
7354 | // InternalSolverLanguage.g:2023:3: ( '<' ) | 6725 | // InternalSolverLanguageParser.g:2102:3: ( LessThanSign ) |
7355 | { | 6726 | { |
7356 | if ( state.backtracking==0 ) { | 6727 | before(grammarAccess.getComparisonOperatorAccess().getLESSEnumLiteralDeclaration_2()); |
7357 | before(grammarAccess.getComparisonOperatorAccess().getLESSEnumLiteralDeclaration_2()); | 6728 | // InternalSolverLanguageParser.g:2103:3: ( LessThanSign ) |
7358 | } | 6729 | // InternalSolverLanguageParser.g:2103:4: LessThanSign |
7359 | // InternalSolverLanguage.g:2024:3: ( '<' ) | ||
7360 | // InternalSolverLanguage.g:2024:4: '<' | ||
7361 | { | 6730 | { |
7362 | match(input,21,FOLLOW_2); if (state.failed) return ; | 6731 | match(input,LessThanSign,FOLLOW_2); |
7363 | 6732 | ||
7364 | } | 6733 | } |
7365 | 6734 | ||
7366 | if ( state.backtracking==0 ) { | 6735 | after(grammarAccess.getComparisonOperatorAccess().getLESSEnumLiteralDeclaration_2()); |
7367 | after(grammarAccess.getComparisonOperatorAccess().getLESSEnumLiteralDeclaration_2()); | ||
7368 | } | ||
7369 | 6736 | ||
7370 | } | 6737 | } |
7371 | 6738 | ||
@@ -7373,24 +6740,20 @@ public class InternalSolverLanguageParser extends AbstractInternalContentAssistP | |||
7373 | } | 6740 | } |
7374 | break; | 6741 | break; |
7375 | case 4 : | 6742 | case 4 : |
7376 | // InternalSolverLanguage.g:2028:2: ( ( '<=' ) ) | 6743 | // InternalSolverLanguageParser.g:2107:2: ( ( LessThanSignEqualsSign ) ) |
7377 | { | 6744 | { |
7378 | // InternalSolverLanguage.g:2028:2: ( ( '<=' ) ) | 6745 | // InternalSolverLanguageParser.g:2107:2: ( ( LessThanSignEqualsSign ) ) |
7379 | // InternalSolverLanguage.g:2029:3: ( '<=' ) | 6746 | // InternalSolverLanguageParser.g:2108:3: ( LessThanSignEqualsSign ) |
7380 | { | 6747 | { |
7381 | if ( state.backtracking==0 ) { | 6748 | before(grammarAccess.getComparisonOperatorAccess().getLESS_EQEnumLiteralDeclaration_3()); |
7382 | before(grammarAccess.getComparisonOperatorAccess().getLESS_EQEnumLiteralDeclaration_3()); | 6749 | // InternalSolverLanguageParser.g:2109:3: ( LessThanSignEqualsSign ) |
7383 | } | 6750 | // InternalSolverLanguageParser.g:2109:4: LessThanSignEqualsSign |
7384 | // InternalSolverLanguage.g:2030:3: ( '<=' ) | ||
7385 | // InternalSolverLanguage.g:2030:4: '<=' | ||
7386 | { | 6751 | { |
7387 | match(input,22,FOLLOW_2); if (state.failed) return ; | 6752 | match(input,LessThanSignEqualsSign,FOLLOW_2); |
7388 | 6753 | ||
7389 | } | 6754 | } |
7390 | 6755 | ||
7391 | if ( state.backtracking==0 ) { | 6756 | after(grammarAccess.getComparisonOperatorAccess().getLESS_EQEnumLiteralDeclaration_3()); |
7392 | after(grammarAccess.getComparisonOperatorAccess().getLESS_EQEnumLiteralDeclaration_3()); | ||
7393 | } | ||
7394 | 6757 | ||
7395 | } | 6758 | } |
7396 | 6759 | ||
@@ -7398,24 +6761,20 @@ public class InternalSolverLanguageParser extends AbstractInternalContentAssistP | |||
7398 | } | 6761 | } |
7399 | break; | 6762 | break; |
7400 | case 5 : | 6763 | case 5 : |
7401 | // InternalSolverLanguage.g:2034:2: ( ( '>' ) ) | 6764 | // InternalSolverLanguageParser.g:2113:2: ( ( GreaterThanSign ) ) |
7402 | { | 6765 | { |
7403 | // InternalSolverLanguage.g:2034:2: ( ( '>' ) ) | 6766 | // InternalSolverLanguageParser.g:2113:2: ( ( GreaterThanSign ) ) |
7404 | // InternalSolverLanguage.g:2035:3: ( '>' ) | 6767 | // InternalSolverLanguageParser.g:2114:3: ( GreaterThanSign ) |
7405 | { | 6768 | { |
7406 | if ( state.backtracking==0 ) { | 6769 | before(grammarAccess.getComparisonOperatorAccess().getGREATEREnumLiteralDeclaration_4()); |
7407 | before(grammarAccess.getComparisonOperatorAccess().getGREATEREnumLiteralDeclaration_4()); | 6770 | // InternalSolverLanguageParser.g:2115:3: ( GreaterThanSign ) |
7408 | } | 6771 | // InternalSolverLanguageParser.g:2115:4: GreaterThanSign |
7409 | // InternalSolverLanguage.g:2036:3: ( '>' ) | ||
7410 | // InternalSolverLanguage.g:2036:4: '>' | ||
7411 | { | 6772 | { |
7412 | match(input,23,FOLLOW_2); if (state.failed) return ; | 6773 | match(input,GreaterThanSign,FOLLOW_2); |
7413 | 6774 | ||
7414 | } | 6775 | } |
7415 | 6776 | ||
7416 | if ( state.backtracking==0 ) { | 6777 | after(grammarAccess.getComparisonOperatorAccess().getGREATEREnumLiteralDeclaration_4()); |
7417 | after(grammarAccess.getComparisonOperatorAccess().getGREATEREnumLiteralDeclaration_4()); | ||
7418 | } | ||
7419 | 6778 | ||
7420 | } | 6779 | } |
7421 | 6780 | ||
@@ -7423,24 +6782,20 @@ public class InternalSolverLanguageParser extends AbstractInternalContentAssistP | |||
7423 | } | 6782 | } |
7424 | break; | 6783 | break; |
7425 | case 6 : | 6784 | case 6 : |
7426 | // InternalSolverLanguage.g:2040:2: ( ( '>=' ) ) | 6785 | // InternalSolverLanguageParser.g:2119:2: ( ( GreaterThanSignEqualsSign ) ) |
7427 | { | 6786 | { |
7428 | // InternalSolverLanguage.g:2040:2: ( ( '>=' ) ) | 6787 | // InternalSolverLanguageParser.g:2119:2: ( ( GreaterThanSignEqualsSign ) ) |
7429 | // InternalSolverLanguage.g:2041:3: ( '>=' ) | 6788 | // InternalSolverLanguageParser.g:2120:3: ( GreaterThanSignEqualsSign ) |
7430 | { | 6789 | { |
7431 | if ( state.backtracking==0 ) { | 6790 | before(grammarAccess.getComparisonOperatorAccess().getGREATER_EQEnumLiteralDeclaration_5()); |
7432 | before(grammarAccess.getComparisonOperatorAccess().getGREATER_EQEnumLiteralDeclaration_5()); | 6791 | // InternalSolverLanguageParser.g:2121:3: ( GreaterThanSignEqualsSign ) |
7433 | } | 6792 | // InternalSolverLanguageParser.g:2121:4: GreaterThanSignEqualsSign |
7434 | // InternalSolverLanguage.g:2042:3: ( '>=' ) | ||
7435 | // InternalSolverLanguage.g:2042:4: '>=' | ||
7436 | { | 6793 | { |
7437 | match(input,24,FOLLOW_2); if (state.failed) return ; | 6794 | match(input,GreaterThanSignEqualsSign,FOLLOW_2); |
7438 | 6795 | ||
7439 | } | 6796 | } |
7440 | 6797 | ||
7441 | if ( state.backtracking==0 ) { | 6798 | after(grammarAccess.getComparisonOperatorAccess().getGREATER_EQEnumLiteralDeclaration_5()); |
7442 | after(grammarAccess.getComparisonOperatorAccess().getGREATER_EQEnumLiteralDeclaration_5()); | ||
7443 | } | ||
7444 | 6799 | ||
7445 | } | 6800 | } |
7446 | 6801 | ||
@@ -7448,24 +6803,20 @@ public class InternalSolverLanguageParser extends AbstractInternalContentAssistP | |||
7448 | } | 6803 | } |
7449 | break; | 6804 | break; |
7450 | case 7 : | 6805 | case 7 : |
7451 | // InternalSolverLanguage.g:2046:2: ( ( 'in' ) ) | 6806 | // InternalSolverLanguageParser.g:2125:2: ( ( In ) ) |
7452 | { | 6807 | { |
7453 | // InternalSolverLanguage.g:2046:2: ( ( 'in' ) ) | 6808 | // InternalSolverLanguageParser.g:2125:2: ( ( In ) ) |
7454 | // InternalSolverLanguage.g:2047:3: ( 'in' ) | 6809 | // InternalSolverLanguageParser.g:2126:3: ( In ) |
7455 | { | 6810 | { |
7456 | if ( state.backtracking==0 ) { | 6811 | before(grammarAccess.getComparisonOperatorAccess().getINEnumLiteralDeclaration_6()); |
7457 | before(grammarAccess.getComparisonOperatorAccess().getINEnumLiteralDeclaration_6()); | 6812 | // InternalSolverLanguageParser.g:2127:3: ( In ) |
7458 | } | 6813 | // InternalSolverLanguageParser.g:2127:4: In |
7459 | // InternalSolverLanguage.g:2048:3: ( 'in' ) | ||
7460 | // InternalSolverLanguage.g:2048:4: 'in' | ||
7461 | { | 6814 | { |
7462 | match(input,25,FOLLOW_2); if (state.failed) return ; | 6815 | match(input,In,FOLLOW_2); |
7463 | 6816 | ||
7464 | } | 6817 | } |
7465 | 6818 | ||
7466 | if ( state.backtracking==0 ) { | 6819 | after(grammarAccess.getComparisonOperatorAccess().getINEnumLiteralDeclaration_6()); |
7467 | after(grammarAccess.getComparisonOperatorAccess().getINEnumLiteralDeclaration_6()); | ||
7468 | } | ||
7469 | 6820 | ||
7470 | } | 6821 | } |
7471 | 6822 | ||
@@ -7490,24 +6841,23 @@ public class InternalSolverLanguageParser extends AbstractInternalContentAssistP | |||
7490 | 6841 | ||
7491 | 6842 | ||
7492 | // $ANTLR start "rule__AdditiveBinaryOperator__Alternatives" | 6843 | // $ANTLR start "rule__AdditiveBinaryOperator__Alternatives" |
7493 | // InternalSolverLanguage.g:2056:1: rule__AdditiveBinaryOperator__Alternatives : ( ( ( '+' ) ) | ( ( '-' ) ) ); | 6844 | // InternalSolverLanguageParser.g:2135:1: rule__AdditiveBinaryOperator__Alternatives : ( ( ( PlusSign ) ) | ( ( HyphenMinus ) ) ); |
7494 | public final void rule__AdditiveBinaryOperator__Alternatives() throws RecognitionException { | 6845 | public final void rule__AdditiveBinaryOperator__Alternatives() throws RecognitionException { |
7495 | 6846 | ||
7496 | int stackSize = keepStackSize(); | 6847 | int stackSize = keepStackSize(); |
7497 | 6848 | ||
7498 | try { | 6849 | try { |
7499 | // InternalSolverLanguage.g:2060:1: ( ( ( '+' ) ) | ( ( '-' ) ) ) | 6850 | // InternalSolverLanguageParser.g:2139:1: ( ( ( PlusSign ) ) | ( ( HyphenMinus ) ) ) |
7500 | int alt21=2; | 6851 | int alt21=2; |
7501 | int LA21_0 = input.LA(1); | 6852 | int LA21_0 = input.LA(1); |
7502 | 6853 | ||
7503 | if ( (LA21_0==26) ) { | 6854 | if ( (LA21_0==PlusSign) ) { |
7504 | alt21=1; | 6855 | alt21=1; |
7505 | } | 6856 | } |
7506 | else if ( (LA21_0==27) ) { | 6857 | else if ( (LA21_0==HyphenMinus) ) { |
7507 | alt21=2; | 6858 | alt21=2; |
7508 | } | 6859 | } |
7509 | else { | 6860 | else { |
7510 | if (state.backtracking>0) {state.failed=true; return ;} | ||
7511 | NoViableAltException nvae = | 6861 | NoViableAltException nvae = |
7512 | new NoViableAltException("", 21, 0, input); | 6862 | new NoViableAltException("", 21, 0, input); |
7513 | 6863 | ||
@@ -7515,24 +6865,20 @@ public class InternalSolverLanguageParser extends AbstractInternalContentAssistP | |||
7515 | } | 6865 | } |
7516 | switch (alt21) { | 6866 | switch (alt21) { |
7517 | case 1 : | 6867 | case 1 : |
7518 | // InternalSolverLanguage.g:2061:2: ( ( '+' ) ) | 6868 | // InternalSolverLanguageParser.g:2140:2: ( ( PlusSign ) ) |
7519 | { | 6869 | { |
7520 | // InternalSolverLanguage.g:2061:2: ( ( '+' ) ) | 6870 | // InternalSolverLanguageParser.g:2140:2: ( ( PlusSign ) ) |
7521 | // InternalSolverLanguage.g:2062:3: ( '+' ) | 6871 | // InternalSolverLanguageParser.g:2141:3: ( PlusSign ) |
7522 | { | 6872 | { |
7523 | if ( state.backtracking==0 ) { | 6873 | before(grammarAccess.getAdditiveBinaryOperatorAccess().getADDEnumLiteralDeclaration_0()); |
7524 | before(grammarAccess.getAdditiveBinaryOperatorAccess().getADDEnumLiteralDeclaration_0()); | 6874 | // InternalSolverLanguageParser.g:2142:3: ( PlusSign ) |
7525 | } | 6875 | // InternalSolverLanguageParser.g:2142:4: PlusSign |
7526 | // InternalSolverLanguage.g:2063:3: ( '+' ) | ||
7527 | // InternalSolverLanguage.g:2063:4: '+' | ||
7528 | { | 6876 | { |
7529 | match(input,26,FOLLOW_2); if (state.failed) return ; | 6877 | match(input,PlusSign,FOLLOW_2); |
7530 | 6878 | ||
7531 | } | 6879 | } |
7532 | 6880 | ||
7533 | if ( state.backtracking==0 ) { | 6881 | after(grammarAccess.getAdditiveBinaryOperatorAccess().getADDEnumLiteralDeclaration_0()); |
7534 | after(grammarAccess.getAdditiveBinaryOperatorAccess().getADDEnumLiteralDeclaration_0()); | ||
7535 | } | ||
7536 | 6882 | ||
7537 | } | 6883 | } |
7538 | 6884 | ||
@@ -7540,24 +6886,20 @@ public class InternalSolverLanguageParser extends AbstractInternalContentAssistP | |||
7540 | } | 6886 | } |
7541 | break; | 6887 | break; |
7542 | case 2 : | 6888 | case 2 : |
7543 | // InternalSolverLanguage.g:2067:2: ( ( '-' ) ) | 6889 | // InternalSolverLanguageParser.g:2146:2: ( ( HyphenMinus ) ) |
7544 | { | 6890 | { |
7545 | // InternalSolverLanguage.g:2067:2: ( ( '-' ) ) | 6891 | // InternalSolverLanguageParser.g:2146:2: ( ( HyphenMinus ) ) |
7546 | // InternalSolverLanguage.g:2068:3: ( '-' ) | 6892 | // InternalSolverLanguageParser.g:2147:3: ( HyphenMinus ) |
7547 | { | 6893 | { |
7548 | if ( state.backtracking==0 ) { | 6894 | before(grammarAccess.getAdditiveBinaryOperatorAccess().getSUBEnumLiteralDeclaration_1()); |
7549 | before(grammarAccess.getAdditiveBinaryOperatorAccess().getSUBEnumLiteralDeclaration_1()); | 6895 | // InternalSolverLanguageParser.g:2148:3: ( HyphenMinus ) |
7550 | } | 6896 | // InternalSolverLanguageParser.g:2148:4: HyphenMinus |
7551 | // InternalSolverLanguage.g:2069:3: ( '-' ) | ||
7552 | // InternalSolverLanguage.g:2069:4: '-' | ||
7553 | { | 6897 | { |
7554 | match(input,27,FOLLOW_2); if (state.failed) return ; | 6898 | match(input,HyphenMinus,FOLLOW_2); |
7555 | 6899 | ||
7556 | } | 6900 | } |
7557 | 6901 | ||
7558 | if ( state.backtracking==0 ) { | 6902 | after(grammarAccess.getAdditiveBinaryOperatorAccess().getSUBEnumLiteralDeclaration_1()); |
7559 | after(grammarAccess.getAdditiveBinaryOperatorAccess().getSUBEnumLiteralDeclaration_1()); | ||
7560 | } | ||
7561 | 6903 | ||
7562 | } | 6904 | } |
7563 | 6905 | ||
@@ -7582,24 +6924,23 @@ public class InternalSolverLanguageParser extends AbstractInternalContentAssistP | |||
7582 | 6924 | ||
7583 | 6925 | ||
7584 | // $ANTLR start "rule__MultiplicativeBinaryOperator__Alternatives" | 6926 | // $ANTLR start "rule__MultiplicativeBinaryOperator__Alternatives" |
7585 | // InternalSolverLanguage.g:2077:1: rule__MultiplicativeBinaryOperator__Alternatives : ( ( ( '*' ) ) | ( ( '/' ) ) ); | 6927 | // InternalSolverLanguageParser.g:2156:1: rule__MultiplicativeBinaryOperator__Alternatives : ( ( ( Asterisk ) ) | ( ( Solidus ) ) ); |
7586 | public final void rule__MultiplicativeBinaryOperator__Alternatives() throws RecognitionException { | 6928 | public final void rule__MultiplicativeBinaryOperator__Alternatives() throws RecognitionException { |
7587 | 6929 | ||
7588 | int stackSize = keepStackSize(); | 6930 | int stackSize = keepStackSize(); |
7589 | 6931 | ||
7590 | try { | 6932 | try { |
7591 | // InternalSolverLanguage.g:2081:1: ( ( ( '*' ) ) | ( ( '/' ) ) ) | 6933 | // InternalSolverLanguageParser.g:2160:1: ( ( ( Asterisk ) ) | ( ( Solidus ) ) ) |
7592 | int alt22=2; | 6934 | int alt22=2; |
7593 | int LA22_0 = input.LA(1); | 6935 | int LA22_0 = input.LA(1); |
7594 | 6936 | ||
7595 | if ( (LA22_0==16) ) { | 6937 | if ( (LA22_0==Asterisk) ) { |
7596 | alt22=1; | 6938 | alt22=1; |
7597 | } | 6939 | } |
7598 | else if ( (LA22_0==28) ) { | 6940 | else if ( (LA22_0==Solidus) ) { |
7599 | alt22=2; | 6941 | alt22=2; |
7600 | } | 6942 | } |
7601 | else { | 6943 | else { |
7602 | if (state.backtracking>0) {state.failed=true; return ;} | ||
7603 | NoViableAltException nvae = | 6944 | NoViableAltException nvae = |
7604 | new NoViableAltException("", 22, 0, input); | 6945 | new NoViableAltException("", 22, 0, input); |
7605 | 6946 | ||
@@ -7607,24 +6948,20 @@ public class InternalSolverLanguageParser extends AbstractInternalContentAssistP | |||
7607 | } | 6948 | } |
7608 | switch (alt22) { | 6949 | switch (alt22) { |
7609 | case 1 : | 6950 | case 1 : |
7610 | // InternalSolverLanguage.g:2082:2: ( ( '*' ) ) | 6951 | // InternalSolverLanguageParser.g:2161:2: ( ( Asterisk ) ) |
7611 | { | 6952 | { |
7612 | // InternalSolverLanguage.g:2082:2: ( ( '*' ) ) | 6953 | // InternalSolverLanguageParser.g:2161:2: ( ( Asterisk ) ) |
7613 | // InternalSolverLanguage.g:2083:3: ( '*' ) | 6954 | // InternalSolverLanguageParser.g:2162:3: ( Asterisk ) |
7614 | { | 6955 | { |
7615 | if ( state.backtracking==0 ) { | 6956 | before(grammarAccess.getMultiplicativeBinaryOperatorAccess().getMULEnumLiteralDeclaration_0()); |
7616 | before(grammarAccess.getMultiplicativeBinaryOperatorAccess().getMULEnumLiteralDeclaration_0()); | 6957 | // InternalSolverLanguageParser.g:2163:3: ( Asterisk ) |
7617 | } | 6958 | // InternalSolverLanguageParser.g:2163:4: Asterisk |
7618 | // InternalSolverLanguage.g:2084:3: ( '*' ) | ||
7619 | // InternalSolverLanguage.g:2084:4: '*' | ||
7620 | { | 6959 | { |
7621 | match(input,16,FOLLOW_2); if (state.failed) return ; | 6960 | match(input,Asterisk,FOLLOW_2); |
7622 | 6961 | ||
7623 | } | 6962 | } |
7624 | 6963 | ||
7625 | if ( state.backtracking==0 ) { | 6964 | after(grammarAccess.getMultiplicativeBinaryOperatorAccess().getMULEnumLiteralDeclaration_0()); |
7626 | after(grammarAccess.getMultiplicativeBinaryOperatorAccess().getMULEnumLiteralDeclaration_0()); | ||
7627 | } | ||
7628 | 6965 | ||
7629 | } | 6966 | } |
7630 | 6967 | ||
@@ -7632,24 +6969,20 @@ public class InternalSolverLanguageParser extends AbstractInternalContentAssistP | |||
7632 | } | 6969 | } |
7633 | break; | 6970 | break; |
7634 | case 2 : | 6971 | case 2 : |
7635 | // InternalSolverLanguage.g:2088:2: ( ( '/' ) ) | 6972 | // InternalSolverLanguageParser.g:2167:2: ( ( Solidus ) ) |
7636 | { | 6973 | { |
7637 | // InternalSolverLanguage.g:2088:2: ( ( '/' ) ) | 6974 | // InternalSolverLanguageParser.g:2167:2: ( ( Solidus ) ) |
7638 | // InternalSolverLanguage.g:2089:3: ( '/' ) | 6975 | // InternalSolverLanguageParser.g:2168:3: ( Solidus ) |
7639 | { | 6976 | { |
7640 | if ( state.backtracking==0 ) { | 6977 | before(grammarAccess.getMultiplicativeBinaryOperatorAccess().getDIVEnumLiteralDeclaration_1()); |
7641 | before(grammarAccess.getMultiplicativeBinaryOperatorAccess().getDIVEnumLiteralDeclaration_1()); | 6978 | // InternalSolverLanguageParser.g:2169:3: ( Solidus ) |
7642 | } | 6979 | // InternalSolverLanguageParser.g:2169:4: Solidus |
7643 | // InternalSolverLanguage.g:2090:3: ( '/' ) | ||
7644 | // InternalSolverLanguage.g:2090:4: '/' | ||
7645 | { | 6980 | { |
7646 | match(input,28,FOLLOW_2); if (state.failed) return ; | 6981 | match(input,Solidus,FOLLOW_2); |
7647 | 6982 | ||
7648 | } | 6983 | } |
7649 | 6984 | ||
7650 | if ( state.backtracking==0 ) { | 6985 | after(grammarAccess.getMultiplicativeBinaryOperatorAccess().getDIVEnumLiteralDeclaration_1()); |
7651 | after(grammarAccess.getMultiplicativeBinaryOperatorAccess().getDIVEnumLiteralDeclaration_1()); | ||
7652 | } | ||
7653 | 6986 | ||
7654 | } | 6987 | } |
7655 | 6988 | ||
@@ -7674,47 +7007,46 @@ public class InternalSolverLanguageParser extends AbstractInternalContentAssistP | |||
7674 | 7007 | ||
7675 | 7008 | ||
7676 | // $ANTLR start "rule__UnaryOp__Alternatives" | 7009 | // $ANTLR start "rule__UnaryOp__Alternatives" |
7677 | // InternalSolverLanguage.g:2098:1: rule__UnaryOp__Alternatives : ( ( ( '!' ) ) | ( ( '+' ) ) | ( ( '-' ) ) | ( ( 'may' ) ) | ( ( 'must' ) ) | ( ( 'current' ) ) ); | 7010 | // InternalSolverLanguageParser.g:2177:1: rule__UnaryOp__Alternatives : ( ( ( ExclamationMark ) ) | ( ( PlusSign ) ) | ( ( HyphenMinus ) ) | ( ( May ) ) | ( ( Must ) ) | ( ( Current ) ) ); |
7678 | public final void rule__UnaryOp__Alternatives() throws RecognitionException { | 7011 | public final void rule__UnaryOp__Alternatives() throws RecognitionException { |
7679 | 7012 | ||
7680 | int stackSize = keepStackSize(); | 7013 | int stackSize = keepStackSize(); |
7681 | 7014 | ||
7682 | try { | 7015 | try { |
7683 | // InternalSolverLanguage.g:2102:1: ( ( ( '!' ) ) | ( ( '+' ) ) | ( ( '-' ) ) | ( ( 'may' ) ) | ( ( 'must' ) ) | ( ( 'current' ) ) ) | 7016 | // InternalSolverLanguageParser.g:2181:1: ( ( ( ExclamationMark ) ) | ( ( PlusSign ) ) | ( ( HyphenMinus ) ) | ( ( May ) ) | ( ( Must ) ) | ( ( Current ) ) ) |
7684 | int alt23=6; | 7017 | int alt23=6; |
7685 | switch ( input.LA(1) ) { | 7018 | switch ( input.LA(1) ) { |
7686 | case 29: | 7019 | case ExclamationMark: |
7687 | { | 7020 | { |
7688 | alt23=1; | 7021 | alt23=1; |
7689 | } | 7022 | } |
7690 | break; | 7023 | break; |
7691 | case 26: | 7024 | case PlusSign: |
7692 | { | 7025 | { |
7693 | alt23=2; | 7026 | alt23=2; |
7694 | } | 7027 | } |
7695 | break; | 7028 | break; |
7696 | case 27: | 7029 | case HyphenMinus: |
7697 | { | 7030 | { |
7698 | alt23=3; | 7031 | alt23=3; |
7699 | } | 7032 | } |
7700 | break; | 7033 | break; |
7701 | case 30: | 7034 | case May: |
7702 | { | 7035 | { |
7703 | alt23=4; | 7036 | alt23=4; |
7704 | } | 7037 | } |
7705 | break; | 7038 | break; |
7706 | case 31: | 7039 | case Must: |
7707 | { | 7040 | { |
7708 | alt23=5; | 7041 | alt23=5; |
7709 | } | 7042 | } |
7710 | break; | 7043 | break; |
7711 | case 32: | 7044 | case Current: |
7712 | { | 7045 | { |
7713 | alt23=6; | 7046 | alt23=6; |
7714 | } | 7047 | } |
7715 | break; | 7048 | break; |
7716 | default: | 7049 | default: |
7717 | if (state.backtracking>0) {state.failed=true; return ;} | ||
7718 | NoViableAltException nvae = | 7050 | NoViableAltException nvae = |
7719 | new NoViableAltException("", 23, 0, input); | 7051 | new NoViableAltException("", 23, 0, input); |
7720 | 7052 | ||
@@ -7723,24 +7055,20 @@ public class InternalSolverLanguageParser extends AbstractInternalContentAssistP | |||
7723 | 7055 | ||
7724 | switch (alt23) { | 7056 | switch (alt23) { |
7725 | case 1 : | 7057 | case 1 : |
7726 | // InternalSolverLanguage.g:2103:2: ( ( '!' ) ) | 7058 | // InternalSolverLanguageParser.g:2182:2: ( ( ExclamationMark ) ) |
7727 | { | 7059 | { |
7728 | // InternalSolverLanguage.g:2103:2: ( ( '!' ) ) | 7060 | // InternalSolverLanguageParser.g:2182:2: ( ( ExclamationMark ) ) |
7729 | // InternalSolverLanguage.g:2104:3: ( '!' ) | 7061 | // InternalSolverLanguageParser.g:2183:3: ( ExclamationMark ) |
7730 | { | 7062 | { |
7731 | if ( state.backtracking==0 ) { | 7063 | before(grammarAccess.getUnaryOpAccess().getNEGEnumLiteralDeclaration_0()); |
7732 | before(grammarAccess.getUnaryOpAccess().getNEGEnumLiteralDeclaration_0()); | 7064 | // InternalSolverLanguageParser.g:2184:3: ( ExclamationMark ) |
7733 | } | 7065 | // InternalSolverLanguageParser.g:2184:4: ExclamationMark |
7734 | // InternalSolverLanguage.g:2105:3: ( '!' ) | ||
7735 | // InternalSolverLanguage.g:2105:4: '!' | ||
7736 | { | 7066 | { |
7737 | match(input,29,FOLLOW_2); if (state.failed) return ; | 7067 | match(input,ExclamationMark,FOLLOW_2); |
7738 | 7068 | ||
7739 | } | 7069 | } |
7740 | 7070 | ||
7741 | if ( state.backtracking==0 ) { | 7071 | after(grammarAccess.getUnaryOpAccess().getNEGEnumLiteralDeclaration_0()); |
7742 | after(grammarAccess.getUnaryOpAccess().getNEGEnumLiteralDeclaration_0()); | ||
7743 | } | ||
7744 | 7072 | ||
7745 | } | 7073 | } |
7746 | 7074 | ||
@@ -7748,24 +7076,20 @@ public class InternalSolverLanguageParser extends AbstractInternalContentAssistP | |||
7748 | } | 7076 | } |
7749 | break; | 7077 | break; |
7750 | case 2 : | 7078 | case 2 : |
7751 | // InternalSolverLanguage.g:2109:2: ( ( '+' ) ) | 7079 | // InternalSolverLanguageParser.g:2188:2: ( ( PlusSign ) ) |
7752 | { | 7080 | { |
7753 | // InternalSolverLanguage.g:2109:2: ( ( '+' ) ) | 7081 | // InternalSolverLanguageParser.g:2188:2: ( ( PlusSign ) ) |
7754 | // InternalSolverLanguage.g:2110:3: ( '+' ) | 7082 | // InternalSolverLanguageParser.g:2189:3: ( PlusSign ) |
7755 | { | 7083 | { |
7756 | if ( state.backtracking==0 ) { | 7084 | before(grammarAccess.getUnaryOpAccess().getPLUSEnumLiteralDeclaration_1()); |
7757 | before(grammarAccess.getUnaryOpAccess().getPLUSEnumLiteralDeclaration_1()); | 7085 | // InternalSolverLanguageParser.g:2190:3: ( PlusSign ) |
7758 | } | 7086 | // InternalSolverLanguageParser.g:2190:4: PlusSign |
7759 | // InternalSolverLanguage.g:2111:3: ( '+' ) | ||
7760 | // InternalSolverLanguage.g:2111:4: '+' | ||
7761 | { | 7087 | { |
7762 | match(input,26,FOLLOW_2); if (state.failed) return ; | 7088 | match(input,PlusSign,FOLLOW_2); |
7763 | 7089 | ||
7764 | } | 7090 | } |
7765 | 7091 | ||
7766 | if ( state.backtracking==0 ) { | 7092 | after(grammarAccess.getUnaryOpAccess().getPLUSEnumLiteralDeclaration_1()); |
7767 | after(grammarAccess.getUnaryOpAccess().getPLUSEnumLiteralDeclaration_1()); | ||
7768 | } | ||
7769 | 7093 | ||
7770 | } | 7094 | } |
7771 | 7095 | ||
@@ -7773,24 +7097,20 @@ public class InternalSolverLanguageParser extends AbstractInternalContentAssistP | |||
7773 | } | 7097 | } |
7774 | break; | 7098 | break; |
7775 | case 3 : | 7099 | case 3 : |
7776 | // InternalSolverLanguage.g:2115:2: ( ( '-' ) ) | 7100 | // InternalSolverLanguageParser.g:2194:2: ( ( HyphenMinus ) ) |
7777 | { | 7101 | { |
7778 | // InternalSolverLanguage.g:2115:2: ( ( '-' ) ) | 7102 | // InternalSolverLanguageParser.g:2194:2: ( ( HyphenMinus ) ) |
7779 | // InternalSolverLanguage.g:2116:3: ( '-' ) | 7103 | // InternalSolverLanguageParser.g:2195:3: ( HyphenMinus ) |
7780 | { | 7104 | { |
7781 | if ( state.backtracking==0 ) { | 7105 | before(grammarAccess.getUnaryOpAccess().getMINUSEnumLiteralDeclaration_2()); |
7782 | before(grammarAccess.getUnaryOpAccess().getMINUSEnumLiteralDeclaration_2()); | 7106 | // InternalSolverLanguageParser.g:2196:3: ( HyphenMinus ) |
7783 | } | 7107 | // InternalSolverLanguageParser.g:2196:4: HyphenMinus |
7784 | // InternalSolverLanguage.g:2117:3: ( '-' ) | ||
7785 | // InternalSolverLanguage.g:2117:4: '-' | ||
7786 | { | 7108 | { |
7787 | match(input,27,FOLLOW_2); if (state.failed) return ; | 7109 | match(input,HyphenMinus,FOLLOW_2); |
7788 | 7110 | ||
7789 | } | 7111 | } |
7790 | 7112 | ||
7791 | if ( state.backtracking==0 ) { | 7113 | after(grammarAccess.getUnaryOpAccess().getMINUSEnumLiteralDeclaration_2()); |
7792 | after(grammarAccess.getUnaryOpAccess().getMINUSEnumLiteralDeclaration_2()); | ||
7793 | } | ||
7794 | 7114 | ||
7795 | } | 7115 | } |
7796 | 7116 | ||
@@ -7798,24 +7118,20 @@ public class InternalSolverLanguageParser extends AbstractInternalContentAssistP | |||
7798 | } | 7118 | } |
7799 | break; | 7119 | break; |
7800 | case 4 : | 7120 | case 4 : |
7801 | // InternalSolverLanguage.g:2121:2: ( ( 'may' ) ) | 7121 | // InternalSolverLanguageParser.g:2200:2: ( ( May ) ) |
7802 | { | 7122 | { |
7803 | // InternalSolverLanguage.g:2121:2: ( ( 'may' ) ) | 7123 | // InternalSolverLanguageParser.g:2200:2: ( ( May ) ) |
7804 | // InternalSolverLanguage.g:2122:3: ( 'may' ) | 7124 | // InternalSolverLanguageParser.g:2201:3: ( May ) |
7805 | { | 7125 | { |
7806 | if ( state.backtracking==0 ) { | 7126 | before(grammarAccess.getUnaryOpAccess().getMAYEnumLiteralDeclaration_3()); |
7807 | before(grammarAccess.getUnaryOpAccess().getMAYEnumLiteralDeclaration_3()); | 7127 | // InternalSolverLanguageParser.g:2202:3: ( May ) |
7808 | } | 7128 | // InternalSolverLanguageParser.g:2202:4: May |
7809 | // InternalSolverLanguage.g:2123:3: ( 'may' ) | ||
7810 | // InternalSolverLanguage.g:2123:4: 'may' | ||
7811 | { | 7129 | { |
7812 | match(input,30,FOLLOW_2); if (state.failed) return ; | 7130 | match(input,May,FOLLOW_2); |
7813 | 7131 | ||
7814 | } | 7132 | } |
7815 | 7133 | ||
7816 | if ( state.backtracking==0 ) { | 7134 | after(grammarAccess.getUnaryOpAccess().getMAYEnumLiteralDeclaration_3()); |
7817 | after(grammarAccess.getUnaryOpAccess().getMAYEnumLiteralDeclaration_3()); | ||
7818 | } | ||
7819 | 7135 | ||
7820 | } | 7136 | } |
7821 | 7137 | ||
@@ -7823,24 +7139,20 @@ public class InternalSolverLanguageParser extends AbstractInternalContentAssistP | |||
7823 | } | 7139 | } |
7824 | break; | 7140 | break; |
7825 | case 5 : | 7141 | case 5 : |
7826 | // InternalSolverLanguage.g:2127:2: ( ( 'must' ) ) | 7142 | // InternalSolverLanguageParser.g:2206:2: ( ( Must ) ) |
7827 | { | 7143 | { |
7828 | // InternalSolverLanguage.g:2127:2: ( ( 'must' ) ) | 7144 | // InternalSolverLanguageParser.g:2206:2: ( ( Must ) ) |
7829 | // InternalSolverLanguage.g:2128:3: ( 'must' ) | 7145 | // InternalSolverLanguageParser.g:2207:3: ( Must ) |
7830 | { | 7146 | { |
7831 | if ( state.backtracking==0 ) { | 7147 | before(grammarAccess.getUnaryOpAccess().getMUSTEnumLiteralDeclaration_4()); |
7832 | before(grammarAccess.getUnaryOpAccess().getMUSTEnumLiteralDeclaration_4()); | 7148 | // InternalSolverLanguageParser.g:2208:3: ( Must ) |
7833 | } | 7149 | // InternalSolverLanguageParser.g:2208:4: Must |
7834 | // InternalSolverLanguage.g:2129:3: ( 'must' ) | ||
7835 | // InternalSolverLanguage.g:2129:4: 'must' | ||
7836 | { | 7150 | { |
7837 | match(input,31,FOLLOW_2); if (state.failed) return ; | 7151 | match(input,Must,FOLLOW_2); |
7838 | 7152 | ||
7839 | } | 7153 | } |
7840 | 7154 | ||
7841 | if ( state.backtracking==0 ) { | 7155 | after(grammarAccess.getUnaryOpAccess().getMUSTEnumLiteralDeclaration_4()); |
7842 | after(grammarAccess.getUnaryOpAccess().getMUSTEnumLiteralDeclaration_4()); | ||
7843 | } | ||
7844 | 7156 | ||
7845 | } | 7157 | } |
7846 | 7158 | ||
@@ -7848,24 +7160,20 @@ public class InternalSolverLanguageParser extends AbstractInternalContentAssistP | |||
7848 | } | 7160 | } |
7849 | break; | 7161 | break; |
7850 | case 6 : | 7162 | case 6 : |
7851 | // InternalSolverLanguage.g:2133:2: ( ( 'current' ) ) | 7163 | // InternalSolverLanguageParser.g:2212:2: ( ( Current ) ) |
7852 | { | 7164 | { |
7853 | // InternalSolverLanguage.g:2133:2: ( ( 'current' ) ) | 7165 | // InternalSolverLanguageParser.g:2212:2: ( ( Current ) ) |
7854 | // InternalSolverLanguage.g:2134:3: ( 'current' ) | 7166 | // InternalSolverLanguageParser.g:2213:3: ( Current ) |
7855 | { | 7167 | { |
7856 | if ( state.backtracking==0 ) { | 7168 | before(grammarAccess.getUnaryOpAccess().getCURRENTEnumLiteralDeclaration_5()); |
7857 | before(grammarAccess.getUnaryOpAccess().getCURRENTEnumLiteralDeclaration_5()); | 7169 | // InternalSolverLanguageParser.g:2214:3: ( Current ) |
7858 | } | 7170 | // InternalSolverLanguageParser.g:2214:4: Current |
7859 | // InternalSolverLanguage.g:2135:3: ( 'current' ) | ||
7860 | // InternalSolverLanguage.g:2135:4: 'current' | ||
7861 | { | 7171 | { |
7862 | match(input,32,FOLLOW_2); if (state.failed) return ; | 7172 | match(input,Current,FOLLOW_2); |
7863 | 7173 | ||
7864 | } | 7174 | } |
7865 | 7175 | ||
7866 | if ( state.backtracking==0 ) { | 7176 | after(grammarAccess.getUnaryOpAccess().getCURRENTEnumLiteralDeclaration_5()); |
7867 | after(grammarAccess.getUnaryOpAccess().getCURRENTEnumLiteralDeclaration_5()); | ||
7868 | } | ||
7869 | 7177 | ||
7870 | } | 7178 | } |
7871 | 7179 | ||
@@ -7890,47 +7198,46 @@ public class InternalSolverLanguageParser extends AbstractInternalContentAssistP | |||
7890 | 7198 | ||
7891 | 7199 | ||
7892 | // $ANTLR start "rule__AggregationOp__Alternatives" | 7200 | // $ANTLR start "rule__AggregationOp__Alternatives" |
7893 | // InternalSolverLanguage.g:2143:1: rule__AggregationOp__Alternatives : ( ( ( 'only' ) ) | ( ( 'sum' ) ) | ( ( 'prod' ) ) | ( ( 'avg' ) ) | ( ( 'min' ) ) | ( ( 'max' ) ) ); | 7201 | // InternalSolverLanguageParser.g:2222:1: rule__AggregationOp__Alternatives : ( ( ( Only ) ) | ( ( Sum ) ) | ( ( Prod ) ) | ( ( Avg ) ) | ( ( Min ) ) | ( ( Max ) ) ); |
7894 | public final void rule__AggregationOp__Alternatives() throws RecognitionException { | 7202 | public final void rule__AggregationOp__Alternatives() throws RecognitionException { |
7895 | 7203 | ||
7896 | int stackSize = keepStackSize(); | 7204 | int stackSize = keepStackSize(); |
7897 | 7205 | ||
7898 | try { | 7206 | try { |
7899 | // InternalSolverLanguage.g:2147:1: ( ( ( 'only' ) ) | ( ( 'sum' ) ) | ( ( 'prod' ) ) | ( ( 'avg' ) ) | ( ( 'min' ) ) | ( ( 'max' ) ) ) | 7207 | // InternalSolverLanguageParser.g:2226:1: ( ( ( Only ) ) | ( ( Sum ) ) | ( ( Prod ) ) | ( ( Avg ) ) | ( ( Min ) ) | ( ( Max ) ) ) |
7900 | int alt24=6; | 7208 | int alt24=6; |
7901 | switch ( input.LA(1) ) { | 7209 | switch ( input.LA(1) ) { |
7902 | case 33: | 7210 | case Only: |
7903 | { | 7211 | { |
7904 | alt24=1; | 7212 | alt24=1; |
7905 | } | 7213 | } |
7906 | break; | 7214 | break; |
7907 | case 34: | 7215 | case Sum: |
7908 | { | 7216 | { |
7909 | alt24=2; | 7217 | alt24=2; |
7910 | } | 7218 | } |
7911 | break; | 7219 | break; |
7912 | case 35: | 7220 | case Prod: |
7913 | { | 7221 | { |
7914 | alt24=3; | 7222 | alt24=3; |
7915 | } | 7223 | } |
7916 | break; | 7224 | break; |
7917 | case 36: | 7225 | case Avg: |
7918 | { | 7226 | { |
7919 | alt24=4; | 7227 | alt24=4; |
7920 | } | 7228 | } |
7921 | break; | 7229 | break; |
7922 | case 37: | 7230 | case Min: |
7923 | { | 7231 | { |
7924 | alt24=5; | 7232 | alt24=5; |
7925 | } | 7233 | } |
7926 | break; | 7234 | break; |
7927 | case 38: | 7235 | case Max: |
7928 | { | 7236 | { |
7929 | alt24=6; | 7237 | alt24=6; |
7930 | } | 7238 | } |
7931 | break; | 7239 | break; |
7932 | default: | 7240 | default: |
7933 | if (state.backtracking>0) {state.failed=true; return ;} | ||
7934 | NoViableAltException nvae = | 7241 | NoViableAltException nvae = |
7935 | new NoViableAltException("", 24, 0, input); | 7242 | new NoViableAltException("", 24, 0, input); |
7936 | 7243 | ||
@@ -7939,24 +7246,20 @@ public class InternalSolverLanguageParser extends AbstractInternalContentAssistP | |||
7939 | 7246 | ||
7940 | switch (alt24) { | 7247 | switch (alt24) { |
7941 | case 1 : | 7248 | case 1 : |
7942 | // InternalSolverLanguage.g:2148:2: ( ( 'only' ) ) | 7249 | // InternalSolverLanguageParser.g:2227:2: ( ( Only ) ) |
7943 | { | 7250 | { |
7944 | // InternalSolverLanguage.g:2148:2: ( ( 'only' ) ) | 7251 | // InternalSolverLanguageParser.g:2227:2: ( ( Only ) ) |
7945 | // InternalSolverLanguage.g:2149:3: ( 'only' ) | 7252 | // InternalSolverLanguageParser.g:2228:3: ( Only ) |
7946 | { | 7253 | { |
7947 | if ( state.backtracking==0 ) { | 7254 | before(grammarAccess.getAggregationOpAccess().getONLYEnumLiteralDeclaration_0()); |
7948 | before(grammarAccess.getAggregationOpAccess().getONLYEnumLiteralDeclaration_0()); | 7255 | // InternalSolverLanguageParser.g:2229:3: ( Only ) |
7949 | } | 7256 | // InternalSolverLanguageParser.g:2229:4: Only |
7950 | // InternalSolverLanguage.g:2150:3: ( 'only' ) | ||
7951 | // InternalSolverLanguage.g:2150:4: 'only' | ||
7952 | { | 7257 | { |
7953 | match(input,33,FOLLOW_2); if (state.failed) return ; | 7258 | match(input,Only,FOLLOW_2); |
7954 | 7259 | ||
7955 | } | 7260 | } |
7956 | 7261 | ||
7957 | if ( state.backtracking==0 ) { | 7262 | after(grammarAccess.getAggregationOpAccess().getONLYEnumLiteralDeclaration_0()); |
7958 | after(grammarAccess.getAggregationOpAccess().getONLYEnumLiteralDeclaration_0()); | ||
7959 | } | ||
7960 | 7263 | ||
7961 | } | 7264 | } |
7962 | 7265 | ||
@@ -7964,24 +7267,20 @@ public class InternalSolverLanguageParser extends AbstractInternalContentAssistP | |||
7964 | } | 7267 | } |
7965 | break; | 7268 | break; |
7966 | case 2 : | 7269 | case 2 : |
7967 | // InternalSolverLanguage.g:2154:2: ( ( 'sum' ) ) | 7270 | // InternalSolverLanguageParser.g:2233:2: ( ( Sum ) ) |
7968 | { | 7271 | { |
7969 | // InternalSolverLanguage.g:2154:2: ( ( 'sum' ) ) | 7272 | // InternalSolverLanguageParser.g:2233:2: ( ( Sum ) ) |
7970 | // InternalSolverLanguage.g:2155:3: ( 'sum' ) | 7273 | // InternalSolverLanguageParser.g:2234:3: ( Sum ) |
7971 | { | 7274 | { |
7972 | if ( state.backtracking==0 ) { | 7275 | before(grammarAccess.getAggregationOpAccess().getSUMEnumLiteralDeclaration_1()); |
7973 | before(grammarAccess.getAggregationOpAccess().getSUMEnumLiteralDeclaration_1()); | 7276 | // InternalSolverLanguageParser.g:2235:3: ( Sum ) |
7974 | } | 7277 | // InternalSolverLanguageParser.g:2235:4: Sum |
7975 | // InternalSolverLanguage.g:2156:3: ( 'sum' ) | ||
7976 | // InternalSolverLanguage.g:2156:4: 'sum' | ||
7977 | { | 7278 | { |
7978 | match(input,34,FOLLOW_2); if (state.failed) return ; | 7279 | match(input,Sum,FOLLOW_2); |
7979 | 7280 | ||
7980 | } | 7281 | } |
7981 | 7282 | ||
7982 | if ( state.backtracking==0 ) { | 7283 | after(grammarAccess.getAggregationOpAccess().getSUMEnumLiteralDeclaration_1()); |
7983 | after(grammarAccess.getAggregationOpAccess().getSUMEnumLiteralDeclaration_1()); | ||
7984 | } | ||
7985 | 7284 | ||
7986 | } | 7285 | } |
7987 | 7286 | ||
@@ -7989,24 +7288,20 @@ public class InternalSolverLanguageParser extends AbstractInternalContentAssistP | |||
7989 | } | 7288 | } |
7990 | break; | 7289 | break; |
7991 | case 3 : | 7290 | case 3 : |
7992 | // InternalSolverLanguage.g:2160:2: ( ( 'prod' ) ) | 7291 | // InternalSolverLanguageParser.g:2239:2: ( ( Prod ) ) |
7993 | { | 7292 | { |
7994 | // InternalSolverLanguage.g:2160:2: ( ( 'prod' ) ) | 7293 | // InternalSolverLanguageParser.g:2239:2: ( ( Prod ) ) |
7995 | // InternalSolverLanguage.g:2161:3: ( 'prod' ) | 7294 | // InternalSolverLanguageParser.g:2240:3: ( Prod ) |
7996 | { | 7295 | { |
7997 | if ( state.backtracking==0 ) { | 7296 | before(grammarAccess.getAggregationOpAccess().getPRODEnumLiteralDeclaration_2()); |
7998 | before(grammarAccess.getAggregationOpAccess().getPRODEnumLiteralDeclaration_2()); | 7297 | // InternalSolverLanguageParser.g:2241:3: ( Prod ) |
7999 | } | 7298 | // InternalSolverLanguageParser.g:2241:4: Prod |
8000 | // InternalSolverLanguage.g:2162:3: ( 'prod' ) | ||
8001 | // InternalSolverLanguage.g:2162:4: 'prod' | ||
8002 | { | 7299 | { |
8003 | match(input,35,FOLLOW_2); if (state.failed) return ; | 7300 | match(input,Prod,FOLLOW_2); |
8004 | 7301 | ||
8005 | } | 7302 | } |
8006 | 7303 | ||
8007 | if ( state.backtracking==0 ) { | 7304 | after(grammarAccess.getAggregationOpAccess().getPRODEnumLiteralDeclaration_2()); |
8008 | after(grammarAccess.getAggregationOpAccess().getPRODEnumLiteralDeclaration_2()); | ||
8009 | } | ||
8010 | 7305 | ||
8011 | } | 7306 | } |
8012 | 7307 | ||
@@ -8014,24 +7309,20 @@ public class InternalSolverLanguageParser extends AbstractInternalContentAssistP | |||
8014 | } | 7309 | } |
8015 | break; | 7310 | break; |
8016 | case 4 : | 7311 | case 4 : |
8017 | // InternalSolverLanguage.g:2166:2: ( ( 'avg' ) ) | 7312 | // InternalSolverLanguageParser.g:2245:2: ( ( Avg ) ) |
8018 | { | 7313 | { |
8019 | // InternalSolverLanguage.g:2166:2: ( ( 'avg' ) ) | 7314 | // InternalSolverLanguageParser.g:2245:2: ( ( Avg ) ) |
8020 | // InternalSolverLanguage.g:2167:3: ( 'avg' ) | 7315 | // InternalSolverLanguageParser.g:2246:3: ( Avg ) |
8021 | { | 7316 | { |
8022 | if ( state.backtracking==0 ) { | 7317 | before(grammarAccess.getAggregationOpAccess().getAVGEnumLiteralDeclaration_3()); |
8023 | before(grammarAccess.getAggregationOpAccess().getAVGEnumLiteralDeclaration_3()); | 7318 | // InternalSolverLanguageParser.g:2247:3: ( Avg ) |
8024 | } | 7319 | // InternalSolverLanguageParser.g:2247:4: Avg |
8025 | // InternalSolverLanguage.g:2168:3: ( 'avg' ) | ||
8026 | // InternalSolverLanguage.g:2168:4: 'avg' | ||
8027 | { | 7320 | { |
8028 | match(input,36,FOLLOW_2); if (state.failed) return ; | 7321 | match(input,Avg,FOLLOW_2); |
8029 | 7322 | ||
8030 | } | 7323 | } |
8031 | 7324 | ||
8032 | if ( state.backtracking==0 ) { | 7325 | after(grammarAccess.getAggregationOpAccess().getAVGEnumLiteralDeclaration_3()); |
8033 | after(grammarAccess.getAggregationOpAccess().getAVGEnumLiteralDeclaration_3()); | ||
8034 | } | ||
8035 | 7326 | ||
8036 | } | 7327 | } |
8037 | 7328 | ||
@@ -8039,24 +7330,20 @@ public class InternalSolverLanguageParser extends AbstractInternalContentAssistP | |||
8039 | } | 7330 | } |
8040 | break; | 7331 | break; |
8041 | case 5 : | 7332 | case 5 : |
8042 | // InternalSolverLanguage.g:2172:2: ( ( 'min' ) ) | 7333 | // InternalSolverLanguageParser.g:2251:2: ( ( Min ) ) |
8043 | { | 7334 | { |
8044 | // InternalSolverLanguage.g:2172:2: ( ( 'min' ) ) | 7335 | // InternalSolverLanguageParser.g:2251:2: ( ( Min ) ) |
8045 | // InternalSolverLanguage.g:2173:3: ( 'min' ) | 7336 | // InternalSolverLanguageParser.g:2252:3: ( Min ) |
8046 | { | 7337 | { |
8047 | if ( state.backtracking==0 ) { | 7338 | before(grammarAccess.getAggregationOpAccess().getMINEnumLiteralDeclaration_4()); |
8048 | before(grammarAccess.getAggregationOpAccess().getMINEnumLiteralDeclaration_4()); | 7339 | // InternalSolverLanguageParser.g:2253:3: ( Min ) |
8049 | } | 7340 | // InternalSolverLanguageParser.g:2253:4: Min |
8050 | // InternalSolverLanguage.g:2174:3: ( 'min' ) | ||
8051 | // InternalSolverLanguage.g:2174:4: 'min' | ||
8052 | { | 7341 | { |
8053 | match(input,37,FOLLOW_2); if (state.failed) return ; | 7342 | match(input,Min,FOLLOW_2); |
8054 | 7343 | ||
8055 | } | 7344 | } |
8056 | 7345 | ||
8057 | if ( state.backtracking==0 ) { | 7346 | after(grammarAccess.getAggregationOpAccess().getMINEnumLiteralDeclaration_4()); |
8058 | after(grammarAccess.getAggregationOpAccess().getMINEnumLiteralDeclaration_4()); | ||
8059 | } | ||
8060 | 7347 | ||
8061 | } | 7348 | } |
8062 | 7349 | ||
@@ -8064,24 +7351,20 @@ public class InternalSolverLanguageParser extends AbstractInternalContentAssistP | |||
8064 | } | 7351 | } |
8065 | break; | 7352 | break; |
8066 | case 6 : | 7353 | case 6 : |
8067 | // InternalSolverLanguage.g:2178:2: ( ( 'max' ) ) | 7354 | // InternalSolverLanguageParser.g:2257:2: ( ( Max ) ) |
8068 | { | 7355 | { |
8069 | // InternalSolverLanguage.g:2178:2: ( ( 'max' ) ) | 7356 | // InternalSolverLanguageParser.g:2257:2: ( ( Max ) ) |
8070 | // InternalSolverLanguage.g:2179:3: ( 'max' ) | 7357 | // InternalSolverLanguageParser.g:2258:3: ( Max ) |
8071 | { | 7358 | { |
8072 | if ( state.backtracking==0 ) { | 7359 | before(grammarAccess.getAggregationOpAccess().getMAXEnumLiteralDeclaration_5()); |
8073 | before(grammarAccess.getAggregationOpAccess().getMAXEnumLiteralDeclaration_5()); | 7360 | // InternalSolverLanguageParser.g:2259:3: ( Max ) |
8074 | } | 7361 | // InternalSolverLanguageParser.g:2259:4: Max |
8075 | // InternalSolverLanguage.g:2180:3: ( 'max' ) | ||
8076 | // InternalSolverLanguage.g:2180:4: 'max' | ||
8077 | { | 7362 | { |
8078 | match(input,38,FOLLOW_2); if (state.failed) return ; | 7363 | match(input,Max,FOLLOW_2); |
8079 | 7364 | ||
8080 | } | 7365 | } |
8081 | 7366 | ||
8082 | if ( state.backtracking==0 ) { | 7367 | after(grammarAccess.getAggregationOpAccess().getMAXEnumLiteralDeclaration_5()); |
8083 | after(grammarAccess.getAggregationOpAccess().getMAXEnumLiteralDeclaration_5()); | ||
8084 | } | ||
8085 | 7368 | ||
8086 | } | 7369 | } |
8087 | 7370 | ||
@@ -8106,37 +7389,36 @@ public class InternalSolverLanguageParser extends AbstractInternalContentAssistP | |||
8106 | 7389 | ||
8107 | 7390 | ||
8108 | // $ANTLR start "rule__LogicValue__Alternatives" | 7391 | // $ANTLR start "rule__LogicValue__Alternatives" |
8109 | // InternalSolverLanguage.g:2188:1: rule__LogicValue__Alternatives : ( ( ( 'true' ) ) | ( ( 'false' ) ) | ( ( 'unknown' ) ) | ( ( 'error' ) ) ); | 7392 | // InternalSolverLanguageParser.g:2267:1: rule__LogicValue__Alternatives : ( ( ( True ) ) | ( ( False ) ) | ( ( Unknown ) ) | ( ( Error ) ) ); |
8110 | public final void rule__LogicValue__Alternatives() throws RecognitionException { | 7393 | public final void rule__LogicValue__Alternatives() throws RecognitionException { |
8111 | 7394 | ||
8112 | int stackSize = keepStackSize(); | 7395 | int stackSize = keepStackSize(); |
8113 | 7396 | ||
8114 | try { | 7397 | try { |
8115 | // InternalSolverLanguage.g:2192:1: ( ( ( 'true' ) ) | ( ( 'false' ) ) | ( ( 'unknown' ) ) | ( ( 'error' ) ) ) | 7398 | // InternalSolverLanguageParser.g:2271:1: ( ( ( True ) ) | ( ( False ) ) | ( ( Unknown ) ) | ( ( Error ) ) ) |
8116 | int alt25=4; | 7399 | int alt25=4; |
8117 | switch ( input.LA(1) ) { | 7400 | switch ( input.LA(1) ) { |
8118 | case 39: | 7401 | case True: |
8119 | { | 7402 | { |
8120 | alt25=1; | 7403 | alt25=1; |
8121 | } | 7404 | } |
8122 | break; | 7405 | break; |
8123 | case 40: | 7406 | case False: |
8124 | { | 7407 | { |
8125 | alt25=2; | 7408 | alt25=2; |
8126 | } | 7409 | } |
8127 | break; | 7410 | break; |
8128 | case 41: | 7411 | case Unknown: |
8129 | { | 7412 | { |
8130 | alt25=3; | 7413 | alt25=3; |
8131 | } | 7414 | } |
8132 | break; | 7415 | break; |
8133 | case 42: | 7416 | case Error: |
8134 | { | 7417 | { |
8135 | alt25=4; | 7418 | alt25=4; |
8136 | } | 7419 | } |
8137 | break; | 7420 | break; |
8138 | default: | 7421 | default: |
8139 | if (state.backtracking>0) {state.failed=true; return ;} | ||
8140 | NoViableAltException nvae = | 7422 | NoViableAltException nvae = |
8141 | new NoViableAltException("", 25, 0, input); | 7423 | new NoViableAltException("", 25, 0, input); |
8142 | 7424 | ||
@@ -8145,24 +7427,20 @@ public class InternalSolverLanguageParser extends AbstractInternalContentAssistP | |||
8145 | 7427 | ||
8146 | switch (alt25) { | 7428 | switch (alt25) { |
8147 | case 1 : | 7429 | case 1 : |
8148 | // InternalSolverLanguage.g:2193:2: ( ( 'true' ) ) | 7430 | // InternalSolverLanguageParser.g:2272:2: ( ( True ) ) |
8149 | { | 7431 | { |
8150 | // InternalSolverLanguage.g:2193:2: ( ( 'true' ) ) | 7432 | // InternalSolverLanguageParser.g:2272:2: ( ( True ) ) |
8151 | // InternalSolverLanguage.g:2194:3: ( 'true' ) | 7433 | // InternalSolverLanguageParser.g:2273:3: ( True ) |
8152 | { | 7434 | { |
8153 | if ( state.backtracking==0 ) { | 7435 | before(grammarAccess.getLogicValueAccess().getTRUEEnumLiteralDeclaration_0()); |
8154 | before(grammarAccess.getLogicValueAccess().getTRUEEnumLiteralDeclaration_0()); | 7436 | // InternalSolverLanguageParser.g:2274:3: ( True ) |
8155 | } | 7437 | // InternalSolverLanguageParser.g:2274:4: True |
8156 | // InternalSolverLanguage.g:2195:3: ( 'true' ) | ||
8157 | // InternalSolverLanguage.g:2195:4: 'true' | ||
8158 | { | 7438 | { |
8159 | match(input,39,FOLLOW_2); if (state.failed) return ; | 7439 | match(input,True,FOLLOW_2); |
8160 | 7440 | ||
8161 | } | 7441 | } |
8162 | 7442 | ||
8163 | if ( state.backtracking==0 ) { | 7443 | after(grammarAccess.getLogicValueAccess().getTRUEEnumLiteralDeclaration_0()); |
8164 | after(grammarAccess.getLogicValueAccess().getTRUEEnumLiteralDeclaration_0()); | ||
8165 | } | ||
8166 | 7444 | ||
8167 | } | 7445 | } |
8168 | 7446 | ||
@@ -8170,24 +7448,20 @@ public class InternalSolverLanguageParser extends AbstractInternalContentAssistP | |||
8170 | } | 7448 | } |
8171 | break; | 7449 | break; |
8172 | case 2 : | 7450 | case 2 : |
8173 | // InternalSolverLanguage.g:2199:2: ( ( 'false' ) ) | 7451 | // InternalSolverLanguageParser.g:2278:2: ( ( False ) ) |
8174 | { | 7452 | { |
8175 | // InternalSolverLanguage.g:2199:2: ( ( 'false' ) ) | 7453 | // InternalSolverLanguageParser.g:2278:2: ( ( False ) ) |
8176 | // InternalSolverLanguage.g:2200:3: ( 'false' ) | 7454 | // InternalSolverLanguageParser.g:2279:3: ( False ) |
8177 | { | 7455 | { |
8178 | if ( state.backtracking==0 ) { | 7456 | before(grammarAccess.getLogicValueAccess().getFALSEEnumLiteralDeclaration_1()); |
8179 | before(grammarAccess.getLogicValueAccess().getFALSEEnumLiteralDeclaration_1()); | 7457 | // InternalSolverLanguageParser.g:2280:3: ( False ) |
8180 | } | 7458 | // InternalSolverLanguageParser.g:2280:4: False |
8181 | // InternalSolverLanguage.g:2201:3: ( 'false' ) | ||
8182 | // InternalSolverLanguage.g:2201:4: 'false' | ||
8183 | { | 7459 | { |
8184 | match(input,40,FOLLOW_2); if (state.failed) return ; | 7460 | match(input,False,FOLLOW_2); |
8185 | 7461 | ||
8186 | } | 7462 | } |
8187 | 7463 | ||
8188 | if ( state.backtracking==0 ) { | 7464 | after(grammarAccess.getLogicValueAccess().getFALSEEnumLiteralDeclaration_1()); |
8189 | after(grammarAccess.getLogicValueAccess().getFALSEEnumLiteralDeclaration_1()); | ||
8190 | } | ||
8191 | 7465 | ||
8192 | } | 7466 | } |
8193 | 7467 | ||
@@ -8195,24 +7469,20 @@ public class InternalSolverLanguageParser extends AbstractInternalContentAssistP | |||
8195 | } | 7469 | } |
8196 | break; | 7470 | break; |
8197 | case 3 : | 7471 | case 3 : |
8198 | // InternalSolverLanguage.g:2205:2: ( ( 'unknown' ) ) | 7472 | // InternalSolverLanguageParser.g:2284:2: ( ( Unknown ) ) |
8199 | { | 7473 | { |
8200 | // InternalSolverLanguage.g:2205:2: ( ( 'unknown' ) ) | 7474 | // InternalSolverLanguageParser.g:2284:2: ( ( Unknown ) ) |
8201 | // InternalSolverLanguage.g:2206:3: ( 'unknown' ) | 7475 | // InternalSolverLanguageParser.g:2285:3: ( Unknown ) |
8202 | { | 7476 | { |
8203 | if ( state.backtracking==0 ) { | 7477 | before(grammarAccess.getLogicValueAccess().getUNKNOWNEnumLiteralDeclaration_2()); |
8204 | before(grammarAccess.getLogicValueAccess().getUNKNOWNEnumLiteralDeclaration_2()); | 7478 | // InternalSolverLanguageParser.g:2286:3: ( Unknown ) |
8205 | } | 7479 | // InternalSolverLanguageParser.g:2286:4: Unknown |
8206 | // InternalSolverLanguage.g:2207:3: ( 'unknown' ) | ||
8207 | // InternalSolverLanguage.g:2207:4: 'unknown' | ||
8208 | { | 7480 | { |
8209 | match(input,41,FOLLOW_2); if (state.failed) return ; | 7481 | match(input,Unknown,FOLLOW_2); |
8210 | 7482 | ||
8211 | } | 7483 | } |
8212 | 7484 | ||
8213 | if ( state.backtracking==0 ) { | 7485 | after(grammarAccess.getLogicValueAccess().getUNKNOWNEnumLiteralDeclaration_2()); |
8214 | after(grammarAccess.getLogicValueAccess().getUNKNOWNEnumLiteralDeclaration_2()); | ||
8215 | } | ||
8216 | 7486 | ||
8217 | } | 7487 | } |
8218 | 7488 | ||
@@ -8220,24 +7490,20 @@ public class InternalSolverLanguageParser extends AbstractInternalContentAssistP | |||
8220 | } | 7490 | } |
8221 | break; | 7491 | break; |
8222 | case 4 : | 7492 | case 4 : |
8223 | // InternalSolverLanguage.g:2211:2: ( ( 'error' ) ) | 7493 | // InternalSolverLanguageParser.g:2290:2: ( ( Error ) ) |
8224 | { | 7494 | { |
8225 | // InternalSolverLanguage.g:2211:2: ( ( 'error' ) ) | 7495 | // InternalSolverLanguageParser.g:2290:2: ( ( Error ) ) |
8226 | // InternalSolverLanguage.g:2212:3: ( 'error' ) | 7496 | // InternalSolverLanguageParser.g:2291:3: ( Error ) |
8227 | { | 7497 | { |
8228 | if ( state.backtracking==0 ) { | 7498 | before(grammarAccess.getLogicValueAccess().getERROREnumLiteralDeclaration_3()); |
8229 | before(grammarAccess.getLogicValueAccess().getERROREnumLiteralDeclaration_3()); | 7499 | // InternalSolverLanguageParser.g:2292:3: ( Error ) |
8230 | } | 7500 | // InternalSolverLanguageParser.g:2292:4: Error |
8231 | // InternalSolverLanguage.g:2213:3: ( 'error' ) | ||
8232 | // InternalSolverLanguage.g:2213:4: 'error' | ||
8233 | { | 7501 | { |
8234 | match(input,42,FOLLOW_2); if (state.failed) return ; | 7502 | match(input,Error,FOLLOW_2); |
8235 | 7503 | ||
8236 | } | 7504 | } |
8237 | 7505 | ||
8238 | if ( state.backtracking==0 ) { | 7506 | after(grammarAccess.getLogicValueAccess().getERROREnumLiteralDeclaration_3()); |
8239 | after(grammarAccess.getLogicValueAccess().getERROREnumLiteralDeclaration_3()); | ||
8240 | } | ||
8241 | 7507 | ||
8242 | } | 7508 | } |
8243 | 7509 | ||
@@ -8262,24 +7528,23 @@ public class InternalSolverLanguageParser extends AbstractInternalContentAssistP | |||
8262 | 7528 | ||
8263 | 7529 | ||
8264 | // $ANTLR start "rule__ObjectiveKind__Alternatives" | 7530 | // $ANTLR start "rule__ObjectiveKind__Alternatives" |
8265 | // InternalSolverLanguage.g:2221:1: rule__ObjectiveKind__Alternatives : ( ( ( 'minimize' ) ) | ( ( 'maximize' ) ) ); | 7531 | // InternalSolverLanguageParser.g:2300:1: rule__ObjectiveKind__Alternatives : ( ( ( Minimize ) ) | ( ( Maximize ) ) ); |
8266 | public final void rule__ObjectiveKind__Alternatives() throws RecognitionException { | 7532 | public final void rule__ObjectiveKind__Alternatives() throws RecognitionException { |
8267 | 7533 | ||
8268 | int stackSize = keepStackSize(); | 7534 | int stackSize = keepStackSize(); |
8269 | 7535 | ||
8270 | try { | 7536 | try { |
8271 | // InternalSolverLanguage.g:2225:1: ( ( ( 'minimize' ) ) | ( ( 'maximize' ) ) ) | 7537 | // InternalSolverLanguageParser.g:2304:1: ( ( ( Minimize ) ) | ( ( Maximize ) ) ) |
8272 | int alt26=2; | 7538 | int alt26=2; |
8273 | int LA26_0 = input.LA(1); | 7539 | int LA26_0 = input.LA(1); |
8274 | 7540 | ||
8275 | if ( (LA26_0==43) ) { | 7541 | if ( (LA26_0==Minimize) ) { |
8276 | alt26=1; | 7542 | alt26=1; |
8277 | } | 7543 | } |
8278 | else if ( (LA26_0==44) ) { | 7544 | else if ( (LA26_0==Maximize) ) { |
8279 | alt26=2; | 7545 | alt26=2; |
8280 | } | 7546 | } |
8281 | else { | 7547 | else { |
8282 | if (state.backtracking>0) {state.failed=true; return ;} | ||
8283 | NoViableAltException nvae = | 7548 | NoViableAltException nvae = |
8284 | new NoViableAltException("", 26, 0, input); | 7549 | new NoViableAltException("", 26, 0, input); |
8285 | 7550 | ||
@@ -8287,24 +7552,20 @@ public class InternalSolverLanguageParser extends AbstractInternalContentAssistP | |||
8287 | } | 7552 | } |
8288 | switch (alt26) { | 7553 | switch (alt26) { |
8289 | case 1 : | 7554 | case 1 : |
8290 | // InternalSolverLanguage.g:2226:2: ( ( 'minimize' ) ) | 7555 | // InternalSolverLanguageParser.g:2305:2: ( ( Minimize ) ) |
8291 | { | 7556 | { |
8292 | // InternalSolverLanguage.g:2226:2: ( ( 'minimize' ) ) | 7557 | // InternalSolverLanguageParser.g:2305:2: ( ( Minimize ) ) |
8293 | // InternalSolverLanguage.g:2227:3: ( 'minimize' ) | 7558 | // InternalSolverLanguageParser.g:2306:3: ( Minimize ) |
8294 | { | 7559 | { |
8295 | if ( state.backtracking==0 ) { | 7560 | before(grammarAccess.getObjectiveKindAccess().getMINIMIZEEnumLiteralDeclaration_0()); |
8296 | before(grammarAccess.getObjectiveKindAccess().getMINIMIZEEnumLiteralDeclaration_0()); | 7561 | // InternalSolverLanguageParser.g:2307:3: ( Minimize ) |
8297 | } | 7562 | // InternalSolverLanguageParser.g:2307:4: Minimize |
8298 | // InternalSolverLanguage.g:2228:3: ( 'minimize' ) | ||
8299 | // InternalSolverLanguage.g:2228:4: 'minimize' | ||
8300 | { | 7563 | { |
8301 | match(input,43,FOLLOW_2); if (state.failed) return ; | 7564 | match(input,Minimize,FOLLOW_2); |
8302 | 7565 | ||
8303 | } | 7566 | } |
8304 | 7567 | ||
8305 | if ( state.backtracking==0 ) { | 7568 | after(grammarAccess.getObjectiveKindAccess().getMINIMIZEEnumLiteralDeclaration_0()); |
8306 | after(grammarAccess.getObjectiveKindAccess().getMINIMIZEEnumLiteralDeclaration_0()); | ||
8307 | } | ||
8308 | 7569 | ||
8309 | } | 7570 | } |
8310 | 7571 | ||
@@ -8312,24 +7573,20 @@ public class InternalSolverLanguageParser extends AbstractInternalContentAssistP | |||
8312 | } | 7573 | } |
8313 | break; | 7574 | break; |
8314 | case 2 : | 7575 | case 2 : |
8315 | // InternalSolverLanguage.g:2232:2: ( ( 'maximize' ) ) | 7576 | // InternalSolverLanguageParser.g:2311:2: ( ( Maximize ) ) |
8316 | { | 7577 | { |
8317 | // InternalSolverLanguage.g:2232:2: ( ( 'maximize' ) ) | 7578 | // InternalSolverLanguageParser.g:2311:2: ( ( Maximize ) ) |
8318 | // InternalSolverLanguage.g:2233:3: ( 'maximize' ) | 7579 | // InternalSolverLanguageParser.g:2312:3: ( Maximize ) |
8319 | { | 7580 | { |
8320 | if ( state.backtracking==0 ) { | 7581 | before(grammarAccess.getObjectiveKindAccess().getMAXIMIZEEnumLiteralDeclaration_1()); |
8321 | before(grammarAccess.getObjectiveKindAccess().getMAXIMIZEEnumLiteralDeclaration_1()); | 7582 | // InternalSolverLanguageParser.g:2313:3: ( Maximize ) |
8322 | } | 7583 | // InternalSolverLanguageParser.g:2313:4: Maximize |
8323 | // InternalSolverLanguage.g:2234:3: ( 'maximize' ) | ||
8324 | // InternalSolverLanguage.g:2234:4: 'maximize' | ||
8325 | { | 7584 | { |
8326 | match(input,44,FOLLOW_2); if (state.failed) return ; | 7585 | match(input,Maximize,FOLLOW_2); |
8327 | 7586 | ||
8328 | } | 7587 | } |
8329 | 7588 | ||
8330 | if ( state.backtracking==0 ) { | 7589 | after(grammarAccess.getObjectiveKindAccess().getMAXIMIZEEnumLiteralDeclaration_1()); |
8331 | after(grammarAccess.getObjectiveKindAccess().getMAXIMIZEEnumLiteralDeclaration_1()); | ||
8332 | } | ||
8333 | 7590 | ||
8334 | } | 7591 | } |
8335 | 7592 | ||
@@ -8354,25 +7611,25 @@ public class InternalSolverLanguageParser extends AbstractInternalContentAssistP | |||
8354 | 7611 | ||
8355 | 7612 | ||
8356 | // $ANTLR start "rule__Statement__Group__0" | 7613 | // $ANTLR start "rule__Statement__Group__0" |
8357 | // InternalSolverLanguage.g:2242:1: rule__Statement__Group__0 : rule__Statement__Group__0__Impl rule__Statement__Group__1 ; | 7614 | // InternalSolverLanguageParser.g:2321:1: rule__Statement__Group__0 : rule__Statement__Group__0__Impl rule__Statement__Group__1 ; |
8358 | public final void rule__Statement__Group__0() throws RecognitionException { | 7615 | public final void rule__Statement__Group__0() throws RecognitionException { |
8359 | 7616 | ||
8360 | int stackSize = keepStackSize(); | 7617 | int stackSize = keepStackSize(); |
8361 | 7618 | ||
8362 | try { | 7619 | try { |
8363 | // InternalSolverLanguage.g:2246:1: ( rule__Statement__Group__0__Impl rule__Statement__Group__1 ) | 7620 | // InternalSolverLanguageParser.g:2325:1: ( rule__Statement__Group__0__Impl rule__Statement__Group__1 ) |
8364 | // InternalSolverLanguage.g:2247:2: rule__Statement__Group__0__Impl rule__Statement__Group__1 | 7621 | // InternalSolverLanguageParser.g:2326:2: rule__Statement__Group__0__Impl rule__Statement__Group__1 |
8365 | { | 7622 | { |
8366 | pushFollow(FOLLOW_4); | 7623 | pushFollow(FOLLOW_4); |
8367 | rule__Statement__Group__0__Impl(); | 7624 | rule__Statement__Group__0__Impl(); |
8368 | 7625 | ||
8369 | state._fsp--; | 7626 | state._fsp--; |
8370 | if (state.failed) return ; | 7627 | |
8371 | pushFollow(FOLLOW_2); | 7628 | pushFollow(FOLLOW_2); |
8372 | rule__Statement__Group__1(); | 7629 | rule__Statement__Group__1(); |
8373 | 7630 | ||
8374 | state._fsp--; | 7631 | state._fsp--; |
8375 | if (state.failed) return ; | 7632 | |
8376 | 7633 | ||
8377 | } | 7634 | } |
8378 | 7635 | ||
@@ -8392,36 +7649,32 @@ public class InternalSolverLanguageParser extends AbstractInternalContentAssistP | |||
8392 | 7649 | ||
8393 | 7650 | ||
8394 | // $ANTLR start "rule__Statement__Group__0__Impl" | 7651 | // $ANTLR start "rule__Statement__Group__0__Impl" |
8395 | // InternalSolverLanguage.g:2254:1: rule__Statement__Group__0__Impl : ( ( rule__Statement__Alternatives_0 ) ) ; | 7652 | // InternalSolverLanguageParser.g:2333:1: rule__Statement__Group__0__Impl : ( ( rule__Statement__Alternatives_0 ) ) ; |
8396 | public final void rule__Statement__Group__0__Impl() throws RecognitionException { | 7653 | public final void rule__Statement__Group__0__Impl() throws RecognitionException { |
8397 | 7654 | ||
8398 | int stackSize = keepStackSize(); | 7655 | int stackSize = keepStackSize(); |
8399 | 7656 | ||
8400 | try { | 7657 | try { |
8401 | // InternalSolverLanguage.g:2258:1: ( ( ( rule__Statement__Alternatives_0 ) ) ) | 7658 | // InternalSolverLanguageParser.g:2337:1: ( ( ( rule__Statement__Alternatives_0 ) ) ) |
8402 | // InternalSolverLanguage.g:2259:1: ( ( rule__Statement__Alternatives_0 ) ) | 7659 | // InternalSolverLanguageParser.g:2338:1: ( ( rule__Statement__Alternatives_0 ) ) |
8403 | { | 7660 | { |
8404 | // InternalSolverLanguage.g:2259:1: ( ( rule__Statement__Alternatives_0 ) ) | 7661 | // InternalSolverLanguageParser.g:2338:1: ( ( rule__Statement__Alternatives_0 ) ) |
8405 | // InternalSolverLanguage.g:2260:2: ( rule__Statement__Alternatives_0 ) | 7662 | // InternalSolverLanguageParser.g:2339:2: ( rule__Statement__Alternatives_0 ) |
8406 | { | 7663 | { |
8407 | if ( state.backtracking==0 ) { | 7664 | before(grammarAccess.getStatementAccess().getAlternatives_0()); |
8408 | before(grammarAccess.getStatementAccess().getAlternatives_0()); | 7665 | // InternalSolverLanguageParser.g:2340:2: ( rule__Statement__Alternatives_0 ) |
8409 | } | 7666 | // InternalSolverLanguageParser.g:2340:3: rule__Statement__Alternatives_0 |
8410 | // InternalSolverLanguage.g:2261:2: ( rule__Statement__Alternatives_0 ) | ||
8411 | // InternalSolverLanguage.g:2261:3: rule__Statement__Alternatives_0 | ||
8412 | { | 7667 | { |
8413 | pushFollow(FOLLOW_2); | 7668 | pushFollow(FOLLOW_2); |
8414 | rule__Statement__Alternatives_0(); | 7669 | rule__Statement__Alternatives_0(); |
8415 | 7670 | ||
8416 | state._fsp--; | 7671 | state._fsp--; |
8417 | if (state.failed) return ; | ||
8418 | 7672 | ||
8419 | } | ||
8420 | 7673 | ||
8421 | if ( state.backtracking==0 ) { | ||
8422 | after(grammarAccess.getStatementAccess().getAlternatives_0()); | ||
8423 | } | 7674 | } |
8424 | 7675 | ||
7676 | after(grammarAccess.getStatementAccess().getAlternatives_0()); | ||
7677 | |||
8425 | } | 7678 | } |
8426 | 7679 | ||
8427 | 7680 | ||
@@ -8443,20 +7696,20 @@ public class InternalSolverLanguageParser extends AbstractInternalContentAssistP | |||
8443 | 7696 | ||
8444 | 7697 | ||
8445 | // $ANTLR start "rule__Statement__Group__1" | 7698 | // $ANTLR start "rule__Statement__Group__1" |
8446 | // InternalSolverLanguage.g:2269:1: rule__Statement__Group__1 : rule__Statement__Group__1__Impl ; | 7699 | // InternalSolverLanguageParser.g:2348:1: rule__Statement__Group__1 : rule__Statement__Group__1__Impl ; |
8447 | public final void rule__Statement__Group__1() throws RecognitionException { | 7700 | public final void rule__Statement__Group__1() throws RecognitionException { |
8448 | 7701 | ||
8449 | int stackSize = keepStackSize(); | 7702 | int stackSize = keepStackSize(); |
8450 | 7703 | ||
8451 | try { | 7704 | try { |
8452 | // InternalSolverLanguage.g:2273:1: ( rule__Statement__Group__1__Impl ) | 7705 | // InternalSolverLanguageParser.g:2352:1: ( rule__Statement__Group__1__Impl ) |
8453 | // InternalSolverLanguage.g:2274:2: rule__Statement__Group__1__Impl | 7706 | // InternalSolverLanguageParser.g:2353:2: rule__Statement__Group__1__Impl |
8454 | { | 7707 | { |
8455 | pushFollow(FOLLOW_2); | 7708 | pushFollow(FOLLOW_2); |
8456 | rule__Statement__Group__1__Impl(); | 7709 | rule__Statement__Group__1__Impl(); |
8457 | 7710 | ||
8458 | state._fsp--; | 7711 | state._fsp--; |
8459 | if (state.failed) return ; | 7712 | |
8460 | 7713 | ||
8461 | } | 7714 | } |
8462 | 7715 | ||
@@ -8476,25 +7729,21 @@ public class InternalSolverLanguageParser extends AbstractInternalContentAssistP | |||
8476 | 7729 | ||
8477 | 7730 | ||
8478 | // $ANTLR start "rule__Statement__Group__1__Impl" | 7731 | // $ANTLR start "rule__Statement__Group__1__Impl" |
8479 | // InternalSolverLanguage.g:2280:1: rule__Statement__Group__1__Impl : ( RULE_DOT ) ; | 7732 | // InternalSolverLanguageParser.g:2359:1: rule__Statement__Group__1__Impl : ( RULE_FULL_STOP ) ; |
8480 | public final void rule__Statement__Group__1__Impl() throws RecognitionException { | 7733 | public final void rule__Statement__Group__1__Impl() throws RecognitionException { |
8481 | 7734 | ||
8482 | int stackSize = keepStackSize(); | 7735 | int stackSize = keepStackSize(); |
8483 | 7736 | ||
8484 | try { | 7737 | try { |
8485 | // InternalSolverLanguage.g:2284:1: ( ( RULE_DOT ) ) | 7738 | // InternalSolverLanguageParser.g:2363:1: ( ( RULE_FULL_STOP ) ) |
8486 | // InternalSolverLanguage.g:2285:1: ( RULE_DOT ) | 7739 | // InternalSolverLanguageParser.g:2364:1: ( RULE_FULL_STOP ) |
8487 | { | 7740 | { |
8488 | // InternalSolverLanguage.g:2285:1: ( RULE_DOT ) | 7741 | // InternalSolverLanguageParser.g:2364:1: ( RULE_FULL_STOP ) |
8489 | // InternalSolverLanguage.g:2286:2: RULE_DOT | 7742 | // InternalSolverLanguageParser.g:2365:2: RULE_FULL_STOP |
8490 | { | 7743 | { |
8491 | if ( state.backtracking==0 ) { | 7744 | before(grammarAccess.getStatementAccess().getFULL_STOPTerminalRuleCall_1()); |
8492 | before(grammarAccess.getStatementAccess().getDOTTerminalRuleCall_1()); | 7745 | match(input,RULE_FULL_STOP,FOLLOW_2); |
8493 | } | 7746 | after(grammarAccess.getStatementAccess().getFULL_STOPTerminalRuleCall_1()); |
8494 | match(input,RULE_DOT,FOLLOW_2); if (state.failed) return ; | ||
8495 | if ( state.backtracking==0 ) { | ||
8496 | after(grammarAccess.getStatementAccess().getDOTTerminalRuleCall_1()); | ||
8497 | } | ||
8498 | 7747 | ||
8499 | } | 7748 | } |
8500 | 7749 | ||
@@ -8517,25 +7766,25 @@ public class InternalSolverLanguageParser extends AbstractInternalContentAssistP | |||
8517 | 7766 | ||
8518 | 7767 | ||
8519 | // $ANTLR start "rule__AssertionOrDefinition__Group__0" | 7768 | // $ANTLR start "rule__AssertionOrDefinition__Group__0" |
8520 | // InternalSolverLanguage.g:2296:1: rule__AssertionOrDefinition__Group__0 : rule__AssertionOrDefinition__Group__0__Impl rule__AssertionOrDefinition__Group__1 ; | 7769 | // InternalSolverLanguageParser.g:2375:1: rule__AssertionOrDefinition__Group__0 : rule__AssertionOrDefinition__Group__0__Impl rule__AssertionOrDefinition__Group__1 ; |
8521 | public final void rule__AssertionOrDefinition__Group__0() throws RecognitionException { | 7770 | public final void rule__AssertionOrDefinition__Group__0() throws RecognitionException { |
8522 | 7771 | ||
8523 | int stackSize = keepStackSize(); | 7772 | int stackSize = keepStackSize(); |
8524 | 7773 | ||
8525 | try { | 7774 | try { |
8526 | // InternalSolverLanguage.g:2300:1: ( rule__AssertionOrDefinition__Group__0__Impl rule__AssertionOrDefinition__Group__1 ) | 7775 | // InternalSolverLanguageParser.g:2379:1: ( rule__AssertionOrDefinition__Group__0__Impl rule__AssertionOrDefinition__Group__1 ) |
8527 | // InternalSolverLanguage.g:2301:2: rule__AssertionOrDefinition__Group__0__Impl rule__AssertionOrDefinition__Group__1 | 7776 | // InternalSolverLanguageParser.g:2380:2: rule__AssertionOrDefinition__Group__0__Impl rule__AssertionOrDefinition__Group__1 |
8528 | { | 7777 | { |
8529 | pushFollow(FOLLOW_5); | 7778 | pushFollow(FOLLOW_5); |
8530 | rule__AssertionOrDefinition__Group__0__Impl(); | 7779 | rule__AssertionOrDefinition__Group__0__Impl(); |
8531 | 7780 | ||
8532 | state._fsp--; | 7781 | state._fsp--; |
8533 | if (state.failed) return ; | 7782 | |
8534 | pushFollow(FOLLOW_2); | 7783 | pushFollow(FOLLOW_2); |
8535 | rule__AssertionOrDefinition__Group__1(); | 7784 | rule__AssertionOrDefinition__Group__1(); |
8536 | 7785 | ||
8537 | state._fsp--; | 7786 | state._fsp--; |
8538 | if (state.failed) return ; | 7787 | |
8539 | 7788 | ||
8540 | } | 7789 | } |
8541 | 7790 | ||
@@ -8555,29 +7804,25 @@ public class InternalSolverLanguageParser extends AbstractInternalContentAssistP | |||
8555 | 7804 | ||
8556 | 7805 | ||
8557 | // $ANTLR start "rule__AssertionOrDefinition__Group__0__Impl" | 7806 | // $ANTLR start "rule__AssertionOrDefinition__Group__0__Impl" |
8558 | // InternalSolverLanguage.g:2308:1: rule__AssertionOrDefinition__Group__0__Impl : ( ruleExpression ) ; | 7807 | // InternalSolverLanguageParser.g:2387:1: rule__AssertionOrDefinition__Group__0__Impl : ( ruleExpression ) ; |
8559 | public final void rule__AssertionOrDefinition__Group__0__Impl() throws RecognitionException { | 7808 | public final void rule__AssertionOrDefinition__Group__0__Impl() throws RecognitionException { |
8560 | 7809 | ||
8561 | int stackSize = keepStackSize(); | 7810 | int stackSize = keepStackSize(); |
8562 | 7811 | ||
8563 | try { | 7812 | try { |
8564 | // InternalSolverLanguage.g:2312:1: ( ( ruleExpression ) ) | 7813 | // InternalSolverLanguageParser.g:2391:1: ( ( ruleExpression ) ) |
8565 | // InternalSolverLanguage.g:2313:1: ( ruleExpression ) | 7814 | // InternalSolverLanguageParser.g:2392:1: ( ruleExpression ) |
8566 | { | 7815 | { |
8567 | // InternalSolverLanguage.g:2313:1: ( ruleExpression ) | 7816 | // InternalSolverLanguageParser.g:2392:1: ( ruleExpression ) |
8568 | // InternalSolverLanguage.g:2314:2: ruleExpression | 7817 | // InternalSolverLanguageParser.g:2393:2: ruleExpression |
8569 | { | 7818 | { |
8570 | if ( state.backtracking==0 ) { | 7819 | before(grammarAccess.getAssertionOrDefinitionAccess().getExpressionParserRuleCall_0()); |
8571 | before(grammarAccess.getAssertionOrDefinitionAccess().getExpressionParserRuleCall_0()); | ||
8572 | } | ||
8573 | pushFollow(FOLLOW_2); | 7820 | pushFollow(FOLLOW_2); |
8574 | ruleExpression(); | 7821 | ruleExpression(); |
8575 | 7822 | ||
8576 | state._fsp--; | 7823 | state._fsp--; |
8577 | if (state.failed) return ; | 7824 | |
8578 | if ( state.backtracking==0 ) { | 7825 | after(grammarAccess.getAssertionOrDefinitionAccess().getExpressionParserRuleCall_0()); |
8579 | after(grammarAccess.getAssertionOrDefinitionAccess().getExpressionParserRuleCall_0()); | ||
8580 | } | ||
8581 | 7826 | ||
8582 | } | 7827 | } |
8583 | 7828 | ||
@@ -8600,20 +7845,20 @@ public class InternalSolverLanguageParser extends AbstractInternalContentAssistP | |||
8600 | 7845 | ||
8601 | 7846 | ||
8602 | // $ANTLR start "rule__AssertionOrDefinition__Group__1" | 7847 | // $ANTLR start "rule__AssertionOrDefinition__Group__1" |
8603 | // InternalSolverLanguage.g:2323:1: rule__AssertionOrDefinition__Group__1 : rule__AssertionOrDefinition__Group__1__Impl ; | 7848 | // InternalSolverLanguageParser.g:2402:1: rule__AssertionOrDefinition__Group__1 : rule__AssertionOrDefinition__Group__1__Impl ; |
8604 | public final void rule__AssertionOrDefinition__Group__1() throws RecognitionException { | 7849 | public final void rule__AssertionOrDefinition__Group__1() throws RecognitionException { |
8605 | 7850 | ||
8606 | int stackSize = keepStackSize(); | 7851 | int stackSize = keepStackSize(); |
8607 | 7852 | ||
8608 | try { | 7853 | try { |
8609 | // InternalSolverLanguage.g:2327:1: ( rule__AssertionOrDefinition__Group__1__Impl ) | 7854 | // InternalSolverLanguageParser.g:2406:1: ( rule__AssertionOrDefinition__Group__1__Impl ) |
8610 | // InternalSolverLanguage.g:2328:2: rule__AssertionOrDefinition__Group__1__Impl | 7855 | // InternalSolverLanguageParser.g:2407:2: rule__AssertionOrDefinition__Group__1__Impl |
8611 | { | 7856 | { |
8612 | pushFollow(FOLLOW_2); | 7857 | pushFollow(FOLLOW_2); |
8613 | rule__AssertionOrDefinition__Group__1__Impl(); | 7858 | rule__AssertionOrDefinition__Group__1__Impl(); |
8614 | 7859 | ||
8615 | state._fsp--; | 7860 | state._fsp--; |
8616 | if (state.failed) return ; | 7861 | |
8617 | 7862 | ||
8618 | } | 7863 | } |
8619 | 7864 | ||
@@ -8633,36 +7878,32 @@ public class InternalSolverLanguageParser extends AbstractInternalContentAssistP | |||
8633 | 7878 | ||
8634 | 7879 | ||
8635 | // $ANTLR start "rule__AssertionOrDefinition__Group__1__Impl" | 7880 | // $ANTLR start "rule__AssertionOrDefinition__Group__1__Impl" |
8636 | // InternalSolverLanguage.g:2334:1: rule__AssertionOrDefinition__Group__1__Impl : ( ( rule__AssertionOrDefinition__Alternatives_1 ) ) ; | 7881 | // InternalSolverLanguageParser.g:2413:1: rule__AssertionOrDefinition__Group__1__Impl : ( ( rule__AssertionOrDefinition__Alternatives_1 ) ) ; |
8637 | public final void rule__AssertionOrDefinition__Group__1__Impl() throws RecognitionException { | 7882 | public final void rule__AssertionOrDefinition__Group__1__Impl() throws RecognitionException { |
8638 | 7883 | ||
8639 | int stackSize = keepStackSize(); | 7884 | int stackSize = keepStackSize(); |
8640 | 7885 | ||
8641 | try { | 7886 | try { |
8642 | // InternalSolverLanguage.g:2338:1: ( ( ( rule__AssertionOrDefinition__Alternatives_1 ) ) ) | 7887 | // InternalSolverLanguageParser.g:2417:1: ( ( ( rule__AssertionOrDefinition__Alternatives_1 ) ) ) |
8643 | // InternalSolverLanguage.g:2339:1: ( ( rule__AssertionOrDefinition__Alternatives_1 ) ) | 7888 | // InternalSolverLanguageParser.g:2418:1: ( ( rule__AssertionOrDefinition__Alternatives_1 ) ) |
8644 | { | 7889 | { |
8645 | // InternalSolverLanguage.g:2339:1: ( ( rule__AssertionOrDefinition__Alternatives_1 ) ) | 7890 | // InternalSolverLanguageParser.g:2418:1: ( ( rule__AssertionOrDefinition__Alternatives_1 ) ) |
8646 | // InternalSolverLanguage.g:2340:2: ( rule__AssertionOrDefinition__Alternatives_1 ) | 7891 | // InternalSolverLanguageParser.g:2419:2: ( rule__AssertionOrDefinition__Alternatives_1 ) |
8647 | { | 7892 | { |
8648 | if ( state.backtracking==0 ) { | 7893 | before(grammarAccess.getAssertionOrDefinitionAccess().getAlternatives_1()); |
8649 | before(grammarAccess.getAssertionOrDefinitionAccess().getAlternatives_1()); | 7894 | // InternalSolverLanguageParser.g:2420:2: ( rule__AssertionOrDefinition__Alternatives_1 ) |
8650 | } | 7895 | // InternalSolverLanguageParser.g:2420:3: rule__AssertionOrDefinition__Alternatives_1 |
8651 | // InternalSolverLanguage.g:2341:2: ( rule__AssertionOrDefinition__Alternatives_1 ) | ||
8652 | // InternalSolverLanguage.g:2341:3: rule__AssertionOrDefinition__Alternatives_1 | ||
8653 | { | 7896 | { |
8654 | pushFollow(FOLLOW_2); | 7897 | pushFollow(FOLLOW_2); |
8655 | rule__AssertionOrDefinition__Alternatives_1(); | 7898 | rule__AssertionOrDefinition__Alternatives_1(); |
8656 | 7899 | ||
8657 | state._fsp--; | 7900 | state._fsp--; |
8658 | if (state.failed) return ; | ||
8659 | 7901 | ||
8660 | } | ||
8661 | 7902 | ||
8662 | if ( state.backtracking==0 ) { | ||
8663 | after(grammarAccess.getAssertionOrDefinitionAccess().getAlternatives_1()); | ||
8664 | } | 7903 | } |
8665 | 7904 | ||
7905 | after(grammarAccess.getAssertionOrDefinitionAccess().getAlternatives_1()); | ||
7906 | |||
8666 | } | 7907 | } |
8667 | 7908 | ||
8668 | 7909 | ||
@@ -8684,25 +7925,25 @@ public class InternalSolverLanguageParser extends AbstractInternalContentAssistP | |||
8684 | 7925 | ||
8685 | 7926 | ||
8686 | // $ANTLR start "rule__AssertionOrDefinition__Group_1_0__0" | 7927 | // $ANTLR start "rule__AssertionOrDefinition__Group_1_0__0" |
8687 | // InternalSolverLanguage.g:2350:1: rule__AssertionOrDefinition__Group_1_0__0 : rule__AssertionOrDefinition__Group_1_0__0__Impl rule__AssertionOrDefinition__Group_1_0__1 ; | 7928 | // InternalSolverLanguageParser.g:2429:1: rule__AssertionOrDefinition__Group_1_0__0 : rule__AssertionOrDefinition__Group_1_0__0__Impl rule__AssertionOrDefinition__Group_1_0__1 ; |
8688 | public final void rule__AssertionOrDefinition__Group_1_0__0() throws RecognitionException { | 7929 | public final void rule__AssertionOrDefinition__Group_1_0__0() throws RecognitionException { |
8689 | 7930 | ||
8690 | int stackSize = keepStackSize(); | 7931 | int stackSize = keepStackSize(); |
8691 | 7932 | ||
8692 | try { | 7933 | try { |
8693 | // InternalSolverLanguage.g:2354:1: ( rule__AssertionOrDefinition__Group_1_0__0__Impl rule__AssertionOrDefinition__Group_1_0__1 ) | 7934 | // InternalSolverLanguageParser.g:2433:1: ( rule__AssertionOrDefinition__Group_1_0__0__Impl rule__AssertionOrDefinition__Group_1_0__1 ) |
8694 | // InternalSolverLanguage.g:2355:2: rule__AssertionOrDefinition__Group_1_0__0__Impl rule__AssertionOrDefinition__Group_1_0__1 | 7935 | // InternalSolverLanguageParser.g:2434:2: rule__AssertionOrDefinition__Group_1_0__0__Impl rule__AssertionOrDefinition__Group_1_0__1 |
8695 | { | 7936 | { |
8696 | pushFollow(FOLLOW_6); | 7937 | pushFollow(FOLLOW_6); |
8697 | rule__AssertionOrDefinition__Group_1_0__0__Impl(); | 7938 | rule__AssertionOrDefinition__Group_1_0__0__Impl(); |
8698 | 7939 | ||
8699 | state._fsp--; | 7940 | state._fsp--; |
8700 | if (state.failed) return ; | 7941 | |
8701 | pushFollow(FOLLOW_2); | 7942 | pushFollow(FOLLOW_2); |
8702 | rule__AssertionOrDefinition__Group_1_0__1(); | 7943 | rule__AssertionOrDefinition__Group_1_0__1(); |
8703 | 7944 | ||
8704 | state._fsp--; | 7945 | state._fsp--; |
8705 | if (state.failed) return ; | 7946 | |
8706 | 7947 | ||
8707 | } | 7948 | } |
8708 | 7949 | ||
@@ -8722,29 +7963,25 @@ public class InternalSolverLanguageParser extends AbstractInternalContentAssistP | |||
8722 | 7963 | ||
8723 | 7964 | ||
8724 | // $ANTLR start "rule__AssertionOrDefinition__Group_1_0__0__Impl" | 7965 | // $ANTLR start "rule__AssertionOrDefinition__Group_1_0__0__Impl" |
8725 | // InternalSolverLanguage.g:2362:1: rule__AssertionOrDefinition__Group_1_0__0__Impl : ( () ) ; | 7966 | // InternalSolverLanguageParser.g:2441:1: rule__AssertionOrDefinition__Group_1_0__0__Impl : ( () ) ; |
8726 | public final void rule__AssertionOrDefinition__Group_1_0__0__Impl() throws RecognitionException { | 7967 | public final void rule__AssertionOrDefinition__Group_1_0__0__Impl() throws RecognitionException { |
8727 | 7968 | ||
8728 | int stackSize = keepStackSize(); | 7969 | int stackSize = keepStackSize(); |
8729 | 7970 | ||
8730 | try { | 7971 | try { |
8731 | // InternalSolverLanguage.g:2366:1: ( ( () ) ) | 7972 | // InternalSolverLanguageParser.g:2445:1: ( ( () ) ) |
8732 | // InternalSolverLanguage.g:2367:1: ( () ) | 7973 | // InternalSolverLanguageParser.g:2446:1: ( () ) |
8733 | { | 7974 | { |
8734 | // InternalSolverLanguage.g:2367:1: ( () ) | 7975 | // InternalSolverLanguageParser.g:2446:1: ( () ) |
8735 | // InternalSolverLanguage.g:2368:2: () | 7976 | // InternalSolverLanguageParser.g:2447:2: () |
8736 | { | 7977 | { |
8737 | if ( state.backtracking==0 ) { | 7978 | before(grammarAccess.getAssertionOrDefinitionAccess().getAssertionBodyAction_1_0_0()); |
8738 | before(grammarAccess.getAssertionOrDefinitionAccess().getAssertionBodyAction_1_0_0()); | 7979 | // InternalSolverLanguageParser.g:2448:2: () |
8739 | } | 7980 | // InternalSolverLanguageParser.g:2448:3: |
8740 | // InternalSolverLanguage.g:2369:2: () | ||
8741 | // InternalSolverLanguage.g:2369:3: | ||
8742 | { | 7981 | { |
8743 | } | 7982 | } |
8744 | 7983 | ||
8745 | if ( state.backtracking==0 ) { | 7984 | after(grammarAccess.getAssertionOrDefinitionAccess().getAssertionBodyAction_1_0_0()); |
8746 | after(grammarAccess.getAssertionOrDefinitionAccess().getAssertionBodyAction_1_0_0()); | ||
8747 | } | ||
8748 | 7985 | ||
8749 | } | 7986 | } |
8750 | 7987 | ||
@@ -8763,20 +8000,20 @@ public class InternalSolverLanguageParser extends AbstractInternalContentAssistP | |||
8763 | 8000 | ||
8764 | 8001 | ||
8765 | // $ANTLR start "rule__AssertionOrDefinition__Group_1_0__1" | 8002 | // $ANTLR start "rule__AssertionOrDefinition__Group_1_0__1" |
8766 | // InternalSolverLanguage.g:2377:1: rule__AssertionOrDefinition__Group_1_0__1 : rule__AssertionOrDefinition__Group_1_0__1__Impl ; | 8003 | // InternalSolverLanguageParser.g:2456:1: rule__AssertionOrDefinition__Group_1_0__1 : rule__AssertionOrDefinition__Group_1_0__1__Impl ; |
8767 | public final void rule__AssertionOrDefinition__Group_1_0__1() throws RecognitionException { | 8004 | public final void rule__AssertionOrDefinition__Group_1_0__1() throws RecognitionException { |
8768 | 8005 | ||
8769 | int stackSize = keepStackSize(); | 8006 | int stackSize = keepStackSize(); |
8770 | 8007 | ||
8771 | try { | 8008 | try { |
8772 | // InternalSolverLanguage.g:2381:1: ( rule__AssertionOrDefinition__Group_1_0__1__Impl ) | 8009 | // InternalSolverLanguageParser.g:2460:1: ( rule__AssertionOrDefinition__Group_1_0__1__Impl ) |
8773 | // InternalSolverLanguage.g:2382:2: rule__AssertionOrDefinition__Group_1_0__1__Impl | 8010 | // InternalSolverLanguageParser.g:2461:2: rule__AssertionOrDefinition__Group_1_0__1__Impl |
8774 | { | 8011 | { |
8775 | pushFollow(FOLLOW_2); | 8012 | pushFollow(FOLLOW_2); |
8776 | rule__AssertionOrDefinition__Group_1_0__1__Impl(); | 8013 | rule__AssertionOrDefinition__Group_1_0__1__Impl(); |
8777 | 8014 | ||
8778 | state._fsp--; | 8015 | state._fsp--; |
8779 | if (state.failed) return ; | 8016 | |
8780 | 8017 | ||
8781 | } | 8018 | } |
8782 | 8019 | ||
@@ -8796,46 +8033,42 @@ public class InternalSolverLanguageParser extends AbstractInternalContentAssistP | |||
8796 | 8033 | ||
8797 | 8034 | ||
8798 | // $ANTLR start "rule__AssertionOrDefinition__Group_1_0__1__Impl" | 8035 | // $ANTLR start "rule__AssertionOrDefinition__Group_1_0__1__Impl" |
8799 | // InternalSolverLanguage.g:2388:1: rule__AssertionOrDefinition__Group_1_0__1__Impl : ( ( rule__AssertionOrDefinition__Group_1_0_1__0 )? ) ; | 8036 | // InternalSolverLanguageParser.g:2467:1: rule__AssertionOrDefinition__Group_1_0__1__Impl : ( ( rule__AssertionOrDefinition__Group_1_0_1__0 )? ) ; |
8800 | public final void rule__AssertionOrDefinition__Group_1_0__1__Impl() throws RecognitionException { | 8037 | public final void rule__AssertionOrDefinition__Group_1_0__1__Impl() throws RecognitionException { |
8801 | 8038 | ||
8802 | int stackSize = keepStackSize(); | 8039 | int stackSize = keepStackSize(); |
8803 | 8040 | ||
8804 | try { | 8041 | try { |
8805 | // InternalSolverLanguage.g:2392:1: ( ( ( rule__AssertionOrDefinition__Group_1_0_1__0 )? ) ) | 8042 | // InternalSolverLanguageParser.g:2471:1: ( ( ( rule__AssertionOrDefinition__Group_1_0_1__0 )? ) ) |
8806 | // InternalSolverLanguage.g:2393:1: ( ( rule__AssertionOrDefinition__Group_1_0_1__0 )? ) | 8043 | // InternalSolverLanguageParser.g:2472:1: ( ( rule__AssertionOrDefinition__Group_1_0_1__0 )? ) |
8807 | { | 8044 | { |
8808 | // InternalSolverLanguage.g:2393:1: ( ( rule__AssertionOrDefinition__Group_1_0_1__0 )? ) | 8045 | // InternalSolverLanguageParser.g:2472:1: ( ( rule__AssertionOrDefinition__Group_1_0_1__0 )? ) |
8809 | // InternalSolverLanguage.g:2394:2: ( rule__AssertionOrDefinition__Group_1_0_1__0 )? | 8046 | // InternalSolverLanguageParser.g:2473:2: ( rule__AssertionOrDefinition__Group_1_0_1__0 )? |
8810 | { | 8047 | { |
8811 | if ( state.backtracking==0 ) { | 8048 | before(grammarAccess.getAssertionOrDefinitionAccess().getGroup_1_0_1()); |
8812 | before(grammarAccess.getAssertionOrDefinitionAccess().getGroup_1_0_1()); | 8049 | // InternalSolverLanguageParser.g:2474:2: ( rule__AssertionOrDefinition__Group_1_0_1__0 )? |
8813 | } | ||
8814 | // InternalSolverLanguage.g:2395:2: ( rule__AssertionOrDefinition__Group_1_0_1__0 )? | ||
8815 | int alt27=2; | 8050 | int alt27=2; |
8816 | int LA27_0 = input.LA(1); | 8051 | int LA27_0 = input.LA(1); |
8817 | 8052 | ||
8818 | if ( (LA27_0==45) ) { | 8053 | if ( (LA27_0==Colon) ) { |
8819 | alt27=1; | 8054 | alt27=1; |
8820 | } | 8055 | } |
8821 | switch (alt27) { | 8056 | switch (alt27) { |
8822 | case 1 : | 8057 | case 1 : |
8823 | // InternalSolverLanguage.g:2395:3: rule__AssertionOrDefinition__Group_1_0_1__0 | 8058 | // InternalSolverLanguageParser.g:2474:3: rule__AssertionOrDefinition__Group_1_0_1__0 |
8824 | { | 8059 | { |
8825 | pushFollow(FOLLOW_2); | 8060 | pushFollow(FOLLOW_2); |
8826 | rule__AssertionOrDefinition__Group_1_0_1__0(); | 8061 | rule__AssertionOrDefinition__Group_1_0_1__0(); |
8827 | 8062 | ||
8828 | state._fsp--; | 8063 | state._fsp--; |
8829 | if (state.failed) return ; | 8064 | |
8830 | 8065 | ||
8831 | } | 8066 | } |
8832 | break; | 8067 | break; |
8833 | 8068 | ||
8834 | } | 8069 | } |
8835 | 8070 | ||
8836 | if ( state.backtracking==0 ) { | 8071 | after(grammarAccess.getAssertionOrDefinitionAccess().getGroup_1_0_1()); |
8837 | after(grammarAccess.getAssertionOrDefinitionAccess().getGroup_1_0_1()); | ||
8838 | } | ||
8839 | 8072 | ||
8840 | } | 8073 | } |
8841 | 8074 | ||
@@ -8858,25 +8091,25 @@ public class InternalSolverLanguageParser extends AbstractInternalContentAssistP | |||
8858 | 8091 | ||
8859 | 8092 | ||
8860 | // $ANTLR start "rule__AssertionOrDefinition__Group_1_0_1__0" | 8093 | // $ANTLR start "rule__AssertionOrDefinition__Group_1_0_1__0" |
8861 | // InternalSolverLanguage.g:2404:1: rule__AssertionOrDefinition__Group_1_0_1__0 : rule__AssertionOrDefinition__Group_1_0_1__0__Impl rule__AssertionOrDefinition__Group_1_0_1__1 ; | 8094 | // InternalSolverLanguageParser.g:2483:1: rule__AssertionOrDefinition__Group_1_0_1__0 : rule__AssertionOrDefinition__Group_1_0_1__0__Impl rule__AssertionOrDefinition__Group_1_0_1__1 ; |
8862 | public final void rule__AssertionOrDefinition__Group_1_0_1__0() throws RecognitionException { | 8095 | public final void rule__AssertionOrDefinition__Group_1_0_1__0() throws RecognitionException { |
8863 | 8096 | ||
8864 | int stackSize = keepStackSize(); | 8097 | int stackSize = keepStackSize(); |
8865 | 8098 | ||
8866 | try { | 8099 | try { |
8867 | // InternalSolverLanguage.g:2408:1: ( rule__AssertionOrDefinition__Group_1_0_1__0__Impl rule__AssertionOrDefinition__Group_1_0_1__1 ) | 8100 | // InternalSolverLanguageParser.g:2487:1: ( rule__AssertionOrDefinition__Group_1_0_1__0__Impl rule__AssertionOrDefinition__Group_1_0_1__1 ) |
8868 | // InternalSolverLanguage.g:2409:2: rule__AssertionOrDefinition__Group_1_0_1__0__Impl rule__AssertionOrDefinition__Group_1_0_1__1 | 8101 | // InternalSolverLanguageParser.g:2488:2: rule__AssertionOrDefinition__Group_1_0_1__0__Impl rule__AssertionOrDefinition__Group_1_0_1__1 |
8869 | { | 8102 | { |
8870 | pushFollow(FOLLOW_7); | 8103 | pushFollow(FOLLOW_7); |
8871 | rule__AssertionOrDefinition__Group_1_0_1__0__Impl(); | 8104 | rule__AssertionOrDefinition__Group_1_0_1__0__Impl(); |
8872 | 8105 | ||
8873 | state._fsp--; | 8106 | state._fsp--; |
8874 | if (state.failed) return ; | 8107 | |
8875 | pushFollow(FOLLOW_2); | 8108 | pushFollow(FOLLOW_2); |
8876 | rule__AssertionOrDefinition__Group_1_0_1__1(); | 8109 | rule__AssertionOrDefinition__Group_1_0_1__1(); |
8877 | 8110 | ||
8878 | state._fsp--; | 8111 | state._fsp--; |
8879 | if (state.failed) return ; | 8112 | |
8880 | 8113 | ||
8881 | } | 8114 | } |
8882 | 8115 | ||
@@ -8896,25 +8129,21 @@ public class InternalSolverLanguageParser extends AbstractInternalContentAssistP | |||
8896 | 8129 | ||
8897 | 8130 | ||
8898 | // $ANTLR start "rule__AssertionOrDefinition__Group_1_0_1__0__Impl" | 8131 | // $ANTLR start "rule__AssertionOrDefinition__Group_1_0_1__0__Impl" |
8899 | // InternalSolverLanguage.g:2416:1: rule__AssertionOrDefinition__Group_1_0_1__0__Impl : ( ':' ) ; | 8132 | // InternalSolverLanguageParser.g:2495:1: rule__AssertionOrDefinition__Group_1_0_1__0__Impl : ( Colon ) ; |
8900 | public final void rule__AssertionOrDefinition__Group_1_0_1__0__Impl() throws RecognitionException { | 8133 | public final void rule__AssertionOrDefinition__Group_1_0_1__0__Impl() throws RecognitionException { |
8901 | 8134 | ||
8902 | int stackSize = keepStackSize(); | 8135 | int stackSize = keepStackSize(); |
8903 | 8136 | ||
8904 | try { | 8137 | try { |
8905 | // InternalSolverLanguage.g:2420:1: ( ( ':' ) ) | 8138 | // InternalSolverLanguageParser.g:2499:1: ( ( Colon ) ) |
8906 | // InternalSolverLanguage.g:2421:1: ( ':' ) | 8139 | // InternalSolverLanguageParser.g:2500:1: ( Colon ) |
8907 | { | 8140 | { |
8908 | // InternalSolverLanguage.g:2421:1: ( ':' ) | 8141 | // InternalSolverLanguageParser.g:2500:1: ( Colon ) |
8909 | // InternalSolverLanguage.g:2422:2: ':' | 8142 | // InternalSolverLanguageParser.g:2501:2: Colon |
8910 | { | 8143 | { |
8911 | if ( state.backtracking==0 ) { | 8144 | before(grammarAccess.getAssertionOrDefinitionAccess().getColonKeyword_1_0_1_0()); |
8912 | before(grammarAccess.getAssertionOrDefinitionAccess().getColonKeyword_1_0_1_0()); | 8145 | match(input,Colon,FOLLOW_2); |
8913 | } | 8146 | after(grammarAccess.getAssertionOrDefinitionAccess().getColonKeyword_1_0_1_0()); |
8914 | match(input,45,FOLLOW_2); if (state.failed) return ; | ||
8915 | if ( state.backtracking==0 ) { | ||
8916 | after(grammarAccess.getAssertionOrDefinitionAccess().getColonKeyword_1_0_1_0()); | ||
8917 | } | ||
8918 | 8147 | ||
8919 | } | 8148 | } |
8920 | 8149 | ||
@@ -8937,20 +8166,20 @@ public class InternalSolverLanguageParser extends AbstractInternalContentAssistP | |||
8937 | 8166 | ||
8938 | 8167 | ||
8939 | // $ANTLR start "rule__AssertionOrDefinition__Group_1_0_1__1" | 8168 | // $ANTLR start "rule__AssertionOrDefinition__Group_1_0_1__1" |
8940 | // InternalSolverLanguage.g:2431:1: rule__AssertionOrDefinition__Group_1_0_1__1 : rule__AssertionOrDefinition__Group_1_0_1__1__Impl ; | 8169 | // InternalSolverLanguageParser.g:2510:1: rule__AssertionOrDefinition__Group_1_0_1__1 : rule__AssertionOrDefinition__Group_1_0_1__1__Impl ; |
8941 | public final void rule__AssertionOrDefinition__Group_1_0_1__1() throws RecognitionException { | 8170 | public final void rule__AssertionOrDefinition__Group_1_0_1__1() throws RecognitionException { |
8942 | 8171 | ||
8943 | int stackSize = keepStackSize(); | 8172 | int stackSize = keepStackSize(); |
8944 | 8173 | ||
8945 | try { | 8174 | try { |
8946 | // InternalSolverLanguage.g:2435:1: ( rule__AssertionOrDefinition__Group_1_0_1__1__Impl ) | 8175 | // InternalSolverLanguageParser.g:2514:1: ( rule__AssertionOrDefinition__Group_1_0_1__1__Impl ) |
8947 | // InternalSolverLanguage.g:2436:2: rule__AssertionOrDefinition__Group_1_0_1__1__Impl | 8176 | // InternalSolverLanguageParser.g:2515:2: rule__AssertionOrDefinition__Group_1_0_1__1__Impl |
8948 | { | 8177 | { |
8949 | pushFollow(FOLLOW_2); | 8178 | pushFollow(FOLLOW_2); |
8950 | rule__AssertionOrDefinition__Group_1_0_1__1__Impl(); | 8179 | rule__AssertionOrDefinition__Group_1_0_1__1__Impl(); |
8951 | 8180 | ||
8952 | state._fsp--; | 8181 | state._fsp--; |
8953 | if (state.failed) return ; | 8182 | |
8954 | 8183 | ||
8955 | } | 8184 | } |
8956 | 8185 | ||
@@ -8970,36 +8199,32 @@ public class InternalSolverLanguageParser extends AbstractInternalContentAssistP | |||
8970 | 8199 | ||
8971 | 8200 | ||
8972 | // $ANTLR start "rule__AssertionOrDefinition__Group_1_0_1__1__Impl" | 8201 | // $ANTLR start "rule__AssertionOrDefinition__Group_1_0_1__1__Impl" |
8973 | // InternalSolverLanguage.g:2442:1: rule__AssertionOrDefinition__Group_1_0_1__1__Impl : ( ( rule__AssertionOrDefinition__RangeAssignment_1_0_1_1 ) ) ; | 8202 | // InternalSolverLanguageParser.g:2521:1: rule__AssertionOrDefinition__Group_1_0_1__1__Impl : ( ( rule__AssertionOrDefinition__RangeAssignment_1_0_1_1 ) ) ; |
8974 | public final void rule__AssertionOrDefinition__Group_1_0_1__1__Impl() throws RecognitionException { | 8203 | public final void rule__AssertionOrDefinition__Group_1_0_1__1__Impl() throws RecognitionException { |
8975 | 8204 | ||
8976 | int stackSize = keepStackSize(); | 8205 | int stackSize = keepStackSize(); |
8977 | 8206 | ||
8978 | try { | 8207 | try { |
8979 | // InternalSolverLanguage.g:2446:1: ( ( ( rule__AssertionOrDefinition__RangeAssignment_1_0_1_1 ) ) ) | 8208 | // InternalSolverLanguageParser.g:2525:1: ( ( ( rule__AssertionOrDefinition__RangeAssignment_1_0_1_1 ) ) ) |
8980 | // InternalSolverLanguage.g:2447:1: ( ( rule__AssertionOrDefinition__RangeAssignment_1_0_1_1 ) ) | 8209 | // InternalSolverLanguageParser.g:2526:1: ( ( rule__AssertionOrDefinition__RangeAssignment_1_0_1_1 ) ) |
8981 | { | 8210 | { |
8982 | // InternalSolverLanguage.g:2447:1: ( ( rule__AssertionOrDefinition__RangeAssignment_1_0_1_1 ) ) | 8211 | // InternalSolverLanguageParser.g:2526:1: ( ( rule__AssertionOrDefinition__RangeAssignment_1_0_1_1 ) ) |
8983 | // InternalSolverLanguage.g:2448:2: ( rule__AssertionOrDefinition__RangeAssignment_1_0_1_1 ) | 8212 | // InternalSolverLanguageParser.g:2527:2: ( rule__AssertionOrDefinition__RangeAssignment_1_0_1_1 ) |
8984 | { | 8213 | { |
8985 | if ( state.backtracking==0 ) { | 8214 | before(grammarAccess.getAssertionOrDefinitionAccess().getRangeAssignment_1_0_1_1()); |
8986 | before(grammarAccess.getAssertionOrDefinitionAccess().getRangeAssignment_1_0_1_1()); | 8215 | // InternalSolverLanguageParser.g:2528:2: ( rule__AssertionOrDefinition__RangeAssignment_1_0_1_1 ) |
8987 | } | 8216 | // InternalSolverLanguageParser.g:2528:3: rule__AssertionOrDefinition__RangeAssignment_1_0_1_1 |
8988 | // InternalSolverLanguage.g:2449:2: ( rule__AssertionOrDefinition__RangeAssignment_1_0_1_1 ) | ||
8989 | // InternalSolverLanguage.g:2449:3: rule__AssertionOrDefinition__RangeAssignment_1_0_1_1 | ||
8990 | { | 8217 | { |
8991 | pushFollow(FOLLOW_2); | 8218 | pushFollow(FOLLOW_2); |
8992 | rule__AssertionOrDefinition__RangeAssignment_1_0_1_1(); | 8219 | rule__AssertionOrDefinition__RangeAssignment_1_0_1_1(); |
8993 | 8220 | ||
8994 | state._fsp--; | 8221 | state._fsp--; |
8995 | if (state.failed) return ; | ||
8996 | 8222 | ||
8997 | } | ||
8998 | 8223 | ||
8999 | if ( state.backtracking==0 ) { | ||
9000 | after(grammarAccess.getAssertionOrDefinitionAccess().getRangeAssignment_1_0_1_1()); | ||
9001 | } | 8224 | } |
9002 | 8225 | ||
8226 | after(grammarAccess.getAssertionOrDefinitionAccess().getRangeAssignment_1_0_1_1()); | ||
8227 | |||
9003 | } | 8228 | } |
9004 | 8229 | ||
9005 | 8230 | ||
@@ -9021,25 +8246,25 @@ public class InternalSolverLanguageParser extends AbstractInternalContentAssistP | |||
9021 | 8246 | ||
9022 | 8247 | ||
9023 | // $ANTLR start "rule__AssertionOrDefinition__Group_1_1__0" | 8248 | // $ANTLR start "rule__AssertionOrDefinition__Group_1_1__0" |
9024 | // InternalSolverLanguage.g:2458:1: rule__AssertionOrDefinition__Group_1_1__0 : rule__AssertionOrDefinition__Group_1_1__0__Impl rule__AssertionOrDefinition__Group_1_1__1 ; | 8249 | // InternalSolverLanguageParser.g:2537:1: rule__AssertionOrDefinition__Group_1_1__0 : rule__AssertionOrDefinition__Group_1_1__0__Impl rule__AssertionOrDefinition__Group_1_1__1 ; |
9025 | public final void rule__AssertionOrDefinition__Group_1_1__0() throws RecognitionException { | 8250 | public final void rule__AssertionOrDefinition__Group_1_1__0() throws RecognitionException { |
9026 | 8251 | ||
9027 | int stackSize = keepStackSize(); | 8252 | int stackSize = keepStackSize(); |
9028 | 8253 | ||
9029 | try { | 8254 | try { |
9030 | // InternalSolverLanguage.g:2462:1: ( rule__AssertionOrDefinition__Group_1_1__0__Impl rule__AssertionOrDefinition__Group_1_1__1 ) | 8255 | // InternalSolverLanguageParser.g:2541:1: ( rule__AssertionOrDefinition__Group_1_1__0__Impl rule__AssertionOrDefinition__Group_1_1__1 ) |
9031 | // InternalSolverLanguage.g:2463:2: rule__AssertionOrDefinition__Group_1_1__0__Impl rule__AssertionOrDefinition__Group_1_1__1 | 8256 | // InternalSolverLanguageParser.g:2542:2: rule__AssertionOrDefinition__Group_1_1__0__Impl rule__AssertionOrDefinition__Group_1_1__1 |
9032 | { | 8257 | { |
9033 | pushFollow(FOLLOW_8); | 8258 | pushFollow(FOLLOW_8); |
9034 | rule__AssertionOrDefinition__Group_1_1__0__Impl(); | 8259 | rule__AssertionOrDefinition__Group_1_1__0__Impl(); |
9035 | 8260 | ||
9036 | state._fsp--; | 8261 | state._fsp--; |
9037 | if (state.failed) return ; | 8262 | |
9038 | pushFollow(FOLLOW_2); | 8263 | pushFollow(FOLLOW_2); |
9039 | rule__AssertionOrDefinition__Group_1_1__1(); | 8264 | rule__AssertionOrDefinition__Group_1_1__1(); |
9040 | 8265 | ||
9041 | state._fsp--; | 8266 | state._fsp--; |
9042 | if (state.failed) return ; | 8267 | |
9043 | 8268 | ||
9044 | } | 8269 | } |
9045 | 8270 | ||
@@ -9059,29 +8284,25 @@ public class InternalSolverLanguageParser extends AbstractInternalContentAssistP | |||
9059 | 8284 | ||
9060 | 8285 | ||
9061 | // $ANTLR start "rule__AssertionOrDefinition__Group_1_1__0__Impl" | 8286 | // $ANTLR start "rule__AssertionOrDefinition__Group_1_1__0__Impl" |
9062 | // InternalSolverLanguage.g:2470:1: rule__AssertionOrDefinition__Group_1_1__0__Impl : ( () ) ; | 8287 | // InternalSolverLanguageParser.g:2549:1: rule__AssertionOrDefinition__Group_1_1__0__Impl : ( () ) ; |
9063 | public final void rule__AssertionOrDefinition__Group_1_1__0__Impl() throws RecognitionException { | 8288 | public final void rule__AssertionOrDefinition__Group_1_1__0__Impl() throws RecognitionException { |
9064 | 8289 | ||
9065 | int stackSize = keepStackSize(); | 8290 | int stackSize = keepStackSize(); |
9066 | 8291 | ||
9067 | try { | 8292 | try { |
9068 | // InternalSolverLanguage.g:2474:1: ( ( () ) ) | 8293 | // InternalSolverLanguageParser.g:2553:1: ( ( () ) ) |
9069 | // InternalSolverLanguage.g:2475:1: ( () ) | 8294 | // InternalSolverLanguageParser.g:2554:1: ( () ) |
9070 | { | 8295 | { |
9071 | // InternalSolverLanguage.g:2475:1: ( () ) | 8296 | // InternalSolverLanguageParser.g:2554:1: ( () ) |
9072 | // InternalSolverLanguage.g:2476:2: () | 8297 | // InternalSolverLanguageParser.g:2555:2: () |
9073 | { | 8298 | { |
9074 | if ( state.backtracking==0 ) { | 8299 | before(grammarAccess.getAssertionOrDefinitionAccess().getPredicateDefinitionHeadAction_1_1_0()); |
9075 | before(grammarAccess.getAssertionOrDefinitionAccess().getPredicateDefinitionHeadAction_1_1_0()); | 8300 | // InternalSolverLanguageParser.g:2556:2: () |
9076 | } | 8301 | // InternalSolverLanguageParser.g:2556:3: |
9077 | // InternalSolverLanguage.g:2477:2: () | ||
9078 | // InternalSolverLanguage.g:2477:3: | ||
9079 | { | 8302 | { |
9080 | } | 8303 | } |
9081 | 8304 | ||
9082 | if ( state.backtracking==0 ) { | 8305 | after(grammarAccess.getAssertionOrDefinitionAccess().getPredicateDefinitionHeadAction_1_1_0()); |
9083 | after(grammarAccess.getAssertionOrDefinitionAccess().getPredicateDefinitionHeadAction_1_1_0()); | ||
9084 | } | ||
9085 | 8306 | ||
9086 | } | 8307 | } |
9087 | 8308 | ||
@@ -9100,25 +8321,25 @@ public class InternalSolverLanguageParser extends AbstractInternalContentAssistP | |||
9100 | 8321 | ||
9101 | 8322 | ||
9102 | // $ANTLR start "rule__AssertionOrDefinition__Group_1_1__1" | 8323 | // $ANTLR start "rule__AssertionOrDefinition__Group_1_1__1" |
9103 | // InternalSolverLanguage.g:2485:1: rule__AssertionOrDefinition__Group_1_1__1 : rule__AssertionOrDefinition__Group_1_1__1__Impl rule__AssertionOrDefinition__Group_1_1__2 ; | 8324 | // InternalSolverLanguageParser.g:2564:1: rule__AssertionOrDefinition__Group_1_1__1 : rule__AssertionOrDefinition__Group_1_1__1__Impl rule__AssertionOrDefinition__Group_1_1__2 ; |
9104 | public final void rule__AssertionOrDefinition__Group_1_1__1() throws RecognitionException { | 8325 | public final void rule__AssertionOrDefinition__Group_1_1__1() throws RecognitionException { |
9105 | 8326 | ||
9106 | int stackSize = keepStackSize(); | 8327 | int stackSize = keepStackSize(); |
9107 | 8328 | ||
9108 | try { | 8329 | try { |
9109 | // InternalSolverLanguage.g:2489:1: ( rule__AssertionOrDefinition__Group_1_1__1__Impl rule__AssertionOrDefinition__Group_1_1__2 ) | 8330 | // InternalSolverLanguageParser.g:2568:1: ( rule__AssertionOrDefinition__Group_1_1__1__Impl rule__AssertionOrDefinition__Group_1_1__2 ) |
9110 | // InternalSolverLanguage.g:2490:2: rule__AssertionOrDefinition__Group_1_1__1__Impl rule__AssertionOrDefinition__Group_1_1__2 | 8331 | // InternalSolverLanguageParser.g:2569:2: rule__AssertionOrDefinition__Group_1_1__1__Impl rule__AssertionOrDefinition__Group_1_1__2 |
9111 | { | 8332 | { |
9112 | pushFollow(FOLLOW_7); | 8333 | pushFollow(FOLLOW_7); |
9113 | rule__AssertionOrDefinition__Group_1_1__1__Impl(); | 8334 | rule__AssertionOrDefinition__Group_1_1__1__Impl(); |
9114 | 8335 | ||
9115 | state._fsp--; | 8336 | state._fsp--; |
9116 | if (state.failed) return ; | 8337 | |
9117 | pushFollow(FOLLOW_2); | 8338 | pushFollow(FOLLOW_2); |
9118 | rule__AssertionOrDefinition__Group_1_1__2(); | 8339 | rule__AssertionOrDefinition__Group_1_1__2(); |
9119 | 8340 | ||
9120 | state._fsp--; | 8341 | state._fsp--; |
9121 | if (state.failed) return ; | 8342 | |
9122 | 8343 | ||
9123 | } | 8344 | } |
9124 | 8345 | ||
@@ -9138,25 +8359,21 @@ public class InternalSolverLanguageParser extends AbstractInternalContentAssistP | |||
9138 | 8359 | ||
9139 | 8360 | ||
9140 | // $ANTLR start "rule__AssertionOrDefinition__Group_1_1__1__Impl" | 8361 | // $ANTLR start "rule__AssertionOrDefinition__Group_1_1__1__Impl" |
9141 | // InternalSolverLanguage.g:2497:1: rule__AssertionOrDefinition__Group_1_1__1__Impl : ( ':-' ) ; | 8362 | // InternalSolverLanguageParser.g:2576:1: rule__AssertionOrDefinition__Group_1_1__1__Impl : ( ColonHyphenMinus ) ; |
9142 | public final void rule__AssertionOrDefinition__Group_1_1__1__Impl() throws RecognitionException { | 8363 | public final void rule__AssertionOrDefinition__Group_1_1__1__Impl() throws RecognitionException { |
9143 | 8364 | ||
9144 | int stackSize = keepStackSize(); | 8365 | int stackSize = keepStackSize(); |
9145 | 8366 | ||
9146 | try { | 8367 | try { |
9147 | // InternalSolverLanguage.g:2501:1: ( ( ':-' ) ) | 8368 | // InternalSolverLanguageParser.g:2580:1: ( ( ColonHyphenMinus ) ) |
9148 | // InternalSolverLanguage.g:2502:1: ( ':-' ) | 8369 | // InternalSolverLanguageParser.g:2581:1: ( ColonHyphenMinus ) |
9149 | { | 8370 | { |
9150 | // InternalSolverLanguage.g:2502:1: ( ':-' ) | 8371 | // InternalSolverLanguageParser.g:2581:1: ( ColonHyphenMinus ) |
9151 | // InternalSolverLanguage.g:2503:2: ':-' | 8372 | // InternalSolverLanguageParser.g:2582:2: ColonHyphenMinus |
9152 | { | 8373 | { |
9153 | if ( state.backtracking==0 ) { | 8374 | before(grammarAccess.getAssertionOrDefinitionAccess().getColonHyphenMinusKeyword_1_1_1()); |
9154 | before(grammarAccess.getAssertionOrDefinitionAccess().getColonHyphenMinusKeyword_1_1_1()); | 8375 | match(input,ColonHyphenMinus,FOLLOW_2); |
9155 | } | 8376 | after(grammarAccess.getAssertionOrDefinitionAccess().getColonHyphenMinusKeyword_1_1_1()); |
9156 | match(input,46,FOLLOW_2); if (state.failed) return ; | ||
9157 | if ( state.backtracking==0 ) { | ||
9158 | after(grammarAccess.getAssertionOrDefinitionAccess().getColonHyphenMinusKeyword_1_1_1()); | ||
9159 | } | ||
9160 | 8377 | ||
9161 | } | 8378 | } |
9162 | 8379 | ||
@@ -9179,20 +8396,20 @@ public class InternalSolverLanguageParser extends AbstractInternalContentAssistP | |||
9179 | 8396 | ||
9180 | 8397 | ||
9181 | // $ANTLR start "rule__AssertionOrDefinition__Group_1_1__2" | 8398 | // $ANTLR start "rule__AssertionOrDefinition__Group_1_1__2" |
9182 | // InternalSolverLanguage.g:2512:1: rule__AssertionOrDefinition__Group_1_1__2 : rule__AssertionOrDefinition__Group_1_1__2__Impl ; | 8399 | // InternalSolverLanguageParser.g:2591:1: rule__AssertionOrDefinition__Group_1_1__2 : rule__AssertionOrDefinition__Group_1_1__2__Impl ; |
9183 | public final void rule__AssertionOrDefinition__Group_1_1__2() throws RecognitionException { | 8400 | public final void rule__AssertionOrDefinition__Group_1_1__2() throws RecognitionException { |
9184 | 8401 | ||
9185 | int stackSize = keepStackSize(); | 8402 | int stackSize = keepStackSize(); |
9186 | 8403 | ||
9187 | try { | 8404 | try { |
9188 | // InternalSolverLanguage.g:2516:1: ( rule__AssertionOrDefinition__Group_1_1__2__Impl ) | 8405 | // InternalSolverLanguageParser.g:2595:1: ( rule__AssertionOrDefinition__Group_1_1__2__Impl ) |
9189 | // InternalSolverLanguage.g:2517:2: rule__AssertionOrDefinition__Group_1_1__2__Impl | 8406 | // InternalSolverLanguageParser.g:2596:2: rule__AssertionOrDefinition__Group_1_1__2__Impl |
9190 | { | 8407 | { |
9191 | pushFollow(FOLLOW_2); | 8408 | pushFollow(FOLLOW_2); |
9192 | rule__AssertionOrDefinition__Group_1_1__2__Impl(); | 8409 | rule__AssertionOrDefinition__Group_1_1__2__Impl(); |
9193 | 8410 | ||
9194 | state._fsp--; | 8411 | state._fsp--; |
9195 | if (state.failed) return ; | 8412 | |
9196 | 8413 | ||
9197 | } | 8414 | } |
9198 | 8415 | ||
@@ -9212,36 +8429,32 @@ public class InternalSolverLanguageParser extends AbstractInternalContentAssistP | |||
9212 | 8429 | ||
9213 | 8430 | ||
9214 | // $ANTLR start "rule__AssertionOrDefinition__Group_1_1__2__Impl" | 8431 | // $ANTLR start "rule__AssertionOrDefinition__Group_1_1__2__Impl" |
9215 | // InternalSolverLanguage.g:2523:1: rule__AssertionOrDefinition__Group_1_1__2__Impl : ( ( rule__AssertionOrDefinition__BodyAssignment_1_1_2 ) ) ; | 8432 | // InternalSolverLanguageParser.g:2602:1: rule__AssertionOrDefinition__Group_1_1__2__Impl : ( ( rule__AssertionOrDefinition__BodyAssignment_1_1_2 ) ) ; |
9216 | public final void rule__AssertionOrDefinition__Group_1_1__2__Impl() throws RecognitionException { | 8433 | public final void rule__AssertionOrDefinition__Group_1_1__2__Impl() throws RecognitionException { |
9217 | 8434 | ||
9218 | int stackSize = keepStackSize(); | 8435 | int stackSize = keepStackSize(); |
9219 | 8436 | ||
9220 | try { | 8437 | try { |
9221 | // InternalSolverLanguage.g:2527:1: ( ( ( rule__AssertionOrDefinition__BodyAssignment_1_1_2 ) ) ) | 8438 | // InternalSolverLanguageParser.g:2606:1: ( ( ( rule__AssertionOrDefinition__BodyAssignment_1_1_2 ) ) ) |
9222 | // InternalSolverLanguage.g:2528:1: ( ( rule__AssertionOrDefinition__BodyAssignment_1_1_2 ) ) | 8439 | // InternalSolverLanguageParser.g:2607:1: ( ( rule__AssertionOrDefinition__BodyAssignment_1_1_2 ) ) |
9223 | { | 8440 | { |
9224 | // InternalSolverLanguage.g:2528:1: ( ( rule__AssertionOrDefinition__BodyAssignment_1_1_2 ) ) | 8441 | // InternalSolverLanguageParser.g:2607:1: ( ( rule__AssertionOrDefinition__BodyAssignment_1_1_2 ) ) |
9225 | // InternalSolverLanguage.g:2529:2: ( rule__AssertionOrDefinition__BodyAssignment_1_1_2 ) | 8442 | // InternalSolverLanguageParser.g:2608:2: ( rule__AssertionOrDefinition__BodyAssignment_1_1_2 ) |
9226 | { | 8443 | { |
9227 | if ( state.backtracking==0 ) { | 8444 | before(grammarAccess.getAssertionOrDefinitionAccess().getBodyAssignment_1_1_2()); |
9228 | before(grammarAccess.getAssertionOrDefinitionAccess().getBodyAssignment_1_1_2()); | 8445 | // InternalSolverLanguageParser.g:2609:2: ( rule__AssertionOrDefinition__BodyAssignment_1_1_2 ) |
9229 | } | 8446 | // InternalSolverLanguageParser.g:2609:3: rule__AssertionOrDefinition__BodyAssignment_1_1_2 |
9230 | // InternalSolverLanguage.g:2530:2: ( rule__AssertionOrDefinition__BodyAssignment_1_1_2 ) | ||
9231 | // InternalSolverLanguage.g:2530:3: rule__AssertionOrDefinition__BodyAssignment_1_1_2 | ||
9232 | { | 8447 | { |
9233 | pushFollow(FOLLOW_2); | 8448 | pushFollow(FOLLOW_2); |
9234 | rule__AssertionOrDefinition__BodyAssignment_1_1_2(); | 8449 | rule__AssertionOrDefinition__BodyAssignment_1_1_2(); |
9235 | 8450 | ||
9236 | state._fsp--; | 8451 | state._fsp--; |
9237 | if (state.failed) return ; | ||
9238 | 8452 | ||
9239 | } | ||
9240 | 8453 | ||
9241 | if ( state.backtracking==0 ) { | ||
9242 | after(grammarAccess.getAssertionOrDefinitionAccess().getBodyAssignment_1_1_2()); | ||
9243 | } | 8454 | } |
9244 | 8455 | ||
8456 | after(grammarAccess.getAssertionOrDefinitionAccess().getBodyAssignment_1_1_2()); | ||
8457 | |||
9245 | } | 8458 | } |
9246 | 8459 | ||
9247 | 8460 | ||
@@ -9263,25 +8476,25 @@ public class InternalSolverLanguageParser extends AbstractInternalContentAssistP | |||
9263 | 8476 | ||
9264 | 8477 | ||
9265 | // $ANTLR start "rule__AssertionOrDefinition__Group_1_2__0" | 8478 | // $ANTLR start "rule__AssertionOrDefinition__Group_1_2__0" |
9266 | // InternalSolverLanguage.g:2539:1: rule__AssertionOrDefinition__Group_1_2__0 : rule__AssertionOrDefinition__Group_1_2__0__Impl rule__AssertionOrDefinition__Group_1_2__1 ; | 8479 | // InternalSolverLanguageParser.g:2618:1: rule__AssertionOrDefinition__Group_1_2__0 : rule__AssertionOrDefinition__Group_1_2__0__Impl rule__AssertionOrDefinition__Group_1_2__1 ; |
9267 | public final void rule__AssertionOrDefinition__Group_1_2__0() throws RecognitionException { | 8480 | public final void rule__AssertionOrDefinition__Group_1_2__0() throws RecognitionException { |
9268 | 8481 | ||
9269 | int stackSize = keepStackSize(); | 8482 | int stackSize = keepStackSize(); |
9270 | 8483 | ||
9271 | try { | 8484 | try { |
9272 | // InternalSolverLanguage.g:2543:1: ( rule__AssertionOrDefinition__Group_1_2__0__Impl rule__AssertionOrDefinition__Group_1_2__1 ) | 8485 | // InternalSolverLanguageParser.g:2622:1: ( rule__AssertionOrDefinition__Group_1_2__0__Impl rule__AssertionOrDefinition__Group_1_2__1 ) |
9273 | // InternalSolverLanguage.g:2544:2: rule__AssertionOrDefinition__Group_1_2__0__Impl rule__AssertionOrDefinition__Group_1_2__1 | 8486 | // InternalSolverLanguageParser.g:2623:2: rule__AssertionOrDefinition__Group_1_2__0__Impl rule__AssertionOrDefinition__Group_1_2__1 |
9274 | { | 8487 | { |
9275 | pushFollow(FOLLOW_5); | 8488 | pushFollow(FOLLOW_5); |
9276 | rule__AssertionOrDefinition__Group_1_2__0__Impl(); | 8489 | rule__AssertionOrDefinition__Group_1_2__0__Impl(); |
9277 | 8490 | ||
9278 | state._fsp--; | 8491 | state._fsp--; |
9279 | if (state.failed) return ; | 8492 | |
9280 | pushFollow(FOLLOW_2); | 8493 | pushFollow(FOLLOW_2); |
9281 | rule__AssertionOrDefinition__Group_1_2__1(); | 8494 | rule__AssertionOrDefinition__Group_1_2__1(); |
9282 | 8495 | ||
9283 | state._fsp--; | 8496 | state._fsp--; |
9284 | if (state.failed) return ; | 8497 | |
9285 | 8498 | ||
9286 | } | 8499 | } |
9287 | 8500 | ||
@@ -9301,29 +8514,25 @@ public class InternalSolverLanguageParser extends AbstractInternalContentAssistP | |||
9301 | 8514 | ||
9302 | 8515 | ||
9303 | // $ANTLR start "rule__AssertionOrDefinition__Group_1_2__0__Impl" | 8516 | // $ANTLR start "rule__AssertionOrDefinition__Group_1_2__0__Impl" |
9304 | // InternalSolverLanguage.g:2551:1: rule__AssertionOrDefinition__Group_1_2__0__Impl : ( () ) ; | 8517 | // InternalSolverLanguageParser.g:2630:1: rule__AssertionOrDefinition__Group_1_2__0__Impl : ( () ) ; |
9305 | public final void rule__AssertionOrDefinition__Group_1_2__0__Impl() throws RecognitionException { | 8518 | public final void rule__AssertionOrDefinition__Group_1_2__0__Impl() throws RecognitionException { |
9306 | 8519 | ||
9307 | int stackSize = keepStackSize(); | 8520 | int stackSize = keepStackSize(); |
9308 | 8521 | ||
9309 | try { | 8522 | try { |
9310 | // InternalSolverLanguage.g:2555:1: ( ( () ) ) | 8523 | // InternalSolverLanguageParser.g:2634:1: ( ( () ) ) |
9311 | // InternalSolverLanguage.g:2556:1: ( () ) | 8524 | // InternalSolverLanguageParser.g:2635:1: ( () ) |
9312 | { | 8525 | { |
9313 | // InternalSolverLanguage.g:2556:1: ( () ) | 8526 | // InternalSolverLanguageParser.g:2635:1: ( () ) |
9314 | // InternalSolverLanguage.g:2557:2: () | 8527 | // InternalSolverLanguageParser.g:2636:2: () |
9315 | { | 8528 | { |
9316 | if ( state.backtracking==0 ) { | 8529 | before(grammarAccess.getAssertionOrDefinitionAccess().getMetricDefinitionHeadAction_1_2_0()); |
9317 | before(grammarAccess.getAssertionOrDefinitionAccess().getMetricDefinitionHeadAction_1_2_0()); | 8530 | // InternalSolverLanguageParser.g:2637:2: () |
9318 | } | 8531 | // InternalSolverLanguageParser.g:2637:3: |
9319 | // InternalSolverLanguage.g:2558:2: () | ||
9320 | // InternalSolverLanguage.g:2558:3: | ||
9321 | { | 8532 | { |
9322 | } | 8533 | } |
9323 | 8534 | ||
9324 | if ( state.backtracking==0 ) { | 8535 | after(grammarAccess.getAssertionOrDefinitionAccess().getMetricDefinitionHeadAction_1_2_0()); |
9325 | after(grammarAccess.getAssertionOrDefinitionAccess().getMetricDefinitionHeadAction_1_2_0()); | ||
9326 | } | ||
9327 | 8536 | ||
9328 | } | 8537 | } |
9329 | 8538 | ||
@@ -9342,25 +8551,25 @@ public class InternalSolverLanguageParser extends AbstractInternalContentAssistP | |||
9342 | 8551 | ||
9343 | 8552 | ||
9344 | // $ANTLR start "rule__AssertionOrDefinition__Group_1_2__1" | 8553 | // $ANTLR start "rule__AssertionOrDefinition__Group_1_2__1" |
9345 | // InternalSolverLanguage.g:2566:1: rule__AssertionOrDefinition__Group_1_2__1 : rule__AssertionOrDefinition__Group_1_2__1__Impl rule__AssertionOrDefinition__Group_1_2__2 ; | 8554 | // InternalSolverLanguageParser.g:2645:1: rule__AssertionOrDefinition__Group_1_2__1 : rule__AssertionOrDefinition__Group_1_2__1__Impl rule__AssertionOrDefinition__Group_1_2__2 ; |
9346 | public final void rule__AssertionOrDefinition__Group_1_2__1() throws RecognitionException { | 8555 | public final void rule__AssertionOrDefinition__Group_1_2__1() throws RecognitionException { |
9347 | 8556 | ||
9348 | int stackSize = keepStackSize(); | 8557 | int stackSize = keepStackSize(); |
9349 | 8558 | ||
9350 | try { | 8559 | try { |
9351 | // InternalSolverLanguage.g:2570:1: ( rule__AssertionOrDefinition__Group_1_2__1__Impl rule__AssertionOrDefinition__Group_1_2__2 ) | 8560 | // InternalSolverLanguageParser.g:2649:1: ( rule__AssertionOrDefinition__Group_1_2__1__Impl rule__AssertionOrDefinition__Group_1_2__2 ) |
9352 | // InternalSolverLanguage.g:2571:2: rule__AssertionOrDefinition__Group_1_2__1__Impl rule__AssertionOrDefinition__Group_1_2__2 | 8561 | // InternalSolverLanguageParser.g:2650:2: rule__AssertionOrDefinition__Group_1_2__1__Impl rule__AssertionOrDefinition__Group_1_2__2 |
9353 | { | 8562 | { |
9354 | pushFollow(FOLLOW_7); | 8563 | pushFollow(FOLLOW_7); |
9355 | rule__AssertionOrDefinition__Group_1_2__1__Impl(); | 8564 | rule__AssertionOrDefinition__Group_1_2__1__Impl(); |
9356 | 8565 | ||
9357 | state._fsp--; | 8566 | state._fsp--; |
9358 | if (state.failed) return ; | 8567 | |
9359 | pushFollow(FOLLOW_2); | 8568 | pushFollow(FOLLOW_2); |
9360 | rule__AssertionOrDefinition__Group_1_2__2(); | 8569 | rule__AssertionOrDefinition__Group_1_2__2(); |
9361 | 8570 | ||
9362 | state._fsp--; | 8571 | state._fsp--; |
9363 | if (state.failed) return ; | 8572 | |
9364 | 8573 | ||
9365 | } | 8574 | } |
9366 | 8575 | ||
@@ -9380,25 +8589,21 @@ public class InternalSolverLanguageParser extends AbstractInternalContentAssistP | |||
9380 | 8589 | ||
9381 | 8590 | ||
9382 | // $ANTLR start "rule__AssertionOrDefinition__Group_1_2__1__Impl" | 8591 | // $ANTLR start "rule__AssertionOrDefinition__Group_1_2__1__Impl" |
9383 | // InternalSolverLanguage.g:2578:1: rule__AssertionOrDefinition__Group_1_2__1__Impl : ( '=' ) ; | 8592 | // InternalSolverLanguageParser.g:2657:1: rule__AssertionOrDefinition__Group_1_2__1__Impl : ( EqualsSign ) ; |
9384 | public final void rule__AssertionOrDefinition__Group_1_2__1__Impl() throws RecognitionException { | 8593 | public final void rule__AssertionOrDefinition__Group_1_2__1__Impl() throws RecognitionException { |
9385 | 8594 | ||
9386 | int stackSize = keepStackSize(); | 8595 | int stackSize = keepStackSize(); |
9387 | 8596 | ||
9388 | try { | 8597 | try { |
9389 | // InternalSolverLanguage.g:2582:1: ( ( '=' ) ) | 8598 | // InternalSolverLanguageParser.g:2661:1: ( ( EqualsSign ) ) |
9390 | // InternalSolverLanguage.g:2583:1: ( '=' ) | 8599 | // InternalSolverLanguageParser.g:2662:1: ( EqualsSign ) |
9391 | { | 8600 | { |
9392 | // InternalSolverLanguage.g:2583:1: ( '=' ) | 8601 | // InternalSolverLanguageParser.g:2662:1: ( EqualsSign ) |
9393 | // InternalSolverLanguage.g:2584:2: '=' | 8602 | // InternalSolverLanguageParser.g:2663:2: EqualsSign |
9394 | { | 8603 | { |
9395 | if ( state.backtracking==0 ) { | 8604 | before(grammarAccess.getAssertionOrDefinitionAccess().getEqualsSignKeyword_1_2_1()); |
9396 | before(grammarAccess.getAssertionOrDefinitionAccess().getEqualsSignKeyword_1_2_1()); | 8605 | match(input,EqualsSign,FOLLOW_2); |
9397 | } | 8606 | after(grammarAccess.getAssertionOrDefinitionAccess().getEqualsSignKeyword_1_2_1()); |
9398 | match(input,47,FOLLOW_2); if (state.failed) return ; | ||
9399 | if ( state.backtracking==0 ) { | ||
9400 | after(grammarAccess.getAssertionOrDefinitionAccess().getEqualsSignKeyword_1_2_1()); | ||
9401 | } | ||
9402 | 8607 | ||
9403 | } | 8608 | } |
9404 | 8609 | ||
@@ -9421,20 +8626,20 @@ public class InternalSolverLanguageParser extends AbstractInternalContentAssistP | |||
9421 | 8626 | ||
9422 | 8627 | ||
9423 | // $ANTLR start "rule__AssertionOrDefinition__Group_1_2__2" | 8628 | // $ANTLR start "rule__AssertionOrDefinition__Group_1_2__2" |
9424 | // InternalSolverLanguage.g:2593:1: rule__AssertionOrDefinition__Group_1_2__2 : rule__AssertionOrDefinition__Group_1_2__2__Impl ; | 8629 | // InternalSolverLanguageParser.g:2672:1: rule__AssertionOrDefinition__Group_1_2__2 : rule__AssertionOrDefinition__Group_1_2__2__Impl ; |
9425 | public final void rule__AssertionOrDefinition__Group_1_2__2() throws RecognitionException { | 8630 | public final void rule__AssertionOrDefinition__Group_1_2__2() throws RecognitionException { |
9426 | 8631 | ||
9427 | int stackSize = keepStackSize(); | 8632 | int stackSize = keepStackSize(); |
9428 | 8633 | ||
9429 | try { | 8634 | try { |
9430 | // InternalSolverLanguage.g:2597:1: ( rule__AssertionOrDefinition__Group_1_2__2__Impl ) | 8635 | // InternalSolverLanguageParser.g:2676:1: ( rule__AssertionOrDefinition__Group_1_2__2__Impl ) |
9431 | // InternalSolverLanguage.g:2598:2: rule__AssertionOrDefinition__Group_1_2__2__Impl | 8636 | // InternalSolverLanguageParser.g:2677:2: rule__AssertionOrDefinition__Group_1_2__2__Impl |
9432 | { | 8637 | { |
9433 | pushFollow(FOLLOW_2); | 8638 | pushFollow(FOLLOW_2); |
9434 | rule__AssertionOrDefinition__Group_1_2__2__Impl(); | 8639 | rule__AssertionOrDefinition__Group_1_2__2__Impl(); |
9435 | 8640 | ||
9436 | state._fsp--; | 8641 | state._fsp--; |
9437 | if (state.failed) return ; | 8642 | |
9438 | 8643 | ||
9439 | } | 8644 | } |
9440 | 8645 | ||
@@ -9454,36 +8659,32 @@ public class InternalSolverLanguageParser extends AbstractInternalContentAssistP | |||
9454 | 8659 | ||
9455 | 8660 | ||
9456 | // $ANTLR start "rule__AssertionOrDefinition__Group_1_2__2__Impl" | 8661 | // $ANTLR start "rule__AssertionOrDefinition__Group_1_2__2__Impl" |
9457 | // InternalSolverLanguage.g:2604:1: rule__AssertionOrDefinition__Group_1_2__2__Impl : ( ( rule__AssertionOrDefinition__BodyAssignment_1_2_2 ) ) ; | 8662 | // InternalSolverLanguageParser.g:2683:1: rule__AssertionOrDefinition__Group_1_2__2__Impl : ( ( rule__AssertionOrDefinition__BodyAssignment_1_2_2 ) ) ; |
9458 | public final void rule__AssertionOrDefinition__Group_1_2__2__Impl() throws RecognitionException { | 8663 | public final void rule__AssertionOrDefinition__Group_1_2__2__Impl() throws RecognitionException { |
9459 | 8664 | ||
9460 | int stackSize = keepStackSize(); | 8665 | int stackSize = keepStackSize(); |
9461 | 8666 | ||
9462 | try { | 8667 | try { |
9463 | // InternalSolverLanguage.g:2608:1: ( ( ( rule__AssertionOrDefinition__BodyAssignment_1_2_2 ) ) ) | 8668 | // InternalSolverLanguageParser.g:2687:1: ( ( ( rule__AssertionOrDefinition__BodyAssignment_1_2_2 ) ) ) |
9464 | // InternalSolverLanguage.g:2609:1: ( ( rule__AssertionOrDefinition__BodyAssignment_1_2_2 ) ) | 8669 | // InternalSolverLanguageParser.g:2688:1: ( ( rule__AssertionOrDefinition__BodyAssignment_1_2_2 ) ) |
9465 | { | 8670 | { |
9466 | // InternalSolverLanguage.g:2609:1: ( ( rule__AssertionOrDefinition__BodyAssignment_1_2_2 ) ) | 8671 | // InternalSolverLanguageParser.g:2688:1: ( ( rule__AssertionOrDefinition__BodyAssignment_1_2_2 ) ) |
9467 | // InternalSolverLanguage.g:2610:2: ( rule__AssertionOrDefinition__BodyAssignment_1_2_2 ) | 8672 | // InternalSolverLanguageParser.g:2689:2: ( rule__AssertionOrDefinition__BodyAssignment_1_2_2 ) |
9468 | { | 8673 | { |
9469 | if ( state.backtracking==0 ) { | 8674 | before(grammarAccess.getAssertionOrDefinitionAccess().getBodyAssignment_1_2_2()); |
9470 | before(grammarAccess.getAssertionOrDefinitionAccess().getBodyAssignment_1_2_2()); | 8675 | // InternalSolverLanguageParser.g:2690:2: ( rule__AssertionOrDefinition__BodyAssignment_1_2_2 ) |
9471 | } | 8676 | // InternalSolverLanguageParser.g:2690:3: rule__AssertionOrDefinition__BodyAssignment_1_2_2 |
9472 | // InternalSolverLanguage.g:2611:2: ( rule__AssertionOrDefinition__BodyAssignment_1_2_2 ) | ||
9473 | // InternalSolverLanguage.g:2611:3: rule__AssertionOrDefinition__BodyAssignment_1_2_2 | ||
9474 | { | 8677 | { |
9475 | pushFollow(FOLLOW_2); | 8678 | pushFollow(FOLLOW_2); |
9476 | rule__AssertionOrDefinition__BodyAssignment_1_2_2(); | 8679 | rule__AssertionOrDefinition__BodyAssignment_1_2_2(); |
9477 | 8680 | ||
9478 | state._fsp--; | 8681 | state._fsp--; |
9479 | if (state.failed) return ; | ||
9480 | 8682 | ||
9481 | } | ||
9482 | 8683 | ||
9483 | if ( state.backtracking==0 ) { | ||
9484 | after(grammarAccess.getAssertionOrDefinitionAccess().getBodyAssignment_1_2_2()); | ||
9485 | } | 8684 | } |
9486 | 8685 | ||
8686 | after(grammarAccess.getAssertionOrDefinitionAccess().getBodyAssignment_1_2_2()); | ||
8687 | |||
9487 | } | 8688 | } |
9488 | 8689 | ||
9489 | 8690 | ||
@@ -9505,25 +8706,25 @@ public class InternalSolverLanguageParser extends AbstractInternalContentAssistP | |||
9505 | 8706 | ||
9506 | 8707 | ||
9507 | // $ANTLR start "rule__PredicateDefinition__Group__0" | 8708 | // $ANTLR start "rule__PredicateDefinition__Group__0" |
9508 | // InternalSolverLanguage.g:2620:1: rule__PredicateDefinition__Group__0 : rule__PredicateDefinition__Group__0__Impl rule__PredicateDefinition__Group__1 ; | 8709 | // InternalSolverLanguageParser.g:2699:1: rule__PredicateDefinition__Group__0 : rule__PredicateDefinition__Group__0__Impl rule__PredicateDefinition__Group__1 ; |
9509 | public final void rule__PredicateDefinition__Group__0() throws RecognitionException { | 8710 | public final void rule__PredicateDefinition__Group__0() throws RecognitionException { |
9510 | 8711 | ||
9511 | int stackSize = keepStackSize(); | 8712 | int stackSize = keepStackSize(); |
9512 | 8713 | ||
9513 | try { | 8714 | try { |
9514 | // InternalSolverLanguage.g:2624:1: ( rule__PredicateDefinition__Group__0__Impl rule__PredicateDefinition__Group__1 ) | 8715 | // InternalSolverLanguageParser.g:2703:1: ( rule__PredicateDefinition__Group__0__Impl rule__PredicateDefinition__Group__1 ) |
9515 | // InternalSolverLanguage.g:2625:2: rule__PredicateDefinition__Group__0__Impl rule__PredicateDefinition__Group__1 | 8716 | // InternalSolverLanguageParser.g:2704:2: rule__PredicateDefinition__Group__0__Impl rule__PredicateDefinition__Group__1 |
9516 | { | 8717 | { |
9517 | pushFollow(FOLLOW_9); | 8718 | pushFollow(FOLLOW_9); |
9518 | rule__PredicateDefinition__Group__0__Impl(); | 8719 | rule__PredicateDefinition__Group__0__Impl(); |
9519 | 8720 | ||
9520 | state._fsp--; | 8721 | state._fsp--; |
9521 | if (state.failed) return ; | 8722 | |
9522 | pushFollow(FOLLOW_2); | 8723 | pushFollow(FOLLOW_2); |
9523 | rule__PredicateDefinition__Group__1(); | 8724 | rule__PredicateDefinition__Group__1(); |
9524 | 8725 | ||
9525 | state._fsp--; | 8726 | state._fsp--; |
9526 | if (state.failed) return ; | 8727 | |
9527 | 8728 | ||
9528 | } | 8729 | } |
9529 | 8730 | ||
@@ -9543,36 +8744,32 @@ public class InternalSolverLanguageParser extends AbstractInternalContentAssistP | |||
9543 | 8744 | ||
9544 | 8745 | ||
9545 | // $ANTLR start "rule__PredicateDefinition__Group__0__Impl" | 8746 | // $ANTLR start "rule__PredicateDefinition__Group__0__Impl" |
9546 | // InternalSolverLanguage.g:2632:1: rule__PredicateDefinition__Group__0__Impl : ( ( rule__PredicateDefinition__Alternatives_0 ) ) ; | 8747 | // InternalSolverLanguageParser.g:2711:1: rule__PredicateDefinition__Group__0__Impl : ( ( rule__PredicateDefinition__Alternatives_0 ) ) ; |
9547 | public final void rule__PredicateDefinition__Group__0__Impl() throws RecognitionException { | 8748 | public final void rule__PredicateDefinition__Group__0__Impl() throws RecognitionException { |
9548 | 8749 | ||
9549 | int stackSize = keepStackSize(); | 8750 | int stackSize = keepStackSize(); |
9550 | 8751 | ||
9551 | try { | 8752 | try { |
9552 | // InternalSolverLanguage.g:2636:1: ( ( ( rule__PredicateDefinition__Alternatives_0 ) ) ) | 8753 | // InternalSolverLanguageParser.g:2715:1: ( ( ( rule__PredicateDefinition__Alternatives_0 ) ) ) |
9553 | // InternalSolverLanguage.g:2637:1: ( ( rule__PredicateDefinition__Alternatives_0 ) ) | 8754 | // InternalSolverLanguageParser.g:2716:1: ( ( rule__PredicateDefinition__Alternatives_0 ) ) |
9554 | { | 8755 | { |
9555 | // InternalSolverLanguage.g:2637:1: ( ( rule__PredicateDefinition__Alternatives_0 ) ) | 8756 | // InternalSolverLanguageParser.g:2716:1: ( ( rule__PredicateDefinition__Alternatives_0 ) ) |
9556 | // InternalSolverLanguage.g:2638:2: ( rule__PredicateDefinition__Alternatives_0 ) | 8757 | // InternalSolverLanguageParser.g:2717:2: ( rule__PredicateDefinition__Alternatives_0 ) |
9557 | { | 8758 | { |
9558 | if ( state.backtracking==0 ) { | 8759 | before(grammarAccess.getPredicateDefinitionAccess().getAlternatives_0()); |
9559 | before(grammarAccess.getPredicateDefinitionAccess().getAlternatives_0()); | 8760 | // InternalSolverLanguageParser.g:2718:2: ( rule__PredicateDefinition__Alternatives_0 ) |
9560 | } | 8761 | // InternalSolverLanguageParser.g:2718:3: rule__PredicateDefinition__Alternatives_0 |
9561 | // InternalSolverLanguage.g:2639:2: ( rule__PredicateDefinition__Alternatives_0 ) | ||
9562 | // InternalSolverLanguage.g:2639:3: rule__PredicateDefinition__Alternatives_0 | ||
9563 | { | 8762 | { |
9564 | pushFollow(FOLLOW_2); | 8763 | pushFollow(FOLLOW_2); |
9565 | rule__PredicateDefinition__Alternatives_0(); | 8764 | rule__PredicateDefinition__Alternatives_0(); |
9566 | 8765 | ||
9567 | state._fsp--; | 8766 | state._fsp--; |
9568 | if (state.failed) return ; | ||
9569 | 8767 | ||
9570 | } | ||
9571 | 8768 | ||
9572 | if ( state.backtracking==0 ) { | ||
9573 | after(grammarAccess.getPredicateDefinitionAccess().getAlternatives_0()); | ||
9574 | } | 8769 | } |
9575 | 8770 | ||
8771 | after(grammarAccess.getPredicateDefinitionAccess().getAlternatives_0()); | ||
8772 | |||
9576 | } | 8773 | } |
9577 | 8774 | ||
9578 | 8775 | ||
@@ -9594,25 +8791,25 @@ public class InternalSolverLanguageParser extends AbstractInternalContentAssistP | |||
9594 | 8791 | ||
9595 | 8792 | ||
9596 | // $ANTLR start "rule__PredicateDefinition__Group__1" | 8793 | // $ANTLR start "rule__PredicateDefinition__Group__1" |
9597 | // InternalSolverLanguage.g:2647:1: rule__PredicateDefinition__Group__1 : rule__PredicateDefinition__Group__1__Impl rule__PredicateDefinition__Group__2 ; | 8794 | // InternalSolverLanguageParser.g:2726:1: rule__PredicateDefinition__Group__1 : rule__PredicateDefinition__Group__1__Impl rule__PredicateDefinition__Group__2 ; |
9598 | public final void rule__PredicateDefinition__Group__1() throws RecognitionException { | 8795 | public final void rule__PredicateDefinition__Group__1() throws RecognitionException { |
9599 | 8796 | ||
9600 | int stackSize = keepStackSize(); | 8797 | int stackSize = keepStackSize(); |
9601 | 8798 | ||
9602 | try { | 8799 | try { |
9603 | // InternalSolverLanguage.g:2651:1: ( rule__PredicateDefinition__Group__1__Impl rule__PredicateDefinition__Group__2 ) | 8800 | // InternalSolverLanguageParser.g:2730:1: ( rule__PredicateDefinition__Group__1__Impl rule__PredicateDefinition__Group__2 ) |
9604 | // InternalSolverLanguage.g:2652:2: rule__PredicateDefinition__Group__1__Impl rule__PredicateDefinition__Group__2 | 8801 | // InternalSolverLanguageParser.g:2731:2: rule__PredicateDefinition__Group__1__Impl rule__PredicateDefinition__Group__2 |
9605 | { | 8802 | { |
9606 | pushFollow(FOLLOW_8); | 8803 | pushFollow(FOLLOW_8); |
9607 | rule__PredicateDefinition__Group__1__Impl(); | 8804 | rule__PredicateDefinition__Group__1__Impl(); |
9608 | 8805 | ||
9609 | state._fsp--; | 8806 | state._fsp--; |
9610 | if (state.failed) return ; | 8807 | |
9611 | pushFollow(FOLLOW_2); | 8808 | pushFollow(FOLLOW_2); |
9612 | rule__PredicateDefinition__Group__2(); | 8809 | rule__PredicateDefinition__Group__2(); |
9613 | 8810 | ||
9614 | state._fsp--; | 8811 | state._fsp--; |
9615 | if (state.failed) return ; | 8812 | |
9616 | 8813 | ||
9617 | } | 8814 | } |
9618 | 8815 | ||
@@ -9632,36 +8829,32 @@ public class InternalSolverLanguageParser extends AbstractInternalContentAssistP | |||
9632 | 8829 | ||
9633 | 8830 | ||
9634 | // $ANTLR start "rule__PredicateDefinition__Group__1__Impl" | 8831 | // $ANTLR start "rule__PredicateDefinition__Group__1__Impl" |
9635 | // InternalSolverLanguage.g:2659:1: rule__PredicateDefinition__Group__1__Impl : ( ( rule__PredicateDefinition__HeadAssignment_1 ) ) ; | 8832 | // InternalSolverLanguageParser.g:2738:1: rule__PredicateDefinition__Group__1__Impl : ( ( rule__PredicateDefinition__HeadAssignment_1 ) ) ; |
9636 | public final void rule__PredicateDefinition__Group__1__Impl() throws RecognitionException { | 8833 | public final void rule__PredicateDefinition__Group__1__Impl() throws RecognitionException { |
9637 | 8834 | ||
9638 | int stackSize = keepStackSize(); | 8835 | int stackSize = keepStackSize(); |
9639 | 8836 | ||
9640 | try { | 8837 | try { |
9641 | // InternalSolverLanguage.g:2663:1: ( ( ( rule__PredicateDefinition__HeadAssignment_1 ) ) ) | 8838 | // InternalSolverLanguageParser.g:2742:1: ( ( ( rule__PredicateDefinition__HeadAssignment_1 ) ) ) |
9642 | // InternalSolverLanguage.g:2664:1: ( ( rule__PredicateDefinition__HeadAssignment_1 ) ) | 8839 | // InternalSolverLanguageParser.g:2743:1: ( ( rule__PredicateDefinition__HeadAssignment_1 ) ) |
9643 | { | 8840 | { |
9644 | // InternalSolverLanguage.g:2664:1: ( ( rule__PredicateDefinition__HeadAssignment_1 ) ) | 8841 | // InternalSolverLanguageParser.g:2743:1: ( ( rule__PredicateDefinition__HeadAssignment_1 ) ) |
9645 | // InternalSolverLanguage.g:2665:2: ( rule__PredicateDefinition__HeadAssignment_1 ) | 8842 | // InternalSolverLanguageParser.g:2744:2: ( rule__PredicateDefinition__HeadAssignment_1 ) |
9646 | { | 8843 | { |
9647 | if ( state.backtracking==0 ) { | 8844 | before(grammarAccess.getPredicateDefinitionAccess().getHeadAssignment_1()); |
9648 | before(grammarAccess.getPredicateDefinitionAccess().getHeadAssignment_1()); | 8845 | // InternalSolverLanguageParser.g:2745:2: ( rule__PredicateDefinition__HeadAssignment_1 ) |
9649 | } | 8846 | // InternalSolverLanguageParser.g:2745:3: rule__PredicateDefinition__HeadAssignment_1 |
9650 | // InternalSolverLanguage.g:2666:2: ( rule__PredicateDefinition__HeadAssignment_1 ) | ||
9651 | // InternalSolverLanguage.g:2666:3: rule__PredicateDefinition__HeadAssignment_1 | ||
9652 | { | 8847 | { |
9653 | pushFollow(FOLLOW_2); | 8848 | pushFollow(FOLLOW_2); |
9654 | rule__PredicateDefinition__HeadAssignment_1(); | 8849 | rule__PredicateDefinition__HeadAssignment_1(); |
9655 | 8850 | ||
9656 | state._fsp--; | 8851 | state._fsp--; |
9657 | if (state.failed) return ; | ||
9658 | 8852 | ||
9659 | } | ||
9660 | 8853 | ||
9661 | if ( state.backtracking==0 ) { | ||
9662 | after(grammarAccess.getPredicateDefinitionAccess().getHeadAssignment_1()); | ||
9663 | } | 8854 | } |
9664 | 8855 | ||
8856 | after(grammarAccess.getPredicateDefinitionAccess().getHeadAssignment_1()); | ||
8857 | |||
9665 | } | 8858 | } |
9666 | 8859 | ||
9667 | 8860 | ||
@@ -9683,25 +8876,25 @@ public class InternalSolverLanguageParser extends AbstractInternalContentAssistP | |||
9683 | 8876 | ||
9684 | 8877 | ||
9685 | // $ANTLR start "rule__PredicateDefinition__Group__2" | 8878 | // $ANTLR start "rule__PredicateDefinition__Group__2" |
9686 | // InternalSolverLanguage.g:2674:1: rule__PredicateDefinition__Group__2 : rule__PredicateDefinition__Group__2__Impl rule__PredicateDefinition__Group__3 ; | 8879 | // InternalSolverLanguageParser.g:2753:1: rule__PredicateDefinition__Group__2 : rule__PredicateDefinition__Group__2__Impl rule__PredicateDefinition__Group__3 ; |
9687 | public final void rule__PredicateDefinition__Group__2() throws RecognitionException { | 8880 | public final void rule__PredicateDefinition__Group__2() throws RecognitionException { |
9688 | 8881 | ||
9689 | int stackSize = keepStackSize(); | 8882 | int stackSize = keepStackSize(); |
9690 | 8883 | ||
9691 | try { | 8884 | try { |
9692 | // InternalSolverLanguage.g:2678:1: ( rule__PredicateDefinition__Group__2__Impl rule__PredicateDefinition__Group__3 ) | 8885 | // InternalSolverLanguageParser.g:2757:1: ( rule__PredicateDefinition__Group__2__Impl rule__PredicateDefinition__Group__3 ) |
9693 | // InternalSolverLanguage.g:2679:2: rule__PredicateDefinition__Group__2__Impl rule__PredicateDefinition__Group__3 | 8886 | // InternalSolverLanguageParser.g:2758:2: rule__PredicateDefinition__Group__2__Impl rule__PredicateDefinition__Group__3 |
9694 | { | 8887 | { |
9695 | pushFollow(FOLLOW_7); | 8888 | pushFollow(FOLLOW_7); |
9696 | rule__PredicateDefinition__Group__2__Impl(); | 8889 | rule__PredicateDefinition__Group__2__Impl(); |
9697 | 8890 | ||
9698 | state._fsp--; | 8891 | state._fsp--; |
9699 | if (state.failed) return ; | 8892 | |
9700 | pushFollow(FOLLOW_2); | 8893 | pushFollow(FOLLOW_2); |
9701 | rule__PredicateDefinition__Group__3(); | 8894 | rule__PredicateDefinition__Group__3(); |
9702 | 8895 | ||
9703 | state._fsp--; | 8896 | state._fsp--; |
9704 | if (state.failed) return ; | 8897 | |
9705 | 8898 | ||
9706 | } | 8899 | } |
9707 | 8900 | ||
@@ -9721,25 +8914,21 @@ public class InternalSolverLanguageParser extends AbstractInternalContentAssistP | |||
9721 | 8914 | ||
9722 | 8915 | ||
9723 | // $ANTLR start "rule__PredicateDefinition__Group__2__Impl" | 8916 | // $ANTLR start "rule__PredicateDefinition__Group__2__Impl" |
9724 | // InternalSolverLanguage.g:2686:1: rule__PredicateDefinition__Group__2__Impl : ( ':-' ) ; | 8917 | // InternalSolverLanguageParser.g:2765:1: rule__PredicateDefinition__Group__2__Impl : ( ColonHyphenMinus ) ; |
9725 | public final void rule__PredicateDefinition__Group__2__Impl() throws RecognitionException { | 8918 | public final void rule__PredicateDefinition__Group__2__Impl() throws RecognitionException { |
9726 | 8919 | ||
9727 | int stackSize = keepStackSize(); | 8920 | int stackSize = keepStackSize(); |
9728 | 8921 | ||
9729 | try { | 8922 | try { |
9730 | // InternalSolverLanguage.g:2690:1: ( ( ':-' ) ) | 8923 | // InternalSolverLanguageParser.g:2769:1: ( ( ColonHyphenMinus ) ) |
9731 | // InternalSolverLanguage.g:2691:1: ( ':-' ) | 8924 | // InternalSolverLanguageParser.g:2770:1: ( ColonHyphenMinus ) |
9732 | { | 8925 | { |
9733 | // InternalSolverLanguage.g:2691:1: ( ':-' ) | 8926 | // InternalSolverLanguageParser.g:2770:1: ( ColonHyphenMinus ) |
9734 | // InternalSolverLanguage.g:2692:2: ':-' | 8927 | // InternalSolverLanguageParser.g:2771:2: ColonHyphenMinus |
9735 | { | 8928 | { |
9736 | if ( state.backtracking==0 ) { | 8929 | before(grammarAccess.getPredicateDefinitionAccess().getColonHyphenMinusKeyword_2()); |
9737 | before(grammarAccess.getPredicateDefinitionAccess().getColonHyphenMinusKeyword_2()); | 8930 | match(input,ColonHyphenMinus,FOLLOW_2); |
9738 | } | 8931 | after(grammarAccess.getPredicateDefinitionAccess().getColonHyphenMinusKeyword_2()); |
9739 | match(input,46,FOLLOW_2); if (state.failed) return ; | ||
9740 | if ( state.backtracking==0 ) { | ||
9741 | after(grammarAccess.getPredicateDefinitionAccess().getColonHyphenMinusKeyword_2()); | ||
9742 | } | ||
9743 | 8932 | ||
9744 | } | 8933 | } |
9745 | 8934 | ||
@@ -9762,20 +8951,20 @@ public class InternalSolverLanguageParser extends AbstractInternalContentAssistP | |||
9762 | 8951 | ||
9763 | 8952 | ||
9764 | // $ANTLR start "rule__PredicateDefinition__Group__3" | 8953 | // $ANTLR start "rule__PredicateDefinition__Group__3" |
9765 | // InternalSolverLanguage.g:2701:1: rule__PredicateDefinition__Group__3 : rule__PredicateDefinition__Group__3__Impl ; | 8954 | // InternalSolverLanguageParser.g:2780:1: rule__PredicateDefinition__Group__3 : rule__PredicateDefinition__Group__3__Impl ; |
9766 | public final void rule__PredicateDefinition__Group__3() throws RecognitionException { | 8955 | public final void rule__PredicateDefinition__Group__3() throws RecognitionException { |
9767 | 8956 | ||
9768 | int stackSize = keepStackSize(); | 8957 | int stackSize = keepStackSize(); |
9769 | 8958 | ||
9770 | try { | 8959 | try { |
9771 | // InternalSolverLanguage.g:2705:1: ( rule__PredicateDefinition__Group__3__Impl ) | 8960 | // InternalSolverLanguageParser.g:2784:1: ( rule__PredicateDefinition__Group__3__Impl ) |
9772 | // InternalSolverLanguage.g:2706:2: rule__PredicateDefinition__Group__3__Impl | 8961 | // InternalSolverLanguageParser.g:2785:2: rule__PredicateDefinition__Group__3__Impl |
9773 | { | 8962 | { |
9774 | pushFollow(FOLLOW_2); | 8963 | pushFollow(FOLLOW_2); |
9775 | rule__PredicateDefinition__Group__3__Impl(); | 8964 | rule__PredicateDefinition__Group__3__Impl(); |
9776 | 8965 | ||
9777 | state._fsp--; | 8966 | state._fsp--; |
9778 | if (state.failed) return ; | 8967 | |
9779 | 8968 | ||
9780 | } | 8969 | } |
9781 | 8970 | ||
@@ -9795,36 +8984,32 @@ public class InternalSolverLanguageParser extends AbstractInternalContentAssistP | |||
9795 | 8984 | ||
9796 | 8985 | ||
9797 | // $ANTLR start "rule__PredicateDefinition__Group__3__Impl" | 8986 | // $ANTLR start "rule__PredicateDefinition__Group__3__Impl" |
9798 | // InternalSolverLanguage.g:2712:1: rule__PredicateDefinition__Group__3__Impl : ( ( rule__PredicateDefinition__BodyAssignment_3 ) ) ; | 8987 | // InternalSolverLanguageParser.g:2791:1: rule__PredicateDefinition__Group__3__Impl : ( ( rule__PredicateDefinition__BodyAssignment_3 ) ) ; |
9799 | public final void rule__PredicateDefinition__Group__3__Impl() throws RecognitionException { | 8988 | public final void rule__PredicateDefinition__Group__3__Impl() throws RecognitionException { |
9800 | 8989 | ||
9801 | int stackSize = keepStackSize(); | 8990 | int stackSize = keepStackSize(); |
9802 | 8991 | ||
9803 | try { | 8992 | try { |
9804 | // InternalSolverLanguage.g:2716:1: ( ( ( rule__PredicateDefinition__BodyAssignment_3 ) ) ) | 8993 | // InternalSolverLanguageParser.g:2795:1: ( ( ( rule__PredicateDefinition__BodyAssignment_3 ) ) ) |
9805 | // InternalSolverLanguage.g:2717:1: ( ( rule__PredicateDefinition__BodyAssignment_3 ) ) | 8994 | // InternalSolverLanguageParser.g:2796:1: ( ( rule__PredicateDefinition__BodyAssignment_3 ) ) |
9806 | { | 8995 | { |
9807 | // InternalSolverLanguage.g:2717:1: ( ( rule__PredicateDefinition__BodyAssignment_3 ) ) | 8996 | // InternalSolverLanguageParser.g:2796:1: ( ( rule__PredicateDefinition__BodyAssignment_3 ) ) |
9808 | // InternalSolverLanguage.g:2718:2: ( rule__PredicateDefinition__BodyAssignment_3 ) | 8997 | // InternalSolverLanguageParser.g:2797:2: ( rule__PredicateDefinition__BodyAssignment_3 ) |
9809 | { | 8998 | { |
9810 | if ( state.backtracking==0 ) { | 8999 | before(grammarAccess.getPredicateDefinitionAccess().getBodyAssignment_3()); |
9811 | before(grammarAccess.getPredicateDefinitionAccess().getBodyAssignment_3()); | 9000 | // InternalSolverLanguageParser.g:2798:2: ( rule__PredicateDefinition__BodyAssignment_3 ) |
9812 | } | 9001 | // InternalSolverLanguageParser.g:2798:3: rule__PredicateDefinition__BodyAssignment_3 |
9813 | // InternalSolverLanguage.g:2719:2: ( rule__PredicateDefinition__BodyAssignment_3 ) | ||
9814 | // InternalSolverLanguage.g:2719:3: rule__PredicateDefinition__BodyAssignment_3 | ||
9815 | { | 9002 | { |
9816 | pushFollow(FOLLOW_2); | 9003 | pushFollow(FOLLOW_2); |
9817 | rule__PredicateDefinition__BodyAssignment_3(); | 9004 | rule__PredicateDefinition__BodyAssignment_3(); |
9818 | 9005 | ||
9819 | state._fsp--; | 9006 | state._fsp--; |
9820 | if (state.failed) return ; | ||
9821 | 9007 | ||
9822 | } | ||
9823 | 9008 | ||
9824 | if ( state.backtracking==0 ) { | ||
9825 | after(grammarAccess.getPredicateDefinitionAccess().getBodyAssignment_3()); | ||
9826 | } | 9009 | } |
9827 | 9010 | ||
9011 | after(grammarAccess.getPredicateDefinitionAccess().getBodyAssignment_3()); | ||
9012 | |||
9828 | } | 9013 | } |
9829 | 9014 | ||
9830 | 9015 | ||
@@ -9846,25 +9031,25 @@ public class InternalSolverLanguageParser extends AbstractInternalContentAssistP | |||
9846 | 9031 | ||
9847 | 9032 | ||
9848 | // $ANTLR start "rule__PredicateDefinition__Group_0_0__0" | 9033 | // $ANTLR start "rule__PredicateDefinition__Group_0_0__0" |
9849 | // InternalSolverLanguage.g:2728:1: rule__PredicateDefinition__Group_0_0__0 : rule__PredicateDefinition__Group_0_0__0__Impl rule__PredicateDefinition__Group_0_0__1 ; | 9034 | // InternalSolverLanguageParser.g:2807:1: rule__PredicateDefinition__Group_0_0__0 : rule__PredicateDefinition__Group_0_0__0__Impl rule__PredicateDefinition__Group_0_0__1 ; |
9850 | public final void rule__PredicateDefinition__Group_0_0__0() throws RecognitionException { | 9035 | public final void rule__PredicateDefinition__Group_0_0__0() throws RecognitionException { |
9851 | 9036 | ||
9852 | int stackSize = keepStackSize(); | 9037 | int stackSize = keepStackSize(); |
9853 | 9038 | ||
9854 | try { | 9039 | try { |
9855 | // InternalSolverLanguage.g:2732:1: ( rule__PredicateDefinition__Group_0_0__0__Impl rule__PredicateDefinition__Group_0_0__1 ) | 9040 | // InternalSolverLanguageParser.g:2811:1: ( rule__PredicateDefinition__Group_0_0__0__Impl rule__PredicateDefinition__Group_0_0__1 ) |
9856 | // InternalSolverLanguage.g:2733:2: rule__PredicateDefinition__Group_0_0__0__Impl rule__PredicateDefinition__Group_0_0__1 | 9041 | // InternalSolverLanguageParser.g:2812:2: rule__PredicateDefinition__Group_0_0__0__Impl rule__PredicateDefinition__Group_0_0__1 |
9857 | { | 9042 | { |
9858 | pushFollow(FOLLOW_10); | 9043 | pushFollow(FOLLOW_10); |
9859 | rule__PredicateDefinition__Group_0_0__0__Impl(); | 9044 | rule__PredicateDefinition__Group_0_0__0__Impl(); |
9860 | 9045 | ||
9861 | state._fsp--; | 9046 | state._fsp--; |
9862 | if (state.failed) return ; | 9047 | |
9863 | pushFollow(FOLLOW_2); | 9048 | pushFollow(FOLLOW_2); |
9864 | rule__PredicateDefinition__Group_0_0__1(); | 9049 | rule__PredicateDefinition__Group_0_0__1(); |
9865 | 9050 | ||
9866 | state._fsp--; | 9051 | state._fsp--; |
9867 | if (state.failed) return ; | 9052 | |
9868 | 9053 | ||
9869 | } | 9054 | } |
9870 | 9055 | ||
@@ -9884,36 +9069,32 @@ public class InternalSolverLanguageParser extends AbstractInternalContentAssistP | |||
9884 | 9069 | ||
9885 | 9070 | ||
9886 | // $ANTLR start "rule__PredicateDefinition__Group_0_0__0__Impl" | 9071 | // $ANTLR start "rule__PredicateDefinition__Group_0_0__0__Impl" |
9887 | // InternalSolverLanguage.g:2740:1: rule__PredicateDefinition__Group_0_0__0__Impl : ( ( rule__PredicateDefinition__FunctionalAssignment_0_0_0 ) ) ; | 9072 | // InternalSolverLanguageParser.g:2819:1: rule__PredicateDefinition__Group_0_0__0__Impl : ( ( rule__PredicateDefinition__FunctionalAssignment_0_0_0 ) ) ; |
9888 | public final void rule__PredicateDefinition__Group_0_0__0__Impl() throws RecognitionException { | 9073 | public final void rule__PredicateDefinition__Group_0_0__0__Impl() throws RecognitionException { |
9889 | 9074 | ||
9890 | int stackSize = keepStackSize(); | 9075 | int stackSize = keepStackSize(); |
9891 | 9076 | ||
9892 | try { | 9077 | try { |
9893 | // InternalSolverLanguage.g:2744:1: ( ( ( rule__PredicateDefinition__FunctionalAssignment_0_0_0 ) ) ) | 9078 | // InternalSolverLanguageParser.g:2823:1: ( ( ( rule__PredicateDefinition__FunctionalAssignment_0_0_0 ) ) ) |
9894 | // InternalSolverLanguage.g:2745:1: ( ( rule__PredicateDefinition__FunctionalAssignment_0_0_0 ) ) | 9079 | // InternalSolverLanguageParser.g:2824:1: ( ( rule__PredicateDefinition__FunctionalAssignment_0_0_0 ) ) |
9895 | { | 9080 | { |
9896 | // InternalSolverLanguage.g:2745:1: ( ( rule__PredicateDefinition__FunctionalAssignment_0_0_0 ) ) | 9081 | // InternalSolverLanguageParser.g:2824:1: ( ( rule__PredicateDefinition__FunctionalAssignment_0_0_0 ) ) |
9897 | // InternalSolverLanguage.g:2746:2: ( rule__PredicateDefinition__FunctionalAssignment_0_0_0 ) | 9082 | // InternalSolverLanguageParser.g:2825:2: ( rule__PredicateDefinition__FunctionalAssignment_0_0_0 ) |
9898 | { | 9083 | { |
9899 | if ( state.backtracking==0 ) { | 9084 | before(grammarAccess.getPredicateDefinitionAccess().getFunctionalAssignment_0_0_0()); |
9900 | before(grammarAccess.getPredicateDefinitionAccess().getFunctionalAssignment_0_0_0()); | 9085 | // InternalSolverLanguageParser.g:2826:2: ( rule__PredicateDefinition__FunctionalAssignment_0_0_0 ) |
9901 | } | 9086 | // InternalSolverLanguageParser.g:2826:3: rule__PredicateDefinition__FunctionalAssignment_0_0_0 |
9902 | // InternalSolverLanguage.g:2747:2: ( rule__PredicateDefinition__FunctionalAssignment_0_0_0 ) | ||
9903 | // InternalSolverLanguage.g:2747:3: rule__PredicateDefinition__FunctionalAssignment_0_0_0 | ||
9904 | { | 9087 | { |
9905 | pushFollow(FOLLOW_2); | 9088 | pushFollow(FOLLOW_2); |
9906 | rule__PredicateDefinition__FunctionalAssignment_0_0_0(); | 9089 | rule__PredicateDefinition__FunctionalAssignment_0_0_0(); |
9907 | 9090 | ||
9908 | state._fsp--; | 9091 | state._fsp--; |
9909 | if (state.failed) return ; | ||
9910 | 9092 | ||
9911 | } | ||
9912 | 9093 | ||
9913 | if ( state.backtracking==0 ) { | ||
9914 | after(grammarAccess.getPredicateDefinitionAccess().getFunctionalAssignment_0_0_0()); | ||
9915 | } | 9094 | } |
9916 | 9095 | ||
9096 | after(grammarAccess.getPredicateDefinitionAccess().getFunctionalAssignment_0_0_0()); | ||
9097 | |||
9917 | } | 9098 | } |
9918 | 9099 | ||
9919 | 9100 | ||
@@ -9935,20 +9116,20 @@ public class InternalSolverLanguageParser extends AbstractInternalContentAssistP | |||
9935 | 9116 | ||
9936 | 9117 | ||
9937 | // $ANTLR start "rule__PredicateDefinition__Group_0_0__1" | 9118 | // $ANTLR start "rule__PredicateDefinition__Group_0_0__1" |
9938 | // InternalSolverLanguage.g:2755:1: rule__PredicateDefinition__Group_0_0__1 : rule__PredicateDefinition__Group_0_0__1__Impl ; | 9119 | // InternalSolverLanguageParser.g:2834:1: rule__PredicateDefinition__Group_0_0__1 : rule__PredicateDefinition__Group_0_0__1__Impl ; |
9939 | public final void rule__PredicateDefinition__Group_0_0__1() throws RecognitionException { | 9120 | public final void rule__PredicateDefinition__Group_0_0__1() throws RecognitionException { |
9940 | 9121 | ||
9941 | int stackSize = keepStackSize(); | 9122 | int stackSize = keepStackSize(); |
9942 | 9123 | ||
9943 | try { | 9124 | try { |
9944 | // InternalSolverLanguage.g:2759:1: ( rule__PredicateDefinition__Group_0_0__1__Impl ) | 9125 | // InternalSolverLanguageParser.g:2838:1: ( rule__PredicateDefinition__Group_0_0__1__Impl ) |
9945 | // InternalSolverLanguage.g:2760:2: rule__PredicateDefinition__Group_0_0__1__Impl | 9126 | // InternalSolverLanguageParser.g:2839:2: rule__PredicateDefinition__Group_0_0__1__Impl |
9946 | { | 9127 | { |
9947 | pushFollow(FOLLOW_2); | 9128 | pushFollow(FOLLOW_2); |
9948 | rule__PredicateDefinition__Group_0_0__1__Impl(); | 9129 | rule__PredicateDefinition__Group_0_0__1__Impl(); |
9949 | 9130 | ||
9950 | state._fsp--; | 9131 | state._fsp--; |
9951 | if (state.failed) return ; | 9132 | |
9952 | 9133 | ||
9953 | } | 9134 | } |
9954 | 9135 | ||
@@ -9968,46 +9149,42 @@ public class InternalSolverLanguageParser extends AbstractInternalContentAssistP | |||
9968 | 9149 | ||
9969 | 9150 | ||
9970 | // $ANTLR start "rule__PredicateDefinition__Group_0_0__1__Impl" | 9151 | // $ANTLR start "rule__PredicateDefinition__Group_0_0__1__Impl" |
9971 | // InternalSolverLanguage.g:2766:1: rule__PredicateDefinition__Group_0_0__1__Impl : ( ( rule__PredicateDefinition__ErrorAssignment_0_0_1 )? ) ; | 9152 | // InternalSolverLanguageParser.g:2845:1: rule__PredicateDefinition__Group_0_0__1__Impl : ( ( rule__PredicateDefinition__ErrorAssignment_0_0_1 )? ) ; |
9972 | public final void rule__PredicateDefinition__Group_0_0__1__Impl() throws RecognitionException { | 9153 | public final void rule__PredicateDefinition__Group_0_0__1__Impl() throws RecognitionException { |
9973 | 9154 | ||
9974 | int stackSize = keepStackSize(); | 9155 | int stackSize = keepStackSize(); |
9975 | 9156 | ||
9976 | try { | 9157 | try { |
9977 | // InternalSolverLanguage.g:2770:1: ( ( ( rule__PredicateDefinition__ErrorAssignment_0_0_1 )? ) ) | 9158 | // InternalSolverLanguageParser.g:2849:1: ( ( ( rule__PredicateDefinition__ErrorAssignment_0_0_1 )? ) ) |
9978 | // InternalSolverLanguage.g:2771:1: ( ( rule__PredicateDefinition__ErrorAssignment_0_0_1 )? ) | 9159 | // InternalSolverLanguageParser.g:2850:1: ( ( rule__PredicateDefinition__ErrorAssignment_0_0_1 )? ) |
9979 | { | 9160 | { |
9980 | // InternalSolverLanguage.g:2771:1: ( ( rule__PredicateDefinition__ErrorAssignment_0_0_1 )? ) | 9161 | // InternalSolverLanguageParser.g:2850:1: ( ( rule__PredicateDefinition__ErrorAssignment_0_0_1 )? ) |
9981 | // InternalSolverLanguage.g:2772:2: ( rule__PredicateDefinition__ErrorAssignment_0_0_1 )? | 9162 | // InternalSolverLanguageParser.g:2851:2: ( rule__PredicateDefinition__ErrorAssignment_0_0_1 )? |
9982 | { | 9163 | { |
9983 | if ( state.backtracking==0 ) { | 9164 | before(grammarAccess.getPredicateDefinitionAccess().getErrorAssignment_0_0_1()); |
9984 | before(grammarAccess.getPredicateDefinitionAccess().getErrorAssignment_0_0_1()); | 9165 | // InternalSolverLanguageParser.g:2852:2: ( rule__PredicateDefinition__ErrorAssignment_0_0_1 )? |
9985 | } | ||
9986 | // InternalSolverLanguage.g:2773:2: ( rule__PredicateDefinition__ErrorAssignment_0_0_1 )? | ||
9987 | int alt28=2; | 9166 | int alt28=2; |
9988 | int LA28_0 = input.LA(1); | 9167 | int LA28_0 = input.LA(1); |
9989 | 9168 | ||
9990 | if ( (LA28_0==42) ) { | 9169 | if ( (LA28_0==Error) ) { |
9991 | alt28=1; | 9170 | alt28=1; |
9992 | } | 9171 | } |
9993 | switch (alt28) { | 9172 | switch (alt28) { |
9994 | case 1 : | 9173 | case 1 : |
9995 | // InternalSolverLanguage.g:2773:3: rule__PredicateDefinition__ErrorAssignment_0_0_1 | 9174 | // InternalSolverLanguageParser.g:2852:3: rule__PredicateDefinition__ErrorAssignment_0_0_1 |
9996 | { | 9175 | { |
9997 | pushFollow(FOLLOW_2); | 9176 | pushFollow(FOLLOW_2); |
9998 | rule__PredicateDefinition__ErrorAssignment_0_0_1(); | 9177 | rule__PredicateDefinition__ErrorAssignment_0_0_1(); |
9999 | 9178 | ||
10000 | state._fsp--; | 9179 | state._fsp--; |
10001 | if (state.failed) return ; | 9180 | |
10002 | 9181 | ||
10003 | } | 9182 | } |
10004 | break; | 9183 | break; |
10005 | 9184 | ||
10006 | } | 9185 | } |
10007 | 9186 | ||
10008 | if ( state.backtracking==0 ) { | 9187 | after(grammarAccess.getPredicateDefinitionAccess().getErrorAssignment_0_0_1()); |
10009 | after(grammarAccess.getPredicateDefinitionAccess().getErrorAssignment_0_0_1()); | ||
10010 | } | ||
10011 | 9188 | ||
10012 | } | 9189 | } |
10013 | 9190 | ||
@@ -10030,25 +9207,25 @@ public class InternalSolverLanguageParser extends AbstractInternalContentAssistP | |||
10030 | 9207 | ||
10031 | 9208 | ||
10032 | // $ANTLR start "rule__PredicateDefinition__Group_0_1__0" | 9209 | // $ANTLR start "rule__PredicateDefinition__Group_0_1__0" |
10033 | // InternalSolverLanguage.g:2782:1: rule__PredicateDefinition__Group_0_1__0 : rule__PredicateDefinition__Group_0_1__0__Impl rule__PredicateDefinition__Group_0_1__1 ; | 9210 | // InternalSolverLanguageParser.g:2861:1: rule__PredicateDefinition__Group_0_1__0 : rule__PredicateDefinition__Group_0_1__0__Impl rule__PredicateDefinition__Group_0_1__1 ; |
10034 | public final void rule__PredicateDefinition__Group_0_1__0() throws RecognitionException { | 9211 | public final void rule__PredicateDefinition__Group_0_1__0() throws RecognitionException { |
10035 | 9212 | ||
10036 | int stackSize = keepStackSize(); | 9213 | int stackSize = keepStackSize(); |
10037 | 9214 | ||
10038 | try { | 9215 | try { |
10039 | // InternalSolverLanguage.g:2786:1: ( rule__PredicateDefinition__Group_0_1__0__Impl rule__PredicateDefinition__Group_0_1__1 ) | 9216 | // InternalSolverLanguageParser.g:2865:1: ( rule__PredicateDefinition__Group_0_1__0__Impl rule__PredicateDefinition__Group_0_1__1 ) |
10040 | // InternalSolverLanguage.g:2787:2: rule__PredicateDefinition__Group_0_1__0__Impl rule__PredicateDefinition__Group_0_1__1 | 9217 | // InternalSolverLanguageParser.g:2866:2: rule__PredicateDefinition__Group_0_1__0__Impl rule__PredicateDefinition__Group_0_1__1 |
10041 | { | 9218 | { |
10042 | pushFollow(FOLLOW_11); | 9219 | pushFollow(FOLLOW_11); |
10043 | rule__PredicateDefinition__Group_0_1__0__Impl(); | 9220 | rule__PredicateDefinition__Group_0_1__0__Impl(); |
10044 | 9221 | ||
10045 | state._fsp--; | 9222 | state._fsp--; |
10046 | if (state.failed) return ; | 9223 | |
10047 | pushFollow(FOLLOW_2); | 9224 | pushFollow(FOLLOW_2); |
10048 | rule__PredicateDefinition__Group_0_1__1(); | 9225 | rule__PredicateDefinition__Group_0_1__1(); |
10049 | 9226 | ||
10050 | state._fsp--; | 9227 | state._fsp--; |
10051 | if (state.failed) return ; | 9228 | |
10052 | 9229 | ||
10053 | } | 9230 | } |
10054 | 9231 | ||
@@ -10068,36 +9245,32 @@ public class InternalSolverLanguageParser extends AbstractInternalContentAssistP | |||
10068 | 9245 | ||
10069 | 9246 | ||
10070 | // $ANTLR start "rule__PredicateDefinition__Group_0_1__0__Impl" | 9247 | // $ANTLR start "rule__PredicateDefinition__Group_0_1__0__Impl" |
10071 | // InternalSolverLanguage.g:2794:1: rule__PredicateDefinition__Group_0_1__0__Impl : ( ( rule__PredicateDefinition__ErrorAssignment_0_1_0 ) ) ; | 9248 | // InternalSolverLanguageParser.g:2873:1: rule__PredicateDefinition__Group_0_1__0__Impl : ( ( rule__PredicateDefinition__ErrorAssignment_0_1_0 ) ) ; |
10072 | public final void rule__PredicateDefinition__Group_0_1__0__Impl() throws RecognitionException { | 9249 | public final void rule__PredicateDefinition__Group_0_1__0__Impl() throws RecognitionException { |
10073 | 9250 | ||
10074 | int stackSize = keepStackSize(); | 9251 | int stackSize = keepStackSize(); |
10075 | 9252 | ||
10076 | try { | 9253 | try { |
10077 | // InternalSolverLanguage.g:2798:1: ( ( ( rule__PredicateDefinition__ErrorAssignment_0_1_0 ) ) ) | 9254 | // InternalSolverLanguageParser.g:2877:1: ( ( ( rule__PredicateDefinition__ErrorAssignment_0_1_0 ) ) ) |
10078 | // InternalSolverLanguage.g:2799:1: ( ( rule__PredicateDefinition__ErrorAssignment_0_1_0 ) ) | 9255 | // InternalSolverLanguageParser.g:2878:1: ( ( rule__PredicateDefinition__ErrorAssignment_0_1_0 ) ) |
10079 | { | 9256 | { |
10080 | // InternalSolverLanguage.g:2799:1: ( ( rule__PredicateDefinition__ErrorAssignment_0_1_0 ) ) | 9257 | // InternalSolverLanguageParser.g:2878:1: ( ( rule__PredicateDefinition__ErrorAssignment_0_1_0 ) ) |
10081 | // InternalSolverLanguage.g:2800:2: ( rule__PredicateDefinition__ErrorAssignment_0_1_0 ) | 9258 | // InternalSolverLanguageParser.g:2879:2: ( rule__PredicateDefinition__ErrorAssignment_0_1_0 ) |
10082 | { | 9259 | { |
10083 | if ( state.backtracking==0 ) { | 9260 | before(grammarAccess.getPredicateDefinitionAccess().getErrorAssignment_0_1_0()); |
10084 | before(grammarAccess.getPredicateDefinitionAccess().getErrorAssignment_0_1_0()); | 9261 | // InternalSolverLanguageParser.g:2880:2: ( rule__PredicateDefinition__ErrorAssignment_0_1_0 ) |
10085 | } | 9262 | // InternalSolverLanguageParser.g:2880:3: rule__PredicateDefinition__ErrorAssignment_0_1_0 |
10086 | // InternalSolverLanguage.g:2801:2: ( rule__PredicateDefinition__ErrorAssignment_0_1_0 ) | ||
10087 | // InternalSolverLanguage.g:2801:3: rule__PredicateDefinition__ErrorAssignment_0_1_0 | ||
10088 | { | 9263 | { |
10089 | pushFollow(FOLLOW_2); | 9264 | pushFollow(FOLLOW_2); |
10090 | rule__PredicateDefinition__ErrorAssignment_0_1_0(); | 9265 | rule__PredicateDefinition__ErrorAssignment_0_1_0(); |
10091 | 9266 | ||
10092 | state._fsp--; | 9267 | state._fsp--; |
10093 | if (state.failed) return ; | ||
10094 | 9268 | ||
10095 | } | ||
10096 | 9269 | ||
10097 | if ( state.backtracking==0 ) { | ||
10098 | after(grammarAccess.getPredicateDefinitionAccess().getErrorAssignment_0_1_0()); | ||
10099 | } | 9270 | } |
10100 | 9271 | ||
9272 | after(grammarAccess.getPredicateDefinitionAccess().getErrorAssignment_0_1_0()); | ||
9273 | |||
10101 | } | 9274 | } |
10102 | 9275 | ||
10103 | 9276 | ||
@@ -10119,20 +9292,20 @@ public class InternalSolverLanguageParser extends AbstractInternalContentAssistP | |||
10119 | 9292 | ||
10120 | 9293 | ||
10121 | // $ANTLR start "rule__PredicateDefinition__Group_0_1__1" | 9294 | // $ANTLR start "rule__PredicateDefinition__Group_0_1__1" |
10122 | // InternalSolverLanguage.g:2809:1: rule__PredicateDefinition__Group_0_1__1 : rule__PredicateDefinition__Group_0_1__1__Impl ; | 9295 | // InternalSolverLanguageParser.g:2888:1: rule__PredicateDefinition__Group_0_1__1 : rule__PredicateDefinition__Group_0_1__1__Impl ; |
10123 | public final void rule__PredicateDefinition__Group_0_1__1() throws RecognitionException { | 9296 | public final void rule__PredicateDefinition__Group_0_1__1() throws RecognitionException { |
10124 | 9297 | ||
10125 | int stackSize = keepStackSize(); | 9298 | int stackSize = keepStackSize(); |
10126 | 9299 | ||
10127 | try { | 9300 | try { |
10128 | // InternalSolverLanguage.g:2813:1: ( rule__PredicateDefinition__Group_0_1__1__Impl ) | 9301 | // InternalSolverLanguageParser.g:2892:1: ( rule__PredicateDefinition__Group_0_1__1__Impl ) |
10129 | // InternalSolverLanguage.g:2814:2: rule__PredicateDefinition__Group_0_1__1__Impl | 9302 | // InternalSolverLanguageParser.g:2893:2: rule__PredicateDefinition__Group_0_1__1__Impl |
10130 | { | 9303 | { |
10131 | pushFollow(FOLLOW_2); | 9304 | pushFollow(FOLLOW_2); |
10132 | rule__PredicateDefinition__Group_0_1__1__Impl(); | 9305 | rule__PredicateDefinition__Group_0_1__1__Impl(); |
10133 | 9306 | ||
10134 | state._fsp--; | 9307 | state._fsp--; |
10135 | if (state.failed) return ; | 9308 | |
10136 | 9309 | ||
10137 | } | 9310 | } |
10138 | 9311 | ||
@@ -10152,46 +9325,42 @@ public class InternalSolverLanguageParser extends AbstractInternalContentAssistP | |||
10152 | 9325 | ||
10153 | 9326 | ||
10154 | // $ANTLR start "rule__PredicateDefinition__Group_0_1__1__Impl" | 9327 | // $ANTLR start "rule__PredicateDefinition__Group_0_1__1__Impl" |
10155 | // InternalSolverLanguage.g:2820:1: rule__PredicateDefinition__Group_0_1__1__Impl : ( ( rule__PredicateDefinition__FunctionalAssignment_0_1_1 )? ) ; | 9328 | // InternalSolverLanguageParser.g:2899:1: rule__PredicateDefinition__Group_0_1__1__Impl : ( ( rule__PredicateDefinition__FunctionalAssignment_0_1_1 )? ) ; |
10156 | public final void rule__PredicateDefinition__Group_0_1__1__Impl() throws RecognitionException { | 9329 | public final void rule__PredicateDefinition__Group_0_1__1__Impl() throws RecognitionException { |
10157 | 9330 | ||
10158 | int stackSize = keepStackSize(); | 9331 | int stackSize = keepStackSize(); |
10159 | 9332 | ||
10160 | try { | 9333 | try { |
10161 | // InternalSolverLanguage.g:2824:1: ( ( ( rule__PredicateDefinition__FunctionalAssignment_0_1_1 )? ) ) | 9334 | // InternalSolverLanguageParser.g:2903:1: ( ( ( rule__PredicateDefinition__FunctionalAssignment_0_1_1 )? ) ) |
10162 | // InternalSolverLanguage.g:2825:1: ( ( rule__PredicateDefinition__FunctionalAssignment_0_1_1 )? ) | 9335 | // InternalSolverLanguageParser.g:2904:1: ( ( rule__PredicateDefinition__FunctionalAssignment_0_1_1 )? ) |
10163 | { | 9336 | { |
10164 | // InternalSolverLanguage.g:2825:1: ( ( rule__PredicateDefinition__FunctionalAssignment_0_1_1 )? ) | 9337 | // InternalSolverLanguageParser.g:2904:1: ( ( rule__PredicateDefinition__FunctionalAssignment_0_1_1 )? ) |
10165 | // InternalSolverLanguage.g:2826:2: ( rule__PredicateDefinition__FunctionalAssignment_0_1_1 )? | 9338 | // InternalSolverLanguageParser.g:2905:2: ( rule__PredicateDefinition__FunctionalAssignment_0_1_1 )? |
10166 | { | 9339 | { |
10167 | if ( state.backtracking==0 ) { | 9340 | before(grammarAccess.getPredicateDefinitionAccess().getFunctionalAssignment_0_1_1()); |
10168 | before(grammarAccess.getPredicateDefinitionAccess().getFunctionalAssignment_0_1_1()); | 9341 | // InternalSolverLanguageParser.g:2906:2: ( rule__PredicateDefinition__FunctionalAssignment_0_1_1 )? |
10169 | } | ||
10170 | // InternalSolverLanguage.g:2827:2: ( rule__PredicateDefinition__FunctionalAssignment_0_1_1 )? | ||
10171 | int alt29=2; | 9342 | int alt29=2; |
10172 | int LA29_0 = input.LA(1); | 9343 | int LA29_0 = input.LA(1); |
10173 | 9344 | ||
10174 | if ( (LA29_0==72) ) { | 9345 | if ( (LA29_0==Functional) ) { |
10175 | alt29=1; | 9346 | alt29=1; |
10176 | } | 9347 | } |
10177 | switch (alt29) { | 9348 | switch (alt29) { |
10178 | case 1 : | 9349 | case 1 : |
10179 | // InternalSolverLanguage.g:2827:3: rule__PredicateDefinition__FunctionalAssignment_0_1_1 | 9350 | // InternalSolverLanguageParser.g:2906:3: rule__PredicateDefinition__FunctionalAssignment_0_1_1 |
10180 | { | 9351 | { |
10181 | pushFollow(FOLLOW_2); | 9352 | pushFollow(FOLLOW_2); |
10182 | rule__PredicateDefinition__FunctionalAssignment_0_1_1(); | 9353 | rule__PredicateDefinition__FunctionalAssignment_0_1_1(); |
10183 | 9354 | ||
10184 | state._fsp--; | 9355 | state._fsp--; |
10185 | if (state.failed) return ; | 9356 | |
10186 | 9357 | ||
10187 | } | 9358 | } |
10188 | break; | 9359 | break; |
10189 | 9360 | ||
10190 | } | 9361 | } |
10191 | 9362 | ||
10192 | if ( state.backtracking==0 ) { | 9363 | after(grammarAccess.getPredicateDefinitionAccess().getFunctionalAssignment_0_1_1()); |
10193 | after(grammarAccess.getPredicateDefinitionAccess().getFunctionalAssignment_0_1_1()); | ||
10194 | } | ||
10195 | 9364 | ||
10196 | } | 9365 | } |
10197 | 9366 | ||
@@ -10214,25 +9383,25 @@ public class InternalSolverLanguageParser extends AbstractInternalContentAssistP | |||
10214 | 9383 | ||
10215 | 9384 | ||
10216 | // $ANTLR start "rule__UnnamedErrorPrediateDefinition__Group__0" | 9385 | // $ANTLR start "rule__UnnamedErrorPrediateDefinition__Group__0" |
10217 | // InternalSolverLanguage.g:2836:1: rule__UnnamedErrorPrediateDefinition__Group__0 : rule__UnnamedErrorPrediateDefinition__Group__0__Impl rule__UnnamedErrorPrediateDefinition__Group__1 ; | 9386 | // InternalSolverLanguageParser.g:2915:1: rule__UnnamedErrorPrediateDefinition__Group__0 : rule__UnnamedErrorPrediateDefinition__Group__0__Impl rule__UnnamedErrorPrediateDefinition__Group__1 ; |
10218 | public final void rule__UnnamedErrorPrediateDefinition__Group__0() throws RecognitionException { | 9387 | public final void rule__UnnamedErrorPrediateDefinition__Group__0() throws RecognitionException { |
10219 | 9388 | ||
10220 | int stackSize = keepStackSize(); | 9389 | int stackSize = keepStackSize(); |
10221 | 9390 | ||
10222 | try { | 9391 | try { |
10223 | // InternalSolverLanguage.g:2840:1: ( rule__UnnamedErrorPrediateDefinition__Group__0__Impl rule__UnnamedErrorPrediateDefinition__Group__1 ) | 9392 | // InternalSolverLanguageParser.g:2919:1: ( rule__UnnamedErrorPrediateDefinition__Group__0__Impl rule__UnnamedErrorPrediateDefinition__Group__1 ) |
10224 | // InternalSolverLanguage.g:2841:2: rule__UnnamedErrorPrediateDefinition__Group__0__Impl rule__UnnamedErrorPrediateDefinition__Group__1 | 9393 | // InternalSolverLanguageParser.g:2920:2: rule__UnnamedErrorPrediateDefinition__Group__0__Impl rule__UnnamedErrorPrediateDefinition__Group__1 |
10225 | { | 9394 | { |
10226 | pushFollow(FOLLOW_12); | 9395 | pushFollow(FOLLOW_12); |
10227 | rule__UnnamedErrorPrediateDefinition__Group__0__Impl(); | 9396 | rule__UnnamedErrorPrediateDefinition__Group__0__Impl(); |
10228 | 9397 | ||
10229 | state._fsp--; | 9398 | state._fsp--; |
10230 | if (state.failed) return ; | 9399 | |
10231 | pushFollow(FOLLOW_2); | 9400 | pushFollow(FOLLOW_2); |
10232 | rule__UnnamedErrorPrediateDefinition__Group__1(); | 9401 | rule__UnnamedErrorPrediateDefinition__Group__1(); |
10233 | 9402 | ||
10234 | state._fsp--; | 9403 | state._fsp--; |
10235 | if (state.failed) return ; | 9404 | |
10236 | 9405 | ||
10237 | } | 9406 | } |
10238 | 9407 | ||
@@ -10252,25 +9421,21 @@ public class InternalSolverLanguageParser extends AbstractInternalContentAssistP | |||
10252 | 9421 | ||
10253 | 9422 | ||
10254 | // $ANTLR start "rule__UnnamedErrorPrediateDefinition__Group__0__Impl" | 9423 | // $ANTLR start "rule__UnnamedErrorPrediateDefinition__Group__0__Impl" |
10255 | // InternalSolverLanguage.g:2848:1: rule__UnnamedErrorPrediateDefinition__Group__0__Impl : ( 'error' ) ; | 9424 | // InternalSolverLanguageParser.g:2927:1: rule__UnnamedErrorPrediateDefinition__Group__0__Impl : ( Error ) ; |
10256 | public final void rule__UnnamedErrorPrediateDefinition__Group__0__Impl() throws RecognitionException { | 9425 | public final void rule__UnnamedErrorPrediateDefinition__Group__0__Impl() throws RecognitionException { |
10257 | 9426 | ||
10258 | int stackSize = keepStackSize(); | 9427 | int stackSize = keepStackSize(); |
10259 | 9428 | ||
10260 | try { | 9429 | try { |
10261 | // InternalSolverLanguage.g:2852:1: ( ( 'error' ) ) | 9430 | // InternalSolverLanguageParser.g:2931:1: ( ( Error ) ) |
10262 | // InternalSolverLanguage.g:2853:1: ( 'error' ) | 9431 | // InternalSolverLanguageParser.g:2932:1: ( Error ) |
10263 | { | 9432 | { |
10264 | // InternalSolverLanguage.g:2853:1: ( 'error' ) | 9433 | // InternalSolverLanguageParser.g:2932:1: ( Error ) |
10265 | // InternalSolverLanguage.g:2854:2: 'error' | 9434 | // InternalSolverLanguageParser.g:2933:2: Error |
10266 | { | 9435 | { |
10267 | if ( state.backtracking==0 ) { | 9436 | before(grammarAccess.getUnnamedErrorPrediateDefinitionAccess().getErrorKeyword_0()); |
10268 | before(grammarAccess.getUnnamedErrorPrediateDefinitionAccess().getErrorKeyword_0()); | 9437 | match(input,Error,FOLLOW_2); |
10269 | } | 9438 | after(grammarAccess.getUnnamedErrorPrediateDefinitionAccess().getErrorKeyword_0()); |
10270 | match(input,42,FOLLOW_2); if (state.failed) return ; | ||
10271 | if ( state.backtracking==0 ) { | ||
10272 | after(grammarAccess.getUnnamedErrorPrediateDefinitionAccess().getErrorKeyword_0()); | ||
10273 | } | ||
10274 | 9439 | ||
10275 | } | 9440 | } |
10276 | 9441 | ||
@@ -10293,25 +9458,25 @@ public class InternalSolverLanguageParser extends AbstractInternalContentAssistP | |||
10293 | 9458 | ||
10294 | 9459 | ||
10295 | // $ANTLR start "rule__UnnamedErrorPrediateDefinition__Group__1" | 9460 | // $ANTLR start "rule__UnnamedErrorPrediateDefinition__Group__1" |
10296 | // InternalSolverLanguage.g:2863:1: rule__UnnamedErrorPrediateDefinition__Group__1 : rule__UnnamedErrorPrediateDefinition__Group__1__Impl rule__UnnamedErrorPrediateDefinition__Group__2 ; | 9461 | // InternalSolverLanguageParser.g:2942:1: rule__UnnamedErrorPrediateDefinition__Group__1 : rule__UnnamedErrorPrediateDefinition__Group__1__Impl rule__UnnamedErrorPrediateDefinition__Group__2 ; |
10297 | public final void rule__UnnamedErrorPrediateDefinition__Group__1() throws RecognitionException { | 9462 | public final void rule__UnnamedErrorPrediateDefinition__Group__1() throws RecognitionException { |
10298 | 9463 | ||
10299 | int stackSize = keepStackSize(); | 9464 | int stackSize = keepStackSize(); |
10300 | 9465 | ||
10301 | try { | 9466 | try { |
10302 | // InternalSolverLanguage.g:2867:1: ( rule__UnnamedErrorPrediateDefinition__Group__1__Impl rule__UnnamedErrorPrediateDefinition__Group__2 ) | 9467 | // InternalSolverLanguageParser.g:2946:1: ( rule__UnnamedErrorPrediateDefinition__Group__1__Impl rule__UnnamedErrorPrediateDefinition__Group__2 ) |
10303 | // InternalSolverLanguage.g:2868:2: rule__UnnamedErrorPrediateDefinition__Group__1__Impl rule__UnnamedErrorPrediateDefinition__Group__2 | 9468 | // InternalSolverLanguageParser.g:2947:2: rule__UnnamedErrorPrediateDefinition__Group__1__Impl rule__UnnamedErrorPrediateDefinition__Group__2 |
10304 | { | 9469 | { |
10305 | pushFollow(FOLLOW_8); | 9470 | pushFollow(FOLLOW_8); |
10306 | rule__UnnamedErrorPrediateDefinition__Group__1__Impl(); | 9471 | rule__UnnamedErrorPrediateDefinition__Group__1__Impl(); |
10307 | 9472 | ||
10308 | state._fsp--; | 9473 | state._fsp--; |
10309 | if (state.failed) return ; | 9474 | |
10310 | pushFollow(FOLLOW_2); | 9475 | pushFollow(FOLLOW_2); |
10311 | rule__UnnamedErrorPrediateDefinition__Group__2(); | 9476 | rule__UnnamedErrorPrediateDefinition__Group__2(); |
10312 | 9477 | ||
10313 | state._fsp--; | 9478 | state._fsp--; |
10314 | if (state.failed) return ; | 9479 | |
10315 | 9480 | ||
10316 | } | 9481 | } |
10317 | 9482 | ||
@@ -10331,36 +9496,32 @@ public class InternalSolverLanguageParser extends AbstractInternalContentAssistP | |||
10331 | 9496 | ||
10332 | 9497 | ||
10333 | // $ANTLR start "rule__UnnamedErrorPrediateDefinition__Group__1__Impl" | 9498 | // $ANTLR start "rule__UnnamedErrorPrediateDefinition__Group__1__Impl" |
10334 | // InternalSolverLanguage.g:2875:1: rule__UnnamedErrorPrediateDefinition__Group__1__Impl : ( ( rule__UnnamedErrorPrediateDefinition__ArgumentListAssignment_1 ) ) ; | 9499 | // InternalSolverLanguageParser.g:2954:1: rule__UnnamedErrorPrediateDefinition__Group__1__Impl : ( ( rule__UnnamedErrorPrediateDefinition__ArgumentListAssignment_1 ) ) ; |
10335 | public final void rule__UnnamedErrorPrediateDefinition__Group__1__Impl() throws RecognitionException { | 9500 | public final void rule__UnnamedErrorPrediateDefinition__Group__1__Impl() throws RecognitionException { |
10336 | 9501 | ||
10337 | int stackSize = keepStackSize(); | 9502 | int stackSize = keepStackSize(); |
10338 | 9503 | ||
10339 | try { | 9504 | try { |
10340 | // InternalSolverLanguage.g:2879:1: ( ( ( rule__UnnamedErrorPrediateDefinition__ArgumentListAssignment_1 ) ) ) | 9505 | // InternalSolverLanguageParser.g:2958:1: ( ( ( rule__UnnamedErrorPrediateDefinition__ArgumentListAssignment_1 ) ) ) |
10341 | // InternalSolverLanguage.g:2880:1: ( ( rule__UnnamedErrorPrediateDefinition__ArgumentListAssignment_1 ) ) | 9506 | // InternalSolverLanguageParser.g:2959:1: ( ( rule__UnnamedErrorPrediateDefinition__ArgumentListAssignment_1 ) ) |
10342 | { | 9507 | { |
10343 | // InternalSolverLanguage.g:2880:1: ( ( rule__UnnamedErrorPrediateDefinition__ArgumentListAssignment_1 ) ) | 9508 | // InternalSolverLanguageParser.g:2959:1: ( ( rule__UnnamedErrorPrediateDefinition__ArgumentListAssignment_1 ) ) |
10344 | // InternalSolverLanguage.g:2881:2: ( rule__UnnamedErrorPrediateDefinition__ArgumentListAssignment_1 ) | 9509 | // InternalSolverLanguageParser.g:2960:2: ( rule__UnnamedErrorPrediateDefinition__ArgumentListAssignment_1 ) |
10345 | { | 9510 | { |
10346 | if ( state.backtracking==0 ) { | 9511 | before(grammarAccess.getUnnamedErrorPrediateDefinitionAccess().getArgumentListAssignment_1()); |
10347 | before(grammarAccess.getUnnamedErrorPrediateDefinitionAccess().getArgumentListAssignment_1()); | 9512 | // InternalSolverLanguageParser.g:2961:2: ( rule__UnnamedErrorPrediateDefinition__ArgumentListAssignment_1 ) |
10348 | } | 9513 | // InternalSolverLanguageParser.g:2961:3: rule__UnnamedErrorPrediateDefinition__ArgumentListAssignment_1 |
10349 | // InternalSolverLanguage.g:2882:2: ( rule__UnnamedErrorPrediateDefinition__ArgumentListAssignment_1 ) | ||
10350 | // InternalSolverLanguage.g:2882:3: rule__UnnamedErrorPrediateDefinition__ArgumentListAssignment_1 | ||
10351 | { | 9514 | { |
10352 | pushFollow(FOLLOW_2); | 9515 | pushFollow(FOLLOW_2); |
10353 | rule__UnnamedErrorPrediateDefinition__ArgumentListAssignment_1(); | 9516 | rule__UnnamedErrorPrediateDefinition__ArgumentListAssignment_1(); |
10354 | 9517 | ||
10355 | state._fsp--; | 9518 | state._fsp--; |
10356 | if (state.failed) return ; | ||
10357 | 9519 | ||
10358 | } | ||
10359 | 9520 | ||
10360 | if ( state.backtracking==0 ) { | ||
10361 | after(grammarAccess.getUnnamedErrorPrediateDefinitionAccess().getArgumentListAssignment_1()); | ||
10362 | } | 9521 | } |
10363 | 9522 | ||
9523 | after(grammarAccess.getUnnamedErrorPrediateDefinitionAccess().getArgumentListAssignment_1()); | ||
9524 | |||
10364 | } | 9525 | } |
10365 | 9526 | ||
10366 | 9527 | ||
@@ -10382,25 +9543,25 @@ public class InternalSolverLanguageParser extends AbstractInternalContentAssistP | |||
10382 | 9543 | ||
10383 | 9544 | ||
10384 | // $ANTLR start "rule__UnnamedErrorPrediateDefinition__Group__2" | 9545 | // $ANTLR start "rule__UnnamedErrorPrediateDefinition__Group__2" |
10385 | // InternalSolverLanguage.g:2890:1: rule__UnnamedErrorPrediateDefinition__Group__2 : rule__UnnamedErrorPrediateDefinition__Group__2__Impl rule__UnnamedErrorPrediateDefinition__Group__3 ; | 9546 | // InternalSolverLanguageParser.g:2969:1: rule__UnnamedErrorPrediateDefinition__Group__2 : rule__UnnamedErrorPrediateDefinition__Group__2__Impl rule__UnnamedErrorPrediateDefinition__Group__3 ; |
10386 | public final void rule__UnnamedErrorPrediateDefinition__Group__2() throws RecognitionException { | 9547 | public final void rule__UnnamedErrorPrediateDefinition__Group__2() throws RecognitionException { |
10387 | 9548 | ||
10388 | int stackSize = keepStackSize(); | 9549 | int stackSize = keepStackSize(); |
10389 | 9550 | ||
10390 | try { | 9551 | try { |
10391 | // InternalSolverLanguage.g:2894:1: ( rule__UnnamedErrorPrediateDefinition__Group__2__Impl rule__UnnamedErrorPrediateDefinition__Group__3 ) | 9552 | // InternalSolverLanguageParser.g:2973:1: ( rule__UnnamedErrorPrediateDefinition__Group__2__Impl rule__UnnamedErrorPrediateDefinition__Group__3 ) |
10392 | // InternalSolverLanguage.g:2895:2: rule__UnnamedErrorPrediateDefinition__Group__2__Impl rule__UnnamedErrorPrediateDefinition__Group__3 | 9553 | // InternalSolverLanguageParser.g:2974:2: rule__UnnamedErrorPrediateDefinition__Group__2__Impl rule__UnnamedErrorPrediateDefinition__Group__3 |
10393 | { | 9554 | { |
10394 | pushFollow(FOLLOW_7); | 9555 | pushFollow(FOLLOW_7); |
10395 | rule__UnnamedErrorPrediateDefinition__Group__2__Impl(); | 9556 | rule__UnnamedErrorPrediateDefinition__Group__2__Impl(); |
10396 | 9557 | ||
10397 | state._fsp--; | 9558 | state._fsp--; |
10398 | if (state.failed) return ; | 9559 | |
10399 | pushFollow(FOLLOW_2); | 9560 | pushFollow(FOLLOW_2); |
10400 | rule__UnnamedErrorPrediateDefinition__Group__3(); | 9561 | rule__UnnamedErrorPrediateDefinition__Group__3(); |
10401 | 9562 | ||
10402 | state._fsp--; | 9563 | state._fsp--; |
10403 | if (state.failed) return ; | 9564 | |
10404 | 9565 | ||
10405 | } | 9566 | } |
10406 | 9567 | ||
@@ -10420,25 +9581,21 @@ public class InternalSolverLanguageParser extends AbstractInternalContentAssistP | |||
10420 | 9581 | ||
10421 | 9582 | ||
10422 | // $ANTLR start "rule__UnnamedErrorPrediateDefinition__Group__2__Impl" | 9583 | // $ANTLR start "rule__UnnamedErrorPrediateDefinition__Group__2__Impl" |
10423 | // InternalSolverLanguage.g:2902:1: rule__UnnamedErrorPrediateDefinition__Group__2__Impl : ( ':-' ) ; | 9584 | // InternalSolverLanguageParser.g:2981:1: rule__UnnamedErrorPrediateDefinition__Group__2__Impl : ( ColonHyphenMinus ) ; |
10424 | public final void rule__UnnamedErrorPrediateDefinition__Group__2__Impl() throws RecognitionException { | 9585 | public final void rule__UnnamedErrorPrediateDefinition__Group__2__Impl() throws RecognitionException { |
10425 | 9586 | ||
10426 | int stackSize = keepStackSize(); | 9587 | int stackSize = keepStackSize(); |
10427 | 9588 | ||
10428 | try { | 9589 | try { |
10429 | // InternalSolverLanguage.g:2906:1: ( ( ':-' ) ) | 9590 | // InternalSolverLanguageParser.g:2985:1: ( ( ColonHyphenMinus ) ) |
10430 | // InternalSolverLanguage.g:2907:1: ( ':-' ) | 9591 | // InternalSolverLanguageParser.g:2986:1: ( ColonHyphenMinus ) |
10431 | { | 9592 | { |
10432 | // InternalSolverLanguage.g:2907:1: ( ':-' ) | 9593 | // InternalSolverLanguageParser.g:2986:1: ( ColonHyphenMinus ) |
10433 | // InternalSolverLanguage.g:2908:2: ':-' | 9594 | // InternalSolverLanguageParser.g:2987:2: ColonHyphenMinus |
10434 | { | 9595 | { |
10435 | if ( state.backtracking==0 ) { | 9596 | before(grammarAccess.getUnnamedErrorPrediateDefinitionAccess().getColonHyphenMinusKeyword_2()); |
10436 | before(grammarAccess.getUnnamedErrorPrediateDefinitionAccess().getColonHyphenMinusKeyword_2()); | 9597 | match(input,ColonHyphenMinus,FOLLOW_2); |
10437 | } | 9598 | after(grammarAccess.getUnnamedErrorPrediateDefinitionAccess().getColonHyphenMinusKeyword_2()); |
10438 | match(input,46,FOLLOW_2); if (state.failed) return ; | ||
10439 | if ( state.backtracking==0 ) { | ||
10440 | after(grammarAccess.getUnnamedErrorPrediateDefinitionAccess().getColonHyphenMinusKeyword_2()); | ||
10441 | } | ||
10442 | 9599 | ||
10443 | } | 9600 | } |
10444 | 9601 | ||
@@ -10461,20 +9618,20 @@ public class InternalSolverLanguageParser extends AbstractInternalContentAssistP | |||
10461 | 9618 | ||
10462 | 9619 | ||
10463 | // $ANTLR start "rule__UnnamedErrorPrediateDefinition__Group__3" | 9620 | // $ANTLR start "rule__UnnamedErrorPrediateDefinition__Group__3" |
10464 | // InternalSolverLanguage.g:2917:1: rule__UnnamedErrorPrediateDefinition__Group__3 : rule__UnnamedErrorPrediateDefinition__Group__3__Impl ; | 9621 | // InternalSolverLanguageParser.g:2996:1: rule__UnnamedErrorPrediateDefinition__Group__3 : rule__UnnamedErrorPrediateDefinition__Group__3__Impl ; |
10465 | public final void rule__UnnamedErrorPrediateDefinition__Group__3() throws RecognitionException { | 9622 | public final void rule__UnnamedErrorPrediateDefinition__Group__3() throws RecognitionException { |
10466 | 9623 | ||
10467 | int stackSize = keepStackSize(); | 9624 | int stackSize = keepStackSize(); |
10468 | 9625 | ||
10469 | try { | 9626 | try { |
10470 | // InternalSolverLanguage.g:2921:1: ( rule__UnnamedErrorPrediateDefinition__Group__3__Impl ) | 9627 | // InternalSolverLanguageParser.g:3000:1: ( rule__UnnamedErrorPrediateDefinition__Group__3__Impl ) |
10471 | // InternalSolverLanguage.g:2922:2: rule__UnnamedErrorPrediateDefinition__Group__3__Impl | 9628 | // InternalSolverLanguageParser.g:3001:2: rule__UnnamedErrorPrediateDefinition__Group__3__Impl |
10472 | { | 9629 | { |
10473 | pushFollow(FOLLOW_2); | 9630 | pushFollow(FOLLOW_2); |
10474 | rule__UnnamedErrorPrediateDefinition__Group__3__Impl(); | 9631 | rule__UnnamedErrorPrediateDefinition__Group__3__Impl(); |
10475 | 9632 | ||
10476 | state._fsp--; | 9633 | state._fsp--; |
10477 | if (state.failed) return ; | 9634 | |
10478 | 9635 | ||
10479 | } | 9636 | } |
10480 | 9637 | ||
@@ -10494,36 +9651,32 @@ public class InternalSolverLanguageParser extends AbstractInternalContentAssistP | |||
10494 | 9651 | ||
10495 | 9652 | ||
10496 | // $ANTLR start "rule__UnnamedErrorPrediateDefinition__Group__3__Impl" | 9653 | // $ANTLR start "rule__UnnamedErrorPrediateDefinition__Group__3__Impl" |
10497 | // InternalSolverLanguage.g:2928:1: rule__UnnamedErrorPrediateDefinition__Group__3__Impl : ( ( rule__UnnamedErrorPrediateDefinition__BodyAssignment_3 ) ) ; | 9654 | // InternalSolverLanguageParser.g:3007:1: rule__UnnamedErrorPrediateDefinition__Group__3__Impl : ( ( rule__UnnamedErrorPrediateDefinition__BodyAssignment_3 ) ) ; |
10498 | public final void rule__UnnamedErrorPrediateDefinition__Group__3__Impl() throws RecognitionException { | 9655 | public final void rule__UnnamedErrorPrediateDefinition__Group__3__Impl() throws RecognitionException { |
10499 | 9656 | ||
10500 | int stackSize = keepStackSize(); | 9657 | int stackSize = keepStackSize(); |
10501 | 9658 | ||
10502 | try { | 9659 | try { |
10503 | // InternalSolverLanguage.g:2932:1: ( ( ( rule__UnnamedErrorPrediateDefinition__BodyAssignment_3 ) ) ) | 9660 | // InternalSolverLanguageParser.g:3011:1: ( ( ( rule__UnnamedErrorPrediateDefinition__BodyAssignment_3 ) ) ) |
10504 | // InternalSolverLanguage.g:2933:1: ( ( rule__UnnamedErrorPrediateDefinition__BodyAssignment_3 ) ) | 9661 | // InternalSolverLanguageParser.g:3012:1: ( ( rule__UnnamedErrorPrediateDefinition__BodyAssignment_3 ) ) |
10505 | { | 9662 | { |
10506 | // InternalSolverLanguage.g:2933:1: ( ( rule__UnnamedErrorPrediateDefinition__BodyAssignment_3 ) ) | 9663 | // InternalSolverLanguageParser.g:3012:1: ( ( rule__UnnamedErrorPrediateDefinition__BodyAssignment_3 ) ) |
10507 | // InternalSolverLanguage.g:2934:2: ( rule__UnnamedErrorPrediateDefinition__BodyAssignment_3 ) | 9664 | // InternalSolverLanguageParser.g:3013:2: ( rule__UnnamedErrorPrediateDefinition__BodyAssignment_3 ) |
10508 | { | 9665 | { |
10509 | if ( state.backtracking==0 ) { | 9666 | before(grammarAccess.getUnnamedErrorPrediateDefinitionAccess().getBodyAssignment_3()); |
10510 | before(grammarAccess.getUnnamedErrorPrediateDefinitionAccess().getBodyAssignment_3()); | 9667 | // InternalSolverLanguageParser.g:3014:2: ( rule__UnnamedErrorPrediateDefinition__BodyAssignment_3 ) |
10511 | } | 9668 | // InternalSolverLanguageParser.g:3014:3: rule__UnnamedErrorPrediateDefinition__BodyAssignment_3 |
10512 | // InternalSolverLanguage.g:2935:2: ( rule__UnnamedErrorPrediateDefinition__BodyAssignment_3 ) | ||
10513 | // InternalSolverLanguage.g:2935:3: rule__UnnamedErrorPrediateDefinition__BodyAssignment_3 | ||
10514 | { | 9669 | { |
10515 | pushFollow(FOLLOW_2); | 9670 | pushFollow(FOLLOW_2); |
10516 | rule__UnnamedErrorPrediateDefinition__BodyAssignment_3(); | 9671 | rule__UnnamedErrorPrediateDefinition__BodyAssignment_3(); |
10517 | 9672 | ||
10518 | state._fsp--; | 9673 | state._fsp--; |
10519 | if (state.failed) return ; | ||
10520 | 9674 | ||
10521 | } | ||
10522 | 9675 | ||
10523 | if ( state.backtracking==0 ) { | ||
10524 | after(grammarAccess.getUnnamedErrorPrediateDefinitionAccess().getBodyAssignment_3()); | ||
10525 | } | 9676 | } |
10526 | 9677 | ||
9678 | after(grammarAccess.getUnnamedErrorPrediateDefinitionAccess().getBodyAssignment_3()); | ||
9679 | |||
10527 | } | 9680 | } |
10528 | 9681 | ||
10529 | 9682 | ||
@@ -10545,25 +9698,25 @@ public class InternalSolverLanguageParser extends AbstractInternalContentAssistP | |||
10545 | 9698 | ||
10546 | 9699 | ||
10547 | // $ANTLR start "rule__DefaultDefinition__Group__0" | 9700 | // $ANTLR start "rule__DefaultDefinition__Group__0" |
10548 | // InternalSolverLanguage.g:2944:1: rule__DefaultDefinition__Group__0 : rule__DefaultDefinition__Group__0__Impl rule__DefaultDefinition__Group__1 ; | 9701 | // InternalSolverLanguageParser.g:3023:1: rule__DefaultDefinition__Group__0 : rule__DefaultDefinition__Group__0__Impl rule__DefaultDefinition__Group__1 ; |
10549 | public final void rule__DefaultDefinition__Group__0() throws RecognitionException { | 9702 | public final void rule__DefaultDefinition__Group__0() throws RecognitionException { |
10550 | 9703 | ||
10551 | int stackSize = keepStackSize(); | 9704 | int stackSize = keepStackSize(); |
10552 | 9705 | ||
10553 | try { | 9706 | try { |
10554 | // InternalSolverLanguage.g:2948:1: ( rule__DefaultDefinition__Group__0__Impl rule__DefaultDefinition__Group__1 ) | 9707 | // InternalSolverLanguageParser.g:3027:1: ( rule__DefaultDefinition__Group__0__Impl rule__DefaultDefinition__Group__1 ) |
10555 | // InternalSolverLanguage.g:2949:2: rule__DefaultDefinition__Group__0__Impl rule__DefaultDefinition__Group__1 | 9708 | // InternalSolverLanguageParser.g:3028:2: rule__DefaultDefinition__Group__0__Impl rule__DefaultDefinition__Group__1 |
10556 | { | 9709 | { |
10557 | pushFollow(FOLLOW_9); | 9710 | pushFollow(FOLLOW_9); |
10558 | rule__DefaultDefinition__Group__0__Impl(); | 9711 | rule__DefaultDefinition__Group__0__Impl(); |
10559 | 9712 | ||
10560 | state._fsp--; | 9713 | state._fsp--; |
10561 | if (state.failed) return ; | 9714 | |
10562 | pushFollow(FOLLOW_2); | 9715 | pushFollow(FOLLOW_2); |
10563 | rule__DefaultDefinition__Group__1(); | 9716 | rule__DefaultDefinition__Group__1(); |
10564 | 9717 | ||
10565 | state._fsp--; | 9718 | state._fsp--; |
10566 | if (state.failed) return ; | 9719 | |
10567 | 9720 | ||
10568 | } | 9721 | } |
10569 | 9722 | ||
@@ -10583,25 +9736,21 @@ public class InternalSolverLanguageParser extends AbstractInternalContentAssistP | |||
10583 | 9736 | ||
10584 | 9737 | ||
10585 | // $ANTLR start "rule__DefaultDefinition__Group__0__Impl" | 9738 | // $ANTLR start "rule__DefaultDefinition__Group__0__Impl" |
10586 | // InternalSolverLanguage.g:2956:1: rule__DefaultDefinition__Group__0__Impl : ( 'default' ) ; | 9739 | // InternalSolverLanguageParser.g:3035:1: rule__DefaultDefinition__Group__0__Impl : ( Default ) ; |
10587 | public final void rule__DefaultDefinition__Group__0__Impl() throws RecognitionException { | 9740 | public final void rule__DefaultDefinition__Group__0__Impl() throws RecognitionException { |
10588 | 9741 | ||
10589 | int stackSize = keepStackSize(); | 9742 | int stackSize = keepStackSize(); |
10590 | 9743 | ||
10591 | try { | 9744 | try { |
10592 | // InternalSolverLanguage.g:2960:1: ( ( 'default' ) ) | 9745 | // InternalSolverLanguageParser.g:3039:1: ( ( Default ) ) |
10593 | // InternalSolverLanguage.g:2961:1: ( 'default' ) | 9746 | // InternalSolverLanguageParser.g:3040:1: ( Default ) |
10594 | { | 9747 | { |
10595 | // InternalSolverLanguage.g:2961:1: ( 'default' ) | 9748 | // InternalSolverLanguageParser.g:3040:1: ( Default ) |
10596 | // InternalSolverLanguage.g:2962:2: 'default' | 9749 | // InternalSolverLanguageParser.g:3041:2: Default |
10597 | { | 9750 | { |
10598 | if ( state.backtracking==0 ) { | 9751 | before(grammarAccess.getDefaultDefinitionAccess().getDefaultKeyword_0()); |
10599 | before(grammarAccess.getDefaultDefinitionAccess().getDefaultKeyword_0()); | 9752 | match(input,Default,FOLLOW_2); |
10600 | } | 9753 | after(grammarAccess.getDefaultDefinitionAccess().getDefaultKeyword_0()); |
10601 | match(input,48,FOLLOW_2); if (state.failed) return ; | ||
10602 | if ( state.backtracking==0 ) { | ||
10603 | after(grammarAccess.getDefaultDefinitionAccess().getDefaultKeyword_0()); | ||
10604 | } | ||
10605 | 9754 | ||
10606 | } | 9755 | } |
10607 | 9756 | ||
@@ -10624,25 +9773,25 @@ public class InternalSolverLanguageParser extends AbstractInternalContentAssistP | |||
10624 | 9773 | ||
10625 | 9774 | ||
10626 | // $ANTLR start "rule__DefaultDefinition__Group__1" | 9775 | // $ANTLR start "rule__DefaultDefinition__Group__1" |
10627 | // InternalSolverLanguage.g:2971:1: rule__DefaultDefinition__Group__1 : rule__DefaultDefinition__Group__1__Impl rule__DefaultDefinition__Group__2 ; | 9776 | // InternalSolverLanguageParser.g:3050:1: rule__DefaultDefinition__Group__1 : rule__DefaultDefinition__Group__1__Impl rule__DefaultDefinition__Group__2 ; |
10628 | public final void rule__DefaultDefinition__Group__1() throws RecognitionException { | 9777 | public final void rule__DefaultDefinition__Group__1() throws RecognitionException { |
10629 | 9778 | ||
10630 | int stackSize = keepStackSize(); | 9779 | int stackSize = keepStackSize(); |
10631 | 9780 | ||
10632 | try { | 9781 | try { |
10633 | // InternalSolverLanguage.g:2975:1: ( rule__DefaultDefinition__Group__1__Impl rule__DefaultDefinition__Group__2 ) | 9782 | // InternalSolverLanguageParser.g:3054:1: ( rule__DefaultDefinition__Group__1__Impl rule__DefaultDefinition__Group__2 ) |
10634 | // InternalSolverLanguage.g:2976:2: rule__DefaultDefinition__Group__1__Impl rule__DefaultDefinition__Group__2 | 9783 | // InternalSolverLanguageParser.g:3055:2: rule__DefaultDefinition__Group__1__Impl rule__DefaultDefinition__Group__2 |
10635 | { | 9784 | { |
10636 | pushFollow(FOLLOW_6); | 9785 | pushFollow(FOLLOW_6); |
10637 | rule__DefaultDefinition__Group__1__Impl(); | 9786 | rule__DefaultDefinition__Group__1__Impl(); |
10638 | 9787 | ||
10639 | state._fsp--; | 9788 | state._fsp--; |
10640 | if (state.failed) return ; | 9789 | |
10641 | pushFollow(FOLLOW_2); | 9790 | pushFollow(FOLLOW_2); |
10642 | rule__DefaultDefinition__Group__2(); | 9791 | rule__DefaultDefinition__Group__2(); |
10643 | 9792 | ||
10644 | state._fsp--; | 9793 | state._fsp--; |
10645 | if (state.failed) return ; | 9794 | |
10646 | 9795 | ||
10647 | } | 9796 | } |
10648 | 9797 | ||
@@ -10662,36 +9811,32 @@ public class InternalSolverLanguageParser extends AbstractInternalContentAssistP | |||
10662 | 9811 | ||
10663 | 9812 | ||
10664 | // $ANTLR start "rule__DefaultDefinition__Group__1__Impl" | 9813 | // $ANTLR start "rule__DefaultDefinition__Group__1__Impl" |
10665 | // InternalSolverLanguage.g:2983:1: rule__DefaultDefinition__Group__1__Impl : ( ( rule__DefaultDefinition__HeadAssignment_1 ) ) ; | 9814 | // InternalSolverLanguageParser.g:3062:1: rule__DefaultDefinition__Group__1__Impl : ( ( rule__DefaultDefinition__HeadAssignment_1 ) ) ; |
10666 | public final void rule__DefaultDefinition__Group__1__Impl() throws RecognitionException { | 9815 | public final void rule__DefaultDefinition__Group__1__Impl() throws RecognitionException { |
10667 | 9816 | ||
10668 | int stackSize = keepStackSize(); | 9817 | int stackSize = keepStackSize(); |
10669 | 9818 | ||
10670 | try { | 9819 | try { |
10671 | // InternalSolverLanguage.g:2987:1: ( ( ( rule__DefaultDefinition__HeadAssignment_1 ) ) ) | 9820 | // InternalSolverLanguageParser.g:3066:1: ( ( ( rule__DefaultDefinition__HeadAssignment_1 ) ) ) |
10672 | // InternalSolverLanguage.g:2988:1: ( ( rule__DefaultDefinition__HeadAssignment_1 ) ) | 9821 | // InternalSolverLanguageParser.g:3067:1: ( ( rule__DefaultDefinition__HeadAssignment_1 ) ) |
10673 | { | 9822 | { |
10674 | // InternalSolverLanguage.g:2988:1: ( ( rule__DefaultDefinition__HeadAssignment_1 ) ) | 9823 | // InternalSolverLanguageParser.g:3067:1: ( ( rule__DefaultDefinition__HeadAssignment_1 ) ) |
10675 | // InternalSolverLanguage.g:2989:2: ( rule__DefaultDefinition__HeadAssignment_1 ) | 9824 | // InternalSolverLanguageParser.g:3068:2: ( rule__DefaultDefinition__HeadAssignment_1 ) |
10676 | { | 9825 | { |
10677 | if ( state.backtracking==0 ) { | 9826 | before(grammarAccess.getDefaultDefinitionAccess().getHeadAssignment_1()); |
10678 | before(grammarAccess.getDefaultDefinitionAccess().getHeadAssignment_1()); | 9827 | // InternalSolverLanguageParser.g:3069:2: ( rule__DefaultDefinition__HeadAssignment_1 ) |
10679 | } | 9828 | // InternalSolverLanguageParser.g:3069:3: rule__DefaultDefinition__HeadAssignment_1 |
10680 | // InternalSolverLanguage.g:2990:2: ( rule__DefaultDefinition__HeadAssignment_1 ) | ||
10681 | // InternalSolverLanguage.g:2990:3: rule__DefaultDefinition__HeadAssignment_1 | ||
10682 | { | 9829 | { |
10683 | pushFollow(FOLLOW_2); | 9830 | pushFollow(FOLLOW_2); |
10684 | rule__DefaultDefinition__HeadAssignment_1(); | 9831 | rule__DefaultDefinition__HeadAssignment_1(); |
10685 | 9832 | ||
10686 | state._fsp--; | 9833 | state._fsp--; |
10687 | if (state.failed) return ; | ||
10688 | 9834 | ||
10689 | } | ||
10690 | 9835 | ||
10691 | if ( state.backtracking==0 ) { | ||
10692 | after(grammarAccess.getDefaultDefinitionAccess().getHeadAssignment_1()); | ||
10693 | } | 9836 | } |
10694 | 9837 | ||
9838 | after(grammarAccess.getDefaultDefinitionAccess().getHeadAssignment_1()); | ||
9839 | |||
10695 | } | 9840 | } |
10696 | 9841 | ||
10697 | 9842 | ||
@@ -10713,25 +9858,25 @@ public class InternalSolverLanguageParser extends AbstractInternalContentAssistP | |||
10713 | 9858 | ||
10714 | 9859 | ||
10715 | // $ANTLR start "rule__DefaultDefinition__Group__2" | 9860 | // $ANTLR start "rule__DefaultDefinition__Group__2" |
10716 | // InternalSolverLanguage.g:2998:1: rule__DefaultDefinition__Group__2 : rule__DefaultDefinition__Group__2__Impl rule__DefaultDefinition__Group__3 ; | 9861 | // InternalSolverLanguageParser.g:3077:1: rule__DefaultDefinition__Group__2 : rule__DefaultDefinition__Group__2__Impl rule__DefaultDefinition__Group__3 ; |
10717 | public final void rule__DefaultDefinition__Group__2() throws RecognitionException { | 9862 | public final void rule__DefaultDefinition__Group__2() throws RecognitionException { |
10718 | 9863 | ||
10719 | int stackSize = keepStackSize(); | 9864 | int stackSize = keepStackSize(); |
10720 | 9865 | ||
10721 | try { | 9866 | try { |
10722 | // InternalSolverLanguage.g:3002:1: ( rule__DefaultDefinition__Group__2__Impl rule__DefaultDefinition__Group__3 ) | 9867 | // InternalSolverLanguageParser.g:3081:1: ( rule__DefaultDefinition__Group__2__Impl rule__DefaultDefinition__Group__3 ) |
10723 | // InternalSolverLanguage.g:3003:2: rule__DefaultDefinition__Group__2__Impl rule__DefaultDefinition__Group__3 | 9868 | // InternalSolverLanguageParser.g:3082:2: rule__DefaultDefinition__Group__2__Impl rule__DefaultDefinition__Group__3 |
10724 | { | 9869 | { |
10725 | pushFollow(FOLLOW_7); | 9870 | pushFollow(FOLLOW_7); |
10726 | rule__DefaultDefinition__Group__2__Impl(); | 9871 | rule__DefaultDefinition__Group__2__Impl(); |
10727 | 9872 | ||
10728 | state._fsp--; | 9873 | state._fsp--; |
10729 | if (state.failed) return ; | 9874 | |
10730 | pushFollow(FOLLOW_2); | 9875 | pushFollow(FOLLOW_2); |
10731 | rule__DefaultDefinition__Group__3(); | 9876 | rule__DefaultDefinition__Group__3(); |
10732 | 9877 | ||
10733 | state._fsp--; | 9878 | state._fsp--; |
10734 | if (state.failed) return ; | 9879 | |
10735 | 9880 | ||
10736 | } | 9881 | } |
10737 | 9882 | ||
@@ -10751,25 +9896,21 @@ public class InternalSolverLanguageParser extends AbstractInternalContentAssistP | |||
10751 | 9896 | ||
10752 | 9897 | ||
10753 | // $ANTLR start "rule__DefaultDefinition__Group__2__Impl" | 9898 | // $ANTLR start "rule__DefaultDefinition__Group__2__Impl" |
10754 | // InternalSolverLanguage.g:3010:1: rule__DefaultDefinition__Group__2__Impl : ( ':' ) ; | 9899 | // InternalSolverLanguageParser.g:3089:1: rule__DefaultDefinition__Group__2__Impl : ( Colon ) ; |
10755 | public final void rule__DefaultDefinition__Group__2__Impl() throws RecognitionException { | 9900 | public final void rule__DefaultDefinition__Group__2__Impl() throws RecognitionException { |
10756 | 9901 | ||
10757 | int stackSize = keepStackSize(); | 9902 | int stackSize = keepStackSize(); |
10758 | 9903 | ||
10759 | try { | 9904 | try { |
10760 | // InternalSolverLanguage.g:3014:1: ( ( ':' ) ) | 9905 | // InternalSolverLanguageParser.g:3093:1: ( ( Colon ) ) |
10761 | // InternalSolverLanguage.g:3015:1: ( ':' ) | 9906 | // InternalSolverLanguageParser.g:3094:1: ( Colon ) |
10762 | { | 9907 | { |
10763 | // InternalSolverLanguage.g:3015:1: ( ':' ) | 9908 | // InternalSolverLanguageParser.g:3094:1: ( Colon ) |
10764 | // InternalSolverLanguage.g:3016:2: ':' | 9909 | // InternalSolverLanguageParser.g:3095:2: Colon |
10765 | { | 9910 | { |
10766 | if ( state.backtracking==0 ) { | 9911 | before(grammarAccess.getDefaultDefinitionAccess().getColonKeyword_2()); |
10767 | before(grammarAccess.getDefaultDefinitionAccess().getColonKeyword_2()); | 9912 | match(input,Colon,FOLLOW_2); |
10768 | } | 9913 | after(grammarAccess.getDefaultDefinitionAccess().getColonKeyword_2()); |
10769 | match(input,45,FOLLOW_2); if (state.failed) return ; | ||
10770 | if ( state.backtracking==0 ) { | ||
10771 | after(grammarAccess.getDefaultDefinitionAccess().getColonKeyword_2()); | ||
10772 | } | ||
10773 | 9914 | ||
10774 | } | 9915 | } |
10775 | 9916 | ||
@@ -10792,20 +9933,20 @@ public class InternalSolverLanguageParser extends AbstractInternalContentAssistP | |||
10792 | 9933 | ||
10793 | 9934 | ||
10794 | // $ANTLR start "rule__DefaultDefinition__Group__3" | 9935 | // $ANTLR start "rule__DefaultDefinition__Group__3" |
10795 | // InternalSolverLanguage.g:3025:1: rule__DefaultDefinition__Group__3 : rule__DefaultDefinition__Group__3__Impl ; | 9936 | // InternalSolverLanguageParser.g:3104:1: rule__DefaultDefinition__Group__3 : rule__DefaultDefinition__Group__3__Impl ; |
10796 | public final void rule__DefaultDefinition__Group__3() throws RecognitionException { | 9937 | public final void rule__DefaultDefinition__Group__3() throws RecognitionException { |
10797 | 9938 | ||
10798 | int stackSize = keepStackSize(); | 9939 | int stackSize = keepStackSize(); |
10799 | 9940 | ||
10800 | try { | 9941 | try { |
10801 | // InternalSolverLanguage.g:3029:1: ( rule__DefaultDefinition__Group__3__Impl ) | 9942 | // InternalSolverLanguageParser.g:3108:1: ( rule__DefaultDefinition__Group__3__Impl ) |
10802 | // InternalSolverLanguage.g:3030:2: rule__DefaultDefinition__Group__3__Impl | 9943 | // InternalSolverLanguageParser.g:3109:2: rule__DefaultDefinition__Group__3__Impl |
10803 | { | 9944 | { |
10804 | pushFollow(FOLLOW_2); | 9945 | pushFollow(FOLLOW_2); |
10805 | rule__DefaultDefinition__Group__3__Impl(); | 9946 | rule__DefaultDefinition__Group__3__Impl(); |
10806 | 9947 | ||
10807 | state._fsp--; | 9948 | state._fsp--; |
10808 | if (state.failed) return ; | 9949 | |
10809 | 9950 | ||
10810 | } | 9951 | } |
10811 | 9952 | ||
@@ -10825,36 +9966,32 @@ public class InternalSolverLanguageParser extends AbstractInternalContentAssistP | |||
10825 | 9966 | ||
10826 | 9967 | ||
10827 | // $ANTLR start "rule__DefaultDefinition__Group__3__Impl" | 9968 | // $ANTLR start "rule__DefaultDefinition__Group__3__Impl" |
10828 | // InternalSolverLanguage.g:3036:1: rule__DefaultDefinition__Group__3__Impl : ( ( rule__DefaultDefinition__RangeAssignment_3 ) ) ; | 9969 | // InternalSolverLanguageParser.g:3115:1: rule__DefaultDefinition__Group__3__Impl : ( ( rule__DefaultDefinition__RangeAssignment_3 ) ) ; |
10829 | public final void rule__DefaultDefinition__Group__3__Impl() throws RecognitionException { | 9970 | public final void rule__DefaultDefinition__Group__3__Impl() throws RecognitionException { |
10830 | 9971 | ||
10831 | int stackSize = keepStackSize(); | 9972 | int stackSize = keepStackSize(); |
10832 | 9973 | ||
10833 | try { | 9974 | try { |
10834 | // InternalSolverLanguage.g:3040:1: ( ( ( rule__DefaultDefinition__RangeAssignment_3 ) ) ) | 9975 | // InternalSolverLanguageParser.g:3119:1: ( ( ( rule__DefaultDefinition__RangeAssignment_3 ) ) ) |
10835 | // InternalSolverLanguage.g:3041:1: ( ( rule__DefaultDefinition__RangeAssignment_3 ) ) | 9976 | // InternalSolverLanguageParser.g:3120:1: ( ( rule__DefaultDefinition__RangeAssignment_3 ) ) |
10836 | { | 9977 | { |
10837 | // InternalSolverLanguage.g:3041:1: ( ( rule__DefaultDefinition__RangeAssignment_3 ) ) | 9978 | // InternalSolverLanguageParser.g:3120:1: ( ( rule__DefaultDefinition__RangeAssignment_3 ) ) |
10838 | // InternalSolverLanguage.g:3042:2: ( rule__DefaultDefinition__RangeAssignment_3 ) | 9979 | // InternalSolverLanguageParser.g:3121:2: ( rule__DefaultDefinition__RangeAssignment_3 ) |
10839 | { | 9980 | { |
10840 | if ( state.backtracking==0 ) { | 9981 | before(grammarAccess.getDefaultDefinitionAccess().getRangeAssignment_3()); |
10841 | before(grammarAccess.getDefaultDefinitionAccess().getRangeAssignment_3()); | 9982 | // InternalSolverLanguageParser.g:3122:2: ( rule__DefaultDefinition__RangeAssignment_3 ) |
10842 | } | 9983 | // InternalSolverLanguageParser.g:3122:3: rule__DefaultDefinition__RangeAssignment_3 |
10843 | // InternalSolverLanguage.g:3043:2: ( rule__DefaultDefinition__RangeAssignment_3 ) | ||
10844 | // InternalSolverLanguage.g:3043:3: rule__DefaultDefinition__RangeAssignment_3 | ||
10845 | { | 9984 | { |
10846 | pushFollow(FOLLOW_2); | 9985 | pushFollow(FOLLOW_2); |
10847 | rule__DefaultDefinition__RangeAssignment_3(); | 9986 | rule__DefaultDefinition__RangeAssignment_3(); |
10848 | 9987 | ||
10849 | state._fsp--; | 9988 | state._fsp--; |
10850 | if (state.failed) return ; | ||
10851 | 9989 | ||
10852 | } | ||
10853 | 9990 | ||
10854 | if ( state.backtracking==0 ) { | ||
10855 | after(grammarAccess.getDefaultDefinitionAccess().getRangeAssignment_3()); | ||
10856 | } | 9991 | } |
10857 | 9992 | ||
9993 | after(grammarAccess.getDefaultDefinitionAccess().getRangeAssignment_3()); | ||
9994 | |||
10858 | } | 9995 | } |
10859 | 9996 | ||
10860 | 9997 | ||
@@ -10876,25 +10013,25 @@ public class InternalSolverLanguageParser extends AbstractInternalContentAssistP | |||
10876 | 10013 | ||
10877 | 10014 | ||
10878 | // $ANTLR start "rule__ExternPredicateDefinition__Group__0" | 10015 | // $ANTLR start "rule__ExternPredicateDefinition__Group__0" |
10879 | // InternalSolverLanguage.g:3052:1: rule__ExternPredicateDefinition__Group__0 : rule__ExternPredicateDefinition__Group__0__Impl rule__ExternPredicateDefinition__Group__1 ; | 10016 | // InternalSolverLanguageParser.g:3131:1: rule__ExternPredicateDefinition__Group__0 : rule__ExternPredicateDefinition__Group__0__Impl rule__ExternPredicateDefinition__Group__1 ; |
10880 | public final void rule__ExternPredicateDefinition__Group__0() throws RecognitionException { | 10017 | public final void rule__ExternPredicateDefinition__Group__0() throws RecognitionException { |
10881 | 10018 | ||
10882 | int stackSize = keepStackSize(); | 10019 | int stackSize = keepStackSize(); |
10883 | 10020 | ||
10884 | try { | 10021 | try { |
10885 | // InternalSolverLanguage.g:3056:1: ( rule__ExternPredicateDefinition__Group__0__Impl rule__ExternPredicateDefinition__Group__1 ) | 10022 | // InternalSolverLanguageParser.g:3135:1: ( rule__ExternPredicateDefinition__Group__0__Impl rule__ExternPredicateDefinition__Group__1 ) |
10886 | // InternalSolverLanguage.g:3057:2: rule__ExternPredicateDefinition__Group__0__Impl rule__ExternPredicateDefinition__Group__1 | 10023 | // InternalSolverLanguageParser.g:3136:2: rule__ExternPredicateDefinition__Group__0__Impl rule__ExternPredicateDefinition__Group__1 |
10887 | { | 10024 | { |
10888 | pushFollow(FOLLOW_9); | 10025 | pushFollow(FOLLOW_9); |
10889 | rule__ExternPredicateDefinition__Group__0__Impl(); | 10026 | rule__ExternPredicateDefinition__Group__0__Impl(); |
10890 | 10027 | ||
10891 | state._fsp--; | 10028 | state._fsp--; |
10892 | if (state.failed) return ; | 10029 | |
10893 | pushFollow(FOLLOW_2); | 10030 | pushFollow(FOLLOW_2); |
10894 | rule__ExternPredicateDefinition__Group__1(); | 10031 | rule__ExternPredicateDefinition__Group__1(); |
10895 | 10032 | ||
10896 | state._fsp--; | 10033 | state._fsp--; |
10897 | if (state.failed) return ; | 10034 | |
10898 | 10035 | ||
10899 | } | 10036 | } |
10900 | 10037 | ||
@@ -10914,25 +10051,21 @@ public class InternalSolverLanguageParser extends AbstractInternalContentAssistP | |||
10914 | 10051 | ||
10915 | 10052 | ||
10916 | // $ANTLR start "rule__ExternPredicateDefinition__Group__0__Impl" | 10053 | // $ANTLR start "rule__ExternPredicateDefinition__Group__0__Impl" |
10917 | // InternalSolverLanguage.g:3064:1: rule__ExternPredicateDefinition__Group__0__Impl : ( 'extern' ) ; | 10054 | // InternalSolverLanguageParser.g:3143:1: rule__ExternPredicateDefinition__Group__0__Impl : ( Extern ) ; |
10918 | public final void rule__ExternPredicateDefinition__Group__0__Impl() throws RecognitionException { | 10055 | public final void rule__ExternPredicateDefinition__Group__0__Impl() throws RecognitionException { |
10919 | 10056 | ||
10920 | int stackSize = keepStackSize(); | 10057 | int stackSize = keepStackSize(); |
10921 | 10058 | ||
10922 | try { | 10059 | try { |
10923 | // InternalSolverLanguage.g:3068:1: ( ( 'extern' ) ) | 10060 | // InternalSolverLanguageParser.g:3147:1: ( ( Extern ) ) |
10924 | // InternalSolverLanguage.g:3069:1: ( 'extern' ) | 10061 | // InternalSolverLanguageParser.g:3148:1: ( Extern ) |
10925 | { | 10062 | { |
10926 | // InternalSolverLanguage.g:3069:1: ( 'extern' ) | 10063 | // InternalSolverLanguageParser.g:3148:1: ( Extern ) |
10927 | // InternalSolverLanguage.g:3070:2: 'extern' | 10064 | // InternalSolverLanguageParser.g:3149:2: Extern |
10928 | { | 10065 | { |
10929 | if ( state.backtracking==0 ) { | 10066 | before(grammarAccess.getExternPredicateDefinitionAccess().getExternKeyword_0()); |
10930 | before(grammarAccess.getExternPredicateDefinitionAccess().getExternKeyword_0()); | 10067 | match(input,Extern,FOLLOW_2); |
10931 | } | 10068 | after(grammarAccess.getExternPredicateDefinitionAccess().getExternKeyword_0()); |
10932 | match(input,49,FOLLOW_2); if (state.failed) return ; | ||
10933 | if ( state.backtracking==0 ) { | ||
10934 | after(grammarAccess.getExternPredicateDefinitionAccess().getExternKeyword_0()); | ||
10935 | } | ||
10936 | 10069 | ||
10937 | } | 10070 | } |
10938 | 10071 | ||
@@ -10955,25 +10088,20 @@ public class InternalSolverLanguageParser extends AbstractInternalContentAssistP | |||
10955 | 10088 | ||
10956 | 10089 | ||
10957 | // $ANTLR start "rule__ExternPredicateDefinition__Group__1" | 10090 | // $ANTLR start "rule__ExternPredicateDefinition__Group__1" |
10958 | // InternalSolverLanguage.g:3079:1: rule__ExternPredicateDefinition__Group__1 : rule__ExternPredicateDefinition__Group__1__Impl rule__ExternPredicateDefinition__Group__2 ; | 10091 | // InternalSolverLanguageParser.g:3158:1: rule__ExternPredicateDefinition__Group__1 : rule__ExternPredicateDefinition__Group__1__Impl ; |
10959 | public final void rule__ExternPredicateDefinition__Group__1() throws RecognitionException { | 10092 | public final void rule__ExternPredicateDefinition__Group__1() throws RecognitionException { |
10960 | 10093 | ||
10961 | int stackSize = keepStackSize(); | 10094 | int stackSize = keepStackSize(); |
10962 | 10095 | ||
10963 | try { | 10096 | try { |
10964 | // InternalSolverLanguage.g:3083:1: ( rule__ExternPredicateDefinition__Group__1__Impl rule__ExternPredicateDefinition__Group__2 ) | 10097 | // InternalSolverLanguageParser.g:3162:1: ( rule__ExternPredicateDefinition__Group__1__Impl ) |
10965 | // InternalSolverLanguage.g:3084:2: rule__ExternPredicateDefinition__Group__1__Impl rule__ExternPredicateDefinition__Group__2 | 10098 | // InternalSolverLanguageParser.g:3163:2: rule__ExternPredicateDefinition__Group__1__Impl |
10966 | { | 10099 | { |
10967 | pushFollow(FOLLOW_13); | 10100 | pushFollow(FOLLOW_2); |
10968 | rule__ExternPredicateDefinition__Group__1__Impl(); | 10101 | rule__ExternPredicateDefinition__Group__1__Impl(); |
10969 | 10102 | ||
10970 | state._fsp--; | 10103 | state._fsp--; |
10971 | if (state.failed) return ; | ||
10972 | pushFollow(FOLLOW_2); | ||
10973 | rule__ExternPredicateDefinition__Group__2(); | ||
10974 | 10104 | ||
10975 | state._fsp--; | ||
10976 | if (state.failed) return ; | ||
10977 | 10105 | ||
10978 | } | 10106 | } |
10979 | 10107 | ||
@@ -10993,109 +10121,31 @@ public class InternalSolverLanguageParser extends AbstractInternalContentAssistP | |||
10993 | 10121 | ||
10994 | 10122 | ||
10995 | // $ANTLR start "rule__ExternPredicateDefinition__Group__1__Impl" | 10123 | // $ANTLR start "rule__ExternPredicateDefinition__Group__1__Impl" |
10996 | // InternalSolverLanguage.g:3091:1: rule__ExternPredicateDefinition__Group__1__Impl : ( ( rule__ExternPredicateDefinition__HeadAssignment_1 ) ) ; | 10124 | // InternalSolverLanguageParser.g:3169:1: rule__ExternPredicateDefinition__Group__1__Impl : ( ( rule__ExternPredicateDefinition__HeadAssignment_1 ) ) ; |
10997 | public final void rule__ExternPredicateDefinition__Group__1__Impl() throws RecognitionException { | 10125 | public final void rule__ExternPredicateDefinition__Group__1__Impl() throws RecognitionException { |
10998 | 10126 | ||
10999 | int stackSize = keepStackSize(); | 10127 | int stackSize = keepStackSize(); |
11000 | 10128 | ||
11001 | try { | 10129 | try { |
11002 | // InternalSolverLanguage.g:3095:1: ( ( ( rule__ExternPredicateDefinition__HeadAssignment_1 ) ) ) | 10130 | // InternalSolverLanguageParser.g:3173:1: ( ( ( rule__ExternPredicateDefinition__HeadAssignment_1 ) ) ) |
11003 | // InternalSolverLanguage.g:3096:1: ( ( rule__ExternPredicateDefinition__HeadAssignment_1 ) ) | 10131 | // InternalSolverLanguageParser.g:3174:1: ( ( rule__ExternPredicateDefinition__HeadAssignment_1 ) ) |
11004 | { | 10132 | { |
11005 | // InternalSolverLanguage.g:3096:1: ( ( rule__ExternPredicateDefinition__HeadAssignment_1 ) ) | 10133 | // InternalSolverLanguageParser.g:3174:1: ( ( rule__ExternPredicateDefinition__HeadAssignment_1 ) ) |
11006 | // InternalSolverLanguage.g:3097:2: ( rule__ExternPredicateDefinition__HeadAssignment_1 ) | 10134 | // InternalSolverLanguageParser.g:3175:2: ( rule__ExternPredicateDefinition__HeadAssignment_1 ) |
11007 | { | 10135 | { |
11008 | if ( state.backtracking==0 ) { | 10136 | before(grammarAccess.getExternPredicateDefinitionAccess().getHeadAssignment_1()); |
11009 | before(grammarAccess.getExternPredicateDefinitionAccess().getHeadAssignment_1()); | 10137 | // InternalSolverLanguageParser.g:3176:2: ( rule__ExternPredicateDefinition__HeadAssignment_1 ) |
11010 | } | 10138 | // InternalSolverLanguageParser.g:3176:3: rule__ExternPredicateDefinition__HeadAssignment_1 |
11011 | // InternalSolverLanguage.g:3098:2: ( rule__ExternPredicateDefinition__HeadAssignment_1 ) | ||
11012 | // InternalSolverLanguage.g:3098:3: rule__ExternPredicateDefinition__HeadAssignment_1 | ||
11013 | { | 10139 | { |
11014 | pushFollow(FOLLOW_2); | 10140 | pushFollow(FOLLOW_2); |
11015 | rule__ExternPredicateDefinition__HeadAssignment_1(); | 10141 | rule__ExternPredicateDefinition__HeadAssignment_1(); |
11016 | 10142 | ||
11017 | state._fsp--; | 10143 | state._fsp--; |
11018 | if (state.failed) return ; | ||
11019 | 10144 | ||
11020 | } | ||
11021 | |||
11022 | if ( state.backtracking==0 ) { | ||
11023 | after(grammarAccess.getExternPredicateDefinitionAccess().getHeadAssignment_1()); | ||
11024 | } | ||
11025 | 10145 | ||
11026 | } | 10146 | } |
11027 | 10147 | ||
11028 | 10148 | after(grammarAccess.getExternPredicateDefinitionAccess().getHeadAssignment_1()); | |
11029 | } | ||
11030 | |||
11031 | } | ||
11032 | catch (RecognitionException re) { | ||
11033 | reportError(re); | ||
11034 | recover(input,re); | ||
11035 | } | ||
11036 | finally { | ||
11037 | |||
11038 | restoreStackSize(stackSize); | ||
11039 | |||
11040 | } | ||
11041 | return ; | ||
11042 | } | ||
11043 | // $ANTLR end "rule__ExternPredicateDefinition__Group__1__Impl" | ||
11044 | |||
11045 | |||
11046 | // $ANTLR start "rule__ExternPredicateDefinition__Group__2" | ||
11047 | // InternalSolverLanguage.g:3106:1: rule__ExternPredicateDefinition__Group__2 : rule__ExternPredicateDefinition__Group__2__Impl ; | ||
11048 | public final void rule__ExternPredicateDefinition__Group__2() throws RecognitionException { | ||
11049 | |||
11050 | int stackSize = keepStackSize(); | ||
11051 | |||
11052 | try { | ||
11053 | // InternalSolverLanguage.g:3110:1: ( rule__ExternPredicateDefinition__Group__2__Impl ) | ||
11054 | // InternalSolverLanguage.g:3111:2: rule__ExternPredicateDefinition__Group__2__Impl | ||
11055 | { | ||
11056 | pushFollow(FOLLOW_2); | ||
11057 | rule__ExternPredicateDefinition__Group__2__Impl(); | ||
11058 | |||
11059 | state._fsp--; | ||
11060 | if (state.failed) return ; | ||
11061 | |||
11062 | } | ||
11063 | |||
11064 | } | ||
11065 | catch (RecognitionException re) { | ||
11066 | reportError(re); | ||
11067 | recover(input,re); | ||
11068 | } | ||
11069 | finally { | ||
11070 | |||
11071 | restoreStackSize(stackSize); | ||
11072 | |||
11073 | } | ||
11074 | return ; | ||
11075 | } | ||
11076 | // $ANTLR end "rule__ExternPredicateDefinition__Group__2" | ||
11077 | |||
11078 | |||
11079 | // $ANTLR start "rule__ExternPredicateDefinition__Group__2__Impl" | ||
11080 | // InternalSolverLanguage.g:3117:1: rule__ExternPredicateDefinition__Group__2__Impl : ( '.' ) ; | ||
11081 | public final void rule__ExternPredicateDefinition__Group__2__Impl() throws RecognitionException { | ||
11082 | |||
11083 | int stackSize = keepStackSize(); | ||
11084 | |||
11085 | try { | ||
11086 | // InternalSolverLanguage.g:3121:1: ( ( '.' ) ) | ||
11087 | // InternalSolverLanguage.g:3122:1: ( '.' ) | ||
11088 | { | ||
11089 | // InternalSolverLanguage.g:3122:1: ( '.' ) | ||
11090 | // InternalSolverLanguage.g:3123:2: '.' | ||
11091 | { | ||
11092 | if ( state.backtracking==0 ) { | ||
11093 | before(grammarAccess.getExternPredicateDefinitionAccess().getFullStopKeyword_2()); | ||
11094 | } | ||
11095 | match(input,50,FOLLOW_2); if (state.failed) return ; | ||
11096 | if ( state.backtracking==0 ) { | ||
11097 | after(grammarAccess.getExternPredicateDefinitionAccess().getFullStopKeyword_2()); | ||
11098 | } | ||
11099 | 10149 | ||
11100 | } | 10150 | } |
11101 | 10151 | ||
@@ -11114,29 +10164,29 @@ public class InternalSolverLanguageParser extends AbstractInternalContentAssistP | |||
11114 | } | 10164 | } |
11115 | return ; | 10165 | return ; |
11116 | } | 10166 | } |
11117 | // $ANTLR end "rule__ExternPredicateDefinition__Group__2__Impl" | 10167 | // $ANTLR end "rule__ExternPredicateDefinition__Group__1__Impl" |
11118 | 10168 | ||
11119 | 10169 | ||
11120 | // $ANTLR start "rule__MetricDefinition__Group__0" | 10170 | // $ANTLR start "rule__MetricDefinition__Group__0" |
11121 | // InternalSolverLanguage.g:3133:1: rule__MetricDefinition__Group__0 : rule__MetricDefinition__Group__0__Impl rule__MetricDefinition__Group__1 ; | 10171 | // InternalSolverLanguageParser.g:3185:1: rule__MetricDefinition__Group__0 : rule__MetricDefinition__Group__0__Impl rule__MetricDefinition__Group__1 ; |
11122 | public final void rule__MetricDefinition__Group__0() throws RecognitionException { | 10172 | public final void rule__MetricDefinition__Group__0() throws RecognitionException { |
11123 | 10173 | ||
11124 | int stackSize = keepStackSize(); | 10174 | int stackSize = keepStackSize(); |
11125 | 10175 | ||
11126 | try { | 10176 | try { |
11127 | // InternalSolverLanguage.g:3137:1: ( rule__MetricDefinition__Group__0__Impl rule__MetricDefinition__Group__1 ) | 10177 | // InternalSolverLanguageParser.g:3189:1: ( rule__MetricDefinition__Group__0__Impl rule__MetricDefinition__Group__1 ) |
11128 | // InternalSolverLanguage.g:3138:2: rule__MetricDefinition__Group__0__Impl rule__MetricDefinition__Group__1 | 10178 | // InternalSolverLanguageParser.g:3190:2: rule__MetricDefinition__Group__0__Impl rule__MetricDefinition__Group__1 |
11129 | { | 10179 | { |
11130 | pushFollow(FOLLOW_7); | 10180 | pushFollow(FOLLOW_7); |
11131 | rule__MetricDefinition__Group__0__Impl(); | 10181 | rule__MetricDefinition__Group__0__Impl(); |
11132 | 10182 | ||
11133 | state._fsp--; | 10183 | state._fsp--; |
11134 | if (state.failed) return ; | 10184 | |
11135 | pushFollow(FOLLOW_2); | 10185 | pushFollow(FOLLOW_2); |
11136 | rule__MetricDefinition__Group__1(); | 10186 | rule__MetricDefinition__Group__1(); |
11137 | 10187 | ||
11138 | state._fsp--; | 10188 | state._fsp--; |
11139 | if (state.failed) return ; | 10189 | |
11140 | 10190 | ||
11141 | } | 10191 | } |
11142 | 10192 | ||
@@ -11156,36 +10206,32 @@ public class InternalSolverLanguageParser extends AbstractInternalContentAssistP | |||
11156 | 10206 | ||
11157 | 10207 | ||
11158 | // $ANTLR start "rule__MetricDefinition__Group__0__Impl" | 10208 | // $ANTLR start "rule__MetricDefinition__Group__0__Impl" |
11159 | // InternalSolverLanguage.g:3145:1: rule__MetricDefinition__Group__0__Impl : ( ( rule__MetricDefinition__TypeAssignment_0 ) ) ; | 10209 | // InternalSolverLanguageParser.g:3197:1: rule__MetricDefinition__Group__0__Impl : ( ( rule__MetricDefinition__TypeAssignment_0 ) ) ; |
11160 | public final void rule__MetricDefinition__Group__0__Impl() throws RecognitionException { | 10210 | public final void rule__MetricDefinition__Group__0__Impl() throws RecognitionException { |
11161 | 10211 | ||
11162 | int stackSize = keepStackSize(); | 10212 | int stackSize = keepStackSize(); |
11163 | 10213 | ||
11164 | try { | 10214 | try { |
11165 | // InternalSolverLanguage.g:3149:1: ( ( ( rule__MetricDefinition__TypeAssignment_0 ) ) ) | 10215 | // InternalSolverLanguageParser.g:3201:1: ( ( ( rule__MetricDefinition__TypeAssignment_0 ) ) ) |
11166 | // InternalSolverLanguage.g:3150:1: ( ( rule__MetricDefinition__TypeAssignment_0 ) ) | 10216 | // InternalSolverLanguageParser.g:3202:1: ( ( rule__MetricDefinition__TypeAssignment_0 ) ) |
11167 | { | 10217 | { |
11168 | // InternalSolverLanguage.g:3150:1: ( ( rule__MetricDefinition__TypeAssignment_0 ) ) | 10218 | // InternalSolverLanguageParser.g:3202:1: ( ( rule__MetricDefinition__TypeAssignment_0 ) ) |
11169 | // InternalSolverLanguage.g:3151:2: ( rule__MetricDefinition__TypeAssignment_0 ) | 10219 | // InternalSolverLanguageParser.g:3203:2: ( rule__MetricDefinition__TypeAssignment_0 ) |
11170 | { | 10220 | { |
11171 | if ( state.backtracking==0 ) { | 10221 | before(grammarAccess.getMetricDefinitionAccess().getTypeAssignment_0()); |
11172 | before(grammarAccess.getMetricDefinitionAccess().getTypeAssignment_0()); | 10222 | // InternalSolverLanguageParser.g:3204:2: ( rule__MetricDefinition__TypeAssignment_0 ) |
11173 | } | 10223 | // InternalSolverLanguageParser.g:3204:3: rule__MetricDefinition__TypeAssignment_0 |
11174 | // InternalSolverLanguage.g:3152:2: ( rule__MetricDefinition__TypeAssignment_0 ) | ||
11175 | // InternalSolverLanguage.g:3152:3: rule__MetricDefinition__TypeAssignment_0 | ||
11176 | { | 10224 | { |
11177 | pushFollow(FOLLOW_2); | 10225 | pushFollow(FOLLOW_2); |
11178 | rule__MetricDefinition__TypeAssignment_0(); | 10226 | rule__MetricDefinition__TypeAssignment_0(); |
11179 | 10227 | ||
11180 | state._fsp--; | 10228 | state._fsp--; |
11181 | if (state.failed) return ; | ||
11182 | 10229 | ||
11183 | } | ||
11184 | 10230 | ||
11185 | if ( state.backtracking==0 ) { | ||
11186 | after(grammarAccess.getMetricDefinitionAccess().getTypeAssignment_0()); | ||
11187 | } | 10231 | } |
11188 | 10232 | ||
10233 | after(grammarAccess.getMetricDefinitionAccess().getTypeAssignment_0()); | ||
10234 | |||
11189 | } | 10235 | } |
11190 | 10236 | ||
11191 | 10237 | ||
@@ -11207,25 +10253,25 @@ public class InternalSolverLanguageParser extends AbstractInternalContentAssistP | |||
11207 | 10253 | ||
11208 | 10254 | ||
11209 | // $ANTLR start "rule__MetricDefinition__Group__1" | 10255 | // $ANTLR start "rule__MetricDefinition__Group__1" |
11210 | // InternalSolverLanguage.g:3160:1: rule__MetricDefinition__Group__1 : rule__MetricDefinition__Group__1__Impl rule__MetricDefinition__Group__2 ; | 10256 | // InternalSolverLanguageParser.g:3212:1: rule__MetricDefinition__Group__1 : rule__MetricDefinition__Group__1__Impl rule__MetricDefinition__Group__2 ; |
11211 | public final void rule__MetricDefinition__Group__1() throws RecognitionException { | 10257 | public final void rule__MetricDefinition__Group__1() throws RecognitionException { |
11212 | 10258 | ||
11213 | int stackSize = keepStackSize(); | 10259 | int stackSize = keepStackSize(); |
11214 | 10260 | ||
11215 | try { | 10261 | try { |
11216 | // InternalSolverLanguage.g:3164:1: ( rule__MetricDefinition__Group__1__Impl rule__MetricDefinition__Group__2 ) | 10262 | // InternalSolverLanguageParser.g:3216:1: ( rule__MetricDefinition__Group__1__Impl rule__MetricDefinition__Group__2 ) |
11217 | // InternalSolverLanguage.g:3165:2: rule__MetricDefinition__Group__1__Impl rule__MetricDefinition__Group__2 | 10263 | // InternalSolverLanguageParser.g:3217:2: rule__MetricDefinition__Group__1__Impl rule__MetricDefinition__Group__2 |
11218 | { | 10264 | { |
11219 | pushFollow(FOLLOW_14); | 10265 | pushFollow(FOLLOW_13); |
11220 | rule__MetricDefinition__Group__1__Impl(); | 10266 | rule__MetricDefinition__Group__1__Impl(); |
11221 | 10267 | ||
11222 | state._fsp--; | 10268 | state._fsp--; |
11223 | if (state.failed) return ; | 10269 | |
11224 | pushFollow(FOLLOW_2); | 10270 | pushFollow(FOLLOW_2); |
11225 | rule__MetricDefinition__Group__2(); | 10271 | rule__MetricDefinition__Group__2(); |
11226 | 10272 | ||
11227 | state._fsp--; | 10273 | state._fsp--; |
11228 | if (state.failed) return ; | 10274 | |
11229 | 10275 | ||
11230 | } | 10276 | } |
11231 | 10277 | ||
@@ -11245,36 +10291,32 @@ public class InternalSolverLanguageParser extends AbstractInternalContentAssistP | |||
11245 | 10291 | ||
11246 | 10292 | ||
11247 | // $ANTLR start "rule__MetricDefinition__Group__1__Impl" | 10293 | // $ANTLR start "rule__MetricDefinition__Group__1__Impl" |
11248 | // InternalSolverLanguage.g:3172:1: rule__MetricDefinition__Group__1__Impl : ( ( rule__MetricDefinition__HeadAssignment_1 ) ) ; | 10294 | // InternalSolverLanguageParser.g:3224:1: rule__MetricDefinition__Group__1__Impl : ( ( rule__MetricDefinition__HeadAssignment_1 ) ) ; |
11249 | public final void rule__MetricDefinition__Group__1__Impl() throws RecognitionException { | 10295 | public final void rule__MetricDefinition__Group__1__Impl() throws RecognitionException { |
11250 | 10296 | ||
11251 | int stackSize = keepStackSize(); | 10297 | int stackSize = keepStackSize(); |
11252 | 10298 | ||
11253 | try { | 10299 | try { |
11254 | // InternalSolverLanguage.g:3176:1: ( ( ( rule__MetricDefinition__HeadAssignment_1 ) ) ) | 10300 | // InternalSolverLanguageParser.g:3228:1: ( ( ( rule__MetricDefinition__HeadAssignment_1 ) ) ) |
11255 | // InternalSolverLanguage.g:3177:1: ( ( rule__MetricDefinition__HeadAssignment_1 ) ) | 10301 | // InternalSolverLanguageParser.g:3229:1: ( ( rule__MetricDefinition__HeadAssignment_1 ) ) |
11256 | { | 10302 | { |
11257 | // InternalSolverLanguage.g:3177:1: ( ( rule__MetricDefinition__HeadAssignment_1 ) ) | 10303 | // InternalSolverLanguageParser.g:3229:1: ( ( rule__MetricDefinition__HeadAssignment_1 ) ) |
11258 | // InternalSolverLanguage.g:3178:2: ( rule__MetricDefinition__HeadAssignment_1 ) | 10304 | // InternalSolverLanguageParser.g:3230:2: ( rule__MetricDefinition__HeadAssignment_1 ) |
11259 | { | 10305 | { |
11260 | if ( state.backtracking==0 ) { | 10306 | before(grammarAccess.getMetricDefinitionAccess().getHeadAssignment_1()); |
11261 | before(grammarAccess.getMetricDefinitionAccess().getHeadAssignment_1()); | 10307 | // InternalSolverLanguageParser.g:3231:2: ( rule__MetricDefinition__HeadAssignment_1 ) |
11262 | } | 10308 | // InternalSolverLanguageParser.g:3231:3: rule__MetricDefinition__HeadAssignment_1 |
11263 | // InternalSolverLanguage.g:3179:2: ( rule__MetricDefinition__HeadAssignment_1 ) | ||
11264 | // InternalSolverLanguage.g:3179:3: rule__MetricDefinition__HeadAssignment_1 | ||
11265 | { | 10309 | { |
11266 | pushFollow(FOLLOW_2); | 10310 | pushFollow(FOLLOW_2); |
11267 | rule__MetricDefinition__HeadAssignment_1(); | 10311 | rule__MetricDefinition__HeadAssignment_1(); |
11268 | 10312 | ||
11269 | state._fsp--; | 10313 | state._fsp--; |
11270 | if (state.failed) return ; | ||
11271 | 10314 | ||
11272 | } | ||
11273 | 10315 | ||
11274 | if ( state.backtracking==0 ) { | ||
11275 | after(grammarAccess.getMetricDefinitionAccess().getHeadAssignment_1()); | ||
11276 | } | 10316 | } |
11277 | 10317 | ||
10318 | after(grammarAccess.getMetricDefinitionAccess().getHeadAssignment_1()); | ||
10319 | |||
11278 | } | 10320 | } |
11279 | 10321 | ||
11280 | 10322 | ||
@@ -11296,25 +10338,25 @@ public class InternalSolverLanguageParser extends AbstractInternalContentAssistP | |||
11296 | 10338 | ||
11297 | 10339 | ||
11298 | // $ANTLR start "rule__MetricDefinition__Group__2" | 10340 | // $ANTLR start "rule__MetricDefinition__Group__2" |
11299 | // InternalSolverLanguage.g:3187:1: rule__MetricDefinition__Group__2 : rule__MetricDefinition__Group__2__Impl rule__MetricDefinition__Group__3 ; | 10341 | // InternalSolverLanguageParser.g:3239:1: rule__MetricDefinition__Group__2 : rule__MetricDefinition__Group__2__Impl rule__MetricDefinition__Group__3 ; |
11300 | public final void rule__MetricDefinition__Group__2() throws RecognitionException { | 10342 | public final void rule__MetricDefinition__Group__2() throws RecognitionException { |
11301 | 10343 | ||
11302 | int stackSize = keepStackSize(); | 10344 | int stackSize = keepStackSize(); |
11303 | 10345 | ||
11304 | try { | 10346 | try { |
11305 | // InternalSolverLanguage.g:3191:1: ( rule__MetricDefinition__Group__2__Impl rule__MetricDefinition__Group__3 ) | 10347 | // InternalSolverLanguageParser.g:3243:1: ( rule__MetricDefinition__Group__2__Impl rule__MetricDefinition__Group__3 ) |
11306 | // InternalSolverLanguage.g:3192:2: rule__MetricDefinition__Group__2__Impl rule__MetricDefinition__Group__3 | 10348 | // InternalSolverLanguageParser.g:3244:2: rule__MetricDefinition__Group__2__Impl rule__MetricDefinition__Group__3 |
11307 | { | 10349 | { |
11308 | pushFollow(FOLLOW_7); | 10350 | pushFollow(FOLLOW_7); |
11309 | rule__MetricDefinition__Group__2__Impl(); | 10351 | rule__MetricDefinition__Group__2__Impl(); |
11310 | 10352 | ||
11311 | state._fsp--; | 10353 | state._fsp--; |
11312 | if (state.failed) return ; | 10354 | |
11313 | pushFollow(FOLLOW_2); | 10355 | pushFollow(FOLLOW_2); |
11314 | rule__MetricDefinition__Group__3(); | 10356 | rule__MetricDefinition__Group__3(); |
11315 | 10357 | ||
11316 | state._fsp--; | 10358 | state._fsp--; |
11317 | if (state.failed) return ; | 10359 | |
11318 | 10360 | ||
11319 | } | 10361 | } |
11320 | 10362 | ||
@@ -11334,25 +10376,21 @@ public class InternalSolverLanguageParser extends AbstractInternalContentAssistP | |||
11334 | 10376 | ||
11335 | 10377 | ||
11336 | // $ANTLR start "rule__MetricDefinition__Group__2__Impl" | 10378 | // $ANTLR start "rule__MetricDefinition__Group__2__Impl" |
11337 | // InternalSolverLanguage.g:3199:1: rule__MetricDefinition__Group__2__Impl : ( '=' ) ; | 10379 | // InternalSolverLanguageParser.g:3251:1: rule__MetricDefinition__Group__2__Impl : ( EqualsSign ) ; |
11338 | public final void rule__MetricDefinition__Group__2__Impl() throws RecognitionException { | 10380 | public final void rule__MetricDefinition__Group__2__Impl() throws RecognitionException { |
11339 | 10381 | ||
11340 | int stackSize = keepStackSize(); | 10382 | int stackSize = keepStackSize(); |
11341 | 10383 | ||
11342 | try { | 10384 | try { |
11343 | // InternalSolverLanguage.g:3203:1: ( ( '=' ) ) | 10385 | // InternalSolverLanguageParser.g:3255:1: ( ( EqualsSign ) ) |
11344 | // InternalSolverLanguage.g:3204:1: ( '=' ) | 10386 | // InternalSolverLanguageParser.g:3256:1: ( EqualsSign ) |
11345 | { | 10387 | { |
11346 | // InternalSolverLanguage.g:3204:1: ( '=' ) | 10388 | // InternalSolverLanguageParser.g:3256:1: ( EqualsSign ) |
11347 | // InternalSolverLanguage.g:3205:2: '=' | 10389 | // InternalSolverLanguageParser.g:3257:2: EqualsSign |
11348 | { | 10390 | { |
11349 | if ( state.backtracking==0 ) { | 10391 | before(grammarAccess.getMetricDefinitionAccess().getEqualsSignKeyword_2()); |
11350 | before(grammarAccess.getMetricDefinitionAccess().getEqualsSignKeyword_2()); | 10392 | match(input,EqualsSign,FOLLOW_2); |
11351 | } | 10393 | after(grammarAccess.getMetricDefinitionAccess().getEqualsSignKeyword_2()); |
11352 | match(input,47,FOLLOW_2); if (state.failed) return ; | ||
11353 | if ( state.backtracking==0 ) { | ||
11354 | after(grammarAccess.getMetricDefinitionAccess().getEqualsSignKeyword_2()); | ||
11355 | } | ||
11356 | 10394 | ||
11357 | } | 10395 | } |
11358 | 10396 | ||
@@ -11375,20 +10413,20 @@ public class InternalSolverLanguageParser extends AbstractInternalContentAssistP | |||
11375 | 10413 | ||
11376 | 10414 | ||
11377 | // $ANTLR start "rule__MetricDefinition__Group__3" | 10415 | // $ANTLR start "rule__MetricDefinition__Group__3" |
11378 | // InternalSolverLanguage.g:3214:1: rule__MetricDefinition__Group__3 : rule__MetricDefinition__Group__3__Impl ; | 10416 | // InternalSolverLanguageParser.g:3266:1: rule__MetricDefinition__Group__3 : rule__MetricDefinition__Group__3__Impl ; |
11379 | public final void rule__MetricDefinition__Group__3() throws RecognitionException { | 10417 | public final void rule__MetricDefinition__Group__3() throws RecognitionException { |
11380 | 10418 | ||
11381 | int stackSize = keepStackSize(); | 10419 | int stackSize = keepStackSize(); |
11382 | 10420 | ||
11383 | try { | 10421 | try { |
11384 | // InternalSolverLanguage.g:3218:1: ( rule__MetricDefinition__Group__3__Impl ) | 10422 | // InternalSolverLanguageParser.g:3270:1: ( rule__MetricDefinition__Group__3__Impl ) |
11385 | // InternalSolverLanguage.g:3219:2: rule__MetricDefinition__Group__3__Impl | 10423 | // InternalSolverLanguageParser.g:3271:2: rule__MetricDefinition__Group__3__Impl |
11386 | { | 10424 | { |
11387 | pushFollow(FOLLOW_2); | 10425 | pushFollow(FOLLOW_2); |
11388 | rule__MetricDefinition__Group__3__Impl(); | 10426 | rule__MetricDefinition__Group__3__Impl(); |
11389 | 10427 | ||
11390 | state._fsp--; | 10428 | state._fsp--; |
11391 | if (state.failed) return ; | 10429 | |
11392 | 10430 | ||
11393 | } | 10431 | } |
11394 | 10432 | ||
@@ -11408,36 +10446,32 @@ public class InternalSolverLanguageParser extends AbstractInternalContentAssistP | |||
11408 | 10446 | ||
11409 | 10447 | ||
11410 | // $ANTLR start "rule__MetricDefinition__Group__3__Impl" | 10448 | // $ANTLR start "rule__MetricDefinition__Group__3__Impl" |
11411 | // InternalSolverLanguage.g:3225:1: rule__MetricDefinition__Group__3__Impl : ( ( rule__MetricDefinition__BodyAssignment_3 ) ) ; | 10449 | // InternalSolverLanguageParser.g:3277:1: rule__MetricDefinition__Group__3__Impl : ( ( rule__MetricDefinition__BodyAssignment_3 ) ) ; |
11412 | public final void rule__MetricDefinition__Group__3__Impl() throws RecognitionException { | 10450 | public final void rule__MetricDefinition__Group__3__Impl() throws RecognitionException { |
11413 | 10451 | ||
11414 | int stackSize = keepStackSize(); | 10452 | int stackSize = keepStackSize(); |
11415 | 10453 | ||
11416 | try { | 10454 | try { |
11417 | // InternalSolverLanguage.g:3229:1: ( ( ( rule__MetricDefinition__BodyAssignment_3 ) ) ) | 10455 | // InternalSolverLanguageParser.g:3281:1: ( ( ( rule__MetricDefinition__BodyAssignment_3 ) ) ) |
11418 | // InternalSolverLanguage.g:3230:1: ( ( rule__MetricDefinition__BodyAssignment_3 ) ) | 10456 | // InternalSolverLanguageParser.g:3282:1: ( ( rule__MetricDefinition__BodyAssignment_3 ) ) |
11419 | { | 10457 | { |
11420 | // InternalSolverLanguage.g:3230:1: ( ( rule__MetricDefinition__BodyAssignment_3 ) ) | 10458 | // InternalSolverLanguageParser.g:3282:1: ( ( rule__MetricDefinition__BodyAssignment_3 ) ) |
11421 | // InternalSolverLanguage.g:3231:2: ( rule__MetricDefinition__BodyAssignment_3 ) | 10459 | // InternalSolverLanguageParser.g:3283:2: ( rule__MetricDefinition__BodyAssignment_3 ) |
11422 | { | 10460 | { |
11423 | if ( state.backtracking==0 ) { | 10461 | before(grammarAccess.getMetricDefinitionAccess().getBodyAssignment_3()); |
11424 | before(grammarAccess.getMetricDefinitionAccess().getBodyAssignment_3()); | 10462 | // InternalSolverLanguageParser.g:3284:2: ( rule__MetricDefinition__BodyAssignment_3 ) |
11425 | } | 10463 | // InternalSolverLanguageParser.g:3284:3: rule__MetricDefinition__BodyAssignment_3 |
11426 | // InternalSolverLanguage.g:3232:2: ( rule__MetricDefinition__BodyAssignment_3 ) | ||
11427 | // InternalSolverLanguage.g:3232:3: rule__MetricDefinition__BodyAssignment_3 | ||
11428 | { | 10464 | { |
11429 | pushFollow(FOLLOW_2); | 10465 | pushFollow(FOLLOW_2); |
11430 | rule__MetricDefinition__BodyAssignment_3(); | 10466 | rule__MetricDefinition__BodyAssignment_3(); |
11431 | 10467 | ||
11432 | state._fsp--; | 10468 | state._fsp--; |
11433 | if (state.failed) return ; | ||
11434 | 10469 | ||
11435 | } | ||
11436 | 10470 | ||
11437 | if ( state.backtracking==0 ) { | ||
11438 | after(grammarAccess.getMetricDefinitionAccess().getBodyAssignment_3()); | ||
11439 | } | 10471 | } |
11440 | 10472 | ||
10473 | after(grammarAccess.getMetricDefinitionAccess().getBodyAssignment_3()); | ||
10474 | |||
11441 | } | 10475 | } |
11442 | 10476 | ||
11443 | 10477 | ||
@@ -11459,25 +10493,25 @@ public class InternalSolverLanguageParser extends AbstractInternalContentAssistP | |||
11459 | 10493 | ||
11460 | 10494 | ||
11461 | // $ANTLR start "rule__ExternMetricDefinition__Group__0" | 10495 | // $ANTLR start "rule__ExternMetricDefinition__Group__0" |
11462 | // InternalSolverLanguage.g:3241:1: rule__ExternMetricDefinition__Group__0 : rule__ExternMetricDefinition__Group__0__Impl rule__ExternMetricDefinition__Group__1 ; | 10496 | // InternalSolverLanguageParser.g:3293:1: rule__ExternMetricDefinition__Group__0 : rule__ExternMetricDefinition__Group__0__Impl rule__ExternMetricDefinition__Group__1 ; |
11463 | public final void rule__ExternMetricDefinition__Group__0() throws RecognitionException { | 10497 | public final void rule__ExternMetricDefinition__Group__0() throws RecognitionException { |
11464 | 10498 | ||
11465 | int stackSize = keepStackSize(); | 10499 | int stackSize = keepStackSize(); |
11466 | 10500 | ||
11467 | try { | 10501 | try { |
11468 | // InternalSolverLanguage.g:3245:1: ( rule__ExternMetricDefinition__Group__0__Impl rule__ExternMetricDefinition__Group__1 ) | 10502 | // InternalSolverLanguageParser.g:3297:1: ( rule__ExternMetricDefinition__Group__0__Impl rule__ExternMetricDefinition__Group__1 ) |
11469 | // InternalSolverLanguage.g:3246:2: rule__ExternMetricDefinition__Group__0__Impl rule__ExternMetricDefinition__Group__1 | 10503 | // InternalSolverLanguageParser.g:3298:2: rule__ExternMetricDefinition__Group__0__Impl rule__ExternMetricDefinition__Group__1 |
11470 | { | 10504 | { |
11471 | pushFollow(FOLLOW_15); | 10505 | pushFollow(FOLLOW_14); |
11472 | rule__ExternMetricDefinition__Group__0__Impl(); | 10506 | rule__ExternMetricDefinition__Group__0__Impl(); |
11473 | 10507 | ||
11474 | state._fsp--; | 10508 | state._fsp--; |
11475 | if (state.failed) return ; | 10509 | |
11476 | pushFollow(FOLLOW_2); | 10510 | pushFollow(FOLLOW_2); |
11477 | rule__ExternMetricDefinition__Group__1(); | 10511 | rule__ExternMetricDefinition__Group__1(); |
11478 | 10512 | ||
11479 | state._fsp--; | 10513 | state._fsp--; |
11480 | if (state.failed) return ; | 10514 | |
11481 | 10515 | ||
11482 | } | 10516 | } |
11483 | 10517 | ||
@@ -11497,25 +10531,21 @@ public class InternalSolverLanguageParser extends AbstractInternalContentAssistP | |||
11497 | 10531 | ||
11498 | 10532 | ||
11499 | // $ANTLR start "rule__ExternMetricDefinition__Group__0__Impl" | 10533 | // $ANTLR start "rule__ExternMetricDefinition__Group__0__Impl" |
11500 | // InternalSolverLanguage.g:3253:1: rule__ExternMetricDefinition__Group__0__Impl : ( 'extern' ) ; | 10534 | // InternalSolverLanguageParser.g:3305:1: rule__ExternMetricDefinition__Group__0__Impl : ( Extern ) ; |
11501 | public final void rule__ExternMetricDefinition__Group__0__Impl() throws RecognitionException { | 10535 | public final void rule__ExternMetricDefinition__Group__0__Impl() throws RecognitionException { |
11502 | 10536 | ||
11503 | int stackSize = keepStackSize(); | 10537 | int stackSize = keepStackSize(); |
11504 | 10538 | ||
11505 | try { | 10539 | try { |
11506 | // InternalSolverLanguage.g:3257:1: ( ( 'extern' ) ) | 10540 | // InternalSolverLanguageParser.g:3309:1: ( ( Extern ) ) |
11507 | // InternalSolverLanguage.g:3258:1: ( 'extern' ) | 10541 | // InternalSolverLanguageParser.g:3310:1: ( Extern ) |
11508 | { | 10542 | { |
11509 | // InternalSolverLanguage.g:3258:1: ( 'extern' ) | 10543 | // InternalSolverLanguageParser.g:3310:1: ( Extern ) |
11510 | // InternalSolverLanguage.g:3259:2: 'extern' | 10544 | // InternalSolverLanguageParser.g:3311:2: Extern |
11511 | { | 10545 | { |
11512 | if ( state.backtracking==0 ) { | 10546 | before(grammarAccess.getExternMetricDefinitionAccess().getExternKeyword_0()); |
11513 | before(grammarAccess.getExternMetricDefinitionAccess().getExternKeyword_0()); | 10547 | match(input,Extern,FOLLOW_2); |
11514 | } | 10548 | after(grammarAccess.getExternMetricDefinitionAccess().getExternKeyword_0()); |
11515 | match(input,49,FOLLOW_2); if (state.failed) return ; | ||
11516 | if ( state.backtracking==0 ) { | ||
11517 | after(grammarAccess.getExternMetricDefinitionAccess().getExternKeyword_0()); | ||
11518 | } | ||
11519 | 10549 | ||
11520 | } | 10550 | } |
11521 | 10551 | ||
@@ -11538,25 +10568,25 @@ public class InternalSolverLanguageParser extends AbstractInternalContentAssistP | |||
11538 | 10568 | ||
11539 | 10569 | ||
11540 | // $ANTLR start "rule__ExternMetricDefinition__Group__1" | 10570 | // $ANTLR start "rule__ExternMetricDefinition__Group__1" |
11541 | // InternalSolverLanguage.g:3268:1: rule__ExternMetricDefinition__Group__1 : rule__ExternMetricDefinition__Group__1__Impl rule__ExternMetricDefinition__Group__2 ; | 10571 | // InternalSolverLanguageParser.g:3320:1: rule__ExternMetricDefinition__Group__1 : rule__ExternMetricDefinition__Group__1__Impl rule__ExternMetricDefinition__Group__2 ; |
11542 | public final void rule__ExternMetricDefinition__Group__1() throws RecognitionException { | 10572 | public final void rule__ExternMetricDefinition__Group__1() throws RecognitionException { |
11543 | 10573 | ||
11544 | int stackSize = keepStackSize(); | 10574 | int stackSize = keepStackSize(); |
11545 | 10575 | ||
11546 | try { | 10576 | try { |
11547 | // InternalSolverLanguage.g:3272:1: ( rule__ExternMetricDefinition__Group__1__Impl rule__ExternMetricDefinition__Group__2 ) | 10577 | // InternalSolverLanguageParser.g:3324:1: ( rule__ExternMetricDefinition__Group__1__Impl rule__ExternMetricDefinition__Group__2 ) |
11548 | // InternalSolverLanguage.g:3273:2: rule__ExternMetricDefinition__Group__1__Impl rule__ExternMetricDefinition__Group__2 | 10578 | // InternalSolverLanguageParser.g:3325:2: rule__ExternMetricDefinition__Group__1__Impl rule__ExternMetricDefinition__Group__2 |
11549 | { | 10579 | { |
11550 | pushFollow(FOLLOW_9); | 10580 | pushFollow(FOLLOW_9); |
11551 | rule__ExternMetricDefinition__Group__1__Impl(); | 10581 | rule__ExternMetricDefinition__Group__1__Impl(); |
11552 | 10582 | ||
11553 | state._fsp--; | 10583 | state._fsp--; |
11554 | if (state.failed) return ; | 10584 | |
11555 | pushFollow(FOLLOW_2); | 10585 | pushFollow(FOLLOW_2); |
11556 | rule__ExternMetricDefinition__Group__2(); | 10586 | rule__ExternMetricDefinition__Group__2(); |
11557 | 10587 | ||
11558 | state._fsp--; | 10588 | state._fsp--; |
11559 | if (state.failed) return ; | 10589 | |
11560 | 10590 | ||
11561 | } | 10591 | } |
11562 | 10592 | ||
@@ -11576,36 +10606,32 @@ public class InternalSolverLanguageParser extends AbstractInternalContentAssistP | |||
11576 | 10606 | ||
11577 | 10607 | ||
11578 | // $ANTLR start "rule__ExternMetricDefinition__Group__1__Impl" | 10608 | // $ANTLR start "rule__ExternMetricDefinition__Group__1__Impl" |
11579 | // InternalSolverLanguage.g:3280:1: rule__ExternMetricDefinition__Group__1__Impl : ( ( rule__ExternMetricDefinition__TypeAssignment_1 ) ) ; | 10609 | // InternalSolverLanguageParser.g:3332:1: rule__ExternMetricDefinition__Group__1__Impl : ( ( rule__ExternMetricDefinition__TypeAssignment_1 ) ) ; |
11580 | public final void rule__ExternMetricDefinition__Group__1__Impl() throws RecognitionException { | 10610 | public final void rule__ExternMetricDefinition__Group__1__Impl() throws RecognitionException { |
11581 | 10611 | ||
11582 | int stackSize = keepStackSize(); | 10612 | int stackSize = keepStackSize(); |
11583 | 10613 | ||
11584 | try { | 10614 | try { |
11585 | // InternalSolverLanguage.g:3284:1: ( ( ( rule__ExternMetricDefinition__TypeAssignment_1 ) ) ) | 10615 | // InternalSolverLanguageParser.g:3336:1: ( ( ( rule__ExternMetricDefinition__TypeAssignment_1 ) ) ) |
11586 | // InternalSolverLanguage.g:3285:1: ( ( rule__ExternMetricDefinition__TypeAssignment_1 ) ) | 10616 | // InternalSolverLanguageParser.g:3337:1: ( ( rule__ExternMetricDefinition__TypeAssignment_1 ) ) |
11587 | { | 10617 | { |
11588 | // InternalSolverLanguage.g:3285:1: ( ( rule__ExternMetricDefinition__TypeAssignment_1 ) ) | 10618 | // InternalSolverLanguageParser.g:3337:1: ( ( rule__ExternMetricDefinition__TypeAssignment_1 ) ) |
11589 | // InternalSolverLanguage.g:3286:2: ( rule__ExternMetricDefinition__TypeAssignment_1 ) | 10619 | // InternalSolverLanguageParser.g:3338:2: ( rule__ExternMetricDefinition__TypeAssignment_1 ) |
11590 | { | 10620 | { |
11591 | if ( state.backtracking==0 ) { | 10621 | before(grammarAccess.getExternMetricDefinitionAccess().getTypeAssignment_1()); |
11592 | before(grammarAccess.getExternMetricDefinitionAccess().getTypeAssignment_1()); | 10622 | // InternalSolverLanguageParser.g:3339:2: ( rule__ExternMetricDefinition__TypeAssignment_1 ) |
11593 | } | 10623 | // InternalSolverLanguageParser.g:3339:3: rule__ExternMetricDefinition__TypeAssignment_1 |
11594 | // InternalSolverLanguage.g:3287:2: ( rule__ExternMetricDefinition__TypeAssignment_1 ) | ||
11595 | // InternalSolverLanguage.g:3287:3: rule__ExternMetricDefinition__TypeAssignment_1 | ||
11596 | { | 10624 | { |
11597 | pushFollow(FOLLOW_2); | 10625 | pushFollow(FOLLOW_2); |
11598 | rule__ExternMetricDefinition__TypeAssignment_1(); | 10626 | rule__ExternMetricDefinition__TypeAssignment_1(); |
11599 | 10627 | ||
11600 | state._fsp--; | 10628 | state._fsp--; |
11601 | if (state.failed) return ; | ||
11602 | 10629 | ||
11603 | } | ||
11604 | 10630 | ||
11605 | if ( state.backtracking==0 ) { | ||
11606 | after(grammarAccess.getExternMetricDefinitionAccess().getTypeAssignment_1()); | ||
11607 | } | 10631 | } |
11608 | 10632 | ||
10633 | after(grammarAccess.getExternMetricDefinitionAccess().getTypeAssignment_1()); | ||
10634 | |||
11609 | } | 10635 | } |
11610 | 10636 | ||
11611 | 10637 | ||
@@ -11627,20 +10653,20 @@ public class InternalSolverLanguageParser extends AbstractInternalContentAssistP | |||
11627 | 10653 | ||
11628 | 10654 | ||
11629 | // $ANTLR start "rule__ExternMetricDefinition__Group__2" | 10655 | // $ANTLR start "rule__ExternMetricDefinition__Group__2" |
11630 | // InternalSolverLanguage.g:3295:1: rule__ExternMetricDefinition__Group__2 : rule__ExternMetricDefinition__Group__2__Impl ; | 10656 | // InternalSolverLanguageParser.g:3347:1: rule__ExternMetricDefinition__Group__2 : rule__ExternMetricDefinition__Group__2__Impl ; |
11631 | public final void rule__ExternMetricDefinition__Group__2() throws RecognitionException { | 10657 | public final void rule__ExternMetricDefinition__Group__2() throws RecognitionException { |
11632 | 10658 | ||
11633 | int stackSize = keepStackSize(); | 10659 | int stackSize = keepStackSize(); |
11634 | 10660 | ||
11635 | try { | 10661 | try { |
11636 | // InternalSolverLanguage.g:3299:1: ( rule__ExternMetricDefinition__Group__2__Impl ) | 10662 | // InternalSolverLanguageParser.g:3351:1: ( rule__ExternMetricDefinition__Group__2__Impl ) |
11637 | // InternalSolverLanguage.g:3300:2: rule__ExternMetricDefinition__Group__2__Impl | 10663 | // InternalSolverLanguageParser.g:3352:2: rule__ExternMetricDefinition__Group__2__Impl |
11638 | { | 10664 | { |
11639 | pushFollow(FOLLOW_2); | 10665 | pushFollow(FOLLOW_2); |
11640 | rule__ExternMetricDefinition__Group__2__Impl(); | 10666 | rule__ExternMetricDefinition__Group__2__Impl(); |
11641 | 10667 | ||
11642 | state._fsp--; | 10668 | state._fsp--; |
11643 | if (state.failed) return ; | 10669 | |
11644 | 10670 | ||
11645 | } | 10671 | } |
11646 | 10672 | ||
@@ -11660,36 +10686,32 @@ public class InternalSolverLanguageParser extends AbstractInternalContentAssistP | |||
11660 | 10686 | ||
11661 | 10687 | ||
11662 | // $ANTLR start "rule__ExternMetricDefinition__Group__2__Impl" | 10688 | // $ANTLR start "rule__ExternMetricDefinition__Group__2__Impl" |
11663 | // InternalSolverLanguage.g:3306:1: rule__ExternMetricDefinition__Group__2__Impl : ( ( rule__ExternMetricDefinition__HeadAssignment_2 ) ) ; | 10689 | // InternalSolverLanguageParser.g:3358:1: rule__ExternMetricDefinition__Group__2__Impl : ( ( rule__ExternMetricDefinition__HeadAssignment_2 ) ) ; |
11664 | public final void rule__ExternMetricDefinition__Group__2__Impl() throws RecognitionException { | 10690 | public final void rule__ExternMetricDefinition__Group__2__Impl() throws RecognitionException { |
11665 | 10691 | ||
11666 | int stackSize = keepStackSize(); | 10692 | int stackSize = keepStackSize(); |
11667 | 10693 | ||
11668 | try { | 10694 | try { |
11669 | // InternalSolverLanguage.g:3310:1: ( ( ( rule__ExternMetricDefinition__HeadAssignment_2 ) ) ) | 10695 | // InternalSolverLanguageParser.g:3362:1: ( ( ( rule__ExternMetricDefinition__HeadAssignment_2 ) ) ) |
11670 | // InternalSolverLanguage.g:3311:1: ( ( rule__ExternMetricDefinition__HeadAssignment_2 ) ) | 10696 | // InternalSolverLanguageParser.g:3363:1: ( ( rule__ExternMetricDefinition__HeadAssignment_2 ) ) |
11671 | { | 10697 | { |
11672 | // InternalSolverLanguage.g:3311:1: ( ( rule__ExternMetricDefinition__HeadAssignment_2 ) ) | 10698 | // InternalSolverLanguageParser.g:3363:1: ( ( rule__ExternMetricDefinition__HeadAssignment_2 ) ) |
11673 | // InternalSolverLanguage.g:3312:2: ( rule__ExternMetricDefinition__HeadAssignment_2 ) | 10699 | // InternalSolverLanguageParser.g:3364:2: ( rule__ExternMetricDefinition__HeadAssignment_2 ) |
11674 | { | 10700 | { |
11675 | if ( state.backtracking==0 ) { | 10701 | before(grammarAccess.getExternMetricDefinitionAccess().getHeadAssignment_2()); |
11676 | before(grammarAccess.getExternMetricDefinitionAccess().getHeadAssignment_2()); | 10702 | // InternalSolverLanguageParser.g:3365:2: ( rule__ExternMetricDefinition__HeadAssignment_2 ) |
11677 | } | 10703 | // InternalSolverLanguageParser.g:3365:3: rule__ExternMetricDefinition__HeadAssignment_2 |
11678 | // InternalSolverLanguage.g:3313:2: ( rule__ExternMetricDefinition__HeadAssignment_2 ) | ||
11679 | // InternalSolverLanguage.g:3313:3: rule__ExternMetricDefinition__HeadAssignment_2 | ||
11680 | { | 10704 | { |
11681 | pushFollow(FOLLOW_2); | 10705 | pushFollow(FOLLOW_2); |
11682 | rule__ExternMetricDefinition__HeadAssignment_2(); | 10706 | rule__ExternMetricDefinition__HeadAssignment_2(); |
11683 | 10707 | ||
11684 | state._fsp--; | 10708 | state._fsp--; |
11685 | if (state.failed) return ; | ||
11686 | 10709 | ||
11687 | } | ||
11688 | 10710 | ||
11689 | if ( state.backtracking==0 ) { | ||
11690 | after(grammarAccess.getExternMetricDefinitionAccess().getHeadAssignment_2()); | ||
11691 | } | 10711 | } |
11692 | 10712 | ||
10713 | after(grammarAccess.getExternMetricDefinitionAccess().getHeadAssignment_2()); | ||
10714 | |||
11693 | } | 10715 | } |
11694 | 10716 | ||
11695 | 10717 | ||
@@ -11711,25 +10733,25 @@ public class InternalSolverLanguageParser extends AbstractInternalContentAssistP | |||
11711 | 10733 | ||
11712 | 10734 | ||
11713 | // $ANTLR start "rule__IfElse__Group__0" | 10735 | // $ANTLR start "rule__IfElse__Group__0" |
11714 | // InternalSolverLanguage.g:3322:1: rule__IfElse__Group__0 : rule__IfElse__Group__0__Impl rule__IfElse__Group__1 ; | 10736 | // InternalSolverLanguageParser.g:3374:1: rule__IfElse__Group__0 : rule__IfElse__Group__0__Impl rule__IfElse__Group__1 ; |
11715 | public final void rule__IfElse__Group__0() throws RecognitionException { | 10737 | public final void rule__IfElse__Group__0() throws RecognitionException { |
11716 | 10738 | ||
11717 | int stackSize = keepStackSize(); | 10739 | int stackSize = keepStackSize(); |
11718 | 10740 | ||
11719 | try { | 10741 | try { |
11720 | // InternalSolverLanguage.g:3326:1: ( rule__IfElse__Group__0__Impl rule__IfElse__Group__1 ) | 10742 | // InternalSolverLanguageParser.g:3378:1: ( rule__IfElse__Group__0__Impl rule__IfElse__Group__1 ) |
11721 | // InternalSolverLanguage.g:3327:2: rule__IfElse__Group__0__Impl rule__IfElse__Group__1 | 10743 | // InternalSolverLanguageParser.g:3379:2: rule__IfElse__Group__0__Impl rule__IfElse__Group__1 |
11722 | { | 10744 | { |
11723 | pushFollow(FOLLOW_7); | 10745 | pushFollow(FOLLOW_7); |
11724 | rule__IfElse__Group__0__Impl(); | 10746 | rule__IfElse__Group__0__Impl(); |
11725 | 10747 | ||
11726 | state._fsp--; | 10748 | state._fsp--; |
11727 | if (state.failed) return ; | 10749 | |
11728 | pushFollow(FOLLOW_2); | 10750 | pushFollow(FOLLOW_2); |
11729 | rule__IfElse__Group__1(); | 10751 | rule__IfElse__Group__1(); |
11730 | 10752 | ||
11731 | state._fsp--; | 10753 | state._fsp--; |
11732 | if (state.failed) return ; | 10754 | |
11733 | 10755 | ||
11734 | } | 10756 | } |
11735 | 10757 | ||
@@ -11749,25 +10771,21 @@ public class InternalSolverLanguageParser extends AbstractInternalContentAssistP | |||
11749 | 10771 | ||
11750 | 10772 | ||
11751 | // $ANTLR start "rule__IfElse__Group__0__Impl" | 10773 | // $ANTLR start "rule__IfElse__Group__0__Impl" |
11752 | // InternalSolverLanguage.g:3334:1: rule__IfElse__Group__0__Impl : ( 'if' ) ; | 10774 | // InternalSolverLanguageParser.g:3386:1: rule__IfElse__Group__0__Impl : ( If ) ; |
11753 | public final void rule__IfElse__Group__0__Impl() throws RecognitionException { | 10775 | public final void rule__IfElse__Group__0__Impl() throws RecognitionException { |
11754 | 10776 | ||
11755 | int stackSize = keepStackSize(); | 10777 | int stackSize = keepStackSize(); |
11756 | 10778 | ||
11757 | try { | 10779 | try { |
11758 | // InternalSolverLanguage.g:3338:1: ( ( 'if' ) ) | 10780 | // InternalSolverLanguageParser.g:3390:1: ( ( If ) ) |
11759 | // InternalSolverLanguage.g:3339:1: ( 'if' ) | 10781 | // InternalSolverLanguageParser.g:3391:1: ( If ) |
11760 | { | 10782 | { |
11761 | // InternalSolverLanguage.g:3339:1: ( 'if' ) | 10783 | // InternalSolverLanguageParser.g:3391:1: ( If ) |
11762 | // InternalSolverLanguage.g:3340:2: 'if' | 10784 | // InternalSolverLanguageParser.g:3392:2: If |
11763 | { | 10785 | { |
11764 | if ( state.backtracking==0 ) { | 10786 | before(grammarAccess.getIfElseAccess().getIfKeyword_0()); |
11765 | before(grammarAccess.getIfElseAccess().getIfKeyword_0()); | 10787 | match(input,If,FOLLOW_2); |
11766 | } | 10788 | after(grammarAccess.getIfElseAccess().getIfKeyword_0()); |
11767 | match(input,51,FOLLOW_2); if (state.failed) return ; | ||
11768 | if ( state.backtracking==0 ) { | ||
11769 | after(grammarAccess.getIfElseAccess().getIfKeyword_0()); | ||
11770 | } | ||
11771 | 10789 | ||
11772 | } | 10790 | } |
11773 | 10791 | ||
@@ -11790,25 +10808,25 @@ public class InternalSolverLanguageParser extends AbstractInternalContentAssistP | |||
11790 | 10808 | ||
11791 | 10809 | ||
11792 | // $ANTLR start "rule__IfElse__Group__1" | 10810 | // $ANTLR start "rule__IfElse__Group__1" |
11793 | // InternalSolverLanguage.g:3349:1: rule__IfElse__Group__1 : rule__IfElse__Group__1__Impl rule__IfElse__Group__2 ; | 10811 | // InternalSolverLanguageParser.g:3401:1: rule__IfElse__Group__1 : rule__IfElse__Group__1__Impl rule__IfElse__Group__2 ; |
11794 | public final void rule__IfElse__Group__1() throws RecognitionException { | 10812 | public final void rule__IfElse__Group__1() throws RecognitionException { |
11795 | 10813 | ||
11796 | int stackSize = keepStackSize(); | 10814 | int stackSize = keepStackSize(); |
11797 | 10815 | ||
11798 | try { | 10816 | try { |
11799 | // InternalSolverLanguage.g:3353:1: ( rule__IfElse__Group__1__Impl rule__IfElse__Group__2 ) | 10817 | // InternalSolverLanguageParser.g:3405:1: ( rule__IfElse__Group__1__Impl rule__IfElse__Group__2 ) |
11800 | // InternalSolverLanguage.g:3354:2: rule__IfElse__Group__1__Impl rule__IfElse__Group__2 | 10818 | // InternalSolverLanguageParser.g:3406:2: rule__IfElse__Group__1__Impl rule__IfElse__Group__2 |
11801 | { | 10819 | { |
11802 | pushFollow(FOLLOW_16); | 10820 | pushFollow(FOLLOW_15); |
11803 | rule__IfElse__Group__1__Impl(); | 10821 | rule__IfElse__Group__1__Impl(); |
11804 | 10822 | ||
11805 | state._fsp--; | 10823 | state._fsp--; |
11806 | if (state.failed) return ; | 10824 | |
11807 | pushFollow(FOLLOW_2); | 10825 | pushFollow(FOLLOW_2); |
11808 | rule__IfElse__Group__2(); | 10826 | rule__IfElse__Group__2(); |
11809 | 10827 | ||
11810 | state._fsp--; | 10828 | state._fsp--; |
11811 | if (state.failed) return ; | 10829 | |
11812 | 10830 | ||
11813 | } | 10831 | } |
11814 | 10832 | ||
@@ -11828,36 +10846,32 @@ public class InternalSolverLanguageParser extends AbstractInternalContentAssistP | |||
11828 | 10846 | ||
11829 | 10847 | ||
11830 | // $ANTLR start "rule__IfElse__Group__1__Impl" | 10848 | // $ANTLR start "rule__IfElse__Group__1__Impl" |
11831 | // InternalSolverLanguage.g:3361:1: rule__IfElse__Group__1__Impl : ( ( rule__IfElse__ConditionAssignment_1 ) ) ; | 10849 | // InternalSolverLanguageParser.g:3413:1: rule__IfElse__Group__1__Impl : ( ( rule__IfElse__ConditionAssignment_1 ) ) ; |
11832 | public final void rule__IfElse__Group__1__Impl() throws RecognitionException { | 10850 | public final void rule__IfElse__Group__1__Impl() throws RecognitionException { |
11833 | 10851 | ||
11834 | int stackSize = keepStackSize(); | 10852 | int stackSize = keepStackSize(); |
11835 | 10853 | ||
11836 | try { | 10854 | try { |
11837 | // InternalSolverLanguage.g:3365:1: ( ( ( rule__IfElse__ConditionAssignment_1 ) ) ) | 10855 | // InternalSolverLanguageParser.g:3417:1: ( ( ( rule__IfElse__ConditionAssignment_1 ) ) ) |
11838 | // InternalSolverLanguage.g:3366:1: ( ( rule__IfElse__ConditionAssignment_1 ) ) | 10856 | // InternalSolverLanguageParser.g:3418:1: ( ( rule__IfElse__ConditionAssignment_1 ) ) |
11839 | { | 10857 | { |
11840 | // InternalSolverLanguage.g:3366:1: ( ( rule__IfElse__ConditionAssignment_1 ) ) | 10858 | // InternalSolverLanguageParser.g:3418:1: ( ( rule__IfElse__ConditionAssignment_1 ) ) |
11841 | // InternalSolverLanguage.g:3367:2: ( rule__IfElse__ConditionAssignment_1 ) | 10859 | // InternalSolverLanguageParser.g:3419:2: ( rule__IfElse__ConditionAssignment_1 ) |
11842 | { | 10860 | { |
11843 | if ( state.backtracking==0 ) { | 10861 | before(grammarAccess.getIfElseAccess().getConditionAssignment_1()); |
11844 | before(grammarAccess.getIfElseAccess().getConditionAssignment_1()); | 10862 | // InternalSolverLanguageParser.g:3420:2: ( rule__IfElse__ConditionAssignment_1 ) |
11845 | } | 10863 | // InternalSolverLanguageParser.g:3420:3: rule__IfElse__ConditionAssignment_1 |
11846 | // InternalSolverLanguage.g:3368:2: ( rule__IfElse__ConditionAssignment_1 ) | ||
11847 | // InternalSolverLanguage.g:3368:3: rule__IfElse__ConditionAssignment_1 | ||
11848 | { | 10864 | { |
11849 | pushFollow(FOLLOW_2); | 10865 | pushFollow(FOLLOW_2); |
11850 | rule__IfElse__ConditionAssignment_1(); | 10866 | rule__IfElse__ConditionAssignment_1(); |
11851 | 10867 | ||
11852 | state._fsp--; | 10868 | state._fsp--; |
11853 | if (state.failed) return ; | ||
11854 | 10869 | ||
11855 | } | ||
11856 | 10870 | ||
11857 | if ( state.backtracking==0 ) { | ||
11858 | after(grammarAccess.getIfElseAccess().getConditionAssignment_1()); | ||
11859 | } | 10871 | } |
11860 | 10872 | ||
10873 | after(grammarAccess.getIfElseAccess().getConditionAssignment_1()); | ||
10874 | |||
11861 | } | 10875 | } |
11862 | 10876 | ||
11863 | 10877 | ||
@@ -11879,25 +10893,25 @@ public class InternalSolverLanguageParser extends AbstractInternalContentAssistP | |||
11879 | 10893 | ||
11880 | 10894 | ||
11881 | // $ANTLR start "rule__IfElse__Group__2" | 10895 | // $ANTLR start "rule__IfElse__Group__2" |
11882 | // InternalSolverLanguage.g:3376:1: rule__IfElse__Group__2 : rule__IfElse__Group__2__Impl rule__IfElse__Group__3 ; | 10896 | // InternalSolverLanguageParser.g:3428:1: rule__IfElse__Group__2 : rule__IfElse__Group__2__Impl rule__IfElse__Group__3 ; |
11883 | public final void rule__IfElse__Group__2() throws RecognitionException { | 10897 | public final void rule__IfElse__Group__2() throws RecognitionException { |
11884 | 10898 | ||
11885 | int stackSize = keepStackSize(); | 10899 | int stackSize = keepStackSize(); |
11886 | 10900 | ||
11887 | try { | 10901 | try { |
11888 | // InternalSolverLanguage.g:3380:1: ( rule__IfElse__Group__2__Impl rule__IfElse__Group__3 ) | 10902 | // InternalSolverLanguageParser.g:3432:1: ( rule__IfElse__Group__2__Impl rule__IfElse__Group__3 ) |
11889 | // InternalSolverLanguage.g:3381:2: rule__IfElse__Group__2__Impl rule__IfElse__Group__3 | 10903 | // InternalSolverLanguageParser.g:3433:2: rule__IfElse__Group__2__Impl rule__IfElse__Group__3 |
11890 | { | 10904 | { |
11891 | pushFollow(FOLLOW_7); | 10905 | pushFollow(FOLLOW_7); |
11892 | rule__IfElse__Group__2__Impl(); | 10906 | rule__IfElse__Group__2__Impl(); |
11893 | 10907 | ||
11894 | state._fsp--; | 10908 | state._fsp--; |
11895 | if (state.failed) return ; | 10909 | |
11896 | pushFollow(FOLLOW_2); | 10910 | pushFollow(FOLLOW_2); |
11897 | rule__IfElse__Group__3(); | 10911 | rule__IfElse__Group__3(); |
11898 | 10912 | ||
11899 | state._fsp--; | 10913 | state._fsp--; |
11900 | if (state.failed) return ; | 10914 | |
11901 | 10915 | ||
11902 | } | 10916 | } |
11903 | 10917 | ||
@@ -11917,25 +10931,21 @@ public class InternalSolverLanguageParser extends AbstractInternalContentAssistP | |||
11917 | 10931 | ||
11918 | 10932 | ||
11919 | // $ANTLR start "rule__IfElse__Group__2__Impl" | 10933 | // $ANTLR start "rule__IfElse__Group__2__Impl" |
11920 | // InternalSolverLanguage.g:3388:1: rule__IfElse__Group__2__Impl : ( 'then' ) ; | 10934 | // InternalSolverLanguageParser.g:3440:1: rule__IfElse__Group__2__Impl : ( Then ) ; |
11921 | public final void rule__IfElse__Group__2__Impl() throws RecognitionException { | 10935 | public final void rule__IfElse__Group__2__Impl() throws RecognitionException { |
11922 | 10936 | ||
11923 | int stackSize = keepStackSize(); | 10937 | int stackSize = keepStackSize(); |
11924 | 10938 | ||
11925 | try { | 10939 | try { |
11926 | // InternalSolverLanguage.g:3392:1: ( ( 'then' ) ) | 10940 | // InternalSolverLanguageParser.g:3444:1: ( ( Then ) ) |
11927 | // InternalSolverLanguage.g:3393:1: ( 'then' ) | 10941 | // InternalSolverLanguageParser.g:3445:1: ( Then ) |
11928 | { | 10942 | { |
11929 | // InternalSolverLanguage.g:3393:1: ( 'then' ) | 10943 | // InternalSolverLanguageParser.g:3445:1: ( Then ) |
11930 | // InternalSolverLanguage.g:3394:2: 'then' | 10944 | // InternalSolverLanguageParser.g:3446:2: Then |
11931 | { | 10945 | { |
11932 | if ( state.backtracking==0 ) { | 10946 | before(grammarAccess.getIfElseAccess().getThenKeyword_2()); |
11933 | before(grammarAccess.getIfElseAccess().getThenKeyword_2()); | 10947 | match(input,Then,FOLLOW_2); |
11934 | } | 10948 | after(grammarAccess.getIfElseAccess().getThenKeyword_2()); |
11935 | match(input,52,FOLLOW_2); if (state.failed) return ; | ||
11936 | if ( state.backtracking==0 ) { | ||
11937 | after(grammarAccess.getIfElseAccess().getThenKeyword_2()); | ||
11938 | } | ||
11939 | 10949 | ||
11940 | } | 10950 | } |
11941 | 10951 | ||
@@ -11958,25 +10968,25 @@ public class InternalSolverLanguageParser extends AbstractInternalContentAssistP | |||
11958 | 10968 | ||
11959 | 10969 | ||
11960 | // $ANTLR start "rule__IfElse__Group__3" | 10970 | // $ANTLR start "rule__IfElse__Group__3" |
11961 | // InternalSolverLanguage.g:3403:1: rule__IfElse__Group__3 : rule__IfElse__Group__3__Impl rule__IfElse__Group__4 ; | 10971 | // InternalSolverLanguageParser.g:3455:1: rule__IfElse__Group__3 : rule__IfElse__Group__3__Impl rule__IfElse__Group__4 ; |
11962 | public final void rule__IfElse__Group__3() throws RecognitionException { | 10972 | public final void rule__IfElse__Group__3() throws RecognitionException { |
11963 | 10973 | ||
11964 | int stackSize = keepStackSize(); | 10974 | int stackSize = keepStackSize(); |
11965 | 10975 | ||
11966 | try { | 10976 | try { |
11967 | // InternalSolverLanguage.g:3407:1: ( rule__IfElse__Group__3__Impl rule__IfElse__Group__4 ) | 10977 | // InternalSolverLanguageParser.g:3459:1: ( rule__IfElse__Group__3__Impl rule__IfElse__Group__4 ) |
11968 | // InternalSolverLanguage.g:3408:2: rule__IfElse__Group__3__Impl rule__IfElse__Group__4 | 10978 | // InternalSolverLanguageParser.g:3460:2: rule__IfElse__Group__3__Impl rule__IfElse__Group__4 |
11969 | { | 10979 | { |
11970 | pushFollow(FOLLOW_17); | 10980 | pushFollow(FOLLOW_16); |
11971 | rule__IfElse__Group__3__Impl(); | 10981 | rule__IfElse__Group__3__Impl(); |
11972 | 10982 | ||
11973 | state._fsp--; | 10983 | state._fsp--; |
11974 | if (state.failed) return ; | 10984 | |
11975 | pushFollow(FOLLOW_2); | 10985 | pushFollow(FOLLOW_2); |
11976 | rule__IfElse__Group__4(); | 10986 | rule__IfElse__Group__4(); |
11977 | 10987 | ||
11978 | state._fsp--; | 10988 | state._fsp--; |
11979 | if (state.failed) return ; | 10989 | |
11980 | 10990 | ||
11981 | } | 10991 | } |
11982 | 10992 | ||
@@ -11996,36 +11006,32 @@ public class InternalSolverLanguageParser extends AbstractInternalContentAssistP | |||
11996 | 11006 | ||
11997 | 11007 | ||
11998 | // $ANTLR start "rule__IfElse__Group__3__Impl" | 11008 | // $ANTLR start "rule__IfElse__Group__3__Impl" |
11999 | // InternalSolverLanguage.g:3415:1: rule__IfElse__Group__3__Impl : ( ( rule__IfElse__ThenAssignment_3 ) ) ; | 11009 | // InternalSolverLanguageParser.g:3467:1: rule__IfElse__Group__3__Impl : ( ( rule__IfElse__ThenAssignment_3 ) ) ; |
12000 | public final void rule__IfElse__Group__3__Impl() throws RecognitionException { | 11010 | public final void rule__IfElse__Group__3__Impl() throws RecognitionException { |
12001 | 11011 | ||
12002 | int stackSize = keepStackSize(); | 11012 | int stackSize = keepStackSize(); |
12003 | 11013 | ||
12004 | try { | 11014 | try { |
12005 | // InternalSolverLanguage.g:3419:1: ( ( ( rule__IfElse__ThenAssignment_3 ) ) ) | 11015 | // InternalSolverLanguageParser.g:3471:1: ( ( ( rule__IfElse__ThenAssignment_3 ) ) ) |
12006 | // InternalSolverLanguage.g:3420:1: ( ( rule__IfElse__ThenAssignment_3 ) ) | 11016 | // InternalSolverLanguageParser.g:3472:1: ( ( rule__IfElse__ThenAssignment_3 ) ) |
12007 | { | 11017 | { |
12008 | // InternalSolverLanguage.g:3420:1: ( ( rule__IfElse__ThenAssignment_3 ) ) | 11018 | // InternalSolverLanguageParser.g:3472:1: ( ( rule__IfElse__ThenAssignment_3 ) ) |
12009 | // InternalSolverLanguage.g:3421:2: ( rule__IfElse__ThenAssignment_3 ) | 11019 | // InternalSolverLanguageParser.g:3473:2: ( rule__IfElse__ThenAssignment_3 ) |
12010 | { | 11020 | { |
12011 | if ( state.backtracking==0 ) { | 11021 | before(grammarAccess.getIfElseAccess().getThenAssignment_3()); |
12012 | before(grammarAccess.getIfElseAccess().getThenAssignment_3()); | 11022 | // InternalSolverLanguageParser.g:3474:2: ( rule__IfElse__ThenAssignment_3 ) |
12013 | } | 11023 | // InternalSolverLanguageParser.g:3474:3: rule__IfElse__ThenAssignment_3 |
12014 | // InternalSolverLanguage.g:3422:2: ( rule__IfElse__ThenAssignment_3 ) | ||
12015 | // InternalSolverLanguage.g:3422:3: rule__IfElse__ThenAssignment_3 | ||
12016 | { | 11024 | { |
12017 | pushFollow(FOLLOW_2); | 11025 | pushFollow(FOLLOW_2); |
12018 | rule__IfElse__ThenAssignment_3(); | 11026 | rule__IfElse__ThenAssignment_3(); |
12019 | 11027 | ||
12020 | state._fsp--; | 11028 | state._fsp--; |
12021 | if (state.failed) return ; | ||
12022 | 11029 | ||
12023 | } | ||
12024 | 11030 | ||
12025 | if ( state.backtracking==0 ) { | ||
12026 | after(grammarAccess.getIfElseAccess().getThenAssignment_3()); | ||
12027 | } | 11031 | } |
12028 | 11032 | ||
11033 | after(grammarAccess.getIfElseAccess().getThenAssignment_3()); | ||
11034 | |||
12029 | } | 11035 | } |
12030 | 11036 | ||
12031 | 11037 | ||
@@ -12047,25 +11053,25 @@ public class InternalSolverLanguageParser extends AbstractInternalContentAssistP | |||
12047 | 11053 | ||
12048 | 11054 | ||
12049 | // $ANTLR start "rule__IfElse__Group__4" | 11055 | // $ANTLR start "rule__IfElse__Group__4" |
12050 | // InternalSolverLanguage.g:3430:1: rule__IfElse__Group__4 : rule__IfElse__Group__4__Impl rule__IfElse__Group__5 ; | 11056 | // InternalSolverLanguageParser.g:3482:1: rule__IfElse__Group__4 : rule__IfElse__Group__4__Impl rule__IfElse__Group__5 ; |
12051 | public final void rule__IfElse__Group__4() throws RecognitionException { | 11057 | public final void rule__IfElse__Group__4() throws RecognitionException { |
12052 | 11058 | ||
12053 | int stackSize = keepStackSize(); | 11059 | int stackSize = keepStackSize(); |
12054 | 11060 | ||
12055 | try { | 11061 | try { |
12056 | // InternalSolverLanguage.g:3434:1: ( rule__IfElse__Group__4__Impl rule__IfElse__Group__5 ) | 11062 | // InternalSolverLanguageParser.g:3486:1: ( rule__IfElse__Group__4__Impl rule__IfElse__Group__5 ) |
12057 | // InternalSolverLanguage.g:3435:2: rule__IfElse__Group__4__Impl rule__IfElse__Group__5 | 11063 | // InternalSolverLanguageParser.g:3487:2: rule__IfElse__Group__4__Impl rule__IfElse__Group__5 |
12058 | { | 11064 | { |
12059 | pushFollow(FOLLOW_7); | 11065 | pushFollow(FOLLOW_7); |
12060 | rule__IfElse__Group__4__Impl(); | 11066 | rule__IfElse__Group__4__Impl(); |
12061 | 11067 | ||
12062 | state._fsp--; | 11068 | state._fsp--; |
12063 | if (state.failed) return ; | 11069 | |
12064 | pushFollow(FOLLOW_2); | 11070 | pushFollow(FOLLOW_2); |
12065 | rule__IfElse__Group__5(); | 11071 | rule__IfElse__Group__5(); |
12066 | 11072 | ||
12067 | state._fsp--; | 11073 | state._fsp--; |
12068 | if (state.failed) return ; | 11074 | |
12069 | 11075 | ||
12070 | } | 11076 | } |
12071 | 11077 | ||
@@ -12085,25 +11091,21 @@ public class InternalSolverLanguageParser extends AbstractInternalContentAssistP | |||
12085 | 11091 | ||
12086 | 11092 | ||
12087 | // $ANTLR start "rule__IfElse__Group__4__Impl" | 11093 | // $ANTLR start "rule__IfElse__Group__4__Impl" |
12088 | // InternalSolverLanguage.g:3442:1: rule__IfElse__Group__4__Impl : ( 'else' ) ; | 11094 | // InternalSolverLanguageParser.g:3494:1: rule__IfElse__Group__4__Impl : ( Else ) ; |
12089 | public final void rule__IfElse__Group__4__Impl() throws RecognitionException { | 11095 | public final void rule__IfElse__Group__4__Impl() throws RecognitionException { |
12090 | 11096 | ||
12091 | int stackSize = keepStackSize(); | 11097 | int stackSize = keepStackSize(); |
12092 | 11098 | ||
12093 | try { | 11099 | try { |
12094 | // InternalSolverLanguage.g:3446:1: ( ( 'else' ) ) | 11100 | // InternalSolverLanguageParser.g:3498:1: ( ( Else ) ) |
12095 | // InternalSolverLanguage.g:3447:1: ( 'else' ) | 11101 | // InternalSolverLanguageParser.g:3499:1: ( Else ) |
12096 | { | 11102 | { |
12097 | // InternalSolverLanguage.g:3447:1: ( 'else' ) | 11103 | // InternalSolverLanguageParser.g:3499:1: ( Else ) |
12098 | // InternalSolverLanguage.g:3448:2: 'else' | 11104 | // InternalSolverLanguageParser.g:3500:2: Else |
12099 | { | 11105 | { |
12100 | if ( state.backtracking==0 ) { | 11106 | before(grammarAccess.getIfElseAccess().getElseKeyword_4()); |
12101 | before(grammarAccess.getIfElseAccess().getElseKeyword_4()); | 11107 | match(input,Else,FOLLOW_2); |
12102 | } | 11108 | after(grammarAccess.getIfElseAccess().getElseKeyword_4()); |
12103 | match(input,53,FOLLOW_2); if (state.failed) return ; | ||
12104 | if ( state.backtracking==0 ) { | ||
12105 | after(grammarAccess.getIfElseAccess().getElseKeyword_4()); | ||
12106 | } | ||
12107 | 11109 | ||
12108 | } | 11110 | } |
12109 | 11111 | ||
@@ -12126,20 +11128,20 @@ public class InternalSolverLanguageParser extends AbstractInternalContentAssistP | |||
12126 | 11128 | ||
12127 | 11129 | ||
12128 | // $ANTLR start "rule__IfElse__Group__5" | 11130 | // $ANTLR start "rule__IfElse__Group__5" |
12129 | // InternalSolverLanguage.g:3457:1: rule__IfElse__Group__5 : rule__IfElse__Group__5__Impl ; | 11131 | // InternalSolverLanguageParser.g:3509:1: rule__IfElse__Group__5 : rule__IfElse__Group__5__Impl ; |
12130 | public final void rule__IfElse__Group__5() throws RecognitionException { | 11132 | public final void rule__IfElse__Group__5() throws RecognitionException { |
12131 | 11133 | ||
12132 | int stackSize = keepStackSize(); | 11134 | int stackSize = keepStackSize(); |
12133 | 11135 | ||
12134 | try { | 11136 | try { |
12135 | // InternalSolverLanguage.g:3461:1: ( rule__IfElse__Group__5__Impl ) | 11137 | // InternalSolverLanguageParser.g:3513:1: ( rule__IfElse__Group__5__Impl ) |
12136 | // InternalSolverLanguage.g:3462:2: rule__IfElse__Group__5__Impl | 11138 | // InternalSolverLanguageParser.g:3514:2: rule__IfElse__Group__5__Impl |
12137 | { | 11139 | { |
12138 | pushFollow(FOLLOW_2); | 11140 | pushFollow(FOLLOW_2); |
12139 | rule__IfElse__Group__5__Impl(); | 11141 | rule__IfElse__Group__5__Impl(); |
12140 | 11142 | ||
12141 | state._fsp--; | 11143 | state._fsp--; |
12142 | if (state.failed) return ; | 11144 | |
12143 | 11145 | ||
12144 | } | 11146 | } |
12145 | 11147 | ||
@@ -12159,36 +11161,32 @@ public class InternalSolverLanguageParser extends AbstractInternalContentAssistP | |||
12159 | 11161 | ||
12160 | 11162 | ||
12161 | // $ANTLR start "rule__IfElse__Group__5__Impl" | 11163 | // $ANTLR start "rule__IfElse__Group__5__Impl" |
12162 | // InternalSolverLanguage.g:3468:1: rule__IfElse__Group__5__Impl : ( ( rule__IfElse__ElseAssignment_5 ) ) ; | 11164 | // InternalSolverLanguageParser.g:3520:1: rule__IfElse__Group__5__Impl : ( ( rule__IfElse__ElseAssignment_5 ) ) ; |
12163 | public final void rule__IfElse__Group__5__Impl() throws RecognitionException { | 11165 | public final void rule__IfElse__Group__5__Impl() throws RecognitionException { |
12164 | 11166 | ||
12165 | int stackSize = keepStackSize(); | 11167 | int stackSize = keepStackSize(); |
12166 | 11168 | ||
12167 | try { | 11169 | try { |
12168 | // InternalSolverLanguage.g:3472:1: ( ( ( rule__IfElse__ElseAssignment_5 ) ) ) | 11170 | // InternalSolverLanguageParser.g:3524:1: ( ( ( rule__IfElse__ElseAssignment_5 ) ) ) |
12169 | // InternalSolverLanguage.g:3473:1: ( ( rule__IfElse__ElseAssignment_5 ) ) | 11171 | // InternalSolverLanguageParser.g:3525:1: ( ( rule__IfElse__ElseAssignment_5 ) ) |
12170 | { | 11172 | { |
12171 | // InternalSolverLanguage.g:3473:1: ( ( rule__IfElse__ElseAssignment_5 ) ) | 11173 | // InternalSolverLanguageParser.g:3525:1: ( ( rule__IfElse__ElseAssignment_5 ) ) |
12172 | // InternalSolverLanguage.g:3474:2: ( rule__IfElse__ElseAssignment_5 ) | 11174 | // InternalSolverLanguageParser.g:3526:2: ( rule__IfElse__ElseAssignment_5 ) |
12173 | { | 11175 | { |
12174 | if ( state.backtracking==0 ) { | 11176 | before(grammarAccess.getIfElseAccess().getElseAssignment_5()); |
12175 | before(grammarAccess.getIfElseAccess().getElseAssignment_5()); | 11177 | // InternalSolverLanguageParser.g:3527:2: ( rule__IfElse__ElseAssignment_5 ) |
12176 | } | 11178 | // InternalSolverLanguageParser.g:3527:3: rule__IfElse__ElseAssignment_5 |
12177 | // InternalSolverLanguage.g:3475:2: ( rule__IfElse__ElseAssignment_5 ) | ||
12178 | // InternalSolverLanguage.g:3475:3: rule__IfElse__ElseAssignment_5 | ||
12179 | { | 11179 | { |
12180 | pushFollow(FOLLOW_2); | 11180 | pushFollow(FOLLOW_2); |
12181 | rule__IfElse__ElseAssignment_5(); | 11181 | rule__IfElse__ElseAssignment_5(); |
12182 | 11182 | ||
12183 | state._fsp--; | 11183 | state._fsp--; |
12184 | if (state.failed) return ; | ||
12185 | 11184 | ||
12186 | } | ||
12187 | 11185 | ||
12188 | if ( state.backtracking==0 ) { | ||
12189 | after(grammarAccess.getIfElseAccess().getElseAssignment_5()); | ||
12190 | } | 11186 | } |
12191 | 11187 | ||
11188 | after(grammarAccess.getIfElseAccess().getElseAssignment_5()); | ||
11189 | |||
12192 | } | 11190 | } |
12193 | 11191 | ||
12194 | 11192 | ||
@@ -12210,25 +11208,25 @@ public class InternalSolverLanguageParser extends AbstractInternalContentAssistP | |||
12210 | 11208 | ||
12211 | 11209 | ||
12212 | // $ANTLR start "rule__DisjunctiveExpression__Group__0" | 11210 | // $ANTLR start "rule__DisjunctiveExpression__Group__0" |
12213 | // InternalSolverLanguage.g:3484:1: rule__DisjunctiveExpression__Group__0 : rule__DisjunctiveExpression__Group__0__Impl rule__DisjunctiveExpression__Group__1 ; | 11211 | // InternalSolverLanguageParser.g:3536:1: rule__DisjunctiveExpression__Group__0 : rule__DisjunctiveExpression__Group__0__Impl rule__DisjunctiveExpression__Group__1 ; |
12214 | public final void rule__DisjunctiveExpression__Group__0() throws RecognitionException { | 11212 | public final void rule__DisjunctiveExpression__Group__0() throws RecognitionException { |
12215 | 11213 | ||
12216 | int stackSize = keepStackSize(); | 11214 | int stackSize = keepStackSize(); |
12217 | 11215 | ||
12218 | try { | 11216 | try { |
12219 | // InternalSolverLanguage.g:3488:1: ( rule__DisjunctiveExpression__Group__0__Impl rule__DisjunctiveExpression__Group__1 ) | 11217 | // InternalSolverLanguageParser.g:3540:1: ( rule__DisjunctiveExpression__Group__0__Impl rule__DisjunctiveExpression__Group__1 ) |
12220 | // InternalSolverLanguage.g:3489:2: rule__DisjunctiveExpression__Group__0__Impl rule__DisjunctiveExpression__Group__1 | 11218 | // InternalSolverLanguageParser.g:3541:2: rule__DisjunctiveExpression__Group__0__Impl rule__DisjunctiveExpression__Group__1 |
12221 | { | 11219 | { |
12222 | pushFollow(FOLLOW_18); | 11220 | pushFollow(FOLLOW_17); |
12223 | rule__DisjunctiveExpression__Group__0__Impl(); | 11221 | rule__DisjunctiveExpression__Group__0__Impl(); |
12224 | 11222 | ||
12225 | state._fsp--; | 11223 | state._fsp--; |
12226 | if (state.failed) return ; | 11224 | |
12227 | pushFollow(FOLLOW_2); | 11225 | pushFollow(FOLLOW_2); |
12228 | rule__DisjunctiveExpression__Group__1(); | 11226 | rule__DisjunctiveExpression__Group__1(); |
12229 | 11227 | ||
12230 | state._fsp--; | 11228 | state._fsp--; |
12231 | if (state.failed) return ; | 11229 | |
12232 | 11230 | ||
12233 | } | 11231 | } |
12234 | 11232 | ||
@@ -12248,29 +11246,25 @@ public class InternalSolverLanguageParser extends AbstractInternalContentAssistP | |||
12248 | 11246 | ||
12249 | 11247 | ||
12250 | // $ANTLR start "rule__DisjunctiveExpression__Group__0__Impl" | 11248 | // $ANTLR start "rule__DisjunctiveExpression__Group__0__Impl" |
12251 | // InternalSolverLanguage.g:3496:1: rule__DisjunctiveExpression__Group__0__Impl : ( ruleConjunctiveExpression ) ; | 11249 | // InternalSolverLanguageParser.g:3548:1: rule__DisjunctiveExpression__Group__0__Impl : ( ruleConjunctiveExpression ) ; |
12252 | public final void rule__DisjunctiveExpression__Group__0__Impl() throws RecognitionException { | 11250 | public final void rule__DisjunctiveExpression__Group__0__Impl() throws RecognitionException { |
12253 | 11251 | ||
12254 | int stackSize = keepStackSize(); | 11252 | int stackSize = keepStackSize(); |
12255 | 11253 | ||
12256 | try { | 11254 | try { |
12257 | // InternalSolverLanguage.g:3500:1: ( ( ruleConjunctiveExpression ) ) | 11255 | // InternalSolverLanguageParser.g:3552:1: ( ( ruleConjunctiveExpression ) ) |
12258 | // InternalSolverLanguage.g:3501:1: ( ruleConjunctiveExpression ) | 11256 | // InternalSolverLanguageParser.g:3553:1: ( ruleConjunctiveExpression ) |
12259 | { | 11257 | { |
12260 | // InternalSolverLanguage.g:3501:1: ( ruleConjunctiveExpression ) | 11258 | // InternalSolverLanguageParser.g:3553:1: ( ruleConjunctiveExpression ) |
12261 | // InternalSolverLanguage.g:3502:2: ruleConjunctiveExpression | 11259 | // InternalSolverLanguageParser.g:3554:2: ruleConjunctiveExpression |
12262 | { | 11260 | { |
12263 | if ( state.backtracking==0 ) { | 11261 | before(grammarAccess.getDisjunctiveExpressionAccess().getConjunctiveExpressionParserRuleCall_0()); |
12264 | before(grammarAccess.getDisjunctiveExpressionAccess().getConjunctiveExpressionParserRuleCall_0()); | ||
12265 | } | ||
12266 | pushFollow(FOLLOW_2); | 11262 | pushFollow(FOLLOW_2); |
12267 | ruleConjunctiveExpression(); | 11263 | ruleConjunctiveExpression(); |
12268 | 11264 | ||
12269 | state._fsp--; | 11265 | state._fsp--; |
12270 | if (state.failed) return ; | 11266 | |
12271 | if ( state.backtracking==0 ) { | 11267 | after(grammarAccess.getDisjunctiveExpressionAccess().getConjunctiveExpressionParserRuleCall_0()); |
12272 | after(grammarAccess.getDisjunctiveExpressionAccess().getConjunctiveExpressionParserRuleCall_0()); | ||
12273 | } | ||
12274 | 11268 | ||
12275 | } | 11269 | } |
12276 | 11270 | ||
@@ -12293,20 +11287,20 @@ public class InternalSolverLanguageParser extends AbstractInternalContentAssistP | |||
12293 | 11287 | ||
12294 | 11288 | ||
12295 | // $ANTLR start "rule__DisjunctiveExpression__Group__1" | 11289 | // $ANTLR start "rule__DisjunctiveExpression__Group__1" |
12296 | // InternalSolverLanguage.g:3511:1: rule__DisjunctiveExpression__Group__1 : rule__DisjunctiveExpression__Group__1__Impl ; | 11290 | // InternalSolverLanguageParser.g:3563:1: rule__DisjunctiveExpression__Group__1 : rule__DisjunctiveExpression__Group__1__Impl ; |
12297 | public final void rule__DisjunctiveExpression__Group__1() throws RecognitionException { | 11291 | public final void rule__DisjunctiveExpression__Group__1() throws RecognitionException { |
12298 | 11292 | ||
12299 | int stackSize = keepStackSize(); | 11293 | int stackSize = keepStackSize(); |
12300 | 11294 | ||
12301 | try { | 11295 | try { |
12302 | // InternalSolverLanguage.g:3515:1: ( rule__DisjunctiveExpression__Group__1__Impl ) | 11296 | // InternalSolverLanguageParser.g:3567:1: ( rule__DisjunctiveExpression__Group__1__Impl ) |
12303 | // InternalSolverLanguage.g:3516:2: rule__DisjunctiveExpression__Group__1__Impl | 11297 | // InternalSolverLanguageParser.g:3568:2: rule__DisjunctiveExpression__Group__1__Impl |
12304 | { | 11298 | { |
12305 | pushFollow(FOLLOW_2); | 11299 | pushFollow(FOLLOW_2); |
12306 | rule__DisjunctiveExpression__Group__1__Impl(); | 11300 | rule__DisjunctiveExpression__Group__1__Impl(); |
12307 | 11301 | ||
12308 | state._fsp--; | 11302 | state._fsp--; |
12309 | if (state.failed) return ; | 11303 | |
12310 | 11304 | ||
12311 | } | 11305 | } |
12312 | 11306 | ||
@@ -12326,46 +11320,42 @@ public class InternalSolverLanguageParser extends AbstractInternalContentAssistP | |||
12326 | 11320 | ||
12327 | 11321 | ||
12328 | // $ANTLR start "rule__DisjunctiveExpression__Group__1__Impl" | 11322 | // $ANTLR start "rule__DisjunctiveExpression__Group__1__Impl" |
12329 | // InternalSolverLanguage.g:3522:1: rule__DisjunctiveExpression__Group__1__Impl : ( ( rule__DisjunctiveExpression__Alternatives_1 )? ) ; | 11323 | // InternalSolverLanguageParser.g:3574:1: rule__DisjunctiveExpression__Group__1__Impl : ( ( rule__DisjunctiveExpression__Alternatives_1 )? ) ; |
12330 | public final void rule__DisjunctiveExpression__Group__1__Impl() throws RecognitionException { | 11324 | public final void rule__DisjunctiveExpression__Group__1__Impl() throws RecognitionException { |
12331 | 11325 | ||
12332 | int stackSize = keepStackSize(); | 11326 | int stackSize = keepStackSize(); |
12333 | 11327 | ||
12334 | try { | 11328 | try { |
12335 | // InternalSolverLanguage.g:3526:1: ( ( ( rule__DisjunctiveExpression__Alternatives_1 )? ) ) | 11329 | // InternalSolverLanguageParser.g:3578:1: ( ( ( rule__DisjunctiveExpression__Alternatives_1 )? ) ) |
12336 | // InternalSolverLanguage.g:3527:1: ( ( rule__DisjunctiveExpression__Alternatives_1 )? ) | 11330 | // InternalSolverLanguageParser.g:3579:1: ( ( rule__DisjunctiveExpression__Alternatives_1 )? ) |
12337 | { | 11331 | { |
12338 | // InternalSolverLanguage.g:3527:1: ( ( rule__DisjunctiveExpression__Alternatives_1 )? ) | 11332 | // InternalSolverLanguageParser.g:3579:1: ( ( rule__DisjunctiveExpression__Alternatives_1 )? ) |
12339 | // InternalSolverLanguage.g:3528:2: ( rule__DisjunctiveExpression__Alternatives_1 )? | 11333 | // InternalSolverLanguageParser.g:3580:2: ( rule__DisjunctiveExpression__Alternatives_1 )? |
12340 | { | 11334 | { |
12341 | if ( state.backtracking==0 ) { | 11335 | before(grammarAccess.getDisjunctiveExpressionAccess().getAlternatives_1()); |
12342 | before(grammarAccess.getDisjunctiveExpressionAccess().getAlternatives_1()); | 11336 | // InternalSolverLanguageParser.g:3581:2: ( rule__DisjunctiveExpression__Alternatives_1 )? |
12343 | } | ||
12344 | // InternalSolverLanguage.g:3529:2: ( rule__DisjunctiveExpression__Alternatives_1 )? | ||
12345 | int alt30=2; | 11337 | int alt30=2; |
12346 | int LA30_0 = input.LA(1); | 11338 | int LA30_0 = input.LA(1); |
12347 | 11339 | ||
12348 | if ( ((LA30_0>=54 && LA30_0<=55)) ) { | 11340 | if ( (LA30_0==HyphenMinusGreaterThanSign||LA30_0==Semicolon) ) { |
12349 | alt30=1; | 11341 | alt30=1; |
12350 | } | 11342 | } |
12351 | switch (alt30) { | 11343 | switch (alt30) { |
12352 | case 1 : | 11344 | case 1 : |
12353 | // InternalSolverLanguage.g:3529:3: rule__DisjunctiveExpression__Alternatives_1 | 11345 | // InternalSolverLanguageParser.g:3581:3: rule__DisjunctiveExpression__Alternatives_1 |
12354 | { | 11346 | { |
12355 | pushFollow(FOLLOW_2); | 11347 | pushFollow(FOLLOW_2); |
12356 | rule__DisjunctiveExpression__Alternatives_1(); | 11348 | rule__DisjunctiveExpression__Alternatives_1(); |
12357 | 11349 | ||
12358 | state._fsp--; | 11350 | state._fsp--; |
12359 | if (state.failed) return ; | 11351 | |
12360 | 11352 | ||
12361 | } | 11353 | } |
12362 | break; | 11354 | break; |
12363 | 11355 | ||
12364 | } | 11356 | } |
12365 | 11357 | ||
12366 | if ( state.backtracking==0 ) { | 11358 | after(grammarAccess.getDisjunctiveExpressionAccess().getAlternatives_1()); |
12367 | after(grammarAccess.getDisjunctiveExpressionAccess().getAlternatives_1()); | ||
12368 | } | ||
12369 | 11359 | ||
12370 | } | 11360 | } |
12371 | 11361 | ||
@@ -12388,25 +11378,25 @@ public class InternalSolverLanguageParser extends AbstractInternalContentAssistP | |||
12388 | 11378 | ||
12389 | 11379 | ||
12390 | // $ANTLR start "rule__DisjunctiveExpression__Group_1_0__0" | 11380 | // $ANTLR start "rule__DisjunctiveExpression__Group_1_0__0" |
12391 | // InternalSolverLanguage.g:3538:1: rule__DisjunctiveExpression__Group_1_0__0 : rule__DisjunctiveExpression__Group_1_0__0__Impl rule__DisjunctiveExpression__Group_1_0__1 ; | 11381 | // InternalSolverLanguageParser.g:3590:1: rule__DisjunctiveExpression__Group_1_0__0 : rule__DisjunctiveExpression__Group_1_0__0__Impl rule__DisjunctiveExpression__Group_1_0__1 ; |
12392 | public final void rule__DisjunctiveExpression__Group_1_0__0() throws RecognitionException { | 11382 | public final void rule__DisjunctiveExpression__Group_1_0__0() throws RecognitionException { |
12393 | 11383 | ||
12394 | int stackSize = keepStackSize(); | 11384 | int stackSize = keepStackSize(); |
12395 | 11385 | ||
12396 | try { | 11386 | try { |
12397 | // InternalSolverLanguage.g:3542:1: ( rule__DisjunctiveExpression__Group_1_0__0__Impl rule__DisjunctiveExpression__Group_1_0__1 ) | 11387 | // InternalSolverLanguageParser.g:3594:1: ( rule__DisjunctiveExpression__Group_1_0__0__Impl rule__DisjunctiveExpression__Group_1_0__1 ) |
12398 | // InternalSolverLanguage.g:3543:2: rule__DisjunctiveExpression__Group_1_0__0__Impl rule__DisjunctiveExpression__Group_1_0__1 | 11388 | // InternalSolverLanguageParser.g:3595:2: rule__DisjunctiveExpression__Group_1_0__0__Impl rule__DisjunctiveExpression__Group_1_0__1 |
12399 | { | 11389 | { |
12400 | pushFollow(FOLLOW_19); | 11390 | pushFollow(FOLLOW_18); |
12401 | rule__DisjunctiveExpression__Group_1_0__0__Impl(); | 11391 | rule__DisjunctiveExpression__Group_1_0__0__Impl(); |
12402 | 11392 | ||
12403 | state._fsp--; | 11393 | state._fsp--; |
12404 | if (state.failed) return ; | 11394 | |
12405 | pushFollow(FOLLOW_2); | 11395 | pushFollow(FOLLOW_2); |
12406 | rule__DisjunctiveExpression__Group_1_0__1(); | 11396 | rule__DisjunctiveExpression__Group_1_0__1(); |
12407 | 11397 | ||
12408 | state._fsp--; | 11398 | state._fsp--; |
12409 | if (state.failed) return ; | 11399 | |
12410 | 11400 | ||
12411 | } | 11401 | } |
12412 | 11402 | ||
@@ -12426,29 +11416,25 @@ public class InternalSolverLanguageParser extends AbstractInternalContentAssistP | |||
12426 | 11416 | ||
12427 | 11417 | ||
12428 | // $ANTLR start "rule__DisjunctiveExpression__Group_1_0__0__Impl" | 11418 | // $ANTLR start "rule__DisjunctiveExpression__Group_1_0__0__Impl" |
12429 | // InternalSolverLanguage.g:3550:1: rule__DisjunctiveExpression__Group_1_0__0__Impl : ( () ) ; | 11419 | // InternalSolverLanguageParser.g:3602:1: rule__DisjunctiveExpression__Group_1_0__0__Impl : ( () ) ; |
12430 | public final void rule__DisjunctiveExpression__Group_1_0__0__Impl() throws RecognitionException { | 11420 | public final void rule__DisjunctiveExpression__Group_1_0__0__Impl() throws RecognitionException { |
12431 | 11421 | ||
12432 | int stackSize = keepStackSize(); | 11422 | int stackSize = keepStackSize(); |
12433 | 11423 | ||
12434 | try { | 11424 | try { |
12435 | // InternalSolverLanguage.g:3554:1: ( ( () ) ) | 11425 | // InternalSolverLanguageParser.g:3606:1: ( ( () ) ) |
12436 | // InternalSolverLanguage.g:3555:1: ( () ) | 11426 | // InternalSolverLanguageParser.g:3607:1: ( () ) |
12437 | { | 11427 | { |
12438 | // InternalSolverLanguage.g:3555:1: ( () ) | 11428 | // InternalSolverLanguageParser.g:3607:1: ( () ) |
12439 | // InternalSolverLanguage.g:3556:2: () | 11429 | // InternalSolverLanguageParser.g:3608:2: () |
12440 | { | 11430 | { |
12441 | if ( state.backtracking==0 ) { | 11431 | before(grammarAccess.getDisjunctiveExpressionAccess().getDisjunctionChildrenAction_1_0_0()); |
12442 | before(grammarAccess.getDisjunctiveExpressionAccess().getDisjunctionChildrenAction_1_0_0()); | 11432 | // InternalSolverLanguageParser.g:3609:2: () |
12443 | } | 11433 | // InternalSolverLanguageParser.g:3609:3: |
12444 | // InternalSolverLanguage.g:3557:2: () | ||
12445 | // InternalSolverLanguage.g:3557:3: | ||
12446 | { | 11434 | { |
12447 | } | 11435 | } |
12448 | 11436 | ||
12449 | if ( state.backtracking==0 ) { | 11437 | after(grammarAccess.getDisjunctiveExpressionAccess().getDisjunctionChildrenAction_1_0_0()); |
12450 | after(grammarAccess.getDisjunctiveExpressionAccess().getDisjunctionChildrenAction_1_0_0()); | ||
12451 | } | ||
12452 | 11438 | ||
12453 | } | 11439 | } |
12454 | 11440 | ||
@@ -12467,20 +11453,20 @@ public class InternalSolverLanguageParser extends AbstractInternalContentAssistP | |||
12467 | 11453 | ||
12468 | 11454 | ||
12469 | // $ANTLR start "rule__DisjunctiveExpression__Group_1_0__1" | 11455 | // $ANTLR start "rule__DisjunctiveExpression__Group_1_0__1" |
12470 | // InternalSolverLanguage.g:3565:1: rule__DisjunctiveExpression__Group_1_0__1 : rule__DisjunctiveExpression__Group_1_0__1__Impl ; | 11456 | // InternalSolverLanguageParser.g:3617:1: rule__DisjunctiveExpression__Group_1_0__1 : rule__DisjunctiveExpression__Group_1_0__1__Impl ; |
12471 | public final void rule__DisjunctiveExpression__Group_1_0__1() throws RecognitionException { | 11457 | public final void rule__DisjunctiveExpression__Group_1_0__1() throws RecognitionException { |
12472 | 11458 | ||
12473 | int stackSize = keepStackSize(); | 11459 | int stackSize = keepStackSize(); |
12474 | 11460 | ||
12475 | try { | 11461 | try { |
12476 | // InternalSolverLanguage.g:3569:1: ( rule__DisjunctiveExpression__Group_1_0__1__Impl ) | 11462 | // InternalSolverLanguageParser.g:3621:1: ( rule__DisjunctiveExpression__Group_1_0__1__Impl ) |
12477 | // InternalSolverLanguage.g:3570:2: rule__DisjunctiveExpression__Group_1_0__1__Impl | 11463 | // InternalSolverLanguageParser.g:3622:2: rule__DisjunctiveExpression__Group_1_0__1__Impl |
12478 | { | 11464 | { |
12479 | pushFollow(FOLLOW_2); | 11465 | pushFollow(FOLLOW_2); |
12480 | rule__DisjunctiveExpression__Group_1_0__1__Impl(); | 11466 | rule__DisjunctiveExpression__Group_1_0__1__Impl(); |
12481 | 11467 | ||
12482 | state._fsp--; | 11468 | state._fsp--; |
12483 | if (state.failed) return ; | 11469 | |
12484 | 11470 | ||
12485 | } | 11471 | } |
12486 | 11472 | ||
@@ -12500,67 +11486,61 @@ public class InternalSolverLanguageParser extends AbstractInternalContentAssistP | |||
12500 | 11486 | ||
12501 | 11487 | ||
12502 | // $ANTLR start "rule__DisjunctiveExpression__Group_1_0__1__Impl" | 11488 | // $ANTLR start "rule__DisjunctiveExpression__Group_1_0__1__Impl" |
12503 | // InternalSolverLanguage.g:3576:1: rule__DisjunctiveExpression__Group_1_0__1__Impl : ( ( ( rule__DisjunctiveExpression__Group_1_0_1__0 ) ) ( ( rule__DisjunctiveExpression__Group_1_0_1__0 )* ) ) ; | 11489 | // InternalSolverLanguageParser.g:3628:1: rule__DisjunctiveExpression__Group_1_0__1__Impl : ( ( ( rule__DisjunctiveExpression__Group_1_0_1__0 ) ) ( ( rule__DisjunctiveExpression__Group_1_0_1__0 )* ) ) ; |
12504 | public final void rule__DisjunctiveExpression__Group_1_0__1__Impl() throws RecognitionException { | 11490 | public final void rule__DisjunctiveExpression__Group_1_0__1__Impl() throws RecognitionException { |
12505 | 11491 | ||
12506 | int stackSize = keepStackSize(); | 11492 | int stackSize = keepStackSize(); |
12507 | 11493 | ||
12508 | try { | 11494 | try { |
12509 | // InternalSolverLanguage.g:3580:1: ( ( ( ( rule__DisjunctiveExpression__Group_1_0_1__0 ) ) ( ( rule__DisjunctiveExpression__Group_1_0_1__0 )* ) ) ) | 11495 | // InternalSolverLanguageParser.g:3632:1: ( ( ( ( rule__DisjunctiveExpression__Group_1_0_1__0 ) ) ( ( rule__DisjunctiveExpression__Group_1_0_1__0 )* ) ) ) |
12510 | // InternalSolverLanguage.g:3581:1: ( ( ( rule__DisjunctiveExpression__Group_1_0_1__0 ) ) ( ( rule__DisjunctiveExpression__Group_1_0_1__0 )* ) ) | 11496 | // InternalSolverLanguageParser.g:3633:1: ( ( ( rule__DisjunctiveExpression__Group_1_0_1__0 ) ) ( ( rule__DisjunctiveExpression__Group_1_0_1__0 )* ) ) |
12511 | { | 11497 | { |
12512 | // InternalSolverLanguage.g:3581:1: ( ( ( rule__DisjunctiveExpression__Group_1_0_1__0 ) ) ( ( rule__DisjunctiveExpression__Group_1_0_1__0 )* ) ) | 11498 | // InternalSolverLanguageParser.g:3633:1: ( ( ( rule__DisjunctiveExpression__Group_1_0_1__0 ) ) ( ( rule__DisjunctiveExpression__Group_1_0_1__0 )* ) ) |
12513 | // InternalSolverLanguage.g:3582:2: ( ( rule__DisjunctiveExpression__Group_1_0_1__0 ) ) ( ( rule__DisjunctiveExpression__Group_1_0_1__0 )* ) | 11499 | // InternalSolverLanguageParser.g:3634:2: ( ( rule__DisjunctiveExpression__Group_1_0_1__0 ) ) ( ( rule__DisjunctiveExpression__Group_1_0_1__0 )* ) |
12514 | { | 11500 | { |
12515 | // InternalSolverLanguage.g:3582:2: ( ( rule__DisjunctiveExpression__Group_1_0_1__0 ) ) | 11501 | // InternalSolverLanguageParser.g:3634:2: ( ( rule__DisjunctiveExpression__Group_1_0_1__0 ) ) |
12516 | // InternalSolverLanguage.g:3583:3: ( rule__DisjunctiveExpression__Group_1_0_1__0 ) | 11502 | // InternalSolverLanguageParser.g:3635:3: ( rule__DisjunctiveExpression__Group_1_0_1__0 ) |
12517 | { | 11503 | { |
12518 | if ( state.backtracking==0 ) { | 11504 | before(grammarAccess.getDisjunctiveExpressionAccess().getGroup_1_0_1()); |
12519 | before(grammarAccess.getDisjunctiveExpressionAccess().getGroup_1_0_1()); | 11505 | // InternalSolverLanguageParser.g:3636:3: ( rule__DisjunctiveExpression__Group_1_0_1__0 ) |
12520 | } | 11506 | // InternalSolverLanguageParser.g:3636:4: rule__DisjunctiveExpression__Group_1_0_1__0 |
12521 | // InternalSolverLanguage.g:3584:3: ( rule__DisjunctiveExpression__Group_1_0_1__0 ) | ||
12522 | // InternalSolverLanguage.g:3584:4: rule__DisjunctiveExpression__Group_1_0_1__0 | ||
12523 | { | 11507 | { |
12524 | pushFollow(FOLLOW_20); | 11508 | pushFollow(FOLLOW_19); |
12525 | rule__DisjunctiveExpression__Group_1_0_1__0(); | 11509 | rule__DisjunctiveExpression__Group_1_0_1__0(); |
12526 | 11510 | ||
12527 | state._fsp--; | 11511 | state._fsp--; |
12528 | if (state.failed) return ; | ||
12529 | 11512 | ||
12530 | } | ||
12531 | 11513 | ||
12532 | if ( state.backtracking==0 ) { | ||
12533 | after(grammarAccess.getDisjunctiveExpressionAccess().getGroup_1_0_1()); | ||
12534 | } | 11514 | } |
12535 | 11515 | ||
11516 | after(grammarAccess.getDisjunctiveExpressionAccess().getGroup_1_0_1()); | ||
11517 | |||
12536 | } | 11518 | } |
12537 | 11519 | ||
12538 | // InternalSolverLanguage.g:3587:2: ( ( rule__DisjunctiveExpression__Group_1_0_1__0 )* ) | 11520 | // InternalSolverLanguageParser.g:3639:2: ( ( rule__DisjunctiveExpression__Group_1_0_1__0 )* ) |
12539 | // InternalSolverLanguage.g:3588:3: ( rule__DisjunctiveExpression__Group_1_0_1__0 )* | 11521 | // InternalSolverLanguageParser.g:3640:3: ( rule__DisjunctiveExpression__Group_1_0_1__0 )* |
12540 | { | 11522 | { |
12541 | if ( state.backtracking==0 ) { | 11523 | before(grammarAccess.getDisjunctiveExpressionAccess().getGroup_1_0_1()); |
12542 | before(grammarAccess.getDisjunctiveExpressionAccess().getGroup_1_0_1()); | 11524 | // InternalSolverLanguageParser.g:3641:3: ( rule__DisjunctiveExpression__Group_1_0_1__0 )* |
12543 | } | ||
12544 | // InternalSolverLanguage.g:3589:3: ( rule__DisjunctiveExpression__Group_1_0_1__0 )* | ||
12545 | loop31: | 11525 | loop31: |
12546 | do { | 11526 | do { |
12547 | int alt31=2; | 11527 | int alt31=2; |
12548 | int LA31_0 = input.LA(1); | 11528 | int LA31_0 = input.LA(1); |
12549 | 11529 | ||
12550 | if ( (LA31_0==54) ) { | 11530 | if ( (LA31_0==Semicolon) ) { |
12551 | alt31=1; | 11531 | alt31=1; |
12552 | } | 11532 | } |
12553 | 11533 | ||
12554 | 11534 | ||
12555 | switch (alt31) { | 11535 | switch (alt31) { |
12556 | case 1 : | 11536 | case 1 : |
12557 | // InternalSolverLanguage.g:3589:4: rule__DisjunctiveExpression__Group_1_0_1__0 | 11537 | // InternalSolverLanguageParser.g:3641:4: rule__DisjunctiveExpression__Group_1_0_1__0 |
12558 | { | 11538 | { |
12559 | pushFollow(FOLLOW_20); | 11539 | pushFollow(FOLLOW_19); |
12560 | rule__DisjunctiveExpression__Group_1_0_1__0(); | 11540 | rule__DisjunctiveExpression__Group_1_0_1__0(); |
12561 | 11541 | ||
12562 | state._fsp--; | 11542 | state._fsp--; |
12563 | if (state.failed) return ; | 11543 | |
12564 | 11544 | ||
12565 | } | 11545 | } |
12566 | break; | 11546 | break; |
@@ -12570,9 +11550,7 @@ public class InternalSolverLanguageParser extends AbstractInternalContentAssistP | |||
12570 | } | 11550 | } |
12571 | } while (true); | 11551 | } while (true); |
12572 | 11552 | ||
12573 | if ( state.backtracking==0 ) { | 11553 | after(grammarAccess.getDisjunctiveExpressionAccess().getGroup_1_0_1()); |
12574 | after(grammarAccess.getDisjunctiveExpressionAccess().getGroup_1_0_1()); | ||
12575 | } | ||
12576 | 11554 | ||
12577 | } | 11555 | } |
12578 | 11556 | ||
@@ -12598,25 +11576,25 @@ public class InternalSolverLanguageParser extends AbstractInternalContentAssistP | |||
12598 | 11576 | ||
12599 | 11577 | ||
12600 | // $ANTLR start "rule__DisjunctiveExpression__Group_1_0_1__0" | 11578 | // $ANTLR start "rule__DisjunctiveExpression__Group_1_0_1__0" |
12601 | // InternalSolverLanguage.g:3599:1: rule__DisjunctiveExpression__Group_1_0_1__0 : rule__DisjunctiveExpression__Group_1_0_1__0__Impl rule__DisjunctiveExpression__Group_1_0_1__1 ; | 11579 | // InternalSolverLanguageParser.g:3651:1: rule__DisjunctiveExpression__Group_1_0_1__0 : rule__DisjunctiveExpression__Group_1_0_1__0__Impl rule__DisjunctiveExpression__Group_1_0_1__1 ; |
12602 | public final void rule__DisjunctiveExpression__Group_1_0_1__0() throws RecognitionException { | 11580 | public final void rule__DisjunctiveExpression__Group_1_0_1__0() throws RecognitionException { |
12603 | 11581 | ||
12604 | int stackSize = keepStackSize(); | 11582 | int stackSize = keepStackSize(); |
12605 | 11583 | ||
12606 | try { | 11584 | try { |
12607 | // InternalSolverLanguage.g:3603:1: ( rule__DisjunctiveExpression__Group_1_0_1__0__Impl rule__DisjunctiveExpression__Group_1_0_1__1 ) | 11585 | // InternalSolverLanguageParser.g:3655:1: ( rule__DisjunctiveExpression__Group_1_0_1__0__Impl rule__DisjunctiveExpression__Group_1_0_1__1 ) |
12608 | // InternalSolverLanguage.g:3604:2: rule__DisjunctiveExpression__Group_1_0_1__0__Impl rule__DisjunctiveExpression__Group_1_0_1__1 | 11586 | // InternalSolverLanguageParser.g:3656:2: rule__DisjunctiveExpression__Group_1_0_1__0__Impl rule__DisjunctiveExpression__Group_1_0_1__1 |
12609 | { | 11587 | { |
12610 | pushFollow(FOLLOW_7); | 11588 | pushFollow(FOLLOW_7); |
12611 | rule__DisjunctiveExpression__Group_1_0_1__0__Impl(); | 11589 | rule__DisjunctiveExpression__Group_1_0_1__0__Impl(); |
12612 | 11590 | ||
12613 | state._fsp--; | 11591 | state._fsp--; |
12614 | if (state.failed) return ; | 11592 | |
12615 | pushFollow(FOLLOW_2); | 11593 | pushFollow(FOLLOW_2); |
12616 | rule__DisjunctiveExpression__Group_1_0_1__1(); | 11594 | rule__DisjunctiveExpression__Group_1_0_1__1(); |
12617 | 11595 | ||
12618 | state._fsp--; | 11596 | state._fsp--; |
12619 | if (state.failed) return ; | 11597 | |
12620 | 11598 | ||
12621 | } | 11599 | } |
12622 | 11600 | ||
@@ -12636,25 +11614,21 @@ public class InternalSolverLanguageParser extends AbstractInternalContentAssistP | |||
12636 | 11614 | ||
12637 | 11615 | ||
12638 | // $ANTLR start "rule__DisjunctiveExpression__Group_1_0_1__0__Impl" | 11616 | // $ANTLR start "rule__DisjunctiveExpression__Group_1_0_1__0__Impl" |
12639 | // InternalSolverLanguage.g:3611:1: rule__DisjunctiveExpression__Group_1_0_1__0__Impl : ( ';' ) ; | 11617 | // InternalSolverLanguageParser.g:3663:1: rule__DisjunctiveExpression__Group_1_0_1__0__Impl : ( Semicolon ) ; |
12640 | public final void rule__DisjunctiveExpression__Group_1_0_1__0__Impl() throws RecognitionException { | 11618 | public final void rule__DisjunctiveExpression__Group_1_0_1__0__Impl() throws RecognitionException { |
12641 | 11619 | ||
12642 | int stackSize = keepStackSize(); | 11620 | int stackSize = keepStackSize(); |
12643 | 11621 | ||
12644 | try { | 11622 | try { |
12645 | // InternalSolverLanguage.g:3615:1: ( ( ';' ) ) | 11623 | // InternalSolverLanguageParser.g:3667:1: ( ( Semicolon ) ) |
12646 | // InternalSolverLanguage.g:3616:1: ( ';' ) | 11624 | // InternalSolverLanguageParser.g:3668:1: ( Semicolon ) |
12647 | { | 11625 | { |
12648 | // InternalSolverLanguage.g:3616:1: ( ';' ) | 11626 | // InternalSolverLanguageParser.g:3668:1: ( Semicolon ) |
12649 | // InternalSolverLanguage.g:3617:2: ';' | 11627 | // InternalSolverLanguageParser.g:3669:2: Semicolon |
12650 | { | 11628 | { |
12651 | if ( state.backtracking==0 ) { | 11629 | before(grammarAccess.getDisjunctiveExpressionAccess().getSemicolonKeyword_1_0_1_0()); |
12652 | before(grammarAccess.getDisjunctiveExpressionAccess().getSemicolonKeyword_1_0_1_0()); | 11630 | match(input,Semicolon,FOLLOW_2); |
12653 | } | 11631 | after(grammarAccess.getDisjunctiveExpressionAccess().getSemicolonKeyword_1_0_1_0()); |
12654 | match(input,54,FOLLOW_2); if (state.failed) return ; | ||
12655 | if ( state.backtracking==0 ) { | ||
12656 | after(grammarAccess.getDisjunctiveExpressionAccess().getSemicolonKeyword_1_0_1_0()); | ||
12657 | } | ||
12658 | 11632 | ||
12659 | } | 11633 | } |
12660 | 11634 | ||
@@ -12677,20 +11651,20 @@ public class InternalSolverLanguageParser extends AbstractInternalContentAssistP | |||
12677 | 11651 | ||
12678 | 11652 | ||
12679 | // $ANTLR start "rule__DisjunctiveExpression__Group_1_0_1__1" | 11653 | // $ANTLR start "rule__DisjunctiveExpression__Group_1_0_1__1" |
12680 | // InternalSolverLanguage.g:3626:1: rule__DisjunctiveExpression__Group_1_0_1__1 : rule__DisjunctiveExpression__Group_1_0_1__1__Impl ; | 11654 | // InternalSolverLanguageParser.g:3678:1: rule__DisjunctiveExpression__Group_1_0_1__1 : rule__DisjunctiveExpression__Group_1_0_1__1__Impl ; |
12681 | public final void rule__DisjunctiveExpression__Group_1_0_1__1() throws RecognitionException { | 11655 | public final void rule__DisjunctiveExpression__Group_1_0_1__1() throws RecognitionException { |
12682 | 11656 | ||
12683 | int stackSize = keepStackSize(); | 11657 | int stackSize = keepStackSize(); |
12684 | 11658 | ||
12685 | try { | 11659 | try { |
12686 | // InternalSolverLanguage.g:3630:1: ( rule__DisjunctiveExpression__Group_1_0_1__1__Impl ) | 11660 | // InternalSolverLanguageParser.g:3682:1: ( rule__DisjunctiveExpression__Group_1_0_1__1__Impl ) |
12687 | // InternalSolverLanguage.g:3631:2: rule__DisjunctiveExpression__Group_1_0_1__1__Impl | 11661 | // InternalSolverLanguageParser.g:3683:2: rule__DisjunctiveExpression__Group_1_0_1__1__Impl |
12688 | { | 11662 | { |
12689 | pushFollow(FOLLOW_2); | 11663 | pushFollow(FOLLOW_2); |
12690 | rule__DisjunctiveExpression__Group_1_0_1__1__Impl(); | 11664 | rule__DisjunctiveExpression__Group_1_0_1__1__Impl(); |
12691 | 11665 | ||
12692 | state._fsp--; | 11666 | state._fsp--; |
12693 | if (state.failed) return ; | 11667 | |
12694 | 11668 | ||
12695 | } | 11669 | } |
12696 | 11670 | ||
@@ -12710,36 +11684,32 @@ public class InternalSolverLanguageParser extends AbstractInternalContentAssistP | |||
12710 | 11684 | ||
12711 | 11685 | ||
12712 | // $ANTLR start "rule__DisjunctiveExpression__Group_1_0_1__1__Impl" | 11686 | // $ANTLR start "rule__DisjunctiveExpression__Group_1_0_1__1__Impl" |
12713 | // InternalSolverLanguage.g:3637:1: rule__DisjunctiveExpression__Group_1_0_1__1__Impl : ( ( rule__DisjunctiveExpression__ChildrenAssignment_1_0_1_1 ) ) ; | 11687 | // InternalSolverLanguageParser.g:3689:1: rule__DisjunctiveExpression__Group_1_0_1__1__Impl : ( ( rule__DisjunctiveExpression__ChildrenAssignment_1_0_1_1 ) ) ; |
12714 | public final void rule__DisjunctiveExpression__Group_1_0_1__1__Impl() throws RecognitionException { | 11688 | public final void rule__DisjunctiveExpression__Group_1_0_1__1__Impl() throws RecognitionException { |
12715 | 11689 | ||
12716 | int stackSize = keepStackSize(); | 11690 | int stackSize = keepStackSize(); |
12717 | 11691 | ||
12718 | try { | 11692 | try { |
12719 | // InternalSolverLanguage.g:3641:1: ( ( ( rule__DisjunctiveExpression__ChildrenAssignment_1_0_1_1 ) ) ) | 11693 | // InternalSolverLanguageParser.g:3693:1: ( ( ( rule__DisjunctiveExpression__ChildrenAssignment_1_0_1_1 ) ) ) |
12720 | // InternalSolverLanguage.g:3642:1: ( ( rule__DisjunctiveExpression__ChildrenAssignment_1_0_1_1 ) ) | 11694 | // InternalSolverLanguageParser.g:3694:1: ( ( rule__DisjunctiveExpression__ChildrenAssignment_1_0_1_1 ) ) |
12721 | { | 11695 | { |
12722 | // InternalSolverLanguage.g:3642:1: ( ( rule__DisjunctiveExpression__ChildrenAssignment_1_0_1_1 ) ) | 11696 | // InternalSolverLanguageParser.g:3694:1: ( ( rule__DisjunctiveExpression__ChildrenAssignment_1_0_1_1 ) ) |
12723 | // InternalSolverLanguage.g:3643:2: ( rule__DisjunctiveExpression__ChildrenAssignment_1_0_1_1 ) | 11697 | // InternalSolverLanguageParser.g:3695:2: ( rule__DisjunctiveExpression__ChildrenAssignment_1_0_1_1 ) |
12724 | { | 11698 | { |
12725 | if ( state.backtracking==0 ) { | 11699 | before(grammarAccess.getDisjunctiveExpressionAccess().getChildrenAssignment_1_0_1_1()); |
12726 | before(grammarAccess.getDisjunctiveExpressionAccess().getChildrenAssignment_1_0_1_1()); | 11700 | // InternalSolverLanguageParser.g:3696:2: ( rule__DisjunctiveExpression__ChildrenAssignment_1_0_1_1 ) |
12727 | } | 11701 | // InternalSolverLanguageParser.g:3696:3: rule__DisjunctiveExpression__ChildrenAssignment_1_0_1_1 |
12728 | // InternalSolverLanguage.g:3644:2: ( rule__DisjunctiveExpression__ChildrenAssignment_1_0_1_1 ) | ||
12729 | // InternalSolverLanguage.g:3644:3: rule__DisjunctiveExpression__ChildrenAssignment_1_0_1_1 | ||
12730 | { | 11702 | { |
12731 | pushFollow(FOLLOW_2); | 11703 | pushFollow(FOLLOW_2); |
12732 | rule__DisjunctiveExpression__ChildrenAssignment_1_0_1_1(); | 11704 | rule__DisjunctiveExpression__ChildrenAssignment_1_0_1_1(); |
12733 | 11705 | ||
12734 | state._fsp--; | 11706 | state._fsp--; |
12735 | if (state.failed) return ; | ||
12736 | 11707 | ||
12737 | } | ||
12738 | 11708 | ||
12739 | if ( state.backtracking==0 ) { | ||
12740 | after(grammarAccess.getDisjunctiveExpressionAccess().getChildrenAssignment_1_0_1_1()); | ||
12741 | } | 11709 | } |
12742 | 11710 | ||
11711 | after(grammarAccess.getDisjunctiveExpressionAccess().getChildrenAssignment_1_0_1_1()); | ||
11712 | |||
12743 | } | 11713 | } |
12744 | 11714 | ||
12745 | 11715 | ||
@@ -12761,25 +11731,25 @@ public class InternalSolverLanguageParser extends AbstractInternalContentAssistP | |||
12761 | 11731 | ||
12762 | 11732 | ||
12763 | // $ANTLR start "rule__DisjunctiveExpression__Group_1_1__0" | 11733 | // $ANTLR start "rule__DisjunctiveExpression__Group_1_1__0" |
12764 | // InternalSolverLanguage.g:3653:1: rule__DisjunctiveExpression__Group_1_1__0 : rule__DisjunctiveExpression__Group_1_1__0__Impl rule__DisjunctiveExpression__Group_1_1__1 ; | 11734 | // InternalSolverLanguageParser.g:3705:1: rule__DisjunctiveExpression__Group_1_1__0 : rule__DisjunctiveExpression__Group_1_1__0__Impl rule__DisjunctiveExpression__Group_1_1__1 ; |
12765 | public final void rule__DisjunctiveExpression__Group_1_1__0() throws RecognitionException { | 11735 | public final void rule__DisjunctiveExpression__Group_1_1__0() throws RecognitionException { |
12766 | 11736 | ||
12767 | int stackSize = keepStackSize(); | 11737 | int stackSize = keepStackSize(); |
12768 | 11738 | ||
12769 | try { | 11739 | try { |
12770 | // InternalSolverLanguage.g:3657:1: ( rule__DisjunctiveExpression__Group_1_1__0__Impl rule__DisjunctiveExpression__Group_1_1__1 ) | 11740 | // InternalSolverLanguageParser.g:3709:1: ( rule__DisjunctiveExpression__Group_1_1__0__Impl rule__DisjunctiveExpression__Group_1_1__1 ) |
12771 | // InternalSolverLanguage.g:3658:2: rule__DisjunctiveExpression__Group_1_1__0__Impl rule__DisjunctiveExpression__Group_1_1__1 | 11741 | // InternalSolverLanguageParser.g:3710:2: rule__DisjunctiveExpression__Group_1_1__0__Impl rule__DisjunctiveExpression__Group_1_1__1 |
12772 | { | 11742 | { |
12773 | pushFollow(FOLLOW_18); | 11743 | pushFollow(FOLLOW_17); |
12774 | rule__DisjunctiveExpression__Group_1_1__0__Impl(); | 11744 | rule__DisjunctiveExpression__Group_1_1__0__Impl(); |
12775 | 11745 | ||
12776 | state._fsp--; | 11746 | state._fsp--; |
12777 | if (state.failed) return ; | 11747 | |
12778 | pushFollow(FOLLOW_2); | 11748 | pushFollow(FOLLOW_2); |
12779 | rule__DisjunctiveExpression__Group_1_1__1(); | 11749 | rule__DisjunctiveExpression__Group_1_1__1(); |
12780 | 11750 | ||
12781 | state._fsp--; | 11751 | state._fsp--; |
12782 | if (state.failed) return ; | 11752 | |
12783 | 11753 | ||
12784 | } | 11754 | } |
12785 | 11755 | ||
@@ -12799,29 +11769,25 @@ public class InternalSolverLanguageParser extends AbstractInternalContentAssistP | |||
12799 | 11769 | ||
12800 | 11770 | ||
12801 | // $ANTLR start "rule__DisjunctiveExpression__Group_1_1__0__Impl" | 11771 | // $ANTLR start "rule__DisjunctiveExpression__Group_1_1__0__Impl" |
12802 | // InternalSolverLanguage.g:3665:1: rule__DisjunctiveExpression__Group_1_1__0__Impl : ( () ) ; | 11772 | // InternalSolverLanguageParser.g:3717:1: rule__DisjunctiveExpression__Group_1_1__0__Impl : ( () ) ; |
12803 | public final void rule__DisjunctiveExpression__Group_1_1__0__Impl() throws RecognitionException { | 11773 | public final void rule__DisjunctiveExpression__Group_1_1__0__Impl() throws RecognitionException { |
12804 | 11774 | ||
12805 | int stackSize = keepStackSize(); | 11775 | int stackSize = keepStackSize(); |
12806 | 11776 | ||
12807 | try { | 11777 | try { |
12808 | // InternalSolverLanguage.g:3669:1: ( ( () ) ) | 11778 | // InternalSolverLanguageParser.g:3721:1: ( ( () ) ) |
12809 | // InternalSolverLanguage.g:3670:1: ( () ) | 11779 | // InternalSolverLanguageParser.g:3722:1: ( () ) |
12810 | { | 11780 | { |
12811 | // InternalSolverLanguage.g:3670:1: ( () ) | 11781 | // InternalSolverLanguageParser.g:3722:1: ( () ) |
12812 | // InternalSolverLanguage.g:3671:2: () | 11782 | // InternalSolverLanguageParser.g:3723:2: () |
12813 | { | 11783 | { |
12814 | if ( state.backtracking==0 ) { | 11784 | before(grammarAccess.getDisjunctiveExpressionAccess().getCaseConditionAction_1_1_0()); |
12815 | before(grammarAccess.getDisjunctiveExpressionAccess().getCaseConditionAction_1_1_0()); | 11785 | // InternalSolverLanguageParser.g:3724:2: () |
12816 | } | 11786 | // InternalSolverLanguageParser.g:3724:3: |
12817 | // InternalSolverLanguage.g:3672:2: () | ||
12818 | // InternalSolverLanguage.g:3672:3: | ||
12819 | { | 11787 | { |
12820 | } | 11788 | } |
12821 | 11789 | ||
12822 | if ( state.backtracking==0 ) { | 11790 | after(grammarAccess.getDisjunctiveExpressionAccess().getCaseConditionAction_1_1_0()); |
12823 | after(grammarAccess.getDisjunctiveExpressionAccess().getCaseConditionAction_1_1_0()); | ||
12824 | } | ||
12825 | 11791 | ||
12826 | } | 11792 | } |
12827 | 11793 | ||
@@ -12840,25 +11806,25 @@ public class InternalSolverLanguageParser extends AbstractInternalContentAssistP | |||
12840 | 11806 | ||
12841 | 11807 | ||
12842 | // $ANTLR start "rule__DisjunctiveExpression__Group_1_1__1" | 11808 | // $ANTLR start "rule__DisjunctiveExpression__Group_1_1__1" |
12843 | // InternalSolverLanguage.g:3680:1: rule__DisjunctiveExpression__Group_1_1__1 : rule__DisjunctiveExpression__Group_1_1__1__Impl rule__DisjunctiveExpression__Group_1_1__2 ; | 11809 | // InternalSolverLanguageParser.g:3732:1: rule__DisjunctiveExpression__Group_1_1__1 : rule__DisjunctiveExpression__Group_1_1__1__Impl rule__DisjunctiveExpression__Group_1_1__2 ; |
12844 | public final void rule__DisjunctiveExpression__Group_1_1__1() throws RecognitionException { | 11810 | public final void rule__DisjunctiveExpression__Group_1_1__1() throws RecognitionException { |
12845 | 11811 | ||
12846 | int stackSize = keepStackSize(); | 11812 | int stackSize = keepStackSize(); |
12847 | 11813 | ||
12848 | try { | 11814 | try { |
12849 | // InternalSolverLanguage.g:3684:1: ( rule__DisjunctiveExpression__Group_1_1__1__Impl rule__DisjunctiveExpression__Group_1_1__2 ) | 11815 | // InternalSolverLanguageParser.g:3736:1: ( rule__DisjunctiveExpression__Group_1_1__1__Impl rule__DisjunctiveExpression__Group_1_1__2 ) |
12850 | // InternalSolverLanguage.g:3685:2: rule__DisjunctiveExpression__Group_1_1__1__Impl rule__DisjunctiveExpression__Group_1_1__2 | 11816 | // InternalSolverLanguageParser.g:3737:2: rule__DisjunctiveExpression__Group_1_1__1__Impl rule__DisjunctiveExpression__Group_1_1__2 |
12851 | { | 11817 | { |
12852 | pushFollow(FOLLOW_7); | 11818 | pushFollow(FOLLOW_7); |
12853 | rule__DisjunctiveExpression__Group_1_1__1__Impl(); | 11819 | rule__DisjunctiveExpression__Group_1_1__1__Impl(); |
12854 | 11820 | ||
12855 | state._fsp--; | 11821 | state._fsp--; |
12856 | if (state.failed) return ; | 11822 | |
12857 | pushFollow(FOLLOW_2); | 11823 | pushFollow(FOLLOW_2); |
12858 | rule__DisjunctiveExpression__Group_1_1__2(); | 11824 | rule__DisjunctiveExpression__Group_1_1__2(); |
12859 | 11825 | ||
12860 | state._fsp--; | 11826 | state._fsp--; |
12861 | if (state.failed) return ; | 11827 | |
12862 | 11828 | ||
12863 | } | 11829 | } |
12864 | 11830 | ||
@@ -12878,25 +11844,21 @@ public class InternalSolverLanguageParser extends AbstractInternalContentAssistP | |||
12878 | 11844 | ||
12879 | 11845 | ||
12880 | // $ANTLR start "rule__DisjunctiveExpression__Group_1_1__1__Impl" | 11846 | // $ANTLR start "rule__DisjunctiveExpression__Group_1_1__1__Impl" |
12881 | // InternalSolverLanguage.g:3692:1: rule__DisjunctiveExpression__Group_1_1__1__Impl : ( '->' ) ; | 11847 | // InternalSolverLanguageParser.g:3744:1: rule__DisjunctiveExpression__Group_1_1__1__Impl : ( HyphenMinusGreaterThanSign ) ; |
12882 | public final void rule__DisjunctiveExpression__Group_1_1__1__Impl() throws RecognitionException { | 11848 | public final void rule__DisjunctiveExpression__Group_1_1__1__Impl() throws RecognitionException { |
12883 | 11849 | ||
12884 | int stackSize = keepStackSize(); | 11850 | int stackSize = keepStackSize(); |
12885 | 11851 | ||
12886 | try { | 11852 | try { |
12887 | // InternalSolverLanguage.g:3696:1: ( ( '->' ) ) | 11853 | // InternalSolverLanguageParser.g:3748:1: ( ( HyphenMinusGreaterThanSign ) ) |
12888 | // InternalSolverLanguage.g:3697:1: ( '->' ) | 11854 | // InternalSolverLanguageParser.g:3749:1: ( HyphenMinusGreaterThanSign ) |
12889 | { | 11855 | { |
12890 | // InternalSolverLanguage.g:3697:1: ( '->' ) | 11856 | // InternalSolverLanguageParser.g:3749:1: ( HyphenMinusGreaterThanSign ) |
12891 | // InternalSolverLanguage.g:3698:2: '->' | 11857 | // InternalSolverLanguageParser.g:3750:2: HyphenMinusGreaterThanSign |
12892 | { | 11858 | { |
12893 | if ( state.backtracking==0 ) { | 11859 | before(grammarAccess.getDisjunctiveExpressionAccess().getHyphenMinusGreaterThanSignKeyword_1_1_1()); |
12894 | before(grammarAccess.getDisjunctiveExpressionAccess().getHyphenMinusGreaterThanSignKeyword_1_1_1()); | 11860 | match(input,HyphenMinusGreaterThanSign,FOLLOW_2); |
12895 | } | 11861 | after(grammarAccess.getDisjunctiveExpressionAccess().getHyphenMinusGreaterThanSignKeyword_1_1_1()); |
12896 | match(input,55,FOLLOW_2); if (state.failed) return ; | ||
12897 | if ( state.backtracking==0 ) { | ||
12898 | after(grammarAccess.getDisjunctiveExpressionAccess().getHyphenMinusGreaterThanSignKeyword_1_1_1()); | ||
12899 | } | ||
12900 | 11862 | ||
12901 | } | 11863 | } |
12902 | 11864 | ||
@@ -12919,25 +11881,25 @@ public class InternalSolverLanguageParser extends AbstractInternalContentAssistP | |||
12919 | 11881 | ||
12920 | 11882 | ||
12921 | // $ANTLR start "rule__DisjunctiveExpression__Group_1_1__2" | 11883 | // $ANTLR start "rule__DisjunctiveExpression__Group_1_1__2" |
12922 | // InternalSolverLanguage.g:3707:1: rule__DisjunctiveExpression__Group_1_1__2 : rule__DisjunctiveExpression__Group_1_1__2__Impl rule__DisjunctiveExpression__Group_1_1__3 ; | 11884 | // InternalSolverLanguageParser.g:3759:1: rule__DisjunctiveExpression__Group_1_1__2 : rule__DisjunctiveExpression__Group_1_1__2__Impl rule__DisjunctiveExpression__Group_1_1__3 ; |
12923 | public final void rule__DisjunctiveExpression__Group_1_1__2() throws RecognitionException { | 11885 | public final void rule__DisjunctiveExpression__Group_1_1__2() throws RecognitionException { |
12924 | 11886 | ||
12925 | int stackSize = keepStackSize(); | 11887 | int stackSize = keepStackSize(); |
12926 | 11888 | ||
12927 | try { | 11889 | try { |
12928 | // InternalSolverLanguage.g:3711:1: ( rule__DisjunctiveExpression__Group_1_1__2__Impl rule__DisjunctiveExpression__Group_1_1__3 ) | 11890 | // InternalSolverLanguageParser.g:3763:1: ( rule__DisjunctiveExpression__Group_1_1__2__Impl rule__DisjunctiveExpression__Group_1_1__3 ) |
12929 | // InternalSolverLanguage.g:3712:2: rule__DisjunctiveExpression__Group_1_1__2__Impl rule__DisjunctiveExpression__Group_1_1__3 | 11891 | // InternalSolverLanguageParser.g:3764:2: rule__DisjunctiveExpression__Group_1_1__2__Impl rule__DisjunctiveExpression__Group_1_1__3 |
12930 | { | 11892 | { |
12931 | pushFollow(FOLLOW_19); | 11893 | pushFollow(FOLLOW_18); |
12932 | rule__DisjunctiveExpression__Group_1_1__2__Impl(); | 11894 | rule__DisjunctiveExpression__Group_1_1__2__Impl(); |
12933 | 11895 | ||
12934 | state._fsp--; | 11896 | state._fsp--; |
12935 | if (state.failed) return ; | 11897 | |
12936 | pushFollow(FOLLOW_2); | 11898 | pushFollow(FOLLOW_2); |
12937 | rule__DisjunctiveExpression__Group_1_1__3(); | 11899 | rule__DisjunctiveExpression__Group_1_1__3(); |
12938 | 11900 | ||
12939 | state._fsp--; | 11901 | state._fsp--; |
12940 | if (state.failed) return ; | 11902 | |
12941 | 11903 | ||
12942 | } | 11904 | } |
12943 | 11905 | ||
@@ -12957,36 +11919,32 @@ public class InternalSolverLanguageParser extends AbstractInternalContentAssistP | |||
12957 | 11919 | ||
12958 | 11920 | ||
12959 | // $ANTLR start "rule__DisjunctiveExpression__Group_1_1__2__Impl" | 11921 | // $ANTLR start "rule__DisjunctiveExpression__Group_1_1__2__Impl" |
12960 | // InternalSolverLanguage.g:3719:1: rule__DisjunctiveExpression__Group_1_1__2__Impl : ( ( rule__DisjunctiveExpression__BodyAssignment_1_1_2 ) ) ; | 11922 | // InternalSolverLanguageParser.g:3771:1: rule__DisjunctiveExpression__Group_1_1__2__Impl : ( ( rule__DisjunctiveExpression__BodyAssignment_1_1_2 ) ) ; |
12961 | public final void rule__DisjunctiveExpression__Group_1_1__2__Impl() throws RecognitionException { | 11923 | public final void rule__DisjunctiveExpression__Group_1_1__2__Impl() throws RecognitionException { |
12962 | 11924 | ||
12963 | int stackSize = keepStackSize(); | 11925 | int stackSize = keepStackSize(); |
12964 | 11926 | ||
12965 | try { | 11927 | try { |
12966 | // InternalSolverLanguage.g:3723:1: ( ( ( rule__DisjunctiveExpression__BodyAssignment_1_1_2 ) ) ) | 11928 | // InternalSolverLanguageParser.g:3775:1: ( ( ( rule__DisjunctiveExpression__BodyAssignment_1_1_2 ) ) ) |
12967 | // InternalSolverLanguage.g:3724:1: ( ( rule__DisjunctiveExpression__BodyAssignment_1_1_2 ) ) | 11929 | // InternalSolverLanguageParser.g:3776:1: ( ( rule__DisjunctiveExpression__BodyAssignment_1_1_2 ) ) |
12968 | { | 11930 | { |
12969 | // InternalSolverLanguage.g:3724:1: ( ( rule__DisjunctiveExpression__BodyAssignment_1_1_2 ) ) | 11931 | // InternalSolverLanguageParser.g:3776:1: ( ( rule__DisjunctiveExpression__BodyAssignment_1_1_2 ) ) |
12970 | // InternalSolverLanguage.g:3725:2: ( rule__DisjunctiveExpression__BodyAssignment_1_1_2 ) | 11932 | // InternalSolverLanguageParser.g:3777:2: ( rule__DisjunctiveExpression__BodyAssignment_1_1_2 ) |
12971 | { | 11933 | { |
12972 | if ( state.backtracking==0 ) { | 11934 | before(grammarAccess.getDisjunctiveExpressionAccess().getBodyAssignment_1_1_2()); |
12973 | before(grammarAccess.getDisjunctiveExpressionAccess().getBodyAssignment_1_1_2()); | 11935 | // InternalSolverLanguageParser.g:3778:2: ( rule__DisjunctiveExpression__BodyAssignment_1_1_2 ) |
12974 | } | 11936 | // InternalSolverLanguageParser.g:3778:3: rule__DisjunctiveExpression__BodyAssignment_1_1_2 |
12975 | // InternalSolverLanguage.g:3726:2: ( rule__DisjunctiveExpression__BodyAssignment_1_1_2 ) | ||
12976 | // InternalSolverLanguage.g:3726:3: rule__DisjunctiveExpression__BodyAssignment_1_1_2 | ||
12977 | { | 11937 | { |
12978 | pushFollow(FOLLOW_2); | 11938 | pushFollow(FOLLOW_2); |
12979 | rule__DisjunctiveExpression__BodyAssignment_1_1_2(); | 11939 | rule__DisjunctiveExpression__BodyAssignment_1_1_2(); |
12980 | 11940 | ||
12981 | state._fsp--; | 11941 | state._fsp--; |
12982 | if (state.failed) return ; | ||
12983 | 11942 | ||
12984 | } | ||
12985 | 11943 | ||
12986 | if ( state.backtracking==0 ) { | ||
12987 | after(grammarAccess.getDisjunctiveExpressionAccess().getBodyAssignment_1_1_2()); | ||
12988 | } | 11944 | } |
12989 | 11945 | ||
11946 | after(grammarAccess.getDisjunctiveExpressionAccess().getBodyAssignment_1_1_2()); | ||
11947 | |||
12990 | } | 11948 | } |
12991 | 11949 | ||
12992 | 11950 | ||
@@ -13008,25 +11966,25 @@ public class InternalSolverLanguageParser extends AbstractInternalContentAssistP | |||
13008 | 11966 | ||
13009 | 11967 | ||
13010 | // $ANTLR start "rule__DisjunctiveExpression__Group_1_1__3" | 11968 | // $ANTLR start "rule__DisjunctiveExpression__Group_1_1__3" |
13011 | // InternalSolverLanguage.g:3734:1: rule__DisjunctiveExpression__Group_1_1__3 : rule__DisjunctiveExpression__Group_1_1__3__Impl rule__DisjunctiveExpression__Group_1_1__4 ; | 11969 | // InternalSolverLanguageParser.g:3786:1: rule__DisjunctiveExpression__Group_1_1__3 : rule__DisjunctiveExpression__Group_1_1__3__Impl rule__DisjunctiveExpression__Group_1_1__4 ; |
13012 | public final void rule__DisjunctiveExpression__Group_1_1__3() throws RecognitionException { | 11970 | public final void rule__DisjunctiveExpression__Group_1_1__3() throws RecognitionException { |
13013 | 11971 | ||
13014 | int stackSize = keepStackSize(); | 11972 | int stackSize = keepStackSize(); |
13015 | 11973 | ||
13016 | try { | 11974 | try { |
13017 | // InternalSolverLanguage.g:3738:1: ( rule__DisjunctiveExpression__Group_1_1__3__Impl rule__DisjunctiveExpression__Group_1_1__4 ) | 11975 | // InternalSolverLanguageParser.g:3790:1: ( rule__DisjunctiveExpression__Group_1_1__3__Impl rule__DisjunctiveExpression__Group_1_1__4 ) |
13018 | // InternalSolverLanguage.g:3739:2: rule__DisjunctiveExpression__Group_1_1__3__Impl rule__DisjunctiveExpression__Group_1_1__4 | 11976 | // InternalSolverLanguageParser.g:3791:2: rule__DisjunctiveExpression__Group_1_1__3__Impl rule__DisjunctiveExpression__Group_1_1__4 |
13019 | { | 11977 | { |
13020 | pushFollow(FOLLOW_19); | 11978 | pushFollow(FOLLOW_18); |
13021 | rule__DisjunctiveExpression__Group_1_1__3__Impl(); | 11979 | rule__DisjunctiveExpression__Group_1_1__3__Impl(); |
13022 | 11980 | ||
13023 | state._fsp--; | 11981 | state._fsp--; |
13024 | if (state.failed) return ; | 11982 | |
13025 | pushFollow(FOLLOW_2); | 11983 | pushFollow(FOLLOW_2); |
13026 | rule__DisjunctiveExpression__Group_1_1__4(); | 11984 | rule__DisjunctiveExpression__Group_1_1__4(); |
13027 | 11985 | ||
13028 | state._fsp--; | 11986 | state._fsp--; |
13029 | if (state.failed) return ; | 11987 | |
13030 | 11988 | ||
13031 | } | 11989 | } |
13032 | 11990 | ||
@@ -13046,29 +12004,25 @@ public class InternalSolverLanguageParser extends AbstractInternalContentAssistP | |||
13046 | 12004 | ||
13047 | 12005 | ||
13048 | // $ANTLR start "rule__DisjunctiveExpression__Group_1_1__3__Impl" | 12006 | // $ANTLR start "rule__DisjunctiveExpression__Group_1_1__3__Impl" |
13049 | // InternalSolverLanguage.g:3746:1: rule__DisjunctiveExpression__Group_1_1__3__Impl : ( () ) ; | 12007 | // InternalSolverLanguageParser.g:3798:1: rule__DisjunctiveExpression__Group_1_1__3__Impl : ( () ) ; |
13050 | public final void rule__DisjunctiveExpression__Group_1_1__3__Impl() throws RecognitionException { | 12008 | public final void rule__DisjunctiveExpression__Group_1_1__3__Impl() throws RecognitionException { |
13051 | 12009 | ||
13052 | int stackSize = keepStackSize(); | 12010 | int stackSize = keepStackSize(); |
13053 | 12011 | ||
13054 | try { | 12012 | try { |
13055 | // InternalSolverLanguage.g:3750:1: ( ( () ) ) | 12013 | // InternalSolverLanguageParser.g:3802:1: ( ( () ) ) |
13056 | // InternalSolverLanguage.g:3751:1: ( () ) | 12014 | // InternalSolverLanguageParser.g:3803:1: ( () ) |
13057 | { | 12015 | { |
13058 | // InternalSolverLanguage.g:3751:1: ( () ) | 12016 | // InternalSolverLanguageParser.g:3803:1: ( () ) |
13059 | // InternalSolverLanguage.g:3752:2: () | 12017 | // InternalSolverLanguageParser.g:3804:2: () |
13060 | { | 12018 | { |
13061 | if ( state.backtracking==0 ) { | 12019 | before(grammarAccess.getDisjunctiveExpressionAccess().getSwitchCasesAction_1_1_3()); |
13062 | before(grammarAccess.getDisjunctiveExpressionAccess().getSwitchCasesAction_1_1_3()); | 12020 | // InternalSolverLanguageParser.g:3805:2: () |
13063 | } | 12021 | // InternalSolverLanguageParser.g:3805:3: |
13064 | // InternalSolverLanguage.g:3753:2: () | ||
13065 | // InternalSolverLanguage.g:3753:3: | ||
13066 | { | 12022 | { |
13067 | } | 12023 | } |
13068 | 12024 | ||
13069 | if ( state.backtracking==0 ) { | 12025 | after(grammarAccess.getDisjunctiveExpressionAccess().getSwitchCasesAction_1_1_3()); |
13070 | after(grammarAccess.getDisjunctiveExpressionAccess().getSwitchCasesAction_1_1_3()); | ||
13071 | } | ||
13072 | 12026 | ||
13073 | } | 12027 | } |
13074 | 12028 | ||
@@ -13087,20 +12041,20 @@ public class InternalSolverLanguageParser extends AbstractInternalContentAssistP | |||
13087 | 12041 | ||
13088 | 12042 | ||
13089 | // $ANTLR start "rule__DisjunctiveExpression__Group_1_1__4" | 12043 | // $ANTLR start "rule__DisjunctiveExpression__Group_1_1__4" |
13090 | // InternalSolverLanguage.g:3761:1: rule__DisjunctiveExpression__Group_1_1__4 : rule__DisjunctiveExpression__Group_1_1__4__Impl ; | 12044 | // InternalSolverLanguageParser.g:3813:1: rule__DisjunctiveExpression__Group_1_1__4 : rule__DisjunctiveExpression__Group_1_1__4__Impl ; |
13091 | public final void rule__DisjunctiveExpression__Group_1_1__4() throws RecognitionException { | 12045 | public final void rule__DisjunctiveExpression__Group_1_1__4() throws RecognitionException { |
13092 | 12046 | ||
13093 | int stackSize = keepStackSize(); | 12047 | int stackSize = keepStackSize(); |
13094 | 12048 | ||
13095 | try { | 12049 | try { |
13096 | // InternalSolverLanguage.g:3765:1: ( rule__DisjunctiveExpression__Group_1_1__4__Impl ) | 12050 | // InternalSolverLanguageParser.g:3817:1: ( rule__DisjunctiveExpression__Group_1_1__4__Impl ) |
13097 | // InternalSolverLanguage.g:3766:2: rule__DisjunctiveExpression__Group_1_1__4__Impl | 12051 | // InternalSolverLanguageParser.g:3818:2: rule__DisjunctiveExpression__Group_1_1__4__Impl |
13098 | { | 12052 | { |
13099 | pushFollow(FOLLOW_2); | 12053 | pushFollow(FOLLOW_2); |
13100 | rule__DisjunctiveExpression__Group_1_1__4__Impl(); | 12054 | rule__DisjunctiveExpression__Group_1_1__4__Impl(); |
13101 | 12055 | ||
13102 | state._fsp--; | 12056 | state._fsp--; |
13103 | if (state.failed) return ; | 12057 | |
13104 | 12058 | ||
13105 | } | 12059 | } |
13106 | 12060 | ||
@@ -13120,41 +12074,39 @@ public class InternalSolverLanguageParser extends AbstractInternalContentAssistP | |||
13120 | 12074 | ||
13121 | 12075 | ||
13122 | // $ANTLR start "rule__DisjunctiveExpression__Group_1_1__4__Impl" | 12076 | // $ANTLR start "rule__DisjunctiveExpression__Group_1_1__4__Impl" |
13123 | // InternalSolverLanguage.g:3772:1: rule__DisjunctiveExpression__Group_1_1__4__Impl : ( ( rule__DisjunctiveExpression__Group_1_1_4__0 )* ) ; | 12077 | // InternalSolverLanguageParser.g:3824:1: rule__DisjunctiveExpression__Group_1_1__4__Impl : ( ( rule__DisjunctiveExpression__Group_1_1_4__0 )* ) ; |
13124 | public final void rule__DisjunctiveExpression__Group_1_1__4__Impl() throws RecognitionException { | 12078 | public final void rule__DisjunctiveExpression__Group_1_1__4__Impl() throws RecognitionException { |
13125 | 12079 | ||
13126 | int stackSize = keepStackSize(); | 12080 | int stackSize = keepStackSize(); |
13127 | 12081 | ||
13128 | try { | 12082 | try { |
13129 | // InternalSolverLanguage.g:3776:1: ( ( ( rule__DisjunctiveExpression__Group_1_1_4__0 )* ) ) | 12083 | // InternalSolverLanguageParser.g:3828:1: ( ( ( rule__DisjunctiveExpression__Group_1_1_4__0 )* ) ) |
13130 | // InternalSolverLanguage.g:3777:1: ( ( rule__DisjunctiveExpression__Group_1_1_4__0 )* ) | 12084 | // InternalSolverLanguageParser.g:3829:1: ( ( rule__DisjunctiveExpression__Group_1_1_4__0 )* ) |
13131 | { | 12085 | { |
13132 | // InternalSolverLanguage.g:3777:1: ( ( rule__DisjunctiveExpression__Group_1_1_4__0 )* ) | 12086 | // InternalSolverLanguageParser.g:3829:1: ( ( rule__DisjunctiveExpression__Group_1_1_4__0 )* ) |
13133 | // InternalSolverLanguage.g:3778:2: ( rule__DisjunctiveExpression__Group_1_1_4__0 )* | 12087 | // InternalSolverLanguageParser.g:3830:2: ( rule__DisjunctiveExpression__Group_1_1_4__0 )* |
13134 | { | 12088 | { |
13135 | if ( state.backtracking==0 ) { | 12089 | before(grammarAccess.getDisjunctiveExpressionAccess().getGroup_1_1_4()); |
13136 | before(grammarAccess.getDisjunctiveExpressionAccess().getGroup_1_1_4()); | 12090 | // InternalSolverLanguageParser.g:3831:2: ( rule__DisjunctiveExpression__Group_1_1_4__0 )* |
13137 | } | ||
13138 | // InternalSolverLanguage.g:3779:2: ( rule__DisjunctiveExpression__Group_1_1_4__0 )* | ||
13139 | loop32: | 12091 | loop32: |
13140 | do { | 12092 | do { |
13141 | int alt32=2; | 12093 | int alt32=2; |
13142 | int LA32_0 = input.LA(1); | 12094 | int LA32_0 = input.LA(1); |
13143 | 12095 | ||
13144 | if ( (LA32_0==54) ) { | 12096 | if ( (LA32_0==Semicolon) ) { |
13145 | alt32=1; | 12097 | alt32=1; |
13146 | } | 12098 | } |
13147 | 12099 | ||
13148 | 12100 | ||
13149 | switch (alt32) { | 12101 | switch (alt32) { |
13150 | case 1 : | 12102 | case 1 : |
13151 | // InternalSolverLanguage.g:3779:3: rule__DisjunctiveExpression__Group_1_1_4__0 | 12103 | // InternalSolverLanguageParser.g:3831:3: rule__DisjunctiveExpression__Group_1_1_4__0 |
13152 | { | 12104 | { |
13153 | pushFollow(FOLLOW_20); | 12105 | pushFollow(FOLLOW_19); |
13154 | rule__DisjunctiveExpression__Group_1_1_4__0(); | 12106 | rule__DisjunctiveExpression__Group_1_1_4__0(); |
13155 | 12107 | ||
13156 | state._fsp--; | 12108 | state._fsp--; |
13157 | if (state.failed) return ; | 12109 | |
13158 | 12110 | ||
13159 | } | 12111 | } |
13160 | break; | 12112 | break; |
@@ -13164,9 +12116,7 @@ public class InternalSolverLanguageParser extends AbstractInternalContentAssistP | |||
13164 | } | 12116 | } |
13165 | } while (true); | 12117 | } while (true); |
13166 | 12118 | ||
13167 | if ( state.backtracking==0 ) { | 12119 | after(grammarAccess.getDisjunctiveExpressionAccess().getGroup_1_1_4()); |
13168 | after(grammarAccess.getDisjunctiveExpressionAccess().getGroup_1_1_4()); | ||
13169 | } | ||
13170 | 12120 | ||
13171 | } | 12121 | } |
13172 | 12122 | ||
@@ -13189,25 +12139,25 @@ public class InternalSolverLanguageParser extends AbstractInternalContentAssistP | |||
13189 | 12139 | ||
13190 | 12140 | ||
13191 | // $ANTLR start "rule__DisjunctiveExpression__Group_1_1_4__0" | 12141 | // $ANTLR start "rule__DisjunctiveExpression__Group_1_1_4__0" |
13192 | // InternalSolverLanguage.g:3788:1: rule__DisjunctiveExpression__Group_1_1_4__0 : rule__DisjunctiveExpression__Group_1_1_4__0__Impl rule__DisjunctiveExpression__Group_1_1_4__1 ; | 12142 | // InternalSolverLanguageParser.g:3840:1: rule__DisjunctiveExpression__Group_1_1_4__0 : rule__DisjunctiveExpression__Group_1_1_4__0__Impl rule__DisjunctiveExpression__Group_1_1_4__1 ; |
13193 | public final void rule__DisjunctiveExpression__Group_1_1_4__0() throws RecognitionException { | 12143 | public final void rule__DisjunctiveExpression__Group_1_1_4__0() throws RecognitionException { |
13194 | 12144 | ||
13195 | int stackSize = keepStackSize(); | 12145 | int stackSize = keepStackSize(); |
13196 | 12146 | ||
13197 | try { | 12147 | try { |
13198 | // InternalSolverLanguage.g:3792:1: ( rule__DisjunctiveExpression__Group_1_1_4__0__Impl rule__DisjunctiveExpression__Group_1_1_4__1 ) | 12148 | // InternalSolverLanguageParser.g:3844:1: ( rule__DisjunctiveExpression__Group_1_1_4__0__Impl rule__DisjunctiveExpression__Group_1_1_4__1 ) |
13199 | // InternalSolverLanguage.g:3793:2: rule__DisjunctiveExpression__Group_1_1_4__0__Impl rule__DisjunctiveExpression__Group_1_1_4__1 | 12149 | // InternalSolverLanguageParser.g:3845:2: rule__DisjunctiveExpression__Group_1_1_4__0__Impl rule__DisjunctiveExpression__Group_1_1_4__1 |
13200 | { | 12150 | { |
13201 | pushFollow(FOLLOW_7); | 12151 | pushFollow(FOLLOW_7); |
13202 | rule__DisjunctiveExpression__Group_1_1_4__0__Impl(); | 12152 | rule__DisjunctiveExpression__Group_1_1_4__0__Impl(); |
13203 | 12153 | ||
13204 | state._fsp--; | 12154 | state._fsp--; |
13205 | if (state.failed) return ; | 12155 | |
13206 | pushFollow(FOLLOW_2); | 12156 | pushFollow(FOLLOW_2); |
13207 | rule__DisjunctiveExpression__Group_1_1_4__1(); | 12157 | rule__DisjunctiveExpression__Group_1_1_4__1(); |
13208 | 12158 | ||
13209 | state._fsp--; | 12159 | state._fsp--; |
13210 | if (state.failed) return ; | 12160 | |
13211 | 12161 | ||
13212 | } | 12162 | } |
13213 | 12163 | ||
@@ -13227,25 +12177,21 @@ public class InternalSolverLanguageParser extends AbstractInternalContentAssistP | |||
13227 | 12177 | ||
13228 | 12178 | ||
13229 | // $ANTLR start "rule__DisjunctiveExpression__Group_1_1_4__0__Impl" | 12179 | // $ANTLR start "rule__DisjunctiveExpression__Group_1_1_4__0__Impl" |
13230 | // InternalSolverLanguage.g:3800:1: rule__DisjunctiveExpression__Group_1_1_4__0__Impl : ( ';' ) ; | 12180 | // InternalSolverLanguageParser.g:3852:1: rule__DisjunctiveExpression__Group_1_1_4__0__Impl : ( Semicolon ) ; |
13231 | public final void rule__DisjunctiveExpression__Group_1_1_4__0__Impl() throws RecognitionException { | 12181 | public final void rule__DisjunctiveExpression__Group_1_1_4__0__Impl() throws RecognitionException { |
13232 | 12182 | ||
13233 | int stackSize = keepStackSize(); | 12183 | int stackSize = keepStackSize(); |
13234 | 12184 | ||
13235 | try { | 12185 | try { |
13236 | // InternalSolverLanguage.g:3804:1: ( ( ';' ) ) | 12186 | // InternalSolverLanguageParser.g:3856:1: ( ( Semicolon ) ) |
13237 | // InternalSolverLanguage.g:3805:1: ( ';' ) | 12187 | // InternalSolverLanguageParser.g:3857:1: ( Semicolon ) |
13238 | { | 12188 | { |
13239 | // InternalSolverLanguage.g:3805:1: ( ';' ) | 12189 | // InternalSolverLanguageParser.g:3857:1: ( Semicolon ) |
13240 | // InternalSolverLanguage.g:3806:2: ';' | 12190 | // InternalSolverLanguageParser.g:3858:2: Semicolon |
13241 | { | 12191 | { |
13242 | if ( state.backtracking==0 ) { | 12192 | before(grammarAccess.getDisjunctiveExpressionAccess().getSemicolonKeyword_1_1_4_0()); |
13243 | before(grammarAccess.getDisjunctiveExpressionAccess().getSemicolonKeyword_1_1_4_0()); | 12193 | match(input,Semicolon,FOLLOW_2); |
13244 | } | 12194 | after(grammarAccess.getDisjunctiveExpressionAccess().getSemicolonKeyword_1_1_4_0()); |
13245 | match(input,54,FOLLOW_2); if (state.failed) return ; | ||
13246 | if ( state.backtracking==0 ) { | ||
13247 | after(grammarAccess.getDisjunctiveExpressionAccess().getSemicolonKeyword_1_1_4_0()); | ||
13248 | } | ||
13249 | 12195 | ||
13250 | } | 12196 | } |
13251 | 12197 | ||
@@ -13268,20 +12214,20 @@ public class InternalSolverLanguageParser extends AbstractInternalContentAssistP | |||
13268 | 12214 | ||
13269 | 12215 | ||
13270 | // $ANTLR start "rule__DisjunctiveExpression__Group_1_1_4__1" | 12216 | // $ANTLR start "rule__DisjunctiveExpression__Group_1_1_4__1" |
13271 | // InternalSolverLanguage.g:3815:1: rule__DisjunctiveExpression__Group_1_1_4__1 : rule__DisjunctiveExpression__Group_1_1_4__1__Impl ; | 12217 | // InternalSolverLanguageParser.g:3867:1: rule__DisjunctiveExpression__Group_1_1_4__1 : rule__DisjunctiveExpression__Group_1_1_4__1__Impl ; |
13272 | public final void rule__DisjunctiveExpression__Group_1_1_4__1() throws RecognitionException { | 12218 | public final void rule__DisjunctiveExpression__Group_1_1_4__1() throws RecognitionException { |
13273 | 12219 | ||
13274 | int stackSize = keepStackSize(); | 12220 | int stackSize = keepStackSize(); |
13275 | 12221 | ||
13276 | try { | 12222 | try { |
13277 | // InternalSolverLanguage.g:3819:1: ( rule__DisjunctiveExpression__Group_1_1_4__1__Impl ) | 12223 | // InternalSolverLanguageParser.g:3871:1: ( rule__DisjunctiveExpression__Group_1_1_4__1__Impl ) |
13278 | // InternalSolverLanguage.g:3820:2: rule__DisjunctiveExpression__Group_1_1_4__1__Impl | 12224 | // InternalSolverLanguageParser.g:3872:2: rule__DisjunctiveExpression__Group_1_1_4__1__Impl |
13279 | { | 12225 | { |
13280 | pushFollow(FOLLOW_2); | 12226 | pushFollow(FOLLOW_2); |
13281 | rule__DisjunctiveExpression__Group_1_1_4__1__Impl(); | 12227 | rule__DisjunctiveExpression__Group_1_1_4__1__Impl(); |
13282 | 12228 | ||
13283 | state._fsp--; | 12229 | state._fsp--; |
13284 | if (state.failed) return ; | 12230 | |
13285 | 12231 | ||
13286 | } | 12232 | } |
13287 | 12233 | ||
@@ -13301,36 +12247,32 @@ public class InternalSolverLanguageParser extends AbstractInternalContentAssistP | |||
13301 | 12247 | ||
13302 | 12248 | ||
13303 | // $ANTLR start "rule__DisjunctiveExpression__Group_1_1_4__1__Impl" | 12249 | // $ANTLR start "rule__DisjunctiveExpression__Group_1_1_4__1__Impl" |
13304 | // InternalSolverLanguage.g:3826:1: rule__DisjunctiveExpression__Group_1_1_4__1__Impl : ( ( rule__DisjunctiveExpression__CasesAssignment_1_1_4_1 ) ) ; | 12250 | // InternalSolverLanguageParser.g:3878:1: rule__DisjunctiveExpression__Group_1_1_4__1__Impl : ( ( rule__DisjunctiveExpression__CasesAssignment_1_1_4_1 ) ) ; |
13305 | public final void rule__DisjunctiveExpression__Group_1_1_4__1__Impl() throws RecognitionException { | 12251 | public final void rule__DisjunctiveExpression__Group_1_1_4__1__Impl() throws RecognitionException { |
13306 | 12252 | ||
13307 | int stackSize = keepStackSize(); | 12253 | int stackSize = keepStackSize(); |
13308 | 12254 | ||
13309 | try { | 12255 | try { |
13310 | // InternalSolverLanguage.g:3830:1: ( ( ( rule__DisjunctiveExpression__CasesAssignment_1_1_4_1 ) ) ) | 12256 | // InternalSolverLanguageParser.g:3882:1: ( ( ( rule__DisjunctiveExpression__CasesAssignment_1_1_4_1 ) ) ) |
13311 | // InternalSolverLanguage.g:3831:1: ( ( rule__DisjunctiveExpression__CasesAssignment_1_1_4_1 ) ) | 12257 | // InternalSolverLanguageParser.g:3883:1: ( ( rule__DisjunctiveExpression__CasesAssignment_1_1_4_1 ) ) |
13312 | { | 12258 | { |
13313 | // InternalSolverLanguage.g:3831:1: ( ( rule__DisjunctiveExpression__CasesAssignment_1_1_4_1 ) ) | 12259 | // InternalSolverLanguageParser.g:3883:1: ( ( rule__DisjunctiveExpression__CasesAssignment_1_1_4_1 ) ) |
13314 | // InternalSolverLanguage.g:3832:2: ( rule__DisjunctiveExpression__CasesAssignment_1_1_4_1 ) | 12260 | // InternalSolverLanguageParser.g:3884:2: ( rule__DisjunctiveExpression__CasesAssignment_1_1_4_1 ) |
13315 | { | 12261 | { |
13316 | if ( state.backtracking==0 ) { | 12262 | before(grammarAccess.getDisjunctiveExpressionAccess().getCasesAssignment_1_1_4_1()); |
13317 | before(grammarAccess.getDisjunctiveExpressionAccess().getCasesAssignment_1_1_4_1()); | 12263 | // InternalSolverLanguageParser.g:3885:2: ( rule__DisjunctiveExpression__CasesAssignment_1_1_4_1 ) |
13318 | } | 12264 | // InternalSolverLanguageParser.g:3885:3: rule__DisjunctiveExpression__CasesAssignment_1_1_4_1 |
13319 | // InternalSolverLanguage.g:3833:2: ( rule__DisjunctiveExpression__CasesAssignment_1_1_4_1 ) | ||
13320 | // InternalSolverLanguage.g:3833:3: rule__DisjunctiveExpression__CasesAssignment_1_1_4_1 | ||
13321 | { | 12265 | { |
13322 | pushFollow(FOLLOW_2); | 12266 | pushFollow(FOLLOW_2); |
13323 | rule__DisjunctiveExpression__CasesAssignment_1_1_4_1(); | 12267 | rule__DisjunctiveExpression__CasesAssignment_1_1_4_1(); |
13324 | 12268 | ||
13325 | state._fsp--; | 12269 | state._fsp--; |
13326 | if (state.failed) return ; | ||
13327 | 12270 | ||
13328 | } | ||
13329 | 12271 | ||
13330 | if ( state.backtracking==0 ) { | ||
13331 | after(grammarAccess.getDisjunctiveExpressionAccess().getCasesAssignment_1_1_4_1()); | ||
13332 | } | 12272 | } |
13333 | 12273 | ||
12274 | after(grammarAccess.getDisjunctiveExpressionAccess().getCasesAssignment_1_1_4_1()); | ||
12275 | |||
13334 | } | 12276 | } |
13335 | 12277 | ||
13336 | 12278 | ||
@@ -13352,25 +12294,25 @@ public class InternalSolverLanguageParser extends AbstractInternalContentAssistP | |||
13352 | 12294 | ||
13353 | 12295 | ||
13354 | // $ANTLR start "rule__Case__Group__0" | 12296 | // $ANTLR start "rule__Case__Group__0" |
13355 | // InternalSolverLanguage.g:3842:1: rule__Case__Group__0 : rule__Case__Group__0__Impl rule__Case__Group__1 ; | 12297 | // InternalSolverLanguageParser.g:3894:1: rule__Case__Group__0 : rule__Case__Group__0__Impl rule__Case__Group__1 ; |
13356 | public final void rule__Case__Group__0() throws RecognitionException { | 12298 | public final void rule__Case__Group__0() throws RecognitionException { |
13357 | 12299 | ||
13358 | int stackSize = keepStackSize(); | 12300 | int stackSize = keepStackSize(); |
13359 | 12301 | ||
13360 | try { | 12302 | try { |
13361 | // InternalSolverLanguage.g:3846:1: ( rule__Case__Group__0__Impl rule__Case__Group__1 ) | 12303 | // InternalSolverLanguageParser.g:3898:1: ( rule__Case__Group__0__Impl rule__Case__Group__1 ) |
13362 | // InternalSolverLanguage.g:3847:2: rule__Case__Group__0__Impl rule__Case__Group__1 | 12304 | // InternalSolverLanguageParser.g:3899:2: rule__Case__Group__0__Impl rule__Case__Group__1 |
13363 | { | 12305 | { |
13364 | pushFollow(FOLLOW_21); | 12306 | pushFollow(FOLLOW_20); |
13365 | rule__Case__Group__0__Impl(); | 12307 | rule__Case__Group__0__Impl(); |
13366 | 12308 | ||
13367 | state._fsp--; | 12309 | state._fsp--; |
13368 | if (state.failed) return ; | 12310 | |
13369 | pushFollow(FOLLOW_2); | 12311 | pushFollow(FOLLOW_2); |
13370 | rule__Case__Group__1(); | 12312 | rule__Case__Group__1(); |
13371 | 12313 | ||
13372 | state._fsp--; | 12314 | state._fsp--; |
13373 | if (state.failed) return ; | 12315 | |
13374 | 12316 | ||
13375 | } | 12317 | } |
13376 | 12318 | ||
@@ -13390,36 +12332,32 @@ public class InternalSolverLanguageParser extends AbstractInternalContentAssistP | |||
13390 | 12332 | ||
13391 | 12333 | ||
13392 | // $ANTLR start "rule__Case__Group__0__Impl" | 12334 | // $ANTLR start "rule__Case__Group__0__Impl" |
13393 | // InternalSolverLanguage.g:3854:1: rule__Case__Group__0__Impl : ( ( rule__Case__ConditionAssignment_0 ) ) ; | 12335 | // InternalSolverLanguageParser.g:3906:1: rule__Case__Group__0__Impl : ( ( rule__Case__ConditionAssignment_0 ) ) ; |
13394 | public final void rule__Case__Group__0__Impl() throws RecognitionException { | 12336 | public final void rule__Case__Group__0__Impl() throws RecognitionException { |
13395 | 12337 | ||
13396 | int stackSize = keepStackSize(); | 12338 | int stackSize = keepStackSize(); |
13397 | 12339 | ||
13398 | try { | 12340 | try { |
13399 | // InternalSolverLanguage.g:3858:1: ( ( ( rule__Case__ConditionAssignment_0 ) ) ) | 12341 | // InternalSolverLanguageParser.g:3910:1: ( ( ( rule__Case__ConditionAssignment_0 ) ) ) |
13400 | // InternalSolverLanguage.g:3859:1: ( ( rule__Case__ConditionAssignment_0 ) ) | 12342 | // InternalSolverLanguageParser.g:3911:1: ( ( rule__Case__ConditionAssignment_0 ) ) |
13401 | { | 12343 | { |
13402 | // InternalSolverLanguage.g:3859:1: ( ( rule__Case__ConditionAssignment_0 ) ) | 12344 | // InternalSolverLanguageParser.g:3911:1: ( ( rule__Case__ConditionAssignment_0 ) ) |
13403 | // InternalSolverLanguage.g:3860:2: ( rule__Case__ConditionAssignment_0 ) | 12345 | // InternalSolverLanguageParser.g:3912:2: ( rule__Case__ConditionAssignment_0 ) |
13404 | { | 12346 | { |
13405 | if ( state.backtracking==0 ) { | 12347 | before(grammarAccess.getCaseAccess().getConditionAssignment_0()); |
13406 | before(grammarAccess.getCaseAccess().getConditionAssignment_0()); | 12348 | // InternalSolverLanguageParser.g:3913:2: ( rule__Case__ConditionAssignment_0 ) |
13407 | } | 12349 | // InternalSolverLanguageParser.g:3913:3: rule__Case__ConditionAssignment_0 |
13408 | // InternalSolverLanguage.g:3861:2: ( rule__Case__ConditionAssignment_0 ) | ||
13409 | // InternalSolverLanguage.g:3861:3: rule__Case__ConditionAssignment_0 | ||
13410 | { | 12350 | { |
13411 | pushFollow(FOLLOW_2); | 12351 | pushFollow(FOLLOW_2); |
13412 | rule__Case__ConditionAssignment_0(); | 12352 | rule__Case__ConditionAssignment_0(); |
13413 | 12353 | ||
13414 | state._fsp--; | 12354 | state._fsp--; |
13415 | if (state.failed) return ; | ||
13416 | 12355 | ||
13417 | } | ||
13418 | 12356 | ||
13419 | if ( state.backtracking==0 ) { | ||
13420 | after(grammarAccess.getCaseAccess().getConditionAssignment_0()); | ||
13421 | } | 12357 | } |
13422 | 12358 | ||
12359 | after(grammarAccess.getCaseAccess().getConditionAssignment_0()); | ||
12360 | |||
13423 | } | 12361 | } |
13424 | 12362 | ||
13425 | 12363 | ||
@@ -13441,25 +12379,25 @@ public class InternalSolverLanguageParser extends AbstractInternalContentAssistP | |||
13441 | 12379 | ||
13442 | 12380 | ||
13443 | // $ANTLR start "rule__Case__Group__1" | 12381 | // $ANTLR start "rule__Case__Group__1" |
13444 | // InternalSolverLanguage.g:3869:1: rule__Case__Group__1 : rule__Case__Group__1__Impl rule__Case__Group__2 ; | 12382 | // InternalSolverLanguageParser.g:3921:1: rule__Case__Group__1 : rule__Case__Group__1__Impl rule__Case__Group__2 ; |
13445 | public final void rule__Case__Group__1() throws RecognitionException { | 12383 | public final void rule__Case__Group__1() throws RecognitionException { |
13446 | 12384 | ||
13447 | int stackSize = keepStackSize(); | 12385 | int stackSize = keepStackSize(); |
13448 | 12386 | ||
13449 | try { | 12387 | try { |
13450 | // InternalSolverLanguage.g:3873:1: ( rule__Case__Group__1__Impl rule__Case__Group__2 ) | 12388 | // InternalSolverLanguageParser.g:3925:1: ( rule__Case__Group__1__Impl rule__Case__Group__2 ) |
13451 | // InternalSolverLanguage.g:3874:2: rule__Case__Group__1__Impl rule__Case__Group__2 | 12389 | // InternalSolverLanguageParser.g:3926:2: rule__Case__Group__1__Impl rule__Case__Group__2 |
13452 | { | 12390 | { |
13453 | pushFollow(FOLLOW_7); | 12391 | pushFollow(FOLLOW_7); |
13454 | rule__Case__Group__1__Impl(); | 12392 | rule__Case__Group__1__Impl(); |
13455 | 12393 | ||
13456 | state._fsp--; | 12394 | state._fsp--; |
13457 | if (state.failed) return ; | 12395 | |
13458 | pushFollow(FOLLOW_2); | 12396 | pushFollow(FOLLOW_2); |
13459 | rule__Case__Group__2(); | 12397 | rule__Case__Group__2(); |
13460 | 12398 | ||
13461 | state._fsp--; | 12399 | state._fsp--; |
13462 | if (state.failed) return ; | 12400 | |
13463 | 12401 | ||
13464 | } | 12402 | } |
13465 | 12403 | ||
@@ -13479,25 +12417,21 @@ public class InternalSolverLanguageParser extends AbstractInternalContentAssistP | |||
13479 | 12417 | ||
13480 | 12418 | ||
13481 | // $ANTLR start "rule__Case__Group__1__Impl" | 12419 | // $ANTLR start "rule__Case__Group__1__Impl" |
13482 | // InternalSolverLanguage.g:3881:1: rule__Case__Group__1__Impl : ( '->' ) ; | 12420 | // InternalSolverLanguageParser.g:3933:1: rule__Case__Group__1__Impl : ( HyphenMinusGreaterThanSign ) ; |
13483 | public final void rule__Case__Group__1__Impl() throws RecognitionException { | 12421 | public final void rule__Case__Group__1__Impl() throws RecognitionException { |
13484 | 12422 | ||
13485 | int stackSize = keepStackSize(); | 12423 | int stackSize = keepStackSize(); |
13486 | 12424 | ||
13487 | try { | 12425 | try { |
13488 | // InternalSolverLanguage.g:3885:1: ( ( '->' ) ) | 12426 | // InternalSolverLanguageParser.g:3937:1: ( ( HyphenMinusGreaterThanSign ) ) |
13489 | // InternalSolverLanguage.g:3886:1: ( '->' ) | 12427 | // InternalSolverLanguageParser.g:3938:1: ( HyphenMinusGreaterThanSign ) |
13490 | { | 12428 | { |
13491 | // InternalSolverLanguage.g:3886:1: ( '->' ) | 12429 | // InternalSolverLanguageParser.g:3938:1: ( HyphenMinusGreaterThanSign ) |
13492 | // InternalSolverLanguage.g:3887:2: '->' | 12430 | // InternalSolverLanguageParser.g:3939:2: HyphenMinusGreaterThanSign |
13493 | { | 12431 | { |
13494 | if ( state.backtracking==0 ) { | 12432 | before(grammarAccess.getCaseAccess().getHyphenMinusGreaterThanSignKeyword_1()); |
13495 | before(grammarAccess.getCaseAccess().getHyphenMinusGreaterThanSignKeyword_1()); | 12433 | match(input,HyphenMinusGreaterThanSign,FOLLOW_2); |
13496 | } | 12434 | after(grammarAccess.getCaseAccess().getHyphenMinusGreaterThanSignKeyword_1()); |
13497 | match(input,55,FOLLOW_2); if (state.failed) return ; | ||
13498 | if ( state.backtracking==0 ) { | ||
13499 | after(grammarAccess.getCaseAccess().getHyphenMinusGreaterThanSignKeyword_1()); | ||
13500 | } | ||
13501 | 12435 | ||
13502 | } | 12436 | } |
13503 | 12437 | ||
@@ -13520,20 +12454,20 @@ public class InternalSolverLanguageParser extends AbstractInternalContentAssistP | |||
13520 | 12454 | ||
13521 | 12455 | ||
13522 | // $ANTLR start "rule__Case__Group__2" | 12456 | // $ANTLR start "rule__Case__Group__2" |
13523 | // InternalSolverLanguage.g:3896:1: rule__Case__Group__2 : rule__Case__Group__2__Impl ; | 12457 | // InternalSolverLanguageParser.g:3948:1: rule__Case__Group__2 : rule__Case__Group__2__Impl ; |
13524 | public final void rule__Case__Group__2() throws RecognitionException { | 12458 | public final void rule__Case__Group__2() throws RecognitionException { |
13525 | 12459 | ||
13526 | int stackSize = keepStackSize(); | 12460 | int stackSize = keepStackSize(); |
13527 | 12461 | ||
13528 | try { | 12462 | try { |
13529 | // InternalSolverLanguage.g:3900:1: ( rule__Case__Group__2__Impl ) | 12463 | // InternalSolverLanguageParser.g:3952:1: ( rule__Case__Group__2__Impl ) |
13530 | // InternalSolverLanguage.g:3901:2: rule__Case__Group__2__Impl | 12464 | // InternalSolverLanguageParser.g:3953:2: rule__Case__Group__2__Impl |
13531 | { | 12465 | { |
13532 | pushFollow(FOLLOW_2); | 12466 | pushFollow(FOLLOW_2); |
13533 | rule__Case__Group__2__Impl(); | 12467 | rule__Case__Group__2__Impl(); |
13534 | 12468 | ||
13535 | state._fsp--; | 12469 | state._fsp--; |
13536 | if (state.failed) return ; | 12470 | |
13537 | 12471 | ||
13538 | } | 12472 | } |
13539 | 12473 | ||
@@ -13553,36 +12487,32 @@ public class InternalSolverLanguageParser extends AbstractInternalContentAssistP | |||
13553 | 12487 | ||
13554 | 12488 | ||
13555 | // $ANTLR start "rule__Case__Group__2__Impl" | 12489 | // $ANTLR start "rule__Case__Group__2__Impl" |
13556 | // InternalSolverLanguage.g:3907:1: rule__Case__Group__2__Impl : ( ( rule__Case__BodyAssignment_2 ) ) ; | 12490 | // InternalSolverLanguageParser.g:3959:1: rule__Case__Group__2__Impl : ( ( rule__Case__BodyAssignment_2 ) ) ; |
13557 | public final void rule__Case__Group__2__Impl() throws RecognitionException { | 12491 | public final void rule__Case__Group__2__Impl() throws RecognitionException { |
13558 | 12492 | ||
13559 | int stackSize = keepStackSize(); | 12493 | int stackSize = keepStackSize(); |
13560 | 12494 | ||
13561 | try { | 12495 | try { |
13562 | // InternalSolverLanguage.g:3911:1: ( ( ( rule__Case__BodyAssignment_2 ) ) ) | 12496 | // InternalSolverLanguageParser.g:3963:1: ( ( ( rule__Case__BodyAssignment_2 ) ) ) |
13563 | // InternalSolverLanguage.g:3912:1: ( ( rule__Case__BodyAssignment_2 ) ) | 12497 | // InternalSolverLanguageParser.g:3964:1: ( ( rule__Case__BodyAssignment_2 ) ) |
13564 | { | 12498 | { |
13565 | // InternalSolverLanguage.g:3912:1: ( ( rule__Case__BodyAssignment_2 ) ) | 12499 | // InternalSolverLanguageParser.g:3964:1: ( ( rule__Case__BodyAssignment_2 ) ) |
13566 | // InternalSolverLanguage.g:3913:2: ( rule__Case__BodyAssignment_2 ) | 12500 | // InternalSolverLanguageParser.g:3965:2: ( rule__Case__BodyAssignment_2 ) |
13567 | { | 12501 | { |
13568 | if ( state.backtracking==0 ) { | 12502 | before(grammarAccess.getCaseAccess().getBodyAssignment_2()); |
13569 | before(grammarAccess.getCaseAccess().getBodyAssignment_2()); | 12503 | // InternalSolverLanguageParser.g:3966:2: ( rule__Case__BodyAssignment_2 ) |
13570 | } | 12504 | // InternalSolverLanguageParser.g:3966:3: rule__Case__BodyAssignment_2 |
13571 | // InternalSolverLanguage.g:3914:2: ( rule__Case__BodyAssignment_2 ) | ||
13572 | // InternalSolverLanguage.g:3914:3: rule__Case__BodyAssignment_2 | ||
13573 | { | 12505 | { |
13574 | pushFollow(FOLLOW_2); | 12506 | pushFollow(FOLLOW_2); |
13575 | rule__Case__BodyAssignment_2(); | 12507 | rule__Case__BodyAssignment_2(); |
13576 | 12508 | ||
13577 | state._fsp--; | 12509 | state._fsp--; |
13578 | if (state.failed) return ; | ||
13579 | 12510 | ||
13580 | } | ||
13581 | 12511 | ||
13582 | if ( state.backtracking==0 ) { | ||
13583 | after(grammarAccess.getCaseAccess().getBodyAssignment_2()); | ||
13584 | } | 12512 | } |
13585 | 12513 | ||
12514 | after(grammarAccess.getCaseAccess().getBodyAssignment_2()); | ||
12515 | |||
13586 | } | 12516 | } |
13587 | 12517 | ||
13588 | 12518 | ||
@@ -13604,25 +12534,25 @@ public class InternalSolverLanguageParser extends AbstractInternalContentAssistP | |||
13604 | 12534 | ||
13605 | 12535 | ||
13606 | // $ANTLR start "rule__ConjunctiveExpression__Group__0" | 12536 | // $ANTLR start "rule__ConjunctiveExpression__Group__0" |
13607 | // InternalSolverLanguage.g:3923:1: rule__ConjunctiveExpression__Group__0 : rule__ConjunctiveExpression__Group__0__Impl rule__ConjunctiveExpression__Group__1 ; | 12537 | // InternalSolverLanguageParser.g:3975:1: rule__ConjunctiveExpression__Group__0 : rule__ConjunctiveExpression__Group__0__Impl rule__ConjunctiveExpression__Group__1 ; |
13608 | public final void rule__ConjunctiveExpression__Group__0() throws RecognitionException { | 12538 | public final void rule__ConjunctiveExpression__Group__0() throws RecognitionException { |
13609 | 12539 | ||
13610 | int stackSize = keepStackSize(); | 12540 | int stackSize = keepStackSize(); |
13611 | 12541 | ||
13612 | try { | 12542 | try { |
13613 | // InternalSolverLanguage.g:3927:1: ( rule__ConjunctiveExpression__Group__0__Impl rule__ConjunctiveExpression__Group__1 ) | 12543 | // InternalSolverLanguageParser.g:3979:1: ( rule__ConjunctiveExpression__Group__0__Impl rule__ConjunctiveExpression__Group__1 ) |
13614 | // InternalSolverLanguage.g:3928:2: rule__ConjunctiveExpression__Group__0__Impl rule__ConjunctiveExpression__Group__1 | 12544 | // InternalSolverLanguageParser.g:3980:2: rule__ConjunctiveExpression__Group__0__Impl rule__ConjunctiveExpression__Group__1 |
13615 | { | 12545 | { |
13616 | pushFollow(FOLLOW_22); | 12546 | pushFollow(FOLLOW_21); |
13617 | rule__ConjunctiveExpression__Group__0__Impl(); | 12547 | rule__ConjunctiveExpression__Group__0__Impl(); |
13618 | 12548 | ||
13619 | state._fsp--; | 12549 | state._fsp--; |
13620 | if (state.failed) return ; | 12550 | |
13621 | pushFollow(FOLLOW_2); | 12551 | pushFollow(FOLLOW_2); |
13622 | rule__ConjunctiveExpression__Group__1(); | 12552 | rule__ConjunctiveExpression__Group__1(); |
13623 | 12553 | ||
13624 | state._fsp--; | 12554 | state._fsp--; |
13625 | if (state.failed) return ; | 12555 | |
13626 | 12556 | ||
13627 | } | 12557 | } |
13628 | 12558 | ||
@@ -13642,29 +12572,25 @@ public class InternalSolverLanguageParser extends AbstractInternalContentAssistP | |||
13642 | 12572 | ||
13643 | 12573 | ||
13644 | // $ANTLR start "rule__ConjunctiveExpression__Group__0__Impl" | 12574 | // $ANTLR start "rule__ConjunctiveExpression__Group__0__Impl" |
13645 | // InternalSolverLanguage.g:3935:1: rule__ConjunctiveExpression__Group__0__Impl : ( ruleComparisonExpression ) ; | 12575 | // InternalSolverLanguageParser.g:3987:1: rule__ConjunctiveExpression__Group__0__Impl : ( ruleComparisonExpression ) ; |
13646 | public final void rule__ConjunctiveExpression__Group__0__Impl() throws RecognitionException { | 12576 | public final void rule__ConjunctiveExpression__Group__0__Impl() throws RecognitionException { |
13647 | 12577 | ||
13648 | int stackSize = keepStackSize(); | 12578 | int stackSize = keepStackSize(); |
13649 | 12579 | ||
13650 | try { | 12580 | try { |
13651 | // InternalSolverLanguage.g:3939:1: ( ( ruleComparisonExpression ) ) | 12581 | // InternalSolverLanguageParser.g:3991:1: ( ( ruleComparisonExpression ) ) |
13652 | // InternalSolverLanguage.g:3940:1: ( ruleComparisonExpression ) | 12582 | // InternalSolverLanguageParser.g:3992:1: ( ruleComparisonExpression ) |
13653 | { | 12583 | { |
13654 | // InternalSolverLanguage.g:3940:1: ( ruleComparisonExpression ) | 12584 | // InternalSolverLanguageParser.g:3992:1: ( ruleComparisonExpression ) |
13655 | // InternalSolverLanguage.g:3941:2: ruleComparisonExpression | 12585 | // InternalSolverLanguageParser.g:3993:2: ruleComparisonExpression |
13656 | { | 12586 | { |
13657 | if ( state.backtracking==0 ) { | 12587 | before(grammarAccess.getConjunctiveExpressionAccess().getComparisonExpressionParserRuleCall_0()); |
13658 | before(grammarAccess.getConjunctiveExpressionAccess().getComparisonExpressionParserRuleCall_0()); | ||
13659 | } | ||
13660 | pushFollow(FOLLOW_2); | 12588 | pushFollow(FOLLOW_2); |
13661 | ruleComparisonExpression(); | 12589 | ruleComparisonExpression(); |
13662 | 12590 | ||
13663 | state._fsp--; | 12591 | state._fsp--; |
13664 | if (state.failed) return ; | 12592 | |
13665 | if ( state.backtracking==0 ) { | 12593 | after(grammarAccess.getConjunctiveExpressionAccess().getComparisonExpressionParserRuleCall_0()); |
13666 | after(grammarAccess.getConjunctiveExpressionAccess().getComparisonExpressionParserRuleCall_0()); | ||
13667 | } | ||
13668 | 12594 | ||
13669 | } | 12595 | } |
13670 | 12596 | ||
@@ -13687,20 +12613,20 @@ public class InternalSolverLanguageParser extends AbstractInternalContentAssistP | |||
13687 | 12613 | ||
13688 | 12614 | ||
13689 | // $ANTLR start "rule__ConjunctiveExpression__Group__1" | 12615 | // $ANTLR start "rule__ConjunctiveExpression__Group__1" |
13690 | // InternalSolverLanguage.g:3950:1: rule__ConjunctiveExpression__Group__1 : rule__ConjunctiveExpression__Group__1__Impl ; | 12616 | // InternalSolverLanguageParser.g:4002:1: rule__ConjunctiveExpression__Group__1 : rule__ConjunctiveExpression__Group__1__Impl ; |
13691 | public final void rule__ConjunctiveExpression__Group__1() throws RecognitionException { | 12617 | public final void rule__ConjunctiveExpression__Group__1() throws RecognitionException { |
13692 | 12618 | ||
13693 | int stackSize = keepStackSize(); | 12619 | int stackSize = keepStackSize(); |
13694 | 12620 | ||
13695 | try { | 12621 | try { |
13696 | // InternalSolverLanguage.g:3954:1: ( rule__ConjunctiveExpression__Group__1__Impl ) | 12622 | // InternalSolverLanguageParser.g:4006:1: ( rule__ConjunctiveExpression__Group__1__Impl ) |
13697 | // InternalSolverLanguage.g:3955:2: rule__ConjunctiveExpression__Group__1__Impl | 12623 | // InternalSolverLanguageParser.g:4007:2: rule__ConjunctiveExpression__Group__1__Impl |
13698 | { | 12624 | { |
13699 | pushFollow(FOLLOW_2); | 12625 | pushFollow(FOLLOW_2); |
13700 | rule__ConjunctiveExpression__Group__1__Impl(); | 12626 | rule__ConjunctiveExpression__Group__1__Impl(); |
13701 | 12627 | ||
13702 | state._fsp--; | 12628 | state._fsp--; |
13703 | if (state.failed) return ; | 12629 | |
13704 | 12630 | ||
13705 | } | 12631 | } |
13706 | 12632 | ||
@@ -13720,46 +12646,42 @@ public class InternalSolverLanguageParser extends AbstractInternalContentAssistP | |||
13720 | 12646 | ||
13721 | 12647 | ||
13722 | // $ANTLR start "rule__ConjunctiveExpression__Group__1__Impl" | 12648 | // $ANTLR start "rule__ConjunctiveExpression__Group__1__Impl" |
13723 | // InternalSolverLanguage.g:3961:1: rule__ConjunctiveExpression__Group__1__Impl : ( ( rule__ConjunctiveExpression__Group_1__0 )? ) ; | 12649 | // InternalSolverLanguageParser.g:4013:1: rule__ConjunctiveExpression__Group__1__Impl : ( ( rule__ConjunctiveExpression__Group_1__0 )? ) ; |
13724 | public final void rule__ConjunctiveExpression__Group__1__Impl() throws RecognitionException { | 12650 | public final void rule__ConjunctiveExpression__Group__1__Impl() throws RecognitionException { |
13725 | 12651 | ||
13726 | int stackSize = keepStackSize(); | 12652 | int stackSize = keepStackSize(); |
13727 | 12653 | ||
13728 | try { | 12654 | try { |
13729 | // InternalSolverLanguage.g:3965:1: ( ( ( rule__ConjunctiveExpression__Group_1__0 )? ) ) | 12655 | // InternalSolverLanguageParser.g:4017:1: ( ( ( rule__ConjunctiveExpression__Group_1__0 )? ) ) |
13730 | // InternalSolverLanguage.g:3966:1: ( ( rule__ConjunctiveExpression__Group_1__0 )? ) | 12656 | // InternalSolverLanguageParser.g:4018:1: ( ( rule__ConjunctiveExpression__Group_1__0 )? ) |
13731 | { | 12657 | { |
13732 | // InternalSolverLanguage.g:3966:1: ( ( rule__ConjunctiveExpression__Group_1__0 )? ) | 12658 | // InternalSolverLanguageParser.g:4018:1: ( ( rule__ConjunctiveExpression__Group_1__0 )? ) |
13733 | // InternalSolverLanguage.g:3967:2: ( rule__ConjunctiveExpression__Group_1__0 )? | 12659 | // InternalSolverLanguageParser.g:4019:2: ( rule__ConjunctiveExpression__Group_1__0 )? |
13734 | { | 12660 | { |
13735 | if ( state.backtracking==0 ) { | 12661 | before(grammarAccess.getConjunctiveExpressionAccess().getGroup_1()); |
13736 | before(grammarAccess.getConjunctiveExpressionAccess().getGroup_1()); | 12662 | // InternalSolverLanguageParser.g:4020:2: ( rule__ConjunctiveExpression__Group_1__0 )? |
13737 | } | ||
13738 | // InternalSolverLanguage.g:3968:2: ( rule__ConjunctiveExpression__Group_1__0 )? | ||
13739 | int alt33=2; | 12663 | int alt33=2; |
13740 | int LA33_0 = input.LA(1); | 12664 | int LA33_0 = input.LA(1); |
13741 | 12665 | ||
13742 | if ( (LA33_0==56) ) { | 12666 | if ( (LA33_0==Comma) ) { |
13743 | alt33=1; | 12667 | alt33=1; |
13744 | } | 12668 | } |
13745 | switch (alt33) { | 12669 | switch (alt33) { |
13746 | case 1 : | 12670 | case 1 : |
13747 | // InternalSolverLanguage.g:3968:3: rule__ConjunctiveExpression__Group_1__0 | 12671 | // InternalSolverLanguageParser.g:4020:3: rule__ConjunctiveExpression__Group_1__0 |
13748 | { | 12672 | { |
13749 | pushFollow(FOLLOW_2); | 12673 | pushFollow(FOLLOW_2); |
13750 | rule__ConjunctiveExpression__Group_1__0(); | 12674 | rule__ConjunctiveExpression__Group_1__0(); |
13751 | 12675 | ||
13752 | state._fsp--; | 12676 | state._fsp--; |
13753 | if (state.failed) return ; | 12677 | |
13754 | 12678 | ||
13755 | } | 12679 | } |
13756 | break; | 12680 | break; |
13757 | 12681 | ||
13758 | } | 12682 | } |
13759 | 12683 | ||
13760 | if ( state.backtracking==0 ) { | 12684 | after(grammarAccess.getConjunctiveExpressionAccess().getGroup_1()); |
13761 | after(grammarAccess.getConjunctiveExpressionAccess().getGroup_1()); | ||
13762 | } | ||
13763 | 12685 | ||
13764 | } | 12686 | } |
13765 | 12687 | ||
@@ -13782,25 +12704,25 @@ public class InternalSolverLanguageParser extends AbstractInternalContentAssistP | |||
13782 | 12704 | ||
13783 | 12705 | ||
13784 | // $ANTLR start "rule__ConjunctiveExpression__Group_1__0" | 12706 | // $ANTLR start "rule__ConjunctiveExpression__Group_1__0" |
13785 | // InternalSolverLanguage.g:3977:1: rule__ConjunctiveExpression__Group_1__0 : rule__ConjunctiveExpression__Group_1__0__Impl rule__ConjunctiveExpression__Group_1__1 ; | 12707 | // InternalSolverLanguageParser.g:4029:1: rule__ConjunctiveExpression__Group_1__0 : rule__ConjunctiveExpression__Group_1__0__Impl rule__ConjunctiveExpression__Group_1__1 ; |
13786 | public final void rule__ConjunctiveExpression__Group_1__0() throws RecognitionException { | 12708 | public final void rule__ConjunctiveExpression__Group_1__0() throws RecognitionException { |
13787 | 12709 | ||
13788 | int stackSize = keepStackSize(); | 12710 | int stackSize = keepStackSize(); |
13789 | 12711 | ||
13790 | try { | 12712 | try { |
13791 | // InternalSolverLanguage.g:3981:1: ( rule__ConjunctiveExpression__Group_1__0__Impl rule__ConjunctiveExpression__Group_1__1 ) | 12713 | // InternalSolverLanguageParser.g:4033:1: ( rule__ConjunctiveExpression__Group_1__0__Impl rule__ConjunctiveExpression__Group_1__1 ) |
13792 | // InternalSolverLanguage.g:3982:2: rule__ConjunctiveExpression__Group_1__0__Impl rule__ConjunctiveExpression__Group_1__1 | 12714 | // InternalSolverLanguageParser.g:4034:2: rule__ConjunctiveExpression__Group_1__0__Impl rule__ConjunctiveExpression__Group_1__1 |
13793 | { | 12715 | { |
13794 | pushFollow(FOLLOW_22); | 12716 | pushFollow(FOLLOW_21); |
13795 | rule__ConjunctiveExpression__Group_1__0__Impl(); | 12717 | rule__ConjunctiveExpression__Group_1__0__Impl(); |
13796 | 12718 | ||
13797 | state._fsp--; | 12719 | state._fsp--; |
13798 | if (state.failed) return ; | 12720 | |
13799 | pushFollow(FOLLOW_2); | 12721 | pushFollow(FOLLOW_2); |
13800 | rule__ConjunctiveExpression__Group_1__1(); | 12722 | rule__ConjunctiveExpression__Group_1__1(); |
13801 | 12723 | ||
13802 | state._fsp--; | 12724 | state._fsp--; |
13803 | if (state.failed) return ; | 12725 | |
13804 | 12726 | ||
13805 | } | 12727 | } |
13806 | 12728 | ||
@@ -13820,29 +12742,25 @@ public class InternalSolverLanguageParser extends AbstractInternalContentAssistP | |||
13820 | 12742 | ||
13821 | 12743 | ||
13822 | // $ANTLR start "rule__ConjunctiveExpression__Group_1__0__Impl" | 12744 | // $ANTLR start "rule__ConjunctiveExpression__Group_1__0__Impl" |
13823 | // InternalSolverLanguage.g:3989:1: rule__ConjunctiveExpression__Group_1__0__Impl : ( () ) ; | 12745 | // InternalSolverLanguageParser.g:4041:1: rule__ConjunctiveExpression__Group_1__0__Impl : ( () ) ; |
13824 | public final void rule__ConjunctiveExpression__Group_1__0__Impl() throws RecognitionException { | 12746 | public final void rule__ConjunctiveExpression__Group_1__0__Impl() throws RecognitionException { |
13825 | 12747 | ||
13826 | int stackSize = keepStackSize(); | 12748 | int stackSize = keepStackSize(); |
13827 | 12749 | ||
13828 | try { | 12750 | try { |
13829 | // InternalSolverLanguage.g:3993:1: ( ( () ) ) | 12751 | // InternalSolverLanguageParser.g:4045:1: ( ( () ) ) |
13830 | // InternalSolverLanguage.g:3994:1: ( () ) | 12752 | // InternalSolverLanguageParser.g:4046:1: ( () ) |
13831 | { | 12753 | { |
13832 | // InternalSolverLanguage.g:3994:1: ( () ) | 12754 | // InternalSolverLanguageParser.g:4046:1: ( () ) |
13833 | // InternalSolverLanguage.g:3995:2: () | 12755 | // InternalSolverLanguageParser.g:4047:2: () |
13834 | { | 12756 | { |
13835 | if ( state.backtracking==0 ) { | 12757 | before(grammarAccess.getConjunctiveExpressionAccess().getConjunctionChildrenAction_1_0()); |
13836 | before(grammarAccess.getConjunctiveExpressionAccess().getConjunctionChildrenAction_1_0()); | 12758 | // InternalSolverLanguageParser.g:4048:2: () |
13837 | } | 12759 | // InternalSolverLanguageParser.g:4048:3: |
13838 | // InternalSolverLanguage.g:3996:2: () | ||
13839 | // InternalSolverLanguage.g:3996:3: | ||
13840 | { | 12760 | { |
13841 | } | 12761 | } |
13842 | 12762 | ||
13843 | if ( state.backtracking==0 ) { | 12763 | after(grammarAccess.getConjunctiveExpressionAccess().getConjunctionChildrenAction_1_0()); |
13844 | after(grammarAccess.getConjunctiveExpressionAccess().getConjunctionChildrenAction_1_0()); | ||
13845 | } | ||
13846 | 12764 | ||
13847 | } | 12765 | } |
13848 | 12766 | ||
@@ -13861,20 +12779,20 @@ public class InternalSolverLanguageParser extends AbstractInternalContentAssistP | |||
13861 | 12779 | ||
13862 | 12780 | ||
13863 | // $ANTLR start "rule__ConjunctiveExpression__Group_1__1" | 12781 | // $ANTLR start "rule__ConjunctiveExpression__Group_1__1" |
13864 | // InternalSolverLanguage.g:4004:1: rule__ConjunctiveExpression__Group_1__1 : rule__ConjunctiveExpression__Group_1__1__Impl ; | 12782 | // InternalSolverLanguageParser.g:4056:1: rule__ConjunctiveExpression__Group_1__1 : rule__ConjunctiveExpression__Group_1__1__Impl ; |
13865 | public final void rule__ConjunctiveExpression__Group_1__1() throws RecognitionException { | 12783 | public final void rule__ConjunctiveExpression__Group_1__1() throws RecognitionException { |
13866 | 12784 | ||
13867 | int stackSize = keepStackSize(); | 12785 | int stackSize = keepStackSize(); |
13868 | 12786 | ||
13869 | try { | 12787 | try { |
13870 | // InternalSolverLanguage.g:4008:1: ( rule__ConjunctiveExpression__Group_1__1__Impl ) | 12788 | // InternalSolverLanguageParser.g:4060:1: ( rule__ConjunctiveExpression__Group_1__1__Impl ) |
13871 | // InternalSolverLanguage.g:4009:2: rule__ConjunctiveExpression__Group_1__1__Impl | 12789 | // InternalSolverLanguageParser.g:4061:2: rule__ConjunctiveExpression__Group_1__1__Impl |
13872 | { | 12790 | { |
13873 | pushFollow(FOLLOW_2); | 12791 | pushFollow(FOLLOW_2); |
13874 | rule__ConjunctiveExpression__Group_1__1__Impl(); | 12792 | rule__ConjunctiveExpression__Group_1__1__Impl(); |
13875 | 12793 | ||
13876 | state._fsp--; | 12794 | state._fsp--; |
13877 | if (state.failed) return ; | 12795 | |
13878 | 12796 | ||
13879 | } | 12797 | } |
13880 | 12798 | ||
@@ -13894,67 +12812,61 @@ public class InternalSolverLanguageParser extends AbstractInternalContentAssistP | |||
13894 | 12812 | ||
13895 | 12813 | ||
13896 | // $ANTLR start "rule__ConjunctiveExpression__Group_1__1__Impl" | 12814 | // $ANTLR start "rule__ConjunctiveExpression__Group_1__1__Impl" |
13897 | // InternalSolverLanguage.g:4015:1: rule__ConjunctiveExpression__Group_1__1__Impl : ( ( ( rule__ConjunctiveExpression__Group_1_1__0 ) ) ( ( rule__ConjunctiveExpression__Group_1_1__0 )* ) ) ; | 12815 | // InternalSolverLanguageParser.g:4067:1: rule__ConjunctiveExpression__Group_1__1__Impl : ( ( ( rule__ConjunctiveExpression__Group_1_1__0 ) ) ( ( rule__ConjunctiveExpression__Group_1_1__0 )* ) ) ; |
13898 | public final void rule__ConjunctiveExpression__Group_1__1__Impl() throws RecognitionException { | 12816 | public final void rule__ConjunctiveExpression__Group_1__1__Impl() throws RecognitionException { |
13899 | 12817 | ||
13900 | int stackSize = keepStackSize(); | 12818 | int stackSize = keepStackSize(); |
13901 | 12819 | ||
13902 | try { | 12820 | try { |
13903 | // InternalSolverLanguage.g:4019:1: ( ( ( ( rule__ConjunctiveExpression__Group_1_1__0 ) ) ( ( rule__ConjunctiveExpression__Group_1_1__0 )* ) ) ) | 12821 | // InternalSolverLanguageParser.g:4071:1: ( ( ( ( rule__ConjunctiveExpression__Group_1_1__0 ) ) ( ( rule__ConjunctiveExpression__Group_1_1__0 )* ) ) ) |
13904 | // InternalSolverLanguage.g:4020:1: ( ( ( rule__ConjunctiveExpression__Group_1_1__0 ) ) ( ( rule__ConjunctiveExpression__Group_1_1__0 )* ) ) | 12822 | // InternalSolverLanguageParser.g:4072:1: ( ( ( rule__ConjunctiveExpression__Group_1_1__0 ) ) ( ( rule__ConjunctiveExpression__Group_1_1__0 )* ) ) |
13905 | { | 12823 | { |
13906 | // InternalSolverLanguage.g:4020:1: ( ( ( rule__ConjunctiveExpression__Group_1_1__0 ) ) ( ( rule__ConjunctiveExpression__Group_1_1__0 )* ) ) | 12824 | // InternalSolverLanguageParser.g:4072:1: ( ( ( rule__ConjunctiveExpression__Group_1_1__0 ) ) ( ( rule__ConjunctiveExpression__Group_1_1__0 )* ) ) |
13907 | // InternalSolverLanguage.g:4021:2: ( ( rule__ConjunctiveExpression__Group_1_1__0 ) ) ( ( rule__ConjunctiveExpression__Group_1_1__0 )* ) | 12825 | // InternalSolverLanguageParser.g:4073:2: ( ( rule__ConjunctiveExpression__Group_1_1__0 ) ) ( ( rule__ConjunctiveExpression__Group_1_1__0 )* ) |
13908 | { | 12826 | { |
13909 | // InternalSolverLanguage.g:4021:2: ( ( rule__ConjunctiveExpression__Group_1_1__0 ) ) | 12827 | // InternalSolverLanguageParser.g:4073:2: ( ( rule__ConjunctiveExpression__Group_1_1__0 ) ) |
13910 | // InternalSolverLanguage.g:4022:3: ( rule__ConjunctiveExpression__Group_1_1__0 ) | 12828 | // InternalSolverLanguageParser.g:4074:3: ( rule__ConjunctiveExpression__Group_1_1__0 ) |
13911 | { | 12829 | { |
13912 | if ( state.backtracking==0 ) { | 12830 | before(grammarAccess.getConjunctiveExpressionAccess().getGroup_1_1()); |
13913 | before(grammarAccess.getConjunctiveExpressionAccess().getGroup_1_1()); | 12831 | // InternalSolverLanguageParser.g:4075:3: ( rule__ConjunctiveExpression__Group_1_1__0 ) |
13914 | } | 12832 | // InternalSolverLanguageParser.g:4075:4: rule__ConjunctiveExpression__Group_1_1__0 |
13915 | // InternalSolverLanguage.g:4023:3: ( rule__ConjunctiveExpression__Group_1_1__0 ) | ||
13916 | // InternalSolverLanguage.g:4023:4: rule__ConjunctiveExpression__Group_1_1__0 | ||
13917 | { | 12833 | { |
13918 | pushFollow(FOLLOW_23); | 12834 | pushFollow(FOLLOW_22); |
13919 | rule__ConjunctiveExpression__Group_1_1__0(); | 12835 | rule__ConjunctiveExpression__Group_1_1__0(); |
13920 | 12836 | ||
13921 | state._fsp--; | 12837 | state._fsp--; |
13922 | if (state.failed) return ; | ||
13923 | 12838 | ||
13924 | } | ||
13925 | 12839 | ||
13926 | if ( state.backtracking==0 ) { | ||
13927 | after(grammarAccess.getConjunctiveExpressionAccess().getGroup_1_1()); | ||
13928 | } | 12840 | } |
13929 | 12841 | ||
12842 | after(grammarAccess.getConjunctiveExpressionAccess().getGroup_1_1()); | ||
12843 | |||
13930 | } | 12844 | } |
13931 | 12845 | ||
13932 | // InternalSolverLanguage.g:4026:2: ( ( rule__ConjunctiveExpression__Group_1_1__0 )* ) | 12846 | // InternalSolverLanguageParser.g:4078:2: ( ( rule__ConjunctiveExpression__Group_1_1__0 )* ) |
13933 | // InternalSolverLanguage.g:4027:3: ( rule__ConjunctiveExpression__Group_1_1__0 )* | 12847 | // InternalSolverLanguageParser.g:4079:3: ( rule__ConjunctiveExpression__Group_1_1__0 )* |
13934 | { | 12848 | { |
13935 | if ( state.backtracking==0 ) { | 12849 | before(grammarAccess.getConjunctiveExpressionAccess().getGroup_1_1()); |
13936 | before(grammarAccess.getConjunctiveExpressionAccess().getGroup_1_1()); | 12850 | // InternalSolverLanguageParser.g:4080:3: ( rule__ConjunctiveExpression__Group_1_1__0 )* |
13937 | } | ||
13938 | // InternalSolverLanguage.g:4028:3: ( rule__ConjunctiveExpression__Group_1_1__0 )* | ||
13939 | loop34: | 12851 | loop34: |
13940 | do { | 12852 | do { |
13941 | int alt34=2; | 12853 | int alt34=2; |
13942 | int LA34_0 = input.LA(1); | 12854 | int LA34_0 = input.LA(1); |
13943 | 12855 | ||
13944 | if ( (LA34_0==56) ) { | 12856 | if ( (LA34_0==Comma) ) { |
13945 | alt34=1; | 12857 | alt34=1; |
13946 | } | 12858 | } |
13947 | 12859 | ||
13948 | 12860 | ||
13949 | switch (alt34) { | 12861 | switch (alt34) { |
13950 | case 1 : | 12862 | case 1 : |
13951 | // InternalSolverLanguage.g:4028:4: rule__ConjunctiveExpression__Group_1_1__0 | 12863 | // InternalSolverLanguageParser.g:4080:4: rule__ConjunctiveExpression__Group_1_1__0 |
13952 | { | 12864 | { |
13953 | pushFollow(FOLLOW_23); | 12865 | pushFollow(FOLLOW_22); |
13954 | rule__ConjunctiveExpression__Group_1_1__0(); | 12866 | rule__ConjunctiveExpression__Group_1_1__0(); |
13955 | 12867 | ||
13956 | state._fsp--; | 12868 | state._fsp--; |
13957 | if (state.failed) return ; | 12869 | |
13958 | 12870 | ||
13959 | } | 12871 | } |
13960 | break; | 12872 | break; |
@@ -13964,9 +12876,7 @@ public class InternalSolverLanguageParser extends AbstractInternalContentAssistP | |||
13964 | } | 12876 | } |
13965 | } while (true); | 12877 | } while (true); |
13966 | 12878 | ||
13967 | if ( state.backtracking==0 ) { | 12879 | after(grammarAccess.getConjunctiveExpressionAccess().getGroup_1_1()); |
13968 | after(grammarAccess.getConjunctiveExpressionAccess().getGroup_1_1()); | ||
13969 | } | ||
13970 | 12880 | ||
13971 | } | 12881 | } |
13972 | 12882 | ||
@@ -13992,25 +12902,25 @@ public class InternalSolverLanguageParser extends AbstractInternalContentAssistP | |||
13992 | 12902 | ||
13993 | 12903 | ||
13994 | // $ANTLR start "rule__ConjunctiveExpression__Group_1_1__0" | 12904 | // $ANTLR start "rule__ConjunctiveExpression__Group_1_1__0" |
13995 | // InternalSolverLanguage.g:4038:1: rule__ConjunctiveExpression__Group_1_1__0 : rule__ConjunctiveExpression__Group_1_1__0__Impl rule__ConjunctiveExpression__Group_1_1__1 ; | 12905 | // InternalSolverLanguageParser.g:4090:1: rule__ConjunctiveExpression__Group_1_1__0 : rule__ConjunctiveExpression__Group_1_1__0__Impl rule__ConjunctiveExpression__Group_1_1__1 ; |
13996 | public final void rule__ConjunctiveExpression__Group_1_1__0() throws RecognitionException { | 12906 | public final void rule__ConjunctiveExpression__Group_1_1__0() throws RecognitionException { |
13997 | 12907 | ||
13998 | int stackSize = keepStackSize(); | 12908 | int stackSize = keepStackSize(); |
13999 | 12909 | ||
14000 | try { | 12910 | try { |
14001 | // InternalSolverLanguage.g:4042:1: ( rule__ConjunctiveExpression__Group_1_1__0__Impl rule__ConjunctiveExpression__Group_1_1__1 ) | 12911 | // InternalSolverLanguageParser.g:4094:1: ( rule__ConjunctiveExpression__Group_1_1__0__Impl rule__ConjunctiveExpression__Group_1_1__1 ) |
14002 | // InternalSolverLanguage.g:4043:2: rule__ConjunctiveExpression__Group_1_1__0__Impl rule__ConjunctiveExpression__Group_1_1__1 | 12912 | // InternalSolverLanguageParser.g:4095:2: rule__ConjunctiveExpression__Group_1_1__0__Impl rule__ConjunctiveExpression__Group_1_1__1 |
14003 | { | 12913 | { |
14004 | pushFollow(FOLLOW_7); | 12914 | pushFollow(FOLLOW_7); |
14005 | rule__ConjunctiveExpression__Group_1_1__0__Impl(); | 12915 | rule__ConjunctiveExpression__Group_1_1__0__Impl(); |
14006 | 12916 | ||
14007 | state._fsp--; | 12917 | state._fsp--; |
14008 | if (state.failed) return ; | 12918 | |
14009 | pushFollow(FOLLOW_2); | 12919 | pushFollow(FOLLOW_2); |
14010 | rule__ConjunctiveExpression__Group_1_1__1(); | 12920 | rule__ConjunctiveExpression__Group_1_1__1(); |
14011 | 12921 | ||
14012 | state._fsp--; | 12922 | state._fsp--; |
14013 | if (state.failed) return ; | 12923 | |
14014 | 12924 | ||
14015 | } | 12925 | } |
14016 | 12926 | ||
@@ -14030,25 +12940,21 @@ public class InternalSolverLanguageParser extends AbstractInternalContentAssistP | |||
14030 | 12940 | ||
14031 | 12941 | ||
14032 | // $ANTLR start "rule__ConjunctiveExpression__Group_1_1__0__Impl" | 12942 | // $ANTLR start "rule__ConjunctiveExpression__Group_1_1__0__Impl" |
14033 | // InternalSolverLanguage.g:4050:1: rule__ConjunctiveExpression__Group_1_1__0__Impl : ( ',' ) ; | 12943 | // InternalSolverLanguageParser.g:4102:1: rule__ConjunctiveExpression__Group_1_1__0__Impl : ( Comma ) ; |
14034 | public final void rule__ConjunctiveExpression__Group_1_1__0__Impl() throws RecognitionException { | 12944 | public final void rule__ConjunctiveExpression__Group_1_1__0__Impl() throws RecognitionException { |
14035 | 12945 | ||
14036 | int stackSize = keepStackSize(); | 12946 | int stackSize = keepStackSize(); |
14037 | 12947 | ||
14038 | try { | 12948 | try { |
14039 | // InternalSolverLanguage.g:4054:1: ( ( ',' ) ) | 12949 | // InternalSolverLanguageParser.g:4106:1: ( ( Comma ) ) |
14040 | // InternalSolverLanguage.g:4055:1: ( ',' ) | 12950 | // InternalSolverLanguageParser.g:4107:1: ( Comma ) |
14041 | { | 12951 | { |
14042 | // InternalSolverLanguage.g:4055:1: ( ',' ) | 12952 | // InternalSolverLanguageParser.g:4107:1: ( Comma ) |
14043 | // InternalSolverLanguage.g:4056:2: ',' | 12953 | // InternalSolverLanguageParser.g:4108:2: Comma |
14044 | { | 12954 | { |
14045 | if ( state.backtracking==0 ) { | 12955 | before(grammarAccess.getConjunctiveExpressionAccess().getCommaKeyword_1_1_0()); |
14046 | before(grammarAccess.getConjunctiveExpressionAccess().getCommaKeyword_1_1_0()); | 12956 | match(input,Comma,FOLLOW_2); |
14047 | } | 12957 | after(grammarAccess.getConjunctiveExpressionAccess().getCommaKeyword_1_1_0()); |
14048 | match(input,56,FOLLOW_2); if (state.failed) return ; | ||
14049 | if ( state.backtracking==0 ) { | ||
14050 | after(grammarAccess.getConjunctiveExpressionAccess().getCommaKeyword_1_1_0()); | ||
14051 | } | ||
14052 | 12958 | ||
14053 | } | 12959 | } |
14054 | 12960 | ||
@@ -14071,20 +12977,20 @@ public class InternalSolverLanguageParser extends AbstractInternalContentAssistP | |||
14071 | 12977 | ||
14072 | 12978 | ||
14073 | // $ANTLR start "rule__ConjunctiveExpression__Group_1_1__1" | 12979 | // $ANTLR start "rule__ConjunctiveExpression__Group_1_1__1" |
14074 | // InternalSolverLanguage.g:4065:1: rule__ConjunctiveExpression__Group_1_1__1 : rule__ConjunctiveExpression__Group_1_1__1__Impl ; | 12980 | // InternalSolverLanguageParser.g:4117:1: rule__ConjunctiveExpression__Group_1_1__1 : rule__ConjunctiveExpression__Group_1_1__1__Impl ; |
14075 | public final void rule__ConjunctiveExpression__Group_1_1__1() throws RecognitionException { | 12981 | public final void rule__ConjunctiveExpression__Group_1_1__1() throws RecognitionException { |
14076 | 12982 | ||
14077 | int stackSize = keepStackSize(); | 12983 | int stackSize = keepStackSize(); |
14078 | 12984 | ||
14079 | try { | 12985 | try { |
14080 | // InternalSolverLanguage.g:4069:1: ( rule__ConjunctiveExpression__Group_1_1__1__Impl ) | 12986 | // InternalSolverLanguageParser.g:4121:1: ( rule__ConjunctiveExpression__Group_1_1__1__Impl ) |
14081 | // InternalSolverLanguage.g:4070:2: rule__ConjunctiveExpression__Group_1_1__1__Impl | 12987 | // InternalSolverLanguageParser.g:4122:2: rule__ConjunctiveExpression__Group_1_1__1__Impl |
14082 | { | 12988 | { |
14083 | pushFollow(FOLLOW_2); | 12989 | pushFollow(FOLLOW_2); |
14084 | rule__ConjunctiveExpression__Group_1_1__1__Impl(); | 12990 | rule__ConjunctiveExpression__Group_1_1__1__Impl(); |
14085 | 12991 | ||
14086 | state._fsp--; | 12992 | state._fsp--; |
14087 | if (state.failed) return ; | 12993 | |
14088 | 12994 | ||
14089 | } | 12995 | } |
14090 | 12996 | ||
@@ -14104,36 +13010,32 @@ public class InternalSolverLanguageParser extends AbstractInternalContentAssistP | |||
14104 | 13010 | ||
14105 | 13011 | ||
14106 | // $ANTLR start "rule__ConjunctiveExpression__Group_1_1__1__Impl" | 13012 | // $ANTLR start "rule__ConjunctiveExpression__Group_1_1__1__Impl" |
14107 | // InternalSolverLanguage.g:4076:1: rule__ConjunctiveExpression__Group_1_1__1__Impl : ( ( rule__ConjunctiveExpression__ChildrenAssignment_1_1_1 ) ) ; | 13013 | // InternalSolverLanguageParser.g:4128:1: rule__ConjunctiveExpression__Group_1_1__1__Impl : ( ( rule__ConjunctiveExpression__ChildrenAssignment_1_1_1 ) ) ; |
14108 | public final void rule__ConjunctiveExpression__Group_1_1__1__Impl() throws RecognitionException { | 13014 | public final void rule__ConjunctiveExpression__Group_1_1__1__Impl() throws RecognitionException { |
14109 | 13015 | ||
14110 | int stackSize = keepStackSize(); | 13016 | int stackSize = keepStackSize(); |
14111 | 13017 | ||
14112 | try { | 13018 | try { |
14113 | // InternalSolverLanguage.g:4080:1: ( ( ( rule__ConjunctiveExpression__ChildrenAssignment_1_1_1 ) ) ) | 13019 | // InternalSolverLanguageParser.g:4132:1: ( ( ( rule__ConjunctiveExpression__ChildrenAssignment_1_1_1 ) ) ) |
14114 | // InternalSolverLanguage.g:4081:1: ( ( rule__ConjunctiveExpression__ChildrenAssignment_1_1_1 ) ) | 13020 | // InternalSolverLanguageParser.g:4133:1: ( ( rule__ConjunctiveExpression__ChildrenAssignment_1_1_1 ) ) |
14115 | { | 13021 | { |
14116 | // InternalSolverLanguage.g:4081:1: ( ( rule__ConjunctiveExpression__ChildrenAssignment_1_1_1 ) ) | 13022 | // InternalSolverLanguageParser.g:4133:1: ( ( rule__ConjunctiveExpression__ChildrenAssignment_1_1_1 ) ) |
14117 | // InternalSolverLanguage.g:4082:2: ( rule__ConjunctiveExpression__ChildrenAssignment_1_1_1 ) | 13023 | // InternalSolverLanguageParser.g:4134:2: ( rule__ConjunctiveExpression__ChildrenAssignment_1_1_1 ) |
14118 | { | 13024 | { |
14119 | if ( state.backtracking==0 ) { | 13025 | before(grammarAccess.getConjunctiveExpressionAccess().getChildrenAssignment_1_1_1()); |
14120 | before(grammarAccess.getConjunctiveExpressionAccess().getChildrenAssignment_1_1_1()); | 13026 | // InternalSolverLanguageParser.g:4135:2: ( rule__ConjunctiveExpression__ChildrenAssignment_1_1_1 ) |
14121 | } | 13027 | // InternalSolverLanguageParser.g:4135:3: rule__ConjunctiveExpression__ChildrenAssignment_1_1_1 |
14122 | // InternalSolverLanguage.g:4083:2: ( rule__ConjunctiveExpression__ChildrenAssignment_1_1_1 ) | ||
14123 | // InternalSolverLanguage.g:4083:3: rule__ConjunctiveExpression__ChildrenAssignment_1_1_1 | ||
14124 | { | 13028 | { |
14125 | pushFollow(FOLLOW_2); | 13029 | pushFollow(FOLLOW_2); |
14126 | rule__ConjunctiveExpression__ChildrenAssignment_1_1_1(); | 13030 | rule__ConjunctiveExpression__ChildrenAssignment_1_1_1(); |
14127 | 13031 | ||
14128 | state._fsp--; | 13032 | state._fsp--; |
14129 | if (state.failed) return ; | ||
14130 | 13033 | ||
14131 | } | ||
14132 | 13034 | ||
14133 | if ( state.backtracking==0 ) { | ||
14134 | after(grammarAccess.getConjunctiveExpressionAccess().getChildrenAssignment_1_1_1()); | ||
14135 | } | 13035 | } |
14136 | 13036 | ||
13037 | after(grammarAccess.getConjunctiveExpressionAccess().getChildrenAssignment_1_1_1()); | ||
13038 | |||
14137 | } | 13039 | } |
14138 | 13040 | ||
14139 | 13041 | ||
@@ -14155,25 +13057,25 @@ public class InternalSolverLanguageParser extends AbstractInternalContentAssistP | |||
14155 | 13057 | ||
14156 | 13058 | ||
14157 | // $ANTLR start "rule__ComparisonExpression__Group__0" | 13059 | // $ANTLR start "rule__ComparisonExpression__Group__0" |
14158 | // InternalSolverLanguage.g:4092:1: rule__ComparisonExpression__Group__0 : rule__ComparisonExpression__Group__0__Impl rule__ComparisonExpression__Group__1 ; | 13060 | // InternalSolverLanguageParser.g:4144:1: rule__ComparisonExpression__Group__0 : rule__ComparisonExpression__Group__0__Impl rule__ComparisonExpression__Group__1 ; |
14159 | public final void rule__ComparisonExpression__Group__0() throws RecognitionException { | 13061 | public final void rule__ComparisonExpression__Group__0() throws RecognitionException { |
14160 | 13062 | ||
14161 | int stackSize = keepStackSize(); | 13063 | int stackSize = keepStackSize(); |
14162 | 13064 | ||
14163 | try { | 13065 | try { |
14164 | // InternalSolverLanguage.g:4096:1: ( rule__ComparisonExpression__Group__0__Impl rule__ComparisonExpression__Group__1 ) | 13066 | // InternalSolverLanguageParser.g:4148:1: ( rule__ComparisonExpression__Group__0__Impl rule__ComparisonExpression__Group__1 ) |
14165 | // InternalSolverLanguage.g:4097:2: rule__ComparisonExpression__Group__0__Impl rule__ComparisonExpression__Group__1 | 13067 | // InternalSolverLanguageParser.g:4149:2: rule__ComparisonExpression__Group__0__Impl rule__ComparisonExpression__Group__1 |
14166 | { | 13068 | { |
14167 | pushFollow(FOLLOW_24); | 13069 | pushFollow(FOLLOW_23); |
14168 | rule__ComparisonExpression__Group__0__Impl(); | 13070 | rule__ComparisonExpression__Group__0__Impl(); |
14169 | 13071 | ||
14170 | state._fsp--; | 13072 | state._fsp--; |
14171 | if (state.failed) return ; | 13073 | |
14172 | pushFollow(FOLLOW_2); | 13074 | pushFollow(FOLLOW_2); |
14173 | rule__ComparisonExpression__Group__1(); | 13075 | rule__ComparisonExpression__Group__1(); |
14174 | 13076 | ||
14175 | state._fsp--; | 13077 | state._fsp--; |
14176 | if (state.failed) return ; | 13078 | |
14177 | 13079 | ||
14178 | } | 13080 | } |
14179 | 13081 | ||
@@ -14193,29 +13095,25 @@ public class InternalSolverLanguageParser extends AbstractInternalContentAssistP | |||
14193 | 13095 | ||
14194 | 13096 | ||
14195 | // $ANTLR start "rule__ComparisonExpression__Group__0__Impl" | 13097 | // $ANTLR start "rule__ComparisonExpression__Group__0__Impl" |
14196 | // InternalSolverLanguage.g:4104:1: rule__ComparisonExpression__Group__0__Impl : ( ruleAdditiveExpression ) ; | 13098 | // InternalSolverLanguageParser.g:4156:1: rule__ComparisonExpression__Group__0__Impl : ( ruleAdditiveExpression ) ; |
14197 | public final void rule__ComparisonExpression__Group__0__Impl() throws RecognitionException { | 13099 | public final void rule__ComparisonExpression__Group__0__Impl() throws RecognitionException { |
14198 | 13100 | ||
14199 | int stackSize = keepStackSize(); | 13101 | int stackSize = keepStackSize(); |
14200 | 13102 | ||
14201 | try { | 13103 | try { |
14202 | // InternalSolverLanguage.g:4108:1: ( ( ruleAdditiveExpression ) ) | 13104 | // InternalSolverLanguageParser.g:4160:1: ( ( ruleAdditiveExpression ) ) |
14203 | // InternalSolverLanguage.g:4109:1: ( ruleAdditiveExpression ) | 13105 | // InternalSolverLanguageParser.g:4161:1: ( ruleAdditiveExpression ) |
14204 | { | 13106 | { |
14205 | // InternalSolverLanguage.g:4109:1: ( ruleAdditiveExpression ) | 13107 | // InternalSolverLanguageParser.g:4161:1: ( ruleAdditiveExpression ) |
14206 | // InternalSolverLanguage.g:4110:2: ruleAdditiveExpression | 13108 | // InternalSolverLanguageParser.g:4162:2: ruleAdditiveExpression |
14207 | { | 13109 | { |
14208 | if ( state.backtracking==0 ) { | 13110 | before(grammarAccess.getComparisonExpressionAccess().getAdditiveExpressionParserRuleCall_0()); |
14209 | before(grammarAccess.getComparisonExpressionAccess().getAdditiveExpressionParserRuleCall_0()); | ||
14210 | } | ||
14211 | pushFollow(FOLLOW_2); | 13111 | pushFollow(FOLLOW_2); |
14212 | ruleAdditiveExpression(); | 13112 | ruleAdditiveExpression(); |
14213 | 13113 | ||
14214 | state._fsp--; | 13114 | state._fsp--; |
14215 | if (state.failed) return ; | 13115 | |
14216 | if ( state.backtracking==0 ) { | 13116 | after(grammarAccess.getComparisonExpressionAccess().getAdditiveExpressionParserRuleCall_0()); |
14217 | after(grammarAccess.getComparisonExpressionAccess().getAdditiveExpressionParserRuleCall_0()); | ||
14218 | } | ||
14219 | 13117 | ||
14220 | } | 13118 | } |
14221 | 13119 | ||
@@ -14238,20 +13136,20 @@ public class InternalSolverLanguageParser extends AbstractInternalContentAssistP | |||
14238 | 13136 | ||
14239 | 13137 | ||
14240 | // $ANTLR start "rule__ComparisonExpression__Group__1" | 13138 | // $ANTLR start "rule__ComparisonExpression__Group__1" |
14241 | // InternalSolverLanguage.g:4119:1: rule__ComparisonExpression__Group__1 : rule__ComparisonExpression__Group__1__Impl ; | 13139 | // InternalSolverLanguageParser.g:4171:1: rule__ComparisonExpression__Group__1 : rule__ComparisonExpression__Group__1__Impl ; |
14242 | public final void rule__ComparisonExpression__Group__1() throws RecognitionException { | 13140 | public final void rule__ComparisonExpression__Group__1() throws RecognitionException { |
14243 | 13141 | ||
14244 | int stackSize = keepStackSize(); | 13142 | int stackSize = keepStackSize(); |
14245 | 13143 | ||
14246 | try { | 13144 | try { |
14247 | // InternalSolverLanguage.g:4123:1: ( rule__ComparisonExpression__Group__1__Impl ) | 13145 | // InternalSolverLanguageParser.g:4175:1: ( rule__ComparisonExpression__Group__1__Impl ) |
14248 | // InternalSolverLanguage.g:4124:2: rule__ComparisonExpression__Group__1__Impl | 13146 | // InternalSolverLanguageParser.g:4176:2: rule__ComparisonExpression__Group__1__Impl |
14249 | { | 13147 | { |
14250 | pushFollow(FOLLOW_2); | 13148 | pushFollow(FOLLOW_2); |
14251 | rule__ComparisonExpression__Group__1__Impl(); | 13149 | rule__ComparisonExpression__Group__1__Impl(); |
14252 | 13150 | ||
14253 | state._fsp--; | 13151 | state._fsp--; |
14254 | if (state.failed) return ; | 13152 | |
14255 | 13153 | ||
14256 | } | 13154 | } |
14257 | 13155 | ||
@@ -14271,46 +13169,42 @@ public class InternalSolverLanguageParser extends AbstractInternalContentAssistP | |||
14271 | 13169 | ||
14272 | 13170 | ||
14273 | // $ANTLR start "rule__ComparisonExpression__Group__1__Impl" | 13171 | // $ANTLR start "rule__ComparisonExpression__Group__1__Impl" |
14274 | // InternalSolverLanguage.g:4130:1: rule__ComparisonExpression__Group__1__Impl : ( ( rule__ComparisonExpression__Group_1__0 )? ) ; | 13172 | // InternalSolverLanguageParser.g:4182:1: rule__ComparisonExpression__Group__1__Impl : ( ( rule__ComparisonExpression__Group_1__0 )? ) ; |
14275 | public final void rule__ComparisonExpression__Group__1__Impl() throws RecognitionException { | 13173 | public final void rule__ComparisonExpression__Group__1__Impl() throws RecognitionException { |
14276 | 13174 | ||
14277 | int stackSize = keepStackSize(); | 13175 | int stackSize = keepStackSize(); |
14278 | 13176 | ||
14279 | try { | 13177 | try { |
14280 | // InternalSolverLanguage.g:4134:1: ( ( ( rule__ComparisonExpression__Group_1__0 )? ) ) | 13178 | // InternalSolverLanguageParser.g:4186:1: ( ( ( rule__ComparisonExpression__Group_1__0 )? ) ) |
14281 | // InternalSolverLanguage.g:4135:1: ( ( rule__ComparisonExpression__Group_1__0 )? ) | 13179 | // InternalSolverLanguageParser.g:4187:1: ( ( rule__ComparisonExpression__Group_1__0 )? ) |
14282 | { | 13180 | { |
14283 | // InternalSolverLanguage.g:4135:1: ( ( rule__ComparisonExpression__Group_1__0 )? ) | 13181 | // InternalSolverLanguageParser.g:4187:1: ( ( rule__ComparisonExpression__Group_1__0 )? ) |
14284 | // InternalSolverLanguage.g:4136:2: ( rule__ComparisonExpression__Group_1__0 )? | 13182 | // InternalSolverLanguageParser.g:4188:2: ( rule__ComparisonExpression__Group_1__0 )? |
14285 | { | 13183 | { |
14286 | if ( state.backtracking==0 ) { | 13184 | before(grammarAccess.getComparisonExpressionAccess().getGroup_1()); |
14287 | before(grammarAccess.getComparisonExpressionAccess().getGroup_1()); | 13185 | // InternalSolverLanguageParser.g:4189:2: ( rule__ComparisonExpression__Group_1__0 )? |
14288 | } | ||
14289 | // InternalSolverLanguage.g:4137:2: ( rule__ComparisonExpression__Group_1__0 )? | ||
14290 | int alt35=2; | 13186 | int alt35=2; |
14291 | int LA35_0 = input.LA(1); | 13187 | int LA35_0 = input.LA(1); |
14292 | 13188 | ||
14293 | if ( ((LA35_0>=19 && LA35_0<=25)) ) { | 13189 | if ( (LA35_0==ExclamationMarkEqualsSign||(LA35_0>=LessThanSignEqualsSign && LA35_0<=GreaterThanSignEqualsSign)||LA35_0==In||LA35_0==LessThanSign||LA35_0==GreaterThanSign) ) { |
14294 | alt35=1; | 13190 | alt35=1; |
14295 | } | 13191 | } |
14296 | switch (alt35) { | 13192 | switch (alt35) { |
14297 | case 1 : | 13193 | case 1 : |
14298 | // InternalSolverLanguage.g:4137:3: rule__ComparisonExpression__Group_1__0 | 13194 | // InternalSolverLanguageParser.g:4189:3: rule__ComparisonExpression__Group_1__0 |
14299 | { | 13195 | { |
14300 | pushFollow(FOLLOW_2); | 13196 | pushFollow(FOLLOW_2); |
14301 | rule__ComparisonExpression__Group_1__0(); | 13197 | rule__ComparisonExpression__Group_1__0(); |
14302 | 13198 | ||
14303 | state._fsp--; | 13199 | state._fsp--; |
14304 | if (state.failed) return ; | 13200 | |
14305 | 13201 | ||
14306 | } | 13202 | } |
14307 | break; | 13203 | break; |
14308 | 13204 | ||
14309 | } | 13205 | } |
14310 | 13206 | ||
14311 | if ( state.backtracking==0 ) { | 13207 | after(grammarAccess.getComparisonExpressionAccess().getGroup_1()); |
14312 | after(grammarAccess.getComparisonExpressionAccess().getGroup_1()); | ||
14313 | } | ||
14314 | 13208 | ||
14315 | } | 13209 | } |
14316 | 13210 | ||
@@ -14333,25 +13227,25 @@ public class InternalSolverLanguageParser extends AbstractInternalContentAssistP | |||
14333 | 13227 | ||
14334 | 13228 | ||
14335 | // $ANTLR start "rule__ComparisonExpression__Group_1__0" | 13229 | // $ANTLR start "rule__ComparisonExpression__Group_1__0" |
14336 | // InternalSolverLanguage.g:4146:1: rule__ComparisonExpression__Group_1__0 : rule__ComparisonExpression__Group_1__0__Impl rule__ComparisonExpression__Group_1__1 ; | 13230 | // InternalSolverLanguageParser.g:4198:1: rule__ComparisonExpression__Group_1__0 : rule__ComparisonExpression__Group_1__0__Impl rule__ComparisonExpression__Group_1__1 ; |
14337 | public final void rule__ComparisonExpression__Group_1__0() throws RecognitionException { | 13231 | public final void rule__ComparisonExpression__Group_1__0() throws RecognitionException { |
14338 | 13232 | ||
14339 | int stackSize = keepStackSize(); | 13233 | int stackSize = keepStackSize(); |
14340 | 13234 | ||
14341 | try { | 13235 | try { |
14342 | // InternalSolverLanguage.g:4150:1: ( rule__ComparisonExpression__Group_1__0__Impl rule__ComparisonExpression__Group_1__1 ) | 13236 | // InternalSolverLanguageParser.g:4202:1: ( rule__ComparisonExpression__Group_1__0__Impl rule__ComparisonExpression__Group_1__1 ) |
14343 | // InternalSolverLanguage.g:4151:2: rule__ComparisonExpression__Group_1__0__Impl rule__ComparisonExpression__Group_1__1 | 13237 | // InternalSolverLanguageParser.g:4203:2: rule__ComparisonExpression__Group_1__0__Impl rule__ComparisonExpression__Group_1__1 |
14344 | { | 13238 | { |
14345 | pushFollow(FOLLOW_24); | 13239 | pushFollow(FOLLOW_23); |
14346 | rule__ComparisonExpression__Group_1__0__Impl(); | 13240 | rule__ComparisonExpression__Group_1__0__Impl(); |
14347 | 13241 | ||
14348 | state._fsp--; | 13242 | state._fsp--; |
14349 | if (state.failed) return ; | 13243 | |
14350 | pushFollow(FOLLOW_2); | 13244 | pushFollow(FOLLOW_2); |
14351 | rule__ComparisonExpression__Group_1__1(); | 13245 | rule__ComparisonExpression__Group_1__1(); |
14352 | 13246 | ||
14353 | state._fsp--; | 13247 | state._fsp--; |
14354 | if (state.failed) return ; | 13248 | |
14355 | 13249 | ||
14356 | } | 13250 | } |
14357 | 13251 | ||
@@ -14371,29 +13265,25 @@ public class InternalSolverLanguageParser extends AbstractInternalContentAssistP | |||
14371 | 13265 | ||
14372 | 13266 | ||
14373 | // $ANTLR start "rule__ComparisonExpression__Group_1__0__Impl" | 13267 | // $ANTLR start "rule__ComparisonExpression__Group_1__0__Impl" |
14374 | // InternalSolverLanguage.g:4158:1: rule__ComparisonExpression__Group_1__0__Impl : ( () ) ; | 13268 | // InternalSolverLanguageParser.g:4210:1: rule__ComparisonExpression__Group_1__0__Impl : ( () ) ; |
14375 | public final void rule__ComparisonExpression__Group_1__0__Impl() throws RecognitionException { | 13269 | public final void rule__ComparisonExpression__Group_1__0__Impl() throws RecognitionException { |
14376 | 13270 | ||
14377 | int stackSize = keepStackSize(); | 13271 | int stackSize = keepStackSize(); |
14378 | 13272 | ||
14379 | try { | 13273 | try { |
14380 | // InternalSolverLanguage.g:4162:1: ( ( () ) ) | 13274 | // InternalSolverLanguageParser.g:4214:1: ( ( () ) ) |
14381 | // InternalSolverLanguage.g:4163:1: ( () ) | 13275 | // InternalSolverLanguageParser.g:4215:1: ( () ) |
14382 | { | 13276 | { |
14383 | // InternalSolverLanguage.g:4163:1: ( () ) | 13277 | // InternalSolverLanguageParser.g:4215:1: ( () ) |
14384 | // InternalSolverLanguage.g:4164:2: () | 13278 | // InternalSolverLanguageParser.g:4216:2: () |
14385 | { | 13279 | { |
14386 | if ( state.backtracking==0 ) { | 13280 | before(grammarAccess.getComparisonExpressionAccess().getComparisonLeftAction_1_0()); |
14387 | before(grammarAccess.getComparisonExpressionAccess().getComparisonLeftAction_1_0()); | 13281 | // InternalSolverLanguageParser.g:4217:2: () |
14388 | } | 13282 | // InternalSolverLanguageParser.g:4217:3: |
14389 | // InternalSolverLanguage.g:4165:2: () | ||
14390 | // InternalSolverLanguage.g:4165:3: | ||
14391 | { | 13283 | { |
14392 | } | 13284 | } |
14393 | 13285 | ||
14394 | if ( state.backtracking==0 ) { | 13286 | after(grammarAccess.getComparisonExpressionAccess().getComparisonLeftAction_1_0()); |
14395 | after(grammarAccess.getComparisonExpressionAccess().getComparisonLeftAction_1_0()); | ||
14396 | } | ||
14397 | 13287 | ||
14398 | } | 13288 | } |
14399 | 13289 | ||
@@ -14412,25 +13302,25 @@ public class InternalSolverLanguageParser extends AbstractInternalContentAssistP | |||
14412 | 13302 | ||
14413 | 13303 | ||
14414 | // $ANTLR start "rule__ComparisonExpression__Group_1__1" | 13304 | // $ANTLR start "rule__ComparisonExpression__Group_1__1" |
14415 | // InternalSolverLanguage.g:4173:1: rule__ComparisonExpression__Group_1__1 : rule__ComparisonExpression__Group_1__1__Impl rule__ComparisonExpression__Group_1__2 ; | 13305 | // InternalSolverLanguageParser.g:4225:1: rule__ComparisonExpression__Group_1__1 : rule__ComparisonExpression__Group_1__1__Impl rule__ComparisonExpression__Group_1__2 ; |
14416 | public final void rule__ComparisonExpression__Group_1__1() throws RecognitionException { | 13306 | public final void rule__ComparisonExpression__Group_1__1() throws RecognitionException { |
14417 | 13307 | ||
14418 | int stackSize = keepStackSize(); | 13308 | int stackSize = keepStackSize(); |
14419 | 13309 | ||
14420 | try { | 13310 | try { |
14421 | // InternalSolverLanguage.g:4177:1: ( rule__ComparisonExpression__Group_1__1__Impl rule__ComparisonExpression__Group_1__2 ) | 13311 | // InternalSolverLanguageParser.g:4229:1: ( rule__ComparisonExpression__Group_1__1__Impl rule__ComparisonExpression__Group_1__2 ) |
14422 | // InternalSolverLanguage.g:4178:2: rule__ComparisonExpression__Group_1__1__Impl rule__ComparisonExpression__Group_1__2 | 13312 | // InternalSolverLanguageParser.g:4230:2: rule__ComparisonExpression__Group_1__1__Impl rule__ComparisonExpression__Group_1__2 |
14423 | { | 13313 | { |
14424 | pushFollow(FOLLOW_7); | 13314 | pushFollow(FOLLOW_7); |
14425 | rule__ComparisonExpression__Group_1__1__Impl(); | 13315 | rule__ComparisonExpression__Group_1__1__Impl(); |
14426 | 13316 | ||
14427 | state._fsp--; | 13317 | state._fsp--; |
14428 | if (state.failed) return ; | 13318 | |
14429 | pushFollow(FOLLOW_2); | 13319 | pushFollow(FOLLOW_2); |
14430 | rule__ComparisonExpression__Group_1__2(); | 13320 | rule__ComparisonExpression__Group_1__2(); |
14431 | 13321 | ||
14432 | state._fsp--; | 13322 | state._fsp--; |
14433 | if (state.failed) return ; | 13323 | |
14434 | 13324 | ||
14435 | } | 13325 | } |
14436 | 13326 | ||
@@ -14450,36 +13340,32 @@ public class InternalSolverLanguageParser extends AbstractInternalContentAssistP | |||
14450 | 13340 | ||
14451 | 13341 | ||
14452 | // $ANTLR start "rule__ComparisonExpression__Group_1__1__Impl" | 13342 | // $ANTLR start "rule__ComparisonExpression__Group_1__1__Impl" |
14453 | // InternalSolverLanguage.g:4185:1: rule__ComparisonExpression__Group_1__1__Impl : ( ( rule__ComparisonExpression__OpAssignment_1_1 ) ) ; | 13343 | // InternalSolverLanguageParser.g:4237:1: rule__ComparisonExpression__Group_1__1__Impl : ( ( rule__ComparisonExpression__OpAssignment_1_1 ) ) ; |
14454 | public final void rule__ComparisonExpression__Group_1__1__Impl() throws RecognitionException { | 13344 | public final void rule__ComparisonExpression__Group_1__1__Impl() throws RecognitionException { |
14455 | 13345 | ||
14456 | int stackSize = keepStackSize(); | 13346 | int stackSize = keepStackSize(); |
14457 | 13347 | ||
14458 | try { | 13348 | try { |
14459 | // InternalSolverLanguage.g:4189:1: ( ( ( rule__ComparisonExpression__OpAssignment_1_1 ) ) ) | 13349 | // InternalSolverLanguageParser.g:4241:1: ( ( ( rule__ComparisonExpression__OpAssignment_1_1 ) ) ) |
14460 | // InternalSolverLanguage.g:4190:1: ( ( rule__ComparisonExpression__OpAssignment_1_1 ) ) | 13350 | // InternalSolverLanguageParser.g:4242:1: ( ( rule__ComparisonExpression__OpAssignment_1_1 ) ) |
14461 | { | 13351 | { |
14462 | // InternalSolverLanguage.g:4190:1: ( ( rule__ComparisonExpression__OpAssignment_1_1 ) ) | 13352 | // InternalSolverLanguageParser.g:4242:1: ( ( rule__ComparisonExpression__OpAssignment_1_1 ) ) |
14463 | // InternalSolverLanguage.g:4191:2: ( rule__ComparisonExpression__OpAssignment_1_1 ) | 13353 | // InternalSolverLanguageParser.g:4243:2: ( rule__ComparisonExpression__OpAssignment_1_1 ) |
14464 | { | 13354 | { |
14465 | if ( state.backtracking==0 ) { | 13355 | before(grammarAccess.getComparisonExpressionAccess().getOpAssignment_1_1()); |
14466 | before(grammarAccess.getComparisonExpressionAccess().getOpAssignment_1_1()); | 13356 | // InternalSolverLanguageParser.g:4244:2: ( rule__ComparisonExpression__OpAssignment_1_1 ) |
14467 | } | 13357 | // InternalSolverLanguageParser.g:4244:3: rule__ComparisonExpression__OpAssignment_1_1 |
14468 | // InternalSolverLanguage.g:4192:2: ( rule__ComparisonExpression__OpAssignment_1_1 ) | ||
14469 | // InternalSolverLanguage.g:4192:3: rule__ComparisonExpression__OpAssignment_1_1 | ||
14470 | { | 13358 | { |
14471 | pushFollow(FOLLOW_2); | 13359 | pushFollow(FOLLOW_2); |
14472 | rule__ComparisonExpression__OpAssignment_1_1(); | 13360 | rule__ComparisonExpression__OpAssignment_1_1(); |
14473 | 13361 | ||
14474 | state._fsp--; | 13362 | state._fsp--; |
14475 | if (state.failed) return ; | ||
14476 | 13363 | ||
14477 | } | ||
14478 | 13364 | ||
14479 | if ( state.backtracking==0 ) { | ||
14480 | after(grammarAccess.getComparisonExpressionAccess().getOpAssignment_1_1()); | ||
14481 | } | 13365 | } |
14482 | 13366 | ||
13367 | after(grammarAccess.getComparisonExpressionAccess().getOpAssignment_1_1()); | ||
13368 | |||
14483 | } | 13369 | } |
14484 | 13370 | ||
14485 | 13371 | ||
@@ -14501,20 +13387,20 @@ public class InternalSolverLanguageParser extends AbstractInternalContentAssistP | |||
14501 | 13387 | ||
14502 | 13388 | ||
14503 | // $ANTLR start "rule__ComparisonExpression__Group_1__2" | 13389 | // $ANTLR start "rule__ComparisonExpression__Group_1__2" |
14504 | // InternalSolverLanguage.g:4200:1: rule__ComparisonExpression__Group_1__2 : rule__ComparisonExpression__Group_1__2__Impl ; | 13390 | // InternalSolverLanguageParser.g:4252:1: rule__ComparisonExpression__Group_1__2 : rule__ComparisonExpression__Group_1__2__Impl ; |
14505 | public final void rule__ComparisonExpression__Group_1__2() throws RecognitionException { | 13391 | public final void rule__ComparisonExpression__Group_1__2() throws RecognitionException { |
14506 | 13392 | ||
14507 | int stackSize = keepStackSize(); | 13393 | int stackSize = keepStackSize(); |
14508 | 13394 | ||
14509 | try { | 13395 | try { |
14510 | // InternalSolverLanguage.g:4204:1: ( rule__ComparisonExpression__Group_1__2__Impl ) | 13396 | // InternalSolverLanguageParser.g:4256:1: ( rule__ComparisonExpression__Group_1__2__Impl ) |
14511 | // InternalSolverLanguage.g:4205:2: rule__ComparisonExpression__Group_1__2__Impl | 13397 | // InternalSolverLanguageParser.g:4257:2: rule__ComparisonExpression__Group_1__2__Impl |
14512 | { | 13398 | { |
14513 | pushFollow(FOLLOW_2); | 13399 | pushFollow(FOLLOW_2); |
14514 | rule__ComparisonExpression__Group_1__2__Impl(); | 13400 | rule__ComparisonExpression__Group_1__2__Impl(); |
14515 | 13401 | ||
14516 | state._fsp--; | 13402 | state._fsp--; |
14517 | if (state.failed) return ; | 13403 | |
14518 | 13404 | ||
14519 | } | 13405 | } |
14520 | 13406 | ||
@@ -14534,36 +13420,32 @@ public class InternalSolverLanguageParser extends AbstractInternalContentAssistP | |||
14534 | 13420 | ||
14535 | 13421 | ||
14536 | // $ANTLR start "rule__ComparisonExpression__Group_1__2__Impl" | 13422 | // $ANTLR start "rule__ComparisonExpression__Group_1__2__Impl" |
14537 | // InternalSolverLanguage.g:4211:1: rule__ComparisonExpression__Group_1__2__Impl : ( ( rule__ComparisonExpression__RightAssignment_1_2 ) ) ; | 13423 | // InternalSolverLanguageParser.g:4263:1: rule__ComparisonExpression__Group_1__2__Impl : ( ( rule__ComparisonExpression__RightAssignment_1_2 ) ) ; |
14538 | public final void rule__ComparisonExpression__Group_1__2__Impl() throws RecognitionException { | 13424 | public final void rule__ComparisonExpression__Group_1__2__Impl() throws RecognitionException { |
14539 | 13425 | ||
14540 | int stackSize = keepStackSize(); | 13426 | int stackSize = keepStackSize(); |
14541 | 13427 | ||
14542 | try { | 13428 | try { |
14543 | // InternalSolverLanguage.g:4215:1: ( ( ( rule__ComparisonExpression__RightAssignment_1_2 ) ) ) | 13429 | // InternalSolverLanguageParser.g:4267:1: ( ( ( rule__ComparisonExpression__RightAssignment_1_2 ) ) ) |
14544 | // InternalSolverLanguage.g:4216:1: ( ( rule__ComparisonExpression__RightAssignment_1_2 ) ) | 13430 | // InternalSolverLanguageParser.g:4268:1: ( ( rule__ComparisonExpression__RightAssignment_1_2 ) ) |
14545 | { | 13431 | { |
14546 | // InternalSolverLanguage.g:4216:1: ( ( rule__ComparisonExpression__RightAssignment_1_2 ) ) | 13432 | // InternalSolverLanguageParser.g:4268:1: ( ( rule__ComparisonExpression__RightAssignment_1_2 ) ) |
14547 | // InternalSolverLanguage.g:4217:2: ( rule__ComparisonExpression__RightAssignment_1_2 ) | 13433 | // InternalSolverLanguageParser.g:4269:2: ( rule__ComparisonExpression__RightAssignment_1_2 ) |
14548 | { | 13434 | { |
14549 | if ( state.backtracking==0 ) { | 13435 | before(grammarAccess.getComparisonExpressionAccess().getRightAssignment_1_2()); |
14550 | before(grammarAccess.getComparisonExpressionAccess().getRightAssignment_1_2()); | 13436 | // InternalSolverLanguageParser.g:4270:2: ( rule__ComparisonExpression__RightAssignment_1_2 ) |
14551 | } | 13437 | // InternalSolverLanguageParser.g:4270:3: rule__ComparisonExpression__RightAssignment_1_2 |
14552 | // InternalSolverLanguage.g:4218:2: ( rule__ComparisonExpression__RightAssignment_1_2 ) | ||
14553 | // InternalSolverLanguage.g:4218:3: rule__ComparisonExpression__RightAssignment_1_2 | ||
14554 | { | 13438 | { |
14555 | pushFollow(FOLLOW_2); | 13439 | pushFollow(FOLLOW_2); |
14556 | rule__ComparisonExpression__RightAssignment_1_2(); | 13440 | rule__ComparisonExpression__RightAssignment_1_2(); |
14557 | 13441 | ||
14558 | state._fsp--; | 13442 | state._fsp--; |
14559 | if (state.failed) return ; | ||
14560 | 13443 | ||
14561 | } | ||
14562 | 13444 | ||
14563 | if ( state.backtracking==0 ) { | ||
14564 | after(grammarAccess.getComparisonExpressionAccess().getRightAssignment_1_2()); | ||
14565 | } | 13445 | } |
14566 | 13446 | ||
13447 | after(grammarAccess.getComparisonExpressionAccess().getRightAssignment_1_2()); | ||
13448 | |||
14567 | } | 13449 | } |
14568 | 13450 | ||
14569 | 13451 | ||
@@ -14585,25 +13467,25 @@ public class InternalSolverLanguageParser extends AbstractInternalContentAssistP | |||
14585 | 13467 | ||
14586 | 13468 | ||
14587 | // $ANTLR start "rule__AdditiveExpression__Group__0" | 13469 | // $ANTLR start "rule__AdditiveExpression__Group__0" |
14588 | // InternalSolverLanguage.g:4227:1: rule__AdditiveExpression__Group__0 : rule__AdditiveExpression__Group__0__Impl rule__AdditiveExpression__Group__1 ; | 13470 | // InternalSolverLanguageParser.g:4279:1: rule__AdditiveExpression__Group__0 : rule__AdditiveExpression__Group__0__Impl rule__AdditiveExpression__Group__1 ; |
14589 | public final void rule__AdditiveExpression__Group__0() throws RecognitionException { | 13471 | public final void rule__AdditiveExpression__Group__0() throws RecognitionException { |
14590 | 13472 | ||
14591 | int stackSize = keepStackSize(); | 13473 | int stackSize = keepStackSize(); |
14592 | 13474 | ||
14593 | try { | 13475 | try { |
14594 | // InternalSolverLanguage.g:4231:1: ( rule__AdditiveExpression__Group__0__Impl rule__AdditiveExpression__Group__1 ) | 13476 | // InternalSolverLanguageParser.g:4283:1: ( rule__AdditiveExpression__Group__0__Impl rule__AdditiveExpression__Group__1 ) |
14595 | // InternalSolverLanguage.g:4232:2: rule__AdditiveExpression__Group__0__Impl rule__AdditiveExpression__Group__1 | 13477 | // InternalSolverLanguageParser.g:4284:2: rule__AdditiveExpression__Group__0__Impl rule__AdditiveExpression__Group__1 |
14596 | { | 13478 | { |
14597 | pushFollow(FOLLOW_25); | 13479 | pushFollow(FOLLOW_24); |
14598 | rule__AdditiveExpression__Group__0__Impl(); | 13480 | rule__AdditiveExpression__Group__0__Impl(); |
14599 | 13481 | ||
14600 | state._fsp--; | 13482 | state._fsp--; |
14601 | if (state.failed) return ; | 13483 | |
14602 | pushFollow(FOLLOW_2); | 13484 | pushFollow(FOLLOW_2); |
14603 | rule__AdditiveExpression__Group__1(); | 13485 | rule__AdditiveExpression__Group__1(); |
14604 | 13486 | ||
14605 | state._fsp--; | 13487 | state._fsp--; |
14606 | if (state.failed) return ; | 13488 | |
14607 | 13489 | ||
14608 | } | 13490 | } |
14609 | 13491 | ||
@@ -14623,29 +13505,25 @@ public class InternalSolverLanguageParser extends AbstractInternalContentAssistP | |||
14623 | 13505 | ||
14624 | 13506 | ||
14625 | // $ANTLR start "rule__AdditiveExpression__Group__0__Impl" | 13507 | // $ANTLR start "rule__AdditiveExpression__Group__0__Impl" |
14626 | // InternalSolverLanguage.g:4239:1: rule__AdditiveExpression__Group__0__Impl : ( ruleMultiplicativeExpression ) ; | 13508 | // InternalSolverLanguageParser.g:4291:1: rule__AdditiveExpression__Group__0__Impl : ( ruleMultiplicativeExpression ) ; |
14627 | public final void rule__AdditiveExpression__Group__0__Impl() throws RecognitionException { | 13509 | public final void rule__AdditiveExpression__Group__0__Impl() throws RecognitionException { |
14628 | 13510 | ||
14629 | int stackSize = keepStackSize(); | 13511 | int stackSize = keepStackSize(); |
14630 | 13512 | ||
14631 | try { | 13513 | try { |
14632 | // InternalSolverLanguage.g:4243:1: ( ( ruleMultiplicativeExpression ) ) | 13514 | // InternalSolverLanguageParser.g:4295:1: ( ( ruleMultiplicativeExpression ) ) |
14633 | // InternalSolverLanguage.g:4244:1: ( ruleMultiplicativeExpression ) | 13515 | // InternalSolverLanguageParser.g:4296:1: ( ruleMultiplicativeExpression ) |
14634 | { | 13516 | { |
14635 | // InternalSolverLanguage.g:4244:1: ( ruleMultiplicativeExpression ) | 13517 | // InternalSolverLanguageParser.g:4296:1: ( ruleMultiplicativeExpression ) |
14636 | // InternalSolverLanguage.g:4245:2: ruleMultiplicativeExpression | 13518 | // InternalSolverLanguageParser.g:4297:2: ruleMultiplicativeExpression |
14637 | { | 13519 | { |
14638 | if ( state.backtracking==0 ) { | 13520 | before(grammarAccess.getAdditiveExpressionAccess().getMultiplicativeExpressionParserRuleCall_0()); |
14639 | before(grammarAccess.getAdditiveExpressionAccess().getMultiplicativeExpressionParserRuleCall_0()); | ||
14640 | } | ||
14641 | pushFollow(FOLLOW_2); | 13521 | pushFollow(FOLLOW_2); |
14642 | ruleMultiplicativeExpression(); | 13522 | ruleMultiplicativeExpression(); |
14643 | 13523 | ||
14644 | state._fsp--; | 13524 | state._fsp--; |
14645 | if (state.failed) return ; | 13525 | |
14646 | if ( state.backtracking==0 ) { | 13526 | after(grammarAccess.getAdditiveExpressionAccess().getMultiplicativeExpressionParserRuleCall_0()); |
14647 | after(grammarAccess.getAdditiveExpressionAccess().getMultiplicativeExpressionParserRuleCall_0()); | ||
14648 | } | ||
14649 | 13527 | ||
14650 | } | 13528 | } |
14651 | 13529 | ||
@@ -14668,20 +13546,20 @@ public class InternalSolverLanguageParser extends AbstractInternalContentAssistP | |||
14668 | 13546 | ||
14669 | 13547 | ||
14670 | // $ANTLR start "rule__AdditiveExpression__Group__1" | 13548 | // $ANTLR start "rule__AdditiveExpression__Group__1" |
14671 | // InternalSolverLanguage.g:4254:1: rule__AdditiveExpression__Group__1 : rule__AdditiveExpression__Group__1__Impl ; | 13549 | // InternalSolverLanguageParser.g:4306:1: rule__AdditiveExpression__Group__1 : rule__AdditiveExpression__Group__1__Impl ; |
14672 | public final void rule__AdditiveExpression__Group__1() throws RecognitionException { | 13550 | public final void rule__AdditiveExpression__Group__1() throws RecognitionException { |
14673 | 13551 | ||
14674 | int stackSize = keepStackSize(); | 13552 | int stackSize = keepStackSize(); |
14675 | 13553 | ||
14676 | try { | 13554 | try { |
14677 | // InternalSolverLanguage.g:4258:1: ( rule__AdditiveExpression__Group__1__Impl ) | 13555 | // InternalSolverLanguageParser.g:4310:1: ( rule__AdditiveExpression__Group__1__Impl ) |
14678 | // InternalSolverLanguage.g:4259:2: rule__AdditiveExpression__Group__1__Impl | 13556 | // InternalSolverLanguageParser.g:4311:2: rule__AdditiveExpression__Group__1__Impl |
14679 | { | 13557 | { |
14680 | pushFollow(FOLLOW_2); | 13558 | pushFollow(FOLLOW_2); |
14681 | rule__AdditiveExpression__Group__1__Impl(); | 13559 | rule__AdditiveExpression__Group__1__Impl(); |
14682 | 13560 | ||
14683 | state._fsp--; | 13561 | state._fsp--; |
14684 | if (state.failed) return ; | 13562 | |
14685 | 13563 | ||
14686 | } | 13564 | } |
14687 | 13565 | ||
@@ -14701,41 +13579,39 @@ public class InternalSolverLanguageParser extends AbstractInternalContentAssistP | |||
14701 | 13579 | ||
14702 | 13580 | ||
14703 | // $ANTLR start "rule__AdditiveExpression__Group__1__Impl" | 13581 | // $ANTLR start "rule__AdditiveExpression__Group__1__Impl" |
14704 | // InternalSolverLanguage.g:4265:1: rule__AdditiveExpression__Group__1__Impl : ( ( rule__AdditiveExpression__Group_1__0 )* ) ; | 13582 | // InternalSolverLanguageParser.g:4317:1: rule__AdditiveExpression__Group__1__Impl : ( ( rule__AdditiveExpression__Group_1__0 )* ) ; |
14705 | public final void rule__AdditiveExpression__Group__1__Impl() throws RecognitionException { | 13583 | public final void rule__AdditiveExpression__Group__1__Impl() throws RecognitionException { |
14706 | 13584 | ||
14707 | int stackSize = keepStackSize(); | 13585 | int stackSize = keepStackSize(); |
14708 | 13586 | ||
14709 | try { | 13587 | try { |
14710 | // InternalSolverLanguage.g:4269:1: ( ( ( rule__AdditiveExpression__Group_1__0 )* ) ) | 13588 | // InternalSolverLanguageParser.g:4321:1: ( ( ( rule__AdditiveExpression__Group_1__0 )* ) ) |
14711 | // InternalSolverLanguage.g:4270:1: ( ( rule__AdditiveExpression__Group_1__0 )* ) | 13589 | // InternalSolverLanguageParser.g:4322:1: ( ( rule__AdditiveExpression__Group_1__0 )* ) |
14712 | { | 13590 | { |
14713 | // InternalSolverLanguage.g:4270:1: ( ( rule__AdditiveExpression__Group_1__0 )* ) | 13591 | // InternalSolverLanguageParser.g:4322:1: ( ( rule__AdditiveExpression__Group_1__0 )* ) |
14714 | // InternalSolverLanguage.g:4271:2: ( rule__AdditiveExpression__Group_1__0 )* | 13592 | // InternalSolverLanguageParser.g:4323:2: ( rule__AdditiveExpression__Group_1__0 )* |
14715 | { | 13593 | { |
14716 | if ( state.backtracking==0 ) { | 13594 | before(grammarAccess.getAdditiveExpressionAccess().getGroup_1()); |
14717 | before(grammarAccess.getAdditiveExpressionAccess().getGroup_1()); | 13595 | // InternalSolverLanguageParser.g:4324:2: ( rule__AdditiveExpression__Group_1__0 )* |
14718 | } | ||
14719 | // InternalSolverLanguage.g:4272:2: ( rule__AdditiveExpression__Group_1__0 )* | ||
14720 | loop36: | 13596 | loop36: |
14721 | do { | 13597 | do { |
14722 | int alt36=2; | 13598 | int alt36=2; |
14723 | int LA36_0 = input.LA(1); | 13599 | int LA36_0 = input.LA(1); |
14724 | 13600 | ||
14725 | if ( ((LA36_0>=26 && LA36_0<=27)) ) { | 13601 | if ( (LA36_0==PlusSign||LA36_0==HyphenMinus) ) { |
14726 | alt36=1; | 13602 | alt36=1; |
14727 | } | 13603 | } |
14728 | 13604 | ||
14729 | 13605 | ||
14730 | switch (alt36) { | 13606 | switch (alt36) { |
14731 | case 1 : | 13607 | case 1 : |
14732 | // InternalSolverLanguage.g:4272:3: rule__AdditiveExpression__Group_1__0 | 13608 | // InternalSolverLanguageParser.g:4324:3: rule__AdditiveExpression__Group_1__0 |
14733 | { | 13609 | { |
14734 | pushFollow(FOLLOW_26); | 13610 | pushFollow(FOLLOW_25); |
14735 | rule__AdditiveExpression__Group_1__0(); | 13611 | rule__AdditiveExpression__Group_1__0(); |
14736 | 13612 | ||
14737 | state._fsp--; | 13613 | state._fsp--; |
14738 | if (state.failed) return ; | 13614 | |
14739 | 13615 | ||
14740 | } | 13616 | } |
14741 | break; | 13617 | break; |
@@ -14745,9 +13621,7 @@ public class InternalSolverLanguageParser extends AbstractInternalContentAssistP | |||
14745 | } | 13621 | } |
14746 | } while (true); | 13622 | } while (true); |
14747 | 13623 | ||
14748 | if ( state.backtracking==0 ) { | 13624 | after(grammarAccess.getAdditiveExpressionAccess().getGroup_1()); |
14749 | after(grammarAccess.getAdditiveExpressionAccess().getGroup_1()); | ||
14750 | } | ||
14751 | 13625 | ||
14752 | } | 13626 | } |
14753 | 13627 | ||
@@ -14770,25 +13644,25 @@ public class InternalSolverLanguageParser extends AbstractInternalContentAssistP | |||
14770 | 13644 | ||
14771 | 13645 | ||
14772 | // $ANTLR start "rule__AdditiveExpression__Group_1__0" | 13646 | // $ANTLR start "rule__AdditiveExpression__Group_1__0" |
14773 | // InternalSolverLanguage.g:4281:1: rule__AdditiveExpression__Group_1__0 : rule__AdditiveExpression__Group_1__0__Impl rule__AdditiveExpression__Group_1__1 ; | 13647 | // InternalSolverLanguageParser.g:4333:1: rule__AdditiveExpression__Group_1__0 : rule__AdditiveExpression__Group_1__0__Impl rule__AdditiveExpression__Group_1__1 ; |
14774 | public final void rule__AdditiveExpression__Group_1__0() throws RecognitionException { | 13648 | public final void rule__AdditiveExpression__Group_1__0() throws RecognitionException { |
14775 | 13649 | ||
14776 | int stackSize = keepStackSize(); | 13650 | int stackSize = keepStackSize(); |
14777 | 13651 | ||
14778 | try { | 13652 | try { |
14779 | // InternalSolverLanguage.g:4285:1: ( rule__AdditiveExpression__Group_1__0__Impl rule__AdditiveExpression__Group_1__1 ) | 13653 | // InternalSolverLanguageParser.g:4337:1: ( rule__AdditiveExpression__Group_1__0__Impl rule__AdditiveExpression__Group_1__1 ) |
14780 | // InternalSolverLanguage.g:4286:2: rule__AdditiveExpression__Group_1__0__Impl rule__AdditiveExpression__Group_1__1 | 13654 | // InternalSolverLanguageParser.g:4338:2: rule__AdditiveExpression__Group_1__0__Impl rule__AdditiveExpression__Group_1__1 |
14781 | { | 13655 | { |
14782 | pushFollow(FOLLOW_25); | 13656 | pushFollow(FOLLOW_24); |
14783 | rule__AdditiveExpression__Group_1__0__Impl(); | 13657 | rule__AdditiveExpression__Group_1__0__Impl(); |
14784 | 13658 | ||
14785 | state._fsp--; | 13659 | state._fsp--; |
14786 | if (state.failed) return ; | 13660 | |
14787 | pushFollow(FOLLOW_2); | 13661 | pushFollow(FOLLOW_2); |
14788 | rule__AdditiveExpression__Group_1__1(); | 13662 | rule__AdditiveExpression__Group_1__1(); |
14789 | 13663 | ||
14790 | state._fsp--; | 13664 | state._fsp--; |
14791 | if (state.failed) return ; | 13665 | |
14792 | 13666 | ||
14793 | } | 13667 | } |
14794 | 13668 | ||
@@ -14808,29 +13682,25 @@ public class InternalSolverLanguageParser extends AbstractInternalContentAssistP | |||
14808 | 13682 | ||
14809 | 13683 | ||
14810 | // $ANTLR start "rule__AdditiveExpression__Group_1__0__Impl" | 13684 | // $ANTLR start "rule__AdditiveExpression__Group_1__0__Impl" |
14811 | // InternalSolverLanguage.g:4293:1: rule__AdditiveExpression__Group_1__0__Impl : ( () ) ; | 13685 | // InternalSolverLanguageParser.g:4345:1: rule__AdditiveExpression__Group_1__0__Impl : ( () ) ; |
14812 | public final void rule__AdditiveExpression__Group_1__0__Impl() throws RecognitionException { | 13686 | public final void rule__AdditiveExpression__Group_1__0__Impl() throws RecognitionException { |
14813 | 13687 | ||
14814 | int stackSize = keepStackSize(); | 13688 | int stackSize = keepStackSize(); |
14815 | 13689 | ||
14816 | try { | 13690 | try { |
14817 | // InternalSolverLanguage.g:4297:1: ( ( () ) ) | 13691 | // InternalSolverLanguageParser.g:4349:1: ( ( () ) ) |
14818 | // InternalSolverLanguage.g:4298:1: ( () ) | 13692 | // InternalSolverLanguageParser.g:4350:1: ( () ) |
14819 | { | 13693 | { |
14820 | // InternalSolverLanguage.g:4298:1: ( () ) | 13694 | // InternalSolverLanguageParser.g:4350:1: ( () ) |
14821 | // InternalSolverLanguage.g:4299:2: () | 13695 | // InternalSolverLanguageParser.g:4351:2: () |
14822 | { | 13696 | { |
14823 | if ( state.backtracking==0 ) { | 13697 | before(grammarAccess.getAdditiveExpressionAccess().getBinaryExpressionLeftAction_1_0()); |
14824 | before(grammarAccess.getAdditiveExpressionAccess().getBinaryExpressionLeftAction_1_0()); | 13698 | // InternalSolverLanguageParser.g:4352:2: () |
14825 | } | 13699 | // InternalSolverLanguageParser.g:4352:3: |
14826 | // InternalSolverLanguage.g:4300:2: () | ||
14827 | // InternalSolverLanguage.g:4300:3: | ||
14828 | { | 13700 | { |
14829 | } | 13701 | } |
14830 | 13702 | ||
14831 | if ( state.backtracking==0 ) { | 13703 | after(grammarAccess.getAdditiveExpressionAccess().getBinaryExpressionLeftAction_1_0()); |
14832 | after(grammarAccess.getAdditiveExpressionAccess().getBinaryExpressionLeftAction_1_0()); | ||
14833 | } | ||
14834 | 13704 | ||
14835 | } | 13705 | } |
14836 | 13706 | ||
@@ -14849,25 +13719,25 @@ public class InternalSolverLanguageParser extends AbstractInternalContentAssistP | |||
14849 | 13719 | ||
14850 | 13720 | ||
14851 | // $ANTLR start "rule__AdditiveExpression__Group_1__1" | 13721 | // $ANTLR start "rule__AdditiveExpression__Group_1__1" |
14852 | // InternalSolverLanguage.g:4308:1: rule__AdditiveExpression__Group_1__1 : rule__AdditiveExpression__Group_1__1__Impl rule__AdditiveExpression__Group_1__2 ; | 13722 | // InternalSolverLanguageParser.g:4360:1: rule__AdditiveExpression__Group_1__1 : rule__AdditiveExpression__Group_1__1__Impl rule__AdditiveExpression__Group_1__2 ; |
14853 | public final void rule__AdditiveExpression__Group_1__1() throws RecognitionException { | 13723 | public final void rule__AdditiveExpression__Group_1__1() throws RecognitionException { |
14854 | 13724 | ||
14855 | int stackSize = keepStackSize(); | 13725 | int stackSize = keepStackSize(); |
14856 | 13726 | ||
14857 | try { | 13727 | try { |
14858 | // InternalSolverLanguage.g:4312:1: ( rule__AdditiveExpression__Group_1__1__Impl rule__AdditiveExpression__Group_1__2 ) | 13728 | // InternalSolverLanguageParser.g:4364:1: ( rule__AdditiveExpression__Group_1__1__Impl rule__AdditiveExpression__Group_1__2 ) |
14859 | // InternalSolverLanguage.g:4313:2: rule__AdditiveExpression__Group_1__1__Impl rule__AdditiveExpression__Group_1__2 | 13729 | // InternalSolverLanguageParser.g:4365:2: rule__AdditiveExpression__Group_1__1__Impl rule__AdditiveExpression__Group_1__2 |
14860 | { | 13730 | { |
14861 | pushFollow(FOLLOW_7); | 13731 | pushFollow(FOLLOW_7); |
14862 | rule__AdditiveExpression__Group_1__1__Impl(); | 13732 | rule__AdditiveExpression__Group_1__1__Impl(); |
14863 | 13733 | ||
14864 | state._fsp--; | 13734 | state._fsp--; |
14865 | if (state.failed) return ; | 13735 | |
14866 | pushFollow(FOLLOW_2); | 13736 | pushFollow(FOLLOW_2); |
14867 | rule__AdditiveExpression__Group_1__2(); | 13737 | rule__AdditiveExpression__Group_1__2(); |
14868 | 13738 | ||
14869 | state._fsp--; | 13739 | state._fsp--; |
14870 | if (state.failed) return ; | 13740 | |
14871 | 13741 | ||
14872 | } | 13742 | } |
14873 | 13743 | ||
@@ -14887,36 +13757,32 @@ public class InternalSolverLanguageParser extends AbstractInternalContentAssistP | |||
14887 | 13757 | ||
14888 | 13758 | ||
14889 | // $ANTLR start "rule__AdditiveExpression__Group_1__1__Impl" | 13759 | // $ANTLR start "rule__AdditiveExpression__Group_1__1__Impl" |
14890 | // InternalSolverLanguage.g:4320:1: rule__AdditiveExpression__Group_1__1__Impl : ( ( rule__AdditiveExpression__OpAssignment_1_1 ) ) ; | 13760 | // InternalSolverLanguageParser.g:4372:1: rule__AdditiveExpression__Group_1__1__Impl : ( ( rule__AdditiveExpression__OpAssignment_1_1 ) ) ; |
14891 | public final void rule__AdditiveExpression__Group_1__1__Impl() throws RecognitionException { | 13761 | public final void rule__AdditiveExpression__Group_1__1__Impl() throws RecognitionException { |
14892 | 13762 | ||
14893 | int stackSize = keepStackSize(); | 13763 | int stackSize = keepStackSize(); |
14894 | 13764 | ||
14895 | try { | 13765 | try { |
14896 | // InternalSolverLanguage.g:4324:1: ( ( ( rule__AdditiveExpression__OpAssignment_1_1 ) ) ) | 13766 | // InternalSolverLanguageParser.g:4376:1: ( ( ( rule__AdditiveExpression__OpAssignment_1_1 ) ) ) |
14897 | // InternalSolverLanguage.g:4325:1: ( ( rule__AdditiveExpression__OpAssignment_1_1 ) ) | 13767 | // InternalSolverLanguageParser.g:4377:1: ( ( rule__AdditiveExpression__OpAssignment_1_1 ) ) |
14898 | { | 13768 | { |
14899 | // InternalSolverLanguage.g:4325:1: ( ( rule__AdditiveExpression__OpAssignment_1_1 ) ) | 13769 | // InternalSolverLanguageParser.g:4377:1: ( ( rule__AdditiveExpression__OpAssignment_1_1 ) ) |
14900 | // InternalSolverLanguage.g:4326:2: ( rule__AdditiveExpression__OpAssignment_1_1 ) | 13770 | // InternalSolverLanguageParser.g:4378:2: ( rule__AdditiveExpression__OpAssignment_1_1 ) |
14901 | { | 13771 | { |
14902 | if ( state.backtracking==0 ) { | 13772 | before(grammarAccess.getAdditiveExpressionAccess().getOpAssignment_1_1()); |
14903 | before(grammarAccess.getAdditiveExpressionAccess().getOpAssignment_1_1()); | 13773 | // InternalSolverLanguageParser.g:4379:2: ( rule__AdditiveExpression__OpAssignment_1_1 ) |
14904 | } | 13774 | // InternalSolverLanguageParser.g:4379:3: rule__AdditiveExpression__OpAssignment_1_1 |
14905 | // InternalSolverLanguage.g:4327:2: ( rule__AdditiveExpression__OpAssignment_1_1 ) | ||
14906 | // InternalSolverLanguage.g:4327:3: rule__AdditiveExpression__OpAssignment_1_1 | ||
14907 | { | 13775 | { |
14908 | pushFollow(FOLLOW_2); | 13776 | pushFollow(FOLLOW_2); |
14909 | rule__AdditiveExpression__OpAssignment_1_1(); | 13777 | rule__AdditiveExpression__OpAssignment_1_1(); |
14910 | 13778 | ||
14911 | state._fsp--; | 13779 | state._fsp--; |
14912 | if (state.failed) return ; | ||
14913 | 13780 | ||
14914 | } | ||
14915 | 13781 | ||
14916 | if ( state.backtracking==0 ) { | ||
14917 | after(grammarAccess.getAdditiveExpressionAccess().getOpAssignment_1_1()); | ||
14918 | } | 13782 | } |
14919 | 13783 | ||
13784 | after(grammarAccess.getAdditiveExpressionAccess().getOpAssignment_1_1()); | ||
13785 | |||
14920 | } | 13786 | } |
14921 | 13787 | ||
14922 | 13788 | ||
@@ -14938,20 +13804,20 @@ public class InternalSolverLanguageParser extends AbstractInternalContentAssistP | |||
14938 | 13804 | ||
14939 | 13805 | ||
14940 | // $ANTLR start "rule__AdditiveExpression__Group_1__2" | 13806 | // $ANTLR start "rule__AdditiveExpression__Group_1__2" |
14941 | // InternalSolverLanguage.g:4335:1: rule__AdditiveExpression__Group_1__2 : rule__AdditiveExpression__Group_1__2__Impl ; | 13807 | // InternalSolverLanguageParser.g:4387:1: rule__AdditiveExpression__Group_1__2 : rule__AdditiveExpression__Group_1__2__Impl ; |
14942 | public final void rule__AdditiveExpression__Group_1__2() throws RecognitionException { | 13808 | public final void rule__AdditiveExpression__Group_1__2() throws RecognitionException { |
14943 | 13809 | ||
14944 | int stackSize = keepStackSize(); | 13810 | int stackSize = keepStackSize(); |
14945 | 13811 | ||
14946 | try { | 13812 | try { |
14947 | // InternalSolverLanguage.g:4339:1: ( rule__AdditiveExpression__Group_1__2__Impl ) | 13813 | // InternalSolverLanguageParser.g:4391:1: ( rule__AdditiveExpression__Group_1__2__Impl ) |
14948 | // InternalSolverLanguage.g:4340:2: rule__AdditiveExpression__Group_1__2__Impl | 13814 | // InternalSolverLanguageParser.g:4392:2: rule__AdditiveExpression__Group_1__2__Impl |
14949 | { | 13815 | { |
14950 | pushFollow(FOLLOW_2); | 13816 | pushFollow(FOLLOW_2); |
14951 | rule__AdditiveExpression__Group_1__2__Impl(); | 13817 | rule__AdditiveExpression__Group_1__2__Impl(); |
14952 | 13818 | ||
14953 | state._fsp--; | 13819 | state._fsp--; |
14954 | if (state.failed) return ; | 13820 | |
14955 | 13821 | ||
14956 | } | 13822 | } |
14957 | 13823 | ||
@@ -14971,36 +13837,32 @@ public class InternalSolverLanguageParser extends AbstractInternalContentAssistP | |||
14971 | 13837 | ||
14972 | 13838 | ||
14973 | // $ANTLR start "rule__AdditiveExpression__Group_1__2__Impl" | 13839 | // $ANTLR start "rule__AdditiveExpression__Group_1__2__Impl" |
14974 | // InternalSolverLanguage.g:4346:1: rule__AdditiveExpression__Group_1__2__Impl : ( ( rule__AdditiveExpression__RightAssignment_1_2 ) ) ; | 13840 | // InternalSolverLanguageParser.g:4398:1: rule__AdditiveExpression__Group_1__2__Impl : ( ( rule__AdditiveExpression__RightAssignment_1_2 ) ) ; |
14975 | public final void rule__AdditiveExpression__Group_1__2__Impl() throws RecognitionException { | 13841 | public final void rule__AdditiveExpression__Group_1__2__Impl() throws RecognitionException { |
14976 | 13842 | ||
14977 | int stackSize = keepStackSize(); | 13843 | int stackSize = keepStackSize(); |
14978 | 13844 | ||
14979 | try { | 13845 | try { |
14980 | // InternalSolverLanguage.g:4350:1: ( ( ( rule__AdditiveExpression__RightAssignment_1_2 ) ) ) | 13846 | // InternalSolverLanguageParser.g:4402:1: ( ( ( rule__AdditiveExpression__RightAssignment_1_2 ) ) ) |
14981 | // InternalSolverLanguage.g:4351:1: ( ( rule__AdditiveExpression__RightAssignment_1_2 ) ) | 13847 | // InternalSolverLanguageParser.g:4403:1: ( ( rule__AdditiveExpression__RightAssignment_1_2 ) ) |
14982 | { | 13848 | { |
14983 | // InternalSolverLanguage.g:4351:1: ( ( rule__AdditiveExpression__RightAssignment_1_2 ) ) | 13849 | // InternalSolverLanguageParser.g:4403:1: ( ( rule__AdditiveExpression__RightAssignment_1_2 ) ) |
14984 | // InternalSolverLanguage.g:4352:2: ( rule__AdditiveExpression__RightAssignment_1_2 ) | 13850 | // InternalSolverLanguageParser.g:4404:2: ( rule__AdditiveExpression__RightAssignment_1_2 ) |
14985 | { | 13851 | { |
14986 | if ( state.backtracking==0 ) { | 13852 | before(grammarAccess.getAdditiveExpressionAccess().getRightAssignment_1_2()); |
14987 | before(grammarAccess.getAdditiveExpressionAccess().getRightAssignment_1_2()); | 13853 | // InternalSolverLanguageParser.g:4405:2: ( rule__AdditiveExpression__RightAssignment_1_2 ) |
14988 | } | 13854 | // InternalSolverLanguageParser.g:4405:3: rule__AdditiveExpression__RightAssignment_1_2 |
14989 | // InternalSolverLanguage.g:4353:2: ( rule__AdditiveExpression__RightAssignment_1_2 ) | ||
14990 | // InternalSolverLanguage.g:4353:3: rule__AdditiveExpression__RightAssignment_1_2 | ||
14991 | { | 13855 | { |
14992 | pushFollow(FOLLOW_2); | 13856 | pushFollow(FOLLOW_2); |
14993 | rule__AdditiveExpression__RightAssignment_1_2(); | 13857 | rule__AdditiveExpression__RightAssignment_1_2(); |
14994 | 13858 | ||
14995 | state._fsp--; | 13859 | state._fsp--; |
14996 | if (state.failed) return ; | ||
14997 | 13860 | ||
14998 | } | ||
14999 | 13861 | ||
15000 | if ( state.backtracking==0 ) { | ||
15001 | after(grammarAccess.getAdditiveExpressionAccess().getRightAssignment_1_2()); | ||
15002 | } | 13862 | } |
15003 | 13863 | ||
13864 | after(grammarAccess.getAdditiveExpressionAccess().getRightAssignment_1_2()); | ||
13865 | |||
15004 | } | 13866 | } |
15005 | 13867 | ||
15006 | 13868 | ||
@@ -15022,25 +13884,25 @@ public class InternalSolverLanguageParser extends AbstractInternalContentAssistP | |||
15022 | 13884 | ||
15023 | 13885 | ||
15024 | // $ANTLR start "rule__MultiplicativeExpression__Group__0" | 13886 | // $ANTLR start "rule__MultiplicativeExpression__Group__0" |
15025 | // InternalSolverLanguage.g:4362:1: rule__MultiplicativeExpression__Group__0 : rule__MultiplicativeExpression__Group__0__Impl rule__MultiplicativeExpression__Group__1 ; | 13887 | // InternalSolverLanguageParser.g:4414:1: rule__MultiplicativeExpression__Group__0 : rule__MultiplicativeExpression__Group__0__Impl rule__MultiplicativeExpression__Group__1 ; |
15026 | public final void rule__MultiplicativeExpression__Group__0() throws RecognitionException { | 13888 | public final void rule__MultiplicativeExpression__Group__0() throws RecognitionException { |
15027 | 13889 | ||
15028 | int stackSize = keepStackSize(); | 13890 | int stackSize = keepStackSize(); |
15029 | 13891 | ||
15030 | try { | 13892 | try { |
15031 | // InternalSolverLanguage.g:4366:1: ( rule__MultiplicativeExpression__Group__0__Impl rule__MultiplicativeExpression__Group__1 ) | 13893 | // InternalSolverLanguageParser.g:4418:1: ( rule__MultiplicativeExpression__Group__0__Impl rule__MultiplicativeExpression__Group__1 ) |
15032 | // InternalSolverLanguage.g:4367:2: rule__MultiplicativeExpression__Group__0__Impl rule__MultiplicativeExpression__Group__1 | 13894 | // InternalSolverLanguageParser.g:4419:2: rule__MultiplicativeExpression__Group__0__Impl rule__MultiplicativeExpression__Group__1 |
15033 | { | 13895 | { |
15034 | pushFollow(FOLLOW_27); | 13896 | pushFollow(FOLLOW_26); |
15035 | rule__MultiplicativeExpression__Group__0__Impl(); | 13897 | rule__MultiplicativeExpression__Group__0__Impl(); |
15036 | 13898 | ||
15037 | state._fsp--; | 13899 | state._fsp--; |
15038 | if (state.failed) return ; | 13900 | |
15039 | pushFollow(FOLLOW_2); | 13901 | pushFollow(FOLLOW_2); |
15040 | rule__MultiplicativeExpression__Group__1(); | 13902 | rule__MultiplicativeExpression__Group__1(); |
15041 | 13903 | ||
15042 | state._fsp--; | 13904 | state._fsp--; |
15043 | if (state.failed) return ; | 13905 | |
15044 | 13906 | ||
15045 | } | 13907 | } |
15046 | 13908 | ||
@@ -15060,29 +13922,25 @@ public class InternalSolverLanguageParser extends AbstractInternalContentAssistP | |||
15060 | 13922 | ||
15061 | 13923 | ||
15062 | // $ANTLR start "rule__MultiplicativeExpression__Group__0__Impl" | 13924 | // $ANTLR start "rule__MultiplicativeExpression__Group__0__Impl" |
15063 | // InternalSolverLanguage.g:4374:1: rule__MultiplicativeExpression__Group__0__Impl : ( ruleExponentialExpression ) ; | 13925 | // InternalSolverLanguageParser.g:4426:1: rule__MultiplicativeExpression__Group__0__Impl : ( ruleExponentialExpression ) ; |
15064 | public final void rule__MultiplicativeExpression__Group__0__Impl() throws RecognitionException { | 13926 | public final void rule__MultiplicativeExpression__Group__0__Impl() throws RecognitionException { |
15065 | 13927 | ||
15066 | int stackSize = keepStackSize(); | 13928 | int stackSize = keepStackSize(); |
15067 | 13929 | ||
15068 | try { | 13930 | try { |
15069 | // InternalSolverLanguage.g:4378:1: ( ( ruleExponentialExpression ) ) | 13931 | // InternalSolverLanguageParser.g:4430:1: ( ( ruleExponentialExpression ) ) |
15070 | // InternalSolverLanguage.g:4379:1: ( ruleExponentialExpression ) | 13932 | // InternalSolverLanguageParser.g:4431:1: ( ruleExponentialExpression ) |
15071 | { | 13933 | { |
15072 | // InternalSolverLanguage.g:4379:1: ( ruleExponentialExpression ) | 13934 | // InternalSolverLanguageParser.g:4431:1: ( ruleExponentialExpression ) |
15073 | // InternalSolverLanguage.g:4380:2: ruleExponentialExpression | 13935 | // InternalSolverLanguageParser.g:4432:2: ruleExponentialExpression |
15074 | { | 13936 | { |
15075 | if ( state.backtracking==0 ) { | 13937 | before(grammarAccess.getMultiplicativeExpressionAccess().getExponentialExpressionParserRuleCall_0()); |
15076 | before(grammarAccess.getMultiplicativeExpressionAccess().getExponentialExpressionParserRuleCall_0()); | ||
15077 | } | ||
15078 | pushFollow(FOLLOW_2); | 13938 | pushFollow(FOLLOW_2); |
15079 | ruleExponentialExpression(); | 13939 | ruleExponentialExpression(); |
15080 | 13940 | ||
15081 | state._fsp--; | 13941 | state._fsp--; |
15082 | if (state.failed) return ; | 13942 | |
15083 | if ( state.backtracking==0 ) { | 13943 | after(grammarAccess.getMultiplicativeExpressionAccess().getExponentialExpressionParserRuleCall_0()); |
15084 | after(grammarAccess.getMultiplicativeExpressionAccess().getExponentialExpressionParserRuleCall_0()); | ||
15085 | } | ||
15086 | 13944 | ||
15087 | } | 13945 | } |
15088 | 13946 | ||
@@ -15105,20 +13963,20 @@ public class InternalSolverLanguageParser extends AbstractInternalContentAssistP | |||
15105 | 13963 | ||
15106 | 13964 | ||
15107 | // $ANTLR start "rule__MultiplicativeExpression__Group__1" | 13965 | // $ANTLR start "rule__MultiplicativeExpression__Group__1" |
15108 | // InternalSolverLanguage.g:4389:1: rule__MultiplicativeExpression__Group__1 : rule__MultiplicativeExpression__Group__1__Impl ; | 13966 | // InternalSolverLanguageParser.g:4441:1: rule__MultiplicativeExpression__Group__1 : rule__MultiplicativeExpression__Group__1__Impl ; |
15109 | public final void rule__MultiplicativeExpression__Group__1() throws RecognitionException { | 13967 | public final void rule__MultiplicativeExpression__Group__1() throws RecognitionException { |
15110 | 13968 | ||
15111 | int stackSize = keepStackSize(); | 13969 | int stackSize = keepStackSize(); |
15112 | 13970 | ||
15113 | try { | 13971 | try { |
15114 | // InternalSolverLanguage.g:4393:1: ( rule__MultiplicativeExpression__Group__1__Impl ) | 13972 | // InternalSolverLanguageParser.g:4445:1: ( rule__MultiplicativeExpression__Group__1__Impl ) |
15115 | // InternalSolverLanguage.g:4394:2: rule__MultiplicativeExpression__Group__1__Impl | 13973 | // InternalSolverLanguageParser.g:4446:2: rule__MultiplicativeExpression__Group__1__Impl |
15116 | { | 13974 | { |
15117 | pushFollow(FOLLOW_2); | 13975 | pushFollow(FOLLOW_2); |
15118 | rule__MultiplicativeExpression__Group__1__Impl(); | 13976 | rule__MultiplicativeExpression__Group__1__Impl(); |
15119 | 13977 | ||
15120 | state._fsp--; | 13978 | state._fsp--; |
15121 | if (state.failed) return ; | 13979 | |
15122 | 13980 | ||
15123 | } | 13981 | } |
15124 | 13982 | ||
@@ -15138,41 +13996,39 @@ public class InternalSolverLanguageParser extends AbstractInternalContentAssistP | |||
15138 | 13996 | ||
15139 | 13997 | ||
15140 | // $ANTLR start "rule__MultiplicativeExpression__Group__1__Impl" | 13998 | // $ANTLR start "rule__MultiplicativeExpression__Group__1__Impl" |
15141 | // InternalSolverLanguage.g:4400:1: rule__MultiplicativeExpression__Group__1__Impl : ( ( rule__MultiplicativeExpression__Group_1__0 )* ) ; | 13999 | // InternalSolverLanguageParser.g:4452:1: rule__MultiplicativeExpression__Group__1__Impl : ( ( rule__MultiplicativeExpression__Group_1__0 )* ) ; |
15142 | public final void rule__MultiplicativeExpression__Group__1__Impl() throws RecognitionException { | 14000 | public final void rule__MultiplicativeExpression__Group__1__Impl() throws RecognitionException { |
15143 | 14001 | ||
15144 | int stackSize = keepStackSize(); | 14002 | int stackSize = keepStackSize(); |
15145 | 14003 | ||
15146 | try { | 14004 | try { |
15147 | // InternalSolverLanguage.g:4404:1: ( ( ( rule__MultiplicativeExpression__Group_1__0 )* ) ) | 14005 | // InternalSolverLanguageParser.g:4456:1: ( ( ( rule__MultiplicativeExpression__Group_1__0 )* ) ) |
15148 | // InternalSolverLanguage.g:4405:1: ( ( rule__MultiplicativeExpression__Group_1__0 )* ) | 14006 | // InternalSolverLanguageParser.g:4457:1: ( ( rule__MultiplicativeExpression__Group_1__0 )* ) |
15149 | { | 14007 | { |
15150 | // InternalSolverLanguage.g:4405:1: ( ( rule__MultiplicativeExpression__Group_1__0 )* ) | 14008 | // InternalSolverLanguageParser.g:4457:1: ( ( rule__MultiplicativeExpression__Group_1__0 )* ) |
15151 | // InternalSolverLanguage.g:4406:2: ( rule__MultiplicativeExpression__Group_1__0 )* | 14009 | // InternalSolverLanguageParser.g:4458:2: ( rule__MultiplicativeExpression__Group_1__0 )* |
15152 | { | 14010 | { |
15153 | if ( state.backtracking==0 ) { | 14011 | before(grammarAccess.getMultiplicativeExpressionAccess().getGroup_1()); |
15154 | before(grammarAccess.getMultiplicativeExpressionAccess().getGroup_1()); | 14012 | // InternalSolverLanguageParser.g:4459:2: ( rule__MultiplicativeExpression__Group_1__0 )* |
15155 | } | ||
15156 | // InternalSolverLanguage.g:4407:2: ( rule__MultiplicativeExpression__Group_1__0 )* | ||
15157 | loop37: | 14013 | loop37: |
15158 | do { | 14014 | do { |
15159 | int alt37=2; | 14015 | int alt37=2; |
15160 | int LA37_0 = input.LA(1); | 14016 | int LA37_0 = input.LA(1); |
15161 | 14017 | ||
15162 | if ( (LA37_0==16||LA37_0==28) ) { | 14018 | if ( (LA37_0==Asterisk||LA37_0==Solidus) ) { |
15163 | alt37=1; | 14019 | alt37=1; |
15164 | } | 14020 | } |
15165 | 14021 | ||
15166 | 14022 | ||
15167 | switch (alt37) { | 14023 | switch (alt37) { |
15168 | case 1 : | 14024 | case 1 : |
15169 | // InternalSolverLanguage.g:4407:3: rule__MultiplicativeExpression__Group_1__0 | 14025 | // InternalSolverLanguageParser.g:4459:3: rule__MultiplicativeExpression__Group_1__0 |
15170 | { | 14026 | { |
15171 | pushFollow(FOLLOW_28); | 14027 | pushFollow(FOLLOW_27); |
15172 | rule__MultiplicativeExpression__Group_1__0(); | 14028 | rule__MultiplicativeExpression__Group_1__0(); |
15173 | 14029 | ||
15174 | state._fsp--; | 14030 | state._fsp--; |
15175 | if (state.failed) return ; | 14031 | |
15176 | 14032 | ||
15177 | } | 14033 | } |
15178 | break; | 14034 | break; |
@@ -15182,9 +14038,7 @@ public class InternalSolverLanguageParser extends AbstractInternalContentAssistP | |||
15182 | } | 14038 | } |
15183 | } while (true); | 14039 | } while (true); |
15184 | 14040 | ||
15185 | if ( state.backtracking==0 ) { | 14041 | after(grammarAccess.getMultiplicativeExpressionAccess().getGroup_1()); |
15186 | after(grammarAccess.getMultiplicativeExpressionAccess().getGroup_1()); | ||
15187 | } | ||
15188 | 14042 | ||
15189 | } | 14043 | } |
15190 | 14044 | ||
@@ -15207,25 +14061,25 @@ public class InternalSolverLanguageParser extends AbstractInternalContentAssistP | |||
15207 | 14061 | ||
15208 | 14062 | ||
15209 | // $ANTLR start "rule__MultiplicativeExpression__Group_1__0" | 14063 | // $ANTLR start "rule__MultiplicativeExpression__Group_1__0" |
15210 | // InternalSolverLanguage.g:4416:1: rule__MultiplicativeExpression__Group_1__0 : rule__MultiplicativeExpression__Group_1__0__Impl rule__MultiplicativeExpression__Group_1__1 ; | 14064 | // InternalSolverLanguageParser.g:4468:1: rule__MultiplicativeExpression__Group_1__0 : rule__MultiplicativeExpression__Group_1__0__Impl rule__MultiplicativeExpression__Group_1__1 ; |
15211 | public final void rule__MultiplicativeExpression__Group_1__0() throws RecognitionException { | 14065 | public final void rule__MultiplicativeExpression__Group_1__0() throws RecognitionException { |
15212 | 14066 | ||
15213 | int stackSize = keepStackSize(); | 14067 | int stackSize = keepStackSize(); |
15214 | 14068 | ||
15215 | try { | 14069 | try { |
15216 | // InternalSolverLanguage.g:4420:1: ( rule__MultiplicativeExpression__Group_1__0__Impl rule__MultiplicativeExpression__Group_1__1 ) | 14070 | // InternalSolverLanguageParser.g:4472:1: ( rule__MultiplicativeExpression__Group_1__0__Impl rule__MultiplicativeExpression__Group_1__1 ) |
15217 | // InternalSolverLanguage.g:4421:2: rule__MultiplicativeExpression__Group_1__0__Impl rule__MultiplicativeExpression__Group_1__1 | 14071 | // InternalSolverLanguageParser.g:4473:2: rule__MultiplicativeExpression__Group_1__0__Impl rule__MultiplicativeExpression__Group_1__1 |
15218 | { | 14072 | { |
15219 | pushFollow(FOLLOW_27); | 14073 | pushFollow(FOLLOW_26); |
15220 | rule__MultiplicativeExpression__Group_1__0__Impl(); | 14074 | rule__MultiplicativeExpression__Group_1__0__Impl(); |
15221 | 14075 | ||
15222 | state._fsp--; | 14076 | state._fsp--; |
15223 | if (state.failed) return ; | 14077 | |
15224 | pushFollow(FOLLOW_2); | 14078 | pushFollow(FOLLOW_2); |
15225 | rule__MultiplicativeExpression__Group_1__1(); | 14079 | rule__MultiplicativeExpression__Group_1__1(); |
15226 | 14080 | ||
15227 | state._fsp--; | 14081 | state._fsp--; |
15228 | if (state.failed) return ; | 14082 | |
15229 | 14083 | ||
15230 | } | 14084 | } |
15231 | 14085 | ||
@@ -15245,29 +14099,25 @@ public class InternalSolverLanguageParser extends AbstractInternalContentAssistP | |||
15245 | 14099 | ||
15246 | 14100 | ||
15247 | // $ANTLR start "rule__MultiplicativeExpression__Group_1__0__Impl" | 14101 | // $ANTLR start "rule__MultiplicativeExpression__Group_1__0__Impl" |
15248 | // InternalSolverLanguage.g:4428:1: rule__MultiplicativeExpression__Group_1__0__Impl : ( () ) ; | 14102 | // InternalSolverLanguageParser.g:4480:1: rule__MultiplicativeExpression__Group_1__0__Impl : ( () ) ; |
15249 | public final void rule__MultiplicativeExpression__Group_1__0__Impl() throws RecognitionException { | 14103 | public final void rule__MultiplicativeExpression__Group_1__0__Impl() throws RecognitionException { |
15250 | 14104 | ||
15251 | int stackSize = keepStackSize(); | 14105 | int stackSize = keepStackSize(); |
15252 | 14106 | ||
15253 | try { | 14107 | try { |
15254 | // InternalSolverLanguage.g:4432:1: ( ( () ) ) | 14108 | // InternalSolverLanguageParser.g:4484:1: ( ( () ) ) |
15255 | // InternalSolverLanguage.g:4433:1: ( () ) | 14109 | // InternalSolverLanguageParser.g:4485:1: ( () ) |
15256 | { | 14110 | { |
15257 | // InternalSolverLanguage.g:4433:1: ( () ) | 14111 | // InternalSolverLanguageParser.g:4485:1: ( () ) |
15258 | // InternalSolverLanguage.g:4434:2: () | 14112 | // InternalSolverLanguageParser.g:4486:2: () |
15259 | { | 14113 | { |
15260 | if ( state.backtracking==0 ) { | 14114 | before(grammarAccess.getMultiplicativeExpressionAccess().getBinaryExpressionLeftAction_1_0()); |
15261 | before(grammarAccess.getMultiplicativeExpressionAccess().getBinaryExpressionLeftAction_1_0()); | 14115 | // InternalSolverLanguageParser.g:4487:2: () |
15262 | } | 14116 | // InternalSolverLanguageParser.g:4487:3: |
15263 | // InternalSolverLanguage.g:4435:2: () | ||
15264 | // InternalSolverLanguage.g:4435:3: | ||
15265 | { | 14117 | { |
15266 | } | 14118 | } |
15267 | 14119 | ||
15268 | if ( state.backtracking==0 ) { | 14120 | after(grammarAccess.getMultiplicativeExpressionAccess().getBinaryExpressionLeftAction_1_0()); |
15269 | after(grammarAccess.getMultiplicativeExpressionAccess().getBinaryExpressionLeftAction_1_0()); | ||
15270 | } | ||
15271 | 14121 | ||
15272 | } | 14122 | } |
15273 | 14123 | ||
@@ -15286,25 +14136,25 @@ public class InternalSolverLanguageParser extends AbstractInternalContentAssistP | |||
15286 | 14136 | ||
15287 | 14137 | ||
15288 | // $ANTLR start "rule__MultiplicativeExpression__Group_1__1" | 14138 | // $ANTLR start "rule__MultiplicativeExpression__Group_1__1" |
15289 | // InternalSolverLanguage.g:4443:1: rule__MultiplicativeExpression__Group_1__1 : rule__MultiplicativeExpression__Group_1__1__Impl rule__MultiplicativeExpression__Group_1__2 ; | 14139 | // InternalSolverLanguageParser.g:4495:1: rule__MultiplicativeExpression__Group_1__1 : rule__MultiplicativeExpression__Group_1__1__Impl rule__MultiplicativeExpression__Group_1__2 ; |
15290 | public final void rule__MultiplicativeExpression__Group_1__1() throws RecognitionException { | 14140 | public final void rule__MultiplicativeExpression__Group_1__1() throws RecognitionException { |
15291 | 14141 | ||
15292 | int stackSize = keepStackSize(); | 14142 | int stackSize = keepStackSize(); |
15293 | 14143 | ||
15294 | try { | 14144 | try { |
15295 | // InternalSolverLanguage.g:4447:1: ( rule__MultiplicativeExpression__Group_1__1__Impl rule__MultiplicativeExpression__Group_1__2 ) | 14145 | // InternalSolverLanguageParser.g:4499:1: ( rule__MultiplicativeExpression__Group_1__1__Impl rule__MultiplicativeExpression__Group_1__2 ) |
15296 | // InternalSolverLanguage.g:4448:2: rule__MultiplicativeExpression__Group_1__1__Impl rule__MultiplicativeExpression__Group_1__2 | 14146 | // InternalSolverLanguageParser.g:4500:2: rule__MultiplicativeExpression__Group_1__1__Impl rule__MultiplicativeExpression__Group_1__2 |
15297 | { | 14147 | { |
15298 | pushFollow(FOLLOW_7); | 14148 | pushFollow(FOLLOW_7); |
15299 | rule__MultiplicativeExpression__Group_1__1__Impl(); | 14149 | rule__MultiplicativeExpression__Group_1__1__Impl(); |
15300 | 14150 | ||
15301 | state._fsp--; | 14151 | state._fsp--; |
15302 | if (state.failed) return ; | 14152 | |
15303 | pushFollow(FOLLOW_2); | 14153 | pushFollow(FOLLOW_2); |
15304 | rule__MultiplicativeExpression__Group_1__2(); | 14154 | rule__MultiplicativeExpression__Group_1__2(); |
15305 | 14155 | ||
15306 | state._fsp--; | 14156 | state._fsp--; |
15307 | if (state.failed) return ; | 14157 | |
15308 | 14158 | ||
15309 | } | 14159 | } |
15310 | 14160 | ||
@@ -15324,36 +14174,32 @@ public class InternalSolverLanguageParser extends AbstractInternalContentAssistP | |||
15324 | 14174 | ||
15325 | 14175 | ||
15326 | // $ANTLR start "rule__MultiplicativeExpression__Group_1__1__Impl" | 14176 | // $ANTLR start "rule__MultiplicativeExpression__Group_1__1__Impl" |
15327 | // InternalSolverLanguage.g:4455:1: rule__MultiplicativeExpression__Group_1__1__Impl : ( ( rule__MultiplicativeExpression__OpAssignment_1_1 ) ) ; | 14177 | // InternalSolverLanguageParser.g:4507:1: rule__MultiplicativeExpression__Group_1__1__Impl : ( ( rule__MultiplicativeExpression__OpAssignment_1_1 ) ) ; |
15328 | public final void rule__MultiplicativeExpression__Group_1__1__Impl() throws RecognitionException { | 14178 | public final void rule__MultiplicativeExpression__Group_1__1__Impl() throws RecognitionException { |
15329 | 14179 | ||
15330 | int stackSize = keepStackSize(); | 14180 | int stackSize = keepStackSize(); |
15331 | 14181 | ||
15332 | try { | 14182 | try { |
15333 | // InternalSolverLanguage.g:4459:1: ( ( ( rule__MultiplicativeExpression__OpAssignment_1_1 ) ) ) | 14183 | // InternalSolverLanguageParser.g:4511:1: ( ( ( rule__MultiplicativeExpression__OpAssignment_1_1 ) ) ) |
15334 | // InternalSolverLanguage.g:4460:1: ( ( rule__MultiplicativeExpression__OpAssignment_1_1 ) ) | 14184 | // InternalSolverLanguageParser.g:4512:1: ( ( rule__MultiplicativeExpression__OpAssignment_1_1 ) ) |
15335 | { | 14185 | { |
15336 | // InternalSolverLanguage.g:4460:1: ( ( rule__MultiplicativeExpression__OpAssignment_1_1 ) ) | 14186 | // InternalSolverLanguageParser.g:4512:1: ( ( rule__MultiplicativeExpression__OpAssignment_1_1 ) ) |
15337 | // InternalSolverLanguage.g:4461:2: ( rule__MultiplicativeExpression__OpAssignment_1_1 ) | 14187 | // InternalSolverLanguageParser.g:4513:2: ( rule__MultiplicativeExpression__OpAssignment_1_1 ) |
15338 | { | 14188 | { |
15339 | if ( state.backtracking==0 ) { | 14189 | before(grammarAccess.getMultiplicativeExpressionAccess().getOpAssignment_1_1()); |
15340 | before(grammarAccess.getMultiplicativeExpressionAccess().getOpAssignment_1_1()); | 14190 | // InternalSolverLanguageParser.g:4514:2: ( rule__MultiplicativeExpression__OpAssignment_1_1 ) |
15341 | } | 14191 | // InternalSolverLanguageParser.g:4514:3: rule__MultiplicativeExpression__OpAssignment_1_1 |
15342 | // InternalSolverLanguage.g:4462:2: ( rule__MultiplicativeExpression__OpAssignment_1_1 ) | ||
15343 | // InternalSolverLanguage.g:4462:3: rule__MultiplicativeExpression__OpAssignment_1_1 | ||
15344 | { | 14192 | { |
15345 | pushFollow(FOLLOW_2); | 14193 | pushFollow(FOLLOW_2); |
15346 | rule__MultiplicativeExpression__OpAssignment_1_1(); | 14194 | rule__MultiplicativeExpression__OpAssignment_1_1(); |
15347 | 14195 | ||
15348 | state._fsp--; | 14196 | state._fsp--; |
15349 | if (state.failed) return ; | ||
15350 | 14197 | ||
15351 | } | ||
15352 | 14198 | ||
15353 | if ( state.backtracking==0 ) { | ||
15354 | after(grammarAccess.getMultiplicativeExpressionAccess().getOpAssignment_1_1()); | ||
15355 | } | 14199 | } |
15356 | 14200 | ||
14201 | after(grammarAccess.getMultiplicativeExpressionAccess().getOpAssignment_1_1()); | ||
14202 | |||
15357 | } | 14203 | } |
15358 | 14204 | ||
15359 | 14205 | ||
@@ -15375,20 +14221,20 @@ public class InternalSolverLanguageParser extends AbstractInternalContentAssistP | |||
15375 | 14221 | ||
15376 | 14222 | ||
15377 | // $ANTLR start "rule__MultiplicativeExpression__Group_1__2" | 14223 | // $ANTLR start "rule__MultiplicativeExpression__Group_1__2" |
15378 | // InternalSolverLanguage.g:4470:1: rule__MultiplicativeExpression__Group_1__2 : rule__MultiplicativeExpression__Group_1__2__Impl ; | 14224 | // InternalSolverLanguageParser.g:4522:1: rule__MultiplicativeExpression__Group_1__2 : rule__MultiplicativeExpression__Group_1__2__Impl ; |
15379 | public final void rule__MultiplicativeExpression__Group_1__2() throws RecognitionException { | 14225 | public final void rule__MultiplicativeExpression__Group_1__2() throws RecognitionException { |
15380 | 14226 | ||
15381 | int stackSize = keepStackSize(); | 14227 | int stackSize = keepStackSize(); |
15382 | 14228 | ||
15383 | try { | 14229 | try { |
15384 | // InternalSolverLanguage.g:4474:1: ( rule__MultiplicativeExpression__Group_1__2__Impl ) | 14230 | // InternalSolverLanguageParser.g:4526:1: ( rule__MultiplicativeExpression__Group_1__2__Impl ) |
15385 | // InternalSolverLanguage.g:4475:2: rule__MultiplicativeExpression__Group_1__2__Impl | 14231 | // InternalSolverLanguageParser.g:4527:2: rule__MultiplicativeExpression__Group_1__2__Impl |
15386 | { | 14232 | { |
15387 | pushFollow(FOLLOW_2); | 14233 | pushFollow(FOLLOW_2); |
15388 | rule__MultiplicativeExpression__Group_1__2__Impl(); | 14234 | rule__MultiplicativeExpression__Group_1__2__Impl(); |
15389 | 14235 | ||
15390 | state._fsp--; | 14236 | state._fsp--; |
15391 | if (state.failed) return ; | 14237 | |
15392 | 14238 | ||
15393 | } | 14239 | } |
15394 | 14240 | ||
@@ -15408,36 +14254,32 @@ public class InternalSolverLanguageParser extends AbstractInternalContentAssistP | |||
15408 | 14254 | ||
15409 | 14255 | ||
15410 | // $ANTLR start "rule__MultiplicativeExpression__Group_1__2__Impl" | 14256 | // $ANTLR start "rule__MultiplicativeExpression__Group_1__2__Impl" |
15411 | // InternalSolverLanguage.g:4481:1: rule__MultiplicativeExpression__Group_1__2__Impl : ( ( rule__MultiplicativeExpression__RightAssignment_1_2 ) ) ; | 14257 | // InternalSolverLanguageParser.g:4533:1: rule__MultiplicativeExpression__Group_1__2__Impl : ( ( rule__MultiplicativeExpression__RightAssignment_1_2 ) ) ; |
15412 | public final void rule__MultiplicativeExpression__Group_1__2__Impl() throws RecognitionException { | 14258 | public final void rule__MultiplicativeExpression__Group_1__2__Impl() throws RecognitionException { |
15413 | 14259 | ||
15414 | int stackSize = keepStackSize(); | 14260 | int stackSize = keepStackSize(); |
15415 | 14261 | ||
15416 | try { | 14262 | try { |
15417 | // InternalSolverLanguage.g:4485:1: ( ( ( rule__MultiplicativeExpression__RightAssignment_1_2 ) ) ) | 14263 | // InternalSolverLanguageParser.g:4537:1: ( ( ( rule__MultiplicativeExpression__RightAssignment_1_2 ) ) ) |
15418 | // InternalSolverLanguage.g:4486:1: ( ( rule__MultiplicativeExpression__RightAssignment_1_2 ) ) | 14264 | // InternalSolverLanguageParser.g:4538:1: ( ( rule__MultiplicativeExpression__RightAssignment_1_2 ) ) |
15419 | { | 14265 | { |
15420 | // InternalSolverLanguage.g:4486:1: ( ( rule__MultiplicativeExpression__RightAssignment_1_2 ) ) | 14266 | // InternalSolverLanguageParser.g:4538:1: ( ( rule__MultiplicativeExpression__RightAssignment_1_2 ) ) |
15421 | // InternalSolverLanguage.g:4487:2: ( rule__MultiplicativeExpression__RightAssignment_1_2 ) | 14267 | // InternalSolverLanguageParser.g:4539:2: ( rule__MultiplicativeExpression__RightAssignment_1_2 ) |
15422 | { | 14268 | { |
15423 | if ( state.backtracking==0 ) { | 14269 | before(grammarAccess.getMultiplicativeExpressionAccess().getRightAssignment_1_2()); |
15424 | before(grammarAccess.getMultiplicativeExpressionAccess().getRightAssignment_1_2()); | 14270 | // InternalSolverLanguageParser.g:4540:2: ( rule__MultiplicativeExpression__RightAssignment_1_2 ) |
15425 | } | 14271 | // InternalSolverLanguageParser.g:4540:3: rule__MultiplicativeExpression__RightAssignment_1_2 |
15426 | // InternalSolverLanguage.g:4488:2: ( rule__MultiplicativeExpression__RightAssignment_1_2 ) | ||
15427 | // InternalSolverLanguage.g:4488:3: rule__MultiplicativeExpression__RightAssignment_1_2 | ||
15428 | { | 14272 | { |
15429 | pushFollow(FOLLOW_2); | 14273 | pushFollow(FOLLOW_2); |
15430 | rule__MultiplicativeExpression__RightAssignment_1_2(); | 14274 | rule__MultiplicativeExpression__RightAssignment_1_2(); |
15431 | 14275 | ||
15432 | state._fsp--; | 14276 | state._fsp--; |
15433 | if (state.failed) return ; | ||
15434 | 14277 | ||
15435 | } | ||
15436 | 14278 | ||
15437 | if ( state.backtracking==0 ) { | ||
15438 | after(grammarAccess.getMultiplicativeExpressionAccess().getRightAssignment_1_2()); | ||
15439 | } | 14279 | } |
15440 | 14280 | ||
14281 | after(grammarAccess.getMultiplicativeExpressionAccess().getRightAssignment_1_2()); | ||
14282 | |||
15441 | } | 14283 | } |
15442 | 14284 | ||
15443 | 14285 | ||
@@ -15459,25 +14301,25 @@ public class InternalSolverLanguageParser extends AbstractInternalContentAssistP | |||
15459 | 14301 | ||
15460 | 14302 | ||
15461 | // $ANTLR start "rule__ExponentialExpression__Group__0" | 14303 | // $ANTLR start "rule__ExponentialExpression__Group__0" |
15462 | // InternalSolverLanguage.g:4497:1: rule__ExponentialExpression__Group__0 : rule__ExponentialExpression__Group__0__Impl rule__ExponentialExpression__Group__1 ; | 14304 | // InternalSolverLanguageParser.g:4549:1: rule__ExponentialExpression__Group__0 : rule__ExponentialExpression__Group__0__Impl rule__ExponentialExpression__Group__1 ; |
15463 | public final void rule__ExponentialExpression__Group__0() throws RecognitionException { | 14305 | public final void rule__ExponentialExpression__Group__0() throws RecognitionException { |
15464 | 14306 | ||
15465 | int stackSize = keepStackSize(); | 14307 | int stackSize = keepStackSize(); |
15466 | 14308 | ||
15467 | try { | 14309 | try { |
15468 | // InternalSolverLanguage.g:4501:1: ( rule__ExponentialExpression__Group__0__Impl rule__ExponentialExpression__Group__1 ) | 14310 | // InternalSolverLanguageParser.g:4553:1: ( rule__ExponentialExpression__Group__0__Impl rule__ExponentialExpression__Group__1 ) |
15469 | // InternalSolverLanguage.g:4502:2: rule__ExponentialExpression__Group__0__Impl rule__ExponentialExpression__Group__1 | 14311 | // InternalSolverLanguageParser.g:4554:2: rule__ExponentialExpression__Group__0__Impl rule__ExponentialExpression__Group__1 |
15470 | { | 14312 | { |
15471 | pushFollow(FOLLOW_29); | 14313 | pushFollow(FOLLOW_28); |
15472 | rule__ExponentialExpression__Group__0__Impl(); | 14314 | rule__ExponentialExpression__Group__0__Impl(); |
15473 | 14315 | ||
15474 | state._fsp--; | 14316 | state._fsp--; |
15475 | if (state.failed) return ; | 14317 | |
15476 | pushFollow(FOLLOW_2); | 14318 | pushFollow(FOLLOW_2); |
15477 | rule__ExponentialExpression__Group__1(); | 14319 | rule__ExponentialExpression__Group__1(); |
15478 | 14320 | ||
15479 | state._fsp--; | 14321 | state._fsp--; |
15480 | if (state.failed) return ; | 14322 | |
15481 | 14323 | ||
15482 | } | 14324 | } |
15483 | 14325 | ||
@@ -15497,29 +14339,25 @@ public class InternalSolverLanguageParser extends AbstractInternalContentAssistP | |||
15497 | 14339 | ||
15498 | 14340 | ||
15499 | // $ANTLR start "rule__ExponentialExpression__Group__0__Impl" | 14341 | // $ANTLR start "rule__ExponentialExpression__Group__0__Impl" |
15500 | // InternalSolverLanguage.g:4509:1: rule__ExponentialExpression__Group__0__Impl : ( ruleUnaryExpression ) ; | 14342 | // InternalSolverLanguageParser.g:4561:1: rule__ExponentialExpression__Group__0__Impl : ( ruleUnaryExpression ) ; |
15501 | public final void rule__ExponentialExpression__Group__0__Impl() throws RecognitionException { | 14343 | public final void rule__ExponentialExpression__Group__0__Impl() throws RecognitionException { |
15502 | 14344 | ||
15503 | int stackSize = keepStackSize(); | 14345 | int stackSize = keepStackSize(); |
15504 | 14346 | ||
15505 | try { | 14347 | try { |
15506 | // InternalSolverLanguage.g:4513:1: ( ( ruleUnaryExpression ) ) | 14348 | // InternalSolverLanguageParser.g:4565:1: ( ( ruleUnaryExpression ) ) |
15507 | // InternalSolverLanguage.g:4514:1: ( ruleUnaryExpression ) | 14349 | // InternalSolverLanguageParser.g:4566:1: ( ruleUnaryExpression ) |
15508 | { | 14350 | { |
15509 | // InternalSolverLanguage.g:4514:1: ( ruleUnaryExpression ) | 14351 | // InternalSolverLanguageParser.g:4566:1: ( ruleUnaryExpression ) |
15510 | // InternalSolverLanguage.g:4515:2: ruleUnaryExpression | 14352 | // InternalSolverLanguageParser.g:4567:2: ruleUnaryExpression |
15511 | { | 14353 | { |
15512 | if ( state.backtracking==0 ) { | 14354 | before(grammarAccess.getExponentialExpressionAccess().getUnaryExpressionParserRuleCall_0()); |
15513 | before(grammarAccess.getExponentialExpressionAccess().getUnaryExpressionParserRuleCall_0()); | ||
15514 | } | ||
15515 | pushFollow(FOLLOW_2); | 14355 | pushFollow(FOLLOW_2); |
15516 | ruleUnaryExpression(); | 14356 | ruleUnaryExpression(); |
15517 | 14357 | ||
15518 | state._fsp--; | 14358 | state._fsp--; |
15519 | if (state.failed) return ; | 14359 | |
15520 | if ( state.backtracking==0 ) { | 14360 | after(grammarAccess.getExponentialExpressionAccess().getUnaryExpressionParserRuleCall_0()); |
15521 | after(grammarAccess.getExponentialExpressionAccess().getUnaryExpressionParserRuleCall_0()); | ||
15522 | } | ||
15523 | 14361 | ||
15524 | } | 14362 | } |
15525 | 14363 | ||
@@ -15542,20 +14380,20 @@ public class InternalSolverLanguageParser extends AbstractInternalContentAssistP | |||
15542 | 14380 | ||
15543 | 14381 | ||
15544 | // $ANTLR start "rule__ExponentialExpression__Group__1" | 14382 | // $ANTLR start "rule__ExponentialExpression__Group__1" |
15545 | // InternalSolverLanguage.g:4524:1: rule__ExponentialExpression__Group__1 : rule__ExponentialExpression__Group__1__Impl ; | 14383 | // InternalSolverLanguageParser.g:4576:1: rule__ExponentialExpression__Group__1 : rule__ExponentialExpression__Group__1__Impl ; |
15546 | public final void rule__ExponentialExpression__Group__1() throws RecognitionException { | 14384 | public final void rule__ExponentialExpression__Group__1() throws RecognitionException { |
15547 | 14385 | ||
15548 | int stackSize = keepStackSize(); | 14386 | int stackSize = keepStackSize(); |
15549 | 14387 | ||
15550 | try { | 14388 | try { |
15551 | // InternalSolverLanguage.g:4528:1: ( rule__ExponentialExpression__Group__1__Impl ) | 14389 | // InternalSolverLanguageParser.g:4580:1: ( rule__ExponentialExpression__Group__1__Impl ) |
15552 | // InternalSolverLanguage.g:4529:2: rule__ExponentialExpression__Group__1__Impl | 14390 | // InternalSolverLanguageParser.g:4581:2: rule__ExponentialExpression__Group__1__Impl |
15553 | { | 14391 | { |
15554 | pushFollow(FOLLOW_2); | 14392 | pushFollow(FOLLOW_2); |
15555 | rule__ExponentialExpression__Group__1__Impl(); | 14393 | rule__ExponentialExpression__Group__1__Impl(); |
15556 | 14394 | ||
15557 | state._fsp--; | 14395 | state._fsp--; |
15558 | if (state.failed) return ; | 14396 | |
15559 | 14397 | ||
15560 | } | 14398 | } |
15561 | 14399 | ||
@@ -15575,46 +14413,42 @@ public class InternalSolverLanguageParser extends AbstractInternalContentAssistP | |||
15575 | 14413 | ||
15576 | 14414 | ||
15577 | // $ANTLR start "rule__ExponentialExpression__Group__1__Impl" | 14415 | // $ANTLR start "rule__ExponentialExpression__Group__1__Impl" |
15578 | // InternalSolverLanguage.g:4535:1: rule__ExponentialExpression__Group__1__Impl : ( ( rule__ExponentialExpression__Group_1__0 )? ) ; | 14416 | // InternalSolverLanguageParser.g:4587:1: rule__ExponentialExpression__Group__1__Impl : ( ( rule__ExponentialExpression__Group_1__0 )? ) ; |
15579 | public final void rule__ExponentialExpression__Group__1__Impl() throws RecognitionException { | 14417 | public final void rule__ExponentialExpression__Group__1__Impl() throws RecognitionException { |
15580 | 14418 | ||
15581 | int stackSize = keepStackSize(); | 14419 | int stackSize = keepStackSize(); |
15582 | 14420 | ||
15583 | try { | 14421 | try { |
15584 | // InternalSolverLanguage.g:4539:1: ( ( ( rule__ExponentialExpression__Group_1__0 )? ) ) | 14422 | // InternalSolverLanguageParser.g:4591:1: ( ( ( rule__ExponentialExpression__Group_1__0 )? ) ) |
15585 | // InternalSolverLanguage.g:4540:1: ( ( rule__ExponentialExpression__Group_1__0 )? ) | 14423 | // InternalSolverLanguageParser.g:4592:1: ( ( rule__ExponentialExpression__Group_1__0 )? ) |
15586 | { | 14424 | { |
15587 | // InternalSolverLanguage.g:4540:1: ( ( rule__ExponentialExpression__Group_1__0 )? ) | 14425 | // InternalSolverLanguageParser.g:4592:1: ( ( rule__ExponentialExpression__Group_1__0 )? ) |
15588 | // InternalSolverLanguage.g:4541:2: ( rule__ExponentialExpression__Group_1__0 )? | 14426 | // InternalSolverLanguageParser.g:4593:2: ( rule__ExponentialExpression__Group_1__0 )? |
15589 | { | 14427 | { |
15590 | if ( state.backtracking==0 ) { | 14428 | before(grammarAccess.getExponentialExpressionAccess().getGroup_1()); |
15591 | before(grammarAccess.getExponentialExpressionAccess().getGroup_1()); | 14429 | // InternalSolverLanguageParser.g:4594:2: ( rule__ExponentialExpression__Group_1__0 )? |
15592 | } | ||
15593 | // InternalSolverLanguage.g:4542:2: ( rule__ExponentialExpression__Group_1__0 )? | ||
15594 | int alt38=2; | 14430 | int alt38=2; |
15595 | int LA38_0 = input.LA(1); | 14431 | int LA38_0 = input.LA(1); |
15596 | 14432 | ||
15597 | if ( (LA38_0==15) ) { | 14433 | if ( (LA38_0==CircumflexAccent) ) { |
15598 | alt38=1; | 14434 | alt38=1; |
15599 | } | 14435 | } |
15600 | switch (alt38) { | 14436 | switch (alt38) { |
15601 | case 1 : | 14437 | case 1 : |
15602 | // InternalSolverLanguage.g:4542:3: rule__ExponentialExpression__Group_1__0 | 14438 | // InternalSolverLanguageParser.g:4594:3: rule__ExponentialExpression__Group_1__0 |
15603 | { | 14439 | { |
15604 | pushFollow(FOLLOW_2); | 14440 | pushFollow(FOLLOW_2); |
15605 | rule__ExponentialExpression__Group_1__0(); | 14441 | rule__ExponentialExpression__Group_1__0(); |
15606 | 14442 | ||
15607 | state._fsp--; | 14443 | state._fsp--; |
15608 | if (state.failed) return ; | 14444 | |
15609 | 14445 | ||
15610 | } | 14446 | } |
15611 | break; | 14447 | break; |
15612 | 14448 | ||
15613 | } | 14449 | } |
15614 | 14450 | ||
15615 | if ( state.backtracking==0 ) { | 14451 | after(grammarAccess.getExponentialExpressionAccess().getGroup_1()); |
15616 | after(grammarAccess.getExponentialExpressionAccess().getGroup_1()); | ||
15617 | } | ||
15618 | 14452 | ||
15619 | } | 14453 | } |
15620 | 14454 | ||
@@ -15637,25 +14471,25 @@ public class InternalSolverLanguageParser extends AbstractInternalContentAssistP | |||
15637 | 14471 | ||
15638 | 14472 | ||
15639 | // $ANTLR start "rule__ExponentialExpression__Group_1__0" | 14473 | // $ANTLR start "rule__ExponentialExpression__Group_1__0" |
15640 | // InternalSolverLanguage.g:4551:1: rule__ExponentialExpression__Group_1__0 : rule__ExponentialExpression__Group_1__0__Impl rule__ExponentialExpression__Group_1__1 ; | 14474 | // InternalSolverLanguageParser.g:4603:1: rule__ExponentialExpression__Group_1__0 : rule__ExponentialExpression__Group_1__0__Impl rule__ExponentialExpression__Group_1__1 ; |
15641 | public final void rule__ExponentialExpression__Group_1__0() throws RecognitionException { | 14475 | public final void rule__ExponentialExpression__Group_1__0() throws RecognitionException { |
15642 | 14476 | ||
15643 | int stackSize = keepStackSize(); | 14477 | int stackSize = keepStackSize(); |
15644 | 14478 | ||
15645 | try { | 14479 | try { |
15646 | // InternalSolverLanguage.g:4555:1: ( rule__ExponentialExpression__Group_1__0__Impl rule__ExponentialExpression__Group_1__1 ) | 14480 | // InternalSolverLanguageParser.g:4607:1: ( rule__ExponentialExpression__Group_1__0__Impl rule__ExponentialExpression__Group_1__1 ) |
15647 | // InternalSolverLanguage.g:4556:2: rule__ExponentialExpression__Group_1__0__Impl rule__ExponentialExpression__Group_1__1 | 14481 | // InternalSolverLanguageParser.g:4608:2: rule__ExponentialExpression__Group_1__0__Impl rule__ExponentialExpression__Group_1__1 |
15648 | { | 14482 | { |
15649 | pushFollow(FOLLOW_29); | 14483 | pushFollow(FOLLOW_28); |
15650 | rule__ExponentialExpression__Group_1__0__Impl(); | 14484 | rule__ExponentialExpression__Group_1__0__Impl(); |
15651 | 14485 | ||
15652 | state._fsp--; | 14486 | state._fsp--; |
15653 | if (state.failed) return ; | 14487 | |
15654 | pushFollow(FOLLOW_2); | 14488 | pushFollow(FOLLOW_2); |
15655 | rule__ExponentialExpression__Group_1__1(); | 14489 | rule__ExponentialExpression__Group_1__1(); |
15656 | 14490 | ||
15657 | state._fsp--; | 14491 | state._fsp--; |
15658 | if (state.failed) return ; | 14492 | |
15659 | 14493 | ||
15660 | } | 14494 | } |
15661 | 14495 | ||
@@ -15675,29 +14509,25 @@ public class InternalSolverLanguageParser extends AbstractInternalContentAssistP | |||
15675 | 14509 | ||
15676 | 14510 | ||
15677 | // $ANTLR start "rule__ExponentialExpression__Group_1__0__Impl" | 14511 | // $ANTLR start "rule__ExponentialExpression__Group_1__0__Impl" |
15678 | // InternalSolverLanguage.g:4563:1: rule__ExponentialExpression__Group_1__0__Impl : ( () ) ; | 14512 | // InternalSolverLanguageParser.g:4615:1: rule__ExponentialExpression__Group_1__0__Impl : ( () ) ; |
15679 | public final void rule__ExponentialExpression__Group_1__0__Impl() throws RecognitionException { | 14513 | public final void rule__ExponentialExpression__Group_1__0__Impl() throws RecognitionException { |
15680 | 14514 | ||
15681 | int stackSize = keepStackSize(); | 14515 | int stackSize = keepStackSize(); |
15682 | 14516 | ||
15683 | try { | 14517 | try { |
15684 | // InternalSolverLanguage.g:4567:1: ( ( () ) ) | 14518 | // InternalSolverLanguageParser.g:4619:1: ( ( () ) ) |
15685 | // InternalSolverLanguage.g:4568:1: ( () ) | 14519 | // InternalSolverLanguageParser.g:4620:1: ( () ) |
15686 | { | 14520 | { |
15687 | // InternalSolverLanguage.g:4568:1: ( () ) | 14521 | // InternalSolverLanguageParser.g:4620:1: ( () ) |
15688 | // InternalSolverLanguage.g:4569:2: () | 14522 | // InternalSolverLanguageParser.g:4621:2: () |
15689 | { | 14523 | { |
15690 | if ( state.backtracking==0 ) { | 14524 | before(grammarAccess.getExponentialExpressionAccess().getBinaryExpressionLeftAction_1_0()); |
15691 | before(grammarAccess.getExponentialExpressionAccess().getBinaryExpressionLeftAction_1_0()); | 14525 | // InternalSolverLanguageParser.g:4622:2: () |
15692 | } | 14526 | // InternalSolverLanguageParser.g:4622:3: |
15693 | // InternalSolverLanguage.g:4570:2: () | ||
15694 | // InternalSolverLanguage.g:4570:3: | ||
15695 | { | 14527 | { |
15696 | } | 14528 | } |
15697 | 14529 | ||
15698 | if ( state.backtracking==0 ) { | 14530 | after(grammarAccess.getExponentialExpressionAccess().getBinaryExpressionLeftAction_1_0()); |
15699 | after(grammarAccess.getExponentialExpressionAccess().getBinaryExpressionLeftAction_1_0()); | ||
15700 | } | ||
15701 | 14531 | ||
15702 | } | 14532 | } |
15703 | 14533 | ||
@@ -15716,25 +14546,25 @@ public class InternalSolverLanguageParser extends AbstractInternalContentAssistP | |||
15716 | 14546 | ||
15717 | 14547 | ||
15718 | // $ANTLR start "rule__ExponentialExpression__Group_1__1" | 14548 | // $ANTLR start "rule__ExponentialExpression__Group_1__1" |
15719 | // InternalSolverLanguage.g:4578:1: rule__ExponentialExpression__Group_1__1 : rule__ExponentialExpression__Group_1__1__Impl rule__ExponentialExpression__Group_1__2 ; | 14549 | // InternalSolverLanguageParser.g:4630:1: rule__ExponentialExpression__Group_1__1 : rule__ExponentialExpression__Group_1__1__Impl rule__ExponentialExpression__Group_1__2 ; |
15720 | public final void rule__ExponentialExpression__Group_1__1() throws RecognitionException { | 14550 | public final void rule__ExponentialExpression__Group_1__1() throws RecognitionException { |
15721 | 14551 | ||
15722 | int stackSize = keepStackSize(); | 14552 | int stackSize = keepStackSize(); |
15723 | 14553 | ||
15724 | try { | 14554 | try { |
15725 | // InternalSolverLanguage.g:4582:1: ( rule__ExponentialExpression__Group_1__1__Impl rule__ExponentialExpression__Group_1__2 ) | 14555 | // InternalSolverLanguageParser.g:4634:1: ( rule__ExponentialExpression__Group_1__1__Impl rule__ExponentialExpression__Group_1__2 ) |
15726 | // InternalSolverLanguage.g:4583:2: rule__ExponentialExpression__Group_1__1__Impl rule__ExponentialExpression__Group_1__2 | 14556 | // InternalSolverLanguageParser.g:4635:2: rule__ExponentialExpression__Group_1__1__Impl rule__ExponentialExpression__Group_1__2 |
15727 | { | 14557 | { |
15728 | pushFollow(FOLLOW_7); | 14558 | pushFollow(FOLLOW_7); |
15729 | rule__ExponentialExpression__Group_1__1__Impl(); | 14559 | rule__ExponentialExpression__Group_1__1__Impl(); |
15730 | 14560 | ||
15731 | state._fsp--; | 14561 | state._fsp--; |
15732 | if (state.failed) return ; | 14562 | |
15733 | pushFollow(FOLLOW_2); | 14563 | pushFollow(FOLLOW_2); |
15734 | rule__ExponentialExpression__Group_1__2(); | 14564 | rule__ExponentialExpression__Group_1__2(); |
15735 | 14565 | ||
15736 | state._fsp--; | 14566 | state._fsp--; |
15737 | if (state.failed) return ; | 14567 | |
15738 | 14568 | ||
15739 | } | 14569 | } |
15740 | 14570 | ||
@@ -15754,36 +14584,32 @@ public class InternalSolverLanguageParser extends AbstractInternalContentAssistP | |||
15754 | 14584 | ||
15755 | 14585 | ||
15756 | // $ANTLR start "rule__ExponentialExpression__Group_1__1__Impl" | 14586 | // $ANTLR start "rule__ExponentialExpression__Group_1__1__Impl" |
15757 | // InternalSolverLanguage.g:4590:1: rule__ExponentialExpression__Group_1__1__Impl : ( ( rule__ExponentialExpression__OpAssignment_1_1 ) ) ; | 14587 | // InternalSolverLanguageParser.g:4642:1: rule__ExponentialExpression__Group_1__1__Impl : ( ( rule__ExponentialExpression__OpAssignment_1_1 ) ) ; |
15758 | public final void rule__ExponentialExpression__Group_1__1__Impl() throws RecognitionException { | 14588 | public final void rule__ExponentialExpression__Group_1__1__Impl() throws RecognitionException { |
15759 | 14589 | ||
15760 | int stackSize = keepStackSize(); | 14590 | int stackSize = keepStackSize(); |
15761 | 14591 | ||
15762 | try { | 14592 | try { |
15763 | // InternalSolverLanguage.g:4594:1: ( ( ( rule__ExponentialExpression__OpAssignment_1_1 ) ) ) | 14593 | // InternalSolverLanguageParser.g:4646:1: ( ( ( rule__ExponentialExpression__OpAssignment_1_1 ) ) ) |
15764 | // InternalSolverLanguage.g:4595:1: ( ( rule__ExponentialExpression__OpAssignment_1_1 ) ) | 14594 | // InternalSolverLanguageParser.g:4647:1: ( ( rule__ExponentialExpression__OpAssignment_1_1 ) ) |
15765 | { | 14595 | { |
15766 | // InternalSolverLanguage.g:4595:1: ( ( rule__ExponentialExpression__OpAssignment_1_1 ) ) | 14596 | // InternalSolverLanguageParser.g:4647:1: ( ( rule__ExponentialExpression__OpAssignment_1_1 ) ) |
15767 | // InternalSolverLanguage.g:4596:2: ( rule__ExponentialExpression__OpAssignment_1_1 ) | 14597 | // InternalSolverLanguageParser.g:4648:2: ( rule__ExponentialExpression__OpAssignment_1_1 ) |
15768 | { | 14598 | { |
15769 | if ( state.backtracking==0 ) { | 14599 | before(grammarAccess.getExponentialExpressionAccess().getOpAssignment_1_1()); |
15770 | before(grammarAccess.getExponentialExpressionAccess().getOpAssignment_1_1()); | 14600 | // InternalSolverLanguageParser.g:4649:2: ( rule__ExponentialExpression__OpAssignment_1_1 ) |
15771 | } | 14601 | // InternalSolverLanguageParser.g:4649:3: rule__ExponentialExpression__OpAssignment_1_1 |
15772 | // InternalSolverLanguage.g:4597:2: ( rule__ExponentialExpression__OpAssignment_1_1 ) | ||
15773 | // InternalSolverLanguage.g:4597:3: rule__ExponentialExpression__OpAssignment_1_1 | ||
15774 | { | 14602 | { |
15775 | pushFollow(FOLLOW_2); | 14603 | pushFollow(FOLLOW_2); |
15776 | rule__ExponentialExpression__OpAssignment_1_1(); | 14604 | rule__ExponentialExpression__OpAssignment_1_1(); |
15777 | 14605 | ||
15778 | state._fsp--; | 14606 | state._fsp--; |
15779 | if (state.failed) return ; | ||
15780 | 14607 | ||
15781 | } | ||
15782 | 14608 | ||
15783 | if ( state.backtracking==0 ) { | ||
15784 | after(grammarAccess.getExponentialExpressionAccess().getOpAssignment_1_1()); | ||
15785 | } | 14609 | } |
15786 | 14610 | ||
14611 | after(grammarAccess.getExponentialExpressionAccess().getOpAssignment_1_1()); | ||
14612 | |||
15787 | } | 14613 | } |
15788 | 14614 | ||
15789 | 14615 | ||
@@ -15805,20 +14631,20 @@ public class InternalSolverLanguageParser extends AbstractInternalContentAssistP | |||
15805 | 14631 | ||
15806 | 14632 | ||
15807 | // $ANTLR start "rule__ExponentialExpression__Group_1__2" | 14633 | // $ANTLR start "rule__ExponentialExpression__Group_1__2" |
15808 | // InternalSolverLanguage.g:4605:1: rule__ExponentialExpression__Group_1__2 : rule__ExponentialExpression__Group_1__2__Impl ; | 14634 | // InternalSolverLanguageParser.g:4657:1: rule__ExponentialExpression__Group_1__2 : rule__ExponentialExpression__Group_1__2__Impl ; |
15809 | public final void rule__ExponentialExpression__Group_1__2() throws RecognitionException { | 14635 | public final void rule__ExponentialExpression__Group_1__2() throws RecognitionException { |
15810 | 14636 | ||
15811 | int stackSize = keepStackSize(); | 14637 | int stackSize = keepStackSize(); |
15812 | 14638 | ||
15813 | try { | 14639 | try { |
15814 | // InternalSolverLanguage.g:4609:1: ( rule__ExponentialExpression__Group_1__2__Impl ) | 14640 | // InternalSolverLanguageParser.g:4661:1: ( rule__ExponentialExpression__Group_1__2__Impl ) |
15815 | // InternalSolverLanguage.g:4610:2: rule__ExponentialExpression__Group_1__2__Impl | 14641 | // InternalSolverLanguageParser.g:4662:2: rule__ExponentialExpression__Group_1__2__Impl |
15816 | { | 14642 | { |
15817 | pushFollow(FOLLOW_2); | 14643 | pushFollow(FOLLOW_2); |
15818 | rule__ExponentialExpression__Group_1__2__Impl(); | 14644 | rule__ExponentialExpression__Group_1__2__Impl(); |
15819 | 14645 | ||
15820 | state._fsp--; | 14646 | state._fsp--; |
15821 | if (state.failed) return ; | 14647 | |
15822 | 14648 | ||
15823 | } | 14649 | } |
15824 | 14650 | ||
@@ -15838,36 +14664,32 @@ public class InternalSolverLanguageParser extends AbstractInternalContentAssistP | |||
15838 | 14664 | ||
15839 | 14665 | ||
15840 | // $ANTLR start "rule__ExponentialExpression__Group_1__2__Impl" | 14666 | // $ANTLR start "rule__ExponentialExpression__Group_1__2__Impl" |
15841 | // InternalSolverLanguage.g:4616:1: rule__ExponentialExpression__Group_1__2__Impl : ( ( rule__ExponentialExpression__RightAssignment_1_2 ) ) ; | 14667 | // InternalSolverLanguageParser.g:4668:1: rule__ExponentialExpression__Group_1__2__Impl : ( ( rule__ExponentialExpression__RightAssignment_1_2 ) ) ; |
15842 | public final void rule__ExponentialExpression__Group_1__2__Impl() throws RecognitionException { | 14668 | public final void rule__ExponentialExpression__Group_1__2__Impl() throws RecognitionException { |
15843 | 14669 | ||
15844 | int stackSize = keepStackSize(); | 14670 | int stackSize = keepStackSize(); |
15845 | 14671 | ||
15846 | try { | 14672 | try { |
15847 | // InternalSolverLanguage.g:4620:1: ( ( ( rule__ExponentialExpression__RightAssignment_1_2 ) ) ) | 14673 | // InternalSolverLanguageParser.g:4672:1: ( ( ( rule__ExponentialExpression__RightAssignment_1_2 ) ) ) |
15848 | // InternalSolverLanguage.g:4621:1: ( ( rule__ExponentialExpression__RightAssignment_1_2 ) ) | 14674 | // InternalSolverLanguageParser.g:4673:1: ( ( rule__ExponentialExpression__RightAssignment_1_2 ) ) |
15849 | { | 14675 | { |
15850 | // InternalSolverLanguage.g:4621:1: ( ( rule__ExponentialExpression__RightAssignment_1_2 ) ) | 14676 | // InternalSolverLanguageParser.g:4673:1: ( ( rule__ExponentialExpression__RightAssignment_1_2 ) ) |
15851 | // InternalSolverLanguage.g:4622:2: ( rule__ExponentialExpression__RightAssignment_1_2 ) | 14677 | // InternalSolverLanguageParser.g:4674:2: ( rule__ExponentialExpression__RightAssignment_1_2 ) |
15852 | { | 14678 | { |
15853 | if ( state.backtracking==0 ) { | 14679 | before(grammarAccess.getExponentialExpressionAccess().getRightAssignment_1_2()); |
15854 | before(grammarAccess.getExponentialExpressionAccess().getRightAssignment_1_2()); | 14680 | // InternalSolverLanguageParser.g:4675:2: ( rule__ExponentialExpression__RightAssignment_1_2 ) |
15855 | } | 14681 | // InternalSolverLanguageParser.g:4675:3: rule__ExponentialExpression__RightAssignment_1_2 |
15856 | // InternalSolverLanguage.g:4623:2: ( rule__ExponentialExpression__RightAssignment_1_2 ) | ||
15857 | // InternalSolverLanguage.g:4623:3: rule__ExponentialExpression__RightAssignment_1_2 | ||
15858 | { | 14682 | { |
15859 | pushFollow(FOLLOW_2); | 14683 | pushFollow(FOLLOW_2); |
15860 | rule__ExponentialExpression__RightAssignment_1_2(); | 14684 | rule__ExponentialExpression__RightAssignment_1_2(); |
15861 | 14685 | ||
15862 | state._fsp--; | 14686 | state._fsp--; |
15863 | if (state.failed) return ; | ||
15864 | 14687 | ||
15865 | } | ||
15866 | 14688 | ||
15867 | if ( state.backtracking==0 ) { | ||
15868 | after(grammarAccess.getExponentialExpressionAccess().getRightAssignment_1_2()); | ||
15869 | } | 14689 | } |
15870 | 14690 | ||
14691 | after(grammarAccess.getExponentialExpressionAccess().getRightAssignment_1_2()); | ||
14692 | |||
15871 | } | 14693 | } |
15872 | 14694 | ||
15873 | 14695 | ||
@@ -15889,25 +14711,25 @@ public class InternalSolverLanguageParser extends AbstractInternalContentAssistP | |||
15889 | 14711 | ||
15890 | 14712 | ||
15891 | // $ANTLR start "rule__UnaryExpression__Group_1__0" | 14713 | // $ANTLR start "rule__UnaryExpression__Group_1__0" |
15892 | // InternalSolverLanguage.g:4632:1: rule__UnaryExpression__Group_1__0 : rule__UnaryExpression__Group_1__0__Impl rule__UnaryExpression__Group_1__1 ; | 14714 | // InternalSolverLanguageParser.g:4684:1: rule__UnaryExpression__Group_1__0 : rule__UnaryExpression__Group_1__0__Impl rule__UnaryExpression__Group_1__1 ; |
15893 | public final void rule__UnaryExpression__Group_1__0() throws RecognitionException { | 14715 | public final void rule__UnaryExpression__Group_1__0() throws RecognitionException { |
15894 | 14716 | ||
15895 | int stackSize = keepStackSize(); | 14717 | int stackSize = keepStackSize(); |
15896 | 14718 | ||
15897 | try { | 14719 | try { |
15898 | // InternalSolverLanguage.g:4636:1: ( rule__UnaryExpression__Group_1__0__Impl rule__UnaryExpression__Group_1__1 ) | 14720 | // InternalSolverLanguageParser.g:4688:1: ( rule__UnaryExpression__Group_1__0__Impl rule__UnaryExpression__Group_1__1 ) |
15899 | // InternalSolverLanguage.g:4637:2: rule__UnaryExpression__Group_1__0__Impl rule__UnaryExpression__Group_1__1 | 14721 | // InternalSolverLanguageParser.g:4689:2: rule__UnaryExpression__Group_1__0__Impl rule__UnaryExpression__Group_1__1 |
15900 | { | 14722 | { |
15901 | pushFollow(FOLLOW_7); | 14723 | pushFollow(FOLLOW_7); |
15902 | rule__UnaryExpression__Group_1__0__Impl(); | 14724 | rule__UnaryExpression__Group_1__0__Impl(); |
15903 | 14725 | ||
15904 | state._fsp--; | 14726 | state._fsp--; |
15905 | if (state.failed) return ; | 14727 | |
15906 | pushFollow(FOLLOW_2); | 14728 | pushFollow(FOLLOW_2); |
15907 | rule__UnaryExpression__Group_1__1(); | 14729 | rule__UnaryExpression__Group_1__1(); |
15908 | 14730 | ||
15909 | state._fsp--; | 14731 | state._fsp--; |
15910 | if (state.failed) return ; | 14732 | |
15911 | 14733 | ||
15912 | } | 14734 | } |
15913 | 14735 | ||
@@ -15927,29 +14749,25 @@ public class InternalSolverLanguageParser extends AbstractInternalContentAssistP | |||
15927 | 14749 | ||
15928 | 14750 | ||
15929 | // $ANTLR start "rule__UnaryExpression__Group_1__0__Impl" | 14751 | // $ANTLR start "rule__UnaryExpression__Group_1__0__Impl" |
15930 | // InternalSolverLanguage.g:4644:1: rule__UnaryExpression__Group_1__0__Impl : ( () ) ; | 14752 | // InternalSolverLanguageParser.g:4696:1: rule__UnaryExpression__Group_1__0__Impl : ( () ) ; |
15931 | public final void rule__UnaryExpression__Group_1__0__Impl() throws RecognitionException { | 14753 | public final void rule__UnaryExpression__Group_1__0__Impl() throws RecognitionException { |
15932 | 14754 | ||
15933 | int stackSize = keepStackSize(); | 14755 | int stackSize = keepStackSize(); |
15934 | 14756 | ||
15935 | try { | 14757 | try { |
15936 | // InternalSolverLanguage.g:4648:1: ( ( () ) ) | 14758 | // InternalSolverLanguageParser.g:4700:1: ( ( () ) ) |
15937 | // InternalSolverLanguage.g:4649:1: ( () ) | 14759 | // InternalSolverLanguageParser.g:4701:1: ( () ) |
15938 | { | 14760 | { |
15939 | // InternalSolverLanguage.g:4649:1: ( () ) | 14761 | // InternalSolverLanguageParser.g:4701:1: ( () ) |
15940 | // InternalSolverLanguage.g:4650:2: () | 14762 | // InternalSolverLanguageParser.g:4702:2: () |
15941 | { | 14763 | { |
15942 | if ( state.backtracking==0 ) { | 14764 | before(grammarAccess.getUnaryExpressionAccess().getUnaryExpressionAction_1_0()); |
15943 | before(grammarAccess.getUnaryExpressionAccess().getUnaryExpressionAction_1_0()); | 14765 | // InternalSolverLanguageParser.g:4703:2: () |
15944 | } | 14766 | // InternalSolverLanguageParser.g:4703:3: |
15945 | // InternalSolverLanguage.g:4651:2: () | ||
15946 | // InternalSolverLanguage.g:4651:3: | ||
15947 | { | 14767 | { |
15948 | } | 14768 | } |
15949 | 14769 | ||
15950 | if ( state.backtracking==0 ) { | 14770 | after(grammarAccess.getUnaryExpressionAccess().getUnaryExpressionAction_1_0()); |
15951 | after(grammarAccess.getUnaryExpressionAccess().getUnaryExpressionAction_1_0()); | ||
15952 | } | ||
15953 | 14771 | ||
15954 | } | 14772 | } |
15955 | 14773 | ||
@@ -15968,25 +14786,25 @@ public class InternalSolverLanguageParser extends AbstractInternalContentAssistP | |||
15968 | 14786 | ||
15969 | 14787 | ||
15970 | // $ANTLR start "rule__UnaryExpression__Group_1__1" | 14788 | // $ANTLR start "rule__UnaryExpression__Group_1__1" |
15971 | // InternalSolverLanguage.g:4659:1: rule__UnaryExpression__Group_1__1 : rule__UnaryExpression__Group_1__1__Impl rule__UnaryExpression__Group_1__2 ; | 14789 | // InternalSolverLanguageParser.g:4711:1: rule__UnaryExpression__Group_1__1 : rule__UnaryExpression__Group_1__1__Impl rule__UnaryExpression__Group_1__2 ; |
15972 | public final void rule__UnaryExpression__Group_1__1() throws RecognitionException { | 14790 | public final void rule__UnaryExpression__Group_1__1() throws RecognitionException { |
15973 | 14791 | ||
15974 | int stackSize = keepStackSize(); | 14792 | int stackSize = keepStackSize(); |
15975 | 14793 | ||
15976 | try { | 14794 | try { |
15977 | // InternalSolverLanguage.g:4663:1: ( rule__UnaryExpression__Group_1__1__Impl rule__UnaryExpression__Group_1__2 ) | 14795 | // InternalSolverLanguageParser.g:4715:1: ( rule__UnaryExpression__Group_1__1__Impl rule__UnaryExpression__Group_1__2 ) |
15978 | // InternalSolverLanguage.g:4664:2: rule__UnaryExpression__Group_1__1__Impl rule__UnaryExpression__Group_1__2 | 14796 | // InternalSolverLanguageParser.g:4716:2: rule__UnaryExpression__Group_1__1__Impl rule__UnaryExpression__Group_1__2 |
15979 | { | 14797 | { |
15980 | pushFollow(FOLLOW_30); | 14798 | pushFollow(FOLLOW_29); |
15981 | rule__UnaryExpression__Group_1__1__Impl(); | 14799 | rule__UnaryExpression__Group_1__1__Impl(); |
15982 | 14800 | ||
15983 | state._fsp--; | 14801 | state._fsp--; |
15984 | if (state.failed) return ; | 14802 | |
15985 | pushFollow(FOLLOW_2); | 14803 | pushFollow(FOLLOW_2); |
15986 | rule__UnaryExpression__Group_1__2(); | 14804 | rule__UnaryExpression__Group_1__2(); |
15987 | 14805 | ||
15988 | state._fsp--; | 14806 | state._fsp--; |
15989 | if (state.failed) return ; | 14807 | |
15990 | 14808 | ||
15991 | } | 14809 | } |
15992 | 14810 | ||
@@ -16006,36 +14824,32 @@ public class InternalSolverLanguageParser extends AbstractInternalContentAssistP | |||
16006 | 14824 | ||
16007 | 14825 | ||
16008 | // $ANTLR start "rule__UnaryExpression__Group_1__1__Impl" | 14826 | // $ANTLR start "rule__UnaryExpression__Group_1__1__Impl" |
16009 | // InternalSolverLanguage.g:4671:1: rule__UnaryExpression__Group_1__1__Impl : ( ( rule__UnaryExpression__OpAssignment_1_1 ) ) ; | 14827 | // InternalSolverLanguageParser.g:4723:1: rule__UnaryExpression__Group_1__1__Impl : ( ( rule__UnaryExpression__OpAssignment_1_1 ) ) ; |
16010 | public final void rule__UnaryExpression__Group_1__1__Impl() throws RecognitionException { | 14828 | public final void rule__UnaryExpression__Group_1__1__Impl() throws RecognitionException { |
16011 | 14829 | ||
16012 | int stackSize = keepStackSize(); | 14830 | int stackSize = keepStackSize(); |
16013 | 14831 | ||
16014 | try { | 14832 | try { |
16015 | // InternalSolverLanguage.g:4675:1: ( ( ( rule__UnaryExpression__OpAssignment_1_1 ) ) ) | 14833 | // InternalSolverLanguageParser.g:4727:1: ( ( ( rule__UnaryExpression__OpAssignment_1_1 ) ) ) |
16016 | // InternalSolverLanguage.g:4676:1: ( ( rule__UnaryExpression__OpAssignment_1_1 ) ) | 14834 | // InternalSolverLanguageParser.g:4728:1: ( ( rule__UnaryExpression__OpAssignment_1_1 ) ) |
16017 | { | 14835 | { |
16018 | // InternalSolverLanguage.g:4676:1: ( ( rule__UnaryExpression__OpAssignment_1_1 ) ) | 14836 | // InternalSolverLanguageParser.g:4728:1: ( ( rule__UnaryExpression__OpAssignment_1_1 ) ) |
16019 | // InternalSolverLanguage.g:4677:2: ( rule__UnaryExpression__OpAssignment_1_1 ) | 14837 | // InternalSolverLanguageParser.g:4729:2: ( rule__UnaryExpression__OpAssignment_1_1 ) |
16020 | { | 14838 | { |
16021 | if ( state.backtracking==0 ) { | 14839 | before(grammarAccess.getUnaryExpressionAccess().getOpAssignment_1_1()); |
16022 | before(grammarAccess.getUnaryExpressionAccess().getOpAssignment_1_1()); | 14840 | // InternalSolverLanguageParser.g:4730:2: ( rule__UnaryExpression__OpAssignment_1_1 ) |
16023 | } | 14841 | // InternalSolverLanguageParser.g:4730:3: rule__UnaryExpression__OpAssignment_1_1 |
16024 | // InternalSolverLanguage.g:4678:2: ( rule__UnaryExpression__OpAssignment_1_1 ) | ||
16025 | // InternalSolverLanguage.g:4678:3: rule__UnaryExpression__OpAssignment_1_1 | ||
16026 | { | 14842 | { |
16027 | pushFollow(FOLLOW_2); | 14843 | pushFollow(FOLLOW_2); |
16028 | rule__UnaryExpression__OpAssignment_1_1(); | 14844 | rule__UnaryExpression__OpAssignment_1_1(); |
16029 | 14845 | ||
16030 | state._fsp--; | 14846 | state._fsp--; |
16031 | if (state.failed) return ; | ||
16032 | 14847 | ||
16033 | } | ||
16034 | 14848 | ||
16035 | if ( state.backtracking==0 ) { | ||
16036 | after(grammarAccess.getUnaryExpressionAccess().getOpAssignment_1_1()); | ||
16037 | } | 14849 | } |
16038 | 14850 | ||
14851 | after(grammarAccess.getUnaryExpressionAccess().getOpAssignment_1_1()); | ||
14852 | |||
16039 | } | 14853 | } |
16040 | 14854 | ||
16041 | 14855 | ||
@@ -16057,20 +14871,20 @@ public class InternalSolverLanguageParser extends AbstractInternalContentAssistP | |||
16057 | 14871 | ||
16058 | 14872 | ||
16059 | // $ANTLR start "rule__UnaryExpression__Group_1__2" | 14873 | // $ANTLR start "rule__UnaryExpression__Group_1__2" |
16060 | // InternalSolverLanguage.g:4686:1: rule__UnaryExpression__Group_1__2 : rule__UnaryExpression__Group_1__2__Impl ; | 14874 | // InternalSolverLanguageParser.g:4738:1: rule__UnaryExpression__Group_1__2 : rule__UnaryExpression__Group_1__2__Impl ; |
16061 | public final void rule__UnaryExpression__Group_1__2() throws RecognitionException { | 14875 | public final void rule__UnaryExpression__Group_1__2() throws RecognitionException { |
16062 | 14876 | ||
16063 | int stackSize = keepStackSize(); | 14877 | int stackSize = keepStackSize(); |
16064 | 14878 | ||
16065 | try { | 14879 | try { |
16066 | // InternalSolverLanguage.g:4690:1: ( rule__UnaryExpression__Group_1__2__Impl ) | 14880 | // InternalSolverLanguageParser.g:4742:1: ( rule__UnaryExpression__Group_1__2__Impl ) |
16067 | // InternalSolverLanguage.g:4691:2: rule__UnaryExpression__Group_1__2__Impl | 14881 | // InternalSolverLanguageParser.g:4743:2: rule__UnaryExpression__Group_1__2__Impl |
16068 | { | 14882 | { |
16069 | pushFollow(FOLLOW_2); | 14883 | pushFollow(FOLLOW_2); |
16070 | rule__UnaryExpression__Group_1__2__Impl(); | 14884 | rule__UnaryExpression__Group_1__2__Impl(); |
16071 | 14885 | ||
16072 | state._fsp--; | 14886 | state._fsp--; |
16073 | if (state.failed) return ; | 14887 | |
16074 | 14888 | ||
16075 | } | 14889 | } |
16076 | 14890 | ||
@@ -16090,36 +14904,32 @@ public class InternalSolverLanguageParser extends AbstractInternalContentAssistP | |||
16090 | 14904 | ||
16091 | 14905 | ||
16092 | // $ANTLR start "rule__UnaryExpression__Group_1__2__Impl" | 14906 | // $ANTLR start "rule__UnaryExpression__Group_1__2__Impl" |
16093 | // InternalSolverLanguage.g:4697:1: rule__UnaryExpression__Group_1__2__Impl : ( ( rule__UnaryExpression__BodyAssignment_1_2 ) ) ; | 14907 | // InternalSolverLanguageParser.g:4749:1: rule__UnaryExpression__Group_1__2__Impl : ( ( rule__UnaryExpression__BodyAssignment_1_2 ) ) ; |
16094 | public final void rule__UnaryExpression__Group_1__2__Impl() throws RecognitionException { | 14908 | public final void rule__UnaryExpression__Group_1__2__Impl() throws RecognitionException { |
16095 | 14909 | ||
16096 | int stackSize = keepStackSize(); | 14910 | int stackSize = keepStackSize(); |
16097 | 14911 | ||
16098 | try { | 14912 | try { |
16099 | // InternalSolverLanguage.g:4701:1: ( ( ( rule__UnaryExpression__BodyAssignment_1_2 ) ) ) | 14913 | // InternalSolverLanguageParser.g:4753:1: ( ( ( rule__UnaryExpression__BodyAssignment_1_2 ) ) ) |
16100 | // InternalSolverLanguage.g:4702:1: ( ( rule__UnaryExpression__BodyAssignment_1_2 ) ) | 14914 | // InternalSolverLanguageParser.g:4754:1: ( ( rule__UnaryExpression__BodyAssignment_1_2 ) ) |
16101 | { | 14915 | { |
16102 | // InternalSolverLanguage.g:4702:1: ( ( rule__UnaryExpression__BodyAssignment_1_2 ) ) | 14916 | // InternalSolverLanguageParser.g:4754:1: ( ( rule__UnaryExpression__BodyAssignment_1_2 ) ) |
16103 | // InternalSolverLanguage.g:4703:2: ( rule__UnaryExpression__BodyAssignment_1_2 ) | 14917 | // InternalSolverLanguageParser.g:4755:2: ( rule__UnaryExpression__BodyAssignment_1_2 ) |
16104 | { | 14918 | { |
16105 | if ( state.backtracking==0 ) { | 14919 | before(grammarAccess.getUnaryExpressionAccess().getBodyAssignment_1_2()); |
16106 | before(grammarAccess.getUnaryExpressionAccess().getBodyAssignment_1_2()); | 14920 | // InternalSolverLanguageParser.g:4756:2: ( rule__UnaryExpression__BodyAssignment_1_2 ) |
16107 | } | 14921 | // InternalSolverLanguageParser.g:4756:3: rule__UnaryExpression__BodyAssignment_1_2 |
16108 | // InternalSolverLanguage.g:4704:2: ( rule__UnaryExpression__BodyAssignment_1_2 ) | ||
16109 | // InternalSolverLanguage.g:4704:3: rule__UnaryExpression__BodyAssignment_1_2 | ||
16110 | { | 14922 | { |
16111 | pushFollow(FOLLOW_2); | 14923 | pushFollow(FOLLOW_2); |
16112 | rule__UnaryExpression__BodyAssignment_1_2(); | 14924 | rule__UnaryExpression__BodyAssignment_1_2(); |
16113 | 14925 | ||
16114 | state._fsp--; | 14926 | state._fsp--; |
16115 | if (state.failed) return ; | ||
16116 | 14927 | ||
16117 | } | ||
16118 | 14928 | ||
16119 | if ( state.backtracking==0 ) { | ||
16120 | after(grammarAccess.getUnaryExpressionAccess().getBodyAssignment_1_2()); | ||
16121 | } | 14929 | } |
16122 | 14930 | ||
14931 | after(grammarAccess.getUnaryExpressionAccess().getBodyAssignment_1_2()); | ||
14932 | |||
16123 | } | 14933 | } |
16124 | 14934 | ||
16125 | 14935 | ||
@@ -16141,25 +14951,25 @@ public class InternalSolverLanguageParser extends AbstractInternalContentAssistP | |||
16141 | 14951 | ||
16142 | 14952 | ||
16143 | // $ANTLR start "rule__Count__Group__0" | 14953 | // $ANTLR start "rule__Count__Group__0" |
16144 | // InternalSolverLanguage.g:4713:1: rule__Count__Group__0 : rule__Count__Group__0__Impl rule__Count__Group__1 ; | 14954 | // InternalSolverLanguageParser.g:4765:1: rule__Count__Group__0 : rule__Count__Group__0__Impl rule__Count__Group__1 ; |
16145 | public final void rule__Count__Group__0() throws RecognitionException { | 14955 | public final void rule__Count__Group__0() throws RecognitionException { |
16146 | 14956 | ||
16147 | int stackSize = keepStackSize(); | 14957 | int stackSize = keepStackSize(); |
16148 | 14958 | ||
16149 | try { | 14959 | try { |
16150 | // InternalSolverLanguage.g:4717:1: ( rule__Count__Group__0__Impl rule__Count__Group__1 ) | 14960 | // InternalSolverLanguageParser.g:4769:1: ( rule__Count__Group__0__Impl rule__Count__Group__1 ) |
16151 | // InternalSolverLanguage.g:4718:2: rule__Count__Group__0__Impl rule__Count__Group__1 | 14961 | // InternalSolverLanguageParser.g:4770:2: rule__Count__Group__0__Impl rule__Count__Group__1 |
16152 | { | 14962 | { |
16153 | pushFollow(FOLLOW_31); | 14963 | pushFollow(FOLLOW_30); |
16154 | rule__Count__Group__0__Impl(); | 14964 | rule__Count__Group__0__Impl(); |
16155 | 14965 | ||
16156 | state._fsp--; | 14966 | state._fsp--; |
16157 | if (state.failed) return ; | 14967 | |
16158 | pushFollow(FOLLOW_2); | 14968 | pushFollow(FOLLOW_2); |
16159 | rule__Count__Group__1(); | 14969 | rule__Count__Group__1(); |
16160 | 14970 | ||
16161 | state._fsp--; | 14971 | state._fsp--; |
16162 | if (state.failed) return ; | 14972 | |
16163 | 14973 | ||
16164 | } | 14974 | } |
16165 | 14975 | ||
@@ -16179,25 +14989,21 @@ public class InternalSolverLanguageParser extends AbstractInternalContentAssistP | |||
16179 | 14989 | ||
16180 | 14990 | ||
16181 | // $ANTLR start "rule__Count__Group__0__Impl" | 14991 | // $ANTLR start "rule__Count__Group__0__Impl" |
16182 | // InternalSolverLanguage.g:4725:1: rule__Count__Group__0__Impl : ( 'count' ) ; | 14992 | // InternalSolverLanguageParser.g:4777:1: rule__Count__Group__0__Impl : ( Count ) ; |
16183 | public final void rule__Count__Group__0__Impl() throws RecognitionException { | 14993 | public final void rule__Count__Group__0__Impl() throws RecognitionException { |
16184 | 14994 | ||
16185 | int stackSize = keepStackSize(); | 14995 | int stackSize = keepStackSize(); |
16186 | 14996 | ||
16187 | try { | 14997 | try { |
16188 | // InternalSolverLanguage.g:4729:1: ( ( 'count' ) ) | 14998 | // InternalSolverLanguageParser.g:4781:1: ( ( Count ) ) |
16189 | // InternalSolverLanguage.g:4730:1: ( 'count' ) | 14999 | // InternalSolverLanguageParser.g:4782:1: ( Count ) |
16190 | { | 15000 | { |
16191 | // InternalSolverLanguage.g:4730:1: ( 'count' ) | 15001 | // InternalSolverLanguageParser.g:4782:1: ( Count ) |
16192 | // InternalSolverLanguage.g:4731:2: 'count' | 15002 | // InternalSolverLanguageParser.g:4783:2: Count |
16193 | { | 15003 | { |
16194 | if ( state.backtracking==0 ) { | 15004 | before(grammarAccess.getCountAccess().getCountKeyword_0()); |
16195 | before(grammarAccess.getCountAccess().getCountKeyword_0()); | 15005 | match(input,Count,FOLLOW_2); |
16196 | } | 15006 | after(grammarAccess.getCountAccess().getCountKeyword_0()); |
16197 | match(input,57,FOLLOW_2); if (state.failed) return ; | ||
16198 | if ( state.backtracking==0 ) { | ||
16199 | after(grammarAccess.getCountAccess().getCountKeyword_0()); | ||
16200 | } | ||
16201 | 15007 | ||
16202 | } | 15008 | } |
16203 | 15009 | ||
@@ -16220,25 +15026,25 @@ public class InternalSolverLanguageParser extends AbstractInternalContentAssistP | |||
16220 | 15026 | ||
16221 | 15027 | ||
16222 | // $ANTLR start "rule__Count__Group__1" | 15028 | // $ANTLR start "rule__Count__Group__1" |
16223 | // InternalSolverLanguage.g:4740:1: rule__Count__Group__1 : rule__Count__Group__1__Impl rule__Count__Group__2 ; | 15029 | // InternalSolverLanguageParser.g:4792:1: rule__Count__Group__1 : rule__Count__Group__1__Impl rule__Count__Group__2 ; |
16224 | public final void rule__Count__Group__1() throws RecognitionException { | 15030 | public final void rule__Count__Group__1() throws RecognitionException { |
16225 | 15031 | ||
16226 | int stackSize = keepStackSize(); | 15032 | int stackSize = keepStackSize(); |
16227 | 15033 | ||
16228 | try { | 15034 | try { |
16229 | // InternalSolverLanguage.g:4744:1: ( rule__Count__Group__1__Impl rule__Count__Group__2 ) | 15035 | // InternalSolverLanguageParser.g:4796:1: ( rule__Count__Group__1__Impl rule__Count__Group__2 ) |
16230 | // InternalSolverLanguage.g:4745:2: rule__Count__Group__1__Impl rule__Count__Group__2 | 15036 | // InternalSolverLanguageParser.g:4797:2: rule__Count__Group__1__Impl rule__Count__Group__2 |
16231 | { | 15037 | { |
16232 | pushFollow(FOLLOW_7); | 15038 | pushFollow(FOLLOW_7); |
16233 | rule__Count__Group__1__Impl(); | 15039 | rule__Count__Group__1__Impl(); |
16234 | 15040 | ||
16235 | state._fsp--; | 15041 | state._fsp--; |
16236 | if (state.failed) return ; | 15042 | |
16237 | pushFollow(FOLLOW_2); | 15043 | pushFollow(FOLLOW_2); |
16238 | rule__Count__Group__2(); | 15044 | rule__Count__Group__2(); |
16239 | 15045 | ||
16240 | state._fsp--; | 15046 | state._fsp--; |
16241 | if (state.failed) return ; | 15047 | |
16242 | 15048 | ||
16243 | } | 15049 | } |
16244 | 15050 | ||
@@ -16258,25 +15064,21 @@ public class InternalSolverLanguageParser extends AbstractInternalContentAssistP | |||
16258 | 15064 | ||
16259 | 15065 | ||
16260 | // $ANTLR start "rule__Count__Group__1__Impl" | 15066 | // $ANTLR start "rule__Count__Group__1__Impl" |
16261 | // InternalSolverLanguage.g:4752:1: rule__Count__Group__1__Impl : ( '{' ) ; | 15067 | // InternalSolverLanguageParser.g:4804:1: rule__Count__Group__1__Impl : ( LeftCurlyBracket ) ; |
16262 | public final void rule__Count__Group__1__Impl() throws RecognitionException { | 15068 | public final void rule__Count__Group__1__Impl() throws RecognitionException { |
16263 | 15069 | ||
16264 | int stackSize = keepStackSize(); | 15070 | int stackSize = keepStackSize(); |
16265 | 15071 | ||
16266 | try { | 15072 | try { |
16267 | // InternalSolverLanguage.g:4756:1: ( ( '{' ) ) | 15073 | // InternalSolverLanguageParser.g:4808:1: ( ( LeftCurlyBracket ) ) |
16268 | // InternalSolverLanguage.g:4757:1: ( '{' ) | 15074 | // InternalSolverLanguageParser.g:4809:1: ( LeftCurlyBracket ) |
16269 | { | 15075 | { |
16270 | // InternalSolverLanguage.g:4757:1: ( '{' ) | 15076 | // InternalSolverLanguageParser.g:4809:1: ( LeftCurlyBracket ) |
16271 | // InternalSolverLanguage.g:4758:2: '{' | 15077 | // InternalSolverLanguageParser.g:4810:2: LeftCurlyBracket |
16272 | { | 15078 | { |
16273 | if ( state.backtracking==0 ) { | 15079 | before(grammarAccess.getCountAccess().getLeftCurlyBracketKeyword_1()); |
16274 | before(grammarAccess.getCountAccess().getLeftCurlyBracketKeyword_1()); | 15080 | match(input,LeftCurlyBracket,FOLLOW_2); |
16275 | } | 15081 | after(grammarAccess.getCountAccess().getLeftCurlyBracketKeyword_1()); |
16276 | match(input,58,FOLLOW_2); if (state.failed) return ; | ||
16277 | if ( state.backtracking==0 ) { | ||
16278 | after(grammarAccess.getCountAccess().getLeftCurlyBracketKeyword_1()); | ||
16279 | } | ||
16280 | 15082 | ||
16281 | } | 15083 | } |
16282 | 15084 | ||
@@ -16299,25 +15101,25 @@ public class InternalSolverLanguageParser extends AbstractInternalContentAssistP | |||
16299 | 15101 | ||
16300 | 15102 | ||
16301 | // $ANTLR start "rule__Count__Group__2" | 15103 | // $ANTLR start "rule__Count__Group__2" |
16302 | // InternalSolverLanguage.g:4767:1: rule__Count__Group__2 : rule__Count__Group__2__Impl rule__Count__Group__3 ; | 15104 | // InternalSolverLanguageParser.g:4819:1: rule__Count__Group__2 : rule__Count__Group__2__Impl rule__Count__Group__3 ; |
16303 | public final void rule__Count__Group__2() throws RecognitionException { | 15105 | public final void rule__Count__Group__2() throws RecognitionException { |
16304 | 15106 | ||
16305 | int stackSize = keepStackSize(); | 15107 | int stackSize = keepStackSize(); |
16306 | 15108 | ||
16307 | try { | 15109 | try { |
16308 | // InternalSolverLanguage.g:4771:1: ( rule__Count__Group__2__Impl rule__Count__Group__3 ) | 15110 | // InternalSolverLanguageParser.g:4823:1: ( rule__Count__Group__2__Impl rule__Count__Group__3 ) |
16309 | // InternalSolverLanguage.g:4772:2: rule__Count__Group__2__Impl rule__Count__Group__3 | 15111 | // InternalSolverLanguageParser.g:4824:2: rule__Count__Group__2__Impl rule__Count__Group__3 |
16310 | { | 15112 | { |
16311 | pushFollow(FOLLOW_32); | 15113 | pushFollow(FOLLOW_31); |
16312 | rule__Count__Group__2__Impl(); | 15114 | rule__Count__Group__2__Impl(); |
16313 | 15115 | ||
16314 | state._fsp--; | 15116 | state._fsp--; |
16315 | if (state.failed) return ; | 15117 | |
16316 | pushFollow(FOLLOW_2); | 15118 | pushFollow(FOLLOW_2); |
16317 | rule__Count__Group__3(); | 15119 | rule__Count__Group__3(); |
16318 | 15120 | ||
16319 | state._fsp--; | 15121 | state._fsp--; |
16320 | if (state.failed) return ; | 15122 | |
16321 | 15123 | ||
16322 | } | 15124 | } |
16323 | 15125 | ||
@@ -16337,36 +15139,32 @@ public class InternalSolverLanguageParser extends AbstractInternalContentAssistP | |||
16337 | 15139 | ||
16338 | 15140 | ||
16339 | // $ANTLR start "rule__Count__Group__2__Impl" | 15141 | // $ANTLR start "rule__Count__Group__2__Impl" |
16340 | // InternalSolverLanguage.g:4779:1: rule__Count__Group__2__Impl : ( ( rule__Count__BodyAssignment_2 ) ) ; | 15142 | // InternalSolverLanguageParser.g:4831:1: rule__Count__Group__2__Impl : ( ( rule__Count__BodyAssignment_2 ) ) ; |
16341 | public final void rule__Count__Group__2__Impl() throws RecognitionException { | 15143 | public final void rule__Count__Group__2__Impl() throws RecognitionException { |
16342 | 15144 | ||
16343 | int stackSize = keepStackSize(); | 15145 | int stackSize = keepStackSize(); |
16344 | 15146 | ||
16345 | try { | 15147 | try { |
16346 | // InternalSolverLanguage.g:4783:1: ( ( ( rule__Count__BodyAssignment_2 ) ) ) | 15148 | // InternalSolverLanguageParser.g:4835:1: ( ( ( rule__Count__BodyAssignment_2 ) ) ) |
16347 | // InternalSolverLanguage.g:4784:1: ( ( rule__Count__BodyAssignment_2 ) ) | 15149 | // InternalSolverLanguageParser.g:4836:1: ( ( rule__Count__BodyAssignment_2 ) ) |
16348 | { | 15150 | { |
16349 | // InternalSolverLanguage.g:4784:1: ( ( rule__Count__BodyAssignment_2 ) ) | 15151 | // InternalSolverLanguageParser.g:4836:1: ( ( rule__Count__BodyAssignment_2 ) ) |
16350 | // InternalSolverLanguage.g:4785:2: ( rule__Count__BodyAssignment_2 ) | 15152 | // InternalSolverLanguageParser.g:4837:2: ( rule__Count__BodyAssignment_2 ) |
16351 | { | 15153 | { |
16352 | if ( state.backtracking==0 ) { | 15154 | before(grammarAccess.getCountAccess().getBodyAssignment_2()); |
16353 | before(grammarAccess.getCountAccess().getBodyAssignment_2()); | 15155 | // InternalSolverLanguageParser.g:4838:2: ( rule__Count__BodyAssignment_2 ) |
16354 | } | 15156 | // InternalSolverLanguageParser.g:4838:3: rule__Count__BodyAssignment_2 |
16355 | // InternalSolverLanguage.g:4786:2: ( rule__Count__BodyAssignment_2 ) | ||
16356 | // InternalSolverLanguage.g:4786:3: rule__Count__BodyAssignment_2 | ||
16357 | { | 15157 | { |
16358 | pushFollow(FOLLOW_2); | 15158 | pushFollow(FOLLOW_2); |
16359 | rule__Count__BodyAssignment_2(); | 15159 | rule__Count__BodyAssignment_2(); |
16360 | 15160 | ||
16361 | state._fsp--; | 15161 | state._fsp--; |
16362 | if (state.failed) return ; | ||
16363 | 15162 | ||
16364 | } | ||
16365 | 15163 | ||
16366 | if ( state.backtracking==0 ) { | ||
16367 | after(grammarAccess.getCountAccess().getBodyAssignment_2()); | ||
16368 | } | 15164 | } |
16369 | 15165 | ||
15166 | after(grammarAccess.getCountAccess().getBodyAssignment_2()); | ||
15167 | |||
16370 | } | 15168 | } |
16371 | 15169 | ||
16372 | 15170 | ||
@@ -16388,20 +15186,20 @@ public class InternalSolverLanguageParser extends AbstractInternalContentAssistP | |||
16388 | 15186 | ||
16389 | 15187 | ||
16390 | // $ANTLR start "rule__Count__Group__3" | 15188 | // $ANTLR start "rule__Count__Group__3" |
16391 | // InternalSolverLanguage.g:4794:1: rule__Count__Group__3 : rule__Count__Group__3__Impl ; | 15189 | // InternalSolverLanguageParser.g:4846:1: rule__Count__Group__3 : rule__Count__Group__3__Impl ; |
16392 | public final void rule__Count__Group__3() throws RecognitionException { | 15190 | public final void rule__Count__Group__3() throws RecognitionException { |
16393 | 15191 | ||
16394 | int stackSize = keepStackSize(); | 15192 | int stackSize = keepStackSize(); |
16395 | 15193 | ||
16396 | try { | 15194 | try { |
16397 | // InternalSolverLanguage.g:4798:1: ( rule__Count__Group__3__Impl ) | 15195 | // InternalSolverLanguageParser.g:4850:1: ( rule__Count__Group__3__Impl ) |
16398 | // InternalSolverLanguage.g:4799:2: rule__Count__Group__3__Impl | 15196 | // InternalSolverLanguageParser.g:4851:2: rule__Count__Group__3__Impl |
16399 | { | 15197 | { |
16400 | pushFollow(FOLLOW_2); | 15198 | pushFollow(FOLLOW_2); |
16401 | rule__Count__Group__3__Impl(); | 15199 | rule__Count__Group__3__Impl(); |
16402 | 15200 | ||
16403 | state._fsp--; | 15201 | state._fsp--; |
16404 | if (state.failed) return ; | 15202 | |
16405 | 15203 | ||
16406 | } | 15204 | } |
16407 | 15205 | ||
@@ -16421,25 +15219,21 @@ public class InternalSolverLanguageParser extends AbstractInternalContentAssistP | |||
16421 | 15219 | ||
16422 | 15220 | ||
16423 | // $ANTLR start "rule__Count__Group__3__Impl" | 15221 | // $ANTLR start "rule__Count__Group__3__Impl" |
16424 | // InternalSolverLanguage.g:4805:1: rule__Count__Group__3__Impl : ( '}' ) ; | 15222 | // InternalSolverLanguageParser.g:4857:1: rule__Count__Group__3__Impl : ( RightCurlyBracket ) ; |
16425 | public final void rule__Count__Group__3__Impl() throws RecognitionException { | 15223 | public final void rule__Count__Group__3__Impl() throws RecognitionException { |
16426 | 15224 | ||
16427 | int stackSize = keepStackSize(); | 15225 | int stackSize = keepStackSize(); |
16428 | 15226 | ||
16429 | try { | 15227 | try { |
16430 | // InternalSolverLanguage.g:4809:1: ( ( '}' ) ) | 15228 | // InternalSolverLanguageParser.g:4861:1: ( ( RightCurlyBracket ) ) |
16431 | // InternalSolverLanguage.g:4810:1: ( '}' ) | 15229 | // InternalSolverLanguageParser.g:4862:1: ( RightCurlyBracket ) |
16432 | { | 15230 | { |
16433 | // InternalSolverLanguage.g:4810:1: ( '}' ) | 15231 | // InternalSolverLanguageParser.g:4862:1: ( RightCurlyBracket ) |
16434 | // InternalSolverLanguage.g:4811:2: '}' | 15232 | // InternalSolverLanguageParser.g:4863:2: RightCurlyBracket |
16435 | { | 15233 | { |
16436 | if ( state.backtracking==0 ) { | 15234 | before(grammarAccess.getCountAccess().getRightCurlyBracketKeyword_3()); |
16437 | before(grammarAccess.getCountAccess().getRightCurlyBracketKeyword_3()); | 15235 | match(input,RightCurlyBracket,FOLLOW_2); |
16438 | } | 15236 | after(grammarAccess.getCountAccess().getRightCurlyBracketKeyword_3()); |
16439 | match(input,59,FOLLOW_2); if (state.failed) return ; | ||
16440 | if ( state.backtracking==0 ) { | ||
16441 | after(grammarAccess.getCountAccess().getRightCurlyBracketKeyword_3()); | ||
16442 | } | ||
16443 | 15237 | ||
16444 | } | 15238 | } |
16445 | 15239 | ||
@@ -16462,25 +15256,25 @@ public class InternalSolverLanguageParser extends AbstractInternalContentAssistP | |||
16462 | 15256 | ||
16463 | 15257 | ||
16464 | // $ANTLR start "rule__Aggregation__Group__0" | 15258 | // $ANTLR start "rule__Aggregation__Group__0" |
16465 | // InternalSolverLanguage.g:4821:1: rule__Aggregation__Group__0 : rule__Aggregation__Group__0__Impl rule__Aggregation__Group__1 ; | 15259 | // InternalSolverLanguageParser.g:4873:1: rule__Aggregation__Group__0 : rule__Aggregation__Group__0__Impl rule__Aggregation__Group__1 ; |
16466 | public final void rule__Aggregation__Group__0() throws RecognitionException { | 15260 | public final void rule__Aggregation__Group__0() throws RecognitionException { |
16467 | 15261 | ||
16468 | int stackSize = keepStackSize(); | 15262 | int stackSize = keepStackSize(); |
16469 | 15263 | ||
16470 | try { | 15264 | try { |
16471 | // InternalSolverLanguage.g:4825:1: ( rule__Aggregation__Group__0__Impl rule__Aggregation__Group__1 ) | 15265 | // InternalSolverLanguageParser.g:4877:1: ( rule__Aggregation__Group__0__Impl rule__Aggregation__Group__1 ) |
16472 | // InternalSolverLanguage.g:4826:2: rule__Aggregation__Group__0__Impl rule__Aggregation__Group__1 | 15266 | // InternalSolverLanguageParser.g:4878:2: rule__Aggregation__Group__0__Impl rule__Aggregation__Group__1 |
16473 | { | 15267 | { |
16474 | pushFollow(FOLLOW_31); | 15268 | pushFollow(FOLLOW_30); |
16475 | rule__Aggregation__Group__0__Impl(); | 15269 | rule__Aggregation__Group__0__Impl(); |
16476 | 15270 | ||
16477 | state._fsp--; | 15271 | state._fsp--; |
16478 | if (state.failed) return ; | 15272 | |
16479 | pushFollow(FOLLOW_2); | 15273 | pushFollow(FOLLOW_2); |
16480 | rule__Aggregation__Group__1(); | 15274 | rule__Aggregation__Group__1(); |
16481 | 15275 | ||
16482 | state._fsp--; | 15276 | state._fsp--; |
16483 | if (state.failed) return ; | 15277 | |
16484 | 15278 | ||
16485 | } | 15279 | } |
16486 | 15280 | ||
@@ -16500,36 +15294,32 @@ public class InternalSolverLanguageParser extends AbstractInternalContentAssistP | |||
16500 | 15294 | ||
16501 | 15295 | ||
16502 | // $ANTLR start "rule__Aggregation__Group__0__Impl" | 15296 | // $ANTLR start "rule__Aggregation__Group__0__Impl" |
16503 | // InternalSolverLanguage.g:4833:1: rule__Aggregation__Group__0__Impl : ( ( rule__Aggregation__OpAssignment_0 ) ) ; | 15297 | // InternalSolverLanguageParser.g:4885:1: rule__Aggregation__Group__0__Impl : ( ( rule__Aggregation__OpAssignment_0 ) ) ; |
16504 | public final void rule__Aggregation__Group__0__Impl() throws RecognitionException { | 15298 | public final void rule__Aggregation__Group__0__Impl() throws RecognitionException { |
16505 | 15299 | ||
16506 | int stackSize = keepStackSize(); | 15300 | int stackSize = keepStackSize(); |
16507 | 15301 | ||
16508 | try { | 15302 | try { |
16509 | // InternalSolverLanguage.g:4837:1: ( ( ( rule__Aggregation__OpAssignment_0 ) ) ) | 15303 | // InternalSolverLanguageParser.g:4889:1: ( ( ( rule__Aggregation__OpAssignment_0 ) ) ) |
16510 | // InternalSolverLanguage.g:4838:1: ( ( rule__Aggregation__OpAssignment_0 ) ) | 15304 | // InternalSolverLanguageParser.g:4890:1: ( ( rule__Aggregation__OpAssignment_0 ) ) |
16511 | { | 15305 | { |
16512 | // InternalSolverLanguage.g:4838:1: ( ( rule__Aggregation__OpAssignment_0 ) ) | 15306 | // InternalSolverLanguageParser.g:4890:1: ( ( rule__Aggregation__OpAssignment_0 ) ) |
16513 | // InternalSolverLanguage.g:4839:2: ( rule__Aggregation__OpAssignment_0 ) | 15307 | // InternalSolverLanguageParser.g:4891:2: ( rule__Aggregation__OpAssignment_0 ) |
16514 | { | 15308 | { |
16515 | if ( state.backtracking==0 ) { | 15309 | before(grammarAccess.getAggregationAccess().getOpAssignment_0()); |
16516 | before(grammarAccess.getAggregationAccess().getOpAssignment_0()); | 15310 | // InternalSolverLanguageParser.g:4892:2: ( rule__Aggregation__OpAssignment_0 ) |
16517 | } | 15311 | // InternalSolverLanguageParser.g:4892:3: rule__Aggregation__OpAssignment_0 |
16518 | // InternalSolverLanguage.g:4840:2: ( rule__Aggregation__OpAssignment_0 ) | ||
16519 | // InternalSolverLanguage.g:4840:3: rule__Aggregation__OpAssignment_0 | ||
16520 | { | 15312 | { |
16521 | pushFollow(FOLLOW_2); | 15313 | pushFollow(FOLLOW_2); |
16522 | rule__Aggregation__OpAssignment_0(); | 15314 | rule__Aggregation__OpAssignment_0(); |
16523 | 15315 | ||
16524 | state._fsp--; | 15316 | state._fsp--; |
16525 | if (state.failed) return ; | ||
16526 | 15317 | ||
16527 | } | ||
16528 | 15318 | ||
16529 | if ( state.backtracking==0 ) { | ||
16530 | after(grammarAccess.getAggregationAccess().getOpAssignment_0()); | ||
16531 | } | 15319 | } |
16532 | 15320 | ||
15321 | after(grammarAccess.getAggregationAccess().getOpAssignment_0()); | ||
15322 | |||
16533 | } | 15323 | } |
16534 | 15324 | ||
16535 | 15325 | ||
@@ -16551,25 +15341,25 @@ public class InternalSolverLanguageParser extends AbstractInternalContentAssistP | |||
16551 | 15341 | ||
16552 | 15342 | ||
16553 | // $ANTLR start "rule__Aggregation__Group__1" | 15343 | // $ANTLR start "rule__Aggregation__Group__1" |
16554 | // InternalSolverLanguage.g:4848:1: rule__Aggregation__Group__1 : rule__Aggregation__Group__1__Impl rule__Aggregation__Group__2 ; | 15344 | // InternalSolverLanguageParser.g:4900:1: rule__Aggregation__Group__1 : rule__Aggregation__Group__1__Impl rule__Aggregation__Group__2 ; |
16555 | public final void rule__Aggregation__Group__1() throws RecognitionException { | 15345 | public final void rule__Aggregation__Group__1() throws RecognitionException { |
16556 | 15346 | ||
16557 | int stackSize = keepStackSize(); | 15347 | int stackSize = keepStackSize(); |
16558 | 15348 | ||
16559 | try { | 15349 | try { |
16560 | // InternalSolverLanguage.g:4852:1: ( rule__Aggregation__Group__1__Impl rule__Aggregation__Group__2 ) | 15350 | // InternalSolverLanguageParser.g:4904:1: ( rule__Aggregation__Group__1__Impl rule__Aggregation__Group__2 ) |
16561 | // InternalSolverLanguage.g:4853:2: rule__Aggregation__Group__1__Impl rule__Aggregation__Group__2 | 15351 | // InternalSolverLanguageParser.g:4905:2: rule__Aggregation__Group__1__Impl rule__Aggregation__Group__2 |
16562 | { | 15352 | { |
16563 | pushFollow(FOLLOW_7); | 15353 | pushFollow(FOLLOW_7); |
16564 | rule__Aggregation__Group__1__Impl(); | 15354 | rule__Aggregation__Group__1__Impl(); |
16565 | 15355 | ||
16566 | state._fsp--; | 15356 | state._fsp--; |
16567 | if (state.failed) return ; | 15357 | |
16568 | pushFollow(FOLLOW_2); | 15358 | pushFollow(FOLLOW_2); |
16569 | rule__Aggregation__Group__2(); | 15359 | rule__Aggregation__Group__2(); |
16570 | 15360 | ||
16571 | state._fsp--; | 15361 | state._fsp--; |
16572 | if (state.failed) return ; | 15362 | |
16573 | 15363 | ||
16574 | } | 15364 | } |
16575 | 15365 | ||
@@ -16589,25 +15379,21 @@ public class InternalSolverLanguageParser extends AbstractInternalContentAssistP | |||
16589 | 15379 | ||
16590 | 15380 | ||
16591 | // $ANTLR start "rule__Aggregation__Group__1__Impl" | 15381 | // $ANTLR start "rule__Aggregation__Group__1__Impl" |
16592 | // InternalSolverLanguage.g:4860:1: rule__Aggregation__Group__1__Impl : ( '{' ) ; | 15382 | // InternalSolverLanguageParser.g:4912:1: rule__Aggregation__Group__1__Impl : ( LeftCurlyBracket ) ; |
16593 | public final void rule__Aggregation__Group__1__Impl() throws RecognitionException { | 15383 | public final void rule__Aggregation__Group__1__Impl() throws RecognitionException { |
16594 | 15384 | ||
16595 | int stackSize = keepStackSize(); | 15385 | int stackSize = keepStackSize(); |
16596 | 15386 | ||
16597 | try { | 15387 | try { |
16598 | // InternalSolverLanguage.g:4864:1: ( ( '{' ) ) | 15388 | // InternalSolverLanguageParser.g:4916:1: ( ( LeftCurlyBracket ) ) |
16599 | // InternalSolverLanguage.g:4865:1: ( '{' ) | 15389 | // InternalSolverLanguageParser.g:4917:1: ( LeftCurlyBracket ) |
16600 | { | 15390 | { |
16601 | // InternalSolverLanguage.g:4865:1: ( '{' ) | 15391 | // InternalSolverLanguageParser.g:4917:1: ( LeftCurlyBracket ) |
16602 | // InternalSolverLanguage.g:4866:2: '{' | 15392 | // InternalSolverLanguageParser.g:4918:2: LeftCurlyBracket |
16603 | { | 15393 | { |
16604 | if ( state.backtracking==0 ) { | 15394 | before(grammarAccess.getAggregationAccess().getLeftCurlyBracketKeyword_1()); |
16605 | before(grammarAccess.getAggregationAccess().getLeftCurlyBracketKeyword_1()); | 15395 | match(input,LeftCurlyBracket,FOLLOW_2); |
16606 | } | 15396 | after(grammarAccess.getAggregationAccess().getLeftCurlyBracketKeyword_1()); |
16607 | match(input,58,FOLLOW_2); if (state.failed) return ; | ||
16608 | if ( state.backtracking==0 ) { | ||
16609 | after(grammarAccess.getAggregationAccess().getLeftCurlyBracketKeyword_1()); | ||
16610 | } | ||
16611 | 15397 | ||
16612 | } | 15398 | } |
16613 | 15399 | ||
@@ -16630,25 +15416,25 @@ public class InternalSolverLanguageParser extends AbstractInternalContentAssistP | |||
16630 | 15416 | ||
16631 | 15417 | ||
16632 | // $ANTLR start "rule__Aggregation__Group__2" | 15418 | // $ANTLR start "rule__Aggregation__Group__2" |
16633 | // InternalSolverLanguage.g:4875:1: rule__Aggregation__Group__2 : rule__Aggregation__Group__2__Impl rule__Aggregation__Group__3 ; | 15419 | // InternalSolverLanguageParser.g:4927:1: rule__Aggregation__Group__2 : rule__Aggregation__Group__2__Impl rule__Aggregation__Group__3 ; |
16634 | public final void rule__Aggregation__Group__2() throws RecognitionException { | 15420 | public final void rule__Aggregation__Group__2() throws RecognitionException { |
16635 | 15421 | ||
16636 | int stackSize = keepStackSize(); | 15422 | int stackSize = keepStackSize(); |
16637 | 15423 | ||
16638 | try { | 15424 | try { |
16639 | // InternalSolverLanguage.g:4879:1: ( rule__Aggregation__Group__2__Impl rule__Aggregation__Group__3 ) | 15425 | // InternalSolverLanguageParser.g:4931:1: ( rule__Aggregation__Group__2__Impl rule__Aggregation__Group__3 ) |
16640 | // InternalSolverLanguage.g:4880:2: rule__Aggregation__Group__2__Impl rule__Aggregation__Group__3 | 15426 | // InternalSolverLanguageParser.g:4932:2: rule__Aggregation__Group__2__Impl rule__Aggregation__Group__3 |
16641 | { | 15427 | { |
16642 | pushFollow(FOLLOW_33); | 15428 | pushFollow(FOLLOW_32); |
16643 | rule__Aggregation__Group__2__Impl(); | 15429 | rule__Aggregation__Group__2__Impl(); |
16644 | 15430 | ||
16645 | state._fsp--; | 15431 | state._fsp--; |
16646 | if (state.failed) return ; | 15432 | |
16647 | pushFollow(FOLLOW_2); | 15433 | pushFollow(FOLLOW_2); |
16648 | rule__Aggregation__Group__3(); | 15434 | rule__Aggregation__Group__3(); |
16649 | 15435 | ||
16650 | state._fsp--; | 15436 | state._fsp--; |
16651 | if (state.failed) return ; | 15437 | |
16652 | 15438 | ||
16653 | } | 15439 | } |
16654 | 15440 | ||
@@ -16668,36 +15454,32 @@ public class InternalSolverLanguageParser extends AbstractInternalContentAssistP | |||
16668 | 15454 | ||
16669 | 15455 | ||
16670 | // $ANTLR start "rule__Aggregation__Group__2__Impl" | 15456 | // $ANTLR start "rule__Aggregation__Group__2__Impl" |
16671 | // InternalSolverLanguage.g:4887:1: rule__Aggregation__Group__2__Impl : ( ( rule__Aggregation__BodyAssignment_2 ) ) ; | 15457 | // InternalSolverLanguageParser.g:4939:1: rule__Aggregation__Group__2__Impl : ( ( rule__Aggregation__BodyAssignment_2 ) ) ; |
16672 | public final void rule__Aggregation__Group__2__Impl() throws RecognitionException { | 15458 | public final void rule__Aggregation__Group__2__Impl() throws RecognitionException { |
16673 | 15459 | ||
16674 | int stackSize = keepStackSize(); | 15460 | int stackSize = keepStackSize(); |
16675 | 15461 | ||
16676 | try { | 15462 | try { |
16677 | // InternalSolverLanguage.g:4891:1: ( ( ( rule__Aggregation__BodyAssignment_2 ) ) ) | 15463 | // InternalSolverLanguageParser.g:4943:1: ( ( ( rule__Aggregation__BodyAssignment_2 ) ) ) |
16678 | // InternalSolverLanguage.g:4892:1: ( ( rule__Aggregation__BodyAssignment_2 ) ) | 15464 | // InternalSolverLanguageParser.g:4944:1: ( ( rule__Aggregation__BodyAssignment_2 ) ) |
16679 | { | 15465 | { |
16680 | // InternalSolverLanguage.g:4892:1: ( ( rule__Aggregation__BodyAssignment_2 ) ) | 15466 | // InternalSolverLanguageParser.g:4944:1: ( ( rule__Aggregation__BodyAssignment_2 ) ) |
16681 | // InternalSolverLanguage.g:4893:2: ( rule__Aggregation__BodyAssignment_2 ) | 15467 | // InternalSolverLanguageParser.g:4945:2: ( rule__Aggregation__BodyAssignment_2 ) |
16682 | { | 15468 | { |
16683 | if ( state.backtracking==0 ) { | 15469 | before(grammarAccess.getAggregationAccess().getBodyAssignment_2()); |
16684 | before(grammarAccess.getAggregationAccess().getBodyAssignment_2()); | 15470 | // InternalSolverLanguageParser.g:4946:2: ( rule__Aggregation__BodyAssignment_2 ) |
16685 | } | 15471 | // InternalSolverLanguageParser.g:4946:3: rule__Aggregation__BodyAssignment_2 |
16686 | // InternalSolverLanguage.g:4894:2: ( rule__Aggregation__BodyAssignment_2 ) | ||
16687 | // InternalSolverLanguage.g:4894:3: rule__Aggregation__BodyAssignment_2 | ||
16688 | { | 15472 | { |
16689 | pushFollow(FOLLOW_2); | 15473 | pushFollow(FOLLOW_2); |
16690 | rule__Aggregation__BodyAssignment_2(); | 15474 | rule__Aggregation__BodyAssignment_2(); |
16691 | 15475 | ||
16692 | state._fsp--; | 15476 | state._fsp--; |
16693 | if (state.failed) return ; | ||
16694 | 15477 | ||
16695 | } | ||
16696 | 15478 | ||
16697 | if ( state.backtracking==0 ) { | ||
16698 | after(grammarAccess.getAggregationAccess().getBodyAssignment_2()); | ||
16699 | } | 15479 | } |
16700 | 15480 | ||
15481 | after(grammarAccess.getAggregationAccess().getBodyAssignment_2()); | ||
15482 | |||
16701 | } | 15483 | } |
16702 | 15484 | ||
16703 | 15485 | ||
@@ -16719,25 +15501,25 @@ public class InternalSolverLanguageParser extends AbstractInternalContentAssistP | |||
16719 | 15501 | ||
16720 | 15502 | ||
16721 | // $ANTLR start "rule__Aggregation__Group__3" | 15503 | // $ANTLR start "rule__Aggregation__Group__3" |
16722 | // InternalSolverLanguage.g:4902:1: rule__Aggregation__Group__3 : rule__Aggregation__Group__3__Impl rule__Aggregation__Group__4 ; | 15504 | // InternalSolverLanguageParser.g:4954:1: rule__Aggregation__Group__3 : rule__Aggregation__Group__3__Impl rule__Aggregation__Group__4 ; |
16723 | public final void rule__Aggregation__Group__3() throws RecognitionException { | 15505 | public final void rule__Aggregation__Group__3() throws RecognitionException { |
16724 | 15506 | ||
16725 | int stackSize = keepStackSize(); | 15507 | int stackSize = keepStackSize(); |
16726 | 15508 | ||
16727 | try { | 15509 | try { |
16728 | // InternalSolverLanguage.g:4906:1: ( rule__Aggregation__Group__3__Impl rule__Aggregation__Group__4 ) | 15510 | // InternalSolverLanguageParser.g:4958:1: ( rule__Aggregation__Group__3__Impl rule__Aggregation__Group__4 ) |
16729 | // InternalSolverLanguage.g:4907:2: rule__Aggregation__Group__3__Impl rule__Aggregation__Group__4 | 15511 | // InternalSolverLanguageParser.g:4959:2: rule__Aggregation__Group__3__Impl rule__Aggregation__Group__4 |
16730 | { | 15512 | { |
16731 | pushFollow(FOLLOW_7); | 15513 | pushFollow(FOLLOW_7); |
16732 | rule__Aggregation__Group__3__Impl(); | 15514 | rule__Aggregation__Group__3__Impl(); |
16733 | 15515 | ||
16734 | state._fsp--; | 15516 | state._fsp--; |
16735 | if (state.failed) return ; | 15517 | |
16736 | pushFollow(FOLLOW_2); | 15518 | pushFollow(FOLLOW_2); |
16737 | rule__Aggregation__Group__4(); | 15519 | rule__Aggregation__Group__4(); |
16738 | 15520 | ||
16739 | state._fsp--; | 15521 | state._fsp--; |
16740 | if (state.failed) return ; | 15522 | |
16741 | 15523 | ||
16742 | } | 15524 | } |
16743 | 15525 | ||
@@ -16757,25 +15539,21 @@ public class InternalSolverLanguageParser extends AbstractInternalContentAssistP | |||
16757 | 15539 | ||
16758 | 15540 | ||
16759 | // $ANTLR start "rule__Aggregation__Group__3__Impl" | 15541 | // $ANTLR start "rule__Aggregation__Group__3__Impl" |
16760 | // InternalSolverLanguage.g:4914:1: rule__Aggregation__Group__3__Impl : ( '|' ) ; | 15542 | // InternalSolverLanguageParser.g:4966:1: rule__Aggregation__Group__3__Impl : ( VerticalLine ) ; |
16761 | public final void rule__Aggregation__Group__3__Impl() throws RecognitionException { | 15543 | public final void rule__Aggregation__Group__3__Impl() throws RecognitionException { |
16762 | 15544 | ||
16763 | int stackSize = keepStackSize(); | 15545 | int stackSize = keepStackSize(); |
16764 | 15546 | ||
16765 | try { | 15547 | try { |
16766 | // InternalSolverLanguage.g:4918:1: ( ( '|' ) ) | 15548 | // InternalSolverLanguageParser.g:4970:1: ( ( VerticalLine ) ) |
16767 | // InternalSolverLanguage.g:4919:1: ( '|' ) | 15549 | // InternalSolverLanguageParser.g:4971:1: ( VerticalLine ) |
16768 | { | 15550 | { |
16769 | // InternalSolverLanguage.g:4919:1: ( '|' ) | 15551 | // InternalSolverLanguageParser.g:4971:1: ( VerticalLine ) |
16770 | // InternalSolverLanguage.g:4920:2: '|' | 15552 | // InternalSolverLanguageParser.g:4972:2: VerticalLine |
16771 | { | 15553 | { |
16772 | if ( state.backtracking==0 ) { | 15554 | before(grammarAccess.getAggregationAccess().getVerticalLineKeyword_3()); |
16773 | before(grammarAccess.getAggregationAccess().getVerticalLineKeyword_3()); | 15555 | match(input,VerticalLine,FOLLOW_2); |
16774 | } | 15556 | after(grammarAccess.getAggregationAccess().getVerticalLineKeyword_3()); |
16775 | match(input,60,FOLLOW_2); if (state.failed) return ; | ||
16776 | if ( state.backtracking==0 ) { | ||
16777 | after(grammarAccess.getAggregationAccess().getVerticalLineKeyword_3()); | ||
16778 | } | ||
16779 | 15557 | ||
16780 | } | 15558 | } |
16781 | 15559 | ||
@@ -16798,25 +15576,25 @@ public class InternalSolverLanguageParser extends AbstractInternalContentAssistP | |||
16798 | 15576 | ||
16799 | 15577 | ||
16800 | // $ANTLR start "rule__Aggregation__Group__4" | 15578 | // $ANTLR start "rule__Aggregation__Group__4" |
16801 | // InternalSolverLanguage.g:4929:1: rule__Aggregation__Group__4 : rule__Aggregation__Group__4__Impl rule__Aggregation__Group__5 ; | 15579 | // InternalSolverLanguageParser.g:4981:1: rule__Aggregation__Group__4 : rule__Aggregation__Group__4__Impl rule__Aggregation__Group__5 ; |
16802 | public final void rule__Aggregation__Group__4() throws RecognitionException { | 15580 | public final void rule__Aggregation__Group__4() throws RecognitionException { |
16803 | 15581 | ||
16804 | int stackSize = keepStackSize(); | 15582 | int stackSize = keepStackSize(); |
16805 | 15583 | ||
16806 | try { | 15584 | try { |
16807 | // InternalSolverLanguage.g:4933:1: ( rule__Aggregation__Group__4__Impl rule__Aggregation__Group__5 ) | 15585 | // InternalSolverLanguageParser.g:4985:1: ( rule__Aggregation__Group__4__Impl rule__Aggregation__Group__5 ) |
16808 | // InternalSolverLanguage.g:4934:2: rule__Aggregation__Group__4__Impl rule__Aggregation__Group__5 | 15586 | // InternalSolverLanguageParser.g:4986:2: rule__Aggregation__Group__4__Impl rule__Aggregation__Group__5 |
16809 | { | 15587 | { |
16810 | pushFollow(FOLLOW_32); | 15588 | pushFollow(FOLLOW_31); |
16811 | rule__Aggregation__Group__4__Impl(); | 15589 | rule__Aggregation__Group__4__Impl(); |
16812 | 15590 | ||
16813 | state._fsp--; | 15591 | state._fsp--; |
16814 | if (state.failed) return ; | 15592 | |
16815 | pushFollow(FOLLOW_2); | 15593 | pushFollow(FOLLOW_2); |
16816 | rule__Aggregation__Group__5(); | 15594 | rule__Aggregation__Group__5(); |
16817 | 15595 | ||
16818 | state._fsp--; | 15596 | state._fsp--; |
16819 | if (state.failed) return ; | 15597 | |
16820 | 15598 | ||
16821 | } | 15599 | } |
16822 | 15600 | ||
@@ -16836,36 +15614,32 @@ public class InternalSolverLanguageParser extends AbstractInternalContentAssistP | |||
16836 | 15614 | ||
16837 | 15615 | ||
16838 | // $ANTLR start "rule__Aggregation__Group__4__Impl" | 15616 | // $ANTLR start "rule__Aggregation__Group__4__Impl" |
16839 | // InternalSolverLanguage.g:4941:1: rule__Aggregation__Group__4__Impl : ( ( rule__Aggregation__ConditionAssignment_4 ) ) ; | 15617 | // InternalSolverLanguageParser.g:4993:1: rule__Aggregation__Group__4__Impl : ( ( rule__Aggregation__ConditionAssignment_4 ) ) ; |
16840 | public final void rule__Aggregation__Group__4__Impl() throws RecognitionException { | 15618 | public final void rule__Aggregation__Group__4__Impl() throws RecognitionException { |
16841 | 15619 | ||
16842 | int stackSize = keepStackSize(); | 15620 | int stackSize = keepStackSize(); |
16843 | 15621 | ||
16844 | try { | 15622 | try { |
16845 | // InternalSolverLanguage.g:4945:1: ( ( ( rule__Aggregation__ConditionAssignment_4 ) ) ) | 15623 | // InternalSolverLanguageParser.g:4997:1: ( ( ( rule__Aggregation__ConditionAssignment_4 ) ) ) |
16846 | // InternalSolverLanguage.g:4946:1: ( ( rule__Aggregation__ConditionAssignment_4 ) ) | 15624 | // InternalSolverLanguageParser.g:4998:1: ( ( rule__Aggregation__ConditionAssignment_4 ) ) |
16847 | { | 15625 | { |
16848 | // InternalSolverLanguage.g:4946:1: ( ( rule__Aggregation__ConditionAssignment_4 ) ) | 15626 | // InternalSolverLanguageParser.g:4998:1: ( ( rule__Aggregation__ConditionAssignment_4 ) ) |
16849 | // InternalSolverLanguage.g:4947:2: ( rule__Aggregation__ConditionAssignment_4 ) | 15627 | // InternalSolverLanguageParser.g:4999:2: ( rule__Aggregation__ConditionAssignment_4 ) |
16850 | { | 15628 | { |
16851 | if ( state.backtracking==0 ) { | 15629 | before(grammarAccess.getAggregationAccess().getConditionAssignment_4()); |
16852 | before(grammarAccess.getAggregationAccess().getConditionAssignment_4()); | 15630 | // InternalSolverLanguageParser.g:5000:2: ( rule__Aggregation__ConditionAssignment_4 ) |
16853 | } | 15631 | // InternalSolverLanguageParser.g:5000:3: rule__Aggregation__ConditionAssignment_4 |
16854 | // InternalSolverLanguage.g:4948:2: ( rule__Aggregation__ConditionAssignment_4 ) | ||
16855 | // InternalSolverLanguage.g:4948:3: rule__Aggregation__ConditionAssignment_4 | ||
16856 | { | 15632 | { |
16857 | pushFollow(FOLLOW_2); | 15633 | pushFollow(FOLLOW_2); |
16858 | rule__Aggregation__ConditionAssignment_4(); | 15634 | rule__Aggregation__ConditionAssignment_4(); |
16859 | 15635 | ||
16860 | state._fsp--; | 15636 | state._fsp--; |
16861 | if (state.failed) return ; | ||
16862 | 15637 | ||
16863 | } | ||
16864 | 15638 | ||
16865 | if ( state.backtracking==0 ) { | ||
16866 | after(grammarAccess.getAggregationAccess().getConditionAssignment_4()); | ||
16867 | } | 15639 | } |
16868 | 15640 | ||
15641 | after(grammarAccess.getAggregationAccess().getConditionAssignment_4()); | ||
15642 | |||
16869 | } | 15643 | } |
16870 | 15644 | ||
16871 | 15645 | ||
@@ -16887,20 +15661,20 @@ public class InternalSolverLanguageParser extends AbstractInternalContentAssistP | |||
16887 | 15661 | ||
16888 | 15662 | ||
16889 | // $ANTLR start "rule__Aggregation__Group__5" | 15663 | // $ANTLR start "rule__Aggregation__Group__5" |
16890 | // InternalSolverLanguage.g:4956:1: rule__Aggregation__Group__5 : rule__Aggregation__Group__5__Impl ; | 15664 | // InternalSolverLanguageParser.g:5008:1: rule__Aggregation__Group__5 : rule__Aggregation__Group__5__Impl ; |
16891 | public final void rule__Aggregation__Group__5() throws RecognitionException { | 15665 | public final void rule__Aggregation__Group__5() throws RecognitionException { |
16892 | 15666 | ||
16893 | int stackSize = keepStackSize(); | 15667 | int stackSize = keepStackSize(); |
16894 | 15668 | ||
16895 | try { | 15669 | try { |
16896 | // InternalSolverLanguage.g:4960:1: ( rule__Aggregation__Group__5__Impl ) | 15670 | // InternalSolverLanguageParser.g:5012:1: ( rule__Aggregation__Group__5__Impl ) |
16897 | // InternalSolverLanguage.g:4961:2: rule__Aggregation__Group__5__Impl | 15671 | // InternalSolverLanguageParser.g:5013:2: rule__Aggregation__Group__5__Impl |
16898 | { | 15672 | { |
16899 | pushFollow(FOLLOW_2); | 15673 | pushFollow(FOLLOW_2); |
16900 | rule__Aggregation__Group__5__Impl(); | 15674 | rule__Aggregation__Group__5__Impl(); |
16901 | 15675 | ||
16902 | state._fsp--; | 15676 | state._fsp--; |
16903 | if (state.failed) return ; | 15677 | |
16904 | 15678 | ||
16905 | } | 15679 | } |
16906 | 15680 | ||
@@ -16920,25 +15694,21 @@ public class InternalSolverLanguageParser extends AbstractInternalContentAssistP | |||
16920 | 15694 | ||
16921 | 15695 | ||
16922 | // $ANTLR start "rule__Aggregation__Group__5__Impl" | 15696 | // $ANTLR start "rule__Aggregation__Group__5__Impl" |
16923 | // InternalSolverLanguage.g:4967:1: rule__Aggregation__Group__5__Impl : ( '}' ) ; | 15697 | // InternalSolverLanguageParser.g:5019:1: rule__Aggregation__Group__5__Impl : ( RightCurlyBracket ) ; |
16924 | public final void rule__Aggregation__Group__5__Impl() throws RecognitionException { | 15698 | public final void rule__Aggregation__Group__5__Impl() throws RecognitionException { |
16925 | 15699 | ||
16926 | int stackSize = keepStackSize(); | 15700 | int stackSize = keepStackSize(); |
16927 | 15701 | ||
16928 | try { | 15702 | try { |
16929 | // InternalSolverLanguage.g:4971:1: ( ( '}' ) ) | 15703 | // InternalSolverLanguageParser.g:5023:1: ( ( RightCurlyBracket ) ) |
16930 | // InternalSolverLanguage.g:4972:1: ( '}' ) | 15704 | // InternalSolverLanguageParser.g:5024:1: ( RightCurlyBracket ) |
16931 | { | 15705 | { |
16932 | // InternalSolverLanguage.g:4972:1: ( '}' ) | 15706 | // InternalSolverLanguageParser.g:5024:1: ( RightCurlyBracket ) |
16933 | // InternalSolverLanguage.g:4973:2: '}' | 15707 | // InternalSolverLanguageParser.g:5025:2: RightCurlyBracket |
16934 | { | 15708 | { |
16935 | if ( state.backtracking==0 ) { | 15709 | before(grammarAccess.getAggregationAccess().getRightCurlyBracketKeyword_5()); |
16936 | before(grammarAccess.getAggregationAccess().getRightCurlyBracketKeyword_5()); | 15710 | match(input,RightCurlyBracket,FOLLOW_2); |
16937 | } | 15711 | after(grammarAccess.getAggregationAccess().getRightCurlyBracketKeyword_5()); |
16938 | match(input,59,FOLLOW_2); if (state.failed) return ; | ||
16939 | if ( state.backtracking==0 ) { | ||
16940 | after(grammarAccess.getAggregationAccess().getRightCurlyBracketKeyword_5()); | ||
16941 | } | ||
16942 | 15712 | ||
16943 | } | 15713 | } |
16944 | 15714 | ||
@@ -16960,70 +15730,25 @@ public class InternalSolverLanguageParser extends AbstractInternalContentAssistP | |||
16960 | // $ANTLR end "rule__Aggregation__Group__5__Impl" | 15730 | // $ANTLR end "rule__Aggregation__Group__5__Impl" |
16961 | 15731 | ||
16962 | 15732 | ||
16963 | // $ANTLR start "rule__AtomicExpression__Group_0__0" | 15733 | // $ANTLR start "rule__AtomicExpression__Group_4__0" |
16964 | // InternalSolverLanguage.g:4983:1: rule__AtomicExpression__Group_0__0 : rule__AtomicExpression__Group_0__0__Impl rule__AtomicExpression__Group_0__1 ; | 15734 | // InternalSolverLanguageParser.g:5035:1: rule__AtomicExpression__Group_4__0 : rule__AtomicExpression__Group_4__0__Impl rule__AtomicExpression__Group_4__1 ; |
16965 | public final void rule__AtomicExpression__Group_0__0() throws RecognitionException { | 15735 | public final void rule__AtomicExpression__Group_4__0() throws RecognitionException { |
16966 | 15736 | ||
16967 | int stackSize = keepStackSize(); | 15737 | int stackSize = keepStackSize(); |
16968 | 15738 | ||
16969 | try { | 15739 | try { |
16970 | // InternalSolverLanguage.g:4987:1: ( rule__AtomicExpression__Group_0__0__Impl rule__AtomicExpression__Group_0__1 ) | 15740 | // InternalSolverLanguageParser.g:5039:1: ( rule__AtomicExpression__Group_4__0__Impl rule__AtomicExpression__Group_4__1 ) |
16971 | // InternalSolverLanguage.g:4988:2: rule__AtomicExpression__Group_0__0__Impl rule__AtomicExpression__Group_0__1 | 15741 | // InternalSolverLanguageParser.g:5040:2: rule__AtomicExpression__Group_4__0__Impl rule__AtomicExpression__Group_4__1 |
16972 | { | 15742 | { |
16973 | pushFollow(FOLLOW_12); | 15743 | pushFollow(FOLLOW_7); |
16974 | rule__AtomicExpression__Group_0__0__Impl(); | 15744 | rule__AtomicExpression__Group_4__0__Impl(); |
16975 | |||
16976 | state._fsp--; | ||
16977 | if (state.failed) return ; | ||
16978 | pushFollow(FOLLOW_2); | ||
16979 | rule__AtomicExpression__Group_0__1(); | ||
16980 | 15745 | ||
16981 | state._fsp--; | 15746 | state._fsp--; |
16982 | if (state.failed) return ; | ||
16983 | |||
16984 | } | ||
16985 | |||
16986 | } | ||
16987 | catch (RecognitionException re) { | ||
16988 | reportError(re); | ||
16989 | recover(input,re); | ||
16990 | } | ||
16991 | finally { | ||
16992 | |||
16993 | restoreStackSize(stackSize); | ||
16994 | 15747 | ||
16995 | } | ||
16996 | return ; | ||
16997 | } | ||
16998 | // $ANTLR end "rule__AtomicExpression__Group_0__0" | ||
16999 | |||
17000 | |||
17001 | // $ANTLR start "rule__AtomicExpression__Group_0__0__Impl" | ||
17002 | // InternalSolverLanguage.g:4995:1: rule__AtomicExpression__Group_0__0__Impl : ( ruleReference ) ; | ||
17003 | public final void rule__AtomicExpression__Group_0__0__Impl() throws RecognitionException { | ||
17004 | |||
17005 | int stackSize = keepStackSize(); | ||
17006 | |||
17007 | try { | ||
17008 | // InternalSolverLanguage.g:4999:1: ( ( ruleReference ) ) | ||
17009 | // InternalSolverLanguage.g:5000:1: ( ruleReference ) | ||
17010 | { | ||
17011 | // InternalSolverLanguage.g:5000:1: ( ruleReference ) | ||
17012 | // InternalSolverLanguage.g:5001:2: ruleReference | ||
17013 | { | ||
17014 | if ( state.backtracking==0 ) { | ||
17015 | before(grammarAccess.getAtomicExpressionAccess().getReferenceParserRuleCall_0_0()); | ||
17016 | } | ||
17017 | pushFollow(FOLLOW_2); | 15748 | pushFollow(FOLLOW_2); |
17018 | ruleReference(); | 15749 | rule__AtomicExpression__Group_4__1(); |
17019 | 15750 | ||
17020 | state._fsp--; | 15751 | state._fsp--; |
17021 | if (state.failed) return ; | ||
17022 | if ( state.backtracking==0 ) { | ||
17023 | after(grammarAccess.getAtomicExpressionAccess().getReferenceParserRuleCall_0_0()); | ||
17024 | } | ||
17025 | |||
17026 | } | ||
17027 | 15752 | ||
17028 | 15753 | ||
17029 | } | 15754 | } |
@@ -17040,124 +15765,28 @@ public class InternalSolverLanguageParser extends AbstractInternalContentAssistP | |||
17040 | } | 15765 | } |
17041 | return ; | 15766 | return ; |
17042 | } | 15767 | } |
17043 | // $ANTLR end "rule__AtomicExpression__Group_0__0__Impl" | 15768 | // $ANTLR end "rule__AtomicExpression__Group_4__0" |
17044 | 15769 | ||
17045 | 15770 | ||
17046 | // $ANTLR start "rule__AtomicExpression__Group_0__1" | 15771 | // $ANTLR start "rule__AtomicExpression__Group_4__0__Impl" |
17047 | // InternalSolverLanguage.g:5010:1: rule__AtomicExpression__Group_0__1 : rule__AtomicExpression__Group_0__1__Impl ; | 15772 | // InternalSolverLanguageParser.g:5047:1: rule__AtomicExpression__Group_4__0__Impl : ( LeftParenthesis ) ; |
17048 | public final void rule__AtomicExpression__Group_0__1() throws RecognitionException { | 15773 | public final void rule__AtomicExpression__Group_4__0__Impl() throws RecognitionException { |
17049 | 15774 | ||
17050 | int stackSize = keepStackSize(); | 15775 | int stackSize = keepStackSize(); |
17051 | 15776 | ||
17052 | try { | 15777 | try { |
17053 | // InternalSolverLanguage.g:5014:1: ( rule__AtomicExpression__Group_0__1__Impl ) | 15778 | // InternalSolverLanguageParser.g:5051:1: ( ( LeftParenthesis ) ) |
17054 | // InternalSolverLanguage.g:5015:2: rule__AtomicExpression__Group_0__1__Impl | 15779 | // InternalSolverLanguageParser.g:5052:1: ( LeftParenthesis ) |
17055 | { | 15780 | { |
17056 | pushFollow(FOLLOW_2); | 15781 | // InternalSolverLanguageParser.g:5052:1: ( LeftParenthesis ) |
17057 | rule__AtomicExpression__Group_0__1__Impl(); | 15782 | // InternalSolverLanguageParser.g:5053:2: LeftParenthesis |
17058 | |||
17059 | state._fsp--; | ||
17060 | if (state.failed) return ; | ||
17061 | |||
17062 | } | ||
17063 | |||
17064 | } | ||
17065 | catch (RecognitionException re) { | ||
17066 | reportError(re); | ||
17067 | recover(input,re); | ||
17068 | } | ||
17069 | finally { | ||
17070 | |||
17071 | restoreStackSize(stackSize); | ||
17072 | |||
17073 | } | ||
17074 | return ; | ||
17075 | } | ||
17076 | // $ANTLR end "rule__AtomicExpression__Group_0__1" | ||
17077 | |||
17078 | |||
17079 | // $ANTLR start "rule__AtomicExpression__Group_0__1__Impl" | ||
17080 | // InternalSolverLanguage.g:5021:1: rule__AtomicExpression__Group_0__1__Impl : ( ( rule__AtomicExpression__Group_0_1__0 )? ) ; | ||
17081 | public final void rule__AtomicExpression__Group_0__1__Impl() throws RecognitionException { | ||
17082 | |||
17083 | int stackSize = keepStackSize(); | ||
17084 | |||
17085 | try { | ||
17086 | // InternalSolverLanguage.g:5025:1: ( ( ( rule__AtomicExpression__Group_0_1__0 )? ) ) | ||
17087 | // InternalSolverLanguage.g:5026:1: ( ( rule__AtomicExpression__Group_0_1__0 )? ) | ||
17088 | { | 15783 | { |
17089 | // InternalSolverLanguage.g:5026:1: ( ( rule__AtomicExpression__Group_0_1__0 )? ) | 15784 | before(grammarAccess.getAtomicExpressionAccess().getLeftParenthesisKeyword_4_0()); |
17090 | // InternalSolverLanguage.g:5027:2: ( rule__AtomicExpression__Group_0_1__0 )? | 15785 | match(input,LeftParenthesis,FOLLOW_2); |
17091 | { | 15786 | after(grammarAccess.getAtomicExpressionAccess().getLeftParenthesisKeyword_4_0()); |
17092 | if ( state.backtracking==0 ) { | ||
17093 | before(grammarAccess.getAtomicExpressionAccess().getGroup_0_1()); | ||
17094 | } | ||
17095 | // InternalSolverLanguage.g:5028:2: ( rule__AtomicExpression__Group_0_1__0 )? | ||
17096 | int alt39=2; | ||
17097 | int LA39_0 = input.LA(1); | ||
17098 | 15787 | ||
17099 | if ( (LA39_0==61) ) { | ||
17100 | alt39=1; | ||
17101 | } | 15788 | } |
17102 | switch (alt39) { | ||
17103 | case 1 : | ||
17104 | // InternalSolverLanguage.g:5028:3: rule__AtomicExpression__Group_0_1__0 | ||
17105 | { | ||
17106 | pushFollow(FOLLOW_2); | ||
17107 | rule__AtomicExpression__Group_0_1__0(); | ||
17108 | |||
17109 | state._fsp--; | ||
17110 | if (state.failed) return ; | ||
17111 | |||
17112 | } | ||
17113 | break; | ||
17114 | |||
17115 | } | ||
17116 | |||
17117 | if ( state.backtracking==0 ) { | ||
17118 | after(grammarAccess.getAtomicExpressionAccess().getGroup_0_1()); | ||
17119 | } | ||
17120 | |||
17121 | } | ||
17122 | |||
17123 | |||
17124 | } | ||
17125 | |||
17126 | } | ||
17127 | catch (RecognitionException re) { | ||
17128 | reportError(re); | ||
17129 | recover(input,re); | ||
17130 | } | ||
17131 | finally { | ||
17132 | |||
17133 | restoreStackSize(stackSize); | ||
17134 | |||
17135 | } | ||
17136 | return ; | ||
17137 | } | ||
17138 | // $ANTLR end "rule__AtomicExpression__Group_0__1__Impl" | ||
17139 | |||
17140 | |||
17141 | // $ANTLR start "rule__AtomicExpression__Group_0_1__0" | ||
17142 | // InternalSolverLanguage.g:5037:1: rule__AtomicExpression__Group_0_1__0 : rule__AtomicExpression__Group_0_1__0__Impl rule__AtomicExpression__Group_0_1__1 ; | ||
17143 | public final void rule__AtomicExpression__Group_0_1__0() throws RecognitionException { | ||
17144 | |||
17145 | int stackSize = keepStackSize(); | ||
17146 | |||
17147 | try { | ||
17148 | // InternalSolverLanguage.g:5041:1: ( rule__AtomicExpression__Group_0_1__0__Impl rule__AtomicExpression__Group_0_1__1 ) | ||
17149 | // InternalSolverLanguage.g:5042:2: rule__AtomicExpression__Group_0_1__0__Impl rule__AtomicExpression__Group_0_1__1 | ||
17150 | { | ||
17151 | pushFollow(FOLLOW_12); | ||
17152 | rule__AtomicExpression__Group_0_1__0__Impl(); | ||
17153 | 15789 | ||
17154 | state._fsp--; | ||
17155 | if (state.failed) return ; | ||
17156 | pushFollow(FOLLOW_2); | ||
17157 | rule__AtomicExpression__Group_0_1__1(); | ||
17158 | |||
17159 | state._fsp--; | ||
17160 | if (state.failed) return ; | ||
17161 | 15790 | ||
17162 | } | 15791 | } |
17163 | 15792 | ||
@@ -17173,154 +15802,29 @@ public class InternalSolverLanguageParser extends AbstractInternalContentAssistP | |||
17173 | } | 15802 | } |
17174 | return ; | 15803 | return ; |
17175 | } | 15804 | } |
17176 | // $ANTLR end "rule__AtomicExpression__Group_0_1__0" | 15805 | // $ANTLR end "rule__AtomicExpression__Group_4__0__Impl" |
17177 | |||
17178 | |||
17179 | // $ANTLR start "rule__AtomicExpression__Group_0_1__0__Impl" | ||
17180 | // InternalSolverLanguage.g:5049:1: rule__AtomicExpression__Group_0_1__0__Impl : ( () ) ; | ||
17181 | public final void rule__AtomicExpression__Group_0_1__0__Impl() throws RecognitionException { | ||
17182 | |||
17183 | int stackSize = keepStackSize(); | ||
17184 | |||
17185 | try { | ||
17186 | // InternalSolverLanguage.g:5053:1: ( ( () ) ) | ||
17187 | // InternalSolverLanguage.g:5054:1: ( () ) | ||
17188 | { | ||
17189 | // InternalSolverLanguage.g:5054:1: ( () ) | ||
17190 | // InternalSolverLanguage.g:5055:2: () | ||
17191 | { | ||
17192 | if ( state.backtracking==0 ) { | ||
17193 | before(grammarAccess.getAtomicExpressionAccess().getCallFunctorAction_0_1_0()); | ||
17194 | } | ||
17195 | // InternalSolverLanguage.g:5056:2: () | ||
17196 | // InternalSolverLanguage.g:5056:3: | ||
17197 | { | ||
17198 | } | ||
17199 | |||
17200 | if ( state.backtracking==0 ) { | ||
17201 | after(grammarAccess.getAtomicExpressionAccess().getCallFunctorAction_0_1_0()); | ||
17202 | } | ||
17203 | |||
17204 | } | ||
17205 | |||
17206 | |||
17207 | } | ||
17208 | |||
17209 | } | ||
17210 | finally { | ||
17211 | |||
17212 | restoreStackSize(stackSize); | ||
17213 | |||
17214 | } | ||
17215 | return ; | ||
17216 | } | ||
17217 | // $ANTLR end "rule__AtomicExpression__Group_0_1__0__Impl" | ||
17218 | 15806 | ||
17219 | 15807 | ||
17220 | // $ANTLR start "rule__AtomicExpression__Group_0_1__1" | 15808 | // $ANTLR start "rule__AtomicExpression__Group_4__1" |
17221 | // InternalSolverLanguage.g:5064:1: rule__AtomicExpression__Group_0_1__1 : rule__AtomicExpression__Group_0_1__1__Impl ; | 15809 | // InternalSolverLanguageParser.g:5062:1: rule__AtomicExpression__Group_4__1 : rule__AtomicExpression__Group_4__1__Impl rule__AtomicExpression__Group_4__2 ; |
17222 | public final void rule__AtomicExpression__Group_0_1__1() throws RecognitionException { | 15810 | public final void rule__AtomicExpression__Group_4__1() throws RecognitionException { |
17223 | 15811 | ||
17224 | int stackSize = keepStackSize(); | 15812 | int stackSize = keepStackSize(); |
17225 | 15813 | ||
17226 | try { | 15814 | try { |
17227 | // InternalSolverLanguage.g:5068:1: ( rule__AtomicExpression__Group_0_1__1__Impl ) | 15815 | // InternalSolverLanguageParser.g:5066:1: ( rule__AtomicExpression__Group_4__1__Impl rule__AtomicExpression__Group_4__2 ) |
17228 | // InternalSolverLanguage.g:5069:2: rule__AtomicExpression__Group_0_1__1__Impl | 15816 | // InternalSolverLanguageParser.g:5067:2: rule__AtomicExpression__Group_4__1__Impl rule__AtomicExpression__Group_4__2 |
17229 | { | 15817 | { |
17230 | pushFollow(FOLLOW_2); | 15818 | pushFollow(FOLLOW_33); |
17231 | rule__AtomicExpression__Group_0_1__1__Impl(); | 15819 | rule__AtomicExpression__Group_4__1__Impl(); |
17232 | 15820 | ||
17233 | state._fsp--; | 15821 | state._fsp--; |
17234 | if (state.failed) return ; | ||
17235 | |||
17236 | } | ||
17237 | |||
17238 | } | ||
17239 | catch (RecognitionException re) { | ||
17240 | reportError(re); | ||
17241 | recover(input,re); | ||
17242 | } | ||
17243 | finally { | ||
17244 | |||
17245 | restoreStackSize(stackSize); | ||
17246 | |||
17247 | } | ||
17248 | return ; | ||
17249 | } | ||
17250 | // $ANTLR end "rule__AtomicExpression__Group_0_1__1" | ||
17251 | 15822 | ||
17252 | |||
17253 | // $ANTLR start "rule__AtomicExpression__Group_0_1__1__Impl" | ||
17254 | // InternalSolverLanguage.g:5075:1: rule__AtomicExpression__Group_0_1__1__Impl : ( ( rule__AtomicExpression__ArgumentListAssignment_0_1_1 ) ) ; | ||
17255 | public final void rule__AtomicExpression__Group_0_1__1__Impl() throws RecognitionException { | ||
17256 | |||
17257 | int stackSize = keepStackSize(); | ||
17258 | |||
17259 | try { | ||
17260 | // InternalSolverLanguage.g:5079:1: ( ( ( rule__AtomicExpression__ArgumentListAssignment_0_1_1 ) ) ) | ||
17261 | // InternalSolverLanguage.g:5080:1: ( ( rule__AtomicExpression__ArgumentListAssignment_0_1_1 ) ) | ||
17262 | { | ||
17263 | // InternalSolverLanguage.g:5080:1: ( ( rule__AtomicExpression__ArgumentListAssignment_0_1_1 ) ) | ||
17264 | // InternalSolverLanguage.g:5081:2: ( rule__AtomicExpression__ArgumentListAssignment_0_1_1 ) | ||
17265 | { | ||
17266 | if ( state.backtracking==0 ) { | ||
17267 | before(grammarAccess.getAtomicExpressionAccess().getArgumentListAssignment_0_1_1()); | ||
17268 | } | ||
17269 | // InternalSolverLanguage.g:5082:2: ( rule__AtomicExpression__ArgumentListAssignment_0_1_1 ) | ||
17270 | // InternalSolverLanguage.g:5082:3: rule__AtomicExpression__ArgumentListAssignment_0_1_1 | ||
17271 | { | ||
17272 | pushFollow(FOLLOW_2); | 15823 | pushFollow(FOLLOW_2); |
17273 | rule__AtomicExpression__ArgumentListAssignment_0_1_1(); | 15824 | rule__AtomicExpression__Group_4__2(); |
17274 | |||
17275 | state._fsp--; | ||
17276 | if (state.failed) return ; | ||
17277 | |||
17278 | } | ||
17279 | |||
17280 | if ( state.backtracking==0 ) { | ||
17281 | after(grammarAccess.getAtomicExpressionAccess().getArgumentListAssignment_0_1_1()); | ||
17282 | } | ||
17283 | |||
17284 | } | ||
17285 | |||
17286 | |||
17287 | } | ||
17288 | |||
17289 | } | ||
17290 | catch (RecognitionException re) { | ||
17291 | reportError(re); | ||
17292 | recover(input,re); | ||
17293 | } | ||
17294 | finally { | ||
17295 | |||
17296 | restoreStackSize(stackSize); | ||
17297 | |||
17298 | } | ||
17299 | return ; | ||
17300 | } | ||
17301 | // $ANTLR end "rule__AtomicExpression__Group_0_1__1__Impl" | ||
17302 | |||
17303 | |||
17304 | // $ANTLR start "rule__AtomicExpression__Group_3__0" | ||
17305 | // InternalSolverLanguage.g:5091:1: rule__AtomicExpression__Group_3__0 : rule__AtomicExpression__Group_3__0__Impl rule__AtomicExpression__Group_3__1 ; | ||
17306 | public final void rule__AtomicExpression__Group_3__0() throws RecognitionException { | ||
17307 | |||
17308 | int stackSize = keepStackSize(); | ||
17309 | |||
17310 | try { | ||
17311 | // InternalSolverLanguage.g:5095:1: ( rule__AtomicExpression__Group_3__0__Impl rule__AtomicExpression__Group_3__1 ) | ||
17312 | // InternalSolverLanguage.g:5096:2: rule__AtomicExpression__Group_3__0__Impl rule__AtomicExpression__Group_3__1 | ||
17313 | { | ||
17314 | pushFollow(FOLLOW_7); | ||
17315 | rule__AtomicExpression__Group_3__0__Impl(); | ||
17316 | 15825 | ||
17317 | state._fsp--; | 15826 | state._fsp--; |
17318 | if (state.failed) return ; | ||
17319 | pushFollow(FOLLOW_2); | ||
17320 | rule__AtomicExpression__Group_3__1(); | ||
17321 | 15827 | ||
17322 | state._fsp--; | ||
17323 | if (state.failed) return ; | ||
17324 | 15828 | ||
17325 | } | 15829 | } |
17326 | 15830 | ||
@@ -17336,112 +15840,29 @@ public class InternalSolverLanguageParser extends AbstractInternalContentAssistP | |||
17336 | } | 15840 | } |
17337 | return ; | 15841 | return ; |
17338 | } | 15842 | } |
17339 | // $ANTLR end "rule__AtomicExpression__Group_3__0" | 15843 | // $ANTLR end "rule__AtomicExpression__Group_4__1" |
17340 | 15844 | ||
17341 | 15845 | ||
17342 | // $ANTLR start "rule__AtomicExpression__Group_3__0__Impl" | 15846 | // $ANTLR start "rule__AtomicExpression__Group_4__1__Impl" |
17343 | // InternalSolverLanguage.g:5103:1: rule__AtomicExpression__Group_3__0__Impl : ( '(' ) ; | 15847 | // InternalSolverLanguageParser.g:5074:1: rule__AtomicExpression__Group_4__1__Impl : ( ruleExpression ) ; |
17344 | public final void rule__AtomicExpression__Group_3__0__Impl() throws RecognitionException { | 15848 | public final void rule__AtomicExpression__Group_4__1__Impl() throws RecognitionException { |
17345 | 15849 | ||
17346 | int stackSize = keepStackSize(); | 15850 | int stackSize = keepStackSize(); |
17347 | 15851 | ||
17348 | try { | 15852 | try { |
17349 | // InternalSolverLanguage.g:5107:1: ( ( '(' ) ) | 15853 | // InternalSolverLanguageParser.g:5078:1: ( ( ruleExpression ) ) |
17350 | // InternalSolverLanguage.g:5108:1: ( '(' ) | 15854 | // InternalSolverLanguageParser.g:5079:1: ( ruleExpression ) |
17351 | { | 15855 | { |
17352 | // InternalSolverLanguage.g:5108:1: ( '(' ) | 15856 | // InternalSolverLanguageParser.g:5079:1: ( ruleExpression ) |
17353 | // InternalSolverLanguage.g:5109:2: '(' | 15857 | // InternalSolverLanguageParser.g:5080:2: ruleExpression |
17354 | { | 15858 | { |
17355 | if ( state.backtracking==0 ) { | 15859 | before(grammarAccess.getAtomicExpressionAccess().getExpressionParserRuleCall_4_1()); |
17356 | before(grammarAccess.getAtomicExpressionAccess().getLeftParenthesisKeyword_3_0()); | ||
17357 | } | ||
17358 | match(input,61,FOLLOW_2); if (state.failed) return ; | ||
17359 | if ( state.backtracking==0 ) { | ||
17360 | after(grammarAccess.getAtomicExpressionAccess().getLeftParenthesisKeyword_3_0()); | ||
17361 | } | ||
17362 | |||
17363 | } | ||
17364 | |||
17365 | |||
17366 | } | ||
17367 | |||
17368 | } | ||
17369 | catch (RecognitionException re) { | ||
17370 | reportError(re); | ||
17371 | recover(input,re); | ||
17372 | } | ||
17373 | finally { | ||
17374 | |||
17375 | restoreStackSize(stackSize); | ||
17376 | |||
17377 | } | ||
17378 | return ; | ||
17379 | } | ||
17380 | // $ANTLR end "rule__AtomicExpression__Group_3__0__Impl" | ||
17381 | |||
17382 | |||
17383 | // $ANTLR start "rule__AtomicExpression__Group_3__1" | ||
17384 | // InternalSolverLanguage.g:5118:1: rule__AtomicExpression__Group_3__1 : rule__AtomicExpression__Group_3__1__Impl rule__AtomicExpression__Group_3__2 ; | ||
17385 | public final void rule__AtomicExpression__Group_3__1() throws RecognitionException { | ||
17386 | |||
17387 | int stackSize = keepStackSize(); | ||
17388 | |||
17389 | try { | ||
17390 | // InternalSolverLanguage.g:5122:1: ( rule__AtomicExpression__Group_3__1__Impl rule__AtomicExpression__Group_3__2 ) | ||
17391 | // InternalSolverLanguage.g:5123:2: rule__AtomicExpression__Group_3__1__Impl rule__AtomicExpression__Group_3__2 | ||
17392 | { | ||
17393 | pushFollow(FOLLOW_34); | ||
17394 | rule__AtomicExpression__Group_3__1__Impl(); | ||
17395 | |||
17396 | state._fsp--; | ||
17397 | if (state.failed) return ; | ||
17398 | pushFollow(FOLLOW_2); | ||
17399 | rule__AtomicExpression__Group_3__2(); | ||
17400 | |||
17401 | state._fsp--; | ||
17402 | if (state.failed) return ; | ||
17403 | |||
17404 | } | ||
17405 | |||
17406 | } | ||
17407 | catch (RecognitionException re) { | ||
17408 | reportError(re); | ||
17409 | recover(input,re); | ||
17410 | } | ||
17411 | finally { | ||
17412 | |||
17413 | restoreStackSize(stackSize); | ||
17414 | |||
17415 | } | ||
17416 | return ; | ||
17417 | } | ||
17418 | // $ANTLR end "rule__AtomicExpression__Group_3__1" | ||
17419 | |||
17420 | |||
17421 | // $ANTLR start "rule__AtomicExpression__Group_3__1__Impl" | ||
17422 | // InternalSolverLanguage.g:5130:1: rule__AtomicExpression__Group_3__1__Impl : ( ruleExpression ) ; | ||
17423 | public final void rule__AtomicExpression__Group_3__1__Impl() throws RecognitionException { | ||
17424 | |||
17425 | int stackSize = keepStackSize(); | ||
17426 | |||
17427 | try { | ||
17428 | // InternalSolverLanguage.g:5134:1: ( ( ruleExpression ) ) | ||
17429 | // InternalSolverLanguage.g:5135:1: ( ruleExpression ) | ||
17430 | { | ||
17431 | // InternalSolverLanguage.g:5135:1: ( ruleExpression ) | ||
17432 | // InternalSolverLanguage.g:5136:2: ruleExpression | ||
17433 | { | ||
17434 | if ( state.backtracking==0 ) { | ||
17435 | before(grammarAccess.getAtomicExpressionAccess().getExpressionParserRuleCall_3_1()); | ||
17436 | } | ||
17437 | pushFollow(FOLLOW_2); | 15860 | pushFollow(FOLLOW_2); |
17438 | ruleExpression(); | 15861 | ruleExpression(); |
17439 | 15862 | ||
17440 | state._fsp--; | 15863 | state._fsp--; |
17441 | if (state.failed) return ; | 15864 | |
17442 | if ( state.backtracking==0 ) { | 15865 | after(grammarAccess.getAtomicExpressionAccess().getExpressionParserRuleCall_4_1()); |
17443 | after(grammarAccess.getAtomicExpressionAccess().getExpressionParserRuleCall_3_1()); | ||
17444 | } | ||
17445 | 15866 | ||
17446 | } | 15867 | } |
17447 | 15868 | ||
@@ -17460,24 +15881,24 @@ public class InternalSolverLanguageParser extends AbstractInternalContentAssistP | |||
17460 | } | 15881 | } |
17461 | return ; | 15882 | return ; |
17462 | } | 15883 | } |
17463 | // $ANTLR end "rule__AtomicExpression__Group_3__1__Impl" | 15884 | // $ANTLR end "rule__AtomicExpression__Group_4__1__Impl" |
17464 | 15885 | ||
17465 | 15886 | ||
17466 | // $ANTLR start "rule__AtomicExpression__Group_3__2" | 15887 | // $ANTLR start "rule__AtomicExpression__Group_4__2" |
17467 | // InternalSolverLanguage.g:5145:1: rule__AtomicExpression__Group_3__2 : rule__AtomicExpression__Group_3__2__Impl ; | 15888 | // InternalSolverLanguageParser.g:5089:1: rule__AtomicExpression__Group_4__2 : rule__AtomicExpression__Group_4__2__Impl ; |
17468 | public final void rule__AtomicExpression__Group_3__2() throws RecognitionException { | 15889 | public final void rule__AtomicExpression__Group_4__2() throws RecognitionException { |
17469 | 15890 | ||
17470 | int stackSize = keepStackSize(); | 15891 | int stackSize = keepStackSize(); |
17471 | 15892 | ||
17472 | try { | 15893 | try { |
17473 | // InternalSolverLanguage.g:5149:1: ( rule__AtomicExpression__Group_3__2__Impl ) | 15894 | // InternalSolverLanguageParser.g:5093:1: ( rule__AtomicExpression__Group_4__2__Impl ) |
17474 | // InternalSolverLanguage.g:5150:2: rule__AtomicExpression__Group_3__2__Impl | 15895 | // InternalSolverLanguageParser.g:5094:2: rule__AtomicExpression__Group_4__2__Impl |
17475 | { | 15896 | { |
17476 | pushFollow(FOLLOW_2); | 15897 | pushFollow(FOLLOW_2); |
17477 | rule__AtomicExpression__Group_3__2__Impl(); | 15898 | rule__AtomicExpression__Group_4__2__Impl(); |
17478 | 15899 | ||
17479 | state._fsp--; | 15900 | state._fsp--; |
17480 | if (state.failed) return ; | 15901 | |
17481 | 15902 | ||
17482 | } | 15903 | } |
17483 | 15904 | ||
@@ -17493,29 +15914,25 @@ public class InternalSolverLanguageParser extends AbstractInternalContentAssistP | |||
17493 | } | 15914 | } |
17494 | return ; | 15915 | return ; |
17495 | } | 15916 | } |
17496 | // $ANTLR end "rule__AtomicExpression__Group_3__2" | 15917 | // $ANTLR end "rule__AtomicExpression__Group_4__2" |
17497 | 15918 | ||
17498 | 15919 | ||
17499 | // $ANTLR start "rule__AtomicExpression__Group_3__2__Impl" | 15920 | // $ANTLR start "rule__AtomicExpression__Group_4__2__Impl" |
17500 | // InternalSolverLanguage.g:5156:1: rule__AtomicExpression__Group_3__2__Impl : ( ')' ) ; | 15921 | // InternalSolverLanguageParser.g:5100:1: rule__AtomicExpression__Group_4__2__Impl : ( RightParenthesis ) ; |
17501 | public final void rule__AtomicExpression__Group_3__2__Impl() throws RecognitionException { | 15922 | public final void rule__AtomicExpression__Group_4__2__Impl() throws RecognitionException { |
17502 | 15923 | ||
17503 | int stackSize = keepStackSize(); | 15924 | int stackSize = keepStackSize(); |
17504 | 15925 | ||
17505 | try { | 15926 | try { |
17506 | // InternalSolverLanguage.g:5160:1: ( ( ')' ) ) | 15927 | // InternalSolverLanguageParser.g:5104:1: ( ( RightParenthesis ) ) |
17507 | // InternalSolverLanguage.g:5161:1: ( ')' ) | 15928 | // InternalSolverLanguageParser.g:5105:1: ( RightParenthesis ) |
17508 | { | 15929 | { |
17509 | // InternalSolverLanguage.g:5161:1: ( ')' ) | 15930 | // InternalSolverLanguageParser.g:5105:1: ( RightParenthesis ) |
17510 | // InternalSolverLanguage.g:5162:2: ')' | 15931 | // InternalSolverLanguageParser.g:5106:2: RightParenthesis |
17511 | { | 15932 | { |
17512 | if ( state.backtracking==0 ) { | 15933 | before(grammarAccess.getAtomicExpressionAccess().getRightParenthesisKeyword_4_2()); |
17513 | before(grammarAccess.getAtomicExpressionAccess().getRightParenthesisKeyword_3_2()); | 15934 | match(input,RightParenthesis,FOLLOW_2); |
17514 | } | 15935 | after(grammarAccess.getAtomicExpressionAccess().getRightParenthesisKeyword_4_2()); |
17515 | match(input,62,FOLLOW_2); if (state.failed) return ; | ||
17516 | if ( state.backtracking==0 ) { | ||
17517 | after(grammarAccess.getAtomicExpressionAccess().getRightParenthesisKeyword_3_2()); | ||
17518 | } | ||
17519 | 15936 | ||
17520 | } | 15937 | } |
17521 | 15938 | ||
@@ -17534,29 +15951,29 @@ public class InternalSolverLanguageParser extends AbstractInternalContentAssistP | |||
17534 | } | 15951 | } |
17535 | return ; | 15952 | return ; |
17536 | } | 15953 | } |
17537 | // $ANTLR end "rule__AtomicExpression__Group_3__2__Impl" | 15954 | // $ANTLR end "rule__AtomicExpression__Group_4__2__Impl" |
17538 | 15955 | ||
17539 | 15956 | ||
17540 | // $ANTLR start "rule__Call__Group__0" | 15957 | // $ANTLR start "rule__Call__Group__0" |
17541 | // InternalSolverLanguage.g:5172:1: rule__Call__Group__0 : rule__Call__Group__0__Impl rule__Call__Group__1 ; | 15958 | // InternalSolverLanguageParser.g:5116:1: rule__Call__Group__0 : rule__Call__Group__0__Impl rule__Call__Group__1 ; |
17542 | public final void rule__Call__Group__0() throws RecognitionException { | 15959 | public final void rule__Call__Group__0() throws RecognitionException { |
17543 | 15960 | ||
17544 | int stackSize = keepStackSize(); | 15961 | int stackSize = keepStackSize(); |
17545 | 15962 | ||
17546 | try { | 15963 | try { |
17547 | // InternalSolverLanguage.g:5176:1: ( rule__Call__Group__0__Impl rule__Call__Group__1 ) | 15964 | // InternalSolverLanguageParser.g:5120:1: ( rule__Call__Group__0__Impl rule__Call__Group__1 ) |
17548 | // InternalSolverLanguage.g:5177:2: rule__Call__Group__0__Impl rule__Call__Group__1 | 15965 | // InternalSolverLanguageParser.g:5121:2: rule__Call__Group__0__Impl rule__Call__Group__1 |
17549 | { | 15966 | { |
17550 | pushFollow(FOLLOW_35); | 15967 | pushFollow(FOLLOW_34); |
17551 | rule__Call__Group__0__Impl(); | 15968 | rule__Call__Group__0__Impl(); |
17552 | 15969 | ||
17553 | state._fsp--; | 15970 | state._fsp--; |
17554 | if (state.failed) return ; | 15971 | |
17555 | pushFollow(FOLLOW_2); | 15972 | pushFollow(FOLLOW_2); |
17556 | rule__Call__Group__1(); | 15973 | rule__Call__Group__1(); |
17557 | 15974 | ||
17558 | state._fsp--; | 15975 | state._fsp--; |
17559 | if (state.failed) return ; | 15976 | |
17560 | 15977 | ||
17561 | } | 15978 | } |
17562 | 15979 | ||
@@ -17576,36 +15993,32 @@ public class InternalSolverLanguageParser extends AbstractInternalContentAssistP | |||
17576 | 15993 | ||
17577 | 15994 | ||
17578 | // $ANTLR start "rule__Call__Group__0__Impl" | 15995 | // $ANTLR start "rule__Call__Group__0__Impl" |
17579 | // InternalSolverLanguage.g:5184:1: rule__Call__Group__0__Impl : ( ( rule__Call__FunctorAssignment_0 ) ) ; | 15996 | // InternalSolverLanguageParser.g:5128:1: rule__Call__Group__0__Impl : ( ( rule__Call__FunctorAssignment_0 ) ) ; |
17580 | public final void rule__Call__Group__0__Impl() throws RecognitionException { | 15997 | public final void rule__Call__Group__0__Impl() throws RecognitionException { |
17581 | 15998 | ||
17582 | int stackSize = keepStackSize(); | 15999 | int stackSize = keepStackSize(); |
17583 | 16000 | ||
17584 | try { | 16001 | try { |
17585 | // InternalSolverLanguage.g:5188:1: ( ( ( rule__Call__FunctorAssignment_0 ) ) ) | 16002 | // InternalSolverLanguageParser.g:5132:1: ( ( ( rule__Call__FunctorAssignment_0 ) ) ) |
17586 | // InternalSolverLanguage.g:5189:1: ( ( rule__Call__FunctorAssignment_0 ) ) | 16003 | // InternalSolverLanguageParser.g:5133:1: ( ( rule__Call__FunctorAssignment_0 ) ) |
17587 | { | 16004 | { |
17588 | // InternalSolverLanguage.g:5189:1: ( ( rule__Call__FunctorAssignment_0 ) ) | 16005 | // InternalSolverLanguageParser.g:5133:1: ( ( rule__Call__FunctorAssignment_0 ) ) |
17589 | // InternalSolverLanguage.g:5190:2: ( rule__Call__FunctorAssignment_0 ) | 16006 | // InternalSolverLanguageParser.g:5134:2: ( rule__Call__FunctorAssignment_0 ) |
17590 | { | 16007 | { |
17591 | if ( state.backtracking==0 ) { | 16008 | before(grammarAccess.getCallAccess().getFunctorAssignment_0()); |
17592 | before(grammarAccess.getCallAccess().getFunctorAssignment_0()); | 16009 | // InternalSolverLanguageParser.g:5135:2: ( rule__Call__FunctorAssignment_0 ) |
17593 | } | 16010 | // InternalSolverLanguageParser.g:5135:3: rule__Call__FunctorAssignment_0 |
17594 | // InternalSolverLanguage.g:5191:2: ( rule__Call__FunctorAssignment_0 ) | ||
17595 | // InternalSolverLanguage.g:5191:3: rule__Call__FunctorAssignment_0 | ||
17596 | { | 16011 | { |
17597 | pushFollow(FOLLOW_2); | 16012 | pushFollow(FOLLOW_2); |
17598 | rule__Call__FunctorAssignment_0(); | 16013 | rule__Call__FunctorAssignment_0(); |
17599 | 16014 | ||
17600 | state._fsp--; | 16015 | state._fsp--; |
17601 | if (state.failed) return ; | ||
17602 | 16016 | ||
17603 | } | ||
17604 | 16017 | ||
17605 | if ( state.backtracking==0 ) { | ||
17606 | after(grammarAccess.getCallAccess().getFunctorAssignment_0()); | ||
17607 | } | 16018 | } |
17608 | 16019 | ||
16020 | after(grammarAccess.getCallAccess().getFunctorAssignment_0()); | ||
16021 | |||
17609 | } | 16022 | } |
17610 | 16023 | ||
17611 | 16024 | ||
@@ -17627,25 +16040,25 @@ public class InternalSolverLanguageParser extends AbstractInternalContentAssistP | |||
17627 | 16040 | ||
17628 | 16041 | ||
17629 | // $ANTLR start "rule__Call__Group__1" | 16042 | // $ANTLR start "rule__Call__Group__1" |
17630 | // InternalSolverLanguage.g:5199:1: rule__Call__Group__1 : rule__Call__Group__1__Impl rule__Call__Group__2 ; | 16043 | // InternalSolverLanguageParser.g:5143:1: rule__Call__Group__1 : rule__Call__Group__1__Impl rule__Call__Group__2 ; |
17631 | public final void rule__Call__Group__1() throws RecognitionException { | 16044 | public final void rule__Call__Group__1() throws RecognitionException { |
17632 | 16045 | ||
17633 | int stackSize = keepStackSize(); | 16046 | int stackSize = keepStackSize(); |
17634 | 16047 | ||
17635 | try { | 16048 | try { |
17636 | // InternalSolverLanguage.g:5203:1: ( rule__Call__Group__1__Impl rule__Call__Group__2 ) | 16049 | // InternalSolverLanguageParser.g:5147:1: ( rule__Call__Group__1__Impl rule__Call__Group__2 ) |
17637 | // InternalSolverLanguage.g:5204:2: rule__Call__Group__1__Impl rule__Call__Group__2 | 16050 | // InternalSolverLanguageParser.g:5148:2: rule__Call__Group__1__Impl rule__Call__Group__2 |
17638 | { | 16051 | { |
17639 | pushFollow(FOLLOW_35); | 16052 | pushFollow(FOLLOW_34); |
17640 | rule__Call__Group__1__Impl(); | 16053 | rule__Call__Group__1__Impl(); |
17641 | 16054 | ||
17642 | state._fsp--; | 16055 | state._fsp--; |
17643 | if (state.failed) return ; | 16056 | |
17644 | pushFollow(FOLLOW_2); | 16057 | pushFollow(FOLLOW_2); |
17645 | rule__Call__Group__2(); | 16058 | rule__Call__Group__2(); |
17646 | 16059 | ||
17647 | state._fsp--; | 16060 | state._fsp--; |
17648 | if (state.failed) return ; | 16061 | |
17649 | 16062 | ||
17650 | } | 16063 | } |
17651 | 16064 | ||
@@ -17665,46 +16078,42 @@ public class InternalSolverLanguageParser extends AbstractInternalContentAssistP | |||
17665 | 16078 | ||
17666 | 16079 | ||
17667 | // $ANTLR start "rule__Call__Group__1__Impl" | 16080 | // $ANTLR start "rule__Call__Group__1__Impl" |
17668 | // InternalSolverLanguage.g:5211:1: rule__Call__Group__1__Impl : ( ( rule__Call__Alternatives_1 )? ) ; | 16081 | // InternalSolverLanguageParser.g:5155:1: rule__Call__Group__1__Impl : ( ( rule__Call__Alternatives_1 )? ) ; |
17669 | public final void rule__Call__Group__1__Impl() throws RecognitionException { | 16082 | public final void rule__Call__Group__1__Impl() throws RecognitionException { |
17670 | 16083 | ||
17671 | int stackSize = keepStackSize(); | 16084 | int stackSize = keepStackSize(); |
17672 | 16085 | ||
17673 | try { | 16086 | try { |
17674 | // InternalSolverLanguage.g:5215:1: ( ( ( rule__Call__Alternatives_1 )? ) ) | 16087 | // InternalSolverLanguageParser.g:5159:1: ( ( ( rule__Call__Alternatives_1 )? ) ) |
17675 | // InternalSolverLanguage.g:5216:1: ( ( rule__Call__Alternatives_1 )? ) | 16088 | // InternalSolverLanguageParser.g:5160:1: ( ( rule__Call__Alternatives_1 )? ) |
17676 | { | 16089 | { |
17677 | // InternalSolverLanguage.g:5216:1: ( ( rule__Call__Alternatives_1 )? ) | 16090 | // InternalSolverLanguageParser.g:5160:1: ( ( rule__Call__Alternatives_1 )? ) |
17678 | // InternalSolverLanguage.g:5217:2: ( rule__Call__Alternatives_1 )? | 16091 | // InternalSolverLanguageParser.g:5161:2: ( rule__Call__Alternatives_1 )? |
17679 | { | 16092 | { |
17680 | if ( state.backtracking==0 ) { | 16093 | before(grammarAccess.getCallAccess().getAlternatives_1()); |
17681 | before(grammarAccess.getCallAccess().getAlternatives_1()); | 16094 | // InternalSolverLanguageParser.g:5162:2: ( rule__Call__Alternatives_1 )? |
17682 | } | 16095 | int alt39=2; |
17683 | // InternalSolverLanguage.g:5218:2: ( rule__Call__Alternatives_1 )? | 16096 | int LA39_0 = input.LA(1); |
17684 | int alt40=2; | ||
17685 | int LA40_0 = input.LA(1); | ||
17686 | 16097 | ||
17687 | if ( ((LA40_0>=RULE_STAR && LA40_0<=RULE_PLUS)) ) { | 16098 | if ( ((LA39_0>=RULE_TRANSITIVE_CLOSURE && LA39_0<=RULE_REFLEXIVE_TRANSITIVE_CLOSURE)) ) { |
17688 | alt40=1; | 16099 | alt39=1; |
17689 | } | 16100 | } |
17690 | switch (alt40) { | 16101 | switch (alt39) { |
17691 | case 1 : | 16102 | case 1 : |
17692 | // InternalSolverLanguage.g:5218:3: rule__Call__Alternatives_1 | 16103 | // InternalSolverLanguageParser.g:5162:3: rule__Call__Alternatives_1 |
17693 | { | 16104 | { |
17694 | pushFollow(FOLLOW_2); | 16105 | pushFollow(FOLLOW_2); |
17695 | rule__Call__Alternatives_1(); | 16106 | rule__Call__Alternatives_1(); |
17696 | 16107 | ||
17697 | state._fsp--; | 16108 | state._fsp--; |
17698 | if (state.failed) return ; | 16109 | |
17699 | 16110 | ||
17700 | } | 16111 | } |
17701 | break; | 16112 | break; |
17702 | 16113 | ||
17703 | } | 16114 | } |
17704 | 16115 | ||
17705 | if ( state.backtracking==0 ) { | 16116 | after(grammarAccess.getCallAccess().getAlternatives_1()); |
17706 | after(grammarAccess.getCallAccess().getAlternatives_1()); | ||
17707 | } | ||
17708 | 16117 | ||
17709 | } | 16118 | } |
17710 | 16119 | ||
@@ -17727,20 +16136,20 @@ public class InternalSolverLanguageParser extends AbstractInternalContentAssistP | |||
17727 | 16136 | ||
17728 | 16137 | ||
17729 | // $ANTLR start "rule__Call__Group__2" | 16138 | // $ANTLR start "rule__Call__Group__2" |
17730 | // InternalSolverLanguage.g:5226:1: rule__Call__Group__2 : rule__Call__Group__2__Impl ; | 16139 | // InternalSolverLanguageParser.g:5170:1: rule__Call__Group__2 : rule__Call__Group__2__Impl ; |
17731 | public final void rule__Call__Group__2() throws RecognitionException { | 16140 | public final void rule__Call__Group__2() throws RecognitionException { |
17732 | 16141 | ||
17733 | int stackSize = keepStackSize(); | 16142 | int stackSize = keepStackSize(); |
17734 | 16143 | ||
17735 | try { | 16144 | try { |
17736 | // InternalSolverLanguage.g:5230:1: ( rule__Call__Group__2__Impl ) | 16145 | // InternalSolverLanguageParser.g:5174:1: ( rule__Call__Group__2__Impl ) |
17737 | // InternalSolverLanguage.g:5231:2: rule__Call__Group__2__Impl | 16146 | // InternalSolverLanguageParser.g:5175:2: rule__Call__Group__2__Impl |
17738 | { | 16147 | { |
17739 | pushFollow(FOLLOW_2); | 16148 | pushFollow(FOLLOW_2); |
17740 | rule__Call__Group__2__Impl(); | 16149 | rule__Call__Group__2__Impl(); |
17741 | 16150 | ||
17742 | state._fsp--; | 16151 | state._fsp--; |
17743 | if (state.failed) return ; | 16152 | |
17744 | 16153 | ||
17745 | } | 16154 | } |
17746 | 16155 | ||
@@ -17760,36 +16169,32 @@ public class InternalSolverLanguageParser extends AbstractInternalContentAssistP | |||
17760 | 16169 | ||
17761 | 16170 | ||
17762 | // $ANTLR start "rule__Call__Group__2__Impl" | 16171 | // $ANTLR start "rule__Call__Group__2__Impl" |
17763 | // InternalSolverLanguage.g:5237:1: rule__Call__Group__2__Impl : ( ( rule__Call__ArgumentListAssignment_2 ) ) ; | 16172 | // InternalSolverLanguageParser.g:5181:1: rule__Call__Group__2__Impl : ( ( rule__Call__ArgumentListAssignment_2 ) ) ; |
17764 | public final void rule__Call__Group__2__Impl() throws RecognitionException { | 16173 | public final void rule__Call__Group__2__Impl() throws RecognitionException { |
17765 | 16174 | ||
17766 | int stackSize = keepStackSize(); | 16175 | int stackSize = keepStackSize(); |
17767 | 16176 | ||
17768 | try { | 16177 | try { |
17769 | // InternalSolverLanguage.g:5241:1: ( ( ( rule__Call__ArgumentListAssignment_2 ) ) ) | 16178 | // InternalSolverLanguageParser.g:5185:1: ( ( ( rule__Call__ArgumentListAssignment_2 ) ) ) |
17770 | // InternalSolverLanguage.g:5242:1: ( ( rule__Call__ArgumentListAssignment_2 ) ) | 16179 | // InternalSolverLanguageParser.g:5186:1: ( ( rule__Call__ArgumentListAssignment_2 ) ) |
17771 | { | 16180 | { |
17772 | // InternalSolverLanguage.g:5242:1: ( ( rule__Call__ArgumentListAssignment_2 ) ) | 16181 | // InternalSolverLanguageParser.g:5186:1: ( ( rule__Call__ArgumentListAssignment_2 ) ) |
17773 | // InternalSolverLanguage.g:5243:2: ( rule__Call__ArgumentListAssignment_2 ) | 16182 | // InternalSolverLanguageParser.g:5187:2: ( rule__Call__ArgumentListAssignment_2 ) |
17774 | { | 16183 | { |
17775 | if ( state.backtracking==0 ) { | 16184 | before(grammarAccess.getCallAccess().getArgumentListAssignment_2()); |
17776 | before(grammarAccess.getCallAccess().getArgumentListAssignment_2()); | 16185 | // InternalSolverLanguageParser.g:5188:2: ( rule__Call__ArgumentListAssignment_2 ) |
17777 | } | 16186 | // InternalSolverLanguageParser.g:5188:3: rule__Call__ArgumentListAssignment_2 |
17778 | // InternalSolverLanguage.g:5244:2: ( rule__Call__ArgumentListAssignment_2 ) | ||
17779 | // InternalSolverLanguage.g:5244:3: rule__Call__ArgumentListAssignment_2 | ||
17780 | { | 16187 | { |
17781 | pushFollow(FOLLOW_2); | 16188 | pushFollow(FOLLOW_2); |
17782 | rule__Call__ArgumentListAssignment_2(); | 16189 | rule__Call__ArgumentListAssignment_2(); |
17783 | 16190 | ||
17784 | state._fsp--; | 16191 | state._fsp--; |
17785 | if (state.failed) return ; | ||
17786 | 16192 | ||
17787 | } | ||
17788 | 16193 | ||
17789 | if ( state.backtracking==0 ) { | ||
17790 | after(grammarAccess.getCallAccess().getArgumentListAssignment_2()); | ||
17791 | } | 16194 | } |
17792 | 16195 | ||
16196 | after(grammarAccess.getCallAccess().getArgumentListAssignment_2()); | ||
16197 | |||
17793 | } | 16198 | } |
17794 | 16199 | ||
17795 | 16200 | ||
@@ -17811,25 +16216,25 @@ public class InternalSolverLanguageParser extends AbstractInternalContentAssistP | |||
17811 | 16216 | ||
17812 | 16217 | ||
17813 | // $ANTLR start "rule__ArgumentList__Group__0" | 16218 | // $ANTLR start "rule__ArgumentList__Group__0" |
17814 | // InternalSolverLanguage.g:5253:1: rule__ArgumentList__Group__0 : rule__ArgumentList__Group__0__Impl rule__ArgumentList__Group__1 ; | 16219 | // InternalSolverLanguageParser.g:5197:1: rule__ArgumentList__Group__0 : rule__ArgumentList__Group__0__Impl rule__ArgumentList__Group__1 ; |
17815 | public final void rule__ArgumentList__Group__0() throws RecognitionException { | 16220 | public final void rule__ArgumentList__Group__0() throws RecognitionException { |
17816 | 16221 | ||
17817 | int stackSize = keepStackSize(); | 16222 | int stackSize = keepStackSize(); |
17818 | 16223 | ||
17819 | try { | 16224 | try { |
17820 | // InternalSolverLanguage.g:5257:1: ( rule__ArgumentList__Group__0__Impl rule__ArgumentList__Group__1 ) | 16225 | // InternalSolverLanguageParser.g:5201:1: ( rule__ArgumentList__Group__0__Impl rule__ArgumentList__Group__1 ) |
17821 | // InternalSolverLanguage.g:5258:2: rule__ArgumentList__Group__0__Impl rule__ArgumentList__Group__1 | 16226 | // InternalSolverLanguageParser.g:5202:2: rule__ArgumentList__Group__0__Impl rule__ArgumentList__Group__1 |
17822 | { | 16227 | { |
17823 | pushFollow(FOLLOW_12); | 16228 | pushFollow(FOLLOW_12); |
17824 | rule__ArgumentList__Group__0__Impl(); | 16229 | rule__ArgumentList__Group__0__Impl(); |
17825 | 16230 | ||
17826 | state._fsp--; | 16231 | state._fsp--; |
17827 | if (state.failed) return ; | 16232 | |
17828 | pushFollow(FOLLOW_2); | 16233 | pushFollow(FOLLOW_2); |
17829 | rule__ArgumentList__Group__1(); | 16234 | rule__ArgumentList__Group__1(); |
17830 | 16235 | ||
17831 | state._fsp--; | 16236 | state._fsp--; |
17832 | if (state.failed) return ; | 16237 | |
17833 | 16238 | ||
17834 | } | 16239 | } |
17835 | 16240 | ||
@@ -17849,29 +16254,25 @@ public class InternalSolverLanguageParser extends AbstractInternalContentAssistP | |||
17849 | 16254 | ||
17850 | 16255 | ||
17851 | // $ANTLR start "rule__ArgumentList__Group__0__Impl" | 16256 | // $ANTLR start "rule__ArgumentList__Group__0__Impl" |
17852 | // InternalSolverLanguage.g:5265:1: rule__ArgumentList__Group__0__Impl : ( () ) ; | 16257 | // InternalSolverLanguageParser.g:5209:1: rule__ArgumentList__Group__0__Impl : ( () ) ; |
17853 | public final void rule__ArgumentList__Group__0__Impl() throws RecognitionException { | 16258 | public final void rule__ArgumentList__Group__0__Impl() throws RecognitionException { |
17854 | 16259 | ||
17855 | int stackSize = keepStackSize(); | 16260 | int stackSize = keepStackSize(); |
17856 | 16261 | ||
17857 | try { | 16262 | try { |
17858 | // InternalSolverLanguage.g:5269:1: ( ( () ) ) | 16263 | // InternalSolverLanguageParser.g:5213:1: ( ( () ) ) |
17859 | // InternalSolverLanguage.g:5270:1: ( () ) | 16264 | // InternalSolverLanguageParser.g:5214:1: ( () ) |
17860 | { | 16265 | { |
17861 | // InternalSolverLanguage.g:5270:1: ( () ) | 16266 | // InternalSolverLanguageParser.g:5214:1: ( () ) |
17862 | // InternalSolverLanguage.g:5271:2: () | 16267 | // InternalSolverLanguageParser.g:5215:2: () |
17863 | { | 16268 | { |
17864 | if ( state.backtracking==0 ) { | 16269 | before(grammarAccess.getArgumentListAccess().getArgumentListAction_0()); |
17865 | before(grammarAccess.getArgumentListAccess().getArgumentListAction_0()); | 16270 | // InternalSolverLanguageParser.g:5216:2: () |
17866 | } | 16271 | // InternalSolverLanguageParser.g:5216:3: |
17867 | // InternalSolverLanguage.g:5272:2: () | ||
17868 | // InternalSolverLanguage.g:5272:3: | ||
17869 | { | 16272 | { |
17870 | } | 16273 | } |
17871 | 16274 | ||
17872 | if ( state.backtracking==0 ) { | 16275 | after(grammarAccess.getArgumentListAccess().getArgumentListAction_0()); |
17873 | after(grammarAccess.getArgumentListAccess().getArgumentListAction_0()); | ||
17874 | } | ||
17875 | 16276 | ||
17876 | } | 16277 | } |
17877 | 16278 | ||
@@ -17890,25 +16291,25 @@ public class InternalSolverLanguageParser extends AbstractInternalContentAssistP | |||
17890 | 16291 | ||
17891 | 16292 | ||
17892 | // $ANTLR start "rule__ArgumentList__Group__1" | 16293 | // $ANTLR start "rule__ArgumentList__Group__1" |
17893 | // InternalSolverLanguage.g:5280:1: rule__ArgumentList__Group__1 : rule__ArgumentList__Group__1__Impl rule__ArgumentList__Group__2 ; | 16294 | // InternalSolverLanguageParser.g:5224:1: rule__ArgumentList__Group__1 : rule__ArgumentList__Group__1__Impl rule__ArgumentList__Group__2 ; |
17894 | public final void rule__ArgumentList__Group__1() throws RecognitionException { | 16295 | public final void rule__ArgumentList__Group__1() throws RecognitionException { |
17895 | 16296 | ||
17896 | int stackSize = keepStackSize(); | 16297 | int stackSize = keepStackSize(); |
17897 | 16298 | ||
17898 | try { | 16299 | try { |
17899 | // InternalSolverLanguage.g:5284:1: ( rule__ArgumentList__Group__1__Impl rule__ArgumentList__Group__2 ) | 16300 | // InternalSolverLanguageParser.g:5228:1: ( rule__ArgumentList__Group__1__Impl rule__ArgumentList__Group__2 ) |
17900 | // InternalSolverLanguage.g:5285:2: rule__ArgumentList__Group__1__Impl rule__ArgumentList__Group__2 | 16301 | // InternalSolverLanguageParser.g:5229:2: rule__ArgumentList__Group__1__Impl rule__ArgumentList__Group__2 |
17901 | { | 16302 | { |
17902 | pushFollow(FOLLOW_36); | 16303 | pushFollow(FOLLOW_35); |
17903 | rule__ArgumentList__Group__1__Impl(); | 16304 | rule__ArgumentList__Group__1__Impl(); |
17904 | 16305 | ||
17905 | state._fsp--; | 16306 | state._fsp--; |
17906 | if (state.failed) return ; | 16307 | |
17907 | pushFollow(FOLLOW_2); | 16308 | pushFollow(FOLLOW_2); |
17908 | rule__ArgumentList__Group__2(); | 16309 | rule__ArgumentList__Group__2(); |
17909 | 16310 | ||
17910 | state._fsp--; | 16311 | state._fsp--; |
17911 | if (state.failed) return ; | 16312 | |
17912 | 16313 | ||
17913 | } | 16314 | } |
17914 | 16315 | ||
@@ -17928,25 +16329,21 @@ public class InternalSolverLanguageParser extends AbstractInternalContentAssistP | |||
17928 | 16329 | ||
17929 | 16330 | ||
17930 | // $ANTLR start "rule__ArgumentList__Group__1__Impl" | 16331 | // $ANTLR start "rule__ArgumentList__Group__1__Impl" |
17931 | // InternalSolverLanguage.g:5292:1: rule__ArgumentList__Group__1__Impl : ( '(' ) ; | 16332 | // InternalSolverLanguageParser.g:5236:1: rule__ArgumentList__Group__1__Impl : ( LeftParenthesis ) ; |
17932 | public final void rule__ArgumentList__Group__1__Impl() throws RecognitionException { | 16333 | public final void rule__ArgumentList__Group__1__Impl() throws RecognitionException { |
17933 | 16334 | ||
17934 | int stackSize = keepStackSize(); | 16335 | int stackSize = keepStackSize(); |
17935 | 16336 | ||
17936 | try { | 16337 | try { |
17937 | // InternalSolverLanguage.g:5296:1: ( ( '(' ) ) | 16338 | // InternalSolverLanguageParser.g:5240:1: ( ( LeftParenthesis ) ) |
17938 | // InternalSolverLanguage.g:5297:1: ( '(' ) | 16339 | // InternalSolverLanguageParser.g:5241:1: ( LeftParenthesis ) |
17939 | { | 16340 | { |
17940 | // InternalSolverLanguage.g:5297:1: ( '(' ) | 16341 | // InternalSolverLanguageParser.g:5241:1: ( LeftParenthesis ) |
17941 | // InternalSolverLanguage.g:5298:2: '(' | 16342 | // InternalSolverLanguageParser.g:5242:2: LeftParenthesis |
17942 | { | 16343 | { |
17943 | if ( state.backtracking==0 ) { | 16344 | before(grammarAccess.getArgumentListAccess().getLeftParenthesisKeyword_1()); |
17944 | before(grammarAccess.getArgumentListAccess().getLeftParenthesisKeyword_1()); | 16345 | match(input,LeftParenthesis,FOLLOW_2); |
17945 | } | 16346 | after(grammarAccess.getArgumentListAccess().getLeftParenthesisKeyword_1()); |
17946 | match(input,61,FOLLOW_2); if (state.failed) return ; | ||
17947 | if ( state.backtracking==0 ) { | ||
17948 | after(grammarAccess.getArgumentListAccess().getLeftParenthesisKeyword_1()); | ||
17949 | } | ||
17950 | 16347 | ||
17951 | } | 16348 | } |
17952 | 16349 | ||
@@ -17969,25 +16366,25 @@ public class InternalSolverLanguageParser extends AbstractInternalContentAssistP | |||
17969 | 16366 | ||
17970 | 16367 | ||
17971 | // $ANTLR start "rule__ArgumentList__Group__2" | 16368 | // $ANTLR start "rule__ArgumentList__Group__2" |
17972 | // InternalSolverLanguage.g:5307:1: rule__ArgumentList__Group__2 : rule__ArgumentList__Group__2__Impl rule__ArgumentList__Group__3 ; | 16369 | // InternalSolverLanguageParser.g:5251:1: rule__ArgumentList__Group__2 : rule__ArgumentList__Group__2__Impl rule__ArgumentList__Group__3 ; |
17973 | public final void rule__ArgumentList__Group__2() throws RecognitionException { | 16370 | public final void rule__ArgumentList__Group__2() throws RecognitionException { |
17974 | 16371 | ||
17975 | int stackSize = keepStackSize(); | 16372 | int stackSize = keepStackSize(); |
17976 | 16373 | ||
17977 | try { | 16374 | try { |
17978 | // InternalSolverLanguage.g:5311:1: ( rule__ArgumentList__Group__2__Impl rule__ArgumentList__Group__3 ) | 16375 | // InternalSolverLanguageParser.g:5255:1: ( rule__ArgumentList__Group__2__Impl rule__ArgumentList__Group__3 ) |
17979 | // InternalSolverLanguage.g:5312:2: rule__ArgumentList__Group__2__Impl rule__ArgumentList__Group__3 | 16376 | // InternalSolverLanguageParser.g:5256:2: rule__ArgumentList__Group__2__Impl rule__ArgumentList__Group__3 |
17980 | { | 16377 | { |
17981 | pushFollow(FOLLOW_36); | 16378 | pushFollow(FOLLOW_35); |
17982 | rule__ArgumentList__Group__2__Impl(); | 16379 | rule__ArgumentList__Group__2__Impl(); |
17983 | 16380 | ||
17984 | state._fsp--; | 16381 | state._fsp--; |
17985 | if (state.failed) return ; | 16382 | |
17986 | pushFollow(FOLLOW_2); | 16383 | pushFollow(FOLLOW_2); |
17987 | rule__ArgumentList__Group__3(); | 16384 | rule__ArgumentList__Group__3(); |
17988 | 16385 | ||
17989 | state._fsp--; | 16386 | state._fsp--; |
17990 | if (state.failed) return ; | 16387 | |
17991 | 16388 | ||
17992 | } | 16389 | } |
17993 | 16390 | ||
@@ -18007,46 +16404,42 @@ public class InternalSolverLanguageParser extends AbstractInternalContentAssistP | |||
18007 | 16404 | ||
18008 | 16405 | ||
18009 | // $ANTLR start "rule__ArgumentList__Group__2__Impl" | 16406 | // $ANTLR start "rule__ArgumentList__Group__2__Impl" |
18010 | // InternalSolverLanguage.g:5319:1: rule__ArgumentList__Group__2__Impl : ( ( rule__ArgumentList__Group_2__0 )? ) ; | 16407 | // InternalSolverLanguageParser.g:5263:1: rule__ArgumentList__Group__2__Impl : ( ( rule__ArgumentList__Group_2__0 )? ) ; |
18011 | public final void rule__ArgumentList__Group__2__Impl() throws RecognitionException { | 16408 | public final void rule__ArgumentList__Group__2__Impl() throws RecognitionException { |
18012 | 16409 | ||
18013 | int stackSize = keepStackSize(); | 16410 | int stackSize = keepStackSize(); |
18014 | 16411 | ||
18015 | try { | 16412 | try { |
18016 | // InternalSolverLanguage.g:5323:1: ( ( ( rule__ArgumentList__Group_2__0 )? ) ) | 16413 | // InternalSolverLanguageParser.g:5267:1: ( ( ( rule__ArgumentList__Group_2__0 )? ) ) |
18017 | // InternalSolverLanguage.g:5324:1: ( ( rule__ArgumentList__Group_2__0 )? ) | 16414 | // InternalSolverLanguageParser.g:5268:1: ( ( rule__ArgumentList__Group_2__0 )? ) |
18018 | { | 16415 | { |
18019 | // InternalSolverLanguage.g:5324:1: ( ( rule__ArgumentList__Group_2__0 )? ) | 16416 | // InternalSolverLanguageParser.g:5268:1: ( ( rule__ArgumentList__Group_2__0 )? ) |
18020 | // InternalSolverLanguage.g:5325:2: ( rule__ArgumentList__Group_2__0 )? | 16417 | // InternalSolverLanguageParser.g:5269:2: ( rule__ArgumentList__Group_2__0 )? |
18021 | { | 16418 | { |
18022 | if ( state.backtracking==0 ) { | 16419 | before(grammarAccess.getArgumentListAccess().getGroup_2()); |
18023 | before(grammarAccess.getArgumentListAccess().getGroup_2()); | 16420 | // InternalSolverLanguageParser.g:5270:2: ( rule__ArgumentList__Group_2__0 )? |
18024 | } | 16421 | int alt40=2; |
18025 | // InternalSolverLanguage.g:5326:2: ( rule__ArgumentList__Group_2__0 )? | 16422 | int LA40_0 = input.LA(1); |
18026 | int alt41=2; | ||
18027 | int LA41_0 = input.LA(1); | ||
18028 | 16423 | ||
18029 | if ( ((LA41_0>=RULE_INT && LA41_0<=RULE_QUOTED_ID)||LA41_0==RULE_ID||LA41_0==RULE_STRING||LA41_0==16||(LA41_0>=26 && LA41_0<=27)||(LA41_0>=29 && LA41_0<=42)||LA41_0==57||LA41_0==61||LA41_0==63||(LA41_0>=66 && LA41_0<=67)) ) { | 16424 | if ( (LA40_0==Current||LA40_0==Unknown||(LA40_0>=Count && LA40_0<=False)||(LA40_0>=Must && LA40_0<=Prod)||LA40_0==True||(LA40_0>=Avg && LA40_0<=Inf)||(LA40_0>=Max && LA40_0<=Sum)||(LA40_0>=ExclamationMark && LA40_0<=LeftParenthesis)||(LA40_0>=Asterisk && LA40_0<=PlusSign)||LA40_0==HyphenMinus||LA40_0==LeftSquareBracket||(LA40_0>=RULE_STRING && LA40_0<=RULE_QUOTED_ID)||(LA40_0>=RULE_ID && LA40_0<=RULE_INT)) ) { |
18030 | alt41=1; | 16425 | alt40=1; |
18031 | } | 16426 | } |
18032 | switch (alt41) { | 16427 | switch (alt40) { |
18033 | case 1 : | 16428 | case 1 : |
18034 | // InternalSolverLanguage.g:5326:3: rule__ArgumentList__Group_2__0 | 16429 | // InternalSolverLanguageParser.g:5270:3: rule__ArgumentList__Group_2__0 |
18035 | { | 16430 | { |
18036 | pushFollow(FOLLOW_2); | 16431 | pushFollow(FOLLOW_2); |
18037 | rule__ArgumentList__Group_2__0(); | 16432 | rule__ArgumentList__Group_2__0(); |
18038 | 16433 | ||
18039 | state._fsp--; | 16434 | state._fsp--; |
18040 | if (state.failed) return ; | 16435 | |
18041 | 16436 | ||
18042 | } | 16437 | } |
18043 | break; | 16438 | break; |
18044 | 16439 | ||
18045 | } | 16440 | } |
18046 | 16441 | ||
18047 | if ( state.backtracking==0 ) { | 16442 | after(grammarAccess.getArgumentListAccess().getGroup_2()); |
18048 | after(grammarAccess.getArgumentListAccess().getGroup_2()); | ||
18049 | } | ||
18050 | 16443 | ||
18051 | } | 16444 | } |
18052 | 16445 | ||
@@ -18069,20 +16462,20 @@ public class InternalSolverLanguageParser extends AbstractInternalContentAssistP | |||
18069 | 16462 | ||
18070 | 16463 | ||
18071 | // $ANTLR start "rule__ArgumentList__Group__3" | 16464 | // $ANTLR start "rule__ArgumentList__Group__3" |
18072 | // InternalSolverLanguage.g:5334:1: rule__ArgumentList__Group__3 : rule__ArgumentList__Group__3__Impl ; | 16465 | // InternalSolverLanguageParser.g:5278:1: rule__ArgumentList__Group__3 : rule__ArgumentList__Group__3__Impl ; |
18073 | public final void rule__ArgumentList__Group__3() throws RecognitionException { | 16466 | public final void rule__ArgumentList__Group__3() throws RecognitionException { |
18074 | 16467 | ||
18075 | int stackSize = keepStackSize(); | 16468 | int stackSize = keepStackSize(); |
18076 | 16469 | ||
18077 | try { | 16470 | try { |
18078 | // InternalSolverLanguage.g:5338:1: ( rule__ArgumentList__Group__3__Impl ) | 16471 | // InternalSolverLanguageParser.g:5282:1: ( rule__ArgumentList__Group__3__Impl ) |
18079 | // InternalSolverLanguage.g:5339:2: rule__ArgumentList__Group__3__Impl | 16472 | // InternalSolverLanguageParser.g:5283:2: rule__ArgumentList__Group__3__Impl |
18080 | { | 16473 | { |
18081 | pushFollow(FOLLOW_2); | 16474 | pushFollow(FOLLOW_2); |
18082 | rule__ArgumentList__Group__3__Impl(); | 16475 | rule__ArgumentList__Group__3__Impl(); |
18083 | 16476 | ||
18084 | state._fsp--; | 16477 | state._fsp--; |
18085 | if (state.failed) return ; | 16478 | |
18086 | 16479 | ||
18087 | } | 16480 | } |
18088 | 16481 | ||
@@ -18102,25 +16495,21 @@ public class InternalSolverLanguageParser extends AbstractInternalContentAssistP | |||
18102 | 16495 | ||
18103 | 16496 | ||
18104 | // $ANTLR start "rule__ArgumentList__Group__3__Impl" | 16497 | // $ANTLR start "rule__ArgumentList__Group__3__Impl" |
18105 | // InternalSolverLanguage.g:5345:1: rule__ArgumentList__Group__3__Impl : ( ')' ) ; | 16498 | // InternalSolverLanguageParser.g:5289:1: rule__ArgumentList__Group__3__Impl : ( RightParenthesis ) ; |
18106 | public final void rule__ArgumentList__Group__3__Impl() throws RecognitionException { | 16499 | public final void rule__ArgumentList__Group__3__Impl() throws RecognitionException { |
18107 | 16500 | ||
18108 | int stackSize = keepStackSize(); | 16501 | int stackSize = keepStackSize(); |
18109 | 16502 | ||
18110 | try { | 16503 | try { |
18111 | // InternalSolverLanguage.g:5349:1: ( ( ')' ) ) | 16504 | // InternalSolverLanguageParser.g:5293:1: ( ( RightParenthesis ) ) |
18112 | // InternalSolverLanguage.g:5350:1: ( ')' ) | 16505 | // InternalSolverLanguageParser.g:5294:1: ( RightParenthesis ) |
18113 | { | 16506 | { |
18114 | // InternalSolverLanguage.g:5350:1: ( ')' ) | 16507 | // InternalSolverLanguageParser.g:5294:1: ( RightParenthesis ) |
18115 | // InternalSolverLanguage.g:5351:2: ')' | 16508 | // InternalSolverLanguageParser.g:5295:2: RightParenthesis |
18116 | { | 16509 | { |
18117 | if ( state.backtracking==0 ) { | 16510 | before(grammarAccess.getArgumentListAccess().getRightParenthesisKeyword_3()); |
18118 | before(grammarAccess.getArgumentListAccess().getRightParenthesisKeyword_3()); | 16511 | match(input,RightParenthesis,FOLLOW_2); |
18119 | } | 16512 | after(grammarAccess.getArgumentListAccess().getRightParenthesisKeyword_3()); |
18120 | match(input,62,FOLLOW_2); if (state.failed) return ; | ||
18121 | if ( state.backtracking==0 ) { | ||
18122 | after(grammarAccess.getArgumentListAccess().getRightParenthesisKeyword_3()); | ||
18123 | } | ||
18124 | 16513 | ||
18125 | } | 16514 | } |
18126 | 16515 | ||
@@ -18143,25 +16532,25 @@ public class InternalSolverLanguageParser extends AbstractInternalContentAssistP | |||
18143 | 16532 | ||
18144 | 16533 | ||
18145 | // $ANTLR start "rule__ArgumentList__Group_2__0" | 16534 | // $ANTLR start "rule__ArgumentList__Group_2__0" |
18146 | // InternalSolverLanguage.g:5361:1: rule__ArgumentList__Group_2__0 : rule__ArgumentList__Group_2__0__Impl rule__ArgumentList__Group_2__1 ; | 16535 | // InternalSolverLanguageParser.g:5305:1: rule__ArgumentList__Group_2__0 : rule__ArgumentList__Group_2__0__Impl rule__ArgumentList__Group_2__1 ; |
18147 | public final void rule__ArgumentList__Group_2__0() throws RecognitionException { | 16536 | public final void rule__ArgumentList__Group_2__0() throws RecognitionException { |
18148 | 16537 | ||
18149 | int stackSize = keepStackSize(); | 16538 | int stackSize = keepStackSize(); |
18150 | 16539 | ||
18151 | try { | 16540 | try { |
18152 | // InternalSolverLanguage.g:5365:1: ( rule__ArgumentList__Group_2__0__Impl rule__ArgumentList__Group_2__1 ) | 16541 | // InternalSolverLanguageParser.g:5309:1: ( rule__ArgumentList__Group_2__0__Impl rule__ArgumentList__Group_2__1 ) |
18153 | // InternalSolverLanguage.g:5366:2: rule__ArgumentList__Group_2__0__Impl rule__ArgumentList__Group_2__1 | 16542 | // InternalSolverLanguageParser.g:5310:2: rule__ArgumentList__Group_2__0__Impl rule__ArgumentList__Group_2__1 |
18154 | { | 16543 | { |
18155 | pushFollow(FOLLOW_22); | 16544 | pushFollow(FOLLOW_21); |
18156 | rule__ArgumentList__Group_2__0__Impl(); | 16545 | rule__ArgumentList__Group_2__0__Impl(); |
18157 | 16546 | ||
18158 | state._fsp--; | 16547 | state._fsp--; |
18159 | if (state.failed) return ; | 16548 | |
18160 | pushFollow(FOLLOW_2); | 16549 | pushFollow(FOLLOW_2); |
18161 | rule__ArgumentList__Group_2__1(); | 16550 | rule__ArgumentList__Group_2__1(); |
18162 | 16551 | ||
18163 | state._fsp--; | 16552 | state._fsp--; |
18164 | if (state.failed) return ; | 16553 | |
18165 | 16554 | ||
18166 | } | 16555 | } |
18167 | 16556 | ||
@@ -18181,36 +16570,32 @@ public class InternalSolverLanguageParser extends AbstractInternalContentAssistP | |||
18181 | 16570 | ||
18182 | 16571 | ||
18183 | // $ANTLR start "rule__ArgumentList__Group_2__0__Impl" | 16572 | // $ANTLR start "rule__ArgumentList__Group_2__0__Impl" |
18184 | // InternalSolverLanguage.g:5373:1: rule__ArgumentList__Group_2__0__Impl : ( ( rule__ArgumentList__ArgumentsAssignment_2_0 ) ) ; | 16573 | // InternalSolverLanguageParser.g:5317:1: rule__ArgumentList__Group_2__0__Impl : ( ( rule__ArgumentList__ArgumentsAssignment_2_0 ) ) ; |
18185 | public final void rule__ArgumentList__Group_2__0__Impl() throws RecognitionException { | 16574 | public final void rule__ArgumentList__Group_2__0__Impl() throws RecognitionException { |
18186 | 16575 | ||
18187 | int stackSize = keepStackSize(); | 16576 | int stackSize = keepStackSize(); |
18188 | 16577 | ||
18189 | try { | 16578 | try { |
18190 | // InternalSolverLanguage.g:5377:1: ( ( ( rule__ArgumentList__ArgumentsAssignment_2_0 ) ) ) | 16579 | // InternalSolverLanguageParser.g:5321:1: ( ( ( rule__ArgumentList__ArgumentsAssignment_2_0 ) ) ) |
18191 | // InternalSolverLanguage.g:5378:1: ( ( rule__ArgumentList__ArgumentsAssignment_2_0 ) ) | 16580 | // InternalSolverLanguageParser.g:5322:1: ( ( rule__ArgumentList__ArgumentsAssignment_2_0 ) ) |
18192 | { | 16581 | { |
18193 | // InternalSolverLanguage.g:5378:1: ( ( rule__ArgumentList__ArgumentsAssignment_2_0 ) ) | 16582 | // InternalSolverLanguageParser.g:5322:1: ( ( rule__ArgumentList__ArgumentsAssignment_2_0 ) ) |
18194 | // InternalSolverLanguage.g:5379:2: ( rule__ArgumentList__ArgumentsAssignment_2_0 ) | 16583 | // InternalSolverLanguageParser.g:5323:2: ( rule__ArgumentList__ArgumentsAssignment_2_0 ) |
18195 | { | 16584 | { |
18196 | if ( state.backtracking==0 ) { | 16585 | before(grammarAccess.getArgumentListAccess().getArgumentsAssignment_2_0()); |
18197 | before(grammarAccess.getArgumentListAccess().getArgumentsAssignment_2_0()); | 16586 | // InternalSolverLanguageParser.g:5324:2: ( rule__ArgumentList__ArgumentsAssignment_2_0 ) |
18198 | } | 16587 | // InternalSolverLanguageParser.g:5324:3: rule__ArgumentList__ArgumentsAssignment_2_0 |
18199 | // InternalSolverLanguage.g:5380:2: ( rule__ArgumentList__ArgumentsAssignment_2_0 ) | ||
18200 | // InternalSolverLanguage.g:5380:3: rule__ArgumentList__ArgumentsAssignment_2_0 | ||
18201 | { | 16588 | { |
18202 | pushFollow(FOLLOW_2); | 16589 | pushFollow(FOLLOW_2); |
18203 | rule__ArgumentList__ArgumentsAssignment_2_0(); | 16590 | rule__ArgumentList__ArgumentsAssignment_2_0(); |
18204 | 16591 | ||
18205 | state._fsp--; | 16592 | state._fsp--; |
18206 | if (state.failed) return ; | ||
18207 | 16593 | ||
18208 | } | ||
18209 | 16594 | ||
18210 | if ( state.backtracking==0 ) { | ||
18211 | after(grammarAccess.getArgumentListAccess().getArgumentsAssignment_2_0()); | ||
18212 | } | 16595 | } |
18213 | 16596 | ||
16597 | after(grammarAccess.getArgumentListAccess().getArgumentsAssignment_2_0()); | ||
16598 | |||
18214 | } | 16599 | } |
18215 | 16600 | ||
18216 | 16601 | ||
@@ -18232,20 +16617,20 @@ public class InternalSolverLanguageParser extends AbstractInternalContentAssistP | |||
18232 | 16617 | ||
18233 | 16618 | ||
18234 | // $ANTLR start "rule__ArgumentList__Group_2__1" | 16619 | // $ANTLR start "rule__ArgumentList__Group_2__1" |
18235 | // InternalSolverLanguage.g:5388:1: rule__ArgumentList__Group_2__1 : rule__ArgumentList__Group_2__1__Impl ; | 16620 | // InternalSolverLanguageParser.g:5332:1: rule__ArgumentList__Group_2__1 : rule__ArgumentList__Group_2__1__Impl ; |
18236 | public final void rule__ArgumentList__Group_2__1() throws RecognitionException { | 16621 | public final void rule__ArgumentList__Group_2__1() throws RecognitionException { |
18237 | 16622 | ||
18238 | int stackSize = keepStackSize(); | 16623 | int stackSize = keepStackSize(); |
18239 | 16624 | ||
18240 | try { | 16625 | try { |
18241 | // InternalSolverLanguage.g:5392:1: ( rule__ArgumentList__Group_2__1__Impl ) | 16626 | // InternalSolverLanguageParser.g:5336:1: ( rule__ArgumentList__Group_2__1__Impl ) |
18242 | // InternalSolverLanguage.g:5393:2: rule__ArgumentList__Group_2__1__Impl | 16627 | // InternalSolverLanguageParser.g:5337:2: rule__ArgumentList__Group_2__1__Impl |
18243 | { | 16628 | { |
18244 | pushFollow(FOLLOW_2); | 16629 | pushFollow(FOLLOW_2); |
18245 | rule__ArgumentList__Group_2__1__Impl(); | 16630 | rule__ArgumentList__Group_2__1__Impl(); |
18246 | 16631 | ||
18247 | state._fsp--; | 16632 | state._fsp--; |
18248 | if (state.failed) return ; | 16633 | |
18249 | 16634 | ||
18250 | } | 16635 | } |
18251 | 16636 | ||
@@ -18265,53 +16650,49 @@ public class InternalSolverLanguageParser extends AbstractInternalContentAssistP | |||
18265 | 16650 | ||
18266 | 16651 | ||
18267 | // $ANTLR start "rule__ArgumentList__Group_2__1__Impl" | 16652 | // $ANTLR start "rule__ArgumentList__Group_2__1__Impl" |
18268 | // InternalSolverLanguage.g:5399:1: rule__ArgumentList__Group_2__1__Impl : ( ( rule__ArgumentList__Group_2_1__0 )* ) ; | 16653 | // InternalSolverLanguageParser.g:5343:1: rule__ArgumentList__Group_2__1__Impl : ( ( rule__ArgumentList__Group_2_1__0 )* ) ; |
18269 | public final void rule__ArgumentList__Group_2__1__Impl() throws RecognitionException { | 16654 | public final void rule__ArgumentList__Group_2__1__Impl() throws RecognitionException { |
18270 | 16655 | ||
18271 | int stackSize = keepStackSize(); | 16656 | int stackSize = keepStackSize(); |
18272 | 16657 | ||
18273 | try { | 16658 | try { |
18274 | // InternalSolverLanguage.g:5403:1: ( ( ( rule__ArgumentList__Group_2_1__0 )* ) ) | 16659 | // InternalSolverLanguageParser.g:5347:1: ( ( ( rule__ArgumentList__Group_2_1__0 )* ) ) |
18275 | // InternalSolverLanguage.g:5404:1: ( ( rule__ArgumentList__Group_2_1__0 )* ) | 16660 | // InternalSolverLanguageParser.g:5348:1: ( ( rule__ArgumentList__Group_2_1__0 )* ) |
18276 | { | 16661 | { |
18277 | // InternalSolverLanguage.g:5404:1: ( ( rule__ArgumentList__Group_2_1__0 )* ) | 16662 | // InternalSolverLanguageParser.g:5348:1: ( ( rule__ArgumentList__Group_2_1__0 )* ) |
18278 | // InternalSolverLanguage.g:5405:2: ( rule__ArgumentList__Group_2_1__0 )* | 16663 | // InternalSolverLanguageParser.g:5349:2: ( rule__ArgumentList__Group_2_1__0 )* |
18279 | { | 16664 | { |
18280 | if ( state.backtracking==0 ) { | 16665 | before(grammarAccess.getArgumentListAccess().getGroup_2_1()); |
18281 | before(grammarAccess.getArgumentListAccess().getGroup_2_1()); | 16666 | // InternalSolverLanguageParser.g:5350:2: ( rule__ArgumentList__Group_2_1__0 )* |
18282 | } | 16667 | loop41: |
18283 | // InternalSolverLanguage.g:5406:2: ( rule__ArgumentList__Group_2_1__0 )* | ||
18284 | loop42: | ||
18285 | do { | 16668 | do { |
18286 | int alt42=2; | 16669 | int alt41=2; |
18287 | int LA42_0 = input.LA(1); | 16670 | int LA41_0 = input.LA(1); |
18288 | 16671 | ||
18289 | if ( (LA42_0==56) ) { | 16672 | if ( (LA41_0==Comma) ) { |
18290 | alt42=1; | 16673 | alt41=1; |
18291 | } | 16674 | } |
18292 | 16675 | ||
18293 | 16676 | ||
18294 | switch (alt42) { | 16677 | switch (alt41) { |
18295 | case 1 : | 16678 | case 1 : |
18296 | // InternalSolverLanguage.g:5406:3: rule__ArgumentList__Group_2_1__0 | 16679 | // InternalSolverLanguageParser.g:5350:3: rule__ArgumentList__Group_2_1__0 |
18297 | { | 16680 | { |
18298 | pushFollow(FOLLOW_23); | 16681 | pushFollow(FOLLOW_22); |
18299 | rule__ArgumentList__Group_2_1__0(); | 16682 | rule__ArgumentList__Group_2_1__0(); |
18300 | 16683 | ||
18301 | state._fsp--; | 16684 | state._fsp--; |
18302 | if (state.failed) return ; | 16685 | |
18303 | 16686 | ||
18304 | } | 16687 | } |
18305 | break; | 16688 | break; |
18306 | 16689 | ||
18307 | default : | 16690 | default : |
18308 | break loop42; | 16691 | break loop41; |
18309 | } | 16692 | } |
18310 | } while (true); | 16693 | } while (true); |
18311 | 16694 | ||
18312 | if ( state.backtracking==0 ) { | 16695 | after(grammarAccess.getArgumentListAccess().getGroup_2_1()); |
18313 | after(grammarAccess.getArgumentListAccess().getGroup_2_1()); | ||
18314 | } | ||
18315 | 16696 | ||
18316 | } | 16697 | } |
18317 | 16698 | ||
@@ -18334,25 +16715,25 @@ public class InternalSolverLanguageParser extends AbstractInternalContentAssistP | |||
18334 | 16715 | ||
18335 | 16716 | ||
18336 | // $ANTLR start "rule__ArgumentList__Group_2_1__0" | 16717 | // $ANTLR start "rule__ArgumentList__Group_2_1__0" |
18337 | // InternalSolverLanguage.g:5415:1: rule__ArgumentList__Group_2_1__0 : rule__ArgumentList__Group_2_1__0__Impl rule__ArgumentList__Group_2_1__1 ; | 16718 | // InternalSolverLanguageParser.g:5359:1: rule__ArgumentList__Group_2_1__0 : rule__ArgumentList__Group_2_1__0__Impl rule__ArgumentList__Group_2_1__1 ; |
18338 | public final void rule__ArgumentList__Group_2_1__0() throws RecognitionException { | 16719 | public final void rule__ArgumentList__Group_2_1__0() throws RecognitionException { |
18339 | 16720 | ||
18340 | int stackSize = keepStackSize(); | 16721 | int stackSize = keepStackSize(); |
18341 | 16722 | ||
18342 | try { | 16723 | try { |
18343 | // InternalSolverLanguage.g:5419:1: ( rule__ArgumentList__Group_2_1__0__Impl rule__ArgumentList__Group_2_1__1 ) | 16724 | // InternalSolverLanguageParser.g:5363:1: ( rule__ArgumentList__Group_2_1__0__Impl rule__ArgumentList__Group_2_1__1 ) |
18344 | // InternalSolverLanguage.g:5420:2: rule__ArgumentList__Group_2_1__0__Impl rule__ArgumentList__Group_2_1__1 | 16725 | // InternalSolverLanguageParser.g:5364:2: rule__ArgumentList__Group_2_1__0__Impl rule__ArgumentList__Group_2_1__1 |
18345 | { | 16726 | { |
18346 | pushFollow(FOLLOW_37); | 16727 | pushFollow(FOLLOW_36); |
18347 | rule__ArgumentList__Group_2_1__0__Impl(); | 16728 | rule__ArgumentList__Group_2_1__0__Impl(); |
18348 | 16729 | ||
18349 | state._fsp--; | 16730 | state._fsp--; |
18350 | if (state.failed) return ; | 16731 | |
18351 | pushFollow(FOLLOW_2); | 16732 | pushFollow(FOLLOW_2); |
18352 | rule__ArgumentList__Group_2_1__1(); | 16733 | rule__ArgumentList__Group_2_1__1(); |
18353 | 16734 | ||
18354 | state._fsp--; | 16735 | state._fsp--; |
18355 | if (state.failed) return ; | 16736 | |
18356 | 16737 | ||
18357 | } | 16738 | } |
18358 | 16739 | ||
@@ -18372,25 +16753,21 @@ public class InternalSolverLanguageParser extends AbstractInternalContentAssistP | |||
18372 | 16753 | ||
18373 | 16754 | ||
18374 | // $ANTLR start "rule__ArgumentList__Group_2_1__0__Impl" | 16755 | // $ANTLR start "rule__ArgumentList__Group_2_1__0__Impl" |
18375 | // InternalSolverLanguage.g:5427:1: rule__ArgumentList__Group_2_1__0__Impl : ( ',' ) ; | 16756 | // InternalSolverLanguageParser.g:5371:1: rule__ArgumentList__Group_2_1__0__Impl : ( Comma ) ; |
18376 | public final void rule__ArgumentList__Group_2_1__0__Impl() throws RecognitionException { | 16757 | public final void rule__ArgumentList__Group_2_1__0__Impl() throws RecognitionException { |
18377 | 16758 | ||
18378 | int stackSize = keepStackSize(); | 16759 | int stackSize = keepStackSize(); |
18379 | 16760 | ||
18380 | try { | 16761 | try { |
18381 | // InternalSolverLanguage.g:5431:1: ( ( ',' ) ) | 16762 | // InternalSolverLanguageParser.g:5375:1: ( ( Comma ) ) |
18382 | // InternalSolverLanguage.g:5432:1: ( ',' ) | 16763 | // InternalSolverLanguageParser.g:5376:1: ( Comma ) |
18383 | { | 16764 | { |
18384 | // InternalSolverLanguage.g:5432:1: ( ',' ) | 16765 | // InternalSolverLanguageParser.g:5376:1: ( Comma ) |
18385 | // InternalSolverLanguage.g:5433:2: ',' | 16766 | // InternalSolverLanguageParser.g:5377:2: Comma |
18386 | { | 16767 | { |
18387 | if ( state.backtracking==0 ) { | 16768 | before(grammarAccess.getArgumentListAccess().getCommaKeyword_2_1_0()); |
18388 | before(grammarAccess.getArgumentListAccess().getCommaKeyword_2_1_0()); | 16769 | match(input,Comma,FOLLOW_2); |
18389 | } | 16770 | after(grammarAccess.getArgumentListAccess().getCommaKeyword_2_1_0()); |
18390 | match(input,56,FOLLOW_2); if (state.failed) return ; | ||
18391 | if ( state.backtracking==0 ) { | ||
18392 | after(grammarAccess.getArgumentListAccess().getCommaKeyword_2_1_0()); | ||
18393 | } | ||
18394 | 16771 | ||
18395 | } | 16772 | } |
18396 | 16773 | ||
@@ -18413,20 +16790,20 @@ public class InternalSolverLanguageParser extends AbstractInternalContentAssistP | |||
18413 | 16790 | ||
18414 | 16791 | ||
18415 | // $ANTLR start "rule__ArgumentList__Group_2_1__1" | 16792 | // $ANTLR start "rule__ArgumentList__Group_2_1__1" |
18416 | // InternalSolverLanguage.g:5442:1: rule__ArgumentList__Group_2_1__1 : rule__ArgumentList__Group_2_1__1__Impl ; | 16793 | // InternalSolverLanguageParser.g:5386:1: rule__ArgumentList__Group_2_1__1 : rule__ArgumentList__Group_2_1__1__Impl ; |
18417 | public final void rule__ArgumentList__Group_2_1__1() throws RecognitionException { | 16794 | public final void rule__ArgumentList__Group_2_1__1() throws RecognitionException { |
18418 | 16795 | ||
18419 | int stackSize = keepStackSize(); | 16796 | int stackSize = keepStackSize(); |
18420 | 16797 | ||
18421 | try { | 16798 | try { |
18422 | // InternalSolverLanguage.g:5446:1: ( rule__ArgumentList__Group_2_1__1__Impl ) | 16799 | // InternalSolverLanguageParser.g:5390:1: ( rule__ArgumentList__Group_2_1__1__Impl ) |
18423 | // InternalSolverLanguage.g:5447:2: rule__ArgumentList__Group_2_1__1__Impl | 16800 | // InternalSolverLanguageParser.g:5391:2: rule__ArgumentList__Group_2_1__1__Impl |
18424 | { | 16801 | { |
18425 | pushFollow(FOLLOW_2); | 16802 | pushFollow(FOLLOW_2); |
18426 | rule__ArgumentList__Group_2_1__1__Impl(); | 16803 | rule__ArgumentList__Group_2_1__1__Impl(); |
18427 | 16804 | ||
18428 | state._fsp--; | 16805 | state._fsp--; |
18429 | if (state.failed) return ; | 16806 | |
18430 | 16807 | ||
18431 | } | 16808 | } |
18432 | 16809 | ||
@@ -18446,36 +16823,32 @@ public class InternalSolverLanguageParser extends AbstractInternalContentAssistP | |||
18446 | 16823 | ||
18447 | 16824 | ||
18448 | // $ANTLR start "rule__ArgumentList__Group_2_1__1__Impl" | 16825 | // $ANTLR start "rule__ArgumentList__Group_2_1__1__Impl" |
18449 | // InternalSolverLanguage.g:5453:1: rule__ArgumentList__Group_2_1__1__Impl : ( ( rule__ArgumentList__ArgumentsAssignment_2_1_1 ) ) ; | 16826 | // InternalSolverLanguageParser.g:5397:1: rule__ArgumentList__Group_2_1__1__Impl : ( ( rule__ArgumentList__ArgumentsAssignment_2_1_1 ) ) ; |
18450 | public final void rule__ArgumentList__Group_2_1__1__Impl() throws RecognitionException { | 16827 | public final void rule__ArgumentList__Group_2_1__1__Impl() throws RecognitionException { |
18451 | 16828 | ||
18452 | int stackSize = keepStackSize(); | 16829 | int stackSize = keepStackSize(); |
18453 | 16830 | ||
18454 | try { | 16831 | try { |
18455 | // InternalSolverLanguage.g:5457:1: ( ( ( rule__ArgumentList__ArgumentsAssignment_2_1_1 ) ) ) | 16832 | // InternalSolverLanguageParser.g:5401:1: ( ( ( rule__ArgumentList__ArgumentsAssignment_2_1_1 ) ) ) |
18456 | // InternalSolverLanguage.g:5458:1: ( ( rule__ArgumentList__ArgumentsAssignment_2_1_1 ) ) | 16833 | // InternalSolverLanguageParser.g:5402:1: ( ( rule__ArgumentList__ArgumentsAssignment_2_1_1 ) ) |
18457 | { | 16834 | { |
18458 | // InternalSolverLanguage.g:5458:1: ( ( rule__ArgumentList__ArgumentsAssignment_2_1_1 ) ) | 16835 | // InternalSolverLanguageParser.g:5402:1: ( ( rule__ArgumentList__ArgumentsAssignment_2_1_1 ) ) |
18459 | // InternalSolverLanguage.g:5459:2: ( rule__ArgumentList__ArgumentsAssignment_2_1_1 ) | 16836 | // InternalSolverLanguageParser.g:5403:2: ( rule__ArgumentList__ArgumentsAssignment_2_1_1 ) |
18460 | { | 16837 | { |
18461 | if ( state.backtracking==0 ) { | 16838 | before(grammarAccess.getArgumentListAccess().getArgumentsAssignment_2_1_1()); |
18462 | before(grammarAccess.getArgumentListAccess().getArgumentsAssignment_2_1_1()); | 16839 | // InternalSolverLanguageParser.g:5404:2: ( rule__ArgumentList__ArgumentsAssignment_2_1_1 ) |
18463 | } | 16840 | // InternalSolverLanguageParser.g:5404:3: rule__ArgumentList__ArgumentsAssignment_2_1_1 |
18464 | // InternalSolverLanguage.g:5460:2: ( rule__ArgumentList__ArgumentsAssignment_2_1_1 ) | ||
18465 | // InternalSolverLanguage.g:5460:3: rule__ArgumentList__ArgumentsAssignment_2_1_1 | ||
18466 | { | 16841 | { |
18467 | pushFollow(FOLLOW_2); | 16842 | pushFollow(FOLLOW_2); |
18468 | rule__ArgumentList__ArgumentsAssignment_2_1_1(); | 16843 | rule__ArgumentList__ArgumentsAssignment_2_1_1(); |
18469 | 16844 | ||
18470 | state._fsp--; | 16845 | state._fsp--; |
18471 | if (state.failed) return ; | ||
18472 | 16846 | ||
18473 | } | ||
18474 | 16847 | ||
18475 | if ( state.backtracking==0 ) { | ||
18476 | after(grammarAccess.getArgumentListAccess().getArgumentsAssignment_2_1_1()); | ||
18477 | } | 16848 | } |
18478 | 16849 | ||
16850 | after(grammarAccess.getArgumentListAccess().getArgumentsAssignment_2_1_1()); | ||
16851 | |||
18479 | } | 16852 | } |
18480 | 16853 | ||
18481 | 16854 | ||
@@ -18497,25 +16870,25 @@ public class InternalSolverLanguageParser extends AbstractInternalContentAssistP | |||
18497 | 16870 | ||
18498 | 16871 | ||
18499 | // $ANTLR start "rule__StarArgument__Group__0" | 16872 | // $ANTLR start "rule__StarArgument__Group__0" |
18500 | // InternalSolverLanguage.g:5469:1: rule__StarArgument__Group__0 : rule__StarArgument__Group__0__Impl rule__StarArgument__Group__1 ; | 16873 | // InternalSolverLanguageParser.g:5413:1: rule__StarArgument__Group__0 : rule__StarArgument__Group__0__Impl rule__StarArgument__Group__1 ; |
18501 | public final void rule__StarArgument__Group__0() throws RecognitionException { | 16874 | public final void rule__StarArgument__Group__0() throws RecognitionException { |
18502 | 16875 | ||
18503 | int stackSize = keepStackSize(); | 16876 | int stackSize = keepStackSize(); |
18504 | 16877 | ||
18505 | try { | 16878 | try { |
18506 | // InternalSolverLanguage.g:5473:1: ( rule__StarArgument__Group__0__Impl rule__StarArgument__Group__1 ) | 16879 | // InternalSolverLanguageParser.g:5417:1: ( rule__StarArgument__Group__0__Impl rule__StarArgument__Group__1 ) |
18507 | // InternalSolverLanguage.g:5474:2: rule__StarArgument__Group__0__Impl rule__StarArgument__Group__1 | 16880 | // InternalSolverLanguageParser.g:5418:2: rule__StarArgument__Group__0__Impl rule__StarArgument__Group__1 |
18508 | { | 16881 | { |
18509 | pushFollow(FOLLOW_38); | 16882 | pushFollow(FOLLOW_37); |
18510 | rule__StarArgument__Group__0__Impl(); | 16883 | rule__StarArgument__Group__0__Impl(); |
18511 | 16884 | ||
18512 | state._fsp--; | 16885 | state._fsp--; |
18513 | if (state.failed) return ; | 16886 | |
18514 | pushFollow(FOLLOW_2); | 16887 | pushFollow(FOLLOW_2); |
18515 | rule__StarArgument__Group__1(); | 16888 | rule__StarArgument__Group__1(); |
18516 | 16889 | ||
18517 | state._fsp--; | 16890 | state._fsp--; |
18518 | if (state.failed) return ; | 16891 | |
18519 | 16892 | ||
18520 | } | 16893 | } |
18521 | 16894 | ||
@@ -18535,29 +16908,25 @@ public class InternalSolverLanguageParser extends AbstractInternalContentAssistP | |||
18535 | 16908 | ||
18536 | 16909 | ||
18537 | // $ANTLR start "rule__StarArgument__Group__0__Impl" | 16910 | // $ANTLR start "rule__StarArgument__Group__0__Impl" |
18538 | // InternalSolverLanguage.g:5481:1: rule__StarArgument__Group__0__Impl : ( () ) ; | 16911 | // InternalSolverLanguageParser.g:5425:1: rule__StarArgument__Group__0__Impl : ( () ) ; |
18539 | public final void rule__StarArgument__Group__0__Impl() throws RecognitionException { | 16912 | public final void rule__StarArgument__Group__0__Impl() throws RecognitionException { |
18540 | 16913 | ||
18541 | int stackSize = keepStackSize(); | 16914 | int stackSize = keepStackSize(); |
18542 | 16915 | ||
18543 | try { | 16916 | try { |
18544 | // InternalSolverLanguage.g:5485:1: ( ( () ) ) | 16917 | // InternalSolverLanguageParser.g:5429:1: ( ( () ) ) |
18545 | // InternalSolverLanguage.g:5486:1: ( () ) | 16918 | // InternalSolverLanguageParser.g:5430:1: ( () ) |
18546 | { | 16919 | { |
18547 | // InternalSolverLanguage.g:5486:1: ( () ) | 16920 | // InternalSolverLanguageParser.g:5430:1: ( () ) |
18548 | // InternalSolverLanguage.g:5487:2: () | 16921 | // InternalSolverLanguageParser.g:5431:2: () |
18549 | { | 16922 | { |
18550 | if ( state.backtracking==0 ) { | 16923 | before(grammarAccess.getStarArgumentAccess().getStarArgumentAction_0()); |
18551 | before(grammarAccess.getStarArgumentAccess().getStarArgumentAction_0()); | 16924 | // InternalSolverLanguageParser.g:5432:2: () |
18552 | } | 16925 | // InternalSolverLanguageParser.g:5432:3: |
18553 | // InternalSolverLanguage.g:5488:2: () | ||
18554 | // InternalSolverLanguage.g:5488:3: | ||
18555 | { | 16926 | { |
18556 | } | 16927 | } |
18557 | 16928 | ||
18558 | if ( state.backtracking==0 ) { | 16929 | after(grammarAccess.getStarArgumentAccess().getStarArgumentAction_0()); |
18559 | after(grammarAccess.getStarArgumentAccess().getStarArgumentAction_0()); | ||
18560 | } | ||
18561 | 16930 | ||
18562 | } | 16931 | } |
18563 | 16932 | ||
@@ -18576,20 +16945,20 @@ public class InternalSolverLanguageParser extends AbstractInternalContentAssistP | |||
18576 | 16945 | ||
18577 | 16946 | ||
18578 | // $ANTLR start "rule__StarArgument__Group__1" | 16947 | // $ANTLR start "rule__StarArgument__Group__1" |
18579 | // InternalSolverLanguage.g:5496:1: rule__StarArgument__Group__1 : rule__StarArgument__Group__1__Impl ; | 16948 | // InternalSolverLanguageParser.g:5440:1: rule__StarArgument__Group__1 : rule__StarArgument__Group__1__Impl ; |
18580 | public final void rule__StarArgument__Group__1() throws RecognitionException { | 16949 | public final void rule__StarArgument__Group__1() throws RecognitionException { |
18581 | 16950 | ||
18582 | int stackSize = keepStackSize(); | 16951 | int stackSize = keepStackSize(); |
18583 | 16952 | ||
18584 | try { | 16953 | try { |
18585 | // InternalSolverLanguage.g:5500:1: ( rule__StarArgument__Group__1__Impl ) | 16954 | // InternalSolverLanguageParser.g:5444:1: ( rule__StarArgument__Group__1__Impl ) |
18586 | // InternalSolverLanguage.g:5501:2: rule__StarArgument__Group__1__Impl | 16955 | // InternalSolverLanguageParser.g:5445:2: rule__StarArgument__Group__1__Impl |
18587 | { | 16956 | { |
18588 | pushFollow(FOLLOW_2); | 16957 | pushFollow(FOLLOW_2); |
18589 | rule__StarArgument__Group__1__Impl(); | 16958 | rule__StarArgument__Group__1__Impl(); |
18590 | 16959 | ||
18591 | state._fsp--; | 16960 | state._fsp--; |
18592 | if (state.failed) return ; | 16961 | |
18593 | 16962 | ||
18594 | } | 16963 | } |
18595 | 16964 | ||
@@ -18609,25 +16978,21 @@ public class InternalSolverLanguageParser extends AbstractInternalContentAssistP | |||
18609 | 16978 | ||
18610 | 16979 | ||
18611 | // $ANTLR start "rule__StarArgument__Group__1__Impl" | 16980 | // $ANTLR start "rule__StarArgument__Group__1__Impl" |
18612 | // InternalSolverLanguage.g:5507:1: rule__StarArgument__Group__1__Impl : ( '*' ) ; | 16981 | // InternalSolverLanguageParser.g:5451:1: rule__StarArgument__Group__1__Impl : ( Asterisk ) ; |
18613 | public final void rule__StarArgument__Group__1__Impl() throws RecognitionException { | 16982 | public final void rule__StarArgument__Group__1__Impl() throws RecognitionException { |
18614 | 16983 | ||
18615 | int stackSize = keepStackSize(); | 16984 | int stackSize = keepStackSize(); |
18616 | 16985 | ||
18617 | try { | 16986 | try { |
18618 | // InternalSolverLanguage.g:5511:1: ( ( '*' ) ) | 16987 | // InternalSolverLanguageParser.g:5455:1: ( ( Asterisk ) ) |
18619 | // InternalSolverLanguage.g:5512:1: ( '*' ) | 16988 | // InternalSolverLanguageParser.g:5456:1: ( Asterisk ) |
18620 | { | 16989 | { |
18621 | // InternalSolverLanguage.g:5512:1: ( '*' ) | 16990 | // InternalSolverLanguageParser.g:5456:1: ( Asterisk ) |
18622 | // InternalSolverLanguage.g:5513:2: '*' | 16991 | // InternalSolverLanguageParser.g:5457:2: Asterisk |
18623 | { | 16992 | { |
18624 | if ( state.backtracking==0 ) { | 16993 | before(grammarAccess.getStarArgumentAccess().getAsteriskKeyword_1()); |
18625 | before(grammarAccess.getStarArgumentAccess().getAsteriskKeyword_1()); | 16994 | match(input,Asterisk,FOLLOW_2); |
18626 | } | 16995 | after(grammarAccess.getStarArgumentAccess().getAsteriskKeyword_1()); |
18627 | match(input,16,FOLLOW_2); if (state.failed) return ; | ||
18628 | if ( state.backtracking==0 ) { | ||
18629 | after(grammarAccess.getStarArgumentAccess().getAsteriskKeyword_1()); | ||
18630 | } | ||
18631 | 16996 | ||
18632 | } | 16997 | } |
18633 | 16998 | ||
@@ -18650,25 +17015,25 @@ public class InternalSolverLanguageParser extends AbstractInternalContentAssistP | |||
18650 | 17015 | ||
18651 | 17016 | ||
18652 | // $ANTLR start "rule__TypedArgument__Group__0" | 17017 | // $ANTLR start "rule__TypedArgument__Group__0" |
18653 | // InternalSolverLanguage.g:5523:1: rule__TypedArgument__Group__0 : rule__TypedArgument__Group__0__Impl rule__TypedArgument__Group__1 ; | 17018 | // InternalSolverLanguageParser.g:5467:1: rule__TypedArgument__Group__0 : rule__TypedArgument__Group__0__Impl rule__TypedArgument__Group__1 ; |
18654 | public final void rule__TypedArgument__Group__0() throws RecognitionException { | 17019 | public final void rule__TypedArgument__Group__0() throws RecognitionException { |
18655 | 17020 | ||
18656 | int stackSize = keepStackSize(); | 17021 | int stackSize = keepStackSize(); |
18657 | 17022 | ||
18658 | try { | 17023 | try { |
18659 | // InternalSolverLanguage.g:5527:1: ( rule__TypedArgument__Group__0__Impl rule__TypedArgument__Group__1 ) | 17024 | // InternalSolverLanguageParser.g:5471:1: ( rule__TypedArgument__Group__0__Impl rule__TypedArgument__Group__1 ) |
18660 | // InternalSolverLanguage.g:5528:2: rule__TypedArgument__Group__0__Impl rule__TypedArgument__Group__1 | 17025 | // InternalSolverLanguageParser.g:5472:2: rule__TypedArgument__Group__0__Impl rule__TypedArgument__Group__1 |
18661 | { | 17026 | { |
18662 | pushFollow(FOLLOW_9); | 17027 | pushFollow(FOLLOW_9); |
18663 | rule__TypedArgument__Group__0__Impl(); | 17028 | rule__TypedArgument__Group__0__Impl(); |
18664 | 17029 | ||
18665 | state._fsp--; | 17030 | state._fsp--; |
18666 | if (state.failed) return ; | 17031 | |
18667 | pushFollow(FOLLOW_2); | 17032 | pushFollow(FOLLOW_2); |
18668 | rule__TypedArgument__Group__1(); | 17033 | rule__TypedArgument__Group__1(); |
18669 | 17034 | ||
18670 | state._fsp--; | 17035 | state._fsp--; |
18671 | if (state.failed) return ; | 17036 | |
18672 | 17037 | ||
18673 | } | 17038 | } |
18674 | 17039 | ||
@@ -18688,36 +17053,32 @@ public class InternalSolverLanguageParser extends AbstractInternalContentAssistP | |||
18688 | 17053 | ||
18689 | 17054 | ||
18690 | // $ANTLR start "rule__TypedArgument__Group__0__Impl" | 17055 | // $ANTLR start "rule__TypedArgument__Group__0__Impl" |
18691 | // InternalSolverLanguage.g:5535:1: rule__TypedArgument__Group__0__Impl : ( ( rule__TypedArgument__TypeAssignment_0 ) ) ; | 17056 | // InternalSolverLanguageParser.g:5479:1: rule__TypedArgument__Group__0__Impl : ( ( rule__TypedArgument__TypeAssignment_0 ) ) ; |
18692 | public final void rule__TypedArgument__Group__0__Impl() throws RecognitionException { | 17057 | public final void rule__TypedArgument__Group__0__Impl() throws RecognitionException { |
18693 | 17058 | ||
18694 | int stackSize = keepStackSize(); | 17059 | int stackSize = keepStackSize(); |
18695 | 17060 | ||
18696 | try { | 17061 | try { |
18697 | // InternalSolverLanguage.g:5539:1: ( ( ( rule__TypedArgument__TypeAssignment_0 ) ) ) | 17062 | // InternalSolverLanguageParser.g:5483:1: ( ( ( rule__TypedArgument__TypeAssignment_0 ) ) ) |
18698 | // InternalSolverLanguage.g:5540:1: ( ( rule__TypedArgument__TypeAssignment_0 ) ) | 17063 | // InternalSolverLanguageParser.g:5484:1: ( ( rule__TypedArgument__TypeAssignment_0 ) ) |
18699 | { | 17064 | { |
18700 | // InternalSolverLanguage.g:5540:1: ( ( rule__TypedArgument__TypeAssignment_0 ) ) | 17065 | // InternalSolverLanguageParser.g:5484:1: ( ( rule__TypedArgument__TypeAssignment_0 ) ) |
18701 | // InternalSolverLanguage.g:5541:2: ( rule__TypedArgument__TypeAssignment_0 ) | 17066 | // InternalSolverLanguageParser.g:5485:2: ( rule__TypedArgument__TypeAssignment_0 ) |
18702 | { | 17067 | { |
18703 | if ( state.backtracking==0 ) { | 17068 | before(grammarAccess.getTypedArgumentAccess().getTypeAssignment_0()); |
18704 | before(grammarAccess.getTypedArgumentAccess().getTypeAssignment_0()); | 17069 | // InternalSolverLanguageParser.g:5486:2: ( rule__TypedArgument__TypeAssignment_0 ) |
18705 | } | 17070 | // InternalSolverLanguageParser.g:5486:3: rule__TypedArgument__TypeAssignment_0 |
18706 | // InternalSolverLanguage.g:5542:2: ( rule__TypedArgument__TypeAssignment_0 ) | ||
18707 | // InternalSolverLanguage.g:5542:3: rule__TypedArgument__TypeAssignment_0 | ||
18708 | { | 17071 | { |
18709 | pushFollow(FOLLOW_2); | 17072 | pushFollow(FOLLOW_2); |
18710 | rule__TypedArgument__TypeAssignment_0(); | 17073 | rule__TypedArgument__TypeAssignment_0(); |
18711 | 17074 | ||
18712 | state._fsp--; | 17075 | state._fsp--; |
18713 | if (state.failed) return ; | ||
18714 | 17076 | ||
18715 | } | ||
18716 | 17077 | ||
18717 | if ( state.backtracking==0 ) { | ||
18718 | after(grammarAccess.getTypedArgumentAccess().getTypeAssignment_0()); | ||
18719 | } | 17078 | } |
18720 | 17079 | ||
17080 | after(grammarAccess.getTypedArgumentAccess().getTypeAssignment_0()); | ||
17081 | |||
18721 | } | 17082 | } |
18722 | 17083 | ||
18723 | 17084 | ||
@@ -18739,20 +17100,20 @@ public class InternalSolverLanguageParser extends AbstractInternalContentAssistP | |||
18739 | 17100 | ||
18740 | 17101 | ||
18741 | // $ANTLR start "rule__TypedArgument__Group__1" | 17102 | // $ANTLR start "rule__TypedArgument__Group__1" |
18742 | // InternalSolverLanguage.g:5550:1: rule__TypedArgument__Group__1 : rule__TypedArgument__Group__1__Impl ; | 17103 | // InternalSolverLanguageParser.g:5494:1: rule__TypedArgument__Group__1 : rule__TypedArgument__Group__1__Impl ; |
18743 | public final void rule__TypedArgument__Group__1() throws RecognitionException { | 17104 | public final void rule__TypedArgument__Group__1() throws RecognitionException { |
18744 | 17105 | ||
18745 | int stackSize = keepStackSize(); | 17106 | int stackSize = keepStackSize(); |
18746 | 17107 | ||
18747 | try { | 17108 | try { |
18748 | // InternalSolverLanguage.g:5554:1: ( rule__TypedArgument__Group__1__Impl ) | 17109 | // InternalSolverLanguageParser.g:5498:1: ( rule__TypedArgument__Group__1__Impl ) |
18749 | // InternalSolverLanguage.g:5555:2: rule__TypedArgument__Group__1__Impl | 17110 | // InternalSolverLanguageParser.g:5499:2: rule__TypedArgument__Group__1__Impl |
18750 | { | 17111 | { |
18751 | pushFollow(FOLLOW_2); | 17112 | pushFollow(FOLLOW_2); |
18752 | rule__TypedArgument__Group__1__Impl(); | 17113 | rule__TypedArgument__Group__1__Impl(); |
18753 | 17114 | ||
18754 | state._fsp--; | 17115 | state._fsp--; |
18755 | if (state.failed) return ; | 17116 | |
18756 | 17117 | ||
18757 | } | 17118 | } |
18758 | 17119 | ||
@@ -18772,36 +17133,32 @@ public class InternalSolverLanguageParser extends AbstractInternalContentAssistP | |||
18772 | 17133 | ||
18773 | 17134 | ||
18774 | // $ANTLR start "rule__TypedArgument__Group__1__Impl" | 17135 | // $ANTLR start "rule__TypedArgument__Group__1__Impl" |
18775 | // InternalSolverLanguage.g:5561:1: rule__TypedArgument__Group__1__Impl : ( ( rule__TypedArgument__VariableAssignment_1 ) ) ; | 17136 | // InternalSolverLanguageParser.g:5505:1: rule__TypedArgument__Group__1__Impl : ( ( rule__TypedArgument__VariableAssignment_1 ) ) ; |
18776 | public final void rule__TypedArgument__Group__1__Impl() throws RecognitionException { | 17137 | public final void rule__TypedArgument__Group__1__Impl() throws RecognitionException { |
18777 | 17138 | ||
18778 | int stackSize = keepStackSize(); | 17139 | int stackSize = keepStackSize(); |
18779 | 17140 | ||
18780 | try { | 17141 | try { |
18781 | // InternalSolverLanguage.g:5565:1: ( ( ( rule__TypedArgument__VariableAssignment_1 ) ) ) | 17142 | // InternalSolverLanguageParser.g:5509:1: ( ( ( rule__TypedArgument__VariableAssignment_1 ) ) ) |
18782 | // InternalSolverLanguage.g:5566:1: ( ( rule__TypedArgument__VariableAssignment_1 ) ) | 17143 | // InternalSolverLanguageParser.g:5510:1: ( ( rule__TypedArgument__VariableAssignment_1 ) ) |
18783 | { | 17144 | { |
18784 | // InternalSolverLanguage.g:5566:1: ( ( rule__TypedArgument__VariableAssignment_1 ) ) | 17145 | // InternalSolverLanguageParser.g:5510:1: ( ( rule__TypedArgument__VariableAssignment_1 ) ) |
18785 | // InternalSolverLanguage.g:5567:2: ( rule__TypedArgument__VariableAssignment_1 ) | 17146 | // InternalSolverLanguageParser.g:5511:2: ( rule__TypedArgument__VariableAssignment_1 ) |
18786 | { | 17147 | { |
18787 | if ( state.backtracking==0 ) { | 17148 | before(grammarAccess.getTypedArgumentAccess().getVariableAssignment_1()); |
18788 | before(grammarAccess.getTypedArgumentAccess().getVariableAssignment_1()); | 17149 | // InternalSolverLanguageParser.g:5512:2: ( rule__TypedArgument__VariableAssignment_1 ) |
18789 | } | 17150 | // InternalSolverLanguageParser.g:5512:3: rule__TypedArgument__VariableAssignment_1 |
18790 | // InternalSolverLanguage.g:5568:2: ( rule__TypedArgument__VariableAssignment_1 ) | ||
18791 | // InternalSolverLanguage.g:5568:3: rule__TypedArgument__VariableAssignment_1 | ||
18792 | { | 17151 | { |
18793 | pushFollow(FOLLOW_2); | 17152 | pushFollow(FOLLOW_2); |
18794 | rule__TypedArgument__VariableAssignment_1(); | 17153 | rule__TypedArgument__VariableAssignment_1(); |
18795 | 17154 | ||
18796 | state._fsp--; | 17155 | state._fsp--; |
18797 | if (state.failed) return ; | ||
18798 | 17156 | ||
18799 | } | ||
18800 | 17157 | ||
18801 | if ( state.backtracking==0 ) { | ||
18802 | after(grammarAccess.getTypedArgumentAccess().getVariableAssignment_1()); | ||
18803 | } | 17158 | } |
18804 | 17159 | ||
17160 | after(grammarAccess.getTypedArgumentAccess().getVariableAssignment_1()); | ||
17161 | |||
18805 | } | 17162 | } |
18806 | 17163 | ||
18807 | 17164 | ||
@@ -18823,25 +17180,25 @@ public class InternalSolverLanguageParser extends AbstractInternalContentAssistP | |||
18823 | 17180 | ||
18824 | 17181 | ||
18825 | // $ANTLR start "rule__TypedStarArgument__Group__0" | 17182 | // $ANTLR start "rule__TypedStarArgument__Group__0" |
18826 | // InternalSolverLanguage.g:5577:1: rule__TypedStarArgument__Group__0 : rule__TypedStarArgument__Group__0__Impl rule__TypedStarArgument__Group__1 ; | 17183 | // InternalSolverLanguageParser.g:5521:1: rule__TypedStarArgument__Group__0 : rule__TypedStarArgument__Group__0__Impl rule__TypedStarArgument__Group__1 ; |
18827 | public final void rule__TypedStarArgument__Group__0() throws RecognitionException { | 17184 | public final void rule__TypedStarArgument__Group__0() throws RecognitionException { |
18828 | 17185 | ||
18829 | int stackSize = keepStackSize(); | 17186 | int stackSize = keepStackSize(); |
18830 | 17187 | ||
18831 | try { | 17188 | try { |
18832 | // InternalSolverLanguage.g:5581:1: ( rule__TypedStarArgument__Group__0__Impl rule__TypedStarArgument__Group__1 ) | 17189 | // InternalSolverLanguageParser.g:5525:1: ( rule__TypedStarArgument__Group__0__Impl rule__TypedStarArgument__Group__1 ) |
18833 | // InternalSolverLanguage.g:5582:2: rule__TypedStarArgument__Group__0__Impl rule__TypedStarArgument__Group__1 | 17190 | // InternalSolverLanguageParser.g:5526:2: rule__TypedStarArgument__Group__0__Impl rule__TypedStarArgument__Group__1 |
18834 | { | 17191 | { |
18835 | pushFollow(FOLLOW_38); | 17192 | pushFollow(FOLLOW_37); |
18836 | rule__TypedStarArgument__Group__0__Impl(); | 17193 | rule__TypedStarArgument__Group__0__Impl(); |
18837 | 17194 | ||
18838 | state._fsp--; | 17195 | state._fsp--; |
18839 | if (state.failed) return ; | 17196 | |
18840 | pushFollow(FOLLOW_2); | 17197 | pushFollow(FOLLOW_2); |
18841 | rule__TypedStarArgument__Group__1(); | 17198 | rule__TypedStarArgument__Group__1(); |
18842 | 17199 | ||
18843 | state._fsp--; | 17200 | state._fsp--; |
18844 | if (state.failed) return ; | 17201 | |
18845 | 17202 | ||
18846 | } | 17203 | } |
18847 | 17204 | ||
@@ -18861,36 +17218,32 @@ public class InternalSolverLanguageParser extends AbstractInternalContentAssistP | |||
18861 | 17218 | ||
18862 | 17219 | ||
18863 | // $ANTLR start "rule__TypedStarArgument__Group__0__Impl" | 17220 | // $ANTLR start "rule__TypedStarArgument__Group__0__Impl" |
18864 | // InternalSolverLanguage.g:5589:1: rule__TypedStarArgument__Group__0__Impl : ( ( rule__TypedStarArgument__TypeAssignment_0 ) ) ; | 17221 | // InternalSolverLanguageParser.g:5533:1: rule__TypedStarArgument__Group__0__Impl : ( ( rule__TypedStarArgument__TypeAssignment_0 ) ) ; |
18865 | public final void rule__TypedStarArgument__Group__0__Impl() throws RecognitionException { | 17222 | public final void rule__TypedStarArgument__Group__0__Impl() throws RecognitionException { |
18866 | 17223 | ||
18867 | int stackSize = keepStackSize(); | 17224 | int stackSize = keepStackSize(); |
18868 | 17225 | ||
18869 | try { | 17226 | try { |
18870 | // InternalSolverLanguage.g:5593:1: ( ( ( rule__TypedStarArgument__TypeAssignment_0 ) ) ) | 17227 | // InternalSolverLanguageParser.g:5537:1: ( ( ( rule__TypedStarArgument__TypeAssignment_0 ) ) ) |
18871 | // InternalSolverLanguage.g:5594:1: ( ( rule__TypedStarArgument__TypeAssignment_0 ) ) | 17228 | // InternalSolverLanguageParser.g:5538:1: ( ( rule__TypedStarArgument__TypeAssignment_0 ) ) |
18872 | { | 17229 | { |
18873 | // InternalSolverLanguage.g:5594:1: ( ( rule__TypedStarArgument__TypeAssignment_0 ) ) | 17230 | // InternalSolverLanguageParser.g:5538:1: ( ( rule__TypedStarArgument__TypeAssignment_0 ) ) |
18874 | // InternalSolverLanguage.g:5595:2: ( rule__TypedStarArgument__TypeAssignment_0 ) | 17231 | // InternalSolverLanguageParser.g:5539:2: ( rule__TypedStarArgument__TypeAssignment_0 ) |
18875 | { | 17232 | { |
18876 | if ( state.backtracking==0 ) { | 17233 | before(grammarAccess.getTypedStarArgumentAccess().getTypeAssignment_0()); |
18877 | before(grammarAccess.getTypedStarArgumentAccess().getTypeAssignment_0()); | 17234 | // InternalSolverLanguageParser.g:5540:2: ( rule__TypedStarArgument__TypeAssignment_0 ) |
18878 | } | 17235 | // InternalSolverLanguageParser.g:5540:3: rule__TypedStarArgument__TypeAssignment_0 |
18879 | // InternalSolverLanguage.g:5596:2: ( rule__TypedStarArgument__TypeAssignment_0 ) | ||
18880 | // InternalSolverLanguage.g:5596:3: rule__TypedStarArgument__TypeAssignment_0 | ||
18881 | { | 17236 | { |
18882 | pushFollow(FOLLOW_2); | 17237 | pushFollow(FOLLOW_2); |
18883 | rule__TypedStarArgument__TypeAssignment_0(); | 17238 | rule__TypedStarArgument__TypeAssignment_0(); |
18884 | 17239 | ||
18885 | state._fsp--; | 17240 | state._fsp--; |
18886 | if (state.failed) return ; | ||
18887 | 17241 | ||
18888 | } | ||
18889 | 17242 | ||
18890 | if ( state.backtracking==0 ) { | ||
18891 | after(grammarAccess.getTypedStarArgumentAccess().getTypeAssignment_0()); | ||
18892 | } | 17243 | } |
18893 | 17244 | ||
17245 | after(grammarAccess.getTypedStarArgumentAccess().getTypeAssignment_0()); | ||
17246 | |||
18894 | } | 17247 | } |
18895 | 17248 | ||
18896 | 17249 | ||
@@ -18912,20 +17265,20 @@ public class InternalSolverLanguageParser extends AbstractInternalContentAssistP | |||
18912 | 17265 | ||
18913 | 17266 | ||
18914 | // $ANTLR start "rule__TypedStarArgument__Group__1" | 17267 | // $ANTLR start "rule__TypedStarArgument__Group__1" |
18915 | // InternalSolverLanguage.g:5604:1: rule__TypedStarArgument__Group__1 : rule__TypedStarArgument__Group__1__Impl ; | 17268 | // InternalSolverLanguageParser.g:5548:1: rule__TypedStarArgument__Group__1 : rule__TypedStarArgument__Group__1__Impl ; |
18916 | public final void rule__TypedStarArgument__Group__1() throws RecognitionException { | 17269 | public final void rule__TypedStarArgument__Group__1() throws RecognitionException { |
18917 | 17270 | ||
18918 | int stackSize = keepStackSize(); | 17271 | int stackSize = keepStackSize(); |
18919 | 17272 | ||
18920 | try { | 17273 | try { |
18921 | // InternalSolverLanguage.g:5608:1: ( rule__TypedStarArgument__Group__1__Impl ) | 17274 | // InternalSolverLanguageParser.g:5552:1: ( rule__TypedStarArgument__Group__1__Impl ) |
18922 | // InternalSolverLanguage.g:5609:2: rule__TypedStarArgument__Group__1__Impl | 17275 | // InternalSolverLanguageParser.g:5553:2: rule__TypedStarArgument__Group__1__Impl |
18923 | { | 17276 | { |
18924 | pushFollow(FOLLOW_2); | 17277 | pushFollow(FOLLOW_2); |
18925 | rule__TypedStarArgument__Group__1__Impl(); | 17278 | rule__TypedStarArgument__Group__1__Impl(); |
18926 | 17279 | ||
18927 | state._fsp--; | 17280 | state._fsp--; |
18928 | if (state.failed) return ; | 17281 | |
18929 | 17282 | ||
18930 | } | 17283 | } |
18931 | 17284 | ||
@@ -18945,25 +17298,21 @@ public class InternalSolverLanguageParser extends AbstractInternalContentAssistP | |||
18945 | 17298 | ||
18946 | 17299 | ||
18947 | // $ANTLR start "rule__TypedStarArgument__Group__1__Impl" | 17300 | // $ANTLR start "rule__TypedStarArgument__Group__1__Impl" |
18948 | // InternalSolverLanguage.g:5615:1: rule__TypedStarArgument__Group__1__Impl : ( '*' ) ; | 17301 | // InternalSolverLanguageParser.g:5559:1: rule__TypedStarArgument__Group__1__Impl : ( Asterisk ) ; |
18949 | public final void rule__TypedStarArgument__Group__1__Impl() throws RecognitionException { | 17302 | public final void rule__TypedStarArgument__Group__1__Impl() throws RecognitionException { |
18950 | 17303 | ||
18951 | int stackSize = keepStackSize(); | 17304 | int stackSize = keepStackSize(); |
18952 | 17305 | ||
18953 | try { | 17306 | try { |
18954 | // InternalSolverLanguage.g:5619:1: ( ( '*' ) ) | 17307 | // InternalSolverLanguageParser.g:5563:1: ( ( Asterisk ) ) |
18955 | // InternalSolverLanguage.g:5620:1: ( '*' ) | 17308 | // InternalSolverLanguageParser.g:5564:1: ( Asterisk ) |
18956 | { | 17309 | { |
18957 | // InternalSolverLanguage.g:5620:1: ( '*' ) | 17310 | // InternalSolverLanguageParser.g:5564:1: ( Asterisk ) |
18958 | // InternalSolverLanguage.g:5621:2: '*' | 17311 | // InternalSolverLanguageParser.g:5565:2: Asterisk |
18959 | { | 17312 | { |
18960 | if ( state.backtracking==0 ) { | 17313 | before(grammarAccess.getTypedStarArgumentAccess().getAsteriskKeyword_1()); |
18961 | before(grammarAccess.getTypedStarArgumentAccess().getAsteriskKeyword_1()); | 17314 | match(input,Asterisk,FOLLOW_2); |
18962 | } | 17315 | after(grammarAccess.getTypedStarArgumentAccess().getAsteriskKeyword_1()); |
18963 | match(input,16,FOLLOW_2); if (state.failed) return ; | ||
18964 | if ( state.backtracking==0 ) { | ||
18965 | after(grammarAccess.getTypedStarArgumentAccess().getAsteriskKeyword_1()); | ||
18966 | } | ||
18967 | 17316 | ||
18968 | } | 17317 | } |
18969 | 17318 | ||
@@ -18986,25 +17335,25 @@ public class InternalSolverLanguageParser extends AbstractInternalContentAssistP | |||
18986 | 17335 | ||
18987 | 17336 | ||
18988 | // $ANTLR start "rule__Interval__Group__0" | 17337 | // $ANTLR start "rule__Interval__Group__0" |
18989 | // InternalSolverLanguage.g:5631:1: rule__Interval__Group__0 : rule__Interval__Group__0__Impl rule__Interval__Group__1 ; | 17338 | // InternalSolverLanguageParser.g:5575:1: rule__Interval__Group__0 : rule__Interval__Group__0__Impl rule__Interval__Group__1 ; |
18990 | public final void rule__Interval__Group__0() throws RecognitionException { | 17339 | public final void rule__Interval__Group__0() throws RecognitionException { |
18991 | 17340 | ||
18992 | int stackSize = keepStackSize(); | 17341 | int stackSize = keepStackSize(); |
18993 | 17342 | ||
18994 | try { | 17343 | try { |
18995 | // InternalSolverLanguage.g:5635:1: ( rule__Interval__Group__0__Impl rule__Interval__Group__1 ) | 17344 | // InternalSolverLanguageParser.g:5579:1: ( rule__Interval__Group__0__Impl rule__Interval__Group__1 ) |
18996 | // InternalSolverLanguage.g:5636:2: rule__Interval__Group__0__Impl rule__Interval__Group__1 | 17345 | // InternalSolverLanguageParser.g:5580:2: rule__Interval__Group__0__Impl rule__Interval__Group__1 |
18997 | { | 17346 | { |
18998 | pushFollow(FOLLOW_7); | 17347 | pushFollow(FOLLOW_7); |
18999 | rule__Interval__Group__0__Impl(); | 17348 | rule__Interval__Group__0__Impl(); |
19000 | 17349 | ||
19001 | state._fsp--; | 17350 | state._fsp--; |
19002 | if (state.failed) return ; | 17351 | |
19003 | pushFollow(FOLLOW_2); | 17352 | pushFollow(FOLLOW_2); |
19004 | rule__Interval__Group__1(); | 17353 | rule__Interval__Group__1(); |
19005 | 17354 | ||
19006 | state._fsp--; | 17355 | state._fsp--; |
19007 | if (state.failed) return ; | 17356 | |
19008 | 17357 | ||
19009 | } | 17358 | } |
19010 | 17359 | ||
@@ -19024,25 +17373,21 @@ public class InternalSolverLanguageParser extends AbstractInternalContentAssistP | |||
19024 | 17373 | ||
19025 | 17374 | ||
19026 | // $ANTLR start "rule__Interval__Group__0__Impl" | 17375 | // $ANTLR start "rule__Interval__Group__0__Impl" |
19027 | // InternalSolverLanguage.g:5643:1: rule__Interval__Group__0__Impl : ( '[' ) ; | 17376 | // InternalSolverLanguageParser.g:5587:1: rule__Interval__Group__0__Impl : ( LeftSquareBracket ) ; |
19028 | public final void rule__Interval__Group__0__Impl() throws RecognitionException { | 17377 | public final void rule__Interval__Group__0__Impl() throws RecognitionException { |
19029 | 17378 | ||
19030 | int stackSize = keepStackSize(); | 17379 | int stackSize = keepStackSize(); |
19031 | 17380 | ||
19032 | try { | 17381 | try { |
19033 | // InternalSolverLanguage.g:5647:1: ( ( '[' ) ) | 17382 | // InternalSolverLanguageParser.g:5591:1: ( ( LeftSquareBracket ) ) |
19034 | // InternalSolverLanguage.g:5648:1: ( '[' ) | 17383 | // InternalSolverLanguageParser.g:5592:1: ( LeftSquareBracket ) |
19035 | { | 17384 | { |
19036 | // InternalSolverLanguage.g:5648:1: ( '[' ) | 17385 | // InternalSolverLanguageParser.g:5592:1: ( LeftSquareBracket ) |
19037 | // InternalSolverLanguage.g:5649:2: '[' | 17386 | // InternalSolverLanguageParser.g:5593:2: LeftSquareBracket |
19038 | { | 17387 | { |
19039 | if ( state.backtracking==0 ) { | 17388 | before(grammarAccess.getIntervalAccess().getLeftSquareBracketKeyword_0()); |
19040 | before(grammarAccess.getIntervalAccess().getLeftSquareBracketKeyword_0()); | 17389 | match(input,LeftSquareBracket,FOLLOW_2); |
19041 | } | 17390 | after(grammarAccess.getIntervalAccess().getLeftSquareBracketKeyword_0()); |
19042 | match(input,63,FOLLOW_2); if (state.failed) return ; | ||
19043 | if ( state.backtracking==0 ) { | ||
19044 | after(grammarAccess.getIntervalAccess().getLeftSquareBracketKeyword_0()); | ||
19045 | } | ||
19046 | 17391 | ||
19047 | } | 17392 | } |
19048 | 17393 | ||
@@ -19065,25 +17410,25 @@ public class InternalSolverLanguageParser extends AbstractInternalContentAssistP | |||
19065 | 17410 | ||
19066 | 17411 | ||
19067 | // $ANTLR start "rule__Interval__Group__1" | 17412 | // $ANTLR start "rule__Interval__Group__1" |
19068 | // InternalSolverLanguage.g:5658:1: rule__Interval__Group__1 : rule__Interval__Group__1__Impl rule__Interval__Group__2 ; | 17413 | // InternalSolverLanguageParser.g:5602:1: rule__Interval__Group__1 : rule__Interval__Group__1__Impl rule__Interval__Group__2 ; |
19069 | public final void rule__Interval__Group__1() throws RecognitionException { | 17414 | public final void rule__Interval__Group__1() throws RecognitionException { |
19070 | 17415 | ||
19071 | int stackSize = keepStackSize(); | 17416 | int stackSize = keepStackSize(); |
19072 | 17417 | ||
19073 | try { | 17418 | try { |
19074 | // InternalSolverLanguage.g:5662:1: ( rule__Interval__Group__1__Impl rule__Interval__Group__2 ) | 17419 | // InternalSolverLanguageParser.g:5606:1: ( rule__Interval__Group__1__Impl rule__Interval__Group__2 ) |
19075 | // InternalSolverLanguage.g:5663:2: rule__Interval__Group__1__Impl rule__Interval__Group__2 | 17420 | // InternalSolverLanguageParser.g:5607:2: rule__Interval__Group__1__Impl rule__Interval__Group__2 |
19076 | { | 17421 | { |
19077 | pushFollow(FOLLOW_39); | 17422 | pushFollow(FOLLOW_38); |
19078 | rule__Interval__Group__1__Impl(); | 17423 | rule__Interval__Group__1__Impl(); |
19079 | 17424 | ||
19080 | state._fsp--; | 17425 | state._fsp--; |
19081 | if (state.failed) return ; | 17426 | |
19082 | pushFollow(FOLLOW_2); | 17427 | pushFollow(FOLLOW_2); |
19083 | rule__Interval__Group__2(); | 17428 | rule__Interval__Group__2(); |
19084 | 17429 | ||
19085 | state._fsp--; | 17430 | state._fsp--; |
19086 | if (state.failed) return ; | 17431 | |
19087 | 17432 | ||
19088 | } | 17433 | } |
19089 | 17434 | ||
@@ -19103,36 +17448,32 @@ public class InternalSolverLanguageParser extends AbstractInternalContentAssistP | |||
19103 | 17448 | ||
19104 | 17449 | ||
19105 | // $ANTLR start "rule__Interval__Group__1__Impl" | 17450 | // $ANTLR start "rule__Interval__Group__1__Impl" |
19106 | // InternalSolverLanguage.g:5670:1: rule__Interval__Group__1__Impl : ( ( rule__Interval__LowerBoundAssignment_1 ) ) ; | 17451 | // InternalSolverLanguageParser.g:5614:1: rule__Interval__Group__1__Impl : ( ( rule__Interval__LowerBoundAssignment_1 ) ) ; |
19107 | public final void rule__Interval__Group__1__Impl() throws RecognitionException { | 17452 | public final void rule__Interval__Group__1__Impl() throws RecognitionException { |
19108 | 17453 | ||
19109 | int stackSize = keepStackSize(); | 17454 | int stackSize = keepStackSize(); |
19110 | 17455 | ||
19111 | try { | 17456 | try { |
19112 | // InternalSolverLanguage.g:5674:1: ( ( ( rule__Interval__LowerBoundAssignment_1 ) ) ) | 17457 | // InternalSolverLanguageParser.g:5618:1: ( ( ( rule__Interval__LowerBoundAssignment_1 ) ) ) |
19113 | // InternalSolverLanguage.g:5675:1: ( ( rule__Interval__LowerBoundAssignment_1 ) ) | 17458 | // InternalSolverLanguageParser.g:5619:1: ( ( rule__Interval__LowerBoundAssignment_1 ) ) |
19114 | { | 17459 | { |
19115 | // InternalSolverLanguage.g:5675:1: ( ( rule__Interval__LowerBoundAssignment_1 ) ) | 17460 | // InternalSolverLanguageParser.g:5619:1: ( ( rule__Interval__LowerBoundAssignment_1 ) ) |
19116 | // InternalSolverLanguage.g:5676:2: ( rule__Interval__LowerBoundAssignment_1 ) | 17461 | // InternalSolverLanguageParser.g:5620:2: ( rule__Interval__LowerBoundAssignment_1 ) |
19117 | { | 17462 | { |
19118 | if ( state.backtracking==0 ) { | 17463 | before(grammarAccess.getIntervalAccess().getLowerBoundAssignment_1()); |
19119 | before(grammarAccess.getIntervalAccess().getLowerBoundAssignment_1()); | 17464 | // InternalSolverLanguageParser.g:5621:2: ( rule__Interval__LowerBoundAssignment_1 ) |
19120 | } | 17465 | // InternalSolverLanguageParser.g:5621:3: rule__Interval__LowerBoundAssignment_1 |
19121 | // InternalSolverLanguage.g:5677:2: ( rule__Interval__LowerBoundAssignment_1 ) | ||
19122 | // InternalSolverLanguage.g:5677:3: rule__Interval__LowerBoundAssignment_1 | ||
19123 | { | 17466 | { |
19124 | pushFollow(FOLLOW_2); | 17467 | pushFollow(FOLLOW_2); |
19125 | rule__Interval__LowerBoundAssignment_1(); | 17468 | rule__Interval__LowerBoundAssignment_1(); |
19126 | 17469 | ||
19127 | state._fsp--; | 17470 | state._fsp--; |
19128 | if (state.failed) return ; | ||
19129 | 17471 | ||
19130 | } | ||
19131 | 17472 | ||
19132 | if ( state.backtracking==0 ) { | ||
19133 | after(grammarAccess.getIntervalAccess().getLowerBoundAssignment_1()); | ||
19134 | } | 17473 | } |
19135 | 17474 | ||
17475 | after(grammarAccess.getIntervalAccess().getLowerBoundAssignment_1()); | ||
17476 | |||
19136 | } | 17477 | } |
19137 | 17478 | ||
19138 | 17479 | ||
@@ -19154,25 +17495,25 @@ public class InternalSolverLanguageParser extends AbstractInternalContentAssistP | |||
19154 | 17495 | ||
19155 | 17496 | ||
19156 | // $ANTLR start "rule__Interval__Group__2" | 17497 | // $ANTLR start "rule__Interval__Group__2" |
19157 | // InternalSolverLanguage.g:5685:1: rule__Interval__Group__2 : rule__Interval__Group__2__Impl rule__Interval__Group__3 ; | 17498 | // InternalSolverLanguageParser.g:5629:1: rule__Interval__Group__2 : rule__Interval__Group__2__Impl rule__Interval__Group__3 ; |
19158 | public final void rule__Interval__Group__2() throws RecognitionException { | 17499 | public final void rule__Interval__Group__2() throws RecognitionException { |
19159 | 17500 | ||
19160 | int stackSize = keepStackSize(); | 17501 | int stackSize = keepStackSize(); |
19161 | 17502 | ||
19162 | try { | 17503 | try { |
19163 | // InternalSolverLanguage.g:5689:1: ( rule__Interval__Group__2__Impl rule__Interval__Group__3 ) | 17504 | // InternalSolverLanguageParser.g:5633:1: ( rule__Interval__Group__2__Impl rule__Interval__Group__3 ) |
19164 | // InternalSolverLanguage.g:5690:2: rule__Interval__Group__2__Impl rule__Interval__Group__3 | 17505 | // InternalSolverLanguageParser.g:5634:2: rule__Interval__Group__2__Impl rule__Interval__Group__3 |
19165 | { | 17506 | { |
19166 | pushFollow(FOLLOW_7); | 17507 | pushFollow(FOLLOW_7); |
19167 | rule__Interval__Group__2__Impl(); | 17508 | rule__Interval__Group__2__Impl(); |
19168 | 17509 | ||
19169 | state._fsp--; | 17510 | state._fsp--; |
19170 | if (state.failed) return ; | 17511 | |
19171 | pushFollow(FOLLOW_2); | 17512 | pushFollow(FOLLOW_2); |
19172 | rule__Interval__Group__3(); | 17513 | rule__Interval__Group__3(); |
19173 | 17514 | ||
19174 | state._fsp--; | 17515 | state._fsp--; |
19175 | if (state.failed) return ; | 17516 | |
19176 | 17517 | ||
19177 | } | 17518 | } |
19178 | 17519 | ||
@@ -19192,25 +17533,21 @@ public class InternalSolverLanguageParser extends AbstractInternalContentAssistP | |||
19192 | 17533 | ||
19193 | 17534 | ||
19194 | // $ANTLR start "rule__Interval__Group__2__Impl" | 17535 | // $ANTLR start "rule__Interval__Group__2__Impl" |
19195 | // InternalSolverLanguage.g:5697:1: rule__Interval__Group__2__Impl : ( '..' ) ; | 17536 | // InternalSolverLanguageParser.g:5641:1: rule__Interval__Group__2__Impl : ( FullStopFullStop ) ; |
19196 | public final void rule__Interval__Group__2__Impl() throws RecognitionException { | 17537 | public final void rule__Interval__Group__2__Impl() throws RecognitionException { |
19197 | 17538 | ||
19198 | int stackSize = keepStackSize(); | 17539 | int stackSize = keepStackSize(); |
19199 | 17540 | ||
19200 | try { | 17541 | try { |
19201 | // InternalSolverLanguage.g:5701:1: ( ( '..' ) ) | 17542 | // InternalSolverLanguageParser.g:5645:1: ( ( FullStopFullStop ) ) |
19202 | // InternalSolverLanguage.g:5702:1: ( '..' ) | 17543 | // InternalSolverLanguageParser.g:5646:1: ( FullStopFullStop ) |
19203 | { | 17544 | { |
19204 | // InternalSolverLanguage.g:5702:1: ( '..' ) | 17545 | // InternalSolverLanguageParser.g:5646:1: ( FullStopFullStop ) |
19205 | // InternalSolverLanguage.g:5703:2: '..' | 17546 | // InternalSolverLanguageParser.g:5647:2: FullStopFullStop |
19206 | { | 17547 | { |
19207 | if ( state.backtracking==0 ) { | 17548 | before(grammarAccess.getIntervalAccess().getFullStopFullStopKeyword_2()); |
19208 | before(grammarAccess.getIntervalAccess().getFullStopFullStopKeyword_2()); | 17549 | match(input,FullStopFullStop,FOLLOW_2); |
19209 | } | 17550 | after(grammarAccess.getIntervalAccess().getFullStopFullStopKeyword_2()); |
19210 | match(input,64,FOLLOW_2); if (state.failed) return ; | ||
19211 | if ( state.backtracking==0 ) { | ||
19212 | after(grammarAccess.getIntervalAccess().getFullStopFullStopKeyword_2()); | ||
19213 | } | ||
19214 | 17551 | ||
19215 | } | 17552 | } |
19216 | 17553 | ||
@@ -19233,25 +17570,25 @@ public class InternalSolverLanguageParser extends AbstractInternalContentAssistP | |||
19233 | 17570 | ||
19234 | 17571 | ||
19235 | // $ANTLR start "rule__Interval__Group__3" | 17572 | // $ANTLR start "rule__Interval__Group__3" |
19236 | // InternalSolverLanguage.g:5712:1: rule__Interval__Group__3 : rule__Interval__Group__3__Impl rule__Interval__Group__4 ; | 17573 | // InternalSolverLanguageParser.g:5656:1: rule__Interval__Group__3 : rule__Interval__Group__3__Impl rule__Interval__Group__4 ; |
19237 | public final void rule__Interval__Group__3() throws RecognitionException { | 17574 | public final void rule__Interval__Group__3() throws RecognitionException { |
19238 | 17575 | ||
19239 | int stackSize = keepStackSize(); | 17576 | int stackSize = keepStackSize(); |
19240 | 17577 | ||
19241 | try { | 17578 | try { |
19242 | // InternalSolverLanguage.g:5716:1: ( rule__Interval__Group__3__Impl rule__Interval__Group__4 ) | 17579 | // InternalSolverLanguageParser.g:5660:1: ( rule__Interval__Group__3__Impl rule__Interval__Group__4 ) |
19243 | // InternalSolverLanguage.g:5717:2: rule__Interval__Group__3__Impl rule__Interval__Group__4 | 17580 | // InternalSolverLanguageParser.g:5661:2: rule__Interval__Group__3__Impl rule__Interval__Group__4 |
19244 | { | 17581 | { |
19245 | pushFollow(FOLLOW_40); | 17582 | pushFollow(FOLLOW_39); |
19246 | rule__Interval__Group__3__Impl(); | 17583 | rule__Interval__Group__3__Impl(); |
19247 | 17584 | ||
19248 | state._fsp--; | 17585 | state._fsp--; |
19249 | if (state.failed) return ; | 17586 | |
19250 | pushFollow(FOLLOW_2); | 17587 | pushFollow(FOLLOW_2); |
19251 | rule__Interval__Group__4(); | 17588 | rule__Interval__Group__4(); |
19252 | 17589 | ||
19253 | state._fsp--; | 17590 | state._fsp--; |
19254 | if (state.failed) return ; | 17591 | |
19255 | 17592 | ||
19256 | } | 17593 | } |
19257 | 17594 | ||
@@ -19271,36 +17608,32 @@ public class InternalSolverLanguageParser extends AbstractInternalContentAssistP | |||
19271 | 17608 | ||
19272 | 17609 | ||
19273 | // $ANTLR start "rule__Interval__Group__3__Impl" | 17610 | // $ANTLR start "rule__Interval__Group__3__Impl" |
19274 | // InternalSolverLanguage.g:5724:1: rule__Interval__Group__3__Impl : ( ( rule__Interval__UpperBoundAssignment_3 ) ) ; | 17611 | // InternalSolverLanguageParser.g:5668:1: rule__Interval__Group__3__Impl : ( ( rule__Interval__UpperBoundAssignment_3 ) ) ; |
19275 | public final void rule__Interval__Group__3__Impl() throws RecognitionException { | 17612 | public final void rule__Interval__Group__3__Impl() throws RecognitionException { |
19276 | 17613 | ||
19277 | int stackSize = keepStackSize(); | 17614 | int stackSize = keepStackSize(); |
19278 | 17615 | ||
19279 | try { | 17616 | try { |
19280 | // InternalSolverLanguage.g:5728:1: ( ( ( rule__Interval__UpperBoundAssignment_3 ) ) ) | 17617 | // InternalSolverLanguageParser.g:5672:1: ( ( ( rule__Interval__UpperBoundAssignment_3 ) ) ) |
19281 | // InternalSolverLanguage.g:5729:1: ( ( rule__Interval__UpperBoundAssignment_3 ) ) | 17618 | // InternalSolverLanguageParser.g:5673:1: ( ( rule__Interval__UpperBoundAssignment_3 ) ) |
19282 | { | 17619 | { |
19283 | // InternalSolverLanguage.g:5729:1: ( ( rule__Interval__UpperBoundAssignment_3 ) ) | 17620 | // InternalSolverLanguageParser.g:5673:1: ( ( rule__Interval__UpperBoundAssignment_3 ) ) |
19284 | // InternalSolverLanguage.g:5730:2: ( rule__Interval__UpperBoundAssignment_3 ) | 17621 | // InternalSolverLanguageParser.g:5674:2: ( rule__Interval__UpperBoundAssignment_3 ) |
19285 | { | 17622 | { |
19286 | if ( state.backtracking==0 ) { | 17623 | before(grammarAccess.getIntervalAccess().getUpperBoundAssignment_3()); |
19287 | before(grammarAccess.getIntervalAccess().getUpperBoundAssignment_3()); | 17624 | // InternalSolverLanguageParser.g:5675:2: ( rule__Interval__UpperBoundAssignment_3 ) |
19288 | } | 17625 | // InternalSolverLanguageParser.g:5675:3: rule__Interval__UpperBoundAssignment_3 |
19289 | // InternalSolverLanguage.g:5731:2: ( rule__Interval__UpperBoundAssignment_3 ) | ||
19290 | // InternalSolverLanguage.g:5731:3: rule__Interval__UpperBoundAssignment_3 | ||
19291 | { | 17626 | { |
19292 | pushFollow(FOLLOW_2); | 17627 | pushFollow(FOLLOW_2); |
19293 | rule__Interval__UpperBoundAssignment_3(); | 17628 | rule__Interval__UpperBoundAssignment_3(); |
19294 | 17629 | ||
19295 | state._fsp--; | 17630 | state._fsp--; |
19296 | if (state.failed) return ; | ||
19297 | 17631 | ||
19298 | } | ||
19299 | 17632 | ||
19300 | if ( state.backtracking==0 ) { | ||
19301 | after(grammarAccess.getIntervalAccess().getUpperBoundAssignment_3()); | ||
19302 | } | 17633 | } |
19303 | 17634 | ||
17635 | after(grammarAccess.getIntervalAccess().getUpperBoundAssignment_3()); | ||
17636 | |||
19304 | } | 17637 | } |
19305 | 17638 | ||
19306 | 17639 | ||
@@ -19322,20 +17655,20 @@ public class InternalSolverLanguageParser extends AbstractInternalContentAssistP | |||
19322 | 17655 | ||
19323 | 17656 | ||
19324 | // $ANTLR start "rule__Interval__Group__4" | 17657 | // $ANTLR start "rule__Interval__Group__4" |
19325 | // InternalSolverLanguage.g:5739:1: rule__Interval__Group__4 : rule__Interval__Group__4__Impl ; | 17658 | // InternalSolverLanguageParser.g:5683:1: rule__Interval__Group__4 : rule__Interval__Group__4__Impl ; |
19326 | public final void rule__Interval__Group__4() throws RecognitionException { | 17659 | public final void rule__Interval__Group__4() throws RecognitionException { |
19327 | 17660 | ||
19328 | int stackSize = keepStackSize(); | 17661 | int stackSize = keepStackSize(); |
19329 | 17662 | ||
19330 | try { | 17663 | try { |
19331 | // InternalSolverLanguage.g:5743:1: ( rule__Interval__Group__4__Impl ) | 17664 | // InternalSolverLanguageParser.g:5687:1: ( rule__Interval__Group__4__Impl ) |
19332 | // InternalSolverLanguage.g:5744:2: rule__Interval__Group__4__Impl | 17665 | // InternalSolverLanguageParser.g:5688:2: rule__Interval__Group__4__Impl |
19333 | { | 17666 | { |
19334 | pushFollow(FOLLOW_2); | 17667 | pushFollow(FOLLOW_2); |
19335 | rule__Interval__Group__4__Impl(); | 17668 | rule__Interval__Group__4__Impl(); |
19336 | 17669 | ||
19337 | state._fsp--; | 17670 | state._fsp--; |
19338 | if (state.failed) return ; | 17671 | |
19339 | 17672 | ||
19340 | } | 17673 | } |
19341 | 17674 | ||
@@ -19355,25 +17688,21 @@ public class InternalSolverLanguageParser extends AbstractInternalContentAssistP | |||
19355 | 17688 | ||
19356 | 17689 | ||
19357 | // $ANTLR start "rule__Interval__Group__4__Impl" | 17690 | // $ANTLR start "rule__Interval__Group__4__Impl" |
19358 | // InternalSolverLanguage.g:5750:1: rule__Interval__Group__4__Impl : ( ']' ) ; | 17691 | // InternalSolverLanguageParser.g:5694:1: rule__Interval__Group__4__Impl : ( RightSquareBracket ) ; |
19359 | public final void rule__Interval__Group__4__Impl() throws RecognitionException { | 17692 | public final void rule__Interval__Group__4__Impl() throws RecognitionException { |
19360 | 17693 | ||
19361 | int stackSize = keepStackSize(); | 17694 | int stackSize = keepStackSize(); |
19362 | 17695 | ||
19363 | try { | 17696 | try { |
19364 | // InternalSolverLanguage.g:5754:1: ( ( ']' ) ) | 17697 | // InternalSolverLanguageParser.g:5698:1: ( ( RightSquareBracket ) ) |
19365 | // InternalSolverLanguage.g:5755:1: ( ']' ) | 17698 | // InternalSolverLanguageParser.g:5699:1: ( RightSquareBracket ) |
19366 | { | 17699 | { |
19367 | // InternalSolverLanguage.g:5755:1: ( ']' ) | 17700 | // InternalSolverLanguageParser.g:5699:1: ( RightSquareBracket ) |
19368 | // InternalSolverLanguage.g:5756:2: ']' | 17701 | // InternalSolverLanguageParser.g:5700:2: RightSquareBracket |
19369 | { | 17702 | { |
19370 | if ( state.backtracking==0 ) { | 17703 | before(grammarAccess.getIntervalAccess().getRightSquareBracketKeyword_4()); |
19371 | before(grammarAccess.getIntervalAccess().getRightSquareBracketKeyword_4()); | 17704 | match(input,RightSquareBracket,FOLLOW_2); |
19372 | } | 17705 | after(grammarAccess.getIntervalAccess().getRightSquareBracketKeyword_4()); |
19373 | match(input,65,FOLLOW_2); if (state.failed) return ; | ||
19374 | if ( state.backtracking==0 ) { | ||
19375 | after(grammarAccess.getIntervalAccess().getRightSquareBracketKeyword_4()); | ||
19376 | } | ||
19377 | 17706 | ||
19378 | } | 17707 | } |
19379 | 17708 | ||
@@ -19396,25 +17725,25 @@ public class InternalSolverLanguageParser extends AbstractInternalContentAssistP | |||
19396 | 17725 | ||
19397 | 17726 | ||
19398 | // $ANTLR start "rule__InfinityLiteral__Group__0" | 17727 | // $ANTLR start "rule__InfinityLiteral__Group__0" |
19399 | // InternalSolverLanguage.g:5766:1: rule__InfinityLiteral__Group__0 : rule__InfinityLiteral__Group__0__Impl rule__InfinityLiteral__Group__1 ; | 17728 | // InternalSolverLanguageParser.g:5710:1: rule__InfinityLiteral__Group__0 : rule__InfinityLiteral__Group__0__Impl rule__InfinityLiteral__Group__1 ; |
19400 | public final void rule__InfinityLiteral__Group__0() throws RecognitionException { | 17729 | public final void rule__InfinityLiteral__Group__0() throws RecognitionException { |
19401 | 17730 | ||
19402 | int stackSize = keepStackSize(); | 17731 | int stackSize = keepStackSize(); |
19403 | 17732 | ||
19404 | try { | 17733 | try { |
19405 | // InternalSolverLanguage.g:5770:1: ( rule__InfinityLiteral__Group__0__Impl rule__InfinityLiteral__Group__1 ) | 17734 | // InternalSolverLanguageParser.g:5714:1: ( rule__InfinityLiteral__Group__0__Impl rule__InfinityLiteral__Group__1 ) |
19406 | // InternalSolverLanguage.g:5771:2: rule__InfinityLiteral__Group__0__Impl rule__InfinityLiteral__Group__1 | 17735 | // InternalSolverLanguageParser.g:5715:2: rule__InfinityLiteral__Group__0__Impl rule__InfinityLiteral__Group__1 |
19407 | { | 17736 | { |
19408 | pushFollow(FOLLOW_41); | 17737 | pushFollow(FOLLOW_40); |
19409 | rule__InfinityLiteral__Group__0__Impl(); | 17738 | rule__InfinityLiteral__Group__0__Impl(); |
19410 | 17739 | ||
19411 | state._fsp--; | 17740 | state._fsp--; |
19412 | if (state.failed) return ; | 17741 | |
19413 | pushFollow(FOLLOW_2); | 17742 | pushFollow(FOLLOW_2); |
19414 | rule__InfinityLiteral__Group__1(); | 17743 | rule__InfinityLiteral__Group__1(); |
19415 | 17744 | ||
19416 | state._fsp--; | 17745 | state._fsp--; |
19417 | if (state.failed) return ; | 17746 | |
19418 | 17747 | ||
19419 | } | 17748 | } |
19420 | 17749 | ||
@@ -19434,29 +17763,25 @@ public class InternalSolverLanguageParser extends AbstractInternalContentAssistP | |||
19434 | 17763 | ||
19435 | 17764 | ||
19436 | // $ANTLR start "rule__InfinityLiteral__Group__0__Impl" | 17765 | // $ANTLR start "rule__InfinityLiteral__Group__0__Impl" |
19437 | // InternalSolverLanguage.g:5778:1: rule__InfinityLiteral__Group__0__Impl : ( () ) ; | 17766 | // InternalSolverLanguageParser.g:5722:1: rule__InfinityLiteral__Group__0__Impl : ( () ) ; |
19438 | public final void rule__InfinityLiteral__Group__0__Impl() throws RecognitionException { | 17767 | public final void rule__InfinityLiteral__Group__0__Impl() throws RecognitionException { |
19439 | 17768 | ||
19440 | int stackSize = keepStackSize(); | 17769 | int stackSize = keepStackSize(); |
19441 | 17770 | ||
19442 | try { | 17771 | try { |
19443 | // InternalSolverLanguage.g:5782:1: ( ( () ) ) | 17772 | // InternalSolverLanguageParser.g:5726:1: ( ( () ) ) |
19444 | // InternalSolverLanguage.g:5783:1: ( () ) | 17773 | // InternalSolverLanguageParser.g:5727:1: ( () ) |
19445 | { | 17774 | { |
19446 | // InternalSolverLanguage.g:5783:1: ( () ) | 17775 | // InternalSolverLanguageParser.g:5727:1: ( () ) |
19447 | // InternalSolverLanguage.g:5784:2: () | 17776 | // InternalSolverLanguageParser.g:5728:2: () |
19448 | { | 17777 | { |
19449 | if ( state.backtracking==0 ) { | 17778 | before(grammarAccess.getInfinityLiteralAccess().getInfinityLiteralAction_0()); |
19450 | before(grammarAccess.getInfinityLiteralAccess().getInfinityLiteralAction_0()); | 17779 | // InternalSolverLanguageParser.g:5729:2: () |
19451 | } | 17780 | // InternalSolverLanguageParser.g:5729:3: |
19452 | // InternalSolverLanguage.g:5785:2: () | ||
19453 | // InternalSolverLanguage.g:5785:3: | ||
19454 | { | 17781 | { |
19455 | } | 17782 | } |
19456 | 17783 | ||
19457 | if ( state.backtracking==0 ) { | 17784 | after(grammarAccess.getInfinityLiteralAccess().getInfinityLiteralAction_0()); |
19458 | after(grammarAccess.getInfinityLiteralAccess().getInfinityLiteralAction_0()); | ||
19459 | } | ||
19460 | 17785 | ||
19461 | } | 17786 | } |
19462 | 17787 | ||
@@ -19475,20 +17800,20 @@ public class InternalSolverLanguageParser extends AbstractInternalContentAssistP | |||
19475 | 17800 | ||
19476 | 17801 | ||
19477 | // $ANTLR start "rule__InfinityLiteral__Group__1" | 17802 | // $ANTLR start "rule__InfinityLiteral__Group__1" |
19478 | // InternalSolverLanguage.g:5793:1: rule__InfinityLiteral__Group__1 : rule__InfinityLiteral__Group__1__Impl ; | 17803 | // InternalSolverLanguageParser.g:5737:1: rule__InfinityLiteral__Group__1 : rule__InfinityLiteral__Group__1__Impl ; |
19479 | public final void rule__InfinityLiteral__Group__1() throws RecognitionException { | 17804 | public final void rule__InfinityLiteral__Group__1() throws RecognitionException { |
19480 | 17805 | ||
19481 | int stackSize = keepStackSize(); | 17806 | int stackSize = keepStackSize(); |
19482 | 17807 | ||
19483 | try { | 17808 | try { |
19484 | // InternalSolverLanguage.g:5797:1: ( rule__InfinityLiteral__Group__1__Impl ) | 17809 | // InternalSolverLanguageParser.g:5741:1: ( rule__InfinityLiteral__Group__1__Impl ) |
19485 | // InternalSolverLanguage.g:5798:2: rule__InfinityLiteral__Group__1__Impl | 17810 | // InternalSolverLanguageParser.g:5742:2: rule__InfinityLiteral__Group__1__Impl |
19486 | { | 17811 | { |
19487 | pushFollow(FOLLOW_2); | 17812 | pushFollow(FOLLOW_2); |
19488 | rule__InfinityLiteral__Group__1__Impl(); | 17813 | rule__InfinityLiteral__Group__1__Impl(); |
19489 | 17814 | ||
19490 | state._fsp--; | 17815 | state._fsp--; |
19491 | if (state.failed) return ; | 17816 | |
19492 | 17817 | ||
19493 | } | 17818 | } |
19494 | 17819 | ||
@@ -19508,25 +17833,21 @@ public class InternalSolverLanguageParser extends AbstractInternalContentAssistP | |||
19508 | 17833 | ||
19509 | 17834 | ||
19510 | // $ANTLR start "rule__InfinityLiteral__Group__1__Impl" | 17835 | // $ANTLR start "rule__InfinityLiteral__Group__1__Impl" |
19511 | // InternalSolverLanguage.g:5804:1: rule__InfinityLiteral__Group__1__Impl : ( 'inf' ) ; | 17836 | // InternalSolverLanguageParser.g:5748:1: rule__InfinityLiteral__Group__1__Impl : ( Inf ) ; |
19512 | public final void rule__InfinityLiteral__Group__1__Impl() throws RecognitionException { | 17837 | public final void rule__InfinityLiteral__Group__1__Impl() throws RecognitionException { |
19513 | 17838 | ||
19514 | int stackSize = keepStackSize(); | 17839 | int stackSize = keepStackSize(); |
19515 | 17840 | ||
19516 | try { | 17841 | try { |
19517 | // InternalSolverLanguage.g:5808:1: ( ( 'inf' ) ) | 17842 | // InternalSolverLanguageParser.g:5752:1: ( ( Inf ) ) |
19518 | // InternalSolverLanguage.g:5809:1: ( 'inf' ) | 17843 | // InternalSolverLanguageParser.g:5753:1: ( Inf ) |
19519 | { | 17844 | { |
19520 | // InternalSolverLanguage.g:5809:1: ( 'inf' ) | 17845 | // InternalSolverLanguageParser.g:5753:1: ( Inf ) |
19521 | // InternalSolverLanguage.g:5810:2: 'inf' | 17846 | // InternalSolverLanguageParser.g:5754:2: Inf |
19522 | { | 17847 | { |
19523 | if ( state.backtracking==0 ) { | 17848 | before(grammarAccess.getInfinityLiteralAccess().getInfKeyword_1()); |
19524 | before(grammarAccess.getInfinityLiteralAccess().getInfKeyword_1()); | 17849 | match(input,Inf,FOLLOW_2); |
19525 | } | 17850 | after(grammarAccess.getInfinityLiteralAccess().getInfKeyword_1()); |
19526 | match(input,66,FOLLOW_2); if (state.failed) return ; | ||
19527 | if ( state.backtracking==0 ) { | ||
19528 | after(grammarAccess.getInfinityLiteralAccess().getInfKeyword_1()); | ||
19529 | } | ||
19530 | 17851 | ||
19531 | } | 17852 | } |
19532 | 17853 | ||
@@ -19549,25 +17870,25 @@ public class InternalSolverLanguageParser extends AbstractInternalContentAssistP | |||
19549 | 17870 | ||
19550 | 17871 | ||
19551 | // $ANTLR start "rule__EmptyIntervalLiteral__Group__0" | 17872 | // $ANTLR start "rule__EmptyIntervalLiteral__Group__0" |
19552 | // InternalSolverLanguage.g:5820:1: rule__EmptyIntervalLiteral__Group__0 : rule__EmptyIntervalLiteral__Group__0__Impl rule__EmptyIntervalLiteral__Group__1 ; | 17873 | // InternalSolverLanguageParser.g:5764:1: rule__EmptyIntervalLiteral__Group__0 : rule__EmptyIntervalLiteral__Group__0__Impl rule__EmptyIntervalLiteral__Group__1 ; |
19553 | public final void rule__EmptyIntervalLiteral__Group__0() throws RecognitionException { | 17874 | public final void rule__EmptyIntervalLiteral__Group__0() throws RecognitionException { |
19554 | 17875 | ||
19555 | int stackSize = keepStackSize(); | 17876 | int stackSize = keepStackSize(); |
19556 | 17877 | ||
19557 | try { | 17878 | try { |
19558 | // InternalSolverLanguage.g:5824:1: ( rule__EmptyIntervalLiteral__Group__0__Impl rule__EmptyIntervalLiteral__Group__1 ) | 17879 | // InternalSolverLanguageParser.g:5768:1: ( rule__EmptyIntervalLiteral__Group__0__Impl rule__EmptyIntervalLiteral__Group__1 ) |
19559 | // InternalSolverLanguage.g:5825:2: rule__EmptyIntervalLiteral__Group__0__Impl rule__EmptyIntervalLiteral__Group__1 | 17880 | // InternalSolverLanguageParser.g:5769:2: rule__EmptyIntervalLiteral__Group__0__Impl rule__EmptyIntervalLiteral__Group__1 |
19560 | { | 17881 | { |
19561 | pushFollow(FOLLOW_42); | 17882 | pushFollow(FOLLOW_41); |
19562 | rule__EmptyIntervalLiteral__Group__0__Impl(); | 17883 | rule__EmptyIntervalLiteral__Group__0__Impl(); |
19563 | 17884 | ||
19564 | state._fsp--; | 17885 | state._fsp--; |
19565 | if (state.failed) return ; | 17886 | |
19566 | pushFollow(FOLLOW_2); | 17887 | pushFollow(FOLLOW_2); |
19567 | rule__EmptyIntervalLiteral__Group__1(); | 17888 | rule__EmptyIntervalLiteral__Group__1(); |
19568 | 17889 | ||
19569 | state._fsp--; | 17890 | state._fsp--; |
19570 | if (state.failed) return ; | 17891 | |
19571 | 17892 | ||
19572 | } | 17893 | } |
19573 | 17894 | ||
@@ -19587,29 +17908,25 @@ public class InternalSolverLanguageParser extends AbstractInternalContentAssistP | |||
19587 | 17908 | ||
19588 | 17909 | ||
19589 | // $ANTLR start "rule__EmptyIntervalLiteral__Group__0__Impl" | 17910 | // $ANTLR start "rule__EmptyIntervalLiteral__Group__0__Impl" |
19590 | // InternalSolverLanguage.g:5832:1: rule__EmptyIntervalLiteral__Group__0__Impl : ( () ) ; | 17911 | // InternalSolverLanguageParser.g:5776:1: rule__EmptyIntervalLiteral__Group__0__Impl : ( () ) ; |
19591 | public final void rule__EmptyIntervalLiteral__Group__0__Impl() throws RecognitionException { | 17912 | public final void rule__EmptyIntervalLiteral__Group__0__Impl() throws RecognitionException { |
19592 | 17913 | ||
19593 | int stackSize = keepStackSize(); | 17914 | int stackSize = keepStackSize(); |
19594 | 17915 | ||
19595 | try { | 17916 | try { |
19596 | // InternalSolverLanguage.g:5836:1: ( ( () ) ) | 17917 | // InternalSolverLanguageParser.g:5780:1: ( ( () ) ) |
19597 | // InternalSolverLanguage.g:5837:1: ( () ) | 17918 | // InternalSolverLanguageParser.g:5781:1: ( () ) |
19598 | { | 17919 | { |
19599 | // InternalSolverLanguage.g:5837:1: ( () ) | 17920 | // InternalSolverLanguageParser.g:5781:1: ( () ) |
19600 | // InternalSolverLanguage.g:5838:2: () | 17921 | // InternalSolverLanguageParser.g:5782:2: () |
19601 | { | 17922 | { |
19602 | if ( state.backtracking==0 ) { | 17923 | before(grammarAccess.getEmptyIntervalLiteralAccess().getEmptyIntervalLiteralAction_0()); |
19603 | before(grammarAccess.getEmptyIntervalLiteralAccess().getEmptyIntervalLiteralAction_0()); | 17924 | // InternalSolverLanguageParser.g:5783:2: () |
19604 | } | 17925 | // InternalSolverLanguageParser.g:5783:3: |
19605 | // InternalSolverLanguage.g:5839:2: () | ||
19606 | // InternalSolverLanguage.g:5839:3: | ||
19607 | { | 17926 | { |
19608 | } | 17927 | } |
19609 | 17928 | ||
19610 | if ( state.backtracking==0 ) { | 17929 | after(grammarAccess.getEmptyIntervalLiteralAccess().getEmptyIntervalLiteralAction_0()); |
19611 | after(grammarAccess.getEmptyIntervalLiteralAccess().getEmptyIntervalLiteralAction_0()); | ||
19612 | } | ||
19613 | 17930 | ||
19614 | } | 17931 | } |
19615 | 17932 | ||
@@ -19628,20 +17945,20 @@ public class InternalSolverLanguageParser extends AbstractInternalContentAssistP | |||
19628 | 17945 | ||
19629 | 17946 | ||
19630 | // $ANTLR start "rule__EmptyIntervalLiteral__Group__1" | 17947 | // $ANTLR start "rule__EmptyIntervalLiteral__Group__1" |
19631 | // InternalSolverLanguage.g:5847:1: rule__EmptyIntervalLiteral__Group__1 : rule__EmptyIntervalLiteral__Group__1__Impl ; | 17948 | // InternalSolverLanguageParser.g:5791:1: rule__EmptyIntervalLiteral__Group__1 : rule__EmptyIntervalLiteral__Group__1__Impl ; |
19632 | public final void rule__EmptyIntervalLiteral__Group__1() throws RecognitionException { | 17949 | public final void rule__EmptyIntervalLiteral__Group__1() throws RecognitionException { |
19633 | 17950 | ||
19634 | int stackSize = keepStackSize(); | 17951 | int stackSize = keepStackSize(); |
19635 | 17952 | ||
19636 | try { | 17953 | try { |
19637 | // InternalSolverLanguage.g:5851:1: ( rule__EmptyIntervalLiteral__Group__1__Impl ) | 17954 | // InternalSolverLanguageParser.g:5795:1: ( rule__EmptyIntervalLiteral__Group__1__Impl ) |
19638 | // InternalSolverLanguage.g:5852:2: rule__EmptyIntervalLiteral__Group__1__Impl | 17955 | // InternalSolverLanguageParser.g:5796:2: rule__EmptyIntervalLiteral__Group__1__Impl |
19639 | { | 17956 | { |
19640 | pushFollow(FOLLOW_2); | 17957 | pushFollow(FOLLOW_2); |
19641 | rule__EmptyIntervalLiteral__Group__1__Impl(); | 17958 | rule__EmptyIntervalLiteral__Group__1__Impl(); |
19642 | 17959 | ||
19643 | state._fsp--; | 17960 | state._fsp--; |
19644 | if (state.failed) return ; | 17961 | |
19645 | 17962 | ||
19646 | } | 17963 | } |
19647 | 17964 | ||
@@ -19661,25 +17978,21 @@ public class InternalSolverLanguageParser extends AbstractInternalContentAssistP | |||
19661 | 17978 | ||
19662 | 17979 | ||
19663 | // $ANTLR start "rule__EmptyIntervalLiteral__Group__1__Impl" | 17980 | // $ANTLR start "rule__EmptyIntervalLiteral__Group__1__Impl" |
19664 | // InternalSolverLanguage.g:5858:1: rule__EmptyIntervalLiteral__Group__1__Impl : ( 'empty' ) ; | 17981 | // InternalSolverLanguageParser.g:5802:1: rule__EmptyIntervalLiteral__Group__1__Impl : ( Empty ) ; |
19665 | public final void rule__EmptyIntervalLiteral__Group__1__Impl() throws RecognitionException { | 17982 | public final void rule__EmptyIntervalLiteral__Group__1__Impl() throws RecognitionException { |
19666 | 17983 | ||
19667 | int stackSize = keepStackSize(); | 17984 | int stackSize = keepStackSize(); |
19668 | 17985 | ||
19669 | try { | 17986 | try { |
19670 | // InternalSolverLanguage.g:5862:1: ( ( 'empty' ) ) | 17987 | // InternalSolverLanguageParser.g:5806:1: ( ( Empty ) ) |
19671 | // InternalSolverLanguage.g:5863:1: ( 'empty' ) | 17988 | // InternalSolverLanguageParser.g:5807:1: ( Empty ) |
19672 | { | 17989 | { |
19673 | // InternalSolverLanguage.g:5863:1: ( 'empty' ) | 17990 | // InternalSolverLanguageParser.g:5807:1: ( Empty ) |
19674 | // InternalSolverLanguage.g:5864:2: 'empty' | 17991 | // InternalSolverLanguageParser.g:5808:2: Empty |
19675 | { | 17992 | { |
19676 | if ( state.backtracking==0 ) { | 17993 | before(grammarAccess.getEmptyIntervalLiteralAccess().getEmptyKeyword_1()); |
19677 | before(grammarAccess.getEmptyIntervalLiteralAccess().getEmptyKeyword_1()); | 17994 | match(input,Empty,FOLLOW_2); |
19678 | } | 17995 | after(grammarAccess.getEmptyIntervalLiteralAccess().getEmptyKeyword_1()); |
19679 | match(input,67,FOLLOW_2); if (state.failed) return ; | ||
19680 | if ( state.backtracking==0 ) { | ||
19681 | after(grammarAccess.getEmptyIntervalLiteralAccess().getEmptyKeyword_1()); | ||
19682 | } | ||
19683 | 17996 | ||
19684 | } | 17997 | } |
19685 | 17998 | ||
@@ -19702,25 +18015,25 @@ public class InternalSolverLanguageParser extends AbstractInternalContentAssistP | |||
19702 | 18015 | ||
19703 | 18016 | ||
19704 | // $ANTLR start "rule__ClassDefinition__Group__0" | 18017 | // $ANTLR start "rule__ClassDefinition__Group__0" |
19705 | // InternalSolverLanguage.g:5874:1: rule__ClassDefinition__Group__0 : rule__ClassDefinition__Group__0__Impl rule__ClassDefinition__Group__1 ; | 18018 | // InternalSolverLanguageParser.g:5818:1: rule__ClassDefinition__Group__0 : rule__ClassDefinition__Group__0__Impl rule__ClassDefinition__Group__1 ; |
19706 | public final void rule__ClassDefinition__Group__0() throws RecognitionException { | 18019 | public final void rule__ClassDefinition__Group__0() throws RecognitionException { |
19707 | 18020 | ||
19708 | int stackSize = keepStackSize(); | 18021 | int stackSize = keepStackSize(); |
19709 | 18022 | ||
19710 | try { | 18023 | try { |
19711 | // InternalSolverLanguage.g:5878:1: ( rule__ClassDefinition__Group__0__Impl rule__ClassDefinition__Group__1 ) | 18024 | // InternalSolverLanguageParser.g:5822:1: ( rule__ClassDefinition__Group__0__Impl rule__ClassDefinition__Group__1 ) |
19712 | // InternalSolverLanguage.g:5879:2: rule__ClassDefinition__Group__0__Impl rule__ClassDefinition__Group__1 | 18025 | // InternalSolverLanguageParser.g:5823:2: rule__ClassDefinition__Group__0__Impl rule__ClassDefinition__Group__1 |
19713 | { | 18026 | { |
19714 | pushFollow(FOLLOW_43); | 18027 | pushFollow(FOLLOW_42); |
19715 | rule__ClassDefinition__Group__0__Impl(); | 18028 | rule__ClassDefinition__Group__0__Impl(); |
19716 | 18029 | ||
19717 | state._fsp--; | 18030 | state._fsp--; |
19718 | if (state.failed) return ; | 18031 | |
19719 | pushFollow(FOLLOW_2); | 18032 | pushFollow(FOLLOW_2); |
19720 | rule__ClassDefinition__Group__1(); | 18033 | rule__ClassDefinition__Group__1(); |
19721 | 18034 | ||
19722 | state._fsp--; | 18035 | state._fsp--; |
19723 | if (state.failed) return ; | 18036 | |
19724 | 18037 | ||
19725 | } | 18038 | } |
19726 | 18039 | ||
@@ -19740,46 +18053,42 @@ public class InternalSolverLanguageParser extends AbstractInternalContentAssistP | |||
19740 | 18053 | ||
19741 | 18054 | ||
19742 | // $ANTLR start "rule__ClassDefinition__Group__0__Impl" | 18055 | // $ANTLR start "rule__ClassDefinition__Group__0__Impl" |
19743 | // InternalSolverLanguage.g:5886:1: rule__ClassDefinition__Group__0__Impl : ( ( rule__ClassDefinition__AbstractAssignment_0 )? ) ; | 18056 | // InternalSolverLanguageParser.g:5830:1: rule__ClassDefinition__Group__0__Impl : ( ( rule__ClassDefinition__AbstractAssignment_0 )? ) ; |
19744 | public final void rule__ClassDefinition__Group__0__Impl() throws RecognitionException { | 18057 | public final void rule__ClassDefinition__Group__0__Impl() throws RecognitionException { |
19745 | 18058 | ||
19746 | int stackSize = keepStackSize(); | 18059 | int stackSize = keepStackSize(); |
19747 | 18060 | ||
19748 | try { | 18061 | try { |
19749 | // InternalSolverLanguage.g:5890:1: ( ( ( rule__ClassDefinition__AbstractAssignment_0 )? ) ) | 18062 | // InternalSolverLanguageParser.g:5834:1: ( ( ( rule__ClassDefinition__AbstractAssignment_0 )? ) ) |
19750 | // InternalSolverLanguage.g:5891:1: ( ( rule__ClassDefinition__AbstractAssignment_0 )? ) | 18063 | // InternalSolverLanguageParser.g:5835:1: ( ( rule__ClassDefinition__AbstractAssignment_0 )? ) |
19751 | { | 18064 | { |
19752 | // InternalSolverLanguage.g:5891:1: ( ( rule__ClassDefinition__AbstractAssignment_0 )? ) | 18065 | // InternalSolverLanguageParser.g:5835:1: ( ( rule__ClassDefinition__AbstractAssignment_0 )? ) |
19753 | // InternalSolverLanguage.g:5892:2: ( rule__ClassDefinition__AbstractAssignment_0 )? | 18066 | // InternalSolverLanguageParser.g:5836:2: ( rule__ClassDefinition__AbstractAssignment_0 )? |
19754 | { | 18067 | { |
19755 | if ( state.backtracking==0 ) { | 18068 | before(grammarAccess.getClassDefinitionAccess().getAbstractAssignment_0()); |
19756 | before(grammarAccess.getClassDefinitionAccess().getAbstractAssignment_0()); | 18069 | // InternalSolverLanguageParser.g:5837:2: ( rule__ClassDefinition__AbstractAssignment_0 )? |
19757 | } | 18070 | int alt42=2; |
19758 | // InternalSolverLanguage.g:5893:2: ( rule__ClassDefinition__AbstractAssignment_0 )? | 18071 | int LA42_0 = input.LA(1); |
19759 | int alt43=2; | ||
19760 | int LA43_0 = input.LA(1); | ||
19761 | 18072 | ||
19762 | if ( (LA43_0==73) ) { | 18073 | if ( (LA42_0==Abstract) ) { |
19763 | alt43=1; | 18074 | alt42=1; |
19764 | } | 18075 | } |
19765 | switch (alt43) { | 18076 | switch (alt42) { |
19766 | case 1 : | 18077 | case 1 : |
19767 | // InternalSolverLanguage.g:5893:3: rule__ClassDefinition__AbstractAssignment_0 | 18078 | // InternalSolverLanguageParser.g:5837:3: rule__ClassDefinition__AbstractAssignment_0 |
19768 | { | 18079 | { |
19769 | pushFollow(FOLLOW_2); | 18080 | pushFollow(FOLLOW_2); |
19770 | rule__ClassDefinition__AbstractAssignment_0(); | 18081 | rule__ClassDefinition__AbstractAssignment_0(); |
19771 | 18082 | ||
19772 | state._fsp--; | 18083 | state._fsp--; |
19773 | if (state.failed) return ; | 18084 | |
19774 | 18085 | ||
19775 | } | 18086 | } |
19776 | break; | 18087 | break; |
19777 | 18088 | ||
19778 | } | 18089 | } |
19779 | 18090 | ||
19780 | if ( state.backtracking==0 ) { | 18091 | after(grammarAccess.getClassDefinitionAccess().getAbstractAssignment_0()); |
19781 | after(grammarAccess.getClassDefinitionAccess().getAbstractAssignment_0()); | ||
19782 | } | ||
19783 | 18092 | ||
19784 | } | 18093 | } |
19785 | 18094 | ||
@@ -19802,25 +18111,25 @@ public class InternalSolverLanguageParser extends AbstractInternalContentAssistP | |||
19802 | 18111 | ||
19803 | 18112 | ||
19804 | // $ANTLR start "rule__ClassDefinition__Group__1" | 18113 | // $ANTLR start "rule__ClassDefinition__Group__1" |
19805 | // InternalSolverLanguage.g:5901:1: rule__ClassDefinition__Group__1 : rule__ClassDefinition__Group__1__Impl rule__ClassDefinition__Group__2 ; | 18114 | // InternalSolverLanguageParser.g:5845:1: rule__ClassDefinition__Group__1 : rule__ClassDefinition__Group__1__Impl rule__ClassDefinition__Group__2 ; |
19806 | public final void rule__ClassDefinition__Group__1() throws RecognitionException { | 18115 | public final void rule__ClassDefinition__Group__1() throws RecognitionException { |
19807 | 18116 | ||
19808 | int stackSize = keepStackSize(); | 18117 | int stackSize = keepStackSize(); |
19809 | 18118 | ||
19810 | try { | 18119 | try { |
19811 | // InternalSolverLanguage.g:5905:1: ( rule__ClassDefinition__Group__1__Impl rule__ClassDefinition__Group__2 ) | 18120 | // InternalSolverLanguageParser.g:5849:1: ( rule__ClassDefinition__Group__1__Impl rule__ClassDefinition__Group__2 ) |
19812 | // InternalSolverLanguage.g:5906:2: rule__ClassDefinition__Group__1__Impl rule__ClassDefinition__Group__2 | 18121 | // InternalSolverLanguageParser.g:5850:2: rule__ClassDefinition__Group__1__Impl rule__ClassDefinition__Group__2 |
19813 | { | 18122 | { |
19814 | pushFollow(FOLLOW_44); | 18123 | pushFollow(FOLLOW_43); |
19815 | rule__ClassDefinition__Group__1__Impl(); | 18124 | rule__ClassDefinition__Group__1__Impl(); |
19816 | 18125 | ||
19817 | state._fsp--; | 18126 | state._fsp--; |
19818 | if (state.failed) return ; | 18127 | |
19819 | pushFollow(FOLLOW_2); | 18128 | pushFollow(FOLLOW_2); |
19820 | rule__ClassDefinition__Group__2(); | 18129 | rule__ClassDefinition__Group__2(); |
19821 | 18130 | ||
19822 | state._fsp--; | 18131 | state._fsp--; |
19823 | if (state.failed) return ; | 18132 | |
19824 | 18133 | ||
19825 | } | 18134 | } |
19826 | 18135 | ||
@@ -19840,25 +18149,21 @@ public class InternalSolverLanguageParser extends AbstractInternalContentAssistP | |||
19840 | 18149 | ||
19841 | 18150 | ||
19842 | // $ANTLR start "rule__ClassDefinition__Group__1__Impl" | 18151 | // $ANTLR start "rule__ClassDefinition__Group__1__Impl" |
19843 | // InternalSolverLanguage.g:5913:1: rule__ClassDefinition__Group__1__Impl : ( 'class' ) ; | 18152 | // InternalSolverLanguageParser.g:5857:1: rule__ClassDefinition__Group__1__Impl : ( Class ) ; |
19844 | public final void rule__ClassDefinition__Group__1__Impl() throws RecognitionException { | 18153 | public final void rule__ClassDefinition__Group__1__Impl() throws RecognitionException { |
19845 | 18154 | ||
19846 | int stackSize = keepStackSize(); | 18155 | int stackSize = keepStackSize(); |
19847 | 18156 | ||
19848 | try { | 18157 | try { |
19849 | // InternalSolverLanguage.g:5917:1: ( ( 'class' ) ) | 18158 | // InternalSolverLanguageParser.g:5861:1: ( ( Class ) ) |
19850 | // InternalSolverLanguage.g:5918:1: ( 'class' ) | 18159 | // InternalSolverLanguageParser.g:5862:1: ( Class ) |
19851 | { | 18160 | { |
19852 | // InternalSolverLanguage.g:5918:1: ( 'class' ) | 18161 | // InternalSolverLanguageParser.g:5862:1: ( Class ) |
19853 | // InternalSolverLanguage.g:5919:2: 'class' | 18162 | // InternalSolverLanguageParser.g:5863:2: Class |
19854 | { | 18163 | { |
19855 | if ( state.backtracking==0 ) { | 18164 | before(grammarAccess.getClassDefinitionAccess().getClassKeyword_1()); |
19856 | before(grammarAccess.getClassDefinitionAccess().getClassKeyword_1()); | 18165 | match(input,Class,FOLLOW_2); |
19857 | } | 18166 | after(grammarAccess.getClassDefinitionAccess().getClassKeyword_1()); |
19858 | match(input,68,FOLLOW_2); if (state.failed) return ; | ||
19859 | if ( state.backtracking==0 ) { | ||
19860 | after(grammarAccess.getClassDefinitionAccess().getClassKeyword_1()); | ||
19861 | } | ||
19862 | 18167 | ||
19863 | } | 18168 | } |
19864 | 18169 | ||
@@ -19881,25 +18186,25 @@ public class InternalSolverLanguageParser extends AbstractInternalContentAssistP | |||
19881 | 18186 | ||
19882 | 18187 | ||
19883 | // $ANTLR start "rule__ClassDefinition__Group__2" | 18188 | // $ANTLR start "rule__ClassDefinition__Group__2" |
19884 | // InternalSolverLanguage.g:5928:1: rule__ClassDefinition__Group__2 : rule__ClassDefinition__Group__2__Impl rule__ClassDefinition__Group__3 ; | 18189 | // InternalSolverLanguageParser.g:5872:1: rule__ClassDefinition__Group__2 : rule__ClassDefinition__Group__2__Impl rule__ClassDefinition__Group__3 ; |
19885 | public final void rule__ClassDefinition__Group__2() throws RecognitionException { | 18190 | public final void rule__ClassDefinition__Group__2() throws RecognitionException { |
19886 | 18191 | ||
19887 | int stackSize = keepStackSize(); | 18192 | int stackSize = keepStackSize(); |
19888 | 18193 | ||
19889 | try { | 18194 | try { |
19890 | // InternalSolverLanguage.g:5932:1: ( rule__ClassDefinition__Group__2__Impl rule__ClassDefinition__Group__3 ) | 18195 | // InternalSolverLanguageParser.g:5876:1: ( rule__ClassDefinition__Group__2__Impl rule__ClassDefinition__Group__3 ) |
19891 | // InternalSolverLanguage.g:5933:2: rule__ClassDefinition__Group__2__Impl rule__ClassDefinition__Group__3 | 18196 | // InternalSolverLanguageParser.g:5877:2: rule__ClassDefinition__Group__2__Impl rule__ClassDefinition__Group__3 |
19892 | { | 18197 | { |
19893 | pushFollow(FOLLOW_45); | 18198 | pushFollow(FOLLOW_44); |
19894 | rule__ClassDefinition__Group__2__Impl(); | 18199 | rule__ClassDefinition__Group__2__Impl(); |
19895 | 18200 | ||
19896 | state._fsp--; | 18201 | state._fsp--; |
19897 | if (state.failed) return ; | 18202 | |
19898 | pushFollow(FOLLOW_2); | 18203 | pushFollow(FOLLOW_2); |
19899 | rule__ClassDefinition__Group__3(); | 18204 | rule__ClassDefinition__Group__3(); |
19900 | 18205 | ||
19901 | state._fsp--; | 18206 | state._fsp--; |
19902 | if (state.failed) return ; | 18207 | |
19903 | 18208 | ||
19904 | } | 18209 | } |
19905 | 18210 | ||
@@ -19919,36 +18224,32 @@ public class InternalSolverLanguageParser extends AbstractInternalContentAssistP | |||
19919 | 18224 | ||
19920 | 18225 | ||
19921 | // $ANTLR start "rule__ClassDefinition__Group__2__Impl" | 18226 | // $ANTLR start "rule__ClassDefinition__Group__2__Impl" |
19922 | // InternalSolverLanguage.g:5940:1: rule__ClassDefinition__Group__2__Impl : ( ( rule__ClassDefinition__NameAssignment_2 ) ) ; | 18227 | // InternalSolverLanguageParser.g:5884:1: rule__ClassDefinition__Group__2__Impl : ( ( rule__ClassDefinition__NameAssignment_2 ) ) ; |
19923 | public final void rule__ClassDefinition__Group__2__Impl() throws RecognitionException { | 18228 | public final void rule__ClassDefinition__Group__2__Impl() throws RecognitionException { |
19924 | 18229 | ||
19925 | int stackSize = keepStackSize(); | 18230 | int stackSize = keepStackSize(); |
19926 | 18231 | ||
19927 | try { | 18232 | try { |
19928 | // InternalSolverLanguage.g:5944:1: ( ( ( rule__ClassDefinition__NameAssignment_2 ) ) ) | 18233 | // InternalSolverLanguageParser.g:5888:1: ( ( ( rule__ClassDefinition__NameAssignment_2 ) ) ) |
19929 | // InternalSolverLanguage.g:5945:1: ( ( rule__ClassDefinition__NameAssignment_2 ) ) | 18234 | // InternalSolverLanguageParser.g:5889:1: ( ( rule__ClassDefinition__NameAssignment_2 ) ) |
19930 | { | 18235 | { |
19931 | // InternalSolverLanguage.g:5945:1: ( ( rule__ClassDefinition__NameAssignment_2 ) ) | 18236 | // InternalSolverLanguageParser.g:5889:1: ( ( rule__ClassDefinition__NameAssignment_2 ) ) |
19932 | // InternalSolverLanguage.g:5946:2: ( rule__ClassDefinition__NameAssignment_2 ) | 18237 | // InternalSolverLanguageParser.g:5890:2: ( rule__ClassDefinition__NameAssignment_2 ) |
19933 | { | 18238 | { |
19934 | if ( state.backtracking==0 ) { | 18239 | before(grammarAccess.getClassDefinitionAccess().getNameAssignment_2()); |
19935 | before(grammarAccess.getClassDefinitionAccess().getNameAssignment_2()); | 18240 | // InternalSolverLanguageParser.g:5891:2: ( rule__ClassDefinition__NameAssignment_2 ) |
19936 | } | 18241 | // InternalSolverLanguageParser.g:5891:3: rule__ClassDefinition__NameAssignment_2 |
19937 | // InternalSolverLanguage.g:5947:2: ( rule__ClassDefinition__NameAssignment_2 ) | ||
19938 | // InternalSolverLanguage.g:5947:3: rule__ClassDefinition__NameAssignment_2 | ||
19939 | { | 18242 | { |
19940 | pushFollow(FOLLOW_2); | 18243 | pushFollow(FOLLOW_2); |
19941 | rule__ClassDefinition__NameAssignment_2(); | 18244 | rule__ClassDefinition__NameAssignment_2(); |
19942 | 18245 | ||
19943 | state._fsp--; | 18246 | state._fsp--; |
19944 | if (state.failed) return ; | ||
19945 | 18247 | ||
19946 | } | ||
19947 | 18248 | ||
19948 | if ( state.backtracking==0 ) { | ||
19949 | after(grammarAccess.getClassDefinitionAccess().getNameAssignment_2()); | ||
19950 | } | 18249 | } |
19951 | 18250 | ||
18251 | after(grammarAccess.getClassDefinitionAccess().getNameAssignment_2()); | ||
18252 | |||
19952 | } | 18253 | } |
19953 | 18254 | ||
19954 | 18255 | ||
@@ -19970,25 +18271,25 @@ public class InternalSolverLanguageParser extends AbstractInternalContentAssistP | |||
19970 | 18271 | ||
19971 | 18272 | ||
19972 | // $ANTLR start "rule__ClassDefinition__Group__3" | 18273 | // $ANTLR start "rule__ClassDefinition__Group__3" |
19973 | // InternalSolverLanguage.g:5955:1: rule__ClassDefinition__Group__3 : rule__ClassDefinition__Group__3__Impl rule__ClassDefinition__Group__4 ; | 18274 | // InternalSolverLanguageParser.g:5899:1: rule__ClassDefinition__Group__3 : rule__ClassDefinition__Group__3__Impl rule__ClassDefinition__Group__4 ; |
19974 | public final void rule__ClassDefinition__Group__3() throws RecognitionException { | 18275 | public final void rule__ClassDefinition__Group__3() throws RecognitionException { |
19975 | 18276 | ||
19976 | int stackSize = keepStackSize(); | 18277 | int stackSize = keepStackSize(); |
19977 | 18278 | ||
19978 | try { | 18279 | try { |
19979 | // InternalSolverLanguage.g:5959:1: ( rule__ClassDefinition__Group__3__Impl rule__ClassDefinition__Group__4 ) | 18280 | // InternalSolverLanguageParser.g:5903:1: ( rule__ClassDefinition__Group__3__Impl rule__ClassDefinition__Group__4 ) |
19980 | // InternalSolverLanguage.g:5960:2: rule__ClassDefinition__Group__3__Impl rule__ClassDefinition__Group__4 | 18281 | // InternalSolverLanguageParser.g:5904:2: rule__ClassDefinition__Group__3__Impl rule__ClassDefinition__Group__4 |
19981 | { | 18282 | { |
19982 | pushFollow(FOLLOW_45); | 18283 | pushFollow(FOLLOW_44); |
19983 | rule__ClassDefinition__Group__3__Impl(); | 18284 | rule__ClassDefinition__Group__3__Impl(); |
19984 | 18285 | ||
19985 | state._fsp--; | 18286 | state._fsp--; |
19986 | if (state.failed) return ; | 18287 | |
19987 | pushFollow(FOLLOW_2); | 18288 | pushFollow(FOLLOW_2); |
19988 | rule__ClassDefinition__Group__4(); | 18289 | rule__ClassDefinition__Group__4(); |
19989 | 18290 | ||
19990 | state._fsp--; | 18291 | state._fsp--; |
19991 | if (state.failed) return ; | 18292 | |
19992 | 18293 | ||
19993 | } | 18294 | } |
19994 | 18295 | ||
@@ -20008,46 +18309,42 @@ public class InternalSolverLanguageParser extends AbstractInternalContentAssistP | |||
20008 | 18309 | ||
20009 | 18310 | ||
20010 | // $ANTLR start "rule__ClassDefinition__Group__3__Impl" | 18311 | // $ANTLR start "rule__ClassDefinition__Group__3__Impl" |
20011 | // InternalSolverLanguage.g:5967:1: rule__ClassDefinition__Group__3__Impl : ( ( rule__ClassDefinition__Group_3__0 )? ) ; | 18312 | // InternalSolverLanguageParser.g:5911:1: rule__ClassDefinition__Group__3__Impl : ( ( rule__ClassDefinition__Group_3__0 )? ) ; |
20012 | public final void rule__ClassDefinition__Group__3__Impl() throws RecognitionException { | 18313 | public final void rule__ClassDefinition__Group__3__Impl() throws RecognitionException { |
20013 | 18314 | ||
20014 | int stackSize = keepStackSize(); | 18315 | int stackSize = keepStackSize(); |
20015 | 18316 | ||
20016 | try { | 18317 | try { |
20017 | // InternalSolverLanguage.g:5971:1: ( ( ( rule__ClassDefinition__Group_3__0 )? ) ) | 18318 | // InternalSolverLanguageParser.g:5915:1: ( ( ( rule__ClassDefinition__Group_3__0 )? ) ) |
20018 | // InternalSolverLanguage.g:5972:1: ( ( rule__ClassDefinition__Group_3__0 )? ) | 18319 | // InternalSolverLanguageParser.g:5916:1: ( ( rule__ClassDefinition__Group_3__0 )? ) |
20019 | { | 18320 | { |
20020 | // InternalSolverLanguage.g:5972:1: ( ( rule__ClassDefinition__Group_3__0 )? ) | 18321 | // InternalSolverLanguageParser.g:5916:1: ( ( rule__ClassDefinition__Group_3__0 )? ) |
20021 | // InternalSolverLanguage.g:5973:2: ( rule__ClassDefinition__Group_3__0 )? | 18322 | // InternalSolverLanguageParser.g:5917:2: ( rule__ClassDefinition__Group_3__0 )? |
20022 | { | 18323 | { |
20023 | if ( state.backtracking==0 ) { | 18324 | before(grammarAccess.getClassDefinitionAccess().getGroup_3()); |
20024 | before(grammarAccess.getClassDefinitionAccess().getGroup_3()); | 18325 | // InternalSolverLanguageParser.g:5918:2: ( rule__ClassDefinition__Group_3__0 )? |
20025 | } | 18326 | int alt43=2; |
20026 | // InternalSolverLanguage.g:5974:2: ( rule__ClassDefinition__Group_3__0 )? | 18327 | int LA43_0 = input.LA(1); |
20027 | int alt44=2; | ||
20028 | int LA44_0 = input.LA(1); | ||
20029 | 18328 | ||
20030 | if ( (LA44_0==69) ) { | 18329 | if ( (LA43_0==Extends) ) { |
20031 | alt44=1; | 18330 | alt43=1; |
20032 | } | 18331 | } |
20033 | switch (alt44) { | 18332 | switch (alt43) { |
20034 | case 1 : | 18333 | case 1 : |
20035 | // InternalSolverLanguage.g:5974:3: rule__ClassDefinition__Group_3__0 | 18334 | // InternalSolverLanguageParser.g:5918:3: rule__ClassDefinition__Group_3__0 |
20036 | { | 18335 | { |
20037 | pushFollow(FOLLOW_2); | 18336 | pushFollow(FOLLOW_2); |
20038 | rule__ClassDefinition__Group_3__0(); | 18337 | rule__ClassDefinition__Group_3__0(); |
20039 | 18338 | ||
20040 | state._fsp--; | 18339 | state._fsp--; |
20041 | if (state.failed) return ; | 18340 | |
20042 | 18341 | ||
20043 | } | 18342 | } |
20044 | break; | 18343 | break; |
20045 | 18344 | ||
20046 | } | 18345 | } |
20047 | 18346 | ||
20048 | if ( state.backtracking==0 ) { | 18347 | after(grammarAccess.getClassDefinitionAccess().getGroup_3()); |
20049 | after(grammarAccess.getClassDefinitionAccess().getGroup_3()); | ||
20050 | } | ||
20051 | 18348 | ||
20052 | } | 18349 | } |
20053 | 18350 | ||
@@ -20070,25 +18367,25 @@ public class InternalSolverLanguageParser extends AbstractInternalContentAssistP | |||
20070 | 18367 | ||
20071 | 18368 | ||
20072 | // $ANTLR start "rule__ClassDefinition__Group__4" | 18369 | // $ANTLR start "rule__ClassDefinition__Group__4" |
20073 | // InternalSolverLanguage.g:5982:1: rule__ClassDefinition__Group__4 : rule__ClassDefinition__Group__4__Impl rule__ClassDefinition__Group__5 ; | 18370 | // InternalSolverLanguageParser.g:5926:1: rule__ClassDefinition__Group__4 : rule__ClassDefinition__Group__4__Impl rule__ClassDefinition__Group__5 ; |
20074 | public final void rule__ClassDefinition__Group__4() throws RecognitionException { | 18371 | public final void rule__ClassDefinition__Group__4() throws RecognitionException { |
20075 | 18372 | ||
20076 | int stackSize = keepStackSize(); | 18373 | int stackSize = keepStackSize(); |
20077 | 18374 | ||
20078 | try { | 18375 | try { |
20079 | // InternalSolverLanguage.g:5986:1: ( rule__ClassDefinition__Group__4__Impl rule__ClassDefinition__Group__5 ) | 18376 | // InternalSolverLanguageParser.g:5930:1: ( rule__ClassDefinition__Group__4__Impl rule__ClassDefinition__Group__5 ) |
20080 | // InternalSolverLanguage.g:5987:2: rule__ClassDefinition__Group__4__Impl rule__ClassDefinition__Group__5 | 18377 | // InternalSolverLanguageParser.g:5931:2: rule__ClassDefinition__Group__4__Impl rule__ClassDefinition__Group__5 |
20081 | { | 18378 | { |
20082 | pushFollow(FOLLOW_46); | 18379 | pushFollow(FOLLOW_45); |
20083 | rule__ClassDefinition__Group__4__Impl(); | 18380 | rule__ClassDefinition__Group__4__Impl(); |
20084 | 18381 | ||
20085 | state._fsp--; | 18382 | state._fsp--; |
20086 | if (state.failed) return ; | 18383 | |
20087 | pushFollow(FOLLOW_2); | 18384 | pushFollow(FOLLOW_2); |
20088 | rule__ClassDefinition__Group__5(); | 18385 | rule__ClassDefinition__Group__5(); |
20089 | 18386 | ||
20090 | state._fsp--; | 18387 | state._fsp--; |
20091 | if (state.failed) return ; | 18388 | |
20092 | 18389 | ||
20093 | } | 18390 | } |
20094 | 18391 | ||
@@ -20108,25 +18405,21 @@ public class InternalSolverLanguageParser extends AbstractInternalContentAssistP | |||
20108 | 18405 | ||
20109 | 18406 | ||
20110 | // $ANTLR start "rule__ClassDefinition__Group__4__Impl" | 18407 | // $ANTLR start "rule__ClassDefinition__Group__4__Impl" |
20111 | // InternalSolverLanguage.g:5994:1: rule__ClassDefinition__Group__4__Impl : ( '{' ) ; | 18408 | // InternalSolverLanguageParser.g:5938:1: rule__ClassDefinition__Group__4__Impl : ( LeftCurlyBracket ) ; |
20112 | public final void rule__ClassDefinition__Group__4__Impl() throws RecognitionException { | 18409 | public final void rule__ClassDefinition__Group__4__Impl() throws RecognitionException { |
20113 | 18410 | ||
20114 | int stackSize = keepStackSize(); | 18411 | int stackSize = keepStackSize(); |
20115 | 18412 | ||
20116 | try { | 18413 | try { |
20117 | // InternalSolverLanguage.g:5998:1: ( ( '{' ) ) | 18414 | // InternalSolverLanguageParser.g:5942:1: ( ( LeftCurlyBracket ) ) |
20118 | // InternalSolverLanguage.g:5999:1: ( '{' ) | 18415 | // InternalSolverLanguageParser.g:5943:1: ( LeftCurlyBracket ) |
20119 | { | 18416 | { |
20120 | // InternalSolverLanguage.g:5999:1: ( '{' ) | 18417 | // InternalSolverLanguageParser.g:5943:1: ( LeftCurlyBracket ) |
20121 | // InternalSolverLanguage.g:6000:2: '{' | 18418 | // InternalSolverLanguageParser.g:5944:2: LeftCurlyBracket |
20122 | { | 18419 | { |
20123 | if ( state.backtracking==0 ) { | 18420 | before(grammarAccess.getClassDefinitionAccess().getLeftCurlyBracketKeyword_4()); |
20124 | before(grammarAccess.getClassDefinitionAccess().getLeftCurlyBracketKeyword_4()); | 18421 | match(input,LeftCurlyBracket,FOLLOW_2); |
20125 | } | 18422 | after(grammarAccess.getClassDefinitionAccess().getLeftCurlyBracketKeyword_4()); |
20126 | match(input,58,FOLLOW_2); if (state.failed) return ; | ||
20127 | if ( state.backtracking==0 ) { | ||
20128 | after(grammarAccess.getClassDefinitionAccess().getLeftCurlyBracketKeyword_4()); | ||
20129 | } | ||
20130 | 18423 | ||
20131 | } | 18424 | } |
20132 | 18425 | ||
@@ -20149,25 +18442,25 @@ public class InternalSolverLanguageParser extends AbstractInternalContentAssistP | |||
20149 | 18442 | ||
20150 | 18443 | ||
20151 | // $ANTLR start "rule__ClassDefinition__Group__5" | 18444 | // $ANTLR start "rule__ClassDefinition__Group__5" |
20152 | // InternalSolverLanguage.g:6009:1: rule__ClassDefinition__Group__5 : rule__ClassDefinition__Group__5__Impl rule__ClassDefinition__Group__6 ; | 18445 | // InternalSolverLanguageParser.g:5953:1: rule__ClassDefinition__Group__5 : rule__ClassDefinition__Group__5__Impl rule__ClassDefinition__Group__6 ; |
20153 | public final void rule__ClassDefinition__Group__5() throws RecognitionException { | 18446 | public final void rule__ClassDefinition__Group__5() throws RecognitionException { |
20154 | 18447 | ||
20155 | int stackSize = keepStackSize(); | 18448 | int stackSize = keepStackSize(); |
20156 | 18449 | ||
20157 | try { | 18450 | try { |
20158 | // InternalSolverLanguage.g:6013:1: ( rule__ClassDefinition__Group__5__Impl rule__ClassDefinition__Group__6 ) | 18451 | // InternalSolverLanguageParser.g:5957:1: ( rule__ClassDefinition__Group__5__Impl rule__ClassDefinition__Group__6 ) |
20159 | // InternalSolverLanguage.g:6014:2: rule__ClassDefinition__Group__5__Impl rule__ClassDefinition__Group__6 | 18452 | // InternalSolverLanguageParser.g:5958:2: rule__ClassDefinition__Group__5__Impl rule__ClassDefinition__Group__6 |
20160 | { | 18453 | { |
20161 | pushFollow(FOLLOW_46); | 18454 | pushFollow(FOLLOW_45); |
20162 | rule__ClassDefinition__Group__5__Impl(); | 18455 | rule__ClassDefinition__Group__5__Impl(); |
20163 | 18456 | ||
20164 | state._fsp--; | 18457 | state._fsp--; |
20165 | if (state.failed) return ; | 18458 | |
20166 | pushFollow(FOLLOW_2); | 18459 | pushFollow(FOLLOW_2); |
20167 | rule__ClassDefinition__Group__6(); | 18460 | rule__ClassDefinition__Group__6(); |
20168 | 18461 | ||
20169 | state._fsp--; | 18462 | state._fsp--; |
20170 | if (state.failed) return ; | 18463 | |
20171 | 18464 | ||
20172 | } | 18465 | } |
20173 | 18466 | ||
@@ -20187,53 +18480,49 @@ public class InternalSolverLanguageParser extends AbstractInternalContentAssistP | |||
20187 | 18480 | ||
20188 | 18481 | ||
20189 | // $ANTLR start "rule__ClassDefinition__Group__5__Impl" | 18482 | // $ANTLR start "rule__ClassDefinition__Group__5__Impl" |
20190 | // InternalSolverLanguage.g:6021:1: rule__ClassDefinition__Group__5__Impl : ( ( rule__ClassDefinition__MembersAssignment_5 )* ) ; | 18483 | // InternalSolverLanguageParser.g:5965:1: rule__ClassDefinition__Group__5__Impl : ( ( rule__ClassDefinition__MembersAssignment_5 )* ) ; |
20191 | public final void rule__ClassDefinition__Group__5__Impl() throws RecognitionException { | 18484 | public final void rule__ClassDefinition__Group__5__Impl() throws RecognitionException { |
20192 | 18485 | ||
20193 | int stackSize = keepStackSize(); | 18486 | int stackSize = keepStackSize(); |
20194 | 18487 | ||
20195 | try { | 18488 | try { |
20196 | // InternalSolverLanguage.g:6025:1: ( ( ( rule__ClassDefinition__MembersAssignment_5 )* ) ) | 18489 | // InternalSolverLanguageParser.g:5969:1: ( ( ( rule__ClassDefinition__MembersAssignment_5 )* ) ) |
20197 | // InternalSolverLanguage.g:6026:1: ( ( rule__ClassDefinition__MembersAssignment_5 )* ) | 18490 | // InternalSolverLanguageParser.g:5970:1: ( ( rule__ClassDefinition__MembersAssignment_5 )* ) |
20198 | { | 18491 | { |
20199 | // InternalSolverLanguage.g:6026:1: ( ( rule__ClassDefinition__MembersAssignment_5 )* ) | 18492 | // InternalSolverLanguageParser.g:5970:1: ( ( rule__ClassDefinition__MembersAssignment_5 )* ) |
20200 | // InternalSolverLanguage.g:6027:2: ( rule__ClassDefinition__MembersAssignment_5 )* | 18493 | // InternalSolverLanguageParser.g:5971:2: ( rule__ClassDefinition__MembersAssignment_5 )* |
20201 | { | 18494 | { |
20202 | if ( state.backtracking==0 ) { | 18495 | before(grammarAccess.getClassDefinitionAccess().getMembersAssignment_5()); |
20203 | before(grammarAccess.getClassDefinitionAccess().getMembersAssignment_5()); | 18496 | // InternalSolverLanguageParser.g:5972:2: ( rule__ClassDefinition__MembersAssignment_5 )* |
20204 | } | 18497 | loop44: |
20205 | // InternalSolverLanguage.g:6028:2: ( rule__ClassDefinition__MembersAssignment_5 )* | ||
20206 | loop45: | ||
20207 | do { | 18498 | do { |
20208 | int alt45=2; | 18499 | int alt44=2; |
20209 | int LA45_0 = input.LA(1); | 18500 | int LA44_0 = input.LA(1); |
20210 | 18501 | ||
20211 | if ( (LA45_0==RULE_QUOTED_ID||LA45_0==RULE_ID||LA45_0==74) ) { | 18502 | if ( (LA44_0==Contains||LA44_0==RULE_QUOTED_ID||LA44_0==RULE_ID) ) { |
20212 | alt45=1; | 18503 | alt44=1; |
20213 | } | 18504 | } |
20214 | 18505 | ||
20215 | 18506 | ||
20216 | switch (alt45) { | 18507 | switch (alt44) { |
20217 | case 1 : | 18508 | case 1 : |
20218 | // InternalSolverLanguage.g:6028:3: rule__ClassDefinition__MembersAssignment_5 | 18509 | // InternalSolverLanguageParser.g:5972:3: rule__ClassDefinition__MembersAssignment_5 |
20219 | { | 18510 | { |
20220 | pushFollow(FOLLOW_47); | 18511 | pushFollow(FOLLOW_46); |
20221 | rule__ClassDefinition__MembersAssignment_5(); | 18512 | rule__ClassDefinition__MembersAssignment_5(); |
20222 | 18513 | ||
20223 | state._fsp--; | 18514 | state._fsp--; |
20224 | if (state.failed) return ; | 18515 | |
20225 | 18516 | ||
20226 | } | 18517 | } |
20227 | break; | 18518 | break; |
20228 | 18519 | ||
20229 | default : | 18520 | default : |
20230 | break loop45; | 18521 | break loop44; |
20231 | } | 18522 | } |
20232 | } while (true); | 18523 | } while (true); |
20233 | 18524 | ||
20234 | if ( state.backtracking==0 ) { | 18525 | after(grammarAccess.getClassDefinitionAccess().getMembersAssignment_5()); |
20235 | after(grammarAccess.getClassDefinitionAccess().getMembersAssignment_5()); | ||
20236 | } | ||
20237 | 18526 | ||
20238 | } | 18527 | } |
20239 | 18528 | ||
@@ -20256,20 +18545,20 @@ public class InternalSolverLanguageParser extends AbstractInternalContentAssistP | |||
20256 | 18545 | ||
20257 | 18546 | ||
20258 | // $ANTLR start "rule__ClassDefinition__Group__6" | 18547 | // $ANTLR start "rule__ClassDefinition__Group__6" |
20259 | // InternalSolverLanguage.g:6036:1: rule__ClassDefinition__Group__6 : rule__ClassDefinition__Group__6__Impl ; | 18548 | // InternalSolverLanguageParser.g:5980:1: rule__ClassDefinition__Group__6 : rule__ClassDefinition__Group__6__Impl ; |
20260 | public final void rule__ClassDefinition__Group__6() throws RecognitionException { | 18549 | public final void rule__ClassDefinition__Group__6() throws RecognitionException { |
20261 | 18550 | ||
20262 | int stackSize = keepStackSize(); | 18551 | int stackSize = keepStackSize(); |
20263 | 18552 | ||
20264 | try { | 18553 | try { |
20265 | // InternalSolverLanguage.g:6040:1: ( rule__ClassDefinition__Group__6__Impl ) | 18554 | // InternalSolverLanguageParser.g:5984:1: ( rule__ClassDefinition__Group__6__Impl ) |
20266 | // InternalSolverLanguage.g:6041:2: rule__ClassDefinition__Group__6__Impl | 18555 | // InternalSolverLanguageParser.g:5985:2: rule__ClassDefinition__Group__6__Impl |
20267 | { | 18556 | { |
20268 | pushFollow(FOLLOW_2); | 18557 | pushFollow(FOLLOW_2); |
20269 | rule__ClassDefinition__Group__6__Impl(); | 18558 | rule__ClassDefinition__Group__6__Impl(); |
20270 | 18559 | ||
20271 | state._fsp--; | 18560 | state._fsp--; |
20272 | if (state.failed) return ; | 18561 | |
20273 | 18562 | ||
20274 | } | 18563 | } |
20275 | 18564 | ||
@@ -20289,25 +18578,21 @@ public class InternalSolverLanguageParser extends AbstractInternalContentAssistP | |||
20289 | 18578 | ||
20290 | 18579 | ||
20291 | // $ANTLR start "rule__ClassDefinition__Group__6__Impl" | 18580 | // $ANTLR start "rule__ClassDefinition__Group__6__Impl" |
20292 | // InternalSolverLanguage.g:6047:1: rule__ClassDefinition__Group__6__Impl : ( '}' ) ; | 18581 | // InternalSolverLanguageParser.g:5991:1: rule__ClassDefinition__Group__6__Impl : ( RightCurlyBracket ) ; |
20293 | public final void rule__ClassDefinition__Group__6__Impl() throws RecognitionException { | 18582 | public final void rule__ClassDefinition__Group__6__Impl() throws RecognitionException { |
20294 | 18583 | ||
20295 | int stackSize = keepStackSize(); | 18584 | int stackSize = keepStackSize(); |
20296 | 18585 | ||
20297 | try { | 18586 | try { |
20298 | // InternalSolverLanguage.g:6051:1: ( ( '}' ) ) | 18587 | // InternalSolverLanguageParser.g:5995:1: ( ( RightCurlyBracket ) ) |
20299 | // InternalSolverLanguage.g:6052:1: ( '}' ) | 18588 | // InternalSolverLanguageParser.g:5996:1: ( RightCurlyBracket ) |
20300 | { | 18589 | { |
20301 | // InternalSolverLanguage.g:6052:1: ( '}' ) | 18590 | // InternalSolverLanguageParser.g:5996:1: ( RightCurlyBracket ) |
20302 | // InternalSolverLanguage.g:6053:2: '}' | 18591 | // InternalSolverLanguageParser.g:5997:2: RightCurlyBracket |
20303 | { | 18592 | { |
20304 | if ( state.backtracking==0 ) { | 18593 | before(grammarAccess.getClassDefinitionAccess().getRightCurlyBracketKeyword_6()); |
20305 | before(grammarAccess.getClassDefinitionAccess().getRightCurlyBracketKeyword_6()); | 18594 | match(input,RightCurlyBracket,FOLLOW_2); |
20306 | } | 18595 | after(grammarAccess.getClassDefinitionAccess().getRightCurlyBracketKeyword_6()); |
20307 | match(input,59,FOLLOW_2); if (state.failed) return ; | ||
20308 | if ( state.backtracking==0 ) { | ||
20309 | after(grammarAccess.getClassDefinitionAccess().getRightCurlyBracketKeyword_6()); | ||
20310 | } | ||
20311 | 18596 | ||
20312 | } | 18597 | } |
20313 | 18598 | ||
@@ -20330,25 +18615,25 @@ public class InternalSolverLanguageParser extends AbstractInternalContentAssistP | |||
20330 | 18615 | ||
20331 | 18616 | ||
20332 | // $ANTLR start "rule__ClassDefinition__Group_3__0" | 18617 | // $ANTLR start "rule__ClassDefinition__Group_3__0" |
20333 | // InternalSolverLanguage.g:6063:1: rule__ClassDefinition__Group_3__0 : rule__ClassDefinition__Group_3__0__Impl rule__ClassDefinition__Group_3__1 ; | 18618 | // InternalSolverLanguageParser.g:6007:1: rule__ClassDefinition__Group_3__0 : rule__ClassDefinition__Group_3__0__Impl rule__ClassDefinition__Group_3__1 ; |
20334 | public final void rule__ClassDefinition__Group_3__0() throws RecognitionException { | 18619 | public final void rule__ClassDefinition__Group_3__0() throws RecognitionException { |
20335 | 18620 | ||
20336 | int stackSize = keepStackSize(); | 18621 | int stackSize = keepStackSize(); |
20337 | 18622 | ||
20338 | try { | 18623 | try { |
20339 | // InternalSolverLanguage.g:6067:1: ( rule__ClassDefinition__Group_3__0__Impl rule__ClassDefinition__Group_3__1 ) | 18624 | // InternalSolverLanguageParser.g:6011:1: ( rule__ClassDefinition__Group_3__0__Impl rule__ClassDefinition__Group_3__1 ) |
20340 | // InternalSolverLanguage.g:6068:2: rule__ClassDefinition__Group_3__0__Impl rule__ClassDefinition__Group_3__1 | 18625 | // InternalSolverLanguageParser.g:6012:2: rule__ClassDefinition__Group_3__0__Impl rule__ClassDefinition__Group_3__1 |
20341 | { | 18626 | { |
20342 | pushFollow(FOLLOW_9); | 18627 | pushFollow(FOLLOW_9); |
20343 | rule__ClassDefinition__Group_3__0__Impl(); | 18628 | rule__ClassDefinition__Group_3__0__Impl(); |
20344 | 18629 | ||
20345 | state._fsp--; | 18630 | state._fsp--; |
20346 | if (state.failed) return ; | 18631 | |
20347 | pushFollow(FOLLOW_2); | 18632 | pushFollow(FOLLOW_2); |
20348 | rule__ClassDefinition__Group_3__1(); | 18633 | rule__ClassDefinition__Group_3__1(); |
20349 | 18634 | ||
20350 | state._fsp--; | 18635 | state._fsp--; |
20351 | if (state.failed) return ; | 18636 | |
20352 | 18637 | ||
20353 | } | 18638 | } |
20354 | 18639 | ||
@@ -20368,25 +18653,21 @@ public class InternalSolverLanguageParser extends AbstractInternalContentAssistP | |||
20368 | 18653 | ||
20369 | 18654 | ||
20370 | // $ANTLR start "rule__ClassDefinition__Group_3__0__Impl" | 18655 | // $ANTLR start "rule__ClassDefinition__Group_3__0__Impl" |
20371 | // InternalSolverLanguage.g:6075:1: rule__ClassDefinition__Group_3__0__Impl : ( 'extends' ) ; | 18656 | // InternalSolverLanguageParser.g:6019:1: rule__ClassDefinition__Group_3__0__Impl : ( Extends ) ; |
20372 | public final void rule__ClassDefinition__Group_3__0__Impl() throws RecognitionException { | 18657 | public final void rule__ClassDefinition__Group_3__0__Impl() throws RecognitionException { |
20373 | 18658 | ||
20374 | int stackSize = keepStackSize(); | 18659 | int stackSize = keepStackSize(); |
20375 | 18660 | ||
20376 | try { | 18661 | try { |
20377 | // InternalSolverLanguage.g:6079:1: ( ( 'extends' ) ) | 18662 | // InternalSolverLanguageParser.g:6023:1: ( ( Extends ) ) |
20378 | // InternalSolverLanguage.g:6080:1: ( 'extends' ) | 18663 | // InternalSolverLanguageParser.g:6024:1: ( Extends ) |
20379 | { | 18664 | { |
20380 | // InternalSolverLanguage.g:6080:1: ( 'extends' ) | 18665 | // InternalSolverLanguageParser.g:6024:1: ( Extends ) |
20381 | // InternalSolverLanguage.g:6081:2: 'extends' | 18666 | // InternalSolverLanguageParser.g:6025:2: Extends |
20382 | { | 18667 | { |
20383 | if ( state.backtracking==0 ) { | 18668 | before(grammarAccess.getClassDefinitionAccess().getExtendsKeyword_3_0()); |
20384 | before(grammarAccess.getClassDefinitionAccess().getExtendsKeyword_3_0()); | 18669 | match(input,Extends,FOLLOW_2); |
20385 | } | 18670 | after(grammarAccess.getClassDefinitionAccess().getExtendsKeyword_3_0()); |
20386 | match(input,69,FOLLOW_2); if (state.failed) return ; | ||
20387 | if ( state.backtracking==0 ) { | ||
20388 | after(grammarAccess.getClassDefinitionAccess().getExtendsKeyword_3_0()); | ||
20389 | } | ||
20390 | 18671 | ||
20391 | } | 18672 | } |
20392 | 18673 | ||
@@ -20409,25 +18690,25 @@ public class InternalSolverLanguageParser extends AbstractInternalContentAssistP | |||
20409 | 18690 | ||
20410 | 18691 | ||
20411 | // $ANTLR start "rule__ClassDefinition__Group_3__1" | 18692 | // $ANTLR start "rule__ClassDefinition__Group_3__1" |
20412 | // InternalSolverLanguage.g:6090:1: rule__ClassDefinition__Group_3__1 : rule__ClassDefinition__Group_3__1__Impl rule__ClassDefinition__Group_3__2 ; | 18693 | // InternalSolverLanguageParser.g:6034:1: rule__ClassDefinition__Group_3__1 : rule__ClassDefinition__Group_3__1__Impl rule__ClassDefinition__Group_3__2 ; |
20413 | public final void rule__ClassDefinition__Group_3__1() throws RecognitionException { | 18694 | public final void rule__ClassDefinition__Group_3__1() throws RecognitionException { |
20414 | 18695 | ||
20415 | int stackSize = keepStackSize(); | 18696 | int stackSize = keepStackSize(); |
20416 | 18697 | ||
20417 | try { | 18698 | try { |
20418 | // InternalSolverLanguage.g:6094:1: ( rule__ClassDefinition__Group_3__1__Impl rule__ClassDefinition__Group_3__2 ) | 18699 | // InternalSolverLanguageParser.g:6038:1: ( rule__ClassDefinition__Group_3__1__Impl rule__ClassDefinition__Group_3__2 ) |
20419 | // InternalSolverLanguage.g:6095:2: rule__ClassDefinition__Group_3__1__Impl rule__ClassDefinition__Group_3__2 | 18700 | // InternalSolverLanguageParser.g:6039:2: rule__ClassDefinition__Group_3__1__Impl rule__ClassDefinition__Group_3__2 |
20420 | { | 18701 | { |
20421 | pushFollow(FOLLOW_22); | 18702 | pushFollow(FOLLOW_21); |
20422 | rule__ClassDefinition__Group_3__1__Impl(); | 18703 | rule__ClassDefinition__Group_3__1__Impl(); |
20423 | 18704 | ||
20424 | state._fsp--; | 18705 | state._fsp--; |
20425 | if (state.failed) return ; | 18706 | |
20426 | pushFollow(FOLLOW_2); | 18707 | pushFollow(FOLLOW_2); |
20427 | rule__ClassDefinition__Group_3__2(); | 18708 | rule__ClassDefinition__Group_3__2(); |
20428 | 18709 | ||
20429 | state._fsp--; | 18710 | state._fsp--; |
20430 | if (state.failed) return ; | 18711 | |
20431 | 18712 | ||
20432 | } | 18713 | } |
20433 | 18714 | ||
@@ -20447,36 +18728,32 @@ public class InternalSolverLanguageParser extends AbstractInternalContentAssistP | |||
20447 | 18728 | ||
20448 | 18729 | ||
20449 | // $ANTLR start "rule__ClassDefinition__Group_3__1__Impl" | 18730 | // $ANTLR start "rule__ClassDefinition__Group_3__1__Impl" |
20450 | // InternalSolverLanguage.g:6102:1: rule__ClassDefinition__Group_3__1__Impl : ( ( rule__ClassDefinition__SuperclassesAssignment_3_1 ) ) ; | 18731 | // InternalSolverLanguageParser.g:6046:1: rule__ClassDefinition__Group_3__1__Impl : ( ( rule__ClassDefinition__SuperclassesAssignment_3_1 ) ) ; |
20451 | public final void rule__ClassDefinition__Group_3__1__Impl() throws RecognitionException { | 18732 | public final void rule__ClassDefinition__Group_3__1__Impl() throws RecognitionException { |
20452 | 18733 | ||
20453 | int stackSize = keepStackSize(); | 18734 | int stackSize = keepStackSize(); |
20454 | 18735 | ||
20455 | try { | 18736 | try { |
20456 | // InternalSolverLanguage.g:6106:1: ( ( ( rule__ClassDefinition__SuperclassesAssignment_3_1 ) ) ) | 18737 | // InternalSolverLanguageParser.g:6050:1: ( ( ( rule__ClassDefinition__SuperclassesAssignment_3_1 ) ) ) |
20457 | // InternalSolverLanguage.g:6107:1: ( ( rule__ClassDefinition__SuperclassesAssignment_3_1 ) ) | 18738 | // InternalSolverLanguageParser.g:6051:1: ( ( rule__ClassDefinition__SuperclassesAssignment_3_1 ) ) |
20458 | { | 18739 | { |
20459 | // InternalSolverLanguage.g:6107:1: ( ( rule__ClassDefinition__SuperclassesAssignment_3_1 ) ) | 18740 | // InternalSolverLanguageParser.g:6051:1: ( ( rule__ClassDefinition__SuperclassesAssignment_3_1 ) ) |
20460 | // InternalSolverLanguage.g:6108:2: ( rule__ClassDefinition__SuperclassesAssignment_3_1 ) | 18741 | // InternalSolverLanguageParser.g:6052:2: ( rule__ClassDefinition__SuperclassesAssignment_3_1 ) |
20461 | { | 18742 | { |
20462 | if ( state.backtracking==0 ) { | 18743 | before(grammarAccess.getClassDefinitionAccess().getSuperclassesAssignment_3_1()); |
20463 | before(grammarAccess.getClassDefinitionAccess().getSuperclassesAssignment_3_1()); | 18744 | // InternalSolverLanguageParser.g:6053:2: ( rule__ClassDefinition__SuperclassesAssignment_3_1 ) |
20464 | } | 18745 | // InternalSolverLanguageParser.g:6053:3: rule__ClassDefinition__SuperclassesAssignment_3_1 |
20465 | // InternalSolverLanguage.g:6109:2: ( rule__ClassDefinition__SuperclassesAssignment_3_1 ) | ||
20466 | // InternalSolverLanguage.g:6109:3: rule__ClassDefinition__SuperclassesAssignment_3_1 | ||
20467 | { | 18746 | { |
20468 | pushFollow(FOLLOW_2); | 18747 | pushFollow(FOLLOW_2); |
20469 | rule__ClassDefinition__SuperclassesAssignment_3_1(); | 18748 | rule__ClassDefinition__SuperclassesAssignment_3_1(); |
20470 | 18749 | ||
20471 | state._fsp--; | 18750 | state._fsp--; |
20472 | if (state.failed) return ; | ||
20473 | 18751 | ||
20474 | } | ||
20475 | 18752 | ||
20476 | if ( state.backtracking==0 ) { | ||
20477 | after(grammarAccess.getClassDefinitionAccess().getSuperclassesAssignment_3_1()); | ||
20478 | } | 18753 | } |
20479 | 18754 | ||
18755 | after(grammarAccess.getClassDefinitionAccess().getSuperclassesAssignment_3_1()); | ||
18756 | |||
20480 | } | 18757 | } |
20481 | 18758 | ||
20482 | 18759 | ||
@@ -20498,20 +18775,20 @@ public class InternalSolverLanguageParser extends AbstractInternalContentAssistP | |||
20498 | 18775 | ||
20499 | 18776 | ||
20500 | // $ANTLR start "rule__ClassDefinition__Group_3__2" | 18777 | // $ANTLR start "rule__ClassDefinition__Group_3__2" |
20501 | // InternalSolverLanguage.g:6117:1: rule__ClassDefinition__Group_3__2 : rule__ClassDefinition__Group_3__2__Impl ; | 18778 | // InternalSolverLanguageParser.g:6061:1: rule__ClassDefinition__Group_3__2 : rule__ClassDefinition__Group_3__2__Impl ; |
20502 | public final void rule__ClassDefinition__Group_3__2() throws RecognitionException { | 18779 | public final void rule__ClassDefinition__Group_3__2() throws RecognitionException { |
20503 | 18780 | ||
20504 | int stackSize = keepStackSize(); | 18781 | int stackSize = keepStackSize(); |
20505 | 18782 | ||
20506 | try { | 18783 | try { |
20507 | // InternalSolverLanguage.g:6121:1: ( rule__ClassDefinition__Group_3__2__Impl ) | 18784 | // InternalSolverLanguageParser.g:6065:1: ( rule__ClassDefinition__Group_3__2__Impl ) |
20508 | // InternalSolverLanguage.g:6122:2: rule__ClassDefinition__Group_3__2__Impl | 18785 | // InternalSolverLanguageParser.g:6066:2: rule__ClassDefinition__Group_3__2__Impl |
20509 | { | 18786 | { |
20510 | pushFollow(FOLLOW_2); | 18787 | pushFollow(FOLLOW_2); |
20511 | rule__ClassDefinition__Group_3__2__Impl(); | 18788 | rule__ClassDefinition__Group_3__2__Impl(); |
20512 | 18789 | ||
20513 | state._fsp--; | 18790 | state._fsp--; |
20514 | if (state.failed) return ; | 18791 | |
20515 | 18792 | ||
20516 | } | 18793 | } |
20517 | 18794 | ||
@@ -20531,53 +18808,49 @@ public class InternalSolverLanguageParser extends AbstractInternalContentAssistP | |||
20531 | 18808 | ||
20532 | 18809 | ||
20533 | // $ANTLR start "rule__ClassDefinition__Group_3__2__Impl" | 18810 | // $ANTLR start "rule__ClassDefinition__Group_3__2__Impl" |
20534 | // InternalSolverLanguage.g:6128:1: rule__ClassDefinition__Group_3__2__Impl : ( ( rule__ClassDefinition__Group_3_2__0 )* ) ; | 18811 | // InternalSolverLanguageParser.g:6072:1: rule__ClassDefinition__Group_3__2__Impl : ( ( rule__ClassDefinition__Group_3_2__0 )* ) ; |
20535 | public final void rule__ClassDefinition__Group_3__2__Impl() throws RecognitionException { | 18812 | public final void rule__ClassDefinition__Group_3__2__Impl() throws RecognitionException { |
20536 | 18813 | ||
20537 | int stackSize = keepStackSize(); | 18814 | int stackSize = keepStackSize(); |
20538 | 18815 | ||
20539 | try { | 18816 | try { |
20540 | // InternalSolverLanguage.g:6132:1: ( ( ( rule__ClassDefinition__Group_3_2__0 )* ) ) | 18817 | // InternalSolverLanguageParser.g:6076:1: ( ( ( rule__ClassDefinition__Group_3_2__0 )* ) ) |
20541 | // InternalSolverLanguage.g:6133:1: ( ( rule__ClassDefinition__Group_3_2__0 )* ) | 18818 | // InternalSolverLanguageParser.g:6077:1: ( ( rule__ClassDefinition__Group_3_2__0 )* ) |
20542 | { | 18819 | { |
20543 | // InternalSolverLanguage.g:6133:1: ( ( rule__ClassDefinition__Group_3_2__0 )* ) | 18820 | // InternalSolverLanguageParser.g:6077:1: ( ( rule__ClassDefinition__Group_3_2__0 )* ) |
20544 | // InternalSolverLanguage.g:6134:2: ( rule__ClassDefinition__Group_3_2__0 )* | 18821 | // InternalSolverLanguageParser.g:6078:2: ( rule__ClassDefinition__Group_3_2__0 )* |
20545 | { | 18822 | { |
20546 | if ( state.backtracking==0 ) { | 18823 | before(grammarAccess.getClassDefinitionAccess().getGroup_3_2()); |
20547 | before(grammarAccess.getClassDefinitionAccess().getGroup_3_2()); | 18824 | // InternalSolverLanguageParser.g:6079:2: ( rule__ClassDefinition__Group_3_2__0 )* |
20548 | } | 18825 | loop45: |
20549 | // InternalSolverLanguage.g:6135:2: ( rule__ClassDefinition__Group_3_2__0 )* | ||
20550 | loop46: | ||
20551 | do { | 18826 | do { |
20552 | int alt46=2; | 18827 | int alt45=2; |
20553 | int LA46_0 = input.LA(1); | 18828 | int LA45_0 = input.LA(1); |
20554 | 18829 | ||
20555 | if ( (LA46_0==56) ) { | 18830 | if ( (LA45_0==Comma) ) { |
20556 | alt46=1; | 18831 | alt45=1; |
20557 | } | 18832 | } |
20558 | 18833 | ||
20559 | 18834 | ||
20560 | switch (alt46) { | 18835 | switch (alt45) { |
20561 | case 1 : | 18836 | case 1 : |
20562 | // InternalSolverLanguage.g:6135:3: rule__ClassDefinition__Group_3_2__0 | 18837 | // InternalSolverLanguageParser.g:6079:3: rule__ClassDefinition__Group_3_2__0 |
20563 | { | 18838 | { |
20564 | pushFollow(FOLLOW_23); | 18839 | pushFollow(FOLLOW_22); |
20565 | rule__ClassDefinition__Group_3_2__0(); | 18840 | rule__ClassDefinition__Group_3_2__0(); |
20566 | 18841 | ||
20567 | state._fsp--; | 18842 | state._fsp--; |
20568 | if (state.failed) return ; | 18843 | |
20569 | 18844 | ||
20570 | } | 18845 | } |
20571 | break; | 18846 | break; |
20572 | 18847 | ||
20573 | default : | 18848 | default : |
20574 | break loop46; | 18849 | break loop45; |
20575 | } | 18850 | } |
20576 | } while (true); | 18851 | } while (true); |
20577 | 18852 | ||
20578 | if ( state.backtracking==0 ) { | 18853 | after(grammarAccess.getClassDefinitionAccess().getGroup_3_2()); |
20579 | after(grammarAccess.getClassDefinitionAccess().getGroup_3_2()); | ||
20580 | } | ||
20581 | 18854 | ||
20582 | } | 18855 | } |
20583 | 18856 | ||
@@ -20600,25 +18873,25 @@ public class InternalSolverLanguageParser extends AbstractInternalContentAssistP | |||
20600 | 18873 | ||
20601 | 18874 | ||
20602 | // $ANTLR start "rule__ClassDefinition__Group_3_2__0" | 18875 | // $ANTLR start "rule__ClassDefinition__Group_3_2__0" |
20603 | // InternalSolverLanguage.g:6144:1: rule__ClassDefinition__Group_3_2__0 : rule__ClassDefinition__Group_3_2__0__Impl rule__ClassDefinition__Group_3_2__1 ; | 18876 | // InternalSolverLanguageParser.g:6088:1: rule__ClassDefinition__Group_3_2__0 : rule__ClassDefinition__Group_3_2__0__Impl rule__ClassDefinition__Group_3_2__1 ; |
20604 | public final void rule__ClassDefinition__Group_3_2__0() throws RecognitionException { | 18877 | public final void rule__ClassDefinition__Group_3_2__0() throws RecognitionException { |
20605 | 18878 | ||
20606 | int stackSize = keepStackSize(); | 18879 | int stackSize = keepStackSize(); |
20607 | 18880 | ||
20608 | try { | 18881 | try { |
20609 | // InternalSolverLanguage.g:6148:1: ( rule__ClassDefinition__Group_3_2__0__Impl rule__ClassDefinition__Group_3_2__1 ) | 18882 | // InternalSolverLanguageParser.g:6092:1: ( rule__ClassDefinition__Group_3_2__0__Impl rule__ClassDefinition__Group_3_2__1 ) |
20610 | // InternalSolverLanguage.g:6149:2: rule__ClassDefinition__Group_3_2__0__Impl rule__ClassDefinition__Group_3_2__1 | 18883 | // InternalSolverLanguageParser.g:6093:2: rule__ClassDefinition__Group_3_2__0__Impl rule__ClassDefinition__Group_3_2__1 |
20611 | { | 18884 | { |
20612 | pushFollow(FOLLOW_9); | 18885 | pushFollow(FOLLOW_9); |
20613 | rule__ClassDefinition__Group_3_2__0__Impl(); | 18886 | rule__ClassDefinition__Group_3_2__0__Impl(); |
20614 | 18887 | ||
20615 | state._fsp--; | 18888 | state._fsp--; |
20616 | if (state.failed) return ; | 18889 | |
20617 | pushFollow(FOLLOW_2); | 18890 | pushFollow(FOLLOW_2); |
20618 | rule__ClassDefinition__Group_3_2__1(); | 18891 | rule__ClassDefinition__Group_3_2__1(); |
20619 | 18892 | ||
20620 | state._fsp--; | 18893 | state._fsp--; |
20621 | if (state.failed) return ; | 18894 | |
20622 | 18895 | ||
20623 | } | 18896 | } |
20624 | 18897 | ||
@@ -20638,25 +18911,21 @@ public class InternalSolverLanguageParser extends AbstractInternalContentAssistP | |||
20638 | 18911 | ||
20639 | 18912 | ||
20640 | // $ANTLR start "rule__ClassDefinition__Group_3_2__0__Impl" | 18913 | // $ANTLR start "rule__ClassDefinition__Group_3_2__0__Impl" |
20641 | // InternalSolverLanguage.g:6156:1: rule__ClassDefinition__Group_3_2__0__Impl : ( ',' ) ; | 18914 | // InternalSolverLanguageParser.g:6100:1: rule__ClassDefinition__Group_3_2__0__Impl : ( Comma ) ; |
20642 | public final void rule__ClassDefinition__Group_3_2__0__Impl() throws RecognitionException { | 18915 | public final void rule__ClassDefinition__Group_3_2__0__Impl() throws RecognitionException { |
20643 | 18916 | ||
20644 | int stackSize = keepStackSize(); | 18917 | int stackSize = keepStackSize(); |
20645 | 18918 | ||
20646 | try { | 18919 | try { |
20647 | // InternalSolverLanguage.g:6160:1: ( ( ',' ) ) | 18920 | // InternalSolverLanguageParser.g:6104:1: ( ( Comma ) ) |
20648 | // InternalSolverLanguage.g:6161:1: ( ',' ) | 18921 | // InternalSolverLanguageParser.g:6105:1: ( Comma ) |
20649 | { | 18922 | { |
20650 | // InternalSolverLanguage.g:6161:1: ( ',' ) | 18923 | // InternalSolverLanguageParser.g:6105:1: ( Comma ) |
20651 | // InternalSolverLanguage.g:6162:2: ',' | 18924 | // InternalSolverLanguageParser.g:6106:2: Comma |
20652 | { | 18925 | { |
20653 | if ( state.backtracking==0 ) { | 18926 | before(grammarAccess.getClassDefinitionAccess().getCommaKeyword_3_2_0()); |
20654 | before(grammarAccess.getClassDefinitionAccess().getCommaKeyword_3_2_0()); | 18927 | match(input,Comma,FOLLOW_2); |
20655 | } | 18928 | after(grammarAccess.getClassDefinitionAccess().getCommaKeyword_3_2_0()); |
20656 | match(input,56,FOLLOW_2); if (state.failed) return ; | ||
20657 | if ( state.backtracking==0 ) { | ||
20658 | after(grammarAccess.getClassDefinitionAccess().getCommaKeyword_3_2_0()); | ||
20659 | } | ||
20660 | 18929 | ||
20661 | } | 18930 | } |
20662 | 18931 | ||
@@ -20679,20 +18948,20 @@ public class InternalSolverLanguageParser extends AbstractInternalContentAssistP | |||
20679 | 18948 | ||
20680 | 18949 | ||
20681 | // $ANTLR start "rule__ClassDefinition__Group_3_2__1" | 18950 | // $ANTLR start "rule__ClassDefinition__Group_3_2__1" |
20682 | // InternalSolverLanguage.g:6171:1: rule__ClassDefinition__Group_3_2__1 : rule__ClassDefinition__Group_3_2__1__Impl ; | 18951 | // InternalSolverLanguageParser.g:6115:1: rule__ClassDefinition__Group_3_2__1 : rule__ClassDefinition__Group_3_2__1__Impl ; |
20683 | public final void rule__ClassDefinition__Group_3_2__1() throws RecognitionException { | 18952 | public final void rule__ClassDefinition__Group_3_2__1() throws RecognitionException { |
20684 | 18953 | ||
20685 | int stackSize = keepStackSize(); | 18954 | int stackSize = keepStackSize(); |
20686 | 18955 | ||
20687 | try { | 18956 | try { |
20688 | // InternalSolverLanguage.g:6175:1: ( rule__ClassDefinition__Group_3_2__1__Impl ) | 18957 | // InternalSolverLanguageParser.g:6119:1: ( rule__ClassDefinition__Group_3_2__1__Impl ) |
20689 | // InternalSolverLanguage.g:6176:2: rule__ClassDefinition__Group_3_2__1__Impl | 18958 | // InternalSolverLanguageParser.g:6120:2: rule__ClassDefinition__Group_3_2__1__Impl |
20690 | { | 18959 | { |
20691 | pushFollow(FOLLOW_2); | 18960 | pushFollow(FOLLOW_2); |
20692 | rule__ClassDefinition__Group_3_2__1__Impl(); | 18961 | rule__ClassDefinition__Group_3_2__1__Impl(); |
20693 | 18962 | ||
20694 | state._fsp--; | 18963 | state._fsp--; |
20695 | if (state.failed) return ; | 18964 | |
20696 | 18965 | ||
20697 | } | 18966 | } |
20698 | 18967 | ||
@@ -20712,36 +18981,32 @@ public class InternalSolverLanguageParser extends AbstractInternalContentAssistP | |||
20712 | 18981 | ||
20713 | 18982 | ||
20714 | // $ANTLR start "rule__ClassDefinition__Group_3_2__1__Impl" | 18983 | // $ANTLR start "rule__ClassDefinition__Group_3_2__1__Impl" |
20715 | // InternalSolverLanguage.g:6182:1: rule__ClassDefinition__Group_3_2__1__Impl : ( ( rule__ClassDefinition__SuperclassesAssignment_3_2_1 ) ) ; | 18984 | // InternalSolverLanguageParser.g:6126:1: rule__ClassDefinition__Group_3_2__1__Impl : ( ( rule__ClassDefinition__SuperclassesAssignment_3_2_1 ) ) ; |
20716 | public final void rule__ClassDefinition__Group_3_2__1__Impl() throws RecognitionException { | 18985 | public final void rule__ClassDefinition__Group_3_2__1__Impl() throws RecognitionException { |
20717 | 18986 | ||
20718 | int stackSize = keepStackSize(); | 18987 | int stackSize = keepStackSize(); |
20719 | 18988 | ||
20720 | try { | 18989 | try { |
20721 | // InternalSolverLanguage.g:6186:1: ( ( ( rule__ClassDefinition__SuperclassesAssignment_3_2_1 ) ) ) | 18990 | // InternalSolverLanguageParser.g:6130:1: ( ( ( rule__ClassDefinition__SuperclassesAssignment_3_2_1 ) ) ) |
20722 | // InternalSolverLanguage.g:6187:1: ( ( rule__ClassDefinition__SuperclassesAssignment_3_2_1 ) ) | 18991 | // InternalSolverLanguageParser.g:6131:1: ( ( rule__ClassDefinition__SuperclassesAssignment_3_2_1 ) ) |
20723 | { | 18992 | { |
20724 | // InternalSolverLanguage.g:6187:1: ( ( rule__ClassDefinition__SuperclassesAssignment_3_2_1 ) ) | 18993 | // InternalSolverLanguageParser.g:6131:1: ( ( rule__ClassDefinition__SuperclassesAssignment_3_2_1 ) ) |
20725 | // InternalSolverLanguage.g:6188:2: ( rule__ClassDefinition__SuperclassesAssignment_3_2_1 ) | 18994 | // InternalSolverLanguageParser.g:6132:2: ( rule__ClassDefinition__SuperclassesAssignment_3_2_1 ) |
20726 | { | 18995 | { |
20727 | if ( state.backtracking==0 ) { | 18996 | before(grammarAccess.getClassDefinitionAccess().getSuperclassesAssignment_3_2_1()); |
20728 | before(grammarAccess.getClassDefinitionAccess().getSuperclassesAssignment_3_2_1()); | 18997 | // InternalSolverLanguageParser.g:6133:2: ( rule__ClassDefinition__SuperclassesAssignment_3_2_1 ) |
20729 | } | 18998 | // InternalSolverLanguageParser.g:6133:3: rule__ClassDefinition__SuperclassesAssignment_3_2_1 |
20730 | // InternalSolverLanguage.g:6189:2: ( rule__ClassDefinition__SuperclassesAssignment_3_2_1 ) | ||
20731 | // InternalSolverLanguage.g:6189:3: rule__ClassDefinition__SuperclassesAssignment_3_2_1 | ||
20732 | { | 18999 | { |
20733 | pushFollow(FOLLOW_2); | 19000 | pushFollow(FOLLOW_2); |
20734 | rule__ClassDefinition__SuperclassesAssignment_3_2_1(); | 19001 | rule__ClassDefinition__SuperclassesAssignment_3_2_1(); |
20735 | 19002 | ||
20736 | state._fsp--; | 19003 | state._fsp--; |
20737 | if (state.failed) return ; | ||
20738 | 19004 | ||
20739 | } | ||
20740 | 19005 | ||
20741 | if ( state.backtracking==0 ) { | ||
20742 | after(grammarAccess.getClassDefinitionAccess().getSuperclassesAssignment_3_2_1()); | ||
20743 | } | 19006 | } |
20744 | 19007 | ||
19008 | after(grammarAccess.getClassDefinitionAccess().getSuperclassesAssignment_3_2_1()); | ||
19009 | |||
20745 | } | 19010 | } |
20746 | 19011 | ||
20747 | 19012 | ||
@@ -20763,25 +19028,25 @@ public class InternalSolverLanguageParser extends AbstractInternalContentAssistP | |||
20763 | 19028 | ||
20764 | 19029 | ||
20765 | // $ANTLR start "rule__MemberDefinition__Group__0" | 19030 | // $ANTLR start "rule__MemberDefinition__Group__0" |
20766 | // InternalSolverLanguage.g:6198:1: rule__MemberDefinition__Group__0 : rule__MemberDefinition__Group__0__Impl rule__MemberDefinition__Group__1 ; | 19031 | // InternalSolverLanguageParser.g:6142:1: rule__MemberDefinition__Group__0 : rule__MemberDefinition__Group__0__Impl rule__MemberDefinition__Group__1 ; |
20767 | public final void rule__MemberDefinition__Group__0() throws RecognitionException { | 19032 | public final void rule__MemberDefinition__Group__0() throws RecognitionException { |
20768 | 19033 | ||
20769 | int stackSize = keepStackSize(); | 19034 | int stackSize = keepStackSize(); |
20770 | 19035 | ||
20771 | try { | 19036 | try { |
20772 | // InternalSolverLanguage.g:6202:1: ( rule__MemberDefinition__Group__0__Impl rule__MemberDefinition__Group__1 ) | 19037 | // InternalSolverLanguageParser.g:6146:1: ( rule__MemberDefinition__Group__0__Impl rule__MemberDefinition__Group__1 ) |
20773 | // InternalSolverLanguage.g:6203:2: rule__MemberDefinition__Group__0__Impl rule__MemberDefinition__Group__1 | 19038 | // InternalSolverLanguageParser.g:6147:2: rule__MemberDefinition__Group__0__Impl rule__MemberDefinition__Group__1 |
20774 | { | 19039 | { |
20775 | pushFollow(FOLLOW_48); | 19040 | pushFollow(FOLLOW_47); |
20776 | rule__MemberDefinition__Group__0__Impl(); | 19041 | rule__MemberDefinition__Group__0__Impl(); |
20777 | 19042 | ||
20778 | state._fsp--; | 19043 | state._fsp--; |
20779 | if (state.failed) return ; | 19044 | |
20780 | pushFollow(FOLLOW_2); | 19045 | pushFollow(FOLLOW_2); |
20781 | rule__MemberDefinition__Group__1(); | 19046 | rule__MemberDefinition__Group__1(); |
20782 | 19047 | ||
20783 | state._fsp--; | 19048 | state._fsp--; |
20784 | if (state.failed) return ; | 19049 | |
20785 | 19050 | ||
20786 | } | 19051 | } |
20787 | 19052 | ||
@@ -20801,46 +19066,42 @@ public class InternalSolverLanguageParser extends AbstractInternalContentAssistP | |||
20801 | 19066 | ||
20802 | 19067 | ||
20803 | // $ANTLR start "rule__MemberDefinition__Group__0__Impl" | 19068 | // $ANTLR start "rule__MemberDefinition__Group__0__Impl" |
20804 | // InternalSolverLanguage.g:6210:1: rule__MemberDefinition__Group__0__Impl : ( ( rule__MemberDefinition__ContainmentAssignment_0 )? ) ; | 19069 | // InternalSolverLanguageParser.g:6154:1: rule__MemberDefinition__Group__0__Impl : ( ( rule__MemberDefinition__ContainmentAssignment_0 )? ) ; |
20805 | public final void rule__MemberDefinition__Group__0__Impl() throws RecognitionException { | 19070 | public final void rule__MemberDefinition__Group__0__Impl() throws RecognitionException { |
20806 | 19071 | ||
20807 | int stackSize = keepStackSize(); | 19072 | int stackSize = keepStackSize(); |
20808 | 19073 | ||
20809 | try { | 19074 | try { |
20810 | // InternalSolverLanguage.g:6214:1: ( ( ( rule__MemberDefinition__ContainmentAssignment_0 )? ) ) | 19075 | // InternalSolverLanguageParser.g:6158:1: ( ( ( rule__MemberDefinition__ContainmentAssignment_0 )? ) ) |
20811 | // InternalSolverLanguage.g:6215:1: ( ( rule__MemberDefinition__ContainmentAssignment_0 )? ) | 19076 | // InternalSolverLanguageParser.g:6159:1: ( ( rule__MemberDefinition__ContainmentAssignment_0 )? ) |
20812 | { | 19077 | { |
20813 | // InternalSolverLanguage.g:6215:1: ( ( rule__MemberDefinition__ContainmentAssignment_0 )? ) | 19078 | // InternalSolverLanguageParser.g:6159:1: ( ( rule__MemberDefinition__ContainmentAssignment_0 )? ) |
20814 | // InternalSolverLanguage.g:6216:2: ( rule__MemberDefinition__ContainmentAssignment_0 )? | 19079 | // InternalSolverLanguageParser.g:6160:2: ( rule__MemberDefinition__ContainmentAssignment_0 )? |
20815 | { | 19080 | { |
20816 | if ( state.backtracking==0 ) { | 19081 | before(grammarAccess.getMemberDefinitionAccess().getContainmentAssignment_0()); |
20817 | before(grammarAccess.getMemberDefinitionAccess().getContainmentAssignment_0()); | 19082 | // InternalSolverLanguageParser.g:6161:2: ( rule__MemberDefinition__ContainmentAssignment_0 )? |
20818 | } | 19083 | int alt46=2; |
20819 | // InternalSolverLanguage.g:6217:2: ( rule__MemberDefinition__ContainmentAssignment_0 )? | 19084 | int LA46_0 = input.LA(1); |
20820 | int alt47=2; | ||
20821 | int LA47_0 = input.LA(1); | ||
20822 | 19085 | ||
20823 | if ( (LA47_0==74) ) { | 19086 | if ( (LA46_0==Contains) ) { |
20824 | alt47=1; | 19087 | alt46=1; |
20825 | } | 19088 | } |
20826 | switch (alt47) { | 19089 | switch (alt46) { |
20827 | case 1 : | 19090 | case 1 : |
20828 | // InternalSolverLanguage.g:6217:3: rule__MemberDefinition__ContainmentAssignment_0 | 19091 | // InternalSolverLanguageParser.g:6161:3: rule__MemberDefinition__ContainmentAssignment_0 |
20829 | { | 19092 | { |
20830 | pushFollow(FOLLOW_2); | 19093 | pushFollow(FOLLOW_2); |
20831 | rule__MemberDefinition__ContainmentAssignment_0(); | 19094 | rule__MemberDefinition__ContainmentAssignment_0(); |
20832 | 19095 | ||
20833 | state._fsp--; | 19096 | state._fsp--; |
20834 | if (state.failed) return ; | 19097 | |
20835 | 19098 | ||
20836 | } | 19099 | } |
20837 | break; | 19100 | break; |
20838 | 19101 | ||
20839 | } | 19102 | } |
20840 | 19103 | ||
20841 | if ( state.backtracking==0 ) { | 19104 | after(grammarAccess.getMemberDefinitionAccess().getContainmentAssignment_0()); |
20842 | after(grammarAccess.getMemberDefinitionAccess().getContainmentAssignment_0()); | ||
20843 | } | ||
20844 | 19105 | ||
20845 | } | 19106 | } |
20846 | 19107 | ||
@@ -20863,25 +19124,25 @@ public class InternalSolverLanguageParser extends AbstractInternalContentAssistP | |||
20863 | 19124 | ||
20864 | 19125 | ||
20865 | // $ANTLR start "rule__MemberDefinition__Group__1" | 19126 | // $ANTLR start "rule__MemberDefinition__Group__1" |
20866 | // InternalSolverLanguage.g:6225:1: rule__MemberDefinition__Group__1 : rule__MemberDefinition__Group__1__Impl rule__MemberDefinition__Group__2 ; | 19127 | // InternalSolverLanguageParser.g:6169:1: rule__MemberDefinition__Group__1 : rule__MemberDefinition__Group__1__Impl rule__MemberDefinition__Group__2 ; |
20867 | public final void rule__MemberDefinition__Group__1() throws RecognitionException { | 19128 | public final void rule__MemberDefinition__Group__1() throws RecognitionException { |
20868 | 19129 | ||
20869 | int stackSize = keepStackSize(); | 19130 | int stackSize = keepStackSize(); |
20870 | 19131 | ||
20871 | try { | 19132 | try { |
20872 | // InternalSolverLanguage.g:6229:1: ( rule__MemberDefinition__Group__1__Impl rule__MemberDefinition__Group__2 ) | 19133 | // InternalSolverLanguageParser.g:6173:1: ( rule__MemberDefinition__Group__1__Impl rule__MemberDefinition__Group__2 ) |
20873 | // InternalSolverLanguage.g:6230:2: rule__MemberDefinition__Group__1__Impl rule__MemberDefinition__Group__2 | 19134 | // InternalSolverLanguageParser.g:6174:2: rule__MemberDefinition__Group__1__Impl rule__MemberDefinition__Group__2 |
20874 | { | 19135 | { |
20875 | pushFollow(FOLLOW_49); | 19136 | pushFollow(FOLLOW_48); |
20876 | rule__MemberDefinition__Group__1__Impl(); | 19137 | rule__MemberDefinition__Group__1__Impl(); |
20877 | 19138 | ||
20878 | state._fsp--; | 19139 | state._fsp--; |
20879 | if (state.failed) return ; | 19140 | |
20880 | pushFollow(FOLLOW_2); | 19141 | pushFollow(FOLLOW_2); |
20881 | rule__MemberDefinition__Group__2(); | 19142 | rule__MemberDefinition__Group__2(); |
20882 | 19143 | ||
20883 | state._fsp--; | 19144 | state._fsp--; |
20884 | if (state.failed) return ; | 19145 | |
20885 | 19146 | ||
20886 | } | 19147 | } |
20887 | 19148 | ||
@@ -20901,36 +19162,32 @@ public class InternalSolverLanguageParser extends AbstractInternalContentAssistP | |||
20901 | 19162 | ||
20902 | 19163 | ||
20903 | // $ANTLR start "rule__MemberDefinition__Group__1__Impl" | 19164 | // $ANTLR start "rule__MemberDefinition__Group__1__Impl" |
20904 | // InternalSolverLanguage.g:6237:1: rule__MemberDefinition__Group__1__Impl : ( ( rule__MemberDefinition__TypeAssignment_1 ) ) ; | 19165 | // InternalSolverLanguageParser.g:6181:1: rule__MemberDefinition__Group__1__Impl : ( ( rule__MemberDefinition__TypeAssignment_1 ) ) ; |
20905 | public final void rule__MemberDefinition__Group__1__Impl() throws RecognitionException { | 19166 | public final void rule__MemberDefinition__Group__1__Impl() throws RecognitionException { |
20906 | 19167 | ||
20907 | int stackSize = keepStackSize(); | 19168 | int stackSize = keepStackSize(); |
20908 | 19169 | ||
20909 | try { | 19170 | try { |
20910 | // InternalSolverLanguage.g:6241:1: ( ( ( rule__MemberDefinition__TypeAssignment_1 ) ) ) | 19171 | // InternalSolverLanguageParser.g:6185:1: ( ( ( rule__MemberDefinition__TypeAssignment_1 ) ) ) |
20911 | // InternalSolverLanguage.g:6242:1: ( ( rule__MemberDefinition__TypeAssignment_1 ) ) | 19172 | // InternalSolverLanguageParser.g:6186:1: ( ( rule__MemberDefinition__TypeAssignment_1 ) ) |
20912 | { | 19173 | { |
20913 | // InternalSolverLanguage.g:6242:1: ( ( rule__MemberDefinition__TypeAssignment_1 ) ) | 19174 | // InternalSolverLanguageParser.g:6186:1: ( ( rule__MemberDefinition__TypeAssignment_1 ) ) |
20914 | // InternalSolverLanguage.g:6243:2: ( rule__MemberDefinition__TypeAssignment_1 ) | 19175 | // InternalSolverLanguageParser.g:6187:2: ( rule__MemberDefinition__TypeAssignment_1 ) |
20915 | { | 19176 | { |
20916 | if ( state.backtracking==0 ) { | 19177 | before(grammarAccess.getMemberDefinitionAccess().getTypeAssignment_1()); |
20917 | before(grammarAccess.getMemberDefinitionAccess().getTypeAssignment_1()); | 19178 | // InternalSolverLanguageParser.g:6188:2: ( rule__MemberDefinition__TypeAssignment_1 ) |
20918 | } | 19179 | // InternalSolverLanguageParser.g:6188:3: rule__MemberDefinition__TypeAssignment_1 |
20919 | // InternalSolverLanguage.g:6244:2: ( rule__MemberDefinition__TypeAssignment_1 ) | ||
20920 | // InternalSolverLanguage.g:6244:3: rule__MemberDefinition__TypeAssignment_1 | ||
20921 | { | 19180 | { |
20922 | pushFollow(FOLLOW_2); | 19181 | pushFollow(FOLLOW_2); |
20923 | rule__MemberDefinition__TypeAssignment_1(); | 19182 | rule__MemberDefinition__TypeAssignment_1(); |
20924 | 19183 | ||
20925 | state._fsp--; | 19184 | state._fsp--; |
20926 | if (state.failed) return ; | ||
20927 | 19185 | ||
20928 | } | ||
20929 | 19186 | ||
20930 | if ( state.backtracking==0 ) { | ||
20931 | after(grammarAccess.getMemberDefinitionAccess().getTypeAssignment_1()); | ||
20932 | } | 19187 | } |
20933 | 19188 | ||
19189 | after(grammarAccess.getMemberDefinitionAccess().getTypeAssignment_1()); | ||
19190 | |||
20934 | } | 19191 | } |
20935 | 19192 | ||
20936 | 19193 | ||
@@ -20952,25 +19209,25 @@ public class InternalSolverLanguageParser extends AbstractInternalContentAssistP | |||
20952 | 19209 | ||
20953 | 19210 | ||
20954 | // $ANTLR start "rule__MemberDefinition__Group__2" | 19211 | // $ANTLR start "rule__MemberDefinition__Group__2" |
20955 | // InternalSolverLanguage.g:6252:1: rule__MemberDefinition__Group__2 : rule__MemberDefinition__Group__2__Impl rule__MemberDefinition__Group__3 ; | 19212 | // InternalSolverLanguageParser.g:6196:1: rule__MemberDefinition__Group__2 : rule__MemberDefinition__Group__2__Impl rule__MemberDefinition__Group__3 ; |
20956 | public final void rule__MemberDefinition__Group__2() throws RecognitionException { | 19213 | public final void rule__MemberDefinition__Group__2() throws RecognitionException { |
20957 | 19214 | ||
20958 | int stackSize = keepStackSize(); | 19215 | int stackSize = keepStackSize(); |
20959 | 19216 | ||
20960 | try { | 19217 | try { |
20961 | // InternalSolverLanguage.g:6256:1: ( rule__MemberDefinition__Group__2__Impl rule__MemberDefinition__Group__3 ) | 19218 | // InternalSolverLanguageParser.g:6200:1: ( rule__MemberDefinition__Group__2__Impl rule__MemberDefinition__Group__3 ) |
20962 | // InternalSolverLanguage.g:6257:2: rule__MemberDefinition__Group__2__Impl rule__MemberDefinition__Group__3 | 19219 | // InternalSolverLanguageParser.g:6201:2: rule__MemberDefinition__Group__2__Impl rule__MemberDefinition__Group__3 |
20963 | { | 19220 | { |
20964 | pushFollow(FOLLOW_49); | 19221 | pushFollow(FOLLOW_48); |
20965 | rule__MemberDefinition__Group__2__Impl(); | 19222 | rule__MemberDefinition__Group__2__Impl(); |
20966 | 19223 | ||
20967 | state._fsp--; | 19224 | state._fsp--; |
20968 | if (state.failed) return ; | 19225 | |
20969 | pushFollow(FOLLOW_2); | 19226 | pushFollow(FOLLOW_2); |
20970 | rule__MemberDefinition__Group__3(); | 19227 | rule__MemberDefinition__Group__3(); |
20971 | 19228 | ||
20972 | state._fsp--; | 19229 | state._fsp--; |
20973 | if (state.failed) return ; | 19230 | |
20974 | 19231 | ||
20975 | } | 19232 | } |
20976 | 19233 | ||
@@ -20990,46 +19247,42 @@ public class InternalSolverLanguageParser extends AbstractInternalContentAssistP | |||
20990 | 19247 | ||
20991 | 19248 | ||
20992 | // $ANTLR start "rule__MemberDefinition__Group__2__Impl" | 19249 | // $ANTLR start "rule__MemberDefinition__Group__2__Impl" |
20993 | // InternalSolverLanguage.g:6264:1: rule__MemberDefinition__Group__2__Impl : ( ( rule__MemberDefinition__MultiplicityAssignment_2 )? ) ; | 19250 | // InternalSolverLanguageParser.g:6208:1: rule__MemberDefinition__Group__2__Impl : ( ( rule__MemberDefinition__MultiplicityAssignment_2 )? ) ; |
20994 | public final void rule__MemberDefinition__Group__2__Impl() throws RecognitionException { | 19251 | public final void rule__MemberDefinition__Group__2__Impl() throws RecognitionException { |
20995 | 19252 | ||
20996 | int stackSize = keepStackSize(); | 19253 | int stackSize = keepStackSize(); |
20997 | 19254 | ||
20998 | try { | 19255 | try { |
20999 | // InternalSolverLanguage.g:6268:1: ( ( ( rule__MemberDefinition__MultiplicityAssignment_2 )? ) ) | 19256 | // InternalSolverLanguageParser.g:6212:1: ( ( ( rule__MemberDefinition__MultiplicityAssignment_2 )? ) ) |
21000 | // InternalSolverLanguage.g:6269:1: ( ( rule__MemberDefinition__MultiplicityAssignment_2 )? ) | 19257 | // InternalSolverLanguageParser.g:6213:1: ( ( rule__MemberDefinition__MultiplicityAssignment_2 )? ) |
21001 | { | 19258 | { |
21002 | // InternalSolverLanguage.g:6269:1: ( ( rule__MemberDefinition__MultiplicityAssignment_2 )? ) | 19259 | // InternalSolverLanguageParser.g:6213:1: ( ( rule__MemberDefinition__MultiplicityAssignment_2 )? ) |
21003 | // InternalSolverLanguage.g:6270:2: ( rule__MemberDefinition__MultiplicityAssignment_2 )? | 19260 | // InternalSolverLanguageParser.g:6214:2: ( rule__MemberDefinition__MultiplicityAssignment_2 )? |
21004 | { | 19261 | { |
21005 | if ( state.backtracking==0 ) { | 19262 | before(grammarAccess.getMemberDefinitionAccess().getMultiplicityAssignment_2()); |
21006 | before(grammarAccess.getMemberDefinitionAccess().getMultiplicityAssignment_2()); | 19263 | // InternalSolverLanguageParser.g:6215:2: ( rule__MemberDefinition__MultiplicityAssignment_2 )? |
21007 | } | 19264 | int alt47=2; |
21008 | // InternalSolverLanguage.g:6271:2: ( rule__MemberDefinition__MultiplicityAssignment_2 )? | 19265 | int LA47_0 = input.LA(1); |
21009 | int alt48=2; | ||
21010 | int LA48_0 = input.LA(1); | ||
21011 | 19266 | ||
21012 | if ( (LA48_0==63) ) { | 19267 | if ( (LA47_0==LeftSquareBracket) ) { |
21013 | alt48=1; | 19268 | alt47=1; |
21014 | } | 19269 | } |
21015 | switch (alt48) { | 19270 | switch (alt47) { |
21016 | case 1 : | 19271 | case 1 : |
21017 | // InternalSolverLanguage.g:6271:3: rule__MemberDefinition__MultiplicityAssignment_2 | 19272 | // InternalSolverLanguageParser.g:6215:3: rule__MemberDefinition__MultiplicityAssignment_2 |
21018 | { | 19273 | { |
21019 | pushFollow(FOLLOW_2); | 19274 | pushFollow(FOLLOW_2); |
21020 | rule__MemberDefinition__MultiplicityAssignment_2(); | 19275 | rule__MemberDefinition__MultiplicityAssignment_2(); |
21021 | 19276 | ||
21022 | state._fsp--; | 19277 | state._fsp--; |
21023 | if (state.failed) return ; | 19278 | |
21024 | 19279 | ||
21025 | } | 19280 | } |
21026 | break; | 19281 | break; |
21027 | 19282 | ||
21028 | } | 19283 | } |
21029 | 19284 | ||
21030 | if ( state.backtracking==0 ) { | 19285 | after(grammarAccess.getMemberDefinitionAccess().getMultiplicityAssignment_2()); |
21031 | after(grammarAccess.getMemberDefinitionAccess().getMultiplicityAssignment_2()); | ||
21032 | } | ||
21033 | 19286 | ||
21034 | } | 19287 | } |
21035 | 19288 | ||
@@ -21052,25 +19305,25 @@ public class InternalSolverLanguageParser extends AbstractInternalContentAssistP | |||
21052 | 19305 | ||
21053 | 19306 | ||
21054 | // $ANTLR start "rule__MemberDefinition__Group__3" | 19307 | // $ANTLR start "rule__MemberDefinition__Group__3" |
21055 | // InternalSolverLanguage.g:6279:1: rule__MemberDefinition__Group__3 : rule__MemberDefinition__Group__3__Impl rule__MemberDefinition__Group__4 ; | 19308 | // InternalSolverLanguageParser.g:6223:1: rule__MemberDefinition__Group__3 : rule__MemberDefinition__Group__3__Impl rule__MemberDefinition__Group__4 ; |
21056 | public final void rule__MemberDefinition__Group__3() throws RecognitionException { | 19309 | public final void rule__MemberDefinition__Group__3() throws RecognitionException { |
21057 | 19310 | ||
21058 | int stackSize = keepStackSize(); | 19311 | int stackSize = keepStackSize(); |
21059 | 19312 | ||
21060 | try { | 19313 | try { |
21061 | // InternalSolverLanguage.g:6283:1: ( rule__MemberDefinition__Group__3__Impl rule__MemberDefinition__Group__4 ) | 19314 | // InternalSolverLanguageParser.g:6227:1: ( rule__MemberDefinition__Group__3__Impl rule__MemberDefinition__Group__4 ) |
21062 | // InternalSolverLanguage.g:6284:2: rule__MemberDefinition__Group__3__Impl rule__MemberDefinition__Group__4 | 19315 | // InternalSolverLanguageParser.g:6228:2: rule__MemberDefinition__Group__3__Impl rule__MemberDefinition__Group__4 |
21063 | { | 19316 | { |
21064 | pushFollow(FOLLOW_50); | 19317 | pushFollow(FOLLOW_49); |
21065 | rule__MemberDefinition__Group__3__Impl(); | 19318 | rule__MemberDefinition__Group__3__Impl(); |
21066 | 19319 | ||
21067 | state._fsp--; | 19320 | state._fsp--; |
21068 | if (state.failed) return ; | 19321 | |
21069 | pushFollow(FOLLOW_2); | 19322 | pushFollow(FOLLOW_2); |
21070 | rule__MemberDefinition__Group__4(); | 19323 | rule__MemberDefinition__Group__4(); |
21071 | 19324 | ||
21072 | state._fsp--; | 19325 | state._fsp--; |
21073 | if (state.failed) return ; | 19326 | |
21074 | 19327 | ||
21075 | } | 19328 | } |
21076 | 19329 | ||
@@ -21090,36 +19343,32 @@ public class InternalSolverLanguageParser extends AbstractInternalContentAssistP | |||
21090 | 19343 | ||
21091 | 19344 | ||
21092 | // $ANTLR start "rule__MemberDefinition__Group__3__Impl" | 19345 | // $ANTLR start "rule__MemberDefinition__Group__3__Impl" |
21093 | // InternalSolverLanguage.g:6291:1: rule__MemberDefinition__Group__3__Impl : ( ( rule__MemberDefinition__NameAssignment_3 ) ) ; | 19346 | // InternalSolverLanguageParser.g:6235:1: rule__MemberDefinition__Group__3__Impl : ( ( rule__MemberDefinition__NameAssignment_3 ) ) ; |
21094 | public final void rule__MemberDefinition__Group__3__Impl() throws RecognitionException { | 19347 | public final void rule__MemberDefinition__Group__3__Impl() throws RecognitionException { |
21095 | 19348 | ||
21096 | int stackSize = keepStackSize(); | 19349 | int stackSize = keepStackSize(); |
21097 | 19350 | ||
21098 | try { | 19351 | try { |
21099 | // InternalSolverLanguage.g:6295:1: ( ( ( rule__MemberDefinition__NameAssignment_3 ) ) ) | 19352 | // InternalSolverLanguageParser.g:6239:1: ( ( ( rule__MemberDefinition__NameAssignment_3 ) ) ) |
21100 | // InternalSolverLanguage.g:6296:1: ( ( rule__MemberDefinition__NameAssignment_3 ) ) | 19353 | // InternalSolverLanguageParser.g:6240:1: ( ( rule__MemberDefinition__NameAssignment_3 ) ) |
21101 | { | 19354 | { |
21102 | // InternalSolverLanguage.g:6296:1: ( ( rule__MemberDefinition__NameAssignment_3 ) ) | 19355 | // InternalSolverLanguageParser.g:6240:1: ( ( rule__MemberDefinition__NameAssignment_3 ) ) |
21103 | // InternalSolverLanguage.g:6297:2: ( rule__MemberDefinition__NameAssignment_3 ) | 19356 | // InternalSolverLanguageParser.g:6241:2: ( rule__MemberDefinition__NameAssignment_3 ) |
21104 | { | 19357 | { |
21105 | if ( state.backtracking==0 ) { | 19358 | before(grammarAccess.getMemberDefinitionAccess().getNameAssignment_3()); |
21106 | before(grammarAccess.getMemberDefinitionAccess().getNameAssignment_3()); | 19359 | // InternalSolverLanguageParser.g:6242:2: ( rule__MemberDefinition__NameAssignment_3 ) |
21107 | } | 19360 | // InternalSolverLanguageParser.g:6242:3: rule__MemberDefinition__NameAssignment_3 |
21108 | // InternalSolverLanguage.g:6298:2: ( rule__MemberDefinition__NameAssignment_3 ) | ||
21109 | // InternalSolverLanguage.g:6298:3: rule__MemberDefinition__NameAssignment_3 | ||
21110 | { | 19361 | { |
21111 | pushFollow(FOLLOW_2); | 19362 | pushFollow(FOLLOW_2); |
21112 | rule__MemberDefinition__NameAssignment_3(); | 19363 | rule__MemberDefinition__NameAssignment_3(); |
21113 | 19364 | ||
21114 | state._fsp--; | 19365 | state._fsp--; |
21115 | if (state.failed) return ; | ||
21116 | 19366 | ||
21117 | } | ||
21118 | 19367 | ||
21119 | if ( state.backtracking==0 ) { | ||
21120 | after(grammarAccess.getMemberDefinitionAccess().getNameAssignment_3()); | ||
21121 | } | 19368 | } |
21122 | 19369 | ||
19370 | after(grammarAccess.getMemberDefinitionAccess().getNameAssignment_3()); | ||
19371 | |||
21123 | } | 19372 | } |
21124 | 19373 | ||
21125 | 19374 | ||
@@ -21141,25 +19390,25 @@ public class InternalSolverLanguageParser extends AbstractInternalContentAssistP | |||
21141 | 19390 | ||
21142 | 19391 | ||
21143 | // $ANTLR start "rule__MemberDefinition__Group__4" | 19392 | // $ANTLR start "rule__MemberDefinition__Group__4" |
21144 | // InternalSolverLanguage.g:6306:1: rule__MemberDefinition__Group__4 : rule__MemberDefinition__Group__4__Impl rule__MemberDefinition__Group__5 ; | 19393 | // InternalSolverLanguageParser.g:6250:1: rule__MemberDefinition__Group__4 : rule__MemberDefinition__Group__4__Impl rule__MemberDefinition__Group__5 ; |
21145 | public final void rule__MemberDefinition__Group__4() throws RecognitionException { | 19394 | public final void rule__MemberDefinition__Group__4() throws RecognitionException { |
21146 | 19395 | ||
21147 | int stackSize = keepStackSize(); | 19396 | int stackSize = keepStackSize(); |
21148 | 19397 | ||
21149 | try { | 19398 | try { |
21150 | // InternalSolverLanguage.g:6310:1: ( rule__MemberDefinition__Group__4__Impl rule__MemberDefinition__Group__5 ) | 19399 | // InternalSolverLanguageParser.g:6254:1: ( rule__MemberDefinition__Group__4__Impl rule__MemberDefinition__Group__5 ) |
21151 | // InternalSolverLanguage.g:6311:2: rule__MemberDefinition__Group__4__Impl rule__MemberDefinition__Group__5 | 19400 | // InternalSolverLanguageParser.g:6255:2: rule__MemberDefinition__Group__4__Impl rule__MemberDefinition__Group__5 |
21152 | { | 19401 | { |
21153 | pushFollow(FOLLOW_50); | 19402 | pushFollow(FOLLOW_49); |
21154 | rule__MemberDefinition__Group__4__Impl(); | 19403 | rule__MemberDefinition__Group__4__Impl(); |
21155 | 19404 | ||
21156 | state._fsp--; | 19405 | state._fsp--; |
21157 | if (state.failed) return ; | 19406 | |
21158 | pushFollow(FOLLOW_2); | 19407 | pushFollow(FOLLOW_2); |
21159 | rule__MemberDefinition__Group__5(); | 19408 | rule__MemberDefinition__Group__5(); |
21160 | 19409 | ||
21161 | state._fsp--; | 19410 | state._fsp--; |
21162 | if (state.failed) return ; | 19411 | |
21163 | 19412 | ||
21164 | } | 19413 | } |
21165 | 19414 | ||
@@ -21179,46 +19428,42 @@ public class InternalSolverLanguageParser extends AbstractInternalContentAssistP | |||
21179 | 19428 | ||
21180 | 19429 | ||
21181 | // $ANTLR start "rule__MemberDefinition__Group__4__Impl" | 19430 | // $ANTLR start "rule__MemberDefinition__Group__4__Impl" |
21182 | // InternalSolverLanguage.g:6318:1: rule__MemberDefinition__Group__4__Impl : ( ( rule__MemberDefinition__Group_4__0 )? ) ; | 19431 | // InternalSolverLanguageParser.g:6262:1: rule__MemberDefinition__Group__4__Impl : ( ( rule__MemberDefinition__Group_4__0 )? ) ; |
21183 | public final void rule__MemberDefinition__Group__4__Impl() throws RecognitionException { | 19432 | public final void rule__MemberDefinition__Group__4__Impl() throws RecognitionException { |
21184 | 19433 | ||
21185 | int stackSize = keepStackSize(); | 19434 | int stackSize = keepStackSize(); |
21186 | 19435 | ||
21187 | try { | 19436 | try { |
21188 | // InternalSolverLanguage.g:6322:1: ( ( ( rule__MemberDefinition__Group_4__0 )? ) ) | 19437 | // InternalSolverLanguageParser.g:6266:1: ( ( ( rule__MemberDefinition__Group_4__0 )? ) ) |
21189 | // InternalSolverLanguage.g:6323:1: ( ( rule__MemberDefinition__Group_4__0 )? ) | 19438 | // InternalSolverLanguageParser.g:6267:1: ( ( rule__MemberDefinition__Group_4__0 )? ) |
21190 | { | 19439 | { |
21191 | // InternalSolverLanguage.g:6323:1: ( ( rule__MemberDefinition__Group_4__0 )? ) | 19440 | // InternalSolverLanguageParser.g:6267:1: ( ( rule__MemberDefinition__Group_4__0 )? ) |
21192 | // InternalSolverLanguage.g:6324:2: ( rule__MemberDefinition__Group_4__0 )? | 19441 | // InternalSolverLanguageParser.g:6268:2: ( rule__MemberDefinition__Group_4__0 )? |
21193 | { | 19442 | { |
21194 | if ( state.backtracking==0 ) { | 19443 | before(grammarAccess.getMemberDefinitionAccess().getGroup_4()); |
21195 | before(grammarAccess.getMemberDefinitionAccess().getGroup_4()); | 19444 | // InternalSolverLanguageParser.g:6269:2: ( rule__MemberDefinition__Group_4__0 )? |
21196 | } | 19445 | int alt48=2; |
21197 | // InternalSolverLanguage.g:6325:2: ( rule__MemberDefinition__Group_4__0 )? | 19446 | int LA48_0 = input.LA(1); |
21198 | int alt49=2; | ||
21199 | int LA49_0 = input.LA(1); | ||
21200 | 19447 | ||
21201 | if ( (LA49_0==70) ) { | 19448 | if ( (LA48_0==Opposite) ) { |
21202 | alt49=1; | 19449 | alt48=1; |
21203 | } | 19450 | } |
21204 | switch (alt49) { | 19451 | switch (alt48) { |
21205 | case 1 : | 19452 | case 1 : |
21206 | // InternalSolverLanguage.g:6325:3: rule__MemberDefinition__Group_4__0 | 19453 | // InternalSolverLanguageParser.g:6269:3: rule__MemberDefinition__Group_4__0 |
21207 | { | 19454 | { |
21208 | pushFollow(FOLLOW_2); | 19455 | pushFollow(FOLLOW_2); |
21209 | rule__MemberDefinition__Group_4__0(); | 19456 | rule__MemberDefinition__Group_4__0(); |
21210 | 19457 | ||
21211 | state._fsp--; | 19458 | state._fsp--; |
21212 | if (state.failed) return ; | 19459 | |
21213 | 19460 | ||
21214 | } | 19461 | } |
21215 | break; | 19462 | break; |
21216 | 19463 | ||
21217 | } | 19464 | } |
21218 | 19465 | ||
21219 | if ( state.backtracking==0 ) { | 19466 | after(grammarAccess.getMemberDefinitionAccess().getGroup_4()); |
21220 | after(grammarAccess.getMemberDefinitionAccess().getGroup_4()); | ||
21221 | } | ||
21222 | 19467 | ||
21223 | } | 19468 | } |
21224 | 19469 | ||
@@ -21241,20 +19486,20 @@ public class InternalSolverLanguageParser extends AbstractInternalContentAssistP | |||
21241 | 19486 | ||
21242 | 19487 | ||
21243 | // $ANTLR start "rule__MemberDefinition__Group__5" | 19488 | // $ANTLR start "rule__MemberDefinition__Group__5" |
21244 | // InternalSolverLanguage.g:6333:1: rule__MemberDefinition__Group__5 : rule__MemberDefinition__Group__5__Impl ; | 19489 | // InternalSolverLanguageParser.g:6277:1: rule__MemberDefinition__Group__5 : rule__MemberDefinition__Group__5__Impl ; |
21245 | public final void rule__MemberDefinition__Group__5() throws RecognitionException { | 19490 | public final void rule__MemberDefinition__Group__5() throws RecognitionException { |
21246 | 19491 | ||
21247 | int stackSize = keepStackSize(); | 19492 | int stackSize = keepStackSize(); |
21248 | 19493 | ||
21249 | try { | 19494 | try { |
21250 | // InternalSolverLanguage.g:6337:1: ( rule__MemberDefinition__Group__5__Impl ) | 19495 | // InternalSolverLanguageParser.g:6281:1: ( rule__MemberDefinition__Group__5__Impl ) |
21251 | // InternalSolverLanguage.g:6338:2: rule__MemberDefinition__Group__5__Impl | 19496 | // InternalSolverLanguageParser.g:6282:2: rule__MemberDefinition__Group__5__Impl |
21252 | { | 19497 | { |
21253 | pushFollow(FOLLOW_2); | 19498 | pushFollow(FOLLOW_2); |
21254 | rule__MemberDefinition__Group__5__Impl(); | 19499 | rule__MemberDefinition__Group__5__Impl(); |
21255 | 19500 | ||
21256 | state._fsp--; | 19501 | state._fsp--; |
21257 | if (state.failed) return ; | 19502 | |
21258 | 19503 | ||
21259 | } | 19504 | } |
21260 | 19505 | ||
@@ -21274,42 +19519,38 @@ public class InternalSolverLanguageParser extends AbstractInternalContentAssistP | |||
21274 | 19519 | ||
21275 | 19520 | ||
21276 | // $ANTLR start "rule__MemberDefinition__Group__5__Impl" | 19521 | // $ANTLR start "rule__MemberDefinition__Group__5__Impl" |
21277 | // InternalSolverLanguage.g:6344:1: rule__MemberDefinition__Group__5__Impl : ( ( ';' )? ) ; | 19522 | // InternalSolverLanguageParser.g:6288:1: rule__MemberDefinition__Group__5__Impl : ( ( Semicolon )? ) ; |
21278 | public final void rule__MemberDefinition__Group__5__Impl() throws RecognitionException { | 19523 | public final void rule__MemberDefinition__Group__5__Impl() throws RecognitionException { |
21279 | 19524 | ||
21280 | int stackSize = keepStackSize(); | 19525 | int stackSize = keepStackSize(); |
21281 | 19526 | ||
21282 | try { | 19527 | try { |
21283 | // InternalSolverLanguage.g:6348:1: ( ( ( ';' )? ) ) | 19528 | // InternalSolverLanguageParser.g:6292:1: ( ( ( Semicolon )? ) ) |
21284 | // InternalSolverLanguage.g:6349:1: ( ( ';' )? ) | 19529 | // InternalSolverLanguageParser.g:6293:1: ( ( Semicolon )? ) |
21285 | { | 19530 | { |
21286 | // InternalSolverLanguage.g:6349:1: ( ( ';' )? ) | 19531 | // InternalSolverLanguageParser.g:6293:1: ( ( Semicolon )? ) |
21287 | // InternalSolverLanguage.g:6350:2: ( ';' )? | 19532 | // InternalSolverLanguageParser.g:6294:2: ( Semicolon )? |
21288 | { | 19533 | { |
21289 | if ( state.backtracking==0 ) { | 19534 | before(grammarAccess.getMemberDefinitionAccess().getSemicolonKeyword_5()); |
21290 | before(grammarAccess.getMemberDefinitionAccess().getSemicolonKeyword_5()); | 19535 | // InternalSolverLanguageParser.g:6295:2: ( Semicolon )? |
21291 | } | 19536 | int alt49=2; |
21292 | // InternalSolverLanguage.g:6351:2: ( ';' )? | 19537 | int LA49_0 = input.LA(1); |
21293 | int alt50=2; | ||
21294 | int LA50_0 = input.LA(1); | ||
21295 | 19538 | ||
21296 | if ( (LA50_0==54) ) { | 19539 | if ( (LA49_0==Semicolon) ) { |
21297 | alt50=1; | 19540 | alt49=1; |
21298 | } | 19541 | } |
21299 | switch (alt50) { | 19542 | switch (alt49) { |
21300 | case 1 : | 19543 | case 1 : |
21301 | // InternalSolverLanguage.g:6351:3: ';' | 19544 | // InternalSolverLanguageParser.g:6295:3: Semicolon |
21302 | { | 19545 | { |
21303 | match(input,54,FOLLOW_2); if (state.failed) return ; | 19546 | match(input,Semicolon,FOLLOW_2); |
21304 | 19547 | ||
21305 | } | 19548 | } |
21306 | break; | 19549 | break; |
21307 | 19550 | ||
21308 | } | 19551 | } |
21309 | 19552 | ||
21310 | if ( state.backtracking==0 ) { | 19553 | after(grammarAccess.getMemberDefinitionAccess().getSemicolonKeyword_5()); |
21311 | after(grammarAccess.getMemberDefinitionAccess().getSemicolonKeyword_5()); | ||
21312 | } | ||
21313 | 19554 | ||
21314 | } | 19555 | } |
21315 | 19556 | ||
@@ -21332,25 +19573,25 @@ public class InternalSolverLanguageParser extends AbstractInternalContentAssistP | |||
21332 | 19573 | ||
21333 | 19574 | ||
21334 | // $ANTLR start "rule__MemberDefinition__Group_4__0" | 19575 | // $ANTLR start "rule__MemberDefinition__Group_4__0" |
21335 | // InternalSolverLanguage.g:6360:1: rule__MemberDefinition__Group_4__0 : rule__MemberDefinition__Group_4__0__Impl rule__MemberDefinition__Group_4__1 ; | 19576 | // InternalSolverLanguageParser.g:6304:1: rule__MemberDefinition__Group_4__0 : rule__MemberDefinition__Group_4__0__Impl rule__MemberDefinition__Group_4__1 ; |
21336 | public final void rule__MemberDefinition__Group_4__0() throws RecognitionException { | 19577 | public final void rule__MemberDefinition__Group_4__0() throws RecognitionException { |
21337 | 19578 | ||
21338 | int stackSize = keepStackSize(); | 19579 | int stackSize = keepStackSize(); |
21339 | 19580 | ||
21340 | try { | 19581 | try { |
21341 | // InternalSolverLanguage.g:6364:1: ( rule__MemberDefinition__Group_4__0__Impl rule__MemberDefinition__Group_4__1 ) | 19582 | // InternalSolverLanguageParser.g:6308:1: ( rule__MemberDefinition__Group_4__0__Impl rule__MemberDefinition__Group_4__1 ) |
21342 | // InternalSolverLanguage.g:6365:2: rule__MemberDefinition__Group_4__0__Impl rule__MemberDefinition__Group_4__1 | 19583 | // InternalSolverLanguageParser.g:6309:2: rule__MemberDefinition__Group_4__0__Impl rule__MemberDefinition__Group_4__1 |
21343 | { | 19584 | { |
21344 | pushFollow(FOLLOW_9); | 19585 | pushFollow(FOLLOW_9); |
21345 | rule__MemberDefinition__Group_4__0__Impl(); | 19586 | rule__MemberDefinition__Group_4__0__Impl(); |
21346 | 19587 | ||
21347 | state._fsp--; | 19588 | state._fsp--; |
21348 | if (state.failed) return ; | 19589 | |
21349 | pushFollow(FOLLOW_2); | 19590 | pushFollow(FOLLOW_2); |
21350 | rule__MemberDefinition__Group_4__1(); | 19591 | rule__MemberDefinition__Group_4__1(); |
21351 | 19592 | ||
21352 | state._fsp--; | 19593 | state._fsp--; |
21353 | if (state.failed) return ; | 19594 | |
21354 | 19595 | ||
21355 | } | 19596 | } |
21356 | 19597 | ||
@@ -21370,25 +19611,21 @@ public class InternalSolverLanguageParser extends AbstractInternalContentAssistP | |||
21370 | 19611 | ||
21371 | 19612 | ||
21372 | // $ANTLR start "rule__MemberDefinition__Group_4__0__Impl" | 19613 | // $ANTLR start "rule__MemberDefinition__Group_4__0__Impl" |
21373 | // InternalSolverLanguage.g:6372:1: rule__MemberDefinition__Group_4__0__Impl : ( 'opposite' ) ; | 19614 | // InternalSolverLanguageParser.g:6316:1: rule__MemberDefinition__Group_4__0__Impl : ( Opposite ) ; |
21374 | public final void rule__MemberDefinition__Group_4__0__Impl() throws RecognitionException { | 19615 | public final void rule__MemberDefinition__Group_4__0__Impl() throws RecognitionException { |
21375 | 19616 | ||
21376 | int stackSize = keepStackSize(); | 19617 | int stackSize = keepStackSize(); |
21377 | 19618 | ||
21378 | try { | 19619 | try { |
21379 | // InternalSolverLanguage.g:6376:1: ( ( 'opposite' ) ) | 19620 | // InternalSolverLanguageParser.g:6320:1: ( ( Opposite ) ) |
21380 | // InternalSolverLanguage.g:6377:1: ( 'opposite' ) | 19621 | // InternalSolverLanguageParser.g:6321:1: ( Opposite ) |
21381 | { | 19622 | { |
21382 | // InternalSolverLanguage.g:6377:1: ( 'opposite' ) | 19623 | // InternalSolverLanguageParser.g:6321:1: ( Opposite ) |
21383 | // InternalSolverLanguage.g:6378:2: 'opposite' | 19624 | // InternalSolverLanguageParser.g:6322:2: Opposite |
21384 | { | 19625 | { |
21385 | if ( state.backtracking==0 ) { | 19626 | before(grammarAccess.getMemberDefinitionAccess().getOppositeKeyword_4_0()); |
21386 | before(grammarAccess.getMemberDefinitionAccess().getOppositeKeyword_4_0()); | 19627 | match(input,Opposite,FOLLOW_2); |
21387 | } | 19628 | after(grammarAccess.getMemberDefinitionAccess().getOppositeKeyword_4_0()); |
21388 | match(input,70,FOLLOW_2); if (state.failed) return ; | ||
21389 | if ( state.backtracking==0 ) { | ||
21390 | after(grammarAccess.getMemberDefinitionAccess().getOppositeKeyword_4_0()); | ||
21391 | } | ||
21392 | 19629 | ||
21393 | } | 19630 | } |
21394 | 19631 | ||
@@ -21411,20 +19648,20 @@ public class InternalSolverLanguageParser extends AbstractInternalContentAssistP | |||
21411 | 19648 | ||
21412 | 19649 | ||
21413 | // $ANTLR start "rule__MemberDefinition__Group_4__1" | 19650 | // $ANTLR start "rule__MemberDefinition__Group_4__1" |
21414 | // InternalSolverLanguage.g:6387:1: rule__MemberDefinition__Group_4__1 : rule__MemberDefinition__Group_4__1__Impl ; | 19651 | // InternalSolverLanguageParser.g:6331:1: rule__MemberDefinition__Group_4__1 : rule__MemberDefinition__Group_4__1__Impl ; |
21415 | public final void rule__MemberDefinition__Group_4__1() throws RecognitionException { | 19652 | public final void rule__MemberDefinition__Group_4__1() throws RecognitionException { |
21416 | 19653 | ||
21417 | int stackSize = keepStackSize(); | 19654 | int stackSize = keepStackSize(); |
21418 | 19655 | ||
21419 | try { | 19656 | try { |
21420 | // InternalSolverLanguage.g:6391:1: ( rule__MemberDefinition__Group_4__1__Impl ) | 19657 | // InternalSolverLanguageParser.g:6335:1: ( rule__MemberDefinition__Group_4__1__Impl ) |
21421 | // InternalSolverLanguage.g:6392:2: rule__MemberDefinition__Group_4__1__Impl | 19658 | // InternalSolverLanguageParser.g:6336:2: rule__MemberDefinition__Group_4__1__Impl |
21422 | { | 19659 | { |
21423 | pushFollow(FOLLOW_2); | 19660 | pushFollow(FOLLOW_2); |
21424 | rule__MemberDefinition__Group_4__1__Impl(); | 19661 | rule__MemberDefinition__Group_4__1__Impl(); |
21425 | 19662 | ||
21426 | state._fsp--; | 19663 | state._fsp--; |
21427 | if (state.failed) return ; | 19664 | |
21428 | 19665 | ||
21429 | } | 19666 | } |
21430 | 19667 | ||
@@ -21444,36 +19681,32 @@ public class InternalSolverLanguageParser extends AbstractInternalContentAssistP | |||
21444 | 19681 | ||
21445 | 19682 | ||
21446 | // $ANTLR start "rule__MemberDefinition__Group_4__1__Impl" | 19683 | // $ANTLR start "rule__MemberDefinition__Group_4__1__Impl" |
21447 | // InternalSolverLanguage.g:6398:1: rule__MemberDefinition__Group_4__1__Impl : ( ( rule__MemberDefinition__OppositeAssignment_4_1 ) ) ; | 19684 | // InternalSolverLanguageParser.g:6342:1: rule__MemberDefinition__Group_4__1__Impl : ( ( rule__MemberDefinition__OppositeAssignment_4_1 ) ) ; |
21448 | public final void rule__MemberDefinition__Group_4__1__Impl() throws RecognitionException { | 19685 | public final void rule__MemberDefinition__Group_4__1__Impl() throws RecognitionException { |
21449 | 19686 | ||
21450 | int stackSize = keepStackSize(); | 19687 | int stackSize = keepStackSize(); |
21451 | 19688 | ||
21452 | try { | 19689 | try { |
21453 | // InternalSolverLanguage.g:6402:1: ( ( ( rule__MemberDefinition__OppositeAssignment_4_1 ) ) ) | 19690 | // InternalSolverLanguageParser.g:6346:1: ( ( ( rule__MemberDefinition__OppositeAssignment_4_1 ) ) ) |
21454 | // InternalSolverLanguage.g:6403:1: ( ( rule__MemberDefinition__OppositeAssignment_4_1 ) ) | 19691 | // InternalSolverLanguageParser.g:6347:1: ( ( rule__MemberDefinition__OppositeAssignment_4_1 ) ) |
21455 | { | 19692 | { |
21456 | // InternalSolverLanguage.g:6403:1: ( ( rule__MemberDefinition__OppositeAssignment_4_1 ) ) | 19693 | // InternalSolverLanguageParser.g:6347:1: ( ( rule__MemberDefinition__OppositeAssignment_4_1 ) ) |
21457 | // InternalSolverLanguage.g:6404:2: ( rule__MemberDefinition__OppositeAssignment_4_1 ) | 19694 | // InternalSolverLanguageParser.g:6348:2: ( rule__MemberDefinition__OppositeAssignment_4_1 ) |
21458 | { | 19695 | { |
21459 | if ( state.backtracking==0 ) { | 19696 | before(grammarAccess.getMemberDefinitionAccess().getOppositeAssignment_4_1()); |
21460 | before(grammarAccess.getMemberDefinitionAccess().getOppositeAssignment_4_1()); | 19697 | // InternalSolverLanguageParser.g:6349:2: ( rule__MemberDefinition__OppositeAssignment_4_1 ) |
21461 | } | 19698 | // InternalSolverLanguageParser.g:6349:3: rule__MemberDefinition__OppositeAssignment_4_1 |
21462 | // InternalSolverLanguage.g:6405:2: ( rule__MemberDefinition__OppositeAssignment_4_1 ) | ||
21463 | // InternalSolverLanguage.g:6405:3: rule__MemberDefinition__OppositeAssignment_4_1 | ||
21464 | { | 19699 | { |
21465 | pushFollow(FOLLOW_2); | 19700 | pushFollow(FOLLOW_2); |
21466 | rule__MemberDefinition__OppositeAssignment_4_1(); | 19701 | rule__MemberDefinition__OppositeAssignment_4_1(); |
21467 | 19702 | ||
21468 | state._fsp--; | 19703 | state._fsp--; |
21469 | if (state.failed) return ; | ||
21470 | 19704 | ||
21471 | } | ||
21472 | 19705 | ||
21473 | if ( state.backtracking==0 ) { | ||
21474 | after(grammarAccess.getMemberDefinitionAccess().getOppositeAssignment_4_1()); | ||
21475 | } | 19706 | } |
21476 | 19707 | ||
19708 | after(grammarAccess.getMemberDefinitionAccess().getOppositeAssignment_4_1()); | ||
19709 | |||
21477 | } | 19710 | } |
21478 | 19711 | ||
21479 | 19712 | ||
@@ -21495,25 +19728,25 @@ public class InternalSolverLanguageParser extends AbstractInternalContentAssistP | |||
21495 | 19728 | ||
21496 | 19729 | ||
21497 | // $ANTLR start "rule__ManyMultiplicity__Group__0" | 19730 | // $ANTLR start "rule__ManyMultiplicity__Group__0" |
21498 | // InternalSolverLanguage.g:6414:1: rule__ManyMultiplicity__Group__0 : rule__ManyMultiplicity__Group__0__Impl rule__ManyMultiplicity__Group__1 ; | 19731 | // InternalSolverLanguageParser.g:6358:1: rule__ManyMultiplicity__Group__0 : rule__ManyMultiplicity__Group__0__Impl rule__ManyMultiplicity__Group__1 ; |
21499 | public final void rule__ManyMultiplicity__Group__0() throws RecognitionException { | 19732 | public final void rule__ManyMultiplicity__Group__0() throws RecognitionException { |
21500 | 19733 | ||
21501 | int stackSize = keepStackSize(); | 19734 | int stackSize = keepStackSize(); |
21502 | 19735 | ||
21503 | try { | 19736 | try { |
21504 | // InternalSolverLanguage.g:6418:1: ( rule__ManyMultiplicity__Group__0__Impl rule__ManyMultiplicity__Group__1 ) | 19737 | // InternalSolverLanguageParser.g:6362:1: ( rule__ManyMultiplicity__Group__0__Impl rule__ManyMultiplicity__Group__1 ) |
21505 | // InternalSolverLanguage.g:6419:2: rule__ManyMultiplicity__Group__0__Impl rule__ManyMultiplicity__Group__1 | 19738 | // InternalSolverLanguageParser.g:6363:2: rule__ManyMultiplicity__Group__0__Impl rule__ManyMultiplicity__Group__1 |
21506 | { | 19739 | { |
21507 | pushFollow(FOLLOW_51); | 19740 | pushFollow(FOLLOW_50); |
21508 | rule__ManyMultiplicity__Group__0__Impl(); | 19741 | rule__ManyMultiplicity__Group__0__Impl(); |
21509 | 19742 | ||
21510 | state._fsp--; | 19743 | state._fsp--; |
21511 | if (state.failed) return ; | 19744 | |
21512 | pushFollow(FOLLOW_2); | 19745 | pushFollow(FOLLOW_2); |
21513 | rule__ManyMultiplicity__Group__1(); | 19746 | rule__ManyMultiplicity__Group__1(); |
21514 | 19747 | ||
21515 | state._fsp--; | 19748 | state._fsp--; |
21516 | if (state.failed) return ; | 19749 | |
21517 | 19750 | ||
21518 | } | 19751 | } |
21519 | 19752 | ||
@@ -21533,29 +19766,25 @@ public class InternalSolverLanguageParser extends AbstractInternalContentAssistP | |||
21533 | 19766 | ||
21534 | 19767 | ||
21535 | // $ANTLR start "rule__ManyMultiplicity__Group__0__Impl" | 19768 | // $ANTLR start "rule__ManyMultiplicity__Group__0__Impl" |
21536 | // InternalSolverLanguage.g:6426:1: rule__ManyMultiplicity__Group__0__Impl : ( () ) ; | 19769 | // InternalSolverLanguageParser.g:6370:1: rule__ManyMultiplicity__Group__0__Impl : ( () ) ; |
21537 | public final void rule__ManyMultiplicity__Group__0__Impl() throws RecognitionException { | 19770 | public final void rule__ManyMultiplicity__Group__0__Impl() throws RecognitionException { |
21538 | 19771 | ||
21539 | int stackSize = keepStackSize(); | 19772 | int stackSize = keepStackSize(); |
21540 | 19773 | ||
21541 | try { | 19774 | try { |
21542 | // InternalSolverLanguage.g:6430:1: ( ( () ) ) | 19775 | // InternalSolverLanguageParser.g:6374:1: ( ( () ) ) |
21543 | // InternalSolverLanguage.g:6431:1: ( () ) | 19776 | // InternalSolverLanguageParser.g:6375:1: ( () ) |
21544 | { | 19777 | { |
21545 | // InternalSolverLanguage.g:6431:1: ( () ) | 19778 | // InternalSolverLanguageParser.g:6375:1: ( () ) |
21546 | // InternalSolverLanguage.g:6432:2: () | 19779 | // InternalSolverLanguageParser.g:6376:2: () |
21547 | { | 19780 | { |
21548 | if ( state.backtracking==0 ) { | 19781 | before(grammarAccess.getManyMultiplicityAccess().getManyMultiplicityAction_0()); |
21549 | before(grammarAccess.getManyMultiplicityAccess().getManyMultiplicityAction_0()); | 19782 | // InternalSolverLanguageParser.g:6377:2: () |
21550 | } | 19783 | // InternalSolverLanguageParser.g:6377:3: |
21551 | // InternalSolverLanguage.g:6433:2: () | ||
21552 | // InternalSolverLanguage.g:6433:3: | ||
21553 | { | 19784 | { |
21554 | } | 19785 | } |
21555 | 19786 | ||
21556 | if ( state.backtracking==0 ) { | 19787 | after(grammarAccess.getManyMultiplicityAccess().getManyMultiplicityAction_0()); |
21557 | after(grammarAccess.getManyMultiplicityAccess().getManyMultiplicityAction_0()); | ||
21558 | } | ||
21559 | 19788 | ||
21560 | } | 19789 | } |
21561 | 19790 | ||
@@ -21574,25 +19803,25 @@ public class InternalSolverLanguageParser extends AbstractInternalContentAssistP | |||
21574 | 19803 | ||
21575 | 19804 | ||
21576 | // $ANTLR start "rule__ManyMultiplicity__Group__1" | 19805 | // $ANTLR start "rule__ManyMultiplicity__Group__1" |
21577 | // InternalSolverLanguage.g:6441:1: rule__ManyMultiplicity__Group__1 : rule__ManyMultiplicity__Group__1__Impl rule__ManyMultiplicity__Group__2 ; | 19806 | // InternalSolverLanguageParser.g:6385:1: rule__ManyMultiplicity__Group__1 : rule__ManyMultiplicity__Group__1__Impl rule__ManyMultiplicity__Group__2 ; |
21578 | public final void rule__ManyMultiplicity__Group__1() throws RecognitionException { | 19807 | public final void rule__ManyMultiplicity__Group__1() throws RecognitionException { |
21579 | 19808 | ||
21580 | int stackSize = keepStackSize(); | 19809 | int stackSize = keepStackSize(); |
21581 | 19810 | ||
21582 | try { | 19811 | try { |
21583 | // InternalSolverLanguage.g:6445:1: ( rule__ManyMultiplicity__Group__1__Impl rule__ManyMultiplicity__Group__2 ) | 19812 | // InternalSolverLanguageParser.g:6389:1: ( rule__ManyMultiplicity__Group__1__Impl rule__ManyMultiplicity__Group__2 ) |
21584 | // InternalSolverLanguage.g:6446:2: rule__ManyMultiplicity__Group__1__Impl rule__ManyMultiplicity__Group__2 | 19813 | // InternalSolverLanguageParser.g:6390:2: rule__ManyMultiplicity__Group__1__Impl rule__ManyMultiplicity__Group__2 |
21585 | { | 19814 | { |
21586 | pushFollow(FOLLOW_40); | 19815 | pushFollow(FOLLOW_39); |
21587 | rule__ManyMultiplicity__Group__1__Impl(); | 19816 | rule__ManyMultiplicity__Group__1__Impl(); |
21588 | 19817 | ||
21589 | state._fsp--; | 19818 | state._fsp--; |
21590 | if (state.failed) return ; | 19819 | |
21591 | pushFollow(FOLLOW_2); | 19820 | pushFollow(FOLLOW_2); |
21592 | rule__ManyMultiplicity__Group__2(); | 19821 | rule__ManyMultiplicity__Group__2(); |
21593 | 19822 | ||
21594 | state._fsp--; | 19823 | state._fsp--; |
21595 | if (state.failed) return ; | 19824 | |
21596 | 19825 | ||
21597 | } | 19826 | } |
21598 | 19827 | ||
@@ -21612,25 +19841,21 @@ public class InternalSolverLanguageParser extends AbstractInternalContentAssistP | |||
21612 | 19841 | ||
21613 | 19842 | ||
21614 | // $ANTLR start "rule__ManyMultiplicity__Group__1__Impl" | 19843 | // $ANTLR start "rule__ManyMultiplicity__Group__1__Impl" |
21615 | // InternalSolverLanguage.g:6453:1: rule__ManyMultiplicity__Group__1__Impl : ( '[' ) ; | 19844 | // InternalSolverLanguageParser.g:6397:1: rule__ManyMultiplicity__Group__1__Impl : ( LeftSquareBracket ) ; |
21616 | public final void rule__ManyMultiplicity__Group__1__Impl() throws RecognitionException { | 19845 | public final void rule__ManyMultiplicity__Group__1__Impl() throws RecognitionException { |
21617 | 19846 | ||
21618 | int stackSize = keepStackSize(); | 19847 | int stackSize = keepStackSize(); |
21619 | 19848 | ||
21620 | try { | 19849 | try { |
21621 | // InternalSolverLanguage.g:6457:1: ( ( '[' ) ) | 19850 | // InternalSolverLanguageParser.g:6401:1: ( ( LeftSquareBracket ) ) |
21622 | // InternalSolverLanguage.g:6458:1: ( '[' ) | 19851 | // InternalSolverLanguageParser.g:6402:1: ( LeftSquareBracket ) |
21623 | { | 19852 | { |
21624 | // InternalSolverLanguage.g:6458:1: ( '[' ) | 19853 | // InternalSolverLanguageParser.g:6402:1: ( LeftSquareBracket ) |
21625 | // InternalSolverLanguage.g:6459:2: '[' | 19854 | // InternalSolverLanguageParser.g:6403:2: LeftSquareBracket |
21626 | { | 19855 | { |
21627 | if ( state.backtracking==0 ) { | 19856 | before(grammarAccess.getManyMultiplicityAccess().getLeftSquareBracketKeyword_1()); |
21628 | before(grammarAccess.getManyMultiplicityAccess().getLeftSquareBracketKeyword_1()); | 19857 | match(input,LeftSquareBracket,FOLLOW_2); |
21629 | } | 19858 | after(grammarAccess.getManyMultiplicityAccess().getLeftSquareBracketKeyword_1()); |
21630 | match(input,63,FOLLOW_2); if (state.failed) return ; | ||
21631 | if ( state.backtracking==0 ) { | ||
21632 | after(grammarAccess.getManyMultiplicityAccess().getLeftSquareBracketKeyword_1()); | ||
21633 | } | ||
21634 | 19859 | ||
21635 | } | 19860 | } |
21636 | 19861 | ||
@@ -21653,20 +19878,20 @@ public class InternalSolverLanguageParser extends AbstractInternalContentAssistP | |||
21653 | 19878 | ||
21654 | 19879 | ||
21655 | // $ANTLR start "rule__ManyMultiplicity__Group__2" | 19880 | // $ANTLR start "rule__ManyMultiplicity__Group__2" |
21656 | // InternalSolverLanguage.g:6468:1: rule__ManyMultiplicity__Group__2 : rule__ManyMultiplicity__Group__2__Impl ; | 19881 | // InternalSolverLanguageParser.g:6412:1: rule__ManyMultiplicity__Group__2 : rule__ManyMultiplicity__Group__2__Impl ; |
21657 | public final void rule__ManyMultiplicity__Group__2() throws RecognitionException { | 19882 | public final void rule__ManyMultiplicity__Group__2() throws RecognitionException { |
21658 | 19883 | ||
21659 | int stackSize = keepStackSize(); | 19884 | int stackSize = keepStackSize(); |
21660 | 19885 | ||
21661 | try { | 19886 | try { |
21662 | // InternalSolverLanguage.g:6472:1: ( rule__ManyMultiplicity__Group__2__Impl ) | 19887 | // InternalSolverLanguageParser.g:6416:1: ( rule__ManyMultiplicity__Group__2__Impl ) |
21663 | // InternalSolverLanguage.g:6473:2: rule__ManyMultiplicity__Group__2__Impl | 19888 | // InternalSolverLanguageParser.g:6417:2: rule__ManyMultiplicity__Group__2__Impl |
21664 | { | 19889 | { |
21665 | pushFollow(FOLLOW_2); | 19890 | pushFollow(FOLLOW_2); |
21666 | rule__ManyMultiplicity__Group__2__Impl(); | 19891 | rule__ManyMultiplicity__Group__2__Impl(); |
21667 | 19892 | ||
21668 | state._fsp--; | 19893 | state._fsp--; |
21669 | if (state.failed) return ; | 19894 | |
21670 | 19895 | ||
21671 | } | 19896 | } |
21672 | 19897 | ||
@@ -21686,25 +19911,21 @@ public class InternalSolverLanguageParser extends AbstractInternalContentAssistP | |||
21686 | 19911 | ||
21687 | 19912 | ||
21688 | // $ANTLR start "rule__ManyMultiplicity__Group__2__Impl" | 19913 | // $ANTLR start "rule__ManyMultiplicity__Group__2__Impl" |
21689 | // InternalSolverLanguage.g:6479:1: rule__ManyMultiplicity__Group__2__Impl : ( ']' ) ; | 19914 | // InternalSolverLanguageParser.g:6423:1: rule__ManyMultiplicity__Group__2__Impl : ( RightSquareBracket ) ; |
21690 | public final void rule__ManyMultiplicity__Group__2__Impl() throws RecognitionException { | 19915 | public final void rule__ManyMultiplicity__Group__2__Impl() throws RecognitionException { |
21691 | 19916 | ||
21692 | int stackSize = keepStackSize(); | 19917 | int stackSize = keepStackSize(); |
21693 | 19918 | ||
21694 | try { | 19919 | try { |
21695 | // InternalSolverLanguage.g:6483:1: ( ( ']' ) ) | 19920 | // InternalSolverLanguageParser.g:6427:1: ( ( RightSquareBracket ) ) |
21696 | // InternalSolverLanguage.g:6484:1: ( ']' ) | 19921 | // InternalSolverLanguageParser.g:6428:1: ( RightSquareBracket ) |
21697 | { | 19922 | { |
21698 | // InternalSolverLanguage.g:6484:1: ( ']' ) | 19923 | // InternalSolverLanguageParser.g:6428:1: ( RightSquareBracket ) |
21699 | // InternalSolverLanguage.g:6485:2: ']' | 19924 | // InternalSolverLanguageParser.g:6429:2: RightSquareBracket |
21700 | { | 19925 | { |
21701 | if ( state.backtracking==0 ) { | 19926 | before(grammarAccess.getManyMultiplicityAccess().getRightSquareBracketKeyword_2()); |
21702 | before(grammarAccess.getManyMultiplicityAccess().getRightSquareBracketKeyword_2()); | 19927 | match(input,RightSquareBracket,FOLLOW_2); |
21703 | } | 19928 | after(grammarAccess.getManyMultiplicityAccess().getRightSquareBracketKeyword_2()); |
21704 | match(input,65,FOLLOW_2); if (state.failed) return ; | ||
21705 | if ( state.backtracking==0 ) { | ||
21706 | after(grammarAccess.getManyMultiplicityAccess().getRightSquareBracketKeyword_2()); | ||
21707 | } | ||
21708 | 19929 | ||
21709 | } | 19930 | } |
21710 | 19931 | ||
@@ -21727,25 +19948,25 @@ public class InternalSolverLanguageParser extends AbstractInternalContentAssistP | |||
21727 | 19948 | ||
21728 | 19949 | ||
21729 | // $ANTLR start "rule__ExactMultiplicity__Group__0" | 19950 | // $ANTLR start "rule__ExactMultiplicity__Group__0" |
21730 | // InternalSolverLanguage.g:6495:1: rule__ExactMultiplicity__Group__0 : rule__ExactMultiplicity__Group__0__Impl rule__ExactMultiplicity__Group__1 ; | 19951 | // InternalSolverLanguageParser.g:6439:1: rule__ExactMultiplicity__Group__0 : rule__ExactMultiplicity__Group__0__Impl rule__ExactMultiplicity__Group__1 ; |
21731 | public final void rule__ExactMultiplicity__Group__0() throws RecognitionException { | 19952 | public final void rule__ExactMultiplicity__Group__0() throws RecognitionException { |
21732 | 19953 | ||
21733 | int stackSize = keepStackSize(); | 19954 | int stackSize = keepStackSize(); |
21734 | 19955 | ||
21735 | try { | 19956 | try { |
21736 | // InternalSolverLanguage.g:6499:1: ( rule__ExactMultiplicity__Group__0__Impl rule__ExactMultiplicity__Group__1 ) | 19957 | // InternalSolverLanguageParser.g:6443:1: ( rule__ExactMultiplicity__Group__0__Impl rule__ExactMultiplicity__Group__1 ) |
21737 | // InternalSolverLanguage.g:6500:2: rule__ExactMultiplicity__Group__0__Impl rule__ExactMultiplicity__Group__1 | 19958 | // InternalSolverLanguageParser.g:6444:2: rule__ExactMultiplicity__Group__0__Impl rule__ExactMultiplicity__Group__1 |
21738 | { | 19959 | { |
21739 | pushFollow(FOLLOW_52); | 19960 | pushFollow(FOLLOW_51); |
21740 | rule__ExactMultiplicity__Group__0__Impl(); | 19961 | rule__ExactMultiplicity__Group__0__Impl(); |
21741 | 19962 | ||
21742 | state._fsp--; | 19963 | state._fsp--; |
21743 | if (state.failed) return ; | 19964 | |
21744 | pushFollow(FOLLOW_2); | 19965 | pushFollow(FOLLOW_2); |
21745 | rule__ExactMultiplicity__Group__1(); | 19966 | rule__ExactMultiplicity__Group__1(); |
21746 | 19967 | ||
21747 | state._fsp--; | 19968 | state._fsp--; |
21748 | if (state.failed) return ; | 19969 | |
21749 | 19970 | ||
21750 | } | 19971 | } |
21751 | 19972 | ||
@@ -21765,25 +19986,21 @@ public class InternalSolverLanguageParser extends AbstractInternalContentAssistP | |||
21765 | 19986 | ||
21766 | 19987 | ||
21767 | // $ANTLR start "rule__ExactMultiplicity__Group__0__Impl" | 19988 | // $ANTLR start "rule__ExactMultiplicity__Group__0__Impl" |
21768 | // InternalSolverLanguage.g:6507:1: rule__ExactMultiplicity__Group__0__Impl : ( '[' ) ; | 19989 | // InternalSolverLanguageParser.g:6451:1: rule__ExactMultiplicity__Group__0__Impl : ( LeftSquareBracket ) ; |
21769 | public final void rule__ExactMultiplicity__Group__0__Impl() throws RecognitionException { | 19990 | public final void rule__ExactMultiplicity__Group__0__Impl() throws RecognitionException { |
21770 | 19991 | ||
21771 | int stackSize = keepStackSize(); | 19992 | int stackSize = keepStackSize(); |
21772 | 19993 | ||
21773 | try { | 19994 | try { |
21774 | // InternalSolverLanguage.g:6511:1: ( ( '[' ) ) | 19995 | // InternalSolverLanguageParser.g:6455:1: ( ( LeftSquareBracket ) ) |
21775 | // InternalSolverLanguage.g:6512:1: ( '[' ) | 19996 | // InternalSolverLanguageParser.g:6456:1: ( LeftSquareBracket ) |
21776 | { | 19997 | { |
21777 | // InternalSolverLanguage.g:6512:1: ( '[' ) | 19998 | // InternalSolverLanguageParser.g:6456:1: ( LeftSquareBracket ) |
21778 | // InternalSolverLanguage.g:6513:2: '[' | 19999 | // InternalSolverLanguageParser.g:6457:2: LeftSquareBracket |
21779 | { | 20000 | { |
21780 | if ( state.backtracking==0 ) { | 20001 | before(grammarAccess.getExactMultiplicityAccess().getLeftSquareBracketKeyword_0()); |
21781 | before(grammarAccess.getExactMultiplicityAccess().getLeftSquareBracketKeyword_0()); | 20002 | match(input,LeftSquareBracket,FOLLOW_2); |
21782 | } | 20003 | after(grammarAccess.getExactMultiplicityAccess().getLeftSquareBracketKeyword_0()); |
21783 | match(input,63,FOLLOW_2); if (state.failed) return ; | ||
21784 | if ( state.backtracking==0 ) { | ||
21785 | after(grammarAccess.getExactMultiplicityAccess().getLeftSquareBracketKeyword_0()); | ||
21786 | } | ||
21787 | 20004 | ||
21788 | } | 20005 | } |
21789 | 20006 | ||
@@ -21806,25 +20023,25 @@ public class InternalSolverLanguageParser extends AbstractInternalContentAssistP | |||
21806 | 20023 | ||
21807 | 20024 | ||
21808 | // $ANTLR start "rule__ExactMultiplicity__Group__1" | 20025 | // $ANTLR start "rule__ExactMultiplicity__Group__1" |
21809 | // InternalSolverLanguage.g:6522:1: rule__ExactMultiplicity__Group__1 : rule__ExactMultiplicity__Group__1__Impl rule__ExactMultiplicity__Group__2 ; | 20026 | // InternalSolverLanguageParser.g:6466:1: rule__ExactMultiplicity__Group__1 : rule__ExactMultiplicity__Group__1__Impl rule__ExactMultiplicity__Group__2 ; |
21810 | public final void rule__ExactMultiplicity__Group__1() throws RecognitionException { | 20027 | public final void rule__ExactMultiplicity__Group__1() throws RecognitionException { |
21811 | 20028 | ||
21812 | int stackSize = keepStackSize(); | 20029 | int stackSize = keepStackSize(); |
21813 | 20030 | ||
21814 | try { | 20031 | try { |
21815 | // InternalSolverLanguage.g:6526:1: ( rule__ExactMultiplicity__Group__1__Impl rule__ExactMultiplicity__Group__2 ) | 20032 | // InternalSolverLanguageParser.g:6470:1: ( rule__ExactMultiplicity__Group__1__Impl rule__ExactMultiplicity__Group__2 ) |
21816 | // InternalSolverLanguage.g:6527:2: rule__ExactMultiplicity__Group__1__Impl rule__ExactMultiplicity__Group__2 | 20033 | // InternalSolverLanguageParser.g:6471:2: rule__ExactMultiplicity__Group__1__Impl rule__ExactMultiplicity__Group__2 |
21817 | { | 20034 | { |
21818 | pushFollow(FOLLOW_40); | 20035 | pushFollow(FOLLOW_39); |
21819 | rule__ExactMultiplicity__Group__1__Impl(); | 20036 | rule__ExactMultiplicity__Group__1__Impl(); |
21820 | 20037 | ||
21821 | state._fsp--; | 20038 | state._fsp--; |
21822 | if (state.failed) return ; | 20039 | |
21823 | pushFollow(FOLLOW_2); | 20040 | pushFollow(FOLLOW_2); |
21824 | rule__ExactMultiplicity__Group__2(); | 20041 | rule__ExactMultiplicity__Group__2(); |
21825 | 20042 | ||
21826 | state._fsp--; | 20043 | state._fsp--; |
21827 | if (state.failed) return ; | 20044 | |
21828 | 20045 | ||
21829 | } | 20046 | } |
21830 | 20047 | ||
@@ -21844,36 +20061,32 @@ public class InternalSolverLanguageParser extends AbstractInternalContentAssistP | |||
21844 | 20061 | ||
21845 | 20062 | ||
21846 | // $ANTLR start "rule__ExactMultiplicity__Group__1__Impl" | 20063 | // $ANTLR start "rule__ExactMultiplicity__Group__1__Impl" |
21847 | // InternalSolverLanguage.g:6534:1: rule__ExactMultiplicity__Group__1__Impl : ( ( rule__ExactMultiplicity__MultiplicityAssignment_1 ) ) ; | 20064 | // InternalSolverLanguageParser.g:6478:1: rule__ExactMultiplicity__Group__1__Impl : ( ( rule__ExactMultiplicity__MultiplicityAssignment_1 ) ) ; |
21848 | public final void rule__ExactMultiplicity__Group__1__Impl() throws RecognitionException { | 20065 | public final void rule__ExactMultiplicity__Group__1__Impl() throws RecognitionException { |
21849 | 20066 | ||
21850 | int stackSize = keepStackSize(); | 20067 | int stackSize = keepStackSize(); |
21851 | 20068 | ||
21852 | try { | 20069 | try { |
21853 | // InternalSolverLanguage.g:6538:1: ( ( ( rule__ExactMultiplicity__MultiplicityAssignment_1 ) ) ) | 20070 | // InternalSolverLanguageParser.g:6482:1: ( ( ( rule__ExactMultiplicity__MultiplicityAssignment_1 ) ) ) |
21854 | // InternalSolverLanguage.g:6539:1: ( ( rule__ExactMultiplicity__MultiplicityAssignment_1 ) ) | 20071 | // InternalSolverLanguageParser.g:6483:1: ( ( rule__ExactMultiplicity__MultiplicityAssignment_1 ) ) |
21855 | { | 20072 | { |
21856 | // InternalSolverLanguage.g:6539:1: ( ( rule__ExactMultiplicity__MultiplicityAssignment_1 ) ) | 20073 | // InternalSolverLanguageParser.g:6483:1: ( ( rule__ExactMultiplicity__MultiplicityAssignment_1 ) ) |
21857 | // InternalSolverLanguage.g:6540:2: ( rule__ExactMultiplicity__MultiplicityAssignment_1 ) | 20074 | // InternalSolverLanguageParser.g:6484:2: ( rule__ExactMultiplicity__MultiplicityAssignment_1 ) |
21858 | { | 20075 | { |
21859 | if ( state.backtracking==0 ) { | 20076 | before(grammarAccess.getExactMultiplicityAccess().getMultiplicityAssignment_1()); |
21860 | before(grammarAccess.getExactMultiplicityAccess().getMultiplicityAssignment_1()); | 20077 | // InternalSolverLanguageParser.g:6485:2: ( rule__ExactMultiplicity__MultiplicityAssignment_1 ) |
21861 | } | 20078 | // InternalSolverLanguageParser.g:6485:3: rule__ExactMultiplicity__MultiplicityAssignment_1 |
21862 | // InternalSolverLanguage.g:6541:2: ( rule__ExactMultiplicity__MultiplicityAssignment_1 ) | ||
21863 | // InternalSolverLanguage.g:6541:3: rule__ExactMultiplicity__MultiplicityAssignment_1 | ||
21864 | { | 20079 | { |
21865 | pushFollow(FOLLOW_2); | 20080 | pushFollow(FOLLOW_2); |
21866 | rule__ExactMultiplicity__MultiplicityAssignment_1(); | 20081 | rule__ExactMultiplicity__MultiplicityAssignment_1(); |
21867 | 20082 | ||
21868 | state._fsp--; | 20083 | state._fsp--; |
21869 | if (state.failed) return ; | ||
21870 | 20084 | ||
21871 | } | ||
21872 | 20085 | ||
21873 | if ( state.backtracking==0 ) { | ||
21874 | after(grammarAccess.getExactMultiplicityAccess().getMultiplicityAssignment_1()); | ||
21875 | } | 20086 | } |
21876 | 20087 | ||
20088 | after(grammarAccess.getExactMultiplicityAccess().getMultiplicityAssignment_1()); | ||
20089 | |||
21877 | } | 20090 | } |
21878 | 20091 | ||
21879 | 20092 | ||
@@ -21895,20 +20108,20 @@ public class InternalSolverLanguageParser extends AbstractInternalContentAssistP | |||
21895 | 20108 | ||
21896 | 20109 | ||
21897 | // $ANTLR start "rule__ExactMultiplicity__Group__2" | 20110 | // $ANTLR start "rule__ExactMultiplicity__Group__2" |
21898 | // InternalSolverLanguage.g:6549:1: rule__ExactMultiplicity__Group__2 : rule__ExactMultiplicity__Group__2__Impl ; | 20111 | // InternalSolverLanguageParser.g:6493:1: rule__ExactMultiplicity__Group__2 : rule__ExactMultiplicity__Group__2__Impl ; |
21899 | public final void rule__ExactMultiplicity__Group__2() throws RecognitionException { | 20112 | public final void rule__ExactMultiplicity__Group__2() throws RecognitionException { |
21900 | 20113 | ||
21901 | int stackSize = keepStackSize(); | 20114 | int stackSize = keepStackSize(); |
21902 | 20115 | ||
21903 | try { | 20116 | try { |
21904 | // InternalSolverLanguage.g:6553:1: ( rule__ExactMultiplicity__Group__2__Impl ) | 20117 | // InternalSolverLanguageParser.g:6497:1: ( rule__ExactMultiplicity__Group__2__Impl ) |
21905 | // InternalSolverLanguage.g:6554:2: rule__ExactMultiplicity__Group__2__Impl | 20118 | // InternalSolverLanguageParser.g:6498:2: rule__ExactMultiplicity__Group__2__Impl |
21906 | { | 20119 | { |
21907 | pushFollow(FOLLOW_2); | 20120 | pushFollow(FOLLOW_2); |
21908 | rule__ExactMultiplicity__Group__2__Impl(); | 20121 | rule__ExactMultiplicity__Group__2__Impl(); |
21909 | 20122 | ||
21910 | state._fsp--; | 20123 | state._fsp--; |
21911 | if (state.failed) return ; | 20124 | |
21912 | 20125 | ||
21913 | } | 20126 | } |
21914 | 20127 | ||
@@ -21928,25 +20141,21 @@ public class InternalSolverLanguageParser extends AbstractInternalContentAssistP | |||
21928 | 20141 | ||
21929 | 20142 | ||
21930 | // $ANTLR start "rule__ExactMultiplicity__Group__2__Impl" | 20143 | // $ANTLR start "rule__ExactMultiplicity__Group__2__Impl" |
21931 | // InternalSolverLanguage.g:6560:1: rule__ExactMultiplicity__Group__2__Impl : ( ']' ) ; | 20144 | // InternalSolverLanguageParser.g:6504:1: rule__ExactMultiplicity__Group__2__Impl : ( RightSquareBracket ) ; |
21932 | public final void rule__ExactMultiplicity__Group__2__Impl() throws RecognitionException { | 20145 | public final void rule__ExactMultiplicity__Group__2__Impl() throws RecognitionException { |
21933 | 20146 | ||
21934 | int stackSize = keepStackSize(); | 20147 | int stackSize = keepStackSize(); |
21935 | 20148 | ||
21936 | try { | 20149 | try { |
21937 | // InternalSolverLanguage.g:6564:1: ( ( ']' ) ) | 20150 | // InternalSolverLanguageParser.g:6508:1: ( ( RightSquareBracket ) ) |
21938 | // InternalSolverLanguage.g:6565:1: ( ']' ) | 20151 | // InternalSolverLanguageParser.g:6509:1: ( RightSquareBracket ) |
21939 | { | 20152 | { |
21940 | // InternalSolverLanguage.g:6565:1: ( ']' ) | 20153 | // InternalSolverLanguageParser.g:6509:1: ( RightSquareBracket ) |
21941 | // InternalSolverLanguage.g:6566:2: ']' | 20154 | // InternalSolverLanguageParser.g:6510:2: RightSquareBracket |
21942 | { | 20155 | { |
21943 | if ( state.backtracking==0 ) { | 20156 | before(grammarAccess.getExactMultiplicityAccess().getRightSquareBracketKeyword_2()); |
21944 | before(grammarAccess.getExactMultiplicityAccess().getRightSquareBracketKeyword_2()); | 20157 | match(input,RightSquareBracket,FOLLOW_2); |
21945 | } | 20158 | after(grammarAccess.getExactMultiplicityAccess().getRightSquareBracketKeyword_2()); |
21946 | match(input,65,FOLLOW_2); if (state.failed) return ; | ||
21947 | if ( state.backtracking==0 ) { | ||
21948 | after(grammarAccess.getExactMultiplicityAccess().getRightSquareBracketKeyword_2()); | ||
21949 | } | ||
21950 | 20159 | ||
21951 | } | 20160 | } |
21952 | 20161 | ||
@@ -21969,25 +20178,25 @@ public class InternalSolverLanguageParser extends AbstractInternalContentAssistP | |||
21969 | 20178 | ||
21970 | 20179 | ||
21971 | // $ANTLR start "rule__BoundedMultiplicity__Group__0" | 20180 | // $ANTLR start "rule__BoundedMultiplicity__Group__0" |
21972 | // InternalSolverLanguage.g:6576:1: rule__BoundedMultiplicity__Group__0 : rule__BoundedMultiplicity__Group__0__Impl rule__BoundedMultiplicity__Group__1 ; | 20181 | // InternalSolverLanguageParser.g:6520:1: rule__BoundedMultiplicity__Group__0 : rule__BoundedMultiplicity__Group__0__Impl rule__BoundedMultiplicity__Group__1 ; |
21973 | public final void rule__BoundedMultiplicity__Group__0() throws RecognitionException { | 20182 | public final void rule__BoundedMultiplicity__Group__0() throws RecognitionException { |
21974 | 20183 | ||
21975 | int stackSize = keepStackSize(); | 20184 | int stackSize = keepStackSize(); |
21976 | 20185 | ||
21977 | try { | 20186 | try { |
21978 | // InternalSolverLanguage.g:6580:1: ( rule__BoundedMultiplicity__Group__0__Impl rule__BoundedMultiplicity__Group__1 ) | 20187 | // InternalSolverLanguageParser.g:6524:1: ( rule__BoundedMultiplicity__Group__0__Impl rule__BoundedMultiplicity__Group__1 ) |
21979 | // InternalSolverLanguage.g:6581:2: rule__BoundedMultiplicity__Group__0__Impl rule__BoundedMultiplicity__Group__1 | 20188 | // InternalSolverLanguageParser.g:6525:2: rule__BoundedMultiplicity__Group__0__Impl rule__BoundedMultiplicity__Group__1 |
21980 | { | 20189 | { |
21981 | pushFollow(FOLLOW_53); | 20190 | pushFollow(FOLLOW_52); |
21982 | rule__BoundedMultiplicity__Group__0__Impl(); | 20191 | rule__BoundedMultiplicity__Group__0__Impl(); |
21983 | 20192 | ||
21984 | state._fsp--; | 20193 | state._fsp--; |
21985 | if (state.failed) return ; | 20194 | |
21986 | pushFollow(FOLLOW_2); | 20195 | pushFollow(FOLLOW_2); |
21987 | rule__BoundedMultiplicity__Group__1(); | 20196 | rule__BoundedMultiplicity__Group__1(); |
21988 | 20197 | ||
21989 | state._fsp--; | 20198 | state._fsp--; |
21990 | if (state.failed) return ; | 20199 | |
21991 | 20200 | ||
21992 | } | 20201 | } |
21993 | 20202 | ||
@@ -22007,25 +20216,21 @@ public class InternalSolverLanguageParser extends AbstractInternalContentAssistP | |||
22007 | 20216 | ||
22008 | 20217 | ||
22009 | // $ANTLR start "rule__BoundedMultiplicity__Group__0__Impl" | 20218 | // $ANTLR start "rule__BoundedMultiplicity__Group__0__Impl" |
22010 | // InternalSolverLanguage.g:6588:1: rule__BoundedMultiplicity__Group__0__Impl : ( '[' ) ; | 20219 | // InternalSolverLanguageParser.g:6532:1: rule__BoundedMultiplicity__Group__0__Impl : ( LeftSquareBracket ) ; |
22011 | public final void rule__BoundedMultiplicity__Group__0__Impl() throws RecognitionException { | 20220 | public final void rule__BoundedMultiplicity__Group__0__Impl() throws RecognitionException { |
22012 | 20221 | ||
22013 | int stackSize = keepStackSize(); | 20222 | int stackSize = keepStackSize(); |
22014 | 20223 | ||
22015 | try { | 20224 | try { |
22016 | // InternalSolverLanguage.g:6592:1: ( ( '[' ) ) | 20225 | // InternalSolverLanguageParser.g:6536:1: ( ( LeftSquareBracket ) ) |
22017 | // InternalSolverLanguage.g:6593:1: ( '[' ) | 20226 | // InternalSolverLanguageParser.g:6537:1: ( LeftSquareBracket ) |
22018 | { | 20227 | { |
22019 | // InternalSolverLanguage.g:6593:1: ( '[' ) | 20228 | // InternalSolverLanguageParser.g:6537:1: ( LeftSquareBracket ) |
22020 | // InternalSolverLanguage.g:6594:2: '[' | 20229 | // InternalSolverLanguageParser.g:6538:2: LeftSquareBracket |
22021 | { | 20230 | { |
22022 | if ( state.backtracking==0 ) { | 20231 | before(grammarAccess.getBoundedMultiplicityAccess().getLeftSquareBracketKeyword_0()); |
22023 | before(grammarAccess.getBoundedMultiplicityAccess().getLeftSquareBracketKeyword_0()); | 20232 | match(input,LeftSquareBracket,FOLLOW_2); |
22024 | } | 20233 | after(grammarAccess.getBoundedMultiplicityAccess().getLeftSquareBracketKeyword_0()); |
22025 | match(input,63,FOLLOW_2); if (state.failed) return ; | ||
22026 | if ( state.backtracking==0 ) { | ||
22027 | after(grammarAccess.getBoundedMultiplicityAccess().getLeftSquareBracketKeyword_0()); | ||
22028 | } | ||
22029 | 20234 | ||
22030 | } | 20235 | } |
22031 | 20236 | ||
@@ -22048,25 +20253,25 @@ public class InternalSolverLanguageParser extends AbstractInternalContentAssistP | |||
22048 | 20253 | ||
22049 | 20254 | ||
22050 | // $ANTLR start "rule__BoundedMultiplicity__Group__1" | 20255 | // $ANTLR start "rule__BoundedMultiplicity__Group__1" |
22051 | // InternalSolverLanguage.g:6603:1: rule__BoundedMultiplicity__Group__1 : rule__BoundedMultiplicity__Group__1__Impl rule__BoundedMultiplicity__Group__2 ; | 20256 | // InternalSolverLanguageParser.g:6547:1: rule__BoundedMultiplicity__Group__1 : rule__BoundedMultiplicity__Group__1__Impl rule__BoundedMultiplicity__Group__2 ; |
22052 | public final void rule__BoundedMultiplicity__Group__1() throws RecognitionException { | 20257 | public final void rule__BoundedMultiplicity__Group__1() throws RecognitionException { |
22053 | 20258 | ||
22054 | int stackSize = keepStackSize(); | 20259 | int stackSize = keepStackSize(); |
22055 | 20260 | ||
22056 | try { | 20261 | try { |
22057 | // InternalSolverLanguage.g:6607:1: ( rule__BoundedMultiplicity__Group__1__Impl rule__BoundedMultiplicity__Group__2 ) | 20262 | // InternalSolverLanguageParser.g:6551:1: ( rule__BoundedMultiplicity__Group__1__Impl rule__BoundedMultiplicity__Group__2 ) |
22058 | // InternalSolverLanguage.g:6608:2: rule__BoundedMultiplicity__Group__1__Impl rule__BoundedMultiplicity__Group__2 | 20263 | // InternalSolverLanguageParser.g:6552:2: rule__BoundedMultiplicity__Group__1__Impl rule__BoundedMultiplicity__Group__2 |
22059 | { | 20264 | { |
22060 | pushFollow(FOLLOW_39); | 20265 | pushFollow(FOLLOW_38); |
22061 | rule__BoundedMultiplicity__Group__1__Impl(); | 20266 | rule__BoundedMultiplicity__Group__1__Impl(); |
22062 | 20267 | ||
22063 | state._fsp--; | 20268 | state._fsp--; |
22064 | if (state.failed) return ; | 20269 | |
22065 | pushFollow(FOLLOW_2); | 20270 | pushFollow(FOLLOW_2); |
22066 | rule__BoundedMultiplicity__Group__2(); | 20271 | rule__BoundedMultiplicity__Group__2(); |
22067 | 20272 | ||
22068 | state._fsp--; | 20273 | state._fsp--; |
22069 | if (state.failed) return ; | 20274 | |
22070 | 20275 | ||
22071 | } | 20276 | } |
22072 | 20277 | ||
@@ -22086,36 +20291,32 @@ public class InternalSolverLanguageParser extends AbstractInternalContentAssistP | |||
22086 | 20291 | ||
22087 | 20292 | ||
22088 | // $ANTLR start "rule__BoundedMultiplicity__Group__1__Impl" | 20293 | // $ANTLR start "rule__BoundedMultiplicity__Group__1__Impl" |
22089 | // InternalSolverLanguage.g:6615:1: rule__BoundedMultiplicity__Group__1__Impl : ( ( rule__BoundedMultiplicity__LowerBoundAssignment_1 ) ) ; | 20294 | // InternalSolverLanguageParser.g:6559:1: rule__BoundedMultiplicity__Group__1__Impl : ( ( rule__BoundedMultiplicity__LowerBoundAssignment_1 ) ) ; |
22090 | public final void rule__BoundedMultiplicity__Group__1__Impl() throws RecognitionException { | 20295 | public final void rule__BoundedMultiplicity__Group__1__Impl() throws RecognitionException { |
22091 | 20296 | ||
22092 | int stackSize = keepStackSize(); | 20297 | int stackSize = keepStackSize(); |
22093 | 20298 | ||
22094 | try { | 20299 | try { |
22095 | // InternalSolverLanguage.g:6619:1: ( ( ( rule__BoundedMultiplicity__LowerBoundAssignment_1 ) ) ) | 20300 | // InternalSolverLanguageParser.g:6563:1: ( ( ( rule__BoundedMultiplicity__LowerBoundAssignment_1 ) ) ) |
22096 | // InternalSolverLanguage.g:6620:1: ( ( rule__BoundedMultiplicity__LowerBoundAssignment_1 ) ) | 20301 | // InternalSolverLanguageParser.g:6564:1: ( ( rule__BoundedMultiplicity__LowerBoundAssignment_1 ) ) |
22097 | { | 20302 | { |
22098 | // InternalSolverLanguage.g:6620:1: ( ( rule__BoundedMultiplicity__LowerBoundAssignment_1 ) ) | 20303 | // InternalSolverLanguageParser.g:6564:1: ( ( rule__BoundedMultiplicity__LowerBoundAssignment_1 ) ) |
22099 | // InternalSolverLanguage.g:6621:2: ( rule__BoundedMultiplicity__LowerBoundAssignment_1 ) | 20304 | // InternalSolverLanguageParser.g:6565:2: ( rule__BoundedMultiplicity__LowerBoundAssignment_1 ) |
22100 | { | 20305 | { |
22101 | if ( state.backtracking==0 ) { | 20306 | before(grammarAccess.getBoundedMultiplicityAccess().getLowerBoundAssignment_1()); |
22102 | before(grammarAccess.getBoundedMultiplicityAccess().getLowerBoundAssignment_1()); | 20307 | // InternalSolverLanguageParser.g:6566:2: ( rule__BoundedMultiplicity__LowerBoundAssignment_1 ) |
22103 | } | 20308 | // InternalSolverLanguageParser.g:6566:3: rule__BoundedMultiplicity__LowerBoundAssignment_1 |
22104 | // InternalSolverLanguage.g:6622:2: ( rule__BoundedMultiplicity__LowerBoundAssignment_1 ) | ||
22105 | // InternalSolverLanguage.g:6622:3: rule__BoundedMultiplicity__LowerBoundAssignment_1 | ||
22106 | { | 20309 | { |
22107 | pushFollow(FOLLOW_2); | 20310 | pushFollow(FOLLOW_2); |
22108 | rule__BoundedMultiplicity__LowerBoundAssignment_1(); | 20311 | rule__BoundedMultiplicity__LowerBoundAssignment_1(); |
22109 | 20312 | ||
22110 | state._fsp--; | 20313 | state._fsp--; |
22111 | if (state.failed) return ; | ||
22112 | 20314 | ||
22113 | } | ||
22114 | 20315 | ||
22115 | if ( state.backtracking==0 ) { | ||
22116 | after(grammarAccess.getBoundedMultiplicityAccess().getLowerBoundAssignment_1()); | ||
22117 | } | 20316 | } |
22118 | 20317 | ||
20318 | after(grammarAccess.getBoundedMultiplicityAccess().getLowerBoundAssignment_1()); | ||
20319 | |||
22119 | } | 20320 | } |
22120 | 20321 | ||
22121 | 20322 | ||
@@ -22137,25 +20338,25 @@ public class InternalSolverLanguageParser extends AbstractInternalContentAssistP | |||
22137 | 20338 | ||
22138 | 20339 | ||
22139 | // $ANTLR start "rule__BoundedMultiplicity__Group__2" | 20340 | // $ANTLR start "rule__BoundedMultiplicity__Group__2" |
22140 | // InternalSolverLanguage.g:6630:1: rule__BoundedMultiplicity__Group__2 : rule__BoundedMultiplicity__Group__2__Impl rule__BoundedMultiplicity__Group__3 ; | 20341 | // InternalSolverLanguageParser.g:6574:1: rule__BoundedMultiplicity__Group__2 : rule__BoundedMultiplicity__Group__2__Impl rule__BoundedMultiplicity__Group__3 ; |
22141 | public final void rule__BoundedMultiplicity__Group__2() throws RecognitionException { | 20342 | public final void rule__BoundedMultiplicity__Group__2() throws RecognitionException { |
22142 | 20343 | ||
22143 | int stackSize = keepStackSize(); | 20344 | int stackSize = keepStackSize(); |
22144 | 20345 | ||
22145 | try { | 20346 | try { |
22146 | // InternalSolverLanguage.g:6634:1: ( rule__BoundedMultiplicity__Group__2__Impl rule__BoundedMultiplicity__Group__3 ) | 20347 | // InternalSolverLanguageParser.g:6578:1: ( rule__BoundedMultiplicity__Group__2__Impl rule__BoundedMultiplicity__Group__3 ) |
22147 | // InternalSolverLanguage.g:6635:2: rule__BoundedMultiplicity__Group__2__Impl rule__BoundedMultiplicity__Group__3 | 20348 | // InternalSolverLanguageParser.g:6579:2: rule__BoundedMultiplicity__Group__2__Impl rule__BoundedMultiplicity__Group__3 |
22148 | { | 20349 | { |
22149 | pushFollow(FOLLOW_52); | 20350 | pushFollow(FOLLOW_51); |
22150 | rule__BoundedMultiplicity__Group__2__Impl(); | 20351 | rule__BoundedMultiplicity__Group__2__Impl(); |
22151 | 20352 | ||
22152 | state._fsp--; | 20353 | state._fsp--; |
22153 | if (state.failed) return ; | 20354 | |
22154 | pushFollow(FOLLOW_2); | 20355 | pushFollow(FOLLOW_2); |
22155 | rule__BoundedMultiplicity__Group__3(); | 20356 | rule__BoundedMultiplicity__Group__3(); |
22156 | 20357 | ||
22157 | state._fsp--; | 20358 | state._fsp--; |
22158 | if (state.failed) return ; | 20359 | |
22159 | 20360 | ||
22160 | } | 20361 | } |
22161 | 20362 | ||
@@ -22175,25 +20376,21 @@ public class InternalSolverLanguageParser extends AbstractInternalContentAssistP | |||
22175 | 20376 | ||
22176 | 20377 | ||
22177 | // $ANTLR start "rule__BoundedMultiplicity__Group__2__Impl" | 20378 | // $ANTLR start "rule__BoundedMultiplicity__Group__2__Impl" |
22178 | // InternalSolverLanguage.g:6642:1: rule__BoundedMultiplicity__Group__2__Impl : ( '..' ) ; | 20379 | // InternalSolverLanguageParser.g:6586:1: rule__BoundedMultiplicity__Group__2__Impl : ( FullStopFullStop ) ; |
22179 | public final void rule__BoundedMultiplicity__Group__2__Impl() throws RecognitionException { | 20380 | public final void rule__BoundedMultiplicity__Group__2__Impl() throws RecognitionException { |
22180 | 20381 | ||
22181 | int stackSize = keepStackSize(); | 20382 | int stackSize = keepStackSize(); |
22182 | 20383 | ||
22183 | try { | 20384 | try { |
22184 | // InternalSolverLanguage.g:6646:1: ( ( '..' ) ) | 20385 | // InternalSolverLanguageParser.g:6590:1: ( ( FullStopFullStop ) ) |
22185 | // InternalSolverLanguage.g:6647:1: ( '..' ) | 20386 | // InternalSolverLanguageParser.g:6591:1: ( FullStopFullStop ) |
22186 | { | 20387 | { |
22187 | // InternalSolverLanguage.g:6647:1: ( '..' ) | 20388 | // InternalSolverLanguageParser.g:6591:1: ( FullStopFullStop ) |
22188 | // InternalSolverLanguage.g:6648:2: '..' | 20389 | // InternalSolverLanguageParser.g:6592:2: FullStopFullStop |
22189 | { | 20390 | { |
22190 | if ( state.backtracking==0 ) { | 20391 | before(grammarAccess.getBoundedMultiplicityAccess().getFullStopFullStopKeyword_2()); |
22191 | before(grammarAccess.getBoundedMultiplicityAccess().getFullStopFullStopKeyword_2()); | 20392 | match(input,FullStopFullStop,FOLLOW_2); |
22192 | } | 20393 | after(grammarAccess.getBoundedMultiplicityAccess().getFullStopFullStopKeyword_2()); |
22193 | match(input,64,FOLLOW_2); if (state.failed) return ; | ||
22194 | if ( state.backtracking==0 ) { | ||
22195 | after(grammarAccess.getBoundedMultiplicityAccess().getFullStopFullStopKeyword_2()); | ||
22196 | } | ||
22197 | 20394 | ||
22198 | } | 20395 | } |
22199 | 20396 | ||
@@ -22216,25 +20413,25 @@ public class InternalSolverLanguageParser extends AbstractInternalContentAssistP | |||
22216 | 20413 | ||
22217 | 20414 | ||
22218 | // $ANTLR start "rule__BoundedMultiplicity__Group__3" | 20415 | // $ANTLR start "rule__BoundedMultiplicity__Group__3" |
22219 | // InternalSolverLanguage.g:6657:1: rule__BoundedMultiplicity__Group__3 : rule__BoundedMultiplicity__Group__3__Impl rule__BoundedMultiplicity__Group__4 ; | 20416 | // InternalSolverLanguageParser.g:6601:1: rule__BoundedMultiplicity__Group__3 : rule__BoundedMultiplicity__Group__3__Impl rule__BoundedMultiplicity__Group__4 ; |
22220 | public final void rule__BoundedMultiplicity__Group__3() throws RecognitionException { | 20417 | public final void rule__BoundedMultiplicity__Group__3() throws RecognitionException { |
22221 | 20418 | ||
22222 | int stackSize = keepStackSize(); | 20419 | int stackSize = keepStackSize(); |
22223 | 20420 | ||
22224 | try { | 20421 | try { |
22225 | // InternalSolverLanguage.g:6661:1: ( rule__BoundedMultiplicity__Group__3__Impl rule__BoundedMultiplicity__Group__4 ) | 20422 | // InternalSolverLanguageParser.g:6605:1: ( rule__BoundedMultiplicity__Group__3__Impl rule__BoundedMultiplicity__Group__4 ) |
22226 | // InternalSolverLanguage.g:6662:2: rule__BoundedMultiplicity__Group__3__Impl rule__BoundedMultiplicity__Group__4 | 20423 | // InternalSolverLanguageParser.g:6606:2: rule__BoundedMultiplicity__Group__3__Impl rule__BoundedMultiplicity__Group__4 |
22227 | { | 20424 | { |
22228 | pushFollow(FOLLOW_40); | 20425 | pushFollow(FOLLOW_39); |
22229 | rule__BoundedMultiplicity__Group__3__Impl(); | 20426 | rule__BoundedMultiplicity__Group__3__Impl(); |
22230 | 20427 | ||
22231 | state._fsp--; | 20428 | state._fsp--; |
22232 | if (state.failed) return ; | 20429 | |
22233 | pushFollow(FOLLOW_2); | 20430 | pushFollow(FOLLOW_2); |
22234 | rule__BoundedMultiplicity__Group__4(); | 20431 | rule__BoundedMultiplicity__Group__4(); |
22235 | 20432 | ||
22236 | state._fsp--; | 20433 | state._fsp--; |
22237 | if (state.failed) return ; | 20434 | |
22238 | 20435 | ||
22239 | } | 20436 | } |
22240 | 20437 | ||
@@ -22254,36 +20451,32 @@ public class InternalSolverLanguageParser extends AbstractInternalContentAssistP | |||
22254 | 20451 | ||
22255 | 20452 | ||
22256 | // $ANTLR start "rule__BoundedMultiplicity__Group__3__Impl" | 20453 | // $ANTLR start "rule__BoundedMultiplicity__Group__3__Impl" |
22257 | // InternalSolverLanguage.g:6669:1: rule__BoundedMultiplicity__Group__3__Impl : ( ( rule__BoundedMultiplicity__UpperBoundAssignment_3 ) ) ; | 20454 | // InternalSolverLanguageParser.g:6613:1: rule__BoundedMultiplicity__Group__3__Impl : ( ( rule__BoundedMultiplicity__UpperBoundAssignment_3 ) ) ; |
22258 | public final void rule__BoundedMultiplicity__Group__3__Impl() throws RecognitionException { | 20455 | public final void rule__BoundedMultiplicity__Group__3__Impl() throws RecognitionException { |
22259 | 20456 | ||
22260 | int stackSize = keepStackSize(); | 20457 | int stackSize = keepStackSize(); |
22261 | 20458 | ||
22262 | try { | 20459 | try { |
22263 | // InternalSolverLanguage.g:6673:1: ( ( ( rule__BoundedMultiplicity__UpperBoundAssignment_3 ) ) ) | 20460 | // InternalSolverLanguageParser.g:6617:1: ( ( ( rule__BoundedMultiplicity__UpperBoundAssignment_3 ) ) ) |
22264 | // InternalSolverLanguage.g:6674:1: ( ( rule__BoundedMultiplicity__UpperBoundAssignment_3 ) ) | 20461 | // InternalSolverLanguageParser.g:6618:1: ( ( rule__BoundedMultiplicity__UpperBoundAssignment_3 ) ) |
22265 | { | 20462 | { |
22266 | // InternalSolverLanguage.g:6674:1: ( ( rule__BoundedMultiplicity__UpperBoundAssignment_3 ) ) | 20463 | // InternalSolverLanguageParser.g:6618:1: ( ( rule__BoundedMultiplicity__UpperBoundAssignment_3 ) ) |
22267 | // InternalSolverLanguage.g:6675:2: ( rule__BoundedMultiplicity__UpperBoundAssignment_3 ) | 20464 | // InternalSolverLanguageParser.g:6619:2: ( rule__BoundedMultiplicity__UpperBoundAssignment_3 ) |
22268 | { | 20465 | { |
22269 | if ( state.backtracking==0 ) { | 20466 | before(grammarAccess.getBoundedMultiplicityAccess().getUpperBoundAssignment_3()); |
22270 | before(grammarAccess.getBoundedMultiplicityAccess().getUpperBoundAssignment_3()); | 20467 | // InternalSolverLanguageParser.g:6620:2: ( rule__BoundedMultiplicity__UpperBoundAssignment_3 ) |
22271 | } | 20468 | // InternalSolverLanguageParser.g:6620:3: rule__BoundedMultiplicity__UpperBoundAssignment_3 |
22272 | // InternalSolverLanguage.g:6676:2: ( rule__BoundedMultiplicity__UpperBoundAssignment_3 ) | ||
22273 | // InternalSolverLanguage.g:6676:3: rule__BoundedMultiplicity__UpperBoundAssignment_3 | ||
22274 | { | 20469 | { |
22275 | pushFollow(FOLLOW_2); | 20470 | pushFollow(FOLLOW_2); |
22276 | rule__BoundedMultiplicity__UpperBoundAssignment_3(); | 20471 | rule__BoundedMultiplicity__UpperBoundAssignment_3(); |
22277 | 20472 | ||
22278 | state._fsp--; | 20473 | state._fsp--; |
22279 | if (state.failed) return ; | ||
22280 | 20474 | ||
22281 | } | ||
22282 | 20475 | ||
22283 | if ( state.backtracking==0 ) { | ||
22284 | after(grammarAccess.getBoundedMultiplicityAccess().getUpperBoundAssignment_3()); | ||
22285 | } | 20476 | } |
22286 | 20477 | ||
20478 | after(grammarAccess.getBoundedMultiplicityAccess().getUpperBoundAssignment_3()); | ||
20479 | |||
22287 | } | 20480 | } |
22288 | 20481 | ||
22289 | 20482 | ||
@@ -22305,20 +20498,20 @@ public class InternalSolverLanguageParser extends AbstractInternalContentAssistP | |||
22305 | 20498 | ||
22306 | 20499 | ||
22307 | // $ANTLR start "rule__BoundedMultiplicity__Group__4" | 20500 | // $ANTLR start "rule__BoundedMultiplicity__Group__4" |
22308 | // InternalSolverLanguage.g:6684:1: rule__BoundedMultiplicity__Group__4 : rule__BoundedMultiplicity__Group__4__Impl ; | 20501 | // InternalSolverLanguageParser.g:6628:1: rule__BoundedMultiplicity__Group__4 : rule__BoundedMultiplicity__Group__4__Impl ; |
22309 | public final void rule__BoundedMultiplicity__Group__4() throws RecognitionException { | 20502 | public final void rule__BoundedMultiplicity__Group__4() throws RecognitionException { |
22310 | 20503 | ||
22311 | int stackSize = keepStackSize(); | 20504 | int stackSize = keepStackSize(); |
22312 | 20505 | ||
22313 | try { | 20506 | try { |
22314 | // InternalSolverLanguage.g:6688:1: ( rule__BoundedMultiplicity__Group__4__Impl ) | 20507 | // InternalSolverLanguageParser.g:6632:1: ( rule__BoundedMultiplicity__Group__4__Impl ) |
22315 | // InternalSolverLanguage.g:6689:2: rule__BoundedMultiplicity__Group__4__Impl | 20508 | // InternalSolverLanguageParser.g:6633:2: rule__BoundedMultiplicity__Group__4__Impl |
22316 | { | 20509 | { |
22317 | pushFollow(FOLLOW_2); | 20510 | pushFollow(FOLLOW_2); |
22318 | rule__BoundedMultiplicity__Group__4__Impl(); | 20511 | rule__BoundedMultiplicity__Group__4__Impl(); |
22319 | 20512 | ||
22320 | state._fsp--; | 20513 | state._fsp--; |
22321 | if (state.failed) return ; | 20514 | |
22322 | 20515 | ||
22323 | } | 20516 | } |
22324 | 20517 | ||
@@ -22338,25 +20531,21 @@ public class InternalSolverLanguageParser extends AbstractInternalContentAssistP | |||
22338 | 20531 | ||
22339 | 20532 | ||
22340 | // $ANTLR start "rule__BoundedMultiplicity__Group__4__Impl" | 20533 | // $ANTLR start "rule__BoundedMultiplicity__Group__4__Impl" |
22341 | // InternalSolverLanguage.g:6695:1: rule__BoundedMultiplicity__Group__4__Impl : ( ']' ) ; | 20534 | // InternalSolverLanguageParser.g:6639:1: rule__BoundedMultiplicity__Group__4__Impl : ( RightSquareBracket ) ; |
22342 | public final void rule__BoundedMultiplicity__Group__4__Impl() throws RecognitionException { | 20535 | public final void rule__BoundedMultiplicity__Group__4__Impl() throws RecognitionException { |
22343 | 20536 | ||
22344 | int stackSize = keepStackSize(); | 20537 | int stackSize = keepStackSize(); |
22345 | 20538 | ||
22346 | try { | 20539 | try { |
22347 | // InternalSolverLanguage.g:6699:1: ( ( ']' ) ) | 20540 | // InternalSolverLanguageParser.g:6643:1: ( ( RightSquareBracket ) ) |
22348 | // InternalSolverLanguage.g:6700:1: ( ']' ) | 20541 | // InternalSolverLanguageParser.g:6644:1: ( RightSquareBracket ) |
22349 | { | 20542 | { |
22350 | // InternalSolverLanguage.g:6700:1: ( ']' ) | 20543 | // InternalSolverLanguageParser.g:6644:1: ( RightSquareBracket ) |
22351 | // InternalSolverLanguage.g:6701:2: ']' | 20544 | // InternalSolverLanguageParser.g:6645:2: RightSquareBracket |
22352 | { | 20545 | { |
22353 | if ( state.backtracking==0 ) { | 20546 | before(grammarAccess.getBoundedMultiplicityAccess().getRightSquareBracketKeyword_4()); |
22354 | before(grammarAccess.getBoundedMultiplicityAccess().getRightSquareBracketKeyword_4()); | 20547 | match(input,RightSquareBracket,FOLLOW_2); |
22355 | } | 20548 | after(grammarAccess.getBoundedMultiplicityAccess().getRightSquareBracketKeyword_4()); |
22356 | match(input,65,FOLLOW_2); if (state.failed) return ; | ||
22357 | if ( state.backtracking==0 ) { | ||
22358 | after(grammarAccess.getBoundedMultiplicityAccess().getRightSquareBracketKeyword_4()); | ||
22359 | } | ||
22360 | 20549 | ||
22361 | } | 20550 | } |
22362 | 20551 | ||
@@ -22379,25 +20568,25 @@ public class InternalSolverLanguageParser extends AbstractInternalContentAssistP | |||
22379 | 20568 | ||
22380 | 20569 | ||
22381 | // $ANTLR start "rule__ExactScopeDefinition__Group__0" | 20570 | // $ANTLR start "rule__ExactScopeDefinition__Group__0" |
22382 | // InternalSolverLanguage.g:6711:1: rule__ExactScopeDefinition__Group__0 : rule__ExactScopeDefinition__Group__0__Impl rule__ExactScopeDefinition__Group__1 ; | 20571 | // InternalSolverLanguageParser.g:6655:1: rule__ExactScopeDefinition__Group__0 : rule__ExactScopeDefinition__Group__0__Impl rule__ExactScopeDefinition__Group__1 ; |
22383 | public final void rule__ExactScopeDefinition__Group__0() throws RecognitionException { | 20572 | public final void rule__ExactScopeDefinition__Group__0() throws RecognitionException { |
22384 | 20573 | ||
22385 | int stackSize = keepStackSize(); | 20574 | int stackSize = keepStackSize(); |
22386 | 20575 | ||
22387 | try { | 20576 | try { |
22388 | // InternalSolverLanguage.g:6715:1: ( rule__ExactScopeDefinition__Group__0__Impl rule__ExactScopeDefinition__Group__1 ) | 20577 | // InternalSolverLanguageParser.g:6659:1: ( rule__ExactScopeDefinition__Group__0__Impl rule__ExactScopeDefinition__Group__1 ) |
22389 | // InternalSolverLanguage.g:6716:2: rule__ExactScopeDefinition__Group__0__Impl rule__ExactScopeDefinition__Group__1 | 20578 | // InternalSolverLanguageParser.g:6660:2: rule__ExactScopeDefinition__Group__0__Impl rule__ExactScopeDefinition__Group__1 |
22390 | { | 20579 | { |
22391 | pushFollow(FOLLOW_9); | 20580 | pushFollow(FOLLOW_9); |
22392 | rule__ExactScopeDefinition__Group__0__Impl(); | 20581 | rule__ExactScopeDefinition__Group__0__Impl(); |
22393 | 20582 | ||
22394 | state._fsp--; | 20583 | state._fsp--; |
22395 | if (state.failed) return ; | 20584 | |
22396 | pushFollow(FOLLOW_2); | 20585 | pushFollow(FOLLOW_2); |
22397 | rule__ExactScopeDefinition__Group__1(); | 20586 | rule__ExactScopeDefinition__Group__1(); |
22398 | 20587 | ||
22399 | state._fsp--; | 20588 | state._fsp--; |
22400 | if (state.failed) return ; | 20589 | |
22401 | 20590 | ||
22402 | } | 20591 | } |
22403 | 20592 | ||
@@ -22417,25 +20606,21 @@ public class InternalSolverLanguageParser extends AbstractInternalContentAssistP | |||
22417 | 20606 | ||
22418 | 20607 | ||
22419 | // $ANTLR start "rule__ExactScopeDefinition__Group__0__Impl" | 20608 | // $ANTLR start "rule__ExactScopeDefinition__Group__0__Impl" |
22420 | // InternalSolverLanguage.g:6723:1: rule__ExactScopeDefinition__Group__0__Impl : ( 'scope' ) ; | 20609 | // InternalSolverLanguageParser.g:6667:1: rule__ExactScopeDefinition__Group__0__Impl : ( Scope ) ; |
22421 | public final void rule__ExactScopeDefinition__Group__0__Impl() throws RecognitionException { | 20610 | public final void rule__ExactScopeDefinition__Group__0__Impl() throws RecognitionException { |
22422 | 20611 | ||
22423 | int stackSize = keepStackSize(); | 20612 | int stackSize = keepStackSize(); |
22424 | 20613 | ||
22425 | try { | 20614 | try { |
22426 | // InternalSolverLanguage.g:6727:1: ( ( 'scope' ) ) | 20615 | // InternalSolverLanguageParser.g:6671:1: ( ( Scope ) ) |
22427 | // InternalSolverLanguage.g:6728:1: ( 'scope' ) | 20616 | // InternalSolverLanguageParser.g:6672:1: ( Scope ) |
22428 | { | 20617 | { |
22429 | // InternalSolverLanguage.g:6728:1: ( 'scope' ) | 20618 | // InternalSolverLanguageParser.g:6672:1: ( Scope ) |
22430 | // InternalSolverLanguage.g:6729:2: 'scope' | 20619 | // InternalSolverLanguageParser.g:6673:2: Scope |
22431 | { | 20620 | { |
22432 | if ( state.backtracking==0 ) { | 20621 | before(grammarAccess.getExactScopeDefinitionAccess().getScopeKeyword_0()); |
22433 | before(grammarAccess.getExactScopeDefinitionAccess().getScopeKeyword_0()); | 20622 | match(input,Scope,FOLLOW_2); |
22434 | } | 20623 | after(grammarAccess.getExactScopeDefinitionAccess().getScopeKeyword_0()); |
22435 | match(input,71,FOLLOW_2); if (state.failed) return ; | ||
22436 | if ( state.backtracking==0 ) { | ||
22437 | after(grammarAccess.getExactScopeDefinitionAccess().getScopeKeyword_0()); | ||
22438 | } | ||
22439 | 20624 | ||
22440 | } | 20625 | } |
22441 | 20626 | ||
@@ -22458,25 +20643,25 @@ public class InternalSolverLanguageParser extends AbstractInternalContentAssistP | |||
22458 | 20643 | ||
22459 | 20644 | ||
22460 | // $ANTLR start "rule__ExactScopeDefinition__Group__1" | 20645 | // $ANTLR start "rule__ExactScopeDefinition__Group__1" |
22461 | // InternalSolverLanguage.g:6738:1: rule__ExactScopeDefinition__Group__1 : rule__ExactScopeDefinition__Group__1__Impl rule__ExactScopeDefinition__Group__2 ; | 20646 | // InternalSolverLanguageParser.g:6682:1: rule__ExactScopeDefinition__Group__1 : rule__ExactScopeDefinition__Group__1__Impl rule__ExactScopeDefinition__Group__2 ; |
22462 | public final void rule__ExactScopeDefinition__Group__1() throws RecognitionException { | 20647 | public final void rule__ExactScopeDefinition__Group__1() throws RecognitionException { |
22463 | 20648 | ||
22464 | int stackSize = keepStackSize(); | 20649 | int stackSize = keepStackSize(); |
22465 | 20650 | ||
22466 | try { | 20651 | try { |
22467 | // InternalSolverLanguage.g:6742:1: ( rule__ExactScopeDefinition__Group__1__Impl rule__ExactScopeDefinition__Group__2 ) | 20652 | // InternalSolverLanguageParser.g:6686:1: ( rule__ExactScopeDefinition__Group__1__Impl rule__ExactScopeDefinition__Group__2 ) |
22468 | // InternalSolverLanguage.g:6743:2: rule__ExactScopeDefinition__Group__1__Impl rule__ExactScopeDefinition__Group__2 | 20653 | // InternalSolverLanguageParser.g:6687:2: rule__ExactScopeDefinition__Group__1__Impl rule__ExactScopeDefinition__Group__2 |
22469 | { | 20654 | { |
22470 | pushFollow(FOLLOW_54); | 20655 | pushFollow(FOLLOW_53); |
22471 | rule__ExactScopeDefinition__Group__1__Impl(); | 20656 | rule__ExactScopeDefinition__Group__1__Impl(); |
22472 | 20657 | ||
22473 | state._fsp--; | 20658 | state._fsp--; |
22474 | if (state.failed) return ; | 20659 | |
22475 | pushFollow(FOLLOW_2); | 20660 | pushFollow(FOLLOW_2); |
22476 | rule__ExactScopeDefinition__Group__2(); | 20661 | rule__ExactScopeDefinition__Group__2(); |
22477 | 20662 | ||
22478 | state._fsp--; | 20663 | state._fsp--; |
22479 | if (state.failed) return ; | 20664 | |
22480 | 20665 | ||
22481 | } | 20666 | } |
22482 | 20667 | ||
@@ -22496,36 +20681,32 @@ public class InternalSolverLanguageParser extends AbstractInternalContentAssistP | |||
22496 | 20681 | ||
22497 | 20682 | ||
22498 | // $ANTLR start "rule__ExactScopeDefinition__Group__1__Impl" | 20683 | // $ANTLR start "rule__ExactScopeDefinition__Group__1__Impl" |
22499 | // InternalSolverLanguage.g:6750:1: rule__ExactScopeDefinition__Group__1__Impl : ( ( rule__ExactScopeDefinition__TypeAssignment_1 ) ) ; | 20684 | // InternalSolverLanguageParser.g:6694:1: rule__ExactScopeDefinition__Group__1__Impl : ( ( rule__ExactScopeDefinition__TypeAssignment_1 ) ) ; |
22500 | public final void rule__ExactScopeDefinition__Group__1__Impl() throws RecognitionException { | 20685 | public final void rule__ExactScopeDefinition__Group__1__Impl() throws RecognitionException { |
22501 | 20686 | ||
22502 | int stackSize = keepStackSize(); | 20687 | int stackSize = keepStackSize(); |
22503 | 20688 | ||
22504 | try { | 20689 | try { |
22505 | // InternalSolverLanguage.g:6754:1: ( ( ( rule__ExactScopeDefinition__TypeAssignment_1 ) ) ) | 20690 | // InternalSolverLanguageParser.g:6698:1: ( ( ( rule__ExactScopeDefinition__TypeAssignment_1 ) ) ) |
22506 | // InternalSolverLanguage.g:6755:1: ( ( rule__ExactScopeDefinition__TypeAssignment_1 ) ) | 20691 | // InternalSolverLanguageParser.g:6699:1: ( ( rule__ExactScopeDefinition__TypeAssignment_1 ) ) |
22507 | { | 20692 | { |
22508 | // InternalSolverLanguage.g:6755:1: ( ( rule__ExactScopeDefinition__TypeAssignment_1 ) ) | 20693 | // InternalSolverLanguageParser.g:6699:1: ( ( rule__ExactScopeDefinition__TypeAssignment_1 ) ) |
22509 | // InternalSolverLanguage.g:6756:2: ( rule__ExactScopeDefinition__TypeAssignment_1 ) | 20694 | // InternalSolverLanguageParser.g:6700:2: ( rule__ExactScopeDefinition__TypeAssignment_1 ) |
22510 | { | 20695 | { |
22511 | if ( state.backtracking==0 ) { | 20696 | before(grammarAccess.getExactScopeDefinitionAccess().getTypeAssignment_1()); |
22512 | before(grammarAccess.getExactScopeDefinitionAccess().getTypeAssignment_1()); | 20697 | // InternalSolverLanguageParser.g:6701:2: ( rule__ExactScopeDefinition__TypeAssignment_1 ) |
22513 | } | 20698 | // InternalSolverLanguageParser.g:6701:3: rule__ExactScopeDefinition__TypeAssignment_1 |
22514 | // InternalSolverLanguage.g:6757:2: ( rule__ExactScopeDefinition__TypeAssignment_1 ) | ||
22515 | // InternalSolverLanguage.g:6757:3: rule__ExactScopeDefinition__TypeAssignment_1 | ||
22516 | { | 20699 | { |
22517 | pushFollow(FOLLOW_2); | 20700 | pushFollow(FOLLOW_2); |
22518 | rule__ExactScopeDefinition__TypeAssignment_1(); | 20701 | rule__ExactScopeDefinition__TypeAssignment_1(); |
22519 | 20702 | ||
22520 | state._fsp--; | 20703 | state._fsp--; |
22521 | if (state.failed) return ; | ||
22522 | 20704 | ||
22523 | } | ||
22524 | 20705 | ||
22525 | if ( state.backtracking==0 ) { | ||
22526 | after(grammarAccess.getExactScopeDefinitionAccess().getTypeAssignment_1()); | ||
22527 | } | 20706 | } |
22528 | 20707 | ||
20708 | after(grammarAccess.getExactScopeDefinitionAccess().getTypeAssignment_1()); | ||
20709 | |||
22529 | } | 20710 | } |
22530 | 20711 | ||
22531 | 20712 | ||
@@ -22547,25 +20728,25 @@ public class InternalSolverLanguageParser extends AbstractInternalContentAssistP | |||
22547 | 20728 | ||
22548 | 20729 | ||
22549 | // $ANTLR start "rule__ExactScopeDefinition__Group__2" | 20730 | // $ANTLR start "rule__ExactScopeDefinition__Group__2" |
22550 | // InternalSolverLanguage.g:6765:1: rule__ExactScopeDefinition__Group__2 : rule__ExactScopeDefinition__Group__2__Impl rule__ExactScopeDefinition__Group__3 ; | 20731 | // InternalSolverLanguageParser.g:6709:1: rule__ExactScopeDefinition__Group__2 : rule__ExactScopeDefinition__Group__2__Impl rule__ExactScopeDefinition__Group__3 ; |
22551 | public final void rule__ExactScopeDefinition__Group__2() throws RecognitionException { | 20732 | public final void rule__ExactScopeDefinition__Group__2() throws RecognitionException { |
22552 | 20733 | ||
22553 | int stackSize = keepStackSize(); | 20734 | int stackSize = keepStackSize(); |
22554 | 20735 | ||
22555 | try { | 20736 | try { |
22556 | // InternalSolverLanguage.g:6769:1: ( rule__ExactScopeDefinition__Group__2__Impl rule__ExactScopeDefinition__Group__3 ) | 20737 | // InternalSolverLanguageParser.g:6713:1: ( rule__ExactScopeDefinition__Group__2__Impl rule__ExactScopeDefinition__Group__3 ) |
22557 | // InternalSolverLanguage.g:6770:2: rule__ExactScopeDefinition__Group__2__Impl rule__ExactScopeDefinition__Group__3 | 20738 | // InternalSolverLanguageParser.g:6714:2: rule__ExactScopeDefinition__Group__2__Impl rule__ExactScopeDefinition__Group__3 |
22558 | { | 20739 | { |
22559 | pushFollow(FOLLOW_53); | 20740 | pushFollow(FOLLOW_52); |
22560 | rule__ExactScopeDefinition__Group__2__Impl(); | 20741 | rule__ExactScopeDefinition__Group__2__Impl(); |
22561 | 20742 | ||
22562 | state._fsp--; | 20743 | state._fsp--; |
22563 | if (state.failed) return ; | 20744 | |
22564 | pushFollow(FOLLOW_2); | 20745 | pushFollow(FOLLOW_2); |
22565 | rule__ExactScopeDefinition__Group__3(); | 20746 | rule__ExactScopeDefinition__Group__3(); |
22566 | 20747 | ||
22567 | state._fsp--; | 20748 | state._fsp--; |
22568 | if (state.failed) return ; | 20749 | |
22569 | 20750 | ||
22570 | } | 20751 | } |
22571 | 20752 | ||
@@ -22585,25 +20766,21 @@ public class InternalSolverLanguageParser extends AbstractInternalContentAssistP | |||
22585 | 20766 | ||
22586 | 20767 | ||
22587 | // $ANTLR start "rule__ExactScopeDefinition__Group__2__Impl" | 20768 | // $ANTLR start "rule__ExactScopeDefinition__Group__2__Impl" |
22588 | // InternalSolverLanguage.g:6777:1: rule__ExactScopeDefinition__Group__2__Impl : ( '==' ) ; | 20769 | // InternalSolverLanguageParser.g:6721:1: rule__ExactScopeDefinition__Group__2__Impl : ( EqualsSignEqualsSign ) ; |
22589 | public final void rule__ExactScopeDefinition__Group__2__Impl() throws RecognitionException { | 20770 | public final void rule__ExactScopeDefinition__Group__2__Impl() throws RecognitionException { |
22590 | 20771 | ||
22591 | int stackSize = keepStackSize(); | 20772 | int stackSize = keepStackSize(); |
22592 | 20773 | ||
22593 | try { | 20774 | try { |
22594 | // InternalSolverLanguage.g:6781:1: ( ( '==' ) ) | 20775 | // InternalSolverLanguageParser.g:6725:1: ( ( EqualsSignEqualsSign ) ) |
22595 | // InternalSolverLanguage.g:6782:1: ( '==' ) | 20776 | // InternalSolverLanguageParser.g:6726:1: ( EqualsSignEqualsSign ) |
22596 | { | 20777 | { |
22597 | // InternalSolverLanguage.g:6782:1: ( '==' ) | 20778 | // InternalSolverLanguageParser.g:6726:1: ( EqualsSignEqualsSign ) |
22598 | // InternalSolverLanguage.g:6783:2: '==' | 20779 | // InternalSolverLanguageParser.g:6727:2: EqualsSignEqualsSign |
22599 | { | 20780 | { |
22600 | if ( state.backtracking==0 ) { | 20781 | before(grammarAccess.getExactScopeDefinitionAccess().getEqualsSignEqualsSignKeyword_2()); |
22601 | before(grammarAccess.getExactScopeDefinitionAccess().getEqualsSignEqualsSignKeyword_2()); | 20782 | match(input,EqualsSignEqualsSign,FOLLOW_2); |
22602 | } | 20783 | after(grammarAccess.getExactScopeDefinitionAccess().getEqualsSignEqualsSignKeyword_2()); |
22603 | match(input,19,FOLLOW_2); if (state.failed) return ; | ||
22604 | if ( state.backtracking==0 ) { | ||
22605 | after(grammarAccess.getExactScopeDefinitionAccess().getEqualsSignEqualsSignKeyword_2()); | ||
22606 | } | ||
22607 | 20784 | ||
22608 | } | 20785 | } |
22609 | 20786 | ||
@@ -22626,20 +20803,20 @@ public class InternalSolverLanguageParser extends AbstractInternalContentAssistP | |||
22626 | 20803 | ||
22627 | 20804 | ||
22628 | // $ANTLR start "rule__ExactScopeDefinition__Group__3" | 20805 | // $ANTLR start "rule__ExactScopeDefinition__Group__3" |
22629 | // InternalSolverLanguage.g:6792:1: rule__ExactScopeDefinition__Group__3 : rule__ExactScopeDefinition__Group__3__Impl ; | 20806 | // InternalSolverLanguageParser.g:6736:1: rule__ExactScopeDefinition__Group__3 : rule__ExactScopeDefinition__Group__3__Impl ; |
22630 | public final void rule__ExactScopeDefinition__Group__3() throws RecognitionException { | 20807 | public final void rule__ExactScopeDefinition__Group__3() throws RecognitionException { |
22631 | 20808 | ||
22632 | int stackSize = keepStackSize(); | 20809 | int stackSize = keepStackSize(); |
22633 | 20810 | ||
22634 | try { | 20811 | try { |
22635 | // InternalSolverLanguage.g:6796:1: ( rule__ExactScopeDefinition__Group__3__Impl ) | 20812 | // InternalSolverLanguageParser.g:6740:1: ( rule__ExactScopeDefinition__Group__3__Impl ) |
22636 | // InternalSolverLanguage.g:6797:2: rule__ExactScopeDefinition__Group__3__Impl | 20813 | // InternalSolverLanguageParser.g:6741:2: rule__ExactScopeDefinition__Group__3__Impl |
22637 | { | 20814 | { |
22638 | pushFollow(FOLLOW_2); | 20815 | pushFollow(FOLLOW_2); |
22639 | rule__ExactScopeDefinition__Group__3__Impl(); | 20816 | rule__ExactScopeDefinition__Group__3__Impl(); |
22640 | 20817 | ||
22641 | state._fsp--; | 20818 | state._fsp--; |
22642 | if (state.failed) return ; | 20819 | |
22643 | 20820 | ||
22644 | } | 20821 | } |
22645 | 20822 | ||
@@ -22659,36 +20836,32 @@ public class InternalSolverLanguageParser extends AbstractInternalContentAssistP | |||
22659 | 20836 | ||
22660 | 20837 | ||
22661 | // $ANTLR start "rule__ExactScopeDefinition__Group__3__Impl" | 20838 | // $ANTLR start "rule__ExactScopeDefinition__Group__3__Impl" |
22662 | // InternalSolverLanguage.g:6803:1: rule__ExactScopeDefinition__Group__3__Impl : ( ( rule__ExactScopeDefinition__ExactScopeAssignment_3 ) ) ; | 20839 | // InternalSolverLanguageParser.g:6747:1: rule__ExactScopeDefinition__Group__3__Impl : ( ( rule__ExactScopeDefinition__ExactScopeAssignment_3 ) ) ; |
22663 | public final void rule__ExactScopeDefinition__Group__3__Impl() throws RecognitionException { | 20840 | public final void rule__ExactScopeDefinition__Group__3__Impl() throws RecognitionException { |
22664 | 20841 | ||
22665 | int stackSize = keepStackSize(); | 20842 | int stackSize = keepStackSize(); |
22666 | 20843 | ||
22667 | try { | 20844 | try { |
22668 | // InternalSolverLanguage.g:6807:1: ( ( ( rule__ExactScopeDefinition__ExactScopeAssignment_3 ) ) ) | 20845 | // InternalSolverLanguageParser.g:6751:1: ( ( ( rule__ExactScopeDefinition__ExactScopeAssignment_3 ) ) ) |
22669 | // InternalSolverLanguage.g:6808:1: ( ( rule__ExactScopeDefinition__ExactScopeAssignment_3 ) ) | 20846 | // InternalSolverLanguageParser.g:6752:1: ( ( rule__ExactScopeDefinition__ExactScopeAssignment_3 ) ) |
22670 | { | 20847 | { |
22671 | // InternalSolverLanguage.g:6808:1: ( ( rule__ExactScopeDefinition__ExactScopeAssignment_3 ) ) | 20848 | // InternalSolverLanguageParser.g:6752:1: ( ( rule__ExactScopeDefinition__ExactScopeAssignment_3 ) ) |
22672 | // InternalSolverLanguage.g:6809:2: ( rule__ExactScopeDefinition__ExactScopeAssignment_3 ) | 20849 | // InternalSolverLanguageParser.g:6753:2: ( rule__ExactScopeDefinition__ExactScopeAssignment_3 ) |
22673 | { | 20850 | { |
22674 | if ( state.backtracking==0 ) { | 20851 | before(grammarAccess.getExactScopeDefinitionAccess().getExactScopeAssignment_3()); |
22675 | before(grammarAccess.getExactScopeDefinitionAccess().getExactScopeAssignment_3()); | 20852 | // InternalSolverLanguageParser.g:6754:2: ( rule__ExactScopeDefinition__ExactScopeAssignment_3 ) |
22676 | } | 20853 | // InternalSolverLanguageParser.g:6754:3: rule__ExactScopeDefinition__ExactScopeAssignment_3 |
22677 | // InternalSolverLanguage.g:6810:2: ( rule__ExactScopeDefinition__ExactScopeAssignment_3 ) | ||
22678 | // InternalSolverLanguage.g:6810:3: rule__ExactScopeDefinition__ExactScopeAssignment_3 | ||
22679 | { | 20854 | { |
22680 | pushFollow(FOLLOW_2); | 20855 | pushFollow(FOLLOW_2); |
22681 | rule__ExactScopeDefinition__ExactScopeAssignment_3(); | 20856 | rule__ExactScopeDefinition__ExactScopeAssignment_3(); |
22682 | 20857 | ||
22683 | state._fsp--; | 20858 | state._fsp--; |
22684 | if (state.failed) return ; | ||
22685 | 20859 | ||
22686 | } | ||
22687 | 20860 | ||
22688 | if ( state.backtracking==0 ) { | ||
22689 | after(grammarAccess.getExactScopeDefinitionAccess().getExactScopeAssignment_3()); | ||
22690 | } | 20861 | } |
22691 | 20862 | ||
20863 | after(grammarAccess.getExactScopeDefinitionAccess().getExactScopeAssignment_3()); | ||
20864 | |||
22692 | } | 20865 | } |
22693 | 20866 | ||
22694 | 20867 | ||
@@ -22710,25 +20883,25 @@ public class InternalSolverLanguageParser extends AbstractInternalContentAssistP | |||
22710 | 20883 | ||
22711 | 20884 | ||
22712 | // $ANTLR start "rule__BoundedScopeDefinition__Group__0" | 20885 | // $ANTLR start "rule__BoundedScopeDefinition__Group__0" |
22713 | // InternalSolverLanguage.g:6819:1: rule__BoundedScopeDefinition__Group__0 : rule__BoundedScopeDefinition__Group__0__Impl rule__BoundedScopeDefinition__Group__1 ; | 20886 | // InternalSolverLanguageParser.g:6763:1: rule__BoundedScopeDefinition__Group__0 : rule__BoundedScopeDefinition__Group__0__Impl rule__BoundedScopeDefinition__Group__1 ; |
22714 | public final void rule__BoundedScopeDefinition__Group__0() throws RecognitionException { | 20887 | public final void rule__BoundedScopeDefinition__Group__0() throws RecognitionException { |
22715 | 20888 | ||
22716 | int stackSize = keepStackSize(); | 20889 | int stackSize = keepStackSize(); |
22717 | 20890 | ||
22718 | try { | 20891 | try { |
22719 | // InternalSolverLanguage.g:6823:1: ( rule__BoundedScopeDefinition__Group__0__Impl rule__BoundedScopeDefinition__Group__1 ) | 20892 | // InternalSolverLanguageParser.g:6767:1: ( rule__BoundedScopeDefinition__Group__0__Impl rule__BoundedScopeDefinition__Group__1 ) |
22720 | // InternalSolverLanguage.g:6824:2: rule__BoundedScopeDefinition__Group__0__Impl rule__BoundedScopeDefinition__Group__1 | 20893 | // InternalSolverLanguageParser.g:6768:2: rule__BoundedScopeDefinition__Group__0__Impl rule__BoundedScopeDefinition__Group__1 |
22721 | { | 20894 | { |
22722 | pushFollow(FOLLOW_55); | 20895 | pushFollow(FOLLOW_54); |
22723 | rule__BoundedScopeDefinition__Group__0__Impl(); | 20896 | rule__BoundedScopeDefinition__Group__0__Impl(); |
22724 | 20897 | ||
22725 | state._fsp--; | 20898 | state._fsp--; |
22726 | if (state.failed) return ; | 20899 | |
22727 | pushFollow(FOLLOW_2); | 20900 | pushFollow(FOLLOW_2); |
22728 | rule__BoundedScopeDefinition__Group__1(); | 20901 | rule__BoundedScopeDefinition__Group__1(); |
22729 | 20902 | ||
22730 | state._fsp--; | 20903 | state._fsp--; |
22731 | if (state.failed) return ; | 20904 | |
22732 | 20905 | ||
22733 | } | 20906 | } |
22734 | 20907 | ||
@@ -22748,25 +20921,21 @@ public class InternalSolverLanguageParser extends AbstractInternalContentAssistP | |||
22748 | 20921 | ||
22749 | 20922 | ||
22750 | // $ANTLR start "rule__BoundedScopeDefinition__Group__0__Impl" | 20923 | // $ANTLR start "rule__BoundedScopeDefinition__Group__0__Impl" |
22751 | // InternalSolverLanguage.g:6831:1: rule__BoundedScopeDefinition__Group__0__Impl : ( 'scope' ) ; | 20924 | // InternalSolverLanguageParser.g:6775:1: rule__BoundedScopeDefinition__Group__0__Impl : ( Scope ) ; |
22752 | public final void rule__BoundedScopeDefinition__Group__0__Impl() throws RecognitionException { | 20925 | public final void rule__BoundedScopeDefinition__Group__0__Impl() throws RecognitionException { |
22753 | 20926 | ||
22754 | int stackSize = keepStackSize(); | 20927 | int stackSize = keepStackSize(); |
22755 | 20928 | ||
22756 | try { | 20929 | try { |
22757 | // InternalSolverLanguage.g:6835:1: ( ( 'scope' ) ) | 20930 | // InternalSolverLanguageParser.g:6779:1: ( ( Scope ) ) |
22758 | // InternalSolverLanguage.g:6836:1: ( 'scope' ) | 20931 | // InternalSolverLanguageParser.g:6780:1: ( Scope ) |
22759 | { | 20932 | { |
22760 | // InternalSolverLanguage.g:6836:1: ( 'scope' ) | 20933 | // InternalSolverLanguageParser.g:6780:1: ( Scope ) |
22761 | // InternalSolverLanguage.g:6837:2: 'scope' | 20934 | // InternalSolverLanguageParser.g:6781:2: Scope |
22762 | { | 20935 | { |
22763 | if ( state.backtracking==0 ) { | 20936 | before(grammarAccess.getBoundedScopeDefinitionAccess().getScopeKeyword_0()); |
22764 | before(grammarAccess.getBoundedScopeDefinitionAccess().getScopeKeyword_0()); | 20937 | match(input,Scope,FOLLOW_2); |
22765 | } | 20938 | after(grammarAccess.getBoundedScopeDefinitionAccess().getScopeKeyword_0()); |
22766 | match(input,71,FOLLOW_2); if (state.failed) return ; | ||
22767 | if ( state.backtracking==0 ) { | ||
22768 | after(grammarAccess.getBoundedScopeDefinitionAccess().getScopeKeyword_0()); | ||
22769 | } | ||
22770 | 20939 | ||
22771 | } | 20940 | } |
22772 | 20941 | ||
@@ -22789,25 +20958,20 @@ public class InternalSolverLanguageParser extends AbstractInternalContentAssistP | |||
22789 | 20958 | ||
22790 | 20959 | ||
22791 | // $ANTLR start "rule__BoundedScopeDefinition__Group__1" | 20960 | // $ANTLR start "rule__BoundedScopeDefinition__Group__1" |
22792 | // InternalSolverLanguage.g:6846:1: rule__BoundedScopeDefinition__Group__1 : rule__BoundedScopeDefinition__Group__1__Impl rule__BoundedScopeDefinition__Group__2 ; | 20961 | // InternalSolverLanguageParser.g:6790:1: rule__BoundedScopeDefinition__Group__1 : rule__BoundedScopeDefinition__Group__1__Impl ; |
22793 | public final void rule__BoundedScopeDefinition__Group__1() throws RecognitionException { | 20962 | public final void rule__BoundedScopeDefinition__Group__1() throws RecognitionException { |
22794 | 20963 | ||
22795 | int stackSize = keepStackSize(); | 20964 | int stackSize = keepStackSize(); |
22796 | 20965 | ||
22797 | try { | 20966 | try { |
22798 | // InternalSolverLanguage.g:6850:1: ( rule__BoundedScopeDefinition__Group__1__Impl rule__BoundedScopeDefinition__Group__2 ) | 20967 | // InternalSolverLanguageParser.g:6794:1: ( rule__BoundedScopeDefinition__Group__1__Impl ) |
22799 | // InternalSolverLanguage.g:6851:2: rule__BoundedScopeDefinition__Group__1__Impl rule__BoundedScopeDefinition__Group__2 | 20968 | // InternalSolverLanguageParser.g:6795:2: rule__BoundedScopeDefinition__Group__1__Impl |
22800 | { | 20969 | { |
22801 | pushFollow(FOLLOW_13); | 20970 | pushFollow(FOLLOW_2); |
22802 | rule__BoundedScopeDefinition__Group__1__Impl(); | 20971 | rule__BoundedScopeDefinition__Group__1__Impl(); |
22803 | 20972 | ||
22804 | state._fsp--; | 20973 | state._fsp--; |
22805 | if (state.failed) return ; | ||
22806 | pushFollow(FOLLOW_2); | ||
22807 | rule__BoundedScopeDefinition__Group__2(); | ||
22808 | 20974 | ||
22809 | state._fsp--; | ||
22810 | if (state.failed) return ; | ||
22811 | 20975 | ||
22812 | } | 20976 | } |
22813 | 20977 | ||
@@ -22827,109 +20991,31 @@ public class InternalSolverLanguageParser extends AbstractInternalContentAssistP | |||
22827 | 20991 | ||
22828 | 20992 | ||
22829 | // $ANTLR start "rule__BoundedScopeDefinition__Group__1__Impl" | 20993 | // $ANTLR start "rule__BoundedScopeDefinition__Group__1__Impl" |
22830 | // InternalSolverLanguage.g:6858:1: rule__BoundedScopeDefinition__Group__1__Impl : ( ( rule__BoundedScopeDefinition__Alternatives_1 ) ) ; | 20994 | // InternalSolverLanguageParser.g:6801:1: rule__BoundedScopeDefinition__Group__1__Impl : ( ( rule__BoundedScopeDefinition__Alternatives_1 ) ) ; |
22831 | public final void rule__BoundedScopeDefinition__Group__1__Impl() throws RecognitionException { | 20995 | public final void rule__BoundedScopeDefinition__Group__1__Impl() throws RecognitionException { |
22832 | 20996 | ||
22833 | int stackSize = keepStackSize(); | 20997 | int stackSize = keepStackSize(); |
22834 | 20998 | ||
22835 | try { | 20999 | try { |
22836 | // InternalSolverLanguage.g:6862:1: ( ( ( rule__BoundedScopeDefinition__Alternatives_1 ) ) ) | 21000 | // InternalSolverLanguageParser.g:6805:1: ( ( ( rule__BoundedScopeDefinition__Alternatives_1 ) ) ) |
22837 | // InternalSolverLanguage.g:6863:1: ( ( rule__BoundedScopeDefinition__Alternatives_1 ) ) | 21001 | // InternalSolverLanguageParser.g:6806:1: ( ( rule__BoundedScopeDefinition__Alternatives_1 ) ) |
22838 | { | 21002 | { |
22839 | // InternalSolverLanguage.g:6863:1: ( ( rule__BoundedScopeDefinition__Alternatives_1 ) ) | 21003 | // InternalSolverLanguageParser.g:6806:1: ( ( rule__BoundedScopeDefinition__Alternatives_1 ) ) |
22840 | // InternalSolverLanguage.g:6864:2: ( rule__BoundedScopeDefinition__Alternatives_1 ) | 21004 | // InternalSolverLanguageParser.g:6807:2: ( rule__BoundedScopeDefinition__Alternatives_1 ) |
22841 | { | 21005 | { |
22842 | if ( state.backtracking==0 ) { | 21006 | before(grammarAccess.getBoundedScopeDefinitionAccess().getAlternatives_1()); |
22843 | before(grammarAccess.getBoundedScopeDefinitionAccess().getAlternatives_1()); | 21007 | // InternalSolverLanguageParser.g:6808:2: ( rule__BoundedScopeDefinition__Alternatives_1 ) |
22844 | } | 21008 | // InternalSolverLanguageParser.g:6808:3: rule__BoundedScopeDefinition__Alternatives_1 |
22845 | // InternalSolverLanguage.g:6865:2: ( rule__BoundedScopeDefinition__Alternatives_1 ) | ||
22846 | // InternalSolverLanguage.g:6865:3: rule__BoundedScopeDefinition__Alternatives_1 | ||
22847 | { | 21009 | { |
22848 | pushFollow(FOLLOW_2); | 21010 | pushFollow(FOLLOW_2); |
22849 | rule__BoundedScopeDefinition__Alternatives_1(); | 21011 | rule__BoundedScopeDefinition__Alternatives_1(); |
22850 | 21012 | ||
22851 | state._fsp--; | 21013 | state._fsp--; |
22852 | if (state.failed) return ; | ||
22853 | |||
22854 | } | ||
22855 | |||
22856 | if ( state.backtracking==0 ) { | ||
22857 | after(grammarAccess.getBoundedScopeDefinitionAccess().getAlternatives_1()); | ||
22858 | } | ||
22859 | |||
22860 | } | ||
22861 | |||
22862 | |||
22863 | } | ||
22864 | |||
22865 | } | ||
22866 | catch (RecognitionException re) { | ||
22867 | reportError(re); | ||
22868 | recover(input,re); | ||
22869 | } | ||
22870 | finally { | ||
22871 | |||
22872 | restoreStackSize(stackSize); | ||
22873 | |||
22874 | } | ||
22875 | return ; | ||
22876 | } | ||
22877 | // $ANTLR end "rule__BoundedScopeDefinition__Group__1__Impl" | ||
22878 | 21014 | ||
22879 | 21015 | ||
22880 | // $ANTLR start "rule__BoundedScopeDefinition__Group__2" | ||
22881 | // InternalSolverLanguage.g:6873:1: rule__BoundedScopeDefinition__Group__2 : rule__BoundedScopeDefinition__Group__2__Impl ; | ||
22882 | public final void rule__BoundedScopeDefinition__Group__2() throws RecognitionException { | ||
22883 | |||
22884 | int stackSize = keepStackSize(); | ||
22885 | |||
22886 | try { | ||
22887 | // InternalSolverLanguage.g:6877:1: ( rule__BoundedScopeDefinition__Group__2__Impl ) | ||
22888 | // InternalSolverLanguage.g:6878:2: rule__BoundedScopeDefinition__Group__2__Impl | ||
22889 | { | ||
22890 | pushFollow(FOLLOW_2); | ||
22891 | rule__BoundedScopeDefinition__Group__2__Impl(); | ||
22892 | |||
22893 | state._fsp--; | ||
22894 | if (state.failed) return ; | ||
22895 | |||
22896 | } | 21016 | } |
22897 | 21017 | ||
22898 | } | 21018 | after(grammarAccess.getBoundedScopeDefinitionAccess().getAlternatives_1()); |
22899 | catch (RecognitionException re) { | ||
22900 | reportError(re); | ||
22901 | recover(input,re); | ||
22902 | } | ||
22903 | finally { | ||
22904 | |||
22905 | restoreStackSize(stackSize); | ||
22906 | |||
22907 | } | ||
22908 | return ; | ||
22909 | } | ||
22910 | // $ANTLR end "rule__BoundedScopeDefinition__Group__2" | ||
22911 | |||
22912 | |||
22913 | // $ANTLR start "rule__BoundedScopeDefinition__Group__2__Impl" | ||
22914 | // InternalSolverLanguage.g:6884:1: rule__BoundedScopeDefinition__Group__2__Impl : ( '.' ) ; | ||
22915 | public final void rule__BoundedScopeDefinition__Group__2__Impl() throws RecognitionException { | ||
22916 | |||
22917 | int stackSize = keepStackSize(); | ||
22918 | |||
22919 | try { | ||
22920 | // InternalSolverLanguage.g:6888:1: ( ( '.' ) ) | ||
22921 | // InternalSolverLanguage.g:6889:1: ( '.' ) | ||
22922 | { | ||
22923 | // InternalSolverLanguage.g:6889:1: ( '.' ) | ||
22924 | // InternalSolverLanguage.g:6890:2: '.' | ||
22925 | { | ||
22926 | if ( state.backtracking==0 ) { | ||
22927 | before(grammarAccess.getBoundedScopeDefinitionAccess().getFullStopKeyword_2()); | ||
22928 | } | ||
22929 | match(input,50,FOLLOW_2); if (state.failed) return ; | ||
22930 | if ( state.backtracking==0 ) { | ||
22931 | after(grammarAccess.getBoundedScopeDefinitionAccess().getFullStopKeyword_2()); | ||
22932 | } | ||
22933 | 21019 | ||
22934 | } | 21020 | } |
22935 | 21021 | ||
@@ -22948,29 +21034,29 @@ public class InternalSolverLanguageParser extends AbstractInternalContentAssistP | |||
22948 | } | 21034 | } |
22949 | return ; | 21035 | return ; |
22950 | } | 21036 | } |
22951 | // $ANTLR end "rule__BoundedScopeDefinition__Group__2__Impl" | 21037 | // $ANTLR end "rule__BoundedScopeDefinition__Group__1__Impl" |
22952 | 21038 | ||
22953 | 21039 | ||
22954 | // $ANTLR start "rule__BoundedScopeDefinition__Group_1_0__0" | 21040 | // $ANTLR start "rule__BoundedScopeDefinition__Group_1_0__0" |
22955 | // InternalSolverLanguage.g:6900:1: rule__BoundedScopeDefinition__Group_1_0__0 : rule__BoundedScopeDefinition__Group_1_0__0__Impl rule__BoundedScopeDefinition__Group_1_0__1 ; | 21041 | // InternalSolverLanguageParser.g:6817:1: rule__BoundedScopeDefinition__Group_1_0__0 : rule__BoundedScopeDefinition__Group_1_0__0__Impl rule__BoundedScopeDefinition__Group_1_0__1 ; |
22956 | public final void rule__BoundedScopeDefinition__Group_1_0__0() throws RecognitionException { | 21042 | public final void rule__BoundedScopeDefinition__Group_1_0__0() throws RecognitionException { |
22957 | 21043 | ||
22958 | int stackSize = keepStackSize(); | 21044 | int stackSize = keepStackSize(); |
22959 | 21045 | ||
22960 | try { | 21046 | try { |
22961 | // InternalSolverLanguage.g:6904:1: ( rule__BoundedScopeDefinition__Group_1_0__0__Impl rule__BoundedScopeDefinition__Group_1_0__1 ) | 21047 | // InternalSolverLanguageParser.g:6821:1: ( rule__BoundedScopeDefinition__Group_1_0__0__Impl rule__BoundedScopeDefinition__Group_1_0__1 ) |
22962 | // InternalSolverLanguage.g:6905:2: rule__BoundedScopeDefinition__Group_1_0__0__Impl rule__BoundedScopeDefinition__Group_1_0__1 | 21048 | // InternalSolverLanguageParser.g:6822:2: rule__BoundedScopeDefinition__Group_1_0__0__Impl rule__BoundedScopeDefinition__Group_1_0__1 |
22963 | { | 21049 | { |
22964 | pushFollow(FOLLOW_55); | 21050 | pushFollow(FOLLOW_54); |
22965 | rule__BoundedScopeDefinition__Group_1_0__0__Impl(); | 21051 | rule__BoundedScopeDefinition__Group_1_0__0__Impl(); |
22966 | 21052 | ||
22967 | state._fsp--; | 21053 | state._fsp--; |
22968 | if (state.failed) return ; | 21054 | |
22969 | pushFollow(FOLLOW_2); | 21055 | pushFollow(FOLLOW_2); |
22970 | rule__BoundedScopeDefinition__Group_1_0__1(); | 21056 | rule__BoundedScopeDefinition__Group_1_0__1(); |
22971 | 21057 | ||
22972 | state._fsp--; | 21058 | state._fsp--; |
22973 | if (state.failed) return ; | 21059 | |
22974 | 21060 | ||
22975 | } | 21061 | } |
22976 | 21062 | ||
@@ -22990,46 +21076,42 @@ public class InternalSolverLanguageParser extends AbstractInternalContentAssistP | |||
22990 | 21076 | ||
22991 | 21077 | ||
22992 | // $ANTLR start "rule__BoundedScopeDefinition__Group_1_0__0__Impl" | 21078 | // $ANTLR start "rule__BoundedScopeDefinition__Group_1_0__0__Impl" |
22993 | // InternalSolverLanguage.g:6912:1: rule__BoundedScopeDefinition__Group_1_0__0__Impl : ( ( rule__BoundedScopeDefinition__Group_1_0_0__0 )? ) ; | 21079 | // InternalSolverLanguageParser.g:6829:1: rule__BoundedScopeDefinition__Group_1_0__0__Impl : ( ( rule__BoundedScopeDefinition__Group_1_0_0__0 )? ) ; |
22994 | public final void rule__BoundedScopeDefinition__Group_1_0__0__Impl() throws RecognitionException { | 21080 | public final void rule__BoundedScopeDefinition__Group_1_0__0__Impl() throws RecognitionException { |
22995 | 21081 | ||
22996 | int stackSize = keepStackSize(); | 21082 | int stackSize = keepStackSize(); |
22997 | 21083 | ||
22998 | try { | 21084 | try { |
22999 | // InternalSolverLanguage.g:6916:1: ( ( ( rule__BoundedScopeDefinition__Group_1_0_0__0 )? ) ) | 21085 | // InternalSolverLanguageParser.g:6833:1: ( ( ( rule__BoundedScopeDefinition__Group_1_0_0__0 )? ) ) |
23000 | // InternalSolverLanguage.g:6917:1: ( ( rule__BoundedScopeDefinition__Group_1_0_0__0 )? ) | 21086 | // InternalSolverLanguageParser.g:6834:1: ( ( rule__BoundedScopeDefinition__Group_1_0_0__0 )? ) |
23001 | { | 21087 | { |
23002 | // InternalSolverLanguage.g:6917:1: ( ( rule__BoundedScopeDefinition__Group_1_0_0__0 )? ) | 21088 | // InternalSolverLanguageParser.g:6834:1: ( ( rule__BoundedScopeDefinition__Group_1_0_0__0 )? ) |
23003 | // InternalSolverLanguage.g:6918:2: ( rule__BoundedScopeDefinition__Group_1_0_0__0 )? | 21089 | // InternalSolverLanguageParser.g:6835:2: ( rule__BoundedScopeDefinition__Group_1_0_0__0 )? |
23004 | { | 21090 | { |
23005 | if ( state.backtracking==0 ) { | 21091 | before(grammarAccess.getBoundedScopeDefinitionAccess().getGroup_1_0_0()); |
23006 | before(grammarAccess.getBoundedScopeDefinitionAccess().getGroup_1_0_0()); | 21092 | // InternalSolverLanguageParser.g:6836:2: ( rule__BoundedScopeDefinition__Group_1_0_0__0 )? |
23007 | } | 21093 | int alt50=2; |
23008 | // InternalSolverLanguage.g:6919:2: ( rule__BoundedScopeDefinition__Group_1_0_0__0 )? | 21094 | int LA50_0 = input.LA(1); |
23009 | int alt51=2; | ||
23010 | int LA51_0 = input.LA(1); | ||
23011 | 21095 | ||
23012 | if ( (LA51_0==RULE_INT) ) { | 21096 | if ( (LA50_0==RULE_INT) ) { |
23013 | alt51=1; | 21097 | alt50=1; |
23014 | } | 21098 | } |
23015 | switch (alt51) { | 21099 | switch (alt50) { |
23016 | case 1 : | 21100 | case 1 : |
23017 | // InternalSolverLanguage.g:6919:3: rule__BoundedScopeDefinition__Group_1_0_0__0 | 21101 | // InternalSolverLanguageParser.g:6836:3: rule__BoundedScopeDefinition__Group_1_0_0__0 |
23018 | { | 21102 | { |
23019 | pushFollow(FOLLOW_2); | 21103 | pushFollow(FOLLOW_2); |
23020 | rule__BoundedScopeDefinition__Group_1_0_0__0(); | 21104 | rule__BoundedScopeDefinition__Group_1_0_0__0(); |
23021 | 21105 | ||
23022 | state._fsp--; | 21106 | state._fsp--; |
23023 | if (state.failed) return ; | 21107 | |
23024 | 21108 | ||
23025 | } | 21109 | } |
23026 | break; | 21110 | break; |
23027 | 21111 | ||
23028 | } | 21112 | } |
23029 | 21113 | ||
23030 | if ( state.backtracking==0 ) { | 21114 | after(grammarAccess.getBoundedScopeDefinitionAccess().getGroup_1_0_0()); |
23031 | after(grammarAccess.getBoundedScopeDefinitionAccess().getGroup_1_0_0()); | ||
23032 | } | ||
23033 | 21115 | ||
23034 | } | 21116 | } |
23035 | 21117 | ||
@@ -23052,25 +21134,25 @@ public class InternalSolverLanguageParser extends AbstractInternalContentAssistP | |||
23052 | 21134 | ||
23053 | 21135 | ||
23054 | // $ANTLR start "rule__BoundedScopeDefinition__Group_1_0__1" | 21136 | // $ANTLR start "rule__BoundedScopeDefinition__Group_1_0__1" |
23055 | // InternalSolverLanguage.g:6927:1: rule__BoundedScopeDefinition__Group_1_0__1 : rule__BoundedScopeDefinition__Group_1_0__1__Impl rule__BoundedScopeDefinition__Group_1_0__2 ; | 21137 | // InternalSolverLanguageParser.g:6844:1: rule__BoundedScopeDefinition__Group_1_0__1 : rule__BoundedScopeDefinition__Group_1_0__1__Impl rule__BoundedScopeDefinition__Group_1_0__2 ; |
23056 | public final void rule__BoundedScopeDefinition__Group_1_0__1() throws RecognitionException { | 21138 | public final void rule__BoundedScopeDefinition__Group_1_0__1() throws RecognitionException { |
23057 | 21139 | ||
23058 | int stackSize = keepStackSize(); | 21140 | int stackSize = keepStackSize(); |
23059 | 21141 | ||
23060 | try { | 21142 | try { |
23061 | // InternalSolverLanguage.g:6931:1: ( rule__BoundedScopeDefinition__Group_1_0__1__Impl rule__BoundedScopeDefinition__Group_1_0__2 ) | 21143 | // InternalSolverLanguageParser.g:6848:1: ( rule__BoundedScopeDefinition__Group_1_0__1__Impl rule__BoundedScopeDefinition__Group_1_0__2 ) |
23062 | // InternalSolverLanguage.g:6932:2: rule__BoundedScopeDefinition__Group_1_0__1__Impl rule__BoundedScopeDefinition__Group_1_0__2 | 21144 | // InternalSolverLanguageParser.g:6849:2: rule__BoundedScopeDefinition__Group_1_0__1__Impl rule__BoundedScopeDefinition__Group_1_0__2 |
23063 | { | 21145 | { |
23064 | pushFollow(FOLLOW_56); | 21146 | pushFollow(FOLLOW_55); |
23065 | rule__BoundedScopeDefinition__Group_1_0__1__Impl(); | 21147 | rule__BoundedScopeDefinition__Group_1_0__1__Impl(); |
23066 | 21148 | ||
23067 | state._fsp--; | 21149 | state._fsp--; |
23068 | if (state.failed) return ; | 21150 | |
23069 | pushFollow(FOLLOW_2); | 21151 | pushFollow(FOLLOW_2); |
23070 | rule__BoundedScopeDefinition__Group_1_0__2(); | 21152 | rule__BoundedScopeDefinition__Group_1_0__2(); |
23071 | 21153 | ||
23072 | state._fsp--; | 21154 | state._fsp--; |
23073 | if (state.failed) return ; | 21155 | |
23074 | 21156 | ||
23075 | } | 21157 | } |
23076 | 21158 | ||
@@ -23090,36 +21172,32 @@ public class InternalSolverLanguageParser extends AbstractInternalContentAssistP | |||
23090 | 21172 | ||
23091 | 21173 | ||
23092 | // $ANTLR start "rule__BoundedScopeDefinition__Group_1_0__1__Impl" | 21174 | // $ANTLR start "rule__BoundedScopeDefinition__Group_1_0__1__Impl" |
23093 | // InternalSolverLanguage.g:6939:1: rule__BoundedScopeDefinition__Group_1_0__1__Impl : ( ( rule__BoundedScopeDefinition__TypeAssignment_1_0_1 ) ) ; | 21175 | // InternalSolverLanguageParser.g:6856:1: rule__BoundedScopeDefinition__Group_1_0__1__Impl : ( ( rule__BoundedScopeDefinition__TypeAssignment_1_0_1 ) ) ; |
23094 | public final void rule__BoundedScopeDefinition__Group_1_0__1__Impl() throws RecognitionException { | 21176 | public final void rule__BoundedScopeDefinition__Group_1_0__1__Impl() throws RecognitionException { |
23095 | 21177 | ||
23096 | int stackSize = keepStackSize(); | 21178 | int stackSize = keepStackSize(); |
23097 | 21179 | ||
23098 | try { | 21180 | try { |
23099 | // InternalSolverLanguage.g:6943:1: ( ( ( rule__BoundedScopeDefinition__TypeAssignment_1_0_1 ) ) ) | 21181 | // InternalSolverLanguageParser.g:6860:1: ( ( ( rule__BoundedScopeDefinition__TypeAssignment_1_0_1 ) ) ) |
23100 | // InternalSolverLanguage.g:6944:1: ( ( rule__BoundedScopeDefinition__TypeAssignment_1_0_1 ) ) | 21182 | // InternalSolverLanguageParser.g:6861:1: ( ( rule__BoundedScopeDefinition__TypeAssignment_1_0_1 ) ) |
23101 | { | 21183 | { |
23102 | // InternalSolverLanguage.g:6944:1: ( ( rule__BoundedScopeDefinition__TypeAssignment_1_0_1 ) ) | 21184 | // InternalSolverLanguageParser.g:6861:1: ( ( rule__BoundedScopeDefinition__TypeAssignment_1_0_1 ) ) |
23103 | // InternalSolverLanguage.g:6945:2: ( rule__BoundedScopeDefinition__TypeAssignment_1_0_1 ) | 21185 | // InternalSolverLanguageParser.g:6862:2: ( rule__BoundedScopeDefinition__TypeAssignment_1_0_1 ) |
23104 | { | 21186 | { |
23105 | if ( state.backtracking==0 ) { | 21187 | before(grammarAccess.getBoundedScopeDefinitionAccess().getTypeAssignment_1_0_1()); |
23106 | before(grammarAccess.getBoundedScopeDefinitionAccess().getTypeAssignment_1_0_1()); | 21188 | // InternalSolverLanguageParser.g:6863:2: ( rule__BoundedScopeDefinition__TypeAssignment_1_0_1 ) |
23107 | } | 21189 | // InternalSolverLanguageParser.g:6863:3: rule__BoundedScopeDefinition__TypeAssignment_1_0_1 |
23108 | // InternalSolverLanguage.g:6946:2: ( rule__BoundedScopeDefinition__TypeAssignment_1_0_1 ) | ||
23109 | // InternalSolverLanguage.g:6946:3: rule__BoundedScopeDefinition__TypeAssignment_1_0_1 | ||
23110 | { | 21190 | { |
23111 | pushFollow(FOLLOW_2); | 21191 | pushFollow(FOLLOW_2); |
23112 | rule__BoundedScopeDefinition__TypeAssignment_1_0_1(); | 21192 | rule__BoundedScopeDefinition__TypeAssignment_1_0_1(); |
23113 | 21193 | ||
23114 | state._fsp--; | 21194 | state._fsp--; |
23115 | if (state.failed) return ; | ||
23116 | 21195 | ||
23117 | } | ||
23118 | 21196 | ||
23119 | if ( state.backtracking==0 ) { | ||
23120 | after(grammarAccess.getBoundedScopeDefinitionAccess().getTypeAssignment_1_0_1()); | ||
23121 | } | 21197 | } |
23122 | 21198 | ||
21199 | after(grammarAccess.getBoundedScopeDefinitionAccess().getTypeAssignment_1_0_1()); | ||
21200 | |||
23123 | } | 21201 | } |
23124 | 21202 | ||
23125 | 21203 | ||
@@ -23141,25 +21219,25 @@ public class InternalSolverLanguageParser extends AbstractInternalContentAssistP | |||
23141 | 21219 | ||
23142 | 21220 | ||
23143 | // $ANTLR start "rule__BoundedScopeDefinition__Group_1_0__2" | 21221 | // $ANTLR start "rule__BoundedScopeDefinition__Group_1_0__2" |
23144 | // InternalSolverLanguage.g:6954:1: rule__BoundedScopeDefinition__Group_1_0__2 : rule__BoundedScopeDefinition__Group_1_0__2__Impl rule__BoundedScopeDefinition__Group_1_0__3 ; | 21222 | // InternalSolverLanguageParser.g:6871:1: rule__BoundedScopeDefinition__Group_1_0__2 : rule__BoundedScopeDefinition__Group_1_0__2__Impl rule__BoundedScopeDefinition__Group_1_0__3 ; |
23145 | public final void rule__BoundedScopeDefinition__Group_1_0__2() throws RecognitionException { | 21223 | public final void rule__BoundedScopeDefinition__Group_1_0__2() throws RecognitionException { |
23146 | 21224 | ||
23147 | int stackSize = keepStackSize(); | 21225 | int stackSize = keepStackSize(); |
23148 | 21226 | ||
23149 | try { | 21227 | try { |
23150 | // InternalSolverLanguage.g:6958:1: ( rule__BoundedScopeDefinition__Group_1_0__2__Impl rule__BoundedScopeDefinition__Group_1_0__3 ) | 21228 | // InternalSolverLanguageParser.g:6875:1: ( rule__BoundedScopeDefinition__Group_1_0__2__Impl rule__BoundedScopeDefinition__Group_1_0__3 ) |
23151 | // InternalSolverLanguage.g:6959:2: rule__BoundedScopeDefinition__Group_1_0__2__Impl rule__BoundedScopeDefinition__Group_1_0__3 | 21229 | // InternalSolverLanguageParser.g:6876:2: rule__BoundedScopeDefinition__Group_1_0__2__Impl rule__BoundedScopeDefinition__Group_1_0__3 |
23152 | { | 21230 | { |
23153 | pushFollow(FOLLOW_53); | 21231 | pushFollow(FOLLOW_52); |
23154 | rule__BoundedScopeDefinition__Group_1_0__2__Impl(); | 21232 | rule__BoundedScopeDefinition__Group_1_0__2__Impl(); |
23155 | 21233 | ||
23156 | state._fsp--; | 21234 | state._fsp--; |
23157 | if (state.failed) return ; | 21235 | |
23158 | pushFollow(FOLLOW_2); | 21236 | pushFollow(FOLLOW_2); |
23159 | rule__BoundedScopeDefinition__Group_1_0__3(); | 21237 | rule__BoundedScopeDefinition__Group_1_0__3(); |
23160 | 21238 | ||
23161 | state._fsp--; | 21239 | state._fsp--; |
23162 | if (state.failed) return ; | 21240 | |
23163 | 21241 | ||
23164 | } | 21242 | } |
23165 | 21243 | ||
@@ -23179,25 +21257,21 @@ public class InternalSolverLanguageParser extends AbstractInternalContentAssistP | |||
23179 | 21257 | ||
23180 | 21258 | ||
23181 | // $ANTLR start "rule__BoundedScopeDefinition__Group_1_0__2__Impl" | 21259 | // $ANTLR start "rule__BoundedScopeDefinition__Group_1_0__2__Impl" |
23182 | // InternalSolverLanguage.g:6966:1: rule__BoundedScopeDefinition__Group_1_0__2__Impl : ( '<=' ) ; | 21260 | // InternalSolverLanguageParser.g:6883:1: rule__BoundedScopeDefinition__Group_1_0__2__Impl : ( LessThanSignEqualsSign ) ; |
23183 | public final void rule__BoundedScopeDefinition__Group_1_0__2__Impl() throws RecognitionException { | 21261 | public final void rule__BoundedScopeDefinition__Group_1_0__2__Impl() throws RecognitionException { |
23184 | 21262 | ||
23185 | int stackSize = keepStackSize(); | 21263 | int stackSize = keepStackSize(); |
23186 | 21264 | ||
23187 | try { | 21265 | try { |
23188 | // InternalSolverLanguage.g:6970:1: ( ( '<=' ) ) | 21266 | // InternalSolverLanguageParser.g:6887:1: ( ( LessThanSignEqualsSign ) ) |
23189 | // InternalSolverLanguage.g:6971:1: ( '<=' ) | 21267 | // InternalSolverLanguageParser.g:6888:1: ( LessThanSignEqualsSign ) |
23190 | { | 21268 | { |
23191 | // InternalSolverLanguage.g:6971:1: ( '<=' ) | 21269 | // InternalSolverLanguageParser.g:6888:1: ( LessThanSignEqualsSign ) |
23192 | // InternalSolverLanguage.g:6972:2: '<=' | 21270 | // InternalSolverLanguageParser.g:6889:2: LessThanSignEqualsSign |
23193 | { | 21271 | { |
23194 | if ( state.backtracking==0 ) { | 21272 | before(grammarAccess.getBoundedScopeDefinitionAccess().getLessThanSignEqualsSignKeyword_1_0_2()); |
23195 | before(grammarAccess.getBoundedScopeDefinitionAccess().getLessThanSignEqualsSignKeyword_1_0_2()); | 21273 | match(input,LessThanSignEqualsSign,FOLLOW_2); |
23196 | } | 21274 | after(grammarAccess.getBoundedScopeDefinitionAccess().getLessThanSignEqualsSignKeyword_1_0_2()); |
23197 | match(input,22,FOLLOW_2); if (state.failed) return ; | ||
23198 | if ( state.backtracking==0 ) { | ||
23199 | after(grammarAccess.getBoundedScopeDefinitionAccess().getLessThanSignEqualsSignKeyword_1_0_2()); | ||
23200 | } | ||
23201 | 21275 | ||
23202 | } | 21276 | } |
23203 | 21277 | ||
@@ -23220,20 +21294,20 @@ public class InternalSolverLanguageParser extends AbstractInternalContentAssistP | |||
23220 | 21294 | ||
23221 | 21295 | ||
23222 | // $ANTLR start "rule__BoundedScopeDefinition__Group_1_0__3" | 21296 | // $ANTLR start "rule__BoundedScopeDefinition__Group_1_0__3" |
23223 | // InternalSolverLanguage.g:6981:1: rule__BoundedScopeDefinition__Group_1_0__3 : rule__BoundedScopeDefinition__Group_1_0__3__Impl ; | 21297 | // InternalSolverLanguageParser.g:6898:1: rule__BoundedScopeDefinition__Group_1_0__3 : rule__BoundedScopeDefinition__Group_1_0__3__Impl ; |
23224 | public final void rule__BoundedScopeDefinition__Group_1_0__3() throws RecognitionException { | 21298 | public final void rule__BoundedScopeDefinition__Group_1_0__3() throws RecognitionException { |
23225 | 21299 | ||
23226 | int stackSize = keepStackSize(); | 21300 | int stackSize = keepStackSize(); |
23227 | 21301 | ||
23228 | try { | 21302 | try { |
23229 | // InternalSolverLanguage.g:6985:1: ( rule__BoundedScopeDefinition__Group_1_0__3__Impl ) | 21303 | // InternalSolverLanguageParser.g:6902:1: ( rule__BoundedScopeDefinition__Group_1_0__3__Impl ) |
23230 | // InternalSolverLanguage.g:6986:2: rule__BoundedScopeDefinition__Group_1_0__3__Impl | 21304 | // InternalSolverLanguageParser.g:6903:2: rule__BoundedScopeDefinition__Group_1_0__3__Impl |
23231 | { | 21305 | { |
23232 | pushFollow(FOLLOW_2); | 21306 | pushFollow(FOLLOW_2); |
23233 | rule__BoundedScopeDefinition__Group_1_0__3__Impl(); | 21307 | rule__BoundedScopeDefinition__Group_1_0__3__Impl(); |
23234 | 21308 | ||
23235 | state._fsp--; | 21309 | state._fsp--; |
23236 | if (state.failed) return ; | 21310 | |
23237 | 21311 | ||
23238 | } | 21312 | } |
23239 | 21313 | ||
@@ -23253,36 +21327,32 @@ public class InternalSolverLanguageParser extends AbstractInternalContentAssistP | |||
23253 | 21327 | ||
23254 | 21328 | ||
23255 | // $ANTLR start "rule__BoundedScopeDefinition__Group_1_0__3__Impl" | 21329 | // $ANTLR start "rule__BoundedScopeDefinition__Group_1_0__3__Impl" |
23256 | // InternalSolverLanguage.g:6992:1: rule__BoundedScopeDefinition__Group_1_0__3__Impl : ( ( rule__BoundedScopeDefinition__UpperBoundAssignment_1_0_3 ) ) ; | 21330 | // InternalSolverLanguageParser.g:6909:1: rule__BoundedScopeDefinition__Group_1_0__3__Impl : ( ( rule__BoundedScopeDefinition__UpperBoundAssignment_1_0_3 ) ) ; |
23257 | public final void rule__BoundedScopeDefinition__Group_1_0__3__Impl() throws RecognitionException { | 21331 | public final void rule__BoundedScopeDefinition__Group_1_0__3__Impl() throws RecognitionException { |
23258 | 21332 | ||
23259 | int stackSize = keepStackSize(); | 21333 | int stackSize = keepStackSize(); |
23260 | 21334 | ||
23261 | try { | 21335 | try { |
23262 | // InternalSolverLanguage.g:6996:1: ( ( ( rule__BoundedScopeDefinition__UpperBoundAssignment_1_0_3 ) ) ) | 21336 | // InternalSolverLanguageParser.g:6913:1: ( ( ( rule__BoundedScopeDefinition__UpperBoundAssignment_1_0_3 ) ) ) |
23263 | // InternalSolverLanguage.g:6997:1: ( ( rule__BoundedScopeDefinition__UpperBoundAssignment_1_0_3 ) ) | 21337 | // InternalSolverLanguageParser.g:6914:1: ( ( rule__BoundedScopeDefinition__UpperBoundAssignment_1_0_3 ) ) |
23264 | { | 21338 | { |
23265 | // InternalSolverLanguage.g:6997:1: ( ( rule__BoundedScopeDefinition__UpperBoundAssignment_1_0_3 ) ) | 21339 | // InternalSolverLanguageParser.g:6914:1: ( ( rule__BoundedScopeDefinition__UpperBoundAssignment_1_0_3 ) ) |
23266 | // InternalSolverLanguage.g:6998:2: ( rule__BoundedScopeDefinition__UpperBoundAssignment_1_0_3 ) | 21340 | // InternalSolverLanguageParser.g:6915:2: ( rule__BoundedScopeDefinition__UpperBoundAssignment_1_0_3 ) |
23267 | { | 21341 | { |
23268 | if ( state.backtracking==0 ) { | 21342 | before(grammarAccess.getBoundedScopeDefinitionAccess().getUpperBoundAssignment_1_0_3()); |
23269 | before(grammarAccess.getBoundedScopeDefinitionAccess().getUpperBoundAssignment_1_0_3()); | 21343 | // InternalSolverLanguageParser.g:6916:2: ( rule__BoundedScopeDefinition__UpperBoundAssignment_1_0_3 ) |
23270 | } | 21344 | // InternalSolverLanguageParser.g:6916:3: rule__BoundedScopeDefinition__UpperBoundAssignment_1_0_3 |
23271 | // InternalSolverLanguage.g:6999:2: ( rule__BoundedScopeDefinition__UpperBoundAssignment_1_0_3 ) | ||
23272 | // InternalSolverLanguage.g:6999:3: rule__BoundedScopeDefinition__UpperBoundAssignment_1_0_3 | ||
23273 | { | 21345 | { |
23274 | pushFollow(FOLLOW_2); | 21346 | pushFollow(FOLLOW_2); |
23275 | rule__BoundedScopeDefinition__UpperBoundAssignment_1_0_3(); | 21347 | rule__BoundedScopeDefinition__UpperBoundAssignment_1_0_3(); |
23276 | 21348 | ||
23277 | state._fsp--; | 21349 | state._fsp--; |
23278 | if (state.failed) return ; | ||
23279 | 21350 | ||
23280 | } | ||
23281 | 21351 | ||
23282 | if ( state.backtracking==0 ) { | ||
23283 | after(grammarAccess.getBoundedScopeDefinitionAccess().getUpperBoundAssignment_1_0_3()); | ||
23284 | } | 21352 | } |
23285 | 21353 | ||
21354 | after(grammarAccess.getBoundedScopeDefinitionAccess().getUpperBoundAssignment_1_0_3()); | ||
21355 | |||
23286 | } | 21356 | } |
23287 | 21357 | ||
23288 | 21358 | ||
@@ -23304,25 +21374,25 @@ public class InternalSolverLanguageParser extends AbstractInternalContentAssistP | |||
23304 | 21374 | ||
23305 | 21375 | ||
23306 | // $ANTLR start "rule__BoundedScopeDefinition__Group_1_0_0__0" | 21376 | // $ANTLR start "rule__BoundedScopeDefinition__Group_1_0_0__0" |
23307 | // InternalSolverLanguage.g:7008:1: rule__BoundedScopeDefinition__Group_1_0_0__0 : rule__BoundedScopeDefinition__Group_1_0_0__0__Impl rule__BoundedScopeDefinition__Group_1_0_0__1 ; | 21377 | // InternalSolverLanguageParser.g:6925:1: rule__BoundedScopeDefinition__Group_1_0_0__0 : rule__BoundedScopeDefinition__Group_1_0_0__0__Impl rule__BoundedScopeDefinition__Group_1_0_0__1 ; |
23308 | public final void rule__BoundedScopeDefinition__Group_1_0_0__0() throws RecognitionException { | 21378 | public final void rule__BoundedScopeDefinition__Group_1_0_0__0() throws RecognitionException { |
23309 | 21379 | ||
23310 | int stackSize = keepStackSize(); | 21380 | int stackSize = keepStackSize(); |
23311 | 21381 | ||
23312 | try { | 21382 | try { |
23313 | // InternalSolverLanguage.g:7012:1: ( rule__BoundedScopeDefinition__Group_1_0_0__0__Impl rule__BoundedScopeDefinition__Group_1_0_0__1 ) | 21383 | // InternalSolverLanguageParser.g:6929:1: ( rule__BoundedScopeDefinition__Group_1_0_0__0__Impl rule__BoundedScopeDefinition__Group_1_0_0__1 ) |
23314 | // InternalSolverLanguage.g:7013:2: rule__BoundedScopeDefinition__Group_1_0_0__0__Impl rule__BoundedScopeDefinition__Group_1_0_0__1 | 21384 | // InternalSolverLanguageParser.g:6930:2: rule__BoundedScopeDefinition__Group_1_0_0__0__Impl rule__BoundedScopeDefinition__Group_1_0_0__1 |
23315 | { | 21385 | { |
23316 | pushFollow(FOLLOW_56); | 21386 | pushFollow(FOLLOW_55); |
23317 | rule__BoundedScopeDefinition__Group_1_0_0__0__Impl(); | 21387 | rule__BoundedScopeDefinition__Group_1_0_0__0__Impl(); |
23318 | 21388 | ||
23319 | state._fsp--; | 21389 | state._fsp--; |
23320 | if (state.failed) return ; | 21390 | |
23321 | pushFollow(FOLLOW_2); | 21391 | pushFollow(FOLLOW_2); |
23322 | rule__BoundedScopeDefinition__Group_1_0_0__1(); | 21392 | rule__BoundedScopeDefinition__Group_1_0_0__1(); |
23323 | 21393 | ||
23324 | state._fsp--; | 21394 | state._fsp--; |
23325 | if (state.failed) return ; | 21395 | |
23326 | 21396 | ||
23327 | } | 21397 | } |
23328 | 21398 | ||
@@ -23342,36 +21412,32 @@ public class InternalSolverLanguageParser extends AbstractInternalContentAssistP | |||
23342 | 21412 | ||
23343 | 21413 | ||
23344 | // $ANTLR start "rule__BoundedScopeDefinition__Group_1_0_0__0__Impl" | 21414 | // $ANTLR start "rule__BoundedScopeDefinition__Group_1_0_0__0__Impl" |
23345 | // InternalSolverLanguage.g:7020:1: rule__BoundedScopeDefinition__Group_1_0_0__0__Impl : ( ( rule__BoundedScopeDefinition__LowerBoundAssignment_1_0_0_0 ) ) ; | 21415 | // InternalSolverLanguageParser.g:6937:1: rule__BoundedScopeDefinition__Group_1_0_0__0__Impl : ( ( rule__BoundedScopeDefinition__LowerBoundAssignment_1_0_0_0 ) ) ; |
23346 | public final void rule__BoundedScopeDefinition__Group_1_0_0__0__Impl() throws RecognitionException { | 21416 | public final void rule__BoundedScopeDefinition__Group_1_0_0__0__Impl() throws RecognitionException { |
23347 | 21417 | ||
23348 | int stackSize = keepStackSize(); | 21418 | int stackSize = keepStackSize(); |
23349 | 21419 | ||
23350 | try { | 21420 | try { |
23351 | // InternalSolverLanguage.g:7024:1: ( ( ( rule__BoundedScopeDefinition__LowerBoundAssignment_1_0_0_0 ) ) ) | 21421 | // InternalSolverLanguageParser.g:6941:1: ( ( ( rule__BoundedScopeDefinition__LowerBoundAssignment_1_0_0_0 ) ) ) |
23352 | // InternalSolverLanguage.g:7025:1: ( ( rule__BoundedScopeDefinition__LowerBoundAssignment_1_0_0_0 ) ) | 21422 | // InternalSolverLanguageParser.g:6942:1: ( ( rule__BoundedScopeDefinition__LowerBoundAssignment_1_0_0_0 ) ) |
23353 | { | 21423 | { |
23354 | // InternalSolverLanguage.g:7025:1: ( ( rule__BoundedScopeDefinition__LowerBoundAssignment_1_0_0_0 ) ) | 21424 | // InternalSolverLanguageParser.g:6942:1: ( ( rule__BoundedScopeDefinition__LowerBoundAssignment_1_0_0_0 ) ) |
23355 | // InternalSolverLanguage.g:7026:2: ( rule__BoundedScopeDefinition__LowerBoundAssignment_1_0_0_0 ) | 21425 | // InternalSolverLanguageParser.g:6943:2: ( rule__BoundedScopeDefinition__LowerBoundAssignment_1_0_0_0 ) |
23356 | { | 21426 | { |
23357 | if ( state.backtracking==0 ) { | 21427 | before(grammarAccess.getBoundedScopeDefinitionAccess().getLowerBoundAssignment_1_0_0_0()); |
23358 | before(grammarAccess.getBoundedScopeDefinitionAccess().getLowerBoundAssignment_1_0_0_0()); | 21428 | // InternalSolverLanguageParser.g:6944:2: ( rule__BoundedScopeDefinition__LowerBoundAssignment_1_0_0_0 ) |
23359 | } | 21429 | // InternalSolverLanguageParser.g:6944:3: rule__BoundedScopeDefinition__LowerBoundAssignment_1_0_0_0 |
23360 | // InternalSolverLanguage.g:7027:2: ( rule__BoundedScopeDefinition__LowerBoundAssignment_1_0_0_0 ) | ||
23361 | // InternalSolverLanguage.g:7027:3: rule__BoundedScopeDefinition__LowerBoundAssignment_1_0_0_0 | ||
23362 | { | 21430 | { |
23363 | pushFollow(FOLLOW_2); | 21431 | pushFollow(FOLLOW_2); |
23364 | rule__BoundedScopeDefinition__LowerBoundAssignment_1_0_0_0(); | 21432 | rule__BoundedScopeDefinition__LowerBoundAssignment_1_0_0_0(); |
23365 | 21433 | ||
23366 | state._fsp--; | 21434 | state._fsp--; |
23367 | if (state.failed) return ; | ||
23368 | 21435 | ||
23369 | } | ||
23370 | 21436 | ||
23371 | if ( state.backtracking==0 ) { | ||
23372 | after(grammarAccess.getBoundedScopeDefinitionAccess().getLowerBoundAssignment_1_0_0_0()); | ||
23373 | } | 21437 | } |
23374 | 21438 | ||
21439 | after(grammarAccess.getBoundedScopeDefinitionAccess().getLowerBoundAssignment_1_0_0_0()); | ||
21440 | |||
23375 | } | 21441 | } |
23376 | 21442 | ||
23377 | 21443 | ||
@@ -23393,20 +21459,20 @@ public class InternalSolverLanguageParser extends AbstractInternalContentAssistP | |||
23393 | 21459 | ||
23394 | 21460 | ||
23395 | // $ANTLR start "rule__BoundedScopeDefinition__Group_1_0_0__1" | 21461 | // $ANTLR start "rule__BoundedScopeDefinition__Group_1_0_0__1" |
23396 | // InternalSolverLanguage.g:7035:1: rule__BoundedScopeDefinition__Group_1_0_0__1 : rule__BoundedScopeDefinition__Group_1_0_0__1__Impl ; | 21462 | // InternalSolverLanguageParser.g:6952:1: rule__BoundedScopeDefinition__Group_1_0_0__1 : rule__BoundedScopeDefinition__Group_1_0_0__1__Impl ; |
23397 | public final void rule__BoundedScopeDefinition__Group_1_0_0__1() throws RecognitionException { | 21463 | public final void rule__BoundedScopeDefinition__Group_1_0_0__1() throws RecognitionException { |
23398 | 21464 | ||
23399 | int stackSize = keepStackSize(); | 21465 | int stackSize = keepStackSize(); |
23400 | 21466 | ||
23401 | try { | 21467 | try { |
23402 | // InternalSolverLanguage.g:7039:1: ( rule__BoundedScopeDefinition__Group_1_0_0__1__Impl ) | 21468 | // InternalSolverLanguageParser.g:6956:1: ( rule__BoundedScopeDefinition__Group_1_0_0__1__Impl ) |
23403 | // InternalSolverLanguage.g:7040:2: rule__BoundedScopeDefinition__Group_1_0_0__1__Impl | 21469 | // InternalSolverLanguageParser.g:6957:2: rule__BoundedScopeDefinition__Group_1_0_0__1__Impl |
23404 | { | 21470 | { |
23405 | pushFollow(FOLLOW_2); | 21471 | pushFollow(FOLLOW_2); |
23406 | rule__BoundedScopeDefinition__Group_1_0_0__1__Impl(); | 21472 | rule__BoundedScopeDefinition__Group_1_0_0__1__Impl(); |
23407 | 21473 | ||
23408 | state._fsp--; | 21474 | state._fsp--; |
23409 | if (state.failed) return ; | 21475 | |
23410 | 21476 | ||
23411 | } | 21477 | } |
23412 | 21478 | ||
@@ -23426,25 +21492,21 @@ public class InternalSolverLanguageParser extends AbstractInternalContentAssistP | |||
23426 | 21492 | ||
23427 | 21493 | ||
23428 | // $ANTLR start "rule__BoundedScopeDefinition__Group_1_0_0__1__Impl" | 21494 | // $ANTLR start "rule__BoundedScopeDefinition__Group_1_0_0__1__Impl" |
23429 | // InternalSolverLanguage.g:7046:1: rule__BoundedScopeDefinition__Group_1_0_0__1__Impl : ( '<=' ) ; | 21495 | // InternalSolverLanguageParser.g:6963:1: rule__BoundedScopeDefinition__Group_1_0_0__1__Impl : ( LessThanSignEqualsSign ) ; |
23430 | public final void rule__BoundedScopeDefinition__Group_1_0_0__1__Impl() throws RecognitionException { | 21496 | public final void rule__BoundedScopeDefinition__Group_1_0_0__1__Impl() throws RecognitionException { |
23431 | 21497 | ||
23432 | int stackSize = keepStackSize(); | 21498 | int stackSize = keepStackSize(); |
23433 | 21499 | ||
23434 | try { | 21500 | try { |
23435 | // InternalSolverLanguage.g:7050:1: ( ( '<=' ) ) | 21501 | // InternalSolverLanguageParser.g:6967:1: ( ( LessThanSignEqualsSign ) ) |
23436 | // InternalSolverLanguage.g:7051:1: ( '<=' ) | 21502 | // InternalSolverLanguageParser.g:6968:1: ( LessThanSignEqualsSign ) |
23437 | { | 21503 | { |
23438 | // InternalSolverLanguage.g:7051:1: ( '<=' ) | 21504 | // InternalSolverLanguageParser.g:6968:1: ( LessThanSignEqualsSign ) |
23439 | // InternalSolverLanguage.g:7052:2: '<=' | 21505 | // InternalSolverLanguageParser.g:6969:2: LessThanSignEqualsSign |
23440 | { | 21506 | { |
23441 | if ( state.backtracking==0 ) { | 21507 | before(grammarAccess.getBoundedScopeDefinitionAccess().getLessThanSignEqualsSignKeyword_1_0_0_1()); |
23442 | before(grammarAccess.getBoundedScopeDefinitionAccess().getLessThanSignEqualsSignKeyword_1_0_0_1()); | 21508 | match(input,LessThanSignEqualsSign,FOLLOW_2); |
23443 | } | 21509 | after(grammarAccess.getBoundedScopeDefinitionAccess().getLessThanSignEqualsSignKeyword_1_0_0_1()); |
23444 | match(input,22,FOLLOW_2); if (state.failed) return ; | ||
23445 | if ( state.backtracking==0 ) { | ||
23446 | after(grammarAccess.getBoundedScopeDefinitionAccess().getLessThanSignEqualsSignKeyword_1_0_0_1()); | ||
23447 | } | ||
23448 | 21510 | ||
23449 | } | 21511 | } |
23450 | 21512 | ||
@@ -23467,25 +21529,25 @@ public class InternalSolverLanguageParser extends AbstractInternalContentAssistP | |||
23467 | 21529 | ||
23468 | 21530 | ||
23469 | // $ANTLR start "rule__BoundedScopeDefinition__Group_1_1__0" | 21531 | // $ANTLR start "rule__BoundedScopeDefinition__Group_1_1__0" |
23470 | // InternalSolverLanguage.g:7062:1: rule__BoundedScopeDefinition__Group_1_1__0 : rule__BoundedScopeDefinition__Group_1_1__0__Impl rule__BoundedScopeDefinition__Group_1_1__1 ; | 21532 | // InternalSolverLanguageParser.g:6979:1: rule__BoundedScopeDefinition__Group_1_1__0 : rule__BoundedScopeDefinition__Group_1_1__0__Impl rule__BoundedScopeDefinition__Group_1_1__1 ; |
23471 | public final void rule__BoundedScopeDefinition__Group_1_1__0() throws RecognitionException { | 21533 | public final void rule__BoundedScopeDefinition__Group_1_1__0() throws RecognitionException { |
23472 | 21534 | ||
23473 | int stackSize = keepStackSize(); | 21535 | int stackSize = keepStackSize(); |
23474 | 21536 | ||
23475 | try { | 21537 | try { |
23476 | // InternalSolverLanguage.g:7066:1: ( rule__BoundedScopeDefinition__Group_1_1__0__Impl rule__BoundedScopeDefinition__Group_1_1__1 ) | 21538 | // InternalSolverLanguageParser.g:6983:1: ( rule__BoundedScopeDefinition__Group_1_1__0__Impl rule__BoundedScopeDefinition__Group_1_1__1 ) |
23477 | // InternalSolverLanguage.g:7067:2: rule__BoundedScopeDefinition__Group_1_1__0__Impl rule__BoundedScopeDefinition__Group_1_1__1 | 21539 | // InternalSolverLanguageParser.g:6984:2: rule__BoundedScopeDefinition__Group_1_1__0__Impl rule__BoundedScopeDefinition__Group_1_1__1 |
23478 | { | 21540 | { |
23479 | pushFollow(FOLLOW_57); | 21541 | pushFollow(FOLLOW_56); |
23480 | rule__BoundedScopeDefinition__Group_1_1__0__Impl(); | 21542 | rule__BoundedScopeDefinition__Group_1_1__0__Impl(); |
23481 | 21543 | ||
23482 | state._fsp--; | 21544 | state._fsp--; |
23483 | if (state.failed) return ; | 21545 | |
23484 | pushFollow(FOLLOW_2); | 21546 | pushFollow(FOLLOW_2); |
23485 | rule__BoundedScopeDefinition__Group_1_1__1(); | 21547 | rule__BoundedScopeDefinition__Group_1_1__1(); |
23486 | 21548 | ||
23487 | state._fsp--; | 21549 | state._fsp--; |
23488 | if (state.failed) return ; | 21550 | |
23489 | 21551 | ||
23490 | } | 21552 | } |
23491 | 21553 | ||
@@ -23505,36 +21567,32 @@ public class InternalSolverLanguageParser extends AbstractInternalContentAssistP | |||
23505 | 21567 | ||
23506 | 21568 | ||
23507 | // $ANTLR start "rule__BoundedScopeDefinition__Group_1_1__0__Impl" | 21569 | // $ANTLR start "rule__BoundedScopeDefinition__Group_1_1__0__Impl" |
23508 | // InternalSolverLanguage.g:7074:1: rule__BoundedScopeDefinition__Group_1_1__0__Impl : ( ( rule__BoundedScopeDefinition__UpperBoundAssignment_1_1_0 ) ) ; | 21570 | // InternalSolverLanguageParser.g:6991:1: rule__BoundedScopeDefinition__Group_1_1__0__Impl : ( ( rule__BoundedScopeDefinition__UpperBoundAssignment_1_1_0 ) ) ; |
23509 | public final void rule__BoundedScopeDefinition__Group_1_1__0__Impl() throws RecognitionException { | 21571 | public final void rule__BoundedScopeDefinition__Group_1_1__0__Impl() throws RecognitionException { |
23510 | 21572 | ||
23511 | int stackSize = keepStackSize(); | 21573 | int stackSize = keepStackSize(); |
23512 | 21574 | ||
23513 | try { | 21575 | try { |
23514 | // InternalSolverLanguage.g:7078:1: ( ( ( rule__BoundedScopeDefinition__UpperBoundAssignment_1_1_0 ) ) ) | 21576 | // InternalSolverLanguageParser.g:6995:1: ( ( ( rule__BoundedScopeDefinition__UpperBoundAssignment_1_1_0 ) ) ) |
23515 | // InternalSolverLanguage.g:7079:1: ( ( rule__BoundedScopeDefinition__UpperBoundAssignment_1_1_0 ) ) | 21577 | // InternalSolverLanguageParser.g:6996:1: ( ( rule__BoundedScopeDefinition__UpperBoundAssignment_1_1_0 ) ) |
23516 | { | 21578 | { |
23517 | // InternalSolverLanguage.g:7079:1: ( ( rule__BoundedScopeDefinition__UpperBoundAssignment_1_1_0 ) ) | 21579 | // InternalSolverLanguageParser.g:6996:1: ( ( rule__BoundedScopeDefinition__UpperBoundAssignment_1_1_0 ) ) |
23518 | // InternalSolverLanguage.g:7080:2: ( rule__BoundedScopeDefinition__UpperBoundAssignment_1_1_0 ) | 21580 | // InternalSolverLanguageParser.g:6997:2: ( rule__BoundedScopeDefinition__UpperBoundAssignment_1_1_0 ) |
23519 | { | 21581 | { |
23520 | if ( state.backtracking==0 ) { | 21582 | before(grammarAccess.getBoundedScopeDefinitionAccess().getUpperBoundAssignment_1_1_0()); |
23521 | before(grammarAccess.getBoundedScopeDefinitionAccess().getUpperBoundAssignment_1_1_0()); | 21583 | // InternalSolverLanguageParser.g:6998:2: ( rule__BoundedScopeDefinition__UpperBoundAssignment_1_1_0 ) |
23522 | } | 21584 | // InternalSolverLanguageParser.g:6998:3: rule__BoundedScopeDefinition__UpperBoundAssignment_1_1_0 |
23523 | // InternalSolverLanguage.g:7081:2: ( rule__BoundedScopeDefinition__UpperBoundAssignment_1_1_0 ) | ||
23524 | // InternalSolverLanguage.g:7081:3: rule__BoundedScopeDefinition__UpperBoundAssignment_1_1_0 | ||
23525 | { | 21585 | { |
23526 | pushFollow(FOLLOW_2); | 21586 | pushFollow(FOLLOW_2); |
23527 | rule__BoundedScopeDefinition__UpperBoundAssignment_1_1_0(); | 21587 | rule__BoundedScopeDefinition__UpperBoundAssignment_1_1_0(); |
23528 | 21588 | ||
23529 | state._fsp--; | 21589 | state._fsp--; |
23530 | if (state.failed) return ; | ||
23531 | 21590 | ||
23532 | } | ||
23533 | 21591 | ||
23534 | if ( state.backtracking==0 ) { | ||
23535 | after(grammarAccess.getBoundedScopeDefinitionAccess().getUpperBoundAssignment_1_1_0()); | ||
23536 | } | 21592 | } |
23537 | 21593 | ||
21594 | after(grammarAccess.getBoundedScopeDefinitionAccess().getUpperBoundAssignment_1_1_0()); | ||
21595 | |||
23538 | } | 21596 | } |
23539 | 21597 | ||
23540 | 21598 | ||
@@ -23556,25 +21614,25 @@ public class InternalSolverLanguageParser extends AbstractInternalContentAssistP | |||
23556 | 21614 | ||
23557 | 21615 | ||
23558 | // $ANTLR start "rule__BoundedScopeDefinition__Group_1_1__1" | 21616 | // $ANTLR start "rule__BoundedScopeDefinition__Group_1_1__1" |
23559 | // InternalSolverLanguage.g:7089:1: rule__BoundedScopeDefinition__Group_1_1__1 : rule__BoundedScopeDefinition__Group_1_1__1__Impl rule__BoundedScopeDefinition__Group_1_1__2 ; | 21617 | // InternalSolverLanguageParser.g:7006:1: rule__BoundedScopeDefinition__Group_1_1__1 : rule__BoundedScopeDefinition__Group_1_1__1__Impl rule__BoundedScopeDefinition__Group_1_1__2 ; |
23560 | public final void rule__BoundedScopeDefinition__Group_1_1__1() throws RecognitionException { | 21618 | public final void rule__BoundedScopeDefinition__Group_1_1__1() throws RecognitionException { |
23561 | 21619 | ||
23562 | int stackSize = keepStackSize(); | 21620 | int stackSize = keepStackSize(); |
23563 | 21621 | ||
23564 | try { | 21622 | try { |
23565 | // InternalSolverLanguage.g:7093:1: ( rule__BoundedScopeDefinition__Group_1_1__1__Impl rule__BoundedScopeDefinition__Group_1_1__2 ) | 21623 | // InternalSolverLanguageParser.g:7010:1: ( rule__BoundedScopeDefinition__Group_1_1__1__Impl rule__BoundedScopeDefinition__Group_1_1__2 ) |
23566 | // InternalSolverLanguage.g:7094:2: rule__BoundedScopeDefinition__Group_1_1__1__Impl rule__BoundedScopeDefinition__Group_1_1__2 | 21624 | // InternalSolverLanguageParser.g:7011:2: rule__BoundedScopeDefinition__Group_1_1__1__Impl rule__BoundedScopeDefinition__Group_1_1__2 |
23567 | { | 21625 | { |
23568 | pushFollow(FOLLOW_9); | 21626 | pushFollow(FOLLOW_9); |
23569 | rule__BoundedScopeDefinition__Group_1_1__1__Impl(); | 21627 | rule__BoundedScopeDefinition__Group_1_1__1__Impl(); |
23570 | 21628 | ||
23571 | state._fsp--; | 21629 | state._fsp--; |
23572 | if (state.failed) return ; | 21630 | |
23573 | pushFollow(FOLLOW_2); | 21631 | pushFollow(FOLLOW_2); |
23574 | rule__BoundedScopeDefinition__Group_1_1__2(); | 21632 | rule__BoundedScopeDefinition__Group_1_1__2(); |
23575 | 21633 | ||
23576 | state._fsp--; | 21634 | state._fsp--; |
23577 | if (state.failed) return ; | 21635 | |
23578 | 21636 | ||
23579 | } | 21637 | } |
23580 | 21638 | ||
@@ -23594,25 +21652,21 @@ public class InternalSolverLanguageParser extends AbstractInternalContentAssistP | |||
23594 | 21652 | ||
23595 | 21653 | ||
23596 | // $ANTLR start "rule__BoundedScopeDefinition__Group_1_1__1__Impl" | 21654 | // $ANTLR start "rule__BoundedScopeDefinition__Group_1_1__1__Impl" |
23597 | // InternalSolverLanguage.g:7101:1: rule__BoundedScopeDefinition__Group_1_1__1__Impl : ( '>=' ) ; | 21655 | // InternalSolverLanguageParser.g:7018:1: rule__BoundedScopeDefinition__Group_1_1__1__Impl : ( GreaterThanSignEqualsSign ) ; |
23598 | public final void rule__BoundedScopeDefinition__Group_1_1__1__Impl() throws RecognitionException { | 21656 | public final void rule__BoundedScopeDefinition__Group_1_1__1__Impl() throws RecognitionException { |
23599 | 21657 | ||
23600 | int stackSize = keepStackSize(); | 21658 | int stackSize = keepStackSize(); |
23601 | 21659 | ||
23602 | try { | 21660 | try { |
23603 | // InternalSolverLanguage.g:7105:1: ( ( '>=' ) ) | 21661 | // InternalSolverLanguageParser.g:7022:1: ( ( GreaterThanSignEqualsSign ) ) |
23604 | // InternalSolverLanguage.g:7106:1: ( '>=' ) | 21662 | // InternalSolverLanguageParser.g:7023:1: ( GreaterThanSignEqualsSign ) |
23605 | { | 21663 | { |
23606 | // InternalSolverLanguage.g:7106:1: ( '>=' ) | 21664 | // InternalSolverLanguageParser.g:7023:1: ( GreaterThanSignEqualsSign ) |
23607 | // InternalSolverLanguage.g:7107:2: '>=' | 21665 | // InternalSolverLanguageParser.g:7024:2: GreaterThanSignEqualsSign |
23608 | { | 21666 | { |
23609 | if ( state.backtracking==0 ) { | 21667 | before(grammarAccess.getBoundedScopeDefinitionAccess().getGreaterThanSignEqualsSignKeyword_1_1_1()); |
23610 | before(grammarAccess.getBoundedScopeDefinitionAccess().getGreaterThanSignEqualsSignKeyword_1_1_1()); | 21668 | match(input,GreaterThanSignEqualsSign,FOLLOW_2); |
23611 | } | 21669 | after(grammarAccess.getBoundedScopeDefinitionAccess().getGreaterThanSignEqualsSignKeyword_1_1_1()); |
23612 | match(input,24,FOLLOW_2); if (state.failed) return ; | ||
23613 | if ( state.backtracking==0 ) { | ||
23614 | after(grammarAccess.getBoundedScopeDefinitionAccess().getGreaterThanSignEqualsSignKeyword_1_1_1()); | ||
23615 | } | ||
23616 | 21670 | ||
23617 | } | 21671 | } |
23618 | 21672 | ||
@@ -23635,25 +21689,25 @@ public class InternalSolverLanguageParser extends AbstractInternalContentAssistP | |||
23635 | 21689 | ||
23636 | 21690 | ||
23637 | // $ANTLR start "rule__BoundedScopeDefinition__Group_1_1__2" | 21691 | // $ANTLR start "rule__BoundedScopeDefinition__Group_1_1__2" |
23638 | // InternalSolverLanguage.g:7116:1: rule__BoundedScopeDefinition__Group_1_1__2 : rule__BoundedScopeDefinition__Group_1_1__2__Impl rule__BoundedScopeDefinition__Group_1_1__3 ; | 21692 | // InternalSolverLanguageParser.g:7033:1: rule__BoundedScopeDefinition__Group_1_1__2 : rule__BoundedScopeDefinition__Group_1_1__2__Impl rule__BoundedScopeDefinition__Group_1_1__3 ; |
23639 | public final void rule__BoundedScopeDefinition__Group_1_1__2() throws RecognitionException { | 21693 | public final void rule__BoundedScopeDefinition__Group_1_1__2() throws RecognitionException { |
23640 | 21694 | ||
23641 | int stackSize = keepStackSize(); | 21695 | int stackSize = keepStackSize(); |
23642 | 21696 | ||
23643 | try { | 21697 | try { |
23644 | // InternalSolverLanguage.g:7120:1: ( rule__BoundedScopeDefinition__Group_1_1__2__Impl rule__BoundedScopeDefinition__Group_1_1__3 ) | 21698 | // InternalSolverLanguageParser.g:7037:1: ( rule__BoundedScopeDefinition__Group_1_1__2__Impl rule__BoundedScopeDefinition__Group_1_1__3 ) |
23645 | // InternalSolverLanguage.g:7121:2: rule__BoundedScopeDefinition__Group_1_1__2__Impl rule__BoundedScopeDefinition__Group_1_1__3 | 21699 | // InternalSolverLanguageParser.g:7038:2: rule__BoundedScopeDefinition__Group_1_1__2__Impl rule__BoundedScopeDefinition__Group_1_1__3 |
23646 | { | 21700 | { |
23647 | pushFollow(FOLLOW_57); | 21701 | pushFollow(FOLLOW_56); |
23648 | rule__BoundedScopeDefinition__Group_1_1__2__Impl(); | 21702 | rule__BoundedScopeDefinition__Group_1_1__2__Impl(); |
23649 | 21703 | ||
23650 | state._fsp--; | 21704 | state._fsp--; |
23651 | if (state.failed) return ; | 21705 | |
23652 | pushFollow(FOLLOW_2); | 21706 | pushFollow(FOLLOW_2); |
23653 | rule__BoundedScopeDefinition__Group_1_1__3(); | 21707 | rule__BoundedScopeDefinition__Group_1_1__3(); |
23654 | 21708 | ||
23655 | state._fsp--; | 21709 | state._fsp--; |
23656 | if (state.failed) return ; | 21710 | |
23657 | 21711 | ||
23658 | } | 21712 | } |
23659 | 21713 | ||
@@ -23673,36 +21727,32 @@ public class InternalSolverLanguageParser extends AbstractInternalContentAssistP | |||
23673 | 21727 | ||
23674 | 21728 | ||
23675 | // $ANTLR start "rule__BoundedScopeDefinition__Group_1_1__2__Impl" | 21729 | // $ANTLR start "rule__BoundedScopeDefinition__Group_1_1__2__Impl" |
23676 | // InternalSolverLanguage.g:7128:1: rule__BoundedScopeDefinition__Group_1_1__2__Impl : ( ( rule__BoundedScopeDefinition__TypeAssignment_1_1_2 ) ) ; | 21730 | // InternalSolverLanguageParser.g:7045:1: rule__BoundedScopeDefinition__Group_1_1__2__Impl : ( ( rule__BoundedScopeDefinition__TypeAssignment_1_1_2 ) ) ; |
23677 | public final void rule__BoundedScopeDefinition__Group_1_1__2__Impl() throws RecognitionException { | 21731 | public final void rule__BoundedScopeDefinition__Group_1_1__2__Impl() throws RecognitionException { |
23678 | 21732 | ||
23679 | int stackSize = keepStackSize(); | 21733 | int stackSize = keepStackSize(); |
23680 | 21734 | ||
23681 | try { | 21735 | try { |
23682 | // InternalSolverLanguage.g:7132:1: ( ( ( rule__BoundedScopeDefinition__TypeAssignment_1_1_2 ) ) ) | 21736 | // InternalSolverLanguageParser.g:7049:1: ( ( ( rule__BoundedScopeDefinition__TypeAssignment_1_1_2 ) ) ) |
23683 | // InternalSolverLanguage.g:7133:1: ( ( rule__BoundedScopeDefinition__TypeAssignment_1_1_2 ) ) | 21737 | // InternalSolverLanguageParser.g:7050:1: ( ( rule__BoundedScopeDefinition__TypeAssignment_1_1_2 ) ) |
23684 | { | 21738 | { |
23685 | // InternalSolverLanguage.g:7133:1: ( ( rule__BoundedScopeDefinition__TypeAssignment_1_1_2 ) ) | 21739 | // InternalSolverLanguageParser.g:7050:1: ( ( rule__BoundedScopeDefinition__TypeAssignment_1_1_2 ) ) |
23686 | // InternalSolverLanguage.g:7134:2: ( rule__BoundedScopeDefinition__TypeAssignment_1_1_2 ) | 21740 | // InternalSolverLanguageParser.g:7051:2: ( rule__BoundedScopeDefinition__TypeAssignment_1_1_2 ) |
23687 | { | 21741 | { |
23688 | if ( state.backtracking==0 ) { | 21742 | before(grammarAccess.getBoundedScopeDefinitionAccess().getTypeAssignment_1_1_2()); |
23689 | before(grammarAccess.getBoundedScopeDefinitionAccess().getTypeAssignment_1_1_2()); | 21743 | // InternalSolverLanguageParser.g:7052:2: ( rule__BoundedScopeDefinition__TypeAssignment_1_1_2 ) |
23690 | } | 21744 | // InternalSolverLanguageParser.g:7052:3: rule__BoundedScopeDefinition__TypeAssignment_1_1_2 |
23691 | // InternalSolverLanguage.g:7135:2: ( rule__BoundedScopeDefinition__TypeAssignment_1_1_2 ) | ||
23692 | // InternalSolverLanguage.g:7135:3: rule__BoundedScopeDefinition__TypeAssignment_1_1_2 | ||
23693 | { | 21745 | { |
23694 | pushFollow(FOLLOW_2); | 21746 | pushFollow(FOLLOW_2); |
23695 | rule__BoundedScopeDefinition__TypeAssignment_1_1_2(); | 21747 | rule__BoundedScopeDefinition__TypeAssignment_1_1_2(); |
23696 | 21748 | ||
23697 | state._fsp--; | 21749 | state._fsp--; |
23698 | if (state.failed) return ; | ||
23699 | 21750 | ||
23700 | } | ||
23701 | 21751 | ||
23702 | if ( state.backtracking==0 ) { | ||
23703 | after(grammarAccess.getBoundedScopeDefinitionAccess().getTypeAssignment_1_1_2()); | ||
23704 | } | 21752 | } |
23705 | 21753 | ||
21754 | after(grammarAccess.getBoundedScopeDefinitionAccess().getTypeAssignment_1_1_2()); | ||
21755 | |||
23706 | } | 21756 | } |
23707 | 21757 | ||
23708 | 21758 | ||
@@ -23724,20 +21774,20 @@ public class InternalSolverLanguageParser extends AbstractInternalContentAssistP | |||
23724 | 21774 | ||
23725 | 21775 | ||
23726 | // $ANTLR start "rule__BoundedScopeDefinition__Group_1_1__3" | 21776 | // $ANTLR start "rule__BoundedScopeDefinition__Group_1_1__3" |
23727 | // InternalSolverLanguage.g:7143:1: rule__BoundedScopeDefinition__Group_1_1__3 : rule__BoundedScopeDefinition__Group_1_1__3__Impl ; | 21777 | // InternalSolverLanguageParser.g:7060:1: rule__BoundedScopeDefinition__Group_1_1__3 : rule__BoundedScopeDefinition__Group_1_1__3__Impl ; |
23728 | public final void rule__BoundedScopeDefinition__Group_1_1__3() throws RecognitionException { | 21778 | public final void rule__BoundedScopeDefinition__Group_1_1__3() throws RecognitionException { |
23729 | 21779 | ||
23730 | int stackSize = keepStackSize(); | 21780 | int stackSize = keepStackSize(); |
23731 | 21781 | ||
23732 | try { | 21782 | try { |
23733 | // InternalSolverLanguage.g:7147:1: ( rule__BoundedScopeDefinition__Group_1_1__3__Impl ) | 21783 | // InternalSolverLanguageParser.g:7064:1: ( rule__BoundedScopeDefinition__Group_1_1__3__Impl ) |
23734 | // InternalSolverLanguage.g:7148:2: rule__BoundedScopeDefinition__Group_1_1__3__Impl | 21784 | // InternalSolverLanguageParser.g:7065:2: rule__BoundedScopeDefinition__Group_1_1__3__Impl |
23735 | { | 21785 | { |
23736 | pushFollow(FOLLOW_2); | 21786 | pushFollow(FOLLOW_2); |
23737 | rule__BoundedScopeDefinition__Group_1_1__3__Impl(); | 21787 | rule__BoundedScopeDefinition__Group_1_1__3__Impl(); |
23738 | 21788 | ||
23739 | state._fsp--; | 21789 | state._fsp--; |
23740 | if (state.failed) return ; | 21790 | |
23741 | 21791 | ||
23742 | } | 21792 | } |
23743 | 21793 | ||
@@ -23757,46 +21807,42 @@ public class InternalSolverLanguageParser extends AbstractInternalContentAssistP | |||
23757 | 21807 | ||
23758 | 21808 | ||
23759 | // $ANTLR start "rule__BoundedScopeDefinition__Group_1_1__3__Impl" | 21809 | // $ANTLR start "rule__BoundedScopeDefinition__Group_1_1__3__Impl" |
23760 | // InternalSolverLanguage.g:7154:1: rule__BoundedScopeDefinition__Group_1_1__3__Impl : ( ( rule__BoundedScopeDefinition__Group_1_1_3__0 )? ) ; | 21810 | // InternalSolverLanguageParser.g:7071:1: rule__BoundedScopeDefinition__Group_1_1__3__Impl : ( ( rule__BoundedScopeDefinition__Group_1_1_3__0 )? ) ; |
23761 | public final void rule__BoundedScopeDefinition__Group_1_1__3__Impl() throws RecognitionException { | 21811 | public final void rule__BoundedScopeDefinition__Group_1_1__3__Impl() throws RecognitionException { |
23762 | 21812 | ||
23763 | int stackSize = keepStackSize(); | 21813 | int stackSize = keepStackSize(); |
23764 | 21814 | ||
23765 | try { | 21815 | try { |
23766 | // InternalSolverLanguage.g:7158:1: ( ( ( rule__BoundedScopeDefinition__Group_1_1_3__0 )? ) ) | 21816 | // InternalSolverLanguageParser.g:7075:1: ( ( ( rule__BoundedScopeDefinition__Group_1_1_3__0 )? ) ) |
23767 | // InternalSolverLanguage.g:7159:1: ( ( rule__BoundedScopeDefinition__Group_1_1_3__0 )? ) | 21817 | // InternalSolverLanguageParser.g:7076:1: ( ( rule__BoundedScopeDefinition__Group_1_1_3__0 )? ) |
23768 | { | 21818 | { |
23769 | // InternalSolverLanguage.g:7159:1: ( ( rule__BoundedScopeDefinition__Group_1_1_3__0 )? ) | 21819 | // InternalSolverLanguageParser.g:7076:1: ( ( rule__BoundedScopeDefinition__Group_1_1_3__0 )? ) |
23770 | // InternalSolverLanguage.g:7160:2: ( rule__BoundedScopeDefinition__Group_1_1_3__0 )? | 21820 | // InternalSolverLanguageParser.g:7077:2: ( rule__BoundedScopeDefinition__Group_1_1_3__0 )? |
23771 | { | 21821 | { |
23772 | if ( state.backtracking==0 ) { | 21822 | before(grammarAccess.getBoundedScopeDefinitionAccess().getGroup_1_1_3()); |
23773 | before(grammarAccess.getBoundedScopeDefinitionAccess().getGroup_1_1_3()); | 21823 | // InternalSolverLanguageParser.g:7078:2: ( rule__BoundedScopeDefinition__Group_1_1_3__0 )? |
23774 | } | 21824 | int alt51=2; |
23775 | // InternalSolverLanguage.g:7161:2: ( rule__BoundedScopeDefinition__Group_1_1_3__0 )? | 21825 | int LA51_0 = input.LA(1); |
23776 | int alt52=2; | ||
23777 | int LA52_0 = input.LA(1); | ||
23778 | 21826 | ||
23779 | if ( (LA52_0==24) ) { | 21827 | if ( (LA51_0==GreaterThanSignEqualsSign) ) { |
23780 | alt52=1; | 21828 | alt51=1; |
23781 | } | 21829 | } |
23782 | switch (alt52) { | 21830 | switch (alt51) { |
23783 | case 1 : | 21831 | case 1 : |
23784 | // InternalSolverLanguage.g:7161:3: rule__BoundedScopeDefinition__Group_1_1_3__0 | 21832 | // InternalSolverLanguageParser.g:7078:3: rule__BoundedScopeDefinition__Group_1_1_3__0 |
23785 | { | 21833 | { |
23786 | pushFollow(FOLLOW_2); | 21834 | pushFollow(FOLLOW_2); |
23787 | rule__BoundedScopeDefinition__Group_1_1_3__0(); | 21835 | rule__BoundedScopeDefinition__Group_1_1_3__0(); |
23788 | 21836 | ||
23789 | state._fsp--; | 21837 | state._fsp--; |
23790 | if (state.failed) return ; | 21838 | |
23791 | 21839 | ||
23792 | } | 21840 | } |
23793 | break; | 21841 | break; |
23794 | 21842 | ||
23795 | } | 21843 | } |
23796 | 21844 | ||
23797 | if ( state.backtracking==0 ) { | 21845 | after(grammarAccess.getBoundedScopeDefinitionAccess().getGroup_1_1_3()); |
23798 | after(grammarAccess.getBoundedScopeDefinitionAccess().getGroup_1_1_3()); | ||
23799 | } | ||
23800 | 21846 | ||
23801 | } | 21847 | } |
23802 | 21848 | ||
@@ -23819,25 +21865,25 @@ public class InternalSolverLanguageParser extends AbstractInternalContentAssistP | |||
23819 | 21865 | ||
23820 | 21866 | ||
23821 | // $ANTLR start "rule__BoundedScopeDefinition__Group_1_1_3__0" | 21867 | // $ANTLR start "rule__BoundedScopeDefinition__Group_1_1_3__0" |
23822 | // InternalSolverLanguage.g:7170:1: rule__BoundedScopeDefinition__Group_1_1_3__0 : rule__BoundedScopeDefinition__Group_1_1_3__0__Impl rule__BoundedScopeDefinition__Group_1_1_3__1 ; | 21868 | // InternalSolverLanguageParser.g:7087:1: rule__BoundedScopeDefinition__Group_1_1_3__0 : rule__BoundedScopeDefinition__Group_1_1_3__0__Impl rule__BoundedScopeDefinition__Group_1_1_3__1 ; |
23823 | public final void rule__BoundedScopeDefinition__Group_1_1_3__0() throws RecognitionException { | 21869 | public final void rule__BoundedScopeDefinition__Group_1_1_3__0() throws RecognitionException { |
23824 | 21870 | ||
23825 | int stackSize = keepStackSize(); | 21871 | int stackSize = keepStackSize(); |
23826 | 21872 | ||
23827 | try { | 21873 | try { |
23828 | // InternalSolverLanguage.g:7174:1: ( rule__BoundedScopeDefinition__Group_1_1_3__0__Impl rule__BoundedScopeDefinition__Group_1_1_3__1 ) | 21874 | // InternalSolverLanguageParser.g:7091:1: ( rule__BoundedScopeDefinition__Group_1_1_3__0__Impl rule__BoundedScopeDefinition__Group_1_1_3__1 ) |
23829 | // InternalSolverLanguage.g:7175:2: rule__BoundedScopeDefinition__Group_1_1_3__0__Impl rule__BoundedScopeDefinition__Group_1_1_3__1 | 21875 | // InternalSolverLanguageParser.g:7092:2: rule__BoundedScopeDefinition__Group_1_1_3__0__Impl rule__BoundedScopeDefinition__Group_1_1_3__1 |
23830 | { | 21876 | { |
23831 | pushFollow(FOLLOW_53); | 21877 | pushFollow(FOLLOW_52); |
23832 | rule__BoundedScopeDefinition__Group_1_1_3__0__Impl(); | 21878 | rule__BoundedScopeDefinition__Group_1_1_3__0__Impl(); |
23833 | 21879 | ||
23834 | state._fsp--; | 21880 | state._fsp--; |
23835 | if (state.failed) return ; | 21881 | |
23836 | pushFollow(FOLLOW_2); | 21882 | pushFollow(FOLLOW_2); |
23837 | rule__BoundedScopeDefinition__Group_1_1_3__1(); | 21883 | rule__BoundedScopeDefinition__Group_1_1_3__1(); |
23838 | 21884 | ||
23839 | state._fsp--; | 21885 | state._fsp--; |
23840 | if (state.failed) return ; | 21886 | |
23841 | 21887 | ||
23842 | } | 21888 | } |
23843 | 21889 | ||
@@ -23857,25 +21903,21 @@ public class InternalSolverLanguageParser extends AbstractInternalContentAssistP | |||
23857 | 21903 | ||
23858 | 21904 | ||
23859 | // $ANTLR start "rule__BoundedScopeDefinition__Group_1_1_3__0__Impl" | 21905 | // $ANTLR start "rule__BoundedScopeDefinition__Group_1_1_3__0__Impl" |
23860 | // InternalSolverLanguage.g:7182:1: rule__BoundedScopeDefinition__Group_1_1_3__0__Impl : ( '>=' ) ; | 21906 | // InternalSolverLanguageParser.g:7099:1: rule__BoundedScopeDefinition__Group_1_1_3__0__Impl : ( GreaterThanSignEqualsSign ) ; |
23861 | public final void rule__BoundedScopeDefinition__Group_1_1_3__0__Impl() throws RecognitionException { | 21907 | public final void rule__BoundedScopeDefinition__Group_1_1_3__0__Impl() throws RecognitionException { |
23862 | 21908 | ||
23863 | int stackSize = keepStackSize(); | 21909 | int stackSize = keepStackSize(); |
23864 | 21910 | ||
23865 | try { | 21911 | try { |
23866 | // InternalSolverLanguage.g:7186:1: ( ( '>=' ) ) | 21912 | // InternalSolverLanguageParser.g:7103:1: ( ( GreaterThanSignEqualsSign ) ) |
23867 | // InternalSolverLanguage.g:7187:1: ( '>=' ) | 21913 | // InternalSolverLanguageParser.g:7104:1: ( GreaterThanSignEqualsSign ) |
23868 | { | 21914 | { |
23869 | // InternalSolverLanguage.g:7187:1: ( '>=' ) | 21915 | // InternalSolverLanguageParser.g:7104:1: ( GreaterThanSignEqualsSign ) |
23870 | // InternalSolverLanguage.g:7188:2: '>=' | 21916 | // InternalSolverLanguageParser.g:7105:2: GreaterThanSignEqualsSign |
23871 | { | 21917 | { |
23872 | if ( state.backtracking==0 ) { | 21918 | before(grammarAccess.getBoundedScopeDefinitionAccess().getGreaterThanSignEqualsSignKeyword_1_1_3_0()); |
23873 | before(grammarAccess.getBoundedScopeDefinitionAccess().getGreaterThanSignEqualsSignKeyword_1_1_3_0()); | 21919 | match(input,GreaterThanSignEqualsSign,FOLLOW_2); |
23874 | } | 21920 | after(grammarAccess.getBoundedScopeDefinitionAccess().getGreaterThanSignEqualsSignKeyword_1_1_3_0()); |
23875 | match(input,24,FOLLOW_2); if (state.failed) return ; | ||
23876 | if ( state.backtracking==0 ) { | ||
23877 | after(grammarAccess.getBoundedScopeDefinitionAccess().getGreaterThanSignEqualsSignKeyword_1_1_3_0()); | ||
23878 | } | ||
23879 | 21921 | ||
23880 | } | 21922 | } |
23881 | 21923 | ||
@@ -23898,20 +21940,20 @@ public class InternalSolverLanguageParser extends AbstractInternalContentAssistP | |||
23898 | 21940 | ||
23899 | 21941 | ||
23900 | // $ANTLR start "rule__BoundedScopeDefinition__Group_1_1_3__1" | 21942 | // $ANTLR start "rule__BoundedScopeDefinition__Group_1_1_3__1" |
23901 | // InternalSolverLanguage.g:7197:1: rule__BoundedScopeDefinition__Group_1_1_3__1 : rule__BoundedScopeDefinition__Group_1_1_3__1__Impl ; | 21943 | // InternalSolverLanguageParser.g:7114:1: rule__BoundedScopeDefinition__Group_1_1_3__1 : rule__BoundedScopeDefinition__Group_1_1_3__1__Impl ; |
23902 | public final void rule__BoundedScopeDefinition__Group_1_1_3__1() throws RecognitionException { | 21944 | public final void rule__BoundedScopeDefinition__Group_1_1_3__1() throws RecognitionException { |
23903 | 21945 | ||
23904 | int stackSize = keepStackSize(); | 21946 | int stackSize = keepStackSize(); |
23905 | 21947 | ||
23906 | try { | 21948 | try { |
23907 | // InternalSolverLanguage.g:7201:1: ( rule__BoundedScopeDefinition__Group_1_1_3__1__Impl ) | 21949 | // InternalSolverLanguageParser.g:7118:1: ( rule__BoundedScopeDefinition__Group_1_1_3__1__Impl ) |
23908 | // InternalSolverLanguage.g:7202:2: rule__BoundedScopeDefinition__Group_1_1_3__1__Impl | 21950 | // InternalSolverLanguageParser.g:7119:2: rule__BoundedScopeDefinition__Group_1_1_3__1__Impl |
23909 | { | 21951 | { |
23910 | pushFollow(FOLLOW_2); | 21952 | pushFollow(FOLLOW_2); |
23911 | rule__BoundedScopeDefinition__Group_1_1_3__1__Impl(); | 21953 | rule__BoundedScopeDefinition__Group_1_1_3__1__Impl(); |
23912 | 21954 | ||
23913 | state._fsp--; | 21955 | state._fsp--; |
23914 | if (state.failed) return ; | 21956 | |
23915 | 21957 | ||
23916 | } | 21958 | } |
23917 | 21959 | ||
@@ -23931,36 +21973,32 @@ public class InternalSolverLanguageParser extends AbstractInternalContentAssistP | |||
23931 | 21973 | ||
23932 | 21974 | ||
23933 | // $ANTLR start "rule__BoundedScopeDefinition__Group_1_1_3__1__Impl" | 21975 | // $ANTLR start "rule__BoundedScopeDefinition__Group_1_1_3__1__Impl" |
23934 | // InternalSolverLanguage.g:7208:1: rule__BoundedScopeDefinition__Group_1_1_3__1__Impl : ( ( rule__BoundedScopeDefinition__LowerBoundAssignment_1_1_3_1 ) ) ; | 21976 | // InternalSolverLanguageParser.g:7125:1: rule__BoundedScopeDefinition__Group_1_1_3__1__Impl : ( ( rule__BoundedScopeDefinition__LowerBoundAssignment_1_1_3_1 ) ) ; |
23935 | public final void rule__BoundedScopeDefinition__Group_1_1_3__1__Impl() throws RecognitionException { | 21977 | public final void rule__BoundedScopeDefinition__Group_1_1_3__1__Impl() throws RecognitionException { |
23936 | 21978 | ||
23937 | int stackSize = keepStackSize(); | 21979 | int stackSize = keepStackSize(); |
23938 | 21980 | ||
23939 | try { | 21981 | try { |
23940 | // InternalSolverLanguage.g:7212:1: ( ( ( rule__BoundedScopeDefinition__LowerBoundAssignment_1_1_3_1 ) ) ) | 21982 | // InternalSolverLanguageParser.g:7129:1: ( ( ( rule__BoundedScopeDefinition__LowerBoundAssignment_1_1_3_1 ) ) ) |
23941 | // InternalSolverLanguage.g:7213:1: ( ( rule__BoundedScopeDefinition__LowerBoundAssignment_1_1_3_1 ) ) | 21983 | // InternalSolverLanguageParser.g:7130:1: ( ( rule__BoundedScopeDefinition__LowerBoundAssignment_1_1_3_1 ) ) |
23942 | { | 21984 | { |
23943 | // InternalSolverLanguage.g:7213:1: ( ( rule__BoundedScopeDefinition__LowerBoundAssignment_1_1_3_1 ) ) | 21985 | // InternalSolverLanguageParser.g:7130:1: ( ( rule__BoundedScopeDefinition__LowerBoundAssignment_1_1_3_1 ) ) |
23944 | // InternalSolverLanguage.g:7214:2: ( rule__BoundedScopeDefinition__LowerBoundAssignment_1_1_3_1 ) | 21986 | // InternalSolverLanguageParser.g:7131:2: ( rule__BoundedScopeDefinition__LowerBoundAssignment_1_1_3_1 ) |
23945 | { | 21987 | { |
23946 | if ( state.backtracking==0 ) { | 21988 | before(grammarAccess.getBoundedScopeDefinitionAccess().getLowerBoundAssignment_1_1_3_1()); |
23947 | before(grammarAccess.getBoundedScopeDefinitionAccess().getLowerBoundAssignment_1_1_3_1()); | 21989 | // InternalSolverLanguageParser.g:7132:2: ( rule__BoundedScopeDefinition__LowerBoundAssignment_1_1_3_1 ) |
23948 | } | 21990 | // InternalSolverLanguageParser.g:7132:3: rule__BoundedScopeDefinition__LowerBoundAssignment_1_1_3_1 |
23949 | // InternalSolverLanguage.g:7215:2: ( rule__BoundedScopeDefinition__LowerBoundAssignment_1_1_3_1 ) | ||
23950 | // InternalSolverLanguage.g:7215:3: rule__BoundedScopeDefinition__LowerBoundAssignment_1_1_3_1 | ||
23951 | { | 21991 | { |
23952 | pushFollow(FOLLOW_2); | 21992 | pushFollow(FOLLOW_2); |
23953 | rule__BoundedScopeDefinition__LowerBoundAssignment_1_1_3_1(); | 21993 | rule__BoundedScopeDefinition__LowerBoundAssignment_1_1_3_1(); |
23954 | 21994 | ||
23955 | state._fsp--; | 21995 | state._fsp--; |
23956 | if (state.failed) return ; | ||
23957 | 21996 | ||
23958 | } | ||
23959 | 21997 | ||
23960 | if ( state.backtracking==0 ) { | ||
23961 | after(grammarAccess.getBoundedScopeDefinitionAccess().getLowerBoundAssignment_1_1_3_1()); | ||
23962 | } | 21998 | } |
23963 | 21999 | ||
22000 | after(grammarAccess.getBoundedScopeDefinitionAccess().getLowerBoundAssignment_1_1_3_1()); | ||
22001 | |||
23964 | } | 22002 | } |
23965 | 22003 | ||
23966 | 22004 | ||
@@ -23982,25 +22020,25 @@ public class InternalSolverLanguageParser extends AbstractInternalContentAssistP | |||
23982 | 22020 | ||
23983 | 22021 | ||
23984 | // $ANTLR start "rule__LowerBoundedScopeDefinition__Group__0" | 22022 | // $ANTLR start "rule__LowerBoundedScopeDefinition__Group__0" |
23985 | // InternalSolverLanguage.g:7224:1: rule__LowerBoundedScopeDefinition__Group__0 : rule__LowerBoundedScopeDefinition__Group__0__Impl rule__LowerBoundedScopeDefinition__Group__1 ; | 22023 | // InternalSolverLanguageParser.g:7141:1: rule__LowerBoundedScopeDefinition__Group__0 : rule__LowerBoundedScopeDefinition__Group__0__Impl rule__LowerBoundedScopeDefinition__Group__1 ; |
23986 | public final void rule__LowerBoundedScopeDefinition__Group__0() throws RecognitionException { | 22024 | public final void rule__LowerBoundedScopeDefinition__Group__0() throws RecognitionException { |
23987 | 22025 | ||
23988 | int stackSize = keepStackSize(); | 22026 | int stackSize = keepStackSize(); |
23989 | 22027 | ||
23990 | try { | 22028 | try { |
23991 | // InternalSolverLanguage.g:7228:1: ( rule__LowerBoundedScopeDefinition__Group__0__Impl rule__LowerBoundedScopeDefinition__Group__1 ) | 22029 | // InternalSolverLanguageParser.g:7145:1: ( rule__LowerBoundedScopeDefinition__Group__0__Impl rule__LowerBoundedScopeDefinition__Group__1 ) |
23992 | // InternalSolverLanguage.g:7229:2: rule__LowerBoundedScopeDefinition__Group__0__Impl rule__LowerBoundedScopeDefinition__Group__1 | 22030 | // InternalSolverLanguageParser.g:7146:2: rule__LowerBoundedScopeDefinition__Group__0__Impl rule__LowerBoundedScopeDefinition__Group__1 |
23993 | { | 22031 | { |
23994 | pushFollow(FOLLOW_55); | 22032 | pushFollow(FOLLOW_54); |
23995 | rule__LowerBoundedScopeDefinition__Group__0__Impl(); | 22033 | rule__LowerBoundedScopeDefinition__Group__0__Impl(); |
23996 | 22034 | ||
23997 | state._fsp--; | 22035 | state._fsp--; |
23998 | if (state.failed) return ; | 22036 | |
23999 | pushFollow(FOLLOW_2); | 22037 | pushFollow(FOLLOW_2); |
24000 | rule__LowerBoundedScopeDefinition__Group__1(); | 22038 | rule__LowerBoundedScopeDefinition__Group__1(); |
24001 | 22039 | ||
24002 | state._fsp--; | 22040 | state._fsp--; |
24003 | if (state.failed) return ; | 22041 | |
24004 | 22042 | ||
24005 | } | 22043 | } |
24006 | 22044 | ||
@@ -24020,25 +22058,21 @@ public class InternalSolverLanguageParser extends AbstractInternalContentAssistP | |||
24020 | 22058 | ||
24021 | 22059 | ||
24022 | // $ANTLR start "rule__LowerBoundedScopeDefinition__Group__0__Impl" | 22060 | // $ANTLR start "rule__LowerBoundedScopeDefinition__Group__0__Impl" |
24023 | // InternalSolverLanguage.g:7236:1: rule__LowerBoundedScopeDefinition__Group__0__Impl : ( 'scope' ) ; | 22061 | // InternalSolverLanguageParser.g:7153:1: rule__LowerBoundedScopeDefinition__Group__0__Impl : ( Scope ) ; |
24024 | public final void rule__LowerBoundedScopeDefinition__Group__0__Impl() throws RecognitionException { | 22062 | public final void rule__LowerBoundedScopeDefinition__Group__0__Impl() throws RecognitionException { |
24025 | 22063 | ||
24026 | int stackSize = keepStackSize(); | 22064 | int stackSize = keepStackSize(); |
24027 | 22065 | ||
24028 | try { | 22066 | try { |
24029 | // InternalSolverLanguage.g:7240:1: ( ( 'scope' ) ) | 22067 | // InternalSolverLanguageParser.g:7157:1: ( ( Scope ) ) |
24030 | // InternalSolverLanguage.g:7241:1: ( 'scope' ) | 22068 | // InternalSolverLanguageParser.g:7158:1: ( Scope ) |
24031 | { | 22069 | { |
24032 | // InternalSolverLanguage.g:7241:1: ( 'scope' ) | 22070 | // InternalSolverLanguageParser.g:7158:1: ( Scope ) |
24033 | // InternalSolverLanguage.g:7242:2: 'scope' | 22071 | // InternalSolverLanguageParser.g:7159:2: Scope |
24034 | { | 22072 | { |
24035 | if ( state.backtracking==0 ) { | 22073 | before(grammarAccess.getLowerBoundedScopeDefinitionAccess().getScopeKeyword_0()); |
24036 | before(grammarAccess.getLowerBoundedScopeDefinitionAccess().getScopeKeyword_0()); | 22074 | match(input,Scope,FOLLOW_2); |
24037 | } | 22075 | after(grammarAccess.getLowerBoundedScopeDefinitionAccess().getScopeKeyword_0()); |
24038 | match(input,71,FOLLOW_2); if (state.failed) return ; | ||
24039 | if ( state.backtracking==0 ) { | ||
24040 | after(grammarAccess.getLowerBoundedScopeDefinitionAccess().getScopeKeyword_0()); | ||
24041 | } | ||
24042 | 22076 | ||
24043 | } | 22077 | } |
24044 | 22078 | ||
@@ -24061,25 +22095,20 @@ public class InternalSolverLanguageParser extends AbstractInternalContentAssistP | |||
24061 | 22095 | ||
24062 | 22096 | ||
24063 | // $ANTLR start "rule__LowerBoundedScopeDefinition__Group__1" | 22097 | // $ANTLR start "rule__LowerBoundedScopeDefinition__Group__1" |
24064 | // InternalSolverLanguage.g:7251:1: rule__LowerBoundedScopeDefinition__Group__1 : rule__LowerBoundedScopeDefinition__Group__1__Impl rule__LowerBoundedScopeDefinition__Group__2 ; | 22098 | // InternalSolverLanguageParser.g:7168:1: rule__LowerBoundedScopeDefinition__Group__1 : rule__LowerBoundedScopeDefinition__Group__1__Impl ; |
24065 | public final void rule__LowerBoundedScopeDefinition__Group__1() throws RecognitionException { | 22099 | public final void rule__LowerBoundedScopeDefinition__Group__1() throws RecognitionException { |
24066 | 22100 | ||
24067 | int stackSize = keepStackSize(); | 22101 | int stackSize = keepStackSize(); |
24068 | 22102 | ||
24069 | try { | 22103 | try { |
24070 | // InternalSolverLanguage.g:7255:1: ( rule__LowerBoundedScopeDefinition__Group__1__Impl rule__LowerBoundedScopeDefinition__Group__2 ) | 22104 | // InternalSolverLanguageParser.g:7172:1: ( rule__LowerBoundedScopeDefinition__Group__1__Impl ) |
24071 | // InternalSolverLanguage.g:7256:2: rule__LowerBoundedScopeDefinition__Group__1__Impl rule__LowerBoundedScopeDefinition__Group__2 | 22105 | // InternalSolverLanguageParser.g:7173:2: rule__LowerBoundedScopeDefinition__Group__1__Impl |
24072 | { | 22106 | { |
24073 | pushFollow(FOLLOW_13); | 22107 | pushFollow(FOLLOW_2); |
24074 | rule__LowerBoundedScopeDefinition__Group__1__Impl(); | 22108 | rule__LowerBoundedScopeDefinition__Group__1__Impl(); |
24075 | 22109 | ||
24076 | state._fsp--; | 22110 | state._fsp--; |
24077 | if (state.failed) return ; | ||
24078 | pushFollow(FOLLOW_2); | ||
24079 | rule__LowerBoundedScopeDefinition__Group__2(); | ||
24080 | 22111 | ||
24081 | state._fsp--; | ||
24082 | if (state.failed) return ; | ||
24083 | 22112 | ||
24084 | } | 22113 | } |
24085 | 22114 | ||
@@ -24099,71 +22128,34 @@ public class InternalSolverLanguageParser extends AbstractInternalContentAssistP | |||
24099 | 22128 | ||
24100 | 22129 | ||
24101 | // $ANTLR start "rule__LowerBoundedScopeDefinition__Group__1__Impl" | 22130 | // $ANTLR start "rule__LowerBoundedScopeDefinition__Group__1__Impl" |
24102 | // InternalSolverLanguage.g:7263:1: rule__LowerBoundedScopeDefinition__Group__1__Impl : ( ( rule__LowerBoundedScopeDefinition__Alternatives_1 ) ) ; | 22131 | // InternalSolverLanguageParser.g:7179:1: rule__LowerBoundedScopeDefinition__Group__1__Impl : ( ( rule__LowerBoundedScopeDefinition__Alternatives_1 ) ) ; |
24103 | public final void rule__LowerBoundedScopeDefinition__Group__1__Impl() throws RecognitionException { | 22132 | public final void rule__LowerBoundedScopeDefinition__Group__1__Impl() throws RecognitionException { |
24104 | 22133 | ||
24105 | int stackSize = keepStackSize(); | 22134 | int stackSize = keepStackSize(); |
24106 | 22135 | ||
24107 | try { | 22136 | try { |
24108 | // InternalSolverLanguage.g:7267:1: ( ( ( rule__LowerBoundedScopeDefinition__Alternatives_1 ) ) ) | 22137 | // InternalSolverLanguageParser.g:7183:1: ( ( ( rule__LowerBoundedScopeDefinition__Alternatives_1 ) ) ) |
24109 | // InternalSolverLanguage.g:7268:1: ( ( rule__LowerBoundedScopeDefinition__Alternatives_1 ) ) | 22138 | // InternalSolverLanguageParser.g:7184:1: ( ( rule__LowerBoundedScopeDefinition__Alternatives_1 ) ) |
24110 | { | 22139 | { |
24111 | // InternalSolverLanguage.g:7268:1: ( ( rule__LowerBoundedScopeDefinition__Alternatives_1 ) ) | 22140 | // InternalSolverLanguageParser.g:7184:1: ( ( rule__LowerBoundedScopeDefinition__Alternatives_1 ) ) |
24112 | // InternalSolverLanguage.g:7269:2: ( rule__LowerBoundedScopeDefinition__Alternatives_1 ) | 22141 | // InternalSolverLanguageParser.g:7185:2: ( rule__LowerBoundedScopeDefinition__Alternatives_1 ) |
24113 | { | 22142 | { |
24114 | if ( state.backtracking==0 ) { | 22143 | before(grammarAccess.getLowerBoundedScopeDefinitionAccess().getAlternatives_1()); |
24115 | before(grammarAccess.getLowerBoundedScopeDefinitionAccess().getAlternatives_1()); | 22144 | // InternalSolverLanguageParser.g:7186:2: ( rule__LowerBoundedScopeDefinition__Alternatives_1 ) |
24116 | } | 22145 | // InternalSolverLanguageParser.g:7186:3: rule__LowerBoundedScopeDefinition__Alternatives_1 |
24117 | // InternalSolverLanguage.g:7270:2: ( rule__LowerBoundedScopeDefinition__Alternatives_1 ) | ||
24118 | // InternalSolverLanguage.g:7270:3: rule__LowerBoundedScopeDefinition__Alternatives_1 | ||
24119 | { | 22146 | { |
24120 | pushFollow(FOLLOW_2); | 22147 | pushFollow(FOLLOW_2); |
24121 | rule__LowerBoundedScopeDefinition__Alternatives_1(); | 22148 | rule__LowerBoundedScopeDefinition__Alternatives_1(); |
24122 | 22149 | ||
24123 | state._fsp--; | 22150 | state._fsp--; |
24124 | if (state.failed) return ; | ||
24125 | 22151 | ||
24126 | } | ||
24127 | |||
24128 | if ( state.backtracking==0 ) { | ||
24129 | after(grammarAccess.getLowerBoundedScopeDefinitionAccess().getAlternatives_1()); | ||
24130 | } | ||
24131 | 22152 | ||
24132 | } | 22153 | } |
24133 | 22154 | ||
22155 | after(grammarAccess.getLowerBoundedScopeDefinitionAccess().getAlternatives_1()); | ||
24134 | 22156 | ||
24135 | } | 22157 | } |
24136 | 22158 | ||
24137 | } | ||
24138 | catch (RecognitionException re) { | ||
24139 | reportError(re); | ||
24140 | recover(input,re); | ||
24141 | } | ||
24142 | finally { | ||
24143 | |||
24144 | restoreStackSize(stackSize); | ||
24145 | |||
24146 | } | ||
24147 | return ; | ||
24148 | } | ||
24149 | // $ANTLR end "rule__LowerBoundedScopeDefinition__Group__1__Impl" | ||
24150 | |||
24151 | |||
24152 | // $ANTLR start "rule__LowerBoundedScopeDefinition__Group__2" | ||
24153 | // InternalSolverLanguage.g:7278:1: rule__LowerBoundedScopeDefinition__Group__2 : rule__LowerBoundedScopeDefinition__Group__2__Impl ; | ||
24154 | public final void rule__LowerBoundedScopeDefinition__Group__2() throws RecognitionException { | ||
24155 | |||
24156 | int stackSize = keepStackSize(); | ||
24157 | |||
24158 | try { | ||
24159 | // InternalSolverLanguage.g:7282:1: ( rule__LowerBoundedScopeDefinition__Group__2__Impl ) | ||
24160 | // InternalSolverLanguage.g:7283:2: rule__LowerBoundedScopeDefinition__Group__2__Impl | ||
24161 | { | ||
24162 | pushFollow(FOLLOW_2); | ||
24163 | rule__LowerBoundedScopeDefinition__Group__2__Impl(); | ||
24164 | |||
24165 | state._fsp--; | ||
24166 | if (state.failed) return ; | ||
24167 | 22159 | ||
24168 | } | 22160 | } |
24169 | 22161 | ||
@@ -24179,70 +22171,29 @@ public class InternalSolverLanguageParser extends AbstractInternalContentAssistP | |||
24179 | } | 22171 | } |
24180 | return ; | 22172 | return ; |
24181 | } | 22173 | } |
24182 | // $ANTLR end "rule__LowerBoundedScopeDefinition__Group__2" | 22174 | // $ANTLR end "rule__LowerBoundedScopeDefinition__Group__1__Impl" |
24183 | |||
24184 | |||
24185 | // $ANTLR start "rule__LowerBoundedScopeDefinition__Group__2__Impl" | ||
24186 | // InternalSolverLanguage.g:7289:1: rule__LowerBoundedScopeDefinition__Group__2__Impl : ( '.' ) ; | ||
24187 | public final void rule__LowerBoundedScopeDefinition__Group__2__Impl() throws RecognitionException { | ||
24188 | |||
24189 | int stackSize = keepStackSize(); | ||
24190 | |||
24191 | try { | ||
24192 | // InternalSolverLanguage.g:7293:1: ( ( '.' ) ) | ||
24193 | // InternalSolverLanguage.g:7294:1: ( '.' ) | ||
24194 | { | ||
24195 | // InternalSolverLanguage.g:7294:1: ( '.' ) | ||
24196 | // InternalSolverLanguage.g:7295:2: '.' | ||
24197 | { | ||
24198 | if ( state.backtracking==0 ) { | ||
24199 | before(grammarAccess.getLowerBoundedScopeDefinitionAccess().getFullStopKeyword_2()); | ||
24200 | } | ||
24201 | match(input,50,FOLLOW_2); if (state.failed) return ; | ||
24202 | if ( state.backtracking==0 ) { | ||
24203 | after(grammarAccess.getLowerBoundedScopeDefinitionAccess().getFullStopKeyword_2()); | ||
24204 | } | ||
24205 | |||
24206 | } | ||
24207 | |||
24208 | |||
24209 | } | ||
24210 | |||
24211 | } | ||
24212 | catch (RecognitionException re) { | ||
24213 | reportError(re); | ||
24214 | recover(input,re); | ||
24215 | } | ||
24216 | finally { | ||
24217 | |||
24218 | restoreStackSize(stackSize); | ||
24219 | |||
24220 | } | ||
24221 | return ; | ||
24222 | } | ||
24223 | // $ANTLR end "rule__LowerBoundedScopeDefinition__Group__2__Impl" | ||
24224 | 22175 | ||
24225 | 22176 | ||
24226 | // $ANTLR start "rule__LowerBoundedScopeDefinition__Group_1_0__0" | 22177 | // $ANTLR start "rule__LowerBoundedScopeDefinition__Group_1_0__0" |
24227 | // InternalSolverLanguage.g:7305:1: rule__LowerBoundedScopeDefinition__Group_1_0__0 : rule__LowerBoundedScopeDefinition__Group_1_0__0__Impl rule__LowerBoundedScopeDefinition__Group_1_0__1 ; | 22178 | // InternalSolverLanguageParser.g:7195:1: rule__LowerBoundedScopeDefinition__Group_1_0__0 : rule__LowerBoundedScopeDefinition__Group_1_0__0__Impl rule__LowerBoundedScopeDefinition__Group_1_0__1 ; |
24228 | public final void rule__LowerBoundedScopeDefinition__Group_1_0__0() throws RecognitionException { | 22179 | public final void rule__LowerBoundedScopeDefinition__Group_1_0__0() throws RecognitionException { |
24229 | 22180 | ||
24230 | int stackSize = keepStackSize(); | 22181 | int stackSize = keepStackSize(); |
24231 | 22182 | ||
24232 | try { | 22183 | try { |
24233 | // InternalSolverLanguage.g:7309:1: ( rule__LowerBoundedScopeDefinition__Group_1_0__0__Impl rule__LowerBoundedScopeDefinition__Group_1_0__1 ) | 22184 | // InternalSolverLanguageParser.g:7199:1: ( rule__LowerBoundedScopeDefinition__Group_1_0__0__Impl rule__LowerBoundedScopeDefinition__Group_1_0__1 ) |
24234 | // InternalSolverLanguage.g:7310:2: rule__LowerBoundedScopeDefinition__Group_1_0__0__Impl rule__LowerBoundedScopeDefinition__Group_1_0__1 | 22185 | // InternalSolverLanguageParser.g:7200:2: rule__LowerBoundedScopeDefinition__Group_1_0__0__Impl rule__LowerBoundedScopeDefinition__Group_1_0__1 |
24235 | { | 22186 | { |
24236 | pushFollow(FOLLOW_56); | 22187 | pushFollow(FOLLOW_55); |
24237 | rule__LowerBoundedScopeDefinition__Group_1_0__0__Impl(); | 22188 | rule__LowerBoundedScopeDefinition__Group_1_0__0__Impl(); |
24238 | 22189 | ||
24239 | state._fsp--; | 22190 | state._fsp--; |
24240 | if (state.failed) return ; | 22191 | |
24241 | pushFollow(FOLLOW_2); | 22192 | pushFollow(FOLLOW_2); |
24242 | rule__LowerBoundedScopeDefinition__Group_1_0__1(); | 22193 | rule__LowerBoundedScopeDefinition__Group_1_0__1(); |
24243 | 22194 | ||
24244 | state._fsp--; | 22195 | state._fsp--; |
24245 | if (state.failed) return ; | 22196 | |
24246 | 22197 | ||
24247 | } | 22198 | } |
24248 | 22199 | ||
@@ -24262,36 +22213,32 @@ public class InternalSolverLanguageParser extends AbstractInternalContentAssistP | |||
24262 | 22213 | ||
24263 | 22214 | ||
24264 | // $ANTLR start "rule__LowerBoundedScopeDefinition__Group_1_0__0__Impl" | 22215 | // $ANTLR start "rule__LowerBoundedScopeDefinition__Group_1_0__0__Impl" |
24265 | // InternalSolverLanguage.g:7317:1: rule__LowerBoundedScopeDefinition__Group_1_0__0__Impl : ( ( rule__LowerBoundedScopeDefinition__LowerBoundAssignment_1_0_0 ) ) ; | 22216 | // InternalSolverLanguageParser.g:7207:1: rule__LowerBoundedScopeDefinition__Group_1_0__0__Impl : ( ( rule__LowerBoundedScopeDefinition__LowerBoundAssignment_1_0_0 ) ) ; |
24266 | public final void rule__LowerBoundedScopeDefinition__Group_1_0__0__Impl() throws RecognitionException { | 22217 | public final void rule__LowerBoundedScopeDefinition__Group_1_0__0__Impl() throws RecognitionException { |
24267 | 22218 | ||
24268 | int stackSize = keepStackSize(); | 22219 | int stackSize = keepStackSize(); |
24269 | 22220 | ||
24270 | try { | 22221 | try { |
24271 | // InternalSolverLanguage.g:7321:1: ( ( ( rule__LowerBoundedScopeDefinition__LowerBoundAssignment_1_0_0 ) ) ) | 22222 | // InternalSolverLanguageParser.g:7211:1: ( ( ( rule__LowerBoundedScopeDefinition__LowerBoundAssignment_1_0_0 ) ) ) |
24272 | // InternalSolverLanguage.g:7322:1: ( ( rule__LowerBoundedScopeDefinition__LowerBoundAssignment_1_0_0 ) ) | 22223 | // InternalSolverLanguageParser.g:7212:1: ( ( rule__LowerBoundedScopeDefinition__LowerBoundAssignment_1_0_0 ) ) |
24273 | { | 22224 | { |
24274 | // InternalSolverLanguage.g:7322:1: ( ( rule__LowerBoundedScopeDefinition__LowerBoundAssignment_1_0_0 ) ) | 22225 | // InternalSolverLanguageParser.g:7212:1: ( ( rule__LowerBoundedScopeDefinition__LowerBoundAssignment_1_0_0 ) ) |
24275 | // InternalSolverLanguage.g:7323:2: ( rule__LowerBoundedScopeDefinition__LowerBoundAssignment_1_0_0 ) | 22226 | // InternalSolverLanguageParser.g:7213:2: ( rule__LowerBoundedScopeDefinition__LowerBoundAssignment_1_0_0 ) |
24276 | { | 22227 | { |
24277 | if ( state.backtracking==0 ) { | 22228 | before(grammarAccess.getLowerBoundedScopeDefinitionAccess().getLowerBoundAssignment_1_0_0()); |
24278 | before(grammarAccess.getLowerBoundedScopeDefinitionAccess().getLowerBoundAssignment_1_0_0()); | 22229 | // InternalSolverLanguageParser.g:7214:2: ( rule__LowerBoundedScopeDefinition__LowerBoundAssignment_1_0_0 ) |
24279 | } | 22230 | // InternalSolverLanguageParser.g:7214:3: rule__LowerBoundedScopeDefinition__LowerBoundAssignment_1_0_0 |
24280 | // InternalSolverLanguage.g:7324:2: ( rule__LowerBoundedScopeDefinition__LowerBoundAssignment_1_0_0 ) | ||
24281 | // InternalSolverLanguage.g:7324:3: rule__LowerBoundedScopeDefinition__LowerBoundAssignment_1_0_0 | ||
24282 | { | 22231 | { |
24283 | pushFollow(FOLLOW_2); | 22232 | pushFollow(FOLLOW_2); |
24284 | rule__LowerBoundedScopeDefinition__LowerBoundAssignment_1_0_0(); | 22233 | rule__LowerBoundedScopeDefinition__LowerBoundAssignment_1_0_0(); |
24285 | 22234 | ||
24286 | state._fsp--; | 22235 | state._fsp--; |
24287 | if (state.failed) return ; | ||
24288 | 22236 | ||
24289 | } | ||
24290 | 22237 | ||
24291 | if ( state.backtracking==0 ) { | ||
24292 | after(grammarAccess.getLowerBoundedScopeDefinitionAccess().getLowerBoundAssignment_1_0_0()); | ||
24293 | } | 22238 | } |
24294 | 22239 | ||
22240 | after(grammarAccess.getLowerBoundedScopeDefinitionAccess().getLowerBoundAssignment_1_0_0()); | ||
22241 | |||
24295 | } | 22242 | } |
24296 | 22243 | ||
24297 | 22244 | ||
@@ -24313,25 +22260,25 @@ public class InternalSolverLanguageParser extends AbstractInternalContentAssistP | |||
24313 | 22260 | ||
24314 | 22261 | ||
24315 | // $ANTLR start "rule__LowerBoundedScopeDefinition__Group_1_0__1" | 22262 | // $ANTLR start "rule__LowerBoundedScopeDefinition__Group_1_0__1" |
24316 | // InternalSolverLanguage.g:7332:1: rule__LowerBoundedScopeDefinition__Group_1_0__1 : rule__LowerBoundedScopeDefinition__Group_1_0__1__Impl rule__LowerBoundedScopeDefinition__Group_1_0__2 ; | 22263 | // InternalSolverLanguageParser.g:7222:1: rule__LowerBoundedScopeDefinition__Group_1_0__1 : rule__LowerBoundedScopeDefinition__Group_1_0__1__Impl rule__LowerBoundedScopeDefinition__Group_1_0__2 ; |
24317 | public final void rule__LowerBoundedScopeDefinition__Group_1_0__1() throws RecognitionException { | 22264 | public final void rule__LowerBoundedScopeDefinition__Group_1_0__1() throws RecognitionException { |
24318 | 22265 | ||
24319 | int stackSize = keepStackSize(); | 22266 | int stackSize = keepStackSize(); |
24320 | 22267 | ||
24321 | try { | 22268 | try { |
24322 | // InternalSolverLanguage.g:7336:1: ( rule__LowerBoundedScopeDefinition__Group_1_0__1__Impl rule__LowerBoundedScopeDefinition__Group_1_0__2 ) | 22269 | // InternalSolverLanguageParser.g:7226:1: ( rule__LowerBoundedScopeDefinition__Group_1_0__1__Impl rule__LowerBoundedScopeDefinition__Group_1_0__2 ) |
24323 | // InternalSolverLanguage.g:7337:2: rule__LowerBoundedScopeDefinition__Group_1_0__1__Impl rule__LowerBoundedScopeDefinition__Group_1_0__2 | 22270 | // InternalSolverLanguageParser.g:7227:2: rule__LowerBoundedScopeDefinition__Group_1_0__1__Impl rule__LowerBoundedScopeDefinition__Group_1_0__2 |
24324 | { | 22271 | { |
24325 | pushFollow(FOLLOW_9); | 22272 | pushFollow(FOLLOW_9); |
24326 | rule__LowerBoundedScopeDefinition__Group_1_0__1__Impl(); | 22273 | rule__LowerBoundedScopeDefinition__Group_1_0__1__Impl(); |
24327 | 22274 | ||
24328 | state._fsp--; | 22275 | state._fsp--; |
24329 | if (state.failed) return ; | 22276 | |
24330 | pushFollow(FOLLOW_2); | 22277 | pushFollow(FOLLOW_2); |
24331 | rule__LowerBoundedScopeDefinition__Group_1_0__2(); | 22278 | rule__LowerBoundedScopeDefinition__Group_1_0__2(); |
24332 | 22279 | ||
24333 | state._fsp--; | 22280 | state._fsp--; |
24334 | if (state.failed) return ; | 22281 | |
24335 | 22282 | ||
24336 | } | 22283 | } |
24337 | 22284 | ||
@@ -24351,25 +22298,21 @@ public class InternalSolverLanguageParser extends AbstractInternalContentAssistP | |||
24351 | 22298 | ||
24352 | 22299 | ||
24353 | // $ANTLR start "rule__LowerBoundedScopeDefinition__Group_1_0__1__Impl" | 22300 | // $ANTLR start "rule__LowerBoundedScopeDefinition__Group_1_0__1__Impl" |
24354 | // InternalSolverLanguage.g:7344:1: rule__LowerBoundedScopeDefinition__Group_1_0__1__Impl : ( '<=' ) ; | 22301 | // InternalSolverLanguageParser.g:7234:1: rule__LowerBoundedScopeDefinition__Group_1_0__1__Impl : ( LessThanSignEqualsSign ) ; |
24355 | public final void rule__LowerBoundedScopeDefinition__Group_1_0__1__Impl() throws RecognitionException { | 22302 | public final void rule__LowerBoundedScopeDefinition__Group_1_0__1__Impl() throws RecognitionException { |
24356 | 22303 | ||
24357 | int stackSize = keepStackSize(); | 22304 | int stackSize = keepStackSize(); |
24358 | 22305 | ||
24359 | try { | 22306 | try { |
24360 | // InternalSolverLanguage.g:7348:1: ( ( '<=' ) ) | 22307 | // InternalSolverLanguageParser.g:7238:1: ( ( LessThanSignEqualsSign ) ) |
24361 | // InternalSolverLanguage.g:7349:1: ( '<=' ) | 22308 | // InternalSolverLanguageParser.g:7239:1: ( LessThanSignEqualsSign ) |
24362 | { | 22309 | { |
24363 | // InternalSolverLanguage.g:7349:1: ( '<=' ) | 22310 | // InternalSolverLanguageParser.g:7239:1: ( LessThanSignEqualsSign ) |
24364 | // InternalSolverLanguage.g:7350:2: '<=' | 22311 | // InternalSolverLanguageParser.g:7240:2: LessThanSignEqualsSign |
24365 | { | 22312 | { |
24366 | if ( state.backtracking==0 ) { | 22313 | before(grammarAccess.getLowerBoundedScopeDefinitionAccess().getLessThanSignEqualsSignKeyword_1_0_1()); |
24367 | before(grammarAccess.getLowerBoundedScopeDefinitionAccess().getLessThanSignEqualsSignKeyword_1_0_1()); | 22314 | match(input,LessThanSignEqualsSign,FOLLOW_2); |
24368 | } | 22315 | after(grammarAccess.getLowerBoundedScopeDefinitionAccess().getLessThanSignEqualsSignKeyword_1_0_1()); |
24369 | match(input,22,FOLLOW_2); if (state.failed) return ; | ||
24370 | if ( state.backtracking==0 ) { | ||
24371 | after(grammarAccess.getLowerBoundedScopeDefinitionAccess().getLessThanSignEqualsSignKeyword_1_0_1()); | ||
24372 | } | ||
24373 | 22316 | ||
24374 | } | 22317 | } |
24375 | 22318 | ||
@@ -24392,20 +22335,20 @@ public class InternalSolverLanguageParser extends AbstractInternalContentAssistP | |||
24392 | 22335 | ||
24393 | 22336 | ||
24394 | // $ANTLR start "rule__LowerBoundedScopeDefinition__Group_1_0__2" | 22337 | // $ANTLR start "rule__LowerBoundedScopeDefinition__Group_1_0__2" |
24395 | // InternalSolverLanguage.g:7359:1: rule__LowerBoundedScopeDefinition__Group_1_0__2 : rule__LowerBoundedScopeDefinition__Group_1_0__2__Impl ; | 22338 | // InternalSolverLanguageParser.g:7249:1: rule__LowerBoundedScopeDefinition__Group_1_0__2 : rule__LowerBoundedScopeDefinition__Group_1_0__2__Impl ; |
24396 | public final void rule__LowerBoundedScopeDefinition__Group_1_0__2() throws RecognitionException { | 22339 | public final void rule__LowerBoundedScopeDefinition__Group_1_0__2() throws RecognitionException { |
24397 | 22340 | ||
24398 | int stackSize = keepStackSize(); | 22341 | int stackSize = keepStackSize(); |
24399 | 22342 | ||
24400 | try { | 22343 | try { |
24401 | // InternalSolverLanguage.g:7363:1: ( rule__LowerBoundedScopeDefinition__Group_1_0__2__Impl ) | 22344 | // InternalSolverLanguageParser.g:7253:1: ( rule__LowerBoundedScopeDefinition__Group_1_0__2__Impl ) |
24402 | // InternalSolverLanguage.g:7364:2: rule__LowerBoundedScopeDefinition__Group_1_0__2__Impl | 22345 | // InternalSolverLanguageParser.g:7254:2: rule__LowerBoundedScopeDefinition__Group_1_0__2__Impl |
24403 | { | 22346 | { |
24404 | pushFollow(FOLLOW_2); | 22347 | pushFollow(FOLLOW_2); |
24405 | rule__LowerBoundedScopeDefinition__Group_1_0__2__Impl(); | 22348 | rule__LowerBoundedScopeDefinition__Group_1_0__2__Impl(); |
24406 | 22349 | ||
24407 | state._fsp--; | 22350 | state._fsp--; |
24408 | if (state.failed) return ; | 22351 | |
24409 | 22352 | ||
24410 | } | 22353 | } |
24411 | 22354 | ||
@@ -24425,36 +22368,32 @@ public class InternalSolverLanguageParser extends AbstractInternalContentAssistP | |||
24425 | 22368 | ||
24426 | 22369 | ||
24427 | // $ANTLR start "rule__LowerBoundedScopeDefinition__Group_1_0__2__Impl" | 22370 | // $ANTLR start "rule__LowerBoundedScopeDefinition__Group_1_0__2__Impl" |
24428 | // InternalSolverLanguage.g:7370:1: rule__LowerBoundedScopeDefinition__Group_1_0__2__Impl : ( ( rule__LowerBoundedScopeDefinition__TypeAssignment_1_0_2 ) ) ; | 22371 | // InternalSolverLanguageParser.g:7260:1: rule__LowerBoundedScopeDefinition__Group_1_0__2__Impl : ( ( rule__LowerBoundedScopeDefinition__TypeAssignment_1_0_2 ) ) ; |
24429 | public final void rule__LowerBoundedScopeDefinition__Group_1_0__2__Impl() throws RecognitionException { | 22372 | public final void rule__LowerBoundedScopeDefinition__Group_1_0__2__Impl() throws RecognitionException { |
24430 | 22373 | ||
24431 | int stackSize = keepStackSize(); | 22374 | int stackSize = keepStackSize(); |
24432 | 22375 | ||
24433 | try { | 22376 | try { |
24434 | // InternalSolverLanguage.g:7374:1: ( ( ( rule__LowerBoundedScopeDefinition__TypeAssignment_1_0_2 ) ) ) | 22377 | // InternalSolverLanguageParser.g:7264:1: ( ( ( rule__LowerBoundedScopeDefinition__TypeAssignment_1_0_2 ) ) ) |
24435 | // InternalSolverLanguage.g:7375:1: ( ( rule__LowerBoundedScopeDefinition__TypeAssignment_1_0_2 ) ) | 22378 | // InternalSolverLanguageParser.g:7265:1: ( ( rule__LowerBoundedScopeDefinition__TypeAssignment_1_0_2 ) ) |
24436 | { | 22379 | { |
24437 | // InternalSolverLanguage.g:7375:1: ( ( rule__LowerBoundedScopeDefinition__TypeAssignment_1_0_2 ) ) | 22380 | // InternalSolverLanguageParser.g:7265:1: ( ( rule__LowerBoundedScopeDefinition__TypeAssignment_1_0_2 ) ) |
24438 | // InternalSolverLanguage.g:7376:2: ( rule__LowerBoundedScopeDefinition__TypeAssignment_1_0_2 ) | 22381 | // InternalSolverLanguageParser.g:7266:2: ( rule__LowerBoundedScopeDefinition__TypeAssignment_1_0_2 ) |
24439 | { | 22382 | { |
24440 | if ( state.backtracking==0 ) { | 22383 | before(grammarAccess.getLowerBoundedScopeDefinitionAccess().getTypeAssignment_1_0_2()); |
24441 | before(grammarAccess.getLowerBoundedScopeDefinitionAccess().getTypeAssignment_1_0_2()); | 22384 | // InternalSolverLanguageParser.g:7267:2: ( rule__LowerBoundedScopeDefinition__TypeAssignment_1_0_2 ) |
24442 | } | 22385 | // InternalSolverLanguageParser.g:7267:3: rule__LowerBoundedScopeDefinition__TypeAssignment_1_0_2 |
24443 | // InternalSolverLanguage.g:7377:2: ( rule__LowerBoundedScopeDefinition__TypeAssignment_1_0_2 ) | ||
24444 | // InternalSolverLanguage.g:7377:3: rule__LowerBoundedScopeDefinition__TypeAssignment_1_0_2 | ||
24445 | { | 22386 | { |
24446 | pushFollow(FOLLOW_2); | 22387 | pushFollow(FOLLOW_2); |
24447 | rule__LowerBoundedScopeDefinition__TypeAssignment_1_0_2(); | 22388 | rule__LowerBoundedScopeDefinition__TypeAssignment_1_0_2(); |
24448 | 22389 | ||
24449 | state._fsp--; | 22390 | state._fsp--; |
24450 | if (state.failed) return ; | ||
24451 | 22391 | ||
24452 | } | ||
24453 | 22392 | ||
24454 | if ( state.backtracking==0 ) { | ||
24455 | after(grammarAccess.getLowerBoundedScopeDefinitionAccess().getTypeAssignment_1_0_2()); | ||
24456 | } | 22393 | } |
24457 | 22394 | ||
22395 | after(grammarAccess.getLowerBoundedScopeDefinitionAccess().getTypeAssignment_1_0_2()); | ||
22396 | |||
24458 | } | 22397 | } |
24459 | 22398 | ||
24460 | 22399 | ||
@@ -24476,25 +22415,25 @@ public class InternalSolverLanguageParser extends AbstractInternalContentAssistP | |||
24476 | 22415 | ||
24477 | 22416 | ||
24478 | // $ANTLR start "rule__LowerBoundedScopeDefinition__Group_1_1__0" | 22417 | // $ANTLR start "rule__LowerBoundedScopeDefinition__Group_1_1__0" |
24479 | // InternalSolverLanguage.g:7386:1: rule__LowerBoundedScopeDefinition__Group_1_1__0 : rule__LowerBoundedScopeDefinition__Group_1_1__0__Impl rule__LowerBoundedScopeDefinition__Group_1_1__1 ; | 22418 | // InternalSolverLanguageParser.g:7276:1: rule__LowerBoundedScopeDefinition__Group_1_1__0 : rule__LowerBoundedScopeDefinition__Group_1_1__0__Impl rule__LowerBoundedScopeDefinition__Group_1_1__1 ; |
24480 | public final void rule__LowerBoundedScopeDefinition__Group_1_1__0() throws RecognitionException { | 22419 | public final void rule__LowerBoundedScopeDefinition__Group_1_1__0() throws RecognitionException { |
24481 | 22420 | ||
24482 | int stackSize = keepStackSize(); | 22421 | int stackSize = keepStackSize(); |
24483 | 22422 | ||
24484 | try { | 22423 | try { |
24485 | // InternalSolverLanguage.g:7390:1: ( rule__LowerBoundedScopeDefinition__Group_1_1__0__Impl rule__LowerBoundedScopeDefinition__Group_1_1__1 ) | 22424 | // InternalSolverLanguageParser.g:7280:1: ( rule__LowerBoundedScopeDefinition__Group_1_1__0__Impl rule__LowerBoundedScopeDefinition__Group_1_1__1 ) |
24486 | // InternalSolverLanguage.g:7391:2: rule__LowerBoundedScopeDefinition__Group_1_1__0__Impl rule__LowerBoundedScopeDefinition__Group_1_1__1 | 22425 | // InternalSolverLanguageParser.g:7281:2: rule__LowerBoundedScopeDefinition__Group_1_1__0__Impl rule__LowerBoundedScopeDefinition__Group_1_1__1 |
24487 | { | 22426 | { |
24488 | pushFollow(FOLLOW_57); | 22427 | pushFollow(FOLLOW_56); |
24489 | rule__LowerBoundedScopeDefinition__Group_1_1__0__Impl(); | 22428 | rule__LowerBoundedScopeDefinition__Group_1_1__0__Impl(); |
24490 | 22429 | ||
24491 | state._fsp--; | 22430 | state._fsp--; |
24492 | if (state.failed) return ; | 22431 | |
24493 | pushFollow(FOLLOW_2); | 22432 | pushFollow(FOLLOW_2); |
24494 | rule__LowerBoundedScopeDefinition__Group_1_1__1(); | 22433 | rule__LowerBoundedScopeDefinition__Group_1_1__1(); |
24495 | 22434 | ||
24496 | state._fsp--; | 22435 | state._fsp--; |
24497 | if (state.failed) return ; | 22436 | |
24498 | 22437 | ||
24499 | } | 22438 | } |
24500 | 22439 | ||
@@ -24514,36 +22453,32 @@ public class InternalSolverLanguageParser extends AbstractInternalContentAssistP | |||
24514 | 22453 | ||
24515 | 22454 | ||
24516 | // $ANTLR start "rule__LowerBoundedScopeDefinition__Group_1_1__0__Impl" | 22455 | // $ANTLR start "rule__LowerBoundedScopeDefinition__Group_1_1__0__Impl" |
24517 | // InternalSolverLanguage.g:7398:1: rule__LowerBoundedScopeDefinition__Group_1_1__0__Impl : ( ( rule__LowerBoundedScopeDefinition__TypeAssignment_1_1_0 ) ) ; | 22456 | // InternalSolverLanguageParser.g:7288:1: rule__LowerBoundedScopeDefinition__Group_1_1__0__Impl : ( ( rule__LowerBoundedScopeDefinition__TypeAssignment_1_1_0 ) ) ; |
24518 | public final void rule__LowerBoundedScopeDefinition__Group_1_1__0__Impl() throws RecognitionException { | 22457 | public final void rule__LowerBoundedScopeDefinition__Group_1_1__0__Impl() throws RecognitionException { |
24519 | 22458 | ||
24520 | int stackSize = keepStackSize(); | 22459 | int stackSize = keepStackSize(); |
24521 | 22460 | ||
24522 | try { | 22461 | try { |
24523 | // InternalSolverLanguage.g:7402:1: ( ( ( rule__LowerBoundedScopeDefinition__TypeAssignment_1_1_0 ) ) ) | 22462 | // InternalSolverLanguageParser.g:7292:1: ( ( ( rule__LowerBoundedScopeDefinition__TypeAssignment_1_1_0 ) ) ) |
24524 | // InternalSolverLanguage.g:7403:1: ( ( rule__LowerBoundedScopeDefinition__TypeAssignment_1_1_0 ) ) | 22463 | // InternalSolverLanguageParser.g:7293:1: ( ( rule__LowerBoundedScopeDefinition__TypeAssignment_1_1_0 ) ) |
24525 | { | 22464 | { |
24526 | // InternalSolverLanguage.g:7403:1: ( ( rule__LowerBoundedScopeDefinition__TypeAssignment_1_1_0 ) ) | 22465 | // InternalSolverLanguageParser.g:7293:1: ( ( rule__LowerBoundedScopeDefinition__TypeAssignment_1_1_0 ) ) |
24527 | // InternalSolverLanguage.g:7404:2: ( rule__LowerBoundedScopeDefinition__TypeAssignment_1_1_0 ) | 22466 | // InternalSolverLanguageParser.g:7294:2: ( rule__LowerBoundedScopeDefinition__TypeAssignment_1_1_0 ) |
24528 | { | 22467 | { |
24529 | if ( state.backtracking==0 ) { | 22468 | before(grammarAccess.getLowerBoundedScopeDefinitionAccess().getTypeAssignment_1_1_0()); |
24530 | before(grammarAccess.getLowerBoundedScopeDefinitionAccess().getTypeAssignment_1_1_0()); | 22469 | // InternalSolverLanguageParser.g:7295:2: ( rule__LowerBoundedScopeDefinition__TypeAssignment_1_1_0 ) |
24531 | } | 22470 | // InternalSolverLanguageParser.g:7295:3: rule__LowerBoundedScopeDefinition__TypeAssignment_1_1_0 |
24532 | // InternalSolverLanguage.g:7405:2: ( rule__LowerBoundedScopeDefinition__TypeAssignment_1_1_0 ) | ||
24533 | // InternalSolverLanguage.g:7405:3: rule__LowerBoundedScopeDefinition__TypeAssignment_1_1_0 | ||
24534 | { | 22471 | { |
24535 | pushFollow(FOLLOW_2); | 22472 | pushFollow(FOLLOW_2); |
24536 | rule__LowerBoundedScopeDefinition__TypeAssignment_1_1_0(); | 22473 | rule__LowerBoundedScopeDefinition__TypeAssignment_1_1_0(); |
24537 | 22474 | ||
24538 | state._fsp--; | 22475 | state._fsp--; |
24539 | if (state.failed) return ; | ||
24540 | 22476 | ||
24541 | } | ||
24542 | 22477 | ||
24543 | if ( state.backtracking==0 ) { | ||
24544 | after(grammarAccess.getLowerBoundedScopeDefinitionAccess().getTypeAssignment_1_1_0()); | ||
24545 | } | 22478 | } |
24546 | 22479 | ||
22480 | after(grammarAccess.getLowerBoundedScopeDefinitionAccess().getTypeAssignment_1_1_0()); | ||
22481 | |||
24547 | } | 22482 | } |
24548 | 22483 | ||
24549 | 22484 | ||
@@ -24565,25 +22500,25 @@ public class InternalSolverLanguageParser extends AbstractInternalContentAssistP | |||
24565 | 22500 | ||
24566 | 22501 | ||
24567 | // $ANTLR start "rule__LowerBoundedScopeDefinition__Group_1_1__1" | 22502 | // $ANTLR start "rule__LowerBoundedScopeDefinition__Group_1_1__1" |
24568 | // InternalSolverLanguage.g:7413:1: rule__LowerBoundedScopeDefinition__Group_1_1__1 : rule__LowerBoundedScopeDefinition__Group_1_1__1__Impl rule__LowerBoundedScopeDefinition__Group_1_1__2 ; | 22503 | // InternalSolverLanguageParser.g:7303:1: rule__LowerBoundedScopeDefinition__Group_1_1__1 : rule__LowerBoundedScopeDefinition__Group_1_1__1__Impl rule__LowerBoundedScopeDefinition__Group_1_1__2 ; |
24569 | public final void rule__LowerBoundedScopeDefinition__Group_1_1__1() throws RecognitionException { | 22504 | public final void rule__LowerBoundedScopeDefinition__Group_1_1__1() throws RecognitionException { |
24570 | 22505 | ||
24571 | int stackSize = keepStackSize(); | 22506 | int stackSize = keepStackSize(); |
24572 | 22507 | ||
24573 | try { | 22508 | try { |
24574 | // InternalSolverLanguage.g:7417:1: ( rule__LowerBoundedScopeDefinition__Group_1_1__1__Impl rule__LowerBoundedScopeDefinition__Group_1_1__2 ) | 22509 | // InternalSolverLanguageParser.g:7307:1: ( rule__LowerBoundedScopeDefinition__Group_1_1__1__Impl rule__LowerBoundedScopeDefinition__Group_1_1__2 ) |
24575 | // InternalSolverLanguage.g:7418:2: rule__LowerBoundedScopeDefinition__Group_1_1__1__Impl rule__LowerBoundedScopeDefinition__Group_1_1__2 | 22510 | // InternalSolverLanguageParser.g:7308:2: rule__LowerBoundedScopeDefinition__Group_1_1__1__Impl rule__LowerBoundedScopeDefinition__Group_1_1__2 |
24576 | { | 22511 | { |
24577 | pushFollow(FOLLOW_53); | 22512 | pushFollow(FOLLOW_52); |
24578 | rule__LowerBoundedScopeDefinition__Group_1_1__1__Impl(); | 22513 | rule__LowerBoundedScopeDefinition__Group_1_1__1__Impl(); |
24579 | 22514 | ||
24580 | state._fsp--; | 22515 | state._fsp--; |
24581 | if (state.failed) return ; | 22516 | |
24582 | pushFollow(FOLLOW_2); | 22517 | pushFollow(FOLLOW_2); |
24583 | rule__LowerBoundedScopeDefinition__Group_1_1__2(); | 22518 | rule__LowerBoundedScopeDefinition__Group_1_1__2(); |
24584 | 22519 | ||
24585 | state._fsp--; | 22520 | state._fsp--; |
24586 | if (state.failed) return ; | 22521 | |
24587 | 22522 | ||
24588 | } | 22523 | } |
24589 | 22524 | ||
@@ -24603,25 +22538,21 @@ public class InternalSolverLanguageParser extends AbstractInternalContentAssistP | |||
24603 | 22538 | ||
24604 | 22539 | ||
24605 | // $ANTLR start "rule__LowerBoundedScopeDefinition__Group_1_1__1__Impl" | 22540 | // $ANTLR start "rule__LowerBoundedScopeDefinition__Group_1_1__1__Impl" |
24606 | // InternalSolverLanguage.g:7425:1: rule__LowerBoundedScopeDefinition__Group_1_1__1__Impl : ( '>=' ) ; | 22541 | // InternalSolverLanguageParser.g:7315:1: rule__LowerBoundedScopeDefinition__Group_1_1__1__Impl : ( GreaterThanSignEqualsSign ) ; |
24607 | public final void rule__LowerBoundedScopeDefinition__Group_1_1__1__Impl() throws RecognitionException { | 22542 | public final void rule__LowerBoundedScopeDefinition__Group_1_1__1__Impl() throws RecognitionException { |
24608 | 22543 | ||
24609 | int stackSize = keepStackSize(); | 22544 | int stackSize = keepStackSize(); |
24610 | 22545 | ||
24611 | try { | 22546 | try { |
24612 | // InternalSolverLanguage.g:7429:1: ( ( '>=' ) ) | 22547 | // InternalSolverLanguageParser.g:7319:1: ( ( GreaterThanSignEqualsSign ) ) |
24613 | // InternalSolverLanguage.g:7430:1: ( '>=' ) | 22548 | // InternalSolverLanguageParser.g:7320:1: ( GreaterThanSignEqualsSign ) |
24614 | { | 22549 | { |
24615 | // InternalSolverLanguage.g:7430:1: ( '>=' ) | 22550 | // InternalSolverLanguageParser.g:7320:1: ( GreaterThanSignEqualsSign ) |
24616 | // InternalSolverLanguage.g:7431:2: '>=' | 22551 | // InternalSolverLanguageParser.g:7321:2: GreaterThanSignEqualsSign |
24617 | { | 22552 | { |
24618 | if ( state.backtracking==0 ) { | 22553 | before(grammarAccess.getLowerBoundedScopeDefinitionAccess().getGreaterThanSignEqualsSignKeyword_1_1_1()); |
24619 | before(grammarAccess.getLowerBoundedScopeDefinitionAccess().getGreaterThanSignEqualsSignKeyword_1_1_1()); | 22554 | match(input,GreaterThanSignEqualsSign,FOLLOW_2); |
24620 | } | 22555 | after(grammarAccess.getLowerBoundedScopeDefinitionAccess().getGreaterThanSignEqualsSignKeyword_1_1_1()); |
24621 | match(input,24,FOLLOW_2); if (state.failed) return ; | ||
24622 | if ( state.backtracking==0 ) { | ||
24623 | after(grammarAccess.getLowerBoundedScopeDefinitionAccess().getGreaterThanSignEqualsSignKeyword_1_1_1()); | ||
24624 | } | ||
24625 | 22556 | ||
24626 | } | 22557 | } |
24627 | 22558 | ||
@@ -24644,20 +22575,20 @@ public class InternalSolverLanguageParser extends AbstractInternalContentAssistP | |||
24644 | 22575 | ||
24645 | 22576 | ||
24646 | // $ANTLR start "rule__LowerBoundedScopeDefinition__Group_1_1__2" | 22577 | // $ANTLR start "rule__LowerBoundedScopeDefinition__Group_1_1__2" |
24647 | // InternalSolverLanguage.g:7440:1: rule__LowerBoundedScopeDefinition__Group_1_1__2 : rule__LowerBoundedScopeDefinition__Group_1_1__2__Impl ; | 22578 | // InternalSolverLanguageParser.g:7330:1: rule__LowerBoundedScopeDefinition__Group_1_1__2 : rule__LowerBoundedScopeDefinition__Group_1_1__2__Impl ; |
24648 | public final void rule__LowerBoundedScopeDefinition__Group_1_1__2() throws RecognitionException { | 22579 | public final void rule__LowerBoundedScopeDefinition__Group_1_1__2() throws RecognitionException { |
24649 | 22580 | ||
24650 | int stackSize = keepStackSize(); | 22581 | int stackSize = keepStackSize(); |
24651 | 22582 | ||
24652 | try { | 22583 | try { |
24653 | // InternalSolverLanguage.g:7444:1: ( rule__LowerBoundedScopeDefinition__Group_1_1__2__Impl ) | 22584 | // InternalSolverLanguageParser.g:7334:1: ( rule__LowerBoundedScopeDefinition__Group_1_1__2__Impl ) |
24654 | // InternalSolverLanguage.g:7445:2: rule__LowerBoundedScopeDefinition__Group_1_1__2__Impl | 22585 | // InternalSolverLanguageParser.g:7335:2: rule__LowerBoundedScopeDefinition__Group_1_1__2__Impl |
24655 | { | 22586 | { |
24656 | pushFollow(FOLLOW_2); | 22587 | pushFollow(FOLLOW_2); |
24657 | rule__LowerBoundedScopeDefinition__Group_1_1__2__Impl(); | 22588 | rule__LowerBoundedScopeDefinition__Group_1_1__2__Impl(); |
24658 | 22589 | ||
24659 | state._fsp--; | 22590 | state._fsp--; |
24660 | if (state.failed) return ; | 22591 | |
24661 | 22592 | ||
24662 | } | 22593 | } |
24663 | 22594 | ||
@@ -24677,36 +22608,32 @@ public class InternalSolverLanguageParser extends AbstractInternalContentAssistP | |||
24677 | 22608 | ||
24678 | 22609 | ||
24679 | // $ANTLR start "rule__LowerBoundedScopeDefinition__Group_1_1__2__Impl" | 22610 | // $ANTLR start "rule__LowerBoundedScopeDefinition__Group_1_1__2__Impl" |
24680 | // InternalSolverLanguage.g:7451:1: rule__LowerBoundedScopeDefinition__Group_1_1__2__Impl : ( ( rule__LowerBoundedScopeDefinition__LowerBoundAssignment_1_1_2 ) ) ; | 22611 | // InternalSolverLanguageParser.g:7341:1: rule__LowerBoundedScopeDefinition__Group_1_1__2__Impl : ( ( rule__LowerBoundedScopeDefinition__LowerBoundAssignment_1_1_2 ) ) ; |
24681 | public final void rule__LowerBoundedScopeDefinition__Group_1_1__2__Impl() throws RecognitionException { | 22612 | public final void rule__LowerBoundedScopeDefinition__Group_1_1__2__Impl() throws RecognitionException { |
24682 | 22613 | ||
24683 | int stackSize = keepStackSize(); | 22614 | int stackSize = keepStackSize(); |
24684 | 22615 | ||
24685 | try { | 22616 | try { |
24686 | // InternalSolverLanguage.g:7455:1: ( ( ( rule__LowerBoundedScopeDefinition__LowerBoundAssignment_1_1_2 ) ) ) | 22617 | // InternalSolverLanguageParser.g:7345:1: ( ( ( rule__LowerBoundedScopeDefinition__LowerBoundAssignment_1_1_2 ) ) ) |
24687 | // InternalSolverLanguage.g:7456:1: ( ( rule__LowerBoundedScopeDefinition__LowerBoundAssignment_1_1_2 ) ) | 22618 | // InternalSolverLanguageParser.g:7346:1: ( ( rule__LowerBoundedScopeDefinition__LowerBoundAssignment_1_1_2 ) ) |
24688 | { | 22619 | { |
24689 | // InternalSolverLanguage.g:7456:1: ( ( rule__LowerBoundedScopeDefinition__LowerBoundAssignment_1_1_2 ) ) | 22620 | // InternalSolverLanguageParser.g:7346:1: ( ( rule__LowerBoundedScopeDefinition__LowerBoundAssignment_1_1_2 ) ) |
24690 | // InternalSolverLanguage.g:7457:2: ( rule__LowerBoundedScopeDefinition__LowerBoundAssignment_1_1_2 ) | 22621 | // InternalSolverLanguageParser.g:7347:2: ( rule__LowerBoundedScopeDefinition__LowerBoundAssignment_1_1_2 ) |
24691 | { | 22622 | { |
24692 | if ( state.backtracking==0 ) { | 22623 | before(grammarAccess.getLowerBoundedScopeDefinitionAccess().getLowerBoundAssignment_1_1_2()); |
24693 | before(grammarAccess.getLowerBoundedScopeDefinitionAccess().getLowerBoundAssignment_1_1_2()); | 22624 | // InternalSolverLanguageParser.g:7348:2: ( rule__LowerBoundedScopeDefinition__LowerBoundAssignment_1_1_2 ) |
24694 | } | 22625 | // InternalSolverLanguageParser.g:7348:3: rule__LowerBoundedScopeDefinition__LowerBoundAssignment_1_1_2 |
24695 | // InternalSolverLanguage.g:7458:2: ( rule__LowerBoundedScopeDefinition__LowerBoundAssignment_1_1_2 ) | ||
24696 | // InternalSolverLanguage.g:7458:3: rule__LowerBoundedScopeDefinition__LowerBoundAssignment_1_1_2 | ||
24697 | { | 22626 | { |
24698 | pushFollow(FOLLOW_2); | 22627 | pushFollow(FOLLOW_2); |
24699 | rule__LowerBoundedScopeDefinition__LowerBoundAssignment_1_1_2(); | 22628 | rule__LowerBoundedScopeDefinition__LowerBoundAssignment_1_1_2(); |
24700 | 22629 | ||
24701 | state._fsp--; | 22630 | state._fsp--; |
24702 | if (state.failed) return ; | ||
24703 | 22631 | ||
24704 | } | ||
24705 | 22632 | ||
24706 | if ( state.backtracking==0 ) { | ||
24707 | after(grammarAccess.getLowerBoundedScopeDefinitionAccess().getLowerBoundAssignment_1_1_2()); | ||
24708 | } | 22633 | } |
24709 | 22634 | ||
22635 | after(grammarAccess.getLowerBoundedScopeDefinitionAccess().getLowerBoundAssignment_1_1_2()); | ||
22636 | |||
24710 | } | 22637 | } |
24711 | 22638 | ||
24712 | 22639 | ||
@@ -24728,25 +22655,25 @@ public class InternalSolverLanguageParser extends AbstractInternalContentAssistP | |||
24728 | 22655 | ||
24729 | 22656 | ||
24730 | // $ANTLR start "rule__ObjectiveDefinition__Group__0" | 22657 | // $ANTLR start "rule__ObjectiveDefinition__Group__0" |
24731 | // InternalSolverLanguage.g:7467:1: rule__ObjectiveDefinition__Group__0 : rule__ObjectiveDefinition__Group__0__Impl rule__ObjectiveDefinition__Group__1 ; | 22658 | // InternalSolverLanguageParser.g:7357:1: rule__ObjectiveDefinition__Group__0 : rule__ObjectiveDefinition__Group__0__Impl rule__ObjectiveDefinition__Group__1 ; |
24732 | public final void rule__ObjectiveDefinition__Group__0() throws RecognitionException { | 22659 | public final void rule__ObjectiveDefinition__Group__0() throws RecognitionException { |
24733 | 22660 | ||
24734 | int stackSize = keepStackSize(); | 22661 | int stackSize = keepStackSize(); |
24735 | 22662 | ||
24736 | try { | 22663 | try { |
24737 | // InternalSolverLanguage.g:7471:1: ( rule__ObjectiveDefinition__Group__0__Impl rule__ObjectiveDefinition__Group__1 ) | 22664 | // InternalSolverLanguageParser.g:7361:1: ( rule__ObjectiveDefinition__Group__0__Impl rule__ObjectiveDefinition__Group__1 ) |
24738 | // InternalSolverLanguage.g:7472:2: rule__ObjectiveDefinition__Group__0__Impl rule__ObjectiveDefinition__Group__1 | 22665 | // InternalSolverLanguageParser.g:7362:2: rule__ObjectiveDefinition__Group__0__Impl rule__ObjectiveDefinition__Group__1 |
24739 | { | 22666 | { |
24740 | pushFollow(FOLLOW_7); | 22667 | pushFollow(FOLLOW_7); |
24741 | rule__ObjectiveDefinition__Group__0__Impl(); | 22668 | rule__ObjectiveDefinition__Group__0__Impl(); |
24742 | 22669 | ||
24743 | state._fsp--; | 22670 | state._fsp--; |
24744 | if (state.failed) return ; | 22671 | |
24745 | pushFollow(FOLLOW_2); | 22672 | pushFollow(FOLLOW_2); |
24746 | rule__ObjectiveDefinition__Group__1(); | 22673 | rule__ObjectiveDefinition__Group__1(); |
24747 | 22674 | ||
24748 | state._fsp--; | 22675 | state._fsp--; |
24749 | if (state.failed) return ; | 22676 | |
24750 | 22677 | ||
24751 | } | 22678 | } |
24752 | 22679 | ||
@@ -24766,36 +22693,32 @@ public class InternalSolverLanguageParser extends AbstractInternalContentAssistP | |||
24766 | 22693 | ||
24767 | 22694 | ||
24768 | // $ANTLR start "rule__ObjectiveDefinition__Group__0__Impl" | 22695 | // $ANTLR start "rule__ObjectiveDefinition__Group__0__Impl" |
24769 | // InternalSolverLanguage.g:7479:1: rule__ObjectiveDefinition__Group__0__Impl : ( ( rule__ObjectiveDefinition__KindAssignment_0 ) ) ; | 22696 | // InternalSolverLanguageParser.g:7369:1: rule__ObjectiveDefinition__Group__0__Impl : ( ( rule__ObjectiveDefinition__KindAssignment_0 ) ) ; |
24770 | public final void rule__ObjectiveDefinition__Group__0__Impl() throws RecognitionException { | 22697 | public final void rule__ObjectiveDefinition__Group__0__Impl() throws RecognitionException { |
24771 | 22698 | ||
24772 | int stackSize = keepStackSize(); | 22699 | int stackSize = keepStackSize(); |
24773 | 22700 | ||
24774 | try { | 22701 | try { |
24775 | // InternalSolverLanguage.g:7483:1: ( ( ( rule__ObjectiveDefinition__KindAssignment_0 ) ) ) | 22702 | // InternalSolverLanguageParser.g:7373:1: ( ( ( rule__ObjectiveDefinition__KindAssignment_0 ) ) ) |
24776 | // InternalSolverLanguage.g:7484:1: ( ( rule__ObjectiveDefinition__KindAssignment_0 ) ) | 22703 | // InternalSolverLanguageParser.g:7374:1: ( ( rule__ObjectiveDefinition__KindAssignment_0 ) ) |
24777 | { | 22704 | { |
24778 | // InternalSolverLanguage.g:7484:1: ( ( rule__ObjectiveDefinition__KindAssignment_0 ) ) | 22705 | // InternalSolverLanguageParser.g:7374:1: ( ( rule__ObjectiveDefinition__KindAssignment_0 ) ) |
24779 | // InternalSolverLanguage.g:7485:2: ( rule__ObjectiveDefinition__KindAssignment_0 ) | 22706 | // InternalSolverLanguageParser.g:7375:2: ( rule__ObjectiveDefinition__KindAssignment_0 ) |
24780 | { | 22707 | { |
24781 | if ( state.backtracking==0 ) { | 22708 | before(grammarAccess.getObjectiveDefinitionAccess().getKindAssignment_0()); |
24782 | before(grammarAccess.getObjectiveDefinitionAccess().getKindAssignment_0()); | 22709 | // InternalSolverLanguageParser.g:7376:2: ( rule__ObjectiveDefinition__KindAssignment_0 ) |
24783 | } | 22710 | // InternalSolverLanguageParser.g:7376:3: rule__ObjectiveDefinition__KindAssignment_0 |
24784 | // InternalSolverLanguage.g:7486:2: ( rule__ObjectiveDefinition__KindAssignment_0 ) | ||
24785 | // InternalSolverLanguage.g:7486:3: rule__ObjectiveDefinition__KindAssignment_0 | ||
24786 | { | 22711 | { |
24787 | pushFollow(FOLLOW_2); | 22712 | pushFollow(FOLLOW_2); |
24788 | rule__ObjectiveDefinition__KindAssignment_0(); | 22713 | rule__ObjectiveDefinition__KindAssignment_0(); |
24789 | 22714 | ||
24790 | state._fsp--; | 22715 | state._fsp--; |
24791 | if (state.failed) return ; | ||
24792 | 22716 | ||
24793 | } | ||
24794 | 22717 | ||
24795 | if ( state.backtracking==0 ) { | ||
24796 | after(grammarAccess.getObjectiveDefinitionAccess().getKindAssignment_0()); | ||
24797 | } | 22718 | } |
24798 | 22719 | ||
22720 | after(grammarAccess.getObjectiveDefinitionAccess().getKindAssignment_0()); | ||
22721 | |||
24799 | } | 22722 | } |
24800 | 22723 | ||
24801 | 22724 | ||
@@ -24817,20 +22740,20 @@ public class InternalSolverLanguageParser extends AbstractInternalContentAssistP | |||
24817 | 22740 | ||
24818 | 22741 | ||
24819 | // $ANTLR start "rule__ObjectiveDefinition__Group__1" | 22742 | // $ANTLR start "rule__ObjectiveDefinition__Group__1" |
24820 | // InternalSolverLanguage.g:7494:1: rule__ObjectiveDefinition__Group__1 : rule__ObjectiveDefinition__Group__1__Impl ; | 22743 | // InternalSolverLanguageParser.g:7384:1: rule__ObjectiveDefinition__Group__1 : rule__ObjectiveDefinition__Group__1__Impl ; |
24821 | public final void rule__ObjectiveDefinition__Group__1() throws RecognitionException { | 22744 | public final void rule__ObjectiveDefinition__Group__1() throws RecognitionException { |
24822 | 22745 | ||
24823 | int stackSize = keepStackSize(); | 22746 | int stackSize = keepStackSize(); |
24824 | 22747 | ||
24825 | try { | 22748 | try { |
24826 | // InternalSolverLanguage.g:7498:1: ( rule__ObjectiveDefinition__Group__1__Impl ) | 22749 | // InternalSolverLanguageParser.g:7388:1: ( rule__ObjectiveDefinition__Group__1__Impl ) |
24827 | // InternalSolverLanguage.g:7499:2: rule__ObjectiveDefinition__Group__1__Impl | 22750 | // InternalSolverLanguageParser.g:7389:2: rule__ObjectiveDefinition__Group__1__Impl |
24828 | { | 22751 | { |
24829 | pushFollow(FOLLOW_2); | 22752 | pushFollow(FOLLOW_2); |
24830 | rule__ObjectiveDefinition__Group__1__Impl(); | 22753 | rule__ObjectiveDefinition__Group__1__Impl(); |
24831 | 22754 | ||
24832 | state._fsp--; | 22755 | state._fsp--; |
24833 | if (state.failed) return ; | 22756 | |
24834 | 22757 | ||
24835 | } | 22758 | } |
24836 | 22759 | ||
@@ -24850,36 +22773,32 @@ public class InternalSolverLanguageParser extends AbstractInternalContentAssistP | |||
24850 | 22773 | ||
24851 | 22774 | ||
24852 | // $ANTLR start "rule__ObjectiveDefinition__Group__1__Impl" | 22775 | // $ANTLR start "rule__ObjectiveDefinition__Group__1__Impl" |
24853 | // InternalSolverLanguage.g:7505:1: rule__ObjectiveDefinition__Group__1__Impl : ( ( rule__ObjectiveDefinition__ObjectiveAssignment_1 ) ) ; | 22776 | // InternalSolverLanguageParser.g:7395:1: rule__ObjectiveDefinition__Group__1__Impl : ( ( rule__ObjectiveDefinition__ObjectiveAssignment_1 ) ) ; |
24854 | public final void rule__ObjectiveDefinition__Group__1__Impl() throws RecognitionException { | 22777 | public final void rule__ObjectiveDefinition__Group__1__Impl() throws RecognitionException { |
24855 | 22778 | ||
24856 | int stackSize = keepStackSize(); | 22779 | int stackSize = keepStackSize(); |
24857 | 22780 | ||
24858 | try { | 22781 | try { |
24859 | // InternalSolverLanguage.g:7509:1: ( ( ( rule__ObjectiveDefinition__ObjectiveAssignment_1 ) ) ) | 22782 | // InternalSolverLanguageParser.g:7399:1: ( ( ( rule__ObjectiveDefinition__ObjectiveAssignment_1 ) ) ) |
24860 | // InternalSolverLanguage.g:7510:1: ( ( rule__ObjectiveDefinition__ObjectiveAssignment_1 ) ) | 22783 | // InternalSolverLanguageParser.g:7400:1: ( ( rule__ObjectiveDefinition__ObjectiveAssignment_1 ) ) |
24861 | { | 22784 | { |
24862 | // InternalSolverLanguage.g:7510:1: ( ( rule__ObjectiveDefinition__ObjectiveAssignment_1 ) ) | 22785 | // InternalSolverLanguageParser.g:7400:1: ( ( rule__ObjectiveDefinition__ObjectiveAssignment_1 ) ) |
24863 | // InternalSolverLanguage.g:7511:2: ( rule__ObjectiveDefinition__ObjectiveAssignment_1 ) | 22786 | // InternalSolverLanguageParser.g:7401:2: ( rule__ObjectiveDefinition__ObjectiveAssignment_1 ) |
24864 | { | 22787 | { |
24865 | if ( state.backtracking==0 ) { | 22788 | before(grammarAccess.getObjectiveDefinitionAccess().getObjectiveAssignment_1()); |
24866 | before(grammarAccess.getObjectiveDefinitionAccess().getObjectiveAssignment_1()); | 22789 | // InternalSolverLanguageParser.g:7402:2: ( rule__ObjectiveDefinition__ObjectiveAssignment_1 ) |
24867 | } | 22790 | // InternalSolverLanguageParser.g:7402:3: rule__ObjectiveDefinition__ObjectiveAssignment_1 |
24868 | // InternalSolverLanguage.g:7512:2: ( rule__ObjectiveDefinition__ObjectiveAssignment_1 ) | ||
24869 | // InternalSolverLanguage.g:7512:3: rule__ObjectiveDefinition__ObjectiveAssignment_1 | ||
24870 | { | 22791 | { |
24871 | pushFollow(FOLLOW_2); | 22792 | pushFollow(FOLLOW_2); |
24872 | rule__ObjectiveDefinition__ObjectiveAssignment_1(); | 22793 | rule__ObjectiveDefinition__ObjectiveAssignment_1(); |
24873 | 22794 | ||
24874 | state._fsp--; | 22795 | state._fsp--; |
24875 | if (state.failed) return ; | ||
24876 | 22796 | ||
24877 | } | ||
24878 | 22797 | ||
24879 | if ( state.backtracking==0 ) { | ||
24880 | after(grammarAccess.getObjectiveDefinitionAccess().getObjectiveAssignment_1()); | ||
24881 | } | 22798 | } |
24882 | 22799 | ||
22800 | after(grammarAccess.getObjectiveDefinitionAccess().getObjectiveAssignment_1()); | ||
22801 | |||
24883 | } | 22802 | } |
24884 | 22803 | ||
24885 | 22804 | ||
@@ -24901,25 +22820,25 @@ public class InternalSolverLanguageParser extends AbstractInternalContentAssistP | |||
24901 | 22820 | ||
24902 | 22821 | ||
24903 | // $ANTLR start "rule__Real__Group__0" | 22822 | // $ANTLR start "rule__Real__Group__0" |
24904 | // InternalSolverLanguage.g:7521:1: rule__Real__Group__0 : rule__Real__Group__0__Impl rule__Real__Group__1 ; | 22823 | // InternalSolverLanguageParser.g:7411:1: rule__Real__Group__0 : rule__Real__Group__0__Impl rule__Real__Group__1 ; |
24905 | public final void rule__Real__Group__0() throws RecognitionException { | 22824 | public final void rule__Real__Group__0() throws RecognitionException { |
24906 | 22825 | ||
24907 | int stackSize = keepStackSize(); | 22826 | int stackSize = keepStackSize(); |
24908 | 22827 | ||
24909 | try { | 22828 | try { |
24910 | // InternalSolverLanguage.g:7525:1: ( rule__Real__Group__0__Impl rule__Real__Group__1 ) | 22829 | // InternalSolverLanguageParser.g:7415:1: ( rule__Real__Group__0__Impl rule__Real__Group__1 ) |
24911 | // InternalSolverLanguage.g:7526:2: rule__Real__Group__0__Impl rule__Real__Group__1 | 22830 | // InternalSolverLanguageParser.g:7416:2: rule__Real__Group__0__Impl rule__Real__Group__1 |
24912 | { | 22831 | { |
24913 | pushFollow(FOLLOW_13); | 22832 | pushFollow(FOLLOW_57); |
24914 | rule__Real__Group__0__Impl(); | 22833 | rule__Real__Group__0__Impl(); |
24915 | 22834 | ||
24916 | state._fsp--; | 22835 | state._fsp--; |
24917 | if (state.failed) return ; | 22836 | |
24918 | pushFollow(FOLLOW_2); | 22837 | pushFollow(FOLLOW_2); |
24919 | rule__Real__Group__1(); | 22838 | rule__Real__Group__1(); |
24920 | 22839 | ||
24921 | state._fsp--; | 22840 | state._fsp--; |
24922 | if (state.failed) return ; | 22841 | |
24923 | 22842 | ||
24924 | } | 22843 | } |
24925 | 22844 | ||
@@ -24939,25 +22858,21 @@ public class InternalSolverLanguageParser extends AbstractInternalContentAssistP | |||
24939 | 22858 | ||
24940 | 22859 | ||
24941 | // $ANTLR start "rule__Real__Group__0__Impl" | 22860 | // $ANTLR start "rule__Real__Group__0__Impl" |
24942 | // InternalSolverLanguage.g:7533:1: rule__Real__Group__0__Impl : ( RULE_INT ) ; | 22861 | // InternalSolverLanguageParser.g:7423:1: rule__Real__Group__0__Impl : ( RULE_INT ) ; |
24943 | public final void rule__Real__Group__0__Impl() throws RecognitionException { | 22862 | public final void rule__Real__Group__0__Impl() throws RecognitionException { |
24944 | 22863 | ||
24945 | int stackSize = keepStackSize(); | 22864 | int stackSize = keepStackSize(); |
24946 | 22865 | ||
24947 | try { | 22866 | try { |
24948 | // InternalSolverLanguage.g:7537:1: ( ( RULE_INT ) ) | 22867 | // InternalSolverLanguageParser.g:7427:1: ( ( RULE_INT ) ) |
24949 | // InternalSolverLanguage.g:7538:1: ( RULE_INT ) | 22868 | // InternalSolverLanguageParser.g:7428:1: ( RULE_INT ) |
24950 | { | 22869 | { |
24951 | // InternalSolverLanguage.g:7538:1: ( RULE_INT ) | 22870 | // InternalSolverLanguageParser.g:7428:1: ( RULE_INT ) |
24952 | // InternalSolverLanguage.g:7539:2: RULE_INT | 22871 | // InternalSolverLanguageParser.g:7429:2: RULE_INT |
24953 | { | 22872 | { |
24954 | if ( state.backtracking==0 ) { | 22873 | before(grammarAccess.getRealAccess().getINTTerminalRuleCall_0()); |
24955 | before(grammarAccess.getRealAccess().getINTTerminalRuleCall_0()); | 22874 | match(input,RULE_INT,FOLLOW_2); |
24956 | } | 22875 | after(grammarAccess.getRealAccess().getINTTerminalRuleCall_0()); |
24957 | match(input,RULE_INT,FOLLOW_2); if (state.failed) return ; | ||
24958 | if ( state.backtracking==0 ) { | ||
24959 | after(grammarAccess.getRealAccess().getINTTerminalRuleCall_0()); | ||
24960 | } | ||
24961 | 22876 | ||
24962 | } | 22877 | } |
24963 | 22878 | ||
@@ -24980,20 +22895,20 @@ public class InternalSolverLanguageParser extends AbstractInternalContentAssistP | |||
24980 | 22895 | ||
24981 | 22896 | ||
24982 | // $ANTLR start "rule__Real__Group__1" | 22897 | // $ANTLR start "rule__Real__Group__1" |
24983 | // InternalSolverLanguage.g:7548:1: rule__Real__Group__1 : rule__Real__Group__1__Impl ; | 22898 | // InternalSolverLanguageParser.g:7438:1: rule__Real__Group__1 : rule__Real__Group__1__Impl ; |
24984 | public final void rule__Real__Group__1() throws RecognitionException { | 22899 | public final void rule__Real__Group__1() throws RecognitionException { |
24985 | 22900 | ||
24986 | int stackSize = keepStackSize(); | 22901 | int stackSize = keepStackSize(); |
24987 | 22902 | ||
24988 | try { | 22903 | try { |
24989 | // InternalSolverLanguage.g:7552:1: ( rule__Real__Group__1__Impl ) | 22904 | // InternalSolverLanguageParser.g:7442:1: ( rule__Real__Group__1__Impl ) |
24990 | // InternalSolverLanguage.g:7553:2: rule__Real__Group__1__Impl | 22905 | // InternalSolverLanguageParser.g:7443:2: rule__Real__Group__1__Impl |
24991 | { | 22906 | { |
24992 | pushFollow(FOLLOW_2); | 22907 | pushFollow(FOLLOW_2); |
24993 | rule__Real__Group__1__Impl(); | 22908 | rule__Real__Group__1__Impl(); |
24994 | 22909 | ||
24995 | state._fsp--; | 22910 | state._fsp--; |
24996 | if (state.failed) return ; | 22911 | |
24997 | 22912 | ||
24998 | } | 22913 | } |
24999 | 22914 | ||
@@ -25013,46 +22928,42 @@ public class InternalSolverLanguageParser extends AbstractInternalContentAssistP | |||
25013 | 22928 | ||
25014 | 22929 | ||
25015 | // $ANTLR start "rule__Real__Group__1__Impl" | 22930 | // $ANTLR start "rule__Real__Group__1__Impl" |
25016 | // InternalSolverLanguage.g:7559:1: rule__Real__Group__1__Impl : ( ( rule__Real__Group_1__0 )? ) ; | 22931 | // InternalSolverLanguageParser.g:7449:1: rule__Real__Group__1__Impl : ( ( rule__Real__Group_1__0 )? ) ; |
25017 | public final void rule__Real__Group__1__Impl() throws RecognitionException { | 22932 | public final void rule__Real__Group__1__Impl() throws RecognitionException { |
25018 | 22933 | ||
25019 | int stackSize = keepStackSize(); | 22934 | int stackSize = keepStackSize(); |
25020 | 22935 | ||
25021 | try { | 22936 | try { |
25022 | // InternalSolverLanguage.g:7563:1: ( ( ( rule__Real__Group_1__0 )? ) ) | 22937 | // InternalSolverLanguageParser.g:7453:1: ( ( ( rule__Real__Group_1__0 )? ) ) |
25023 | // InternalSolverLanguage.g:7564:1: ( ( rule__Real__Group_1__0 )? ) | 22938 | // InternalSolverLanguageParser.g:7454:1: ( ( rule__Real__Group_1__0 )? ) |
25024 | { | 22939 | { |
25025 | // InternalSolverLanguage.g:7564:1: ( ( rule__Real__Group_1__0 )? ) | 22940 | // InternalSolverLanguageParser.g:7454:1: ( ( rule__Real__Group_1__0 )? ) |
25026 | // InternalSolverLanguage.g:7565:2: ( rule__Real__Group_1__0 )? | 22941 | // InternalSolverLanguageParser.g:7455:2: ( rule__Real__Group_1__0 )? |
25027 | { | 22942 | { |
25028 | if ( state.backtracking==0 ) { | 22943 | before(grammarAccess.getRealAccess().getGroup_1()); |
25029 | before(grammarAccess.getRealAccess().getGroup_1()); | 22944 | // InternalSolverLanguageParser.g:7456:2: ( rule__Real__Group_1__0 )? |
25030 | } | 22945 | int alt52=2; |
25031 | // InternalSolverLanguage.g:7566:2: ( rule__Real__Group_1__0 )? | 22946 | int LA52_0 = input.LA(1); |
25032 | int alt53=2; | ||
25033 | int LA53_0 = input.LA(1); | ||
25034 | 22947 | ||
25035 | if ( (LA53_0==50) ) { | 22948 | if ( (LA52_0==FullStop) ) { |
25036 | alt53=1; | 22949 | alt52=1; |
25037 | } | 22950 | } |
25038 | switch (alt53) { | 22951 | switch (alt52) { |
25039 | case 1 : | 22952 | case 1 : |
25040 | // InternalSolverLanguage.g:7566:3: rule__Real__Group_1__0 | 22953 | // InternalSolverLanguageParser.g:7456:3: rule__Real__Group_1__0 |
25041 | { | 22954 | { |
25042 | pushFollow(FOLLOW_2); | 22955 | pushFollow(FOLLOW_2); |
25043 | rule__Real__Group_1__0(); | 22956 | rule__Real__Group_1__0(); |
25044 | 22957 | ||
25045 | state._fsp--; | 22958 | state._fsp--; |
25046 | if (state.failed) return ; | 22959 | |
25047 | 22960 | ||
25048 | } | 22961 | } |
25049 | break; | 22962 | break; |
25050 | 22963 | ||
25051 | } | 22964 | } |
25052 | 22965 | ||
25053 | if ( state.backtracking==0 ) { | 22966 | after(grammarAccess.getRealAccess().getGroup_1()); |
25054 | after(grammarAccess.getRealAccess().getGroup_1()); | ||
25055 | } | ||
25056 | 22967 | ||
25057 | } | 22968 | } |
25058 | 22969 | ||
@@ -25075,25 +22986,25 @@ public class InternalSolverLanguageParser extends AbstractInternalContentAssistP | |||
25075 | 22986 | ||
25076 | 22987 | ||
25077 | // $ANTLR start "rule__Real__Group_1__0" | 22988 | // $ANTLR start "rule__Real__Group_1__0" |
25078 | // InternalSolverLanguage.g:7575:1: rule__Real__Group_1__0 : rule__Real__Group_1__0__Impl rule__Real__Group_1__1 ; | 22989 | // InternalSolverLanguageParser.g:7465:1: rule__Real__Group_1__0 : rule__Real__Group_1__0__Impl rule__Real__Group_1__1 ; |
25079 | public final void rule__Real__Group_1__0() throws RecognitionException { | 22990 | public final void rule__Real__Group_1__0() throws RecognitionException { |
25080 | 22991 | ||
25081 | int stackSize = keepStackSize(); | 22992 | int stackSize = keepStackSize(); |
25082 | 22993 | ||
25083 | try { | 22994 | try { |
25084 | // InternalSolverLanguage.g:7579:1: ( rule__Real__Group_1__0__Impl rule__Real__Group_1__1 ) | 22995 | // InternalSolverLanguageParser.g:7469:1: ( rule__Real__Group_1__0__Impl rule__Real__Group_1__1 ) |
25085 | // InternalSolverLanguage.g:7580:2: rule__Real__Group_1__0__Impl rule__Real__Group_1__1 | 22996 | // InternalSolverLanguageParser.g:7470:2: rule__Real__Group_1__0__Impl rule__Real__Group_1__1 |
25086 | { | 22997 | { |
25087 | pushFollow(FOLLOW_53); | 22998 | pushFollow(FOLLOW_52); |
25088 | rule__Real__Group_1__0__Impl(); | 22999 | rule__Real__Group_1__0__Impl(); |
25089 | 23000 | ||
25090 | state._fsp--; | 23001 | state._fsp--; |
25091 | if (state.failed) return ; | 23002 | |
25092 | pushFollow(FOLLOW_2); | 23003 | pushFollow(FOLLOW_2); |
25093 | rule__Real__Group_1__1(); | 23004 | rule__Real__Group_1__1(); |
25094 | 23005 | ||
25095 | state._fsp--; | 23006 | state._fsp--; |
25096 | if (state.failed) return ; | 23007 | |
25097 | 23008 | ||
25098 | } | 23009 | } |
25099 | 23010 | ||
@@ -25113,25 +23024,21 @@ public class InternalSolverLanguageParser extends AbstractInternalContentAssistP | |||
25113 | 23024 | ||
25114 | 23025 | ||
25115 | // $ANTLR start "rule__Real__Group_1__0__Impl" | 23026 | // $ANTLR start "rule__Real__Group_1__0__Impl" |
25116 | // InternalSolverLanguage.g:7587:1: rule__Real__Group_1__0__Impl : ( '.' ) ; | 23027 | // InternalSolverLanguageParser.g:7477:1: rule__Real__Group_1__0__Impl : ( FullStop ) ; |
25117 | public final void rule__Real__Group_1__0__Impl() throws RecognitionException { | 23028 | public final void rule__Real__Group_1__0__Impl() throws RecognitionException { |
25118 | 23029 | ||
25119 | int stackSize = keepStackSize(); | 23030 | int stackSize = keepStackSize(); |
25120 | 23031 | ||
25121 | try { | 23032 | try { |
25122 | // InternalSolverLanguage.g:7591:1: ( ( '.' ) ) | 23033 | // InternalSolverLanguageParser.g:7481:1: ( ( FullStop ) ) |
25123 | // InternalSolverLanguage.g:7592:1: ( '.' ) | 23034 | // InternalSolverLanguageParser.g:7482:1: ( FullStop ) |
25124 | { | 23035 | { |
25125 | // InternalSolverLanguage.g:7592:1: ( '.' ) | 23036 | // InternalSolverLanguageParser.g:7482:1: ( FullStop ) |
25126 | // InternalSolverLanguage.g:7593:2: '.' | 23037 | // InternalSolverLanguageParser.g:7483:2: FullStop |
25127 | { | 23038 | { |
25128 | if ( state.backtracking==0 ) { | 23039 | before(grammarAccess.getRealAccess().getFullStopKeyword_1_0()); |
25129 | before(grammarAccess.getRealAccess().getFullStopKeyword_1_0()); | 23040 | match(input,FullStop,FOLLOW_2); |
25130 | } | 23041 | after(grammarAccess.getRealAccess().getFullStopKeyword_1_0()); |
25131 | match(input,50,FOLLOW_2); if (state.failed) return ; | ||
25132 | if ( state.backtracking==0 ) { | ||
25133 | after(grammarAccess.getRealAccess().getFullStopKeyword_1_0()); | ||
25134 | } | ||
25135 | 23042 | ||
25136 | } | 23043 | } |
25137 | 23044 | ||
@@ -25154,20 +23061,20 @@ public class InternalSolverLanguageParser extends AbstractInternalContentAssistP | |||
25154 | 23061 | ||
25155 | 23062 | ||
25156 | // $ANTLR start "rule__Real__Group_1__1" | 23063 | // $ANTLR start "rule__Real__Group_1__1" |
25157 | // InternalSolverLanguage.g:7602:1: rule__Real__Group_1__1 : rule__Real__Group_1__1__Impl ; | 23064 | // InternalSolverLanguageParser.g:7492:1: rule__Real__Group_1__1 : rule__Real__Group_1__1__Impl ; |
25158 | public final void rule__Real__Group_1__1() throws RecognitionException { | 23065 | public final void rule__Real__Group_1__1() throws RecognitionException { |
25159 | 23066 | ||
25160 | int stackSize = keepStackSize(); | 23067 | int stackSize = keepStackSize(); |
25161 | 23068 | ||
25162 | try { | 23069 | try { |
25163 | // InternalSolverLanguage.g:7606:1: ( rule__Real__Group_1__1__Impl ) | 23070 | // InternalSolverLanguageParser.g:7496:1: ( rule__Real__Group_1__1__Impl ) |
25164 | // InternalSolverLanguage.g:7607:2: rule__Real__Group_1__1__Impl | 23071 | // InternalSolverLanguageParser.g:7497:2: rule__Real__Group_1__1__Impl |
25165 | { | 23072 | { |
25166 | pushFollow(FOLLOW_2); | 23073 | pushFollow(FOLLOW_2); |
25167 | rule__Real__Group_1__1__Impl(); | 23074 | rule__Real__Group_1__1__Impl(); |
25168 | 23075 | ||
25169 | state._fsp--; | 23076 | state._fsp--; |
25170 | if (state.failed) return ; | 23077 | |
25171 | 23078 | ||
25172 | } | 23079 | } |
25173 | 23080 | ||
@@ -25187,25 +23094,21 @@ public class InternalSolverLanguageParser extends AbstractInternalContentAssistP | |||
25187 | 23094 | ||
25188 | 23095 | ||
25189 | // $ANTLR start "rule__Real__Group_1__1__Impl" | 23096 | // $ANTLR start "rule__Real__Group_1__1__Impl" |
25190 | // InternalSolverLanguage.g:7613:1: rule__Real__Group_1__1__Impl : ( RULE_INT ) ; | 23097 | // InternalSolverLanguageParser.g:7503:1: rule__Real__Group_1__1__Impl : ( RULE_INT ) ; |
25191 | public final void rule__Real__Group_1__1__Impl() throws RecognitionException { | 23098 | public final void rule__Real__Group_1__1__Impl() throws RecognitionException { |
25192 | 23099 | ||
25193 | int stackSize = keepStackSize(); | 23100 | int stackSize = keepStackSize(); |
25194 | 23101 | ||
25195 | try { | 23102 | try { |
25196 | // InternalSolverLanguage.g:7617:1: ( ( RULE_INT ) ) | 23103 | // InternalSolverLanguageParser.g:7507:1: ( ( RULE_INT ) ) |
25197 | // InternalSolverLanguage.g:7618:1: ( RULE_INT ) | 23104 | // InternalSolverLanguageParser.g:7508:1: ( RULE_INT ) |
25198 | { | 23105 | { |
25199 | // InternalSolverLanguage.g:7618:1: ( RULE_INT ) | 23106 | // InternalSolverLanguageParser.g:7508:1: ( RULE_INT ) |
25200 | // InternalSolverLanguage.g:7619:2: RULE_INT | 23107 | // InternalSolverLanguageParser.g:7509:2: RULE_INT |
25201 | { | 23108 | { |
25202 | if ( state.backtracking==0 ) { | 23109 | before(grammarAccess.getRealAccess().getINTTerminalRuleCall_1_1()); |
25203 | before(grammarAccess.getRealAccess().getINTTerminalRuleCall_1_1()); | 23110 | match(input,RULE_INT,FOLLOW_2); |
25204 | } | 23111 | after(grammarAccess.getRealAccess().getINTTerminalRuleCall_1_1()); |
25205 | match(input,RULE_INT,FOLLOW_2); if (state.failed) return ; | ||
25206 | if ( state.backtracking==0 ) { | ||
25207 | after(grammarAccess.getRealAccess().getINTTerminalRuleCall_1_1()); | ||
25208 | } | ||
25209 | 23112 | ||
25210 | } | 23113 | } |
25211 | 23114 | ||
@@ -25228,25 +23131,25 @@ public class InternalSolverLanguageParser extends AbstractInternalContentAssistP | |||
25228 | 23131 | ||
25229 | 23132 | ||
25230 | // $ANTLR start "rule__QualifiedName__Group_0__0" | 23133 | // $ANTLR start "rule__QualifiedName__Group_0__0" |
25231 | // InternalSolverLanguage.g:7629:1: rule__QualifiedName__Group_0__0 : rule__QualifiedName__Group_0__0__Impl rule__QualifiedName__Group_0__1 ; | 23134 | // InternalSolverLanguageParser.g:7519:1: rule__QualifiedName__Group_0__0 : rule__QualifiedName__Group_0__0__Impl rule__QualifiedName__Group_0__1 ; |
25232 | public final void rule__QualifiedName__Group_0__0() throws RecognitionException { | 23135 | public final void rule__QualifiedName__Group_0__0() throws RecognitionException { |
25233 | 23136 | ||
25234 | int stackSize = keepStackSize(); | 23137 | int stackSize = keepStackSize(); |
25235 | 23138 | ||
25236 | try { | 23139 | try { |
25237 | // InternalSolverLanguage.g:7633:1: ( rule__QualifiedName__Group_0__0__Impl rule__QualifiedName__Group_0__1 ) | 23140 | // InternalSolverLanguageParser.g:7523:1: ( rule__QualifiedName__Group_0__0__Impl rule__QualifiedName__Group_0__1 ) |
25238 | // InternalSolverLanguage.g:7634:2: rule__QualifiedName__Group_0__0__Impl rule__QualifiedName__Group_0__1 | 23141 | // InternalSolverLanguageParser.g:7524:2: rule__QualifiedName__Group_0__0__Impl rule__QualifiedName__Group_0__1 |
25239 | { | 23142 | { |
25240 | pushFollow(FOLLOW_13); | 23143 | pushFollow(FOLLOW_57); |
25241 | rule__QualifiedName__Group_0__0__Impl(); | 23144 | rule__QualifiedName__Group_0__0__Impl(); |
25242 | 23145 | ||
25243 | state._fsp--; | 23146 | state._fsp--; |
25244 | if (state.failed) return ; | 23147 | |
25245 | pushFollow(FOLLOW_2); | 23148 | pushFollow(FOLLOW_2); |
25246 | rule__QualifiedName__Group_0__1(); | 23149 | rule__QualifiedName__Group_0__1(); |
25247 | 23150 | ||
25248 | state._fsp--; | 23151 | state._fsp--; |
25249 | if (state.failed) return ; | 23152 | |
25250 | 23153 | ||
25251 | } | 23154 | } |
25252 | 23155 | ||
@@ -25266,25 +23169,21 @@ public class InternalSolverLanguageParser extends AbstractInternalContentAssistP | |||
25266 | 23169 | ||
25267 | 23170 | ||
25268 | // $ANTLR start "rule__QualifiedName__Group_0__0__Impl" | 23171 | // $ANTLR start "rule__QualifiedName__Group_0__0__Impl" |
25269 | // InternalSolverLanguage.g:7641:1: rule__QualifiedName__Group_0__0__Impl : ( RULE_ID ) ; | 23172 | // InternalSolverLanguageParser.g:7531:1: rule__QualifiedName__Group_0__0__Impl : ( RULE_ID ) ; |
25270 | public final void rule__QualifiedName__Group_0__0__Impl() throws RecognitionException { | 23173 | public final void rule__QualifiedName__Group_0__0__Impl() throws RecognitionException { |
25271 | 23174 | ||
25272 | int stackSize = keepStackSize(); | 23175 | int stackSize = keepStackSize(); |
25273 | 23176 | ||
25274 | try { | 23177 | try { |
25275 | // InternalSolverLanguage.g:7645:1: ( ( RULE_ID ) ) | 23178 | // InternalSolverLanguageParser.g:7535:1: ( ( RULE_ID ) ) |
25276 | // InternalSolverLanguage.g:7646:1: ( RULE_ID ) | 23179 | // InternalSolverLanguageParser.g:7536:1: ( RULE_ID ) |
25277 | { | 23180 | { |
25278 | // InternalSolverLanguage.g:7646:1: ( RULE_ID ) | 23181 | // InternalSolverLanguageParser.g:7536:1: ( RULE_ID ) |
25279 | // InternalSolverLanguage.g:7647:2: RULE_ID | 23182 | // InternalSolverLanguageParser.g:7537:2: RULE_ID |
25280 | { | 23183 | { |
25281 | if ( state.backtracking==0 ) { | 23184 | before(grammarAccess.getQualifiedNameAccess().getIDTerminalRuleCall_0_0()); |
25282 | before(grammarAccess.getQualifiedNameAccess().getIDTerminalRuleCall_0_0()); | 23185 | match(input,RULE_ID,FOLLOW_2); |
25283 | } | 23186 | after(grammarAccess.getQualifiedNameAccess().getIDTerminalRuleCall_0_0()); |
25284 | match(input,RULE_ID,FOLLOW_2); if (state.failed) return ; | ||
25285 | if ( state.backtracking==0 ) { | ||
25286 | after(grammarAccess.getQualifiedNameAccess().getIDTerminalRuleCall_0_0()); | ||
25287 | } | ||
25288 | 23187 | ||
25289 | } | 23188 | } |
25290 | 23189 | ||
@@ -25307,20 +23206,20 @@ public class InternalSolverLanguageParser extends AbstractInternalContentAssistP | |||
25307 | 23206 | ||
25308 | 23207 | ||
25309 | // $ANTLR start "rule__QualifiedName__Group_0__1" | 23208 | // $ANTLR start "rule__QualifiedName__Group_0__1" |
25310 | // InternalSolverLanguage.g:7656:1: rule__QualifiedName__Group_0__1 : rule__QualifiedName__Group_0__1__Impl ; | 23209 | // InternalSolverLanguageParser.g:7546:1: rule__QualifiedName__Group_0__1 : rule__QualifiedName__Group_0__1__Impl ; |
25311 | public final void rule__QualifiedName__Group_0__1() throws RecognitionException { | 23210 | public final void rule__QualifiedName__Group_0__1() throws RecognitionException { |
25312 | 23211 | ||
25313 | int stackSize = keepStackSize(); | 23212 | int stackSize = keepStackSize(); |
25314 | 23213 | ||
25315 | try { | 23214 | try { |
25316 | // InternalSolverLanguage.g:7660:1: ( rule__QualifiedName__Group_0__1__Impl ) | 23215 | // InternalSolverLanguageParser.g:7550:1: ( rule__QualifiedName__Group_0__1__Impl ) |
25317 | // InternalSolverLanguage.g:7661:2: rule__QualifiedName__Group_0__1__Impl | 23216 | // InternalSolverLanguageParser.g:7551:2: rule__QualifiedName__Group_0__1__Impl |
25318 | { | 23217 | { |
25319 | pushFollow(FOLLOW_2); | 23218 | pushFollow(FOLLOW_2); |
25320 | rule__QualifiedName__Group_0__1__Impl(); | 23219 | rule__QualifiedName__Group_0__1__Impl(); |
25321 | 23220 | ||
25322 | state._fsp--; | 23221 | state._fsp--; |
25323 | if (state.failed) return ; | 23222 | |
25324 | 23223 | ||
25325 | } | 23224 | } |
25326 | 23225 | ||
@@ -25340,59 +23239,49 @@ public class InternalSolverLanguageParser extends AbstractInternalContentAssistP | |||
25340 | 23239 | ||
25341 | 23240 | ||
25342 | // $ANTLR start "rule__QualifiedName__Group_0__1__Impl" | 23241 | // $ANTLR start "rule__QualifiedName__Group_0__1__Impl" |
25343 | // InternalSolverLanguage.g:7667:1: rule__QualifiedName__Group_0__1__Impl : ( ( rule__QualifiedName__Group_0_1__0 )* ) ; | 23242 | // InternalSolverLanguageParser.g:7557:1: rule__QualifiedName__Group_0__1__Impl : ( ( rule__QualifiedName__Group_0_1__0 )* ) ; |
25344 | public final void rule__QualifiedName__Group_0__1__Impl() throws RecognitionException { | 23243 | public final void rule__QualifiedName__Group_0__1__Impl() throws RecognitionException { |
25345 | 23244 | ||
25346 | int stackSize = keepStackSize(); | 23245 | int stackSize = keepStackSize(); |
25347 | 23246 | ||
25348 | try { | 23247 | try { |
25349 | // InternalSolverLanguage.g:7671:1: ( ( ( rule__QualifiedName__Group_0_1__0 )* ) ) | 23248 | // InternalSolverLanguageParser.g:7561:1: ( ( ( rule__QualifiedName__Group_0_1__0 )* ) ) |
25350 | // InternalSolverLanguage.g:7672:1: ( ( rule__QualifiedName__Group_0_1__0 )* ) | 23249 | // InternalSolverLanguageParser.g:7562:1: ( ( rule__QualifiedName__Group_0_1__0 )* ) |
25351 | { | 23250 | { |
25352 | // InternalSolverLanguage.g:7672:1: ( ( rule__QualifiedName__Group_0_1__0 )* ) | 23251 | // InternalSolverLanguageParser.g:7562:1: ( ( rule__QualifiedName__Group_0_1__0 )* ) |
25353 | // InternalSolverLanguage.g:7673:2: ( rule__QualifiedName__Group_0_1__0 )* | 23252 | // InternalSolverLanguageParser.g:7563:2: ( rule__QualifiedName__Group_0_1__0 )* |
25354 | { | 23253 | { |
25355 | if ( state.backtracking==0 ) { | 23254 | before(grammarAccess.getQualifiedNameAccess().getGroup_0_1()); |
25356 | before(grammarAccess.getQualifiedNameAccess().getGroup_0_1()); | 23255 | // InternalSolverLanguageParser.g:7564:2: ( rule__QualifiedName__Group_0_1__0 )* |
25357 | } | 23256 | loop53: |
25358 | // InternalSolverLanguage.g:7674:2: ( rule__QualifiedName__Group_0_1__0 )* | ||
25359 | loop54: | ||
25360 | do { | 23257 | do { |
25361 | int alt54=2; | 23258 | int alt53=2; |
25362 | int LA54_0 = input.LA(1); | 23259 | int LA53_0 = input.LA(1); |
25363 | |||
25364 | if ( (LA54_0==50) ) { | ||
25365 | int LA54_2 = input.LA(2); | ||
25366 | |||
25367 | if ( (LA54_2==RULE_ID) ) { | ||
25368 | alt54=1; | ||
25369 | } | ||
25370 | |||
25371 | 23260 | ||
23261 | if ( (LA53_0==FullStop) ) { | ||
23262 | alt53=1; | ||
25372 | } | 23263 | } |
25373 | 23264 | ||
25374 | 23265 | ||
25375 | switch (alt54) { | 23266 | switch (alt53) { |
25376 | case 1 : | 23267 | case 1 : |
25377 | // InternalSolverLanguage.g:7674:3: rule__QualifiedName__Group_0_1__0 | 23268 | // InternalSolverLanguageParser.g:7564:3: rule__QualifiedName__Group_0_1__0 |
25378 | { | 23269 | { |
25379 | pushFollow(FOLLOW_58); | 23270 | pushFollow(FOLLOW_58); |
25380 | rule__QualifiedName__Group_0_1__0(); | 23271 | rule__QualifiedName__Group_0_1__0(); |
25381 | 23272 | ||
25382 | state._fsp--; | 23273 | state._fsp--; |
25383 | if (state.failed) return ; | 23274 | |
25384 | 23275 | ||
25385 | } | 23276 | } |
25386 | break; | 23277 | break; |
25387 | 23278 | ||
25388 | default : | 23279 | default : |
25389 | break loop54; | 23280 | break loop53; |
25390 | } | 23281 | } |
25391 | } while (true); | 23282 | } while (true); |
25392 | 23283 | ||
25393 | if ( state.backtracking==0 ) { | 23284 | after(grammarAccess.getQualifiedNameAccess().getGroup_0_1()); |
25394 | after(grammarAccess.getQualifiedNameAccess().getGroup_0_1()); | ||
25395 | } | ||
25396 | 23285 | ||
25397 | } | 23286 | } |
25398 | 23287 | ||
@@ -25415,25 +23304,25 @@ public class InternalSolverLanguageParser extends AbstractInternalContentAssistP | |||
25415 | 23304 | ||
25416 | 23305 | ||
25417 | // $ANTLR start "rule__QualifiedName__Group_0_1__0" | 23306 | // $ANTLR start "rule__QualifiedName__Group_0_1__0" |
25418 | // InternalSolverLanguage.g:7683:1: rule__QualifiedName__Group_0_1__0 : rule__QualifiedName__Group_0_1__0__Impl rule__QualifiedName__Group_0_1__1 ; | 23307 | // InternalSolverLanguageParser.g:7573:1: rule__QualifiedName__Group_0_1__0 : rule__QualifiedName__Group_0_1__0__Impl rule__QualifiedName__Group_0_1__1 ; |
25419 | public final void rule__QualifiedName__Group_0_1__0() throws RecognitionException { | 23308 | public final void rule__QualifiedName__Group_0_1__0() throws RecognitionException { |
25420 | 23309 | ||
25421 | int stackSize = keepStackSize(); | 23310 | int stackSize = keepStackSize(); |
25422 | 23311 | ||
25423 | try { | 23312 | try { |
25424 | // InternalSolverLanguage.g:7687:1: ( rule__QualifiedName__Group_0_1__0__Impl rule__QualifiedName__Group_0_1__1 ) | 23313 | // InternalSolverLanguageParser.g:7577:1: ( rule__QualifiedName__Group_0_1__0__Impl rule__QualifiedName__Group_0_1__1 ) |
25425 | // InternalSolverLanguage.g:7688:2: rule__QualifiedName__Group_0_1__0__Impl rule__QualifiedName__Group_0_1__1 | 23314 | // InternalSolverLanguageParser.g:7578:2: rule__QualifiedName__Group_0_1__0__Impl rule__QualifiedName__Group_0_1__1 |
25426 | { | 23315 | { |
25427 | pushFollow(FOLLOW_44); | 23316 | pushFollow(FOLLOW_43); |
25428 | rule__QualifiedName__Group_0_1__0__Impl(); | 23317 | rule__QualifiedName__Group_0_1__0__Impl(); |
25429 | 23318 | ||
25430 | state._fsp--; | 23319 | state._fsp--; |
25431 | if (state.failed) return ; | 23320 | |
25432 | pushFollow(FOLLOW_2); | 23321 | pushFollow(FOLLOW_2); |
25433 | rule__QualifiedName__Group_0_1__1(); | 23322 | rule__QualifiedName__Group_0_1__1(); |
25434 | 23323 | ||
25435 | state._fsp--; | 23324 | state._fsp--; |
25436 | if (state.failed) return ; | 23325 | |
25437 | 23326 | ||
25438 | } | 23327 | } |
25439 | 23328 | ||
@@ -25453,25 +23342,21 @@ public class InternalSolverLanguageParser extends AbstractInternalContentAssistP | |||
25453 | 23342 | ||
25454 | 23343 | ||
25455 | // $ANTLR start "rule__QualifiedName__Group_0_1__0__Impl" | 23344 | // $ANTLR start "rule__QualifiedName__Group_0_1__0__Impl" |
25456 | // InternalSolverLanguage.g:7695:1: rule__QualifiedName__Group_0_1__0__Impl : ( '.' ) ; | 23345 | // InternalSolverLanguageParser.g:7585:1: rule__QualifiedName__Group_0_1__0__Impl : ( FullStop ) ; |
25457 | public final void rule__QualifiedName__Group_0_1__0__Impl() throws RecognitionException { | 23346 | public final void rule__QualifiedName__Group_0_1__0__Impl() throws RecognitionException { |
25458 | 23347 | ||
25459 | int stackSize = keepStackSize(); | 23348 | int stackSize = keepStackSize(); |
25460 | 23349 | ||
25461 | try { | 23350 | try { |
25462 | // InternalSolverLanguage.g:7699:1: ( ( '.' ) ) | 23351 | // InternalSolverLanguageParser.g:7589:1: ( ( FullStop ) ) |
25463 | // InternalSolverLanguage.g:7700:1: ( '.' ) | 23352 | // InternalSolverLanguageParser.g:7590:1: ( FullStop ) |
25464 | { | 23353 | { |
25465 | // InternalSolverLanguage.g:7700:1: ( '.' ) | 23354 | // InternalSolverLanguageParser.g:7590:1: ( FullStop ) |
25466 | // InternalSolverLanguage.g:7701:2: '.' | 23355 | // InternalSolverLanguageParser.g:7591:2: FullStop |
25467 | { | 23356 | { |
25468 | if ( state.backtracking==0 ) { | 23357 | before(grammarAccess.getQualifiedNameAccess().getFullStopKeyword_0_1_0()); |
25469 | before(grammarAccess.getQualifiedNameAccess().getFullStopKeyword_0_1_0()); | 23358 | match(input,FullStop,FOLLOW_2); |
25470 | } | 23359 | after(grammarAccess.getQualifiedNameAccess().getFullStopKeyword_0_1_0()); |
25471 | match(input,50,FOLLOW_2); if (state.failed) return ; | ||
25472 | if ( state.backtracking==0 ) { | ||
25473 | after(grammarAccess.getQualifiedNameAccess().getFullStopKeyword_0_1_0()); | ||
25474 | } | ||
25475 | 23360 | ||
25476 | } | 23361 | } |
25477 | 23362 | ||
@@ -25494,20 +23379,20 @@ public class InternalSolverLanguageParser extends AbstractInternalContentAssistP | |||
25494 | 23379 | ||
25495 | 23380 | ||
25496 | // $ANTLR start "rule__QualifiedName__Group_0_1__1" | 23381 | // $ANTLR start "rule__QualifiedName__Group_0_1__1" |
25497 | // InternalSolverLanguage.g:7710:1: rule__QualifiedName__Group_0_1__1 : rule__QualifiedName__Group_0_1__1__Impl ; | 23382 | // InternalSolverLanguageParser.g:7600:1: rule__QualifiedName__Group_0_1__1 : rule__QualifiedName__Group_0_1__1__Impl ; |
25498 | public final void rule__QualifiedName__Group_0_1__1() throws RecognitionException { | 23383 | public final void rule__QualifiedName__Group_0_1__1() throws RecognitionException { |
25499 | 23384 | ||
25500 | int stackSize = keepStackSize(); | 23385 | int stackSize = keepStackSize(); |
25501 | 23386 | ||
25502 | try { | 23387 | try { |
25503 | // InternalSolverLanguage.g:7714:1: ( rule__QualifiedName__Group_0_1__1__Impl ) | 23388 | // InternalSolverLanguageParser.g:7604:1: ( rule__QualifiedName__Group_0_1__1__Impl ) |
25504 | // InternalSolverLanguage.g:7715:2: rule__QualifiedName__Group_0_1__1__Impl | 23389 | // InternalSolverLanguageParser.g:7605:2: rule__QualifiedName__Group_0_1__1__Impl |
25505 | { | 23390 | { |
25506 | pushFollow(FOLLOW_2); | 23391 | pushFollow(FOLLOW_2); |
25507 | rule__QualifiedName__Group_0_1__1__Impl(); | 23392 | rule__QualifiedName__Group_0_1__1__Impl(); |
25508 | 23393 | ||
25509 | state._fsp--; | 23394 | state._fsp--; |
25510 | if (state.failed) return ; | 23395 | |
25511 | 23396 | ||
25512 | } | 23397 | } |
25513 | 23398 | ||
@@ -25527,25 +23412,21 @@ public class InternalSolverLanguageParser extends AbstractInternalContentAssistP | |||
25527 | 23412 | ||
25528 | 23413 | ||
25529 | // $ANTLR start "rule__QualifiedName__Group_0_1__1__Impl" | 23414 | // $ANTLR start "rule__QualifiedName__Group_0_1__1__Impl" |
25530 | // InternalSolverLanguage.g:7721:1: rule__QualifiedName__Group_0_1__1__Impl : ( RULE_ID ) ; | 23415 | // InternalSolverLanguageParser.g:7611:1: rule__QualifiedName__Group_0_1__1__Impl : ( RULE_ID ) ; |
25531 | public final void rule__QualifiedName__Group_0_1__1__Impl() throws RecognitionException { | 23416 | public final void rule__QualifiedName__Group_0_1__1__Impl() throws RecognitionException { |
25532 | 23417 | ||
25533 | int stackSize = keepStackSize(); | 23418 | int stackSize = keepStackSize(); |
25534 | 23419 | ||
25535 | try { | 23420 | try { |
25536 | // InternalSolverLanguage.g:7725:1: ( ( RULE_ID ) ) | 23421 | // InternalSolverLanguageParser.g:7615:1: ( ( RULE_ID ) ) |
25537 | // InternalSolverLanguage.g:7726:1: ( RULE_ID ) | 23422 | // InternalSolverLanguageParser.g:7616:1: ( RULE_ID ) |
25538 | { | 23423 | { |
25539 | // InternalSolverLanguage.g:7726:1: ( RULE_ID ) | 23424 | // InternalSolverLanguageParser.g:7616:1: ( RULE_ID ) |
25540 | // InternalSolverLanguage.g:7727:2: RULE_ID | 23425 | // InternalSolverLanguageParser.g:7617:2: RULE_ID |
25541 | { | 23426 | { |
25542 | if ( state.backtracking==0 ) { | 23427 | before(grammarAccess.getQualifiedNameAccess().getIDTerminalRuleCall_0_1_1()); |
25543 | before(grammarAccess.getQualifiedNameAccess().getIDTerminalRuleCall_0_1_1()); | 23428 | match(input,RULE_ID,FOLLOW_2); |
25544 | } | 23429 | after(grammarAccess.getQualifiedNameAccess().getIDTerminalRuleCall_0_1_1()); |
25545 | match(input,RULE_ID,FOLLOW_2); if (state.failed) return ; | ||
25546 | if ( state.backtracking==0 ) { | ||
25547 | after(grammarAccess.getQualifiedNameAccess().getIDTerminalRuleCall_0_1_1()); | ||
25548 | } | ||
25549 | 23430 | ||
25550 | } | 23431 | } |
25551 | 23432 | ||
@@ -25568,29 +23449,25 @@ public class InternalSolverLanguageParser extends AbstractInternalContentAssistP | |||
25568 | 23449 | ||
25569 | 23450 | ||
25570 | // $ANTLR start "rule__Problem__StatementsAssignment" | 23451 | // $ANTLR start "rule__Problem__StatementsAssignment" |
25571 | // InternalSolverLanguage.g:7737:1: rule__Problem__StatementsAssignment : ( ruleStatement ) ; | 23452 | // InternalSolverLanguageParser.g:7627:1: rule__Problem__StatementsAssignment : ( ruleStatement ) ; |
25572 | public final void rule__Problem__StatementsAssignment() throws RecognitionException { | 23453 | public final void rule__Problem__StatementsAssignment() throws RecognitionException { |
25573 | 23454 | ||
25574 | int stackSize = keepStackSize(); | 23455 | int stackSize = keepStackSize(); |
25575 | 23456 | ||
25576 | try { | 23457 | try { |
25577 | // InternalSolverLanguage.g:7741:1: ( ( ruleStatement ) ) | 23458 | // InternalSolverLanguageParser.g:7631:1: ( ( ruleStatement ) ) |
25578 | // InternalSolverLanguage.g:7742:2: ( ruleStatement ) | 23459 | // InternalSolverLanguageParser.g:7632:2: ( ruleStatement ) |
25579 | { | 23460 | { |
25580 | // InternalSolverLanguage.g:7742:2: ( ruleStatement ) | 23461 | // InternalSolverLanguageParser.g:7632:2: ( ruleStatement ) |
25581 | // InternalSolverLanguage.g:7743:3: ruleStatement | 23462 | // InternalSolverLanguageParser.g:7633:3: ruleStatement |
25582 | { | 23463 | { |
25583 | if ( state.backtracking==0 ) { | 23464 | before(grammarAccess.getProblemAccess().getStatementsStatementParserRuleCall_0()); |
25584 | before(grammarAccess.getProblemAccess().getStatementsStatementParserRuleCall_0()); | ||
25585 | } | ||
25586 | pushFollow(FOLLOW_2); | 23465 | pushFollow(FOLLOW_2); |
25587 | ruleStatement(); | 23466 | ruleStatement(); |
25588 | 23467 | ||
25589 | state._fsp--; | 23468 | state._fsp--; |
25590 | if (state.failed) return ; | 23469 | |
25591 | if ( state.backtracking==0 ) { | 23470 | after(grammarAccess.getProblemAccess().getStatementsStatementParserRuleCall_0()); |
25592 | after(grammarAccess.getProblemAccess().getStatementsStatementParserRuleCall_0()); | ||
25593 | } | ||
25594 | 23471 | ||
25595 | } | 23472 | } |
25596 | 23473 | ||
@@ -25613,29 +23490,25 @@ public class InternalSolverLanguageParser extends AbstractInternalContentAssistP | |||
25613 | 23490 | ||
25614 | 23491 | ||
25615 | // $ANTLR start "rule__AssertionOrDefinition__RangeAssignment_1_0_1_1" | 23492 | // $ANTLR start "rule__AssertionOrDefinition__RangeAssignment_1_0_1_1" |
25616 | // InternalSolverLanguage.g:7752:1: rule__AssertionOrDefinition__RangeAssignment_1_0_1_1 : ( ruleExpression ) ; | 23493 | // InternalSolverLanguageParser.g:7642:1: rule__AssertionOrDefinition__RangeAssignment_1_0_1_1 : ( ruleExpression ) ; |
25617 | public final void rule__AssertionOrDefinition__RangeAssignment_1_0_1_1() throws RecognitionException { | 23494 | public final void rule__AssertionOrDefinition__RangeAssignment_1_0_1_1() throws RecognitionException { |
25618 | 23495 | ||
25619 | int stackSize = keepStackSize(); | 23496 | int stackSize = keepStackSize(); |
25620 | 23497 | ||
25621 | try { | 23498 | try { |
25622 | // InternalSolverLanguage.g:7756:1: ( ( ruleExpression ) ) | 23499 | // InternalSolverLanguageParser.g:7646:1: ( ( ruleExpression ) ) |
25623 | // InternalSolverLanguage.g:7757:2: ( ruleExpression ) | 23500 | // InternalSolverLanguageParser.g:7647:2: ( ruleExpression ) |
25624 | { | 23501 | { |
25625 | // InternalSolverLanguage.g:7757:2: ( ruleExpression ) | 23502 | // InternalSolverLanguageParser.g:7647:2: ( ruleExpression ) |
25626 | // InternalSolverLanguage.g:7758:3: ruleExpression | 23503 | // InternalSolverLanguageParser.g:7648:3: ruleExpression |
25627 | { | 23504 | { |
25628 | if ( state.backtracking==0 ) { | 23505 | before(grammarAccess.getAssertionOrDefinitionAccess().getRangeExpressionParserRuleCall_1_0_1_1_0()); |
25629 | before(grammarAccess.getAssertionOrDefinitionAccess().getRangeExpressionParserRuleCall_1_0_1_1_0()); | ||
25630 | } | ||
25631 | pushFollow(FOLLOW_2); | 23506 | pushFollow(FOLLOW_2); |
25632 | ruleExpression(); | 23507 | ruleExpression(); |
25633 | 23508 | ||
25634 | state._fsp--; | 23509 | state._fsp--; |
25635 | if (state.failed) return ; | 23510 | |
25636 | if ( state.backtracking==0 ) { | 23511 | after(grammarAccess.getAssertionOrDefinitionAccess().getRangeExpressionParserRuleCall_1_0_1_1_0()); |
25637 | after(grammarAccess.getAssertionOrDefinitionAccess().getRangeExpressionParserRuleCall_1_0_1_1_0()); | ||
25638 | } | ||
25639 | 23512 | ||
25640 | } | 23513 | } |
25641 | 23514 | ||
@@ -25658,29 +23531,25 @@ public class InternalSolverLanguageParser extends AbstractInternalContentAssistP | |||
25658 | 23531 | ||
25659 | 23532 | ||
25660 | // $ANTLR start "rule__AssertionOrDefinition__BodyAssignment_1_1_2" | 23533 | // $ANTLR start "rule__AssertionOrDefinition__BodyAssignment_1_1_2" |
25661 | // InternalSolverLanguage.g:7767:1: rule__AssertionOrDefinition__BodyAssignment_1_1_2 : ( ruleExpression ) ; | 23534 | // InternalSolverLanguageParser.g:7657:1: rule__AssertionOrDefinition__BodyAssignment_1_1_2 : ( ruleExpression ) ; |
25662 | public final void rule__AssertionOrDefinition__BodyAssignment_1_1_2() throws RecognitionException { | 23535 | public final void rule__AssertionOrDefinition__BodyAssignment_1_1_2() throws RecognitionException { |
25663 | 23536 | ||
25664 | int stackSize = keepStackSize(); | 23537 | int stackSize = keepStackSize(); |
25665 | 23538 | ||
25666 | try { | 23539 | try { |
25667 | // InternalSolverLanguage.g:7771:1: ( ( ruleExpression ) ) | 23540 | // InternalSolverLanguageParser.g:7661:1: ( ( ruleExpression ) ) |
25668 | // InternalSolverLanguage.g:7772:2: ( ruleExpression ) | 23541 | // InternalSolverLanguageParser.g:7662:2: ( ruleExpression ) |
25669 | { | 23542 | { |
25670 | // InternalSolverLanguage.g:7772:2: ( ruleExpression ) | 23543 | // InternalSolverLanguageParser.g:7662:2: ( ruleExpression ) |
25671 | // InternalSolverLanguage.g:7773:3: ruleExpression | 23544 | // InternalSolverLanguageParser.g:7663:3: ruleExpression |
25672 | { | 23545 | { |
25673 | if ( state.backtracking==0 ) { | 23546 | before(grammarAccess.getAssertionOrDefinitionAccess().getBodyExpressionParserRuleCall_1_1_2_0()); |
25674 | before(grammarAccess.getAssertionOrDefinitionAccess().getBodyExpressionParserRuleCall_1_1_2_0()); | ||
25675 | } | ||
25676 | pushFollow(FOLLOW_2); | 23547 | pushFollow(FOLLOW_2); |
25677 | ruleExpression(); | 23548 | ruleExpression(); |
25678 | 23549 | ||
25679 | state._fsp--; | 23550 | state._fsp--; |
25680 | if (state.failed) return ; | 23551 | |
25681 | if ( state.backtracking==0 ) { | 23552 | after(grammarAccess.getAssertionOrDefinitionAccess().getBodyExpressionParserRuleCall_1_1_2_0()); |
25682 | after(grammarAccess.getAssertionOrDefinitionAccess().getBodyExpressionParserRuleCall_1_1_2_0()); | ||
25683 | } | ||
25684 | 23553 | ||
25685 | } | 23554 | } |
25686 | 23555 | ||
@@ -25703,29 +23572,25 @@ public class InternalSolverLanguageParser extends AbstractInternalContentAssistP | |||
25703 | 23572 | ||
25704 | 23573 | ||
25705 | // $ANTLR start "rule__AssertionOrDefinition__BodyAssignment_1_2_2" | 23574 | // $ANTLR start "rule__AssertionOrDefinition__BodyAssignment_1_2_2" |
25706 | // InternalSolverLanguage.g:7782:1: rule__AssertionOrDefinition__BodyAssignment_1_2_2 : ( ruleExpression ) ; | 23575 | // InternalSolverLanguageParser.g:7672:1: rule__AssertionOrDefinition__BodyAssignment_1_2_2 : ( ruleExpression ) ; |
25707 | public final void rule__AssertionOrDefinition__BodyAssignment_1_2_2() throws RecognitionException { | 23576 | public final void rule__AssertionOrDefinition__BodyAssignment_1_2_2() throws RecognitionException { |
25708 | 23577 | ||
25709 | int stackSize = keepStackSize(); | 23578 | int stackSize = keepStackSize(); |
25710 | 23579 | ||
25711 | try { | 23580 | try { |
25712 | // InternalSolverLanguage.g:7786:1: ( ( ruleExpression ) ) | 23581 | // InternalSolverLanguageParser.g:7676:1: ( ( ruleExpression ) ) |
25713 | // InternalSolverLanguage.g:7787:2: ( ruleExpression ) | 23582 | // InternalSolverLanguageParser.g:7677:2: ( ruleExpression ) |
25714 | { | 23583 | { |
25715 | // InternalSolverLanguage.g:7787:2: ( ruleExpression ) | 23584 | // InternalSolverLanguageParser.g:7677:2: ( ruleExpression ) |
25716 | // InternalSolverLanguage.g:7788:3: ruleExpression | 23585 | // InternalSolverLanguageParser.g:7678:3: ruleExpression |
25717 | { | 23586 | { |
25718 | if ( state.backtracking==0 ) { | 23587 | before(grammarAccess.getAssertionOrDefinitionAccess().getBodyExpressionParserRuleCall_1_2_2_0()); |
25719 | before(grammarAccess.getAssertionOrDefinitionAccess().getBodyExpressionParserRuleCall_1_2_2_0()); | ||
25720 | } | ||
25721 | pushFollow(FOLLOW_2); | 23588 | pushFollow(FOLLOW_2); |
25722 | ruleExpression(); | 23589 | ruleExpression(); |
25723 | 23590 | ||
25724 | state._fsp--; | 23591 | state._fsp--; |
25725 | if (state.failed) return ; | 23592 | |
25726 | if ( state.backtracking==0 ) { | 23593 | after(grammarAccess.getAssertionOrDefinitionAccess().getBodyExpressionParserRuleCall_1_2_2_0()); |
25727 | after(grammarAccess.getAssertionOrDefinitionAccess().getBodyExpressionParserRuleCall_1_2_2_0()); | ||
25728 | } | ||
25729 | 23594 | ||
25730 | } | 23595 | } |
25731 | 23596 | ||
@@ -25748,37 +23613,29 @@ public class InternalSolverLanguageParser extends AbstractInternalContentAssistP | |||
25748 | 23613 | ||
25749 | 23614 | ||
25750 | // $ANTLR start "rule__PredicateDefinition__FunctionalAssignment_0_0_0" | 23615 | // $ANTLR start "rule__PredicateDefinition__FunctionalAssignment_0_0_0" |
25751 | // InternalSolverLanguage.g:7797:1: rule__PredicateDefinition__FunctionalAssignment_0_0_0 : ( ( 'functional' ) ) ; | 23616 | // InternalSolverLanguageParser.g:7687:1: rule__PredicateDefinition__FunctionalAssignment_0_0_0 : ( ( Functional ) ) ; |
25752 | public final void rule__PredicateDefinition__FunctionalAssignment_0_0_0() throws RecognitionException { | 23617 | public final void rule__PredicateDefinition__FunctionalAssignment_0_0_0() throws RecognitionException { |
25753 | 23618 | ||
25754 | int stackSize = keepStackSize(); | 23619 | int stackSize = keepStackSize(); |
25755 | 23620 | ||
25756 | try { | 23621 | try { |
25757 | // InternalSolverLanguage.g:7801:1: ( ( ( 'functional' ) ) ) | 23622 | // InternalSolverLanguageParser.g:7691:1: ( ( ( Functional ) ) ) |
25758 | // InternalSolverLanguage.g:7802:2: ( ( 'functional' ) ) | 23623 | // InternalSolverLanguageParser.g:7692:2: ( ( Functional ) ) |
25759 | { | 23624 | { |
25760 | // InternalSolverLanguage.g:7802:2: ( ( 'functional' ) ) | 23625 | // InternalSolverLanguageParser.g:7692:2: ( ( Functional ) ) |
25761 | // InternalSolverLanguage.g:7803:3: ( 'functional' ) | 23626 | // InternalSolverLanguageParser.g:7693:3: ( Functional ) |
25762 | { | 23627 | { |
25763 | if ( state.backtracking==0 ) { | 23628 | before(grammarAccess.getPredicateDefinitionAccess().getFunctionalFunctionalKeyword_0_0_0_0()); |
25764 | before(grammarAccess.getPredicateDefinitionAccess().getFunctionalFunctionalKeyword_0_0_0_0()); | 23629 | // InternalSolverLanguageParser.g:7694:3: ( Functional ) |
25765 | } | 23630 | // InternalSolverLanguageParser.g:7695:4: Functional |
25766 | // InternalSolverLanguage.g:7804:3: ( 'functional' ) | ||
25767 | // InternalSolverLanguage.g:7805:4: 'functional' | ||
25768 | { | 23631 | { |
25769 | if ( state.backtracking==0 ) { | 23632 | before(grammarAccess.getPredicateDefinitionAccess().getFunctionalFunctionalKeyword_0_0_0_0()); |
25770 | before(grammarAccess.getPredicateDefinitionAccess().getFunctionalFunctionalKeyword_0_0_0_0()); | 23633 | match(input,Functional,FOLLOW_2); |
25771 | } | 23634 | after(grammarAccess.getPredicateDefinitionAccess().getFunctionalFunctionalKeyword_0_0_0_0()); |
25772 | match(input,72,FOLLOW_2); if (state.failed) return ; | ||
25773 | if ( state.backtracking==0 ) { | ||
25774 | after(grammarAccess.getPredicateDefinitionAccess().getFunctionalFunctionalKeyword_0_0_0_0()); | ||
25775 | } | ||
25776 | 23635 | ||
25777 | } | 23636 | } |
25778 | 23637 | ||
25779 | if ( state.backtracking==0 ) { | 23638 | after(grammarAccess.getPredicateDefinitionAccess().getFunctionalFunctionalKeyword_0_0_0_0()); |
25780 | after(grammarAccess.getPredicateDefinitionAccess().getFunctionalFunctionalKeyword_0_0_0_0()); | ||
25781 | } | ||
25782 | 23639 | ||
25783 | } | 23640 | } |
25784 | 23641 | ||
@@ -25801,37 +23658,29 @@ public class InternalSolverLanguageParser extends AbstractInternalContentAssistP | |||
25801 | 23658 | ||
25802 | 23659 | ||
25803 | // $ANTLR start "rule__PredicateDefinition__ErrorAssignment_0_0_1" | 23660 | // $ANTLR start "rule__PredicateDefinition__ErrorAssignment_0_0_1" |
25804 | // InternalSolverLanguage.g:7816:1: rule__PredicateDefinition__ErrorAssignment_0_0_1 : ( ( 'error' ) ) ; | 23661 | // InternalSolverLanguageParser.g:7706:1: rule__PredicateDefinition__ErrorAssignment_0_0_1 : ( ( Error ) ) ; |
25805 | public final void rule__PredicateDefinition__ErrorAssignment_0_0_1() throws RecognitionException { | 23662 | public final void rule__PredicateDefinition__ErrorAssignment_0_0_1() throws RecognitionException { |
25806 | 23663 | ||
25807 | int stackSize = keepStackSize(); | 23664 | int stackSize = keepStackSize(); |
25808 | 23665 | ||
25809 | try { | 23666 | try { |
25810 | // InternalSolverLanguage.g:7820:1: ( ( ( 'error' ) ) ) | 23667 | // InternalSolverLanguageParser.g:7710:1: ( ( ( Error ) ) ) |
25811 | // InternalSolverLanguage.g:7821:2: ( ( 'error' ) ) | 23668 | // InternalSolverLanguageParser.g:7711:2: ( ( Error ) ) |
25812 | { | 23669 | { |
25813 | // InternalSolverLanguage.g:7821:2: ( ( 'error' ) ) | 23670 | // InternalSolverLanguageParser.g:7711:2: ( ( Error ) ) |
25814 | // InternalSolverLanguage.g:7822:3: ( 'error' ) | 23671 | // InternalSolverLanguageParser.g:7712:3: ( Error ) |
25815 | { | 23672 | { |
25816 | if ( state.backtracking==0 ) { | 23673 | before(grammarAccess.getPredicateDefinitionAccess().getErrorErrorKeyword_0_0_1_0()); |
25817 | before(grammarAccess.getPredicateDefinitionAccess().getErrorErrorKeyword_0_0_1_0()); | 23674 | // InternalSolverLanguageParser.g:7713:3: ( Error ) |
25818 | } | 23675 | // InternalSolverLanguageParser.g:7714:4: Error |
25819 | // InternalSolverLanguage.g:7823:3: ( 'error' ) | ||
25820 | // InternalSolverLanguage.g:7824:4: 'error' | ||
25821 | { | 23676 | { |
25822 | if ( state.backtracking==0 ) { | 23677 | before(grammarAccess.getPredicateDefinitionAccess().getErrorErrorKeyword_0_0_1_0()); |
25823 | before(grammarAccess.getPredicateDefinitionAccess().getErrorErrorKeyword_0_0_1_0()); | 23678 | match(input,Error,FOLLOW_2); |
25824 | } | 23679 | after(grammarAccess.getPredicateDefinitionAccess().getErrorErrorKeyword_0_0_1_0()); |
25825 | match(input,42,FOLLOW_2); if (state.failed) return ; | ||
25826 | if ( state.backtracking==0 ) { | ||
25827 | after(grammarAccess.getPredicateDefinitionAccess().getErrorErrorKeyword_0_0_1_0()); | ||
25828 | } | ||
25829 | 23680 | ||
25830 | } | 23681 | } |
25831 | 23682 | ||
25832 | if ( state.backtracking==0 ) { | 23683 | after(grammarAccess.getPredicateDefinitionAccess().getErrorErrorKeyword_0_0_1_0()); |
25833 | after(grammarAccess.getPredicateDefinitionAccess().getErrorErrorKeyword_0_0_1_0()); | ||
25834 | } | ||
25835 | 23684 | ||
25836 | } | 23685 | } |
25837 | 23686 | ||
@@ -25854,37 +23703,29 @@ public class InternalSolverLanguageParser extends AbstractInternalContentAssistP | |||
25854 | 23703 | ||
25855 | 23704 | ||
25856 | // $ANTLR start "rule__PredicateDefinition__ErrorAssignment_0_1_0" | 23705 | // $ANTLR start "rule__PredicateDefinition__ErrorAssignment_0_1_0" |
25857 | // InternalSolverLanguage.g:7835:1: rule__PredicateDefinition__ErrorAssignment_0_1_0 : ( ( 'error' ) ) ; | 23706 | // InternalSolverLanguageParser.g:7725:1: rule__PredicateDefinition__ErrorAssignment_0_1_0 : ( ( Error ) ) ; |
25858 | public final void rule__PredicateDefinition__ErrorAssignment_0_1_0() throws RecognitionException { | 23707 | public final void rule__PredicateDefinition__ErrorAssignment_0_1_0() throws RecognitionException { |
25859 | 23708 | ||
25860 | int stackSize = keepStackSize(); | 23709 | int stackSize = keepStackSize(); |
25861 | 23710 | ||
25862 | try { | 23711 | try { |
25863 | // InternalSolverLanguage.g:7839:1: ( ( ( 'error' ) ) ) | 23712 | // InternalSolverLanguageParser.g:7729:1: ( ( ( Error ) ) ) |
25864 | // InternalSolverLanguage.g:7840:2: ( ( 'error' ) ) | 23713 | // InternalSolverLanguageParser.g:7730:2: ( ( Error ) ) |
25865 | { | 23714 | { |
25866 | // InternalSolverLanguage.g:7840:2: ( ( 'error' ) ) | 23715 | // InternalSolverLanguageParser.g:7730:2: ( ( Error ) ) |
25867 | // InternalSolverLanguage.g:7841:3: ( 'error' ) | 23716 | // InternalSolverLanguageParser.g:7731:3: ( Error ) |
25868 | { | 23717 | { |
25869 | if ( state.backtracking==0 ) { | 23718 | before(grammarAccess.getPredicateDefinitionAccess().getErrorErrorKeyword_0_1_0_0()); |
25870 | before(grammarAccess.getPredicateDefinitionAccess().getErrorErrorKeyword_0_1_0_0()); | 23719 | // InternalSolverLanguageParser.g:7732:3: ( Error ) |
25871 | } | 23720 | // InternalSolverLanguageParser.g:7733:4: Error |
25872 | // InternalSolverLanguage.g:7842:3: ( 'error' ) | ||
25873 | // InternalSolverLanguage.g:7843:4: 'error' | ||
25874 | { | 23721 | { |
25875 | if ( state.backtracking==0 ) { | 23722 | before(grammarAccess.getPredicateDefinitionAccess().getErrorErrorKeyword_0_1_0_0()); |
25876 | before(grammarAccess.getPredicateDefinitionAccess().getErrorErrorKeyword_0_1_0_0()); | 23723 | match(input,Error,FOLLOW_2); |
25877 | } | 23724 | after(grammarAccess.getPredicateDefinitionAccess().getErrorErrorKeyword_0_1_0_0()); |
25878 | match(input,42,FOLLOW_2); if (state.failed) return ; | ||
25879 | if ( state.backtracking==0 ) { | ||
25880 | after(grammarAccess.getPredicateDefinitionAccess().getErrorErrorKeyword_0_1_0_0()); | ||
25881 | } | ||
25882 | 23725 | ||
25883 | } | 23726 | } |
25884 | 23727 | ||
25885 | if ( state.backtracking==0 ) { | 23728 | after(grammarAccess.getPredicateDefinitionAccess().getErrorErrorKeyword_0_1_0_0()); |
25886 | after(grammarAccess.getPredicateDefinitionAccess().getErrorErrorKeyword_0_1_0_0()); | ||
25887 | } | ||
25888 | 23729 | ||
25889 | } | 23730 | } |
25890 | 23731 | ||
@@ -25907,37 +23748,29 @@ public class InternalSolverLanguageParser extends AbstractInternalContentAssistP | |||
25907 | 23748 | ||
25908 | 23749 | ||
25909 | // $ANTLR start "rule__PredicateDefinition__FunctionalAssignment_0_1_1" | 23750 | // $ANTLR start "rule__PredicateDefinition__FunctionalAssignment_0_1_1" |
25910 | // InternalSolverLanguage.g:7854:1: rule__PredicateDefinition__FunctionalAssignment_0_1_1 : ( ( 'functional' ) ) ; | 23751 | // InternalSolverLanguageParser.g:7744:1: rule__PredicateDefinition__FunctionalAssignment_0_1_1 : ( ( Functional ) ) ; |
25911 | public final void rule__PredicateDefinition__FunctionalAssignment_0_1_1() throws RecognitionException { | 23752 | public final void rule__PredicateDefinition__FunctionalAssignment_0_1_1() throws RecognitionException { |
25912 | 23753 | ||
25913 | int stackSize = keepStackSize(); | 23754 | int stackSize = keepStackSize(); |
25914 | 23755 | ||
25915 | try { | 23756 | try { |
25916 | // InternalSolverLanguage.g:7858:1: ( ( ( 'functional' ) ) ) | 23757 | // InternalSolverLanguageParser.g:7748:1: ( ( ( Functional ) ) ) |
25917 | // InternalSolverLanguage.g:7859:2: ( ( 'functional' ) ) | 23758 | // InternalSolverLanguageParser.g:7749:2: ( ( Functional ) ) |
25918 | { | 23759 | { |
25919 | // InternalSolverLanguage.g:7859:2: ( ( 'functional' ) ) | 23760 | // InternalSolverLanguageParser.g:7749:2: ( ( Functional ) ) |
25920 | // InternalSolverLanguage.g:7860:3: ( 'functional' ) | 23761 | // InternalSolverLanguageParser.g:7750:3: ( Functional ) |
25921 | { | 23762 | { |
25922 | if ( state.backtracking==0 ) { | 23763 | before(grammarAccess.getPredicateDefinitionAccess().getFunctionalFunctionalKeyword_0_1_1_0()); |
25923 | before(grammarAccess.getPredicateDefinitionAccess().getFunctionalFunctionalKeyword_0_1_1_0()); | 23764 | // InternalSolverLanguageParser.g:7751:3: ( Functional ) |
25924 | } | 23765 | // InternalSolverLanguageParser.g:7752:4: Functional |
25925 | // InternalSolverLanguage.g:7861:3: ( 'functional' ) | ||
25926 | // InternalSolverLanguage.g:7862:4: 'functional' | ||
25927 | { | 23766 | { |
25928 | if ( state.backtracking==0 ) { | 23767 | before(grammarAccess.getPredicateDefinitionAccess().getFunctionalFunctionalKeyword_0_1_1_0()); |
25929 | before(grammarAccess.getPredicateDefinitionAccess().getFunctionalFunctionalKeyword_0_1_1_0()); | 23768 | match(input,Functional,FOLLOW_2); |
25930 | } | 23769 | after(grammarAccess.getPredicateDefinitionAccess().getFunctionalFunctionalKeyword_0_1_1_0()); |
25931 | match(input,72,FOLLOW_2); if (state.failed) return ; | ||
25932 | if ( state.backtracking==0 ) { | ||
25933 | after(grammarAccess.getPredicateDefinitionAccess().getFunctionalFunctionalKeyword_0_1_1_0()); | ||
25934 | } | ||
25935 | 23770 | ||
25936 | } | 23771 | } |
25937 | 23772 | ||
25938 | if ( state.backtracking==0 ) { | 23773 | after(grammarAccess.getPredicateDefinitionAccess().getFunctionalFunctionalKeyword_0_1_1_0()); |
25939 | after(grammarAccess.getPredicateDefinitionAccess().getFunctionalFunctionalKeyword_0_1_1_0()); | ||
25940 | } | ||
25941 | 23774 | ||
25942 | } | 23775 | } |
25943 | 23776 | ||
@@ -25960,29 +23793,25 @@ public class InternalSolverLanguageParser extends AbstractInternalContentAssistP | |||
25960 | 23793 | ||
25961 | 23794 | ||
25962 | // $ANTLR start "rule__PredicateDefinition__HeadAssignment_1" | 23795 | // $ANTLR start "rule__PredicateDefinition__HeadAssignment_1" |
25963 | // InternalSolverLanguage.g:7873:1: rule__PredicateDefinition__HeadAssignment_1 : ( ruleCall ) ; | 23796 | // InternalSolverLanguageParser.g:7763:1: rule__PredicateDefinition__HeadAssignment_1 : ( ruleCall ) ; |
25964 | public final void rule__PredicateDefinition__HeadAssignment_1() throws RecognitionException { | 23797 | public final void rule__PredicateDefinition__HeadAssignment_1() throws RecognitionException { |
25965 | 23798 | ||
25966 | int stackSize = keepStackSize(); | 23799 | int stackSize = keepStackSize(); |
25967 | 23800 | ||
25968 | try { | 23801 | try { |
25969 | // InternalSolverLanguage.g:7877:1: ( ( ruleCall ) ) | 23802 | // InternalSolverLanguageParser.g:7767:1: ( ( ruleCall ) ) |
25970 | // InternalSolverLanguage.g:7878:2: ( ruleCall ) | 23803 | // InternalSolverLanguageParser.g:7768:2: ( ruleCall ) |
25971 | { | 23804 | { |
25972 | // InternalSolverLanguage.g:7878:2: ( ruleCall ) | 23805 | // InternalSolverLanguageParser.g:7768:2: ( ruleCall ) |
25973 | // InternalSolverLanguage.g:7879:3: ruleCall | 23806 | // InternalSolverLanguageParser.g:7769:3: ruleCall |
25974 | { | 23807 | { |
25975 | if ( state.backtracking==0 ) { | 23808 | before(grammarAccess.getPredicateDefinitionAccess().getHeadCallParserRuleCall_1_0()); |
25976 | before(grammarAccess.getPredicateDefinitionAccess().getHeadCallParserRuleCall_1_0()); | ||
25977 | } | ||
25978 | pushFollow(FOLLOW_2); | 23809 | pushFollow(FOLLOW_2); |
25979 | ruleCall(); | 23810 | ruleCall(); |
25980 | 23811 | ||
25981 | state._fsp--; | 23812 | state._fsp--; |
25982 | if (state.failed) return ; | 23813 | |
25983 | if ( state.backtracking==0 ) { | 23814 | after(grammarAccess.getPredicateDefinitionAccess().getHeadCallParserRuleCall_1_0()); |
25984 | after(grammarAccess.getPredicateDefinitionAccess().getHeadCallParserRuleCall_1_0()); | ||
25985 | } | ||
25986 | 23815 | ||
25987 | } | 23816 | } |
25988 | 23817 | ||
@@ -26005,29 +23834,25 @@ public class InternalSolverLanguageParser extends AbstractInternalContentAssistP | |||
26005 | 23834 | ||
26006 | 23835 | ||
26007 | // $ANTLR start "rule__PredicateDefinition__BodyAssignment_3" | 23836 | // $ANTLR start "rule__PredicateDefinition__BodyAssignment_3" |
26008 | // InternalSolverLanguage.g:7888:1: rule__PredicateDefinition__BodyAssignment_3 : ( ruleExpression ) ; | 23837 | // InternalSolverLanguageParser.g:7778:1: rule__PredicateDefinition__BodyAssignment_3 : ( ruleExpression ) ; |
26009 | public final void rule__PredicateDefinition__BodyAssignment_3() throws RecognitionException { | 23838 | public final void rule__PredicateDefinition__BodyAssignment_3() throws RecognitionException { |
26010 | 23839 | ||
26011 | int stackSize = keepStackSize(); | 23840 | int stackSize = keepStackSize(); |
26012 | 23841 | ||
26013 | try { | 23842 | try { |
26014 | // InternalSolverLanguage.g:7892:1: ( ( ruleExpression ) ) | 23843 | // InternalSolverLanguageParser.g:7782:1: ( ( ruleExpression ) ) |
26015 | // InternalSolverLanguage.g:7893:2: ( ruleExpression ) | 23844 | // InternalSolverLanguageParser.g:7783:2: ( ruleExpression ) |
26016 | { | 23845 | { |
26017 | // InternalSolverLanguage.g:7893:2: ( ruleExpression ) | 23846 | // InternalSolverLanguageParser.g:7783:2: ( ruleExpression ) |
26018 | // InternalSolverLanguage.g:7894:3: ruleExpression | 23847 | // InternalSolverLanguageParser.g:7784:3: ruleExpression |
26019 | { | 23848 | { |
26020 | if ( state.backtracking==0 ) { | 23849 | before(grammarAccess.getPredicateDefinitionAccess().getBodyExpressionParserRuleCall_3_0()); |
26021 | before(grammarAccess.getPredicateDefinitionAccess().getBodyExpressionParserRuleCall_3_0()); | ||
26022 | } | ||
26023 | pushFollow(FOLLOW_2); | 23850 | pushFollow(FOLLOW_2); |
26024 | ruleExpression(); | 23851 | ruleExpression(); |
26025 | 23852 | ||
26026 | state._fsp--; | 23853 | state._fsp--; |
26027 | if (state.failed) return ; | 23854 | |
26028 | if ( state.backtracking==0 ) { | 23855 | after(grammarAccess.getPredicateDefinitionAccess().getBodyExpressionParserRuleCall_3_0()); |
26029 | after(grammarAccess.getPredicateDefinitionAccess().getBodyExpressionParserRuleCall_3_0()); | ||
26030 | } | ||
26031 | 23856 | ||
26032 | } | 23857 | } |
26033 | 23858 | ||
@@ -26050,29 +23875,25 @@ public class InternalSolverLanguageParser extends AbstractInternalContentAssistP | |||
26050 | 23875 | ||
26051 | 23876 | ||
26052 | // $ANTLR start "rule__UnnamedErrorPrediateDefinition__ArgumentListAssignment_1" | 23877 | // $ANTLR start "rule__UnnamedErrorPrediateDefinition__ArgumentListAssignment_1" |
26053 | // InternalSolverLanguage.g:7903:1: rule__UnnamedErrorPrediateDefinition__ArgumentListAssignment_1 : ( ruleArgumentList ) ; | 23878 | // InternalSolverLanguageParser.g:7793:1: rule__UnnamedErrorPrediateDefinition__ArgumentListAssignment_1 : ( ruleArgumentList ) ; |
26054 | public final void rule__UnnamedErrorPrediateDefinition__ArgumentListAssignment_1() throws RecognitionException { | 23879 | public final void rule__UnnamedErrorPrediateDefinition__ArgumentListAssignment_1() throws RecognitionException { |
26055 | 23880 | ||
26056 | int stackSize = keepStackSize(); | 23881 | int stackSize = keepStackSize(); |
26057 | 23882 | ||
26058 | try { | 23883 | try { |
26059 | // InternalSolverLanguage.g:7907:1: ( ( ruleArgumentList ) ) | 23884 | // InternalSolverLanguageParser.g:7797:1: ( ( ruleArgumentList ) ) |
26060 | // InternalSolverLanguage.g:7908:2: ( ruleArgumentList ) | 23885 | // InternalSolverLanguageParser.g:7798:2: ( ruleArgumentList ) |
26061 | { | 23886 | { |
26062 | // InternalSolverLanguage.g:7908:2: ( ruleArgumentList ) | 23887 | // InternalSolverLanguageParser.g:7798:2: ( ruleArgumentList ) |
26063 | // InternalSolverLanguage.g:7909:3: ruleArgumentList | 23888 | // InternalSolverLanguageParser.g:7799:3: ruleArgumentList |
26064 | { | 23889 | { |
26065 | if ( state.backtracking==0 ) { | 23890 | before(grammarAccess.getUnnamedErrorPrediateDefinitionAccess().getArgumentListArgumentListParserRuleCall_1_0()); |
26066 | before(grammarAccess.getUnnamedErrorPrediateDefinitionAccess().getArgumentListArgumentListParserRuleCall_1_0()); | ||
26067 | } | ||
26068 | pushFollow(FOLLOW_2); | 23891 | pushFollow(FOLLOW_2); |
26069 | ruleArgumentList(); | 23892 | ruleArgumentList(); |
26070 | 23893 | ||
26071 | state._fsp--; | 23894 | state._fsp--; |
26072 | if (state.failed) return ; | 23895 | |
26073 | if ( state.backtracking==0 ) { | 23896 | after(grammarAccess.getUnnamedErrorPrediateDefinitionAccess().getArgumentListArgumentListParserRuleCall_1_0()); |
26074 | after(grammarAccess.getUnnamedErrorPrediateDefinitionAccess().getArgumentListArgumentListParserRuleCall_1_0()); | ||
26075 | } | ||
26076 | 23897 | ||
26077 | } | 23898 | } |
26078 | 23899 | ||
@@ -26095,29 +23916,25 @@ public class InternalSolverLanguageParser extends AbstractInternalContentAssistP | |||
26095 | 23916 | ||
26096 | 23917 | ||
26097 | // $ANTLR start "rule__UnnamedErrorPrediateDefinition__BodyAssignment_3" | 23918 | // $ANTLR start "rule__UnnamedErrorPrediateDefinition__BodyAssignment_3" |
26098 | // InternalSolverLanguage.g:7918:1: rule__UnnamedErrorPrediateDefinition__BodyAssignment_3 : ( ruleExpression ) ; | 23919 | // InternalSolverLanguageParser.g:7808:1: rule__UnnamedErrorPrediateDefinition__BodyAssignment_3 : ( ruleExpression ) ; |
26099 | public final void rule__UnnamedErrorPrediateDefinition__BodyAssignment_3() throws RecognitionException { | 23920 | public final void rule__UnnamedErrorPrediateDefinition__BodyAssignment_3() throws RecognitionException { |
26100 | 23921 | ||
26101 | int stackSize = keepStackSize(); | 23922 | int stackSize = keepStackSize(); |
26102 | 23923 | ||
26103 | try { | 23924 | try { |
26104 | // InternalSolverLanguage.g:7922:1: ( ( ruleExpression ) ) | 23925 | // InternalSolverLanguageParser.g:7812:1: ( ( ruleExpression ) ) |
26105 | // InternalSolverLanguage.g:7923:2: ( ruleExpression ) | 23926 | // InternalSolverLanguageParser.g:7813:2: ( ruleExpression ) |
26106 | { | 23927 | { |
26107 | // InternalSolverLanguage.g:7923:2: ( ruleExpression ) | 23928 | // InternalSolverLanguageParser.g:7813:2: ( ruleExpression ) |
26108 | // InternalSolverLanguage.g:7924:3: ruleExpression | 23929 | // InternalSolverLanguageParser.g:7814:3: ruleExpression |
26109 | { | 23930 | { |
26110 | if ( state.backtracking==0 ) { | 23931 | before(grammarAccess.getUnnamedErrorPrediateDefinitionAccess().getBodyExpressionParserRuleCall_3_0()); |
26111 | before(grammarAccess.getUnnamedErrorPrediateDefinitionAccess().getBodyExpressionParserRuleCall_3_0()); | ||
26112 | } | ||
26113 | pushFollow(FOLLOW_2); | 23932 | pushFollow(FOLLOW_2); |
26114 | ruleExpression(); | 23933 | ruleExpression(); |
26115 | 23934 | ||
26116 | state._fsp--; | 23935 | state._fsp--; |
26117 | if (state.failed) return ; | 23936 | |
26118 | if ( state.backtracking==0 ) { | 23937 | after(grammarAccess.getUnnamedErrorPrediateDefinitionAccess().getBodyExpressionParserRuleCall_3_0()); |
26119 | after(grammarAccess.getUnnamedErrorPrediateDefinitionAccess().getBodyExpressionParserRuleCall_3_0()); | ||
26120 | } | ||
26121 | 23938 | ||
26122 | } | 23939 | } |
26123 | 23940 | ||
@@ -26140,29 +23957,25 @@ public class InternalSolverLanguageParser extends AbstractInternalContentAssistP | |||
26140 | 23957 | ||
26141 | 23958 | ||
26142 | // $ANTLR start "rule__DefaultDefinition__HeadAssignment_1" | 23959 | // $ANTLR start "rule__DefaultDefinition__HeadAssignment_1" |
26143 | // InternalSolverLanguage.g:7933:1: rule__DefaultDefinition__HeadAssignment_1 : ( ruleCall ) ; | 23960 | // InternalSolverLanguageParser.g:7823:1: rule__DefaultDefinition__HeadAssignment_1 : ( ruleCall ) ; |
26144 | public final void rule__DefaultDefinition__HeadAssignment_1() throws RecognitionException { | 23961 | public final void rule__DefaultDefinition__HeadAssignment_1() throws RecognitionException { |
26145 | 23962 | ||
26146 | int stackSize = keepStackSize(); | 23963 | int stackSize = keepStackSize(); |
26147 | 23964 | ||
26148 | try { | 23965 | try { |
26149 | // InternalSolverLanguage.g:7937:1: ( ( ruleCall ) ) | 23966 | // InternalSolverLanguageParser.g:7827:1: ( ( ruleCall ) ) |
26150 | // InternalSolverLanguage.g:7938:2: ( ruleCall ) | 23967 | // InternalSolverLanguageParser.g:7828:2: ( ruleCall ) |
26151 | { | 23968 | { |
26152 | // InternalSolverLanguage.g:7938:2: ( ruleCall ) | 23969 | // InternalSolverLanguageParser.g:7828:2: ( ruleCall ) |
26153 | // InternalSolverLanguage.g:7939:3: ruleCall | 23970 | // InternalSolverLanguageParser.g:7829:3: ruleCall |
26154 | { | 23971 | { |
26155 | if ( state.backtracking==0 ) { | 23972 | before(grammarAccess.getDefaultDefinitionAccess().getHeadCallParserRuleCall_1_0()); |
26156 | before(grammarAccess.getDefaultDefinitionAccess().getHeadCallParserRuleCall_1_0()); | ||
26157 | } | ||
26158 | pushFollow(FOLLOW_2); | 23973 | pushFollow(FOLLOW_2); |
26159 | ruleCall(); | 23974 | ruleCall(); |
26160 | 23975 | ||
26161 | state._fsp--; | 23976 | state._fsp--; |
26162 | if (state.failed) return ; | 23977 | |
26163 | if ( state.backtracking==0 ) { | 23978 | after(grammarAccess.getDefaultDefinitionAccess().getHeadCallParserRuleCall_1_0()); |
26164 | after(grammarAccess.getDefaultDefinitionAccess().getHeadCallParserRuleCall_1_0()); | ||
26165 | } | ||
26166 | 23979 | ||
26167 | } | 23980 | } |
26168 | 23981 | ||
@@ -26185,29 +23998,25 @@ public class InternalSolverLanguageParser extends AbstractInternalContentAssistP | |||
26185 | 23998 | ||
26186 | 23999 | ||
26187 | // $ANTLR start "rule__DefaultDefinition__RangeAssignment_3" | 24000 | // $ANTLR start "rule__DefaultDefinition__RangeAssignment_3" |
26188 | // InternalSolverLanguage.g:7948:1: rule__DefaultDefinition__RangeAssignment_3 : ( ruleExpression ) ; | 24001 | // InternalSolverLanguageParser.g:7838:1: rule__DefaultDefinition__RangeAssignment_3 : ( ruleExpression ) ; |
26189 | public final void rule__DefaultDefinition__RangeAssignment_3() throws RecognitionException { | 24002 | public final void rule__DefaultDefinition__RangeAssignment_3() throws RecognitionException { |
26190 | 24003 | ||
26191 | int stackSize = keepStackSize(); | 24004 | int stackSize = keepStackSize(); |
26192 | 24005 | ||
26193 | try { | 24006 | try { |
26194 | // InternalSolverLanguage.g:7952:1: ( ( ruleExpression ) ) | 24007 | // InternalSolverLanguageParser.g:7842:1: ( ( ruleExpression ) ) |
26195 | // InternalSolverLanguage.g:7953:2: ( ruleExpression ) | 24008 | // InternalSolverLanguageParser.g:7843:2: ( ruleExpression ) |
26196 | { | 24009 | { |
26197 | // InternalSolverLanguage.g:7953:2: ( ruleExpression ) | 24010 | // InternalSolverLanguageParser.g:7843:2: ( ruleExpression ) |
26198 | // InternalSolverLanguage.g:7954:3: ruleExpression | 24011 | // InternalSolverLanguageParser.g:7844:3: ruleExpression |
26199 | { | 24012 | { |
26200 | if ( state.backtracking==0 ) { | 24013 | before(grammarAccess.getDefaultDefinitionAccess().getRangeExpressionParserRuleCall_3_0()); |
26201 | before(grammarAccess.getDefaultDefinitionAccess().getRangeExpressionParserRuleCall_3_0()); | ||
26202 | } | ||
26203 | pushFollow(FOLLOW_2); | 24014 | pushFollow(FOLLOW_2); |
26204 | ruleExpression(); | 24015 | ruleExpression(); |
26205 | 24016 | ||
26206 | state._fsp--; | 24017 | state._fsp--; |
26207 | if (state.failed) return ; | 24018 | |
26208 | if ( state.backtracking==0 ) { | 24019 | after(grammarAccess.getDefaultDefinitionAccess().getRangeExpressionParserRuleCall_3_0()); |
26209 | after(grammarAccess.getDefaultDefinitionAccess().getRangeExpressionParserRuleCall_3_0()); | ||
26210 | } | ||
26211 | 24020 | ||
26212 | } | 24021 | } |
26213 | 24022 | ||
@@ -26230,29 +24039,25 @@ public class InternalSolverLanguageParser extends AbstractInternalContentAssistP | |||
26230 | 24039 | ||
26231 | 24040 | ||
26232 | // $ANTLR start "rule__ExternPredicateDefinition__HeadAssignment_1" | 24041 | // $ANTLR start "rule__ExternPredicateDefinition__HeadAssignment_1" |
26233 | // InternalSolverLanguage.g:7963:1: rule__ExternPredicateDefinition__HeadAssignment_1 : ( ruleCall ) ; | 24042 | // InternalSolverLanguageParser.g:7853:1: rule__ExternPredicateDefinition__HeadAssignment_1 : ( ruleCall ) ; |
26234 | public final void rule__ExternPredicateDefinition__HeadAssignment_1() throws RecognitionException { | 24043 | public final void rule__ExternPredicateDefinition__HeadAssignment_1() throws RecognitionException { |
26235 | 24044 | ||
26236 | int stackSize = keepStackSize(); | 24045 | int stackSize = keepStackSize(); |
26237 | 24046 | ||
26238 | try { | 24047 | try { |
26239 | // InternalSolverLanguage.g:7967:1: ( ( ruleCall ) ) | 24048 | // InternalSolverLanguageParser.g:7857:1: ( ( ruleCall ) ) |
26240 | // InternalSolverLanguage.g:7968:2: ( ruleCall ) | 24049 | // InternalSolverLanguageParser.g:7858:2: ( ruleCall ) |
26241 | { | 24050 | { |
26242 | // InternalSolverLanguage.g:7968:2: ( ruleCall ) | 24051 | // InternalSolverLanguageParser.g:7858:2: ( ruleCall ) |
26243 | // InternalSolverLanguage.g:7969:3: ruleCall | 24052 | // InternalSolverLanguageParser.g:7859:3: ruleCall |
26244 | { | 24053 | { |
26245 | if ( state.backtracking==0 ) { | 24054 | before(grammarAccess.getExternPredicateDefinitionAccess().getHeadCallParserRuleCall_1_0()); |
26246 | before(grammarAccess.getExternPredicateDefinitionAccess().getHeadCallParserRuleCall_1_0()); | ||
26247 | } | ||
26248 | pushFollow(FOLLOW_2); | 24055 | pushFollow(FOLLOW_2); |
26249 | ruleCall(); | 24056 | ruleCall(); |
26250 | 24057 | ||
26251 | state._fsp--; | 24058 | state._fsp--; |
26252 | if (state.failed) return ; | 24059 | |
26253 | if ( state.backtracking==0 ) { | 24060 | after(grammarAccess.getExternPredicateDefinitionAccess().getHeadCallParserRuleCall_1_0()); |
26254 | after(grammarAccess.getExternPredicateDefinitionAccess().getHeadCallParserRuleCall_1_0()); | ||
26255 | } | ||
26256 | 24061 | ||
26257 | } | 24062 | } |
26258 | 24063 | ||
@@ -26275,29 +24080,25 @@ public class InternalSolverLanguageParser extends AbstractInternalContentAssistP | |||
26275 | 24080 | ||
26276 | 24081 | ||
26277 | // $ANTLR start "rule__MetricDefinition__TypeAssignment_0" | 24082 | // $ANTLR start "rule__MetricDefinition__TypeAssignment_0" |
26278 | // InternalSolverLanguage.g:7978:1: rule__MetricDefinition__TypeAssignment_0 : ( ruleMetricType ) ; | 24083 | // InternalSolverLanguageParser.g:7868:1: rule__MetricDefinition__TypeAssignment_0 : ( ruleMetricType ) ; |
26279 | public final void rule__MetricDefinition__TypeAssignment_0() throws RecognitionException { | 24084 | public final void rule__MetricDefinition__TypeAssignment_0() throws RecognitionException { |
26280 | 24085 | ||
26281 | int stackSize = keepStackSize(); | 24086 | int stackSize = keepStackSize(); |
26282 | 24087 | ||
26283 | try { | 24088 | try { |
26284 | // InternalSolverLanguage.g:7982:1: ( ( ruleMetricType ) ) | 24089 | // InternalSolverLanguageParser.g:7872:1: ( ( ruleMetricType ) ) |
26285 | // InternalSolverLanguage.g:7983:2: ( ruleMetricType ) | 24090 | // InternalSolverLanguageParser.g:7873:2: ( ruleMetricType ) |
26286 | { | 24091 | { |
26287 | // InternalSolverLanguage.g:7983:2: ( ruleMetricType ) | 24092 | // InternalSolverLanguageParser.g:7873:2: ( ruleMetricType ) |
26288 | // InternalSolverLanguage.g:7984:3: ruleMetricType | 24093 | // InternalSolverLanguageParser.g:7874:3: ruleMetricType |
26289 | { | 24094 | { |
26290 | if ( state.backtracking==0 ) { | 24095 | before(grammarAccess.getMetricDefinitionAccess().getTypeMetricTypeEnumRuleCall_0_0()); |
26291 | before(grammarAccess.getMetricDefinitionAccess().getTypeMetricTypeEnumRuleCall_0_0()); | ||
26292 | } | ||
26293 | pushFollow(FOLLOW_2); | 24096 | pushFollow(FOLLOW_2); |
26294 | ruleMetricType(); | 24097 | ruleMetricType(); |
26295 | 24098 | ||
26296 | state._fsp--; | 24099 | state._fsp--; |
26297 | if (state.failed) return ; | 24100 | |
26298 | if ( state.backtracking==0 ) { | 24101 | after(grammarAccess.getMetricDefinitionAccess().getTypeMetricTypeEnumRuleCall_0_0()); |
26299 | after(grammarAccess.getMetricDefinitionAccess().getTypeMetricTypeEnumRuleCall_0_0()); | ||
26300 | } | ||
26301 | 24102 | ||
26302 | } | 24103 | } |
26303 | 24104 | ||
@@ -26320,29 +24121,25 @@ public class InternalSolverLanguageParser extends AbstractInternalContentAssistP | |||
26320 | 24121 | ||
26321 | 24122 | ||
26322 | // $ANTLR start "rule__MetricDefinition__HeadAssignment_1" | 24123 | // $ANTLR start "rule__MetricDefinition__HeadAssignment_1" |
26323 | // InternalSolverLanguage.g:7993:1: rule__MetricDefinition__HeadAssignment_1 : ( ruleExpression ) ; | 24124 | // InternalSolverLanguageParser.g:7883:1: rule__MetricDefinition__HeadAssignment_1 : ( ruleExpression ) ; |
26324 | public final void rule__MetricDefinition__HeadAssignment_1() throws RecognitionException { | 24125 | public final void rule__MetricDefinition__HeadAssignment_1() throws RecognitionException { |
26325 | 24126 | ||
26326 | int stackSize = keepStackSize(); | 24127 | int stackSize = keepStackSize(); |
26327 | 24128 | ||
26328 | try { | 24129 | try { |
26329 | // InternalSolverLanguage.g:7997:1: ( ( ruleExpression ) ) | 24130 | // InternalSolverLanguageParser.g:7887:1: ( ( ruleExpression ) ) |
26330 | // InternalSolverLanguage.g:7998:2: ( ruleExpression ) | 24131 | // InternalSolverLanguageParser.g:7888:2: ( ruleExpression ) |
26331 | { | 24132 | { |
26332 | // InternalSolverLanguage.g:7998:2: ( ruleExpression ) | 24133 | // InternalSolverLanguageParser.g:7888:2: ( ruleExpression ) |
26333 | // InternalSolverLanguage.g:7999:3: ruleExpression | 24134 | // InternalSolverLanguageParser.g:7889:3: ruleExpression |
26334 | { | 24135 | { |
26335 | if ( state.backtracking==0 ) { | 24136 | before(grammarAccess.getMetricDefinitionAccess().getHeadExpressionParserRuleCall_1_0()); |
26336 | before(grammarAccess.getMetricDefinitionAccess().getHeadExpressionParserRuleCall_1_0()); | ||
26337 | } | ||
26338 | pushFollow(FOLLOW_2); | 24137 | pushFollow(FOLLOW_2); |
26339 | ruleExpression(); | 24138 | ruleExpression(); |
26340 | 24139 | ||
26341 | state._fsp--; | 24140 | state._fsp--; |
26342 | if (state.failed) return ; | 24141 | |
26343 | if ( state.backtracking==0 ) { | 24142 | after(grammarAccess.getMetricDefinitionAccess().getHeadExpressionParserRuleCall_1_0()); |
26344 | after(grammarAccess.getMetricDefinitionAccess().getHeadExpressionParserRuleCall_1_0()); | ||
26345 | } | ||
26346 | 24143 | ||
26347 | } | 24144 | } |
26348 | 24145 | ||
@@ -26365,29 +24162,25 @@ public class InternalSolverLanguageParser extends AbstractInternalContentAssistP | |||
26365 | 24162 | ||
26366 | 24163 | ||
26367 | // $ANTLR start "rule__MetricDefinition__BodyAssignment_3" | 24164 | // $ANTLR start "rule__MetricDefinition__BodyAssignment_3" |
26368 | // InternalSolverLanguage.g:8008:1: rule__MetricDefinition__BodyAssignment_3 : ( ruleExpression ) ; | 24165 | // InternalSolverLanguageParser.g:7898:1: rule__MetricDefinition__BodyAssignment_3 : ( ruleExpression ) ; |
26369 | public final void rule__MetricDefinition__BodyAssignment_3() throws RecognitionException { | 24166 | public final void rule__MetricDefinition__BodyAssignment_3() throws RecognitionException { |
26370 | 24167 | ||
26371 | int stackSize = keepStackSize(); | 24168 | int stackSize = keepStackSize(); |
26372 | 24169 | ||
26373 | try { | 24170 | try { |
26374 | // InternalSolverLanguage.g:8012:1: ( ( ruleExpression ) ) | 24171 | // InternalSolverLanguageParser.g:7902:1: ( ( ruleExpression ) ) |
26375 | // InternalSolverLanguage.g:8013:2: ( ruleExpression ) | 24172 | // InternalSolverLanguageParser.g:7903:2: ( ruleExpression ) |
26376 | { | 24173 | { |
26377 | // InternalSolverLanguage.g:8013:2: ( ruleExpression ) | 24174 | // InternalSolverLanguageParser.g:7903:2: ( ruleExpression ) |
26378 | // InternalSolverLanguage.g:8014:3: ruleExpression | 24175 | // InternalSolverLanguageParser.g:7904:3: ruleExpression |
26379 | { | 24176 | { |
26380 | if ( state.backtracking==0 ) { | 24177 | before(grammarAccess.getMetricDefinitionAccess().getBodyExpressionParserRuleCall_3_0()); |
26381 | before(grammarAccess.getMetricDefinitionAccess().getBodyExpressionParserRuleCall_3_0()); | ||
26382 | } | ||
26383 | pushFollow(FOLLOW_2); | 24178 | pushFollow(FOLLOW_2); |
26384 | ruleExpression(); | 24179 | ruleExpression(); |
26385 | 24180 | ||
26386 | state._fsp--; | 24181 | state._fsp--; |
26387 | if (state.failed) return ; | 24182 | |
26388 | if ( state.backtracking==0 ) { | 24183 | after(grammarAccess.getMetricDefinitionAccess().getBodyExpressionParserRuleCall_3_0()); |
26389 | after(grammarAccess.getMetricDefinitionAccess().getBodyExpressionParserRuleCall_3_0()); | ||
26390 | } | ||
26391 | 24184 | ||
26392 | } | 24185 | } |
26393 | 24186 | ||
@@ -26410,29 +24203,25 @@ public class InternalSolverLanguageParser extends AbstractInternalContentAssistP | |||
26410 | 24203 | ||
26411 | 24204 | ||
26412 | // $ANTLR start "rule__ExternMetricDefinition__TypeAssignment_1" | 24205 | // $ANTLR start "rule__ExternMetricDefinition__TypeAssignment_1" |
26413 | // InternalSolverLanguage.g:8023:1: rule__ExternMetricDefinition__TypeAssignment_1 : ( ruleMetricType ) ; | 24206 | // InternalSolverLanguageParser.g:7913:1: rule__ExternMetricDefinition__TypeAssignment_1 : ( ruleMetricType ) ; |
26414 | public final void rule__ExternMetricDefinition__TypeAssignment_1() throws RecognitionException { | 24207 | public final void rule__ExternMetricDefinition__TypeAssignment_1() throws RecognitionException { |
26415 | 24208 | ||
26416 | int stackSize = keepStackSize(); | 24209 | int stackSize = keepStackSize(); |
26417 | 24210 | ||
26418 | try { | 24211 | try { |
26419 | // InternalSolverLanguage.g:8027:1: ( ( ruleMetricType ) ) | 24212 | // InternalSolverLanguageParser.g:7917:1: ( ( ruleMetricType ) ) |
26420 | // InternalSolverLanguage.g:8028:2: ( ruleMetricType ) | 24213 | // InternalSolverLanguageParser.g:7918:2: ( ruleMetricType ) |
26421 | { | 24214 | { |
26422 | // InternalSolverLanguage.g:8028:2: ( ruleMetricType ) | 24215 | // InternalSolverLanguageParser.g:7918:2: ( ruleMetricType ) |
26423 | // InternalSolverLanguage.g:8029:3: ruleMetricType | 24216 | // InternalSolverLanguageParser.g:7919:3: ruleMetricType |
26424 | { | 24217 | { |
26425 | if ( state.backtracking==0 ) { | 24218 | before(grammarAccess.getExternMetricDefinitionAccess().getTypeMetricTypeEnumRuleCall_1_0()); |
26426 | before(grammarAccess.getExternMetricDefinitionAccess().getTypeMetricTypeEnumRuleCall_1_0()); | ||
26427 | } | ||
26428 | pushFollow(FOLLOW_2); | 24219 | pushFollow(FOLLOW_2); |
26429 | ruleMetricType(); | 24220 | ruleMetricType(); |
26430 | 24221 | ||
26431 | state._fsp--; | 24222 | state._fsp--; |
26432 | if (state.failed) return ; | 24223 | |
26433 | if ( state.backtracking==0 ) { | 24224 | after(grammarAccess.getExternMetricDefinitionAccess().getTypeMetricTypeEnumRuleCall_1_0()); |
26434 | after(grammarAccess.getExternMetricDefinitionAccess().getTypeMetricTypeEnumRuleCall_1_0()); | ||
26435 | } | ||
26436 | 24225 | ||
26437 | } | 24226 | } |
26438 | 24227 | ||
@@ -26455,29 +24244,25 @@ public class InternalSolverLanguageParser extends AbstractInternalContentAssistP | |||
26455 | 24244 | ||
26456 | 24245 | ||
26457 | // $ANTLR start "rule__ExternMetricDefinition__HeadAssignment_2" | 24246 | // $ANTLR start "rule__ExternMetricDefinition__HeadAssignment_2" |
26458 | // InternalSolverLanguage.g:8038:1: rule__ExternMetricDefinition__HeadAssignment_2 : ( ruleCall ) ; | 24247 | // InternalSolverLanguageParser.g:7928:1: rule__ExternMetricDefinition__HeadAssignment_2 : ( ruleCall ) ; |
26459 | public final void rule__ExternMetricDefinition__HeadAssignment_2() throws RecognitionException { | 24248 | public final void rule__ExternMetricDefinition__HeadAssignment_2() throws RecognitionException { |
26460 | 24249 | ||
26461 | int stackSize = keepStackSize(); | 24250 | int stackSize = keepStackSize(); |
26462 | 24251 | ||
26463 | try { | 24252 | try { |
26464 | // InternalSolverLanguage.g:8042:1: ( ( ruleCall ) ) | 24253 | // InternalSolverLanguageParser.g:7932:1: ( ( ruleCall ) ) |
26465 | // InternalSolverLanguage.g:8043:2: ( ruleCall ) | 24254 | // InternalSolverLanguageParser.g:7933:2: ( ruleCall ) |
26466 | { | 24255 | { |
26467 | // InternalSolverLanguage.g:8043:2: ( ruleCall ) | 24256 | // InternalSolverLanguageParser.g:7933:2: ( ruleCall ) |
26468 | // InternalSolverLanguage.g:8044:3: ruleCall | 24257 | // InternalSolverLanguageParser.g:7934:3: ruleCall |
26469 | { | 24258 | { |
26470 | if ( state.backtracking==0 ) { | 24259 | before(grammarAccess.getExternMetricDefinitionAccess().getHeadCallParserRuleCall_2_0()); |
26471 | before(grammarAccess.getExternMetricDefinitionAccess().getHeadCallParserRuleCall_2_0()); | ||
26472 | } | ||
26473 | pushFollow(FOLLOW_2); | 24260 | pushFollow(FOLLOW_2); |
26474 | ruleCall(); | 24261 | ruleCall(); |
26475 | 24262 | ||
26476 | state._fsp--; | 24263 | state._fsp--; |
26477 | if (state.failed) return ; | 24264 | |
26478 | if ( state.backtracking==0 ) { | 24265 | after(grammarAccess.getExternMetricDefinitionAccess().getHeadCallParserRuleCall_2_0()); |
26479 | after(grammarAccess.getExternMetricDefinitionAccess().getHeadCallParserRuleCall_2_0()); | ||
26480 | } | ||
26481 | 24266 | ||
26482 | } | 24267 | } |
26483 | 24268 | ||
@@ -26500,29 +24285,25 @@ public class InternalSolverLanguageParser extends AbstractInternalContentAssistP | |||
26500 | 24285 | ||
26501 | 24286 | ||
26502 | // $ANTLR start "rule__IfElse__ConditionAssignment_1" | 24287 | // $ANTLR start "rule__IfElse__ConditionAssignment_1" |
26503 | // InternalSolverLanguage.g:8053:1: rule__IfElse__ConditionAssignment_1 : ( ruleExpression ) ; | 24288 | // InternalSolverLanguageParser.g:7943:1: rule__IfElse__ConditionAssignment_1 : ( ruleExpression ) ; |
26504 | public final void rule__IfElse__ConditionAssignment_1() throws RecognitionException { | 24289 | public final void rule__IfElse__ConditionAssignment_1() throws RecognitionException { |
26505 | 24290 | ||
26506 | int stackSize = keepStackSize(); | 24291 | int stackSize = keepStackSize(); |
26507 | 24292 | ||
26508 | try { | 24293 | try { |
26509 | // InternalSolverLanguage.g:8057:1: ( ( ruleExpression ) ) | 24294 | // InternalSolverLanguageParser.g:7947:1: ( ( ruleExpression ) ) |
26510 | // InternalSolverLanguage.g:8058:2: ( ruleExpression ) | 24295 | // InternalSolverLanguageParser.g:7948:2: ( ruleExpression ) |
26511 | { | 24296 | { |
26512 | // InternalSolverLanguage.g:8058:2: ( ruleExpression ) | 24297 | // InternalSolverLanguageParser.g:7948:2: ( ruleExpression ) |
26513 | // InternalSolverLanguage.g:8059:3: ruleExpression | 24298 | // InternalSolverLanguageParser.g:7949:3: ruleExpression |
26514 | { | 24299 | { |
26515 | if ( state.backtracking==0 ) { | 24300 | before(grammarAccess.getIfElseAccess().getConditionExpressionParserRuleCall_1_0()); |
26516 | before(grammarAccess.getIfElseAccess().getConditionExpressionParserRuleCall_1_0()); | ||
26517 | } | ||
26518 | pushFollow(FOLLOW_2); | 24301 | pushFollow(FOLLOW_2); |
26519 | ruleExpression(); | 24302 | ruleExpression(); |
26520 | 24303 | ||
26521 | state._fsp--; | 24304 | state._fsp--; |
26522 | if (state.failed) return ; | 24305 | |
26523 | if ( state.backtracking==0 ) { | 24306 | after(grammarAccess.getIfElseAccess().getConditionExpressionParserRuleCall_1_0()); |
26524 | after(grammarAccess.getIfElseAccess().getConditionExpressionParserRuleCall_1_0()); | ||
26525 | } | ||
26526 | 24307 | ||
26527 | } | 24308 | } |
26528 | 24309 | ||
@@ -26545,29 +24326,25 @@ public class InternalSolverLanguageParser extends AbstractInternalContentAssistP | |||
26545 | 24326 | ||
26546 | 24327 | ||
26547 | // $ANTLR start "rule__IfElse__ThenAssignment_3" | 24328 | // $ANTLR start "rule__IfElse__ThenAssignment_3" |
26548 | // InternalSolverLanguage.g:8068:1: rule__IfElse__ThenAssignment_3 : ( ruleExpression ) ; | 24329 | // InternalSolverLanguageParser.g:7958:1: rule__IfElse__ThenAssignment_3 : ( ruleExpression ) ; |
26549 | public final void rule__IfElse__ThenAssignment_3() throws RecognitionException { | 24330 | public final void rule__IfElse__ThenAssignment_3() throws RecognitionException { |
26550 | 24331 | ||
26551 | int stackSize = keepStackSize(); | 24332 | int stackSize = keepStackSize(); |
26552 | 24333 | ||
26553 | try { | 24334 | try { |
26554 | // InternalSolverLanguage.g:8072:1: ( ( ruleExpression ) ) | 24335 | // InternalSolverLanguageParser.g:7962:1: ( ( ruleExpression ) ) |
26555 | // InternalSolverLanguage.g:8073:2: ( ruleExpression ) | 24336 | // InternalSolverLanguageParser.g:7963:2: ( ruleExpression ) |
26556 | { | 24337 | { |
26557 | // InternalSolverLanguage.g:8073:2: ( ruleExpression ) | 24338 | // InternalSolverLanguageParser.g:7963:2: ( ruleExpression ) |
26558 | // InternalSolverLanguage.g:8074:3: ruleExpression | 24339 | // InternalSolverLanguageParser.g:7964:3: ruleExpression |
26559 | { | 24340 | { |
26560 | if ( state.backtracking==0 ) { | 24341 | before(grammarAccess.getIfElseAccess().getThenExpressionParserRuleCall_3_0()); |
26561 | before(grammarAccess.getIfElseAccess().getThenExpressionParserRuleCall_3_0()); | ||
26562 | } | ||
26563 | pushFollow(FOLLOW_2); | 24342 | pushFollow(FOLLOW_2); |
26564 | ruleExpression(); | 24343 | ruleExpression(); |
26565 | 24344 | ||
26566 | state._fsp--; | 24345 | state._fsp--; |
26567 | if (state.failed) return ; | 24346 | |
26568 | if ( state.backtracking==0 ) { | 24347 | after(grammarAccess.getIfElseAccess().getThenExpressionParserRuleCall_3_0()); |
26569 | after(grammarAccess.getIfElseAccess().getThenExpressionParserRuleCall_3_0()); | ||
26570 | } | ||
26571 | 24348 | ||
26572 | } | 24349 | } |
26573 | 24350 | ||
@@ -26590,29 +24367,25 @@ public class InternalSolverLanguageParser extends AbstractInternalContentAssistP | |||
26590 | 24367 | ||
26591 | 24368 | ||
26592 | // $ANTLR start "rule__IfElse__ElseAssignment_5" | 24369 | // $ANTLR start "rule__IfElse__ElseAssignment_5" |
26593 | // InternalSolverLanguage.g:8083:1: rule__IfElse__ElseAssignment_5 : ( ruleExpression ) ; | 24370 | // InternalSolverLanguageParser.g:7973:1: rule__IfElse__ElseAssignment_5 : ( ruleExpression ) ; |
26594 | public final void rule__IfElse__ElseAssignment_5() throws RecognitionException { | 24371 | public final void rule__IfElse__ElseAssignment_5() throws RecognitionException { |
26595 | 24372 | ||
26596 | int stackSize = keepStackSize(); | 24373 | int stackSize = keepStackSize(); |
26597 | 24374 | ||
26598 | try { | 24375 | try { |
26599 | // InternalSolverLanguage.g:8087:1: ( ( ruleExpression ) ) | 24376 | // InternalSolverLanguageParser.g:7977:1: ( ( ruleExpression ) ) |
26600 | // InternalSolverLanguage.g:8088:2: ( ruleExpression ) | 24377 | // InternalSolverLanguageParser.g:7978:2: ( ruleExpression ) |
26601 | { | 24378 | { |
26602 | // InternalSolverLanguage.g:8088:2: ( ruleExpression ) | 24379 | // InternalSolverLanguageParser.g:7978:2: ( ruleExpression ) |
26603 | // InternalSolverLanguage.g:8089:3: ruleExpression | 24380 | // InternalSolverLanguageParser.g:7979:3: ruleExpression |
26604 | { | 24381 | { |
26605 | if ( state.backtracking==0 ) { | 24382 | before(grammarAccess.getIfElseAccess().getElseExpressionParserRuleCall_5_0()); |
26606 | before(grammarAccess.getIfElseAccess().getElseExpressionParserRuleCall_5_0()); | ||
26607 | } | ||
26608 | pushFollow(FOLLOW_2); | 24383 | pushFollow(FOLLOW_2); |
26609 | ruleExpression(); | 24384 | ruleExpression(); |
26610 | 24385 | ||
26611 | state._fsp--; | 24386 | state._fsp--; |
26612 | if (state.failed) return ; | 24387 | |
26613 | if ( state.backtracking==0 ) { | 24388 | after(grammarAccess.getIfElseAccess().getElseExpressionParserRuleCall_5_0()); |
26614 | after(grammarAccess.getIfElseAccess().getElseExpressionParserRuleCall_5_0()); | ||
26615 | } | ||
26616 | 24389 | ||
26617 | } | 24390 | } |
26618 | 24391 | ||
@@ -26635,29 +24408,25 @@ public class InternalSolverLanguageParser extends AbstractInternalContentAssistP | |||
26635 | 24408 | ||
26636 | 24409 | ||
26637 | // $ANTLR start "rule__DisjunctiveExpression__ChildrenAssignment_1_0_1_1" | 24410 | // $ANTLR start "rule__DisjunctiveExpression__ChildrenAssignment_1_0_1_1" |
26638 | // InternalSolverLanguage.g:8098:1: rule__DisjunctiveExpression__ChildrenAssignment_1_0_1_1 : ( ruleConjunctiveExpression ) ; | 24411 | // InternalSolverLanguageParser.g:7988:1: rule__DisjunctiveExpression__ChildrenAssignment_1_0_1_1 : ( ruleConjunctiveExpression ) ; |
26639 | public final void rule__DisjunctiveExpression__ChildrenAssignment_1_0_1_1() throws RecognitionException { | 24412 | public final void rule__DisjunctiveExpression__ChildrenAssignment_1_0_1_1() throws RecognitionException { |
26640 | 24413 | ||
26641 | int stackSize = keepStackSize(); | 24414 | int stackSize = keepStackSize(); |
26642 | 24415 | ||
26643 | try { | 24416 | try { |
26644 | // InternalSolverLanguage.g:8102:1: ( ( ruleConjunctiveExpression ) ) | 24417 | // InternalSolverLanguageParser.g:7992:1: ( ( ruleConjunctiveExpression ) ) |
26645 | // InternalSolverLanguage.g:8103:2: ( ruleConjunctiveExpression ) | 24418 | // InternalSolverLanguageParser.g:7993:2: ( ruleConjunctiveExpression ) |
26646 | { | 24419 | { |
26647 | // InternalSolverLanguage.g:8103:2: ( ruleConjunctiveExpression ) | 24420 | // InternalSolverLanguageParser.g:7993:2: ( ruleConjunctiveExpression ) |
26648 | // InternalSolverLanguage.g:8104:3: ruleConjunctiveExpression | 24421 | // InternalSolverLanguageParser.g:7994:3: ruleConjunctiveExpression |
26649 | { | 24422 | { |
26650 | if ( state.backtracking==0 ) { | 24423 | before(grammarAccess.getDisjunctiveExpressionAccess().getChildrenConjunctiveExpressionParserRuleCall_1_0_1_1_0()); |
26651 | before(grammarAccess.getDisjunctiveExpressionAccess().getChildrenConjunctiveExpressionParserRuleCall_1_0_1_1_0()); | ||
26652 | } | ||
26653 | pushFollow(FOLLOW_2); | 24424 | pushFollow(FOLLOW_2); |
26654 | ruleConjunctiveExpression(); | 24425 | ruleConjunctiveExpression(); |
26655 | 24426 | ||
26656 | state._fsp--; | 24427 | state._fsp--; |
26657 | if (state.failed) return ; | 24428 | |
26658 | if ( state.backtracking==0 ) { | 24429 | after(grammarAccess.getDisjunctiveExpressionAccess().getChildrenConjunctiveExpressionParserRuleCall_1_0_1_1_0()); |
26659 | after(grammarAccess.getDisjunctiveExpressionAccess().getChildrenConjunctiveExpressionParserRuleCall_1_0_1_1_0()); | ||
26660 | } | ||
26661 | 24430 | ||
26662 | } | 24431 | } |
26663 | 24432 | ||
@@ -26680,29 +24449,25 @@ public class InternalSolverLanguageParser extends AbstractInternalContentAssistP | |||
26680 | 24449 | ||
26681 | 24450 | ||
26682 | // $ANTLR start "rule__DisjunctiveExpression__BodyAssignment_1_1_2" | 24451 | // $ANTLR start "rule__DisjunctiveExpression__BodyAssignment_1_1_2" |
26683 | // InternalSolverLanguage.g:8113:1: rule__DisjunctiveExpression__BodyAssignment_1_1_2 : ( ruleConjunctiveExpression ) ; | 24452 | // InternalSolverLanguageParser.g:8003:1: rule__DisjunctiveExpression__BodyAssignment_1_1_2 : ( ruleConjunctiveExpression ) ; |
26684 | public final void rule__DisjunctiveExpression__BodyAssignment_1_1_2() throws RecognitionException { | 24453 | public final void rule__DisjunctiveExpression__BodyAssignment_1_1_2() throws RecognitionException { |
26685 | 24454 | ||
26686 | int stackSize = keepStackSize(); | 24455 | int stackSize = keepStackSize(); |
26687 | 24456 | ||
26688 | try { | 24457 | try { |
26689 | // InternalSolverLanguage.g:8117:1: ( ( ruleConjunctiveExpression ) ) | 24458 | // InternalSolverLanguageParser.g:8007:1: ( ( ruleConjunctiveExpression ) ) |
26690 | // InternalSolverLanguage.g:8118:2: ( ruleConjunctiveExpression ) | 24459 | // InternalSolverLanguageParser.g:8008:2: ( ruleConjunctiveExpression ) |
26691 | { | 24460 | { |
26692 | // InternalSolverLanguage.g:8118:2: ( ruleConjunctiveExpression ) | 24461 | // InternalSolverLanguageParser.g:8008:2: ( ruleConjunctiveExpression ) |
26693 | // InternalSolverLanguage.g:8119:3: ruleConjunctiveExpression | 24462 | // InternalSolverLanguageParser.g:8009:3: ruleConjunctiveExpression |
26694 | { | 24463 | { |
26695 | if ( state.backtracking==0 ) { | 24464 | before(grammarAccess.getDisjunctiveExpressionAccess().getBodyConjunctiveExpressionParserRuleCall_1_1_2_0()); |
26696 | before(grammarAccess.getDisjunctiveExpressionAccess().getBodyConjunctiveExpressionParserRuleCall_1_1_2_0()); | ||
26697 | } | ||
26698 | pushFollow(FOLLOW_2); | 24465 | pushFollow(FOLLOW_2); |
26699 | ruleConjunctiveExpression(); | 24466 | ruleConjunctiveExpression(); |
26700 | 24467 | ||
26701 | state._fsp--; | 24468 | state._fsp--; |
26702 | if (state.failed) return ; | 24469 | |
26703 | if ( state.backtracking==0 ) { | 24470 | after(grammarAccess.getDisjunctiveExpressionAccess().getBodyConjunctiveExpressionParserRuleCall_1_1_2_0()); |
26704 | after(grammarAccess.getDisjunctiveExpressionAccess().getBodyConjunctiveExpressionParserRuleCall_1_1_2_0()); | ||
26705 | } | ||
26706 | 24471 | ||
26707 | } | 24472 | } |
26708 | 24473 | ||
@@ -26725,29 +24490,25 @@ public class InternalSolverLanguageParser extends AbstractInternalContentAssistP | |||
26725 | 24490 | ||
26726 | 24491 | ||
26727 | // $ANTLR start "rule__DisjunctiveExpression__CasesAssignment_1_1_4_1" | 24492 | // $ANTLR start "rule__DisjunctiveExpression__CasesAssignment_1_1_4_1" |
26728 | // InternalSolverLanguage.g:8128:1: rule__DisjunctiveExpression__CasesAssignment_1_1_4_1 : ( ruleCase ) ; | 24493 | // InternalSolverLanguageParser.g:8018:1: rule__DisjunctiveExpression__CasesAssignment_1_1_4_1 : ( ruleCase ) ; |
26729 | public final void rule__DisjunctiveExpression__CasesAssignment_1_1_4_1() throws RecognitionException { | 24494 | public final void rule__DisjunctiveExpression__CasesAssignment_1_1_4_1() throws RecognitionException { |
26730 | 24495 | ||
26731 | int stackSize = keepStackSize(); | 24496 | int stackSize = keepStackSize(); |
26732 | 24497 | ||
26733 | try { | 24498 | try { |
26734 | // InternalSolverLanguage.g:8132:1: ( ( ruleCase ) ) | 24499 | // InternalSolverLanguageParser.g:8022:1: ( ( ruleCase ) ) |
26735 | // InternalSolverLanguage.g:8133:2: ( ruleCase ) | 24500 | // InternalSolverLanguageParser.g:8023:2: ( ruleCase ) |
26736 | { | 24501 | { |
26737 | // InternalSolverLanguage.g:8133:2: ( ruleCase ) | 24502 | // InternalSolverLanguageParser.g:8023:2: ( ruleCase ) |
26738 | // InternalSolverLanguage.g:8134:3: ruleCase | 24503 | // InternalSolverLanguageParser.g:8024:3: ruleCase |
26739 | { | 24504 | { |
26740 | if ( state.backtracking==0 ) { | 24505 | before(grammarAccess.getDisjunctiveExpressionAccess().getCasesCaseParserRuleCall_1_1_4_1_0()); |
26741 | before(grammarAccess.getDisjunctiveExpressionAccess().getCasesCaseParserRuleCall_1_1_4_1_0()); | ||
26742 | } | ||
26743 | pushFollow(FOLLOW_2); | 24506 | pushFollow(FOLLOW_2); |
26744 | ruleCase(); | 24507 | ruleCase(); |
26745 | 24508 | ||
26746 | state._fsp--; | 24509 | state._fsp--; |
26747 | if (state.failed) return ; | 24510 | |
26748 | if ( state.backtracking==0 ) { | 24511 | after(grammarAccess.getDisjunctiveExpressionAccess().getCasesCaseParserRuleCall_1_1_4_1_0()); |
26749 | after(grammarAccess.getDisjunctiveExpressionAccess().getCasesCaseParserRuleCall_1_1_4_1_0()); | ||
26750 | } | ||
26751 | 24512 | ||
26752 | } | 24513 | } |
26753 | 24514 | ||
@@ -26770,29 +24531,25 @@ public class InternalSolverLanguageParser extends AbstractInternalContentAssistP | |||
26770 | 24531 | ||
26771 | 24532 | ||
26772 | // $ANTLR start "rule__Case__ConditionAssignment_0" | 24533 | // $ANTLR start "rule__Case__ConditionAssignment_0" |
26773 | // InternalSolverLanguage.g:8143:1: rule__Case__ConditionAssignment_0 : ( ruleConjunctiveExpression ) ; | 24534 | // InternalSolverLanguageParser.g:8033:1: rule__Case__ConditionAssignment_0 : ( ruleConjunctiveExpression ) ; |
26774 | public final void rule__Case__ConditionAssignment_0() throws RecognitionException { | 24535 | public final void rule__Case__ConditionAssignment_0() throws RecognitionException { |
26775 | 24536 | ||
26776 | int stackSize = keepStackSize(); | 24537 | int stackSize = keepStackSize(); |
26777 | 24538 | ||
26778 | try { | 24539 | try { |
26779 | // InternalSolverLanguage.g:8147:1: ( ( ruleConjunctiveExpression ) ) | 24540 | // InternalSolverLanguageParser.g:8037:1: ( ( ruleConjunctiveExpression ) ) |
26780 | // InternalSolverLanguage.g:8148:2: ( ruleConjunctiveExpression ) | 24541 | // InternalSolverLanguageParser.g:8038:2: ( ruleConjunctiveExpression ) |
26781 | { | 24542 | { |
26782 | // InternalSolverLanguage.g:8148:2: ( ruleConjunctiveExpression ) | 24543 | // InternalSolverLanguageParser.g:8038:2: ( ruleConjunctiveExpression ) |
26783 | // InternalSolverLanguage.g:8149:3: ruleConjunctiveExpression | 24544 | // InternalSolverLanguageParser.g:8039:3: ruleConjunctiveExpression |
26784 | { | 24545 | { |
26785 | if ( state.backtracking==0 ) { | 24546 | before(grammarAccess.getCaseAccess().getConditionConjunctiveExpressionParserRuleCall_0_0()); |
26786 | before(grammarAccess.getCaseAccess().getConditionConjunctiveExpressionParserRuleCall_0_0()); | ||
26787 | } | ||
26788 | pushFollow(FOLLOW_2); | 24547 | pushFollow(FOLLOW_2); |
26789 | ruleConjunctiveExpression(); | 24548 | ruleConjunctiveExpression(); |
26790 | 24549 | ||
26791 | state._fsp--; | 24550 | state._fsp--; |
26792 | if (state.failed) return ; | 24551 | |
26793 | if ( state.backtracking==0 ) { | 24552 | after(grammarAccess.getCaseAccess().getConditionConjunctiveExpressionParserRuleCall_0_0()); |
26794 | after(grammarAccess.getCaseAccess().getConditionConjunctiveExpressionParserRuleCall_0_0()); | ||
26795 | } | ||
26796 | 24553 | ||
26797 | } | 24554 | } |
26798 | 24555 | ||
@@ -26815,29 +24572,25 @@ public class InternalSolverLanguageParser extends AbstractInternalContentAssistP | |||
26815 | 24572 | ||
26816 | 24573 | ||
26817 | // $ANTLR start "rule__Case__BodyAssignment_2" | 24574 | // $ANTLR start "rule__Case__BodyAssignment_2" |
26818 | // InternalSolverLanguage.g:8158:1: rule__Case__BodyAssignment_2 : ( ruleConjunctiveExpression ) ; | 24575 | // InternalSolverLanguageParser.g:8048:1: rule__Case__BodyAssignment_2 : ( ruleConjunctiveExpression ) ; |
26819 | public final void rule__Case__BodyAssignment_2() throws RecognitionException { | 24576 | public final void rule__Case__BodyAssignment_2() throws RecognitionException { |
26820 | 24577 | ||
26821 | int stackSize = keepStackSize(); | 24578 | int stackSize = keepStackSize(); |
26822 | 24579 | ||
26823 | try { | 24580 | try { |
26824 | // InternalSolverLanguage.g:8162:1: ( ( ruleConjunctiveExpression ) ) | 24581 | // InternalSolverLanguageParser.g:8052:1: ( ( ruleConjunctiveExpression ) ) |
26825 | // InternalSolverLanguage.g:8163:2: ( ruleConjunctiveExpression ) | 24582 | // InternalSolverLanguageParser.g:8053:2: ( ruleConjunctiveExpression ) |
26826 | { | 24583 | { |
26827 | // InternalSolverLanguage.g:8163:2: ( ruleConjunctiveExpression ) | 24584 | // InternalSolverLanguageParser.g:8053:2: ( ruleConjunctiveExpression ) |
26828 | // InternalSolverLanguage.g:8164:3: ruleConjunctiveExpression | 24585 | // InternalSolverLanguageParser.g:8054:3: ruleConjunctiveExpression |
26829 | { | 24586 | { |
26830 | if ( state.backtracking==0 ) { | 24587 | before(grammarAccess.getCaseAccess().getBodyConjunctiveExpressionParserRuleCall_2_0()); |
26831 | before(grammarAccess.getCaseAccess().getBodyConjunctiveExpressionParserRuleCall_2_0()); | ||
26832 | } | ||
26833 | pushFollow(FOLLOW_2); | 24588 | pushFollow(FOLLOW_2); |
26834 | ruleConjunctiveExpression(); | 24589 | ruleConjunctiveExpression(); |
26835 | 24590 | ||
26836 | state._fsp--; | 24591 | state._fsp--; |
26837 | if (state.failed) return ; | 24592 | |
26838 | if ( state.backtracking==0 ) { | 24593 | after(grammarAccess.getCaseAccess().getBodyConjunctiveExpressionParserRuleCall_2_0()); |
26839 | after(grammarAccess.getCaseAccess().getBodyConjunctiveExpressionParserRuleCall_2_0()); | ||
26840 | } | ||
26841 | 24594 | ||
26842 | } | 24595 | } |
26843 | 24596 | ||
@@ -26860,29 +24613,25 @@ public class InternalSolverLanguageParser extends AbstractInternalContentAssistP | |||
26860 | 24613 | ||
26861 | 24614 | ||
26862 | // $ANTLR start "rule__ConjunctiveExpression__ChildrenAssignment_1_1_1" | 24615 | // $ANTLR start "rule__ConjunctiveExpression__ChildrenAssignment_1_1_1" |
26863 | // InternalSolverLanguage.g:8173:1: rule__ConjunctiveExpression__ChildrenAssignment_1_1_1 : ( ruleComparisonExpression ) ; | 24616 | // InternalSolverLanguageParser.g:8063:1: rule__ConjunctiveExpression__ChildrenAssignment_1_1_1 : ( ruleComparisonExpression ) ; |
26864 | public final void rule__ConjunctiveExpression__ChildrenAssignment_1_1_1() throws RecognitionException { | 24617 | public final void rule__ConjunctiveExpression__ChildrenAssignment_1_1_1() throws RecognitionException { |
26865 | 24618 | ||
26866 | int stackSize = keepStackSize(); | 24619 | int stackSize = keepStackSize(); |
26867 | 24620 | ||
26868 | try { | 24621 | try { |
26869 | // InternalSolverLanguage.g:8177:1: ( ( ruleComparisonExpression ) ) | 24622 | // InternalSolverLanguageParser.g:8067:1: ( ( ruleComparisonExpression ) ) |
26870 | // InternalSolverLanguage.g:8178:2: ( ruleComparisonExpression ) | 24623 | // InternalSolverLanguageParser.g:8068:2: ( ruleComparisonExpression ) |
26871 | { | 24624 | { |
26872 | // InternalSolverLanguage.g:8178:2: ( ruleComparisonExpression ) | 24625 | // InternalSolverLanguageParser.g:8068:2: ( ruleComparisonExpression ) |
26873 | // InternalSolverLanguage.g:8179:3: ruleComparisonExpression | 24626 | // InternalSolverLanguageParser.g:8069:3: ruleComparisonExpression |
26874 | { | 24627 | { |
26875 | if ( state.backtracking==0 ) { | 24628 | before(grammarAccess.getConjunctiveExpressionAccess().getChildrenComparisonExpressionParserRuleCall_1_1_1_0()); |
26876 | before(grammarAccess.getConjunctiveExpressionAccess().getChildrenComparisonExpressionParserRuleCall_1_1_1_0()); | ||
26877 | } | ||
26878 | pushFollow(FOLLOW_2); | 24629 | pushFollow(FOLLOW_2); |
26879 | ruleComparisonExpression(); | 24630 | ruleComparisonExpression(); |
26880 | 24631 | ||
26881 | state._fsp--; | 24632 | state._fsp--; |
26882 | if (state.failed) return ; | 24633 | |
26883 | if ( state.backtracking==0 ) { | 24634 | after(grammarAccess.getConjunctiveExpressionAccess().getChildrenComparisonExpressionParserRuleCall_1_1_1_0()); |
26884 | after(grammarAccess.getConjunctiveExpressionAccess().getChildrenComparisonExpressionParserRuleCall_1_1_1_0()); | ||
26885 | } | ||
26886 | 24635 | ||
26887 | } | 24636 | } |
26888 | 24637 | ||
@@ -26905,29 +24654,25 @@ public class InternalSolverLanguageParser extends AbstractInternalContentAssistP | |||
26905 | 24654 | ||
26906 | 24655 | ||
26907 | // $ANTLR start "rule__ComparisonExpression__OpAssignment_1_1" | 24656 | // $ANTLR start "rule__ComparisonExpression__OpAssignment_1_1" |
26908 | // InternalSolverLanguage.g:8188:1: rule__ComparisonExpression__OpAssignment_1_1 : ( ruleComparisonOperator ) ; | 24657 | // InternalSolverLanguageParser.g:8078:1: rule__ComparisonExpression__OpAssignment_1_1 : ( ruleComparisonOperator ) ; |
26909 | public final void rule__ComparisonExpression__OpAssignment_1_1() throws RecognitionException { | 24658 | public final void rule__ComparisonExpression__OpAssignment_1_1() throws RecognitionException { |
26910 | 24659 | ||
26911 | int stackSize = keepStackSize(); | 24660 | int stackSize = keepStackSize(); |
26912 | 24661 | ||
26913 | try { | 24662 | try { |
26914 | // InternalSolverLanguage.g:8192:1: ( ( ruleComparisonOperator ) ) | 24663 | // InternalSolverLanguageParser.g:8082:1: ( ( ruleComparisonOperator ) ) |
26915 | // InternalSolverLanguage.g:8193:2: ( ruleComparisonOperator ) | 24664 | // InternalSolverLanguageParser.g:8083:2: ( ruleComparisonOperator ) |
26916 | { | 24665 | { |
26917 | // InternalSolverLanguage.g:8193:2: ( ruleComparisonOperator ) | 24666 | // InternalSolverLanguageParser.g:8083:2: ( ruleComparisonOperator ) |
26918 | // InternalSolverLanguage.g:8194:3: ruleComparisonOperator | 24667 | // InternalSolverLanguageParser.g:8084:3: ruleComparisonOperator |
26919 | { | 24668 | { |
26920 | if ( state.backtracking==0 ) { | 24669 | before(grammarAccess.getComparisonExpressionAccess().getOpComparisonOperatorEnumRuleCall_1_1_0()); |
26921 | before(grammarAccess.getComparisonExpressionAccess().getOpComparisonOperatorEnumRuleCall_1_1_0()); | ||
26922 | } | ||
26923 | pushFollow(FOLLOW_2); | 24670 | pushFollow(FOLLOW_2); |
26924 | ruleComparisonOperator(); | 24671 | ruleComparisonOperator(); |
26925 | 24672 | ||
26926 | state._fsp--; | 24673 | state._fsp--; |
26927 | if (state.failed) return ; | 24674 | |
26928 | if ( state.backtracking==0 ) { | 24675 | after(grammarAccess.getComparisonExpressionAccess().getOpComparisonOperatorEnumRuleCall_1_1_0()); |
26929 | after(grammarAccess.getComparisonExpressionAccess().getOpComparisonOperatorEnumRuleCall_1_1_0()); | ||
26930 | } | ||
26931 | 24676 | ||
26932 | } | 24677 | } |
26933 | 24678 | ||
@@ -26950,29 +24695,25 @@ public class InternalSolverLanguageParser extends AbstractInternalContentAssistP | |||
26950 | 24695 | ||
26951 | 24696 | ||
26952 | // $ANTLR start "rule__ComparisonExpression__RightAssignment_1_2" | 24697 | // $ANTLR start "rule__ComparisonExpression__RightAssignment_1_2" |
26953 | // InternalSolverLanguage.g:8203:1: rule__ComparisonExpression__RightAssignment_1_2 : ( ruleAdditiveExpression ) ; | 24698 | // InternalSolverLanguageParser.g:8093:1: rule__ComparisonExpression__RightAssignment_1_2 : ( ruleAdditiveExpression ) ; |
26954 | public final void rule__ComparisonExpression__RightAssignment_1_2() throws RecognitionException { | 24699 | public final void rule__ComparisonExpression__RightAssignment_1_2() throws RecognitionException { |
26955 | 24700 | ||
26956 | int stackSize = keepStackSize(); | 24701 | int stackSize = keepStackSize(); |
26957 | 24702 | ||
26958 | try { | 24703 | try { |
26959 | // InternalSolverLanguage.g:8207:1: ( ( ruleAdditiveExpression ) ) | 24704 | // InternalSolverLanguageParser.g:8097:1: ( ( ruleAdditiveExpression ) ) |
26960 | // InternalSolverLanguage.g:8208:2: ( ruleAdditiveExpression ) | 24705 | // InternalSolverLanguageParser.g:8098:2: ( ruleAdditiveExpression ) |
26961 | { | 24706 | { |
26962 | // InternalSolverLanguage.g:8208:2: ( ruleAdditiveExpression ) | 24707 | // InternalSolverLanguageParser.g:8098:2: ( ruleAdditiveExpression ) |
26963 | // InternalSolverLanguage.g:8209:3: ruleAdditiveExpression | 24708 | // InternalSolverLanguageParser.g:8099:3: ruleAdditiveExpression |
26964 | { | 24709 | { |
26965 | if ( state.backtracking==0 ) { | 24710 | before(grammarAccess.getComparisonExpressionAccess().getRightAdditiveExpressionParserRuleCall_1_2_0()); |
26966 | before(grammarAccess.getComparisonExpressionAccess().getRightAdditiveExpressionParserRuleCall_1_2_0()); | ||
26967 | } | ||
26968 | pushFollow(FOLLOW_2); | 24711 | pushFollow(FOLLOW_2); |
26969 | ruleAdditiveExpression(); | 24712 | ruleAdditiveExpression(); |
26970 | 24713 | ||
26971 | state._fsp--; | 24714 | state._fsp--; |
26972 | if (state.failed) return ; | 24715 | |
26973 | if ( state.backtracking==0 ) { | 24716 | after(grammarAccess.getComparisonExpressionAccess().getRightAdditiveExpressionParserRuleCall_1_2_0()); |
26974 | after(grammarAccess.getComparisonExpressionAccess().getRightAdditiveExpressionParserRuleCall_1_2_0()); | ||
26975 | } | ||
26976 | 24717 | ||
26977 | } | 24718 | } |
26978 | 24719 | ||
@@ -26995,29 +24736,25 @@ public class InternalSolverLanguageParser extends AbstractInternalContentAssistP | |||
26995 | 24736 | ||
26996 | 24737 | ||
26997 | // $ANTLR start "rule__AdditiveExpression__OpAssignment_1_1" | 24738 | // $ANTLR start "rule__AdditiveExpression__OpAssignment_1_1" |
26998 | // InternalSolverLanguage.g:8218:1: rule__AdditiveExpression__OpAssignment_1_1 : ( ruleAdditiveBinaryOperator ) ; | 24739 | // InternalSolverLanguageParser.g:8108:1: rule__AdditiveExpression__OpAssignment_1_1 : ( ruleAdditiveBinaryOperator ) ; |
26999 | public final void rule__AdditiveExpression__OpAssignment_1_1() throws RecognitionException { | 24740 | public final void rule__AdditiveExpression__OpAssignment_1_1() throws RecognitionException { |
27000 | 24741 | ||
27001 | int stackSize = keepStackSize(); | 24742 | int stackSize = keepStackSize(); |
27002 | 24743 | ||
27003 | try { | 24744 | try { |
27004 | // InternalSolverLanguage.g:8222:1: ( ( ruleAdditiveBinaryOperator ) ) | 24745 | // InternalSolverLanguageParser.g:8112:1: ( ( ruleAdditiveBinaryOperator ) ) |
27005 | // InternalSolverLanguage.g:8223:2: ( ruleAdditiveBinaryOperator ) | 24746 | // InternalSolverLanguageParser.g:8113:2: ( ruleAdditiveBinaryOperator ) |
27006 | { | 24747 | { |
27007 | // InternalSolverLanguage.g:8223:2: ( ruleAdditiveBinaryOperator ) | 24748 | // InternalSolverLanguageParser.g:8113:2: ( ruleAdditiveBinaryOperator ) |
27008 | // InternalSolverLanguage.g:8224:3: ruleAdditiveBinaryOperator | 24749 | // InternalSolverLanguageParser.g:8114:3: ruleAdditiveBinaryOperator |
27009 | { | 24750 | { |
27010 | if ( state.backtracking==0 ) { | 24751 | before(grammarAccess.getAdditiveExpressionAccess().getOpAdditiveBinaryOperatorEnumRuleCall_1_1_0()); |
27011 | before(grammarAccess.getAdditiveExpressionAccess().getOpAdditiveBinaryOperatorEnumRuleCall_1_1_0()); | ||
27012 | } | ||
27013 | pushFollow(FOLLOW_2); | 24752 | pushFollow(FOLLOW_2); |
27014 | ruleAdditiveBinaryOperator(); | 24753 | ruleAdditiveBinaryOperator(); |
27015 | 24754 | ||
27016 | state._fsp--; | 24755 | state._fsp--; |
27017 | if (state.failed) return ; | 24756 | |
27018 | if ( state.backtracking==0 ) { | 24757 | after(grammarAccess.getAdditiveExpressionAccess().getOpAdditiveBinaryOperatorEnumRuleCall_1_1_0()); |
27019 | after(grammarAccess.getAdditiveExpressionAccess().getOpAdditiveBinaryOperatorEnumRuleCall_1_1_0()); | ||
27020 | } | ||
27021 | 24758 | ||
27022 | } | 24759 | } |
27023 | 24760 | ||
@@ -27040,29 +24777,25 @@ public class InternalSolverLanguageParser extends AbstractInternalContentAssistP | |||
27040 | 24777 | ||
27041 | 24778 | ||
27042 | // $ANTLR start "rule__AdditiveExpression__RightAssignment_1_2" | 24779 | // $ANTLR start "rule__AdditiveExpression__RightAssignment_1_2" |
27043 | // InternalSolverLanguage.g:8233:1: rule__AdditiveExpression__RightAssignment_1_2 : ( ruleMultiplicativeExpression ) ; | 24780 | // InternalSolverLanguageParser.g:8123:1: rule__AdditiveExpression__RightAssignment_1_2 : ( ruleMultiplicativeExpression ) ; |
27044 | public final void rule__AdditiveExpression__RightAssignment_1_2() throws RecognitionException { | 24781 | public final void rule__AdditiveExpression__RightAssignment_1_2() throws RecognitionException { |
27045 | 24782 | ||
27046 | int stackSize = keepStackSize(); | 24783 | int stackSize = keepStackSize(); |
27047 | 24784 | ||
27048 | try { | 24785 | try { |
27049 | // InternalSolverLanguage.g:8237:1: ( ( ruleMultiplicativeExpression ) ) | 24786 | // InternalSolverLanguageParser.g:8127:1: ( ( ruleMultiplicativeExpression ) ) |
27050 | // InternalSolverLanguage.g:8238:2: ( ruleMultiplicativeExpression ) | 24787 | // InternalSolverLanguageParser.g:8128:2: ( ruleMultiplicativeExpression ) |
27051 | { | 24788 | { |
27052 | // InternalSolverLanguage.g:8238:2: ( ruleMultiplicativeExpression ) | 24789 | // InternalSolverLanguageParser.g:8128:2: ( ruleMultiplicativeExpression ) |
27053 | // InternalSolverLanguage.g:8239:3: ruleMultiplicativeExpression | 24790 | // InternalSolverLanguageParser.g:8129:3: ruleMultiplicativeExpression |
27054 | { | 24791 | { |
27055 | if ( state.backtracking==0 ) { | 24792 | before(grammarAccess.getAdditiveExpressionAccess().getRightMultiplicativeExpressionParserRuleCall_1_2_0()); |
27056 | before(grammarAccess.getAdditiveExpressionAccess().getRightMultiplicativeExpressionParserRuleCall_1_2_0()); | ||
27057 | } | ||
27058 | pushFollow(FOLLOW_2); | 24793 | pushFollow(FOLLOW_2); |
27059 | ruleMultiplicativeExpression(); | 24794 | ruleMultiplicativeExpression(); |
27060 | 24795 | ||
27061 | state._fsp--; | 24796 | state._fsp--; |
27062 | if (state.failed) return ; | 24797 | |
27063 | if ( state.backtracking==0 ) { | 24798 | after(grammarAccess.getAdditiveExpressionAccess().getRightMultiplicativeExpressionParserRuleCall_1_2_0()); |
27064 | after(grammarAccess.getAdditiveExpressionAccess().getRightMultiplicativeExpressionParserRuleCall_1_2_0()); | ||
27065 | } | ||
27066 | 24799 | ||
27067 | } | 24800 | } |
27068 | 24801 | ||
@@ -27085,29 +24818,25 @@ public class InternalSolverLanguageParser extends AbstractInternalContentAssistP | |||
27085 | 24818 | ||
27086 | 24819 | ||
27087 | // $ANTLR start "rule__MultiplicativeExpression__OpAssignment_1_1" | 24820 | // $ANTLR start "rule__MultiplicativeExpression__OpAssignment_1_1" |
27088 | // InternalSolverLanguage.g:8248:1: rule__MultiplicativeExpression__OpAssignment_1_1 : ( ruleMultiplicativeBinaryOperator ) ; | 24821 | // InternalSolverLanguageParser.g:8138:1: rule__MultiplicativeExpression__OpAssignment_1_1 : ( ruleMultiplicativeBinaryOperator ) ; |
27089 | public final void rule__MultiplicativeExpression__OpAssignment_1_1() throws RecognitionException { | 24822 | public final void rule__MultiplicativeExpression__OpAssignment_1_1() throws RecognitionException { |
27090 | 24823 | ||
27091 | int stackSize = keepStackSize(); | 24824 | int stackSize = keepStackSize(); |
27092 | 24825 | ||
27093 | try { | 24826 | try { |
27094 | // InternalSolverLanguage.g:8252:1: ( ( ruleMultiplicativeBinaryOperator ) ) | 24827 | // InternalSolverLanguageParser.g:8142:1: ( ( ruleMultiplicativeBinaryOperator ) ) |
27095 | // InternalSolverLanguage.g:8253:2: ( ruleMultiplicativeBinaryOperator ) | 24828 | // InternalSolverLanguageParser.g:8143:2: ( ruleMultiplicativeBinaryOperator ) |
27096 | { | 24829 | { |
27097 | // InternalSolverLanguage.g:8253:2: ( ruleMultiplicativeBinaryOperator ) | 24830 | // InternalSolverLanguageParser.g:8143:2: ( ruleMultiplicativeBinaryOperator ) |
27098 | // InternalSolverLanguage.g:8254:3: ruleMultiplicativeBinaryOperator | 24831 | // InternalSolverLanguageParser.g:8144:3: ruleMultiplicativeBinaryOperator |
27099 | { | 24832 | { |
27100 | if ( state.backtracking==0 ) { | 24833 | before(grammarAccess.getMultiplicativeExpressionAccess().getOpMultiplicativeBinaryOperatorEnumRuleCall_1_1_0()); |
27101 | before(grammarAccess.getMultiplicativeExpressionAccess().getOpMultiplicativeBinaryOperatorEnumRuleCall_1_1_0()); | ||
27102 | } | ||
27103 | pushFollow(FOLLOW_2); | 24834 | pushFollow(FOLLOW_2); |
27104 | ruleMultiplicativeBinaryOperator(); | 24835 | ruleMultiplicativeBinaryOperator(); |
27105 | 24836 | ||
27106 | state._fsp--; | 24837 | state._fsp--; |
27107 | if (state.failed) return ; | 24838 | |
27108 | if ( state.backtracking==0 ) { | 24839 | after(grammarAccess.getMultiplicativeExpressionAccess().getOpMultiplicativeBinaryOperatorEnumRuleCall_1_1_0()); |
27109 | after(grammarAccess.getMultiplicativeExpressionAccess().getOpMultiplicativeBinaryOperatorEnumRuleCall_1_1_0()); | ||
27110 | } | ||
27111 | 24840 | ||
27112 | } | 24841 | } |
27113 | 24842 | ||
@@ -27130,29 +24859,25 @@ public class InternalSolverLanguageParser extends AbstractInternalContentAssistP | |||
27130 | 24859 | ||
27131 | 24860 | ||
27132 | // $ANTLR start "rule__MultiplicativeExpression__RightAssignment_1_2" | 24861 | // $ANTLR start "rule__MultiplicativeExpression__RightAssignment_1_2" |
27133 | // InternalSolverLanguage.g:8263:1: rule__MultiplicativeExpression__RightAssignment_1_2 : ( ruleExponentialExpression ) ; | 24862 | // InternalSolverLanguageParser.g:8153:1: rule__MultiplicativeExpression__RightAssignment_1_2 : ( ruleExponentialExpression ) ; |
27134 | public final void rule__MultiplicativeExpression__RightAssignment_1_2() throws RecognitionException { | 24863 | public final void rule__MultiplicativeExpression__RightAssignment_1_2() throws RecognitionException { |
27135 | 24864 | ||
27136 | int stackSize = keepStackSize(); | 24865 | int stackSize = keepStackSize(); |
27137 | 24866 | ||
27138 | try { | 24867 | try { |
27139 | // InternalSolverLanguage.g:8267:1: ( ( ruleExponentialExpression ) ) | 24868 | // InternalSolverLanguageParser.g:8157:1: ( ( ruleExponentialExpression ) ) |
27140 | // InternalSolverLanguage.g:8268:2: ( ruleExponentialExpression ) | 24869 | // InternalSolverLanguageParser.g:8158:2: ( ruleExponentialExpression ) |
27141 | { | 24870 | { |
27142 | // InternalSolverLanguage.g:8268:2: ( ruleExponentialExpression ) | 24871 | // InternalSolverLanguageParser.g:8158:2: ( ruleExponentialExpression ) |
27143 | // InternalSolverLanguage.g:8269:3: ruleExponentialExpression | 24872 | // InternalSolverLanguageParser.g:8159:3: ruleExponentialExpression |
27144 | { | 24873 | { |
27145 | if ( state.backtracking==0 ) { | 24874 | before(grammarAccess.getMultiplicativeExpressionAccess().getRightExponentialExpressionParserRuleCall_1_2_0()); |
27146 | before(grammarAccess.getMultiplicativeExpressionAccess().getRightExponentialExpressionParserRuleCall_1_2_0()); | ||
27147 | } | ||
27148 | pushFollow(FOLLOW_2); | 24875 | pushFollow(FOLLOW_2); |
27149 | ruleExponentialExpression(); | 24876 | ruleExponentialExpression(); |
27150 | 24877 | ||
27151 | state._fsp--; | 24878 | state._fsp--; |
27152 | if (state.failed) return ; | 24879 | |
27153 | if ( state.backtracking==0 ) { | 24880 | after(grammarAccess.getMultiplicativeExpressionAccess().getRightExponentialExpressionParserRuleCall_1_2_0()); |
27154 | after(grammarAccess.getMultiplicativeExpressionAccess().getRightExponentialExpressionParserRuleCall_1_2_0()); | ||
27155 | } | ||
27156 | 24881 | ||
27157 | } | 24882 | } |
27158 | 24883 | ||
@@ -27175,29 +24900,25 @@ public class InternalSolverLanguageParser extends AbstractInternalContentAssistP | |||
27175 | 24900 | ||
27176 | 24901 | ||
27177 | // $ANTLR start "rule__ExponentialExpression__OpAssignment_1_1" | 24902 | // $ANTLR start "rule__ExponentialExpression__OpAssignment_1_1" |
27178 | // InternalSolverLanguage.g:8278:1: rule__ExponentialExpression__OpAssignment_1_1 : ( ruleExponentialOp ) ; | 24903 | // InternalSolverLanguageParser.g:8168:1: rule__ExponentialExpression__OpAssignment_1_1 : ( ruleExponentialOp ) ; |
27179 | public final void rule__ExponentialExpression__OpAssignment_1_1() throws RecognitionException { | 24904 | public final void rule__ExponentialExpression__OpAssignment_1_1() throws RecognitionException { |
27180 | 24905 | ||
27181 | int stackSize = keepStackSize(); | 24906 | int stackSize = keepStackSize(); |
27182 | 24907 | ||
27183 | try { | 24908 | try { |
27184 | // InternalSolverLanguage.g:8282:1: ( ( ruleExponentialOp ) ) | 24909 | // InternalSolverLanguageParser.g:8172:1: ( ( ruleExponentialOp ) ) |
27185 | // InternalSolverLanguage.g:8283:2: ( ruleExponentialOp ) | 24910 | // InternalSolverLanguageParser.g:8173:2: ( ruleExponentialOp ) |
27186 | { | 24911 | { |
27187 | // InternalSolverLanguage.g:8283:2: ( ruleExponentialOp ) | 24912 | // InternalSolverLanguageParser.g:8173:2: ( ruleExponentialOp ) |
27188 | // InternalSolverLanguage.g:8284:3: ruleExponentialOp | 24913 | // InternalSolverLanguageParser.g:8174:3: ruleExponentialOp |
27189 | { | 24914 | { |
27190 | if ( state.backtracking==0 ) { | 24915 | before(grammarAccess.getExponentialExpressionAccess().getOpExponentialOpEnumRuleCall_1_1_0()); |
27191 | before(grammarAccess.getExponentialExpressionAccess().getOpExponentialOpEnumRuleCall_1_1_0()); | ||
27192 | } | ||
27193 | pushFollow(FOLLOW_2); | 24916 | pushFollow(FOLLOW_2); |
27194 | ruleExponentialOp(); | 24917 | ruleExponentialOp(); |
27195 | 24918 | ||
27196 | state._fsp--; | 24919 | state._fsp--; |
27197 | if (state.failed) return ; | 24920 | |
27198 | if ( state.backtracking==0 ) { | 24921 | after(grammarAccess.getExponentialExpressionAccess().getOpExponentialOpEnumRuleCall_1_1_0()); |
27199 | after(grammarAccess.getExponentialExpressionAccess().getOpExponentialOpEnumRuleCall_1_1_0()); | ||
27200 | } | ||
27201 | 24922 | ||
27202 | } | 24923 | } |
27203 | 24924 | ||
@@ -27220,29 +24941,25 @@ public class InternalSolverLanguageParser extends AbstractInternalContentAssistP | |||
27220 | 24941 | ||
27221 | 24942 | ||
27222 | // $ANTLR start "rule__ExponentialExpression__RightAssignment_1_2" | 24943 | // $ANTLR start "rule__ExponentialExpression__RightAssignment_1_2" |
27223 | // InternalSolverLanguage.g:8293:1: rule__ExponentialExpression__RightAssignment_1_2 : ( ruleExponentialExpression ) ; | 24944 | // InternalSolverLanguageParser.g:8183:1: rule__ExponentialExpression__RightAssignment_1_2 : ( ruleExponentialExpression ) ; |
27224 | public final void rule__ExponentialExpression__RightAssignment_1_2() throws RecognitionException { | 24945 | public final void rule__ExponentialExpression__RightAssignment_1_2() throws RecognitionException { |
27225 | 24946 | ||
27226 | int stackSize = keepStackSize(); | 24947 | int stackSize = keepStackSize(); |
27227 | 24948 | ||
27228 | try { | 24949 | try { |
27229 | // InternalSolverLanguage.g:8297:1: ( ( ruleExponentialExpression ) ) | 24950 | // InternalSolverLanguageParser.g:8187:1: ( ( ruleExponentialExpression ) ) |
27230 | // InternalSolverLanguage.g:8298:2: ( ruleExponentialExpression ) | 24951 | // InternalSolverLanguageParser.g:8188:2: ( ruleExponentialExpression ) |
27231 | { | 24952 | { |
27232 | // InternalSolverLanguage.g:8298:2: ( ruleExponentialExpression ) | 24953 | // InternalSolverLanguageParser.g:8188:2: ( ruleExponentialExpression ) |
27233 | // InternalSolverLanguage.g:8299:3: ruleExponentialExpression | 24954 | // InternalSolverLanguageParser.g:8189:3: ruleExponentialExpression |
27234 | { | 24955 | { |
27235 | if ( state.backtracking==0 ) { | 24956 | before(grammarAccess.getExponentialExpressionAccess().getRightExponentialExpressionParserRuleCall_1_2_0()); |
27236 | before(grammarAccess.getExponentialExpressionAccess().getRightExponentialExpressionParserRuleCall_1_2_0()); | ||
27237 | } | ||
27238 | pushFollow(FOLLOW_2); | 24957 | pushFollow(FOLLOW_2); |
27239 | ruleExponentialExpression(); | 24958 | ruleExponentialExpression(); |
27240 | 24959 | ||
27241 | state._fsp--; | 24960 | state._fsp--; |
27242 | if (state.failed) return ; | 24961 | |
27243 | if ( state.backtracking==0 ) { | 24962 | after(grammarAccess.getExponentialExpressionAccess().getRightExponentialExpressionParserRuleCall_1_2_0()); |
27244 | after(grammarAccess.getExponentialExpressionAccess().getRightExponentialExpressionParserRuleCall_1_2_0()); | ||
27245 | } | ||
27246 | 24963 | ||
27247 | } | 24964 | } |
27248 | 24965 | ||
@@ -27265,29 +24982,25 @@ public class InternalSolverLanguageParser extends AbstractInternalContentAssistP | |||
27265 | 24982 | ||
27266 | 24983 | ||
27267 | // $ANTLR start "rule__UnaryExpression__OpAssignment_1_1" | 24984 | // $ANTLR start "rule__UnaryExpression__OpAssignment_1_1" |
27268 | // InternalSolverLanguage.g:8308:1: rule__UnaryExpression__OpAssignment_1_1 : ( ruleUnaryOp ) ; | 24985 | // InternalSolverLanguageParser.g:8198:1: rule__UnaryExpression__OpAssignment_1_1 : ( ruleUnaryOp ) ; |
27269 | public final void rule__UnaryExpression__OpAssignment_1_1() throws RecognitionException { | 24986 | public final void rule__UnaryExpression__OpAssignment_1_1() throws RecognitionException { |
27270 | 24987 | ||
27271 | int stackSize = keepStackSize(); | 24988 | int stackSize = keepStackSize(); |
27272 | 24989 | ||
27273 | try { | 24990 | try { |
27274 | // InternalSolverLanguage.g:8312:1: ( ( ruleUnaryOp ) ) | 24991 | // InternalSolverLanguageParser.g:8202:1: ( ( ruleUnaryOp ) ) |
27275 | // InternalSolverLanguage.g:8313:2: ( ruleUnaryOp ) | 24992 | // InternalSolverLanguageParser.g:8203:2: ( ruleUnaryOp ) |
27276 | { | 24993 | { |
27277 | // InternalSolverLanguage.g:8313:2: ( ruleUnaryOp ) | 24994 | // InternalSolverLanguageParser.g:8203:2: ( ruleUnaryOp ) |
27278 | // InternalSolverLanguage.g:8314:3: ruleUnaryOp | 24995 | // InternalSolverLanguageParser.g:8204:3: ruleUnaryOp |
27279 | { | 24996 | { |
27280 | if ( state.backtracking==0 ) { | 24997 | before(grammarAccess.getUnaryExpressionAccess().getOpUnaryOpEnumRuleCall_1_1_0()); |
27281 | before(grammarAccess.getUnaryExpressionAccess().getOpUnaryOpEnumRuleCall_1_1_0()); | ||
27282 | } | ||
27283 | pushFollow(FOLLOW_2); | 24998 | pushFollow(FOLLOW_2); |
27284 | ruleUnaryOp(); | 24999 | ruleUnaryOp(); |
27285 | 25000 | ||
27286 | state._fsp--; | 25001 | state._fsp--; |
27287 | if (state.failed) return ; | 25002 | |
27288 | if ( state.backtracking==0 ) { | 25003 | after(grammarAccess.getUnaryExpressionAccess().getOpUnaryOpEnumRuleCall_1_1_0()); |
27289 | after(grammarAccess.getUnaryExpressionAccess().getOpUnaryOpEnumRuleCall_1_1_0()); | ||
27290 | } | ||
27291 | 25004 | ||
27292 | } | 25005 | } |
27293 | 25006 | ||
@@ -27310,29 +25023,25 @@ public class InternalSolverLanguageParser extends AbstractInternalContentAssistP | |||
27310 | 25023 | ||
27311 | 25024 | ||
27312 | // $ANTLR start "rule__UnaryExpression__BodyAssignment_1_2" | 25025 | // $ANTLR start "rule__UnaryExpression__BodyAssignment_1_2" |
27313 | // InternalSolverLanguage.g:8323:1: rule__UnaryExpression__BodyAssignment_1_2 : ( ruleAggregationExpression ) ; | 25026 | // InternalSolverLanguageParser.g:8213:1: rule__UnaryExpression__BodyAssignment_1_2 : ( ruleAggregationExpression ) ; |
27314 | public final void rule__UnaryExpression__BodyAssignment_1_2() throws RecognitionException { | 25027 | public final void rule__UnaryExpression__BodyAssignment_1_2() throws RecognitionException { |
27315 | 25028 | ||
27316 | int stackSize = keepStackSize(); | 25029 | int stackSize = keepStackSize(); |
27317 | 25030 | ||
27318 | try { | 25031 | try { |
27319 | // InternalSolverLanguage.g:8327:1: ( ( ruleAggregationExpression ) ) | 25032 | // InternalSolverLanguageParser.g:8217:1: ( ( ruleAggregationExpression ) ) |
27320 | // InternalSolverLanguage.g:8328:2: ( ruleAggregationExpression ) | 25033 | // InternalSolverLanguageParser.g:8218:2: ( ruleAggregationExpression ) |
27321 | { | 25034 | { |
27322 | // InternalSolverLanguage.g:8328:2: ( ruleAggregationExpression ) | 25035 | // InternalSolverLanguageParser.g:8218:2: ( ruleAggregationExpression ) |
27323 | // InternalSolverLanguage.g:8329:3: ruleAggregationExpression | 25036 | // InternalSolverLanguageParser.g:8219:3: ruleAggregationExpression |
27324 | { | 25037 | { |
27325 | if ( state.backtracking==0 ) { | 25038 | before(grammarAccess.getUnaryExpressionAccess().getBodyAggregationExpressionParserRuleCall_1_2_0()); |
27326 | before(grammarAccess.getUnaryExpressionAccess().getBodyAggregationExpressionParserRuleCall_1_2_0()); | ||
27327 | } | ||
27328 | pushFollow(FOLLOW_2); | 25039 | pushFollow(FOLLOW_2); |
27329 | ruleAggregationExpression(); | 25040 | ruleAggregationExpression(); |
27330 | 25041 | ||
27331 | state._fsp--; | 25042 | state._fsp--; |
27332 | if (state.failed) return ; | 25043 | |
27333 | if ( state.backtracking==0 ) { | 25044 | after(grammarAccess.getUnaryExpressionAccess().getBodyAggregationExpressionParserRuleCall_1_2_0()); |
27334 | after(grammarAccess.getUnaryExpressionAccess().getBodyAggregationExpressionParserRuleCall_1_2_0()); | ||
27335 | } | ||
27336 | 25045 | ||
27337 | } | 25046 | } |
27338 | 25047 | ||
@@ -27355,29 +25064,25 @@ public class InternalSolverLanguageParser extends AbstractInternalContentAssistP | |||
27355 | 25064 | ||
27356 | 25065 | ||
27357 | // $ANTLR start "rule__Count__BodyAssignment_2" | 25066 | // $ANTLR start "rule__Count__BodyAssignment_2" |
27358 | // InternalSolverLanguage.g:8338:1: rule__Count__BodyAssignment_2 : ( ruleExpression ) ; | 25067 | // InternalSolverLanguageParser.g:8228:1: rule__Count__BodyAssignment_2 : ( ruleExpression ) ; |
27359 | public final void rule__Count__BodyAssignment_2() throws RecognitionException { | 25068 | public final void rule__Count__BodyAssignment_2() throws RecognitionException { |
27360 | 25069 | ||
27361 | int stackSize = keepStackSize(); | 25070 | int stackSize = keepStackSize(); |
27362 | 25071 | ||
27363 | try { | 25072 | try { |
27364 | // InternalSolverLanguage.g:8342:1: ( ( ruleExpression ) ) | 25073 | // InternalSolverLanguageParser.g:8232:1: ( ( ruleExpression ) ) |
27365 | // InternalSolverLanguage.g:8343:2: ( ruleExpression ) | 25074 | // InternalSolverLanguageParser.g:8233:2: ( ruleExpression ) |
27366 | { | 25075 | { |
27367 | // InternalSolverLanguage.g:8343:2: ( ruleExpression ) | 25076 | // InternalSolverLanguageParser.g:8233:2: ( ruleExpression ) |
27368 | // InternalSolverLanguage.g:8344:3: ruleExpression | 25077 | // InternalSolverLanguageParser.g:8234:3: ruleExpression |
27369 | { | 25078 | { |
27370 | if ( state.backtracking==0 ) { | 25079 | before(grammarAccess.getCountAccess().getBodyExpressionParserRuleCall_2_0()); |
27371 | before(grammarAccess.getCountAccess().getBodyExpressionParserRuleCall_2_0()); | ||
27372 | } | ||
27373 | pushFollow(FOLLOW_2); | 25080 | pushFollow(FOLLOW_2); |
27374 | ruleExpression(); | 25081 | ruleExpression(); |
27375 | 25082 | ||
27376 | state._fsp--; | 25083 | state._fsp--; |
27377 | if (state.failed) return ; | 25084 | |
27378 | if ( state.backtracking==0 ) { | 25085 | after(grammarAccess.getCountAccess().getBodyExpressionParserRuleCall_2_0()); |
27379 | after(grammarAccess.getCountAccess().getBodyExpressionParserRuleCall_2_0()); | ||
27380 | } | ||
27381 | 25086 | ||
27382 | } | 25087 | } |
27383 | 25088 | ||
@@ -27400,29 +25105,25 @@ public class InternalSolverLanguageParser extends AbstractInternalContentAssistP | |||
27400 | 25105 | ||
27401 | 25106 | ||
27402 | // $ANTLR start "rule__Aggregation__OpAssignment_0" | 25107 | // $ANTLR start "rule__Aggregation__OpAssignment_0" |
27403 | // InternalSolverLanguage.g:8353:1: rule__Aggregation__OpAssignment_0 : ( ruleAggregationOp ) ; | 25108 | // InternalSolverLanguageParser.g:8243:1: rule__Aggregation__OpAssignment_0 : ( ruleAggregationOp ) ; |
27404 | public final void rule__Aggregation__OpAssignment_0() throws RecognitionException { | 25109 | public final void rule__Aggregation__OpAssignment_0() throws RecognitionException { |
27405 | 25110 | ||
27406 | int stackSize = keepStackSize(); | 25111 | int stackSize = keepStackSize(); |
27407 | 25112 | ||
27408 | try { | 25113 | try { |
27409 | // InternalSolverLanguage.g:8357:1: ( ( ruleAggregationOp ) ) | 25114 | // InternalSolverLanguageParser.g:8247:1: ( ( ruleAggregationOp ) ) |
27410 | // InternalSolverLanguage.g:8358:2: ( ruleAggregationOp ) | 25115 | // InternalSolverLanguageParser.g:8248:2: ( ruleAggregationOp ) |
27411 | { | 25116 | { |
27412 | // InternalSolverLanguage.g:8358:2: ( ruleAggregationOp ) | 25117 | // InternalSolverLanguageParser.g:8248:2: ( ruleAggregationOp ) |
27413 | // InternalSolverLanguage.g:8359:3: ruleAggregationOp | 25118 | // InternalSolverLanguageParser.g:8249:3: ruleAggregationOp |
27414 | { | 25119 | { |
27415 | if ( state.backtracking==0 ) { | 25120 | before(grammarAccess.getAggregationAccess().getOpAggregationOpEnumRuleCall_0_0()); |
27416 | before(grammarAccess.getAggregationAccess().getOpAggregationOpEnumRuleCall_0_0()); | ||
27417 | } | ||
27418 | pushFollow(FOLLOW_2); | 25121 | pushFollow(FOLLOW_2); |
27419 | ruleAggregationOp(); | 25122 | ruleAggregationOp(); |
27420 | 25123 | ||
27421 | state._fsp--; | 25124 | state._fsp--; |
27422 | if (state.failed) return ; | 25125 | |
27423 | if ( state.backtracking==0 ) { | 25126 | after(grammarAccess.getAggregationAccess().getOpAggregationOpEnumRuleCall_0_0()); |
27424 | after(grammarAccess.getAggregationAccess().getOpAggregationOpEnumRuleCall_0_0()); | ||
27425 | } | ||
27426 | 25127 | ||
27427 | } | 25128 | } |
27428 | 25129 | ||
@@ -27445,29 +25146,25 @@ public class InternalSolverLanguageParser extends AbstractInternalContentAssistP | |||
27445 | 25146 | ||
27446 | 25147 | ||
27447 | // $ANTLR start "rule__Aggregation__BodyAssignment_2" | 25148 | // $ANTLR start "rule__Aggregation__BodyAssignment_2" |
27448 | // InternalSolverLanguage.g:8368:1: rule__Aggregation__BodyAssignment_2 : ( ruleExpression ) ; | 25149 | // InternalSolverLanguageParser.g:8258:1: rule__Aggregation__BodyAssignment_2 : ( ruleExpression ) ; |
27449 | public final void rule__Aggregation__BodyAssignment_2() throws RecognitionException { | 25150 | public final void rule__Aggregation__BodyAssignment_2() throws RecognitionException { |
27450 | 25151 | ||
27451 | int stackSize = keepStackSize(); | 25152 | int stackSize = keepStackSize(); |
27452 | 25153 | ||
27453 | try { | 25154 | try { |
27454 | // InternalSolverLanguage.g:8372:1: ( ( ruleExpression ) ) | 25155 | // InternalSolverLanguageParser.g:8262:1: ( ( ruleExpression ) ) |
27455 | // InternalSolverLanguage.g:8373:2: ( ruleExpression ) | 25156 | // InternalSolverLanguageParser.g:8263:2: ( ruleExpression ) |
27456 | { | 25157 | { |
27457 | // InternalSolverLanguage.g:8373:2: ( ruleExpression ) | 25158 | // InternalSolverLanguageParser.g:8263:2: ( ruleExpression ) |
27458 | // InternalSolverLanguage.g:8374:3: ruleExpression | 25159 | // InternalSolverLanguageParser.g:8264:3: ruleExpression |
27459 | { | 25160 | { |
27460 | if ( state.backtracking==0 ) { | 25161 | before(grammarAccess.getAggregationAccess().getBodyExpressionParserRuleCall_2_0()); |
27461 | before(grammarAccess.getAggregationAccess().getBodyExpressionParserRuleCall_2_0()); | ||
27462 | } | ||
27463 | pushFollow(FOLLOW_2); | 25162 | pushFollow(FOLLOW_2); |
27464 | ruleExpression(); | 25163 | ruleExpression(); |
27465 | 25164 | ||
27466 | state._fsp--; | 25165 | state._fsp--; |
27467 | if (state.failed) return ; | 25166 | |
27468 | if ( state.backtracking==0 ) { | 25167 | after(grammarAccess.getAggregationAccess().getBodyExpressionParserRuleCall_2_0()); |
27469 | after(grammarAccess.getAggregationAccess().getBodyExpressionParserRuleCall_2_0()); | ||
27470 | } | ||
27471 | 25168 | ||
27472 | } | 25169 | } |
27473 | 25170 | ||
@@ -27490,74 +25187,25 @@ public class InternalSolverLanguageParser extends AbstractInternalContentAssistP | |||
27490 | 25187 | ||
27491 | 25188 | ||
27492 | // $ANTLR start "rule__Aggregation__ConditionAssignment_4" | 25189 | // $ANTLR start "rule__Aggregation__ConditionAssignment_4" |
27493 | // InternalSolverLanguage.g:8383:1: rule__Aggregation__ConditionAssignment_4 : ( ruleExpression ) ; | 25190 | // InternalSolverLanguageParser.g:8273:1: rule__Aggregation__ConditionAssignment_4 : ( ruleExpression ) ; |
27494 | public final void rule__Aggregation__ConditionAssignment_4() throws RecognitionException { | 25191 | public final void rule__Aggregation__ConditionAssignment_4() throws RecognitionException { |
27495 | 25192 | ||
27496 | int stackSize = keepStackSize(); | 25193 | int stackSize = keepStackSize(); |
27497 | 25194 | ||
27498 | try { | 25195 | try { |
27499 | // InternalSolverLanguage.g:8387:1: ( ( ruleExpression ) ) | 25196 | // InternalSolverLanguageParser.g:8277:1: ( ( ruleExpression ) ) |
27500 | // InternalSolverLanguage.g:8388:2: ( ruleExpression ) | 25197 | // InternalSolverLanguageParser.g:8278:2: ( ruleExpression ) |
27501 | { | 25198 | { |
27502 | // InternalSolverLanguage.g:8388:2: ( ruleExpression ) | 25199 | // InternalSolverLanguageParser.g:8278:2: ( ruleExpression ) |
27503 | // InternalSolverLanguage.g:8389:3: ruleExpression | 25200 | // InternalSolverLanguageParser.g:8279:3: ruleExpression |
27504 | { | 25201 | { |
27505 | if ( state.backtracking==0 ) { | 25202 | before(grammarAccess.getAggregationAccess().getConditionExpressionParserRuleCall_4_0()); |
27506 | before(grammarAccess.getAggregationAccess().getConditionExpressionParserRuleCall_4_0()); | ||
27507 | } | ||
27508 | pushFollow(FOLLOW_2); | 25203 | pushFollow(FOLLOW_2); |
27509 | ruleExpression(); | 25204 | ruleExpression(); |
27510 | 25205 | ||
27511 | state._fsp--; | 25206 | state._fsp--; |
27512 | if (state.failed) return ; | ||
27513 | if ( state.backtracking==0 ) { | ||
27514 | after(grammarAccess.getAggregationAccess().getConditionExpressionParserRuleCall_4_0()); | ||
27515 | } | ||
27516 | |||
27517 | } | ||
27518 | 25207 | ||
27519 | 25208 | after(grammarAccess.getAggregationAccess().getConditionExpressionParserRuleCall_4_0()); | |
27520 | } | ||
27521 | |||
27522 | } | ||
27523 | catch (RecognitionException re) { | ||
27524 | reportError(re); | ||
27525 | recover(input,re); | ||
27526 | } | ||
27527 | finally { | ||
27528 | |||
27529 | restoreStackSize(stackSize); | ||
27530 | |||
27531 | } | ||
27532 | return ; | ||
27533 | } | ||
27534 | // $ANTLR end "rule__Aggregation__ConditionAssignment_4" | ||
27535 | |||
27536 | |||
27537 | // $ANTLR start "rule__AtomicExpression__ArgumentListAssignment_0_1_1" | ||
27538 | // InternalSolverLanguage.g:8398:1: rule__AtomicExpression__ArgumentListAssignment_0_1_1 : ( ruleArgumentList ) ; | ||
27539 | public final void rule__AtomicExpression__ArgumentListAssignment_0_1_1() throws RecognitionException { | ||
27540 | |||
27541 | int stackSize = keepStackSize(); | ||
27542 | |||
27543 | try { | ||
27544 | // InternalSolverLanguage.g:8402:1: ( ( ruleArgumentList ) ) | ||
27545 | // InternalSolverLanguage.g:8403:2: ( ruleArgumentList ) | ||
27546 | { | ||
27547 | // InternalSolverLanguage.g:8403:2: ( ruleArgumentList ) | ||
27548 | // InternalSolverLanguage.g:8404:3: ruleArgumentList | ||
27549 | { | ||
27550 | if ( state.backtracking==0 ) { | ||
27551 | before(grammarAccess.getAtomicExpressionAccess().getArgumentListArgumentListParserRuleCall_0_1_1_0()); | ||
27552 | } | ||
27553 | pushFollow(FOLLOW_2); | ||
27554 | ruleArgumentList(); | ||
27555 | |||
27556 | state._fsp--; | ||
27557 | if (state.failed) return ; | ||
27558 | if ( state.backtracking==0 ) { | ||
27559 | after(grammarAccess.getAtomicExpressionAccess().getArgumentListArgumentListParserRuleCall_0_1_1_0()); | ||
27560 | } | ||
27561 | 25209 | ||
27562 | } | 25210 | } |
27563 | 25211 | ||
@@ -27576,33 +25224,29 @@ public class InternalSolverLanguageParser extends AbstractInternalContentAssistP | |||
27576 | } | 25224 | } |
27577 | return ; | 25225 | return ; |
27578 | } | 25226 | } |
27579 | // $ANTLR end "rule__AtomicExpression__ArgumentListAssignment_0_1_1" | 25227 | // $ANTLR end "rule__Aggregation__ConditionAssignment_4" |
27580 | 25228 | ||
27581 | 25229 | ||
27582 | // $ANTLR start "rule__Call__FunctorAssignment_0" | 25230 | // $ANTLR start "rule__Call__FunctorAssignment_0" |
27583 | // InternalSolverLanguage.g:8413:1: rule__Call__FunctorAssignment_0 : ( ruleReference ) ; | 25231 | // InternalSolverLanguageParser.g:8288:1: rule__Call__FunctorAssignment_0 : ( ruleReference ) ; |
27584 | public final void rule__Call__FunctorAssignment_0() throws RecognitionException { | 25232 | public final void rule__Call__FunctorAssignment_0() throws RecognitionException { |
27585 | 25233 | ||
27586 | int stackSize = keepStackSize(); | 25234 | int stackSize = keepStackSize(); |
27587 | 25235 | ||
27588 | try { | 25236 | try { |
27589 | // InternalSolverLanguage.g:8417:1: ( ( ruleReference ) ) | 25237 | // InternalSolverLanguageParser.g:8292:1: ( ( ruleReference ) ) |
27590 | // InternalSolverLanguage.g:8418:2: ( ruleReference ) | 25238 | // InternalSolverLanguageParser.g:8293:2: ( ruleReference ) |
27591 | { | 25239 | { |
27592 | // InternalSolverLanguage.g:8418:2: ( ruleReference ) | 25240 | // InternalSolverLanguageParser.g:8293:2: ( ruleReference ) |
27593 | // InternalSolverLanguage.g:8419:3: ruleReference | 25241 | // InternalSolverLanguageParser.g:8294:3: ruleReference |
27594 | { | 25242 | { |
27595 | if ( state.backtracking==0 ) { | 25243 | before(grammarAccess.getCallAccess().getFunctorReferenceParserRuleCall_0_0()); |
27596 | before(grammarAccess.getCallAccess().getFunctorReferenceParserRuleCall_0_0()); | ||
27597 | } | ||
27598 | pushFollow(FOLLOW_2); | 25244 | pushFollow(FOLLOW_2); |
27599 | ruleReference(); | 25245 | ruleReference(); |
27600 | 25246 | ||
27601 | state._fsp--; | 25247 | state._fsp--; |
27602 | if (state.failed) return ; | 25248 | |
27603 | if ( state.backtracking==0 ) { | 25249 | after(grammarAccess.getCallAccess().getFunctorReferenceParserRuleCall_0_0()); |
27604 | after(grammarAccess.getCallAccess().getFunctorReferenceParserRuleCall_0_0()); | ||
27605 | } | ||
27606 | 25250 | ||
27607 | } | 25251 | } |
27608 | 25252 | ||
@@ -27625,25 +25269,21 @@ public class InternalSolverLanguageParser extends AbstractInternalContentAssistP | |||
27625 | 25269 | ||
27626 | 25270 | ||
27627 | // $ANTLR start "rule__Call__TransitiveClosureAssignment_1_0" | 25271 | // $ANTLR start "rule__Call__TransitiveClosureAssignment_1_0" |
27628 | // InternalSolverLanguage.g:8428:1: rule__Call__TransitiveClosureAssignment_1_0 : ( RULE_STAR ) ; | 25272 | // InternalSolverLanguageParser.g:8303:1: rule__Call__TransitiveClosureAssignment_1_0 : ( RULE_TRANSITIVE_CLOSURE ) ; |
27629 | public final void rule__Call__TransitiveClosureAssignment_1_0() throws RecognitionException { | 25273 | public final void rule__Call__TransitiveClosureAssignment_1_0() throws RecognitionException { |
27630 | 25274 | ||
27631 | int stackSize = keepStackSize(); | 25275 | int stackSize = keepStackSize(); |
27632 | 25276 | ||
27633 | try { | 25277 | try { |
27634 | // InternalSolverLanguage.g:8432:1: ( ( RULE_STAR ) ) | 25278 | // InternalSolverLanguageParser.g:8307:1: ( ( RULE_TRANSITIVE_CLOSURE ) ) |
27635 | // InternalSolverLanguage.g:8433:2: ( RULE_STAR ) | 25279 | // InternalSolverLanguageParser.g:8308:2: ( RULE_TRANSITIVE_CLOSURE ) |
27636 | { | 25280 | { |
27637 | // InternalSolverLanguage.g:8433:2: ( RULE_STAR ) | 25281 | // InternalSolverLanguageParser.g:8308:2: ( RULE_TRANSITIVE_CLOSURE ) |
27638 | // InternalSolverLanguage.g:8434:3: RULE_STAR | 25282 | // InternalSolverLanguageParser.g:8309:3: RULE_TRANSITIVE_CLOSURE |
27639 | { | 25283 | { |
27640 | if ( state.backtracking==0 ) { | 25284 | before(grammarAccess.getCallAccess().getTransitiveClosureTRANSITIVE_CLOSURETerminalRuleCall_1_0_0()); |
27641 | before(grammarAccess.getCallAccess().getTransitiveClosureSTARTerminalRuleCall_1_0_0()); | 25285 | match(input,RULE_TRANSITIVE_CLOSURE,FOLLOW_2); |
27642 | } | 25286 | after(grammarAccess.getCallAccess().getTransitiveClosureTRANSITIVE_CLOSURETerminalRuleCall_1_0_0()); |
27643 | match(input,RULE_STAR,FOLLOW_2); if (state.failed) return ; | ||
27644 | if ( state.backtracking==0 ) { | ||
27645 | after(grammarAccess.getCallAccess().getTransitiveClosureSTARTerminalRuleCall_1_0_0()); | ||
27646 | } | ||
27647 | 25287 | ||
27648 | } | 25288 | } |
27649 | 25289 | ||
@@ -27666,25 +25306,21 @@ public class InternalSolverLanguageParser extends AbstractInternalContentAssistP | |||
27666 | 25306 | ||
27667 | 25307 | ||
27668 | // $ANTLR start "rule__Call__ReflexiveTransitiveClosureAssignment_1_1" | 25308 | // $ANTLR start "rule__Call__ReflexiveTransitiveClosureAssignment_1_1" |
27669 | // InternalSolverLanguage.g:8443:1: rule__Call__ReflexiveTransitiveClosureAssignment_1_1 : ( RULE_PLUS ) ; | 25309 | // InternalSolverLanguageParser.g:8318:1: rule__Call__ReflexiveTransitiveClosureAssignment_1_1 : ( RULE_REFLEXIVE_TRANSITIVE_CLOSURE ) ; |
27670 | public final void rule__Call__ReflexiveTransitiveClosureAssignment_1_1() throws RecognitionException { | 25310 | public final void rule__Call__ReflexiveTransitiveClosureAssignment_1_1() throws RecognitionException { |
27671 | 25311 | ||
27672 | int stackSize = keepStackSize(); | 25312 | int stackSize = keepStackSize(); |
27673 | 25313 | ||
27674 | try { | 25314 | try { |
27675 | // InternalSolverLanguage.g:8447:1: ( ( RULE_PLUS ) ) | 25315 | // InternalSolverLanguageParser.g:8322:1: ( ( RULE_REFLEXIVE_TRANSITIVE_CLOSURE ) ) |
27676 | // InternalSolverLanguage.g:8448:2: ( RULE_PLUS ) | 25316 | // InternalSolverLanguageParser.g:8323:2: ( RULE_REFLEXIVE_TRANSITIVE_CLOSURE ) |
27677 | { | 25317 | { |
27678 | // InternalSolverLanguage.g:8448:2: ( RULE_PLUS ) | 25318 | // InternalSolverLanguageParser.g:8323:2: ( RULE_REFLEXIVE_TRANSITIVE_CLOSURE ) |
27679 | // InternalSolverLanguage.g:8449:3: RULE_PLUS | 25319 | // InternalSolverLanguageParser.g:8324:3: RULE_REFLEXIVE_TRANSITIVE_CLOSURE |
27680 | { | 25320 | { |
27681 | if ( state.backtracking==0 ) { | 25321 | before(grammarAccess.getCallAccess().getReflexiveTransitiveClosureREFLEXIVE_TRANSITIVE_CLOSURETerminalRuleCall_1_1_0()); |
27682 | before(grammarAccess.getCallAccess().getReflexiveTransitiveClosurePLUSTerminalRuleCall_1_1_0()); | 25322 | match(input,RULE_REFLEXIVE_TRANSITIVE_CLOSURE,FOLLOW_2); |
27683 | } | 25323 | after(grammarAccess.getCallAccess().getReflexiveTransitiveClosureREFLEXIVE_TRANSITIVE_CLOSURETerminalRuleCall_1_1_0()); |
27684 | match(input,RULE_PLUS,FOLLOW_2); if (state.failed) return ; | ||
27685 | if ( state.backtracking==0 ) { | ||
27686 | after(grammarAccess.getCallAccess().getReflexiveTransitiveClosurePLUSTerminalRuleCall_1_1_0()); | ||
27687 | } | ||
27688 | 25324 | ||
27689 | } | 25325 | } |
27690 | 25326 | ||
@@ -27707,29 +25343,25 @@ public class InternalSolverLanguageParser extends AbstractInternalContentAssistP | |||
27707 | 25343 | ||
27708 | 25344 | ||
27709 | // $ANTLR start "rule__Call__ArgumentListAssignment_2" | 25345 | // $ANTLR start "rule__Call__ArgumentListAssignment_2" |
27710 | // InternalSolverLanguage.g:8458:1: rule__Call__ArgumentListAssignment_2 : ( ruleArgumentList ) ; | 25346 | // InternalSolverLanguageParser.g:8333:1: rule__Call__ArgumentListAssignment_2 : ( ruleArgumentList ) ; |
27711 | public final void rule__Call__ArgumentListAssignment_2() throws RecognitionException { | 25347 | public final void rule__Call__ArgumentListAssignment_2() throws RecognitionException { |
27712 | 25348 | ||
27713 | int stackSize = keepStackSize(); | 25349 | int stackSize = keepStackSize(); |
27714 | 25350 | ||
27715 | try { | 25351 | try { |
27716 | // InternalSolverLanguage.g:8462:1: ( ( ruleArgumentList ) ) | 25352 | // InternalSolverLanguageParser.g:8337:1: ( ( ruleArgumentList ) ) |
27717 | // InternalSolverLanguage.g:8463:2: ( ruleArgumentList ) | 25353 | // InternalSolverLanguageParser.g:8338:2: ( ruleArgumentList ) |
27718 | { | 25354 | { |
27719 | // InternalSolverLanguage.g:8463:2: ( ruleArgumentList ) | 25355 | // InternalSolverLanguageParser.g:8338:2: ( ruleArgumentList ) |
27720 | // InternalSolverLanguage.g:8464:3: ruleArgumentList | 25356 | // InternalSolverLanguageParser.g:8339:3: ruleArgumentList |
27721 | { | 25357 | { |
27722 | if ( state.backtracking==0 ) { | 25358 | before(grammarAccess.getCallAccess().getArgumentListArgumentListParserRuleCall_2_0()); |
27723 | before(grammarAccess.getCallAccess().getArgumentListArgumentListParserRuleCall_2_0()); | ||
27724 | } | ||
27725 | pushFollow(FOLLOW_2); | 25359 | pushFollow(FOLLOW_2); |
27726 | ruleArgumentList(); | 25360 | ruleArgumentList(); |
27727 | 25361 | ||
27728 | state._fsp--; | 25362 | state._fsp--; |
27729 | if (state.failed) return ; | 25363 | |
27730 | if ( state.backtracking==0 ) { | 25364 | after(grammarAccess.getCallAccess().getArgumentListArgumentListParserRuleCall_2_0()); |
27731 | after(grammarAccess.getCallAccess().getArgumentListArgumentListParserRuleCall_2_0()); | ||
27732 | } | ||
27733 | 25365 | ||
27734 | } | 25366 | } |
27735 | 25367 | ||
@@ -27752,29 +25384,25 @@ public class InternalSolverLanguageParser extends AbstractInternalContentAssistP | |||
27752 | 25384 | ||
27753 | 25385 | ||
27754 | // $ANTLR start "rule__ArgumentList__ArgumentsAssignment_2_0" | 25386 | // $ANTLR start "rule__ArgumentList__ArgumentsAssignment_2_0" |
27755 | // InternalSolverLanguage.g:8473:1: rule__ArgumentList__ArgumentsAssignment_2_0 : ( ruleArgument ) ; | 25387 | // InternalSolverLanguageParser.g:8348:1: rule__ArgumentList__ArgumentsAssignment_2_0 : ( ruleArgument ) ; |
27756 | public final void rule__ArgumentList__ArgumentsAssignment_2_0() throws RecognitionException { | 25388 | public final void rule__ArgumentList__ArgumentsAssignment_2_0() throws RecognitionException { |
27757 | 25389 | ||
27758 | int stackSize = keepStackSize(); | 25390 | int stackSize = keepStackSize(); |
27759 | 25391 | ||
27760 | try { | 25392 | try { |
27761 | // InternalSolverLanguage.g:8477:1: ( ( ruleArgument ) ) | 25393 | // InternalSolverLanguageParser.g:8352:1: ( ( ruleArgument ) ) |
27762 | // InternalSolverLanguage.g:8478:2: ( ruleArgument ) | 25394 | // InternalSolverLanguageParser.g:8353:2: ( ruleArgument ) |
27763 | { | 25395 | { |
27764 | // InternalSolverLanguage.g:8478:2: ( ruleArgument ) | 25396 | // InternalSolverLanguageParser.g:8353:2: ( ruleArgument ) |
27765 | // InternalSolverLanguage.g:8479:3: ruleArgument | 25397 | // InternalSolverLanguageParser.g:8354:3: ruleArgument |
27766 | { | 25398 | { |
27767 | if ( state.backtracking==0 ) { | 25399 | before(grammarAccess.getArgumentListAccess().getArgumentsArgumentParserRuleCall_2_0_0()); |
27768 | before(grammarAccess.getArgumentListAccess().getArgumentsArgumentParserRuleCall_2_0_0()); | ||
27769 | } | ||
27770 | pushFollow(FOLLOW_2); | 25400 | pushFollow(FOLLOW_2); |
27771 | ruleArgument(); | 25401 | ruleArgument(); |
27772 | 25402 | ||
27773 | state._fsp--; | 25403 | state._fsp--; |
27774 | if (state.failed) return ; | 25404 | |
27775 | if ( state.backtracking==0 ) { | 25405 | after(grammarAccess.getArgumentListAccess().getArgumentsArgumentParserRuleCall_2_0_0()); |
27776 | after(grammarAccess.getArgumentListAccess().getArgumentsArgumentParserRuleCall_2_0_0()); | ||
27777 | } | ||
27778 | 25406 | ||
27779 | } | 25407 | } |
27780 | 25408 | ||
@@ -27797,29 +25425,25 @@ public class InternalSolverLanguageParser extends AbstractInternalContentAssistP | |||
27797 | 25425 | ||
27798 | 25426 | ||
27799 | // $ANTLR start "rule__ArgumentList__ArgumentsAssignment_2_1_1" | 25427 | // $ANTLR start "rule__ArgumentList__ArgumentsAssignment_2_1_1" |
27800 | // InternalSolverLanguage.g:8488:1: rule__ArgumentList__ArgumentsAssignment_2_1_1 : ( ruleArgument ) ; | 25428 | // InternalSolverLanguageParser.g:8363:1: rule__ArgumentList__ArgumentsAssignment_2_1_1 : ( ruleArgument ) ; |
27801 | public final void rule__ArgumentList__ArgumentsAssignment_2_1_1() throws RecognitionException { | 25429 | public final void rule__ArgumentList__ArgumentsAssignment_2_1_1() throws RecognitionException { |
27802 | 25430 | ||
27803 | int stackSize = keepStackSize(); | 25431 | int stackSize = keepStackSize(); |
27804 | 25432 | ||
27805 | try { | 25433 | try { |
27806 | // InternalSolverLanguage.g:8492:1: ( ( ruleArgument ) ) | 25434 | // InternalSolverLanguageParser.g:8367:1: ( ( ruleArgument ) ) |
27807 | // InternalSolverLanguage.g:8493:2: ( ruleArgument ) | 25435 | // InternalSolverLanguageParser.g:8368:2: ( ruleArgument ) |
27808 | { | 25436 | { |
27809 | // InternalSolverLanguage.g:8493:2: ( ruleArgument ) | 25437 | // InternalSolverLanguageParser.g:8368:2: ( ruleArgument ) |
27810 | // InternalSolverLanguage.g:8494:3: ruleArgument | 25438 | // InternalSolverLanguageParser.g:8369:3: ruleArgument |
27811 | { | 25439 | { |
27812 | if ( state.backtracking==0 ) { | 25440 | before(grammarAccess.getArgumentListAccess().getArgumentsArgumentParserRuleCall_2_1_1_0()); |
27813 | before(grammarAccess.getArgumentListAccess().getArgumentsArgumentParserRuleCall_2_1_1_0()); | ||
27814 | } | ||
27815 | pushFollow(FOLLOW_2); | 25441 | pushFollow(FOLLOW_2); |
27816 | ruleArgument(); | 25442 | ruleArgument(); |
27817 | 25443 | ||
27818 | state._fsp--; | 25444 | state._fsp--; |
27819 | if (state.failed) return ; | 25445 | |
27820 | if ( state.backtracking==0 ) { | 25446 | after(grammarAccess.getArgumentListAccess().getArgumentsArgumentParserRuleCall_2_1_1_0()); |
27821 | after(grammarAccess.getArgumentListAccess().getArgumentsArgumentParserRuleCall_2_1_1_0()); | ||
27822 | } | ||
27823 | 25447 | ||
27824 | } | 25448 | } |
27825 | 25449 | ||
@@ -27842,29 +25466,25 @@ public class InternalSolverLanguageParser extends AbstractInternalContentAssistP | |||
27842 | 25466 | ||
27843 | 25467 | ||
27844 | // $ANTLR start "rule__ExpressionArgument__BodyAssignment" | 25468 | // $ANTLR start "rule__ExpressionArgument__BodyAssignment" |
27845 | // InternalSolverLanguage.g:8503:1: rule__ExpressionArgument__BodyAssignment : ( ruleComparisonExpression ) ; | 25469 | // InternalSolverLanguageParser.g:8378:1: rule__ExpressionArgument__BodyAssignment : ( ruleComparisonExpression ) ; |
27846 | public final void rule__ExpressionArgument__BodyAssignment() throws RecognitionException { | 25470 | public final void rule__ExpressionArgument__BodyAssignment() throws RecognitionException { |
27847 | 25471 | ||
27848 | int stackSize = keepStackSize(); | 25472 | int stackSize = keepStackSize(); |
27849 | 25473 | ||
27850 | try { | 25474 | try { |
27851 | // InternalSolverLanguage.g:8507:1: ( ( ruleComparisonExpression ) ) | 25475 | // InternalSolverLanguageParser.g:8382:1: ( ( ruleComparisonExpression ) ) |
27852 | // InternalSolverLanguage.g:8508:2: ( ruleComparisonExpression ) | 25476 | // InternalSolverLanguageParser.g:8383:2: ( ruleComparisonExpression ) |
27853 | { | 25477 | { |
27854 | // InternalSolverLanguage.g:8508:2: ( ruleComparisonExpression ) | 25478 | // InternalSolverLanguageParser.g:8383:2: ( ruleComparisonExpression ) |
27855 | // InternalSolverLanguage.g:8509:3: ruleComparisonExpression | 25479 | // InternalSolverLanguageParser.g:8384:3: ruleComparisonExpression |
27856 | { | 25480 | { |
27857 | if ( state.backtracking==0 ) { | 25481 | before(grammarAccess.getExpressionArgumentAccess().getBodyComparisonExpressionParserRuleCall_0()); |
27858 | before(grammarAccess.getExpressionArgumentAccess().getBodyComparisonExpressionParserRuleCall_0()); | ||
27859 | } | ||
27860 | pushFollow(FOLLOW_2); | 25482 | pushFollow(FOLLOW_2); |
27861 | ruleComparisonExpression(); | 25483 | ruleComparisonExpression(); |
27862 | 25484 | ||
27863 | state._fsp--; | 25485 | state._fsp--; |
27864 | if (state.failed) return ; | 25486 | |
27865 | if ( state.backtracking==0 ) { | 25487 | after(grammarAccess.getExpressionArgumentAccess().getBodyComparisonExpressionParserRuleCall_0()); |
27866 | after(grammarAccess.getExpressionArgumentAccess().getBodyComparisonExpressionParserRuleCall_0()); | ||
27867 | } | ||
27868 | 25488 | ||
27869 | } | 25489 | } |
27870 | 25490 | ||
@@ -27887,42 +25507,34 @@ public class InternalSolverLanguageParser extends AbstractInternalContentAssistP | |||
27887 | 25507 | ||
27888 | 25508 | ||
27889 | // $ANTLR start "rule__TypedArgument__TypeAssignment_0" | 25509 | // $ANTLR start "rule__TypedArgument__TypeAssignment_0" |
27890 | // InternalSolverLanguage.g:8518:1: rule__TypedArgument__TypeAssignment_0 : ( ( ruleQualifiedName ) ) ; | 25510 | // InternalSolverLanguageParser.g:8393:1: rule__TypedArgument__TypeAssignment_0 : ( ( ruleQualifiedName ) ) ; |
27891 | public final void rule__TypedArgument__TypeAssignment_0() throws RecognitionException { | 25511 | public final void rule__TypedArgument__TypeAssignment_0() throws RecognitionException { |
27892 | 25512 | ||
27893 | int stackSize = keepStackSize(); | 25513 | int stackSize = keepStackSize(); |
27894 | 25514 | ||
27895 | try { | 25515 | try { |
27896 | // InternalSolverLanguage.g:8522:1: ( ( ( ruleQualifiedName ) ) ) | 25516 | // InternalSolverLanguageParser.g:8397:1: ( ( ( ruleQualifiedName ) ) ) |
27897 | // InternalSolverLanguage.g:8523:2: ( ( ruleQualifiedName ) ) | 25517 | // InternalSolverLanguageParser.g:8398:2: ( ( ruleQualifiedName ) ) |
27898 | { | 25518 | { |
27899 | // InternalSolverLanguage.g:8523:2: ( ( ruleQualifiedName ) ) | 25519 | // InternalSolverLanguageParser.g:8398:2: ( ( ruleQualifiedName ) ) |
27900 | // InternalSolverLanguage.g:8524:3: ( ruleQualifiedName ) | 25520 | // InternalSolverLanguageParser.g:8399:3: ( ruleQualifiedName ) |
27901 | { | 25521 | { |
27902 | if ( state.backtracking==0 ) { | 25522 | before(grammarAccess.getTypedArgumentAccess().getTypeNamedElementCrossReference_0_0()); |
27903 | before(grammarAccess.getTypedArgumentAccess().getTypeNamedElementCrossReference_0_0()); | 25523 | // InternalSolverLanguageParser.g:8400:3: ( ruleQualifiedName ) |
27904 | } | 25524 | // InternalSolverLanguageParser.g:8401:4: ruleQualifiedName |
27905 | // InternalSolverLanguage.g:8525:3: ( ruleQualifiedName ) | ||
27906 | // InternalSolverLanguage.g:8526:4: ruleQualifiedName | ||
27907 | { | 25525 | { |
27908 | if ( state.backtracking==0 ) { | 25526 | before(grammarAccess.getTypedArgumentAccess().getTypeNamedElementQualifiedNameParserRuleCall_0_0_1()); |
27909 | before(grammarAccess.getTypedArgumentAccess().getTypeNamedElementQualifiedNameParserRuleCall_0_0_1()); | ||
27910 | } | ||
27911 | pushFollow(FOLLOW_2); | 25527 | pushFollow(FOLLOW_2); |
27912 | ruleQualifiedName(); | 25528 | ruleQualifiedName(); |
27913 | 25529 | ||
27914 | state._fsp--; | 25530 | state._fsp--; |
27915 | if (state.failed) return ; | ||
27916 | if ( state.backtracking==0 ) { | ||
27917 | after(grammarAccess.getTypedArgumentAccess().getTypeNamedElementQualifiedNameParserRuleCall_0_0_1()); | ||
27918 | } | ||
27919 | 25531 | ||
27920 | } | 25532 | after(grammarAccess.getTypedArgumentAccess().getTypeNamedElementQualifiedNameParserRuleCall_0_0_1()); |
27921 | 25533 | ||
27922 | if ( state.backtracking==0 ) { | ||
27923 | after(grammarAccess.getTypedArgumentAccess().getTypeNamedElementCrossReference_0_0()); | ||
27924 | } | 25534 | } |
27925 | 25535 | ||
25536 | after(grammarAccess.getTypedArgumentAccess().getTypeNamedElementCrossReference_0_0()); | ||
25537 | |||
27926 | } | 25538 | } |
27927 | 25539 | ||
27928 | 25540 | ||
@@ -27944,42 +25556,34 @@ public class InternalSolverLanguageParser extends AbstractInternalContentAssistP | |||
27944 | 25556 | ||
27945 | 25557 | ||
27946 | // $ANTLR start "rule__TypedArgument__VariableAssignment_1" | 25558 | // $ANTLR start "rule__TypedArgument__VariableAssignment_1" |
27947 | // InternalSolverLanguage.g:8537:1: rule__TypedArgument__VariableAssignment_1 : ( ( ruleQualifiedName ) ) ; | 25559 | // InternalSolverLanguageParser.g:8412:1: rule__TypedArgument__VariableAssignment_1 : ( ( ruleQualifiedName ) ) ; |
27948 | public final void rule__TypedArgument__VariableAssignment_1() throws RecognitionException { | 25560 | public final void rule__TypedArgument__VariableAssignment_1() throws RecognitionException { |
27949 | 25561 | ||
27950 | int stackSize = keepStackSize(); | 25562 | int stackSize = keepStackSize(); |
27951 | 25563 | ||
27952 | try { | 25564 | try { |
27953 | // InternalSolverLanguage.g:8541:1: ( ( ( ruleQualifiedName ) ) ) | 25565 | // InternalSolverLanguageParser.g:8416:1: ( ( ( ruleQualifiedName ) ) ) |
27954 | // InternalSolverLanguage.g:8542:2: ( ( ruleQualifiedName ) ) | 25566 | // InternalSolverLanguageParser.g:8417:2: ( ( ruleQualifiedName ) ) |
27955 | { | 25567 | { |
27956 | // InternalSolverLanguage.g:8542:2: ( ( ruleQualifiedName ) ) | 25568 | // InternalSolverLanguageParser.g:8417:2: ( ( ruleQualifiedName ) ) |
27957 | // InternalSolverLanguage.g:8543:3: ( ruleQualifiedName ) | 25569 | // InternalSolverLanguageParser.g:8418:3: ( ruleQualifiedName ) |
27958 | { | 25570 | { |
27959 | if ( state.backtracking==0 ) { | 25571 | before(grammarAccess.getTypedArgumentAccess().getVariableNamedElementCrossReference_1_0()); |
27960 | before(grammarAccess.getTypedArgumentAccess().getVariableNamedElementCrossReference_1_0()); | 25572 | // InternalSolverLanguageParser.g:8419:3: ( ruleQualifiedName ) |
27961 | } | 25573 | // InternalSolverLanguageParser.g:8420:4: ruleQualifiedName |
27962 | // InternalSolverLanguage.g:8544:3: ( ruleQualifiedName ) | ||
27963 | // InternalSolverLanguage.g:8545:4: ruleQualifiedName | ||
27964 | { | 25574 | { |
27965 | if ( state.backtracking==0 ) { | 25575 | before(grammarAccess.getTypedArgumentAccess().getVariableNamedElementQualifiedNameParserRuleCall_1_0_1()); |
27966 | before(grammarAccess.getTypedArgumentAccess().getVariableNamedElementQualifiedNameParserRuleCall_1_0_1()); | ||
27967 | } | ||
27968 | pushFollow(FOLLOW_2); | 25576 | pushFollow(FOLLOW_2); |
27969 | ruleQualifiedName(); | 25577 | ruleQualifiedName(); |
27970 | 25578 | ||
27971 | state._fsp--; | 25579 | state._fsp--; |
27972 | if (state.failed) return ; | ||
27973 | if ( state.backtracking==0 ) { | ||
27974 | after(grammarAccess.getTypedArgumentAccess().getVariableNamedElementQualifiedNameParserRuleCall_1_0_1()); | ||
27975 | } | ||
27976 | 25580 | ||
27977 | } | 25581 | after(grammarAccess.getTypedArgumentAccess().getVariableNamedElementQualifiedNameParserRuleCall_1_0_1()); |
27978 | 25582 | ||
27979 | if ( state.backtracking==0 ) { | ||
27980 | after(grammarAccess.getTypedArgumentAccess().getVariableNamedElementCrossReference_1_0()); | ||
27981 | } | 25583 | } |
27982 | 25584 | ||
25585 | after(grammarAccess.getTypedArgumentAccess().getVariableNamedElementCrossReference_1_0()); | ||
25586 | |||
27983 | } | 25587 | } |
27984 | 25588 | ||
27985 | 25589 | ||
@@ -28001,42 +25605,34 @@ public class InternalSolverLanguageParser extends AbstractInternalContentAssistP | |||
28001 | 25605 | ||
28002 | 25606 | ||
28003 | // $ANTLR start "rule__TypedStarArgument__TypeAssignment_0" | 25607 | // $ANTLR start "rule__TypedStarArgument__TypeAssignment_0" |
28004 | // InternalSolverLanguage.g:8556:1: rule__TypedStarArgument__TypeAssignment_0 : ( ( ruleQualifiedName ) ) ; | 25608 | // InternalSolverLanguageParser.g:8431:1: rule__TypedStarArgument__TypeAssignment_0 : ( ( ruleQualifiedName ) ) ; |
28005 | public final void rule__TypedStarArgument__TypeAssignment_0() throws RecognitionException { | 25609 | public final void rule__TypedStarArgument__TypeAssignment_0() throws RecognitionException { |
28006 | 25610 | ||
28007 | int stackSize = keepStackSize(); | 25611 | int stackSize = keepStackSize(); |
28008 | 25612 | ||
28009 | try { | 25613 | try { |
28010 | // InternalSolverLanguage.g:8560:1: ( ( ( ruleQualifiedName ) ) ) | 25614 | // InternalSolverLanguageParser.g:8435:1: ( ( ( ruleQualifiedName ) ) ) |
28011 | // InternalSolverLanguage.g:8561:2: ( ( ruleQualifiedName ) ) | 25615 | // InternalSolverLanguageParser.g:8436:2: ( ( ruleQualifiedName ) ) |
28012 | { | 25616 | { |
28013 | // InternalSolverLanguage.g:8561:2: ( ( ruleQualifiedName ) ) | 25617 | // InternalSolverLanguageParser.g:8436:2: ( ( ruleQualifiedName ) ) |
28014 | // InternalSolverLanguage.g:8562:3: ( ruleQualifiedName ) | 25618 | // InternalSolverLanguageParser.g:8437:3: ( ruleQualifiedName ) |
28015 | { | 25619 | { |
28016 | if ( state.backtracking==0 ) { | 25620 | before(grammarAccess.getTypedStarArgumentAccess().getTypeNamedElementCrossReference_0_0()); |
28017 | before(grammarAccess.getTypedStarArgumentAccess().getTypeNamedElementCrossReference_0_0()); | 25621 | // InternalSolverLanguageParser.g:8438:3: ( ruleQualifiedName ) |
28018 | } | 25622 | // InternalSolverLanguageParser.g:8439:4: ruleQualifiedName |
28019 | // InternalSolverLanguage.g:8563:3: ( ruleQualifiedName ) | ||
28020 | // InternalSolverLanguage.g:8564:4: ruleQualifiedName | ||
28021 | { | 25623 | { |
28022 | if ( state.backtracking==0 ) { | 25624 | before(grammarAccess.getTypedStarArgumentAccess().getTypeNamedElementQualifiedNameParserRuleCall_0_0_1()); |
28023 | before(grammarAccess.getTypedStarArgumentAccess().getTypeNamedElementQualifiedNameParserRuleCall_0_0_1()); | ||
28024 | } | ||
28025 | pushFollow(FOLLOW_2); | 25625 | pushFollow(FOLLOW_2); |
28026 | ruleQualifiedName(); | 25626 | ruleQualifiedName(); |
28027 | 25627 | ||
28028 | state._fsp--; | 25628 | state._fsp--; |
28029 | if (state.failed) return ; | ||
28030 | if ( state.backtracking==0 ) { | ||
28031 | after(grammarAccess.getTypedStarArgumentAccess().getTypeNamedElementQualifiedNameParserRuleCall_0_0_1()); | ||
28032 | } | ||
28033 | 25629 | ||
28034 | } | 25630 | after(grammarAccess.getTypedStarArgumentAccess().getTypeNamedElementQualifiedNameParserRuleCall_0_0_1()); |
28035 | 25631 | ||
28036 | if ( state.backtracking==0 ) { | ||
28037 | after(grammarAccess.getTypedStarArgumentAccess().getTypeNamedElementCrossReference_0_0()); | ||
28038 | } | 25632 | } |
28039 | 25633 | ||
25634 | after(grammarAccess.getTypedStarArgumentAccess().getTypeNamedElementCrossReference_0_0()); | ||
25635 | |||
28040 | } | 25636 | } |
28041 | 25637 | ||
28042 | 25638 | ||
@@ -28058,42 +25654,34 @@ public class InternalSolverLanguageParser extends AbstractInternalContentAssistP | |||
28058 | 25654 | ||
28059 | 25655 | ||
28060 | // $ANTLR start "rule__Reference__ReferredAssignment" | 25656 | // $ANTLR start "rule__Reference__ReferredAssignment" |
28061 | // InternalSolverLanguage.g:8575:1: rule__Reference__ReferredAssignment : ( ( ruleQualifiedName ) ) ; | 25657 | // InternalSolverLanguageParser.g:8450:1: rule__Reference__ReferredAssignment : ( ( ruleQualifiedName ) ) ; |
28062 | public final void rule__Reference__ReferredAssignment() throws RecognitionException { | 25658 | public final void rule__Reference__ReferredAssignment() throws RecognitionException { |
28063 | 25659 | ||
28064 | int stackSize = keepStackSize(); | 25660 | int stackSize = keepStackSize(); |
28065 | 25661 | ||
28066 | try { | 25662 | try { |
28067 | // InternalSolverLanguage.g:8579:1: ( ( ( ruleQualifiedName ) ) ) | 25663 | // InternalSolverLanguageParser.g:8454:1: ( ( ( ruleQualifiedName ) ) ) |
28068 | // InternalSolverLanguage.g:8580:2: ( ( ruleQualifiedName ) ) | 25664 | // InternalSolverLanguageParser.g:8455:2: ( ( ruleQualifiedName ) ) |
28069 | { | 25665 | { |
28070 | // InternalSolverLanguage.g:8580:2: ( ( ruleQualifiedName ) ) | 25666 | // InternalSolverLanguageParser.g:8455:2: ( ( ruleQualifiedName ) ) |
28071 | // InternalSolverLanguage.g:8581:3: ( ruleQualifiedName ) | 25667 | // InternalSolverLanguageParser.g:8456:3: ( ruleQualifiedName ) |
28072 | { | 25668 | { |
28073 | if ( state.backtracking==0 ) { | 25669 | before(grammarAccess.getReferenceAccess().getReferredNamedElementCrossReference_0()); |
28074 | before(grammarAccess.getReferenceAccess().getReferredNamedElementCrossReference_0()); | 25670 | // InternalSolverLanguageParser.g:8457:3: ( ruleQualifiedName ) |
28075 | } | 25671 | // InternalSolverLanguageParser.g:8458:4: ruleQualifiedName |
28076 | // InternalSolverLanguage.g:8582:3: ( ruleQualifiedName ) | ||
28077 | // InternalSolverLanguage.g:8583:4: ruleQualifiedName | ||
28078 | { | 25672 | { |
28079 | if ( state.backtracking==0 ) { | 25673 | before(grammarAccess.getReferenceAccess().getReferredNamedElementQualifiedNameParserRuleCall_0_1()); |
28080 | before(grammarAccess.getReferenceAccess().getReferredNamedElementQualifiedNameParserRuleCall_0_1()); | ||
28081 | } | ||
28082 | pushFollow(FOLLOW_2); | 25674 | pushFollow(FOLLOW_2); |
28083 | ruleQualifiedName(); | 25675 | ruleQualifiedName(); |
28084 | 25676 | ||
28085 | state._fsp--; | 25677 | state._fsp--; |
28086 | if (state.failed) return ; | ||
28087 | if ( state.backtracking==0 ) { | ||
28088 | after(grammarAccess.getReferenceAccess().getReferredNamedElementQualifiedNameParserRuleCall_0_1()); | ||
28089 | } | ||
28090 | 25678 | ||
28091 | } | 25679 | after(grammarAccess.getReferenceAccess().getReferredNamedElementQualifiedNameParserRuleCall_0_1()); |
28092 | 25680 | ||
28093 | if ( state.backtracking==0 ) { | ||
28094 | after(grammarAccess.getReferenceAccess().getReferredNamedElementCrossReference_0()); | ||
28095 | } | 25681 | } |
28096 | 25682 | ||
25683 | after(grammarAccess.getReferenceAccess().getReferredNamedElementCrossReference_0()); | ||
25684 | |||
28097 | } | 25685 | } |
28098 | 25686 | ||
28099 | 25687 | ||
@@ -28115,29 +25703,25 @@ public class InternalSolverLanguageParser extends AbstractInternalContentAssistP | |||
28115 | 25703 | ||
28116 | 25704 | ||
28117 | // $ANTLR start "rule__Interval__LowerBoundAssignment_1" | 25705 | // $ANTLR start "rule__Interval__LowerBoundAssignment_1" |
28118 | // InternalSolverLanguage.g:8594:1: rule__Interval__LowerBoundAssignment_1 : ( ruleExpression ) ; | 25706 | // InternalSolverLanguageParser.g:8469:1: rule__Interval__LowerBoundAssignment_1 : ( ruleExpression ) ; |
28119 | public final void rule__Interval__LowerBoundAssignment_1() throws RecognitionException { | 25707 | public final void rule__Interval__LowerBoundAssignment_1() throws RecognitionException { |
28120 | 25708 | ||
28121 | int stackSize = keepStackSize(); | 25709 | int stackSize = keepStackSize(); |
28122 | 25710 | ||
28123 | try { | 25711 | try { |
28124 | // InternalSolverLanguage.g:8598:1: ( ( ruleExpression ) ) | 25712 | // InternalSolverLanguageParser.g:8473:1: ( ( ruleExpression ) ) |
28125 | // InternalSolverLanguage.g:8599:2: ( ruleExpression ) | 25713 | // InternalSolverLanguageParser.g:8474:2: ( ruleExpression ) |
28126 | { | 25714 | { |
28127 | // InternalSolverLanguage.g:8599:2: ( ruleExpression ) | 25715 | // InternalSolverLanguageParser.g:8474:2: ( ruleExpression ) |
28128 | // InternalSolverLanguage.g:8600:3: ruleExpression | 25716 | // InternalSolverLanguageParser.g:8475:3: ruleExpression |
28129 | { | 25717 | { |
28130 | if ( state.backtracking==0 ) { | 25718 | before(grammarAccess.getIntervalAccess().getLowerBoundExpressionParserRuleCall_1_0()); |
28131 | before(grammarAccess.getIntervalAccess().getLowerBoundExpressionParserRuleCall_1_0()); | ||
28132 | } | ||
28133 | pushFollow(FOLLOW_2); | 25719 | pushFollow(FOLLOW_2); |
28134 | ruleExpression(); | 25720 | ruleExpression(); |
28135 | 25721 | ||
28136 | state._fsp--; | 25722 | state._fsp--; |
28137 | if (state.failed) return ; | 25723 | |
28138 | if ( state.backtracking==0 ) { | 25724 | after(grammarAccess.getIntervalAccess().getLowerBoundExpressionParserRuleCall_1_0()); |
28139 | after(grammarAccess.getIntervalAccess().getLowerBoundExpressionParserRuleCall_1_0()); | ||
28140 | } | ||
28141 | 25725 | ||
28142 | } | 25726 | } |
28143 | 25727 | ||
@@ -28160,29 +25744,25 @@ public class InternalSolverLanguageParser extends AbstractInternalContentAssistP | |||
28160 | 25744 | ||
28161 | 25745 | ||
28162 | // $ANTLR start "rule__Interval__UpperBoundAssignment_3" | 25746 | // $ANTLR start "rule__Interval__UpperBoundAssignment_3" |
28163 | // InternalSolverLanguage.g:8609:1: rule__Interval__UpperBoundAssignment_3 : ( ruleExpression ) ; | 25747 | // InternalSolverLanguageParser.g:8484:1: rule__Interval__UpperBoundAssignment_3 : ( ruleExpression ) ; |
28164 | public final void rule__Interval__UpperBoundAssignment_3() throws RecognitionException { | 25748 | public final void rule__Interval__UpperBoundAssignment_3() throws RecognitionException { |
28165 | 25749 | ||
28166 | int stackSize = keepStackSize(); | 25750 | int stackSize = keepStackSize(); |
28167 | 25751 | ||
28168 | try { | 25752 | try { |
28169 | // InternalSolverLanguage.g:8613:1: ( ( ruleExpression ) ) | 25753 | // InternalSolverLanguageParser.g:8488:1: ( ( ruleExpression ) ) |
28170 | // InternalSolverLanguage.g:8614:2: ( ruleExpression ) | 25754 | // InternalSolverLanguageParser.g:8489:2: ( ruleExpression ) |
28171 | { | 25755 | { |
28172 | // InternalSolverLanguage.g:8614:2: ( ruleExpression ) | 25756 | // InternalSolverLanguageParser.g:8489:2: ( ruleExpression ) |
28173 | // InternalSolverLanguage.g:8615:3: ruleExpression | 25757 | // InternalSolverLanguageParser.g:8490:3: ruleExpression |
28174 | { | 25758 | { |
28175 | if ( state.backtracking==0 ) { | 25759 | before(grammarAccess.getIntervalAccess().getUpperBoundExpressionParserRuleCall_3_0()); |
28176 | before(grammarAccess.getIntervalAccess().getUpperBoundExpressionParserRuleCall_3_0()); | ||
28177 | } | ||
28178 | pushFollow(FOLLOW_2); | 25760 | pushFollow(FOLLOW_2); |
28179 | ruleExpression(); | 25761 | ruleExpression(); |
28180 | 25762 | ||
28181 | state._fsp--; | 25763 | state._fsp--; |
28182 | if (state.failed) return ; | 25764 | |
28183 | if ( state.backtracking==0 ) { | 25765 | after(grammarAccess.getIntervalAccess().getUpperBoundExpressionParserRuleCall_3_0()); |
28184 | after(grammarAccess.getIntervalAccess().getUpperBoundExpressionParserRuleCall_3_0()); | ||
28185 | } | ||
28186 | 25766 | ||
28187 | } | 25767 | } |
28188 | 25768 | ||
@@ -28205,29 +25785,25 @@ public class InternalSolverLanguageParser extends AbstractInternalContentAssistP | |||
28205 | 25785 | ||
28206 | 25786 | ||
28207 | // $ANTLR start "rule__LogicLiteral__ValueAssignment" | 25787 | // $ANTLR start "rule__LogicLiteral__ValueAssignment" |
28208 | // InternalSolverLanguage.g:8624:1: rule__LogicLiteral__ValueAssignment : ( ruleLogicValue ) ; | 25788 | // InternalSolverLanguageParser.g:8499:1: rule__LogicLiteral__ValueAssignment : ( ruleLogicValue ) ; |
28209 | public final void rule__LogicLiteral__ValueAssignment() throws RecognitionException { | 25789 | public final void rule__LogicLiteral__ValueAssignment() throws RecognitionException { |
28210 | 25790 | ||
28211 | int stackSize = keepStackSize(); | 25791 | int stackSize = keepStackSize(); |
28212 | 25792 | ||
28213 | try { | 25793 | try { |
28214 | // InternalSolverLanguage.g:8628:1: ( ( ruleLogicValue ) ) | 25794 | // InternalSolverLanguageParser.g:8503:1: ( ( ruleLogicValue ) ) |
28215 | // InternalSolverLanguage.g:8629:2: ( ruleLogicValue ) | 25795 | // InternalSolverLanguageParser.g:8504:2: ( ruleLogicValue ) |
28216 | { | 25796 | { |
28217 | // InternalSolverLanguage.g:8629:2: ( ruleLogicValue ) | 25797 | // InternalSolverLanguageParser.g:8504:2: ( ruleLogicValue ) |
28218 | // InternalSolverLanguage.g:8630:3: ruleLogicValue | 25798 | // InternalSolverLanguageParser.g:8505:3: ruleLogicValue |
28219 | { | 25799 | { |
28220 | if ( state.backtracking==0 ) { | 25800 | before(grammarAccess.getLogicLiteralAccess().getValueLogicValueEnumRuleCall_0()); |
28221 | before(grammarAccess.getLogicLiteralAccess().getValueLogicValueEnumRuleCall_0()); | ||
28222 | } | ||
28223 | pushFollow(FOLLOW_2); | 25801 | pushFollow(FOLLOW_2); |
28224 | ruleLogicValue(); | 25802 | ruleLogicValue(); |
28225 | 25803 | ||
28226 | state._fsp--; | 25804 | state._fsp--; |
28227 | if (state.failed) return ; | 25805 | |
28228 | if ( state.backtracking==0 ) { | 25806 | after(grammarAccess.getLogicLiteralAccess().getValueLogicValueEnumRuleCall_0()); |
28229 | after(grammarAccess.getLogicLiteralAccess().getValueLogicValueEnumRuleCall_0()); | ||
28230 | } | ||
28231 | 25807 | ||
28232 | } | 25808 | } |
28233 | 25809 | ||
@@ -28250,29 +25826,25 @@ public class InternalSolverLanguageParser extends AbstractInternalContentAssistP | |||
28250 | 25826 | ||
28251 | 25827 | ||
28252 | // $ANTLR start "rule__NumericLiteral__ValueAssignment" | 25828 | // $ANTLR start "rule__NumericLiteral__ValueAssignment" |
28253 | // InternalSolverLanguage.g:8639:1: rule__NumericLiteral__ValueAssignment : ( ruleReal ) ; | 25829 | // InternalSolverLanguageParser.g:8514:1: rule__NumericLiteral__ValueAssignment : ( ruleReal ) ; |
28254 | public final void rule__NumericLiteral__ValueAssignment() throws RecognitionException { | 25830 | public final void rule__NumericLiteral__ValueAssignment() throws RecognitionException { |
28255 | 25831 | ||
28256 | int stackSize = keepStackSize(); | 25832 | int stackSize = keepStackSize(); |
28257 | 25833 | ||
28258 | try { | 25834 | try { |
28259 | // InternalSolverLanguage.g:8643:1: ( ( ruleReal ) ) | 25835 | // InternalSolverLanguageParser.g:8518:1: ( ( ruleReal ) ) |
28260 | // InternalSolverLanguage.g:8644:2: ( ruleReal ) | 25836 | // InternalSolverLanguageParser.g:8519:2: ( ruleReal ) |
28261 | { | 25837 | { |
28262 | // InternalSolverLanguage.g:8644:2: ( ruleReal ) | 25838 | // InternalSolverLanguageParser.g:8519:2: ( ruleReal ) |
28263 | // InternalSolverLanguage.g:8645:3: ruleReal | 25839 | // InternalSolverLanguageParser.g:8520:3: ruleReal |
28264 | { | 25840 | { |
28265 | if ( state.backtracking==0 ) { | 25841 | before(grammarAccess.getNumericLiteralAccess().getValueRealParserRuleCall_0()); |
28266 | before(grammarAccess.getNumericLiteralAccess().getValueRealParserRuleCall_0()); | ||
28267 | } | ||
28268 | pushFollow(FOLLOW_2); | 25842 | pushFollow(FOLLOW_2); |
28269 | ruleReal(); | 25843 | ruleReal(); |
28270 | 25844 | ||
28271 | state._fsp--; | 25845 | state._fsp--; |
28272 | if (state.failed) return ; | 25846 | |
28273 | if ( state.backtracking==0 ) { | 25847 | after(grammarAccess.getNumericLiteralAccess().getValueRealParserRuleCall_0()); |
28274 | after(grammarAccess.getNumericLiteralAccess().getValueRealParserRuleCall_0()); | ||
28275 | } | ||
28276 | 25848 | ||
28277 | } | 25849 | } |
28278 | 25850 | ||
@@ -28295,25 +25867,21 @@ public class InternalSolverLanguageParser extends AbstractInternalContentAssistP | |||
28295 | 25867 | ||
28296 | 25868 | ||
28297 | // $ANTLR start "rule__StringLiteral__ValueAssignment" | 25869 | // $ANTLR start "rule__StringLiteral__ValueAssignment" |
28298 | // InternalSolverLanguage.g:8654:1: rule__StringLiteral__ValueAssignment : ( RULE_STRING ) ; | 25870 | // InternalSolverLanguageParser.g:8529:1: rule__StringLiteral__ValueAssignment : ( RULE_STRING ) ; |
28299 | public final void rule__StringLiteral__ValueAssignment() throws RecognitionException { | 25871 | public final void rule__StringLiteral__ValueAssignment() throws RecognitionException { |
28300 | 25872 | ||
28301 | int stackSize = keepStackSize(); | 25873 | int stackSize = keepStackSize(); |
28302 | 25874 | ||
28303 | try { | 25875 | try { |
28304 | // InternalSolverLanguage.g:8658:1: ( ( RULE_STRING ) ) | 25876 | // InternalSolverLanguageParser.g:8533:1: ( ( RULE_STRING ) ) |
28305 | // InternalSolverLanguage.g:8659:2: ( RULE_STRING ) | 25877 | // InternalSolverLanguageParser.g:8534:2: ( RULE_STRING ) |
28306 | { | 25878 | { |
28307 | // InternalSolverLanguage.g:8659:2: ( RULE_STRING ) | 25879 | // InternalSolverLanguageParser.g:8534:2: ( RULE_STRING ) |
28308 | // InternalSolverLanguage.g:8660:3: RULE_STRING | 25880 | // InternalSolverLanguageParser.g:8535:3: RULE_STRING |
28309 | { | 25881 | { |
28310 | if ( state.backtracking==0 ) { | 25882 | before(grammarAccess.getStringLiteralAccess().getValueSTRINGTerminalRuleCall_0()); |
28311 | before(grammarAccess.getStringLiteralAccess().getValueSTRINGTerminalRuleCall_0()); | 25883 | match(input,RULE_STRING,FOLLOW_2); |
28312 | } | 25884 | after(grammarAccess.getStringLiteralAccess().getValueSTRINGTerminalRuleCall_0()); |
28313 | match(input,RULE_STRING,FOLLOW_2); if (state.failed) return ; | ||
28314 | if ( state.backtracking==0 ) { | ||
28315 | after(grammarAccess.getStringLiteralAccess().getValueSTRINGTerminalRuleCall_0()); | ||
28316 | } | ||
28317 | 25885 | ||
28318 | } | 25886 | } |
28319 | 25887 | ||
@@ -28336,37 +25904,29 @@ public class InternalSolverLanguageParser extends AbstractInternalContentAssistP | |||
28336 | 25904 | ||
28337 | 25905 | ||
28338 | // $ANTLR start "rule__ClassDefinition__AbstractAssignment_0" | 25906 | // $ANTLR start "rule__ClassDefinition__AbstractAssignment_0" |
28339 | // InternalSolverLanguage.g:8669:1: rule__ClassDefinition__AbstractAssignment_0 : ( ( 'abstract' ) ) ; | 25907 | // InternalSolverLanguageParser.g:8544:1: rule__ClassDefinition__AbstractAssignment_0 : ( ( Abstract ) ) ; |
28340 | public final void rule__ClassDefinition__AbstractAssignment_0() throws RecognitionException { | 25908 | public final void rule__ClassDefinition__AbstractAssignment_0() throws RecognitionException { |
28341 | 25909 | ||
28342 | int stackSize = keepStackSize(); | 25910 | int stackSize = keepStackSize(); |
28343 | 25911 | ||
28344 | try { | 25912 | try { |
28345 | // InternalSolverLanguage.g:8673:1: ( ( ( 'abstract' ) ) ) | 25913 | // InternalSolverLanguageParser.g:8548:1: ( ( ( Abstract ) ) ) |
28346 | // InternalSolverLanguage.g:8674:2: ( ( 'abstract' ) ) | 25914 | // InternalSolverLanguageParser.g:8549:2: ( ( Abstract ) ) |
28347 | { | 25915 | { |
28348 | // InternalSolverLanguage.g:8674:2: ( ( 'abstract' ) ) | 25916 | // InternalSolverLanguageParser.g:8549:2: ( ( Abstract ) ) |
28349 | // InternalSolverLanguage.g:8675:3: ( 'abstract' ) | 25917 | // InternalSolverLanguageParser.g:8550:3: ( Abstract ) |
28350 | { | 25918 | { |
28351 | if ( state.backtracking==0 ) { | 25919 | before(grammarAccess.getClassDefinitionAccess().getAbstractAbstractKeyword_0_0()); |
28352 | before(grammarAccess.getClassDefinitionAccess().getAbstractAbstractKeyword_0_0()); | 25920 | // InternalSolverLanguageParser.g:8551:3: ( Abstract ) |
28353 | } | 25921 | // InternalSolverLanguageParser.g:8552:4: Abstract |
28354 | // InternalSolverLanguage.g:8676:3: ( 'abstract' ) | ||
28355 | // InternalSolverLanguage.g:8677:4: 'abstract' | ||
28356 | { | 25922 | { |
28357 | if ( state.backtracking==0 ) { | 25923 | before(grammarAccess.getClassDefinitionAccess().getAbstractAbstractKeyword_0_0()); |
28358 | before(grammarAccess.getClassDefinitionAccess().getAbstractAbstractKeyword_0_0()); | 25924 | match(input,Abstract,FOLLOW_2); |
28359 | } | 25925 | after(grammarAccess.getClassDefinitionAccess().getAbstractAbstractKeyword_0_0()); |
28360 | match(input,73,FOLLOW_2); if (state.failed) return ; | ||
28361 | if ( state.backtracking==0 ) { | ||
28362 | after(grammarAccess.getClassDefinitionAccess().getAbstractAbstractKeyword_0_0()); | ||
28363 | } | ||
28364 | 25926 | ||
28365 | } | 25927 | } |
28366 | 25928 | ||
28367 | if ( state.backtracking==0 ) { | 25929 | after(grammarAccess.getClassDefinitionAccess().getAbstractAbstractKeyword_0_0()); |
28368 | after(grammarAccess.getClassDefinitionAccess().getAbstractAbstractKeyword_0_0()); | ||
28369 | } | ||
28370 | 25930 | ||
28371 | } | 25931 | } |
28372 | 25932 | ||
@@ -28389,25 +25949,21 @@ public class InternalSolverLanguageParser extends AbstractInternalContentAssistP | |||
28389 | 25949 | ||
28390 | 25950 | ||
28391 | // $ANTLR start "rule__ClassDefinition__NameAssignment_2" | 25951 | // $ANTLR start "rule__ClassDefinition__NameAssignment_2" |
28392 | // InternalSolverLanguage.g:8688:1: rule__ClassDefinition__NameAssignment_2 : ( RULE_ID ) ; | 25952 | // InternalSolverLanguageParser.g:8563:1: rule__ClassDefinition__NameAssignment_2 : ( RULE_ID ) ; |
28393 | public final void rule__ClassDefinition__NameAssignment_2() throws RecognitionException { | 25953 | public final void rule__ClassDefinition__NameAssignment_2() throws RecognitionException { |
28394 | 25954 | ||
28395 | int stackSize = keepStackSize(); | 25955 | int stackSize = keepStackSize(); |
28396 | 25956 | ||
28397 | try { | 25957 | try { |
28398 | // InternalSolverLanguage.g:8692:1: ( ( RULE_ID ) ) | 25958 | // InternalSolverLanguageParser.g:8567:1: ( ( RULE_ID ) ) |
28399 | // InternalSolverLanguage.g:8693:2: ( RULE_ID ) | 25959 | // InternalSolverLanguageParser.g:8568:2: ( RULE_ID ) |
28400 | { | 25960 | { |
28401 | // InternalSolverLanguage.g:8693:2: ( RULE_ID ) | 25961 | // InternalSolverLanguageParser.g:8568:2: ( RULE_ID ) |
28402 | // InternalSolverLanguage.g:8694:3: RULE_ID | 25962 | // InternalSolverLanguageParser.g:8569:3: RULE_ID |
28403 | { | 25963 | { |
28404 | if ( state.backtracking==0 ) { | 25964 | before(grammarAccess.getClassDefinitionAccess().getNameIDTerminalRuleCall_2_0()); |
28405 | before(grammarAccess.getClassDefinitionAccess().getNameIDTerminalRuleCall_2_0()); | 25965 | match(input,RULE_ID,FOLLOW_2); |
28406 | } | 25966 | after(grammarAccess.getClassDefinitionAccess().getNameIDTerminalRuleCall_2_0()); |
28407 | match(input,RULE_ID,FOLLOW_2); if (state.failed) return ; | ||
28408 | if ( state.backtracking==0 ) { | ||
28409 | after(grammarAccess.getClassDefinitionAccess().getNameIDTerminalRuleCall_2_0()); | ||
28410 | } | ||
28411 | 25967 | ||
28412 | } | 25968 | } |
28413 | 25969 | ||
@@ -28430,42 +25986,34 @@ public class InternalSolverLanguageParser extends AbstractInternalContentAssistP | |||
28430 | 25986 | ||
28431 | 25987 | ||
28432 | // $ANTLR start "rule__ClassDefinition__SuperclassesAssignment_3_1" | 25988 | // $ANTLR start "rule__ClassDefinition__SuperclassesAssignment_3_1" |
28433 | // InternalSolverLanguage.g:8703:1: rule__ClassDefinition__SuperclassesAssignment_3_1 : ( ( ruleQualifiedName ) ) ; | 25989 | // InternalSolverLanguageParser.g:8578:1: rule__ClassDefinition__SuperclassesAssignment_3_1 : ( ( ruleQualifiedName ) ) ; |
28434 | public final void rule__ClassDefinition__SuperclassesAssignment_3_1() throws RecognitionException { | 25990 | public final void rule__ClassDefinition__SuperclassesAssignment_3_1() throws RecognitionException { |
28435 | 25991 | ||
28436 | int stackSize = keepStackSize(); | 25992 | int stackSize = keepStackSize(); |
28437 | 25993 | ||
28438 | try { | 25994 | try { |
28439 | // InternalSolverLanguage.g:8707:1: ( ( ( ruleQualifiedName ) ) ) | 25995 | // InternalSolverLanguageParser.g:8582:1: ( ( ( ruleQualifiedName ) ) ) |
28440 | // InternalSolverLanguage.g:8708:2: ( ( ruleQualifiedName ) ) | 25996 | // InternalSolverLanguageParser.g:8583:2: ( ( ruleQualifiedName ) ) |
28441 | { | 25997 | { |
28442 | // InternalSolverLanguage.g:8708:2: ( ( ruleQualifiedName ) ) | 25998 | // InternalSolverLanguageParser.g:8583:2: ( ( ruleQualifiedName ) ) |
28443 | // InternalSolverLanguage.g:8709:3: ( ruleQualifiedName ) | 25999 | // InternalSolverLanguageParser.g:8584:3: ( ruleQualifiedName ) |
28444 | { | 26000 | { |
28445 | if ( state.backtracking==0 ) { | 26001 | before(grammarAccess.getClassDefinitionAccess().getSuperclassesNamedElementCrossReference_3_1_0()); |
28446 | before(grammarAccess.getClassDefinitionAccess().getSuperclassesNamedElementCrossReference_3_1_0()); | 26002 | // InternalSolverLanguageParser.g:8585:3: ( ruleQualifiedName ) |
28447 | } | 26003 | // InternalSolverLanguageParser.g:8586:4: ruleQualifiedName |
28448 | // InternalSolverLanguage.g:8710:3: ( ruleQualifiedName ) | ||
28449 | // InternalSolverLanguage.g:8711:4: ruleQualifiedName | ||
28450 | { | 26004 | { |
28451 | if ( state.backtracking==0 ) { | 26005 | before(grammarAccess.getClassDefinitionAccess().getSuperclassesNamedElementQualifiedNameParserRuleCall_3_1_0_1()); |
28452 | before(grammarAccess.getClassDefinitionAccess().getSuperclassesNamedElementQualifiedNameParserRuleCall_3_1_0_1()); | ||
28453 | } | ||
28454 | pushFollow(FOLLOW_2); | 26006 | pushFollow(FOLLOW_2); |
28455 | ruleQualifiedName(); | 26007 | ruleQualifiedName(); |
28456 | 26008 | ||
28457 | state._fsp--; | 26009 | state._fsp--; |
28458 | if (state.failed) return ; | ||
28459 | if ( state.backtracking==0 ) { | ||
28460 | after(grammarAccess.getClassDefinitionAccess().getSuperclassesNamedElementQualifiedNameParserRuleCall_3_1_0_1()); | ||
28461 | } | ||
28462 | 26010 | ||
28463 | } | 26011 | after(grammarAccess.getClassDefinitionAccess().getSuperclassesNamedElementQualifiedNameParserRuleCall_3_1_0_1()); |
28464 | 26012 | ||
28465 | if ( state.backtracking==0 ) { | ||
28466 | after(grammarAccess.getClassDefinitionAccess().getSuperclassesNamedElementCrossReference_3_1_0()); | ||
28467 | } | 26013 | } |
28468 | 26014 | ||
26015 | after(grammarAccess.getClassDefinitionAccess().getSuperclassesNamedElementCrossReference_3_1_0()); | ||
26016 | |||
28469 | } | 26017 | } |
28470 | 26018 | ||
28471 | 26019 | ||
@@ -28487,42 +26035,34 @@ public class InternalSolverLanguageParser extends AbstractInternalContentAssistP | |||
28487 | 26035 | ||
28488 | 26036 | ||
28489 | // $ANTLR start "rule__ClassDefinition__SuperclassesAssignment_3_2_1" | 26037 | // $ANTLR start "rule__ClassDefinition__SuperclassesAssignment_3_2_1" |
28490 | // InternalSolverLanguage.g:8722:1: rule__ClassDefinition__SuperclassesAssignment_3_2_1 : ( ( ruleQualifiedName ) ) ; | 26038 | // InternalSolverLanguageParser.g:8597:1: rule__ClassDefinition__SuperclassesAssignment_3_2_1 : ( ( ruleQualifiedName ) ) ; |
28491 | public final void rule__ClassDefinition__SuperclassesAssignment_3_2_1() throws RecognitionException { | 26039 | public final void rule__ClassDefinition__SuperclassesAssignment_3_2_1() throws RecognitionException { |
28492 | 26040 | ||
28493 | int stackSize = keepStackSize(); | 26041 | int stackSize = keepStackSize(); |
28494 | 26042 | ||
28495 | try { | 26043 | try { |
28496 | // InternalSolverLanguage.g:8726:1: ( ( ( ruleQualifiedName ) ) ) | 26044 | // InternalSolverLanguageParser.g:8601:1: ( ( ( ruleQualifiedName ) ) ) |
28497 | // InternalSolverLanguage.g:8727:2: ( ( ruleQualifiedName ) ) | 26045 | // InternalSolverLanguageParser.g:8602:2: ( ( ruleQualifiedName ) ) |
28498 | { | 26046 | { |
28499 | // InternalSolverLanguage.g:8727:2: ( ( ruleQualifiedName ) ) | 26047 | // InternalSolverLanguageParser.g:8602:2: ( ( ruleQualifiedName ) ) |
28500 | // InternalSolverLanguage.g:8728:3: ( ruleQualifiedName ) | 26048 | // InternalSolverLanguageParser.g:8603:3: ( ruleQualifiedName ) |
28501 | { | 26049 | { |
28502 | if ( state.backtracking==0 ) { | 26050 | before(grammarAccess.getClassDefinitionAccess().getSuperclassesNamedElementCrossReference_3_2_1_0()); |
28503 | before(grammarAccess.getClassDefinitionAccess().getSuperclassesNamedElementCrossReference_3_2_1_0()); | 26051 | // InternalSolverLanguageParser.g:8604:3: ( ruleQualifiedName ) |
28504 | } | 26052 | // InternalSolverLanguageParser.g:8605:4: ruleQualifiedName |
28505 | // InternalSolverLanguage.g:8729:3: ( ruleQualifiedName ) | ||
28506 | // InternalSolverLanguage.g:8730:4: ruleQualifiedName | ||
28507 | { | 26053 | { |
28508 | if ( state.backtracking==0 ) { | 26054 | before(grammarAccess.getClassDefinitionAccess().getSuperclassesNamedElementQualifiedNameParserRuleCall_3_2_1_0_1()); |
28509 | before(grammarAccess.getClassDefinitionAccess().getSuperclassesNamedElementQualifiedNameParserRuleCall_3_2_1_0_1()); | ||
28510 | } | ||
28511 | pushFollow(FOLLOW_2); | 26055 | pushFollow(FOLLOW_2); |
28512 | ruleQualifiedName(); | 26056 | ruleQualifiedName(); |
28513 | 26057 | ||
28514 | state._fsp--; | 26058 | state._fsp--; |
28515 | if (state.failed) return ; | ||
28516 | if ( state.backtracking==0 ) { | ||
28517 | after(grammarAccess.getClassDefinitionAccess().getSuperclassesNamedElementQualifiedNameParserRuleCall_3_2_1_0_1()); | ||
28518 | } | ||
28519 | 26059 | ||
28520 | } | 26060 | after(grammarAccess.getClassDefinitionAccess().getSuperclassesNamedElementQualifiedNameParserRuleCall_3_2_1_0_1()); |
28521 | 26061 | ||
28522 | if ( state.backtracking==0 ) { | ||
28523 | after(grammarAccess.getClassDefinitionAccess().getSuperclassesNamedElementCrossReference_3_2_1_0()); | ||
28524 | } | 26062 | } |
28525 | 26063 | ||
26064 | after(grammarAccess.getClassDefinitionAccess().getSuperclassesNamedElementCrossReference_3_2_1_0()); | ||
26065 | |||
28526 | } | 26066 | } |
28527 | 26067 | ||
28528 | 26068 | ||
@@ -28544,29 +26084,25 @@ public class InternalSolverLanguageParser extends AbstractInternalContentAssistP | |||
28544 | 26084 | ||
28545 | 26085 | ||
28546 | // $ANTLR start "rule__ClassDefinition__MembersAssignment_5" | 26086 | // $ANTLR start "rule__ClassDefinition__MembersAssignment_5" |
28547 | // InternalSolverLanguage.g:8741:1: rule__ClassDefinition__MembersAssignment_5 : ( ruleMemberDefinition ) ; | 26087 | // InternalSolverLanguageParser.g:8616:1: rule__ClassDefinition__MembersAssignment_5 : ( ruleMemberDefinition ) ; |
28548 | public final void rule__ClassDefinition__MembersAssignment_5() throws RecognitionException { | 26088 | public final void rule__ClassDefinition__MembersAssignment_5() throws RecognitionException { |
28549 | 26089 | ||
28550 | int stackSize = keepStackSize(); | 26090 | int stackSize = keepStackSize(); |
28551 | 26091 | ||
28552 | try { | 26092 | try { |
28553 | // InternalSolverLanguage.g:8745:1: ( ( ruleMemberDefinition ) ) | 26093 | // InternalSolverLanguageParser.g:8620:1: ( ( ruleMemberDefinition ) ) |
28554 | // InternalSolverLanguage.g:8746:2: ( ruleMemberDefinition ) | 26094 | // InternalSolverLanguageParser.g:8621:2: ( ruleMemberDefinition ) |
28555 | { | 26095 | { |
28556 | // InternalSolverLanguage.g:8746:2: ( ruleMemberDefinition ) | 26096 | // InternalSolverLanguageParser.g:8621:2: ( ruleMemberDefinition ) |
28557 | // InternalSolverLanguage.g:8747:3: ruleMemberDefinition | 26097 | // InternalSolverLanguageParser.g:8622:3: ruleMemberDefinition |
28558 | { | 26098 | { |
28559 | if ( state.backtracking==0 ) { | 26099 | before(grammarAccess.getClassDefinitionAccess().getMembersMemberDefinitionParserRuleCall_5_0()); |
28560 | before(grammarAccess.getClassDefinitionAccess().getMembersMemberDefinitionParserRuleCall_5_0()); | ||
28561 | } | ||
28562 | pushFollow(FOLLOW_2); | 26100 | pushFollow(FOLLOW_2); |
28563 | ruleMemberDefinition(); | 26101 | ruleMemberDefinition(); |
28564 | 26102 | ||
28565 | state._fsp--; | 26103 | state._fsp--; |
28566 | if (state.failed) return ; | 26104 | |
28567 | if ( state.backtracking==0 ) { | 26105 | after(grammarAccess.getClassDefinitionAccess().getMembersMemberDefinitionParserRuleCall_5_0()); |
28568 | after(grammarAccess.getClassDefinitionAccess().getMembersMemberDefinitionParserRuleCall_5_0()); | ||
28569 | } | ||
28570 | 26106 | ||
28571 | } | 26107 | } |
28572 | 26108 | ||
@@ -28589,37 +26125,29 @@ public class InternalSolverLanguageParser extends AbstractInternalContentAssistP | |||
28589 | 26125 | ||
28590 | 26126 | ||
28591 | // $ANTLR start "rule__MemberDefinition__ContainmentAssignment_0" | 26127 | // $ANTLR start "rule__MemberDefinition__ContainmentAssignment_0" |
28592 | // InternalSolverLanguage.g:8756:1: rule__MemberDefinition__ContainmentAssignment_0 : ( ( 'contains' ) ) ; | 26128 | // InternalSolverLanguageParser.g:8631:1: rule__MemberDefinition__ContainmentAssignment_0 : ( ( Contains ) ) ; |
28593 | public final void rule__MemberDefinition__ContainmentAssignment_0() throws RecognitionException { | 26129 | public final void rule__MemberDefinition__ContainmentAssignment_0() throws RecognitionException { |
28594 | 26130 | ||
28595 | int stackSize = keepStackSize(); | 26131 | int stackSize = keepStackSize(); |
28596 | 26132 | ||
28597 | try { | 26133 | try { |
28598 | // InternalSolverLanguage.g:8760:1: ( ( ( 'contains' ) ) ) | 26134 | // InternalSolverLanguageParser.g:8635:1: ( ( ( Contains ) ) ) |
28599 | // InternalSolverLanguage.g:8761:2: ( ( 'contains' ) ) | 26135 | // InternalSolverLanguageParser.g:8636:2: ( ( Contains ) ) |
28600 | { | 26136 | { |
28601 | // InternalSolverLanguage.g:8761:2: ( ( 'contains' ) ) | 26137 | // InternalSolverLanguageParser.g:8636:2: ( ( Contains ) ) |
28602 | // InternalSolverLanguage.g:8762:3: ( 'contains' ) | 26138 | // InternalSolverLanguageParser.g:8637:3: ( Contains ) |
28603 | { | 26139 | { |
28604 | if ( state.backtracking==0 ) { | 26140 | before(grammarAccess.getMemberDefinitionAccess().getContainmentContainsKeyword_0_0()); |
28605 | before(grammarAccess.getMemberDefinitionAccess().getContainmentContainsKeyword_0_0()); | 26141 | // InternalSolverLanguageParser.g:8638:3: ( Contains ) |
28606 | } | 26142 | // InternalSolverLanguageParser.g:8639:4: Contains |
28607 | // InternalSolverLanguage.g:8763:3: ( 'contains' ) | ||
28608 | // InternalSolverLanguage.g:8764:4: 'contains' | ||
28609 | { | 26143 | { |
28610 | if ( state.backtracking==0 ) { | 26144 | before(grammarAccess.getMemberDefinitionAccess().getContainmentContainsKeyword_0_0()); |
28611 | before(grammarAccess.getMemberDefinitionAccess().getContainmentContainsKeyword_0_0()); | 26145 | match(input,Contains,FOLLOW_2); |
28612 | } | 26146 | after(grammarAccess.getMemberDefinitionAccess().getContainmentContainsKeyword_0_0()); |
28613 | match(input,74,FOLLOW_2); if (state.failed) return ; | ||
28614 | if ( state.backtracking==0 ) { | ||
28615 | after(grammarAccess.getMemberDefinitionAccess().getContainmentContainsKeyword_0_0()); | ||
28616 | } | ||
28617 | 26147 | ||
28618 | } | 26148 | } |
28619 | 26149 | ||
28620 | if ( state.backtracking==0 ) { | 26150 | after(grammarAccess.getMemberDefinitionAccess().getContainmentContainsKeyword_0_0()); |
28621 | after(grammarAccess.getMemberDefinitionAccess().getContainmentContainsKeyword_0_0()); | ||
28622 | } | ||
28623 | 26151 | ||
28624 | } | 26152 | } |
28625 | 26153 | ||
@@ -28642,42 +26170,34 @@ public class InternalSolverLanguageParser extends AbstractInternalContentAssistP | |||
28642 | 26170 | ||
28643 | 26171 | ||
28644 | // $ANTLR start "rule__MemberDefinition__TypeAssignment_1" | 26172 | // $ANTLR start "rule__MemberDefinition__TypeAssignment_1" |
28645 | // InternalSolverLanguage.g:8775:1: rule__MemberDefinition__TypeAssignment_1 : ( ( ruleQualifiedName ) ) ; | 26173 | // InternalSolverLanguageParser.g:8650:1: rule__MemberDefinition__TypeAssignment_1 : ( ( ruleQualifiedName ) ) ; |
28646 | public final void rule__MemberDefinition__TypeAssignment_1() throws RecognitionException { | 26174 | public final void rule__MemberDefinition__TypeAssignment_1() throws RecognitionException { |
28647 | 26175 | ||
28648 | int stackSize = keepStackSize(); | 26176 | int stackSize = keepStackSize(); |
28649 | 26177 | ||
28650 | try { | 26178 | try { |
28651 | // InternalSolverLanguage.g:8779:1: ( ( ( ruleQualifiedName ) ) ) | 26179 | // InternalSolverLanguageParser.g:8654:1: ( ( ( ruleQualifiedName ) ) ) |
28652 | // InternalSolverLanguage.g:8780:2: ( ( ruleQualifiedName ) ) | 26180 | // InternalSolverLanguageParser.g:8655:2: ( ( ruleQualifiedName ) ) |
28653 | { | 26181 | { |
28654 | // InternalSolverLanguage.g:8780:2: ( ( ruleQualifiedName ) ) | 26182 | // InternalSolverLanguageParser.g:8655:2: ( ( ruleQualifiedName ) ) |
28655 | // InternalSolverLanguage.g:8781:3: ( ruleQualifiedName ) | 26183 | // InternalSolverLanguageParser.g:8656:3: ( ruleQualifiedName ) |
28656 | { | 26184 | { |
28657 | if ( state.backtracking==0 ) { | 26185 | before(grammarAccess.getMemberDefinitionAccess().getTypeNamedElementCrossReference_1_0()); |
28658 | before(grammarAccess.getMemberDefinitionAccess().getTypeNamedElementCrossReference_1_0()); | 26186 | // InternalSolverLanguageParser.g:8657:3: ( ruleQualifiedName ) |
28659 | } | 26187 | // InternalSolverLanguageParser.g:8658:4: ruleQualifiedName |
28660 | // InternalSolverLanguage.g:8782:3: ( ruleQualifiedName ) | ||
28661 | // InternalSolverLanguage.g:8783:4: ruleQualifiedName | ||
28662 | { | 26188 | { |
28663 | if ( state.backtracking==0 ) { | 26189 | before(grammarAccess.getMemberDefinitionAccess().getTypeNamedElementQualifiedNameParserRuleCall_1_0_1()); |
28664 | before(grammarAccess.getMemberDefinitionAccess().getTypeNamedElementQualifiedNameParserRuleCall_1_0_1()); | ||
28665 | } | ||
28666 | pushFollow(FOLLOW_2); | 26190 | pushFollow(FOLLOW_2); |
28667 | ruleQualifiedName(); | 26191 | ruleQualifiedName(); |
28668 | 26192 | ||
28669 | state._fsp--; | 26193 | state._fsp--; |
28670 | if (state.failed) return ; | ||
28671 | if ( state.backtracking==0 ) { | ||
28672 | after(grammarAccess.getMemberDefinitionAccess().getTypeNamedElementQualifiedNameParserRuleCall_1_0_1()); | ||
28673 | } | ||
28674 | 26194 | ||
28675 | } | 26195 | after(grammarAccess.getMemberDefinitionAccess().getTypeNamedElementQualifiedNameParserRuleCall_1_0_1()); |
28676 | 26196 | ||
28677 | if ( state.backtracking==0 ) { | ||
28678 | after(grammarAccess.getMemberDefinitionAccess().getTypeNamedElementCrossReference_1_0()); | ||
28679 | } | 26197 | } |
28680 | 26198 | ||
26199 | after(grammarAccess.getMemberDefinitionAccess().getTypeNamedElementCrossReference_1_0()); | ||
26200 | |||
28681 | } | 26201 | } |
28682 | 26202 | ||
28683 | 26203 | ||
@@ -28699,29 +26219,25 @@ public class InternalSolverLanguageParser extends AbstractInternalContentAssistP | |||
28699 | 26219 | ||
28700 | 26220 | ||
28701 | // $ANTLR start "rule__MemberDefinition__MultiplicityAssignment_2" | 26221 | // $ANTLR start "rule__MemberDefinition__MultiplicityAssignment_2" |
28702 | // InternalSolverLanguage.g:8794:1: rule__MemberDefinition__MultiplicityAssignment_2 : ( ruleMultiplicity ) ; | 26222 | // InternalSolverLanguageParser.g:8669:1: rule__MemberDefinition__MultiplicityAssignment_2 : ( ruleMultiplicity ) ; |
28703 | public final void rule__MemberDefinition__MultiplicityAssignment_2() throws RecognitionException { | 26223 | public final void rule__MemberDefinition__MultiplicityAssignment_2() throws RecognitionException { |
28704 | 26224 | ||
28705 | int stackSize = keepStackSize(); | 26225 | int stackSize = keepStackSize(); |
28706 | 26226 | ||
28707 | try { | 26227 | try { |
28708 | // InternalSolverLanguage.g:8798:1: ( ( ruleMultiplicity ) ) | 26228 | // InternalSolverLanguageParser.g:8673:1: ( ( ruleMultiplicity ) ) |
28709 | // InternalSolverLanguage.g:8799:2: ( ruleMultiplicity ) | 26229 | // InternalSolverLanguageParser.g:8674:2: ( ruleMultiplicity ) |
28710 | { | 26230 | { |
28711 | // InternalSolverLanguage.g:8799:2: ( ruleMultiplicity ) | 26231 | // InternalSolverLanguageParser.g:8674:2: ( ruleMultiplicity ) |
28712 | // InternalSolverLanguage.g:8800:3: ruleMultiplicity | 26232 | // InternalSolverLanguageParser.g:8675:3: ruleMultiplicity |
28713 | { | 26233 | { |
28714 | if ( state.backtracking==0 ) { | 26234 | before(grammarAccess.getMemberDefinitionAccess().getMultiplicityMultiplicityParserRuleCall_2_0()); |
28715 | before(grammarAccess.getMemberDefinitionAccess().getMultiplicityMultiplicityParserRuleCall_2_0()); | ||
28716 | } | ||
28717 | pushFollow(FOLLOW_2); | 26235 | pushFollow(FOLLOW_2); |
28718 | ruleMultiplicity(); | 26236 | ruleMultiplicity(); |
28719 | 26237 | ||
28720 | state._fsp--; | 26238 | state._fsp--; |
28721 | if (state.failed) return ; | 26239 | |
28722 | if ( state.backtracking==0 ) { | 26240 | after(grammarAccess.getMemberDefinitionAccess().getMultiplicityMultiplicityParserRuleCall_2_0()); |
28723 | after(grammarAccess.getMemberDefinitionAccess().getMultiplicityMultiplicityParserRuleCall_2_0()); | ||
28724 | } | ||
28725 | 26241 | ||
28726 | } | 26242 | } |
28727 | 26243 | ||
@@ -28744,25 +26260,21 @@ public class InternalSolverLanguageParser extends AbstractInternalContentAssistP | |||
28744 | 26260 | ||
28745 | 26261 | ||
28746 | // $ANTLR start "rule__MemberDefinition__NameAssignment_3" | 26262 | // $ANTLR start "rule__MemberDefinition__NameAssignment_3" |
28747 | // InternalSolverLanguage.g:8809:1: rule__MemberDefinition__NameAssignment_3 : ( RULE_ID ) ; | 26263 | // InternalSolverLanguageParser.g:8684:1: rule__MemberDefinition__NameAssignment_3 : ( RULE_ID ) ; |
28748 | public final void rule__MemberDefinition__NameAssignment_3() throws RecognitionException { | 26264 | public final void rule__MemberDefinition__NameAssignment_3() throws RecognitionException { |
28749 | 26265 | ||
28750 | int stackSize = keepStackSize(); | 26266 | int stackSize = keepStackSize(); |
28751 | 26267 | ||
28752 | try { | 26268 | try { |
28753 | // InternalSolverLanguage.g:8813:1: ( ( RULE_ID ) ) | 26269 | // InternalSolverLanguageParser.g:8688:1: ( ( RULE_ID ) ) |
28754 | // InternalSolverLanguage.g:8814:2: ( RULE_ID ) | 26270 | // InternalSolverLanguageParser.g:8689:2: ( RULE_ID ) |
28755 | { | 26271 | { |
28756 | // InternalSolverLanguage.g:8814:2: ( RULE_ID ) | 26272 | // InternalSolverLanguageParser.g:8689:2: ( RULE_ID ) |
28757 | // InternalSolverLanguage.g:8815:3: RULE_ID | 26273 | // InternalSolverLanguageParser.g:8690:3: RULE_ID |
28758 | { | 26274 | { |
28759 | if ( state.backtracking==0 ) { | 26275 | before(grammarAccess.getMemberDefinitionAccess().getNameIDTerminalRuleCall_3_0()); |
28760 | before(grammarAccess.getMemberDefinitionAccess().getNameIDTerminalRuleCall_3_0()); | 26276 | match(input,RULE_ID,FOLLOW_2); |
28761 | } | 26277 | after(grammarAccess.getMemberDefinitionAccess().getNameIDTerminalRuleCall_3_0()); |
28762 | match(input,RULE_ID,FOLLOW_2); if (state.failed) return ; | ||
28763 | if ( state.backtracking==0 ) { | ||
28764 | after(grammarAccess.getMemberDefinitionAccess().getNameIDTerminalRuleCall_3_0()); | ||
28765 | } | ||
28766 | 26278 | ||
28767 | } | 26279 | } |
28768 | 26280 | ||
@@ -28785,42 +26297,34 @@ public class InternalSolverLanguageParser extends AbstractInternalContentAssistP | |||
28785 | 26297 | ||
28786 | 26298 | ||
28787 | // $ANTLR start "rule__MemberDefinition__OppositeAssignment_4_1" | 26299 | // $ANTLR start "rule__MemberDefinition__OppositeAssignment_4_1" |
28788 | // InternalSolverLanguage.g:8824:1: rule__MemberDefinition__OppositeAssignment_4_1 : ( ( ruleQualifiedName ) ) ; | 26300 | // InternalSolverLanguageParser.g:8699:1: rule__MemberDefinition__OppositeAssignment_4_1 : ( ( ruleQualifiedName ) ) ; |
28789 | public final void rule__MemberDefinition__OppositeAssignment_4_1() throws RecognitionException { | 26301 | public final void rule__MemberDefinition__OppositeAssignment_4_1() throws RecognitionException { |
28790 | 26302 | ||
28791 | int stackSize = keepStackSize(); | 26303 | int stackSize = keepStackSize(); |
28792 | 26304 | ||
28793 | try { | 26305 | try { |
28794 | // InternalSolverLanguage.g:8828:1: ( ( ( ruleQualifiedName ) ) ) | 26306 | // InternalSolverLanguageParser.g:8703:1: ( ( ( ruleQualifiedName ) ) ) |
28795 | // InternalSolverLanguage.g:8829:2: ( ( ruleQualifiedName ) ) | 26307 | // InternalSolverLanguageParser.g:8704:2: ( ( ruleQualifiedName ) ) |
28796 | { | 26308 | { |
28797 | // InternalSolverLanguage.g:8829:2: ( ( ruleQualifiedName ) ) | 26309 | // InternalSolverLanguageParser.g:8704:2: ( ( ruleQualifiedName ) ) |
28798 | // InternalSolverLanguage.g:8830:3: ( ruleQualifiedName ) | 26310 | // InternalSolverLanguageParser.g:8705:3: ( ruleQualifiedName ) |
28799 | { | 26311 | { |
28800 | if ( state.backtracking==0 ) { | 26312 | before(grammarAccess.getMemberDefinitionAccess().getOppositeNamedElementCrossReference_4_1_0()); |
28801 | before(grammarAccess.getMemberDefinitionAccess().getOppositeNamedElementCrossReference_4_1_0()); | 26313 | // InternalSolverLanguageParser.g:8706:3: ( ruleQualifiedName ) |
28802 | } | 26314 | // InternalSolverLanguageParser.g:8707:4: ruleQualifiedName |
28803 | // InternalSolverLanguage.g:8831:3: ( ruleQualifiedName ) | ||
28804 | // InternalSolverLanguage.g:8832:4: ruleQualifiedName | ||
28805 | { | 26315 | { |
28806 | if ( state.backtracking==0 ) { | 26316 | before(grammarAccess.getMemberDefinitionAccess().getOppositeNamedElementQualifiedNameParserRuleCall_4_1_0_1()); |
28807 | before(grammarAccess.getMemberDefinitionAccess().getOppositeNamedElementQualifiedNameParserRuleCall_4_1_0_1()); | ||
28808 | } | ||
28809 | pushFollow(FOLLOW_2); | 26317 | pushFollow(FOLLOW_2); |
28810 | ruleQualifiedName(); | 26318 | ruleQualifiedName(); |
28811 | 26319 | ||
28812 | state._fsp--; | 26320 | state._fsp--; |
28813 | if (state.failed) return ; | ||
28814 | if ( state.backtracking==0 ) { | ||
28815 | after(grammarAccess.getMemberDefinitionAccess().getOppositeNamedElementQualifiedNameParserRuleCall_4_1_0_1()); | ||
28816 | } | ||
28817 | 26321 | ||
28818 | } | 26322 | after(grammarAccess.getMemberDefinitionAccess().getOppositeNamedElementQualifiedNameParserRuleCall_4_1_0_1()); |
28819 | 26323 | ||
28820 | if ( state.backtracking==0 ) { | ||
28821 | after(grammarAccess.getMemberDefinitionAccess().getOppositeNamedElementCrossReference_4_1_0()); | ||
28822 | } | 26324 | } |
28823 | 26325 | ||
26326 | after(grammarAccess.getMemberDefinitionAccess().getOppositeNamedElementCrossReference_4_1_0()); | ||
26327 | |||
28824 | } | 26328 | } |
28825 | 26329 | ||
28826 | 26330 | ||
@@ -28842,29 +26346,25 @@ public class InternalSolverLanguageParser extends AbstractInternalContentAssistP | |||
28842 | 26346 | ||
28843 | 26347 | ||
28844 | // $ANTLR start "rule__ExactMultiplicity__MultiplicityAssignment_1" | 26348 | // $ANTLR start "rule__ExactMultiplicity__MultiplicityAssignment_1" |
28845 | // InternalSolverLanguage.g:8843:1: rule__ExactMultiplicity__MultiplicityAssignment_1 : ( ruleUpperMultiplicty ) ; | 26349 | // InternalSolverLanguageParser.g:8718:1: rule__ExactMultiplicity__MultiplicityAssignment_1 : ( ruleUpperMultiplicty ) ; |
28846 | public final void rule__ExactMultiplicity__MultiplicityAssignment_1() throws RecognitionException { | 26350 | public final void rule__ExactMultiplicity__MultiplicityAssignment_1() throws RecognitionException { |
28847 | 26351 | ||
28848 | int stackSize = keepStackSize(); | 26352 | int stackSize = keepStackSize(); |
28849 | 26353 | ||
28850 | try { | 26354 | try { |
28851 | // InternalSolverLanguage.g:8847:1: ( ( ruleUpperMultiplicty ) ) | 26355 | // InternalSolverLanguageParser.g:8722:1: ( ( ruleUpperMultiplicty ) ) |
28852 | // InternalSolverLanguage.g:8848:2: ( ruleUpperMultiplicty ) | 26356 | // InternalSolverLanguageParser.g:8723:2: ( ruleUpperMultiplicty ) |
28853 | { | 26357 | { |
28854 | // InternalSolverLanguage.g:8848:2: ( ruleUpperMultiplicty ) | 26358 | // InternalSolverLanguageParser.g:8723:2: ( ruleUpperMultiplicty ) |
28855 | // InternalSolverLanguage.g:8849:3: ruleUpperMultiplicty | 26359 | // InternalSolverLanguageParser.g:8724:3: ruleUpperMultiplicty |
28856 | { | 26360 | { |
28857 | if ( state.backtracking==0 ) { | 26361 | before(grammarAccess.getExactMultiplicityAccess().getMultiplicityUpperMultiplictyParserRuleCall_1_0()); |
28858 | before(grammarAccess.getExactMultiplicityAccess().getMultiplicityUpperMultiplictyParserRuleCall_1_0()); | ||
28859 | } | ||
28860 | pushFollow(FOLLOW_2); | 26362 | pushFollow(FOLLOW_2); |
28861 | ruleUpperMultiplicty(); | 26363 | ruleUpperMultiplicty(); |
28862 | 26364 | ||
28863 | state._fsp--; | 26365 | state._fsp--; |
28864 | if (state.failed) return ; | 26366 | |
28865 | if ( state.backtracking==0 ) { | 26367 | after(grammarAccess.getExactMultiplicityAccess().getMultiplicityUpperMultiplictyParserRuleCall_1_0()); |
28866 | after(grammarAccess.getExactMultiplicityAccess().getMultiplicityUpperMultiplictyParserRuleCall_1_0()); | ||
28867 | } | ||
28868 | 26368 | ||
28869 | } | 26369 | } |
28870 | 26370 | ||
@@ -28887,25 +26387,21 @@ public class InternalSolverLanguageParser extends AbstractInternalContentAssistP | |||
28887 | 26387 | ||
28888 | 26388 | ||
28889 | // $ANTLR start "rule__BoundedMultiplicity__LowerBoundAssignment_1" | 26389 | // $ANTLR start "rule__BoundedMultiplicity__LowerBoundAssignment_1" |
28890 | // InternalSolverLanguage.g:8858:1: rule__BoundedMultiplicity__LowerBoundAssignment_1 : ( RULE_INT ) ; | 26390 | // InternalSolverLanguageParser.g:8733:1: rule__BoundedMultiplicity__LowerBoundAssignment_1 : ( RULE_INT ) ; |
28891 | public final void rule__BoundedMultiplicity__LowerBoundAssignment_1() throws RecognitionException { | 26391 | public final void rule__BoundedMultiplicity__LowerBoundAssignment_1() throws RecognitionException { |
28892 | 26392 | ||
28893 | int stackSize = keepStackSize(); | 26393 | int stackSize = keepStackSize(); |
28894 | 26394 | ||
28895 | try { | 26395 | try { |
28896 | // InternalSolverLanguage.g:8862:1: ( ( RULE_INT ) ) | 26396 | // InternalSolverLanguageParser.g:8737:1: ( ( RULE_INT ) ) |
28897 | // InternalSolverLanguage.g:8863:2: ( RULE_INT ) | 26397 | // InternalSolverLanguageParser.g:8738:2: ( RULE_INT ) |
28898 | { | 26398 | { |
28899 | // InternalSolverLanguage.g:8863:2: ( RULE_INT ) | 26399 | // InternalSolverLanguageParser.g:8738:2: ( RULE_INT ) |
28900 | // InternalSolverLanguage.g:8864:3: RULE_INT | 26400 | // InternalSolverLanguageParser.g:8739:3: RULE_INT |
28901 | { | 26401 | { |
28902 | if ( state.backtracking==0 ) { | 26402 | before(grammarAccess.getBoundedMultiplicityAccess().getLowerBoundINTTerminalRuleCall_1_0()); |
28903 | before(grammarAccess.getBoundedMultiplicityAccess().getLowerBoundINTTerminalRuleCall_1_0()); | 26403 | match(input,RULE_INT,FOLLOW_2); |
28904 | } | 26404 | after(grammarAccess.getBoundedMultiplicityAccess().getLowerBoundINTTerminalRuleCall_1_0()); |
28905 | match(input,RULE_INT,FOLLOW_2); if (state.failed) return ; | ||
28906 | if ( state.backtracking==0 ) { | ||
28907 | after(grammarAccess.getBoundedMultiplicityAccess().getLowerBoundINTTerminalRuleCall_1_0()); | ||
28908 | } | ||
28909 | 26405 | ||
28910 | } | 26406 | } |
28911 | 26407 | ||
@@ -28928,29 +26424,25 @@ public class InternalSolverLanguageParser extends AbstractInternalContentAssistP | |||
28928 | 26424 | ||
28929 | 26425 | ||
28930 | // $ANTLR start "rule__BoundedMultiplicity__UpperBoundAssignment_3" | 26426 | // $ANTLR start "rule__BoundedMultiplicity__UpperBoundAssignment_3" |
28931 | // InternalSolverLanguage.g:8873:1: rule__BoundedMultiplicity__UpperBoundAssignment_3 : ( ruleUpperMultiplicty ) ; | 26427 | // InternalSolverLanguageParser.g:8748:1: rule__BoundedMultiplicity__UpperBoundAssignment_3 : ( ruleUpperMultiplicty ) ; |
28932 | public final void rule__BoundedMultiplicity__UpperBoundAssignment_3() throws RecognitionException { | 26428 | public final void rule__BoundedMultiplicity__UpperBoundAssignment_3() throws RecognitionException { |
28933 | 26429 | ||
28934 | int stackSize = keepStackSize(); | 26430 | int stackSize = keepStackSize(); |
28935 | 26431 | ||
28936 | try { | 26432 | try { |
28937 | // InternalSolverLanguage.g:8877:1: ( ( ruleUpperMultiplicty ) ) | 26433 | // InternalSolverLanguageParser.g:8752:1: ( ( ruleUpperMultiplicty ) ) |
28938 | // InternalSolverLanguage.g:8878:2: ( ruleUpperMultiplicty ) | 26434 | // InternalSolverLanguageParser.g:8753:2: ( ruleUpperMultiplicty ) |
28939 | { | 26435 | { |
28940 | // InternalSolverLanguage.g:8878:2: ( ruleUpperMultiplicty ) | 26436 | // InternalSolverLanguageParser.g:8753:2: ( ruleUpperMultiplicty ) |
28941 | // InternalSolverLanguage.g:8879:3: ruleUpperMultiplicty | 26437 | // InternalSolverLanguageParser.g:8754:3: ruleUpperMultiplicty |
28942 | { | 26438 | { |
28943 | if ( state.backtracking==0 ) { | 26439 | before(grammarAccess.getBoundedMultiplicityAccess().getUpperBoundUpperMultiplictyParserRuleCall_3_0()); |
28944 | before(grammarAccess.getBoundedMultiplicityAccess().getUpperBoundUpperMultiplictyParserRuleCall_3_0()); | ||
28945 | } | ||
28946 | pushFollow(FOLLOW_2); | 26440 | pushFollow(FOLLOW_2); |
28947 | ruleUpperMultiplicty(); | 26441 | ruleUpperMultiplicty(); |
28948 | 26442 | ||
28949 | state._fsp--; | 26443 | state._fsp--; |
28950 | if (state.failed) return ; | 26444 | |
28951 | if ( state.backtracking==0 ) { | 26445 | after(grammarAccess.getBoundedMultiplicityAccess().getUpperBoundUpperMultiplictyParserRuleCall_3_0()); |
28952 | after(grammarAccess.getBoundedMultiplicityAccess().getUpperBoundUpperMultiplictyParserRuleCall_3_0()); | ||
28953 | } | ||
28954 | 26446 | ||
28955 | } | 26447 | } |
28956 | 26448 | ||
@@ -28973,42 +26465,34 @@ public class InternalSolverLanguageParser extends AbstractInternalContentAssistP | |||
28973 | 26465 | ||
28974 | 26466 | ||
28975 | // $ANTLR start "rule__ExactScopeDefinition__TypeAssignment_1" | 26467 | // $ANTLR start "rule__ExactScopeDefinition__TypeAssignment_1" |
28976 | // InternalSolverLanguage.g:8888:1: rule__ExactScopeDefinition__TypeAssignment_1 : ( ( ruleQualifiedName ) ) ; | 26468 | // InternalSolverLanguageParser.g:8763:1: rule__ExactScopeDefinition__TypeAssignment_1 : ( ( ruleQualifiedName ) ) ; |
28977 | public final void rule__ExactScopeDefinition__TypeAssignment_1() throws RecognitionException { | 26469 | public final void rule__ExactScopeDefinition__TypeAssignment_1() throws RecognitionException { |
28978 | 26470 | ||
28979 | int stackSize = keepStackSize(); | 26471 | int stackSize = keepStackSize(); |
28980 | 26472 | ||
28981 | try { | 26473 | try { |
28982 | // InternalSolverLanguage.g:8892:1: ( ( ( ruleQualifiedName ) ) ) | 26474 | // InternalSolverLanguageParser.g:8767:1: ( ( ( ruleQualifiedName ) ) ) |
28983 | // InternalSolverLanguage.g:8893:2: ( ( ruleQualifiedName ) ) | 26475 | // InternalSolverLanguageParser.g:8768:2: ( ( ruleQualifiedName ) ) |
28984 | { | 26476 | { |
28985 | // InternalSolverLanguage.g:8893:2: ( ( ruleQualifiedName ) ) | 26477 | // InternalSolverLanguageParser.g:8768:2: ( ( ruleQualifiedName ) ) |
28986 | // InternalSolverLanguage.g:8894:3: ( ruleQualifiedName ) | 26478 | // InternalSolverLanguageParser.g:8769:3: ( ruleQualifiedName ) |
28987 | { | 26479 | { |
28988 | if ( state.backtracking==0 ) { | 26480 | before(grammarAccess.getExactScopeDefinitionAccess().getTypeNamedElementCrossReference_1_0()); |
28989 | before(grammarAccess.getExactScopeDefinitionAccess().getTypeNamedElementCrossReference_1_0()); | 26481 | // InternalSolverLanguageParser.g:8770:3: ( ruleQualifiedName ) |
28990 | } | 26482 | // InternalSolverLanguageParser.g:8771:4: ruleQualifiedName |
28991 | // InternalSolverLanguage.g:8895:3: ( ruleQualifiedName ) | ||
28992 | // InternalSolverLanguage.g:8896:4: ruleQualifiedName | ||
28993 | { | 26483 | { |
28994 | if ( state.backtracking==0 ) { | 26484 | before(grammarAccess.getExactScopeDefinitionAccess().getTypeNamedElementQualifiedNameParserRuleCall_1_0_1()); |
28995 | before(grammarAccess.getExactScopeDefinitionAccess().getTypeNamedElementQualifiedNameParserRuleCall_1_0_1()); | ||
28996 | } | ||
28997 | pushFollow(FOLLOW_2); | 26485 | pushFollow(FOLLOW_2); |
28998 | ruleQualifiedName(); | 26486 | ruleQualifiedName(); |
28999 | 26487 | ||
29000 | state._fsp--; | 26488 | state._fsp--; |
29001 | if (state.failed) return ; | ||
29002 | if ( state.backtracking==0 ) { | ||
29003 | after(grammarAccess.getExactScopeDefinitionAccess().getTypeNamedElementQualifiedNameParserRuleCall_1_0_1()); | ||
29004 | } | ||
29005 | 26489 | ||
29006 | } | 26490 | after(grammarAccess.getExactScopeDefinitionAccess().getTypeNamedElementQualifiedNameParserRuleCall_1_0_1()); |
29007 | 26491 | ||
29008 | if ( state.backtracking==0 ) { | ||
29009 | after(grammarAccess.getExactScopeDefinitionAccess().getTypeNamedElementCrossReference_1_0()); | ||
29010 | } | 26492 | } |
29011 | 26493 | ||
26494 | after(grammarAccess.getExactScopeDefinitionAccess().getTypeNamedElementCrossReference_1_0()); | ||
26495 | |||
29012 | } | 26496 | } |
29013 | 26497 | ||
29014 | 26498 | ||
@@ -29030,25 +26514,21 @@ public class InternalSolverLanguageParser extends AbstractInternalContentAssistP | |||
29030 | 26514 | ||
29031 | 26515 | ||
29032 | // $ANTLR start "rule__ExactScopeDefinition__ExactScopeAssignment_3" | 26516 | // $ANTLR start "rule__ExactScopeDefinition__ExactScopeAssignment_3" |
29033 | // InternalSolverLanguage.g:8907:1: rule__ExactScopeDefinition__ExactScopeAssignment_3 : ( RULE_INT ) ; | 26517 | // InternalSolverLanguageParser.g:8782:1: rule__ExactScopeDefinition__ExactScopeAssignment_3 : ( RULE_INT ) ; |
29034 | public final void rule__ExactScopeDefinition__ExactScopeAssignment_3() throws RecognitionException { | 26518 | public final void rule__ExactScopeDefinition__ExactScopeAssignment_3() throws RecognitionException { |
29035 | 26519 | ||
29036 | int stackSize = keepStackSize(); | 26520 | int stackSize = keepStackSize(); |
29037 | 26521 | ||
29038 | try { | 26522 | try { |
29039 | // InternalSolverLanguage.g:8911:1: ( ( RULE_INT ) ) | 26523 | // InternalSolverLanguageParser.g:8786:1: ( ( RULE_INT ) ) |
29040 | // InternalSolverLanguage.g:8912:2: ( RULE_INT ) | 26524 | // InternalSolverLanguageParser.g:8787:2: ( RULE_INT ) |
29041 | { | 26525 | { |
29042 | // InternalSolverLanguage.g:8912:2: ( RULE_INT ) | 26526 | // InternalSolverLanguageParser.g:8787:2: ( RULE_INT ) |
29043 | // InternalSolverLanguage.g:8913:3: RULE_INT | 26527 | // InternalSolverLanguageParser.g:8788:3: RULE_INT |
29044 | { | 26528 | { |
29045 | if ( state.backtracking==0 ) { | 26529 | before(grammarAccess.getExactScopeDefinitionAccess().getExactScopeINTTerminalRuleCall_3_0()); |
29046 | before(grammarAccess.getExactScopeDefinitionAccess().getExactScopeINTTerminalRuleCall_3_0()); | 26530 | match(input,RULE_INT,FOLLOW_2); |
29047 | } | 26531 | after(grammarAccess.getExactScopeDefinitionAccess().getExactScopeINTTerminalRuleCall_3_0()); |
29048 | match(input,RULE_INT,FOLLOW_2); if (state.failed) return ; | ||
29049 | if ( state.backtracking==0 ) { | ||
29050 | after(grammarAccess.getExactScopeDefinitionAccess().getExactScopeINTTerminalRuleCall_3_0()); | ||
29051 | } | ||
29052 | 26532 | ||
29053 | } | 26533 | } |
29054 | 26534 | ||
@@ -29071,25 +26551,21 @@ public class InternalSolverLanguageParser extends AbstractInternalContentAssistP | |||
29071 | 26551 | ||
29072 | 26552 | ||
29073 | // $ANTLR start "rule__BoundedScopeDefinition__LowerBoundAssignment_1_0_0_0" | 26553 | // $ANTLR start "rule__BoundedScopeDefinition__LowerBoundAssignment_1_0_0_0" |
29074 | // InternalSolverLanguage.g:8922:1: rule__BoundedScopeDefinition__LowerBoundAssignment_1_0_0_0 : ( RULE_INT ) ; | 26554 | // InternalSolverLanguageParser.g:8797:1: rule__BoundedScopeDefinition__LowerBoundAssignment_1_0_0_0 : ( RULE_INT ) ; |
29075 | public final void rule__BoundedScopeDefinition__LowerBoundAssignment_1_0_0_0() throws RecognitionException { | 26555 | public final void rule__BoundedScopeDefinition__LowerBoundAssignment_1_0_0_0() throws RecognitionException { |
29076 | 26556 | ||
29077 | int stackSize = keepStackSize(); | 26557 | int stackSize = keepStackSize(); |
29078 | 26558 | ||
29079 | try { | 26559 | try { |
29080 | // InternalSolverLanguage.g:8926:1: ( ( RULE_INT ) ) | 26560 | // InternalSolverLanguageParser.g:8801:1: ( ( RULE_INT ) ) |
29081 | // InternalSolverLanguage.g:8927:2: ( RULE_INT ) | 26561 | // InternalSolverLanguageParser.g:8802:2: ( RULE_INT ) |
29082 | { | 26562 | { |
29083 | // InternalSolverLanguage.g:8927:2: ( RULE_INT ) | 26563 | // InternalSolverLanguageParser.g:8802:2: ( RULE_INT ) |
29084 | // InternalSolverLanguage.g:8928:3: RULE_INT | 26564 | // InternalSolverLanguageParser.g:8803:3: RULE_INT |
29085 | { | 26565 | { |
29086 | if ( state.backtracking==0 ) { | 26566 | before(grammarAccess.getBoundedScopeDefinitionAccess().getLowerBoundINTTerminalRuleCall_1_0_0_0_0()); |
29087 | before(grammarAccess.getBoundedScopeDefinitionAccess().getLowerBoundINTTerminalRuleCall_1_0_0_0_0()); | 26567 | match(input,RULE_INT,FOLLOW_2); |
29088 | } | 26568 | after(grammarAccess.getBoundedScopeDefinitionAccess().getLowerBoundINTTerminalRuleCall_1_0_0_0_0()); |
29089 | match(input,RULE_INT,FOLLOW_2); if (state.failed) return ; | ||
29090 | if ( state.backtracking==0 ) { | ||
29091 | after(grammarAccess.getBoundedScopeDefinitionAccess().getLowerBoundINTTerminalRuleCall_1_0_0_0_0()); | ||
29092 | } | ||
29093 | 26569 | ||
29094 | } | 26570 | } |
29095 | 26571 | ||
@@ -29112,42 +26588,34 @@ public class InternalSolverLanguageParser extends AbstractInternalContentAssistP | |||
29112 | 26588 | ||
29113 | 26589 | ||
29114 | // $ANTLR start "rule__BoundedScopeDefinition__TypeAssignment_1_0_1" | 26590 | // $ANTLR start "rule__BoundedScopeDefinition__TypeAssignment_1_0_1" |
29115 | // InternalSolverLanguage.g:8937:1: rule__BoundedScopeDefinition__TypeAssignment_1_0_1 : ( ( ruleQualifiedName ) ) ; | 26591 | // InternalSolverLanguageParser.g:8812:1: rule__BoundedScopeDefinition__TypeAssignment_1_0_1 : ( ( ruleQualifiedName ) ) ; |
29116 | public final void rule__BoundedScopeDefinition__TypeAssignment_1_0_1() throws RecognitionException { | 26592 | public final void rule__BoundedScopeDefinition__TypeAssignment_1_0_1() throws RecognitionException { |
29117 | 26593 | ||
29118 | int stackSize = keepStackSize(); | 26594 | int stackSize = keepStackSize(); |
29119 | 26595 | ||
29120 | try { | 26596 | try { |
29121 | // InternalSolverLanguage.g:8941:1: ( ( ( ruleQualifiedName ) ) ) | 26597 | // InternalSolverLanguageParser.g:8816:1: ( ( ( ruleQualifiedName ) ) ) |
29122 | // InternalSolverLanguage.g:8942:2: ( ( ruleQualifiedName ) ) | 26598 | // InternalSolverLanguageParser.g:8817:2: ( ( ruleQualifiedName ) ) |
29123 | { | 26599 | { |
29124 | // InternalSolverLanguage.g:8942:2: ( ( ruleQualifiedName ) ) | 26600 | // InternalSolverLanguageParser.g:8817:2: ( ( ruleQualifiedName ) ) |
29125 | // InternalSolverLanguage.g:8943:3: ( ruleQualifiedName ) | 26601 | // InternalSolverLanguageParser.g:8818:3: ( ruleQualifiedName ) |
29126 | { | 26602 | { |
29127 | if ( state.backtracking==0 ) { | 26603 | before(grammarAccess.getBoundedScopeDefinitionAccess().getTypeNamedElementCrossReference_1_0_1_0()); |
29128 | before(grammarAccess.getBoundedScopeDefinitionAccess().getTypeNamedElementCrossReference_1_0_1_0()); | 26604 | // InternalSolverLanguageParser.g:8819:3: ( ruleQualifiedName ) |
29129 | } | 26605 | // InternalSolverLanguageParser.g:8820:4: ruleQualifiedName |
29130 | // InternalSolverLanguage.g:8944:3: ( ruleQualifiedName ) | ||
29131 | // InternalSolverLanguage.g:8945:4: ruleQualifiedName | ||
29132 | { | 26606 | { |
29133 | if ( state.backtracking==0 ) { | 26607 | before(grammarAccess.getBoundedScopeDefinitionAccess().getTypeNamedElementQualifiedNameParserRuleCall_1_0_1_0_1()); |
29134 | before(grammarAccess.getBoundedScopeDefinitionAccess().getTypeNamedElementQualifiedNameParserRuleCall_1_0_1_0_1()); | ||
29135 | } | ||
29136 | pushFollow(FOLLOW_2); | 26608 | pushFollow(FOLLOW_2); |
29137 | ruleQualifiedName(); | 26609 | ruleQualifiedName(); |
29138 | 26610 | ||
29139 | state._fsp--; | 26611 | state._fsp--; |
29140 | if (state.failed) return ; | ||
29141 | if ( state.backtracking==0 ) { | ||
29142 | after(grammarAccess.getBoundedScopeDefinitionAccess().getTypeNamedElementQualifiedNameParserRuleCall_1_0_1_0_1()); | ||
29143 | } | ||
29144 | 26612 | ||
29145 | } | 26613 | after(grammarAccess.getBoundedScopeDefinitionAccess().getTypeNamedElementQualifiedNameParserRuleCall_1_0_1_0_1()); |
29146 | 26614 | ||
29147 | if ( state.backtracking==0 ) { | ||
29148 | after(grammarAccess.getBoundedScopeDefinitionAccess().getTypeNamedElementCrossReference_1_0_1_0()); | ||
29149 | } | 26615 | } |
29150 | 26616 | ||
26617 | after(grammarAccess.getBoundedScopeDefinitionAccess().getTypeNamedElementCrossReference_1_0_1_0()); | ||
26618 | |||
29151 | } | 26619 | } |
29152 | 26620 | ||
29153 | 26621 | ||
@@ -29169,25 +26637,21 @@ public class InternalSolverLanguageParser extends AbstractInternalContentAssistP | |||
29169 | 26637 | ||
29170 | 26638 | ||
29171 | // $ANTLR start "rule__BoundedScopeDefinition__UpperBoundAssignment_1_0_3" | 26639 | // $ANTLR start "rule__BoundedScopeDefinition__UpperBoundAssignment_1_0_3" |
29172 | // InternalSolverLanguage.g:8956:1: rule__BoundedScopeDefinition__UpperBoundAssignment_1_0_3 : ( RULE_INT ) ; | 26640 | // InternalSolverLanguageParser.g:8831:1: rule__BoundedScopeDefinition__UpperBoundAssignment_1_0_3 : ( RULE_INT ) ; |
29173 | public final void rule__BoundedScopeDefinition__UpperBoundAssignment_1_0_3() throws RecognitionException { | 26641 | public final void rule__BoundedScopeDefinition__UpperBoundAssignment_1_0_3() throws RecognitionException { |
29174 | 26642 | ||
29175 | int stackSize = keepStackSize(); | 26643 | int stackSize = keepStackSize(); |
29176 | 26644 | ||
29177 | try { | 26645 | try { |
29178 | // InternalSolverLanguage.g:8960:1: ( ( RULE_INT ) ) | 26646 | // InternalSolverLanguageParser.g:8835:1: ( ( RULE_INT ) ) |
29179 | // InternalSolverLanguage.g:8961:2: ( RULE_INT ) | 26647 | // InternalSolverLanguageParser.g:8836:2: ( RULE_INT ) |
29180 | { | 26648 | { |
29181 | // InternalSolverLanguage.g:8961:2: ( RULE_INT ) | 26649 | // InternalSolverLanguageParser.g:8836:2: ( RULE_INT ) |
29182 | // InternalSolverLanguage.g:8962:3: RULE_INT | 26650 | // InternalSolverLanguageParser.g:8837:3: RULE_INT |
29183 | { | 26651 | { |
29184 | if ( state.backtracking==0 ) { | 26652 | before(grammarAccess.getBoundedScopeDefinitionAccess().getUpperBoundINTTerminalRuleCall_1_0_3_0()); |
29185 | before(grammarAccess.getBoundedScopeDefinitionAccess().getUpperBoundINTTerminalRuleCall_1_0_3_0()); | 26653 | match(input,RULE_INT,FOLLOW_2); |
29186 | } | 26654 | after(grammarAccess.getBoundedScopeDefinitionAccess().getUpperBoundINTTerminalRuleCall_1_0_3_0()); |
29187 | match(input,RULE_INT,FOLLOW_2); if (state.failed) return ; | ||
29188 | if ( state.backtracking==0 ) { | ||
29189 | after(grammarAccess.getBoundedScopeDefinitionAccess().getUpperBoundINTTerminalRuleCall_1_0_3_0()); | ||
29190 | } | ||
29191 | 26655 | ||
29192 | } | 26656 | } |
29193 | 26657 | ||
@@ -29210,25 +26674,21 @@ public class InternalSolverLanguageParser extends AbstractInternalContentAssistP | |||
29210 | 26674 | ||
29211 | 26675 | ||
29212 | // $ANTLR start "rule__BoundedScopeDefinition__UpperBoundAssignment_1_1_0" | 26676 | // $ANTLR start "rule__BoundedScopeDefinition__UpperBoundAssignment_1_1_0" |
29213 | // InternalSolverLanguage.g:8971:1: rule__BoundedScopeDefinition__UpperBoundAssignment_1_1_0 : ( RULE_INT ) ; | 26677 | // InternalSolverLanguageParser.g:8846:1: rule__BoundedScopeDefinition__UpperBoundAssignment_1_1_0 : ( RULE_INT ) ; |
29214 | public final void rule__BoundedScopeDefinition__UpperBoundAssignment_1_1_0() throws RecognitionException { | 26678 | public final void rule__BoundedScopeDefinition__UpperBoundAssignment_1_1_0() throws RecognitionException { |
29215 | 26679 | ||
29216 | int stackSize = keepStackSize(); | 26680 | int stackSize = keepStackSize(); |
29217 | 26681 | ||
29218 | try { | 26682 | try { |
29219 | // InternalSolverLanguage.g:8975:1: ( ( RULE_INT ) ) | 26683 | // InternalSolverLanguageParser.g:8850:1: ( ( RULE_INT ) ) |
29220 | // InternalSolverLanguage.g:8976:2: ( RULE_INT ) | 26684 | // InternalSolverLanguageParser.g:8851:2: ( RULE_INT ) |
29221 | { | 26685 | { |
29222 | // InternalSolverLanguage.g:8976:2: ( RULE_INT ) | 26686 | // InternalSolverLanguageParser.g:8851:2: ( RULE_INT ) |
29223 | // InternalSolverLanguage.g:8977:3: RULE_INT | 26687 | // InternalSolverLanguageParser.g:8852:3: RULE_INT |
29224 | { | 26688 | { |
29225 | if ( state.backtracking==0 ) { | 26689 | before(grammarAccess.getBoundedScopeDefinitionAccess().getUpperBoundINTTerminalRuleCall_1_1_0_0()); |
29226 | before(grammarAccess.getBoundedScopeDefinitionAccess().getUpperBoundINTTerminalRuleCall_1_1_0_0()); | 26690 | match(input,RULE_INT,FOLLOW_2); |
29227 | } | 26691 | after(grammarAccess.getBoundedScopeDefinitionAccess().getUpperBoundINTTerminalRuleCall_1_1_0_0()); |
29228 | match(input,RULE_INT,FOLLOW_2); if (state.failed) return ; | ||
29229 | if ( state.backtracking==0 ) { | ||
29230 | after(grammarAccess.getBoundedScopeDefinitionAccess().getUpperBoundINTTerminalRuleCall_1_1_0_0()); | ||
29231 | } | ||
29232 | 26692 | ||
29233 | } | 26693 | } |
29234 | 26694 | ||
@@ -29251,42 +26711,34 @@ public class InternalSolverLanguageParser extends AbstractInternalContentAssistP | |||
29251 | 26711 | ||
29252 | 26712 | ||
29253 | // $ANTLR start "rule__BoundedScopeDefinition__TypeAssignment_1_1_2" | 26713 | // $ANTLR start "rule__BoundedScopeDefinition__TypeAssignment_1_1_2" |
29254 | // InternalSolverLanguage.g:8986:1: rule__BoundedScopeDefinition__TypeAssignment_1_1_2 : ( ( ruleQualifiedName ) ) ; | 26714 | // InternalSolverLanguageParser.g:8861:1: rule__BoundedScopeDefinition__TypeAssignment_1_1_2 : ( ( ruleQualifiedName ) ) ; |
29255 | public final void rule__BoundedScopeDefinition__TypeAssignment_1_1_2() throws RecognitionException { | 26715 | public final void rule__BoundedScopeDefinition__TypeAssignment_1_1_2() throws RecognitionException { |
29256 | 26716 | ||
29257 | int stackSize = keepStackSize(); | 26717 | int stackSize = keepStackSize(); |
29258 | 26718 | ||
29259 | try { | 26719 | try { |
29260 | // InternalSolverLanguage.g:8990:1: ( ( ( ruleQualifiedName ) ) ) | 26720 | // InternalSolverLanguageParser.g:8865:1: ( ( ( ruleQualifiedName ) ) ) |
29261 | // InternalSolverLanguage.g:8991:2: ( ( ruleQualifiedName ) ) | 26721 | // InternalSolverLanguageParser.g:8866:2: ( ( ruleQualifiedName ) ) |
29262 | { | 26722 | { |
29263 | // InternalSolverLanguage.g:8991:2: ( ( ruleQualifiedName ) ) | 26723 | // InternalSolverLanguageParser.g:8866:2: ( ( ruleQualifiedName ) ) |
29264 | // InternalSolverLanguage.g:8992:3: ( ruleQualifiedName ) | 26724 | // InternalSolverLanguageParser.g:8867:3: ( ruleQualifiedName ) |
29265 | { | 26725 | { |
29266 | if ( state.backtracking==0 ) { | 26726 | before(grammarAccess.getBoundedScopeDefinitionAccess().getTypeNamedElementCrossReference_1_1_2_0()); |
29267 | before(grammarAccess.getBoundedScopeDefinitionAccess().getTypeNamedElementCrossReference_1_1_2_0()); | 26727 | // InternalSolverLanguageParser.g:8868:3: ( ruleQualifiedName ) |
29268 | } | 26728 | // InternalSolverLanguageParser.g:8869:4: ruleQualifiedName |
29269 | // InternalSolverLanguage.g:8993:3: ( ruleQualifiedName ) | ||
29270 | // InternalSolverLanguage.g:8994:4: ruleQualifiedName | ||
29271 | { | 26729 | { |
29272 | if ( state.backtracking==0 ) { | 26730 | before(grammarAccess.getBoundedScopeDefinitionAccess().getTypeNamedElementQualifiedNameParserRuleCall_1_1_2_0_1()); |
29273 | before(grammarAccess.getBoundedScopeDefinitionAccess().getTypeNamedElementQualifiedNameParserRuleCall_1_1_2_0_1()); | ||
29274 | } | ||
29275 | pushFollow(FOLLOW_2); | 26731 | pushFollow(FOLLOW_2); |
29276 | ruleQualifiedName(); | 26732 | ruleQualifiedName(); |
29277 | 26733 | ||
29278 | state._fsp--; | 26734 | state._fsp--; |
29279 | if (state.failed) return ; | ||
29280 | if ( state.backtracking==0 ) { | ||
29281 | after(grammarAccess.getBoundedScopeDefinitionAccess().getTypeNamedElementQualifiedNameParserRuleCall_1_1_2_0_1()); | ||
29282 | } | ||
29283 | 26735 | ||
29284 | } | 26736 | after(grammarAccess.getBoundedScopeDefinitionAccess().getTypeNamedElementQualifiedNameParserRuleCall_1_1_2_0_1()); |
29285 | 26737 | ||
29286 | if ( state.backtracking==0 ) { | ||
29287 | after(grammarAccess.getBoundedScopeDefinitionAccess().getTypeNamedElementCrossReference_1_1_2_0()); | ||
29288 | } | 26738 | } |
29289 | 26739 | ||
26740 | after(grammarAccess.getBoundedScopeDefinitionAccess().getTypeNamedElementCrossReference_1_1_2_0()); | ||
26741 | |||
29290 | } | 26742 | } |
29291 | 26743 | ||
29292 | 26744 | ||
@@ -29308,25 +26760,21 @@ public class InternalSolverLanguageParser extends AbstractInternalContentAssistP | |||
29308 | 26760 | ||
29309 | 26761 | ||
29310 | // $ANTLR start "rule__BoundedScopeDefinition__LowerBoundAssignment_1_1_3_1" | 26762 | // $ANTLR start "rule__BoundedScopeDefinition__LowerBoundAssignment_1_1_3_1" |
29311 | // InternalSolverLanguage.g:9005:1: rule__BoundedScopeDefinition__LowerBoundAssignment_1_1_3_1 : ( RULE_INT ) ; | 26763 | // InternalSolverLanguageParser.g:8880:1: rule__BoundedScopeDefinition__LowerBoundAssignment_1_1_3_1 : ( RULE_INT ) ; |
29312 | public final void rule__BoundedScopeDefinition__LowerBoundAssignment_1_1_3_1() throws RecognitionException { | 26764 | public final void rule__BoundedScopeDefinition__LowerBoundAssignment_1_1_3_1() throws RecognitionException { |
29313 | 26765 | ||
29314 | int stackSize = keepStackSize(); | 26766 | int stackSize = keepStackSize(); |
29315 | 26767 | ||
29316 | try { | 26768 | try { |
29317 | // InternalSolverLanguage.g:9009:1: ( ( RULE_INT ) ) | 26769 | // InternalSolverLanguageParser.g:8884:1: ( ( RULE_INT ) ) |
29318 | // InternalSolverLanguage.g:9010:2: ( RULE_INT ) | 26770 | // InternalSolverLanguageParser.g:8885:2: ( RULE_INT ) |
29319 | { | 26771 | { |
29320 | // InternalSolverLanguage.g:9010:2: ( RULE_INT ) | 26772 | // InternalSolverLanguageParser.g:8885:2: ( RULE_INT ) |
29321 | // InternalSolverLanguage.g:9011:3: RULE_INT | 26773 | // InternalSolverLanguageParser.g:8886:3: RULE_INT |
29322 | { | 26774 | { |
29323 | if ( state.backtracking==0 ) { | 26775 | before(grammarAccess.getBoundedScopeDefinitionAccess().getLowerBoundINTTerminalRuleCall_1_1_3_1_0()); |
29324 | before(grammarAccess.getBoundedScopeDefinitionAccess().getLowerBoundINTTerminalRuleCall_1_1_3_1_0()); | 26776 | match(input,RULE_INT,FOLLOW_2); |
29325 | } | 26777 | after(grammarAccess.getBoundedScopeDefinitionAccess().getLowerBoundINTTerminalRuleCall_1_1_3_1_0()); |
29326 | match(input,RULE_INT,FOLLOW_2); if (state.failed) return ; | ||
29327 | if ( state.backtracking==0 ) { | ||
29328 | after(grammarAccess.getBoundedScopeDefinitionAccess().getLowerBoundINTTerminalRuleCall_1_1_3_1_0()); | ||
29329 | } | ||
29330 | 26778 | ||
29331 | } | 26779 | } |
29332 | 26780 | ||
@@ -29349,25 +26797,21 @@ public class InternalSolverLanguageParser extends AbstractInternalContentAssistP | |||
29349 | 26797 | ||
29350 | 26798 | ||
29351 | // $ANTLR start "rule__LowerBoundedScopeDefinition__LowerBoundAssignment_1_0_0" | 26799 | // $ANTLR start "rule__LowerBoundedScopeDefinition__LowerBoundAssignment_1_0_0" |
29352 | // InternalSolverLanguage.g:9020:1: rule__LowerBoundedScopeDefinition__LowerBoundAssignment_1_0_0 : ( RULE_INT ) ; | 26800 | // InternalSolverLanguageParser.g:8895:1: rule__LowerBoundedScopeDefinition__LowerBoundAssignment_1_0_0 : ( RULE_INT ) ; |
29353 | public final void rule__LowerBoundedScopeDefinition__LowerBoundAssignment_1_0_0() throws RecognitionException { | 26801 | public final void rule__LowerBoundedScopeDefinition__LowerBoundAssignment_1_0_0() throws RecognitionException { |
29354 | 26802 | ||
29355 | int stackSize = keepStackSize(); | 26803 | int stackSize = keepStackSize(); |
29356 | 26804 | ||
29357 | try { | 26805 | try { |
29358 | // InternalSolverLanguage.g:9024:1: ( ( RULE_INT ) ) | 26806 | // InternalSolverLanguageParser.g:8899:1: ( ( RULE_INT ) ) |
29359 | // InternalSolverLanguage.g:9025:2: ( RULE_INT ) | 26807 | // InternalSolverLanguageParser.g:8900:2: ( RULE_INT ) |
29360 | { | 26808 | { |
29361 | // InternalSolverLanguage.g:9025:2: ( RULE_INT ) | 26809 | // InternalSolverLanguageParser.g:8900:2: ( RULE_INT ) |
29362 | // InternalSolverLanguage.g:9026:3: RULE_INT | 26810 | // InternalSolverLanguageParser.g:8901:3: RULE_INT |
29363 | { | 26811 | { |
29364 | if ( state.backtracking==0 ) { | 26812 | before(grammarAccess.getLowerBoundedScopeDefinitionAccess().getLowerBoundINTTerminalRuleCall_1_0_0_0()); |
29365 | before(grammarAccess.getLowerBoundedScopeDefinitionAccess().getLowerBoundINTTerminalRuleCall_1_0_0_0()); | 26813 | match(input,RULE_INT,FOLLOW_2); |
29366 | } | 26814 | after(grammarAccess.getLowerBoundedScopeDefinitionAccess().getLowerBoundINTTerminalRuleCall_1_0_0_0()); |
29367 | match(input,RULE_INT,FOLLOW_2); if (state.failed) return ; | ||
29368 | if ( state.backtracking==0 ) { | ||
29369 | after(grammarAccess.getLowerBoundedScopeDefinitionAccess().getLowerBoundINTTerminalRuleCall_1_0_0_0()); | ||
29370 | } | ||
29371 | 26815 | ||
29372 | } | 26816 | } |
29373 | 26817 | ||
@@ -29390,42 +26834,34 @@ public class InternalSolverLanguageParser extends AbstractInternalContentAssistP | |||
29390 | 26834 | ||
29391 | 26835 | ||
29392 | // $ANTLR start "rule__LowerBoundedScopeDefinition__TypeAssignment_1_0_2" | 26836 | // $ANTLR start "rule__LowerBoundedScopeDefinition__TypeAssignment_1_0_2" |
29393 | // InternalSolverLanguage.g:9035:1: rule__LowerBoundedScopeDefinition__TypeAssignment_1_0_2 : ( ( ruleQualifiedName ) ) ; | 26837 | // InternalSolverLanguageParser.g:8910:1: rule__LowerBoundedScopeDefinition__TypeAssignment_1_0_2 : ( ( ruleQualifiedName ) ) ; |
29394 | public final void rule__LowerBoundedScopeDefinition__TypeAssignment_1_0_2() throws RecognitionException { | 26838 | public final void rule__LowerBoundedScopeDefinition__TypeAssignment_1_0_2() throws RecognitionException { |
29395 | 26839 | ||
29396 | int stackSize = keepStackSize(); | 26840 | int stackSize = keepStackSize(); |
29397 | 26841 | ||
29398 | try { | 26842 | try { |
29399 | // InternalSolverLanguage.g:9039:1: ( ( ( ruleQualifiedName ) ) ) | 26843 | // InternalSolverLanguageParser.g:8914:1: ( ( ( ruleQualifiedName ) ) ) |
29400 | // InternalSolverLanguage.g:9040:2: ( ( ruleQualifiedName ) ) | 26844 | // InternalSolverLanguageParser.g:8915:2: ( ( ruleQualifiedName ) ) |
29401 | { | 26845 | { |
29402 | // InternalSolverLanguage.g:9040:2: ( ( ruleQualifiedName ) ) | 26846 | // InternalSolverLanguageParser.g:8915:2: ( ( ruleQualifiedName ) ) |
29403 | // InternalSolverLanguage.g:9041:3: ( ruleQualifiedName ) | 26847 | // InternalSolverLanguageParser.g:8916:3: ( ruleQualifiedName ) |
29404 | { | 26848 | { |
29405 | if ( state.backtracking==0 ) { | 26849 | before(grammarAccess.getLowerBoundedScopeDefinitionAccess().getTypeNamedElementCrossReference_1_0_2_0()); |
29406 | before(grammarAccess.getLowerBoundedScopeDefinitionAccess().getTypeNamedElementCrossReference_1_0_2_0()); | 26850 | // InternalSolverLanguageParser.g:8917:3: ( ruleQualifiedName ) |
29407 | } | 26851 | // InternalSolverLanguageParser.g:8918:4: ruleQualifiedName |
29408 | // InternalSolverLanguage.g:9042:3: ( ruleQualifiedName ) | ||
29409 | // InternalSolverLanguage.g:9043:4: ruleQualifiedName | ||
29410 | { | 26852 | { |
29411 | if ( state.backtracking==0 ) { | 26853 | before(grammarAccess.getLowerBoundedScopeDefinitionAccess().getTypeNamedElementQualifiedNameParserRuleCall_1_0_2_0_1()); |
29412 | before(grammarAccess.getLowerBoundedScopeDefinitionAccess().getTypeNamedElementQualifiedNameParserRuleCall_1_0_2_0_1()); | ||
29413 | } | ||
29414 | pushFollow(FOLLOW_2); | 26854 | pushFollow(FOLLOW_2); |
29415 | ruleQualifiedName(); | 26855 | ruleQualifiedName(); |
29416 | 26856 | ||
29417 | state._fsp--; | 26857 | state._fsp--; |
29418 | if (state.failed) return ; | ||
29419 | if ( state.backtracking==0 ) { | ||
29420 | after(grammarAccess.getLowerBoundedScopeDefinitionAccess().getTypeNamedElementQualifiedNameParserRuleCall_1_0_2_0_1()); | ||
29421 | } | ||
29422 | 26858 | ||
29423 | } | 26859 | after(grammarAccess.getLowerBoundedScopeDefinitionAccess().getTypeNamedElementQualifiedNameParserRuleCall_1_0_2_0_1()); |
29424 | 26860 | ||
29425 | if ( state.backtracking==0 ) { | ||
29426 | after(grammarAccess.getLowerBoundedScopeDefinitionAccess().getTypeNamedElementCrossReference_1_0_2_0()); | ||
29427 | } | 26861 | } |
29428 | 26862 | ||
26863 | after(grammarAccess.getLowerBoundedScopeDefinitionAccess().getTypeNamedElementCrossReference_1_0_2_0()); | ||
26864 | |||
29429 | } | 26865 | } |
29430 | 26866 | ||
29431 | 26867 | ||
@@ -29447,42 +26883,34 @@ public class InternalSolverLanguageParser extends AbstractInternalContentAssistP | |||
29447 | 26883 | ||
29448 | 26884 | ||
29449 | // $ANTLR start "rule__LowerBoundedScopeDefinition__TypeAssignment_1_1_0" | 26885 | // $ANTLR start "rule__LowerBoundedScopeDefinition__TypeAssignment_1_1_0" |
29450 | // InternalSolverLanguage.g:9054:1: rule__LowerBoundedScopeDefinition__TypeAssignment_1_1_0 : ( ( ruleQualifiedName ) ) ; | 26886 | // InternalSolverLanguageParser.g:8929:1: rule__LowerBoundedScopeDefinition__TypeAssignment_1_1_0 : ( ( ruleQualifiedName ) ) ; |
29451 | public final void rule__LowerBoundedScopeDefinition__TypeAssignment_1_1_0() throws RecognitionException { | 26887 | public final void rule__LowerBoundedScopeDefinition__TypeAssignment_1_1_0() throws RecognitionException { |
29452 | 26888 | ||
29453 | int stackSize = keepStackSize(); | 26889 | int stackSize = keepStackSize(); |
29454 | 26890 | ||
29455 | try { | 26891 | try { |
29456 | // InternalSolverLanguage.g:9058:1: ( ( ( ruleQualifiedName ) ) ) | 26892 | // InternalSolverLanguageParser.g:8933:1: ( ( ( ruleQualifiedName ) ) ) |
29457 | // InternalSolverLanguage.g:9059:2: ( ( ruleQualifiedName ) ) | 26893 | // InternalSolverLanguageParser.g:8934:2: ( ( ruleQualifiedName ) ) |
29458 | { | 26894 | { |
29459 | // InternalSolverLanguage.g:9059:2: ( ( ruleQualifiedName ) ) | 26895 | // InternalSolverLanguageParser.g:8934:2: ( ( ruleQualifiedName ) ) |
29460 | // InternalSolverLanguage.g:9060:3: ( ruleQualifiedName ) | 26896 | // InternalSolverLanguageParser.g:8935:3: ( ruleQualifiedName ) |
29461 | { | 26897 | { |
29462 | if ( state.backtracking==0 ) { | 26898 | before(grammarAccess.getLowerBoundedScopeDefinitionAccess().getTypeNamedElementCrossReference_1_1_0_0()); |
29463 | before(grammarAccess.getLowerBoundedScopeDefinitionAccess().getTypeNamedElementCrossReference_1_1_0_0()); | 26899 | // InternalSolverLanguageParser.g:8936:3: ( ruleQualifiedName ) |
29464 | } | 26900 | // InternalSolverLanguageParser.g:8937:4: ruleQualifiedName |
29465 | // InternalSolverLanguage.g:9061:3: ( ruleQualifiedName ) | ||
29466 | // InternalSolverLanguage.g:9062:4: ruleQualifiedName | ||
29467 | { | 26901 | { |
29468 | if ( state.backtracking==0 ) { | 26902 | before(grammarAccess.getLowerBoundedScopeDefinitionAccess().getTypeNamedElementQualifiedNameParserRuleCall_1_1_0_0_1()); |
29469 | before(grammarAccess.getLowerBoundedScopeDefinitionAccess().getTypeNamedElementQualifiedNameParserRuleCall_1_1_0_0_1()); | ||
29470 | } | ||
29471 | pushFollow(FOLLOW_2); | 26903 | pushFollow(FOLLOW_2); |
29472 | ruleQualifiedName(); | 26904 | ruleQualifiedName(); |
29473 | 26905 | ||
29474 | state._fsp--; | 26906 | state._fsp--; |
29475 | if (state.failed) return ; | ||
29476 | if ( state.backtracking==0 ) { | ||
29477 | after(grammarAccess.getLowerBoundedScopeDefinitionAccess().getTypeNamedElementQualifiedNameParserRuleCall_1_1_0_0_1()); | ||
29478 | } | ||
29479 | 26907 | ||
29480 | } | 26908 | after(grammarAccess.getLowerBoundedScopeDefinitionAccess().getTypeNamedElementQualifiedNameParserRuleCall_1_1_0_0_1()); |
29481 | 26909 | ||
29482 | if ( state.backtracking==0 ) { | ||
29483 | after(grammarAccess.getLowerBoundedScopeDefinitionAccess().getTypeNamedElementCrossReference_1_1_0_0()); | ||
29484 | } | 26910 | } |
29485 | 26911 | ||
26912 | after(grammarAccess.getLowerBoundedScopeDefinitionAccess().getTypeNamedElementCrossReference_1_1_0_0()); | ||
26913 | |||
29486 | } | 26914 | } |
29487 | 26915 | ||
29488 | 26916 | ||
@@ -29504,25 +26932,21 @@ public class InternalSolverLanguageParser extends AbstractInternalContentAssistP | |||
29504 | 26932 | ||
29505 | 26933 | ||
29506 | // $ANTLR start "rule__LowerBoundedScopeDefinition__LowerBoundAssignment_1_1_2" | 26934 | // $ANTLR start "rule__LowerBoundedScopeDefinition__LowerBoundAssignment_1_1_2" |
29507 | // InternalSolverLanguage.g:9073:1: rule__LowerBoundedScopeDefinition__LowerBoundAssignment_1_1_2 : ( RULE_INT ) ; | 26935 | // InternalSolverLanguageParser.g:8948:1: rule__LowerBoundedScopeDefinition__LowerBoundAssignment_1_1_2 : ( RULE_INT ) ; |
29508 | public final void rule__LowerBoundedScopeDefinition__LowerBoundAssignment_1_1_2() throws RecognitionException { | 26936 | public final void rule__LowerBoundedScopeDefinition__LowerBoundAssignment_1_1_2() throws RecognitionException { |
29509 | 26937 | ||
29510 | int stackSize = keepStackSize(); | 26938 | int stackSize = keepStackSize(); |
29511 | 26939 | ||
29512 | try { | 26940 | try { |
29513 | // InternalSolverLanguage.g:9077:1: ( ( RULE_INT ) ) | 26941 | // InternalSolverLanguageParser.g:8952:1: ( ( RULE_INT ) ) |
29514 | // InternalSolverLanguage.g:9078:2: ( RULE_INT ) | 26942 | // InternalSolverLanguageParser.g:8953:2: ( RULE_INT ) |
29515 | { | 26943 | { |
29516 | // InternalSolverLanguage.g:9078:2: ( RULE_INT ) | 26944 | // InternalSolverLanguageParser.g:8953:2: ( RULE_INT ) |
29517 | // InternalSolverLanguage.g:9079:3: RULE_INT | 26945 | // InternalSolverLanguageParser.g:8954:3: RULE_INT |
29518 | { | 26946 | { |
29519 | if ( state.backtracking==0 ) { | 26947 | before(grammarAccess.getLowerBoundedScopeDefinitionAccess().getLowerBoundINTTerminalRuleCall_1_1_2_0()); |
29520 | before(grammarAccess.getLowerBoundedScopeDefinitionAccess().getLowerBoundINTTerminalRuleCall_1_1_2_0()); | 26948 | match(input,RULE_INT,FOLLOW_2); |
29521 | } | 26949 | after(grammarAccess.getLowerBoundedScopeDefinitionAccess().getLowerBoundINTTerminalRuleCall_1_1_2_0()); |
29522 | match(input,RULE_INT,FOLLOW_2); if (state.failed) return ; | ||
29523 | if ( state.backtracking==0 ) { | ||
29524 | after(grammarAccess.getLowerBoundedScopeDefinitionAccess().getLowerBoundINTTerminalRuleCall_1_1_2_0()); | ||
29525 | } | ||
29526 | 26950 | ||
29527 | } | 26951 | } |
29528 | 26952 | ||
@@ -29545,29 +26969,25 @@ public class InternalSolverLanguageParser extends AbstractInternalContentAssistP | |||
29545 | 26969 | ||
29546 | 26970 | ||
29547 | // $ANTLR start "rule__ObjectiveDefinition__KindAssignment_0" | 26971 | // $ANTLR start "rule__ObjectiveDefinition__KindAssignment_0" |
29548 | // InternalSolverLanguage.g:9088:1: rule__ObjectiveDefinition__KindAssignment_0 : ( ruleObjectiveKind ) ; | 26972 | // InternalSolverLanguageParser.g:8963:1: rule__ObjectiveDefinition__KindAssignment_0 : ( ruleObjectiveKind ) ; |
29549 | public final void rule__ObjectiveDefinition__KindAssignment_0() throws RecognitionException { | 26973 | public final void rule__ObjectiveDefinition__KindAssignment_0() throws RecognitionException { |
29550 | 26974 | ||
29551 | int stackSize = keepStackSize(); | 26975 | int stackSize = keepStackSize(); |
29552 | 26976 | ||
29553 | try { | 26977 | try { |
29554 | // InternalSolverLanguage.g:9092:1: ( ( ruleObjectiveKind ) ) | 26978 | // InternalSolverLanguageParser.g:8967:1: ( ( ruleObjectiveKind ) ) |
29555 | // InternalSolverLanguage.g:9093:2: ( ruleObjectiveKind ) | 26979 | // InternalSolverLanguageParser.g:8968:2: ( ruleObjectiveKind ) |
29556 | { | 26980 | { |
29557 | // InternalSolverLanguage.g:9093:2: ( ruleObjectiveKind ) | 26981 | // InternalSolverLanguageParser.g:8968:2: ( ruleObjectiveKind ) |
29558 | // InternalSolverLanguage.g:9094:3: ruleObjectiveKind | 26982 | // InternalSolverLanguageParser.g:8969:3: ruleObjectiveKind |
29559 | { | 26983 | { |
29560 | if ( state.backtracking==0 ) { | 26984 | before(grammarAccess.getObjectiveDefinitionAccess().getKindObjectiveKindEnumRuleCall_0_0()); |
29561 | before(grammarAccess.getObjectiveDefinitionAccess().getKindObjectiveKindEnumRuleCall_0_0()); | ||
29562 | } | ||
29563 | pushFollow(FOLLOW_2); | 26985 | pushFollow(FOLLOW_2); |
29564 | ruleObjectiveKind(); | 26986 | ruleObjectiveKind(); |
29565 | 26987 | ||
29566 | state._fsp--; | 26988 | state._fsp--; |
29567 | if (state.failed) return ; | 26989 | |
29568 | if ( state.backtracking==0 ) { | 26990 | after(grammarAccess.getObjectiveDefinitionAccess().getKindObjectiveKindEnumRuleCall_0_0()); |
29569 | after(grammarAccess.getObjectiveDefinitionAccess().getKindObjectiveKindEnumRuleCall_0_0()); | ||
29570 | } | ||
29571 | 26991 | ||
29572 | } | 26992 | } |
29573 | 26993 | ||
@@ -29590,29 +27010,25 @@ public class InternalSolverLanguageParser extends AbstractInternalContentAssistP | |||
29590 | 27010 | ||
29591 | 27011 | ||
29592 | // $ANTLR start "rule__ObjectiveDefinition__ObjectiveAssignment_1" | 27012 | // $ANTLR start "rule__ObjectiveDefinition__ObjectiveAssignment_1" |
29593 | // InternalSolverLanguage.g:9103:1: rule__ObjectiveDefinition__ObjectiveAssignment_1 : ( ruleExpression ) ; | 27013 | // InternalSolverLanguageParser.g:8978:1: rule__ObjectiveDefinition__ObjectiveAssignment_1 : ( ruleExpression ) ; |
29594 | public final void rule__ObjectiveDefinition__ObjectiveAssignment_1() throws RecognitionException { | 27014 | public final void rule__ObjectiveDefinition__ObjectiveAssignment_1() throws RecognitionException { |
29595 | 27015 | ||
29596 | int stackSize = keepStackSize(); | 27016 | int stackSize = keepStackSize(); |
29597 | 27017 | ||
29598 | try { | 27018 | try { |
29599 | // InternalSolverLanguage.g:9107:1: ( ( ruleExpression ) ) | 27019 | // InternalSolverLanguageParser.g:8982:1: ( ( ruleExpression ) ) |
29600 | // InternalSolverLanguage.g:9108:2: ( ruleExpression ) | 27020 | // InternalSolverLanguageParser.g:8983:2: ( ruleExpression ) |
29601 | { | 27021 | { |
29602 | // InternalSolverLanguage.g:9108:2: ( ruleExpression ) | 27022 | // InternalSolverLanguageParser.g:8983:2: ( ruleExpression ) |
29603 | // InternalSolverLanguage.g:9109:3: ruleExpression | 27023 | // InternalSolverLanguageParser.g:8984:3: ruleExpression |
29604 | { | 27024 | { |
29605 | if ( state.backtracking==0 ) { | 27025 | before(grammarAccess.getObjectiveDefinitionAccess().getObjectiveExpressionParserRuleCall_1_0()); |
29606 | before(grammarAccess.getObjectiveDefinitionAccess().getObjectiveExpressionParserRuleCall_1_0()); | ||
29607 | } | ||
29608 | pushFollow(FOLLOW_2); | 27026 | pushFollow(FOLLOW_2); |
29609 | ruleExpression(); | 27027 | ruleExpression(); |
29610 | 27028 | ||
29611 | state._fsp--; | 27029 | state._fsp--; |
29612 | if (state.failed) return ; | 27030 | |
29613 | if ( state.backtracking==0 ) { | 27031 | after(grammarAccess.getObjectiveDefinitionAccess().getObjectiveExpressionParserRuleCall_1_0()); |
29614 | after(grammarAccess.getObjectiveDefinitionAccess().getObjectiveExpressionParserRuleCall_1_0()); | ||
29615 | } | ||
29616 | 27032 | ||
29617 | } | 27033 | } |
29618 | 27034 | ||
@@ -29637,20 +27053,21 @@ public class InternalSolverLanguageParser extends AbstractInternalContentAssistP | |||
29637 | 27053 | ||
29638 | 27054 | ||
29639 | protected DFA2 dfa2 = new DFA2(this); | 27055 | protected DFA2 dfa2 = new DFA2(this); |
27056 | protected DFA9 dfa9 = new DFA9(this); | ||
29640 | protected DFA11 dfa11 = new DFA11(this); | 27057 | protected DFA11 dfa11 = new DFA11(this); |
29641 | protected DFA14 dfa14 = new DFA14(this); | 27058 | protected DFA14 dfa14 = new DFA14(this); |
29642 | static final String dfa_1s = "\15\uffff"; | 27059 | static final String dfa_1s = "\15\uffff"; |
29643 | static final String dfa_2s = "\1\4\1\uffff\1\5\2\uffff\1\5\7\uffff"; | 27060 | static final String dfa_2s = "\1\5\1\uffff\1\5\2\uffff\1\36\7\uffff"; |
29644 | static final String dfa_3s = "\1\111\1\uffff\1\110\2\uffff\1\22\7\uffff"; | 27061 | static final String dfa_3s = "\1\123\1\uffff\1\122\2\uffff\1\122\7\uffff"; |
29645 | static final String dfa_4s = "\1\uffff\1\1\1\uffff\1\2\1\4\1\uffff\1\6\1\10\1\11\1\12\1\3\1\5\1\7"; | 27062 | static final String dfa_4s = "\1\uffff\1\1\1\uffff\1\2\1\4\1\uffff\1\6\1\10\1\11\1\12\1\3\1\5\1\7"; |
29646 | static final String dfa_5s = "\15\uffff}>"; | 27063 | static final String dfa_5s = "\15\uffff}>"; |
29647 | static final String[] dfa_6s = { | 27064 | static final String[] dfa_6s = { |
29648 | "\2\1\1\uffff\1\1\2\uffff\1\1\6\uffff\2\6\7\uffff\2\1\1\uffff\15\1\1\2\2\11\3\uffff\1\4\1\5\1\uffff\1\1\5\uffff\1\1\3\uffff\1\1\1\uffff\1\1\2\uffff\2\1\1\7\2\uffff\1\10\1\3\1\7", | 27065 | "\1\3\1\7\1\uffff\2\11\3\uffff\1\1\1\4\1\uffff\1\1\1\uffff\1\5\1\7\2\1\1\2\1\1\1\10\2\uffff\3\1\1\6\1\uffff\1\1\5\uffff\2\1\1\6\4\1\11\uffff\1\1\1\uffff\2\1\2\uffff\1\1\1\uffff\1\1\7\uffff\1\1\5\uffff\2\1\4\uffff\2\1", |
29649 | "", | 27066 | "", |
29650 | "\1\3\1\1\1\3\7\uffff\2\1\2\uffff\12\1\20\uffff\3\1\6\uffff\3\1\4\uffff\1\12\12\uffff\1\3", | 27067 | "\1\3\47\uffff\2\1\1\uffff\4\1\3\uffff\1\1\1\uffff\1\12\1\uffff\4\1\1\uffff\6\1\2\uffff\1\1\4\uffff\1\3\3\uffff\1\1\1\3", |
29651 | "", | 27068 | "", |
29652 | "", | 27069 | "", |
29653 | "\1\13\1\uffff\1\13\11\uffff\2\14", | 27070 | "\1\14\11\uffff\1\14\44\uffff\1\13\4\uffff\1\13", |
29654 | "", | 27071 | "", |
29655 | "", | 27072 | "", |
29656 | "", | 27073 | "", |
@@ -29681,26 +27098,26 @@ public class InternalSolverLanguageParser extends AbstractInternalContentAssistP | |||
29681 | this.transition = dfa_6; | 27098 | this.transition = dfa_6; |
29682 | } | 27099 | } |
29683 | public String getDescription() { | 27100 | public String getDescription() { |
29684 | return "1513:1: rule__Statement__Alternatives_0 : ( ( ruleAssertionOrDefinition ) | ( rulePredicateDefinition ) | ( ruleUnnamedErrorPrediateDefinition ) | ( ruleDefaultDefinition ) | ( ruleExternPredicateDefinition ) | ( ruleMetricDefinition ) | ( ruleExternMetricDefinition ) | ( ruleClassDefinition ) | ( ruleScopeDefinition ) | ( ruleObjectiveDefinition ) );"; | 27101 | return "1586:1: rule__Statement__Alternatives_0 : ( ( ruleAssertionOrDefinition ) | ( rulePredicateDefinition ) | ( ruleUnnamedErrorPrediateDefinition ) | ( ruleDefaultDefinition ) | ( ruleExternPredicateDefinition ) | ( ruleMetricDefinition ) | ( ruleExternMetricDefinition ) | ( ruleClassDefinition ) | ( ruleScopeDefinition ) | ( ruleObjectiveDefinition ) );"; |
29685 | } | 27102 | } |
29686 | } | 27103 | } |
29687 | static final String dfa_7s = "\12\uffff"; | 27104 | static final String dfa_7s = "\12\uffff"; |
29688 | static final String dfa_8s = "\1\uffff\2\3\4\uffff\1\11\1\3\1\uffff"; | 27105 | static final String dfa_8s = "\1\uffff\2\7\6\uffff\1\7"; |
29689 | static final String dfa_9s = "\1\4\2\5\2\uffff\1\7\1\uffff\1\4\1\5\1\uffff"; | 27106 | static final String dfa_9s = "\1\20\2\32\3\uffff\1\122\2\uffff\1\32"; |
29690 | static final String dfa_10s = "\1\103\2\76\2\uffff\1\7\1\uffff\1\103\1\76\1\uffff"; | 27107 | static final String dfa_10s = "\1\123\2\121\3\uffff\1\122\2\uffff\1\121"; |
29691 | static final String dfa_11s = "\3\uffff\1\1\1\2\1\uffff\1\3\2\uffff\1\4"; | 27108 | static final String dfa_11s = "\3\uffff\1\3\1\4\1\5\1\uffff\1\1\1\2\1\uffff"; |
29692 | static final String dfa_12s = "\12\uffff}>"; | 27109 | static final String dfa_12s = "\12\uffff}>"; |
29693 | static final String[] dfa_13s = { | 27110 | static final String[] dfa_13s = { |
29694 | "\1\3\1\2\1\uffff\1\1\2\uffff\1\3\5\uffff\1\4\11\uffff\2\3\1\uffff\16\3\16\uffff\1\3\3\uffff\1\3\1\uffff\1\3\2\uffff\2\3", | 27111 | "\1\4\4\uffff\3\4\10\uffff\1\4\6\uffff\1\4\21\uffff\1\5\14\uffff\1\3\5\uffff\1\4\1\2\4\uffff\1\1\1\4", |
29695 | "\1\6\1\uffff\1\6\7\uffff\1\3\1\7\2\uffff\12\3\25\uffff\1\5\5\uffff\1\3\4\uffff\2\3", | 27112 | "\1\7\4\uffff\1\7\15\uffff\7\7\3\uffff\1\7\1\uffff\1\10\5\7\1\6\6\7\1\uffff\2\7\1\uffff\2\7\3\uffff\2\10\1\7", |
29696 | "\1\6\1\uffff\1\6\7\uffff\1\3\1\7\2\uffff\12\3\33\uffff\1\3\4\uffff\2\3", | 27113 | "\1\7\4\uffff\1\7\15\uffff\7\7\3\uffff\1\7\1\uffff\1\10\5\7\1\uffff\6\7\1\uffff\2\7\1\uffff\2\7\3\uffff\2\10\1\7", |
29697 | "", | 27114 | "", |
29698 | "", | 27115 | "", |
29699 | "\1\10", | ||
29700 | "", | 27116 | "", |
29701 | "\2\3\1\uffff\1\3\2\uffff\1\3\17\uffff\2\3\1\uffff\16\3\15\uffff\1\11\1\3\3\uffff\1\3\1\11\1\3\2\uffff\2\3", | 27117 | "\1\11", |
29702 | "\1\6\1\uffff\1\6\7\uffff\1\3\1\7\2\uffff\12\3\25\uffff\1\5\5\uffff\1\3\4\uffff\2\3", | 27118 | "", |
29703 | "" | 27119 | "", |
27120 | "\1\7\4\uffff\1\7\15\uffff\7\7\3\uffff\1\7\1\uffff\1\10\5\7\1\6\6\7\1\uffff\2\7\1\uffff\2\7\3\uffff\2\10\1\7" | ||
29704 | }; | 27121 | }; |
29705 | 27122 | ||
29706 | static final short[] dfa_7 = DFA.unpackEncodedString(dfa_7s); | 27123 | static final short[] dfa_7 = DFA.unpackEncodedString(dfa_7s); |
@@ -29711,11 +27128,11 @@ public class InternalSolverLanguageParser extends AbstractInternalContentAssistP | |||
29711 | static final short[] dfa_12 = DFA.unpackEncodedString(dfa_12s); | 27128 | static final short[] dfa_12 = DFA.unpackEncodedString(dfa_12s); |
29712 | static final short[][] dfa_13 = unpackEncodedStringArray(dfa_13s); | 27129 | static final short[][] dfa_13 = unpackEncodedStringArray(dfa_13s); |
29713 | 27130 | ||
29714 | class DFA11 extends DFA { | 27131 | class DFA9 extends DFA { |
29715 | 27132 | ||
29716 | public DFA11(BaseRecognizer recognizer) { | 27133 | public DFA9(BaseRecognizer recognizer) { |
29717 | this.recognizer = recognizer; | 27134 | this.recognizer = recognizer; |
29718 | this.decisionNumber = 11; | 27135 | this.decisionNumber = 9; |
29719 | this.eot = dfa_7; | 27136 | this.eot = dfa_7; |
29720 | this.eof = dfa_8; | 27137 | this.eof = dfa_8; |
29721 | this.min = dfa_9; | 27138 | this.min = dfa_9; |
@@ -29725,117 +27142,156 @@ public class InternalSolverLanguageParser extends AbstractInternalContentAssistP | |||
29725 | this.transition = dfa_13; | 27142 | this.transition = dfa_13; |
29726 | } | 27143 | } |
29727 | public String getDescription() { | 27144 | public String getDescription() { |
29728 | return "1774:1: rule__Argument__Alternatives : ( ( ruleExpressionArgument ) | ( ruleStarArgument ) | ( ruleTypedArgument ) | ( ruleTypedStarArgument ) );"; | 27145 | return "1793:1: rule__AtomicExpression__Alternatives : ( ( ruleReference ) | ( ruleCall ) | ( ruleInterval ) | ( ruleLiteral ) | ( ( rule__AtomicExpression__Group_4__0 ) ) );"; |
29729 | } | 27146 | } |
29730 | } | 27147 | } |
29731 | static final String dfa_14s = "\17\uffff"; | 27148 | static final String dfa_14s = "\1\uffff\2\3\3\uffff\1\11\1\uffff\1\3\1\uffff"; |
29732 | static final String dfa_15s = "\15\uffff\1\6\1\uffff"; | 27149 | static final String dfa_15s = "\1\15\2\55\2\uffff\1\122\1\15\1\uffff\1\55\1\uffff"; |
29733 | static final String dfa_16s = "\1\107\1\4\2\23\1\26\1\7\3\uffff\1\5\1\23\2\26\1\6\1\26"; | 27150 | static final String dfa_16s = "\1\123\2\122\2\uffff\1\122\1\123\1\uffff\1\122\1\uffff"; |
29734 | static final String dfa_17s = "\1\107\1\7\1\62\2\30\1\7\3\uffff\1\7\3\62\1\7\1\62"; | 27151 | static final String dfa_17s = "\3\uffff\1\1\1\2\2\uffff\1\3\1\uffff\1\4"; |
29735 | static final String dfa_18s = "\6\uffff\1\3\1\2\1\1\6\uffff"; | 27152 | static final String[] dfa_18s = { |
29736 | static final String dfa_19s = "\17\uffff}>"; | 27153 | "\1\3\2\uffff\1\3\3\uffff\4\3\3\uffff\3\3\2\uffff\1\3\5\uffff\2\3\1\uffff\4\3\13\uffff\2\3\1\uffff\1\4\1\3\1\uffff\1\3\7\uffff\1\3\5\uffff\1\3\1\2\4\uffff\1\1\1\3", |
29737 | static final String[] dfa_20s = { | 27154 | "\1\3\3\uffff\3\3\3\uffff\1\3\1\uffff\2\3\1\6\3\3\1\5\1\3\2\uffff\1\3\1\uffff\1\3\2\uffff\1\3\4\uffff\1\7\1\uffff\2\3\1\uffff\1\7", |
27155 | "\1\3\3\uffff\3\3\3\uffff\1\3\1\uffff\2\3\1\6\3\3\1\uffff\1\3\2\uffff\1\3\1\uffff\1\3\2\uffff\1\3\4\uffff\1\7\1\uffff\2\3\1\uffff\1\7", | ||
27156 | "", | ||
27157 | "", | ||
27158 | "\1\10", | ||
27159 | "\1\3\2\uffff\1\3\3\uffff\4\3\3\uffff\3\3\2\uffff\1\3\5\uffff\2\3\1\uffff\4\3\13\uffff\2\3\1\11\1\uffff\1\3\1\11\1\3\7\uffff\1\3\5\uffff\2\3\4\uffff\2\3", | ||
27160 | "", | ||
27161 | "\1\3\3\uffff\3\3\3\uffff\1\3\1\uffff\2\3\1\6\3\3\1\5\1\3\2\uffff\1\3\1\uffff\1\3\2\uffff\1\3\4\uffff\1\7\1\uffff\2\3\1\uffff\1\7", | ||
27162 | "" | ||
27163 | }; | ||
27164 | static final short[] dfa_14 = DFA.unpackEncodedString(dfa_14s); | ||
27165 | static final char[] dfa_15 = DFA.unpackEncodedStringToUnsignedChars(dfa_15s); | ||
27166 | static final char[] dfa_16 = DFA.unpackEncodedStringToUnsignedChars(dfa_16s); | ||
27167 | static final short[] dfa_17 = DFA.unpackEncodedString(dfa_17s); | ||
27168 | static final short[][] dfa_18 = unpackEncodedStringArray(dfa_18s); | ||
27169 | |||
27170 | class DFA11 extends DFA { | ||
27171 | |||
27172 | public DFA11(BaseRecognizer recognizer) { | ||
27173 | this.recognizer = recognizer; | ||
27174 | this.decisionNumber = 11; | ||
27175 | this.eot = dfa_7; | ||
27176 | this.eof = dfa_14; | ||
27177 | this.min = dfa_15; | ||
27178 | this.max = dfa_16; | ||
27179 | this.accept = dfa_17; | ||
27180 | this.special = dfa_12; | ||
27181 | this.transition = dfa_18; | ||
27182 | } | ||
27183 | public String getDescription() { | ||
27184 | return "1853:1: rule__Argument__Alternatives : ( ( ruleExpressionArgument ) | ( ruleStarArgument ) | ( ruleTypedArgument ) | ( ruleTypedStarArgument ) );"; | ||
27185 | } | ||
27186 | } | ||
27187 | static final String dfa_19s = "\17\uffff"; | ||
27188 | static final String dfa_20s = "\13\uffff\2\7\1\uffff\1\7"; | ||
27189 | static final String dfa_21s = "\1\30\1\115\3\61\1\122\3\uffff\1\115\3\61\1\122\1\61"; | ||
27190 | static final String dfa_22s = "\1\30\1\123\1\77\2\63\1\122\3\uffff\1\122\1\77\2\121\1\122\1\121"; | ||
27191 | static final String dfa_23s = "\6\uffff\1\2\1\3\1\1\6\uffff"; | ||
27192 | static final String dfa_24s = "\17\uffff}>"; | ||
27193 | static final String[] dfa_25s = { | ||
29738 | "\1\1", | 27194 | "\1\1", |
29739 | "\1\4\1\3\1\uffff\1\2", | 27195 | "\1\3\4\uffff\1\2\1\4", |
29740 | "\1\10\2\uffff\1\7\1\uffff\1\6\31\uffff\1\5", | 27196 | "\1\6\1\10\1\7\13\uffff\1\5", |
29741 | "\1\10\2\uffff\1\7\1\uffff\1\6", | 27197 | "\1\6\1\10\1\7", |
29742 | "\1\11\1\uffff\1\7", | 27198 | "\1\11\1\uffff\1\6", |
29743 | "\1\12", | 27199 | "\1\12", |
29744 | "", | 27200 | "", |
29745 | "", | 27201 | "", |
29746 | "", | 27202 | "", |
29747 | "\1\14\1\uffff\1\13", | 27203 | "\1\14\4\uffff\1\13", |
29748 | "\1\10\2\uffff\1\7\1\uffff\1\6\31\uffff\1\5", | 27204 | "\1\6\1\10\1\7\13\uffff\1\5", |
29749 | "\1\7\33\uffff\1\15", | 27205 | "\1\6\15\uffff\1\15\21\uffff\1\7", |
29750 | "\1\7\33\uffff\1\6", | 27206 | "\1\6\37\uffff\1\7", |
29751 | "\1\6\1\16", | 27207 | "\1\16", |
29752 | "\1\7\33\uffff\1\15" | 27208 | "\1\6\15\uffff\1\15\21\uffff\1\7" |
29753 | }; | 27209 | }; |
29754 | 27210 | ||
29755 | static final short[] dfa_14 = DFA.unpackEncodedString(dfa_14s); | ||
29756 | static final short[] dfa_15 = DFA.unpackEncodedString(dfa_15s); | ||
29757 | static final char[] dfa_16 = DFA.unpackEncodedStringToUnsignedChars(dfa_16s); | ||
29758 | static final char[] dfa_17 = DFA.unpackEncodedStringToUnsignedChars(dfa_17s); | ||
29759 | static final short[] dfa_18 = DFA.unpackEncodedString(dfa_18s); | ||
29760 | static final short[] dfa_19 = DFA.unpackEncodedString(dfa_19s); | 27211 | static final short[] dfa_19 = DFA.unpackEncodedString(dfa_19s); |
29761 | static final short[][] dfa_20 = unpackEncodedStringArray(dfa_20s); | 27212 | static final short[] dfa_20 = DFA.unpackEncodedString(dfa_20s); |
27213 | static final char[] dfa_21 = DFA.unpackEncodedStringToUnsignedChars(dfa_21s); | ||
27214 | static final char[] dfa_22 = DFA.unpackEncodedStringToUnsignedChars(dfa_22s); | ||
27215 | static final short[] dfa_23 = DFA.unpackEncodedString(dfa_23s); | ||
27216 | static final short[] dfa_24 = DFA.unpackEncodedString(dfa_24s); | ||
27217 | static final short[][] dfa_25 = unpackEncodedStringArray(dfa_25s); | ||
29762 | 27218 | ||
29763 | class DFA14 extends DFA { | 27219 | class DFA14 extends DFA { |
29764 | 27220 | ||
29765 | public DFA14(BaseRecognizer recognizer) { | 27221 | public DFA14(BaseRecognizer recognizer) { |
29766 | this.recognizer = recognizer; | 27222 | this.recognizer = recognizer; |
29767 | this.decisionNumber = 14; | 27223 | this.decisionNumber = 14; |
29768 | this.eot = dfa_14; | 27224 | this.eot = dfa_19; |
29769 | this.eof = dfa_15; | 27225 | this.eof = dfa_20; |
29770 | this.min = dfa_16; | 27226 | this.min = dfa_21; |
29771 | this.max = dfa_17; | 27227 | this.max = dfa_22; |
29772 | this.accept = dfa_18; | 27228 | this.accept = dfa_23; |
29773 | this.special = dfa_19; | 27229 | this.special = dfa_24; |
29774 | this.transition = dfa_20; | 27230 | this.transition = dfa_25; |
29775 | } | 27231 | } |
29776 | public String getDescription() { | 27232 | public String getDescription() { |
29777 | return "1873:1: rule__ScopeDefinition__Alternatives : ( ( ruleExactScopeDefinition ) | ( ruleBoundedScopeDefinition ) | ( ruleLowerBoundedScopeDefinition ) );"; | 27233 | return "1952:1: rule__ScopeDefinition__Alternatives : ( ( ruleExactScopeDefinition ) | ( ruleBoundedScopeDefinition ) | ( ruleLowerBoundedScopeDefinition ) );"; |
29778 | } | 27234 | } |
29779 | } | 27235 | } |
29780 | 27236 | ||
29781 | 27237 | ||
29782 | public static final BitSet FOLLOW_1 = new BitSet(new long[]{0x0000000000000000L}); | 27238 | public static final BitSet FOLLOW_1 = new BitSet(new long[]{0x0000000000000000L}); |
29783 | public static final BitSet FOLLOW_2 = new BitSet(new long[]{0x0000000000000002L}); | 27239 | public static final BitSet FOLLOW_2 = new BitSet(new long[]{0x0000000000000002L}); |
29784 | public static final BitSet FOLLOW_3 = new BitSet(new long[]{0xA20B1FFFEC0604B2L,0x000000000000039CL}); | 27240 | public static final BitSet FOLLOW_3 = new BitSet(new long[]{0x53401FC179FD6362L,0x00000000000C3040L}); |
29785 | public static final BitSet FOLLOW_4 = new BitSet(new long[]{0x0000000000000040L}); | 27241 | public static final BitSet FOLLOW_4 = new BitSet(new long[]{0x0000000000000000L,0x0000000000020000L}); |
29786 | public static final BitSet FOLLOW_5 = new BitSet(new long[]{0x0000E00000000000L}); | 27242 | public static final BitSet FOLLOW_5 = new BitSet(new long[]{0x0001000000000000L,0x0000000000000012L}); |
29787 | public static final BitSet FOLLOW_6 = new BitSet(new long[]{0x0000200000000000L}); | 27243 | public static final BitSet FOLLOW_6 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000002L}); |
29788 | public static final BitSet FOLLOW_7 = new BitSet(new long[]{0xA20807FFEC0004B0L,0x000000000000000CL}); | 27244 | public static final BitSet FOLLOW_7 = new BitSet(new long[]{0x53401EC138F12000L,0x00000000000C3040L}); |
29789 | public static final BitSet FOLLOW_8 = new BitSet(new long[]{0x0000400000000000L}); | 27245 | public static final BitSet FOLLOW_8 = new BitSet(new long[]{0x0001000000000000L}); |
29790 | public static final BitSet FOLLOW_9 = new BitSet(new long[]{0x00000000000000A0L}); | 27246 | public static final BitSet FOLLOW_9 = new BitSet(new long[]{0x0000000000000000L,0x0000000000042000L}); |
29791 | public static final BitSet FOLLOW_10 = new BitSet(new long[]{0x0000040000000000L}); | 27247 | public static final BitSet FOLLOW_10 = new BitSet(new long[]{0x0000000000400000L}); |
29792 | public static final BitSet FOLLOW_11 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000100L}); | 27248 | public static final BitSet FOLLOW_11 = new BitSet(new long[]{0x0000000000000020L}); |
29793 | public static final BitSet FOLLOW_12 = new BitSet(new long[]{0x2000000000000000L}); | 27249 | public static final BitSet FOLLOW_12 = new BitSet(new long[]{0x0200000000000000L}); |
29794 | public static final BitSet FOLLOW_13 = new BitSet(new long[]{0x0004000000000000L}); | 27250 | public static final BitSet FOLLOW_13 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000010L}); |
29795 | public static final BitSet FOLLOW_14 = new BitSet(new long[]{0x0000800000000000L}); | 27251 | public static final BitSet FOLLOW_14 = new BitSet(new long[]{0x0000010040000000L}); |
29796 | public static final BitSet FOLLOW_15 = new BitSet(new long[]{0x0000000000060000L}); | 27252 | public static final BitSet FOLLOW_15 = new BitSet(new long[]{0x0000000080000000L}); |
29797 | public static final BitSet FOLLOW_16 = new BitSet(new long[]{0x0010000000000000L}); | 27253 | public static final BitSet FOLLOW_16 = new BitSet(new long[]{0x0000000004000000L}); |
29798 | public static final BitSet FOLLOW_17 = new BitSet(new long[]{0x0020000000000000L}); | 27254 | public static final BitSet FOLLOW_17 = new BitSet(new long[]{0x0000400000000000L,0x0000000000000004L}); |
29799 | public static final BitSet FOLLOW_18 = new BitSet(new long[]{0x00C0000000000000L}); | 27255 | public static final BitSet FOLLOW_18 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000004L}); |
29800 | public static final BitSet FOLLOW_19 = new BitSet(new long[]{0x0040000000000000L}); | 27256 | public static final BitSet FOLLOW_19 = new BitSet(new long[]{0x0000000000000002L,0x0000000000000004L}); |
29801 | public static final BitSet FOLLOW_20 = new BitSet(new long[]{0x0040000000000002L}); | 27257 | public static final BitSet FOLLOW_20 = new BitSet(new long[]{0x0000400000000000L}); |
29802 | public static final BitSet FOLLOW_21 = new BitSet(new long[]{0x0080000000000000L}); | 27258 | public static final BitSet FOLLOW_21 = new BitSet(new long[]{0x2000000000000000L}); |
29803 | public static final BitSet FOLLOW_22 = new BitSet(new long[]{0x0100000000000000L}); | 27259 | public static final BitSet FOLLOW_22 = new BitSet(new long[]{0x2000000000000002L}); |
29804 | public static final BitSet FOLLOW_23 = new BitSet(new long[]{0x0100000000000002L}); | 27260 | public static final BitSet FOLLOW_23 = new BitSet(new long[]{0x008E200000000000L,0x0000000000000028L}); |
29805 | public static final BitSet FOLLOW_24 = new BitSet(new long[]{0x0000000003F80000L}); | 27261 | public static final BitSet FOLLOW_24 = new BitSet(new long[]{0x5000000000000000L}); |
29806 | public static final BitSet FOLLOW_25 = new BitSet(new long[]{0x000000000C000000L}); | 27262 | public static final BitSet FOLLOW_25 = new BitSet(new long[]{0x5000000000000002L}); |
29807 | public static final BitSet FOLLOW_26 = new BitSet(new long[]{0x000000000C000002L}); | 27263 | public static final BitSet FOLLOW_26 = new BitSet(new long[]{0x0800000000000000L,0x0000000000000001L}); |
29808 | public static final BitSet FOLLOW_27 = new BitSet(new long[]{0x0000000010010000L}); | 27264 | public static final BitSet FOLLOW_27 = new BitSet(new long[]{0x0800000000000002L,0x0000000000000001L}); |
29809 | public static final BitSet FOLLOW_28 = new BitSet(new long[]{0x0000000010010002L}); | 27265 | public static final BitSet FOLLOW_28 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000100L}); |
29810 | public static final BitSet FOLLOW_29 = new BitSet(new long[]{0x0000000000008000L}); | 27266 | public static final BitSet FOLLOW_29 = new BitSet(new long[]{0x02001AC130F10000L,0x00000000000C3040L}); |
29811 | public static final BitSet FOLLOW_30 = new BitSet(new long[]{0xA20007FE000004B0L,0x000000000000000CL}); | 27267 | public static final BitSet FOLLOW_30 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000200L}); |
29812 | public static final BitSet FOLLOW_31 = new BitSet(new long[]{0x0400000000000000L}); | 27268 | public static final BitSet FOLLOW_31 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000800L}); |
29813 | public static final BitSet FOLLOW_32 = new BitSet(new long[]{0x0800000000000000L}); | 27269 | public static final BitSet FOLLOW_32 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000400L}); |
29814 | public static final BitSet FOLLOW_33 = new BitSet(new long[]{0x1000000000000000L}); | 27270 | public static final BitSet FOLLOW_33 = new BitSet(new long[]{0x0400000000000000L}); |
29815 | public static final BitSet FOLLOW_34 = new BitSet(new long[]{0x4000000000000000L}); | 27271 | public static final BitSet FOLLOW_34 = new BitSet(new long[]{0x0200000000000000L,0x0000000000018000L}); |
29816 | public static final BitSet FOLLOW_35 = new BitSet(new long[]{0x2000000000000300L}); | 27272 | public static final BitSet FOLLOW_35 = new BitSet(new long[]{0x5F401EC138F12000L,0x00000000000C3040L}); |
29817 | public static final BitSet FOLLOW_36 = new BitSet(new long[]{0xE20807FFEC0104B0L,0x000000000000000CL}); | 27273 | public static final BitSet FOLLOW_36 = new BitSet(new long[]{0x5B401EC138F12000L,0x00000000000C3040L}); |
29818 | public static final BitSet FOLLOW_37 = new BitSet(new long[]{0xA20807FFEC0104B0L,0x000000000000000CL}); | 27274 | public static final BitSet FOLLOW_37 = new BitSet(new long[]{0x0800000000000000L}); |
29819 | public static final BitSet FOLLOW_38 = new BitSet(new long[]{0x0000000000010000L}); | 27275 | public static final BitSet FOLLOW_38 = new BitSet(new long[]{0x0000800000000000L}); |
29820 | public static final BitSet FOLLOW_39 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000001L}); | 27276 | public static final BitSet FOLLOW_39 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000080L}); |
29821 | public static final BitSet FOLLOW_40 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000002L}); | 27277 | public static final BitSet FOLLOW_40 = new BitSet(new long[]{0x0000008000000000L}); |
29822 | public static final BitSet FOLLOW_41 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000004L}); | 27278 | public static final BitSet FOLLOW_41 = new BitSet(new long[]{0x0000000000200000L}); |
29823 | public static final BitSet FOLLOW_42 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000008L}); | 27279 | public static final BitSet FOLLOW_42 = new BitSet(new long[]{0x0000000000080040L}); |
29824 | public static final BitSet FOLLOW_43 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000210L}); | 27280 | public static final BitSet FOLLOW_43 = new BitSet(new long[]{0x0000000000000000L,0x0000000000040000L}); |
29825 | public static final BitSet FOLLOW_44 = new BitSet(new long[]{0x0000000000000080L}); | 27281 | public static final BitSet FOLLOW_44 = new BitSet(new long[]{0x0000000000008000L,0x0000000000000200L}); |
29826 | public static final BitSet FOLLOW_45 = new BitSet(new long[]{0x0400000000000000L,0x0000000000000020L}); | 27282 | public static final BitSet FOLLOW_45 = new BitSet(new long[]{0x0000000000000080L,0x0000000000042800L}); |
29827 | public static final BitSet FOLLOW_46 = new BitSet(new long[]{0x08000000000000A0L,0x0000000000000400L}); | 27283 | public static final BitSet FOLLOW_46 = new BitSet(new long[]{0x0000000000000082L,0x0000000000042000L}); |
29828 | public static final BitSet FOLLOW_47 = new BitSet(new long[]{0x00000000000000A2L,0x0000000000000400L}); | 27284 | public static final BitSet FOLLOW_47 = new BitSet(new long[]{0x0000000000000080L,0x0000000000042000L}); |
29829 | public static final BitSet FOLLOW_48 = new BitSet(new long[]{0x00000000000000A0L,0x0000000000000400L}); | 27285 | public static final BitSet FOLLOW_48 = new BitSet(new long[]{0x0000000000000000L,0x0000000000040040L}); |
29830 | public static final BitSet FOLLOW_49 = new BitSet(new long[]{0x8000000000000080L}); | 27286 | public static final BitSet FOLLOW_49 = new BitSet(new long[]{0x0000000000000400L,0x0000000000000004L}); |
29831 | public static final BitSet FOLLOW_50 = new BitSet(new long[]{0x0040000000000000L,0x0000000000000040L}); | 27287 | public static final BitSet FOLLOW_50 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000040L}); |
29832 | public static final BitSet FOLLOW_51 = new BitSet(new long[]{0x8000000000000000L}); | 27288 | public static final BitSet FOLLOW_51 = new BitSet(new long[]{0x0800000000000000L,0x0000000000080000L}); |
29833 | public static final BitSet FOLLOW_52 = new BitSet(new long[]{0x0000000000010010L}); | 27289 | public static final BitSet FOLLOW_52 = new BitSet(new long[]{0x0000000000000000L,0x0000000000080000L}); |
29834 | public static final BitSet FOLLOW_53 = new BitSet(new long[]{0x0000000000000010L}); | 27290 | public static final BitSet FOLLOW_53 = new BitSet(new long[]{0x0004000000000000L}); |
29835 | public static final BitSet FOLLOW_54 = new BitSet(new long[]{0x0000000000080000L}); | 27291 | public static final BitSet FOLLOW_54 = new BitSet(new long[]{0x0000000000000000L,0x00000000000C2000L}); |
29836 | public static final BitSet FOLLOW_55 = new BitSet(new long[]{0x00000000000000B0L}); | 27292 | public static final BitSet FOLLOW_55 = new BitSet(new long[]{0x0002000000000000L}); |
29837 | public static final BitSet FOLLOW_56 = new BitSet(new long[]{0x0000000000400000L}); | 27293 | public static final BitSet FOLLOW_56 = new BitSet(new long[]{0x0008000000000000L}); |
29838 | public static final BitSet FOLLOW_57 = new BitSet(new long[]{0x0000000001000000L}); | 27294 | public static final BitSet FOLLOW_57 = new BitSet(new long[]{0x8000000000000000L}); |
29839 | public static final BitSet FOLLOW_58 = new BitSet(new long[]{0x0004000000000002L}); | 27295 | public static final BitSet FOLLOW_58 = new BitSet(new long[]{0x8000000000000002L}); |
29840 | 27296 | ||
29841 | } \ No newline at end of file | 27297 | } \ No newline at end of file |
diff --git a/Application/org.eclipse.viatra.solver.language.ide/src-gen/org/eclipse/viatra/solver/language/ide/contentassist/antlr/internal/InternalSolverLanguageParser.tokens b/Application/org.eclipse.viatra.solver.language.ide/src-gen/org/eclipse/viatra/solver/language/ide/contentassist/antlr/internal/InternalSolverLanguageParser.tokens new file mode 100644 index 00000000..81343db5 --- /dev/null +++ b/Application/org.eclipse.viatra.solver.language.ide/src-gen/org/eclipse/viatra/solver/language/ide/contentassist/antlr/internal/InternalSolverLanguageParser.tokens | |||
@@ -0,0 +1,83 @@ | |||
1 | '!'=56 | ||
2 | '!='=45 | ||
3 | '('=57 | ||
4 | ')'=58 | ||
5 | '*'=59 | ||
6 | '+'=60 | ||
7 | ','=61 | ||
8 | '-'=62 | ||
9 | '->'=46 | ||
10 | '.'=63 | ||
11 | '..'=47 | ||
12 | '/'=64 | ||
13 | ':'=65 | ||
14 | ':-'=48 | ||
15 | ';'=66 | ||
16 | '<'=67 | ||
17 | '<='=49 | ||
18 | '='=68 | ||
19 | '=='=50 | ||
20 | '>'=69 | ||
21 | '>='=51 | ||
22 | 'ADD'=33 | ||
23 | 'DIV'=34 | ||
24 | 'EQ'=52 | ||
25 | 'GREATER'=11 | ||
26 | 'GREATER_EQ'=4 | ||
27 | 'IN'=53 | ||
28 | 'LESS'=25 | ||
29 | 'LESS_EQ'=12 | ||
30 | 'MUL'=35 | ||
31 | 'NOT_EQ'=17 | ||
32 | 'POW'=36 | ||
33 | 'SUB'=37 | ||
34 | '['=70 | ||
35 | ']'=71 | ||
36 | '^'=72 | ||
37 | 'abstract'=6 | ||
38 | 'avg'=38 | ||
39 | 'class'=19 | ||
40 | 'contains'=7 | ||
41 | 'count'=20 | ||
42 | 'current'=13 | ||
43 | 'default'=14 | ||
44 | 'else'=26 | ||
45 | 'empty'=21 | ||
46 | 'error'=22 | ||
47 | 'extends'=15 | ||
48 | 'extern'=18 | ||
49 | 'false'=23 | ||
50 | 'functional'=5 | ||
51 | 'if'=54 | ||
52 | 'in'=55 | ||
53 | 'inf'=39 | ||
54 | 'int'=40 | ||
55 | 'max'=41 | ||
56 | 'maximize'=8 | ||
57 | 'may'=42 | ||
58 | 'min'=43 | ||
59 | 'minimize'=9 | ||
60 | 'must'=27 | ||
61 | 'only'=28 | ||
62 | 'opposite'=10 | ||
63 | 'prod'=29 | ||
64 | 'real'=30 | ||
65 | 'scope'=24 | ||
66 | 'sum'=44 | ||
67 | 'then'=31 | ||
68 | 'true'=32 | ||
69 | 'unknown'=16 | ||
70 | '{'=73 | ||
71 | '|'=74 | ||
72 | '}'=75 | ||
73 | RULE_ANY_OTHER=86 | ||
74 | RULE_FULL_STOP=81 | ||
75 | RULE_ID=82 | ||
76 | RULE_INT=83 | ||
77 | RULE_ML_COMMENT=84 | ||
78 | RULE_QUOTED_ID=77 | ||
79 | RULE_REFLEXIVE_TRANSITIVE_CLOSURE=80 | ||
80 | RULE_SL_COMMENT=78 | ||
81 | RULE_STRING=76 | ||
82 | RULE_TRANSITIVE_CLOSURE=79 | ||
83 | RULE_WS=85 | ||
diff --git a/Application/org.eclipse.viatra.solver.language.ide/src-gen/org/eclipse/viatra/solver/language/ide/contentassist/antlr/lexer/InternalSolverLanguageLexer.g b/Application/org.eclipse.viatra.solver.language.ide/src-gen/org/eclipse/viatra/solver/language/ide/contentassist/antlr/lexer/InternalSolverLanguageLexer.g new file mode 100644 index 00000000..309435e3 --- /dev/null +++ b/Application/org.eclipse.viatra.solver.language.ide/src-gen/org/eclipse/viatra/solver/language/ide/contentassist/antlr/lexer/InternalSolverLanguageLexer.g | |||
@@ -0,0 +1,178 @@ | |||
1 | /* | ||
2 | * generated by Xtext 2.21.0 | ||
3 | */ | ||
4 | lexer grammar InternalSolverLanguageLexer; | ||
5 | |||
6 | @header { | ||
7 | package org.eclipse.viatra.solver.language.ide.contentassist.antlr.lexer; | ||
8 | |||
9 | // Hack: Use our own Lexer superclass by means of import. | ||
10 | // Currently there is no other way to specify the superclass for the lexer. | ||
11 | import org.eclipse.xtext.ide.editor.contentassist.antlr.internal.Lexer; | ||
12 | } | ||
13 | |||
14 | GREATER_EQ : 'GREATER_EQ'; | ||
15 | |||
16 | Functional : 'functional'; | ||
17 | |||
18 | Abstract : 'abstract'; | ||
19 | |||
20 | Contains : 'contains'; | ||
21 | |||
22 | Maximize : 'maximize'; | ||
23 | |||
24 | Minimize : 'minimize'; | ||
25 | |||
26 | Opposite : 'opposite'; | ||
27 | |||
28 | GREATER : 'GREATER'; | ||
29 | |||
30 | LESS_EQ : 'LESS_EQ'; | ||
31 | |||
32 | Current : 'current'; | ||
33 | |||
34 | Default : 'default'; | ||
35 | |||
36 | Extends : 'extends'; | ||
37 | |||
38 | Unknown : 'unknown'; | ||
39 | |||
40 | NOT_EQ : 'NOT_EQ'; | ||
41 | |||
42 | Extern : 'extern'; | ||
43 | |||
44 | Class : 'class'; | ||
45 | |||
46 | Count : 'count'; | ||
47 | |||
48 | Empty : 'empty'; | ||
49 | |||
50 | Error : 'error'; | ||
51 | |||
52 | False : 'false'; | ||
53 | |||
54 | Scope : 'scope'; | ||
55 | |||
56 | LESS : 'LESS'; | ||
57 | |||
58 | Else : 'else'; | ||
59 | |||
60 | Must : 'must'; | ||
61 | |||
62 | Only : 'only'; | ||
63 | |||
64 | Prod : 'prod'; | ||
65 | |||
66 | Real : 'real'; | ||
67 | |||
68 | Then : 'then'; | ||
69 | |||
70 | True : 'true'; | ||
71 | |||
72 | ADD : 'ADD'; | ||
73 | |||
74 | DIV : 'DIV'; | ||
75 | |||
76 | MUL : 'MUL'; | ||
77 | |||
78 | POW : 'POW'; | ||
79 | |||
80 | SUB : 'SUB'; | ||
81 | |||
82 | Avg : 'avg'; | ||
83 | |||
84 | Inf : 'inf'; | ||
85 | |||
86 | Int : 'int'; | ||
87 | |||
88 | Max : 'max'; | ||
89 | |||
90 | May : 'may'; | ||
91 | |||
92 | Min : 'min'; | ||
93 | |||
94 | Sum : 'sum'; | ||
95 | |||
96 | ExclamationMarkEqualsSign : '!='; | ||
97 | |||
98 | HyphenMinusGreaterThanSign : '->'; | ||
99 | |||
100 | FullStopFullStop : '..'; | ||
101 | |||
102 | ColonHyphenMinus : ':-'; | ||
103 | |||
104 | LessThanSignEqualsSign : '<='; | ||
105 | |||
106 | EqualsSignEqualsSign : '=='; | ||
107 | |||
108 | GreaterThanSignEqualsSign : '>='; | ||
109 | |||
110 | EQ : 'EQ'; | ||
111 | |||
112 | IN : 'IN'; | ||
113 | |||
114 | If : 'if'; | ||
115 | |||
116 | In : 'in'; | ||
117 | |||
118 | ExclamationMark : '!'; | ||
119 | |||
120 | LeftParenthesis : '('; | ||
121 | |||
122 | RightParenthesis : ')'; | ||
123 | |||
124 | Asterisk : '*'; | ||
125 | |||
126 | PlusSign : '+'; | ||
127 | |||
128 | Comma : ','; | ||
129 | |||
130 | HyphenMinus : '-'; | ||
131 | |||
132 | FullStop : '.'; | ||
133 | |||
134 | Solidus : '/'; | ||
135 | |||
136 | Colon : ':'; | ||
137 | |||
138 | Semicolon : ';'; | ||
139 | |||
140 | LessThanSign : '<'; | ||
141 | |||
142 | EqualsSign : '='; | ||
143 | |||
144 | GreaterThanSign : '>'; | ||
145 | |||
146 | LeftSquareBracket : '['; | ||
147 | |||
148 | RightSquareBracket : ']'; | ||
149 | |||
150 | CircumflexAccent : '^'; | ||
151 | |||
152 | LeftCurlyBracket : '{'; | ||
153 | |||
154 | VerticalLine : '|'; | ||
155 | |||
156 | RightCurlyBracket : '}'; | ||
157 | |||
158 | RULE_STRING : '"' ('\\' .|~(('\\'|'"')))* '"'; | ||
159 | |||
160 | RULE_QUOTED_ID : '\'' ('\\' .|~(('\\'|'\'')))* '\''; | ||
161 | |||
162 | RULE_SL_COMMENT : ('%'|'//') ~(('\n'|'\r'))* ('\r'? '\n')?; | ||
163 | |||
164 | fragment RULE_TRANSITIVE_CLOSURE : ; | ||
165 | |||
166 | fragment RULE_REFLEXIVE_TRANSITIVE_CLOSURE : ; | ||
167 | |||
168 | fragment RULE_FULL_STOP : ; | ||
169 | |||
170 | RULE_ID : '^'? ('a'..'z'|'A'..'Z'|'_') ('a'..'z'|'A'..'Z'|'_'|'0'..'9')*; | ||
171 | |||
172 | RULE_INT : ('0'..'9')+; | ||
173 | |||
174 | RULE_ML_COMMENT : '/*' ( options {greedy=false;} : . )*'*/'; | ||
175 | |||
176 | RULE_WS : (' '|'\t'|'\r'|'\n')+; | ||
177 | |||
178 | RULE_ANY_OTHER : .; | ||
diff --git a/Application/org.eclipse.viatra.solver.language.ide/src-gen/org/eclipse/viatra/solver/language/ide/contentassist/antlr/lexer/InternalSolverLanguageLexer.java b/Application/org.eclipse.viatra.solver.language.ide/src-gen/org/eclipse/viatra/solver/language/ide/contentassist/antlr/lexer/InternalSolverLanguageLexer.java new file mode 100644 index 00000000..86514bf5 --- /dev/null +++ b/Application/org.eclipse.viatra.solver.language.ide/src-gen/org/eclipse/viatra/solver/language/ide/contentassist/antlr/lexer/InternalSolverLanguageLexer.java | |||
@@ -0,0 +1,3208 @@ | |||
1 | package org.eclipse.viatra.solver.language.ide.contentassist.antlr.lexer; | ||
2 | |||
3 | // Hack: Use our own Lexer superclass by means of import. | ||
4 | // Currently there is no other way to specify the superclass for the lexer. | ||
5 | import org.eclipse.xtext.ide.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 InternalSolverLanguageLexer extends Lexer { | ||
15 | public static final int ADD=33; | ||
16 | public static final int True=32; | ||
17 | public static final int GREATER_EQ=4; | ||
18 | public static final int Count=20; | ||
19 | public static final int False=23; | ||
20 | public static final int Must=27; | ||
21 | public static final int LessThanSign=67; | ||
22 | public static final int LeftParenthesis=57; | ||
23 | public static final int Unknown=16; | ||
24 | public static final int RULE_REFLEXIVE_TRANSITIVE_CLOSURE=80; | ||
25 | public static final int FullStopFullStop=47; | ||
26 | public static final int Real=30; | ||
27 | public static final int Then=31; | ||
28 | public static final int Extends=15; | ||
29 | public static final int RightSquareBracket=71; | ||
30 | public static final int ExclamationMark=56; | ||
31 | public static final int Opposite=10; | ||
32 | public static final int SUB=37; | ||
33 | public static final int GreaterThanSign=69; | ||
34 | public static final int NOT_EQ=17; | ||
35 | public static final int RULE_ID=82; | ||
36 | public static final int MUL=35; | ||
37 | public static final int IN=53; | ||
38 | public static final int RULE_QUOTED_ID=77; | ||
39 | public static final int RightParenthesis=58; | ||
40 | public static final int Sum=44; | ||
41 | public static final int EQ=52; | ||
42 | public static final int GreaterThanSignEqualsSign=51; | ||
43 | public static final int Functional=5; | ||
44 | public static final int EqualsSignEqualsSign=50; | ||
45 | public static final int Avg=38; | ||
46 | public static final int Min=43; | ||
47 | public static final int VerticalLine=74; | ||
48 | public static final int PlusSign=60; | ||
49 | public static final int RULE_INT=83; | ||
50 | public static final int Contains=7; | ||
51 | public static final int RULE_ML_COMMENT=84; | ||
52 | public static final int POW=36; | ||
53 | public static final int RULE_TRANSITIVE_CLOSURE=79; | ||
54 | public static final int Class=19; | ||
55 | public static final int LESS=25; | ||
56 | public static final int LeftSquareBracket=70; | ||
57 | public static final int RULE_FULL_STOP=81; | ||
58 | public static final int Current=13; | ||
59 | public static final int If=54; | ||
60 | public static final int Inf=39; | ||
61 | public static final int LESS_EQ=12; | ||
62 | public static final int May=42; | ||
63 | public static final int Max=41; | ||
64 | public static final int In=55; | ||
65 | public static final int RULE_STRING=76; | ||
66 | public static final int Int=40; | ||
67 | public static final int Extern=18; | ||
68 | public static final int RULE_SL_COMMENT=78; | ||
69 | public static final int Prod=29; | ||
70 | public static final int Comma=61; | ||
71 | public static final int EqualsSign=68; | ||
72 | public static final int Empty=21; | ||
73 | public static final int HyphenMinus=62; | ||
74 | public static final int Maximize=8; | ||
75 | public static final int LessThanSignEqualsSign=49; | ||
76 | public static final int Solidus=64; | ||
77 | public static final int Colon=65; | ||
78 | public static final int RightCurlyBracket=75; | ||
79 | public static final int EOF=-1; | ||
80 | public static final int Asterisk=59; | ||
81 | public static final int FullStop=63; | ||
82 | public static final int RULE_WS=85; | ||
83 | public static final int Abstract=6; | ||
84 | public static final int Minimize=9; | ||
85 | public static final int GREATER=11; | ||
86 | public static final int LeftCurlyBracket=73; | ||
87 | public static final int Error=22; | ||
88 | public static final int Only=28; | ||
89 | public static final int RULE_ANY_OTHER=86; | ||
90 | public static final int Default=14; | ||
91 | public static final int ColonHyphenMinus=48; | ||
92 | public static final int CircumflexAccent=72; | ||
93 | public static final int DIV=34; | ||
94 | public static final int Semicolon=66; | ||
95 | public static final int Scope=24; | ||
96 | public static final int Else=26; | ||
97 | public static final int ExclamationMarkEqualsSign=45; | ||
98 | public static final int HyphenMinusGreaterThanSign=46; | ||
99 | |||
100 | // delegates | ||
101 | // delegators | ||
102 | |||
103 | public InternalSolverLanguageLexer() {;} | ||
104 | public InternalSolverLanguageLexer(CharStream input) { | ||
105 | this(input, new RecognizerSharedState()); | ||
106 | } | ||
107 | public InternalSolverLanguageLexer(CharStream input, RecognizerSharedState state) { | ||
108 | super(input,state); | ||
109 | |||
110 | } | ||
111 | public String getGrammarFileName() { return "InternalSolverLanguageLexer.g"; } | ||
112 | |||
113 | // $ANTLR start "GREATER_EQ" | ||
114 | public final void mGREATER_EQ() throws RecognitionException { | ||
115 | try { | ||
116 | int _type = GREATER_EQ; | ||
117 | int _channel = DEFAULT_TOKEN_CHANNEL; | ||
118 | // InternalSolverLanguageLexer.g:14:12: ( 'GREATER_EQ' ) | ||
119 | // InternalSolverLanguageLexer.g:14:14: 'GREATER_EQ' | ||
120 | { | ||
121 | match("GREATER_EQ"); | ||
122 | |||
123 | |||
124 | } | ||
125 | |||
126 | state.type = _type; | ||
127 | state.channel = _channel; | ||
128 | } | ||
129 | finally { | ||
130 | } | ||
131 | } | ||
132 | // $ANTLR end "GREATER_EQ" | ||
133 | |||
134 | // $ANTLR start "Functional" | ||
135 | public final void mFunctional() throws RecognitionException { | ||
136 | try { | ||
137 | int _type = Functional; | ||
138 | int _channel = DEFAULT_TOKEN_CHANNEL; | ||
139 | // InternalSolverLanguageLexer.g:16:12: ( 'functional' ) | ||
140 | // InternalSolverLanguageLexer.g:16:14: 'functional' | ||
141 | { | ||
142 | match("functional"); | ||
143 | |||
144 | |||
145 | } | ||
146 | |||
147 | state.type = _type; | ||
148 | state.channel = _channel; | ||
149 | } | ||
150 | finally { | ||
151 | } | ||
152 | } | ||
153 | // $ANTLR end "Functional" | ||
154 | |||
155 | // $ANTLR start "Abstract" | ||
156 | public final void mAbstract() throws RecognitionException { | ||
157 | try { | ||
158 | int _type = Abstract; | ||
159 | int _channel = DEFAULT_TOKEN_CHANNEL; | ||
160 | // InternalSolverLanguageLexer.g:18:10: ( 'abstract' ) | ||
161 | // InternalSolverLanguageLexer.g:18:12: 'abstract' | ||
162 | { | ||
163 | match("abstract"); | ||
164 | |||
165 | |||
166 | } | ||
167 | |||
168 | state.type = _type; | ||
169 | state.channel = _channel; | ||
170 | } | ||
171 | finally { | ||
172 | } | ||
173 | } | ||
174 | // $ANTLR end "Abstract" | ||
175 | |||
176 | // $ANTLR start "Contains" | ||
177 | public final void mContains() throws RecognitionException { | ||
178 | try { | ||
179 | int _type = Contains; | ||
180 | int _channel = DEFAULT_TOKEN_CHANNEL; | ||
181 | // InternalSolverLanguageLexer.g:20:10: ( 'contains' ) | ||
182 | // InternalSolverLanguageLexer.g:20:12: 'contains' | ||
183 | { | ||
184 | match("contains"); | ||
185 | |||
186 | |||
187 | } | ||
188 | |||
189 | state.type = _type; | ||
190 | state.channel = _channel; | ||
191 | } | ||
192 | finally { | ||
193 | } | ||
194 | } | ||
195 | // $ANTLR end "Contains" | ||
196 | |||
197 | // $ANTLR start "Maximize" | ||
198 | public final void mMaximize() throws RecognitionException { | ||
199 | try { | ||
200 | int _type = Maximize; | ||
201 | int _channel = DEFAULT_TOKEN_CHANNEL; | ||
202 | // InternalSolverLanguageLexer.g:22:10: ( 'maximize' ) | ||
203 | // InternalSolverLanguageLexer.g:22:12: 'maximize' | ||
204 | { | ||
205 | match("maximize"); | ||
206 | |||
207 | |||
208 | } | ||
209 | |||
210 | state.type = _type; | ||
211 | state.channel = _channel; | ||
212 | } | ||
213 | finally { | ||
214 | } | ||
215 | } | ||
216 | // $ANTLR end "Maximize" | ||
217 | |||
218 | // $ANTLR start "Minimize" | ||
219 | public final void mMinimize() throws RecognitionException { | ||
220 | try { | ||
221 | int _type = Minimize; | ||
222 | int _channel = DEFAULT_TOKEN_CHANNEL; | ||
223 | // InternalSolverLanguageLexer.g:24:10: ( 'minimize' ) | ||
224 | // InternalSolverLanguageLexer.g:24:12: 'minimize' | ||
225 | { | ||
226 | match("minimize"); | ||
227 | |||
228 | |||
229 | } | ||
230 | |||
231 | state.type = _type; | ||
232 | state.channel = _channel; | ||
233 | } | ||
234 | finally { | ||
235 | } | ||
236 | } | ||
237 | // $ANTLR end "Minimize" | ||
238 | |||
239 | // $ANTLR start "Opposite" | ||
240 | public final void mOpposite() throws RecognitionException { | ||
241 | try { | ||
242 | int _type = Opposite; | ||
243 | int _channel = DEFAULT_TOKEN_CHANNEL; | ||
244 | // InternalSolverLanguageLexer.g:26:10: ( 'opposite' ) | ||
245 | // InternalSolverLanguageLexer.g:26:12: 'opposite' | ||
246 | { | ||
247 | match("opposite"); | ||
248 | |||
249 | |||
250 | } | ||
251 | |||
252 | state.type = _type; | ||
253 | state.channel = _channel; | ||
254 | } | ||
255 | finally { | ||
256 | } | ||
257 | } | ||
258 | // $ANTLR end "Opposite" | ||
259 | |||
260 | // $ANTLR start "GREATER" | ||
261 | public final void mGREATER() throws RecognitionException { | ||
262 | try { | ||
263 | int _type = GREATER; | ||
264 | int _channel = DEFAULT_TOKEN_CHANNEL; | ||
265 | // InternalSolverLanguageLexer.g:28:9: ( 'GREATER' ) | ||
266 | // InternalSolverLanguageLexer.g:28:11: 'GREATER' | ||
267 | { | ||
268 | match("GREATER"); | ||
269 | |||
270 | |||
271 | } | ||
272 | |||
273 | state.type = _type; | ||
274 | state.channel = _channel; | ||
275 | } | ||
276 | finally { | ||
277 | } | ||
278 | } | ||
279 | // $ANTLR end "GREATER" | ||
280 | |||
281 | // $ANTLR start "LESS_EQ" | ||
282 | public final void mLESS_EQ() throws RecognitionException { | ||
283 | try { | ||
284 | int _type = LESS_EQ; | ||
285 | int _channel = DEFAULT_TOKEN_CHANNEL; | ||
286 | // InternalSolverLanguageLexer.g:30:9: ( 'LESS_EQ' ) | ||
287 | // InternalSolverLanguageLexer.g:30:11: 'LESS_EQ' | ||
288 | { | ||
289 | match("LESS_EQ"); | ||
290 | |||
291 | |||
292 | } | ||
293 | |||
294 | state.type = _type; | ||
295 | state.channel = _channel; | ||
296 | } | ||
297 | finally { | ||
298 | } | ||
299 | } | ||
300 | // $ANTLR end "LESS_EQ" | ||
301 | |||
302 | // $ANTLR start "Current" | ||
303 | public final void mCurrent() throws RecognitionException { | ||
304 | try { | ||
305 | int _type = Current; | ||
306 | int _channel = DEFAULT_TOKEN_CHANNEL; | ||
307 | // InternalSolverLanguageLexer.g:32:9: ( 'current' ) | ||
308 | // InternalSolverLanguageLexer.g:32:11: 'current' | ||
309 | { | ||
310 | match("current"); | ||
311 | |||
312 | |||
313 | } | ||
314 | |||
315 | state.type = _type; | ||
316 | state.channel = _channel; | ||
317 | } | ||
318 | finally { | ||
319 | } | ||
320 | } | ||
321 | // $ANTLR end "Current" | ||
322 | |||
323 | // $ANTLR start "Default" | ||
324 | public final void mDefault() throws RecognitionException { | ||
325 | try { | ||
326 | int _type = Default; | ||
327 | int _channel = DEFAULT_TOKEN_CHANNEL; | ||
328 | // InternalSolverLanguageLexer.g:34:9: ( 'default' ) | ||
329 | // InternalSolverLanguageLexer.g:34:11: 'default' | ||
330 | { | ||
331 | match("default"); | ||
332 | |||
333 | |||
334 | } | ||
335 | |||
336 | state.type = _type; | ||
337 | state.channel = _channel; | ||
338 | } | ||
339 | finally { | ||
340 | } | ||
341 | } | ||
342 | // $ANTLR end "Default" | ||
343 | |||
344 | // $ANTLR start "Extends" | ||
345 | public final void mExtends() throws RecognitionException { | ||
346 | try { | ||
347 | int _type = Extends; | ||
348 | int _channel = DEFAULT_TOKEN_CHANNEL; | ||
349 | // InternalSolverLanguageLexer.g:36:9: ( 'extends' ) | ||
350 | // InternalSolverLanguageLexer.g:36:11: 'extends' | ||
351 | { | ||
352 | match("extends"); | ||
353 | |||
354 | |||
355 | } | ||
356 | |||
357 | state.type = _type; | ||
358 | state.channel = _channel; | ||
359 | } | ||
360 | finally { | ||
361 | } | ||
362 | } | ||
363 | // $ANTLR end "Extends" | ||
364 | |||
365 | // $ANTLR start "Unknown" | ||
366 | public final void mUnknown() throws RecognitionException { | ||
367 | try { | ||
368 | int _type = Unknown; | ||
369 | int _channel = DEFAULT_TOKEN_CHANNEL; | ||
370 | // InternalSolverLanguageLexer.g:38:9: ( 'unknown' ) | ||
371 | // InternalSolverLanguageLexer.g:38:11: 'unknown' | ||
372 | { | ||
373 | match("unknown"); | ||
374 | |||
375 | |||
376 | } | ||
377 | |||
378 | state.type = _type; | ||
379 | state.channel = _channel; | ||
380 | } | ||
381 | finally { | ||
382 | } | ||
383 | } | ||
384 | // $ANTLR end "Unknown" | ||
385 | |||
386 | // $ANTLR start "NOT_EQ" | ||
387 | public final void mNOT_EQ() throws RecognitionException { | ||
388 | try { | ||
389 | int _type = NOT_EQ; | ||
390 | int _channel = DEFAULT_TOKEN_CHANNEL; | ||
391 | // InternalSolverLanguageLexer.g:40:8: ( 'NOT_EQ' ) | ||
392 | // InternalSolverLanguageLexer.g:40:10: 'NOT_EQ' | ||
393 | { | ||
394 | match("NOT_EQ"); | ||
395 | |||
396 | |||
397 | } | ||
398 | |||
399 | state.type = _type; | ||
400 | state.channel = _channel; | ||
401 | } | ||
402 | finally { | ||
403 | } | ||
404 | } | ||
405 | // $ANTLR end "NOT_EQ" | ||
406 | |||
407 | // $ANTLR start "Extern" | ||
408 | public final void mExtern() throws RecognitionException { | ||
409 | try { | ||
410 | int _type = Extern; | ||
411 | int _channel = DEFAULT_TOKEN_CHANNEL; | ||
412 | // InternalSolverLanguageLexer.g:42:8: ( 'extern' ) | ||
413 | // InternalSolverLanguageLexer.g:42:10: 'extern' | ||
414 | { | ||
415 | match("extern"); | ||
416 | |||
417 | |||
418 | } | ||
419 | |||
420 | state.type = _type; | ||
421 | state.channel = _channel; | ||
422 | } | ||
423 | finally { | ||
424 | } | ||
425 | } | ||
426 | // $ANTLR end "Extern" | ||
427 | |||
428 | // $ANTLR start "Class" | ||
429 | public final void mClass() throws RecognitionException { | ||
430 | try { | ||
431 | int _type = Class; | ||
432 | int _channel = DEFAULT_TOKEN_CHANNEL; | ||
433 | // InternalSolverLanguageLexer.g:44:7: ( 'class' ) | ||
434 | // InternalSolverLanguageLexer.g:44:9: 'class' | ||
435 | { | ||
436 | match("class"); | ||
437 | |||
438 | |||
439 | } | ||
440 | |||
441 | state.type = _type; | ||
442 | state.channel = _channel; | ||
443 | } | ||
444 | finally { | ||
445 | } | ||
446 | } | ||
447 | // $ANTLR end "Class" | ||
448 | |||
449 | // $ANTLR start "Count" | ||
450 | public final void mCount() throws RecognitionException { | ||
451 | try { | ||
452 | int _type = Count; | ||
453 | int _channel = DEFAULT_TOKEN_CHANNEL; | ||
454 | // InternalSolverLanguageLexer.g:46:7: ( 'count' ) | ||
455 | // InternalSolverLanguageLexer.g:46:9: 'count' | ||
456 | { | ||
457 | match("count"); | ||
458 | |||
459 | |||
460 | } | ||
461 | |||
462 | state.type = _type; | ||
463 | state.channel = _channel; | ||
464 | } | ||
465 | finally { | ||
466 | } | ||
467 | } | ||
468 | // $ANTLR end "Count" | ||
469 | |||
470 | // $ANTLR start "Empty" | ||
471 | public final void mEmpty() throws RecognitionException { | ||
472 | try { | ||
473 | int _type = Empty; | ||
474 | int _channel = DEFAULT_TOKEN_CHANNEL; | ||
475 | // InternalSolverLanguageLexer.g:48:7: ( 'empty' ) | ||
476 | // InternalSolverLanguageLexer.g:48:9: 'empty' | ||
477 | { | ||
478 | match("empty"); | ||
479 | |||
480 | |||
481 | } | ||
482 | |||
483 | state.type = _type; | ||
484 | state.channel = _channel; | ||
485 | } | ||
486 | finally { | ||
487 | } | ||
488 | } | ||
489 | // $ANTLR end "Empty" | ||
490 | |||
491 | // $ANTLR start "Error" | ||
492 | public final void mError() throws RecognitionException { | ||
493 | try { | ||
494 | int _type = Error; | ||
495 | int _channel = DEFAULT_TOKEN_CHANNEL; | ||
496 | // InternalSolverLanguageLexer.g:50:7: ( 'error' ) | ||
497 | // InternalSolverLanguageLexer.g:50:9: 'error' | ||
498 | { | ||
499 | match("error"); | ||
500 | |||
501 | |||
502 | } | ||
503 | |||
504 | state.type = _type; | ||
505 | state.channel = _channel; | ||
506 | } | ||
507 | finally { | ||
508 | } | ||
509 | } | ||
510 | // $ANTLR end "Error" | ||
511 | |||
512 | // $ANTLR start "False" | ||
513 | public final void mFalse() throws RecognitionException { | ||
514 | try { | ||
515 | int _type = False; | ||
516 | int _channel = DEFAULT_TOKEN_CHANNEL; | ||
517 | // InternalSolverLanguageLexer.g:52:7: ( 'false' ) | ||
518 | // InternalSolverLanguageLexer.g:52:9: 'false' | ||
519 | { | ||
520 | match("false"); | ||
521 | |||
522 | |||
523 | } | ||
524 | |||
525 | state.type = _type; | ||
526 | state.channel = _channel; | ||
527 | } | ||
528 | finally { | ||
529 | } | ||
530 | } | ||
531 | // $ANTLR end "False" | ||
532 | |||
533 | // $ANTLR start "Scope" | ||
534 | public final void mScope() throws RecognitionException { | ||
535 | try { | ||
536 | int _type = Scope; | ||
537 | int _channel = DEFAULT_TOKEN_CHANNEL; | ||
538 | // InternalSolverLanguageLexer.g:54:7: ( 'scope' ) | ||
539 | // InternalSolverLanguageLexer.g:54:9: 'scope' | ||
540 | { | ||
541 | match("scope"); | ||
542 | |||
543 | |||
544 | } | ||
545 | |||
546 | state.type = _type; | ||
547 | state.channel = _channel; | ||
548 | } | ||
549 | finally { | ||
550 | } | ||
551 | } | ||
552 | // $ANTLR end "Scope" | ||
553 | |||
554 | // $ANTLR start "LESS" | ||
555 | public final void mLESS() throws RecognitionException { | ||
556 | try { | ||
557 | int _type = LESS; | ||
558 | int _channel = DEFAULT_TOKEN_CHANNEL; | ||
559 | // InternalSolverLanguageLexer.g:56:6: ( 'LESS' ) | ||
560 | // InternalSolverLanguageLexer.g:56:8: 'LESS' | ||
561 | { | ||
562 | match("LESS"); | ||
563 | |||
564 | |||
565 | } | ||
566 | |||
567 | state.type = _type; | ||
568 | state.channel = _channel; | ||
569 | } | ||
570 | finally { | ||
571 | } | ||
572 | } | ||
573 | // $ANTLR end "LESS" | ||
574 | |||
575 | // $ANTLR start "Else" | ||
576 | public final void mElse() throws RecognitionException { | ||
577 | try { | ||
578 | int _type = Else; | ||
579 | int _channel = DEFAULT_TOKEN_CHANNEL; | ||
580 | // InternalSolverLanguageLexer.g:58:6: ( 'else' ) | ||
581 | // InternalSolverLanguageLexer.g:58:8: 'else' | ||
582 | { | ||
583 | match("else"); | ||
584 | |||
585 | |||
586 | } | ||
587 | |||
588 | state.type = _type; | ||
589 | state.channel = _channel; | ||
590 | } | ||
591 | finally { | ||
592 | } | ||
593 | } | ||
594 | // $ANTLR end "Else" | ||
595 | |||
596 | // $ANTLR start "Must" | ||
597 | public final void mMust() throws RecognitionException { | ||
598 | try { | ||
599 | int _type = Must; | ||
600 | int _channel = DEFAULT_TOKEN_CHANNEL; | ||
601 | // InternalSolverLanguageLexer.g:60:6: ( 'must' ) | ||
602 | // InternalSolverLanguageLexer.g:60:8: 'must' | ||
603 | { | ||
604 | match("must"); | ||
605 | |||
606 | |||
607 | } | ||
608 | |||
609 | state.type = _type; | ||
610 | state.channel = _channel; | ||
611 | } | ||
612 | finally { | ||
613 | } | ||
614 | } | ||
615 | // $ANTLR end "Must" | ||
616 | |||
617 | // $ANTLR start "Only" | ||
618 | public final void mOnly() throws RecognitionException { | ||
619 | try { | ||
620 | int _type = Only; | ||
621 | int _channel = DEFAULT_TOKEN_CHANNEL; | ||
622 | // InternalSolverLanguageLexer.g:62:6: ( 'only' ) | ||
623 | // InternalSolverLanguageLexer.g:62:8: 'only' | ||
624 | { | ||
625 | match("only"); | ||
626 | |||
627 | |||
628 | } | ||
629 | |||
630 | state.type = _type; | ||
631 | state.channel = _channel; | ||
632 | } | ||
633 | finally { | ||
634 | } | ||
635 | } | ||
636 | // $ANTLR end "Only" | ||
637 | |||
638 | // $ANTLR start "Prod" | ||
639 | public final void mProd() throws RecognitionException { | ||
640 | try { | ||
641 | int _type = Prod; | ||
642 | int _channel = DEFAULT_TOKEN_CHANNEL; | ||
643 | // InternalSolverLanguageLexer.g:64:6: ( 'prod' ) | ||
644 | // InternalSolverLanguageLexer.g:64:8: 'prod' | ||
645 | { | ||
646 | match("prod"); | ||
647 | |||
648 | |||
649 | } | ||
650 | |||
651 | state.type = _type; | ||
652 | state.channel = _channel; | ||
653 | } | ||
654 | finally { | ||
655 | } | ||
656 | } | ||
657 | // $ANTLR end "Prod" | ||
658 | |||
659 | // $ANTLR start "Real" | ||
660 | public final void mReal() throws RecognitionException { | ||
661 | try { | ||
662 | int _type = Real; | ||
663 | int _channel = DEFAULT_TOKEN_CHANNEL; | ||
664 | // InternalSolverLanguageLexer.g:66:6: ( 'real' ) | ||
665 | // InternalSolverLanguageLexer.g:66:8: 'real' | ||
666 | { | ||
667 | match("real"); | ||
668 | |||
669 | |||
670 | } | ||
671 | |||
672 | state.type = _type; | ||
673 | state.channel = _channel; | ||
674 | } | ||
675 | finally { | ||
676 | } | ||
677 | } | ||
678 | // $ANTLR end "Real" | ||
679 | |||
680 | // $ANTLR start "Then" | ||
681 | public final void mThen() throws RecognitionException { | ||
682 | try { | ||
683 | int _type = Then; | ||
684 | int _channel = DEFAULT_TOKEN_CHANNEL; | ||
685 | // InternalSolverLanguageLexer.g:68:6: ( 'then' ) | ||
686 | // InternalSolverLanguageLexer.g:68:8: 'then' | ||
687 | { | ||
688 | match("then"); | ||
689 | |||
690 | |||
691 | } | ||
692 | |||
693 | state.type = _type; | ||
694 | state.channel = _channel; | ||
695 | } | ||
696 | finally { | ||
697 | } | ||
698 | } | ||
699 | // $ANTLR end "Then" | ||
700 | |||
701 | // $ANTLR start "True" | ||
702 | public final void mTrue() throws RecognitionException { | ||
703 | try { | ||
704 | int _type = True; | ||
705 | int _channel = DEFAULT_TOKEN_CHANNEL; | ||
706 | // InternalSolverLanguageLexer.g:70:6: ( 'true' ) | ||
707 | // InternalSolverLanguageLexer.g:70:8: 'true' | ||
708 | { | ||
709 | match("true"); | ||
710 | |||
711 | |||
712 | } | ||
713 | |||
714 | state.type = _type; | ||
715 | state.channel = _channel; | ||
716 | } | ||
717 | finally { | ||
718 | } | ||
719 | } | ||
720 | // $ANTLR end "True" | ||
721 | |||
722 | // $ANTLR start "ADD" | ||
723 | public final void mADD() throws RecognitionException { | ||
724 | try { | ||
725 | int _type = ADD; | ||
726 | int _channel = DEFAULT_TOKEN_CHANNEL; | ||
727 | // InternalSolverLanguageLexer.g:72:5: ( 'ADD' ) | ||
728 | // InternalSolverLanguageLexer.g:72:7: 'ADD' | ||
729 | { | ||
730 | match("ADD"); | ||
731 | |||
732 | |||
733 | } | ||
734 | |||
735 | state.type = _type; | ||
736 | state.channel = _channel; | ||
737 | } | ||
738 | finally { | ||
739 | } | ||
740 | } | ||
741 | // $ANTLR end "ADD" | ||
742 | |||
743 | // $ANTLR start "DIV" | ||
744 | public final void mDIV() throws RecognitionException { | ||
745 | try { | ||
746 | int _type = DIV; | ||
747 | int _channel = DEFAULT_TOKEN_CHANNEL; | ||
748 | // InternalSolverLanguageLexer.g:74:5: ( 'DIV' ) | ||
749 | // InternalSolverLanguageLexer.g:74:7: 'DIV' | ||
750 | { | ||
751 | match("DIV"); | ||
752 | |||
753 | |||
754 | } | ||
755 | |||
756 | state.type = _type; | ||
757 | state.channel = _channel; | ||
758 | } | ||
759 | finally { | ||
760 | } | ||
761 | } | ||
762 | // $ANTLR end "DIV" | ||
763 | |||
764 | // $ANTLR start "MUL" | ||
765 | public final void mMUL() throws RecognitionException { | ||
766 | try { | ||
767 | int _type = MUL; | ||
768 | int _channel = DEFAULT_TOKEN_CHANNEL; | ||
769 | // InternalSolverLanguageLexer.g:76:5: ( 'MUL' ) | ||
770 | // InternalSolverLanguageLexer.g:76:7: 'MUL' | ||
771 | { | ||
772 | match("MUL"); | ||
773 | |||
774 | |||
775 | } | ||
776 | |||
777 | state.type = _type; | ||
778 | state.channel = _channel; | ||
779 | } | ||
780 | finally { | ||
781 | } | ||
782 | } | ||
783 | // $ANTLR end "MUL" | ||
784 | |||
785 | // $ANTLR start "POW" | ||
786 | public final void mPOW() throws RecognitionException { | ||
787 | try { | ||
788 | int _type = POW; | ||
789 | int _channel = DEFAULT_TOKEN_CHANNEL; | ||
790 | // InternalSolverLanguageLexer.g:78:5: ( 'POW' ) | ||
791 | // InternalSolverLanguageLexer.g:78:7: 'POW' | ||
792 | { | ||
793 | match("POW"); | ||
794 | |||
795 | |||
796 | } | ||
797 | |||
798 | state.type = _type; | ||
799 | state.channel = _channel; | ||
800 | } | ||
801 | finally { | ||
802 | } | ||
803 | } | ||
804 | // $ANTLR end "POW" | ||
805 | |||
806 | // $ANTLR start "SUB" | ||
807 | public final void mSUB() throws RecognitionException { | ||
808 | try { | ||
809 | int _type = SUB; | ||
810 | int _channel = DEFAULT_TOKEN_CHANNEL; | ||
811 | // InternalSolverLanguageLexer.g:80:5: ( 'SUB' ) | ||
812 | // InternalSolverLanguageLexer.g:80:7: 'SUB' | ||
813 | { | ||
814 | match("SUB"); | ||
815 | |||
816 | |||
817 | } | ||
818 | |||
819 | state.type = _type; | ||
820 | state.channel = _channel; | ||
821 | } | ||
822 | finally { | ||
823 | } | ||
824 | } | ||
825 | // $ANTLR end "SUB" | ||
826 | |||
827 | // $ANTLR start "Avg" | ||
828 | public final void mAvg() throws RecognitionException { | ||
829 | try { | ||
830 | int _type = Avg; | ||
831 | int _channel = DEFAULT_TOKEN_CHANNEL; | ||
832 | // InternalSolverLanguageLexer.g:82:5: ( 'avg' ) | ||
833 | // InternalSolverLanguageLexer.g:82:7: 'avg' | ||
834 | { | ||
835 | match("avg"); | ||
836 | |||
837 | |||
838 | } | ||
839 | |||
840 | state.type = _type; | ||
841 | state.channel = _channel; | ||
842 | } | ||
843 | finally { | ||
844 | } | ||
845 | } | ||
846 | // $ANTLR end "Avg" | ||
847 | |||
848 | // $ANTLR start "Inf" | ||
849 | public final void mInf() throws RecognitionException { | ||
850 | try { | ||
851 | int _type = Inf; | ||
852 | int _channel = DEFAULT_TOKEN_CHANNEL; | ||
853 | // InternalSolverLanguageLexer.g:84:5: ( 'inf' ) | ||
854 | // InternalSolverLanguageLexer.g:84:7: 'inf' | ||
855 | { | ||
856 | match("inf"); | ||
857 | |||
858 | |||
859 | } | ||
860 | |||
861 | state.type = _type; | ||
862 | state.channel = _channel; | ||
863 | } | ||
864 | finally { | ||
865 | } | ||
866 | } | ||
867 | // $ANTLR end "Inf" | ||
868 | |||
869 | // $ANTLR start "Int" | ||
870 | public final void mInt() throws RecognitionException { | ||
871 | try { | ||
872 | int _type = Int; | ||
873 | int _channel = DEFAULT_TOKEN_CHANNEL; | ||
874 | // InternalSolverLanguageLexer.g:86:5: ( 'int' ) | ||
875 | // InternalSolverLanguageLexer.g:86:7: 'int' | ||
876 | { | ||
877 | match("int"); | ||
878 | |||
879 | |||
880 | } | ||
881 | |||
882 | state.type = _type; | ||
883 | state.channel = _channel; | ||
884 | } | ||
885 | finally { | ||
886 | } | ||
887 | } | ||
888 | // $ANTLR end "Int" | ||
889 | |||
890 | // $ANTLR start "Max" | ||
891 | public final void mMax() throws RecognitionException { | ||
892 | try { | ||
893 | int _type = Max; | ||
894 | int _channel = DEFAULT_TOKEN_CHANNEL; | ||
895 | // InternalSolverLanguageLexer.g:88:5: ( 'max' ) | ||
896 | // InternalSolverLanguageLexer.g:88:7: 'max' | ||
897 | { | ||
898 | match("max"); | ||
899 | |||
900 | |||
901 | } | ||
902 | |||
903 | state.type = _type; | ||
904 | state.channel = _channel; | ||
905 | } | ||
906 | finally { | ||
907 | } | ||
908 | } | ||
909 | // $ANTLR end "Max" | ||
910 | |||
911 | // $ANTLR start "May" | ||
912 | public final void mMay() throws RecognitionException { | ||
913 | try { | ||
914 | int _type = May; | ||
915 | int _channel = DEFAULT_TOKEN_CHANNEL; | ||
916 | // InternalSolverLanguageLexer.g:90:5: ( 'may' ) | ||
917 | // InternalSolverLanguageLexer.g:90:7: 'may' | ||
918 | { | ||
919 | match("may"); | ||
920 | |||
921 | |||
922 | } | ||
923 | |||
924 | state.type = _type; | ||
925 | state.channel = _channel; | ||
926 | } | ||
927 | finally { | ||
928 | } | ||
929 | } | ||
930 | // $ANTLR end "May" | ||
931 | |||
932 | // $ANTLR start "Min" | ||
933 | public final void mMin() throws RecognitionException { | ||
934 | try { | ||
935 | int _type = Min; | ||
936 | int _channel = DEFAULT_TOKEN_CHANNEL; | ||
937 | // InternalSolverLanguageLexer.g:92:5: ( 'min' ) | ||
938 | // InternalSolverLanguageLexer.g:92:7: 'min' | ||
939 | { | ||
940 | match("min"); | ||
941 | |||
942 | |||
943 | } | ||
944 | |||
945 | state.type = _type; | ||
946 | state.channel = _channel; | ||
947 | } | ||
948 | finally { | ||
949 | } | ||
950 | } | ||
951 | // $ANTLR end "Min" | ||
952 | |||
953 | // $ANTLR start "Sum" | ||
954 | public final void mSum() throws RecognitionException { | ||
955 | try { | ||
956 | int _type = Sum; | ||
957 | int _channel = DEFAULT_TOKEN_CHANNEL; | ||
958 | // InternalSolverLanguageLexer.g:94:5: ( 'sum' ) | ||
959 | // InternalSolverLanguageLexer.g:94:7: 'sum' | ||
960 | { | ||
961 | match("sum"); | ||
962 | |||
963 | |||
964 | } | ||
965 | |||
966 | state.type = _type; | ||
967 | state.channel = _channel; | ||
968 | } | ||
969 | finally { | ||
970 | } | ||
971 | } | ||
972 | // $ANTLR end "Sum" | ||
973 | |||
974 | // $ANTLR start "ExclamationMarkEqualsSign" | ||
975 | public final void mExclamationMarkEqualsSign() throws RecognitionException { | ||
976 | try { | ||
977 | int _type = ExclamationMarkEqualsSign; | ||
978 | int _channel = DEFAULT_TOKEN_CHANNEL; | ||
979 | // InternalSolverLanguageLexer.g:96:27: ( '!=' ) | ||
980 | // InternalSolverLanguageLexer.g:96:29: '!=' | ||
981 | { | ||
982 | match("!="); | ||
983 | |||
984 | |||
985 | } | ||
986 | |||
987 | state.type = _type; | ||
988 | state.channel = _channel; | ||
989 | } | ||
990 | finally { | ||
991 | } | ||
992 | } | ||
993 | // $ANTLR end "ExclamationMarkEqualsSign" | ||
994 | |||
995 | // $ANTLR start "HyphenMinusGreaterThanSign" | ||
996 | public final void mHyphenMinusGreaterThanSign() throws RecognitionException { | ||
997 | try { | ||
998 | int _type = HyphenMinusGreaterThanSign; | ||
999 | int _channel = DEFAULT_TOKEN_CHANNEL; | ||
1000 | // InternalSolverLanguageLexer.g:98:28: ( '->' ) | ||
1001 | // InternalSolverLanguageLexer.g:98:30: '->' | ||
1002 | { | ||
1003 | match("->"); | ||
1004 | |||
1005 | |||
1006 | } | ||
1007 | |||
1008 | state.type = _type; | ||
1009 | state.channel = _channel; | ||
1010 | } | ||
1011 | finally { | ||
1012 | } | ||
1013 | } | ||
1014 | // $ANTLR end "HyphenMinusGreaterThanSign" | ||
1015 | |||
1016 | // $ANTLR start "FullStopFullStop" | ||
1017 | public final void mFullStopFullStop() throws RecognitionException { | ||
1018 | try { | ||
1019 | int _type = FullStopFullStop; | ||
1020 | int _channel = DEFAULT_TOKEN_CHANNEL; | ||
1021 | // InternalSolverLanguageLexer.g:100:18: ( '..' ) | ||
1022 | // InternalSolverLanguageLexer.g:100:20: '..' | ||
1023 | { | ||
1024 | match(".."); | ||
1025 | |||
1026 | |||
1027 | } | ||
1028 | |||
1029 | state.type = _type; | ||
1030 | state.channel = _channel; | ||
1031 | } | ||
1032 | finally { | ||
1033 | } | ||
1034 | } | ||
1035 | // $ANTLR end "FullStopFullStop" | ||
1036 | |||
1037 | // $ANTLR start "ColonHyphenMinus" | ||
1038 | public final void mColonHyphenMinus() throws RecognitionException { | ||
1039 | try { | ||
1040 | int _type = ColonHyphenMinus; | ||
1041 | int _channel = DEFAULT_TOKEN_CHANNEL; | ||
1042 | // InternalSolverLanguageLexer.g:102:18: ( ':-' ) | ||
1043 | // InternalSolverLanguageLexer.g:102:20: ':-' | ||
1044 | { | ||
1045 | match(":-"); | ||
1046 | |||
1047 | |||
1048 | } | ||
1049 | |||
1050 | state.type = _type; | ||
1051 | state.channel = _channel; | ||
1052 | } | ||
1053 | finally { | ||
1054 | } | ||
1055 | } | ||
1056 | // $ANTLR end "ColonHyphenMinus" | ||
1057 | |||
1058 | // $ANTLR start "LessThanSignEqualsSign" | ||
1059 | public final void mLessThanSignEqualsSign() throws RecognitionException { | ||
1060 | try { | ||
1061 | int _type = LessThanSignEqualsSign; | ||
1062 | int _channel = DEFAULT_TOKEN_CHANNEL; | ||
1063 | // InternalSolverLanguageLexer.g:104:24: ( '<=' ) | ||
1064 | // InternalSolverLanguageLexer.g:104:26: '<=' | ||
1065 | { | ||
1066 | match("<="); | ||
1067 | |||
1068 | |||
1069 | } | ||
1070 | |||
1071 | state.type = _type; | ||
1072 | state.channel = _channel; | ||
1073 | } | ||
1074 | finally { | ||
1075 | } | ||
1076 | } | ||
1077 | // $ANTLR end "LessThanSignEqualsSign" | ||
1078 | |||
1079 | // $ANTLR start "EqualsSignEqualsSign" | ||
1080 | public final void mEqualsSignEqualsSign() throws RecognitionException { | ||
1081 | try { | ||
1082 | int _type = EqualsSignEqualsSign; | ||
1083 | int _channel = DEFAULT_TOKEN_CHANNEL; | ||
1084 | // InternalSolverLanguageLexer.g:106:22: ( '==' ) | ||
1085 | // InternalSolverLanguageLexer.g:106:24: '==' | ||
1086 | { | ||
1087 | match("=="); | ||
1088 | |||
1089 | |||
1090 | } | ||
1091 | |||
1092 | state.type = _type; | ||
1093 | state.channel = _channel; | ||
1094 | } | ||
1095 | finally { | ||
1096 | } | ||
1097 | } | ||
1098 | // $ANTLR end "EqualsSignEqualsSign" | ||
1099 | |||
1100 | // $ANTLR start "GreaterThanSignEqualsSign" | ||
1101 | public final void mGreaterThanSignEqualsSign() throws RecognitionException { | ||
1102 | try { | ||
1103 | int _type = GreaterThanSignEqualsSign; | ||
1104 | int _channel = DEFAULT_TOKEN_CHANNEL; | ||
1105 | // InternalSolverLanguageLexer.g:108:27: ( '>=' ) | ||
1106 | // InternalSolverLanguageLexer.g:108:29: '>=' | ||
1107 | { | ||
1108 | match(">="); | ||
1109 | |||
1110 | |||
1111 | } | ||
1112 | |||
1113 | state.type = _type; | ||
1114 | state.channel = _channel; | ||
1115 | } | ||
1116 | finally { | ||
1117 | } | ||
1118 | } | ||
1119 | // $ANTLR end "GreaterThanSignEqualsSign" | ||
1120 | |||
1121 | // $ANTLR start "EQ" | ||
1122 | public final void mEQ() throws RecognitionException { | ||
1123 | try { | ||
1124 | int _type = EQ; | ||
1125 | int _channel = DEFAULT_TOKEN_CHANNEL; | ||
1126 | // InternalSolverLanguageLexer.g:110:4: ( 'EQ' ) | ||
1127 | // InternalSolverLanguageLexer.g:110:6: 'EQ' | ||
1128 | { | ||
1129 | match("EQ"); | ||
1130 | |||
1131 | |||
1132 | } | ||
1133 | |||
1134 | state.type = _type; | ||
1135 | state.channel = _channel; | ||
1136 | } | ||
1137 | finally { | ||
1138 | } | ||
1139 | } | ||
1140 | // $ANTLR end "EQ" | ||
1141 | |||
1142 | // $ANTLR start "IN" | ||
1143 | public final void mIN() throws RecognitionException { | ||
1144 | try { | ||
1145 | int _type = IN; | ||
1146 | int _channel = DEFAULT_TOKEN_CHANNEL; | ||
1147 | // InternalSolverLanguageLexer.g:112:4: ( 'IN' ) | ||
1148 | // InternalSolverLanguageLexer.g:112:6: 'IN' | ||
1149 | { | ||
1150 | match("IN"); | ||
1151 | |||
1152 | |||
1153 | } | ||
1154 | |||
1155 | state.type = _type; | ||
1156 | state.channel = _channel; | ||
1157 | } | ||
1158 | finally { | ||
1159 | } | ||
1160 | } | ||
1161 | // $ANTLR end "IN" | ||
1162 | |||
1163 | // $ANTLR start "If" | ||
1164 | public final void mIf() throws RecognitionException { | ||
1165 | try { | ||
1166 | int _type = If; | ||
1167 | int _channel = DEFAULT_TOKEN_CHANNEL; | ||
1168 | // InternalSolverLanguageLexer.g:114:4: ( 'if' ) | ||
1169 | // InternalSolverLanguageLexer.g:114:6: 'if' | ||
1170 | { | ||
1171 | match("if"); | ||
1172 | |||
1173 | |||
1174 | } | ||
1175 | |||
1176 | state.type = _type; | ||
1177 | state.channel = _channel; | ||
1178 | } | ||
1179 | finally { | ||
1180 | } | ||
1181 | } | ||
1182 | // $ANTLR end "If" | ||
1183 | |||
1184 | // $ANTLR start "In" | ||
1185 | public final void mIn() throws RecognitionException { | ||
1186 | try { | ||
1187 | int _type = In; | ||
1188 | int _channel = DEFAULT_TOKEN_CHANNEL; | ||
1189 | // InternalSolverLanguageLexer.g:116:4: ( 'in' ) | ||
1190 | // InternalSolverLanguageLexer.g:116:6: 'in' | ||
1191 | { | ||
1192 | match("in"); | ||
1193 | |||
1194 | |||
1195 | } | ||
1196 | |||
1197 | state.type = _type; | ||
1198 | state.channel = _channel; | ||
1199 | } | ||
1200 | finally { | ||
1201 | } | ||
1202 | } | ||
1203 | // $ANTLR end "In" | ||
1204 | |||
1205 | // $ANTLR start "ExclamationMark" | ||
1206 | public final void mExclamationMark() throws RecognitionException { | ||
1207 | try { | ||
1208 | int _type = ExclamationMark; | ||
1209 | int _channel = DEFAULT_TOKEN_CHANNEL; | ||
1210 | // InternalSolverLanguageLexer.g:118:17: ( '!' ) | ||
1211 | // InternalSolverLanguageLexer.g:118:19: '!' | ||
1212 | { | ||
1213 | match('!'); | ||
1214 | |||
1215 | } | ||
1216 | |||
1217 | state.type = _type; | ||
1218 | state.channel = _channel; | ||
1219 | } | ||
1220 | finally { | ||
1221 | } | ||
1222 | } | ||
1223 | // $ANTLR end "ExclamationMark" | ||
1224 | |||
1225 | // $ANTLR start "LeftParenthesis" | ||
1226 | public final void mLeftParenthesis() throws RecognitionException { | ||
1227 | try { | ||
1228 | int _type = LeftParenthesis; | ||
1229 | int _channel = DEFAULT_TOKEN_CHANNEL; | ||
1230 | // InternalSolverLanguageLexer.g:120:17: ( '(' ) | ||
1231 | // InternalSolverLanguageLexer.g:120:19: '(' | ||
1232 | { | ||
1233 | match('('); | ||
1234 | |||
1235 | } | ||
1236 | |||
1237 | state.type = _type; | ||
1238 | state.channel = _channel; | ||
1239 | } | ||
1240 | finally { | ||
1241 | } | ||
1242 | } | ||
1243 | // $ANTLR end "LeftParenthesis" | ||
1244 | |||
1245 | // $ANTLR start "RightParenthesis" | ||
1246 | public final void mRightParenthesis() throws RecognitionException { | ||
1247 | try { | ||
1248 | int _type = RightParenthesis; | ||
1249 | int _channel = DEFAULT_TOKEN_CHANNEL; | ||
1250 | // InternalSolverLanguageLexer.g:122:18: ( ')' ) | ||
1251 | // InternalSolverLanguageLexer.g:122:20: ')' | ||
1252 | { | ||
1253 | match(')'); | ||
1254 | |||
1255 | } | ||
1256 | |||
1257 | state.type = _type; | ||
1258 | state.channel = _channel; | ||
1259 | } | ||
1260 | finally { | ||
1261 | } | ||
1262 | } | ||
1263 | // $ANTLR end "RightParenthesis" | ||
1264 | |||
1265 | // $ANTLR start "Asterisk" | ||
1266 | public final void mAsterisk() throws RecognitionException { | ||
1267 | try { | ||
1268 | int _type = Asterisk; | ||
1269 | int _channel = DEFAULT_TOKEN_CHANNEL; | ||
1270 | // InternalSolverLanguageLexer.g:124:10: ( '*' ) | ||
1271 | // InternalSolverLanguageLexer.g:124:12: '*' | ||
1272 | { | ||
1273 | match('*'); | ||
1274 | |||
1275 | } | ||
1276 | |||
1277 | state.type = _type; | ||
1278 | state.channel = _channel; | ||
1279 | } | ||
1280 | finally { | ||
1281 | } | ||
1282 | } | ||
1283 | // $ANTLR end "Asterisk" | ||
1284 | |||
1285 | // $ANTLR start "PlusSign" | ||
1286 | public final void mPlusSign() throws RecognitionException { | ||
1287 | try { | ||
1288 | int _type = PlusSign; | ||
1289 | int _channel = DEFAULT_TOKEN_CHANNEL; | ||
1290 | // InternalSolverLanguageLexer.g:126:10: ( '+' ) | ||
1291 | // InternalSolverLanguageLexer.g:126:12: '+' | ||
1292 | { | ||
1293 | match('+'); | ||
1294 | |||
1295 | } | ||
1296 | |||
1297 | state.type = _type; | ||
1298 | state.channel = _channel; | ||
1299 | } | ||
1300 | finally { | ||
1301 | } | ||
1302 | } | ||
1303 | // $ANTLR end "PlusSign" | ||
1304 | |||
1305 | // $ANTLR start "Comma" | ||
1306 | public final void mComma() throws RecognitionException { | ||
1307 | try { | ||
1308 | int _type = Comma; | ||
1309 | int _channel = DEFAULT_TOKEN_CHANNEL; | ||
1310 | // InternalSolverLanguageLexer.g:128:7: ( ',' ) | ||
1311 | // InternalSolverLanguageLexer.g:128:9: ',' | ||
1312 | { | ||
1313 | match(','); | ||
1314 | |||
1315 | } | ||
1316 | |||
1317 | state.type = _type; | ||
1318 | state.channel = _channel; | ||
1319 | } | ||
1320 | finally { | ||
1321 | } | ||
1322 | } | ||
1323 | // $ANTLR end "Comma" | ||
1324 | |||
1325 | // $ANTLR start "HyphenMinus" | ||
1326 | public final void mHyphenMinus() throws RecognitionException { | ||
1327 | try { | ||
1328 | int _type = HyphenMinus; | ||
1329 | int _channel = DEFAULT_TOKEN_CHANNEL; | ||
1330 | // InternalSolverLanguageLexer.g:130:13: ( '-' ) | ||
1331 | // InternalSolverLanguageLexer.g:130:15: '-' | ||
1332 | { | ||
1333 | match('-'); | ||
1334 | |||
1335 | } | ||
1336 | |||
1337 | state.type = _type; | ||
1338 | state.channel = _channel; | ||
1339 | } | ||
1340 | finally { | ||
1341 | } | ||
1342 | } | ||
1343 | // $ANTLR end "HyphenMinus" | ||
1344 | |||
1345 | // $ANTLR start "FullStop" | ||
1346 | public final void mFullStop() throws RecognitionException { | ||
1347 | try { | ||
1348 | int _type = FullStop; | ||
1349 | int _channel = DEFAULT_TOKEN_CHANNEL; | ||
1350 | // InternalSolverLanguageLexer.g:132:10: ( '.' ) | ||
1351 | // InternalSolverLanguageLexer.g:132:12: '.' | ||
1352 | { | ||
1353 | match('.'); | ||
1354 | |||
1355 | } | ||
1356 | |||
1357 | state.type = _type; | ||
1358 | state.channel = _channel; | ||
1359 | } | ||
1360 | finally { | ||
1361 | } | ||
1362 | } | ||
1363 | // $ANTLR end "FullStop" | ||
1364 | |||
1365 | // $ANTLR start "Solidus" | ||
1366 | public final void mSolidus() throws RecognitionException { | ||
1367 | try { | ||
1368 | int _type = Solidus; | ||
1369 | int _channel = DEFAULT_TOKEN_CHANNEL; | ||
1370 | // InternalSolverLanguageLexer.g:134:9: ( '/' ) | ||
1371 | // InternalSolverLanguageLexer.g:134:11: '/' | ||
1372 | { | ||
1373 | match('/'); | ||
1374 | |||
1375 | } | ||
1376 | |||
1377 | state.type = _type; | ||
1378 | state.channel = _channel; | ||
1379 | } | ||
1380 | finally { | ||
1381 | } | ||
1382 | } | ||
1383 | // $ANTLR end "Solidus" | ||
1384 | |||
1385 | // $ANTLR start "Colon" | ||
1386 | public final void mColon() throws RecognitionException { | ||
1387 | try { | ||
1388 | int _type = Colon; | ||
1389 | int _channel = DEFAULT_TOKEN_CHANNEL; | ||
1390 | // InternalSolverLanguageLexer.g:136:7: ( ':' ) | ||
1391 | // InternalSolverLanguageLexer.g:136:9: ':' | ||
1392 | { | ||
1393 | match(':'); | ||
1394 | |||
1395 | } | ||
1396 | |||
1397 | state.type = _type; | ||
1398 | state.channel = _channel; | ||
1399 | } | ||
1400 | finally { | ||
1401 | } | ||
1402 | } | ||
1403 | // $ANTLR end "Colon" | ||
1404 | |||
1405 | // $ANTLR start "Semicolon" | ||
1406 | public final void mSemicolon() throws RecognitionException { | ||
1407 | try { | ||
1408 | int _type = Semicolon; | ||
1409 | int _channel = DEFAULT_TOKEN_CHANNEL; | ||
1410 | // InternalSolverLanguageLexer.g:138:11: ( ';' ) | ||
1411 | // InternalSolverLanguageLexer.g:138:13: ';' | ||
1412 | { | ||
1413 | match(';'); | ||
1414 | |||
1415 | } | ||
1416 | |||
1417 | state.type = _type; | ||
1418 | state.channel = _channel; | ||
1419 | } | ||
1420 | finally { | ||
1421 | } | ||
1422 | } | ||
1423 | // $ANTLR end "Semicolon" | ||
1424 | |||
1425 | // $ANTLR start "LessThanSign" | ||
1426 | public final void mLessThanSign() throws RecognitionException { | ||
1427 | try { | ||
1428 | int _type = LessThanSign; | ||
1429 | int _channel = DEFAULT_TOKEN_CHANNEL; | ||
1430 | // InternalSolverLanguageLexer.g:140:14: ( '<' ) | ||
1431 | // InternalSolverLanguageLexer.g:140:16: '<' | ||
1432 | { | ||
1433 | match('<'); | ||
1434 | |||
1435 | } | ||
1436 | |||
1437 | state.type = _type; | ||
1438 | state.channel = _channel; | ||
1439 | } | ||
1440 | finally { | ||
1441 | } | ||
1442 | } | ||
1443 | // $ANTLR end "LessThanSign" | ||
1444 | |||
1445 | // $ANTLR start "EqualsSign" | ||
1446 | public final void mEqualsSign() throws RecognitionException { | ||
1447 | try { | ||
1448 | int _type = EqualsSign; | ||
1449 | int _channel = DEFAULT_TOKEN_CHANNEL; | ||
1450 | // InternalSolverLanguageLexer.g:142:12: ( '=' ) | ||
1451 | // InternalSolverLanguageLexer.g:142:14: '=' | ||
1452 | { | ||
1453 | match('='); | ||
1454 | |||
1455 | } | ||
1456 | |||
1457 | state.type = _type; | ||
1458 | state.channel = _channel; | ||
1459 | } | ||
1460 | finally { | ||
1461 | } | ||
1462 | } | ||
1463 | // $ANTLR end "EqualsSign" | ||
1464 | |||
1465 | // $ANTLR start "GreaterThanSign" | ||
1466 | public final void mGreaterThanSign() throws RecognitionException { | ||
1467 | try { | ||
1468 | int _type = GreaterThanSign; | ||
1469 | int _channel = DEFAULT_TOKEN_CHANNEL; | ||
1470 | // InternalSolverLanguageLexer.g:144:17: ( '>' ) | ||
1471 | // InternalSolverLanguageLexer.g:144:19: '>' | ||
1472 | { | ||
1473 | match('>'); | ||
1474 | |||
1475 | } | ||
1476 | |||
1477 | state.type = _type; | ||
1478 | state.channel = _channel; | ||
1479 | } | ||
1480 | finally { | ||
1481 | } | ||
1482 | } | ||
1483 | // $ANTLR end "GreaterThanSign" | ||
1484 | |||
1485 | // $ANTLR start "LeftSquareBracket" | ||
1486 | public final void mLeftSquareBracket() throws RecognitionException { | ||
1487 | try { | ||
1488 | int _type = LeftSquareBracket; | ||
1489 | int _channel = DEFAULT_TOKEN_CHANNEL; | ||
1490 | // InternalSolverLanguageLexer.g:146:19: ( '[' ) | ||
1491 | // InternalSolverLanguageLexer.g:146:21: '[' | ||
1492 | { | ||
1493 | match('['); | ||
1494 | |||
1495 | } | ||
1496 | |||
1497 | state.type = _type; | ||
1498 | state.channel = _channel; | ||
1499 | } | ||
1500 | finally { | ||
1501 | } | ||
1502 | } | ||
1503 | // $ANTLR end "LeftSquareBracket" | ||
1504 | |||
1505 | // $ANTLR start "RightSquareBracket" | ||
1506 | public final void mRightSquareBracket() throws RecognitionException { | ||
1507 | try { | ||
1508 | int _type = RightSquareBracket; | ||
1509 | int _channel = DEFAULT_TOKEN_CHANNEL; | ||
1510 | // InternalSolverLanguageLexer.g:148:20: ( ']' ) | ||
1511 | // InternalSolverLanguageLexer.g:148:22: ']' | ||
1512 | { | ||
1513 | match(']'); | ||
1514 | |||
1515 | } | ||
1516 | |||
1517 | state.type = _type; | ||
1518 | state.channel = _channel; | ||
1519 | } | ||
1520 | finally { | ||
1521 | } | ||
1522 | } | ||
1523 | // $ANTLR end "RightSquareBracket" | ||
1524 | |||
1525 | // $ANTLR start "CircumflexAccent" | ||
1526 | public final void mCircumflexAccent() throws RecognitionException { | ||
1527 | try { | ||
1528 | int _type = CircumflexAccent; | ||
1529 | int _channel = DEFAULT_TOKEN_CHANNEL; | ||
1530 | // InternalSolverLanguageLexer.g:150:18: ( '^' ) | ||
1531 | // InternalSolverLanguageLexer.g:150:20: '^' | ||
1532 | { | ||
1533 | match('^'); | ||
1534 | |||
1535 | } | ||
1536 | |||
1537 | state.type = _type; | ||
1538 | state.channel = _channel; | ||
1539 | } | ||
1540 | finally { | ||
1541 | } | ||
1542 | } | ||
1543 | // $ANTLR end "CircumflexAccent" | ||
1544 | |||
1545 | // $ANTLR start "LeftCurlyBracket" | ||
1546 | public final void mLeftCurlyBracket() throws RecognitionException { | ||
1547 | try { | ||
1548 | int _type = LeftCurlyBracket; | ||
1549 | int _channel = DEFAULT_TOKEN_CHANNEL; | ||
1550 | // InternalSolverLanguageLexer.g:152:18: ( '{' ) | ||
1551 | // InternalSolverLanguageLexer.g:152:20: '{' | ||
1552 | { | ||
1553 | match('{'); | ||
1554 | |||
1555 | } | ||
1556 | |||
1557 | state.type = _type; | ||
1558 | state.channel = _channel; | ||
1559 | } | ||
1560 | finally { | ||
1561 | } | ||
1562 | } | ||
1563 | // $ANTLR end "LeftCurlyBracket" | ||
1564 | |||
1565 | // $ANTLR start "VerticalLine" | ||
1566 | public final void mVerticalLine() throws RecognitionException { | ||
1567 | try { | ||
1568 | int _type = VerticalLine; | ||
1569 | int _channel = DEFAULT_TOKEN_CHANNEL; | ||
1570 | // InternalSolverLanguageLexer.g:154:14: ( '|' ) | ||
1571 | // InternalSolverLanguageLexer.g:154:16: '|' | ||
1572 | { | ||
1573 | match('|'); | ||
1574 | |||
1575 | } | ||
1576 | |||
1577 | state.type = _type; | ||
1578 | state.channel = _channel; | ||
1579 | } | ||
1580 | finally { | ||
1581 | } | ||
1582 | } | ||
1583 | // $ANTLR end "VerticalLine" | ||
1584 | |||
1585 | // $ANTLR start "RightCurlyBracket" | ||
1586 | public final void mRightCurlyBracket() throws RecognitionException { | ||
1587 | try { | ||
1588 | int _type = RightCurlyBracket; | ||
1589 | int _channel = DEFAULT_TOKEN_CHANNEL; | ||
1590 | // InternalSolverLanguageLexer.g:156:19: ( '}' ) | ||
1591 | // InternalSolverLanguageLexer.g:156:21: '}' | ||
1592 | { | ||
1593 | match('}'); | ||
1594 | |||
1595 | } | ||
1596 | |||
1597 | state.type = _type; | ||
1598 | state.channel = _channel; | ||
1599 | } | ||
1600 | finally { | ||
1601 | } | ||
1602 | } | ||
1603 | // $ANTLR end "RightCurlyBracket" | ||
1604 | |||
1605 | // $ANTLR start "RULE_STRING" | ||
1606 | public final void mRULE_STRING() throws RecognitionException { | ||
1607 | try { | ||
1608 | int _type = RULE_STRING; | ||
1609 | int _channel = DEFAULT_TOKEN_CHANNEL; | ||
1610 | // InternalSolverLanguageLexer.g:158:13: ( '\"' ( '\\\\' . | ~ ( ( '\\\\' | '\"' ) ) )* '\"' ) | ||
1611 | // InternalSolverLanguageLexer.g:158:15: '\"' ( '\\\\' . | ~ ( ( '\\\\' | '\"' ) ) )* '\"' | ||
1612 | { | ||
1613 | match('\"'); | ||
1614 | // InternalSolverLanguageLexer.g:158:19: ( '\\\\' . | ~ ( ( '\\\\' | '\"' ) ) )* | ||
1615 | loop1: | ||
1616 | do { | ||
1617 | int alt1=3; | ||
1618 | int LA1_0 = input.LA(1); | ||
1619 | |||
1620 | if ( (LA1_0=='\\') ) { | ||
1621 | alt1=1; | ||
1622 | } | ||
1623 | else if ( ((LA1_0>='\u0000' && LA1_0<='!')||(LA1_0>='#' && LA1_0<='[')||(LA1_0>=']' && LA1_0<='\uFFFF')) ) { | ||
1624 | alt1=2; | ||
1625 | } | ||
1626 | |||
1627 | |||
1628 | switch (alt1) { | ||
1629 | case 1 : | ||
1630 | // InternalSolverLanguageLexer.g:158:20: '\\\\' . | ||
1631 | { | ||
1632 | match('\\'); | ||
1633 | matchAny(); | ||
1634 | |||
1635 | } | ||
1636 | break; | ||
1637 | case 2 : | ||
1638 | // InternalSolverLanguageLexer.g:158:27: ~ ( ( '\\\\' | '\"' ) ) | ||
1639 | { | ||
1640 | if ( (input.LA(1)>='\u0000' && input.LA(1)<='!')||(input.LA(1)>='#' && input.LA(1)<='[')||(input.LA(1)>=']' && input.LA(1)<='\uFFFF') ) { | ||
1641 | input.consume(); | ||
1642 | |||
1643 | } | ||
1644 | else { | ||
1645 | MismatchedSetException mse = new MismatchedSetException(null,input); | ||
1646 | recover(mse); | ||
1647 | throw mse;} | ||
1648 | |||
1649 | |||
1650 | } | ||
1651 | break; | ||
1652 | |||
1653 | default : | ||
1654 | break loop1; | ||
1655 | } | ||
1656 | } while (true); | ||
1657 | |||
1658 | match('\"'); | ||
1659 | |||
1660 | } | ||
1661 | |||
1662 | state.type = _type; | ||
1663 | state.channel = _channel; | ||
1664 | } | ||
1665 | finally { | ||
1666 | } | ||
1667 | } | ||
1668 | // $ANTLR end "RULE_STRING" | ||
1669 | |||
1670 | // $ANTLR start "RULE_QUOTED_ID" | ||
1671 | public final void mRULE_QUOTED_ID() throws RecognitionException { | ||
1672 | try { | ||
1673 | int _type = RULE_QUOTED_ID; | ||
1674 | int _channel = DEFAULT_TOKEN_CHANNEL; | ||
1675 | // InternalSolverLanguageLexer.g:160:16: ( '\\'' ( '\\\\' . | ~ ( ( '\\\\' | '\\'' ) ) )* '\\'' ) | ||
1676 | // InternalSolverLanguageLexer.g:160:18: '\\'' ( '\\\\' . | ~ ( ( '\\\\' | '\\'' ) ) )* '\\'' | ||
1677 | { | ||
1678 | match('\''); | ||
1679 | // InternalSolverLanguageLexer.g:160:23: ( '\\\\' . | ~ ( ( '\\\\' | '\\'' ) ) )* | ||
1680 | loop2: | ||
1681 | do { | ||
1682 | int alt2=3; | ||
1683 | int LA2_0 = input.LA(1); | ||
1684 | |||
1685 | if ( (LA2_0=='\\') ) { | ||
1686 | alt2=1; | ||
1687 | } | ||
1688 | else if ( ((LA2_0>='\u0000' && LA2_0<='&')||(LA2_0>='(' && LA2_0<='[')||(LA2_0>=']' && LA2_0<='\uFFFF')) ) { | ||
1689 | alt2=2; | ||
1690 | } | ||
1691 | |||
1692 | |||
1693 | switch (alt2) { | ||
1694 | case 1 : | ||
1695 | // InternalSolverLanguageLexer.g:160:24: '\\\\' . | ||
1696 | { | ||
1697 | match('\\'); | ||
1698 | matchAny(); | ||
1699 | |||
1700 | } | ||
1701 | break; | ||
1702 | case 2 : | ||
1703 | // InternalSolverLanguageLexer.g:160:31: ~ ( ( '\\\\' | '\\'' ) ) | ||
1704 | { | ||
1705 | if ( (input.LA(1)>='\u0000' && input.LA(1)<='&')||(input.LA(1)>='(' && input.LA(1)<='[')||(input.LA(1)>=']' && input.LA(1)<='\uFFFF') ) { | ||
1706 | input.consume(); | ||
1707 | |||
1708 | } | ||
1709 | else { | ||
1710 | MismatchedSetException mse = new MismatchedSetException(null,input); | ||
1711 | recover(mse); | ||
1712 | throw mse;} | ||
1713 | |||
1714 | |||
1715 | } | ||
1716 | break; | ||
1717 | |||
1718 | default : | ||
1719 | break loop2; | ||
1720 | } | ||
1721 | } while (true); | ||
1722 | |||
1723 | match('\''); | ||
1724 | |||
1725 | } | ||
1726 | |||
1727 | state.type = _type; | ||
1728 | state.channel = _channel; | ||
1729 | } | ||
1730 | finally { | ||
1731 | } | ||
1732 | } | ||
1733 | // $ANTLR end "RULE_QUOTED_ID" | ||
1734 | |||
1735 | // $ANTLR start "RULE_SL_COMMENT" | ||
1736 | public final void mRULE_SL_COMMENT() throws RecognitionException { | ||
1737 | try { | ||
1738 | int _type = RULE_SL_COMMENT; | ||
1739 | int _channel = DEFAULT_TOKEN_CHANNEL; | ||
1740 | // InternalSolverLanguageLexer.g:162:17: ( ( '%' | '//' ) (~ ( ( '\\n' | '\\r' ) ) )* ( ( '\\r' )? '\\n' )? ) | ||
1741 | // InternalSolverLanguageLexer.g:162:19: ( '%' | '//' ) (~ ( ( '\\n' | '\\r' ) ) )* ( ( '\\r' )? '\\n' )? | ||
1742 | { | ||
1743 | // InternalSolverLanguageLexer.g:162:19: ( '%' | '//' ) | ||
1744 | int alt3=2; | ||
1745 | int LA3_0 = input.LA(1); | ||
1746 | |||
1747 | if ( (LA3_0=='%') ) { | ||
1748 | alt3=1; | ||
1749 | } | ||
1750 | else if ( (LA3_0=='/') ) { | ||
1751 | alt3=2; | ||
1752 | } | ||
1753 | else { | ||
1754 | NoViableAltException nvae = | ||
1755 | new NoViableAltException("", 3, 0, input); | ||
1756 | |||
1757 | throw nvae; | ||
1758 | } | ||
1759 | switch (alt3) { | ||
1760 | case 1 : | ||
1761 | // InternalSolverLanguageLexer.g:162:20: '%' | ||
1762 | { | ||
1763 | match('%'); | ||
1764 | |||
1765 | } | ||
1766 | break; | ||
1767 | case 2 : | ||
1768 | // InternalSolverLanguageLexer.g:162:24: '//' | ||
1769 | { | ||
1770 | match("//"); | ||
1771 | |||
1772 | |||
1773 | } | ||
1774 | break; | ||
1775 | |||
1776 | } | ||
1777 | |||
1778 | // InternalSolverLanguageLexer.g:162:30: (~ ( ( '\\n' | '\\r' ) ) )* | ||
1779 | loop4: | ||
1780 | do { | ||
1781 | int alt4=2; | ||
1782 | int LA4_0 = input.LA(1); | ||
1783 | |||
1784 | if ( ((LA4_0>='\u0000' && LA4_0<='\t')||(LA4_0>='\u000B' && LA4_0<='\f')||(LA4_0>='\u000E' && LA4_0<='\uFFFF')) ) { | ||
1785 | alt4=1; | ||
1786 | } | ||
1787 | |||
1788 | |||
1789 | switch (alt4) { | ||
1790 | case 1 : | ||
1791 | // InternalSolverLanguageLexer.g:162:30: ~ ( ( '\\n' | '\\r' ) ) | ||
1792 | { | ||
1793 | 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') ) { | ||
1794 | input.consume(); | ||
1795 | |||
1796 | } | ||
1797 | else { | ||
1798 | MismatchedSetException mse = new MismatchedSetException(null,input); | ||
1799 | recover(mse); | ||
1800 | throw mse;} | ||
1801 | |||
1802 | |||
1803 | } | ||
1804 | break; | ||
1805 | |||
1806 | default : | ||
1807 | break loop4; | ||
1808 | } | ||
1809 | } while (true); | ||
1810 | |||
1811 | // InternalSolverLanguageLexer.g:162:46: ( ( '\\r' )? '\\n' )? | ||
1812 | int alt6=2; | ||
1813 | int LA6_0 = input.LA(1); | ||
1814 | |||
1815 | if ( (LA6_0=='\n'||LA6_0=='\r') ) { | ||
1816 | alt6=1; | ||
1817 | } | ||
1818 | switch (alt6) { | ||
1819 | case 1 : | ||
1820 | // InternalSolverLanguageLexer.g:162:47: ( '\\r' )? '\\n' | ||
1821 | { | ||
1822 | // InternalSolverLanguageLexer.g:162:47: ( '\\r' )? | ||
1823 | int alt5=2; | ||
1824 | int LA5_0 = input.LA(1); | ||
1825 | |||
1826 | if ( (LA5_0=='\r') ) { | ||
1827 | alt5=1; | ||
1828 | } | ||
1829 | switch (alt5) { | ||
1830 | case 1 : | ||
1831 | // InternalSolverLanguageLexer.g:162:47: '\\r' | ||
1832 | { | ||
1833 | match('\r'); | ||
1834 | |||
1835 | } | ||
1836 | break; | ||
1837 | |||
1838 | } | ||
1839 | |||
1840 | match('\n'); | ||
1841 | |||
1842 | } | ||
1843 | break; | ||
1844 | |||
1845 | } | ||
1846 | |||
1847 | |||
1848 | } | ||
1849 | |||
1850 | state.type = _type; | ||
1851 | state.channel = _channel; | ||
1852 | } | ||
1853 | finally { | ||
1854 | } | ||
1855 | } | ||
1856 | // $ANTLR end "RULE_SL_COMMENT" | ||
1857 | |||
1858 | // $ANTLR start "RULE_TRANSITIVE_CLOSURE" | ||
1859 | public final void mRULE_TRANSITIVE_CLOSURE() throws RecognitionException { | ||
1860 | try { | ||
1861 | // InternalSolverLanguageLexer.g:164:34: () | ||
1862 | // InternalSolverLanguageLexer.g:164:36: | ||
1863 | { | ||
1864 | } | ||
1865 | |||
1866 | } | ||
1867 | finally { | ||
1868 | } | ||
1869 | } | ||
1870 | // $ANTLR end "RULE_TRANSITIVE_CLOSURE" | ||
1871 | |||
1872 | // $ANTLR start "RULE_REFLEXIVE_TRANSITIVE_CLOSURE" | ||
1873 | public final void mRULE_REFLEXIVE_TRANSITIVE_CLOSURE() throws RecognitionException { | ||
1874 | try { | ||
1875 | // InternalSolverLanguageLexer.g:166:44: () | ||
1876 | // InternalSolverLanguageLexer.g:166:46: | ||
1877 | { | ||
1878 | } | ||
1879 | |||
1880 | } | ||
1881 | finally { | ||
1882 | } | ||
1883 | } | ||
1884 | // $ANTLR end "RULE_REFLEXIVE_TRANSITIVE_CLOSURE" | ||
1885 | |||
1886 | // $ANTLR start "RULE_FULL_STOP" | ||
1887 | public final void mRULE_FULL_STOP() throws RecognitionException { | ||
1888 | try { | ||
1889 | // InternalSolverLanguageLexer.g:168:25: () | ||
1890 | // InternalSolverLanguageLexer.g:168:27: | ||
1891 | { | ||
1892 | } | ||
1893 | |||
1894 | } | ||
1895 | finally { | ||
1896 | } | ||
1897 | } | ||
1898 | // $ANTLR end "RULE_FULL_STOP" | ||
1899 | |||
1900 | // $ANTLR start "RULE_ID" | ||
1901 | public final void mRULE_ID() throws RecognitionException { | ||
1902 | try { | ||
1903 | int _type = RULE_ID; | ||
1904 | int _channel = DEFAULT_TOKEN_CHANNEL; | ||
1905 | // InternalSolverLanguageLexer.g:170:9: ( ( '^' )? ( 'a' .. 'z' | 'A' .. 'Z' | '_' ) ( 'a' .. 'z' | 'A' .. 'Z' | '_' | '0' .. '9' )* ) | ||
1906 | // InternalSolverLanguageLexer.g:170:11: ( '^' )? ( 'a' .. 'z' | 'A' .. 'Z' | '_' ) ( 'a' .. 'z' | 'A' .. 'Z' | '_' | '0' .. '9' )* | ||
1907 | { | ||
1908 | // InternalSolverLanguageLexer.g:170:11: ( '^' )? | ||
1909 | int alt7=2; | ||
1910 | int LA7_0 = input.LA(1); | ||
1911 | |||
1912 | if ( (LA7_0=='^') ) { | ||
1913 | alt7=1; | ||
1914 | } | ||
1915 | switch (alt7) { | ||
1916 | case 1 : | ||
1917 | // InternalSolverLanguageLexer.g:170:11: '^' | ||
1918 | { | ||
1919 | match('^'); | ||
1920 | |||
1921 | } | ||
1922 | break; | ||
1923 | |||
1924 | } | ||
1925 | |||
1926 | if ( (input.LA(1)>='A' && input.LA(1)<='Z')||input.LA(1)=='_'||(input.LA(1)>='a' && input.LA(1)<='z') ) { | ||
1927 | input.consume(); | ||
1928 | |||
1929 | } | ||
1930 | else { | ||
1931 | MismatchedSetException mse = new MismatchedSetException(null,input); | ||
1932 | recover(mse); | ||
1933 | throw mse;} | ||
1934 | |||
1935 | // InternalSolverLanguageLexer.g:170:40: ( 'a' .. 'z' | 'A' .. 'Z' | '_' | '0' .. '9' )* | ||
1936 | loop8: | ||
1937 | do { | ||
1938 | int alt8=2; | ||
1939 | int LA8_0 = input.LA(1); | ||
1940 | |||
1941 | if ( ((LA8_0>='0' && LA8_0<='9')||(LA8_0>='A' && LA8_0<='Z')||LA8_0=='_'||(LA8_0>='a' && LA8_0<='z')) ) { | ||
1942 | alt8=1; | ||
1943 | } | ||
1944 | |||
1945 | |||
1946 | switch (alt8) { | ||
1947 | case 1 : | ||
1948 | // InternalSolverLanguageLexer.g: | ||
1949 | { | ||
1950 | if ( (input.LA(1)>='0' && input.LA(1)<='9')||(input.LA(1)>='A' && input.LA(1)<='Z')||input.LA(1)=='_'||(input.LA(1)>='a' && input.LA(1)<='z') ) { | ||
1951 | input.consume(); | ||
1952 | |||
1953 | } | ||
1954 | else { | ||
1955 | MismatchedSetException mse = new MismatchedSetException(null,input); | ||
1956 | recover(mse); | ||
1957 | throw mse;} | ||
1958 | |||
1959 | |||
1960 | } | ||
1961 | break; | ||
1962 | |||
1963 | default : | ||
1964 | break loop8; | ||
1965 | } | ||
1966 | } while (true); | ||
1967 | |||
1968 | |||
1969 | } | ||
1970 | |||
1971 | state.type = _type; | ||
1972 | state.channel = _channel; | ||
1973 | } | ||
1974 | finally { | ||
1975 | } | ||
1976 | } | ||
1977 | // $ANTLR end "RULE_ID" | ||
1978 | |||
1979 | // $ANTLR start "RULE_INT" | ||
1980 | public final void mRULE_INT() throws RecognitionException { | ||
1981 | try { | ||
1982 | int _type = RULE_INT; | ||
1983 | int _channel = DEFAULT_TOKEN_CHANNEL; | ||
1984 | // InternalSolverLanguageLexer.g:172:10: ( ( '0' .. '9' )+ ) | ||
1985 | // InternalSolverLanguageLexer.g:172:12: ( '0' .. '9' )+ | ||
1986 | { | ||
1987 | // InternalSolverLanguageLexer.g:172:12: ( '0' .. '9' )+ | ||
1988 | int cnt9=0; | ||
1989 | loop9: | ||
1990 | do { | ||
1991 | int alt9=2; | ||
1992 | int LA9_0 = input.LA(1); | ||
1993 | |||
1994 | if ( ((LA9_0>='0' && LA9_0<='9')) ) { | ||
1995 | alt9=1; | ||
1996 | } | ||
1997 | |||
1998 | |||
1999 | switch (alt9) { | ||
2000 | case 1 : | ||
2001 | // InternalSolverLanguageLexer.g:172:13: '0' .. '9' | ||
2002 | { | ||
2003 | matchRange('0','9'); | ||
2004 | |||
2005 | } | ||
2006 | break; | ||
2007 | |||
2008 | default : | ||
2009 | if ( cnt9 >= 1 ) break loop9; | ||
2010 | EarlyExitException eee = | ||
2011 | new EarlyExitException(9, input); | ||
2012 | throw eee; | ||
2013 | } | ||
2014 | cnt9++; | ||
2015 | } while (true); | ||
2016 | |||
2017 | |||
2018 | } | ||
2019 | |||
2020 | state.type = _type; | ||
2021 | state.channel = _channel; | ||
2022 | } | ||
2023 | finally { | ||
2024 | } | ||
2025 | } | ||
2026 | // $ANTLR end "RULE_INT" | ||
2027 | |||
2028 | // $ANTLR start "RULE_ML_COMMENT" | ||
2029 | public final void mRULE_ML_COMMENT() throws RecognitionException { | ||
2030 | try { | ||
2031 | int _type = RULE_ML_COMMENT; | ||
2032 | int _channel = DEFAULT_TOKEN_CHANNEL; | ||
2033 | // InternalSolverLanguageLexer.g:174:17: ( '/*' ( options {greedy=false; } : . )* '*/' ) | ||
2034 | // InternalSolverLanguageLexer.g:174:19: '/*' ( options {greedy=false; } : . )* '*/' | ||
2035 | { | ||
2036 | match("/*"); | ||
2037 | |||
2038 | // InternalSolverLanguageLexer.g:174:24: ( options {greedy=false; } : . )* | ||
2039 | loop10: | ||
2040 | do { | ||
2041 | int alt10=2; | ||
2042 | int LA10_0 = input.LA(1); | ||
2043 | |||
2044 | if ( (LA10_0=='*') ) { | ||
2045 | int LA10_1 = input.LA(2); | ||
2046 | |||
2047 | if ( (LA10_1=='/') ) { | ||
2048 | alt10=2; | ||
2049 | } | ||
2050 | else if ( ((LA10_1>='\u0000' && LA10_1<='.')||(LA10_1>='0' && LA10_1<='\uFFFF')) ) { | ||
2051 | alt10=1; | ||
2052 | } | ||
2053 | |||
2054 | |||
2055 | } | ||
2056 | else if ( ((LA10_0>='\u0000' && LA10_0<=')')||(LA10_0>='+' && LA10_0<='\uFFFF')) ) { | ||
2057 | alt10=1; | ||
2058 | } | ||
2059 | |||
2060 | |||
2061 | switch (alt10) { | ||
2062 | case 1 : | ||
2063 | // InternalSolverLanguageLexer.g:174:52: . | ||
2064 | { | ||
2065 | matchAny(); | ||
2066 | |||
2067 | } | ||
2068 | break; | ||
2069 | |||
2070 | default : | ||
2071 | break loop10; | ||
2072 | } | ||
2073 | } while (true); | ||
2074 | |||
2075 | match("*/"); | ||
2076 | |||
2077 | |||
2078 | } | ||
2079 | |||
2080 | state.type = _type; | ||
2081 | state.channel = _channel; | ||
2082 | } | ||
2083 | finally { | ||
2084 | } | ||
2085 | } | ||
2086 | // $ANTLR end "RULE_ML_COMMENT" | ||
2087 | |||
2088 | // $ANTLR start "RULE_WS" | ||
2089 | public final void mRULE_WS() throws RecognitionException { | ||
2090 | try { | ||
2091 | int _type = RULE_WS; | ||
2092 | int _channel = DEFAULT_TOKEN_CHANNEL; | ||
2093 | // InternalSolverLanguageLexer.g:176:9: ( ( ' ' | '\\t' | '\\r' | '\\n' )+ ) | ||
2094 | // InternalSolverLanguageLexer.g:176:11: ( ' ' | '\\t' | '\\r' | '\\n' )+ | ||
2095 | { | ||
2096 | // InternalSolverLanguageLexer.g:176:11: ( ' ' | '\\t' | '\\r' | '\\n' )+ | ||
2097 | int cnt11=0; | ||
2098 | loop11: | ||
2099 | do { | ||
2100 | int alt11=2; | ||
2101 | int LA11_0 = input.LA(1); | ||
2102 | |||
2103 | if ( ((LA11_0>='\t' && LA11_0<='\n')||LA11_0=='\r'||LA11_0==' ') ) { | ||
2104 | alt11=1; | ||
2105 | } | ||
2106 | |||
2107 | |||
2108 | switch (alt11) { | ||
2109 | case 1 : | ||
2110 | // InternalSolverLanguageLexer.g: | ||
2111 | { | ||
2112 | if ( (input.LA(1)>='\t' && input.LA(1)<='\n')||input.LA(1)=='\r'||input.LA(1)==' ' ) { | ||
2113 | input.consume(); | ||
2114 | |||
2115 | } | ||
2116 | else { | ||
2117 | MismatchedSetException mse = new MismatchedSetException(null,input); | ||
2118 | recover(mse); | ||
2119 | throw mse;} | ||
2120 | |||
2121 | |||
2122 | } | ||
2123 | break; | ||
2124 | |||
2125 | default : | ||
2126 | if ( cnt11 >= 1 ) break loop11; | ||
2127 | EarlyExitException eee = | ||
2128 | new EarlyExitException(11, input); | ||
2129 | throw eee; | ||
2130 | } | ||
2131 | cnt11++; | ||
2132 | } while (true); | ||
2133 | |||
2134 | |||
2135 | } | ||
2136 | |||
2137 | state.type = _type; | ||
2138 | state.channel = _channel; | ||
2139 | } | ||
2140 | finally { | ||
2141 | } | ||
2142 | } | ||
2143 | // $ANTLR end "RULE_WS" | ||
2144 | |||
2145 | // $ANTLR start "RULE_ANY_OTHER" | ||
2146 | public final void mRULE_ANY_OTHER() throws RecognitionException { | ||
2147 | try { | ||
2148 | int _type = RULE_ANY_OTHER; | ||
2149 | int _channel = DEFAULT_TOKEN_CHANNEL; | ||
2150 | // InternalSolverLanguageLexer.g:178:16: ( . ) | ||
2151 | // InternalSolverLanguageLexer.g:178:18: . | ||
2152 | { | ||
2153 | matchAny(); | ||
2154 | |||
2155 | } | ||
2156 | |||
2157 | state.type = _type; | ||
2158 | state.channel = _channel; | ||
2159 | } | ||
2160 | finally { | ||
2161 | } | ||
2162 | } | ||
2163 | // $ANTLR end "RULE_ANY_OTHER" | ||
2164 | |||
2165 | public void mTokens() throws RecognitionException { | ||
2166 | // InternalSolverLanguageLexer.g:1:8: ( GREATER_EQ | Functional | Abstract | Contains | Maximize | Minimize | Opposite | GREATER | LESS_EQ | Current | Default | Extends | Unknown | NOT_EQ | Extern | Class | Count | Empty | Error | False | Scope | LESS | Else | Must | Only | Prod | Real | Then | True | ADD | DIV | MUL | POW | SUB | Avg | Inf | Int | Max | May | Min | Sum | ExclamationMarkEqualsSign | HyphenMinusGreaterThanSign | FullStopFullStop | ColonHyphenMinus | LessThanSignEqualsSign | EqualsSignEqualsSign | GreaterThanSignEqualsSign | EQ | IN | If | In | ExclamationMark | LeftParenthesis | RightParenthesis | Asterisk | PlusSign | Comma | HyphenMinus | FullStop | Solidus | Colon | Semicolon | LessThanSign | EqualsSign | GreaterThanSign | LeftSquareBracket | RightSquareBracket | CircumflexAccent | LeftCurlyBracket | VerticalLine | RightCurlyBracket | RULE_STRING | RULE_QUOTED_ID | RULE_SL_COMMENT | RULE_ID | RULE_INT | RULE_ML_COMMENT | RULE_WS | RULE_ANY_OTHER ) | ||
2167 | int alt12=80; | ||
2168 | alt12 = dfa12.predict(input); | ||
2169 | switch (alt12) { | ||
2170 | case 1 : | ||
2171 | // InternalSolverLanguageLexer.g:1:10: GREATER_EQ | ||
2172 | { | ||
2173 | mGREATER_EQ(); | ||
2174 | |||
2175 | } | ||
2176 | break; | ||
2177 | case 2 : | ||
2178 | // InternalSolverLanguageLexer.g:1:21: Functional | ||
2179 | { | ||
2180 | mFunctional(); | ||
2181 | |||
2182 | } | ||
2183 | break; | ||
2184 | case 3 : | ||
2185 | // InternalSolverLanguageLexer.g:1:32: Abstract | ||
2186 | { | ||
2187 | mAbstract(); | ||
2188 | |||
2189 | } | ||
2190 | break; | ||
2191 | case 4 : | ||
2192 | // InternalSolverLanguageLexer.g:1:41: Contains | ||
2193 | { | ||
2194 | mContains(); | ||
2195 | |||
2196 | } | ||
2197 | break; | ||
2198 | case 5 : | ||
2199 | // InternalSolverLanguageLexer.g:1:50: Maximize | ||
2200 | { | ||
2201 | mMaximize(); | ||
2202 | |||
2203 | } | ||
2204 | break; | ||
2205 | case 6 : | ||
2206 | // InternalSolverLanguageLexer.g:1:59: Minimize | ||
2207 | { | ||
2208 | mMinimize(); | ||
2209 | |||
2210 | } | ||
2211 | break; | ||
2212 | case 7 : | ||
2213 | // InternalSolverLanguageLexer.g:1:68: Opposite | ||
2214 | { | ||
2215 | mOpposite(); | ||
2216 | |||
2217 | } | ||
2218 | break; | ||
2219 | case 8 : | ||
2220 | // InternalSolverLanguageLexer.g:1:77: GREATER | ||
2221 | { | ||
2222 | mGREATER(); | ||
2223 | |||
2224 | } | ||
2225 | break; | ||
2226 | case 9 : | ||
2227 | // InternalSolverLanguageLexer.g:1:85: LESS_EQ | ||
2228 | { | ||
2229 | mLESS_EQ(); | ||
2230 | |||
2231 | } | ||
2232 | break; | ||
2233 | case 10 : | ||
2234 | // InternalSolverLanguageLexer.g:1:93: Current | ||
2235 | { | ||
2236 | mCurrent(); | ||
2237 | |||
2238 | } | ||
2239 | break; | ||
2240 | case 11 : | ||
2241 | // InternalSolverLanguageLexer.g:1:101: Default | ||
2242 | { | ||
2243 | mDefault(); | ||
2244 | |||
2245 | } | ||
2246 | break; | ||
2247 | case 12 : | ||
2248 | // InternalSolverLanguageLexer.g:1:109: Extends | ||
2249 | { | ||
2250 | mExtends(); | ||
2251 | |||
2252 | } | ||
2253 | break; | ||
2254 | case 13 : | ||
2255 | // InternalSolverLanguageLexer.g:1:117: Unknown | ||
2256 | { | ||
2257 | mUnknown(); | ||
2258 | |||
2259 | } | ||
2260 | break; | ||
2261 | case 14 : | ||
2262 | // InternalSolverLanguageLexer.g:1:125: NOT_EQ | ||
2263 | { | ||
2264 | mNOT_EQ(); | ||
2265 | |||
2266 | } | ||
2267 | break; | ||
2268 | case 15 : | ||
2269 | // InternalSolverLanguageLexer.g:1:132: Extern | ||
2270 | { | ||
2271 | mExtern(); | ||
2272 | |||
2273 | } | ||
2274 | break; | ||
2275 | case 16 : | ||
2276 | // InternalSolverLanguageLexer.g:1:139: Class | ||
2277 | { | ||
2278 | mClass(); | ||
2279 | |||
2280 | } | ||
2281 | break; | ||
2282 | case 17 : | ||
2283 | // InternalSolverLanguageLexer.g:1:145: Count | ||
2284 | { | ||
2285 | mCount(); | ||
2286 | |||
2287 | } | ||
2288 | break; | ||
2289 | case 18 : | ||
2290 | // InternalSolverLanguageLexer.g:1:151: Empty | ||
2291 | { | ||
2292 | mEmpty(); | ||
2293 | |||
2294 | } | ||
2295 | break; | ||
2296 | case 19 : | ||
2297 | // InternalSolverLanguageLexer.g:1:157: Error | ||
2298 | { | ||
2299 | mError(); | ||
2300 | |||
2301 | } | ||
2302 | break; | ||
2303 | case 20 : | ||
2304 | // InternalSolverLanguageLexer.g:1:163: False | ||
2305 | { | ||
2306 | mFalse(); | ||
2307 | |||
2308 | } | ||
2309 | break; | ||
2310 | case 21 : | ||
2311 | // InternalSolverLanguageLexer.g:1:169: Scope | ||
2312 | { | ||
2313 | mScope(); | ||
2314 | |||
2315 | } | ||
2316 | break; | ||
2317 | case 22 : | ||
2318 | // InternalSolverLanguageLexer.g:1:175: LESS | ||
2319 | { | ||
2320 | mLESS(); | ||
2321 | |||
2322 | } | ||
2323 | break; | ||
2324 | case 23 : | ||
2325 | // InternalSolverLanguageLexer.g:1:180: Else | ||
2326 | { | ||
2327 | mElse(); | ||
2328 | |||
2329 | } | ||
2330 | break; | ||
2331 | case 24 : | ||
2332 | // InternalSolverLanguageLexer.g:1:185: Must | ||
2333 | { | ||
2334 | mMust(); | ||
2335 | |||
2336 | } | ||
2337 | break; | ||
2338 | case 25 : | ||
2339 | // InternalSolverLanguageLexer.g:1:190: Only | ||
2340 | { | ||
2341 | mOnly(); | ||
2342 | |||
2343 | } | ||
2344 | break; | ||
2345 | case 26 : | ||
2346 | // InternalSolverLanguageLexer.g:1:195: Prod | ||
2347 | { | ||
2348 | mProd(); | ||
2349 | |||
2350 | } | ||
2351 | break; | ||
2352 | case 27 : | ||
2353 | // InternalSolverLanguageLexer.g:1:200: Real | ||
2354 | { | ||
2355 | mReal(); | ||
2356 | |||
2357 | } | ||
2358 | break; | ||
2359 | case 28 : | ||
2360 | // InternalSolverLanguageLexer.g:1:205: Then | ||
2361 | { | ||
2362 | mThen(); | ||
2363 | |||
2364 | } | ||
2365 | break; | ||
2366 | case 29 : | ||
2367 | // InternalSolverLanguageLexer.g:1:210: True | ||
2368 | { | ||
2369 | mTrue(); | ||
2370 | |||
2371 | } | ||
2372 | break; | ||
2373 | case 30 : | ||
2374 | // InternalSolverLanguageLexer.g:1:215: ADD | ||
2375 | { | ||
2376 | mADD(); | ||
2377 | |||
2378 | } | ||
2379 | break; | ||
2380 | case 31 : | ||
2381 | // InternalSolverLanguageLexer.g:1:219: DIV | ||
2382 | { | ||
2383 | mDIV(); | ||
2384 | |||
2385 | } | ||
2386 | break; | ||
2387 | case 32 : | ||
2388 | // InternalSolverLanguageLexer.g:1:223: MUL | ||
2389 | { | ||
2390 | mMUL(); | ||
2391 | |||
2392 | } | ||
2393 | break; | ||
2394 | case 33 : | ||
2395 | // InternalSolverLanguageLexer.g:1:227: POW | ||
2396 | { | ||
2397 | mPOW(); | ||
2398 | |||
2399 | } | ||
2400 | break; | ||
2401 | case 34 : | ||
2402 | // InternalSolverLanguageLexer.g:1:231: SUB | ||
2403 | { | ||
2404 | mSUB(); | ||
2405 | |||
2406 | } | ||
2407 | break; | ||
2408 | case 35 : | ||
2409 | // InternalSolverLanguageLexer.g:1:235: Avg | ||
2410 | { | ||
2411 | mAvg(); | ||
2412 | |||
2413 | } | ||
2414 | break; | ||
2415 | case 36 : | ||
2416 | // InternalSolverLanguageLexer.g:1:239: Inf | ||
2417 | { | ||
2418 | mInf(); | ||
2419 | |||
2420 | } | ||
2421 | break; | ||
2422 | case 37 : | ||
2423 | // InternalSolverLanguageLexer.g:1:243: Int | ||
2424 | { | ||
2425 | mInt(); | ||
2426 | |||
2427 | } | ||
2428 | break; | ||
2429 | case 38 : | ||
2430 | // InternalSolverLanguageLexer.g:1:247: Max | ||
2431 | { | ||
2432 | mMax(); | ||
2433 | |||
2434 | } | ||
2435 | break; | ||
2436 | case 39 : | ||
2437 | // InternalSolverLanguageLexer.g:1:251: May | ||
2438 | { | ||
2439 | mMay(); | ||
2440 | |||
2441 | } | ||
2442 | break; | ||
2443 | case 40 : | ||
2444 | // InternalSolverLanguageLexer.g:1:255: Min | ||
2445 | { | ||
2446 | mMin(); | ||
2447 | |||
2448 | } | ||
2449 | break; | ||
2450 | case 41 : | ||
2451 | // InternalSolverLanguageLexer.g:1:259: Sum | ||
2452 | { | ||
2453 | mSum(); | ||
2454 | |||
2455 | } | ||
2456 | break; | ||
2457 | case 42 : | ||
2458 | // InternalSolverLanguageLexer.g:1:263: ExclamationMarkEqualsSign | ||
2459 | { | ||
2460 | mExclamationMarkEqualsSign(); | ||
2461 | |||
2462 | } | ||
2463 | break; | ||
2464 | case 43 : | ||
2465 | // InternalSolverLanguageLexer.g:1:289: HyphenMinusGreaterThanSign | ||
2466 | { | ||
2467 | mHyphenMinusGreaterThanSign(); | ||
2468 | |||
2469 | } | ||
2470 | break; | ||
2471 | case 44 : | ||
2472 | // InternalSolverLanguageLexer.g:1:316: FullStopFullStop | ||
2473 | { | ||
2474 | mFullStopFullStop(); | ||
2475 | |||
2476 | } | ||
2477 | break; | ||
2478 | case 45 : | ||
2479 | // InternalSolverLanguageLexer.g:1:333: ColonHyphenMinus | ||
2480 | { | ||
2481 | mColonHyphenMinus(); | ||
2482 | |||
2483 | } | ||
2484 | break; | ||
2485 | case 46 : | ||
2486 | // InternalSolverLanguageLexer.g:1:350: LessThanSignEqualsSign | ||
2487 | { | ||
2488 | mLessThanSignEqualsSign(); | ||
2489 | |||
2490 | } | ||
2491 | break; | ||
2492 | case 47 : | ||
2493 | // InternalSolverLanguageLexer.g:1:373: EqualsSignEqualsSign | ||
2494 | { | ||
2495 | mEqualsSignEqualsSign(); | ||
2496 | |||
2497 | } | ||
2498 | break; | ||
2499 | case 48 : | ||
2500 | // InternalSolverLanguageLexer.g:1:394: GreaterThanSignEqualsSign | ||
2501 | { | ||
2502 | mGreaterThanSignEqualsSign(); | ||
2503 | |||
2504 | } | ||
2505 | break; | ||
2506 | case 49 : | ||
2507 | // InternalSolverLanguageLexer.g:1:420: EQ | ||
2508 | { | ||
2509 | mEQ(); | ||
2510 | |||
2511 | } | ||
2512 | break; | ||
2513 | case 50 : | ||
2514 | // InternalSolverLanguageLexer.g:1:423: IN | ||
2515 | { | ||
2516 | mIN(); | ||
2517 | |||
2518 | } | ||
2519 | break; | ||
2520 | case 51 : | ||
2521 | // InternalSolverLanguageLexer.g:1:426: If | ||
2522 | { | ||
2523 | mIf(); | ||
2524 | |||
2525 | } | ||
2526 | break; | ||
2527 | case 52 : | ||
2528 | // InternalSolverLanguageLexer.g:1:429: In | ||
2529 | { | ||
2530 | mIn(); | ||
2531 | |||
2532 | } | ||
2533 | break; | ||
2534 | case 53 : | ||
2535 | // InternalSolverLanguageLexer.g:1:432: ExclamationMark | ||
2536 | { | ||
2537 | mExclamationMark(); | ||
2538 | |||
2539 | } | ||
2540 | break; | ||
2541 | case 54 : | ||
2542 | // InternalSolverLanguageLexer.g:1:448: LeftParenthesis | ||
2543 | { | ||
2544 | mLeftParenthesis(); | ||
2545 | |||
2546 | } | ||
2547 | break; | ||
2548 | case 55 : | ||
2549 | // InternalSolverLanguageLexer.g:1:464: RightParenthesis | ||
2550 | { | ||
2551 | mRightParenthesis(); | ||
2552 | |||
2553 | } | ||
2554 | break; | ||
2555 | case 56 : | ||
2556 | // InternalSolverLanguageLexer.g:1:481: Asterisk | ||
2557 | { | ||
2558 | mAsterisk(); | ||
2559 | |||
2560 | } | ||
2561 | break; | ||
2562 | case 57 : | ||
2563 | // InternalSolverLanguageLexer.g:1:490: PlusSign | ||
2564 | { | ||
2565 | mPlusSign(); | ||
2566 | |||
2567 | } | ||
2568 | break; | ||
2569 | case 58 : | ||
2570 | // InternalSolverLanguageLexer.g:1:499: Comma | ||
2571 | { | ||
2572 | mComma(); | ||
2573 | |||
2574 | } | ||
2575 | break; | ||
2576 | case 59 : | ||
2577 | // InternalSolverLanguageLexer.g:1:505: HyphenMinus | ||
2578 | { | ||
2579 | mHyphenMinus(); | ||
2580 | |||
2581 | } | ||
2582 | break; | ||
2583 | case 60 : | ||
2584 | // InternalSolverLanguageLexer.g:1:517: FullStop | ||
2585 | { | ||
2586 | mFullStop(); | ||
2587 | |||
2588 | } | ||
2589 | break; | ||
2590 | case 61 : | ||
2591 | // InternalSolverLanguageLexer.g:1:526: Solidus | ||
2592 | { | ||
2593 | mSolidus(); | ||
2594 | |||
2595 | } | ||
2596 | break; | ||
2597 | case 62 : | ||
2598 | // InternalSolverLanguageLexer.g:1:534: Colon | ||
2599 | { | ||
2600 | mColon(); | ||
2601 | |||
2602 | } | ||
2603 | break; | ||
2604 | case 63 : | ||
2605 | // InternalSolverLanguageLexer.g:1:540: Semicolon | ||
2606 | { | ||
2607 | mSemicolon(); | ||
2608 | |||
2609 | } | ||
2610 | break; | ||
2611 | case 64 : | ||
2612 | // InternalSolverLanguageLexer.g:1:550: LessThanSign | ||
2613 | { | ||
2614 | mLessThanSign(); | ||
2615 | |||
2616 | } | ||
2617 | break; | ||
2618 | case 65 : | ||
2619 | // InternalSolverLanguageLexer.g:1:563: EqualsSign | ||
2620 | { | ||
2621 | mEqualsSign(); | ||
2622 | |||
2623 | } | ||
2624 | break; | ||
2625 | case 66 : | ||
2626 | // InternalSolverLanguageLexer.g:1:574: GreaterThanSign | ||
2627 | { | ||
2628 | mGreaterThanSign(); | ||
2629 | |||
2630 | } | ||
2631 | break; | ||
2632 | case 67 : | ||
2633 | // InternalSolverLanguageLexer.g:1:590: LeftSquareBracket | ||
2634 | { | ||
2635 | mLeftSquareBracket(); | ||
2636 | |||
2637 | } | ||
2638 | break; | ||
2639 | case 68 : | ||
2640 | // InternalSolverLanguageLexer.g:1:608: RightSquareBracket | ||
2641 | { | ||
2642 | mRightSquareBracket(); | ||
2643 | |||
2644 | } | ||
2645 | break; | ||
2646 | case 69 : | ||
2647 | // InternalSolverLanguageLexer.g:1:627: CircumflexAccent | ||
2648 | { | ||
2649 | mCircumflexAccent(); | ||
2650 | |||
2651 | } | ||
2652 | break; | ||
2653 | case 70 : | ||
2654 | // InternalSolverLanguageLexer.g:1:644: LeftCurlyBracket | ||
2655 | { | ||
2656 | mLeftCurlyBracket(); | ||
2657 | |||
2658 | } | ||
2659 | break; | ||
2660 | case 71 : | ||
2661 | // InternalSolverLanguageLexer.g:1:661: VerticalLine | ||
2662 | { | ||
2663 | mVerticalLine(); | ||
2664 | |||
2665 | } | ||
2666 | break; | ||
2667 | case 72 : | ||
2668 | // InternalSolverLanguageLexer.g:1:674: RightCurlyBracket | ||
2669 | { | ||
2670 | mRightCurlyBracket(); | ||
2671 | |||
2672 | } | ||
2673 | break; | ||
2674 | case 73 : | ||
2675 | // InternalSolverLanguageLexer.g:1:692: RULE_STRING | ||
2676 | { | ||
2677 | mRULE_STRING(); | ||
2678 | |||
2679 | } | ||
2680 | break; | ||
2681 | case 74 : | ||
2682 | // InternalSolverLanguageLexer.g:1:704: RULE_QUOTED_ID | ||
2683 | { | ||
2684 | mRULE_QUOTED_ID(); | ||
2685 | |||
2686 | } | ||
2687 | break; | ||
2688 | case 75 : | ||
2689 | // InternalSolverLanguageLexer.g:1:719: RULE_SL_COMMENT | ||
2690 | { | ||
2691 | mRULE_SL_COMMENT(); | ||
2692 | |||
2693 | } | ||
2694 | break; | ||
2695 | case 76 : | ||
2696 | // InternalSolverLanguageLexer.g:1:735: RULE_ID | ||
2697 | { | ||
2698 | mRULE_ID(); | ||
2699 | |||
2700 | } | ||
2701 | break; | ||
2702 | case 77 : | ||
2703 | // InternalSolverLanguageLexer.g:1:743: RULE_INT | ||
2704 | { | ||
2705 | mRULE_INT(); | ||
2706 | |||
2707 | } | ||
2708 | break; | ||
2709 | case 78 : | ||
2710 | // InternalSolverLanguageLexer.g:1:752: RULE_ML_COMMENT | ||
2711 | { | ||
2712 | mRULE_ML_COMMENT(); | ||
2713 | |||
2714 | } | ||
2715 | break; | ||
2716 | case 79 : | ||
2717 | // InternalSolverLanguageLexer.g:1:768: RULE_WS | ||
2718 | { | ||
2719 | mRULE_WS(); | ||
2720 | |||
2721 | } | ||
2722 | break; | ||
2723 | case 80 : | ||
2724 | // InternalSolverLanguageLexer.g:1:776: RULE_ANY_OTHER | ||
2725 | { | ||
2726 | mRULE_ANY_OTHER(); | ||
2727 | |||
2728 | } | ||
2729 | break; | ||
2730 | |||
2731 | } | ||
2732 | |||
2733 | } | ||
2734 | |||
2735 | |||
2736 | protected DFA12 dfa12 = new DFA12(this); | ||
2737 | static final String DFA12_eotS = | ||
2738 | "\1\uffff\25\64\1\127\1\131\1\133\1\135\1\137\1\141\1\143\2\64\5\uffff\1\155\3\uffff\1\161\3\uffff\2\62\5\uffff\1\64\1\uffff\37\64\1\u009d\1\u009e\16\uffff\1\u009f\1\u00a0\23\uffff\4\64\1\u00a5\4\64\1\u00ab\1\u00ac\1\u00ae\14\64\1\u00bb\4\64\1\u00c0\1\u00c1\1\u00c2\1\u00c3\1\u00c4\1\u00c5\1\u00c6\4\uffff\4\64\1\uffff\5\64\2\uffff\1\64\1\uffff\1\u00d1\1\64\1\u00d3\1\u00d5\4\64\1\u00db\3\64\1\uffff\1\u00df\1\u00e0\1\u00e1\1\u00e2\7\uffff\2\64\1\u00e5\2\64\1\u00e8\1\64\1\u00ea\2\64\1\uffff\1\64\1\uffff\1\64\1\uffff\3\64\1\u00f2\1\u00f3\1\uffff\2\64\1\u00f6\4\uffff\2\64\1\uffff\2\64\1\uffff\1\64\1\uffff\6\64\1\u0102\2\uffff\1\64\1\u0104\1\uffff\1\u0106\3\64\1\u010a\3\64\1\u010e\1\u010f\1\u0110\1\uffff\1\u0111\1\uffff\1\64\1\uffff\1\64\1\u0114\1\u0115\1\uffff\1\u0116\1\u0117\1\u0118\4\uffff\2\64\5\uffff\1\u011b\1\u011c\2\uffff"; | ||
2739 | static final String DFA12_eofS = | ||
2740 | "\u011d\uffff"; | ||
2741 | static final String DFA12_minS = | ||
2742 | "\1\0\1\122\1\141\1\142\1\154\1\141\1\156\1\105\1\145\1\154\1\156\1\117\1\143\1\162\1\145\1\150\1\104\1\111\1\125\1\117\1\125\1\146\1\75\1\76\1\56\1\55\3\75\1\121\1\116\5\uffff\1\52\3\uffff\1\101\3\uffff\2\0\5\uffff\1\105\1\uffff\1\156\1\154\1\163\1\147\1\156\1\162\1\141\1\170\1\156\1\163\1\160\1\154\1\123\1\146\1\164\1\160\1\162\1\163\1\153\1\124\1\157\1\155\1\157\1\141\1\145\1\165\1\104\1\126\1\114\1\127\1\102\2\60\16\uffff\2\60\23\uffff\1\101\1\143\1\163\1\164\1\60\1\164\1\156\1\162\1\163\3\60\1\164\1\157\1\171\1\123\1\141\1\145\1\164\1\157\1\145\1\156\1\137\1\160\1\60\1\144\1\154\1\156\1\145\7\60\4\uffff\1\124\1\164\1\145\1\162\1\uffff\1\141\1\164\1\145\1\163\1\155\2\uffff\1\155\1\uffff\1\60\1\163\2\60\1\165\1\156\1\171\1\162\1\60\1\157\1\105\1\145\1\uffff\4\60\7\uffff\1\105\1\151\1\60\1\141\1\151\1\60\1\156\1\60\2\151\1\uffff\1\151\1\uffff\1\105\1\uffff\1\154\1\144\1\156\2\60\1\uffff\1\167\1\121\1\60\4\uffff\1\122\1\157\1\uffff\1\143\1\156\1\uffff\1\164\1\uffff\2\172\1\164\1\121\1\164\1\163\1\60\2\uffff\1\156\1\60\1\uffff\1\60\1\156\1\164\1\163\1\60\3\145\3\60\1\uffff\1\60\1\uffff\1\105\1\uffff\1\141\2\60\1\uffff\3\60\4\uffff\1\121\1\154\5\uffff\2\60\2\uffff"; | ||
2743 | static final String DFA12_maxS = | ||
2744 | "\1\uffff\1\122\1\165\1\166\2\165\1\160\1\105\1\145\1\170\1\156\1\117\1\165\1\162\1\145\1\162\1\104\1\111\1\125\1\117\1\125\1\156\1\75\1\76\1\56\1\55\3\75\1\121\1\116\5\uffff\1\57\3\uffff\1\172\3\uffff\2\uffff\5\uffff\1\105\1\uffff\1\156\1\154\1\163\1\147\1\165\1\162\1\141\1\171\1\156\1\163\1\160\1\154\1\123\1\146\1\164\1\160\1\162\1\163\1\153\1\124\1\157\1\155\1\157\1\141\1\145\1\165\1\104\1\126\1\114\1\127\1\102\2\172\16\uffff\2\172\23\uffff\1\101\1\143\1\163\1\164\1\172\1\164\1\156\1\162\1\163\3\172\1\164\1\157\1\171\1\123\1\141\1\145\1\164\1\157\1\145\1\156\1\137\1\160\1\172\1\144\1\154\1\156\1\145\7\172\4\uffff\1\124\1\164\1\145\1\162\1\uffff\1\141\1\164\1\145\1\163\1\155\2\uffff\1\155\1\uffff\1\172\1\163\2\172\1\165\1\162\1\171\1\162\1\172\1\157\1\105\1\145\1\uffff\4\172\7\uffff\1\105\1\151\1\172\1\141\1\151\1\172\1\156\1\172\2\151\1\uffff\1\151\1\uffff\1\105\1\uffff\1\154\1\144\1\156\2\172\1\uffff\1\167\1\121\1\172\4\uffff\1\122\1\157\1\uffff\1\143\1\156\1\uffff\1\164\1\uffff\2\172\1\164\1\121\1\164\1\163\1\172\2\uffff\1\156\1\172\1\uffff\1\172\1\156\1\164\1\163\1\172\3\145\3\172\1\uffff\1\172\1\uffff\1\105\1\uffff\1\141\2\172\1\uffff\3\172\4\uffff\1\121\1\154\5\uffff\2\172\2\uffff"; | ||
2745 | static final String DFA12_acceptS = | ||
2746 | "\37\uffff\1\66\1\67\1\70\1\71\1\72\1\uffff\1\77\1\103\1\104\1\uffff\1\106\1\107\1\110\2\uffff\1\113\1\114\1\115\1\117\1\120\1\uffff\1\114\41\uffff\1\52\1\65\1\53\1\73\1\54\1\74\1\55\1\76\1\56\1\100\1\57\1\101\1\60\1\102\2\uffff\1\66\1\67\1\70\1\71\1\72\1\113\1\116\1\75\1\77\1\103\1\104\1\105\1\106\1\107\1\110\1\111\1\112\1\115\1\117\44\uffff\1\64\1\63\1\61\1\62\4\uffff\1\43\5\uffff\1\46\1\47\1\uffff\1\50\14\uffff\1\51\4\uffff\1\36\1\37\1\40\1\41\1\42\1\44\1\45\12\uffff\1\30\1\uffff\1\31\1\uffff\1\26\5\uffff\1\27\3\uffff\1\32\1\33\1\34\1\35\2\uffff\1\24\2\uffff\1\21\1\uffff\1\20\7\uffff\1\22\1\23\2\uffff\1\25\13\uffff\1\17\1\uffff\1\16\1\uffff\1\10\3\uffff\1\12\3\uffff\1\11\1\13\1\14\1\15\2\uffff\1\3\1\4\1\5\1\6\1\7\2\uffff\1\1\1\2"; | ||
2747 | static final String DFA12_specialS = | ||
2748 | "\1\1\53\uffff\1\0\1\2\u00ef\uffff}>"; | ||
2749 | static final String[] DFA12_transitionS = { | ||
2750 | "\11\62\2\61\2\62\1\61\22\62\1\61\1\26\1\54\2\62\1\56\1\62\1\55\1\37\1\40\1\41\1\42\1\43\1\27\1\30\1\44\12\60\1\31\1\45\1\32\1\33\1\34\2\62\1\20\2\57\1\21\1\35\1\57\1\1\1\57\1\36\2\57\1\7\1\22\1\13\1\57\1\23\2\57\1\24\7\57\1\46\1\62\1\47\1\50\1\57\1\62\1\3\1\57\1\4\1\10\1\11\1\2\2\57\1\25\3\57\1\5\1\57\1\6\1\15\1\57\1\16\1\14\1\17\1\12\5\57\1\51\1\52\1\53\uff82\62", | ||
2751 | "\1\63", | ||
2752 | "\1\66\23\uffff\1\65", | ||
2753 | "\1\67\23\uffff\1\70", | ||
2754 | "\1\73\2\uffff\1\71\5\uffff\1\72", | ||
2755 | "\1\74\7\uffff\1\75\13\uffff\1\76", | ||
2756 | "\1\100\1\uffff\1\77", | ||
2757 | "\1\101", | ||
2758 | "\1\102", | ||
2759 | "\1\106\1\104\4\uffff\1\105\5\uffff\1\103", | ||
2760 | "\1\107", | ||
2761 | "\1\110", | ||
2762 | "\1\111\21\uffff\1\112", | ||
2763 | "\1\113", | ||
2764 | "\1\114", | ||
2765 | "\1\115\11\uffff\1\116", | ||
2766 | "\1\117", | ||
2767 | "\1\120", | ||
2768 | "\1\121", | ||
2769 | "\1\122", | ||
2770 | "\1\123", | ||
2771 | "\1\125\7\uffff\1\124", | ||
2772 | "\1\126", | ||
2773 | "\1\130", | ||
2774 | "\1\132", | ||
2775 | "\1\134", | ||
2776 | "\1\136", | ||
2777 | "\1\140", | ||
2778 | "\1\142", | ||
2779 | "\1\144", | ||
2780 | "\1\145", | ||
2781 | "", | ||
2782 | "", | ||
2783 | "", | ||
2784 | "", | ||
2785 | "", | ||
2786 | "\1\154\4\uffff\1\153", | ||
2787 | "", | ||
2788 | "", | ||
2789 | "", | ||
2790 | "\32\64\4\uffff\1\64\1\uffff\32\64", | ||
2791 | "", | ||
2792 | "", | ||
2793 | "", | ||
2794 | "\0\165", | ||
2795 | "\0\166", | ||
2796 | "", | ||
2797 | "", | ||
2798 | "", | ||
2799 | "", | ||
2800 | "", | ||
2801 | "\1\171", | ||
2802 | "", | ||
2803 | "\1\172", | ||
2804 | "\1\173", | ||
2805 | "\1\174", | ||
2806 | "\1\175", | ||
2807 | "\1\176\6\uffff\1\177", | ||
2808 | "\1\u0080", | ||
2809 | "\1\u0081", | ||
2810 | "\1\u0082\1\u0083", | ||
2811 | "\1\u0084", | ||
2812 | "\1\u0085", | ||
2813 | "\1\u0086", | ||
2814 | "\1\u0087", | ||
2815 | "\1\u0088", | ||
2816 | "\1\u0089", | ||
2817 | "\1\u008a", | ||
2818 | "\1\u008b", | ||
2819 | "\1\u008c", | ||
2820 | "\1\u008d", | ||
2821 | "\1\u008e", | ||
2822 | "\1\u008f", | ||
2823 | "\1\u0090", | ||
2824 | "\1\u0091", | ||
2825 | "\1\u0092", | ||
2826 | "\1\u0093", | ||
2827 | "\1\u0094", | ||
2828 | "\1\u0095", | ||
2829 | "\1\u0096", | ||
2830 | "\1\u0097", | ||
2831 | "\1\u0098", | ||
2832 | "\1\u0099", | ||
2833 | "\1\u009a", | ||
2834 | "\12\64\7\uffff\32\64\4\uffff\1\64\1\uffff\5\64\1\u009b\15\64\1\u009c\6\64", | ||
2835 | "\12\64\7\uffff\32\64\4\uffff\1\64\1\uffff\32\64", | ||
2836 | "", | ||
2837 | "", | ||
2838 | "", | ||
2839 | "", | ||
2840 | "", | ||
2841 | "", | ||
2842 | "", | ||
2843 | "", | ||
2844 | "", | ||
2845 | "", | ||
2846 | "", | ||
2847 | "", | ||
2848 | "", | ||
2849 | "", | ||
2850 | "\12\64\7\uffff\32\64\4\uffff\1\64\1\uffff\32\64", | ||
2851 | "\12\64\7\uffff\32\64\4\uffff\1\64\1\uffff\32\64", | ||
2852 | "", | ||
2853 | "", | ||
2854 | "", | ||
2855 | "", | ||
2856 | "", | ||
2857 | "", | ||
2858 | "", | ||
2859 | "", | ||
2860 | "", | ||
2861 | "", | ||
2862 | "", | ||
2863 | "", | ||
2864 | "", | ||
2865 | "", | ||
2866 | "", | ||
2867 | "", | ||
2868 | "", | ||
2869 | "", | ||
2870 | "", | ||
2871 | "\1\u00a1", | ||
2872 | "\1\u00a2", | ||
2873 | "\1\u00a3", | ||
2874 | "\1\u00a4", | ||
2875 | "\12\64\7\uffff\32\64\4\uffff\1\64\1\uffff\32\64", | ||
2876 | "\1\u00a6", | ||
2877 | "\1\u00a7", | ||
2878 | "\1\u00a8", | ||
2879 | "\1\u00a9", | ||
2880 | "\12\64\7\uffff\32\64\4\uffff\1\64\1\uffff\10\64\1\u00aa\21\64", | ||
2881 | "\12\64\7\uffff\32\64\4\uffff\1\64\1\uffff\32\64", | ||
2882 | "\12\64\7\uffff\32\64\4\uffff\1\64\1\uffff\10\64\1\u00ad\21\64", | ||
2883 | "\1\u00af", | ||
2884 | "\1\u00b0", | ||
2885 | "\1\u00b1", | ||
2886 | "\1\u00b2", | ||
2887 | "\1\u00b3", | ||
2888 | "\1\u00b4", | ||
2889 | "\1\u00b5", | ||
2890 | "\1\u00b6", | ||
2891 | "\1\u00b7", | ||
2892 | "\1\u00b8", | ||
2893 | "\1\u00b9", | ||
2894 | "\1\u00ba", | ||
2895 | "\12\64\7\uffff\32\64\4\uffff\1\64\1\uffff\32\64", | ||
2896 | "\1\u00bc", | ||
2897 | "\1\u00bd", | ||
2898 | "\1\u00be", | ||
2899 | "\1\u00bf", | ||
2900 | "\12\64\7\uffff\32\64\4\uffff\1\64\1\uffff\32\64", | ||
2901 | "\12\64\7\uffff\32\64\4\uffff\1\64\1\uffff\32\64", | ||
2902 | "\12\64\7\uffff\32\64\4\uffff\1\64\1\uffff\32\64", | ||
2903 | "\12\64\7\uffff\32\64\4\uffff\1\64\1\uffff\32\64", | ||
2904 | "\12\64\7\uffff\32\64\4\uffff\1\64\1\uffff\32\64", | ||
2905 | "\12\64\7\uffff\32\64\4\uffff\1\64\1\uffff\32\64", | ||
2906 | "\12\64\7\uffff\32\64\4\uffff\1\64\1\uffff\32\64", | ||
2907 | "", | ||
2908 | "", | ||
2909 | "", | ||
2910 | "", | ||
2911 | "\1\u00c7", | ||
2912 | "\1\u00c8", | ||
2913 | "\1\u00c9", | ||
2914 | "\1\u00ca", | ||
2915 | "", | ||
2916 | "\1\u00cb", | ||
2917 | "\1\u00cc", | ||
2918 | "\1\u00cd", | ||
2919 | "\1\u00ce", | ||
2920 | "\1\u00cf", | ||
2921 | "", | ||
2922 | "", | ||
2923 | "\1\u00d0", | ||
2924 | "", | ||
2925 | "\12\64\7\uffff\32\64\4\uffff\1\64\1\uffff\32\64", | ||
2926 | "\1\u00d2", | ||
2927 | "\12\64\7\uffff\32\64\4\uffff\1\64\1\uffff\32\64", | ||
2928 | "\12\64\7\uffff\32\64\4\uffff\1\u00d4\1\uffff\32\64", | ||
2929 | "\1\u00d6", | ||
2930 | "\1\u00d7\3\uffff\1\u00d8", | ||
2931 | "\1\u00d9", | ||
2932 | "\1\u00da", | ||
2933 | "\12\64\7\uffff\32\64\4\uffff\1\64\1\uffff\32\64", | ||
2934 | "\1\u00dc", | ||
2935 | "\1\u00dd", | ||
2936 | "\1\u00de", | ||
2937 | "", | ||
2938 | "\12\64\7\uffff\32\64\4\uffff\1\64\1\uffff\32\64", | ||
2939 | "\12\64\7\uffff\32\64\4\uffff\1\64\1\uffff\32\64", | ||
2940 | "\12\64\7\uffff\32\64\4\uffff\1\64\1\uffff\32\64", | ||
2941 | "\12\64\7\uffff\32\64\4\uffff\1\64\1\uffff\32\64", | ||
2942 | "", | ||
2943 | "", | ||
2944 | "", | ||
2945 | "", | ||
2946 | "", | ||
2947 | "", | ||
2948 | "", | ||
2949 | "\1\u00e3", | ||
2950 | "\1\u00e4", | ||
2951 | "\12\64\7\uffff\32\64\4\uffff\1\64\1\uffff\32\64", | ||
2952 | "\1\u00e6", | ||
2953 | "\1\u00e7", | ||
2954 | "\12\64\7\uffff\32\64\4\uffff\1\64\1\uffff\32\64", | ||
2955 | "\1\u00e9", | ||
2956 | "\12\64\7\uffff\32\64\4\uffff\1\64\1\uffff\32\64", | ||
2957 | "\1\u00eb", | ||
2958 | "\1\u00ec", | ||
2959 | "", | ||
2960 | "\1\u00ed", | ||
2961 | "", | ||
2962 | "\1\u00ee", | ||
2963 | "", | ||
2964 | "\1\u00ef", | ||
2965 | "\1\u00f0", | ||
2966 | "\1\u00f1", | ||
2967 | "\12\64\7\uffff\32\64\4\uffff\1\64\1\uffff\32\64", | ||
2968 | "\12\64\7\uffff\32\64\4\uffff\1\64\1\uffff\32\64", | ||
2969 | "", | ||
2970 | "\1\u00f4", | ||
2971 | "\1\u00f5", | ||
2972 | "\12\64\7\uffff\32\64\4\uffff\1\64\1\uffff\32\64", | ||
2973 | "", | ||
2974 | "", | ||
2975 | "", | ||
2976 | "", | ||
2977 | "\1\u00f7", | ||
2978 | "\1\u00f8", | ||
2979 | "", | ||
2980 | "\1\u00f9", | ||
2981 | "\1\u00fa", | ||
2982 | "", | ||
2983 | "\1\u00fb", | ||
2984 | "", | ||
2985 | "\1\u00fc", | ||
2986 | "\1\u00fd", | ||
2987 | "\1\u00fe", | ||
2988 | "\1\u00ff", | ||
2989 | "\1\u0100", | ||
2990 | "\1\u0101", | ||
2991 | "\12\64\7\uffff\32\64\4\uffff\1\64\1\uffff\32\64", | ||
2992 | "", | ||
2993 | "", | ||
2994 | "\1\u0103", | ||
2995 | "\12\64\7\uffff\32\64\4\uffff\1\64\1\uffff\32\64", | ||
2996 | "", | ||
2997 | "\12\64\7\uffff\32\64\4\uffff\1\u0105\1\uffff\32\64", | ||
2998 | "\1\u0107", | ||
2999 | "\1\u0108", | ||
3000 | "\1\u0109", | ||
3001 | "\12\64\7\uffff\32\64\4\uffff\1\64\1\uffff\32\64", | ||
3002 | "\1\u010b", | ||
3003 | "\1\u010c", | ||
3004 | "\1\u010d", | ||
3005 | "\12\64\7\uffff\32\64\4\uffff\1\64\1\uffff\32\64", | ||
3006 | "\12\64\7\uffff\32\64\4\uffff\1\64\1\uffff\32\64", | ||
3007 | "\12\64\7\uffff\32\64\4\uffff\1\64\1\uffff\32\64", | ||
3008 | "", | ||
3009 | "\12\64\7\uffff\32\64\4\uffff\1\64\1\uffff\32\64", | ||
3010 | "", | ||
3011 | "\1\u0112", | ||
3012 | "", | ||
3013 | "\1\u0113", | ||
3014 | "\12\64\7\uffff\32\64\4\uffff\1\64\1\uffff\32\64", | ||
3015 | "\12\64\7\uffff\32\64\4\uffff\1\64\1\uffff\32\64", | ||
3016 | "", | ||
3017 | "\12\64\7\uffff\32\64\4\uffff\1\64\1\uffff\32\64", | ||
3018 | "\12\64\7\uffff\32\64\4\uffff\1\64\1\uffff\32\64", | ||
3019 | "\12\64\7\uffff\32\64\4\uffff\1\64\1\uffff\32\64", | ||
3020 | "", | ||
3021 | "", | ||
3022 | "", | ||
3023 | "", | ||
3024 | "\1\u0119", | ||
3025 | "\1\u011a", | ||
3026 | "", | ||
3027 | "", | ||
3028 | "", | ||
3029 | "", | ||
3030 | "", | ||
3031 | "\12\64\7\uffff\32\64\4\uffff\1\64\1\uffff\32\64", | ||
3032 | "\12\64\7\uffff\32\64\4\uffff\1\64\1\uffff\32\64", | ||
3033 | "", | ||
3034 | "" | ||
3035 | }; | ||
3036 | |||
3037 | static final short[] DFA12_eot = DFA.unpackEncodedString(DFA12_eotS); | ||
3038 | static final short[] DFA12_eof = DFA.unpackEncodedString(DFA12_eofS); | ||
3039 | static final char[] DFA12_min = DFA.unpackEncodedStringToUnsignedChars(DFA12_minS); | ||
3040 | static final char[] DFA12_max = DFA.unpackEncodedStringToUnsignedChars(DFA12_maxS); | ||
3041 | static final short[] DFA12_accept = DFA.unpackEncodedString(DFA12_acceptS); | ||
3042 | static final short[] DFA12_special = DFA.unpackEncodedString(DFA12_specialS); | ||
3043 | static final short[][] DFA12_transition; | ||
3044 | |||
3045 | static { | ||
3046 | int numStates = DFA12_transitionS.length; | ||
3047 | DFA12_transition = new short[numStates][]; | ||
3048 | for (int i=0; i<numStates; i++) { | ||
3049 | DFA12_transition[i] = DFA.unpackEncodedString(DFA12_transitionS[i]); | ||
3050 | } | ||
3051 | } | ||
3052 | |||
3053 | class DFA12 extends DFA { | ||
3054 | |||
3055 | public DFA12(BaseRecognizer recognizer) { | ||
3056 | this.recognizer = recognizer; | ||
3057 | this.decisionNumber = 12; | ||
3058 | this.eot = DFA12_eot; | ||
3059 | this.eof = DFA12_eof; | ||
3060 | this.min = DFA12_min; | ||
3061 | this.max = DFA12_max; | ||
3062 | this.accept = DFA12_accept; | ||
3063 | this.special = DFA12_special; | ||
3064 | this.transition = DFA12_transition; | ||
3065 | } | ||
3066 | public String getDescription() { | ||
3067 | return "1:1: Tokens : ( GREATER_EQ | Functional | Abstract | Contains | Maximize | Minimize | Opposite | GREATER | LESS_EQ | Current | Default | Extends | Unknown | NOT_EQ | Extern | Class | Count | Empty | Error | False | Scope | LESS | Else | Must | Only | Prod | Real | Then | True | ADD | DIV | MUL | POW | SUB | Avg | Inf | Int | Max | May | Min | Sum | ExclamationMarkEqualsSign | HyphenMinusGreaterThanSign | FullStopFullStop | ColonHyphenMinus | LessThanSignEqualsSign | EqualsSignEqualsSign | GreaterThanSignEqualsSign | EQ | IN | If | In | ExclamationMark | LeftParenthesis | RightParenthesis | Asterisk | PlusSign | Comma | HyphenMinus | FullStop | Solidus | Colon | Semicolon | LessThanSign | EqualsSign | GreaterThanSign | LeftSquareBracket | RightSquareBracket | CircumflexAccent | LeftCurlyBracket | VerticalLine | RightCurlyBracket | RULE_STRING | RULE_QUOTED_ID | RULE_SL_COMMENT | RULE_ID | RULE_INT | RULE_ML_COMMENT | RULE_WS | RULE_ANY_OTHER );"; | ||
3068 | } | ||
3069 | public int specialStateTransition(int s, IntStream _input) throws NoViableAltException { | ||
3070 | IntStream input = _input; | ||
3071 | int _s = s; | ||
3072 | switch ( s ) { | ||
3073 | case 0 : | ||
3074 | int LA12_44 = input.LA(1); | ||
3075 | |||
3076 | s = -1; | ||
3077 | if ( ((LA12_44>='\u0000' && LA12_44<='\uFFFF')) ) {s = 117;} | ||
3078 | |||
3079 | else s = 50; | ||
3080 | |||
3081 | if ( s>=0 ) return s; | ||
3082 | break; | ||
3083 | case 1 : | ||
3084 | int LA12_0 = input.LA(1); | ||
3085 | |||
3086 | s = -1; | ||
3087 | if ( (LA12_0=='G') ) {s = 1;} | ||
3088 | |||
3089 | else if ( (LA12_0=='f') ) {s = 2;} | ||
3090 | |||
3091 | else if ( (LA12_0=='a') ) {s = 3;} | ||
3092 | |||
3093 | else if ( (LA12_0=='c') ) {s = 4;} | ||
3094 | |||
3095 | else if ( (LA12_0=='m') ) {s = 5;} | ||
3096 | |||
3097 | else if ( (LA12_0=='o') ) {s = 6;} | ||
3098 | |||
3099 | else if ( (LA12_0=='L') ) {s = 7;} | ||
3100 | |||
3101 | else if ( (LA12_0=='d') ) {s = 8;} | ||
3102 | |||
3103 | else if ( (LA12_0=='e') ) {s = 9;} | ||
3104 | |||
3105 | else if ( (LA12_0=='u') ) {s = 10;} | ||
3106 | |||
3107 | else if ( (LA12_0=='N') ) {s = 11;} | ||
3108 | |||
3109 | else if ( (LA12_0=='s') ) {s = 12;} | ||
3110 | |||
3111 | else if ( (LA12_0=='p') ) {s = 13;} | ||
3112 | |||
3113 | else if ( (LA12_0=='r') ) {s = 14;} | ||
3114 | |||
3115 | else if ( (LA12_0=='t') ) {s = 15;} | ||
3116 | |||
3117 | else if ( (LA12_0=='A') ) {s = 16;} | ||
3118 | |||
3119 | else if ( (LA12_0=='D') ) {s = 17;} | ||
3120 | |||
3121 | else if ( (LA12_0=='M') ) {s = 18;} | ||
3122 | |||
3123 | else if ( (LA12_0=='P') ) {s = 19;} | ||
3124 | |||
3125 | else if ( (LA12_0=='S') ) {s = 20;} | ||
3126 | |||
3127 | else if ( (LA12_0=='i') ) {s = 21;} | ||
3128 | |||
3129 | else if ( (LA12_0=='!') ) {s = 22;} | ||
3130 | |||
3131 | else if ( (LA12_0=='-') ) {s = 23;} | ||
3132 | |||
3133 | else if ( (LA12_0=='.') ) {s = 24;} | ||
3134 | |||
3135 | else if ( (LA12_0==':') ) {s = 25;} | ||
3136 | |||
3137 | else if ( (LA12_0=='<') ) {s = 26;} | ||
3138 | |||
3139 | else if ( (LA12_0=='=') ) {s = 27;} | ||
3140 | |||
3141 | else if ( (LA12_0=='>') ) {s = 28;} | ||
3142 | |||
3143 | else if ( (LA12_0=='E') ) {s = 29;} | ||
3144 | |||
3145 | else if ( (LA12_0=='I') ) {s = 30;} | ||
3146 | |||
3147 | else if ( (LA12_0=='(') ) {s = 31;} | ||
3148 | |||
3149 | else if ( (LA12_0==')') ) {s = 32;} | ||
3150 | |||
3151 | else if ( (LA12_0=='*') ) {s = 33;} | ||
3152 | |||
3153 | else if ( (LA12_0=='+') ) {s = 34;} | ||
3154 | |||
3155 | else if ( (LA12_0==',') ) {s = 35;} | ||
3156 | |||
3157 | else if ( (LA12_0=='/') ) {s = 36;} | ||
3158 | |||
3159 | else if ( (LA12_0==';') ) {s = 37;} | ||
3160 | |||
3161 | else if ( (LA12_0=='[') ) {s = 38;} | ||
3162 | |||
3163 | else if ( (LA12_0==']') ) {s = 39;} | ||
3164 | |||
3165 | else if ( (LA12_0=='^') ) {s = 40;} | ||
3166 | |||
3167 | else if ( (LA12_0=='{') ) {s = 41;} | ||
3168 | |||
3169 | else if ( (LA12_0=='|') ) {s = 42;} | ||
3170 | |||
3171 | else if ( (LA12_0=='}') ) {s = 43;} | ||
3172 | |||
3173 | else if ( (LA12_0=='\"') ) {s = 44;} | ||
3174 | |||
3175 | else if ( (LA12_0=='\'') ) {s = 45;} | ||
3176 | |||
3177 | else if ( (LA12_0=='%') ) {s = 46;} | ||
3178 | |||
3179 | else if ( ((LA12_0>='B' && LA12_0<='C')||LA12_0=='F'||LA12_0=='H'||(LA12_0>='J' && LA12_0<='K')||LA12_0=='O'||(LA12_0>='Q' && LA12_0<='R')||(LA12_0>='T' && LA12_0<='Z')||LA12_0=='_'||LA12_0=='b'||(LA12_0>='g' && LA12_0<='h')||(LA12_0>='j' && LA12_0<='l')||LA12_0=='n'||LA12_0=='q'||(LA12_0>='v' && LA12_0<='z')) ) {s = 47;} | ||
3180 | |||
3181 | else if ( ((LA12_0>='0' && LA12_0<='9')) ) {s = 48;} | ||
3182 | |||
3183 | else if ( ((LA12_0>='\t' && LA12_0<='\n')||LA12_0=='\r'||LA12_0==' ') ) {s = 49;} | ||
3184 | |||
3185 | else if ( ((LA12_0>='\u0000' && LA12_0<='\b')||(LA12_0>='\u000B' && LA12_0<='\f')||(LA12_0>='\u000E' && LA12_0<='\u001F')||(LA12_0>='#' && LA12_0<='$')||LA12_0=='&'||(LA12_0>='?' && LA12_0<='@')||LA12_0=='\\'||LA12_0=='`'||(LA12_0>='~' && LA12_0<='\uFFFF')) ) {s = 50;} | ||
3186 | |||
3187 | if ( s>=0 ) return s; | ||
3188 | break; | ||
3189 | case 2 : | ||
3190 | int LA12_45 = input.LA(1); | ||
3191 | |||
3192 | s = -1; | ||
3193 | if ( ((LA12_45>='\u0000' && LA12_45<='\uFFFF')) ) {s = 118;} | ||
3194 | |||
3195 | else s = 50; | ||
3196 | |||
3197 | if ( s>=0 ) return s; | ||
3198 | break; | ||
3199 | } | ||
3200 | NoViableAltException nvae = | ||
3201 | new NoViableAltException(getDescription(), 12, _s, input); | ||
3202 | error(nvae); | ||
3203 | throw nvae; | ||
3204 | } | ||
3205 | } | ||
3206 | |||
3207 | |||
3208 | } \ No newline at end of file | ||
diff --git a/Application/org.eclipse.viatra.solver.language.ide/src-gen/org/eclipse/viatra/solver/language/ide/contentassist/antlr/lexer/InternalSolverLanguageLexer.tokens b/Application/org.eclipse.viatra.solver.language.ide/src-gen/org/eclipse/viatra/solver/language/ide/contentassist/antlr/lexer/InternalSolverLanguageLexer.tokens new file mode 100644 index 00000000..133cc9d6 --- /dev/null +++ b/Application/org.eclipse.viatra.solver.language.ide/src-gen/org/eclipse/viatra/solver/language/ide/contentassist/antlr/lexer/InternalSolverLanguageLexer.tokens | |||
@@ -0,0 +1,83 @@ | |||
1 | ADD=33 | ||
2 | Abstract=6 | ||
3 | Asterisk=59 | ||
4 | Avg=38 | ||
5 | CircumflexAccent=72 | ||
6 | Class=19 | ||
7 | Colon=65 | ||
8 | ColonHyphenMinus=48 | ||
9 | Comma=61 | ||
10 | Contains=7 | ||
11 | Count=20 | ||
12 | Current=13 | ||
13 | DIV=34 | ||
14 | Default=14 | ||
15 | EQ=52 | ||
16 | Else=26 | ||
17 | Empty=21 | ||
18 | EqualsSign=68 | ||
19 | EqualsSignEqualsSign=50 | ||
20 | Error=22 | ||
21 | ExclamationMark=56 | ||
22 | ExclamationMarkEqualsSign=45 | ||
23 | Extends=15 | ||
24 | Extern=18 | ||
25 | False=23 | ||
26 | FullStop=63 | ||
27 | FullStopFullStop=47 | ||
28 | Functional=5 | ||
29 | GREATER=11 | ||
30 | GREATER_EQ=4 | ||
31 | GreaterThanSign=69 | ||
32 | GreaterThanSignEqualsSign=51 | ||
33 | HyphenMinus=62 | ||
34 | HyphenMinusGreaterThanSign=46 | ||
35 | IN=53 | ||
36 | If=54 | ||
37 | In=55 | ||
38 | Inf=39 | ||
39 | Int=40 | ||
40 | LESS=25 | ||
41 | LESS_EQ=12 | ||
42 | LeftCurlyBracket=73 | ||
43 | LeftParenthesis=57 | ||
44 | LeftSquareBracket=70 | ||
45 | LessThanSign=67 | ||
46 | LessThanSignEqualsSign=49 | ||
47 | MUL=35 | ||
48 | Max=41 | ||
49 | Maximize=8 | ||
50 | May=42 | ||
51 | Min=43 | ||
52 | Minimize=9 | ||
53 | Must=27 | ||
54 | NOT_EQ=17 | ||
55 | Only=28 | ||
56 | Opposite=10 | ||
57 | POW=36 | ||
58 | PlusSign=60 | ||
59 | Prod=29 | ||
60 | RULE_ANY_OTHER=86 | ||
61 | RULE_FULL_STOP=81 | ||
62 | RULE_ID=82 | ||
63 | RULE_INT=83 | ||
64 | RULE_ML_COMMENT=84 | ||
65 | RULE_QUOTED_ID=77 | ||
66 | RULE_REFLEXIVE_TRANSITIVE_CLOSURE=80 | ||
67 | RULE_SL_COMMENT=78 | ||
68 | RULE_STRING=76 | ||
69 | RULE_TRANSITIVE_CLOSURE=79 | ||
70 | RULE_WS=85 | ||
71 | Real=30 | ||
72 | RightCurlyBracket=75 | ||
73 | RightParenthesis=58 | ||
74 | RightSquareBracket=71 | ||
75 | SUB=37 | ||
76 | Scope=24 | ||
77 | Semicolon=66 | ||
78 | Solidus=64 | ||
79 | Sum=44 | ||
80 | Then=31 | ||
81 | True=32 | ||
82 | Unknown=16 | ||
83 | VerticalLine=74 | ||