aboutsummaryrefslogtreecommitdiffstats
path: root/Application/org.eclipse.viatra.solver.language.ide/src-gen/org/eclipse/viatra/solver/language/ide/contentassist/antlr/internal/InternalSolverLanguage.g
diff options
context:
space:
mode:
Diffstat (limited to 'Application/org.eclipse.viatra.solver.language.ide/src-gen/org/eclipse/viatra/solver/language/ide/contentassist/antlr/internal/InternalSolverLanguage.g')
-rw-r--r--Application/org.eclipse.viatra.solver.language.ide/src-gen/org/eclipse/viatra/solver/language/ide/contentassist/antlr/internal/InternalSolverLanguage.g6573
1 files changed, 4942 insertions, 1631 deletions
diff --git a/Application/org.eclipse.viatra.solver.language.ide/src-gen/org/eclipse/viatra/solver/language/ide/contentassist/antlr/internal/InternalSolverLanguage.g b/Application/org.eclipse.viatra.solver.language.ide/src-gen/org/eclipse/viatra/solver/language/ide/contentassist/antlr/internal/InternalSolverLanguage.g
index df8f4ea3..2e277376 100644
--- a/Application/org.eclipse.viatra.solver.language.ide/src-gen/org/eclipse/viatra/solver/language/ide/contentassist/antlr/internal/InternalSolverLanguage.g
+++ b/Application/org.eclipse.viatra.solver.language.ide/src-gen/org/eclipse/viatra/solver/language/ide/contentassist/antlr/internal/InternalSolverLanguage.g
@@ -1,10 +1,11 @@
1/* 1/*
2 * generated by Xtext 2.18.0.M3 2 * generated by Xtext 2.21.0
3 */ 3 */
4grammar InternalSolverLanguage; 4grammar InternalSolverLanguage;
5 5
6options { 6options {
7 superClass=AbstractInternalContentAssistParser; 7 superClass=AbstractInternalContentAssistParser;
8 backtrack=true;
8} 9}
9 10
10@lexer::header { 11@lexer::header {
@@ -90,1616 +91,2255 @@ ruleStatement
90 } 91 }
91 : 92 :
92 ( 93 (
93 { before(grammarAccess.getStatementAccess().getAlternatives()); } 94 { before(grammarAccess.getStatementAccess().getGroup()); }
94 (rule__Statement__Alternatives) 95 (rule__Statement__Group__0)
95 { after(grammarAccess.getStatementAccess().getAlternatives()); } 96 { after(grammarAccess.getStatementAccess().getGroup()); }
96 ) 97 )
97; 98;
98finally { 99finally {
99 restoreStackSize(stackSize); 100 restoreStackSize(stackSize);
100} 101}
101 102
102// Entry rule entryRuleREALLiteral 103// Entry rule entryRuleAssertionOrDefinition
103entryRuleREALLiteral 104entryRuleAssertionOrDefinition
104: 105:
105{ before(grammarAccess.getREALLiteralRule()); } 106{ before(grammarAccess.getAssertionOrDefinitionRule()); }
106 ruleREALLiteral 107 ruleAssertionOrDefinition
107{ after(grammarAccess.getREALLiteralRule()); } 108{ after(grammarAccess.getAssertionOrDefinitionRule()); }
108 EOF 109 EOF
109; 110;
110 111
111// Rule REALLiteral 112// Rule AssertionOrDefinition
112ruleREALLiteral 113ruleAssertionOrDefinition
113 @init { 114 @init {
114 int stackSize = keepStackSize(); 115 int stackSize = keepStackSize();
115 } 116 }
116 : 117 :
117 ( 118 (
118 { before(grammarAccess.getREALLiteralAccess().getGroup()); } 119 { before(grammarAccess.getAssertionOrDefinitionAccess().getGroup()); }
119 (rule__REALLiteral__Group__0) 120 (rule__AssertionOrDefinition__Group__0)
120 { after(grammarAccess.getREALLiteralAccess().getGroup()); } 121 { after(grammarAccess.getAssertionOrDefinitionAccess().getGroup()); }
121 ) 122 )
122; 123;
123finally { 124finally {
124 restoreStackSize(stackSize); 125 restoreStackSize(stackSize);
125} 126}
126 127
127// Entry rule entryRuleINTLiteral 128// Entry rule entryRulePredicateDefinition
128entryRuleINTLiteral 129entryRulePredicateDefinition
129: 130:
130{ before(grammarAccess.getINTLiteralRule()); } 131{ before(grammarAccess.getPredicateDefinitionRule()); }
131 ruleINTLiteral 132 rulePredicateDefinition
132{ after(grammarAccess.getINTLiteralRule()); } 133{ after(grammarAccess.getPredicateDefinitionRule()); }
133 EOF 134 EOF
134; 135;
135 136
136// Rule INTLiteral 137// Rule PredicateDefinition
137ruleINTLiteral 138rulePredicateDefinition
138 @init { 139 @init {
139 int stackSize = keepStackSize(); 140 int stackSize = keepStackSize();
140 } 141 }
141 : 142 :
142 ( 143 (
143 { before(grammarAccess.getINTLiteralAccess().getGroup()); } 144 { before(grammarAccess.getPredicateDefinitionAccess().getGroup()); }
144 (rule__INTLiteral__Group__0) 145 (rule__PredicateDefinition__Group__0)
145 { after(grammarAccess.getINTLiteralAccess().getGroup()); } 146 { after(grammarAccess.getPredicateDefinitionAccess().getGroup()); }
146 ) 147 )
147; 148;
148finally { 149finally {
149 restoreStackSize(stackSize); 150 restoreStackSize(stackSize);
150} 151}
151 152
152// Entry rule entryRuleBooleanValue 153// Entry rule entryRuleUnnamedErrorPrediateDefinition
153entryRuleBooleanValue 154entryRuleUnnamedErrorPrediateDefinition
154: 155:
155{ before(grammarAccess.getBooleanValueRule()); } 156{ before(grammarAccess.getUnnamedErrorPrediateDefinitionRule()); }
156 ruleBooleanValue 157 ruleUnnamedErrorPrediateDefinition
157{ after(grammarAccess.getBooleanValueRule()); } 158{ after(grammarAccess.getUnnamedErrorPrediateDefinitionRule()); }
158 EOF 159 EOF
159; 160;
160 161
161// Rule BooleanValue 162// Rule UnnamedErrorPrediateDefinition
162ruleBooleanValue 163ruleUnnamedErrorPrediateDefinition
163 @init { 164 @init {
164 int stackSize = keepStackSize(); 165 int stackSize = keepStackSize();
165 } 166 }
166 : 167 :
167 ( 168 (
168 { before(grammarAccess.getBooleanValueAccess().getAlternatives()); } 169 { before(grammarAccess.getUnnamedErrorPrediateDefinitionAccess().getGroup()); }
169 (rule__BooleanValue__Alternatives) 170 (rule__UnnamedErrorPrediateDefinition__Group__0)
170 { after(grammarAccess.getBooleanValueAccess().getAlternatives()); } 171 { after(grammarAccess.getUnnamedErrorPrediateDefinitionAccess().getGroup()); }
171 ) 172 )
172; 173;
173finally { 174finally {
174 restoreStackSize(stackSize); 175 restoreStackSize(stackSize);
175} 176}
176 177
177// Entry rule entryRuleTruthValue 178// Entry rule entryRuleDefaultDefinition
178entryRuleTruthValue 179entryRuleDefaultDefinition
179: 180:
180{ before(grammarAccess.getTruthValueRule()); } 181{ before(grammarAccess.getDefaultDefinitionRule()); }
181 ruleTruthValue 182 ruleDefaultDefinition
182{ after(grammarAccess.getTruthValueRule()); } 183{ after(grammarAccess.getDefaultDefinitionRule()); }
183 EOF 184 EOF
184; 185;
185 186
186// Rule TruthValue 187// Rule DefaultDefinition
187ruleTruthValue 188ruleDefaultDefinition
188 @init { 189 @init {
189 int stackSize = keepStackSize(); 190 int stackSize = keepStackSize();
190 } 191 }
191 : 192 :
192 ( 193 (
193 { before(grammarAccess.getTruthValueAccess().getAlternatives()); } 194 { before(grammarAccess.getDefaultDefinitionAccess().getGroup()); }
194 (rule__TruthValue__Alternatives) 195 (rule__DefaultDefinition__Group__0)
195 { after(grammarAccess.getTruthValueAccess().getAlternatives()); } 196 { after(grammarAccess.getDefaultDefinitionAccess().getGroup()); }
196 ) 197 )
197; 198;
198finally { 199finally {
199 restoreStackSize(stackSize); 200 restoreStackSize(stackSize);
200} 201}
201 202
202// Entry rule entryRuleInterpretation 203// Entry rule entryRuleExternPredicateDefinition
203entryRuleInterpretation 204entryRuleExternPredicateDefinition
204: 205:
205{ before(grammarAccess.getInterpretationRule()); } 206{ before(grammarAccess.getExternPredicateDefinitionRule()); }
206 ruleInterpretation 207 ruleExternPredicateDefinition
207{ after(grammarAccess.getInterpretationRule()); } 208{ after(grammarAccess.getExternPredicateDefinitionRule()); }
208 EOF 209 EOF
209; 210;
210 211
211// Rule Interpretation 212// Rule ExternPredicateDefinition
212ruleInterpretation 213ruleExternPredicateDefinition
213 @init { 214 @init {
214 int stackSize = keepStackSize(); 215 int stackSize = keepStackSize();
215 } 216 }
216 : 217 :
217 ( 218 (
218 { before(grammarAccess.getInterpretationAccess().getAlternatives()); } 219 { before(grammarAccess.getExternPredicateDefinitionAccess().getGroup()); }
219 (rule__Interpretation__Alternatives) 220 (rule__ExternPredicateDefinition__Group__0)
220 { after(grammarAccess.getInterpretationAccess().getAlternatives()); } 221 { after(grammarAccess.getExternPredicateDefinitionAccess().getGroup()); }
221 ) 222 )
222; 223;
223finally { 224finally {
224 restoreStackSize(stackSize); 225 restoreStackSize(stackSize);
225} 226}
226 227
227// Entry rule entryRuleBasicInterpretation 228// Entry rule entryRuleMetricDefinition
228entryRuleBasicInterpretation 229entryRuleMetricDefinition
229: 230:
230{ before(grammarAccess.getBasicInterpretationRule()); } 231{ before(grammarAccess.getMetricDefinitionRule()); }
231 ruleBasicInterpretation 232 ruleMetricDefinition
232{ after(grammarAccess.getBasicInterpretationRule()); } 233{ after(grammarAccess.getMetricDefinitionRule()); }
233 EOF 234 EOF
234; 235;
235 236
236// Rule BasicInterpretation 237// Rule MetricDefinition
237ruleBasicInterpretation 238ruleMetricDefinition
238 @init { 239 @init {
239 int stackSize = keepStackSize(); 240 int stackSize = keepStackSize();
240 } 241 }
241 : 242 :
242 ( 243 (
243 { before(grammarAccess.getBasicInterpretationAccess().getGroup()); } 244 { before(grammarAccess.getMetricDefinitionAccess().getGroup()); }
244 (rule__BasicInterpretation__Group__0) 245 (rule__MetricDefinition__Group__0)
245 { after(grammarAccess.getBasicInterpretationAccess().getGroup()); } 246 { after(grammarAccess.getMetricDefinitionAccess().getGroup()); }
246 ) 247 )
247; 248;
248finally { 249finally {
249 restoreStackSize(stackSize); 250 restoreStackSize(stackSize);
250} 251}
251 252
252// Entry rule entryRuleSymbol 253// Entry rule entryRuleExternMetricDefinition
253entryRuleSymbol 254entryRuleExternMetricDefinition
254: 255:
255{ before(grammarAccess.getSymbolRule()); } 256{ before(grammarAccess.getExternMetricDefinitionRule()); }
256 ruleSymbol 257 ruleExternMetricDefinition
257{ after(grammarAccess.getSymbolRule()); } 258{ after(grammarAccess.getExternMetricDefinitionRule()); }
258 EOF 259 EOF
259; 260;
260 261
261// Rule Symbol 262// Rule ExternMetricDefinition
262ruleSymbol 263ruleExternMetricDefinition
263 @init { 264 @init {
264 int stackSize = keepStackSize(); 265 int stackSize = keepStackSize();
265 } 266 }
266 : 267 :
267 ( 268 (
268 { before(grammarAccess.getSymbolAccess().getAlternatives()); } 269 { before(grammarAccess.getExternMetricDefinitionAccess().getGroup()); }
269 (rule__Symbol__Alternatives) 270 (rule__ExternMetricDefinition__Group__0)
270 { after(grammarAccess.getSymbolAccess().getAlternatives()); } 271 { after(grammarAccess.getExternMetricDefinitionAccess().getGroup()); }
271 ) 272 )
272; 273;
273finally { 274finally {
274 restoreStackSize(stackSize); 275 restoreStackSize(stackSize);
275} 276}
276 277
277// Entry rule entryRuleModelSymbol 278// Entry rule entryRuleExpression
278entryRuleModelSymbol 279entryRuleExpression
279: 280:
280{ before(grammarAccess.getModelSymbolRule()); } 281{ before(grammarAccess.getExpressionRule()); }
281 ruleModelSymbol 282 ruleExpression
282{ after(grammarAccess.getModelSymbolRule()); } 283{ after(grammarAccess.getExpressionRule()); }
283 EOF 284 EOF
284; 285;
285 286
286// Rule ModelSymbol 287// Rule Expression
287ruleModelSymbol 288ruleExpression
288 @init { 289 @init {
289 int stackSize = keepStackSize(); 290 int stackSize = keepStackSize();
290 } 291 }
291 : 292 :
292 ( 293 (
293 { before(grammarAccess.getModelSymbolAccess().getNameAssignment()); } 294 { before(grammarAccess.getExpressionAccess().getAlternatives()); }
294 (rule__ModelSymbol__NameAssignment) 295 (rule__Expression__Alternatives)
295 { after(grammarAccess.getModelSymbolAccess().getNameAssignment()); } 296 { after(grammarAccess.getExpressionAccess().getAlternatives()); }
296 ) 297 )
297; 298;
298finally { 299finally {
299 restoreStackSize(stackSize); 300 restoreStackSize(stackSize);
300} 301}
301 302
302// Entry rule entryRulePartialitySymbol 303// Entry rule entryRuleIfElse
303entryRulePartialitySymbol 304entryRuleIfElse
304: 305:
305{ before(grammarAccess.getPartialitySymbolRule()); } 306{ before(grammarAccess.getIfElseRule()); }
306 rulePartialitySymbol 307 ruleIfElse
307{ after(grammarAccess.getPartialitySymbolRule()); } 308{ after(grammarAccess.getIfElseRule()); }
308 EOF 309 EOF
309; 310;
310 311
311// Rule PartialitySymbol 312// Rule IfElse
312rulePartialitySymbol 313ruleIfElse
313 @init { 314 @init {
314 int stackSize = keepStackSize(); 315 int stackSize = keepStackSize();
315 } 316 }
316 : 317 :
317 ( 318 (
318 { before(grammarAccess.getPartialitySymbolAccess().getAlternatives()); } 319 { before(grammarAccess.getIfElseAccess().getGroup()); }
319 (rule__PartialitySymbol__Alternatives) 320 (rule__IfElse__Group__0)
320 { after(grammarAccess.getPartialitySymbolAccess().getAlternatives()); } 321 { after(grammarAccess.getIfElseAccess().getGroup()); }
321 ) 322 )
322; 323;
323finally { 324finally {
324 restoreStackSize(stackSize); 325 restoreStackSize(stackSize);
325} 326}
326 327
327// Entry rule entryRuleExistSymbol 328// Entry rule entryRuleDisjunctiveExpression
328entryRuleExistSymbol 329entryRuleDisjunctiveExpression
329: 330:
330{ before(grammarAccess.getExistSymbolRule()); } 331{ before(grammarAccess.getDisjunctiveExpressionRule()); }
331 ruleExistSymbol 332 ruleDisjunctiveExpression
332{ after(grammarAccess.getExistSymbolRule()); } 333{ after(grammarAccess.getDisjunctiveExpressionRule()); }
333 EOF 334 EOF
334; 335;
335 336
336// Rule ExistSymbol 337// Rule DisjunctiveExpression
337ruleExistSymbol 338ruleDisjunctiveExpression
338 @init { 339 @init {
339 int stackSize = keepStackSize(); 340 int stackSize = keepStackSize();
340 } 341 }
341 : 342 :
342 ( 343 (
343 { before(grammarAccess.getExistSymbolAccess().getGroup()); } 344 { before(grammarAccess.getDisjunctiveExpressionAccess().getGroup()); }
344 (rule__ExistSymbol__Group__0) 345 (rule__DisjunctiveExpression__Group__0)
345 { after(grammarAccess.getExistSymbolAccess().getGroup()); } 346 { after(grammarAccess.getDisjunctiveExpressionAccess().getGroup()); }
346 ) 347 )
347; 348;
348finally { 349finally {
349 restoreStackSize(stackSize); 350 restoreStackSize(stackSize);
350} 351}
351 352
352// Entry rule entryRuleEqualsSymbol 353// Entry rule entryRuleCase
353entryRuleEqualsSymbol 354entryRuleCase
354: 355:
355{ before(grammarAccess.getEqualsSymbolRule()); } 356{ before(grammarAccess.getCaseRule()); }
356 ruleEqualsSymbol 357 ruleCase
357{ after(grammarAccess.getEqualsSymbolRule()); } 358{ after(grammarAccess.getCaseRule()); }
358 EOF 359 EOF
359; 360;
360 361
361// Rule EqualsSymbol 362// Rule Case
362ruleEqualsSymbol 363ruleCase
363 @init { 364 @init {
364 int stackSize = keepStackSize(); 365 int stackSize = keepStackSize();
365 } 366 }
366 : 367 :
367 ( 368 (
368 { before(grammarAccess.getEqualsSymbolAccess().getGroup()); } 369 { before(grammarAccess.getCaseAccess().getGroup()); }
369 (rule__EqualsSymbol__Group__0) 370 (rule__Case__Group__0)
370 { after(grammarAccess.getEqualsSymbolAccess().getGroup()); } 371 { after(grammarAccess.getCaseAccess().getGroup()); }
371 ) 372 )
372; 373;
373finally { 374finally {
374 restoreStackSize(stackSize); 375 restoreStackSize(stackSize);
375} 376}
376 377
377// Entry rule entryRuleDataSymbol 378// Entry rule entryRuleConjunctiveExpression
378entryRuleDataSymbol 379entryRuleConjunctiveExpression
379: 380:
380{ before(grammarAccess.getDataSymbolRule()); } 381{ before(grammarAccess.getConjunctiveExpressionRule()); }
381 ruleDataSymbol 382 ruleConjunctiveExpression
382{ after(grammarAccess.getDataSymbolRule()); } 383{ after(grammarAccess.getConjunctiveExpressionRule()); }
383 EOF 384 EOF
384; 385;
385 386
386// Rule DataSymbol 387// Rule ConjunctiveExpression
387ruleDataSymbol 388ruleConjunctiveExpression
388 @init { 389 @init {
389 int stackSize = keepStackSize(); 390 int stackSize = keepStackSize();
390 } 391 }
391 : 392 :
392 ( 393 (
393 { before(grammarAccess.getDataSymbolAccess().getAlternatives()); } 394 { before(grammarAccess.getConjunctiveExpressionAccess().getGroup()); }
394 (rule__DataSymbol__Alternatives) 395 (rule__ConjunctiveExpression__Group__0)
395 { after(grammarAccess.getDataSymbolAccess().getAlternatives()); } 396 { after(grammarAccess.getConjunctiveExpressionAccess().getGroup()); }
396 ) 397 )
397; 398;
398finally { 399finally {
399 restoreStackSize(stackSize); 400 restoreStackSize(stackSize);
400} 401}
401 402
402// Entry rule entryRuleBooleanSymbol 403// Entry rule entryRuleComparisonExpression
403entryRuleBooleanSymbol 404entryRuleComparisonExpression
404: 405:
405{ before(grammarAccess.getBooleanSymbolRule()); } 406{ before(grammarAccess.getComparisonExpressionRule()); }
406 ruleBooleanSymbol 407 ruleComparisonExpression
407{ after(grammarAccess.getBooleanSymbolRule()); } 408{ after(grammarAccess.getComparisonExpressionRule()); }
408 EOF 409 EOF
409; 410;
410 411
411// Rule BooleanSymbol 412// Rule ComparisonExpression
412ruleBooleanSymbol 413ruleComparisonExpression
413 @init { 414 @init {
414 int stackSize = keepStackSize(); 415 int stackSize = keepStackSize();
415 } 416 }
416 : 417 :
417 ( 418 (
418 { before(grammarAccess.getBooleanSymbolAccess().getGroup()); } 419 { before(grammarAccess.getComparisonExpressionAccess().getGroup()); }
419 (rule__BooleanSymbol__Group__0) 420 (rule__ComparisonExpression__Group__0)
420 { after(grammarAccess.getBooleanSymbolAccess().getGroup()); } 421 { after(grammarAccess.getComparisonExpressionAccess().getGroup()); }
421 ) 422 )
422; 423;
423finally { 424finally {
424 restoreStackSize(stackSize); 425 restoreStackSize(stackSize);
425} 426}
426 427
427// Entry rule entryRuleIntegerSymbol 428// Entry rule entryRuleAdditiveExpression
428entryRuleIntegerSymbol 429entryRuleAdditiveExpression
429: 430:
430{ before(grammarAccess.getIntegerSymbolRule()); } 431{ before(grammarAccess.getAdditiveExpressionRule()); }
431 ruleIntegerSymbol 432 ruleAdditiveExpression
432{ after(grammarAccess.getIntegerSymbolRule()); } 433{ after(grammarAccess.getAdditiveExpressionRule()); }
433 EOF 434 EOF
434; 435;
435 436
436// Rule IntegerSymbol 437// Rule AdditiveExpression
437ruleIntegerSymbol 438ruleAdditiveExpression
438 @init { 439 @init {
439 int stackSize = keepStackSize(); 440 int stackSize = keepStackSize();
440 } 441 }
441 : 442 :
442 ( 443 (
443 { before(grammarAccess.getIntegerSymbolAccess().getGroup()); } 444 { before(grammarAccess.getAdditiveExpressionAccess().getGroup()); }
444 (rule__IntegerSymbol__Group__0) 445 (rule__AdditiveExpression__Group__0)
445 { after(grammarAccess.getIntegerSymbolAccess().getGroup()); } 446 { after(grammarAccess.getAdditiveExpressionAccess().getGroup()); }
446 ) 447 )
447; 448;
448finally { 449finally {
449 restoreStackSize(stackSize); 450 restoreStackSize(stackSize);
450} 451}
451 452
452// Entry rule entryRuleRealSymbol 453// Entry rule entryRuleMultiplicativeExpression
453entryRuleRealSymbol 454entryRuleMultiplicativeExpression
454: 455:
455{ before(grammarAccess.getRealSymbolRule()); } 456{ before(grammarAccess.getMultiplicativeExpressionRule()); }
456 ruleRealSymbol 457 ruleMultiplicativeExpression
457{ after(grammarAccess.getRealSymbolRule()); } 458{ after(grammarAccess.getMultiplicativeExpressionRule()); }
458 EOF 459 EOF
459; 460;
460 461
461// Rule RealSymbol 462// Rule MultiplicativeExpression
462ruleRealSymbol 463ruleMultiplicativeExpression
463 @init { 464 @init {
464 int stackSize = keepStackSize(); 465 int stackSize = keepStackSize();
465 } 466 }
466 : 467 :
467 ( 468 (
468 { before(grammarAccess.getRealSymbolAccess().getGroup()); } 469 { before(grammarAccess.getMultiplicativeExpressionAccess().getGroup()); }
469 (rule__RealSymbol__Group__0) 470 (rule__MultiplicativeExpression__Group__0)
470 { after(grammarAccess.getRealSymbolAccess().getGroup()); } 471 { after(grammarAccess.getMultiplicativeExpressionAccess().getGroup()); }
471 ) 472 )
472; 473;
473finally { 474finally {
474 restoreStackSize(stackSize); 475 restoreStackSize(stackSize);
475} 476}
476 477
477// Entry rule entryRuleStringSymbol 478// Entry rule entryRuleExponentialExpression
478entryRuleStringSymbol 479entryRuleExponentialExpression
479: 480:
480{ before(grammarAccess.getStringSymbolRule()); } 481{ before(grammarAccess.getExponentialExpressionRule()); }
481 ruleStringSymbol 482 ruleExponentialExpression
482{ after(grammarAccess.getStringSymbolRule()); } 483{ after(grammarAccess.getExponentialExpressionRule()); }
483 EOF 484 EOF
484; 485;
485 486
486// Rule StringSymbol 487// Rule ExponentialExpression
487ruleStringSymbol 488ruleExponentialExpression
488 @init { 489 @init {
489 int stackSize = keepStackSize(); 490 int stackSize = keepStackSize();
490 } 491 }
491 : 492 :
492 ( 493 (
493 { before(grammarAccess.getStringSymbolAccess().getGroup()); } 494 { before(grammarAccess.getExponentialExpressionAccess().getGroup()); }
494 (rule__StringSymbol__Group__0) 495 (rule__ExponentialExpression__Group__0)
495 { after(grammarAccess.getStringSymbolAccess().getGroup()); } 496 { after(grammarAccess.getExponentialExpressionAccess().getGroup()); }
496 ) 497 )
497; 498;
498finally { 499finally {
499 restoreStackSize(stackSize); 500 restoreStackSize(stackSize);
500} 501}
501 502
502// Entry rule entryRuleComplexObject 503// Entry rule entryRuleUnaryExpression
503entryRuleComplexObject 504entryRuleUnaryExpression
504: 505:
505{ before(grammarAccess.getComplexObjectRule()); } 506{ before(grammarAccess.getUnaryExpressionRule()); }
506 ruleComplexObject 507 ruleUnaryExpression
507{ after(grammarAccess.getComplexObjectRule()); } 508{ after(grammarAccess.getUnaryExpressionRule()); }
508 EOF 509 EOF
509; 510;
510 511
511// Rule ComplexObject 512// Rule UnaryExpression
512ruleComplexObject 513ruleUnaryExpression
513 @init { 514 @init {
514 int stackSize = keepStackSize(); 515 int stackSize = keepStackSize();
515 } 516 }
516 : 517 :
517 ( 518 (
518 { before(grammarAccess.getComplexObjectAccess().getAlternatives()); } 519 { before(grammarAccess.getUnaryExpressionAccess().getAlternatives()); }
519 (rule__ComplexObject__Alternatives) 520 (rule__UnaryExpression__Alternatives)
520 { after(grammarAccess.getComplexObjectAccess().getAlternatives()); } 521 { after(grammarAccess.getUnaryExpressionAccess().getAlternatives()); }
521 ) 522 )
522; 523;
523finally { 524finally {
524 restoreStackSize(stackSize); 525 restoreStackSize(stackSize);
525} 526}
526 527
527// Entry rule entryRuleObject 528// Entry rule entryRuleAggregationExpression
528entryRuleObject 529entryRuleAggregationExpression
529: 530:
530{ before(grammarAccess.getObjectRule()); } 531{ before(grammarAccess.getAggregationExpressionRule()); }
531 ruleObject 532 ruleAggregationExpression
532{ after(grammarAccess.getObjectRule()); } 533{ after(grammarAccess.getAggregationExpressionRule()); }
533 EOF 534 EOF
534; 535;
535 536
536// Rule Object 537// Rule AggregationExpression
537ruleObject 538ruleAggregationExpression
538 @init { 539 @init {
539 int stackSize = keepStackSize(); 540 int stackSize = keepStackSize();
540 } 541 }
541 : 542 :
542 ( 543 (
543 { before(grammarAccess.getObjectAccess().getAlternatives()); } 544 { before(grammarAccess.getAggregationExpressionAccess().getAlternatives()); }
544 (rule__Object__Alternatives) 545 (rule__AggregationExpression__Alternatives)
545 { after(grammarAccess.getObjectAccess().getAlternatives()); } 546 { after(grammarAccess.getAggregationExpressionAccess().getAlternatives()); }
546 ) 547 )
547; 548;
548finally { 549finally {
549 restoreStackSize(stackSize); 550 restoreStackSize(stackSize);
550} 551}
551 552
552// Entry rule entryRuleNamedObject 553// Entry rule entryRuleCount
553entryRuleNamedObject 554entryRuleCount
554: 555:
555{ before(grammarAccess.getNamedObjectRule()); } 556{ before(grammarAccess.getCountRule()); }
556 ruleNamedObject 557 ruleCount
557{ after(grammarAccess.getNamedObjectRule()); } 558{ after(grammarAccess.getCountRule()); }
558 EOF 559 EOF
559; 560;
560 561
561// Rule NamedObject 562// Rule Count
562ruleNamedObject 563ruleCount
563 @init { 564 @init {
564 int stackSize = keepStackSize(); 565 int stackSize = keepStackSize();
565 } 566 }
566 : 567 :
567 ( 568 (
568 { before(grammarAccess.getNamedObjectAccess().getGroup()); } 569 { before(grammarAccess.getCountAccess().getGroup()); }
569 (rule__NamedObject__Group__0) 570 (rule__Count__Group__0)
570 { after(grammarAccess.getNamedObjectAccess().getGroup()); } 571 { after(grammarAccess.getCountAccess().getGroup()); }
571 ) 572 )
572; 573;
573finally { 574finally {
574 restoreStackSize(stackSize); 575 restoreStackSize(stackSize);
575} 576}
576 577
577// Entry rule entryRuleUnnamedObject 578// Entry rule entryRuleAggregation
578entryRuleUnnamedObject 579entryRuleAggregation
579: 580:
580{ before(grammarAccess.getUnnamedObjectRule()); } 581{ before(grammarAccess.getAggregationRule()); }
581 ruleUnnamedObject 582 ruleAggregation
582{ after(grammarAccess.getUnnamedObjectRule()); } 583{ after(grammarAccess.getAggregationRule()); }
583 EOF 584 EOF
584; 585;
585 586
586// Rule UnnamedObject 587// Rule Aggregation
587ruleUnnamedObject 588ruleAggregation
588 @init { 589 @init {
589 int stackSize = keepStackSize(); 590 int stackSize = keepStackSize();
590 } 591 }
591 : 592 :
592 ( 593 (
593 { before(grammarAccess.getUnnamedObjectAccess().getNameAssignment()); } 594 { before(grammarAccess.getAggregationAccess().getGroup()); }
594 (rule__UnnamedObject__NameAssignment) 595 (rule__Aggregation__Group__0)
595 { after(grammarAccess.getUnnamedObjectAccess().getNameAssignment()); } 596 { after(grammarAccess.getAggregationAccess().getGroup()); }
596 ) 597 )
597; 598;
598finally { 599finally {
599 restoreStackSize(stackSize); 600 restoreStackSize(stackSize);
600} 601}
601 602
602// Entry rule entryRuleDataObject 603// Entry rule entryRuleAtomicExpression
603entryRuleDataObject 604entryRuleAtomicExpression
604: 605:
605{ before(grammarAccess.getDataObjectRule()); } 606{ before(grammarAccess.getAtomicExpressionRule()); }
606 ruleDataObject 607 ruleAtomicExpression
607{ after(grammarAccess.getDataObjectRule()); } 608{ after(grammarAccess.getAtomicExpressionRule()); }
608 EOF 609 EOF
609; 610;
610 611
611// Rule DataObject 612// Rule AtomicExpression
612ruleDataObject 613ruleAtomicExpression
613 @init { 614 @init {
614 int stackSize = keepStackSize(); 615 int stackSize = keepStackSize();
615 } 616 }
616 : 617 :
617 ( 618 (
618 { before(grammarAccess.getDataObjectAccess().getAlternatives()); } 619 { before(grammarAccess.getAtomicExpressionAccess().getAlternatives()); }
619 (rule__DataObject__Alternatives) 620 (rule__AtomicExpression__Alternatives)
620 { after(grammarAccess.getDataObjectAccess().getAlternatives()); } 621 { after(grammarAccess.getAtomicExpressionAccess().getAlternatives()); }
621 ) 622 )
622; 623;
623finally { 624finally {
624 restoreStackSize(stackSize); 625 restoreStackSize(stackSize);
625} 626}
626 627
627// Entry rule entryRuleBooleanObject 628// Entry rule entryRuleCall
628entryRuleBooleanObject 629entryRuleCall
629: 630:
630{ before(grammarAccess.getBooleanObjectRule()); } 631{ before(grammarAccess.getCallRule()); }
631 ruleBooleanObject 632 ruleCall
632{ after(grammarAccess.getBooleanObjectRule()); } 633{ after(grammarAccess.getCallRule()); }
633 EOF 634 EOF
634; 635;
635 636
636// Rule BooleanObject 637// Rule Call
637ruleBooleanObject 638ruleCall
638 @init { 639 @init {
639 int stackSize = keepStackSize(); 640 int stackSize = keepStackSize();
640 } 641 }
641 : 642 :
642 ( 643 (
643 { before(grammarAccess.getBooleanObjectAccess().getValueAssignment()); } 644 { before(grammarAccess.getCallAccess().getGroup()); }
644 (rule__BooleanObject__ValueAssignment) 645 (rule__Call__Group__0)
645 { after(grammarAccess.getBooleanObjectAccess().getValueAssignment()); } 646 { after(grammarAccess.getCallAccess().getGroup()); }
646 ) 647 )
647; 648;
648finally { 649finally {
649 restoreStackSize(stackSize); 650 restoreStackSize(stackSize);
650} 651}
651 652
652// Entry rule entryRuleIntObject 653// Entry rule entryRuleArgumentList
653entryRuleIntObject 654entryRuleArgumentList
654: 655:
655{ before(grammarAccess.getIntObjectRule()); } 656{ before(grammarAccess.getArgumentListRule()); }
656 ruleIntObject 657 ruleArgumentList
657{ after(grammarAccess.getIntObjectRule()); } 658{ after(grammarAccess.getArgumentListRule()); }
658 EOF 659 EOF
659; 660;
660 661
661// Rule IntObject 662// Rule ArgumentList
662ruleIntObject 663ruleArgumentList
663 @init { 664 @init {
664 int stackSize = keepStackSize(); 665 int stackSize = keepStackSize();
665 } 666 }
666 : 667 :
667 ( 668 (
668 { before(grammarAccess.getIntObjectAccess().getValueAssignment()); } 669 { before(grammarAccess.getArgumentListAccess().getGroup()); }
669 (rule__IntObject__ValueAssignment) 670 (rule__ArgumentList__Group__0)
670 { after(grammarAccess.getIntObjectAccess().getValueAssignment()); } 671 { after(grammarAccess.getArgumentListAccess().getGroup()); }
671 ) 672 )
672; 673;
673finally { 674finally {
674 restoreStackSize(stackSize); 675 restoreStackSize(stackSize);
675} 676}
676 677
677// Entry rule entryRuleRealObject 678// Entry rule entryRuleArgument
678entryRuleRealObject 679entryRuleArgument
679: 680:
680{ before(grammarAccess.getRealObjectRule()); } 681{ before(grammarAccess.getArgumentRule()); }
681 ruleRealObject 682 ruleArgument
682{ after(grammarAccess.getRealObjectRule()); } 683{ after(grammarAccess.getArgumentRule()); }
683 EOF 684 EOF
684; 685;
685 686
686// Rule RealObject 687// Rule Argument
687ruleRealObject 688ruleArgument
688 @init { 689 @init {
689 int stackSize = keepStackSize(); 690 int stackSize = keepStackSize();
690 } 691 }
691 : 692 :
692 ( 693 (
693 { before(grammarAccess.getRealObjectAccess().getValueAssignment()); } 694 { before(grammarAccess.getArgumentAccess().getAlternatives()); }
694 (rule__RealObject__ValueAssignment) 695 (rule__Argument__Alternatives)
695 { after(grammarAccess.getRealObjectAccess().getValueAssignment()); } 696 { after(grammarAccess.getArgumentAccess().getAlternatives()); }
696 ) 697 )
697; 698;
698finally { 699finally {
699 restoreStackSize(stackSize); 700 restoreStackSize(stackSize);
700} 701}
701 702
702// Entry rule entryRuleStringObject 703// Entry rule entryRuleExpressionArgument
703entryRuleStringObject 704entryRuleExpressionArgument
704: 705:
705{ before(grammarAccess.getStringObjectRule()); } 706{ before(grammarAccess.getExpressionArgumentRule()); }
706 ruleStringObject 707 ruleExpressionArgument
707{ after(grammarAccess.getStringObjectRule()); } 708{ after(grammarAccess.getExpressionArgumentRule()); }
708 EOF 709 EOF
709; 710;
710 711
711// Rule StringObject 712// Rule ExpressionArgument
712ruleStringObject 713ruleExpressionArgument
713 @init { 714 @init {
714 int stackSize = keepStackSize(); 715 int stackSize = keepStackSize();
715 } 716 }
716 : 717 :
717 ( 718 (
718 { before(grammarAccess.getStringObjectAccess().getValueAssignment()); } 719 { before(grammarAccess.getExpressionArgumentAccess().getBodyAssignment()); }
719 (rule__StringObject__ValueAssignment) 720 (rule__ExpressionArgument__BodyAssignment)
720 { after(grammarAccess.getStringObjectAccess().getValueAssignment()); } 721 { after(grammarAccess.getExpressionArgumentAccess().getBodyAssignment()); }
721 ) 722 )
722; 723;
723finally { 724finally {
724 restoreStackSize(stackSize); 725 restoreStackSize(stackSize);
725} 726}
726 727
727// Entry rule entryRulePredicate 728// Entry rule entryRuleStarArgument
728entryRulePredicate 729entryRuleStarArgument
729: 730:
730{ before(grammarAccess.getPredicateRule()); } 731{ before(grammarAccess.getStarArgumentRule()); }
731 rulePredicate 732 ruleStarArgument
732{ after(grammarAccess.getPredicateRule()); } 733{ after(grammarAccess.getStarArgumentRule()); }
733 EOF 734 EOF
734; 735;
735 736
736// Rule Predicate 737// Rule StarArgument
737rulePredicate 738ruleStarArgument
738 @init { 739 @init {
739 int stackSize = keepStackSize(); 740 int stackSize = keepStackSize();
740 } 741 }
741 : 742 :
742 ( 743 (
743 { before(grammarAccess.getPredicateAccess().getGroup()); } 744 { before(grammarAccess.getStarArgumentAccess().getGroup()); }
744 (rule__Predicate__Group__0) 745 (rule__StarArgument__Group__0)
745 { after(grammarAccess.getPredicateAccess().getGroup()); } 746 { after(grammarAccess.getStarArgumentAccess().getGroup()); }
746 ) 747 )
747; 748;
748finally { 749finally {
749 restoreStackSize(stackSize); 750 restoreStackSize(stackSize);
750} 751}
751 752
752// Entry rule entryRuleParameter 753// Entry rule entryRuleTypedArgument
753entryRuleParameter 754entryRuleTypedArgument
754: 755:
755{ before(grammarAccess.getParameterRule()); } 756{ before(grammarAccess.getTypedArgumentRule()); }
756 ruleParameter 757 ruleTypedArgument
757{ after(grammarAccess.getParameterRule()); } 758{ after(grammarAccess.getTypedArgumentRule()); }
758 EOF 759 EOF
759; 760;
760 761
761// Rule Parameter 762// Rule TypedArgument
762ruleParameter 763ruleTypedArgument
763 @init { 764 @init {
764 int stackSize = keepStackSize(); 765 int stackSize = keepStackSize();
765 } 766 }
766 : 767 :
767 ( 768 (
768 { before(grammarAccess.getParameterAccess().getGroup()); } 769 { before(grammarAccess.getTypedArgumentAccess().getGroup()); }
769 (rule__Parameter__Group__0) 770 (rule__TypedArgument__Group__0)
770 { after(grammarAccess.getParameterAccess().getGroup()); } 771 { after(grammarAccess.getTypedArgumentAccess().getGroup()); }
771 ) 772 )
772; 773;
773finally { 774finally {
774 restoreStackSize(stackSize); 775 restoreStackSize(stackSize);
775} 776}
776 777
777// Entry rule entryRulePatternBody 778// Entry rule entryRuleTypedStarArgument
778entryRulePatternBody 779entryRuleTypedStarArgument
779: 780:
780{ before(grammarAccess.getPatternBodyRule()); } 781{ before(grammarAccess.getTypedStarArgumentRule()); }
781 rulePatternBody 782 ruleTypedStarArgument
782{ after(grammarAccess.getPatternBodyRule()); } 783{ after(grammarAccess.getTypedStarArgumentRule()); }
783 EOF 784 EOF
784; 785;
785 786
786// Rule PatternBody 787// Rule TypedStarArgument
787rulePatternBody 788ruleTypedStarArgument
788 @init { 789 @init {
789 int stackSize = keepStackSize(); 790 int stackSize = keepStackSize();
790 } 791 }
791 : 792 :
792 ( 793 (
793 { before(grammarAccess.getPatternBodyAccess().getGroup()); } 794 { before(grammarAccess.getTypedStarArgumentAccess().getGroup()); }
794 (rule__PatternBody__Group__0) 795 (rule__TypedStarArgument__Group__0)
795 { after(grammarAccess.getPatternBodyAccess().getGroup()); } 796 { after(grammarAccess.getTypedStarArgumentAccess().getGroup()); }
796 ) 797 )
797; 798;
798finally { 799finally {
799 restoreStackSize(stackSize); 800 restoreStackSize(stackSize);
800} 801}
801 802
802// Entry rule entryRulePolarity 803// Entry rule entryRuleReference
803entryRulePolarity 804entryRuleReference
804: 805:
805{ before(grammarAccess.getPolarityRule()); } 806{ before(grammarAccess.getReferenceRule()); }
806 rulePolarity 807 ruleReference
807{ after(grammarAccess.getPolarityRule()); } 808{ after(grammarAccess.getReferenceRule()); }
808 EOF 809 EOF
809; 810;
810 811
811// Rule Polarity 812// Rule Reference
812rulePolarity 813ruleReference
813 @init { 814 @init {
814 int stackSize = keepStackSize(); 815 int stackSize = keepStackSize();
815 } 816 }
816 : 817 :
817 ( 818 (
818 { before(grammarAccess.getPolarityAccess().getAlternatives()); } 819 { before(grammarAccess.getReferenceAccess().getReferredAssignment()); }
819 (rule__Polarity__Alternatives) 820 (rule__Reference__ReferredAssignment)
820 { after(grammarAccess.getPolarityAccess().getAlternatives()); } 821 { after(grammarAccess.getReferenceAccess().getReferredAssignment()); }
821 ) 822 )
822; 823;
823finally { 824finally {
824 restoreStackSize(stackSize); 825 restoreStackSize(stackSize);
825} 826}
826 827
827// Entry rule entryRuleConstraint 828// Entry rule entryRuleInterval
828entryRuleConstraint 829entryRuleInterval
829: 830:
830{ before(grammarAccess.getConstraintRule()); } 831{ before(grammarAccess.getIntervalRule()); }
831 ruleConstraint 832 ruleInterval
832{ after(grammarAccess.getConstraintRule()); } 833{ after(grammarAccess.getIntervalRule()); }
833 EOF 834 EOF
834; 835;
835 836
836// Rule Constraint 837// Rule Interval
837ruleConstraint 838ruleInterval
838 @init { 839 @init {
839 int stackSize = keepStackSize(); 840 int stackSize = keepStackSize();
840 } 841 }
841 : 842 :
842 ( 843 (
843 { before(grammarAccess.getConstraintAccess().getAlternatives()); } 844 { before(grammarAccess.getIntervalAccess().getGroup()); }
844 (rule__Constraint__Alternatives) 845 (rule__Interval__Group__0)
845 { after(grammarAccess.getConstraintAccess().getAlternatives()); } 846 { after(grammarAccess.getIntervalAccess().getGroup()); }
846 ) 847 )
847; 848;
848finally { 849finally {
849 restoreStackSize(stackSize); 850 restoreStackSize(stackSize);
850} 851}
851 852
852// Entry rule entryRuleClosureType 853// Entry rule entryRuleLiteral
853entryRuleClosureType 854entryRuleLiteral
854: 855:
855{ before(grammarAccess.getClosureTypeRule()); } 856{ before(grammarAccess.getLiteralRule()); }
856 ruleClosureType 857 ruleLiteral
857{ after(grammarAccess.getClosureTypeRule()); } 858{ after(grammarAccess.getLiteralRule()); }
858 EOF 859 EOF
859; 860;
860 861
861// Rule ClosureType 862// Rule Literal
862ruleClosureType 863ruleLiteral
863 @init { 864 @init {
864 int stackSize = keepStackSize(); 865 int stackSize = keepStackSize();
865 } 866 }
866 : 867 :
867 ( 868 (
868 { before(grammarAccess.getClosureTypeAccess().getAlternatives()); } 869 { before(grammarAccess.getLiteralAccess().getAlternatives()); }
869 (rule__ClosureType__Alternatives) 870 (rule__Literal__Alternatives)
870 { after(grammarAccess.getClosureTypeAccess().getAlternatives()); } 871 { after(grammarAccess.getLiteralAccess().getAlternatives()); }
871 ) 872 )
872; 873;
873finally { 874finally {
874 restoreStackSize(stackSize); 875 restoreStackSize(stackSize);
875} 876}
876 877
877// Entry rule entryRuleLiteral 878// Entry rule entryRuleLogicLiteral
878entryRuleLiteral 879entryRuleLogicLiteral
879: 880:
880{ before(grammarAccess.getLiteralRule()); } 881{ before(grammarAccess.getLogicLiteralRule()); }
881 ruleLiteral 882 ruleLogicLiteral
882{ after(grammarAccess.getLiteralRule()); } 883{ after(grammarAccess.getLogicLiteralRule()); }
883 EOF 884 EOF
884; 885;
885 886
886// Rule Literal 887// Rule LogicLiteral
887ruleLiteral 888ruleLogicLiteral
888 @init { 889 @init {
889 int stackSize = keepStackSize(); 890 int stackSize = keepStackSize();
890 } 891 }
891 : 892 :
892 ( 893 (
893 { before(grammarAccess.getLiteralAccess().getAlternatives()); } 894 { before(grammarAccess.getLogicLiteralAccess().getValueAssignment()); }
894 (rule__Literal__Alternatives) 895 (rule__LogicLiteral__ValueAssignment)
895 { after(grammarAccess.getLiteralAccess().getAlternatives()); } 896 { after(grammarAccess.getLogicLiteralAccess().getValueAssignment()); }
896 ) 897 )
897; 898;
898finally { 899finally {
899 restoreStackSize(stackSize); 900 restoreStackSize(stackSize);
900} 901}
901 902
902// Entry rule entryRuleVariable 903// Entry rule entryRuleNumericLiteral
903entryRuleVariable 904entryRuleNumericLiteral
904: 905:
905{ before(grammarAccess.getVariableRule()); } 906{ before(grammarAccess.getNumericLiteralRule()); }
906 ruleVariable 907 ruleNumericLiteral
907{ after(grammarAccess.getVariableRule()); } 908{ after(grammarAccess.getNumericLiteralRule()); }
908 EOF 909 EOF
909; 910;
910 911
911// Rule Variable 912// Rule NumericLiteral
912ruleVariable 913ruleNumericLiteral
913 @init { 914 @init {
914 int stackSize = keepStackSize(); 915 int stackSize = keepStackSize();
915 } 916 }
916 : 917 :
917 ( 918 (
918 { before(grammarAccess.getVariableAccess().getNameAssignment()); } 919 { before(grammarAccess.getNumericLiteralAccess().getValueAssignment()); }
919 (rule__Variable__NameAssignment) 920 (rule__NumericLiteral__ValueAssignment)
920 { after(grammarAccess.getVariableAccess().getNameAssignment()); } 921 { after(grammarAccess.getNumericLiteralAccess().getValueAssignment()); }
921 ) 922 )
922; 923;
923finally { 924finally {
924 restoreStackSize(stackSize); 925 restoreStackSize(stackSize);
925} 926}
926 927
927// Entry rule entryRuleAllInstances 928// Entry rule entryRuleInfinityLiteral
928entryRuleAllInstances 929entryRuleInfinityLiteral
929: 930:
930{ before(grammarAccess.getAllInstancesRule()); } 931{ before(grammarAccess.getInfinityLiteralRule()); }
931 ruleAllInstances 932 ruleInfinityLiteral
932{ after(grammarAccess.getAllInstancesRule()); } 933{ after(grammarAccess.getInfinityLiteralRule()); }
933 EOF 934 EOF
934; 935;
935 936
936// Rule AllInstances 937// Rule InfinityLiteral
937ruleAllInstances 938ruleInfinityLiteral
938 @init { 939 @init {
939 int stackSize = keepStackSize(); 940 int stackSize = keepStackSize();
940 } 941 }
941 : 942 :
942 ( 943 (
943 { before(grammarAccess.getAllInstancesAccess().getGroup()); } 944 { before(grammarAccess.getInfinityLiteralAccess().getGroup()); }
944 (rule__AllInstances__Group__0) 945 (rule__InfinityLiteral__Group__0)
945 { after(grammarAccess.getAllInstancesAccess().getGroup()); } 946 { after(grammarAccess.getInfinityLiteralAccess().getGroup()); }
946 ) 947 )
947; 948;
948finally { 949finally {
949 restoreStackSize(stackSize); 950 restoreStackSize(stackSize);
950} 951}
951 952
952// Entry rule entryRuleAllObjects 953// Entry rule entryRuleEmptyIntervalLiteral
953entryRuleAllObjects 954entryRuleEmptyIntervalLiteral
954: 955:
955{ before(grammarAccess.getAllObjectsRule()); } 956{ before(grammarAccess.getEmptyIntervalLiteralRule()); }
956 ruleAllObjects 957 ruleEmptyIntervalLiteral
957{ after(grammarAccess.getAllObjectsRule()); } 958{ after(grammarAccess.getEmptyIntervalLiteralRule()); }
958 EOF 959 EOF
959; 960;
960 961
961// Rule AllObjects 962// Rule EmptyIntervalLiteral
962ruleAllObjects 963ruleEmptyIntervalLiteral
963 @init { 964 @init {
964 int stackSize = keepStackSize(); 965 int stackSize = keepStackSize();
965 } 966 }
966 : 967 :
967 ( 968 (
968 { before(grammarAccess.getAllObjectsAccess().getGroup()); } 969 { before(grammarAccess.getEmptyIntervalLiteralAccess().getGroup()); }
969 (rule__AllObjects__Group__0) 970 (rule__EmptyIntervalLiteral__Group__0)
970 { after(grammarAccess.getAllObjectsAccess().getGroup()); } 971 { after(grammarAccess.getEmptyIntervalLiteralAccess().getGroup()); }
971 ) 972 )
972; 973;
973finally { 974finally {
974 restoreStackSize(stackSize); 975 restoreStackSize(stackSize);
975} 976}
976 977
977// Entry rule entryRuleDefaultInterpretation 978// Entry rule entryRuleStringLiteral
978entryRuleDefaultInterpretation 979entryRuleStringLiteral
979: 980:
980{ before(grammarAccess.getDefaultInterpretationRule()); } 981{ before(grammarAccess.getStringLiteralRule()); }
981 ruleDefaultInterpretation 982 ruleStringLiteral
982{ after(grammarAccess.getDefaultInterpretationRule()); } 983{ after(grammarAccess.getStringLiteralRule()); }
983 EOF 984 EOF
984; 985;
985 986
986// Rule DefaultInterpretation 987// Rule StringLiteral
987ruleDefaultInterpretation 988ruleStringLiteral
988 @init { 989 @init {
989 int stackSize = keepStackSize(); 990 int stackSize = keepStackSize();
990 } 991 }
991 : 992 :
992 ( 993 (
993 { before(grammarAccess.getDefaultInterpretationAccess().getGroup()); } 994 { before(grammarAccess.getStringLiteralAccess().getValueAssignment()); }
994 (rule__DefaultInterpretation__Group__0) 995 (rule__StringLiteral__ValueAssignment)
995 { after(grammarAccess.getDefaultInterpretationAccess().getGroup()); } 996 { after(grammarAccess.getStringLiteralAccess().getValueAssignment()); }
996 ) 997 )
997; 998;
998finally { 999finally {
999 restoreStackSize(stackSize); 1000 restoreStackSize(stackSize);
1000} 1001}
1001 1002
1002// Entry rule entryRuleCDInterpretation 1003// Entry rule entryRuleClassDefinition
1003entryRuleCDInterpretation 1004entryRuleClassDefinition
1004: 1005:
1005{ before(grammarAccess.getCDInterpretationRule()); } 1006{ before(grammarAccess.getClassDefinitionRule()); }
1006 ruleCDInterpretation 1007 ruleClassDefinition
1007{ after(grammarAccess.getCDInterpretationRule()); } 1008{ after(grammarAccess.getClassDefinitionRule()); }
1008 EOF 1009 EOF
1009; 1010;
1010 1011
1011// Rule CDInterpretation 1012// Rule ClassDefinition
1012ruleCDInterpretation 1013ruleClassDefinition
1013 @init { 1014 @init {
1014 int stackSize = keepStackSize(); 1015 int stackSize = keepStackSize();
1015 } 1016 }
1016 : 1017 :
1017 ( 1018 (
1018 { before(grammarAccess.getCDInterpretationAccess().getAlternatives()); } 1019 { before(grammarAccess.getClassDefinitionAccess().getGroup()); }
1019 (rule__CDInterpretation__Alternatives) 1020 (rule__ClassDefinition__Group__0)
1020 { after(grammarAccess.getCDInterpretationAccess().getAlternatives()); } 1021 { after(grammarAccess.getClassDefinitionAccess().getGroup()); }
1021 ) 1022 )
1022; 1023;
1023finally { 1024finally {
1024 restoreStackSize(stackSize); 1025 restoreStackSize(stackSize);
1025} 1026}
1026 1027
1027// Entry rule entryRuleClassInterpretation 1028// Entry rule entryRuleMemberDefinition
1028entryRuleClassInterpretation 1029entryRuleMemberDefinition
1029: 1030:
1030{ before(grammarAccess.getClassInterpretationRule()); } 1031{ before(grammarAccess.getMemberDefinitionRule()); }
1031 ruleClassInterpretation 1032 ruleMemberDefinition
1032{ after(grammarAccess.getClassInterpretationRule()); } 1033{ after(grammarAccess.getMemberDefinitionRule()); }
1033 EOF 1034 EOF
1034; 1035;
1035 1036
1036// Rule ClassInterpretation 1037// Rule MemberDefinition
1037ruleClassInterpretation 1038ruleMemberDefinition
1038 @init { 1039 @init {
1039 int stackSize = keepStackSize(); 1040 int stackSize = keepStackSize();
1040 } 1041 }
1041 : 1042 :
1042 ( 1043 (
1043 { before(grammarAccess.getClassInterpretationAccess().getGroup()); } 1044 { before(grammarAccess.getMemberDefinitionAccess().getGroup()); }
1044 (rule__ClassInterpretation__Group__0) 1045 (rule__MemberDefinition__Group__0)
1045 { after(grammarAccess.getClassInterpretationAccess().getGroup()); } 1046 { after(grammarAccess.getMemberDefinitionAccess().getGroup()); }
1046 ) 1047 )
1047; 1048;
1048finally { 1049finally {
1049 restoreStackSize(stackSize); 1050 restoreStackSize(stackSize);
1050} 1051}
1051 1052
1052// Entry rule entryRuleEnumInterpretation 1053// Entry rule entryRuleMultiplicity
1053entryRuleEnumInterpretation 1054entryRuleMultiplicity
1054: 1055:
1055{ before(grammarAccess.getEnumInterpretationRule()); } 1056{ before(grammarAccess.getMultiplicityRule()); }
1056 ruleEnumInterpretation 1057 ruleMultiplicity
1057{ after(grammarAccess.getEnumInterpretationRule()); } 1058{ after(grammarAccess.getMultiplicityRule()); }
1058 EOF 1059 EOF
1059; 1060;
1060 1061
1061// Rule EnumInterpretation 1062// Rule Multiplicity
1062ruleEnumInterpretation 1063ruleMultiplicity
1063 @init { 1064 @init {
1064 int stackSize = keepStackSize(); 1065 int stackSize = keepStackSize();
1065 } 1066 }
1066 : 1067 :
1067 ( 1068 (
1068 { before(grammarAccess.getEnumInterpretationAccess().getGroup()); } 1069 { before(grammarAccess.getMultiplicityAccess().getAlternatives()); }
1069 (rule__EnumInterpretation__Group__0) 1070 (rule__Multiplicity__Alternatives)
1070 { after(grammarAccess.getEnumInterpretationAccess().getGroup()); } 1071 { after(grammarAccess.getMultiplicityAccess().getAlternatives()); }
1071 ) 1072 )
1072; 1073;
1073finally { 1074finally {
1074 restoreStackSize(stackSize); 1075 restoreStackSize(stackSize);
1075} 1076}
1076 1077
1077// Entry rule entryRuleFieldRelationInterpretation 1078// Entry rule entryRuleManyMultiplicity
1078entryRuleFieldRelationInterpretation 1079entryRuleManyMultiplicity
1079: 1080:
1080{ before(grammarAccess.getFieldRelationInterpretationRule()); } 1081{ before(grammarAccess.getManyMultiplicityRule()); }
1081 ruleFieldRelationInterpretation 1082 ruleManyMultiplicity
1082{ after(grammarAccess.getFieldRelationInterpretationRule()); } 1083{ after(grammarAccess.getManyMultiplicityRule()); }
1083 EOF 1084 EOF
1084; 1085;
1085 1086
1086// Rule FieldRelationInterpretation 1087// Rule ManyMultiplicity
1087ruleFieldRelationInterpretation 1088ruleManyMultiplicity
1088 @init { 1089 @init {
1089 int stackSize = keepStackSize(); 1090 int stackSize = keepStackSize();
1090 } 1091 }
1091 : 1092 :
1092 ( 1093 (
1093 { before(grammarAccess.getFieldRelationInterpretationAccess().getGroup()); } 1094 { before(grammarAccess.getManyMultiplicityAccess().getGroup()); }
1094 (rule__FieldRelationInterpretation__Group__0) 1095 (rule__ManyMultiplicity__Group__0)
1095 { after(grammarAccess.getFieldRelationInterpretationAccess().getGroup()); } 1096 { after(grammarAccess.getManyMultiplicityAccess().getGroup()); }
1096 ) 1097 )
1097; 1098;
1098finally { 1099finally {
1099 restoreStackSize(stackSize); 1100 restoreStackSize(stackSize);
1100} 1101}
1101 1102
1102// Entry rule entryRuleGlobalRelationInterpretation 1103// Entry rule entryRuleExactMultiplicity
1103entryRuleGlobalRelationInterpretation 1104entryRuleExactMultiplicity
1104: 1105:
1105{ before(grammarAccess.getGlobalRelationInterpretationRule()); } 1106{ before(grammarAccess.getExactMultiplicityRule()); }
1106 ruleGlobalRelationInterpretation 1107 ruleExactMultiplicity
1107{ after(grammarAccess.getGlobalRelationInterpretationRule()); } 1108{ after(grammarAccess.getExactMultiplicityRule()); }
1108 EOF 1109 EOF
1109; 1110;
1110 1111
1111// Rule GlobalRelationInterpretation 1112// Rule ExactMultiplicity
1112ruleGlobalRelationInterpretation 1113ruleExactMultiplicity
1113 @init { 1114 @init {
1114 int stackSize = keepStackSize(); 1115 int stackSize = keepStackSize();
1115 } 1116 }
1116 : 1117 :
1117 ( 1118 (
1118 { before(grammarAccess.getGlobalRelationInterpretationAccess().getGroup()); } 1119 { before(grammarAccess.getExactMultiplicityAccess().getGroup()); }
1119 (rule__GlobalRelationInterpretation__Group__0) 1120 (rule__ExactMultiplicity__Group__0)
1120 { after(grammarAccess.getGlobalRelationInterpretationAccess().getGroup()); } 1121 { after(grammarAccess.getExactMultiplicityAccess().getGroup()); }
1121 ) 1122 )
1122; 1123;
1123finally { 1124finally {
1124 restoreStackSize(stackSize); 1125 restoreStackSize(stackSize);
1125} 1126}
1126 1127
1127// Entry rule entryRuleMultiplicityDefinition 1128// Entry rule entryRuleBoundedMultiplicity
1128entryRuleMultiplicityDefinition 1129entryRuleBoundedMultiplicity
1129: 1130:
1130{ before(grammarAccess.getMultiplicityDefinitionRule()); } 1131{ before(grammarAccess.getBoundedMultiplicityRule()); }
1131 ruleMultiplicityDefinition 1132 ruleBoundedMultiplicity
1132{ after(grammarAccess.getMultiplicityDefinitionRule()); } 1133{ after(grammarAccess.getBoundedMultiplicityRule()); }
1133 EOF 1134 EOF
1134; 1135;
1135 1136
1136// Rule MultiplicityDefinition 1137// Rule BoundedMultiplicity
1137ruleMultiplicityDefinition 1138ruleBoundedMultiplicity
1138 @init { 1139 @init {
1139 int stackSize = keepStackSize(); 1140 int stackSize = keepStackSize();
1140 } 1141 }
1141 : 1142 :
1142 ( 1143 (
1143 { before(grammarAccess.getMultiplicityDefinitionAccess().getGroup()); } 1144 { before(grammarAccess.getBoundedMultiplicityAccess().getGroup()); }
1144 (rule__MultiplicityDefinition__Group__0) 1145 (rule__BoundedMultiplicity__Group__0)
1145 { after(grammarAccess.getMultiplicityDefinitionAccess().getGroup()); } 1146 { after(grammarAccess.getBoundedMultiplicityAccess().getGroup()); }
1147 )
1148;
1149finally {
1150 restoreStackSize(stackSize);
1151}
1152
1153// Entry rule entryRuleScopeDefinition
1154entryRuleScopeDefinition
1155:
1156{ before(grammarAccess.getScopeDefinitionRule()); }
1157 ruleScopeDefinition
1158{ after(grammarAccess.getScopeDefinitionRule()); }
1159 EOF
1160;
1161
1162// Rule ScopeDefinition
1163ruleScopeDefinition
1164 @init {
1165 int stackSize = keepStackSize();
1166 }
1167 :
1168 (
1169 { before(grammarAccess.getScopeDefinitionAccess().getAlternatives()); }
1170 (rule__ScopeDefinition__Alternatives)
1171 { after(grammarAccess.getScopeDefinitionAccess().getAlternatives()); }
1172 )
1173;
1174finally {
1175 restoreStackSize(stackSize);
1176}
1177
1178// Entry rule entryRuleExactScopeDefinition
1179entryRuleExactScopeDefinition
1180:
1181{ before(grammarAccess.getExactScopeDefinitionRule()); }
1182 ruleExactScopeDefinition
1183{ after(grammarAccess.getExactScopeDefinitionRule()); }
1184 EOF
1185;
1186
1187// Rule ExactScopeDefinition
1188ruleExactScopeDefinition
1189 @init {
1190 int stackSize = keepStackSize();
1191 }
1192 :
1193 (
1194 { before(grammarAccess.getExactScopeDefinitionAccess().getGroup()); }
1195 (rule__ExactScopeDefinition__Group__0)
1196 { after(grammarAccess.getExactScopeDefinitionAccess().getGroup()); }
1197 )
1198;
1199finally {
1200 restoreStackSize(stackSize);
1201}
1202
1203// Entry rule entryRuleBoundedScopeDefinition
1204entryRuleBoundedScopeDefinition
1205:
1206{ before(grammarAccess.getBoundedScopeDefinitionRule()); }
1207 ruleBoundedScopeDefinition
1208{ after(grammarAccess.getBoundedScopeDefinitionRule()); }
1209 EOF
1210;
1211
1212// Rule BoundedScopeDefinition
1213ruleBoundedScopeDefinition
1214 @init {
1215 int stackSize = keepStackSize();
1216 }
1217 :
1218 (
1219 { before(grammarAccess.getBoundedScopeDefinitionAccess().getGroup()); }
1220 (rule__BoundedScopeDefinition__Group__0)
1221 { after(grammarAccess.getBoundedScopeDefinitionAccess().getGroup()); }
1222 )
1223;
1224finally {
1225 restoreStackSize(stackSize);
1226}
1227
1228// Entry rule entryRuleLowerBoundedScopeDefinition
1229entryRuleLowerBoundedScopeDefinition
1230:
1231{ before(grammarAccess.getLowerBoundedScopeDefinitionRule()); }
1232 ruleLowerBoundedScopeDefinition
1233{ after(grammarAccess.getLowerBoundedScopeDefinitionRule()); }
1234 EOF
1235;
1236
1237// Rule LowerBoundedScopeDefinition
1238ruleLowerBoundedScopeDefinition
1239 @init {
1240 int stackSize = keepStackSize();
1241 }
1242 :
1243 (
1244 { before(grammarAccess.getLowerBoundedScopeDefinitionAccess().getGroup()); }
1245 (rule__LowerBoundedScopeDefinition__Group__0)
1246 { after(grammarAccess.getLowerBoundedScopeDefinitionAccess().getGroup()); }
1247 )
1248;
1249finally {
1250 restoreStackSize(stackSize);
1251}
1252
1253// Entry rule entryRuleObjectiveDefinition
1254entryRuleObjectiveDefinition
1255:
1256{ before(grammarAccess.getObjectiveDefinitionRule()); }
1257 ruleObjectiveDefinition
1258{ after(grammarAccess.getObjectiveDefinitionRule()); }
1259 EOF
1260;
1261
1262// Rule ObjectiveDefinition
1263ruleObjectiveDefinition
1264 @init {
1265 int stackSize = keepStackSize();
1266 }
1267 :
1268 (
1269 { before(grammarAccess.getObjectiveDefinitionAccess().getGroup()); }
1270 (rule__ObjectiveDefinition__Group__0)
1271 { after(grammarAccess.getObjectiveDefinitionAccess().getGroup()); }
1272 )
1273;
1274finally {
1275 restoreStackSize(stackSize);
1276}
1277
1278// Entry rule entryRuleUpperMultiplicty
1279entryRuleUpperMultiplicty
1280:
1281{ before(grammarAccess.getUpperMultiplictyRule()); }
1282 ruleUpperMultiplicty
1283{ after(grammarAccess.getUpperMultiplictyRule()); }
1284 EOF
1285;
1286
1287// Rule UpperMultiplicty
1288ruleUpperMultiplicty
1289 @init {
1290 int stackSize = keepStackSize();
1291 }
1292 :
1293 (
1294 { before(grammarAccess.getUpperMultiplictyAccess().getAlternatives()); }
1295 (rule__UpperMultiplicty__Alternatives)
1296 { after(grammarAccess.getUpperMultiplictyAccess().getAlternatives()); }
1297 )
1298;
1299finally {
1300 restoreStackSize(stackSize);
1301}
1302
1303// Entry rule entryRuleReal
1304entryRuleReal
1305@init {
1306 HiddenTokens myHiddenTokenState = ((XtextTokenStream)input).setHiddenTokens();
1307}
1308:
1309{ before(grammarAccess.getRealRule()); }
1310 ruleReal
1311{ after(grammarAccess.getRealRule()); }
1312 EOF
1313;
1314finally {
1315 myHiddenTokenState.restore();
1316}
1317
1318// Rule Real
1319ruleReal
1320 @init {
1321 HiddenTokens myHiddenTokenState = ((XtextTokenStream)input).setHiddenTokens();
1322 int stackSize = keepStackSize();
1323 }
1324 :
1325 (
1326 { before(grammarAccess.getRealAccess().getGroup()); }
1327 (rule__Real__Group__0)
1328 { after(grammarAccess.getRealAccess().getGroup()); }
1329 )
1330;
1331finally {
1332 restoreStackSize(stackSize);
1333 myHiddenTokenState.restore();
1334}
1335
1336// Entry rule entryRuleQualifiedName
1337entryRuleQualifiedName
1338@init {
1339 HiddenTokens myHiddenTokenState = ((XtextTokenStream)input).setHiddenTokens();
1340}
1341:
1342{ before(grammarAccess.getQualifiedNameRule()); }
1343 ruleQualifiedName
1344{ after(grammarAccess.getQualifiedNameRule()); }
1345 EOF
1346;
1347finally {
1348 myHiddenTokenState.restore();
1349}
1350
1351// Rule QualifiedName
1352ruleQualifiedName
1353 @init {
1354 HiddenTokens myHiddenTokenState = ((XtextTokenStream)input).setHiddenTokens();
1355 int stackSize = keepStackSize();
1356 }
1357 :
1358 (
1359 { before(grammarAccess.getQualifiedNameAccess().getAlternatives()); }
1360 (rule__QualifiedName__Alternatives)
1361 { after(grammarAccess.getQualifiedNameAccess().getAlternatives()); }
1362 )
1363;
1364finally {
1365 restoreStackSize(stackSize);
1366 myHiddenTokenState.restore();
1367}
1368
1369// Rule MetricType
1370ruleMetricType
1371 @init {
1372 int stackSize = keepStackSize();
1373 }
1374:
1375 (
1376 { before(grammarAccess.getMetricTypeAccess().getAlternatives()); }
1377 (rule__MetricType__Alternatives)
1378 { after(grammarAccess.getMetricTypeAccess().getAlternatives()); }
1146 ) 1379 )
1147; 1380;
1148finally { 1381finally {
1149 restoreStackSize(stackSize); 1382 restoreStackSize(stackSize);
1150} 1383}
1151 1384
1152rule__Statement__Alternatives 1385// Rule ComparisonOperator
1386ruleComparisonOperator
1153 @init { 1387 @init {
1154 int stackSize = keepStackSize(); 1388 int stackSize = keepStackSize();
1155 } 1389 }
1156: 1390:
1157 ( 1391 (
1158 { before(grammarAccess.getStatementAccess().getInterpretationParserRuleCall_0()); } 1392 { before(grammarAccess.getComparisonOperatorAccess().getAlternatives()); }
1159 ruleInterpretation 1393 (rule__ComparisonOperator__Alternatives)
1160 { after(grammarAccess.getStatementAccess().getInterpretationParserRuleCall_0()); } 1394 { after(grammarAccess.getComparisonOperatorAccess().getAlternatives()); }
1395 )
1396;
1397finally {
1398 restoreStackSize(stackSize);
1399}
1400
1401// Rule AdditiveBinaryOperator
1402ruleAdditiveBinaryOperator
1403 @init {
1404 int stackSize = keepStackSize();
1405 }
1406:
1407 (
1408 { before(grammarAccess.getAdditiveBinaryOperatorAccess().getAlternatives()); }
1409 (rule__AdditiveBinaryOperator__Alternatives)
1410 { after(grammarAccess.getAdditiveBinaryOperatorAccess().getAlternatives()); }
1411 )
1412;
1413finally {
1414 restoreStackSize(stackSize);
1415}
1416
1417// Rule MultiplicativeBinaryOperator
1418ruleMultiplicativeBinaryOperator
1419 @init {
1420 int stackSize = keepStackSize();
1421 }
1422:
1423 (
1424 { before(grammarAccess.getMultiplicativeBinaryOperatorAccess().getAlternatives()); }
1425 (rule__MultiplicativeBinaryOperator__Alternatives)
1426 { after(grammarAccess.getMultiplicativeBinaryOperatorAccess().getAlternatives()); }
1427 )
1428;
1429finally {
1430 restoreStackSize(stackSize);
1431}
1432
1433// Rule ExponentialOp
1434ruleExponentialOp
1435 @init {
1436 int stackSize = keepStackSize();
1437 }
1438:
1439 (
1440 { before(grammarAccess.getExponentialOpAccess().getPOWEnumLiteralDeclaration()); }
1441 ('^')
1442 { after(grammarAccess.getExponentialOpAccess().getPOWEnumLiteralDeclaration()); }
1443 )
1444;
1445finally {
1446 restoreStackSize(stackSize);
1447}
1448
1449// Rule UnaryOp
1450ruleUnaryOp
1451 @init {
1452 int stackSize = keepStackSize();
1453 }
1454:
1455 (
1456 { before(grammarAccess.getUnaryOpAccess().getAlternatives()); }
1457 (rule__UnaryOp__Alternatives)
1458 { after(grammarAccess.getUnaryOpAccess().getAlternatives()); }
1459 )
1460;
1461finally {
1462 restoreStackSize(stackSize);
1463}
1464
1465// Rule AggregationOp
1466ruleAggregationOp
1467 @init {
1468 int stackSize = keepStackSize();
1469 }
1470:
1471 (
1472 { before(grammarAccess.getAggregationOpAccess().getAlternatives()); }
1473 (rule__AggregationOp__Alternatives)
1474 { after(grammarAccess.getAggregationOpAccess().getAlternatives()); }
1475 )
1476;
1477finally {
1478 restoreStackSize(stackSize);
1479}
1480
1481// Rule LogicValue
1482ruleLogicValue
1483 @init {
1484 int stackSize = keepStackSize();
1485 }
1486:
1487 (
1488 { before(grammarAccess.getLogicValueAccess().getAlternatives()); }
1489 (rule__LogicValue__Alternatives)
1490 { after(grammarAccess.getLogicValueAccess().getAlternatives()); }
1491 )
1492;
1493finally {
1494 restoreStackSize(stackSize);
1495}
1496
1497// Rule ObjectiveKind
1498ruleObjectiveKind
1499 @init {
1500 int stackSize = keepStackSize();
1501 }
1502:
1503 (
1504 { before(grammarAccess.getObjectiveKindAccess().getAlternatives()); }
1505 (rule__ObjectiveKind__Alternatives)
1506 { after(grammarAccess.getObjectiveKindAccess().getAlternatives()); }
1507 )
1508;
1509finally {
1510 restoreStackSize(stackSize);
1511}
1512
1513rule__Statement__Alternatives_0
1514 @init {
1515 int stackSize = keepStackSize();
1516 }
1517:
1518 (
1519 { before(grammarAccess.getStatementAccess().getAssertionOrDefinitionParserRuleCall_0_0()); }
1520 ruleAssertionOrDefinition
1521 { after(grammarAccess.getStatementAccess().getAssertionOrDefinitionParserRuleCall_0_0()); }
1522 )
1523 |
1524 (
1525 { before(grammarAccess.getStatementAccess().getPredicateDefinitionParserRuleCall_0_1()); }
1526 rulePredicateDefinition
1527 { after(grammarAccess.getStatementAccess().getPredicateDefinitionParserRuleCall_0_1()); }
1528 )
1529 |
1530 (
1531 { before(grammarAccess.getStatementAccess().getUnnamedErrorPrediateDefinitionParserRuleCall_0_2()); }
1532 ruleUnnamedErrorPrediateDefinition
1533 { after(grammarAccess.getStatementAccess().getUnnamedErrorPrediateDefinitionParserRuleCall_0_2()); }
1534 )
1535 |
1536 (
1537 { before(grammarAccess.getStatementAccess().getDefaultDefinitionParserRuleCall_0_3()); }
1538 ruleDefaultDefinition
1539 { after(grammarAccess.getStatementAccess().getDefaultDefinitionParserRuleCall_0_3()); }
1540 )
1541 |
1542 (
1543 { before(grammarAccess.getStatementAccess().getExternPredicateDefinitionParserRuleCall_0_4()); }
1544 ruleExternPredicateDefinition
1545 { after(grammarAccess.getStatementAccess().getExternPredicateDefinitionParserRuleCall_0_4()); }
1546 )
1547 |
1548 (
1549 { before(grammarAccess.getStatementAccess().getMetricDefinitionParserRuleCall_0_5()); }
1550 ruleMetricDefinition
1551 { after(grammarAccess.getStatementAccess().getMetricDefinitionParserRuleCall_0_5()); }
1552 )
1553 |
1554 (
1555 { before(grammarAccess.getStatementAccess().getExternMetricDefinitionParserRuleCall_0_6()); }
1556 ruleExternMetricDefinition
1557 { after(grammarAccess.getStatementAccess().getExternMetricDefinitionParserRuleCall_0_6()); }
1558 )
1559 |
1560 (
1561 { before(grammarAccess.getStatementAccess().getClassDefinitionParserRuleCall_0_7()); }
1562 ruleClassDefinition
1563 { after(grammarAccess.getStatementAccess().getClassDefinitionParserRuleCall_0_7()); }
1564 )
1565 |
1566 (
1567 { before(grammarAccess.getStatementAccess().getScopeDefinitionParserRuleCall_0_8()); }
1568 ruleScopeDefinition
1569 { after(grammarAccess.getStatementAccess().getScopeDefinitionParserRuleCall_0_8()); }
1570 )
1571 |
1572 (
1573 { before(grammarAccess.getStatementAccess().getObjectiveDefinitionParserRuleCall_0_9()); }
1574 ruleObjectiveDefinition
1575 { after(grammarAccess.getStatementAccess().getObjectiveDefinitionParserRuleCall_0_9()); }
1576 )
1577;
1578finally {
1579 restoreStackSize(stackSize);
1580}
1581
1582rule__AssertionOrDefinition__Alternatives_1
1583 @init {
1584 int stackSize = keepStackSize();
1585 }
1586:
1587 (
1588 { before(grammarAccess.getAssertionOrDefinitionAccess().getGroup_1_0()); }
1589 (rule__AssertionOrDefinition__Group_1_0__0)
1590 { after(grammarAccess.getAssertionOrDefinitionAccess().getGroup_1_0()); }
1591 )
1592 |
1593 (
1594 { before(grammarAccess.getAssertionOrDefinitionAccess().getGroup_1_1()); }
1595 (rule__AssertionOrDefinition__Group_1_1__0)
1596 { after(grammarAccess.getAssertionOrDefinitionAccess().getGroup_1_1()); }
1161 ) 1597 )
1162 | 1598 |
1163 ( 1599 (
1164 { before(grammarAccess.getStatementAccess().getPredicateParserRuleCall_1()); } 1600 { before(grammarAccess.getAssertionOrDefinitionAccess().getGroup_1_2()); }
1165 rulePredicate 1601 (rule__AssertionOrDefinition__Group_1_2__0)
1166 { after(grammarAccess.getStatementAccess().getPredicateParserRuleCall_1()); } 1602 { after(grammarAccess.getAssertionOrDefinitionAccess().getGroup_1_2()); }
1167 ) 1603 )
1168; 1604;
1169finally { 1605finally {
1170 restoreStackSize(stackSize); 1606 restoreStackSize(stackSize);
1171} 1607}
1172 1608
1173rule__BooleanValue__Alternatives 1609rule__PredicateDefinition__Alternatives_0
1174 @init { 1610 @init {
1175 int stackSize = keepStackSize(); 1611 int stackSize = keepStackSize();
1176 } 1612 }
1177: 1613:
1178 ( 1614 (
1179 { before(grammarAccess.getBooleanValueAccess().getGroup_0()); } 1615 { before(grammarAccess.getPredicateDefinitionAccess().getGroup_0_0()); }
1180 (rule__BooleanValue__Group_0__0) 1616 (rule__PredicateDefinition__Group_0_0__0)
1181 { after(grammarAccess.getBooleanValueAccess().getGroup_0()); } 1617 { after(grammarAccess.getPredicateDefinitionAccess().getGroup_0_0()); }
1182 ) 1618 )
1183 | 1619 |
1184 ( 1620 (
1185 { before(grammarAccess.getBooleanValueAccess().getGroup_1()); } 1621 { before(grammarAccess.getPredicateDefinitionAccess().getGroup_0_1()); }
1186 (rule__BooleanValue__Group_1__0) 1622 (rule__PredicateDefinition__Group_0_1__0)
1187 { after(grammarAccess.getBooleanValueAccess().getGroup_1()); } 1623 { after(grammarAccess.getPredicateDefinitionAccess().getGroup_0_1()); }
1188 ) 1624 )
1189; 1625;
1190finally { 1626finally {
1191 restoreStackSize(stackSize); 1627 restoreStackSize(stackSize);
1192} 1628}
1193 1629
1194rule__TruthValue__Alternatives 1630rule__Expression__Alternatives
1195 @init { 1631 @init {
1196 int stackSize = keepStackSize(); 1632 int stackSize = keepStackSize();
1197 } 1633 }
1198: 1634:
1199 ( 1635 (
1200 { before(grammarAccess.getTruthValueAccess().getGroup_0()); } 1636 { before(grammarAccess.getExpressionAccess().getIfElseParserRuleCall_0()); }
1201 (rule__TruthValue__Group_0__0) 1637 ruleIfElse
1202 { after(grammarAccess.getTruthValueAccess().getGroup_0()); } 1638 { after(grammarAccess.getExpressionAccess().getIfElseParserRuleCall_0()); }
1203 ) 1639 )
1204 | 1640 |
1205 ( 1641 (
1206 { before(grammarAccess.getTruthValueAccess().getGroup_1()); } 1642 { before(grammarAccess.getExpressionAccess().getDisjunctiveExpressionParserRuleCall_1()); }
1207 (rule__TruthValue__Group_1__0) 1643 ruleDisjunctiveExpression
1208 { after(grammarAccess.getTruthValueAccess().getGroup_1()); } 1644 { after(grammarAccess.getExpressionAccess().getDisjunctiveExpressionParserRuleCall_1()); }
1645 )
1646;
1647finally {
1648 restoreStackSize(stackSize);
1649}
1650
1651rule__DisjunctiveExpression__Alternatives_1
1652 @init {
1653 int stackSize = keepStackSize();
1654 }
1655:
1656 (
1657 { before(grammarAccess.getDisjunctiveExpressionAccess().getGroup_1_0()); }
1658 (rule__DisjunctiveExpression__Group_1_0__0)
1659 { after(grammarAccess.getDisjunctiveExpressionAccess().getGroup_1_0()); }
1209 ) 1660 )
1210 | 1661 |
1211 ( 1662 (
1212 { before(grammarAccess.getTruthValueAccess().getGroup_2()); } 1663 { before(grammarAccess.getDisjunctiveExpressionAccess().getGroup_1_1()); }
1213 (rule__TruthValue__Group_2__0) 1664 (rule__DisjunctiveExpression__Group_1_1__0)
1214 { after(grammarAccess.getTruthValueAccess().getGroup_2()); } 1665 { after(grammarAccess.getDisjunctiveExpressionAccess().getGroup_1_1()); }
1666 )
1667;
1668finally {
1669 restoreStackSize(stackSize);
1670}
1671
1672rule__UnaryExpression__Alternatives
1673 @init {
1674 int stackSize = keepStackSize();
1675 }
1676:
1677 (
1678 { before(grammarAccess.getUnaryExpressionAccess().getAggregationExpressionParserRuleCall_0()); }
1679 ruleAggregationExpression
1680 { after(grammarAccess.getUnaryExpressionAccess().getAggregationExpressionParserRuleCall_0()); }
1215 ) 1681 )
1216 | 1682 |
1217 ( 1683 (
1218 { before(grammarAccess.getTruthValueAccess().getGroup_3()); } 1684 { before(grammarAccess.getUnaryExpressionAccess().getGroup_1()); }
1219 (rule__TruthValue__Group_3__0) 1685 (rule__UnaryExpression__Group_1__0)
1220 { after(grammarAccess.getTruthValueAccess().getGroup_3()); } 1686 { after(grammarAccess.getUnaryExpressionAccess().getGroup_1()); }
1221 ) 1687 )
1222; 1688;
1223finally { 1689finally {
1224 restoreStackSize(stackSize); 1690 restoreStackSize(stackSize);
1225} 1691}
1226 1692
1227rule__Interpretation__Alternatives 1693rule__AggregationExpression__Alternatives
1228 @init { 1694 @init {
1229 int stackSize = keepStackSize(); 1695 int stackSize = keepStackSize();
1230 } 1696 }
1231: 1697:
1232 ( 1698 (
1233 { before(grammarAccess.getInterpretationAccess().getBasicInterpretationParserRuleCall_0()); } 1699 { before(grammarAccess.getAggregationExpressionAccess().getAtomicExpressionParserRuleCall_0()); }
1234 ruleBasicInterpretation 1700 ruleAtomicExpression
1235 { after(grammarAccess.getInterpretationAccess().getBasicInterpretationParserRuleCall_0()); } 1701 { after(grammarAccess.getAggregationExpressionAccess().getAtomicExpressionParserRuleCall_0()); }
1236 ) 1702 )
1237 | 1703 |
1238 ( 1704 (
1239 { before(grammarAccess.getInterpretationAccess().getDefaultInterpretationParserRuleCall_1()); } 1705 { before(grammarAccess.getAggregationExpressionAccess().getCountParserRuleCall_1()); }
1240 ruleDefaultInterpretation 1706 ruleCount
1241 { after(grammarAccess.getInterpretationAccess().getDefaultInterpretationParserRuleCall_1()); } 1707 { after(grammarAccess.getAggregationExpressionAccess().getCountParserRuleCall_1()); }
1242 ) 1708 )
1243 | 1709 |
1244 ( 1710 (
1245 { before(grammarAccess.getInterpretationAccess().getCDInterpretationParserRuleCall_2()); } 1711 { before(grammarAccess.getAggregationExpressionAccess().getAggregationParserRuleCall_2()); }
1246 ruleCDInterpretation 1712 ruleAggregation
1247 { after(grammarAccess.getInterpretationAccess().getCDInterpretationParserRuleCall_2()); } 1713 { after(grammarAccess.getAggregationExpressionAccess().getAggregationParserRuleCall_2()); }
1248 ) 1714 )
1249; 1715;
1250finally { 1716finally {
1251 restoreStackSize(stackSize); 1717 restoreStackSize(stackSize);
1252} 1718}
1253 1719
1254rule__Symbol__Alternatives 1720rule__AtomicExpression__Alternatives
1255 @init { 1721 @init {
1256 int stackSize = keepStackSize(); 1722 int stackSize = keepStackSize();
1257 } 1723 }
1258: 1724:
1259 ( 1725 (
1260 { before(grammarAccess.getSymbolAccess().getModelSymbolParserRuleCall_0()); } 1726 { before(grammarAccess.getAtomicExpressionAccess().getGroup_0()); }
1261 ruleModelSymbol 1727 (rule__AtomicExpression__Group_0__0)
1262 { after(grammarAccess.getSymbolAccess().getModelSymbolParserRuleCall_0()); } 1728 { after(grammarAccess.getAtomicExpressionAccess().getGroup_0()); }
1263 ) 1729 )
1264 | 1730 |
1265 ( 1731 (
1266 { before(grammarAccess.getSymbolAccess().getPartialitySymbolParserRuleCall_1()); } 1732 { before(grammarAccess.getAtomicExpressionAccess().getIntervalParserRuleCall_1()); }
1267 rulePartialitySymbol 1733 ruleInterval
1268 { after(grammarAccess.getSymbolAccess().getPartialitySymbolParserRuleCall_1()); } 1734 { after(grammarAccess.getAtomicExpressionAccess().getIntervalParserRuleCall_1()); }
1269 ) 1735 )
1270 | 1736 |
1271 ( 1737 (
1272 { before(grammarAccess.getSymbolAccess().getDataSymbolParserRuleCall_2()); } 1738 { before(grammarAccess.getAtomicExpressionAccess().getLiteralParserRuleCall_2()); }
1273 ruleDataSymbol 1739 ruleLiteral
1274 { after(grammarAccess.getSymbolAccess().getDataSymbolParserRuleCall_2()); } 1740 { after(grammarAccess.getAtomicExpressionAccess().getLiteralParserRuleCall_2()); }
1741 )
1742 |
1743 (
1744 { before(grammarAccess.getAtomicExpressionAccess().getGroup_3()); }
1745 (rule__AtomicExpression__Group_3__0)
1746 { after(grammarAccess.getAtomicExpressionAccess().getGroup_3()); }
1275 ) 1747 )
1276; 1748;
1277finally { 1749finally {
1278 restoreStackSize(stackSize); 1750 restoreStackSize(stackSize);
1279} 1751}
1280 1752
1281rule__PartialitySymbol__Alternatives 1753rule__Call__Alternatives_1
1282 @init { 1754 @init {
1283 int stackSize = keepStackSize(); 1755 int stackSize = keepStackSize();
1284 } 1756 }
1285: 1757:
1286 ( 1758 (
1287 { before(grammarAccess.getPartialitySymbolAccess().getExistSymbolParserRuleCall_0()); } 1759 { before(grammarAccess.getCallAccess().getTransitiveClosureAssignment_1_0()); }
1288 ruleExistSymbol 1760 (rule__Call__TransitiveClosureAssignment_1_0)
1289 { after(grammarAccess.getPartialitySymbolAccess().getExistSymbolParserRuleCall_0()); } 1761 { after(grammarAccess.getCallAccess().getTransitiveClosureAssignment_1_0()); }
1290 ) 1762 )
1291 | 1763 |
1292 ( 1764 (
1293 { before(grammarAccess.getPartialitySymbolAccess().getEqualsSymbolParserRuleCall_1()); } 1765 { before(grammarAccess.getCallAccess().getReflexiveTransitiveClosureAssignment_1_1()); }
1294 ruleEqualsSymbol 1766 (rule__Call__ReflexiveTransitiveClosureAssignment_1_1)
1295 { after(grammarAccess.getPartialitySymbolAccess().getEqualsSymbolParserRuleCall_1()); } 1767 { after(grammarAccess.getCallAccess().getReflexiveTransitiveClosureAssignment_1_1()); }
1296 ) 1768 )
1297; 1769;
1298finally { 1770finally {
1299 restoreStackSize(stackSize); 1771 restoreStackSize(stackSize);
1300} 1772}
1301 1773
1302rule__DataSymbol__Alternatives 1774rule__Argument__Alternatives
1303 @init { 1775 @init {
1304 int stackSize = keepStackSize(); 1776 int stackSize = keepStackSize();
1305 } 1777 }
1306: 1778:
1307 ( 1779 (
1308 { before(grammarAccess.getDataSymbolAccess().getBooleanSymbolParserRuleCall_0()); } 1780 { before(grammarAccess.getArgumentAccess().getExpressionArgumentParserRuleCall_0()); }
1309 ruleBooleanSymbol 1781 ruleExpressionArgument
1310 { after(grammarAccess.getDataSymbolAccess().getBooleanSymbolParserRuleCall_0()); } 1782 { after(grammarAccess.getArgumentAccess().getExpressionArgumentParserRuleCall_0()); }
1311 ) 1783 )
1312 | 1784 |
1313 ( 1785 (
1314 { before(grammarAccess.getDataSymbolAccess().getIntegerSymbolParserRuleCall_1()); } 1786 { before(grammarAccess.getArgumentAccess().getStarArgumentParserRuleCall_1()); }
1315 ruleIntegerSymbol 1787 ruleStarArgument
1316 { after(grammarAccess.getDataSymbolAccess().getIntegerSymbolParserRuleCall_1()); } 1788 { after(grammarAccess.getArgumentAccess().getStarArgumentParserRuleCall_1()); }
1317 ) 1789 )
1318 | 1790 |
1319 ( 1791 (
1320 { before(grammarAccess.getDataSymbolAccess().getRealSymbolParserRuleCall_2()); } 1792 { before(grammarAccess.getArgumentAccess().getTypedArgumentParserRuleCall_2()); }
1321 ruleRealSymbol 1793 ruleTypedArgument
1322 { after(grammarAccess.getDataSymbolAccess().getRealSymbolParserRuleCall_2()); } 1794 { after(grammarAccess.getArgumentAccess().getTypedArgumentParserRuleCall_2()); }
1323 ) 1795 )
1324 | 1796 |
1325 ( 1797 (
1326 { before(grammarAccess.getDataSymbolAccess().getStringSymbolParserRuleCall_3()); } 1798 { before(grammarAccess.getArgumentAccess().getTypedStarArgumentParserRuleCall_3()); }
1327 ruleStringSymbol 1799 ruleTypedStarArgument
1328 { after(grammarAccess.getDataSymbolAccess().getStringSymbolParserRuleCall_3()); } 1800 { after(grammarAccess.getArgumentAccess().getTypedStarArgumentParserRuleCall_3()); }
1329 ) 1801 )
1330; 1802;
1331finally { 1803finally {
1332 restoreStackSize(stackSize); 1804 restoreStackSize(stackSize);
1333} 1805}
1334 1806
1335rule__ComplexObject__Alternatives 1807rule__Literal__Alternatives
1336 @init { 1808 @init {
1337 int stackSize = keepStackSize(); 1809 int stackSize = keepStackSize();
1338 } 1810 }
1339: 1811:
1340 ( 1812 (
1341 { before(grammarAccess.getComplexObjectAccess().getObjectParserRuleCall_0()); } 1813 { before(grammarAccess.getLiteralAccess().getLogicLiteralParserRuleCall_0()); }
1342 ruleObject 1814 ruleLogicLiteral
1343 { after(grammarAccess.getComplexObjectAccess().getObjectParserRuleCall_0()); } 1815 { after(grammarAccess.getLiteralAccess().getLogicLiteralParserRuleCall_0()); }
1344 ) 1816 )
1345 | 1817 |
1346 ( 1818 (
1347 { before(grammarAccess.getComplexObjectAccess().getAllInstancesParserRuleCall_1()); } 1819 { before(grammarAccess.getLiteralAccess().getNumericLiteralParserRuleCall_1()); }
1348 ruleAllInstances 1820 ruleNumericLiteral
1349 { after(grammarAccess.getComplexObjectAccess().getAllInstancesParserRuleCall_1()); } 1821 { after(grammarAccess.getLiteralAccess().getNumericLiteralParserRuleCall_1()); }
1350 ) 1822 )
1351 | 1823 |
1352 ( 1824 (
1353 { before(grammarAccess.getComplexObjectAccess().getAllObjectsParserRuleCall_2()); } 1825 { before(grammarAccess.getLiteralAccess().getInfinityLiteralParserRuleCall_2()); }
1354 ruleAllObjects 1826 ruleInfinityLiteral
1355 { after(grammarAccess.getComplexObjectAccess().getAllObjectsParserRuleCall_2()); } 1827 { after(grammarAccess.getLiteralAccess().getInfinityLiteralParserRuleCall_2()); }
1828 )
1829 |
1830 (
1831 { before(grammarAccess.getLiteralAccess().getEmptyIntervalLiteralParserRuleCall_3()); }
1832 ruleEmptyIntervalLiteral
1833 { after(grammarAccess.getLiteralAccess().getEmptyIntervalLiteralParserRuleCall_3()); }
1834 )
1835 |
1836 (
1837 { before(grammarAccess.getLiteralAccess().getStringLiteralParserRuleCall_4()); }
1838 ruleStringLiteral
1839 { after(grammarAccess.getLiteralAccess().getStringLiteralParserRuleCall_4()); }
1356 ) 1840 )
1357; 1841;
1358finally { 1842finally {
1359 restoreStackSize(stackSize); 1843 restoreStackSize(stackSize);
1360} 1844}
1361 1845
1362rule__Object__Alternatives 1846rule__Multiplicity__Alternatives
1363 @init { 1847 @init {
1364 int stackSize = keepStackSize(); 1848 int stackSize = keepStackSize();
1365 } 1849 }
1366: 1850:
1367 ( 1851 (
1368 { before(grammarAccess.getObjectAccess().getNamedObjectParserRuleCall_0()); } 1852 { before(grammarAccess.getMultiplicityAccess().getManyMultiplicityParserRuleCall_0()); }
1369 ruleNamedObject 1853 ruleManyMultiplicity
1370 { after(grammarAccess.getObjectAccess().getNamedObjectParserRuleCall_0()); } 1854 { after(grammarAccess.getMultiplicityAccess().getManyMultiplicityParserRuleCall_0()); }
1371 ) 1855 )
1372 | 1856 |
1373 ( 1857 (
1374 { before(grammarAccess.getObjectAccess().getUnnamedObjectParserRuleCall_1()); } 1858 { before(grammarAccess.getMultiplicityAccess().getExactMultiplicityParserRuleCall_1()); }
1375 ruleUnnamedObject 1859 ruleExactMultiplicity
1376 { after(grammarAccess.getObjectAccess().getUnnamedObjectParserRuleCall_1()); } 1860 { after(grammarAccess.getMultiplicityAccess().getExactMultiplicityParserRuleCall_1()); }
1377 ) 1861 )
1378 | 1862 |
1379 ( 1863 (
1380 { before(grammarAccess.getObjectAccess().getDataObjectParserRuleCall_2()); } 1864 { before(grammarAccess.getMultiplicityAccess().getBoundedMultiplicityParserRuleCall_2()); }
1381 ruleDataObject 1865 ruleBoundedMultiplicity
1382 { after(grammarAccess.getObjectAccess().getDataObjectParserRuleCall_2()); } 1866 { after(grammarAccess.getMultiplicityAccess().getBoundedMultiplicityParserRuleCall_2()); }
1383 ) 1867 )
1384; 1868;
1385finally { 1869finally {
1386 restoreStackSize(stackSize); 1870 restoreStackSize(stackSize);
1387} 1871}
1388 1872
1389rule__DataObject__Alternatives 1873rule__ScopeDefinition__Alternatives
1390 @init { 1874 @init {
1391 int stackSize = keepStackSize(); 1875 int stackSize = keepStackSize();
1392 } 1876 }
1393: 1877:
1394 ( 1878 (
1395 { before(grammarAccess.getDataObjectAccess().getBooleanObjectParserRuleCall_0()); } 1879 { before(grammarAccess.getScopeDefinitionAccess().getExactScopeDefinitionParserRuleCall_0()); }
1396 ruleBooleanObject 1880 ruleExactScopeDefinition
1397 { after(grammarAccess.getDataObjectAccess().getBooleanObjectParserRuleCall_0()); } 1881 { after(grammarAccess.getScopeDefinitionAccess().getExactScopeDefinitionParserRuleCall_0()); }
1398 ) 1882 )
1399 | 1883 |
1400 ( 1884 (
1401 { before(grammarAccess.getDataObjectAccess().getIntObjectParserRuleCall_1()); } 1885 { before(grammarAccess.getScopeDefinitionAccess().getBoundedScopeDefinitionParserRuleCall_1()); }
1402 ruleIntObject 1886 ruleBoundedScopeDefinition
1403 { after(grammarAccess.getDataObjectAccess().getIntObjectParserRuleCall_1()); } 1887 { after(grammarAccess.getScopeDefinitionAccess().getBoundedScopeDefinitionParserRuleCall_1()); }
1404 ) 1888 )
1405 | 1889 |
1406 ( 1890 (
1407 { before(grammarAccess.getDataObjectAccess().getRealObjectParserRuleCall_2()); } 1891 { before(grammarAccess.getScopeDefinitionAccess().getLowerBoundedScopeDefinitionParserRuleCall_2()); }
1408 ruleRealObject 1892 ruleLowerBoundedScopeDefinition
1409 { after(grammarAccess.getDataObjectAccess().getRealObjectParserRuleCall_2()); } 1893 { after(grammarAccess.getScopeDefinitionAccess().getLowerBoundedScopeDefinitionParserRuleCall_2()); }
1894 )
1895;
1896finally {
1897 restoreStackSize(stackSize);
1898}
1899
1900rule__BoundedScopeDefinition__Alternatives_1
1901 @init {
1902 int stackSize = keepStackSize();
1903 }
1904:
1905 (
1906 { before(grammarAccess.getBoundedScopeDefinitionAccess().getGroup_1_0()); }
1907 (rule__BoundedScopeDefinition__Group_1_0__0)
1908 { after(grammarAccess.getBoundedScopeDefinitionAccess().getGroup_1_0()); }
1410 ) 1909 )
1411 | 1910 |
1412 ( 1911 (
1413 { before(grammarAccess.getDataObjectAccess().getStringObjectParserRuleCall_3()); } 1912 { before(grammarAccess.getBoundedScopeDefinitionAccess().getGroup_1_1()); }
1414 ruleStringObject 1913 (rule__BoundedScopeDefinition__Group_1_1__0)
1415 { after(grammarAccess.getDataObjectAccess().getStringObjectParserRuleCall_3()); } 1914 { after(grammarAccess.getBoundedScopeDefinitionAccess().getGroup_1_1()); }
1416 ) 1915 )
1417; 1916;
1418finally { 1917finally {
1419 restoreStackSize(stackSize); 1918 restoreStackSize(stackSize);
1420} 1919}
1421 1920
1422rule__Predicate__Alternatives_4 1921rule__LowerBoundedScopeDefinition__Alternatives_1
1423 @init { 1922 @init {
1424 int stackSize = keepStackSize(); 1923 int stackSize = keepStackSize();
1425 } 1924 }
1426: 1925:
1427 ( 1926 (
1428 { before(grammarAccess.getPredicateAccess().getFalseKeyword_4_0()); } 1927 { before(grammarAccess.getLowerBoundedScopeDefinitionAccess().getGroup_1_0()); }
1429 'false' 1928 (rule__LowerBoundedScopeDefinition__Group_1_0__0)
1430 { after(grammarAccess.getPredicateAccess().getFalseKeyword_4_0()); } 1929 { after(grammarAccess.getLowerBoundedScopeDefinitionAccess().getGroup_1_0()); }
1431 ) 1930 )
1432 | 1931 |
1433 ( 1932 (
1434 { before(grammarAccess.getPredicateAccess().getGroup_4_1()); } 1933 { before(grammarAccess.getLowerBoundedScopeDefinitionAccess().getGroup_1_1()); }
1435 (rule__Predicate__Group_4_1__0) 1934 (rule__LowerBoundedScopeDefinition__Group_1_1__0)
1436 { after(grammarAccess.getPredicateAccess().getGroup_4_1()); } 1935 { after(grammarAccess.getLowerBoundedScopeDefinitionAccess().getGroup_1_1()); }
1437 ) 1936 )
1438; 1937;
1439finally { 1938finally {
1440 restoreStackSize(stackSize); 1939 restoreStackSize(stackSize);
1441} 1940}
1442 1941
1443rule__PatternBody__Alternatives_1 1942rule__UpperMultiplicty__Alternatives
1444 @init { 1943 @init {
1445 int stackSize = keepStackSize(); 1944 int stackSize = keepStackSize();
1446 } 1945 }
1447: 1946:
1448 ( 1947 (
1449 { before(grammarAccess.getPatternBodyAccess().getTrueKeyword_1_0()); } 1948 { before(grammarAccess.getUpperMultiplictyAccess().getINTTerminalRuleCall_0()); }
1450 'true' 1949 RULE_INT
1451 { after(grammarAccess.getPatternBodyAccess().getTrueKeyword_1_0()); } 1950 { after(grammarAccess.getUpperMultiplictyAccess().getINTTerminalRuleCall_0()); }
1452 ) 1951 )
1453 | 1952 |
1454 ( 1953 (
1455 { before(grammarAccess.getPatternBodyAccess().getConstraintsAssignment_1_1()); } 1954 { before(grammarAccess.getUpperMultiplictyAccess().getAsteriskKeyword_1()); }
1456 (rule__PatternBody__ConstraintsAssignment_1_1)* 1955 '*'
1457 { after(grammarAccess.getPatternBodyAccess().getConstraintsAssignment_1_1()); } 1956 { after(grammarAccess.getUpperMultiplictyAccess().getAsteriskKeyword_1()); }
1458 ) 1957 )
1459; 1958;
1460finally { 1959finally {
1461 restoreStackSize(stackSize); 1960 restoreStackSize(stackSize);
1462} 1961}
1463 1962
1464rule__Polarity__Alternatives 1963rule__QualifiedName__Alternatives
1465 @init { 1964 @init {
1466 int stackSize = keepStackSize(); 1965 int stackSize = keepStackSize();
1467 } 1966 }
1468: 1967:
1469 ( 1968 (
1470 { before(grammarAccess.getPolarityAccess().getGroup_0()); } 1969 { before(grammarAccess.getQualifiedNameAccess().getGroup_0()); }
1471 (rule__Polarity__Group_0__0) 1970 (rule__QualifiedName__Group_0__0)
1472 { after(grammarAccess.getPolarityAccess().getGroup_0()); } 1971 { after(grammarAccess.getQualifiedNameAccess().getGroup_0()); }
1473 ) 1972 )
1474 | 1973 |
1475 ( 1974 (
1476 { before(grammarAccess.getPolarityAccess().getGroup_1()); } 1975 { before(grammarAccess.getQualifiedNameAccess().getQUOTED_IDTerminalRuleCall_1()); }
1477 (rule__Polarity__Group_1__0) 1976 RULE_QUOTED_ID
1478 { after(grammarAccess.getPolarityAccess().getGroup_1()); } 1977 { after(grammarAccess.getQualifiedNameAccess().getQUOTED_IDTerminalRuleCall_1()); }
1479 ) 1978 )
1480; 1979;
1481finally { 1980finally {
1482 restoreStackSize(stackSize); 1981 restoreStackSize(stackSize);
1483} 1982}
1484 1983
1485rule__Constraint__Alternatives 1984rule__MetricType__Alternatives
1486 @init { 1985 @init {
1487 int stackSize = keepStackSize(); 1986 int stackSize = keepStackSize();
1488 } 1987 }
1489: 1988:
1490 ( 1989 (
1491 { before(grammarAccess.getConstraintAccess().getGroup_0()); } 1990 { before(grammarAccess.getMetricTypeAccess().getINTEnumLiteralDeclaration_0()); }
1492 (rule__Constraint__Group_0__0) 1991 ('int')
1493 { after(grammarAccess.getConstraintAccess().getGroup_0()); } 1992 { after(grammarAccess.getMetricTypeAccess().getINTEnumLiteralDeclaration_0()); }
1494 ) 1993 )
1495 | 1994 |
1496 ( 1995 (
1497 { before(grammarAccess.getConstraintAccess().getGroup_1()); } 1996 { before(grammarAccess.getMetricTypeAccess().getREALEnumLiteralDeclaration_1()); }
1498 (rule__Constraint__Group_1__0) 1997 ('real')
1499 { after(grammarAccess.getConstraintAccess().getGroup_1()); } 1998 { after(grammarAccess.getMetricTypeAccess().getREALEnumLiteralDeclaration_1()); }
1500 ) 1999 )
1501; 2000;
1502finally { 2001finally {
1503 restoreStackSize(stackSize); 2002 restoreStackSize(stackSize);
1504} 2003}
1505 2004
1506rule__ClosureType__Alternatives 2005rule__ComparisonOperator__Alternatives
1507 @init { 2006 @init {
1508 int stackSize = keepStackSize(); 2007 int stackSize = keepStackSize();
1509 } 2008 }
1510: 2009:
1511 ( 2010 (
1512 { before(grammarAccess.getClosureTypeAccess().getGroup_0()); } 2011 { before(grammarAccess.getComparisonOperatorAccess().getEQEnumLiteralDeclaration_0()); }
1513 (rule__ClosureType__Group_0__0) 2012 ('==')
1514 { after(grammarAccess.getClosureTypeAccess().getGroup_0()); } 2013 { after(grammarAccess.getComparisonOperatorAccess().getEQEnumLiteralDeclaration_0()); }
2014 )
2015 |
2016 (
2017 { before(grammarAccess.getComparisonOperatorAccess().getNOT_EQEnumLiteralDeclaration_1()); }
2018 ('!=')
2019 { after(grammarAccess.getComparisonOperatorAccess().getNOT_EQEnumLiteralDeclaration_1()); }
1515 ) 2020 )
1516 | 2021 |
1517 ( 2022 (
1518 { before(grammarAccess.getClosureTypeAccess().getGroup_1()); } 2023 { before(grammarAccess.getComparisonOperatorAccess().getLESSEnumLiteralDeclaration_2()); }
1519 (rule__ClosureType__Group_1__0) 2024 ('<')
1520 { after(grammarAccess.getClosureTypeAccess().getGroup_1()); } 2025 { after(grammarAccess.getComparisonOperatorAccess().getLESSEnumLiteralDeclaration_2()); }
2026 )
2027 |
2028 (
2029 { before(grammarAccess.getComparisonOperatorAccess().getLESS_EQEnumLiteralDeclaration_3()); }
2030 ('<=')
2031 { after(grammarAccess.getComparisonOperatorAccess().getLESS_EQEnumLiteralDeclaration_3()); }
2032 )
2033 |
2034 (
2035 { before(grammarAccess.getComparisonOperatorAccess().getGREATEREnumLiteralDeclaration_4()); }
2036 ('>')
2037 { after(grammarAccess.getComparisonOperatorAccess().getGREATEREnumLiteralDeclaration_4()); }
2038 )
2039 |
2040 (
2041 { before(grammarAccess.getComparisonOperatorAccess().getGREATER_EQEnumLiteralDeclaration_5()); }
2042 ('>=')
2043 { after(grammarAccess.getComparisonOperatorAccess().getGREATER_EQEnumLiteralDeclaration_5()); }
2044 )
2045 |
2046 (
2047 { before(grammarAccess.getComparisonOperatorAccess().getINEnumLiteralDeclaration_6()); }
2048 ('in')
2049 { after(grammarAccess.getComparisonOperatorAccess().getINEnumLiteralDeclaration_6()); }
1521 ) 2050 )
1522; 2051;
1523finally { 2052finally {
1524 restoreStackSize(stackSize); 2053 restoreStackSize(stackSize);
1525} 2054}
1526 2055
1527rule__Literal__Alternatives 2056rule__AdditiveBinaryOperator__Alternatives
1528 @init { 2057 @init {
1529 int stackSize = keepStackSize(); 2058 int stackSize = keepStackSize();
1530 } 2059 }
1531: 2060:
1532 ( 2061 (
1533 { before(grammarAccess.getLiteralAccess().getVariableParserRuleCall_0()); } 2062 { before(grammarAccess.getAdditiveBinaryOperatorAccess().getADDEnumLiteralDeclaration_0()); }
1534 ruleVariable 2063 ('+')
1535 { after(grammarAccess.getLiteralAccess().getVariableParserRuleCall_0()); } 2064 { after(grammarAccess.getAdditiveBinaryOperatorAccess().getADDEnumLiteralDeclaration_0()); }
1536 ) 2065 )
1537 | 2066 |
1538 ( 2067 (
1539 { before(grammarAccess.getLiteralAccess().getDataObjectParserRuleCall_1()); } 2068 { before(grammarAccess.getAdditiveBinaryOperatorAccess().getSUBEnumLiteralDeclaration_1()); }
1540 ruleDataObject 2069 ('-')
1541 { after(grammarAccess.getLiteralAccess().getDataObjectParserRuleCall_1()); } 2070 { after(grammarAccess.getAdditiveBinaryOperatorAccess().getSUBEnumLiteralDeclaration_1()); }
2071 )
2072;
2073finally {
2074 restoreStackSize(stackSize);
2075}
2076
2077rule__MultiplicativeBinaryOperator__Alternatives
2078 @init {
2079 int stackSize = keepStackSize();
2080 }
2081:
2082 (
2083 { before(grammarAccess.getMultiplicativeBinaryOperatorAccess().getMULEnumLiteralDeclaration_0()); }
2084 ('*')
2085 { after(grammarAccess.getMultiplicativeBinaryOperatorAccess().getMULEnumLiteralDeclaration_0()); }
1542 ) 2086 )
1543 | 2087 |
1544 ( 2088 (
1545 { before(grammarAccess.getLiteralAccess().getNamedObjectParserRuleCall_2()); } 2089 { before(grammarAccess.getMultiplicativeBinaryOperatorAccess().getDIVEnumLiteralDeclaration_1()); }
1546 ruleNamedObject 2090 ('/')
1547 { after(grammarAccess.getLiteralAccess().getNamedObjectParserRuleCall_2()); } 2091 { after(grammarAccess.getMultiplicativeBinaryOperatorAccess().getDIVEnumLiteralDeclaration_1()); }
1548 ) 2092 )
1549; 2093;
1550finally { 2094finally {
1551 restoreStackSize(stackSize); 2095 restoreStackSize(stackSize);
1552} 2096}
1553 2097
1554rule__CDInterpretation__Alternatives 2098rule__UnaryOp__Alternatives
1555 @init { 2099 @init {
1556 int stackSize = keepStackSize(); 2100 int stackSize = keepStackSize();
1557 } 2101 }
1558: 2102:
1559 ( 2103 (
1560 { before(grammarAccess.getCDInterpretationAccess().getClassInterpretationParserRuleCall_0()); } 2104 { before(grammarAccess.getUnaryOpAccess().getNEGEnumLiteralDeclaration_0()); }
1561 ruleClassInterpretation 2105 ('!')
1562 { after(grammarAccess.getCDInterpretationAccess().getClassInterpretationParserRuleCall_0()); } 2106 { after(grammarAccess.getUnaryOpAccess().getNEGEnumLiteralDeclaration_0()); }
2107 )
2108 |
2109 (
2110 { before(grammarAccess.getUnaryOpAccess().getPLUSEnumLiteralDeclaration_1()); }
2111 ('+')
2112 { after(grammarAccess.getUnaryOpAccess().getPLUSEnumLiteralDeclaration_1()); }
2113 )
2114 |
2115 (
2116 { before(grammarAccess.getUnaryOpAccess().getMINUSEnumLiteralDeclaration_2()); }
2117 ('-')
2118 { after(grammarAccess.getUnaryOpAccess().getMINUSEnumLiteralDeclaration_2()); }
1563 ) 2119 )
1564 | 2120 |
1565 ( 2121 (
1566 { before(grammarAccess.getCDInterpretationAccess().getEnumInterpretationParserRuleCall_1()); } 2122 { before(grammarAccess.getUnaryOpAccess().getMAYEnumLiteralDeclaration_3()); }
1567 ruleEnumInterpretation 2123 ('may')
1568 { after(grammarAccess.getCDInterpretationAccess().getEnumInterpretationParserRuleCall_1()); } 2124 { after(grammarAccess.getUnaryOpAccess().getMAYEnumLiteralDeclaration_3()); }
1569 ) 2125 )
1570 | 2126 |
1571 ( 2127 (
1572 { before(grammarAccess.getCDInterpretationAccess().getGlobalRelationInterpretationParserRuleCall_2()); } 2128 { before(grammarAccess.getUnaryOpAccess().getMUSTEnumLiteralDeclaration_4()); }
1573 ruleGlobalRelationInterpretation 2129 ('must')
1574 { after(grammarAccess.getCDInterpretationAccess().getGlobalRelationInterpretationParserRuleCall_2()); } 2130 { after(grammarAccess.getUnaryOpAccess().getMUSTEnumLiteralDeclaration_4()); }
2131 )
2132 |
2133 (
2134 { before(grammarAccess.getUnaryOpAccess().getCURRENTEnumLiteralDeclaration_5()); }
2135 ('current')
2136 { after(grammarAccess.getUnaryOpAccess().getCURRENTEnumLiteralDeclaration_5()); }
1575 ) 2137 )
1576; 2138;
1577finally { 2139finally {
1578 restoreStackSize(stackSize); 2140 restoreStackSize(stackSize);
1579} 2141}
1580 2142
1581rule__MultiplicityDefinition__Alternatives_2 2143rule__AggregationOp__Alternatives
1582 @init { 2144 @init {
1583 int stackSize = keepStackSize(); 2145 int stackSize = keepStackSize();
1584 } 2146 }
1585: 2147:
1586 ( 2148 (
1587 { before(grammarAccess.getMultiplicityDefinitionAccess().getUpperAssignment_2_0()); } 2149 { before(grammarAccess.getAggregationOpAccess().getONLYEnumLiteralDeclaration_0()); }
1588 (rule__MultiplicityDefinition__UpperAssignment_2_0) 2150 ('only')
1589 { after(grammarAccess.getMultiplicityDefinitionAccess().getUpperAssignment_2_0()); } 2151 { after(grammarAccess.getAggregationOpAccess().getONLYEnumLiteralDeclaration_0()); }
2152 )
2153 |
2154 (
2155 { before(grammarAccess.getAggregationOpAccess().getSUMEnumLiteralDeclaration_1()); }
2156 ('sum')
2157 { after(grammarAccess.getAggregationOpAccess().getSUMEnumLiteralDeclaration_1()); }
1590 ) 2158 )
1591 | 2159 |
1592 ( 2160 (
1593 { before(grammarAccess.getMultiplicityDefinitionAccess().getUnlimitedUpperAssignment_2_1()); } 2161 { before(grammarAccess.getAggregationOpAccess().getPRODEnumLiteralDeclaration_2()); }
1594 (rule__MultiplicityDefinition__UnlimitedUpperAssignment_2_1) 2162 ('prod')
1595 { after(grammarAccess.getMultiplicityDefinitionAccess().getUnlimitedUpperAssignment_2_1()); } 2163 { after(grammarAccess.getAggregationOpAccess().getPRODEnumLiteralDeclaration_2()); }
2164 )
2165 |
2166 (
2167 { before(grammarAccess.getAggregationOpAccess().getAVGEnumLiteralDeclaration_3()); }
2168 ('avg')
2169 { after(grammarAccess.getAggregationOpAccess().getAVGEnumLiteralDeclaration_3()); }
2170 )
2171 |
2172 (
2173 { before(grammarAccess.getAggregationOpAccess().getMINEnumLiteralDeclaration_4()); }
2174 ('min')
2175 { after(grammarAccess.getAggregationOpAccess().getMINEnumLiteralDeclaration_4()); }
2176 )
2177 |
2178 (
2179 { before(grammarAccess.getAggregationOpAccess().getMAXEnumLiteralDeclaration_5()); }
2180 ('max')
2181 { after(grammarAccess.getAggregationOpAccess().getMAXEnumLiteralDeclaration_5()); }
1596 ) 2182 )
1597; 2183;
1598finally { 2184finally {
1599 restoreStackSize(stackSize); 2185 restoreStackSize(stackSize);
1600} 2186}
1601 2187
1602rule__REALLiteral__Group__0 2188rule__LogicValue__Alternatives
1603 @init { 2189 @init {
1604 int stackSize = keepStackSize(); 2190 int stackSize = keepStackSize();
1605 } 2191 }
1606: 2192:
1607 rule__REALLiteral__Group__0__Impl 2193 (
1608 rule__REALLiteral__Group__1 2194 { before(grammarAccess.getLogicValueAccess().getTRUEEnumLiteralDeclaration_0()); }
2195 ('true')
2196 { after(grammarAccess.getLogicValueAccess().getTRUEEnumLiteralDeclaration_0()); }
2197 )
2198 |
2199 (
2200 { before(grammarAccess.getLogicValueAccess().getFALSEEnumLiteralDeclaration_1()); }
2201 ('false')
2202 { after(grammarAccess.getLogicValueAccess().getFALSEEnumLiteralDeclaration_1()); }
2203 )
2204 |
2205 (
2206 { before(grammarAccess.getLogicValueAccess().getUNKNOWNEnumLiteralDeclaration_2()); }
2207 ('unknown')
2208 { after(grammarAccess.getLogicValueAccess().getUNKNOWNEnumLiteralDeclaration_2()); }
2209 )
2210 |
2211 (
2212 { before(grammarAccess.getLogicValueAccess().getERROREnumLiteralDeclaration_3()); }
2213 ('error')
2214 { after(grammarAccess.getLogicValueAccess().getERROREnumLiteralDeclaration_3()); }
2215 )
1609; 2216;
1610finally { 2217finally {
1611 restoreStackSize(stackSize); 2218 restoreStackSize(stackSize);
1612} 2219}
1613 2220
1614rule__REALLiteral__Group__0__Impl 2221rule__ObjectiveKind__Alternatives
2222 @init {
2223 int stackSize = keepStackSize();
2224 }
2225:
2226 (
2227 { before(grammarAccess.getObjectiveKindAccess().getMINIMIZEEnumLiteralDeclaration_0()); }
2228 ('minimize')
2229 { after(grammarAccess.getObjectiveKindAccess().getMINIMIZEEnumLiteralDeclaration_0()); }
2230 )
2231 |
2232 (
2233 { before(grammarAccess.getObjectiveKindAccess().getMAXIMIZEEnumLiteralDeclaration_1()); }
2234 ('maximize')
2235 { after(grammarAccess.getObjectiveKindAccess().getMAXIMIZEEnumLiteralDeclaration_1()); }
2236 )
2237;
2238finally {
2239 restoreStackSize(stackSize);
2240}
2241
2242rule__Statement__Group__0
2243 @init {
2244 int stackSize = keepStackSize();
2245 }
2246:
2247 rule__Statement__Group__0__Impl
2248 rule__Statement__Group__1
2249;
2250finally {
2251 restoreStackSize(stackSize);
2252}
2253
2254rule__Statement__Group__0__Impl
1615 @init { 2255 @init {
1616 int stackSize = keepStackSize(); 2256 int stackSize = keepStackSize();
1617 } 2257 }
1618: 2258:
1619( 2259(
1620 { before(grammarAccess.getREALLiteralAccess().getHyphenMinusKeyword_0()); } 2260 { before(grammarAccess.getStatementAccess().getAlternatives_0()); }
1621 ('-')? 2261 (rule__Statement__Alternatives_0)
1622 { after(grammarAccess.getREALLiteralAccess().getHyphenMinusKeyword_0()); } 2262 { after(grammarAccess.getStatementAccess().getAlternatives_0()); }
1623) 2263)
1624; 2264;
1625finally { 2265finally {
1626 restoreStackSize(stackSize); 2266 restoreStackSize(stackSize);
1627} 2267}
1628 2268
1629rule__REALLiteral__Group__1 2269rule__Statement__Group__1
1630 @init { 2270 @init {
1631 int stackSize = keepStackSize(); 2271 int stackSize = keepStackSize();
1632 } 2272 }
1633: 2273:
1634 rule__REALLiteral__Group__1__Impl 2274 rule__Statement__Group__1__Impl
1635 rule__REALLiteral__Group__2
1636; 2275;
1637finally { 2276finally {
1638 restoreStackSize(stackSize); 2277 restoreStackSize(stackSize);
1639} 2278}
1640 2279
1641rule__REALLiteral__Group__1__Impl 2280rule__Statement__Group__1__Impl
1642 @init { 2281 @init {
1643 int stackSize = keepStackSize(); 2282 int stackSize = keepStackSize();
1644 } 2283 }
1645: 2284:
1646( 2285(
1647 { before(grammarAccess.getREALLiteralAccess().getINTTerminalRuleCall_1()); } 2286 { before(grammarAccess.getStatementAccess().getDOTTerminalRuleCall_1()); }
1648 RULE_INT 2287 RULE_DOT
1649 { after(grammarAccess.getREALLiteralAccess().getINTTerminalRuleCall_1()); } 2288 { after(grammarAccess.getStatementAccess().getDOTTerminalRuleCall_1()); }
1650) 2289)
1651; 2290;
1652finally { 2291finally {
1653 restoreStackSize(stackSize); 2292 restoreStackSize(stackSize);
1654} 2293}
1655 2294
1656rule__REALLiteral__Group__2 2295
2296rule__AssertionOrDefinition__Group__0
1657 @init { 2297 @init {
1658 int stackSize = keepStackSize(); 2298 int stackSize = keepStackSize();
1659 } 2299 }
1660: 2300:
1661 rule__REALLiteral__Group__2__Impl 2301 rule__AssertionOrDefinition__Group__0__Impl
1662 rule__REALLiteral__Group__3 2302 rule__AssertionOrDefinition__Group__1
1663; 2303;
1664finally { 2304finally {
1665 restoreStackSize(stackSize); 2305 restoreStackSize(stackSize);
1666} 2306}
1667 2307
1668rule__REALLiteral__Group__2__Impl 2308rule__AssertionOrDefinition__Group__0__Impl
1669 @init { 2309 @init {
1670 int stackSize = keepStackSize(); 2310 int stackSize = keepStackSize();
1671 } 2311 }
1672: 2312:
1673( 2313(
1674 { before(grammarAccess.getREALLiteralAccess().getFullStopKeyword_2()); } 2314 { before(grammarAccess.getAssertionOrDefinitionAccess().getExpressionParserRuleCall_0()); }
1675 '.' 2315 ruleExpression
1676 { after(grammarAccess.getREALLiteralAccess().getFullStopKeyword_2()); } 2316 { after(grammarAccess.getAssertionOrDefinitionAccess().getExpressionParserRuleCall_0()); }
1677) 2317)
1678; 2318;
1679finally { 2319finally {
1680 restoreStackSize(stackSize); 2320 restoreStackSize(stackSize);
1681} 2321}
1682 2322
1683rule__REALLiteral__Group__3 2323rule__AssertionOrDefinition__Group__1
1684 @init { 2324 @init {
1685 int stackSize = keepStackSize(); 2325 int stackSize = keepStackSize();
1686 } 2326 }
1687: 2327:
1688 rule__REALLiteral__Group__3__Impl 2328 rule__AssertionOrDefinition__Group__1__Impl
1689; 2329;
1690finally { 2330finally {
1691 restoreStackSize(stackSize); 2331 restoreStackSize(stackSize);
1692} 2332}
1693 2333
1694rule__REALLiteral__Group__3__Impl 2334rule__AssertionOrDefinition__Group__1__Impl
1695 @init { 2335 @init {
1696 int stackSize = keepStackSize(); 2336 int stackSize = keepStackSize();
1697 } 2337 }
1698: 2338:
1699( 2339(
1700 { before(grammarAccess.getREALLiteralAccess().getINTTerminalRuleCall_3()); } 2340 { before(grammarAccess.getAssertionOrDefinitionAccess().getAlternatives_1()); }
1701 RULE_INT 2341 (rule__AssertionOrDefinition__Alternatives_1)
1702 { after(grammarAccess.getREALLiteralAccess().getINTTerminalRuleCall_3()); } 2342 { after(grammarAccess.getAssertionOrDefinitionAccess().getAlternatives_1()); }
1703) 2343)
1704; 2344;
1705finally { 2345finally {
@@ -1707,53 +2347,53 @@ finally {
1707} 2347}
1708 2348
1709 2349
1710rule__INTLiteral__Group__0 2350rule__AssertionOrDefinition__Group_1_0__0
1711 @init { 2351 @init {
1712 int stackSize = keepStackSize(); 2352 int stackSize = keepStackSize();
1713 } 2353 }
1714: 2354:
1715 rule__INTLiteral__Group__0__Impl 2355 rule__AssertionOrDefinition__Group_1_0__0__Impl
1716 rule__INTLiteral__Group__1 2356 rule__AssertionOrDefinition__Group_1_0__1
1717; 2357;
1718finally { 2358finally {
1719 restoreStackSize(stackSize); 2359 restoreStackSize(stackSize);
1720} 2360}
1721 2361
1722rule__INTLiteral__Group__0__Impl 2362rule__AssertionOrDefinition__Group_1_0__0__Impl
1723 @init { 2363 @init {
1724 int stackSize = keepStackSize(); 2364 int stackSize = keepStackSize();
1725 } 2365 }
1726: 2366:
1727( 2367(
1728 { before(grammarAccess.getINTLiteralAccess().getHyphenMinusKeyword_0()); } 2368 { before(grammarAccess.getAssertionOrDefinitionAccess().getAssertionBodyAction_1_0_0()); }
1729 ('-')? 2369 ()
1730 { after(grammarAccess.getINTLiteralAccess().getHyphenMinusKeyword_0()); } 2370 { after(grammarAccess.getAssertionOrDefinitionAccess().getAssertionBodyAction_1_0_0()); }
1731) 2371)
1732; 2372;
1733finally { 2373finally {
1734 restoreStackSize(stackSize); 2374 restoreStackSize(stackSize);
1735} 2375}
1736 2376
1737rule__INTLiteral__Group__1 2377rule__AssertionOrDefinition__Group_1_0__1
1738 @init { 2378 @init {
1739 int stackSize = keepStackSize(); 2379 int stackSize = keepStackSize();
1740 } 2380 }
1741: 2381:
1742 rule__INTLiteral__Group__1__Impl 2382 rule__AssertionOrDefinition__Group_1_0__1__Impl
1743; 2383;
1744finally { 2384finally {
1745 restoreStackSize(stackSize); 2385 restoreStackSize(stackSize);
1746} 2386}
1747 2387
1748rule__INTLiteral__Group__1__Impl 2388rule__AssertionOrDefinition__Group_1_0__1__Impl
1749 @init { 2389 @init {
1750 int stackSize = keepStackSize(); 2390 int stackSize = keepStackSize();
1751 } 2391 }
1752: 2392:
1753( 2393(
1754 { before(grammarAccess.getINTLiteralAccess().getINTTerminalRuleCall_1()); } 2394 { before(grammarAccess.getAssertionOrDefinitionAccess().getGroup_1_0_1()); }
1755 RULE_INT 2395 (rule__AssertionOrDefinition__Group_1_0_1__0)?
1756 { after(grammarAccess.getINTLiteralAccess().getINTTerminalRuleCall_1()); } 2396 { after(grammarAccess.getAssertionOrDefinitionAccess().getGroup_1_0_1()); }
1757) 2397)
1758; 2398;
1759finally { 2399finally {
@@ -1761,53 +2401,53 @@ finally {
1761} 2401}
1762 2402
1763 2403
1764rule__BooleanValue__Group_0__0 2404rule__AssertionOrDefinition__Group_1_0_1__0
1765 @init { 2405 @init {
1766 int stackSize = keepStackSize(); 2406 int stackSize = keepStackSize();
1767 } 2407 }
1768: 2408:
1769 rule__BooleanValue__Group_0__0__Impl 2409 rule__AssertionOrDefinition__Group_1_0_1__0__Impl
1770 rule__BooleanValue__Group_0__1 2410 rule__AssertionOrDefinition__Group_1_0_1__1
1771; 2411;
1772finally { 2412finally {
1773 restoreStackSize(stackSize); 2413 restoreStackSize(stackSize);
1774} 2414}
1775 2415
1776rule__BooleanValue__Group_0__0__Impl 2416rule__AssertionOrDefinition__Group_1_0_1__0__Impl
1777 @init { 2417 @init {
1778 int stackSize = keepStackSize(); 2418 int stackSize = keepStackSize();
1779 } 2419 }
1780: 2420:
1781( 2421(
1782 { before(grammarAccess.getBooleanValueAccess().getBooleanTrueAction_0_0()); } 2422 { before(grammarAccess.getAssertionOrDefinitionAccess().getColonKeyword_1_0_1_0()); }
1783 () 2423 ':'
1784 { after(grammarAccess.getBooleanValueAccess().getBooleanTrueAction_0_0()); } 2424 { after(grammarAccess.getAssertionOrDefinitionAccess().getColonKeyword_1_0_1_0()); }
1785) 2425)
1786; 2426;
1787finally { 2427finally {
1788 restoreStackSize(stackSize); 2428 restoreStackSize(stackSize);
1789} 2429}
1790 2430
1791rule__BooleanValue__Group_0__1 2431rule__AssertionOrDefinition__Group_1_0_1__1
1792 @init { 2432 @init {
1793 int stackSize = keepStackSize(); 2433 int stackSize = keepStackSize();
1794 } 2434 }
1795: 2435:
1796 rule__BooleanValue__Group_0__1__Impl 2436 rule__AssertionOrDefinition__Group_1_0_1__1__Impl
1797; 2437;
1798finally { 2438finally {
1799 restoreStackSize(stackSize); 2439 restoreStackSize(stackSize);
1800} 2440}
1801 2441
1802rule__BooleanValue__Group_0__1__Impl 2442rule__AssertionOrDefinition__Group_1_0_1__1__Impl
1803 @init { 2443 @init {
1804 int stackSize = keepStackSize(); 2444 int stackSize = keepStackSize();
1805 } 2445 }
1806: 2446:
1807( 2447(
1808 { before(grammarAccess.getBooleanValueAccess().getTrueKeyword_0_1()); } 2448 { before(grammarAccess.getAssertionOrDefinitionAccess().getRangeAssignment_1_0_1_1()); }
1809 'true' 2449 (rule__AssertionOrDefinition__RangeAssignment_1_0_1_1)
1810 { after(grammarAccess.getBooleanValueAccess().getTrueKeyword_0_1()); } 2450 { after(grammarAccess.getAssertionOrDefinitionAccess().getRangeAssignment_1_0_1_1()); }
1811) 2451)
1812; 2452;
1813finally { 2453finally {
@@ -1815,53 +2455,80 @@ finally {
1815} 2455}
1816 2456
1817 2457
1818rule__BooleanValue__Group_1__0 2458rule__AssertionOrDefinition__Group_1_1__0
1819 @init { 2459 @init {
1820 int stackSize = keepStackSize(); 2460 int stackSize = keepStackSize();
1821 } 2461 }
1822: 2462:
1823 rule__BooleanValue__Group_1__0__Impl 2463 rule__AssertionOrDefinition__Group_1_1__0__Impl
1824 rule__BooleanValue__Group_1__1 2464 rule__AssertionOrDefinition__Group_1_1__1
1825; 2465;
1826finally { 2466finally {
1827 restoreStackSize(stackSize); 2467 restoreStackSize(stackSize);
1828} 2468}
1829 2469
1830rule__BooleanValue__Group_1__0__Impl 2470rule__AssertionOrDefinition__Group_1_1__0__Impl
1831 @init { 2471 @init {
1832 int stackSize = keepStackSize(); 2472 int stackSize = keepStackSize();
1833 } 2473 }
1834: 2474:
1835( 2475(
1836 { before(grammarAccess.getBooleanValueAccess().getFalseKeyword_1_0()); } 2476 { before(grammarAccess.getAssertionOrDefinitionAccess().getPredicateDefinitionHeadAction_1_1_0()); }
1837 'false' 2477 ()
1838 { after(grammarAccess.getBooleanValueAccess().getFalseKeyword_1_0()); } 2478 { after(grammarAccess.getAssertionOrDefinitionAccess().getPredicateDefinitionHeadAction_1_1_0()); }
1839) 2479)
1840; 2480;
1841finally { 2481finally {
1842 restoreStackSize(stackSize); 2482 restoreStackSize(stackSize);
1843} 2483}
1844 2484
1845rule__BooleanValue__Group_1__1 2485rule__AssertionOrDefinition__Group_1_1__1
1846 @init { 2486 @init {
1847 int stackSize = keepStackSize(); 2487 int stackSize = keepStackSize();
1848 } 2488 }
1849: 2489:
1850 rule__BooleanValue__Group_1__1__Impl 2490 rule__AssertionOrDefinition__Group_1_1__1__Impl
2491 rule__AssertionOrDefinition__Group_1_1__2
1851; 2492;
1852finally { 2493finally {
1853 restoreStackSize(stackSize); 2494 restoreStackSize(stackSize);
1854} 2495}
1855 2496
1856rule__BooleanValue__Group_1__1__Impl 2497rule__AssertionOrDefinition__Group_1_1__1__Impl
1857 @init { 2498 @init {
1858 int stackSize = keepStackSize(); 2499 int stackSize = keepStackSize();
1859 } 2500 }
1860: 2501:
1861( 2502(
1862 { before(grammarAccess.getBooleanValueAccess().getBooleanFalseAction_1_1()); } 2503 { before(grammarAccess.getAssertionOrDefinitionAccess().getColonHyphenMinusKeyword_1_1_1()); }
1863 () 2504 ':-'
1864 { after(grammarAccess.getBooleanValueAccess().getBooleanFalseAction_1_1()); } 2505 { after(grammarAccess.getAssertionOrDefinitionAccess().getColonHyphenMinusKeyword_1_1_1()); }
2506)
2507;
2508finally {
2509 restoreStackSize(stackSize);
2510}
2511
2512rule__AssertionOrDefinition__Group_1_1__2
2513 @init {
2514 int stackSize = keepStackSize();
2515 }
2516:
2517 rule__AssertionOrDefinition__Group_1_1__2__Impl
2518;
2519finally {
2520 restoreStackSize(stackSize);
2521}
2522
2523rule__AssertionOrDefinition__Group_1_1__2__Impl
2524 @init {
2525 int stackSize = keepStackSize();
2526 }
2527:
2528(
2529 { before(grammarAccess.getAssertionOrDefinitionAccess().getBodyAssignment_1_1_2()); }
2530 (rule__AssertionOrDefinition__BodyAssignment_1_1_2)
2531 { after(grammarAccess.getAssertionOrDefinitionAccess().getBodyAssignment_1_1_2()); }
1865) 2532)
1866; 2533;
1867finally { 2534finally {
@@ -1869,215 +2536,404 @@ finally {
1869} 2536}
1870 2537
1871 2538
1872rule__TruthValue__Group_0__0 2539rule__AssertionOrDefinition__Group_1_2__0
1873 @init { 2540 @init {
1874 int stackSize = keepStackSize(); 2541 int stackSize = keepStackSize();
1875 } 2542 }
1876: 2543:
1877 rule__TruthValue__Group_0__0__Impl 2544 rule__AssertionOrDefinition__Group_1_2__0__Impl
1878 rule__TruthValue__Group_0__1 2545 rule__AssertionOrDefinition__Group_1_2__1
1879; 2546;
1880finally { 2547finally {
1881 restoreStackSize(stackSize); 2548 restoreStackSize(stackSize);
1882} 2549}
1883 2550
1884rule__TruthValue__Group_0__0__Impl 2551rule__AssertionOrDefinition__Group_1_2__0__Impl
1885 @init { 2552 @init {
1886 int stackSize = keepStackSize(); 2553 int stackSize = keepStackSize();
1887 } 2554 }
1888: 2555:
1889( 2556(
1890 { before(grammarAccess.getTruthValueAccess().getTrueAction_0_0()); } 2557 { before(grammarAccess.getAssertionOrDefinitionAccess().getMetricDefinitionHeadAction_1_2_0()); }
1891 () 2558 ()
1892 { after(grammarAccess.getTruthValueAccess().getTrueAction_0_0()); } 2559 { after(grammarAccess.getAssertionOrDefinitionAccess().getMetricDefinitionHeadAction_1_2_0()); }
1893) 2560)
1894; 2561;
1895finally { 2562finally {
1896 restoreStackSize(stackSize); 2563 restoreStackSize(stackSize);
1897} 2564}
1898 2565
1899rule__TruthValue__Group_0__1 2566rule__AssertionOrDefinition__Group_1_2__1
1900 @init { 2567 @init {
1901 int stackSize = keepStackSize(); 2568 int stackSize = keepStackSize();
1902 } 2569 }
1903: 2570:
1904 rule__TruthValue__Group_0__1__Impl 2571 rule__AssertionOrDefinition__Group_1_2__1__Impl
2572 rule__AssertionOrDefinition__Group_1_2__2
1905; 2573;
1906finally { 2574finally {
1907 restoreStackSize(stackSize); 2575 restoreStackSize(stackSize);
1908} 2576}
1909 2577
1910rule__TruthValue__Group_0__1__Impl 2578rule__AssertionOrDefinition__Group_1_2__1__Impl
1911 @init { 2579 @init {
1912 int stackSize = keepStackSize(); 2580 int stackSize = keepStackSize();
1913 } 2581 }
1914: 2582:
1915( 2583(
1916 { before(grammarAccess.getTruthValueAccess().getTrueKeyword_0_1()); } 2584 { before(grammarAccess.getAssertionOrDefinitionAccess().getEqualsSignKeyword_1_2_1()); }
1917 'true' 2585 '='
1918 { after(grammarAccess.getTruthValueAccess().getTrueKeyword_0_1()); } 2586 { after(grammarAccess.getAssertionOrDefinitionAccess().getEqualsSignKeyword_1_2_1()); }
1919) 2587)
1920; 2588;
1921finally { 2589finally {
1922 restoreStackSize(stackSize); 2590 restoreStackSize(stackSize);
1923} 2591}
1924 2592
2593rule__AssertionOrDefinition__Group_1_2__2
2594 @init {
2595 int stackSize = keepStackSize();
2596 }
2597:
2598 rule__AssertionOrDefinition__Group_1_2__2__Impl
2599;
2600finally {
2601 restoreStackSize(stackSize);
2602}
1925 2603
1926rule__TruthValue__Group_1__0 2604rule__AssertionOrDefinition__Group_1_2__2__Impl
1927 @init { 2605 @init {
1928 int stackSize = keepStackSize(); 2606 int stackSize = keepStackSize();
1929 } 2607 }
1930: 2608:
1931 rule__TruthValue__Group_1__0__Impl 2609(
1932 rule__TruthValue__Group_1__1 2610 { before(grammarAccess.getAssertionOrDefinitionAccess().getBodyAssignment_1_2_2()); }
2611 (rule__AssertionOrDefinition__BodyAssignment_1_2_2)
2612 { after(grammarAccess.getAssertionOrDefinitionAccess().getBodyAssignment_1_2_2()); }
2613)
1933; 2614;
1934finally { 2615finally {
1935 restoreStackSize(stackSize); 2616 restoreStackSize(stackSize);
1936} 2617}
1937 2618
1938rule__TruthValue__Group_1__0__Impl 2619
2620rule__PredicateDefinition__Group__0
2621 @init {
2622 int stackSize = keepStackSize();
2623 }
2624:
2625 rule__PredicateDefinition__Group__0__Impl
2626 rule__PredicateDefinition__Group__1
2627;
2628finally {
2629 restoreStackSize(stackSize);
2630}
2631
2632rule__PredicateDefinition__Group__0__Impl
1939 @init { 2633 @init {
1940 int stackSize = keepStackSize(); 2634 int stackSize = keepStackSize();
1941 } 2635 }
1942: 2636:
1943( 2637(
1944 { before(grammarAccess.getTruthValueAccess().getFalseAction_1_0()); } 2638 { before(grammarAccess.getPredicateDefinitionAccess().getAlternatives_0()); }
1945 () 2639 (rule__PredicateDefinition__Alternatives_0)
1946 { after(grammarAccess.getTruthValueAccess().getFalseAction_1_0()); } 2640 { after(grammarAccess.getPredicateDefinitionAccess().getAlternatives_0()); }
1947) 2641)
1948; 2642;
1949finally { 2643finally {
1950 restoreStackSize(stackSize); 2644 restoreStackSize(stackSize);
1951} 2645}
1952 2646
1953rule__TruthValue__Group_1__1 2647rule__PredicateDefinition__Group__1
1954 @init { 2648 @init {
1955 int stackSize = keepStackSize(); 2649 int stackSize = keepStackSize();
1956 } 2650 }
1957: 2651:
1958 rule__TruthValue__Group_1__1__Impl 2652 rule__PredicateDefinition__Group__1__Impl
2653 rule__PredicateDefinition__Group__2
1959; 2654;
1960finally { 2655finally {
1961 restoreStackSize(stackSize); 2656 restoreStackSize(stackSize);
1962} 2657}
1963 2658
1964rule__TruthValue__Group_1__1__Impl 2659rule__PredicateDefinition__Group__1__Impl
1965 @init { 2660 @init {
1966 int stackSize = keepStackSize(); 2661 int stackSize = keepStackSize();
1967 } 2662 }
1968: 2663:
1969( 2664(
1970 { before(grammarAccess.getTruthValueAccess().getFalseKeyword_1_1()); } 2665 { before(grammarAccess.getPredicateDefinitionAccess().getHeadAssignment_1()); }
1971 'false' 2666 (rule__PredicateDefinition__HeadAssignment_1)
1972 { after(grammarAccess.getTruthValueAccess().getFalseKeyword_1_1()); } 2667 { after(grammarAccess.getPredicateDefinitionAccess().getHeadAssignment_1()); }
1973) 2668)
1974; 2669;
1975finally { 2670finally {
1976 restoreStackSize(stackSize); 2671 restoreStackSize(stackSize);
1977} 2672}
1978 2673
2674rule__PredicateDefinition__Group__2
2675 @init {
2676 int stackSize = keepStackSize();
2677 }
2678:
2679 rule__PredicateDefinition__Group__2__Impl
2680 rule__PredicateDefinition__Group__3
2681;
2682finally {
2683 restoreStackSize(stackSize);
2684}
2685
2686rule__PredicateDefinition__Group__2__Impl
2687 @init {
2688 int stackSize = keepStackSize();
2689 }
2690:
2691(
2692 { before(grammarAccess.getPredicateDefinitionAccess().getColonHyphenMinusKeyword_2()); }
2693 ':-'
2694 { after(grammarAccess.getPredicateDefinitionAccess().getColonHyphenMinusKeyword_2()); }
2695)
2696;
2697finally {
2698 restoreStackSize(stackSize);
2699}
1979 2700
1980rule__TruthValue__Group_2__0 2701rule__PredicateDefinition__Group__3
1981 @init { 2702 @init {
1982 int stackSize = keepStackSize(); 2703 int stackSize = keepStackSize();
1983 } 2704 }
1984: 2705:
1985 rule__TruthValue__Group_2__0__Impl 2706 rule__PredicateDefinition__Group__3__Impl
1986 rule__TruthValue__Group_2__1
1987; 2707;
1988finally { 2708finally {
1989 restoreStackSize(stackSize); 2709 restoreStackSize(stackSize);
1990} 2710}
1991 2711
1992rule__TruthValue__Group_2__0__Impl 2712rule__PredicateDefinition__Group__3__Impl
1993 @init { 2713 @init {
1994 int stackSize = keepStackSize(); 2714 int stackSize = keepStackSize();
1995 } 2715 }
1996: 2716:
1997( 2717(
1998 { before(grammarAccess.getTruthValueAccess().getUnknownAction_2_0()); } 2718 { before(grammarAccess.getPredicateDefinitionAccess().getBodyAssignment_3()); }
1999 () 2719 (rule__PredicateDefinition__BodyAssignment_3)
2000 { after(grammarAccess.getTruthValueAccess().getUnknownAction_2_0()); } 2720 { after(grammarAccess.getPredicateDefinitionAccess().getBodyAssignment_3()); }
2001) 2721)
2002; 2722;
2003finally { 2723finally {
2004 restoreStackSize(stackSize); 2724 restoreStackSize(stackSize);
2005} 2725}
2006 2726
2007rule__TruthValue__Group_2__1 2727
2728rule__PredicateDefinition__Group_0_0__0
2008 @init { 2729 @init {
2009 int stackSize = keepStackSize(); 2730 int stackSize = keepStackSize();
2010 } 2731 }
2011: 2732:
2012 rule__TruthValue__Group_2__1__Impl 2733 rule__PredicateDefinition__Group_0_0__0__Impl
2734 rule__PredicateDefinition__Group_0_0__1
2013; 2735;
2014finally { 2736finally {
2015 restoreStackSize(stackSize); 2737 restoreStackSize(stackSize);
2016} 2738}
2017 2739
2018rule__TruthValue__Group_2__1__Impl 2740rule__PredicateDefinition__Group_0_0__0__Impl
2019 @init { 2741 @init {
2020 int stackSize = keepStackSize(); 2742 int stackSize = keepStackSize();
2021 } 2743 }
2022: 2744:
2023( 2745(
2024 { before(grammarAccess.getTruthValueAccess().getUnknownKeyword_2_1()); } 2746 { before(grammarAccess.getPredicateDefinitionAccess().getFunctionalAssignment_0_0_0()); }
2025 'unknown' 2747 (rule__PredicateDefinition__FunctionalAssignment_0_0_0)
2026 { after(grammarAccess.getTruthValueAccess().getUnknownKeyword_2_1()); } 2748 { after(grammarAccess.getPredicateDefinitionAccess().getFunctionalAssignment_0_0_0()); }
2027) 2749)
2028; 2750;
2029finally { 2751finally {
2030 restoreStackSize(stackSize); 2752 restoreStackSize(stackSize);
2031} 2753}
2032 2754
2755rule__PredicateDefinition__Group_0_0__1
2756 @init {
2757 int stackSize = keepStackSize();
2758 }
2759:
2760 rule__PredicateDefinition__Group_0_0__1__Impl
2761;
2762finally {
2763 restoreStackSize(stackSize);
2764}
2033 2765
2034rule__TruthValue__Group_3__0 2766rule__PredicateDefinition__Group_0_0__1__Impl
2035 @init { 2767 @init {
2036 int stackSize = keepStackSize(); 2768 int stackSize = keepStackSize();
2037 } 2769 }
2038: 2770:
2039 rule__TruthValue__Group_3__0__Impl 2771(
2040 rule__TruthValue__Group_3__1 2772 { before(grammarAccess.getPredicateDefinitionAccess().getErrorAssignment_0_0_1()); }
2773 (rule__PredicateDefinition__ErrorAssignment_0_0_1)?
2774 { after(grammarAccess.getPredicateDefinitionAccess().getErrorAssignment_0_0_1()); }
2775)
2041; 2776;
2042finally { 2777finally {
2043 restoreStackSize(stackSize); 2778 restoreStackSize(stackSize);
2044} 2779}
2045 2780
2046rule__TruthValue__Group_3__0__Impl 2781
2782rule__PredicateDefinition__Group_0_1__0
2783 @init {
2784 int stackSize = keepStackSize();
2785 }
2786:
2787 rule__PredicateDefinition__Group_0_1__0__Impl
2788 rule__PredicateDefinition__Group_0_1__1
2789;
2790finally {
2791 restoreStackSize(stackSize);
2792}
2793
2794rule__PredicateDefinition__Group_0_1__0__Impl
2047 @init { 2795 @init {
2048 int stackSize = keepStackSize(); 2796 int stackSize = keepStackSize();
2049 } 2797 }
2050: 2798:
2051( 2799(
2052 { before(grammarAccess.getTruthValueAccess().getErrorAction_3_0()); } 2800 { before(grammarAccess.getPredicateDefinitionAccess().getErrorAssignment_0_1_0()); }
2053 () 2801 (rule__PredicateDefinition__ErrorAssignment_0_1_0)
2054 { after(grammarAccess.getTruthValueAccess().getErrorAction_3_0()); } 2802 { after(grammarAccess.getPredicateDefinitionAccess().getErrorAssignment_0_1_0()); }
2803)
2804;
2805finally {
2806 restoreStackSize(stackSize);
2807}
2808
2809rule__PredicateDefinition__Group_0_1__1
2810 @init {
2811 int stackSize = keepStackSize();
2812 }
2813:
2814 rule__PredicateDefinition__Group_0_1__1__Impl
2815;
2816finally {
2817 restoreStackSize(stackSize);
2818}
2819
2820rule__PredicateDefinition__Group_0_1__1__Impl
2821 @init {
2822 int stackSize = keepStackSize();
2823 }
2824:
2825(
2826 { before(grammarAccess.getPredicateDefinitionAccess().getFunctionalAssignment_0_1_1()); }
2827 (rule__PredicateDefinition__FunctionalAssignment_0_1_1)?
2828 { after(grammarAccess.getPredicateDefinitionAccess().getFunctionalAssignment_0_1_1()); }
2055) 2829)
2056; 2830;
2057finally { 2831finally {
2058 restoreStackSize(stackSize); 2832 restoreStackSize(stackSize);
2059} 2833}
2060 2834
2061rule__TruthValue__Group_3__1 2835
2836rule__UnnamedErrorPrediateDefinition__Group__0
2062 @init { 2837 @init {
2063 int stackSize = keepStackSize(); 2838 int stackSize = keepStackSize();
2064 } 2839 }
2065: 2840:
2066 rule__TruthValue__Group_3__1__Impl 2841 rule__UnnamedErrorPrediateDefinition__Group__0__Impl
2842 rule__UnnamedErrorPrediateDefinition__Group__1
2067; 2843;
2068finally { 2844finally {
2069 restoreStackSize(stackSize); 2845 restoreStackSize(stackSize);
2070} 2846}
2071 2847
2072rule__TruthValue__Group_3__1__Impl 2848rule__UnnamedErrorPrediateDefinition__Group__0__Impl
2073 @init { 2849 @init {
2074 int stackSize = keepStackSize(); 2850 int stackSize = keepStackSize();
2075 } 2851 }
2076: 2852:
2077( 2853(
2078 { before(grammarAccess.getTruthValueAccess().getErrorKeyword_3_1()); } 2854 { before(grammarAccess.getUnnamedErrorPrediateDefinitionAccess().getErrorKeyword_0()); }
2079 'error' 2855 'error'
2080 { after(grammarAccess.getTruthValueAccess().getErrorKeyword_3_1()); } 2856 { after(grammarAccess.getUnnamedErrorPrediateDefinitionAccess().getErrorKeyword_0()); }
2857)
2858;
2859finally {
2860 restoreStackSize(stackSize);
2861}
2862
2863rule__UnnamedErrorPrediateDefinition__Group__1
2864 @init {
2865 int stackSize = keepStackSize();
2866 }
2867:
2868 rule__UnnamedErrorPrediateDefinition__Group__1__Impl
2869 rule__UnnamedErrorPrediateDefinition__Group__2
2870;
2871finally {
2872 restoreStackSize(stackSize);
2873}
2874
2875rule__UnnamedErrorPrediateDefinition__Group__1__Impl
2876 @init {
2877 int stackSize = keepStackSize();
2878 }
2879:
2880(
2881 { before(grammarAccess.getUnnamedErrorPrediateDefinitionAccess().getArgumentListAssignment_1()); }
2882 (rule__UnnamedErrorPrediateDefinition__ArgumentListAssignment_1)
2883 { after(grammarAccess.getUnnamedErrorPrediateDefinitionAccess().getArgumentListAssignment_1()); }
2884)
2885;
2886finally {
2887 restoreStackSize(stackSize);
2888}
2889
2890rule__UnnamedErrorPrediateDefinition__Group__2
2891 @init {
2892 int stackSize = keepStackSize();
2893 }
2894:
2895 rule__UnnamedErrorPrediateDefinition__Group__2__Impl
2896 rule__UnnamedErrorPrediateDefinition__Group__3
2897;
2898finally {
2899 restoreStackSize(stackSize);
2900}
2901
2902rule__UnnamedErrorPrediateDefinition__Group__2__Impl
2903 @init {
2904 int stackSize = keepStackSize();
2905 }
2906:
2907(
2908 { before(grammarAccess.getUnnamedErrorPrediateDefinitionAccess().getColonHyphenMinusKeyword_2()); }
2909 ':-'
2910 { after(grammarAccess.getUnnamedErrorPrediateDefinitionAccess().getColonHyphenMinusKeyword_2()); }
2911)
2912;
2913finally {
2914 restoreStackSize(stackSize);
2915}
2916
2917rule__UnnamedErrorPrediateDefinition__Group__3
2918 @init {
2919 int stackSize = keepStackSize();
2920 }
2921:
2922 rule__UnnamedErrorPrediateDefinition__Group__3__Impl
2923;
2924finally {
2925 restoreStackSize(stackSize);
2926}
2927
2928rule__UnnamedErrorPrediateDefinition__Group__3__Impl
2929 @init {
2930 int stackSize = keepStackSize();
2931 }
2932:
2933(
2934 { before(grammarAccess.getUnnamedErrorPrediateDefinitionAccess().getBodyAssignment_3()); }
2935 (rule__UnnamedErrorPrediateDefinition__BodyAssignment_3)
2936 { after(grammarAccess.getUnnamedErrorPrediateDefinitionAccess().getBodyAssignment_3()); }
2081) 2937)
2082; 2938;
2083finally { 2939finally {
@@ -2085,107 +2941,107 @@ finally {
2085} 2941}
2086 2942
2087 2943
2088rule__BasicInterpretation__Group__0 2944rule__DefaultDefinition__Group__0
2089 @init { 2945 @init {
2090 int stackSize = keepStackSize(); 2946 int stackSize = keepStackSize();
2091 } 2947 }
2092: 2948:
2093 rule__BasicInterpretation__Group__0__Impl 2949 rule__DefaultDefinition__Group__0__Impl
2094 rule__BasicInterpretation__Group__1 2950 rule__DefaultDefinition__Group__1
2095; 2951;
2096finally { 2952finally {
2097 restoreStackSize(stackSize); 2953 restoreStackSize(stackSize);
2098} 2954}
2099 2955
2100rule__BasicInterpretation__Group__0__Impl 2956rule__DefaultDefinition__Group__0__Impl
2101 @init { 2957 @init {
2102 int stackSize = keepStackSize(); 2958 int stackSize = keepStackSize();
2103 } 2959 }
2104: 2960:
2105( 2961(
2106 { before(grammarAccess.getBasicInterpretationAccess().getSymbolAssignment_0()); } 2962 { before(grammarAccess.getDefaultDefinitionAccess().getDefaultKeyword_0()); }
2107 (rule__BasicInterpretation__SymbolAssignment_0) 2963 'default'
2108 { after(grammarAccess.getBasicInterpretationAccess().getSymbolAssignment_0()); } 2964 { after(grammarAccess.getDefaultDefinitionAccess().getDefaultKeyword_0()); }
2109) 2965)
2110; 2966;
2111finally { 2967finally {
2112 restoreStackSize(stackSize); 2968 restoreStackSize(stackSize);
2113} 2969}
2114 2970
2115rule__BasicInterpretation__Group__1 2971rule__DefaultDefinition__Group__1
2116 @init { 2972 @init {
2117 int stackSize = keepStackSize(); 2973 int stackSize = keepStackSize();
2118 } 2974 }
2119: 2975:
2120 rule__BasicInterpretation__Group__1__Impl 2976 rule__DefaultDefinition__Group__1__Impl
2121 rule__BasicInterpretation__Group__2 2977 rule__DefaultDefinition__Group__2
2122; 2978;
2123finally { 2979finally {
2124 restoreStackSize(stackSize); 2980 restoreStackSize(stackSize);
2125} 2981}
2126 2982
2127rule__BasicInterpretation__Group__1__Impl 2983rule__DefaultDefinition__Group__1__Impl
2128 @init { 2984 @init {
2129 int stackSize = keepStackSize(); 2985 int stackSize = keepStackSize();
2130 } 2986 }
2131: 2987:
2132( 2988(
2133 { before(grammarAccess.getBasicInterpretationAccess().getGroup_1()); } 2989 { before(grammarAccess.getDefaultDefinitionAccess().getHeadAssignment_1()); }
2134 (rule__BasicInterpretation__Group_1__0)? 2990 (rule__DefaultDefinition__HeadAssignment_1)
2135 { after(grammarAccess.getBasicInterpretationAccess().getGroup_1()); } 2991 { after(grammarAccess.getDefaultDefinitionAccess().getHeadAssignment_1()); }
2136) 2992)
2137; 2993;
2138finally { 2994finally {
2139 restoreStackSize(stackSize); 2995 restoreStackSize(stackSize);
2140} 2996}
2141 2997
2142rule__BasicInterpretation__Group__2 2998rule__DefaultDefinition__Group__2
2143 @init { 2999 @init {
2144 int stackSize = keepStackSize(); 3000 int stackSize = keepStackSize();
2145 } 3001 }
2146: 3002:
2147 rule__BasicInterpretation__Group__2__Impl 3003 rule__DefaultDefinition__Group__2__Impl
2148 rule__BasicInterpretation__Group__3 3004 rule__DefaultDefinition__Group__3
2149; 3005;
2150finally { 3006finally {
2151 restoreStackSize(stackSize); 3007 restoreStackSize(stackSize);
2152} 3008}
2153 3009
2154rule__BasicInterpretation__Group__2__Impl 3010rule__DefaultDefinition__Group__2__Impl
2155 @init { 3011 @init {
2156 int stackSize = keepStackSize(); 3012 int stackSize = keepStackSize();
2157 } 3013 }
2158: 3014:
2159( 3015(
2160 { before(grammarAccess.getBasicInterpretationAccess().getColonKeyword_2()); } 3016 { before(grammarAccess.getDefaultDefinitionAccess().getColonKeyword_2()); }
2161 ':' 3017 ':'
2162 { after(grammarAccess.getBasicInterpretationAccess().getColonKeyword_2()); } 3018 { after(grammarAccess.getDefaultDefinitionAccess().getColonKeyword_2()); }
2163) 3019)
2164; 3020;
2165finally { 3021finally {
2166 restoreStackSize(stackSize); 3022 restoreStackSize(stackSize);
2167} 3023}
2168 3024
2169rule__BasicInterpretation__Group__3 3025rule__DefaultDefinition__Group__3
2170 @init { 3026 @init {
2171 int stackSize = keepStackSize(); 3027 int stackSize = keepStackSize();
2172 } 3028 }
2173: 3029:
2174 rule__BasicInterpretation__Group__3__Impl 3030 rule__DefaultDefinition__Group__3__Impl
2175; 3031;
2176finally { 3032finally {
2177 restoreStackSize(stackSize); 3033 restoreStackSize(stackSize);
2178} 3034}
2179 3035
2180rule__BasicInterpretation__Group__3__Impl 3036rule__DefaultDefinition__Group__3__Impl
2181 @init { 3037 @init {
2182 int stackSize = keepStackSize(); 3038 int stackSize = keepStackSize();
2183 } 3039 }
2184: 3040:
2185( 3041(
2186 { before(grammarAccess.getBasicInterpretationAccess().getValueAssignment_3()); } 3042 { before(grammarAccess.getDefaultDefinitionAccess().getRangeAssignment_3()); }
2187 (rule__BasicInterpretation__ValueAssignment_3) 3043 (rule__DefaultDefinition__RangeAssignment_3)
2188 { after(grammarAccess.getBasicInterpretationAccess().getValueAssignment_3()); } 3044 { after(grammarAccess.getDefaultDefinitionAccess().getRangeAssignment_3()); }
2189) 3045)
2190; 3046;
2191finally { 3047finally {
@@ -2193,80 +3049,80 @@ finally {
2193} 3049}
2194 3050
2195 3051
2196rule__BasicInterpretation__Group_1__0 3052rule__ExternPredicateDefinition__Group__0
2197 @init { 3053 @init {
2198 int stackSize = keepStackSize(); 3054 int stackSize = keepStackSize();
2199 } 3055 }
2200: 3056:
2201 rule__BasicInterpretation__Group_1__0__Impl 3057 rule__ExternPredicateDefinition__Group__0__Impl
2202 rule__BasicInterpretation__Group_1__1 3058 rule__ExternPredicateDefinition__Group__1
2203; 3059;
2204finally { 3060finally {
2205 restoreStackSize(stackSize); 3061 restoreStackSize(stackSize);
2206} 3062}
2207 3063
2208rule__BasicInterpretation__Group_1__0__Impl 3064rule__ExternPredicateDefinition__Group__0__Impl
2209 @init { 3065 @init {
2210 int stackSize = keepStackSize(); 3066 int stackSize = keepStackSize();
2211 } 3067 }
2212: 3068:
2213( 3069(
2214 { before(grammarAccess.getBasicInterpretationAccess().getLeftParenthesisKeyword_1_0()); } 3070 { before(grammarAccess.getExternPredicateDefinitionAccess().getExternKeyword_0()); }
2215 '(' 3071 'extern'
2216 { after(grammarAccess.getBasicInterpretationAccess().getLeftParenthesisKeyword_1_0()); } 3072 { after(grammarAccess.getExternPredicateDefinitionAccess().getExternKeyword_0()); }
2217) 3073)
2218; 3074;
2219finally { 3075finally {
2220 restoreStackSize(stackSize); 3076 restoreStackSize(stackSize);
2221} 3077}
2222 3078
2223rule__BasicInterpretation__Group_1__1 3079rule__ExternPredicateDefinition__Group__1
2224 @init { 3080 @init {
2225 int stackSize = keepStackSize(); 3081 int stackSize = keepStackSize();
2226 } 3082 }
2227: 3083:
2228 rule__BasicInterpretation__Group_1__1__Impl 3084 rule__ExternPredicateDefinition__Group__1__Impl
2229 rule__BasicInterpretation__Group_1__2 3085 rule__ExternPredicateDefinition__Group__2
2230; 3086;
2231finally { 3087finally {
2232 restoreStackSize(stackSize); 3088 restoreStackSize(stackSize);
2233} 3089}
2234 3090
2235rule__BasicInterpretation__Group_1__1__Impl 3091rule__ExternPredicateDefinition__Group__1__Impl
2236 @init { 3092 @init {
2237 int stackSize = keepStackSize(); 3093 int stackSize = keepStackSize();
2238 } 3094 }
2239: 3095:
2240( 3096(
2241 { before(grammarAccess.getBasicInterpretationAccess().getGroup_1_1()); } 3097 { before(grammarAccess.getExternPredicateDefinitionAccess().getHeadAssignment_1()); }
2242 (rule__BasicInterpretation__Group_1_1__0)? 3098 (rule__ExternPredicateDefinition__HeadAssignment_1)
2243 { after(grammarAccess.getBasicInterpretationAccess().getGroup_1_1()); } 3099 { after(grammarAccess.getExternPredicateDefinitionAccess().getHeadAssignment_1()); }
2244) 3100)
2245; 3101;
2246finally { 3102finally {
2247 restoreStackSize(stackSize); 3103 restoreStackSize(stackSize);
2248} 3104}
2249 3105
2250rule__BasicInterpretation__Group_1__2 3106rule__ExternPredicateDefinition__Group__2
2251 @init { 3107 @init {
2252 int stackSize = keepStackSize(); 3108 int stackSize = keepStackSize();
2253 } 3109 }
2254: 3110:
2255 rule__BasicInterpretation__Group_1__2__Impl 3111 rule__ExternPredicateDefinition__Group__2__Impl
2256; 3112;
2257finally { 3113finally {
2258 restoreStackSize(stackSize); 3114 restoreStackSize(stackSize);
2259} 3115}
2260 3116
2261rule__BasicInterpretation__Group_1__2__Impl 3117rule__ExternPredicateDefinition__Group__2__Impl
2262 @init { 3118 @init {
2263 int stackSize = keepStackSize(); 3119 int stackSize = keepStackSize();
2264 } 3120 }
2265: 3121:
2266( 3122(
2267 { before(grammarAccess.getBasicInterpretationAccess().getRightParenthesisKeyword_1_2()); } 3123 { before(grammarAccess.getExternPredicateDefinitionAccess().getFullStopKeyword_2()); }
2268 ')' 3124 '.'
2269 { after(grammarAccess.getBasicInterpretationAccess().getRightParenthesisKeyword_1_2()); } 3125 { after(grammarAccess.getExternPredicateDefinitionAccess().getFullStopKeyword_2()); }
2270) 3126)
2271; 3127;
2272finally { 3128finally {
@@ -2274,107 +3130,188 @@ finally {
2274} 3130}
2275 3131
2276 3132
2277rule__BasicInterpretation__Group_1_1__0 3133rule__MetricDefinition__Group__0
2278 @init { 3134 @init {
2279 int stackSize = keepStackSize(); 3135 int stackSize = keepStackSize();
2280 } 3136 }
2281: 3137:
2282 rule__BasicInterpretation__Group_1_1__0__Impl 3138 rule__MetricDefinition__Group__0__Impl
2283 rule__BasicInterpretation__Group_1_1__1 3139 rule__MetricDefinition__Group__1
2284; 3140;
2285finally { 3141finally {
2286 restoreStackSize(stackSize); 3142 restoreStackSize(stackSize);
2287} 3143}
2288 3144
2289rule__BasicInterpretation__Group_1_1__0__Impl 3145rule__MetricDefinition__Group__0__Impl
2290 @init { 3146 @init {
2291 int stackSize = keepStackSize(); 3147 int stackSize = keepStackSize();
2292 } 3148 }
2293: 3149:
2294( 3150(
2295 { before(grammarAccess.getBasicInterpretationAccess().getObjectsAssignment_1_1_0()); } 3151 { before(grammarAccess.getMetricDefinitionAccess().getTypeAssignment_0()); }
2296 (rule__BasicInterpretation__ObjectsAssignment_1_1_0) 3152 (rule__MetricDefinition__TypeAssignment_0)
2297 { after(grammarAccess.getBasicInterpretationAccess().getObjectsAssignment_1_1_0()); } 3153 { after(grammarAccess.getMetricDefinitionAccess().getTypeAssignment_0()); }
2298) 3154)
2299; 3155;
2300finally { 3156finally {
2301 restoreStackSize(stackSize); 3157 restoreStackSize(stackSize);
2302} 3158}
2303 3159
2304rule__BasicInterpretation__Group_1_1__1 3160rule__MetricDefinition__Group__1
2305 @init { 3161 @init {
2306 int stackSize = keepStackSize(); 3162 int stackSize = keepStackSize();
2307 } 3163 }
2308: 3164:
2309 rule__BasicInterpretation__Group_1_1__1__Impl 3165 rule__MetricDefinition__Group__1__Impl
3166 rule__MetricDefinition__Group__2
2310; 3167;
2311finally { 3168finally {
2312 restoreStackSize(stackSize); 3169 restoreStackSize(stackSize);
2313} 3170}
2314 3171
2315rule__BasicInterpretation__Group_1_1__1__Impl 3172rule__MetricDefinition__Group__1__Impl
2316 @init { 3173 @init {
2317 int stackSize = keepStackSize(); 3174 int stackSize = keepStackSize();
2318 } 3175 }
2319: 3176:
2320( 3177(
2321 { before(grammarAccess.getBasicInterpretationAccess().getGroup_1_1_1()); } 3178 { before(grammarAccess.getMetricDefinitionAccess().getHeadAssignment_1()); }
2322 (rule__BasicInterpretation__Group_1_1_1__0)* 3179 (rule__MetricDefinition__HeadAssignment_1)
2323 { after(grammarAccess.getBasicInterpretationAccess().getGroup_1_1_1()); } 3180 { after(grammarAccess.getMetricDefinitionAccess().getHeadAssignment_1()); }
2324) 3181)
2325; 3182;
2326finally { 3183finally {
2327 restoreStackSize(stackSize); 3184 restoreStackSize(stackSize);
2328} 3185}
2329 3186
3187rule__MetricDefinition__Group__2
3188 @init {
3189 int stackSize = keepStackSize();
3190 }
3191:
3192 rule__MetricDefinition__Group__2__Impl
3193 rule__MetricDefinition__Group__3
3194;
3195finally {
3196 restoreStackSize(stackSize);
3197}
2330 3198
2331rule__BasicInterpretation__Group_1_1_1__0 3199rule__MetricDefinition__Group__2__Impl
2332 @init { 3200 @init {
2333 int stackSize = keepStackSize(); 3201 int stackSize = keepStackSize();
2334 } 3202 }
2335: 3203:
2336 rule__BasicInterpretation__Group_1_1_1__0__Impl 3204(
2337 rule__BasicInterpretation__Group_1_1_1__1 3205 { before(grammarAccess.getMetricDefinitionAccess().getEqualsSignKeyword_2()); }
3206 '='
3207 { after(grammarAccess.getMetricDefinitionAccess().getEqualsSignKeyword_2()); }
3208)
2338; 3209;
2339finally { 3210finally {
2340 restoreStackSize(stackSize); 3211 restoreStackSize(stackSize);
2341} 3212}
2342 3213
2343rule__BasicInterpretation__Group_1_1_1__0__Impl 3214rule__MetricDefinition__Group__3
3215 @init {
3216 int stackSize = keepStackSize();
3217 }
3218:
3219 rule__MetricDefinition__Group__3__Impl
3220;
3221finally {
3222 restoreStackSize(stackSize);
3223}
3224
3225rule__MetricDefinition__Group__3__Impl
2344 @init { 3226 @init {
2345 int stackSize = keepStackSize(); 3227 int stackSize = keepStackSize();
2346 } 3228 }
2347: 3229:
2348( 3230(
2349 { before(grammarAccess.getBasicInterpretationAccess().getCommaKeyword_1_1_1_0()); } 3231 { before(grammarAccess.getMetricDefinitionAccess().getBodyAssignment_3()); }
2350 ',' 3232 (rule__MetricDefinition__BodyAssignment_3)
2351 { after(grammarAccess.getBasicInterpretationAccess().getCommaKeyword_1_1_1_0()); } 3233 { after(grammarAccess.getMetricDefinitionAccess().getBodyAssignment_3()); }
3234)
3235;
3236finally {
3237 restoreStackSize(stackSize);
3238}
3239
3240
3241rule__ExternMetricDefinition__Group__0
3242 @init {
3243 int stackSize = keepStackSize();
3244 }
3245:
3246 rule__ExternMetricDefinition__Group__0__Impl
3247 rule__ExternMetricDefinition__Group__1
3248;
3249finally {
3250 restoreStackSize(stackSize);
3251}
3252
3253rule__ExternMetricDefinition__Group__0__Impl
3254 @init {
3255 int stackSize = keepStackSize();
3256 }
3257:
3258(
3259 { before(grammarAccess.getExternMetricDefinitionAccess().getExternKeyword_0()); }
3260 'extern'
3261 { after(grammarAccess.getExternMetricDefinitionAccess().getExternKeyword_0()); }
3262)
3263;
3264finally {
3265 restoreStackSize(stackSize);
3266}
3267
3268rule__ExternMetricDefinition__Group__1
3269 @init {
3270 int stackSize = keepStackSize();
3271 }
3272:
3273 rule__ExternMetricDefinition__Group__1__Impl
3274 rule__ExternMetricDefinition__Group__2
3275;
3276finally {
3277 restoreStackSize(stackSize);
3278}
3279
3280rule__ExternMetricDefinition__Group__1__Impl
3281 @init {
3282 int stackSize = keepStackSize();
3283 }
3284:
3285(
3286 { before(grammarAccess.getExternMetricDefinitionAccess().getTypeAssignment_1()); }
3287 (rule__ExternMetricDefinition__TypeAssignment_1)
3288 { after(grammarAccess.getExternMetricDefinitionAccess().getTypeAssignment_1()); }
2352) 3289)
2353; 3290;
2354finally { 3291finally {
2355 restoreStackSize(stackSize); 3292 restoreStackSize(stackSize);
2356} 3293}
2357 3294
2358rule__BasicInterpretation__Group_1_1_1__1 3295rule__ExternMetricDefinition__Group__2
2359 @init { 3296 @init {
2360 int stackSize = keepStackSize(); 3297 int stackSize = keepStackSize();
2361 } 3298 }
2362: 3299:
2363 rule__BasicInterpretation__Group_1_1_1__1__Impl 3300 rule__ExternMetricDefinition__Group__2__Impl
2364; 3301;
2365finally { 3302finally {
2366 restoreStackSize(stackSize); 3303 restoreStackSize(stackSize);
2367} 3304}
2368 3305
2369rule__BasicInterpretation__Group_1_1_1__1__Impl 3306rule__ExternMetricDefinition__Group__2__Impl
2370 @init { 3307 @init {
2371 int stackSize = keepStackSize(); 3308 int stackSize = keepStackSize();
2372 } 3309 }
2373: 3310:
2374( 3311(
2375 { before(grammarAccess.getBasicInterpretationAccess().getObjectsAssignment_1_1_1_1()); } 3312 { before(grammarAccess.getExternMetricDefinitionAccess().getHeadAssignment_2()); }
2376 (rule__BasicInterpretation__ObjectsAssignment_1_1_1_1) 3313 (rule__ExternMetricDefinition__HeadAssignment_2)
2377 { after(grammarAccess.getBasicInterpretationAccess().getObjectsAssignment_1_1_1_1()); } 3314 { after(grammarAccess.getExternMetricDefinitionAccess().getHeadAssignment_2()); }
2378) 3315)
2379; 3316;
2380finally { 3317finally {
@@ -2382,269 +3319,465 @@ finally {
2382} 3319}
2383 3320
2384 3321
2385rule__ExistSymbol__Group__0 3322rule__IfElse__Group__0
2386 @init { 3323 @init {
2387 int stackSize = keepStackSize(); 3324 int stackSize = keepStackSize();
2388 } 3325 }
2389: 3326:
2390 rule__ExistSymbol__Group__0__Impl 3327 rule__IfElse__Group__0__Impl
2391 rule__ExistSymbol__Group__1 3328 rule__IfElse__Group__1
2392; 3329;
2393finally { 3330finally {
2394 restoreStackSize(stackSize); 3331 restoreStackSize(stackSize);
2395} 3332}
2396 3333
2397rule__ExistSymbol__Group__0__Impl 3334rule__IfElse__Group__0__Impl
2398 @init { 3335 @init {
2399 int stackSize = keepStackSize(); 3336 int stackSize = keepStackSize();
2400 } 3337 }
2401: 3338:
2402( 3339(
2403 { before(grammarAccess.getExistSymbolAccess().getExistsKeyword_0()); } 3340 { before(grammarAccess.getIfElseAccess().getIfKeyword_0()); }
2404 'exists' 3341 'if'
2405 { after(grammarAccess.getExistSymbolAccess().getExistsKeyword_0()); } 3342 { after(grammarAccess.getIfElseAccess().getIfKeyword_0()); }
2406) 3343)
2407; 3344;
2408finally { 3345finally {
2409 restoreStackSize(stackSize); 3346 restoreStackSize(stackSize);
2410} 3347}
2411 3348
2412rule__ExistSymbol__Group__1 3349rule__IfElse__Group__1
2413 @init { 3350 @init {
2414 int stackSize = keepStackSize(); 3351 int stackSize = keepStackSize();
2415 } 3352 }
2416: 3353:
2417 rule__ExistSymbol__Group__1__Impl 3354 rule__IfElse__Group__1__Impl
3355 rule__IfElse__Group__2
2418; 3356;
2419finally { 3357finally {
2420 restoreStackSize(stackSize); 3358 restoreStackSize(stackSize);
2421} 3359}
2422 3360
2423rule__ExistSymbol__Group__1__Impl 3361rule__IfElse__Group__1__Impl
2424 @init { 3362 @init {
2425 int stackSize = keepStackSize(); 3363 int stackSize = keepStackSize();
2426 } 3364 }
2427: 3365:
2428( 3366(
2429 { before(grammarAccess.getExistSymbolAccess().getExistSymbolAction_1()); } 3367 { before(grammarAccess.getIfElseAccess().getConditionAssignment_1()); }
2430 () 3368 (rule__IfElse__ConditionAssignment_1)
2431 { after(grammarAccess.getExistSymbolAccess().getExistSymbolAction_1()); } 3369 { after(grammarAccess.getIfElseAccess().getConditionAssignment_1()); }
2432) 3370)
2433; 3371;
2434finally { 3372finally {
2435 restoreStackSize(stackSize); 3373 restoreStackSize(stackSize);
2436} 3374}
2437 3375
3376rule__IfElse__Group__2
3377 @init {
3378 int stackSize = keepStackSize();
3379 }
3380:
3381 rule__IfElse__Group__2__Impl
3382 rule__IfElse__Group__3
3383;
3384finally {
3385 restoreStackSize(stackSize);
3386}
2438 3387
2439rule__EqualsSymbol__Group__0 3388rule__IfElse__Group__2__Impl
2440 @init { 3389 @init {
2441 int stackSize = keepStackSize(); 3390 int stackSize = keepStackSize();
2442 } 3391 }
2443: 3392:
2444 rule__EqualsSymbol__Group__0__Impl 3393(
2445 rule__EqualsSymbol__Group__1 3394 { before(grammarAccess.getIfElseAccess().getThenKeyword_2()); }
3395 'then'
3396 { after(grammarAccess.getIfElseAccess().getThenKeyword_2()); }
3397)
2446; 3398;
2447finally { 3399finally {
2448 restoreStackSize(stackSize); 3400 restoreStackSize(stackSize);
2449} 3401}
2450 3402
2451rule__EqualsSymbol__Group__0__Impl 3403rule__IfElse__Group__3
3404 @init {
3405 int stackSize = keepStackSize();
3406 }
3407:
3408 rule__IfElse__Group__3__Impl
3409 rule__IfElse__Group__4
3410;
3411finally {
3412 restoreStackSize(stackSize);
3413}
3414
3415rule__IfElse__Group__3__Impl
2452 @init { 3416 @init {
2453 int stackSize = keepStackSize(); 3417 int stackSize = keepStackSize();
2454 } 3418 }
2455: 3419:
2456( 3420(
2457 { before(grammarAccess.getEqualsSymbolAccess().getEqualsKeyword_0()); } 3421 { before(grammarAccess.getIfElseAccess().getThenAssignment_3()); }
2458 'equals' 3422 (rule__IfElse__ThenAssignment_3)
2459 { after(grammarAccess.getEqualsSymbolAccess().getEqualsKeyword_0()); } 3423 { after(grammarAccess.getIfElseAccess().getThenAssignment_3()); }
2460) 3424)
2461; 3425;
2462finally { 3426finally {
2463 restoreStackSize(stackSize); 3427 restoreStackSize(stackSize);
2464} 3428}
2465 3429
2466rule__EqualsSymbol__Group__1 3430rule__IfElse__Group__4
2467 @init { 3431 @init {
2468 int stackSize = keepStackSize(); 3432 int stackSize = keepStackSize();
2469 } 3433 }
2470: 3434:
2471 rule__EqualsSymbol__Group__1__Impl 3435 rule__IfElse__Group__4__Impl
3436 rule__IfElse__Group__5
2472; 3437;
2473finally { 3438finally {
2474 restoreStackSize(stackSize); 3439 restoreStackSize(stackSize);
2475} 3440}
2476 3441
2477rule__EqualsSymbol__Group__1__Impl 3442rule__IfElse__Group__4__Impl
2478 @init { 3443 @init {
2479 int stackSize = keepStackSize(); 3444 int stackSize = keepStackSize();
2480 } 3445 }
2481: 3446:
2482( 3447(
2483 { before(grammarAccess.getEqualsSymbolAccess().getEqualsSymbolAction_1()); } 3448 { before(grammarAccess.getIfElseAccess().getElseKeyword_4()); }
2484 () 3449 'else'
2485 { after(grammarAccess.getEqualsSymbolAccess().getEqualsSymbolAction_1()); } 3450 { after(grammarAccess.getIfElseAccess().getElseKeyword_4()); }
2486) 3451)
2487; 3452;
2488finally { 3453finally {
2489 restoreStackSize(stackSize); 3454 restoreStackSize(stackSize);
2490} 3455}
2491 3456
3457rule__IfElse__Group__5
3458 @init {
3459 int stackSize = keepStackSize();
3460 }
3461:
3462 rule__IfElse__Group__5__Impl
3463;
3464finally {
3465 restoreStackSize(stackSize);
3466}
2492 3467
2493rule__BooleanSymbol__Group__0 3468rule__IfElse__Group__5__Impl
2494 @init { 3469 @init {
2495 int stackSize = keepStackSize(); 3470 int stackSize = keepStackSize();
2496 } 3471 }
2497: 3472:
2498 rule__BooleanSymbol__Group__0__Impl 3473(
2499 rule__BooleanSymbol__Group__1 3474 { before(grammarAccess.getIfElseAccess().getElseAssignment_5()); }
3475 (rule__IfElse__ElseAssignment_5)
3476 { after(grammarAccess.getIfElseAccess().getElseAssignment_5()); }
3477)
2500; 3478;
2501finally { 3479finally {
2502 restoreStackSize(stackSize); 3480 restoreStackSize(stackSize);
2503} 3481}
2504 3482
2505rule__BooleanSymbol__Group__0__Impl 3483
3484rule__DisjunctiveExpression__Group__0
3485 @init {
3486 int stackSize = keepStackSize();
3487 }
3488:
3489 rule__DisjunctiveExpression__Group__0__Impl
3490 rule__DisjunctiveExpression__Group__1
3491;
3492finally {
3493 restoreStackSize(stackSize);
3494}
3495
3496rule__DisjunctiveExpression__Group__0__Impl
2506 @init { 3497 @init {
2507 int stackSize = keepStackSize(); 3498 int stackSize = keepStackSize();
2508 } 3499 }
2509: 3500:
2510( 3501(
2511 { before(grammarAccess.getBooleanSymbolAccess().getBoolKeyword_0()); } 3502 { before(grammarAccess.getDisjunctiveExpressionAccess().getConjunctiveExpressionParserRuleCall_0()); }
2512 'bool' 3503 ruleConjunctiveExpression
2513 { after(grammarAccess.getBooleanSymbolAccess().getBoolKeyword_0()); } 3504 { after(grammarAccess.getDisjunctiveExpressionAccess().getConjunctiveExpressionParserRuleCall_0()); }
2514) 3505)
2515; 3506;
2516finally { 3507finally {
2517 restoreStackSize(stackSize); 3508 restoreStackSize(stackSize);
2518} 3509}
2519 3510
2520rule__BooleanSymbol__Group__1 3511rule__DisjunctiveExpression__Group__1
2521 @init { 3512 @init {
2522 int stackSize = keepStackSize(); 3513 int stackSize = keepStackSize();
2523 } 3514 }
2524: 3515:
2525 rule__BooleanSymbol__Group__1__Impl 3516 rule__DisjunctiveExpression__Group__1__Impl
2526; 3517;
2527finally { 3518finally {
2528 restoreStackSize(stackSize); 3519 restoreStackSize(stackSize);
2529} 3520}
2530 3521
2531rule__BooleanSymbol__Group__1__Impl 3522rule__DisjunctiveExpression__Group__1__Impl
2532 @init { 3523 @init {
2533 int stackSize = keepStackSize(); 3524 int stackSize = keepStackSize();
2534 } 3525 }
2535: 3526:
2536( 3527(
2537 { before(grammarAccess.getBooleanSymbolAccess().getBooleanSymbolAction_1()); } 3528 { before(grammarAccess.getDisjunctiveExpressionAccess().getAlternatives_1()); }
3529 (rule__DisjunctiveExpression__Alternatives_1)?
3530 { after(grammarAccess.getDisjunctiveExpressionAccess().getAlternatives_1()); }
3531)
3532;
3533finally {
3534 restoreStackSize(stackSize);
3535}
3536
3537
3538rule__DisjunctiveExpression__Group_1_0__0
3539 @init {
3540 int stackSize = keepStackSize();
3541 }
3542:
3543 rule__DisjunctiveExpression__Group_1_0__0__Impl
3544 rule__DisjunctiveExpression__Group_1_0__1
3545;
3546finally {
3547 restoreStackSize(stackSize);
3548}
3549
3550rule__DisjunctiveExpression__Group_1_0__0__Impl
3551 @init {
3552 int stackSize = keepStackSize();
3553 }
3554:
3555(
3556 { before(grammarAccess.getDisjunctiveExpressionAccess().getDisjunctionChildrenAction_1_0_0()); }
2538 () 3557 ()
2539 { after(grammarAccess.getBooleanSymbolAccess().getBooleanSymbolAction_1()); } 3558 { after(grammarAccess.getDisjunctiveExpressionAccess().getDisjunctionChildrenAction_1_0_0()); }
2540) 3559)
2541; 3560;
2542finally { 3561finally {
2543 restoreStackSize(stackSize); 3562 restoreStackSize(stackSize);
2544} 3563}
2545 3564
3565rule__DisjunctiveExpression__Group_1_0__1
3566 @init {
3567 int stackSize = keepStackSize();
3568 }
3569:
3570 rule__DisjunctiveExpression__Group_1_0__1__Impl
3571;
3572finally {
3573 restoreStackSize(stackSize);
3574}
3575
3576rule__DisjunctiveExpression__Group_1_0__1__Impl
3577 @init {
3578 int stackSize = keepStackSize();
3579 }
3580:
3581(
3582 (
3583 { before(grammarAccess.getDisjunctiveExpressionAccess().getGroup_1_0_1()); }
3584 (rule__DisjunctiveExpression__Group_1_0_1__0)
3585 { after(grammarAccess.getDisjunctiveExpressionAccess().getGroup_1_0_1()); }
3586 )
3587 (
3588 { before(grammarAccess.getDisjunctiveExpressionAccess().getGroup_1_0_1()); }
3589 (rule__DisjunctiveExpression__Group_1_0_1__0)*
3590 { after(grammarAccess.getDisjunctiveExpressionAccess().getGroup_1_0_1()); }
3591 )
3592)
3593;
3594finally {
3595 restoreStackSize(stackSize);
3596}
3597
3598
3599rule__DisjunctiveExpression__Group_1_0_1__0
3600 @init {
3601 int stackSize = keepStackSize();
3602 }
3603:
3604 rule__DisjunctiveExpression__Group_1_0_1__0__Impl
3605 rule__DisjunctiveExpression__Group_1_0_1__1
3606;
3607finally {
3608 restoreStackSize(stackSize);
3609}
3610
3611rule__DisjunctiveExpression__Group_1_0_1__0__Impl
3612 @init {
3613 int stackSize = keepStackSize();
3614 }
3615:
3616(
3617 { before(grammarAccess.getDisjunctiveExpressionAccess().getSemicolonKeyword_1_0_1_0()); }
3618 ';'
3619 { after(grammarAccess.getDisjunctiveExpressionAccess().getSemicolonKeyword_1_0_1_0()); }
3620)
3621;
3622finally {
3623 restoreStackSize(stackSize);
3624}
2546 3625
2547rule__IntegerSymbol__Group__0 3626rule__DisjunctiveExpression__Group_1_0_1__1
2548 @init { 3627 @init {
2549 int stackSize = keepStackSize(); 3628 int stackSize = keepStackSize();
2550 } 3629 }
2551: 3630:
2552 rule__IntegerSymbol__Group__0__Impl 3631 rule__DisjunctiveExpression__Group_1_0_1__1__Impl
2553 rule__IntegerSymbol__Group__1
2554; 3632;
2555finally { 3633finally {
2556 restoreStackSize(stackSize); 3634 restoreStackSize(stackSize);
2557} 3635}
2558 3636
2559rule__IntegerSymbol__Group__0__Impl 3637rule__DisjunctiveExpression__Group_1_0_1__1__Impl
2560 @init { 3638 @init {
2561 int stackSize = keepStackSize(); 3639 int stackSize = keepStackSize();
2562 } 3640 }
2563: 3641:
2564( 3642(
2565 { before(grammarAccess.getIntegerSymbolAccess().getIntKeyword_0()); } 3643 { before(grammarAccess.getDisjunctiveExpressionAccess().getChildrenAssignment_1_0_1_1()); }
2566 'int' 3644 (rule__DisjunctiveExpression__ChildrenAssignment_1_0_1_1)
2567 { after(grammarAccess.getIntegerSymbolAccess().getIntKeyword_0()); } 3645 { after(grammarAccess.getDisjunctiveExpressionAccess().getChildrenAssignment_1_0_1_1()); }
2568) 3646)
2569; 3647;
2570finally { 3648finally {
2571 restoreStackSize(stackSize); 3649 restoreStackSize(stackSize);
2572} 3650}
2573 3651
2574rule__IntegerSymbol__Group__1 3652
3653rule__DisjunctiveExpression__Group_1_1__0
2575 @init { 3654 @init {
2576 int stackSize = keepStackSize(); 3655 int stackSize = keepStackSize();
2577 } 3656 }
2578: 3657:
2579 rule__IntegerSymbol__Group__1__Impl 3658 rule__DisjunctiveExpression__Group_1_1__0__Impl
3659 rule__DisjunctiveExpression__Group_1_1__1
2580; 3660;
2581finally { 3661finally {
2582 restoreStackSize(stackSize); 3662 restoreStackSize(stackSize);
2583} 3663}
2584 3664
2585rule__IntegerSymbol__Group__1__Impl 3665rule__DisjunctiveExpression__Group_1_1__0__Impl
2586 @init { 3666 @init {
2587 int stackSize = keepStackSize(); 3667 int stackSize = keepStackSize();
2588 } 3668 }
2589: 3669:
2590( 3670(
2591 { before(grammarAccess.getIntegerSymbolAccess().getIntegerSymbolAction_1()); } 3671 { before(grammarAccess.getDisjunctiveExpressionAccess().getCaseConditionAction_1_1_0()); }
2592 () 3672 ()
2593 { after(grammarAccess.getIntegerSymbolAccess().getIntegerSymbolAction_1()); } 3673 { after(grammarAccess.getDisjunctiveExpressionAccess().getCaseConditionAction_1_1_0()); }
2594) 3674)
2595; 3675;
2596finally { 3676finally {
2597 restoreStackSize(stackSize); 3677 restoreStackSize(stackSize);
2598} 3678}
2599 3679
3680rule__DisjunctiveExpression__Group_1_1__1
3681 @init {
3682 int stackSize = keepStackSize();
3683 }
3684:
3685 rule__DisjunctiveExpression__Group_1_1__1__Impl
3686 rule__DisjunctiveExpression__Group_1_1__2
3687;
3688finally {
3689 restoreStackSize(stackSize);
3690}
2600 3691
2601rule__RealSymbol__Group__0 3692rule__DisjunctiveExpression__Group_1_1__1__Impl
2602 @init { 3693 @init {
2603 int stackSize = keepStackSize(); 3694 int stackSize = keepStackSize();
2604 } 3695 }
2605: 3696:
2606 rule__RealSymbol__Group__0__Impl 3697(
2607 rule__RealSymbol__Group__1 3698 { before(grammarAccess.getDisjunctiveExpressionAccess().getHyphenMinusGreaterThanSignKeyword_1_1_1()); }
3699 '->'
3700 { after(grammarAccess.getDisjunctiveExpressionAccess().getHyphenMinusGreaterThanSignKeyword_1_1_1()); }
3701)
2608; 3702;
2609finally { 3703finally {
2610 restoreStackSize(stackSize); 3704 restoreStackSize(stackSize);
2611} 3705}
2612 3706
2613rule__RealSymbol__Group__0__Impl 3707rule__DisjunctiveExpression__Group_1_1__2
3708 @init {
3709 int stackSize = keepStackSize();
3710 }
3711:
3712 rule__DisjunctiveExpression__Group_1_1__2__Impl
3713 rule__DisjunctiveExpression__Group_1_1__3
3714;
3715finally {
3716 restoreStackSize(stackSize);
3717}
3718
3719rule__DisjunctiveExpression__Group_1_1__2__Impl
2614 @init { 3720 @init {
2615 int stackSize = keepStackSize(); 3721 int stackSize = keepStackSize();
2616 } 3722 }
2617: 3723:
2618( 3724(
2619 { before(grammarAccess.getRealSymbolAccess().getRealKeyword_0()); } 3725 { before(grammarAccess.getDisjunctiveExpressionAccess().getBodyAssignment_1_1_2()); }
2620 'real' 3726 (rule__DisjunctiveExpression__BodyAssignment_1_1_2)
2621 { after(grammarAccess.getRealSymbolAccess().getRealKeyword_0()); } 3727 { after(grammarAccess.getDisjunctiveExpressionAccess().getBodyAssignment_1_1_2()); }
2622) 3728)
2623; 3729;
2624finally { 3730finally {
2625 restoreStackSize(stackSize); 3731 restoreStackSize(stackSize);
2626} 3732}
2627 3733
2628rule__RealSymbol__Group__1 3734rule__DisjunctiveExpression__Group_1_1__3
2629 @init { 3735 @init {
2630 int stackSize = keepStackSize(); 3736 int stackSize = keepStackSize();
2631 } 3737 }
2632: 3738:
2633 rule__RealSymbol__Group__1__Impl 3739 rule__DisjunctiveExpression__Group_1_1__3__Impl
3740 rule__DisjunctiveExpression__Group_1_1__4
2634; 3741;
2635finally { 3742finally {
2636 restoreStackSize(stackSize); 3743 restoreStackSize(stackSize);
2637} 3744}
2638 3745
2639rule__RealSymbol__Group__1__Impl 3746rule__DisjunctiveExpression__Group_1_1__3__Impl
2640 @init { 3747 @init {
2641 int stackSize = keepStackSize(); 3748 int stackSize = keepStackSize();
2642 } 3749 }
2643: 3750:
2644( 3751(
2645 { before(grammarAccess.getRealSymbolAccess().getRealSymbolAction_1()); } 3752 { before(grammarAccess.getDisjunctiveExpressionAccess().getSwitchCasesAction_1_1_3()); }
2646 () 3753 ()
2647 { after(grammarAccess.getRealSymbolAccess().getRealSymbolAction_1()); } 3754 { after(grammarAccess.getDisjunctiveExpressionAccess().getSwitchCasesAction_1_1_3()); }
3755)
3756;
3757finally {
3758 restoreStackSize(stackSize);
3759}
3760
3761rule__DisjunctiveExpression__Group_1_1__4
3762 @init {
3763 int stackSize = keepStackSize();
3764 }
3765:
3766 rule__DisjunctiveExpression__Group_1_1__4__Impl
3767;
3768finally {
3769 restoreStackSize(stackSize);
3770}
3771
3772rule__DisjunctiveExpression__Group_1_1__4__Impl
3773 @init {
3774 int stackSize = keepStackSize();
3775 }
3776:
3777(
3778 { before(grammarAccess.getDisjunctiveExpressionAccess().getGroup_1_1_4()); }
3779 (rule__DisjunctiveExpression__Group_1_1_4__0)*
3780 { after(grammarAccess.getDisjunctiveExpressionAccess().getGroup_1_1_4()); }
2648) 3781)
2649; 3782;
2650finally { 3783finally {
@@ -2652,53 +3785,53 @@ finally {
2652} 3785}
2653 3786
2654 3787
2655rule__StringSymbol__Group__0 3788rule__DisjunctiveExpression__Group_1_1_4__0
2656 @init { 3789 @init {
2657 int stackSize = keepStackSize(); 3790 int stackSize = keepStackSize();
2658 } 3791 }
2659: 3792:
2660 rule__StringSymbol__Group__0__Impl 3793 rule__DisjunctiveExpression__Group_1_1_4__0__Impl
2661 rule__StringSymbol__Group__1 3794 rule__DisjunctiveExpression__Group_1_1_4__1
2662; 3795;
2663finally { 3796finally {
2664 restoreStackSize(stackSize); 3797 restoreStackSize(stackSize);
2665} 3798}
2666 3799
2667rule__StringSymbol__Group__0__Impl 3800rule__DisjunctiveExpression__Group_1_1_4__0__Impl
2668 @init { 3801 @init {
2669 int stackSize = keepStackSize(); 3802 int stackSize = keepStackSize();
2670 } 3803 }
2671: 3804:
2672( 3805(
2673 { before(grammarAccess.getStringSymbolAccess().getStringKeyword_0()); } 3806 { before(grammarAccess.getDisjunctiveExpressionAccess().getSemicolonKeyword_1_1_4_0()); }
2674 'string' 3807 ';'
2675 { after(grammarAccess.getStringSymbolAccess().getStringKeyword_0()); } 3808 { after(grammarAccess.getDisjunctiveExpressionAccess().getSemicolonKeyword_1_1_4_0()); }
2676) 3809)
2677; 3810;
2678finally { 3811finally {
2679 restoreStackSize(stackSize); 3812 restoreStackSize(stackSize);
2680} 3813}
2681 3814
2682rule__StringSymbol__Group__1 3815rule__DisjunctiveExpression__Group_1_1_4__1
2683 @init { 3816 @init {
2684 int stackSize = keepStackSize(); 3817 int stackSize = keepStackSize();
2685 } 3818 }
2686: 3819:
2687 rule__StringSymbol__Group__1__Impl 3820 rule__DisjunctiveExpression__Group_1_1_4__1__Impl
2688; 3821;
2689finally { 3822finally {
2690 restoreStackSize(stackSize); 3823 restoreStackSize(stackSize);
2691} 3824}
2692 3825
2693rule__StringSymbol__Group__1__Impl 3826rule__DisjunctiveExpression__Group_1_1_4__1__Impl
2694 @init { 3827 @init {
2695 int stackSize = keepStackSize(); 3828 int stackSize = keepStackSize();
2696 } 3829 }
2697: 3830:
2698( 3831(
2699 { before(grammarAccess.getStringSymbolAccess().getStringSymbolAction_1()); } 3832 { before(grammarAccess.getDisjunctiveExpressionAccess().getCasesAssignment_1_1_4_1()); }
2700 () 3833 (rule__DisjunctiveExpression__CasesAssignment_1_1_4_1)
2701 { after(grammarAccess.getStringSymbolAccess().getStringSymbolAction_1()); } 3834 { after(grammarAccess.getDisjunctiveExpressionAccess().getCasesAssignment_1_1_4_1()); }
2702) 3835)
2703; 3836;
2704finally { 3837finally {
@@ -2706,80 +3839,80 @@ finally {
2706} 3839}
2707 3840
2708 3841
2709rule__NamedObject__Group__0 3842rule__Case__Group__0
2710 @init { 3843 @init {
2711 int stackSize = keepStackSize(); 3844 int stackSize = keepStackSize();
2712 } 3845 }
2713: 3846:
2714 rule__NamedObject__Group__0__Impl 3847 rule__Case__Group__0__Impl
2715 rule__NamedObject__Group__1 3848 rule__Case__Group__1
2716; 3849;
2717finally { 3850finally {
2718 restoreStackSize(stackSize); 3851 restoreStackSize(stackSize);
2719} 3852}
2720 3853
2721rule__NamedObject__Group__0__Impl 3854rule__Case__Group__0__Impl
2722 @init { 3855 @init {
2723 int stackSize = keepStackSize(); 3856 int stackSize = keepStackSize();
2724 } 3857 }
2725: 3858:
2726( 3859(
2727 { before(grammarAccess.getNamedObjectAccess().getApostropheKeyword_0()); } 3860 { before(grammarAccess.getCaseAccess().getConditionAssignment_0()); }
2728 '\'' 3861 (rule__Case__ConditionAssignment_0)
2729 { after(grammarAccess.getNamedObjectAccess().getApostropheKeyword_0()); } 3862 { after(grammarAccess.getCaseAccess().getConditionAssignment_0()); }
2730) 3863)
2731; 3864;
2732finally { 3865finally {
2733 restoreStackSize(stackSize); 3866 restoreStackSize(stackSize);
2734} 3867}
2735 3868
2736rule__NamedObject__Group__1 3869rule__Case__Group__1
2737 @init { 3870 @init {
2738 int stackSize = keepStackSize(); 3871 int stackSize = keepStackSize();
2739 } 3872 }
2740: 3873:
2741 rule__NamedObject__Group__1__Impl 3874 rule__Case__Group__1__Impl
2742 rule__NamedObject__Group__2 3875 rule__Case__Group__2
2743; 3876;
2744finally { 3877finally {
2745 restoreStackSize(stackSize); 3878 restoreStackSize(stackSize);
2746} 3879}
2747 3880
2748rule__NamedObject__Group__1__Impl 3881rule__Case__Group__1__Impl
2749 @init { 3882 @init {
2750 int stackSize = keepStackSize(); 3883 int stackSize = keepStackSize();
2751 } 3884 }
2752: 3885:
2753( 3886(
2754 { before(grammarAccess.getNamedObjectAccess().getNameAssignment_1()); } 3887 { before(grammarAccess.getCaseAccess().getHyphenMinusGreaterThanSignKeyword_1()); }
2755 (rule__NamedObject__NameAssignment_1) 3888 '->'
2756 { after(grammarAccess.getNamedObjectAccess().getNameAssignment_1()); } 3889 { after(grammarAccess.getCaseAccess().getHyphenMinusGreaterThanSignKeyword_1()); }
2757) 3890)
2758; 3891;
2759finally { 3892finally {
2760 restoreStackSize(stackSize); 3893 restoreStackSize(stackSize);
2761} 3894}
2762 3895
2763rule__NamedObject__Group__2 3896rule__Case__Group__2
2764 @init { 3897 @init {
2765 int stackSize = keepStackSize(); 3898 int stackSize = keepStackSize();
2766 } 3899 }
2767: 3900:
2768 rule__NamedObject__Group__2__Impl 3901 rule__Case__Group__2__Impl
2769; 3902;
2770finally { 3903finally {
2771 restoreStackSize(stackSize); 3904 restoreStackSize(stackSize);
2772} 3905}
2773 3906
2774rule__NamedObject__Group__2__Impl 3907rule__Case__Group__2__Impl
2775 @init { 3908 @init {
2776 int stackSize = keepStackSize(); 3909 int stackSize = keepStackSize();
2777 } 3910 }
2778: 3911:
2779( 3912(
2780 { before(grammarAccess.getNamedObjectAccess().getApostropheKeyword_2()); } 3913 { before(grammarAccess.getCaseAccess().getBodyAssignment_2()); }
2781 '\'' 3914 (rule__Case__BodyAssignment_2)
2782 { after(grammarAccess.getNamedObjectAccess().getApostropheKeyword_2()); } 3915 { after(grammarAccess.getCaseAccess().getBodyAssignment_2()); }
2783) 3916)
2784; 3917;
2785finally { 3918finally {
@@ -2787,161 +3920,168 @@ finally {
2787} 3920}
2788 3921
2789 3922
2790rule__Predicate__Group__0 3923rule__ConjunctiveExpression__Group__0
2791 @init { 3924 @init {
2792 int stackSize = keepStackSize(); 3925 int stackSize = keepStackSize();
2793 } 3926 }
2794: 3927:
2795 rule__Predicate__Group__0__Impl 3928 rule__ConjunctiveExpression__Group__0__Impl
2796 rule__Predicate__Group__1 3929 rule__ConjunctiveExpression__Group__1
2797; 3930;
2798finally { 3931finally {
2799 restoreStackSize(stackSize); 3932 restoreStackSize(stackSize);
2800} 3933}
2801 3934
2802rule__Predicate__Group__0__Impl 3935rule__ConjunctiveExpression__Group__0__Impl
2803 @init { 3936 @init {
2804 int stackSize = keepStackSize(); 3937 int stackSize = keepStackSize();
2805 } 3938 }
2806: 3939:
2807( 3940(
2808 { before(grammarAccess.getPredicateAccess().getIsErrorAssignment_0()); } 3941 { before(grammarAccess.getConjunctiveExpressionAccess().getComparisonExpressionParserRuleCall_0()); }
2809 (rule__Predicate__IsErrorAssignment_0)? 3942 ruleComparisonExpression
2810 { after(grammarAccess.getPredicateAccess().getIsErrorAssignment_0()); } 3943 { after(grammarAccess.getConjunctiveExpressionAccess().getComparisonExpressionParserRuleCall_0()); }
2811) 3944)
2812; 3945;
2813finally { 3946finally {
2814 restoreStackSize(stackSize); 3947 restoreStackSize(stackSize);
2815} 3948}
2816 3949
2817rule__Predicate__Group__1 3950rule__ConjunctiveExpression__Group__1
2818 @init { 3951 @init {
2819 int stackSize = keepStackSize(); 3952 int stackSize = keepStackSize();
2820 } 3953 }
2821: 3954:
2822 rule__Predicate__Group__1__Impl 3955 rule__ConjunctiveExpression__Group__1__Impl
2823 rule__Predicate__Group__2
2824; 3956;
2825finally { 3957finally {
2826 restoreStackSize(stackSize); 3958 restoreStackSize(stackSize);
2827} 3959}
2828 3960
2829rule__Predicate__Group__1__Impl 3961rule__ConjunctiveExpression__Group__1__Impl
2830 @init { 3962 @init {
2831 int stackSize = keepStackSize(); 3963 int stackSize = keepStackSize();
2832 } 3964 }
2833: 3965:
2834( 3966(
2835 { before(grammarAccess.getPredicateAccess().getSymbolAssignment_1()); } 3967 { before(grammarAccess.getConjunctiveExpressionAccess().getGroup_1()); }
2836 (rule__Predicate__SymbolAssignment_1) 3968 (rule__ConjunctiveExpression__Group_1__0)?
2837 { after(grammarAccess.getPredicateAccess().getSymbolAssignment_1()); } 3969 { after(grammarAccess.getConjunctiveExpressionAccess().getGroup_1()); }
2838) 3970)
2839; 3971;
2840finally { 3972finally {
2841 restoreStackSize(stackSize); 3973 restoreStackSize(stackSize);
2842} 3974}
2843 3975
2844rule__Predicate__Group__2 3976
3977rule__ConjunctiveExpression__Group_1__0
2845 @init { 3978 @init {
2846 int stackSize = keepStackSize(); 3979 int stackSize = keepStackSize();
2847 } 3980 }
2848: 3981:
2849 rule__Predicate__Group__2__Impl 3982 rule__ConjunctiveExpression__Group_1__0__Impl
2850 rule__Predicate__Group__3 3983 rule__ConjunctiveExpression__Group_1__1
2851; 3984;
2852finally { 3985finally {
2853 restoreStackSize(stackSize); 3986 restoreStackSize(stackSize);
2854} 3987}
2855 3988
2856rule__Predicate__Group__2__Impl 3989rule__ConjunctiveExpression__Group_1__0__Impl
2857 @init { 3990 @init {
2858 int stackSize = keepStackSize(); 3991 int stackSize = keepStackSize();
2859 } 3992 }
2860: 3993:
2861( 3994(
2862 { before(grammarAccess.getPredicateAccess().getGroup_2()); } 3995 { before(grammarAccess.getConjunctiveExpressionAccess().getConjunctionChildrenAction_1_0()); }
2863 (rule__Predicate__Group_2__0)? 3996 ()
2864 { after(grammarAccess.getPredicateAccess().getGroup_2()); } 3997 { after(grammarAccess.getConjunctiveExpressionAccess().getConjunctionChildrenAction_1_0()); }
2865) 3998)
2866; 3999;
2867finally { 4000finally {
2868 restoreStackSize(stackSize); 4001 restoreStackSize(stackSize);
2869} 4002}
2870 4003
2871rule__Predicate__Group__3 4004rule__ConjunctiveExpression__Group_1__1
2872 @init { 4005 @init {
2873 int stackSize = keepStackSize(); 4006 int stackSize = keepStackSize();
2874 } 4007 }
2875: 4008:
2876 rule__Predicate__Group__3__Impl 4009 rule__ConjunctiveExpression__Group_1__1__Impl
2877 rule__Predicate__Group__4
2878; 4010;
2879finally { 4011finally {
2880 restoreStackSize(stackSize); 4012 restoreStackSize(stackSize);
2881} 4013}
2882 4014
2883rule__Predicate__Group__3__Impl 4015rule__ConjunctiveExpression__Group_1__1__Impl
2884 @init { 4016 @init {
2885 int stackSize = keepStackSize(); 4017 int stackSize = keepStackSize();
2886 } 4018 }
2887: 4019:
2888( 4020(
2889 { before(grammarAccess.getPredicateAccess().getColonHyphenMinusKeyword_3()); } 4021 (
2890 ':-' 4022 { before(grammarAccess.getConjunctiveExpressionAccess().getGroup_1_1()); }
2891 { after(grammarAccess.getPredicateAccess().getColonHyphenMinusKeyword_3()); } 4023 (rule__ConjunctiveExpression__Group_1_1__0)
4024 { after(grammarAccess.getConjunctiveExpressionAccess().getGroup_1_1()); }
4025 )
4026 (
4027 { before(grammarAccess.getConjunctiveExpressionAccess().getGroup_1_1()); }
4028 (rule__ConjunctiveExpression__Group_1_1__0)*
4029 { after(grammarAccess.getConjunctiveExpressionAccess().getGroup_1_1()); }
4030 )
2892) 4031)
2893; 4032;
2894finally { 4033finally {
2895 restoreStackSize(stackSize); 4034 restoreStackSize(stackSize);
2896} 4035}
2897 4036
2898rule__Predicate__Group__4 4037
4038rule__ConjunctiveExpression__Group_1_1__0
2899 @init { 4039 @init {
2900 int stackSize = keepStackSize(); 4040 int stackSize = keepStackSize();
2901 } 4041 }
2902: 4042:
2903 rule__Predicate__Group__4__Impl 4043 rule__ConjunctiveExpression__Group_1_1__0__Impl
2904 rule__Predicate__Group__5 4044 rule__ConjunctiveExpression__Group_1_1__1
2905; 4045;
2906finally { 4046finally {
2907 restoreStackSize(stackSize); 4047 restoreStackSize(stackSize);
2908} 4048}
2909 4049
2910rule__Predicate__Group__4__Impl 4050rule__ConjunctiveExpression__Group_1_1__0__Impl
2911 @init { 4051 @init {
2912 int stackSize = keepStackSize(); 4052 int stackSize = keepStackSize();
2913 } 4053 }
2914: 4054:
2915( 4055(
2916 { before(grammarAccess.getPredicateAccess().getAlternatives_4()); } 4056 { before(grammarAccess.getConjunctiveExpressionAccess().getCommaKeyword_1_1_0()); }
2917 (rule__Predicate__Alternatives_4) 4057 ','
2918 { after(grammarAccess.getPredicateAccess().getAlternatives_4()); } 4058 { after(grammarAccess.getConjunctiveExpressionAccess().getCommaKeyword_1_1_0()); }
2919) 4059)
2920; 4060;
2921finally { 4061finally {
2922 restoreStackSize(stackSize); 4062 restoreStackSize(stackSize);
2923} 4063}
2924 4064
2925rule__Predicate__Group__5 4065rule__ConjunctiveExpression__Group_1_1__1
2926 @init { 4066 @init {
2927 int stackSize = keepStackSize(); 4067 int stackSize = keepStackSize();
2928 } 4068 }
2929: 4069:
2930 rule__Predicate__Group__5__Impl 4070 rule__ConjunctiveExpression__Group_1_1__1__Impl
2931; 4071;
2932finally { 4072finally {
2933 restoreStackSize(stackSize); 4073 restoreStackSize(stackSize);
2934} 4074}
2935 4075
2936rule__Predicate__Group__5__Impl 4076rule__ConjunctiveExpression__Group_1_1__1__Impl
2937 @init { 4077 @init {
2938 int stackSize = keepStackSize(); 4078 int stackSize = keepStackSize();
2939 } 4079 }
2940: 4080:
2941( 4081(
2942 { before(grammarAccess.getPredicateAccess().getFullStopKeyword_5()); } 4082 { before(grammarAccess.getConjunctiveExpressionAccess().getChildrenAssignment_1_1_1()); }
2943 '.' 4083 (rule__ConjunctiveExpression__ChildrenAssignment_1_1_1)
2944 { after(grammarAccess.getPredicateAccess().getFullStopKeyword_5()); } 4084 { after(grammarAccess.getConjunctiveExpressionAccess().getChildrenAssignment_1_1_1()); }
2945) 4085)
2946; 4086;
2947finally { 4087finally {
@@ -2949,134 +4089,134 @@ finally {
2949} 4089}
2950 4090
2951 4091
2952rule__Predicate__Group_2__0 4092rule__ComparisonExpression__Group__0
2953 @init { 4093 @init {
2954 int stackSize = keepStackSize(); 4094 int stackSize = keepStackSize();
2955 } 4095 }
2956: 4096:
2957 rule__Predicate__Group_2__0__Impl 4097 rule__ComparisonExpression__Group__0__Impl
2958 rule__Predicate__Group_2__1 4098 rule__ComparisonExpression__Group__1
2959; 4099;
2960finally { 4100finally {
2961 restoreStackSize(stackSize); 4101 restoreStackSize(stackSize);
2962} 4102}
2963 4103
2964rule__Predicate__Group_2__0__Impl 4104rule__ComparisonExpression__Group__0__Impl
2965 @init { 4105 @init {
2966 int stackSize = keepStackSize(); 4106 int stackSize = keepStackSize();
2967 } 4107 }
2968: 4108:
2969( 4109(
2970 { before(grammarAccess.getPredicateAccess().getLeftParenthesisKeyword_2_0()); } 4110 { before(grammarAccess.getComparisonExpressionAccess().getAdditiveExpressionParserRuleCall_0()); }
2971 '(' 4111 ruleAdditiveExpression
2972 { after(grammarAccess.getPredicateAccess().getLeftParenthesisKeyword_2_0()); } 4112 { after(grammarAccess.getComparisonExpressionAccess().getAdditiveExpressionParserRuleCall_0()); }
2973) 4113)
2974; 4114;
2975finally { 4115finally {
2976 restoreStackSize(stackSize); 4116 restoreStackSize(stackSize);
2977} 4117}
2978 4118
2979rule__Predicate__Group_2__1 4119rule__ComparisonExpression__Group__1
2980 @init { 4120 @init {
2981 int stackSize = keepStackSize(); 4121 int stackSize = keepStackSize();
2982 } 4122 }
2983: 4123:
2984 rule__Predicate__Group_2__1__Impl 4124 rule__ComparisonExpression__Group__1__Impl
2985 rule__Predicate__Group_2__2
2986; 4125;
2987finally { 4126finally {
2988 restoreStackSize(stackSize); 4127 restoreStackSize(stackSize);
2989} 4128}
2990 4129
2991rule__Predicate__Group_2__1__Impl 4130rule__ComparisonExpression__Group__1__Impl
2992 @init { 4131 @init {
2993 int stackSize = keepStackSize(); 4132 int stackSize = keepStackSize();
2994 } 4133 }
2995: 4134:
2996( 4135(
2997 { before(grammarAccess.getPredicateAccess().getGroup_2_1()); } 4136 { before(grammarAccess.getComparisonExpressionAccess().getGroup_1()); }
2998 (rule__Predicate__Group_2_1__0)? 4137 (rule__ComparisonExpression__Group_1__0)?
2999 { after(grammarAccess.getPredicateAccess().getGroup_2_1()); } 4138 { after(grammarAccess.getComparisonExpressionAccess().getGroup_1()); }
3000) 4139)
3001; 4140;
3002finally { 4141finally {
3003 restoreStackSize(stackSize); 4142 restoreStackSize(stackSize);
3004} 4143}
3005 4144
3006rule__Predicate__Group_2__2 4145
4146rule__ComparisonExpression__Group_1__0
3007 @init { 4147 @init {
3008 int stackSize = keepStackSize(); 4148 int stackSize = keepStackSize();
3009 } 4149 }
3010: 4150:
3011 rule__Predicate__Group_2__2__Impl 4151 rule__ComparisonExpression__Group_1__0__Impl
4152 rule__ComparisonExpression__Group_1__1
3012; 4153;
3013finally { 4154finally {
3014 restoreStackSize(stackSize); 4155 restoreStackSize(stackSize);
3015} 4156}
3016 4157
3017rule__Predicate__Group_2__2__Impl 4158rule__ComparisonExpression__Group_1__0__Impl
3018 @init { 4159 @init {
3019 int stackSize = keepStackSize(); 4160 int stackSize = keepStackSize();
3020 } 4161 }
3021: 4162:
3022( 4163(
3023 { before(grammarAccess.getPredicateAccess().getRightParenthesisKeyword_2_2()); } 4164 { before(grammarAccess.getComparisonExpressionAccess().getComparisonLeftAction_1_0()); }
3024 ')' 4165 ()
3025 { after(grammarAccess.getPredicateAccess().getRightParenthesisKeyword_2_2()); } 4166 { after(grammarAccess.getComparisonExpressionAccess().getComparisonLeftAction_1_0()); }
3026) 4167)
3027; 4168;
3028finally { 4169finally {
3029 restoreStackSize(stackSize); 4170 restoreStackSize(stackSize);
3030} 4171}
3031 4172
3032 4173rule__ComparisonExpression__Group_1__1
3033rule__Predicate__Group_2_1__0
3034 @init { 4174 @init {
3035 int stackSize = keepStackSize(); 4175 int stackSize = keepStackSize();
3036 } 4176 }
3037: 4177:
3038 rule__Predicate__Group_2_1__0__Impl 4178 rule__ComparisonExpression__Group_1__1__Impl
3039 rule__Predicate__Group_2_1__1 4179 rule__ComparisonExpression__Group_1__2
3040; 4180;
3041finally { 4181finally {
3042 restoreStackSize(stackSize); 4182 restoreStackSize(stackSize);
3043} 4183}
3044 4184
3045rule__Predicate__Group_2_1__0__Impl 4185rule__ComparisonExpression__Group_1__1__Impl
3046 @init { 4186 @init {
3047 int stackSize = keepStackSize(); 4187 int stackSize = keepStackSize();
3048 } 4188 }
3049: 4189:
3050( 4190(
3051 { before(grammarAccess.getPredicateAccess().getParametersAssignment_2_1_0()); } 4191 { before(grammarAccess.getComparisonExpressionAccess().getOpAssignment_1_1()); }
3052 (rule__Predicate__ParametersAssignment_2_1_0) 4192 (rule__ComparisonExpression__OpAssignment_1_1)
3053 { after(grammarAccess.getPredicateAccess().getParametersAssignment_2_1_0()); } 4193 { after(grammarAccess.getComparisonExpressionAccess().getOpAssignment_1_1()); }
3054) 4194)
3055; 4195;
3056finally { 4196finally {
3057 restoreStackSize(stackSize); 4197 restoreStackSize(stackSize);
3058} 4198}
3059 4199
3060rule__Predicate__Group_2_1__1 4200rule__ComparisonExpression__Group_1__2
3061 @init { 4201 @init {
3062 int stackSize = keepStackSize(); 4202 int stackSize = keepStackSize();
3063 } 4203 }
3064: 4204:
3065 rule__Predicate__Group_2_1__1__Impl 4205 rule__ComparisonExpression__Group_1__2__Impl
3066; 4206;
3067finally { 4207finally {
3068 restoreStackSize(stackSize); 4208 restoreStackSize(stackSize);
3069} 4209}
3070 4210
3071rule__Predicate__Group_2_1__1__Impl 4211rule__ComparisonExpression__Group_1__2__Impl
3072 @init { 4212 @init {
3073 int stackSize = keepStackSize(); 4213 int stackSize = keepStackSize();
3074 } 4214 }
3075: 4215:
3076( 4216(
3077 { before(grammarAccess.getPredicateAccess().getGroup_2_1_1()); } 4217 { before(grammarAccess.getComparisonExpressionAccess().getRightAssignment_1_2()); }
3078 (rule__Predicate__Group_2_1_1__0)* 4218 (rule__ComparisonExpression__RightAssignment_1_2)
3079 { after(grammarAccess.getPredicateAccess().getGroup_2_1_1()); } 4219 { after(grammarAccess.getComparisonExpressionAccess().getRightAssignment_1_2()); }
3080) 4220)
3081; 4221;
3082finally { 4222finally {
@@ -3084,53 +4224,53 @@ finally {
3084} 4224}
3085 4225
3086 4226
3087rule__Predicate__Group_2_1_1__0 4227rule__AdditiveExpression__Group__0
3088 @init { 4228 @init {
3089 int stackSize = keepStackSize(); 4229 int stackSize = keepStackSize();
3090 } 4230 }
3091: 4231:
3092 rule__Predicate__Group_2_1_1__0__Impl 4232 rule__AdditiveExpression__Group__0__Impl
3093 rule__Predicate__Group_2_1_1__1 4233 rule__AdditiveExpression__Group__1
3094; 4234;
3095finally { 4235finally {
3096 restoreStackSize(stackSize); 4236 restoreStackSize(stackSize);
3097} 4237}
3098 4238
3099rule__Predicate__Group_2_1_1__0__Impl 4239rule__AdditiveExpression__Group__0__Impl
3100 @init { 4240 @init {
3101 int stackSize = keepStackSize(); 4241 int stackSize = keepStackSize();
3102 } 4242 }
3103: 4243:
3104( 4244(
3105 { before(grammarAccess.getPredicateAccess().getCommaKeyword_2_1_1_0()); } 4245 { before(grammarAccess.getAdditiveExpressionAccess().getMultiplicativeExpressionParserRuleCall_0()); }
3106 ',' 4246 ruleMultiplicativeExpression
3107 { after(grammarAccess.getPredicateAccess().getCommaKeyword_2_1_1_0()); } 4247 { after(grammarAccess.getAdditiveExpressionAccess().getMultiplicativeExpressionParserRuleCall_0()); }
3108) 4248)
3109; 4249;
3110finally { 4250finally {
3111 restoreStackSize(stackSize); 4251 restoreStackSize(stackSize);
3112} 4252}
3113 4253
3114rule__Predicate__Group_2_1_1__1 4254rule__AdditiveExpression__Group__1
3115 @init { 4255 @init {
3116 int stackSize = keepStackSize(); 4256 int stackSize = keepStackSize();
3117 } 4257 }
3118: 4258:
3119 rule__Predicate__Group_2_1_1__1__Impl 4259 rule__AdditiveExpression__Group__1__Impl
3120; 4260;
3121finally { 4261finally {
3122 restoreStackSize(stackSize); 4262 restoreStackSize(stackSize);
3123} 4263}
3124 4264
3125rule__Predicate__Group_2_1_1__1__Impl 4265rule__AdditiveExpression__Group__1__Impl
3126 @init { 4266 @init {
3127 int stackSize = keepStackSize(); 4267 int stackSize = keepStackSize();
3128 } 4268 }
3129: 4269:
3130( 4270(
3131 { before(grammarAccess.getPredicateAccess().getParametersAssignment_2_1_1_1()); } 4271 { before(grammarAccess.getAdditiveExpressionAccess().getGroup_1()); }
3132 (rule__Predicate__ParametersAssignment_2_1_1_1) 4272 (rule__AdditiveExpression__Group_1__0)*
3133 { after(grammarAccess.getPredicateAccess().getParametersAssignment_2_1_1_1()); } 4273 { after(grammarAccess.getAdditiveExpressionAccess().getGroup_1()); }
3134) 4274)
3135; 4275;
3136finally { 4276finally {
@@ -3138,53 +4278,80 @@ finally {
3138} 4278}
3139 4279
3140 4280
3141rule__Predicate__Group_4_1__0 4281rule__AdditiveExpression__Group_1__0
3142 @init { 4282 @init {
3143 int stackSize = keepStackSize(); 4283 int stackSize = keepStackSize();
3144 } 4284 }
3145: 4285:
3146 rule__Predicate__Group_4_1__0__Impl 4286 rule__AdditiveExpression__Group_1__0__Impl
3147 rule__Predicate__Group_4_1__1 4287 rule__AdditiveExpression__Group_1__1
3148; 4288;
3149finally { 4289finally {
3150 restoreStackSize(stackSize); 4290 restoreStackSize(stackSize);
3151} 4291}
3152 4292
3153rule__Predicate__Group_4_1__0__Impl 4293rule__AdditiveExpression__Group_1__0__Impl
3154 @init { 4294 @init {
3155 int stackSize = keepStackSize(); 4295 int stackSize = keepStackSize();
3156 } 4296 }
3157: 4297:
3158( 4298(
3159 { before(grammarAccess.getPredicateAccess().getBodiesAssignment_4_1_0()); } 4299 { before(grammarAccess.getAdditiveExpressionAccess().getBinaryExpressionLeftAction_1_0()); }
3160 (rule__Predicate__BodiesAssignment_4_1_0) 4300 ()
3161 { after(grammarAccess.getPredicateAccess().getBodiesAssignment_4_1_0()); } 4301 { after(grammarAccess.getAdditiveExpressionAccess().getBinaryExpressionLeftAction_1_0()); }
3162) 4302)
3163; 4303;
3164finally { 4304finally {
3165 restoreStackSize(stackSize); 4305 restoreStackSize(stackSize);
3166} 4306}
3167 4307
3168rule__Predicate__Group_4_1__1 4308rule__AdditiveExpression__Group_1__1
3169 @init { 4309 @init {
3170 int stackSize = keepStackSize(); 4310 int stackSize = keepStackSize();
3171 } 4311 }
3172: 4312:
3173 rule__Predicate__Group_4_1__1__Impl 4313 rule__AdditiveExpression__Group_1__1__Impl
4314 rule__AdditiveExpression__Group_1__2
3174; 4315;
3175finally { 4316finally {
3176 restoreStackSize(stackSize); 4317 restoreStackSize(stackSize);
3177} 4318}
3178 4319
3179rule__Predicate__Group_4_1__1__Impl 4320rule__AdditiveExpression__Group_1__1__Impl
3180 @init { 4321 @init {
3181 int stackSize = keepStackSize(); 4322 int stackSize = keepStackSize();
3182 } 4323 }
3183: 4324:
3184( 4325(
3185 { before(grammarAccess.getPredicateAccess().getGroup_4_1_1()); } 4326 { before(grammarAccess.getAdditiveExpressionAccess().getOpAssignment_1_1()); }
3186 (rule__Predicate__Group_4_1_1__0)* 4327 (rule__AdditiveExpression__OpAssignment_1_1)
3187 { after(grammarAccess.getPredicateAccess().getGroup_4_1_1()); } 4328 { after(grammarAccess.getAdditiveExpressionAccess().getOpAssignment_1_1()); }
4329)
4330;
4331finally {
4332 restoreStackSize(stackSize);
4333}
4334
4335rule__AdditiveExpression__Group_1__2
4336 @init {
4337 int stackSize = keepStackSize();
4338 }
4339:
4340 rule__AdditiveExpression__Group_1__2__Impl
4341;
4342finally {
4343 restoreStackSize(stackSize);
4344}
4345
4346rule__AdditiveExpression__Group_1__2__Impl
4347 @init {
4348 int stackSize = keepStackSize();
4349 }
4350:
4351(
4352 { before(grammarAccess.getAdditiveExpressionAccess().getRightAssignment_1_2()); }
4353 (rule__AdditiveExpression__RightAssignment_1_2)
4354 { after(grammarAccess.getAdditiveExpressionAccess().getRightAssignment_1_2()); }
3188) 4355)
3189; 4356;
3190finally { 4357finally {
@@ -3192,53 +4359,53 @@ finally {
3192} 4359}
3193 4360
3194 4361
3195rule__Predicate__Group_4_1_1__0 4362rule__MultiplicativeExpression__Group__0
3196 @init { 4363 @init {
3197 int stackSize = keepStackSize(); 4364 int stackSize = keepStackSize();
3198 } 4365 }
3199: 4366:
3200 rule__Predicate__Group_4_1_1__0__Impl 4367 rule__MultiplicativeExpression__Group__0__Impl
3201 rule__Predicate__Group_4_1_1__1 4368 rule__MultiplicativeExpression__Group__1
3202; 4369;
3203finally { 4370finally {
3204 restoreStackSize(stackSize); 4371 restoreStackSize(stackSize);
3205} 4372}
3206 4373
3207rule__Predicate__Group_4_1_1__0__Impl 4374rule__MultiplicativeExpression__Group__0__Impl
3208 @init { 4375 @init {
3209 int stackSize = keepStackSize(); 4376 int stackSize = keepStackSize();
3210 } 4377 }
3211: 4378:
3212( 4379(
3213 { before(grammarAccess.getPredicateAccess().getVerticalLineKeyword_4_1_1_0()); } 4380 { before(grammarAccess.getMultiplicativeExpressionAccess().getExponentialExpressionParserRuleCall_0()); }
3214 '|' 4381 ruleExponentialExpression
3215 { after(grammarAccess.getPredicateAccess().getVerticalLineKeyword_4_1_1_0()); } 4382 { after(grammarAccess.getMultiplicativeExpressionAccess().getExponentialExpressionParserRuleCall_0()); }
3216) 4383)
3217; 4384;
3218finally { 4385finally {
3219 restoreStackSize(stackSize); 4386 restoreStackSize(stackSize);
3220} 4387}
3221 4388
3222rule__Predicate__Group_4_1_1__1 4389rule__MultiplicativeExpression__Group__1
3223 @init { 4390 @init {
3224 int stackSize = keepStackSize(); 4391 int stackSize = keepStackSize();
3225 } 4392 }
3226: 4393:
3227 rule__Predicate__Group_4_1_1__1__Impl 4394 rule__MultiplicativeExpression__Group__1__Impl
3228; 4395;
3229finally { 4396finally {
3230 restoreStackSize(stackSize); 4397 restoreStackSize(stackSize);
3231} 4398}
3232 4399
3233rule__Predicate__Group_4_1_1__1__Impl 4400rule__MultiplicativeExpression__Group__1__Impl
3234 @init { 4401 @init {
3235 int stackSize = keepStackSize(); 4402 int stackSize = keepStackSize();
3236 } 4403 }
3237: 4404:
3238( 4405(
3239 { before(grammarAccess.getPredicateAccess().getBodiesAssignment_4_1_1_1()); } 4406 { before(grammarAccess.getMultiplicativeExpressionAccess().getGroup_1()); }
3240 (rule__Predicate__BodiesAssignment_4_1_1_1) 4407 (rule__MultiplicativeExpression__Group_1__0)*
3241 { after(grammarAccess.getPredicateAccess().getBodiesAssignment_4_1_1_1()); } 4408 { after(grammarAccess.getMultiplicativeExpressionAccess().getGroup_1()); }
3242) 4409)
3243; 4410;
3244finally { 4411finally {
@@ -3246,107 +4413,134 @@ finally {
3246} 4413}
3247 4414
3248 4415
3249rule__Parameter__Group__0 4416rule__MultiplicativeExpression__Group_1__0
3250 @init { 4417 @init {
3251 int stackSize = keepStackSize(); 4418 int stackSize = keepStackSize();
3252 } 4419 }
3253: 4420:
3254 rule__Parameter__Group__0__Impl 4421 rule__MultiplicativeExpression__Group_1__0__Impl
3255 rule__Parameter__Group__1 4422 rule__MultiplicativeExpression__Group_1__1
3256; 4423;
3257finally { 4424finally {
3258 restoreStackSize(stackSize); 4425 restoreStackSize(stackSize);
3259} 4426}
3260 4427
3261rule__Parameter__Group__0__Impl 4428rule__MultiplicativeExpression__Group_1__0__Impl
3262 @init { 4429 @init {
3263 int stackSize = keepStackSize(); 4430 int stackSize = keepStackSize();
3264 } 4431 }
3265: 4432:
3266( 4433(
3267 { before(grammarAccess.getParameterAccess().getVariableAssignment_0()); } 4434 { before(grammarAccess.getMultiplicativeExpressionAccess().getBinaryExpressionLeftAction_1_0()); }
3268 (rule__Parameter__VariableAssignment_0) 4435 ()
3269 { after(grammarAccess.getParameterAccess().getVariableAssignment_0()); } 4436 { after(grammarAccess.getMultiplicativeExpressionAccess().getBinaryExpressionLeftAction_1_0()); }
3270) 4437)
3271; 4438;
3272finally { 4439finally {
3273 restoreStackSize(stackSize); 4440 restoreStackSize(stackSize);
3274} 4441}
3275 4442
3276rule__Parameter__Group__1 4443rule__MultiplicativeExpression__Group_1__1
3277 @init { 4444 @init {
3278 int stackSize = keepStackSize(); 4445 int stackSize = keepStackSize();
3279 } 4446 }
3280: 4447:
3281 rule__Parameter__Group__1__Impl 4448 rule__MultiplicativeExpression__Group_1__1__Impl
4449 rule__MultiplicativeExpression__Group_1__2
3282; 4450;
3283finally { 4451finally {
3284 restoreStackSize(stackSize); 4452 restoreStackSize(stackSize);
3285} 4453}
3286 4454
3287rule__Parameter__Group__1__Impl 4455rule__MultiplicativeExpression__Group_1__1__Impl
3288 @init { 4456 @init {
3289 int stackSize = keepStackSize(); 4457 int stackSize = keepStackSize();
3290 } 4458 }
3291: 4459:
3292( 4460(
3293 { before(grammarAccess.getParameterAccess().getGroup_1()); } 4461 { before(grammarAccess.getMultiplicativeExpressionAccess().getOpAssignment_1_1()); }
3294 (rule__Parameter__Group_1__0)? 4462 (rule__MultiplicativeExpression__OpAssignment_1_1)
3295 { after(grammarAccess.getParameterAccess().getGroup_1()); } 4463 { after(grammarAccess.getMultiplicativeExpressionAccess().getOpAssignment_1_1()); }
3296) 4464)
3297; 4465;
3298finally { 4466finally {
3299 restoreStackSize(stackSize); 4467 restoreStackSize(stackSize);
3300} 4468}
3301 4469
4470rule__MultiplicativeExpression__Group_1__2
4471 @init {
4472 int stackSize = keepStackSize();
4473 }
4474:
4475 rule__MultiplicativeExpression__Group_1__2__Impl
4476;
4477finally {
4478 restoreStackSize(stackSize);
4479}
3302 4480
3303rule__Parameter__Group_1__0 4481rule__MultiplicativeExpression__Group_1__2__Impl
3304 @init { 4482 @init {
3305 int stackSize = keepStackSize(); 4483 int stackSize = keepStackSize();
3306 } 4484 }
3307: 4485:
3308 rule__Parameter__Group_1__0__Impl 4486(
3309 rule__Parameter__Group_1__1 4487 { before(grammarAccess.getMultiplicativeExpressionAccess().getRightAssignment_1_2()); }
4488 (rule__MultiplicativeExpression__RightAssignment_1_2)
4489 { after(grammarAccess.getMultiplicativeExpressionAccess().getRightAssignment_1_2()); }
4490)
3310; 4491;
3311finally { 4492finally {
3312 restoreStackSize(stackSize); 4493 restoreStackSize(stackSize);
3313} 4494}
3314 4495
3315rule__Parameter__Group_1__0__Impl 4496
4497rule__ExponentialExpression__Group__0
4498 @init {
4499 int stackSize = keepStackSize();
4500 }
4501:
4502 rule__ExponentialExpression__Group__0__Impl
4503 rule__ExponentialExpression__Group__1
4504;
4505finally {
4506 restoreStackSize(stackSize);
4507}
4508
4509rule__ExponentialExpression__Group__0__Impl
3316 @init { 4510 @init {
3317 int stackSize = keepStackSize(); 4511 int stackSize = keepStackSize();
3318 } 4512 }
3319: 4513:
3320( 4514(
3321 { before(grammarAccess.getParameterAccess().getColonKeyword_1_0()); } 4515 { before(grammarAccess.getExponentialExpressionAccess().getUnaryExpressionParserRuleCall_0()); }
3322 ':' 4516 ruleUnaryExpression
3323 { after(grammarAccess.getParameterAccess().getColonKeyword_1_0()); } 4517 { after(grammarAccess.getExponentialExpressionAccess().getUnaryExpressionParserRuleCall_0()); }
3324) 4518)
3325; 4519;
3326finally { 4520finally {
3327 restoreStackSize(stackSize); 4521 restoreStackSize(stackSize);
3328} 4522}
3329 4523
3330rule__Parameter__Group_1__1 4524rule__ExponentialExpression__Group__1
3331 @init { 4525 @init {
3332 int stackSize = keepStackSize(); 4526 int stackSize = keepStackSize();
3333 } 4527 }
3334: 4528:
3335 rule__Parameter__Group_1__1__Impl 4529 rule__ExponentialExpression__Group__1__Impl
3336; 4530;
3337finally { 4531finally {
3338 restoreStackSize(stackSize); 4532 restoreStackSize(stackSize);
3339} 4533}
3340 4534
3341rule__Parameter__Group_1__1__Impl 4535rule__ExponentialExpression__Group__1__Impl
3342 @init { 4536 @init {
3343 int stackSize = keepStackSize(); 4537 int stackSize = keepStackSize();
3344 } 4538 }
3345: 4539:
3346( 4540(
3347 { before(grammarAccess.getParameterAccess().getTypeAssignment_1_1()); } 4541 { before(grammarAccess.getExponentialExpressionAccess().getGroup_1()); }
3348 (rule__Parameter__TypeAssignment_1_1) 4542 (rule__ExponentialExpression__Group_1__0)?
3349 { after(grammarAccess.getParameterAccess().getTypeAssignment_1_1()); } 4543 { after(grammarAccess.getExponentialExpressionAccess().getGroup_1()); }
3350) 4544)
3351; 4545;
3352finally { 4546finally {
@@ -3354,107 +4548,161 @@ finally {
3354} 4548}
3355 4549
3356 4550
3357rule__PatternBody__Group__0 4551rule__ExponentialExpression__Group_1__0
3358 @init { 4552 @init {
3359 int stackSize = keepStackSize(); 4553 int stackSize = keepStackSize();
3360 } 4554 }
3361: 4555:
3362 rule__PatternBody__Group__0__Impl 4556 rule__ExponentialExpression__Group_1__0__Impl
3363 rule__PatternBody__Group__1 4557 rule__ExponentialExpression__Group_1__1
3364; 4558;
3365finally { 4559finally {
3366 restoreStackSize(stackSize); 4560 restoreStackSize(stackSize);
3367} 4561}
3368 4562
3369rule__PatternBody__Group__0__Impl 4563rule__ExponentialExpression__Group_1__0__Impl
3370 @init { 4564 @init {
3371 int stackSize = keepStackSize(); 4565 int stackSize = keepStackSize();
3372 } 4566 }
3373: 4567:
3374( 4568(
3375 { before(grammarAccess.getPatternBodyAccess().getPatternBodyAction_0()); } 4569 { before(grammarAccess.getExponentialExpressionAccess().getBinaryExpressionLeftAction_1_0()); }
3376 () 4570 ()
3377 { after(grammarAccess.getPatternBodyAccess().getPatternBodyAction_0()); } 4571 { after(grammarAccess.getExponentialExpressionAccess().getBinaryExpressionLeftAction_1_0()); }
3378) 4572)
3379; 4573;
3380finally { 4574finally {
3381 restoreStackSize(stackSize); 4575 restoreStackSize(stackSize);
3382} 4576}
3383 4577
3384rule__PatternBody__Group__1 4578rule__ExponentialExpression__Group_1__1
3385 @init { 4579 @init {
3386 int stackSize = keepStackSize(); 4580 int stackSize = keepStackSize();
3387 } 4581 }
3388: 4582:
3389 rule__PatternBody__Group__1__Impl 4583 rule__ExponentialExpression__Group_1__1__Impl
4584 rule__ExponentialExpression__Group_1__2
3390; 4585;
3391finally { 4586finally {
3392 restoreStackSize(stackSize); 4587 restoreStackSize(stackSize);
3393} 4588}
3394 4589
3395rule__PatternBody__Group__1__Impl 4590rule__ExponentialExpression__Group_1__1__Impl
3396 @init { 4591 @init {
3397 int stackSize = keepStackSize(); 4592 int stackSize = keepStackSize();
3398 } 4593 }
3399: 4594:
3400( 4595(
3401 { before(grammarAccess.getPatternBodyAccess().getAlternatives_1()); } 4596 { before(grammarAccess.getExponentialExpressionAccess().getOpAssignment_1_1()); }
3402 (rule__PatternBody__Alternatives_1) 4597 (rule__ExponentialExpression__OpAssignment_1_1)
3403 { after(grammarAccess.getPatternBodyAccess().getAlternatives_1()); } 4598 { after(grammarAccess.getExponentialExpressionAccess().getOpAssignment_1_1()); }
3404) 4599)
3405; 4600;
3406finally { 4601finally {
3407 restoreStackSize(stackSize); 4602 restoreStackSize(stackSize);
3408} 4603}
3409 4604
4605rule__ExponentialExpression__Group_1__2
4606 @init {
4607 int stackSize = keepStackSize();
4608 }
4609:
4610 rule__ExponentialExpression__Group_1__2__Impl
4611;
4612finally {
4613 restoreStackSize(stackSize);
4614}
4615
4616rule__ExponentialExpression__Group_1__2__Impl
4617 @init {
4618 int stackSize = keepStackSize();
4619 }
4620:
4621(
4622 { before(grammarAccess.getExponentialExpressionAccess().getRightAssignment_1_2()); }
4623 (rule__ExponentialExpression__RightAssignment_1_2)
4624 { after(grammarAccess.getExponentialExpressionAccess().getRightAssignment_1_2()); }
4625)
4626;
4627finally {
4628 restoreStackSize(stackSize);
4629}
3410 4630
3411rule__Polarity__Group_0__0 4631
4632rule__UnaryExpression__Group_1__0
3412 @init { 4633 @init {
3413 int stackSize = keepStackSize(); 4634 int stackSize = keepStackSize();
3414 } 4635 }
3415: 4636:
3416 rule__Polarity__Group_0__0__Impl 4637 rule__UnaryExpression__Group_1__0__Impl
3417 rule__Polarity__Group_0__1 4638 rule__UnaryExpression__Group_1__1
3418; 4639;
3419finally { 4640finally {
3420 restoreStackSize(stackSize); 4641 restoreStackSize(stackSize);
3421} 4642}
3422 4643
3423rule__Polarity__Group_0__0__Impl 4644rule__UnaryExpression__Group_1__0__Impl
3424 @init { 4645 @init {
3425 int stackSize = keepStackSize(); 4646 int stackSize = keepStackSize();
3426 } 4647 }
3427: 4648:
3428( 4649(
3429 { before(grammarAccess.getPolarityAccess().getPositiveAction_0_0()); } 4650 { before(grammarAccess.getUnaryExpressionAccess().getUnaryExpressionAction_1_0()); }
3430 () 4651 ()
3431 { after(grammarAccess.getPolarityAccess().getPositiveAction_0_0()); } 4652 { after(grammarAccess.getUnaryExpressionAccess().getUnaryExpressionAction_1_0()); }
4653)
4654;
4655finally {
4656 restoreStackSize(stackSize);
4657}
4658
4659rule__UnaryExpression__Group_1__1
4660 @init {
4661 int stackSize = keepStackSize();
4662 }
4663:
4664 rule__UnaryExpression__Group_1__1__Impl
4665 rule__UnaryExpression__Group_1__2
4666;
4667finally {
4668 restoreStackSize(stackSize);
4669}
4670
4671rule__UnaryExpression__Group_1__1__Impl
4672 @init {
4673 int stackSize = keepStackSize();
4674 }
4675:
4676(
4677 { before(grammarAccess.getUnaryExpressionAccess().getOpAssignment_1_1()); }
4678 (rule__UnaryExpression__OpAssignment_1_1)
4679 { after(grammarAccess.getUnaryExpressionAccess().getOpAssignment_1_1()); }
3432) 4680)
3433; 4681;
3434finally { 4682finally {
3435 restoreStackSize(stackSize); 4683 restoreStackSize(stackSize);
3436} 4684}
3437 4685
3438rule__Polarity__Group_0__1 4686rule__UnaryExpression__Group_1__2
3439 @init { 4687 @init {
3440 int stackSize = keepStackSize(); 4688 int stackSize = keepStackSize();
3441 } 4689 }
3442: 4690:
3443 rule__Polarity__Group_0__1__Impl 4691 rule__UnaryExpression__Group_1__2__Impl
3444; 4692;
3445finally { 4693finally {
3446 restoreStackSize(stackSize); 4694 restoreStackSize(stackSize);
3447} 4695}
3448 4696
3449rule__Polarity__Group_0__1__Impl 4697rule__UnaryExpression__Group_1__2__Impl
3450 @init { 4698 @init {
3451 int stackSize = keepStackSize(); 4699 int stackSize = keepStackSize();
3452 } 4700 }
3453: 4701:
3454( 4702(
3455 { before(grammarAccess.getPolarityAccess().getPlusSignKeyword_0_1()); } 4703 { before(grammarAccess.getUnaryExpressionAccess().getBodyAssignment_1_2()); }
3456 '+' 4704 (rule__UnaryExpression__BodyAssignment_1_2)
3457 { after(grammarAccess.getPolarityAccess().getPlusSignKeyword_0_1()); } 4705 { after(grammarAccess.getUnaryExpressionAccess().getBodyAssignment_1_2()); }
3458) 4706)
3459; 4707;
3460finally { 4708finally {
@@ -3462,242 +4710,458 @@ finally {
3462} 4710}
3463 4711
3464 4712
3465rule__Polarity__Group_1__0 4713rule__Count__Group__0
3466 @init { 4714 @init {
3467 int stackSize = keepStackSize(); 4715 int stackSize = keepStackSize();
3468 } 4716 }
3469: 4717:
3470 rule__Polarity__Group_1__0__Impl 4718 rule__Count__Group__0__Impl
3471 rule__Polarity__Group_1__1 4719 rule__Count__Group__1
3472; 4720;
3473finally { 4721finally {
3474 restoreStackSize(stackSize); 4722 restoreStackSize(stackSize);
3475} 4723}
3476 4724
3477rule__Polarity__Group_1__0__Impl 4725rule__Count__Group__0__Impl
3478 @init { 4726 @init {
3479 int stackSize = keepStackSize(); 4727 int stackSize = keepStackSize();
3480 } 4728 }
3481: 4729:
3482( 4730(
3483 { before(grammarAccess.getPolarityAccess().getNegativeAction_1_0()); } 4731 { before(grammarAccess.getCountAccess().getCountKeyword_0()); }
3484 () 4732 'count'
3485 { after(grammarAccess.getPolarityAccess().getNegativeAction_1_0()); } 4733 { after(grammarAccess.getCountAccess().getCountKeyword_0()); }
3486) 4734)
3487; 4735;
3488finally { 4736finally {
3489 restoreStackSize(stackSize); 4737 restoreStackSize(stackSize);
3490} 4738}
3491 4739
3492rule__Polarity__Group_1__1 4740rule__Count__Group__1
3493 @init { 4741 @init {
3494 int stackSize = keepStackSize(); 4742 int stackSize = keepStackSize();
3495 } 4743 }
3496: 4744:
3497 rule__Polarity__Group_1__1__Impl 4745 rule__Count__Group__1__Impl
4746 rule__Count__Group__2
3498; 4747;
3499finally { 4748finally {
3500 restoreStackSize(stackSize); 4749 restoreStackSize(stackSize);
3501} 4750}
3502 4751
3503rule__Polarity__Group_1__1__Impl 4752rule__Count__Group__1__Impl
3504 @init { 4753 @init {
3505 int stackSize = keepStackSize(); 4754 int stackSize = keepStackSize();
3506 } 4755 }
3507: 4756:
3508( 4757(
3509 { before(grammarAccess.getPolarityAccess().getHyphenMinusKeyword_1_1()); } 4758 { before(grammarAccess.getCountAccess().getLeftCurlyBracketKeyword_1()); }
3510 '-' 4759 '{'
3511 { after(grammarAccess.getPolarityAccess().getHyphenMinusKeyword_1_1()); } 4760 { after(grammarAccess.getCountAccess().getLeftCurlyBracketKeyword_1()); }
3512) 4761)
3513; 4762;
3514finally { 4763finally {
3515 restoreStackSize(stackSize); 4764 restoreStackSize(stackSize);
3516} 4765}
3517 4766
4767rule__Count__Group__2
4768 @init {
4769 int stackSize = keepStackSize();
4770 }
4771:
4772 rule__Count__Group__2__Impl
4773 rule__Count__Group__3
4774;
4775finally {
4776 restoreStackSize(stackSize);
4777}
3518 4778
3519rule__Constraint__Group_0__0 4779rule__Count__Group__2__Impl
3520 @init { 4780 @init {
3521 int stackSize = keepStackSize(); 4781 int stackSize = keepStackSize();
3522 } 4782 }
3523: 4783:
3524 rule__Constraint__Group_0__0__Impl 4784(
3525 rule__Constraint__Group_0__1 4785 { before(grammarAccess.getCountAccess().getBodyAssignment_2()); }
4786 (rule__Count__BodyAssignment_2)
4787 { after(grammarAccess.getCountAccess().getBodyAssignment_2()); }
4788)
3526; 4789;
3527finally { 4790finally {
3528 restoreStackSize(stackSize); 4791 restoreStackSize(stackSize);
3529} 4792}
3530 4793
3531rule__Constraint__Group_0__0__Impl 4794rule__Count__Group__3
4795 @init {
4796 int stackSize = keepStackSize();
4797 }
4798:
4799 rule__Count__Group__3__Impl
4800;
4801finally {
4802 restoreStackSize(stackSize);
4803}
4804
4805rule__Count__Group__3__Impl
3532 @init { 4806 @init {
3533 int stackSize = keepStackSize(); 4807 int stackSize = keepStackSize();
3534 } 4808 }
3535: 4809:
3536( 4810(
3537 { before(grammarAccess.getConstraintAccess().getPolarityAssignment_0_0()); } 4811 { before(grammarAccess.getCountAccess().getRightCurlyBracketKeyword_3()); }
3538 (rule__Constraint__PolarityAssignment_0_0)? 4812 '}'
3539 { after(grammarAccess.getConstraintAccess().getPolarityAssignment_0_0()); } 4813 { after(grammarAccess.getCountAccess().getRightCurlyBracketKeyword_3()); }
3540) 4814)
3541; 4815;
3542finally { 4816finally {
3543 restoreStackSize(stackSize); 4817 restoreStackSize(stackSize);
3544} 4818}
3545 4819
3546rule__Constraint__Group_0__1 4820
4821rule__Aggregation__Group__0
3547 @init { 4822 @init {
3548 int stackSize = keepStackSize(); 4823 int stackSize = keepStackSize();
3549 } 4824 }
3550: 4825:
3551 rule__Constraint__Group_0__1__Impl 4826 rule__Aggregation__Group__0__Impl
3552 rule__Constraint__Group_0__2 4827 rule__Aggregation__Group__1
3553; 4828;
3554finally { 4829finally {
3555 restoreStackSize(stackSize); 4830 restoreStackSize(stackSize);
3556} 4831}
3557 4832
3558rule__Constraint__Group_0__1__Impl 4833rule__Aggregation__Group__0__Impl
3559 @init { 4834 @init {
3560 int stackSize = keepStackSize(); 4835 int stackSize = keepStackSize();
3561 } 4836 }
3562: 4837:
3563( 4838(
3564 { before(grammarAccess.getConstraintAccess().getSymbolAssignment_0_1()); } 4839 { before(grammarAccess.getAggregationAccess().getOpAssignment_0()); }
3565 (rule__Constraint__SymbolAssignment_0_1) 4840 (rule__Aggregation__OpAssignment_0)
3566 { after(grammarAccess.getConstraintAccess().getSymbolAssignment_0_1()); } 4841 { after(grammarAccess.getAggregationAccess().getOpAssignment_0()); }
3567) 4842)
3568; 4843;
3569finally { 4844finally {
3570 restoreStackSize(stackSize); 4845 restoreStackSize(stackSize);
3571} 4846}
3572 4847
3573rule__Constraint__Group_0__2 4848rule__Aggregation__Group__1
3574 @init { 4849 @init {
3575 int stackSize = keepStackSize(); 4850 int stackSize = keepStackSize();
3576 } 4851 }
3577: 4852:
3578 rule__Constraint__Group_0__2__Impl 4853 rule__Aggregation__Group__1__Impl
4854 rule__Aggregation__Group__2
3579; 4855;
3580finally { 4856finally {
3581 restoreStackSize(stackSize); 4857 restoreStackSize(stackSize);
3582} 4858}
3583 4859
3584rule__Constraint__Group_0__2__Impl 4860rule__Aggregation__Group__1__Impl
3585 @init { 4861 @init {
3586 int stackSize = keepStackSize(); 4862 int stackSize = keepStackSize();
3587 } 4863 }
3588: 4864:
3589( 4865(
3590 { before(grammarAccess.getConstraintAccess().getGroup_0_2()); } 4866 { before(grammarAccess.getAggregationAccess().getLeftCurlyBracketKeyword_1()); }
3591 (rule__Constraint__Group_0_2__0)? 4867 '{'
3592 { after(grammarAccess.getConstraintAccess().getGroup_0_2()); } 4868 { after(grammarAccess.getAggregationAccess().getLeftCurlyBracketKeyword_1()); }
3593) 4869)
3594; 4870;
3595finally { 4871finally {
3596 restoreStackSize(stackSize); 4872 restoreStackSize(stackSize);
3597} 4873}
3598 4874
4875rule__Aggregation__Group__2
4876 @init {
4877 int stackSize = keepStackSize();
4878 }
4879:
4880 rule__Aggregation__Group__2__Impl
4881 rule__Aggregation__Group__3
4882;
4883finally {
4884 restoreStackSize(stackSize);
4885}
3599 4886
3600rule__Constraint__Group_0_2__0 4887rule__Aggregation__Group__2__Impl
3601 @init { 4888 @init {
3602 int stackSize = keepStackSize(); 4889 int stackSize = keepStackSize();
3603 } 4890 }
3604: 4891:
3605 rule__Constraint__Group_0_2__0__Impl 4892(
3606 rule__Constraint__Group_0_2__1 4893 { before(grammarAccess.getAggregationAccess().getBodyAssignment_2()); }
4894 (rule__Aggregation__BodyAssignment_2)
4895 { after(grammarAccess.getAggregationAccess().getBodyAssignment_2()); }
4896)
3607; 4897;
3608finally { 4898finally {
3609 restoreStackSize(stackSize); 4899 restoreStackSize(stackSize);
3610} 4900}
3611 4901
3612rule__Constraint__Group_0_2__0__Impl 4902rule__Aggregation__Group__3
4903 @init {
4904 int stackSize = keepStackSize();
4905 }
4906:
4907 rule__Aggregation__Group__3__Impl
4908 rule__Aggregation__Group__4
4909;
4910finally {
4911 restoreStackSize(stackSize);
4912}
4913
4914rule__Aggregation__Group__3__Impl
3613 @init { 4915 @init {
3614 int stackSize = keepStackSize(); 4916 int stackSize = keepStackSize();
3615 } 4917 }
3616: 4918:
3617( 4919(
3618 { before(grammarAccess.getConstraintAccess().getLeftParenthesisKeyword_0_2_0()); } 4920 { before(grammarAccess.getAggregationAccess().getVerticalLineKeyword_3()); }
3619 '(' 4921 '|'
3620 { after(grammarAccess.getConstraintAccess().getLeftParenthesisKeyword_0_2_0()); } 4922 { after(grammarAccess.getAggregationAccess().getVerticalLineKeyword_3()); }
4923)
4924;
4925finally {
4926 restoreStackSize(stackSize);
4927}
4928
4929rule__Aggregation__Group__4
4930 @init {
4931 int stackSize = keepStackSize();
4932 }
4933:
4934 rule__Aggregation__Group__4__Impl
4935 rule__Aggregation__Group__5
4936;
4937finally {
4938 restoreStackSize(stackSize);
4939}
4940
4941rule__Aggregation__Group__4__Impl
4942 @init {
4943 int stackSize = keepStackSize();
4944 }
4945:
4946(
4947 { before(grammarAccess.getAggregationAccess().getConditionAssignment_4()); }
4948 (rule__Aggregation__ConditionAssignment_4)
4949 { after(grammarAccess.getAggregationAccess().getConditionAssignment_4()); }
3621) 4950)
3622; 4951;
3623finally { 4952finally {
3624 restoreStackSize(stackSize); 4953 restoreStackSize(stackSize);
3625} 4954}
3626 4955
3627rule__Constraint__Group_0_2__1 4956rule__Aggregation__Group__5
3628 @init { 4957 @init {
3629 int stackSize = keepStackSize(); 4958 int stackSize = keepStackSize();
3630 } 4959 }
3631: 4960:
3632 rule__Constraint__Group_0_2__1__Impl 4961 rule__Aggregation__Group__5__Impl
3633 rule__Constraint__Group_0_2__2
3634; 4962;
3635finally { 4963finally {
3636 restoreStackSize(stackSize); 4964 restoreStackSize(stackSize);
3637} 4965}
3638 4966
3639rule__Constraint__Group_0_2__1__Impl 4967rule__Aggregation__Group__5__Impl
3640 @init { 4968 @init {
3641 int stackSize = keepStackSize(); 4969 int stackSize = keepStackSize();
3642 } 4970 }
3643: 4971:
3644( 4972(
3645 { before(grammarAccess.getConstraintAccess().getParamsAssignment_0_2_1()); } 4973 { before(grammarAccess.getAggregationAccess().getRightCurlyBracketKeyword_5()); }
3646 (rule__Constraint__ParamsAssignment_0_2_1)? 4974 '}'
3647 { after(grammarAccess.getConstraintAccess().getParamsAssignment_0_2_1()); } 4975 { after(grammarAccess.getAggregationAccess().getRightCurlyBracketKeyword_5()); }
3648) 4976)
3649; 4977;
3650finally { 4978finally {
3651 restoreStackSize(stackSize); 4979 restoreStackSize(stackSize);
3652} 4980}
3653 4981
3654rule__Constraint__Group_0_2__2 4982
4983rule__AtomicExpression__Group_0__0
3655 @init { 4984 @init {
3656 int stackSize = keepStackSize(); 4985 int stackSize = keepStackSize();
3657 } 4986 }
3658: 4987:
3659 rule__Constraint__Group_0_2__2__Impl 4988 rule__AtomicExpression__Group_0__0__Impl
3660 rule__Constraint__Group_0_2__3 4989 rule__AtomicExpression__Group_0__1
3661; 4990;
3662finally { 4991finally {
3663 restoreStackSize(stackSize); 4992 restoreStackSize(stackSize);
3664} 4993}
3665 4994
3666rule__Constraint__Group_0_2__2__Impl 4995rule__AtomicExpression__Group_0__0__Impl
3667 @init { 4996 @init {
3668 int stackSize = keepStackSize(); 4997 int stackSize = keepStackSize();
3669 } 4998 }
3670: 4999:
3671( 5000(
3672 { before(grammarAccess.getConstraintAccess().getGroup_0_2_2()); } 5001 { before(grammarAccess.getAtomicExpressionAccess().getReferenceParserRuleCall_0_0()); }
3673 (rule__Constraint__Group_0_2_2__0)* 5002 ruleReference
3674 { after(grammarAccess.getConstraintAccess().getGroup_0_2_2()); } 5003 { after(grammarAccess.getAtomicExpressionAccess().getReferenceParserRuleCall_0_0()); }
3675) 5004)
3676; 5005;
3677finally { 5006finally {
3678 restoreStackSize(stackSize); 5007 restoreStackSize(stackSize);
3679} 5008}
3680 5009
3681rule__Constraint__Group_0_2__3 5010rule__AtomicExpression__Group_0__1
3682 @init { 5011 @init {
3683 int stackSize = keepStackSize(); 5012 int stackSize = keepStackSize();
3684 } 5013 }
3685: 5014:
3686 rule__Constraint__Group_0_2__3__Impl 5015 rule__AtomicExpression__Group_0__1__Impl
3687; 5016;
3688finally { 5017finally {
3689 restoreStackSize(stackSize); 5018 restoreStackSize(stackSize);
3690} 5019}
3691 5020
3692rule__Constraint__Group_0_2__3__Impl 5021rule__AtomicExpression__Group_0__1__Impl
3693 @init { 5022 @init {
3694 int stackSize = keepStackSize(); 5023 int stackSize = keepStackSize();
3695 } 5024 }
3696: 5025:
3697( 5026(
3698 { before(grammarAccess.getConstraintAccess().getRightParenthesisKeyword_0_2_3()); } 5027 { before(grammarAccess.getAtomicExpressionAccess().getGroup_0_1()); }
5028 (rule__AtomicExpression__Group_0_1__0)?
5029 { after(grammarAccess.getAtomicExpressionAccess().getGroup_0_1()); }
5030)
5031;
5032finally {
5033 restoreStackSize(stackSize);
5034}
5035
5036
5037rule__AtomicExpression__Group_0_1__0
5038 @init {
5039 int stackSize = keepStackSize();
5040 }
5041:
5042 rule__AtomicExpression__Group_0_1__0__Impl
5043 rule__AtomicExpression__Group_0_1__1
5044;
5045finally {
5046 restoreStackSize(stackSize);
5047}
5048
5049rule__AtomicExpression__Group_0_1__0__Impl
5050 @init {
5051 int stackSize = keepStackSize();
5052 }
5053:
5054(
5055 { before(grammarAccess.getAtomicExpressionAccess().getCallFunctorAction_0_1_0()); }
5056 ()
5057 { after(grammarAccess.getAtomicExpressionAccess().getCallFunctorAction_0_1_0()); }
5058)
5059;
5060finally {
5061 restoreStackSize(stackSize);
5062}
5063
5064rule__AtomicExpression__Group_0_1__1
5065 @init {
5066 int stackSize = keepStackSize();
5067 }
5068:
5069 rule__AtomicExpression__Group_0_1__1__Impl
5070;
5071finally {
5072 restoreStackSize(stackSize);
5073}
5074
5075rule__AtomicExpression__Group_0_1__1__Impl
5076 @init {
5077 int stackSize = keepStackSize();
5078 }
5079:
5080(
5081 { before(grammarAccess.getAtomicExpressionAccess().getArgumentListAssignment_0_1_1()); }
5082 (rule__AtomicExpression__ArgumentListAssignment_0_1_1)
5083 { after(grammarAccess.getAtomicExpressionAccess().getArgumentListAssignment_0_1_1()); }
5084)
5085;
5086finally {
5087 restoreStackSize(stackSize);
5088}
5089
5090
5091rule__AtomicExpression__Group_3__0
5092 @init {
5093 int stackSize = keepStackSize();
5094 }
5095:
5096 rule__AtomicExpression__Group_3__0__Impl
5097 rule__AtomicExpression__Group_3__1
5098;
5099finally {
5100 restoreStackSize(stackSize);
5101}
5102
5103rule__AtomicExpression__Group_3__0__Impl
5104 @init {
5105 int stackSize = keepStackSize();
5106 }
5107:
5108(
5109 { before(grammarAccess.getAtomicExpressionAccess().getLeftParenthesisKeyword_3_0()); }
5110 '('
5111 { after(grammarAccess.getAtomicExpressionAccess().getLeftParenthesisKeyword_3_0()); }
5112)
5113;
5114finally {
5115 restoreStackSize(stackSize);
5116}
5117
5118rule__AtomicExpression__Group_3__1
5119 @init {
5120 int stackSize = keepStackSize();
5121 }
5122:
5123 rule__AtomicExpression__Group_3__1__Impl
5124 rule__AtomicExpression__Group_3__2
5125;
5126finally {
5127 restoreStackSize(stackSize);
5128}
5129
5130rule__AtomicExpression__Group_3__1__Impl
5131 @init {
5132 int stackSize = keepStackSize();
5133 }
5134:
5135(
5136 { before(grammarAccess.getAtomicExpressionAccess().getExpressionParserRuleCall_3_1()); }
5137 ruleExpression
5138 { after(grammarAccess.getAtomicExpressionAccess().getExpressionParserRuleCall_3_1()); }
5139)
5140;
5141finally {
5142 restoreStackSize(stackSize);
5143}
5144
5145rule__AtomicExpression__Group_3__2
5146 @init {
5147 int stackSize = keepStackSize();
5148 }
5149:
5150 rule__AtomicExpression__Group_3__2__Impl
5151;
5152finally {
5153 restoreStackSize(stackSize);
5154}
5155
5156rule__AtomicExpression__Group_3__2__Impl
5157 @init {
5158 int stackSize = keepStackSize();
5159 }
5160:
5161(
5162 { before(grammarAccess.getAtomicExpressionAccess().getRightParenthesisKeyword_3_2()); }
3699 ')' 5163 ')'
3700 { after(grammarAccess.getConstraintAccess().getRightParenthesisKeyword_0_2_3()); } 5164 { after(grammarAccess.getAtomicExpressionAccess().getRightParenthesisKeyword_3_2()); }
3701) 5165)
3702; 5166;
3703finally { 5167finally {
@@ -3705,188 +5169,242 @@ finally {
3705} 5169}
3706 5170
3707 5171
3708rule__Constraint__Group_0_2_2__0 5172rule__Call__Group__0
3709 @init { 5173 @init {
3710 int stackSize = keepStackSize(); 5174 int stackSize = keepStackSize();
3711 } 5175 }
3712: 5176:
3713 rule__Constraint__Group_0_2_2__0__Impl 5177 rule__Call__Group__0__Impl
3714 rule__Constraint__Group_0_2_2__1 5178 rule__Call__Group__1
3715; 5179;
3716finally { 5180finally {
3717 restoreStackSize(stackSize); 5181 restoreStackSize(stackSize);
3718} 5182}
3719 5183
3720rule__Constraint__Group_0_2_2__0__Impl 5184rule__Call__Group__0__Impl
3721 @init { 5185 @init {
3722 int stackSize = keepStackSize(); 5186 int stackSize = keepStackSize();
3723 } 5187 }
3724: 5188:
3725( 5189(
3726 { before(grammarAccess.getConstraintAccess().getCommaKeyword_0_2_2_0()); } 5190 { before(grammarAccess.getCallAccess().getFunctorAssignment_0()); }
3727 ',' 5191 (rule__Call__FunctorAssignment_0)
3728 { after(grammarAccess.getConstraintAccess().getCommaKeyword_0_2_2_0()); } 5192 { after(grammarAccess.getCallAccess().getFunctorAssignment_0()); }
3729) 5193)
3730; 5194;
3731finally { 5195finally {
3732 restoreStackSize(stackSize); 5196 restoreStackSize(stackSize);
3733} 5197}
3734 5198
3735rule__Constraint__Group_0_2_2__1 5199rule__Call__Group__1
3736 @init { 5200 @init {
3737 int stackSize = keepStackSize(); 5201 int stackSize = keepStackSize();
3738 } 5202 }
3739: 5203:
3740 rule__Constraint__Group_0_2_2__1__Impl 5204 rule__Call__Group__1__Impl
5205 rule__Call__Group__2
3741; 5206;
3742finally { 5207finally {
3743 restoreStackSize(stackSize); 5208 restoreStackSize(stackSize);
3744} 5209}
3745 5210
3746rule__Constraint__Group_0_2_2__1__Impl 5211rule__Call__Group__1__Impl
3747 @init { 5212 @init {
3748 int stackSize = keepStackSize(); 5213 int stackSize = keepStackSize();
3749 } 5214 }
3750: 5215:
3751( 5216(
3752 { before(grammarAccess.getConstraintAccess().getParamsAssignment_0_2_2_1()); } 5217 { before(grammarAccess.getCallAccess().getAlternatives_1()); }
3753 (rule__Constraint__ParamsAssignment_0_2_2_1) 5218 (rule__Call__Alternatives_1)?
3754 { after(grammarAccess.getConstraintAccess().getParamsAssignment_0_2_2_1()); } 5219 { after(grammarAccess.getCallAccess().getAlternatives_1()); }
3755) 5220)
3756; 5221;
3757finally { 5222finally {
3758 restoreStackSize(stackSize); 5223 restoreStackSize(stackSize);
3759} 5224}
3760 5225
5226rule__Call__Group__2
5227 @init {
5228 int stackSize = keepStackSize();
5229 }
5230:
5231 rule__Call__Group__2__Impl
5232;
5233finally {
5234 restoreStackSize(stackSize);
5235}
3761 5236
3762rule__Constraint__Group_1__0 5237rule__Call__Group__2__Impl
3763 @init { 5238 @init {
3764 int stackSize = keepStackSize(); 5239 int stackSize = keepStackSize();
3765 } 5240 }
3766: 5241:
3767 rule__Constraint__Group_1__0__Impl 5242(
3768 rule__Constraint__Group_1__1 5243 { before(grammarAccess.getCallAccess().getArgumentListAssignment_2()); }
5244 (rule__Call__ArgumentListAssignment_2)
5245 { after(grammarAccess.getCallAccess().getArgumentListAssignment_2()); }
5246)
3769; 5247;
3770finally { 5248finally {
3771 restoreStackSize(stackSize); 5249 restoreStackSize(stackSize);
3772} 5250}
3773 5251
3774rule__Constraint__Group_1__0__Impl 5252
5253rule__ArgumentList__Group__0
5254 @init {
5255 int stackSize = keepStackSize();
5256 }
5257:
5258 rule__ArgumentList__Group__0__Impl
5259 rule__ArgumentList__Group__1
5260;
5261finally {
5262 restoreStackSize(stackSize);
5263}
5264
5265rule__ArgumentList__Group__0__Impl
3775 @init { 5266 @init {
3776 int stackSize = keepStackSize(); 5267 int stackSize = keepStackSize();
3777 } 5268 }
3778: 5269:
3779( 5270(
3780 { before(grammarAccess.getConstraintAccess().getClosureTypeAssignment_1_0()); } 5271 { before(grammarAccess.getArgumentListAccess().getArgumentListAction_0()); }
3781 (rule__Constraint__ClosureTypeAssignment_1_0) 5272 ()
3782 { after(grammarAccess.getConstraintAccess().getClosureTypeAssignment_1_0()); } 5273 { after(grammarAccess.getArgumentListAccess().getArgumentListAction_0()); }
3783) 5274)
3784; 5275;
3785finally { 5276finally {
3786 restoreStackSize(stackSize); 5277 restoreStackSize(stackSize);
3787} 5278}
3788 5279
3789rule__Constraint__Group_1__1 5280rule__ArgumentList__Group__1
3790 @init { 5281 @init {
3791 int stackSize = keepStackSize(); 5282 int stackSize = keepStackSize();
3792 } 5283 }
3793: 5284:
3794 rule__Constraint__Group_1__1__Impl 5285 rule__ArgumentList__Group__1__Impl
3795 rule__Constraint__Group_1__2 5286 rule__ArgumentList__Group__2
3796; 5287;
3797finally { 5288finally {
3798 restoreStackSize(stackSize); 5289 restoreStackSize(stackSize);
3799} 5290}
3800 5291
3801rule__Constraint__Group_1__1__Impl 5292rule__ArgumentList__Group__1__Impl
3802 @init { 5293 @init {
3803 int stackSize = keepStackSize(); 5294 int stackSize = keepStackSize();
3804 } 5295 }
3805: 5296:
3806( 5297(
3807 { before(grammarAccess.getConstraintAccess().getLeftParenthesisKeyword_1_1()); } 5298 { before(grammarAccess.getArgumentListAccess().getLeftParenthesisKeyword_1()); }
3808 '(' 5299 '('
3809 { after(grammarAccess.getConstraintAccess().getLeftParenthesisKeyword_1_1()); } 5300 { after(grammarAccess.getArgumentListAccess().getLeftParenthesisKeyword_1()); }
3810) 5301)
3811; 5302;
3812finally { 5303finally {
3813 restoreStackSize(stackSize); 5304 restoreStackSize(stackSize);
3814} 5305}
3815 5306
3816rule__Constraint__Group_1__2 5307rule__ArgumentList__Group__2
3817 @init { 5308 @init {
3818 int stackSize = keepStackSize(); 5309 int stackSize = keepStackSize();
3819 } 5310 }
3820: 5311:
3821 rule__Constraint__Group_1__2__Impl 5312 rule__ArgumentList__Group__2__Impl
3822 rule__Constraint__Group_1__3 5313 rule__ArgumentList__Group__3
3823; 5314;
3824finally { 5315finally {
3825 restoreStackSize(stackSize); 5316 restoreStackSize(stackSize);
3826} 5317}
3827 5318
3828rule__Constraint__Group_1__2__Impl 5319rule__ArgumentList__Group__2__Impl
3829 @init { 5320 @init {
3830 int stackSize = keepStackSize(); 5321 int stackSize = keepStackSize();
3831 } 5322 }
3832: 5323:
3833( 5324(
3834 { before(grammarAccess.getConstraintAccess().getParamsAssignment_1_2()); } 5325 { before(grammarAccess.getArgumentListAccess().getGroup_2()); }
3835 (rule__Constraint__ParamsAssignment_1_2)? 5326 (rule__ArgumentList__Group_2__0)?
3836 { after(grammarAccess.getConstraintAccess().getParamsAssignment_1_2()); } 5327 { after(grammarAccess.getArgumentListAccess().getGroup_2()); }
3837) 5328)
3838; 5329;
3839finally { 5330finally {
3840 restoreStackSize(stackSize); 5331 restoreStackSize(stackSize);
3841} 5332}
3842 5333
3843rule__Constraint__Group_1__3 5334rule__ArgumentList__Group__3
3844 @init { 5335 @init {
3845 int stackSize = keepStackSize(); 5336 int stackSize = keepStackSize();
3846 } 5337 }
3847: 5338:
3848 rule__Constraint__Group_1__3__Impl 5339 rule__ArgumentList__Group__3__Impl
3849 rule__Constraint__Group_1__4
3850; 5340;
3851finally { 5341finally {
3852 restoreStackSize(stackSize); 5342 restoreStackSize(stackSize);
3853} 5343}
3854 5344
3855rule__Constraint__Group_1__3__Impl 5345rule__ArgumentList__Group__3__Impl
3856 @init { 5346 @init {
3857 int stackSize = keepStackSize(); 5347 int stackSize = keepStackSize();
3858 } 5348 }
3859: 5349:
3860( 5350(
3861 { before(grammarAccess.getConstraintAccess().getGroup_1_3()); } 5351 { before(grammarAccess.getArgumentListAccess().getRightParenthesisKeyword_3()); }
3862 (rule__Constraint__Group_1_3__0)* 5352 ')'
3863 { after(grammarAccess.getConstraintAccess().getGroup_1_3()); } 5353 { after(grammarAccess.getArgumentListAccess().getRightParenthesisKeyword_3()); }
3864) 5354)
3865; 5355;
3866finally { 5356finally {
3867 restoreStackSize(stackSize); 5357 restoreStackSize(stackSize);
3868} 5358}
3869 5359
3870rule__Constraint__Group_1__4 5360
5361rule__ArgumentList__Group_2__0
3871 @init { 5362 @init {
3872 int stackSize = keepStackSize(); 5363 int stackSize = keepStackSize();
3873 } 5364 }
3874: 5365:
3875 rule__Constraint__Group_1__4__Impl 5366 rule__ArgumentList__Group_2__0__Impl
5367 rule__ArgumentList__Group_2__1
3876; 5368;
3877finally { 5369finally {
3878 restoreStackSize(stackSize); 5370 restoreStackSize(stackSize);
3879} 5371}
3880 5372
3881rule__Constraint__Group_1__4__Impl 5373rule__ArgumentList__Group_2__0__Impl
3882 @init { 5374 @init {
3883 int stackSize = keepStackSize(); 5375 int stackSize = keepStackSize();
3884 } 5376 }
3885: 5377:
3886( 5378(
3887 { before(grammarAccess.getConstraintAccess().getRightParenthesisKeyword_1_4()); } 5379 { before(grammarAccess.getArgumentListAccess().getArgumentsAssignment_2_0()); }
3888 ')' 5380 (rule__ArgumentList__ArgumentsAssignment_2_0)
3889 { after(grammarAccess.getConstraintAccess().getRightParenthesisKeyword_1_4()); } 5381 { after(grammarAccess.getArgumentListAccess().getArgumentsAssignment_2_0()); }
5382)
5383;
5384finally {
5385 restoreStackSize(stackSize);
5386}
5387
5388rule__ArgumentList__Group_2__1
5389 @init {
5390 int stackSize = keepStackSize();
5391 }
5392:
5393 rule__ArgumentList__Group_2__1__Impl
5394;
5395finally {
5396 restoreStackSize(stackSize);
5397}
5398
5399rule__ArgumentList__Group_2__1__Impl
5400 @init {
5401 int stackSize = keepStackSize();
5402 }
5403:
5404(
5405 { before(grammarAccess.getArgumentListAccess().getGroup_2_1()); }
5406 (rule__ArgumentList__Group_2_1__0)*
5407 { after(grammarAccess.getArgumentListAccess().getGroup_2_1()); }
3890) 5408)
3891; 5409;
3892finally { 5410finally {
@@ -3894,53 +5412,53 @@ finally {
3894} 5412}
3895 5413
3896 5414
3897rule__Constraint__Group_1_3__0 5415rule__ArgumentList__Group_2_1__0
3898 @init { 5416 @init {
3899 int stackSize = keepStackSize(); 5417 int stackSize = keepStackSize();
3900 } 5418 }
3901: 5419:
3902 rule__Constraint__Group_1_3__0__Impl 5420 rule__ArgumentList__Group_2_1__0__Impl
3903 rule__Constraint__Group_1_3__1 5421 rule__ArgumentList__Group_2_1__1
3904; 5422;
3905finally { 5423finally {
3906 restoreStackSize(stackSize); 5424 restoreStackSize(stackSize);
3907} 5425}
3908 5426
3909rule__Constraint__Group_1_3__0__Impl 5427rule__ArgumentList__Group_2_1__0__Impl
3910 @init { 5428 @init {
3911 int stackSize = keepStackSize(); 5429 int stackSize = keepStackSize();
3912 } 5430 }
3913: 5431:
3914( 5432(
3915 { before(grammarAccess.getConstraintAccess().getCommaKeyword_1_3_0()); } 5433 { before(grammarAccess.getArgumentListAccess().getCommaKeyword_2_1_0()); }
3916 ',' 5434 ','
3917 { after(grammarAccess.getConstraintAccess().getCommaKeyword_1_3_0()); } 5435 { after(grammarAccess.getArgumentListAccess().getCommaKeyword_2_1_0()); }
3918) 5436)
3919; 5437;
3920finally { 5438finally {
3921 restoreStackSize(stackSize); 5439 restoreStackSize(stackSize);
3922} 5440}
3923 5441
3924rule__Constraint__Group_1_3__1 5442rule__ArgumentList__Group_2_1__1
3925 @init { 5443 @init {
3926 int stackSize = keepStackSize(); 5444 int stackSize = keepStackSize();
3927 } 5445 }
3928: 5446:
3929 rule__Constraint__Group_1_3__1__Impl 5447 rule__ArgumentList__Group_2_1__1__Impl
3930; 5448;
3931finally { 5449finally {
3932 restoreStackSize(stackSize); 5450 restoreStackSize(stackSize);
3933} 5451}
3934 5452
3935rule__Constraint__Group_1_3__1__Impl 5453rule__ArgumentList__Group_2_1__1__Impl
3936 @init { 5454 @init {
3937 int stackSize = keepStackSize(); 5455 int stackSize = keepStackSize();
3938 } 5456 }
3939: 5457:
3940( 5458(
3941 { before(grammarAccess.getConstraintAccess().getParamsAssignment_1_3_1()); } 5459 { before(grammarAccess.getArgumentListAccess().getArgumentsAssignment_2_1_1()); }
3942 (rule__Constraint__ParamsAssignment_1_3_1) 5460 (rule__ArgumentList__ArgumentsAssignment_2_1_1)
3943 { after(grammarAccess.getConstraintAccess().getParamsAssignment_1_3_1()); } 5461 { after(grammarAccess.getArgumentListAccess().getArgumentsAssignment_2_1_1()); }
3944) 5462)
3945; 5463;
3946finally { 5464finally {
@@ -3948,53 +5466,53 @@ finally {
3948} 5466}
3949 5467
3950 5468
3951rule__ClosureType__Group_0__0 5469rule__StarArgument__Group__0
3952 @init { 5470 @init {
3953 int stackSize = keepStackSize(); 5471 int stackSize = keepStackSize();
3954 } 5472 }
3955: 5473:
3956 rule__ClosureType__Group_0__0__Impl 5474 rule__StarArgument__Group__0__Impl
3957 rule__ClosureType__Group_0__1 5475 rule__StarArgument__Group__1
3958; 5476;
3959finally { 5477finally {
3960 restoreStackSize(stackSize); 5478 restoreStackSize(stackSize);
3961} 5479}
3962 5480
3963rule__ClosureType__Group_0__0__Impl 5481rule__StarArgument__Group__0__Impl
3964 @init { 5482 @init {
3965 int stackSize = keepStackSize(); 5483 int stackSize = keepStackSize();
3966 } 5484 }
3967: 5485:
3968( 5486(
3969 { before(grammarAccess.getClosureTypeAccess().getReflexiveClosureAction_0_0()); } 5487 { before(grammarAccess.getStarArgumentAccess().getStarArgumentAction_0()); }
3970 () 5488 ()
3971 { after(grammarAccess.getClosureTypeAccess().getReflexiveClosureAction_0_0()); } 5489 { after(grammarAccess.getStarArgumentAccess().getStarArgumentAction_0()); }
3972) 5490)
3973; 5491;
3974finally { 5492finally {
3975 restoreStackSize(stackSize); 5493 restoreStackSize(stackSize);
3976} 5494}
3977 5495
3978rule__ClosureType__Group_0__1 5496rule__StarArgument__Group__1
3979 @init { 5497 @init {
3980 int stackSize = keepStackSize(); 5498 int stackSize = keepStackSize();
3981 } 5499 }
3982: 5500:
3983 rule__ClosureType__Group_0__1__Impl 5501 rule__StarArgument__Group__1__Impl
3984; 5502;
3985finally { 5503finally {
3986 restoreStackSize(stackSize); 5504 restoreStackSize(stackSize);
3987} 5505}
3988 5506
3989rule__ClosureType__Group_0__1__Impl 5507rule__StarArgument__Group__1__Impl
3990 @init { 5508 @init {
3991 int stackSize = keepStackSize(); 5509 int stackSize = keepStackSize();
3992 } 5510 }
3993: 5511:
3994( 5512(
3995 { before(grammarAccess.getClosureTypeAccess().getAsteriskKeyword_0_1()); } 5513 { before(grammarAccess.getStarArgumentAccess().getAsteriskKeyword_1()); }
3996 '*' 5514 '*'
3997 { after(grammarAccess.getClosureTypeAccess().getAsteriskKeyword_0_1()); } 5515 { after(grammarAccess.getStarArgumentAccess().getAsteriskKeyword_1()); }
3998) 5516)
3999; 5517;
4000finally { 5518finally {
@@ -4002,53 +5520,53 @@ finally {
4002} 5520}
4003 5521
4004 5522
4005rule__ClosureType__Group_1__0 5523rule__TypedArgument__Group__0
4006 @init { 5524 @init {
4007 int stackSize = keepStackSize(); 5525 int stackSize = keepStackSize();
4008 } 5526 }
4009: 5527:
4010 rule__ClosureType__Group_1__0__Impl 5528 rule__TypedArgument__Group__0__Impl
4011 rule__ClosureType__Group_1__1 5529 rule__TypedArgument__Group__1
4012; 5530;
4013finally { 5531finally {
4014 restoreStackSize(stackSize); 5532 restoreStackSize(stackSize);
4015} 5533}
4016 5534
4017rule__ClosureType__Group_1__0__Impl 5535rule__TypedArgument__Group__0__Impl
4018 @init { 5536 @init {
4019 int stackSize = keepStackSize(); 5537 int stackSize = keepStackSize();
4020 } 5538 }
4021: 5539:
4022( 5540(
4023 { before(grammarAccess.getClosureTypeAccess().getIrreflexiveClosureAction_1_0()); } 5541 { before(grammarAccess.getTypedArgumentAccess().getTypeAssignment_0()); }
4024 () 5542 (rule__TypedArgument__TypeAssignment_0)
4025 { after(grammarAccess.getClosureTypeAccess().getIrreflexiveClosureAction_1_0()); } 5543 { after(grammarAccess.getTypedArgumentAccess().getTypeAssignment_0()); }
4026) 5544)
4027; 5545;
4028finally { 5546finally {
4029 restoreStackSize(stackSize); 5547 restoreStackSize(stackSize);
4030} 5548}
4031 5549
4032rule__ClosureType__Group_1__1 5550rule__TypedArgument__Group__1
4033 @init { 5551 @init {
4034 int stackSize = keepStackSize(); 5552 int stackSize = keepStackSize();
4035 } 5553 }
4036: 5554:
4037 rule__ClosureType__Group_1__1__Impl 5555 rule__TypedArgument__Group__1__Impl
4038; 5556;
4039finally { 5557finally {
4040 restoreStackSize(stackSize); 5558 restoreStackSize(stackSize);
4041} 5559}
4042 5560
4043rule__ClosureType__Group_1__1__Impl 5561rule__TypedArgument__Group__1__Impl
4044 @init { 5562 @init {
4045 int stackSize = keepStackSize(); 5563 int stackSize = keepStackSize();
4046 } 5564 }
4047: 5565:
4048( 5566(
4049 { before(grammarAccess.getClosureTypeAccess().getPlusSignKeyword_1_1()); } 5567 { before(grammarAccess.getTypedArgumentAccess().getVariableAssignment_1()); }
4050 '+' 5568 (rule__TypedArgument__VariableAssignment_1)
4051 { after(grammarAccess.getClosureTypeAccess().getPlusSignKeyword_1_1()); } 5569 { after(grammarAccess.getTypedArgumentAccess().getVariableAssignment_1()); }
4052) 5570)
4053; 5571;
4054finally { 5572finally {
@@ -4056,53 +5574,188 @@ finally {
4056} 5574}
4057 5575
4058 5576
4059rule__AllInstances__Group__0 5577rule__TypedStarArgument__Group__0
4060 @init { 5578 @init {
4061 int stackSize = keepStackSize(); 5579 int stackSize = keepStackSize();
4062 } 5580 }
4063: 5581:
4064 rule__AllInstances__Group__0__Impl 5582 rule__TypedStarArgument__Group__0__Impl
4065 rule__AllInstances__Group__1 5583 rule__TypedStarArgument__Group__1
4066; 5584;
4067finally { 5585finally {
4068 restoreStackSize(stackSize); 5586 restoreStackSize(stackSize);
4069} 5587}
4070 5588
4071rule__AllInstances__Group__0__Impl 5589rule__TypedStarArgument__Group__0__Impl
4072 @init { 5590 @init {
4073 int stackSize = keepStackSize(); 5591 int stackSize = keepStackSize();
4074 } 5592 }
4075: 5593:
4076( 5594(
4077 { before(grammarAccess.getAllInstancesAccess().getColonKeyword_0()); } 5595 { before(grammarAccess.getTypedStarArgumentAccess().getTypeAssignment_0()); }
4078 ':' 5596 (rule__TypedStarArgument__TypeAssignment_0)
4079 { after(grammarAccess.getAllInstancesAccess().getColonKeyword_0()); } 5597 { after(grammarAccess.getTypedStarArgumentAccess().getTypeAssignment_0()); }
5598)
5599;
5600finally {
5601 restoreStackSize(stackSize);
5602}
5603
5604rule__TypedStarArgument__Group__1
5605 @init {
5606 int stackSize = keepStackSize();
5607 }
5608:
5609 rule__TypedStarArgument__Group__1__Impl
5610;
5611finally {
5612 restoreStackSize(stackSize);
5613}
5614
5615rule__TypedStarArgument__Group__1__Impl
5616 @init {
5617 int stackSize = keepStackSize();
5618 }
5619:
5620(
5621 { before(grammarAccess.getTypedStarArgumentAccess().getAsteriskKeyword_1()); }
5622 '*'
5623 { after(grammarAccess.getTypedStarArgumentAccess().getAsteriskKeyword_1()); }
5624)
5625;
5626finally {
5627 restoreStackSize(stackSize);
5628}
5629
5630
5631rule__Interval__Group__0
5632 @init {
5633 int stackSize = keepStackSize();
5634 }
5635:
5636 rule__Interval__Group__0__Impl
5637 rule__Interval__Group__1
5638;
5639finally {
5640 restoreStackSize(stackSize);
5641}
5642
5643rule__Interval__Group__0__Impl
5644 @init {
5645 int stackSize = keepStackSize();
5646 }
5647:
5648(
5649 { before(grammarAccess.getIntervalAccess().getLeftSquareBracketKeyword_0()); }
5650 '['
5651 { after(grammarAccess.getIntervalAccess().getLeftSquareBracketKeyword_0()); }
5652)
5653;
5654finally {
5655 restoreStackSize(stackSize);
5656}
5657
5658rule__Interval__Group__1
5659 @init {
5660 int stackSize = keepStackSize();
5661 }
5662:
5663 rule__Interval__Group__1__Impl
5664 rule__Interval__Group__2
5665;
5666finally {
5667 restoreStackSize(stackSize);
5668}
5669
5670rule__Interval__Group__1__Impl
5671 @init {
5672 int stackSize = keepStackSize();
5673 }
5674:
5675(
5676 { before(grammarAccess.getIntervalAccess().getLowerBoundAssignment_1()); }
5677 (rule__Interval__LowerBoundAssignment_1)
5678 { after(grammarAccess.getIntervalAccess().getLowerBoundAssignment_1()); }
5679)
5680;
5681finally {
5682 restoreStackSize(stackSize);
5683}
5684
5685rule__Interval__Group__2
5686 @init {
5687 int stackSize = keepStackSize();
5688 }
5689:
5690 rule__Interval__Group__2__Impl
5691 rule__Interval__Group__3
5692;
5693finally {
5694 restoreStackSize(stackSize);
5695}
5696
5697rule__Interval__Group__2__Impl
5698 @init {
5699 int stackSize = keepStackSize();
5700 }
5701:
5702(
5703 { before(grammarAccess.getIntervalAccess().getFullStopFullStopKeyword_2()); }
5704 '..'
5705 { after(grammarAccess.getIntervalAccess().getFullStopFullStopKeyword_2()); }
5706)
5707;
5708finally {
5709 restoreStackSize(stackSize);
5710}
5711
5712rule__Interval__Group__3
5713 @init {
5714 int stackSize = keepStackSize();
5715 }
5716:
5717 rule__Interval__Group__3__Impl
5718 rule__Interval__Group__4
5719;
5720finally {
5721 restoreStackSize(stackSize);
5722}
5723
5724rule__Interval__Group__3__Impl
5725 @init {
5726 int stackSize = keepStackSize();
5727 }
5728:
5729(
5730 { before(grammarAccess.getIntervalAccess().getUpperBoundAssignment_3()); }
5731 (rule__Interval__UpperBoundAssignment_3)
5732 { after(grammarAccess.getIntervalAccess().getUpperBoundAssignment_3()); }
4080) 5733)
4081; 5734;
4082finally { 5735finally {
4083 restoreStackSize(stackSize); 5736 restoreStackSize(stackSize);
4084} 5737}
4085 5738
4086rule__AllInstances__Group__1 5739rule__Interval__Group__4
4087 @init { 5740 @init {
4088 int stackSize = keepStackSize(); 5741 int stackSize = keepStackSize();
4089 } 5742 }
4090: 5743:
4091 rule__AllInstances__Group__1__Impl 5744 rule__Interval__Group__4__Impl
4092; 5745;
4093finally { 5746finally {
4094 restoreStackSize(stackSize); 5747 restoreStackSize(stackSize);
4095} 5748}
4096 5749
4097rule__AllInstances__Group__1__Impl 5750rule__Interval__Group__4__Impl
4098 @init { 5751 @init {
4099 int stackSize = keepStackSize(); 5752 int stackSize = keepStackSize();
4100 } 5753 }
4101: 5754:
4102( 5755(
4103 { before(grammarAccess.getAllInstancesAccess().getSymbolAssignment_1()); } 5756 { before(grammarAccess.getIntervalAccess().getRightSquareBracketKeyword_4()); }
4104 (rule__AllInstances__SymbolAssignment_1) 5757 ']'
4105 { after(grammarAccess.getAllInstancesAccess().getSymbolAssignment_1()); } 5758 { after(grammarAccess.getIntervalAccess().getRightSquareBracketKeyword_4()); }
4106) 5759)
4107; 5760;
4108finally { 5761finally {
@@ -4110,53 +5763,53 @@ finally {
4110} 5763}
4111 5764
4112 5765
4113rule__AllObjects__Group__0 5766rule__InfinityLiteral__Group__0
4114 @init { 5767 @init {
4115 int stackSize = keepStackSize(); 5768 int stackSize = keepStackSize();
4116 } 5769 }
4117: 5770:
4118 rule__AllObjects__Group__0__Impl 5771 rule__InfinityLiteral__Group__0__Impl
4119 rule__AllObjects__Group__1 5772 rule__InfinityLiteral__Group__1
4120; 5773;
4121finally { 5774finally {
4122 restoreStackSize(stackSize); 5775 restoreStackSize(stackSize);
4123} 5776}
4124 5777
4125rule__AllObjects__Group__0__Impl 5778rule__InfinityLiteral__Group__0__Impl
4126 @init { 5779 @init {
4127 int stackSize = keepStackSize(); 5780 int stackSize = keepStackSize();
4128 } 5781 }
4129: 5782:
4130( 5783(
4131 { before(grammarAccess.getAllObjectsAccess().getAllObjectsAction_0()); } 5784 { before(grammarAccess.getInfinityLiteralAccess().getInfinityLiteralAction_0()); }
4132 () 5785 ()
4133 { after(grammarAccess.getAllObjectsAccess().getAllObjectsAction_0()); } 5786 { after(grammarAccess.getInfinityLiteralAccess().getInfinityLiteralAction_0()); }
4134) 5787)
4135; 5788;
4136finally { 5789finally {
4137 restoreStackSize(stackSize); 5790 restoreStackSize(stackSize);
4138} 5791}
4139 5792
4140rule__AllObjects__Group__1 5793rule__InfinityLiteral__Group__1
4141 @init { 5794 @init {
4142 int stackSize = keepStackSize(); 5795 int stackSize = keepStackSize();
4143 } 5796 }
4144: 5797:
4145 rule__AllObjects__Group__1__Impl 5798 rule__InfinityLiteral__Group__1__Impl
4146; 5799;
4147finally { 5800finally {
4148 restoreStackSize(stackSize); 5801 restoreStackSize(stackSize);
4149} 5802}
4150 5803
4151rule__AllObjects__Group__1__Impl 5804rule__InfinityLiteral__Group__1__Impl
4152 @init { 5805 @init {
4153 int stackSize = keepStackSize(); 5806 int stackSize = keepStackSize();
4154 } 5807 }
4155: 5808:
4156( 5809(
4157 { before(grammarAccess.getAllObjectsAccess().getAsteriskKeyword_1()); } 5810 { before(grammarAccess.getInfinityLiteralAccess().getInfKeyword_1()); }
4158 '*' 5811 'inf'
4159 { after(grammarAccess.getAllObjectsAccess().getAsteriskKeyword_1()); } 5812 { after(grammarAccess.getInfinityLiteralAccess().getInfKeyword_1()); }
4160) 5813)
4161; 5814;
4162finally { 5815finally {
@@ -4164,53 +5817,53 @@ finally {
4164} 5817}
4165 5818
4166 5819
4167rule__DefaultInterpretation__Group__0 5820rule__EmptyIntervalLiteral__Group__0
4168 @init { 5821 @init {
4169 int stackSize = keepStackSize(); 5822 int stackSize = keepStackSize();
4170 } 5823 }
4171: 5824:
4172 rule__DefaultInterpretation__Group__0__Impl 5825 rule__EmptyIntervalLiteral__Group__0__Impl
4173 rule__DefaultInterpretation__Group__1 5826 rule__EmptyIntervalLiteral__Group__1
4174; 5827;
4175finally { 5828finally {
4176 restoreStackSize(stackSize); 5829 restoreStackSize(stackSize);
4177} 5830}
4178 5831
4179rule__DefaultInterpretation__Group__0__Impl 5832rule__EmptyIntervalLiteral__Group__0__Impl
4180 @init { 5833 @init {
4181 int stackSize = keepStackSize(); 5834 int stackSize = keepStackSize();
4182 } 5835 }
4183: 5836:
4184( 5837(
4185 { before(grammarAccess.getDefaultInterpretationAccess().getDefaultKeyword_0()); } 5838 { before(grammarAccess.getEmptyIntervalLiteralAccess().getEmptyIntervalLiteralAction_0()); }
4186 'default' 5839 ()
4187 { after(grammarAccess.getDefaultInterpretationAccess().getDefaultKeyword_0()); } 5840 { after(grammarAccess.getEmptyIntervalLiteralAccess().getEmptyIntervalLiteralAction_0()); }
4188) 5841)
4189; 5842;
4190finally { 5843finally {
4191 restoreStackSize(stackSize); 5844 restoreStackSize(stackSize);
4192} 5845}
4193 5846
4194rule__DefaultInterpretation__Group__1 5847rule__EmptyIntervalLiteral__Group__1
4195 @init { 5848 @init {
4196 int stackSize = keepStackSize(); 5849 int stackSize = keepStackSize();
4197 } 5850 }
4198: 5851:
4199 rule__DefaultInterpretation__Group__1__Impl 5852 rule__EmptyIntervalLiteral__Group__1__Impl
4200; 5853;
4201finally { 5854finally {
4202 restoreStackSize(stackSize); 5855 restoreStackSize(stackSize);
4203} 5856}
4204 5857
4205rule__DefaultInterpretation__Group__1__Impl 5858rule__EmptyIntervalLiteral__Group__1__Impl
4206 @init { 5859 @init {
4207 int stackSize = keepStackSize(); 5860 int stackSize = keepStackSize();
4208 } 5861 }
4209: 5862:
4210( 5863(
4211 { before(grammarAccess.getDefaultInterpretationAccess().getInterpretationAssignment_1()); } 5864 { before(grammarAccess.getEmptyIntervalLiteralAccess().getEmptyKeyword_1()); }
4212 (rule__DefaultInterpretation__InterpretationAssignment_1) 5865 'empty'
4213 { after(grammarAccess.getDefaultInterpretationAccess().getInterpretationAssignment_1()); } 5866 { after(grammarAccess.getEmptyIntervalLiteralAccess().getEmptyKeyword_1()); }
4214) 5867)
4215; 5868;
4216finally { 5869finally {
@@ -4218,188 +5871,188 @@ finally {
4218} 5871}
4219 5872
4220 5873
4221rule__ClassInterpretation__Group__0 5874rule__ClassDefinition__Group__0
4222 @init { 5875 @init {
4223 int stackSize = keepStackSize(); 5876 int stackSize = keepStackSize();
4224 } 5877 }
4225: 5878:
4226 rule__ClassInterpretation__Group__0__Impl 5879 rule__ClassDefinition__Group__0__Impl
4227 rule__ClassInterpretation__Group__1 5880 rule__ClassDefinition__Group__1
4228; 5881;
4229finally { 5882finally {
4230 restoreStackSize(stackSize); 5883 restoreStackSize(stackSize);
4231} 5884}
4232 5885
4233rule__ClassInterpretation__Group__0__Impl 5886rule__ClassDefinition__Group__0__Impl
4234 @init { 5887 @init {
4235 int stackSize = keepStackSize(); 5888 int stackSize = keepStackSize();
4236 } 5889 }
4237: 5890:
4238( 5891(
4239 { before(grammarAccess.getClassInterpretationAccess().getAbstractAssignment_0()); } 5892 { before(grammarAccess.getClassDefinitionAccess().getAbstractAssignment_0()); }
4240 (rule__ClassInterpretation__AbstractAssignment_0)? 5893 (rule__ClassDefinition__AbstractAssignment_0)?
4241 { after(grammarAccess.getClassInterpretationAccess().getAbstractAssignment_0()); } 5894 { after(grammarAccess.getClassDefinitionAccess().getAbstractAssignment_0()); }
4242) 5895)
4243; 5896;
4244finally { 5897finally {
4245 restoreStackSize(stackSize); 5898 restoreStackSize(stackSize);
4246} 5899}
4247 5900
4248rule__ClassInterpretation__Group__1 5901rule__ClassDefinition__Group__1
4249 @init { 5902 @init {
4250 int stackSize = keepStackSize(); 5903 int stackSize = keepStackSize();
4251 } 5904 }
4252: 5905:
4253 rule__ClassInterpretation__Group__1__Impl 5906 rule__ClassDefinition__Group__1__Impl
4254 rule__ClassInterpretation__Group__2 5907 rule__ClassDefinition__Group__2
4255; 5908;
4256finally { 5909finally {
4257 restoreStackSize(stackSize); 5910 restoreStackSize(stackSize);
4258} 5911}
4259 5912
4260rule__ClassInterpretation__Group__1__Impl 5913rule__ClassDefinition__Group__1__Impl
4261 @init { 5914 @init {
4262 int stackSize = keepStackSize(); 5915 int stackSize = keepStackSize();
4263 } 5916 }
4264: 5917:
4265( 5918(
4266 { before(grammarAccess.getClassInterpretationAccess().getClassKeyword_1()); } 5919 { before(grammarAccess.getClassDefinitionAccess().getClassKeyword_1()); }
4267 'class' 5920 'class'
4268 { after(grammarAccess.getClassInterpretationAccess().getClassKeyword_1()); } 5921 { after(grammarAccess.getClassDefinitionAccess().getClassKeyword_1()); }
4269) 5922)
4270; 5923;
4271finally { 5924finally {
4272 restoreStackSize(stackSize); 5925 restoreStackSize(stackSize);
4273} 5926}
4274 5927
4275rule__ClassInterpretation__Group__2 5928rule__ClassDefinition__Group__2
4276 @init { 5929 @init {
4277 int stackSize = keepStackSize(); 5930 int stackSize = keepStackSize();
4278 } 5931 }
4279: 5932:
4280 rule__ClassInterpretation__Group__2__Impl 5933 rule__ClassDefinition__Group__2__Impl
4281 rule__ClassInterpretation__Group__3 5934 rule__ClassDefinition__Group__3
4282; 5935;
4283finally { 5936finally {
4284 restoreStackSize(stackSize); 5937 restoreStackSize(stackSize);
4285} 5938}
4286 5939
4287rule__ClassInterpretation__Group__2__Impl 5940rule__ClassDefinition__Group__2__Impl
4288 @init { 5941 @init {
4289 int stackSize = keepStackSize(); 5942 int stackSize = keepStackSize();
4290 } 5943 }
4291: 5944:
4292( 5945(
4293 { before(grammarAccess.getClassInterpretationAccess().getSymbolAssignment_2()); } 5946 { before(grammarAccess.getClassDefinitionAccess().getNameAssignment_2()); }
4294 (rule__ClassInterpretation__SymbolAssignment_2) 5947 (rule__ClassDefinition__NameAssignment_2)
4295 { after(grammarAccess.getClassInterpretationAccess().getSymbolAssignment_2()); } 5948 { after(grammarAccess.getClassDefinitionAccess().getNameAssignment_2()); }
4296) 5949)
4297; 5950;
4298finally { 5951finally {
4299 restoreStackSize(stackSize); 5952 restoreStackSize(stackSize);
4300} 5953}
4301 5954
4302rule__ClassInterpretation__Group__3 5955rule__ClassDefinition__Group__3
4303 @init { 5956 @init {
4304 int stackSize = keepStackSize(); 5957 int stackSize = keepStackSize();
4305 } 5958 }
4306: 5959:
4307 rule__ClassInterpretation__Group__3__Impl 5960 rule__ClassDefinition__Group__3__Impl
4308 rule__ClassInterpretation__Group__4 5961 rule__ClassDefinition__Group__4
4309; 5962;
4310finally { 5963finally {
4311 restoreStackSize(stackSize); 5964 restoreStackSize(stackSize);
4312} 5965}
4313 5966
4314rule__ClassInterpretation__Group__3__Impl 5967rule__ClassDefinition__Group__3__Impl
4315 @init { 5968 @init {
4316 int stackSize = keepStackSize(); 5969 int stackSize = keepStackSize();
4317 } 5970 }
4318: 5971:
4319( 5972(
4320 { before(grammarAccess.getClassInterpretationAccess().getGroup_3()); } 5973 { before(grammarAccess.getClassDefinitionAccess().getGroup_3()); }
4321 (rule__ClassInterpretation__Group_3__0)? 5974 (rule__ClassDefinition__Group_3__0)?
4322 { after(grammarAccess.getClassInterpretationAccess().getGroup_3()); } 5975 { after(grammarAccess.getClassDefinitionAccess().getGroup_3()); }
4323) 5976)
4324; 5977;
4325finally { 5978finally {
4326 restoreStackSize(stackSize); 5979 restoreStackSize(stackSize);
4327} 5980}
4328 5981
4329rule__ClassInterpretation__Group__4 5982rule__ClassDefinition__Group__4
4330 @init { 5983 @init {
4331 int stackSize = keepStackSize(); 5984 int stackSize = keepStackSize();
4332 } 5985 }
4333: 5986:
4334 rule__ClassInterpretation__Group__4__Impl 5987 rule__ClassDefinition__Group__4__Impl
4335 rule__ClassInterpretation__Group__5 5988 rule__ClassDefinition__Group__5
4336; 5989;
4337finally { 5990finally {
4338 restoreStackSize(stackSize); 5991 restoreStackSize(stackSize);
4339} 5992}
4340 5993
4341rule__ClassInterpretation__Group__4__Impl 5994rule__ClassDefinition__Group__4__Impl
4342 @init { 5995 @init {
4343 int stackSize = keepStackSize(); 5996 int stackSize = keepStackSize();
4344 } 5997 }
4345: 5998:
4346( 5999(
4347 { before(grammarAccess.getClassInterpretationAccess().getLeftCurlyBracketKeyword_4()); } 6000 { before(grammarAccess.getClassDefinitionAccess().getLeftCurlyBracketKeyword_4()); }
4348 '{' 6001 '{'
4349 { after(grammarAccess.getClassInterpretationAccess().getLeftCurlyBracketKeyword_4()); } 6002 { after(grammarAccess.getClassDefinitionAccess().getLeftCurlyBracketKeyword_4()); }
4350) 6003)
4351; 6004;
4352finally { 6005finally {
4353 restoreStackSize(stackSize); 6006 restoreStackSize(stackSize);
4354} 6007}
4355 6008
4356rule__ClassInterpretation__Group__5 6009rule__ClassDefinition__Group__5
4357 @init { 6010 @init {
4358 int stackSize = keepStackSize(); 6011 int stackSize = keepStackSize();
4359 } 6012 }
4360: 6013:
4361 rule__ClassInterpretation__Group__5__Impl 6014 rule__ClassDefinition__Group__5__Impl
4362 rule__ClassInterpretation__Group__6 6015 rule__ClassDefinition__Group__6
4363; 6016;
4364finally { 6017finally {
4365 restoreStackSize(stackSize); 6018 restoreStackSize(stackSize);
4366} 6019}
4367 6020
4368rule__ClassInterpretation__Group__5__Impl 6021rule__ClassDefinition__Group__5__Impl
4369 @init { 6022 @init {
4370 int stackSize = keepStackSize(); 6023 int stackSize = keepStackSize();
4371 } 6024 }
4372: 6025:
4373( 6026(
4374 { before(grammarAccess.getClassInterpretationAccess().getFieltAssignment_5()); } 6027 { before(grammarAccess.getClassDefinitionAccess().getMembersAssignment_5()); }
4375 (rule__ClassInterpretation__FieltAssignment_5)* 6028 (rule__ClassDefinition__MembersAssignment_5)*
4376 { after(grammarAccess.getClassInterpretationAccess().getFieltAssignment_5()); } 6029 { after(grammarAccess.getClassDefinitionAccess().getMembersAssignment_5()); }
4377) 6030)
4378; 6031;
4379finally { 6032finally {
4380 restoreStackSize(stackSize); 6033 restoreStackSize(stackSize);
4381} 6034}
4382 6035
4383rule__ClassInterpretation__Group__6 6036rule__ClassDefinition__Group__6
4384 @init { 6037 @init {
4385 int stackSize = keepStackSize(); 6038 int stackSize = keepStackSize();
4386 } 6039 }
4387: 6040:
4388 rule__ClassInterpretation__Group__6__Impl 6041 rule__ClassDefinition__Group__6__Impl
4389; 6042;
4390finally { 6043finally {
4391 restoreStackSize(stackSize); 6044 restoreStackSize(stackSize);
4392} 6045}
4393 6046
4394rule__ClassInterpretation__Group__6__Impl 6047rule__ClassDefinition__Group__6__Impl
4395 @init { 6048 @init {
4396 int stackSize = keepStackSize(); 6049 int stackSize = keepStackSize();
4397 } 6050 }
4398: 6051:
4399( 6052(
4400 { before(grammarAccess.getClassInterpretationAccess().getRightCurlyBracketKeyword_6()); } 6053 { before(grammarAccess.getClassDefinitionAccess().getRightCurlyBracketKeyword_6()); }
4401 '}' 6054 '}'
4402 { after(grammarAccess.getClassInterpretationAccess().getRightCurlyBracketKeyword_6()); } 6055 { after(grammarAccess.getClassDefinitionAccess().getRightCurlyBracketKeyword_6()); }
4403) 6056)
4404; 6057;
4405finally { 6058finally {
@@ -4407,634 +6060,1673 @@ finally {
4407} 6060}
4408 6061
4409 6062
4410rule__ClassInterpretation__Group_3__0 6063rule__ClassDefinition__Group_3__0
4411 @init { 6064 @init {
4412 int stackSize = keepStackSize(); 6065 int stackSize = keepStackSize();
4413 } 6066 }
4414: 6067:
4415 rule__ClassInterpretation__Group_3__0__Impl 6068 rule__ClassDefinition__Group_3__0__Impl
4416 rule__ClassInterpretation__Group_3__1 6069 rule__ClassDefinition__Group_3__1
4417; 6070;
4418finally { 6071finally {
4419 restoreStackSize(stackSize); 6072 restoreStackSize(stackSize);
4420} 6073}
4421 6074
4422rule__ClassInterpretation__Group_3__0__Impl 6075rule__ClassDefinition__Group_3__0__Impl
4423 @init { 6076 @init {
4424 int stackSize = keepStackSize(); 6077 int stackSize = keepStackSize();
4425 } 6078 }
4426: 6079:
4427( 6080(
4428 { before(grammarAccess.getClassInterpretationAccess().getExtendsKeyword_3_0()); } 6081 { before(grammarAccess.getClassDefinitionAccess().getExtendsKeyword_3_0()); }
4429 'extends' 6082 'extends'
4430 { after(grammarAccess.getClassInterpretationAccess().getExtendsKeyword_3_0()); } 6083 { after(grammarAccess.getClassDefinitionAccess().getExtendsKeyword_3_0()); }
4431) 6084)
4432; 6085;
4433finally { 6086finally {
4434 restoreStackSize(stackSize); 6087 restoreStackSize(stackSize);
4435} 6088}
4436 6089
4437rule__ClassInterpretation__Group_3__1 6090rule__ClassDefinition__Group_3__1
4438 @init { 6091 @init {
4439 int stackSize = keepStackSize(); 6092 int stackSize = keepStackSize();
4440 } 6093 }
4441: 6094:
4442 rule__ClassInterpretation__Group_3__1__Impl 6095 rule__ClassDefinition__Group_3__1__Impl
6096 rule__ClassDefinition__Group_3__2
4443; 6097;
4444finally { 6098finally {
4445 restoreStackSize(stackSize); 6099 restoreStackSize(stackSize);
4446} 6100}
4447 6101
4448rule__ClassInterpretation__Group_3__1__Impl 6102rule__ClassDefinition__Group_3__1__Impl
4449 @init { 6103 @init {
4450 int stackSize = keepStackSize(); 6104 int stackSize = keepStackSize();
4451 } 6105 }
4452: 6106:
4453( 6107(
4454 ( 6108 { before(grammarAccess.getClassDefinitionAccess().getSuperclassesAssignment_3_1()); }
4455 { before(grammarAccess.getClassInterpretationAccess().getSupertypesAssignment_3_1()); } 6109 (rule__ClassDefinition__SuperclassesAssignment_3_1)
4456 (rule__ClassInterpretation__SupertypesAssignment_3_1) 6110 { after(grammarAccess.getClassDefinitionAccess().getSuperclassesAssignment_3_1()); }
4457 { after(grammarAccess.getClassInterpretationAccess().getSupertypesAssignment_3_1()); }
4458 )
4459 (
4460 { before(grammarAccess.getClassInterpretationAccess().getSupertypesAssignment_3_1()); }
4461 (rule__ClassInterpretation__SupertypesAssignment_3_1)*
4462 { after(grammarAccess.getClassInterpretationAccess().getSupertypesAssignment_3_1()); }
4463 )
4464) 6111)
4465; 6112;
4466finally { 6113finally {
4467 restoreStackSize(stackSize); 6114 restoreStackSize(stackSize);
4468} 6115}
4469 6116
6117rule__ClassDefinition__Group_3__2
6118 @init {
6119 int stackSize = keepStackSize();
6120 }
6121:
6122 rule__ClassDefinition__Group_3__2__Impl
6123;
6124finally {
6125 restoreStackSize(stackSize);
6126}
4470 6127
4471rule__EnumInterpretation__Group__0 6128rule__ClassDefinition__Group_3__2__Impl
4472 @init { 6129 @init {
4473 int stackSize = keepStackSize(); 6130 int stackSize = keepStackSize();
4474 } 6131 }
4475: 6132:
4476 rule__EnumInterpretation__Group__0__Impl 6133(
4477 rule__EnumInterpretation__Group__1 6134 { before(grammarAccess.getClassDefinitionAccess().getGroup_3_2()); }
6135 (rule__ClassDefinition__Group_3_2__0)*
6136 { after(grammarAccess.getClassDefinitionAccess().getGroup_3_2()); }
6137)
4478; 6138;
4479finally { 6139finally {
4480 restoreStackSize(stackSize); 6140 restoreStackSize(stackSize);
4481} 6141}
4482 6142
4483rule__EnumInterpretation__Group__0__Impl 6143
6144rule__ClassDefinition__Group_3_2__0
6145 @init {
6146 int stackSize = keepStackSize();
6147 }
6148:
6149 rule__ClassDefinition__Group_3_2__0__Impl
6150 rule__ClassDefinition__Group_3_2__1
6151;
6152finally {
6153 restoreStackSize(stackSize);
6154}
6155
6156rule__ClassDefinition__Group_3_2__0__Impl
4484 @init { 6157 @init {
4485 int stackSize = keepStackSize(); 6158 int stackSize = keepStackSize();
4486 } 6159 }
4487: 6160:
4488( 6161(
4489 { before(grammarAccess.getEnumInterpretationAccess().getEnumKeyword_0()); } 6162 { before(grammarAccess.getClassDefinitionAccess().getCommaKeyword_3_2_0()); }
4490 'enum' 6163 ','
4491 { after(grammarAccess.getEnumInterpretationAccess().getEnumKeyword_0()); } 6164 { after(grammarAccess.getClassDefinitionAccess().getCommaKeyword_3_2_0()); }
4492) 6165)
4493; 6166;
4494finally { 6167finally {
4495 restoreStackSize(stackSize); 6168 restoreStackSize(stackSize);
4496} 6169}
4497 6170
4498rule__EnumInterpretation__Group__1 6171rule__ClassDefinition__Group_3_2__1
4499 @init { 6172 @init {
4500 int stackSize = keepStackSize(); 6173 int stackSize = keepStackSize();
4501 } 6174 }
4502: 6175:
4503 rule__EnumInterpretation__Group__1__Impl 6176 rule__ClassDefinition__Group_3_2__1__Impl
4504 rule__EnumInterpretation__Group__2
4505; 6177;
4506finally { 6178finally {
4507 restoreStackSize(stackSize); 6179 restoreStackSize(stackSize);
4508} 6180}
4509 6181
4510rule__EnumInterpretation__Group__1__Impl 6182rule__ClassDefinition__Group_3_2__1__Impl
4511 @init { 6183 @init {
4512 int stackSize = keepStackSize(); 6184 int stackSize = keepStackSize();
4513 } 6185 }
4514: 6186:
4515( 6187(
4516 { before(grammarAccess.getEnumInterpretationAccess().getSymbolAssignment_1()); } 6188 { before(grammarAccess.getClassDefinitionAccess().getSuperclassesAssignment_3_2_1()); }
4517 (rule__EnumInterpretation__SymbolAssignment_1) 6189 (rule__ClassDefinition__SuperclassesAssignment_3_2_1)
4518 { after(grammarAccess.getEnumInterpretationAccess().getSymbolAssignment_1()); } 6190 { after(grammarAccess.getClassDefinitionAccess().getSuperclassesAssignment_3_2_1()); }
4519) 6191)
4520; 6192;
4521finally { 6193finally {
4522 restoreStackSize(stackSize); 6194 restoreStackSize(stackSize);
4523} 6195}
4524 6196
4525rule__EnumInterpretation__Group__2 6197
6198rule__MemberDefinition__Group__0
4526 @init { 6199 @init {
4527 int stackSize = keepStackSize(); 6200 int stackSize = keepStackSize();
4528 } 6201 }
4529: 6202:
4530 rule__EnumInterpretation__Group__2__Impl 6203 rule__MemberDefinition__Group__0__Impl
4531 rule__EnumInterpretation__Group__3 6204 rule__MemberDefinition__Group__1
4532; 6205;
4533finally { 6206finally {
4534 restoreStackSize(stackSize); 6207 restoreStackSize(stackSize);
4535} 6208}
4536 6209
4537rule__EnumInterpretation__Group__2__Impl 6210rule__MemberDefinition__Group__0__Impl
4538 @init { 6211 @init {
4539 int stackSize = keepStackSize(); 6212 int stackSize = keepStackSize();
4540 } 6213 }
4541: 6214:
4542( 6215(
4543 { before(grammarAccess.getEnumInterpretationAccess().getLeftCurlyBracketKeyword_2()); } 6216 { before(grammarAccess.getMemberDefinitionAccess().getContainmentAssignment_0()); }
4544 '{' 6217 (rule__MemberDefinition__ContainmentAssignment_0)?
4545 { after(grammarAccess.getEnumInterpretationAccess().getLeftCurlyBracketKeyword_2()); } 6218 { after(grammarAccess.getMemberDefinitionAccess().getContainmentAssignment_0()); }
4546) 6219)
4547; 6220;
4548finally { 6221finally {
4549 restoreStackSize(stackSize); 6222 restoreStackSize(stackSize);
4550} 6223}
4551 6224
4552rule__EnumInterpretation__Group__3 6225rule__MemberDefinition__Group__1
4553 @init { 6226 @init {
4554 int stackSize = keepStackSize(); 6227 int stackSize = keepStackSize();
4555 } 6228 }
4556: 6229:
4557 rule__EnumInterpretation__Group__3__Impl 6230 rule__MemberDefinition__Group__1__Impl
4558 rule__EnumInterpretation__Group__4 6231 rule__MemberDefinition__Group__2
4559; 6232;
4560finally { 6233finally {
4561 restoreStackSize(stackSize); 6234 restoreStackSize(stackSize);
4562} 6235}
4563 6236
4564rule__EnumInterpretation__Group__3__Impl 6237rule__MemberDefinition__Group__1__Impl
4565 @init { 6238 @init {
4566 int stackSize = keepStackSize(); 6239 int stackSize = keepStackSize();
4567 } 6240 }
4568: 6241:
4569( 6242(
4570 ( 6243 { before(grammarAccess.getMemberDefinitionAccess().getTypeAssignment_1()); }
4571 { before(grammarAccess.getEnumInterpretationAccess().getObjectsAssignment_3()); } 6244 (rule__MemberDefinition__TypeAssignment_1)
4572 (rule__EnumInterpretation__ObjectsAssignment_3) 6245 { after(grammarAccess.getMemberDefinitionAccess().getTypeAssignment_1()); }
4573 { after(grammarAccess.getEnumInterpretationAccess().getObjectsAssignment_3()); }
4574 )
4575 (
4576 { before(grammarAccess.getEnumInterpretationAccess().getObjectsAssignment_3()); }
4577 (rule__EnumInterpretation__ObjectsAssignment_3)*
4578 { after(grammarAccess.getEnumInterpretationAccess().getObjectsAssignment_3()); }
4579 )
4580) 6246)
4581; 6247;
4582finally { 6248finally {
4583 restoreStackSize(stackSize); 6249 restoreStackSize(stackSize);
4584} 6250}
4585 6251
4586rule__EnumInterpretation__Group__4 6252rule__MemberDefinition__Group__2
4587 @init { 6253 @init {
4588 int stackSize = keepStackSize(); 6254 int stackSize = keepStackSize();
4589 } 6255 }
4590: 6256:
4591 rule__EnumInterpretation__Group__4__Impl 6257 rule__MemberDefinition__Group__2__Impl
6258 rule__MemberDefinition__Group__3
4592; 6259;
4593finally { 6260finally {
4594 restoreStackSize(stackSize); 6261 restoreStackSize(stackSize);
4595} 6262}
4596 6263
4597rule__EnumInterpretation__Group__4__Impl 6264rule__MemberDefinition__Group__2__Impl
4598 @init { 6265 @init {
4599 int stackSize = keepStackSize(); 6266 int stackSize = keepStackSize();
4600 } 6267 }
4601: 6268:
4602( 6269(
4603 { before(grammarAccess.getEnumInterpretationAccess().getRightCurlyBracketKeyword_4()); } 6270 { before(grammarAccess.getMemberDefinitionAccess().getMultiplicityAssignment_2()); }
4604 '}' 6271 (rule__MemberDefinition__MultiplicityAssignment_2)?
4605 { after(grammarAccess.getEnumInterpretationAccess().getRightCurlyBracketKeyword_4()); } 6272 { after(grammarAccess.getMemberDefinitionAccess().getMultiplicityAssignment_2()); }
4606) 6273)
4607; 6274;
4608finally { 6275finally {
4609 restoreStackSize(stackSize); 6276 restoreStackSize(stackSize);
4610} 6277}
4611 6278
6279rule__MemberDefinition__Group__3
6280 @init {
6281 int stackSize = keepStackSize();
6282 }
6283:
6284 rule__MemberDefinition__Group__3__Impl
6285 rule__MemberDefinition__Group__4
6286;
6287finally {
6288 restoreStackSize(stackSize);
6289}
6290
6291rule__MemberDefinition__Group__3__Impl
6292 @init {
6293 int stackSize = keepStackSize();
6294 }
6295:
6296(
6297 { before(grammarAccess.getMemberDefinitionAccess().getNameAssignment_3()); }
6298 (rule__MemberDefinition__NameAssignment_3)
6299 { after(grammarAccess.getMemberDefinitionAccess().getNameAssignment_3()); }
6300)
6301;
6302finally {
6303 restoreStackSize(stackSize);
6304}
4612 6305
4613rule__FieldRelationInterpretation__Group__0 6306rule__MemberDefinition__Group__4
4614 @init { 6307 @init {
4615 int stackSize = keepStackSize(); 6308 int stackSize = keepStackSize();
4616 } 6309 }
4617: 6310:
4618 rule__FieldRelationInterpretation__Group__0__Impl 6311 rule__MemberDefinition__Group__4__Impl
4619 rule__FieldRelationInterpretation__Group__1 6312 rule__MemberDefinition__Group__5
4620; 6313;
4621finally { 6314finally {
4622 restoreStackSize(stackSize); 6315 restoreStackSize(stackSize);
4623} 6316}
4624 6317
4625rule__FieldRelationInterpretation__Group__0__Impl 6318rule__MemberDefinition__Group__4__Impl
4626 @init { 6319 @init {
4627 int stackSize = keepStackSize(); 6320 int stackSize = keepStackSize();
4628 } 6321 }
4629: 6322:
4630( 6323(
4631 { before(grammarAccess.getFieldRelationInterpretationAccess().getContainmentAssignment_0()); } 6324 { before(grammarAccess.getMemberDefinitionAccess().getGroup_4()); }
4632 (rule__FieldRelationInterpretation__ContainmentAssignment_0)? 6325 (rule__MemberDefinition__Group_4__0)?
4633 { after(grammarAccess.getFieldRelationInterpretationAccess().getContainmentAssignment_0()); } 6326 { after(grammarAccess.getMemberDefinitionAccess().getGroup_4()); }
4634) 6327)
4635; 6328;
4636finally { 6329finally {
4637 restoreStackSize(stackSize); 6330 restoreStackSize(stackSize);
4638} 6331}
4639 6332
4640rule__FieldRelationInterpretation__Group__1 6333rule__MemberDefinition__Group__5
4641 @init { 6334 @init {
4642 int stackSize = keepStackSize(); 6335 int stackSize = keepStackSize();
4643 } 6336 }
4644: 6337:
4645 rule__FieldRelationInterpretation__Group__1__Impl 6338 rule__MemberDefinition__Group__5__Impl
4646 rule__FieldRelationInterpretation__Group__2
4647; 6339;
4648finally { 6340finally {
4649 restoreStackSize(stackSize); 6341 restoreStackSize(stackSize);
4650} 6342}
4651 6343
4652rule__FieldRelationInterpretation__Group__1__Impl 6344rule__MemberDefinition__Group__5__Impl
4653 @init { 6345 @init {
4654 int stackSize = keepStackSize(); 6346 int stackSize = keepStackSize();
4655 } 6347 }
4656: 6348:
4657( 6349(
4658 { before(grammarAccess.getFieldRelationInterpretationAccess().getSymbolAssignment_1()); } 6350 { before(grammarAccess.getMemberDefinitionAccess().getSemicolonKeyword_5()); }
4659 (rule__FieldRelationInterpretation__SymbolAssignment_1) 6351 (';')?
4660 { after(grammarAccess.getFieldRelationInterpretationAccess().getSymbolAssignment_1()); } 6352 { after(grammarAccess.getMemberDefinitionAccess().getSemicolonKeyword_5()); }
4661) 6353)
4662; 6354;
4663finally { 6355finally {
4664 restoreStackSize(stackSize); 6356 restoreStackSize(stackSize);
4665} 6357}
4666 6358
4667rule__FieldRelationInterpretation__Group__2 6359
6360rule__MemberDefinition__Group_4__0
4668 @init { 6361 @init {
4669 int stackSize = keepStackSize(); 6362 int stackSize = keepStackSize();
4670 } 6363 }
4671: 6364:
4672 rule__FieldRelationInterpretation__Group__2__Impl 6365 rule__MemberDefinition__Group_4__0__Impl
4673 rule__FieldRelationInterpretation__Group__3 6366 rule__MemberDefinition__Group_4__1
4674; 6367;
4675finally { 6368finally {
4676 restoreStackSize(stackSize); 6369 restoreStackSize(stackSize);
4677} 6370}
4678 6371
4679rule__FieldRelationInterpretation__Group__2__Impl 6372rule__MemberDefinition__Group_4__0__Impl
4680 @init { 6373 @init {
4681 int stackSize = keepStackSize(); 6374 int stackSize = keepStackSize();
4682 } 6375 }
4683: 6376:
4684( 6377(
4685 { before(grammarAccess.getFieldRelationInterpretationAccess().getColonKeyword_2()); } 6378 { before(grammarAccess.getMemberDefinitionAccess().getOppositeKeyword_4_0()); }
4686 ':' 6379 'opposite'
4687 { after(grammarAccess.getFieldRelationInterpretationAccess().getColonKeyword_2()); } 6380 { after(grammarAccess.getMemberDefinitionAccess().getOppositeKeyword_4_0()); }
4688) 6381)
4689; 6382;
4690finally { 6383finally {
4691 restoreStackSize(stackSize); 6384 restoreStackSize(stackSize);
4692} 6385}
4693 6386
4694rule__FieldRelationInterpretation__Group__3 6387rule__MemberDefinition__Group_4__1
4695 @init { 6388 @init {
4696 int stackSize = keepStackSize(); 6389 int stackSize = keepStackSize();
4697 } 6390 }
4698: 6391:
4699 rule__FieldRelationInterpretation__Group__3__Impl 6392 rule__MemberDefinition__Group_4__1__Impl
4700 rule__FieldRelationInterpretation__Group__4
4701; 6393;
4702finally { 6394finally {
4703 restoreStackSize(stackSize); 6395 restoreStackSize(stackSize);
4704} 6396}
4705 6397
4706rule__FieldRelationInterpretation__Group__3__Impl 6398rule__MemberDefinition__Group_4__1__Impl
4707 @init { 6399 @init {
4708 int stackSize = keepStackSize(); 6400 int stackSize = keepStackSize();
4709 } 6401 }
4710: 6402:
4711( 6403(
4712 { before(grammarAccess.getFieldRelationInterpretationAccess().getMultiplicityAssignment_3()); } 6404 { before(grammarAccess.getMemberDefinitionAccess().getOppositeAssignment_4_1()); }
4713 (rule__FieldRelationInterpretation__MultiplicityAssignment_3)? 6405 (rule__MemberDefinition__OppositeAssignment_4_1)
4714 { after(grammarAccess.getFieldRelationInterpretationAccess().getMultiplicityAssignment_3()); } 6406 { after(grammarAccess.getMemberDefinitionAccess().getOppositeAssignment_4_1()); }
4715) 6407)
4716; 6408;
4717finally { 6409finally {
4718 restoreStackSize(stackSize); 6410 restoreStackSize(stackSize);
4719} 6411}
4720 6412
4721rule__FieldRelationInterpretation__Group__4 6413
6414rule__ManyMultiplicity__Group__0
4722 @init { 6415 @init {
4723 int stackSize = keepStackSize(); 6416 int stackSize = keepStackSize();
4724 } 6417 }
4725: 6418:
4726 rule__FieldRelationInterpretation__Group__4__Impl 6419 rule__ManyMultiplicity__Group__0__Impl
6420 rule__ManyMultiplicity__Group__1
4727; 6421;
4728finally { 6422finally {
4729 restoreStackSize(stackSize); 6423 restoreStackSize(stackSize);
4730} 6424}
4731 6425
4732rule__FieldRelationInterpretation__Group__4__Impl 6426rule__ManyMultiplicity__Group__0__Impl
4733 @init { 6427 @init {
4734 int stackSize = keepStackSize(); 6428 int stackSize = keepStackSize();
4735 } 6429 }
4736: 6430:
4737( 6431(
4738 { before(grammarAccess.getFieldRelationInterpretationAccess().getTargetAssignment_4()); } 6432 { before(grammarAccess.getManyMultiplicityAccess().getManyMultiplicityAction_0()); }
4739 (rule__FieldRelationInterpretation__TargetAssignment_4) 6433 ()
4740 { after(grammarAccess.getFieldRelationInterpretationAccess().getTargetAssignment_4()); } 6434 { after(grammarAccess.getManyMultiplicityAccess().getManyMultiplicityAction_0()); }
4741) 6435)
4742; 6436;
4743finally { 6437finally {
4744 restoreStackSize(stackSize); 6438 restoreStackSize(stackSize);
4745} 6439}
4746 6440
6441rule__ManyMultiplicity__Group__1
6442 @init {
6443 int stackSize = keepStackSize();
6444 }
6445:
6446 rule__ManyMultiplicity__Group__1__Impl
6447 rule__ManyMultiplicity__Group__2
6448;
6449finally {
6450 restoreStackSize(stackSize);
6451}
4747 6452
4748rule__GlobalRelationInterpretation__Group__0 6453rule__ManyMultiplicity__Group__1__Impl
4749 @init { 6454 @init {
4750 int stackSize = keepStackSize(); 6455 int stackSize = keepStackSize();
4751 } 6456 }
4752: 6457:
4753 rule__GlobalRelationInterpretation__Group__0__Impl 6458(
4754 rule__GlobalRelationInterpretation__Group__1 6459 { before(grammarAccess.getManyMultiplicityAccess().getLeftSquareBracketKeyword_1()); }
6460 '['
6461 { after(grammarAccess.getManyMultiplicityAccess().getLeftSquareBracketKeyword_1()); }
6462)
4755; 6463;
4756finally { 6464finally {
4757 restoreStackSize(stackSize); 6465 restoreStackSize(stackSize);
4758} 6466}
4759 6467
4760rule__GlobalRelationInterpretation__Group__0__Impl 6468rule__ManyMultiplicity__Group__2
6469 @init {
6470 int stackSize = keepStackSize();
6471 }
6472:
6473 rule__ManyMultiplicity__Group__2__Impl
6474;
6475finally {
6476 restoreStackSize(stackSize);
6477}
6478
6479rule__ManyMultiplicity__Group__2__Impl
4761 @init { 6480 @init {
4762 int stackSize = keepStackSize(); 6481 int stackSize = keepStackSize();
4763 } 6482 }
4764: 6483:
4765( 6484(
4766 { before(grammarAccess.getGlobalRelationInterpretationAccess().getContainmentAssignment_0()); } 6485 { before(grammarAccess.getManyMultiplicityAccess().getRightSquareBracketKeyword_2()); }
4767 (rule__GlobalRelationInterpretation__ContainmentAssignment_0)? 6486 ']'
4768 { after(grammarAccess.getGlobalRelationInterpretationAccess().getContainmentAssignment_0()); } 6487 { after(grammarAccess.getManyMultiplicityAccess().getRightSquareBracketKeyword_2()); }
4769) 6488)
4770; 6489;
4771finally { 6490finally {
4772 restoreStackSize(stackSize); 6491 restoreStackSize(stackSize);
4773} 6492}
4774 6493
4775rule__GlobalRelationInterpretation__Group__1 6494
6495rule__ExactMultiplicity__Group__0
4776 @init { 6496 @init {
4777 int stackSize = keepStackSize(); 6497 int stackSize = keepStackSize();
4778 } 6498 }
4779: 6499:
4780 rule__GlobalRelationInterpretation__Group__1__Impl 6500 rule__ExactMultiplicity__Group__0__Impl
4781 rule__GlobalRelationInterpretation__Group__2 6501 rule__ExactMultiplicity__Group__1
4782; 6502;
4783finally { 6503finally {
4784 restoreStackSize(stackSize); 6504 restoreStackSize(stackSize);
4785} 6505}
4786 6506
4787rule__GlobalRelationInterpretation__Group__1__Impl 6507rule__ExactMultiplicity__Group__0__Impl
4788 @init { 6508 @init {
4789 int stackSize = keepStackSize(); 6509 int stackSize = keepStackSize();
4790 } 6510 }
4791: 6511:
4792( 6512(
4793 { before(grammarAccess.getGlobalRelationInterpretationAccess().getRelationKeyword_1()); } 6513 { before(grammarAccess.getExactMultiplicityAccess().getLeftSquareBracketKeyword_0()); }
4794 'relation' 6514 '['
4795 { after(grammarAccess.getGlobalRelationInterpretationAccess().getRelationKeyword_1()); } 6515 { after(grammarAccess.getExactMultiplicityAccess().getLeftSquareBracketKeyword_0()); }
4796) 6516)
4797; 6517;
4798finally { 6518finally {
4799 restoreStackSize(stackSize); 6519 restoreStackSize(stackSize);
4800} 6520}
4801 6521
4802rule__GlobalRelationInterpretation__Group__2 6522rule__ExactMultiplicity__Group__1
4803 @init { 6523 @init {
4804 int stackSize = keepStackSize(); 6524 int stackSize = keepStackSize();
4805 } 6525 }
4806: 6526:
4807 rule__GlobalRelationInterpretation__Group__2__Impl 6527 rule__ExactMultiplicity__Group__1__Impl
4808 rule__GlobalRelationInterpretation__Group__3 6528 rule__ExactMultiplicity__Group__2
4809; 6529;
4810finally { 6530finally {
4811 restoreStackSize(stackSize); 6531 restoreStackSize(stackSize);
4812} 6532}
4813 6533
4814rule__GlobalRelationInterpretation__Group__2__Impl 6534rule__ExactMultiplicity__Group__1__Impl
4815 @init { 6535 @init {
4816 int stackSize = keepStackSize(); 6536 int stackSize = keepStackSize();
4817 } 6537 }
4818: 6538:
4819( 6539(
4820 { before(grammarAccess.getGlobalRelationInterpretationAccess().getSymbolAssignment_2()); } 6540 { before(grammarAccess.getExactMultiplicityAccess().getMultiplicityAssignment_1()); }
4821 (rule__GlobalRelationInterpretation__SymbolAssignment_2) 6541 (rule__ExactMultiplicity__MultiplicityAssignment_1)
4822 { after(grammarAccess.getGlobalRelationInterpretationAccess().getSymbolAssignment_2()); } 6542 { after(grammarAccess.getExactMultiplicityAccess().getMultiplicityAssignment_1()); }
4823) 6543)
4824; 6544;
4825finally { 6545finally {
4826 restoreStackSize(stackSize); 6546 restoreStackSize(stackSize);
4827} 6547}
4828 6548
4829rule__GlobalRelationInterpretation__Group__3 6549rule__ExactMultiplicity__Group__2
4830 @init { 6550 @init {
4831 int stackSize = keepStackSize(); 6551 int stackSize = keepStackSize();
4832 } 6552 }
4833: 6553:
4834 rule__GlobalRelationInterpretation__Group__3__Impl 6554 rule__ExactMultiplicity__Group__2__Impl
4835 rule__GlobalRelationInterpretation__Group__4
4836; 6555;
4837finally { 6556finally {
4838 restoreStackSize(stackSize); 6557 restoreStackSize(stackSize);
4839} 6558}
4840 6559
4841rule__GlobalRelationInterpretation__Group__3__Impl 6560rule__ExactMultiplicity__Group__2__Impl
4842 @init { 6561 @init {
4843 int stackSize = keepStackSize(); 6562 int stackSize = keepStackSize();
4844 } 6563 }
4845: 6564:
4846( 6565(
4847 { before(grammarAccess.getGlobalRelationInterpretationAccess().getColonKeyword_3()); } 6566 { before(grammarAccess.getExactMultiplicityAccess().getRightSquareBracketKeyword_2()); }
4848 ':' 6567 ']'
4849 { after(grammarAccess.getGlobalRelationInterpretationAccess().getColonKeyword_3()); } 6568 { after(grammarAccess.getExactMultiplicityAccess().getRightSquareBracketKeyword_2()); }
4850) 6569)
4851; 6570;
4852finally { 6571finally {
4853 restoreStackSize(stackSize); 6572 restoreStackSize(stackSize);
4854} 6573}
4855 6574
4856rule__GlobalRelationInterpretation__Group__4 6575
6576rule__BoundedMultiplicity__Group__0
4857 @init { 6577 @init {
4858 int stackSize = keepStackSize(); 6578 int stackSize = keepStackSize();
4859 } 6579 }
4860: 6580:
4861 rule__GlobalRelationInterpretation__Group__4__Impl 6581 rule__BoundedMultiplicity__Group__0__Impl
4862 rule__GlobalRelationInterpretation__Group__5 6582 rule__BoundedMultiplicity__Group__1
4863; 6583;
4864finally { 6584finally {
4865 restoreStackSize(stackSize); 6585 restoreStackSize(stackSize);
4866} 6586}
4867 6587
4868rule__GlobalRelationInterpretation__Group__4__Impl 6588rule__BoundedMultiplicity__Group__0__Impl
4869 @init { 6589 @init {
4870 int stackSize = keepStackSize(); 6590 int stackSize = keepStackSize();
4871 } 6591 }
4872: 6592:
4873( 6593(
4874 { before(grammarAccess.getGlobalRelationInterpretationAccess().getSourceMultiplicityAssignment_4()); } 6594 { before(grammarAccess.getBoundedMultiplicityAccess().getLeftSquareBracketKeyword_0()); }
4875 (rule__GlobalRelationInterpretation__SourceMultiplicityAssignment_4)? 6595 '['
4876 { after(grammarAccess.getGlobalRelationInterpretationAccess().getSourceMultiplicityAssignment_4()); } 6596 { after(grammarAccess.getBoundedMultiplicityAccess().getLeftSquareBracketKeyword_0()); }
4877) 6597)
4878; 6598;
4879finally { 6599finally {
4880 restoreStackSize(stackSize); 6600 restoreStackSize(stackSize);
4881} 6601}
4882 6602
4883rule__GlobalRelationInterpretation__Group__5 6603rule__BoundedMultiplicity__Group__1
4884 @init { 6604 @init {
4885 int stackSize = keepStackSize(); 6605 int stackSize = keepStackSize();
4886 } 6606 }
4887: 6607:
4888 rule__GlobalRelationInterpretation__Group__5__Impl 6608 rule__BoundedMultiplicity__Group__1__Impl
4889 rule__GlobalRelationInterpretation__Group__6 6609 rule__BoundedMultiplicity__Group__2
4890; 6610;
4891finally { 6611finally {
4892 restoreStackSize(stackSize); 6612 restoreStackSize(stackSize);
4893} 6613}
4894 6614
4895rule__GlobalRelationInterpretation__Group__5__Impl 6615rule__BoundedMultiplicity__Group__1__Impl
4896 @init { 6616 @init {
4897 int stackSize = keepStackSize(); 6617 int stackSize = keepStackSize();
4898 } 6618 }
4899: 6619:
4900( 6620(
4901 { before(grammarAccess.getGlobalRelationInterpretationAccess().getSourceAssignment_5()); } 6621 { before(grammarAccess.getBoundedMultiplicityAccess().getLowerBoundAssignment_1()); }
4902 (rule__GlobalRelationInterpretation__SourceAssignment_5) 6622 (rule__BoundedMultiplicity__LowerBoundAssignment_1)
4903 { after(grammarAccess.getGlobalRelationInterpretationAccess().getSourceAssignment_5()); } 6623 { after(grammarAccess.getBoundedMultiplicityAccess().getLowerBoundAssignment_1()); }
4904) 6624)
4905; 6625;
4906finally { 6626finally {
4907 restoreStackSize(stackSize); 6627 restoreStackSize(stackSize);
4908} 6628}
4909 6629
4910rule__GlobalRelationInterpretation__Group__6 6630rule__BoundedMultiplicity__Group__2
4911 @init { 6631 @init {
4912 int stackSize = keepStackSize(); 6632 int stackSize = keepStackSize();
4913 } 6633 }
4914: 6634:
4915 rule__GlobalRelationInterpretation__Group__6__Impl 6635 rule__BoundedMultiplicity__Group__2__Impl
4916 rule__GlobalRelationInterpretation__Group__7 6636 rule__BoundedMultiplicity__Group__3
4917; 6637;
4918finally { 6638finally {
4919 restoreStackSize(stackSize); 6639 restoreStackSize(stackSize);
4920} 6640}
4921 6641
4922rule__GlobalRelationInterpretation__Group__6__Impl 6642rule__BoundedMultiplicity__Group__2__Impl
4923 @init { 6643 @init {
4924 int stackSize = keepStackSize(); 6644 int stackSize = keepStackSize();
4925 } 6645 }
4926: 6646:
4927( 6647(
4928 { before(grammarAccess.getGlobalRelationInterpretationAccess().getTargetMultiplicityAssignment_6()); } 6648 { before(grammarAccess.getBoundedMultiplicityAccess().getFullStopFullStopKeyword_2()); }
4929 (rule__GlobalRelationInterpretation__TargetMultiplicityAssignment_6)? 6649 '..'
4930 { after(grammarAccess.getGlobalRelationInterpretationAccess().getTargetMultiplicityAssignment_6()); } 6650 { after(grammarAccess.getBoundedMultiplicityAccess().getFullStopFullStopKeyword_2()); }
4931) 6651)
4932; 6652;
4933finally { 6653finally {
4934 restoreStackSize(stackSize); 6654 restoreStackSize(stackSize);
4935} 6655}
4936 6656
4937rule__GlobalRelationInterpretation__Group__7 6657rule__BoundedMultiplicity__Group__3
4938 @init { 6658 @init {
4939 int stackSize = keepStackSize(); 6659 int stackSize = keepStackSize();
4940 } 6660 }
4941: 6661:
4942 rule__GlobalRelationInterpretation__Group__7__Impl 6662 rule__BoundedMultiplicity__Group__3__Impl
6663 rule__BoundedMultiplicity__Group__4
4943; 6664;
4944finally { 6665finally {
4945 restoreStackSize(stackSize); 6666 restoreStackSize(stackSize);
4946} 6667}
4947 6668
4948rule__GlobalRelationInterpretation__Group__7__Impl 6669rule__BoundedMultiplicity__Group__3__Impl
4949 @init { 6670 @init {
4950 int stackSize = keepStackSize(); 6671 int stackSize = keepStackSize();
4951 } 6672 }
4952: 6673:
4953( 6674(
4954 { before(grammarAccess.getGlobalRelationInterpretationAccess().getTargetAssignment_7()); } 6675 { before(grammarAccess.getBoundedMultiplicityAccess().getUpperBoundAssignment_3()); }
4955 (rule__GlobalRelationInterpretation__TargetAssignment_7) 6676 (rule__BoundedMultiplicity__UpperBoundAssignment_3)
4956 { after(grammarAccess.getGlobalRelationInterpretationAccess().getTargetAssignment_7()); } 6677 { after(grammarAccess.getBoundedMultiplicityAccess().getUpperBoundAssignment_3()); }
4957) 6678)
4958; 6679;
4959finally { 6680finally {
4960 restoreStackSize(stackSize); 6681 restoreStackSize(stackSize);
4961} 6682}
4962 6683
6684rule__BoundedMultiplicity__Group__4
6685 @init {
6686 int stackSize = keepStackSize();
6687 }
6688:
6689 rule__BoundedMultiplicity__Group__4__Impl
6690;
6691finally {
6692 restoreStackSize(stackSize);
6693}
4963 6694
4964rule__MultiplicityDefinition__Group__0 6695rule__BoundedMultiplicity__Group__4__Impl
4965 @init { 6696 @init {
4966 int stackSize = keepStackSize(); 6697 int stackSize = keepStackSize();
4967 } 6698 }
4968: 6699:
4969 rule__MultiplicityDefinition__Group__0__Impl 6700(
4970 rule__MultiplicityDefinition__Group__1 6701 { before(grammarAccess.getBoundedMultiplicityAccess().getRightSquareBracketKeyword_4()); }
6702 ']'
6703 { after(grammarAccess.getBoundedMultiplicityAccess().getRightSquareBracketKeyword_4()); }
6704)
4971; 6705;
4972finally { 6706finally {
4973 restoreStackSize(stackSize); 6707 restoreStackSize(stackSize);
4974} 6708}
4975 6709
4976rule__MultiplicityDefinition__Group__0__Impl 6710
6711rule__ExactScopeDefinition__Group__0
6712 @init {
6713 int stackSize = keepStackSize();
6714 }
6715:
6716 rule__ExactScopeDefinition__Group__0__Impl
6717 rule__ExactScopeDefinition__Group__1
6718;
6719finally {
6720 restoreStackSize(stackSize);
6721}
6722
6723rule__ExactScopeDefinition__Group__0__Impl
4977 @init { 6724 @init {
4978 int stackSize = keepStackSize(); 6725 int stackSize = keepStackSize();
4979 } 6726 }
4980: 6727:
4981( 6728(
4982 { before(grammarAccess.getMultiplicityDefinitionAccess().getLowerAssignment_0()); } 6729 { before(grammarAccess.getExactScopeDefinitionAccess().getScopeKeyword_0()); }
4983 (rule__MultiplicityDefinition__LowerAssignment_0) 6730 'scope'
4984 { after(grammarAccess.getMultiplicityDefinitionAccess().getLowerAssignment_0()); } 6731 { after(grammarAccess.getExactScopeDefinitionAccess().getScopeKeyword_0()); }
4985) 6732)
4986; 6733;
4987finally { 6734finally {
4988 restoreStackSize(stackSize); 6735 restoreStackSize(stackSize);
4989} 6736}
4990 6737
4991rule__MultiplicityDefinition__Group__1 6738rule__ExactScopeDefinition__Group__1
4992 @init { 6739 @init {
4993 int stackSize = keepStackSize(); 6740 int stackSize = keepStackSize();
4994 } 6741 }
4995: 6742:
4996 rule__MultiplicityDefinition__Group__1__Impl 6743 rule__ExactScopeDefinition__Group__1__Impl
4997 rule__MultiplicityDefinition__Group__2 6744 rule__ExactScopeDefinition__Group__2
4998; 6745;
4999finally { 6746finally {
5000 restoreStackSize(stackSize); 6747 restoreStackSize(stackSize);
5001} 6748}
5002 6749
5003rule__MultiplicityDefinition__Group__1__Impl 6750rule__ExactScopeDefinition__Group__1__Impl
5004 @init { 6751 @init {
5005 int stackSize = keepStackSize(); 6752 int stackSize = keepStackSize();
5006 } 6753 }
5007: 6754:
5008( 6755(
5009 { before(grammarAccess.getMultiplicityDefinitionAccess().getFullStopFullStopKeyword_1()); } 6756 { before(grammarAccess.getExactScopeDefinitionAccess().getTypeAssignment_1()); }
5010 '..' 6757 (rule__ExactScopeDefinition__TypeAssignment_1)
5011 { after(grammarAccess.getMultiplicityDefinitionAccess().getFullStopFullStopKeyword_1()); } 6758 { after(grammarAccess.getExactScopeDefinitionAccess().getTypeAssignment_1()); }
6759)
6760;
6761finally {
6762 restoreStackSize(stackSize);
6763}
6764
6765rule__ExactScopeDefinition__Group__2
6766 @init {
6767 int stackSize = keepStackSize();
6768 }
6769:
6770 rule__ExactScopeDefinition__Group__2__Impl
6771 rule__ExactScopeDefinition__Group__3
6772;
6773finally {
6774 restoreStackSize(stackSize);
6775}
6776
6777rule__ExactScopeDefinition__Group__2__Impl
6778 @init {
6779 int stackSize = keepStackSize();
6780 }
6781:
6782(
6783 { before(grammarAccess.getExactScopeDefinitionAccess().getEqualsSignEqualsSignKeyword_2()); }
6784 '=='
6785 { after(grammarAccess.getExactScopeDefinitionAccess().getEqualsSignEqualsSignKeyword_2()); }
6786)
6787;
6788finally {
6789 restoreStackSize(stackSize);
6790}
6791
6792rule__ExactScopeDefinition__Group__3
6793 @init {
6794 int stackSize = keepStackSize();
6795 }
6796:
6797 rule__ExactScopeDefinition__Group__3__Impl
6798;
6799finally {
6800 restoreStackSize(stackSize);
6801}
6802
6803rule__ExactScopeDefinition__Group__3__Impl
6804 @init {
6805 int stackSize = keepStackSize();
6806 }
6807:
6808(
6809 { before(grammarAccess.getExactScopeDefinitionAccess().getExactScopeAssignment_3()); }
6810 (rule__ExactScopeDefinition__ExactScopeAssignment_3)
6811 { after(grammarAccess.getExactScopeDefinitionAccess().getExactScopeAssignment_3()); }
6812)
6813;
6814finally {
6815 restoreStackSize(stackSize);
6816}
6817
6818
6819rule__BoundedScopeDefinition__Group__0
6820 @init {
6821 int stackSize = keepStackSize();
6822 }
6823:
6824 rule__BoundedScopeDefinition__Group__0__Impl
6825 rule__BoundedScopeDefinition__Group__1
6826;
6827finally {
6828 restoreStackSize(stackSize);
6829}
6830
6831rule__BoundedScopeDefinition__Group__0__Impl
6832 @init {
6833 int stackSize = keepStackSize();
6834 }
6835:
6836(
6837 { before(grammarAccess.getBoundedScopeDefinitionAccess().getScopeKeyword_0()); }
6838 'scope'
6839 { after(grammarAccess.getBoundedScopeDefinitionAccess().getScopeKeyword_0()); }
6840)
6841;
6842finally {
6843 restoreStackSize(stackSize);
6844}
6845
6846rule__BoundedScopeDefinition__Group__1
6847 @init {
6848 int stackSize = keepStackSize();
6849 }
6850:
6851 rule__BoundedScopeDefinition__Group__1__Impl
6852 rule__BoundedScopeDefinition__Group__2
6853;
6854finally {
6855 restoreStackSize(stackSize);
6856}
6857
6858rule__BoundedScopeDefinition__Group__1__Impl
6859 @init {
6860 int stackSize = keepStackSize();
6861 }
6862:
6863(
6864 { before(grammarAccess.getBoundedScopeDefinitionAccess().getAlternatives_1()); }
6865 (rule__BoundedScopeDefinition__Alternatives_1)
6866 { after(grammarAccess.getBoundedScopeDefinitionAccess().getAlternatives_1()); }
6867)
6868;
6869finally {
6870 restoreStackSize(stackSize);
6871}
6872
6873rule__BoundedScopeDefinition__Group__2
6874 @init {
6875 int stackSize = keepStackSize();
6876 }
6877:
6878 rule__BoundedScopeDefinition__Group__2__Impl
6879;
6880finally {
6881 restoreStackSize(stackSize);
6882}
6883
6884rule__BoundedScopeDefinition__Group__2__Impl
6885 @init {
6886 int stackSize = keepStackSize();
6887 }
6888:
6889(
6890 { before(grammarAccess.getBoundedScopeDefinitionAccess().getFullStopKeyword_2()); }
6891 '.'
6892 { after(grammarAccess.getBoundedScopeDefinitionAccess().getFullStopKeyword_2()); }
6893)
6894;
6895finally {
6896 restoreStackSize(stackSize);
6897}
6898
6899
6900rule__BoundedScopeDefinition__Group_1_0__0
6901 @init {
6902 int stackSize = keepStackSize();
6903 }
6904:
6905 rule__BoundedScopeDefinition__Group_1_0__0__Impl
6906 rule__BoundedScopeDefinition__Group_1_0__1
6907;
6908finally {
6909 restoreStackSize(stackSize);
6910}
6911
6912rule__BoundedScopeDefinition__Group_1_0__0__Impl
6913 @init {
6914 int stackSize = keepStackSize();
6915 }
6916:
6917(
6918 { before(grammarAccess.getBoundedScopeDefinitionAccess().getGroup_1_0_0()); }
6919 (rule__BoundedScopeDefinition__Group_1_0_0__0)?
6920 { after(grammarAccess.getBoundedScopeDefinitionAccess().getGroup_1_0_0()); }
6921)
6922;
6923finally {
6924 restoreStackSize(stackSize);
6925}
6926
6927rule__BoundedScopeDefinition__Group_1_0__1
6928 @init {
6929 int stackSize = keepStackSize();
6930 }
6931:
6932 rule__BoundedScopeDefinition__Group_1_0__1__Impl
6933 rule__BoundedScopeDefinition__Group_1_0__2
6934;
6935finally {
6936 restoreStackSize(stackSize);
6937}
6938
6939rule__BoundedScopeDefinition__Group_1_0__1__Impl
6940 @init {
6941 int stackSize = keepStackSize();
6942 }
6943:
6944(
6945 { before(grammarAccess.getBoundedScopeDefinitionAccess().getTypeAssignment_1_0_1()); }
6946 (rule__BoundedScopeDefinition__TypeAssignment_1_0_1)
6947 { after(grammarAccess.getBoundedScopeDefinitionAccess().getTypeAssignment_1_0_1()); }
6948)
6949;
6950finally {
6951 restoreStackSize(stackSize);
6952}
6953
6954rule__BoundedScopeDefinition__Group_1_0__2
6955 @init {
6956 int stackSize = keepStackSize();
6957 }
6958:
6959 rule__BoundedScopeDefinition__Group_1_0__2__Impl
6960 rule__BoundedScopeDefinition__Group_1_0__3
6961;
6962finally {
6963 restoreStackSize(stackSize);
6964}
6965
6966rule__BoundedScopeDefinition__Group_1_0__2__Impl
6967 @init {
6968 int stackSize = keepStackSize();
6969 }
6970:
6971(
6972 { before(grammarAccess.getBoundedScopeDefinitionAccess().getLessThanSignEqualsSignKeyword_1_0_2()); }
6973 '<='
6974 { after(grammarAccess.getBoundedScopeDefinitionAccess().getLessThanSignEqualsSignKeyword_1_0_2()); }
6975)
6976;
6977finally {
6978 restoreStackSize(stackSize);
6979}
6980
6981rule__BoundedScopeDefinition__Group_1_0__3
6982 @init {
6983 int stackSize = keepStackSize();
6984 }
6985:
6986 rule__BoundedScopeDefinition__Group_1_0__3__Impl
6987;
6988finally {
6989 restoreStackSize(stackSize);
6990}
6991
6992rule__BoundedScopeDefinition__Group_1_0__3__Impl
6993 @init {
6994 int stackSize = keepStackSize();
6995 }
6996:
6997(
6998 { before(grammarAccess.getBoundedScopeDefinitionAccess().getUpperBoundAssignment_1_0_3()); }
6999 (rule__BoundedScopeDefinition__UpperBoundAssignment_1_0_3)
7000 { after(grammarAccess.getBoundedScopeDefinitionAccess().getUpperBoundAssignment_1_0_3()); }
7001)
7002;
7003finally {
7004 restoreStackSize(stackSize);
7005}
7006
7007
7008rule__BoundedScopeDefinition__Group_1_0_0__0
7009 @init {
7010 int stackSize = keepStackSize();
7011 }
7012:
7013 rule__BoundedScopeDefinition__Group_1_0_0__0__Impl
7014 rule__BoundedScopeDefinition__Group_1_0_0__1
7015;
7016finally {
7017 restoreStackSize(stackSize);
7018}
7019
7020rule__BoundedScopeDefinition__Group_1_0_0__0__Impl
7021 @init {
7022 int stackSize = keepStackSize();
7023 }
7024:
7025(
7026 { before(grammarAccess.getBoundedScopeDefinitionAccess().getLowerBoundAssignment_1_0_0_0()); }
7027 (rule__BoundedScopeDefinition__LowerBoundAssignment_1_0_0_0)
7028 { after(grammarAccess.getBoundedScopeDefinitionAccess().getLowerBoundAssignment_1_0_0_0()); }
7029)
7030;
7031finally {
7032 restoreStackSize(stackSize);
7033}
7034
7035rule__BoundedScopeDefinition__Group_1_0_0__1
7036 @init {
7037 int stackSize = keepStackSize();
7038 }
7039:
7040 rule__BoundedScopeDefinition__Group_1_0_0__1__Impl
7041;
7042finally {
7043 restoreStackSize(stackSize);
7044}
7045
7046rule__BoundedScopeDefinition__Group_1_0_0__1__Impl
7047 @init {
7048 int stackSize = keepStackSize();
7049 }
7050:
7051(
7052 { before(grammarAccess.getBoundedScopeDefinitionAccess().getLessThanSignEqualsSignKeyword_1_0_0_1()); }
7053 '<='
7054 { after(grammarAccess.getBoundedScopeDefinitionAccess().getLessThanSignEqualsSignKeyword_1_0_0_1()); }
7055)
7056;
7057finally {
7058 restoreStackSize(stackSize);
7059}
7060
7061
7062rule__BoundedScopeDefinition__Group_1_1__0
7063 @init {
7064 int stackSize = keepStackSize();
7065 }
7066:
7067 rule__BoundedScopeDefinition__Group_1_1__0__Impl
7068 rule__BoundedScopeDefinition__Group_1_1__1
7069;
7070finally {
7071 restoreStackSize(stackSize);
7072}
7073
7074rule__BoundedScopeDefinition__Group_1_1__0__Impl
7075 @init {
7076 int stackSize = keepStackSize();
7077 }
7078:
7079(
7080 { before(grammarAccess.getBoundedScopeDefinitionAccess().getUpperBoundAssignment_1_1_0()); }
7081 (rule__BoundedScopeDefinition__UpperBoundAssignment_1_1_0)
7082 { after(grammarAccess.getBoundedScopeDefinitionAccess().getUpperBoundAssignment_1_1_0()); }
7083)
7084;
7085finally {
7086 restoreStackSize(stackSize);
7087}
7088
7089rule__BoundedScopeDefinition__Group_1_1__1
7090 @init {
7091 int stackSize = keepStackSize();
7092 }
7093:
7094 rule__BoundedScopeDefinition__Group_1_1__1__Impl
7095 rule__BoundedScopeDefinition__Group_1_1__2
7096;
7097finally {
7098 restoreStackSize(stackSize);
7099}
7100
7101rule__BoundedScopeDefinition__Group_1_1__1__Impl
7102 @init {
7103 int stackSize = keepStackSize();
7104 }
7105:
7106(
7107 { before(grammarAccess.getBoundedScopeDefinitionAccess().getGreaterThanSignEqualsSignKeyword_1_1_1()); }
7108 '>='
7109 { after(grammarAccess.getBoundedScopeDefinitionAccess().getGreaterThanSignEqualsSignKeyword_1_1_1()); }
7110)
7111;
7112finally {
7113 restoreStackSize(stackSize);
7114}
7115
7116rule__BoundedScopeDefinition__Group_1_1__2
7117 @init {
7118 int stackSize = keepStackSize();
7119 }
7120:
7121 rule__BoundedScopeDefinition__Group_1_1__2__Impl
7122 rule__BoundedScopeDefinition__Group_1_1__3
7123;
7124finally {
7125 restoreStackSize(stackSize);
7126}
7127
7128rule__BoundedScopeDefinition__Group_1_1__2__Impl
7129 @init {
7130 int stackSize = keepStackSize();
7131 }
7132:
7133(
7134 { before(grammarAccess.getBoundedScopeDefinitionAccess().getTypeAssignment_1_1_2()); }
7135 (rule__BoundedScopeDefinition__TypeAssignment_1_1_2)
7136 { after(grammarAccess.getBoundedScopeDefinitionAccess().getTypeAssignment_1_1_2()); }
7137)
7138;
7139finally {
7140 restoreStackSize(stackSize);
7141}
7142
7143rule__BoundedScopeDefinition__Group_1_1__3
7144 @init {
7145 int stackSize = keepStackSize();
7146 }
7147:
7148 rule__BoundedScopeDefinition__Group_1_1__3__Impl
7149;
7150finally {
7151 restoreStackSize(stackSize);
7152}
7153
7154rule__BoundedScopeDefinition__Group_1_1__3__Impl
7155 @init {
7156 int stackSize = keepStackSize();
7157 }
7158:
7159(
7160 { before(grammarAccess.getBoundedScopeDefinitionAccess().getGroup_1_1_3()); }
7161 (rule__BoundedScopeDefinition__Group_1_1_3__0)?
7162 { after(grammarAccess.getBoundedScopeDefinitionAccess().getGroup_1_1_3()); }
7163)
7164;
7165finally {
7166 restoreStackSize(stackSize);
7167}
7168
7169
7170rule__BoundedScopeDefinition__Group_1_1_3__0
7171 @init {
7172 int stackSize = keepStackSize();
7173 }
7174:
7175 rule__BoundedScopeDefinition__Group_1_1_3__0__Impl
7176 rule__BoundedScopeDefinition__Group_1_1_3__1
7177;
7178finally {
7179 restoreStackSize(stackSize);
7180}
7181
7182rule__BoundedScopeDefinition__Group_1_1_3__0__Impl
7183 @init {
7184 int stackSize = keepStackSize();
7185 }
7186:
7187(
7188 { before(grammarAccess.getBoundedScopeDefinitionAccess().getGreaterThanSignEqualsSignKeyword_1_1_3_0()); }
7189 '>='
7190 { after(grammarAccess.getBoundedScopeDefinitionAccess().getGreaterThanSignEqualsSignKeyword_1_1_3_0()); }
7191)
7192;
7193finally {
7194 restoreStackSize(stackSize);
7195}
7196
7197rule__BoundedScopeDefinition__Group_1_1_3__1
7198 @init {
7199 int stackSize = keepStackSize();
7200 }
7201:
7202 rule__BoundedScopeDefinition__Group_1_1_3__1__Impl
7203;
7204finally {
7205 restoreStackSize(stackSize);
7206}
7207
7208rule__BoundedScopeDefinition__Group_1_1_3__1__Impl
7209 @init {
7210 int stackSize = keepStackSize();
7211 }
7212:
7213(
7214 { before(grammarAccess.getBoundedScopeDefinitionAccess().getLowerBoundAssignment_1_1_3_1()); }
7215 (rule__BoundedScopeDefinition__LowerBoundAssignment_1_1_3_1)
7216 { after(grammarAccess.getBoundedScopeDefinitionAccess().getLowerBoundAssignment_1_1_3_1()); }
7217)
7218;
7219finally {
7220 restoreStackSize(stackSize);
7221}
7222
7223
7224rule__LowerBoundedScopeDefinition__Group__0
7225 @init {
7226 int stackSize = keepStackSize();
7227 }
7228:
7229 rule__LowerBoundedScopeDefinition__Group__0__Impl
7230 rule__LowerBoundedScopeDefinition__Group__1
7231;
7232finally {
7233 restoreStackSize(stackSize);
7234}
7235
7236rule__LowerBoundedScopeDefinition__Group__0__Impl
7237 @init {
7238 int stackSize = keepStackSize();
7239 }
7240:
7241(
7242 { before(grammarAccess.getLowerBoundedScopeDefinitionAccess().getScopeKeyword_0()); }
7243 'scope'
7244 { after(grammarAccess.getLowerBoundedScopeDefinitionAccess().getScopeKeyword_0()); }
7245)
7246;
7247finally {
7248 restoreStackSize(stackSize);
7249}
7250
7251rule__LowerBoundedScopeDefinition__Group__1
7252 @init {
7253 int stackSize = keepStackSize();
7254 }
7255:
7256 rule__LowerBoundedScopeDefinition__Group__1__Impl
7257 rule__LowerBoundedScopeDefinition__Group__2
7258;
7259finally {
7260 restoreStackSize(stackSize);
7261}
7262
7263rule__LowerBoundedScopeDefinition__Group__1__Impl
7264 @init {
7265 int stackSize = keepStackSize();
7266 }
7267:
7268(
7269 { before(grammarAccess.getLowerBoundedScopeDefinitionAccess().getAlternatives_1()); }
7270 (rule__LowerBoundedScopeDefinition__Alternatives_1)
7271 { after(grammarAccess.getLowerBoundedScopeDefinitionAccess().getAlternatives_1()); }
7272)
7273;
7274finally {
7275 restoreStackSize(stackSize);
7276}
7277
7278rule__LowerBoundedScopeDefinition__Group__2
7279 @init {
7280 int stackSize = keepStackSize();
7281 }
7282:
7283 rule__LowerBoundedScopeDefinition__Group__2__Impl
7284;
7285finally {
7286 restoreStackSize(stackSize);
7287}
7288
7289rule__LowerBoundedScopeDefinition__Group__2__Impl
7290 @init {
7291 int stackSize = keepStackSize();
7292 }
7293:
7294(
7295 { before(grammarAccess.getLowerBoundedScopeDefinitionAccess().getFullStopKeyword_2()); }
7296 '.'
7297 { after(grammarAccess.getLowerBoundedScopeDefinitionAccess().getFullStopKeyword_2()); }
7298)
7299;
7300finally {
7301 restoreStackSize(stackSize);
7302}
7303
7304
7305rule__LowerBoundedScopeDefinition__Group_1_0__0
7306 @init {
7307 int stackSize = keepStackSize();
7308 }
7309:
7310 rule__LowerBoundedScopeDefinition__Group_1_0__0__Impl
7311 rule__LowerBoundedScopeDefinition__Group_1_0__1
7312;
7313finally {
7314 restoreStackSize(stackSize);
7315}
7316
7317rule__LowerBoundedScopeDefinition__Group_1_0__0__Impl
7318 @init {
7319 int stackSize = keepStackSize();
7320 }
7321:
7322(
7323 { before(grammarAccess.getLowerBoundedScopeDefinitionAccess().getLowerBoundAssignment_1_0_0()); }
7324 (rule__LowerBoundedScopeDefinition__LowerBoundAssignment_1_0_0)
7325 { after(grammarAccess.getLowerBoundedScopeDefinitionAccess().getLowerBoundAssignment_1_0_0()); }
7326)
7327;
7328finally {
7329 restoreStackSize(stackSize);
7330}
7331
7332rule__LowerBoundedScopeDefinition__Group_1_0__1
7333 @init {
7334 int stackSize = keepStackSize();
7335 }
7336:
7337 rule__LowerBoundedScopeDefinition__Group_1_0__1__Impl
7338 rule__LowerBoundedScopeDefinition__Group_1_0__2
7339;
7340finally {
7341 restoreStackSize(stackSize);
7342}
7343
7344rule__LowerBoundedScopeDefinition__Group_1_0__1__Impl
7345 @init {
7346 int stackSize = keepStackSize();
7347 }
7348:
7349(
7350 { before(grammarAccess.getLowerBoundedScopeDefinitionAccess().getLessThanSignEqualsSignKeyword_1_0_1()); }
7351 '<='
7352 { after(grammarAccess.getLowerBoundedScopeDefinitionAccess().getLessThanSignEqualsSignKeyword_1_0_1()); }
7353)
7354;
7355finally {
7356 restoreStackSize(stackSize);
7357}
7358
7359rule__LowerBoundedScopeDefinition__Group_1_0__2
7360 @init {
7361 int stackSize = keepStackSize();
7362 }
7363:
7364 rule__LowerBoundedScopeDefinition__Group_1_0__2__Impl
7365;
7366finally {
7367 restoreStackSize(stackSize);
7368}
7369
7370rule__LowerBoundedScopeDefinition__Group_1_0__2__Impl
7371 @init {
7372 int stackSize = keepStackSize();
7373 }
7374:
7375(
7376 { before(grammarAccess.getLowerBoundedScopeDefinitionAccess().getTypeAssignment_1_0_2()); }
7377 (rule__LowerBoundedScopeDefinition__TypeAssignment_1_0_2)
7378 { after(grammarAccess.getLowerBoundedScopeDefinitionAccess().getTypeAssignment_1_0_2()); }
7379)
7380;
7381finally {
7382 restoreStackSize(stackSize);
7383}
7384
7385
7386rule__LowerBoundedScopeDefinition__Group_1_1__0
7387 @init {
7388 int stackSize = keepStackSize();
7389 }
7390:
7391 rule__LowerBoundedScopeDefinition__Group_1_1__0__Impl
7392 rule__LowerBoundedScopeDefinition__Group_1_1__1
7393;
7394finally {
7395 restoreStackSize(stackSize);
7396}
7397
7398rule__LowerBoundedScopeDefinition__Group_1_1__0__Impl
7399 @init {
7400 int stackSize = keepStackSize();
7401 }
7402:
7403(
7404 { before(grammarAccess.getLowerBoundedScopeDefinitionAccess().getTypeAssignment_1_1_0()); }
7405 (rule__LowerBoundedScopeDefinition__TypeAssignment_1_1_0)
7406 { after(grammarAccess.getLowerBoundedScopeDefinitionAccess().getTypeAssignment_1_1_0()); }
7407)
7408;
7409finally {
7410 restoreStackSize(stackSize);
7411}
7412
7413rule__LowerBoundedScopeDefinition__Group_1_1__1
7414 @init {
7415 int stackSize = keepStackSize();
7416 }
7417:
7418 rule__LowerBoundedScopeDefinition__Group_1_1__1__Impl
7419 rule__LowerBoundedScopeDefinition__Group_1_1__2
7420;
7421finally {
7422 restoreStackSize(stackSize);
7423}
7424
7425rule__LowerBoundedScopeDefinition__Group_1_1__1__Impl
7426 @init {
7427 int stackSize = keepStackSize();
7428 }
7429:
7430(
7431 { before(grammarAccess.getLowerBoundedScopeDefinitionAccess().getGreaterThanSignEqualsSignKeyword_1_1_1()); }
7432 '>='
7433 { after(grammarAccess.getLowerBoundedScopeDefinitionAccess().getGreaterThanSignEqualsSignKeyword_1_1_1()); }
7434)
7435;
7436finally {
7437 restoreStackSize(stackSize);
7438}
7439
7440rule__LowerBoundedScopeDefinition__Group_1_1__2
7441 @init {
7442 int stackSize = keepStackSize();
7443 }
7444:
7445 rule__LowerBoundedScopeDefinition__Group_1_1__2__Impl
7446;
7447finally {
7448 restoreStackSize(stackSize);
7449}
7450
7451rule__LowerBoundedScopeDefinition__Group_1_1__2__Impl
7452 @init {
7453 int stackSize = keepStackSize();
7454 }
7455:
7456(
7457 { before(grammarAccess.getLowerBoundedScopeDefinitionAccess().getLowerBoundAssignment_1_1_2()); }
7458 (rule__LowerBoundedScopeDefinition__LowerBoundAssignment_1_1_2)
7459 { after(grammarAccess.getLowerBoundedScopeDefinitionAccess().getLowerBoundAssignment_1_1_2()); }
7460)
7461;
7462finally {
7463 restoreStackSize(stackSize);
7464}
7465
7466
7467rule__ObjectiveDefinition__Group__0
7468 @init {
7469 int stackSize = keepStackSize();
7470 }
7471:
7472 rule__ObjectiveDefinition__Group__0__Impl
7473 rule__ObjectiveDefinition__Group__1
7474;
7475finally {
7476 restoreStackSize(stackSize);
7477}
7478
7479rule__ObjectiveDefinition__Group__0__Impl
7480 @init {
7481 int stackSize = keepStackSize();
7482 }
7483:
7484(
7485 { before(grammarAccess.getObjectiveDefinitionAccess().getKindAssignment_0()); }
7486 (rule__ObjectiveDefinition__KindAssignment_0)
7487 { after(grammarAccess.getObjectiveDefinitionAccess().getKindAssignment_0()); }
7488)
7489;
7490finally {
7491 restoreStackSize(stackSize);
7492}
7493
7494rule__ObjectiveDefinition__Group__1
7495 @init {
7496 int stackSize = keepStackSize();
7497 }
7498:
7499 rule__ObjectiveDefinition__Group__1__Impl
7500;
7501finally {
7502 restoreStackSize(stackSize);
7503}
7504
7505rule__ObjectiveDefinition__Group__1__Impl
7506 @init {
7507 int stackSize = keepStackSize();
7508 }
7509:
7510(
7511 { before(grammarAccess.getObjectiveDefinitionAccess().getObjectiveAssignment_1()); }
7512 (rule__ObjectiveDefinition__ObjectiveAssignment_1)
7513 { after(grammarAccess.getObjectiveDefinitionAccess().getObjectiveAssignment_1()); }
7514)
7515;
7516finally {
7517 restoreStackSize(stackSize);
7518}
7519
7520
7521rule__Real__Group__0
7522 @init {
7523 int stackSize = keepStackSize();
7524 }
7525:
7526 rule__Real__Group__0__Impl
7527 rule__Real__Group__1
7528;
7529finally {
7530 restoreStackSize(stackSize);
7531}
7532
7533rule__Real__Group__0__Impl
7534 @init {
7535 int stackSize = keepStackSize();
7536 }
7537:
7538(
7539 { before(grammarAccess.getRealAccess().getINTTerminalRuleCall_0()); }
7540 RULE_INT
7541 { after(grammarAccess.getRealAccess().getINTTerminalRuleCall_0()); }
7542)
7543;
7544finally {
7545 restoreStackSize(stackSize);
7546}
7547
7548rule__Real__Group__1
7549 @init {
7550 int stackSize = keepStackSize();
7551 }
7552:
7553 rule__Real__Group__1__Impl
7554;
7555finally {
7556 restoreStackSize(stackSize);
7557}
7558
7559rule__Real__Group__1__Impl
7560 @init {
7561 int stackSize = keepStackSize();
7562 }
7563:
7564(
7565 { before(grammarAccess.getRealAccess().getGroup_1()); }
7566 (rule__Real__Group_1__0)?
7567 { after(grammarAccess.getRealAccess().getGroup_1()); }
7568)
7569;
7570finally {
7571 restoreStackSize(stackSize);
7572}
7573
7574
7575rule__Real__Group_1__0
7576 @init {
7577 int stackSize = keepStackSize();
7578 }
7579:
7580 rule__Real__Group_1__0__Impl
7581 rule__Real__Group_1__1
7582;
7583finally {
7584 restoreStackSize(stackSize);
7585}
7586
7587rule__Real__Group_1__0__Impl
7588 @init {
7589 int stackSize = keepStackSize();
7590 }
7591:
7592(
7593 { before(grammarAccess.getRealAccess().getFullStopKeyword_1_0()); }
7594 '.'
7595 { after(grammarAccess.getRealAccess().getFullStopKeyword_1_0()); }
7596)
7597;
7598finally {
7599 restoreStackSize(stackSize);
7600}
7601
7602rule__Real__Group_1__1
7603 @init {
7604 int stackSize = keepStackSize();
7605 }
7606:
7607 rule__Real__Group_1__1__Impl
7608;
7609finally {
7610 restoreStackSize(stackSize);
7611}
7612
7613rule__Real__Group_1__1__Impl
7614 @init {
7615 int stackSize = keepStackSize();
7616 }
7617:
7618(
7619 { before(grammarAccess.getRealAccess().getINTTerminalRuleCall_1_1()); }
7620 RULE_INT
7621 { after(grammarAccess.getRealAccess().getINTTerminalRuleCall_1_1()); }
7622)
7623;
7624finally {
7625 restoreStackSize(stackSize);
7626}
7627
7628
7629rule__QualifiedName__Group_0__0
7630 @init {
7631 int stackSize = keepStackSize();
7632 }
7633:
7634 rule__QualifiedName__Group_0__0__Impl
7635 rule__QualifiedName__Group_0__1
7636;
7637finally {
7638 restoreStackSize(stackSize);
7639}
7640
7641rule__QualifiedName__Group_0__0__Impl
7642 @init {
7643 int stackSize = keepStackSize();
7644 }
7645:
7646(
7647 { before(grammarAccess.getQualifiedNameAccess().getIDTerminalRuleCall_0_0()); }
7648 RULE_ID
7649 { after(grammarAccess.getQualifiedNameAccess().getIDTerminalRuleCall_0_0()); }
7650)
7651;
7652finally {
7653 restoreStackSize(stackSize);
7654}
7655
7656rule__QualifiedName__Group_0__1
7657 @init {
7658 int stackSize = keepStackSize();
7659 }
7660:
7661 rule__QualifiedName__Group_0__1__Impl
7662;
7663finally {
7664 restoreStackSize(stackSize);
7665}
7666
7667rule__QualifiedName__Group_0__1__Impl
7668 @init {
7669 int stackSize = keepStackSize();
7670 }
7671:
7672(
7673 { before(grammarAccess.getQualifiedNameAccess().getGroup_0_1()); }
7674 (rule__QualifiedName__Group_0_1__0)*
7675 { after(grammarAccess.getQualifiedNameAccess().getGroup_0_1()); }
7676)
7677;
7678finally {
7679 restoreStackSize(stackSize);
7680}
7681
7682
7683rule__QualifiedName__Group_0_1__0
7684 @init {
7685 int stackSize = keepStackSize();
7686 }
7687:
7688 rule__QualifiedName__Group_0_1__0__Impl
7689 rule__QualifiedName__Group_0_1__1
7690;
7691finally {
7692 restoreStackSize(stackSize);
7693}
7694
7695rule__QualifiedName__Group_0_1__0__Impl
7696 @init {
7697 int stackSize = keepStackSize();
7698 }
7699:
7700(
7701 { before(grammarAccess.getQualifiedNameAccess().getFullStopKeyword_0_1_0()); }
7702 '.'
7703 { after(grammarAccess.getQualifiedNameAccess().getFullStopKeyword_0_1_0()); }
5012) 7704)
5013; 7705;
5014finally { 7706finally {
5015 restoreStackSize(stackSize); 7707 restoreStackSize(stackSize);
5016} 7708}
5017 7709
5018rule__MultiplicityDefinition__Group__2 7710rule__QualifiedName__Group_0_1__1
5019 @init { 7711 @init {
5020 int stackSize = keepStackSize(); 7712 int stackSize = keepStackSize();
5021 } 7713 }
5022: 7714:
5023 rule__MultiplicityDefinition__Group__2__Impl 7715 rule__QualifiedName__Group_0_1__1__Impl
5024; 7716;
5025finally { 7717finally {
5026 restoreStackSize(stackSize); 7718 restoreStackSize(stackSize);
5027} 7719}
5028 7720
5029rule__MultiplicityDefinition__Group__2__Impl 7721rule__QualifiedName__Group_0_1__1__Impl
5030 @init { 7722 @init {
5031 int stackSize = keepStackSize(); 7723 int stackSize = keepStackSize();
5032 } 7724 }
5033: 7725:
5034( 7726(
5035 { before(grammarAccess.getMultiplicityDefinitionAccess().getAlternatives_2()); } 7727 { before(grammarAccess.getQualifiedNameAccess().getIDTerminalRuleCall_0_1_1()); }
5036 (rule__MultiplicityDefinition__Alternatives_2) 7728 RULE_ID
5037 { after(grammarAccess.getMultiplicityDefinitionAccess().getAlternatives_2()); } 7729 { after(grammarAccess.getQualifiedNameAccess().getIDTerminalRuleCall_0_1_1()); }
5038) 7730)
5039; 7731;
5040finally { 7732finally {
@@ -5057,755 +7749,1366 @@ finally {
5057 restoreStackSize(stackSize); 7749 restoreStackSize(stackSize);
5058} 7750}
5059 7751
5060rule__BasicInterpretation__SymbolAssignment_0 7752rule__AssertionOrDefinition__RangeAssignment_1_0_1_1
5061 @init { 7753 @init {
5062 int stackSize = keepStackSize(); 7754 int stackSize = keepStackSize();
5063 } 7755 }
5064: 7756:
5065 ( 7757 (
5066 { before(grammarAccess.getBasicInterpretationAccess().getSymbolSymbolParserRuleCall_0_0()); } 7758 { before(grammarAccess.getAssertionOrDefinitionAccess().getRangeExpressionParserRuleCall_1_0_1_1_0()); }
5067 ruleSymbol 7759 ruleExpression
5068 { after(grammarAccess.getBasicInterpretationAccess().getSymbolSymbolParserRuleCall_0_0()); } 7760 { after(grammarAccess.getAssertionOrDefinitionAccess().getRangeExpressionParserRuleCall_1_0_1_1_0()); }
5069 ) 7761 )
5070; 7762;
5071finally { 7763finally {
5072 restoreStackSize(stackSize); 7764 restoreStackSize(stackSize);
5073} 7765}
5074 7766
5075rule__BasicInterpretation__ObjectsAssignment_1_1_0 7767rule__AssertionOrDefinition__BodyAssignment_1_1_2
5076 @init { 7768 @init {
5077 int stackSize = keepStackSize(); 7769 int stackSize = keepStackSize();
5078 } 7770 }
5079: 7771:
5080 ( 7772 (
5081 { before(grammarAccess.getBasicInterpretationAccess().getObjectsComplexObjectParserRuleCall_1_1_0_0()); } 7773 { before(grammarAccess.getAssertionOrDefinitionAccess().getBodyExpressionParserRuleCall_1_1_2_0()); }
5082 ruleComplexObject 7774 ruleExpression
5083 { after(grammarAccess.getBasicInterpretationAccess().getObjectsComplexObjectParserRuleCall_1_1_0_0()); } 7775 { after(grammarAccess.getAssertionOrDefinitionAccess().getBodyExpressionParserRuleCall_1_1_2_0()); }
5084 ) 7776 )
5085; 7777;
5086finally { 7778finally {
5087 restoreStackSize(stackSize); 7779 restoreStackSize(stackSize);
5088} 7780}
5089 7781
5090rule__BasicInterpretation__ObjectsAssignment_1_1_1_1 7782rule__AssertionOrDefinition__BodyAssignment_1_2_2
5091 @init { 7783 @init {
5092 int stackSize = keepStackSize(); 7784 int stackSize = keepStackSize();
5093 } 7785 }
5094: 7786:
5095 ( 7787 (
5096 { before(grammarAccess.getBasicInterpretationAccess().getObjectsComplexObjectParserRuleCall_1_1_1_1_0()); } 7788 { before(grammarAccess.getAssertionOrDefinitionAccess().getBodyExpressionParserRuleCall_1_2_2_0()); }
5097 ruleComplexObject 7789 ruleExpression
5098 { after(grammarAccess.getBasicInterpretationAccess().getObjectsComplexObjectParserRuleCall_1_1_1_1_0()); } 7790 { after(grammarAccess.getAssertionOrDefinitionAccess().getBodyExpressionParserRuleCall_1_2_2_0()); }
5099 ) 7791 )
5100; 7792;
5101finally { 7793finally {
5102 restoreStackSize(stackSize); 7794 restoreStackSize(stackSize);
5103} 7795}
5104 7796
5105rule__BasicInterpretation__ValueAssignment_3 7797rule__PredicateDefinition__FunctionalAssignment_0_0_0
5106 @init { 7798 @init {
5107 int stackSize = keepStackSize(); 7799 int stackSize = keepStackSize();
5108 } 7800 }
5109: 7801:
5110 ( 7802 (
5111 { before(grammarAccess.getBasicInterpretationAccess().getValueTruthValueParserRuleCall_3_0()); } 7803 { before(grammarAccess.getPredicateDefinitionAccess().getFunctionalFunctionalKeyword_0_0_0_0()); }
5112 ruleTruthValue 7804 (
5113 { after(grammarAccess.getBasicInterpretationAccess().getValueTruthValueParserRuleCall_3_0()); } 7805 { before(grammarAccess.getPredicateDefinitionAccess().getFunctionalFunctionalKeyword_0_0_0_0()); }
7806 'functional'
7807 { after(grammarAccess.getPredicateDefinitionAccess().getFunctionalFunctionalKeyword_0_0_0_0()); }
7808 )
7809 { after(grammarAccess.getPredicateDefinitionAccess().getFunctionalFunctionalKeyword_0_0_0_0()); }
5114 ) 7810 )
5115; 7811;
5116finally { 7812finally {
5117 restoreStackSize(stackSize); 7813 restoreStackSize(stackSize);
5118} 7814}
5119 7815
5120rule__ModelSymbol__NameAssignment 7816rule__PredicateDefinition__ErrorAssignment_0_0_1
5121 @init { 7817 @init {
5122 int stackSize = keepStackSize(); 7818 int stackSize = keepStackSize();
5123 } 7819 }
5124: 7820:
5125 ( 7821 (
5126 { before(grammarAccess.getModelSymbolAccess().getNameIDTerminalRuleCall_0()); } 7822 { before(grammarAccess.getPredicateDefinitionAccess().getErrorErrorKeyword_0_0_1_0()); }
5127 RULE_ID 7823 (
5128 { after(grammarAccess.getModelSymbolAccess().getNameIDTerminalRuleCall_0()); } 7824 { before(grammarAccess.getPredicateDefinitionAccess().getErrorErrorKeyword_0_0_1_0()); }
7825 'error'
7826 { after(grammarAccess.getPredicateDefinitionAccess().getErrorErrorKeyword_0_0_1_0()); }
7827 )
7828 { after(grammarAccess.getPredicateDefinitionAccess().getErrorErrorKeyword_0_0_1_0()); }
5129 ) 7829 )
5130; 7830;
5131finally { 7831finally {
5132 restoreStackSize(stackSize); 7832 restoreStackSize(stackSize);
5133} 7833}
5134 7834
5135rule__NamedObject__NameAssignment_1 7835rule__PredicateDefinition__ErrorAssignment_0_1_0
5136 @init { 7836 @init {
5137 int stackSize = keepStackSize(); 7837 int stackSize = keepStackSize();
5138 } 7838 }
5139: 7839:
5140 ( 7840 (
5141 { before(grammarAccess.getNamedObjectAccess().getNameIDTerminalRuleCall_1_0()); } 7841 { before(grammarAccess.getPredicateDefinitionAccess().getErrorErrorKeyword_0_1_0_0()); }
5142 RULE_ID 7842 (
5143 { after(grammarAccess.getNamedObjectAccess().getNameIDTerminalRuleCall_1_0()); } 7843 { before(grammarAccess.getPredicateDefinitionAccess().getErrorErrorKeyword_0_1_0_0()); }
7844 'error'
7845 { after(grammarAccess.getPredicateDefinitionAccess().getErrorErrorKeyword_0_1_0_0()); }
7846 )
7847 { after(grammarAccess.getPredicateDefinitionAccess().getErrorErrorKeyword_0_1_0_0()); }
5144 ) 7848 )
5145; 7849;
5146finally { 7850finally {
5147 restoreStackSize(stackSize); 7851 restoreStackSize(stackSize);
5148} 7852}
5149 7853
5150rule__UnnamedObject__NameAssignment 7854rule__PredicateDefinition__FunctionalAssignment_0_1_1
5151 @init { 7855 @init {
5152 int stackSize = keepStackSize(); 7856 int stackSize = keepStackSize();
5153 } 7857 }
5154: 7858:
5155 ( 7859 (
5156 { before(grammarAccess.getUnnamedObjectAccess().getNameIDTerminalRuleCall_0()); } 7860 { before(grammarAccess.getPredicateDefinitionAccess().getFunctionalFunctionalKeyword_0_1_1_0()); }
5157 RULE_ID 7861 (
5158 { after(grammarAccess.getUnnamedObjectAccess().getNameIDTerminalRuleCall_0()); } 7862 { before(grammarAccess.getPredicateDefinitionAccess().getFunctionalFunctionalKeyword_0_1_1_0()); }
7863 'functional'
7864 { after(grammarAccess.getPredicateDefinitionAccess().getFunctionalFunctionalKeyword_0_1_1_0()); }
7865 )
7866 { after(grammarAccess.getPredicateDefinitionAccess().getFunctionalFunctionalKeyword_0_1_1_0()); }
5159 ) 7867 )
5160; 7868;
5161finally { 7869finally {
5162 restoreStackSize(stackSize); 7870 restoreStackSize(stackSize);
5163} 7871}
5164 7872
5165rule__BooleanObject__ValueAssignment 7873rule__PredicateDefinition__HeadAssignment_1
5166 @init { 7874 @init {
5167 int stackSize = keepStackSize(); 7875 int stackSize = keepStackSize();
5168 } 7876 }
5169: 7877:
5170 ( 7878 (
5171 { before(grammarAccess.getBooleanObjectAccess().getValueBooleanValueParserRuleCall_0()); } 7879 { before(grammarAccess.getPredicateDefinitionAccess().getHeadCallParserRuleCall_1_0()); }
5172 ruleBooleanValue 7880 ruleCall
5173 { after(grammarAccess.getBooleanObjectAccess().getValueBooleanValueParserRuleCall_0()); } 7881 { after(grammarAccess.getPredicateDefinitionAccess().getHeadCallParserRuleCall_1_0()); }
5174 ) 7882 )
5175; 7883;
5176finally { 7884finally {
5177 restoreStackSize(stackSize); 7885 restoreStackSize(stackSize);
5178} 7886}
5179 7887
5180rule__IntObject__ValueAssignment 7888rule__PredicateDefinition__BodyAssignment_3
5181 @init { 7889 @init {
5182 int stackSize = keepStackSize(); 7890 int stackSize = keepStackSize();
5183 } 7891 }
5184: 7892:
5185 ( 7893 (
5186 { before(grammarAccess.getIntObjectAccess().getValueINTLiteralParserRuleCall_0()); } 7894 { before(grammarAccess.getPredicateDefinitionAccess().getBodyExpressionParserRuleCall_3_0()); }
5187 ruleINTLiteral 7895 ruleExpression
5188 { after(grammarAccess.getIntObjectAccess().getValueINTLiteralParserRuleCall_0()); } 7896 { after(grammarAccess.getPredicateDefinitionAccess().getBodyExpressionParserRuleCall_3_0()); }
5189 ) 7897 )
5190; 7898;
5191finally { 7899finally {
5192 restoreStackSize(stackSize); 7900 restoreStackSize(stackSize);
5193} 7901}
5194 7902
5195rule__RealObject__ValueAssignment 7903rule__UnnamedErrorPrediateDefinition__ArgumentListAssignment_1
5196 @init { 7904 @init {
5197 int stackSize = keepStackSize(); 7905 int stackSize = keepStackSize();
5198 } 7906 }
5199: 7907:
5200 ( 7908 (
5201 { before(grammarAccess.getRealObjectAccess().getValueREALLiteralParserRuleCall_0()); } 7909 { before(grammarAccess.getUnnamedErrorPrediateDefinitionAccess().getArgumentListArgumentListParserRuleCall_1_0()); }
5202 ruleREALLiteral 7910 ruleArgumentList
5203 { after(grammarAccess.getRealObjectAccess().getValueREALLiteralParserRuleCall_0()); } 7911 { after(grammarAccess.getUnnamedErrorPrediateDefinitionAccess().getArgumentListArgumentListParserRuleCall_1_0()); }
5204 ) 7912 )
5205; 7913;
5206finally { 7914finally {
5207 restoreStackSize(stackSize); 7915 restoreStackSize(stackSize);
5208} 7916}
5209 7917
5210rule__StringObject__ValueAssignment 7918rule__UnnamedErrorPrediateDefinition__BodyAssignment_3
5211 @init { 7919 @init {
5212 int stackSize = keepStackSize(); 7920 int stackSize = keepStackSize();
5213 } 7921 }
5214: 7922:
5215 ( 7923 (
5216 { before(grammarAccess.getStringObjectAccess().getValueSTRINGTerminalRuleCall_0()); } 7924 { before(grammarAccess.getUnnamedErrorPrediateDefinitionAccess().getBodyExpressionParserRuleCall_3_0()); }
5217 RULE_STRING 7925 ruleExpression
5218 { after(grammarAccess.getStringObjectAccess().getValueSTRINGTerminalRuleCall_0()); } 7926 { after(grammarAccess.getUnnamedErrorPrediateDefinitionAccess().getBodyExpressionParserRuleCall_3_0()); }
5219 ) 7927 )
5220; 7928;
5221finally { 7929finally {
5222 restoreStackSize(stackSize); 7930 restoreStackSize(stackSize);
5223} 7931}
5224 7932
5225rule__Predicate__IsErrorAssignment_0 7933rule__DefaultDefinition__HeadAssignment_1
5226 @init { 7934 @init {
5227 int stackSize = keepStackSize(); 7935 int stackSize = keepStackSize();
5228 } 7936 }
5229: 7937:
5230 ( 7938 (
5231 { before(grammarAccess.getPredicateAccess().getIsErrorErrorKeyword_0_0()); } 7939 { before(grammarAccess.getDefaultDefinitionAccess().getHeadCallParserRuleCall_1_0()); }
5232 ( 7940 ruleCall
5233 { before(grammarAccess.getPredicateAccess().getIsErrorErrorKeyword_0_0()); } 7941 { after(grammarAccess.getDefaultDefinitionAccess().getHeadCallParserRuleCall_1_0()); }
5234 'error'
5235 { after(grammarAccess.getPredicateAccess().getIsErrorErrorKeyword_0_0()); }
5236 )
5237 { after(grammarAccess.getPredicateAccess().getIsErrorErrorKeyword_0_0()); }
5238 ) 7942 )
5239; 7943;
5240finally { 7944finally {
5241 restoreStackSize(stackSize); 7945 restoreStackSize(stackSize);
5242} 7946}
5243 7947
5244rule__Predicate__SymbolAssignment_1 7948rule__DefaultDefinition__RangeAssignment_3
5245 @init { 7949 @init {
5246 int stackSize = keepStackSize(); 7950 int stackSize = keepStackSize();
5247 } 7951 }
5248: 7952:
5249 ( 7953 (
5250 { before(grammarAccess.getPredicateAccess().getSymbolModelSymbolParserRuleCall_1_0()); } 7954 { before(grammarAccess.getDefaultDefinitionAccess().getRangeExpressionParserRuleCall_3_0()); }
5251 ruleModelSymbol 7955 ruleExpression
5252 { after(grammarAccess.getPredicateAccess().getSymbolModelSymbolParserRuleCall_1_0()); } 7956 { after(grammarAccess.getDefaultDefinitionAccess().getRangeExpressionParserRuleCall_3_0()); }
5253 ) 7957 )
5254; 7958;
5255finally { 7959finally {
5256 restoreStackSize(stackSize); 7960 restoreStackSize(stackSize);
5257} 7961}
5258 7962
5259rule__Predicate__ParametersAssignment_2_1_0 7963rule__ExternPredicateDefinition__HeadAssignment_1
5260 @init { 7964 @init {
5261 int stackSize = keepStackSize(); 7965 int stackSize = keepStackSize();
5262 } 7966 }
5263: 7967:
5264 ( 7968 (
5265 { before(grammarAccess.getPredicateAccess().getParametersParameterParserRuleCall_2_1_0_0()); } 7969 { before(grammarAccess.getExternPredicateDefinitionAccess().getHeadCallParserRuleCall_1_0()); }
5266 ruleParameter 7970 ruleCall
5267 { after(grammarAccess.getPredicateAccess().getParametersParameterParserRuleCall_2_1_0_0()); } 7971 { after(grammarAccess.getExternPredicateDefinitionAccess().getHeadCallParserRuleCall_1_0()); }
5268 ) 7972 )
5269; 7973;
5270finally { 7974finally {
5271 restoreStackSize(stackSize); 7975 restoreStackSize(stackSize);
5272} 7976}
5273 7977
5274rule__Predicate__ParametersAssignment_2_1_1_1 7978rule__MetricDefinition__TypeAssignment_0
5275 @init { 7979 @init {
5276 int stackSize = keepStackSize(); 7980 int stackSize = keepStackSize();
5277 } 7981 }
5278: 7982:
5279 ( 7983 (
5280 { before(grammarAccess.getPredicateAccess().getParametersParameterParserRuleCall_2_1_1_1_0()); } 7984 { before(grammarAccess.getMetricDefinitionAccess().getTypeMetricTypeEnumRuleCall_0_0()); }
5281 ruleParameter 7985 ruleMetricType
5282 { after(grammarAccess.getPredicateAccess().getParametersParameterParserRuleCall_2_1_1_1_0()); } 7986 { after(grammarAccess.getMetricDefinitionAccess().getTypeMetricTypeEnumRuleCall_0_0()); }
5283 ) 7987 )
5284; 7988;
5285finally { 7989finally {
5286 restoreStackSize(stackSize); 7990 restoreStackSize(stackSize);
5287} 7991}
5288 7992
5289rule__Predicate__BodiesAssignment_4_1_0 7993rule__MetricDefinition__HeadAssignment_1
5290 @init { 7994 @init {
5291 int stackSize = keepStackSize(); 7995 int stackSize = keepStackSize();
5292 } 7996 }
5293: 7997:
5294 ( 7998 (
5295 { before(grammarAccess.getPredicateAccess().getBodiesPatternBodyParserRuleCall_4_1_0_0()); } 7999 { before(grammarAccess.getMetricDefinitionAccess().getHeadExpressionParserRuleCall_1_0()); }
5296 rulePatternBody 8000 ruleExpression
5297 { after(grammarAccess.getPredicateAccess().getBodiesPatternBodyParserRuleCall_4_1_0_0()); } 8001 { after(grammarAccess.getMetricDefinitionAccess().getHeadExpressionParserRuleCall_1_0()); }
5298 ) 8002 )
5299; 8003;
5300finally { 8004finally {
5301 restoreStackSize(stackSize); 8005 restoreStackSize(stackSize);
5302} 8006}
5303 8007
5304rule__Predicate__BodiesAssignment_4_1_1_1 8008rule__MetricDefinition__BodyAssignment_3
5305 @init { 8009 @init {
5306 int stackSize = keepStackSize(); 8010 int stackSize = keepStackSize();
5307 } 8011 }
5308: 8012:
5309 ( 8013 (
5310 { before(grammarAccess.getPredicateAccess().getBodiesPatternBodyParserRuleCall_4_1_1_1_0()); } 8014 { before(grammarAccess.getMetricDefinitionAccess().getBodyExpressionParserRuleCall_3_0()); }
5311 rulePatternBody 8015 ruleExpression
5312 { after(grammarAccess.getPredicateAccess().getBodiesPatternBodyParserRuleCall_4_1_1_1_0()); } 8016 { after(grammarAccess.getMetricDefinitionAccess().getBodyExpressionParserRuleCall_3_0()); }
5313 ) 8017 )
5314; 8018;
5315finally { 8019finally {
5316 restoreStackSize(stackSize); 8020 restoreStackSize(stackSize);
5317} 8021}
5318 8022
5319rule__Parameter__VariableAssignment_0 8023rule__ExternMetricDefinition__TypeAssignment_1
5320 @init { 8024 @init {
5321 int stackSize = keepStackSize(); 8025 int stackSize = keepStackSize();
5322 } 8026 }
5323: 8027:
5324 ( 8028 (
5325 { before(grammarAccess.getParameterAccess().getVariableVariableParserRuleCall_0_0()); } 8029 { before(grammarAccess.getExternMetricDefinitionAccess().getTypeMetricTypeEnumRuleCall_1_0()); }
5326 ruleVariable 8030 ruleMetricType
5327 { after(grammarAccess.getParameterAccess().getVariableVariableParserRuleCall_0_0()); } 8031 { after(grammarAccess.getExternMetricDefinitionAccess().getTypeMetricTypeEnumRuleCall_1_0()); }
5328 ) 8032 )
5329; 8033;
5330finally { 8034finally {
5331 restoreStackSize(stackSize); 8035 restoreStackSize(stackSize);
5332} 8036}
5333 8037
5334rule__Parameter__TypeAssignment_1_1 8038rule__ExternMetricDefinition__HeadAssignment_2
5335 @init { 8039 @init {
5336 int stackSize = keepStackSize(); 8040 int stackSize = keepStackSize();
5337 } 8041 }
5338: 8042:
5339 ( 8043 (
5340 { before(grammarAccess.getParameterAccess().getTypeSymbolParserRuleCall_1_1_0()); } 8044 { before(grammarAccess.getExternMetricDefinitionAccess().getHeadCallParserRuleCall_2_0()); }
5341 ruleSymbol 8045 ruleCall
5342 { after(grammarAccess.getParameterAccess().getTypeSymbolParserRuleCall_1_1_0()); } 8046 { after(grammarAccess.getExternMetricDefinitionAccess().getHeadCallParserRuleCall_2_0()); }
5343 ) 8047 )
5344; 8048;
5345finally { 8049finally {
5346 restoreStackSize(stackSize); 8050 restoreStackSize(stackSize);
5347} 8051}
5348 8052
5349rule__PatternBody__ConstraintsAssignment_1_1 8053rule__IfElse__ConditionAssignment_1
5350 @init { 8054 @init {
5351 int stackSize = keepStackSize(); 8055 int stackSize = keepStackSize();
5352 } 8056 }
5353: 8057:
5354 ( 8058 (
5355 { before(grammarAccess.getPatternBodyAccess().getConstraintsConstraintParserRuleCall_1_1_0()); } 8059 { before(grammarAccess.getIfElseAccess().getConditionExpressionParserRuleCall_1_0()); }
5356 ruleConstraint 8060 ruleExpression
5357 { after(grammarAccess.getPatternBodyAccess().getConstraintsConstraintParserRuleCall_1_1_0()); } 8061 { after(grammarAccess.getIfElseAccess().getConditionExpressionParserRuleCall_1_0()); }
5358 ) 8062 )
5359; 8063;
5360finally { 8064finally {
5361 restoreStackSize(stackSize); 8065 restoreStackSize(stackSize);
5362} 8066}
5363 8067
5364rule__Constraint__PolarityAssignment_0_0 8068rule__IfElse__ThenAssignment_3
5365 @init { 8069 @init {
5366 int stackSize = keepStackSize(); 8070 int stackSize = keepStackSize();
5367 } 8071 }
5368: 8072:
5369 ( 8073 (
5370 { before(grammarAccess.getConstraintAccess().getPolarityPolarityParserRuleCall_0_0_0()); } 8074 { before(grammarAccess.getIfElseAccess().getThenExpressionParserRuleCall_3_0()); }
5371 rulePolarity 8075 ruleExpression
5372 { after(grammarAccess.getConstraintAccess().getPolarityPolarityParserRuleCall_0_0_0()); } 8076 { after(grammarAccess.getIfElseAccess().getThenExpressionParserRuleCall_3_0()); }
5373 ) 8077 )
5374; 8078;
5375finally { 8079finally {
5376 restoreStackSize(stackSize); 8080 restoreStackSize(stackSize);
5377} 8081}
5378 8082
5379rule__Constraint__SymbolAssignment_0_1 8083rule__IfElse__ElseAssignment_5
5380 @init { 8084 @init {
5381 int stackSize = keepStackSize(); 8085 int stackSize = keepStackSize();
5382 } 8086 }
5383: 8087:
5384 ( 8088 (
5385 { before(grammarAccess.getConstraintAccess().getSymbolModelSymbolParserRuleCall_0_1_0()); } 8089 { before(grammarAccess.getIfElseAccess().getElseExpressionParserRuleCall_5_0()); }
5386 ruleModelSymbol 8090 ruleExpression
5387 { after(grammarAccess.getConstraintAccess().getSymbolModelSymbolParserRuleCall_0_1_0()); } 8091 { after(grammarAccess.getIfElseAccess().getElseExpressionParserRuleCall_5_0()); }
5388 ) 8092 )
5389; 8093;
5390finally { 8094finally {
5391 restoreStackSize(stackSize); 8095 restoreStackSize(stackSize);
5392} 8096}
5393 8097
5394rule__Constraint__ParamsAssignment_0_2_1 8098rule__DisjunctiveExpression__ChildrenAssignment_1_0_1_1
5395 @init { 8099 @init {
5396 int stackSize = keepStackSize(); 8100 int stackSize = keepStackSize();
5397 } 8101 }
5398: 8102:
5399 ( 8103 (
5400 { before(grammarAccess.getConstraintAccess().getParamsLiteralParserRuleCall_0_2_1_0()); } 8104 { before(grammarAccess.getDisjunctiveExpressionAccess().getChildrenConjunctiveExpressionParserRuleCall_1_0_1_1_0()); }
5401 ruleLiteral 8105 ruleConjunctiveExpression
5402 { after(grammarAccess.getConstraintAccess().getParamsLiteralParserRuleCall_0_2_1_0()); } 8106 { after(grammarAccess.getDisjunctiveExpressionAccess().getChildrenConjunctiveExpressionParserRuleCall_1_0_1_1_0()); }
5403 ) 8107 )
5404; 8108;
5405finally { 8109finally {
5406 restoreStackSize(stackSize); 8110 restoreStackSize(stackSize);
5407} 8111}
5408 8112
5409rule__Constraint__ParamsAssignment_0_2_2_1 8113rule__DisjunctiveExpression__BodyAssignment_1_1_2
5410 @init { 8114 @init {
5411 int stackSize = keepStackSize(); 8115 int stackSize = keepStackSize();
5412 } 8116 }
5413: 8117:
5414 ( 8118 (
5415 { before(grammarAccess.getConstraintAccess().getParamsLiteralParserRuleCall_0_2_2_1_0()); } 8119 { before(grammarAccess.getDisjunctiveExpressionAccess().getBodyConjunctiveExpressionParserRuleCall_1_1_2_0()); }
5416 ruleLiteral 8120 ruleConjunctiveExpression
5417 { after(grammarAccess.getConstraintAccess().getParamsLiteralParserRuleCall_0_2_2_1_0()); } 8121 { after(grammarAccess.getDisjunctiveExpressionAccess().getBodyConjunctiveExpressionParserRuleCall_1_1_2_0()); }
5418 ) 8122 )
5419; 8123;
5420finally { 8124finally {
5421 restoreStackSize(stackSize); 8125 restoreStackSize(stackSize);
5422} 8126}
5423 8127
5424rule__Constraint__ClosureTypeAssignment_1_0 8128rule__DisjunctiveExpression__CasesAssignment_1_1_4_1
5425 @init { 8129 @init {
5426 int stackSize = keepStackSize(); 8130 int stackSize = keepStackSize();
5427 } 8131 }
5428: 8132:
5429 ( 8133 (
5430 { before(grammarAccess.getConstraintAccess().getClosureTypeClosureTypeParserRuleCall_1_0_0()); } 8134 { before(grammarAccess.getDisjunctiveExpressionAccess().getCasesCaseParserRuleCall_1_1_4_1_0()); }
5431 ruleClosureType 8135 ruleCase
5432 { after(grammarAccess.getConstraintAccess().getClosureTypeClosureTypeParserRuleCall_1_0_0()); } 8136 { after(grammarAccess.getDisjunctiveExpressionAccess().getCasesCaseParserRuleCall_1_1_4_1_0()); }
5433 ) 8137 )
5434; 8138;
5435finally { 8139finally {
5436 restoreStackSize(stackSize); 8140 restoreStackSize(stackSize);
5437} 8141}
5438 8142
5439rule__Constraint__ParamsAssignment_1_2 8143rule__Case__ConditionAssignment_0
5440 @init { 8144 @init {
5441 int stackSize = keepStackSize(); 8145 int stackSize = keepStackSize();
5442 } 8146 }
5443: 8147:
5444 ( 8148 (
5445 { before(grammarAccess.getConstraintAccess().getParamsLiteralParserRuleCall_1_2_0()); } 8149 { before(grammarAccess.getCaseAccess().getConditionConjunctiveExpressionParserRuleCall_0_0()); }
5446 ruleLiteral 8150 ruleConjunctiveExpression
5447 { after(grammarAccess.getConstraintAccess().getParamsLiteralParserRuleCall_1_2_0()); } 8151 { after(grammarAccess.getCaseAccess().getConditionConjunctiveExpressionParserRuleCall_0_0()); }
5448 ) 8152 )
5449; 8153;
5450finally { 8154finally {
5451 restoreStackSize(stackSize); 8155 restoreStackSize(stackSize);
5452} 8156}
5453 8157
5454rule__Constraint__ParamsAssignment_1_3_1 8158rule__Case__BodyAssignment_2
5455 @init { 8159 @init {
5456 int stackSize = keepStackSize(); 8160 int stackSize = keepStackSize();
5457 } 8161 }
5458: 8162:
5459 ( 8163 (
5460 { before(grammarAccess.getConstraintAccess().getParamsLiteralParserRuleCall_1_3_1_0()); } 8164 { before(grammarAccess.getCaseAccess().getBodyConjunctiveExpressionParserRuleCall_2_0()); }
5461 ruleLiteral 8165 ruleConjunctiveExpression
5462 { after(grammarAccess.getConstraintAccess().getParamsLiteralParserRuleCall_1_3_1_0()); } 8166 { after(grammarAccess.getCaseAccess().getBodyConjunctiveExpressionParserRuleCall_2_0()); }
5463 ) 8167 )
5464; 8168;
5465finally { 8169finally {
5466 restoreStackSize(stackSize); 8170 restoreStackSize(stackSize);
5467} 8171}
5468 8172
5469rule__Variable__NameAssignment 8173rule__ConjunctiveExpression__ChildrenAssignment_1_1_1
5470 @init { 8174 @init {
5471 int stackSize = keepStackSize(); 8175 int stackSize = keepStackSize();
5472 } 8176 }
5473: 8177:
5474 ( 8178 (
5475 { before(grammarAccess.getVariableAccess().getNameIDTerminalRuleCall_0()); } 8179 { before(grammarAccess.getConjunctiveExpressionAccess().getChildrenComparisonExpressionParserRuleCall_1_1_1_0()); }
5476 RULE_ID 8180 ruleComparisonExpression
5477 { after(grammarAccess.getVariableAccess().getNameIDTerminalRuleCall_0()); } 8181 { after(grammarAccess.getConjunctiveExpressionAccess().getChildrenComparisonExpressionParserRuleCall_1_1_1_0()); }
8182 )
8183;
8184finally {
8185 restoreStackSize(stackSize);
8186}
8187
8188rule__ComparisonExpression__OpAssignment_1_1
8189 @init {
8190 int stackSize = keepStackSize();
8191 }
8192:
8193 (
8194 { before(grammarAccess.getComparisonExpressionAccess().getOpComparisonOperatorEnumRuleCall_1_1_0()); }
8195 ruleComparisonOperator
8196 { after(grammarAccess.getComparisonExpressionAccess().getOpComparisonOperatorEnumRuleCall_1_1_0()); }
5478 ) 8197 )
5479; 8198;
5480finally { 8199finally {
5481 restoreStackSize(stackSize); 8200 restoreStackSize(stackSize);
5482} 8201}
5483 8202
5484rule__AllInstances__SymbolAssignment_1 8203rule__ComparisonExpression__RightAssignment_1_2
5485 @init { 8204 @init {
5486 int stackSize = keepStackSize(); 8205 int stackSize = keepStackSize();
5487 } 8206 }
5488: 8207:
5489 ( 8208 (
5490 { before(grammarAccess.getAllInstancesAccess().getSymbolSymbolParserRuleCall_1_0()); } 8209 { before(grammarAccess.getComparisonExpressionAccess().getRightAdditiveExpressionParserRuleCall_1_2_0()); }
5491 ruleSymbol 8210 ruleAdditiveExpression
5492 { after(grammarAccess.getAllInstancesAccess().getSymbolSymbolParserRuleCall_1_0()); } 8211 { after(grammarAccess.getComparisonExpressionAccess().getRightAdditiveExpressionParserRuleCall_1_2_0()); }
5493 ) 8212 )
5494; 8213;
5495finally { 8214finally {
5496 restoreStackSize(stackSize); 8215 restoreStackSize(stackSize);
5497} 8216}
5498 8217
5499rule__DefaultInterpretation__InterpretationAssignment_1 8218rule__AdditiveExpression__OpAssignment_1_1
5500 @init { 8219 @init {
5501 int stackSize = keepStackSize(); 8220 int stackSize = keepStackSize();
5502 } 8221 }
5503: 8222:
5504 ( 8223 (
5505 { before(grammarAccess.getDefaultInterpretationAccess().getInterpretationBasicInterpretationParserRuleCall_1_0()); } 8224 { before(grammarAccess.getAdditiveExpressionAccess().getOpAdditiveBinaryOperatorEnumRuleCall_1_1_0()); }
5506 ruleBasicInterpretation 8225 ruleAdditiveBinaryOperator
5507 { after(grammarAccess.getDefaultInterpretationAccess().getInterpretationBasicInterpretationParserRuleCall_1_0()); } 8226 { after(grammarAccess.getAdditiveExpressionAccess().getOpAdditiveBinaryOperatorEnumRuleCall_1_1_0()); }
5508 ) 8227 )
5509; 8228;
5510finally { 8229finally {
5511 restoreStackSize(stackSize); 8230 restoreStackSize(stackSize);
5512} 8231}
5513 8232
5514rule__ClassInterpretation__AbstractAssignment_0 8233rule__AdditiveExpression__RightAssignment_1_2
5515 @init { 8234 @init {
5516 int stackSize = keepStackSize(); 8235 int stackSize = keepStackSize();
5517 } 8236 }
5518: 8237:
5519 ( 8238 (
5520 { before(grammarAccess.getClassInterpretationAccess().getAbstractAbstractKeyword_0_0()); } 8239 { before(grammarAccess.getAdditiveExpressionAccess().getRightMultiplicativeExpressionParserRuleCall_1_2_0()); }
8240 ruleMultiplicativeExpression
8241 { after(grammarAccess.getAdditiveExpressionAccess().getRightMultiplicativeExpressionParserRuleCall_1_2_0()); }
8242 )
8243;
8244finally {
8245 restoreStackSize(stackSize);
8246}
8247
8248rule__MultiplicativeExpression__OpAssignment_1_1
8249 @init {
8250 int stackSize = keepStackSize();
8251 }
8252:
8253 (
8254 { before(grammarAccess.getMultiplicativeExpressionAccess().getOpMultiplicativeBinaryOperatorEnumRuleCall_1_1_0()); }
8255 ruleMultiplicativeBinaryOperator
8256 { after(grammarAccess.getMultiplicativeExpressionAccess().getOpMultiplicativeBinaryOperatorEnumRuleCall_1_1_0()); }
8257 )
8258;
8259finally {
8260 restoreStackSize(stackSize);
8261}
8262
8263rule__MultiplicativeExpression__RightAssignment_1_2
8264 @init {
8265 int stackSize = keepStackSize();
8266 }
8267:
8268 (
8269 { before(grammarAccess.getMultiplicativeExpressionAccess().getRightExponentialExpressionParserRuleCall_1_2_0()); }
8270 ruleExponentialExpression
8271 { after(grammarAccess.getMultiplicativeExpressionAccess().getRightExponentialExpressionParserRuleCall_1_2_0()); }
8272 )
8273;
8274finally {
8275 restoreStackSize(stackSize);
8276}
8277
8278rule__ExponentialExpression__OpAssignment_1_1
8279 @init {
8280 int stackSize = keepStackSize();
8281 }
8282:
8283 (
8284 { before(grammarAccess.getExponentialExpressionAccess().getOpExponentialOpEnumRuleCall_1_1_0()); }
8285 ruleExponentialOp
8286 { after(grammarAccess.getExponentialExpressionAccess().getOpExponentialOpEnumRuleCall_1_1_0()); }
8287 )
8288;
8289finally {
8290 restoreStackSize(stackSize);
8291}
8292
8293rule__ExponentialExpression__RightAssignment_1_2
8294 @init {
8295 int stackSize = keepStackSize();
8296 }
8297:
8298 (
8299 { before(grammarAccess.getExponentialExpressionAccess().getRightExponentialExpressionParserRuleCall_1_2_0()); }
8300 ruleExponentialExpression
8301 { after(grammarAccess.getExponentialExpressionAccess().getRightExponentialExpressionParserRuleCall_1_2_0()); }
8302 )
8303;
8304finally {
8305 restoreStackSize(stackSize);
8306}
8307
8308rule__UnaryExpression__OpAssignment_1_1
8309 @init {
8310 int stackSize = keepStackSize();
8311 }
8312:
8313 (
8314 { before(grammarAccess.getUnaryExpressionAccess().getOpUnaryOpEnumRuleCall_1_1_0()); }
8315 ruleUnaryOp
8316 { after(grammarAccess.getUnaryExpressionAccess().getOpUnaryOpEnumRuleCall_1_1_0()); }
8317 )
8318;
8319finally {
8320 restoreStackSize(stackSize);
8321}
8322
8323rule__UnaryExpression__BodyAssignment_1_2
8324 @init {
8325 int stackSize = keepStackSize();
8326 }
8327:
8328 (
8329 { before(grammarAccess.getUnaryExpressionAccess().getBodyAggregationExpressionParserRuleCall_1_2_0()); }
8330 ruleAggregationExpression
8331 { after(grammarAccess.getUnaryExpressionAccess().getBodyAggregationExpressionParserRuleCall_1_2_0()); }
8332 )
8333;
8334finally {
8335 restoreStackSize(stackSize);
8336}
8337
8338rule__Count__BodyAssignment_2
8339 @init {
8340 int stackSize = keepStackSize();
8341 }
8342:
8343 (
8344 { before(grammarAccess.getCountAccess().getBodyExpressionParserRuleCall_2_0()); }
8345 ruleExpression
8346 { after(grammarAccess.getCountAccess().getBodyExpressionParserRuleCall_2_0()); }
8347 )
8348;
8349finally {
8350 restoreStackSize(stackSize);
8351}
8352
8353rule__Aggregation__OpAssignment_0
8354 @init {
8355 int stackSize = keepStackSize();
8356 }
8357:
8358 (
8359 { before(grammarAccess.getAggregationAccess().getOpAggregationOpEnumRuleCall_0_0()); }
8360 ruleAggregationOp
8361 { after(grammarAccess.getAggregationAccess().getOpAggregationOpEnumRuleCall_0_0()); }
8362 )
8363;
8364finally {
8365 restoreStackSize(stackSize);
8366}
8367
8368rule__Aggregation__BodyAssignment_2
8369 @init {
8370 int stackSize = keepStackSize();
8371 }
8372:
8373 (
8374 { before(grammarAccess.getAggregationAccess().getBodyExpressionParserRuleCall_2_0()); }
8375 ruleExpression
8376 { after(grammarAccess.getAggregationAccess().getBodyExpressionParserRuleCall_2_0()); }
8377 )
8378;
8379finally {
8380 restoreStackSize(stackSize);
8381}
8382
8383rule__Aggregation__ConditionAssignment_4
8384 @init {
8385 int stackSize = keepStackSize();
8386 }
8387:
8388 (
8389 { before(grammarAccess.getAggregationAccess().getConditionExpressionParserRuleCall_4_0()); }
8390 ruleExpression
8391 { after(grammarAccess.getAggregationAccess().getConditionExpressionParserRuleCall_4_0()); }
8392 )
8393;
8394finally {
8395 restoreStackSize(stackSize);
8396}
8397
8398rule__AtomicExpression__ArgumentListAssignment_0_1_1
8399 @init {
8400 int stackSize = keepStackSize();
8401 }
8402:
8403 (
8404 { before(grammarAccess.getAtomicExpressionAccess().getArgumentListArgumentListParserRuleCall_0_1_1_0()); }
8405 ruleArgumentList
8406 { after(grammarAccess.getAtomicExpressionAccess().getArgumentListArgumentListParserRuleCall_0_1_1_0()); }
8407 )
8408;
8409finally {
8410 restoreStackSize(stackSize);
8411}
8412
8413rule__Call__FunctorAssignment_0
8414 @init {
8415 int stackSize = keepStackSize();
8416 }
8417:
8418 (
8419 { before(grammarAccess.getCallAccess().getFunctorReferenceParserRuleCall_0_0()); }
8420 ruleReference
8421 { after(grammarAccess.getCallAccess().getFunctorReferenceParserRuleCall_0_0()); }
8422 )
8423;
8424finally {
8425 restoreStackSize(stackSize);
8426}
8427
8428rule__Call__TransitiveClosureAssignment_1_0
8429 @init {
8430 int stackSize = keepStackSize();
8431 }
8432:
8433 (
8434 { before(grammarAccess.getCallAccess().getTransitiveClosureSTARTerminalRuleCall_1_0_0()); }
8435 RULE_STAR
8436 { after(grammarAccess.getCallAccess().getTransitiveClosureSTARTerminalRuleCall_1_0_0()); }
8437 )
8438;
8439finally {
8440 restoreStackSize(stackSize);
8441}
8442
8443rule__Call__ReflexiveTransitiveClosureAssignment_1_1
8444 @init {
8445 int stackSize = keepStackSize();
8446 }
8447:
8448 (
8449 { before(grammarAccess.getCallAccess().getReflexiveTransitiveClosurePLUSTerminalRuleCall_1_1_0()); }
8450 RULE_PLUS
8451 { after(grammarAccess.getCallAccess().getReflexiveTransitiveClosurePLUSTerminalRuleCall_1_1_0()); }
8452 )
8453;
8454finally {
8455 restoreStackSize(stackSize);
8456}
8457
8458rule__Call__ArgumentListAssignment_2
8459 @init {
8460 int stackSize = keepStackSize();
8461 }
8462:
8463 (
8464 { before(grammarAccess.getCallAccess().getArgumentListArgumentListParserRuleCall_2_0()); }
8465 ruleArgumentList
8466 { after(grammarAccess.getCallAccess().getArgumentListArgumentListParserRuleCall_2_0()); }
8467 )
8468;
8469finally {
8470 restoreStackSize(stackSize);
8471}
8472
8473rule__ArgumentList__ArgumentsAssignment_2_0
8474 @init {
8475 int stackSize = keepStackSize();
8476 }
8477:
8478 (
8479 { before(grammarAccess.getArgumentListAccess().getArgumentsArgumentParserRuleCall_2_0_0()); }
8480 ruleArgument
8481 { after(grammarAccess.getArgumentListAccess().getArgumentsArgumentParserRuleCall_2_0_0()); }
8482 )
8483;
8484finally {
8485 restoreStackSize(stackSize);
8486}
8487
8488rule__ArgumentList__ArgumentsAssignment_2_1_1
8489 @init {
8490 int stackSize = keepStackSize();
8491 }
8492:
8493 (
8494 { before(grammarAccess.getArgumentListAccess().getArgumentsArgumentParserRuleCall_2_1_1_0()); }
8495 ruleArgument
8496 { after(grammarAccess.getArgumentListAccess().getArgumentsArgumentParserRuleCall_2_1_1_0()); }
8497 )
8498;
8499finally {
8500 restoreStackSize(stackSize);
8501}
8502
8503rule__ExpressionArgument__BodyAssignment
8504 @init {
8505 int stackSize = keepStackSize();
8506 }
8507:
8508 (
8509 { before(grammarAccess.getExpressionArgumentAccess().getBodyComparisonExpressionParserRuleCall_0()); }
8510 ruleComparisonExpression
8511 { after(grammarAccess.getExpressionArgumentAccess().getBodyComparisonExpressionParserRuleCall_0()); }
8512 )
8513;
8514finally {
8515 restoreStackSize(stackSize);
8516}
8517
8518rule__TypedArgument__TypeAssignment_0
8519 @init {
8520 int stackSize = keepStackSize();
8521 }
8522:
8523 (
8524 { before(grammarAccess.getTypedArgumentAccess().getTypeNamedElementCrossReference_0_0()); }
8525 (
8526 { before(grammarAccess.getTypedArgumentAccess().getTypeNamedElementQualifiedNameParserRuleCall_0_0_1()); }
8527 ruleQualifiedName
8528 { after(grammarAccess.getTypedArgumentAccess().getTypeNamedElementQualifiedNameParserRuleCall_0_0_1()); }
8529 )
8530 { after(grammarAccess.getTypedArgumentAccess().getTypeNamedElementCrossReference_0_0()); }
8531 )
8532;
8533finally {
8534 restoreStackSize(stackSize);
8535}
8536
8537rule__TypedArgument__VariableAssignment_1
8538 @init {
8539 int stackSize = keepStackSize();
8540 }
8541:
8542 (
8543 { before(grammarAccess.getTypedArgumentAccess().getVariableNamedElementCrossReference_1_0()); }
8544 (
8545 { before(grammarAccess.getTypedArgumentAccess().getVariableNamedElementQualifiedNameParserRuleCall_1_0_1()); }
8546 ruleQualifiedName
8547 { after(grammarAccess.getTypedArgumentAccess().getVariableNamedElementQualifiedNameParserRuleCall_1_0_1()); }
8548 )
8549 { after(grammarAccess.getTypedArgumentAccess().getVariableNamedElementCrossReference_1_0()); }
8550 )
8551;
8552finally {
8553 restoreStackSize(stackSize);
8554}
8555
8556rule__TypedStarArgument__TypeAssignment_0
8557 @init {
8558 int stackSize = keepStackSize();
8559 }
8560:
8561 (
8562 { before(grammarAccess.getTypedStarArgumentAccess().getTypeNamedElementCrossReference_0_0()); }
8563 (
8564 { before(grammarAccess.getTypedStarArgumentAccess().getTypeNamedElementQualifiedNameParserRuleCall_0_0_1()); }
8565 ruleQualifiedName
8566 { after(grammarAccess.getTypedStarArgumentAccess().getTypeNamedElementQualifiedNameParserRuleCall_0_0_1()); }
8567 )
8568 { after(grammarAccess.getTypedStarArgumentAccess().getTypeNamedElementCrossReference_0_0()); }
8569 )
8570;
8571finally {
8572 restoreStackSize(stackSize);
8573}
8574
8575rule__Reference__ReferredAssignment
8576 @init {
8577 int stackSize = keepStackSize();
8578 }
8579:
8580 (
8581 { before(grammarAccess.getReferenceAccess().getReferredNamedElementCrossReference_0()); }
5521 ( 8582 (
5522 { before(grammarAccess.getClassInterpretationAccess().getAbstractAbstractKeyword_0_0()); } 8583 { before(grammarAccess.getReferenceAccess().getReferredNamedElementQualifiedNameParserRuleCall_0_1()); }
8584 ruleQualifiedName
8585 { after(grammarAccess.getReferenceAccess().getReferredNamedElementQualifiedNameParserRuleCall_0_1()); }
8586 )
8587 { after(grammarAccess.getReferenceAccess().getReferredNamedElementCrossReference_0()); }
8588 )
8589;
8590finally {
8591 restoreStackSize(stackSize);
8592}
8593
8594rule__Interval__LowerBoundAssignment_1
8595 @init {
8596 int stackSize = keepStackSize();
8597 }
8598:
8599 (
8600 { before(grammarAccess.getIntervalAccess().getLowerBoundExpressionParserRuleCall_1_0()); }
8601 ruleExpression
8602 { after(grammarAccess.getIntervalAccess().getLowerBoundExpressionParserRuleCall_1_0()); }
8603 )
8604;
8605finally {
8606 restoreStackSize(stackSize);
8607}
8608
8609rule__Interval__UpperBoundAssignment_3
8610 @init {
8611 int stackSize = keepStackSize();
8612 }
8613:
8614 (
8615 { before(grammarAccess.getIntervalAccess().getUpperBoundExpressionParserRuleCall_3_0()); }
8616 ruleExpression
8617 { after(grammarAccess.getIntervalAccess().getUpperBoundExpressionParserRuleCall_3_0()); }
8618 )
8619;
8620finally {
8621 restoreStackSize(stackSize);
8622}
8623
8624rule__LogicLiteral__ValueAssignment
8625 @init {
8626 int stackSize = keepStackSize();
8627 }
8628:
8629 (
8630 { before(grammarAccess.getLogicLiteralAccess().getValueLogicValueEnumRuleCall_0()); }
8631 ruleLogicValue
8632 { after(grammarAccess.getLogicLiteralAccess().getValueLogicValueEnumRuleCall_0()); }
8633 )
8634;
8635finally {
8636 restoreStackSize(stackSize);
8637}
8638
8639rule__NumericLiteral__ValueAssignment
8640 @init {
8641 int stackSize = keepStackSize();
8642 }
8643:
8644 (
8645 { before(grammarAccess.getNumericLiteralAccess().getValueRealParserRuleCall_0()); }
8646 ruleReal
8647 { after(grammarAccess.getNumericLiteralAccess().getValueRealParserRuleCall_0()); }
8648 )
8649;
8650finally {
8651 restoreStackSize(stackSize);
8652}
8653
8654rule__StringLiteral__ValueAssignment
8655 @init {
8656 int stackSize = keepStackSize();
8657 }
8658:
8659 (
8660 { before(grammarAccess.getStringLiteralAccess().getValueSTRINGTerminalRuleCall_0()); }
8661 RULE_STRING
8662 { after(grammarAccess.getStringLiteralAccess().getValueSTRINGTerminalRuleCall_0()); }
8663 )
8664;
8665finally {
8666 restoreStackSize(stackSize);
8667}
8668
8669rule__ClassDefinition__AbstractAssignment_0
8670 @init {
8671 int stackSize = keepStackSize();
8672 }
8673:
8674 (
8675 { before(grammarAccess.getClassDefinitionAccess().getAbstractAbstractKeyword_0_0()); }
8676 (
8677 { before(grammarAccess.getClassDefinitionAccess().getAbstractAbstractKeyword_0_0()); }
5523 'abstract' 8678 'abstract'
5524 { after(grammarAccess.getClassInterpretationAccess().getAbstractAbstractKeyword_0_0()); } 8679 { after(grammarAccess.getClassDefinitionAccess().getAbstractAbstractKeyword_0_0()); }
8680 )
8681 { after(grammarAccess.getClassDefinitionAccess().getAbstractAbstractKeyword_0_0()); }
8682 )
8683;
8684finally {
8685 restoreStackSize(stackSize);
8686}
8687
8688rule__ClassDefinition__NameAssignment_2
8689 @init {
8690 int stackSize = keepStackSize();
8691 }
8692:
8693 (
8694 { before(grammarAccess.getClassDefinitionAccess().getNameIDTerminalRuleCall_2_0()); }
8695 RULE_ID
8696 { after(grammarAccess.getClassDefinitionAccess().getNameIDTerminalRuleCall_2_0()); }
8697 )
8698;
8699finally {
8700 restoreStackSize(stackSize);
8701}
8702
8703rule__ClassDefinition__SuperclassesAssignment_3_1
8704 @init {
8705 int stackSize = keepStackSize();
8706 }
8707:
8708 (
8709 { before(grammarAccess.getClassDefinitionAccess().getSuperclassesNamedElementCrossReference_3_1_0()); }
8710 (
8711 { before(grammarAccess.getClassDefinitionAccess().getSuperclassesNamedElementQualifiedNameParserRuleCall_3_1_0_1()); }
8712 ruleQualifiedName
8713 { after(grammarAccess.getClassDefinitionAccess().getSuperclassesNamedElementQualifiedNameParserRuleCall_3_1_0_1()); }
8714 )
8715 { after(grammarAccess.getClassDefinitionAccess().getSuperclassesNamedElementCrossReference_3_1_0()); }
8716 )
8717;
8718finally {
8719 restoreStackSize(stackSize);
8720}
8721
8722rule__ClassDefinition__SuperclassesAssignment_3_2_1
8723 @init {
8724 int stackSize = keepStackSize();
8725 }
8726:
8727 (
8728 { before(grammarAccess.getClassDefinitionAccess().getSuperclassesNamedElementCrossReference_3_2_1_0()); }
8729 (
8730 { before(grammarAccess.getClassDefinitionAccess().getSuperclassesNamedElementQualifiedNameParserRuleCall_3_2_1_0_1()); }
8731 ruleQualifiedName
8732 { after(grammarAccess.getClassDefinitionAccess().getSuperclassesNamedElementQualifiedNameParserRuleCall_3_2_1_0_1()); }
5525 ) 8733 )
5526 { after(grammarAccess.getClassInterpretationAccess().getAbstractAbstractKeyword_0_0()); } 8734 { after(grammarAccess.getClassDefinitionAccess().getSuperclassesNamedElementCrossReference_3_2_1_0()); }
5527 ) 8735 )
5528; 8736;
5529finally { 8737finally {
5530 restoreStackSize(stackSize); 8738 restoreStackSize(stackSize);
5531} 8739}
5532 8740
5533rule__ClassInterpretation__SymbolAssignment_2 8741rule__ClassDefinition__MembersAssignment_5
5534 @init { 8742 @init {
5535 int stackSize = keepStackSize(); 8743 int stackSize = keepStackSize();
5536 } 8744 }
5537: 8745:
5538 ( 8746 (
5539 { before(grammarAccess.getClassInterpretationAccess().getSymbolModelSymbolParserRuleCall_2_0()); } 8747 { before(grammarAccess.getClassDefinitionAccess().getMembersMemberDefinitionParserRuleCall_5_0()); }
5540 ruleModelSymbol 8748 ruleMemberDefinition
5541 { after(grammarAccess.getClassInterpretationAccess().getSymbolModelSymbolParserRuleCall_2_0()); } 8749 { after(grammarAccess.getClassDefinitionAccess().getMembersMemberDefinitionParserRuleCall_5_0()); }
5542 ) 8750 )
5543; 8751;
5544finally { 8752finally {
5545 restoreStackSize(stackSize); 8753 restoreStackSize(stackSize);
5546} 8754}
5547 8755
5548rule__ClassInterpretation__SupertypesAssignment_3_1 8756rule__MemberDefinition__ContainmentAssignment_0
5549 @init { 8757 @init {
5550 int stackSize = keepStackSize(); 8758 int stackSize = keepStackSize();
5551 } 8759 }
5552: 8760:
5553 ( 8761 (
5554 { before(grammarAccess.getClassInterpretationAccess().getSupertypesModelSymbolParserRuleCall_3_1_0()); } 8762 { before(grammarAccess.getMemberDefinitionAccess().getContainmentContainsKeyword_0_0()); }
5555 ruleModelSymbol 8763 (
5556 { after(grammarAccess.getClassInterpretationAccess().getSupertypesModelSymbolParserRuleCall_3_1_0()); } 8764 { before(grammarAccess.getMemberDefinitionAccess().getContainmentContainsKeyword_0_0()); }
8765 'contains'
8766 { after(grammarAccess.getMemberDefinitionAccess().getContainmentContainsKeyword_0_0()); }
8767 )
8768 { after(grammarAccess.getMemberDefinitionAccess().getContainmentContainsKeyword_0_0()); }
5557 ) 8769 )
5558; 8770;
5559finally { 8771finally {
5560 restoreStackSize(stackSize); 8772 restoreStackSize(stackSize);
5561} 8773}
5562 8774
5563rule__ClassInterpretation__FieltAssignment_5 8775rule__MemberDefinition__TypeAssignment_1
5564 @init { 8776 @init {
5565 int stackSize = keepStackSize(); 8777 int stackSize = keepStackSize();
5566 } 8778 }
5567: 8779:
5568 ( 8780 (
5569 { before(grammarAccess.getClassInterpretationAccess().getFieltFieldRelationInterpretationParserRuleCall_5_0()); } 8781 { before(grammarAccess.getMemberDefinitionAccess().getTypeNamedElementCrossReference_1_0()); }
5570 ruleFieldRelationInterpretation 8782 (
5571 { after(grammarAccess.getClassInterpretationAccess().getFieltFieldRelationInterpretationParserRuleCall_5_0()); } 8783 { before(grammarAccess.getMemberDefinitionAccess().getTypeNamedElementQualifiedNameParserRuleCall_1_0_1()); }
8784 ruleQualifiedName
8785 { after(grammarAccess.getMemberDefinitionAccess().getTypeNamedElementQualifiedNameParserRuleCall_1_0_1()); }
8786 )
8787 { after(grammarAccess.getMemberDefinitionAccess().getTypeNamedElementCrossReference_1_0()); }
5572 ) 8788 )
5573; 8789;
5574finally { 8790finally {
5575 restoreStackSize(stackSize); 8791 restoreStackSize(stackSize);
5576} 8792}
5577 8793
5578rule__EnumInterpretation__SymbolAssignment_1 8794rule__MemberDefinition__MultiplicityAssignment_2
5579 @init { 8795 @init {
5580 int stackSize = keepStackSize(); 8796 int stackSize = keepStackSize();
5581 } 8797 }
5582: 8798:
5583 ( 8799 (
5584 { before(grammarAccess.getEnumInterpretationAccess().getSymbolModelSymbolParserRuleCall_1_0()); } 8800 { before(grammarAccess.getMemberDefinitionAccess().getMultiplicityMultiplicityParserRuleCall_2_0()); }
5585 ruleModelSymbol 8801 ruleMultiplicity
5586 { after(grammarAccess.getEnumInterpretationAccess().getSymbolModelSymbolParserRuleCall_1_0()); } 8802 { after(grammarAccess.getMemberDefinitionAccess().getMultiplicityMultiplicityParserRuleCall_2_0()); }
5587 ) 8803 )
5588; 8804;
5589finally { 8805finally {
5590 restoreStackSize(stackSize); 8806 restoreStackSize(stackSize);
5591} 8807}
5592 8808
5593rule__EnumInterpretation__ObjectsAssignment_3 8809rule__MemberDefinition__NameAssignment_3
5594 @init { 8810 @init {
5595 int stackSize = keepStackSize(); 8811 int stackSize = keepStackSize();
5596 } 8812 }
5597: 8813:
5598 ( 8814 (
5599 { before(grammarAccess.getEnumInterpretationAccess().getObjectsNamedObjectParserRuleCall_3_0()); } 8815 { before(grammarAccess.getMemberDefinitionAccess().getNameIDTerminalRuleCall_3_0()); }
5600 ruleNamedObject 8816 RULE_ID
5601 { after(grammarAccess.getEnumInterpretationAccess().getObjectsNamedObjectParserRuleCall_3_0()); } 8817 { after(grammarAccess.getMemberDefinitionAccess().getNameIDTerminalRuleCall_3_0()); }
5602 ) 8818 )
5603; 8819;
5604finally { 8820finally {
5605 restoreStackSize(stackSize); 8821 restoreStackSize(stackSize);
5606} 8822}
5607 8823
5608rule__FieldRelationInterpretation__ContainmentAssignment_0 8824rule__MemberDefinition__OppositeAssignment_4_1
5609 @init { 8825 @init {
5610 int stackSize = keepStackSize(); 8826 int stackSize = keepStackSize();
5611 } 8827 }
5612: 8828:
5613 ( 8829 (
5614 { before(grammarAccess.getFieldRelationInterpretationAccess().getContainmentContainmentKeyword_0_0()); } 8830 { before(grammarAccess.getMemberDefinitionAccess().getOppositeNamedElementCrossReference_4_1_0()); }
5615 ( 8831 (
5616 { before(grammarAccess.getFieldRelationInterpretationAccess().getContainmentContainmentKeyword_0_0()); } 8832 { before(grammarAccess.getMemberDefinitionAccess().getOppositeNamedElementQualifiedNameParserRuleCall_4_1_0_1()); }
5617 'containment' 8833 ruleQualifiedName
5618 { after(grammarAccess.getFieldRelationInterpretationAccess().getContainmentContainmentKeyword_0_0()); } 8834 { after(grammarAccess.getMemberDefinitionAccess().getOppositeNamedElementQualifiedNameParserRuleCall_4_1_0_1()); }
5619 ) 8835 )
5620 { after(grammarAccess.getFieldRelationInterpretationAccess().getContainmentContainmentKeyword_0_0()); } 8836 { after(grammarAccess.getMemberDefinitionAccess().getOppositeNamedElementCrossReference_4_1_0()); }
5621 ) 8837 )
5622; 8838;
5623finally { 8839finally {
5624 restoreStackSize(stackSize); 8840 restoreStackSize(stackSize);
5625} 8841}
5626 8842
5627rule__FieldRelationInterpretation__SymbolAssignment_1 8843rule__ExactMultiplicity__MultiplicityAssignment_1
5628 @init { 8844 @init {
5629 int stackSize = keepStackSize(); 8845 int stackSize = keepStackSize();
5630 } 8846 }
5631: 8847:
5632 ( 8848 (
5633 { before(grammarAccess.getFieldRelationInterpretationAccess().getSymbolModelSymbolParserRuleCall_1_0()); } 8849 { before(grammarAccess.getExactMultiplicityAccess().getMultiplicityUpperMultiplictyParserRuleCall_1_0()); }
5634 ruleModelSymbol 8850 ruleUpperMultiplicty
5635 { after(grammarAccess.getFieldRelationInterpretationAccess().getSymbolModelSymbolParserRuleCall_1_0()); } 8851 { after(grammarAccess.getExactMultiplicityAccess().getMultiplicityUpperMultiplictyParserRuleCall_1_0()); }
5636 ) 8852 )
5637; 8853;
5638finally { 8854finally {
5639 restoreStackSize(stackSize); 8855 restoreStackSize(stackSize);
5640} 8856}
5641 8857
5642rule__FieldRelationInterpretation__MultiplicityAssignment_3 8858rule__BoundedMultiplicity__LowerBoundAssignment_1
5643 @init { 8859 @init {
5644 int stackSize = keepStackSize(); 8860 int stackSize = keepStackSize();
5645 } 8861 }
5646: 8862:
5647 ( 8863 (
5648 { before(grammarAccess.getFieldRelationInterpretationAccess().getMultiplicityMultiplicityDefinitionParserRuleCall_3_0()); } 8864 { before(grammarAccess.getBoundedMultiplicityAccess().getLowerBoundINTTerminalRuleCall_1_0()); }
5649 ruleMultiplicityDefinition 8865 RULE_INT
5650 { after(grammarAccess.getFieldRelationInterpretationAccess().getMultiplicityMultiplicityDefinitionParserRuleCall_3_0()); } 8866 { after(grammarAccess.getBoundedMultiplicityAccess().getLowerBoundINTTerminalRuleCall_1_0()); }
5651 ) 8867 )
5652; 8868;
5653finally { 8869finally {
5654 restoreStackSize(stackSize); 8870 restoreStackSize(stackSize);
5655} 8871}
5656 8872
5657rule__FieldRelationInterpretation__TargetAssignment_4 8873rule__BoundedMultiplicity__UpperBoundAssignment_3
5658 @init { 8874 @init {
5659 int stackSize = keepStackSize(); 8875 int stackSize = keepStackSize();
5660 } 8876 }
5661: 8877:
5662 ( 8878 (
5663 { before(grammarAccess.getFieldRelationInterpretationAccess().getTargetSymbolParserRuleCall_4_0()); } 8879 { before(grammarAccess.getBoundedMultiplicityAccess().getUpperBoundUpperMultiplictyParserRuleCall_3_0()); }
5664 ruleSymbol 8880 ruleUpperMultiplicty
5665 { after(grammarAccess.getFieldRelationInterpretationAccess().getTargetSymbolParserRuleCall_4_0()); } 8881 { after(grammarAccess.getBoundedMultiplicityAccess().getUpperBoundUpperMultiplictyParserRuleCall_3_0()); }
5666 ) 8882 )
5667; 8883;
5668finally { 8884finally {
5669 restoreStackSize(stackSize); 8885 restoreStackSize(stackSize);
5670} 8886}
5671 8887
5672rule__GlobalRelationInterpretation__ContainmentAssignment_0 8888rule__ExactScopeDefinition__TypeAssignment_1
5673 @init { 8889 @init {
5674 int stackSize = keepStackSize(); 8890 int stackSize = keepStackSize();
5675 } 8891 }
5676: 8892:
5677 ( 8893 (
5678 { before(grammarAccess.getGlobalRelationInterpretationAccess().getContainmentContainmentKeyword_0_0()); } 8894 { before(grammarAccess.getExactScopeDefinitionAccess().getTypeNamedElementCrossReference_1_0()); }
5679 ( 8895 (
5680 { before(grammarAccess.getGlobalRelationInterpretationAccess().getContainmentContainmentKeyword_0_0()); } 8896 { before(grammarAccess.getExactScopeDefinitionAccess().getTypeNamedElementQualifiedNameParserRuleCall_1_0_1()); }
5681 'containment' 8897 ruleQualifiedName
5682 { after(grammarAccess.getGlobalRelationInterpretationAccess().getContainmentContainmentKeyword_0_0()); } 8898 { after(grammarAccess.getExactScopeDefinitionAccess().getTypeNamedElementQualifiedNameParserRuleCall_1_0_1()); }
5683 ) 8899 )
5684 { after(grammarAccess.getGlobalRelationInterpretationAccess().getContainmentContainmentKeyword_0_0()); } 8900 { after(grammarAccess.getExactScopeDefinitionAccess().getTypeNamedElementCrossReference_1_0()); }
5685 ) 8901 )
5686; 8902;
5687finally { 8903finally {
5688 restoreStackSize(stackSize); 8904 restoreStackSize(stackSize);
5689} 8905}
5690 8906
5691rule__GlobalRelationInterpretation__SymbolAssignment_2 8907rule__ExactScopeDefinition__ExactScopeAssignment_3
5692 @init { 8908 @init {
5693 int stackSize = keepStackSize(); 8909 int stackSize = keepStackSize();
5694 } 8910 }
5695: 8911:
5696 ( 8912 (
5697 { before(grammarAccess.getGlobalRelationInterpretationAccess().getSymbolModelSymbolParserRuleCall_2_0()); } 8913 { before(grammarAccess.getExactScopeDefinitionAccess().getExactScopeINTTerminalRuleCall_3_0()); }
5698 ruleModelSymbol 8914 RULE_INT
5699 { after(grammarAccess.getGlobalRelationInterpretationAccess().getSymbolModelSymbolParserRuleCall_2_0()); } 8915 { after(grammarAccess.getExactScopeDefinitionAccess().getExactScopeINTTerminalRuleCall_3_0()); }
5700 ) 8916 )
5701; 8917;
5702finally { 8918finally {
5703 restoreStackSize(stackSize); 8919 restoreStackSize(stackSize);
5704} 8920}
5705 8921
5706rule__GlobalRelationInterpretation__SourceMultiplicityAssignment_4 8922rule__BoundedScopeDefinition__LowerBoundAssignment_1_0_0_0
5707 @init { 8923 @init {
5708 int stackSize = keepStackSize(); 8924 int stackSize = keepStackSize();
5709 } 8925 }
5710: 8926:
5711 ( 8927 (
5712 { before(grammarAccess.getGlobalRelationInterpretationAccess().getSourceMultiplicityMultiplicityDefinitionParserRuleCall_4_0()); } 8928 { before(grammarAccess.getBoundedScopeDefinitionAccess().getLowerBoundINTTerminalRuleCall_1_0_0_0_0()); }
5713 ruleMultiplicityDefinition 8929 RULE_INT
5714 { after(grammarAccess.getGlobalRelationInterpretationAccess().getSourceMultiplicityMultiplicityDefinitionParserRuleCall_4_0()); } 8930 { after(grammarAccess.getBoundedScopeDefinitionAccess().getLowerBoundINTTerminalRuleCall_1_0_0_0_0()); }
5715 ) 8931 )
5716; 8932;
5717finally { 8933finally {
5718 restoreStackSize(stackSize); 8934 restoreStackSize(stackSize);
5719} 8935}
5720 8936
5721rule__GlobalRelationInterpretation__SourceAssignment_5 8937rule__BoundedScopeDefinition__TypeAssignment_1_0_1
5722 @init { 8938 @init {
5723 int stackSize = keepStackSize(); 8939 int stackSize = keepStackSize();
5724 } 8940 }
5725: 8941:
5726 ( 8942 (
5727 { before(grammarAccess.getGlobalRelationInterpretationAccess().getSourceSymbolParserRuleCall_5_0()); } 8943 { before(grammarAccess.getBoundedScopeDefinitionAccess().getTypeNamedElementCrossReference_1_0_1_0()); }
5728 ruleSymbol 8944 (
5729 { after(grammarAccess.getGlobalRelationInterpretationAccess().getSourceSymbolParserRuleCall_5_0()); } 8945 { before(grammarAccess.getBoundedScopeDefinitionAccess().getTypeNamedElementQualifiedNameParserRuleCall_1_0_1_0_1()); }
8946 ruleQualifiedName
8947 { after(grammarAccess.getBoundedScopeDefinitionAccess().getTypeNamedElementQualifiedNameParserRuleCall_1_0_1_0_1()); }
8948 )
8949 { after(grammarAccess.getBoundedScopeDefinitionAccess().getTypeNamedElementCrossReference_1_0_1_0()); }
5730 ) 8950 )
5731; 8951;
5732finally { 8952finally {
5733 restoreStackSize(stackSize); 8953 restoreStackSize(stackSize);
5734} 8954}
5735 8955
5736rule__GlobalRelationInterpretation__TargetMultiplicityAssignment_6 8956rule__BoundedScopeDefinition__UpperBoundAssignment_1_0_3
5737 @init { 8957 @init {
5738 int stackSize = keepStackSize(); 8958 int stackSize = keepStackSize();
5739 } 8959 }
5740: 8960:
5741 ( 8961 (
5742 { before(grammarAccess.getGlobalRelationInterpretationAccess().getTargetMultiplicityMultiplicityDefinitionParserRuleCall_6_0()); } 8962 { before(grammarAccess.getBoundedScopeDefinitionAccess().getUpperBoundINTTerminalRuleCall_1_0_3_0()); }
5743 ruleMultiplicityDefinition 8963 RULE_INT
5744 { after(grammarAccess.getGlobalRelationInterpretationAccess().getTargetMultiplicityMultiplicityDefinitionParserRuleCall_6_0()); } 8964 { after(grammarAccess.getBoundedScopeDefinitionAccess().getUpperBoundINTTerminalRuleCall_1_0_3_0()); }
5745 ) 8965 )
5746; 8966;
5747finally { 8967finally {
5748 restoreStackSize(stackSize); 8968 restoreStackSize(stackSize);
5749} 8969}
5750 8970
5751rule__GlobalRelationInterpretation__TargetAssignment_7 8971rule__BoundedScopeDefinition__UpperBoundAssignment_1_1_0
5752 @init { 8972 @init {
5753 int stackSize = keepStackSize(); 8973 int stackSize = keepStackSize();
5754 } 8974 }
5755: 8975:
5756 ( 8976 (
5757 { before(grammarAccess.getGlobalRelationInterpretationAccess().getTargetSymbolParserRuleCall_7_0()); } 8977 { before(grammarAccess.getBoundedScopeDefinitionAccess().getUpperBoundINTTerminalRuleCall_1_1_0_0()); }
5758 ruleSymbol 8978 RULE_INT
5759 { after(grammarAccess.getGlobalRelationInterpretationAccess().getTargetSymbolParserRuleCall_7_0()); } 8979 { after(grammarAccess.getBoundedScopeDefinitionAccess().getUpperBoundINTTerminalRuleCall_1_1_0_0()); }
5760 ) 8980 )
5761; 8981;
5762finally { 8982finally {
5763 restoreStackSize(stackSize); 8983 restoreStackSize(stackSize);
5764} 8984}
5765 8985
5766rule__MultiplicityDefinition__LowerAssignment_0 8986rule__BoundedScopeDefinition__TypeAssignment_1_1_2
5767 @init { 8987 @init {
5768 int stackSize = keepStackSize(); 8988 int stackSize = keepStackSize();
5769 } 8989 }
5770: 8990:
5771 ( 8991 (
5772 { before(grammarAccess.getMultiplicityDefinitionAccess().getLowerINTTerminalRuleCall_0_0()); } 8992 { before(grammarAccess.getBoundedScopeDefinitionAccess().getTypeNamedElementCrossReference_1_1_2_0()); }
8993 (
8994 { before(grammarAccess.getBoundedScopeDefinitionAccess().getTypeNamedElementQualifiedNameParserRuleCall_1_1_2_0_1()); }
8995 ruleQualifiedName
8996 { after(grammarAccess.getBoundedScopeDefinitionAccess().getTypeNamedElementQualifiedNameParserRuleCall_1_1_2_0_1()); }
8997 )
8998 { after(grammarAccess.getBoundedScopeDefinitionAccess().getTypeNamedElementCrossReference_1_1_2_0()); }
8999 )
9000;
9001finally {
9002 restoreStackSize(stackSize);
9003}
9004
9005rule__BoundedScopeDefinition__LowerBoundAssignment_1_1_3_1
9006 @init {
9007 int stackSize = keepStackSize();
9008 }
9009:
9010 (
9011 { before(grammarAccess.getBoundedScopeDefinitionAccess().getLowerBoundINTTerminalRuleCall_1_1_3_1_0()); }
5773 RULE_INT 9012 RULE_INT
5774 { after(grammarAccess.getMultiplicityDefinitionAccess().getLowerINTTerminalRuleCall_0_0()); } 9013 { after(grammarAccess.getBoundedScopeDefinitionAccess().getLowerBoundINTTerminalRuleCall_1_1_3_1_0()); }
5775 ) 9014 )
5776; 9015;
5777finally { 9016finally {
5778 restoreStackSize(stackSize); 9017 restoreStackSize(stackSize);
5779} 9018}
5780 9019
5781rule__MultiplicityDefinition__UpperAssignment_2_0 9020rule__LowerBoundedScopeDefinition__LowerBoundAssignment_1_0_0
5782 @init { 9021 @init {
5783 int stackSize = keepStackSize(); 9022 int stackSize = keepStackSize();
5784 } 9023 }
5785: 9024:
5786 ( 9025 (
5787 { before(grammarAccess.getMultiplicityDefinitionAccess().getUpperINTTerminalRuleCall_2_0_0()); } 9026 { before(grammarAccess.getLowerBoundedScopeDefinitionAccess().getLowerBoundINTTerminalRuleCall_1_0_0_0()); }
5788 RULE_INT 9027 RULE_INT
5789 { after(grammarAccess.getMultiplicityDefinitionAccess().getUpperINTTerminalRuleCall_2_0_0()); } 9028 { after(grammarAccess.getLowerBoundedScopeDefinitionAccess().getLowerBoundINTTerminalRuleCall_1_0_0_0()); }
9029 )
9030;
9031finally {
9032 restoreStackSize(stackSize);
9033}
9034
9035rule__LowerBoundedScopeDefinition__TypeAssignment_1_0_2
9036 @init {
9037 int stackSize = keepStackSize();
9038 }
9039:
9040 (
9041 { before(grammarAccess.getLowerBoundedScopeDefinitionAccess().getTypeNamedElementCrossReference_1_0_2_0()); }
9042 (
9043 { before(grammarAccess.getLowerBoundedScopeDefinitionAccess().getTypeNamedElementQualifiedNameParserRuleCall_1_0_2_0_1()); }
9044 ruleQualifiedName
9045 { after(grammarAccess.getLowerBoundedScopeDefinitionAccess().getTypeNamedElementQualifiedNameParserRuleCall_1_0_2_0_1()); }
9046 )
9047 { after(grammarAccess.getLowerBoundedScopeDefinitionAccess().getTypeNamedElementCrossReference_1_0_2_0()); }
5790 ) 9048 )
5791; 9049;
5792finally { 9050finally {
5793 restoreStackSize(stackSize); 9051 restoreStackSize(stackSize);
5794} 9052}
5795 9053
5796rule__MultiplicityDefinition__UnlimitedUpperAssignment_2_1 9054rule__LowerBoundedScopeDefinition__TypeAssignment_1_1_0
5797 @init { 9055 @init {
5798 int stackSize = keepStackSize(); 9056 int stackSize = keepStackSize();
5799 } 9057 }
5800: 9058:
5801 ( 9059 (
5802 { before(grammarAccess.getMultiplicityDefinitionAccess().getUnlimitedUpperAsteriskKeyword_2_1_0()); } 9060 { before(grammarAccess.getLowerBoundedScopeDefinitionAccess().getTypeNamedElementCrossReference_1_1_0_0()); }
5803 ( 9061 (
5804 { before(grammarAccess.getMultiplicityDefinitionAccess().getUnlimitedUpperAsteriskKeyword_2_1_0()); } 9062 { before(grammarAccess.getLowerBoundedScopeDefinitionAccess().getTypeNamedElementQualifiedNameParserRuleCall_1_1_0_0_1()); }
5805 '*' 9063 ruleQualifiedName
5806 { after(grammarAccess.getMultiplicityDefinitionAccess().getUnlimitedUpperAsteriskKeyword_2_1_0()); } 9064 { after(grammarAccess.getLowerBoundedScopeDefinitionAccess().getTypeNamedElementQualifiedNameParserRuleCall_1_1_0_0_1()); }
5807 ) 9065 )
5808 { after(grammarAccess.getMultiplicityDefinitionAccess().getUnlimitedUpperAsteriskKeyword_2_1_0()); } 9066 { after(grammarAccess.getLowerBoundedScopeDefinitionAccess().getTypeNamedElementCrossReference_1_1_0_0()); }
9067 )
9068;
9069finally {
9070 restoreStackSize(stackSize);
9071}
9072
9073rule__LowerBoundedScopeDefinition__LowerBoundAssignment_1_1_2
9074 @init {
9075 int stackSize = keepStackSize();
9076 }
9077:
9078 (
9079 { before(grammarAccess.getLowerBoundedScopeDefinitionAccess().getLowerBoundINTTerminalRuleCall_1_1_2_0()); }
9080 RULE_INT
9081 { after(grammarAccess.getLowerBoundedScopeDefinitionAccess().getLowerBoundINTTerminalRuleCall_1_1_2_0()); }
9082 )
9083;
9084finally {
9085 restoreStackSize(stackSize);
9086}
9087
9088rule__ObjectiveDefinition__KindAssignment_0
9089 @init {
9090 int stackSize = keepStackSize();
9091 }
9092:
9093 (
9094 { before(grammarAccess.getObjectiveDefinitionAccess().getKindObjectiveKindEnumRuleCall_0_0()); }
9095 ruleObjectiveKind
9096 { after(grammarAccess.getObjectiveDefinitionAccess().getKindObjectiveKindEnumRuleCall_0_0()); }
9097 )
9098;
9099finally {
9100 restoreStackSize(stackSize);
9101}
9102
9103rule__ObjectiveDefinition__ObjectiveAssignment_1
9104 @init {
9105 int stackSize = keepStackSize();
9106 }
9107:
9108 (
9109 { before(grammarAccess.getObjectiveDefinitionAccess().getObjectiveExpressionParserRuleCall_1_0()); }
9110 ruleExpression
9111 { after(grammarAccess.getObjectiveDefinitionAccess().getObjectiveExpressionParserRuleCall_1_0()); }
5809 ) 9112 )
5810; 9113;
5811finally { 9114finally {
@@ -5814,6 +9117,14 @@ finally {
5814 9117
5815RULE_STRING : '"' ('\\' .|~(('\\'|'"')))* '"'; 9118RULE_STRING : '"' ('\\' .|~(('\\'|'"')))* '"';
5816 9119
9120RULE_QUOTED_ID : '\'' ('\\' .|~(('\\'|'\'')))* '\'';
9121
9122RULE_PLUS : 'synthetic::plus';
9123
9124RULE_STAR : 'synthetic::star';
9125
9126RULE_DOT : 'synthetic::dot';
9127
5817RULE_ID : '^'? ('a'..'z'|'A'..'Z'|'_') ('a'..'z'|'A'..'Z'|'_'|'0'..'9')*; 9128RULE_ID : '^'? ('a'..'z'|'A'..'Z'|'_') ('a'..'z'|'A'..'Z'|'_'|'0'..'9')*;
5818 9129
5819RULE_INT : ('0'..'9')+; 9130RULE_INT : ('0'..'9')+;
generated by cgit v1.2.3-54-g00ecf (git 2.45.2) at 2024-07-08 13:28:29 +0000