diff options
author | 2020-05-08 21:02:33 +0200 | |
---|---|---|
committer | 2020-05-08 21:02:33 +0200 | |
commit | 771e3773bb7ebbf6712724cb2b248467c9cc2e3c (patch) | |
tree | b1724af24b9c583b2780c7a2fe76e76fd174359d /Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/parser/antlr/internal | |
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/src-gen/org/eclipse/viatra/solver/language/parser/antlr/internal')
-rw-r--r-- | Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/parser/antlr/internal/InternalSolverLanguage.tokens | 131 | ||||
-rw-r--r-- | Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/parser/antlr/internal/InternalSolverLanguageLexer.java | 2805 | ||||
-rw-r--r-- | Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/parser/antlr/internal/InternalSolverLanguageParser.g (renamed from Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/parser/antlr/internal/InternalSolverLanguage.g) | 347 | ||||
-rw-r--r-- | Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/parser/antlr/internal/InternalSolverLanguageParser.java | 8379 | ||||
-rw-r--r-- | Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/parser/antlr/internal/InternalSolverLanguageParser.tokens | 83 |
5 files changed, 3809 insertions, 7936 deletions
diff --git a/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/parser/antlr/internal/InternalSolverLanguage.tokens b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/parser/antlr/internal/InternalSolverLanguage.tokens deleted file mode 100644 index 1cf5b64f..00000000 --- a/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/parser/antlr/internal/InternalSolverLanguage.tokens +++ /dev/null | |||
@@ -1,131 +0,0 @@ | |||
1 | '!'=60 | ||
2 | '!='=52 | ||
3 | '('=33 | ||
4 | ')'=34 | ||
5 | '*'=35 | ||
6 | '+'=56 | ||
7 | ','=28 | ||
8 | '-'=57 | ||
9 | '->'=27 | ||
10 | '.'=22 | ||
11 | '..'=37 | ||
12 | '/'=58 | ||
13 | ':'=15 | ||
14 | ':-'=16 | ||
15 | ';'=26 | ||
16 | '<'=53 | ||
17 | '<='=48 | ||
18 | '='=17 | ||
19 | '=='=47 | ||
20 | '>'=54 | ||
21 | '>='=49 | ||
22 | '['=36 | ||
23 | ']'=38 | ||
24 | '^'=59 | ||
25 | 'abstract'=41 | ||
26 | 'avg'=67 | ||
27 | 'class'=42 | ||
28 | 'contains'=44 | ||
29 | 'count'=29 | ||
30 | 'current'=63 | ||
31 | 'default'=20 | ||
32 | 'else'=25 | ||
33 | 'empty'=40 | ||
34 | 'error'=19 | ||
35 | 'extends'=43 | ||
36 | 'extern'=21 | ||
37 | 'false'=71 | ||
38 | 'functional'=18 | ||
39 | 'if'=23 | ||
40 | 'in'=55 | ||
41 | 'inf'=39 | ||
42 | 'int'=50 | ||
43 | 'max'=69 | ||
44 | 'maximize'=74 | ||
45 | 'may'=61 | ||
46 | 'min'=68 | ||
47 | 'minimize'=73 | ||
48 | 'must'=62 | ||
49 | 'only'=64 | ||
50 | 'opposite'=45 | ||
51 | 'prod'=66 | ||
52 | 'real'=51 | ||
53 | 'scope'=46 | ||
54 | 'sum'=65 | ||
55 | 'then'=24 | ||
56 | 'true'=70 | ||
57 | 'unknown'=72 | ||
58 | '{'=30 | ||
59 | '|'=32 | ||
60 | '}'=31 | ||
61 | RULE_ANY_OTHER=14 | ||
62 | RULE_DOT=4 | ||
63 | RULE_ID=8 | ||
64 | RULE_INT=9 | ||
65 | RULE_ML_COMMENT=11 | ||
66 | RULE_PLUS=6 | ||
67 | RULE_QUOTED_ID=10 | ||
68 | RULE_SL_COMMENT=12 | ||
69 | RULE_STAR=5 | ||
70 | RULE_STRING=7 | ||
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/src-gen/org/eclipse/viatra/solver/language/parser/antlr/internal/InternalSolverLanguageLexer.java b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/parser/antlr/internal/InternalSolverLanguageLexer.java deleted file mode 100644 index 21e5bac9..00000000 --- a/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/parser/antlr/internal/InternalSolverLanguageLexer.java +++ /dev/null | |||
@@ -1,2805 +0,0 @@ | |||
1 | package org.eclipse.viatra.solver.language.parser.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.parser.antlr.Lexer; | ||
6 | |||
7 | |||
8 | import org.antlr.runtime.*; | ||
9 | import java.util.Stack; | ||
10 | import java.util.List; | ||
11 | import java.util.ArrayList; | ||
12 | |||
13 | @SuppressWarnings("all") | ||
14 | public class InternalSolverLanguageLexer extends Lexer { | ||
15 | public static final int 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=5; | ||
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=8; | ||
34 | public static final int RULE_QUOTED_ID=10; | ||
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=9; | ||
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=7; | ||
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=6; | ||
67 | public static final int T__36=36; | ||
68 | public static final int T__73=73; | ||
69 | public static final int RULE_DOT=4; | ||
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 | |||
134 | state.type = _type; | ||
135 | state.channel = _channel; | ||
136 | } | ||
137 | finally { | ||
138 | } | ||
139 | } | ||
140 | // $ANTLR end "T__16" | ||
141 | |||
142 | // $ANTLR start "T__17" | ||
143 | public final void mT__17() throws RecognitionException { | ||
144 | try { | ||
145 | int _type = T__17; | ||
146 | int _channel = DEFAULT_TOKEN_CHANNEL; | ||
147 | // InternalSolverLanguage.g:13:7: ( '=' ) | ||
148 | // InternalSolverLanguage.g:13:9: '=' | ||
149 | { | ||
150 | match('='); | ||
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: ( 'functional' ) | ||
168 | // InternalSolverLanguage.g:14:9: 'functional' | ||
169 | { | ||
170 | match("functional"); | ||
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: ( 'error' ) | ||
189 | // InternalSolverLanguage.g:15:9: 'error' | ||
190 | { | ||
191 | match("error"); | ||
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: ( 'default' ) | ||
210 | // InternalSolverLanguage.g:16:9: 'default' | ||
211 | { | ||
212 | match("default"); | ||
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: ( 'extern' ) | ||
231 | // InternalSolverLanguage.g:17:9: 'extern' | ||
232 | { | ||
233 | match("extern"); | ||
234 | |||
235 | |||
236 | } | ||
237 | |||
238 | state.type = _type; | ||
239 | state.channel = _channel; | ||
240 | } | ||
241 | finally { | ||
242 | } | ||
243 | } | ||
244 | // $ANTLR end "T__21" | ||
245 | |||
246 | // $ANTLR start "T__22" | ||
247 | public final void mT__22() throws RecognitionException { | ||
248 | try { | ||
249 | int _type = T__22; | ||
250 | int _channel = DEFAULT_TOKEN_CHANNEL; | ||
251 | // InternalSolverLanguage.g:18:7: ( '.' ) | ||
252 | // InternalSolverLanguage.g:18:9: '.' | ||
253 | { | ||
254 | match('.'); | ||
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: ( 'if' ) | ||
272 | // InternalSolverLanguage.g:19:9: 'if' | ||
273 | { | ||
274 | match("if"); | ||
275 | |||
276 | |||
277 | } | ||
278 | |||
279 | state.type = _type; | ||
280 | state.channel = _channel; | ||
281 | } | ||
282 | finally { | ||
283 | } | ||
284 | } | ||
285 | // $ANTLR end "T__23" | ||
286 | |||
287 | // $ANTLR start "T__24" | ||
288 | public final void mT__24() throws RecognitionException { | ||
289 | try { | ||
290 | int _type = T__24; | ||
291 | int _channel = DEFAULT_TOKEN_CHANNEL; | ||
292 | // InternalSolverLanguage.g:20:7: ( 'then' ) | ||
293 | // InternalSolverLanguage.g:20:9: 'then' | ||
294 | { | ||
295 | match("then"); | ||
296 | |||
297 | |||
298 | } | ||
299 | |||
300 | state.type = _type; | ||
301 | state.channel = _channel; | ||
302 | } | ||
303 | finally { | ||
304 | } | ||
305 | } | ||
306 | // $ANTLR end "T__24" | ||
307 | |||
308 | // $ANTLR start "T__25" | ||
309 | public final void mT__25() throws RecognitionException { | ||
310 | try { | ||
311 | int _type = T__25; | ||
312 | int _channel = DEFAULT_TOKEN_CHANNEL; | ||
313 | // InternalSolverLanguage.g:21:7: ( 'else' ) | ||
314 | // InternalSolverLanguage.g:21:9: 'else' | ||
315 | { | ||
316 | match("else"); | ||
317 | |||
318 | |||
319 | } | ||
320 | |||
321 | state.type = _type; | ||
322 | state.channel = _channel; | ||
323 | } | ||
324 | finally { | ||
325 | } | ||
326 | } | ||
327 | // $ANTLR end "T__25" | ||
328 | |||
329 | // $ANTLR start "T__26" | ||
330 | public final void mT__26() throws RecognitionException { | ||
331 | try { | ||
332 | int _type = T__26; | ||
333 | int _channel = DEFAULT_TOKEN_CHANNEL; | ||
334 | // InternalSolverLanguage.g:22:7: ( ';' ) | ||
335 | // InternalSolverLanguage.g:22:9: ';' | ||
336 | { | ||
337 | match(';'); | ||
338 | |||
339 | } | ||
340 | |||
341 | state.type = _type; | ||
342 | state.channel = _channel; | ||
343 | } | ||
344 | finally { | ||
345 | } | ||
346 | } | ||
347 | // $ANTLR end "T__26" | ||
348 | |||
349 | // $ANTLR start "T__27" | ||
350 | public final void mT__27() throws RecognitionException { | ||
351 | try { | ||
352 | int _type = T__27; | ||
353 | int _channel = DEFAULT_TOKEN_CHANNEL; | ||
354 | // InternalSolverLanguage.g:23:7: ( '->' ) | ||
355 | // InternalSolverLanguage.g:23:9: '->' | ||
356 | { | ||
357 | match("->"); | ||
358 | |||
359 | |||
360 | } | ||
361 | |||
362 | state.type = _type; | ||
363 | state.channel = _channel; | ||
364 | } | ||
365 | finally { | ||
366 | } | ||
367 | } | ||
368 | // $ANTLR end "T__27" | ||
369 | |||
370 | // $ANTLR start "T__28" | ||
371 | public final void mT__28() throws RecognitionException { | ||
372 | try { | ||
373 | int _type = T__28; | ||
374 | int _channel = DEFAULT_TOKEN_CHANNEL; | ||
375 | // InternalSolverLanguage.g:24:7: ( ',' ) | ||
376 | // InternalSolverLanguage.g:24:9: ',' | ||
377 | { | ||
378 | match(','); | ||
379 | |||
380 | } | ||
381 | |||
382 | state.type = _type; | ||
383 | state.channel = _channel; | ||
384 | } | ||
385 | finally { | ||
386 | } | ||
387 | } | ||
388 | // $ANTLR end "T__28" | ||
389 | |||
390 | // $ANTLR start "T__29" | ||
391 | public final void mT__29() throws RecognitionException { | ||
392 | try { | ||
393 | int _type = T__29; | ||
394 | int _channel = DEFAULT_TOKEN_CHANNEL; | ||
395 | // InternalSolverLanguage.g:25:7: ( 'count' ) | ||
396 | // InternalSolverLanguage.g:25:9: 'count' | ||
397 | { | ||
398 | match("count"); | ||
399 | |||
400 | |||
401 | } | ||
402 | |||
403 | state.type = _type; | ||
404 | state.channel = _channel; | ||
405 | } | ||
406 | finally { | ||
407 | } | ||
408 | } | ||
409 | // $ANTLR end "T__29" | ||
410 | |||
411 | // $ANTLR start "T__30" | ||
412 | public final void mT__30() throws RecognitionException { | ||
413 | try { | ||
414 | int _type = T__30; | ||
415 | int _channel = DEFAULT_TOKEN_CHANNEL; | ||
416 | // InternalSolverLanguage.g:26:7: ( '{' ) | ||
417 | // InternalSolverLanguage.g:26:9: '{' | ||
418 | { | ||
419 | match('{'); | ||
420 | |||
421 | } | ||
422 | |||
423 | state.type = _type; | ||
424 | state.channel = _channel; | ||
425 | } | ||
426 | finally { | ||
427 | } | ||
428 | } | ||
429 | // $ANTLR end "T__30" | ||
430 | |||
431 | // $ANTLR start "T__31" | ||
432 | public final void mT__31() throws RecognitionException { | ||
433 | try { | ||
434 | int _type = T__31; | ||
435 | int _channel = DEFAULT_TOKEN_CHANNEL; | ||
436 | // InternalSolverLanguage.g:27:7: ( '}' ) | ||
437 | // InternalSolverLanguage.g:27:9: '}' | ||
438 | { | ||
439 | match('}'); | ||
440 | |||
441 | } | ||
442 | |||
443 | state.type = _type; | ||
444 | state.channel = _channel; | ||
445 | } | ||
446 | finally { | ||
447 | } | ||
448 | } | ||
449 | // $ANTLR end "T__31" | ||
450 | |||
451 | // $ANTLR start "T__32" | ||
452 | public final void mT__32() throws RecognitionException { | ||
453 | try { | ||
454 | int _type = T__32; | ||
455 | int _channel = DEFAULT_TOKEN_CHANNEL; | ||
456 | // InternalSolverLanguage.g:28:7: ( '|' ) | ||
457 | // InternalSolverLanguage.g:28:9: '|' | ||
458 | { | ||
459 | match('|'); | ||
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: ( '(' ) | ||
477 | // InternalSolverLanguage.g:29:9: '(' | ||
478 | { | ||
479 | match('('); | ||
480 | |||
481 | } | ||
482 | |||
483 | state.type = _type; | ||
484 | state.channel = _channel; | ||
485 | } | ||
486 | finally { | ||
487 | } | ||
488 | } | ||
489 | // $ANTLR end "T__33" | ||
490 | |||
491 | // $ANTLR start "T__34" | ||
492 | public final void mT__34() throws RecognitionException { | ||
493 | try { | ||
494 | int _type = T__34; | ||
495 | int _channel = DEFAULT_TOKEN_CHANNEL; | ||
496 | // InternalSolverLanguage.g:30:7: ( ')' ) | ||
497 | // InternalSolverLanguage.g:30:9: ')' | ||
498 | { | ||
499 | match(')'); | ||
500 | |||
501 | } | ||
502 | |||
503 | state.type = _type; | ||
504 | state.channel = _channel; | ||
505 | } | ||
506 | finally { | ||
507 | } | ||
508 | } | ||
509 | // $ANTLR end "T__34" | ||
510 | |||
511 | // $ANTLR start "T__35" | ||
512 | public final void mT__35() throws RecognitionException { | ||
513 | try { | ||
514 | int _type = T__35; | ||
515 | int _channel = DEFAULT_TOKEN_CHANNEL; | ||
516 | // InternalSolverLanguage.g:31:7: ( '*' ) | ||
517 | // InternalSolverLanguage.g:31:9: '*' | ||
518 | { | ||
519 | match('*'); | ||
520 | |||
521 | } | ||
522 | |||
523 | state.type = _type; | ||
524 | state.channel = _channel; | ||
525 | } | ||
526 | finally { | ||
527 | } | ||
528 | } | ||
529 | // $ANTLR end "T__35" | ||
530 | |||
531 | // $ANTLR start "T__36" | ||
532 | public final void mT__36() throws RecognitionException { | ||
533 | try { | ||
534 | int _type = T__36; | ||
535 | int _channel = DEFAULT_TOKEN_CHANNEL; | ||
536 | // InternalSolverLanguage.g:32:7: ( '[' ) | ||
537 | // InternalSolverLanguage.g:32:9: '[' | ||
538 | { | ||
539 | match('['); | ||
540 | |||
541 | } | ||
542 | |||
543 | state.type = _type; | ||
544 | state.channel = _channel; | ||
545 | } | ||
546 | finally { | ||
547 | } | ||
548 | } | ||
549 | // $ANTLR end "T__36" | ||
550 | |||
551 | // $ANTLR start "T__37" | ||
552 | public final void mT__37() throws RecognitionException { | ||
553 | try { | ||
554 | int _type = T__37; | ||
555 | int _channel = DEFAULT_TOKEN_CHANNEL; | ||
556 | // InternalSolverLanguage.g:33:7: ( '..' ) | ||
557 | // InternalSolverLanguage.g:33:9: '..' | ||
558 | { | ||
559 | match(".."); | ||
560 | |||
561 | |||
562 | } | ||
563 | |||
564 | state.type = _type; | ||
565 | state.channel = _channel; | ||
566 | } | ||
567 | finally { | ||
568 | } | ||
569 | } | ||
570 | // $ANTLR end "T__37" | ||
571 | |||
572 | // $ANTLR start "T__38" | ||
573 | public final void mT__38() throws RecognitionException { | ||
574 | try { | ||
575 | int _type = T__38; | ||
576 | int _channel = DEFAULT_TOKEN_CHANNEL; | ||
577 | // InternalSolverLanguage.g:34:7: ( ']' ) | ||
578 | // InternalSolverLanguage.g:34:9: ']' | ||
579 | { | ||
580 | match(']'); | ||
581 | |||
582 | } | ||
583 | |||
584 | state.type = _type; | ||
585 | state.channel = _channel; | ||
586 | } | ||
587 | finally { | ||
588 | } | ||
589 | } | ||
590 | // $ANTLR end "T__38" | ||
591 | |||
592 | // $ANTLR start "T__39" | ||
593 | public final void mT__39() throws RecognitionException { | ||
594 | try { | ||
595 | int _type = T__39; | ||
596 | int _channel = DEFAULT_TOKEN_CHANNEL; | ||
597 | // InternalSolverLanguage.g:35:7: ( 'inf' ) | ||
598 | // InternalSolverLanguage.g:35:9: 'inf' | ||
599 | { | ||
600 | match("inf"); | ||
601 | |||
602 | |||
603 | } | ||
604 | |||
605 | state.type = _type; | ||
606 | state.channel = _channel; | ||
607 | } | ||
608 | finally { | ||
609 | } | ||
610 | } | ||
611 | // $ANTLR end "T__39" | ||
612 | |||
613 | // $ANTLR start "T__40" | ||
614 | public final void mT__40() throws RecognitionException { | ||
615 | try { | ||
616 | int _type = T__40; | ||
617 | int _channel = DEFAULT_TOKEN_CHANNEL; | ||
618 | // InternalSolverLanguage.g:36:7: ( 'empty' ) | ||
619 | // InternalSolverLanguage.g:36:9: 'empty' | ||
620 | { | ||
621 | match("empty"); | ||
622 | |||
623 | |||
624 | } | ||
625 | |||
626 | state.type = _type; | ||
627 | state.channel = _channel; | ||
628 | } | ||
629 | finally { | ||
630 | } | ||
631 | } | ||
632 | // $ANTLR end "T__40" | ||
633 | |||
634 | // $ANTLR start "T__41" | ||
635 | public final void mT__41() throws RecognitionException { | ||
636 | try { | ||
637 | int _type = T__41; | ||
638 | int _channel = DEFAULT_TOKEN_CHANNEL; | ||
639 | // InternalSolverLanguage.g:37:7: ( 'abstract' ) | ||
640 | // InternalSolverLanguage.g:37:9: 'abstract' | ||
641 | { | ||
642 | match("abstract"); | ||
643 | |||
644 | |||
645 | } | ||
646 | |||
647 | state.type = _type; | ||
648 | state.channel = _channel; | ||
649 | } | ||
650 | finally { | ||
651 | } | ||
652 | } | ||
653 | // $ANTLR end "T__41" | ||
654 | |||
655 | // $ANTLR start "T__42" | ||
656 | public final void mT__42() throws RecognitionException { | ||
657 | try { | ||
658 | int _type = T__42; | ||
659 | int _channel = DEFAULT_TOKEN_CHANNEL; | ||
660 | // InternalSolverLanguage.g:38:7: ( 'class' ) | ||
661 | // InternalSolverLanguage.g:38:9: 'class' | ||
662 | { | ||
663 | match("class"); | ||
664 | |||
665 | |||
666 | } | ||
667 | |||
668 | state.type = _type; | ||
669 | state.channel = _channel; | ||
670 | } | ||
671 | finally { | ||
672 | } | ||
673 | } | ||
674 | // $ANTLR end "T__42" | ||
675 | |||
676 | // $ANTLR start "T__43" | ||
677 | public final void mT__43() throws RecognitionException { | ||
678 | try { | ||
679 | int _type = T__43; | ||
680 | int _channel = DEFAULT_TOKEN_CHANNEL; | ||
681 | // InternalSolverLanguage.g:39:7: ( 'extends' ) | ||
682 | // InternalSolverLanguage.g:39:9: 'extends' | ||
683 | { | ||
684 | match("extends"); | ||
685 | |||
686 | |||
687 | } | ||
688 | |||
689 | state.type = _type; | ||
690 | state.channel = _channel; | ||
691 | } | ||
692 | finally { | ||
693 | } | ||
694 | } | ||
695 | // $ANTLR end "T__43" | ||
696 | |||
697 | // $ANTLR start "T__44" | ||
698 | public final void mT__44() throws RecognitionException { | ||
699 | try { | ||
700 | int _type = T__44; | ||
701 | int _channel = DEFAULT_TOKEN_CHANNEL; | ||
702 | // InternalSolverLanguage.g:40:7: ( 'contains' ) | ||
703 | // InternalSolverLanguage.g:40:9: 'contains' | ||
704 | { | ||
705 | match("contains"); | ||
706 | |||
707 | |||
708 | } | ||
709 | |||
710 | state.type = _type; | ||
711 | state.channel = _channel; | ||
712 | } | ||
713 | finally { | ||
714 | } | ||
715 | } | ||
716 | // $ANTLR end "T__44" | ||
717 | |||
718 | // $ANTLR start "T__45" | ||
719 | public final void mT__45() throws RecognitionException { | ||
720 | try { | ||
721 | int _type = T__45; | ||
722 | int _channel = DEFAULT_TOKEN_CHANNEL; | ||
723 | // InternalSolverLanguage.g:41:7: ( 'opposite' ) | ||
724 | // InternalSolverLanguage.g:41:9: 'opposite' | ||
725 | { | ||
726 | match("opposite"); | ||
727 | |||
728 | |||
729 | } | ||
730 | |||
731 | state.type = _type; | ||
732 | state.channel = _channel; | ||
733 | } | ||
734 | finally { | ||
735 | } | ||
736 | } | ||
737 | // $ANTLR end "T__45" | ||
738 | |||
739 | // $ANTLR start "T__46" | ||
740 | public final void mT__46() throws RecognitionException { | ||
741 | try { | ||
742 | int _type = T__46; | ||
743 | int _channel = DEFAULT_TOKEN_CHANNEL; | ||
744 | // InternalSolverLanguage.g:42:7: ( 'scope' ) | ||
745 | // InternalSolverLanguage.g:42:9: 'scope' | ||
746 | { | ||
747 | match("scope"); | ||
748 | |||
749 | |||
750 | } | ||
751 | |||
752 | state.type = _type; | ||
753 | state.channel = _channel; | ||
754 | } | ||
755 | finally { | ||
756 | } | ||
757 | } | ||
758 | // $ANTLR end "T__46" | ||
759 | |||
760 | // $ANTLR start "T__47" | ||
761 | public final void mT__47() throws RecognitionException { | ||
762 | try { | ||
763 | int _type = T__47; | ||
764 | int _channel = DEFAULT_TOKEN_CHANNEL; | ||
765 | // InternalSolverLanguage.g:43:7: ( '==' ) | ||
766 | // InternalSolverLanguage.g:43:9: '==' | ||
767 | { | ||
768 | match("=="); | ||
769 | |||
770 | |||
771 | } | ||
772 | |||
773 | state.type = _type; | ||
774 | state.channel = _channel; | ||
775 | } | ||
776 | finally { | ||
777 | } | ||
778 | } | ||
779 | // $ANTLR end "T__47" | ||
780 | |||
781 | // $ANTLR start "T__48" | ||
782 | public final void mT__48() throws RecognitionException { | ||
783 | try { | ||
784 | int _type = T__48; | ||
785 | int _channel = DEFAULT_TOKEN_CHANNEL; | ||
786 | // InternalSolverLanguage.g:44:7: ( '<=' ) | ||
787 | // InternalSolverLanguage.g:44:9: '<=' | ||
788 | { | ||
789 | match("<="); | ||
790 | |||
791 | |||
792 | } | ||
793 | |||
794 | state.type = _type; | ||
795 | state.channel = _channel; | ||
796 | } | ||
797 | finally { | ||
798 | } | ||
799 | } | ||
800 | // $ANTLR end "T__48" | ||
801 | |||
802 | // $ANTLR start "T__49" | ||
803 | public final void mT__49() throws RecognitionException { | ||
804 | try { | ||
805 | int _type = T__49; | ||
806 | int _channel = DEFAULT_TOKEN_CHANNEL; | ||
807 | // InternalSolverLanguage.g:45:7: ( '>=' ) | ||
808 | // InternalSolverLanguage.g:45:9: '>=' | ||
809 | { | ||
810 | match(">="); | ||
811 | |||
812 | |||
813 | } | ||
814 | |||
815 | state.type = _type; | ||
816 | state.channel = _channel; | ||
817 | } | ||
818 | finally { | ||
819 | } | ||
820 | } | ||
821 | // $ANTLR end "T__49" | ||
822 | |||
823 | // $ANTLR start "T__50" | ||
824 | public final void mT__50() throws RecognitionException { | ||
825 | try { | ||
826 | int _type = T__50; | ||
827 | int _channel = DEFAULT_TOKEN_CHANNEL; | ||
828 | // InternalSolverLanguage.g:46:7: ( 'int' ) | ||
829 | // InternalSolverLanguage.g:46:9: 'int' | ||
830 | { | ||
831 | match("int"); | ||
832 | |||
833 | |||
834 | } | ||
835 | |||
836 | state.type = _type; | ||
837 | state.channel = _channel; | ||
838 | } | ||
839 | finally { | ||
840 | } | ||
841 | } | ||
842 | // $ANTLR end "T__50" | ||
843 | |||
844 | // $ANTLR start "T__51" | ||
845 | public final void mT__51() throws RecognitionException { | ||
846 | try { | ||
847 | int _type = T__51; | ||
848 | int _channel = DEFAULT_TOKEN_CHANNEL; | ||
849 | // InternalSolverLanguage.g:47:7: ( 'real' ) | ||
850 | // InternalSolverLanguage.g:47:9: 'real' | ||
851 | { | ||
852 | match("real"); | ||
853 | |||
854 | |||
855 | } | ||
856 | |||
857 | state.type = _type; | ||
858 | state.channel = _channel; | ||
859 | } | ||
860 | finally { | ||
861 | } | ||
862 | } | ||
863 | // $ANTLR end "T__51" | ||
864 | |||
865 | // $ANTLR start "T__52" | ||
866 | public final void mT__52() throws RecognitionException { | ||
867 | try { | ||
868 | int _type = T__52; | ||
869 | int _channel = DEFAULT_TOKEN_CHANNEL; | ||
870 | // InternalSolverLanguage.g:48:7: ( '!=' ) | ||
871 | // InternalSolverLanguage.g:48:9: '!=' | ||
872 | { | ||
873 | match("!="); | ||
874 | |||
875 | |||
876 | } | ||
877 | |||
878 | state.type = _type; | ||
879 | state.channel = _channel; | ||
880 | } | ||
881 | finally { | ||
882 | } | ||
883 | } | ||
884 | // $ANTLR end "T__52" | ||
885 | |||
886 | // $ANTLR start "T__53" | ||
887 | public final void mT__53() throws RecognitionException { | ||
888 | try { | ||
889 | int _type = T__53; | ||
890 | int _channel = DEFAULT_TOKEN_CHANNEL; | ||
891 | // InternalSolverLanguage.g:49:7: ( '<' ) | ||
892 | // InternalSolverLanguage.g:49:9: '<' | ||
893 | { | ||
894 | match('<'); | ||
895 | |||
896 | } | ||
897 | |||
898 | state.type = _type; | ||
899 | state.channel = _channel; | ||
900 | } | ||
901 | finally { | ||
902 | } | ||
903 | } | ||
904 | // $ANTLR end "T__53" | ||
905 | |||
906 | // $ANTLR start "T__54" | ||
907 | public final void mT__54() throws RecognitionException { | ||
908 | try { | ||
909 | int _type = T__54; | ||
910 | int _channel = DEFAULT_TOKEN_CHANNEL; | ||
911 | // InternalSolverLanguage.g:50:7: ( '>' ) | ||
912 | // InternalSolverLanguage.g:50:9: '>' | ||
913 | { | ||
914 | match('>'); | ||
915 | |||
916 | } | ||
917 | |||
918 | state.type = _type; | ||
919 | state.channel = _channel; | ||
920 | } | ||
921 | finally { | ||
922 | } | ||
923 | } | ||
924 | // $ANTLR end "T__54" | ||
925 | |||
926 | // $ANTLR start "T__55" | ||
927 | public final void mT__55() throws RecognitionException { | ||
928 | try { | ||
929 | int _type = T__55; | ||
930 | int _channel = DEFAULT_TOKEN_CHANNEL; | ||
931 | // InternalSolverLanguage.g:51:7: ( 'in' ) | ||
932 | // InternalSolverLanguage.g:51:9: 'in' | ||
933 | { | ||
934 | match("in"); | ||
935 | |||
936 | |||
937 | } | ||
938 | |||
939 | state.type = _type; | ||
940 | state.channel = _channel; | ||
941 | } | ||
942 | finally { | ||
943 | } | ||
944 | } | ||
945 | // $ANTLR end "T__55" | ||
946 | |||
947 | // $ANTLR start "T__56" | ||
948 | public final void mT__56() throws RecognitionException { | ||
949 | try { | ||
950 | int _type = T__56; | ||
951 | int _channel = DEFAULT_TOKEN_CHANNEL; | ||
952 | // InternalSolverLanguage.g:52:7: ( '+' ) | ||
953 | // InternalSolverLanguage.g:52:9: '+' | ||
954 | { | ||
955 | match('+'); | ||
956 | |||
957 | } | ||
958 | |||
959 | state.type = _type; | ||
960 | state.channel = _channel; | ||
961 | } | ||
962 | finally { | ||
963 | } | ||
964 | } | ||
965 | // $ANTLR end "T__56" | ||
966 | |||
967 | // $ANTLR start "T__57" | ||
968 | public final void mT__57() throws RecognitionException { | ||
969 | try { | ||
970 | int _type = T__57; | ||
971 | int _channel = DEFAULT_TOKEN_CHANNEL; | ||
972 | // InternalSolverLanguage.g:53:7: ( '-' ) | ||
973 | // InternalSolverLanguage.g:53:9: '-' | ||
974 | { | ||
975 | match('-'); | ||
976 | |||
977 | } | ||
978 | |||
979 | state.type = _type; | ||
980 | state.channel = _channel; | ||
981 | } | ||
982 | finally { | ||
983 | } | ||
984 | } | ||
985 | // $ANTLR end "T__57" | ||
986 | |||
987 | // $ANTLR start "T__58" | ||
988 | public final void mT__58() throws RecognitionException { | ||
989 | try { | ||
990 | int _type = T__58; | ||
991 | int _channel = DEFAULT_TOKEN_CHANNEL; | ||
992 | // InternalSolverLanguage.g:54:7: ( '/' ) | ||
993 | // InternalSolverLanguage.g:54:9: '/' | ||
994 | { | ||
995 | match('/'); | ||
996 | |||
997 | } | ||
998 | |||
999 | state.type = _type; | ||
1000 | state.channel = _channel; | ||
1001 | } | ||
1002 | finally { | ||
1003 | } | ||
1004 | } | ||
1005 | // $ANTLR end "T__58" | ||
1006 | |||
1007 | // $ANTLR start "T__59" | ||
1008 | public final void mT__59() throws RecognitionException { | ||
1009 | try { | ||
1010 | int _type = T__59; | ||
1011 | int _channel = DEFAULT_TOKEN_CHANNEL; | ||
1012 | // InternalSolverLanguage.g:55:7: ( '^' ) | ||
1013 | // InternalSolverLanguage.g:55:9: '^' | ||
1014 | { | ||
1015 | match('^'); | ||
1016 | |||
1017 | } | ||
1018 | |||
1019 | state.type = _type; | ||
1020 | state.channel = _channel; | ||
1021 | } | ||
1022 | finally { | ||
1023 | } | ||
1024 | } | ||
1025 | // $ANTLR end "T__59" | ||
1026 | |||
1027 | // $ANTLR start "T__60" | ||
1028 | public final void mT__60() throws RecognitionException { | ||
1029 | try { | ||
1030 | int _type = T__60; | ||
1031 | int _channel = DEFAULT_TOKEN_CHANNEL; | ||
1032 | // InternalSolverLanguage.g:56:7: ( '!' ) | ||
1033 | // InternalSolverLanguage.g:56:9: '!' | ||
1034 | { | ||
1035 | match('!'); | ||
1036 | |||
1037 | } | ||
1038 | |||
1039 | state.type = _type; | ||
1040 | state.channel = _channel; | ||
1041 | } | ||
1042 | finally { | ||
1043 | } | ||
1044 | } | ||
1045 | // $ANTLR end "T__60" | ||
1046 | |||
1047 | // $ANTLR start "T__61" | ||
1048 | public final void mT__61() throws RecognitionException { | ||
1049 | try { | ||
1050 | int _type = T__61; | ||
1051 | int _channel = DEFAULT_TOKEN_CHANNEL; | ||
1052 | // InternalSolverLanguage.g:57:7: ( 'may' ) | ||
1053 | // InternalSolverLanguage.g:57:9: 'may' | ||
1054 | { | ||
1055 | match("may"); | ||
1056 | |||
1057 | |||
1058 | } | ||
1059 | |||
1060 | state.type = _type; | ||
1061 | state.channel = _channel; | ||
1062 | } | ||
1063 | finally { | ||
1064 | } | ||
1065 | } | ||
1066 | // $ANTLR end "T__61" | ||
1067 | |||
1068 | // $ANTLR start "T__62" | ||
1069 | public final void mT__62() throws RecognitionException { | ||
1070 | try { | ||
1071 | int _type = T__62; | ||
1072 | int _channel = DEFAULT_TOKEN_CHANNEL; | ||
1073 | // InternalSolverLanguage.g:58:7: ( 'must' ) | ||
1074 | // InternalSolverLanguage.g:58:9: 'must' | ||
1075 | { | ||
1076 | match("must"); | ||
1077 | |||
1078 | |||
1079 | } | ||
1080 | |||
1081 | state.type = _type; | ||
1082 | state.channel = _channel; | ||
1083 | } | ||
1084 | finally { | ||
1085 | } | ||
1086 | } | ||
1087 | // $ANTLR end "T__62" | ||
1088 | |||
1089 | // $ANTLR start "T__63" | ||
1090 | public final void mT__63() throws RecognitionException { | ||
1091 | try { | ||
1092 | int _type = T__63; | ||
1093 | int _channel = DEFAULT_TOKEN_CHANNEL; | ||
1094 | // InternalSolverLanguage.g:59:7: ( 'current' ) | ||
1095 | // InternalSolverLanguage.g:59:9: 'current' | ||
1096 | { | ||
1097 | match("current"); | ||
1098 | |||
1099 | |||
1100 | } | ||
1101 | |||
1102 | state.type = _type; | ||
1103 | state.channel = _channel; | ||
1104 | } | ||
1105 | finally { | ||
1106 | } | ||
1107 | } | ||
1108 | // $ANTLR end "T__63" | ||
1109 | |||
1110 | // $ANTLR start "T__64" | ||
1111 | public final void mT__64() throws RecognitionException { | ||
1112 | try { | ||
1113 | int _type = T__64; | ||
1114 | int _channel = DEFAULT_TOKEN_CHANNEL; | ||
1115 | // InternalSolverLanguage.g:60:7: ( 'only' ) | ||
1116 | // InternalSolverLanguage.g:60:9: 'only' | ||
1117 | { | ||
1118 | match("only"); | ||
1119 | |||
1120 | |||
1121 | } | ||
1122 | |||
1123 | state.type = _type; | ||
1124 | state.channel = _channel; | ||
1125 | } | ||
1126 | finally { | ||
1127 | } | ||
1128 | } | ||
1129 | // $ANTLR end "T__64" | ||
1130 | |||
1131 | // $ANTLR start "T__65" | ||
1132 | public final void mT__65() throws RecognitionException { | ||
1133 | try { | ||
1134 | int _type = T__65; | ||
1135 | int _channel = DEFAULT_TOKEN_CHANNEL; | ||
1136 | // InternalSolverLanguage.g:61:7: ( 'sum' ) | ||
1137 | // InternalSolverLanguage.g:61:9: 'sum' | ||
1138 | { | ||
1139 | match("sum"); | ||
1140 | |||
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: ( 'prod' ) | ||
1158 | // InternalSolverLanguage.g:62:9: 'prod' | ||
1159 | { | ||
1160 | match("prod"); | ||
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: ( 'avg' ) | ||
1179 | // InternalSolverLanguage.g:63:9: 'avg' | ||
1180 | { | ||
1181 | match("avg"); | ||
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: ( 'min' ) | ||
1200 | // InternalSolverLanguage.g:64:9: 'min' | ||
1201 | { | ||
1202 | match("min"); | ||
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: ( 'max' ) | ||
1221 | // InternalSolverLanguage.g:65:9: 'max' | ||
1222 | { | ||
1223 | match("max"); | ||
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: ( 'true' ) | ||
1242 | // InternalSolverLanguage.g:66:9: 'true' | ||
1243 | { | ||
1244 | match("true"); | ||
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: ( 'false' ) | ||
1263 | // InternalSolverLanguage.g:67:9: 'false' | ||
1264 | { | ||
1265 | match("false"); | ||
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: ( 'unknown' ) | ||
1284 | // InternalSolverLanguage.g:68:9: 'unknown' | ||
1285 | { | ||
1286 | match("unknown"); | ||
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: ( 'minimize' ) | ||
1305 | // InternalSolverLanguage.g:69:9: 'minimize' | ||
1306 | { | ||
1307 | match("minimize"); | ||
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: ( 'maximize' ) | ||
1326 | // InternalSolverLanguage.g:70:9: 'maximize' | ||
1327 | { | ||
1328 | match("maximize"); | ||
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:3882:13: ( '\"' ( '\\\\' . | ~ ( ( '\\\\' | '\"' ) ) )* '\"' ) | ||
1347 | // InternalSolverLanguage.g:3882:15: '\"' ( '\\\\' . | ~ ( ( '\\\\' | '\"' ) ) )* '\"' | ||
1348 | { | ||
1349 | match('\"'); | ||
1350 | // InternalSolverLanguage.g:3882: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:3882:20: '\\\\' . | ||
1367 | { | ||
1368 | match('\\'); | ||
1369 | matchAny(); | ||
1370 | |||
1371 | } | ||
1372 | break; | ||
1373 | case 2 : | ||
1374 | // InternalSolverLanguage.g:3882: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:3884:16: ( '\\'' ( '\\\\' . | ~ ( ( '\\\\' | '\\'' ) ) )* '\\'' ) | ||
1412 | // InternalSolverLanguage.g:3884:18: '\\'' ( '\\\\' . | ~ ( ( '\\\\' | '\\'' ) ) )* '\\'' | ||
1413 | { | ||
1414 | match('\''); | ||
1415 | // InternalSolverLanguage.g:3884: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:3884:24: '\\\\' . | ||
1432 | { | ||
1433 | match('\\'); | ||
1434 | matchAny(); | ||
1435 | |||
1436 | } | ||
1437 | break; | ||
1438 | case 2 : | ||
1439 | // InternalSolverLanguage.g:3884: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:3886:11: ( 'synthetic::plus' ) | ||
1477 | // InternalSolverLanguage.g:3886: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:3888:11: ( 'synthetic::star' ) | ||
1498 | // InternalSolverLanguage.g:3888: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:3890:10: ( 'synthetic::dot' ) | ||
1519 | // InternalSolverLanguage.g:3890: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:3892:9: ( ( '^' )? ( 'a' .. 'z' | 'A' .. 'Z' | '_' ) ( 'a' .. 'z' | 'A' .. 'Z' | '_' | '0' .. '9' )* ) | ||
1540 | // InternalSolverLanguage.g:3892:11: ( '^' )? ( 'a' .. 'z' | 'A' .. 'Z' | '_' ) ( 'a' .. 'z' | 'A' .. 'Z' | '_' | '0' .. '9' )* | ||
1541 | { | ||
1542 | // InternalSolverLanguage.g:3892: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:3892: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:3892: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:3894:10: ( ( '0' .. '9' )+ ) | ||
1619 | // InternalSolverLanguage.g:3894:12: ( '0' .. '9' )+ | ||
1620 | { | ||
1621 | // InternalSolverLanguage.g:3894: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:3894: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:3896:17: ( '/*' ( options {greedy=false; } : . )* '*/' ) | ||
1668 | // InternalSolverLanguage.g:3896:19: '/*' ( options {greedy=false; } : . )* '*/' | ||
1669 | { | ||
1670 | match("/*"); | ||
1671 | |||
1672 | // InternalSolverLanguage.g:3896: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:3896: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:3898:17: ( '//' (~ ( ( '\\n' | '\\r' ) ) )* ( ( '\\r' )? '\\n' )? ) | ||
1728 | // InternalSolverLanguage.g:3898:19: '//' (~ ( ( '\\n' | '\\r' ) ) )* ( ( '\\r' )? '\\n' )? | ||
1729 | { | ||
1730 | match("//"); | ||
1731 | |||
1732 | // InternalSolverLanguage.g:3898: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:3898: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:3898: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:3898:41: ( '\\r' )? '\\n' | ||
1775 | { | ||
1776 | // InternalSolverLanguage.g:3898: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:3898: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:3900:9: ( ( ' ' | '\\t' | '\\r' | '\\n' )+ ) | ||
1818 | // InternalSolverLanguage.g:3900:11: ( ' ' | '\\t' | '\\r' | '\\n' )+ | ||
1819 | { | ||
1820 | // InternalSolverLanguage.g:3900: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:3902:16: ( . ) | ||
1875 | // InternalSolverLanguage.g:3902: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\51\1\53\3\56\1\65\2\56\1\uffff\1\74\1\uffff\1\56\10\uffff\3\56\1\121\1\123\1\56\1\126\1\uffff\1\132\1\133\3\56\2\47\10\uffff\2\56\1\uffff\5\56\2\uffff\1\154\1\157\2\56\4\uffff\3\56\10\uffff\7\56\4\uffff\1\56\7\uffff\5\56\4\uffff\7\56\1\uffff\1\u008b\1\u008c\1\uffff\7\56\1\u0094\3\56\1\u0098\2\56\1\u009b\1\u009d\1\56\1\u00a0\6\56\1\u00a8\2\56\2\uffff\1\u00ab\1\u00ac\5\56\1\uffff\1\56\1\u00b3\1\56\1\uffff\1\56\1\u00b6\1\uffff\1\56\1\uffff\1\u00b8\1\56\1\uffff\1\u00ba\2\56\1\u00bd\1\u00be\2\56\1\uffff\1\u00c1\1\56\2\uffff\1\u00c3\1\56\1\u00c5\3\56\1\uffff\1\u00c9\1\56\1\uffff\1\56\1\uffff\1\56\1\uffff\2\56\2\uffff\1\u00cf\1\56\1\uffff\1\56\1\uffff\1\56\1\uffff\3\56\1\uffff\5\56\1\uffff\1\u00db\1\u00dc\1\56\1\u00de\5\56\1\u00e4\1\56\2\uffff\1\u00e6\1\uffff\1\u00e7\1\u00e8\1\56\1\u00ea\1\u00eb\1\uffff\1\56\3\uffff\1\56\2\uffff\1\u00ee\6\uffff"; | ||
2400 | static final String DFA11_eofS = | ||
2401 | "\u00f3\uffff"; | ||
2402 | static final String DFA11_minS = | ||
2403 | "\1\0\1\55\1\75\1\141\1\154\1\145\1\56\1\146\1\150\1\uffff\1\76\1\uffff\1\154\10\uffff\1\142\1\156\1\143\2\75\1\145\1\75\1\uffff\1\52\1\101\1\141\1\162\1\156\2\0\10\uffff\1\156\1\154\1\uffff\1\162\1\164\1\163\1\160\1\146\2\uffff\2\60\1\145\1\165\4\uffff\1\156\1\141\1\162\10\uffff\1\163\1\147\1\160\1\154\1\157\1\155\1\156\4\uffff\1\141\7\uffff\1\170\1\163\1\156\1\157\1\153\4\uffff\1\143\1\163\1\157\2\145\1\164\1\141\1\uffff\2\60\1\uffff\1\156\1\145\1\156\1\164\1\163\1\162\1\164\1\60\1\157\1\171\1\160\1\60\1\164\1\154\2\60\1\164\1\60\1\144\1\156\1\164\1\145\1\162\1\156\1\60\1\171\1\165\2\uffff\2\60\1\164\1\141\1\163\1\145\1\162\1\uffff\1\163\1\60\1\145\1\uffff\1\150\1\60\1\uffff\1\155\1\uffff\1\60\1\155\1\uffff\1\60\1\157\1\151\2\60\1\156\1\144\1\uffff\1\60\1\154\2\uffff\1\60\1\151\1\60\1\156\1\141\1\151\1\uffff\1\60\1\145\1\uffff\1\151\1\uffff\1\151\1\uffff\1\167\1\157\2\uffff\1\60\1\163\1\uffff\1\164\1\uffff\1\156\1\uffff\1\164\1\143\1\164\1\uffff\1\164\2\172\2\156\1\uffff\2\60\1\163\1\60\1\164\1\145\1\151\2\145\1\60\1\141\2\uffff\1\60\1\uffff\2\60\1\143\2\60\1\uffff\1\154\3\uffff\1\72\2\uffff\1\60\1\72\1\uffff\1\144\3\uffff"; | ||
2404 | static final String DFA11_maxS = | ||
2405 | "\1\uffff\1\55\1\75\1\165\1\170\1\145\1\56\1\156\1\162\1\uffff\1\76\1\uffff\1\165\10\uffff\1\166\1\160\1\171\2\75\1\145\1\75\1\uffff\1\57\1\172\1\165\1\162\1\156\2\uffff\10\uffff\1\156\1\154\1\uffff\1\162\1\164\1\163\1\160\1\146\2\uffff\2\172\1\145\1\165\4\uffff\1\165\1\141\1\162\10\uffff\1\163\1\147\1\160\1\154\1\157\1\155\1\156\4\uffff\1\141\7\uffff\1\171\1\163\1\156\1\157\1\153\4\uffff\1\143\1\163\1\157\2\145\1\164\1\141\1\uffff\2\172\1\uffff\1\156\1\145\1\156\1\164\1\163\1\162\1\164\1\172\1\157\1\171\1\160\1\172\1\164\1\154\2\172\1\164\1\172\1\144\1\156\1\164\1\145\2\162\1\172\1\171\1\165\2\uffff\2\172\1\164\1\141\1\163\1\145\1\162\1\uffff\1\163\1\172\1\145\1\uffff\1\150\1\172\1\uffff\1\155\1\uffff\1\172\1\155\1\uffff\1\172\1\157\1\151\2\172\1\156\1\144\1\uffff\1\172\1\154\2\uffff\1\172\1\151\1\172\1\156\1\141\1\151\1\uffff\1\172\1\145\1\uffff\1\151\1\uffff\1\151\1\uffff\1\167\1\157\2\uffff\1\172\1\163\1\uffff\1\164\1\uffff\1\156\1\uffff\1\164\1\143\1\164\1\uffff\1\164\2\172\2\156\1\uffff\2\172\1\163\1\172\1\164\1\145\1\151\2\145\1\172\1\141\2\uffff\1\172\1\uffff\2\172\1\143\2\172\1\uffff\1\154\3\uffff\1\72\2\uffff\1\172\1\72\1\uffff\1\163\3\uffff"; | ||
2406 | static final String DFA11_acceptS = | ||
2407 | "\11\uffff\1\14\1\uffff\1\16\1\uffff\1\20\1\21\1\22\1\23\1\24\1\25\1\26\1\30\7\uffff\1\52\7\uffff\1\102\1\103\1\106\1\107\1\2\1\1\1\41\1\3\2\uffff\1\102\5\uffff\1\27\1\10\4\uffff\1\14\1\15\1\53\1\16\3\uffff\1\20\1\21\1\22\1\23\1\24\1\25\1\26\1\30\7\uffff\1\42\1\47\1\43\1\50\1\uffff\1\46\1\56\1\52\1\104\1\105\1\54\1\55\5\uffff\1\75\1\76\1\103\1\106\7\uffff\1\11\2\uffff\1\51\33\uffff\1\31\1\44\7\uffff\1\65\3\uffff\1\63\2\uffff\1\57\1\uffff\1\67\2\uffff\1\66\7\uffff\1\13\2\uffff\1\12\1\70\6\uffff\1\62\2\uffff\1\45\1\uffff\1\60\1\uffff\1\64\2\uffff\1\71\1\5\2\uffff\1\32\1\uffff\1\17\1\uffff\1\34\3\uffff\1\40\5\uffff\1\7\13\uffff\1\35\1\6\1\uffff\1\61\5\uffff\1\72\1\uffff\1\36\1\33\1\37\1\uffff\1\74\1\73\2\uffff\1\4\1\uffff\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\33\1\42\4\47\1\43\1\20\1\21\1\22\1\34\1\13\1\12\1\6\1\35\12\45\1\1\1\11\1\30\1\2\1\31\2\47\32\44\1\23\1\47\1\24\1\36\1\44\1\47\1\25\1\44\1\14\1\5\1\4\1\3\2\44\1\7\3\44\1\37\1\44\1\26\1\40\1\44\1\32\1\27\1\10\1\41\5\44\1\15\1\17\1\16\uff82\47", | ||
2412 | "\1\50", | ||
2413 | "\1\52", | ||
2414 | "\1\55\23\uffff\1\54", | ||
2415 | "\1\61\1\62\4\uffff\1\57\5\uffff\1\60", | ||
2416 | "\1\63", | ||
2417 | "\1\64", | ||
2418 | "\1\66\7\uffff\1\67", | ||
2419 | "\1\70\11\uffff\1\71", | ||
2420 | "", | ||
2421 | "\1\73", | ||
2422 | "", | ||
2423 | "\1\77\2\uffff\1\76\5\uffff\1\100", | ||
2424 | "", | ||
2425 | "", | ||
2426 | "", | ||
2427 | "", | ||
2428 | "", | ||
2429 | "", | ||
2430 | "", | ||
2431 | "", | ||
2432 | "\1\111\23\uffff\1\112", | ||
2433 | "\1\114\1\uffff\1\113", | ||
2434 | "\1\115\21\uffff\1\116\3\uffff\1\117", | ||
2435 | "\1\120", | ||
2436 | "\1\122", | ||
2437 | "\1\124", | ||
2438 | "\1\125", | ||
2439 | "", | ||
2440 | "\1\130\4\uffff\1\131", | ||
2441 | "\32\56\4\uffff\1\56\1\uffff\32\56", | ||
2442 | "\1\134\7\uffff\1\136\13\uffff\1\135", | ||
2443 | "\1\137", | ||
2444 | "\1\140", | ||
2445 | "\0\141", | ||
2446 | "\0\142", | ||
2447 | "", | ||
2448 | "", | ||
2449 | "", | ||
2450 | "", | ||
2451 | "", | ||
2452 | "", | ||
2453 | "", | ||
2454 | "", | ||
2455 | "\1\145", | ||
2456 | "\1\146", | ||
2457 | "", | ||
2458 | "\1\147", | ||
2459 | "\1\150", | ||
2460 | "\1\151", | ||
2461 | "\1\152", | ||
2462 | "\1\153", | ||
2463 | "", | ||
2464 | "", | ||
2465 | "\12\56\7\uffff\32\56\4\uffff\1\56\1\uffff\32\56", | ||
2466 | "\12\56\7\uffff\32\56\4\uffff\1\56\1\uffff\5\56\1\155\15\56\1\156\6\56", | ||
2467 | "\1\160", | ||
2468 | "\1\161", | ||
2469 | "", | ||
2470 | "", | ||
2471 | "", | ||
2472 | "", | ||
2473 | "\1\163\6\uffff\1\162", | ||
2474 | "\1\164", | ||
2475 | "\1\165", | ||
2476 | "", | ||
2477 | "", | ||
2478 | "", | ||
2479 | "", | ||
2480 | "", | ||
2481 | "", | ||
2482 | "", | ||
2483 | "", | ||
2484 | "\1\166", | ||
2485 | "\1\167", | ||
2486 | "\1\170", | ||
2487 | "\1\171", | ||
2488 | "\1\172", | ||
2489 | "\1\173", | ||
2490 | "\1\174", | ||
2491 | "", | ||
2492 | "", | ||
2493 | "", | ||
2494 | "", | ||
2495 | "\1\175", | ||
2496 | "", | ||
2497 | "", | ||
2498 | "", | ||
2499 | "", | ||
2500 | "", | ||
2501 | "", | ||
2502 | "", | ||
2503 | "\1\177\1\176", | ||
2504 | "\1\u0080", | ||
2505 | "\1\u0081", | ||
2506 | "\1\u0082", | ||
2507 | "\1\u0083", | ||
2508 | "", | ||
2509 | "", | ||
2510 | "", | ||
2511 | "", | ||
2512 | "\1\u0084", | ||
2513 | "\1\u0085", | ||
2514 | "\1\u0086", | ||
2515 | "\1\u0087", | ||
2516 | "\1\u0088", | ||
2517 | "\1\u0089", | ||
2518 | "\1\u008a", | ||
2519 | "", | ||
2520 | "\12\56\7\uffff\32\56\4\uffff\1\56\1\uffff\32\56", | ||
2521 | "\12\56\7\uffff\32\56\4\uffff\1\56\1\uffff\32\56", | ||
2522 | "", | ||
2523 | "\1\u008d", | ||
2524 | "\1\u008e", | ||
2525 | "\1\u008f", | ||
2526 | "\1\u0090", | ||
2527 | "\1\u0091", | ||
2528 | "\1\u0092", | ||
2529 | "\1\u0093", | ||
2530 | "\12\56\7\uffff\32\56\4\uffff\1\56\1\uffff\32\56", | ||
2531 | "\1\u0095", | ||
2532 | "\1\u0096", | ||
2533 | "\1\u0097", | ||
2534 | "\12\56\7\uffff\32\56\4\uffff\1\56\1\uffff\32\56", | ||
2535 | "\1\u0099", | ||
2536 | "\1\u009a", | ||
2537 | "\12\56\7\uffff\32\56\4\uffff\1\56\1\uffff\32\56", | ||
2538 | "\12\56\7\uffff\32\56\4\uffff\1\56\1\uffff\10\56\1\u009c\21\56", | ||
2539 | "\1\u009e", | ||
2540 | "\12\56\7\uffff\32\56\4\uffff\1\56\1\uffff\10\56\1\u009f\21\56", | ||
2541 | "\1\u00a1", | ||
2542 | "\1\u00a2", | ||
2543 | "\1\u00a3", | ||
2544 | "\1\u00a4", | ||
2545 | "\1\u00a5", | ||
2546 | "\1\u00a7\3\uffff\1\u00a6", | ||
2547 | "\12\56\7\uffff\32\56\4\uffff\1\56\1\uffff\32\56", | ||
2548 | "\1\u00a9", | ||
2549 | "\1\u00aa", | ||
2550 | "", | ||
2551 | "", | ||
2552 | "\12\56\7\uffff\32\56\4\uffff\1\56\1\uffff\32\56", | ||
2553 | "\12\56\7\uffff\32\56\4\uffff\1\56\1\uffff\32\56", | ||
2554 | "\1\u00ad", | ||
2555 | "\1\u00ae", | ||
2556 | "\1\u00af", | ||
2557 | "\1\u00b0", | ||
2558 | "\1\u00b1", | ||
2559 | "", | ||
2560 | "\1\u00b2", | ||
2561 | "\12\56\7\uffff\32\56\4\uffff\1\56\1\uffff\32\56", | ||
2562 | "\1\u00b4", | ||
2563 | "", | ||
2564 | "\1\u00b5", | ||
2565 | "\12\56\7\uffff\32\56\4\uffff\1\56\1\uffff\32\56", | ||
2566 | "", | ||
2567 | "\1\u00b7", | ||
2568 | "", | ||
2569 | "\12\56\7\uffff\32\56\4\uffff\1\56\1\uffff\32\56", | ||
2570 | "\1\u00b9", | ||
2571 | "", | ||
2572 | "\12\56\7\uffff\32\56\4\uffff\1\56\1\uffff\32\56", | ||
2573 | "\1\u00bb", | ||
2574 | "\1\u00bc", | ||
2575 | "\12\56\7\uffff\32\56\4\uffff\1\56\1\uffff\32\56", | ||
2576 | "\12\56\7\uffff\32\56\4\uffff\1\56\1\uffff\32\56", | ||
2577 | "\1\u00bf", | ||
2578 | "\1\u00c0", | ||
2579 | "", | ||
2580 | "\12\56\7\uffff\32\56\4\uffff\1\56\1\uffff\32\56", | ||
2581 | "\1\u00c2", | ||
2582 | "", | ||
2583 | "", | ||
2584 | "\12\56\7\uffff\32\56\4\uffff\1\56\1\uffff\32\56", | ||
2585 | "\1\u00c4", | ||
2586 | "\12\56\7\uffff\32\56\4\uffff\1\56\1\uffff\32\56", | ||
2587 | "\1\u00c6", | ||
2588 | "\1\u00c7", | ||
2589 | "\1\u00c8", | ||
2590 | "", | ||
2591 | "\12\56\7\uffff\32\56\4\uffff\1\56\1\uffff\32\56", | ||
2592 | "\1\u00ca", | ||
2593 | "", | ||
2594 | "\1\u00cb", | ||
2595 | "", | ||
2596 | "\1\u00cc", | ||
2597 | "", | ||
2598 | "\1\u00cd", | ||
2599 | "\1\u00ce", | ||
2600 | "", | ||
2601 | "", | ||
2602 | "\12\56\7\uffff\32\56\4\uffff\1\56\1\uffff\32\56", | ||
2603 | "\1\u00d0", | ||
2604 | "", | ||
2605 | "\1\u00d1", | ||
2606 | "", | ||
2607 | "\1\u00d2", | ||
2608 | "", | ||
2609 | "\1\u00d3", | ||
2610 | "\1\u00d4", | ||
2611 | "\1\u00d5", | ||
2612 | "", | ||
2613 | "\1\u00d6", | ||
2614 | "\1\u00d7", | ||
2615 | "\1\u00d8", | ||
2616 | "\1\u00d9", | ||
2617 | "\1\u00da", | ||
2618 | "", | ||
2619 | "\12\56\7\uffff\32\56\4\uffff\1\56\1\uffff\32\56", | ||
2620 | "\12\56\7\uffff\32\56\4\uffff\1\56\1\uffff\32\56", | ||
2621 | "\1\u00dd", | ||
2622 | "\12\56\7\uffff\32\56\4\uffff\1\56\1\uffff\32\56", | ||
2623 | "\1\u00df", | ||
2624 | "\1\u00e0", | ||
2625 | "\1\u00e1", | ||
2626 | "\1\u00e2", | ||
2627 | "\1\u00e3", | ||
2628 | "\12\56\7\uffff\32\56\4\uffff\1\56\1\uffff\32\56", | ||
2629 | "\1\u00e5", | ||
2630 | "", | ||
2631 | "", | ||
2632 | "\12\56\7\uffff\32\56\4\uffff\1\56\1\uffff\32\56", | ||
2633 | "", | ||
2634 | "\12\56\7\uffff\32\56\4\uffff\1\56\1\uffff\32\56", | ||
2635 | "\12\56\7\uffff\32\56\4\uffff\1\56\1\uffff\32\56", | ||
2636 | "\1\u00e9", | ||
2637 | "\12\56\7\uffff\32\56\4\uffff\1\56\1\uffff\32\56", | ||
2638 | "\12\56\7\uffff\32\56\4\uffff\1\56\1\uffff\32\56", | ||
2639 | "", | ||
2640 | "\1\u00ec", | ||
2641 | "", | ||
2642 | "", | ||
2643 | "", | ||
2644 | "\1\u00ed", | ||
2645 | "", | ||
2646 | "", | ||
2647 | "\12\56\7\uffff\32\56\4\uffff\1\56\1\uffff\32\56", | ||
2648 | "\1\u00ef", | ||
2649 | "", | ||
2650 | "\1\u00f2\13\uffff\1\u00f0\2\uffff\1\u00f1", | ||
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=='f') ) {s = 3;} | ||
2711 | |||
2712 | else if ( (LA11_0=='e') ) {s = 4;} | ||
2713 | |||
2714 | else if ( (LA11_0=='d') ) {s = 5;} | ||
2715 | |||
2716 | else if ( (LA11_0=='.') ) {s = 6;} | ||
2717 | |||
2718 | else if ( (LA11_0=='i') ) {s = 7;} | ||
2719 | |||
2720 | else if ( (LA11_0=='t') ) {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=='c') ) {s = 12;} | ||
2729 | |||
2730 | else if ( (LA11_0=='{') ) {s = 13;} | ||
2731 | |||
2732 | else if ( (LA11_0=='}') ) {s = 14;} | ||
2733 | |||
2734 | else if ( (LA11_0=='|') ) {s = 15;} | ||
2735 | |||
2736 | else if ( (LA11_0=='(') ) {s = 16;} | ||
2737 | |||
2738 | else if ( (LA11_0==')') ) {s = 17;} | ||
2739 | |||
2740 | else if ( (LA11_0=='*') ) {s = 18;} | ||
2741 | |||
2742 | else if ( (LA11_0=='[') ) {s = 19;} | ||
2743 | |||
2744 | else if ( (LA11_0==']') ) {s = 20;} | ||
2745 | |||
2746 | else if ( (LA11_0=='a') ) {s = 21;} | ||
2747 | |||
2748 | else if ( (LA11_0=='o') ) {s = 22;} | ||
2749 | |||
2750 | else if ( (LA11_0=='s') ) {s = 23;} | ||
2751 | |||
2752 | else if ( (LA11_0=='<') ) {s = 24;} | ||
2753 | |||
2754 | else if ( (LA11_0=='>') ) {s = 25;} | ||
2755 | |||
2756 | else if ( (LA11_0=='r') ) {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=='m') ) {s = 31;} | ||
2767 | |||
2768 | else if ( (LA11_0=='p') ) {s = 32;} | ||
2769 | |||
2770 | else if ( (LA11_0=='u') ) {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/src-gen/org/eclipse/viatra/solver/language/parser/antlr/internal/InternalSolverLanguage.g b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/parser/antlr/internal/InternalSolverLanguageParser.g index 3fac9254..6cd0341f 100644 --- a/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/parser/antlr/internal/InternalSolverLanguage.g +++ b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/parser/antlr/internal/InternalSolverLanguageParser.g | |||
@@ -1,21 +1,14 @@ | |||
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=AbstractInternalAntlrParser; | 8 | superClass=AbstractInternalAntlrParser; |
8 | } | 9 | } |
9 | 10 | ||
10 | @lexer::header { | 11 | @header { |
11 | package org.eclipse.viatra.solver.language.parser.antlr.internal; | ||
12 | |||
13 | // Hack: Use our own Lexer superclass by means of import. | ||
14 | // Currently there is no other way to specify the superclass for the lexer. | ||
15 | import org.eclipse.xtext.parser.antlr.Lexer; | ||
16 | } | ||
17 | |||
18 | @parser::header { | ||
19 | package org.eclipse.viatra.solver.language.parser.antlr.internal; | 12 | package org.eclipse.viatra.solver.language.parser.antlr.internal; |
20 | 13 | ||
21 | import org.eclipse.xtext.*; | 14 | import org.eclipse.xtext.*; |
@@ -32,7 +25,7 @@ import org.eclipse.viatra.solver.language.services.SolverLanguageGrammarAccess; | |||
32 | 25 | ||
33 | } | 26 | } |
34 | 27 | ||
35 | @parser::members { | 28 | @members { |
36 | 29 | ||
37 | private SolverLanguageGrammarAccess grammarAccess; | 30 | private SolverLanguageGrammarAccess grammarAccess; |
38 | 31 | ||
@@ -204,9 +197,9 @@ ruleStatement returns [EObject current=null] | |||
204 | afterParserOrEnumRuleCall(); | 197 | afterParserOrEnumRuleCall(); |
205 | } | 198 | } |
206 | ) | 199 | ) |
207 | this_DOT_10=RULE_DOT | 200 | this_FULL_STOP_10=RULE_FULL_STOP |
208 | { | 201 | { |
209 | newLeafNode(this_DOT_10, grammarAccess.getStatementAccess().getDOTTerminalRuleCall_1()); | 202 | newLeafNode(this_FULL_STOP_10, grammarAccess.getStatementAccess().getFULL_STOPTerminalRuleCall_1()); |
210 | } | 203 | } |
211 | ) | 204 | ) |
212 | ; | 205 | ; |
@@ -245,7 +238,7 @@ ruleAssertionOrDefinition returns [EObject current=null] | |||
245 | } | 238 | } |
246 | ) | 239 | ) |
247 | ( | 240 | ( |
248 | otherlv_2=':' | 241 | otherlv_2=Colon |
249 | { | 242 | { |
250 | newLeafNode(otherlv_2, grammarAccess.getAssertionOrDefinitionAccess().getColonKeyword_1_0_1_0()); | 243 | newLeafNode(otherlv_2, grammarAccess.getAssertionOrDefinitionAccess().getColonKeyword_1_0_1_0()); |
251 | } | 244 | } |
@@ -279,7 +272,7 @@ ruleAssertionOrDefinition returns [EObject current=null] | |||
279 | $current); | 272 | $current); |
280 | } | 273 | } |
281 | ) | 274 | ) |
282 | otherlv_5=':-' | 275 | otherlv_5=ColonHyphenMinus |
283 | { | 276 | { |
284 | newLeafNode(otherlv_5, grammarAccess.getAssertionOrDefinitionAccess().getColonHyphenMinusKeyword_1_1_1()); | 277 | newLeafNode(otherlv_5, grammarAccess.getAssertionOrDefinitionAccess().getColonHyphenMinusKeyword_1_1_1()); |
285 | } | 278 | } |
@@ -312,7 +305,7 @@ ruleAssertionOrDefinition returns [EObject current=null] | |||
312 | $current); | 305 | $current); |
313 | } | 306 | } |
314 | ) | 307 | ) |
315 | otherlv_8='=' | 308 | otherlv_8=EqualsSign |
316 | { | 309 | { |
317 | newLeafNode(otherlv_8, grammarAccess.getAssertionOrDefinitionAccess().getEqualsSignKeyword_1_2_1()); | 310 | newLeafNode(otherlv_8, grammarAccess.getAssertionOrDefinitionAccess().getEqualsSignKeyword_1_2_1()); |
318 | } | 311 | } |
@@ -360,7 +353,7 @@ rulePredicateDefinition returns [EObject current=null] | |||
360 | ( | 353 | ( |
361 | ( | 354 | ( |
362 | ( | 355 | ( |
363 | lv_functional_0_0='functional' | 356 | lv_functional_0_0=Functional |
364 | { | 357 | { |
365 | newLeafNode(lv_functional_0_0, grammarAccess.getPredicateDefinitionAccess().getFunctionalFunctionalKeyword_0_0_0_0()); | 358 | newLeafNode(lv_functional_0_0, grammarAccess.getPredicateDefinitionAccess().getFunctionalFunctionalKeyword_0_0_0_0()); |
366 | } | 359 | } |
@@ -374,7 +367,7 @@ rulePredicateDefinition returns [EObject current=null] | |||
374 | ) | 367 | ) |
375 | ( | 368 | ( |
376 | ( | 369 | ( |
377 | lv_error_1_0='error' | 370 | lv_error_1_0=Error |
378 | { | 371 | { |
379 | newLeafNode(lv_error_1_0, grammarAccess.getPredicateDefinitionAccess().getErrorErrorKeyword_0_0_1_0()); | 372 | newLeafNode(lv_error_1_0, grammarAccess.getPredicateDefinitionAccess().getErrorErrorKeyword_0_0_1_0()); |
380 | } | 373 | } |
@@ -391,7 +384,7 @@ rulePredicateDefinition returns [EObject current=null] | |||
391 | ( | 384 | ( |
392 | ( | 385 | ( |
393 | ( | 386 | ( |
394 | lv_error_2_0='error' | 387 | lv_error_2_0=Error |
395 | { | 388 | { |
396 | newLeafNode(lv_error_2_0, grammarAccess.getPredicateDefinitionAccess().getErrorErrorKeyword_0_1_0_0()); | 389 | newLeafNode(lv_error_2_0, grammarAccess.getPredicateDefinitionAccess().getErrorErrorKeyword_0_1_0_0()); |
397 | } | 390 | } |
@@ -405,7 +398,7 @@ rulePredicateDefinition returns [EObject current=null] | |||
405 | ) | 398 | ) |
406 | ( | 399 | ( |
407 | ( | 400 | ( |
408 | lv_functional_3_0='functional' | 401 | lv_functional_3_0=Functional |
409 | { | 402 | { |
410 | newLeafNode(lv_functional_3_0, grammarAccess.getPredicateDefinitionAccess().getFunctionalFunctionalKeyword_0_1_1_0()); | 403 | newLeafNode(lv_functional_3_0, grammarAccess.getPredicateDefinitionAccess().getFunctionalFunctionalKeyword_0_1_1_0()); |
411 | } | 404 | } |
@@ -438,7 +431,7 @@ rulePredicateDefinition returns [EObject current=null] | |||
438 | } | 431 | } |
439 | ) | 432 | ) |
440 | ) | 433 | ) |
441 | otherlv_5=':-' | 434 | otherlv_5=ColonHyphenMinus |
442 | { | 435 | { |
443 | newLeafNode(otherlv_5, grammarAccess.getPredicateDefinitionAccess().getColonHyphenMinusKeyword_2()); | 436 | newLeafNode(otherlv_5, grammarAccess.getPredicateDefinitionAccess().getColonHyphenMinusKeyword_2()); |
444 | } | 437 | } |
@@ -480,7 +473,7 @@ ruleUnnamedErrorPrediateDefinition returns [EObject current=null] | |||
480 | leaveRule(); | 473 | leaveRule(); |
481 | }: | 474 | }: |
482 | ( | 475 | ( |
483 | otherlv_0='error' | 476 | otherlv_0=Error |
484 | { | 477 | { |
485 | newLeafNode(otherlv_0, grammarAccess.getUnnamedErrorPrediateDefinitionAccess().getErrorKeyword_0()); | 478 | newLeafNode(otherlv_0, grammarAccess.getUnnamedErrorPrediateDefinitionAccess().getErrorKeyword_0()); |
486 | } | 479 | } |
@@ -503,7 +496,7 @@ ruleUnnamedErrorPrediateDefinition returns [EObject current=null] | |||
503 | } | 496 | } |
504 | ) | 497 | ) |
505 | ) | 498 | ) |
506 | otherlv_2=':-' | 499 | otherlv_2=ColonHyphenMinus |
507 | { | 500 | { |
508 | newLeafNode(otherlv_2, grammarAccess.getUnnamedErrorPrediateDefinitionAccess().getColonHyphenMinusKeyword_2()); | 501 | newLeafNode(otherlv_2, grammarAccess.getUnnamedErrorPrediateDefinitionAccess().getColonHyphenMinusKeyword_2()); |
509 | } | 502 | } |
@@ -545,7 +538,7 @@ ruleDefaultDefinition returns [EObject current=null] | |||
545 | leaveRule(); | 538 | leaveRule(); |
546 | }: | 539 | }: |
547 | ( | 540 | ( |
548 | otherlv_0='default' | 541 | otherlv_0=Default |
549 | { | 542 | { |
550 | newLeafNode(otherlv_0, grammarAccess.getDefaultDefinitionAccess().getDefaultKeyword_0()); | 543 | newLeafNode(otherlv_0, grammarAccess.getDefaultDefinitionAccess().getDefaultKeyword_0()); |
551 | } | 544 | } |
@@ -568,7 +561,7 @@ ruleDefaultDefinition returns [EObject current=null] | |||
568 | } | 561 | } |
569 | ) | 562 | ) |
570 | ) | 563 | ) |
571 | otherlv_2=':' | 564 | otherlv_2=Colon |
572 | { | 565 | { |
573 | newLeafNode(otherlv_2, grammarAccess.getDefaultDefinitionAccess().getColonKeyword_2()); | 566 | newLeafNode(otherlv_2, grammarAccess.getDefaultDefinitionAccess().getColonKeyword_2()); |
574 | } | 567 | } |
@@ -610,7 +603,7 @@ ruleExternPredicateDefinition returns [EObject current=null] | |||
610 | leaveRule(); | 603 | leaveRule(); |
611 | }: | 604 | }: |
612 | ( | 605 | ( |
613 | otherlv_0='extern' | 606 | otherlv_0=Extern |
614 | { | 607 | { |
615 | newLeafNode(otherlv_0, grammarAccess.getExternPredicateDefinitionAccess().getExternKeyword_0()); | 608 | newLeafNode(otherlv_0, grammarAccess.getExternPredicateDefinitionAccess().getExternKeyword_0()); |
616 | } | 609 | } |
@@ -633,10 +626,6 @@ ruleExternPredicateDefinition returns [EObject current=null] | |||
633 | } | 626 | } |
634 | ) | 627 | ) |
635 | ) | 628 | ) |
636 | otherlv_2='.' | ||
637 | { | ||
638 | newLeafNode(otherlv_2, grammarAccess.getExternPredicateDefinitionAccess().getFullStopKeyword_2()); | ||
639 | } | ||
640 | ) | 629 | ) |
641 | ; | 630 | ; |
642 | 631 | ||
@@ -694,7 +683,7 @@ ruleMetricDefinition returns [EObject current=null] | |||
694 | } | 683 | } |
695 | ) | 684 | ) |
696 | ) | 685 | ) |
697 | otherlv_2='=' | 686 | otherlv_2=EqualsSign |
698 | { | 687 | { |
699 | newLeafNode(otherlv_2, grammarAccess.getMetricDefinitionAccess().getEqualsSignKeyword_2()); | 688 | newLeafNode(otherlv_2, grammarAccess.getMetricDefinitionAccess().getEqualsSignKeyword_2()); |
700 | } | 689 | } |
@@ -736,7 +725,7 @@ ruleExternMetricDefinition returns [EObject current=null] | |||
736 | leaveRule(); | 725 | leaveRule(); |
737 | }: | 726 | }: |
738 | ( | 727 | ( |
739 | otherlv_0='extern' | 728 | otherlv_0=Extern |
740 | { | 729 | { |
741 | newLeafNode(otherlv_0, grammarAccess.getExternMetricDefinitionAccess().getExternKeyword_0()); | 730 | newLeafNode(otherlv_0, grammarAccess.getExternMetricDefinitionAccess().getExternKeyword_0()); |
742 | } | 731 | } |
@@ -833,7 +822,7 @@ ruleIfElse returns [EObject current=null] | |||
833 | leaveRule(); | 822 | leaveRule(); |
834 | }: | 823 | }: |
835 | ( | 824 | ( |
836 | otherlv_0='if' | 825 | otherlv_0=If |
837 | { | 826 | { |
838 | newLeafNode(otherlv_0, grammarAccess.getIfElseAccess().getIfKeyword_0()); | 827 | newLeafNode(otherlv_0, grammarAccess.getIfElseAccess().getIfKeyword_0()); |
839 | } | 828 | } |
@@ -856,7 +845,7 @@ ruleIfElse returns [EObject current=null] | |||
856 | } | 845 | } |
857 | ) | 846 | ) |
858 | ) | 847 | ) |
859 | otherlv_2='then' | 848 | otherlv_2=Then |
860 | { | 849 | { |
861 | newLeafNode(otherlv_2, grammarAccess.getIfElseAccess().getThenKeyword_2()); | 850 | newLeafNode(otherlv_2, grammarAccess.getIfElseAccess().getThenKeyword_2()); |
862 | } | 851 | } |
@@ -879,7 +868,7 @@ ruleIfElse returns [EObject current=null] | |||
879 | } | 868 | } |
880 | ) | 869 | ) |
881 | ) | 870 | ) |
882 | otherlv_4='else' | 871 | otherlv_4=Else |
883 | { | 872 | { |
884 | newLeafNode(otherlv_4, grammarAccess.getIfElseAccess().getElseKeyword_4()); | 873 | newLeafNode(otherlv_4, grammarAccess.getIfElseAccess().getElseKeyword_4()); |
885 | } | 874 | } |
@@ -939,7 +928,7 @@ ruleDisjunctiveExpression returns [EObject current=null] | |||
939 | } | 928 | } |
940 | ) | 929 | ) |
941 | ( | 930 | ( |
942 | otherlv_2=';' | 931 | otherlv_2=Semicolon |
943 | { | 932 | { |
944 | newLeafNode(otherlv_2, grammarAccess.getDisjunctiveExpressionAccess().getSemicolonKeyword_1_0_1_0()); | 933 | newLeafNode(otherlv_2, grammarAccess.getDisjunctiveExpressionAccess().getSemicolonKeyword_1_0_1_0()); |
945 | } | 934 | } |
@@ -973,7 +962,7 @@ ruleDisjunctiveExpression returns [EObject current=null] | |||
973 | $current); | 962 | $current); |
974 | } | 963 | } |
975 | ) | 964 | ) |
976 | otherlv_5='->' | 965 | otherlv_5=HyphenMinusGreaterThanSign |
977 | { | 966 | { |
978 | newLeafNode(otherlv_5, grammarAccess.getDisjunctiveExpressionAccess().getHyphenMinusGreaterThanSignKeyword_1_1_1()); | 967 | newLeafNode(otherlv_5, grammarAccess.getDisjunctiveExpressionAccess().getHyphenMinusGreaterThanSignKeyword_1_1_1()); |
979 | } | 968 | } |
@@ -1004,7 +993,7 @@ ruleDisjunctiveExpression returns [EObject current=null] | |||
1004 | } | 993 | } |
1005 | ) | 994 | ) |
1006 | ( | 995 | ( |
1007 | otherlv_8=';' | 996 | otherlv_8=Semicolon |
1008 | { | 997 | { |
1009 | newLeafNode(otherlv_8, grammarAccess.getDisjunctiveExpressionAccess().getSemicolonKeyword_1_1_4_0()); | 998 | newLeafNode(otherlv_8, grammarAccess.getDisjunctiveExpressionAccess().getSemicolonKeyword_1_1_4_0()); |
1010 | } | 999 | } |
@@ -1068,7 +1057,7 @@ ruleCase returns [EObject current=null] | |||
1068 | } | 1057 | } |
1069 | ) | 1058 | ) |
1070 | ) | 1059 | ) |
1071 | otherlv_1='->' | 1060 | otherlv_1=HyphenMinusGreaterThanSign |
1072 | { | 1061 | { |
1073 | newLeafNode(otherlv_1, grammarAccess.getCaseAccess().getHyphenMinusGreaterThanSignKeyword_1()); | 1062 | newLeafNode(otherlv_1, grammarAccess.getCaseAccess().getHyphenMinusGreaterThanSignKeyword_1()); |
1074 | } | 1063 | } |
@@ -1127,7 +1116,7 @@ ruleConjunctiveExpression returns [EObject current=null] | |||
1127 | } | 1116 | } |
1128 | ) | 1117 | ) |
1129 | ( | 1118 | ( |
1130 | otherlv_2=',' | 1119 | otherlv_2=Comma |
1131 | { | 1120 | { |
1132 | newLeafNode(otherlv_2, grammarAccess.getConjunctiveExpressionAccess().getCommaKeyword_1_1_0()); | 1121 | newLeafNode(otherlv_2, grammarAccess.getConjunctiveExpressionAccess().getCommaKeyword_1_1_0()); |
1133 | } | 1122 | } |
@@ -1587,11 +1576,11 @@ ruleCount returns [EObject current=null] | |||
1587 | leaveRule(); | 1576 | leaveRule(); |
1588 | }: | 1577 | }: |
1589 | ( | 1578 | ( |
1590 | otherlv_0='count' | 1579 | otherlv_0=Count |
1591 | { | 1580 | { |
1592 | newLeafNode(otherlv_0, grammarAccess.getCountAccess().getCountKeyword_0()); | 1581 | newLeafNode(otherlv_0, grammarAccess.getCountAccess().getCountKeyword_0()); |
1593 | } | 1582 | } |
1594 | otherlv_1='{' | 1583 | otherlv_1=LeftCurlyBracket |
1595 | { | 1584 | { |
1596 | newLeafNode(otherlv_1, grammarAccess.getCountAccess().getLeftCurlyBracketKeyword_1()); | 1585 | newLeafNode(otherlv_1, grammarAccess.getCountAccess().getLeftCurlyBracketKeyword_1()); |
1597 | } | 1586 | } |
@@ -1614,7 +1603,7 @@ ruleCount returns [EObject current=null] | |||
1614 | } | 1603 | } |
1615 | ) | 1604 | ) |
1616 | ) | 1605 | ) |
1617 | otherlv_3='}' | 1606 | otherlv_3=RightCurlyBracket |
1618 | { | 1607 | { |
1619 | newLeafNode(otherlv_3, grammarAccess.getCountAccess().getRightCurlyBracketKeyword_3()); | 1608 | newLeafNode(otherlv_3, grammarAccess.getCountAccess().getRightCurlyBracketKeyword_3()); |
1620 | } | 1609 | } |
@@ -1656,7 +1645,7 @@ ruleAggregation returns [EObject current=null] | |||
1656 | } | 1645 | } |
1657 | ) | 1646 | ) |
1658 | ) | 1647 | ) |
1659 | otherlv_1='{' | 1648 | otherlv_1=LeftCurlyBracket |
1660 | { | 1649 | { |
1661 | newLeafNode(otherlv_1, grammarAccess.getAggregationAccess().getLeftCurlyBracketKeyword_1()); | 1650 | newLeafNode(otherlv_1, grammarAccess.getAggregationAccess().getLeftCurlyBracketKeyword_1()); |
1662 | } | 1651 | } |
@@ -1679,7 +1668,7 @@ ruleAggregation returns [EObject current=null] | |||
1679 | } | 1668 | } |
1680 | ) | 1669 | ) |
1681 | ) | 1670 | ) |
1682 | otherlv_3='|' | 1671 | otherlv_3=VerticalLine |
1683 | { | 1672 | { |
1684 | newLeafNode(otherlv_3, grammarAccess.getAggregationAccess().getVerticalLineKeyword_3()); | 1673 | newLeafNode(otherlv_3, grammarAccess.getAggregationAccess().getVerticalLineKeyword_3()); |
1685 | } | 1674 | } |
@@ -1702,7 +1691,7 @@ ruleAggregation returns [EObject current=null] | |||
1702 | } | 1691 | } |
1703 | ) | 1692 | ) |
1704 | ) | 1693 | ) |
1705 | otherlv_5='}' | 1694 | otherlv_5=RightCurlyBracket |
1706 | { | 1695 | { |
1707 | newLeafNode(otherlv_5, grammarAccess.getAggregationAccess().getRightCurlyBracketKeyword_5()); | 1696 | newLeafNode(otherlv_5, grammarAccess.getAggregationAccess().getRightCurlyBracketKeyword_5()); |
1708 | } | 1697 | } |
@@ -1725,80 +1714,58 @@ ruleAtomicExpression returns [EObject current=null] | |||
1725 | leaveRule(); | 1714 | leaveRule(); |
1726 | }: | 1715 | }: |
1727 | ( | 1716 | ( |
1728 | ( | 1717 | { |
1729 | { | 1718 | newCompositeNode(grammarAccess.getAtomicExpressionAccess().getReferenceParserRuleCall_0()); |
1730 | newCompositeNode(grammarAccess.getAtomicExpressionAccess().getReferenceParserRuleCall_0_0()); | 1719 | } |
1731 | } | 1720 | this_Reference_0=ruleReference |
1732 | this_Reference_0=ruleReference | 1721 | { |
1733 | { | 1722 | $current = $this_Reference_0.current; |
1734 | $current = $this_Reference_0.current; | 1723 | afterParserOrEnumRuleCall(); |
1735 | afterParserOrEnumRuleCall(); | 1724 | } |
1736 | } | ||
1737 | ( | ||
1738 | ( | ||
1739 | { | ||
1740 | $current = forceCreateModelElementAndSet( | ||
1741 | grammarAccess.getAtomicExpressionAccess().getCallFunctorAction_0_1_0(), | ||
1742 | $current); | ||
1743 | } | ||
1744 | ) | ||
1745 | ( | ||
1746 | ('(')=> | ||
1747 | ( | ||
1748 | { | ||
1749 | newCompositeNode(grammarAccess.getAtomicExpressionAccess().getArgumentListArgumentListParserRuleCall_0_1_1_0()); | ||
1750 | } | ||
1751 | lv_argumentList_2_0=ruleArgumentList | ||
1752 | { | ||
1753 | if ($current==null) { | ||
1754 | $current = createModelElementForParent(grammarAccess.getAtomicExpressionRule()); | ||
1755 | } | ||
1756 | set( | ||
1757 | $current, | ||
1758 | "argumentList", | ||
1759 | lv_argumentList_2_0, | ||
1760 | "org.eclipse.viatra.solver.language.SolverLanguage.ArgumentList"); | ||
1761 | afterParserOrEnumRuleCall(); | ||
1762 | } | ||
1763 | ) | ||
1764 | ) | ||
1765 | )? | ||
1766 | ) | ||
1767 | | | 1725 | | |
1768 | { | 1726 | { |
1769 | newCompositeNode(grammarAccess.getAtomicExpressionAccess().getIntervalParserRuleCall_1()); | 1727 | newCompositeNode(grammarAccess.getAtomicExpressionAccess().getCallParserRuleCall_1()); |
1770 | } | 1728 | } |
1771 | this_Interval_3=ruleInterval | 1729 | this_Call_1=ruleCall |
1772 | { | 1730 | { |
1773 | $current = $this_Interval_3.current; | 1731 | $current = $this_Call_1.current; |
1774 | afterParserOrEnumRuleCall(); | 1732 | afterParserOrEnumRuleCall(); |
1775 | } | 1733 | } |
1776 | | | 1734 | | |
1777 | { | 1735 | { |
1778 | newCompositeNode(grammarAccess.getAtomicExpressionAccess().getLiteralParserRuleCall_2()); | 1736 | newCompositeNode(grammarAccess.getAtomicExpressionAccess().getIntervalParserRuleCall_2()); |
1779 | } | 1737 | } |
1780 | this_Literal_4=ruleLiteral | 1738 | this_Interval_2=ruleInterval |
1781 | { | 1739 | { |
1782 | $current = $this_Literal_4.current; | 1740 | $current = $this_Interval_2.current; |
1741 | afterParserOrEnumRuleCall(); | ||
1742 | } | ||
1743 | | | ||
1744 | { | ||
1745 | newCompositeNode(grammarAccess.getAtomicExpressionAccess().getLiteralParserRuleCall_3()); | ||
1746 | } | ||
1747 | this_Literal_3=ruleLiteral | ||
1748 | { | ||
1749 | $current = $this_Literal_3.current; | ||
1783 | afterParserOrEnumRuleCall(); | 1750 | afterParserOrEnumRuleCall(); |
1784 | } | 1751 | } |
1785 | | | 1752 | | |
1786 | ( | 1753 | ( |
1787 | otherlv_5='(' | 1754 | otherlv_4=LeftParenthesis |
1788 | { | 1755 | { |
1789 | newLeafNode(otherlv_5, grammarAccess.getAtomicExpressionAccess().getLeftParenthesisKeyword_3_0()); | 1756 | newLeafNode(otherlv_4, grammarAccess.getAtomicExpressionAccess().getLeftParenthesisKeyword_4_0()); |
1790 | } | 1757 | } |
1791 | { | 1758 | { |
1792 | newCompositeNode(grammarAccess.getAtomicExpressionAccess().getExpressionParserRuleCall_3_1()); | 1759 | newCompositeNode(grammarAccess.getAtomicExpressionAccess().getExpressionParserRuleCall_4_1()); |
1793 | } | 1760 | } |
1794 | this_Expression_6=ruleExpression | 1761 | this_Expression_5=ruleExpression |
1795 | { | 1762 | { |
1796 | $current = $this_Expression_6.current; | 1763 | $current = $this_Expression_5.current; |
1797 | afterParserOrEnumRuleCall(); | 1764 | afterParserOrEnumRuleCall(); |
1798 | } | 1765 | } |
1799 | otherlv_7=')' | 1766 | otherlv_6=RightParenthesis |
1800 | { | 1767 | { |
1801 | newLeafNode(otherlv_7, grammarAccess.getAtomicExpressionAccess().getRightParenthesisKeyword_3_2()); | 1768 | newLeafNode(otherlv_6, grammarAccess.getAtomicExpressionAccess().getRightParenthesisKeyword_4_2()); |
1802 | } | 1769 | } |
1803 | ) | 1770 | ) |
1804 | ) | 1771 | ) |
@@ -1842,9 +1809,9 @@ ruleCall returns [EObject current=null] | |||
1842 | ( | 1809 | ( |
1843 | ( | 1810 | ( |
1844 | ( | 1811 | ( |
1845 | lv_transitiveClosure_1_0=RULE_STAR | 1812 | lv_transitiveClosure_1_0=RULE_TRANSITIVE_CLOSURE |
1846 | { | 1813 | { |
1847 | newLeafNode(lv_transitiveClosure_1_0, grammarAccess.getCallAccess().getTransitiveClosureSTARTerminalRuleCall_1_0_0()); | 1814 | newLeafNode(lv_transitiveClosure_1_0, grammarAccess.getCallAccess().getTransitiveClosureTRANSITIVE_CLOSURETerminalRuleCall_1_0_0()); |
1848 | } | 1815 | } |
1849 | { | 1816 | { |
1850 | if ($current==null) { | 1817 | if ($current==null) { |
@@ -1854,16 +1821,16 @@ ruleCall returns [EObject current=null] | |||
1854 | $current, | 1821 | $current, |
1855 | "transitiveClosure", | 1822 | "transitiveClosure", |
1856 | true, | 1823 | true, |
1857 | "org.eclipse.viatra.solver.language.SolverLanguage.STAR"); | 1824 | "org.eclipse.viatra.solver.language.SolverLanguage.TRANSITIVE_CLOSURE"); |
1858 | } | 1825 | } |
1859 | ) | 1826 | ) |
1860 | ) | 1827 | ) |
1861 | | | 1828 | | |
1862 | ( | 1829 | ( |
1863 | ( | 1830 | ( |
1864 | lv_reflexiveTransitiveClosure_2_0=RULE_PLUS | 1831 | lv_reflexiveTransitiveClosure_2_0=RULE_REFLEXIVE_TRANSITIVE_CLOSURE |
1865 | { | 1832 | { |
1866 | newLeafNode(lv_reflexiveTransitiveClosure_2_0, grammarAccess.getCallAccess().getReflexiveTransitiveClosurePLUSTerminalRuleCall_1_1_0()); | 1833 | newLeafNode(lv_reflexiveTransitiveClosure_2_0, grammarAccess.getCallAccess().getReflexiveTransitiveClosureREFLEXIVE_TRANSITIVE_CLOSURETerminalRuleCall_1_1_0()); |
1867 | } | 1834 | } |
1868 | { | 1835 | { |
1869 | if ($current==null) { | 1836 | if ($current==null) { |
@@ -1873,7 +1840,7 @@ ruleCall returns [EObject current=null] | |||
1873 | $current, | 1840 | $current, |
1874 | "reflexiveTransitiveClosure", | 1841 | "reflexiveTransitiveClosure", |
1875 | true, | 1842 | true, |
1876 | "org.eclipse.viatra.solver.language.SolverLanguage.PLUS"); | 1843 | "org.eclipse.viatra.solver.language.SolverLanguage.REFLEXIVE_TRANSITIVE_CLOSURE"); |
1877 | } | 1844 | } |
1878 | ) | 1845 | ) |
1879 | ) | 1846 | ) |
@@ -1923,7 +1890,7 @@ ruleArgumentList returns [EObject current=null] | |||
1923 | $current); | 1890 | $current); |
1924 | } | 1891 | } |
1925 | ) | 1892 | ) |
1926 | otherlv_1='(' | 1893 | otherlv_1=LeftParenthesis |
1927 | { | 1894 | { |
1928 | newLeafNode(otherlv_1, grammarAccess.getArgumentListAccess().getLeftParenthesisKeyword_1()); | 1895 | newLeafNode(otherlv_1, grammarAccess.getArgumentListAccess().getLeftParenthesisKeyword_1()); |
1929 | } | 1896 | } |
@@ -1948,7 +1915,7 @@ ruleArgumentList returns [EObject current=null] | |||
1948 | ) | 1915 | ) |
1949 | ) | 1916 | ) |
1950 | ( | 1917 | ( |
1951 | otherlv_3=',' | 1918 | otherlv_3=Comma |
1952 | { | 1919 | { |
1953 | newLeafNode(otherlv_3, grammarAccess.getArgumentListAccess().getCommaKeyword_2_1_0()); | 1920 | newLeafNode(otherlv_3, grammarAccess.getArgumentListAccess().getCommaKeyword_2_1_0()); |
1954 | } | 1921 | } |
@@ -1973,7 +1940,7 @@ ruleArgumentList returns [EObject current=null] | |||
1973 | ) | 1940 | ) |
1974 | )* | 1941 | )* |
1975 | )? | 1942 | )? |
1976 | otherlv_5=')' | 1943 | otherlv_5=RightParenthesis |
1977 | { | 1944 | { |
1978 | newLeafNode(otherlv_5, grammarAccess.getArgumentListAccess().getRightParenthesisKeyword_3()); | 1945 | newLeafNode(otherlv_5, grammarAccess.getArgumentListAccess().getRightParenthesisKeyword_3()); |
1979 | } | 1946 | } |
@@ -2093,7 +2060,7 @@ ruleStarArgument returns [EObject current=null] | |||
2093 | $current); | 2060 | $current); |
2094 | } | 2061 | } |
2095 | ) | 2062 | ) |
2096 | otherlv_1='*' | 2063 | otherlv_1=Asterisk |
2097 | { | 2064 | { |
2098 | newLeafNode(otherlv_1, grammarAccess.getStarArgumentAccess().getAsteriskKeyword_1()); | 2065 | newLeafNode(otherlv_1, grammarAccess.getStarArgumentAccess().getAsteriskKeyword_1()); |
2099 | } | 2066 | } |
@@ -2183,7 +2150,7 @@ ruleTypedStarArgument returns [EObject current=null] | |||
2183 | } | 2150 | } |
2184 | ) | 2151 | ) |
2185 | ) | 2152 | ) |
2186 | otherlv_1='*' | 2153 | otherlv_1=Asterisk |
2187 | { | 2154 | { |
2188 | newLeafNode(otherlv_1, grammarAccess.getTypedStarArgumentAccess().getAsteriskKeyword_1()); | 2155 | newLeafNode(otherlv_1, grammarAccess.getTypedStarArgumentAccess().getAsteriskKeyword_1()); |
2189 | } | 2156 | } |
@@ -2239,7 +2206,7 @@ ruleInterval returns [EObject current=null] | |||
2239 | leaveRule(); | 2206 | leaveRule(); |
2240 | }: | 2207 | }: |
2241 | ( | 2208 | ( |
2242 | otherlv_0='[' | 2209 | otherlv_0=LeftSquareBracket |
2243 | { | 2210 | { |
2244 | newLeafNode(otherlv_0, grammarAccess.getIntervalAccess().getLeftSquareBracketKeyword_0()); | 2211 | newLeafNode(otherlv_0, grammarAccess.getIntervalAccess().getLeftSquareBracketKeyword_0()); |
2245 | } | 2212 | } |
@@ -2262,7 +2229,7 @@ ruleInterval returns [EObject current=null] | |||
2262 | } | 2229 | } |
2263 | ) | 2230 | ) |
2264 | ) | 2231 | ) |
2265 | otherlv_2='..' | 2232 | otherlv_2=FullStopFullStop |
2266 | { | 2233 | { |
2267 | newLeafNode(otherlv_2, grammarAccess.getIntervalAccess().getFullStopFullStopKeyword_2()); | 2234 | newLeafNode(otherlv_2, grammarAccess.getIntervalAccess().getFullStopFullStopKeyword_2()); |
2268 | } | 2235 | } |
@@ -2285,7 +2252,7 @@ ruleInterval returns [EObject current=null] | |||
2285 | } | 2252 | } |
2286 | ) | 2253 | ) |
2287 | ) | 2254 | ) |
2288 | otherlv_4=']' | 2255 | otherlv_4=RightSquareBracket |
2289 | { | 2256 | { |
2290 | newLeafNode(otherlv_4, grammarAccess.getIntervalAccess().getRightSquareBracketKeyword_4()); | 2257 | newLeafNode(otherlv_4, grammarAccess.getIntervalAccess().getRightSquareBracketKeyword_4()); |
2291 | } | 2258 | } |
@@ -2450,7 +2417,7 @@ ruleInfinityLiteral returns [EObject current=null] | |||
2450 | $current); | 2417 | $current); |
2451 | } | 2418 | } |
2452 | ) | 2419 | ) |
2453 | otherlv_1='inf' | 2420 | otherlv_1=Inf |
2454 | { | 2421 | { |
2455 | newLeafNode(otherlv_1, grammarAccess.getInfinityLiteralAccess().getInfKeyword_1()); | 2422 | newLeafNode(otherlv_1, grammarAccess.getInfinityLiteralAccess().getInfKeyword_1()); |
2456 | } | 2423 | } |
@@ -2480,7 +2447,7 @@ ruleEmptyIntervalLiteral returns [EObject current=null] | |||
2480 | $current); | 2447 | $current); |
2481 | } | 2448 | } |
2482 | ) | 2449 | ) |
2483 | otherlv_1='empty' | 2450 | otherlv_1=Empty |
2484 | { | 2451 | { |
2485 | newLeafNode(otherlv_1, grammarAccess.getEmptyIntervalLiteralAccess().getEmptyKeyword_1()); | 2452 | newLeafNode(otherlv_1, grammarAccess.getEmptyIntervalLiteralAccess().getEmptyKeyword_1()); |
2486 | } | 2453 | } |
@@ -2540,7 +2507,7 @@ ruleClassDefinition returns [EObject current=null] | |||
2540 | ( | 2507 | ( |
2541 | ( | 2508 | ( |
2542 | ( | 2509 | ( |
2543 | lv_abstract_0_0='abstract' | 2510 | lv_abstract_0_0=Abstract |
2544 | { | 2511 | { |
2545 | newLeafNode(lv_abstract_0_0, grammarAccess.getClassDefinitionAccess().getAbstractAbstractKeyword_0_0()); | 2512 | newLeafNode(lv_abstract_0_0, grammarAccess.getClassDefinitionAccess().getAbstractAbstractKeyword_0_0()); |
2546 | } | 2513 | } |
@@ -2552,7 +2519,7 @@ ruleClassDefinition returns [EObject current=null] | |||
2552 | } | 2519 | } |
2553 | ) | 2520 | ) |
2554 | )? | 2521 | )? |
2555 | otherlv_1='class' | 2522 | otherlv_1=Class |
2556 | { | 2523 | { |
2557 | newLeafNode(otherlv_1, grammarAccess.getClassDefinitionAccess().getClassKeyword_1()); | 2524 | newLeafNode(otherlv_1, grammarAccess.getClassDefinitionAccess().getClassKeyword_1()); |
2558 | } | 2525 | } |
@@ -2575,7 +2542,7 @@ ruleClassDefinition returns [EObject current=null] | |||
2575 | ) | 2542 | ) |
2576 | ) | 2543 | ) |
2577 | ( | 2544 | ( |
2578 | otherlv_3='extends' | 2545 | otherlv_3=Extends |
2579 | { | 2546 | { |
2580 | newLeafNode(otherlv_3, grammarAccess.getClassDefinitionAccess().getExtendsKeyword_3_0()); | 2547 | newLeafNode(otherlv_3, grammarAccess.getClassDefinitionAccess().getExtendsKeyword_3_0()); |
2581 | } | 2548 | } |
@@ -2596,7 +2563,7 @@ ruleClassDefinition returns [EObject current=null] | |||
2596 | ) | 2563 | ) |
2597 | ) | 2564 | ) |
2598 | ( | 2565 | ( |
2599 | otherlv_5=',' | 2566 | otherlv_5=Comma |
2600 | { | 2567 | { |
2601 | newLeafNode(otherlv_5, grammarAccess.getClassDefinitionAccess().getCommaKeyword_3_2_0()); | 2568 | newLeafNode(otherlv_5, grammarAccess.getClassDefinitionAccess().getCommaKeyword_3_2_0()); |
2602 | } | 2569 | } |
@@ -2618,7 +2585,7 @@ ruleClassDefinition returns [EObject current=null] | |||
2618 | ) | 2585 | ) |
2619 | )* | 2586 | )* |
2620 | )? | 2587 | )? |
2621 | otherlv_7='{' | 2588 | otherlv_7=LeftCurlyBracket |
2622 | { | 2589 | { |
2623 | newLeafNode(otherlv_7, grammarAccess.getClassDefinitionAccess().getLeftCurlyBracketKeyword_4()); | 2590 | newLeafNode(otherlv_7, grammarAccess.getClassDefinitionAccess().getLeftCurlyBracketKeyword_4()); |
2624 | } | 2591 | } |
@@ -2641,7 +2608,7 @@ ruleClassDefinition returns [EObject current=null] | |||
2641 | } | 2608 | } |
2642 | ) | 2609 | ) |
2643 | )* | 2610 | )* |
2644 | otherlv_9='}' | 2611 | otherlv_9=RightCurlyBracket |
2645 | { | 2612 | { |
2646 | newLeafNode(otherlv_9, grammarAccess.getClassDefinitionAccess().getRightCurlyBracketKeyword_6()); | 2613 | newLeafNode(otherlv_9, grammarAccess.getClassDefinitionAccess().getRightCurlyBracketKeyword_6()); |
2647 | } | 2614 | } |
@@ -2666,7 +2633,7 @@ ruleMemberDefinition returns [EObject current=null] | |||
2666 | ( | 2633 | ( |
2667 | ( | 2634 | ( |
2668 | ( | 2635 | ( |
2669 | lv_containment_0_0='contains' | 2636 | lv_containment_0_0=Contains |
2670 | { | 2637 | { |
2671 | newLeafNode(lv_containment_0_0, grammarAccess.getMemberDefinitionAccess().getContainmentContainsKeyword_0_0()); | 2638 | newLeafNode(lv_containment_0_0, grammarAccess.getMemberDefinitionAccess().getContainmentContainsKeyword_0_0()); |
2672 | } | 2639 | } |
@@ -2732,7 +2699,7 @@ ruleMemberDefinition returns [EObject current=null] | |||
2732 | ) | 2699 | ) |
2733 | ) | 2700 | ) |
2734 | ( | 2701 | ( |
2735 | otherlv_4='opposite' | 2702 | otherlv_4=Opposite |
2736 | { | 2703 | { |
2737 | newLeafNode(otherlv_4, grammarAccess.getMemberDefinitionAccess().getOppositeKeyword_4_0()); | 2704 | newLeafNode(otherlv_4, grammarAccess.getMemberDefinitionAccess().getOppositeKeyword_4_0()); |
2738 | } | 2705 | } |
@@ -2754,7 +2721,7 @@ ruleMemberDefinition returns [EObject current=null] | |||
2754 | ) | 2721 | ) |
2755 | )? | 2722 | )? |
2756 | ( | 2723 | ( |
2757 | otherlv_6=';' | 2724 | otherlv_6=Semicolon |
2758 | { | 2725 | { |
2759 | newLeafNode(otherlv_6, grammarAccess.getMemberDefinitionAccess().getSemicolonKeyword_5()); | 2726 | newLeafNode(otherlv_6, grammarAccess.getMemberDefinitionAccess().getSemicolonKeyword_5()); |
2760 | } | 2727 | } |
@@ -2830,11 +2797,11 @@ ruleManyMultiplicity returns [EObject current=null] | |||
2830 | $current); | 2797 | $current); |
2831 | } | 2798 | } |
2832 | ) | 2799 | ) |
2833 | otherlv_1='[' | 2800 | otherlv_1=LeftSquareBracket |
2834 | { | 2801 | { |
2835 | newLeafNode(otherlv_1, grammarAccess.getManyMultiplicityAccess().getLeftSquareBracketKeyword_1()); | 2802 | newLeafNode(otherlv_1, grammarAccess.getManyMultiplicityAccess().getLeftSquareBracketKeyword_1()); |
2836 | } | 2803 | } |
2837 | otherlv_2=']' | 2804 | otherlv_2=RightSquareBracket |
2838 | { | 2805 | { |
2839 | newLeafNode(otherlv_2, grammarAccess.getManyMultiplicityAccess().getRightSquareBracketKeyword_2()); | 2806 | newLeafNode(otherlv_2, grammarAccess.getManyMultiplicityAccess().getRightSquareBracketKeyword_2()); |
2840 | } | 2807 | } |
@@ -2857,7 +2824,7 @@ ruleExactMultiplicity returns [EObject current=null] | |||
2857 | leaveRule(); | 2824 | leaveRule(); |
2858 | }: | 2825 | }: |
2859 | ( | 2826 | ( |
2860 | otherlv_0='[' | 2827 | otherlv_0=LeftSquareBracket |
2861 | { | 2828 | { |
2862 | newLeafNode(otherlv_0, grammarAccess.getExactMultiplicityAccess().getLeftSquareBracketKeyword_0()); | 2829 | newLeafNode(otherlv_0, grammarAccess.getExactMultiplicityAccess().getLeftSquareBracketKeyword_0()); |
2863 | } | 2830 | } |
@@ -2880,7 +2847,7 @@ ruleExactMultiplicity returns [EObject current=null] | |||
2880 | } | 2847 | } |
2881 | ) | 2848 | ) |
2882 | ) | 2849 | ) |
2883 | otherlv_2=']' | 2850 | otherlv_2=RightSquareBracket |
2884 | { | 2851 | { |
2885 | newLeafNode(otherlv_2, grammarAccess.getExactMultiplicityAccess().getRightSquareBracketKeyword_2()); | 2852 | newLeafNode(otherlv_2, grammarAccess.getExactMultiplicityAccess().getRightSquareBracketKeyword_2()); |
2886 | } | 2853 | } |
@@ -2903,7 +2870,7 @@ ruleBoundedMultiplicity returns [EObject current=null] | |||
2903 | leaveRule(); | 2870 | leaveRule(); |
2904 | }: | 2871 | }: |
2905 | ( | 2872 | ( |
2906 | otherlv_0='[' | 2873 | otherlv_0=LeftSquareBracket |
2907 | { | 2874 | { |
2908 | newLeafNode(otherlv_0, grammarAccess.getBoundedMultiplicityAccess().getLeftSquareBracketKeyword_0()); | 2875 | newLeafNode(otherlv_0, grammarAccess.getBoundedMultiplicityAccess().getLeftSquareBracketKeyword_0()); |
2909 | } | 2876 | } |
@@ -2925,7 +2892,7 @@ ruleBoundedMultiplicity returns [EObject current=null] | |||
2925 | } | 2892 | } |
2926 | ) | 2893 | ) |
2927 | ) | 2894 | ) |
2928 | otherlv_2='..' | 2895 | otherlv_2=FullStopFullStop |
2929 | { | 2896 | { |
2930 | newLeafNode(otherlv_2, grammarAccess.getBoundedMultiplicityAccess().getFullStopFullStopKeyword_2()); | 2897 | newLeafNode(otherlv_2, grammarAccess.getBoundedMultiplicityAccess().getFullStopFullStopKeyword_2()); |
2931 | } | 2898 | } |
@@ -2948,7 +2915,7 @@ ruleBoundedMultiplicity returns [EObject current=null] | |||
2948 | } | 2915 | } |
2949 | ) | 2916 | ) |
2950 | ) | 2917 | ) |
2951 | otherlv_4=']' | 2918 | otherlv_4=RightSquareBracket |
2952 | { | 2919 | { |
2953 | newLeafNode(otherlv_4, grammarAccess.getBoundedMultiplicityAccess().getRightSquareBracketKeyword_4()); | 2920 | newLeafNode(otherlv_4, grammarAccess.getBoundedMultiplicityAccess().getRightSquareBracketKeyword_4()); |
2954 | } | 2921 | } |
@@ -3016,7 +2983,7 @@ ruleExactScopeDefinition returns [EObject current=null] | |||
3016 | leaveRule(); | 2983 | leaveRule(); |
3017 | }: | 2984 | }: |
3018 | ( | 2985 | ( |
3019 | otherlv_0='scope' | 2986 | otherlv_0=Scope |
3020 | { | 2987 | { |
3021 | newLeafNode(otherlv_0, grammarAccess.getExactScopeDefinitionAccess().getScopeKeyword_0()); | 2988 | newLeafNode(otherlv_0, grammarAccess.getExactScopeDefinitionAccess().getScopeKeyword_0()); |
3022 | } | 2989 | } |
@@ -3036,7 +3003,7 @@ ruleExactScopeDefinition returns [EObject current=null] | |||
3036 | } | 3003 | } |
3037 | ) | 3004 | ) |
3038 | ) | 3005 | ) |
3039 | otherlv_2='==' | 3006 | otherlv_2=EqualsSignEqualsSign |
3040 | { | 3007 | { |
3041 | newLeafNode(otherlv_2, grammarAccess.getExactScopeDefinitionAccess().getEqualsSignEqualsSignKeyword_2()); | 3008 | newLeafNode(otherlv_2, grammarAccess.getExactScopeDefinitionAccess().getEqualsSignEqualsSignKeyword_2()); |
3042 | } | 3009 | } |
@@ -3077,7 +3044,7 @@ ruleBoundedScopeDefinition returns [EObject current=null] | |||
3077 | leaveRule(); | 3044 | leaveRule(); |
3078 | }: | 3045 | }: |
3079 | ( | 3046 | ( |
3080 | otherlv_0='scope' | 3047 | otherlv_0=Scope |
3081 | { | 3048 | { |
3082 | newLeafNode(otherlv_0, grammarAccess.getBoundedScopeDefinitionAccess().getScopeKeyword_0()); | 3049 | newLeafNode(otherlv_0, grammarAccess.getBoundedScopeDefinitionAccess().getScopeKeyword_0()); |
3083 | } | 3050 | } |
@@ -3102,7 +3069,7 @@ ruleBoundedScopeDefinition returns [EObject current=null] | |||
3102 | } | 3069 | } |
3103 | ) | 3070 | ) |
3104 | ) | 3071 | ) |
3105 | otherlv_2='<=' | 3072 | otherlv_2=LessThanSignEqualsSign |
3106 | { | 3073 | { |
3107 | newLeafNode(otherlv_2, grammarAccess.getBoundedScopeDefinitionAccess().getLessThanSignEqualsSignKeyword_1_0_0_1()); | 3074 | newLeafNode(otherlv_2, grammarAccess.getBoundedScopeDefinitionAccess().getLessThanSignEqualsSignKeyword_1_0_0_1()); |
3108 | } | 3075 | } |
@@ -3123,7 +3090,7 @@ ruleBoundedScopeDefinition returns [EObject current=null] | |||
3123 | } | 3090 | } |
3124 | ) | 3091 | ) |
3125 | ) | 3092 | ) |
3126 | otherlv_4='<=' | 3093 | otherlv_4=LessThanSignEqualsSign |
3127 | { | 3094 | { |
3128 | newLeafNode(otherlv_4, grammarAccess.getBoundedScopeDefinitionAccess().getLessThanSignEqualsSignKeyword_1_0_2()); | 3095 | newLeafNode(otherlv_4, grammarAccess.getBoundedScopeDefinitionAccess().getLessThanSignEqualsSignKeyword_1_0_2()); |
3129 | } | 3096 | } |
@@ -3166,7 +3133,7 @@ ruleBoundedScopeDefinition returns [EObject current=null] | |||
3166 | } | 3133 | } |
3167 | ) | 3134 | ) |
3168 | ) | 3135 | ) |
3169 | otherlv_7='>=' | 3136 | otherlv_7=GreaterThanSignEqualsSign |
3170 | { | 3137 | { |
3171 | newLeafNode(otherlv_7, grammarAccess.getBoundedScopeDefinitionAccess().getGreaterThanSignEqualsSignKeyword_1_1_1()); | 3138 | newLeafNode(otherlv_7, grammarAccess.getBoundedScopeDefinitionAccess().getGreaterThanSignEqualsSignKeyword_1_1_1()); |
3172 | } | 3139 | } |
@@ -3187,7 +3154,7 @@ ruleBoundedScopeDefinition returns [EObject current=null] | |||
3187 | ) | 3154 | ) |
3188 | ) | 3155 | ) |
3189 | ( | 3156 | ( |
3190 | otherlv_9='>=' | 3157 | otherlv_9=GreaterThanSignEqualsSign |
3191 | { | 3158 | { |
3192 | newLeafNode(otherlv_9, grammarAccess.getBoundedScopeDefinitionAccess().getGreaterThanSignEqualsSignKeyword_1_1_3_0()); | 3159 | newLeafNode(otherlv_9, grammarAccess.getBoundedScopeDefinitionAccess().getGreaterThanSignEqualsSignKeyword_1_1_3_0()); |
3193 | } | 3160 | } |
@@ -3212,10 +3179,6 @@ ruleBoundedScopeDefinition returns [EObject current=null] | |||
3212 | )? | 3179 | )? |
3213 | ) | 3180 | ) |
3214 | ) | 3181 | ) |
3215 | otherlv_11='.' | ||
3216 | { | ||
3217 | newLeafNode(otherlv_11, grammarAccess.getBoundedScopeDefinitionAccess().getFullStopKeyword_2()); | ||
3218 | } | ||
3219 | ) | 3182 | ) |
3220 | ; | 3183 | ; |
3221 | 3184 | ||
@@ -3235,7 +3198,7 @@ ruleLowerBoundedScopeDefinition returns [EObject current=null] | |||
3235 | leaveRule(); | 3198 | leaveRule(); |
3236 | }: | 3199 | }: |
3237 | ( | 3200 | ( |
3238 | otherlv_0='scope' | 3201 | otherlv_0=Scope |
3239 | { | 3202 | { |
3240 | newLeafNode(otherlv_0, grammarAccess.getLowerBoundedScopeDefinitionAccess().getScopeKeyword_0()); | 3203 | newLeafNode(otherlv_0, grammarAccess.getLowerBoundedScopeDefinitionAccess().getScopeKeyword_0()); |
3241 | } | 3204 | } |
@@ -3259,7 +3222,7 @@ ruleLowerBoundedScopeDefinition returns [EObject current=null] | |||
3259 | } | 3222 | } |
3260 | ) | 3223 | ) |
3261 | ) | 3224 | ) |
3262 | otherlv_2='<=' | 3225 | otherlv_2=LessThanSignEqualsSign |
3263 | { | 3226 | { |
3264 | newLeafNode(otherlv_2, grammarAccess.getLowerBoundedScopeDefinitionAccess().getLessThanSignEqualsSignKeyword_1_0_1()); | 3227 | newLeafNode(otherlv_2, grammarAccess.getLowerBoundedScopeDefinitionAccess().getLessThanSignEqualsSignKeyword_1_0_1()); |
3265 | } | 3228 | } |
@@ -3298,7 +3261,7 @@ ruleLowerBoundedScopeDefinition returns [EObject current=null] | |||
3298 | } | 3261 | } |
3299 | ) | 3262 | ) |
3300 | ) | 3263 | ) |
3301 | otherlv_5='>=' | 3264 | otherlv_5=GreaterThanSignEqualsSign |
3302 | { | 3265 | { |
3303 | newLeafNode(otherlv_5, grammarAccess.getLowerBoundedScopeDefinitionAccess().getGreaterThanSignEqualsSignKeyword_1_1_1()); | 3266 | newLeafNode(otherlv_5, grammarAccess.getLowerBoundedScopeDefinitionAccess().getGreaterThanSignEqualsSignKeyword_1_1_1()); |
3304 | } | 3267 | } |
@@ -3322,10 +3285,6 @@ ruleLowerBoundedScopeDefinition returns [EObject current=null] | |||
3322 | ) | 3285 | ) |
3323 | ) | 3286 | ) |
3324 | ) | 3287 | ) |
3325 | otherlv_7='.' | ||
3326 | { | ||
3327 | newLeafNode(otherlv_7, grammarAccess.getLowerBoundedScopeDefinitionAccess().getFullStopKeyword_2()); | ||
3328 | } | ||
3329 | ) | 3288 | ) |
3330 | ; | 3289 | ; |
3331 | 3290 | ||
@@ -3410,7 +3369,7 @@ ruleUpperMultiplicty returns [AntlrDatatypeRuleToken current=new AntlrDatatypeRu | |||
3410 | newLeafNode(this_INT_0, grammarAccess.getUpperMultiplictyAccess().getINTTerminalRuleCall_0()); | 3369 | newLeafNode(this_INT_0, grammarAccess.getUpperMultiplictyAccess().getINTTerminalRuleCall_0()); |
3411 | } | 3370 | } |
3412 | | | 3371 | | |
3413 | kw='*' | 3372 | kw=Asterisk |
3414 | { | 3373 | { |
3415 | $current.merge(kw); | 3374 | $current.merge(kw); |
3416 | newLeafNode(kw, grammarAccess.getUpperMultiplictyAccess().getAsteriskKeyword_1()); | 3375 | newLeafNode(kw, grammarAccess.getUpperMultiplictyAccess().getAsteriskKeyword_1()); |
@@ -3448,7 +3407,7 @@ ruleReal returns [AntlrDatatypeRuleToken current=new AntlrDatatypeRuleToken()] | |||
3448 | newLeafNode(this_INT_0, grammarAccess.getRealAccess().getINTTerminalRuleCall_0()); | 3407 | newLeafNode(this_INT_0, grammarAccess.getRealAccess().getINTTerminalRuleCall_0()); |
3449 | } | 3408 | } |
3450 | ( | 3409 | ( |
3451 | kw='.' | 3410 | kw=FullStop |
3452 | { | 3411 | { |
3453 | $current.merge(kw); | 3412 | $current.merge(kw); |
3454 | newLeafNode(kw, grammarAccess.getRealAccess().getFullStopKeyword_1_0()); | 3413 | newLeafNode(kw, grammarAccess.getRealAccess().getFullStopKeyword_1_0()); |
@@ -3498,7 +3457,7 @@ ruleQualifiedName returns [AntlrDatatypeRuleToken current=new AntlrDatatypeRuleT | |||
3498 | newLeafNode(this_ID_0, grammarAccess.getQualifiedNameAccess().getIDTerminalRuleCall_0_0()); | 3457 | newLeafNode(this_ID_0, grammarAccess.getQualifiedNameAccess().getIDTerminalRuleCall_0_0()); |
3499 | } | 3458 | } |
3500 | ( | 3459 | ( |
3501 | kw='.' | 3460 | kw=FullStop |
3502 | { | 3461 | { |
3503 | $current.merge(kw); | 3462 | $current.merge(kw); |
3504 | newLeafNode(kw, grammarAccess.getQualifiedNameAccess().getFullStopKeyword_0_1_0()); | 3463 | newLeafNode(kw, grammarAccess.getQualifiedNameAccess().getFullStopKeyword_0_1_0()); |
@@ -3536,7 +3495,7 @@ ruleMetricType returns [Enumerator current=null] | |||
3536 | }: | 3495 | }: |
3537 | ( | 3496 | ( |
3538 | ( | 3497 | ( |
3539 | enumLiteral_0='int' | 3498 | enumLiteral_0=Int |
3540 | { | 3499 | { |
3541 | $current = grammarAccess.getMetricTypeAccess().getINTEnumLiteralDeclaration_0().getEnumLiteral().getInstance(); | 3500 | $current = grammarAccess.getMetricTypeAccess().getINTEnumLiteralDeclaration_0().getEnumLiteral().getInstance(); |
3542 | newLeafNode(enumLiteral_0, grammarAccess.getMetricTypeAccess().getINTEnumLiteralDeclaration_0()); | 3501 | newLeafNode(enumLiteral_0, grammarAccess.getMetricTypeAccess().getINTEnumLiteralDeclaration_0()); |
@@ -3544,7 +3503,7 @@ ruleMetricType returns [Enumerator current=null] | |||
3544 | ) | 3503 | ) |
3545 | | | 3504 | | |
3546 | ( | 3505 | ( |
3547 | enumLiteral_1='real' | 3506 | enumLiteral_1=Real |
3548 | { | 3507 | { |
3549 | $current = grammarAccess.getMetricTypeAccess().getREALEnumLiteralDeclaration_1().getEnumLiteral().getInstance(); | 3508 | $current = grammarAccess.getMetricTypeAccess().getREALEnumLiteralDeclaration_1().getEnumLiteral().getInstance(); |
3550 | newLeafNode(enumLiteral_1, grammarAccess.getMetricTypeAccess().getREALEnumLiteralDeclaration_1()); | 3509 | newLeafNode(enumLiteral_1, grammarAccess.getMetricTypeAccess().getREALEnumLiteralDeclaration_1()); |
@@ -3563,7 +3522,7 @@ ruleComparisonOperator returns [Enumerator current=null] | |||
3563 | }: | 3522 | }: |
3564 | ( | 3523 | ( |
3565 | ( | 3524 | ( |
3566 | enumLiteral_0='==' | 3525 | enumLiteral_0=EqualsSignEqualsSign |
3567 | { | 3526 | { |
3568 | $current = grammarAccess.getComparisonOperatorAccess().getEQEnumLiteralDeclaration_0().getEnumLiteral().getInstance(); | 3527 | $current = grammarAccess.getComparisonOperatorAccess().getEQEnumLiteralDeclaration_0().getEnumLiteral().getInstance(); |
3569 | newLeafNode(enumLiteral_0, grammarAccess.getComparisonOperatorAccess().getEQEnumLiteralDeclaration_0()); | 3528 | newLeafNode(enumLiteral_0, grammarAccess.getComparisonOperatorAccess().getEQEnumLiteralDeclaration_0()); |
@@ -3571,7 +3530,7 @@ ruleComparisonOperator returns [Enumerator current=null] | |||
3571 | ) | 3530 | ) |
3572 | | | 3531 | | |
3573 | ( | 3532 | ( |
3574 | enumLiteral_1='!=' | 3533 | enumLiteral_1=ExclamationMarkEqualsSign |
3575 | { | 3534 | { |
3576 | $current = grammarAccess.getComparisonOperatorAccess().getNOT_EQEnumLiteralDeclaration_1().getEnumLiteral().getInstance(); | 3535 | $current = grammarAccess.getComparisonOperatorAccess().getNOT_EQEnumLiteralDeclaration_1().getEnumLiteral().getInstance(); |
3577 | newLeafNode(enumLiteral_1, grammarAccess.getComparisonOperatorAccess().getNOT_EQEnumLiteralDeclaration_1()); | 3536 | newLeafNode(enumLiteral_1, grammarAccess.getComparisonOperatorAccess().getNOT_EQEnumLiteralDeclaration_1()); |
@@ -3579,7 +3538,7 @@ ruleComparisonOperator returns [Enumerator current=null] | |||
3579 | ) | 3538 | ) |
3580 | | | 3539 | | |
3581 | ( | 3540 | ( |
3582 | enumLiteral_2='<' | 3541 | enumLiteral_2=LessThanSign |
3583 | { | 3542 | { |
3584 | $current = grammarAccess.getComparisonOperatorAccess().getLESSEnumLiteralDeclaration_2().getEnumLiteral().getInstance(); | 3543 | $current = grammarAccess.getComparisonOperatorAccess().getLESSEnumLiteralDeclaration_2().getEnumLiteral().getInstance(); |
3585 | newLeafNode(enumLiteral_2, grammarAccess.getComparisonOperatorAccess().getLESSEnumLiteralDeclaration_2()); | 3544 | newLeafNode(enumLiteral_2, grammarAccess.getComparisonOperatorAccess().getLESSEnumLiteralDeclaration_2()); |
@@ -3587,7 +3546,7 @@ ruleComparisonOperator returns [Enumerator current=null] | |||
3587 | ) | 3546 | ) |
3588 | | | 3547 | | |
3589 | ( | 3548 | ( |
3590 | enumLiteral_3='<=' | 3549 | enumLiteral_3=LessThanSignEqualsSign |
3591 | { | 3550 | { |
3592 | $current = grammarAccess.getComparisonOperatorAccess().getLESS_EQEnumLiteralDeclaration_3().getEnumLiteral().getInstance(); | 3551 | $current = grammarAccess.getComparisonOperatorAccess().getLESS_EQEnumLiteralDeclaration_3().getEnumLiteral().getInstance(); |
3593 | newLeafNode(enumLiteral_3, grammarAccess.getComparisonOperatorAccess().getLESS_EQEnumLiteralDeclaration_3()); | 3552 | newLeafNode(enumLiteral_3, grammarAccess.getComparisonOperatorAccess().getLESS_EQEnumLiteralDeclaration_3()); |
@@ -3595,7 +3554,7 @@ ruleComparisonOperator returns [Enumerator current=null] | |||
3595 | ) | 3554 | ) |
3596 | | | 3555 | | |
3597 | ( | 3556 | ( |
3598 | enumLiteral_4='>' | 3557 | enumLiteral_4=GreaterThanSign |
3599 | { | 3558 | { |
3600 | $current = grammarAccess.getComparisonOperatorAccess().getGREATEREnumLiteralDeclaration_4().getEnumLiteral().getInstance(); | 3559 | $current = grammarAccess.getComparisonOperatorAccess().getGREATEREnumLiteralDeclaration_4().getEnumLiteral().getInstance(); |
3601 | newLeafNode(enumLiteral_4, grammarAccess.getComparisonOperatorAccess().getGREATEREnumLiteralDeclaration_4()); | 3560 | newLeafNode(enumLiteral_4, grammarAccess.getComparisonOperatorAccess().getGREATEREnumLiteralDeclaration_4()); |
@@ -3603,7 +3562,7 @@ ruleComparisonOperator returns [Enumerator current=null] | |||
3603 | ) | 3562 | ) |
3604 | | | 3563 | | |
3605 | ( | 3564 | ( |
3606 | enumLiteral_5='>=' | 3565 | enumLiteral_5=GreaterThanSignEqualsSign |
3607 | { | 3566 | { |
3608 | $current = grammarAccess.getComparisonOperatorAccess().getGREATER_EQEnumLiteralDeclaration_5().getEnumLiteral().getInstance(); | 3567 | $current = grammarAccess.getComparisonOperatorAccess().getGREATER_EQEnumLiteralDeclaration_5().getEnumLiteral().getInstance(); |
3609 | newLeafNode(enumLiteral_5, grammarAccess.getComparisonOperatorAccess().getGREATER_EQEnumLiteralDeclaration_5()); | 3568 | newLeafNode(enumLiteral_5, grammarAccess.getComparisonOperatorAccess().getGREATER_EQEnumLiteralDeclaration_5()); |
@@ -3611,7 +3570,7 @@ ruleComparisonOperator returns [Enumerator current=null] | |||
3611 | ) | 3570 | ) |
3612 | | | 3571 | | |
3613 | ( | 3572 | ( |
3614 | enumLiteral_6='in' | 3573 | enumLiteral_6=In |
3615 | { | 3574 | { |
3616 | $current = grammarAccess.getComparisonOperatorAccess().getINEnumLiteralDeclaration_6().getEnumLiteral().getInstance(); | 3575 | $current = grammarAccess.getComparisonOperatorAccess().getINEnumLiteralDeclaration_6().getEnumLiteral().getInstance(); |
3617 | newLeafNode(enumLiteral_6, grammarAccess.getComparisonOperatorAccess().getINEnumLiteralDeclaration_6()); | 3576 | newLeafNode(enumLiteral_6, grammarAccess.getComparisonOperatorAccess().getINEnumLiteralDeclaration_6()); |
@@ -3630,7 +3589,7 @@ ruleAdditiveBinaryOperator returns [Enumerator current=null] | |||
3630 | }: | 3589 | }: |
3631 | ( | 3590 | ( |
3632 | ( | 3591 | ( |
3633 | enumLiteral_0='+' | 3592 | enumLiteral_0=PlusSign |
3634 | { | 3593 | { |
3635 | $current = grammarAccess.getAdditiveBinaryOperatorAccess().getADDEnumLiteralDeclaration_0().getEnumLiteral().getInstance(); | 3594 | $current = grammarAccess.getAdditiveBinaryOperatorAccess().getADDEnumLiteralDeclaration_0().getEnumLiteral().getInstance(); |
3636 | newLeafNode(enumLiteral_0, grammarAccess.getAdditiveBinaryOperatorAccess().getADDEnumLiteralDeclaration_0()); | 3595 | newLeafNode(enumLiteral_0, grammarAccess.getAdditiveBinaryOperatorAccess().getADDEnumLiteralDeclaration_0()); |
@@ -3638,7 +3597,7 @@ ruleAdditiveBinaryOperator returns [Enumerator current=null] | |||
3638 | ) | 3597 | ) |
3639 | | | 3598 | | |
3640 | ( | 3599 | ( |
3641 | enumLiteral_1='-' | 3600 | enumLiteral_1=HyphenMinus |
3642 | { | 3601 | { |
3643 | $current = grammarAccess.getAdditiveBinaryOperatorAccess().getSUBEnumLiteralDeclaration_1().getEnumLiteral().getInstance(); | 3602 | $current = grammarAccess.getAdditiveBinaryOperatorAccess().getSUBEnumLiteralDeclaration_1().getEnumLiteral().getInstance(); |
3644 | newLeafNode(enumLiteral_1, grammarAccess.getAdditiveBinaryOperatorAccess().getSUBEnumLiteralDeclaration_1()); | 3603 | newLeafNode(enumLiteral_1, grammarAccess.getAdditiveBinaryOperatorAccess().getSUBEnumLiteralDeclaration_1()); |
@@ -3657,7 +3616,7 @@ ruleMultiplicativeBinaryOperator returns [Enumerator current=null] | |||
3657 | }: | 3616 | }: |
3658 | ( | 3617 | ( |
3659 | ( | 3618 | ( |
3660 | enumLiteral_0='*' | 3619 | enumLiteral_0=Asterisk |
3661 | { | 3620 | { |
3662 | $current = grammarAccess.getMultiplicativeBinaryOperatorAccess().getMULEnumLiteralDeclaration_0().getEnumLiteral().getInstance(); | 3621 | $current = grammarAccess.getMultiplicativeBinaryOperatorAccess().getMULEnumLiteralDeclaration_0().getEnumLiteral().getInstance(); |
3663 | newLeafNode(enumLiteral_0, grammarAccess.getMultiplicativeBinaryOperatorAccess().getMULEnumLiteralDeclaration_0()); | 3622 | newLeafNode(enumLiteral_0, grammarAccess.getMultiplicativeBinaryOperatorAccess().getMULEnumLiteralDeclaration_0()); |
@@ -3665,7 +3624,7 @@ ruleMultiplicativeBinaryOperator returns [Enumerator current=null] | |||
3665 | ) | 3624 | ) |
3666 | | | 3625 | | |
3667 | ( | 3626 | ( |
3668 | enumLiteral_1='/' | 3627 | enumLiteral_1=Solidus |
3669 | { | 3628 | { |
3670 | $current = grammarAccess.getMultiplicativeBinaryOperatorAccess().getDIVEnumLiteralDeclaration_1().getEnumLiteral().getInstance(); | 3629 | $current = grammarAccess.getMultiplicativeBinaryOperatorAccess().getDIVEnumLiteralDeclaration_1().getEnumLiteral().getInstance(); |
3671 | newLeafNode(enumLiteral_1, grammarAccess.getMultiplicativeBinaryOperatorAccess().getDIVEnumLiteralDeclaration_1()); | 3630 | newLeafNode(enumLiteral_1, grammarAccess.getMultiplicativeBinaryOperatorAccess().getDIVEnumLiteralDeclaration_1()); |
@@ -3683,7 +3642,7 @@ ruleExponentialOp returns [Enumerator current=null] | |||
3683 | leaveRule(); | 3642 | leaveRule(); |
3684 | }: | 3643 | }: |
3685 | ( | 3644 | ( |
3686 | enumLiteral_0='^' | 3645 | enumLiteral_0=CircumflexAccent |
3687 | { | 3646 | { |
3688 | $current = grammarAccess.getExponentialOpAccess().getPOWEnumLiteralDeclaration().getEnumLiteral().getInstance(); | 3647 | $current = grammarAccess.getExponentialOpAccess().getPOWEnumLiteralDeclaration().getEnumLiteral().getInstance(); |
3689 | newLeafNode(enumLiteral_0, grammarAccess.getExponentialOpAccess().getPOWEnumLiteralDeclaration()); | 3648 | newLeafNode(enumLiteral_0, grammarAccess.getExponentialOpAccess().getPOWEnumLiteralDeclaration()); |
@@ -3701,7 +3660,7 @@ ruleUnaryOp returns [Enumerator current=null] | |||
3701 | }: | 3660 | }: |
3702 | ( | 3661 | ( |
3703 | ( | 3662 | ( |
3704 | enumLiteral_0='!' | 3663 | enumLiteral_0=ExclamationMark |
3705 | { | 3664 | { |
3706 | $current = grammarAccess.getUnaryOpAccess().getNEGEnumLiteralDeclaration_0().getEnumLiteral().getInstance(); | 3665 | $current = grammarAccess.getUnaryOpAccess().getNEGEnumLiteralDeclaration_0().getEnumLiteral().getInstance(); |
3707 | newLeafNode(enumLiteral_0, grammarAccess.getUnaryOpAccess().getNEGEnumLiteralDeclaration_0()); | 3666 | newLeafNode(enumLiteral_0, grammarAccess.getUnaryOpAccess().getNEGEnumLiteralDeclaration_0()); |
@@ -3709,7 +3668,7 @@ ruleUnaryOp returns [Enumerator current=null] | |||
3709 | ) | 3668 | ) |
3710 | | | 3669 | | |
3711 | ( | 3670 | ( |
3712 | enumLiteral_1='+' | 3671 | enumLiteral_1=PlusSign |
3713 | { | 3672 | { |
3714 | $current = grammarAccess.getUnaryOpAccess().getPLUSEnumLiteralDeclaration_1().getEnumLiteral().getInstance(); | 3673 | $current = grammarAccess.getUnaryOpAccess().getPLUSEnumLiteralDeclaration_1().getEnumLiteral().getInstance(); |
3715 | newLeafNode(enumLiteral_1, grammarAccess.getUnaryOpAccess().getPLUSEnumLiteralDeclaration_1()); | 3674 | newLeafNode(enumLiteral_1, grammarAccess.getUnaryOpAccess().getPLUSEnumLiteralDeclaration_1()); |
@@ -3717,7 +3676,7 @@ ruleUnaryOp returns [Enumerator current=null] | |||
3717 | ) | 3676 | ) |
3718 | | | 3677 | | |
3719 | ( | 3678 | ( |
3720 | enumLiteral_2='-' | 3679 | enumLiteral_2=HyphenMinus |
3721 | { | 3680 | { |
3722 | $current = grammarAccess.getUnaryOpAccess().getMINUSEnumLiteralDeclaration_2().getEnumLiteral().getInstance(); | 3681 | $current = grammarAccess.getUnaryOpAccess().getMINUSEnumLiteralDeclaration_2().getEnumLiteral().getInstance(); |
3723 | newLeafNode(enumLiteral_2, grammarAccess.getUnaryOpAccess().getMINUSEnumLiteralDeclaration_2()); | 3682 | newLeafNode(enumLiteral_2, grammarAccess.getUnaryOpAccess().getMINUSEnumLiteralDeclaration_2()); |
@@ -3725,7 +3684,7 @@ ruleUnaryOp returns [Enumerator current=null] | |||
3725 | ) | 3684 | ) |
3726 | | | 3685 | | |
3727 | ( | 3686 | ( |
3728 | enumLiteral_3='may' | 3687 | enumLiteral_3=May |
3729 | { | 3688 | { |
3730 | $current = grammarAccess.getUnaryOpAccess().getMAYEnumLiteralDeclaration_3().getEnumLiteral().getInstance(); | 3689 | $current = grammarAccess.getUnaryOpAccess().getMAYEnumLiteralDeclaration_3().getEnumLiteral().getInstance(); |
3731 | newLeafNode(enumLiteral_3, grammarAccess.getUnaryOpAccess().getMAYEnumLiteralDeclaration_3()); | 3690 | newLeafNode(enumLiteral_3, grammarAccess.getUnaryOpAccess().getMAYEnumLiteralDeclaration_3()); |
@@ -3733,7 +3692,7 @@ ruleUnaryOp returns [Enumerator current=null] | |||
3733 | ) | 3692 | ) |
3734 | | | 3693 | | |
3735 | ( | 3694 | ( |
3736 | enumLiteral_4='must' | 3695 | enumLiteral_4=Must |
3737 | { | 3696 | { |
3738 | $current = grammarAccess.getUnaryOpAccess().getMUSTEnumLiteralDeclaration_4().getEnumLiteral().getInstance(); | 3697 | $current = grammarAccess.getUnaryOpAccess().getMUSTEnumLiteralDeclaration_4().getEnumLiteral().getInstance(); |
3739 | newLeafNode(enumLiteral_4, grammarAccess.getUnaryOpAccess().getMUSTEnumLiteralDeclaration_4()); | 3698 | newLeafNode(enumLiteral_4, grammarAccess.getUnaryOpAccess().getMUSTEnumLiteralDeclaration_4()); |
@@ -3741,7 +3700,7 @@ ruleUnaryOp returns [Enumerator current=null] | |||
3741 | ) | 3700 | ) |
3742 | | | 3701 | | |
3743 | ( | 3702 | ( |
3744 | enumLiteral_5='current' | 3703 | enumLiteral_5=Current |
3745 | { | 3704 | { |
3746 | $current = grammarAccess.getUnaryOpAccess().getCURRENTEnumLiteralDeclaration_5().getEnumLiteral().getInstance(); | 3705 | $current = grammarAccess.getUnaryOpAccess().getCURRENTEnumLiteralDeclaration_5().getEnumLiteral().getInstance(); |
3747 | newLeafNode(enumLiteral_5, grammarAccess.getUnaryOpAccess().getCURRENTEnumLiteralDeclaration_5()); | 3706 | newLeafNode(enumLiteral_5, grammarAccess.getUnaryOpAccess().getCURRENTEnumLiteralDeclaration_5()); |
@@ -3760,7 +3719,7 @@ ruleAggregationOp returns [Enumerator current=null] | |||
3760 | }: | 3719 | }: |
3761 | ( | 3720 | ( |
3762 | ( | 3721 | ( |
3763 | enumLiteral_0='only' | 3722 | enumLiteral_0=Only |
3764 | { | 3723 | { |
3765 | $current = grammarAccess.getAggregationOpAccess().getONLYEnumLiteralDeclaration_0().getEnumLiteral().getInstance(); | 3724 | $current = grammarAccess.getAggregationOpAccess().getONLYEnumLiteralDeclaration_0().getEnumLiteral().getInstance(); |
3766 | newLeafNode(enumLiteral_0, grammarAccess.getAggregationOpAccess().getONLYEnumLiteralDeclaration_0()); | 3725 | newLeafNode(enumLiteral_0, grammarAccess.getAggregationOpAccess().getONLYEnumLiteralDeclaration_0()); |
@@ -3768,7 +3727,7 @@ ruleAggregationOp returns [Enumerator current=null] | |||
3768 | ) | 3727 | ) |
3769 | | | 3728 | | |
3770 | ( | 3729 | ( |
3771 | enumLiteral_1='sum' | 3730 | enumLiteral_1=Sum |
3772 | { | 3731 | { |
3773 | $current = grammarAccess.getAggregationOpAccess().getSUMEnumLiteralDeclaration_1().getEnumLiteral().getInstance(); | 3732 | $current = grammarAccess.getAggregationOpAccess().getSUMEnumLiteralDeclaration_1().getEnumLiteral().getInstance(); |
3774 | newLeafNode(enumLiteral_1, grammarAccess.getAggregationOpAccess().getSUMEnumLiteralDeclaration_1()); | 3733 | newLeafNode(enumLiteral_1, grammarAccess.getAggregationOpAccess().getSUMEnumLiteralDeclaration_1()); |
@@ -3776,7 +3735,7 @@ ruleAggregationOp returns [Enumerator current=null] | |||
3776 | ) | 3735 | ) |
3777 | | | 3736 | | |
3778 | ( | 3737 | ( |
3779 | enumLiteral_2='prod' | 3738 | enumLiteral_2=Prod |
3780 | { | 3739 | { |
3781 | $current = grammarAccess.getAggregationOpAccess().getPRODEnumLiteralDeclaration_2().getEnumLiteral().getInstance(); | 3740 | $current = grammarAccess.getAggregationOpAccess().getPRODEnumLiteralDeclaration_2().getEnumLiteral().getInstance(); |
3782 | newLeafNode(enumLiteral_2, grammarAccess.getAggregationOpAccess().getPRODEnumLiteralDeclaration_2()); | 3741 | newLeafNode(enumLiteral_2, grammarAccess.getAggregationOpAccess().getPRODEnumLiteralDeclaration_2()); |
@@ -3784,7 +3743,7 @@ ruleAggregationOp returns [Enumerator current=null] | |||
3784 | ) | 3743 | ) |
3785 | | | 3744 | | |
3786 | ( | 3745 | ( |
3787 | enumLiteral_3='avg' | 3746 | enumLiteral_3=Avg |
3788 | { | 3747 | { |
3789 | $current = grammarAccess.getAggregationOpAccess().getAVGEnumLiteralDeclaration_3().getEnumLiteral().getInstance(); | 3748 | $current = grammarAccess.getAggregationOpAccess().getAVGEnumLiteralDeclaration_3().getEnumLiteral().getInstance(); |
3790 | newLeafNode(enumLiteral_3, grammarAccess.getAggregationOpAccess().getAVGEnumLiteralDeclaration_3()); | 3749 | newLeafNode(enumLiteral_3, grammarAccess.getAggregationOpAccess().getAVGEnumLiteralDeclaration_3()); |
@@ -3792,7 +3751,7 @@ ruleAggregationOp returns [Enumerator current=null] | |||
3792 | ) | 3751 | ) |
3793 | | | 3752 | | |
3794 | ( | 3753 | ( |
3795 | enumLiteral_4='min' | 3754 | enumLiteral_4=Min |
3796 | { | 3755 | { |
3797 | $current = grammarAccess.getAggregationOpAccess().getMINEnumLiteralDeclaration_4().getEnumLiteral().getInstance(); | 3756 | $current = grammarAccess.getAggregationOpAccess().getMINEnumLiteralDeclaration_4().getEnumLiteral().getInstance(); |
3798 | newLeafNode(enumLiteral_4, grammarAccess.getAggregationOpAccess().getMINEnumLiteralDeclaration_4()); | 3757 | newLeafNode(enumLiteral_4, grammarAccess.getAggregationOpAccess().getMINEnumLiteralDeclaration_4()); |
@@ -3800,7 +3759,7 @@ ruleAggregationOp returns [Enumerator current=null] | |||
3800 | ) | 3759 | ) |
3801 | | | 3760 | | |
3802 | ( | 3761 | ( |
3803 | enumLiteral_5='max' | 3762 | enumLiteral_5=Max |
3804 | { | 3763 | { |
3805 | $current = grammarAccess.getAggregationOpAccess().getMAXEnumLiteralDeclaration_5().getEnumLiteral().getInstance(); | 3764 | $current = grammarAccess.getAggregationOpAccess().getMAXEnumLiteralDeclaration_5().getEnumLiteral().getInstance(); |
3806 | newLeafNode(enumLiteral_5, grammarAccess.getAggregationOpAccess().getMAXEnumLiteralDeclaration_5()); | 3765 | newLeafNode(enumLiteral_5, grammarAccess.getAggregationOpAccess().getMAXEnumLiteralDeclaration_5()); |
@@ -3819,7 +3778,7 @@ ruleLogicValue returns [Enumerator current=null] | |||
3819 | }: | 3778 | }: |
3820 | ( | 3779 | ( |
3821 | ( | 3780 | ( |
3822 | enumLiteral_0='true' | 3781 | enumLiteral_0=True |
3823 | { | 3782 | { |
3824 | $current = grammarAccess.getLogicValueAccess().getTRUEEnumLiteralDeclaration_0().getEnumLiteral().getInstance(); | 3783 | $current = grammarAccess.getLogicValueAccess().getTRUEEnumLiteralDeclaration_0().getEnumLiteral().getInstance(); |
3825 | newLeafNode(enumLiteral_0, grammarAccess.getLogicValueAccess().getTRUEEnumLiteralDeclaration_0()); | 3784 | newLeafNode(enumLiteral_0, grammarAccess.getLogicValueAccess().getTRUEEnumLiteralDeclaration_0()); |
@@ -3827,7 +3786,7 @@ ruleLogicValue returns [Enumerator current=null] | |||
3827 | ) | 3786 | ) |
3828 | | | 3787 | | |
3829 | ( | 3788 | ( |
3830 | enumLiteral_1='false' | 3789 | enumLiteral_1=False |
3831 | { | 3790 | { |
3832 | $current = grammarAccess.getLogicValueAccess().getFALSEEnumLiteralDeclaration_1().getEnumLiteral().getInstance(); | 3791 | $current = grammarAccess.getLogicValueAccess().getFALSEEnumLiteralDeclaration_1().getEnumLiteral().getInstance(); |
3833 | newLeafNode(enumLiteral_1, grammarAccess.getLogicValueAccess().getFALSEEnumLiteralDeclaration_1()); | 3792 | newLeafNode(enumLiteral_1, grammarAccess.getLogicValueAccess().getFALSEEnumLiteralDeclaration_1()); |
@@ -3835,7 +3794,7 @@ ruleLogicValue returns [Enumerator current=null] | |||
3835 | ) | 3794 | ) |
3836 | | | 3795 | | |
3837 | ( | 3796 | ( |
3838 | enumLiteral_2='unknown' | 3797 | enumLiteral_2=Unknown |
3839 | { | 3798 | { |
3840 | $current = grammarAccess.getLogicValueAccess().getUNKNOWNEnumLiteralDeclaration_2().getEnumLiteral().getInstance(); | 3799 | $current = grammarAccess.getLogicValueAccess().getUNKNOWNEnumLiteralDeclaration_2().getEnumLiteral().getInstance(); |
3841 | newLeafNode(enumLiteral_2, grammarAccess.getLogicValueAccess().getUNKNOWNEnumLiteralDeclaration_2()); | 3800 | newLeafNode(enumLiteral_2, grammarAccess.getLogicValueAccess().getUNKNOWNEnumLiteralDeclaration_2()); |
@@ -3843,7 +3802,7 @@ ruleLogicValue returns [Enumerator current=null] | |||
3843 | ) | 3802 | ) |
3844 | | | 3803 | | |
3845 | ( | 3804 | ( |
3846 | enumLiteral_3='error' | 3805 | enumLiteral_3=Error |
3847 | { | 3806 | { |
3848 | $current = grammarAccess.getLogicValueAccess().getERROREnumLiteralDeclaration_3().getEnumLiteral().getInstance(); | 3807 | $current = grammarAccess.getLogicValueAccess().getERROREnumLiteralDeclaration_3().getEnumLiteral().getInstance(); |
3849 | newLeafNode(enumLiteral_3, grammarAccess.getLogicValueAccess().getERROREnumLiteralDeclaration_3()); | 3808 | newLeafNode(enumLiteral_3, grammarAccess.getLogicValueAccess().getERROREnumLiteralDeclaration_3()); |
@@ -3862,7 +3821,7 @@ ruleObjectiveKind returns [Enumerator current=null] | |||
3862 | }: | 3821 | }: |
3863 | ( | 3822 | ( |
3864 | ( | 3823 | ( |
3865 | enumLiteral_0='minimize' | 3824 | enumLiteral_0=Minimize |
3866 | { | 3825 | { |
3867 | $current = grammarAccess.getObjectiveKindAccess().getMINIMIZEEnumLiteralDeclaration_0().getEnumLiteral().getInstance(); | 3826 | $current = grammarAccess.getObjectiveKindAccess().getMINIMIZEEnumLiteralDeclaration_0().getEnumLiteral().getInstance(); |
3868 | newLeafNode(enumLiteral_0, grammarAccess.getObjectiveKindAccess().getMINIMIZEEnumLiteralDeclaration_0()); | 3827 | newLeafNode(enumLiteral_0, grammarAccess.getObjectiveKindAccess().getMINIMIZEEnumLiteralDeclaration_0()); |
@@ -3870,7 +3829,7 @@ ruleObjectiveKind returns [Enumerator current=null] | |||
3870 | ) | 3829 | ) |
3871 | | | 3830 | | |
3872 | ( | 3831 | ( |
3873 | enumLiteral_1='maximize' | 3832 | enumLiteral_1=Maximize |
3874 | { | 3833 | { |
3875 | $current = grammarAccess.getObjectiveKindAccess().getMAXIMIZEEnumLiteralDeclaration_1().getEnumLiteral().getInstance(); | 3834 | $current = grammarAccess.getObjectiveKindAccess().getMAXIMIZEEnumLiteralDeclaration_1().getEnumLiteral().getInstance(); |
3876 | newLeafNode(enumLiteral_1, grammarAccess.getObjectiveKindAccess().getMAXIMIZEEnumLiteralDeclaration_1()); | 3835 | newLeafNode(enumLiteral_1, grammarAccess.getObjectiveKindAccess().getMAXIMIZEEnumLiteralDeclaration_1()); |
@@ -3878,25 +3837,3 @@ ruleObjectiveKind returns [Enumerator current=null] | |||
3878 | ) | 3837 | ) |
3879 | ) | 3838 | ) |
3880 | ; | 3839 | ; |
3881 | |||
3882 | RULE_STRING : '"' ('\\' .|~(('\\'|'"')))* '"'; | ||
3883 | |||
3884 | RULE_QUOTED_ID : '\'' ('\\' .|~(('\\'|'\'')))* '\''; | ||
3885 | |||
3886 | RULE_PLUS : 'synthetic::plus'; | ||
3887 | |||
3888 | RULE_STAR : 'synthetic::star'; | ||
3889 | |||
3890 | RULE_DOT : 'synthetic::dot'; | ||
3891 | |||
3892 | RULE_ID : '^'? ('a'..'z'|'A'..'Z'|'_') ('a'..'z'|'A'..'Z'|'_'|'0'..'9')*; | ||
3893 | |||
3894 | RULE_INT : ('0'..'9')+; | ||
3895 | |||
3896 | RULE_ML_COMMENT : '/*' ( options {greedy=false;} : . )*'*/'; | ||
3897 | |||
3898 | RULE_SL_COMMENT : '//' ~(('\n'|'\r'))* ('\r'? '\n')?; | ||
3899 | |||
3900 | RULE_WS : (' '|'\t'|'\r'|'\n')+; | ||
3901 | |||
3902 | RULE_ANY_OTHER : .; | ||
diff --git a/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/parser/antlr/internal/InternalSolverLanguageParser.java b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/parser/antlr/internal/InternalSolverLanguageParser.java index ee2f6175..7dbfa002 100644 --- a/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/parser/antlr/internal/InternalSolverLanguageParser.java +++ b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/parser/antlr/internal/InternalSolverLanguageParser.java | |||
@@ -18,85 +18,96 @@ import org.antlr.runtime.*; | |||
18 | import java.util.Stack; | 18 | import java.util.Stack; |
19 | import java.util.List; | 19 | import java.util.List; |
20 | import java.util.ArrayList; | 20 | import java.util.ArrayList; |
21 | import java.util.Map; | 21 | |
22 | import java.util.HashMap; | ||
23 | @SuppressWarnings("all") | 22 | @SuppressWarnings("all") |
24 | public class InternalSolverLanguageParser extends AbstractInternalAntlrParser { | 23 | public class InternalSolverLanguageParser extends AbstractInternalAntlrParser { |
25 | public static final String[] tokenNames = new String[] { | 24 | public static final String[] tokenNames = new String[] { |
26 | "<invalid>", "<EOR>", "<DOWN>", "<UP>", "RULE_DOT", "RULE_STAR", "RULE_PLUS", "RULE_STRING", "RULE_ID", "RULE_INT", "RULE_QUOTED_ID", "RULE_ML_COMMENT", "RULE_SL_COMMENT", "RULE_WS", "RULE_ANY_OTHER", "':'", "':-'", "'='", "'functional'", "'error'", "'default'", "'extern'", "'.'", "'if'", "'then'", "'else'", "';'", "'->'", "','", "'count'", "'{'", "'}'", "'|'", "'('", "')'", "'*'", "'['", "'..'", "']'", "'inf'", "'empty'", "'abstract'", "'class'", "'extends'", "'contains'", "'opposite'", "'scope'", "'=='", "'<='", "'>='", "'int'", "'real'", "'!='", "'<'", "'>'", "'in'", "'+'", "'-'", "'/'", "'^'", "'!'", "'may'", "'must'", "'current'", "'only'", "'sum'", "'prod'", "'avg'", "'min'", "'max'", "'true'", "'false'", "'unknown'", "'minimize'", "'maximize'" | 25 | "<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 | }; | 26 | }; |
28 | public static final int T__50=50; | 27 | public static final int ADD=33; |
29 | public static final int T__19=19; | 28 | public static final int True=32; |
30 | public static final int T__15=15; | 29 | public static final int GREATER_EQ=4; |
31 | public static final int T__59=59; | 30 | public static final int Count=20; |
32 | public static final int T__16=16; | 31 | public static final int False=23; |
33 | public static final int T__17=17; | 32 | public static final int Must=27; |
34 | public static final int T__18=18; | 33 | public static final int LessThanSign=67; |
35 | public static final int T__55=55; | 34 | public static final int LeftParenthesis=57; |
36 | public static final int T__56=56; | 35 | public static final int Unknown=16; |
37 | public static final int T__57=57; | 36 | public static final int RULE_REFLEXIVE_TRANSITIVE_CLOSURE=80; |
38 | public static final int T__58=58; | 37 | public static final int FullStopFullStop=47; |
39 | public static final int T__51=51; | 38 | public static final int Real=30; |
40 | public static final int RULE_STAR=5; | 39 | public static final int Then=31; |
41 | public static final int T__52=52; | 40 | public static final int Extends=15; |
42 | public static final int T__53=53; | 41 | public static final int RightSquareBracket=71; |
43 | public static final int T__54=54; | 42 | public static final int ExclamationMark=56; |
44 | public static final int T__60=60; | 43 | public static final int Opposite=10; |
45 | public static final int T__61=61; | 44 | public static final int SUB=37; |
46 | public static final int RULE_ID=8; | 45 | public static final int GreaterThanSign=69; |
47 | public static final int RULE_QUOTED_ID=10; | 46 | public static final int NOT_EQ=17; |
48 | public static final int T__26=26; | 47 | public static final int RULE_ID=82; |
49 | public static final int T__27=27; | 48 | public static final int MUL=35; |
50 | public static final int T__28=28; | 49 | public static final int IN=53; |
51 | public static final int RULE_INT=9; | 50 | public static final int RULE_QUOTED_ID=77; |
52 | public static final int T__29=29; | 51 | public static final int RightParenthesis=58; |
53 | public static final int T__22=22; | 52 | public static final int Sum=44; |
54 | public static final int T__66=66; | 53 | public static final int EQ=52; |
55 | public static final int RULE_ML_COMMENT=11; | 54 | public static final int GreaterThanSignEqualsSign=51; |
56 | public static final int T__23=23; | 55 | public static final int Functional=5; |
57 | public static final int T__67=67; | 56 | public static final int EqualsSignEqualsSign=50; |
58 | public static final int T__24=24; | 57 | public static final int Avg=38; |
59 | public static final int T__68=68; | 58 | public static final int Min=43; |
60 | public static final int T__25=25; | 59 | public static final int VerticalLine=74; |
61 | public static final int T__69=69; | 60 | public static final int PlusSign=60; |
62 | public static final int T__62=62; | 61 | public static final int RULE_INT=83; |
63 | public static final int T__63=63; | 62 | public static final int Contains=7; |
64 | public static final int T__20=20; | 63 | public static final int RULE_ML_COMMENT=84; |
65 | public static final int T__64=64; | 64 | public static final int POW=36; |
66 | public static final int T__21=21; | 65 | public static final int RULE_TRANSITIVE_CLOSURE=79; |
67 | public static final int T__65=65; | 66 | public static final int Class=19; |
68 | public static final int T__70=70; | 67 | public static final int LESS=25; |
69 | public static final int T__71=71; | 68 | public static final int LeftSquareBracket=70; |
70 | public static final int T__72=72; | 69 | public static final int RULE_FULL_STOP=81; |
71 | public static final int RULE_STRING=7; | 70 | public static final int Current=13; |
72 | public static final int RULE_SL_COMMENT=12; | 71 | public static final int If=54; |
73 | public static final int T__37=37; | 72 | public static final int Inf=39; |
74 | public static final int T__38=38; | 73 | public static final int LESS_EQ=12; |
75 | public static final int T__39=39; | 74 | public static final int May=42; |
76 | public static final int T__33=33; | 75 | public static final int Max=41; |
77 | public static final int T__34=34; | 76 | public static final int In=55; |
78 | public static final int T__35=35; | 77 | public static final int RULE_STRING=76; |
79 | public static final int RULE_PLUS=6; | 78 | public static final int Int=40; |
80 | public static final int T__36=36; | 79 | public static final int Extern=18; |
81 | public static final int T__73=73; | 80 | public static final int RULE_SL_COMMENT=78; |
82 | public static final int RULE_DOT=4; | 81 | public static final int Prod=29; |
82 | public static final int Comma=61; | ||
83 | public static final int EqualsSign=68; | ||
84 | public static final int Empty=21; | ||
85 | public static final int HyphenMinus=62; | ||
86 | public static final int Maximize=8; | ||
87 | public static final int LessThanSignEqualsSign=49; | ||
88 | public static final int Solidus=64; | ||
89 | public static final int Colon=65; | ||
90 | public static final int RightCurlyBracket=75; | ||
83 | public static final int EOF=-1; | 91 | public static final int EOF=-1; |
84 | public static final int T__30=30; | 92 | public static final int Asterisk=59; |
85 | public static final int T__74=74; | 93 | public static final int FullStop=63; |
86 | public static final int T__31=31; | 94 | public static final int RULE_WS=85; |
87 | public static final int T__32=32; | 95 | public static final int Abstract=6; |
88 | public static final int RULE_WS=13; | 96 | public static final int Minimize=9; |
89 | public static final int RULE_ANY_OTHER=14; | 97 | public static final int GREATER=11; |
90 | public static final int T__48=48; | 98 | public static final int LeftCurlyBracket=73; |
91 | public static final int T__49=49; | 99 | public static final int Error=22; |
92 | public static final int T__44=44; | 100 | public static final int Only=28; |
93 | public static final int T__45=45; | 101 | public static final int RULE_ANY_OTHER=86; |
94 | public static final int T__46=46; | 102 | public static final int Default=14; |
95 | public static final int T__47=47; | 103 | public static final int ColonHyphenMinus=48; |
96 | public static final int T__40=40; | 104 | public static final int CircumflexAccent=72; |
97 | public static final int T__41=41; | 105 | public static final int DIV=34; |
98 | public static final int T__42=42; | 106 | public static final int Semicolon=66; |
99 | public static final int T__43=43; | 107 | public static final int Scope=24; |
108 | public static final int Else=26; | ||
109 | public static final int ExclamationMarkEqualsSign=45; | ||
110 | public static final int HyphenMinusGreaterThanSign=46; | ||
100 | 111 | ||
101 | // delegates | 112 | // delegates |
102 | // delegators | 113 | // delegators |
@@ -112,7 +123,7 @@ public class InternalSolverLanguageParser extends AbstractInternalAntlrParser { | |||
112 | 123 | ||
113 | 124 | ||
114 | public String[] getTokenNames() { return InternalSolverLanguageParser.tokenNames; } | 125 | public String[] getTokenNames() { return InternalSolverLanguageParser.tokenNames; } |
115 | public String getGrammarFileName() { return "InternalSolverLanguage.g"; } | 126 | public String getGrammarFileName() { return "InternalSolverLanguageParser.g"; } |
116 | 127 | ||
117 | 128 | ||
118 | 129 | ||
@@ -138,7 +149,7 @@ public class InternalSolverLanguageParser extends AbstractInternalAntlrParser { | |||
138 | 149 | ||
139 | 150 | ||
140 | // $ANTLR start "entryRuleProblem" | 151 | // $ANTLR start "entryRuleProblem" |
141 | // InternalSolverLanguage.g:65:1: entryRuleProblem returns [EObject current=null] : iv_ruleProblem= ruleProblem EOF ; | 152 | // InternalSolverLanguageParser.g:58:1: entryRuleProblem returns [EObject current=null] : iv_ruleProblem= ruleProblem EOF ; |
142 | public final EObject entryRuleProblem() throws RecognitionException { | 153 | public final EObject entryRuleProblem() throws RecognitionException { |
143 | EObject current = null; | 154 | EObject current = null; |
144 | 155 | ||
@@ -146,21 +157,17 @@ public class InternalSolverLanguageParser extends AbstractInternalAntlrParser { | |||
146 | 157 | ||
147 | 158 | ||
148 | try { | 159 | try { |
149 | // InternalSolverLanguage.g:65:48: (iv_ruleProblem= ruleProblem EOF ) | 160 | // InternalSolverLanguageParser.g:58:48: (iv_ruleProblem= ruleProblem EOF ) |
150 | // InternalSolverLanguage.g:66:2: iv_ruleProblem= ruleProblem EOF | 161 | // InternalSolverLanguageParser.g:59:2: iv_ruleProblem= ruleProblem EOF |
151 | { | 162 | { |
152 | if ( state.backtracking==0 ) { | 163 | newCompositeNode(grammarAccess.getProblemRule()); |
153 | newCompositeNode(grammarAccess.getProblemRule()); | ||
154 | } | ||
155 | pushFollow(FOLLOW_1); | 164 | pushFollow(FOLLOW_1); |
156 | iv_ruleProblem=ruleProblem(); | 165 | iv_ruleProblem=ruleProblem(); |
157 | 166 | ||
158 | state._fsp--; | 167 | state._fsp--; |
159 | if (state.failed) return current; | 168 | |
160 | if ( state.backtracking==0 ) { | 169 | current =iv_ruleProblem; |
161 | current =iv_ruleProblem; | 170 | match(input,EOF,FOLLOW_2); |
162 | } | ||
163 | match(input,EOF,FOLLOW_2); if (state.failed) return current; | ||
164 | 171 | ||
165 | } | 172 | } |
166 | 173 | ||
@@ -178,7 +185,7 @@ public class InternalSolverLanguageParser extends AbstractInternalAntlrParser { | |||
178 | 185 | ||
179 | 186 | ||
180 | // $ANTLR start "ruleProblem" | 187 | // $ANTLR start "ruleProblem" |
181 | // InternalSolverLanguage.g:72:1: ruleProblem returns [EObject current=null] : ( (lv_statements_0_0= ruleStatement ) )* ; | 188 | // InternalSolverLanguageParser.g:65:1: ruleProblem returns [EObject current=null] : ( (lv_statements_0_0= ruleStatement ) )* ; |
182 | public final EObject ruleProblem() throws RecognitionException { | 189 | public final EObject ruleProblem() throws RecognitionException { |
183 | EObject current = null; | 190 | EObject current = null; |
184 | 191 | ||
@@ -189,50 +196,46 @@ public class InternalSolverLanguageParser extends AbstractInternalAntlrParser { | |||
189 | enterRule(); | 196 | enterRule(); |
190 | 197 | ||
191 | try { | 198 | try { |
192 | // InternalSolverLanguage.g:78:2: ( ( (lv_statements_0_0= ruleStatement ) )* ) | 199 | // InternalSolverLanguageParser.g:71:2: ( ( (lv_statements_0_0= ruleStatement ) )* ) |
193 | // InternalSolverLanguage.g:79:2: ( (lv_statements_0_0= ruleStatement ) )* | 200 | // InternalSolverLanguageParser.g:72:2: ( (lv_statements_0_0= ruleStatement ) )* |
194 | { | 201 | { |
195 | // InternalSolverLanguage.g:79:2: ( (lv_statements_0_0= ruleStatement ) )* | 202 | // InternalSolverLanguageParser.g:72:2: ( (lv_statements_0_0= ruleStatement ) )* |
196 | loop1: | 203 | loop1: |
197 | do { | 204 | do { |
198 | int alt1=2; | 205 | int alt1=2; |
199 | int LA1_0 = input.LA(1); | 206 | int LA1_0 = input.LA(1); |
200 | 207 | ||
201 | if ( ((LA1_0>=RULE_STRING && LA1_0<=RULE_QUOTED_ID)||(LA1_0>=18 && LA1_0<=21)||LA1_0==23||LA1_0==29||LA1_0==33||LA1_0==36||(LA1_0>=39 && LA1_0<=42)||LA1_0==46||(LA1_0>=50 && LA1_0<=51)||(LA1_0>=56 && LA1_0<=57)||(LA1_0>=60 && LA1_0<=74)) ) { | 208 | 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)) ) { |
202 | alt1=1; | 209 | alt1=1; |
203 | } | 210 | } |
204 | 211 | ||
205 | 212 | ||
206 | switch (alt1) { | 213 | switch (alt1) { |
207 | case 1 : | 214 | case 1 : |
208 | // InternalSolverLanguage.g:80:3: (lv_statements_0_0= ruleStatement ) | 215 | // InternalSolverLanguageParser.g:73:3: (lv_statements_0_0= ruleStatement ) |
209 | { | 216 | { |
210 | // InternalSolverLanguage.g:80:3: (lv_statements_0_0= ruleStatement ) | 217 | // InternalSolverLanguageParser.g:73:3: (lv_statements_0_0= ruleStatement ) |
211 | // InternalSolverLanguage.g:81:4: lv_statements_0_0= ruleStatement | 218 | // InternalSolverLanguageParser.g:74:4: lv_statements_0_0= ruleStatement |
212 | { | 219 | { |
213 | if ( state.backtracking==0 ) { | ||
214 | 220 | ||
215 | newCompositeNode(grammarAccess.getProblemAccess().getStatementsStatementParserRuleCall_0()); | 221 | newCompositeNode(grammarAccess.getProblemAccess().getStatementsStatementParserRuleCall_0()); |
216 | 222 | ||
217 | } | ||
218 | pushFollow(FOLLOW_3); | 223 | pushFollow(FOLLOW_3); |
219 | lv_statements_0_0=ruleStatement(); | 224 | lv_statements_0_0=ruleStatement(); |
220 | 225 | ||
221 | state._fsp--; | 226 | state._fsp--; |
222 | if (state.failed) return current; | 227 | |
223 | if ( state.backtracking==0 ) { | 228 | |
224 | 229 | if (current==null) { | |
225 | if (current==null) { | 230 | current = createModelElementForParent(grammarAccess.getProblemRule()); |
226 | current = createModelElementForParent(grammarAccess.getProblemRule()); | 231 | } |
227 | } | 232 | add( |
228 | add( | 233 | current, |
229 | current, | 234 | "statements", |
230 | "statements", | 235 | lv_statements_0_0, |
231 | lv_statements_0_0, | 236 | "org.eclipse.viatra.solver.language.SolverLanguage.Statement"); |
232 | "org.eclipse.viatra.solver.language.SolverLanguage.Statement"); | 237 | afterParserOrEnumRuleCall(); |
233 | afterParserOrEnumRuleCall(); | 238 | |
234 | |||
235 | } | ||
236 | 239 | ||
237 | } | 240 | } |
238 | 241 | ||
@@ -248,11 +251,9 @@ public class InternalSolverLanguageParser extends AbstractInternalAntlrParser { | |||
248 | 251 | ||
249 | } | 252 | } |
250 | 253 | ||
251 | if ( state.backtracking==0 ) { | ||
252 | 254 | ||
253 | leaveRule(); | 255 | leaveRule(); |
254 | 256 | ||
255 | } | ||
256 | } | 257 | } |
257 | 258 | ||
258 | catch (RecognitionException re) { | 259 | catch (RecognitionException re) { |
@@ -267,7 +268,7 @@ public class InternalSolverLanguageParser extends AbstractInternalAntlrParser { | |||
267 | 268 | ||
268 | 269 | ||
269 | // $ANTLR start "entryRuleStatement" | 270 | // $ANTLR start "entryRuleStatement" |
270 | // InternalSolverLanguage.g:101:1: entryRuleStatement returns [EObject current=null] : iv_ruleStatement= ruleStatement EOF ; | 271 | // InternalSolverLanguageParser.g:94:1: entryRuleStatement returns [EObject current=null] : iv_ruleStatement= ruleStatement EOF ; |
271 | public final EObject entryRuleStatement() throws RecognitionException { | 272 | public final EObject entryRuleStatement() throws RecognitionException { |
272 | EObject current = null; | 273 | EObject current = null; |
273 | 274 | ||
@@ -275,21 +276,17 @@ public class InternalSolverLanguageParser extends AbstractInternalAntlrParser { | |||
275 | 276 | ||
276 | 277 | ||
277 | try { | 278 | try { |
278 | // InternalSolverLanguage.g:101:50: (iv_ruleStatement= ruleStatement EOF ) | 279 | // InternalSolverLanguageParser.g:94:50: (iv_ruleStatement= ruleStatement EOF ) |
279 | // InternalSolverLanguage.g:102:2: iv_ruleStatement= ruleStatement EOF | 280 | // InternalSolverLanguageParser.g:95:2: iv_ruleStatement= ruleStatement EOF |
280 | { | 281 | { |
281 | if ( state.backtracking==0 ) { | 282 | newCompositeNode(grammarAccess.getStatementRule()); |
282 | newCompositeNode(grammarAccess.getStatementRule()); | ||
283 | } | ||
284 | pushFollow(FOLLOW_1); | 283 | pushFollow(FOLLOW_1); |
285 | iv_ruleStatement=ruleStatement(); | 284 | iv_ruleStatement=ruleStatement(); |
286 | 285 | ||
287 | state._fsp--; | 286 | state._fsp--; |
288 | if (state.failed) return current; | 287 | |
289 | if ( state.backtracking==0 ) { | 288 | current =iv_ruleStatement; |
290 | current =iv_ruleStatement; | 289 | match(input,EOF,FOLLOW_2); |
291 | } | ||
292 | match(input,EOF,FOLLOW_2); if (state.failed) return current; | ||
293 | 290 | ||
294 | } | 291 | } |
295 | 292 | ||
@@ -307,11 +304,11 @@ public class InternalSolverLanguageParser extends AbstractInternalAntlrParser { | |||
307 | 304 | ||
308 | 305 | ||
309 | // $ANTLR start "ruleStatement" | 306 | // $ANTLR start "ruleStatement" |
310 | // InternalSolverLanguage.g:108:1: ruleStatement returns [EObject current=null] : ( (this_AssertionOrDefinition_0= ruleAssertionOrDefinition | this_PredicateDefinition_1= rulePredicateDefinition | this_UnnamedErrorPrediateDefinition_2= ruleUnnamedErrorPrediateDefinition | this_DefaultDefinition_3= ruleDefaultDefinition | this_ExternPredicateDefinition_4= ruleExternPredicateDefinition | this_MetricDefinition_5= ruleMetricDefinition | this_ExternMetricDefinition_6= ruleExternMetricDefinition | this_ClassDefinition_7= ruleClassDefinition | this_ScopeDefinition_8= ruleScopeDefinition | this_ObjectiveDefinition_9= ruleObjectiveDefinition ) this_DOT_10= RULE_DOT ) ; | 307 | // InternalSolverLanguageParser.g:101:1: ruleStatement returns [EObject current=null] : ( (this_AssertionOrDefinition_0= ruleAssertionOrDefinition | this_PredicateDefinition_1= rulePredicateDefinition | this_UnnamedErrorPrediateDefinition_2= ruleUnnamedErrorPrediateDefinition | this_DefaultDefinition_3= ruleDefaultDefinition | this_ExternPredicateDefinition_4= ruleExternPredicateDefinition | this_MetricDefinition_5= ruleMetricDefinition | this_ExternMetricDefinition_6= ruleExternMetricDefinition | this_ClassDefinition_7= ruleClassDefinition | this_ScopeDefinition_8= ruleScopeDefinition | this_ObjectiveDefinition_9= ruleObjectiveDefinition ) this_FULL_STOP_10= RULE_FULL_STOP ) ; |
311 | public final EObject ruleStatement() throws RecognitionException { | 308 | public final EObject ruleStatement() throws RecognitionException { |
312 | EObject current = null; | 309 | EObject current = null; |
313 | 310 | ||
314 | Token this_DOT_10=null; | 311 | Token this_FULL_STOP_10=null; |
315 | EObject this_AssertionOrDefinition_0 = null; | 312 | EObject this_AssertionOrDefinition_0 = null; |
316 | 313 | ||
317 | EObject this_PredicateDefinition_1 = null; | 314 | EObject this_PredicateDefinition_1 = null; |
@@ -337,256 +334,212 @@ public class InternalSolverLanguageParser extends AbstractInternalAntlrParser { | |||
337 | enterRule(); | 334 | enterRule(); |
338 | 335 | ||
339 | try { | 336 | try { |
340 | // InternalSolverLanguage.g:114:2: ( ( (this_AssertionOrDefinition_0= ruleAssertionOrDefinition | this_PredicateDefinition_1= rulePredicateDefinition | this_UnnamedErrorPrediateDefinition_2= ruleUnnamedErrorPrediateDefinition | this_DefaultDefinition_3= ruleDefaultDefinition | this_ExternPredicateDefinition_4= ruleExternPredicateDefinition | this_MetricDefinition_5= ruleMetricDefinition | this_ExternMetricDefinition_6= ruleExternMetricDefinition | this_ClassDefinition_7= ruleClassDefinition | this_ScopeDefinition_8= ruleScopeDefinition | this_ObjectiveDefinition_9= ruleObjectiveDefinition ) this_DOT_10= RULE_DOT ) ) | 337 | // InternalSolverLanguageParser.g:107:2: ( ( (this_AssertionOrDefinition_0= ruleAssertionOrDefinition | this_PredicateDefinition_1= rulePredicateDefinition | this_UnnamedErrorPrediateDefinition_2= ruleUnnamedErrorPrediateDefinition | this_DefaultDefinition_3= ruleDefaultDefinition | this_ExternPredicateDefinition_4= ruleExternPredicateDefinition | this_MetricDefinition_5= ruleMetricDefinition | this_ExternMetricDefinition_6= ruleExternMetricDefinition | this_ClassDefinition_7= ruleClassDefinition | this_ScopeDefinition_8= ruleScopeDefinition | this_ObjectiveDefinition_9= ruleObjectiveDefinition ) this_FULL_STOP_10= RULE_FULL_STOP ) ) |
341 | // InternalSolverLanguage.g:115:2: ( (this_AssertionOrDefinition_0= ruleAssertionOrDefinition | this_PredicateDefinition_1= rulePredicateDefinition | this_UnnamedErrorPrediateDefinition_2= ruleUnnamedErrorPrediateDefinition | this_DefaultDefinition_3= ruleDefaultDefinition | this_ExternPredicateDefinition_4= ruleExternPredicateDefinition | this_MetricDefinition_5= ruleMetricDefinition | this_ExternMetricDefinition_6= ruleExternMetricDefinition | this_ClassDefinition_7= ruleClassDefinition | this_ScopeDefinition_8= ruleScopeDefinition | this_ObjectiveDefinition_9= ruleObjectiveDefinition ) this_DOT_10= RULE_DOT ) | 338 | // InternalSolverLanguageParser.g:108:2: ( (this_AssertionOrDefinition_0= ruleAssertionOrDefinition | this_PredicateDefinition_1= rulePredicateDefinition | this_UnnamedErrorPrediateDefinition_2= ruleUnnamedErrorPrediateDefinition | this_DefaultDefinition_3= ruleDefaultDefinition | this_ExternPredicateDefinition_4= ruleExternPredicateDefinition | this_MetricDefinition_5= ruleMetricDefinition | this_ExternMetricDefinition_6= ruleExternMetricDefinition | this_ClassDefinition_7= ruleClassDefinition | this_ScopeDefinition_8= ruleScopeDefinition | this_ObjectiveDefinition_9= ruleObjectiveDefinition ) this_FULL_STOP_10= RULE_FULL_STOP ) |
342 | { | 339 | { |
343 | // InternalSolverLanguage.g:115:2: ( (this_AssertionOrDefinition_0= ruleAssertionOrDefinition | this_PredicateDefinition_1= rulePredicateDefinition | this_UnnamedErrorPrediateDefinition_2= ruleUnnamedErrorPrediateDefinition | this_DefaultDefinition_3= ruleDefaultDefinition | this_ExternPredicateDefinition_4= ruleExternPredicateDefinition | this_MetricDefinition_5= ruleMetricDefinition | this_ExternMetricDefinition_6= ruleExternMetricDefinition | this_ClassDefinition_7= ruleClassDefinition | this_ScopeDefinition_8= ruleScopeDefinition | this_ObjectiveDefinition_9= ruleObjectiveDefinition ) this_DOT_10= RULE_DOT ) | 340 | // InternalSolverLanguageParser.g:108:2: ( (this_AssertionOrDefinition_0= ruleAssertionOrDefinition | this_PredicateDefinition_1= rulePredicateDefinition | this_UnnamedErrorPrediateDefinition_2= ruleUnnamedErrorPrediateDefinition | this_DefaultDefinition_3= ruleDefaultDefinition | this_ExternPredicateDefinition_4= ruleExternPredicateDefinition | this_MetricDefinition_5= ruleMetricDefinition | this_ExternMetricDefinition_6= ruleExternMetricDefinition | this_ClassDefinition_7= ruleClassDefinition | this_ScopeDefinition_8= ruleScopeDefinition | this_ObjectiveDefinition_9= ruleObjectiveDefinition ) this_FULL_STOP_10= RULE_FULL_STOP ) |
344 | // InternalSolverLanguage.g:116:3: (this_AssertionOrDefinition_0= ruleAssertionOrDefinition | this_PredicateDefinition_1= rulePredicateDefinition | this_UnnamedErrorPrediateDefinition_2= ruleUnnamedErrorPrediateDefinition | this_DefaultDefinition_3= ruleDefaultDefinition | this_ExternPredicateDefinition_4= ruleExternPredicateDefinition | this_MetricDefinition_5= ruleMetricDefinition | this_ExternMetricDefinition_6= ruleExternMetricDefinition | this_ClassDefinition_7= ruleClassDefinition | this_ScopeDefinition_8= ruleScopeDefinition | this_ObjectiveDefinition_9= ruleObjectiveDefinition ) this_DOT_10= RULE_DOT | 341 | // InternalSolverLanguageParser.g:109:3: (this_AssertionOrDefinition_0= ruleAssertionOrDefinition | this_PredicateDefinition_1= rulePredicateDefinition | this_UnnamedErrorPrediateDefinition_2= ruleUnnamedErrorPrediateDefinition | this_DefaultDefinition_3= ruleDefaultDefinition | this_ExternPredicateDefinition_4= ruleExternPredicateDefinition | this_MetricDefinition_5= ruleMetricDefinition | this_ExternMetricDefinition_6= ruleExternMetricDefinition | this_ClassDefinition_7= ruleClassDefinition | this_ScopeDefinition_8= ruleScopeDefinition | this_ObjectiveDefinition_9= ruleObjectiveDefinition ) this_FULL_STOP_10= RULE_FULL_STOP |
345 | { | 342 | { |
346 | // InternalSolverLanguage.g:116:3: (this_AssertionOrDefinition_0= ruleAssertionOrDefinition | this_PredicateDefinition_1= rulePredicateDefinition | this_UnnamedErrorPrediateDefinition_2= ruleUnnamedErrorPrediateDefinition | this_DefaultDefinition_3= ruleDefaultDefinition | this_ExternPredicateDefinition_4= ruleExternPredicateDefinition | this_MetricDefinition_5= ruleMetricDefinition | this_ExternMetricDefinition_6= ruleExternMetricDefinition | this_ClassDefinition_7= ruleClassDefinition | this_ScopeDefinition_8= ruleScopeDefinition | this_ObjectiveDefinition_9= ruleObjectiveDefinition ) | 343 | // InternalSolverLanguageParser.g:109:3: (this_AssertionOrDefinition_0= ruleAssertionOrDefinition | this_PredicateDefinition_1= rulePredicateDefinition | this_UnnamedErrorPrediateDefinition_2= ruleUnnamedErrorPrediateDefinition | this_DefaultDefinition_3= ruleDefaultDefinition | this_ExternPredicateDefinition_4= ruleExternPredicateDefinition | this_MetricDefinition_5= ruleMetricDefinition | this_ExternMetricDefinition_6= ruleExternMetricDefinition | this_ClassDefinition_7= ruleClassDefinition | this_ScopeDefinition_8= ruleScopeDefinition | this_ObjectiveDefinition_9= ruleObjectiveDefinition ) |
347 | int alt2=10; | 344 | int alt2=10; |
348 | alt2 = dfa2.predict(input); | 345 | alt2 = dfa2.predict(input); |
349 | switch (alt2) { | 346 | switch (alt2) { |
350 | case 1 : | 347 | case 1 : |
351 | // InternalSolverLanguage.g:117:4: this_AssertionOrDefinition_0= ruleAssertionOrDefinition | 348 | // InternalSolverLanguageParser.g:110:4: this_AssertionOrDefinition_0= ruleAssertionOrDefinition |
352 | { | 349 | { |
353 | if ( state.backtracking==0 ) { | ||
354 | 350 | ||
355 | newCompositeNode(grammarAccess.getStatementAccess().getAssertionOrDefinitionParserRuleCall_0_0()); | 351 | newCompositeNode(grammarAccess.getStatementAccess().getAssertionOrDefinitionParserRuleCall_0_0()); |
356 | 352 | ||
357 | } | ||
358 | pushFollow(FOLLOW_4); | 353 | pushFollow(FOLLOW_4); |
359 | this_AssertionOrDefinition_0=ruleAssertionOrDefinition(); | 354 | this_AssertionOrDefinition_0=ruleAssertionOrDefinition(); |
360 | 355 | ||
361 | state._fsp--; | 356 | state._fsp--; |
362 | if (state.failed) return current; | ||
363 | if ( state.backtracking==0 ) { | ||
364 | 357 | ||
365 | current = this_AssertionOrDefinition_0; | 358 | |
366 | afterParserOrEnumRuleCall(); | 359 | current = this_AssertionOrDefinition_0; |
367 | 360 | afterParserOrEnumRuleCall(); | |
368 | } | 361 | |
369 | 362 | ||
370 | } | 363 | } |
371 | break; | 364 | break; |
372 | case 2 : | 365 | case 2 : |
373 | // InternalSolverLanguage.g:126:4: this_PredicateDefinition_1= rulePredicateDefinition | 366 | // InternalSolverLanguageParser.g:119:4: this_PredicateDefinition_1= rulePredicateDefinition |
374 | { | 367 | { |
375 | if ( state.backtracking==0 ) { | ||
376 | 368 | ||
377 | newCompositeNode(grammarAccess.getStatementAccess().getPredicateDefinitionParserRuleCall_0_1()); | 369 | newCompositeNode(grammarAccess.getStatementAccess().getPredicateDefinitionParserRuleCall_0_1()); |
378 | 370 | ||
379 | } | ||
380 | pushFollow(FOLLOW_4); | 371 | pushFollow(FOLLOW_4); |
381 | this_PredicateDefinition_1=rulePredicateDefinition(); | 372 | this_PredicateDefinition_1=rulePredicateDefinition(); |
382 | 373 | ||
383 | state._fsp--; | 374 | state._fsp--; |
384 | if (state.failed) return current; | ||
385 | if ( state.backtracking==0 ) { | ||
386 | 375 | ||
387 | current = this_PredicateDefinition_1; | 376 | |
388 | afterParserOrEnumRuleCall(); | 377 | current = this_PredicateDefinition_1; |
389 | 378 | afterParserOrEnumRuleCall(); | |
390 | } | 379 | |
391 | 380 | ||
392 | } | 381 | } |
393 | break; | 382 | break; |
394 | case 3 : | 383 | case 3 : |
395 | // InternalSolverLanguage.g:135:4: this_UnnamedErrorPrediateDefinition_2= ruleUnnamedErrorPrediateDefinition | 384 | // InternalSolverLanguageParser.g:128:4: this_UnnamedErrorPrediateDefinition_2= ruleUnnamedErrorPrediateDefinition |
396 | { | 385 | { |
397 | if ( state.backtracking==0 ) { | ||
398 | 386 | ||
399 | newCompositeNode(grammarAccess.getStatementAccess().getUnnamedErrorPrediateDefinitionParserRuleCall_0_2()); | 387 | newCompositeNode(grammarAccess.getStatementAccess().getUnnamedErrorPrediateDefinitionParserRuleCall_0_2()); |
400 | 388 | ||
401 | } | ||
402 | pushFollow(FOLLOW_4); | 389 | pushFollow(FOLLOW_4); |
403 | this_UnnamedErrorPrediateDefinition_2=ruleUnnamedErrorPrediateDefinition(); | 390 | this_UnnamedErrorPrediateDefinition_2=ruleUnnamedErrorPrediateDefinition(); |
404 | 391 | ||
405 | state._fsp--; | 392 | state._fsp--; |
406 | if (state.failed) return current; | ||
407 | if ( state.backtracking==0 ) { | ||
408 | 393 | ||
409 | current = this_UnnamedErrorPrediateDefinition_2; | 394 | |
410 | afterParserOrEnumRuleCall(); | 395 | current = this_UnnamedErrorPrediateDefinition_2; |
411 | 396 | afterParserOrEnumRuleCall(); | |
412 | } | 397 | |
413 | 398 | ||
414 | } | 399 | } |
415 | break; | 400 | break; |
416 | case 4 : | 401 | case 4 : |
417 | // InternalSolverLanguage.g:144:4: this_DefaultDefinition_3= ruleDefaultDefinition | 402 | // InternalSolverLanguageParser.g:137:4: this_DefaultDefinition_3= ruleDefaultDefinition |
418 | { | 403 | { |
419 | if ( state.backtracking==0 ) { | ||
420 | 404 | ||
421 | newCompositeNode(grammarAccess.getStatementAccess().getDefaultDefinitionParserRuleCall_0_3()); | 405 | newCompositeNode(grammarAccess.getStatementAccess().getDefaultDefinitionParserRuleCall_0_3()); |
422 | 406 | ||
423 | } | ||
424 | pushFollow(FOLLOW_4); | 407 | pushFollow(FOLLOW_4); |
425 | this_DefaultDefinition_3=ruleDefaultDefinition(); | 408 | this_DefaultDefinition_3=ruleDefaultDefinition(); |
426 | 409 | ||
427 | state._fsp--; | 410 | state._fsp--; |
428 | if (state.failed) return current; | ||
429 | if ( state.backtracking==0 ) { | ||
430 | 411 | ||
431 | current = this_DefaultDefinition_3; | 412 | |
432 | afterParserOrEnumRuleCall(); | 413 | current = this_DefaultDefinition_3; |
433 | 414 | afterParserOrEnumRuleCall(); | |
434 | } | 415 | |
435 | 416 | ||
436 | } | 417 | } |
437 | break; | 418 | break; |
438 | case 5 : | 419 | case 5 : |
439 | // InternalSolverLanguage.g:153:4: this_ExternPredicateDefinition_4= ruleExternPredicateDefinition | 420 | // InternalSolverLanguageParser.g:146:4: this_ExternPredicateDefinition_4= ruleExternPredicateDefinition |
440 | { | 421 | { |
441 | if ( state.backtracking==0 ) { | ||
442 | 422 | ||
443 | newCompositeNode(grammarAccess.getStatementAccess().getExternPredicateDefinitionParserRuleCall_0_4()); | 423 | newCompositeNode(grammarAccess.getStatementAccess().getExternPredicateDefinitionParserRuleCall_0_4()); |
444 | 424 | ||
445 | } | ||
446 | pushFollow(FOLLOW_4); | 425 | pushFollow(FOLLOW_4); |
447 | this_ExternPredicateDefinition_4=ruleExternPredicateDefinition(); | 426 | this_ExternPredicateDefinition_4=ruleExternPredicateDefinition(); |
448 | 427 | ||
449 | state._fsp--; | 428 | state._fsp--; |
450 | if (state.failed) return current; | ||
451 | if ( state.backtracking==0 ) { | ||
452 | 429 | ||
453 | current = this_ExternPredicateDefinition_4; | 430 | |
454 | afterParserOrEnumRuleCall(); | 431 | current = this_ExternPredicateDefinition_4; |
455 | 432 | afterParserOrEnumRuleCall(); | |
456 | } | 433 | |
457 | 434 | ||
458 | } | 435 | } |
459 | break; | 436 | break; |
460 | case 6 : | 437 | case 6 : |
461 | // InternalSolverLanguage.g:162:4: this_MetricDefinition_5= ruleMetricDefinition | 438 | // InternalSolverLanguageParser.g:155:4: this_MetricDefinition_5= ruleMetricDefinition |
462 | { | 439 | { |
463 | if ( state.backtracking==0 ) { | ||
464 | 440 | ||
465 | newCompositeNode(grammarAccess.getStatementAccess().getMetricDefinitionParserRuleCall_0_5()); | 441 | newCompositeNode(grammarAccess.getStatementAccess().getMetricDefinitionParserRuleCall_0_5()); |
466 | 442 | ||
467 | } | ||
468 | pushFollow(FOLLOW_4); | 443 | pushFollow(FOLLOW_4); |
469 | this_MetricDefinition_5=ruleMetricDefinition(); | 444 | this_MetricDefinition_5=ruleMetricDefinition(); |
470 | 445 | ||
471 | state._fsp--; | 446 | state._fsp--; |
472 | if (state.failed) return current; | ||
473 | if ( state.backtracking==0 ) { | ||
474 | 447 | ||
475 | current = this_MetricDefinition_5; | 448 | |
476 | afterParserOrEnumRuleCall(); | 449 | current = this_MetricDefinition_5; |
477 | 450 | afterParserOrEnumRuleCall(); | |
478 | } | 451 | |
479 | 452 | ||
480 | } | 453 | } |
481 | break; | 454 | break; |
482 | case 7 : | 455 | case 7 : |
483 | // InternalSolverLanguage.g:171:4: this_ExternMetricDefinition_6= ruleExternMetricDefinition | 456 | // InternalSolverLanguageParser.g:164:4: this_ExternMetricDefinition_6= ruleExternMetricDefinition |
484 | { | 457 | { |
485 | if ( state.backtracking==0 ) { | ||
486 | 458 | ||
487 | newCompositeNode(grammarAccess.getStatementAccess().getExternMetricDefinitionParserRuleCall_0_6()); | 459 | newCompositeNode(grammarAccess.getStatementAccess().getExternMetricDefinitionParserRuleCall_0_6()); |
488 | 460 | ||
489 | } | ||
490 | pushFollow(FOLLOW_4); | 461 | pushFollow(FOLLOW_4); |
491 | this_ExternMetricDefinition_6=ruleExternMetricDefinition(); | 462 | this_ExternMetricDefinition_6=ruleExternMetricDefinition(); |
492 | 463 | ||
493 | state._fsp--; | 464 | state._fsp--; |
494 | if (state.failed) return current; | ||
495 | if ( state.backtracking==0 ) { | ||
496 | 465 | ||
497 | current = this_ExternMetricDefinition_6; | 466 | |
498 | afterParserOrEnumRuleCall(); | 467 | current = this_ExternMetricDefinition_6; |
499 | 468 | afterParserOrEnumRuleCall(); | |
500 | } | 469 | |
501 | 470 | ||
502 | } | 471 | } |
503 | break; | 472 | break; |
504 | case 8 : | 473 | case 8 : |
505 | // InternalSolverLanguage.g:180:4: this_ClassDefinition_7= ruleClassDefinition | 474 | // InternalSolverLanguageParser.g:173:4: this_ClassDefinition_7= ruleClassDefinition |
506 | { | 475 | { |
507 | if ( state.backtracking==0 ) { | ||
508 | 476 | ||
509 | newCompositeNode(grammarAccess.getStatementAccess().getClassDefinitionParserRuleCall_0_7()); | 477 | newCompositeNode(grammarAccess.getStatementAccess().getClassDefinitionParserRuleCall_0_7()); |
510 | 478 | ||
511 | } | ||
512 | pushFollow(FOLLOW_4); | 479 | pushFollow(FOLLOW_4); |
513 | this_ClassDefinition_7=ruleClassDefinition(); | 480 | this_ClassDefinition_7=ruleClassDefinition(); |
514 | 481 | ||
515 | state._fsp--; | 482 | state._fsp--; |
516 | if (state.failed) return current; | ||
517 | if ( state.backtracking==0 ) { | ||
518 | 483 | ||
519 | current = this_ClassDefinition_7; | 484 | |
520 | afterParserOrEnumRuleCall(); | 485 | current = this_ClassDefinition_7; |
521 | 486 | afterParserOrEnumRuleCall(); | |
522 | } | 487 | |
523 | 488 | ||
524 | } | 489 | } |
525 | break; | 490 | break; |
526 | case 9 : | 491 | case 9 : |
527 | // InternalSolverLanguage.g:189:4: this_ScopeDefinition_8= ruleScopeDefinition | 492 | // InternalSolverLanguageParser.g:182:4: this_ScopeDefinition_8= ruleScopeDefinition |
528 | { | 493 | { |
529 | if ( state.backtracking==0 ) { | ||
530 | 494 | ||
531 | newCompositeNode(grammarAccess.getStatementAccess().getScopeDefinitionParserRuleCall_0_8()); | 495 | newCompositeNode(grammarAccess.getStatementAccess().getScopeDefinitionParserRuleCall_0_8()); |
532 | 496 | ||
533 | } | ||
534 | pushFollow(FOLLOW_4); | 497 | pushFollow(FOLLOW_4); |
535 | this_ScopeDefinition_8=ruleScopeDefinition(); | 498 | this_ScopeDefinition_8=ruleScopeDefinition(); |
536 | 499 | ||
537 | state._fsp--; | 500 | state._fsp--; |
538 | if (state.failed) return current; | ||
539 | if ( state.backtracking==0 ) { | ||
540 | 501 | ||
541 | current = this_ScopeDefinition_8; | 502 | |
542 | afterParserOrEnumRuleCall(); | 503 | current = this_ScopeDefinition_8; |
543 | 504 | afterParserOrEnumRuleCall(); | |
544 | } | 505 | |
545 | 506 | ||
546 | } | 507 | } |
547 | break; | 508 | break; |
548 | case 10 : | 509 | case 10 : |
549 | // InternalSolverLanguage.g:198:4: this_ObjectiveDefinition_9= ruleObjectiveDefinition | 510 | // InternalSolverLanguageParser.g:191:4: this_ObjectiveDefinition_9= ruleObjectiveDefinition |
550 | { | 511 | { |
551 | if ( state.backtracking==0 ) { | ||
552 | 512 | ||
553 | newCompositeNode(grammarAccess.getStatementAccess().getObjectiveDefinitionParserRuleCall_0_9()); | 513 | newCompositeNode(grammarAccess.getStatementAccess().getObjectiveDefinitionParserRuleCall_0_9()); |
554 | 514 | ||
555 | } | ||
556 | pushFollow(FOLLOW_4); | 515 | pushFollow(FOLLOW_4); |
557 | this_ObjectiveDefinition_9=ruleObjectiveDefinition(); | 516 | this_ObjectiveDefinition_9=ruleObjectiveDefinition(); |
558 | 517 | ||
559 | state._fsp--; | 518 | state._fsp--; |
560 | if (state.failed) return current; | ||
561 | if ( state.backtracking==0 ) { | ||
562 | 519 | ||
563 | current = this_ObjectiveDefinition_9; | 520 | |
564 | afterParserOrEnumRuleCall(); | 521 | current = this_ObjectiveDefinition_9; |
565 | 522 | afterParserOrEnumRuleCall(); | |
566 | } | 523 | |
567 | 524 | ||
568 | } | 525 | } |
569 | break; | 526 | break; |
570 | 527 | ||
571 | } | 528 | } |
572 | 529 | ||
573 | this_DOT_10=(Token)match(input,RULE_DOT,FOLLOW_2); if (state.failed) return current; | 530 | this_FULL_STOP_10=(Token)match(input,RULE_FULL_STOP,FOLLOW_2); |
574 | if ( state.backtracking==0 ) { | ||
575 | 531 | ||
576 | newLeafNode(this_DOT_10, grammarAccess.getStatementAccess().getDOTTerminalRuleCall_1()); | 532 | newLeafNode(this_FULL_STOP_10, grammarAccess.getStatementAccess().getFULL_STOPTerminalRuleCall_1()); |
577 | 533 | ||
578 | } | ||
579 | 534 | ||
580 | } | 535 | } |
581 | 536 | ||
582 | 537 | ||
583 | } | 538 | } |
584 | 539 | ||
585 | if ( state.backtracking==0 ) { | ||
586 | 540 | ||
587 | leaveRule(); | 541 | leaveRule(); |
588 | 542 | ||
589 | } | ||
590 | } | 543 | } |
591 | 544 | ||
592 | catch (RecognitionException re) { | 545 | catch (RecognitionException re) { |
@@ -601,7 +554,7 @@ public class InternalSolverLanguageParser extends AbstractInternalAntlrParser { | |||
601 | 554 | ||
602 | 555 | ||
603 | // $ANTLR start "entryRuleAssertionOrDefinition" | 556 | // $ANTLR start "entryRuleAssertionOrDefinition" |
604 | // InternalSolverLanguage.g:215:1: entryRuleAssertionOrDefinition returns [EObject current=null] : iv_ruleAssertionOrDefinition= ruleAssertionOrDefinition EOF ; | 557 | // InternalSolverLanguageParser.g:208:1: entryRuleAssertionOrDefinition returns [EObject current=null] : iv_ruleAssertionOrDefinition= ruleAssertionOrDefinition EOF ; |
605 | public final EObject entryRuleAssertionOrDefinition() throws RecognitionException { | 558 | public final EObject entryRuleAssertionOrDefinition() throws RecognitionException { |
606 | EObject current = null; | 559 | EObject current = null; |
607 | 560 | ||
@@ -609,21 +562,17 @@ public class InternalSolverLanguageParser extends AbstractInternalAntlrParser { | |||
609 | 562 | ||
610 | 563 | ||
611 | try { | 564 | try { |
612 | // InternalSolverLanguage.g:215:62: (iv_ruleAssertionOrDefinition= ruleAssertionOrDefinition EOF ) | 565 | // InternalSolverLanguageParser.g:208:62: (iv_ruleAssertionOrDefinition= ruleAssertionOrDefinition EOF ) |
613 | // InternalSolverLanguage.g:216:2: iv_ruleAssertionOrDefinition= ruleAssertionOrDefinition EOF | 566 | // InternalSolverLanguageParser.g:209:2: iv_ruleAssertionOrDefinition= ruleAssertionOrDefinition EOF |
614 | { | 567 | { |
615 | if ( state.backtracking==0 ) { | 568 | newCompositeNode(grammarAccess.getAssertionOrDefinitionRule()); |
616 | newCompositeNode(grammarAccess.getAssertionOrDefinitionRule()); | ||
617 | } | ||
618 | pushFollow(FOLLOW_1); | 569 | pushFollow(FOLLOW_1); |
619 | iv_ruleAssertionOrDefinition=ruleAssertionOrDefinition(); | 570 | iv_ruleAssertionOrDefinition=ruleAssertionOrDefinition(); |
620 | 571 | ||
621 | state._fsp--; | 572 | state._fsp--; |
622 | if (state.failed) return current; | 573 | |
623 | if ( state.backtracking==0 ) { | 574 | current =iv_ruleAssertionOrDefinition; |
624 | current =iv_ruleAssertionOrDefinition; | 575 | match(input,EOF,FOLLOW_2); |
625 | } | ||
626 | match(input,EOF,FOLLOW_2); if (state.failed) return current; | ||
627 | 576 | ||
628 | } | 577 | } |
629 | 578 | ||
@@ -641,7 +590,7 @@ public class InternalSolverLanguageParser extends AbstractInternalAntlrParser { | |||
641 | 590 | ||
642 | 591 | ||
643 | // $ANTLR start "ruleAssertionOrDefinition" | 592 | // $ANTLR start "ruleAssertionOrDefinition" |
644 | // InternalSolverLanguage.g:222:1: ruleAssertionOrDefinition returns [EObject current=null] : (this_Expression_0= ruleExpression ( ( () (otherlv_2= ':' ( (lv_range_3_0= ruleExpression ) ) )? ) | ( () otherlv_5= ':-' ( (lv_body_6_0= ruleExpression ) ) ) | ( () otherlv_8= '=' ( (lv_body_9_0= ruleExpression ) ) ) ) ) ; | 593 | // InternalSolverLanguageParser.g:215:1: ruleAssertionOrDefinition returns [EObject current=null] : (this_Expression_0= ruleExpression ( ( () (otherlv_2= Colon ( (lv_range_3_0= ruleExpression ) ) )? ) | ( () otherlv_5= ColonHyphenMinus ( (lv_body_6_0= ruleExpression ) ) ) | ( () otherlv_8= EqualsSign ( (lv_body_9_0= ruleExpression ) ) ) ) ) ; |
645 | public final EObject ruleAssertionOrDefinition() throws RecognitionException { | 594 | public final EObject ruleAssertionOrDefinition() throws RecognitionException { |
646 | EObject current = null; | 595 | EObject current = null; |
647 | 596 | ||
@@ -661,50 +610,45 @@ public class InternalSolverLanguageParser extends AbstractInternalAntlrParser { | |||
661 | enterRule(); | 610 | enterRule(); |
662 | 611 | ||
663 | try { | 612 | try { |
664 | // InternalSolverLanguage.g:228:2: ( (this_Expression_0= ruleExpression ( ( () (otherlv_2= ':' ( (lv_range_3_0= ruleExpression ) ) )? ) | ( () otherlv_5= ':-' ( (lv_body_6_0= ruleExpression ) ) ) | ( () otherlv_8= '=' ( (lv_body_9_0= ruleExpression ) ) ) ) ) ) | 613 | // InternalSolverLanguageParser.g:221:2: ( (this_Expression_0= ruleExpression ( ( () (otherlv_2= Colon ( (lv_range_3_0= ruleExpression ) ) )? ) | ( () otherlv_5= ColonHyphenMinus ( (lv_body_6_0= ruleExpression ) ) ) | ( () otherlv_8= EqualsSign ( (lv_body_9_0= ruleExpression ) ) ) ) ) ) |
665 | // InternalSolverLanguage.g:229:2: (this_Expression_0= ruleExpression ( ( () (otherlv_2= ':' ( (lv_range_3_0= ruleExpression ) ) )? ) | ( () otherlv_5= ':-' ( (lv_body_6_0= ruleExpression ) ) ) | ( () otherlv_8= '=' ( (lv_body_9_0= ruleExpression ) ) ) ) ) | 614 | // InternalSolverLanguageParser.g:222:2: (this_Expression_0= ruleExpression ( ( () (otherlv_2= Colon ( (lv_range_3_0= ruleExpression ) ) )? ) | ( () otherlv_5= ColonHyphenMinus ( (lv_body_6_0= ruleExpression ) ) ) | ( () otherlv_8= EqualsSign ( (lv_body_9_0= ruleExpression ) ) ) ) ) |
666 | { | 615 | { |
667 | // InternalSolverLanguage.g:229:2: (this_Expression_0= ruleExpression ( ( () (otherlv_2= ':' ( (lv_range_3_0= ruleExpression ) ) )? ) | ( () otherlv_5= ':-' ( (lv_body_6_0= ruleExpression ) ) ) | ( () otherlv_8= '=' ( (lv_body_9_0= ruleExpression ) ) ) ) ) | 616 | // InternalSolverLanguageParser.g:222:2: (this_Expression_0= ruleExpression ( ( () (otherlv_2= Colon ( (lv_range_3_0= ruleExpression ) ) )? ) | ( () otherlv_5= ColonHyphenMinus ( (lv_body_6_0= ruleExpression ) ) ) | ( () otherlv_8= EqualsSign ( (lv_body_9_0= ruleExpression ) ) ) ) ) |
668 | // InternalSolverLanguage.g:230:3: this_Expression_0= ruleExpression ( ( () (otherlv_2= ':' ( (lv_range_3_0= ruleExpression ) ) )? ) | ( () otherlv_5= ':-' ( (lv_body_6_0= ruleExpression ) ) ) | ( () otherlv_8= '=' ( (lv_body_9_0= ruleExpression ) ) ) ) | 617 | // InternalSolverLanguageParser.g:223:3: this_Expression_0= ruleExpression ( ( () (otherlv_2= Colon ( (lv_range_3_0= ruleExpression ) ) )? ) | ( () otherlv_5= ColonHyphenMinus ( (lv_body_6_0= ruleExpression ) ) ) | ( () otherlv_8= EqualsSign ( (lv_body_9_0= ruleExpression ) ) ) ) |
669 | { | 618 | { |
670 | if ( state.backtracking==0 ) { | ||
671 | 619 | ||
672 | newCompositeNode(grammarAccess.getAssertionOrDefinitionAccess().getExpressionParserRuleCall_0()); | 620 | newCompositeNode(grammarAccess.getAssertionOrDefinitionAccess().getExpressionParserRuleCall_0()); |
673 | 621 | ||
674 | } | ||
675 | pushFollow(FOLLOW_5); | 622 | pushFollow(FOLLOW_5); |
676 | this_Expression_0=ruleExpression(); | 623 | this_Expression_0=ruleExpression(); |
677 | 624 | ||
678 | state._fsp--; | 625 | state._fsp--; |
679 | if (state.failed) return current; | ||
680 | if ( state.backtracking==0 ) { | ||
681 | 626 | ||
682 | current = this_Expression_0; | 627 | |
683 | afterParserOrEnumRuleCall(); | 628 | current = this_Expression_0; |
684 | 629 | afterParserOrEnumRuleCall(); | |
685 | } | 630 | |
686 | // InternalSolverLanguage.g:238:3: ( ( () (otherlv_2= ':' ( (lv_range_3_0= ruleExpression ) ) )? ) | ( () otherlv_5= ':-' ( (lv_body_6_0= ruleExpression ) ) ) | ( () otherlv_8= '=' ( (lv_body_9_0= ruleExpression ) ) ) ) | 631 | // InternalSolverLanguageParser.g:231:3: ( ( () (otherlv_2= Colon ( (lv_range_3_0= ruleExpression ) ) )? ) | ( () otherlv_5= ColonHyphenMinus ( (lv_body_6_0= ruleExpression ) ) ) | ( () otherlv_8= EqualsSign ( (lv_body_9_0= ruleExpression ) ) ) ) |
687 | int alt4=3; | 632 | int alt4=3; |
688 | switch ( input.LA(1) ) { | 633 | switch ( input.LA(1) ) { |
689 | case EOF: | 634 | case EOF: |
690 | case RULE_DOT: | 635 | case Colon: |
691 | case 15: | 636 | case RULE_FULL_STOP: |
692 | { | 637 | { |
693 | alt4=1; | 638 | alt4=1; |
694 | } | 639 | } |
695 | break; | 640 | break; |
696 | case 16: | 641 | case ColonHyphenMinus: |
697 | { | 642 | { |
698 | alt4=2; | 643 | alt4=2; |
699 | } | 644 | } |
700 | break; | 645 | break; |
701 | case 17: | 646 | case EqualsSign: |
702 | { | 647 | { |
703 | alt4=3; | 648 | alt4=3; |
704 | } | 649 | } |
705 | break; | 650 | break; |
706 | default: | 651 | default: |
707 | if (state.backtracking>0) {state.failed=true; return current;} | ||
708 | NoViableAltException nvae = | 652 | NoViableAltException nvae = |
709 | new NoViableAltException("", 4, 0, input); | 653 | new NoViableAltException("", 4, 0, input); |
710 | 654 | ||
@@ -713,70 +657,62 @@ public class InternalSolverLanguageParser extends AbstractInternalAntlrParser { | |||
713 | 657 | ||
714 | switch (alt4) { | 658 | switch (alt4) { |
715 | case 1 : | 659 | case 1 : |
716 | // InternalSolverLanguage.g:239:4: ( () (otherlv_2= ':' ( (lv_range_3_0= ruleExpression ) ) )? ) | 660 | // InternalSolverLanguageParser.g:232:4: ( () (otherlv_2= Colon ( (lv_range_3_0= ruleExpression ) ) )? ) |
717 | { | 661 | { |
718 | // InternalSolverLanguage.g:239:4: ( () (otherlv_2= ':' ( (lv_range_3_0= ruleExpression ) ) )? ) | 662 | // InternalSolverLanguageParser.g:232:4: ( () (otherlv_2= Colon ( (lv_range_3_0= ruleExpression ) ) )? ) |
719 | // InternalSolverLanguage.g:240:5: () (otherlv_2= ':' ( (lv_range_3_0= ruleExpression ) ) )? | 663 | // InternalSolverLanguageParser.g:233:5: () (otherlv_2= Colon ( (lv_range_3_0= ruleExpression ) ) )? |
720 | { | 664 | { |
721 | // InternalSolverLanguage.g:240:5: () | 665 | // InternalSolverLanguageParser.g:233:5: () |
722 | // InternalSolverLanguage.g:241:6: | 666 | // InternalSolverLanguageParser.g:234:6: |
723 | { | 667 | { |
724 | if ( state.backtracking==0 ) { | ||
725 | 668 | ||
726 | current = forceCreateModelElementAndSet( | 669 | current = forceCreateModelElementAndSet( |
727 | grammarAccess.getAssertionOrDefinitionAccess().getAssertionBodyAction_1_0_0(), | 670 | grammarAccess.getAssertionOrDefinitionAccess().getAssertionBodyAction_1_0_0(), |
728 | current); | 671 | current); |
729 | 672 | ||
730 | } | ||
731 | 673 | ||
732 | } | 674 | } |
733 | 675 | ||
734 | // InternalSolverLanguage.g:247:5: (otherlv_2= ':' ( (lv_range_3_0= ruleExpression ) ) )? | 676 | // InternalSolverLanguageParser.g:240:5: (otherlv_2= Colon ( (lv_range_3_0= ruleExpression ) ) )? |
735 | int alt3=2; | 677 | int alt3=2; |
736 | int LA3_0 = input.LA(1); | 678 | int LA3_0 = input.LA(1); |
737 | 679 | ||
738 | if ( (LA3_0==15) ) { | 680 | if ( (LA3_0==Colon) ) { |
739 | alt3=1; | 681 | alt3=1; |
740 | } | 682 | } |
741 | switch (alt3) { | 683 | switch (alt3) { |
742 | case 1 : | 684 | case 1 : |
743 | // InternalSolverLanguage.g:248:6: otherlv_2= ':' ( (lv_range_3_0= ruleExpression ) ) | 685 | // InternalSolverLanguageParser.g:241:6: otherlv_2= Colon ( (lv_range_3_0= ruleExpression ) ) |
744 | { | 686 | { |
745 | otherlv_2=(Token)match(input,15,FOLLOW_6); if (state.failed) return current; | 687 | otherlv_2=(Token)match(input,Colon,FOLLOW_6); |
746 | if ( state.backtracking==0 ) { | ||
747 | 688 | ||
748 | newLeafNode(otherlv_2, grammarAccess.getAssertionOrDefinitionAccess().getColonKeyword_1_0_1_0()); | 689 | newLeafNode(otherlv_2, grammarAccess.getAssertionOrDefinitionAccess().getColonKeyword_1_0_1_0()); |
749 | 690 | ||
750 | } | 691 | // InternalSolverLanguageParser.g:245:6: ( (lv_range_3_0= ruleExpression ) ) |
751 | // InternalSolverLanguage.g:252:6: ( (lv_range_3_0= ruleExpression ) ) | 692 | // InternalSolverLanguageParser.g:246:7: (lv_range_3_0= ruleExpression ) |
752 | // InternalSolverLanguage.g:253:7: (lv_range_3_0= ruleExpression ) | ||
753 | { | 693 | { |
754 | // InternalSolverLanguage.g:253:7: (lv_range_3_0= ruleExpression ) | 694 | // InternalSolverLanguageParser.g:246:7: (lv_range_3_0= ruleExpression ) |
755 | // InternalSolverLanguage.g:254:8: lv_range_3_0= ruleExpression | 695 | // InternalSolverLanguageParser.g:247:8: lv_range_3_0= ruleExpression |
756 | { | 696 | { |
757 | if ( state.backtracking==0 ) { | ||
758 | 697 | ||
759 | newCompositeNode(grammarAccess.getAssertionOrDefinitionAccess().getRangeExpressionParserRuleCall_1_0_1_1_0()); | 698 | newCompositeNode(grammarAccess.getAssertionOrDefinitionAccess().getRangeExpressionParserRuleCall_1_0_1_1_0()); |
760 | 699 | ||
761 | } | ||
762 | pushFollow(FOLLOW_2); | 700 | pushFollow(FOLLOW_2); |
763 | lv_range_3_0=ruleExpression(); | 701 | lv_range_3_0=ruleExpression(); |
764 | 702 | ||
765 | state._fsp--; | 703 | state._fsp--; |
766 | if (state.failed) return current; | 704 | |
767 | if ( state.backtracking==0 ) { | 705 | |
768 | 706 | if (current==null) { | |
769 | if (current==null) { | 707 | current = createModelElementForParent(grammarAccess.getAssertionOrDefinitionRule()); |
770 | current = createModelElementForParent(grammarAccess.getAssertionOrDefinitionRule()); | 708 | } |
771 | } | 709 | set( |
772 | set( | 710 | current, |
773 | current, | 711 | "range", |
774 | "range", | 712 | lv_range_3_0, |
775 | lv_range_3_0, | 713 | "org.eclipse.viatra.solver.language.SolverLanguage.Expression"); |
776 | "org.eclipse.viatra.solver.language.SolverLanguage.Expression"); | 714 | afterParserOrEnumRuleCall(); |
777 | afterParserOrEnumRuleCall(); | 715 | |
778 | |||
779 | } | ||
780 | 716 | ||
781 | } | 717 | } |
782 | 718 | ||
@@ -796,59 +732,51 @@ public class InternalSolverLanguageParser extends AbstractInternalAntlrParser { | |||
796 | } | 732 | } |
797 | break; | 733 | break; |
798 | case 2 : | 734 | case 2 : |
799 | // InternalSolverLanguage.g:274:4: ( () otherlv_5= ':-' ( (lv_body_6_0= ruleExpression ) ) ) | 735 | // InternalSolverLanguageParser.g:267:4: ( () otherlv_5= ColonHyphenMinus ( (lv_body_6_0= ruleExpression ) ) ) |
800 | { | 736 | { |
801 | // InternalSolverLanguage.g:274:4: ( () otherlv_5= ':-' ( (lv_body_6_0= ruleExpression ) ) ) | 737 | // InternalSolverLanguageParser.g:267:4: ( () otherlv_5= ColonHyphenMinus ( (lv_body_6_0= ruleExpression ) ) ) |
802 | // InternalSolverLanguage.g:275:5: () otherlv_5= ':-' ( (lv_body_6_0= ruleExpression ) ) | 738 | // InternalSolverLanguageParser.g:268:5: () otherlv_5= ColonHyphenMinus ( (lv_body_6_0= ruleExpression ) ) |
803 | { | 739 | { |
804 | // InternalSolverLanguage.g:275:5: () | 740 | // InternalSolverLanguageParser.g:268:5: () |
805 | // InternalSolverLanguage.g:276:6: | 741 | // InternalSolverLanguageParser.g:269:6: |
806 | { | 742 | { |
807 | if ( state.backtracking==0 ) { | ||
808 | 743 | ||
809 | current = forceCreateModelElementAndSet( | 744 | current = forceCreateModelElementAndSet( |
810 | grammarAccess.getAssertionOrDefinitionAccess().getPredicateDefinitionHeadAction_1_1_0(), | 745 | grammarAccess.getAssertionOrDefinitionAccess().getPredicateDefinitionHeadAction_1_1_0(), |
811 | current); | 746 | current); |
812 | 747 | ||
813 | } | ||
814 | 748 | ||
815 | } | 749 | } |
816 | 750 | ||
817 | otherlv_5=(Token)match(input,16,FOLLOW_6); if (state.failed) return current; | 751 | otherlv_5=(Token)match(input,ColonHyphenMinus,FOLLOW_6); |
818 | if ( state.backtracking==0 ) { | ||
819 | 752 | ||
820 | newLeafNode(otherlv_5, grammarAccess.getAssertionOrDefinitionAccess().getColonHyphenMinusKeyword_1_1_1()); | 753 | newLeafNode(otherlv_5, grammarAccess.getAssertionOrDefinitionAccess().getColonHyphenMinusKeyword_1_1_1()); |
821 | 754 | ||
822 | } | 755 | // InternalSolverLanguageParser.g:279:5: ( (lv_body_6_0= ruleExpression ) ) |
823 | // InternalSolverLanguage.g:286:5: ( (lv_body_6_0= ruleExpression ) ) | 756 | // InternalSolverLanguageParser.g:280:6: (lv_body_6_0= ruleExpression ) |
824 | // InternalSolverLanguage.g:287:6: (lv_body_6_0= ruleExpression ) | ||
825 | { | 757 | { |
826 | // InternalSolverLanguage.g:287:6: (lv_body_6_0= ruleExpression ) | 758 | // InternalSolverLanguageParser.g:280:6: (lv_body_6_0= ruleExpression ) |
827 | // InternalSolverLanguage.g:288:7: lv_body_6_0= ruleExpression | 759 | // InternalSolverLanguageParser.g:281:7: lv_body_6_0= ruleExpression |
828 | { | 760 | { |
829 | if ( state.backtracking==0 ) { | ||
830 | 761 | ||
831 | newCompositeNode(grammarAccess.getAssertionOrDefinitionAccess().getBodyExpressionParserRuleCall_1_1_2_0()); | 762 | newCompositeNode(grammarAccess.getAssertionOrDefinitionAccess().getBodyExpressionParserRuleCall_1_1_2_0()); |
832 | 763 | ||
833 | } | ||
834 | pushFollow(FOLLOW_2); | 764 | pushFollow(FOLLOW_2); |
835 | lv_body_6_0=ruleExpression(); | 765 | lv_body_6_0=ruleExpression(); |
836 | 766 | ||
837 | state._fsp--; | 767 | state._fsp--; |
838 | if (state.failed) return current; | ||
839 | if ( state.backtracking==0 ) { | ||
840 | 768 | ||
841 | if (current==null) { | 769 | |
842 | current = createModelElementForParent(grammarAccess.getAssertionOrDefinitionRule()); | 770 | if (current==null) { |
843 | } | 771 | current = createModelElementForParent(grammarAccess.getAssertionOrDefinitionRule()); |
844 | set( | 772 | } |
845 | current, | 773 | set( |
846 | "body", | 774 | current, |
847 | lv_body_6_0, | 775 | "body", |
848 | "org.eclipse.viatra.solver.language.SolverLanguage.Expression"); | 776 | lv_body_6_0, |
849 | afterParserOrEnumRuleCall(); | 777 | "org.eclipse.viatra.solver.language.SolverLanguage.Expression"); |
850 | 778 | afterParserOrEnumRuleCall(); | |
851 | } | 779 | |
852 | 780 | ||
853 | } | 781 | } |
854 | 782 | ||
@@ -862,59 +790,51 @@ public class InternalSolverLanguageParser extends AbstractInternalAntlrParser { | |||
862 | } | 790 | } |
863 | break; | 791 | break; |
864 | case 3 : | 792 | case 3 : |
865 | // InternalSolverLanguage.g:307:4: ( () otherlv_8= '=' ( (lv_body_9_0= ruleExpression ) ) ) | 793 | // InternalSolverLanguageParser.g:300:4: ( () otherlv_8= EqualsSign ( (lv_body_9_0= ruleExpression ) ) ) |
866 | { | 794 | { |
867 | // InternalSolverLanguage.g:307:4: ( () otherlv_8= '=' ( (lv_body_9_0= ruleExpression ) ) ) | 795 | // InternalSolverLanguageParser.g:300:4: ( () otherlv_8= EqualsSign ( (lv_body_9_0= ruleExpression ) ) ) |
868 | // InternalSolverLanguage.g:308:5: () otherlv_8= '=' ( (lv_body_9_0= ruleExpression ) ) | 796 | // InternalSolverLanguageParser.g:301:5: () otherlv_8= EqualsSign ( (lv_body_9_0= ruleExpression ) ) |
869 | { | 797 | { |
870 | // InternalSolverLanguage.g:308:5: () | 798 | // InternalSolverLanguageParser.g:301:5: () |
871 | // InternalSolverLanguage.g:309:6: | 799 | // InternalSolverLanguageParser.g:302:6: |
872 | { | 800 | { |
873 | if ( state.backtracking==0 ) { | ||
874 | 801 | ||
875 | current = forceCreateModelElementAndSet( | 802 | current = forceCreateModelElementAndSet( |
876 | grammarAccess.getAssertionOrDefinitionAccess().getMetricDefinitionHeadAction_1_2_0(), | 803 | grammarAccess.getAssertionOrDefinitionAccess().getMetricDefinitionHeadAction_1_2_0(), |
877 | current); | 804 | current); |
878 | 805 | ||
879 | } | ||
880 | 806 | ||
881 | } | 807 | } |
882 | 808 | ||
883 | otherlv_8=(Token)match(input,17,FOLLOW_6); if (state.failed) return current; | 809 | otherlv_8=(Token)match(input,EqualsSign,FOLLOW_6); |
884 | if ( state.backtracking==0 ) { | ||
885 | 810 | ||
886 | newLeafNode(otherlv_8, grammarAccess.getAssertionOrDefinitionAccess().getEqualsSignKeyword_1_2_1()); | 811 | newLeafNode(otherlv_8, grammarAccess.getAssertionOrDefinitionAccess().getEqualsSignKeyword_1_2_1()); |
887 | 812 | ||
888 | } | 813 | // InternalSolverLanguageParser.g:312:5: ( (lv_body_9_0= ruleExpression ) ) |
889 | // InternalSolverLanguage.g:319:5: ( (lv_body_9_0= ruleExpression ) ) | 814 | // InternalSolverLanguageParser.g:313:6: (lv_body_9_0= ruleExpression ) |
890 | // InternalSolverLanguage.g:320:6: (lv_body_9_0= ruleExpression ) | ||
891 | { | 815 | { |
892 | // InternalSolverLanguage.g:320:6: (lv_body_9_0= ruleExpression ) | 816 | // InternalSolverLanguageParser.g:313:6: (lv_body_9_0= ruleExpression ) |
893 | // InternalSolverLanguage.g:321:7: lv_body_9_0= ruleExpression | 817 | // InternalSolverLanguageParser.g:314:7: lv_body_9_0= ruleExpression |
894 | { | 818 | { |
895 | if ( state.backtracking==0 ) { | ||
896 | 819 | ||
897 | newCompositeNode(grammarAccess.getAssertionOrDefinitionAccess().getBodyExpressionParserRuleCall_1_2_2_0()); | 820 | newCompositeNode(grammarAccess.getAssertionOrDefinitionAccess().getBodyExpressionParserRuleCall_1_2_2_0()); |
898 | 821 | ||
899 | } | ||
900 | pushFollow(FOLLOW_2); | 822 | pushFollow(FOLLOW_2); |
901 | lv_body_9_0=ruleExpression(); | 823 | lv_body_9_0=ruleExpression(); |
902 | 824 | ||
903 | state._fsp--; | 825 | state._fsp--; |
904 | if (state.failed) return current; | ||
905 | if ( state.backtracking==0 ) { | ||
906 | 826 | ||
907 | if (current==null) { | 827 | |
908 | current = createModelElementForParent(grammarAccess.getAssertionOrDefinitionRule()); | 828 | if (current==null) { |
909 | } | 829 | current = createModelElementForParent(grammarAccess.getAssertionOrDefinitionRule()); |
910 | set( | 830 | } |
911 | current, | 831 | set( |
912 | "body", | 832 | current, |
913 | lv_body_9_0, | 833 | "body", |
914 | "org.eclipse.viatra.solver.language.SolverLanguage.Expression"); | 834 | lv_body_9_0, |
915 | afterParserOrEnumRuleCall(); | 835 | "org.eclipse.viatra.solver.language.SolverLanguage.Expression"); |
916 | 836 | afterParserOrEnumRuleCall(); | |
917 | } | 837 | |
918 | 838 | ||
919 | } | 839 | } |
920 | 840 | ||
@@ -936,11 +856,9 @@ public class InternalSolverLanguageParser extends AbstractInternalAntlrParser { | |||
936 | 856 | ||
937 | } | 857 | } |
938 | 858 | ||
939 | if ( state.backtracking==0 ) { | ||
940 | 859 | ||
941 | leaveRule(); | 860 | leaveRule(); |
942 | 861 | ||
943 | } | ||
944 | } | 862 | } |
945 | 863 | ||
946 | catch (RecognitionException re) { | 864 | catch (RecognitionException re) { |
@@ -955,7 +873,7 @@ public class InternalSolverLanguageParser extends AbstractInternalAntlrParser { | |||
955 | 873 | ||
956 | 874 | ||
957 | // $ANTLR start "entryRulePredicateDefinition" | 875 | // $ANTLR start "entryRulePredicateDefinition" |
958 | // InternalSolverLanguage.g:344:1: entryRulePredicateDefinition returns [EObject current=null] : iv_rulePredicateDefinition= rulePredicateDefinition EOF ; | 876 | // InternalSolverLanguageParser.g:337:1: entryRulePredicateDefinition returns [EObject current=null] : iv_rulePredicateDefinition= rulePredicateDefinition EOF ; |
959 | public final EObject entryRulePredicateDefinition() throws RecognitionException { | 877 | public final EObject entryRulePredicateDefinition() throws RecognitionException { |
960 | EObject current = null; | 878 | EObject current = null; |
961 | 879 | ||
@@ -963,21 +881,17 @@ public class InternalSolverLanguageParser extends AbstractInternalAntlrParser { | |||
963 | 881 | ||
964 | 882 | ||
965 | try { | 883 | try { |
966 | // InternalSolverLanguage.g:344:60: (iv_rulePredicateDefinition= rulePredicateDefinition EOF ) | 884 | // InternalSolverLanguageParser.g:337:60: (iv_rulePredicateDefinition= rulePredicateDefinition EOF ) |
967 | // InternalSolverLanguage.g:345:2: iv_rulePredicateDefinition= rulePredicateDefinition EOF | 885 | // InternalSolverLanguageParser.g:338:2: iv_rulePredicateDefinition= rulePredicateDefinition EOF |
968 | { | 886 | { |
969 | if ( state.backtracking==0 ) { | 887 | newCompositeNode(grammarAccess.getPredicateDefinitionRule()); |
970 | newCompositeNode(grammarAccess.getPredicateDefinitionRule()); | ||
971 | } | ||
972 | pushFollow(FOLLOW_1); | 888 | pushFollow(FOLLOW_1); |
973 | iv_rulePredicateDefinition=rulePredicateDefinition(); | 889 | iv_rulePredicateDefinition=rulePredicateDefinition(); |
974 | 890 | ||
975 | state._fsp--; | 891 | state._fsp--; |
976 | if (state.failed) return current; | 892 | |
977 | if ( state.backtracking==0 ) { | 893 | current =iv_rulePredicateDefinition; |
978 | current =iv_rulePredicateDefinition; | 894 | match(input,EOF,FOLLOW_2); |
979 | } | ||
980 | match(input,EOF,FOLLOW_2); if (state.failed) return current; | ||
981 | 895 | ||
982 | } | 896 | } |
983 | 897 | ||
@@ -995,7 +909,7 @@ public class InternalSolverLanguageParser extends AbstractInternalAntlrParser { | |||
995 | 909 | ||
996 | 910 | ||
997 | // $ANTLR start "rulePredicateDefinition" | 911 | // $ANTLR start "rulePredicateDefinition" |
998 | // InternalSolverLanguage.g:351:1: rulePredicateDefinition returns [EObject current=null] : ( ( ( ( (lv_functional_0_0= 'functional' ) ) ( (lv_error_1_0= 'error' ) )? ) | ( ( (lv_error_2_0= 'error' ) ) ( (lv_functional_3_0= 'functional' ) )? ) ) ( (lv_head_4_0= ruleCall ) ) otherlv_5= ':-' ( (lv_body_6_0= ruleExpression ) ) ) ; | 912 | // InternalSolverLanguageParser.g:344:1: rulePredicateDefinition returns [EObject current=null] : ( ( ( ( (lv_functional_0_0= Functional ) ) ( (lv_error_1_0= Error ) )? ) | ( ( (lv_error_2_0= Error ) ) ( (lv_functional_3_0= Functional ) )? ) ) ( (lv_head_4_0= ruleCall ) ) otherlv_5= ColonHyphenMinus ( (lv_body_6_0= ruleExpression ) ) ) ; |
999 | public final EObject rulePredicateDefinition() throws RecognitionException { | 913 | public final EObject rulePredicateDefinition() throws RecognitionException { |
1000 | EObject current = null; | 914 | EObject current = null; |
1001 | 915 | ||
@@ -1013,24 +927,23 @@ public class InternalSolverLanguageParser extends AbstractInternalAntlrParser { | |||
1013 | enterRule(); | 927 | enterRule(); |
1014 | 928 | ||
1015 | try { | 929 | try { |
1016 | // InternalSolverLanguage.g:357:2: ( ( ( ( ( (lv_functional_0_0= 'functional' ) ) ( (lv_error_1_0= 'error' ) )? ) | ( ( (lv_error_2_0= 'error' ) ) ( (lv_functional_3_0= 'functional' ) )? ) ) ( (lv_head_4_0= ruleCall ) ) otherlv_5= ':-' ( (lv_body_6_0= ruleExpression ) ) ) ) | 930 | // InternalSolverLanguageParser.g:350:2: ( ( ( ( ( (lv_functional_0_0= Functional ) ) ( (lv_error_1_0= Error ) )? ) | ( ( (lv_error_2_0= Error ) ) ( (lv_functional_3_0= Functional ) )? ) ) ( (lv_head_4_0= ruleCall ) ) otherlv_5= ColonHyphenMinus ( (lv_body_6_0= ruleExpression ) ) ) ) |
1017 | // InternalSolverLanguage.g:358:2: ( ( ( ( (lv_functional_0_0= 'functional' ) ) ( (lv_error_1_0= 'error' ) )? ) | ( ( (lv_error_2_0= 'error' ) ) ( (lv_functional_3_0= 'functional' ) )? ) ) ( (lv_head_4_0= ruleCall ) ) otherlv_5= ':-' ( (lv_body_6_0= ruleExpression ) ) ) | 931 | // InternalSolverLanguageParser.g:351:2: ( ( ( ( (lv_functional_0_0= Functional ) ) ( (lv_error_1_0= Error ) )? ) | ( ( (lv_error_2_0= Error ) ) ( (lv_functional_3_0= Functional ) )? ) ) ( (lv_head_4_0= ruleCall ) ) otherlv_5= ColonHyphenMinus ( (lv_body_6_0= ruleExpression ) ) ) |
1018 | { | 932 | { |
1019 | // InternalSolverLanguage.g:358:2: ( ( ( ( (lv_functional_0_0= 'functional' ) ) ( (lv_error_1_0= 'error' ) )? ) | ( ( (lv_error_2_0= 'error' ) ) ( (lv_functional_3_0= 'functional' ) )? ) ) ( (lv_head_4_0= ruleCall ) ) otherlv_5= ':-' ( (lv_body_6_0= ruleExpression ) ) ) | 933 | // InternalSolverLanguageParser.g:351:2: ( ( ( ( (lv_functional_0_0= Functional ) ) ( (lv_error_1_0= Error ) )? ) | ( ( (lv_error_2_0= Error ) ) ( (lv_functional_3_0= Functional ) )? ) ) ( (lv_head_4_0= ruleCall ) ) otherlv_5= ColonHyphenMinus ( (lv_body_6_0= ruleExpression ) ) ) |
1020 | // InternalSolverLanguage.g:359:3: ( ( ( (lv_functional_0_0= 'functional' ) ) ( (lv_error_1_0= 'error' ) )? ) | ( ( (lv_error_2_0= 'error' ) ) ( (lv_functional_3_0= 'functional' ) )? ) ) ( (lv_head_4_0= ruleCall ) ) otherlv_5= ':-' ( (lv_body_6_0= ruleExpression ) ) | 934 | // InternalSolverLanguageParser.g:352:3: ( ( ( (lv_functional_0_0= Functional ) ) ( (lv_error_1_0= Error ) )? ) | ( ( (lv_error_2_0= Error ) ) ( (lv_functional_3_0= Functional ) )? ) ) ( (lv_head_4_0= ruleCall ) ) otherlv_5= ColonHyphenMinus ( (lv_body_6_0= ruleExpression ) ) |
1021 | { | 935 | { |
1022 | // InternalSolverLanguage.g:359:3: ( ( ( (lv_functional_0_0= 'functional' ) ) ( (lv_error_1_0= 'error' ) )? ) | ( ( (lv_error_2_0= 'error' ) ) ( (lv_functional_3_0= 'functional' ) )? ) ) | 936 | // InternalSolverLanguageParser.g:352:3: ( ( ( (lv_functional_0_0= Functional ) ) ( (lv_error_1_0= Error ) )? ) | ( ( (lv_error_2_0= Error ) ) ( (lv_functional_3_0= Functional ) )? ) ) |
1023 | int alt7=2; | 937 | int alt7=2; |
1024 | int LA7_0 = input.LA(1); | 938 | int LA7_0 = input.LA(1); |
1025 | 939 | ||
1026 | if ( (LA7_0==18) ) { | 940 | if ( (LA7_0==Functional) ) { |
1027 | alt7=1; | 941 | alt7=1; |
1028 | } | 942 | } |
1029 | else if ( (LA7_0==19) ) { | 943 | else if ( (LA7_0==Error) ) { |
1030 | alt7=2; | 944 | alt7=2; |
1031 | } | 945 | } |
1032 | else { | 946 | else { |
1033 | if (state.backtracking>0) {state.failed=true; return current;} | ||
1034 | NoViableAltException nvae = | 947 | NoViableAltException nvae = |
1035 | new NoViableAltException("", 7, 0, input); | 948 | new NoViableAltException("", 7, 0, input); |
1036 | 949 | ||
@@ -1038,65 +951,57 @@ public class InternalSolverLanguageParser extends AbstractInternalAntlrParser { | |||
1038 | } | 951 | } |
1039 | switch (alt7) { | 952 | switch (alt7) { |
1040 | case 1 : | 953 | case 1 : |
1041 | // InternalSolverLanguage.g:360:4: ( ( (lv_functional_0_0= 'functional' ) ) ( (lv_error_1_0= 'error' ) )? ) | 954 | // InternalSolverLanguageParser.g:353:4: ( ( (lv_functional_0_0= Functional ) ) ( (lv_error_1_0= Error ) )? ) |
1042 | { | 955 | { |
1043 | // InternalSolverLanguage.g:360:4: ( ( (lv_functional_0_0= 'functional' ) ) ( (lv_error_1_0= 'error' ) )? ) | 956 | // InternalSolverLanguageParser.g:353:4: ( ( (lv_functional_0_0= Functional ) ) ( (lv_error_1_0= Error ) )? ) |
1044 | // InternalSolverLanguage.g:361:5: ( (lv_functional_0_0= 'functional' ) ) ( (lv_error_1_0= 'error' ) )? | 957 | // InternalSolverLanguageParser.g:354:5: ( (lv_functional_0_0= Functional ) ) ( (lv_error_1_0= Error ) )? |
1045 | { | 958 | { |
1046 | // InternalSolverLanguage.g:361:5: ( (lv_functional_0_0= 'functional' ) ) | 959 | // InternalSolverLanguageParser.g:354:5: ( (lv_functional_0_0= Functional ) ) |
1047 | // InternalSolverLanguage.g:362:6: (lv_functional_0_0= 'functional' ) | 960 | // InternalSolverLanguageParser.g:355:6: (lv_functional_0_0= Functional ) |
1048 | { | 961 | { |
1049 | // InternalSolverLanguage.g:362:6: (lv_functional_0_0= 'functional' ) | 962 | // InternalSolverLanguageParser.g:355:6: (lv_functional_0_0= Functional ) |
1050 | // InternalSolverLanguage.g:363:7: lv_functional_0_0= 'functional' | 963 | // InternalSolverLanguageParser.g:356:7: lv_functional_0_0= Functional |
1051 | { | 964 | { |
1052 | lv_functional_0_0=(Token)match(input,18,FOLLOW_7); if (state.failed) return current; | 965 | lv_functional_0_0=(Token)match(input,Functional,FOLLOW_7); |
1053 | if ( state.backtracking==0 ) { | ||
1054 | 966 | ||
1055 | newLeafNode(lv_functional_0_0, grammarAccess.getPredicateDefinitionAccess().getFunctionalFunctionalKeyword_0_0_0_0()); | 967 | newLeafNode(lv_functional_0_0, grammarAccess.getPredicateDefinitionAccess().getFunctionalFunctionalKeyword_0_0_0_0()); |
1056 | 968 | ||
1057 | } | ||
1058 | if ( state.backtracking==0 ) { | ||
1059 | 969 | ||
1060 | if (current==null) { | 970 | if (current==null) { |
1061 | current = createModelElement(grammarAccess.getPredicateDefinitionRule()); | 971 | current = createModelElement(grammarAccess.getPredicateDefinitionRule()); |
1062 | } | 972 | } |
1063 | setWithLastConsumed(current, "functional", true, "functional"); | 973 | setWithLastConsumed(current, "functional", true, "functional"); |
1064 | 974 | ||
1065 | } | ||
1066 | 975 | ||
1067 | } | 976 | } |
1068 | 977 | ||
1069 | 978 | ||
1070 | } | 979 | } |
1071 | 980 | ||
1072 | // InternalSolverLanguage.g:375:5: ( (lv_error_1_0= 'error' ) )? | 981 | // InternalSolverLanguageParser.g:368:5: ( (lv_error_1_0= Error ) )? |
1073 | int alt5=2; | 982 | int alt5=2; |
1074 | int LA5_0 = input.LA(1); | 983 | int LA5_0 = input.LA(1); |
1075 | 984 | ||
1076 | if ( (LA5_0==19) ) { | 985 | if ( (LA5_0==Error) ) { |
1077 | alt5=1; | 986 | alt5=1; |
1078 | } | 987 | } |
1079 | switch (alt5) { | 988 | switch (alt5) { |
1080 | case 1 : | 989 | case 1 : |
1081 | // InternalSolverLanguage.g:376:6: (lv_error_1_0= 'error' ) | 990 | // InternalSolverLanguageParser.g:369:6: (lv_error_1_0= Error ) |
1082 | { | 991 | { |
1083 | // InternalSolverLanguage.g:376:6: (lv_error_1_0= 'error' ) | 992 | // InternalSolverLanguageParser.g:369:6: (lv_error_1_0= Error ) |
1084 | // InternalSolverLanguage.g:377:7: lv_error_1_0= 'error' | 993 | // InternalSolverLanguageParser.g:370:7: lv_error_1_0= Error |
1085 | { | 994 | { |
1086 | lv_error_1_0=(Token)match(input,19,FOLLOW_7); if (state.failed) return current; | 995 | lv_error_1_0=(Token)match(input,Error,FOLLOW_8); |
1087 | if ( state.backtracking==0 ) { | ||
1088 | 996 | ||
1089 | newLeafNode(lv_error_1_0, grammarAccess.getPredicateDefinitionAccess().getErrorErrorKeyword_0_0_1_0()); | 997 | newLeafNode(lv_error_1_0, grammarAccess.getPredicateDefinitionAccess().getErrorErrorKeyword_0_0_1_0()); |
1090 | 998 | ||
1091 | } | ||
1092 | if ( state.backtracking==0 ) { | ||
1093 | 999 | ||
1094 | if (current==null) { | 1000 | if (current==null) { |
1095 | current = createModelElement(grammarAccess.getPredicateDefinitionRule()); | 1001 | current = createModelElement(grammarAccess.getPredicateDefinitionRule()); |
1096 | } | 1002 | } |
1097 | setWithLastConsumed(current, "error", true, "error"); | 1003 | setWithLastConsumed(current, "error", true, "error"); |
1098 | 1004 | ||
1099 | } | ||
1100 | 1005 | ||
1101 | } | 1006 | } |
1102 | 1007 | ||
@@ -1113,65 +1018,57 @@ public class InternalSolverLanguageParser extends AbstractInternalAntlrParser { | |||
1113 | } | 1018 | } |
1114 | break; | 1019 | break; |
1115 | case 2 : | 1020 | case 2 : |
1116 | // InternalSolverLanguage.g:391:4: ( ( (lv_error_2_0= 'error' ) ) ( (lv_functional_3_0= 'functional' ) )? ) | 1021 | // InternalSolverLanguageParser.g:384:4: ( ( (lv_error_2_0= Error ) ) ( (lv_functional_3_0= Functional ) )? ) |
1117 | { | 1022 | { |
1118 | // InternalSolverLanguage.g:391:4: ( ( (lv_error_2_0= 'error' ) ) ( (lv_functional_3_0= 'functional' ) )? ) | 1023 | // InternalSolverLanguageParser.g:384:4: ( ( (lv_error_2_0= Error ) ) ( (lv_functional_3_0= Functional ) )? ) |
1119 | // InternalSolverLanguage.g:392:5: ( (lv_error_2_0= 'error' ) ) ( (lv_functional_3_0= 'functional' ) )? | 1024 | // InternalSolverLanguageParser.g:385:5: ( (lv_error_2_0= Error ) ) ( (lv_functional_3_0= Functional ) )? |
1120 | { | 1025 | { |
1121 | // InternalSolverLanguage.g:392:5: ( (lv_error_2_0= 'error' ) ) | 1026 | // InternalSolverLanguageParser.g:385:5: ( (lv_error_2_0= Error ) ) |
1122 | // InternalSolverLanguage.g:393:6: (lv_error_2_0= 'error' ) | 1027 | // InternalSolverLanguageParser.g:386:6: (lv_error_2_0= Error ) |
1123 | { | 1028 | { |
1124 | // InternalSolverLanguage.g:393:6: (lv_error_2_0= 'error' ) | 1029 | // InternalSolverLanguageParser.g:386:6: (lv_error_2_0= Error ) |
1125 | // InternalSolverLanguage.g:394:7: lv_error_2_0= 'error' | 1030 | // InternalSolverLanguageParser.g:387:7: lv_error_2_0= Error |
1126 | { | 1031 | { |
1127 | lv_error_2_0=(Token)match(input,19,FOLLOW_8); if (state.failed) return current; | 1032 | lv_error_2_0=(Token)match(input,Error,FOLLOW_9); |
1128 | if ( state.backtracking==0 ) { | ||
1129 | 1033 | ||
1130 | newLeafNode(lv_error_2_0, grammarAccess.getPredicateDefinitionAccess().getErrorErrorKeyword_0_1_0_0()); | 1034 | newLeafNode(lv_error_2_0, grammarAccess.getPredicateDefinitionAccess().getErrorErrorKeyword_0_1_0_0()); |
1131 | 1035 | ||
1132 | } | ||
1133 | if ( state.backtracking==0 ) { | ||
1134 | 1036 | ||
1135 | if (current==null) { | 1037 | if (current==null) { |
1136 | current = createModelElement(grammarAccess.getPredicateDefinitionRule()); | 1038 | current = createModelElement(grammarAccess.getPredicateDefinitionRule()); |
1137 | } | 1039 | } |
1138 | setWithLastConsumed(current, "error", true, "error"); | 1040 | setWithLastConsumed(current, "error", true, "error"); |
1139 | 1041 | ||
1140 | } | ||
1141 | 1042 | ||
1142 | } | 1043 | } |
1143 | 1044 | ||
1144 | 1045 | ||
1145 | } | 1046 | } |
1146 | 1047 | ||
1147 | // InternalSolverLanguage.g:406:5: ( (lv_functional_3_0= 'functional' ) )? | 1048 | // InternalSolverLanguageParser.g:399:5: ( (lv_functional_3_0= Functional ) )? |
1148 | int alt6=2; | 1049 | int alt6=2; |
1149 | int LA6_0 = input.LA(1); | 1050 | int LA6_0 = input.LA(1); |
1150 | 1051 | ||
1151 | if ( (LA6_0==18) ) { | 1052 | if ( (LA6_0==Functional) ) { |
1152 | alt6=1; | 1053 | alt6=1; |
1153 | } | 1054 | } |
1154 | switch (alt6) { | 1055 | switch (alt6) { |
1155 | case 1 : | 1056 | case 1 : |
1156 | // InternalSolverLanguage.g:407:6: (lv_functional_3_0= 'functional' ) | 1057 | // InternalSolverLanguageParser.g:400:6: (lv_functional_3_0= Functional ) |
1157 | { | 1058 | { |
1158 | // InternalSolverLanguage.g:407:6: (lv_functional_3_0= 'functional' ) | 1059 | // InternalSolverLanguageParser.g:400:6: (lv_functional_3_0= Functional ) |
1159 | // InternalSolverLanguage.g:408:7: lv_functional_3_0= 'functional' | 1060 | // InternalSolverLanguageParser.g:401:7: lv_functional_3_0= Functional |
1160 | { | 1061 | { |
1161 | lv_functional_3_0=(Token)match(input,18,FOLLOW_7); if (state.failed) return current; | 1062 | lv_functional_3_0=(Token)match(input,Functional,FOLLOW_8); |
1162 | if ( state.backtracking==0 ) { | ||
1163 | 1063 | ||
1164 | newLeafNode(lv_functional_3_0, grammarAccess.getPredicateDefinitionAccess().getFunctionalFunctionalKeyword_0_1_1_0()); | 1064 | newLeafNode(lv_functional_3_0, grammarAccess.getPredicateDefinitionAccess().getFunctionalFunctionalKeyword_0_1_1_0()); |
1165 | 1065 | ||
1166 | } | ||
1167 | if ( state.backtracking==0 ) { | ||
1168 | 1066 | ||
1169 | if (current==null) { | 1067 | if (current==null) { |
1170 | current = createModelElement(grammarAccess.getPredicateDefinitionRule()); | 1068 | current = createModelElement(grammarAccess.getPredicateDefinitionRule()); |
1171 | } | 1069 | } |
1172 | setWithLastConsumed(current, "functional", true, "functional"); | 1070 | setWithLastConsumed(current, "functional", true, "functional"); |
1173 | 1071 | ||
1174 | } | ||
1175 | 1072 | ||
1176 | } | 1073 | } |
1177 | 1074 | ||
@@ -1190,76 +1087,66 @@ public class InternalSolverLanguageParser extends AbstractInternalAntlrParser { | |||
1190 | 1087 | ||
1191 | } | 1088 | } |
1192 | 1089 | ||
1193 | // InternalSolverLanguage.g:422:3: ( (lv_head_4_0= ruleCall ) ) | 1090 | // InternalSolverLanguageParser.g:415:3: ( (lv_head_4_0= ruleCall ) ) |
1194 | // InternalSolverLanguage.g:423:4: (lv_head_4_0= ruleCall ) | 1091 | // InternalSolverLanguageParser.g:416:4: (lv_head_4_0= ruleCall ) |
1195 | { | 1092 | { |
1196 | // InternalSolverLanguage.g:423:4: (lv_head_4_0= ruleCall ) | 1093 | // InternalSolverLanguageParser.g:416:4: (lv_head_4_0= ruleCall ) |
1197 | // InternalSolverLanguage.g:424:5: lv_head_4_0= ruleCall | 1094 | // InternalSolverLanguageParser.g:417:5: lv_head_4_0= ruleCall |
1198 | { | 1095 | { |
1199 | if ( state.backtracking==0 ) { | ||
1200 | 1096 | ||
1201 | newCompositeNode(grammarAccess.getPredicateDefinitionAccess().getHeadCallParserRuleCall_1_0()); | 1097 | newCompositeNode(grammarAccess.getPredicateDefinitionAccess().getHeadCallParserRuleCall_1_0()); |
1202 | 1098 | ||
1203 | } | 1099 | pushFollow(FOLLOW_10); |
1204 | pushFollow(FOLLOW_9); | ||
1205 | lv_head_4_0=ruleCall(); | 1100 | lv_head_4_0=ruleCall(); |
1206 | 1101 | ||
1207 | state._fsp--; | 1102 | state._fsp--; |
1208 | if (state.failed) return current; | ||
1209 | if ( state.backtracking==0 ) { | ||
1210 | 1103 | ||
1211 | if (current==null) { | 1104 | |
1212 | current = createModelElementForParent(grammarAccess.getPredicateDefinitionRule()); | 1105 | if (current==null) { |
1213 | } | 1106 | current = createModelElementForParent(grammarAccess.getPredicateDefinitionRule()); |
1214 | set( | 1107 | } |
1215 | current, | 1108 | set( |
1216 | "head", | 1109 | current, |
1217 | lv_head_4_0, | 1110 | "head", |
1218 | "org.eclipse.viatra.solver.language.SolverLanguage.Call"); | 1111 | lv_head_4_0, |
1219 | afterParserOrEnumRuleCall(); | 1112 | "org.eclipse.viatra.solver.language.SolverLanguage.Call"); |
1220 | 1113 | afterParserOrEnumRuleCall(); | |
1221 | } | 1114 | |
1222 | 1115 | ||
1223 | } | 1116 | } |
1224 | 1117 | ||
1225 | 1118 | ||
1226 | } | 1119 | } |
1227 | 1120 | ||
1228 | otherlv_5=(Token)match(input,16,FOLLOW_6); if (state.failed) return current; | 1121 | otherlv_5=(Token)match(input,ColonHyphenMinus,FOLLOW_6); |
1229 | if ( state.backtracking==0 ) { | ||
1230 | 1122 | ||
1231 | newLeafNode(otherlv_5, grammarAccess.getPredicateDefinitionAccess().getColonHyphenMinusKeyword_2()); | 1123 | newLeafNode(otherlv_5, grammarAccess.getPredicateDefinitionAccess().getColonHyphenMinusKeyword_2()); |
1232 | 1124 | ||
1233 | } | 1125 | // InternalSolverLanguageParser.g:438:3: ( (lv_body_6_0= ruleExpression ) ) |
1234 | // InternalSolverLanguage.g:445:3: ( (lv_body_6_0= ruleExpression ) ) | 1126 | // InternalSolverLanguageParser.g:439:4: (lv_body_6_0= ruleExpression ) |
1235 | // InternalSolverLanguage.g:446:4: (lv_body_6_0= ruleExpression ) | ||
1236 | { | 1127 | { |
1237 | // InternalSolverLanguage.g:446:4: (lv_body_6_0= ruleExpression ) | 1128 | // InternalSolverLanguageParser.g:439:4: (lv_body_6_0= ruleExpression ) |
1238 | // InternalSolverLanguage.g:447:5: lv_body_6_0= ruleExpression | 1129 | // InternalSolverLanguageParser.g:440:5: lv_body_6_0= ruleExpression |
1239 | { | 1130 | { |
1240 | if ( state.backtracking==0 ) { | ||
1241 | 1131 | ||
1242 | newCompositeNode(grammarAccess.getPredicateDefinitionAccess().getBodyExpressionParserRuleCall_3_0()); | 1132 | newCompositeNode(grammarAccess.getPredicateDefinitionAccess().getBodyExpressionParserRuleCall_3_0()); |
1243 | 1133 | ||
1244 | } | ||
1245 | pushFollow(FOLLOW_2); | 1134 | pushFollow(FOLLOW_2); |
1246 | lv_body_6_0=ruleExpression(); | 1135 | lv_body_6_0=ruleExpression(); |
1247 | 1136 | ||
1248 | state._fsp--; | 1137 | state._fsp--; |
1249 | if (state.failed) return current; | ||
1250 | if ( state.backtracking==0 ) { | ||
1251 | 1138 | ||
1252 | if (current==null) { | 1139 | |
1253 | current = createModelElementForParent(grammarAccess.getPredicateDefinitionRule()); | 1140 | if (current==null) { |
1254 | } | 1141 | current = createModelElementForParent(grammarAccess.getPredicateDefinitionRule()); |
1255 | set( | 1142 | } |
1256 | current, | 1143 | set( |
1257 | "body", | 1144 | current, |
1258 | lv_body_6_0, | 1145 | "body", |
1259 | "org.eclipse.viatra.solver.language.SolverLanguage.Expression"); | 1146 | lv_body_6_0, |
1260 | afterParserOrEnumRuleCall(); | 1147 | "org.eclipse.viatra.solver.language.SolverLanguage.Expression"); |
1261 | 1148 | afterParserOrEnumRuleCall(); | |
1262 | } | 1149 | |
1263 | 1150 | ||
1264 | } | 1151 | } |
1265 | 1152 | ||
@@ -1272,11 +1159,9 @@ public class InternalSolverLanguageParser extends AbstractInternalAntlrParser { | |||
1272 | 1159 | ||
1273 | } | 1160 | } |
1274 | 1161 | ||
1275 | if ( state.backtracking==0 ) { | ||
1276 | 1162 | ||
1277 | leaveRule(); | 1163 | leaveRule(); |
1278 | 1164 | ||
1279 | } | ||
1280 | } | 1165 | } |
1281 | 1166 | ||
1282 | catch (RecognitionException re) { | 1167 | catch (RecognitionException re) { |
@@ -1291,7 +1176,7 @@ public class InternalSolverLanguageParser extends AbstractInternalAntlrParser { | |||
1291 | 1176 | ||
1292 | 1177 | ||
1293 | // $ANTLR start "entryRuleUnnamedErrorPrediateDefinition" | 1178 | // $ANTLR start "entryRuleUnnamedErrorPrediateDefinition" |
1294 | // InternalSolverLanguage.g:468:1: entryRuleUnnamedErrorPrediateDefinition returns [EObject current=null] : iv_ruleUnnamedErrorPrediateDefinition= ruleUnnamedErrorPrediateDefinition EOF ; | 1179 | // InternalSolverLanguageParser.g:461:1: entryRuleUnnamedErrorPrediateDefinition returns [EObject current=null] : iv_ruleUnnamedErrorPrediateDefinition= ruleUnnamedErrorPrediateDefinition EOF ; |
1295 | public final EObject entryRuleUnnamedErrorPrediateDefinition() throws RecognitionException { | 1180 | public final EObject entryRuleUnnamedErrorPrediateDefinition() throws RecognitionException { |
1296 | EObject current = null; | 1181 | EObject current = null; |
1297 | 1182 | ||
@@ -1299,21 +1184,17 @@ public class InternalSolverLanguageParser extends AbstractInternalAntlrParser { | |||
1299 | 1184 | ||
1300 | 1185 | ||
1301 | try { | 1186 | try { |
1302 | // InternalSolverLanguage.g:468:71: (iv_ruleUnnamedErrorPrediateDefinition= ruleUnnamedErrorPrediateDefinition EOF ) | 1187 | // InternalSolverLanguageParser.g:461:71: (iv_ruleUnnamedErrorPrediateDefinition= ruleUnnamedErrorPrediateDefinition EOF ) |
1303 | // InternalSolverLanguage.g:469:2: iv_ruleUnnamedErrorPrediateDefinition= ruleUnnamedErrorPrediateDefinition EOF | 1188 | // InternalSolverLanguageParser.g:462:2: iv_ruleUnnamedErrorPrediateDefinition= ruleUnnamedErrorPrediateDefinition EOF |
1304 | { | 1189 | { |
1305 | if ( state.backtracking==0 ) { | 1190 | newCompositeNode(grammarAccess.getUnnamedErrorPrediateDefinitionRule()); |
1306 | newCompositeNode(grammarAccess.getUnnamedErrorPrediateDefinitionRule()); | ||
1307 | } | ||
1308 | pushFollow(FOLLOW_1); | 1191 | pushFollow(FOLLOW_1); |
1309 | iv_ruleUnnamedErrorPrediateDefinition=ruleUnnamedErrorPrediateDefinition(); | 1192 | iv_ruleUnnamedErrorPrediateDefinition=ruleUnnamedErrorPrediateDefinition(); |
1310 | 1193 | ||
1311 | state._fsp--; | 1194 | state._fsp--; |
1312 | if (state.failed) return current; | 1195 | |
1313 | if ( state.backtracking==0 ) { | 1196 | current =iv_ruleUnnamedErrorPrediateDefinition; |
1314 | current =iv_ruleUnnamedErrorPrediateDefinition; | 1197 | match(input,EOF,FOLLOW_2); |
1315 | } | ||
1316 | match(input,EOF,FOLLOW_2); if (state.failed) return current; | ||
1317 | 1198 | ||
1318 | } | 1199 | } |
1319 | 1200 | ||
@@ -1331,7 +1212,7 @@ public class InternalSolverLanguageParser extends AbstractInternalAntlrParser { | |||
1331 | 1212 | ||
1332 | 1213 | ||
1333 | // $ANTLR start "ruleUnnamedErrorPrediateDefinition" | 1214 | // $ANTLR start "ruleUnnamedErrorPrediateDefinition" |
1334 | // InternalSolverLanguage.g:475:1: ruleUnnamedErrorPrediateDefinition returns [EObject current=null] : (otherlv_0= 'error' ( (lv_argumentList_1_0= ruleArgumentList ) ) otherlv_2= ':-' ( (lv_body_3_0= ruleExpression ) ) ) ; | 1215 | // InternalSolverLanguageParser.g:468:1: ruleUnnamedErrorPrediateDefinition returns [EObject current=null] : (otherlv_0= Error ( (lv_argumentList_1_0= ruleArgumentList ) ) otherlv_2= ColonHyphenMinus ( (lv_body_3_0= ruleExpression ) ) ) ; |
1335 | public final EObject ruleUnnamedErrorPrediateDefinition() throws RecognitionException { | 1216 | public final EObject ruleUnnamedErrorPrediateDefinition() throws RecognitionException { |
1336 | EObject current = null; | 1217 | EObject current = null; |
1337 | 1218 | ||
@@ -1346,88 +1227,76 @@ public class InternalSolverLanguageParser extends AbstractInternalAntlrParser { | |||
1346 | enterRule(); | 1227 | enterRule(); |
1347 | 1228 | ||
1348 | try { | 1229 | try { |
1349 | // InternalSolverLanguage.g:481:2: ( (otherlv_0= 'error' ( (lv_argumentList_1_0= ruleArgumentList ) ) otherlv_2= ':-' ( (lv_body_3_0= ruleExpression ) ) ) ) | 1230 | // InternalSolverLanguageParser.g:474:2: ( (otherlv_0= Error ( (lv_argumentList_1_0= ruleArgumentList ) ) otherlv_2= ColonHyphenMinus ( (lv_body_3_0= ruleExpression ) ) ) ) |
1350 | // InternalSolverLanguage.g:482:2: (otherlv_0= 'error' ( (lv_argumentList_1_0= ruleArgumentList ) ) otherlv_2= ':-' ( (lv_body_3_0= ruleExpression ) ) ) | 1231 | // InternalSolverLanguageParser.g:475:2: (otherlv_0= Error ( (lv_argumentList_1_0= ruleArgumentList ) ) otherlv_2= ColonHyphenMinus ( (lv_body_3_0= ruleExpression ) ) ) |
1351 | { | 1232 | { |
1352 | // InternalSolverLanguage.g:482:2: (otherlv_0= 'error' ( (lv_argumentList_1_0= ruleArgumentList ) ) otherlv_2= ':-' ( (lv_body_3_0= ruleExpression ) ) ) | 1233 | // InternalSolverLanguageParser.g:475:2: (otherlv_0= Error ( (lv_argumentList_1_0= ruleArgumentList ) ) otherlv_2= ColonHyphenMinus ( (lv_body_3_0= ruleExpression ) ) ) |
1353 | // InternalSolverLanguage.g:483:3: otherlv_0= 'error' ( (lv_argumentList_1_0= ruleArgumentList ) ) otherlv_2= ':-' ( (lv_body_3_0= ruleExpression ) ) | 1234 | // InternalSolverLanguageParser.g:476:3: otherlv_0= Error ( (lv_argumentList_1_0= ruleArgumentList ) ) otherlv_2= ColonHyphenMinus ( (lv_body_3_0= ruleExpression ) ) |
1354 | { | 1235 | { |
1355 | otherlv_0=(Token)match(input,19,FOLLOW_10); if (state.failed) return current; | 1236 | otherlv_0=(Token)match(input,Error,FOLLOW_11); |
1356 | if ( state.backtracking==0 ) { | ||
1357 | 1237 | ||
1358 | newLeafNode(otherlv_0, grammarAccess.getUnnamedErrorPrediateDefinitionAccess().getErrorKeyword_0()); | 1238 | newLeafNode(otherlv_0, grammarAccess.getUnnamedErrorPrediateDefinitionAccess().getErrorKeyword_0()); |
1359 | 1239 | ||
1360 | } | 1240 | // InternalSolverLanguageParser.g:480:3: ( (lv_argumentList_1_0= ruleArgumentList ) ) |
1361 | // InternalSolverLanguage.g:487:3: ( (lv_argumentList_1_0= ruleArgumentList ) ) | 1241 | // InternalSolverLanguageParser.g:481:4: (lv_argumentList_1_0= ruleArgumentList ) |
1362 | // InternalSolverLanguage.g:488:4: (lv_argumentList_1_0= ruleArgumentList ) | ||
1363 | { | 1242 | { |
1364 | // InternalSolverLanguage.g:488:4: (lv_argumentList_1_0= ruleArgumentList ) | 1243 | // InternalSolverLanguageParser.g:481:4: (lv_argumentList_1_0= ruleArgumentList ) |
1365 | // InternalSolverLanguage.g:489:5: lv_argumentList_1_0= ruleArgumentList | 1244 | // InternalSolverLanguageParser.g:482:5: lv_argumentList_1_0= ruleArgumentList |
1366 | { | 1245 | { |
1367 | if ( state.backtracking==0 ) { | ||
1368 | 1246 | ||
1369 | newCompositeNode(grammarAccess.getUnnamedErrorPrediateDefinitionAccess().getArgumentListArgumentListParserRuleCall_1_0()); | 1247 | newCompositeNode(grammarAccess.getUnnamedErrorPrediateDefinitionAccess().getArgumentListArgumentListParserRuleCall_1_0()); |
1370 | 1248 | ||
1371 | } | 1249 | pushFollow(FOLLOW_10); |
1372 | pushFollow(FOLLOW_9); | ||
1373 | lv_argumentList_1_0=ruleArgumentList(); | 1250 | lv_argumentList_1_0=ruleArgumentList(); |
1374 | 1251 | ||
1375 | state._fsp--; | 1252 | state._fsp--; |
1376 | if (state.failed) return current; | ||
1377 | if ( state.backtracking==0 ) { | ||
1378 | 1253 | ||
1379 | if (current==null) { | 1254 | |
1380 | current = createModelElementForParent(grammarAccess.getUnnamedErrorPrediateDefinitionRule()); | 1255 | if (current==null) { |
1381 | } | 1256 | current = createModelElementForParent(grammarAccess.getUnnamedErrorPrediateDefinitionRule()); |
1382 | set( | 1257 | } |
1383 | current, | 1258 | set( |
1384 | "argumentList", | 1259 | current, |
1385 | lv_argumentList_1_0, | 1260 | "argumentList", |
1386 | "org.eclipse.viatra.solver.language.SolverLanguage.ArgumentList"); | 1261 | lv_argumentList_1_0, |
1387 | afterParserOrEnumRuleCall(); | 1262 | "org.eclipse.viatra.solver.language.SolverLanguage.ArgumentList"); |
1388 | 1263 | afterParserOrEnumRuleCall(); | |
1389 | } | 1264 | |
1390 | 1265 | ||
1391 | } | 1266 | } |
1392 | 1267 | ||
1393 | 1268 | ||
1394 | } | 1269 | } |
1395 | 1270 | ||
1396 | otherlv_2=(Token)match(input,16,FOLLOW_6); if (state.failed) return current; | 1271 | otherlv_2=(Token)match(input,ColonHyphenMinus,FOLLOW_6); |
1397 | if ( state.backtracking==0 ) { | ||
1398 | 1272 | ||
1399 | newLeafNode(otherlv_2, grammarAccess.getUnnamedErrorPrediateDefinitionAccess().getColonHyphenMinusKeyword_2()); | 1273 | newLeafNode(otherlv_2, grammarAccess.getUnnamedErrorPrediateDefinitionAccess().getColonHyphenMinusKeyword_2()); |
1400 | 1274 | ||
1401 | } | 1275 | // InternalSolverLanguageParser.g:503:3: ( (lv_body_3_0= ruleExpression ) ) |
1402 | // InternalSolverLanguage.g:510:3: ( (lv_body_3_0= ruleExpression ) ) | 1276 | // InternalSolverLanguageParser.g:504:4: (lv_body_3_0= ruleExpression ) |
1403 | // InternalSolverLanguage.g:511:4: (lv_body_3_0= ruleExpression ) | ||
1404 | { | 1277 | { |
1405 | // InternalSolverLanguage.g:511:4: (lv_body_3_0= ruleExpression ) | 1278 | // InternalSolverLanguageParser.g:504:4: (lv_body_3_0= ruleExpression ) |
1406 | // InternalSolverLanguage.g:512:5: lv_body_3_0= ruleExpression | 1279 | // InternalSolverLanguageParser.g:505:5: lv_body_3_0= ruleExpression |
1407 | { | 1280 | { |
1408 | if ( state.backtracking==0 ) { | ||
1409 | 1281 | ||
1410 | newCompositeNode(grammarAccess.getUnnamedErrorPrediateDefinitionAccess().getBodyExpressionParserRuleCall_3_0()); | 1282 | newCompositeNode(grammarAccess.getUnnamedErrorPrediateDefinitionAccess().getBodyExpressionParserRuleCall_3_0()); |
1411 | 1283 | ||
1412 | } | ||
1413 | pushFollow(FOLLOW_2); | 1284 | pushFollow(FOLLOW_2); |
1414 | lv_body_3_0=ruleExpression(); | 1285 | lv_body_3_0=ruleExpression(); |
1415 | 1286 | ||
1416 | state._fsp--; | 1287 | state._fsp--; |
1417 | if (state.failed) return current; | ||
1418 | if ( state.backtracking==0 ) { | ||
1419 | 1288 | ||
1420 | if (current==null) { | 1289 | |
1421 | current = createModelElementForParent(grammarAccess.getUnnamedErrorPrediateDefinitionRule()); | 1290 | if (current==null) { |
1422 | } | 1291 | current = createModelElementForParent(grammarAccess.getUnnamedErrorPrediateDefinitionRule()); |
1423 | set( | 1292 | } |
1424 | current, | 1293 | set( |
1425 | "body", | 1294 | current, |
1426 | lv_body_3_0, | 1295 | "body", |
1427 | "org.eclipse.viatra.solver.language.SolverLanguage.Expression"); | 1296 | lv_body_3_0, |
1428 | afterParserOrEnumRuleCall(); | 1297 | "org.eclipse.viatra.solver.language.SolverLanguage.Expression"); |
1429 | 1298 | afterParserOrEnumRuleCall(); | |
1430 | } | 1299 | |
1431 | 1300 | ||
1432 | } | 1301 | } |
1433 | 1302 | ||
@@ -1440,11 +1309,9 @@ public class InternalSolverLanguageParser extends AbstractInternalAntlrParser { | |||
1440 | 1309 | ||
1441 | } | 1310 | } |
1442 | 1311 | ||
1443 | if ( state.backtracking==0 ) { | ||
1444 | 1312 | ||
1445 | leaveRule(); | 1313 | leaveRule(); |
1446 | 1314 | ||
1447 | } | ||
1448 | } | 1315 | } |
1449 | 1316 | ||
1450 | catch (RecognitionException re) { | 1317 | catch (RecognitionException re) { |
@@ -1459,7 +1326,7 @@ public class InternalSolverLanguageParser extends AbstractInternalAntlrParser { | |||
1459 | 1326 | ||
1460 | 1327 | ||
1461 | // $ANTLR start "entryRuleDefaultDefinition" | 1328 | // $ANTLR start "entryRuleDefaultDefinition" |
1462 | // InternalSolverLanguage.g:533:1: entryRuleDefaultDefinition returns [EObject current=null] : iv_ruleDefaultDefinition= ruleDefaultDefinition EOF ; | 1329 | // InternalSolverLanguageParser.g:526:1: entryRuleDefaultDefinition returns [EObject current=null] : iv_ruleDefaultDefinition= ruleDefaultDefinition EOF ; |
1463 | public final EObject entryRuleDefaultDefinition() throws RecognitionException { | 1330 | public final EObject entryRuleDefaultDefinition() throws RecognitionException { |
1464 | EObject current = null; | 1331 | EObject current = null; |
1465 | 1332 | ||
@@ -1467,21 +1334,17 @@ public class InternalSolverLanguageParser extends AbstractInternalAntlrParser { | |||
1467 | 1334 | ||
1468 | 1335 | ||
1469 | try { | 1336 | try { |
1470 | // InternalSolverLanguage.g:533:58: (iv_ruleDefaultDefinition= ruleDefaultDefinition EOF ) | 1337 | // InternalSolverLanguageParser.g:526:58: (iv_ruleDefaultDefinition= ruleDefaultDefinition EOF ) |
1471 | // InternalSolverLanguage.g:534:2: iv_ruleDefaultDefinition= ruleDefaultDefinition EOF | 1338 | // InternalSolverLanguageParser.g:527:2: iv_ruleDefaultDefinition= ruleDefaultDefinition EOF |
1472 | { | 1339 | { |
1473 | if ( state.backtracking==0 ) { | 1340 | newCompositeNode(grammarAccess.getDefaultDefinitionRule()); |
1474 | newCompositeNode(grammarAccess.getDefaultDefinitionRule()); | ||
1475 | } | ||
1476 | pushFollow(FOLLOW_1); | 1341 | pushFollow(FOLLOW_1); |
1477 | iv_ruleDefaultDefinition=ruleDefaultDefinition(); | 1342 | iv_ruleDefaultDefinition=ruleDefaultDefinition(); |
1478 | 1343 | ||
1479 | state._fsp--; | 1344 | state._fsp--; |
1480 | if (state.failed) return current; | 1345 | |
1481 | if ( state.backtracking==0 ) { | 1346 | current =iv_ruleDefaultDefinition; |
1482 | current =iv_ruleDefaultDefinition; | 1347 | match(input,EOF,FOLLOW_2); |
1483 | } | ||
1484 | match(input,EOF,FOLLOW_2); if (state.failed) return current; | ||
1485 | 1348 | ||
1486 | } | 1349 | } |
1487 | 1350 | ||
@@ -1499,7 +1362,7 @@ public class InternalSolverLanguageParser extends AbstractInternalAntlrParser { | |||
1499 | 1362 | ||
1500 | 1363 | ||
1501 | // $ANTLR start "ruleDefaultDefinition" | 1364 | // $ANTLR start "ruleDefaultDefinition" |
1502 | // InternalSolverLanguage.g:540:1: ruleDefaultDefinition returns [EObject current=null] : (otherlv_0= 'default' ( (lv_head_1_0= ruleCall ) ) otherlv_2= ':' ( (lv_range_3_0= ruleExpression ) ) ) ; | 1365 | // InternalSolverLanguageParser.g:533:1: ruleDefaultDefinition returns [EObject current=null] : (otherlv_0= Default ( (lv_head_1_0= ruleCall ) ) otherlv_2= Colon ( (lv_range_3_0= ruleExpression ) ) ) ; |
1503 | public final EObject ruleDefaultDefinition() throws RecognitionException { | 1366 | public final EObject ruleDefaultDefinition() throws RecognitionException { |
1504 | EObject current = null; | 1367 | EObject current = null; |
1505 | 1368 | ||
@@ -1514,88 +1377,76 @@ public class InternalSolverLanguageParser extends AbstractInternalAntlrParser { | |||
1514 | enterRule(); | 1377 | enterRule(); |
1515 | 1378 | ||
1516 | try { | 1379 | try { |
1517 | // InternalSolverLanguage.g:546:2: ( (otherlv_0= 'default' ( (lv_head_1_0= ruleCall ) ) otherlv_2= ':' ( (lv_range_3_0= ruleExpression ) ) ) ) | 1380 | // InternalSolverLanguageParser.g:539:2: ( (otherlv_0= Default ( (lv_head_1_0= ruleCall ) ) otherlv_2= Colon ( (lv_range_3_0= ruleExpression ) ) ) ) |
1518 | // InternalSolverLanguage.g:547:2: (otherlv_0= 'default' ( (lv_head_1_0= ruleCall ) ) otherlv_2= ':' ( (lv_range_3_0= ruleExpression ) ) ) | 1381 | // InternalSolverLanguageParser.g:540:2: (otherlv_0= Default ( (lv_head_1_0= ruleCall ) ) otherlv_2= Colon ( (lv_range_3_0= ruleExpression ) ) ) |
1519 | { | 1382 | { |
1520 | // InternalSolverLanguage.g:547:2: (otherlv_0= 'default' ( (lv_head_1_0= ruleCall ) ) otherlv_2= ':' ( (lv_range_3_0= ruleExpression ) ) ) | 1383 | // InternalSolverLanguageParser.g:540:2: (otherlv_0= Default ( (lv_head_1_0= ruleCall ) ) otherlv_2= Colon ( (lv_range_3_0= ruleExpression ) ) ) |
1521 | // InternalSolverLanguage.g:548:3: otherlv_0= 'default' ( (lv_head_1_0= ruleCall ) ) otherlv_2= ':' ( (lv_range_3_0= ruleExpression ) ) | 1384 | // InternalSolverLanguageParser.g:541:3: otherlv_0= Default ( (lv_head_1_0= ruleCall ) ) otherlv_2= Colon ( (lv_range_3_0= ruleExpression ) ) |
1522 | { | 1385 | { |
1523 | otherlv_0=(Token)match(input,20,FOLLOW_7); if (state.failed) return current; | 1386 | otherlv_0=(Token)match(input,Default,FOLLOW_8); |
1524 | if ( state.backtracking==0 ) { | ||
1525 | 1387 | ||
1526 | newLeafNode(otherlv_0, grammarAccess.getDefaultDefinitionAccess().getDefaultKeyword_0()); | 1388 | newLeafNode(otherlv_0, grammarAccess.getDefaultDefinitionAccess().getDefaultKeyword_0()); |
1527 | 1389 | ||
1528 | } | 1390 | // InternalSolverLanguageParser.g:545:3: ( (lv_head_1_0= ruleCall ) ) |
1529 | // InternalSolverLanguage.g:552:3: ( (lv_head_1_0= ruleCall ) ) | 1391 | // InternalSolverLanguageParser.g:546:4: (lv_head_1_0= ruleCall ) |
1530 | // InternalSolverLanguage.g:553:4: (lv_head_1_0= ruleCall ) | ||
1531 | { | 1392 | { |
1532 | // InternalSolverLanguage.g:553:4: (lv_head_1_0= ruleCall ) | 1393 | // InternalSolverLanguageParser.g:546:4: (lv_head_1_0= ruleCall ) |
1533 | // InternalSolverLanguage.g:554:5: lv_head_1_0= ruleCall | 1394 | // InternalSolverLanguageParser.g:547:5: lv_head_1_0= ruleCall |
1534 | { | 1395 | { |
1535 | if ( state.backtracking==0 ) { | ||
1536 | 1396 | ||
1537 | newCompositeNode(grammarAccess.getDefaultDefinitionAccess().getHeadCallParserRuleCall_1_0()); | 1397 | newCompositeNode(grammarAccess.getDefaultDefinitionAccess().getHeadCallParserRuleCall_1_0()); |
1538 | 1398 | ||
1539 | } | 1399 | pushFollow(FOLLOW_12); |
1540 | pushFollow(FOLLOW_11); | ||
1541 | lv_head_1_0=ruleCall(); | 1400 | lv_head_1_0=ruleCall(); |
1542 | 1401 | ||
1543 | state._fsp--; | 1402 | state._fsp--; |
1544 | if (state.failed) return current; | ||
1545 | if ( state.backtracking==0 ) { | ||
1546 | 1403 | ||
1547 | if (current==null) { | 1404 | |
1548 | current = createModelElementForParent(grammarAccess.getDefaultDefinitionRule()); | 1405 | if (current==null) { |
1549 | } | 1406 | current = createModelElementForParent(grammarAccess.getDefaultDefinitionRule()); |
1550 | set( | 1407 | } |
1551 | current, | 1408 | set( |
1552 | "head", | 1409 | current, |
1553 | lv_head_1_0, | 1410 | "head", |
1554 | "org.eclipse.viatra.solver.language.SolverLanguage.Call"); | 1411 | lv_head_1_0, |
1555 | afterParserOrEnumRuleCall(); | 1412 | "org.eclipse.viatra.solver.language.SolverLanguage.Call"); |
1556 | 1413 | afterParserOrEnumRuleCall(); | |
1557 | } | 1414 | |
1558 | 1415 | ||
1559 | } | 1416 | } |
1560 | 1417 | ||
1561 | 1418 | ||
1562 | } | 1419 | } |
1563 | 1420 | ||
1564 | otherlv_2=(Token)match(input,15,FOLLOW_6); if (state.failed) return current; | 1421 | otherlv_2=(Token)match(input,Colon,FOLLOW_6); |
1565 | if ( state.backtracking==0 ) { | ||
1566 | 1422 | ||
1567 | newLeafNode(otherlv_2, grammarAccess.getDefaultDefinitionAccess().getColonKeyword_2()); | 1423 | newLeafNode(otherlv_2, grammarAccess.getDefaultDefinitionAccess().getColonKeyword_2()); |
1568 | 1424 | ||
1569 | } | 1425 | // InternalSolverLanguageParser.g:568:3: ( (lv_range_3_0= ruleExpression ) ) |
1570 | // InternalSolverLanguage.g:575:3: ( (lv_range_3_0= ruleExpression ) ) | 1426 | // InternalSolverLanguageParser.g:569:4: (lv_range_3_0= ruleExpression ) |
1571 | // InternalSolverLanguage.g:576:4: (lv_range_3_0= ruleExpression ) | ||
1572 | { | 1427 | { |
1573 | // InternalSolverLanguage.g:576:4: (lv_range_3_0= ruleExpression ) | 1428 | // InternalSolverLanguageParser.g:569:4: (lv_range_3_0= ruleExpression ) |
1574 | // InternalSolverLanguage.g:577:5: lv_range_3_0= ruleExpression | 1429 | // InternalSolverLanguageParser.g:570:5: lv_range_3_0= ruleExpression |
1575 | { | 1430 | { |
1576 | if ( state.backtracking==0 ) { | ||
1577 | 1431 | ||
1578 | newCompositeNode(grammarAccess.getDefaultDefinitionAccess().getRangeExpressionParserRuleCall_3_0()); | 1432 | newCompositeNode(grammarAccess.getDefaultDefinitionAccess().getRangeExpressionParserRuleCall_3_0()); |
1579 | 1433 | ||
1580 | } | ||
1581 | pushFollow(FOLLOW_2); | 1434 | pushFollow(FOLLOW_2); |
1582 | lv_range_3_0=ruleExpression(); | 1435 | lv_range_3_0=ruleExpression(); |
1583 | 1436 | ||
1584 | state._fsp--; | 1437 | state._fsp--; |
1585 | if (state.failed) return current; | ||
1586 | if ( state.backtracking==0 ) { | ||
1587 | 1438 | ||
1588 | if (current==null) { | 1439 | |
1589 | current = createModelElementForParent(grammarAccess.getDefaultDefinitionRule()); | 1440 | if (current==null) { |
1590 | } | 1441 | current = createModelElementForParent(grammarAccess.getDefaultDefinitionRule()); |
1591 | set( | 1442 | } |
1592 | current, | 1443 | set( |
1593 | "range", | 1444 | current, |
1594 | lv_range_3_0, | 1445 | "range", |
1595 | "org.eclipse.viatra.solver.language.SolverLanguage.Expression"); | 1446 | lv_range_3_0, |
1596 | afterParserOrEnumRuleCall(); | 1447 | "org.eclipse.viatra.solver.language.SolverLanguage.Expression"); |
1597 | 1448 | afterParserOrEnumRuleCall(); | |
1598 | } | 1449 | |
1599 | 1450 | ||
1600 | } | 1451 | } |
1601 | 1452 | ||
@@ -1608,11 +1459,9 @@ public class InternalSolverLanguageParser extends AbstractInternalAntlrParser { | |||
1608 | 1459 | ||
1609 | } | 1460 | } |
1610 | 1461 | ||
1611 | if ( state.backtracking==0 ) { | ||
1612 | 1462 | ||
1613 | leaveRule(); | 1463 | leaveRule(); |
1614 | 1464 | ||
1615 | } | ||
1616 | } | 1465 | } |
1617 | 1466 | ||
1618 | catch (RecognitionException re) { | 1467 | catch (RecognitionException re) { |
@@ -1627,7 +1476,7 @@ public class InternalSolverLanguageParser extends AbstractInternalAntlrParser { | |||
1627 | 1476 | ||
1628 | 1477 | ||
1629 | // $ANTLR start "entryRuleExternPredicateDefinition" | 1478 | // $ANTLR start "entryRuleExternPredicateDefinition" |
1630 | // InternalSolverLanguage.g:598:1: entryRuleExternPredicateDefinition returns [EObject current=null] : iv_ruleExternPredicateDefinition= ruleExternPredicateDefinition EOF ; | 1479 | // InternalSolverLanguageParser.g:591:1: entryRuleExternPredicateDefinition returns [EObject current=null] : iv_ruleExternPredicateDefinition= ruleExternPredicateDefinition EOF ; |
1631 | public final EObject entryRuleExternPredicateDefinition() throws RecognitionException { | 1480 | public final EObject entryRuleExternPredicateDefinition() throws RecognitionException { |
1632 | EObject current = null; | 1481 | EObject current = null; |
1633 | 1482 | ||
@@ -1635,21 +1484,17 @@ public class InternalSolverLanguageParser extends AbstractInternalAntlrParser { | |||
1635 | 1484 | ||
1636 | 1485 | ||
1637 | try { | 1486 | try { |
1638 | // InternalSolverLanguage.g:598:66: (iv_ruleExternPredicateDefinition= ruleExternPredicateDefinition EOF ) | 1487 | // InternalSolverLanguageParser.g:591:66: (iv_ruleExternPredicateDefinition= ruleExternPredicateDefinition EOF ) |
1639 | // InternalSolverLanguage.g:599:2: iv_ruleExternPredicateDefinition= ruleExternPredicateDefinition EOF | 1488 | // InternalSolverLanguageParser.g:592:2: iv_ruleExternPredicateDefinition= ruleExternPredicateDefinition EOF |
1640 | { | 1489 | { |
1641 | if ( state.backtracking==0 ) { | 1490 | newCompositeNode(grammarAccess.getExternPredicateDefinitionRule()); |
1642 | newCompositeNode(grammarAccess.getExternPredicateDefinitionRule()); | ||
1643 | } | ||
1644 | pushFollow(FOLLOW_1); | 1491 | pushFollow(FOLLOW_1); |
1645 | iv_ruleExternPredicateDefinition=ruleExternPredicateDefinition(); | 1492 | iv_ruleExternPredicateDefinition=ruleExternPredicateDefinition(); |
1646 | 1493 | ||
1647 | state._fsp--; | 1494 | state._fsp--; |
1648 | if (state.failed) return current; | 1495 | |
1649 | if ( state.backtracking==0 ) { | 1496 | current =iv_ruleExternPredicateDefinition; |
1650 | current =iv_ruleExternPredicateDefinition; | 1497 | match(input,EOF,FOLLOW_2); |
1651 | } | ||
1652 | match(input,EOF,FOLLOW_2); if (state.failed) return current; | ||
1653 | 1498 | ||
1654 | } | 1499 | } |
1655 | 1500 | ||
@@ -1667,12 +1512,11 @@ public class InternalSolverLanguageParser extends AbstractInternalAntlrParser { | |||
1667 | 1512 | ||
1668 | 1513 | ||
1669 | // $ANTLR start "ruleExternPredicateDefinition" | 1514 | // $ANTLR start "ruleExternPredicateDefinition" |
1670 | // InternalSolverLanguage.g:605:1: ruleExternPredicateDefinition returns [EObject current=null] : (otherlv_0= 'extern' ( (lv_head_1_0= ruleCall ) ) otherlv_2= '.' ) ; | 1515 | // InternalSolverLanguageParser.g:598:1: ruleExternPredicateDefinition returns [EObject current=null] : (otherlv_0= Extern ( (lv_head_1_0= ruleCall ) ) ) ; |
1671 | public final EObject ruleExternPredicateDefinition() throws RecognitionException { | 1516 | public final EObject ruleExternPredicateDefinition() throws RecognitionException { |
1672 | EObject current = null; | 1517 | EObject current = null; |
1673 | 1518 | ||
1674 | Token otherlv_0=null; | 1519 | Token otherlv_0=null; |
1675 | Token otherlv_2=null; | ||
1676 | EObject lv_head_1_0 = null; | 1520 | EObject lv_head_1_0 = null; |
1677 | 1521 | ||
1678 | 1522 | ||
@@ -1680,70 +1524,56 @@ public class InternalSolverLanguageParser extends AbstractInternalAntlrParser { | |||
1680 | enterRule(); | 1524 | enterRule(); |
1681 | 1525 | ||
1682 | try { | 1526 | try { |
1683 | // InternalSolverLanguage.g:611:2: ( (otherlv_0= 'extern' ( (lv_head_1_0= ruleCall ) ) otherlv_2= '.' ) ) | 1527 | // InternalSolverLanguageParser.g:604:2: ( (otherlv_0= Extern ( (lv_head_1_0= ruleCall ) ) ) ) |
1684 | // InternalSolverLanguage.g:612:2: (otherlv_0= 'extern' ( (lv_head_1_0= ruleCall ) ) otherlv_2= '.' ) | 1528 | // InternalSolverLanguageParser.g:605:2: (otherlv_0= Extern ( (lv_head_1_0= ruleCall ) ) ) |
1685 | { | 1529 | { |
1686 | // InternalSolverLanguage.g:612:2: (otherlv_0= 'extern' ( (lv_head_1_0= ruleCall ) ) otherlv_2= '.' ) | 1530 | // InternalSolverLanguageParser.g:605:2: (otherlv_0= Extern ( (lv_head_1_0= ruleCall ) ) ) |
1687 | // InternalSolverLanguage.g:613:3: otherlv_0= 'extern' ( (lv_head_1_0= ruleCall ) ) otherlv_2= '.' | 1531 | // InternalSolverLanguageParser.g:606:3: otherlv_0= Extern ( (lv_head_1_0= ruleCall ) ) |
1688 | { | 1532 | { |
1689 | otherlv_0=(Token)match(input,21,FOLLOW_7); if (state.failed) return current; | 1533 | otherlv_0=(Token)match(input,Extern,FOLLOW_8); |
1690 | if ( state.backtracking==0 ) { | ||
1691 | 1534 | ||
1692 | newLeafNode(otherlv_0, grammarAccess.getExternPredicateDefinitionAccess().getExternKeyword_0()); | 1535 | newLeafNode(otherlv_0, grammarAccess.getExternPredicateDefinitionAccess().getExternKeyword_0()); |
1693 | 1536 | ||
1694 | } | 1537 | // InternalSolverLanguageParser.g:610:3: ( (lv_head_1_0= ruleCall ) ) |
1695 | // InternalSolverLanguage.g:617:3: ( (lv_head_1_0= ruleCall ) ) | 1538 | // InternalSolverLanguageParser.g:611:4: (lv_head_1_0= ruleCall ) |
1696 | // InternalSolverLanguage.g:618:4: (lv_head_1_0= ruleCall ) | ||
1697 | { | 1539 | { |
1698 | // InternalSolverLanguage.g:618:4: (lv_head_1_0= ruleCall ) | 1540 | // InternalSolverLanguageParser.g:611:4: (lv_head_1_0= ruleCall ) |
1699 | // InternalSolverLanguage.g:619:5: lv_head_1_0= ruleCall | 1541 | // InternalSolverLanguageParser.g:612:5: lv_head_1_0= ruleCall |
1700 | { | 1542 | { |
1701 | if ( state.backtracking==0 ) { | ||
1702 | 1543 | ||
1703 | newCompositeNode(grammarAccess.getExternPredicateDefinitionAccess().getHeadCallParserRuleCall_1_0()); | 1544 | newCompositeNode(grammarAccess.getExternPredicateDefinitionAccess().getHeadCallParserRuleCall_1_0()); |
1704 | 1545 | ||
1705 | } | 1546 | pushFollow(FOLLOW_2); |
1706 | pushFollow(FOLLOW_12); | ||
1707 | lv_head_1_0=ruleCall(); | 1547 | lv_head_1_0=ruleCall(); |
1708 | 1548 | ||
1709 | state._fsp--; | 1549 | state._fsp--; |
1710 | if (state.failed) return current; | ||
1711 | if ( state.backtracking==0 ) { | ||
1712 | |||
1713 | if (current==null) { | ||
1714 | current = createModelElementForParent(grammarAccess.getExternPredicateDefinitionRule()); | ||
1715 | } | ||
1716 | set( | ||
1717 | current, | ||
1718 | "head", | ||
1719 | lv_head_1_0, | ||
1720 | "org.eclipse.viatra.solver.language.SolverLanguage.Call"); | ||
1721 | afterParserOrEnumRuleCall(); | ||
1722 | |||
1723 | } | ||
1724 | 1550 | ||
1725 | } | ||
1726 | 1551 | ||
1552 | if (current==null) { | ||
1553 | current = createModelElementForParent(grammarAccess.getExternPredicateDefinitionRule()); | ||
1554 | } | ||
1555 | set( | ||
1556 | current, | ||
1557 | "head", | ||
1558 | lv_head_1_0, | ||
1559 | "org.eclipse.viatra.solver.language.SolverLanguage.Call"); | ||
1560 | afterParserOrEnumRuleCall(); | ||
1561 | |||
1727 | 1562 | ||
1728 | } | 1563 | } |
1729 | 1564 | ||
1730 | otherlv_2=(Token)match(input,22,FOLLOW_2); if (state.failed) return current; | ||
1731 | if ( state.backtracking==0 ) { | ||
1732 | 1565 | ||
1733 | newLeafNode(otherlv_2, grammarAccess.getExternPredicateDefinitionAccess().getFullStopKeyword_2()); | ||
1734 | |||
1735 | } | 1566 | } |
1736 | 1567 | ||
1568 | |||
1737 | } | 1569 | } |
1738 | 1570 | ||
1739 | 1571 | ||
1740 | } | 1572 | } |
1741 | 1573 | ||
1742 | if ( state.backtracking==0 ) { | ||
1743 | 1574 | ||
1744 | leaveRule(); | 1575 | leaveRule(); |
1745 | 1576 | ||
1746 | } | ||
1747 | } | 1577 | } |
1748 | 1578 | ||
1749 | catch (RecognitionException re) { | 1579 | catch (RecognitionException re) { |
@@ -1758,7 +1588,7 @@ public class InternalSolverLanguageParser extends AbstractInternalAntlrParser { | |||
1758 | 1588 | ||
1759 | 1589 | ||
1760 | // $ANTLR start "entryRuleMetricDefinition" | 1590 | // $ANTLR start "entryRuleMetricDefinition" |
1761 | // InternalSolverLanguage.g:644:1: entryRuleMetricDefinition returns [EObject current=null] : iv_ruleMetricDefinition= ruleMetricDefinition EOF ; | 1591 | // InternalSolverLanguageParser.g:633:1: entryRuleMetricDefinition returns [EObject current=null] : iv_ruleMetricDefinition= ruleMetricDefinition EOF ; |
1762 | public final EObject entryRuleMetricDefinition() throws RecognitionException { | 1592 | public final EObject entryRuleMetricDefinition() throws RecognitionException { |
1763 | EObject current = null; | 1593 | EObject current = null; |
1764 | 1594 | ||
@@ -1766,21 +1596,17 @@ public class InternalSolverLanguageParser extends AbstractInternalAntlrParser { | |||
1766 | 1596 | ||
1767 | 1597 | ||
1768 | try { | 1598 | try { |
1769 | // InternalSolverLanguage.g:644:57: (iv_ruleMetricDefinition= ruleMetricDefinition EOF ) | 1599 | // InternalSolverLanguageParser.g:633:57: (iv_ruleMetricDefinition= ruleMetricDefinition EOF ) |
1770 | // InternalSolverLanguage.g:645:2: iv_ruleMetricDefinition= ruleMetricDefinition EOF | 1600 | // InternalSolverLanguageParser.g:634:2: iv_ruleMetricDefinition= ruleMetricDefinition EOF |
1771 | { | 1601 | { |
1772 | if ( state.backtracking==0 ) { | 1602 | newCompositeNode(grammarAccess.getMetricDefinitionRule()); |
1773 | newCompositeNode(grammarAccess.getMetricDefinitionRule()); | ||
1774 | } | ||
1775 | pushFollow(FOLLOW_1); | 1603 | pushFollow(FOLLOW_1); |
1776 | iv_ruleMetricDefinition=ruleMetricDefinition(); | 1604 | iv_ruleMetricDefinition=ruleMetricDefinition(); |
1777 | 1605 | ||
1778 | state._fsp--; | 1606 | state._fsp--; |
1779 | if (state.failed) return current; | 1607 | |
1780 | if ( state.backtracking==0 ) { | 1608 | current =iv_ruleMetricDefinition; |
1781 | current =iv_ruleMetricDefinition; | 1609 | match(input,EOF,FOLLOW_2); |
1782 | } | ||
1783 | match(input,EOF,FOLLOW_2); if (state.failed) return current; | ||
1784 | 1610 | ||
1785 | } | 1611 | } |
1786 | 1612 | ||
@@ -1798,7 +1624,7 @@ public class InternalSolverLanguageParser extends AbstractInternalAntlrParser { | |||
1798 | 1624 | ||
1799 | 1625 | ||
1800 | // $ANTLR start "ruleMetricDefinition" | 1626 | // $ANTLR start "ruleMetricDefinition" |
1801 | // InternalSolverLanguage.g:651:1: ruleMetricDefinition returns [EObject current=null] : ( ( (lv_type_0_0= ruleMetricType ) ) ( (lv_head_1_0= ruleExpression ) ) otherlv_2= '=' ( (lv_body_3_0= ruleExpression ) ) ) ; | 1627 | // InternalSolverLanguageParser.g:640:1: ruleMetricDefinition returns [EObject current=null] : ( ( (lv_type_0_0= ruleMetricType ) ) ( (lv_head_1_0= ruleExpression ) ) otherlv_2= EqualsSign ( (lv_body_3_0= ruleExpression ) ) ) ; |
1802 | public final EObject ruleMetricDefinition() throws RecognitionException { | 1628 | public final EObject ruleMetricDefinition() throws RecognitionException { |
1803 | EObject current = null; | 1629 | EObject current = null; |
1804 | 1630 | ||
@@ -1814,117 +1640,103 @@ public class InternalSolverLanguageParser extends AbstractInternalAntlrParser { | |||
1814 | enterRule(); | 1640 | enterRule(); |
1815 | 1641 | ||
1816 | try { | 1642 | try { |
1817 | // InternalSolverLanguage.g:657:2: ( ( ( (lv_type_0_0= ruleMetricType ) ) ( (lv_head_1_0= ruleExpression ) ) otherlv_2= '=' ( (lv_body_3_0= ruleExpression ) ) ) ) | 1643 | // InternalSolverLanguageParser.g:646:2: ( ( ( (lv_type_0_0= ruleMetricType ) ) ( (lv_head_1_0= ruleExpression ) ) otherlv_2= EqualsSign ( (lv_body_3_0= ruleExpression ) ) ) ) |
1818 | // InternalSolverLanguage.g:658:2: ( ( (lv_type_0_0= ruleMetricType ) ) ( (lv_head_1_0= ruleExpression ) ) otherlv_2= '=' ( (lv_body_3_0= ruleExpression ) ) ) | 1644 | // InternalSolverLanguageParser.g:647:2: ( ( (lv_type_0_0= ruleMetricType ) ) ( (lv_head_1_0= ruleExpression ) ) otherlv_2= EqualsSign ( (lv_body_3_0= ruleExpression ) ) ) |
1819 | { | 1645 | { |
1820 | // InternalSolverLanguage.g:658:2: ( ( (lv_type_0_0= ruleMetricType ) ) ( (lv_head_1_0= ruleExpression ) ) otherlv_2= '=' ( (lv_body_3_0= ruleExpression ) ) ) | 1646 | // InternalSolverLanguageParser.g:647:2: ( ( (lv_type_0_0= ruleMetricType ) ) ( (lv_head_1_0= ruleExpression ) ) otherlv_2= EqualsSign ( (lv_body_3_0= ruleExpression ) ) ) |
1821 | // InternalSolverLanguage.g:659:3: ( (lv_type_0_0= ruleMetricType ) ) ( (lv_head_1_0= ruleExpression ) ) otherlv_2= '=' ( (lv_body_3_0= ruleExpression ) ) | 1647 | // InternalSolverLanguageParser.g:648:3: ( (lv_type_0_0= ruleMetricType ) ) ( (lv_head_1_0= ruleExpression ) ) otherlv_2= EqualsSign ( (lv_body_3_0= ruleExpression ) ) |
1822 | { | 1648 | { |
1823 | // InternalSolverLanguage.g:659:3: ( (lv_type_0_0= ruleMetricType ) ) | 1649 | // InternalSolverLanguageParser.g:648:3: ( (lv_type_0_0= ruleMetricType ) ) |
1824 | // InternalSolverLanguage.g:660:4: (lv_type_0_0= ruleMetricType ) | 1650 | // InternalSolverLanguageParser.g:649:4: (lv_type_0_0= ruleMetricType ) |
1825 | { | 1651 | { |
1826 | // InternalSolverLanguage.g:660:4: (lv_type_0_0= ruleMetricType ) | 1652 | // InternalSolverLanguageParser.g:649:4: (lv_type_0_0= ruleMetricType ) |
1827 | // InternalSolverLanguage.g:661:5: lv_type_0_0= ruleMetricType | 1653 | // InternalSolverLanguageParser.g:650:5: lv_type_0_0= ruleMetricType |
1828 | { | 1654 | { |
1829 | if ( state.backtracking==0 ) { | ||
1830 | 1655 | ||
1831 | newCompositeNode(grammarAccess.getMetricDefinitionAccess().getTypeMetricTypeEnumRuleCall_0_0()); | 1656 | newCompositeNode(grammarAccess.getMetricDefinitionAccess().getTypeMetricTypeEnumRuleCall_0_0()); |
1832 | 1657 | ||
1833 | } | ||
1834 | pushFollow(FOLLOW_6); | 1658 | pushFollow(FOLLOW_6); |
1835 | lv_type_0_0=ruleMetricType(); | 1659 | lv_type_0_0=ruleMetricType(); |
1836 | 1660 | ||
1837 | state._fsp--; | 1661 | state._fsp--; |
1838 | if (state.failed) return current; | ||
1839 | if ( state.backtracking==0 ) { | ||
1840 | 1662 | ||
1841 | if (current==null) { | 1663 | |
1842 | current = createModelElementForParent(grammarAccess.getMetricDefinitionRule()); | 1664 | if (current==null) { |
1843 | } | 1665 | current = createModelElementForParent(grammarAccess.getMetricDefinitionRule()); |
1844 | set( | 1666 | } |
1845 | current, | 1667 | set( |
1846 | "type", | 1668 | current, |
1847 | lv_type_0_0, | 1669 | "type", |
1848 | "org.eclipse.viatra.solver.language.SolverLanguage.MetricType"); | 1670 | lv_type_0_0, |
1849 | afterParserOrEnumRuleCall(); | 1671 | "org.eclipse.viatra.solver.language.SolverLanguage.MetricType"); |
1850 | 1672 | afterParserOrEnumRuleCall(); | |
1851 | } | 1673 | |
1852 | 1674 | ||
1853 | } | 1675 | } |
1854 | 1676 | ||
1855 | 1677 | ||
1856 | } | 1678 | } |
1857 | 1679 | ||
1858 | // InternalSolverLanguage.g:678:3: ( (lv_head_1_0= ruleExpression ) ) | 1680 | // InternalSolverLanguageParser.g:667:3: ( (lv_head_1_0= ruleExpression ) ) |
1859 | // InternalSolverLanguage.g:679:4: (lv_head_1_0= ruleExpression ) | 1681 | // InternalSolverLanguageParser.g:668:4: (lv_head_1_0= ruleExpression ) |
1860 | { | 1682 | { |
1861 | // InternalSolverLanguage.g:679:4: (lv_head_1_0= ruleExpression ) | 1683 | // InternalSolverLanguageParser.g:668:4: (lv_head_1_0= ruleExpression ) |
1862 | // InternalSolverLanguage.g:680:5: lv_head_1_0= ruleExpression | 1684 | // InternalSolverLanguageParser.g:669:5: lv_head_1_0= ruleExpression |
1863 | { | 1685 | { |
1864 | if ( state.backtracking==0 ) { | ||
1865 | 1686 | ||
1866 | newCompositeNode(grammarAccess.getMetricDefinitionAccess().getHeadExpressionParserRuleCall_1_0()); | 1687 | newCompositeNode(grammarAccess.getMetricDefinitionAccess().getHeadExpressionParserRuleCall_1_0()); |
1867 | 1688 | ||
1868 | } | ||
1869 | pushFollow(FOLLOW_13); | 1689 | pushFollow(FOLLOW_13); |
1870 | lv_head_1_0=ruleExpression(); | 1690 | lv_head_1_0=ruleExpression(); |
1871 | 1691 | ||
1872 | state._fsp--; | 1692 | state._fsp--; |
1873 | if (state.failed) return current; | ||
1874 | if ( state.backtracking==0 ) { | ||
1875 | 1693 | ||
1876 | if (current==null) { | 1694 | |
1877 | current = createModelElementForParent(grammarAccess.getMetricDefinitionRule()); | 1695 | if (current==null) { |
1878 | } | 1696 | current = createModelElementForParent(grammarAccess.getMetricDefinitionRule()); |
1879 | set( | 1697 | } |
1880 | current, | 1698 | set( |
1881 | "head", | 1699 | current, |
1882 | lv_head_1_0, | 1700 | "head", |
1883 | "org.eclipse.viatra.solver.language.SolverLanguage.Expression"); | 1701 | lv_head_1_0, |
1884 | afterParserOrEnumRuleCall(); | 1702 | "org.eclipse.viatra.solver.language.SolverLanguage.Expression"); |
1885 | 1703 | afterParserOrEnumRuleCall(); | |
1886 | } | 1704 | |
1887 | 1705 | ||
1888 | } | 1706 | } |
1889 | 1707 | ||
1890 | 1708 | ||
1891 | } | 1709 | } |
1892 | 1710 | ||
1893 | otherlv_2=(Token)match(input,17,FOLLOW_6); if (state.failed) return current; | 1711 | otherlv_2=(Token)match(input,EqualsSign,FOLLOW_6); |
1894 | if ( state.backtracking==0 ) { | ||
1895 | 1712 | ||
1896 | newLeafNode(otherlv_2, grammarAccess.getMetricDefinitionAccess().getEqualsSignKeyword_2()); | 1713 | newLeafNode(otherlv_2, grammarAccess.getMetricDefinitionAccess().getEqualsSignKeyword_2()); |
1897 | 1714 | ||
1898 | } | 1715 | // InternalSolverLanguageParser.g:690:3: ( (lv_body_3_0= ruleExpression ) ) |
1899 | // InternalSolverLanguage.g:701:3: ( (lv_body_3_0= ruleExpression ) ) | 1716 | // InternalSolverLanguageParser.g:691:4: (lv_body_3_0= ruleExpression ) |
1900 | // InternalSolverLanguage.g:702:4: (lv_body_3_0= ruleExpression ) | ||
1901 | { | 1717 | { |
1902 | // InternalSolverLanguage.g:702:4: (lv_body_3_0= ruleExpression ) | 1718 | // InternalSolverLanguageParser.g:691:4: (lv_body_3_0= ruleExpression ) |
1903 | // InternalSolverLanguage.g:703:5: lv_body_3_0= ruleExpression | 1719 | // InternalSolverLanguageParser.g:692:5: lv_body_3_0= ruleExpression |
1904 | { | 1720 | { |
1905 | if ( state.backtracking==0 ) { | ||
1906 | 1721 | ||
1907 | newCompositeNode(grammarAccess.getMetricDefinitionAccess().getBodyExpressionParserRuleCall_3_0()); | 1722 | newCompositeNode(grammarAccess.getMetricDefinitionAccess().getBodyExpressionParserRuleCall_3_0()); |
1908 | 1723 | ||
1909 | } | ||
1910 | pushFollow(FOLLOW_2); | 1724 | pushFollow(FOLLOW_2); |
1911 | lv_body_3_0=ruleExpression(); | 1725 | lv_body_3_0=ruleExpression(); |
1912 | 1726 | ||
1913 | state._fsp--; | 1727 | state._fsp--; |
1914 | if (state.failed) return current; | ||
1915 | if ( state.backtracking==0 ) { | ||
1916 | 1728 | ||
1917 | if (current==null) { | 1729 | |
1918 | current = createModelElementForParent(grammarAccess.getMetricDefinitionRule()); | 1730 | if (current==null) { |
1919 | } | 1731 | current = createModelElementForParent(grammarAccess.getMetricDefinitionRule()); |
1920 | set( | 1732 | } |
1921 | current, | 1733 | set( |
1922 | "body", | 1734 | current, |
1923 | lv_body_3_0, | 1735 | "body", |
1924 | "org.eclipse.viatra.solver.language.SolverLanguage.Expression"); | 1736 | lv_body_3_0, |
1925 | afterParserOrEnumRuleCall(); | 1737 | "org.eclipse.viatra.solver.language.SolverLanguage.Expression"); |
1926 | 1738 | afterParserOrEnumRuleCall(); | |
1927 | } | 1739 | |
1928 | 1740 | ||
1929 | } | 1741 | } |
1930 | 1742 | ||
@@ -1937,11 +1749,9 @@ public class InternalSolverLanguageParser extends AbstractInternalAntlrParser { | |||
1937 | 1749 | ||
1938 | } | 1750 | } |
1939 | 1751 | ||
1940 | if ( state.backtracking==0 ) { | ||
1941 | 1752 | ||
1942 | leaveRule(); | 1753 | leaveRule(); |
1943 | 1754 | ||
1944 | } | ||
1945 | } | 1755 | } |
1946 | 1756 | ||
1947 | catch (RecognitionException re) { | 1757 | catch (RecognitionException re) { |
@@ -1956,7 +1766,7 @@ public class InternalSolverLanguageParser extends AbstractInternalAntlrParser { | |||
1956 | 1766 | ||
1957 | 1767 | ||
1958 | // $ANTLR start "entryRuleExternMetricDefinition" | 1768 | // $ANTLR start "entryRuleExternMetricDefinition" |
1959 | // InternalSolverLanguage.g:724:1: entryRuleExternMetricDefinition returns [EObject current=null] : iv_ruleExternMetricDefinition= ruleExternMetricDefinition EOF ; | 1769 | // InternalSolverLanguageParser.g:713:1: entryRuleExternMetricDefinition returns [EObject current=null] : iv_ruleExternMetricDefinition= ruleExternMetricDefinition EOF ; |
1960 | public final EObject entryRuleExternMetricDefinition() throws RecognitionException { | 1770 | public final EObject entryRuleExternMetricDefinition() throws RecognitionException { |
1961 | EObject current = null; | 1771 | EObject current = null; |
1962 | 1772 | ||
@@ -1964,21 +1774,17 @@ public class InternalSolverLanguageParser extends AbstractInternalAntlrParser { | |||
1964 | 1774 | ||
1965 | 1775 | ||
1966 | try { | 1776 | try { |
1967 | // InternalSolverLanguage.g:724:63: (iv_ruleExternMetricDefinition= ruleExternMetricDefinition EOF ) | 1777 | // InternalSolverLanguageParser.g:713:63: (iv_ruleExternMetricDefinition= ruleExternMetricDefinition EOF ) |
1968 | // InternalSolverLanguage.g:725:2: iv_ruleExternMetricDefinition= ruleExternMetricDefinition EOF | 1778 | // InternalSolverLanguageParser.g:714:2: iv_ruleExternMetricDefinition= ruleExternMetricDefinition EOF |
1969 | { | 1779 | { |
1970 | if ( state.backtracking==0 ) { | 1780 | newCompositeNode(grammarAccess.getExternMetricDefinitionRule()); |
1971 | newCompositeNode(grammarAccess.getExternMetricDefinitionRule()); | ||
1972 | } | ||
1973 | pushFollow(FOLLOW_1); | 1781 | pushFollow(FOLLOW_1); |
1974 | iv_ruleExternMetricDefinition=ruleExternMetricDefinition(); | 1782 | iv_ruleExternMetricDefinition=ruleExternMetricDefinition(); |
1975 | 1783 | ||
1976 | state._fsp--; | 1784 | state._fsp--; |
1977 | if (state.failed) return current; | 1785 | |
1978 | if ( state.backtracking==0 ) { | 1786 | current =iv_ruleExternMetricDefinition; |
1979 | current =iv_ruleExternMetricDefinition; | 1787 | match(input,EOF,FOLLOW_2); |
1980 | } | ||
1981 | match(input,EOF,FOLLOW_2); if (state.failed) return current; | ||
1982 | 1788 | ||
1983 | } | 1789 | } |
1984 | 1790 | ||
@@ -1996,7 +1802,7 @@ public class InternalSolverLanguageParser extends AbstractInternalAntlrParser { | |||
1996 | 1802 | ||
1997 | 1803 | ||
1998 | // $ANTLR start "ruleExternMetricDefinition" | 1804 | // $ANTLR start "ruleExternMetricDefinition" |
1999 | // InternalSolverLanguage.g:731:1: ruleExternMetricDefinition returns [EObject current=null] : (otherlv_0= 'extern' ( (lv_type_1_0= ruleMetricType ) ) ( (lv_head_2_0= ruleCall ) ) ) ; | 1805 | // InternalSolverLanguageParser.g:720:1: ruleExternMetricDefinition returns [EObject current=null] : (otherlv_0= Extern ( (lv_type_1_0= ruleMetricType ) ) ( (lv_head_2_0= ruleCall ) ) ) ; |
2000 | public final EObject ruleExternMetricDefinition() throws RecognitionException { | 1806 | public final EObject ruleExternMetricDefinition() throws RecognitionException { |
2001 | EObject current = null; | 1807 | EObject current = null; |
2002 | 1808 | ||
@@ -2010,82 +1816,72 @@ public class InternalSolverLanguageParser extends AbstractInternalAntlrParser { | |||
2010 | enterRule(); | 1816 | enterRule(); |
2011 | 1817 | ||
2012 | try { | 1818 | try { |
2013 | // InternalSolverLanguage.g:737:2: ( (otherlv_0= 'extern' ( (lv_type_1_0= ruleMetricType ) ) ( (lv_head_2_0= ruleCall ) ) ) ) | 1819 | // InternalSolverLanguageParser.g:726:2: ( (otherlv_0= Extern ( (lv_type_1_0= ruleMetricType ) ) ( (lv_head_2_0= ruleCall ) ) ) ) |
2014 | // InternalSolverLanguage.g:738:2: (otherlv_0= 'extern' ( (lv_type_1_0= ruleMetricType ) ) ( (lv_head_2_0= ruleCall ) ) ) | 1820 | // InternalSolverLanguageParser.g:727:2: (otherlv_0= Extern ( (lv_type_1_0= ruleMetricType ) ) ( (lv_head_2_0= ruleCall ) ) ) |
2015 | { | 1821 | { |
2016 | // InternalSolverLanguage.g:738:2: (otherlv_0= 'extern' ( (lv_type_1_0= ruleMetricType ) ) ( (lv_head_2_0= ruleCall ) ) ) | 1822 | // InternalSolverLanguageParser.g:727:2: (otherlv_0= Extern ( (lv_type_1_0= ruleMetricType ) ) ( (lv_head_2_0= ruleCall ) ) ) |
2017 | // InternalSolverLanguage.g:739:3: otherlv_0= 'extern' ( (lv_type_1_0= ruleMetricType ) ) ( (lv_head_2_0= ruleCall ) ) | 1823 | // InternalSolverLanguageParser.g:728:3: otherlv_0= Extern ( (lv_type_1_0= ruleMetricType ) ) ( (lv_head_2_0= ruleCall ) ) |
2018 | { | 1824 | { |
2019 | otherlv_0=(Token)match(input,21,FOLLOW_14); if (state.failed) return current; | 1825 | otherlv_0=(Token)match(input,Extern,FOLLOW_14); |
2020 | if ( state.backtracking==0 ) { | ||
2021 | 1826 | ||
2022 | newLeafNode(otherlv_0, grammarAccess.getExternMetricDefinitionAccess().getExternKeyword_0()); | 1827 | newLeafNode(otherlv_0, grammarAccess.getExternMetricDefinitionAccess().getExternKeyword_0()); |
2023 | 1828 | ||
2024 | } | 1829 | // InternalSolverLanguageParser.g:732:3: ( (lv_type_1_0= ruleMetricType ) ) |
2025 | // InternalSolverLanguage.g:743:3: ( (lv_type_1_0= ruleMetricType ) ) | 1830 | // InternalSolverLanguageParser.g:733:4: (lv_type_1_0= ruleMetricType ) |
2026 | // InternalSolverLanguage.g:744:4: (lv_type_1_0= ruleMetricType ) | ||
2027 | { | 1831 | { |
2028 | // InternalSolverLanguage.g:744:4: (lv_type_1_0= ruleMetricType ) | 1832 | // InternalSolverLanguageParser.g:733:4: (lv_type_1_0= ruleMetricType ) |
2029 | // InternalSolverLanguage.g:745:5: lv_type_1_0= ruleMetricType | 1833 | // InternalSolverLanguageParser.g:734:5: lv_type_1_0= ruleMetricType |
2030 | { | 1834 | { |
2031 | if ( state.backtracking==0 ) { | ||
2032 | 1835 | ||
2033 | newCompositeNode(grammarAccess.getExternMetricDefinitionAccess().getTypeMetricTypeEnumRuleCall_1_0()); | 1836 | newCompositeNode(grammarAccess.getExternMetricDefinitionAccess().getTypeMetricTypeEnumRuleCall_1_0()); |
2034 | 1837 | ||
2035 | } | 1838 | pushFollow(FOLLOW_8); |
2036 | pushFollow(FOLLOW_7); | ||
2037 | lv_type_1_0=ruleMetricType(); | 1839 | lv_type_1_0=ruleMetricType(); |
2038 | 1840 | ||
2039 | state._fsp--; | 1841 | state._fsp--; |
2040 | if (state.failed) return current; | ||
2041 | if ( state.backtracking==0 ) { | ||
2042 | 1842 | ||
2043 | if (current==null) { | 1843 | |
2044 | current = createModelElementForParent(grammarAccess.getExternMetricDefinitionRule()); | 1844 | if (current==null) { |
2045 | } | 1845 | current = createModelElementForParent(grammarAccess.getExternMetricDefinitionRule()); |
2046 | set( | 1846 | } |
2047 | current, | 1847 | set( |
2048 | "type", | 1848 | current, |
2049 | lv_type_1_0, | 1849 | "type", |
2050 | "org.eclipse.viatra.solver.language.SolverLanguage.MetricType"); | 1850 | lv_type_1_0, |
2051 | afterParserOrEnumRuleCall(); | 1851 | "org.eclipse.viatra.solver.language.SolverLanguage.MetricType"); |
2052 | 1852 | afterParserOrEnumRuleCall(); | |
2053 | } | 1853 | |
2054 | 1854 | ||
2055 | } | 1855 | } |
2056 | 1856 | ||
2057 | 1857 | ||
2058 | } | 1858 | } |
2059 | 1859 | ||
2060 | // InternalSolverLanguage.g:762:3: ( (lv_head_2_0= ruleCall ) ) | 1860 | // InternalSolverLanguageParser.g:751:3: ( (lv_head_2_0= ruleCall ) ) |
2061 | // InternalSolverLanguage.g:763:4: (lv_head_2_0= ruleCall ) | 1861 | // InternalSolverLanguageParser.g:752:4: (lv_head_2_0= ruleCall ) |
2062 | { | 1862 | { |
2063 | // InternalSolverLanguage.g:763:4: (lv_head_2_0= ruleCall ) | 1863 | // InternalSolverLanguageParser.g:752:4: (lv_head_2_0= ruleCall ) |
2064 | // InternalSolverLanguage.g:764:5: lv_head_2_0= ruleCall | 1864 | // InternalSolverLanguageParser.g:753:5: lv_head_2_0= ruleCall |
2065 | { | 1865 | { |
2066 | if ( state.backtracking==0 ) { | ||
2067 | 1866 | ||
2068 | newCompositeNode(grammarAccess.getExternMetricDefinitionAccess().getHeadCallParserRuleCall_2_0()); | 1867 | newCompositeNode(grammarAccess.getExternMetricDefinitionAccess().getHeadCallParserRuleCall_2_0()); |
2069 | 1868 | ||
2070 | } | ||
2071 | pushFollow(FOLLOW_2); | 1869 | pushFollow(FOLLOW_2); |
2072 | lv_head_2_0=ruleCall(); | 1870 | lv_head_2_0=ruleCall(); |
2073 | 1871 | ||
2074 | state._fsp--; | 1872 | state._fsp--; |
2075 | if (state.failed) return current; | ||
2076 | if ( state.backtracking==0 ) { | ||
2077 | 1873 | ||
2078 | if (current==null) { | 1874 | |
2079 | current = createModelElementForParent(grammarAccess.getExternMetricDefinitionRule()); | 1875 | if (current==null) { |
2080 | } | 1876 | current = createModelElementForParent(grammarAccess.getExternMetricDefinitionRule()); |
2081 | set( | 1877 | } |
2082 | current, | 1878 | set( |
2083 | "head", | 1879 | current, |
2084 | lv_head_2_0, | 1880 | "head", |
2085 | "org.eclipse.viatra.solver.language.SolverLanguage.Call"); | 1881 | lv_head_2_0, |
2086 | afterParserOrEnumRuleCall(); | 1882 | "org.eclipse.viatra.solver.language.SolverLanguage.Call"); |
2087 | 1883 | afterParserOrEnumRuleCall(); | |
2088 | } | 1884 | |
2089 | 1885 | ||
2090 | } | 1886 | } |
2091 | 1887 | ||
@@ -2098,11 +1894,9 @@ public class InternalSolverLanguageParser extends AbstractInternalAntlrParser { | |||
2098 | 1894 | ||
2099 | } | 1895 | } |
2100 | 1896 | ||
2101 | if ( state.backtracking==0 ) { | ||
2102 | 1897 | ||
2103 | leaveRule(); | 1898 | leaveRule(); |
2104 | 1899 | ||
2105 | } | ||
2106 | } | 1900 | } |
2107 | 1901 | ||
2108 | catch (RecognitionException re) { | 1902 | catch (RecognitionException re) { |
@@ -2117,7 +1911,7 @@ public class InternalSolverLanguageParser extends AbstractInternalAntlrParser { | |||
2117 | 1911 | ||
2118 | 1912 | ||
2119 | // $ANTLR start "entryRuleExpression" | 1913 | // $ANTLR start "entryRuleExpression" |
2120 | // InternalSolverLanguage.g:785:1: entryRuleExpression returns [EObject current=null] : iv_ruleExpression= ruleExpression EOF ; | 1914 | // InternalSolverLanguageParser.g:774:1: entryRuleExpression returns [EObject current=null] : iv_ruleExpression= ruleExpression EOF ; |
2121 | public final EObject entryRuleExpression() throws RecognitionException { | 1915 | public final EObject entryRuleExpression() throws RecognitionException { |
2122 | EObject current = null; | 1916 | EObject current = null; |
2123 | 1917 | ||
@@ -2125,21 +1919,17 @@ public class InternalSolverLanguageParser extends AbstractInternalAntlrParser { | |||
2125 | 1919 | ||
2126 | 1920 | ||
2127 | try { | 1921 | try { |
2128 | // InternalSolverLanguage.g:785:51: (iv_ruleExpression= ruleExpression EOF ) | 1922 | // InternalSolverLanguageParser.g:774:51: (iv_ruleExpression= ruleExpression EOF ) |
2129 | // InternalSolverLanguage.g:786:2: iv_ruleExpression= ruleExpression EOF | 1923 | // InternalSolverLanguageParser.g:775:2: iv_ruleExpression= ruleExpression EOF |
2130 | { | 1924 | { |
2131 | if ( state.backtracking==0 ) { | 1925 | newCompositeNode(grammarAccess.getExpressionRule()); |
2132 | newCompositeNode(grammarAccess.getExpressionRule()); | ||
2133 | } | ||
2134 | pushFollow(FOLLOW_1); | 1926 | pushFollow(FOLLOW_1); |
2135 | iv_ruleExpression=ruleExpression(); | 1927 | iv_ruleExpression=ruleExpression(); |
2136 | 1928 | ||
2137 | state._fsp--; | 1929 | state._fsp--; |
2138 | if (state.failed) return current; | 1930 | |
2139 | if ( state.backtracking==0 ) { | 1931 | current =iv_ruleExpression; |
2140 | current =iv_ruleExpression; | 1932 | match(input,EOF,FOLLOW_2); |
2141 | } | ||
2142 | match(input,EOF,FOLLOW_2); if (state.failed) return current; | ||
2143 | 1933 | ||
2144 | } | 1934 | } |
2145 | 1935 | ||
@@ -2157,7 +1947,7 @@ public class InternalSolverLanguageParser extends AbstractInternalAntlrParser { | |||
2157 | 1947 | ||
2158 | 1948 | ||
2159 | // $ANTLR start "ruleExpression" | 1949 | // $ANTLR start "ruleExpression" |
2160 | // InternalSolverLanguage.g:792:1: ruleExpression returns [EObject current=null] : (this_IfElse_0= ruleIfElse | this_DisjunctiveExpression_1= ruleDisjunctiveExpression ) ; | 1950 | // InternalSolverLanguageParser.g:781:1: ruleExpression returns [EObject current=null] : (this_IfElse_0= ruleIfElse | this_DisjunctiveExpression_1= ruleDisjunctiveExpression ) ; |
2161 | public final EObject ruleExpression() throws RecognitionException { | 1951 | public final EObject ruleExpression() throws RecognitionException { |
2162 | EObject current = null; | 1952 | EObject current = null; |
2163 | 1953 | ||
@@ -2170,21 +1960,20 @@ public class InternalSolverLanguageParser extends AbstractInternalAntlrParser { | |||
2170 | enterRule(); | 1960 | enterRule(); |
2171 | 1961 | ||
2172 | try { | 1962 | try { |
2173 | // InternalSolverLanguage.g:798:2: ( (this_IfElse_0= ruleIfElse | this_DisjunctiveExpression_1= ruleDisjunctiveExpression ) ) | 1963 | // InternalSolverLanguageParser.g:787:2: ( (this_IfElse_0= ruleIfElse | this_DisjunctiveExpression_1= ruleDisjunctiveExpression ) ) |
2174 | // InternalSolverLanguage.g:799:2: (this_IfElse_0= ruleIfElse | this_DisjunctiveExpression_1= ruleDisjunctiveExpression ) | 1964 | // InternalSolverLanguageParser.g:788:2: (this_IfElse_0= ruleIfElse | this_DisjunctiveExpression_1= ruleDisjunctiveExpression ) |
2175 | { | 1965 | { |
2176 | // InternalSolverLanguage.g:799:2: (this_IfElse_0= ruleIfElse | this_DisjunctiveExpression_1= ruleDisjunctiveExpression ) | 1966 | // InternalSolverLanguageParser.g:788:2: (this_IfElse_0= ruleIfElse | this_DisjunctiveExpression_1= ruleDisjunctiveExpression ) |
2177 | int alt8=2; | 1967 | int alt8=2; |
2178 | int LA8_0 = input.LA(1); | 1968 | int LA8_0 = input.LA(1); |
2179 | 1969 | ||
2180 | if ( (LA8_0==23) ) { | 1970 | if ( (LA8_0==If) ) { |
2181 | alt8=1; | 1971 | alt8=1; |
2182 | } | 1972 | } |
2183 | else if ( ((LA8_0>=RULE_STRING && LA8_0<=RULE_QUOTED_ID)||LA8_0==19||LA8_0==29||LA8_0==33||LA8_0==36||(LA8_0>=39 && LA8_0<=40)||(LA8_0>=56 && LA8_0<=57)||(LA8_0>=60 && LA8_0<=72)) ) { | 1973 | else if ( (LA8_0==Current||LA8_0==Unknown||(LA8_0>=Count && LA8_0<=False)||(LA8_0>=Must && LA8_0<=Prod)||LA8_0==True||(LA8_0>=Avg && LA8_0<=Inf)||(LA8_0>=Max && LA8_0<=Sum)||(LA8_0>=ExclamationMark && LA8_0<=LeftParenthesis)||LA8_0==PlusSign||LA8_0==HyphenMinus||LA8_0==LeftSquareBracket||(LA8_0>=RULE_STRING && LA8_0<=RULE_QUOTED_ID)||(LA8_0>=RULE_ID && LA8_0<=RULE_INT)) ) { |
2184 | alt8=2; | 1974 | alt8=2; |
2185 | } | 1975 | } |
2186 | else { | 1976 | else { |
2187 | if (state.backtracking>0) {state.failed=true; return current;} | ||
2188 | NoViableAltException nvae = | 1977 | NoViableAltException nvae = |
2189 | new NoViableAltException("", 8, 0, input); | 1978 | new NoViableAltException("", 8, 0, input); |
2190 | 1979 | ||
@@ -2192,46 +1981,38 @@ public class InternalSolverLanguageParser extends AbstractInternalAntlrParser { | |||
2192 | } | 1981 | } |
2193 | switch (alt8) { | 1982 | switch (alt8) { |
2194 | case 1 : | 1983 | case 1 : |
2195 | // InternalSolverLanguage.g:800:3: this_IfElse_0= ruleIfElse | 1984 | // InternalSolverLanguageParser.g:789:3: this_IfElse_0= ruleIfElse |
2196 | { | 1985 | { |
2197 | if ( state.backtracking==0 ) { | ||
2198 | 1986 | ||
2199 | newCompositeNode(grammarAccess.getExpressionAccess().getIfElseParserRuleCall_0()); | 1987 | newCompositeNode(grammarAccess.getExpressionAccess().getIfElseParserRuleCall_0()); |
2200 | 1988 | ||
2201 | } | ||
2202 | pushFollow(FOLLOW_2); | 1989 | pushFollow(FOLLOW_2); |
2203 | this_IfElse_0=ruleIfElse(); | 1990 | this_IfElse_0=ruleIfElse(); |
2204 | 1991 | ||
2205 | state._fsp--; | 1992 | state._fsp--; |
2206 | if (state.failed) return current; | ||
2207 | if ( state.backtracking==0 ) { | ||
2208 | 1993 | ||
2209 | current = this_IfElse_0; | 1994 | |
2210 | afterParserOrEnumRuleCall(); | 1995 | current = this_IfElse_0; |
2211 | 1996 | afterParserOrEnumRuleCall(); | |
2212 | } | 1997 | |
2213 | 1998 | ||
2214 | } | 1999 | } |
2215 | break; | 2000 | break; |
2216 | case 2 : | 2001 | case 2 : |
2217 | // InternalSolverLanguage.g:809:3: this_DisjunctiveExpression_1= ruleDisjunctiveExpression | 2002 | // InternalSolverLanguageParser.g:798:3: this_DisjunctiveExpression_1= ruleDisjunctiveExpression |
2218 | { | 2003 | { |
2219 | if ( state.backtracking==0 ) { | ||
2220 | 2004 | ||
2221 | newCompositeNode(grammarAccess.getExpressionAccess().getDisjunctiveExpressionParserRuleCall_1()); | 2005 | newCompositeNode(grammarAccess.getExpressionAccess().getDisjunctiveExpressionParserRuleCall_1()); |
2222 | 2006 | ||
2223 | } | ||
2224 | pushFollow(FOLLOW_2); | 2007 | pushFollow(FOLLOW_2); |
2225 | this_DisjunctiveExpression_1=ruleDisjunctiveExpression(); | 2008 | this_DisjunctiveExpression_1=ruleDisjunctiveExpression(); |
2226 | 2009 | ||
2227 | state._fsp--; | 2010 | state._fsp--; |
2228 | if (state.failed) return current; | ||
2229 | if ( state.backtracking==0 ) { | ||
2230 | 2011 | ||
2231 | current = this_DisjunctiveExpression_1; | 2012 | |
2232 | afterParserOrEnumRuleCall(); | 2013 | current = this_DisjunctiveExpression_1; |
2233 | 2014 | afterParserOrEnumRuleCall(); | |
2234 | } | 2015 | |
2235 | 2016 | ||
2236 | } | 2017 | } |
2237 | break; | 2018 | break; |
@@ -2241,11 +2022,9 @@ public class InternalSolverLanguageParser extends AbstractInternalAntlrParser { | |||
2241 | 2022 | ||
2242 | } | 2023 | } |
2243 | 2024 | ||
2244 | if ( state.backtracking==0 ) { | ||
2245 | 2025 | ||
2246 | leaveRule(); | 2026 | leaveRule(); |
2247 | 2027 | ||
2248 | } | ||
2249 | } | 2028 | } |
2250 | 2029 | ||
2251 | catch (RecognitionException re) { | 2030 | catch (RecognitionException re) { |
@@ -2260,7 +2039,7 @@ public class InternalSolverLanguageParser extends AbstractInternalAntlrParser { | |||
2260 | 2039 | ||
2261 | 2040 | ||
2262 | // $ANTLR start "entryRuleIfElse" | 2041 | // $ANTLR start "entryRuleIfElse" |
2263 | // InternalSolverLanguage.g:821:1: entryRuleIfElse returns [EObject current=null] : iv_ruleIfElse= ruleIfElse EOF ; | 2042 | // InternalSolverLanguageParser.g:810:1: entryRuleIfElse returns [EObject current=null] : iv_ruleIfElse= ruleIfElse EOF ; |
2264 | public final EObject entryRuleIfElse() throws RecognitionException { | 2043 | public final EObject entryRuleIfElse() throws RecognitionException { |
2265 | EObject current = null; | 2044 | EObject current = null; |
2266 | 2045 | ||
@@ -2268,21 +2047,17 @@ public class InternalSolverLanguageParser extends AbstractInternalAntlrParser { | |||
2268 | 2047 | ||
2269 | 2048 | ||
2270 | try { | 2049 | try { |
2271 | // InternalSolverLanguage.g:821:47: (iv_ruleIfElse= ruleIfElse EOF ) | 2050 | // InternalSolverLanguageParser.g:810:47: (iv_ruleIfElse= ruleIfElse EOF ) |
2272 | // InternalSolverLanguage.g:822:2: iv_ruleIfElse= ruleIfElse EOF | 2051 | // InternalSolverLanguageParser.g:811:2: iv_ruleIfElse= ruleIfElse EOF |
2273 | { | 2052 | { |
2274 | if ( state.backtracking==0 ) { | 2053 | newCompositeNode(grammarAccess.getIfElseRule()); |
2275 | newCompositeNode(grammarAccess.getIfElseRule()); | ||
2276 | } | ||
2277 | pushFollow(FOLLOW_1); | 2054 | pushFollow(FOLLOW_1); |
2278 | iv_ruleIfElse=ruleIfElse(); | 2055 | iv_ruleIfElse=ruleIfElse(); |
2279 | 2056 | ||
2280 | state._fsp--; | 2057 | state._fsp--; |
2281 | if (state.failed) return current; | 2058 | |
2282 | if ( state.backtracking==0 ) { | 2059 | current =iv_ruleIfElse; |
2283 | current =iv_ruleIfElse; | 2060 | match(input,EOF,FOLLOW_2); |
2284 | } | ||
2285 | match(input,EOF,FOLLOW_2); if (state.failed) return current; | ||
2286 | 2061 | ||
2287 | } | 2062 | } |
2288 | 2063 | ||
@@ -2300,7 +2075,7 @@ public class InternalSolverLanguageParser extends AbstractInternalAntlrParser { | |||
2300 | 2075 | ||
2301 | 2076 | ||
2302 | // $ANTLR start "ruleIfElse" | 2077 | // $ANTLR start "ruleIfElse" |
2303 | // InternalSolverLanguage.g:828:1: ruleIfElse returns [EObject current=null] : (otherlv_0= 'if' ( (lv_condition_1_0= ruleExpression ) ) otherlv_2= 'then' ( (lv_then_3_0= ruleExpression ) ) otherlv_4= 'else' ( (lv_else_5_0= ruleExpression ) ) ) ; | 2078 | // InternalSolverLanguageParser.g:817:1: ruleIfElse returns [EObject current=null] : (otherlv_0= If ( (lv_condition_1_0= ruleExpression ) ) otherlv_2= Then ( (lv_then_3_0= ruleExpression ) ) otherlv_4= Else ( (lv_else_5_0= ruleExpression ) ) ) ; |
2304 | public final EObject ruleIfElse() throws RecognitionException { | 2079 | public final EObject ruleIfElse() throws RecognitionException { |
2305 | EObject current = null; | 2080 | EObject current = null; |
2306 | 2081 | ||
@@ -2318,129 +2093,111 @@ public class InternalSolverLanguageParser extends AbstractInternalAntlrParser { | |||
2318 | enterRule(); | 2093 | enterRule(); |
2319 | 2094 | ||
2320 | try { | 2095 | try { |
2321 | // InternalSolverLanguage.g:834:2: ( (otherlv_0= 'if' ( (lv_condition_1_0= ruleExpression ) ) otherlv_2= 'then' ( (lv_then_3_0= ruleExpression ) ) otherlv_4= 'else' ( (lv_else_5_0= ruleExpression ) ) ) ) | 2096 | // InternalSolverLanguageParser.g:823:2: ( (otherlv_0= If ( (lv_condition_1_0= ruleExpression ) ) otherlv_2= Then ( (lv_then_3_0= ruleExpression ) ) otherlv_4= Else ( (lv_else_5_0= ruleExpression ) ) ) ) |
2322 | // InternalSolverLanguage.g:835:2: (otherlv_0= 'if' ( (lv_condition_1_0= ruleExpression ) ) otherlv_2= 'then' ( (lv_then_3_0= ruleExpression ) ) otherlv_4= 'else' ( (lv_else_5_0= ruleExpression ) ) ) | 2097 | // InternalSolverLanguageParser.g:824:2: (otherlv_0= If ( (lv_condition_1_0= ruleExpression ) ) otherlv_2= Then ( (lv_then_3_0= ruleExpression ) ) otherlv_4= Else ( (lv_else_5_0= ruleExpression ) ) ) |
2323 | { | 2098 | { |
2324 | // InternalSolverLanguage.g:835:2: (otherlv_0= 'if' ( (lv_condition_1_0= ruleExpression ) ) otherlv_2= 'then' ( (lv_then_3_0= ruleExpression ) ) otherlv_4= 'else' ( (lv_else_5_0= ruleExpression ) ) ) | 2099 | // InternalSolverLanguageParser.g:824:2: (otherlv_0= If ( (lv_condition_1_0= ruleExpression ) ) otherlv_2= Then ( (lv_then_3_0= ruleExpression ) ) otherlv_4= Else ( (lv_else_5_0= ruleExpression ) ) ) |
2325 | // InternalSolverLanguage.g:836:3: otherlv_0= 'if' ( (lv_condition_1_0= ruleExpression ) ) otherlv_2= 'then' ( (lv_then_3_0= ruleExpression ) ) otherlv_4= 'else' ( (lv_else_5_0= ruleExpression ) ) | 2100 | // InternalSolverLanguageParser.g:825:3: otherlv_0= If ( (lv_condition_1_0= ruleExpression ) ) otherlv_2= Then ( (lv_then_3_0= ruleExpression ) ) otherlv_4= Else ( (lv_else_5_0= ruleExpression ) ) |
2326 | { | 2101 | { |
2327 | otherlv_0=(Token)match(input,23,FOLLOW_6); if (state.failed) return current; | 2102 | otherlv_0=(Token)match(input,If,FOLLOW_6); |
2328 | if ( state.backtracking==0 ) { | ||
2329 | 2103 | ||
2330 | newLeafNode(otherlv_0, grammarAccess.getIfElseAccess().getIfKeyword_0()); | 2104 | newLeafNode(otherlv_0, grammarAccess.getIfElseAccess().getIfKeyword_0()); |
2331 | 2105 | ||
2332 | } | 2106 | // InternalSolverLanguageParser.g:829:3: ( (lv_condition_1_0= ruleExpression ) ) |
2333 | // InternalSolverLanguage.g:840:3: ( (lv_condition_1_0= ruleExpression ) ) | 2107 | // InternalSolverLanguageParser.g:830:4: (lv_condition_1_0= ruleExpression ) |
2334 | // InternalSolverLanguage.g:841:4: (lv_condition_1_0= ruleExpression ) | ||
2335 | { | 2108 | { |
2336 | // InternalSolverLanguage.g:841:4: (lv_condition_1_0= ruleExpression ) | 2109 | // InternalSolverLanguageParser.g:830:4: (lv_condition_1_0= ruleExpression ) |
2337 | // InternalSolverLanguage.g:842:5: lv_condition_1_0= ruleExpression | 2110 | // InternalSolverLanguageParser.g:831:5: lv_condition_1_0= ruleExpression |
2338 | { | 2111 | { |
2339 | if ( state.backtracking==0 ) { | ||
2340 | 2112 | ||
2341 | newCompositeNode(grammarAccess.getIfElseAccess().getConditionExpressionParserRuleCall_1_0()); | 2113 | newCompositeNode(grammarAccess.getIfElseAccess().getConditionExpressionParserRuleCall_1_0()); |
2342 | 2114 | ||
2343 | } | ||
2344 | pushFollow(FOLLOW_15); | 2115 | pushFollow(FOLLOW_15); |
2345 | lv_condition_1_0=ruleExpression(); | 2116 | lv_condition_1_0=ruleExpression(); |
2346 | 2117 | ||
2347 | state._fsp--; | 2118 | state._fsp--; |
2348 | if (state.failed) return current; | ||
2349 | if ( state.backtracking==0 ) { | ||
2350 | 2119 | ||
2351 | if (current==null) { | 2120 | |
2352 | current = createModelElementForParent(grammarAccess.getIfElseRule()); | 2121 | if (current==null) { |
2353 | } | 2122 | current = createModelElementForParent(grammarAccess.getIfElseRule()); |
2354 | set( | 2123 | } |
2355 | current, | 2124 | set( |
2356 | "condition", | 2125 | current, |
2357 | lv_condition_1_0, | 2126 | "condition", |
2358 | "org.eclipse.viatra.solver.language.SolverLanguage.Expression"); | 2127 | lv_condition_1_0, |
2359 | afterParserOrEnumRuleCall(); | 2128 | "org.eclipse.viatra.solver.language.SolverLanguage.Expression"); |
2360 | 2129 | afterParserOrEnumRuleCall(); | |
2361 | } | 2130 | |
2362 | 2131 | ||
2363 | } | 2132 | } |
2364 | 2133 | ||
2365 | 2134 | ||
2366 | } | 2135 | } |
2367 | 2136 | ||
2368 | otherlv_2=(Token)match(input,24,FOLLOW_6); if (state.failed) return current; | 2137 | otherlv_2=(Token)match(input,Then,FOLLOW_6); |
2369 | if ( state.backtracking==0 ) { | ||
2370 | 2138 | ||
2371 | newLeafNode(otherlv_2, grammarAccess.getIfElseAccess().getThenKeyword_2()); | 2139 | newLeafNode(otherlv_2, grammarAccess.getIfElseAccess().getThenKeyword_2()); |
2372 | 2140 | ||
2373 | } | 2141 | // InternalSolverLanguageParser.g:852:3: ( (lv_then_3_0= ruleExpression ) ) |
2374 | // InternalSolverLanguage.g:863:3: ( (lv_then_3_0= ruleExpression ) ) | 2142 | // InternalSolverLanguageParser.g:853:4: (lv_then_3_0= ruleExpression ) |
2375 | // InternalSolverLanguage.g:864:4: (lv_then_3_0= ruleExpression ) | ||
2376 | { | 2143 | { |
2377 | // InternalSolverLanguage.g:864:4: (lv_then_3_0= ruleExpression ) | 2144 | // InternalSolverLanguageParser.g:853:4: (lv_then_3_0= ruleExpression ) |
2378 | // InternalSolverLanguage.g:865:5: lv_then_3_0= ruleExpression | 2145 | // InternalSolverLanguageParser.g:854:5: lv_then_3_0= ruleExpression |
2379 | { | 2146 | { |
2380 | if ( state.backtracking==0 ) { | ||
2381 | 2147 | ||
2382 | newCompositeNode(grammarAccess.getIfElseAccess().getThenExpressionParserRuleCall_3_0()); | 2148 | newCompositeNode(grammarAccess.getIfElseAccess().getThenExpressionParserRuleCall_3_0()); |
2383 | 2149 | ||
2384 | } | ||
2385 | pushFollow(FOLLOW_16); | 2150 | pushFollow(FOLLOW_16); |
2386 | lv_then_3_0=ruleExpression(); | 2151 | lv_then_3_0=ruleExpression(); |
2387 | 2152 | ||
2388 | state._fsp--; | 2153 | state._fsp--; |
2389 | if (state.failed) return current; | ||
2390 | if ( state.backtracking==0 ) { | ||
2391 | 2154 | ||
2392 | if (current==null) { | 2155 | |
2393 | current = createModelElementForParent(grammarAccess.getIfElseRule()); | 2156 | if (current==null) { |
2394 | } | 2157 | current = createModelElementForParent(grammarAccess.getIfElseRule()); |
2395 | set( | 2158 | } |
2396 | current, | 2159 | set( |
2397 | "then", | 2160 | current, |
2398 | lv_then_3_0, | 2161 | "then", |
2399 | "org.eclipse.viatra.solver.language.SolverLanguage.Expression"); | 2162 | lv_then_3_0, |
2400 | afterParserOrEnumRuleCall(); | 2163 | "org.eclipse.viatra.solver.language.SolverLanguage.Expression"); |
2401 | 2164 | afterParserOrEnumRuleCall(); | |
2402 | } | 2165 | |
2403 | 2166 | ||
2404 | } | 2167 | } |
2405 | 2168 | ||
2406 | 2169 | ||
2407 | } | 2170 | } |
2408 | 2171 | ||
2409 | otherlv_4=(Token)match(input,25,FOLLOW_6); if (state.failed) return current; | 2172 | otherlv_4=(Token)match(input,Else,FOLLOW_6); |
2410 | if ( state.backtracking==0 ) { | ||
2411 | 2173 | ||
2412 | newLeafNode(otherlv_4, grammarAccess.getIfElseAccess().getElseKeyword_4()); | 2174 | newLeafNode(otherlv_4, grammarAccess.getIfElseAccess().getElseKeyword_4()); |
2413 | 2175 | ||
2414 | } | 2176 | // InternalSolverLanguageParser.g:875:3: ( (lv_else_5_0= ruleExpression ) ) |
2415 | // InternalSolverLanguage.g:886:3: ( (lv_else_5_0= ruleExpression ) ) | 2177 | // InternalSolverLanguageParser.g:876:4: (lv_else_5_0= ruleExpression ) |
2416 | // InternalSolverLanguage.g:887:4: (lv_else_5_0= ruleExpression ) | ||
2417 | { | 2178 | { |
2418 | // InternalSolverLanguage.g:887:4: (lv_else_5_0= ruleExpression ) | 2179 | // InternalSolverLanguageParser.g:876:4: (lv_else_5_0= ruleExpression ) |
2419 | // InternalSolverLanguage.g:888:5: lv_else_5_0= ruleExpression | 2180 | // InternalSolverLanguageParser.g:877:5: lv_else_5_0= ruleExpression |
2420 | { | 2181 | { |
2421 | if ( state.backtracking==0 ) { | ||
2422 | 2182 | ||
2423 | newCompositeNode(grammarAccess.getIfElseAccess().getElseExpressionParserRuleCall_5_0()); | 2183 | newCompositeNode(grammarAccess.getIfElseAccess().getElseExpressionParserRuleCall_5_0()); |
2424 | 2184 | ||
2425 | } | ||
2426 | pushFollow(FOLLOW_2); | 2185 | pushFollow(FOLLOW_2); |
2427 | lv_else_5_0=ruleExpression(); | 2186 | lv_else_5_0=ruleExpression(); |
2428 | 2187 | ||
2429 | state._fsp--; | 2188 | state._fsp--; |
2430 | if (state.failed) return current; | ||
2431 | if ( state.backtracking==0 ) { | ||
2432 | 2189 | ||
2433 | if (current==null) { | 2190 | |
2434 | current = createModelElementForParent(grammarAccess.getIfElseRule()); | 2191 | if (current==null) { |
2435 | } | 2192 | current = createModelElementForParent(grammarAccess.getIfElseRule()); |
2436 | set( | 2193 | } |
2437 | current, | 2194 | set( |
2438 | "else", | 2195 | current, |
2439 | lv_else_5_0, | 2196 | "else", |
2440 | "org.eclipse.viatra.solver.language.SolverLanguage.Expression"); | 2197 | lv_else_5_0, |
2441 | afterParserOrEnumRuleCall(); | 2198 | "org.eclipse.viatra.solver.language.SolverLanguage.Expression"); |
2442 | 2199 | afterParserOrEnumRuleCall(); | |
2443 | } | 2200 | |
2444 | 2201 | ||
2445 | } | 2202 | } |
2446 | 2203 | ||
@@ -2453,11 +2210,9 @@ public class InternalSolverLanguageParser extends AbstractInternalAntlrParser { | |||
2453 | 2210 | ||
2454 | } | 2211 | } |
2455 | 2212 | ||
2456 | if ( state.backtracking==0 ) { | ||
2457 | 2213 | ||
2458 | leaveRule(); | 2214 | leaveRule(); |
2459 | 2215 | ||
2460 | } | ||
2461 | } | 2216 | } |
2462 | 2217 | ||
2463 | catch (RecognitionException re) { | 2218 | catch (RecognitionException re) { |
@@ -2472,7 +2227,7 @@ public class InternalSolverLanguageParser extends AbstractInternalAntlrParser { | |||
2472 | 2227 | ||
2473 | 2228 | ||
2474 | // $ANTLR start "entryRuleDisjunctiveExpression" | 2229 | // $ANTLR start "entryRuleDisjunctiveExpression" |
2475 | // InternalSolverLanguage.g:909:1: entryRuleDisjunctiveExpression returns [EObject current=null] : iv_ruleDisjunctiveExpression= ruleDisjunctiveExpression EOF ; | 2230 | // InternalSolverLanguageParser.g:898:1: entryRuleDisjunctiveExpression returns [EObject current=null] : iv_ruleDisjunctiveExpression= ruleDisjunctiveExpression EOF ; |
2476 | public final EObject entryRuleDisjunctiveExpression() throws RecognitionException { | 2231 | public final EObject entryRuleDisjunctiveExpression() throws RecognitionException { |
2477 | EObject current = null; | 2232 | EObject current = null; |
2478 | 2233 | ||
@@ -2480,21 +2235,17 @@ public class InternalSolverLanguageParser extends AbstractInternalAntlrParser { | |||
2480 | 2235 | ||
2481 | 2236 | ||
2482 | try { | 2237 | try { |
2483 | // InternalSolverLanguage.g:909:62: (iv_ruleDisjunctiveExpression= ruleDisjunctiveExpression EOF ) | 2238 | // InternalSolverLanguageParser.g:898:62: (iv_ruleDisjunctiveExpression= ruleDisjunctiveExpression EOF ) |
2484 | // InternalSolverLanguage.g:910:2: iv_ruleDisjunctiveExpression= ruleDisjunctiveExpression EOF | 2239 | // InternalSolverLanguageParser.g:899:2: iv_ruleDisjunctiveExpression= ruleDisjunctiveExpression EOF |
2485 | { | 2240 | { |
2486 | if ( state.backtracking==0 ) { | 2241 | newCompositeNode(grammarAccess.getDisjunctiveExpressionRule()); |
2487 | newCompositeNode(grammarAccess.getDisjunctiveExpressionRule()); | ||
2488 | } | ||
2489 | pushFollow(FOLLOW_1); | 2242 | pushFollow(FOLLOW_1); |
2490 | iv_ruleDisjunctiveExpression=ruleDisjunctiveExpression(); | 2243 | iv_ruleDisjunctiveExpression=ruleDisjunctiveExpression(); |
2491 | 2244 | ||
2492 | state._fsp--; | 2245 | state._fsp--; |
2493 | if (state.failed) return current; | 2246 | |
2494 | if ( state.backtracking==0 ) { | 2247 | current =iv_ruleDisjunctiveExpression; |
2495 | current =iv_ruleDisjunctiveExpression; | 2248 | match(input,EOF,FOLLOW_2); |
2496 | } | ||
2497 | match(input,EOF,FOLLOW_2); if (state.failed) return current; | ||
2498 | 2249 | ||
2499 | } | 2250 | } |
2500 | 2251 | ||
@@ -2512,7 +2263,7 @@ public class InternalSolverLanguageParser extends AbstractInternalAntlrParser { | |||
2512 | 2263 | ||
2513 | 2264 | ||
2514 | // $ANTLR start "ruleDisjunctiveExpression" | 2265 | // $ANTLR start "ruleDisjunctiveExpression" |
2515 | // InternalSolverLanguage.g:916:1: ruleDisjunctiveExpression returns [EObject current=null] : (this_ConjunctiveExpression_0= ruleConjunctiveExpression ( ( () (otherlv_2= ';' ( (lv_children_3_0= ruleConjunctiveExpression ) ) )+ ) | ( () otherlv_5= '->' ( (lv_body_6_0= ruleConjunctiveExpression ) ) () (otherlv_8= ';' ( (lv_cases_9_0= ruleCase ) ) )* ) )? ) ; | 2266 | // InternalSolverLanguageParser.g:905:1: ruleDisjunctiveExpression returns [EObject current=null] : (this_ConjunctiveExpression_0= ruleConjunctiveExpression ( ( () (otherlv_2= Semicolon ( (lv_children_3_0= ruleConjunctiveExpression ) ) )+ ) | ( () otherlv_5= HyphenMinusGreaterThanSign ( (lv_body_6_0= ruleConjunctiveExpression ) ) () (otherlv_8= Semicolon ( (lv_cases_9_0= ruleCase ) ) )* ) )? ) ; |
2516 | public final EObject ruleDisjunctiveExpression() throws RecognitionException { | 2267 | public final EObject ruleDisjunctiveExpression() throws RecognitionException { |
2517 | EObject current = null; | 2268 | EObject current = null; |
2518 | 2269 | ||
@@ -2532,109 +2283,97 @@ public class InternalSolverLanguageParser extends AbstractInternalAntlrParser { | |||
2532 | enterRule(); | 2283 | enterRule(); |
2533 | 2284 | ||
2534 | try { | 2285 | try { |
2535 | // InternalSolverLanguage.g:922:2: ( (this_ConjunctiveExpression_0= ruleConjunctiveExpression ( ( () (otherlv_2= ';' ( (lv_children_3_0= ruleConjunctiveExpression ) ) )+ ) | ( () otherlv_5= '->' ( (lv_body_6_0= ruleConjunctiveExpression ) ) () (otherlv_8= ';' ( (lv_cases_9_0= ruleCase ) ) )* ) )? ) ) | 2286 | // InternalSolverLanguageParser.g:911:2: ( (this_ConjunctiveExpression_0= ruleConjunctiveExpression ( ( () (otherlv_2= Semicolon ( (lv_children_3_0= ruleConjunctiveExpression ) ) )+ ) | ( () otherlv_5= HyphenMinusGreaterThanSign ( (lv_body_6_0= ruleConjunctiveExpression ) ) () (otherlv_8= Semicolon ( (lv_cases_9_0= ruleCase ) ) )* ) )? ) ) |
2536 | // InternalSolverLanguage.g:923:2: (this_ConjunctiveExpression_0= ruleConjunctiveExpression ( ( () (otherlv_2= ';' ( (lv_children_3_0= ruleConjunctiveExpression ) ) )+ ) | ( () otherlv_5= '->' ( (lv_body_6_0= ruleConjunctiveExpression ) ) () (otherlv_8= ';' ( (lv_cases_9_0= ruleCase ) ) )* ) )? ) | 2287 | // InternalSolverLanguageParser.g:912:2: (this_ConjunctiveExpression_0= ruleConjunctiveExpression ( ( () (otherlv_2= Semicolon ( (lv_children_3_0= ruleConjunctiveExpression ) ) )+ ) | ( () otherlv_5= HyphenMinusGreaterThanSign ( (lv_body_6_0= ruleConjunctiveExpression ) ) () (otherlv_8= Semicolon ( (lv_cases_9_0= ruleCase ) ) )* ) )? ) |
2537 | { | 2288 | { |
2538 | // InternalSolverLanguage.g:923:2: (this_ConjunctiveExpression_0= ruleConjunctiveExpression ( ( () (otherlv_2= ';' ( (lv_children_3_0= ruleConjunctiveExpression ) ) )+ ) | ( () otherlv_5= '->' ( (lv_body_6_0= ruleConjunctiveExpression ) ) () (otherlv_8= ';' ( (lv_cases_9_0= ruleCase ) ) )* ) )? ) | 2289 | // InternalSolverLanguageParser.g:912:2: (this_ConjunctiveExpression_0= ruleConjunctiveExpression ( ( () (otherlv_2= Semicolon ( (lv_children_3_0= ruleConjunctiveExpression ) ) )+ ) | ( () otherlv_5= HyphenMinusGreaterThanSign ( (lv_body_6_0= ruleConjunctiveExpression ) ) () (otherlv_8= Semicolon ( (lv_cases_9_0= ruleCase ) ) )* ) )? ) |
2539 | // InternalSolverLanguage.g:924:3: this_ConjunctiveExpression_0= ruleConjunctiveExpression ( ( () (otherlv_2= ';' ( (lv_children_3_0= ruleConjunctiveExpression ) ) )+ ) | ( () otherlv_5= '->' ( (lv_body_6_0= ruleConjunctiveExpression ) ) () (otherlv_8= ';' ( (lv_cases_9_0= ruleCase ) ) )* ) )? | 2290 | // InternalSolverLanguageParser.g:913:3: this_ConjunctiveExpression_0= ruleConjunctiveExpression ( ( () (otherlv_2= Semicolon ( (lv_children_3_0= ruleConjunctiveExpression ) ) )+ ) | ( () otherlv_5= HyphenMinusGreaterThanSign ( (lv_body_6_0= ruleConjunctiveExpression ) ) () (otherlv_8= Semicolon ( (lv_cases_9_0= ruleCase ) ) )* ) )? |
2540 | { | 2291 | { |
2541 | if ( state.backtracking==0 ) { | ||
2542 | 2292 | ||
2543 | newCompositeNode(grammarAccess.getDisjunctiveExpressionAccess().getConjunctiveExpressionParserRuleCall_0()); | 2293 | newCompositeNode(grammarAccess.getDisjunctiveExpressionAccess().getConjunctiveExpressionParserRuleCall_0()); |
2544 | 2294 | ||
2545 | } | ||
2546 | pushFollow(FOLLOW_17); | 2295 | pushFollow(FOLLOW_17); |
2547 | this_ConjunctiveExpression_0=ruleConjunctiveExpression(); | 2296 | this_ConjunctiveExpression_0=ruleConjunctiveExpression(); |
2548 | 2297 | ||
2549 | state._fsp--; | 2298 | state._fsp--; |
2550 | if (state.failed) return current; | ||
2551 | if ( state.backtracking==0 ) { | ||
2552 | 2299 | ||
2553 | current = this_ConjunctiveExpression_0; | 2300 | |
2554 | afterParserOrEnumRuleCall(); | 2301 | current = this_ConjunctiveExpression_0; |
2555 | 2302 | afterParserOrEnumRuleCall(); | |
2556 | } | 2303 | |
2557 | // InternalSolverLanguage.g:932:3: ( ( () (otherlv_2= ';' ( (lv_children_3_0= ruleConjunctiveExpression ) ) )+ ) | ( () otherlv_5= '->' ( (lv_body_6_0= ruleConjunctiveExpression ) ) () (otherlv_8= ';' ( (lv_cases_9_0= ruleCase ) ) )* ) )? | 2304 | // InternalSolverLanguageParser.g:921:3: ( ( () (otherlv_2= Semicolon ( (lv_children_3_0= ruleConjunctiveExpression ) ) )+ ) | ( () otherlv_5= HyphenMinusGreaterThanSign ( (lv_body_6_0= ruleConjunctiveExpression ) ) () (otherlv_8= Semicolon ( (lv_cases_9_0= ruleCase ) ) )* ) )? |
2558 | int alt11=3; | 2305 | int alt11=3; |
2559 | int LA11_0 = input.LA(1); | 2306 | int LA11_0 = input.LA(1); |
2560 | 2307 | ||
2561 | if ( (LA11_0==26) ) { | 2308 | if ( (LA11_0==Semicolon) ) { |
2562 | alt11=1; | 2309 | alt11=1; |
2563 | } | 2310 | } |
2564 | else if ( (LA11_0==27) ) { | 2311 | else if ( (LA11_0==HyphenMinusGreaterThanSign) ) { |
2565 | alt11=2; | 2312 | alt11=2; |
2566 | } | 2313 | } |
2567 | switch (alt11) { | 2314 | switch (alt11) { |
2568 | case 1 : | 2315 | case 1 : |
2569 | // InternalSolverLanguage.g:933:4: ( () (otherlv_2= ';' ( (lv_children_3_0= ruleConjunctiveExpression ) ) )+ ) | 2316 | // InternalSolverLanguageParser.g:922:4: ( () (otherlv_2= Semicolon ( (lv_children_3_0= ruleConjunctiveExpression ) ) )+ ) |
2570 | { | 2317 | { |
2571 | // InternalSolverLanguage.g:933:4: ( () (otherlv_2= ';' ( (lv_children_3_0= ruleConjunctiveExpression ) ) )+ ) | 2318 | // InternalSolverLanguageParser.g:922:4: ( () (otherlv_2= Semicolon ( (lv_children_3_0= ruleConjunctiveExpression ) ) )+ ) |
2572 | // InternalSolverLanguage.g:934:5: () (otherlv_2= ';' ( (lv_children_3_0= ruleConjunctiveExpression ) ) )+ | 2319 | // InternalSolverLanguageParser.g:923:5: () (otherlv_2= Semicolon ( (lv_children_3_0= ruleConjunctiveExpression ) ) )+ |
2573 | { | 2320 | { |
2574 | // InternalSolverLanguage.g:934:5: () | 2321 | // InternalSolverLanguageParser.g:923:5: () |
2575 | // InternalSolverLanguage.g:935:6: | 2322 | // InternalSolverLanguageParser.g:924:6: |
2576 | { | 2323 | { |
2577 | if ( state.backtracking==0 ) { | ||
2578 | 2324 | ||
2579 | current = forceCreateModelElementAndAdd( | 2325 | current = forceCreateModelElementAndAdd( |
2580 | grammarAccess.getDisjunctiveExpressionAccess().getDisjunctionChildrenAction_1_0_0(), | 2326 | grammarAccess.getDisjunctiveExpressionAccess().getDisjunctionChildrenAction_1_0_0(), |
2581 | current); | 2327 | current); |
2582 | 2328 | ||
2583 | } | ||
2584 | 2329 | ||
2585 | } | 2330 | } |
2586 | 2331 | ||
2587 | // InternalSolverLanguage.g:941:5: (otherlv_2= ';' ( (lv_children_3_0= ruleConjunctiveExpression ) ) )+ | 2332 | // InternalSolverLanguageParser.g:930:5: (otherlv_2= Semicolon ( (lv_children_3_0= ruleConjunctiveExpression ) ) )+ |
2588 | int cnt9=0; | 2333 | int cnt9=0; |
2589 | loop9: | 2334 | loop9: |
2590 | do { | 2335 | do { |
2591 | int alt9=2; | 2336 | int alt9=2; |
2592 | int LA9_0 = input.LA(1); | 2337 | int LA9_0 = input.LA(1); |
2593 | 2338 | ||
2594 | if ( (LA9_0==26) ) { | 2339 | if ( (LA9_0==Semicolon) ) { |
2595 | alt9=1; | 2340 | alt9=1; |
2596 | } | 2341 | } |
2597 | 2342 | ||
2598 | 2343 | ||
2599 | switch (alt9) { | 2344 | switch (alt9) { |
2600 | case 1 : | 2345 | case 1 : |
2601 | // InternalSolverLanguage.g:942:6: otherlv_2= ';' ( (lv_children_3_0= ruleConjunctiveExpression ) ) | 2346 | // InternalSolverLanguageParser.g:931:6: otherlv_2= Semicolon ( (lv_children_3_0= ruleConjunctiveExpression ) ) |
2602 | { | 2347 | { |
2603 | otherlv_2=(Token)match(input,26,FOLLOW_6); if (state.failed) return current; | 2348 | otherlv_2=(Token)match(input,Semicolon,FOLLOW_6); |
2604 | if ( state.backtracking==0 ) { | ||
2605 | 2349 | ||
2606 | newLeafNode(otherlv_2, grammarAccess.getDisjunctiveExpressionAccess().getSemicolonKeyword_1_0_1_0()); | 2350 | newLeafNode(otherlv_2, grammarAccess.getDisjunctiveExpressionAccess().getSemicolonKeyword_1_0_1_0()); |
2607 | 2351 | ||
2608 | } | 2352 | // InternalSolverLanguageParser.g:935:6: ( (lv_children_3_0= ruleConjunctiveExpression ) ) |
2609 | // InternalSolverLanguage.g:946:6: ( (lv_children_3_0= ruleConjunctiveExpression ) ) | 2353 | // InternalSolverLanguageParser.g:936:7: (lv_children_3_0= ruleConjunctiveExpression ) |
2610 | // InternalSolverLanguage.g:947:7: (lv_children_3_0= ruleConjunctiveExpression ) | ||
2611 | { | 2354 | { |
2612 | // InternalSolverLanguage.g:947:7: (lv_children_3_0= ruleConjunctiveExpression ) | 2355 | // InternalSolverLanguageParser.g:936:7: (lv_children_3_0= ruleConjunctiveExpression ) |
2613 | // InternalSolverLanguage.g:948:8: lv_children_3_0= ruleConjunctiveExpression | 2356 | // InternalSolverLanguageParser.g:937:8: lv_children_3_0= ruleConjunctiveExpression |
2614 | { | 2357 | { |
2615 | if ( state.backtracking==0 ) { | ||
2616 | 2358 | ||
2617 | newCompositeNode(grammarAccess.getDisjunctiveExpressionAccess().getChildrenConjunctiveExpressionParserRuleCall_1_0_1_1_0()); | 2359 | newCompositeNode(grammarAccess.getDisjunctiveExpressionAccess().getChildrenConjunctiveExpressionParserRuleCall_1_0_1_1_0()); |
2618 | 2360 | ||
2619 | } | ||
2620 | pushFollow(FOLLOW_18); | 2361 | pushFollow(FOLLOW_18); |
2621 | lv_children_3_0=ruleConjunctiveExpression(); | 2362 | lv_children_3_0=ruleConjunctiveExpression(); |
2622 | 2363 | ||
2623 | state._fsp--; | 2364 | state._fsp--; |
2624 | if (state.failed) return current; | 2365 | |
2625 | if ( state.backtracking==0 ) { | 2366 | |
2626 | 2367 | if (current==null) { | |
2627 | if (current==null) { | 2368 | current = createModelElementForParent(grammarAccess.getDisjunctiveExpressionRule()); |
2628 | current = createModelElementForParent(grammarAccess.getDisjunctiveExpressionRule()); | 2369 | } |
2629 | } | 2370 | add( |
2630 | add( | 2371 | current, |
2631 | current, | 2372 | "children", |
2632 | "children", | 2373 | lv_children_3_0, |
2633 | lv_children_3_0, | 2374 | "org.eclipse.viatra.solver.language.SolverLanguage.ConjunctiveExpression"); |
2634 | "org.eclipse.viatra.solver.language.SolverLanguage.ConjunctiveExpression"); | 2375 | afterParserOrEnumRuleCall(); |
2635 | afterParserOrEnumRuleCall(); | 2376 | |
2636 | |||
2637 | } | ||
2638 | 2377 | ||
2639 | } | 2378 | } |
2640 | 2379 | ||
@@ -2647,7 +2386,6 @@ public class InternalSolverLanguageParser extends AbstractInternalAntlrParser { | |||
2647 | 2386 | ||
2648 | default : | 2387 | default : |
2649 | if ( cnt9 >= 1 ) break loop9; | 2388 | if ( cnt9 >= 1 ) break loop9; |
2650 | if (state.backtracking>0) {state.failed=true; return current;} | ||
2651 | EarlyExitException eee = | 2389 | EarlyExitException eee = |
2652 | new EarlyExitException(9, input); | 2390 | new EarlyExitException(9, input); |
2653 | throw eee; | 2391 | throw eee; |
@@ -2662,128 +2400,112 @@ public class InternalSolverLanguageParser extends AbstractInternalAntlrParser { | |||
2662 | } | 2400 | } |
2663 | break; | 2401 | break; |
2664 | case 2 : | 2402 | case 2 : |
2665 | // InternalSolverLanguage.g:968:4: ( () otherlv_5= '->' ( (lv_body_6_0= ruleConjunctiveExpression ) ) () (otherlv_8= ';' ( (lv_cases_9_0= ruleCase ) ) )* ) | 2403 | // InternalSolverLanguageParser.g:957:4: ( () otherlv_5= HyphenMinusGreaterThanSign ( (lv_body_6_0= ruleConjunctiveExpression ) ) () (otherlv_8= Semicolon ( (lv_cases_9_0= ruleCase ) ) )* ) |
2666 | { | 2404 | { |
2667 | // InternalSolverLanguage.g:968:4: ( () otherlv_5= '->' ( (lv_body_6_0= ruleConjunctiveExpression ) ) () (otherlv_8= ';' ( (lv_cases_9_0= ruleCase ) ) )* ) | 2405 | // InternalSolverLanguageParser.g:957:4: ( () otherlv_5= HyphenMinusGreaterThanSign ( (lv_body_6_0= ruleConjunctiveExpression ) ) () (otherlv_8= Semicolon ( (lv_cases_9_0= ruleCase ) ) )* ) |
2668 | // InternalSolverLanguage.g:969:5: () otherlv_5= '->' ( (lv_body_6_0= ruleConjunctiveExpression ) ) () (otherlv_8= ';' ( (lv_cases_9_0= ruleCase ) ) )* | 2406 | // InternalSolverLanguageParser.g:958:5: () otherlv_5= HyphenMinusGreaterThanSign ( (lv_body_6_0= ruleConjunctiveExpression ) ) () (otherlv_8= Semicolon ( (lv_cases_9_0= ruleCase ) ) )* |
2669 | { | 2407 | { |
2670 | // InternalSolverLanguage.g:969:5: () | 2408 | // InternalSolverLanguageParser.g:958:5: () |
2671 | // InternalSolverLanguage.g:970:6: | 2409 | // InternalSolverLanguageParser.g:959:6: |
2672 | { | 2410 | { |
2673 | if ( state.backtracking==0 ) { | ||
2674 | 2411 | ||
2675 | current = forceCreateModelElementAndSet( | 2412 | current = forceCreateModelElementAndSet( |
2676 | grammarAccess.getDisjunctiveExpressionAccess().getCaseConditionAction_1_1_0(), | 2413 | grammarAccess.getDisjunctiveExpressionAccess().getCaseConditionAction_1_1_0(), |
2677 | current); | 2414 | current); |
2678 | 2415 | ||
2679 | } | ||
2680 | 2416 | ||
2681 | } | 2417 | } |
2682 | 2418 | ||
2683 | otherlv_5=(Token)match(input,27,FOLLOW_6); if (state.failed) return current; | 2419 | otherlv_5=(Token)match(input,HyphenMinusGreaterThanSign,FOLLOW_6); |
2684 | if ( state.backtracking==0 ) { | ||
2685 | 2420 | ||
2686 | newLeafNode(otherlv_5, grammarAccess.getDisjunctiveExpressionAccess().getHyphenMinusGreaterThanSignKeyword_1_1_1()); | 2421 | newLeafNode(otherlv_5, grammarAccess.getDisjunctiveExpressionAccess().getHyphenMinusGreaterThanSignKeyword_1_1_1()); |
2687 | 2422 | ||
2688 | } | 2423 | // InternalSolverLanguageParser.g:969:5: ( (lv_body_6_0= ruleConjunctiveExpression ) ) |
2689 | // InternalSolverLanguage.g:980:5: ( (lv_body_6_0= ruleConjunctiveExpression ) ) | 2424 | // InternalSolverLanguageParser.g:970:6: (lv_body_6_0= ruleConjunctiveExpression ) |
2690 | // InternalSolverLanguage.g:981:6: (lv_body_6_0= ruleConjunctiveExpression ) | ||
2691 | { | 2425 | { |
2692 | // InternalSolverLanguage.g:981:6: (lv_body_6_0= ruleConjunctiveExpression ) | 2426 | // InternalSolverLanguageParser.g:970:6: (lv_body_6_0= ruleConjunctiveExpression ) |
2693 | // InternalSolverLanguage.g:982:7: lv_body_6_0= ruleConjunctiveExpression | 2427 | // InternalSolverLanguageParser.g:971:7: lv_body_6_0= ruleConjunctiveExpression |
2694 | { | 2428 | { |
2695 | if ( state.backtracking==0 ) { | ||
2696 | 2429 | ||
2697 | newCompositeNode(grammarAccess.getDisjunctiveExpressionAccess().getBodyConjunctiveExpressionParserRuleCall_1_1_2_0()); | 2430 | newCompositeNode(grammarAccess.getDisjunctiveExpressionAccess().getBodyConjunctiveExpressionParserRuleCall_1_1_2_0()); |
2698 | 2431 | ||
2699 | } | ||
2700 | pushFollow(FOLLOW_18); | 2432 | pushFollow(FOLLOW_18); |
2701 | lv_body_6_0=ruleConjunctiveExpression(); | 2433 | lv_body_6_0=ruleConjunctiveExpression(); |
2702 | 2434 | ||
2703 | state._fsp--; | 2435 | state._fsp--; |
2704 | if (state.failed) return current; | ||
2705 | if ( state.backtracking==0 ) { | ||
2706 | 2436 | ||
2707 | if (current==null) { | 2437 | |
2708 | current = createModelElementForParent(grammarAccess.getDisjunctiveExpressionRule()); | 2438 | if (current==null) { |
2709 | } | 2439 | current = createModelElementForParent(grammarAccess.getDisjunctiveExpressionRule()); |
2710 | set( | 2440 | } |
2711 | current, | 2441 | set( |
2712 | "body", | 2442 | current, |
2713 | lv_body_6_0, | 2443 | "body", |
2714 | "org.eclipse.viatra.solver.language.SolverLanguage.ConjunctiveExpression"); | 2444 | lv_body_6_0, |
2715 | afterParserOrEnumRuleCall(); | 2445 | "org.eclipse.viatra.solver.language.SolverLanguage.ConjunctiveExpression"); |
2716 | 2446 | afterParserOrEnumRuleCall(); | |
2717 | } | 2447 | |
2718 | 2448 | ||
2719 | } | 2449 | } |
2720 | 2450 | ||
2721 | 2451 | ||
2722 | } | 2452 | } |
2723 | 2453 | ||
2724 | // InternalSolverLanguage.g:999:5: () | 2454 | // InternalSolverLanguageParser.g:988:5: () |
2725 | // InternalSolverLanguage.g:1000:6: | 2455 | // InternalSolverLanguageParser.g:989:6: |
2726 | { | 2456 | { |
2727 | if ( state.backtracking==0 ) { | ||
2728 | 2457 | ||
2729 | current = forceCreateModelElementAndAdd( | 2458 | current = forceCreateModelElementAndAdd( |
2730 | grammarAccess.getDisjunctiveExpressionAccess().getSwitchCasesAction_1_1_3(), | 2459 | grammarAccess.getDisjunctiveExpressionAccess().getSwitchCasesAction_1_1_3(), |
2731 | current); | 2460 | current); |
2732 | 2461 | ||
2733 | } | ||
2734 | 2462 | ||
2735 | } | 2463 | } |
2736 | 2464 | ||
2737 | // InternalSolverLanguage.g:1006:5: (otherlv_8= ';' ( (lv_cases_9_0= ruleCase ) ) )* | 2465 | // InternalSolverLanguageParser.g:995:5: (otherlv_8= Semicolon ( (lv_cases_9_0= ruleCase ) ) )* |
2738 | loop10: | 2466 | loop10: |
2739 | do { | 2467 | do { |
2740 | int alt10=2; | 2468 | int alt10=2; |
2741 | int LA10_0 = input.LA(1); | 2469 | int LA10_0 = input.LA(1); |
2742 | 2470 | ||
2743 | if ( (LA10_0==26) ) { | 2471 | if ( (LA10_0==Semicolon) ) { |
2744 | alt10=1; | 2472 | alt10=1; |
2745 | } | 2473 | } |
2746 | 2474 | ||
2747 | 2475 | ||
2748 | switch (alt10) { | 2476 | switch (alt10) { |
2749 | case 1 : | 2477 | case 1 : |
2750 | // InternalSolverLanguage.g:1007:6: otherlv_8= ';' ( (lv_cases_9_0= ruleCase ) ) | 2478 | // InternalSolverLanguageParser.g:996:6: otherlv_8= Semicolon ( (lv_cases_9_0= ruleCase ) ) |
2751 | { | 2479 | { |
2752 | otherlv_8=(Token)match(input,26,FOLLOW_6); if (state.failed) return current; | 2480 | otherlv_8=(Token)match(input,Semicolon,FOLLOW_6); |
2753 | if ( state.backtracking==0 ) { | ||
2754 | 2481 | ||
2755 | newLeafNode(otherlv_8, grammarAccess.getDisjunctiveExpressionAccess().getSemicolonKeyword_1_1_4_0()); | 2482 | newLeafNode(otherlv_8, grammarAccess.getDisjunctiveExpressionAccess().getSemicolonKeyword_1_1_4_0()); |
2756 | 2483 | ||
2757 | } | 2484 | // InternalSolverLanguageParser.g:1000:6: ( (lv_cases_9_0= ruleCase ) ) |
2758 | // InternalSolverLanguage.g:1011:6: ( (lv_cases_9_0= ruleCase ) ) | 2485 | // InternalSolverLanguageParser.g:1001:7: (lv_cases_9_0= ruleCase ) |
2759 | // InternalSolverLanguage.g:1012:7: (lv_cases_9_0= ruleCase ) | ||
2760 | { | 2486 | { |
2761 | // InternalSolverLanguage.g:1012:7: (lv_cases_9_0= ruleCase ) | 2487 | // InternalSolverLanguageParser.g:1001:7: (lv_cases_9_0= ruleCase ) |
2762 | // InternalSolverLanguage.g:1013:8: lv_cases_9_0= ruleCase | 2488 | // InternalSolverLanguageParser.g:1002:8: lv_cases_9_0= ruleCase |
2763 | { | 2489 | { |
2764 | if ( state.backtracking==0 ) { | ||
2765 | 2490 | ||
2766 | newCompositeNode(grammarAccess.getDisjunctiveExpressionAccess().getCasesCaseParserRuleCall_1_1_4_1_0()); | 2491 | newCompositeNode(grammarAccess.getDisjunctiveExpressionAccess().getCasesCaseParserRuleCall_1_1_4_1_0()); |
2767 | 2492 | ||
2768 | } | ||
2769 | pushFollow(FOLLOW_18); | 2493 | pushFollow(FOLLOW_18); |
2770 | lv_cases_9_0=ruleCase(); | 2494 | lv_cases_9_0=ruleCase(); |
2771 | 2495 | ||
2772 | state._fsp--; | 2496 | state._fsp--; |
2773 | if (state.failed) return current; | 2497 | |
2774 | if ( state.backtracking==0 ) { | 2498 | |
2775 | 2499 | if (current==null) { | |
2776 | if (current==null) { | 2500 | current = createModelElementForParent(grammarAccess.getDisjunctiveExpressionRule()); |
2777 | current = createModelElementForParent(grammarAccess.getDisjunctiveExpressionRule()); | 2501 | } |
2778 | } | 2502 | add( |
2779 | add( | 2503 | current, |
2780 | current, | 2504 | "cases", |
2781 | "cases", | 2505 | lv_cases_9_0, |
2782 | lv_cases_9_0, | 2506 | "org.eclipse.viatra.solver.language.SolverLanguage.Case"); |
2783 | "org.eclipse.viatra.solver.language.SolverLanguage.Case"); | 2507 | afterParserOrEnumRuleCall(); |
2784 | afterParserOrEnumRuleCall(); | 2508 | |
2785 | |||
2786 | } | ||
2787 | 2509 | ||
2788 | } | 2510 | } |
2789 | 2511 | ||
@@ -2814,11 +2536,9 @@ public class InternalSolverLanguageParser extends AbstractInternalAntlrParser { | |||
2814 | 2536 | ||
2815 | } | 2537 | } |
2816 | 2538 | ||
2817 | if ( state.backtracking==0 ) { | ||
2818 | 2539 | ||
2819 | leaveRule(); | 2540 | leaveRule(); |
2820 | 2541 | ||
2821 | } | ||
2822 | } | 2542 | } |
2823 | 2543 | ||
2824 | catch (RecognitionException re) { | 2544 | catch (RecognitionException re) { |
@@ -2833,7 +2553,7 @@ public class InternalSolverLanguageParser extends AbstractInternalAntlrParser { | |||
2833 | 2553 | ||
2834 | 2554 | ||
2835 | // $ANTLR start "entryRuleCase" | 2555 | // $ANTLR start "entryRuleCase" |
2836 | // InternalSolverLanguage.g:1037:1: entryRuleCase returns [EObject current=null] : iv_ruleCase= ruleCase EOF ; | 2556 | // InternalSolverLanguageParser.g:1026:1: entryRuleCase returns [EObject current=null] : iv_ruleCase= ruleCase EOF ; |
2837 | public final EObject entryRuleCase() throws RecognitionException { | 2557 | public final EObject entryRuleCase() throws RecognitionException { |
2838 | EObject current = null; | 2558 | EObject current = null; |
2839 | 2559 | ||
@@ -2841,21 +2561,17 @@ public class InternalSolverLanguageParser extends AbstractInternalAntlrParser { | |||
2841 | 2561 | ||
2842 | 2562 | ||
2843 | try { | 2563 | try { |
2844 | // InternalSolverLanguage.g:1037:45: (iv_ruleCase= ruleCase EOF ) | 2564 | // InternalSolverLanguageParser.g:1026:45: (iv_ruleCase= ruleCase EOF ) |
2845 | // InternalSolverLanguage.g:1038:2: iv_ruleCase= ruleCase EOF | 2565 | // InternalSolverLanguageParser.g:1027:2: iv_ruleCase= ruleCase EOF |
2846 | { | 2566 | { |
2847 | if ( state.backtracking==0 ) { | 2567 | newCompositeNode(grammarAccess.getCaseRule()); |
2848 | newCompositeNode(grammarAccess.getCaseRule()); | ||
2849 | } | ||
2850 | pushFollow(FOLLOW_1); | 2568 | pushFollow(FOLLOW_1); |
2851 | iv_ruleCase=ruleCase(); | 2569 | iv_ruleCase=ruleCase(); |
2852 | 2570 | ||
2853 | state._fsp--; | 2571 | state._fsp--; |
2854 | if (state.failed) return current; | 2572 | |
2855 | if ( state.backtracking==0 ) { | 2573 | current =iv_ruleCase; |
2856 | current =iv_ruleCase; | 2574 | match(input,EOF,FOLLOW_2); |
2857 | } | ||
2858 | match(input,EOF,FOLLOW_2); if (state.failed) return current; | ||
2859 | 2575 | ||
2860 | } | 2576 | } |
2861 | 2577 | ||
@@ -2873,7 +2589,7 @@ public class InternalSolverLanguageParser extends AbstractInternalAntlrParser { | |||
2873 | 2589 | ||
2874 | 2590 | ||
2875 | // $ANTLR start "ruleCase" | 2591 | // $ANTLR start "ruleCase" |
2876 | // InternalSolverLanguage.g:1044:1: ruleCase returns [EObject current=null] : ( ( (lv_condition_0_0= ruleConjunctiveExpression ) ) otherlv_1= '->' ( (lv_body_2_0= ruleConjunctiveExpression ) ) ) ; | 2592 | // InternalSolverLanguageParser.g:1033:1: ruleCase returns [EObject current=null] : ( ( (lv_condition_0_0= ruleConjunctiveExpression ) ) otherlv_1= HyphenMinusGreaterThanSign ( (lv_body_2_0= ruleConjunctiveExpression ) ) ) ; |
2877 | public final EObject ruleCase() throws RecognitionException { | 2593 | public final EObject ruleCase() throws RecognitionException { |
2878 | EObject current = null; | 2594 | EObject current = null; |
2879 | 2595 | ||
@@ -2887,82 +2603,72 @@ public class InternalSolverLanguageParser extends AbstractInternalAntlrParser { | |||
2887 | enterRule(); | 2603 | enterRule(); |
2888 | 2604 | ||
2889 | try { | 2605 | try { |
2890 | // InternalSolverLanguage.g:1050:2: ( ( ( (lv_condition_0_0= ruleConjunctiveExpression ) ) otherlv_1= '->' ( (lv_body_2_0= ruleConjunctiveExpression ) ) ) ) | 2606 | // InternalSolverLanguageParser.g:1039:2: ( ( ( (lv_condition_0_0= ruleConjunctiveExpression ) ) otherlv_1= HyphenMinusGreaterThanSign ( (lv_body_2_0= ruleConjunctiveExpression ) ) ) ) |
2891 | // InternalSolverLanguage.g:1051:2: ( ( (lv_condition_0_0= ruleConjunctiveExpression ) ) otherlv_1= '->' ( (lv_body_2_0= ruleConjunctiveExpression ) ) ) | 2607 | // InternalSolverLanguageParser.g:1040:2: ( ( (lv_condition_0_0= ruleConjunctiveExpression ) ) otherlv_1= HyphenMinusGreaterThanSign ( (lv_body_2_0= ruleConjunctiveExpression ) ) ) |
2892 | { | 2608 | { |
2893 | // InternalSolverLanguage.g:1051:2: ( ( (lv_condition_0_0= ruleConjunctiveExpression ) ) otherlv_1= '->' ( (lv_body_2_0= ruleConjunctiveExpression ) ) ) | 2609 | // InternalSolverLanguageParser.g:1040:2: ( ( (lv_condition_0_0= ruleConjunctiveExpression ) ) otherlv_1= HyphenMinusGreaterThanSign ( (lv_body_2_0= ruleConjunctiveExpression ) ) ) |
2894 | // InternalSolverLanguage.g:1052:3: ( (lv_condition_0_0= ruleConjunctiveExpression ) ) otherlv_1= '->' ( (lv_body_2_0= ruleConjunctiveExpression ) ) | 2610 | // InternalSolverLanguageParser.g:1041:3: ( (lv_condition_0_0= ruleConjunctiveExpression ) ) otherlv_1= HyphenMinusGreaterThanSign ( (lv_body_2_0= ruleConjunctiveExpression ) ) |
2895 | { | 2611 | { |
2896 | // InternalSolverLanguage.g:1052:3: ( (lv_condition_0_0= ruleConjunctiveExpression ) ) | 2612 | // InternalSolverLanguageParser.g:1041:3: ( (lv_condition_0_0= ruleConjunctiveExpression ) ) |
2897 | // InternalSolverLanguage.g:1053:4: (lv_condition_0_0= ruleConjunctiveExpression ) | 2613 | // InternalSolverLanguageParser.g:1042:4: (lv_condition_0_0= ruleConjunctiveExpression ) |
2898 | { | 2614 | { |
2899 | // InternalSolverLanguage.g:1053:4: (lv_condition_0_0= ruleConjunctiveExpression ) | 2615 | // InternalSolverLanguageParser.g:1042:4: (lv_condition_0_0= ruleConjunctiveExpression ) |
2900 | // InternalSolverLanguage.g:1054:5: lv_condition_0_0= ruleConjunctiveExpression | 2616 | // InternalSolverLanguageParser.g:1043:5: lv_condition_0_0= ruleConjunctiveExpression |
2901 | { | 2617 | { |
2902 | if ( state.backtracking==0 ) { | ||
2903 | 2618 | ||
2904 | newCompositeNode(grammarAccess.getCaseAccess().getConditionConjunctiveExpressionParserRuleCall_0_0()); | 2619 | newCompositeNode(grammarAccess.getCaseAccess().getConditionConjunctiveExpressionParserRuleCall_0_0()); |
2905 | 2620 | ||
2906 | } | ||
2907 | pushFollow(FOLLOW_19); | 2621 | pushFollow(FOLLOW_19); |
2908 | lv_condition_0_0=ruleConjunctiveExpression(); | 2622 | lv_condition_0_0=ruleConjunctiveExpression(); |
2909 | 2623 | ||
2910 | state._fsp--; | 2624 | state._fsp--; |
2911 | if (state.failed) return current; | ||
2912 | if ( state.backtracking==0 ) { | ||
2913 | 2625 | ||
2914 | if (current==null) { | 2626 | |
2915 | current = createModelElementForParent(grammarAccess.getCaseRule()); | 2627 | if (current==null) { |
2916 | } | 2628 | current = createModelElementForParent(grammarAccess.getCaseRule()); |
2917 | set( | 2629 | } |
2918 | current, | 2630 | set( |
2919 | "condition", | 2631 | current, |
2920 | lv_condition_0_0, | 2632 | "condition", |
2921 | "org.eclipse.viatra.solver.language.SolverLanguage.ConjunctiveExpression"); | 2633 | lv_condition_0_0, |
2922 | afterParserOrEnumRuleCall(); | 2634 | "org.eclipse.viatra.solver.language.SolverLanguage.ConjunctiveExpression"); |
2923 | 2635 | afterParserOrEnumRuleCall(); | |
2924 | } | 2636 | |
2925 | 2637 | ||
2926 | } | 2638 | } |
2927 | 2639 | ||
2928 | 2640 | ||
2929 | } | 2641 | } |
2930 | 2642 | ||
2931 | otherlv_1=(Token)match(input,27,FOLLOW_6); if (state.failed) return current; | 2643 | otherlv_1=(Token)match(input,HyphenMinusGreaterThanSign,FOLLOW_6); |
2932 | if ( state.backtracking==0 ) { | ||
2933 | 2644 | ||
2934 | newLeafNode(otherlv_1, grammarAccess.getCaseAccess().getHyphenMinusGreaterThanSignKeyword_1()); | 2645 | newLeafNode(otherlv_1, grammarAccess.getCaseAccess().getHyphenMinusGreaterThanSignKeyword_1()); |
2935 | 2646 | ||
2936 | } | 2647 | // InternalSolverLanguageParser.g:1064:3: ( (lv_body_2_0= ruleConjunctiveExpression ) ) |
2937 | // InternalSolverLanguage.g:1075:3: ( (lv_body_2_0= ruleConjunctiveExpression ) ) | 2648 | // InternalSolverLanguageParser.g:1065:4: (lv_body_2_0= ruleConjunctiveExpression ) |
2938 | // InternalSolverLanguage.g:1076:4: (lv_body_2_0= ruleConjunctiveExpression ) | ||
2939 | { | 2649 | { |
2940 | // InternalSolverLanguage.g:1076:4: (lv_body_2_0= ruleConjunctiveExpression ) | 2650 | // InternalSolverLanguageParser.g:1065:4: (lv_body_2_0= ruleConjunctiveExpression ) |
2941 | // InternalSolverLanguage.g:1077:5: lv_body_2_0= ruleConjunctiveExpression | 2651 | // InternalSolverLanguageParser.g:1066:5: lv_body_2_0= ruleConjunctiveExpression |
2942 | { | 2652 | { |
2943 | if ( state.backtracking==0 ) { | ||
2944 | 2653 | ||
2945 | newCompositeNode(grammarAccess.getCaseAccess().getBodyConjunctiveExpressionParserRuleCall_2_0()); | 2654 | newCompositeNode(grammarAccess.getCaseAccess().getBodyConjunctiveExpressionParserRuleCall_2_0()); |
2946 | 2655 | ||
2947 | } | ||
2948 | pushFollow(FOLLOW_2); | 2656 | pushFollow(FOLLOW_2); |
2949 | lv_body_2_0=ruleConjunctiveExpression(); | 2657 | lv_body_2_0=ruleConjunctiveExpression(); |
2950 | 2658 | ||
2951 | state._fsp--; | 2659 | state._fsp--; |
2952 | if (state.failed) return current; | ||
2953 | if ( state.backtracking==0 ) { | ||
2954 | 2660 | ||
2955 | if (current==null) { | 2661 | |
2956 | current = createModelElementForParent(grammarAccess.getCaseRule()); | 2662 | if (current==null) { |
2957 | } | 2663 | current = createModelElementForParent(grammarAccess.getCaseRule()); |
2958 | set( | 2664 | } |
2959 | current, | 2665 | set( |
2960 | "body", | 2666 | current, |
2961 | lv_body_2_0, | 2667 | "body", |
2962 | "org.eclipse.viatra.solver.language.SolverLanguage.ConjunctiveExpression"); | 2668 | lv_body_2_0, |
2963 | afterParserOrEnumRuleCall(); | 2669 | "org.eclipse.viatra.solver.language.SolverLanguage.ConjunctiveExpression"); |
2964 | 2670 | afterParserOrEnumRuleCall(); | |
2965 | } | 2671 | |
2966 | 2672 | ||
2967 | } | 2673 | } |
2968 | 2674 | ||
@@ -2975,11 +2681,9 @@ public class InternalSolverLanguageParser extends AbstractInternalAntlrParser { | |||
2975 | 2681 | ||
2976 | } | 2682 | } |
2977 | 2683 | ||
2978 | if ( state.backtracking==0 ) { | ||
2979 | 2684 | ||
2980 | leaveRule(); | 2685 | leaveRule(); |
2981 | 2686 | ||
2982 | } | ||
2983 | } | 2687 | } |
2984 | 2688 | ||
2985 | catch (RecognitionException re) { | 2689 | catch (RecognitionException re) { |
@@ -2994,7 +2698,7 @@ public class InternalSolverLanguageParser extends AbstractInternalAntlrParser { | |||
2994 | 2698 | ||
2995 | 2699 | ||
2996 | // $ANTLR start "entryRuleConjunctiveExpression" | 2700 | // $ANTLR start "entryRuleConjunctiveExpression" |
2997 | // InternalSolverLanguage.g:1098:1: entryRuleConjunctiveExpression returns [EObject current=null] : iv_ruleConjunctiveExpression= ruleConjunctiveExpression EOF ; | 2701 | // InternalSolverLanguageParser.g:1087:1: entryRuleConjunctiveExpression returns [EObject current=null] : iv_ruleConjunctiveExpression= ruleConjunctiveExpression EOF ; |
2998 | public final EObject entryRuleConjunctiveExpression() throws RecognitionException { | 2702 | public final EObject entryRuleConjunctiveExpression() throws RecognitionException { |
2999 | EObject current = null; | 2703 | EObject current = null; |
3000 | 2704 | ||
@@ -3002,21 +2706,17 @@ public class InternalSolverLanguageParser extends AbstractInternalAntlrParser { | |||
3002 | 2706 | ||
3003 | 2707 | ||
3004 | try { | 2708 | try { |
3005 | // InternalSolverLanguage.g:1098:62: (iv_ruleConjunctiveExpression= ruleConjunctiveExpression EOF ) | 2709 | // InternalSolverLanguageParser.g:1087:62: (iv_ruleConjunctiveExpression= ruleConjunctiveExpression EOF ) |
3006 | // InternalSolverLanguage.g:1099:2: iv_ruleConjunctiveExpression= ruleConjunctiveExpression EOF | 2710 | // InternalSolverLanguageParser.g:1088:2: iv_ruleConjunctiveExpression= ruleConjunctiveExpression EOF |
3007 | { | 2711 | { |
3008 | if ( state.backtracking==0 ) { | 2712 | newCompositeNode(grammarAccess.getConjunctiveExpressionRule()); |
3009 | newCompositeNode(grammarAccess.getConjunctiveExpressionRule()); | ||
3010 | } | ||
3011 | pushFollow(FOLLOW_1); | 2713 | pushFollow(FOLLOW_1); |
3012 | iv_ruleConjunctiveExpression=ruleConjunctiveExpression(); | 2714 | iv_ruleConjunctiveExpression=ruleConjunctiveExpression(); |
3013 | 2715 | ||
3014 | state._fsp--; | 2716 | state._fsp--; |
3015 | if (state.failed) return current; | 2717 | |
3016 | if ( state.backtracking==0 ) { | 2718 | current =iv_ruleConjunctiveExpression; |
3017 | current =iv_ruleConjunctiveExpression; | 2719 | match(input,EOF,FOLLOW_2); |
3018 | } | ||
3019 | match(input,EOF,FOLLOW_2); if (state.failed) return current; | ||
3020 | 2720 | ||
3021 | } | 2721 | } |
3022 | 2722 | ||
@@ -3034,7 +2734,7 @@ public class InternalSolverLanguageParser extends AbstractInternalAntlrParser { | |||
3034 | 2734 | ||
3035 | 2735 | ||
3036 | // $ANTLR start "ruleConjunctiveExpression" | 2736 | // $ANTLR start "ruleConjunctiveExpression" |
3037 | // InternalSolverLanguage.g:1105:1: ruleConjunctiveExpression returns [EObject current=null] : (this_ComparisonExpression_0= ruleComparisonExpression ( () (otherlv_2= ',' ( (lv_children_3_0= ruleComparisonExpression ) ) )+ )? ) ; | 2737 | // InternalSolverLanguageParser.g:1094:1: ruleConjunctiveExpression returns [EObject current=null] : (this_ComparisonExpression_0= ruleComparisonExpression ( () (otherlv_2= Comma ( (lv_children_3_0= ruleComparisonExpression ) ) )+ )? ) ; |
3038 | public final EObject ruleConjunctiveExpression() throws RecognitionException { | 2738 | public final EObject ruleConjunctiveExpression() throws RecognitionException { |
3039 | EObject current = null; | 2739 | EObject current = null; |
3040 | 2740 | ||
@@ -3048,103 +2748,91 @@ public class InternalSolverLanguageParser extends AbstractInternalAntlrParser { | |||
3048 | enterRule(); | 2748 | enterRule(); |
3049 | 2749 | ||
3050 | try { | 2750 | try { |
3051 | // InternalSolverLanguage.g:1111:2: ( (this_ComparisonExpression_0= ruleComparisonExpression ( () (otherlv_2= ',' ( (lv_children_3_0= ruleComparisonExpression ) ) )+ )? ) ) | 2751 | // InternalSolverLanguageParser.g:1100:2: ( (this_ComparisonExpression_0= ruleComparisonExpression ( () (otherlv_2= Comma ( (lv_children_3_0= ruleComparisonExpression ) ) )+ )? ) ) |
3052 | // InternalSolverLanguage.g:1112:2: (this_ComparisonExpression_0= ruleComparisonExpression ( () (otherlv_2= ',' ( (lv_children_3_0= ruleComparisonExpression ) ) )+ )? ) | 2752 | // InternalSolverLanguageParser.g:1101:2: (this_ComparisonExpression_0= ruleComparisonExpression ( () (otherlv_2= Comma ( (lv_children_3_0= ruleComparisonExpression ) ) )+ )? ) |
3053 | { | 2753 | { |
3054 | // InternalSolverLanguage.g:1112:2: (this_ComparisonExpression_0= ruleComparisonExpression ( () (otherlv_2= ',' ( (lv_children_3_0= ruleComparisonExpression ) ) )+ )? ) | 2754 | // InternalSolverLanguageParser.g:1101:2: (this_ComparisonExpression_0= ruleComparisonExpression ( () (otherlv_2= Comma ( (lv_children_3_0= ruleComparisonExpression ) ) )+ )? ) |
3055 | // InternalSolverLanguage.g:1113:3: this_ComparisonExpression_0= ruleComparisonExpression ( () (otherlv_2= ',' ( (lv_children_3_0= ruleComparisonExpression ) ) )+ )? | 2755 | // InternalSolverLanguageParser.g:1102:3: this_ComparisonExpression_0= ruleComparisonExpression ( () (otherlv_2= Comma ( (lv_children_3_0= ruleComparisonExpression ) ) )+ )? |
3056 | { | 2756 | { |
3057 | if ( state.backtracking==0 ) { | ||
3058 | 2757 | ||
3059 | newCompositeNode(grammarAccess.getConjunctiveExpressionAccess().getComparisonExpressionParserRuleCall_0()); | 2758 | newCompositeNode(grammarAccess.getConjunctiveExpressionAccess().getComparisonExpressionParserRuleCall_0()); |
3060 | 2759 | ||
3061 | } | ||
3062 | pushFollow(FOLLOW_20); | 2760 | pushFollow(FOLLOW_20); |
3063 | this_ComparisonExpression_0=ruleComparisonExpression(); | 2761 | this_ComparisonExpression_0=ruleComparisonExpression(); |
3064 | 2762 | ||
3065 | state._fsp--; | 2763 | state._fsp--; |
3066 | if (state.failed) return current; | ||
3067 | if ( state.backtracking==0 ) { | ||
3068 | 2764 | ||
3069 | current = this_ComparisonExpression_0; | 2765 | |
3070 | afterParserOrEnumRuleCall(); | 2766 | current = this_ComparisonExpression_0; |
3071 | 2767 | afterParserOrEnumRuleCall(); | |
3072 | } | 2768 | |
3073 | // InternalSolverLanguage.g:1121:3: ( () (otherlv_2= ',' ( (lv_children_3_0= ruleComparisonExpression ) ) )+ )? | 2769 | // InternalSolverLanguageParser.g:1110:3: ( () (otherlv_2= Comma ( (lv_children_3_0= ruleComparisonExpression ) ) )+ )? |
3074 | int alt13=2; | 2770 | int alt13=2; |
3075 | int LA13_0 = input.LA(1); | 2771 | int LA13_0 = input.LA(1); |
3076 | 2772 | ||
3077 | if ( (LA13_0==28) ) { | 2773 | if ( (LA13_0==Comma) ) { |
3078 | alt13=1; | 2774 | alt13=1; |
3079 | } | 2775 | } |
3080 | switch (alt13) { | 2776 | switch (alt13) { |
3081 | case 1 : | 2777 | case 1 : |
3082 | // InternalSolverLanguage.g:1122:4: () (otherlv_2= ',' ( (lv_children_3_0= ruleComparisonExpression ) ) )+ | 2778 | // InternalSolverLanguageParser.g:1111:4: () (otherlv_2= Comma ( (lv_children_3_0= ruleComparisonExpression ) ) )+ |
3083 | { | 2779 | { |
3084 | // InternalSolverLanguage.g:1122:4: () | 2780 | // InternalSolverLanguageParser.g:1111:4: () |
3085 | // InternalSolverLanguage.g:1123:5: | 2781 | // InternalSolverLanguageParser.g:1112:5: |
3086 | { | 2782 | { |
3087 | if ( state.backtracking==0 ) { | ||
3088 | 2783 | ||
3089 | current = forceCreateModelElementAndAdd( | 2784 | current = forceCreateModelElementAndAdd( |
3090 | grammarAccess.getConjunctiveExpressionAccess().getConjunctionChildrenAction_1_0(), | 2785 | grammarAccess.getConjunctiveExpressionAccess().getConjunctionChildrenAction_1_0(), |
3091 | current); | 2786 | current); |
3092 | 2787 | ||
3093 | } | ||
3094 | 2788 | ||
3095 | } | 2789 | } |
3096 | 2790 | ||
3097 | // InternalSolverLanguage.g:1129:4: (otherlv_2= ',' ( (lv_children_3_0= ruleComparisonExpression ) ) )+ | 2791 | // InternalSolverLanguageParser.g:1118:4: (otherlv_2= Comma ( (lv_children_3_0= ruleComparisonExpression ) ) )+ |
3098 | int cnt12=0; | 2792 | int cnt12=0; |
3099 | loop12: | 2793 | loop12: |
3100 | do { | 2794 | do { |
3101 | int alt12=2; | 2795 | int alt12=2; |
3102 | int LA12_0 = input.LA(1); | 2796 | int LA12_0 = input.LA(1); |
3103 | 2797 | ||
3104 | if ( (LA12_0==28) ) { | 2798 | if ( (LA12_0==Comma) ) { |
3105 | alt12=1; | 2799 | alt12=1; |
3106 | } | 2800 | } |
3107 | 2801 | ||
3108 | 2802 | ||
3109 | switch (alt12) { | 2803 | switch (alt12) { |
3110 | case 1 : | 2804 | case 1 : |
3111 | // InternalSolverLanguage.g:1130:5: otherlv_2= ',' ( (lv_children_3_0= ruleComparisonExpression ) ) | 2805 | // InternalSolverLanguageParser.g:1119:5: otherlv_2= Comma ( (lv_children_3_0= ruleComparisonExpression ) ) |
3112 | { | 2806 | { |
3113 | otherlv_2=(Token)match(input,28,FOLLOW_6); if (state.failed) return current; | 2807 | otherlv_2=(Token)match(input,Comma,FOLLOW_6); |
3114 | if ( state.backtracking==0 ) { | ||
3115 | 2808 | ||
3116 | newLeafNode(otherlv_2, grammarAccess.getConjunctiveExpressionAccess().getCommaKeyword_1_1_0()); | 2809 | newLeafNode(otherlv_2, grammarAccess.getConjunctiveExpressionAccess().getCommaKeyword_1_1_0()); |
3117 | 2810 | ||
3118 | } | 2811 | // InternalSolverLanguageParser.g:1123:5: ( (lv_children_3_0= ruleComparisonExpression ) ) |
3119 | // InternalSolverLanguage.g:1134:5: ( (lv_children_3_0= ruleComparisonExpression ) ) | 2812 | // InternalSolverLanguageParser.g:1124:6: (lv_children_3_0= ruleComparisonExpression ) |
3120 | // InternalSolverLanguage.g:1135:6: (lv_children_3_0= ruleComparisonExpression ) | ||
3121 | { | 2813 | { |
3122 | // InternalSolverLanguage.g:1135:6: (lv_children_3_0= ruleComparisonExpression ) | 2814 | // InternalSolverLanguageParser.g:1124:6: (lv_children_3_0= ruleComparisonExpression ) |
3123 | // InternalSolverLanguage.g:1136:7: lv_children_3_0= ruleComparisonExpression | 2815 | // InternalSolverLanguageParser.g:1125:7: lv_children_3_0= ruleComparisonExpression |
3124 | { | 2816 | { |
3125 | if ( state.backtracking==0 ) { | ||
3126 | 2817 | ||
3127 | newCompositeNode(grammarAccess.getConjunctiveExpressionAccess().getChildrenComparisonExpressionParserRuleCall_1_1_1_0()); | 2818 | newCompositeNode(grammarAccess.getConjunctiveExpressionAccess().getChildrenComparisonExpressionParserRuleCall_1_1_1_0()); |
3128 | 2819 | ||
3129 | } | ||
3130 | pushFollow(FOLLOW_20); | 2820 | pushFollow(FOLLOW_20); |
3131 | lv_children_3_0=ruleComparisonExpression(); | 2821 | lv_children_3_0=ruleComparisonExpression(); |
3132 | 2822 | ||
3133 | state._fsp--; | 2823 | state._fsp--; |
3134 | if (state.failed) return current; | 2824 | |
3135 | if ( state.backtracking==0 ) { | 2825 | |
3136 | 2826 | if (current==null) { | |
3137 | if (current==null) { | 2827 | current = createModelElementForParent(grammarAccess.getConjunctiveExpressionRule()); |
3138 | current = createModelElementForParent(grammarAccess.getConjunctiveExpressionRule()); | 2828 | } |
3139 | } | 2829 | add( |
3140 | add( | 2830 | current, |
3141 | current, | 2831 | "children", |
3142 | "children", | 2832 | lv_children_3_0, |
3143 | lv_children_3_0, | 2833 | "org.eclipse.viatra.solver.language.SolverLanguage.ComparisonExpression"); |
3144 | "org.eclipse.viatra.solver.language.SolverLanguage.ComparisonExpression"); | 2834 | afterParserOrEnumRuleCall(); |
3145 | afterParserOrEnumRuleCall(); | 2835 | |
3146 | |||
3147 | } | ||
3148 | 2836 | ||
3149 | } | 2837 | } |
3150 | 2838 | ||
@@ -3157,7 +2845,6 @@ public class InternalSolverLanguageParser extends AbstractInternalAntlrParser { | |||
3157 | 2845 | ||
3158 | default : | 2846 | default : |
3159 | if ( cnt12 >= 1 ) break loop12; | 2847 | if ( cnt12 >= 1 ) break loop12; |
3160 | if (state.backtracking>0) {state.failed=true; return current;} | ||
3161 | EarlyExitException eee = | 2848 | EarlyExitException eee = |
3162 | new EarlyExitException(12, input); | 2849 | new EarlyExitException(12, input); |
3163 | throw eee; | 2850 | throw eee; |
@@ -3177,11 +2864,9 @@ public class InternalSolverLanguageParser extends AbstractInternalAntlrParser { | |||
3177 | 2864 | ||
3178 | } | 2865 | } |
3179 | 2866 | ||
3180 | if ( state.backtracking==0 ) { | ||
3181 | 2867 | ||
3182 | leaveRule(); | 2868 | leaveRule(); |
3183 | 2869 | ||
3184 | } | ||
3185 | } | 2870 | } |
3186 | 2871 | ||
3187 | catch (RecognitionException re) { | 2872 | catch (RecognitionException re) { |
@@ -3196,7 +2881,7 @@ public class InternalSolverLanguageParser extends AbstractInternalAntlrParser { | |||
3196 | 2881 | ||
3197 | 2882 | ||
3198 | // $ANTLR start "entryRuleComparisonExpression" | 2883 | // $ANTLR start "entryRuleComparisonExpression" |
3199 | // InternalSolverLanguage.g:1159:1: entryRuleComparisonExpression returns [EObject current=null] : iv_ruleComparisonExpression= ruleComparisonExpression EOF ; | 2884 | // InternalSolverLanguageParser.g:1148:1: entryRuleComparisonExpression returns [EObject current=null] : iv_ruleComparisonExpression= ruleComparisonExpression EOF ; |
3200 | public final EObject entryRuleComparisonExpression() throws RecognitionException { | 2885 | public final EObject entryRuleComparisonExpression() throws RecognitionException { |
3201 | EObject current = null; | 2886 | EObject current = null; |
3202 | 2887 | ||
@@ -3204,21 +2889,17 @@ public class InternalSolverLanguageParser extends AbstractInternalAntlrParser { | |||
3204 | 2889 | ||
3205 | 2890 | ||
3206 | try { | 2891 | try { |
3207 | // InternalSolverLanguage.g:1159:61: (iv_ruleComparisonExpression= ruleComparisonExpression EOF ) | 2892 | // InternalSolverLanguageParser.g:1148:61: (iv_ruleComparisonExpression= ruleComparisonExpression EOF ) |
3208 | // InternalSolverLanguage.g:1160:2: iv_ruleComparisonExpression= ruleComparisonExpression EOF | 2893 | // InternalSolverLanguageParser.g:1149:2: iv_ruleComparisonExpression= ruleComparisonExpression EOF |
3209 | { | 2894 | { |
3210 | if ( state.backtracking==0 ) { | 2895 | newCompositeNode(grammarAccess.getComparisonExpressionRule()); |
3211 | newCompositeNode(grammarAccess.getComparisonExpressionRule()); | ||
3212 | } | ||
3213 | pushFollow(FOLLOW_1); | 2896 | pushFollow(FOLLOW_1); |
3214 | iv_ruleComparisonExpression=ruleComparisonExpression(); | 2897 | iv_ruleComparisonExpression=ruleComparisonExpression(); |
3215 | 2898 | ||
3216 | state._fsp--; | 2899 | state._fsp--; |
3217 | if (state.failed) return current; | 2900 | |
3218 | if ( state.backtracking==0 ) { | 2901 | current =iv_ruleComparisonExpression; |
3219 | current =iv_ruleComparisonExpression; | 2902 | match(input,EOF,FOLLOW_2); |
3220 | } | ||
3221 | match(input,EOF,FOLLOW_2); if (state.failed) return current; | ||
3222 | 2903 | ||
3223 | } | 2904 | } |
3224 | 2905 | ||
@@ -3236,7 +2917,7 @@ public class InternalSolverLanguageParser extends AbstractInternalAntlrParser { | |||
3236 | 2917 | ||
3237 | 2918 | ||
3238 | // $ANTLR start "ruleComparisonExpression" | 2919 | // $ANTLR start "ruleComparisonExpression" |
3239 | // InternalSolverLanguage.g:1166:1: ruleComparisonExpression returns [EObject current=null] : (this_AdditiveExpression_0= ruleAdditiveExpression ( () ( (lv_op_2_0= ruleComparisonOperator ) ) ( (lv_right_3_0= ruleAdditiveExpression ) ) )? ) ; | 2920 | // InternalSolverLanguageParser.g:1155:1: ruleComparisonExpression returns [EObject current=null] : (this_AdditiveExpression_0= ruleAdditiveExpression ( () ( (lv_op_2_0= ruleComparisonOperator ) ) ( (lv_right_3_0= ruleAdditiveExpression ) ) )? ) ; |
3240 | public final EObject ruleComparisonExpression() throws RecognitionException { | 2921 | public final EObject ruleComparisonExpression() throws RecognitionException { |
3241 | EObject current = null; | 2922 | EObject current = null; |
3242 | 2923 | ||
@@ -3251,116 +2932,102 @@ public class InternalSolverLanguageParser extends AbstractInternalAntlrParser { | |||
3251 | enterRule(); | 2932 | enterRule(); |
3252 | 2933 | ||
3253 | try { | 2934 | try { |
3254 | // InternalSolverLanguage.g:1172:2: ( (this_AdditiveExpression_0= ruleAdditiveExpression ( () ( (lv_op_2_0= ruleComparisonOperator ) ) ( (lv_right_3_0= ruleAdditiveExpression ) ) )? ) ) | 2935 | // InternalSolverLanguageParser.g:1161:2: ( (this_AdditiveExpression_0= ruleAdditiveExpression ( () ( (lv_op_2_0= ruleComparisonOperator ) ) ( (lv_right_3_0= ruleAdditiveExpression ) ) )? ) ) |
3255 | // InternalSolverLanguage.g:1173:2: (this_AdditiveExpression_0= ruleAdditiveExpression ( () ( (lv_op_2_0= ruleComparisonOperator ) ) ( (lv_right_3_0= ruleAdditiveExpression ) ) )? ) | 2936 | // InternalSolverLanguageParser.g:1162:2: (this_AdditiveExpression_0= ruleAdditiveExpression ( () ( (lv_op_2_0= ruleComparisonOperator ) ) ( (lv_right_3_0= ruleAdditiveExpression ) ) )? ) |
3256 | { | 2937 | { |
3257 | // InternalSolverLanguage.g:1173:2: (this_AdditiveExpression_0= ruleAdditiveExpression ( () ( (lv_op_2_0= ruleComparisonOperator ) ) ( (lv_right_3_0= ruleAdditiveExpression ) ) )? ) | 2938 | // InternalSolverLanguageParser.g:1162:2: (this_AdditiveExpression_0= ruleAdditiveExpression ( () ( (lv_op_2_0= ruleComparisonOperator ) ) ( (lv_right_3_0= ruleAdditiveExpression ) ) )? ) |
3258 | // InternalSolverLanguage.g:1174:3: this_AdditiveExpression_0= ruleAdditiveExpression ( () ( (lv_op_2_0= ruleComparisonOperator ) ) ( (lv_right_3_0= ruleAdditiveExpression ) ) )? | 2939 | // InternalSolverLanguageParser.g:1163:3: this_AdditiveExpression_0= ruleAdditiveExpression ( () ( (lv_op_2_0= ruleComparisonOperator ) ) ( (lv_right_3_0= ruleAdditiveExpression ) ) )? |
3259 | { | 2940 | { |
3260 | if ( state.backtracking==0 ) { | ||
3261 | 2941 | ||
3262 | newCompositeNode(grammarAccess.getComparisonExpressionAccess().getAdditiveExpressionParserRuleCall_0()); | 2942 | newCompositeNode(grammarAccess.getComparisonExpressionAccess().getAdditiveExpressionParserRuleCall_0()); |
3263 | 2943 | ||
3264 | } | ||
3265 | pushFollow(FOLLOW_21); | 2944 | pushFollow(FOLLOW_21); |
3266 | this_AdditiveExpression_0=ruleAdditiveExpression(); | 2945 | this_AdditiveExpression_0=ruleAdditiveExpression(); |
3267 | 2946 | ||
3268 | state._fsp--; | 2947 | state._fsp--; |
3269 | if (state.failed) return current; | ||
3270 | if ( state.backtracking==0 ) { | ||
3271 | 2948 | ||
3272 | current = this_AdditiveExpression_0; | 2949 | |
3273 | afterParserOrEnumRuleCall(); | 2950 | current = this_AdditiveExpression_0; |
3274 | 2951 | afterParserOrEnumRuleCall(); | |
3275 | } | 2952 | |
3276 | // InternalSolverLanguage.g:1182:3: ( () ( (lv_op_2_0= ruleComparisonOperator ) ) ( (lv_right_3_0= ruleAdditiveExpression ) ) )? | 2953 | // InternalSolverLanguageParser.g:1171:3: ( () ( (lv_op_2_0= ruleComparisonOperator ) ) ( (lv_right_3_0= ruleAdditiveExpression ) ) )? |
3277 | int alt14=2; | 2954 | int alt14=2; |
3278 | int LA14_0 = input.LA(1); | 2955 | int LA14_0 = input.LA(1); |
3279 | 2956 | ||
3280 | if ( ((LA14_0>=47 && LA14_0<=49)||(LA14_0>=52 && LA14_0<=55)) ) { | 2957 | if ( (LA14_0==ExclamationMarkEqualsSign||(LA14_0>=LessThanSignEqualsSign && LA14_0<=GreaterThanSignEqualsSign)||LA14_0==In||LA14_0==LessThanSign||LA14_0==GreaterThanSign) ) { |
3281 | alt14=1; | 2958 | alt14=1; |
3282 | } | 2959 | } |
3283 | switch (alt14) { | 2960 | switch (alt14) { |
3284 | case 1 : | 2961 | case 1 : |
3285 | // InternalSolverLanguage.g:1183:4: () ( (lv_op_2_0= ruleComparisonOperator ) ) ( (lv_right_3_0= ruleAdditiveExpression ) ) | 2962 | // InternalSolverLanguageParser.g:1172:4: () ( (lv_op_2_0= ruleComparisonOperator ) ) ( (lv_right_3_0= ruleAdditiveExpression ) ) |
3286 | { | 2963 | { |
3287 | // InternalSolverLanguage.g:1183:4: () | 2964 | // InternalSolverLanguageParser.g:1172:4: () |
3288 | // InternalSolverLanguage.g:1184:5: | 2965 | // InternalSolverLanguageParser.g:1173:5: |
3289 | { | 2966 | { |
3290 | if ( state.backtracking==0 ) { | ||
3291 | 2967 | ||
3292 | current = forceCreateModelElementAndSet( | 2968 | current = forceCreateModelElementAndSet( |
3293 | grammarAccess.getComparisonExpressionAccess().getComparisonLeftAction_1_0(), | 2969 | grammarAccess.getComparisonExpressionAccess().getComparisonLeftAction_1_0(), |
3294 | current); | 2970 | current); |
3295 | 2971 | ||
3296 | } | ||
3297 | 2972 | ||
3298 | } | 2973 | } |
3299 | 2974 | ||
3300 | // InternalSolverLanguage.g:1190:4: ( (lv_op_2_0= ruleComparisonOperator ) ) | 2975 | // InternalSolverLanguageParser.g:1179:4: ( (lv_op_2_0= ruleComparisonOperator ) ) |
3301 | // InternalSolverLanguage.g:1191:5: (lv_op_2_0= ruleComparisonOperator ) | 2976 | // InternalSolverLanguageParser.g:1180:5: (lv_op_2_0= ruleComparisonOperator ) |
3302 | { | 2977 | { |
3303 | // InternalSolverLanguage.g:1191:5: (lv_op_2_0= ruleComparisonOperator ) | 2978 | // InternalSolverLanguageParser.g:1180:5: (lv_op_2_0= ruleComparisonOperator ) |
3304 | // InternalSolverLanguage.g:1192:6: lv_op_2_0= ruleComparisonOperator | 2979 | // InternalSolverLanguageParser.g:1181:6: lv_op_2_0= ruleComparisonOperator |
3305 | { | 2980 | { |
3306 | if ( state.backtracking==0 ) { | ||
3307 | 2981 | ||
3308 | newCompositeNode(grammarAccess.getComparisonExpressionAccess().getOpComparisonOperatorEnumRuleCall_1_1_0()); | 2982 | newCompositeNode(grammarAccess.getComparisonExpressionAccess().getOpComparisonOperatorEnumRuleCall_1_1_0()); |
3309 | 2983 | ||
3310 | } | ||
3311 | pushFollow(FOLLOW_6); | 2984 | pushFollow(FOLLOW_6); |
3312 | lv_op_2_0=ruleComparisonOperator(); | 2985 | lv_op_2_0=ruleComparisonOperator(); |
3313 | 2986 | ||
3314 | state._fsp--; | 2987 | state._fsp--; |
3315 | if (state.failed) return current; | ||
3316 | if ( state.backtracking==0 ) { | ||
3317 | 2988 | ||
3318 | if (current==null) { | 2989 | |
3319 | current = createModelElementForParent(grammarAccess.getComparisonExpressionRule()); | 2990 | if (current==null) { |
3320 | } | 2991 | current = createModelElementForParent(grammarAccess.getComparisonExpressionRule()); |
3321 | set( | 2992 | } |
3322 | current, | 2993 | set( |
3323 | "op", | 2994 | current, |
3324 | lv_op_2_0, | 2995 | "op", |
3325 | "org.eclipse.viatra.solver.language.SolverLanguage.ComparisonOperator"); | 2996 | lv_op_2_0, |
3326 | afterParserOrEnumRuleCall(); | 2997 | "org.eclipse.viatra.solver.language.SolverLanguage.ComparisonOperator"); |
3327 | 2998 | afterParserOrEnumRuleCall(); | |
3328 | } | 2999 | |
3329 | 3000 | ||
3330 | } | 3001 | } |
3331 | 3002 | ||
3332 | 3003 | ||
3333 | } | 3004 | } |
3334 | 3005 | ||
3335 | // InternalSolverLanguage.g:1209:4: ( (lv_right_3_0= ruleAdditiveExpression ) ) | 3006 | // InternalSolverLanguageParser.g:1198:4: ( (lv_right_3_0= ruleAdditiveExpression ) ) |
3336 | // InternalSolverLanguage.g:1210:5: (lv_right_3_0= ruleAdditiveExpression ) | 3007 | // InternalSolverLanguageParser.g:1199:5: (lv_right_3_0= ruleAdditiveExpression ) |
3337 | { | 3008 | { |
3338 | // InternalSolverLanguage.g:1210:5: (lv_right_3_0= ruleAdditiveExpression ) | 3009 | // InternalSolverLanguageParser.g:1199:5: (lv_right_3_0= ruleAdditiveExpression ) |
3339 | // InternalSolverLanguage.g:1211:6: lv_right_3_0= ruleAdditiveExpression | 3010 | // InternalSolverLanguageParser.g:1200:6: lv_right_3_0= ruleAdditiveExpression |
3340 | { | 3011 | { |
3341 | if ( state.backtracking==0 ) { | ||
3342 | 3012 | ||
3343 | newCompositeNode(grammarAccess.getComparisonExpressionAccess().getRightAdditiveExpressionParserRuleCall_1_2_0()); | 3013 | newCompositeNode(grammarAccess.getComparisonExpressionAccess().getRightAdditiveExpressionParserRuleCall_1_2_0()); |
3344 | 3014 | ||
3345 | } | ||
3346 | pushFollow(FOLLOW_2); | 3015 | pushFollow(FOLLOW_2); |
3347 | lv_right_3_0=ruleAdditiveExpression(); | 3016 | lv_right_3_0=ruleAdditiveExpression(); |
3348 | 3017 | ||
3349 | state._fsp--; | 3018 | state._fsp--; |
3350 | if (state.failed) return current; | ||
3351 | if ( state.backtracking==0 ) { | ||
3352 | 3019 | ||
3353 | if (current==null) { | 3020 | |
3354 | current = createModelElementForParent(grammarAccess.getComparisonExpressionRule()); | 3021 | if (current==null) { |
3355 | } | 3022 | current = createModelElementForParent(grammarAccess.getComparisonExpressionRule()); |
3356 | set( | 3023 | } |
3357 | current, | 3024 | set( |
3358 | "right", | 3025 | current, |
3359 | lv_right_3_0, | 3026 | "right", |
3360 | "org.eclipse.viatra.solver.language.SolverLanguage.AdditiveExpression"); | 3027 | lv_right_3_0, |
3361 | afterParserOrEnumRuleCall(); | 3028 | "org.eclipse.viatra.solver.language.SolverLanguage.AdditiveExpression"); |
3362 | 3029 | afterParserOrEnumRuleCall(); | |
3363 | } | 3030 | |
3364 | 3031 | ||
3365 | } | 3032 | } |
3366 | 3033 | ||
@@ -3379,11 +3046,9 @@ public class InternalSolverLanguageParser extends AbstractInternalAntlrParser { | |||
3379 | 3046 | ||
3380 | } | 3047 | } |
3381 | 3048 | ||
3382 | if ( state.backtracking==0 ) { | ||
3383 | 3049 | ||
3384 | leaveRule(); | 3050 | leaveRule(); |
3385 | 3051 | ||
3386 | } | ||
3387 | } | 3052 | } |
3388 | 3053 | ||
3389 | catch (RecognitionException re) { | 3054 | catch (RecognitionException re) { |
@@ -3398,7 +3063,7 @@ public class InternalSolverLanguageParser extends AbstractInternalAntlrParser { | |||
3398 | 3063 | ||
3399 | 3064 | ||
3400 | // $ANTLR start "entryRuleAdditiveExpression" | 3065 | // $ANTLR start "entryRuleAdditiveExpression" |
3401 | // InternalSolverLanguage.g:1233:1: entryRuleAdditiveExpression returns [EObject current=null] : iv_ruleAdditiveExpression= ruleAdditiveExpression EOF ; | 3066 | // InternalSolverLanguageParser.g:1222:1: entryRuleAdditiveExpression returns [EObject current=null] : iv_ruleAdditiveExpression= ruleAdditiveExpression EOF ; |
3402 | public final EObject entryRuleAdditiveExpression() throws RecognitionException { | 3067 | public final EObject entryRuleAdditiveExpression() throws RecognitionException { |
3403 | EObject current = null; | 3068 | EObject current = null; |
3404 | 3069 | ||
@@ -3406,21 +3071,17 @@ public class InternalSolverLanguageParser extends AbstractInternalAntlrParser { | |||
3406 | 3071 | ||
3407 | 3072 | ||
3408 | try { | 3073 | try { |
3409 | // InternalSolverLanguage.g:1233:59: (iv_ruleAdditiveExpression= ruleAdditiveExpression EOF ) | 3074 | // InternalSolverLanguageParser.g:1222:59: (iv_ruleAdditiveExpression= ruleAdditiveExpression EOF ) |
3410 | // InternalSolverLanguage.g:1234:2: iv_ruleAdditiveExpression= ruleAdditiveExpression EOF | 3075 | // InternalSolverLanguageParser.g:1223:2: iv_ruleAdditiveExpression= ruleAdditiveExpression EOF |
3411 | { | 3076 | { |
3412 | if ( state.backtracking==0 ) { | 3077 | newCompositeNode(grammarAccess.getAdditiveExpressionRule()); |
3413 | newCompositeNode(grammarAccess.getAdditiveExpressionRule()); | ||
3414 | } | ||
3415 | pushFollow(FOLLOW_1); | 3078 | pushFollow(FOLLOW_1); |
3416 | iv_ruleAdditiveExpression=ruleAdditiveExpression(); | 3079 | iv_ruleAdditiveExpression=ruleAdditiveExpression(); |
3417 | 3080 | ||
3418 | state._fsp--; | 3081 | state._fsp--; |
3419 | if (state.failed) return current; | 3082 | |
3420 | if ( state.backtracking==0 ) { | 3083 | current =iv_ruleAdditiveExpression; |
3421 | current =iv_ruleAdditiveExpression; | 3084 | match(input,EOF,FOLLOW_2); |
3422 | } | ||
3423 | match(input,EOF,FOLLOW_2); if (state.failed) return current; | ||
3424 | 3085 | ||
3425 | } | 3086 | } |
3426 | 3087 | ||
@@ -3438,7 +3099,7 @@ public class InternalSolverLanguageParser extends AbstractInternalAntlrParser { | |||
3438 | 3099 | ||
3439 | 3100 | ||
3440 | // $ANTLR start "ruleAdditiveExpression" | 3101 | // $ANTLR start "ruleAdditiveExpression" |
3441 | // InternalSolverLanguage.g:1240:1: ruleAdditiveExpression returns [EObject current=null] : (this_MultiplicativeExpression_0= ruleMultiplicativeExpression ( () ( (lv_op_2_0= ruleAdditiveBinaryOperator ) ) ( (lv_right_3_0= ruleMultiplicativeExpression ) ) )* ) ; | 3102 | // InternalSolverLanguageParser.g:1229:1: ruleAdditiveExpression returns [EObject current=null] : (this_MultiplicativeExpression_0= ruleMultiplicativeExpression ( () ( (lv_op_2_0= ruleAdditiveBinaryOperator ) ) ( (lv_right_3_0= ruleMultiplicativeExpression ) ) )* ) ; |
3442 | public final EObject ruleAdditiveExpression() throws RecognitionException { | 3103 | public final EObject ruleAdditiveExpression() throws RecognitionException { |
3443 | EObject current = null; | 3104 | EObject current = null; |
3444 | 3105 | ||
@@ -3453,120 +3114,106 @@ public class InternalSolverLanguageParser extends AbstractInternalAntlrParser { | |||
3453 | enterRule(); | 3114 | enterRule(); |
3454 | 3115 | ||
3455 | try { | 3116 | try { |
3456 | // InternalSolverLanguage.g:1246:2: ( (this_MultiplicativeExpression_0= ruleMultiplicativeExpression ( () ( (lv_op_2_0= ruleAdditiveBinaryOperator ) ) ( (lv_right_3_0= ruleMultiplicativeExpression ) ) )* ) ) | 3117 | // InternalSolverLanguageParser.g:1235:2: ( (this_MultiplicativeExpression_0= ruleMultiplicativeExpression ( () ( (lv_op_2_0= ruleAdditiveBinaryOperator ) ) ( (lv_right_3_0= ruleMultiplicativeExpression ) ) )* ) ) |
3457 | // InternalSolverLanguage.g:1247:2: (this_MultiplicativeExpression_0= ruleMultiplicativeExpression ( () ( (lv_op_2_0= ruleAdditiveBinaryOperator ) ) ( (lv_right_3_0= ruleMultiplicativeExpression ) ) )* ) | 3118 | // InternalSolverLanguageParser.g:1236:2: (this_MultiplicativeExpression_0= ruleMultiplicativeExpression ( () ( (lv_op_2_0= ruleAdditiveBinaryOperator ) ) ( (lv_right_3_0= ruleMultiplicativeExpression ) ) )* ) |
3458 | { | 3119 | { |
3459 | // InternalSolverLanguage.g:1247:2: (this_MultiplicativeExpression_0= ruleMultiplicativeExpression ( () ( (lv_op_2_0= ruleAdditiveBinaryOperator ) ) ( (lv_right_3_0= ruleMultiplicativeExpression ) ) )* ) | 3120 | // InternalSolverLanguageParser.g:1236:2: (this_MultiplicativeExpression_0= ruleMultiplicativeExpression ( () ( (lv_op_2_0= ruleAdditiveBinaryOperator ) ) ( (lv_right_3_0= ruleMultiplicativeExpression ) ) )* ) |
3460 | // InternalSolverLanguage.g:1248:3: this_MultiplicativeExpression_0= ruleMultiplicativeExpression ( () ( (lv_op_2_0= ruleAdditiveBinaryOperator ) ) ( (lv_right_3_0= ruleMultiplicativeExpression ) ) )* | 3121 | // InternalSolverLanguageParser.g:1237:3: this_MultiplicativeExpression_0= ruleMultiplicativeExpression ( () ( (lv_op_2_0= ruleAdditiveBinaryOperator ) ) ( (lv_right_3_0= ruleMultiplicativeExpression ) ) )* |
3461 | { | 3122 | { |
3462 | if ( state.backtracking==0 ) { | ||
3463 | 3123 | ||
3464 | newCompositeNode(grammarAccess.getAdditiveExpressionAccess().getMultiplicativeExpressionParserRuleCall_0()); | 3124 | newCompositeNode(grammarAccess.getAdditiveExpressionAccess().getMultiplicativeExpressionParserRuleCall_0()); |
3465 | 3125 | ||
3466 | } | ||
3467 | pushFollow(FOLLOW_22); | 3126 | pushFollow(FOLLOW_22); |
3468 | this_MultiplicativeExpression_0=ruleMultiplicativeExpression(); | 3127 | this_MultiplicativeExpression_0=ruleMultiplicativeExpression(); |
3469 | 3128 | ||
3470 | state._fsp--; | 3129 | state._fsp--; |
3471 | if (state.failed) return current; | ||
3472 | if ( state.backtracking==0 ) { | ||
3473 | 3130 | ||
3474 | current = this_MultiplicativeExpression_0; | 3131 | |
3475 | afterParserOrEnumRuleCall(); | 3132 | current = this_MultiplicativeExpression_0; |
3476 | 3133 | afterParserOrEnumRuleCall(); | |
3477 | } | 3134 | |
3478 | // InternalSolverLanguage.g:1256:3: ( () ( (lv_op_2_0= ruleAdditiveBinaryOperator ) ) ( (lv_right_3_0= ruleMultiplicativeExpression ) ) )* | 3135 | // InternalSolverLanguageParser.g:1245:3: ( () ( (lv_op_2_0= ruleAdditiveBinaryOperator ) ) ( (lv_right_3_0= ruleMultiplicativeExpression ) ) )* |
3479 | loop15: | 3136 | loop15: |
3480 | do { | 3137 | do { |
3481 | int alt15=2; | 3138 | int alt15=2; |
3482 | int LA15_0 = input.LA(1); | 3139 | int LA15_0 = input.LA(1); |
3483 | 3140 | ||
3484 | if ( ((LA15_0>=56 && LA15_0<=57)) ) { | 3141 | if ( (LA15_0==PlusSign||LA15_0==HyphenMinus) ) { |
3485 | alt15=1; | 3142 | alt15=1; |
3486 | } | 3143 | } |
3487 | 3144 | ||
3488 | 3145 | ||
3489 | switch (alt15) { | 3146 | switch (alt15) { |
3490 | case 1 : | 3147 | case 1 : |
3491 | // InternalSolverLanguage.g:1257:4: () ( (lv_op_2_0= ruleAdditiveBinaryOperator ) ) ( (lv_right_3_0= ruleMultiplicativeExpression ) ) | 3148 | // InternalSolverLanguageParser.g:1246:4: () ( (lv_op_2_0= ruleAdditiveBinaryOperator ) ) ( (lv_right_3_0= ruleMultiplicativeExpression ) ) |
3492 | { | 3149 | { |
3493 | // InternalSolverLanguage.g:1257:4: () | 3150 | // InternalSolverLanguageParser.g:1246:4: () |
3494 | // InternalSolverLanguage.g:1258:5: | 3151 | // InternalSolverLanguageParser.g:1247:5: |
3495 | { | 3152 | { |
3496 | if ( state.backtracking==0 ) { | ||
3497 | 3153 | ||
3498 | current = forceCreateModelElementAndSet( | 3154 | current = forceCreateModelElementAndSet( |
3499 | grammarAccess.getAdditiveExpressionAccess().getBinaryExpressionLeftAction_1_0(), | 3155 | grammarAccess.getAdditiveExpressionAccess().getBinaryExpressionLeftAction_1_0(), |
3500 | current); | 3156 | current); |
3501 | 3157 | ||
3502 | } | ||
3503 | 3158 | ||
3504 | } | 3159 | } |
3505 | 3160 | ||
3506 | // InternalSolverLanguage.g:1264:4: ( (lv_op_2_0= ruleAdditiveBinaryOperator ) ) | 3161 | // InternalSolverLanguageParser.g:1253:4: ( (lv_op_2_0= ruleAdditiveBinaryOperator ) ) |
3507 | // InternalSolverLanguage.g:1265:5: (lv_op_2_0= ruleAdditiveBinaryOperator ) | 3162 | // InternalSolverLanguageParser.g:1254:5: (lv_op_2_0= ruleAdditiveBinaryOperator ) |
3508 | { | 3163 | { |
3509 | // InternalSolverLanguage.g:1265:5: (lv_op_2_0= ruleAdditiveBinaryOperator ) | 3164 | // InternalSolverLanguageParser.g:1254:5: (lv_op_2_0= ruleAdditiveBinaryOperator ) |
3510 | // InternalSolverLanguage.g:1266:6: lv_op_2_0= ruleAdditiveBinaryOperator | 3165 | // InternalSolverLanguageParser.g:1255:6: lv_op_2_0= ruleAdditiveBinaryOperator |
3511 | { | 3166 | { |
3512 | if ( state.backtracking==0 ) { | ||
3513 | 3167 | ||
3514 | newCompositeNode(grammarAccess.getAdditiveExpressionAccess().getOpAdditiveBinaryOperatorEnumRuleCall_1_1_0()); | 3168 | newCompositeNode(grammarAccess.getAdditiveExpressionAccess().getOpAdditiveBinaryOperatorEnumRuleCall_1_1_0()); |
3515 | 3169 | ||
3516 | } | ||
3517 | pushFollow(FOLLOW_6); | 3170 | pushFollow(FOLLOW_6); |
3518 | lv_op_2_0=ruleAdditiveBinaryOperator(); | 3171 | lv_op_2_0=ruleAdditiveBinaryOperator(); |
3519 | 3172 | ||
3520 | state._fsp--; | 3173 | state._fsp--; |
3521 | if (state.failed) return current; | 3174 | |
3522 | if ( state.backtracking==0 ) { | 3175 | |
3523 | 3176 | if (current==null) { | |
3524 | if (current==null) { | 3177 | current = createModelElementForParent(grammarAccess.getAdditiveExpressionRule()); |
3525 | current = createModelElementForParent(grammarAccess.getAdditiveExpressionRule()); | 3178 | } |
3526 | } | 3179 | set( |
3527 | set( | 3180 | current, |
3528 | current, | 3181 | "op", |
3529 | "op", | 3182 | lv_op_2_0, |
3530 | lv_op_2_0, | 3183 | "org.eclipse.viatra.solver.language.SolverLanguage.AdditiveBinaryOperator"); |
3531 | "org.eclipse.viatra.solver.language.SolverLanguage.AdditiveBinaryOperator"); | 3184 | afterParserOrEnumRuleCall(); |
3532 | afterParserOrEnumRuleCall(); | 3185 | |
3533 | |||
3534 | } | ||
3535 | 3186 | ||
3536 | } | 3187 | } |
3537 | 3188 | ||
3538 | 3189 | ||
3539 | } | 3190 | } |
3540 | 3191 | ||
3541 | // InternalSolverLanguage.g:1283:4: ( (lv_right_3_0= ruleMultiplicativeExpression ) ) | 3192 | // InternalSolverLanguageParser.g:1272:4: ( (lv_right_3_0= ruleMultiplicativeExpression ) ) |
3542 | // InternalSolverLanguage.g:1284:5: (lv_right_3_0= ruleMultiplicativeExpression ) | 3193 | // InternalSolverLanguageParser.g:1273:5: (lv_right_3_0= ruleMultiplicativeExpression ) |
3543 | { | 3194 | { |
3544 | // InternalSolverLanguage.g:1284:5: (lv_right_3_0= ruleMultiplicativeExpression ) | 3195 | // InternalSolverLanguageParser.g:1273:5: (lv_right_3_0= ruleMultiplicativeExpression ) |
3545 | // InternalSolverLanguage.g:1285:6: lv_right_3_0= ruleMultiplicativeExpression | 3196 | // InternalSolverLanguageParser.g:1274:6: lv_right_3_0= ruleMultiplicativeExpression |
3546 | { | 3197 | { |
3547 | if ( state.backtracking==0 ) { | ||
3548 | 3198 | ||
3549 | newCompositeNode(grammarAccess.getAdditiveExpressionAccess().getRightMultiplicativeExpressionParserRuleCall_1_2_0()); | 3199 | newCompositeNode(grammarAccess.getAdditiveExpressionAccess().getRightMultiplicativeExpressionParserRuleCall_1_2_0()); |
3550 | 3200 | ||
3551 | } | ||
3552 | pushFollow(FOLLOW_22); | 3201 | pushFollow(FOLLOW_22); |
3553 | lv_right_3_0=ruleMultiplicativeExpression(); | 3202 | lv_right_3_0=ruleMultiplicativeExpression(); |
3554 | 3203 | ||
3555 | state._fsp--; | 3204 | state._fsp--; |
3556 | if (state.failed) return current; | 3205 | |
3557 | if ( state.backtracking==0 ) { | 3206 | |
3558 | 3207 | if (current==null) { | |
3559 | if (current==null) { | 3208 | current = createModelElementForParent(grammarAccess.getAdditiveExpressionRule()); |
3560 | current = createModelElementForParent(grammarAccess.getAdditiveExpressionRule()); | 3209 | } |
3561 | } | 3210 | set( |
3562 | set( | 3211 | current, |
3563 | current, | 3212 | "right", |
3564 | "right", | 3213 | lv_right_3_0, |
3565 | lv_right_3_0, | 3214 | "org.eclipse.viatra.solver.language.SolverLanguage.MultiplicativeExpression"); |
3566 | "org.eclipse.viatra.solver.language.SolverLanguage.MultiplicativeExpression"); | 3215 | afterParserOrEnumRuleCall(); |
3567 | afterParserOrEnumRuleCall(); | 3216 | |
3568 | |||
3569 | } | ||
3570 | 3217 | ||
3571 | } | 3218 | } |
3572 | 3219 | ||
@@ -3588,11 +3235,9 @@ public class InternalSolverLanguageParser extends AbstractInternalAntlrParser { | |||
3588 | 3235 | ||
3589 | } | 3236 | } |
3590 | 3237 | ||
3591 | if ( state.backtracking==0 ) { | ||
3592 | 3238 | ||
3593 | leaveRule(); | 3239 | leaveRule(); |
3594 | 3240 | ||
3595 | } | ||
3596 | } | 3241 | } |
3597 | 3242 | ||
3598 | catch (RecognitionException re) { | 3243 | catch (RecognitionException re) { |
@@ -3607,7 +3252,7 @@ public class InternalSolverLanguageParser extends AbstractInternalAntlrParser { | |||
3607 | 3252 | ||
3608 | 3253 | ||
3609 | // $ANTLR start "entryRuleMultiplicativeExpression" | 3254 | // $ANTLR start "entryRuleMultiplicativeExpression" |
3610 | // InternalSolverLanguage.g:1307:1: entryRuleMultiplicativeExpression returns [EObject current=null] : iv_ruleMultiplicativeExpression= ruleMultiplicativeExpression EOF ; | 3255 | // InternalSolverLanguageParser.g:1296:1: entryRuleMultiplicativeExpression returns [EObject current=null] : iv_ruleMultiplicativeExpression= ruleMultiplicativeExpression EOF ; |
3611 | public final EObject entryRuleMultiplicativeExpression() throws RecognitionException { | 3256 | public final EObject entryRuleMultiplicativeExpression() throws RecognitionException { |
3612 | EObject current = null; | 3257 | EObject current = null; |
3613 | 3258 | ||
@@ -3615,21 +3260,17 @@ public class InternalSolverLanguageParser extends AbstractInternalAntlrParser { | |||
3615 | 3260 | ||
3616 | 3261 | ||
3617 | try { | 3262 | try { |
3618 | // InternalSolverLanguage.g:1307:65: (iv_ruleMultiplicativeExpression= ruleMultiplicativeExpression EOF ) | 3263 | // InternalSolverLanguageParser.g:1296:65: (iv_ruleMultiplicativeExpression= ruleMultiplicativeExpression EOF ) |
3619 | // InternalSolverLanguage.g:1308:2: iv_ruleMultiplicativeExpression= ruleMultiplicativeExpression EOF | 3264 | // InternalSolverLanguageParser.g:1297:2: iv_ruleMultiplicativeExpression= ruleMultiplicativeExpression EOF |
3620 | { | 3265 | { |
3621 | if ( state.backtracking==0 ) { | 3266 | newCompositeNode(grammarAccess.getMultiplicativeExpressionRule()); |
3622 | newCompositeNode(grammarAccess.getMultiplicativeExpressionRule()); | ||
3623 | } | ||
3624 | pushFollow(FOLLOW_1); | 3267 | pushFollow(FOLLOW_1); |
3625 | iv_ruleMultiplicativeExpression=ruleMultiplicativeExpression(); | 3268 | iv_ruleMultiplicativeExpression=ruleMultiplicativeExpression(); |
3626 | 3269 | ||
3627 | state._fsp--; | 3270 | state._fsp--; |
3628 | if (state.failed) return current; | 3271 | |
3629 | if ( state.backtracking==0 ) { | 3272 | current =iv_ruleMultiplicativeExpression; |
3630 | current =iv_ruleMultiplicativeExpression; | 3273 | match(input,EOF,FOLLOW_2); |
3631 | } | ||
3632 | match(input,EOF,FOLLOW_2); if (state.failed) return current; | ||
3633 | 3274 | ||
3634 | } | 3275 | } |
3635 | 3276 | ||
@@ -3647,7 +3288,7 @@ public class InternalSolverLanguageParser extends AbstractInternalAntlrParser { | |||
3647 | 3288 | ||
3648 | 3289 | ||
3649 | // $ANTLR start "ruleMultiplicativeExpression" | 3290 | // $ANTLR start "ruleMultiplicativeExpression" |
3650 | // InternalSolverLanguage.g:1314:1: ruleMultiplicativeExpression returns [EObject current=null] : (this_ExponentialExpression_0= ruleExponentialExpression ( () ( (lv_op_2_0= ruleMultiplicativeBinaryOperator ) ) ( (lv_right_3_0= ruleExponentialExpression ) ) )* ) ; | 3291 | // InternalSolverLanguageParser.g:1303:1: ruleMultiplicativeExpression returns [EObject current=null] : (this_ExponentialExpression_0= ruleExponentialExpression ( () ( (lv_op_2_0= ruleMultiplicativeBinaryOperator ) ) ( (lv_right_3_0= ruleExponentialExpression ) ) )* ) ; |
3651 | public final EObject ruleMultiplicativeExpression() throws RecognitionException { | 3292 | public final EObject ruleMultiplicativeExpression() throws RecognitionException { |
3652 | EObject current = null; | 3293 | EObject current = null; |
3653 | 3294 | ||
@@ -3662,120 +3303,106 @@ public class InternalSolverLanguageParser extends AbstractInternalAntlrParser { | |||
3662 | enterRule(); | 3303 | enterRule(); |
3663 | 3304 | ||
3664 | try { | 3305 | try { |
3665 | // InternalSolverLanguage.g:1320:2: ( (this_ExponentialExpression_0= ruleExponentialExpression ( () ( (lv_op_2_0= ruleMultiplicativeBinaryOperator ) ) ( (lv_right_3_0= ruleExponentialExpression ) ) )* ) ) | 3306 | // InternalSolverLanguageParser.g:1309:2: ( (this_ExponentialExpression_0= ruleExponentialExpression ( () ( (lv_op_2_0= ruleMultiplicativeBinaryOperator ) ) ( (lv_right_3_0= ruleExponentialExpression ) ) )* ) ) |
3666 | // InternalSolverLanguage.g:1321:2: (this_ExponentialExpression_0= ruleExponentialExpression ( () ( (lv_op_2_0= ruleMultiplicativeBinaryOperator ) ) ( (lv_right_3_0= ruleExponentialExpression ) ) )* ) | 3307 | // InternalSolverLanguageParser.g:1310:2: (this_ExponentialExpression_0= ruleExponentialExpression ( () ( (lv_op_2_0= ruleMultiplicativeBinaryOperator ) ) ( (lv_right_3_0= ruleExponentialExpression ) ) )* ) |
3667 | { | 3308 | { |
3668 | // InternalSolverLanguage.g:1321:2: (this_ExponentialExpression_0= ruleExponentialExpression ( () ( (lv_op_2_0= ruleMultiplicativeBinaryOperator ) ) ( (lv_right_3_0= ruleExponentialExpression ) ) )* ) | 3309 | // InternalSolverLanguageParser.g:1310:2: (this_ExponentialExpression_0= ruleExponentialExpression ( () ( (lv_op_2_0= ruleMultiplicativeBinaryOperator ) ) ( (lv_right_3_0= ruleExponentialExpression ) ) )* ) |
3669 | // InternalSolverLanguage.g:1322:3: this_ExponentialExpression_0= ruleExponentialExpression ( () ( (lv_op_2_0= ruleMultiplicativeBinaryOperator ) ) ( (lv_right_3_0= ruleExponentialExpression ) ) )* | 3310 | // InternalSolverLanguageParser.g:1311:3: this_ExponentialExpression_0= ruleExponentialExpression ( () ( (lv_op_2_0= ruleMultiplicativeBinaryOperator ) ) ( (lv_right_3_0= ruleExponentialExpression ) ) )* |
3670 | { | 3311 | { |
3671 | if ( state.backtracking==0 ) { | ||
3672 | 3312 | ||
3673 | newCompositeNode(grammarAccess.getMultiplicativeExpressionAccess().getExponentialExpressionParserRuleCall_0()); | 3313 | newCompositeNode(grammarAccess.getMultiplicativeExpressionAccess().getExponentialExpressionParserRuleCall_0()); |
3674 | 3314 | ||
3675 | } | ||
3676 | pushFollow(FOLLOW_23); | 3315 | pushFollow(FOLLOW_23); |
3677 | this_ExponentialExpression_0=ruleExponentialExpression(); | 3316 | this_ExponentialExpression_0=ruleExponentialExpression(); |
3678 | 3317 | ||
3679 | state._fsp--; | 3318 | state._fsp--; |
3680 | if (state.failed) return current; | ||
3681 | if ( state.backtracking==0 ) { | ||
3682 | 3319 | ||
3683 | current = this_ExponentialExpression_0; | 3320 | |
3684 | afterParserOrEnumRuleCall(); | 3321 | current = this_ExponentialExpression_0; |
3685 | 3322 | afterParserOrEnumRuleCall(); | |
3686 | } | 3323 | |
3687 | // InternalSolverLanguage.g:1330:3: ( () ( (lv_op_2_0= ruleMultiplicativeBinaryOperator ) ) ( (lv_right_3_0= ruleExponentialExpression ) ) )* | 3324 | // InternalSolverLanguageParser.g:1319:3: ( () ( (lv_op_2_0= ruleMultiplicativeBinaryOperator ) ) ( (lv_right_3_0= ruleExponentialExpression ) ) )* |
3688 | loop16: | 3325 | loop16: |
3689 | do { | 3326 | do { |
3690 | int alt16=2; | 3327 | int alt16=2; |
3691 | int LA16_0 = input.LA(1); | 3328 | int LA16_0 = input.LA(1); |
3692 | 3329 | ||
3693 | if ( (LA16_0==35||LA16_0==58) ) { | 3330 | if ( (LA16_0==Asterisk||LA16_0==Solidus) ) { |
3694 | alt16=1; | 3331 | alt16=1; |
3695 | } | 3332 | } |
3696 | 3333 | ||
3697 | 3334 | ||
3698 | switch (alt16) { | 3335 | switch (alt16) { |
3699 | case 1 : | 3336 | case 1 : |
3700 | // InternalSolverLanguage.g:1331:4: () ( (lv_op_2_0= ruleMultiplicativeBinaryOperator ) ) ( (lv_right_3_0= ruleExponentialExpression ) ) | 3337 | // InternalSolverLanguageParser.g:1320:4: () ( (lv_op_2_0= ruleMultiplicativeBinaryOperator ) ) ( (lv_right_3_0= ruleExponentialExpression ) ) |
3701 | { | 3338 | { |
3702 | // InternalSolverLanguage.g:1331:4: () | 3339 | // InternalSolverLanguageParser.g:1320:4: () |
3703 | // InternalSolverLanguage.g:1332:5: | 3340 | // InternalSolverLanguageParser.g:1321:5: |
3704 | { | 3341 | { |
3705 | if ( state.backtracking==0 ) { | ||
3706 | 3342 | ||
3707 | current = forceCreateModelElementAndSet( | 3343 | current = forceCreateModelElementAndSet( |
3708 | grammarAccess.getMultiplicativeExpressionAccess().getBinaryExpressionLeftAction_1_0(), | 3344 | grammarAccess.getMultiplicativeExpressionAccess().getBinaryExpressionLeftAction_1_0(), |
3709 | current); | 3345 | current); |
3710 | 3346 | ||
3711 | } | ||
3712 | 3347 | ||
3713 | } | 3348 | } |
3714 | 3349 | ||
3715 | // InternalSolverLanguage.g:1338:4: ( (lv_op_2_0= ruleMultiplicativeBinaryOperator ) ) | 3350 | // InternalSolverLanguageParser.g:1327:4: ( (lv_op_2_0= ruleMultiplicativeBinaryOperator ) ) |
3716 | // InternalSolverLanguage.g:1339:5: (lv_op_2_0= ruleMultiplicativeBinaryOperator ) | 3351 | // InternalSolverLanguageParser.g:1328:5: (lv_op_2_0= ruleMultiplicativeBinaryOperator ) |
3717 | { | 3352 | { |
3718 | // InternalSolverLanguage.g:1339:5: (lv_op_2_0= ruleMultiplicativeBinaryOperator ) | 3353 | // InternalSolverLanguageParser.g:1328:5: (lv_op_2_0= ruleMultiplicativeBinaryOperator ) |
3719 | // InternalSolverLanguage.g:1340:6: lv_op_2_0= ruleMultiplicativeBinaryOperator | 3354 | // InternalSolverLanguageParser.g:1329:6: lv_op_2_0= ruleMultiplicativeBinaryOperator |
3720 | { | 3355 | { |
3721 | if ( state.backtracking==0 ) { | ||
3722 | 3356 | ||
3723 | newCompositeNode(grammarAccess.getMultiplicativeExpressionAccess().getOpMultiplicativeBinaryOperatorEnumRuleCall_1_1_0()); | 3357 | newCompositeNode(grammarAccess.getMultiplicativeExpressionAccess().getOpMultiplicativeBinaryOperatorEnumRuleCall_1_1_0()); |
3724 | 3358 | ||
3725 | } | ||
3726 | pushFollow(FOLLOW_6); | 3359 | pushFollow(FOLLOW_6); |
3727 | lv_op_2_0=ruleMultiplicativeBinaryOperator(); | 3360 | lv_op_2_0=ruleMultiplicativeBinaryOperator(); |
3728 | 3361 | ||
3729 | state._fsp--; | 3362 | state._fsp--; |
3730 | if (state.failed) return current; | 3363 | |
3731 | if ( state.backtracking==0 ) { | 3364 | |
3732 | 3365 | if (current==null) { | |
3733 | if (current==null) { | 3366 | current = createModelElementForParent(grammarAccess.getMultiplicativeExpressionRule()); |
3734 | current = createModelElementForParent(grammarAccess.getMultiplicativeExpressionRule()); | 3367 | } |
3735 | } | 3368 | set( |
3736 | set( | 3369 | current, |
3737 | current, | 3370 | "op", |
3738 | "op", | 3371 | lv_op_2_0, |
3739 | lv_op_2_0, | 3372 | "org.eclipse.viatra.solver.language.SolverLanguage.MultiplicativeBinaryOperator"); |
3740 | "org.eclipse.viatra.solver.language.SolverLanguage.MultiplicativeBinaryOperator"); | 3373 | afterParserOrEnumRuleCall(); |
3741 | afterParserOrEnumRuleCall(); | 3374 | |
3742 | |||
3743 | } | ||
3744 | 3375 | ||
3745 | } | 3376 | } |
3746 | 3377 | ||
3747 | 3378 | ||
3748 | } | 3379 | } |
3749 | 3380 | ||
3750 | // InternalSolverLanguage.g:1357:4: ( (lv_right_3_0= ruleExponentialExpression ) ) | 3381 | // InternalSolverLanguageParser.g:1346:4: ( (lv_right_3_0= ruleExponentialExpression ) ) |
3751 | // InternalSolverLanguage.g:1358:5: (lv_right_3_0= ruleExponentialExpression ) | 3382 | // InternalSolverLanguageParser.g:1347:5: (lv_right_3_0= ruleExponentialExpression ) |
3752 | { | 3383 | { |
3753 | // InternalSolverLanguage.g:1358:5: (lv_right_3_0= ruleExponentialExpression ) | 3384 | // InternalSolverLanguageParser.g:1347:5: (lv_right_3_0= ruleExponentialExpression ) |
3754 | // InternalSolverLanguage.g:1359:6: lv_right_3_0= ruleExponentialExpression | 3385 | // InternalSolverLanguageParser.g:1348:6: lv_right_3_0= ruleExponentialExpression |
3755 | { | 3386 | { |
3756 | if ( state.backtracking==0 ) { | ||
3757 | 3387 | ||
3758 | newCompositeNode(grammarAccess.getMultiplicativeExpressionAccess().getRightExponentialExpressionParserRuleCall_1_2_0()); | 3388 | newCompositeNode(grammarAccess.getMultiplicativeExpressionAccess().getRightExponentialExpressionParserRuleCall_1_2_0()); |
3759 | 3389 | ||
3760 | } | ||
3761 | pushFollow(FOLLOW_23); | 3390 | pushFollow(FOLLOW_23); |
3762 | lv_right_3_0=ruleExponentialExpression(); | 3391 | lv_right_3_0=ruleExponentialExpression(); |
3763 | 3392 | ||
3764 | state._fsp--; | 3393 | state._fsp--; |
3765 | if (state.failed) return current; | 3394 | |
3766 | if ( state.backtracking==0 ) { | 3395 | |
3767 | 3396 | if (current==null) { | |
3768 | if (current==null) { | 3397 | current = createModelElementForParent(grammarAccess.getMultiplicativeExpressionRule()); |
3769 | current = createModelElementForParent(grammarAccess.getMultiplicativeExpressionRule()); | 3398 | } |
3770 | } | 3399 | set( |
3771 | set( | 3400 | current, |
3772 | current, | 3401 | "right", |
3773 | "right", | 3402 | lv_right_3_0, |
3774 | lv_right_3_0, | 3403 | "org.eclipse.viatra.solver.language.SolverLanguage.ExponentialExpression"); |
3775 | "org.eclipse.viatra.solver.language.SolverLanguage.ExponentialExpression"); | 3404 | afterParserOrEnumRuleCall(); |
3776 | afterParserOrEnumRuleCall(); | 3405 | |
3777 | |||
3778 | } | ||
3779 | 3406 | ||
3780 | } | 3407 | } |
3781 | 3408 | ||
@@ -3797,11 +3424,9 @@ public class InternalSolverLanguageParser extends AbstractInternalAntlrParser { | |||
3797 | 3424 | ||
3798 | } | 3425 | } |
3799 | 3426 | ||
3800 | if ( state.backtracking==0 ) { | ||
3801 | 3427 | ||
3802 | leaveRule(); | 3428 | leaveRule(); |
3803 | 3429 | ||
3804 | } | ||
3805 | } | 3430 | } |
3806 | 3431 | ||
3807 | catch (RecognitionException re) { | 3432 | catch (RecognitionException re) { |
@@ -3816,7 +3441,7 @@ public class InternalSolverLanguageParser extends AbstractInternalAntlrParser { | |||
3816 | 3441 | ||
3817 | 3442 | ||
3818 | // $ANTLR start "entryRuleExponentialExpression" | 3443 | // $ANTLR start "entryRuleExponentialExpression" |
3819 | // InternalSolverLanguage.g:1381:1: entryRuleExponentialExpression returns [EObject current=null] : iv_ruleExponentialExpression= ruleExponentialExpression EOF ; | 3444 | // InternalSolverLanguageParser.g:1370:1: entryRuleExponentialExpression returns [EObject current=null] : iv_ruleExponentialExpression= ruleExponentialExpression EOF ; |
3820 | public final EObject entryRuleExponentialExpression() throws RecognitionException { | 3445 | public final EObject entryRuleExponentialExpression() throws RecognitionException { |
3821 | EObject current = null; | 3446 | EObject current = null; |
3822 | 3447 | ||
@@ -3824,21 +3449,17 @@ public class InternalSolverLanguageParser extends AbstractInternalAntlrParser { | |||
3824 | 3449 | ||
3825 | 3450 | ||
3826 | try { | 3451 | try { |
3827 | // InternalSolverLanguage.g:1381:62: (iv_ruleExponentialExpression= ruleExponentialExpression EOF ) | 3452 | // InternalSolverLanguageParser.g:1370:62: (iv_ruleExponentialExpression= ruleExponentialExpression EOF ) |
3828 | // InternalSolverLanguage.g:1382:2: iv_ruleExponentialExpression= ruleExponentialExpression EOF | 3453 | // InternalSolverLanguageParser.g:1371:2: iv_ruleExponentialExpression= ruleExponentialExpression EOF |
3829 | { | 3454 | { |
3830 | if ( state.backtracking==0 ) { | 3455 | newCompositeNode(grammarAccess.getExponentialExpressionRule()); |
3831 | newCompositeNode(grammarAccess.getExponentialExpressionRule()); | ||
3832 | } | ||
3833 | pushFollow(FOLLOW_1); | 3456 | pushFollow(FOLLOW_1); |
3834 | iv_ruleExponentialExpression=ruleExponentialExpression(); | 3457 | iv_ruleExponentialExpression=ruleExponentialExpression(); |
3835 | 3458 | ||
3836 | state._fsp--; | 3459 | state._fsp--; |
3837 | if (state.failed) return current; | 3460 | |
3838 | if ( state.backtracking==0 ) { | 3461 | current =iv_ruleExponentialExpression; |
3839 | current =iv_ruleExponentialExpression; | 3462 | match(input,EOF,FOLLOW_2); |
3840 | } | ||
3841 | match(input,EOF,FOLLOW_2); if (state.failed) return current; | ||
3842 | 3463 | ||
3843 | } | 3464 | } |
3844 | 3465 | ||
@@ -3856,7 +3477,7 @@ public class InternalSolverLanguageParser extends AbstractInternalAntlrParser { | |||
3856 | 3477 | ||
3857 | 3478 | ||
3858 | // $ANTLR start "ruleExponentialExpression" | 3479 | // $ANTLR start "ruleExponentialExpression" |
3859 | // InternalSolverLanguage.g:1388:1: ruleExponentialExpression returns [EObject current=null] : (this_UnaryExpression_0= ruleUnaryExpression ( () ( (lv_op_2_0= ruleExponentialOp ) ) ( (lv_right_3_0= ruleExponentialExpression ) ) )? ) ; | 3480 | // InternalSolverLanguageParser.g:1377:1: ruleExponentialExpression returns [EObject current=null] : (this_UnaryExpression_0= ruleUnaryExpression ( () ( (lv_op_2_0= ruleExponentialOp ) ) ( (lv_right_3_0= ruleExponentialExpression ) ) )? ) ; |
3860 | public final EObject ruleExponentialExpression() throws RecognitionException { | 3481 | public final EObject ruleExponentialExpression() throws RecognitionException { |
3861 | EObject current = null; | 3482 | EObject current = null; |
3862 | 3483 | ||
@@ -3871,116 +3492,102 @@ public class InternalSolverLanguageParser extends AbstractInternalAntlrParser { | |||
3871 | enterRule(); | 3492 | enterRule(); |
3872 | 3493 | ||
3873 | try { | 3494 | try { |
3874 | // InternalSolverLanguage.g:1394:2: ( (this_UnaryExpression_0= ruleUnaryExpression ( () ( (lv_op_2_0= ruleExponentialOp ) ) ( (lv_right_3_0= ruleExponentialExpression ) ) )? ) ) | 3495 | // InternalSolverLanguageParser.g:1383:2: ( (this_UnaryExpression_0= ruleUnaryExpression ( () ( (lv_op_2_0= ruleExponentialOp ) ) ( (lv_right_3_0= ruleExponentialExpression ) ) )? ) ) |
3875 | // InternalSolverLanguage.g:1395:2: (this_UnaryExpression_0= ruleUnaryExpression ( () ( (lv_op_2_0= ruleExponentialOp ) ) ( (lv_right_3_0= ruleExponentialExpression ) ) )? ) | 3496 | // InternalSolverLanguageParser.g:1384:2: (this_UnaryExpression_0= ruleUnaryExpression ( () ( (lv_op_2_0= ruleExponentialOp ) ) ( (lv_right_3_0= ruleExponentialExpression ) ) )? ) |
3876 | { | 3497 | { |
3877 | // InternalSolverLanguage.g:1395:2: (this_UnaryExpression_0= ruleUnaryExpression ( () ( (lv_op_2_0= ruleExponentialOp ) ) ( (lv_right_3_0= ruleExponentialExpression ) ) )? ) | 3498 | // InternalSolverLanguageParser.g:1384:2: (this_UnaryExpression_0= ruleUnaryExpression ( () ( (lv_op_2_0= ruleExponentialOp ) ) ( (lv_right_3_0= ruleExponentialExpression ) ) )? ) |
3878 | // InternalSolverLanguage.g:1396:3: this_UnaryExpression_0= ruleUnaryExpression ( () ( (lv_op_2_0= ruleExponentialOp ) ) ( (lv_right_3_0= ruleExponentialExpression ) ) )? | 3499 | // InternalSolverLanguageParser.g:1385:3: this_UnaryExpression_0= ruleUnaryExpression ( () ( (lv_op_2_0= ruleExponentialOp ) ) ( (lv_right_3_0= ruleExponentialExpression ) ) )? |
3879 | { | 3500 | { |
3880 | if ( state.backtracking==0 ) { | ||
3881 | 3501 | ||
3882 | newCompositeNode(grammarAccess.getExponentialExpressionAccess().getUnaryExpressionParserRuleCall_0()); | 3502 | newCompositeNode(grammarAccess.getExponentialExpressionAccess().getUnaryExpressionParserRuleCall_0()); |
3883 | 3503 | ||
3884 | } | ||
3885 | pushFollow(FOLLOW_24); | 3504 | pushFollow(FOLLOW_24); |
3886 | this_UnaryExpression_0=ruleUnaryExpression(); | 3505 | this_UnaryExpression_0=ruleUnaryExpression(); |
3887 | 3506 | ||
3888 | state._fsp--; | 3507 | state._fsp--; |
3889 | if (state.failed) return current; | ||
3890 | if ( state.backtracking==0 ) { | ||
3891 | 3508 | ||
3892 | current = this_UnaryExpression_0; | 3509 | |
3893 | afterParserOrEnumRuleCall(); | 3510 | current = this_UnaryExpression_0; |
3894 | 3511 | afterParserOrEnumRuleCall(); | |
3895 | } | 3512 | |
3896 | // InternalSolverLanguage.g:1404:3: ( () ( (lv_op_2_0= ruleExponentialOp ) ) ( (lv_right_3_0= ruleExponentialExpression ) ) )? | 3513 | // InternalSolverLanguageParser.g:1393:3: ( () ( (lv_op_2_0= ruleExponentialOp ) ) ( (lv_right_3_0= ruleExponentialExpression ) ) )? |
3897 | int alt17=2; | 3514 | int alt17=2; |
3898 | int LA17_0 = input.LA(1); | 3515 | int LA17_0 = input.LA(1); |
3899 | 3516 | ||
3900 | if ( (LA17_0==59) ) { | 3517 | if ( (LA17_0==CircumflexAccent) ) { |
3901 | alt17=1; | 3518 | alt17=1; |
3902 | } | 3519 | } |
3903 | switch (alt17) { | 3520 | switch (alt17) { |
3904 | case 1 : | 3521 | case 1 : |
3905 | // InternalSolverLanguage.g:1405:4: () ( (lv_op_2_0= ruleExponentialOp ) ) ( (lv_right_3_0= ruleExponentialExpression ) ) | 3522 | // InternalSolverLanguageParser.g:1394:4: () ( (lv_op_2_0= ruleExponentialOp ) ) ( (lv_right_3_0= ruleExponentialExpression ) ) |
3906 | { | 3523 | { |
3907 | // InternalSolverLanguage.g:1405:4: () | 3524 | // InternalSolverLanguageParser.g:1394:4: () |
3908 | // InternalSolverLanguage.g:1406:5: | 3525 | // InternalSolverLanguageParser.g:1395:5: |
3909 | { | 3526 | { |
3910 | if ( state.backtracking==0 ) { | ||
3911 | 3527 | ||
3912 | current = forceCreateModelElementAndSet( | 3528 | current = forceCreateModelElementAndSet( |
3913 | grammarAccess.getExponentialExpressionAccess().getBinaryExpressionLeftAction_1_0(), | 3529 | grammarAccess.getExponentialExpressionAccess().getBinaryExpressionLeftAction_1_0(), |
3914 | current); | 3530 | current); |
3915 | 3531 | ||
3916 | } | ||
3917 | 3532 | ||
3918 | } | 3533 | } |
3919 | 3534 | ||
3920 | // InternalSolverLanguage.g:1412:4: ( (lv_op_2_0= ruleExponentialOp ) ) | 3535 | // InternalSolverLanguageParser.g:1401:4: ( (lv_op_2_0= ruleExponentialOp ) ) |
3921 | // InternalSolverLanguage.g:1413:5: (lv_op_2_0= ruleExponentialOp ) | 3536 | // InternalSolverLanguageParser.g:1402:5: (lv_op_2_0= ruleExponentialOp ) |
3922 | { | 3537 | { |
3923 | // InternalSolverLanguage.g:1413:5: (lv_op_2_0= ruleExponentialOp ) | 3538 | // InternalSolverLanguageParser.g:1402:5: (lv_op_2_0= ruleExponentialOp ) |
3924 | // InternalSolverLanguage.g:1414:6: lv_op_2_0= ruleExponentialOp | 3539 | // InternalSolverLanguageParser.g:1403:6: lv_op_2_0= ruleExponentialOp |
3925 | { | 3540 | { |
3926 | if ( state.backtracking==0 ) { | ||
3927 | 3541 | ||
3928 | newCompositeNode(grammarAccess.getExponentialExpressionAccess().getOpExponentialOpEnumRuleCall_1_1_0()); | 3542 | newCompositeNode(grammarAccess.getExponentialExpressionAccess().getOpExponentialOpEnumRuleCall_1_1_0()); |
3929 | 3543 | ||
3930 | } | ||
3931 | pushFollow(FOLLOW_6); | 3544 | pushFollow(FOLLOW_6); |
3932 | lv_op_2_0=ruleExponentialOp(); | 3545 | lv_op_2_0=ruleExponentialOp(); |
3933 | 3546 | ||
3934 | state._fsp--; | 3547 | state._fsp--; |
3935 | if (state.failed) return current; | ||
3936 | if ( state.backtracking==0 ) { | ||
3937 | 3548 | ||
3938 | if (current==null) { | 3549 | |
3939 | current = createModelElementForParent(grammarAccess.getExponentialExpressionRule()); | 3550 | if (current==null) { |
3940 | } | 3551 | current = createModelElementForParent(grammarAccess.getExponentialExpressionRule()); |
3941 | set( | 3552 | } |
3942 | current, | 3553 | set( |
3943 | "op", | 3554 | current, |
3944 | lv_op_2_0, | 3555 | "op", |
3945 | "org.eclipse.viatra.solver.language.SolverLanguage.ExponentialOp"); | 3556 | lv_op_2_0, |
3946 | afterParserOrEnumRuleCall(); | 3557 | "org.eclipse.viatra.solver.language.SolverLanguage.ExponentialOp"); |
3947 | 3558 | afterParserOrEnumRuleCall(); | |
3948 | } | 3559 | |
3949 | 3560 | ||
3950 | } | 3561 | } |
3951 | 3562 | ||
3952 | 3563 | ||
3953 | } | 3564 | } |
3954 | 3565 | ||
3955 | // InternalSolverLanguage.g:1431:4: ( (lv_right_3_0= ruleExponentialExpression ) ) | 3566 | // InternalSolverLanguageParser.g:1420:4: ( (lv_right_3_0= ruleExponentialExpression ) ) |
3956 | // InternalSolverLanguage.g:1432:5: (lv_right_3_0= ruleExponentialExpression ) | 3567 | // InternalSolverLanguageParser.g:1421:5: (lv_right_3_0= ruleExponentialExpression ) |
3957 | { | 3568 | { |
3958 | // InternalSolverLanguage.g:1432:5: (lv_right_3_0= ruleExponentialExpression ) | 3569 | // InternalSolverLanguageParser.g:1421:5: (lv_right_3_0= ruleExponentialExpression ) |
3959 | // InternalSolverLanguage.g:1433:6: lv_right_3_0= ruleExponentialExpression | 3570 | // InternalSolverLanguageParser.g:1422:6: lv_right_3_0= ruleExponentialExpression |
3960 | { | 3571 | { |
3961 | if ( state.backtracking==0 ) { | ||
3962 | 3572 | ||
3963 | newCompositeNode(grammarAccess.getExponentialExpressionAccess().getRightExponentialExpressionParserRuleCall_1_2_0()); | 3573 | newCompositeNode(grammarAccess.getExponentialExpressionAccess().getRightExponentialExpressionParserRuleCall_1_2_0()); |
3964 | 3574 | ||
3965 | } | ||
3966 | pushFollow(FOLLOW_2); | 3575 | pushFollow(FOLLOW_2); |
3967 | lv_right_3_0=ruleExponentialExpression(); | 3576 | lv_right_3_0=ruleExponentialExpression(); |
3968 | 3577 | ||
3969 | state._fsp--; | 3578 | state._fsp--; |
3970 | if (state.failed) return current; | ||
3971 | if ( state.backtracking==0 ) { | ||
3972 | 3579 | ||
3973 | if (current==null) { | 3580 | |
3974 | current = createModelElementForParent(grammarAccess.getExponentialExpressionRule()); | 3581 | if (current==null) { |
3975 | } | 3582 | current = createModelElementForParent(grammarAccess.getExponentialExpressionRule()); |
3976 | set( | 3583 | } |
3977 | current, | 3584 | set( |
3978 | "right", | 3585 | current, |
3979 | lv_right_3_0, | 3586 | "right", |
3980 | "org.eclipse.viatra.solver.language.SolverLanguage.ExponentialExpression"); | 3587 | lv_right_3_0, |
3981 | afterParserOrEnumRuleCall(); | 3588 | "org.eclipse.viatra.solver.language.SolverLanguage.ExponentialExpression"); |
3982 | 3589 | afterParserOrEnumRuleCall(); | |
3983 | } | 3590 | |
3984 | 3591 | ||
3985 | } | 3592 | } |
3986 | 3593 | ||
@@ -3999,11 +3606,9 @@ public class InternalSolverLanguageParser extends AbstractInternalAntlrParser { | |||
3999 | 3606 | ||
4000 | } | 3607 | } |
4001 | 3608 | ||
4002 | if ( state.backtracking==0 ) { | ||
4003 | 3609 | ||
4004 | leaveRule(); | 3610 | leaveRule(); |
4005 | 3611 | ||
4006 | } | ||
4007 | } | 3612 | } |
4008 | 3613 | ||
4009 | catch (RecognitionException re) { | 3614 | catch (RecognitionException re) { |
@@ -4018,7 +3623,7 @@ public class InternalSolverLanguageParser extends AbstractInternalAntlrParser { | |||
4018 | 3623 | ||
4019 | 3624 | ||
4020 | // $ANTLR start "entryRuleUnaryExpression" | 3625 | // $ANTLR start "entryRuleUnaryExpression" |
4021 | // InternalSolverLanguage.g:1455:1: entryRuleUnaryExpression returns [EObject current=null] : iv_ruleUnaryExpression= ruleUnaryExpression EOF ; | 3626 | // InternalSolverLanguageParser.g:1444:1: entryRuleUnaryExpression returns [EObject current=null] : iv_ruleUnaryExpression= ruleUnaryExpression EOF ; |
4022 | public final EObject entryRuleUnaryExpression() throws RecognitionException { | 3627 | public final EObject entryRuleUnaryExpression() throws RecognitionException { |
4023 | EObject current = null; | 3628 | EObject current = null; |
4024 | 3629 | ||
@@ -4026,21 +3631,17 @@ public class InternalSolverLanguageParser extends AbstractInternalAntlrParser { | |||
4026 | 3631 | ||
4027 | 3632 | ||
4028 | try { | 3633 | try { |
4029 | // InternalSolverLanguage.g:1455:56: (iv_ruleUnaryExpression= ruleUnaryExpression EOF ) | 3634 | // InternalSolverLanguageParser.g:1444:56: (iv_ruleUnaryExpression= ruleUnaryExpression EOF ) |
4030 | // InternalSolverLanguage.g:1456:2: iv_ruleUnaryExpression= ruleUnaryExpression EOF | 3635 | // InternalSolverLanguageParser.g:1445:2: iv_ruleUnaryExpression= ruleUnaryExpression EOF |
4031 | { | 3636 | { |
4032 | if ( state.backtracking==0 ) { | 3637 | newCompositeNode(grammarAccess.getUnaryExpressionRule()); |
4033 | newCompositeNode(grammarAccess.getUnaryExpressionRule()); | ||
4034 | } | ||
4035 | pushFollow(FOLLOW_1); | 3638 | pushFollow(FOLLOW_1); |
4036 | iv_ruleUnaryExpression=ruleUnaryExpression(); | 3639 | iv_ruleUnaryExpression=ruleUnaryExpression(); |
4037 | 3640 | ||
4038 | state._fsp--; | 3641 | state._fsp--; |
4039 | if (state.failed) return current; | 3642 | |
4040 | if ( state.backtracking==0 ) { | 3643 | current =iv_ruleUnaryExpression; |
4041 | current =iv_ruleUnaryExpression; | 3644 | match(input,EOF,FOLLOW_2); |
4042 | } | ||
4043 | match(input,EOF,FOLLOW_2); if (state.failed) return current; | ||
4044 | 3645 | ||
4045 | } | 3646 | } |
4046 | 3647 | ||
@@ -4058,7 +3659,7 @@ public class InternalSolverLanguageParser extends AbstractInternalAntlrParser { | |||
4058 | 3659 | ||
4059 | 3660 | ||
4060 | // $ANTLR start "ruleUnaryExpression" | 3661 | // $ANTLR start "ruleUnaryExpression" |
4061 | // InternalSolverLanguage.g:1462:1: ruleUnaryExpression returns [EObject current=null] : (this_AggregationExpression_0= ruleAggregationExpression | ( () ( (lv_op_2_0= ruleUnaryOp ) ) ( (lv_body_3_0= ruleAggregationExpression ) ) ) ) ; | 3662 | // InternalSolverLanguageParser.g:1451:1: ruleUnaryExpression returns [EObject current=null] : (this_AggregationExpression_0= ruleAggregationExpression | ( () ( (lv_op_2_0= ruleUnaryOp ) ) ( (lv_body_3_0= ruleAggregationExpression ) ) ) ) ; |
4062 | public final EObject ruleUnaryExpression() throws RecognitionException { | 3663 | public final EObject ruleUnaryExpression() throws RecognitionException { |
4063 | EObject current = null; | 3664 | EObject current = null; |
4064 | 3665 | ||
@@ -4073,21 +3674,20 @@ public class InternalSolverLanguageParser extends AbstractInternalAntlrParser { | |||
4073 | enterRule(); | 3674 | enterRule(); |
4074 | 3675 | ||
4075 | try { | 3676 | try { |
4076 | // InternalSolverLanguage.g:1468:2: ( (this_AggregationExpression_0= ruleAggregationExpression | ( () ( (lv_op_2_0= ruleUnaryOp ) ) ( (lv_body_3_0= ruleAggregationExpression ) ) ) ) ) | 3677 | // InternalSolverLanguageParser.g:1457:2: ( (this_AggregationExpression_0= ruleAggregationExpression | ( () ( (lv_op_2_0= ruleUnaryOp ) ) ( (lv_body_3_0= ruleAggregationExpression ) ) ) ) ) |
4077 | // InternalSolverLanguage.g:1469:2: (this_AggregationExpression_0= ruleAggregationExpression | ( () ( (lv_op_2_0= ruleUnaryOp ) ) ( (lv_body_3_0= ruleAggregationExpression ) ) ) ) | 3678 | // InternalSolverLanguageParser.g:1458:2: (this_AggregationExpression_0= ruleAggregationExpression | ( () ( (lv_op_2_0= ruleUnaryOp ) ) ( (lv_body_3_0= ruleAggregationExpression ) ) ) ) |
4078 | { | 3679 | { |
4079 | // InternalSolverLanguage.g:1469:2: (this_AggregationExpression_0= ruleAggregationExpression | ( () ( (lv_op_2_0= ruleUnaryOp ) ) ( (lv_body_3_0= ruleAggregationExpression ) ) ) ) | 3680 | // InternalSolverLanguageParser.g:1458:2: (this_AggregationExpression_0= ruleAggregationExpression | ( () ( (lv_op_2_0= ruleUnaryOp ) ) ( (lv_body_3_0= ruleAggregationExpression ) ) ) ) |
4080 | int alt18=2; | 3681 | int alt18=2; |
4081 | int LA18_0 = input.LA(1); | 3682 | int LA18_0 = input.LA(1); |
4082 | 3683 | ||
4083 | if ( ((LA18_0>=RULE_STRING && LA18_0<=RULE_QUOTED_ID)||LA18_0==19||LA18_0==29||LA18_0==33||LA18_0==36||(LA18_0>=39 && LA18_0<=40)||(LA18_0>=64 && LA18_0<=72)) ) { | 3684 | if ( (LA18_0==Unknown||(LA18_0>=Count && LA18_0<=False)||(LA18_0>=Only && LA18_0<=Prod)||LA18_0==True||(LA18_0>=Avg && LA18_0<=Inf)||LA18_0==Max||(LA18_0>=Min && LA18_0<=Sum)||LA18_0==LeftParenthesis||LA18_0==LeftSquareBracket||(LA18_0>=RULE_STRING && LA18_0<=RULE_QUOTED_ID)||(LA18_0>=RULE_ID && LA18_0<=RULE_INT)) ) { |
4084 | alt18=1; | 3685 | alt18=1; |
4085 | } | 3686 | } |
4086 | else if ( ((LA18_0>=56 && LA18_0<=57)||(LA18_0>=60 && LA18_0<=63)) ) { | 3687 | else if ( (LA18_0==Current||LA18_0==Must||LA18_0==May||LA18_0==ExclamationMark||LA18_0==PlusSign||LA18_0==HyphenMinus) ) { |
4087 | alt18=2; | 3688 | alt18=2; |
4088 | } | 3689 | } |
4089 | else { | 3690 | else { |
4090 | if (state.backtracking>0) {state.failed=true; return current;} | ||
4091 | NoViableAltException nvae = | 3691 | NoViableAltException nvae = |
4092 | new NoViableAltException("", 18, 0, input); | 3692 | new NoViableAltException("", 18, 0, input); |
4093 | 3693 | ||
@@ -4095,110 +3695,96 @@ public class InternalSolverLanguageParser extends AbstractInternalAntlrParser { | |||
4095 | } | 3695 | } |
4096 | switch (alt18) { | 3696 | switch (alt18) { |
4097 | case 1 : | 3697 | case 1 : |
4098 | // InternalSolverLanguage.g:1470:3: this_AggregationExpression_0= ruleAggregationExpression | 3698 | // InternalSolverLanguageParser.g:1459:3: this_AggregationExpression_0= ruleAggregationExpression |
4099 | { | 3699 | { |
4100 | if ( state.backtracking==0 ) { | ||
4101 | 3700 | ||
4102 | newCompositeNode(grammarAccess.getUnaryExpressionAccess().getAggregationExpressionParserRuleCall_0()); | 3701 | newCompositeNode(grammarAccess.getUnaryExpressionAccess().getAggregationExpressionParserRuleCall_0()); |
4103 | 3702 | ||
4104 | } | ||
4105 | pushFollow(FOLLOW_2); | 3703 | pushFollow(FOLLOW_2); |
4106 | this_AggregationExpression_0=ruleAggregationExpression(); | 3704 | this_AggregationExpression_0=ruleAggregationExpression(); |
4107 | 3705 | ||
4108 | state._fsp--; | 3706 | state._fsp--; |
4109 | if (state.failed) return current; | ||
4110 | if ( state.backtracking==0 ) { | ||
4111 | 3707 | ||
4112 | current = this_AggregationExpression_0; | 3708 | |
4113 | afterParserOrEnumRuleCall(); | 3709 | current = this_AggregationExpression_0; |
4114 | 3710 | afterParserOrEnumRuleCall(); | |
4115 | } | 3711 | |
4116 | 3712 | ||
4117 | } | 3713 | } |
4118 | break; | 3714 | break; |
4119 | case 2 : | 3715 | case 2 : |
4120 | // InternalSolverLanguage.g:1479:3: ( () ( (lv_op_2_0= ruleUnaryOp ) ) ( (lv_body_3_0= ruleAggregationExpression ) ) ) | 3716 | // InternalSolverLanguageParser.g:1468:3: ( () ( (lv_op_2_0= ruleUnaryOp ) ) ( (lv_body_3_0= ruleAggregationExpression ) ) ) |
4121 | { | 3717 | { |
4122 | // InternalSolverLanguage.g:1479:3: ( () ( (lv_op_2_0= ruleUnaryOp ) ) ( (lv_body_3_0= ruleAggregationExpression ) ) ) | 3718 | // InternalSolverLanguageParser.g:1468:3: ( () ( (lv_op_2_0= ruleUnaryOp ) ) ( (lv_body_3_0= ruleAggregationExpression ) ) ) |
4123 | // InternalSolverLanguage.g:1480:4: () ( (lv_op_2_0= ruleUnaryOp ) ) ( (lv_body_3_0= ruleAggregationExpression ) ) | 3719 | // InternalSolverLanguageParser.g:1469:4: () ( (lv_op_2_0= ruleUnaryOp ) ) ( (lv_body_3_0= ruleAggregationExpression ) ) |
4124 | { | 3720 | { |
4125 | // InternalSolverLanguage.g:1480:4: () | 3721 | // InternalSolverLanguageParser.g:1469:4: () |
4126 | // InternalSolverLanguage.g:1481:5: | 3722 | // InternalSolverLanguageParser.g:1470:5: |
4127 | { | 3723 | { |
4128 | if ( state.backtracking==0 ) { | ||
4129 | 3724 | ||
4130 | current = forceCreateModelElement( | 3725 | current = forceCreateModelElement( |
4131 | grammarAccess.getUnaryExpressionAccess().getUnaryExpressionAction_1_0(), | 3726 | grammarAccess.getUnaryExpressionAccess().getUnaryExpressionAction_1_0(), |
4132 | current); | 3727 | current); |
4133 | 3728 | ||
4134 | } | ||
4135 | 3729 | ||
4136 | } | 3730 | } |
4137 | 3731 | ||
4138 | // InternalSolverLanguage.g:1487:4: ( (lv_op_2_0= ruleUnaryOp ) ) | 3732 | // InternalSolverLanguageParser.g:1476:4: ( (lv_op_2_0= ruleUnaryOp ) ) |
4139 | // InternalSolverLanguage.g:1488:5: (lv_op_2_0= ruleUnaryOp ) | 3733 | // InternalSolverLanguageParser.g:1477:5: (lv_op_2_0= ruleUnaryOp ) |
4140 | { | 3734 | { |
4141 | // InternalSolverLanguage.g:1488:5: (lv_op_2_0= ruleUnaryOp ) | 3735 | // InternalSolverLanguageParser.g:1477:5: (lv_op_2_0= ruleUnaryOp ) |
4142 | // InternalSolverLanguage.g:1489:6: lv_op_2_0= ruleUnaryOp | 3736 | // InternalSolverLanguageParser.g:1478:6: lv_op_2_0= ruleUnaryOp |
4143 | { | 3737 | { |
4144 | if ( state.backtracking==0 ) { | ||
4145 | 3738 | ||
4146 | newCompositeNode(grammarAccess.getUnaryExpressionAccess().getOpUnaryOpEnumRuleCall_1_1_0()); | 3739 | newCompositeNode(grammarAccess.getUnaryExpressionAccess().getOpUnaryOpEnumRuleCall_1_1_0()); |
4147 | 3740 | ||
4148 | } | ||
4149 | pushFollow(FOLLOW_25); | 3741 | pushFollow(FOLLOW_25); |
4150 | lv_op_2_0=ruleUnaryOp(); | 3742 | lv_op_2_0=ruleUnaryOp(); |
4151 | 3743 | ||
4152 | state._fsp--; | 3744 | state._fsp--; |
4153 | if (state.failed) return current; | ||
4154 | if ( state.backtracking==0 ) { | ||
4155 | 3745 | ||
4156 | if (current==null) { | 3746 | |
4157 | current = createModelElementForParent(grammarAccess.getUnaryExpressionRule()); | 3747 | if (current==null) { |
4158 | } | 3748 | current = createModelElementForParent(grammarAccess.getUnaryExpressionRule()); |
4159 | set( | 3749 | } |
4160 | current, | 3750 | set( |
4161 | "op", | 3751 | current, |
4162 | lv_op_2_0, | 3752 | "op", |
4163 | "org.eclipse.viatra.solver.language.SolverLanguage.UnaryOp"); | 3753 | lv_op_2_0, |
4164 | afterParserOrEnumRuleCall(); | 3754 | "org.eclipse.viatra.solver.language.SolverLanguage.UnaryOp"); |
4165 | 3755 | afterParserOrEnumRuleCall(); | |
4166 | } | 3756 | |
4167 | 3757 | ||
4168 | } | 3758 | } |
4169 | 3759 | ||
4170 | 3760 | ||
4171 | } | 3761 | } |
4172 | 3762 | ||
4173 | // InternalSolverLanguage.g:1506:4: ( (lv_body_3_0= ruleAggregationExpression ) ) | 3763 | // InternalSolverLanguageParser.g:1495:4: ( (lv_body_3_0= ruleAggregationExpression ) ) |
4174 | // InternalSolverLanguage.g:1507:5: (lv_body_3_0= ruleAggregationExpression ) | 3764 | // InternalSolverLanguageParser.g:1496:5: (lv_body_3_0= ruleAggregationExpression ) |
4175 | { | 3765 | { |
4176 | // InternalSolverLanguage.g:1507:5: (lv_body_3_0= ruleAggregationExpression ) | 3766 | // InternalSolverLanguageParser.g:1496:5: (lv_body_3_0= ruleAggregationExpression ) |
4177 | // InternalSolverLanguage.g:1508:6: lv_body_3_0= ruleAggregationExpression | 3767 | // InternalSolverLanguageParser.g:1497:6: lv_body_3_0= ruleAggregationExpression |
4178 | { | 3768 | { |
4179 | if ( state.backtracking==0 ) { | ||
4180 | 3769 | ||
4181 | newCompositeNode(grammarAccess.getUnaryExpressionAccess().getBodyAggregationExpressionParserRuleCall_1_2_0()); | 3770 | newCompositeNode(grammarAccess.getUnaryExpressionAccess().getBodyAggregationExpressionParserRuleCall_1_2_0()); |
4182 | 3771 | ||
4183 | } | ||
4184 | pushFollow(FOLLOW_2); | 3772 | pushFollow(FOLLOW_2); |
4185 | lv_body_3_0=ruleAggregationExpression(); | 3773 | lv_body_3_0=ruleAggregationExpression(); |
4186 | 3774 | ||
4187 | state._fsp--; | 3775 | state._fsp--; |
4188 | if (state.failed) return current; | ||
4189 | if ( state.backtracking==0 ) { | ||
4190 | 3776 | ||
4191 | if (current==null) { | 3777 | |
4192 | current = createModelElementForParent(grammarAccess.getUnaryExpressionRule()); | 3778 | if (current==null) { |
4193 | } | 3779 | current = createModelElementForParent(grammarAccess.getUnaryExpressionRule()); |
4194 | set( | 3780 | } |
4195 | current, | 3781 | set( |
4196 | "body", | 3782 | current, |
4197 | lv_body_3_0, | 3783 | "body", |
4198 | "org.eclipse.viatra.solver.language.SolverLanguage.AggregationExpression"); | 3784 | lv_body_3_0, |
4199 | afterParserOrEnumRuleCall(); | 3785 | "org.eclipse.viatra.solver.language.SolverLanguage.AggregationExpression"); |
4200 | 3786 | afterParserOrEnumRuleCall(); | |
4201 | } | 3787 | |
4202 | 3788 | ||
4203 | } | 3789 | } |
4204 | 3790 | ||
@@ -4217,11 +3803,9 @@ public class InternalSolverLanguageParser extends AbstractInternalAntlrParser { | |||
4217 | 3803 | ||
4218 | } | 3804 | } |
4219 | 3805 | ||
4220 | if ( state.backtracking==0 ) { | ||
4221 | 3806 | ||
4222 | leaveRule(); | 3807 | leaveRule(); |
4223 | 3808 | ||
4224 | } | ||
4225 | } | 3809 | } |
4226 | 3810 | ||
4227 | catch (RecognitionException re) { | 3811 | catch (RecognitionException re) { |
@@ -4236,7 +3820,7 @@ public class InternalSolverLanguageParser extends AbstractInternalAntlrParser { | |||
4236 | 3820 | ||
4237 | 3821 | ||
4238 | // $ANTLR start "entryRuleAggregationExpression" | 3822 | // $ANTLR start "entryRuleAggregationExpression" |
4239 | // InternalSolverLanguage.g:1530:1: entryRuleAggregationExpression returns [EObject current=null] : iv_ruleAggregationExpression= ruleAggregationExpression EOF ; | 3823 | // InternalSolverLanguageParser.g:1519:1: entryRuleAggregationExpression returns [EObject current=null] : iv_ruleAggregationExpression= ruleAggregationExpression EOF ; |
4240 | public final EObject entryRuleAggregationExpression() throws RecognitionException { | 3824 | public final EObject entryRuleAggregationExpression() throws RecognitionException { |
4241 | EObject current = null; | 3825 | EObject current = null; |
4242 | 3826 | ||
@@ -4244,21 +3828,17 @@ public class InternalSolverLanguageParser extends AbstractInternalAntlrParser { | |||
4244 | 3828 | ||
4245 | 3829 | ||
4246 | try { | 3830 | try { |
4247 | // InternalSolverLanguage.g:1530:62: (iv_ruleAggregationExpression= ruleAggregationExpression EOF ) | 3831 | // InternalSolverLanguageParser.g:1519:62: (iv_ruleAggregationExpression= ruleAggregationExpression EOF ) |
4248 | // InternalSolverLanguage.g:1531:2: iv_ruleAggregationExpression= ruleAggregationExpression EOF | 3832 | // InternalSolverLanguageParser.g:1520:2: iv_ruleAggregationExpression= ruleAggregationExpression EOF |
4249 | { | 3833 | { |
4250 | if ( state.backtracking==0 ) { | 3834 | newCompositeNode(grammarAccess.getAggregationExpressionRule()); |
4251 | newCompositeNode(grammarAccess.getAggregationExpressionRule()); | ||
4252 | } | ||
4253 | pushFollow(FOLLOW_1); | 3835 | pushFollow(FOLLOW_1); |
4254 | iv_ruleAggregationExpression=ruleAggregationExpression(); | 3836 | iv_ruleAggregationExpression=ruleAggregationExpression(); |
4255 | 3837 | ||
4256 | state._fsp--; | 3838 | state._fsp--; |
4257 | if (state.failed) return current; | 3839 | |
4258 | if ( state.backtracking==0 ) { | 3840 | current =iv_ruleAggregationExpression; |
4259 | current =iv_ruleAggregationExpression; | 3841 | match(input,EOF,FOLLOW_2); |
4260 | } | ||
4261 | match(input,EOF,FOLLOW_2); if (state.failed) return current; | ||
4262 | 3842 | ||
4263 | } | 3843 | } |
4264 | 3844 | ||
@@ -4276,7 +3856,7 @@ public class InternalSolverLanguageParser extends AbstractInternalAntlrParser { | |||
4276 | 3856 | ||
4277 | 3857 | ||
4278 | // $ANTLR start "ruleAggregationExpression" | 3858 | // $ANTLR start "ruleAggregationExpression" |
4279 | // InternalSolverLanguage.g:1537:1: ruleAggregationExpression returns [EObject current=null] : (this_AtomicExpression_0= ruleAtomicExpression | this_Count_1= ruleCount | this_Aggregation_2= ruleAggregation ) ; | 3859 | // InternalSolverLanguageParser.g:1526:1: ruleAggregationExpression returns [EObject current=null] : (this_AtomicExpression_0= ruleAtomicExpression | this_Count_1= ruleCount | this_Aggregation_2= ruleAggregation ) ; |
4280 | public final EObject ruleAggregationExpression() throws RecognitionException { | 3860 | public final EObject ruleAggregationExpression() throws RecognitionException { |
4281 | EObject current = null; | 3861 | EObject current = null; |
4282 | 3862 | ||
@@ -4291,45 +3871,44 @@ public class InternalSolverLanguageParser extends AbstractInternalAntlrParser { | |||
4291 | enterRule(); | 3871 | enterRule(); |
4292 | 3872 | ||
4293 | try { | 3873 | try { |
4294 | // InternalSolverLanguage.g:1543:2: ( (this_AtomicExpression_0= ruleAtomicExpression | this_Count_1= ruleCount | this_Aggregation_2= ruleAggregation ) ) | 3874 | // InternalSolverLanguageParser.g:1532:2: ( (this_AtomicExpression_0= ruleAtomicExpression | this_Count_1= ruleCount | this_Aggregation_2= ruleAggregation ) ) |
4295 | // InternalSolverLanguage.g:1544:2: (this_AtomicExpression_0= ruleAtomicExpression | this_Count_1= ruleCount | this_Aggregation_2= ruleAggregation ) | 3875 | // InternalSolverLanguageParser.g:1533:2: (this_AtomicExpression_0= ruleAtomicExpression | this_Count_1= ruleCount | this_Aggregation_2= ruleAggregation ) |
4296 | { | 3876 | { |
4297 | // InternalSolverLanguage.g:1544:2: (this_AtomicExpression_0= ruleAtomicExpression | this_Count_1= ruleCount | this_Aggregation_2= ruleAggregation ) | 3877 | // InternalSolverLanguageParser.g:1533:2: (this_AtomicExpression_0= ruleAtomicExpression | this_Count_1= ruleCount | this_Aggregation_2= ruleAggregation ) |
4298 | int alt19=3; | 3878 | int alt19=3; |
4299 | switch ( input.LA(1) ) { | 3879 | switch ( input.LA(1) ) { |
3880 | case Unknown: | ||
3881 | case Empty: | ||
3882 | case Error: | ||
3883 | case False: | ||
3884 | case True: | ||
3885 | case Inf: | ||
3886 | case LeftParenthesis: | ||
3887 | case LeftSquareBracket: | ||
4300 | case RULE_STRING: | 3888 | case RULE_STRING: |
3889 | case RULE_QUOTED_ID: | ||
4301 | case RULE_ID: | 3890 | case RULE_ID: |
4302 | case RULE_INT: | 3891 | case RULE_INT: |
4303 | case RULE_QUOTED_ID: | ||
4304 | case 19: | ||
4305 | case 33: | ||
4306 | case 36: | ||
4307 | case 39: | ||
4308 | case 40: | ||
4309 | case 70: | ||
4310 | case 71: | ||
4311 | case 72: | ||
4312 | { | 3892 | { |
4313 | alt19=1; | 3893 | alt19=1; |
4314 | } | 3894 | } |
4315 | break; | 3895 | break; |
4316 | case 29: | 3896 | case Count: |
4317 | { | 3897 | { |
4318 | alt19=2; | 3898 | alt19=2; |
4319 | } | 3899 | } |
4320 | break; | 3900 | break; |
4321 | case 64: | 3901 | case Only: |
4322 | case 65: | 3902 | case Prod: |
4323 | case 66: | 3903 | case Avg: |
4324 | case 67: | 3904 | case Max: |
4325 | case 68: | 3905 | case Min: |
4326 | case 69: | 3906 | case Sum: |
4327 | { | 3907 | { |
4328 | alt19=3; | 3908 | alt19=3; |
4329 | } | 3909 | } |
4330 | break; | 3910 | break; |
4331 | default: | 3911 | default: |
4332 | if (state.backtracking>0) {state.failed=true; return current;} | ||
4333 | NoViableAltException nvae = | 3912 | NoViableAltException nvae = |
4334 | new NoViableAltException("", 19, 0, input); | 3913 | new NoViableAltException("", 19, 0, input); |
4335 | 3914 | ||
@@ -4338,68 +3917,56 @@ public class InternalSolverLanguageParser extends AbstractInternalAntlrParser { | |||
4338 | 3917 | ||
4339 | switch (alt19) { | 3918 | switch (alt19) { |
4340 | case 1 : | 3919 | case 1 : |
4341 | // InternalSolverLanguage.g:1545:3: this_AtomicExpression_0= ruleAtomicExpression | 3920 | // InternalSolverLanguageParser.g:1534:3: this_AtomicExpression_0= ruleAtomicExpression |
4342 | { | 3921 | { |
4343 | if ( state.backtracking==0 ) { | ||
4344 | 3922 | ||
4345 | newCompositeNode(grammarAccess.getAggregationExpressionAccess().getAtomicExpressionParserRuleCall_0()); | 3923 | newCompositeNode(grammarAccess.getAggregationExpressionAccess().getAtomicExpressionParserRuleCall_0()); |
4346 | 3924 | ||
4347 | } | ||
4348 | pushFollow(FOLLOW_2); | 3925 | pushFollow(FOLLOW_2); |
4349 | this_AtomicExpression_0=ruleAtomicExpression(); | 3926 | this_AtomicExpression_0=ruleAtomicExpression(); |
4350 | 3927 | ||
4351 | state._fsp--; | 3928 | state._fsp--; |
4352 | if (state.failed) return current; | ||
4353 | if ( state.backtracking==0 ) { | ||
4354 | 3929 | ||
4355 | current = this_AtomicExpression_0; | 3930 | |
4356 | afterParserOrEnumRuleCall(); | 3931 | current = this_AtomicExpression_0; |
4357 | 3932 | afterParserOrEnumRuleCall(); | |
4358 | } | 3933 | |
4359 | 3934 | ||
4360 | } | 3935 | } |
4361 | break; | 3936 | break; |
4362 | case 2 : | 3937 | case 2 : |
4363 | // InternalSolverLanguage.g:1554:3: this_Count_1= ruleCount | 3938 | // InternalSolverLanguageParser.g:1543:3: this_Count_1= ruleCount |
4364 | { | 3939 | { |
4365 | if ( state.backtracking==0 ) { | ||
4366 | 3940 | ||
4367 | newCompositeNode(grammarAccess.getAggregationExpressionAccess().getCountParserRuleCall_1()); | 3941 | newCompositeNode(grammarAccess.getAggregationExpressionAccess().getCountParserRuleCall_1()); |
4368 | 3942 | ||
4369 | } | ||
4370 | pushFollow(FOLLOW_2); | 3943 | pushFollow(FOLLOW_2); |
4371 | this_Count_1=ruleCount(); | 3944 | this_Count_1=ruleCount(); |
4372 | 3945 | ||
4373 | state._fsp--; | 3946 | state._fsp--; |
4374 | if (state.failed) return current; | ||
4375 | if ( state.backtracking==0 ) { | ||
4376 | 3947 | ||
4377 | current = this_Count_1; | 3948 | |
4378 | afterParserOrEnumRuleCall(); | 3949 | current = this_Count_1; |
4379 | 3950 | afterParserOrEnumRuleCall(); | |
4380 | } | 3951 | |
4381 | 3952 | ||
4382 | } | 3953 | } |
4383 | break; | 3954 | break; |
4384 | case 3 : | 3955 | case 3 : |
4385 | // InternalSolverLanguage.g:1563:3: this_Aggregation_2= ruleAggregation | 3956 | // InternalSolverLanguageParser.g:1552:3: this_Aggregation_2= ruleAggregation |
4386 | { | 3957 | { |
4387 | if ( state.backtracking==0 ) { | ||
4388 | 3958 | ||
4389 | newCompositeNode(grammarAccess.getAggregationExpressionAccess().getAggregationParserRuleCall_2()); | 3959 | newCompositeNode(grammarAccess.getAggregationExpressionAccess().getAggregationParserRuleCall_2()); |
4390 | 3960 | ||
4391 | } | ||
4392 | pushFollow(FOLLOW_2); | 3961 | pushFollow(FOLLOW_2); |
4393 | this_Aggregation_2=ruleAggregation(); | 3962 | this_Aggregation_2=ruleAggregation(); |
4394 | 3963 | ||
4395 | state._fsp--; | 3964 | state._fsp--; |
4396 | if (state.failed) return current; | ||
4397 | if ( state.backtracking==0 ) { | ||
4398 | 3965 | ||
4399 | current = this_Aggregation_2; | 3966 | |
4400 | afterParserOrEnumRuleCall(); | 3967 | current = this_Aggregation_2; |
4401 | 3968 | afterParserOrEnumRuleCall(); | |
4402 | } | 3969 | |
4403 | 3970 | ||
4404 | } | 3971 | } |
4405 | break; | 3972 | break; |
@@ -4409,11 +3976,9 @@ public class InternalSolverLanguageParser extends AbstractInternalAntlrParser { | |||
4409 | 3976 | ||
4410 | } | 3977 | } |
4411 | 3978 | ||
4412 | if ( state.backtracking==0 ) { | ||
4413 | 3979 | ||
4414 | leaveRule(); | 3980 | leaveRule(); |
4415 | 3981 | ||
4416 | } | ||
4417 | } | 3982 | } |
4418 | 3983 | ||
4419 | catch (RecognitionException re) { | 3984 | catch (RecognitionException re) { |
@@ -4428,7 +3993,7 @@ public class InternalSolverLanguageParser extends AbstractInternalAntlrParser { | |||
4428 | 3993 | ||
4429 | 3994 | ||
4430 | // $ANTLR start "entryRuleCount" | 3995 | // $ANTLR start "entryRuleCount" |
4431 | // InternalSolverLanguage.g:1575:1: entryRuleCount returns [EObject current=null] : iv_ruleCount= ruleCount EOF ; | 3996 | // InternalSolverLanguageParser.g:1564:1: entryRuleCount returns [EObject current=null] : iv_ruleCount= ruleCount EOF ; |
4432 | public final EObject entryRuleCount() throws RecognitionException { | 3997 | public final EObject entryRuleCount() throws RecognitionException { |
4433 | EObject current = null; | 3998 | EObject current = null; |
4434 | 3999 | ||
@@ -4436,21 +4001,17 @@ public class InternalSolverLanguageParser extends AbstractInternalAntlrParser { | |||
4436 | 4001 | ||
4437 | 4002 | ||
4438 | try { | 4003 | try { |
4439 | // InternalSolverLanguage.g:1575:46: (iv_ruleCount= ruleCount EOF ) | 4004 | // InternalSolverLanguageParser.g:1564:46: (iv_ruleCount= ruleCount EOF ) |
4440 | // InternalSolverLanguage.g:1576:2: iv_ruleCount= ruleCount EOF | 4005 | // InternalSolverLanguageParser.g:1565:2: iv_ruleCount= ruleCount EOF |
4441 | { | 4006 | { |
4442 | if ( state.backtracking==0 ) { | 4007 | newCompositeNode(grammarAccess.getCountRule()); |
4443 | newCompositeNode(grammarAccess.getCountRule()); | ||
4444 | } | ||
4445 | pushFollow(FOLLOW_1); | 4008 | pushFollow(FOLLOW_1); |
4446 | iv_ruleCount=ruleCount(); | 4009 | iv_ruleCount=ruleCount(); |
4447 | 4010 | ||
4448 | state._fsp--; | 4011 | state._fsp--; |
4449 | if (state.failed) return current; | 4012 | |
4450 | if ( state.backtracking==0 ) { | 4013 | current =iv_ruleCount; |
4451 | current =iv_ruleCount; | 4014 | match(input,EOF,FOLLOW_2); |
4452 | } | ||
4453 | match(input,EOF,FOLLOW_2); if (state.failed) return current; | ||
4454 | 4015 | ||
4455 | } | 4016 | } |
4456 | 4017 | ||
@@ -4468,7 +4029,7 @@ public class InternalSolverLanguageParser extends AbstractInternalAntlrParser { | |||
4468 | 4029 | ||
4469 | 4030 | ||
4470 | // $ANTLR start "ruleCount" | 4031 | // $ANTLR start "ruleCount" |
4471 | // InternalSolverLanguage.g:1582:1: ruleCount returns [EObject current=null] : (otherlv_0= 'count' otherlv_1= '{' ( (lv_body_2_0= ruleExpression ) ) otherlv_3= '}' ) ; | 4032 | // InternalSolverLanguageParser.g:1571:1: ruleCount returns [EObject current=null] : (otherlv_0= Count otherlv_1= LeftCurlyBracket ( (lv_body_2_0= ruleExpression ) ) otherlv_3= RightCurlyBracket ) ; |
4472 | public final EObject ruleCount() throws RecognitionException { | 4033 | public final EObject ruleCount() throws RecognitionException { |
4473 | EObject current = null; | 4034 | EObject current = null; |
4474 | 4035 | ||
@@ -4482,76 +4043,64 @@ public class InternalSolverLanguageParser extends AbstractInternalAntlrParser { | |||
4482 | enterRule(); | 4043 | enterRule(); |
4483 | 4044 | ||
4484 | try { | 4045 | try { |
4485 | // InternalSolverLanguage.g:1588:2: ( (otherlv_0= 'count' otherlv_1= '{' ( (lv_body_2_0= ruleExpression ) ) otherlv_3= '}' ) ) | 4046 | // InternalSolverLanguageParser.g:1577:2: ( (otherlv_0= Count otherlv_1= LeftCurlyBracket ( (lv_body_2_0= ruleExpression ) ) otherlv_3= RightCurlyBracket ) ) |
4486 | // InternalSolverLanguage.g:1589:2: (otherlv_0= 'count' otherlv_1= '{' ( (lv_body_2_0= ruleExpression ) ) otherlv_3= '}' ) | 4047 | // InternalSolverLanguageParser.g:1578:2: (otherlv_0= Count otherlv_1= LeftCurlyBracket ( (lv_body_2_0= ruleExpression ) ) otherlv_3= RightCurlyBracket ) |
4487 | { | 4048 | { |
4488 | // InternalSolverLanguage.g:1589:2: (otherlv_0= 'count' otherlv_1= '{' ( (lv_body_2_0= ruleExpression ) ) otherlv_3= '}' ) | 4049 | // InternalSolverLanguageParser.g:1578:2: (otherlv_0= Count otherlv_1= LeftCurlyBracket ( (lv_body_2_0= ruleExpression ) ) otherlv_3= RightCurlyBracket ) |
4489 | // InternalSolverLanguage.g:1590:3: otherlv_0= 'count' otherlv_1= '{' ( (lv_body_2_0= ruleExpression ) ) otherlv_3= '}' | 4050 | // InternalSolverLanguageParser.g:1579:3: otherlv_0= Count otherlv_1= LeftCurlyBracket ( (lv_body_2_0= ruleExpression ) ) otherlv_3= RightCurlyBracket |
4490 | { | 4051 | { |
4491 | otherlv_0=(Token)match(input,29,FOLLOW_26); if (state.failed) return current; | 4052 | otherlv_0=(Token)match(input,Count,FOLLOW_26); |
4492 | if ( state.backtracking==0 ) { | ||
4493 | 4053 | ||
4494 | newLeafNode(otherlv_0, grammarAccess.getCountAccess().getCountKeyword_0()); | 4054 | newLeafNode(otherlv_0, grammarAccess.getCountAccess().getCountKeyword_0()); |
4495 | 4055 | ||
4496 | } | 4056 | otherlv_1=(Token)match(input,LeftCurlyBracket,FOLLOW_6); |
4497 | otherlv_1=(Token)match(input,30,FOLLOW_6); if (state.failed) return current; | ||
4498 | if ( state.backtracking==0 ) { | ||
4499 | 4057 | ||
4500 | newLeafNode(otherlv_1, grammarAccess.getCountAccess().getLeftCurlyBracketKeyword_1()); | 4058 | newLeafNode(otherlv_1, grammarAccess.getCountAccess().getLeftCurlyBracketKeyword_1()); |
4501 | 4059 | ||
4502 | } | 4060 | // InternalSolverLanguageParser.g:1587:3: ( (lv_body_2_0= ruleExpression ) ) |
4503 | // InternalSolverLanguage.g:1598:3: ( (lv_body_2_0= ruleExpression ) ) | 4061 | // InternalSolverLanguageParser.g:1588:4: (lv_body_2_0= ruleExpression ) |
4504 | // InternalSolverLanguage.g:1599:4: (lv_body_2_0= ruleExpression ) | ||
4505 | { | 4062 | { |
4506 | // InternalSolverLanguage.g:1599:4: (lv_body_2_0= ruleExpression ) | 4063 | // InternalSolverLanguageParser.g:1588:4: (lv_body_2_0= ruleExpression ) |
4507 | // InternalSolverLanguage.g:1600:5: lv_body_2_0= ruleExpression | 4064 | // InternalSolverLanguageParser.g:1589:5: lv_body_2_0= ruleExpression |
4508 | { | 4065 | { |
4509 | if ( state.backtracking==0 ) { | ||
4510 | 4066 | ||
4511 | newCompositeNode(grammarAccess.getCountAccess().getBodyExpressionParserRuleCall_2_0()); | 4067 | newCompositeNode(grammarAccess.getCountAccess().getBodyExpressionParserRuleCall_2_0()); |
4512 | 4068 | ||
4513 | } | ||
4514 | pushFollow(FOLLOW_27); | 4069 | pushFollow(FOLLOW_27); |
4515 | lv_body_2_0=ruleExpression(); | 4070 | lv_body_2_0=ruleExpression(); |
4516 | 4071 | ||
4517 | state._fsp--; | 4072 | state._fsp--; |
4518 | if (state.failed) return current; | ||
4519 | if ( state.backtracking==0 ) { | ||
4520 | 4073 | ||
4521 | if (current==null) { | 4074 | |
4522 | current = createModelElementForParent(grammarAccess.getCountRule()); | 4075 | if (current==null) { |
4523 | } | 4076 | current = createModelElementForParent(grammarAccess.getCountRule()); |
4524 | set( | 4077 | } |
4525 | current, | 4078 | set( |
4526 | "body", | 4079 | current, |
4527 | lv_body_2_0, | 4080 | "body", |
4528 | "org.eclipse.viatra.solver.language.SolverLanguage.Expression"); | 4081 | lv_body_2_0, |
4529 | afterParserOrEnumRuleCall(); | 4082 | "org.eclipse.viatra.solver.language.SolverLanguage.Expression"); |
4530 | 4083 | afterParserOrEnumRuleCall(); | |
4531 | } | 4084 | |
4532 | 4085 | ||
4533 | } | 4086 | } |
4534 | 4087 | ||
4535 | 4088 | ||
4536 | } | 4089 | } |
4537 | 4090 | ||
4538 | otherlv_3=(Token)match(input,31,FOLLOW_2); if (state.failed) return current; | 4091 | otherlv_3=(Token)match(input,RightCurlyBracket,FOLLOW_2); |
4539 | if ( state.backtracking==0 ) { | ||
4540 | 4092 | ||
4541 | newLeafNode(otherlv_3, grammarAccess.getCountAccess().getRightCurlyBracketKeyword_3()); | 4093 | newLeafNode(otherlv_3, grammarAccess.getCountAccess().getRightCurlyBracketKeyword_3()); |
4542 | 4094 | ||
4543 | } | ||
4544 | 4095 | ||
4545 | } | 4096 | } |
4546 | 4097 | ||
4547 | 4098 | ||
4548 | } | 4099 | } |
4549 | 4100 | ||
4550 | if ( state.backtracking==0 ) { | ||
4551 | 4101 | ||
4552 | leaveRule(); | 4102 | leaveRule(); |
4553 | 4103 | ||
4554 | } | ||
4555 | } | 4104 | } |
4556 | 4105 | ||
4557 | catch (RecognitionException re) { | 4106 | catch (RecognitionException re) { |
@@ -4566,7 +4115,7 @@ public class InternalSolverLanguageParser extends AbstractInternalAntlrParser { | |||
4566 | 4115 | ||
4567 | 4116 | ||
4568 | // $ANTLR start "entryRuleAggregation" | 4117 | // $ANTLR start "entryRuleAggregation" |
4569 | // InternalSolverLanguage.g:1625:1: entryRuleAggregation returns [EObject current=null] : iv_ruleAggregation= ruleAggregation EOF ; | 4118 | // InternalSolverLanguageParser.g:1614:1: entryRuleAggregation returns [EObject current=null] : iv_ruleAggregation= ruleAggregation EOF ; |
4570 | public final EObject entryRuleAggregation() throws RecognitionException { | 4119 | public final EObject entryRuleAggregation() throws RecognitionException { |
4571 | EObject current = null; | 4120 | EObject current = null; |
4572 | 4121 | ||
@@ -4574,21 +4123,17 @@ public class InternalSolverLanguageParser extends AbstractInternalAntlrParser { | |||
4574 | 4123 | ||
4575 | 4124 | ||
4576 | try { | 4125 | try { |
4577 | // InternalSolverLanguage.g:1625:52: (iv_ruleAggregation= ruleAggregation EOF ) | 4126 | // InternalSolverLanguageParser.g:1614:52: (iv_ruleAggregation= ruleAggregation EOF ) |
4578 | // InternalSolverLanguage.g:1626:2: iv_ruleAggregation= ruleAggregation EOF | 4127 | // InternalSolverLanguageParser.g:1615:2: iv_ruleAggregation= ruleAggregation EOF |
4579 | { | 4128 | { |
4580 | if ( state.backtracking==0 ) { | 4129 | newCompositeNode(grammarAccess.getAggregationRule()); |
4581 | newCompositeNode(grammarAccess.getAggregationRule()); | ||
4582 | } | ||
4583 | pushFollow(FOLLOW_1); | 4130 | pushFollow(FOLLOW_1); |
4584 | iv_ruleAggregation=ruleAggregation(); | 4131 | iv_ruleAggregation=ruleAggregation(); |
4585 | 4132 | ||
4586 | state._fsp--; | 4133 | state._fsp--; |
4587 | if (state.failed) return current; | 4134 | |
4588 | if ( state.backtracking==0 ) { | 4135 | current =iv_ruleAggregation; |
4589 | current =iv_ruleAggregation; | 4136 | match(input,EOF,FOLLOW_2); |
4590 | } | ||
4591 | match(input,EOF,FOLLOW_2); if (state.failed) return current; | ||
4592 | 4137 | ||
4593 | } | 4138 | } |
4594 | 4139 | ||
@@ -4606,7 +4151,7 @@ public class InternalSolverLanguageParser extends AbstractInternalAntlrParser { | |||
4606 | 4151 | ||
4607 | 4152 | ||
4608 | // $ANTLR start "ruleAggregation" | 4153 | // $ANTLR start "ruleAggregation" |
4609 | // InternalSolverLanguage.g:1632:1: ruleAggregation returns [EObject current=null] : ( ( (lv_op_0_0= ruleAggregationOp ) ) otherlv_1= '{' ( (lv_body_2_0= ruleExpression ) ) otherlv_3= '|' ( (lv_condition_4_0= ruleExpression ) ) otherlv_5= '}' ) ; | 4154 | // InternalSolverLanguageParser.g:1621:1: ruleAggregation returns [EObject current=null] : ( ( (lv_op_0_0= ruleAggregationOp ) ) otherlv_1= LeftCurlyBracket ( (lv_body_2_0= ruleExpression ) ) otherlv_3= VerticalLine ( (lv_condition_4_0= ruleExpression ) ) otherlv_5= RightCurlyBracket ) ; |
4610 | public final EObject ruleAggregation() throws RecognitionException { | 4155 | public final EObject ruleAggregation() throws RecognitionException { |
4611 | EObject current = null; | 4156 | EObject current = null; |
4612 | 4157 | ||
@@ -4624,146 +4169,126 @@ public class InternalSolverLanguageParser extends AbstractInternalAntlrParser { | |||
4624 | enterRule(); | 4169 | enterRule(); |
4625 | 4170 | ||
4626 | try { | 4171 | try { |
4627 | // InternalSolverLanguage.g:1638:2: ( ( ( (lv_op_0_0= ruleAggregationOp ) ) otherlv_1= '{' ( (lv_body_2_0= ruleExpression ) ) otherlv_3= '|' ( (lv_condition_4_0= ruleExpression ) ) otherlv_5= '}' ) ) | 4172 | // InternalSolverLanguageParser.g:1627:2: ( ( ( (lv_op_0_0= ruleAggregationOp ) ) otherlv_1= LeftCurlyBracket ( (lv_body_2_0= ruleExpression ) ) otherlv_3= VerticalLine ( (lv_condition_4_0= ruleExpression ) ) otherlv_5= RightCurlyBracket ) ) |
4628 | // InternalSolverLanguage.g:1639:2: ( ( (lv_op_0_0= ruleAggregationOp ) ) otherlv_1= '{' ( (lv_body_2_0= ruleExpression ) ) otherlv_3= '|' ( (lv_condition_4_0= ruleExpression ) ) otherlv_5= '}' ) | 4173 | // InternalSolverLanguageParser.g:1628:2: ( ( (lv_op_0_0= ruleAggregationOp ) ) otherlv_1= LeftCurlyBracket ( (lv_body_2_0= ruleExpression ) ) otherlv_3= VerticalLine ( (lv_condition_4_0= ruleExpression ) ) otherlv_5= RightCurlyBracket ) |
4629 | { | 4174 | { |
4630 | // InternalSolverLanguage.g:1639:2: ( ( (lv_op_0_0= ruleAggregationOp ) ) otherlv_1= '{' ( (lv_body_2_0= ruleExpression ) ) otherlv_3= '|' ( (lv_condition_4_0= ruleExpression ) ) otherlv_5= '}' ) | 4175 | // InternalSolverLanguageParser.g:1628:2: ( ( (lv_op_0_0= ruleAggregationOp ) ) otherlv_1= LeftCurlyBracket ( (lv_body_2_0= ruleExpression ) ) otherlv_3= VerticalLine ( (lv_condition_4_0= ruleExpression ) ) otherlv_5= RightCurlyBracket ) |
4631 | // InternalSolverLanguage.g:1640:3: ( (lv_op_0_0= ruleAggregationOp ) ) otherlv_1= '{' ( (lv_body_2_0= ruleExpression ) ) otherlv_3= '|' ( (lv_condition_4_0= ruleExpression ) ) otherlv_5= '}' | 4176 | // InternalSolverLanguageParser.g:1629:3: ( (lv_op_0_0= ruleAggregationOp ) ) otherlv_1= LeftCurlyBracket ( (lv_body_2_0= ruleExpression ) ) otherlv_3= VerticalLine ( (lv_condition_4_0= ruleExpression ) ) otherlv_5= RightCurlyBracket |
4632 | { | 4177 | { |
4633 | // InternalSolverLanguage.g:1640:3: ( (lv_op_0_0= ruleAggregationOp ) ) | 4178 | // InternalSolverLanguageParser.g:1629:3: ( (lv_op_0_0= ruleAggregationOp ) ) |
4634 | // InternalSolverLanguage.g:1641:4: (lv_op_0_0= ruleAggregationOp ) | 4179 | // InternalSolverLanguageParser.g:1630:4: (lv_op_0_0= ruleAggregationOp ) |
4635 | { | 4180 | { |
4636 | // InternalSolverLanguage.g:1641:4: (lv_op_0_0= ruleAggregationOp ) | 4181 | // InternalSolverLanguageParser.g:1630:4: (lv_op_0_0= ruleAggregationOp ) |
4637 | // InternalSolverLanguage.g:1642:5: lv_op_0_0= ruleAggregationOp | 4182 | // InternalSolverLanguageParser.g:1631:5: lv_op_0_0= ruleAggregationOp |
4638 | { | 4183 | { |
4639 | if ( state.backtracking==0 ) { | ||
4640 | 4184 | ||
4641 | newCompositeNode(grammarAccess.getAggregationAccess().getOpAggregationOpEnumRuleCall_0_0()); | 4185 | newCompositeNode(grammarAccess.getAggregationAccess().getOpAggregationOpEnumRuleCall_0_0()); |
4642 | 4186 | ||
4643 | } | ||
4644 | pushFollow(FOLLOW_26); | 4187 | pushFollow(FOLLOW_26); |
4645 | lv_op_0_0=ruleAggregationOp(); | 4188 | lv_op_0_0=ruleAggregationOp(); |
4646 | 4189 | ||
4647 | state._fsp--; | 4190 | state._fsp--; |
4648 | if (state.failed) return current; | ||
4649 | if ( state.backtracking==0 ) { | ||
4650 | 4191 | ||
4651 | if (current==null) { | 4192 | |
4652 | current = createModelElementForParent(grammarAccess.getAggregationRule()); | 4193 | if (current==null) { |
4653 | } | 4194 | current = createModelElementForParent(grammarAccess.getAggregationRule()); |
4654 | set( | 4195 | } |
4655 | current, | 4196 | set( |
4656 | "op", | 4197 | current, |
4657 | lv_op_0_0, | 4198 | "op", |
4658 | "org.eclipse.viatra.solver.language.SolverLanguage.AggregationOp"); | 4199 | lv_op_0_0, |
4659 | afterParserOrEnumRuleCall(); | 4200 | "org.eclipse.viatra.solver.language.SolverLanguage.AggregationOp"); |
4660 | 4201 | afterParserOrEnumRuleCall(); | |
4661 | } | 4202 | |
4662 | 4203 | ||
4663 | } | 4204 | } |
4664 | 4205 | ||
4665 | 4206 | ||
4666 | } | 4207 | } |
4667 | 4208 | ||
4668 | otherlv_1=(Token)match(input,30,FOLLOW_6); if (state.failed) return current; | 4209 | otherlv_1=(Token)match(input,LeftCurlyBracket,FOLLOW_6); |
4669 | if ( state.backtracking==0 ) { | ||
4670 | 4210 | ||
4671 | newLeafNode(otherlv_1, grammarAccess.getAggregationAccess().getLeftCurlyBracketKeyword_1()); | 4211 | newLeafNode(otherlv_1, grammarAccess.getAggregationAccess().getLeftCurlyBracketKeyword_1()); |
4672 | 4212 | ||
4673 | } | 4213 | // InternalSolverLanguageParser.g:1652:3: ( (lv_body_2_0= ruleExpression ) ) |
4674 | // InternalSolverLanguage.g:1663:3: ( (lv_body_2_0= ruleExpression ) ) | 4214 | // InternalSolverLanguageParser.g:1653:4: (lv_body_2_0= ruleExpression ) |
4675 | // InternalSolverLanguage.g:1664:4: (lv_body_2_0= ruleExpression ) | ||
4676 | { | 4215 | { |
4677 | // InternalSolverLanguage.g:1664:4: (lv_body_2_0= ruleExpression ) | 4216 | // InternalSolverLanguageParser.g:1653:4: (lv_body_2_0= ruleExpression ) |
4678 | // InternalSolverLanguage.g:1665:5: lv_body_2_0= ruleExpression | 4217 | // InternalSolverLanguageParser.g:1654:5: lv_body_2_0= ruleExpression |
4679 | { | 4218 | { |
4680 | if ( state.backtracking==0 ) { | ||
4681 | 4219 | ||
4682 | newCompositeNode(grammarAccess.getAggregationAccess().getBodyExpressionParserRuleCall_2_0()); | 4220 | newCompositeNode(grammarAccess.getAggregationAccess().getBodyExpressionParserRuleCall_2_0()); |
4683 | 4221 | ||
4684 | } | ||
4685 | pushFollow(FOLLOW_28); | 4222 | pushFollow(FOLLOW_28); |
4686 | lv_body_2_0=ruleExpression(); | 4223 | lv_body_2_0=ruleExpression(); |
4687 | 4224 | ||
4688 | state._fsp--; | 4225 | state._fsp--; |
4689 | if (state.failed) return current; | ||
4690 | if ( state.backtracking==0 ) { | ||
4691 | 4226 | ||
4692 | if (current==null) { | 4227 | |
4693 | current = createModelElementForParent(grammarAccess.getAggregationRule()); | 4228 | if (current==null) { |
4694 | } | 4229 | current = createModelElementForParent(grammarAccess.getAggregationRule()); |
4695 | set( | 4230 | } |
4696 | current, | 4231 | set( |
4697 | "body", | 4232 | current, |
4698 | lv_body_2_0, | 4233 | "body", |
4699 | "org.eclipse.viatra.solver.language.SolverLanguage.Expression"); | 4234 | lv_body_2_0, |
4700 | afterParserOrEnumRuleCall(); | 4235 | "org.eclipse.viatra.solver.language.SolverLanguage.Expression"); |
4701 | 4236 | afterParserOrEnumRuleCall(); | |
4702 | } | 4237 | |
4703 | 4238 | ||
4704 | } | 4239 | } |
4705 | 4240 | ||
4706 | 4241 | ||
4707 | } | 4242 | } |
4708 | 4243 | ||
4709 | otherlv_3=(Token)match(input,32,FOLLOW_6); if (state.failed) return current; | 4244 | otherlv_3=(Token)match(input,VerticalLine,FOLLOW_6); |
4710 | if ( state.backtracking==0 ) { | ||
4711 | 4245 | ||
4712 | newLeafNode(otherlv_3, grammarAccess.getAggregationAccess().getVerticalLineKeyword_3()); | 4246 | newLeafNode(otherlv_3, grammarAccess.getAggregationAccess().getVerticalLineKeyword_3()); |
4713 | 4247 | ||
4714 | } | 4248 | // InternalSolverLanguageParser.g:1675:3: ( (lv_condition_4_0= ruleExpression ) ) |
4715 | // InternalSolverLanguage.g:1686:3: ( (lv_condition_4_0= ruleExpression ) ) | 4249 | // InternalSolverLanguageParser.g:1676:4: (lv_condition_4_0= ruleExpression ) |
4716 | // InternalSolverLanguage.g:1687:4: (lv_condition_4_0= ruleExpression ) | ||
4717 | { | 4250 | { |
4718 | // InternalSolverLanguage.g:1687:4: (lv_condition_4_0= ruleExpression ) | 4251 | // InternalSolverLanguageParser.g:1676:4: (lv_condition_4_0= ruleExpression ) |
4719 | // InternalSolverLanguage.g:1688:5: lv_condition_4_0= ruleExpression | 4252 | // InternalSolverLanguageParser.g:1677:5: lv_condition_4_0= ruleExpression |
4720 | { | 4253 | { |
4721 | if ( state.backtracking==0 ) { | ||
4722 | 4254 | ||
4723 | newCompositeNode(grammarAccess.getAggregationAccess().getConditionExpressionParserRuleCall_4_0()); | 4255 | newCompositeNode(grammarAccess.getAggregationAccess().getConditionExpressionParserRuleCall_4_0()); |
4724 | 4256 | ||
4725 | } | ||
4726 | pushFollow(FOLLOW_27); | 4257 | pushFollow(FOLLOW_27); |
4727 | lv_condition_4_0=ruleExpression(); | 4258 | lv_condition_4_0=ruleExpression(); |
4728 | 4259 | ||
4729 | state._fsp--; | 4260 | state._fsp--; |
4730 | if (state.failed) return current; | ||
4731 | if ( state.backtracking==0 ) { | ||
4732 | 4261 | ||
4733 | if (current==null) { | 4262 | |
4734 | current = createModelElementForParent(grammarAccess.getAggregationRule()); | 4263 | if (current==null) { |
4735 | } | 4264 | current = createModelElementForParent(grammarAccess.getAggregationRule()); |
4736 | set( | 4265 | } |
4737 | current, | 4266 | set( |
4738 | "condition", | 4267 | current, |
4739 | lv_condition_4_0, | 4268 | "condition", |
4740 | "org.eclipse.viatra.solver.language.SolverLanguage.Expression"); | 4269 | lv_condition_4_0, |
4741 | afterParserOrEnumRuleCall(); | 4270 | "org.eclipse.viatra.solver.language.SolverLanguage.Expression"); |
4742 | 4271 | afterParserOrEnumRuleCall(); | |
4743 | } | 4272 | |
4744 | 4273 | ||
4745 | } | 4274 | } |
4746 | 4275 | ||
4747 | 4276 | ||
4748 | } | 4277 | } |
4749 | 4278 | ||
4750 | otherlv_5=(Token)match(input,31,FOLLOW_2); if (state.failed) return current; | 4279 | otherlv_5=(Token)match(input,RightCurlyBracket,FOLLOW_2); |
4751 | if ( state.backtracking==0 ) { | ||
4752 | 4280 | ||
4753 | newLeafNode(otherlv_5, grammarAccess.getAggregationAccess().getRightCurlyBracketKeyword_5()); | 4281 | newLeafNode(otherlv_5, grammarAccess.getAggregationAccess().getRightCurlyBracketKeyword_5()); |
4754 | 4282 | ||
4755 | } | ||
4756 | 4283 | ||
4757 | } | 4284 | } |
4758 | 4285 | ||
4759 | 4286 | ||
4760 | } | 4287 | } |
4761 | 4288 | ||
4762 | if ( state.backtracking==0 ) { | ||
4763 | 4289 | ||
4764 | leaveRule(); | 4290 | leaveRule(); |
4765 | 4291 | ||
4766 | } | ||
4767 | } | 4292 | } |
4768 | 4293 | ||
4769 | catch (RecognitionException re) { | 4294 | catch (RecognitionException re) { |
@@ -4778,7 +4303,7 @@ public class InternalSolverLanguageParser extends AbstractInternalAntlrParser { | |||
4778 | 4303 | ||
4779 | 4304 | ||
4780 | // $ANTLR start "entryRuleAtomicExpression" | 4305 | // $ANTLR start "entryRuleAtomicExpression" |
4781 | // InternalSolverLanguage.g:1713:1: entryRuleAtomicExpression returns [EObject current=null] : iv_ruleAtomicExpression= ruleAtomicExpression EOF ; | 4306 | // InternalSolverLanguageParser.g:1702:1: entryRuleAtomicExpression returns [EObject current=null] : iv_ruleAtomicExpression= ruleAtomicExpression EOF ; |
4782 | public final EObject entryRuleAtomicExpression() throws RecognitionException { | 4307 | public final EObject entryRuleAtomicExpression() throws RecognitionException { |
4783 | EObject current = null; | 4308 | EObject current = null; |
4784 | 4309 | ||
@@ -4786,21 +4311,17 @@ public class InternalSolverLanguageParser extends AbstractInternalAntlrParser { | |||
4786 | 4311 | ||
4787 | 4312 | ||
4788 | try { | 4313 | try { |
4789 | // InternalSolverLanguage.g:1713:57: (iv_ruleAtomicExpression= ruleAtomicExpression EOF ) | 4314 | // InternalSolverLanguageParser.g:1702:57: (iv_ruleAtomicExpression= ruleAtomicExpression EOF ) |
4790 | // InternalSolverLanguage.g:1714:2: iv_ruleAtomicExpression= ruleAtomicExpression EOF | 4315 | // InternalSolverLanguageParser.g:1703:2: iv_ruleAtomicExpression= ruleAtomicExpression EOF |
4791 | { | 4316 | { |
4792 | if ( state.backtracking==0 ) { | 4317 | newCompositeNode(grammarAccess.getAtomicExpressionRule()); |
4793 | newCompositeNode(grammarAccess.getAtomicExpressionRule()); | ||
4794 | } | ||
4795 | pushFollow(FOLLOW_1); | 4318 | pushFollow(FOLLOW_1); |
4796 | iv_ruleAtomicExpression=ruleAtomicExpression(); | 4319 | iv_ruleAtomicExpression=ruleAtomicExpression(); |
4797 | 4320 | ||
4798 | state._fsp--; | 4321 | state._fsp--; |
4799 | if (state.failed) return current; | 4322 | |
4800 | if ( state.backtracking==0 ) { | 4323 | current =iv_ruleAtomicExpression; |
4801 | current =iv_ruleAtomicExpression; | 4324 | match(input,EOF,FOLLOW_2); |
4802 | } | ||
4803 | match(input,EOF,FOLLOW_2); if (state.failed) return current; | ||
4804 | 4325 | ||
4805 | } | 4326 | } |
4806 | 4327 | ||
@@ -4818,241 +4339,132 @@ public class InternalSolverLanguageParser extends AbstractInternalAntlrParser { | |||
4818 | 4339 | ||
4819 | 4340 | ||
4820 | // $ANTLR start "ruleAtomicExpression" | 4341 | // $ANTLR start "ruleAtomicExpression" |
4821 | // InternalSolverLanguage.g:1720:1: ruleAtomicExpression returns [EObject current=null] : ( (this_Reference_0= ruleReference ( () ( ( '(' )=> (lv_argumentList_2_0= ruleArgumentList ) ) )? ) | this_Interval_3= ruleInterval | this_Literal_4= ruleLiteral | (otherlv_5= '(' this_Expression_6= ruleExpression otherlv_7= ')' ) ) ; | 4342 | // InternalSolverLanguageParser.g:1709:1: ruleAtomicExpression returns [EObject current=null] : (this_Reference_0= ruleReference | this_Call_1= ruleCall | this_Interval_2= ruleInterval | this_Literal_3= ruleLiteral | (otherlv_4= LeftParenthesis this_Expression_5= ruleExpression otherlv_6= RightParenthesis ) ) ; |
4822 | public final EObject ruleAtomicExpression() throws RecognitionException { | 4343 | public final EObject ruleAtomicExpression() throws RecognitionException { |
4823 | EObject current = null; | 4344 | EObject current = null; |
4824 | 4345 | ||
4825 | Token otherlv_5=null; | 4346 | Token otherlv_4=null; |
4826 | Token otherlv_7=null; | 4347 | Token otherlv_6=null; |
4827 | EObject this_Reference_0 = null; | 4348 | EObject this_Reference_0 = null; |
4828 | 4349 | ||
4829 | EObject lv_argumentList_2_0 = null; | 4350 | EObject this_Call_1 = null; |
4830 | 4351 | ||
4831 | EObject this_Interval_3 = null; | 4352 | EObject this_Interval_2 = null; |
4832 | 4353 | ||
4833 | EObject this_Literal_4 = null; | 4354 | EObject this_Literal_3 = null; |
4834 | 4355 | ||
4835 | EObject this_Expression_6 = null; | 4356 | EObject this_Expression_5 = null; |
4836 | 4357 | ||
4837 | 4358 | ||
4838 | 4359 | ||
4839 | enterRule(); | 4360 | enterRule(); |
4840 | 4361 | ||
4841 | try { | 4362 | try { |
4842 | // InternalSolverLanguage.g:1726:2: ( ( (this_Reference_0= ruleReference ( () ( ( '(' )=> (lv_argumentList_2_0= ruleArgumentList ) ) )? ) | this_Interval_3= ruleInterval | this_Literal_4= ruleLiteral | (otherlv_5= '(' this_Expression_6= ruleExpression otherlv_7= ')' ) ) ) | 4363 | // InternalSolverLanguageParser.g:1715:2: ( (this_Reference_0= ruleReference | this_Call_1= ruleCall | this_Interval_2= ruleInterval | this_Literal_3= ruleLiteral | (otherlv_4= LeftParenthesis this_Expression_5= ruleExpression otherlv_6= RightParenthesis ) ) ) |
4843 | // InternalSolverLanguage.g:1727:2: ( (this_Reference_0= ruleReference ( () ( ( '(' )=> (lv_argumentList_2_0= ruleArgumentList ) ) )? ) | this_Interval_3= ruleInterval | this_Literal_4= ruleLiteral | (otherlv_5= '(' this_Expression_6= ruleExpression otherlv_7= ')' ) ) | 4364 | // InternalSolverLanguageParser.g:1716:2: (this_Reference_0= ruleReference | this_Call_1= ruleCall | this_Interval_2= ruleInterval | this_Literal_3= ruleLiteral | (otherlv_4= LeftParenthesis this_Expression_5= ruleExpression otherlv_6= RightParenthesis ) ) |
4844 | { | 4365 | { |
4845 | // InternalSolverLanguage.g:1727:2: ( (this_Reference_0= ruleReference ( () ( ( '(' )=> (lv_argumentList_2_0= ruleArgumentList ) ) )? ) | this_Interval_3= ruleInterval | this_Literal_4= ruleLiteral | (otherlv_5= '(' this_Expression_6= ruleExpression otherlv_7= ')' ) ) | 4366 | // InternalSolverLanguageParser.g:1716:2: (this_Reference_0= ruleReference | this_Call_1= ruleCall | this_Interval_2= ruleInterval | this_Literal_3= ruleLiteral | (otherlv_4= LeftParenthesis this_Expression_5= ruleExpression otherlv_6= RightParenthesis ) ) |
4846 | int alt21=4; | 4367 | int alt20=5; |
4847 | switch ( input.LA(1) ) { | 4368 | alt20 = dfa20.predict(input); |
4848 | case RULE_ID: | 4369 | switch (alt20) { |
4849 | case RULE_QUOTED_ID: | ||
4850 | { | ||
4851 | alt21=1; | ||
4852 | } | ||
4853 | break; | ||
4854 | case 36: | ||
4855 | { | ||
4856 | alt21=2; | ||
4857 | } | ||
4858 | break; | ||
4859 | case RULE_STRING: | ||
4860 | case RULE_INT: | ||
4861 | case 19: | ||
4862 | case 39: | ||
4863 | case 40: | ||
4864 | case 70: | ||
4865 | case 71: | ||
4866 | case 72: | ||
4867 | { | ||
4868 | alt21=3; | ||
4869 | } | ||
4870 | break; | ||
4871 | case 33: | ||
4872 | { | ||
4873 | alt21=4; | ||
4874 | } | ||
4875 | break; | ||
4876 | default: | ||
4877 | if (state.backtracking>0) {state.failed=true; return current;} | ||
4878 | NoViableAltException nvae = | ||
4879 | new NoViableAltException("", 21, 0, input); | ||
4880 | |||
4881 | throw nvae; | ||
4882 | } | ||
4883 | |||
4884 | switch (alt21) { | ||
4885 | case 1 : | 4370 | case 1 : |
4886 | // InternalSolverLanguage.g:1728:3: (this_Reference_0= ruleReference ( () ( ( '(' )=> (lv_argumentList_2_0= ruleArgumentList ) ) )? ) | 4371 | // InternalSolverLanguageParser.g:1717:3: this_Reference_0= ruleReference |
4887 | { | 4372 | { |
4888 | // InternalSolverLanguage.g:1728:3: (this_Reference_0= ruleReference ( () ( ( '(' )=> (lv_argumentList_2_0= ruleArgumentList ) ) )? ) | ||
4889 | // InternalSolverLanguage.g:1729:4: this_Reference_0= ruleReference ( () ( ( '(' )=> (lv_argumentList_2_0= ruleArgumentList ) ) )? | ||
4890 | { | ||
4891 | if ( state.backtracking==0 ) { | ||
4892 | 4373 | ||
4893 | newCompositeNode(grammarAccess.getAtomicExpressionAccess().getReferenceParserRuleCall_0_0()); | 4374 | newCompositeNode(grammarAccess.getAtomicExpressionAccess().getReferenceParserRuleCall_0()); |
4894 | 4375 | ||
4895 | } | 4376 | pushFollow(FOLLOW_2); |
4896 | pushFollow(FOLLOW_29); | ||
4897 | this_Reference_0=ruleReference(); | 4377 | this_Reference_0=ruleReference(); |
4898 | 4378 | ||
4899 | state._fsp--; | 4379 | state._fsp--; |
4900 | if (state.failed) return current; | ||
4901 | if ( state.backtracking==0 ) { | ||
4902 | |||
4903 | current = this_Reference_0; | ||
4904 | afterParserOrEnumRuleCall(); | ||
4905 | |||
4906 | } | ||
4907 | // InternalSolverLanguage.g:1737:4: ( () ( ( '(' )=> (lv_argumentList_2_0= ruleArgumentList ) ) )? | ||
4908 | int alt20=2; | ||
4909 | int LA20_0 = input.LA(1); | ||
4910 | |||
4911 | if ( (LA20_0==33) ) { | ||
4912 | alt20=1; | ||
4913 | } | ||
4914 | switch (alt20) { | ||
4915 | case 1 : | ||
4916 | // InternalSolverLanguage.g:1738:5: () ( ( '(' )=> (lv_argumentList_2_0= ruleArgumentList ) ) | ||
4917 | { | ||
4918 | // InternalSolverLanguage.g:1738:5: () | ||
4919 | // InternalSolverLanguage.g:1739:6: | ||
4920 | { | ||
4921 | if ( state.backtracking==0 ) { | ||
4922 | |||
4923 | current = forceCreateModelElementAndSet( | ||
4924 | grammarAccess.getAtomicExpressionAccess().getCallFunctorAction_0_1_0(), | ||
4925 | current); | ||
4926 | |||
4927 | } | ||
4928 | 4380 | ||
4929 | } | ||
4930 | 4381 | ||
4931 | // InternalSolverLanguage.g:1745:5: ( ( '(' )=> (lv_argumentList_2_0= ruleArgumentList ) ) | 4382 | current = this_Reference_0; |
4932 | // InternalSolverLanguage.g:1746:6: ( '(' )=> (lv_argumentList_2_0= ruleArgumentList ) | 4383 | afterParserOrEnumRuleCall(); |
4933 | { | 4384 | |
4934 | // InternalSolverLanguage.g:1747:6: (lv_argumentList_2_0= ruleArgumentList ) | ||
4935 | // InternalSolverLanguage.g:1748:7: lv_argumentList_2_0= ruleArgumentList | ||
4936 | { | ||
4937 | if ( state.backtracking==0 ) { | ||
4938 | |||
4939 | newCompositeNode(grammarAccess.getAtomicExpressionAccess().getArgumentListArgumentListParserRuleCall_0_1_1_0()); | ||
4940 | |||
4941 | } | ||
4942 | pushFollow(FOLLOW_2); | ||
4943 | lv_argumentList_2_0=ruleArgumentList(); | ||
4944 | |||
4945 | state._fsp--; | ||
4946 | if (state.failed) return current; | ||
4947 | if ( state.backtracking==0 ) { | ||
4948 | |||
4949 | if (current==null) { | ||
4950 | current = createModelElementForParent(grammarAccess.getAtomicExpressionRule()); | ||
4951 | } | ||
4952 | set( | ||
4953 | current, | ||
4954 | "argumentList", | ||
4955 | lv_argumentList_2_0, | ||
4956 | "org.eclipse.viatra.solver.language.SolverLanguage.ArgumentList"); | ||
4957 | afterParserOrEnumRuleCall(); | ||
4958 | |||
4959 | } | ||
4960 | |||
4961 | } | ||
4962 | |||
4963 | |||
4964 | } | ||
4965 | |||
4966 | |||
4967 | } | ||
4968 | break; | ||
4969 | 4385 | ||
4970 | } | 4386 | } |
4387 | break; | ||
4388 | case 2 : | ||
4389 | // InternalSolverLanguageParser.g:1726:3: this_Call_1= ruleCall | ||
4390 | { | ||
4971 | 4391 | ||
4392 | newCompositeNode(grammarAccess.getAtomicExpressionAccess().getCallParserRuleCall_1()); | ||
4393 | |||
4394 | pushFollow(FOLLOW_2); | ||
4395 | this_Call_1=ruleCall(); | ||
4396 | |||
4397 | state._fsp--; | ||
4972 | 4398 | ||
4973 | } | ||
4974 | 4399 | ||
4400 | current = this_Call_1; | ||
4401 | afterParserOrEnumRuleCall(); | ||
4402 | |||
4975 | 4403 | ||
4976 | } | 4404 | } |
4977 | break; | 4405 | break; |
4978 | case 2 : | 4406 | case 3 : |
4979 | // InternalSolverLanguage.g:1768:3: this_Interval_3= ruleInterval | 4407 | // InternalSolverLanguageParser.g:1735:3: this_Interval_2= ruleInterval |
4980 | { | 4408 | { |
4981 | if ( state.backtracking==0 ) { | ||
4982 | 4409 | ||
4983 | newCompositeNode(grammarAccess.getAtomicExpressionAccess().getIntervalParserRuleCall_1()); | 4410 | newCompositeNode(grammarAccess.getAtomicExpressionAccess().getIntervalParserRuleCall_2()); |
4984 | 4411 | ||
4985 | } | ||
4986 | pushFollow(FOLLOW_2); | 4412 | pushFollow(FOLLOW_2); |
4987 | this_Interval_3=ruleInterval(); | 4413 | this_Interval_2=ruleInterval(); |
4988 | 4414 | ||
4989 | state._fsp--; | 4415 | state._fsp--; |
4990 | if (state.failed) return current; | ||
4991 | if ( state.backtracking==0 ) { | ||
4992 | 4416 | ||
4993 | current = this_Interval_3; | 4417 | |
4994 | afterParserOrEnumRuleCall(); | 4418 | current = this_Interval_2; |
4995 | 4419 | afterParserOrEnumRuleCall(); | |
4996 | } | 4420 | |
4997 | 4421 | ||
4998 | } | 4422 | } |
4999 | break; | 4423 | break; |
5000 | case 3 : | 4424 | case 4 : |
5001 | // InternalSolverLanguage.g:1777:3: this_Literal_4= ruleLiteral | 4425 | // InternalSolverLanguageParser.g:1744:3: this_Literal_3= ruleLiteral |
5002 | { | 4426 | { |
5003 | if ( state.backtracking==0 ) { | ||
5004 | 4427 | ||
5005 | newCompositeNode(grammarAccess.getAtomicExpressionAccess().getLiteralParserRuleCall_2()); | 4428 | newCompositeNode(grammarAccess.getAtomicExpressionAccess().getLiteralParserRuleCall_3()); |
5006 | 4429 | ||
5007 | } | ||
5008 | pushFollow(FOLLOW_2); | 4430 | pushFollow(FOLLOW_2); |
5009 | this_Literal_4=ruleLiteral(); | 4431 | this_Literal_3=ruleLiteral(); |
5010 | 4432 | ||
5011 | state._fsp--; | 4433 | state._fsp--; |
5012 | if (state.failed) return current; | ||
5013 | if ( state.backtracking==0 ) { | ||
5014 | 4434 | ||
5015 | current = this_Literal_4; | 4435 | |
5016 | afterParserOrEnumRuleCall(); | 4436 | current = this_Literal_3; |
5017 | 4437 | afterParserOrEnumRuleCall(); | |
5018 | } | 4438 | |
5019 | 4439 | ||
5020 | } | 4440 | } |
5021 | break; | 4441 | break; |
5022 | case 4 : | 4442 | case 5 : |
5023 | // InternalSolverLanguage.g:1786:3: (otherlv_5= '(' this_Expression_6= ruleExpression otherlv_7= ')' ) | 4443 | // InternalSolverLanguageParser.g:1753:3: (otherlv_4= LeftParenthesis this_Expression_5= ruleExpression otherlv_6= RightParenthesis ) |
5024 | { | 4444 | { |
5025 | // InternalSolverLanguage.g:1786:3: (otherlv_5= '(' this_Expression_6= ruleExpression otherlv_7= ')' ) | 4445 | // InternalSolverLanguageParser.g:1753:3: (otherlv_4= LeftParenthesis this_Expression_5= ruleExpression otherlv_6= RightParenthesis ) |
5026 | // InternalSolverLanguage.g:1787:4: otherlv_5= '(' this_Expression_6= ruleExpression otherlv_7= ')' | 4446 | // InternalSolverLanguageParser.g:1754:4: otherlv_4= LeftParenthesis this_Expression_5= ruleExpression otherlv_6= RightParenthesis |
5027 | { | 4447 | { |
5028 | otherlv_5=(Token)match(input,33,FOLLOW_6); if (state.failed) return current; | 4448 | otherlv_4=(Token)match(input,LeftParenthesis,FOLLOW_6); |
5029 | if ( state.backtracking==0 ) { | ||
5030 | 4449 | ||
5031 | newLeafNode(otherlv_5, grammarAccess.getAtomicExpressionAccess().getLeftParenthesisKeyword_3_0()); | 4450 | newLeafNode(otherlv_4, grammarAccess.getAtomicExpressionAccess().getLeftParenthesisKeyword_4_0()); |
5032 | 4451 | ||
5033 | } | ||
5034 | if ( state.backtracking==0 ) { | ||
5035 | 4452 | ||
5036 | newCompositeNode(grammarAccess.getAtomicExpressionAccess().getExpressionParserRuleCall_3_1()); | 4453 | newCompositeNode(grammarAccess.getAtomicExpressionAccess().getExpressionParserRuleCall_4_1()); |
5037 | 4454 | ||
5038 | } | 4455 | pushFollow(FOLLOW_29); |
5039 | pushFollow(FOLLOW_30); | 4456 | this_Expression_5=ruleExpression(); |
5040 | this_Expression_6=ruleExpression(); | ||
5041 | 4457 | ||
5042 | state._fsp--; | 4458 | state._fsp--; |
5043 | if (state.failed) return current; | ||
5044 | if ( state.backtracking==0 ) { | ||
5045 | 4459 | ||
5046 | current = this_Expression_6; | ||
5047 | afterParserOrEnumRuleCall(); | ||
5048 | |||
5049 | } | ||
5050 | otherlv_7=(Token)match(input,34,FOLLOW_2); if (state.failed) return current; | ||
5051 | if ( state.backtracking==0 ) { | ||
5052 | 4460 | ||
5053 | newLeafNode(otherlv_7, grammarAccess.getAtomicExpressionAccess().getRightParenthesisKeyword_3_2()); | 4461 | current = this_Expression_5; |
5054 | 4462 | afterParserOrEnumRuleCall(); | |
5055 | } | 4463 | |
4464 | otherlv_6=(Token)match(input,RightParenthesis,FOLLOW_2); | ||
4465 | |||
4466 | newLeafNode(otherlv_6, grammarAccess.getAtomicExpressionAccess().getRightParenthesisKeyword_4_2()); | ||
4467 | |||
5056 | 4468 | ||
5057 | } | 4469 | } |
5058 | 4470 | ||
@@ -5065,11 +4477,9 @@ public class InternalSolverLanguageParser extends AbstractInternalAntlrParser { | |||
5065 | 4477 | ||
5066 | } | 4478 | } |
5067 | 4479 | ||
5068 | if ( state.backtracking==0 ) { | ||
5069 | 4480 | ||
5070 | leaveRule(); | 4481 | leaveRule(); |
5071 | 4482 | ||
5072 | } | ||
5073 | } | 4483 | } |
5074 | 4484 | ||
5075 | catch (RecognitionException re) { | 4485 | catch (RecognitionException re) { |
@@ -5084,7 +4494,7 @@ public class InternalSolverLanguageParser extends AbstractInternalAntlrParser { | |||
5084 | 4494 | ||
5085 | 4495 | ||
5086 | // $ANTLR start "entryRuleCall" | 4496 | // $ANTLR start "entryRuleCall" |
5087 | // InternalSolverLanguage.g:1808:1: entryRuleCall returns [EObject current=null] : iv_ruleCall= ruleCall EOF ; | 4497 | // InternalSolverLanguageParser.g:1775:1: entryRuleCall returns [EObject current=null] : iv_ruleCall= ruleCall EOF ; |
5088 | public final EObject entryRuleCall() throws RecognitionException { | 4498 | public final EObject entryRuleCall() throws RecognitionException { |
5089 | EObject current = null; | 4499 | EObject current = null; |
5090 | 4500 | ||
@@ -5092,21 +4502,17 @@ public class InternalSolverLanguageParser extends AbstractInternalAntlrParser { | |||
5092 | 4502 | ||
5093 | 4503 | ||
5094 | try { | 4504 | try { |
5095 | // InternalSolverLanguage.g:1808:45: (iv_ruleCall= ruleCall EOF ) | 4505 | // InternalSolverLanguageParser.g:1775:45: (iv_ruleCall= ruleCall EOF ) |
5096 | // InternalSolverLanguage.g:1809:2: iv_ruleCall= ruleCall EOF | 4506 | // InternalSolverLanguageParser.g:1776:2: iv_ruleCall= ruleCall EOF |
5097 | { | 4507 | { |
5098 | if ( state.backtracking==0 ) { | 4508 | newCompositeNode(grammarAccess.getCallRule()); |
5099 | newCompositeNode(grammarAccess.getCallRule()); | ||
5100 | } | ||
5101 | pushFollow(FOLLOW_1); | 4509 | pushFollow(FOLLOW_1); |
5102 | iv_ruleCall=ruleCall(); | 4510 | iv_ruleCall=ruleCall(); |
5103 | 4511 | ||
5104 | state._fsp--; | 4512 | state._fsp--; |
5105 | if (state.failed) return current; | 4513 | |
5106 | if ( state.backtracking==0 ) { | 4514 | current =iv_ruleCall; |
5107 | current =iv_ruleCall; | 4515 | match(input,EOF,FOLLOW_2); |
5108 | } | ||
5109 | match(input,EOF,FOLLOW_2); if (state.failed) return current; | ||
5110 | 4516 | ||
5111 | } | 4517 | } |
5112 | 4518 | ||
@@ -5124,7 +4530,7 @@ public class InternalSolverLanguageParser extends AbstractInternalAntlrParser { | |||
5124 | 4530 | ||
5125 | 4531 | ||
5126 | // $ANTLR start "ruleCall" | 4532 | // $ANTLR start "ruleCall" |
5127 | // InternalSolverLanguage.g:1815:1: ruleCall returns [EObject current=null] : ( ( (lv_functor_0_0= ruleReference ) ) ( ( (lv_transitiveClosure_1_0= RULE_STAR ) ) | ( (lv_reflexiveTransitiveClosure_2_0= RULE_PLUS ) ) )? ( (lv_argumentList_3_0= ruleArgumentList ) ) ) ; | 4533 | // InternalSolverLanguageParser.g:1782:1: ruleCall returns [EObject current=null] : ( ( (lv_functor_0_0= ruleReference ) ) ( ( (lv_transitiveClosure_1_0= RULE_TRANSITIVE_CLOSURE ) ) | ( (lv_reflexiveTransitiveClosure_2_0= RULE_REFLEXIVE_TRANSITIVE_CLOSURE ) ) )? ( (lv_argumentList_3_0= ruleArgumentList ) ) ) ; |
5128 | public final EObject ruleCall() throws RecognitionException { | 4534 | public final EObject ruleCall() throws RecognitionException { |
5129 | EObject current = null; | 4535 | EObject current = null; |
5130 | 4536 | ||
@@ -5139,85 +4545,77 @@ public class InternalSolverLanguageParser extends AbstractInternalAntlrParser { | |||
5139 | enterRule(); | 4545 | enterRule(); |
5140 | 4546 | ||
5141 | try { | 4547 | try { |
5142 | // InternalSolverLanguage.g:1821:2: ( ( ( (lv_functor_0_0= ruleReference ) ) ( ( (lv_transitiveClosure_1_0= RULE_STAR ) ) | ( (lv_reflexiveTransitiveClosure_2_0= RULE_PLUS ) ) )? ( (lv_argumentList_3_0= ruleArgumentList ) ) ) ) | 4548 | // InternalSolverLanguageParser.g:1788:2: ( ( ( (lv_functor_0_0= ruleReference ) ) ( ( (lv_transitiveClosure_1_0= RULE_TRANSITIVE_CLOSURE ) ) | ( (lv_reflexiveTransitiveClosure_2_0= RULE_REFLEXIVE_TRANSITIVE_CLOSURE ) ) )? ( (lv_argumentList_3_0= ruleArgumentList ) ) ) ) |
5143 | // InternalSolverLanguage.g:1822:2: ( ( (lv_functor_0_0= ruleReference ) ) ( ( (lv_transitiveClosure_1_0= RULE_STAR ) ) | ( (lv_reflexiveTransitiveClosure_2_0= RULE_PLUS ) ) )? ( (lv_argumentList_3_0= ruleArgumentList ) ) ) | 4549 | // InternalSolverLanguageParser.g:1789:2: ( ( (lv_functor_0_0= ruleReference ) ) ( ( (lv_transitiveClosure_1_0= RULE_TRANSITIVE_CLOSURE ) ) | ( (lv_reflexiveTransitiveClosure_2_0= RULE_REFLEXIVE_TRANSITIVE_CLOSURE ) ) )? ( (lv_argumentList_3_0= ruleArgumentList ) ) ) |
5144 | { | 4550 | { |
5145 | // InternalSolverLanguage.g:1822:2: ( ( (lv_functor_0_0= ruleReference ) ) ( ( (lv_transitiveClosure_1_0= RULE_STAR ) ) | ( (lv_reflexiveTransitiveClosure_2_0= RULE_PLUS ) ) )? ( (lv_argumentList_3_0= ruleArgumentList ) ) ) | 4551 | // InternalSolverLanguageParser.g:1789:2: ( ( (lv_functor_0_0= ruleReference ) ) ( ( (lv_transitiveClosure_1_0= RULE_TRANSITIVE_CLOSURE ) ) | ( (lv_reflexiveTransitiveClosure_2_0= RULE_REFLEXIVE_TRANSITIVE_CLOSURE ) ) )? ( (lv_argumentList_3_0= ruleArgumentList ) ) ) |
5146 | // InternalSolverLanguage.g:1823:3: ( (lv_functor_0_0= ruleReference ) ) ( ( (lv_transitiveClosure_1_0= RULE_STAR ) ) | ( (lv_reflexiveTransitiveClosure_2_0= RULE_PLUS ) ) )? ( (lv_argumentList_3_0= ruleArgumentList ) ) | 4552 | // InternalSolverLanguageParser.g:1790:3: ( (lv_functor_0_0= ruleReference ) ) ( ( (lv_transitiveClosure_1_0= RULE_TRANSITIVE_CLOSURE ) ) | ( (lv_reflexiveTransitiveClosure_2_0= RULE_REFLEXIVE_TRANSITIVE_CLOSURE ) ) )? ( (lv_argumentList_3_0= ruleArgumentList ) ) |
5147 | { | 4553 | { |
5148 | // InternalSolverLanguage.g:1823:3: ( (lv_functor_0_0= ruleReference ) ) | 4554 | // InternalSolverLanguageParser.g:1790:3: ( (lv_functor_0_0= ruleReference ) ) |
5149 | // InternalSolverLanguage.g:1824:4: (lv_functor_0_0= ruleReference ) | 4555 | // InternalSolverLanguageParser.g:1791:4: (lv_functor_0_0= ruleReference ) |
5150 | { | 4556 | { |
5151 | // InternalSolverLanguage.g:1824:4: (lv_functor_0_0= ruleReference ) | 4557 | // InternalSolverLanguageParser.g:1791:4: (lv_functor_0_0= ruleReference ) |
5152 | // InternalSolverLanguage.g:1825:5: lv_functor_0_0= ruleReference | 4558 | // InternalSolverLanguageParser.g:1792:5: lv_functor_0_0= ruleReference |
5153 | { | 4559 | { |
5154 | if ( state.backtracking==0 ) { | ||
5155 | 4560 | ||
5156 | newCompositeNode(grammarAccess.getCallAccess().getFunctorReferenceParserRuleCall_0_0()); | 4561 | newCompositeNode(grammarAccess.getCallAccess().getFunctorReferenceParserRuleCall_0_0()); |
5157 | 4562 | ||
5158 | } | 4563 | pushFollow(FOLLOW_30); |
5159 | pushFollow(FOLLOW_31); | ||
5160 | lv_functor_0_0=ruleReference(); | 4564 | lv_functor_0_0=ruleReference(); |
5161 | 4565 | ||
5162 | state._fsp--; | 4566 | state._fsp--; |
5163 | if (state.failed) return current; | ||
5164 | if ( state.backtracking==0 ) { | ||
5165 | 4567 | ||
5166 | if (current==null) { | 4568 | |
5167 | current = createModelElementForParent(grammarAccess.getCallRule()); | 4569 | if (current==null) { |
5168 | } | 4570 | current = createModelElementForParent(grammarAccess.getCallRule()); |
5169 | set( | 4571 | } |
5170 | current, | 4572 | set( |
5171 | "functor", | 4573 | current, |
5172 | lv_functor_0_0, | 4574 | "functor", |
5173 | "org.eclipse.viatra.solver.language.SolverLanguage.Reference"); | 4575 | lv_functor_0_0, |
5174 | afterParserOrEnumRuleCall(); | 4576 | "org.eclipse.viatra.solver.language.SolverLanguage.Reference"); |
5175 | 4577 | afterParserOrEnumRuleCall(); | |
5176 | } | 4578 | |
5177 | 4579 | ||
5178 | } | 4580 | } |
5179 | 4581 | ||
5180 | 4582 | ||
5181 | } | 4583 | } |
5182 | 4584 | ||
5183 | // InternalSolverLanguage.g:1842:3: ( ( (lv_transitiveClosure_1_0= RULE_STAR ) ) | ( (lv_reflexiveTransitiveClosure_2_0= RULE_PLUS ) ) )? | 4585 | // InternalSolverLanguageParser.g:1809:3: ( ( (lv_transitiveClosure_1_0= RULE_TRANSITIVE_CLOSURE ) ) | ( (lv_reflexiveTransitiveClosure_2_0= RULE_REFLEXIVE_TRANSITIVE_CLOSURE ) ) )? |
5184 | int alt22=3; | 4586 | int alt21=3; |
5185 | int LA22_0 = input.LA(1); | 4587 | int LA21_0 = input.LA(1); |
5186 | 4588 | ||
5187 | if ( (LA22_0==RULE_STAR) ) { | 4589 | if ( (LA21_0==RULE_TRANSITIVE_CLOSURE) ) { |
5188 | alt22=1; | 4590 | alt21=1; |
5189 | } | 4591 | } |
5190 | else if ( (LA22_0==RULE_PLUS) ) { | 4592 | else if ( (LA21_0==RULE_REFLEXIVE_TRANSITIVE_CLOSURE) ) { |
5191 | alt22=2; | 4593 | alt21=2; |
5192 | } | 4594 | } |
5193 | switch (alt22) { | 4595 | switch (alt21) { |
5194 | case 1 : | 4596 | case 1 : |
5195 | // InternalSolverLanguage.g:1843:4: ( (lv_transitiveClosure_1_0= RULE_STAR ) ) | 4597 | // InternalSolverLanguageParser.g:1810:4: ( (lv_transitiveClosure_1_0= RULE_TRANSITIVE_CLOSURE ) ) |
5196 | { | 4598 | { |
5197 | // InternalSolverLanguage.g:1843:4: ( (lv_transitiveClosure_1_0= RULE_STAR ) ) | 4599 | // InternalSolverLanguageParser.g:1810:4: ( (lv_transitiveClosure_1_0= RULE_TRANSITIVE_CLOSURE ) ) |
5198 | // InternalSolverLanguage.g:1844:5: (lv_transitiveClosure_1_0= RULE_STAR ) | 4600 | // InternalSolverLanguageParser.g:1811:5: (lv_transitiveClosure_1_0= RULE_TRANSITIVE_CLOSURE ) |
5199 | { | 4601 | { |
5200 | // InternalSolverLanguage.g:1844:5: (lv_transitiveClosure_1_0= RULE_STAR ) | 4602 | // InternalSolverLanguageParser.g:1811:5: (lv_transitiveClosure_1_0= RULE_TRANSITIVE_CLOSURE ) |
5201 | // InternalSolverLanguage.g:1845:6: lv_transitiveClosure_1_0= RULE_STAR | 4603 | // InternalSolverLanguageParser.g:1812:6: lv_transitiveClosure_1_0= RULE_TRANSITIVE_CLOSURE |
5202 | { | 4604 | { |
5203 | lv_transitiveClosure_1_0=(Token)match(input,RULE_STAR,FOLLOW_10); if (state.failed) return current; | 4605 | lv_transitiveClosure_1_0=(Token)match(input,RULE_TRANSITIVE_CLOSURE,FOLLOW_11); |
5204 | if ( state.backtracking==0 ) { | ||
5205 | 4606 | ||
5206 | newLeafNode(lv_transitiveClosure_1_0, grammarAccess.getCallAccess().getTransitiveClosureSTARTerminalRuleCall_1_0_0()); | 4607 | newLeafNode(lv_transitiveClosure_1_0, grammarAccess.getCallAccess().getTransitiveClosureTRANSITIVE_CLOSURETerminalRuleCall_1_0_0()); |
5207 | 4608 | ||
5208 | } | ||
5209 | if ( state.backtracking==0 ) { | ||
5210 | 4609 | ||
5211 | if (current==null) { | 4610 | if (current==null) { |
5212 | current = createModelElement(grammarAccess.getCallRule()); | 4611 | current = createModelElement(grammarAccess.getCallRule()); |
5213 | } | 4612 | } |
5214 | setWithLastConsumed( | 4613 | setWithLastConsumed( |
5215 | current, | 4614 | current, |
5216 | "transitiveClosure", | 4615 | "transitiveClosure", |
5217 | true, | 4616 | true, |
5218 | "org.eclipse.viatra.solver.language.SolverLanguage.STAR"); | 4617 | "org.eclipse.viatra.solver.language.SolverLanguage.TRANSITIVE_CLOSURE"); |
5219 | 4618 | ||
5220 | } | ||
5221 | 4619 | ||
5222 | } | 4620 | } |
5223 | 4621 | ||
@@ -5228,32 +4626,28 @@ public class InternalSolverLanguageParser extends AbstractInternalAntlrParser { | |||
5228 | } | 4626 | } |
5229 | break; | 4627 | break; |
5230 | case 2 : | 4628 | case 2 : |
5231 | // InternalSolverLanguage.g:1862:4: ( (lv_reflexiveTransitiveClosure_2_0= RULE_PLUS ) ) | 4629 | // InternalSolverLanguageParser.g:1829:4: ( (lv_reflexiveTransitiveClosure_2_0= RULE_REFLEXIVE_TRANSITIVE_CLOSURE ) ) |
5232 | { | 4630 | { |
5233 | // InternalSolverLanguage.g:1862:4: ( (lv_reflexiveTransitiveClosure_2_0= RULE_PLUS ) ) | 4631 | // InternalSolverLanguageParser.g:1829:4: ( (lv_reflexiveTransitiveClosure_2_0= RULE_REFLEXIVE_TRANSITIVE_CLOSURE ) ) |
5234 | // InternalSolverLanguage.g:1863:5: (lv_reflexiveTransitiveClosure_2_0= RULE_PLUS ) | 4632 | // InternalSolverLanguageParser.g:1830:5: (lv_reflexiveTransitiveClosure_2_0= RULE_REFLEXIVE_TRANSITIVE_CLOSURE ) |
5235 | { | 4633 | { |
5236 | // InternalSolverLanguage.g:1863:5: (lv_reflexiveTransitiveClosure_2_0= RULE_PLUS ) | 4634 | // InternalSolverLanguageParser.g:1830:5: (lv_reflexiveTransitiveClosure_2_0= RULE_REFLEXIVE_TRANSITIVE_CLOSURE ) |
5237 | // InternalSolverLanguage.g:1864:6: lv_reflexiveTransitiveClosure_2_0= RULE_PLUS | 4635 | // InternalSolverLanguageParser.g:1831:6: lv_reflexiveTransitiveClosure_2_0= RULE_REFLEXIVE_TRANSITIVE_CLOSURE |
5238 | { | 4636 | { |
5239 | lv_reflexiveTransitiveClosure_2_0=(Token)match(input,RULE_PLUS,FOLLOW_10); if (state.failed) return current; | 4637 | lv_reflexiveTransitiveClosure_2_0=(Token)match(input,RULE_REFLEXIVE_TRANSITIVE_CLOSURE,FOLLOW_11); |
5240 | if ( state.backtracking==0 ) { | ||
5241 | 4638 | ||
5242 | newLeafNode(lv_reflexiveTransitiveClosure_2_0, grammarAccess.getCallAccess().getReflexiveTransitiveClosurePLUSTerminalRuleCall_1_1_0()); | 4639 | newLeafNode(lv_reflexiveTransitiveClosure_2_0, grammarAccess.getCallAccess().getReflexiveTransitiveClosureREFLEXIVE_TRANSITIVE_CLOSURETerminalRuleCall_1_1_0()); |
5243 | 4640 | ||
5244 | } | ||
5245 | if ( state.backtracking==0 ) { | ||
5246 | 4641 | ||
5247 | if (current==null) { | 4642 | if (current==null) { |
5248 | current = createModelElement(grammarAccess.getCallRule()); | 4643 | current = createModelElement(grammarAccess.getCallRule()); |
5249 | } | 4644 | } |
5250 | setWithLastConsumed( | 4645 | setWithLastConsumed( |
5251 | current, | 4646 | current, |
5252 | "reflexiveTransitiveClosure", | 4647 | "reflexiveTransitiveClosure", |
5253 | true, | 4648 | true, |
5254 | "org.eclipse.viatra.solver.language.SolverLanguage.PLUS"); | 4649 | "org.eclipse.viatra.solver.language.SolverLanguage.REFLEXIVE_TRANSITIVE_CLOSURE"); |
5255 | 4650 | ||
5256 | } | ||
5257 | 4651 | ||
5258 | } | 4652 | } |
5259 | 4653 | ||
@@ -5266,35 +4660,31 @@ public class InternalSolverLanguageParser extends AbstractInternalAntlrParser { | |||
5266 | 4660 | ||
5267 | } | 4661 | } |
5268 | 4662 | ||
5269 | // InternalSolverLanguage.g:1881:3: ( (lv_argumentList_3_0= ruleArgumentList ) ) | 4663 | // InternalSolverLanguageParser.g:1848:3: ( (lv_argumentList_3_0= ruleArgumentList ) ) |
5270 | // InternalSolverLanguage.g:1882:4: (lv_argumentList_3_0= ruleArgumentList ) | 4664 | // InternalSolverLanguageParser.g:1849:4: (lv_argumentList_3_0= ruleArgumentList ) |
5271 | { | 4665 | { |
5272 | // InternalSolverLanguage.g:1882:4: (lv_argumentList_3_0= ruleArgumentList ) | 4666 | // InternalSolverLanguageParser.g:1849:4: (lv_argumentList_3_0= ruleArgumentList ) |
5273 | // InternalSolverLanguage.g:1883:5: lv_argumentList_3_0= ruleArgumentList | 4667 | // InternalSolverLanguageParser.g:1850:5: lv_argumentList_3_0= ruleArgumentList |
5274 | { | 4668 | { |
5275 | if ( state.backtracking==0 ) { | ||
5276 | 4669 | ||
5277 | newCompositeNode(grammarAccess.getCallAccess().getArgumentListArgumentListParserRuleCall_2_0()); | 4670 | newCompositeNode(grammarAccess.getCallAccess().getArgumentListArgumentListParserRuleCall_2_0()); |
5278 | 4671 | ||
5279 | } | ||
5280 | pushFollow(FOLLOW_2); | 4672 | pushFollow(FOLLOW_2); |
5281 | lv_argumentList_3_0=ruleArgumentList(); | 4673 | lv_argumentList_3_0=ruleArgumentList(); |
5282 | 4674 | ||
5283 | state._fsp--; | 4675 | state._fsp--; |
5284 | if (state.failed) return current; | ||
5285 | if ( state.backtracking==0 ) { | ||
5286 | 4676 | ||
5287 | if (current==null) { | 4677 | |
5288 | current = createModelElementForParent(grammarAccess.getCallRule()); | 4678 | if (current==null) { |
5289 | } | 4679 | current = createModelElementForParent(grammarAccess.getCallRule()); |
5290 | set( | 4680 | } |
5291 | current, | 4681 | set( |
5292 | "argumentList", | 4682 | current, |
5293 | lv_argumentList_3_0, | 4683 | "argumentList", |
5294 | "org.eclipse.viatra.solver.language.SolverLanguage.ArgumentList"); | 4684 | lv_argumentList_3_0, |
5295 | afterParserOrEnumRuleCall(); | 4685 | "org.eclipse.viatra.solver.language.SolverLanguage.ArgumentList"); |
5296 | 4686 | afterParserOrEnumRuleCall(); | |
5297 | } | 4687 | |
5298 | 4688 | ||
5299 | } | 4689 | } |
5300 | 4690 | ||
@@ -5307,11 +4697,9 @@ public class InternalSolverLanguageParser extends AbstractInternalAntlrParser { | |||
5307 | 4697 | ||
5308 | } | 4698 | } |
5309 | 4699 | ||
5310 | if ( state.backtracking==0 ) { | ||
5311 | 4700 | ||
5312 | leaveRule(); | 4701 | leaveRule(); |
5313 | 4702 | ||
5314 | } | ||
5315 | } | 4703 | } |
5316 | 4704 | ||
5317 | catch (RecognitionException re) { | 4705 | catch (RecognitionException re) { |
@@ -5326,7 +4714,7 @@ public class InternalSolverLanguageParser extends AbstractInternalAntlrParser { | |||
5326 | 4714 | ||
5327 | 4715 | ||
5328 | // $ANTLR start "entryRuleArgumentList" | 4716 | // $ANTLR start "entryRuleArgumentList" |
5329 | // InternalSolverLanguage.g:1904:1: entryRuleArgumentList returns [EObject current=null] : iv_ruleArgumentList= ruleArgumentList EOF ; | 4717 | // InternalSolverLanguageParser.g:1871:1: entryRuleArgumentList returns [EObject current=null] : iv_ruleArgumentList= ruleArgumentList EOF ; |
5330 | public final EObject entryRuleArgumentList() throws RecognitionException { | 4718 | public final EObject entryRuleArgumentList() throws RecognitionException { |
5331 | EObject current = null; | 4719 | EObject current = null; |
5332 | 4720 | ||
@@ -5334,21 +4722,17 @@ public class InternalSolverLanguageParser extends AbstractInternalAntlrParser { | |||
5334 | 4722 | ||
5335 | 4723 | ||
5336 | try { | 4724 | try { |
5337 | // InternalSolverLanguage.g:1904:53: (iv_ruleArgumentList= ruleArgumentList EOF ) | 4725 | // InternalSolverLanguageParser.g:1871:53: (iv_ruleArgumentList= ruleArgumentList EOF ) |
5338 | // InternalSolverLanguage.g:1905:2: iv_ruleArgumentList= ruleArgumentList EOF | 4726 | // InternalSolverLanguageParser.g:1872:2: iv_ruleArgumentList= ruleArgumentList EOF |
5339 | { | 4727 | { |
5340 | if ( state.backtracking==0 ) { | 4728 | newCompositeNode(grammarAccess.getArgumentListRule()); |
5341 | newCompositeNode(grammarAccess.getArgumentListRule()); | ||
5342 | } | ||
5343 | pushFollow(FOLLOW_1); | 4729 | pushFollow(FOLLOW_1); |
5344 | iv_ruleArgumentList=ruleArgumentList(); | 4730 | iv_ruleArgumentList=ruleArgumentList(); |
5345 | 4731 | ||
5346 | state._fsp--; | 4732 | state._fsp--; |
5347 | if (state.failed) return current; | 4733 | |
5348 | if ( state.backtracking==0 ) { | 4734 | current =iv_ruleArgumentList; |
5349 | current =iv_ruleArgumentList; | 4735 | match(input,EOF,FOLLOW_2); |
5350 | } | ||
5351 | match(input,EOF,FOLLOW_2); if (state.failed) return current; | ||
5352 | 4736 | ||
5353 | } | 4737 | } |
5354 | 4738 | ||
@@ -5366,7 +4750,7 @@ public class InternalSolverLanguageParser extends AbstractInternalAntlrParser { | |||
5366 | 4750 | ||
5367 | 4751 | ||
5368 | // $ANTLR start "ruleArgumentList" | 4752 | // $ANTLR start "ruleArgumentList" |
5369 | // InternalSolverLanguage.g:1911:1: ruleArgumentList returns [EObject current=null] : ( () otherlv_1= '(' ( ( (lv_arguments_2_0= ruleArgument ) ) (otherlv_3= ',' ( (lv_arguments_4_0= ruleArgument ) ) )* )? otherlv_5= ')' ) ; | 4753 | // InternalSolverLanguageParser.g:1878:1: ruleArgumentList returns [EObject current=null] : ( () otherlv_1= LeftParenthesis ( ( (lv_arguments_2_0= ruleArgument ) ) (otherlv_3= Comma ( (lv_arguments_4_0= ruleArgument ) ) )* )? otherlv_5= RightParenthesis ) ; |
5370 | public final EObject ruleArgumentList() throws RecognitionException { | 4754 | public final EObject ruleArgumentList() throws RecognitionException { |
5371 | EObject current = null; | 4755 | EObject current = null; |
5372 | 4756 | ||
@@ -5382,127 +4766,113 @@ public class InternalSolverLanguageParser extends AbstractInternalAntlrParser { | |||
5382 | enterRule(); | 4766 | enterRule(); |
5383 | 4767 | ||
5384 | try { | 4768 | try { |
5385 | // InternalSolverLanguage.g:1917:2: ( ( () otherlv_1= '(' ( ( (lv_arguments_2_0= ruleArgument ) ) (otherlv_3= ',' ( (lv_arguments_4_0= ruleArgument ) ) )* )? otherlv_5= ')' ) ) | 4769 | // InternalSolverLanguageParser.g:1884:2: ( ( () otherlv_1= LeftParenthesis ( ( (lv_arguments_2_0= ruleArgument ) ) (otherlv_3= Comma ( (lv_arguments_4_0= ruleArgument ) ) )* )? otherlv_5= RightParenthesis ) ) |
5386 | // InternalSolverLanguage.g:1918:2: ( () otherlv_1= '(' ( ( (lv_arguments_2_0= ruleArgument ) ) (otherlv_3= ',' ( (lv_arguments_4_0= ruleArgument ) ) )* )? otherlv_5= ')' ) | 4770 | // InternalSolverLanguageParser.g:1885:2: ( () otherlv_1= LeftParenthesis ( ( (lv_arguments_2_0= ruleArgument ) ) (otherlv_3= Comma ( (lv_arguments_4_0= ruleArgument ) ) )* )? otherlv_5= RightParenthesis ) |
5387 | { | 4771 | { |
5388 | // InternalSolverLanguage.g:1918:2: ( () otherlv_1= '(' ( ( (lv_arguments_2_0= ruleArgument ) ) (otherlv_3= ',' ( (lv_arguments_4_0= ruleArgument ) ) )* )? otherlv_5= ')' ) | 4772 | // InternalSolverLanguageParser.g:1885:2: ( () otherlv_1= LeftParenthesis ( ( (lv_arguments_2_0= ruleArgument ) ) (otherlv_3= Comma ( (lv_arguments_4_0= ruleArgument ) ) )* )? otherlv_5= RightParenthesis ) |
5389 | // InternalSolverLanguage.g:1919:3: () otherlv_1= '(' ( ( (lv_arguments_2_0= ruleArgument ) ) (otherlv_3= ',' ( (lv_arguments_4_0= ruleArgument ) ) )* )? otherlv_5= ')' | 4773 | // InternalSolverLanguageParser.g:1886:3: () otherlv_1= LeftParenthesis ( ( (lv_arguments_2_0= ruleArgument ) ) (otherlv_3= Comma ( (lv_arguments_4_0= ruleArgument ) ) )* )? otherlv_5= RightParenthesis |
5390 | { | 4774 | { |
5391 | // InternalSolverLanguage.g:1919:3: () | 4775 | // InternalSolverLanguageParser.g:1886:3: () |
5392 | // InternalSolverLanguage.g:1920:4: | 4776 | // InternalSolverLanguageParser.g:1887:4: |
5393 | { | 4777 | { |
5394 | if ( state.backtracking==0 ) { | ||
5395 | 4778 | ||
5396 | current = forceCreateModelElement( | 4779 | current = forceCreateModelElement( |
5397 | grammarAccess.getArgumentListAccess().getArgumentListAction_0(), | 4780 | grammarAccess.getArgumentListAccess().getArgumentListAction_0(), |
5398 | current); | 4781 | current); |
5399 | 4782 | ||
5400 | } | ||
5401 | 4783 | ||
5402 | } | 4784 | } |
5403 | 4785 | ||
5404 | otherlv_1=(Token)match(input,33,FOLLOW_32); if (state.failed) return current; | 4786 | otherlv_1=(Token)match(input,LeftParenthesis,FOLLOW_31); |
5405 | if ( state.backtracking==0 ) { | ||
5406 | 4787 | ||
5407 | newLeafNode(otherlv_1, grammarAccess.getArgumentListAccess().getLeftParenthesisKeyword_1()); | 4788 | newLeafNode(otherlv_1, grammarAccess.getArgumentListAccess().getLeftParenthesisKeyword_1()); |
5408 | 4789 | ||
5409 | } | 4790 | // InternalSolverLanguageParser.g:1897:3: ( ( (lv_arguments_2_0= ruleArgument ) ) (otherlv_3= Comma ( (lv_arguments_4_0= ruleArgument ) ) )* )? |
5410 | // InternalSolverLanguage.g:1930:3: ( ( (lv_arguments_2_0= ruleArgument ) ) (otherlv_3= ',' ( (lv_arguments_4_0= ruleArgument ) ) )* )? | 4791 | int alt23=2; |
5411 | int alt24=2; | 4792 | int LA23_0 = input.LA(1); |
5412 | int LA24_0 = input.LA(1); | ||
5413 | 4793 | ||
5414 | if ( ((LA24_0>=RULE_STRING && LA24_0<=RULE_QUOTED_ID)||LA24_0==19||LA24_0==29||LA24_0==33||(LA24_0>=35 && LA24_0<=36)||(LA24_0>=39 && LA24_0<=40)||(LA24_0>=56 && LA24_0<=57)||(LA24_0>=60 && LA24_0<=72)) ) { | 4794 | if ( (LA23_0==Current||LA23_0==Unknown||(LA23_0>=Count && LA23_0<=False)||(LA23_0>=Must && LA23_0<=Prod)||LA23_0==True||(LA23_0>=Avg && LA23_0<=Inf)||(LA23_0>=Max && LA23_0<=Sum)||(LA23_0>=ExclamationMark && LA23_0<=LeftParenthesis)||(LA23_0>=Asterisk && LA23_0<=PlusSign)||LA23_0==HyphenMinus||LA23_0==LeftSquareBracket||(LA23_0>=RULE_STRING && LA23_0<=RULE_QUOTED_ID)||(LA23_0>=RULE_ID && LA23_0<=RULE_INT)) ) { |
5415 | alt24=1; | 4795 | alt23=1; |
5416 | } | 4796 | } |
5417 | switch (alt24) { | 4797 | switch (alt23) { |
5418 | case 1 : | 4798 | case 1 : |
5419 | // InternalSolverLanguage.g:1931:4: ( (lv_arguments_2_0= ruleArgument ) ) (otherlv_3= ',' ( (lv_arguments_4_0= ruleArgument ) ) )* | 4799 | // InternalSolverLanguageParser.g:1898:4: ( (lv_arguments_2_0= ruleArgument ) ) (otherlv_3= Comma ( (lv_arguments_4_0= ruleArgument ) ) )* |
5420 | { | 4800 | { |
5421 | // InternalSolverLanguage.g:1931:4: ( (lv_arguments_2_0= ruleArgument ) ) | 4801 | // InternalSolverLanguageParser.g:1898:4: ( (lv_arguments_2_0= ruleArgument ) ) |
5422 | // InternalSolverLanguage.g:1932:5: (lv_arguments_2_0= ruleArgument ) | 4802 | // InternalSolverLanguageParser.g:1899:5: (lv_arguments_2_0= ruleArgument ) |
5423 | { | 4803 | { |
5424 | // InternalSolverLanguage.g:1932:5: (lv_arguments_2_0= ruleArgument ) | 4804 | // InternalSolverLanguageParser.g:1899:5: (lv_arguments_2_0= ruleArgument ) |
5425 | // InternalSolverLanguage.g:1933:6: lv_arguments_2_0= ruleArgument | 4805 | // InternalSolverLanguageParser.g:1900:6: lv_arguments_2_0= ruleArgument |
5426 | { | 4806 | { |
5427 | if ( state.backtracking==0 ) { | ||
5428 | 4807 | ||
5429 | newCompositeNode(grammarAccess.getArgumentListAccess().getArgumentsArgumentParserRuleCall_2_0_0()); | 4808 | newCompositeNode(grammarAccess.getArgumentListAccess().getArgumentsArgumentParserRuleCall_2_0_0()); |
5430 | 4809 | ||
5431 | } | 4810 | pushFollow(FOLLOW_32); |
5432 | pushFollow(FOLLOW_33); | ||
5433 | lv_arguments_2_0=ruleArgument(); | 4811 | lv_arguments_2_0=ruleArgument(); |
5434 | 4812 | ||
5435 | state._fsp--; | 4813 | state._fsp--; |
5436 | if (state.failed) return current; | ||
5437 | if ( state.backtracking==0 ) { | ||
5438 | 4814 | ||
5439 | if (current==null) { | 4815 | |
5440 | current = createModelElementForParent(grammarAccess.getArgumentListRule()); | 4816 | if (current==null) { |
5441 | } | 4817 | current = createModelElementForParent(grammarAccess.getArgumentListRule()); |
5442 | add( | 4818 | } |
5443 | current, | 4819 | add( |
5444 | "arguments", | 4820 | current, |
5445 | lv_arguments_2_0, | 4821 | "arguments", |
5446 | "org.eclipse.viatra.solver.language.SolverLanguage.Argument"); | 4822 | lv_arguments_2_0, |
5447 | afterParserOrEnumRuleCall(); | 4823 | "org.eclipse.viatra.solver.language.SolverLanguage.Argument"); |
5448 | 4824 | afterParserOrEnumRuleCall(); | |
5449 | } | 4825 | |
5450 | 4826 | ||
5451 | } | 4827 | } |
5452 | 4828 | ||
5453 | 4829 | ||
5454 | } | 4830 | } |
5455 | 4831 | ||
5456 | // InternalSolverLanguage.g:1950:4: (otherlv_3= ',' ( (lv_arguments_4_0= ruleArgument ) ) )* | 4832 | // InternalSolverLanguageParser.g:1917:4: (otherlv_3= Comma ( (lv_arguments_4_0= ruleArgument ) ) )* |
5457 | loop23: | 4833 | loop22: |
5458 | do { | 4834 | do { |
5459 | int alt23=2; | 4835 | int alt22=2; |
5460 | int LA23_0 = input.LA(1); | 4836 | int LA22_0 = input.LA(1); |
5461 | 4837 | ||
5462 | if ( (LA23_0==28) ) { | 4838 | if ( (LA22_0==Comma) ) { |
5463 | alt23=1; | 4839 | alt22=1; |
5464 | } | 4840 | } |
5465 | 4841 | ||
5466 | 4842 | ||
5467 | switch (alt23) { | 4843 | switch (alt22) { |
5468 | case 1 : | 4844 | case 1 : |
5469 | // InternalSolverLanguage.g:1951:5: otherlv_3= ',' ( (lv_arguments_4_0= ruleArgument ) ) | 4845 | // InternalSolverLanguageParser.g:1918:5: otherlv_3= Comma ( (lv_arguments_4_0= ruleArgument ) ) |
5470 | { | 4846 | { |
5471 | otherlv_3=(Token)match(input,28,FOLLOW_34); if (state.failed) return current; | 4847 | otherlv_3=(Token)match(input,Comma,FOLLOW_33); |
5472 | if ( state.backtracking==0 ) { | ||
5473 | 4848 | ||
5474 | newLeafNode(otherlv_3, grammarAccess.getArgumentListAccess().getCommaKeyword_2_1_0()); | 4849 | newLeafNode(otherlv_3, grammarAccess.getArgumentListAccess().getCommaKeyword_2_1_0()); |
5475 | 4850 | ||
5476 | } | 4851 | // InternalSolverLanguageParser.g:1922:5: ( (lv_arguments_4_0= ruleArgument ) ) |
5477 | // InternalSolverLanguage.g:1955:5: ( (lv_arguments_4_0= ruleArgument ) ) | 4852 | // InternalSolverLanguageParser.g:1923:6: (lv_arguments_4_0= ruleArgument ) |
5478 | // InternalSolverLanguage.g:1956:6: (lv_arguments_4_0= ruleArgument ) | ||
5479 | { | 4853 | { |
5480 | // InternalSolverLanguage.g:1956:6: (lv_arguments_4_0= ruleArgument ) | 4854 | // InternalSolverLanguageParser.g:1923:6: (lv_arguments_4_0= ruleArgument ) |
5481 | // InternalSolverLanguage.g:1957:7: lv_arguments_4_0= ruleArgument | 4855 | // InternalSolverLanguageParser.g:1924:7: lv_arguments_4_0= ruleArgument |
5482 | { | 4856 | { |
5483 | if ( state.backtracking==0 ) { | ||
5484 | 4857 | ||
5485 | newCompositeNode(grammarAccess.getArgumentListAccess().getArgumentsArgumentParserRuleCall_2_1_1_0()); | 4858 | newCompositeNode(grammarAccess.getArgumentListAccess().getArgumentsArgumentParserRuleCall_2_1_1_0()); |
5486 | 4859 | ||
5487 | } | 4860 | pushFollow(FOLLOW_32); |
5488 | pushFollow(FOLLOW_33); | ||
5489 | lv_arguments_4_0=ruleArgument(); | 4861 | lv_arguments_4_0=ruleArgument(); |
5490 | 4862 | ||
5491 | state._fsp--; | 4863 | state._fsp--; |
5492 | if (state.failed) return current; | 4864 | |
5493 | if ( state.backtracking==0 ) { | 4865 | |
5494 | 4866 | if (current==null) { | |
5495 | if (current==null) { | 4867 | current = createModelElementForParent(grammarAccess.getArgumentListRule()); |
5496 | current = createModelElementForParent(grammarAccess.getArgumentListRule()); | 4868 | } |
5497 | } | 4869 | add( |
5498 | add( | 4870 | current, |
5499 | current, | 4871 | "arguments", |
5500 | "arguments", | 4872 | lv_arguments_4_0, |
5501 | lv_arguments_4_0, | 4873 | "org.eclipse.viatra.solver.language.SolverLanguage.Argument"); |
5502 | "org.eclipse.viatra.solver.language.SolverLanguage.Argument"); | 4874 | afterParserOrEnumRuleCall(); |
5503 | afterParserOrEnumRuleCall(); | 4875 | |
5504 | |||
5505 | } | ||
5506 | 4876 | ||
5507 | } | 4877 | } |
5508 | 4878 | ||
@@ -5514,7 +4884,7 @@ public class InternalSolverLanguageParser extends AbstractInternalAntlrParser { | |||
5514 | break; | 4884 | break; |
5515 | 4885 | ||
5516 | default : | 4886 | default : |
5517 | break loop23; | 4887 | break loop22; |
5518 | } | 4888 | } |
5519 | } while (true); | 4889 | } while (true); |
5520 | 4890 | ||
@@ -5524,23 +4894,19 @@ public class InternalSolverLanguageParser extends AbstractInternalAntlrParser { | |||
5524 | 4894 | ||
5525 | } | 4895 | } |
5526 | 4896 | ||
5527 | otherlv_5=(Token)match(input,34,FOLLOW_2); if (state.failed) return current; | 4897 | otherlv_5=(Token)match(input,RightParenthesis,FOLLOW_2); |
5528 | if ( state.backtracking==0 ) { | ||
5529 | 4898 | ||
5530 | newLeafNode(otherlv_5, grammarAccess.getArgumentListAccess().getRightParenthesisKeyword_3()); | 4899 | newLeafNode(otherlv_5, grammarAccess.getArgumentListAccess().getRightParenthesisKeyword_3()); |
5531 | 4900 | ||
5532 | } | ||
5533 | 4901 | ||
5534 | } | 4902 | } |
5535 | 4903 | ||
5536 | 4904 | ||
5537 | } | 4905 | } |
5538 | 4906 | ||
5539 | if ( state.backtracking==0 ) { | ||
5540 | 4907 | ||
5541 | leaveRule(); | 4908 | leaveRule(); |
5542 | 4909 | ||
5543 | } | ||
5544 | } | 4910 | } |
5545 | 4911 | ||
5546 | catch (RecognitionException re) { | 4912 | catch (RecognitionException re) { |
@@ -5555,7 +4921,7 @@ public class InternalSolverLanguageParser extends AbstractInternalAntlrParser { | |||
5555 | 4921 | ||
5556 | 4922 | ||
5557 | // $ANTLR start "entryRuleArgument" | 4923 | // $ANTLR start "entryRuleArgument" |
5558 | // InternalSolverLanguage.g:1984:1: entryRuleArgument returns [EObject current=null] : iv_ruleArgument= ruleArgument EOF ; | 4924 | // InternalSolverLanguageParser.g:1951:1: entryRuleArgument returns [EObject current=null] : iv_ruleArgument= ruleArgument EOF ; |
5559 | public final EObject entryRuleArgument() throws RecognitionException { | 4925 | public final EObject entryRuleArgument() throws RecognitionException { |
5560 | EObject current = null; | 4926 | EObject current = null; |
5561 | 4927 | ||
@@ -5563,21 +4929,17 @@ public class InternalSolverLanguageParser extends AbstractInternalAntlrParser { | |||
5563 | 4929 | ||
5564 | 4930 | ||
5565 | try { | 4931 | try { |
5566 | // InternalSolverLanguage.g:1984:49: (iv_ruleArgument= ruleArgument EOF ) | 4932 | // InternalSolverLanguageParser.g:1951:49: (iv_ruleArgument= ruleArgument EOF ) |
5567 | // InternalSolverLanguage.g:1985:2: iv_ruleArgument= ruleArgument EOF | 4933 | // InternalSolverLanguageParser.g:1952:2: iv_ruleArgument= ruleArgument EOF |
5568 | { | 4934 | { |
5569 | if ( state.backtracking==0 ) { | 4935 | newCompositeNode(grammarAccess.getArgumentRule()); |
5570 | newCompositeNode(grammarAccess.getArgumentRule()); | ||
5571 | } | ||
5572 | pushFollow(FOLLOW_1); | 4936 | pushFollow(FOLLOW_1); |
5573 | iv_ruleArgument=ruleArgument(); | 4937 | iv_ruleArgument=ruleArgument(); |
5574 | 4938 | ||
5575 | state._fsp--; | 4939 | state._fsp--; |
5576 | if (state.failed) return current; | 4940 | |
5577 | if ( state.backtracking==0 ) { | 4941 | current =iv_ruleArgument; |
5578 | current =iv_ruleArgument; | 4942 | match(input,EOF,FOLLOW_2); |
5579 | } | ||
5580 | match(input,EOF,FOLLOW_2); if (state.failed) return current; | ||
5581 | 4943 | ||
5582 | } | 4944 | } |
5583 | 4945 | ||
@@ -5595,7 +4957,7 @@ public class InternalSolverLanguageParser extends AbstractInternalAntlrParser { | |||
5595 | 4957 | ||
5596 | 4958 | ||
5597 | // $ANTLR start "ruleArgument" | 4959 | // $ANTLR start "ruleArgument" |
5598 | // InternalSolverLanguage.g:1991:1: ruleArgument returns [EObject current=null] : (this_ExpressionArgument_0= ruleExpressionArgument | this_StarArgument_1= ruleStarArgument | this_TypedArgument_2= ruleTypedArgument | this_TypedStarArgument_3= ruleTypedStarArgument ) ; | 4960 | // InternalSolverLanguageParser.g:1958:1: ruleArgument returns [EObject current=null] : (this_ExpressionArgument_0= ruleExpressionArgument | this_StarArgument_1= ruleStarArgument | this_TypedArgument_2= ruleTypedArgument | this_TypedStarArgument_3= ruleTypedStarArgument ) ; |
5599 | public final EObject ruleArgument() throws RecognitionException { | 4961 | public final EObject ruleArgument() throws RecognitionException { |
5600 | EObject current = null; | 4962 | EObject current = null; |
5601 | 4963 | ||
@@ -5612,98 +4974,82 @@ public class InternalSolverLanguageParser extends AbstractInternalAntlrParser { | |||
5612 | enterRule(); | 4974 | enterRule(); |
5613 | 4975 | ||
5614 | try { | 4976 | try { |
5615 | // InternalSolverLanguage.g:1997:2: ( (this_ExpressionArgument_0= ruleExpressionArgument | this_StarArgument_1= ruleStarArgument | this_TypedArgument_2= ruleTypedArgument | this_TypedStarArgument_3= ruleTypedStarArgument ) ) | 4977 | // InternalSolverLanguageParser.g:1964:2: ( (this_ExpressionArgument_0= ruleExpressionArgument | this_StarArgument_1= ruleStarArgument | this_TypedArgument_2= ruleTypedArgument | this_TypedStarArgument_3= ruleTypedStarArgument ) ) |
5616 | // InternalSolverLanguage.g:1998:2: (this_ExpressionArgument_0= ruleExpressionArgument | this_StarArgument_1= ruleStarArgument | this_TypedArgument_2= ruleTypedArgument | this_TypedStarArgument_3= ruleTypedStarArgument ) | 4978 | // InternalSolverLanguageParser.g:1965:2: (this_ExpressionArgument_0= ruleExpressionArgument | this_StarArgument_1= ruleStarArgument | this_TypedArgument_2= ruleTypedArgument | this_TypedStarArgument_3= ruleTypedStarArgument ) |
5617 | { | 4979 | { |
5618 | // InternalSolverLanguage.g:1998:2: (this_ExpressionArgument_0= ruleExpressionArgument | this_StarArgument_1= ruleStarArgument | this_TypedArgument_2= ruleTypedArgument | this_TypedStarArgument_3= ruleTypedStarArgument ) | 4980 | // InternalSolverLanguageParser.g:1965:2: (this_ExpressionArgument_0= ruleExpressionArgument | this_StarArgument_1= ruleStarArgument | this_TypedArgument_2= ruleTypedArgument | this_TypedStarArgument_3= ruleTypedStarArgument ) |
5619 | int alt25=4; | 4981 | int alt24=4; |
5620 | alt25 = dfa25.predict(input); | 4982 | alt24 = dfa24.predict(input); |
5621 | switch (alt25) { | 4983 | switch (alt24) { |
5622 | case 1 : | 4984 | case 1 : |
5623 | // InternalSolverLanguage.g:1999:3: this_ExpressionArgument_0= ruleExpressionArgument | 4985 | // InternalSolverLanguageParser.g:1966:3: this_ExpressionArgument_0= ruleExpressionArgument |
5624 | { | 4986 | { |
5625 | if ( state.backtracking==0 ) { | ||
5626 | 4987 | ||
5627 | newCompositeNode(grammarAccess.getArgumentAccess().getExpressionArgumentParserRuleCall_0()); | 4988 | newCompositeNode(grammarAccess.getArgumentAccess().getExpressionArgumentParserRuleCall_0()); |
5628 | 4989 | ||
5629 | } | ||
5630 | pushFollow(FOLLOW_2); | 4990 | pushFollow(FOLLOW_2); |
5631 | this_ExpressionArgument_0=ruleExpressionArgument(); | 4991 | this_ExpressionArgument_0=ruleExpressionArgument(); |
5632 | 4992 | ||
5633 | state._fsp--; | 4993 | state._fsp--; |
5634 | if (state.failed) return current; | ||
5635 | if ( state.backtracking==0 ) { | ||
5636 | 4994 | ||
5637 | current = this_ExpressionArgument_0; | 4995 | |
5638 | afterParserOrEnumRuleCall(); | 4996 | current = this_ExpressionArgument_0; |
5639 | 4997 | afterParserOrEnumRuleCall(); | |
5640 | } | 4998 | |
5641 | 4999 | ||
5642 | } | 5000 | } |
5643 | break; | 5001 | break; |
5644 | case 2 : | 5002 | case 2 : |
5645 | // InternalSolverLanguage.g:2008:3: this_StarArgument_1= ruleStarArgument | 5003 | // InternalSolverLanguageParser.g:1975:3: this_StarArgument_1= ruleStarArgument |
5646 | { | 5004 | { |
5647 | if ( state.backtracking==0 ) { | ||
5648 | 5005 | ||
5649 | newCompositeNode(grammarAccess.getArgumentAccess().getStarArgumentParserRuleCall_1()); | 5006 | newCompositeNode(grammarAccess.getArgumentAccess().getStarArgumentParserRuleCall_1()); |
5650 | 5007 | ||
5651 | } | ||
5652 | pushFollow(FOLLOW_2); | 5008 | pushFollow(FOLLOW_2); |
5653 | this_StarArgument_1=ruleStarArgument(); | 5009 | this_StarArgument_1=ruleStarArgument(); |
5654 | 5010 | ||
5655 | state._fsp--; | 5011 | state._fsp--; |
5656 | if (state.failed) return current; | ||
5657 | if ( state.backtracking==0 ) { | ||
5658 | 5012 | ||
5659 | current = this_StarArgument_1; | 5013 | |
5660 | afterParserOrEnumRuleCall(); | 5014 | current = this_StarArgument_1; |
5661 | 5015 | afterParserOrEnumRuleCall(); | |
5662 | } | 5016 | |
5663 | 5017 | ||
5664 | } | 5018 | } |
5665 | break; | 5019 | break; |
5666 | case 3 : | 5020 | case 3 : |
5667 | // InternalSolverLanguage.g:2017:3: this_TypedArgument_2= ruleTypedArgument | 5021 | // InternalSolverLanguageParser.g:1984:3: this_TypedArgument_2= ruleTypedArgument |
5668 | { | 5022 | { |
5669 | if ( state.backtracking==0 ) { | ||
5670 | 5023 | ||
5671 | newCompositeNode(grammarAccess.getArgumentAccess().getTypedArgumentParserRuleCall_2()); | 5024 | newCompositeNode(grammarAccess.getArgumentAccess().getTypedArgumentParserRuleCall_2()); |
5672 | 5025 | ||
5673 | } | ||
5674 | pushFollow(FOLLOW_2); | 5026 | pushFollow(FOLLOW_2); |
5675 | this_TypedArgument_2=ruleTypedArgument(); | 5027 | this_TypedArgument_2=ruleTypedArgument(); |
5676 | 5028 | ||
5677 | state._fsp--; | 5029 | state._fsp--; |
5678 | if (state.failed) return current; | ||
5679 | if ( state.backtracking==0 ) { | ||
5680 | 5030 | ||
5681 | current = this_TypedArgument_2; | 5031 | |
5682 | afterParserOrEnumRuleCall(); | 5032 | current = this_TypedArgument_2; |
5683 | 5033 | afterParserOrEnumRuleCall(); | |
5684 | } | 5034 | |
5685 | 5035 | ||
5686 | } | 5036 | } |
5687 | break; | 5037 | break; |
5688 | case 4 : | 5038 | case 4 : |
5689 | // InternalSolverLanguage.g:2026:3: this_TypedStarArgument_3= ruleTypedStarArgument | 5039 | // InternalSolverLanguageParser.g:1993:3: this_TypedStarArgument_3= ruleTypedStarArgument |
5690 | { | 5040 | { |
5691 | if ( state.backtracking==0 ) { | ||
5692 | 5041 | ||
5693 | newCompositeNode(grammarAccess.getArgumentAccess().getTypedStarArgumentParserRuleCall_3()); | 5042 | newCompositeNode(grammarAccess.getArgumentAccess().getTypedStarArgumentParserRuleCall_3()); |
5694 | 5043 | ||
5695 | } | ||
5696 | pushFollow(FOLLOW_2); | 5044 | pushFollow(FOLLOW_2); |
5697 | this_TypedStarArgument_3=ruleTypedStarArgument(); | 5045 | this_TypedStarArgument_3=ruleTypedStarArgument(); |
5698 | 5046 | ||
5699 | state._fsp--; | 5047 | state._fsp--; |
5700 | if (state.failed) return current; | ||
5701 | if ( state.backtracking==0 ) { | ||
5702 | 5048 | ||
5703 | current = this_TypedStarArgument_3; | 5049 | |
5704 | afterParserOrEnumRuleCall(); | 5050 | current = this_TypedStarArgument_3; |
5705 | 5051 | afterParserOrEnumRuleCall(); | |
5706 | } | 5052 | |
5707 | 5053 | ||
5708 | } | 5054 | } |
5709 | break; | 5055 | break; |
@@ -5713,11 +5059,9 @@ public class InternalSolverLanguageParser extends AbstractInternalAntlrParser { | |||
5713 | 5059 | ||
5714 | } | 5060 | } |
5715 | 5061 | ||
5716 | if ( state.backtracking==0 ) { | ||
5717 | 5062 | ||
5718 | leaveRule(); | 5063 | leaveRule(); |
5719 | 5064 | ||
5720 | } | ||
5721 | } | 5065 | } |
5722 | 5066 | ||
5723 | catch (RecognitionException re) { | 5067 | catch (RecognitionException re) { |
@@ -5732,7 +5076,7 @@ public class InternalSolverLanguageParser extends AbstractInternalAntlrParser { | |||
5732 | 5076 | ||
5733 | 5077 | ||
5734 | // $ANTLR start "entryRuleExpressionArgument" | 5078 | // $ANTLR start "entryRuleExpressionArgument" |
5735 | // InternalSolverLanguage.g:2038:1: entryRuleExpressionArgument returns [EObject current=null] : iv_ruleExpressionArgument= ruleExpressionArgument EOF ; | 5079 | // InternalSolverLanguageParser.g:2005:1: entryRuleExpressionArgument returns [EObject current=null] : iv_ruleExpressionArgument= ruleExpressionArgument EOF ; |
5736 | public final EObject entryRuleExpressionArgument() throws RecognitionException { | 5080 | public final EObject entryRuleExpressionArgument() throws RecognitionException { |
5737 | EObject current = null; | 5081 | EObject current = null; |
5738 | 5082 | ||
@@ -5740,21 +5084,17 @@ public class InternalSolverLanguageParser extends AbstractInternalAntlrParser { | |||
5740 | 5084 | ||
5741 | 5085 | ||
5742 | try { | 5086 | try { |
5743 | // InternalSolverLanguage.g:2038:59: (iv_ruleExpressionArgument= ruleExpressionArgument EOF ) | 5087 | // InternalSolverLanguageParser.g:2005:59: (iv_ruleExpressionArgument= ruleExpressionArgument EOF ) |
5744 | // InternalSolverLanguage.g:2039:2: iv_ruleExpressionArgument= ruleExpressionArgument EOF | 5088 | // InternalSolverLanguageParser.g:2006:2: iv_ruleExpressionArgument= ruleExpressionArgument EOF |
5745 | { | 5089 | { |
5746 | if ( state.backtracking==0 ) { | 5090 | newCompositeNode(grammarAccess.getExpressionArgumentRule()); |
5747 | newCompositeNode(grammarAccess.getExpressionArgumentRule()); | ||
5748 | } | ||
5749 | pushFollow(FOLLOW_1); | 5091 | pushFollow(FOLLOW_1); |
5750 | iv_ruleExpressionArgument=ruleExpressionArgument(); | 5092 | iv_ruleExpressionArgument=ruleExpressionArgument(); |
5751 | 5093 | ||
5752 | state._fsp--; | 5094 | state._fsp--; |
5753 | if (state.failed) return current; | 5095 | |
5754 | if ( state.backtracking==0 ) { | 5096 | current =iv_ruleExpressionArgument; |
5755 | current =iv_ruleExpressionArgument; | 5097 | match(input,EOF,FOLLOW_2); |
5756 | } | ||
5757 | match(input,EOF,FOLLOW_2); if (state.failed) return current; | ||
5758 | 5098 | ||
5759 | } | 5099 | } |
5760 | 5100 | ||
@@ -5772,7 +5112,7 @@ public class InternalSolverLanguageParser extends AbstractInternalAntlrParser { | |||
5772 | 5112 | ||
5773 | 5113 | ||
5774 | // $ANTLR start "ruleExpressionArgument" | 5114 | // $ANTLR start "ruleExpressionArgument" |
5775 | // InternalSolverLanguage.g:2045:1: ruleExpressionArgument returns [EObject current=null] : ( (lv_body_0_0= ruleComparisonExpression ) ) ; | 5115 | // InternalSolverLanguageParser.g:2012:1: ruleExpressionArgument returns [EObject current=null] : ( (lv_body_0_0= ruleComparisonExpression ) ) ; |
5776 | public final EObject ruleExpressionArgument() throws RecognitionException { | 5116 | public final EObject ruleExpressionArgument() throws RecognitionException { |
5777 | EObject current = null; | 5117 | EObject current = null; |
5778 | 5118 | ||
@@ -5783,38 +5123,34 @@ public class InternalSolverLanguageParser extends AbstractInternalAntlrParser { | |||
5783 | enterRule(); | 5123 | enterRule(); |
5784 | 5124 | ||
5785 | try { | 5125 | try { |
5786 | // InternalSolverLanguage.g:2051:2: ( ( (lv_body_0_0= ruleComparisonExpression ) ) ) | 5126 | // InternalSolverLanguageParser.g:2018:2: ( ( (lv_body_0_0= ruleComparisonExpression ) ) ) |
5787 | // InternalSolverLanguage.g:2052:2: ( (lv_body_0_0= ruleComparisonExpression ) ) | 5127 | // InternalSolverLanguageParser.g:2019:2: ( (lv_body_0_0= ruleComparisonExpression ) ) |
5788 | { | 5128 | { |
5789 | // InternalSolverLanguage.g:2052:2: ( (lv_body_0_0= ruleComparisonExpression ) ) | 5129 | // InternalSolverLanguageParser.g:2019:2: ( (lv_body_0_0= ruleComparisonExpression ) ) |
5790 | // InternalSolverLanguage.g:2053:3: (lv_body_0_0= ruleComparisonExpression ) | 5130 | // InternalSolverLanguageParser.g:2020:3: (lv_body_0_0= ruleComparisonExpression ) |
5791 | { | 5131 | { |
5792 | // InternalSolverLanguage.g:2053:3: (lv_body_0_0= ruleComparisonExpression ) | 5132 | // InternalSolverLanguageParser.g:2020:3: (lv_body_0_0= ruleComparisonExpression ) |
5793 | // InternalSolverLanguage.g:2054:4: lv_body_0_0= ruleComparisonExpression | 5133 | // InternalSolverLanguageParser.g:2021:4: lv_body_0_0= ruleComparisonExpression |
5794 | { | 5134 | { |
5795 | if ( state.backtracking==0 ) { | ||
5796 | 5135 | ||
5797 | newCompositeNode(grammarAccess.getExpressionArgumentAccess().getBodyComparisonExpressionParserRuleCall_0()); | 5136 | newCompositeNode(grammarAccess.getExpressionArgumentAccess().getBodyComparisonExpressionParserRuleCall_0()); |
5798 | 5137 | ||
5799 | } | ||
5800 | pushFollow(FOLLOW_2); | 5138 | pushFollow(FOLLOW_2); |
5801 | lv_body_0_0=ruleComparisonExpression(); | 5139 | lv_body_0_0=ruleComparisonExpression(); |
5802 | 5140 | ||
5803 | state._fsp--; | 5141 | state._fsp--; |
5804 | if (state.failed) return current; | ||
5805 | if ( state.backtracking==0 ) { | ||
5806 | 5142 | ||
5807 | if (current==null) { | 5143 | |
5808 | current = createModelElementForParent(grammarAccess.getExpressionArgumentRule()); | 5144 | if (current==null) { |
5809 | } | 5145 | current = createModelElementForParent(grammarAccess.getExpressionArgumentRule()); |
5810 | set( | 5146 | } |
5811 | current, | 5147 | set( |
5812 | "body", | 5148 | current, |
5813 | lv_body_0_0, | 5149 | "body", |
5814 | "org.eclipse.viatra.solver.language.SolverLanguage.ComparisonExpression"); | 5150 | lv_body_0_0, |
5815 | afterParserOrEnumRuleCall(); | 5151 | "org.eclipse.viatra.solver.language.SolverLanguage.ComparisonExpression"); |
5816 | 5152 | afterParserOrEnumRuleCall(); | |
5817 | } | 5153 | |
5818 | 5154 | ||
5819 | } | 5155 | } |
5820 | 5156 | ||
@@ -5824,11 +5160,9 @@ public class InternalSolverLanguageParser extends AbstractInternalAntlrParser { | |||
5824 | 5160 | ||
5825 | } | 5161 | } |
5826 | 5162 | ||
5827 | if ( state.backtracking==0 ) { | ||
5828 | 5163 | ||
5829 | leaveRule(); | 5164 | leaveRule(); |
5830 | 5165 | ||
5831 | } | ||
5832 | } | 5166 | } |
5833 | 5167 | ||
5834 | catch (RecognitionException re) { | 5168 | catch (RecognitionException re) { |
@@ -5843,7 +5177,7 @@ public class InternalSolverLanguageParser extends AbstractInternalAntlrParser { | |||
5843 | 5177 | ||
5844 | 5178 | ||
5845 | // $ANTLR start "entryRuleStarArgument" | 5179 | // $ANTLR start "entryRuleStarArgument" |
5846 | // InternalSolverLanguage.g:2074:1: entryRuleStarArgument returns [EObject current=null] : iv_ruleStarArgument= ruleStarArgument EOF ; | 5180 | // InternalSolverLanguageParser.g:2041:1: entryRuleStarArgument returns [EObject current=null] : iv_ruleStarArgument= ruleStarArgument EOF ; |
5847 | public final EObject entryRuleStarArgument() throws RecognitionException { | 5181 | public final EObject entryRuleStarArgument() throws RecognitionException { |
5848 | EObject current = null; | 5182 | EObject current = null; |
5849 | 5183 | ||
@@ -5851,21 +5185,17 @@ public class InternalSolverLanguageParser extends AbstractInternalAntlrParser { | |||
5851 | 5185 | ||
5852 | 5186 | ||
5853 | try { | 5187 | try { |
5854 | // InternalSolverLanguage.g:2074:53: (iv_ruleStarArgument= ruleStarArgument EOF ) | 5188 | // InternalSolverLanguageParser.g:2041:53: (iv_ruleStarArgument= ruleStarArgument EOF ) |
5855 | // InternalSolverLanguage.g:2075:2: iv_ruleStarArgument= ruleStarArgument EOF | 5189 | // InternalSolverLanguageParser.g:2042:2: iv_ruleStarArgument= ruleStarArgument EOF |
5856 | { | 5190 | { |
5857 | if ( state.backtracking==0 ) { | 5191 | newCompositeNode(grammarAccess.getStarArgumentRule()); |
5858 | newCompositeNode(grammarAccess.getStarArgumentRule()); | ||
5859 | } | ||
5860 | pushFollow(FOLLOW_1); | 5192 | pushFollow(FOLLOW_1); |
5861 | iv_ruleStarArgument=ruleStarArgument(); | 5193 | iv_ruleStarArgument=ruleStarArgument(); |
5862 | 5194 | ||
5863 | state._fsp--; | 5195 | state._fsp--; |
5864 | if (state.failed) return current; | 5196 | |
5865 | if ( state.backtracking==0 ) { | 5197 | current =iv_ruleStarArgument; |
5866 | current =iv_ruleStarArgument; | 5198 | match(input,EOF,FOLLOW_2); |
5867 | } | ||
5868 | match(input,EOF,FOLLOW_2); if (state.failed) return current; | ||
5869 | 5199 | ||
5870 | } | 5200 | } |
5871 | 5201 | ||
@@ -5883,7 +5213,7 @@ public class InternalSolverLanguageParser extends AbstractInternalAntlrParser { | |||
5883 | 5213 | ||
5884 | 5214 | ||
5885 | // $ANTLR start "ruleStarArgument" | 5215 | // $ANTLR start "ruleStarArgument" |
5886 | // InternalSolverLanguage.g:2081:1: ruleStarArgument returns [EObject current=null] : ( () otherlv_1= '*' ) ; | 5216 | // InternalSolverLanguageParser.g:2048:1: ruleStarArgument returns [EObject current=null] : ( () otherlv_1= Asterisk ) ; |
5887 | public final EObject ruleStarArgument() throws RecognitionException { | 5217 | public final EObject ruleStarArgument() throws RecognitionException { |
5888 | EObject current = null; | 5218 | EObject current = null; |
5889 | 5219 | ||
@@ -5893,42 +5223,36 @@ public class InternalSolverLanguageParser extends AbstractInternalAntlrParser { | |||
5893 | enterRule(); | 5223 | enterRule(); |
5894 | 5224 | ||
5895 | try { | 5225 | try { |
5896 | // InternalSolverLanguage.g:2087:2: ( ( () otherlv_1= '*' ) ) | 5226 | // InternalSolverLanguageParser.g:2054:2: ( ( () otherlv_1= Asterisk ) ) |
5897 | // InternalSolverLanguage.g:2088:2: ( () otherlv_1= '*' ) | 5227 | // InternalSolverLanguageParser.g:2055:2: ( () otherlv_1= Asterisk ) |
5898 | { | 5228 | { |
5899 | // InternalSolverLanguage.g:2088:2: ( () otherlv_1= '*' ) | 5229 | // InternalSolverLanguageParser.g:2055:2: ( () otherlv_1= Asterisk ) |
5900 | // InternalSolverLanguage.g:2089:3: () otherlv_1= '*' | 5230 | // InternalSolverLanguageParser.g:2056:3: () otherlv_1= Asterisk |
5901 | { | 5231 | { |
5902 | // InternalSolverLanguage.g:2089:3: () | 5232 | // InternalSolverLanguageParser.g:2056:3: () |
5903 | // InternalSolverLanguage.g:2090:4: | 5233 | // InternalSolverLanguageParser.g:2057:4: |
5904 | { | 5234 | { |
5905 | if ( state.backtracking==0 ) { | ||
5906 | 5235 | ||
5907 | current = forceCreateModelElement( | 5236 | current = forceCreateModelElement( |
5908 | grammarAccess.getStarArgumentAccess().getStarArgumentAction_0(), | 5237 | grammarAccess.getStarArgumentAccess().getStarArgumentAction_0(), |
5909 | current); | 5238 | current); |
5910 | 5239 | ||
5911 | } | ||
5912 | 5240 | ||
5913 | } | 5241 | } |
5914 | 5242 | ||
5915 | otherlv_1=(Token)match(input,35,FOLLOW_2); if (state.failed) return current; | 5243 | otherlv_1=(Token)match(input,Asterisk,FOLLOW_2); |
5916 | if ( state.backtracking==0 ) { | ||
5917 | 5244 | ||
5918 | newLeafNode(otherlv_1, grammarAccess.getStarArgumentAccess().getAsteriskKeyword_1()); | 5245 | newLeafNode(otherlv_1, grammarAccess.getStarArgumentAccess().getAsteriskKeyword_1()); |
5919 | 5246 | ||
5920 | } | ||
5921 | 5247 | ||
5922 | } | 5248 | } |
5923 | 5249 | ||
5924 | 5250 | ||
5925 | } | 5251 | } |
5926 | 5252 | ||
5927 | if ( state.backtracking==0 ) { | ||
5928 | 5253 | ||
5929 | leaveRule(); | 5254 | leaveRule(); |
5930 | 5255 | ||
5931 | } | ||
5932 | } | 5256 | } |
5933 | 5257 | ||
5934 | catch (RecognitionException re) { | 5258 | catch (RecognitionException re) { |
@@ -5943,7 +5267,7 @@ public class InternalSolverLanguageParser extends AbstractInternalAntlrParser { | |||
5943 | 5267 | ||
5944 | 5268 | ||
5945 | // $ANTLR start "entryRuleTypedArgument" | 5269 | // $ANTLR start "entryRuleTypedArgument" |
5946 | // InternalSolverLanguage.g:2104:1: entryRuleTypedArgument returns [EObject current=null] : iv_ruleTypedArgument= ruleTypedArgument EOF ; | 5270 | // InternalSolverLanguageParser.g:2071:1: entryRuleTypedArgument returns [EObject current=null] : iv_ruleTypedArgument= ruleTypedArgument EOF ; |
5947 | public final EObject entryRuleTypedArgument() throws RecognitionException { | 5271 | public final EObject entryRuleTypedArgument() throws RecognitionException { |
5948 | EObject current = null; | 5272 | EObject current = null; |
5949 | 5273 | ||
@@ -5951,21 +5275,17 @@ public class InternalSolverLanguageParser extends AbstractInternalAntlrParser { | |||
5951 | 5275 | ||
5952 | 5276 | ||
5953 | try { | 5277 | try { |
5954 | // InternalSolverLanguage.g:2104:54: (iv_ruleTypedArgument= ruleTypedArgument EOF ) | 5278 | // InternalSolverLanguageParser.g:2071:54: (iv_ruleTypedArgument= ruleTypedArgument EOF ) |
5955 | // InternalSolverLanguage.g:2105:2: iv_ruleTypedArgument= ruleTypedArgument EOF | 5279 | // InternalSolverLanguageParser.g:2072:2: iv_ruleTypedArgument= ruleTypedArgument EOF |
5956 | { | 5280 | { |
5957 | if ( state.backtracking==0 ) { | 5281 | newCompositeNode(grammarAccess.getTypedArgumentRule()); |
5958 | newCompositeNode(grammarAccess.getTypedArgumentRule()); | ||
5959 | } | ||
5960 | pushFollow(FOLLOW_1); | 5282 | pushFollow(FOLLOW_1); |
5961 | iv_ruleTypedArgument=ruleTypedArgument(); | 5283 | iv_ruleTypedArgument=ruleTypedArgument(); |
5962 | 5284 | ||
5963 | state._fsp--; | 5285 | state._fsp--; |
5964 | if (state.failed) return current; | 5286 | |
5965 | if ( state.backtracking==0 ) { | 5287 | current =iv_ruleTypedArgument; |
5966 | current =iv_ruleTypedArgument; | 5288 | match(input,EOF,FOLLOW_2); |
5967 | } | ||
5968 | match(input,EOF,FOLLOW_2); if (state.failed) return current; | ||
5969 | 5289 | ||
5970 | } | 5290 | } |
5971 | 5291 | ||
@@ -5983,7 +5303,7 @@ public class InternalSolverLanguageParser extends AbstractInternalAntlrParser { | |||
5983 | 5303 | ||
5984 | 5304 | ||
5985 | // $ANTLR start "ruleTypedArgument" | 5305 | // $ANTLR start "ruleTypedArgument" |
5986 | // InternalSolverLanguage.g:2111:1: ruleTypedArgument returns [EObject current=null] : ( ( ( ruleQualifiedName ) ) ( ( ruleQualifiedName ) ) ) ; | 5306 | // InternalSolverLanguageParser.g:2078:1: ruleTypedArgument returns [EObject current=null] : ( ( ( ruleQualifiedName ) ) ( ( ruleQualifiedName ) ) ) ; |
5987 | public final EObject ruleTypedArgument() throws RecognitionException { | 5307 | public final EObject ruleTypedArgument() throws RecognitionException { |
5988 | EObject current = null; | 5308 | EObject current = null; |
5989 | 5309 | ||
@@ -5991,74 +5311,62 @@ public class InternalSolverLanguageParser extends AbstractInternalAntlrParser { | |||
5991 | enterRule(); | 5311 | enterRule(); |
5992 | 5312 | ||
5993 | try { | 5313 | try { |
5994 | // InternalSolverLanguage.g:2117:2: ( ( ( ( ruleQualifiedName ) ) ( ( ruleQualifiedName ) ) ) ) | 5314 | // InternalSolverLanguageParser.g:2084:2: ( ( ( ( ruleQualifiedName ) ) ( ( ruleQualifiedName ) ) ) ) |
5995 | // InternalSolverLanguage.g:2118:2: ( ( ( ruleQualifiedName ) ) ( ( ruleQualifiedName ) ) ) | 5315 | // InternalSolverLanguageParser.g:2085:2: ( ( ( ruleQualifiedName ) ) ( ( ruleQualifiedName ) ) ) |
5996 | { | 5316 | { |
5997 | // InternalSolverLanguage.g:2118:2: ( ( ( ruleQualifiedName ) ) ( ( ruleQualifiedName ) ) ) | 5317 | // InternalSolverLanguageParser.g:2085:2: ( ( ( ruleQualifiedName ) ) ( ( ruleQualifiedName ) ) ) |
5998 | // InternalSolverLanguage.g:2119:3: ( ( ruleQualifiedName ) ) ( ( ruleQualifiedName ) ) | 5318 | // InternalSolverLanguageParser.g:2086:3: ( ( ruleQualifiedName ) ) ( ( ruleQualifiedName ) ) |
5999 | { | 5319 | { |
6000 | // InternalSolverLanguage.g:2119:3: ( ( ruleQualifiedName ) ) | 5320 | // InternalSolverLanguageParser.g:2086:3: ( ( ruleQualifiedName ) ) |
6001 | // InternalSolverLanguage.g:2120:4: ( ruleQualifiedName ) | 5321 | // InternalSolverLanguageParser.g:2087:4: ( ruleQualifiedName ) |
6002 | { | 5322 | { |
6003 | // InternalSolverLanguage.g:2120:4: ( ruleQualifiedName ) | 5323 | // InternalSolverLanguageParser.g:2087:4: ( ruleQualifiedName ) |
6004 | // InternalSolverLanguage.g:2121:5: ruleQualifiedName | 5324 | // InternalSolverLanguageParser.g:2088:5: ruleQualifiedName |
6005 | { | 5325 | { |
6006 | if ( state.backtracking==0 ) { | ||
6007 | 5326 | ||
6008 | if (current==null) { | 5327 | if (current==null) { |
6009 | current = createModelElement(grammarAccess.getTypedArgumentRule()); | 5328 | current = createModelElement(grammarAccess.getTypedArgumentRule()); |
6010 | } | 5329 | } |
6011 | 5330 | ||
6012 | } | ||
6013 | if ( state.backtracking==0 ) { | ||
6014 | 5331 | ||
6015 | newCompositeNode(grammarAccess.getTypedArgumentAccess().getTypeNamedElementCrossReference_0_0()); | 5332 | newCompositeNode(grammarAccess.getTypedArgumentAccess().getTypeNamedElementCrossReference_0_0()); |
6016 | 5333 | ||
6017 | } | 5334 | pushFollow(FOLLOW_8); |
6018 | pushFollow(FOLLOW_35); | ||
6019 | ruleQualifiedName(); | 5335 | ruleQualifiedName(); |
6020 | 5336 | ||
6021 | state._fsp--; | 5337 | state._fsp--; |
6022 | if (state.failed) return current; | ||
6023 | if ( state.backtracking==0 ) { | ||
6024 | 5338 | ||
6025 | afterParserOrEnumRuleCall(); | 5339 | |
6026 | 5340 | afterParserOrEnumRuleCall(); | |
6027 | } | 5341 | |
6028 | 5342 | ||
6029 | } | 5343 | } |
6030 | 5344 | ||
6031 | 5345 | ||
6032 | } | 5346 | } |
6033 | 5347 | ||
6034 | // InternalSolverLanguage.g:2135:3: ( ( ruleQualifiedName ) ) | 5348 | // InternalSolverLanguageParser.g:2102:3: ( ( ruleQualifiedName ) ) |
6035 | // InternalSolverLanguage.g:2136:4: ( ruleQualifiedName ) | 5349 | // InternalSolverLanguageParser.g:2103:4: ( ruleQualifiedName ) |
6036 | { | 5350 | { |
6037 | // InternalSolverLanguage.g:2136:4: ( ruleQualifiedName ) | 5351 | // InternalSolverLanguageParser.g:2103:4: ( ruleQualifiedName ) |
6038 | // InternalSolverLanguage.g:2137:5: ruleQualifiedName | 5352 | // InternalSolverLanguageParser.g:2104:5: ruleQualifiedName |
6039 | { | 5353 | { |
6040 | if ( state.backtracking==0 ) { | ||
6041 | 5354 | ||
6042 | if (current==null) { | 5355 | if (current==null) { |
6043 | current = createModelElement(grammarAccess.getTypedArgumentRule()); | 5356 | current = createModelElement(grammarAccess.getTypedArgumentRule()); |
6044 | } | 5357 | } |
6045 | 5358 | ||
6046 | } | ||
6047 | if ( state.backtracking==0 ) { | ||
6048 | 5359 | ||
6049 | newCompositeNode(grammarAccess.getTypedArgumentAccess().getVariableNamedElementCrossReference_1_0()); | 5360 | newCompositeNode(grammarAccess.getTypedArgumentAccess().getVariableNamedElementCrossReference_1_0()); |
6050 | 5361 | ||
6051 | } | ||
6052 | pushFollow(FOLLOW_2); | 5362 | pushFollow(FOLLOW_2); |
6053 | ruleQualifiedName(); | 5363 | ruleQualifiedName(); |
6054 | 5364 | ||
6055 | state._fsp--; | 5365 | state._fsp--; |
6056 | if (state.failed) return current; | ||
6057 | if ( state.backtracking==0 ) { | ||
6058 | 5366 | ||
6059 | afterParserOrEnumRuleCall(); | 5367 | |
6060 | 5368 | afterParserOrEnumRuleCall(); | |
6061 | } | 5369 | |
6062 | 5370 | ||
6063 | } | 5371 | } |
6064 | 5372 | ||
@@ -6071,11 +5379,9 @@ public class InternalSolverLanguageParser extends AbstractInternalAntlrParser { | |||
6071 | 5379 | ||
6072 | } | 5380 | } |
6073 | 5381 | ||
6074 | if ( state.backtracking==0 ) { | ||
6075 | 5382 | ||
6076 | leaveRule(); | 5383 | leaveRule(); |
6077 | 5384 | ||
6078 | } | ||
6079 | } | 5385 | } |
6080 | 5386 | ||
6081 | catch (RecognitionException re) { | 5387 | catch (RecognitionException re) { |
@@ -6090,7 +5396,7 @@ public class InternalSolverLanguageParser extends AbstractInternalAntlrParser { | |||
6090 | 5396 | ||
6091 | 5397 | ||
6092 | // $ANTLR start "entryRuleTypedStarArgument" | 5398 | // $ANTLR start "entryRuleTypedStarArgument" |
6093 | // InternalSolverLanguage.g:2155:1: entryRuleTypedStarArgument returns [EObject current=null] : iv_ruleTypedStarArgument= ruleTypedStarArgument EOF ; | 5399 | // InternalSolverLanguageParser.g:2122:1: entryRuleTypedStarArgument returns [EObject current=null] : iv_ruleTypedStarArgument= ruleTypedStarArgument EOF ; |
6094 | public final EObject entryRuleTypedStarArgument() throws RecognitionException { | 5400 | public final EObject entryRuleTypedStarArgument() throws RecognitionException { |
6095 | EObject current = null; | 5401 | EObject current = null; |
6096 | 5402 | ||
@@ -6098,21 +5404,17 @@ public class InternalSolverLanguageParser extends AbstractInternalAntlrParser { | |||
6098 | 5404 | ||
6099 | 5405 | ||
6100 | try { | 5406 | try { |
6101 | // InternalSolverLanguage.g:2155:58: (iv_ruleTypedStarArgument= ruleTypedStarArgument EOF ) | 5407 | // InternalSolverLanguageParser.g:2122:58: (iv_ruleTypedStarArgument= ruleTypedStarArgument EOF ) |
6102 | // InternalSolverLanguage.g:2156:2: iv_ruleTypedStarArgument= ruleTypedStarArgument EOF | 5408 | // InternalSolverLanguageParser.g:2123:2: iv_ruleTypedStarArgument= ruleTypedStarArgument EOF |
6103 | { | 5409 | { |
6104 | if ( state.backtracking==0 ) { | 5410 | newCompositeNode(grammarAccess.getTypedStarArgumentRule()); |
6105 | newCompositeNode(grammarAccess.getTypedStarArgumentRule()); | ||
6106 | } | ||
6107 | pushFollow(FOLLOW_1); | 5411 | pushFollow(FOLLOW_1); |
6108 | iv_ruleTypedStarArgument=ruleTypedStarArgument(); | 5412 | iv_ruleTypedStarArgument=ruleTypedStarArgument(); |
6109 | 5413 | ||
6110 | state._fsp--; | 5414 | state._fsp--; |
6111 | if (state.failed) return current; | 5415 | |
6112 | if ( state.backtracking==0 ) { | 5416 | current =iv_ruleTypedStarArgument; |
6113 | current =iv_ruleTypedStarArgument; | 5417 | match(input,EOF,FOLLOW_2); |
6114 | } | ||
6115 | match(input,EOF,FOLLOW_2); if (state.failed) return current; | ||
6116 | 5418 | ||
6117 | } | 5419 | } |
6118 | 5420 | ||
@@ -6130,7 +5432,7 @@ public class InternalSolverLanguageParser extends AbstractInternalAntlrParser { | |||
6130 | 5432 | ||
6131 | 5433 | ||
6132 | // $ANTLR start "ruleTypedStarArgument" | 5434 | // $ANTLR start "ruleTypedStarArgument" |
6133 | // InternalSolverLanguage.g:2162:1: ruleTypedStarArgument returns [EObject current=null] : ( ( ( ruleQualifiedName ) ) otherlv_1= '*' ) ; | 5435 | // InternalSolverLanguageParser.g:2129:1: ruleTypedStarArgument returns [EObject current=null] : ( ( ( ruleQualifiedName ) ) otherlv_1= Asterisk ) ; |
6134 | public final EObject ruleTypedStarArgument() throws RecognitionException { | 5436 | public final EObject ruleTypedStarArgument() throws RecognitionException { |
6135 | EObject current = null; | 5437 | EObject current = null; |
6136 | 5438 | ||
@@ -6140,63 +5442,53 @@ public class InternalSolverLanguageParser extends AbstractInternalAntlrParser { | |||
6140 | enterRule(); | 5442 | enterRule(); |
6141 | 5443 | ||
6142 | try { | 5444 | try { |
6143 | // InternalSolverLanguage.g:2168:2: ( ( ( ( ruleQualifiedName ) ) otherlv_1= '*' ) ) | 5445 | // InternalSolverLanguageParser.g:2135:2: ( ( ( ( ruleQualifiedName ) ) otherlv_1= Asterisk ) ) |
6144 | // InternalSolverLanguage.g:2169:2: ( ( ( ruleQualifiedName ) ) otherlv_1= '*' ) | 5446 | // InternalSolverLanguageParser.g:2136:2: ( ( ( ruleQualifiedName ) ) otherlv_1= Asterisk ) |
6145 | { | 5447 | { |
6146 | // InternalSolverLanguage.g:2169:2: ( ( ( ruleQualifiedName ) ) otherlv_1= '*' ) | 5448 | // InternalSolverLanguageParser.g:2136:2: ( ( ( ruleQualifiedName ) ) otherlv_1= Asterisk ) |
6147 | // InternalSolverLanguage.g:2170:3: ( ( ruleQualifiedName ) ) otherlv_1= '*' | 5449 | // InternalSolverLanguageParser.g:2137:3: ( ( ruleQualifiedName ) ) otherlv_1= Asterisk |
6148 | { | 5450 | { |
6149 | // InternalSolverLanguage.g:2170:3: ( ( ruleQualifiedName ) ) | 5451 | // InternalSolverLanguageParser.g:2137:3: ( ( ruleQualifiedName ) ) |
6150 | // InternalSolverLanguage.g:2171:4: ( ruleQualifiedName ) | 5452 | // InternalSolverLanguageParser.g:2138:4: ( ruleQualifiedName ) |
6151 | { | 5453 | { |
6152 | // InternalSolverLanguage.g:2171:4: ( ruleQualifiedName ) | 5454 | // InternalSolverLanguageParser.g:2138:4: ( ruleQualifiedName ) |
6153 | // InternalSolverLanguage.g:2172:5: ruleQualifiedName | 5455 | // InternalSolverLanguageParser.g:2139:5: ruleQualifiedName |
6154 | { | 5456 | { |
6155 | if ( state.backtracking==0 ) { | ||
6156 | 5457 | ||
6157 | if (current==null) { | 5458 | if (current==null) { |
6158 | current = createModelElement(grammarAccess.getTypedStarArgumentRule()); | 5459 | current = createModelElement(grammarAccess.getTypedStarArgumentRule()); |
6159 | } | 5460 | } |
6160 | 5461 | ||
6161 | } | ||
6162 | if ( state.backtracking==0 ) { | ||
6163 | 5462 | ||
6164 | newCompositeNode(grammarAccess.getTypedStarArgumentAccess().getTypeNamedElementCrossReference_0_0()); | 5463 | newCompositeNode(grammarAccess.getTypedStarArgumentAccess().getTypeNamedElementCrossReference_0_0()); |
6165 | 5464 | ||
6166 | } | 5465 | pushFollow(FOLLOW_34); |
6167 | pushFollow(FOLLOW_36); | ||
6168 | ruleQualifiedName(); | 5466 | ruleQualifiedName(); |
6169 | 5467 | ||
6170 | state._fsp--; | 5468 | state._fsp--; |
6171 | if (state.failed) return current; | ||
6172 | if ( state.backtracking==0 ) { | ||
6173 | 5469 | ||
6174 | afterParserOrEnumRuleCall(); | 5470 | |
6175 | 5471 | afterParserOrEnumRuleCall(); | |
6176 | } | 5472 | |
6177 | 5473 | ||
6178 | } | 5474 | } |
6179 | 5475 | ||
6180 | 5476 | ||
6181 | } | 5477 | } |
6182 | 5478 | ||
6183 | otherlv_1=(Token)match(input,35,FOLLOW_2); if (state.failed) return current; | 5479 | otherlv_1=(Token)match(input,Asterisk,FOLLOW_2); |
6184 | if ( state.backtracking==0 ) { | ||
6185 | 5480 | ||
6186 | newLeafNode(otherlv_1, grammarAccess.getTypedStarArgumentAccess().getAsteriskKeyword_1()); | 5481 | newLeafNode(otherlv_1, grammarAccess.getTypedStarArgumentAccess().getAsteriskKeyword_1()); |
6187 | 5482 | ||
6188 | } | ||
6189 | 5483 | ||
6190 | } | 5484 | } |
6191 | 5485 | ||
6192 | 5486 | ||
6193 | } | 5487 | } |
6194 | 5488 | ||
6195 | if ( state.backtracking==0 ) { | ||
6196 | 5489 | ||
6197 | leaveRule(); | 5490 | leaveRule(); |
6198 | 5491 | ||
6199 | } | ||
6200 | } | 5492 | } |
6201 | 5493 | ||
6202 | catch (RecognitionException re) { | 5494 | catch (RecognitionException re) { |
@@ -6211,7 +5503,7 @@ public class InternalSolverLanguageParser extends AbstractInternalAntlrParser { | |||
6211 | 5503 | ||
6212 | 5504 | ||
6213 | // $ANTLR start "entryRuleReference" | 5505 | // $ANTLR start "entryRuleReference" |
6214 | // InternalSolverLanguage.g:2194:1: entryRuleReference returns [EObject current=null] : iv_ruleReference= ruleReference EOF ; | 5506 | // InternalSolverLanguageParser.g:2161:1: entryRuleReference returns [EObject current=null] : iv_ruleReference= ruleReference EOF ; |
6215 | public final EObject entryRuleReference() throws RecognitionException { | 5507 | public final EObject entryRuleReference() throws RecognitionException { |
6216 | EObject current = null; | 5508 | EObject current = null; |
6217 | 5509 | ||
@@ -6219,21 +5511,17 @@ public class InternalSolverLanguageParser extends AbstractInternalAntlrParser { | |||
6219 | 5511 | ||
6220 | 5512 | ||
6221 | try { | 5513 | try { |
6222 | // InternalSolverLanguage.g:2194:50: (iv_ruleReference= ruleReference EOF ) | 5514 | // InternalSolverLanguageParser.g:2161:50: (iv_ruleReference= ruleReference EOF ) |
6223 | // InternalSolverLanguage.g:2195:2: iv_ruleReference= ruleReference EOF | 5515 | // InternalSolverLanguageParser.g:2162:2: iv_ruleReference= ruleReference EOF |
6224 | { | 5516 | { |
6225 | if ( state.backtracking==0 ) { | 5517 | newCompositeNode(grammarAccess.getReferenceRule()); |
6226 | newCompositeNode(grammarAccess.getReferenceRule()); | ||
6227 | } | ||
6228 | pushFollow(FOLLOW_1); | 5518 | pushFollow(FOLLOW_1); |
6229 | iv_ruleReference=ruleReference(); | 5519 | iv_ruleReference=ruleReference(); |
6230 | 5520 | ||
6231 | state._fsp--; | 5521 | state._fsp--; |
6232 | if (state.failed) return current; | 5522 | |
6233 | if ( state.backtracking==0 ) { | 5523 | current =iv_ruleReference; |
6234 | current =iv_ruleReference; | 5524 | match(input,EOF,FOLLOW_2); |
6235 | } | ||
6236 | match(input,EOF,FOLLOW_2); if (state.failed) return current; | ||
6237 | 5525 | ||
6238 | } | 5526 | } |
6239 | 5527 | ||
@@ -6251,7 +5539,7 @@ public class InternalSolverLanguageParser extends AbstractInternalAntlrParser { | |||
6251 | 5539 | ||
6252 | 5540 | ||
6253 | // $ANTLR start "ruleReference" | 5541 | // $ANTLR start "ruleReference" |
6254 | // InternalSolverLanguage.g:2201:1: ruleReference returns [EObject current=null] : ( ( ruleQualifiedName ) ) ; | 5542 | // InternalSolverLanguageParser.g:2168:1: ruleReference returns [EObject current=null] : ( ( ruleQualifiedName ) ) ; |
6255 | public final EObject ruleReference() throws RecognitionException { | 5543 | public final EObject ruleReference() throws RecognitionException { |
6256 | EObject current = null; | 5544 | EObject current = null; |
6257 | 5545 | ||
@@ -6259,37 +5547,31 @@ public class InternalSolverLanguageParser extends AbstractInternalAntlrParser { | |||
6259 | enterRule(); | 5547 | enterRule(); |
6260 | 5548 | ||
6261 | try { | 5549 | try { |
6262 | // InternalSolverLanguage.g:2207:2: ( ( ( ruleQualifiedName ) ) ) | 5550 | // InternalSolverLanguageParser.g:2174:2: ( ( ( ruleQualifiedName ) ) ) |
6263 | // InternalSolverLanguage.g:2208:2: ( ( ruleQualifiedName ) ) | 5551 | // InternalSolverLanguageParser.g:2175:2: ( ( ruleQualifiedName ) ) |
6264 | { | 5552 | { |
6265 | // InternalSolverLanguage.g:2208:2: ( ( ruleQualifiedName ) ) | 5553 | // InternalSolverLanguageParser.g:2175:2: ( ( ruleQualifiedName ) ) |
6266 | // InternalSolverLanguage.g:2209:3: ( ruleQualifiedName ) | 5554 | // InternalSolverLanguageParser.g:2176:3: ( ruleQualifiedName ) |
6267 | { | 5555 | { |
6268 | // InternalSolverLanguage.g:2209:3: ( ruleQualifiedName ) | 5556 | // InternalSolverLanguageParser.g:2176:3: ( ruleQualifiedName ) |
6269 | // InternalSolverLanguage.g:2210:4: ruleQualifiedName | 5557 | // InternalSolverLanguageParser.g:2177:4: ruleQualifiedName |
6270 | { | 5558 | { |
6271 | if ( state.backtracking==0 ) { | ||
6272 | 5559 | ||
6273 | if (current==null) { | 5560 | if (current==null) { |
6274 | current = createModelElement(grammarAccess.getReferenceRule()); | 5561 | current = createModelElement(grammarAccess.getReferenceRule()); |
6275 | } | 5562 | } |
6276 | 5563 | ||
6277 | } | ||
6278 | if ( state.backtracking==0 ) { | ||
6279 | 5564 | ||
6280 | newCompositeNode(grammarAccess.getReferenceAccess().getReferredNamedElementCrossReference_0()); | 5565 | newCompositeNode(grammarAccess.getReferenceAccess().getReferredNamedElementCrossReference_0()); |
6281 | 5566 | ||
6282 | } | ||
6283 | pushFollow(FOLLOW_2); | 5567 | pushFollow(FOLLOW_2); |
6284 | ruleQualifiedName(); | 5568 | ruleQualifiedName(); |
6285 | 5569 | ||
6286 | state._fsp--; | 5570 | state._fsp--; |
6287 | if (state.failed) return current; | ||
6288 | if ( state.backtracking==0 ) { | ||
6289 | 5571 | ||
6290 | afterParserOrEnumRuleCall(); | 5572 | |
6291 | 5573 | afterParserOrEnumRuleCall(); | |
6292 | } | 5574 | |
6293 | 5575 | ||
6294 | } | 5576 | } |
6295 | 5577 | ||
@@ -6299,11 +5581,9 @@ public class InternalSolverLanguageParser extends AbstractInternalAntlrParser { | |||
6299 | 5581 | ||
6300 | } | 5582 | } |
6301 | 5583 | ||
6302 | if ( state.backtracking==0 ) { | ||
6303 | 5584 | ||
6304 | leaveRule(); | 5585 | leaveRule(); |
6305 | 5586 | ||
6306 | } | ||
6307 | } | 5587 | } |
6308 | 5588 | ||
6309 | catch (RecognitionException re) { | 5589 | catch (RecognitionException re) { |
@@ -6318,7 +5598,7 @@ public class InternalSolverLanguageParser extends AbstractInternalAntlrParser { | |||
6318 | 5598 | ||
6319 | 5599 | ||
6320 | // $ANTLR start "entryRuleInterval" | 5600 | // $ANTLR start "entryRuleInterval" |
6321 | // InternalSolverLanguage.g:2227:1: entryRuleInterval returns [EObject current=null] : iv_ruleInterval= ruleInterval EOF ; | 5601 | // InternalSolverLanguageParser.g:2194:1: entryRuleInterval returns [EObject current=null] : iv_ruleInterval= ruleInterval EOF ; |
6322 | public final EObject entryRuleInterval() throws RecognitionException { | 5602 | public final EObject entryRuleInterval() throws RecognitionException { |
6323 | EObject current = null; | 5603 | EObject current = null; |
6324 | 5604 | ||
@@ -6326,21 +5606,17 @@ public class InternalSolverLanguageParser extends AbstractInternalAntlrParser { | |||
6326 | 5606 | ||
6327 | 5607 | ||
6328 | try { | 5608 | try { |
6329 | // InternalSolverLanguage.g:2227:49: (iv_ruleInterval= ruleInterval EOF ) | 5609 | // InternalSolverLanguageParser.g:2194:49: (iv_ruleInterval= ruleInterval EOF ) |
6330 | // InternalSolverLanguage.g:2228:2: iv_ruleInterval= ruleInterval EOF | 5610 | // InternalSolverLanguageParser.g:2195:2: iv_ruleInterval= ruleInterval EOF |
6331 | { | 5611 | { |
6332 | if ( state.backtracking==0 ) { | 5612 | newCompositeNode(grammarAccess.getIntervalRule()); |
6333 | newCompositeNode(grammarAccess.getIntervalRule()); | ||
6334 | } | ||
6335 | pushFollow(FOLLOW_1); | 5613 | pushFollow(FOLLOW_1); |
6336 | iv_ruleInterval=ruleInterval(); | 5614 | iv_ruleInterval=ruleInterval(); |
6337 | 5615 | ||
6338 | state._fsp--; | 5616 | state._fsp--; |
6339 | if (state.failed) return current; | 5617 | |
6340 | if ( state.backtracking==0 ) { | 5618 | current =iv_ruleInterval; |
6341 | current =iv_ruleInterval; | 5619 | match(input,EOF,FOLLOW_2); |
6342 | } | ||
6343 | match(input,EOF,FOLLOW_2); if (state.failed) return current; | ||
6344 | 5620 | ||
6345 | } | 5621 | } |
6346 | 5622 | ||
@@ -6358,7 +5634,7 @@ public class InternalSolverLanguageParser extends AbstractInternalAntlrParser { | |||
6358 | 5634 | ||
6359 | 5635 | ||
6360 | // $ANTLR start "ruleInterval" | 5636 | // $ANTLR start "ruleInterval" |
6361 | // InternalSolverLanguage.g:2234:1: ruleInterval returns [EObject current=null] : (otherlv_0= '[' ( (lv_lowerBound_1_0= ruleExpression ) ) otherlv_2= '..' ( (lv_upperBound_3_0= ruleExpression ) ) otherlv_4= ']' ) ; | 5637 | // InternalSolverLanguageParser.g:2201:1: ruleInterval returns [EObject current=null] : (otherlv_0= LeftSquareBracket ( (lv_lowerBound_1_0= ruleExpression ) ) otherlv_2= FullStopFullStop ( (lv_upperBound_3_0= ruleExpression ) ) otherlv_4= RightSquareBracket ) ; |
6362 | public final EObject ruleInterval() throws RecognitionException { | 5638 | public final EObject ruleInterval() throws RecognitionException { |
6363 | EObject current = null; | 5639 | EObject current = null; |
6364 | 5640 | ||
@@ -6374,111 +5650,95 @@ public class InternalSolverLanguageParser extends AbstractInternalAntlrParser { | |||
6374 | enterRule(); | 5650 | enterRule(); |
6375 | 5651 | ||
6376 | try { | 5652 | try { |
6377 | // InternalSolverLanguage.g:2240:2: ( (otherlv_0= '[' ( (lv_lowerBound_1_0= ruleExpression ) ) otherlv_2= '..' ( (lv_upperBound_3_0= ruleExpression ) ) otherlv_4= ']' ) ) | 5653 | // InternalSolverLanguageParser.g:2207:2: ( (otherlv_0= LeftSquareBracket ( (lv_lowerBound_1_0= ruleExpression ) ) otherlv_2= FullStopFullStop ( (lv_upperBound_3_0= ruleExpression ) ) otherlv_4= RightSquareBracket ) ) |
6378 | // InternalSolverLanguage.g:2241:2: (otherlv_0= '[' ( (lv_lowerBound_1_0= ruleExpression ) ) otherlv_2= '..' ( (lv_upperBound_3_0= ruleExpression ) ) otherlv_4= ']' ) | 5654 | // InternalSolverLanguageParser.g:2208:2: (otherlv_0= LeftSquareBracket ( (lv_lowerBound_1_0= ruleExpression ) ) otherlv_2= FullStopFullStop ( (lv_upperBound_3_0= ruleExpression ) ) otherlv_4= RightSquareBracket ) |
6379 | { | 5655 | { |
6380 | // InternalSolverLanguage.g:2241:2: (otherlv_0= '[' ( (lv_lowerBound_1_0= ruleExpression ) ) otherlv_2= '..' ( (lv_upperBound_3_0= ruleExpression ) ) otherlv_4= ']' ) | 5656 | // InternalSolverLanguageParser.g:2208:2: (otherlv_0= LeftSquareBracket ( (lv_lowerBound_1_0= ruleExpression ) ) otherlv_2= FullStopFullStop ( (lv_upperBound_3_0= ruleExpression ) ) otherlv_4= RightSquareBracket ) |
6381 | // InternalSolverLanguage.g:2242:3: otherlv_0= '[' ( (lv_lowerBound_1_0= ruleExpression ) ) otherlv_2= '..' ( (lv_upperBound_3_0= ruleExpression ) ) otherlv_4= ']' | 5657 | // InternalSolverLanguageParser.g:2209:3: otherlv_0= LeftSquareBracket ( (lv_lowerBound_1_0= ruleExpression ) ) otherlv_2= FullStopFullStop ( (lv_upperBound_3_0= ruleExpression ) ) otherlv_4= RightSquareBracket |
6382 | { | 5658 | { |
6383 | otherlv_0=(Token)match(input,36,FOLLOW_6); if (state.failed) return current; | 5659 | otherlv_0=(Token)match(input,LeftSquareBracket,FOLLOW_6); |
6384 | if ( state.backtracking==0 ) { | ||
6385 | 5660 | ||
6386 | newLeafNode(otherlv_0, grammarAccess.getIntervalAccess().getLeftSquareBracketKeyword_0()); | 5661 | newLeafNode(otherlv_0, grammarAccess.getIntervalAccess().getLeftSquareBracketKeyword_0()); |
6387 | 5662 | ||
6388 | } | 5663 | // InternalSolverLanguageParser.g:2213:3: ( (lv_lowerBound_1_0= ruleExpression ) ) |
6389 | // InternalSolverLanguage.g:2246:3: ( (lv_lowerBound_1_0= ruleExpression ) ) | 5664 | // InternalSolverLanguageParser.g:2214:4: (lv_lowerBound_1_0= ruleExpression ) |
6390 | // InternalSolverLanguage.g:2247:4: (lv_lowerBound_1_0= ruleExpression ) | ||
6391 | { | 5665 | { |
6392 | // InternalSolverLanguage.g:2247:4: (lv_lowerBound_1_0= ruleExpression ) | 5666 | // InternalSolverLanguageParser.g:2214:4: (lv_lowerBound_1_0= ruleExpression ) |
6393 | // InternalSolverLanguage.g:2248:5: lv_lowerBound_1_0= ruleExpression | 5667 | // InternalSolverLanguageParser.g:2215:5: lv_lowerBound_1_0= ruleExpression |
6394 | { | 5668 | { |
6395 | if ( state.backtracking==0 ) { | ||
6396 | 5669 | ||
6397 | newCompositeNode(grammarAccess.getIntervalAccess().getLowerBoundExpressionParserRuleCall_1_0()); | 5670 | newCompositeNode(grammarAccess.getIntervalAccess().getLowerBoundExpressionParserRuleCall_1_0()); |
6398 | 5671 | ||
6399 | } | 5672 | pushFollow(FOLLOW_35); |
6400 | pushFollow(FOLLOW_37); | ||
6401 | lv_lowerBound_1_0=ruleExpression(); | 5673 | lv_lowerBound_1_0=ruleExpression(); |
6402 | 5674 | ||
6403 | state._fsp--; | 5675 | state._fsp--; |
6404 | if (state.failed) return current; | ||
6405 | if ( state.backtracking==0 ) { | ||
6406 | 5676 | ||
6407 | if (current==null) { | 5677 | |
6408 | current = createModelElementForParent(grammarAccess.getIntervalRule()); | 5678 | if (current==null) { |
6409 | } | 5679 | current = createModelElementForParent(grammarAccess.getIntervalRule()); |
6410 | set( | 5680 | } |
6411 | current, | 5681 | set( |
6412 | "lowerBound", | 5682 | current, |
6413 | lv_lowerBound_1_0, | 5683 | "lowerBound", |
6414 | "org.eclipse.viatra.solver.language.SolverLanguage.Expression"); | 5684 | lv_lowerBound_1_0, |
6415 | afterParserOrEnumRuleCall(); | 5685 | "org.eclipse.viatra.solver.language.SolverLanguage.Expression"); |
6416 | 5686 | afterParserOrEnumRuleCall(); | |
6417 | } | 5687 | |
6418 | 5688 | ||
6419 | } | 5689 | } |
6420 | 5690 | ||
6421 | 5691 | ||
6422 | } | 5692 | } |
6423 | 5693 | ||
6424 | otherlv_2=(Token)match(input,37,FOLLOW_6); if (state.failed) return current; | 5694 | otherlv_2=(Token)match(input,FullStopFullStop,FOLLOW_6); |
6425 | if ( state.backtracking==0 ) { | ||
6426 | 5695 | ||
6427 | newLeafNode(otherlv_2, grammarAccess.getIntervalAccess().getFullStopFullStopKeyword_2()); | 5696 | newLeafNode(otherlv_2, grammarAccess.getIntervalAccess().getFullStopFullStopKeyword_2()); |
6428 | 5697 | ||
6429 | } | 5698 | // InternalSolverLanguageParser.g:2236:3: ( (lv_upperBound_3_0= ruleExpression ) ) |
6430 | // InternalSolverLanguage.g:2269:3: ( (lv_upperBound_3_0= ruleExpression ) ) | 5699 | // InternalSolverLanguageParser.g:2237:4: (lv_upperBound_3_0= ruleExpression ) |
6431 | // InternalSolverLanguage.g:2270:4: (lv_upperBound_3_0= ruleExpression ) | ||
6432 | { | 5700 | { |
6433 | // InternalSolverLanguage.g:2270:4: (lv_upperBound_3_0= ruleExpression ) | 5701 | // InternalSolverLanguageParser.g:2237:4: (lv_upperBound_3_0= ruleExpression ) |
6434 | // InternalSolverLanguage.g:2271:5: lv_upperBound_3_0= ruleExpression | 5702 | // InternalSolverLanguageParser.g:2238:5: lv_upperBound_3_0= ruleExpression |
6435 | { | 5703 | { |
6436 | if ( state.backtracking==0 ) { | ||
6437 | 5704 | ||
6438 | newCompositeNode(grammarAccess.getIntervalAccess().getUpperBoundExpressionParserRuleCall_3_0()); | 5705 | newCompositeNode(grammarAccess.getIntervalAccess().getUpperBoundExpressionParserRuleCall_3_0()); |
6439 | 5706 | ||
6440 | } | 5707 | pushFollow(FOLLOW_36); |
6441 | pushFollow(FOLLOW_38); | ||
6442 | lv_upperBound_3_0=ruleExpression(); | 5708 | lv_upperBound_3_0=ruleExpression(); |
6443 | 5709 | ||
6444 | state._fsp--; | 5710 | state._fsp--; |
6445 | if (state.failed) return current; | ||
6446 | if ( state.backtracking==0 ) { | ||
6447 | 5711 | ||
6448 | if (current==null) { | 5712 | |
6449 | current = createModelElementForParent(grammarAccess.getIntervalRule()); | 5713 | if (current==null) { |
6450 | } | 5714 | current = createModelElementForParent(grammarAccess.getIntervalRule()); |
6451 | set( | 5715 | } |
6452 | current, | 5716 | set( |
6453 | "upperBound", | 5717 | current, |
6454 | lv_upperBound_3_0, | 5718 | "upperBound", |
6455 | "org.eclipse.viatra.solver.language.SolverLanguage.Expression"); | 5719 | lv_upperBound_3_0, |
6456 | afterParserOrEnumRuleCall(); | 5720 | "org.eclipse.viatra.solver.language.SolverLanguage.Expression"); |
6457 | 5721 | afterParserOrEnumRuleCall(); | |
6458 | } | 5722 | |
6459 | 5723 | ||
6460 | } | 5724 | } |
6461 | 5725 | ||
6462 | 5726 | ||
6463 | } | 5727 | } |
6464 | 5728 | ||
6465 | otherlv_4=(Token)match(input,38,FOLLOW_2); if (state.failed) return current; | 5729 | otherlv_4=(Token)match(input,RightSquareBracket,FOLLOW_2); |
6466 | if ( state.backtracking==0 ) { | ||
6467 | 5730 | ||
6468 | newLeafNode(otherlv_4, grammarAccess.getIntervalAccess().getRightSquareBracketKeyword_4()); | 5731 | newLeafNode(otherlv_4, grammarAccess.getIntervalAccess().getRightSquareBracketKeyword_4()); |
6469 | 5732 | ||
6470 | } | ||
6471 | 5733 | ||
6472 | } | 5734 | } |
6473 | 5735 | ||
6474 | 5736 | ||
6475 | } | 5737 | } |
6476 | 5738 | ||
6477 | if ( state.backtracking==0 ) { | ||
6478 | 5739 | ||
6479 | leaveRule(); | 5740 | leaveRule(); |
6480 | 5741 | ||
6481 | } | ||
6482 | } | 5742 | } |
6483 | 5743 | ||
6484 | catch (RecognitionException re) { | 5744 | catch (RecognitionException re) { |
@@ -6493,7 +5753,7 @@ public class InternalSolverLanguageParser extends AbstractInternalAntlrParser { | |||
6493 | 5753 | ||
6494 | 5754 | ||
6495 | // $ANTLR start "entryRuleLiteral" | 5755 | // $ANTLR start "entryRuleLiteral" |
6496 | // InternalSolverLanguage.g:2296:1: entryRuleLiteral returns [EObject current=null] : iv_ruleLiteral= ruleLiteral EOF ; | 5756 | // InternalSolverLanguageParser.g:2263:1: entryRuleLiteral returns [EObject current=null] : iv_ruleLiteral= ruleLiteral EOF ; |
6497 | public final EObject entryRuleLiteral() throws RecognitionException { | 5757 | public final EObject entryRuleLiteral() throws RecognitionException { |
6498 | EObject current = null; | 5758 | EObject current = null; |
6499 | 5759 | ||
@@ -6501,21 +5761,17 @@ public class InternalSolverLanguageParser extends AbstractInternalAntlrParser { | |||
6501 | 5761 | ||
6502 | 5762 | ||
6503 | try { | 5763 | try { |
6504 | // InternalSolverLanguage.g:2296:48: (iv_ruleLiteral= ruleLiteral EOF ) | 5764 | // InternalSolverLanguageParser.g:2263:48: (iv_ruleLiteral= ruleLiteral EOF ) |
6505 | // InternalSolverLanguage.g:2297:2: iv_ruleLiteral= ruleLiteral EOF | 5765 | // InternalSolverLanguageParser.g:2264:2: iv_ruleLiteral= ruleLiteral EOF |
6506 | { | 5766 | { |
6507 | if ( state.backtracking==0 ) { | 5767 | newCompositeNode(grammarAccess.getLiteralRule()); |
6508 | newCompositeNode(grammarAccess.getLiteralRule()); | ||
6509 | } | ||
6510 | pushFollow(FOLLOW_1); | 5768 | pushFollow(FOLLOW_1); |
6511 | iv_ruleLiteral=ruleLiteral(); | 5769 | iv_ruleLiteral=ruleLiteral(); |
6512 | 5770 | ||
6513 | state._fsp--; | 5771 | state._fsp--; |
6514 | if (state.failed) return current; | 5772 | |
6515 | if ( state.backtracking==0 ) { | 5773 | current =iv_ruleLiteral; |
6516 | current =iv_ruleLiteral; | 5774 | match(input,EOF,FOLLOW_2); |
6517 | } | ||
6518 | match(input,EOF,FOLLOW_2); if (state.failed) return current; | ||
6519 | 5775 | ||
6520 | } | 5776 | } |
6521 | 5777 | ||
@@ -6533,7 +5789,7 @@ public class InternalSolverLanguageParser extends AbstractInternalAntlrParser { | |||
6533 | 5789 | ||
6534 | 5790 | ||
6535 | // $ANTLR start "ruleLiteral" | 5791 | // $ANTLR start "ruleLiteral" |
6536 | // InternalSolverLanguage.g:2303:1: ruleLiteral returns [EObject current=null] : (this_LogicLiteral_0= ruleLogicLiteral | this_NumericLiteral_1= ruleNumericLiteral | this_InfinityLiteral_2= ruleInfinityLiteral | this_EmptyIntervalLiteral_3= ruleEmptyIntervalLiteral | this_StringLiteral_4= ruleStringLiteral ) ; | 5792 | // InternalSolverLanguageParser.g:2270:1: ruleLiteral returns [EObject current=null] : (this_LogicLiteral_0= ruleLogicLiteral | this_NumericLiteral_1= ruleNumericLiteral | this_InfinityLiteral_2= ruleInfinityLiteral | this_EmptyIntervalLiteral_3= ruleEmptyIntervalLiteral | this_StringLiteral_4= ruleStringLiteral ) ; |
6537 | public final EObject ruleLiteral() throws RecognitionException { | 5793 | public final EObject ruleLiteral() throws RecognitionException { |
6538 | EObject current = null; | 5794 | EObject current = null; |
6539 | 5795 | ||
@@ -6552,156 +5808,135 @@ public class InternalSolverLanguageParser extends AbstractInternalAntlrParser { | |||
6552 | enterRule(); | 5808 | enterRule(); |
6553 | 5809 | ||
6554 | try { | 5810 | try { |
6555 | // InternalSolverLanguage.g:2309:2: ( (this_LogicLiteral_0= ruleLogicLiteral | this_NumericLiteral_1= ruleNumericLiteral | this_InfinityLiteral_2= ruleInfinityLiteral | this_EmptyIntervalLiteral_3= ruleEmptyIntervalLiteral | this_StringLiteral_4= ruleStringLiteral ) ) | 5811 | // InternalSolverLanguageParser.g:2276:2: ( (this_LogicLiteral_0= ruleLogicLiteral | this_NumericLiteral_1= ruleNumericLiteral | this_InfinityLiteral_2= ruleInfinityLiteral | this_EmptyIntervalLiteral_3= ruleEmptyIntervalLiteral | this_StringLiteral_4= ruleStringLiteral ) ) |
6556 | // InternalSolverLanguage.g:2310:2: (this_LogicLiteral_0= ruleLogicLiteral | this_NumericLiteral_1= ruleNumericLiteral | this_InfinityLiteral_2= ruleInfinityLiteral | this_EmptyIntervalLiteral_3= ruleEmptyIntervalLiteral | this_StringLiteral_4= ruleStringLiteral ) | 5812 | // InternalSolverLanguageParser.g:2277:2: (this_LogicLiteral_0= ruleLogicLiteral | this_NumericLiteral_1= ruleNumericLiteral | this_InfinityLiteral_2= ruleInfinityLiteral | this_EmptyIntervalLiteral_3= ruleEmptyIntervalLiteral | this_StringLiteral_4= ruleStringLiteral ) |
6557 | { | 5813 | { |
6558 | // InternalSolverLanguage.g:2310:2: (this_LogicLiteral_0= ruleLogicLiteral | this_NumericLiteral_1= ruleNumericLiteral | this_InfinityLiteral_2= ruleInfinityLiteral | this_EmptyIntervalLiteral_3= ruleEmptyIntervalLiteral | this_StringLiteral_4= ruleStringLiteral ) | 5814 | // InternalSolverLanguageParser.g:2277:2: (this_LogicLiteral_0= ruleLogicLiteral | this_NumericLiteral_1= ruleNumericLiteral | this_InfinityLiteral_2= ruleInfinityLiteral | this_EmptyIntervalLiteral_3= ruleEmptyIntervalLiteral | this_StringLiteral_4= ruleStringLiteral ) |
6559 | int alt26=5; | 5815 | int alt25=5; |
6560 | switch ( input.LA(1) ) { | 5816 | switch ( input.LA(1) ) { |
6561 | case 19: | 5817 | case Unknown: |
6562 | case 70: | 5818 | case Error: |
6563 | case 71: | 5819 | case False: |
6564 | case 72: | 5820 | case True: |
6565 | { | 5821 | { |
6566 | alt26=1; | 5822 | alt25=1; |
6567 | } | 5823 | } |
6568 | break; | 5824 | break; |
6569 | case RULE_INT: | 5825 | case RULE_INT: |
6570 | { | 5826 | { |
6571 | alt26=2; | 5827 | alt25=2; |
6572 | } | 5828 | } |
6573 | break; | 5829 | break; |
6574 | case 39: | 5830 | case Inf: |
6575 | { | 5831 | { |
6576 | alt26=3; | 5832 | alt25=3; |
6577 | } | 5833 | } |
6578 | break; | 5834 | break; |
6579 | case 40: | 5835 | case Empty: |
6580 | { | 5836 | { |
6581 | alt26=4; | 5837 | alt25=4; |
6582 | } | 5838 | } |
6583 | break; | 5839 | break; |
6584 | case RULE_STRING: | 5840 | case RULE_STRING: |
6585 | { | 5841 | { |
6586 | alt26=5; | 5842 | alt25=5; |
6587 | } | 5843 | } |
6588 | break; | 5844 | break; |
6589 | default: | 5845 | default: |
6590 | if (state.backtracking>0) {state.failed=true; return current;} | ||
6591 | NoViableAltException nvae = | 5846 | NoViableAltException nvae = |
6592 | new NoViableAltException("", 26, 0, input); | 5847 | new NoViableAltException("", 25, 0, input); |
6593 | 5848 | ||
6594 | throw nvae; | 5849 | throw nvae; |
6595 | } | 5850 | } |
6596 | 5851 | ||
6597 | switch (alt26) { | 5852 | switch (alt25) { |
6598 | case 1 : | 5853 | case 1 : |
6599 | // InternalSolverLanguage.g:2311:3: this_LogicLiteral_0= ruleLogicLiteral | 5854 | // InternalSolverLanguageParser.g:2278:3: this_LogicLiteral_0= ruleLogicLiteral |
6600 | { | 5855 | { |
6601 | if ( state.backtracking==0 ) { | ||
6602 | 5856 | ||
6603 | newCompositeNode(grammarAccess.getLiteralAccess().getLogicLiteralParserRuleCall_0()); | 5857 | newCompositeNode(grammarAccess.getLiteralAccess().getLogicLiteralParserRuleCall_0()); |
6604 | 5858 | ||
6605 | } | ||
6606 | pushFollow(FOLLOW_2); | 5859 | pushFollow(FOLLOW_2); |
6607 | this_LogicLiteral_0=ruleLogicLiteral(); | 5860 | this_LogicLiteral_0=ruleLogicLiteral(); |
6608 | 5861 | ||
6609 | state._fsp--; | 5862 | state._fsp--; |
6610 | if (state.failed) return current; | ||
6611 | if ( state.backtracking==0 ) { | ||
6612 | 5863 | ||
6613 | current = this_LogicLiteral_0; | 5864 | |
6614 | afterParserOrEnumRuleCall(); | 5865 | current = this_LogicLiteral_0; |
6615 | 5866 | afterParserOrEnumRuleCall(); | |
6616 | } | 5867 | |
6617 | 5868 | ||
6618 | } | 5869 | } |
6619 | break; | 5870 | break; |
6620 | case 2 : | 5871 | case 2 : |
6621 | // InternalSolverLanguage.g:2320:3: this_NumericLiteral_1= ruleNumericLiteral | 5872 | // InternalSolverLanguageParser.g:2287:3: this_NumericLiteral_1= ruleNumericLiteral |
6622 | { | 5873 | { |
6623 | if ( state.backtracking==0 ) { | ||
6624 | 5874 | ||
6625 | newCompositeNode(grammarAccess.getLiteralAccess().getNumericLiteralParserRuleCall_1()); | 5875 | newCompositeNode(grammarAccess.getLiteralAccess().getNumericLiteralParserRuleCall_1()); |
6626 | 5876 | ||
6627 | } | ||
6628 | pushFollow(FOLLOW_2); | 5877 | pushFollow(FOLLOW_2); |
6629 | this_NumericLiteral_1=ruleNumericLiteral(); | 5878 | this_NumericLiteral_1=ruleNumericLiteral(); |
6630 | 5879 | ||
6631 | state._fsp--; | 5880 | state._fsp--; |
6632 | if (state.failed) return current; | ||
6633 | if ( state.backtracking==0 ) { | ||
6634 | 5881 | ||
6635 | current = this_NumericLiteral_1; | 5882 | |
6636 | afterParserOrEnumRuleCall(); | 5883 | current = this_NumericLiteral_1; |
6637 | 5884 | afterParserOrEnumRuleCall(); | |
6638 | } | 5885 | |
6639 | 5886 | ||
6640 | } | 5887 | } |
6641 | break; | 5888 | break; |
6642 | case 3 : | 5889 | case 3 : |
6643 | // InternalSolverLanguage.g:2329:3: this_InfinityLiteral_2= ruleInfinityLiteral | 5890 | // InternalSolverLanguageParser.g:2296:3: this_InfinityLiteral_2= ruleInfinityLiteral |
6644 | { | 5891 | { |
6645 | if ( state.backtracking==0 ) { | ||
6646 | 5892 | ||
6647 | newCompositeNode(grammarAccess.getLiteralAccess().getInfinityLiteralParserRuleCall_2()); | 5893 | newCompositeNode(grammarAccess.getLiteralAccess().getInfinityLiteralParserRuleCall_2()); |
6648 | 5894 | ||
6649 | } | ||
6650 | pushFollow(FOLLOW_2); | 5895 | pushFollow(FOLLOW_2); |
6651 | this_InfinityLiteral_2=ruleInfinityLiteral(); | 5896 | this_InfinityLiteral_2=ruleInfinityLiteral(); |
6652 | 5897 | ||
6653 | state._fsp--; | 5898 | state._fsp--; |
6654 | if (state.failed) return current; | ||
6655 | if ( state.backtracking==0 ) { | ||
6656 | 5899 | ||
6657 | current = this_InfinityLiteral_2; | 5900 | |
6658 | afterParserOrEnumRuleCall(); | 5901 | current = this_InfinityLiteral_2; |
6659 | 5902 | afterParserOrEnumRuleCall(); | |
6660 | } | 5903 | |
6661 | 5904 | ||
6662 | } | 5905 | } |
6663 | break; | 5906 | break; |
6664 | case 4 : | 5907 | case 4 : |
6665 | // InternalSolverLanguage.g:2338:3: this_EmptyIntervalLiteral_3= ruleEmptyIntervalLiteral | 5908 | // InternalSolverLanguageParser.g:2305:3: this_EmptyIntervalLiteral_3= ruleEmptyIntervalLiteral |
6666 | { | 5909 | { |
6667 | if ( state.backtracking==0 ) { | ||
6668 | 5910 | ||
6669 | newCompositeNode(grammarAccess.getLiteralAccess().getEmptyIntervalLiteralParserRuleCall_3()); | 5911 | newCompositeNode(grammarAccess.getLiteralAccess().getEmptyIntervalLiteralParserRuleCall_3()); |
6670 | 5912 | ||
6671 | } | ||
6672 | pushFollow(FOLLOW_2); | 5913 | pushFollow(FOLLOW_2); |
6673 | this_EmptyIntervalLiteral_3=ruleEmptyIntervalLiteral(); | 5914 | this_EmptyIntervalLiteral_3=ruleEmptyIntervalLiteral(); |
6674 | 5915 | ||
6675 | state._fsp--; | 5916 | state._fsp--; |
6676 | if (state.failed) return current; | ||
6677 | if ( state.backtracking==0 ) { | ||
6678 | 5917 | ||
6679 | current = this_EmptyIntervalLiteral_3; | 5918 | |
6680 | afterParserOrEnumRuleCall(); | 5919 | current = this_EmptyIntervalLiteral_3; |
6681 | 5920 | afterParserOrEnumRuleCall(); | |
6682 | } | 5921 | |
6683 | 5922 | ||
6684 | } | 5923 | } |
6685 | break; | 5924 | break; |
6686 | case 5 : | 5925 | case 5 : |
6687 | // InternalSolverLanguage.g:2347:3: this_StringLiteral_4= ruleStringLiteral | 5926 | // InternalSolverLanguageParser.g:2314:3: this_StringLiteral_4= ruleStringLiteral |
6688 | { | 5927 | { |
6689 | if ( state.backtracking==0 ) { | ||
6690 | 5928 | ||
6691 | newCompositeNode(grammarAccess.getLiteralAccess().getStringLiteralParserRuleCall_4()); | 5929 | newCompositeNode(grammarAccess.getLiteralAccess().getStringLiteralParserRuleCall_4()); |
6692 | 5930 | ||
6693 | } | ||
6694 | pushFollow(FOLLOW_2); | 5931 | pushFollow(FOLLOW_2); |
6695 | this_StringLiteral_4=ruleStringLiteral(); | 5932 | this_StringLiteral_4=ruleStringLiteral(); |
6696 | 5933 | ||
6697 | state._fsp--; | 5934 | state._fsp--; |
6698 | if (state.failed) return current; | ||
6699 | if ( state.backtracking==0 ) { | ||
6700 | 5935 | ||
6701 | current = this_StringLiteral_4; | 5936 | |
6702 | afterParserOrEnumRuleCall(); | 5937 | current = this_StringLiteral_4; |
6703 | 5938 | afterParserOrEnumRuleCall(); | |
6704 | } | 5939 | |
6705 | 5940 | ||
6706 | } | 5941 | } |
6707 | break; | 5942 | break; |
@@ -6711,11 +5946,9 @@ public class InternalSolverLanguageParser extends AbstractInternalAntlrParser { | |||
6711 | 5946 | ||
6712 | } | 5947 | } |
6713 | 5948 | ||
6714 | if ( state.backtracking==0 ) { | ||
6715 | 5949 | ||
6716 | leaveRule(); | 5950 | leaveRule(); |
6717 | 5951 | ||
6718 | } | ||
6719 | } | 5952 | } |
6720 | 5953 | ||
6721 | catch (RecognitionException re) { | 5954 | catch (RecognitionException re) { |
@@ -6730,7 +5963,7 @@ public class InternalSolverLanguageParser extends AbstractInternalAntlrParser { | |||
6730 | 5963 | ||
6731 | 5964 | ||
6732 | // $ANTLR start "entryRuleLogicLiteral" | 5965 | // $ANTLR start "entryRuleLogicLiteral" |
6733 | // InternalSolverLanguage.g:2359:1: entryRuleLogicLiteral returns [EObject current=null] : iv_ruleLogicLiteral= ruleLogicLiteral EOF ; | 5966 | // InternalSolverLanguageParser.g:2326:1: entryRuleLogicLiteral returns [EObject current=null] : iv_ruleLogicLiteral= ruleLogicLiteral EOF ; |
6734 | public final EObject entryRuleLogicLiteral() throws RecognitionException { | 5967 | public final EObject entryRuleLogicLiteral() throws RecognitionException { |
6735 | EObject current = null; | 5968 | EObject current = null; |
6736 | 5969 | ||
@@ -6738,21 +5971,17 @@ public class InternalSolverLanguageParser extends AbstractInternalAntlrParser { | |||
6738 | 5971 | ||
6739 | 5972 | ||
6740 | try { | 5973 | try { |
6741 | // InternalSolverLanguage.g:2359:53: (iv_ruleLogicLiteral= ruleLogicLiteral EOF ) | 5974 | // InternalSolverLanguageParser.g:2326:53: (iv_ruleLogicLiteral= ruleLogicLiteral EOF ) |
6742 | // InternalSolverLanguage.g:2360:2: iv_ruleLogicLiteral= ruleLogicLiteral EOF | 5975 | // InternalSolverLanguageParser.g:2327:2: iv_ruleLogicLiteral= ruleLogicLiteral EOF |
6743 | { | 5976 | { |
6744 | if ( state.backtracking==0 ) { | 5977 | newCompositeNode(grammarAccess.getLogicLiteralRule()); |
6745 | newCompositeNode(grammarAccess.getLogicLiteralRule()); | ||
6746 | } | ||
6747 | pushFollow(FOLLOW_1); | 5978 | pushFollow(FOLLOW_1); |
6748 | iv_ruleLogicLiteral=ruleLogicLiteral(); | 5979 | iv_ruleLogicLiteral=ruleLogicLiteral(); |
6749 | 5980 | ||
6750 | state._fsp--; | 5981 | state._fsp--; |
6751 | if (state.failed) return current; | 5982 | |
6752 | if ( state.backtracking==0 ) { | 5983 | current =iv_ruleLogicLiteral; |
6753 | current =iv_ruleLogicLiteral; | 5984 | match(input,EOF,FOLLOW_2); |
6754 | } | ||
6755 | match(input,EOF,FOLLOW_2); if (state.failed) return current; | ||
6756 | 5985 | ||
6757 | } | 5986 | } |
6758 | 5987 | ||
@@ -6770,7 +5999,7 @@ public class InternalSolverLanguageParser extends AbstractInternalAntlrParser { | |||
6770 | 5999 | ||
6771 | 6000 | ||
6772 | // $ANTLR start "ruleLogicLiteral" | 6001 | // $ANTLR start "ruleLogicLiteral" |
6773 | // InternalSolverLanguage.g:2366:1: ruleLogicLiteral returns [EObject current=null] : ( (lv_value_0_0= ruleLogicValue ) ) ; | 6002 | // InternalSolverLanguageParser.g:2333:1: ruleLogicLiteral returns [EObject current=null] : ( (lv_value_0_0= ruleLogicValue ) ) ; |
6774 | public final EObject ruleLogicLiteral() throws RecognitionException { | 6003 | public final EObject ruleLogicLiteral() throws RecognitionException { |
6775 | EObject current = null; | 6004 | EObject current = null; |
6776 | 6005 | ||
@@ -6781,38 +6010,34 @@ public class InternalSolverLanguageParser extends AbstractInternalAntlrParser { | |||
6781 | enterRule(); | 6010 | enterRule(); |
6782 | 6011 | ||
6783 | try { | 6012 | try { |
6784 | // InternalSolverLanguage.g:2372:2: ( ( (lv_value_0_0= ruleLogicValue ) ) ) | 6013 | // InternalSolverLanguageParser.g:2339:2: ( ( (lv_value_0_0= ruleLogicValue ) ) ) |
6785 | // InternalSolverLanguage.g:2373:2: ( (lv_value_0_0= ruleLogicValue ) ) | 6014 | // InternalSolverLanguageParser.g:2340:2: ( (lv_value_0_0= ruleLogicValue ) ) |
6786 | { | 6015 | { |
6787 | // InternalSolverLanguage.g:2373:2: ( (lv_value_0_0= ruleLogicValue ) ) | 6016 | // InternalSolverLanguageParser.g:2340:2: ( (lv_value_0_0= ruleLogicValue ) ) |
6788 | // InternalSolverLanguage.g:2374:3: (lv_value_0_0= ruleLogicValue ) | 6017 | // InternalSolverLanguageParser.g:2341:3: (lv_value_0_0= ruleLogicValue ) |
6789 | { | 6018 | { |
6790 | // InternalSolverLanguage.g:2374:3: (lv_value_0_0= ruleLogicValue ) | 6019 | // InternalSolverLanguageParser.g:2341:3: (lv_value_0_0= ruleLogicValue ) |
6791 | // InternalSolverLanguage.g:2375:4: lv_value_0_0= ruleLogicValue | 6020 | // InternalSolverLanguageParser.g:2342:4: lv_value_0_0= ruleLogicValue |
6792 | { | 6021 | { |
6793 | if ( state.backtracking==0 ) { | ||
6794 | 6022 | ||
6795 | newCompositeNode(grammarAccess.getLogicLiteralAccess().getValueLogicValueEnumRuleCall_0()); | 6023 | newCompositeNode(grammarAccess.getLogicLiteralAccess().getValueLogicValueEnumRuleCall_0()); |
6796 | 6024 | ||
6797 | } | ||
6798 | pushFollow(FOLLOW_2); | 6025 | pushFollow(FOLLOW_2); |
6799 | lv_value_0_0=ruleLogicValue(); | 6026 | lv_value_0_0=ruleLogicValue(); |
6800 | 6027 | ||
6801 | state._fsp--; | 6028 | state._fsp--; |
6802 | if (state.failed) return current; | ||
6803 | if ( state.backtracking==0 ) { | ||
6804 | 6029 | ||
6805 | if (current==null) { | 6030 | |
6806 | current = createModelElementForParent(grammarAccess.getLogicLiteralRule()); | 6031 | if (current==null) { |
6807 | } | 6032 | current = createModelElementForParent(grammarAccess.getLogicLiteralRule()); |
6808 | set( | 6033 | } |
6809 | current, | 6034 | set( |
6810 | "value", | 6035 | current, |
6811 | lv_value_0_0, | 6036 | "value", |
6812 | "org.eclipse.viatra.solver.language.SolverLanguage.LogicValue"); | 6037 | lv_value_0_0, |
6813 | afterParserOrEnumRuleCall(); | 6038 | "org.eclipse.viatra.solver.language.SolverLanguage.LogicValue"); |
6814 | 6039 | afterParserOrEnumRuleCall(); | |
6815 | } | 6040 | |
6816 | 6041 | ||
6817 | } | 6042 | } |
6818 | 6043 | ||
@@ -6822,11 +6047,9 @@ public class InternalSolverLanguageParser extends AbstractInternalAntlrParser { | |||
6822 | 6047 | ||
6823 | } | 6048 | } |
6824 | 6049 | ||
6825 | if ( state.backtracking==0 ) { | ||
6826 | 6050 | ||
6827 | leaveRule(); | 6051 | leaveRule(); |
6828 | 6052 | ||
6829 | } | ||
6830 | } | 6053 | } |
6831 | 6054 | ||
6832 | catch (RecognitionException re) { | 6055 | catch (RecognitionException re) { |
@@ -6841,7 +6064,7 @@ public class InternalSolverLanguageParser extends AbstractInternalAntlrParser { | |||
6841 | 6064 | ||
6842 | 6065 | ||
6843 | // $ANTLR start "entryRuleNumericLiteral" | 6066 | // $ANTLR start "entryRuleNumericLiteral" |
6844 | // InternalSolverLanguage.g:2395:1: entryRuleNumericLiteral returns [EObject current=null] : iv_ruleNumericLiteral= ruleNumericLiteral EOF ; | 6067 | // InternalSolverLanguageParser.g:2362:1: entryRuleNumericLiteral returns [EObject current=null] : iv_ruleNumericLiteral= ruleNumericLiteral EOF ; |
6845 | public final EObject entryRuleNumericLiteral() throws RecognitionException { | 6068 | public final EObject entryRuleNumericLiteral() throws RecognitionException { |
6846 | EObject current = null; | 6069 | EObject current = null; |
6847 | 6070 | ||
@@ -6849,21 +6072,17 @@ public class InternalSolverLanguageParser extends AbstractInternalAntlrParser { | |||
6849 | 6072 | ||
6850 | 6073 | ||
6851 | try { | 6074 | try { |
6852 | // InternalSolverLanguage.g:2395:55: (iv_ruleNumericLiteral= ruleNumericLiteral EOF ) | 6075 | // InternalSolverLanguageParser.g:2362:55: (iv_ruleNumericLiteral= ruleNumericLiteral EOF ) |
6853 | // InternalSolverLanguage.g:2396:2: iv_ruleNumericLiteral= ruleNumericLiteral EOF | 6076 | // InternalSolverLanguageParser.g:2363:2: iv_ruleNumericLiteral= ruleNumericLiteral EOF |
6854 | { | 6077 | { |
6855 | if ( state.backtracking==0 ) { | 6078 | newCompositeNode(grammarAccess.getNumericLiteralRule()); |
6856 | newCompositeNode(grammarAccess.getNumericLiteralRule()); | ||
6857 | } | ||
6858 | pushFollow(FOLLOW_1); | 6079 | pushFollow(FOLLOW_1); |
6859 | iv_ruleNumericLiteral=ruleNumericLiteral(); | 6080 | iv_ruleNumericLiteral=ruleNumericLiteral(); |
6860 | 6081 | ||
6861 | state._fsp--; | 6082 | state._fsp--; |
6862 | if (state.failed) return current; | 6083 | |
6863 | if ( state.backtracking==0 ) { | 6084 | current =iv_ruleNumericLiteral; |
6864 | current =iv_ruleNumericLiteral; | 6085 | match(input,EOF,FOLLOW_2); |
6865 | } | ||
6866 | match(input,EOF,FOLLOW_2); if (state.failed) return current; | ||
6867 | 6086 | ||
6868 | } | 6087 | } |
6869 | 6088 | ||
@@ -6881,7 +6100,7 @@ public class InternalSolverLanguageParser extends AbstractInternalAntlrParser { | |||
6881 | 6100 | ||
6882 | 6101 | ||
6883 | // $ANTLR start "ruleNumericLiteral" | 6102 | // $ANTLR start "ruleNumericLiteral" |
6884 | // InternalSolverLanguage.g:2402:1: ruleNumericLiteral returns [EObject current=null] : ( (lv_value_0_0= ruleReal ) ) ; | 6103 | // InternalSolverLanguageParser.g:2369:1: ruleNumericLiteral returns [EObject current=null] : ( (lv_value_0_0= ruleReal ) ) ; |
6885 | public final EObject ruleNumericLiteral() throws RecognitionException { | 6104 | public final EObject ruleNumericLiteral() throws RecognitionException { |
6886 | EObject current = null; | 6105 | EObject current = null; |
6887 | 6106 | ||
@@ -6892,38 +6111,34 @@ public class InternalSolverLanguageParser extends AbstractInternalAntlrParser { | |||
6892 | enterRule(); | 6111 | enterRule(); |
6893 | 6112 | ||
6894 | try { | 6113 | try { |
6895 | // InternalSolverLanguage.g:2408:2: ( ( (lv_value_0_0= ruleReal ) ) ) | 6114 | // InternalSolverLanguageParser.g:2375:2: ( ( (lv_value_0_0= ruleReal ) ) ) |
6896 | // InternalSolverLanguage.g:2409:2: ( (lv_value_0_0= ruleReal ) ) | 6115 | // InternalSolverLanguageParser.g:2376:2: ( (lv_value_0_0= ruleReal ) ) |
6897 | { | 6116 | { |
6898 | // InternalSolverLanguage.g:2409:2: ( (lv_value_0_0= ruleReal ) ) | 6117 | // InternalSolverLanguageParser.g:2376:2: ( (lv_value_0_0= ruleReal ) ) |
6899 | // InternalSolverLanguage.g:2410:3: (lv_value_0_0= ruleReal ) | 6118 | // InternalSolverLanguageParser.g:2377:3: (lv_value_0_0= ruleReal ) |
6900 | { | 6119 | { |
6901 | // InternalSolverLanguage.g:2410:3: (lv_value_0_0= ruleReal ) | 6120 | // InternalSolverLanguageParser.g:2377:3: (lv_value_0_0= ruleReal ) |
6902 | // InternalSolverLanguage.g:2411:4: lv_value_0_0= ruleReal | 6121 | // InternalSolverLanguageParser.g:2378:4: lv_value_0_0= ruleReal |
6903 | { | 6122 | { |
6904 | if ( state.backtracking==0 ) { | ||
6905 | 6123 | ||
6906 | newCompositeNode(grammarAccess.getNumericLiteralAccess().getValueRealParserRuleCall_0()); | 6124 | newCompositeNode(grammarAccess.getNumericLiteralAccess().getValueRealParserRuleCall_0()); |
6907 | 6125 | ||
6908 | } | ||
6909 | pushFollow(FOLLOW_2); | 6126 | pushFollow(FOLLOW_2); |
6910 | lv_value_0_0=ruleReal(); | 6127 | lv_value_0_0=ruleReal(); |
6911 | 6128 | ||
6912 | state._fsp--; | 6129 | state._fsp--; |
6913 | if (state.failed) return current; | ||
6914 | if ( state.backtracking==0 ) { | ||
6915 | 6130 | ||
6916 | if (current==null) { | 6131 | |
6917 | current = createModelElementForParent(grammarAccess.getNumericLiteralRule()); | 6132 | if (current==null) { |
6918 | } | 6133 | current = createModelElementForParent(grammarAccess.getNumericLiteralRule()); |
6919 | set( | 6134 | } |
6920 | current, | 6135 | set( |
6921 | "value", | 6136 | current, |
6922 | lv_value_0_0, | 6137 | "value", |
6923 | "org.eclipse.viatra.solver.language.SolverLanguage.Real"); | 6138 | lv_value_0_0, |
6924 | afterParserOrEnumRuleCall(); | 6139 | "org.eclipse.viatra.solver.language.SolverLanguage.Real"); |
6925 | 6140 | afterParserOrEnumRuleCall(); | |
6926 | } | 6141 | |
6927 | 6142 | ||
6928 | } | 6143 | } |
6929 | 6144 | ||
@@ -6933,11 +6148,9 @@ public class InternalSolverLanguageParser extends AbstractInternalAntlrParser { | |||
6933 | 6148 | ||
6934 | } | 6149 | } |
6935 | 6150 | ||
6936 | if ( state.backtracking==0 ) { | ||
6937 | 6151 | ||
6938 | leaveRule(); | 6152 | leaveRule(); |
6939 | 6153 | ||
6940 | } | ||
6941 | } | 6154 | } |
6942 | 6155 | ||
6943 | catch (RecognitionException re) { | 6156 | catch (RecognitionException re) { |
@@ -6952,7 +6165,7 @@ public class InternalSolverLanguageParser extends AbstractInternalAntlrParser { | |||
6952 | 6165 | ||
6953 | 6166 | ||
6954 | // $ANTLR start "entryRuleInfinityLiteral" | 6167 | // $ANTLR start "entryRuleInfinityLiteral" |
6955 | // InternalSolverLanguage.g:2431:1: entryRuleInfinityLiteral returns [EObject current=null] : iv_ruleInfinityLiteral= ruleInfinityLiteral EOF ; | 6168 | // InternalSolverLanguageParser.g:2398:1: entryRuleInfinityLiteral returns [EObject current=null] : iv_ruleInfinityLiteral= ruleInfinityLiteral EOF ; |
6956 | public final EObject entryRuleInfinityLiteral() throws RecognitionException { | 6169 | public final EObject entryRuleInfinityLiteral() throws RecognitionException { |
6957 | EObject current = null; | 6170 | EObject current = null; |
6958 | 6171 | ||
@@ -6960,21 +6173,17 @@ public class InternalSolverLanguageParser extends AbstractInternalAntlrParser { | |||
6960 | 6173 | ||
6961 | 6174 | ||
6962 | try { | 6175 | try { |
6963 | // InternalSolverLanguage.g:2431:56: (iv_ruleInfinityLiteral= ruleInfinityLiteral EOF ) | 6176 | // InternalSolverLanguageParser.g:2398:56: (iv_ruleInfinityLiteral= ruleInfinityLiteral EOF ) |
6964 | // InternalSolverLanguage.g:2432:2: iv_ruleInfinityLiteral= ruleInfinityLiteral EOF | 6177 | // InternalSolverLanguageParser.g:2399:2: iv_ruleInfinityLiteral= ruleInfinityLiteral EOF |
6965 | { | 6178 | { |
6966 | if ( state.backtracking==0 ) { | 6179 | newCompositeNode(grammarAccess.getInfinityLiteralRule()); |
6967 | newCompositeNode(grammarAccess.getInfinityLiteralRule()); | ||
6968 | } | ||
6969 | pushFollow(FOLLOW_1); | 6180 | pushFollow(FOLLOW_1); |
6970 | iv_ruleInfinityLiteral=ruleInfinityLiteral(); | 6181 | iv_ruleInfinityLiteral=ruleInfinityLiteral(); |
6971 | 6182 | ||
6972 | state._fsp--; | 6183 | state._fsp--; |
6973 | if (state.failed) return current; | 6184 | |
6974 | if ( state.backtracking==0 ) { | 6185 | current =iv_ruleInfinityLiteral; |
6975 | current =iv_ruleInfinityLiteral; | 6186 | match(input,EOF,FOLLOW_2); |
6976 | } | ||
6977 | match(input,EOF,FOLLOW_2); if (state.failed) return current; | ||
6978 | 6187 | ||
6979 | } | 6188 | } |
6980 | 6189 | ||
@@ -6992,7 +6201,7 @@ public class InternalSolverLanguageParser extends AbstractInternalAntlrParser { | |||
6992 | 6201 | ||
6993 | 6202 | ||
6994 | // $ANTLR start "ruleInfinityLiteral" | 6203 | // $ANTLR start "ruleInfinityLiteral" |
6995 | // InternalSolverLanguage.g:2438:1: ruleInfinityLiteral returns [EObject current=null] : ( () otherlv_1= 'inf' ) ; | 6204 | // InternalSolverLanguageParser.g:2405:1: ruleInfinityLiteral returns [EObject current=null] : ( () otherlv_1= Inf ) ; |
6996 | public final EObject ruleInfinityLiteral() throws RecognitionException { | 6205 | public final EObject ruleInfinityLiteral() throws RecognitionException { |
6997 | EObject current = null; | 6206 | EObject current = null; |
6998 | 6207 | ||
@@ -7002,42 +6211,36 @@ public class InternalSolverLanguageParser extends AbstractInternalAntlrParser { | |||
7002 | enterRule(); | 6211 | enterRule(); |
7003 | 6212 | ||
7004 | try { | 6213 | try { |
7005 | // InternalSolverLanguage.g:2444:2: ( ( () otherlv_1= 'inf' ) ) | 6214 | // InternalSolverLanguageParser.g:2411:2: ( ( () otherlv_1= Inf ) ) |
7006 | // InternalSolverLanguage.g:2445:2: ( () otherlv_1= 'inf' ) | 6215 | // InternalSolverLanguageParser.g:2412:2: ( () otherlv_1= Inf ) |
7007 | { | 6216 | { |
7008 | // InternalSolverLanguage.g:2445:2: ( () otherlv_1= 'inf' ) | 6217 | // InternalSolverLanguageParser.g:2412:2: ( () otherlv_1= Inf ) |
7009 | // InternalSolverLanguage.g:2446:3: () otherlv_1= 'inf' | 6218 | // InternalSolverLanguageParser.g:2413:3: () otherlv_1= Inf |
7010 | { | 6219 | { |
7011 | // InternalSolverLanguage.g:2446:3: () | 6220 | // InternalSolverLanguageParser.g:2413:3: () |
7012 | // InternalSolverLanguage.g:2447:4: | 6221 | // InternalSolverLanguageParser.g:2414:4: |
7013 | { | 6222 | { |
7014 | if ( state.backtracking==0 ) { | ||
7015 | 6223 | ||
7016 | current = forceCreateModelElement( | 6224 | current = forceCreateModelElement( |
7017 | grammarAccess.getInfinityLiteralAccess().getInfinityLiteralAction_0(), | 6225 | grammarAccess.getInfinityLiteralAccess().getInfinityLiteralAction_0(), |
7018 | current); | 6226 | current); |
7019 | 6227 | ||
7020 | } | ||
7021 | 6228 | ||
7022 | } | 6229 | } |
7023 | 6230 | ||
7024 | otherlv_1=(Token)match(input,39,FOLLOW_2); if (state.failed) return current; | 6231 | otherlv_1=(Token)match(input,Inf,FOLLOW_2); |
7025 | if ( state.backtracking==0 ) { | ||
7026 | 6232 | ||
7027 | newLeafNode(otherlv_1, grammarAccess.getInfinityLiteralAccess().getInfKeyword_1()); | 6233 | newLeafNode(otherlv_1, grammarAccess.getInfinityLiteralAccess().getInfKeyword_1()); |
7028 | 6234 | ||
7029 | } | ||
7030 | 6235 | ||
7031 | } | 6236 | } |
7032 | 6237 | ||
7033 | 6238 | ||
7034 | } | 6239 | } |
7035 | 6240 | ||
7036 | if ( state.backtracking==0 ) { | ||
7037 | 6241 | ||
7038 | leaveRule(); | 6242 | leaveRule(); |
7039 | 6243 | ||
7040 | } | ||
7041 | } | 6244 | } |
7042 | 6245 | ||
7043 | catch (RecognitionException re) { | 6246 | catch (RecognitionException re) { |
@@ -7052,7 +6255,7 @@ public class InternalSolverLanguageParser extends AbstractInternalAntlrParser { | |||
7052 | 6255 | ||
7053 | 6256 | ||
7054 | // $ANTLR start "entryRuleEmptyIntervalLiteral" | 6257 | // $ANTLR start "entryRuleEmptyIntervalLiteral" |
7055 | // InternalSolverLanguage.g:2461:1: entryRuleEmptyIntervalLiteral returns [EObject current=null] : iv_ruleEmptyIntervalLiteral= ruleEmptyIntervalLiteral EOF ; | 6258 | // InternalSolverLanguageParser.g:2428:1: entryRuleEmptyIntervalLiteral returns [EObject current=null] : iv_ruleEmptyIntervalLiteral= ruleEmptyIntervalLiteral EOF ; |
7056 | public final EObject entryRuleEmptyIntervalLiteral() throws RecognitionException { | 6259 | public final EObject entryRuleEmptyIntervalLiteral() throws RecognitionException { |
7057 | EObject current = null; | 6260 | EObject current = null; |
7058 | 6261 | ||
@@ -7060,21 +6263,17 @@ public class InternalSolverLanguageParser extends AbstractInternalAntlrParser { | |||
7060 | 6263 | ||
7061 | 6264 | ||
7062 | try { | 6265 | try { |
7063 | // InternalSolverLanguage.g:2461:61: (iv_ruleEmptyIntervalLiteral= ruleEmptyIntervalLiteral EOF ) | 6266 | // InternalSolverLanguageParser.g:2428:61: (iv_ruleEmptyIntervalLiteral= ruleEmptyIntervalLiteral EOF ) |
7064 | // InternalSolverLanguage.g:2462:2: iv_ruleEmptyIntervalLiteral= ruleEmptyIntervalLiteral EOF | 6267 | // InternalSolverLanguageParser.g:2429:2: iv_ruleEmptyIntervalLiteral= ruleEmptyIntervalLiteral EOF |
7065 | { | 6268 | { |
7066 | if ( state.backtracking==0 ) { | 6269 | newCompositeNode(grammarAccess.getEmptyIntervalLiteralRule()); |
7067 | newCompositeNode(grammarAccess.getEmptyIntervalLiteralRule()); | ||
7068 | } | ||
7069 | pushFollow(FOLLOW_1); | 6270 | pushFollow(FOLLOW_1); |
7070 | iv_ruleEmptyIntervalLiteral=ruleEmptyIntervalLiteral(); | 6271 | iv_ruleEmptyIntervalLiteral=ruleEmptyIntervalLiteral(); |
7071 | 6272 | ||
7072 | state._fsp--; | 6273 | state._fsp--; |
7073 | if (state.failed) return current; | 6274 | |
7074 | if ( state.backtracking==0 ) { | 6275 | current =iv_ruleEmptyIntervalLiteral; |
7075 | current =iv_ruleEmptyIntervalLiteral; | 6276 | match(input,EOF,FOLLOW_2); |
7076 | } | ||
7077 | match(input,EOF,FOLLOW_2); if (state.failed) return current; | ||
7078 | 6277 | ||
7079 | } | 6278 | } |
7080 | 6279 | ||
@@ -7092,7 +6291,7 @@ public class InternalSolverLanguageParser extends AbstractInternalAntlrParser { | |||
7092 | 6291 | ||
7093 | 6292 | ||
7094 | // $ANTLR start "ruleEmptyIntervalLiteral" | 6293 | // $ANTLR start "ruleEmptyIntervalLiteral" |
7095 | // InternalSolverLanguage.g:2468:1: ruleEmptyIntervalLiteral returns [EObject current=null] : ( () otherlv_1= 'empty' ) ; | 6294 | // InternalSolverLanguageParser.g:2435:1: ruleEmptyIntervalLiteral returns [EObject current=null] : ( () otherlv_1= Empty ) ; |
7096 | public final EObject ruleEmptyIntervalLiteral() throws RecognitionException { | 6295 | public final EObject ruleEmptyIntervalLiteral() throws RecognitionException { |
7097 | EObject current = null; | 6296 | EObject current = null; |
7098 | 6297 | ||
@@ -7102,42 +6301,36 @@ public class InternalSolverLanguageParser extends AbstractInternalAntlrParser { | |||
7102 | enterRule(); | 6301 | enterRule(); |
7103 | 6302 | ||
7104 | try { | 6303 | try { |
7105 | // InternalSolverLanguage.g:2474:2: ( ( () otherlv_1= 'empty' ) ) | 6304 | // InternalSolverLanguageParser.g:2441:2: ( ( () otherlv_1= Empty ) ) |
7106 | // InternalSolverLanguage.g:2475:2: ( () otherlv_1= 'empty' ) | 6305 | // InternalSolverLanguageParser.g:2442:2: ( () otherlv_1= Empty ) |
7107 | { | 6306 | { |
7108 | // InternalSolverLanguage.g:2475:2: ( () otherlv_1= 'empty' ) | 6307 | // InternalSolverLanguageParser.g:2442:2: ( () otherlv_1= Empty ) |
7109 | // InternalSolverLanguage.g:2476:3: () otherlv_1= 'empty' | 6308 | // InternalSolverLanguageParser.g:2443:3: () otherlv_1= Empty |
7110 | { | 6309 | { |
7111 | // InternalSolverLanguage.g:2476:3: () | 6310 | // InternalSolverLanguageParser.g:2443:3: () |
7112 | // InternalSolverLanguage.g:2477:4: | 6311 | // InternalSolverLanguageParser.g:2444:4: |
7113 | { | 6312 | { |
7114 | if ( state.backtracking==0 ) { | ||
7115 | 6313 | ||
7116 | current = forceCreateModelElement( | 6314 | current = forceCreateModelElement( |
7117 | grammarAccess.getEmptyIntervalLiteralAccess().getEmptyIntervalLiteralAction_0(), | 6315 | grammarAccess.getEmptyIntervalLiteralAccess().getEmptyIntervalLiteralAction_0(), |
7118 | current); | 6316 | current); |
7119 | 6317 | ||
7120 | } | ||
7121 | 6318 | ||
7122 | } | 6319 | } |
7123 | 6320 | ||
7124 | otherlv_1=(Token)match(input,40,FOLLOW_2); if (state.failed) return current; | 6321 | otherlv_1=(Token)match(input,Empty,FOLLOW_2); |
7125 | if ( state.backtracking==0 ) { | ||
7126 | 6322 | ||
7127 | newLeafNode(otherlv_1, grammarAccess.getEmptyIntervalLiteralAccess().getEmptyKeyword_1()); | 6323 | newLeafNode(otherlv_1, grammarAccess.getEmptyIntervalLiteralAccess().getEmptyKeyword_1()); |
7128 | 6324 | ||
7129 | } | ||
7130 | 6325 | ||
7131 | } | 6326 | } |
7132 | 6327 | ||
7133 | 6328 | ||
7134 | } | 6329 | } |
7135 | 6330 | ||
7136 | if ( state.backtracking==0 ) { | ||
7137 | 6331 | ||
7138 | leaveRule(); | 6332 | leaveRule(); |
7139 | 6333 | ||
7140 | } | ||
7141 | } | 6334 | } |
7142 | 6335 | ||
7143 | catch (RecognitionException re) { | 6336 | catch (RecognitionException re) { |
@@ -7152,7 +6345,7 @@ public class InternalSolverLanguageParser extends AbstractInternalAntlrParser { | |||
7152 | 6345 | ||
7153 | 6346 | ||
7154 | // $ANTLR start "entryRuleStringLiteral" | 6347 | // $ANTLR start "entryRuleStringLiteral" |
7155 | // InternalSolverLanguage.g:2491:1: entryRuleStringLiteral returns [EObject current=null] : iv_ruleStringLiteral= ruleStringLiteral EOF ; | 6348 | // InternalSolverLanguageParser.g:2458:1: entryRuleStringLiteral returns [EObject current=null] : iv_ruleStringLiteral= ruleStringLiteral EOF ; |
7156 | public final EObject entryRuleStringLiteral() throws RecognitionException { | 6349 | public final EObject entryRuleStringLiteral() throws RecognitionException { |
7157 | EObject current = null; | 6350 | EObject current = null; |
7158 | 6351 | ||
@@ -7160,21 +6353,17 @@ public class InternalSolverLanguageParser extends AbstractInternalAntlrParser { | |||
7160 | 6353 | ||
7161 | 6354 | ||
7162 | try { | 6355 | try { |
7163 | // InternalSolverLanguage.g:2491:54: (iv_ruleStringLiteral= ruleStringLiteral EOF ) | 6356 | // InternalSolverLanguageParser.g:2458:54: (iv_ruleStringLiteral= ruleStringLiteral EOF ) |
7164 | // InternalSolverLanguage.g:2492:2: iv_ruleStringLiteral= ruleStringLiteral EOF | 6357 | // InternalSolverLanguageParser.g:2459:2: iv_ruleStringLiteral= ruleStringLiteral EOF |
7165 | { | 6358 | { |
7166 | if ( state.backtracking==0 ) { | 6359 | newCompositeNode(grammarAccess.getStringLiteralRule()); |
7167 | newCompositeNode(grammarAccess.getStringLiteralRule()); | ||
7168 | } | ||
7169 | pushFollow(FOLLOW_1); | 6360 | pushFollow(FOLLOW_1); |
7170 | iv_ruleStringLiteral=ruleStringLiteral(); | 6361 | iv_ruleStringLiteral=ruleStringLiteral(); |
7171 | 6362 | ||
7172 | state._fsp--; | 6363 | state._fsp--; |
7173 | if (state.failed) return current; | 6364 | |
7174 | if ( state.backtracking==0 ) { | 6365 | current =iv_ruleStringLiteral; |
7175 | current =iv_ruleStringLiteral; | 6366 | match(input,EOF,FOLLOW_2); |
7176 | } | ||
7177 | match(input,EOF,FOLLOW_2); if (state.failed) return current; | ||
7178 | 6367 | ||
7179 | } | 6368 | } |
7180 | 6369 | ||
@@ -7192,7 +6381,7 @@ public class InternalSolverLanguageParser extends AbstractInternalAntlrParser { | |||
7192 | 6381 | ||
7193 | 6382 | ||
7194 | // $ANTLR start "ruleStringLiteral" | 6383 | // $ANTLR start "ruleStringLiteral" |
7195 | // InternalSolverLanguage.g:2498:1: ruleStringLiteral returns [EObject current=null] : ( (lv_value_0_0= RULE_STRING ) ) ; | 6384 | // InternalSolverLanguageParser.g:2465:1: ruleStringLiteral returns [EObject current=null] : ( (lv_value_0_0= RULE_STRING ) ) ; |
7196 | public final EObject ruleStringLiteral() throws RecognitionException { | 6385 | public final EObject ruleStringLiteral() throws RecognitionException { |
7197 | EObject current = null; | 6386 | EObject current = null; |
7198 | 6387 | ||
@@ -7202,33 +6391,29 @@ public class InternalSolverLanguageParser extends AbstractInternalAntlrParser { | |||
7202 | enterRule(); | 6391 | enterRule(); |
7203 | 6392 | ||
7204 | try { | 6393 | try { |
7205 | // InternalSolverLanguage.g:2504:2: ( ( (lv_value_0_0= RULE_STRING ) ) ) | 6394 | // InternalSolverLanguageParser.g:2471:2: ( ( (lv_value_0_0= RULE_STRING ) ) ) |
7206 | // InternalSolverLanguage.g:2505:2: ( (lv_value_0_0= RULE_STRING ) ) | 6395 | // InternalSolverLanguageParser.g:2472:2: ( (lv_value_0_0= RULE_STRING ) ) |
7207 | { | 6396 | { |
7208 | // InternalSolverLanguage.g:2505:2: ( (lv_value_0_0= RULE_STRING ) ) | 6397 | // InternalSolverLanguageParser.g:2472:2: ( (lv_value_0_0= RULE_STRING ) ) |
7209 | // InternalSolverLanguage.g:2506:3: (lv_value_0_0= RULE_STRING ) | 6398 | // InternalSolverLanguageParser.g:2473:3: (lv_value_0_0= RULE_STRING ) |
7210 | { | 6399 | { |
7211 | // InternalSolverLanguage.g:2506:3: (lv_value_0_0= RULE_STRING ) | 6400 | // InternalSolverLanguageParser.g:2473:3: (lv_value_0_0= RULE_STRING ) |
7212 | // InternalSolverLanguage.g:2507:4: lv_value_0_0= RULE_STRING | 6401 | // InternalSolverLanguageParser.g:2474:4: lv_value_0_0= RULE_STRING |
7213 | { | 6402 | { |
7214 | lv_value_0_0=(Token)match(input,RULE_STRING,FOLLOW_2); if (state.failed) return current; | 6403 | lv_value_0_0=(Token)match(input,RULE_STRING,FOLLOW_2); |
7215 | if ( state.backtracking==0 ) { | ||
7216 | 6404 | ||
7217 | newLeafNode(lv_value_0_0, grammarAccess.getStringLiteralAccess().getValueSTRINGTerminalRuleCall_0()); | 6405 | newLeafNode(lv_value_0_0, grammarAccess.getStringLiteralAccess().getValueSTRINGTerminalRuleCall_0()); |
7218 | 6406 | ||
7219 | } | ||
7220 | if ( state.backtracking==0 ) { | ||
7221 | 6407 | ||
7222 | if (current==null) { | 6408 | if (current==null) { |
7223 | current = createModelElement(grammarAccess.getStringLiteralRule()); | 6409 | current = createModelElement(grammarAccess.getStringLiteralRule()); |
7224 | } | 6410 | } |
7225 | setWithLastConsumed( | 6411 | setWithLastConsumed( |
7226 | current, | 6412 | current, |
7227 | "value", | 6413 | "value", |
7228 | lv_value_0_0, | 6414 | lv_value_0_0, |
7229 | "org.eclipse.viatra.solver.language.SolverLanguage.STRING"); | 6415 | "org.eclipse.viatra.solver.language.SolverLanguage.STRING"); |
7230 | 6416 | ||
7231 | } | ||
7232 | 6417 | ||
7233 | } | 6418 | } |
7234 | 6419 | ||
@@ -7238,11 +6423,9 @@ public class InternalSolverLanguageParser extends AbstractInternalAntlrParser { | |||
7238 | 6423 | ||
7239 | } | 6424 | } |
7240 | 6425 | ||
7241 | if ( state.backtracking==0 ) { | ||
7242 | 6426 | ||
7243 | leaveRule(); | 6427 | leaveRule(); |
7244 | 6428 | ||
7245 | } | ||
7246 | } | 6429 | } |
7247 | 6430 | ||
7248 | catch (RecognitionException re) { | 6431 | catch (RecognitionException re) { |
@@ -7257,7 +6440,7 @@ public class InternalSolverLanguageParser extends AbstractInternalAntlrParser { | |||
7257 | 6440 | ||
7258 | 6441 | ||
7259 | // $ANTLR start "entryRuleClassDefinition" | 6442 | // $ANTLR start "entryRuleClassDefinition" |
7260 | // InternalSolverLanguage.g:2526:1: entryRuleClassDefinition returns [EObject current=null] : iv_ruleClassDefinition= ruleClassDefinition EOF ; | 6443 | // InternalSolverLanguageParser.g:2493:1: entryRuleClassDefinition returns [EObject current=null] : iv_ruleClassDefinition= ruleClassDefinition EOF ; |
7261 | public final EObject entryRuleClassDefinition() throws RecognitionException { | 6444 | public final EObject entryRuleClassDefinition() throws RecognitionException { |
7262 | EObject current = null; | 6445 | EObject current = null; |
7263 | 6446 | ||
@@ -7265,21 +6448,17 @@ public class InternalSolverLanguageParser extends AbstractInternalAntlrParser { | |||
7265 | 6448 | ||
7266 | 6449 | ||
7267 | try { | 6450 | try { |
7268 | // InternalSolverLanguage.g:2526:56: (iv_ruleClassDefinition= ruleClassDefinition EOF ) | 6451 | // InternalSolverLanguageParser.g:2493:56: (iv_ruleClassDefinition= ruleClassDefinition EOF ) |
7269 | // InternalSolverLanguage.g:2527:2: iv_ruleClassDefinition= ruleClassDefinition EOF | 6452 | // InternalSolverLanguageParser.g:2494:2: iv_ruleClassDefinition= ruleClassDefinition EOF |
7270 | { | 6453 | { |
7271 | if ( state.backtracking==0 ) { | 6454 | newCompositeNode(grammarAccess.getClassDefinitionRule()); |
7272 | newCompositeNode(grammarAccess.getClassDefinitionRule()); | ||
7273 | } | ||
7274 | pushFollow(FOLLOW_1); | 6455 | pushFollow(FOLLOW_1); |
7275 | iv_ruleClassDefinition=ruleClassDefinition(); | 6456 | iv_ruleClassDefinition=ruleClassDefinition(); |
7276 | 6457 | ||
7277 | state._fsp--; | 6458 | state._fsp--; |
7278 | if (state.failed) return current; | 6459 | |
7279 | if ( state.backtracking==0 ) { | 6460 | current =iv_ruleClassDefinition; |
7280 | current =iv_ruleClassDefinition; | 6461 | match(input,EOF,FOLLOW_2); |
7281 | } | ||
7282 | match(input,EOF,FOLLOW_2); if (state.failed) return current; | ||
7283 | 6462 | ||
7284 | } | 6463 | } |
7285 | 6464 | ||
@@ -7297,7 +6476,7 @@ public class InternalSolverLanguageParser extends AbstractInternalAntlrParser { | |||
7297 | 6476 | ||
7298 | 6477 | ||
7299 | // $ANTLR start "ruleClassDefinition" | 6478 | // $ANTLR start "ruleClassDefinition" |
7300 | // InternalSolverLanguage.g:2533:1: ruleClassDefinition returns [EObject current=null] : ( ( (lv_abstract_0_0= 'abstract' ) )? otherlv_1= 'class' ( (lv_name_2_0= RULE_ID ) ) (otherlv_3= 'extends' ( ( ruleQualifiedName ) ) (otherlv_5= ',' ( ( ruleQualifiedName ) ) )* )? otherlv_7= '{' ( (lv_members_8_0= ruleMemberDefinition ) )* otherlv_9= '}' ) ; | 6479 | // InternalSolverLanguageParser.g:2500:1: ruleClassDefinition returns [EObject current=null] : ( ( (lv_abstract_0_0= Abstract ) )? otherlv_1= Class ( (lv_name_2_0= RULE_ID ) ) (otherlv_3= Extends ( ( ruleQualifiedName ) ) (otherlv_5= Comma ( ( ruleQualifiedName ) ) )* )? otherlv_7= LeftCurlyBracket ( (lv_members_8_0= ruleMemberDefinition ) )* otherlv_9= RightCurlyBracket ) ; |
7301 | public final EObject ruleClassDefinition() throws RecognitionException { | 6480 | public final EObject ruleClassDefinition() throws RecognitionException { |
7302 | EObject current = null; | 6481 | EObject current = null; |
7303 | 6482 | ||
@@ -7315,40 +6494,36 @@ public class InternalSolverLanguageParser extends AbstractInternalAntlrParser { | |||
7315 | enterRule(); | 6494 | enterRule(); |
7316 | 6495 | ||
7317 | try { | 6496 | try { |
7318 | // InternalSolverLanguage.g:2539:2: ( ( ( (lv_abstract_0_0= 'abstract' ) )? otherlv_1= 'class' ( (lv_name_2_0= RULE_ID ) ) (otherlv_3= 'extends' ( ( ruleQualifiedName ) ) (otherlv_5= ',' ( ( ruleQualifiedName ) ) )* )? otherlv_7= '{' ( (lv_members_8_0= ruleMemberDefinition ) )* otherlv_9= '}' ) ) | 6497 | // InternalSolverLanguageParser.g:2506:2: ( ( ( (lv_abstract_0_0= Abstract ) )? otherlv_1= Class ( (lv_name_2_0= RULE_ID ) ) (otherlv_3= Extends ( ( ruleQualifiedName ) ) (otherlv_5= Comma ( ( ruleQualifiedName ) ) )* )? otherlv_7= LeftCurlyBracket ( (lv_members_8_0= ruleMemberDefinition ) )* otherlv_9= RightCurlyBracket ) ) |
7319 | // InternalSolverLanguage.g:2540:2: ( ( (lv_abstract_0_0= 'abstract' ) )? otherlv_1= 'class' ( (lv_name_2_0= RULE_ID ) ) (otherlv_3= 'extends' ( ( ruleQualifiedName ) ) (otherlv_5= ',' ( ( ruleQualifiedName ) ) )* )? otherlv_7= '{' ( (lv_members_8_0= ruleMemberDefinition ) )* otherlv_9= '}' ) | 6498 | // InternalSolverLanguageParser.g:2507:2: ( ( (lv_abstract_0_0= Abstract ) )? otherlv_1= Class ( (lv_name_2_0= RULE_ID ) ) (otherlv_3= Extends ( ( ruleQualifiedName ) ) (otherlv_5= Comma ( ( ruleQualifiedName ) ) )* )? otherlv_7= LeftCurlyBracket ( (lv_members_8_0= ruleMemberDefinition ) )* otherlv_9= RightCurlyBracket ) |
7320 | { | 6499 | { |
7321 | // InternalSolverLanguage.g:2540:2: ( ( (lv_abstract_0_0= 'abstract' ) )? otherlv_1= 'class' ( (lv_name_2_0= RULE_ID ) ) (otherlv_3= 'extends' ( ( ruleQualifiedName ) ) (otherlv_5= ',' ( ( ruleQualifiedName ) ) )* )? otherlv_7= '{' ( (lv_members_8_0= ruleMemberDefinition ) )* otherlv_9= '}' ) | 6500 | // InternalSolverLanguageParser.g:2507:2: ( ( (lv_abstract_0_0= Abstract ) )? otherlv_1= Class ( (lv_name_2_0= RULE_ID ) ) (otherlv_3= Extends ( ( ruleQualifiedName ) ) (otherlv_5= Comma ( ( ruleQualifiedName ) ) )* )? otherlv_7= LeftCurlyBracket ( (lv_members_8_0= ruleMemberDefinition ) )* otherlv_9= RightCurlyBracket ) |
7322 | // InternalSolverLanguage.g:2541:3: ( (lv_abstract_0_0= 'abstract' ) )? otherlv_1= 'class' ( (lv_name_2_0= RULE_ID ) ) (otherlv_3= 'extends' ( ( ruleQualifiedName ) ) (otherlv_5= ',' ( ( ruleQualifiedName ) ) )* )? otherlv_7= '{' ( (lv_members_8_0= ruleMemberDefinition ) )* otherlv_9= '}' | 6501 | // InternalSolverLanguageParser.g:2508:3: ( (lv_abstract_0_0= Abstract ) )? otherlv_1= Class ( (lv_name_2_0= RULE_ID ) ) (otherlv_3= Extends ( ( ruleQualifiedName ) ) (otherlv_5= Comma ( ( ruleQualifiedName ) ) )* )? otherlv_7= LeftCurlyBracket ( (lv_members_8_0= ruleMemberDefinition ) )* otherlv_9= RightCurlyBracket |
7323 | { | 6502 | { |
7324 | // InternalSolverLanguage.g:2541:3: ( (lv_abstract_0_0= 'abstract' ) )? | 6503 | // InternalSolverLanguageParser.g:2508:3: ( (lv_abstract_0_0= Abstract ) )? |
7325 | int alt27=2; | 6504 | int alt26=2; |
7326 | int LA27_0 = input.LA(1); | 6505 | int LA26_0 = input.LA(1); |
7327 | 6506 | ||
7328 | if ( (LA27_0==41) ) { | 6507 | if ( (LA26_0==Abstract) ) { |
7329 | alt27=1; | 6508 | alt26=1; |
7330 | } | 6509 | } |
7331 | switch (alt27) { | 6510 | switch (alt26) { |
7332 | case 1 : | 6511 | case 1 : |
7333 | // InternalSolverLanguage.g:2542:4: (lv_abstract_0_0= 'abstract' ) | 6512 | // InternalSolverLanguageParser.g:2509:4: (lv_abstract_0_0= Abstract ) |
7334 | { | 6513 | { |
7335 | // InternalSolverLanguage.g:2542:4: (lv_abstract_0_0= 'abstract' ) | 6514 | // InternalSolverLanguageParser.g:2509:4: (lv_abstract_0_0= Abstract ) |
7336 | // InternalSolverLanguage.g:2543:5: lv_abstract_0_0= 'abstract' | 6515 | // InternalSolverLanguageParser.g:2510:5: lv_abstract_0_0= Abstract |
7337 | { | 6516 | { |
7338 | lv_abstract_0_0=(Token)match(input,41,FOLLOW_39); if (state.failed) return current; | 6517 | lv_abstract_0_0=(Token)match(input,Abstract,FOLLOW_37); |
7339 | if ( state.backtracking==0 ) { | ||
7340 | 6518 | ||
7341 | newLeafNode(lv_abstract_0_0, grammarAccess.getClassDefinitionAccess().getAbstractAbstractKeyword_0_0()); | 6519 | newLeafNode(lv_abstract_0_0, grammarAccess.getClassDefinitionAccess().getAbstractAbstractKeyword_0_0()); |
7342 | 6520 | ||
7343 | } | ||
7344 | if ( state.backtracking==0 ) { | ||
7345 | 6521 | ||
7346 | if (current==null) { | 6522 | if (current==null) { |
7347 | current = createModelElement(grammarAccess.getClassDefinitionRule()); | 6523 | current = createModelElement(grammarAccess.getClassDefinitionRule()); |
7348 | } | 6524 | } |
7349 | setWithLastConsumed(current, "abstract", true, "abstract"); | 6525 | setWithLastConsumed(current, "abstract", true, "abstract"); |
7350 | 6526 | ||
7351 | } | ||
7352 | 6527 | ||
7353 | } | 6528 | } |
7354 | 6529 | ||
@@ -7358,142 +6533,120 @@ public class InternalSolverLanguageParser extends AbstractInternalAntlrParser { | |||
7358 | 6533 | ||
7359 | } | 6534 | } |
7360 | 6535 | ||
7361 | otherlv_1=(Token)match(input,42,FOLLOW_40); if (state.failed) return current; | 6536 | otherlv_1=(Token)match(input,Class,FOLLOW_38); |
7362 | if ( state.backtracking==0 ) { | ||
7363 | 6537 | ||
7364 | newLeafNode(otherlv_1, grammarAccess.getClassDefinitionAccess().getClassKeyword_1()); | 6538 | newLeafNode(otherlv_1, grammarAccess.getClassDefinitionAccess().getClassKeyword_1()); |
7365 | 6539 | ||
7366 | } | 6540 | // InternalSolverLanguageParser.g:2526:3: ( (lv_name_2_0= RULE_ID ) ) |
7367 | // InternalSolverLanguage.g:2559:3: ( (lv_name_2_0= RULE_ID ) ) | 6541 | // InternalSolverLanguageParser.g:2527:4: (lv_name_2_0= RULE_ID ) |
7368 | // InternalSolverLanguage.g:2560:4: (lv_name_2_0= RULE_ID ) | ||
7369 | { | 6542 | { |
7370 | // InternalSolverLanguage.g:2560:4: (lv_name_2_0= RULE_ID ) | 6543 | // InternalSolverLanguageParser.g:2527:4: (lv_name_2_0= RULE_ID ) |
7371 | // InternalSolverLanguage.g:2561:5: lv_name_2_0= RULE_ID | 6544 | // InternalSolverLanguageParser.g:2528:5: lv_name_2_0= RULE_ID |
7372 | { | 6545 | { |
7373 | lv_name_2_0=(Token)match(input,RULE_ID,FOLLOW_41); if (state.failed) return current; | 6546 | lv_name_2_0=(Token)match(input,RULE_ID,FOLLOW_39); |
7374 | if ( state.backtracking==0 ) { | ||
7375 | 6547 | ||
7376 | newLeafNode(lv_name_2_0, grammarAccess.getClassDefinitionAccess().getNameIDTerminalRuleCall_2_0()); | 6548 | newLeafNode(lv_name_2_0, grammarAccess.getClassDefinitionAccess().getNameIDTerminalRuleCall_2_0()); |
7377 | 6549 | ||
7378 | } | ||
7379 | if ( state.backtracking==0 ) { | ||
7380 | 6550 | ||
7381 | if (current==null) { | 6551 | if (current==null) { |
7382 | current = createModelElement(grammarAccess.getClassDefinitionRule()); | 6552 | current = createModelElement(grammarAccess.getClassDefinitionRule()); |
7383 | } | 6553 | } |
7384 | setWithLastConsumed( | 6554 | setWithLastConsumed( |
7385 | current, | 6555 | current, |
7386 | "name", | 6556 | "name", |
7387 | lv_name_2_0, | 6557 | lv_name_2_0, |
7388 | "org.eclipse.xtext.common.Terminals.ID"); | 6558 | "org.eclipse.xtext.common.Terminals.ID"); |
7389 | 6559 | ||
7390 | } | ||
7391 | 6560 | ||
7392 | } | 6561 | } |
7393 | 6562 | ||
7394 | 6563 | ||
7395 | } | 6564 | } |
7396 | 6565 | ||
7397 | // InternalSolverLanguage.g:2577:3: (otherlv_3= 'extends' ( ( ruleQualifiedName ) ) (otherlv_5= ',' ( ( ruleQualifiedName ) ) )* )? | 6566 | // InternalSolverLanguageParser.g:2544:3: (otherlv_3= Extends ( ( ruleQualifiedName ) ) (otherlv_5= Comma ( ( ruleQualifiedName ) ) )* )? |
7398 | int alt29=2; | 6567 | int alt28=2; |
7399 | int LA29_0 = input.LA(1); | 6568 | int LA28_0 = input.LA(1); |
7400 | 6569 | ||
7401 | if ( (LA29_0==43) ) { | 6570 | if ( (LA28_0==Extends) ) { |
7402 | alt29=1; | 6571 | alt28=1; |
7403 | } | 6572 | } |
7404 | switch (alt29) { | 6573 | switch (alt28) { |
7405 | case 1 : | 6574 | case 1 : |
7406 | // InternalSolverLanguage.g:2578:4: otherlv_3= 'extends' ( ( ruleQualifiedName ) ) (otherlv_5= ',' ( ( ruleQualifiedName ) ) )* | 6575 | // InternalSolverLanguageParser.g:2545:4: otherlv_3= Extends ( ( ruleQualifiedName ) ) (otherlv_5= Comma ( ( ruleQualifiedName ) ) )* |
7407 | { | 6576 | { |
7408 | otherlv_3=(Token)match(input,43,FOLLOW_35); if (state.failed) return current; | 6577 | otherlv_3=(Token)match(input,Extends,FOLLOW_8); |
7409 | if ( state.backtracking==0 ) { | ||
7410 | 6578 | ||
7411 | newLeafNode(otherlv_3, grammarAccess.getClassDefinitionAccess().getExtendsKeyword_3_0()); | 6579 | newLeafNode(otherlv_3, grammarAccess.getClassDefinitionAccess().getExtendsKeyword_3_0()); |
7412 | 6580 | ||
7413 | } | 6581 | // InternalSolverLanguageParser.g:2549:4: ( ( ruleQualifiedName ) ) |
7414 | // InternalSolverLanguage.g:2582:4: ( ( ruleQualifiedName ) ) | 6582 | // InternalSolverLanguageParser.g:2550:5: ( ruleQualifiedName ) |
7415 | // InternalSolverLanguage.g:2583:5: ( ruleQualifiedName ) | ||
7416 | { | 6583 | { |
7417 | // InternalSolverLanguage.g:2583:5: ( ruleQualifiedName ) | 6584 | // InternalSolverLanguageParser.g:2550:5: ( ruleQualifiedName ) |
7418 | // InternalSolverLanguage.g:2584:6: ruleQualifiedName | 6585 | // InternalSolverLanguageParser.g:2551:6: ruleQualifiedName |
7419 | { | 6586 | { |
7420 | if ( state.backtracking==0 ) { | ||
7421 | 6587 | ||
7422 | if (current==null) { | 6588 | if (current==null) { |
7423 | current = createModelElement(grammarAccess.getClassDefinitionRule()); | 6589 | current = createModelElement(grammarAccess.getClassDefinitionRule()); |
7424 | } | 6590 | } |
7425 | 6591 | ||
7426 | } | ||
7427 | if ( state.backtracking==0 ) { | ||
7428 | 6592 | ||
7429 | newCompositeNode(grammarAccess.getClassDefinitionAccess().getSuperclassesNamedElementCrossReference_3_1_0()); | 6593 | newCompositeNode(grammarAccess.getClassDefinitionAccess().getSuperclassesNamedElementCrossReference_3_1_0()); |
7430 | 6594 | ||
7431 | } | 6595 | pushFollow(FOLLOW_40); |
7432 | pushFollow(FOLLOW_42); | ||
7433 | ruleQualifiedName(); | 6596 | ruleQualifiedName(); |
7434 | 6597 | ||
7435 | state._fsp--; | 6598 | state._fsp--; |
7436 | if (state.failed) return current; | ||
7437 | if ( state.backtracking==0 ) { | ||
7438 | 6599 | ||
7439 | afterParserOrEnumRuleCall(); | 6600 | |
7440 | 6601 | afterParserOrEnumRuleCall(); | |
7441 | } | 6602 | |
7442 | 6603 | ||
7443 | } | 6604 | } |
7444 | 6605 | ||
7445 | 6606 | ||
7446 | } | 6607 | } |
7447 | 6608 | ||
7448 | // InternalSolverLanguage.g:2598:4: (otherlv_5= ',' ( ( ruleQualifiedName ) ) )* | 6609 | // InternalSolverLanguageParser.g:2565:4: (otherlv_5= Comma ( ( ruleQualifiedName ) ) )* |
7449 | loop28: | 6610 | loop27: |
7450 | do { | 6611 | do { |
7451 | int alt28=2; | 6612 | int alt27=2; |
7452 | int LA28_0 = input.LA(1); | 6613 | int LA27_0 = input.LA(1); |
7453 | 6614 | ||
7454 | if ( (LA28_0==28) ) { | 6615 | if ( (LA27_0==Comma) ) { |
7455 | alt28=1; | 6616 | alt27=1; |
7456 | } | 6617 | } |
7457 | 6618 | ||
7458 | 6619 | ||
7459 | switch (alt28) { | 6620 | switch (alt27) { |
7460 | case 1 : | 6621 | case 1 : |
7461 | // InternalSolverLanguage.g:2599:5: otherlv_5= ',' ( ( ruleQualifiedName ) ) | 6622 | // InternalSolverLanguageParser.g:2566:5: otherlv_5= Comma ( ( ruleQualifiedName ) ) |
7462 | { | 6623 | { |
7463 | otherlv_5=(Token)match(input,28,FOLLOW_35); if (state.failed) return current; | 6624 | otherlv_5=(Token)match(input,Comma,FOLLOW_8); |
7464 | if ( state.backtracking==0 ) { | ||
7465 | 6625 | ||
7466 | newLeafNode(otherlv_5, grammarAccess.getClassDefinitionAccess().getCommaKeyword_3_2_0()); | 6626 | newLeafNode(otherlv_5, grammarAccess.getClassDefinitionAccess().getCommaKeyword_3_2_0()); |
7467 | 6627 | ||
7468 | } | 6628 | // InternalSolverLanguageParser.g:2570:5: ( ( ruleQualifiedName ) ) |
7469 | // InternalSolverLanguage.g:2603:5: ( ( ruleQualifiedName ) ) | 6629 | // InternalSolverLanguageParser.g:2571:6: ( ruleQualifiedName ) |
7470 | // InternalSolverLanguage.g:2604:6: ( ruleQualifiedName ) | ||
7471 | { | 6630 | { |
7472 | // InternalSolverLanguage.g:2604:6: ( ruleQualifiedName ) | 6631 | // InternalSolverLanguageParser.g:2571:6: ( ruleQualifiedName ) |
7473 | // InternalSolverLanguage.g:2605:7: ruleQualifiedName | 6632 | // InternalSolverLanguageParser.g:2572:7: ruleQualifiedName |
7474 | { | 6633 | { |
7475 | if ( state.backtracking==0 ) { | ||
7476 | 6634 | ||
7477 | if (current==null) { | 6635 | if (current==null) { |
7478 | current = createModelElement(grammarAccess.getClassDefinitionRule()); | 6636 | current = createModelElement(grammarAccess.getClassDefinitionRule()); |
7479 | } | 6637 | } |
7480 | 6638 | ||
7481 | } | ||
7482 | if ( state.backtracking==0 ) { | ||
7483 | 6639 | ||
7484 | newCompositeNode(grammarAccess.getClassDefinitionAccess().getSuperclassesNamedElementCrossReference_3_2_1_0()); | 6640 | newCompositeNode(grammarAccess.getClassDefinitionAccess().getSuperclassesNamedElementCrossReference_3_2_1_0()); |
7485 | 6641 | ||
7486 | } | 6642 | pushFollow(FOLLOW_40); |
7487 | pushFollow(FOLLOW_42); | ||
7488 | ruleQualifiedName(); | 6643 | ruleQualifiedName(); |
7489 | 6644 | ||
7490 | state._fsp--; | 6645 | state._fsp--; |
7491 | if (state.failed) return current; | ||
7492 | if ( state.backtracking==0 ) { | ||
7493 | 6646 | ||
7494 | afterParserOrEnumRuleCall(); | 6647 | |
7495 | 6648 | afterParserOrEnumRuleCall(); | |
7496 | } | 6649 | |
7497 | 6650 | ||
7498 | } | 6651 | } |
7499 | 6652 | ||
@@ -7505,7 +6658,7 @@ public class InternalSolverLanguageParser extends AbstractInternalAntlrParser { | |||
7505 | break; | 6658 | break; |
7506 | 6659 | ||
7507 | default : | 6660 | default : |
7508 | break loop28; | 6661 | break loop27; |
7509 | } | 6662 | } |
7510 | } while (true); | 6663 | } while (true); |
7511 | 6664 | ||
@@ -7515,53 +6668,47 @@ public class InternalSolverLanguageParser extends AbstractInternalAntlrParser { | |||
7515 | 6668 | ||
7516 | } | 6669 | } |
7517 | 6670 | ||
7518 | otherlv_7=(Token)match(input,30,FOLLOW_43); if (state.failed) return current; | 6671 | otherlv_7=(Token)match(input,LeftCurlyBracket,FOLLOW_41); |
7519 | if ( state.backtracking==0 ) { | ||
7520 | 6672 | ||
7521 | newLeafNode(otherlv_7, grammarAccess.getClassDefinitionAccess().getLeftCurlyBracketKeyword_4()); | 6673 | newLeafNode(otherlv_7, grammarAccess.getClassDefinitionAccess().getLeftCurlyBracketKeyword_4()); |
7522 | 6674 | ||
7523 | } | 6675 | // InternalSolverLanguageParser.g:2592:3: ( (lv_members_8_0= ruleMemberDefinition ) )* |
7524 | // InternalSolverLanguage.g:2625:3: ( (lv_members_8_0= ruleMemberDefinition ) )* | 6676 | loop29: |
7525 | loop30: | ||
7526 | do { | 6677 | do { |
7527 | int alt30=2; | 6678 | int alt29=2; |
7528 | int LA30_0 = input.LA(1); | 6679 | int LA29_0 = input.LA(1); |
7529 | 6680 | ||
7530 | if ( (LA30_0==RULE_ID||LA30_0==RULE_QUOTED_ID||LA30_0==44) ) { | 6681 | if ( (LA29_0==Contains||LA29_0==RULE_QUOTED_ID||LA29_0==RULE_ID) ) { |
7531 | alt30=1; | 6682 | alt29=1; |
7532 | } | 6683 | } |
7533 | 6684 | ||
7534 | 6685 | ||
7535 | switch (alt30) { | 6686 | switch (alt29) { |
7536 | case 1 : | 6687 | case 1 : |
7537 | // InternalSolverLanguage.g:2626:4: (lv_members_8_0= ruleMemberDefinition ) | 6688 | // InternalSolverLanguageParser.g:2593:4: (lv_members_8_0= ruleMemberDefinition ) |
7538 | { | 6689 | { |
7539 | // InternalSolverLanguage.g:2626:4: (lv_members_8_0= ruleMemberDefinition ) | 6690 | // InternalSolverLanguageParser.g:2593:4: (lv_members_8_0= ruleMemberDefinition ) |
7540 | // InternalSolverLanguage.g:2627:5: lv_members_8_0= ruleMemberDefinition | 6691 | // InternalSolverLanguageParser.g:2594:5: lv_members_8_0= ruleMemberDefinition |
7541 | { | 6692 | { |
7542 | if ( state.backtracking==0 ) { | ||
7543 | 6693 | ||
7544 | newCompositeNode(grammarAccess.getClassDefinitionAccess().getMembersMemberDefinitionParserRuleCall_5_0()); | 6694 | newCompositeNode(grammarAccess.getClassDefinitionAccess().getMembersMemberDefinitionParserRuleCall_5_0()); |
7545 | 6695 | ||
7546 | } | 6696 | pushFollow(FOLLOW_41); |
7547 | pushFollow(FOLLOW_43); | ||
7548 | lv_members_8_0=ruleMemberDefinition(); | 6697 | lv_members_8_0=ruleMemberDefinition(); |
7549 | 6698 | ||
7550 | state._fsp--; | 6699 | state._fsp--; |
7551 | if (state.failed) return current; | 6700 | |
7552 | if ( state.backtracking==0 ) { | 6701 | |
7553 | 6702 | if (current==null) { | |
7554 | if (current==null) { | 6703 | current = createModelElementForParent(grammarAccess.getClassDefinitionRule()); |
7555 | current = createModelElementForParent(grammarAccess.getClassDefinitionRule()); | 6704 | } |
7556 | } | 6705 | add( |
7557 | add( | 6706 | current, |
7558 | current, | 6707 | "members", |
7559 | "members", | 6708 | lv_members_8_0, |
7560 | lv_members_8_0, | 6709 | "org.eclipse.viatra.solver.language.SolverLanguage.MemberDefinition"); |
7561 | "org.eclipse.viatra.solver.language.SolverLanguage.MemberDefinition"); | 6710 | afterParserOrEnumRuleCall(); |
7562 | afterParserOrEnumRuleCall(); | 6711 | |
7563 | |||
7564 | } | ||
7565 | 6712 | ||
7566 | } | 6713 | } |
7567 | 6714 | ||
@@ -7570,27 +6717,23 @@ public class InternalSolverLanguageParser extends AbstractInternalAntlrParser { | |||
7570 | break; | 6717 | break; |
7571 | 6718 | ||
7572 | default : | 6719 | default : |
7573 | break loop30; | 6720 | break loop29; |
7574 | } | 6721 | } |
7575 | } while (true); | 6722 | } while (true); |
7576 | 6723 | ||
7577 | otherlv_9=(Token)match(input,31,FOLLOW_2); if (state.failed) return current; | 6724 | otherlv_9=(Token)match(input,RightCurlyBracket,FOLLOW_2); |
7578 | if ( state.backtracking==0 ) { | ||
7579 | 6725 | ||
7580 | newLeafNode(otherlv_9, grammarAccess.getClassDefinitionAccess().getRightCurlyBracketKeyword_6()); | 6726 | newLeafNode(otherlv_9, grammarAccess.getClassDefinitionAccess().getRightCurlyBracketKeyword_6()); |
7581 | 6727 | ||
7582 | } | ||
7583 | 6728 | ||
7584 | } | 6729 | } |
7585 | 6730 | ||
7586 | 6731 | ||
7587 | } | 6732 | } |
7588 | 6733 | ||
7589 | if ( state.backtracking==0 ) { | ||
7590 | 6734 | ||
7591 | leaveRule(); | 6735 | leaveRule(); |
7592 | 6736 | ||
7593 | } | ||
7594 | } | 6737 | } |
7595 | 6738 | ||
7596 | catch (RecognitionException re) { | 6739 | catch (RecognitionException re) { |
@@ -7605,7 +6748,7 @@ public class InternalSolverLanguageParser extends AbstractInternalAntlrParser { | |||
7605 | 6748 | ||
7606 | 6749 | ||
7607 | // $ANTLR start "entryRuleMemberDefinition" | 6750 | // $ANTLR start "entryRuleMemberDefinition" |
7608 | // InternalSolverLanguage.g:2652:1: entryRuleMemberDefinition returns [EObject current=null] : iv_ruleMemberDefinition= ruleMemberDefinition EOF ; | 6751 | // InternalSolverLanguageParser.g:2619:1: entryRuleMemberDefinition returns [EObject current=null] : iv_ruleMemberDefinition= ruleMemberDefinition EOF ; |
7609 | public final EObject entryRuleMemberDefinition() throws RecognitionException { | 6752 | public final EObject entryRuleMemberDefinition() throws RecognitionException { |
7610 | EObject current = null; | 6753 | EObject current = null; |
7611 | 6754 | ||
@@ -7613,21 +6756,17 @@ public class InternalSolverLanguageParser extends AbstractInternalAntlrParser { | |||
7613 | 6756 | ||
7614 | 6757 | ||
7615 | try { | 6758 | try { |
7616 | // InternalSolverLanguage.g:2652:57: (iv_ruleMemberDefinition= ruleMemberDefinition EOF ) | 6759 | // InternalSolverLanguageParser.g:2619:57: (iv_ruleMemberDefinition= ruleMemberDefinition EOF ) |
7617 | // InternalSolverLanguage.g:2653:2: iv_ruleMemberDefinition= ruleMemberDefinition EOF | 6760 | // InternalSolverLanguageParser.g:2620:2: iv_ruleMemberDefinition= ruleMemberDefinition EOF |
7618 | { | 6761 | { |
7619 | if ( state.backtracking==0 ) { | 6762 | newCompositeNode(grammarAccess.getMemberDefinitionRule()); |
7620 | newCompositeNode(grammarAccess.getMemberDefinitionRule()); | ||
7621 | } | ||
7622 | pushFollow(FOLLOW_1); | 6763 | pushFollow(FOLLOW_1); |
7623 | iv_ruleMemberDefinition=ruleMemberDefinition(); | 6764 | iv_ruleMemberDefinition=ruleMemberDefinition(); |
7624 | 6765 | ||
7625 | state._fsp--; | 6766 | state._fsp--; |
7626 | if (state.failed) return current; | 6767 | |
7627 | if ( state.backtracking==0 ) { | 6768 | current =iv_ruleMemberDefinition; |
7628 | current =iv_ruleMemberDefinition; | 6769 | match(input,EOF,FOLLOW_2); |
7629 | } | ||
7630 | match(input,EOF,FOLLOW_2); if (state.failed) return current; | ||
7631 | 6770 | ||
7632 | } | 6771 | } |
7633 | 6772 | ||
@@ -7645,7 +6784,7 @@ public class InternalSolverLanguageParser extends AbstractInternalAntlrParser { | |||
7645 | 6784 | ||
7646 | 6785 | ||
7647 | // $ANTLR start "ruleMemberDefinition" | 6786 | // $ANTLR start "ruleMemberDefinition" |
7648 | // InternalSolverLanguage.g:2659:1: ruleMemberDefinition returns [EObject current=null] : ( ( (lv_containment_0_0= 'contains' ) )? ( ( ruleQualifiedName ) ) ( (lv_multiplicity_2_0= ruleMultiplicity ) )? ( (lv_name_3_0= RULE_ID ) ) (otherlv_4= 'opposite' ( ( ruleQualifiedName ) ) )? (otherlv_6= ';' )? ) ; | 6787 | // InternalSolverLanguageParser.g:2626:1: ruleMemberDefinition returns [EObject current=null] : ( ( (lv_containment_0_0= Contains ) )? ( ( ruleQualifiedName ) ) ( (lv_multiplicity_2_0= ruleMultiplicity ) )? ( (lv_name_3_0= RULE_ID ) ) (otherlv_4= Opposite ( ( ruleQualifiedName ) ) )? (otherlv_6= Semicolon )? ) ; |
7649 | public final EObject ruleMemberDefinition() throws RecognitionException { | 6788 | public final EObject ruleMemberDefinition() throws RecognitionException { |
7650 | EObject current = null; | 6789 | EObject current = null; |
7651 | 6790 | ||
@@ -7660,40 +6799,36 @@ public class InternalSolverLanguageParser extends AbstractInternalAntlrParser { | |||
7660 | enterRule(); | 6799 | enterRule(); |
7661 | 6800 | ||
7662 | try { | 6801 | try { |
7663 | // InternalSolverLanguage.g:2665:2: ( ( ( (lv_containment_0_0= 'contains' ) )? ( ( ruleQualifiedName ) ) ( (lv_multiplicity_2_0= ruleMultiplicity ) )? ( (lv_name_3_0= RULE_ID ) ) (otherlv_4= 'opposite' ( ( ruleQualifiedName ) ) )? (otherlv_6= ';' )? ) ) | 6802 | // InternalSolverLanguageParser.g:2632:2: ( ( ( (lv_containment_0_0= Contains ) )? ( ( ruleQualifiedName ) ) ( (lv_multiplicity_2_0= ruleMultiplicity ) )? ( (lv_name_3_0= RULE_ID ) ) (otherlv_4= Opposite ( ( ruleQualifiedName ) ) )? (otherlv_6= Semicolon )? ) ) |
7664 | // InternalSolverLanguage.g:2666:2: ( ( (lv_containment_0_0= 'contains' ) )? ( ( ruleQualifiedName ) ) ( (lv_multiplicity_2_0= ruleMultiplicity ) )? ( (lv_name_3_0= RULE_ID ) ) (otherlv_4= 'opposite' ( ( ruleQualifiedName ) ) )? (otherlv_6= ';' )? ) | 6803 | // InternalSolverLanguageParser.g:2633:2: ( ( (lv_containment_0_0= Contains ) )? ( ( ruleQualifiedName ) ) ( (lv_multiplicity_2_0= ruleMultiplicity ) )? ( (lv_name_3_0= RULE_ID ) ) (otherlv_4= Opposite ( ( ruleQualifiedName ) ) )? (otherlv_6= Semicolon )? ) |
7665 | { | 6804 | { |
7666 | // InternalSolverLanguage.g:2666:2: ( ( (lv_containment_0_0= 'contains' ) )? ( ( ruleQualifiedName ) ) ( (lv_multiplicity_2_0= ruleMultiplicity ) )? ( (lv_name_3_0= RULE_ID ) ) (otherlv_4= 'opposite' ( ( ruleQualifiedName ) ) )? (otherlv_6= ';' )? ) | 6805 | // InternalSolverLanguageParser.g:2633:2: ( ( (lv_containment_0_0= Contains ) )? ( ( ruleQualifiedName ) ) ( (lv_multiplicity_2_0= ruleMultiplicity ) )? ( (lv_name_3_0= RULE_ID ) ) (otherlv_4= Opposite ( ( ruleQualifiedName ) ) )? (otherlv_6= Semicolon )? ) |
7667 | // InternalSolverLanguage.g:2667:3: ( (lv_containment_0_0= 'contains' ) )? ( ( ruleQualifiedName ) ) ( (lv_multiplicity_2_0= ruleMultiplicity ) )? ( (lv_name_3_0= RULE_ID ) ) (otherlv_4= 'opposite' ( ( ruleQualifiedName ) ) )? (otherlv_6= ';' )? | 6806 | // InternalSolverLanguageParser.g:2634:3: ( (lv_containment_0_0= Contains ) )? ( ( ruleQualifiedName ) ) ( (lv_multiplicity_2_0= ruleMultiplicity ) )? ( (lv_name_3_0= RULE_ID ) ) (otherlv_4= Opposite ( ( ruleQualifiedName ) ) )? (otherlv_6= Semicolon )? |
7668 | { | 6807 | { |
7669 | // InternalSolverLanguage.g:2667:3: ( (lv_containment_0_0= 'contains' ) )? | 6808 | // InternalSolverLanguageParser.g:2634:3: ( (lv_containment_0_0= Contains ) )? |
7670 | int alt31=2; | 6809 | int alt30=2; |
7671 | int LA31_0 = input.LA(1); | 6810 | int LA30_0 = input.LA(1); |
7672 | 6811 | ||
7673 | if ( (LA31_0==44) ) { | 6812 | if ( (LA30_0==Contains) ) { |
7674 | alt31=1; | 6813 | alt30=1; |
7675 | } | 6814 | } |
7676 | switch (alt31) { | 6815 | switch (alt30) { |
7677 | case 1 : | 6816 | case 1 : |
7678 | // InternalSolverLanguage.g:2668:4: (lv_containment_0_0= 'contains' ) | 6817 | // InternalSolverLanguageParser.g:2635:4: (lv_containment_0_0= Contains ) |
7679 | { | 6818 | { |
7680 | // InternalSolverLanguage.g:2668:4: (lv_containment_0_0= 'contains' ) | 6819 | // InternalSolverLanguageParser.g:2635:4: (lv_containment_0_0= Contains ) |
7681 | // InternalSolverLanguage.g:2669:5: lv_containment_0_0= 'contains' | 6820 | // InternalSolverLanguageParser.g:2636:5: lv_containment_0_0= Contains |
7682 | { | 6821 | { |
7683 | lv_containment_0_0=(Token)match(input,44,FOLLOW_35); if (state.failed) return current; | 6822 | lv_containment_0_0=(Token)match(input,Contains,FOLLOW_8); |
7684 | if ( state.backtracking==0 ) { | ||
7685 | 6823 | ||
7686 | newLeafNode(lv_containment_0_0, grammarAccess.getMemberDefinitionAccess().getContainmentContainsKeyword_0_0()); | 6824 | newLeafNode(lv_containment_0_0, grammarAccess.getMemberDefinitionAccess().getContainmentContainsKeyword_0_0()); |
7687 | 6825 | ||
7688 | } | ||
7689 | if ( state.backtracking==0 ) { | ||
7690 | 6826 | ||
7691 | if (current==null) { | 6827 | if (current==null) { |
7692 | current = createModelElement(grammarAccess.getMemberDefinitionRule()); | 6828 | current = createModelElement(grammarAccess.getMemberDefinitionRule()); |
7693 | } | 6829 | } |
7694 | setWithLastConsumed(current, "containment", true, "contains"); | 6830 | setWithLastConsumed(current, "containment", true, "contains"); |
7695 | 6831 | ||
7696 | } | ||
7697 | 6832 | ||
7698 | } | 6833 | } |
7699 | 6834 | ||
@@ -7703,77 +6838,67 @@ public class InternalSolverLanguageParser extends AbstractInternalAntlrParser { | |||
7703 | 6838 | ||
7704 | } | 6839 | } |
7705 | 6840 | ||
7706 | // InternalSolverLanguage.g:2681:3: ( ( ruleQualifiedName ) ) | 6841 | // InternalSolverLanguageParser.g:2648:3: ( ( ruleQualifiedName ) ) |
7707 | // InternalSolverLanguage.g:2682:4: ( ruleQualifiedName ) | 6842 | // InternalSolverLanguageParser.g:2649:4: ( ruleQualifiedName ) |
7708 | { | 6843 | { |
7709 | // InternalSolverLanguage.g:2682:4: ( ruleQualifiedName ) | 6844 | // InternalSolverLanguageParser.g:2649:4: ( ruleQualifiedName ) |
7710 | // InternalSolverLanguage.g:2683:5: ruleQualifiedName | 6845 | // InternalSolverLanguageParser.g:2650:5: ruleQualifiedName |
7711 | { | 6846 | { |
7712 | if ( state.backtracking==0 ) { | ||
7713 | 6847 | ||
7714 | if (current==null) { | 6848 | if (current==null) { |
7715 | current = createModelElement(grammarAccess.getMemberDefinitionRule()); | 6849 | current = createModelElement(grammarAccess.getMemberDefinitionRule()); |
7716 | } | 6850 | } |
7717 | 6851 | ||
7718 | } | ||
7719 | if ( state.backtracking==0 ) { | ||
7720 | 6852 | ||
7721 | newCompositeNode(grammarAccess.getMemberDefinitionAccess().getTypeNamedElementCrossReference_1_0()); | 6853 | newCompositeNode(grammarAccess.getMemberDefinitionAccess().getTypeNamedElementCrossReference_1_0()); |
7722 | 6854 | ||
7723 | } | 6855 | pushFollow(FOLLOW_42); |
7724 | pushFollow(FOLLOW_44); | ||
7725 | ruleQualifiedName(); | 6856 | ruleQualifiedName(); |
7726 | 6857 | ||
7727 | state._fsp--; | 6858 | state._fsp--; |
7728 | if (state.failed) return current; | ||
7729 | if ( state.backtracking==0 ) { | ||
7730 | 6859 | ||
7731 | afterParserOrEnumRuleCall(); | 6860 | |
7732 | 6861 | afterParserOrEnumRuleCall(); | |
7733 | } | 6862 | |
7734 | 6863 | ||
7735 | } | 6864 | } |
7736 | 6865 | ||
7737 | 6866 | ||
7738 | } | 6867 | } |
7739 | 6868 | ||
7740 | // InternalSolverLanguage.g:2697:3: ( (lv_multiplicity_2_0= ruleMultiplicity ) )? | 6869 | // InternalSolverLanguageParser.g:2664:3: ( (lv_multiplicity_2_0= ruleMultiplicity ) )? |
7741 | int alt32=2; | 6870 | int alt31=2; |
7742 | int LA32_0 = input.LA(1); | 6871 | int LA31_0 = input.LA(1); |
7743 | 6872 | ||
7744 | if ( (LA32_0==36) ) { | 6873 | if ( (LA31_0==LeftSquareBracket) ) { |
7745 | alt32=1; | 6874 | alt31=1; |
7746 | } | 6875 | } |
7747 | switch (alt32) { | 6876 | switch (alt31) { |
7748 | case 1 : | 6877 | case 1 : |
7749 | // InternalSolverLanguage.g:2698:4: (lv_multiplicity_2_0= ruleMultiplicity ) | 6878 | // InternalSolverLanguageParser.g:2665:4: (lv_multiplicity_2_0= ruleMultiplicity ) |
7750 | { | 6879 | { |
7751 | // InternalSolverLanguage.g:2698:4: (lv_multiplicity_2_0= ruleMultiplicity ) | 6880 | // InternalSolverLanguageParser.g:2665:4: (lv_multiplicity_2_0= ruleMultiplicity ) |
7752 | // InternalSolverLanguage.g:2699:5: lv_multiplicity_2_0= ruleMultiplicity | 6881 | // InternalSolverLanguageParser.g:2666:5: lv_multiplicity_2_0= ruleMultiplicity |
7753 | { | 6882 | { |
7754 | if ( state.backtracking==0 ) { | ||
7755 | 6883 | ||
7756 | newCompositeNode(grammarAccess.getMemberDefinitionAccess().getMultiplicityMultiplicityParserRuleCall_2_0()); | 6884 | newCompositeNode(grammarAccess.getMemberDefinitionAccess().getMultiplicityMultiplicityParserRuleCall_2_0()); |
7757 | 6885 | ||
7758 | } | 6886 | pushFollow(FOLLOW_38); |
7759 | pushFollow(FOLLOW_40); | ||
7760 | lv_multiplicity_2_0=ruleMultiplicity(); | 6887 | lv_multiplicity_2_0=ruleMultiplicity(); |
7761 | 6888 | ||
7762 | state._fsp--; | 6889 | state._fsp--; |
7763 | if (state.failed) return current; | ||
7764 | if ( state.backtracking==0 ) { | ||
7765 | 6890 | ||
7766 | if (current==null) { | 6891 | |
7767 | current = createModelElementForParent(grammarAccess.getMemberDefinitionRule()); | 6892 | if (current==null) { |
7768 | } | 6893 | current = createModelElementForParent(grammarAccess.getMemberDefinitionRule()); |
7769 | set( | 6894 | } |
7770 | current, | 6895 | set( |
7771 | "multiplicity", | 6896 | current, |
7772 | lv_multiplicity_2_0, | 6897 | "multiplicity", |
7773 | "org.eclipse.viatra.solver.language.SolverLanguage.Multiplicity"); | 6898 | lv_multiplicity_2_0, |
7774 | afterParserOrEnumRuleCall(); | 6899 | "org.eclipse.viatra.solver.language.SolverLanguage.Multiplicity"); |
7775 | 6900 | afterParserOrEnumRuleCall(); | |
7776 | } | 6901 | |
7777 | 6902 | ||
7778 | } | 6903 | } |
7779 | 6904 | ||
@@ -7783,81 +6908,69 @@ public class InternalSolverLanguageParser extends AbstractInternalAntlrParser { | |||
7783 | 6908 | ||
7784 | } | 6909 | } |
7785 | 6910 | ||
7786 | // InternalSolverLanguage.g:2716:3: ( (lv_name_3_0= RULE_ID ) ) | 6911 | // InternalSolverLanguageParser.g:2683:3: ( (lv_name_3_0= RULE_ID ) ) |
7787 | // InternalSolverLanguage.g:2717:4: (lv_name_3_0= RULE_ID ) | 6912 | // InternalSolverLanguageParser.g:2684:4: (lv_name_3_0= RULE_ID ) |
7788 | { | 6913 | { |
7789 | // InternalSolverLanguage.g:2717:4: (lv_name_3_0= RULE_ID ) | 6914 | // InternalSolverLanguageParser.g:2684:4: (lv_name_3_0= RULE_ID ) |
7790 | // InternalSolverLanguage.g:2718:5: lv_name_3_0= RULE_ID | 6915 | // InternalSolverLanguageParser.g:2685:5: lv_name_3_0= RULE_ID |
7791 | { | 6916 | { |
7792 | lv_name_3_0=(Token)match(input,RULE_ID,FOLLOW_45); if (state.failed) return current; | 6917 | lv_name_3_0=(Token)match(input,RULE_ID,FOLLOW_43); |
7793 | if ( state.backtracking==0 ) { | ||
7794 | 6918 | ||
7795 | newLeafNode(lv_name_3_0, grammarAccess.getMemberDefinitionAccess().getNameIDTerminalRuleCall_3_0()); | 6919 | newLeafNode(lv_name_3_0, grammarAccess.getMemberDefinitionAccess().getNameIDTerminalRuleCall_3_0()); |
7796 | 6920 | ||
7797 | } | ||
7798 | if ( state.backtracking==0 ) { | ||
7799 | 6921 | ||
7800 | if (current==null) { | 6922 | if (current==null) { |
7801 | current = createModelElement(grammarAccess.getMemberDefinitionRule()); | 6923 | current = createModelElement(grammarAccess.getMemberDefinitionRule()); |
7802 | } | 6924 | } |
7803 | setWithLastConsumed( | 6925 | setWithLastConsumed( |
7804 | current, | 6926 | current, |
7805 | "name", | 6927 | "name", |
7806 | lv_name_3_0, | 6928 | lv_name_3_0, |
7807 | "org.eclipse.xtext.common.Terminals.ID"); | 6929 | "org.eclipse.xtext.common.Terminals.ID"); |
7808 | 6930 | ||
7809 | } | ||
7810 | 6931 | ||
7811 | } | 6932 | } |
7812 | 6933 | ||
7813 | 6934 | ||
7814 | } | 6935 | } |
7815 | 6936 | ||
7816 | // InternalSolverLanguage.g:2734:3: (otherlv_4= 'opposite' ( ( ruleQualifiedName ) ) )? | 6937 | // InternalSolverLanguageParser.g:2701:3: (otherlv_4= Opposite ( ( ruleQualifiedName ) ) )? |
7817 | int alt33=2; | 6938 | int alt32=2; |
7818 | int LA33_0 = input.LA(1); | 6939 | int LA32_0 = input.LA(1); |
7819 | 6940 | ||
7820 | if ( (LA33_0==45) ) { | 6941 | if ( (LA32_0==Opposite) ) { |
7821 | alt33=1; | 6942 | alt32=1; |
7822 | } | 6943 | } |
7823 | switch (alt33) { | 6944 | switch (alt32) { |
7824 | case 1 : | 6945 | case 1 : |
7825 | // InternalSolverLanguage.g:2735:4: otherlv_4= 'opposite' ( ( ruleQualifiedName ) ) | 6946 | // InternalSolverLanguageParser.g:2702:4: otherlv_4= Opposite ( ( ruleQualifiedName ) ) |
7826 | { | 6947 | { |
7827 | otherlv_4=(Token)match(input,45,FOLLOW_35); if (state.failed) return current; | 6948 | otherlv_4=(Token)match(input,Opposite,FOLLOW_8); |
7828 | if ( state.backtracking==0 ) { | ||
7829 | 6949 | ||
7830 | newLeafNode(otherlv_4, grammarAccess.getMemberDefinitionAccess().getOppositeKeyword_4_0()); | 6950 | newLeafNode(otherlv_4, grammarAccess.getMemberDefinitionAccess().getOppositeKeyword_4_0()); |
7831 | 6951 | ||
7832 | } | 6952 | // InternalSolverLanguageParser.g:2706:4: ( ( ruleQualifiedName ) ) |
7833 | // InternalSolverLanguage.g:2739:4: ( ( ruleQualifiedName ) ) | 6953 | // InternalSolverLanguageParser.g:2707:5: ( ruleQualifiedName ) |
7834 | // InternalSolverLanguage.g:2740:5: ( ruleQualifiedName ) | ||
7835 | { | 6954 | { |
7836 | // InternalSolverLanguage.g:2740:5: ( ruleQualifiedName ) | 6955 | // InternalSolverLanguageParser.g:2707:5: ( ruleQualifiedName ) |
7837 | // InternalSolverLanguage.g:2741:6: ruleQualifiedName | 6956 | // InternalSolverLanguageParser.g:2708:6: ruleQualifiedName |
7838 | { | 6957 | { |
7839 | if ( state.backtracking==0 ) { | ||
7840 | 6958 | ||
7841 | if (current==null) { | 6959 | if (current==null) { |
7842 | current = createModelElement(grammarAccess.getMemberDefinitionRule()); | 6960 | current = createModelElement(grammarAccess.getMemberDefinitionRule()); |
7843 | } | 6961 | } |
7844 | 6962 | ||
7845 | } | ||
7846 | if ( state.backtracking==0 ) { | ||
7847 | 6963 | ||
7848 | newCompositeNode(grammarAccess.getMemberDefinitionAccess().getOppositeNamedElementCrossReference_4_1_0()); | 6964 | newCompositeNode(grammarAccess.getMemberDefinitionAccess().getOppositeNamedElementCrossReference_4_1_0()); |
7849 | 6965 | ||
7850 | } | ||
7851 | pushFollow(FOLLOW_18); | 6966 | pushFollow(FOLLOW_18); |
7852 | ruleQualifiedName(); | 6967 | ruleQualifiedName(); |
7853 | 6968 | ||
7854 | state._fsp--; | 6969 | state._fsp--; |
7855 | if (state.failed) return current; | ||
7856 | if ( state.backtracking==0 ) { | ||
7857 | 6970 | ||
7858 | afterParserOrEnumRuleCall(); | 6971 | |
7859 | 6972 | afterParserOrEnumRuleCall(); | |
7860 | } | 6973 | |
7861 | 6974 | ||
7862 | } | 6975 | } |
7863 | 6976 | ||
@@ -7870,23 +6983,21 @@ public class InternalSolverLanguageParser extends AbstractInternalAntlrParser { | |||
7870 | 6983 | ||
7871 | } | 6984 | } |
7872 | 6985 | ||
7873 | // InternalSolverLanguage.g:2756:3: (otherlv_6= ';' )? | 6986 | // InternalSolverLanguageParser.g:2723:3: (otherlv_6= Semicolon )? |
7874 | int alt34=2; | 6987 | int alt33=2; |
7875 | int LA34_0 = input.LA(1); | 6988 | int LA33_0 = input.LA(1); |
7876 | 6989 | ||
7877 | if ( (LA34_0==26) ) { | 6990 | if ( (LA33_0==Semicolon) ) { |
7878 | alt34=1; | 6991 | alt33=1; |
7879 | } | 6992 | } |
7880 | switch (alt34) { | 6993 | switch (alt33) { |
7881 | case 1 : | 6994 | case 1 : |
7882 | // InternalSolverLanguage.g:2757:4: otherlv_6= ';' | 6995 | // InternalSolverLanguageParser.g:2724:4: otherlv_6= Semicolon |
7883 | { | 6996 | { |
7884 | otherlv_6=(Token)match(input,26,FOLLOW_2); if (state.failed) return current; | 6997 | otherlv_6=(Token)match(input,Semicolon,FOLLOW_2); |
7885 | if ( state.backtracking==0 ) { | ||
7886 | 6998 | ||
7887 | newLeafNode(otherlv_6, grammarAccess.getMemberDefinitionAccess().getSemicolonKeyword_5()); | 6999 | newLeafNode(otherlv_6, grammarAccess.getMemberDefinitionAccess().getSemicolonKeyword_5()); |
7888 | 7000 | ||
7889 | } | ||
7890 | 7001 | ||
7891 | } | 7002 | } |
7892 | break; | 7003 | break; |
@@ -7899,11 +7010,9 @@ public class InternalSolverLanguageParser extends AbstractInternalAntlrParser { | |||
7899 | 7010 | ||
7900 | } | 7011 | } |
7901 | 7012 | ||
7902 | if ( state.backtracking==0 ) { | ||
7903 | 7013 | ||
7904 | leaveRule(); | 7014 | leaveRule(); |
7905 | 7015 | ||
7906 | } | ||
7907 | } | 7016 | } |
7908 | 7017 | ||
7909 | catch (RecognitionException re) { | 7018 | catch (RecognitionException re) { |
@@ -7918,7 +7027,7 @@ public class InternalSolverLanguageParser extends AbstractInternalAntlrParser { | |||
7918 | 7027 | ||
7919 | 7028 | ||
7920 | // $ANTLR start "entryRuleMultiplicity" | 7029 | // $ANTLR start "entryRuleMultiplicity" |
7921 | // InternalSolverLanguage.g:2766:1: entryRuleMultiplicity returns [EObject current=null] : iv_ruleMultiplicity= ruleMultiplicity EOF ; | 7030 | // InternalSolverLanguageParser.g:2733:1: entryRuleMultiplicity returns [EObject current=null] : iv_ruleMultiplicity= ruleMultiplicity EOF ; |
7922 | public final EObject entryRuleMultiplicity() throws RecognitionException { | 7031 | public final EObject entryRuleMultiplicity() throws RecognitionException { |
7923 | EObject current = null; | 7032 | EObject current = null; |
7924 | 7033 | ||
@@ -7926,21 +7035,17 @@ public class InternalSolverLanguageParser extends AbstractInternalAntlrParser { | |||
7926 | 7035 | ||
7927 | 7036 | ||
7928 | try { | 7037 | try { |
7929 | // InternalSolverLanguage.g:2766:53: (iv_ruleMultiplicity= ruleMultiplicity EOF ) | 7038 | // InternalSolverLanguageParser.g:2733:53: (iv_ruleMultiplicity= ruleMultiplicity EOF ) |
7930 | // InternalSolverLanguage.g:2767:2: iv_ruleMultiplicity= ruleMultiplicity EOF | 7039 | // InternalSolverLanguageParser.g:2734:2: iv_ruleMultiplicity= ruleMultiplicity EOF |
7931 | { | 7040 | { |
7932 | if ( state.backtracking==0 ) { | 7041 | newCompositeNode(grammarAccess.getMultiplicityRule()); |
7933 | newCompositeNode(grammarAccess.getMultiplicityRule()); | ||
7934 | } | ||
7935 | pushFollow(FOLLOW_1); | 7042 | pushFollow(FOLLOW_1); |
7936 | iv_ruleMultiplicity=ruleMultiplicity(); | 7043 | iv_ruleMultiplicity=ruleMultiplicity(); |
7937 | 7044 | ||
7938 | state._fsp--; | 7045 | state._fsp--; |
7939 | if (state.failed) return current; | 7046 | |
7940 | if ( state.backtracking==0 ) { | 7047 | current =iv_ruleMultiplicity; |
7941 | current =iv_ruleMultiplicity; | 7048 | match(input,EOF,FOLLOW_2); |
7942 | } | ||
7943 | match(input,EOF,FOLLOW_2); if (state.failed) return current; | ||
7944 | 7049 | ||
7945 | } | 7050 | } |
7946 | 7051 | ||
@@ -7958,7 +7063,7 @@ public class InternalSolverLanguageParser extends AbstractInternalAntlrParser { | |||
7958 | 7063 | ||
7959 | 7064 | ||
7960 | // $ANTLR start "ruleMultiplicity" | 7065 | // $ANTLR start "ruleMultiplicity" |
7961 | // InternalSolverLanguage.g:2773:1: ruleMultiplicity returns [EObject current=null] : (this_ManyMultiplicity_0= ruleManyMultiplicity | this_ExactMultiplicity_1= ruleExactMultiplicity | this_BoundedMultiplicity_2= ruleBoundedMultiplicity ) ; | 7066 | // InternalSolverLanguageParser.g:2740:1: ruleMultiplicity returns [EObject current=null] : (this_ManyMultiplicity_0= ruleManyMultiplicity | this_ExactMultiplicity_1= ruleExactMultiplicity | this_BoundedMultiplicity_2= ruleBoundedMultiplicity ) ; |
7962 | public final EObject ruleMultiplicity() throws RecognitionException { | 7067 | public final EObject ruleMultiplicity() throws RecognitionException { |
7963 | EObject current = null; | 7068 | EObject current = null; |
7964 | 7069 | ||
@@ -7973,124 +7078,109 @@ public class InternalSolverLanguageParser extends AbstractInternalAntlrParser { | |||
7973 | enterRule(); | 7078 | enterRule(); |
7974 | 7079 | ||
7975 | try { | 7080 | try { |
7976 | // InternalSolverLanguage.g:2779:2: ( (this_ManyMultiplicity_0= ruleManyMultiplicity | this_ExactMultiplicity_1= ruleExactMultiplicity | this_BoundedMultiplicity_2= ruleBoundedMultiplicity ) ) | 7081 | // InternalSolverLanguageParser.g:2746:2: ( (this_ManyMultiplicity_0= ruleManyMultiplicity | this_ExactMultiplicity_1= ruleExactMultiplicity | this_BoundedMultiplicity_2= ruleBoundedMultiplicity ) ) |
7977 | // InternalSolverLanguage.g:2780:2: (this_ManyMultiplicity_0= ruleManyMultiplicity | this_ExactMultiplicity_1= ruleExactMultiplicity | this_BoundedMultiplicity_2= ruleBoundedMultiplicity ) | 7082 | // InternalSolverLanguageParser.g:2747:2: (this_ManyMultiplicity_0= ruleManyMultiplicity | this_ExactMultiplicity_1= ruleExactMultiplicity | this_BoundedMultiplicity_2= ruleBoundedMultiplicity ) |
7978 | { | 7083 | { |
7979 | // InternalSolverLanguage.g:2780:2: (this_ManyMultiplicity_0= ruleManyMultiplicity | this_ExactMultiplicity_1= ruleExactMultiplicity | this_BoundedMultiplicity_2= ruleBoundedMultiplicity ) | 7084 | // InternalSolverLanguageParser.g:2747:2: (this_ManyMultiplicity_0= ruleManyMultiplicity | this_ExactMultiplicity_1= ruleExactMultiplicity | this_BoundedMultiplicity_2= ruleBoundedMultiplicity ) |
7980 | int alt35=3; | 7085 | int alt34=3; |
7981 | int LA35_0 = input.LA(1); | 7086 | int LA34_0 = input.LA(1); |
7982 | 7087 | ||
7983 | if ( (LA35_0==36) ) { | 7088 | if ( (LA34_0==LeftSquareBracket) ) { |
7984 | switch ( input.LA(2) ) { | 7089 | switch ( input.LA(2) ) { |
7985 | case RULE_INT: | 7090 | case RULE_INT: |
7986 | { | 7091 | { |
7987 | int LA35_2 = input.LA(3); | 7092 | int LA34_2 = input.LA(3); |
7988 | 7093 | ||
7989 | if ( (LA35_2==38) ) { | 7094 | if ( (LA34_2==FullStopFullStop) ) { |
7990 | alt35=2; | 7095 | alt34=3; |
7991 | } | 7096 | } |
7992 | else if ( (LA35_2==37) ) { | 7097 | else if ( (LA34_2==RightSquareBracket) ) { |
7993 | alt35=3; | 7098 | alt34=2; |
7994 | } | 7099 | } |
7995 | else { | 7100 | else { |
7996 | if (state.backtracking>0) {state.failed=true; return current;} | ||
7997 | NoViableAltException nvae = | 7101 | NoViableAltException nvae = |
7998 | new NoViableAltException("", 35, 2, input); | 7102 | new NoViableAltException("", 34, 2, input); |
7999 | 7103 | ||
8000 | throw nvae; | 7104 | throw nvae; |
8001 | } | 7105 | } |
8002 | } | 7106 | } |
8003 | break; | 7107 | break; |
8004 | case 35: | 7108 | case Asterisk: |
8005 | { | 7109 | { |
8006 | alt35=2; | 7110 | alt34=2; |
8007 | } | 7111 | } |
8008 | break; | 7112 | break; |
8009 | case 38: | 7113 | case RightSquareBracket: |
8010 | { | 7114 | { |
8011 | alt35=1; | 7115 | alt34=1; |
8012 | } | 7116 | } |
8013 | break; | 7117 | break; |
8014 | default: | 7118 | default: |
8015 | if (state.backtracking>0) {state.failed=true; return current;} | ||
8016 | NoViableAltException nvae = | 7119 | NoViableAltException nvae = |
8017 | new NoViableAltException("", 35, 1, input); | 7120 | new NoViableAltException("", 34, 1, input); |
8018 | 7121 | ||
8019 | throw nvae; | 7122 | throw nvae; |
8020 | } | 7123 | } |
8021 | 7124 | ||
8022 | } | 7125 | } |
8023 | else { | 7126 | else { |
8024 | if (state.backtracking>0) {state.failed=true; return current;} | ||
8025 | NoViableAltException nvae = | 7127 | NoViableAltException nvae = |
8026 | new NoViableAltException("", 35, 0, input); | 7128 | new NoViableAltException("", 34, 0, input); |
8027 | 7129 | ||
8028 | throw nvae; | 7130 | throw nvae; |
8029 | } | 7131 | } |
8030 | switch (alt35) { | 7132 | switch (alt34) { |
8031 | case 1 : | 7133 | case 1 : |
8032 | // InternalSolverLanguage.g:2781:3: this_ManyMultiplicity_0= ruleManyMultiplicity | 7134 | // InternalSolverLanguageParser.g:2748:3: this_ManyMultiplicity_0= ruleManyMultiplicity |
8033 | { | 7135 | { |
8034 | if ( state.backtracking==0 ) { | ||
8035 | 7136 | ||
8036 | newCompositeNode(grammarAccess.getMultiplicityAccess().getManyMultiplicityParserRuleCall_0()); | 7137 | newCompositeNode(grammarAccess.getMultiplicityAccess().getManyMultiplicityParserRuleCall_0()); |
8037 | 7138 | ||
8038 | } | ||
8039 | pushFollow(FOLLOW_2); | 7139 | pushFollow(FOLLOW_2); |
8040 | this_ManyMultiplicity_0=ruleManyMultiplicity(); | 7140 | this_ManyMultiplicity_0=ruleManyMultiplicity(); |
8041 | 7141 | ||
8042 | state._fsp--; | 7142 | state._fsp--; |
8043 | if (state.failed) return current; | ||
8044 | if ( state.backtracking==0 ) { | ||
8045 | 7143 | ||
8046 | current = this_ManyMultiplicity_0; | 7144 | |
8047 | afterParserOrEnumRuleCall(); | 7145 | current = this_ManyMultiplicity_0; |
8048 | 7146 | afterParserOrEnumRuleCall(); | |
8049 | } | 7147 | |
8050 | 7148 | ||
8051 | } | 7149 | } |
8052 | break; | 7150 | break; |
8053 | case 2 : | 7151 | case 2 : |
8054 | // InternalSolverLanguage.g:2790:3: this_ExactMultiplicity_1= ruleExactMultiplicity | 7152 | // InternalSolverLanguageParser.g:2757:3: this_ExactMultiplicity_1= ruleExactMultiplicity |
8055 | { | 7153 | { |
8056 | if ( state.backtracking==0 ) { | ||
8057 | 7154 | ||
8058 | newCompositeNode(grammarAccess.getMultiplicityAccess().getExactMultiplicityParserRuleCall_1()); | 7155 | newCompositeNode(grammarAccess.getMultiplicityAccess().getExactMultiplicityParserRuleCall_1()); |
8059 | 7156 | ||
8060 | } | ||
8061 | pushFollow(FOLLOW_2); | 7157 | pushFollow(FOLLOW_2); |
8062 | this_ExactMultiplicity_1=ruleExactMultiplicity(); | 7158 | this_ExactMultiplicity_1=ruleExactMultiplicity(); |
8063 | 7159 | ||
8064 | state._fsp--; | 7160 | state._fsp--; |
8065 | if (state.failed) return current; | ||
8066 | if ( state.backtracking==0 ) { | ||
8067 | 7161 | ||
8068 | current = this_ExactMultiplicity_1; | 7162 | |
8069 | afterParserOrEnumRuleCall(); | 7163 | current = this_ExactMultiplicity_1; |
8070 | 7164 | afterParserOrEnumRuleCall(); | |
8071 | } | 7165 | |
8072 | 7166 | ||
8073 | } | 7167 | } |
8074 | break; | 7168 | break; |
8075 | case 3 : | 7169 | case 3 : |
8076 | // InternalSolverLanguage.g:2799:3: this_BoundedMultiplicity_2= ruleBoundedMultiplicity | 7170 | // InternalSolverLanguageParser.g:2766:3: this_BoundedMultiplicity_2= ruleBoundedMultiplicity |
8077 | { | 7171 | { |
8078 | if ( state.backtracking==0 ) { | ||
8079 | 7172 | ||
8080 | newCompositeNode(grammarAccess.getMultiplicityAccess().getBoundedMultiplicityParserRuleCall_2()); | 7173 | newCompositeNode(grammarAccess.getMultiplicityAccess().getBoundedMultiplicityParserRuleCall_2()); |
8081 | 7174 | ||
8082 | } | ||
8083 | pushFollow(FOLLOW_2); | 7175 | pushFollow(FOLLOW_2); |
8084 | this_BoundedMultiplicity_2=ruleBoundedMultiplicity(); | 7176 | this_BoundedMultiplicity_2=ruleBoundedMultiplicity(); |
8085 | 7177 | ||
8086 | state._fsp--; | 7178 | state._fsp--; |
8087 | if (state.failed) return current; | ||
8088 | if ( state.backtracking==0 ) { | ||
8089 | 7179 | ||
8090 | current = this_BoundedMultiplicity_2; | 7180 | |
8091 | afterParserOrEnumRuleCall(); | 7181 | current = this_BoundedMultiplicity_2; |
8092 | 7182 | afterParserOrEnumRuleCall(); | |
8093 | } | 7183 | |
8094 | 7184 | ||
8095 | } | 7185 | } |
8096 | break; | 7186 | break; |
@@ -8100,11 +7190,9 @@ public class InternalSolverLanguageParser extends AbstractInternalAntlrParser { | |||
8100 | 7190 | ||
8101 | } | 7191 | } |
8102 | 7192 | ||
8103 | if ( state.backtracking==0 ) { | ||
8104 | 7193 | ||
8105 | leaveRule(); | 7194 | leaveRule(); |
8106 | 7195 | ||
8107 | } | ||
8108 | } | 7196 | } |
8109 | 7197 | ||
8110 | catch (RecognitionException re) { | 7198 | catch (RecognitionException re) { |
@@ -8119,7 +7207,7 @@ public class InternalSolverLanguageParser extends AbstractInternalAntlrParser { | |||
8119 | 7207 | ||
8120 | 7208 | ||
8121 | // $ANTLR start "entryRuleManyMultiplicity" | 7209 | // $ANTLR start "entryRuleManyMultiplicity" |
8122 | // InternalSolverLanguage.g:2811:1: entryRuleManyMultiplicity returns [EObject current=null] : iv_ruleManyMultiplicity= ruleManyMultiplicity EOF ; | 7210 | // InternalSolverLanguageParser.g:2778:1: entryRuleManyMultiplicity returns [EObject current=null] : iv_ruleManyMultiplicity= ruleManyMultiplicity EOF ; |
8123 | public final EObject entryRuleManyMultiplicity() throws RecognitionException { | 7211 | public final EObject entryRuleManyMultiplicity() throws RecognitionException { |
8124 | EObject current = null; | 7212 | EObject current = null; |
8125 | 7213 | ||
@@ -8127,21 +7215,17 @@ public class InternalSolverLanguageParser extends AbstractInternalAntlrParser { | |||
8127 | 7215 | ||
8128 | 7216 | ||
8129 | try { | 7217 | try { |
8130 | // InternalSolverLanguage.g:2811:57: (iv_ruleManyMultiplicity= ruleManyMultiplicity EOF ) | 7218 | // InternalSolverLanguageParser.g:2778:57: (iv_ruleManyMultiplicity= ruleManyMultiplicity EOF ) |
8131 | // InternalSolverLanguage.g:2812:2: iv_ruleManyMultiplicity= ruleManyMultiplicity EOF | 7219 | // InternalSolverLanguageParser.g:2779:2: iv_ruleManyMultiplicity= ruleManyMultiplicity EOF |
8132 | { | 7220 | { |
8133 | if ( state.backtracking==0 ) { | 7221 | newCompositeNode(grammarAccess.getManyMultiplicityRule()); |
8134 | newCompositeNode(grammarAccess.getManyMultiplicityRule()); | ||
8135 | } | ||
8136 | pushFollow(FOLLOW_1); | 7222 | pushFollow(FOLLOW_1); |
8137 | iv_ruleManyMultiplicity=ruleManyMultiplicity(); | 7223 | iv_ruleManyMultiplicity=ruleManyMultiplicity(); |
8138 | 7224 | ||
8139 | state._fsp--; | 7225 | state._fsp--; |
8140 | if (state.failed) return current; | 7226 | |
8141 | if ( state.backtracking==0 ) { | 7227 | current =iv_ruleManyMultiplicity; |
8142 | current =iv_ruleManyMultiplicity; | 7228 | match(input,EOF,FOLLOW_2); |
8143 | } | ||
8144 | match(input,EOF,FOLLOW_2); if (state.failed) return current; | ||
8145 | 7229 | ||
8146 | } | 7230 | } |
8147 | 7231 | ||
@@ -8159,7 +7243,7 @@ public class InternalSolverLanguageParser extends AbstractInternalAntlrParser { | |||
8159 | 7243 | ||
8160 | 7244 | ||
8161 | // $ANTLR start "ruleManyMultiplicity" | 7245 | // $ANTLR start "ruleManyMultiplicity" |
8162 | // InternalSolverLanguage.g:2818:1: ruleManyMultiplicity returns [EObject current=null] : ( () otherlv_1= '[' otherlv_2= ']' ) ; | 7246 | // InternalSolverLanguageParser.g:2785:1: ruleManyMultiplicity returns [EObject current=null] : ( () otherlv_1= LeftSquareBracket otherlv_2= RightSquareBracket ) ; |
8163 | public final EObject ruleManyMultiplicity() throws RecognitionException { | 7247 | public final EObject ruleManyMultiplicity() throws RecognitionException { |
8164 | EObject current = null; | 7248 | EObject current = null; |
8165 | 7249 | ||
@@ -8170,48 +7254,40 @@ public class InternalSolverLanguageParser extends AbstractInternalAntlrParser { | |||
8170 | enterRule(); | 7254 | enterRule(); |
8171 | 7255 | ||
8172 | try { | 7256 | try { |
8173 | // InternalSolverLanguage.g:2824:2: ( ( () otherlv_1= '[' otherlv_2= ']' ) ) | 7257 | // InternalSolverLanguageParser.g:2791:2: ( ( () otherlv_1= LeftSquareBracket otherlv_2= RightSquareBracket ) ) |
8174 | // InternalSolverLanguage.g:2825:2: ( () otherlv_1= '[' otherlv_2= ']' ) | 7258 | // InternalSolverLanguageParser.g:2792:2: ( () otherlv_1= LeftSquareBracket otherlv_2= RightSquareBracket ) |
8175 | { | 7259 | { |
8176 | // InternalSolverLanguage.g:2825:2: ( () otherlv_1= '[' otherlv_2= ']' ) | 7260 | // InternalSolverLanguageParser.g:2792:2: ( () otherlv_1= LeftSquareBracket otherlv_2= RightSquareBracket ) |
8177 | // InternalSolverLanguage.g:2826:3: () otherlv_1= '[' otherlv_2= ']' | 7261 | // InternalSolverLanguageParser.g:2793:3: () otherlv_1= LeftSquareBracket otherlv_2= RightSquareBracket |
8178 | { | 7262 | { |
8179 | // InternalSolverLanguage.g:2826:3: () | 7263 | // InternalSolverLanguageParser.g:2793:3: () |
8180 | // InternalSolverLanguage.g:2827:4: | 7264 | // InternalSolverLanguageParser.g:2794:4: |
8181 | { | 7265 | { |
8182 | if ( state.backtracking==0 ) { | ||
8183 | 7266 | ||
8184 | current = forceCreateModelElement( | 7267 | current = forceCreateModelElement( |
8185 | grammarAccess.getManyMultiplicityAccess().getManyMultiplicityAction_0(), | 7268 | grammarAccess.getManyMultiplicityAccess().getManyMultiplicityAction_0(), |
8186 | current); | 7269 | current); |
8187 | 7270 | ||
8188 | } | ||
8189 | 7271 | ||
8190 | } | 7272 | } |
8191 | 7273 | ||
8192 | otherlv_1=(Token)match(input,36,FOLLOW_38); if (state.failed) return current; | 7274 | otherlv_1=(Token)match(input,LeftSquareBracket,FOLLOW_36); |
8193 | if ( state.backtracking==0 ) { | ||
8194 | 7275 | ||
8195 | newLeafNode(otherlv_1, grammarAccess.getManyMultiplicityAccess().getLeftSquareBracketKeyword_1()); | 7276 | newLeafNode(otherlv_1, grammarAccess.getManyMultiplicityAccess().getLeftSquareBracketKeyword_1()); |
8196 | 7277 | ||
8197 | } | 7278 | otherlv_2=(Token)match(input,RightSquareBracket,FOLLOW_2); |
8198 | otherlv_2=(Token)match(input,38,FOLLOW_2); if (state.failed) return current; | ||
8199 | if ( state.backtracking==0 ) { | ||
8200 | 7279 | ||
8201 | newLeafNode(otherlv_2, grammarAccess.getManyMultiplicityAccess().getRightSquareBracketKeyword_2()); | 7280 | newLeafNode(otherlv_2, grammarAccess.getManyMultiplicityAccess().getRightSquareBracketKeyword_2()); |
8202 | 7281 | ||
8203 | } | ||
8204 | 7282 | ||
8205 | } | 7283 | } |
8206 | 7284 | ||
8207 | 7285 | ||
8208 | } | 7286 | } |
8209 | 7287 | ||
8210 | if ( state.backtracking==0 ) { | ||
8211 | 7288 | ||
8212 | leaveRule(); | 7289 | leaveRule(); |
8213 | 7290 | ||
8214 | } | ||
8215 | } | 7291 | } |
8216 | 7292 | ||
8217 | catch (RecognitionException re) { | 7293 | catch (RecognitionException re) { |
@@ -8226,7 +7302,7 @@ public class InternalSolverLanguageParser extends AbstractInternalAntlrParser { | |||
8226 | 7302 | ||
8227 | 7303 | ||
8228 | // $ANTLR start "entryRuleExactMultiplicity" | 7304 | // $ANTLR start "entryRuleExactMultiplicity" |
8229 | // InternalSolverLanguage.g:2845:1: entryRuleExactMultiplicity returns [EObject current=null] : iv_ruleExactMultiplicity= ruleExactMultiplicity EOF ; | 7305 | // InternalSolverLanguageParser.g:2812:1: entryRuleExactMultiplicity returns [EObject current=null] : iv_ruleExactMultiplicity= ruleExactMultiplicity EOF ; |
8230 | public final EObject entryRuleExactMultiplicity() throws RecognitionException { | 7306 | public final EObject entryRuleExactMultiplicity() throws RecognitionException { |
8231 | EObject current = null; | 7307 | EObject current = null; |
8232 | 7308 | ||
@@ -8234,21 +7310,17 @@ public class InternalSolverLanguageParser extends AbstractInternalAntlrParser { | |||
8234 | 7310 | ||
8235 | 7311 | ||
8236 | try { | 7312 | try { |
8237 | // InternalSolverLanguage.g:2845:58: (iv_ruleExactMultiplicity= ruleExactMultiplicity EOF ) | 7313 | // InternalSolverLanguageParser.g:2812:58: (iv_ruleExactMultiplicity= ruleExactMultiplicity EOF ) |
8238 | // InternalSolverLanguage.g:2846:2: iv_ruleExactMultiplicity= ruleExactMultiplicity EOF | 7314 | // InternalSolverLanguageParser.g:2813:2: iv_ruleExactMultiplicity= ruleExactMultiplicity EOF |
8239 | { | 7315 | { |
8240 | if ( state.backtracking==0 ) { | 7316 | newCompositeNode(grammarAccess.getExactMultiplicityRule()); |
8241 | newCompositeNode(grammarAccess.getExactMultiplicityRule()); | ||
8242 | } | ||
8243 | pushFollow(FOLLOW_1); | 7317 | pushFollow(FOLLOW_1); |
8244 | iv_ruleExactMultiplicity=ruleExactMultiplicity(); | 7318 | iv_ruleExactMultiplicity=ruleExactMultiplicity(); |
8245 | 7319 | ||
8246 | state._fsp--; | 7320 | state._fsp--; |
8247 | if (state.failed) return current; | 7321 | |
8248 | if ( state.backtracking==0 ) { | 7322 | current =iv_ruleExactMultiplicity; |
8249 | current =iv_ruleExactMultiplicity; | 7323 | match(input,EOF,FOLLOW_2); |
8250 | } | ||
8251 | match(input,EOF,FOLLOW_2); if (state.failed) return current; | ||
8252 | 7324 | ||
8253 | } | 7325 | } |
8254 | 7326 | ||
@@ -8266,7 +7338,7 @@ public class InternalSolverLanguageParser extends AbstractInternalAntlrParser { | |||
8266 | 7338 | ||
8267 | 7339 | ||
8268 | // $ANTLR start "ruleExactMultiplicity" | 7340 | // $ANTLR start "ruleExactMultiplicity" |
8269 | // InternalSolverLanguage.g:2852:1: ruleExactMultiplicity returns [EObject current=null] : (otherlv_0= '[' ( (lv_multiplicity_1_0= ruleUpperMultiplicty ) ) otherlv_2= ']' ) ; | 7341 | // InternalSolverLanguageParser.g:2819:1: ruleExactMultiplicity returns [EObject current=null] : (otherlv_0= LeftSquareBracket ( (lv_multiplicity_1_0= ruleUpperMultiplicty ) ) otherlv_2= RightSquareBracket ) ; |
8270 | public final EObject ruleExactMultiplicity() throws RecognitionException { | 7342 | public final EObject ruleExactMultiplicity() throws RecognitionException { |
8271 | EObject current = null; | 7343 | EObject current = null; |
8272 | 7344 | ||
@@ -8279,70 +7351,60 @@ public class InternalSolverLanguageParser extends AbstractInternalAntlrParser { | |||
8279 | enterRule(); | 7351 | enterRule(); |
8280 | 7352 | ||
8281 | try { | 7353 | try { |
8282 | // InternalSolverLanguage.g:2858:2: ( (otherlv_0= '[' ( (lv_multiplicity_1_0= ruleUpperMultiplicty ) ) otherlv_2= ']' ) ) | 7354 | // InternalSolverLanguageParser.g:2825:2: ( (otherlv_0= LeftSquareBracket ( (lv_multiplicity_1_0= ruleUpperMultiplicty ) ) otherlv_2= RightSquareBracket ) ) |
8283 | // InternalSolverLanguage.g:2859:2: (otherlv_0= '[' ( (lv_multiplicity_1_0= ruleUpperMultiplicty ) ) otherlv_2= ']' ) | 7355 | // InternalSolverLanguageParser.g:2826:2: (otherlv_0= LeftSquareBracket ( (lv_multiplicity_1_0= ruleUpperMultiplicty ) ) otherlv_2= RightSquareBracket ) |
8284 | { | 7356 | { |
8285 | // InternalSolverLanguage.g:2859:2: (otherlv_0= '[' ( (lv_multiplicity_1_0= ruleUpperMultiplicty ) ) otherlv_2= ']' ) | 7357 | // InternalSolverLanguageParser.g:2826:2: (otherlv_0= LeftSquareBracket ( (lv_multiplicity_1_0= ruleUpperMultiplicty ) ) otherlv_2= RightSquareBracket ) |
8286 | // InternalSolverLanguage.g:2860:3: otherlv_0= '[' ( (lv_multiplicity_1_0= ruleUpperMultiplicty ) ) otherlv_2= ']' | 7358 | // InternalSolverLanguageParser.g:2827:3: otherlv_0= LeftSquareBracket ( (lv_multiplicity_1_0= ruleUpperMultiplicty ) ) otherlv_2= RightSquareBracket |
8287 | { | 7359 | { |
8288 | otherlv_0=(Token)match(input,36,FOLLOW_46); if (state.failed) return current; | 7360 | otherlv_0=(Token)match(input,LeftSquareBracket,FOLLOW_44); |
8289 | if ( state.backtracking==0 ) { | ||
8290 | 7361 | ||
8291 | newLeafNode(otherlv_0, grammarAccess.getExactMultiplicityAccess().getLeftSquareBracketKeyword_0()); | 7362 | newLeafNode(otherlv_0, grammarAccess.getExactMultiplicityAccess().getLeftSquareBracketKeyword_0()); |
8292 | 7363 | ||
8293 | } | 7364 | // InternalSolverLanguageParser.g:2831:3: ( (lv_multiplicity_1_0= ruleUpperMultiplicty ) ) |
8294 | // InternalSolverLanguage.g:2864:3: ( (lv_multiplicity_1_0= ruleUpperMultiplicty ) ) | 7365 | // InternalSolverLanguageParser.g:2832:4: (lv_multiplicity_1_0= ruleUpperMultiplicty ) |
8295 | // InternalSolverLanguage.g:2865:4: (lv_multiplicity_1_0= ruleUpperMultiplicty ) | ||
8296 | { | 7366 | { |
8297 | // InternalSolverLanguage.g:2865:4: (lv_multiplicity_1_0= ruleUpperMultiplicty ) | 7367 | // InternalSolverLanguageParser.g:2832:4: (lv_multiplicity_1_0= ruleUpperMultiplicty ) |
8298 | // InternalSolverLanguage.g:2866:5: lv_multiplicity_1_0= ruleUpperMultiplicty | 7368 | // InternalSolverLanguageParser.g:2833:5: lv_multiplicity_1_0= ruleUpperMultiplicty |
8299 | { | 7369 | { |
8300 | if ( state.backtracking==0 ) { | ||
8301 | 7370 | ||
8302 | newCompositeNode(grammarAccess.getExactMultiplicityAccess().getMultiplicityUpperMultiplictyParserRuleCall_1_0()); | 7371 | newCompositeNode(grammarAccess.getExactMultiplicityAccess().getMultiplicityUpperMultiplictyParserRuleCall_1_0()); |
8303 | 7372 | ||
8304 | } | 7373 | pushFollow(FOLLOW_36); |
8305 | pushFollow(FOLLOW_38); | ||
8306 | lv_multiplicity_1_0=ruleUpperMultiplicty(); | 7374 | lv_multiplicity_1_0=ruleUpperMultiplicty(); |
8307 | 7375 | ||
8308 | state._fsp--; | 7376 | state._fsp--; |
8309 | if (state.failed) return current; | ||
8310 | if ( state.backtracking==0 ) { | ||
8311 | 7377 | ||
8312 | if (current==null) { | 7378 | |
8313 | current = createModelElementForParent(grammarAccess.getExactMultiplicityRule()); | 7379 | if (current==null) { |
8314 | } | 7380 | current = createModelElementForParent(grammarAccess.getExactMultiplicityRule()); |
8315 | set( | 7381 | } |
8316 | current, | 7382 | set( |
8317 | "multiplicity", | 7383 | current, |
8318 | lv_multiplicity_1_0, | 7384 | "multiplicity", |
8319 | "org.eclipse.viatra.solver.language.SolverLanguage.UpperMultiplicty"); | 7385 | lv_multiplicity_1_0, |
8320 | afterParserOrEnumRuleCall(); | 7386 | "org.eclipse.viatra.solver.language.SolverLanguage.UpperMultiplicty"); |
8321 | 7387 | afterParserOrEnumRuleCall(); | |
8322 | } | 7388 | |
8323 | 7389 | ||
8324 | } | 7390 | } |
8325 | 7391 | ||
8326 | 7392 | ||
8327 | } | 7393 | } |
8328 | 7394 | ||
8329 | otherlv_2=(Token)match(input,38,FOLLOW_2); if (state.failed) return current; | 7395 | otherlv_2=(Token)match(input,RightSquareBracket,FOLLOW_2); |
8330 | if ( state.backtracking==0 ) { | ||
8331 | 7396 | ||
8332 | newLeafNode(otherlv_2, grammarAccess.getExactMultiplicityAccess().getRightSquareBracketKeyword_2()); | 7397 | newLeafNode(otherlv_2, grammarAccess.getExactMultiplicityAccess().getRightSquareBracketKeyword_2()); |
8333 | 7398 | ||
8334 | } | ||
8335 | 7399 | ||
8336 | } | 7400 | } |
8337 | 7401 | ||
8338 | 7402 | ||
8339 | } | 7403 | } |
8340 | 7404 | ||
8341 | if ( state.backtracking==0 ) { | ||
8342 | 7405 | ||
8343 | leaveRule(); | 7406 | leaveRule(); |
8344 | 7407 | ||
8345 | } | ||
8346 | } | 7408 | } |
8347 | 7409 | ||
8348 | catch (RecognitionException re) { | 7410 | catch (RecognitionException re) { |
@@ -8357,7 +7419,7 @@ public class InternalSolverLanguageParser extends AbstractInternalAntlrParser { | |||
8357 | 7419 | ||
8358 | 7420 | ||
8359 | // $ANTLR start "entryRuleBoundedMultiplicity" | 7421 | // $ANTLR start "entryRuleBoundedMultiplicity" |
8360 | // InternalSolverLanguage.g:2891:1: entryRuleBoundedMultiplicity returns [EObject current=null] : iv_ruleBoundedMultiplicity= ruleBoundedMultiplicity EOF ; | 7422 | // InternalSolverLanguageParser.g:2858:1: entryRuleBoundedMultiplicity returns [EObject current=null] : iv_ruleBoundedMultiplicity= ruleBoundedMultiplicity EOF ; |
8361 | public final EObject entryRuleBoundedMultiplicity() throws RecognitionException { | 7423 | public final EObject entryRuleBoundedMultiplicity() throws RecognitionException { |
8362 | EObject current = null; | 7424 | EObject current = null; |
8363 | 7425 | ||
@@ -8365,21 +7427,17 @@ public class InternalSolverLanguageParser extends AbstractInternalAntlrParser { | |||
8365 | 7427 | ||
8366 | 7428 | ||
8367 | try { | 7429 | try { |
8368 | // InternalSolverLanguage.g:2891:60: (iv_ruleBoundedMultiplicity= ruleBoundedMultiplicity EOF ) | 7430 | // InternalSolverLanguageParser.g:2858:60: (iv_ruleBoundedMultiplicity= ruleBoundedMultiplicity EOF ) |
8369 | // InternalSolverLanguage.g:2892:2: iv_ruleBoundedMultiplicity= ruleBoundedMultiplicity EOF | 7431 | // InternalSolverLanguageParser.g:2859:2: iv_ruleBoundedMultiplicity= ruleBoundedMultiplicity EOF |
8370 | { | 7432 | { |
8371 | if ( state.backtracking==0 ) { | 7433 | newCompositeNode(grammarAccess.getBoundedMultiplicityRule()); |
8372 | newCompositeNode(grammarAccess.getBoundedMultiplicityRule()); | ||
8373 | } | ||
8374 | pushFollow(FOLLOW_1); | 7434 | pushFollow(FOLLOW_1); |
8375 | iv_ruleBoundedMultiplicity=ruleBoundedMultiplicity(); | 7435 | iv_ruleBoundedMultiplicity=ruleBoundedMultiplicity(); |
8376 | 7436 | ||
8377 | state._fsp--; | 7437 | state._fsp--; |
8378 | if (state.failed) return current; | 7438 | |
8379 | if ( state.backtracking==0 ) { | 7439 | current =iv_ruleBoundedMultiplicity; |
8380 | current =iv_ruleBoundedMultiplicity; | 7440 | match(input,EOF,FOLLOW_2); |
8381 | } | ||
8382 | match(input,EOF,FOLLOW_2); if (state.failed) return current; | ||
8383 | 7441 | ||
8384 | } | 7442 | } |
8385 | 7443 | ||
@@ -8397,7 +7455,7 @@ public class InternalSolverLanguageParser extends AbstractInternalAntlrParser { | |||
8397 | 7455 | ||
8398 | 7456 | ||
8399 | // $ANTLR start "ruleBoundedMultiplicity" | 7457 | // $ANTLR start "ruleBoundedMultiplicity" |
8400 | // InternalSolverLanguage.g:2898:1: ruleBoundedMultiplicity returns [EObject current=null] : (otherlv_0= '[' ( (lv_lowerBound_1_0= RULE_INT ) ) otherlv_2= '..' ( (lv_upperBound_3_0= ruleUpperMultiplicty ) ) otherlv_4= ']' ) ; | 7458 | // InternalSolverLanguageParser.g:2865:1: ruleBoundedMultiplicity returns [EObject current=null] : (otherlv_0= LeftSquareBracket ( (lv_lowerBound_1_0= RULE_INT ) ) otherlv_2= FullStopFullStop ( (lv_upperBound_3_0= ruleUpperMultiplicty ) ) otherlv_4= RightSquareBracket ) ; |
8401 | public final EObject ruleBoundedMultiplicity() throws RecognitionException { | 7459 | public final EObject ruleBoundedMultiplicity() throws RecognitionException { |
8402 | EObject current = null; | 7460 | EObject current = null; |
8403 | 7461 | ||
@@ -8412,106 +7470,90 @@ public class InternalSolverLanguageParser extends AbstractInternalAntlrParser { | |||
8412 | enterRule(); | 7470 | enterRule(); |
8413 | 7471 | ||
8414 | try { | 7472 | try { |
8415 | // InternalSolverLanguage.g:2904:2: ( (otherlv_0= '[' ( (lv_lowerBound_1_0= RULE_INT ) ) otherlv_2= '..' ( (lv_upperBound_3_0= ruleUpperMultiplicty ) ) otherlv_4= ']' ) ) | 7473 | // InternalSolverLanguageParser.g:2871:2: ( (otherlv_0= LeftSquareBracket ( (lv_lowerBound_1_0= RULE_INT ) ) otherlv_2= FullStopFullStop ( (lv_upperBound_3_0= ruleUpperMultiplicty ) ) otherlv_4= RightSquareBracket ) ) |
8416 | // InternalSolverLanguage.g:2905:2: (otherlv_0= '[' ( (lv_lowerBound_1_0= RULE_INT ) ) otherlv_2= '..' ( (lv_upperBound_3_0= ruleUpperMultiplicty ) ) otherlv_4= ']' ) | 7474 | // InternalSolverLanguageParser.g:2872:2: (otherlv_0= LeftSquareBracket ( (lv_lowerBound_1_0= RULE_INT ) ) otherlv_2= FullStopFullStop ( (lv_upperBound_3_0= ruleUpperMultiplicty ) ) otherlv_4= RightSquareBracket ) |
8417 | { | 7475 | { |
8418 | // InternalSolverLanguage.g:2905:2: (otherlv_0= '[' ( (lv_lowerBound_1_0= RULE_INT ) ) otherlv_2= '..' ( (lv_upperBound_3_0= ruleUpperMultiplicty ) ) otherlv_4= ']' ) | 7476 | // InternalSolverLanguageParser.g:2872:2: (otherlv_0= LeftSquareBracket ( (lv_lowerBound_1_0= RULE_INT ) ) otherlv_2= FullStopFullStop ( (lv_upperBound_3_0= ruleUpperMultiplicty ) ) otherlv_4= RightSquareBracket ) |
8419 | // InternalSolverLanguage.g:2906:3: otherlv_0= '[' ( (lv_lowerBound_1_0= RULE_INT ) ) otherlv_2= '..' ( (lv_upperBound_3_0= ruleUpperMultiplicty ) ) otherlv_4= ']' | 7477 | // InternalSolverLanguageParser.g:2873:3: otherlv_0= LeftSquareBracket ( (lv_lowerBound_1_0= RULE_INT ) ) otherlv_2= FullStopFullStop ( (lv_upperBound_3_0= ruleUpperMultiplicty ) ) otherlv_4= RightSquareBracket |
8420 | { | 7478 | { |
8421 | otherlv_0=(Token)match(input,36,FOLLOW_47); if (state.failed) return current; | 7479 | otherlv_0=(Token)match(input,LeftSquareBracket,FOLLOW_45); |
8422 | if ( state.backtracking==0 ) { | ||
8423 | 7480 | ||
8424 | newLeafNode(otherlv_0, grammarAccess.getBoundedMultiplicityAccess().getLeftSquareBracketKeyword_0()); | 7481 | newLeafNode(otherlv_0, grammarAccess.getBoundedMultiplicityAccess().getLeftSquareBracketKeyword_0()); |
8425 | 7482 | ||
8426 | } | 7483 | // InternalSolverLanguageParser.g:2877:3: ( (lv_lowerBound_1_0= RULE_INT ) ) |
8427 | // InternalSolverLanguage.g:2910:3: ( (lv_lowerBound_1_0= RULE_INT ) ) | 7484 | // InternalSolverLanguageParser.g:2878:4: (lv_lowerBound_1_0= RULE_INT ) |
8428 | // InternalSolverLanguage.g:2911:4: (lv_lowerBound_1_0= RULE_INT ) | ||
8429 | { | 7485 | { |
8430 | // InternalSolverLanguage.g:2911:4: (lv_lowerBound_1_0= RULE_INT ) | 7486 | // InternalSolverLanguageParser.g:2878:4: (lv_lowerBound_1_0= RULE_INT ) |
8431 | // InternalSolverLanguage.g:2912:5: lv_lowerBound_1_0= RULE_INT | 7487 | // InternalSolverLanguageParser.g:2879:5: lv_lowerBound_1_0= RULE_INT |
8432 | { | 7488 | { |
8433 | lv_lowerBound_1_0=(Token)match(input,RULE_INT,FOLLOW_37); if (state.failed) return current; | 7489 | lv_lowerBound_1_0=(Token)match(input,RULE_INT,FOLLOW_35); |
8434 | if ( state.backtracking==0 ) { | ||
8435 | 7490 | ||
8436 | newLeafNode(lv_lowerBound_1_0, grammarAccess.getBoundedMultiplicityAccess().getLowerBoundINTTerminalRuleCall_1_0()); | 7491 | newLeafNode(lv_lowerBound_1_0, grammarAccess.getBoundedMultiplicityAccess().getLowerBoundINTTerminalRuleCall_1_0()); |
8437 | 7492 | ||
8438 | } | ||
8439 | if ( state.backtracking==0 ) { | ||
8440 | 7493 | ||
8441 | if (current==null) { | 7494 | if (current==null) { |
8442 | current = createModelElement(grammarAccess.getBoundedMultiplicityRule()); | 7495 | current = createModelElement(grammarAccess.getBoundedMultiplicityRule()); |
8443 | } | 7496 | } |
8444 | setWithLastConsumed( | 7497 | setWithLastConsumed( |
8445 | current, | 7498 | current, |
8446 | "lowerBound", | 7499 | "lowerBound", |
8447 | lv_lowerBound_1_0, | 7500 | lv_lowerBound_1_0, |
8448 | "org.eclipse.xtext.common.Terminals.INT"); | 7501 | "org.eclipse.xtext.common.Terminals.INT"); |
8449 | 7502 | ||
8450 | } | ||
8451 | 7503 | ||
8452 | } | 7504 | } |
8453 | 7505 | ||
8454 | 7506 | ||
8455 | } | 7507 | } |
8456 | 7508 | ||
8457 | otherlv_2=(Token)match(input,37,FOLLOW_46); if (state.failed) return current; | 7509 | otherlv_2=(Token)match(input,FullStopFullStop,FOLLOW_44); |
8458 | if ( state.backtracking==0 ) { | ||
8459 | 7510 | ||
8460 | newLeafNode(otherlv_2, grammarAccess.getBoundedMultiplicityAccess().getFullStopFullStopKeyword_2()); | 7511 | newLeafNode(otherlv_2, grammarAccess.getBoundedMultiplicityAccess().getFullStopFullStopKeyword_2()); |
8461 | 7512 | ||
8462 | } | 7513 | // InternalSolverLanguageParser.g:2899:3: ( (lv_upperBound_3_0= ruleUpperMultiplicty ) ) |
8463 | // InternalSolverLanguage.g:2932:3: ( (lv_upperBound_3_0= ruleUpperMultiplicty ) ) | 7514 | // InternalSolverLanguageParser.g:2900:4: (lv_upperBound_3_0= ruleUpperMultiplicty ) |
8464 | // InternalSolverLanguage.g:2933:4: (lv_upperBound_3_0= ruleUpperMultiplicty ) | ||
8465 | { | 7515 | { |
8466 | // InternalSolverLanguage.g:2933:4: (lv_upperBound_3_0= ruleUpperMultiplicty ) | 7516 | // InternalSolverLanguageParser.g:2900:4: (lv_upperBound_3_0= ruleUpperMultiplicty ) |
8467 | // InternalSolverLanguage.g:2934:5: lv_upperBound_3_0= ruleUpperMultiplicty | 7517 | // InternalSolverLanguageParser.g:2901:5: lv_upperBound_3_0= ruleUpperMultiplicty |
8468 | { | 7518 | { |
8469 | if ( state.backtracking==0 ) { | ||
8470 | 7519 | ||
8471 | newCompositeNode(grammarAccess.getBoundedMultiplicityAccess().getUpperBoundUpperMultiplictyParserRuleCall_3_0()); | 7520 | newCompositeNode(grammarAccess.getBoundedMultiplicityAccess().getUpperBoundUpperMultiplictyParserRuleCall_3_0()); |
8472 | 7521 | ||
8473 | } | 7522 | pushFollow(FOLLOW_36); |
8474 | pushFollow(FOLLOW_38); | ||
8475 | lv_upperBound_3_0=ruleUpperMultiplicty(); | 7523 | lv_upperBound_3_0=ruleUpperMultiplicty(); |
8476 | 7524 | ||
8477 | state._fsp--; | 7525 | state._fsp--; |
8478 | if (state.failed) return current; | ||
8479 | if ( state.backtracking==0 ) { | ||
8480 | 7526 | ||
8481 | if (current==null) { | 7527 | |
8482 | current = createModelElementForParent(grammarAccess.getBoundedMultiplicityRule()); | 7528 | if (current==null) { |
8483 | } | 7529 | current = createModelElementForParent(grammarAccess.getBoundedMultiplicityRule()); |
8484 | set( | 7530 | } |
8485 | current, | 7531 | set( |
8486 | "upperBound", | 7532 | current, |
8487 | lv_upperBound_3_0, | 7533 | "upperBound", |
8488 | "org.eclipse.viatra.solver.language.SolverLanguage.UpperMultiplicty"); | 7534 | lv_upperBound_3_0, |
8489 | afterParserOrEnumRuleCall(); | 7535 | "org.eclipse.viatra.solver.language.SolverLanguage.UpperMultiplicty"); |
8490 | 7536 | afterParserOrEnumRuleCall(); | |
8491 | } | 7537 | |
8492 | 7538 | ||
8493 | } | 7539 | } |
8494 | 7540 | ||
8495 | 7541 | ||
8496 | } | 7542 | } |
8497 | 7543 | ||
8498 | otherlv_4=(Token)match(input,38,FOLLOW_2); if (state.failed) return current; | 7544 | otherlv_4=(Token)match(input,RightSquareBracket,FOLLOW_2); |
8499 | if ( state.backtracking==0 ) { | ||
8500 | 7545 | ||
8501 | newLeafNode(otherlv_4, grammarAccess.getBoundedMultiplicityAccess().getRightSquareBracketKeyword_4()); | 7546 | newLeafNode(otherlv_4, grammarAccess.getBoundedMultiplicityAccess().getRightSquareBracketKeyword_4()); |
8502 | 7547 | ||
8503 | } | ||
8504 | 7548 | ||
8505 | } | 7549 | } |
8506 | 7550 | ||
8507 | 7551 | ||
8508 | } | 7552 | } |
8509 | 7553 | ||
8510 | if ( state.backtracking==0 ) { | ||
8511 | 7554 | ||
8512 | leaveRule(); | 7555 | leaveRule(); |
8513 | 7556 | ||
8514 | } | ||
8515 | } | 7557 | } |
8516 | 7558 | ||
8517 | catch (RecognitionException re) { | 7559 | catch (RecognitionException re) { |
@@ -8526,7 +7568,7 @@ public class InternalSolverLanguageParser extends AbstractInternalAntlrParser { | |||
8526 | 7568 | ||
8527 | 7569 | ||
8528 | // $ANTLR start "entryRuleScopeDefinition" | 7570 | // $ANTLR start "entryRuleScopeDefinition" |
8529 | // InternalSolverLanguage.g:2959:1: entryRuleScopeDefinition returns [EObject current=null] : iv_ruleScopeDefinition= ruleScopeDefinition EOF ; | 7571 | // InternalSolverLanguageParser.g:2926:1: entryRuleScopeDefinition returns [EObject current=null] : iv_ruleScopeDefinition= ruleScopeDefinition EOF ; |
8530 | public final EObject entryRuleScopeDefinition() throws RecognitionException { | 7572 | public final EObject entryRuleScopeDefinition() throws RecognitionException { |
8531 | EObject current = null; | 7573 | EObject current = null; |
8532 | 7574 | ||
@@ -8534,21 +7576,17 @@ public class InternalSolverLanguageParser extends AbstractInternalAntlrParser { | |||
8534 | 7576 | ||
8535 | 7577 | ||
8536 | try { | 7578 | try { |
8537 | // InternalSolverLanguage.g:2959:56: (iv_ruleScopeDefinition= ruleScopeDefinition EOF ) | 7579 | // InternalSolverLanguageParser.g:2926:56: (iv_ruleScopeDefinition= ruleScopeDefinition EOF ) |
8538 | // InternalSolverLanguage.g:2960:2: iv_ruleScopeDefinition= ruleScopeDefinition EOF | 7580 | // InternalSolverLanguageParser.g:2927:2: iv_ruleScopeDefinition= ruleScopeDefinition EOF |
8539 | { | 7581 | { |
8540 | if ( state.backtracking==0 ) { | 7582 | newCompositeNode(grammarAccess.getScopeDefinitionRule()); |
8541 | newCompositeNode(grammarAccess.getScopeDefinitionRule()); | ||
8542 | } | ||
8543 | pushFollow(FOLLOW_1); | 7583 | pushFollow(FOLLOW_1); |
8544 | iv_ruleScopeDefinition=ruleScopeDefinition(); | 7584 | iv_ruleScopeDefinition=ruleScopeDefinition(); |
8545 | 7585 | ||
8546 | state._fsp--; | 7586 | state._fsp--; |
8547 | if (state.failed) return current; | 7587 | |
8548 | if ( state.backtracking==0 ) { | 7588 | current =iv_ruleScopeDefinition; |
8549 | current =iv_ruleScopeDefinition; | 7589 | match(input,EOF,FOLLOW_2); |
8550 | } | ||
8551 | match(input,EOF,FOLLOW_2); if (state.failed) return current; | ||
8552 | 7590 | ||
8553 | } | 7591 | } |
8554 | 7592 | ||
@@ -8566,7 +7604,7 @@ public class InternalSolverLanguageParser extends AbstractInternalAntlrParser { | |||
8566 | 7604 | ||
8567 | 7605 | ||
8568 | // $ANTLR start "ruleScopeDefinition" | 7606 | // $ANTLR start "ruleScopeDefinition" |
8569 | // InternalSolverLanguage.g:2966:1: ruleScopeDefinition returns [EObject current=null] : (this_ExactScopeDefinition_0= ruleExactScopeDefinition | this_BoundedScopeDefinition_1= ruleBoundedScopeDefinition | this_LowerBoundedScopeDefinition_2= ruleLowerBoundedScopeDefinition ) ; | 7607 | // InternalSolverLanguageParser.g:2933:1: ruleScopeDefinition returns [EObject current=null] : (this_ExactScopeDefinition_0= ruleExactScopeDefinition | this_BoundedScopeDefinition_1= ruleBoundedScopeDefinition | this_LowerBoundedScopeDefinition_2= ruleLowerBoundedScopeDefinition ) ; |
8570 | public final EObject ruleScopeDefinition() throws RecognitionException { | 7608 | public final EObject ruleScopeDefinition() throws RecognitionException { |
8571 | EObject current = null; | 7609 | EObject current = null; |
8572 | 7610 | ||
@@ -8581,76 +7619,64 @@ public class InternalSolverLanguageParser extends AbstractInternalAntlrParser { | |||
8581 | enterRule(); | 7619 | enterRule(); |
8582 | 7620 | ||
8583 | try { | 7621 | try { |
8584 | // InternalSolverLanguage.g:2972:2: ( (this_ExactScopeDefinition_0= ruleExactScopeDefinition | this_BoundedScopeDefinition_1= ruleBoundedScopeDefinition | this_LowerBoundedScopeDefinition_2= ruleLowerBoundedScopeDefinition ) ) | 7622 | // InternalSolverLanguageParser.g:2939:2: ( (this_ExactScopeDefinition_0= ruleExactScopeDefinition | this_BoundedScopeDefinition_1= ruleBoundedScopeDefinition | this_LowerBoundedScopeDefinition_2= ruleLowerBoundedScopeDefinition ) ) |
8585 | // InternalSolverLanguage.g:2973:2: (this_ExactScopeDefinition_0= ruleExactScopeDefinition | this_BoundedScopeDefinition_1= ruleBoundedScopeDefinition | this_LowerBoundedScopeDefinition_2= ruleLowerBoundedScopeDefinition ) | 7623 | // InternalSolverLanguageParser.g:2940:2: (this_ExactScopeDefinition_0= ruleExactScopeDefinition | this_BoundedScopeDefinition_1= ruleBoundedScopeDefinition | this_LowerBoundedScopeDefinition_2= ruleLowerBoundedScopeDefinition ) |
8586 | { | 7624 | { |
8587 | // InternalSolverLanguage.g:2973:2: (this_ExactScopeDefinition_0= ruleExactScopeDefinition | this_BoundedScopeDefinition_1= ruleBoundedScopeDefinition | this_LowerBoundedScopeDefinition_2= ruleLowerBoundedScopeDefinition ) | 7625 | // InternalSolverLanguageParser.g:2940:2: (this_ExactScopeDefinition_0= ruleExactScopeDefinition | this_BoundedScopeDefinition_1= ruleBoundedScopeDefinition | this_LowerBoundedScopeDefinition_2= ruleLowerBoundedScopeDefinition ) |
8588 | int alt36=3; | 7626 | int alt35=3; |
8589 | alt36 = dfa36.predict(input); | 7627 | alt35 = dfa35.predict(input); |
8590 | switch (alt36) { | 7628 | switch (alt35) { |
8591 | case 1 : | 7629 | case 1 : |
8592 | // InternalSolverLanguage.g:2974:3: this_ExactScopeDefinition_0= ruleExactScopeDefinition | 7630 | // InternalSolverLanguageParser.g:2941:3: this_ExactScopeDefinition_0= ruleExactScopeDefinition |
8593 | { | 7631 | { |
8594 | if ( state.backtracking==0 ) { | ||
8595 | 7632 | ||
8596 | newCompositeNode(grammarAccess.getScopeDefinitionAccess().getExactScopeDefinitionParserRuleCall_0()); | 7633 | newCompositeNode(grammarAccess.getScopeDefinitionAccess().getExactScopeDefinitionParserRuleCall_0()); |
8597 | 7634 | ||
8598 | } | ||
8599 | pushFollow(FOLLOW_2); | 7635 | pushFollow(FOLLOW_2); |
8600 | this_ExactScopeDefinition_0=ruleExactScopeDefinition(); | 7636 | this_ExactScopeDefinition_0=ruleExactScopeDefinition(); |
8601 | 7637 | ||
8602 | state._fsp--; | 7638 | state._fsp--; |
8603 | if (state.failed) return current; | ||
8604 | if ( state.backtracking==0 ) { | ||
8605 | 7639 | ||
8606 | current = this_ExactScopeDefinition_0; | 7640 | |
8607 | afterParserOrEnumRuleCall(); | 7641 | current = this_ExactScopeDefinition_0; |
8608 | 7642 | afterParserOrEnumRuleCall(); | |
8609 | } | 7643 | |
8610 | 7644 | ||
8611 | } | 7645 | } |
8612 | break; | 7646 | break; |
8613 | case 2 : | 7647 | case 2 : |
8614 | // InternalSolverLanguage.g:2983:3: this_BoundedScopeDefinition_1= ruleBoundedScopeDefinition | 7648 | // InternalSolverLanguageParser.g:2950:3: this_BoundedScopeDefinition_1= ruleBoundedScopeDefinition |
8615 | { | 7649 | { |
8616 | if ( state.backtracking==0 ) { | ||
8617 | 7650 | ||
8618 | newCompositeNode(grammarAccess.getScopeDefinitionAccess().getBoundedScopeDefinitionParserRuleCall_1()); | 7651 | newCompositeNode(grammarAccess.getScopeDefinitionAccess().getBoundedScopeDefinitionParserRuleCall_1()); |
8619 | 7652 | ||
8620 | } | ||
8621 | pushFollow(FOLLOW_2); | 7653 | pushFollow(FOLLOW_2); |
8622 | this_BoundedScopeDefinition_1=ruleBoundedScopeDefinition(); | 7654 | this_BoundedScopeDefinition_1=ruleBoundedScopeDefinition(); |
8623 | 7655 | ||
8624 | state._fsp--; | 7656 | state._fsp--; |
8625 | if (state.failed) return current; | ||
8626 | if ( state.backtracking==0 ) { | ||
8627 | 7657 | ||
8628 | current = this_BoundedScopeDefinition_1; | 7658 | |
8629 | afterParserOrEnumRuleCall(); | 7659 | current = this_BoundedScopeDefinition_1; |
8630 | 7660 | afterParserOrEnumRuleCall(); | |
8631 | } | 7661 | |
8632 | 7662 | ||
8633 | } | 7663 | } |
8634 | break; | 7664 | break; |
8635 | case 3 : | 7665 | case 3 : |
8636 | // InternalSolverLanguage.g:2992:3: this_LowerBoundedScopeDefinition_2= ruleLowerBoundedScopeDefinition | 7666 | // InternalSolverLanguageParser.g:2959:3: this_LowerBoundedScopeDefinition_2= ruleLowerBoundedScopeDefinition |
8637 | { | 7667 | { |
8638 | if ( state.backtracking==0 ) { | ||
8639 | 7668 | ||
8640 | newCompositeNode(grammarAccess.getScopeDefinitionAccess().getLowerBoundedScopeDefinitionParserRuleCall_2()); | 7669 | newCompositeNode(grammarAccess.getScopeDefinitionAccess().getLowerBoundedScopeDefinitionParserRuleCall_2()); |
8641 | 7670 | ||
8642 | } | ||
8643 | pushFollow(FOLLOW_2); | 7671 | pushFollow(FOLLOW_2); |
8644 | this_LowerBoundedScopeDefinition_2=ruleLowerBoundedScopeDefinition(); | 7672 | this_LowerBoundedScopeDefinition_2=ruleLowerBoundedScopeDefinition(); |
8645 | 7673 | ||
8646 | state._fsp--; | 7674 | state._fsp--; |
8647 | if (state.failed) return current; | ||
8648 | if ( state.backtracking==0 ) { | ||
8649 | 7675 | ||
8650 | current = this_LowerBoundedScopeDefinition_2; | 7676 | |
8651 | afterParserOrEnumRuleCall(); | 7677 | current = this_LowerBoundedScopeDefinition_2; |
8652 | 7678 | afterParserOrEnumRuleCall(); | |
8653 | } | 7679 | |
8654 | 7680 | ||
8655 | } | 7681 | } |
8656 | break; | 7682 | break; |
@@ -8660,11 +7686,9 @@ public class InternalSolverLanguageParser extends AbstractInternalAntlrParser { | |||
8660 | 7686 | ||
8661 | } | 7687 | } |
8662 | 7688 | ||
8663 | if ( state.backtracking==0 ) { | ||
8664 | 7689 | ||
8665 | leaveRule(); | 7690 | leaveRule(); |
8666 | 7691 | ||
8667 | } | ||
8668 | } | 7692 | } |
8669 | 7693 | ||
8670 | catch (RecognitionException re) { | 7694 | catch (RecognitionException re) { |
@@ -8679,7 +7703,7 @@ public class InternalSolverLanguageParser extends AbstractInternalAntlrParser { | |||
8679 | 7703 | ||
8680 | 7704 | ||
8681 | // $ANTLR start "entryRuleExactScopeDefinition" | 7705 | // $ANTLR start "entryRuleExactScopeDefinition" |
8682 | // InternalSolverLanguage.g:3004:1: entryRuleExactScopeDefinition returns [EObject current=null] : iv_ruleExactScopeDefinition= ruleExactScopeDefinition EOF ; | 7706 | // InternalSolverLanguageParser.g:2971:1: entryRuleExactScopeDefinition returns [EObject current=null] : iv_ruleExactScopeDefinition= ruleExactScopeDefinition EOF ; |
8683 | public final EObject entryRuleExactScopeDefinition() throws RecognitionException { | 7707 | public final EObject entryRuleExactScopeDefinition() throws RecognitionException { |
8684 | EObject current = null; | 7708 | EObject current = null; |
8685 | 7709 | ||
@@ -8687,21 +7711,17 @@ public class InternalSolverLanguageParser extends AbstractInternalAntlrParser { | |||
8687 | 7711 | ||
8688 | 7712 | ||
8689 | try { | 7713 | try { |
8690 | // InternalSolverLanguage.g:3004:61: (iv_ruleExactScopeDefinition= ruleExactScopeDefinition EOF ) | 7714 | // InternalSolverLanguageParser.g:2971:61: (iv_ruleExactScopeDefinition= ruleExactScopeDefinition EOF ) |
8691 | // InternalSolverLanguage.g:3005:2: iv_ruleExactScopeDefinition= ruleExactScopeDefinition EOF | 7715 | // InternalSolverLanguageParser.g:2972:2: iv_ruleExactScopeDefinition= ruleExactScopeDefinition EOF |
8692 | { | 7716 | { |
8693 | if ( state.backtracking==0 ) { | 7717 | newCompositeNode(grammarAccess.getExactScopeDefinitionRule()); |
8694 | newCompositeNode(grammarAccess.getExactScopeDefinitionRule()); | ||
8695 | } | ||
8696 | pushFollow(FOLLOW_1); | 7718 | pushFollow(FOLLOW_1); |
8697 | iv_ruleExactScopeDefinition=ruleExactScopeDefinition(); | 7719 | iv_ruleExactScopeDefinition=ruleExactScopeDefinition(); |
8698 | 7720 | ||
8699 | state._fsp--; | 7721 | state._fsp--; |
8700 | if (state.failed) return current; | 7722 | |
8701 | if ( state.backtracking==0 ) { | 7723 | current =iv_ruleExactScopeDefinition; |
8702 | current =iv_ruleExactScopeDefinition; | 7724 | match(input,EOF,FOLLOW_2); |
8703 | } | ||
8704 | match(input,EOF,FOLLOW_2); if (state.failed) return current; | ||
8705 | 7725 | ||
8706 | } | 7726 | } |
8707 | 7727 | ||
@@ -8719,7 +7739,7 @@ public class InternalSolverLanguageParser extends AbstractInternalAntlrParser { | |||
8719 | 7739 | ||
8720 | 7740 | ||
8721 | // $ANTLR start "ruleExactScopeDefinition" | 7741 | // $ANTLR start "ruleExactScopeDefinition" |
8722 | // InternalSolverLanguage.g:3011:1: ruleExactScopeDefinition returns [EObject current=null] : (otherlv_0= 'scope' ( ( ruleQualifiedName ) ) otherlv_2= '==' ( (lv_exactScope_3_0= RULE_INT ) ) ) ; | 7742 | // InternalSolverLanguageParser.g:2978:1: ruleExactScopeDefinition returns [EObject current=null] : (otherlv_0= Scope ( ( ruleQualifiedName ) ) otherlv_2= EqualsSignEqualsSign ( (lv_exactScope_3_0= RULE_INT ) ) ) ; |
8723 | public final EObject ruleExactScopeDefinition() throws RecognitionException { | 7743 | public final EObject ruleExactScopeDefinition() throws RecognitionException { |
8724 | EObject current = null; | 7744 | EObject current = null; |
8725 | 7745 | ||
@@ -8731,82 +7751,68 @@ public class InternalSolverLanguageParser extends AbstractInternalAntlrParser { | |||
8731 | enterRule(); | 7751 | enterRule(); |
8732 | 7752 | ||
8733 | try { | 7753 | try { |
8734 | // InternalSolverLanguage.g:3017:2: ( (otherlv_0= 'scope' ( ( ruleQualifiedName ) ) otherlv_2= '==' ( (lv_exactScope_3_0= RULE_INT ) ) ) ) | 7754 | // InternalSolverLanguageParser.g:2984:2: ( (otherlv_0= Scope ( ( ruleQualifiedName ) ) otherlv_2= EqualsSignEqualsSign ( (lv_exactScope_3_0= RULE_INT ) ) ) ) |
8735 | // InternalSolverLanguage.g:3018:2: (otherlv_0= 'scope' ( ( ruleQualifiedName ) ) otherlv_2= '==' ( (lv_exactScope_3_0= RULE_INT ) ) ) | 7755 | // InternalSolverLanguageParser.g:2985:2: (otherlv_0= Scope ( ( ruleQualifiedName ) ) otherlv_2= EqualsSignEqualsSign ( (lv_exactScope_3_0= RULE_INT ) ) ) |
8736 | { | 7756 | { |
8737 | // InternalSolverLanguage.g:3018:2: (otherlv_0= 'scope' ( ( ruleQualifiedName ) ) otherlv_2= '==' ( (lv_exactScope_3_0= RULE_INT ) ) ) | 7757 | // InternalSolverLanguageParser.g:2985:2: (otherlv_0= Scope ( ( ruleQualifiedName ) ) otherlv_2= EqualsSignEqualsSign ( (lv_exactScope_3_0= RULE_INT ) ) ) |
8738 | // InternalSolverLanguage.g:3019:3: otherlv_0= 'scope' ( ( ruleQualifiedName ) ) otherlv_2= '==' ( (lv_exactScope_3_0= RULE_INT ) ) | 7758 | // InternalSolverLanguageParser.g:2986:3: otherlv_0= Scope ( ( ruleQualifiedName ) ) otherlv_2= EqualsSignEqualsSign ( (lv_exactScope_3_0= RULE_INT ) ) |
8739 | { | 7759 | { |
8740 | otherlv_0=(Token)match(input,46,FOLLOW_35); if (state.failed) return current; | 7760 | otherlv_0=(Token)match(input,Scope,FOLLOW_8); |
8741 | if ( state.backtracking==0 ) { | ||
8742 | 7761 | ||
8743 | newLeafNode(otherlv_0, grammarAccess.getExactScopeDefinitionAccess().getScopeKeyword_0()); | 7762 | newLeafNode(otherlv_0, grammarAccess.getExactScopeDefinitionAccess().getScopeKeyword_0()); |
8744 | 7763 | ||
8745 | } | 7764 | // InternalSolverLanguageParser.g:2990:3: ( ( ruleQualifiedName ) ) |
8746 | // InternalSolverLanguage.g:3023:3: ( ( ruleQualifiedName ) ) | 7765 | // InternalSolverLanguageParser.g:2991:4: ( ruleQualifiedName ) |
8747 | // InternalSolverLanguage.g:3024:4: ( ruleQualifiedName ) | ||
8748 | { | 7766 | { |
8749 | // InternalSolverLanguage.g:3024:4: ( ruleQualifiedName ) | 7767 | // InternalSolverLanguageParser.g:2991:4: ( ruleQualifiedName ) |
8750 | // InternalSolverLanguage.g:3025:5: ruleQualifiedName | 7768 | // InternalSolverLanguageParser.g:2992:5: ruleQualifiedName |
8751 | { | 7769 | { |
8752 | if ( state.backtracking==0 ) { | ||
8753 | 7770 | ||
8754 | if (current==null) { | 7771 | if (current==null) { |
8755 | current = createModelElement(grammarAccess.getExactScopeDefinitionRule()); | 7772 | current = createModelElement(grammarAccess.getExactScopeDefinitionRule()); |
8756 | } | 7773 | } |
8757 | 7774 | ||
8758 | } | ||
8759 | if ( state.backtracking==0 ) { | ||
8760 | 7775 | ||
8761 | newCompositeNode(grammarAccess.getExactScopeDefinitionAccess().getTypeNamedElementCrossReference_1_0()); | 7776 | newCompositeNode(grammarAccess.getExactScopeDefinitionAccess().getTypeNamedElementCrossReference_1_0()); |
8762 | 7777 | ||
8763 | } | 7778 | pushFollow(FOLLOW_46); |
8764 | pushFollow(FOLLOW_48); | ||
8765 | ruleQualifiedName(); | 7779 | ruleQualifiedName(); |
8766 | 7780 | ||
8767 | state._fsp--; | 7781 | state._fsp--; |
8768 | if (state.failed) return current; | ||
8769 | if ( state.backtracking==0 ) { | ||
8770 | 7782 | ||
8771 | afterParserOrEnumRuleCall(); | 7783 | |
8772 | 7784 | afterParserOrEnumRuleCall(); | |
8773 | } | 7785 | |
8774 | 7786 | ||
8775 | } | 7787 | } |
8776 | 7788 | ||
8777 | 7789 | ||
8778 | } | 7790 | } |
8779 | 7791 | ||
8780 | otherlv_2=(Token)match(input,47,FOLLOW_47); if (state.failed) return current; | 7792 | otherlv_2=(Token)match(input,EqualsSignEqualsSign,FOLLOW_45); |
8781 | if ( state.backtracking==0 ) { | ||
8782 | 7793 | ||
8783 | newLeafNode(otherlv_2, grammarAccess.getExactScopeDefinitionAccess().getEqualsSignEqualsSignKeyword_2()); | 7794 | newLeafNode(otherlv_2, grammarAccess.getExactScopeDefinitionAccess().getEqualsSignEqualsSignKeyword_2()); |
8784 | 7795 | ||
8785 | } | 7796 | // InternalSolverLanguageParser.g:3010:3: ( (lv_exactScope_3_0= RULE_INT ) ) |
8786 | // InternalSolverLanguage.g:3043:3: ( (lv_exactScope_3_0= RULE_INT ) ) | 7797 | // InternalSolverLanguageParser.g:3011:4: (lv_exactScope_3_0= RULE_INT ) |
8787 | // InternalSolverLanguage.g:3044:4: (lv_exactScope_3_0= RULE_INT ) | ||
8788 | { | 7798 | { |
8789 | // InternalSolverLanguage.g:3044:4: (lv_exactScope_3_0= RULE_INT ) | 7799 | // InternalSolverLanguageParser.g:3011:4: (lv_exactScope_3_0= RULE_INT ) |
8790 | // InternalSolverLanguage.g:3045:5: lv_exactScope_3_0= RULE_INT | 7800 | // InternalSolverLanguageParser.g:3012:5: lv_exactScope_3_0= RULE_INT |
8791 | { | 7801 | { |
8792 | lv_exactScope_3_0=(Token)match(input,RULE_INT,FOLLOW_2); if (state.failed) return current; | 7802 | lv_exactScope_3_0=(Token)match(input,RULE_INT,FOLLOW_2); |
8793 | if ( state.backtracking==0 ) { | ||
8794 | 7803 | ||
8795 | newLeafNode(lv_exactScope_3_0, grammarAccess.getExactScopeDefinitionAccess().getExactScopeINTTerminalRuleCall_3_0()); | 7804 | newLeafNode(lv_exactScope_3_0, grammarAccess.getExactScopeDefinitionAccess().getExactScopeINTTerminalRuleCall_3_0()); |
8796 | 7805 | ||
8797 | } | ||
8798 | if ( state.backtracking==0 ) { | ||
8799 | 7806 | ||
8800 | if (current==null) { | 7807 | if (current==null) { |
8801 | current = createModelElement(grammarAccess.getExactScopeDefinitionRule()); | 7808 | current = createModelElement(grammarAccess.getExactScopeDefinitionRule()); |
8802 | } | 7809 | } |
8803 | setWithLastConsumed( | 7810 | setWithLastConsumed( |
8804 | current, | 7811 | current, |
8805 | "exactScope", | 7812 | "exactScope", |
8806 | lv_exactScope_3_0, | 7813 | lv_exactScope_3_0, |
8807 | "org.eclipse.xtext.common.Terminals.INT"); | 7814 | "org.eclipse.xtext.common.Terminals.INT"); |
8808 | 7815 | ||
8809 | } | ||
8810 | 7816 | ||
8811 | } | 7817 | } |
8812 | 7818 | ||
@@ -8819,11 +7825,9 @@ public class InternalSolverLanguageParser extends AbstractInternalAntlrParser { | |||
8819 | 7825 | ||
8820 | } | 7826 | } |
8821 | 7827 | ||
8822 | if ( state.backtracking==0 ) { | ||
8823 | 7828 | ||
8824 | leaveRule(); | 7829 | leaveRule(); |
8825 | 7830 | ||
8826 | } | ||
8827 | } | 7831 | } |
8828 | 7832 | ||
8829 | catch (RecognitionException re) { | 7833 | catch (RecognitionException re) { |
@@ -8838,7 +7842,7 @@ public class InternalSolverLanguageParser extends AbstractInternalAntlrParser { | |||
8838 | 7842 | ||
8839 | 7843 | ||
8840 | // $ANTLR start "entryRuleBoundedScopeDefinition" | 7844 | // $ANTLR start "entryRuleBoundedScopeDefinition" |
8841 | // InternalSolverLanguage.g:3065:1: entryRuleBoundedScopeDefinition returns [EObject current=null] : iv_ruleBoundedScopeDefinition= ruleBoundedScopeDefinition EOF ; | 7845 | // InternalSolverLanguageParser.g:3032:1: entryRuleBoundedScopeDefinition returns [EObject current=null] : iv_ruleBoundedScopeDefinition= ruleBoundedScopeDefinition EOF ; |
8842 | public final EObject entryRuleBoundedScopeDefinition() throws RecognitionException { | 7846 | public final EObject entryRuleBoundedScopeDefinition() throws RecognitionException { |
8843 | EObject current = null; | 7847 | EObject current = null; |
8844 | 7848 | ||
@@ -8846,21 +7850,17 @@ public class InternalSolverLanguageParser extends AbstractInternalAntlrParser { | |||
8846 | 7850 | ||
8847 | 7851 | ||
8848 | try { | 7852 | try { |
8849 | // InternalSolverLanguage.g:3065:63: (iv_ruleBoundedScopeDefinition= ruleBoundedScopeDefinition EOF ) | 7853 | // InternalSolverLanguageParser.g:3032:63: (iv_ruleBoundedScopeDefinition= ruleBoundedScopeDefinition EOF ) |
8850 | // InternalSolverLanguage.g:3066:2: iv_ruleBoundedScopeDefinition= ruleBoundedScopeDefinition EOF | 7854 | // InternalSolverLanguageParser.g:3033:2: iv_ruleBoundedScopeDefinition= ruleBoundedScopeDefinition EOF |
8851 | { | 7855 | { |
8852 | if ( state.backtracking==0 ) { | 7856 | newCompositeNode(grammarAccess.getBoundedScopeDefinitionRule()); |
8853 | newCompositeNode(grammarAccess.getBoundedScopeDefinitionRule()); | ||
8854 | } | ||
8855 | pushFollow(FOLLOW_1); | 7857 | pushFollow(FOLLOW_1); |
8856 | iv_ruleBoundedScopeDefinition=ruleBoundedScopeDefinition(); | 7858 | iv_ruleBoundedScopeDefinition=ruleBoundedScopeDefinition(); |
8857 | 7859 | ||
8858 | state._fsp--; | 7860 | state._fsp--; |
8859 | if (state.failed) return current; | 7861 | |
8860 | if ( state.backtracking==0 ) { | 7862 | current =iv_ruleBoundedScopeDefinition; |
8861 | current =iv_ruleBoundedScopeDefinition; | 7863 | match(input,EOF,FOLLOW_2); |
8862 | } | ||
8863 | match(input,EOF,FOLLOW_2); if (state.failed) return current; | ||
8864 | 7864 | ||
8865 | } | 7865 | } |
8866 | 7866 | ||
@@ -8878,7 +7878,7 @@ public class InternalSolverLanguageParser extends AbstractInternalAntlrParser { | |||
8878 | 7878 | ||
8879 | 7879 | ||
8880 | // $ANTLR start "ruleBoundedScopeDefinition" | 7880 | // $ANTLR start "ruleBoundedScopeDefinition" |
8881 | // InternalSolverLanguage.g:3072:1: ruleBoundedScopeDefinition returns [EObject current=null] : (otherlv_0= 'scope' ( ( ( ( (lv_lowerBound_1_0= RULE_INT ) ) otherlv_2= '<=' )? ( ( ruleQualifiedName ) ) otherlv_4= '<=' ( (lv_upperBound_5_0= RULE_INT ) ) ) | ( ( (lv_upperBound_6_0= RULE_INT ) ) otherlv_7= '>=' ( ( ruleQualifiedName ) ) (otherlv_9= '>=' ( (lv_lowerBound_10_0= RULE_INT ) ) )? ) ) otherlv_11= '.' ) ; | 7881 | // InternalSolverLanguageParser.g:3039:1: ruleBoundedScopeDefinition returns [EObject current=null] : (otherlv_0= Scope ( ( ( ( (lv_lowerBound_1_0= RULE_INT ) ) otherlv_2= LessThanSignEqualsSign )? ( ( ruleQualifiedName ) ) otherlv_4= LessThanSignEqualsSign ( (lv_upperBound_5_0= RULE_INT ) ) ) | ( ( (lv_upperBound_6_0= RULE_INT ) ) otherlv_7= GreaterThanSignEqualsSign ( ( ruleQualifiedName ) ) (otherlv_9= GreaterThanSignEqualsSign ( (lv_lowerBound_10_0= RULE_INT ) ) )? ) ) ) ; |
8882 | public final EObject ruleBoundedScopeDefinition() throws RecognitionException { | 7882 | public final EObject ruleBoundedScopeDefinition() throws RecognitionException { |
8883 | EObject current = null; | 7883 | EObject current = null; |
8884 | 7884 | ||
@@ -8891,179 +7891,156 @@ public class InternalSolverLanguageParser extends AbstractInternalAntlrParser { | |||
8891 | Token otherlv_7=null; | 7891 | Token otherlv_7=null; |
8892 | Token otherlv_9=null; | 7892 | Token otherlv_9=null; |
8893 | Token lv_lowerBound_10_0=null; | 7893 | Token lv_lowerBound_10_0=null; |
8894 | Token otherlv_11=null; | ||
8895 | 7894 | ||
8896 | 7895 | ||
8897 | enterRule(); | 7896 | enterRule(); |
8898 | 7897 | ||
8899 | try { | 7898 | try { |
8900 | // InternalSolverLanguage.g:3078:2: ( (otherlv_0= 'scope' ( ( ( ( (lv_lowerBound_1_0= RULE_INT ) ) otherlv_2= '<=' )? ( ( ruleQualifiedName ) ) otherlv_4= '<=' ( (lv_upperBound_5_0= RULE_INT ) ) ) | ( ( (lv_upperBound_6_0= RULE_INT ) ) otherlv_7= '>=' ( ( ruleQualifiedName ) ) (otherlv_9= '>=' ( (lv_lowerBound_10_0= RULE_INT ) ) )? ) ) otherlv_11= '.' ) ) | 7899 | // InternalSolverLanguageParser.g:3045:2: ( (otherlv_0= Scope ( ( ( ( (lv_lowerBound_1_0= RULE_INT ) ) otherlv_2= LessThanSignEqualsSign )? ( ( ruleQualifiedName ) ) otherlv_4= LessThanSignEqualsSign ( (lv_upperBound_5_0= RULE_INT ) ) ) | ( ( (lv_upperBound_6_0= RULE_INT ) ) otherlv_7= GreaterThanSignEqualsSign ( ( ruleQualifiedName ) ) (otherlv_9= GreaterThanSignEqualsSign ( (lv_lowerBound_10_0= RULE_INT ) ) )? ) ) ) ) |
8901 | // InternalSolverLanguage.g:3079:2: (otherlv_0= 'scope' ( ( ( ( (lv_lowerBound_1_0= RULE_INT ) ) otherlv_2= '<=' )? ( ( ruleQualifiedName ) ) otherlv_4= '<=' ( (lv_upperBound_5_0= RULE_INT ) ) ) | ( ( (lv_upperBound_6_0= RULE_INT ) ) otherlv_7= '>=' ( ( ruleQualifiedName ) ) (otherlv_9= '>=' ( (lv_lowerBound_10_0= RULE_INT ) ) )? ) ) otherlv_11= '.' ) | 7900 | // InternalSolverLanguageParser.g:3046:2: (otherlv_0= Scope ( ( ( ( (lv_lowerBound_1_0= RULE_INT ) ) otherlv_2= LessThanSignEqualsSign )? ( ( ruleQualifiedName ) ) otherlv_4= LessThanSignEqualsSign ( (lv_upperBound_5_0= RULE_INT ) ) ) | ( ( (lv_upperBound_6_0= RULE_INT ) ) otherlv_7= GreaterThanSignEqualsSign ( ( ruleQualifiedName ) ) (otherlv_9= GreaterThanSignEqualsSign ( (lv_lowerBound_10_0= RULE_INT ) ) )? ) ) ) |
8902 | { | 7901 | { |
8903 | // InternalSolverLanguage.g:3079:2: (otherlv_0= 'scope' ( ( ( ( (lv_lowerBound_1_0= RULE_INT ) ) otherlv_2= '<=' )? ( ( ruleQualifiedName ) ) otherlv_4= '<=' ( (lv_upperBound_5_0= RULE_INT ) ) ) | ( ( (lv_upperBound_6_0= RULE_INT ) ) otherlv_7= '>=' ( ( ruleQualifiedName ) ) (otherlv_9= '>=' ( (lv_lowerBound_10_0= RULE_INT ) ) )? ) ) otherlv_11= '.' ) | 7902 | // InternalSolverLanguageParser.g:3046:2: (otherlv_0= Scope ( ( ( ( (lv_lowerBound_1_0= RULE_INT ) ) otherlv_2= LessThanSignEqualsSign )? ( ( ruleQualifiedName ) ) otherlv_4= LessThanSignEqualsSign ( (lv_upperBound_5_0= RULE_INT ) ) ) | ( ( (lv_upperBound_6_0= RULE_INT ) ) otherlv_7= GreaterThanSignEqualsSign ( ( ruleQualifiedName ) ) (otherlv_9= GreaterThanSignEqualsSign ( (lv_lowerBound_10_0= RULE_INT ) ) )? ) ) ) |
8904 | // InternalSolverLanguage.g:3080:3: otherlv_0= 'scope' ( ( ( ( (lv_lowerBound_1_0= RULE_INT ) ) otherlv_2= '<=' )? ( ( ruleQualifiedName ) ) otherlv_4= '<=' ( (lv_upperBound_5_0= RULE_INT ) ) ) | ( ( (lv_upperBound_6_0= RULE_INT ) ) otherlv_7= '>=' ( ( ruleQualifiedName ) ) (otherlv_9= '>=' ( (lv_lowerBound_10_0= RULE_INT ) ) )? ) ) otherlv_11= '.' | 7903 | // InternalSolverLanguageParser.g:3047:3: otherlv_0= Scope ( ( ( ( (lv_lowerBound_1_0= RULE_INT ) ) otherlv_2= LessThanSignEqualsSign )? ( ( ruleQualifiedName ) ) otherlv_4= LessThanSignEqualsSign ( (lv_upperBound_5_0= RULE_INT ) ) ) | ( ( (lv_upperBound_6_0= RULE_INT ) ) otherlv_7= GreaterThanSignEqualsSign ( ( ruleQualifiedName ) ) (otherlv_9= GreaterThanSignEqualsSign ( (lv_lowerBound_10_0= RULE_INT ) ) )? ) ) |
8905 | { | 7904 | { |
8906 | otherlv_0=(Token)match(input,46,FOLLOW_49); if (state.failed) return current; | 7905 | otherlv_0=(Token)match(input,Scope,FOLLOW_47); |
8907 | if ( state.backtracking==0 ) { | ||
8908 | 7906 | ||
8909 | newLeafNode(otherlv_0, grammarAccess.getBoundedScopeDefinitionAccess().getScopeKeyword_0()); | 7907 | newLeafNode(otherlv_0, grammarAccess.getBoundedScopeDefinitionAccess().getScopeKeyword_0()); |
8910 | 7908 | ||
8911 | } | 7909 | // InternalSolverLanguageParser.g:3051:3: ( ( ( ( (lv_lowerBound_1_0= RULE_INT ) ) otherlv_2= LessThanSignEqualsSign )? ( ( ruleQualifiedName ) ) otherlv_4= LessThanSignEqualsSign ( (lv_upperBound_5_0= RULE_INT ) ) ) | ( ( (lv_upperBound_6_0= RULE_INT ) ) otherlv_7= GreaterThanSignEqualsSign ( ( ruleQualifiedName ) ) (otherlv_9= GreaterThanSignEqualsSign ( (lv_lowerBound_10_0= RULE_INT ) ) )? ) ) |
8912 | // InternalSolverLanguage.g:3084:3: ( ( ( ( (lv_lowerBound_1_0= RULE_INT ) ) otherlv_2= '<=' )? ( ( ruleQualifiedName ) ) otherlv_4= '<=' ( (lv_upperBound_5_0= RULE_INT ) ) ) | ( ( (lv_upperBound_6_0= RULE_INT ) ) otherlv_7= '>=' ( ( ruleQualifiedName ) ) (otherlv_9= '>=' ( (lv_lowerBound_10_0= RULE_INT ) ) )? ) ) | 7910 | int alt38=2; |
8913 | int alt39=2; | 7911 | int LA38_0 = input.LA(1); |
8914 | int LA39_0 = input.LA(1); | ||
8915 | 7912 | ||
8916 | if ( (LA39_0==RULE_INT) ) { | 7913 | if ( (LA38_0==RULE_INT) ) { |
8917 | int LA39_1 = input.LA(2); | 7914 | int LA38_1 = input.LA(2); |
8918 | 7915 | ||
8919 | if ( (LA39_1==49) ) { | 7916 | if ( (LA38_1==GreaterThanSignEqualsSign) ) { |
8920 | alt39=2; | 7917 | alt38=2; |
8921 | } | 7918 | } |
8922 | else if ( (LA39_1==48) ) { | 7919 | else if ( (LA38_1==LessThanSignEqualsSign) ) { |
8923 | alt39=1; | 7920 | alt38=1; |
8924 | } | 7921 | } |
8925 | else { | 7922 | else { |
8926 | if (state.backtracking>0) {state.failed=true; return current;} | ||
8927 | NoViableAltException nvae = | 7923 | NoViableAltException nvae = |
8928 | new NoViableAltException("", 39, 1, input); | 7924 | new NoViableAltException("", 38, 1, input); |
8929 | 7925 | ||
8930 | throw nvae; | 7926 | throw nvae; |
8931 | } | 7927 | } |
8932 | } | 7928 | } |
8933 | else if ( (LA39_0==RULE_ID||LA39_0==RULE_QUOTED_ID) ) { | 7929 | else if ( (LA38_0==RULE_QUOTED_ID||LA38_0==RULE_ID) ) { |
8934 | alt39=1; | 7930 | alt38=1; |
8935 | } | 7931 | } |
8936 | else { | 7932 | else { |
8937 | if (state.backtracking>0) {state.failed=true; return current;} | ||
8938 | NoViableAltException nvae = | 7933 | NoViableAltException nvae = |
8939 | new NoViableAltException("", 39, 0, input); | 7934 | new NoViableAltException("", 38, 0, input); |
8940 | 7935 | ||
8941 | throw nvae; | 7936 | throw nvae; |
8942 | } | 7937 | } |
8943 | switch (alt39) { | 7938 | switch (alt38) { |
8944 | case 1 : | 7939 | case 1 : |
8945 | // InternalSolverLanguage.g:3085:4: ( ( ( (lv_lowerBound_1_0= RULE_INT ) ) otherlv_2= '<=' )? ( ( ruleQualifiedName ) ) otherlv_4= '<=' ( (lv_upperBound_5_0= RULE_INT ) ) ) | 7940 | // InternalSolverLanguageParser.g:3052:4: ( ( ( (lv_lowerBound_1_0= RULE_INT ) ) otherlv_2= LessThanSignEqualsSign )? ( ( ruleQualifiedName ) ) otherlv_4= LessThanSignEqualsSign ( (lv_upperBound_5_0= RULE_INT ) ) ) |
8946 | { | 7941 | { |
8947 | // InternalSolverLanguage.g:3085:4: ( ( ( (lv_lowerBound_1_0= RULE_INT ) ) otherlv_2= '<=' )? ( ( ruleQualifiedName ) ) otherlv_4= '<=' ( (lv_upperBound_5_0= RULE_INT ) ) ) | 7942 | // InternalSolverLanguageParser.g:3052:4: ( ( ( (lv_lowerBound_1_0= RULE_INT ) ) otherlv_2= LessThanSignEqualsSign )? ( ( ruleQualifiedName ) ) otherlv_4= LessThanSignEqualsSign ( (lv_upperBound_5_0= RULE_INT ) ) ) |
8948 | // InternalSolverLanguage.g:3086:5: ( ( (lv_lowerBound_1_0= RULE_INT ) ) otherlv_2= '<=' )? ( ( ruleQualifiedName ) ) otherlv_4= '<=' ( (lv_upperBound_5_0= RULE_INT ) ) | 7943 | // InternalSolverLanguageParser.g:3053:5: ( ( (lv_lowerBound_1_0= RULE_INT ) ) otherlv_2= LessThanSignEqualsSign )? ( ( ruleQualifiedName ) ) otherlv_4= LessThanSignEqualsSign ( (lv_upperBound_5_0= RULE_INT ) ) |
8949 | { | 7944 | { |
8950 | // InternalSolverLanguage.g:3086:5: ( ( (lv_lowerBound_1_0= RULE_INT ) ) otherlv_2= '<=' )? | 7945 | // InternalSolverLanguageParser.g:3053:5: ( ( (lv_lowerBound_1_0= RULE_INT ) ) otherlv_2= LessThanSignEqualsSign )? |
8951 | int alt37=2; | 7946 | int alt36=2; |
8952 | int LA37_0 = input.LA(1); | 7947 | int LA36_0 = input.LA(1); |
8953 | 7948 | ||
8954 | if ( (LA37_0==RULE_INT) ) { | 7949 | if ( (LA36_0==RULE_INT) ) { |
8955 | alt37=1; | 7950 | alt36=1; |
8956 | } | 7951 | } |
8957 | switch (alt37) { | 7952 | switch (alt36) { |
8958 | case 1 : | 7953 | case 1 : |
8959 | // InternalSolverLanguage.g:3087:6: ( (lv_lowerBound_1_0= RULE_INT ) ) otherlv_2= '<=' | 7954 | // InternalSolverLanguageParser.g:3054:6: ( (lv_lowerBound_1_0= RULE_INT ) ) otherlv_2= LessThanSignEqualsSign |
8960 | { | 7955 | { |
8961 | // InternalSolverLanguage.g:3087:6: ( (lv_lowerBound_1_0= RULE_INT ) ) | 7956 | // InternalSolverLanguageParser.g:3054:6: ( (lv_lowerBound_1_0= RULE_INT ) ) |
8962 | // InternalSolverLanguage.g:3088:7: (lv_lowerBound_1_0= RULE_INT ) | 7957 | // InternalSolverLanguageParser.g:3055:7: (lv_lowerBound_1_0= RULE_INT ) |
8963 | { | 7958 | { |
8964 | // InternalSolverLanguage.g:3088:7: (lv_lowerBound_1_0= RULE_INT ) | 7959 | // InternalSolverLanguageParser.g:3055:7: (lv_lowerBound_1_0= RULE_INT ) |
8965 | // InternalSolverLanguage.g:3089:8: lv_lowerBound_1_0= RULE_INT | 7960 | // InternalSolverLanguageParser.g:3056:8: lv_lowerBound_1_0= RULE_INT |
8966 | { | 7961 | { |
8967 | lv_lowerBound_1_0=(Token)match(input,RULE_INT,FOLLOW_50); if (state.failed) return current; | 7962 | lv_lowerBound_1_0=(Token)match(input,RULE_INT,FOLLOW_48); |
8968 | if ( state.backtracking==0 ) { | ||
8969 | 7963 | ||
8970 | newLeafNode(lv_lowerBound_1_0, grammarAccess.getBoundedScopeDefinitionAccess().getLowerBoundINTTerminalRuleCall_1_0_0_0_0()); | 7964 | newLeafNode(lv_lowerBound_1_0, grammarAccess.getBoundedScopeDefinitionAccess().getLowerBoundINTTerminalRuleCall_1_0_0_0_0()); |
8971 | 7965 | ||
8972 | } | 7966 | |
8973 | if ( state.backtracking==0 ) { | 7967 | if (current==null) { |
8974 | 7968 | current = createModelElement(grammarAccess.getBoundedScopeDefinitionRule()); | |
8975 | if (current==null) { | 7969 | } |
8976 | current = createModelElement(grammarAccess.getBoundedScopeDefinitionRule()); | 7970 | setWithLastConsumed( |
8977 | } | 7971 | current, |
8978 | setWithLastConsumed( | 7972 | "lowerBound", |
8979 | current, | 7973 | lv_lowerBound_1_0, |
8980 | "lowerBound", | 7974 | "org.eclipse.xtext.common.Terminals.INT"); |
8981 | lv_lowerBound_1_0, | 7975 | |
8982 | "org.eclipse.xtext.common.Terminals.INT"); | ||
8983 | |||
8984 | } | ||
8985 | 7976 | ||
8986 | } | 7977 | } |
8987 | 7978 | ||
8988 | 7979 | ||
8989 | } | 7980 | } |
8990 | 7981 | ||
8991 | otherlv_2=(Token)match(input,48,FOLLOW_35); if (state.failed) return current; | 7982 | otherlv_2=(Token)match(input,LessThanSignEqualsSign,FOLLOW_8); |
8992 | if ( state.backtracking==0 ) { | ||
8993 | 7983 | ||
8994 | newLeafNode(otherlv_2, grammarAccess.getBoundedScopeDefinitionAccess().getLessThanSignEqualsSignKeyword_1_0_0_1()); | 7984 | newLeafNode(otherlv_2, grammarAccess.getBoundedScopeDefinitionAccess().getLessThanSignEqualsSignKeyword_1_0_0_1()); |
8995 | 7985 | ||
8996 | } | ||
8997 | 7986 | ||
8998 | } | 7987 | } |
8999 | break; | 7988 | break; |
9000 | 7989 | ||
9001 | } | 7990 | } |
9002 | 7991 | ||
9003 | // InternalSolverLanguage.g:3110:5: ( ( ruleQualifiedName ) ) | 7992 | // InternalSolverLanguageParser.g:3077:5: ( ( ruleQualifiedName ) ) |
9004 | // InternalSolverLanguage.g:3111:6: ( ruleQualifiedName ) | 7993 | // InternalSolverLanguageParser.g:3078:6: ( ruleQualifiedName ) |
9005 | { | 7994 | { |
9006 | // InternalSolverLanguage.g:3111:6: ( ruleQualifiedName ) | 7995 | // InternalSolverLanguageParser.g:3078:6: ( ruleQualifiedName ) |
9007 | // InternalSolverLanguage.g:3112:7: ruleQualifiedName | 7996 | // InternalSolverLanguageParser.g:3079:7: ruleQualifiedName |
9008 | { | 7997 | { |
9009 | if ( state.backtracking==0 ) { | ||
9010 | 7998 | ||
9011 | if (current==null) { | 7999 | if (current==null) { |
9012 | current = createModelElement(grammarAccess.getBoundedScopeDefinitionRule()); | 8000 | current = createModelElement(grammarAccess.getBoundedScopeDefinitionRule()); |
9013 | } | 8001 | } |
9014 | 8002 | ||
9015 | } | ||
9016 | if ( state.backtracking==0 ) { | ||
9017 | 8003 | ||
9018 | newCompositeNode(grammarAccess.getBoundedScopeDefinitionAccess().getTypeNamedElementCrossReference_1_0_1_0()); | 8004 | newCompositeNode(grammarAccess.getBoundedScopeDefinitionAccess().getTypeNamedElementCrossReference_1_0_1_0()); |
9019 | 8005 | ||
9020 | } | 8006 | pushFollow(FOLLOW_48); |
9021 | pushFollow(FOLLOW_50); | ||
9022 | ruleQualifiedName(); | 8007 | ruleQualifiedName(); |
9023 | 8008 | ||
9024 | state._fsp--; | 8009 | state._fsp--; |
9025 | if (state.failed) return current; | ||
9026 | if ( state.backtracking==0 ) { | ||
9027 | 8010 | ||
9028 | afterParserOrEnumRuleCall(); | 8011 | |
9029 | 8012 | afterParserOrEnumRuleCall(); | |
9030 | } | 8013 | |
9031 | 8014 | ||
9032 | } | 8015 | } |
9033 | 8016 | ||
9034 | 8017 | ||
9035 | } | 8018 | } |
9036 | 8019 | ||
9037 | otherlv_4=(Token)match(input,48,FOLLOW_47); if (state.failed) return current; | 8020 | otherlv_4=(Token)match(input,LessThanSignEqualsSign,FOLLOW_45); |
9038 | if ( state.backtracking==0 ) { | ||
9039 | 8021 | ||
9040 | newLeafNode(otherlv_4, grammarAccess.getBoundedScopeDefinitionAccess().getLessThanSignEqualsSignKeyword_1_0_2()); | 8022 | newLeafNode(otherlv_4, grammarAccess.getBoundedScopeDefinitionAccess().getLessThanSignEqualsSignKeyword_1_0_2()); |
9041 | 8023 | ||
9042 | } | 8024 | // InternalSolverLanguageParser.g:3097:5: ( (lv_upperBound_5_0= RULE_INT ) ) |
9043 | // InternalSolverLanguage.g:3130:5: ( (lv_upperBound_5_0= RULE_INT ) ) | 8025 | // InternalSolverLanguageParser.g:3098:6: (lv_upperBound_5_0= RULE_INT ) |
9044 | // InternalSolverLanguage.g:3131:6: (lv_upperBound_5_0= RULE_INT ) | ||
9045 | { | 8026 | { |
9046 | // InternalSolverLanguage.g:3131:6: (lv_upperBound_5_0= RULE_INT ) | 8027 | // InternalSolverLanguageParser.g:3098:6: (lv_upperBound_5_0= RULE_INT ) |
9047 | // InternalSolverLanguage.g:3132:7: lv_upperBound_5_0= RULE_INT | 8028 | // InternalSolverLanguageParser.g:3099:7: lv_upperBound_5_0= RULE_INT |
9048 | { | 8029 | { |
9049 | lv_upperBound_5_0=(Token)match(input,RULE_INT,FOLLOW_12); if (state.failed) return current; | 8030 | lv_upperBound_5_0=(Token)match(input,RULE_INT,FOLLOW_2); |
9050 | if ( state.backtracking==0 ) { | ||
9051 | 8031 | ||
9052 | newLeafNode(lv_upperBound_5_0, grammarAccess.getBoundedScopeDefinitionAccess().getUpperBoundINTTerminalRuleCall_1_0_3_0()); | 8032 | newLeafNode(lv_upperBound_5_0, grammarAccess.getBoundedScopeDefinitionAccess().getUpperBoundINTTerminalRuleCall_1_0_3_0()); |
9053 | 8033 | ||
9054 | } | ||
9055 | if ( state.backtracking==0 ) { | ||
9056 | 8034 | ||
9057 | if (current==null) { | 8035 | if (current==null) { |
9058 | current = createModelElement(grammarAccess.getBoundedScopeDefinitionRule()); | 8036 | current = createModelElement(grammarAccess.getBoundedScopeDefinitionRule()); |
9059 | } | 8037 | } |
9060 | setWithLastConsumed( | 8038 | setWithLastConsumed( |
9061 | current, | 8039 | current, |
9062 | "upperBound", | 8040 | "upperBound", |
9063 | lv_upperBound_5_0, | 8041 | lv_upperBound_5_0, |
9064 | "org.eclipse.xtext.common.Terminals.INT"); | 8042 | "org.eclipse.xtext.common.Terminals.INT"); |
9065 | 8043 | ||
9066 | } | ||
9067 | 8044 | ||
9068 | } | 8045 | } |
9069 | 8046 | ||
@@ -9077,122 +8054,104 @@ public class InternalSolverLanguageParser extends AbstractInternalAntlrParser { | |||
9077 | } | 8054 | } |
9078 | break; | 8055 | break; |
9079 | case 2 : | 8056 | case 2 : |
9080 | // InternalSolverLanguage.g:3150:4: ( ( (lv_upperBound_6_0= RULE_INT ) ) otherlv_7= '>=' ( ( ruleQualifiedName ) ) (otherlv_9= '>=' ( (lv_lowerBound_10_0= RULE_INT ) ) )? ) | 8057 | // InternalSolverLanguageParser.g:3117:4: ( ( (lv_upperBound_6_0= RULE_INT ) ) otherlv_7= GreaterThanSignEqualsSign ( ( ruleQualifiedName ) ) (otherlv_9= GreaterThanSignEqualsSign ( (lv_lowerBound_10_0= RULE_INT ) ) )? ) |
9081 | { | 8058 | { |
9082 | // InternalSolverLanguage.g:3150:4: ( ( (lv_upperBound_6_0= RULE_INT ) ) otherlv_7= '>=' ( ( ruleQualifiedName ) ) (otherlv_9= '>=' ( (lv_lowerBound_10_0= RULE_INT ) ) )? ) | 8059 | // InternalSolverLanguageParser.g:3117:4: ( ( (lv_upperBound_6_0= RULE_INT ) ) otherlv_7= GreaterThanSignEqualsSign ( ( ruleQualifiedName ) ) (otherlv_9= GreaterThanSignEqualsSign ( (lv_lowerBound_10_0= RULE_INT ) ) )? ) |
9083 | // InternalSolverLanguage.g:3151:5: ( (lv_upperBound_6_0= RULE_INT ) ) otherlv_7= '>=' ( ( ruleQualifiedName ) ) (otherlv_9= '>=' ( (lv_lowerBound_10_0= RULE_INT ) ) )? | 8060 | // InternalSolverLanguageParser.g:3118:5: ( (lv_upperBound_6_0= RULE_INT ) ) otherlv_7= GreaterThanSignEqualsSign ( ( ruleQualifiedName ) ) (otherlv_9= GreaterThanSignEqualsSign ( (lv_lowerBound_10_0= RULE_INT ) ) )? |
9084 | { | 8061 | { |
9085 | // InternalSolverLanguage.g:3151:5: ( (lv_upperBound_6_0= RULE_INT ) ) | 8062 | // InternalSolverLanguageParser.g:3118:5: ( (lv_upperBound_6_0= RULE_INT ) ) |
9086 | // InternalSolverLanguage.g:3152:6: (lv_upperBound_6_0= RULE_INT ) | 8063 | // InternalSolverLanguageParser.g:3119:6: (lv_upperBound_6_0= RULE_INT ) |
9087 | { | 8064 | { |
9088 | // InternalSolverLanguage.g:3152:6: (lv_upperBound_6_0= RULE_INT ) | 8065 | // InternalSolverLanguageParser.g:3119:6: (lv_upperBound_6_0= RULE_INT ) |
9089 | // InternalSolverLanguage.g:3153:7: lv_upperBound_6_0= RULE_INT | 8066 | // InternalSolverLanguageParser.g:3120:7: lv_upperBound_6_0= RULE_INT |
9090 | { | 8067 | { |
9091 | lv_upperBound_6_0=(Token)match(input,RULE_INT,FOLLOW_51); if (state.failed) return current; | 8068 | lv_upperBound_6_0=(Token)match(input,RULE_INT,FOLLOW_49); |
9092 | if ( state.backtracking==0 ) { | ||
9093 | 8069 | ||
9094 | newLeafNode(lv_upperBound_6_0, grammarAccess.getBoundedScopeDefinitionAccess().getUpperBoundINTTerminalRuleCall_1_1_0_0()); | 8070 | newLeafNode(lv_upperBound_6_0, grammarAccess.getBoundedScopeDefinitionAccess().getUpperBoundINTTerminalRuleCall_1_1_0_0()); |
9095 | 8071 | ||
9096 | } | ||
9097 | if ( state.backtracking==0 ) { | ||
9098 | 8072 | ||
9099 | if (current==null) { | 8073 | if (current==null) { |
9100 | current = createModelElement(grammarAccess.getBoundedScopeDefinitionRule()); | 8074 | current = createModelElement(grammarAccess.getBoundedScopeDefinitionRule()); |
9101 | } | 8075 | } |
9102 | setWithLastConsumed( | 8076 | setWithLastConsumed( |
9103 | current, | 8077 | current, |
9104 | "upperBound", | 8078 | "upperBound", |
9105 | lv_upperBound_6_0, | 8079 | lv_upperBound_6_0, |
9106 | "org.eclipse.xtext.common.Terminals.INT"); | 8080 | "org.eclipse.xtext.common.Terminals.INT"); |
9107 | 8081 | ||
9108 | } | ||
9109 | 8082 | ||
9110 | } | 8083 | } |
9111 | 8084 | ||
9112 | 8085 | ||
9113 | } | 8086 | } |
9114 | 8087 | ||
9115 | otherlv_7=(Token)match(input,49,FOLLOW_35); if (state.failed) return current; | 8088 | otherlv_7=(Token)match(input,GreaterThanSignEqualsSign,FOLLOW_8); |
9116 | if ( state.backtracking==0 ) { | ||
9117 | 8089 | ||
9118 | newLeafNode(otherlv_7, grammarAccess.getBoundedScopeDefinitionAccess().getGreaterThanSignEqualsSignKeyword_1_1_1()); | 8090 | newLeafNode(otherlv_7, grammarAccess.getBoundedScopeDefinitionAccess().getGreaterThanSignEqualsSignKeyword_1_1_1()); |
9119 | 8091 | ||
9120 | } | 8092 | // InternalSolverLanguageParser.g:3140:5: ( ( ruleQualifiedName ) ) |
9121 | // InternalSolverLanguage.g:3173:5: ( ( ruleQualifiedName ) ) | 8093 | // InternalSolverLanguageParser.g:3141:6: ( ruleQualifiedName ) |
9122 | // InternalSolverLanguage.g:3174:6: ( ruleQualifiedName ) | ||
9123 | { | 8094 | { |
9124 | // InternalSolverLanguage.g:3174:6: ( ruleQualifiedName ) | 8095 | // InternalSolverLanguageParser.g:3141:6: ( ruleQualifiedName ) |
9125 | // InternalSolverLanguage.g:3175:7: ruleQualifiedName | 8096 | // InternalSolverLanguageParser.g:3142:7: ruleQualifiedName |
9126 | { | 8097 | { |
9127 | if ( state.backtracking==0 ) { | ||
9128 | 8098 | ||
9129 | if (current==null) { | 8099 | if (current==null) { |
9130 | current = createModelElement(grammarAccess.getBoundedScopeDefinitionRule()); | 8100 | current = createModelElement(grammarAccess.getBoundedScopeDefinitionRule()); |
9131 | } | 8101 | } |
9132 | 8102 | ||
9133 | } | ||
9134 | if ( state.backtracking==0 ) { | ||
9135 | 8103 | ||
9136 | newCompositeNode(grammarAccess.getBoundedScopeDefinitionAccess().getTypeNamedElementCrossReference_1_1_2_0()); | 8104 | newCompositeNode(grammarAccess.getBoundedScopeDefinitionAccess().getTypeNamedElementCrossReference_1_1_2_0()); |
9137 | 8105 | ||
9138 | } | 8106 | pushFollow(FOLLOW_50); |
9139 | pushFollow(FOLLOW_52); | ||
9140 | ruleQualifiedName(); | 8107 | ruleQualifiedName(); |
9141 | 8108 | ||
9142 | state._fsp--; | 8109 | state._fsp--; |
9143 | if (state.failed) return current; | ||
9144 | if ( state.backtracking==0 ) { | ||
9145 | 8110 | ||
9146 | afterParserOrEnumRuleCall(); | 8111 | |
9147 | 8112 | afterParserOrEnumRuleCall(); | |
9148 | } | 8113 | |
9149 | 8114 | ||
9150 | } | 8115 | } |
9151 | 8116 | ||
9152 | 8117 | ||
9153 | } | 8118 | } |
9154 | 8119 | ||
9155 | // InternalSolverLanguage.g:3189:5: (otherlv_9= '>=' ( (lv_lowerBound_10_0= RULE_INT ) ) )? | 8120 | // InternalSolverLanguageParser.g:3156:5: (otherlv_9= GreaterThanSignEqualsSign ( (lv_lowerBound_10_0= RULE_INT ) ) )? |
9156 | int alt38=2; | 8121 | int alt37=2; |
9157 | int LA38_0 = input.LA(1); | 8122 | int LA37_0 = input.LA(1); |
9158 | 8123 | ||
9159 | if ( (LA38_0==49) ) { | 8124 | if ( (LA37_0==GreaterThanSignEqualsSign) ) { |
9160 | alt38=1; | 8125 | alt37=1; |
9161 | } | 8126 | } |
9162 | switch (alt38) { | 8127 | switch (alt37) { |
9163 | case 1 : | 8128 | case 1 : |
9164 | // InternalSolverLanguage.g:3190:6: otherlv_9= '>=' ( (lv_lowerBound_10_0= RULE_INT ) ) | 8129 | // InternalSolverLanguageParser.g:3157:6: otherlv_9= GreaterThanSignEqualsSign ( (lv_lowerBound_10_0= RULE_INT ) ) |
9165 | { | 8130 | { |
9166 | otherlv_9=(Token)match(input,49,FOLLOW_47); if (state.failed) return current; | 8131 | otherlv_9=(Token)match(input,GreaterThanSignEqualsSign,FOLLOW_45); |
9167 | if ( state.backtracking==0 ) { | ||
9168 | 8132 | ||
9169 | newLeafNode(otherlv_9, grammarAccess.getBoundedScopeDefinitionAccess().getGreaterThanSignEqualsSignKeyword_1_1_3_0()); | 8133 | newLeafNode(otherlv_9, grammarAccess.getBoundedScopeDefinitionAccess().getGreaterThanSignEqualsSignKeyword_1_1_3_0()); |
9170 | 8134 | ||
9171 | } | 8135 | // InternalSolverLanguageParser.g:3161:6: ( (lv_lowerBound_10_0= RULE_INT ) ) |
9172 | // InternalSolverLanguage.g:3194:6: ( (lv_lowerBound_10_0= RULE_INT ) ) | 8136 | // InternalSolverLanguageParser.g:3162:7: (lv_lowerBound_10_0= RULE_INT ) |
9173 | // InternalSolverLanguage.g:3195:7: (lv_lowerBound_10_0= RULE_INT ) | ||
9174 | { | 8137 | { |
9175 | // InternalSolverLanguage.g:3195:7: (lv_lowerBound_10_0= RULE_INT ) | 8138 | // InternalSolverLanguageParser.g:3162:7: (lv_lowerBound_10_0= RULE_INT ) |
9176 | // InternalSolverLanguage.g:3196:8: lv_lowerBound_10_0= RULE_INT | 8139 | // InternalSolverLanguageParser.g:3163:8: lv_lowerBound_10_0= RULE_INT |
9177 | { | 8140 | { |
9178 | lv_lowerBound_10_0=(Token)match(input,RULE_INT,FOLLOW_12); if (state.failed) return current; | 8141 | lv_lowerBound_10_0=(Token)match(input,RULE_INT,FOLLOW_2); |
9179 | if ( state.backtracking==0 ) { | ||
9180 | 8142 | ||
9181 | newLeafNode(lv_lowerBound_10_0, grammarAccess.getBoundedScopeDefinitionAccess().getLowerBoundINTTerminalRuleCall_1_1_3_1_0()); | 8143 | newLeafNode(lv_lowerBound_10_0, grammarAccess.getBoundedScopeDefinitionAccess().getLowerBoundINTTerminalRuleCall_1_1_3_1_0()); |
9182 | 8144 | ||
9183 | } | 8145 | |
9184 | if ( state.backtracking==0 ) { | 8146 | if (current==null) { |
9185 | 8147 | current = createModelElement(grammarAccess.getBoundedScopeDefinitionRule()); | |
9186 | if (current==null) { | 8148 | } |
9187 | current = createModelElement(grammarAccess.getBoundedScopeDefinitionRule()); | 8149 | setWithLastConsumed( |
9188 | } | 8150 | current, |
9189 | setWithLastConsumed( | 8151 | "lowerBound", |
9190 | current, | 8152 | lv_lowerBound_10_0, |
9191 | "lowerBound", | 8153 | "org.eclipse.xtext.common.Terminals.INT"); |
9192 | lv_lowerBound_10_0, | 8154 | |
9193 | "org.eclipse.xtext.common.Terminals.INT"); | ||
9194 | |||
9195 | } | ||
9196 | 8155 | ||
9197 | } | 8156 | } |
9198 | 8157 | ||
@@ -9214,23 +8173,15 @@ public class InternalSolverLanguageParser extends AbstractInternalAntlrParser { | |||
9214 | 8173 | ||
9215 | } | 8174 | } |
9216 | 8175 | ||
9217 | otherlv_11=(Token)match(input,22,FOLLOW_2); if (state.failed) return current; | ||
9218 | if ( state.backtracking==0 ) { | ||
9219 | |||
9220 | newLeafNode(otherlv_11, grammarAccess.getBoundedScopeDefinitionAccess().getFullStopKeyword_2()); | ||
9221 | |||
9222 | } | ||
9223 | 8176 | ||
9224 | } | 8177 | } |
9225 | 8178 | ||
9226 | 8179 | ||
9227 | } | 8180 | } |
9228 | 8181 | ||
9229 | if ( state.backtracking==0 ) { | ||
9230 | 8182 | ||
9231 | leaveRule(); | 8183 | leaveRule(); |
9232 | 8184 | ||
9233 | } | ||
9234 | } | 8185 | } |
9235 | 8186 | ||
9236 | catch (RecognitionException re) { | 8187 | catch (RecognitionException re) { |
@@ -9245,7 +8196,7 @@ public class InternalSolverLanguageParser extends AbstractInternalAntlrParser { | |||
9245 | 8196 | ||
9246 | 8197 | ||
9247 | // $ANTLR start "entryRuleLowerBoundedScopeDefinition" | 8198 | // $ANTLR start "entryRuleLowerBoundedScopeDefinition" |
9248 | // InternalSolverLanguage.g:3223:1: entryRuleLowerBoundedScopeDefinition returns [EObject current=null] : iv_ruleLowerBoundedScopeDefinition= ruleLowerBoundedScopeDefinition EOF ; | 8199 | // InternalSolverLanguageParser.g:3186:1: entryRuleLowerBoundedScopeDefinition returns [EObject current=null] : iv_ruleLowerBoundedScopeDefinition= ruleLowerBoundedScopeDefinition EOF ; |
9249 | public final EObject entryRuleLowerBoundedScopeDefinition() throws RecognitionException { | 8200 | public final EObject entryRuleLowerBoundedScopeDefinition() throws RecognitionException { |
9250 | EObject current = null; | 8201 | EObject current = null; |
9251 | 8202 | ||
@@ -9253,21 +8204,17 @@ public class InternalSolverLanguageParser extends AbstractInternalAntlrParser { | |||
9253 | 8204 | ||
9254 | 8205 | ||
9255 | try { | 8206 | try { |
9256 | // InternalSolverLanguage.g:3223:68: (iv_ruleLowerBoundedScopeDefinition= ruleLowerBoundedScopeDefinition EOF ) | 8207 | // InternalSolverLanguageParser.g:3186:68: (iv_ruleLowerBoundedScopeDefinition= ruleLowerBoundedScopeDefinition EOF ) |
9257 | // InternalSolverLanguage.g:3224:2: iv_ruleLowerBoundedScopeDefinition= ruleLowerBoundedScopeDefinition EOF | 8208 | // InternalSolverLanguageParser.g:3187:2: iv_ruleLowerBoundedScopeDefinition= ruleLowerBoundedScopeDefinition EOF |
9258 | { | 8209 | { |
9259 | if ( state.backtracking==0 ) { | 8210 | newCompositeNode(grammarAccess.getLowerBoundedScopeDefinitionRule()); |
9260 | newCompositeNode(grammarAccess.getLowerBoundedScopeDefinitionRule()); | ||
9261 | } | ||
9262 | pushFollow(FOLLOW_1); | 8211 | pushFollow(FOLLOW_1); |
9263 | iv_ruleLowerBoundedScopeDefinition=ruleLowerBoundedScopeDefinition(); | 8212 | iv_ruleLowerBoundedScopeDefinition=ruleLowerBoundedScopeDefinition(); |
9264 | 8213 | ||
9265 | state._fsp--; | 8214 | state._fsp--; |
9266 | if (state.failed) return current; | 8215 | |
9267 | if ( state.backtracking==0 ) { | 8216 | current =iv_ruleLowerBoundedScopeDefinition; |
9268 | current =iv_ruleLowerBoundedScopeDefinition; | 8217 | match(input,EOF,FOLLOW_2); |
9269 | } | ||
9270 | match(input,EOF,FOLLOW_2); if (state.failed) return current; | ||
9271 | 8218 | ||
9272 | } | 8219 | } |
9273 | 8220 | ||
@@ -9285,7 +8232,7 @@ public class InternalSolverLanguageParser extends AbstractInternalAntlrParser { | |||
9285 | 8232 | ||
9286 | 8233 | ||
9287 | // $ANTLR start "ruleLowerBoundedScopeDefinition" | 8234 | // $ANTLR start "ruleLowerBoundedScopeDefinition" |
9288 | // InternalSolverLanguage.g:3230:1: ruleLowerBoundedScopeDefinition returns [EObject current=null] : (otherlv_0= 'scope' ( ( ( (lv_lowerBound_1_0= RULE_INT ) ) otherlv_2= '<=' ( ( ruleQualifiedName ) ) ) | ( ( ( ruleQualifiedName ) ) otherlv_5= '>=' ( (lv_lowerBound_6_0= RULE_INT ) ) ) ) otherlv_7= '.' ) ; | 8235 | // InternalSolverLanguageParser.g:3193:1: ruleLowerBoundedScopeDefinition returns [EObject current=null] : (otherlv_0= Scope ( ( ( (lv_lowerBound_1_0= RULE_INT ) ) otherlv_2= LessThanSignEqualsSign ( ( ruleQualifiedName ) ) ) | ( ( ( ruleQualifiedName ) ) otherlv_5= GreaterThanSignEqualsSign ( (lv_lowerBound_6_0= RULE_INT ) ) ) ) ) ; |
9289 | public final EObject ruleLowerBoundedScopeDefinition() throws RecognitionException { | 8236 | public final EObject ruleLowerBoundedScopeDefinition() throws RecognitionException { |
9290 | EObject current = null; | 8237 | EObject current = null; |
9291 | 8238 | ||
@@ -9294,112 +8241,96 @@ public class InternalSolverLanguageParser extends AbstractInternalAntlrParser { | |||
9294 | Token otherlv_2=null; | 8241 | Token otherlv_2=null; |
9295 | Token otherlv_5=null; | 8242 | Token otherlv_5=null; |
9296 | Token lv_lowerBound_6_0=null; | 8243 | Token lv_lowerBound_6_0=null; |
9297 | Token otherlv_7=null; | ||
9298 | 8244 | ||
9299 | 8245 | ||
9300 | enterRule(); | 8246 | enterRule(); |
9301 | 8247 | ||
9302 | try { | 8248 | try { |
9303 | // InternalSolverLanguage.g:3236:2: ( (otherlv_0= 'scope' ( ( ( (lv_lowerBound_1_0= RULE_INT ) ) otherlv_2= '<=' ( ( ruleQualifiedName ) ) ) | ( ( ( ruleQualifiedName ) ) otherlv_5= '>=' ( (lv_lowerBound_6_0= RULE_INT ) ) ) ) otherlv_7= '.' ) ) | 8249 | // InternalSolverLanguageParser.g:3199:2: ( (otherlv_0= Scope ( ( ( (lv_lowerBound_1_0= RULE_INT ) ) otherlv_2= LessThanSignEqualsSign ( ( ruleQualifiedName ) ) ) | ( ( ( ruleQualifiedName ) ) otherlv_5= GreaterThanSignEqualsSign ( (lv_lowerBound_6_0= RULE_INT ) ) ) ) ) ) |
9304 | // InternalSolverLanguage.g:3237:2: (otherlv_0= 'scope' ( ( ( (lv_lowerBound_1_0= RULE_INT ) ) otherlv_2= '<=' ( ( ruleQualifiedName ) ) ) | ( ( ( ruleQualifiedName ) ) otherlv_5= '>=' ( (lv_lowerBound_6_0= RULE_INT ) ) ) ) otherlv_7= '.' ) | 8250 | // InternalSolverLanguageParser.g:3200:2: (otherlv_0= Scope ( ( ( (lv_lowerBound_1_0= RULE_INT ) ) otherlv_2= LessThanSignEqualsSign ( ( ruleQualifiedName ) ) ) | ( ( ( ruleQualifiedName ) ) otherlv_5= GreaterThanSignEqualsSign ( (lv_lowerBound_6_0= RULE_INT ) ) ) ) ) |
9305 | { | 8251 | { |
9306 | // InternalSolverLanguage.g:3237:2: (otherlv_0= 'scope' ( ( ( (lv_lowerBound_1_0= RULE_INT ) ) otherlv_2= '<=' ( ( ruleQualifiedName ) ) ) | ( ( ( ruleQualifiedName ) ) otherlv_5= '>=' ( (lv_lowerBound_6_0= RULE_INT ) ) ) ) otherlv_7= '.' ) | 8252 | // InternalSolverLanguageParser.g:3200:2: (otherlv_0= Scope ( ( ( (lv_lowerBound_1_0= RULE_INT ) ) otherlv_2= LessThanSignEqualsSign ( ( ruleQualifiedName ) ) ) | ( ( ( ruleQualifiedName ) ) otherlv_5= GreaterThanSignEqualsSign ( (lv_lowerBound_6_0= RULE_INT ) ) ) ) ) |
9307 | // InternalSolverLanguage.g:3238:3: otherlv_0= 'scope' ( ( ( (lv_lowerBound_1_0= RULE_INT ) ) otherlv_2= '<=' ( ( ruleQualifiedName ) ) ) | ( ( ( ruleQualifiedName ) ) otherlv_5= '>=' ( (lv_lowerBound_6_0= RULE_INT ) ) ) ) otherlv_7= '.' | 8253 | // InternalSolverLanguageParser.g:3201:3: otherlv_0= Scope ( ( ( (lv_lowerBound_1_0= RULE_INT ) ) otherlv_2= LessThanSignEqualsSign ( ( ruleQualifiedName ) ) ) | ( ( ( ruleQualifiedName ) ) otherlv_5= GreaterThanSignEqualsSign ( (lv_lowerBound_6_0= RULE_INT ) ) ) ) |
9308 | { | 8254 | { |
9309 | otherlv_0=(Token)match(input,46,FOLLOW_49); if (state.failed) return current; | 8255 | otherlv_0=(Token)match(input,Scope,FOLLOW_47); |
9310 | if ( state.backtracking==0 ) { | ||
9311 | 8256 | ||
9312 | newLeafNode(otherlv_0, grammarAccess.getLowerBoundedScopeDefinitionAccess().getScopeKeyword_0()); | 8257 | newLeafNode(otherlv_0, grammarAccess.getLowerBoundedScopeDefinitionAccess().getScopeKeyword_0()); |
9313 | 8258 | ||
9314 | } | 8259 | // InternalSolverLanguageParser.g:3205:3: ( ( ( (lv_lowerBound_1_0= RULE_INT ) ) otherlv_2= LessThanSignEqualsSign ( ( ruleQualifiedName ) ) ) | ( ( ( ruleQualifiedName ) ) otherlv_5= GreaterThanSignEqualsSign ( (lv_lowerBound_6_0= RULE_INT ) ) ) ) |
9315 | // InternalSolverLanguage.g:3242:3: ( ( ( (lv_lowerBound_1_0= RULE_INT ) ) otherlv_2= '<=' ( ( ruleQualifiedName ) ) ) | ( ( ( ruleQualifiedName ) ) otherlv_5= '>=' ( (lv_lowerBound_6_0= RULE_INT ) ) ) ) | 8260 | int alt39=2; |
9316 | int alt40=2; | 8261 | int LA39_0 = input.LA(1); |
9317 | int LA40_0 = input.LA(1); | ||
9318 | 8262 | ||
9319 | if ( (LA40_0==RULE_INT) ) { | 8263 | if ( (LA39_0==RULE_INT) ) { |
9320 | alt40=1; | 8264 | alt39=1; |
9321 | } | 8265 | } |
9322 | else if ( (LA40_0==RULE_ID||LA40_0==RULE_QUOTED_ID) ) { | 8266 | else if ( (LA39_0==RULE_QUOTED_ID||LA39_0==RULE_ID) ) { |
9323 | alt40=2; | 8267 | alt39=2; |
9324 | } | 8268 | } |
9325 | else { | 8269 | else { |
9326 | if (state.backtracking>0) {state.failed=true; return current;} | ||
9327 | NoViableAltException nvae = | 8270 | NoViableAltException nvae = |
9328 | new NoViableAltException("", 40, 0, input); | 8271 | new NoViableAltException("", 39, 0, input); |
9329 | 8272 | ||
9330 | throw nvae; | 8273 | throw nvae; |
9331 | } | 8274 | } |
9332 | switch (alt40) { | 8275 | switch (alt39) { |
9333 | case 1 : | 8276 | case 1 : |
9334 | // InternalSolverLanguage.g:3243:4: ( ( (lv_lowerBound_1_0= RULE_INT ) ) otherlv_2= '<=' ( ( ruleQualifiedName ) ) ) | 8277 | // InternalSolverLanguageParser.g:3206:4: ( ( (lv_lowerBound_1_0= RULE_INT ) ) otherlv_2= LessThanSignEqualsSign ( ( ruleQualifiedName ) ) ) |
9335 | { | 8278 | { |
9336 | // InternalSolverLanguage.g:3243:4: ( ( (lv_lowerBound_1_0= RULE_INT ) ) otherlv_2= '<=' ( ( ruleQualifiedName ) ) ) | 8279 | // InternalSolverLanguageParser.g:3206:4: ( ( (lv_lowerBound_1_0= RULE_INT ) ) otherlv_2= LessThanSignEqualsSign ( ( ruleQualifiedName ) ) ) |
9337 | // InternalSolverLanguage.g:3244:5: ( (lv_lowerBound_1_0= RULE_INT ) ) otherlv_2= '<=' ( ( ruleQualifiedName ) ) | 8280 | // InternalSolverLanguageParser.g:3207:5: ( (lv_lowerBound_1_0= RULE_INT ) ) otherlv_2= LessThanSignEqualsSign ( ( ruleQualifiedName ) ) |
9338 | { | 8281 | { |
9339 | // InternalSolverLanguage.g:3244:5: ( (lv_lowerBound_1_0= RULE_INT ) ) | 8282 | // InternalSolverLanguageParser.g:3207:5: ( (lv_lowerBound_1_0= RULE_INT ) ) |
9340 | // InternalSolverLanguage.g:3245:6: (lv_lowerBound_1_0= RULE_INT ) | 8283 | // InternalSolverLanguageParser.g:3208:6: (lv_lowerBound_1_0= RULE_INT ) |
9341 | { | 8284 | { |
9342 | // InternalSolverLanguage.g:3245:6: (lv_lowerBound_1_0= RULE_INT ) | 8285 | // InternalSolverLanguageParser.g:3208:6: (lv_lowerBound_1_0= RULE_INT ) |
9343 | // InternalSolverLanguage.g:3246:7: lv_lowerBound_1_0= RULE_INT | 8286 | // InternalSolverLanguageParser.g:3209:7: lv_lowerBound_1_0= RULE_INT |
9344 | { | 8287 | { |
9345 | lv_lowerBound_1_0=(Token)match(input,RULE_INT,FOLLOW_50); if (state.failed) return current; | 8288 | lv_lowerBound_1_0=(Token)match(input,RULE_INT,FOLLOW_48); |
9346 | if ( state.backtracking==0 ) { | ||
9347 | 8289 | ||
9348 | newLeafNode(lv_lowerBound_1_0, grammarAccess.getLowerBoundedScopeDefinitionAccess().getLowerBoundINTTerminalRuleCall_1_0_0_0()); | 8290 | newLeafNode(lv_lowerBound_1_0, grammarAccess.getLowerBoundedScopeDefinitionAccess().getLowerBoundINTTerminalRuleCall_1_0_0_0()); |
9349 | 8291 | ||
9350 | } | ||
9351 | if ( state.backtracking==0 ) { | ||
9352 | 8292 | ||
9353 | if (current==null) { | 8293 | if (current==null) { |
9354 | current = createModelElement(grammarAccess.getLowerBoundedScopeDefinitionRule()); | 8294 | current = createModelElement(grammarAccess.getLowerBoundedScopeDefinitionRule()); |
9355 | } | 8295 | } |
9356 | setWithLastConsumed( | 8296 | setWithLastConsumed( |
9357 | current, | 8297 | current, |
9358 | "lowerBound", | 8298 | "lowerBound", |
9359 | lv_lowerBound_1_0, | 8299 | lv_lowerBound_1_0, |
9360 | "org.eclipse.xtext.common.Terminals.INT"); | 8300 | "org.eclipse.xtext.common.Terminals.INT"); |
9361 | 8301 | ||
9362 | } | ||
9363 | 8302 | ||
9364 | } | 8303 | } |
9365 | 8304 | ||
9366 | 8305 | ||
9367 | } | 8306 | } |
9368 | 8307 | ||
9369 | otherlv_2=(Token)match(input,48,FOLLOW_35); if (state.failed) return current; | 8308 | otherlv_2=(Token)match(input,LessThanSignEqualsSign,FOLLOW_8); |
9370 | if ( state.backtracking==0 ) { | ||
9371 | 8309 | ||
9372 | newLeafNode(otherlv_2, grammarAccess.getLowerBoundedScopeDefinitionAccess().getLessThanSignEqualsSignKeyword_1_0_1()); | 8310 | newLeafNode(otherlv_2, grammarAccess.getLowerBoundedScopeDefinitionAccess().getLessThanSignEqualsSignKeyword_1_0_1()); |
9373 | 8311 | ||
9374 | } | 8312 | // InternalSolverLanguageParser.g:3229:5: ( ( ruleQualifiedName ) ) |
9375 | // InternalSolverLanguage.g:3266:5: ( ( ruleQualifiedName ) ) | 8313 | // InternalSolverLanguageParser.g:3230:6: ( ruleQualifiedName ) |
9376 | // InternalSolverLanguage.g:3267:6: ( ruleQualifiedName ) | ||
9377 | { | 8314 | { |
9378 | // InternalSolverLanguage.g:3267:6: ( ruleQualifiedName ) | 8315 | // InternalSolverLanguageParser.g:3230:6: ( ruleQualifiedName ) |
9379 | // InternalSolverLanguage.g:3268:7: ruleQualifiedName | 8316 | // InternalSolverLanguageParser.g:3231:7: ruleQualifiedName |
9380 | { | 8317 | { |
9381 | if ( state.backtracking==0 ) { | ||
9382 | 8318 | ||
9383 | if (current==null) { | 8319 | if (current==null) { |
9384 | current = createModelElement(grammarAccess.getLowerBoundedScopeDefinitionRule()); | 8320 | current = createModelElement(grammarAccess.getLowerBoundedScopeDefinitionRule()); |
9385 | } | 8321 | } |
9386 | 8322 | ||
9387 | } | ||
9388 | if ( state.backtracking==0 ) { | ||
9389 | 8323 | ||
9390 | newCompositeNode(grammarAccess.getLowerBoundedScopeDefinitionAccess().getTypeNamedElementCrossReference_1_0_2_0()); | 8324 | newCompositeNode(grammarAccess.getLowerBoundedScopeDefinitionAccess().getTypeNamedElementCrossReference_1_0_2_0()); |
9391 | 8325 | ||
9392 | } | 8326 | pushFollow(FOLLOW_2); |
9393 | pushFollow(FOLLOW_12); | ||
9394 | ruleQualifiedName(); | 8327 | ruleQualifiedName(); |
9395 | 8328 | ||
9396 | state._fsp--; | 8329 | state._fsp--; |
9397 | if (state.failed) return current; | ||
9398 | if ( state.backtracking==0 ) { | ||
9399 | 8330 | ||
9400 | afterParserOrEnumRuleCall(); | 8331 | |
9401 | 8332 | afterParserOrEnumRuleCall(); | |
9402 | } | 8333 | |
9403 | 8334 | ||
9404 | } | 8335 | } |
9405 | 8336 | ||
@@ -9413,75 +8344,63 @@ public class InternalSolverLanguageParser extends AbstractInternalAntlrParser { | |||
9413 | } | 8344 | } |
9414 | break; | 8345 | break; |
9415 | case 2 : | 8346 | case 2 : |
9416 | // InternalSolverLanguage.g:3284:4: ( ( ( ruleQualifiedName ) ) otherlv_5= '>=' ( (lv_lowerBound_6_0= RULE_INT ) ) ) | 8347 | // InternalSolverLanguageParser.g:3247:4: ( ( ( ruleQualifiedName ) ) otherlv_5= GreaterThanSignEqualsSign ( (lv_lowerBound_6_0= RULE_INT ) ) ) |
9417 | { | 8348 | { |
9418 | // InternalSolverLanguage.g:3284:4: ( ( ( ruleQualifiedName ) ) otherlv_5= '>=' ( (lv_lowerBound_6_0= RULE_INT ) ) ) | 8349 | // InternalSolverLanguageParser.g:3247:4: ( ( ( ruleQualifiedName ) ) otherlv_5= GreaterThanSignEqualsSign ( (lv_lowerBound_6_0= RULE_INT ) ) ) |
9419 | // InternalSolverLanguage.g:3285:5: ( ( ruleQualifiedName ) ) otherlv_5= '>=' ( (lv_lowerBound_6_0= RULE_INT ) ) | 8350 | // InternalSolverLanguageParser.g:3248:5: ( ( ruleQualifiedName ) ) otherlv_5= GreaterThanSignEqualsSign ( (lv_lowerBound_6_0= RULE_INT ) ) |
9420 | { | 8351 | { |
9421 | // InternalSolverLanguage.g:3285:5: ( ( ruleQualifiedName ) ) | 8352 | // InternalSolverLanguageParser.g:3248:5: ( ( ruleQualifiedName ) ) |
9422 | // InternalSolverLanguage.g:3286:6: ( ruleQualifiedName ) | 8353 | // InternalSolverLanguageParser.g:3249:6: ( ruleQualifiedName ) |
9423 | { | 8354 | { |
9424 | // InternalSolverLanguage.g:3286:6: ( ruleQualifiedName ) | 8355 | // InternalSolverLanguageParser.g:3249:6: ( ruleQualifiedName ) |
9425 | // InternalSolverLanguage.g:3287:7: ruleQualifiedName | 8356 | // InternalSolverLanguageParser.g:3250:7: ruleQualifiedName |
9426 | { | 8357 | { |
9427 | if ( state.backtracking==0 ) { | ||
9428 | 8358 | ||
9429 | if (current==null) { | 8359 | if (current==null) { |
9430 | current = createModelElement(grammarAccess.getLowerBoundedScopeDefinitionRule()); | 8360 | current = createModelElement(grammarAccess.getLowerBoundedScopeDefinitionRule()); |
9431 | } | 8361 | } |
9432 | 8362 | ||
9433 | } | ||
9434 | if ( state.backtracking==0 ) { | ||
9435 | 8363 | ||
9436 | newCompositeNode(grammarAccess.getLowerBoundedScopeDefinitionAccess().getTypeNamedElementCrossReference_1_1_0_0()); | 8364 | newCompositeNode(grammarAccess.getLowerBoundedScopeDefinitionAccess().getTypeNamedElementCrossReference_1_1_0_0()); |
9437 | 8365 | ||
9438 | } | 8366 | pushFollow(FOLLOW_49); |
9439 | pushFollow(FOLLOW_51); | ||
9440 | ruleQualifiedName(); | 8367 | ruleQualifiedName(); |
9441 | 8368 | ||
9442 | state._fsp--; | 8369 | state._fsp--; |
9443 | if (state.failed) return current; | ||
9444 | if ( state.backtracking==0 ) { | ||
9445 | 8370 | ||
9446 | afterParserOrEnumRuleCall(); | 8371 | |
9447 | 8372 | afterParserOrEnumRuleCall(); | |
9448 | } | 8373 | |
9449 | 8374 | ||
9450 | } | 8375 | } |
9451 | 8376 | ||
9452 | 8377 | ||
9453 | } | 8378 | } |
9454 | 8379 | ||
9455 | otherlv_5=(Token)match(input,49,FOLLOW_47); if (state.failed) return current; | 8380 | otherlv_5=(Token)match(input,GreaterThanSignEqualsSign,FOLLOW_45); |
9456 | if ( state.backtracking==0 ) { | ||
9457 | 8381 | ||
9458 | newLeafNode(otherlv_5, grammarAccess.getLowerBoundedScopeDefinitionAccess().getGreaterThanSignEqualsSignKeyword_1_1_1()); | 8382 | newLeafNode(otherlv_5, grammarAccess.getLowerBoundedScopeDefinitionAccess().getGreaterThanSignEqualsSignKeyword_1_1_1()); |
9459 | 8383 | ||
9460 | } | 8384 | // InternalSolverLanguageParser.g:3268:5: ( (lv_lowerBound_6_0= RULE_INT ) ) |
9461 | // InternalSolverLanguage.g:3305:5: ( (lv_lowerBound_6_0= RULE_INT ) ) | 8385 | // InternalSolverLanguageParser.g:3269:6: (lv_lowerBound_6_0= RULE_INT ) |
9462 | // InternalSolverLanguage.g:3306:6: (lv_lowerBound_6_0= RULE_INT ) | ||
9463 | { | 8386 | { |
9464 | // InternalSolverLanguage.g:3306:6: (lv_lowerBound_6_0= RULE_INT ) | 8387 | // InternalSolverLanguageParser.g:3269:6: (lv_lowerBound_6_0= RULE_INT ) |
9465 | // InternalSolverLanguage.g:3307:7: lv_lowerBound_6_0= RULE_INT | 8388 | // InternalSolverLanguageParser.g:3270:7: lv_lowerBound_6_0= RULE_INT |
9466 | { | 8389 | { |
9467 | lv_lowerBound_6_0=(Token)match(input,RULE_INT,FOLLOW_12); if (state.failed) return current; | 8390 | lv_lowerBound_6_0=(Token)match(input,RULE_INT,FOLLOW_2); |
9468 | if ( state.backtracking==0 ) { | ||
9469 | 8391 | ||
9470 | newLeafNode(lv_lowerBound_6_0, grammarAccess.getLowerBoundedScopeDefinitionAccess().getLowerBoundINTTerminalRuleCall_1_1_2_0()); | 8392 | newLeafNode(lv_lowerBound_6_0, grammarAccess.getLowerBoundedScopeDefinitionAccess().getLowerBoundINTTerminalRuleCall_1_1_2_0()); |
9471 | 8393 | ||
9472 | } | ||
9473 | if ( state.backtracking==0 ) { | ||
9474 | 8394 | ||
9475 | if (current==null) { | 8395 | if (current==null) { |
9476 | current = createModelElement(grammarAccess.getLowerBoundedScopeDefinitionRule()); | 8396 | current = createModelElement(grammarAccess.getLowerBoundedScopeDefinitionRule()); |
9477 | } | 8397 | } |
9478 | setWithLastConsumed( | 8398 | setWithLastConsumed( |
9479 | current, | 8399 | current, |
9480 | "lowerBound", | 8400 | "lowerBound", |
9481 | lv_lowerBound_6_0, | 8401 | lv_lowerBound_6_0, |
9482 | "org.eclipse.xtext.common.Terminals.INT"); | 8402 | "org.eclipse.xtext.common.Terminals.INT"); |
9483 | 8403 | ||
9484 | } | ||
9485 | 8404 | ||
9486 | } | 8405 | } |
9487 | 8406 | ||
@@ -9497,23 +8416,15 @@ public class InternalSolverLanguageParser extends AbstractInternalAntlrParser { | |||
9497 | 8416 | ||
9498 | } | 8417 | } |
9499 | 8418 | ||
9500 | otherlv_7=(Token)match(input,22,FOLLOW_2); if (state.failed) return current; | ||
9501 | if ( state.backtracking==0 ) { | ||
9502 | |||
9503 | newLeafNode(otherlv_7, grammarAccess.getLowerBoundedScopeDefinitionAccess().getFullStopKeyword_2()); | ||
9504 | |||
9505 | } | ||
9506 | 8419 | ||
9507 | } | 8420 | } |
9508 | 8421 | ||
9509 | 8422 | ||
9510 | } | 8423 | } |
9511 | 8424 | ||
9512 | if ( state.backtracking==0 ) { | ||
9513 | 8425 | ||
9514 | leaveRule(); | 8426 | leaveRule(); |
9515 | 8427 | ||
9516 | } | ||
9517 | } | 8428 | } |
9518 | 8429 | ||
9519 | catch (RecognitionException re) { | 8430 | catch (RecognitionException re) { |
@@ -9528,7 +8439,7 @@ public class InternalSolverLanguageParser extends AbstractInternalAntlrParser { | |||
9528 | 8439 | ||
9529 | 8440 | ||
9530 | // $ANTLR start "entryRuleObjectiveDefinition" | 8441 | // $ANTLR start "entryRuleObjectiveDefinition" |
9531 | // InternalSolverLanguage.g:3333:1: entryRuleObjectiveDefinition returns [EObject current=null] : iv_ruleObjectiveDefinition= ruleObjectiveDefinition EOF ; | 8442 | // InternalSolverLanguageParser.g:3292:1: entryRuleObjectiveDefinition returns [EObject current=null] : iv_ruleObjectiveDefinition= ruleObjectiveDefinition EOF ; |
9532 | public final EObject entryRuleObjectiveDefinition() throws RecognitionException { | 8443 | public final EObject entryRuleObjectiveDefinition() throws RecognitionException { |
9533 | EObject current = null; | 8444 | EObject current = null; |
9534 | 8445 | ||
@@ -9536,21 +8447,17 @@ public class InternalSolverLanguageParser extends AbstractInternalAntlrParser { | |||
9536 | 8447 | ||
9537 | 8448 | ||
9538 | try { | 8449 | try { |
9539 | // InternalSolverLanguage.g:3333:60: (iv_ruleObjectiveDefinition= ruleObjectiveDefinition EOF ) | 8450 | // InternalSolverLanguageParser.g:3292:60: (iv_ruleObjectiveDefinition= ruleObjectiveDefinition EOF ) |
9540 | // InternalSolverLanguage.g:3334:2: iv_ruleObjectiveDefinition= ruleObjectiveDefinition EOF | 8451 | // InternalSolverLanguageParser.g:3293:2: iv_ruleObjectiveDefinition= ruleObjectiveDefinition EOF |
9541 | { | 8452 | { |
9542 | if ( state.backtracking==0 ) { | 8453 | newCompositeNode(grammarAccess.getObjectiveDefinitionRule()); |
9543 | newCompositeNode(grammarAccess.getObjectiveDefinitionRule()); | ||
9544 | } | ||
9545 | pushFollow(FOLLOW_1); | 8454 | pushFollow(FOLLOW_1); |
9546 | iv_ruleObjectiveDefinition=ruleObjectiveDefinition(); | 8455 | iv_ruleObjectiveDefinition=ruleObjectiveDefinition(); |
9547 | 8456 | ||
9548 | state._fsp--; | 8457 | state._fsp--; |
9549 | if (state.failed) return current; | 8458 | |
9550 | if ( state.backtracking==0 ) { | 8459 | current =iv_ruleObjectiveDefinition; |
9551 | current =iv_ruleObjectiveDefinition; | 8460 | match(input,EOF,FOLLOW_2); |
9552 | } | ||
9553 | match(input,EOF,FOLLOW_2); if (state.failed) return current; | ||
9554 | 8461 | ||
9555 | } | 8462 | } |
9556 | 8463 | ||
@@ -9568,7 +8475,7 @@ public class InternalSolverLanguageParser extends AbstractInternalAntlrParser { | |||
9568 | 8475 | ||
9569 | 8476 | ||
9570 | // $ANTLR start "ruleObjectiveDefinition" | 8477 | // $ANTLR start "ruleObjectiveDefinition" |
9571 | // InternalSolverLanguage.g:3340:1: ruleObjectiveDefinition returns [EObject current=null] : ( ( (lv_kind_0_0= ruleObjectiveKind ) ) ( (lv_objective_1_0= ruleExpression ) ) ) ; | 8478 | // InternalSolverLanguageParser.g:3299:1: ruleObjectiveDefinition returns [EObject current=null] : ( ( (lv_kind_0_0= ruleObjectiveKind ) ) ( (lv_objective_1_0= ruleExpression ) ) ) ; |
9572 | public final EObject ruleObjectiveDefinition() throws RecognitionException { | 8479 | public final EObject ruleObjectiveDefinition() throws RecognitionException { |
9573 | EObject current = null; | 8480 | EObject current = null; |
9574 | 8481 | ||
@@ -9581,76 +8488,68 @@ public class InternalSolverLanguageParser extends AbstractInternalAntlrParser { | |||
9581 | enterRule(); | 8488 | enterRule(); |
9582 | 8489 | ||
9583 | try { | 8490 | try { |
9584 | // InternalSolverLanguage.g:3346:2: ( ( ( (lv_kind_0_0= ruleObjectiveKind ) ) ( (lv_objective_1_0= ruleExpression ) ) ) ) | 8491 | // InternalSolverLanguageParser.g:3305:2: ( ( ( (lv_kind_0_0= ruleObjectiveKind ) ) ( (lv_objective_1_0= ruleExpression ) ) ) ) |
9585 | // InternalSolverLanguage.g:3347:2: ( ( (lv_kind_0_0= ruleObjectiveKind ) ) ( (lv_objective_1_0= ruleExpression ) ) ) | 8492 | // InternalSolverLanguageParser.g:3306:2: ( ( (lv_kind_0_0= ruleObjectiveKind ) ) ( (lv_objective_1_0= ruleExpression ) ) ) |
9586 | { | 8493 | { |
9587 | // InternalSolverLanguage.g:3347:2: ( ( (lv_kind_0_0= ruleObjectiveKind ) ) ( (lv_objective_1_0= ruleExpression ) ) ) | 8494 | // InternalSolverLanguageParser.g:3306:2: ( ( (lv_kind_0_0= ruleObjectiveKind ) ) ( (lv_objective_1_0= ruleExpression ) ) ) |
9588 | // InternalSolverLanguage.g:3348:3: ( (lv_kind_0_0= ruleObjectiveKind ) ) ( (lv_objective_1_0= ruleExpression ) ) | 8495 | // InternalSolverLanguageParser.g:3307:3: ( (lv_kind_0_0= ruleObjectiveKind ) ) ( (lv_objective_1_0= ruleExpression ) ) |
9589 | { | 8496 | { |
9590 | // InternalSolverLanguage.g:3348:3: ( (lv_kind_0_0= ruleObjectiveKind ) ) | 8497 | // InternalSolverLanguageParser.g:3307:3: ( (lv_kind_0_0= ruleObjectiveKind ) ) |
9591 | // InternalSolverLanguage.g:3349:4: (lv_kind_0_0= ruleObjectiveKind ) | 8498 | // InternalSolverLanguageParser.g:3308:4: (lv_kind_0_0= ruleObjectiveKind ) |
9592 | { | 8499 | { |
9593 | // InternalSolverLanguage.g:3349:4: (lv_kind_0_0= ruleObjectiveKind ) | 8500 | // InternalSolverLanguageParser.g:3308:4: (lv_kind_0_0= ruleObjectiveKind ) |
9594 | // InternalSolverLanguage.g:3350:5: lv_kind_0_0= ruleObjectiveKind | 8501 | // InternalSolverLanguageParser.g:3309:5: lv_kind_0_0= ruleObjectiveKind |
9595 | { | 8502 | { |
9596 | if ( state.backtracking==0 ) { | ||
9597 | 8503 | ||
9598 | newCompositeNode(grammarAccess.getObjectiveDefinitionAccess().getKindObjectiveKindEnumRuleCall_0_0()); | 8504 | newCompositeNode(grammarAccess.getObjectiveDefinitionAccess().getKindObjectiveKindEnumRuleCall_0_0()); |
9599 | 8505 | ||
9600 | } | ||
9601 | pushFollow(FOLLOW_6); | 8506 | pushFollow(FOLLOW_6); |
9602 | lv_kind_0_0=ruleObjectiveKind(); | 8507 | lv_kind_0_0=ruleObjectiveKind(); |
9603 | 8508 | ||
9604 | state._fsp--; | 8509 | state._fsp--; |
9605 | if (state.failed) return current; | ||
9606 | if ( state.backtracking==0 ) { | ||
9607 | 8510 | ||
9608 | if (current==null) { | 8511 | |
9609 | current = createModelElementForParent(grammarAccess.getObjectiveDefinitionRule()); | 8512 | if (current==null) { |
9610 | } | 8513 | current = createModelElementForParent(grammarAccess.getObjectiveDefinitionRule()); |
9611 | set( | 8514 | } |
9612 | current, | 8515 | set( |
9613 | "kind", | 8516 | current, |
9614 | lv_kind_0_0, | 8517 | "kind", |
9615 | "org.eclipse.viatra.solver.language.SolverLanguage.ObjectiveKind"); | 8518 | lv_kind_0_0, |
9616 | afterParserOrEnumRuleCall(); | 8519 | "org.eclipse.viatra.solver.language.SolverLanguage.ObjectiveKind"); |
9617 | 8520 | afterParserOrEnumRuleCall(); | |
9618 | } | 8521 | |
9619 | 8522 | ||
9620 | } | 8523 | } |
9621 | 8524 | ||
9622 | 8525 | ||
9623 | } | 8526 | } |
9624 | 8527 | ||
9625 | // InternalSolverLanguage.g:3367:3: ( (lv_objective_1_0= ruleExpression ) ) | 8528 | // InternalSolverLanguageParser.g:3326:3: ( (lv_objective_1_0= ruleExpression ) ) |
9626 | // InternalSolverLanguage.g:3368:4: (lv_objective_1_0= ruleExpression ) | 8529 | // InternalSolverLanguageParser.g:3327:4: (lv_objective_1_0= ruleExpression ) |
9627 | { | 8530 | { |
9628 | // InternalSolverLanguage.g:3368:4: (lv_objective_1_0= ruleExpression ) | 8531 | // InternalSolverLanguageParser.g:3327:4: (lv_objective_1_0= ruleExpression ) |
9629 | // InternalSolverLanguage.g:3369:5: lv_objective_1_0= ruleExpression | 8532 | // InternalSolverLanguageParser.g:3328:5: lv_objective_1_0= ruleExpression |
9630 | { | 8533 | { |
9631 | if ( state.backtracking==0 ) { | ||
9632 | 8534 | ||
9633 | newCompositeNode(grammarAccess.getObjectiveDefinitionAccess().getObjectiveExpressionParserRuleCall_1_0()); | 8535 | newCompositeNode(grammarAccess.getObjectiveDefinitionAccess().getObjectiveExpressionParserRuleCall_1_0()); |
9634 | 8536 | ||
9635 | } | ||
9636 | pushFollow(FOLLOW_2); | 8537 | pushFollow(FOLLOW_2); |
9637 | lv_objective_1_0=ruleExpression(); | 8538 | lv_objective_1_0=ruleExpression(); |
9638 | 8539 | ||
9639 | state._fsp--; | 8540 | state._fsp--; |
9640 | if (state.failed) return current; | ||
9641 | if ( state.backtracking==0 ) { | ||
9642 | 8541 | ||
9643 | if (current==null) { | 8542 | |
9644 | current = createModelElementForParent(grammarAccess.getObjectiveDefinitionRule()); | 8543 | if (current==null) { |
9645 | } | 8544 | current = createModelElementForParent(grammarAccess.getObjectiveDefinitionRule()); |
9646 | set( | 8545 | } |
9647 | current, | 8546 | set( |
9648 | "objective", | 8547 | current, |
9649 | lv_objective_1_0, | 8548 | "objective", |
9650 | "org.eclipse.viatra.solver.language.SolverLanguage.Expression"); | 8549 | lv_objective_1_0, |
9651 | afterParserOrEnumRuleCall(); | 8550 | "org.eclipse.viatra.solver.language.SolverLanguage.Expression"); |
9652 | 8551 | afterParserOrEnumRuleCall(); | |
9653 | } | 8552 | |
9654 | 8553 | ||
9655 | } | 8554 | } |
9656 | 8555 | ||
@@ -9663,11 +8562,9 @@ public class InternalSolverLanguageParser extends AbstractInternalAntlrParser { | |||
9663 | 8562 | ||
9664 | } | 8563 | } |
9665 | 8564 | ||
9666 | if ( state.backtracking==0 ) { | ||
9667 | 8565 | ||
9668 | leaveRule(); | 8566 | leaveRule(); |
9669 | 8567 | ||
9670 | } | ||
9671 | } | 8568 | } |
9672 | 8569 | ||
9673 | catch (RecognitionException re) { | 8570 | catch (RecognitionException re) { |
@@ -9682,7 +8579,7 @@ public class InternalSolverLanguageParser extends AbstractInternalAntlrParser { | |||
9682 | 8579 | ||
9683 | 8580 | ||
9684 | // $ANTLR start "entryRuleUpperMultiplicty" | 8581 | // $ANTLR start "entryRuleUpperMultiplicty" |
9685 | // InternalSolverLanguage.g:3390:1: entryRuleUpperMultiplicty returns [String current=null] : iv_ruleUpperMultiplicty= ruleUpperMultiplicty EOF ; | 8582 | // InternalSolverLanguageParser.g:3349:1: entryRuleUpperMultiplicty returns [String current=null] : iv_ruleUpperMultiplicty= ruleUpperMultiplicty EOF ; |
9686 | public final String entryRuleUpperMultiplicty() throws RecognitionException { | 8583 | public final String entryRuleUpperMultiplicty() throws RecognitionException { |
9687 | String current = null; | 8584 | String current = null; |
9688 | 8585 | ||
@@ -9690,21 +8587,17 @@ public class InternalSolverLanguageParser extends AbstractInternalAntlrParser { | |||
9690 | 8587 | ||
9691 | 8588 | ||
9692 | try { | 8589 | try { |
9693 | // InternalSolverLanguage.g:3390:56: (iv_ruleUpperMultiplicty= ruleUpperMultiplicty EOF ) | 8590 | // InternalSolverLanguageParser.g:3349:56: (iv_ruleUpperMultiplicty= ruleUpperMultiplicty EOF ) |
9694 | // InternalSolverLanguage.g:3391:2: iv_ruleUpperMultiplicty= ruleUpperMultiplicty EOF | 8591 | // InternalSolverLanguageParser.g:3350:2: iv_ruleUpperMultiplicty= ruleUpperMultiplicty EOF |
9695 | { | 8592 | { |
9696 | if ( state.backtracking==0 ) { | 8593 | newCompositeNode(grammarAccess.getUpperMultiplictyRule()); |
9697 | newCompositeNode(grammarAccess.getUpperMultiplictyRule()); | ||
9698 | } | ||
9699 | pushFollow(FOLLOW_1); | 8594 | pushFollow(FOLLOW_1); |
9700 | iv_ruleUpperMultiplicty=ruleUpperMultiplicty(); | 8595 | iv_ruleUpperMultiplicty=ruleUpperMultiplicty(); |
9701 | 8596 | ||
9702 | state._fsp--; | 8597 | state._fsp--; |
9703 | if (state.failed) return current; | 8598 | |
9704 | if ( state.backtracking==0 ) { | 8599 | current =iv_ruleUpperMultiplicty.getText(); |
9705 | current =iv_ruleUpperMultiplicty.getText(); | 8600 | match(input,EOF,FOLLOW_2); |
9706 | } | ||
9707 | match(input,EOF,FOLLOW_2); if (state.failed) return current; | ||
9708 | 8601 | ||
9709 | } | 8602 | } |
9710 | 8603 | ||
@@ -9722,7 +8615,7 @@ public class InternalSolverLanguageParser extends AbstractInternalAntlrParser { | |||
9722 | 8615 | ||
9723 | 8616 | ||
9724 | // $ANTLR start "ruleUpperMultiplicty" | 8617 | // $ANTLR start "ruleUpperMultiplicty" |
9725 | // InternalSolverLanguage.g:3397:1: ruleUpperMultiplicty returns [AntlrDatatypeRuleToken current=new AntlrDatatypeRuleToken()] : (this_INT_0= RULE_INT | kw= '*' ) ; | 8618 | // InternalSolverLanguageParser.g:3356:1: ruleUpperMultiplicty returns [AntlrDatatypeRuleToken current=new AntlrDatatypeRuleToken()] : (this_INT_0= RULE_INT | kw= Asterisk ) ; |
9726 | public final AntlrDatatypeRuleToken ruleUpperMultiplicty() throws RecognitionException { | 8619 | public final AntlrDatatypeRuleToken ruleUpperMultiplicty() throws RecognitionException { |
9727 | AntlrDatatypeRuleToken current = new AntlrDatatypeRuleToken(); | 8620 | AntlrDatatypeRuleToken current = new AntlrDatatypeRuleToken(); |
9728 | 8621 | ||
@@ -9733,54 +8626,47 @@ public class InternalSolverLanguageParser extends AbstractInternalAntlrParser { | |||
9733 | enterRule(); | 8626 | enterRule(); |
9734 | 8627 | ||
9735 | try { | 8628 | try { |
9736 | // InternalSolverLanguage.g:3403:2: ( (this_INT_0= RULE_INT | kw= '*' ) ) | 8629 | // InternalSolverLanguageParser.g:3362:2: ( (this_INT_0= RULE_INT | kw= Asterisk ) ) |
9737 | // InternalSolverLanguage.g:3404:2: (this_INT_0= RULE_INT | kw= '*' ) | 8630 | // InternalSolverLanguageParser.g:3363:2: (this_INT_0= RULE_INT | kw= Asterisk ) |
9738 | { | 8631 | { |
9739 | // InternalSolverLanguage.g:3404:2: (this_INT_0= RULE_INT | kw= '*' ) | 8632 | // InternalSolverLanguageParser.g:3363:2: (this_INT_0= RULE_INT | kw= Asterisk ) |
9740 | int alt41=2; | 8633 | int alt40=2; |
9741 | int LA41_0 = input.LA(1); | 8634 | int LA40_0 = input.LA(1); |
9742 | 8635 | ||
9743 | if ( (LA41_0==RULE_INT) ) { | 8636 | if ( (LA40_0==RULE_INT) ) { |
9744 | alt41=1; | 8637 | alt40=1; |
9745 | } | 8638 | } |
9746 | else if ( (LA41_0==35) ) { | 8639 | else if ( (LA40_0==Asterisk) ) { |
9747 | alt41=2; | 8640 | alt40=2; |
9748 | } | 8641 | } |
9749 | else { | 8642 | else { |
9750 | if (state.backtracking>0) {state.failed=true; return current;} | ||
9751 | NoViableAltException nvae = | 8643 | NoViableAltException nvae = |
9752 | new NoViableAltException("", 41, 0, input); | 8644 | new NoViableAltException("", 40, 0, input); |
9753 | 8645 | ||
9754 | throw nvae; | 8646 | throw nvae; |
9755 | } | 8647 | } |
9756 | switch (alt41) { | 8648 | switch (alt40) { |
9757 | case 1 : | 8649 | case 1 : |
9758 | // InternalSolverLanguage.g:3405:3: this_INT_0= RULE_INT | 8650 | // InternalSolverLanguageParser.g:3364:3: this_INT_0= RULE_INT |
9759 | { | 8651 | { |
9760 | this_INT_0=(Token)match(input,RULE_INT,FOLLOW_2); if (state.failed) return current; | 8652 | this_INT_0=(Token)match(input,RULE_INT,FOLLOW_2); |
9761 | if ( state.backtracking==0 ) { | ||
9762 | 8653 | ||
9763 | current.merge(this_INT_0); | 8654 | current.merge(this_INT_0); |
9764 | 8655 | ||
9765 | } | ||
9766 | if ( state.backtracking==0 ) { | ||
9767 | 8656 | ||
9768 | newLeafNode(this_INT_0, grammarAccess.getUpperMultiplictyAccess().getINTTerminalRuleCall_0()); | 8657 | newLeafNode(this_INT_0, grammarAccess.getUpperMultiplictyAccess().getINTTerminalRuleCall_0()); |
9769 | 8658 | ||
9770 | } | ||
9771 | 8659 | ||
9772 | } | 8660 | } |
9773 | break; | 8661 | break; |
9774 | case 2 : | 8662 | case 2 : |
9775 | // InternalSolverLanguage.g:3413:3: kw= '*' | 8663 | // InternalSolverLanguageParser.g:3372:3: kw= Asterisk |
9776 | { | 8664 | { |
9777 | kw=(Token)match(input,35,FOLLOW_2); if (state.failed) return current; | 8665 | kw=(Token)match(input,Asterisk,FOLLOW_2); |
9778 | if ( state.backtracking==0 ) { | ||
9779 | 8666 | ||
9780 | current.merge(kw); | 8667 | current.merge(kw); |
9781 | newLeafNode(kw, grammarAccess.getUpperMultiplictyAccess().getAsteriskKeyword_1()); | 8668 | newLeafNode(kw, grammarAccess.getUpperMultiplictyAccess().getAsteriskKeyword_1()); |
9782 | 8669 | ||
9783 | } | ||
9784 | 8670 | ||
9785 | } | 8671 | } |
9786 | break; | 8672 | break; |
@@ -9790,11 +8676,9 @@ public class InternalSolverLanguageParser extends AbstractInternalAntlrParser { | |||
9790 | 8676 | ||
9791 | } | 8677 | } |
9792 | 8678 | ||
9793 | if ( state.backtracking==0 ) { | ||
9794 | 8679 | ||
9795 | leaveRule(); | 8680 | leaveRule(); |
9796 | 8681 | ||
9797 | } | ||
9798 | } | 8682 | } |
9799 | 8683 | ||
9800 | catch (RecognitionException re) { | 8684 | catch (RecognitionException re) { |
@@ -9809,7 +8693,7 @@ public class InternalSolverLanguageParser extends AbstractInternalAntlrParser { | |||
9809 | 8693 | ||
9810 | 8694 | ||
9811 | // $ANTLR start "entryRuleReal" | 8695 | // $ANTLR start "entryRuleReal" |
9812 | // InternalSolverLanguage.g:3422:1: entryRuleReal returns [String current=null] : iv_ruleReal= ruleReal EOF ; | 8696 | // InternalSolverLanguageParser.g:3381:1: entryRuleReal returns [String current=null] : iv_ruleReal= ruleReal EOF ; |
9813 | public final String entryRuleReal() throws RecognitionException { | 8697 | public final String entryRuleReal() throws RecognitionException { |
9814 | String current = null; | 8698 | String current = null; |
9815 | 8699 | ||
@@ -9820,21 +8704,17 @@ public class InternalSolverLanguageParser extends AbstractInternalAntlrParser { | |||
9820 | HiddenTokens myHiddenTokenState = ((XtextTokenStream)input).setHiddenTokens(); | 8704 | HiddenTokens myHiddenTokenState = ((XtextTokenStream)input).setHiddenTokens(); |
9821 | 8705 | ||
9822 | try { | 8706 | try { |
9823 | // InternalSolverLanguage.g:3424:2: (iv_ruleReal= ruleReal EOF ) | 8707 | // InternalSolverLanguageParser.g:3383:2: (iv_ruleReal= ruleReal EOF ) |
9824 | // InternalSolverLanguage.g:3425:2: iv_ruleReal= ruleReal EOF | 8708 | // InternalSolverLanguageParser.g:3384:2: iv_ruleReal= ruleReal EOF |
9825 | { | 8709 | { |
9826 | if ( state.backtracking==0 ) { | 8710 | newCompositeNode(grammarAccess.getRealRule()); |
9827 | newCompositeNode(grammarAccess.getRealRule()); | ||
9828 | } | ||
9829 | pushFollow(FOLLOW_1); | 8711 | pushFollow(FOLLOW_1); |
9830 | iv_ruleReal=ruleReal(); | 8712 | iv_ruleReal=ruleReal(); |
9831 | 8713 | ||
9832 | state._fsp--; | 8714 | state._fsp--; |
9833 | if (state.failed) return current; | 8715 | |
9834 | if ( state.backtracking==0 ) { | 8716 | current =iv_ruleReal.getText(); |
9835 | current =iv_ruleReal.getText(); | 8717 | match(input,EOF,FOLLOW_2); |
9836 | } | ||
9837 | match(input,EOF,FOLLOW_2); if (state.failed) return current; | ||
9838 | 8718 | ||
9839 | } | 8719 | } |
9840 | 8720 | ||
@@ -9855,7 +8735,7 @@ public class InternalSolverLanguageParser extends AbstractInternalAntlrParser { | |||
9855 | 8735 | ||
9856 | 8736 | ||
9857 | // $ANTLR start "ruleReal" | 8737 | // $ANTLR start "ruleReal" |
9858 | // InternalSolverLanguage.g:3434:1: ruleReal returns [AntlrDatatypeRuleToken current=new AntlrDatatypeRuleToken()] : (this_INT_0= RULE_INT (kw= '.' this_INT_2= RULE_INT )? ) ; | 8738 | // InternalSolverLanguageParser.g:3393:1: ruleReal returns [AntlrDatatypeRuleToken current=new AntlrDatatypeRuleToken()] : (this_INT_0= RULE_INT (kw= FullStop this_INT_2= RULE_INT )? ) ; |
9859 | public final AntlrDatatypeRuleToken ruleReal() throws RecognitionException { | 8739 | public final AntlrDatatypeRuleToken ruleReal() throws RecognitionException { |
9860 | AntlrDatatypeRuleToken current = new AntlrDatatypeRuleToken(); | 8740 | AntlrDatatypeRuleToken current = new AntlrDatatypeRuleToken(); |
9861 | 8741 | ||
@@ -9868,52 +8748,42 @@ public class InternalSolverLanguageParser extends AbstractInternalAntlrParser { | |||
9868 | HiddenTokens myHiddenTokenState = ((XtextTokenStream)input).setHiddenTokens(); | 8748 | HiddenTokens myHiddenTokenState = ((XtextTokenStream)input).setHiddenTokens(); |
9869 | 8749 | ||
9870 | try { | 8750 | try { |
9871 | // InternalSolverLanguage.g:3441:2: ( (this_INT_0= RULE_INT (kw= '.' this_INT_2= RULE_INT )? ) ) | 8751 | // InternalSolverLanguageParser.g:3400:2: ( (this_INT_0= RULE_INT (kw= FullStop this_INT_2= RULE_INT )? ) ) |
9872 | // InternalSolverLanguage.g:3442:2: (this_INT_0= RULE_INT (kw= '.' this_INT_2= RULE_INT )? ) | 8752 | // InternalSolverLanguageParser.g:3401:2: (this_INT_0= RULE_INT (kw= FullStop this_INT_2= RULE_INT )? ) |
9873 | { | 8753 | { |
9874 | // InternalSolverLanguage.g:3442:2: (this_INT_0= RULE_INT (kw= '.' this_INT_2= RULE_INT )? ) | 8754 | // InternalSolverLanguageParser.g:3401:2: (this_INT_0= RULE_INT (kw= FullStop this_INT_2= RULE_INT )? ) |
9875 | // InternalSolverLanguage.g:3443:3: this_INT_0= RULE_INT (kw= '.' this_INT_2= RULE_INT )? | 8755 | // InternalSolverLanguageParser.g:3402:3: this_INT_0= RULE_INT (kw= FullStop this_INT_2= RULE_INT )? |
9876 | { | 8756 | { |
9877 | this_INT_0=(Token)match(input,RULE_INT,FOLLOW_53); if (state.failed) return current; | 8757 | this_INT_0=(Token)match(input,RULE_INT,FOLLOW_51); |
9878 | if ( state.backtracking==0 ) { | ||
9879 | 8758 | ||
9880 | current.merge(this_INT_0); | 8759 | current.merge(this_INT_0); |
9881 | 8760 | ||
9882 | } | ||
9883 | if ( state.backtracking==0 ) { | ||
9884 | 8761 | ||
9885 | newLeafNode(this_INT_0, grammarAccess.getRealAccess().getINTTerminalRuleCall_0()); | 8762 | newLeafNode(this_INT_0, grammarAccess.getRealAccess().getINTTerminalRuleCall_0()); |
9886 | 8763 | ||
9887 | } | 8764 | // InternalSolverLanguageParser.g:3409:3: (kw= FullStop this_INT_2= RULE_INT )? |
9888 | // InternalSolverLanguage.g:3450:3: (kw= '.' this_INT_2= RULE_INT )? | 8765 | int alt41=2; |
9889 | int alt42=2; | 8766 | int LA41_0 = input.LA(1); |
9890 | int LA42_0 = input.LA(1); | ||
9891 | 8767 | ||
9892 | if ( (LA42_0==22) ) { | 8768 | if ( (LA41_0==FullStop) ) { |
9893 | alt42=1; | 8769 | alt41=1; |
9894 | } | 8770 | } |
9895 | switch (alt42) { | 8771 | switch (alt41) { |
9896 | case 1 : | 8772 | case 1 : |
9897 | // InternalSolverLanguage.g:3451:4: kw= '.' this_INT_2= RULE_INT | 8773 | // InternalSolverLanguageParser.g:3410:4: kw= FullStop this_INT_2= RULE_INT |
9898 | { | 8774 | { |
9899 | kw=(Token)match(input,22,FOLLOW_47); if (state.failed) return current; | 8775 | kw=(Token)match(input,FullStop,FOLLOW_45); |
9900 | if ( state.backtracking==0 ) { | ||
9901 | 8776 | ||
9902 | current.merge(kw); | 8777 | current.merge(kw); |
9903 | newLeafNode(kw, grammarAccess.getRealAccess().getFullStopKeyword_1_0()); | 8778 | newLeafNode(kw, grammarAccess.getRealAccess().getFullStopKeyword_1_0()); |
9904 | 8779 | ||
9905 | } | 8780 | this_INT_2=(Token)match(input,RULE_INT,FOLLOW_2); |
9906 | this_INT_2=(Token)match(input,RULE_INT,FOLLOW_2); if (state.failed) return current; | ||
9907 | if ( state.backtracking==0 ) { | ||
9908 | 8781 | ||
9909 | current.merge(this_INT_2); | 8782 | current.merge(this_INT_2); |
9910 | 8783 | ||
9911 | } | ||
9912 | if ( state.backtracking==0 ) { | ||
9913 | 8784 | ||
9914 | newLeafNode(this_INT_2, grammarAccess.getRealAccess().getINTTerminalRuleCall_1_1()); | 8785 | newLeafNode(this_INT_2, grammarAccess.getRealAccess().getINTTerminalRuleCall_1_1()); |
9915 | 8786 | ||
9916 | } | ||
9917 | 8787 | ||
9918 | } | 8788 | } |
9919 | break; | 8789 | break; |
@@ -9926,11 +8796,9 @@ public class InternalSolverLanguageParser extends AbstractInternalAntlrParser { | |||
9926 | 8796 | ||
9927 | } | 8797 | } |
9928 | 8798 | ||
9929 | if ( state.backtracking==0 ) { | ||
9930 | 8799 | ||
9931 | leaveRule(); | 8800 | leaveRule(); |
9932 | 8801 | ||
9933 | } | ||
9934 | } | 8802 | } |
9935 | 8803 | ||
9936 | catch (RecognitionException re) { | 8804 | catch (RecognitionException re) { |
@@ -9948,7 +8816,7 @@ public class InternalSolverLanguageParser extends AbstractInternalAntlrParser { | |||
9948 | 8816 | ||
9949 | 8817 | ||
9950 | // $ANTLR start "entryRuleQualifiedName" | 8818 | // $ANTLR start "entryRuleQualifiedName" |
9951 | // InternalSolverLanguage.g:3471:1: entryRuleQualifiedName returns [String current=null] : iv_ruleQualifiedName= ruleQualifiedName EOF ; | 8819 | // InternalSolverLanguageParser.g:3430:1: entryRuleQualifiedName returns [String current=null] : iv_ruleQualifiedName= ruleQualifiedName EOF ; |
9952 | public final String entryRuleQualifiedName() throws RecognitionException { | 8820 | public final String entryRuleQualifiedName() throws RecognitionException { |
9953 | String current = null; | 8821 | String current = null; |
9954 | 8822 | ||
@@ -9959,21 +8827,17 @@ public class InternalSolverLanguageParser extends AbstractInternalAntlrParser { | |||
9959 | HiddenTokens myHiddenTokenState = ((XtextTokenStream)input).setHiddenTokens(); | 8827 | HiddenTokens myHiddenTokenState = ((XtextTokenStream)input).setHiddenTokens(); |
9960 | 8828 | ||
9961 | try { | 8829 | try { |
9962 | // InternalSolverLanguage.g:3473:2: (iv_ruleQualifiedName= ruleQualifiedName EOF ) | 8830 | // InternalSolverLanguageParser.g:3432:2: (iv_ruleQualifiedName= ruleQualifiedName EOF ) |
9963 | // InternalSolverLanguage.g:3474:2: iv_ruleQualifiedName= ruleQualifiedName EOF | 8831 | // InternalSolverLanguageParser.g:3433:2: iv_ruleQualifiedName= ruleQualifiedName EOF |
9964 | { | 8832 | { |
9965 | if ( state.backtracking==0 ) { | 8833 | newCompositeNode(grammarAccess.getQualifiedNameRule()); |
9966 | newCompositeNode(grammarAccess.getQualifiedNameRule()); | ||
9967 | } | ||
9968 | pushFollow(FOLLOW_1); | 8834 | pushFollow(FOLLOW_1); |
9969 | iv_ruleQualifiedName=ruleQualifiedName(); | 8835 | iv_ruleQualifiedName=ruleQualifiedName(); |
9970 | 8836 | ||
9971 | state._fsp--; | 8837 | state._fsp--; |
9972 | if (state.failed) return current; | 8838 | |
9973 | if ( state.backtracking==0 ) { | 8839 | current =iv_ruleQualifiedName.getText(); |
9974 | current =iv_ruleQualifiedName.getText(); | 8840 | match(input,EOF,FOLLOW_2); |
9975 | } | ||
9976 | match(input,EOF,FOLLOW_2); if (state.failed) return current; | ||
9977 | 8841 | ||
9978 | } | 8842 | } |
9979 | 8843 | ||
@@ -9994,7 +8858,7 @@ public class InternalSolverLanguageParser extends AbstractInternalAntlrParser { | |||
9994 | 8858 | ||
9995 | 8859 | ||
9996 | // $ANTLR start "ruleQualifiedName" | 8860 | // $ANTLR start "ruleQualifiedName" |
9997 | // InternalSolverLanguage.g:3483:1: ruleQualifiedName returns [AntlrDatatypeRuleToken current=new AntlrDatatypeRuleToken()] : ( (this_ID_0= RULE_ID (kw= '.' this_ID_2= RULE_ID )* ) | this_QUOTED_ID_3= RULE_QUOTED_ID ) ; | 8861 | // InternalSolverLanguageParser.g:3442:1: ruleQualifiedName returns [AntlrDatatypeRuleToken current=new AntlrDatatypeRuleToken()] : ( (this_ID_0= RULE_ID (kw= FullStop this_ID_2= RULE_ID )* ) | this_QUOTED_ID_3= RULE_QUOTED_ID ) ; |
9998 | public final AntlrDatatypeRuleToken ruleQualifiedName() throws RecognitionException { | 8862 | public final AntlrDatatypeRuleToken ruleQualifiedName() throws RecognitionException { |
9999 | AntlrDatatypeRuleToken current = new AntlrDatatypeRuleToken(); | 8863 | AntlrDatatypeRuleToken current = new AntlrDatatypeRuleToken(); |
10000 | 8864 | ||
@@ -10008,89 +8872,72 @@ public class InternalSolverLanguageParser extends AbstractInternalAntlrParser { | |||
10008 | HiddenTokens myHiddenTokenState = ((XtextTokenStream)input).setHiddenTokens(); | 8872 | HiddenTokens myHiddenTokenState = ((XtextTokenStream)input).setHiddenTokens(); |
10009 | 8873 | ||
10010 | try { | 8874 | try { |
10011 | // InternalSolverLanguage.g:3490:2: ( ( (this_ID_0= RULE_ID (kw= '.' this_ID_2= RULE_ID )* ) | this_QUOTED_ID_3= RULE_QUOTED_ID ) ) | 8875 | // InternalSolverLanguageParser.g:3449:2: ( ( (this_ID_0= RULE_ID (kw= FullStop this_ID_2= RULE_ID )* ) | this_QUOTED_ID_3= RULE_QUOTED_ID ) ) |
10012 | // InternalSolverLanguage.g:3491:2: ( (this_ID_0= RULE_ID (kw= '.' this_ID_2= RULE_ID )* ) | this_QUOTED_ID_3= RULE_QUOTED_ID ) | 8876 | // InternalSolverLanguageParser.g:3450:2: ( (this_ID_0= RULE_ID (kw= FullStop this_ID_2= RULE_ID )* ) | this_QUOTED_ID_3= RULE_QUOTED_ID ) |
10013 | { | 8877 | { |
10014 | // InternalSolverLanguage.g:3491:2: ( (this_ID_0= RULE_ID (kw= '.' this_ID_2= RULE_ID )* ) | this_QUOTED_ID_3= RULE_QUOTED_ID ) | 8878 | // InternalSolverLanguageParser.g:3450:2: ( (this_ID_0= RULE_ID (kw= FullStop this_ID_2= RULE_ID )* ) | this_QUOTED_ID_3= RULE_QUOTED_ID ) |
10015 | int alt44=2; | 8879 | int alt43=2; |
10016 | int LA44_0 = input.LA(1); | 8880 | int LA43_0 = input.LA(1); |
10017 | 8881 | ||
10018 | if ( (LA44_0==RULE_ID) ) { | 8882 | if ( (LA43_0==RULE_ID) ) { |
10019 | alt44=1; | 8883 | alt43=1; |
10020 | } | 8884 | } |
10021 | else if ( (LA44_0==RULE_QUOTED_ID) ) { | 8885 | else if ( (LA43_0==RULE_QUOTED_ID) ) { |
10022 | alt44=2; | 8886 | alt43=2; |
10023 | } | 8887 | } |
10024 | else { | 8888 | else { |
10025 | if (state.backtracking>0) {state.failed=true; return current;} | ||
10026 | NoViableAltException nvae = | 8889 | NoViableAltException nvae = |
10027 | new NoViableAltException("", 44, 0, input); | 8890 | new NoViableAltException("", 43, 0, input); |
10028 | 8891 | ||
10029 | throw nvae; | 8892 | throw nvae; |
10030 | } | 8893 | } |
10031 | switch (alt44) { | 8894 | switch (alt43) { |
10032 | case 1 : | 8895 | case 1 : |
10033 | // InternalSolverLanguage.g:3492:3: (this_ID_0= RULE_ID (kw= '.' this_ID_2= RULE_ID )* ) | 8896 | // InternalSolverLanguageParser.g:3451:3: (this_ID_0= RULE_ID (kw= FullStop this_ID_2= RULE_ID )* ) |
10034 | { | 8897 | { |
10035 | // InternalSolverLanguage.g:3492:3: (this_ID_0= RULE_ID (kw= '.' this_ID_2= RULE_ID )* ) | 8898 | // InternalSolverLanguageParser.g:3451:3: (this_ID_0= RULE_ID (kw= FullStop this_ID_2= RULE_ID )* ) |
10036 | // InternalSolverLanguage.g:3493:4: this_ID_0= RULE_ID (kw= '.' this_ID_2= RULE_ID )* | 8899 | // InternalSolverLanguageParser.g:3452:4: this_ID_0= RULE_ID (kw= FullStop this_ID_2= RULE_ID )* |
10037 | { | 8900 | { |
10038 | this_ID_0=(Token)match(input,RULE_ID,FOLLOW_53); if (state.failed) return current; | 8901 | this_ID_0=(Token)match(input,RULE_ID,FOLLOW_51); |
10039 | if ( state.backtracking==0 ) { | ||
10040 | 8902 | ||
10041 | current.merge(this_ID_0); | 8903 | current.merge(this_ID_0); |
10042 | 8904 | ||
10043 | } | ||
10044 | if ( state.backtracking==0 ) { | ||
10045 | 8905 | ||
10046 | newLeafNode(this_ID_0, grammarAccess.getQualifiedNameAccess().getIDTerminalRuleCall_0_0()); | 8906 | newLeafNode(this_ID_0, grammarAccess.getQualifiedNameAccess().getIDTerminalRuleCall_0_0()); |
10047 | 8907 | ||
10048 | } | 8908 | // InternalSolverLanguageParser.g:3459:4: (kw= FullStop this_ID_2= RULE_ID )* |
10049 | // InternalSolverLanguage.g:3500:4: (kw= '.' this_ID_2= RULE_ID )* | 8909 | loop42: |
10050 | loop43: | ||
10051 | do { | 8910 | do { |
10052 | int alt43=2; | 8911 | int alt42=2; |
10053 | int LA43_0 = input.LA(1); | 8912 | int LA42_0 = input.LA(1); |
10054 | |||
10055 | if ( (LA43_0==22) ) { | ||
10056 | int LA43_2 = input.LA(2); | ||
10057 | |||
10058 | if ( (LA43_2==RULE_ID) ) { | ||
10059 | alt43=1; | ||
10060 | } | ||
10061 | |||
10062 | 8913 | ||
8914 | if ( (LA42_0==FullStop) ) { | ||
8915 | alt42=1; | ||
10063 | } | 8916 | } |
10064 | 8917 | ||
10065 | 8918 | ||
10066 | switch (alt43) { | 8919 | switch (alt42) { |
10067 | case 1 : | 8920 | case 1 : |
10068 | // InternalSolverLanguage.g:3501:5: kw= '.' this_ID_2= RULE_ID | 8921 | // InternalSolverLanguageParser.g:3460:5: kw= FullStop this_ID_2= RULE_ID |
10069 | { | 8922 | { |
10070 | kw=(Token)match(input,22,FOLLOW_40); if (state.failed) return current; | 8923 | kw=(Token)match(input,FullStop,FOLLOW_38); |
10071 | if ( state.backtracking==0 ) { | ||
10072 | 8924 | ||
10073 | current.merge(kw); | 8925 | current.merge(kw); |
10074 | newLeafNode(kw, grammarAccess.getQualifiedNameAccess().getFullStopKeyword_0_1_0()); | 8926 | newLeafNode(kw, grammarAccess.getQualifiedNameAccess().getFullStopKeyword_0_1_0()); |
10075 | 8927 | ||
10076 | } | 8928 | this_ID_2=(Token)match(input,RULE_ID,FOLLOW_51); |
10077 | this_ID_2=(Token)match(input,RULE_ID,FOLLOW_53); if (state.failed) return current; | ||
10078 | if ( state.backtracking==0 ) { | ||
10079 | 8929 | ||
10080 | current.merge(this_ID_2); | 8930 | current.merge(this_ID_2); |
10081 | 8931 | ||
10082 | } | ||
10083 | if ( state.backtracking==0 ) { | ||
10084 | 8932 | ||
10085 | newLeafNode(this_ID_2, grammarAccess.getQualifiedNameAccess().getIDTerminalRuleCall_0_1_1()); | 8933 | newLeafNode(this_ID_2, grammarAccess.getQualifiedNameAccess().getIDTerminalRuleCall_0_1_1()); |
10086 | 8934 | ||
10087 | } | ||
10088 | 8935 | ||
10089 | } | 8936 | } |
10090 | break; | 8937 | break; |
10091 | 8938 | ||
10092 | default : | 8939 | default : |
10093 | break loop43; | 8940 | break loop42; |
10094 | } | 8941 | } |
10095 | } while (true); | 8942 | } while (true); |
10096 | 8943 | ||
@@ -10101,19 +8948,15 @@ public class InternalSolverLanguageParser extends AbstractInternalAntlrParser { | |||
10101 | } | 8948 | } |
10102 | break; | 8949 | break; |
10103 | case 2 : | 8950 | case 2 : |
10104 | // InternalSolverLanguage.g:3516:3: this_QUOTED_ID_3= RULE_QUOTED_ID | 8951 | // InternalSolverLanguageParser.g:3475:3: this_QUOTED_ID_3= RULE_QUOTED_ID |
10105 | { | 8952 | { |
10106 | this_QUOTED_ID_3=(Token)match(input,RULE_QUOTED_ID,FOLLOW_2); if (state.failed) return current; | 8953 | this_QUOTED_ID_3=(Token)match(input,RULE_QUOTED_ID,FOLLOW_2); |
10107 | if ( state.backtracking==0 ) { | ||
10108 | 8954 | ||
10109 | current.merge(this_QUOTED_ID_3); | 8955 | current.merge(this_QUOTED_ID_3); |
10110 | 8956 | ||
10111 | } | ||
10112 | if ( state.backtracking==0 ) { | ||
10113 | 8957 | ||
10114 | newLeafNode(this_QUOTED_ID_3, grammarAccess.getQualifiedNameAccess().getQUOTED_IDTerminalRuleCall_1()); | 8958 | newLeafNode(this_QUOTED_ID_3, grammarAccess.getQualifiedNameAccess().getQUOTED_IDTerminalRuleCall_1()); |
10115 | 8959 | ||
10116 | } | ||
10117 | 8960 | ||
10118 | } | 8961 | } |
10119 | break; | 8962 | break; |
@@ -10123,11 +8966,9 @@ public class InternalSolverLanguageParser extends AbstractInternalAntlrParser { | |||
10123 | 8966 | ||
10124 | } | 8967 | } |
10125 | 8968 | ||
10126 | if ( state.backtracking==0 ) { | ||
10127 | 8969 | ||
10128 | leaveRule(); | 8970 | leaveRule(); |
10129 | 8971 | ||
10130 | } | ||
10131 | } | 8972 | } |
10132 | 8973 | ||
10133 | catch (RecognitionException re) { | 8974 | catch (RecognitionException re) { |
@@ -10145,7 +8986,7 @@ public class InternalSolverLanguageParser extends AbstractInternalAntlrParser { | |||
10145 | 8986 | ||
10146 | 8987 | ||
10147 | // $ANTLR start "ruleMetricType" | 8988 | // $ANTLR start "ruleMetricType" |
10148 | // InternalSolverLanguage.g:3530:1: ruleMetricType returns [Enumerator current=null] : ( (enumLiteral_0= 'int' ) | (enumLiteral_1= 'real' ) ) ; | 8989 | // InternalSolverLanguageParser.g:3489:1: ruleMetricType returns [Enumerator current=null] : ( (enumLiteral_0= Int ) | (enumLiteral_1= Real ) ) ; |
10149 | public final Enumerator ruleMetricType() throws RecognitionException { | 8990 | public final Enumerator ruleMetricType() throws RecognitionException { |
10150 | Enumerator current = null; | 8991 | Enumerator current = null; |
10151 | 8992 | ||
@@ -10156,40 +8997,37 @@ public class InternalSolverLanguageParser extends AbstractInternalAntlrParser { | |||
10156 | enterRule(); | 8997 | enterRule(); |
10157 | 8998 | ||
10158 | try { | 8999 | try { |
10159 | // InternalSolverLanguage.g:3536:2: ( ( (enumLiteral_0= 'int' ) | (enumLiteral_1= 'real' ) ) ) | 9000 | // InternalSolverLanguageParser.g:3495:2: ( ( (enumLiteral_0= Int ) | (enumLiteral_1= Real ) ) ) |
10160 | // InternalSolverLanguage.g:3537:2: ( (enumLiteral_0= 'int' ) | (enumLiteral_1= 'real' ) ) | 9001 | // InternalSolverLanguageParser.g:3496:2: ( (enumLiteral_0= Int ) | (enumLiteral_1= Real ) ) |
10161 | { | 9002 | { |
10162 | // InternalSolverLanguage.g:3537:2: ( (enumLiteral_0= 'int' ) | (enumLiteral_1= 'real' ) ) | 9003 | // InternalSolverLanguageParser.g:3496:2: ( (enumLiteral_0= Int ) | (enumLiteral_1= Real ) ) |
10163 | int alt45=2; | 9004 | int alt44=2; |
10164 | int LA45_0 = input.LA(1); | 9005 | int LA44_0 = input.LA(1); |
10165 | 9006 | ||
10166 | if ( (LA45_0==50) ) { | 9007 | if ( (LA44_0==Int) ) { |
10167 | alt45=1; | 9008 | alt44=1; |
10168 | } | 9009 | } |
10169 | else if ( (LA45_0==51) ) { | 9010 | else if ( (LA44_0==Real) ) { |
10170 | alt45=2; | 9011 | alt44=2; |
10171 | } | 9012 | } |
10172 | else { | 9013 | else { |
10173 | if (state.backtracking>0) {state.failed=true; return current;} | ||
10174 | NoViableAltException nvae = | 9014 | NoViableAltException nvae = |
10175 | new NoViableAltException("", 45, 0, input); | 9015 | new NoViableAltException("", 44, 0, input); |
10176 | 9016 | ||
10177 | throw nvae; | 9017 | throw nvae; |
10178 | } | 9018 | } |
10179 | switch (alt45) { | 9019 | switch (alt44) { |
10180 | case 1 : | 9020 | case 1 : |
10181 | // InternalSolverLanguage.g:3538:3: (enumLiteral_0= 'int' ) | 9021 | // InternalSolverLanguageParser.g:3497:3: (enumLiteral_0= Int ) |
10182 | { | 9022 | { |
10183 | // InternalSolverLanguage.g:3538:3: (enumLiteral_0= 'int' ) | 9023 | // InternalSolverLanguageParser.g:3497:3: (enumLiteral_0= Int ) |
10184 | // InternalSolverLanguage.g:3539:4: enumLiteral_0= 'int' | 9024 | // InternalSolverLanguageParser.g:3498:4: enumLiteral_0= Int |
10185 | { | 9025 | { |
10186 | enumLiteral_0=(Token)match(input,50,FOLLOW_2); if (state.failed) return current; | 9026 | enumLiteral_0=(Token)match(input,Int,FOLLOW_2); |
10187 | if ( state.backtracking==0 ) { | ||
10188 | 9027 | ||
10189 | current = grammarAccess.getMetricTypeAccess().getINTEnumLiteralDeclaration_0().getEnumLiteral().getInstance(); | 9028 | current = grammarAccess.getMetricTypeAccess().getINTEnumLiteralDeclaration_0().getEnumLiteral().getInstance(); |
10190 | newLeafNode(enumLiteral_0, grammarAccess.getMetricTypeAccess().getINTEnumLiteralDeclaration_0()); | 9029 | newLeafNode(enumLiteral_0, grammarAccess.getMetricTypeAccess().getINTEnumLiteralDeclaration_0()); |
10191 | 9030 | ||
10192 | } | ||
10193 | 9031 | ||
10194 | } | 9032 | } |
10195 | 9033 | ||
@@ -10197,18 +9035,16 @@ public class InternalSolverLanguageParser extends AbstractInternalAntlrParser { | |||
10197 | } | 9035 | } |
10198 | break; | 9036 | break; |
10199 | case 2 : | 9037 | case 2 : |
10200 | // InternalSolverLanguage.g:3546:3: (enumLiteral_1= 'real' ) | 9038 | // InternalSolverLanguageParser.g:3505:3: (enumLiteral_1= Real ) |
10201 | { | 9039 | { |
10202 | // InternalSolverLanguage.g:3546:3: (enumLiteral_1= 'real' ) | 9040 | // InternalSolverLanguageParser.g:3505:3: (enumLiteral_1= Real ) |
10203 | // InternalSolverLanguage.g:3547:4: enumLiteral_1= 'real' | 9041 | // InternalSolverLanguageParser.g:3506:4: enumLiteral_1= Real |
10204 | { | 9042 | { |
10205 | enumLiteral_1=(Token)match(input,51,FOLLOW_2); if (state.failed) return current; | 9043 | enumLiteral_1=(Token)match(input,Real,FOLLOW_2); |
10206 | if ( state.backtracking==0 ) { | ||
10207 | 9044 | ||
10208 | current = grammarAccess.getMetricTypeAccess().getREALEnumLiteralDeclaration_1().getEnumLiteral().getInstance(); | 9045 | current = grammarAccess.getMetricTypeAccess().getREALEnumLiteralDeclaration_1().getEnumLiteral().getInstance(); |
10209 | newLeafNode(enumLiteral_1, grammarAccess.getMetricTypeAccess().getREALEnumLiteralDeclaration_1()); | 9046 | newLeafNode(enumLiteral_1, grammarAccess.getMetricTypeAccess().getREALEnumLiteralDeclaration_1()); |
10210 | 9047 | ||
10211 | } | ||
10212 | 9048 | ||
10213 | } | 9049 | } |
10214 | 9050 | ||
@@ -10221,11 +9057,9 @@ public class InternalSolverLanguageParser extends AbstractInternalAntlrParser { | |||
10221 | 9057 | ||
10222 | } | 9058 | } |
10223 | 9059 | ||
10224 | if ( state.backtracking==0 ) { | ||
10225 | 9060 | ||
10226 | leaveRule(); | 9061 | leaveRule(); |
10227 | 9062 | ||
10228 | } | ||
10229 | } | 9063 | } |
10230 | 9064 | ||
10231 | catch (RecognitionException re) { | 9065 | catch (RecognitionException re) { |
@@ -10240,7 +9074,7 @@ public class InternalSolverLanguageParser extends AbstractInternalAntlrParser { | |||
10240 | 9074 | ||
10241 | 9075 | ||
10242 | // $ANTLR start "ruleComparisonOperator" | 9076 | // $ANTLR start "ruleComparisonOperator" |
10243 | // InternalSolverLanguage.g:3557:1: ruleComparisonOperator returns [Enumerator current=null] : ( (enumLiteral_0= '==' ) | (enumLiteral_1= '!=' ) | (enumLiteral_2= '<' ) | (enumLiteral_3= '<=' ) | (enumLiteral_4= '>' ) | (enumLiteral_5= '>=' ) | (enumLiteral_6= 'in' ) ) ; | 9077 | // InternalSolverLanguageParser.g:3516:1: ruleComparisonOperator returns [Enumerator current=null] : ( (enumLiteral_0= EqualsSignEqualsSign ) | (enumLiteral_1= ExclamationMarkEqualsSign ) | (enumLiteral_2= LessThanSign ) | (enumLiteral_3= LessThanSignEqualsSign ) | (enumLiteral_4= GreaterThanSign ) | (enumLiteral_5= GreaterThanSignEqualsSign ) | (enumLiteral_6= In ) ) ; |
10244 | public final Enumerator ruleComparisonOperator() throws RecognitionException { | 9078 | public final Enumerator ruleComparisonOperator() throws RecognitionException { |
10245 | Enumerator current = null; | 9079 | Enumerator current = null; |
10246 | 9080 | ||
@@ -10256,69 +9090,66 @@ public class InternalSolverLanguageParser extends AbstractInternalAntlrParser { | |||
10256 | enterRule(); | 9090 | enterRule(); |
10257 | 9091 | ||
10258 | try { | 9092 | try { |
10259 | // InternalSolverLanguage.g:3563:2: ( ( (enumLiteral_0= '==' ) | (enumLiteral_1= '!=' ) | (enumLiteral_2= '<' ) | (enumLiteral_3= '<=' ) | (enumLiteral_4= '>' ) | (enumLiteral_5= '>=' ) | (enumLiteral_6= 'in' ) ) ) | 9093 | // InternalSolverLanguageParser.g:3522:2: ( ( (enumLiteral_0= EqualsSignEqualsSign ) | (enumLiteral_1= ExclamationMarkEqualsSign ) | (enumLiteral_2= LessThanSign ) | (enumLiteral_3= LessThanSignEqualsSign ) | (enumLiteral_4= GreaterThanSign ) | (enumLiteral_5= GreaterThanSignEqualsSign ) | (enumLiteral_6= In ) ) ) |
10260 | // InternalSolverLanguage.g:3564:2: ( (enumLiteral_0= '==' ) | (enumLiteral_1= '!=' ) | (enumLiteral_2= '<' ) | (enumLiteral_3= '<=' ) | (enumLiteral_4= '>' ) | (enumLiteral_5= '>=' ) | (enumLiteral_6= 'in' ) ) | 9094 | // InternalSolverLanguageParser.g:3523:2: ( (enumLiteral_0= EqualsSignEqualsSign ) | (enumLiteral_1= ExclamationMarkEqualsSign ) | (enumLiteral_2= LessThanSign ) | (enumLiteral_3= LessThanSignEqualsSign ) | (enumLiteral_4= GreaterThanSign ) | (enumLiteral_5= GreaterThanSignEqualsSign ) | (enumLiteral_6= In ) ) |
10261 | { | 9095 | { |
10262 | // InternalSolverLanguage.g:3564:2: ( (enumLiteral_0= '==' ) | (enumLiteral_1= '!=' ) | (enumLiteral_2= '<' ) | (enumLiteral_3= '<=' ) | (enumLiteral_4= '>' ) | (enumLiteral_5= '>=' ) | (enumLiteral_6= 'in' ) ) | 9096 | // InternalSolverLanguageParser.g:3523:2: ( (enumLiteral_0= EqualsSignEqualsSign ) | (enumLiteral_1= ExclamationMarkEqualsSign ) | (enumLiteral_2= LessThanSign ) | (enumLiteral_3= LessThanSignEqualsSign ) | (enumLiteral_4= GreaterThanSign ) | (enumLiteral_5= GreaterThanSignEqualsSign ) | (enumLiteral_6= In ) ) |
10263 | int alt46=7; | 9097 | int alt45=7; |
10264 | switch ( input.LA(1) ) { | 9098 | switch ( input.LA(1) ) { |
10265 | case 47: | 9099 | case EqualsSignEqualsSign: |
10266 | { | 9100 | { |
10267 | alt46=1; | 9101 | alt45=1; |
10268 | } | 9102 | } |
10269 | break; | 9103 | break; |
10270 | case 52: | 9104 | case ExclamationMarkEqualsSign: |
10271 | { | 9105 | { |
10272 | alt46=2; | 9106 | alt45=2; |
10273 | } | 9107 | } |
10274 | break; | 9108 | break; |
10275 | case 53: | 9109 | case LessThanSign: |
10276 | { | 9110 | { |
10277 | alt46=3; | 9111 | alt45=3; |
10278 | } | 9112 | } |
10279 | break; | 9113 | break; |
10280 | case 48: | 9114 | case LessThanSignEqualsSign: |
10281 | { | 9115 | { |
10282 | alt46=4; | 9116 | alt45=4; |
10283 | } | 9117 | } |
10284 | break; | 9118 | break; |
10285 | case 54: | 9119 | case GreaterThanSign: |
10286 | { | 9120 | { |
10287 | alt46=5; | 9121 | alt45=5; |
10288 | } | 9122 | } |
10289 | break; | 9123 | break; |
10290 | case 49: | 9124 | case GreaterThanSignEqualsSign: |
10291 | { | 9125 | { |
10292 | alt46=6; | 9126 | alt45=6; |
10293 | } | 9127 | } |
10294 | break; | 9128 | break; |
10295 | case 55: | 9129 | case In: |
10296 | { | 9130 | { |
10297 | alt46=7; | 9131 | alt45=7; |
10298 | } | 9132 | } |
10299 | break; | 9133 | break; |
10300 | default: | 9134 | default: |
10301 | if (state.backtracking>0) {state.failed=true; return current;} | ||
10302 | NoViableAltException nvae = | 9135 | NoViableAltException nvae = |
10303 | new NoViableAltException("", 46, 0, input); | 9136 | new NoViableAltException("", 45, 0, input); |
10304 | 9137 | ||
10305 | throw nvae; | 9138 | throw nvae; |
10306 | } | 9139 | } |
10307 | 9140 | ||
10308 | switch (alt46) { | 9141 | switch (alt45) { |
10309 | case 1 : | 9142 | case 1 : |
10310 | // InternalSolverLanguage.g:3565:3: (enumLiteral_0= '==' ) | 9143 | // InternalSolverLanguageParser.g:3524:3: (enumLiteral_0= EqualsSignEqualsSign ) |
10311 | { | 9144 | { |
10312 | // InternalSolverLanguage.g:3565:3: (enumLiteral_0= '==' ) | 9145 | // InternalSolverLanguageParser.g:3524:3: (enumLiteral_0= EqualsSignEqualsSign ) |
10313 | // InternalSolverLanguage.g:3566:4: enumLiteral_0= '==' | 9146 | // InternalSolverLanguageParser.g:3525:4: enumLiteral_0= EqualsSignEqualsSign |
10314 | { | 9147 | { |
10315 | enumLiteral_0=(Token)match(input,47,FOLLOW_2); if (state.failed) return current; | 9148 | enumLiteral_0=(Token)match(input,EqualsSignEqualsSign,FOLLOW_2); |
10316 | if ( state.backtracking==0 ) { | ||
10317 | 9149 | ||
10318 | current = grammarAccess.getComparisonOperatorAccess().getEQEnumLiteralDeclaration_0().getEnumLiteral().getInstance(); | 9150 | current = grammarAccess.getComparisonOperatorAccess().getEQEnumLiteralDeclaration_0().getEnumLiteral().getInstance(); |
10319 | newLeafNode(enumLiteral_0, grammarAccess.getComparisonOperatorAccess().getEQEnumLiteralDeclaration_0()); | 9151 | newLeafNode(enumLiteral_0, grammarAccess.getComparisonOperatorAccess().getEQEnumLiteralDeclaration_0()); |
10320 | 9152 | ||
10321 | } | ||
10322 | 9153 | ||
10323 | } | 9154 | } |
10324 | 9155 | ||
@@ -10326,18 +9157,16 @@ public class InternalSolverLanguageParser extends AbstractInternalAntlrParser { | |||
10326 | } | 9157 | } |
10327 | break; | 9158 | break; |
10328 | case 2 : | 9159 | case 2 : |
10329 | // InternalSolverLanguage.g:3573:3: (enumLiteral_1= '!=' ) | 9160 | // InternalSolverLanguageParser.g:3532:3: (enumLiteral_1= ExclamationMarkEqualsSign ) |
10330 | { | 9161 | { |
10331 | // InternalSolverLanguage.g:3573:3: (enumLiteral_1= '!=' ) | 9162 | // InternalSolverLanguageParser.g:3532:3: (enumLiteral_1= ExclamationMarkEqualsSign ) |
10332 | // InternalSolverLanguage.g:3574:4: enumLiteral_1= '!=' | 9163 | // InternalSolverLanguageParser.g:3533:4: enumLiteral_1= ExclamationMarkEqualsSign |
10333 | { | 9164 | { |
10334 | enumLiteral_1=(Token)match(input,52,FOLLOW_2); if (state.failed) return current; | 9165 | enumLiteral_1=(Token)match(input,ExclamationMarkEqualsSign,FOLLOW_2); |
10335 | if ( state.backtracking==0 ) { | ||
10336 | 9166 | ||
10337 | current = grammarAccess.getComparisonOperatorAccess().getNOT_EQEnumLiteralDeclaration_1().getEnumLiteral().getInstance(); | 9167 | current = grammarAccess.getComparisonOperatorAccess().getNOT_EQEnumLiteralDeclaration_1().getEnumLiteral().getInstance(); |
10338 | newLeafNode(enumLiteral_1, grammarAccess.getComparisonOperatorAccess().getNOT_EQEnumLiteralDeclaration_1()); | 9168 | newLeafNode(enumLiteral_1, grammarAccess.getComparisonOperatorAccess().getNOT_EQEnumLiteralDeclaration_1()); |
10339 | 9169 | ||
10340 | } | ||
10341 | 9170 | ||
10342 | } | 9171 | } |
10343 | 9172 | ||
@@ -10345,18 +9174,16 @@ public class InternalSolverLanguageParser extends AbstractInternalAntlrParser { | |||
10345 | } | 9174 | } |
10346 | break; | 9175 | break; |
10347 | case 3 : | 9176 | case 3 : |
10348 | // InternalSolverLanguage.g:3581:3: (enumLiteral_2= '<' ) | 9177 | // InternalSolverLanguageParser.g:3540:3: (enumLiteral_2= LessThanSign ) |
10349 | { | 9178 | { |
10350 | // InternalSolverLanguage.g:3581:3: (enumLiteral_2= '<' ) | 9179 | // InternalSolverLanguageParser.g:3540:3: (enumLiteral_2= LessThanSign ) |
10351 | // InternalSolverLanguage.g:3582:4: enumLiteral_2= '<' | 9180 | // InternalSolverLanguageParser.g:3541:4: enumLiteral_2= LessThanSign |
10352 | { | 9181 | { |
10353 | enumLiteral_2=(Token)match(input,53,FOLLOW_2); if (state.failed) return current; | 9182 | enumLiteral_2=(Token)match(input,LessThanSign,FOLLOW_2); |
10354 | if ( state.backtracking==0 ) { | ||
10355 | 9183 | ||
10356 | current = grammarAccess.getComparisonOperatorAccess().getLESSEnumLiteralDeclaration_2().getEnumLiteral().getInstance(); | 9184 | current = grammarAccess.getComparisonOperatorAccess().getLESSEnumLiteralDeclaration_2().getEnumLiteral().getInstance(); |
10357 | newLeafNode(enumLiteral_2, grammarAccess.getComparisonOperatorAccess().getLESSEnumLiteralDeclaration_2()); | 9185 | newLeafNode(enumLiteral_2, grammarAccess.getComparisonOperatorAccess().getLESSEnumLiteralDeclaration_2()); |
10358 | 9186 | ||
10359 | } | ||
10360 | 9187 | ||
10361 | } | 9188 | } |
10362 | 9189 | ||
@@ -10364,18 +9191,16 @@ public class InternalSolverLanguageParser extends AbstractInternalAntlrParser { | |||
10364 | } | 9191 | } |
10365 | break; | 9192 | break; |
10366 | case 4 : | 9193 | case 4 : |
10367 | // InternalSolverLanguage.g:3589:3: (enumLiteral_3= '<=' ) | 9194 | // InternalSolverLanguageParser.g:3548:3: (enumLiteral_3= LessThanSignEqualsSign ) |
10368 | { | 9195 | { |
10369 | // InternalSolverLanguage.g:3589:3: (enumLiteral_3= '<=' ) | 9196 | // InternalSolverLanguageParser.g:3548:3: (enumLiteral_3= LessThanSignEqualsSign ) |
10370 | // InternalSolverLanguage.g:3590:4: enumLiteral_3= '<=' | 9197 | // InternalSolverLanguageParser.g:3549:4: enumLiteral_3= LessThanSignEqualsSign |
10371 | { | 9198 | { |
10372 | enumLiteral_3=(Token)match(input,48,FOLLOW_2); if (state.failed) return current; | 9199 | enumLiteral_3=(Token)match(input,LessThanSignEqualsSign,FOLLOW_2); |
10373 | if ( state.backtracking==0 ) { | ||
10374 | 9200 | ||
10375 | current = grammarAccess.getComparisonOperatorAccess().getLESS_EQEnumLiteralDeclaration_3().getEnumLiteral().getInstance(); | 9201 | current = grammarAccess.getComparisonOperatorAccess().getLESS_EQEnumLiteralDeclaration_3().getEnumLiteral().getInstance(); |
10376 | newLeafNode(enumLiteral_3, grammarAccess.getComparisonOperatorAccess().getLESS_EQEnumLiteralDeclaration_3()); | 9202 | newLeafNode(enumLiteral_3, grammarAccess.getComparisonOperatorAccess().getLESS_EQEnumLiteralDeclaration_3()); |
10377 | 9203 | ||
10378 | } | ||
10379 | 9204 | ||
10380 | } | 9205 | } |
10381 | 9206 | ||
@@ -10383,18 +9208,16 @@ public class InternalSolverLanguageParser extends AbstractInternalAntlrParser { | |||
10383 | } | 9208 | } |
10384 | break; | 9209 | break; |
10385 | case 5 : | 9210 | case 5 : |
10386 | // InternalSolverLanguage.g:3597:3: (enumLiteral_4= '>' ) | 9211 | // InternalSolverLanguageParser.g:3556:3: (enumLiteral_4= GreaterThanSign ) |
10387 | { | 9212 | { |
10388 | // InternalSolverLanguage.g:3597:3: (enumLiteral_4= '>' ) | 9213 | // InternalSolverLanguageParser.g:3556:3: (enumLiteral_4= GreaterThanSign ) |
10389 | // InternalSolverLanguage.g:3598:4: enumLiteral_4= '>' | 9214 | // InternalSolverLanguageParser.g:3557:4: enumLiteral_4= GreaterThanSign |
10390 | { | 9215 | { |
10391 | enumLiteral_4=(Token)match(input,54,FOLLOW_2); if (state.failed) return current; | 9216 | enumLiteral_4=(Token)match(input,GreaterThanSign,FOLLOW_2); |
10392 | if ( state.backtracking==0 ) { | ||
10393 | 9217 | ||
10394 | current = grammarAccess.getComparisonOperatorAccess().getGREATEREnumLiteralDeclaration_4().getEnumLiteral().getInstance(); | 9218 | current = grammarAccess.getComparisonOperatorAccess().getGREATEREnumLiteralDeclaration_4().getEnumLiteral().getInstance(); |
10395 | newLeafNode(enumLiteral_4, grammarAccess.getComparisonOperatorAccess().getGREATEREnumLiteralDeclaration_4()); | 9219 | newLeafNode(enumLiteral_4, grammarAccess.getComparisonOperatorAccess().getGREATEREnumLiteralDeclaration_4()); |
10396 | 9220 | ||
10397 | } | ||
10398 | 9221 | ||
10399 | } | 9222 | } |
10400 | 9223 | ||
@@ -10402,18 +9225,16 @@ public class InternalSolverLanguageParser extends AbstractInternalAntlrParser { | |||
10402 | } | 9225 | } |
10403 | break; | 9226 | break; |
10404 | case 6 : | 9227 | case 6 : |
10405 | // InternalSolverLanguage.g:3605:3: (enumLiteral_5= '>=' ) | 9228 | // InternalSolverLanguageParser.g:3564:3: (enumLiteral_5= GreaterThanSignEqualsSign ) |
10406 | { | 9229 | { |
10407 | // InternalSolverLanguage.g:3605:3: (enumLiteral_5= '>=' ) | 9230 | // InternalSolverLanguageParser.g:3564:3: (enumLiteral_5= GreaterThanSignEqualsSign ) |
10408 | // InternalSolverLanguage.g:3606:4: enumLiteral_5= '>=' | 9231 | // InternalSolverLanguageParser.g:3565:4: enumLiteral_5= GreaterThanSignEqualsSign |
10409 | { | 9232 | { |
10410 | enumLiteral_5=(Token)match(input,49,FOLLOW_2); if (state.failed) return current; | 9233 | enumLiteral_5=(Token)match(input,GreaterThanSignEqualsSign,FOLLOW_2); |
10411 | if ( state.backtracking==0 ) { | ||
10412 | 9234 | ||
10413 | current = grammarAccess.getComparisonOperatorAccess().getGREATER_EQEnumLiteralDeclaration_5().getEnumLiteral().getInstance(); | 9235 | current = grammarAccess.getComparisonOperatorAccess().getGREATER_EQEnumLiteralDeclaration_5().getEnumLiteral().getInstance(); |
10414 | newLeafNode(enumLiteral_5, grammarAccess.getComparisonOperatorAccess().getGREATER_EQEnumLiteralDeclaration_5()); | 9236 | newLeafNode(enumLiteral_5, grammarAccess.getComparisonOperatorAccess().getGREATER_EQEnumLiteralDeclaration_5()); |
10415 | 9237 | ||
10416 | } | ||
10417 | 9238 | ||
10418 | } | 9239 | } |
10419 | 9240 | ||
@@ -10421,18 +9242,16 @@ public class InternalSolverLanguageParser extends AbstractInternalAntlrParser { | |||
10421 | } | 9242 | } |
10422 | break; | 9243 | break; |
10423 | case 7 : | 9244 | case 7 : |
10424 | // InternalSolverLanguage.g:3613:3: (enumLiteral_6= 'in' ) | 9245 | // InternalSolverLanguageParser.g:3572:3: (enumLiteral_6= In ) |
10425 | { | 9246 | { |
10426 | // InternalSolverLanguage.g:3613:3: (enumLiteral_6= 'in' ) | 9247 | // InternalSolverLanguageParser.g:3572:3: (enumLiteral_6= In ) |
10427 | // InternalSolverLanguage.g:3614:4: enumLiteral_6= 'in' | 9248 | // InternalSolverLanguageParser.g:3573:4: enumLiteral_6= In |
10428 | { | 9249 | { |
10429 | enumLiteral_6=(Token)match(input,55,FOLLOW_2); if (state.failed) return current; | 9250 | enumLiteral_6=(Token)match(input,In,FOLLOW_2); |
10430 | if ( state.backtracking==0 ) { | ||
10431 | 9251 | ||
10432 | current = grammarAccess.getComparisonOperatorAccess().getINEnumLiteralDeclaration_6().getEnumLiteral().getInstance(); | 9252 | current = grammarAccess.getComparisonOperatorAccess().getINEnumLiteralDeclaration_6().getEnumLiteral().getInstance(); |
10433 | newLeafNode(enumLiteral_6, grammarAccess.getComparisonOperatorAccess().getINEnumLiteralDeclaration_6()); | 9253 | newLeafNode(enumLiteral_6, grammarAccess.getComparisonOperatorAccess().getINEnumLiteralDeclaration_6()); |
10434 | 9254 | ||
10435 | } | ||
10436 | 9255 | ||
10437 | } | 9256 | } |
10438 | 9257 | ||
@@ -10445,11 +9264,9 @@ public class InternalSolverLanguageParser extends AbstractInternalAntlrParser { | |||
10445 | 9264 | ||
10446 | } | 9265 | } |
10447 | 9266 | ||
10448 | if ( state.backtracking==0 ) { | ||
10449 | 9267 | ||
10450 | leaveRule(); | 9268 | leaveRule(); |
10451 | 9269 | ||
10452 | } | ||
10453 | } | 9270 | } |
10454 | 9271 | ||
10455 | catch (RecognitionException re) { | 9272 | catch (RecognitionException re) { |
@@ -10464,7 +9281,7 @@ public class InternalSolverLanguageParser extends AbstractInternalAntlrParser { | |||
10464 | 9281 | ||
10465 | 9282 | ||
10466 | // $ANTLR start "ruleAdditiveBinaryOperator" | 9283 | // $ANTLR start "ruleAdditiveBinaryOperator" |
10467 | // InternalSolverLanguage.g:3624:1: ruleAdditiveBinaryOperator returns [Enumerator current=null] : ( (enumLiteral_0= '+' ) | (enumLiteral_1= '-' ) ) ; | 9284 | // InternalSolverLanguageParser.g:3583:1: ruleAdditiveBinaryOperator returns [Enumerator current=null] : ( (enumLiteral_0= PlusSign ) | (enumLiteral_1= HyphenMinus ) ) ; |
10468 | public final Enumerator ruleAdditiveBinaryOperator() throws RecognitionException { | 9285 | public final Enumerator ruleAdditiveBinaryOperator() throws RecognitionException { |
10469 | Enumerator current = null; | 9286 | Enumerator current = null; |
10470 | 9287 | ||
@@ -10475,40 +9292,37 @@ public class InternalSolverLanguageParser extends AbstractInternalAntlrParser { | |||
10475 | enterRule(); | 9292 | enterRule(); |
10476 | 9293 | ||
10477 | try { | 9294 | try { |
10478 | // InternalSolverLanguage.g:3630:2: ( ( (enumLiteral_0= '+' ) | (enumLiteral_1= '-' ) ) ) | 9295 | // InternalSolverLanguageParser.g:3589:2: ( ( (enumLiteral_0= PlusSign ) | (enumLiteral_1= HyphenMinus ) ) ) |
10479 | // InternalSolverLanguage.g:3631:2: ( (enumLiteral_0= '+' ) | (enumLiteral_1= '-' ) ) | 9296 | // InternalSolverLanguageParser.g:3590:2: ( (enumLiteral_0= PlusSign ) | (enumLiteral_1= HyphenMinus ) ) |
10480 | { | 9297 | { |
10481 | // InternalSolverLanguage.g:3631:2: ( (enumLiteral_0= '+' ) | (enumLiteral_1= '-' ) ) | 9298 | // InternalSolverLanguageParser.g:3590:2: ( (enumLiteral_0= PlusSign ) | (enumLiteral_1= HyphenMinus ) ) |
10482 | int alt47=2; | 9299 | int alt46=2; |
10483 | int LA47_0 = input.LA(1); | 9300 | int LA46_0 = input.LA(1); |
10484 | 9301 | ||
10485 | if ( (LA47_0==56) ) { | 9302 | if ( (LA46_0==PlusSign) ) { |
10486 | alt47=1; | 9303 | alt46=1; |
10487 | } | 9304 | } |
10488 | else if ( (LA47_0==57) ) { | 9305 | else if ( (LA46_0==HyphenMinus) ) { |
10489 | alt47=2; | 9306 | alt46=2; |
10490 | } | 9307 | } |
10491 | else { | 9308 | else { |
10492 | if (state.backtracking>0) {state.failed=true; return current;} | ||
10493 | NoViableAltException nvae = | 9309 | NoViableAltException nvae = |
10494 | new NoViableAltException("", 47, 0, input); | 9310 | new NoViableAltException("", 46, 0, input); |
10495 | 9311 | ||
10496 | throw nvae; | 9312 | throw nvae; |
10497 | } | 9313 | } |
10498 | switch (alt47) { | 9314 | switch (alt46) { |
10499 | case 1 : | 9315 | case 1 : |
10500 | // InternalSolverLanguage.g:3632:3: (enumLiteral_0= '+' ) | 9316 | // InternalSolverLanguageParser.g:3591:3: (enumLiteral_0= PlusSign ) |
10501 | { | 9317 | { |
10502 | // InternalSolverLanguage.g:3632:3: (enumLiteral_0= '+' ) | 9318 | // InternalSolverLanguageParser.g:3591:3: (enumLiteral_0= PlusSign ) |
10503 | // InternalSolverLanguage.g:3633:4: enumLiteral_0= '+' | 9319 | // InternalSolverLanguageParser.g:3592:4: enumLiteral_0= PlusSign |
10504 | { | 9320 | { |
10505 | enumLiteral_0=(Token)match(input,56,FOLLOW_2); if (state.failed) return current; | 9321 | enumLiteral_0=(Token)match(input,PlusSign,FOLLOW_2); |
10506 | if ( state.backtracking==0 ) { | ||
10507 | 9322 | ||
10508 | current = grammarAccess.getAdditiveBinaryOperatorAccess().getADDEnumLiteralDeclaration_0().getEnumLiteral().getInstance(); | 9323 | current = grammarAccess.getAdditiveBinaryOperatorAccess().getADDEnumLiteralDeclaration_0().getEnumLiteral().getInstance(); |
10509 | newLeafNode(enumLiteral_0, grammarAccess.getAdditiveBinaryOperatorAccess().getADDEnumLiteralDeclaration_0()); | 9324 | newLeafNode(enumLiteral_0, grammarAccess.getAdditiveBinaryOperatorAccess().getADDEnumLiteralDeclaration_0()); |
10510 | 9325 | ||
10511 | } | ||
10512 | 9326 | ||
10513 | } | 9327 | } |
10514 | 9328 | ||
@@ -10516,18 +9330,16 @@ public class InternalSolverLanguageParser extends AbstractInternalAntlrParser { | |||
10516 | } | 9330 | } |
10517 | break; | 9331 | break; |
10518 | case 2 : | 9332 | case 2 : |
10519 | // InternalSolverLanguage.g:3640:3: (enumLiteral_1= '-' ) | 9333 | // InternalSolverLanguageParser.g:3599:3: (enumLiteral_1= HyphenMinus ) |
10520 | { | 9334 | { |
10521 | // InternalSolverLanguage.g:3640:3: (enumLiteral_1= '-' ) | 9335 | // InternalSolverLanguageParser.g:3599:3: (enumLiteral_1= HyphenMinus ) |
10522 | // InternalSolverLanguage.g:3641:4: enumLiteral_1= '-' | 9336 | // InternalSolverLanguageParser.g:3600:4: enumLiteral_1= HyphenMinus |
10523 | { | 9337 | { |
10524 | enumLiteral_1=(Token)match(input,57,FOLLOW_2); if (state.failed) return current; | 9338 | enumLiteral_1=(Token)match(input,HyphenMinus,FOLLOW_2); |
10525 | if ( state.backtracking==0 ) { | ||
10526 | 9339 | ||
10527 | current = grammarAccess.getAdditiveBinaryOperatorAccess().getSUBEnumLiteralDeclaration_1().getEnumLiteral().getInstance(); | 9340 | current = grammarAccess.getAdditiveBinaryOperatorAccess().getSUBEnumLiteralDeclaration_1().getEnumLiteral().getInstance(); |
10528 | newLeafNode(enumLiteral_1, grammarAccess.getAdditiveBinaryOperatorAccess().getSUBEnumLiteralDeclaration_1()); | 9341 | newLeafNode(enumLiteral_1, grammarAccess.getAdditiveBinaryOperatorAccess().getSUBEnumLiteralDeclaration_1()); |
10529 | 9342 | ||
10530 | } | ||
10531 | 9343 | ||
10532 | } | 9344 | } |
10533 | 9345 | ||
@@ -10540,11 +9352,9 @@ public class InternalSolverLanguageParser extends AbstractInternalAntlrParser { | |||
10540 | 9352 | ||
10541 | } | 9353 | } |
10542 | 9354 | ||
10543 | if ( state.backtracking==0 ) { | ||
10544 | 9355 | ||
10545 | leaveRule(); | 9356 | leaveRule(); |
10546 | 9357 | ||
10547 | } | ||
10548 | } | 9358 | } |
10549 | 9359 | ||
10550 | catch (RecognitionException re) { | 9360 | catch (RecognitionException re) { |
@@ -10559,7 +9369,7 @@ public class InternalSolverLanguageParser extends AbstractInternalAntlrParser { | |||
10559 | 9369 | ||
10560 | 9370 | ||
10561 | // $ANTLR start "ruleMultiplicativeBinaryOperator" | 9371 | // $ANTLR start "ruleMultiplicativeBinaryOperator" |
10562 | // InternalSolverLanguage.g:3651:1: ruleMultiplicativeBinaryOperator returns [Enumerator current=null] : ( (enumLiteral_0= '*' ) | (enumLiteral_1= '/' ) ) ; | 9372 | // InternalSolverLanguageParser.g:3610:1: ruleMultiplicativeBinaryOperator returns [Enumerator current=null] : ( (enumLiteral_0= Asterisk ) | (enumLiteral_1= Solidus ) ) ; |
10563 | public final Enumerator ruleMultiplicativeBinaryOperator() throws RecognitionException { | 9373 | public final Enumerator ruleMultiplicativeBinaryOperator() throws RecognitionException { |
10564 | Enumerator current = null; | 9374 | Enumerator current = null; |
10565 | 9375 | ||
@@ -10570,40 +9380,37 @@ public class InternalSolverLanguageParser extends AbstractInternalAntlrParser { | |||
10570 | enterRule(); | 9380 | enterRule(); |
10571 | 9381 | ||
10572 | try { | 9382 | try { |
10573 | // InternalSolverLanguage.g:3657:2: ( ( (enumLiteral_0= '*' ) | (enumLiteral_1= '/' ) ) ) | 9383 | // InternalSolverLanguageParser.g:3616:2: ( ( (enumLiteral_0= Asterisk ) | (enumLiteral_1= Solidus ) ) ) |
10574 | // InternalSolverLanguage.g:3658:2: ( (enumLiteral_0= '*' ) | (enumLiteral_1= '/' ) ) | 9384 | // InternalSolverLanguageParser.g:3617:2: ( (enumLiteral_0= Asterisk ) | (enumLiteral_1= Solidus ) ) |
10575 | { | 9385 | { |
10576 | // InternalSolverLanguage.g:3658:2: ( (enumLiteral_0= '*' ) | (enumLiteral_1= '/' ) ) | 9386 | // InternalSolverLanguageParser.g:3617:2: ( (enumLiteral_0= Asterisk ) | (enumLiteral_1= Solidus ) ) |
10577 | int alt48=2; | 9387 | int alt47=2; |
10578 | int LA48_0 = input.LA(1); | 9388 | int LA47_0 = input.LA(1); |
10579 | 9389 | ||
10580 | if ( (LA48_0==35) ) { | 9390 | if ( (LA47_0==Asterisk) ) { |
10581 | alt48=1; | 9391 | alt47=1; |
10582 | } | 9392 | } |
10583 | else if ( (LA48_0==58) ) { | 9393 | else if ( (LA47_0==Solidus) ) { |
10584 | alt48=2; | 9394 | alt47=2; |
10585 | } | 9395 | } |
10586 | else { | 9396 | else { |
10587 | if (state.backtracking>0) {state.failed=true; return current;} | ||
10588 | NoViableAltException nvae = | 9397 | NoViableAltException nvae = |
10589 | new NoViableAltException("", 48, 0, input); | 9398 | new NoViableAltException("", 47, 0, input); |
10590 | 9399 | ||
10591 | throw nvae; | 9400 | throw nvae; |
10592 | } | 9401 | } |
10593 | switch (alt48) { | 9402 | switch (alt47) { |
10594 | case 1 : | 9403 | case 1 : |
10595 | // InternalSolverLanguage.g:3659:3: (enumLiteral_0= '*' ) | 9404 | // InternalSolverLanguageParser.g:3618:3: (enumLiteral_0= Asterisk ) |
10596 | { | 9405 | { |
10597 | // InternalSolverLanguage.g:3659:3: (enumLiteral_0= '*' ) | 9406 | // InternalSolverLanguageParser.g:3618:3: (enumLiteral_0= Asterisk ) |
10598 | // InternalSolverLanguage.g:3660:4: enumLiteral_0= '*' | 9407 | // InternalSolverLanguageParser.g:3619:4: enumLiteral_0= Asterisk |
10599 | { | 9408 | { |
10600 | enumLiteral_0=(Token)match(input,35,FOLLOW_2); if (state.failed) return current; | 9409 | enumLiteral_0=(Token)match(input,Asterisk,FOLLOW_2); |
10601 | if ( state.backtracking==0 ) { | ||
10602 | 9410 | ||
10603 | current = grammarAccess.getMultiplicativeBinaryOperatorAccess().getMULEnumLiteralDeclaration_0().getEnumLiteral().getInstance(); | 9411 | current = grammarAccess.getMultiplicativeBinaryOperatorAccess().getMULEnumLiteralDeclaration_0().getEnumLiteral().getInstance(); |
10604 | newLeafNode(enumLiteral_0, grammarAccess.getMultiplicativeBinaryOperatorAccess().getMULEnumLiteralDeclaration_0()); | 9412 | newLeafNode(enumLiteral_0, grammarAccess.getMultiplicativeBinaryOperatorAccess().getMULEnumLiteralDeclaration_0()); |
10605 | 9413 | ||
10606 | } | ||
10607 | 9414 | ||
10608 | } | 9415 | } |
10609 | 9416 | ||
@@ -10611,18 +9418,16 @@ public class InternalSolverLanguageParser extends AbstractInternalAntlrParser { | |||
10611 | } | 9418 | } |
10612 | break; | 9419 | break; |
10613 | case 2 : | 9420 | case 2 : |
10614 | // InternalSolverLanguage.g:3667:3: (enumLiteral_1= '/' ) | 9421 | // InternalSolverLanguageParser.g:3626:3: (enumLiteral_1= Solidus ) |
10615 | { | 9422 | { |
10616 | // InternalSolverLanguage.g:3667:3: (enumLiteral_1= '/' ) | 9423 | // InternalSolverLanguageParser.g:3626:3: (enumLiteral_1= Solidus ) |
10617 | // InternalSolverLanguage.g:3668:4: enumLiteral_1= '/' | 9424 | // InternalSolverLanguageParser.g:3627:4: enumLiteral_1= Solidus |
10618 | { | 9425 | { |
10619 | enumLiteral_1=(Token)match(input,58,FOLLOW_2); if (state.failed) return current; | 9426 | enumLiteral_1=(Token)match(input,Solidus,FOLLOW_2); |
10620 | if ( state.backtracking==0 ) { | ||
10621 | 9427 | ||
10622 | current = grammarAccess.getMultiplicativeBinaryOperatorAccess().getDIVEnumLiteralDeclaration_1().getEnumLiteral().getInstance(); | 9428 | current = grammarAccess.getMultiplicativeBinaryOperatorAccess().getDIVEnumLiteralDeclaration_1().getEnumLiteral().getInstance(); |
10623 | newLeafNode(enumLiteral_1, grammarAccess.getMultiplicativeBinaryOperatorAccess().getDIVEnumLiteralDeclaration_1()); | 9429 | newLeafNode(enumLiteral_1, grammarAccess.getMultiplicativeBinaryOperatorAccess().getDIVEnumLiteralDeclaration_1()); |
10624 | 9430 | ||
10625 | } | ||
10626 | 9431 | ||
10627 | } | 9432 | } |
10628 | 9433 | ||
@@ -10635,11 +9440,9 @@ public class InternalSolverLanguageParser extends AbstractInternalAntlrParser { | |||
10635 | 9440 | ||
10636 | } | 9441 | } |
10637 | 9442 | ||
10638 | if ( state.backtracking==0 ) { | ||
10639 | 9443 | ||
10640 | leaveRule(); | 9444 | leaveRule(); |
10641 | 9445 | ||
10642 | } | ||
10643 | } | 9446 | } |
10644 | 9447 | ||
10645 | catch (RecognitionException re) { | 9448 | catch (RecognitionException re) { |
@@ -10654,7 +9457,7 @@ public class InternalSolverLanguageParser extends AbstractInternalAntlrParser { | |||
10654 | 9457 | ||
10655 | 9458 | ||
10656 | // $ANTLR start "ruleExponentialOp" | 9459 | // $ANTLR start "ruleExponentialOp" |
10657 | // InternalSolverLanguage.g:3678:1: ruleExponentialOp returns [Enumerator current=null] : (enumLiteral_0= '^' ) ; | 9460 | // InternalSolverLanguageParser.g:3637:1: ruleExponentialOp returns [Enumerator current=null] : (enumLiteral_0= CircumflexAccent ) ; |
10658 | public final Enumerator ruleExponentialOp() throws RecognitionException { | 9461 | public final Enumerator ruleExponentialOp() throws RecognitionException { |
10659 | Enumerator current = null; | 9462 | Enumerator current = null; |
10660 | 9463 | ||
@@ -10664,30 +9467,26 @@ public class InternalSolverLanguageParser extends AbstractInternalAntlrParser { | |||
10664 | enterRule(); | 9467 | enterRule(); |
10665 | 9468 | ||
10666 | try { | 9469 | try { |
10667 | // InternalSolverLanguage.g:3684:2: ( (enumLiteral_0= '^' ) ) | 9470 | // InternalSolverLanguageParser.g:3643:2: ( (enumLiteral_0= CircumflexAccent ) ) |
10668 | // InternalSolverLanguage.g:3685:2: (enumLiteral_0= '^' ) | 9471 | // InternalSolverLanguageParser.g:3644:2: (enumLiteral_0= CircumflexAccent ) |
10669 | { | 9472 | { |
10670 | // InternalSolverLanguage.g:3685:2: (enumLiteral_0= '^' ) | 9473 | // InternalSolverLanguageParser.g:3644:2: (enumLiteral_0= CircumflexAccent ) |
10671 | // InternalSolverLanguage.g:3686:3: enumLiteral_0= '^' | 9474 | // InternalSolverLanguageParser.g:3645:3: enumLiteral_0= CircumflexAccent |
10672 | { | 9475 | { |
10673 | enumLiteral_0=(Token)match(input,59,FOLLOW_2); if (state.failed) return current; | 9476 | enumLiteral_0=(Token)match(input,CircumflexAccent,FOLLOW_2); |
10674 | if ( state.backtracking==0 ) { | ||
10675 | 9477 | ||
10676 | current = grammarAccess.getExponentialOpAccess().getPOWEnumLiteralDeclaration().getEnumLiteral().getInstance(); | 9478 | current = grammarAccess.getExponentialOpAccess().getPOWEnumLiteralDeclaration().getEnumLiteral().getInstance(); |
10677 | newLeafNode(enumLiteral_0, grammarAccess.getExponentialOpAccess().getPOWEnumLiteralDeclaration()); | 9479 | newLeafNode(enumLiteral_0, grammarAccess.getExponentialOpAccess().getPOWEnumLiteralDeclaration()); |
10678 | 9480 | ||
10679 | } | ||
10680 | 9481 | ||
10681 | } | 9482 | } |
10682 | 9483 | ||
10683 | 9484 | ||
10684 | } | 9485 | } |
10685 | 9486 | ||
10686 | if ( state.backtracking==0 ) { | ||
10687 | 9487 | ||
10688 | leaveRule(); | 9488 | leaveRule(); |
10689 | 9489 | ||
10690 | } | ||
10691 | } | 9490 | } |
10692 | 9491 | ||
10693 | catch (RecognitionException re) { | 9492 | catch (RecognitionException re) { |
@@ -10702,7 +9501,7 @@ public class InternalSolverLanguageParser extends AbstractInternalAntlrParser { | |||
10702 | 9501 | ||
10703 | 9502 | ||
10704 | // $ANTLR start "ruleUnaryOp" | 9503 | // $ANTLR start "ruleUnaryOp" |
10705 | // InternalSolverLanguage.g:3695:1: ruleUnaryOp returns [Enumerator current=null] : ( (enumLiteral_0= '!' ) | (enumLiteral_1= '+' ) | (enumLiteral_2= '-' ) | (enumLiteral_3= 'may' ) | (enumLiteral_4= 'must' ) | (enumLiteral_5= 'current' ) ) ; | 9504 | // InternalSolverLanguageParser.g:3654:1: ruleUnaryOp returns [Enumerator current=null] : ( (enumLiteral_0= ExclamationMark ) | (enumLiteral_1= PlusSign ) | (enumLiteral_2= HyphenMinus ) | (enumLiteral_3= May ) | (enumLiteral_4= Must ) | (enumLiteral_5= Current ) ) ; |
10706 | public final Enumerator ruleUnaryOp() throws RecognitionException { | 9505 | public final Enumerator ruleUnaryOp() throws RecognitionException { |
10707 | Enumerator current = null; | 9506 | Enumerator current = null; |
10708 | 9507 | ||
@@ -10717,64 +9516,61 @@ public class InternalSolverLanguageParser extends AbstractInternalAntlrParser { | |||
10717 | enterRule(); | 9516 | enterRule(); |
10718 | 9517 | ||
10719 | try { | 9518 | try { |
10720 | // InternalSolverLanguage.g:3701:2: ( ( (enumLiteral_0= '!' ) | (enumLiteral_1= '+' ) | (enumLiteral_2= '-' ) | (enumLiteral_3= 'may' ) | (enumLiteral_4= 'must' ) | (enumLiteral_5= 'current' ) ) ) | 9519 | // InternalSolverLanguageParser.g:3660:2: ( ( (enumLiteral_0= ExclamationMark ) | (enumLiteral_1= PlusSign ) | (enumLiteral_2= HyphenMinus ) | (enumLiteral_3= May ) | (enumLiteral_4= Must ) | (enumLiteral_5= Current ) ) ) |
10721 | // InternalSolverLanguage.g:3702:2: ( (enumLiteral_0= '!' ) | (enumLiteral_1= '+' ) | (enumLiteral_2= '-' ) | (enumLiteral_3= 'may' ) | (enumLiteral_4= 'must' ) | (enumLiteral_5= 'current' ) ) | 9520 | // InternalSolverLanguageParser.g:3661:2: ( (enumLiteral_0= ExclamationMark ) | (enumLiteral_1= PlusSign ) | (enumLiteral_2= HyphenMinus ) | (enumLiteral_3= May ) | (enumLiteral_4= Must ) | (enumLiteral_5= Current ) ) |
10722 | { | 9521 | { |
10723 | // InternalSolverLanguage.g:3702:2: ( (enumLiteral_0= '!' ) | (enumLiteral_1= '+' ) | (enumLiteral_2= '-' ) | (enumLiteral_3= 'may' ) | (enumLiteral_4= 'must' ) | (enumLiteral_5= 'current' ) ) | 9522 | // InternalSolverLanguageParser.g:3661:2: ( (enumLiteral_0= ExclamationMark ) | (enumLiteral_1= PlusSign ) | (enumLiteral_2= HyphenMinus ) | (enumLiteral_3= May ) | (enumLiteral_4= Must ) | (enumLiteral_5= Current ) ) |
10724 | int alt49=6; | 9523 | int alt48=6; |
10725 | switch ( input.LA(1) ) { | 9524 | switch ( input.LA(1) ) { |
10726 | case 60: | 9525 | case ExclamationMark: |
10727 | { | 9526 | { |
10728 | alt49=1; | 9527 | alt48=1; |
10729 | } | 9528 | } |
10730 | break; | 9529 | break; |
10731 | case 56: | 9530 | case PlusSign: |
10732 | { | 9531 | { |
10733 | alt49=2; | 9532 | alt48=2; |
10734 | } | 9533 | } |
10735 | break; | 9534 | break; |
10736 | case 57: | 9535 | case HyphenMinus: |
10737 | { | 9536 | { |
10738 | alt49=3; | 9537 | alt48=3; |
10739 | } | 9538 | } |
10740 | break; | 9539 | break; |
10741 | case 61: | 9540 | case May: |
10742 | { | 9541 | { |
10743 | alt49=4; | 9542 | alt48=4; |
10744 | } | 9543 | } |
10745 | break; | 9544 | break; |
10746 | case 62: | 9545 | case Must: |
10747 | { | 9546 | { |
10748 | alt49=5; | 9547 | alt48=5; |
10749 | } | 9548 | } |
10750 | break; | 9549 | break; |
10751 | case 63: | 9550 | case Current: |
10752 | { | 9551 | { |
10753 | alt49=6; | 9552 | alt48=6; |
10754 | } | 9553 | } |
10755 | break; | 9554 | break; |
10756 | default: | 9555 | default: |
10757 | if (state.backtracking>0) {state.failed=true; return current;} | ||
10758 | NoViableAltException nvae = | 9556 | NoViableAltException nvae = |
10759 | new NoViableAltException("", 49, 0, input); | 9557 | new NoViableAltException("", 48, 0, input); |
10760 | 9558 | ||
10761 | throw nvae; | 9559 | throw nvae; |
10762 | } | 9560 | } |
10763 | 9561 | ||
10764 | switch (alt49) { | 9562 | switch (alt48) { |
10765 | case 1 : | 9563 | case 1 : |
10766 | // InternalSolverLanguage.g:3703:3: (enumLiteral_0= '!' ) | 9564 | // InternalSolverLanguageParser.g:3662:3: (enumLiteral_0= ExclamationMark ) |
10767 | { | 9565 | { |
10768 | // InternalSolverLanguage.g:3703:3: (enumLiteral_0= '!' ) | 9566 | // InternalSolverLanguageParser.g:3662:3: (enumLiteral_0= ExclamationMark ) |
10769 | // InternalSolverLanguage.g:3704:4: enumLiteral_0= '!' | 9567 | // InternalSolverLanguageParser.g:3663:4: enumLiteral_0= ExclamationMark |
10770 | { | 9568 | { |
10771 | enumLiteral_0=(Token)match(input,60,FOLLOW_2); if (state.failed) return current; | 9569 | enumLiteral_0=(Token)match(input,ExclamationMark,FOLLOW_2); |
10772 | if ( state.backtracking==0 ) { | ||
10773 | 9570 | ||
10774 | current = grammarAccess.getUnaryOpAccess().getNEGEnumLiteralDeclaration_0().getEnumLiteral().getInstance(); | 9571 | current = grammarAccess.getUnaryOpAccess().getNEGEnumLiteralDeclaration_0().getEnumLiteral().getInstance(); |
10775 | newLeafNode(enumLiteral_0, grammarAccess.getUnaryOpAccess().getNEGEnumLiteralDeclaration_0()); | 9572 | newLeafNode(enumLiteral_0, grammarAccess.getUnaryOpAccess().getNEGEnumLiteralDeclaration_0()); |
10776 | 9573 | ||
10777 | } | ||
10778 | 9574 | ||
10779 | } | 9575 | } |
10780 | 9576 | ||
@@ -10782,18 +9578,16 @@ public class InternalSolverLanguageParser extends AbstractInternalAntlrParser { | |||
10782 | } | 9578 | } |
10783 | break; | 9579 | break; |
10784 | case 2 : | 9580 | case 2 : |
10785 | // InternalSolverLanguage.g:3711:3: (enumLiteral_1= '+' ) | 9581 | // InternalSolverLanguageParser.g:3670:3: (enumLiteral_1= PlusSign ) |
10786 | { | 9582 | { |
10787 | // InternalSolverLanguage.g:3711:3: (enumLiteral_1= '+' ) | 9583 | // InternalSolverLanguageParser.g:3670:3: (enumLiteral_1= PlusSign ) |
10788 | // InternalSolverLanguage.g:3712:4: enumLiteral_1= '+' | 9584 | // InternalSolverLanguageParser.g:3671:4: enumLiteral_1= PlusSign |
10789 | { | 9585 | { |
10790 | enumLiteral_1=(Token)match(input,56,FOLLOW_2); if (state.failed) return current; | 9586 | enumLiteral_1=(Token)match(input,PlusSign,FOLLOW_2); |
10791 | if ( state.backtracking==0 ) { | ||
10792 | 9587 | ||
10793 | current = grammarAccess.getUnaryOpAccess().getPLUSEnumLiteralDeclaration_1().getEnumLiteral().getInstance(); | 9588 | current = grammarAccess.getUnaryOpAccess().getPLUSEnumLiteralDeclaration_1().getEnumLiteral().getInstance(); |
10794 | newLeafNode(enumLiteral_1, grammarAccess.getUnaryOpAccess().getPLUSEnumLiteralDeclaration_1()); | 9589 | newLeafNode(enumLiteral_1, grammarAccess.getUnaryOpAccess().getPLUSEnumLiteralDeclaration_1()); |
10795 | 9590 | ||
10796 | } | ||
10797 | 9591 | ||
10798 | } | 9592 | } |
10799 | 9593 | ||
@@ -10801,18 +9595,16 @@ public class InternalSolverLanguageParser extends AbstractInternalAntlrParser { | |||
10801 | } | 9595 | } |
10802 | break; | 9596 | break; |
10803 | case 3 : | 9597 | case 3 : |
10804 | // InternalSolverLanguage.g:3719:3: (enumLiteral_2= '-' ) | 9598 | // InternalSolverLanguageParser.g:3678:3: (enumLiteral_2= HyphenMinus ) |
10805 | { | 9599 | { |
10806 | // InternalSolverLanguage.g:3719:3: (enumLiteral_2= '-' ) | 9600 | // InternalSolverLanguageParser.g:3678:3: (enumLiteral_2= HyphenMinus ) |
10807 | // InternalSolverLanguage.g:3720:4: enumLiteral_2= '-' | 9601 | // InternalSolverLanguageParser.g:3679:4: enumLiteral_2= HyphenMinus |
10808 | { | 9602 | { |
10809 | enumLiteral_2=(Token)match(input,57,FOLLOW_2); if (state.failed) return current; | 9603 | enumLiteral_2=(Token)match(input,HyphenMinus,FOLLOW_2); |
10810 | if ( state.backtracking==0 ) { | ||
10811 | 9604 | ||
10812 | current = grammarAccess.getUnaryOpAccess().getMINUSEnumLiteralDeclaration_2().getEnumLiteral().getInstance(); | 9605 | current = grammarAccess.getUnaryOpAccess().getMINUSEnumLiteralDeclaration_2().getEnumLiteral().getInstance(); |
10813 | newLeafNode(enumLiteral_2, grammarAccess.getUnaryOpAccess().getMINUSEnumLiteralDeclaration_2()); | 9606 | newLeafNode(enumLiteral_2, grammarAccess.getUnaryOpAccess().getMINUSEnumLiteralDeclaration_2()); |
10814 | 9607 | ||
10815 | } | ||
10816 | 9608 | ||
10817 | } | 9609 | } |
10818 | 9610 | ||
@@ -10820,18 +9612,16 @@ public class InternalSolverLanguageParser extends AbstractInternalAntlrParser { | |||
10820 | } | 9612 | } |
10821 | break; | 9613 | break; |
10822 | case 4 : | 9614 | case 4 : |
10823 | // InternalSolverLanguage.g:3727:3: (enumLiteral_3= 'may' ) | 9615 | // InternalSolverLanguageParser.g:3686:3: (enumLiteral_3= May ) |
10824 | { | 9616 | { |
10825 | // InternalSolverLanguage.g:3727:3: (enumLiteral_3= 'may' ) | 9617 | // InternalSolverLanguageParser.g:3686:3: (enumLiteral_3= May ) |
10826 | // InternalSolverLanguage.g:3728:4: enumLiteral_3= 'may' | 9618 | // InternalSolverLanguageParser.g:3687:4: enumLiteral_3= May |
10827 | { | 9619 | { |
10828 | enumLiteral_3=(Token)match(input,61,FOLLOW_2); if (state.failed) return current; | 9620 | enumLiteral_3=(Token)match(input,May,FOLLOW_2); |
10829 | if ( state.backtracking==0 ) { | ||
10830 | 9621 | ||
10831 | current = grammarAccess.getUnaryOpAccess().getMAYEnumLiteralDeclaration_3().getEnumLiteral().getInstance(); | 9622 | current = grammarAccess.getUnaryOpAccess().getMAYEnumLiteralDeclaration_3().getEnumLiteral().getInstance(); |
10832 | newLeafNode(enumLiteral_3, grammarAccess.getUnaryOpAccess().getMAYEnumLiteralDeclaration_3()); | 9623 | newLeafNode(enumLiteral_3, grammarAccess.getUnaryOpAccess().getMAYEnumLiteralDeclaration_3()); |
10833 | 9624 | ||
10834 | } | ||
10835 | 9625 | ||
10836 | } | 9626 | } |
10837 | 9627 | ||
@@ -10839,18 +9629,16 @@ public class InternalSolverLanguageParser extends AbstractInternalAntlrParser { | |||
10839 | } | 9629 | } |
10840 | break; | 9630 | break; |
10841 | case 5 : | 9631 | case 5 : |
10842 | // InternalSolverLanguage.g:3735:3: (enumLiteral_4= 'must' ) | 9632 | // InternalSolverLanguageParser.g:3694:3: (enumLiteral_4= Must ) |
10843 | { | 9633 | { |
10844 | // InternalSolverLanguage.g:3735:3: (enumLiteral_4= 'must' ) | 9634 | // InternalSolverLanguageParser.g:3694:3: (enumLiteral_4= Must ) |
10845 | // InternalSolverLanguage.g:3736:4: enumLiteral_4= 'must' | 9635 | // InternalSolverLanguageParser.g:3695:4: enumLiteral_4= Must |
10846 | { | 9636 | { |
10847 | enumLiteral_4=(Token)match(input,62,FOLLOW_2); if (state.failed) return current; | 9637 | enumLiteral_4=(Token)match(input,Must,FOLLOW_2); |
10848 | if ( state.backtracking==0 ) { | ||
10849 | 9638 | ||
10850 | current = grammarAccess.getUnaryOpAccess().getMUSTEnumLiteralDeclaration_4().getEnumLiteral().getInstance(); | 9639 | current = grammarAccess.getUnaryOpAccess().getMUSTEnumLiteralDeclaration_4().getEnumLiteral().getInstance(); |
10851 | newLeafNode(enumLiteral_4, grammarAccess.getUnaryOpAccess().getMUSTEnumLiteralDeclaration_4()); | 9640 | newLeafNode(enumLiteral_4, grammarAccess.getUnaryOpAccess().getMUSTEnumLiteralDeclaration_4()); |
10852 | 9641 | ||
10853 | } | ||
10854 | 9642 | ||
10855 | } | 9643 | } |
10856 | 9644 | ||
@@ -10858,18 +9646,16 @@ public class InternalSolverLanguageParser extends AbstractInternalAntlrParser { | |||
10858 | } | 9646 | } |
10859 | break; | 9647 | break; |
10860 | case 6 : | 9648 | case 6 : |
10861 | // InternalSolverLanguage.g:3743:3: (enumLiteral_5= 'current' ) | 9649 | // InternalSolverLanguageParser.g:3702:3: (enumLiteral_5= Current ) |
10862 | { | 9650 | { |
10863 | // InternalSolverLanguage.g:3743:3: (enumLiteral_5= 'current' ) | 9651 | // InternalSolverLanguageParser.g:3702:3: (enumLiteral_5= Current ) |
10864 | // InternalSolverLanguage.g:3744:4: enumLiteral_5= 'current' | 9652 | // InternalSolverLanguageParser.g:3703:4: enumLiteral_5= Current |
10865 | { | 9653 | { |
10866 | enumLiteral_5=(Token)match(input,63,FOLLOW_2); if (state.failed) return current; | 9654 | enumLiteral_5=(Token)match(input,Current,FOLLOW_2); |
10867 | if ( state.backtracking==0 ) { | ||
10868 | 9655 | ||
10869 | current = grammarAccess.getUnaryOpAccess().getCURRENTEnumLiteralDeclaration_5().getEnumLiteral().getInstance(); | 9656 | current = grammarAccess.getUnaryOpAccess().getCURRENTEnumLiteralDeclaration_5().getEnumLiteral().getInstance(); |
10870 | newLeafNode(enumLiteral_5, grammarAccess.getUnaryOpAccess().getCURRENTEnumLiteralDeclaration_5()); | 9657 | newLeafNode(enumLiteral_5, grammarAccess.getUnaryOpAccess().getCURRENTEnumLiteralDeclaration_5()); |
10871 | 9658 | ||
10872 | } | ||
10873 | 9659 | ||
10874 | } | 9660 | } |
10875 | 9661 | ||
@@ -10882,11 +9668,9 @@ public class InternalSolverLanguageParser extends AbstractInternalAntlrParser { | |||
10882 | 9668 | ||
10883 | } | 9669 | } |
10884 | 9670 | ||
10885 | if ( state.backtracking==0 ) { | ||
10886 | 9671 | ||
10887 | leaveRule(); | 9672 | leaveRule(); |
10888 | 9673 | ||
10889 | } | ||
10890 | } | 9674 | } |
10891 | 9675 | ||
10892 | catch (RecognitionException re) { | 9676 | catch (RecognitionException re) { |
@@ -10901,7 +9685,7 @@ public class InternalSolverLanguageParser extends AbstractInternalAntlrParser { | |||
10901 | 9685 | ||
10902 | 9686 | ||
10903 | // $ANTLR start "ruleAggregationOp" | 9687 | // $ANTLR start "ruleAggregationOp" |
10904 | // InternalSolverLanguage.g:3754:1: ruleAggregationOp returns [Enumerator current=null] : ( (enumLiteral_0= 'only' ) | (enumLiteral_1= 'sum' ) | (enumLiteral_2= 'prod' ) | (enumLiteral_3= 'avg' ) | (enumLiteral_4= 'min' ) | (enumLiteral_5= 'max' ) ) ; | 9688 | // InternalSolverLanguageParser.g:3713:1: ruleAggregationOp returns [Enumerator current=null] : ( (enumLiteral_0= Only ) | (enumLiteral_1= Sum ) | (enumLiteral_2= Prod ) | (enumLiteral_3= Avg ) | (enumLiteral_4= Min ) | (enumLiteral_5= Max ) ) ; |
10905 | public final Enumerator ruleAggregationOp() throws RecognitionException { | 9689 | public final Enumerator ruleAggregationOp() throws RecognitionException { |
10906 | Enumerator current = null; | 9690 | Enumerator current = null; |
10907 | 9691 | ||
@@ -10916,64 +9700,61 @@ public class InternalSolverLanguageParser extends AbstractInternalAntlrParser { | |||
10916 | enterRule(); | 9700 | enterRule(); |
10917 | 9701 | ||
10918 | try { | 9702 | try { |
10919 | // InternalSolverLanguage.g:3760:2: ( ( (enumLiteral_0= 'only' ) | (enumLiteral_1= 'sum' ) | (enumLiteral_2= 'prod' ) | (enumLiteral_3= 'avg' ) | (enumLiteral_4= 'min' ) | (enumLiteral_5= 'max' ) ) ) | 9703 | // InternalSolverLanguageParser.g:3719:2: ( ( (enumLiteral_0= Only ) | (enumLiteral_1= Sum ) | (enumLiteral_2= Prod ) | (enumLiteral_3= Avg ) | (enumLiteral_4= Min ) | (enumLiteral_5= Max ) ) ) |
10920 | // InternalSolverLanguage.g:3761:2: ( (enumLiteral_0= 'only' ) | (enumLiteral_1= 'sum' ) | (enumLiteral_2= 'prod' ) | (enumLiteral_3= 'avg' ) | (enumLiteral_4= 'min' ) | (enumLiteral_5= 'max' ) ) | 9704 | // InternalSolverLanguageParser.g:3720:2: ( (enumLiteral_0= Only ) | (enumLiteral_1= Sum ) | (enumLiteral_2= Prod ) | (enumLiteral_3= Avg ) | (enumLiteral_4= Min ) | (enumLiteral_5= Max ) ) |
10921 | { | 9705 | { |
10922 | // InternalSolverLanguage.g:3761:2: ( (enumLiteral_0= 'only' ) | (enumLiteral_1= 'sum' ) | (enumLiteral_2= 'prod' ) | (enumLiteral_3= 'avg' ) | (enumLiteral_4= 'min' ) | (enumLiteral_5= 'max' ) ) | 9706 | // InternalSolverLanguageParser.g:3720:2: ( (enumLiteral_0= Only ) | (enumLiteral_1= Sum ) | (enumLiteral_2= Prod ) | (enumLiteral_3= Avg ) | (enumLiteral_4= Min ) | (enumLiteral_5= Max ) ) |
10923 | int alt50=6; | 9707 | int alt49=6; |
10924 | switch ( input.LA(1) ) { | 9708 | switch ( input.LA(1) ) { |
10925 | case 64: | 9709 | case Only: |
10926 | { | 9710 | { |
10927 | alt50=1; | 9711 | alt49=1; |
10928 | } | 9712 | } |
10929 | break; | 9713 | break; |
10930 | case 65: | 9714 | case Sum: |
10931 | { | 9715 | { |
10932 | alt50=2; | 9716 | alt49=2; |
10933 | } | 9717 | } |
10934 | break; | 9718 | break; |
10935 | case 66: | 9719 | case Prod: |
10936 | { | 9720 | { |
10937 | alt50=3; | 9721 | alt49=3; |
10938 | } | 9722 | } |
10939 | break; | 9723 | break; |
10940 | case 67: | 9724 | case Avg: |
10941 | { | 9725 | { |
10942 | alt50=4; | 9726 | alt49=4; |
10943 | } | 9727 | } |
10944 | break; | 9728 | break; |
10945 | case 68: | 9729 | case Min: |
10946 | { | 9730 | { |
10947 | alt50=5; | 9731 | alt49=5; |
10948 | } | 9732 | } |
10949 | break; | 9733 | break; |
10950 | case 69: | 9734 | case Max: |
10951 | { | 9735 | { |
10952 | alt50=6; | 9736 | alt49=6; |
10953 | } | 9737 | } |
10954 | break; | 9738 | break; |
10955 | default: | 9739 | default: |
10956 | if (state.backtracking>0) {state.failed=true; return current;} | ||
10957 | NoViableAltException nvae = | 9740 | NoViableAltException nvae = |
10958 | new NoViableAltException("", 50, 0, input); | 9741 | new NoViableAltException("", 49, 0, input); |
10959 | 9742 | ||
10960 | throw nvae; | 9743 | throw nvae; |
10961 | } | 9744 | } |
10962 | 9745 | ||
10963 | switch (alt50) { | 9746 | switch (alt49) { |
10964 | case 1 : | 9747 | case 1 : |
10965 | // InternalSolverLanguage.g:3762:3: (enumLiteral_0= 'only' ) | 9748 | // InternalSolverLanguageParser.g:3721:3: (enumLiteral_0= Only ) |
10966 | { | 9749 | { |
10967 | // InternalSolverLanguage.g:3762:3: (enumLiteral_0= 'only' ) | 9750 | // InternalSolverLanguageParser.g:3721:3: (enumLiteral_0= Only ) |
10968 | // InternalSolverLanguage.g:3763:4: enumLiteral_0= 'only' | 9751 | // InternalSolverLanguageParser.g:3722:4: enumLiteral_0= Only |
10969 | { | 9752 | { |
10970 | enumLiteral_0=(Token)match(input,64,FOLLOW_2); if (state.failed) return current; | 9753 | enumLiteral_0=(Token)match(input,Only,FOLLOW_2); |
10971 | if ( state.backtracking==0 ) { | ||
10972 | 9754 | ||
10973 | current = grammarAccess.getAggregationOpAccess().getONLYEnumLiteralDeclaration_0().getEnumLiteral().getInstance(); | 9755 | current = grammarAccess.getAggregationOpAccess().getONLYEnumLiteralDeclaration_0().getEnumLiteral().getInstance(); |
10974 | newLeafNode(enumLiteral_0, grammarAccess.getAggregationOpAccess().getONLYEnumLiteralDeclaration_0()); | 9756 | newLeafNode(enumLiteral_0, grammarAccess.getAggregationOpAccess().getONLYEnumLiteralDeclaration_0()); |
10975 | 9757 | ||
10976 | } | ||
10977 | 9758 | ||
10978 | } | 9759 | } |
10979 | 9760 | ||
@@ -10981,18 +9762,16 @@ public class InternalSolverLanguageParser extends AbstractInternalAntlrParser { | |||
10981 | } | 9762 | } |
10982 | break; | 9763 | break; |
10983 | case 2 : | 9764 | case 2 : |
10984 | // InternalSolverLanguage.g:3770:3: (enumLiteral_1= 'sum' ) | 9765 | // InternalSolverLanguageParser.g:3729:3: (enumLiteral_1= Sum ) |
10985 | { | 9766 | { |
10986 | // InternalSolverLanguage.g:3770:3: (enumLiteral_1= 'sum' ) | 9767 | // InternalSolverLanguageParser.g:3729:3: (enumLiteral_1= Sum ) |
10987 | // InternalSolverLanguage.g:3771:4: enumLiteral_1= 'sum' | 9768 | // InternalSolverLanguageParser.g:3730:4: enumLiteral_1= Sum |
10988 | { | 9769 | { |
10989 | enumLiteral_1=(Token)match(input,65,FOLLOW_2); if (state.failed) return current; | 9770 | enumLiteral_1=(Token)match(input,Sum,FOLLOW_2); |
10990 | if ( state.backtracking==0 ) { | ||
10991 | 9771 | ||
10992 | current = grammarAccess.getAggregationOpAccess().getSUMEnumLiteralDeclaration_1().getEnumLiteral().getInstance(); | 9772 | current = grammarAccess.getAggregationOpAccess().getSUMEnumLiteralDeclaration_1().getEnumLiteral().getInstance(); |
10993 | newLeafNode(enumLiteral_1, grammarAccess.getAggregationOpAccess().getSUMEnumLiteralDeclaration_1()); | 9773 | newLeafNode(enumLiteral_1, grammarAccess.getAggregationOpAccess().getSUMEnumLiteralDeclaration_1()); |
10994 | 9774 | ||
10995 | } | ||
10996 | 9775 | ||
10997 | } | 9776 | } |
10998 | 9777 | ||
@@ -11000,18 +9779,16 @@ public class InternalSolverLanguageParser extends AbstractInternalAntlrParser { | |||
11000 | } | 9779 | } |
11001 | break; | 9780 | break; |
11002 | case 3 : | 9781 | case 3 : |
11003 | // InternalSolverLanguage.g:3778:3: (enumLiteral_2= 'prod' ) | 9782 | // InternalSolverLanguageParser.g:3737:3: (enumLiteral_2= Prod ) |
11004 | { | 9783 | { |
11005 | // InternalSolverLanguage.g:3778:3: (enumLiteral_2= 'prod' ) | 9784 | // InternalSolverLanguageParser.g:3737:3: (enumLiteral_2= Prod ) |
11006 | // InternalSolverLanguage.g:3779:4: enumLiteral_2= 'prod' | 9785 | // InternalSolverLanguageParser.g:3738:4: enumLiteral_2= Prod |
11007 | { | 9786 | { |
11008 | enumLiteral_2=(Token)match(input,66,FOLLOW_2); if (state.failed) return current; | 9787 | enumLiteral_2=(Token)match(input,Prod,FOLLOW_2); |
11009 | if ( state.backtracking==0 ) { | ||
11010 | 9788 | ||
11011 | current = grammarAccess.getAggregationOpAccess().getPRODEnumLiteralDeclaration_2().getEnumLiteral().getInstance(); | 9789 | current = grammarAccess.getAggregationOpAccess().getPRODEnumLiteralDeclaration_2().getEnumLiteral().getInstance(); |
11012 | newLeafNode(enumLiteral_2, grammarAccess.getAggregationOpAccess().getPRODEnumLiteralDeclaration_2()); | 9790 | newLeafNode(enumLiteral_2, grammarAccess.getAggregationOpAccess().getPRODEnumLiteralDeclaration_2()); |
11013 | 9791 | ||
11014 | } | ||
11015 | 9792 | ||
11016 | } | 9793 | } |
11017 | 9794 | ||
@@ -11019,18 +9796,16 @@ public class InternalSolverLanguageParser extends AbstractInternalAntlrParser { | |||
11019 | } | 9796 | } |
11020 | break; | 9797 | break; |
11021 | case 4 : | 9798 | case 4 : |
11022 | // InternalSolverLanguage.g:3786:3: (enumLiteral_3= 'avg' ) | 9799 | // InternalSolverLanguageParser.g:3745:3: (enumLiteral_3= Avg ) |
11023 | { | 9800 | { |
11024 | // InternalSolverLanguage.g:3786:3: (enumLiteral_3= 'avg' ) | 9801 | // InternalSolverLanguageParser.g:3745:3: (enumLiteral_3= Avg ) |
11025 | // InternalSolverLanguage.g:3787:4: enumLiteral_3= 'avg' | 9802 | // InternalSolverLanguageParser.g:3746:4: enumLiteral_3= Avg |
11026 | { | 9803 | { |
11027 | enumLiteral_3=(Token)match(input,67,FOLLOW_2); if (state.failed) return current; | 9804 | enumLiteral_3=(Token)match(input,Avg,FOLLOW_2); |
11028 | if ( state.backtracking==0 ) { | ||
11029 | 9805 | ||
11030 | current = grammarAccess.getAggregationOpAccess().getAVGEnumLiteralDeclaration_3().getEnumLiteral().getInstance(); | 9806 | current = grammarAccess.getAggregationOpAccess().getAVGEnumLiteralDeclaration_3().getEnumLiteral().getInstance(); |
11031 | newLeafNode(enumLiteral_3, grammarAccess.getAggregationOpAccess().getAVGEnumLiteralDeclaration_3()); | 9807 | newLeafNode(enumLiteral_3, grammarAccess.getAggregationOpAccess().getAVGEnumLiteralDeclaration_3()); |
11032 | 9808 | ||
11033 | } | ||
11034 | 9809 | ||
11035 | } | 9810 | } |
11036 | 9811 | ||
@@ -11038,18 +9813,16 @@ public class InternalSolverLanguageParser extends AbstractInternalAntlrParser { | |||
11038 | } | 9813 | } |
11039 | break; | 9814 | break; |
11040 | case 5 : | 9815 | case 5 : |
11041 | // InternalSolverLanguage.g:3794:3: (enumLiteral_4= 'min' ) | 9816 | // InternalSolverLanguageParser.g:3753:3: (enumLiteral_4= Min ) |
11042 | { | 9817 | { |
11043 | // InternalSolverLanguage.g:3794:3: (enumLiteral_4= 'min' ) | 9818 | // InternalSolverLanguageParser.g:3753:3: (enumLiteral_4= Min ) |
11044 | // InternalSolverLanguage.g:3795:4: enumLiteral_4= 'min' | 9819 | // InternalSolverLanguageParser.g:3754:4: enumLiteral_4= Min |
11045 | { | 9820 | { |
11046 | enumLiteral_4=(Token)match(input,68,FOLLOW_2); if (state.failed) return current; | 9821 | enumLiteral_4=(Token)match(input,Min,FOLLOW_2); |
11047 | if ( state.backtracking==0 ) { | ||
11048 | 9822 | ||
11049 | current = grammarAccess.getAggregationOpAccess().getMINEnumLiteralDeclaration_4().getEnumLiteral().getInstance(); | 9823 | current = grammarAccess.getAggregationOpAccess().getMINEnumLiteralDeclaration_4().getEnumLiteral().getInstance(); |
11050 | newLeafNode(enumLiteral_4, grammarAccess.getAggregationOpAccess().getMINEnumLiteralDeclaration_4()); | 9824 | newLeafNode(enumLiteral_4, grammarAccess.getAggregationOpAccess().getMINEnumLiteralDeclaration_4()); |
11051 | 9825 | ||
11052 | } | ||
11053 | 9826 | ||
11054 | } | 9827 | } |
11055 | 9828 | ||
@@ -11057,18 +9830,16 @@ public class InternalSolverLanguageParser extends AbstractInternalAntlrParser { | |||
11057 | } | 9830 | } |
11058 | break; | 9831 | break; |
11059 | case 6 : | 9832 | case 6 : |
11060 | // InternalSolverLanguage.g:3802:3: (enumLiteral_5= 'max' ) | 9833 | // InternalSolverLanguageParser.g:3761:3: (enumLiteral_5= Max ) |
11061 | { | 9834 | { |
11062 | // InternalSolverLanguage.g:3802:3: (enumLiteral_5= 'max' ) | 9835 | // InternalSolverLanguageParser.g:3761:3: (enumLiteral_5= Max ) |
11063 | // InternalSolverLanguage.g:3803:4: enumLiteral_5= 'max' | 9836 | // InternalSolverLanguageParser.g:3762:4: enumLiteral_5= Max |
11064 | { | 9837 | { |
11065 | enumLiteral_5=(Token)match(input,69,FOLLOW_2); if (state.failed) return current; | 9838 | enumLiteral_5=(Token)match(input,Max,FOLLOW_2); |
11066 | if ( state.backtracking==0 ) { | ||
11067 | 9839 | ||
11068 | current = grammarAccess.getAggregationOpAccess().getMAXEnumLiteralDeclaration_5().getEnumLiteral().getInstance(); | 9840 | current = grammarAccess.getAggregationOpAccess().getMAXEnumLiteralDeclaration_5().getEnumLiteral().getInstance(); |
11069 | newLeafNode(enumLiteral_5, grammarAccess.getAggregationOpAccess().getMAXEnumLiteralDeclaration_5()); | 9841 | newLeafNode(enumLiteral_5, grammarAccess.getAggregationOpAccess().getMAXEnumLiteralDeclaration_5()); |
11070 | 9842 | ||
11071 | } | ||
11072 | 9843 | ||
11073 | } | 9844 | } |
11074 | 9845 | ||
@@ -11081,11 +9852,9 @@ public class InternalSolverLanguageParser extends AbstractInternalAntlrParser { | |||
11081 | 9852 | ||
11082 | } | 9853 | } |
11083 | 9854 | ||
11084 | if ( state.backtracking==0 ) { | ||
11085 | 9855 | ||
11086 | leaveRule(); | 9856 | leaveRule(); |
11087 | 9857 | ||
11088 | } | ||
11089 | } | 9858 | } |
11090 | 9859 | ||
11091 | catch (RecognitionException re) { | 9860 | catch (RecognitionException re) { |
@@ -11100,7 +9869,7 @@ public class InternalSolverLanguageParser extends AbstractInternalAntlrParser { | |||
11100 | 9869 | ||
11101 | 9870 | ||
11102 | // $ANTLR start "ruleLogicValue" | 9871 | // $ANTLR start "ruleLogicValue" |
11103 | // InternalSolverLanguage.g:3813:1: ruleLogicValue returns [Enumerator current=null] : ( (enumLiteral_0= 'true' ) | (enumLiteral_1= 'false' ) | (enumLiteral_2= 'unknown' ) | (enumLiteral_3= 'error' ) ) ; | 9872 | // InternalSolverLanguageParser.g:3772:1: ruleLogicValue returns [Enumerator current=null] : ( (enumLiteral_0= True ) | (enumLiteral_1= False ) | (enumLiteral_2= Unknown ) | (enumLiteral_3= Error ) ) ; |
11104 | public final Enumerator ruleLogicValue() throws RecognitionException { | 9873 | public final Enumerator ruleLogicValue() throws RecognitionException { |
11105 | Enumerator current = null; | 9874 | Enumerator current = null; |
11106 | 9875 | ||
@@ -11113,54 +9882,51 @@ public class InternalSolverLanguageParser extends AbstractInternalAntlrParser { | |||
11113 | enterRule(); | 9882 | enterRule(); |
11114 | 9883 | ||
11115 | try { | 9884 | try { |
11116 | // InternalSolverLanguage.g:3819:2: ( ( (enumLiteral_0= 'true' ) | (enumLiteral_1= 'false' ) | (enumLiteral_2= 'unknown' ) | (enumLiteral_3= 'error' ) ) ) | 9885 | // InternalSolverLanguageParser.g:3778:2: ( ( (enumLiteral_0= True ) | (enumLiteral_1= False ) | (enumLiteral_2= Unknown ) | (enumLiteral_3= Error ) ) ) |
11117 | // InternalSolverLanguage.g:3820:2: ( (enumLiteral_0= 'true' ) | (enumLiteral_1= 'false' ) | (enumLiteral_2= 'unknown' ) | (enumLiteral_3= 'error' ) ) | 9886 | // InternalSolverLanguageParser.g:3779:2: ( (enumLiteral_0= True ) | (enumLiteral_1= False ) | (enumLiteral_2= Unknown ) | (enumLiteral_3= Error ) ) |
11118 | { | 9887 | { |
11119 | // InternalSolverLanguage.g:3820:2: ( (enumLiteral_0= 'true' ) | (enumLiteral_1= 'false' ) | (enumLiteral_2= 'unknown' ) | (enumLiteral_3= 'error' ) ) | 9888 | // InternalSolverLanguageParser.g:3779:2: ( (enumLiteral_0= True ) | (enumLiteral_1= False ) | (enumLiteral_2= Unknown ) | (enumLiteral_3= Error ) ) |
11120 | int alt51=4; | 9889 | int alt50=4; |
11121 | switch ( input.LA(1) ) { | 9890 | switch ( input.LA(1) ) { |
11122 | case 70: | 9891 | case True: |
11123 | { | 9892 | { |
11124 | alt51=1; | 9893 | alt50=1; |
11125 | } | 9894 | } |
11126 | break; | 9895 | break; |
11127 | case 71: | 9896 | case False: |
11128 | { | 9897 | { |
11129 | alt51=2; | 9898 | alt50=2; |
11130 | } | 9899 | } |
11131 | break; | 9900 | break; |
11132 | case 72: | 9901 | case Unknown: |
11133 | { | 9902 | { |
11134 | alt51=3; | 9903 | alt50=3; |
11135 | } | 9904 | } |
11136 | break; | 9905 | break; |
11137 | case 19: | 9906 | case Error: |
11138 | { | 9907 | { |
11139 | alt51=4; | 9908 | alt50=4; |
11140 | } | 9909 | } |
11141 | break; | 9910 | break; |
11142 | default: | 9911 | default: |
11143 | if (state.backtracking>0) {state.failed=true; return current;} | ||
11144 | NoViableAltException nvae = | 9912 | NoViableAltException nvae = |
11145 | new NoViableAltException("", 51, 0, input); | 9913 | new NoViableAltException("", 50, 0, input); |
11146 | 9914 | ||
11147 | throw nvae; | 9915 | throw nvae; |
11148 | } | 9916 | } |
11149 | 9917 | ||
11150 | switch (alt51) { | 9918 | switch (alt50) { |
11151 | case 1 : | 9919 | case 1 : |
11152 | // InternalSolverLanguage.g:3821:3: (enumLiteral_0= 'true' ) | 9920 | // InternalSolverLanguageParser.g:3780:3: (enumLiteral_0= True ) |
11153 | { | 9921 | { |
11154 | // InternalSolverLanguage.g:3821:3: (enumLiteral_0= 'true' ) | 9922 | // InternalSolverLanguageParser.g:3780:3: (enumLiteral_0= True ) |
11155 | // InternalSolverLanguage.g:3822:4: enumLiteral_0= 'true' | 9923 | // InternalSolverLanguageParser.g:3781:4: enumLiteral_0= True |
11156 | { | 9924 | { |
11157 | enumLiteral_0=(Token)match(input,70,FOLLOW_2); if (state.failed) return current; | 9925 | enumLiteral_0=(Token)match(input,True,FOLLOW_2); |
11158 | if ( state.backtracking==0 ) { | ||
11159 | 9926 | ||
11160 | current = grammarAccess.getLogicValueAccess().getTRUEEnumLiteralDeclaration_0().getEnumLiteral().getInstance(); | 9927 | current = grammarAccess.getLogicValueAccess().getTRUEEnumLiteralDeclaration_0().getEnumLiteral().getInstance(); |
11161 | newLeafNode(enumLiteral_0, grammarAccess.getLogicValueAccess().getTRUEEnumLiteralDeclaration_0()); | 9928 | newLeafNode(enumLiteral_0, grammarAccess.getLogicValueAccess().getTRUEEnumLiteralDeclaration_0()); |
11162 | 9929 | ||
11163 | } | ||
11164 | 9930 | ||
11165 | } | 9931 | } |
11166 | 9932 | ||
@@ -11168,18 +9934,16 @@ public class InternalSolverLanguageParser extends AbstractInternalAntlrParser { | |||
11168 | } | 9934 | } |
11169 | break; | 9935 | break; |
11170 | case 2 : | 9936 | case 2 : |
11171 | // InternalSolverLanguage.g:3829:3: (enumLiteral_1= 'false' ) | 9937 | // InternalSolverLanguageParser.g:3788:3: (enumLiteral_1= False ) |
11172 | { | 9938 | { |
11173 | // InternalSolverLanguage.g:3829:3: (enumLiteral_1= 'false' ) | 9939 | // InternalSolverLanguageParser.g:3788:3: (enumLiteral_1= False ) |
11174 | // InternalSolverLanguage.g:3830:4: enumLiteral_1= 'false' | 9940 | // InternalSolverLanguageParser.g:3789:4: enumLiteral_1= False |
11175 | { | 9941 | { |
11176 | enumLiteral_1=(Token)match(input,71,FOLLOW_2); if (state.failed) return current; | 9942 | enumLiteral_1=(Token)match(input,False,FOLLOW_2); |
11177 | if ( state.backtracking==0 ) { | ||
11178 | 9943 | ||
11179 | current = grammarAccess.getLogicValueAccess().getFALSEEnumLiteralDeclaration_1().getEnumLiteral().getInstance(); | 9944 | current = grammarAccess.getLogicValueAccess().getFALSEEnumLiteralDeclaration_1().getEnumLiteral().getInstance(); |
11180 | newLeafNode(enumLiteral_1, grammarAccess.getLogicValueAccess().getFALSEEnumLiteralDeclaration_1()); | 9945 | newLeafNode(enumLiteral_1, grammarAccess.getLogicValueAccess().getFALSEEnumLiteralDeclaration_1()); |
11181 | 9946 | ||
11182 | } | ||
11183 | 9947 | ||
11184 | } | 9948 | } |
11185 | 9949 | ||
@@ -11187,18 +9951,16 @@ public class InternalSolverLanguageParser extends AbstractInternalAntlrParser { | |||
11187 | } | 9951 | } |
11188 | break; | 9952 | break; |
11189 | case 3 : | 9953 | case 3 : |
11190 | // InternalSolverLanguage.g:3837:3: (enumLiteral_2= 'unknown' ) | 9954 | // InternalSolverLanguageParser.g:3796:3: (enumLiteral_2= Unknown ) |
11191 | { | 9955 | { |
11192 | // InternalSolverLanguage.g:3837:3: (enumLiteral_2= 'unknown' ) | 9956 | // InternalSolverLanguageParser.g:3796:3: (enumLiteral_2= Unknown ) |
11193 | // InternalSolverLanguage.g:3838:4: enumLiteral_2= 'unknown' | 9957 | // InternalSolverLanguageParser.g:3797:4: enumLiteral_2= Unknown |
11194 | { | 9958 | { |
11195 | enumLiteral_2=(Token)match(input,72,FOLLOW_2); if (state.failed) return current; | 9959 | enumLiteral_2=(Token)match(input,Unknown,FOLLOW_2); |
11196 | if ( state.backtracking==0 ) { | ||
11197 | 9960 | ||
11198 | current = grammarAccess.getLogicValueAccess().getUNKNOWNEnumLiteralDeclaration_2().getEnumLiteral().getInstance(); | 9961 | current = grammarAccess.getLogicValueAccess().getUNKNOWNEnumLiteralDeclaration_2().getEnumLiteral().getInstance(); |
11199 | newLeafNode(enumLiteral_2, grammarAccess.getLogicValueAccess().getUNKNOWNEnumLiteralDeclaration_2()); | 9962 | newLeafNode(enumLiteral_2, grammarAccess.getLogicValueAccess().getUNKNOWNEnumLiteralDeclaration_2()); |
11200 | 9963 | ||
11201 | } | ||
11202 | 9964 | ||
11203 | } | 9965 | } |
11204 | 9966 | ||
@@ -11206,18 +9968,16 @@ public class InternalSolverLanguageParser extends AbstractInternalAntlrParser { | |||
11206 | } | 9968 | } |
11207 | break; | 9969 | break; |
11208 | case 4 : | 9970 | case 4 : |
11209 | // InternalSolverLanguage.g:3845:3: (enumLiteral_3= 'error' ) | 9971 | // InternalSolverLanguageParser.g:3804:3: (enumLiteral_3= Error ) |
11210 | { | 9972 | { |
11211 | // InternalSolverLanguage.g:3845:3: (enumLiteral_3= 'error' ) | 9973 | // InternalSolverLanguageParser.g:3804:3: (enumLiteral_3= Error ) |
11212 | // InternalSolverLanguage.g:3846:4: enumLiteral_3= 'error' | 9974 | // InternalSolverLanguageParser.g:3805:4: enumLiteral_3= Error |
11213 | { | 9975 | { |
11214 | enumLiteral_3=(Token)match(input,19,FOLLOW_2); if (state.failed) return current; | 9976 | enumLiteral_3=(Token)match(input,Error,FOLLOW_2); |
11215 | if ( state.backtracking==0 ) { | ||
11216 | 9977 | ||
11217 | current = grammarAccess.getLogicValueAccess().getERROREnumLiteralDeclaration_3().getEnumLiteral().getInstance(); | 9978 | current = grammarAccess.getLogicValueAccess().getERROREnumLiteralDeclaration_3().getEnumLiteral().getInstance(); |
11218 | newLeafNode(enumLiteral_3, grammarAccess.getLogicValueAccess().getERROREnumLiteralDeclaration_3()); | 9979 | newLeafNode(enumLiteral_3, grammarAccess.getLogicValueAccess().getERROREnumLiteralDeclaration_3()); |
11219 | 9980 | ||
11220 | } | ||
11221 | 9981 | ||
11222 | } | 9982 | } |
11223 | 9983 | ||
@@ -11230,11 +9990,9 @@ public class InternalSolverLanguageParser extends AbstractInternalAntlrParser { | |||
11230 | 9990 | ||
11231 | } | 9991 | } |
11232 | 9992 | ||
11233 | if ( state.backtracking==0 ) { | ||
11234 | 9993 | ||
11235 | leaveRule(); | 9994 | leaveRule(); |
11236 | 9995 | ||
11237 | } | ||
11238 | } | 9996 | } |
11239 | 9997 | ||
11240 | catch (RecognitionException re) { | 9998 | catch (RecognitionException re) { |
@@ -11249,7 +10007,7 @@ public class InternalSolverLanguageParser extends AbstractInternalAntlrParser { | |||
11249 | 10007 | ||
11250 | 10008 | ||
11251 | // $ANTLR start "ruleObjectiveKind" | 10009 | // $ANTLR start "ruleObjectiveKind" |
11252 | // InternalSolverLanguage.g:3856:1: ruleObjectiveKind returns [Enumerator current=null] : ( (enumLiteral_0= 'minimize' ) | (enumLiteral_1= 'maximize' ) ) ; | 10010 | // InternalSolverLanguageParser.g:3815:1: ruleObjectiveKind returns [Enumerator current=null] : ( (enumLiteral_0= Minimize ) | (enumLiteral_1= Maximize ) ) ; |
11253 | public final Enumerator ruleObjectiveKind() throws RecognitionException { | 10011 | public final Enumerator ruleObjectiveKind() throws RecognitionException { |
11254 | Enumerator current = null; | 10012 | Enumerator current = null; |
11255 | 10013 | ||
@@ -11260,40 +10018,37 @@ public class InternalSolverLanguageParser extends AbstractInternalAntlrParser { | |||
11260 | enterRule(); | 10018 | enterRule(); |
11261 | 10019 | ||
11262 | try { | 10020 | try { |
11263 | // InternalSolverLanguage.g:3862:2: ( ( (enumLiteral_0= 'minimize' ) | (enumLiteral_1= 'maximize' ) ) ) | 10021 | // InternalSolverLanguageParser.g:3821:2: ( ( (enumLiteral_0= Minimize ) | (enumLiteral_1= Maximize ) ) ) |
11264 | // InternalSolverLanguage.g:3863:2: ( (enumLiteral_0= 'minimize' ) | (enumLiteral_1= 'maximize' ) ) | 10022 | // InternalSolverLanguageParser.g:3822:2: ( (enumLiteral_0= Minimize ) | (enumLiteral_1= Maximize ) ) |
11265 | { | 10023 | { |
11266 | // InternalSolverLanguage.g:3863:2: ( (enumLiteral_0= 'minimize' ) | (enumLiteral_1= 'maximize' ) ) | 10024 | // InternalSolverLanguageParser.g:3822:2: ( (enumLiteral_0= Minimize ) | (enumLiteral_1= Maximize ) ) |
11267 | int alt52=2; | 10025 | int alt51=2; |
11268 | int LA52_0 = input.LA(1); | 10026 | int LA51_0 = input.LA(1); |
11269 | 10027 | ||
11270 | if ( (LA52_0==73) ) { | 10028 | if ( (LA51_0==Minimize) ) { |
11271 | alt52=1; | 10029 | alt51=1; |
11272 | } | 10030 | } |
11273 | else if ( (LA52_0==74) ) { | 10031 | else if ( (LA51_0==Maximize) ) { |
11274 | alt52=2; | 10032 | alt51=2; |
11275 | } | 10033 | } |
11276 | else { | 10034 | else { |
11277 | if (state.backtracking>0) {state.failed=true; return current;} | ||
11278 | NoViableAltException nvae = | 10035 | NoViableAltException nvae = |
11279 | new NoViableAltException("", 52, 0, input); | 10036 | new NoViableAltException("", 51, 0, input); |
11280 | 10037 | ||
11281 | throw nvae; | 10038 | throw nvae; |
11282 | } | 10039 | } |
11283 | switch (alt52) { | 10040 | switch (alt51) { |
11284 | case 1 : | 10041 | case 1 : |
11285 | // InternalSolverLanguage.g:3864:3: (enumLiteral_0= 'minimize' ) | 10042 | // InternalSolverLanguageParser.g:3823:3: (enumLiteral_0= Minimize ) |
11286 | { | 10043 | { |
11287 | // InternalSolverLanguage.g:3864:3: (enumLiteral_0= 'minimize' ) | 10044 | // InternalSolverLanguageParser.g:3823:3: (enumLiteral_0= Minimize ) |
11288 | // InternalSolverLanguage.g:3865:4: enumLiteral_0= 'minimize' | 10045 | // InternalSolverLanguageParser.g:3824:4: enumLiteral_0= Minimize |
11289 | { | 10046 | { |
11290 | enumLiteral_0=(Token)match(input,73,FOLLOW_2); if (state.failed) return current; | 10047 | enumLiteral_0=(Token)match(input,Minimize,FOLLOW_2); |
11291 | if ( state.backtracking==0 ) { | ||
11292 | 10048 | ||
11293 | current = grammarAccess.getObjectiveKindAccess().getMINIMIZEEnumLiteralDeclaration_0().getEnumLiteral().getInstance(); | 10049 | current = grammarAccess.getObjectiveKindAccess().getMINIMIZEEnumLiteralDeclaration_0().getEnumLiteral().getInstance(); |
11294 | newLeafNode(enumLiteral_0, grammarAccess.getObjectiveKindAccess().getMINIMIZEEnumLiteralDeclaration_0()); | 10050 | newLeafNode(enumLiteral_0, grammarAccess.getObjectiveKindAccess().getMINIMIZEEnumLiteralDeclaration_0()); |
11295 | 10051 | ||
11296 | } | ||
11297 | 10052 | ||
11298 | } | 10053 | } |
11299 | 10054 | ||
@@ -11301,18 +10056,16 @@ public class InternalSolverLanguageParser extends AbstractInternalAntlrParser { | |||
11301 | } | 10056 | } |
11302 | break; | 10057 | break; |
11303 | case 2 : | 10058 | case 2 : |
11304 | // InternalSolverLanguage.g:3872:3: (enumLiteral_1= 'maximize' ) | 10059 | // InternalSolverLanguageParser.g:3831:3: (enumLiteral_1= Maximize ) |
11305 | { | 10060 | { |
11306 | // InternalSolverLanguage.g:3872:3: (enumLiteral_1= 'maximize' ) | 10061 | // InternalSolverLanguageParser.g:3831:3: (enumLiteral_1= Maximize ) |
11307 | // InternalSolverLanguage.g:3873:4: enumLiteral_1= 'maximize' | 10062 | // InternalSolverLanguageParser.g:3832:4: enumLiteral_1= Maximize |
11308 | { | 10063 | { |
11309 | enumLiteral_1=(Token)match(input,74,FOLLOW_2); if (state.failed) return current; | 10064 | enumLiteral_1=(Token)match(input,Maximize,FOLLOW_2); |
11310 | if ( state.backtracking==0 ) { | ||
11311 | 10065 | ||
11312 | current = grammarAccess.getObjectiveKindAccess().getMAXIMIZEEnumLiteralDeclaration_1().getEnumLiteral().getInstance(); | 10066 | current = grammarAccess.getObjectiveKindAccess().getMAXIMIZEEnumLiteralDeclaration_1().getEnumLiteral().getInstance(); |
11313 | newLeafNode(enumLiteral_1, grammarAccess.getObjectiveKindAccess().getMAXIMIZEEnumLiteralDeclaration_1()); | 10067 | newLeafNode(enumLiteral_1, grammarAccess.getObjectiveKindAccess().getMAXIMIZEEnumLiteralDeclaration_1()); |
11314 | 10068 | ||
11315 | } | ||
11316 | 10069 | ||
11317 | } | 10070 | } |
11318 | 10071 | ||
@@ -11325,11 +10078,9 @@ public class InternalSolverLanguageParser extends AbstractInternalAntlrParser { | |||
11325 | 10078 | ||
11326 | } | 10079 | } |
11327 | 10080 | ||
11328 | if ( state.backtracking==0 ) { | ||
11329 | 10081 | ||
11330 | leaveRule(); | 10082 | leaveRule(); |
11331 | 10083 | ||
11332 | } | ||
11333 | } | 10084 | } |
11334 | 10085 | ||
11335 | catch (RecognitionException re) { | 10086 | catch (RecognitionException re) { |
@@ -11346,20 +10097,21 @@ public class InternalSolverLanguageParser extends AbstractInternalAntlrParser { | |||
11346 | 10097 | ||
11347 | 10098 | ||
11348 | protected DFA2 dfa2 = new DFA2(this); | 10099 | protected DFA2 dfa2 = new DFA2(this); |
11349 | protected DFA25 dfa25 = new DFA25(this); | 10100 | protected DFA20 dfa20 = new DFA20(this); |
11350 | protected DFA36 dfa36 = new DFA36(this); | 10101 | protected DFA24 dfa24 = new DFA24(this); |
10102 | protected DFA35 dfa35 = new DFA35(this); | ||
11351 | static final String dfa_1s = "\15\uffff"; | 10103 | static final String dfa_1s = "\15\uffff"; |
11352 | static final String dfa_2s = "\1\7\1\uffff\1\4\2\uffff\1\10\7\uffff"; | 10104 | static final String dfa_2s = "\1\5\1\uffff\1\5\2\uffff\1\36\7\uffff"; |
11353 | static final String dfa_3s = "\1\112\1\uffff\1\73\2\uffff\1\63\7\uffff"; | 10105 | static final String dfa_3s = "\1\123\1\uffff\1\122\2\uffff\1\122\7\uffff"; |
11354 | 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\7\1\5"; | 10106 | 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"; |
11355 | static final String dfa_5s = "\15\uffff}>"; | 10107 | static final String dfa_5s = "\15\uffff}>"; |
11356 | static final String[] dfa_6s = { | 10108 | static final String[] dfa_6s = { |
11357 | "\4\1\7\uffff\1\3\1\2\1\4\1\5\1\uffff\1\1\5\uffff\1\1\3\uffff\1\1\2\uffff\1\1\2\uffff\2\1\2\7\3\uffff\1\10\3\uffff\2\6\4\uffff\2\1\2\uffff\15\1\2\11", | 10109 | "\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", |
11358 | "", | 10110 | "", |
11359 | "\1\1\3\uffff\1\3\1\uffff\1\3\4\uffff\3\1\1\3\7\uffff\3\1\4\uffff\1\12\1\uffff\1\1\13\uffff\3\1\2\uffff\10\1", | 10111 | "\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", |
11360 | "", | 10112 | "", |
11361 | "", | 10113 | "", |
11362 | "\1\14\1\uffff\1\14\47\uffff\2\13", | 10114 | "\1\14\11\uffff\1\14\44\uffff\1\13\4\uffff\1\13", |
11363 | "", | 10115 | "", |
11364 | "", | 10116 | "", |
11365 | "", | 10117 | "", |
@@ -11390,26 +10142,26 @@ public class InternalSolverLanguageParser extends AbstractInternalAntlrParser { | |||
11390 | this.transition = dfa_6; | 10142 | this.transition = dfa_6; |
11391 | } | 10143 | } |
11392 | public String getDescription() { | 10144 | public String getDescription() { |
11393 | return "116:3: (this_AssertionOrDefinition_0= ruleAssertionOrDefinition | this_PredicateDefinition_1= rulePredicateDefinition | this_UnnamedErrorPrediateDefinition_2= ruleUnnamedErrorPrediateDefinition | this_DefaultDefinition_3= ruleDefaultDefinition | this_ExternPredicateDefinition_4= ruleExternPredicateDefinition | this_MetricDefinition_5= ruleMetricDefinition | this_ExternMetricDefinition_6= ruleExternMetricDefinition | this_ClassDefinition_7= ruleClassDefinition | this_ScopeDefinition_8= ruleScopeDefinition | this_ObjectiveDefinition_9= ruleObjectiveDefinition )"; | 10145 | return "109:3: (this_AssertionOrDefinition_0= ruleAssertionOrDefinition | this_PredicateDefinition_1= rulePredicateDefinition | this_UnnamedErrorPrediateDefinition_2= ruleUnnamedErrorPrediateDefinition | this_DefaultDefinition_3= ruleDefaultDefinition | this_ExternPredicateDefinition_4= ruleExternPredicateDefinition | this_MetricDefinition_5= ruleMetricDefinition | this_ExternMetricDefinition_6= ruleExternMetricDefinition | this_ClassDefinition_7= ruleClassDefinition | this_ScopeDefinition_8= ruleScopeDefinition | this_ObjectiveDefinition_9= ruleObjectiveDefinition )"; |
11394 | } | 10146 | } |
11395 | } | 10147 | } |
11396 | static final String dfa_7s = "\12\uffff"; | 10148 | static final String dfa_7s = "\12\uffff"; |
11397 | static final String dfa_8s = "\1\uffff\2\3\4\uffff\1\11\1\3\1\uffff"; | 10149 | static final String dfa_8s = "\1\uffff\2\10\6\uffff\1\10"; |
11398 | static final String dfa_9s = "\1\7\2\10\2\uffff\1\10\1\uffff\1\7\1\10\1\uffff"; | 10150 | static final String dfa_9s = "\1\20\2\32\3\uffff\1\122\2\uffff\1\32"; |
11399 | static final String dfa_10s = "\1\110\2\73\2\uffff\1\10\1\uffff\1\110\1\73\1\uffff"; | 10151 | static final String dfa_10s = "\1\123\2\121\3\uffff\1\122\2\uffff\1\121"; |
11400 | static final String dfa_11s = "\3\uffff\1\1\1\2\1\uffff\1\3\2\uffff\1\4"; | 10152 | static final String dfa_11s = "\3\uffff\1\3\1\4\1\5\1\uffff\1\2\1\1\1\uffff"; |
11401 | static final String dfa_12s = "\12\uffff}>"; | 10153 | static final String dfa_12s = "\12\uffff}>"; |
11402 | static final String[] dfa_13s = { | 10154 | static final String[] dfa_13s = { |
11403 | "\1\3\1\1\1\3\1\2\10\uffff\1\3\11\uffff\1\3\3\uffff\1\3\1\uffff\1\4\1\3\2\uffff\2\3\17\uffff\2\3\2\uffff\15\3", | 10155 | "\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", |
11404 | "\1\6\1\uffff\1\6\13\uffff\1\5\5\uffff\1\3\4\uffff\2\3\1\7\13\uffff\3\3\2\uffff\10\3", | 10156 | "\1\10\4\uffff\1\10\15\uffff\7\10\3\uffff\1\10\1\uffff\1\7\5\10\1\6\6\10\1\uffff\2\10\1\uffff\2\10\3\uffff\2\7\1\10", |
11405 | "\1\6\1\uffff\1\6\21\uffff\1\3\4\uffff\2\3\1\7\13\uffff\3\3\2\uffff\10\3", | 10157 | "\1\10\4\uffff\1\10\15\uffff\7\10\3\uffff\1\10\1\uffff\1\7\5\10\1\uffff\6\10\1\uffff\2\10\1\uffff\2\10\3\uffff\2\7\1\10", |
11406 | "", | 10158 | "", |
11407 | "", | 10159 | "", |
11408 | "\1\10", | ||
11409 | "", | 10160 | "", |
11410 | "\4\3\10\uffff\1\3\10\uffff\1\11\1\3\3\uffff\1\3\1\11\1\uffff\1\3\2\uffff\2\3\17\uffff\2\3\2\uffff\15\3", | 10161 | "\1\11", |
11411 | "\1\6\1\uffff\1\6\13\uffff\1\5\5\uffff\1\3\4\uffff\2\3\1\7\13\uffff\3\3\2\uffff\10\3", | 10162 | "", |
11412 | "" | 10163 | "", |
10164 | "\1\10\4\uffff\1\10\15\uffff\7\10\3\uffff\1\10\1\uffff\1\7\5\10\1\6\6\10\1\uffff\2\10\1\uffff\2\10\3\uffff\2\7\1\10" | ||
11413 | }; | 10165 | }; |
11414 | 10166 | ||
11415 | static final short[] dfa_7 = DFA.unpackEncodedString(dfa_7s); | 10167 | static final short[] dfa_7 = DFA.unpackEncodedString(dfa_7s); |
@@ -11420,11 +10172,11 @@ public class InternalSolverLanguageParser extends AbstractInternalAntlrParser { | |||
11420 | static final short[] dfa_12 = DFA.unpackEncodedString(dfa_12s); | 10172 | static final short[] dfa_12 = DFA.unpackEncodedString(dfa_12s); |
11421 | static final short[][] dfa_13 = unpackEncodedStringArray(dfa_13s); | 10173 | static final short[][] dfa_13 = unpackEncodedStringArray(dfa_13s); |
11422 | 10174 | ||
11423 | class DFA25 extends DFA { | 10175 | class DFA20 extends DFA { |
11424 | 10176 | ||
11425 | public DFA25(BaseRecognizer recognizer) { | 10177 | public DFA20(BaseRecognizer recognizer) { |
11426 | this.recognizer = recognizer; | 10178 | this.recognizer = recognizer; |
11427 | this.decisionNumber = 25; | 10179 | this.decisionNumber = 20; |
11428 | this.eot = dfa_7; | 10180 | this.eot = dfa_7; |
11429 | this.eof = dfa_8; | 10181 | this.eof = dfa_8; |
11430 | this.min = dfa_9; | 10182 | this.min = dfa_9; |
@@ -11434,112 +10186,149 @@ public class InternalSolverLanguageParser extends AbstractInternalAntlrParser { | |||
11434 | this.transition = dfa_13; | 10186 | this.transition = dfa_13; |
11435 | } | 10187 | } |
11436 | public String getDescription() { | 10188 | public String getDescription() { |
11437 | return "1998:2: (this_ExpressionArgument_0= ruleExpressionArgument | this_StarArgument_1= ruleStarArgument | this_TypedArgument_2= ruleTypedArgument | this_TypedStarArgument_3= ruleTypedStarArgument )"; | 10189 | return "1716:2: (this_Reference_0= ruleReference | this_Call_1= ruleCall | this_Interval_2= ruleInterval | this_Literal_3= ruleLiteral | (otherlv_4= LeftParenthesis this_Expression_5= ruleExpression otherlv_6= RightParenthesis ) )"; |
10190 | } | ||
10191 | } | ||
10192 | static final String dfa_14s = "\1\uffff\2\3\3\uffff\1\11\1\uffff\1\3\1\uffff"; | ||
10193 | static final String dfa_15s = "\1\15\2\55\2\uffff\1\122\1\15\1\uffff\1\55\1\uffff"; | ||
10194 | static final String dfa_16s = "\1\123\2\122\2\uffff\1\122\1\123\1\uffff\1\122\1\uffff"; | ||
10195 | static final String dfa_17s = "\3\uffff\1\1\1\2\2\uffff\1\3\1\uffff\1\4"; | ||
10196 | static final String[] dfa_18s = { | ||
10197 | "\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", | ||
10198 | "\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", | ||
10199 | "\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", | ||
10200 | "", | ||
10201 | "", | ||
10202 | "\1\10", | ||
10203 | "\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", | ||
10204 | "", | ||
10205 | "\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", | ||
10206 | "" | ||
10207 | }; | ||
10208 | static final short[] dfa_14 = DFA.unpackEncodedString(dfa_14s); | ||
10209 | static final char[] dfa_15 = DFA.unpackEncodedStringToUnsignedChars(dfa_15s); | ||
10210 | static final char[] dfa_16 = DFA.unpackEncodedStringToUnsignedChars(dfa_16s); | ||
10211 | static final short[] dfa_17 = DFA.unpackEncodedString(dfa_17s); | ||
10212 | static final short[][] dfa_18 = unpackEncodedStringArray(dfa_18s); | ||
10213 | |||
10214 | class DFA24 extends DFA { | ||
10215 | |||
10216 | public DFA24(BaseRecognizer recognizer) { | ||
10217 | this.recognizer = recognizer; | ||
10218 | this.decisionNumber = 24; | ||
10219 | this.eot = dfa_7; | ||
10220 | this.eof = dfa_14; | ||
10221 | this.min = dfa_15; | ||
10222 | this.max = dfa_16; | ||
10223 | this.accept = dfa_17; | ||
10224 | this.special = dfa_12; | ||
10225 | this.transition = dfa_18; | ||
10226 | } | ||
10227 | public String getDescription() { | ||
10228 | return "1965:2: (this_ExpressionArgument_0= ruleExpressionArgument | this_StarArgument_1= ruleStarArgument | this_TypedArgument_2= ruleTypedArgument | this_TypedStarArgument_3= ruleTypedStarArgument )"; | ||
11438 | } | 10229 | } |
11439 | } | 10230 | } |
11440 | static final String dfa_14s = "\17\uffff"; | 10231 | static final String dfa_19s = "\17\uffff"; |
11441 | static final String dfa_15s = "\15\uffff\1\11\1\uffff"; | 10232 | static final String dfa_20s = "\12\uffff\2\10\2\uffff\1\10"; |
11442 | static final String dfa_16s = "\1\56\1\10\1\60\1\26\1\57\1\10\1\uffff\1\10\2\uffff\3\26\1\4\1\26"; | 10233 | static final String dfa_21s = "\1\30\1\115\3\61\1\115\1\uffff\1\122\2\uffff\3\61\1\122\1\61"; |
11443 | static final String dfa_17s = "\1\56\1\12\3\61\1\12\1\uffff\1\10\2\uffff\2\60\1\61\1\10\1\60"; | 10234 | static final String dfa_22s = "\1\30\1\123\1\63\1\77\1\63\1\122\1\uffff\1\122\2\uffff\2\121\1\77\1\122\1\121"; |
11444 | static final String dfa_18s = "\6\uffff\1\2\1\uffff\1\1\1\3\5\uffff"; | 10235 | static final String dfa_23s = "\6\uffff\1\2\1\uffff\1\3\1\1\5\uffff"; |
11445 | static final String dfa_19s = "\17\uffff}>"; | 10236 | static final String dfa_24s = "\17\uffff}>"; |
11446 | static final String[] dfa_20s = { | 10237 | static final String[] dfa_25s = { |
11447 | "\1\1", | 10238 | "\1\1", |
11448 | "\1\3\1\2\1\4", | 10239 | "\1\4\4\uffff\1\3\1\2", |
11449 | "\1\5\1\6", | 10240 | "\1\5\1\uffff\1\6", |
11450 | "\1\7\30\uffff\1\10\1\6\1\11", | 10241 | "\1\6\1\11\1\10\13\uffff\1\7", |
11451 | "\1\10\1\6\1\11", | 10242 | "\1\6\1\11\1\10", |
11452 | "\1\12\1\uffff\1\13", | 10243 | "\1\13\4\uffff\1\12", |
11453 | "", | 10244 | "", |
11454 | "\1\14", | 10245 | "\1\14", |
11455 | "", | 10246 | "", |
11456 | "", | 10247 | "", |
11457 | "\1\15\31\uffff\1\6", | 10248 | "\1\6\15\uffff\1\15\21\uffff\1\10", |
11458 | "\1\11\31\uffff\1\6", | 10249 | "\1\6\37\uffff\1\10", |
11459 | "\1\7\30\uffff\1\10\1\6\1\11", | 10250 | "\1\6\1\11\1\10\13\uffff\1\7", |
11460 | "\1\11\3\uffff\1\16", | 10251 | "\1\16", |
11461 | "\1\15\31\uffff\1\6" | 10252 | "\1\6\15\uffff\1\15\21\uffff\1\10" |
11462 | }; | 10253 | }; |
11463 | 10254 | ||
11464 | static final short[] dfa_14 = DFA.unpackEncodedString(dfa_14s); | ||
11465 | static final short[] dfa_15 = DFA.unpackEncodedString(dfa_15s); | ||
11466 | static final char[] dfa_16 = DFA.unpackEncodedStringToUnsignedChars(dfa_16s); | ||
11467 | static final char[] dfa_17 = DFA.unpackEncodedStringToUnsignedChars(dfa_17s); | ||
11468 | static final short[] dfa_18 = DFA.unpackEncodedString(dfa_18s); | ||
11469 | static final short[] dfa_19 = DFA.unpackEncodedString(dfa_19s); | 10255 | static final short[] dfa_19 = DFA.unpackEncodedString(dfa_19s); |
11470 | static final short[][] dfa_20 = unpackEncodedStringArray(dfa_20s); | 10256 | static final short[] dfa_20 = DFA.unpackEncodedString(dfa_20s); |
10257 | static final char[] dfa_21 = DFA.unpackEncodedStringToUnsignedChars(dfa_21s); | ||
10258 | static final char[] dfa_22 = DFA.unpackEncodedStringToUnsignedChars(dfa_22s); | ||
10259 | static final short[] dfa_23 = DFA.unpackEncodedString(dfa_23s); | ||
10260 | static final short[] dfa_24 = DFA.unpackEncodedString(dfa_24s); | ||
10261 | static final short[][] dfa_25 = unpackEncodedStringArray(dfa_25s); | ||
11471 | 10262 | ||
11472 | class DFA36 extends DFA { | 10263 | class DFA35 extends DFA { |
11473 | 10264 | ||
11474 | public DFA36(BaseRecognizer recognizer) { | 10265 | public DFA35(BaseRecognizer recognizer) { |
11475 | this.recognizer = recognizer; | 10266 | this.recognizer = recognizer; |
11476 | this.decisionNumber = 36; | 10267 | this.decisionNumber = 35; |
11477 | this.eot = dfa_14; | 10268 | this.eot = dfa_19; |
11478 | this.eof = dfa_15; | 10269 | this.eof = dfa_20; |
11479 | this.min = dfa_16; | 10270 | this.min = dfa_21; |
11480 | this.max = dfa_17; | 10271 | this.max = dfa_22; |
11481 | this.accept = dfa_18; | 10272 | this.accept = dfa_23; |
11482 | this.special = dfa_19; | 10273 | this.special = dfa_24; |
11483 | this.transition = dfa_20; | 10274 | this.transition = dfa_25; |
11484 | } | 10275 | } |
11485 | public String getDescription() { | 10276 | public String getDescription() { |
11486 | return "2973:2: (this_ExactScopeDefinition_0= ruleExactScopeDefinition | this_BoundedScopeDefinition_1= ruleBoundedScopeDefinition | this_LowerBoundedScopeDefinition_2= ruleLowerBoundedScopeDefinition )"; | 10277 | return "2940:2: (this_ExactScopeDefinition_0= ruleExactScopeDefinition | this_BoundedScopeDefinition_1= ruleBoundedScopeDefinition | this_LowerBoundedScopeDefinition_2= ruleLowerBoundedScopeDefinition )"; |
11487 | } | 10278 | } |
11488 | } | 10279 | } |
11489 | 10280 | ||
11490 | 10281 | ||
11491 | public static final BitSet FOLLOW_1 = new BitSet(new long[]{0x0000000000000000L}); | 10282 | public static final BitSet FOLLOW_1 = new BitSet(new long[]{0x0000000000000000L}); |
11492 | public static final BitSet FOLLOW_2 = new BitSet(new long[]{0x0000000000000002L}); | 10283 | public static final BitSet FOLLOW_2 = new BitSet(new long[]{0x0000000000000002L}); |
11493 | public static final BitSet FOLLOW_3 = new BitSet(new long[]{0xF30C479220BC0782L,0x00000000000007FFL}); | 10284 | public static final BitSet FOLLOW_3 = new BitSet(new long[]{0x53401FC179FD6362L,0x00000000000C3040L}); |
11494 | public static final BitSet FOLLOW_4 = new BitSet(new long[]{0x0000000000000010L}); | 10285 | public static final BitSet FOLLOW_4 = new BitSet(new long[]{0x0000000000000000L,0x0000000000020000L}); |
11495 | public static final BitSet FOLLOW_5 = new BitSet(new long[]{0x0000000000038002L}); | 10286 | public static final BitSet FOLLOW_5 = new BitSet(new long[]{0x0001000000000002L,0x0000000000000012L}); |
11496 | public static final BitSet FOLLOW_6 = new BitSet(new long[]{0xF300019220880780L,0x00000000000001FFL}); | 10287 | public static final BitSet FOLLOW_6 = new BitSet(new long[]{0x53401EC138F12000L,0x00000000000C3040L}); |
11497 | public static final BitSet FOLLOW_7 = new BitSet(new long[]{0x0000000000080500L}); | 10288 | public static final BitSet FOLLOW_7 = new BitSet(new long[]{0x0000000000400000L,0x0000000000042000L}); |
11498 | public static final BitSet FOLLOW_8 = new BitSet(new long[]{0x00000000000C0500L}); | 10289 | public static final BitSet FOLLOW_8 = new BitSet(new long[]{0x0000000000000000L,0x0000000000042000L}); |
11499 | public static final BitSet FOLLOW_9 = new BitSet(new long[]{0x0000000000010000L}); | 10290 | public static final BitSet FOLLOW_9 = new BitSet(new long[]{0x0000000000000020L,0x0000000000042000L}); |
11500 | public static final BitSet FOLLOW_10 = new BitSet(new long[]{0x0000000200000000L}); | 10291 | public static final BitSet FOLLOW_10 = new BitSet(new long[]{0x0001000000000000L}); |
11501 | public static final BitSet FOLLOW_11 = new BitSet(new long[]{0x0000000000008000L}); | 10292 | public static final BitSet FOLLOW_11 = new BitSet(new long[]{0x0200000000000000L}); |
11502 | public static final BitSet FOLLOW_12 = new BitSet(new long[]{0x0000000000400000L}); | 10293 | public static final BitSet FOLLOW_12 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000002L}); |
11503 | public static final BitSet FOLLOW_13 = new BitSet(new long[]{0x0000000000020000L}); | 10294 | public static final BitSet FOLLOW_13 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000010L}); |
11504 | public static final BitSet FOLLOW_14 = new BitSet(new long[]{0x000C000000000000L}); | 10295 | public static final BitSet FOLLOW_14 = new BitSet(new long[]{0x0000010040000000L}); |
11505 | public static final BitSet FOLLOW_15 = new BitSet(new long[]{0x0000000001000000L}); | 10296 | public static final BitSet FOLLOW_15 = new BitSet(new long[]{0x0000000080000000L}); |
11506 | public static final BitSet FOLLOW_16 = new BitSet(new long[]{0x0000000002000000L}); | 10297 | public static final BitSet FOLLOW_16 = new BitSet(new long[]{0x0000000004000000L}); |
11507 | public static final BitSet FOLLOW_17 = new BitSet(new long[]{0x000000000C000002L}); | 10298 | public static final BitSet FOLLOW_17 = new BitSet(new long[]{0x0000400000000002L,0x0000000000000004L}); |
11508 | public static final BitSet FOLLOW_18 = new BitSet(new long[]{0x0000000004000002L}); | 10299 | public static final BitSet FOLLOW_18 = new BitSet(new long[]{0x0000000000000002L,0x0000000000000004L}); |
11509 | public static final BitSet FOLLOW_19 = new BitSet(new long[]{0x0000000008000000L}); | 10300 | public static final BitSet FOLLOW_19 = new BitSet(new long[]{0x0000400000000000L}); |
11510 | public static final BitSet FOLLOW_20 = new BitSet(new long[]{0x0000000010000002L}); | 10301 | public static final BitSet FOLLOW_20 = new BitSet(new long[]{0x2000000000000002L}); |
11511 | public static final BitSet FOLLOW_21 = new BitSet(new long[]{0x00F3800000000002L}); | 10302 | public static final BitSet FOLLOW_21 = new BitSet(new long[]{0x008E200000000002L,0x0000000000000028L}); |
11512 | public static final BitSet FOLLOW_22 = new BitSet(new long[]{0x0300000000000002L}); | 10303 | public static final BitSet FOLLOW_22 = new BitSet(new long[]{0x5000000000000002L}); |
11513 | public static final BitSet FOLLOW_23 = new BitSet(new long[]{0x0400000800000002L}); | 10304 | public static final BitSet FOLLOW_23 = new BitSet(new long[]{0x0800000000000002L,0x0000000000000001L}); |
11514 | public static final BitSet FOLLOW_24 = new BitSet(new long[]{0x0800000000000002L}); | 10305 | public static final BitSet FOLLOW_24 = new BitSet(new long[]{0x0000000000000002L,0x0000000000000100L}); |
11515 | public static final BitSet FOLLOW_25 = new BitSet(new long[]{0x0000019220080780L,0x00000000000001FFL}); | 10306 | public static final BitSet FOLLOW_25 = new BitSet(new long[]{0x02001AC130F10000L,0x00000000000C3040L}); |
11516 | public static final BitSet FOLLOW_26 = new BitSet(new long[]{0x0000000040000000L}); | 10307 | public static final BitSet FOLLOW_26 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000200L}); |
11517 | public static final BitSet FOLLOW_27 = new BitSet(new long[]{0x0000000080000000L}); | 10308 | public static final BitSet FOLLOW_27 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000800L}); |
11518 | public static final BitSet FOLLOW_28 = new BitSet(new long[]{0x0000000100000000L}); | 10309 | public static final BitSet FOLLOW_28 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000400L}); |
11519 | public static final BitSet FOLLOW_29 = new BitSet(new long[]{0x0000000200000002L}); | 10310 | public static final BitSet FOLLOW_29 = new BitSet(new long[]{0x0400000000000000L}); |
11520 | public static final BitSet FOLLOW_30 = new BitSet(new long[]{0x0000000400000000L}); | 10311 | public static final BitSet FOLLOW_30 = new BitSet(new long[]{0x0200000000000000L,0x0000000000018000L}); |
11521 | public static final BitSet FOLLOW_31 = new BitSet(new long[]{0x0000000200000060L}); | 10312 | public static final BitSet FOLLOW_31 = new BitSet(new long[]{0x5F401EC138F12000L,0x00000000000C3040L}); |
11522 | public static final BitSet FOLLOW_32 = new BitSet(new long[]{0xF300019E20880780L,0x00000000000001FFL}); | 10313 | public static final BitSet FOLLOW_32 = new BitSet(new long[]{0x2400000000000000L}); |
11523 | public static final BitSet FOLLOW_33 = new BitSet(new long[]{0x0000000410000000L}); | 10314 | public static final BitSet FOLLOW_33 = new BitSet(new long[]{0x5B401EC138F12000L,0x00000000000C3040L}); |
11524 | public static final BitSet FOLLOW_34 = new BitSet(new long[]{0xF300019A20880780L,0x00000000000001FFL}); | 10315 | public static final BitSet FOLLOW_34 = new BitSet(new long[]{0x0800000000000000L}); |
11525 | public static final BitSet FOLLOW_35 = new BitSet(new long[]{0x0000000000000500L}); | 10316 | public static final BitSet FOLLOW_35 = new BitSet(new long[]{0x0000800000000000L}); |
11526 | public static final BitSet FOLLOW_36 = new BitSet(new long[]{0x0000000800000000L}); | 10317 | public static final BitSet FOLLOW_36 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000080L}); |
11527 | public static final BitSet FOLLOW_37 = new BitSet(new long[]{0x0000002000000000L}); | 10318 | public static final BitSet FOLLOW_37 = new BitSet(new long[]{0x0000000000080000L}); |
11528 | public static final BitSet FOLLOW_38 = new BitSet(new long[]{0x0000004000000000L}); | 10319 | public static final BitSet FOLLOW_38 = new BitSet(new long[]{0x0000000000000000L,0x0000000000040000L}); |
11529 | public static final BitSet FOLLOW_39 = new BitSet(new long[]{0x0000040000000000L}); | 10320 | public static final BitSet FOLLOW_39 = new BitSet(new long[]{0x0000000000008000L,0x0000000000000200L}); |
11530 | public static final BitSet FOLLOW_40 = new BitSet(new long[]{0x0000000000000100L}); | 10321 | public static final BitSet FOLLOW_40 = new BitSet(new long[]{0x2000000000000000L,0x0000000000000200L}); |
11531 | public static final BitSet FOLLOW_41 = new BitSet(new long[]{0x0000080040000000L}); | 10322 | public static final BitSet FOLLOW_41 = new BitSet(new long[]{0x0000000000000080L,0x0000000000042800L}); |
11532 | public static final BitSet FOLLOW_42 = new BitSet(new long[]{0x0000000050000000L}); | 10323 | public static final BitSet FOLLOW_42 = new BitSet(new long[]{0x0000000000000000L,0x0000000000040040L}); |
11533 | public static final BitSet FOLLOW_43 = new BitSet(new long[]{0x0000100080000500L}); | 10324 | public static final BitSet FOLLOW_43 = new BitSet(new long[]{0x0000000000000402L,0x0000000000000004L}); |
11534 | public static final BitSet FOLLOW_44 = new BitSet(new long[]{0x0000001000000100L}); | 10325 | public static final BitSet FOLLOW_44 = new BitSet(new long[]{0x0800000000000000L,0x0000000000080000L}); |
11535 | public static final BitSet FOLLOW_45 = new BitSet(new long[]{0x0000200004000002L}); | 10326 | public static final BitSet FOLLOW_45 = new BitSet(new long[]{0x0000000000000000L,0x0000000000080000L}); |
11536 | public static final BitSet FOLLOW_46 = new BitSet(new long[]{0x0000000800000200L}); | 10327 | public static final BitSet FOLLOW_46 = new BitSet(new long[]{0x0004000000000000L}); |
11537 | public static final BitSet FOLLOW_47 = new BitSet(new long[]{0x0000000000000200L}); | 10328 | public static final BitSet FOLLOW_47 = new BitSet(new long[]{0x0000000000000000L,0x00000000000C2000L}); |
11538 | public static final BitSet FOLLOW_48 = new BitSet(new long[]{0x0000800000000000L}); | 10329 | public static final BitSet FOLLOW_48 = new BitSet(new long[]{0x0002000000000000L}); |
11539 | public static final BitSet FOLLOW_49 = new BitSet(new long[]{0x0000000000000700L}); | 10330 | public static final BitSet FOLLOW_49 = new BitSet(new long[]{0x0008000000000000L}); |
11540 | public static final BitSet FOLLOW_50 = new BitSet(new long[]{0x0001000000000000L}); | 10331 | public static final BitSet FOLLOW_50 = new BitSet(new long[]{0x0008000000000002L}); |
11541 | public static final BitSet FOLLOW_51 = new BitSet(new long[]{0x0002000000000000L}); | 10332 | public static final BitSet FOLLOW_51 = new BitSet(new long[]{0x8000000000000002L}); |
11542 | public static final BitSet FOLLOW_52 = new BitSet(new long[]{0x0002000000400000L}); | ||
11543 | public static final BitSet FOLLOW_53 = new BitSet(new long[]{0x0000000000400002L}); | ||
11544 | 10333 | ||
11545 | } \ No newline at end of file | 10334 | } \ No newline at end of file |
diff --git a/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/parser/antlr/internal/InternalSolverLanguageParser.tokens b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/parser/antlr/internal/InternalSolverLanguageParser.tokens new file mode 100644 index 00000000..81343db5 --- /dev/null +++ b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/parser/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 | ||