aboutsummaryrefslogtreecommitdiffstats
path: root/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/parser/antlr/lexer/InternalSolverLanguageLexer.java
diff options
context:
space:
mode:
Diffstat (limited to 'Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/parser/antlr/lexer/InternalSolverLanguageLexer.java')
-rw-r--r--Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/parser/antlr/lexer/InternalSolverLanguageLexer.java3208
1 files changed, 3208 insertions, 0 deletions
diff --git a/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/parser/antlr/lexer/InternalSolverLanguageLexer.java b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/parser/antlr/lexer/InternalSolverLanguageLexer.java
new file mode 100644
index 00000000..b46f86fc
--- /dev/null
+++ b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/parser/antlr/lexer/InternalSolverLanguageLexer.java
@@ -0,0 +1,3208 @@
1package org.eclipse.viatra.solver.language.parser.antlr.lexer;
2
3// Hack: Use our own Lexer superclass by means of import.
4// Currently there is no other way to specify the superclass for the lexer.
5import org.eclipse.xtext.parser.antlr.Lexer;
6
7
8import org.antlr.runtime.*;
9import java.util.Stack;
10import java.util.List;
11import java.util.ArrayList;
12
13@SuppressWarnings("all")
14public class InternalSolverLanguageLexer extends Lexer {
15 public static final int ADD=33;
16 public static final int True=32;
17 public static final int GREATER_EQ=4;
18 public static final int Count=20;
19 public static final int False=23;
20 public static final int Must=27;
21 public static final int LessThanSign=67;
22 public static final int LeftParenthesis=57;
23 public static final int Unknown=16;
24 public static final int RULE_REFLEXIVE_TRANSITIVE_CLOSURE=80;
25 public static final int FullStopFullStop=47;
26 public static final int Real=30;
27 public static final int Then=31;
28 public static final int Extends=15;
29 public static final int RightSquareBracket=71;
30 public static final int ExclamationMark=56;
31 public static final int Opposite=10;
32 public static final int SUB=37;
33 public static final int GreaterThanSign=69;
34 public static final int NOT_EQ=17;
35 public static final int RULE_ID=82;
36 public static final int MUL=35;
37 public static final int IN=53;
38 public static final int RULE_QUOTED_ID=77;
39 public static final int RightParenthesis=58;
40 public static final int Sum=44;
41 public static final int EQ=52;
42 public static final int GreaterThanSignEqualsSign=51;
43 public static final int Functional=5;
44 public static final int EqualsSignEqualsSign=50;
45 public static final int Avg=38;
46 public static final int Min=43;
47 public static final int VerticalLine=74;
48 public static final int PlusSign=60;
49 public static final int RULE_INT=83;
50 public static final int Contains=7;
51 public static final int RULE_ML_COMMENT=84;
52 public static final int POW=36;
53 public static final int RULE_TRANSITIVE_CLOSURE=79;
54 public static final int Class=19;
55 public static final int LESS=25;
56 public static final int LeftSquareBracket=70;
57 public static final int RULE_FULL_STOP=81;
58 public static final int Current=13;
59 public static final int If=54;
60 public static final int Inf=39;
61 public static final int LESS_EQ=12;
62 public static final int May=42;
63 public static final int Max=41;
64 public static final int In=55;
65 public static final int RULE_STRING=76;
66 public static final int Int=40;
67 public static final int Extern=18;
68 public static final int RULE_SL_COMMENT=78;
69 public static final int Prod=29;
70 public static final int Comma=61;
71 public static final int EqualsSign=68;
72 public static final int Empty=21;
73 public static final int HyphenMinus=62;
74 public static final int Maximize=8;
75 public static final int LessThanSignEqualsSign=49;
76 public static final int Solidus=64;
77 public static final int Colon=65;
78 public static final int RightCurlyBracket=75;
79 public static final int EOF=-1;
80 public static final int Asterisk=59;
81 public static final int FullStop=63;
82 public static final int RULE_WS=85;
83 public static final int Abstract=6;
84 public static final int Minimize=9;
85 public static final int GREATER=11;
86 public static final int LeftCurlyBracket=73;
87 public static final int Error=22;
88 public static final int Only=28;
89 public static final int RULE_ANY_OTHER=86;
90 public static final int Default=14;
91 public static final int ColonHyphenMinus=48;
92 public static final int CircumflexAccent=72;
93 public static final int DIV=34;
94 public static final int Semicolon=66;
95 public static final int Scope=24;
96 public static final int Else=26;
97 public static final int ExclamationMarkEqualsSign=45;
98 public static final int HyphenMinusGreaterThanSign=46;
99
100 // delegates
101 // delegators
102
103 public InternalSolverLanguageLexer() {;}
104 public InternalSolverLanguageLexer(CharStream input) {
105 this(input, new RecognizerSharedState());
106 }
107 public InternalSolverLanguageLexer(CharStream input, RecognizerSharedState state) {
108 super(input,state);
109
110 }
111 public String getGrammarFileName() { return "InternalSolverLanguageLexer.g"; }
112
113 // $ANTLR start "GREATER_EQ"
114 public final void mGREATER_EQ() throws RecognitionException {
115 try {
116 int _type = GREATER_EQ;
117 int _channel = DEFAULT_TOKEN_CHANNEL;
118 // InternalSolverLanguageLexer.g:14:12: ( 'GREATER_EQ' )
119 // InternalSolverLanguageLexer.g:14:14: 'GREATER_EQ'
120 {
121 match("GREATER_EQ");
122
123
124 }
125
126 state.type = _type;
127 state.channel = _channel;
128 }
129 finally {
130 }
131 }
132 // $ANTLR end "GREATER_EQ"
133
134 // $ANTLR start "Functional"
135 public final void mFunctional() throws RecognitionException {
136 try {
137 int _type = Functional;
138 int _channel = DEFAULT_TOKEN_CHANNEL;
139 // InternalSolverLanguageLexer.g:16:12: ( 'functional' )
140 // InternalSolverLanguageLexer.g:16:14: 'functional'
141 {
142 match("functional");
143
144
145 }
146
147 state.type = _type;
148 state.channel = _channel;
149 }
150 finally {
151 }
152 }
153 // $ANTLR end "Functional"
154
155 // $ANTLR start "Abstract"
156 public final void mAbstract() throws RecognitionException {
157 try {
158 int _type = Abstract;
159 int _channel = DEFAULT_TOKEN_CHANNEL;
160 // InternalSolverLanguageLexer.g:18:10: ( 'abstract' )
161 // InternalSolverLanguageLexer.g:18:12: 'abstract'
162 {
163 match("abstract");
164
165
166 }
167
168 state.type = _type;
169 state.channel = _channel;
170 }
171 finally {
172 }
173 }
174 // $ANTLR end "Abstract"
175
176 // $ANTLR start "Contains"
177 public final void mContains() throws RecognitionException {
178 try {
179 int _type = Contains;
180 int _channel = DEFAULT_TOKEN_CHANNEL;
181 // InternalSolverLanguageLexer.g:20:10: ( 'contains' )
182 // InternalSolverLanguageLexer.g:20:12: 'contains'
183 {
184 match("contains");
185
186
187 }
188
189 state.type = _type;
190 state.channel = _channel;
191 }
192 finally {
193 }
194 }
195 // $ANTLR end "Contains"
196
197 // $ANTLR start "Maximize"
198 public final void mMaximize() throws RecognitionException {
199 try {
200 int _type = Maximize;
201 int _channel = DEFAULT_TOKEN_CHANNEL;
202 // InternalSolverLanguageLexer.g:22:10: ( 'maximize' )
203 // InternalSolverLanguageLexer.g:22:12: 'maximize'
204 {
205 match("maximize");
206
207
208 }
209
210 state.type = _type;
211 state.channel = _channel;
212 }
213 finally {
214 }
215 }
216 // $ANTLR end "Maximize"
217
218 // $ANTLR start "Minimize"
219 public final void mMinimize() throws RecognitionException {
220 try {
221 int _type = Minimize;
222 int _channel = DEFAULT_TOKEN_CHANNEL;
223 // InternalSolverLanguageLexer.g:24:10: ( 'minimize' )
224 // InternalSolverLanguageLexer.g:24:12: 'minimize'
225 {
226 match("minimize");
227
228
229 }
230
231 state.type = _type;
232 state.channel = _channel;
233 }
234 finally {
235 }
236 }
237 // $ANTLR end "Minimize"
238
239 // $ANTLR start "Opposite"
240 public final void mOpposite() throws RecognitionException {
241 try {
242 int _type = Opposite;
243 int _channel = DEFAULT_TOKEN_CHANNEL;
244 // InternalSolverLanguageLexer.g:26:10: ( 'opposite' )
245 // InternalSolverLanguageLexer.g:26:12: 'opposite'
246 {
247 match("opposite");
248
249
250 }
251
252 state.type = _type;
253 state.channel = _channel;
254 }
255 finally {
256 }
257 }
258 // $ANTLR end "Opposite"
259
260 // $ANTLR start "GREATER"
261 public final void mGREATER() throws RecognitionException {
262 try {
263 int _type = GREATER;
264 int _channel = DEFAULT_TOKEN_CHANNEL;
265 // InternalSolverLanguageLexer.g:28:9: ( 'GREATER' )
266 // InternalSolverLanguageLexer.g:28:11: 'GREATER'
267 {
268 match("GREATER");
269
270
271 }
272
273 state.type = _type;
274 state.channel = _channel;
275 }
276 finally {
277 }
278 }
279 // $ANTLR end "GREATER"
280
281 // $ANTLR start "LESS_EQ"
282 public final void mLESS_EQ() throws RecognitionException {
283 try {
284 int _type = LESS_EQ;
285 int _channel = DEFAULT_TOKEN_CHANNEL;
286 // InternalSolverLanguageLexer.g:30:9: ( 'LESS_EQ' )
287 // InternalSolverLanguageLexer.g:30:11: 'LESS_EQ'
288 {
289 match("LESS_EQ");
290
291
292 }
293
294 state.type = _type;
295 state.channel = _channel;
296 }
297 finally {
298 }
299 }
300 // $ANTLR end "LESS_EQ"
301
302 // $ANTLR start "Current"
303 public final void mCurrent() throws RecognitionException {
304 try {
305 int _type = Current;
306 int _channel = DEFAULT_TOKEN_CHANNEL;
307 // InternalSolverLanguageLexer.g:32:9: ( 'current' )
308 // InternalSolverLanguageLexer.g:32:11: 'current'
309 {
310 match("current");
311
312
313 }
314
315 state.type = _type;
316 state.channel = _channel;
317 }
318 finally {
319 }
320 }
321 // $ANTLR end "Current"
322
323 // $ANTLR start "Default"
324 public final void mDefault() throws RecognitionException {
325 try {
326 int _type = Default;
327 int _channel = DEFAULT_TOKEN_CHANNEL;
328 // InternalSolverLanguageLexer.g:34:9: ( 'default' )
329 // InternalSolverLanguageLexer.g:34:11: 'default'
330 {
331 match("default");
332
333
334 }
335
336 state.type = _type;
337 state.channel = _channel;
338 }
339 finally {
340 }
341 }
342 // $ANTLR end "Default"
343
344 // $ANTLR start "Extends"
345 public final void mExtends() throws RecognitionException {
346 try {
347 int _type = Extends;
348 int _channel = DEFAULT_TOKEN_CHANNEL;
349 // InternalSolverLanguageLexer.g:36:9: ( 'extends' )
350 // InternalSolverLanguageLexer.g:36:11: 'extends'
351 {
352 match("extends");
353
354
355 }
356
357 state.type = _type;
358 state.channel = _channel;
359 }
360 finally {
361 }
362 }
363 // $ANTLR end "Extends"
364
365 // $ANTLR start "Unknown"
366 public final void mUnknown() throws RecognitionException {
367 try {
368 int _type = Unknown;
369 int _channel = DEFAULT_TOKEN_CHANNEL;
370 // InternalSolverLanguageLexer.g:38:9: ( 'unknown' )
371 // InternalSolverLanguageLexer.g:38:11: 'unknown'
372 {
373 match("unknown");
374
375
376 }
377
378 state.type = _type;
379 state.channel = _channel;
380 }
381 finally {
382 }
383 }
384 // $ANTLR end "Unknown"
385
386 // $ANTLR start "NOT_EQ"
387 public final void mNOT_EQ() throws RecognitionException {
388 try {
389 int _type = NOT_EQ;
390 int _channel = DEFAULT_TOKEN_CHANNEL;
391 // InternalSolverLanguageLexer.g:40:8: ( 'NOT_EQ' )
392 // InternalSolverLanguageLexer.g:40:10: 'NOT_EQ'
393 {
394 match("NOT_EQ");
395
396
397 }
398
399 state.type = _type;
400 state.channel = _channel;
401 }
402 finally {
403 }
404 }
405 // $ANTLR end "NOT_EQ"
406
407 // $ANTLR start "Extern"
408 public final void mExtern() throws RecognitionException {
409 try {
410 int _type = Extern;
411 int _channel = DEFAULT_TOKEN_CHANNEL;
412 // InternalSolverLanguageLexer.g:42:8: ( 'extern' )
413 // InternalSolverLanguageLexer.g:42:10: 'extern'
414 {
415 match("extern");
416
417
418 }
419
420 state.type = _type;
421 state.channel = _channel;
422 }
423 finally {
424 }
425 }
426 // $ANTLR end "Extern"
427
428 // $ANTLR start "Class"
429 public final void mClass() throws RecognitionException {
430 try {
431 int _type = Class;
432 int _channel = DEFAULT_TOKEN_CHANNEL;
433 // InternalSolverLanguageLexer.g:44:7: ( 'class' )
434 // InternalSolverLanguageLexer.g:44:9: 'class'
435 {
436 match("class");
437
438
439 }
440
441 state.type = _type;
442 state.channel = _channel;
443 }
444 finally {
445 }
446 }
447 // $ANTLR end "Class"
448
449 // $ANTLR start "Count"
450 public final void mCount() throws RecognitionException {
451 try {
452 int _type = Count;
453 int _channel = DEFAULT_TOKEN_CHANNEL;
454 // InternalSolverLanguageLexer.g:46:7: ( 'count' )
455 // InternalSolverLanguageLexer.g:46:9: 'count'
456 {
457 match("count");
458
459
460 }
461
462 state.type = _type;
463 state.channel = _channel;
464 }
465 finally {
466 }
467 }
468 // $ANTLR end "Count"
469
470 // $ANTLR start "Empty"
471 public final void mEmpty() throws RecognitionException {
472 try {
473 int _type = Empty;
474 int _channel = DEFAULT_TOKEN_CHANNEL;
475 // InternalSolverLanguageLexer.g:48:7: ( 'empty' )
476 // InternalSolverLanguageLexer.g:48:9: 'empty'
477 {
478 match("empty");
479
480
481 }
482
483 state.type = _type;
484 state.channel = _channel;
485 }
486 finally {
487 }
488 }
489 // $ANTLR end "Empty"
490
491 // $ANTLR start "Error"
492 public final void mError() throws RecognitionException {
493 try {
494 int _type = Error;
495 int _channel = DEFAULT_TOKEN_CHANNEL;
496 // InternalSolverLanguageLexer.g:50:7: ( 'error' )
497 // InternalSolverLanguageLexer.g:50:9: 'error'
498 {
499 match("error");
500
501
502 }
503
504 state.type = _type;
505 state.channel = _channel;
506 }
507 finally {
508 }
509 }
510 // $ANTLR end "Error"
511
512 // $ANTLR start "False"
513 public final void mFalse() throws RecognitionException {
514 try {
515 int _type = False;
516 int _channel = DEFAULT_TOKEN_CHANNEL;
517 // InternalSolverLanguageLexer.g:52:7: ( 'false' )
518 // InternalSolverLanguageLexer.g:52:9: 'false'
519 {
520 match("false");
521
522
523 }
524
525 state.type = _type;
526 state.channel = _channel;
527 }
528 finally {
529 }
530 }
531 // $ANTLR end "False"
532
533 // $ANTLR start "Scope"
534 public final void mScope() throws RecognitionException {
535 try {
536 int _type = Scope;
537 int _channel = DEFAULT_TOKEN_CHANNEL;
538 // InternalSolverLanguageLexer.g:54:7: ( 'scope' )
539 // InternalSolverLanguageLexer.g:54:9: 'scope'
540 {
541 match("scope");
542
543
544 }
545
546 state.type = _type;
547 state.channel = _channel;
548 }
549 finally {
550 }
551 }
552 // $ANTLR end "Scope"
553
554 // $ANTLR start "LESS"
555 public final void mLESS() throws RecognitionException {
556 try {
557 int _type = LESS;
558 int _channel = DEFAULT_TOKEN_CHANNEL;
559 // InternalSolverLanguageLexer.g:56:6: ( 'LESS' )
560 // InternalSolverLanguageLexer.g:56:8: 'LESS'
561 {
562 match("LESS");
563
564
565 }
566
567 state.type = _type;
568 state.channel = _channel;
569 }
570 finally {
571 }
572 }
573 // $ANTLR end "LESS"
574
575 // $ANTLR start "Else"
576 public final void mElse() throws RecognitionException {
577 try {
578 int _type = Else;
579 int _channel = DEFAULT_TOKEN_CHANNEL;
580 // InternalSolverLanguageLexer.g:58:6: ( 'else' )
581 // InternalSolverLanguageLexer.g:58:8: 'else'
582 {
583 match("else");
584
585
586 }
587
588 state.type = _type;
589 state.channel = _channel;
590 }
591 finally {
592 }
593 }
594 // $ANTLR end "Else"
595
596 // $ANTLR start "Must"
597 public final void mMust() throws RecognitionException {
598 try {
599 int _type = Must;
600 int _channel = DEFAULT_TOKEN_CHANNEL;
601 // InternalSolverLanguageLexer.g:60:6: ( 'must' )
602 // InternalSolverLanguageLexer.g:60:8: 'must'
603 {
604 match("must");
605
606
607 }
608
609 state.type = _type;
610 state.channel = _channel;
611 }
612 finally {
613 }
614 }
615 // $ANTLR end "Must"
616
617 // $ANTLR start "Only"
618 public final void mOnly() throws RecognitionException {
619 try {
620 int _type = Only;
621 int _channel = DEFAULT_TOKEN_CHANNEL;
622 // InternalSolverLanguageLexer.g:62:6: ( 'only' )
623 // InternalSolverLanguageLexer.g:62:8: 'only'
624 {
625 match("only");
626
627
628 }
629
630 state.type = _type;
631 state.channel = _channel;
632 }
633 finally {
634 }
635 }
636 // $ANTLR end "Only"
637
638 // $ANTLR start "Prod"
639 public final void mProd() throws RecognitionException {
640 try {
641 int _type = Prod;
642 int _channel = DEFAULT_TOKEN_CHANNEL;
643 // InternalSolverLanguageLexer.g:64:6: ( 'prod' )
644 // InternalSolverLanguageLexer.g:64:8: 'prod'
645 {
646 match("prod");
647
648
649 }
650
651 state.type = _type;
652 state.channel = _channel;
653 }
654 finally {
655 }
656 }
657 // $ANTLR end "Prod"
658
659 // $ANTLR start "Real"
660 public final void mReal() throws RecognitionException {
661 try {
662 int _type = Real;
663 int _channel = DEFAULT_TOKEN_CHANNEL;
664 // InternalSolverLanguageLexer.g:66:6: ( 'real' )
665 // InternalSolverLanguageLexer.g:66:8: 'real'
666 {
667 match("real");
668
669
670 }
671
672 state.type = _type;
673 state.channel = _channel;
674 }
675 finally {
676 }
677 }
678 // $ANTLR end "Real"
679
680 // $ANTLR start "Then"
681 public final void mThen() throws RecognitionException {
682 try {
683 int _type = Then;
684 int _channel = DEFAULT_TOKEN_CHANNEL;
685 // InternalSolverLanguageLexer.g:68:6: ( 'then' )
686 // InternalSolverLanguageLexer.g:68:8: 'then'
687 {
688 match("then");
689
690
691 }
692
693 state.type = _type;
694 state.channel = _channel;
695 }
696 finally {
697 }
698 }
699 // $ANTLR end "Then"
700
701 // $ANTLR start "True"
702 public final void mTrue() throws RecognitionException {
703 try {
704 int _type = True;
705 int _channel = DEFAULT_TOKEN_CHANNEL;
706 // InternalSolverLanguageLexer.g:70:6: ( 'true' )
707 // InternalSolverLanguageLexer.g:70:8: 'true'
708 {
709 match("true");
710
711
712 }
713
714 state.type = _type;
715 state.channel = _channel;
716 }
717 finally {
718 }
719 }
720 // $ANTLR end "True"
721
722 // $ANTLR start "ADD"
723 public final void mADD() throws RecognitionException {
724 try {
725 int _type = ADD;
726 int _channel = DEFAULT_TOKEN_CHANNEL;
727 // InternalSolverLanguageLexer.g:72:5: ( 'ADD' )
728 // InternalSolverLanguageLexer.g:72:7: 'ADD'
729 {
730 match("ADD");
731
732
733 }
734
735 state.type = _type;
736 state.channel = _channel;
737 }
738 finally {
739 }
740 }
741 // $ANTLR end "ADD"
742
743 // $ANTLR start "DIV"
744 public final void mDIV() throws RecognitionException {
745 try {
746 int _type = DIV;
747 int _channel = DEFAULT_TOKEN_CHANNEL;
748 // InternalSolverLanguageLexer.g:74:5: ( 'DIV' )
749 // InternalSolverLanguageLexer.g:74:7: 'DIV'
750 {
751 match("DIV");
752
753
754 }
755
756 state.type = _type;
757 state.channel = _channel;
758 }
759 finally {
760 }
761 }
762 // $ANTLR end "DIV"
763
764 // $ANTLR start "MUL"
765 public final void mMUL() throws RecognitionException {
766 try {
767 int _type = MUL;
768 int _channel = DEFAULT_TOKEN_CHANNEL;
769 // InternalSolverLanguageLexer.g:76:5: ( 'MUL' )
770 // InternalSolverLanguageLexer.g:76:7: 'MUL'
771 {
772 match("MUL");
773
774
775 }
776
777 state.type = _type;
778 state.channel = _channel;
779 }
780 finally {
781 }
782 }
783 // $ANTLR end "MUL"
784
785 // $ANTLR start "POW"
786 public final void mPOW() throws RecognitionException {
787 try {
788 int _type = POW;
789 int _channel = DEFAULT_TOKEN_CHANNEL;
790 // InternalSolverLanguageLexer.g:78:5: ( 'POW' )
791 // InternalSolverLanguageLexer.g:78:7: 'POW'
792 {
793 match("POW");
794
795
796 }
797
798 state.type = _type;
799 state.channel = _channel;
800 }
801 finally {
802 }
803 }
804 // $ANTLR end "POW"
805
806 // $ANTLR start "SUB"
807 public final void mSUB() throws RecognitionException {
808 try {
809 int _type = SUB;
810 int _channel = DEFAULT_TOKEN_CHANNEL;
811 // InternalSolverLanguageLexer.g:80:5: ( 'SUB' )
812 // InternalSolverLanguageLexer.g:80:7: 'SUB'
813 {
814 match("SUB");
815
816
817 }
818
819 state.type = _type;
820 state.channel = _channel;
821 }
822 finally {
823 }
824 }
825 // $ANTLR end "SUB"
826
827 // $ANTLR start "Avg"
828 public final void mAvg() throws RecognitionException {
829 try {
830 int _type = Avg;
831 int _channel = DEFAULT_TOKEN_CHANNEL;
832 // InternalSolverLanguageLexer.g:82:5: ( 'avg' )
833 // InternalSolverLanguageLexer.g:82:7: 'avg'
834 {
835 match("avg");
836
837
838 }
839
840 state.type = _type;
841 state.channel = _channel;
842 }
843 finally {
844 }
845 }
846 // $ANTLR end "Avg"
847
848 // $ANTLR start "Inf"
849 public final void mInf() throws RecognitionException {
850 try {
851 int _type = Inf;
852 int _channel = DEFAULT_TOKEN_CHANNEL;
853 // InternalSolverLanguageLexer.g:84:5: ( 'inf' )
854 // InternalSolverLanguageLexer.g:84:7: 'inf'
855 {
856 match("inf");
857
858
859 }
860
861 state.type = _type;
862 state.channel = _channel;
863 }
864 finally {
865 }
866 }
867 // $ANTLR end "Inf"
868
869 // $ANTLR start "Int"
870 public final void mInt() throws RecognitionException {
871 try {
872 int _type = Int;
873 int _channel = DEFAULT_TOKEN_CHANNEL;
874 // InternalSolverLanguageLexer.g:86:5: ( 'int' )
875 // InternalSolverLanguageLexer.g:86:7: 'int'
876 {
877 match("int");
878
879
880 }
881
882 state.type = _type;
883 state.channel = _channel;
884 }
885 finally {
886 }
887 }
888 // $ANTLR end "Int"
889
890 // $ANTLR start "Max"
891 public final void mMax() throws RecognitionException {
892 try {
893 int _type = Max;
894 int _channel = DEFAULT_TOKEN_CHANNEL;
895 // InternalSolverLanguageLexer.g:88:5: ( 'max' )
896 // InternalSolverLanguageLexer.g:88:7: 'max'
897 {
898 match("max");
899
900
901 }
902
903 state.type = _type;
904 state.channel = _channel;
905 }
906 finally {
907 }
908 }
909 // $ANTLR end "Max"
910
911 // $ANTLR start "May"
912 public final void mMay() throws RecognitionException {
913 try {
914 int _type = May;
915 int _channel = DEFAULT_TOKEN_CHANNEL;
916 // InternalSolverLanguageLexer.g:90:5: ( 'may' )
917 // InternalSolverLanguageLexer.g:90:7: 'may'
918 {
919 match("may");
920
921
922 }
923
924 state.type = _type;
925 state.channel = _channel;
926 }
927 finally {
928 }
929 }
930 // $ANTLR end "May"
931
932 // $ANTLR start "Min"
933 public final void mMin() throws RecognitionException {
934 try {
935 int _type = Min;
936 int _channel = DEFAULT_TOKEN_CHANNEL;
937 // InternalSolverLanguageLexer.g:92:5: ( 'min' )
938 // InternalSolverLanguageLexer.g:92:7: 'min'
939 {
940 match("min");
941
942
943 }
944
945 state.type = _type;
946 state.channel = _channel;
947 }
948 finally {
949 }
950 }
951 // $ANTLR end "Min"
952
953 // $ANTLR start "Sum"
954 public final void mSum() throws RecognitionException {
955 try {
956 int _type = Sum;
957 int _channel = DEFAULT_TOKEN_CHANNEL;
958 // InternalSolverLanguageLexer.g:94:5: ( 'sum' )
959 // InternalSolverLanguageLexer.g:94:7: 'sum'
960 {
961 match("sum");
962
963
964 }
965
966 state.type = _type;
967 state.channel = _channel;
968 }
969 finally {
970 }
971 }
972 // $ANTLR end "Sum"
973
974 // $ANTLR start "ExclamationMarkEqualsSign"
975 public final void mExclamationMarkEqualsSign() throws RecognitionException {
976 try {
977 int _type = ExclamationMarkEqualsSign;
978 int _channel = DEFAULT_TOKEN_CHANNEL;
979 // InternalSolverLanguageLexer.g:96:27: ( '!=' )
980 // InternalSolverLanguageLexer.g:96:29: '!='
981 {
982 match("!=");
983
984
985 }
986
987 state.type = _type;
988 state.channel = _channel;
989 }
990 finally {
991 }
992 }
993 // $ANTLR end "ExclamationMarkEqualsSign"
994
995 // $ANTLR start "HyphenMinusGreaterThanSign"
996 public final void mHyphenMinusGreaterThanSign() throws RecognitionException {
997 try {
998 int _type = HyphenMinusGreaterThanSign;
999 int _channel = DEFAULT_TOKEN_CHANNEL;
1000 // InternalSolverLanguageLexer.g:98:28: ( '->' )
1001 // InternalSolverLanguageLexer.g:98:30: '->'
1002 {
1003 match("->");
1004
1005
1006 }
1007
1008 state.type = _type;
1009 state.channel = _channel;
1010 }
1011 finally {
1012 }
1013 }
1014 // $ANTLR end "HyphenMinusGreaterThanSign"
1015
1016 // $ANTLR start "FullStopFullStop"
1017 public final void mFullStopFullStop() throws RecognitionException {
1018 try {
1019 int _type = FullStopFullStop;
1020 int _channel = DEFAULT_TOKEN_CHANNEL;
1021 // InternalSolverLanguageLexer.g:100:18: ( '..' )
1022 // InternalSolverLanguageLexer.g:100:20: '..'
1023 {
1024 match("..");
1025
1026
1027 }
1028
1029 state.type = _type;
1030 state.channel = _channel;
1031 }
1032 finally {
1033 }
1034 }
1035 // $ANTLR end "FullStopFullStop"
1036
1037 // $ANTLR start "ColonHyphenMinus"
1038 public final void mColonHyphenMinus() throws RecognitionException {
1039 try {
1040 int _type = ColonHyphenMinus;
1041 int _channel = DEFAULT_TOKEN_CHANNEL;
1042 // InternalSolverLanguageLexer.g:102:18: ( ':-' )
1043 // InternalSolverLanguageLexer.g:102:20: ':-'
1044 {
1045 match(":-");
1046
1047
1048 }
1049
1050 state.type = _type;
1051 state.channel = _channel;
1052 }
1053 finally {
1054 }
1055 }
1056 // $ANTLR end "ColonHyphenMinus"
1057
1058 // $ANTLR start "LessThanSignEqualsSign"
1059 public final void mLessThanSignEqualsSign() throws RecognitionException {
1060 try {
1061 int _type = LessThanSignEqualsSign;
1062 int _channel = DEFAULT_TOKEN_CHANNEL;
1063 // InternalSolverLanguageLexer.g:104:24: ( '<=' )
1064 // InternalSolverLanguageLexer.g:104:26: '<='
1065 {
1066 match("<=");
1067
1068
1069 }
1070
1071 state.type = _type;
1072 state.channel = _channel;
1073 }
1074 finally {
1075 }
1076 }
1077 // $ANTLR end "LessThanSignEqualsSign"
1078
1079 // $ANTLR start "EqualsSignEqualsSign"
1080 public final void mEqualsSignEqualsSign() throws RecognitionException {
1081 try {
1082 int _type = EqualsSignEqualsSign;
1083 int _channel = DEFAULT_TOKEN_CHANNEL;
1084 // InternalSolverLanguageLexer.g:106:22: ( '==' )
1085 // InternalSolverLanguageLexer.g:106:24: '=='
1086 {
1087 match("==");
1088
1089
1090 }
1091
1092 state.type = _type;
1093 state.channel = _channel;
1094 }
1095 finally {
1096 }
1097 }
1098 // $ANTLR end "EqualsSignEqualsSign"
1099
1100 // $ANTLR start "GreaterThanSignEqualsSign"
1101 public final void mGreaterThanSignEqualsSign() throws RecognitionException {
1102 try {
1103 int _type = GreaterThanSignEqualsSign;
1104 int _channel = DEFAULT_TOKEN_CHANNEL;
1105 // InternalSolverLanguageLexer.g:108:27: ( '>=' )
1106 // InternalSolverLanguageLexer.g:108:29: '>='
1107 {
1108 match(">=");
1109
1110
1111 }
1112
1113 state.type = _type;
1114 state.channel = _channel;
1115 }
1116 finally {
1117 }
1118 }
1119 // $ANTLR end "GreaterThanSignEqualsSign"
1120
1121 // $ANTLR start "EQ"
1122 public final void mEQ() throws RecognitionException {
1123 try {
1124 int _type = EQ;
1125 int _channel = DEFAULT_TOKEN_CHANNEL;
1126 // InternalSolverLanguageLexer.g:110:4: ( 'EQ' )
1127 // InternalSolverLanguageLexer.g:110:6: 'EQ'
1128 {
1129 match("EQ");
1130
1131
1132 }
1133
1134 state.type = _type;
1135 state.channel = _channel;
1136 }
1137 finally {
1138 }
1139 }
1140 // $ANTLR end "EQ"
1141
1142 // $ANTLR start "IN"
1143 public final void mIN() throws RecognitionException {
1144 try {
1145 int _type = IN;
1146 int _channel = DEFAULT_TOKEN_CHANNEL;
1147 // InternalSolverLanguageLexer.g:112:4: ( 'IN' )
1148 // InternalSolverLanguageLexer.g:112:6: 'IN'
1149 {
1150 match("IN");
1151
1152
1153 }
1154
1155 state.type = _type;
1156 state.channel = _channel;
1157 }
1158 finally {
1159 }
1160 }
1161 // $ANTLR end "IN"
1162
1163 // $ANTLR start "If"
1164 public final void mIf() throws RecognitionException {
1165 try {
1166 int _type = If;
1167 int _channel = DEFAULT_TOKEN_CHANNEL;
1168 // InternalSolverLanguageLexer.g:114:4: ( 'if' )
1169 // InternalSolverLanguageLexer.g:114:6: 'if'
1170 {
1171 match("if");
1172
1173
1174 }
1175
1176 state.type = _type;
1177 state.channel = _channel;
1178 }
1179 finally {
1180 }
1181 }
1182 // $ANTLR end "If"
1183
1184 // $ANTLR start "In"
1185 public final void mIn() throws RecognitionException {
1186 try {
1187 int _type = In;
1188 int _channel = DEFAULT_TOKEN_CHANNEL;
1189 // InternalSolverLanguageLexer.g:116:4: ( 'in' )
1190 // InternalSolverLanguageLexer.g:116:6: 'in'
1191 {
1192 match("in");
1193
1194
1195 }
1196
1197 state.type = _type;
1198 state.channel = _channel;
1199 }
1200 finally {
1201 }
1202 }
1203 // $ANTLR end "In"
1204
1205 // $ANTLR start "ExclamationMark"
1206 public final void mExclamationMark() throws RecognitionException {
1207 try {
1208 int _type = ExclamationMark;
1209 int _channel = DEFAULT_TOKEN_CHANNEL;
1210 // InternalSolverLanguageLexer.g:118:17: ( '!' )
1211 // InternalSolverLanguageLexer.g:118:19: '!'
1212 {
1213 match('!');
1214
1215 }
1216
1217 state.type = _type;
1218 state.channel = _channel;
1219 }
1220 finally {
1221 }
1222 }
1223 // $ANTLR end "ExclamationMark"
1224
1225 // $ANTLR start "LeftParenthesis"
1226 public final void mLeftParenthesis() throws RecognitionException {
1227 try {
1228 int _type = LeftParenthesis;
1229 int _channel = DEFAULT_TOKEN_CHANNEL;
1230 // InternalSolverLanguageLexer.g:120:17: ( '(' )
1231 // InternalSolverLanguageLexer.g:120:19: '('
1232 {
1233 match('(');
1234
1235 }
1236
1237 state.type = _type;
1238 state.channel = _channel;
1239 }
1240 finally {
1241 }
1242 }
1243 // $ANTLR end "LeftParenthesis"
1244
1245 // $ANTLR start "RightParenthesis"
1246 public final void mRightParenthesis() throws RecognitionException {
1247 try {
1248 int _type = RightParenthesis;
1249 int _channel = DEFAULT_TOKEN_CHANNEL;
1250 // InternalSolverLanguageLexer.g:122:18: ( ')' )
1251 // InternalSolverLanguageLexer.g:122:20: ')'
1252 {
1253 match(')');
1254
1255 }
1256
1257 state.type = _type;
1258 state.channel = _channel;
1259 }
1260 finally {
1261 }
1262 }
1263 // $ANTLR end "RightParenthesis"
1264
1265 // $ANTLR start "Asterisk"
1266 public final void mAsterisk() throws RecognitionException {
1267 try {
1268 int _type = Asterisk;
1269 int _channel = DEFAULT_TOKEN_CHANNEL;
1270 // InternalSolverLanguageLexer.g:124:10: ( '*' )
1271 // InternalSolverLanguageLexer.g:124:12: '*'
1272 {
1273 match('*');
1274
1275 }
1276
1277 state.type = _type;
1278 state.channel = _channel;
1279 }
1280 finally {
1281 }
1282 }
1283 // $ANTLR end "Asterisk"
1284
1285 // $ANTLR start "PlusSign"
1286 public final void mPlusSign() throws RecognitionException {
1287 try {
1288 int _type = PlusSign;
1289 int _channel = DEFAULT_TOKEN_CHANNEL;
1290 // InternalSolverLanguageLexer.g:126:10: ( '+' )
1291 // InternalSolverLanguageLexer.g:126:12: '+'
1292 {
1293 match('+');
1294
1295 }
1296
1297 state.type = _type;
1298 state.channel = _channel;
1299 }
1300 finally {
1301 }
1302 }
1303 // $ANTLR end "PlusSign"
1304
1305 // $ANTLR start "Comma"
1306 public final void mComma() throws RecognitionException {
1307 try {
1308 int _type = Comma;
1309 int _channel = DEFAULT_TOKEN_CHANNEL;
1310 // InternalSolverLanguageLexer.g:128:7: ( ',' )
1311 // InternalSolverLanguageLexer.g:128:9: ','
1312 {
1313 match(',');
1314
1315 }
1316
1317 state.type = _type;
1318 state.channel = _channel;
1319 }
1320 finally {
1321 }
1322 }
1323 // $ANTLR end "Comma"
1324
1325 // $ANTLR start "HyphenMinus"
1326 public final void mHyphenMinus() throws RecognitionException {
1327 try {
1328 int _type = HyphenMinus;
1329 int _channel = DEFAULT_TOKEN_CHANNEL;
1330 // InternalSolverLanguageLexer.g:130:13: ( '-' )
1331 // InternalSolverLanguageLexer.g:130:15: '-'
1332 {
1333 match('-');
1334
1335 }
1336
1337 state.type = _type;
1338 state.channel = _channel;
1339 }
1340 finally {
1341 }
1342 }
1343 // $ANTLR end "HyphenMinus"
1344
1345 // $ANTLR start "FullStop"
1346 public final void mFullStop() throws RecognitionException {
1347 try {
1348 int _type = FullStop;
1349 int _channel = DEFAULT_TOKEN_CHANNEL;
1350 // InternalSolverLanguageLexer.g:132:10: ( '.' )
1351 // InternalSolverLanguageLexer.g:132:12: '.'
1352 {
1353 match('.');
1354
1355 }
1356
1357 state.type = _type;
1358 state.channel = _channel;
1359 }
1360 finally {
1361 }
1362 }
1363 // $ANTLR end "FullStop"
1364
1365 // $ANTLR start "Solidus"
1366 public final void mSolidus() throws RecognitionException {
1367 try {
1368 int _type = Solidus;
1369 int _channel = DEFAULT_TOKEN_CHANNEL;
1370 // InternalSolverLanguageLexer.g:134:9: ( '/' )
1371 // InternalSolverLanguageLexer.g:134:11: '/'
1372 {
1373 match('/');
1374
1375 }
1376
1377 state.type = _type;
1378 state.channel = _channel;
1379 }
1380 finally {
1381 }
1382 }
1383 // $ANTLR end "Solidus"
1384
1385 // $ANTLR start "Colon"
1386 public final void mColon() throws RecognitionException {
1387 try {
1388 int _type = Colon;
1389 int _channel = DEFAULT_TOKEN_CHANNEL;
1390 // InternalSolverLanguageLexer.g:136:7: ( ':' )
1391 // InternalSolverLanguageLexer.g:136:9: ':'
1392 {
1393 match(':');
1394
1395 }
1396
1397 state.type = _type;
1398 state.channel = _channel;
1399 }
1400 finally {
1401 }
1402 }
1403 // $ANTLR end "Colon"
1404
1405 // $ANTLR start "Semicolon"
1406 public final void mSemicolon() throws RecognitionException {
1407 try {
1408 int _type = Semicolon;
1409 int _channel = DEFAULT_TOKEN_CHANNEL;
1410 // InternalSolverLanguageLexer.g:138:11: ( ';' )
1411 // InternalSolverLanguageLexer.g:138:13: ';'
1412 {
1413 match(';');
1414
1415 }
1416
1417 state.type = _type;
1418 state.channel = _channel;
1419 }
1420 finally {
1421 }
1422 }
1423 // $ANTLR end "Semicolon"
1424
1425 // $ANTLR start "LessThanSign"
1426 public final void mLessThanSign() throws RecognitionException {
1427 try {
1428 int _type = LessThanSign;
1429 int _channel = DEFAULT_TOKEN_CHANNEL;
1430 // InternalSolverLanguageLexer.g:140:14: ( '<' )
1431 // InternalSolverLanguageLexer.g:140:16: '<'
1432 {
1433 match('<');
1434
1435 }
1436
1437 state.type = _type;
1438 state.channel = _channel;
1439 }
1440 finally {
1441 }
1442 }
1443 // $ANTLR end "LessThanSign"
1444
1445 // $ANTLR start "EqualsSign"
1446 public final void mEqualsSign() throws RecognitionException {
1447 try {
1448 int _type = EqualsSign;
1449 int _channel = DEFAULT_TOKEN_CHANNEL;
1450 // InternalSolverLanguageLexer.g:142:12: ( '=' )
1451 // InternalSolverLanguageLexer.g:142:14: '='
1452 {
1453 match('=');
1454
1455 }
1456
1457 state.type = _type;
1458 state.channel = _channel;
1459 }
1460 finally {
1461 }
1462 }
1463 // $ANTLR end "EqualsSign"
1464
1465 // $ANTLR start "GreaterThanSign"
1466 public final void mGreaterThanSign() throws RecognitionException {
1467 try {
1468 int _type = GreaterThanSign;
1469 int _channel = DEFAULT_TOKEN_CHANNEL;
1470 // InternalSolverLanguageLexer.g:144:17: ( '>' )
1471 // InternalSolverLanguageLexer.g:144:19: '>'
1472 {
1473 match('>');
1474
1475 }
1476
1477 state.type = _type;
1478 state.channel = _channel;
1479 }
1480 finally {
1481 }
1482 }
1483 // $ANTLR end "GreaterThanSign"
1484
1485 // $ANTLR start "LeftSquareBracket"
1486 public final void mLeftSquareBracket() throws RecognitionException {
1487 try {
1488 int _type = LeftSquareBracket;
1489 int _channel = DEFAULT_TOKEN_CHANNEL;
1490 // InternalSolverLanguageLexer.g:146:19: ( '[' )
1491 // InternalSolverLanguageLexer.g:146:21: '['
1492 {
1493 match('[');
1494
1495 }
1496
1497 state.type = _type;
1498 state.channel = _channel;
1499 }
1500 finally {
1501 }
1502 }
1503 // $ANTLR end "LeftSquareBracket"
1504
1505 // $ANTLR start "RightSquareBracket"
1506 public final void mRightSquareBracket() throws RecognitionException {
1507 try {
1508 int _type = RightSquareBracket;
1509 int _channel = DEFAULT_TOKEN_CHANNEL;
1510 // InternalSolverLanguageLexer.g:148:20: ( ']' )
1511 // InternalSolverLanguageLexer.g:148:22: ']'
1512 {
1513 match(']');
1514
1515 }
1516
1517 state.type = _type;
1518 state.channel = _channel;
1519 }
1520 finally {
1521 }
1522 }
1523 // $ANTLR end "RightSquareBracket"
1524
1525 // $ANTLR start "CircumflexAccent"
1526 public final void mCircumflexAccent() throws RecognitionException {
1527 try {
1528 int _type = CircumflexAccent;
1529 int _channel = DEFAULT_TOKEN_CHANNEL;
1530 // InternalSolverLanguageLexer.g:150:18: ( '^' )
1531 // InternalSolverLanguageLexer.g:150:20: '^'
1532 {
1533 match('^');
1534
1535 }
1536
1537 state.type = _type;
1538 state.channel = _channel;
1539 }
1540 finally {
1541 }
1542 }
1543 // $ANTLR end "CircumflexAccent"
1544
1545 // $ANTLR start "LeftCurlyBracket"
1546 public final void mLeftCurlyBracket() throws RecognitionException {
1547 try {
1548 int _type = LeftCurlyBracket;
1549 int _channel = DEFAULT_TOKEN_CHANNEL;
1550 // InternalSolverLanguageLexer.g:152:18: ( '{' )
1551 // InternalSolverLanguageLexer.g:152:20: '{'
1552 {
1553 match('{');
1554
1555 }
1556
1557 state.type = _type;
1558 state.channel = _channel;
1559 }
1560 finally {
1561 }
1562 }
1563 // $ANTLR end "LeftCurlyBracket"
1564
1565 // $ANTLR start "VerticalLine"
1566 public final void mVerticalLine() throws RecognitionException {
1567 try {
1568 int _type = VerticalLine;
1569 int _channel = DEFAULT_TOKEN_CHANNEL;
1570 // InternalSolverLanguageLexer.g:154:14: ( '|' )
1571 // InternalSolverLanguageLexer.g:154:16: '|'
1572 {
1573 match('|');
1574
1575 }
1576
1577 state.type = _type;
1578 state.channel = _channel;
1579 }
1580 finally {
1581 }
1582 }
1583 // $ANTLR end "VerticalLine"
1584
1585 // $ANTLR start "RightCurlyBracket"
1586 public final void mRightCurlyBracket() throws RecognitionException {
1587 try {
1588 int _type = RightCurlyBracket;
1589 int _channel = DEFAULT_TOKEN_CHANNEL;
1590 // InternalSolverLanguageLexer.g:156:19: ( '}' )
1591 // InternalSolverLanguageLexer.g:156:21: '}'
1592 {
1593 match('}');
1594
1595 }
1596
1597 state.type = _type;
1598 state.channel = _channel;
1599 }
1600 finally {
1601 }
1602 }
1603 // $ANTLR end "RightCurlyBracket"
1604
1605 // $ANTLR start "RULE_STRING"
1606 public final void mRULE_STRING() throws RecognitionException {
1607 try {
1608 int _type = RULE_STRING;
1609 int _channel = DEFAULT_TOKEN_CHANNEL;
1610 // InternalSolverLanguageLexer.g:158:13: ( '\"' ( '\\\\' . | ~ ( ( '\\\\' | '\"' ) ) )* '\"' )
1611 // InternalSolverLanguageLexer.g:158:15: '\"' ( '\\\\' . | ~ ( ( '\\\\' | '\"' ) ) )* '\"'
1612 {
1613 match('\"');
1614 // InternalSolverLanguageLexer.g:158:19: ( '\\\\' . | ~ ( ( '\\\\' | '\"' ) ) )*
1615 loop1:
1616 do {
1617 int alt1=3;
1618 int LA1_0 = input.LA(1);
1619
1620 if ( (LA1_0=='\\') ) {
1621 alt1=1;
1622 }
1623 else if ( ((LA1_0>='\u0000' && LA1_0<='!')||(LA1_0>='#' && LA1_0<='[')||(LA1_0>=']' && LA1_0<='\uFFFF')) ) {
1624 alt1=2;
1625 }
1626
1627
1628 switch (alt1) {
1629 case 1 :
1630 // InternalSolverLanguageLexer.g:158:20: '\\\\' .
1631 {
1632 match('\\');
1633 matchAny();
1634
1635 }
1636 break;
1637 case 2 :
1638 // InternalSolverLanguageLexer.g:158:27: ~ ( ( '\\\\' | '\"' ) )
1639 {
1640 if ( (input.LA(1)>='\u0000' && input.LA(1)<='!')||(input.LA(1)>='#' && input.LA(1)<='[')||(input.LA(1)>=']' && input.LA(1)<='\uFFFF') ) {
1641 input.consume();
1642
1643 }
1644 else {
1645 MismatchedSetException mse = new MismatchedSetException(null,input);
1646 recover(mse);
1647 throw mse;}
1648
1649
1650 }
1651 break;
1652
1653 default :
1654 break loop1;
1655 }
1656 } while (true);
1657
1658 match('\"');
1659
1660 }
1661
1662 state.type = _type;
1663 state.channel = _channel;
1664 }
1665 finally {
1666 }
1667 }
1668 // $ANTLR end "RULE_STRING"
1669
1670 // $ANTLR start "RULE_QUOTED_ID"
1671 public final void mRULE_QUOTED_ID() throws RecognitionException {
1672 try {
1673 int _type = RULE_QUOTED_ID;
1674 int _channel = DEFAULT_TOKEN_CHANNEL;
1675 // InternalSolverLanguageLexer.g:160:16: ( '\\'' ( '\\\\' . | ~ ( ( '\\\\' | '\\'' ) ) )* '\\'' )
1676 // InternalSolverLanguageLexer.g:160:18: '\\'' ( '\\\\' . | ~ ( ( '\\\\' | '\\'' ) ) )* '\\''
1677 {
1678 match('\'');
1679 // InternalSolverLanguageLexer.g:160:23: ( '\\\\' . | ~ ( ( '\\\\' | '\\'' ) ) )*
1680 loop2:
1681 do {
1682 int alt2=3;
1683 int LA2_0 = input.LA(1);
1684
1685 if ( (LA2_0=='\\') ) {
1686 alt2=1;
1687 }
1688 else if ( ((LA2_0>='\u0000' && LA2_0<='&')||(LA2_0>='(' && LA2_0<='[')||(LA2_0>=']' && LA2_0<='\uFFFF')) ) {
1689 alt2=2;
1690 }
1691
1692
1693 switch (alt2) {
1694 case 1 :
1695 // InternalSolverLanguageLexer.g:160:24: '\\\\' .
1696 {
1697 match('\\');
1698 matchAny();
1699
1700 }
1701 break;
1702 case 2 :
1703 // InternalSolverLanguageLexer.g:160:31: ~ ( ( '\\\\' | '\\'' ) )
1704 {
1705 if ( (input.LA(1)>='\u0000' && input.LA(1)<='&')||(input.LA(1)>='(' && input.LA(1)<='[')||(input.LA(1)>=']' && input.LA(1)<='\uFFFF') ) {
1706 input.consume();
1707
1708 }
1709 else {
1710 MismatchedSetException mse = new MismatchedSetException(null,input);
1711 recover(mse);
1712 throw mse;}
1713
1714
1715 }
1716 break;
1717
1718 default :
1719 break loop2;
1720 }
1721 } while (true);
1722
1723 match('\'');
1724
1725 }
1726
1727 state.type = _type;
1728 state.channel = _channel;
1729 }
1730 finally {
1731 }
1732 }
1733 // $ANTLR end "RULE_QUOTED_ID"
1734
1735 // $ANTLR start "RULE_SL_COMMENT"
1736 public final void mRULE_SL_COMMENT() throws RecognitionException {
1737 try {
1738 int _type = RULE_SL_COMMENT;
1739 int _channel = DEFAULT_TOKEN_CHANNEL;
1740 // InternalSolverLanguageLexer.g:162:17: ( ( '%' | '//' ) (~ ( ( '\\n' | '\\r' ) ) )* ( ( '\\r' )? '\\n' )? )
1741 // InternalSolverLanguageLexer.g:162:19: ( '%' | '//' ) (~ ( ( '\\n' | '\\r' ) ) )* ( ( '\\r' )? '\\n' )?
1742 {
1743 // InternalSolverLanguageLexer.g:162:19: ( '%' | '//' )
1744 int alt3=2;
1745 int LA3_0 = input.LA(1);
1746
1747 if ( (LA3_0=='%') ) {
1748 alt3=1;
1749 }
1750 else if ( (LA3_0=='/') ) {
1751 alt3=2;
1752 }
1753 else {
1754 NoViableAltException nvae =
1755 new NoViableAltException("", 3, 0, input);
1756
1757 throw nvae;
1758 }
1759 switch (alt3) {
1760 case 1 :
1761 // InternalSolverLanguageLexer.g:162:20: '%'
1762 {
1763 match('%');
1764
1765 }
1766 break;
1767 case 2 :
1768 // InternalSolverLanguageLexer.g:162:24: '//'
1769 {
1770 match("//");
1771
1772
1773 }
1774 break;
1775
1776 }
1777
1778 // InternalSolverLanguageLexer.g:162:30: (~ ( ( '\\n' | '\\r' ) ) )*
1779 loop4:
1780 do {
1781 int alt4=2;
1782 int LA4_0 = input.LA(1);
1783
1784 if ( ((LA4_0>='\u0000' && LA4_0<='\t')||(LA4_0>='\u000B' && LA4_0<='\f')||(LA4_0>='\u000E' && LA4_0<='\uFFFF')) ) {
1785 alt4=1;
1786 }
1787
1788
1789 switch (alt4) {
1790 case 1 :
1791 // InternalSolverLanguageLexer.g:162:30: ~ ( ( '\\n' | '\\r' ) )
1792 {
1793 if ( (input.LA(1)>='\u0000' && input.LA(1)<='\t')||(input.LA(1)>='\u000B' && input.LA(1)<='\f')||(input.LA(1)>='\u000E' && input.LA(1)<='\uFFFF') ) {
1794 input.consume();
1795
1796 }
1797 else {
1798 MismatchedSetException mse = new MismatchedSetException(null,input);
1799 recover(mse);
1800 throw mse;}
1801
1802
1803 }
1804 break;
1805
1806 default :
1807 break loop4;
1808 }
1809 } while (true);
1810
1811 // InternalSolverLanguageLexer.g:162:46: ( ( '\\r' )? '\\n' )?
1812 int alt6=2;
1813 int LA6_0 = input.LA(1);
1814
1815 if ( (LA6_0=='\n'||LA6_0=='\r') ) {
1816 alt6=1;
1817 }
1818 switch (alt6) {
1819 case 1 :
1820 // InternalSolverLanguageLexer.g:162:47: ( '\\r' )? '\\n'
1821 {
1822 // InternalSolverLanguageLexer.g:162:47: ( '\\r' )?
1823 int alt5=2;
1824 int LA5_0 = input.LA(1);
1825
1826 if ( (LA5_0=='\r') ) {
1827 alt5=1;
1828 }
1829 switch (alt5) {
1830 case 1 :
1831 // InternalSolverLanguageLexer.g:162:47: '\\r'
1832 {
1833 match('\r');
1834
1835 }
1836 break;
1837
1838 }
1839
1840 match('\n');
1841
1842 }
1843 break;
1844
1845 }
1846
1847
1848 }
1849
1850 state.type = _type;
1851 state.channel = _channel;
1852 }
1853 finally {
1854 }
1855 }
1856 // $ANTLR end "RULE_SL_COMMENT"
1857
1858 // $ANTLR start "RULE_TRANSITIVE_CLOSURE"
1859 public final void mRULE_TRANSITIVE_CLOSURE() throws RecognitionException {
1860 try {
1861 // InternalSolverLanguageLexer.g:164:34: ()
1862 // InternalSolverLanguageLexer.g:164:36:
1863 {
1864 }
1865
1866 }
1867 finally {
1868 }
1869 }
1870 // $ANTLR end "RULE_TRANSITIVE_CLOSURE"
1871
1872 // $ANTLR start "RULE_REFLEXIVE_TRANSITIVE_CLOSURE"
1873 public final void mRULE_REFLEXIVE_TRANSITIVE_CLOSURE() throws RecognitionException {
1874 try {
1875 // InternalSolverLanguageLexer.g:166:44: ()
1876 // InternalSolverLanguageLexer.g:166:46:
1877 {
1878 }
1879
1880 }
1881 finally {
1882 }
1883 }
1884 // $ANTLR end "RULE_REFLEXIVE_TRANSITIVE_CLOSURE"
1885
1886 // $ANTLR start "RULE_FULL_STOP"
1887 public final void mRULE_FULL_STOP() throws RecognitionException {
1888 try {
1889 // InternalSolverLanguageLexer.g:168:25: ()
1890 // InternalSolverLanguageLexer.g:168:27:
1891 {
1892 }
1893
1894 }
1895 finally {
1896 }
1897 }
1898 // $ANTLR end "RULE_FULL_STOP"
1899
1900 // $ANTLR start "RULE_ID"
1901 public final void mRULE_ID() throws RecognitionException {
1902 try {
1903 int _type = RULE_ID;
1904 int _channel = DEFAULT_TOKEN_CHANNEL;
1905 // InternalSolverLanguageLexer.g:170:9: ( ( '^' )? ( 'a' .. 'z' | 'A' .. 'Z' | '_' ) ( 'a' .. 'z' | 'A' .. 'Z' | '_' | '0' .. '9' )* )
1906 // InternalSolverLanguageLexer.g:170:11: ( '^' )? ( 'a' .. 'z' | 'A' .. 'Z' | '_' ) ( 'a' .. 'z' | 'A' .. 'Z' | '_' | '0' .. '9' )*
1907 {
1908 // InternalSolverLanguageLexer.g:170:11: ( '^' )?
1909 int alt7=2;
1910 int LA7_0 = input.LA(1);
1911
1912 if ( (LA7_0=='^') ) {
1913 alt7=1;
1914 }
1915 switch (alt7) {
1916 case 1 :
1917 // InternalSolverLanguageLexer.g:170:11: '^'
1918 {
1919 match('^');
1920
1921 }
1922 break;
1923
1924 }
1925
1926 if ( (input.LA(1)>='A' && input.LA(1)<='Z')||input.LA(1)=='_'||(input.LA(1)>='a' && input.LA(1)<='z') ) {
1927 input.consume();
1928
1929 }
1930 else {
1931 MismatchedSetException mse = new MismatchedSetException(null,input);
1932 recover(mse);
1933 throw mse;}
1934
1935 // InternalSolverLanguageLexer.g:170:40: ( 'a' .. 'z' | 'A' .. 'Z' | '_' | '0' .. '9' )*
1936 loop8:
1937 do {
1938 int alt8=2;
1939 int LA8_0 = input.LA(1);
1940
1941 if ( ((LA8_0>='0' && LA8_0<='9')||(LA8_0>='A' && LA8_0<='Z')||LA8_0=='_'||(LA8_0>='a' && LA8_0<='z')) ) {
1942 alt8=1;
1943 }
1944
1945
1946 switch (alt8) {
1947 case 1 :
1948 // InternalSolverLanguageLexer.g:
1949 {
1950 if ( (input.LA(1)>='0' && input.LA(1)<='9')||(input.LA(1)>='A' && input.LA(1)<='Z')||input.LA(1)=='_'||(input.LA(1)>='a' && input.LA(1)<='z') ) {
1951 input.consume();
1952
1953 }
1954 else {
1955 MismatchedSetException mse = new MismatchedSetException(null,input);
1956 recover(mse);
1957 throw mse;}
1958
1959
1960 }
1961 break;
1962
1963 default :
1964 break loop8;
1965 }
1966 } while (true);
1967
1968
1969 }
1970
1971 state.type = _type;
1972 state.channel = _channel;
1973 }
1974 finally {
1975 }
1976 }
1977 // $ANTLR end "RULE_ID"
1978
1979 // $ANTLR start "RULE_INT"
1980 public final void mRULE_INT() throws RecognitionException {
1981 try {
1982 int _type = RULE_INT;
1983 int _channel = DEFAULT_TOKEN_CHANNEL;
1984 // InternalSolverLanguageLexer.g:172:10: ( ( '0' .. '9' )+ )
1985 // InternalSolverLanguageLexer.g:172:12: ( '0' .. '9' )+
1986 {
1987 // InternalSolverLanguageLexer.g:172:12: ( '0' .. '9' )+
1988 int cnt9=0;
1989 loop9:
1990 do {
1991 int alt9=2;
1992 int LA9_0 = input.LA(1);
1993
1994 if ( ((LA9_0>='0' && LA9_0<='9')) ) {
1995 alt9=1;
1996 }
1997
1998
1999 switch (alt9) {
2000 case 1 :
2001 // InternalSolverLanguageLexer.g:172:13: '0' .. '9'
2002 {
2003 matchRange('0','9');
2004
2005 }
2006 break;
2007
2008 default :
2009 if ( cnt9 >= 1 ) break loop9;
2010 EarlyExitException eee =
2011 new EarlyExitException(9, input);
2012 throw eee;
2013 }
2014 cnt9++;
2015 } while (true);
2016
2017
2018 }
2019
2020 state.type = _type;
2021 state.channel = _channel;
2022 }
2023 finally {
2024 }
2025 }
2026 // $ANTLR end "RULE_INT"
2027
2028 // $ANTLR start "RULE_ML_COMMENT"
2029 public final void mRULE_ML_COMMENT() throws RecognitionException {
2030 try {
2031 int _type = RULE_ML_COMMENT;
2032 int _channel = DEFAULT_TOKEN_CHANNEL;
2033 // InternalSolverLanguageLexer.g:174:17: ( '/*' ( options {greedy=false; } : . )* '*/' )
2034 // InternalSolverLanguageLexer.g:174:19: '/*' ( options {greedy=false; } : . )* '*/'
2035 {
2036 match("/*");
2037
2038 // InternalSolverLanguageLexer.g:174:24: ( options {greedy=false; } : . )*
2039 loop10:
2040 do {
2041 int alt10=2;
2042 int LA10_0 = input.LA(1);
2043
2044 if ( (LA10_0=='*') ) {
2045 int LA10_1 = input.LA(2);
2046
2047 if ( (LA10_1=='/') ) {
2048 alt10=2;
2049 }
2050 else if ( ((LA10_1>='\u0000' && LA10_1<='.')||(LA10_1>='0' && LA10_1<='\uFFFF')) ) {
2051 alt10=1;
2052 }
2053
2054
2055 }
2056 else if ( ((LA10_0>='\u0000' && LA10_0<=')')||(LA10_0>='+' && LA10_0<='\uFFFF')) ) {
2057 alt10=1;
2058 }
2059
2060
2061 switch (alt10) {
2062 case 1 :
2063 // InternalSolverLanguageLexer.g:174:52: .
2064 {
2065 matchAny();
2066
2067 }
2068 break;
2069
2070 default :
2071 break loop10;
2072 }
2073 } while (true);
2074
2075 match("*/");
2076
2077
2078 }
2079
2080 state.type = _type;
2081 state.channel = _channel;
2082 }
2083 finally {
2084 }
2085 }
2086 // $ANTLR end "RULE_ML_COMMENT"
2087
2088 // $ANTLR start "RULE_WS"
2089 public final void mRULE_WS() throws RecognitionException {
2090 try {
2091 int _type = RULE_WS;
2092 int _channel = DEFAULT_TOKEN_CHANNEL;
2093 // InternalSolverLanguageLexer.g:176:9: ( ( ' ' | '\\t' | '\\r' | '\\n' )+ )
2094 // InternalSolverLanguageLexer.g:176:11: ( ' ' | '\\t' | '\\r' | '\\n' )+
2095 {
2096 // InternalSolverLanguageLexer.g:176:11: ( ' ' | '\\t' | '\\r' | '\\n' )+
2097 int cnt11=0;
2098 loop11:
2099 do {
2100 int alt11=2;
2101 int LA11_0 = input.LA(1);
2102
2103 if ( ((LA11_0>='\t' && LA11_0<='\n')||LA11_0=='\r'||LA11_0==' ') ) {
2104 alt11=1;
2105 }
2106
2107
2108 switch (alt11) {
2109 case 1 :
2110 // InternalSolverLanguageLexer.g:
2111 {
2112 if ( (input.LA(1)>='\t' && input.LA(1)<='\n')||input.LA(1)=='\r'||input.LA(1)==' ' ) {
2113 input.consume();
2114
2115 }
2116 else {
2117 MismatchedSetException mse = new MismatchedSetException(null,input);
2118 recover(mse);
2119 throw mse;}
2120
2121
2122 }
2123 break;
2124
2125 default :
2126 if ( cnt11 >= 1 ) break loop11;
2127 EarlyExitException eee =
2128 new EarlyExitException(11, input);
2129 throw eee;
2130 }
2131 cnt11++;
2132 } while (true);
2133
2134
2135 }
2136
2137 state.type = _type;
2138 state.channel = _channel;
2139 }
2140 finally {
2141 }
2142 }
2143 // $ANTLR end "RULE_WS"
2144
2145 // $ANTLR start "RULE_ANY_OTHER"
2146 public final void mRULE_ANY_OTHER() throws RecognitionException {
2147 try {
2148 int _type = RULE_ANY_OTHER;
2149 int _channel = DEFAULT_TOKEN_CHANNEL;
2150 // InternalSolverLanguageLexer.g:178:16: ( . )
2151 // InternalSolverLanguageLexer.g:178:18: .
2152 {
2153 matchAny();
2154
2155 }
2156
2157 state.type = _type;
2158 state.channel = _channel;
2159 }
2160 finally {
2161 }
2162 }
2163 // $ANTLR end "RULE_ANY_OTHER"
2164
2165 public void mTokens() throws RecognitionException {
2166 // InternalSolverLanguageLexer.g:1:8: ( GREATER_EQ | Functional | Abstract | Contains | Maximize | Minimize | Opposite | GREATER | LESS_EQ | Current | Default | Extends | Unknown | NOT_EQ | Extern | Class | Count | Empty | Error | False | Scope | LESS | Else | Must | Only | Prod | Real | Then | True | ADD | DIV | MUL | POW | SUB | Avg | Inf | Int | Max | May | Min | Sum | ExclamationMarkEqualsSign | HyphenMinusGreaterThanSign | FullStopFullStop | ColonHyphenMinus | LessThanSignEqualsSign | EqualsSignEqualsSign | GreaterThanSignEqualsSign | EQ | IN | If | In | ExclamationMark | LeftParenthesis | RightParenthesis | Asterisk | PlusSign | Comma | HyphenMinus | FullStop | Solidus | Colon | Semicolon | LessThanSign | EqualsSign | GreaterThanSign | LeftSquareBracket | RightSquareBracket | CircumflexAccent | LeftCurlyBracket | VerticalLine | RightCurlyBracket | RULE_STRING | RULE_QUOTED_ID | RULE_SL_COMMENT | RULE_ID | RULE_INT | RULE_ML_COMMENT | RULE_WS | RULE_ANY_OTHER )
2167 int alt12=80;
2168 alt12 = dfa12.predict(input);
2169 switch (alt12) {
2170 case 1 :
2171 // InternalSolverLanguageLexer.g:1:10: GREATER_EQ
2172 {
2173 mGREATER_EQ();
2174
2175 }
2176 break;
2177 case 2 :
2178 // InternalSolverLanguageLexer.g:1:21: Functional
2179 {
2180 mFunctional();
2181
2182 }
2183 break;
2184 case 3 :
2185 // InternalSolverLanguageLexer.g:1:32: Abstract
2186 {
2187 mAbstract();
2188
2189 }
2190 break;
2191 case 4 :
2192 // InternalSolverLanguageLexer.g:1:41: Contains
2193 {
2194 mContains();
2195
2196 }
2197 break;
2198 case 5 :
2199 // InternalSolverLanguageLexer.g:1:50: Maximize
2200 {
2201 mMaximize();
2202
2203 }
2204 break;
2205 case 6 :
2206 // InternalSolverLanguageLexer.g:1:59: Minimize
2207 {
2208 mMinimize();
2209
2210 }
2211 break;
2212 case 7 :
2213 // InternalSolverLanguageLexer.g:1:68: Opposite
2214 {
2215 mOpposite();
2216
2217 }
2218 break;
2219 case 8 :
2220 // InternalSolverLanguageLexer.g:1:77: GREATER
2221 {
2222 mGREATER();
2223
2224 }
2225 break;
2226 case 9 :
2227 // InternalSolverLanguageLexer.g:1:85: LESS_EQ
2228 {
2229 mLESS_EQ();
2230
2231 }
2232 break;
2233 case 10 :
2234 // InternalSolverLanguageLexer.g:1:93: Current
2235 {
2236 mCurrent();
2237
2238 }
2239 break;
2240 case 11 :
2241 // InternalSolverLanguageLexer.g:1:101: Default
2242 {
2243 mDefault();
2244
2245 }
2246 break;
2247 case 12 :
2248 // InternalSolverLanguageLexer.g:1:109: Extends
2249 {
2250 mExtends();
2251
2252 }
2253 break;
2254 case 13 :
2255 // InternalSolverLanguageLexer.g:1:117: Unknown
2256 {
2257 mUnknown();
2258
2259 }
2260 break;
2261 case 14 :
2262 // InternalSolverLanguageLexer.g:1:125: NOT_EQ
2263 {
2264 mNOT_EQ();
2265
2266 }
2267 break;
2268 case 15 :
2269 // InternalSolverLanguageLexer.g:1:132: Extern
2270 {
2271 mExtern();
2272
2273 }
2274 break;
2275 case 16 :
2276 // InternalSolverLanguageLexer.g:1:139: Class
2277 {
2278 mClass();
2279
2280 }
2281 break;
2282 case 17 :
2283 // InternalSolverLanguageLexer.g:1:145: Count
2284 {
2285 mCount();
2286
2287 }
2288 break;
2289 case 18 :
2290 // InternalSolverLanguageLexer.g:1:151: Empty
2291 {
2292 mEmpty();
2293
2294 }
2295 break;
2296 case 19 :
2297 // InternalSolverLanguageLexer.g:1:157: Error
2298 {
2299 mError();
2300
2301 }
2302 break;
2303 case 20 :
2304 // InternalSolverLanguageLexer.g:1:163: False
2305 {
2306 mFalse();
2307
2308 }
2309 break;
2310 case 21 :
2311 // InternalSolverLanguageLexer.g:1:169: Scope
2312 {
2313 mScope();
2314
2315 }
2316 break;
2317 case 22 :
2318 // InternalSolverLanguageLexer.g:1:175: LESS
2319 {
2320 mLESS();
2321
2322 }
2323 break;
2324 case 23 :
2325 // InternalSolverLanguageLexer.g:1:180: Else
2326 {
2327 mElse();
2328
2329 }
2330 break;
2331 case 24 :
2332 // InternalSolverLanguageLexer.g:1:185: Must
2333 {
2334 mMust();
2335
2336 }
2337 break;
2338 case 25 :
2339 // InternalSolverLanguageLexer.g:1:190: Only
2340 {
2341 mOnly();
2342
2343 }
2344 break;
2345 case 26 :
2346 // InternalSolverLanguageLexer.g:1:195: Prod
2347 {
2348 mProd();
2349
2350 }
2351 break;
2352 case 27 :
2353 // InternalSolverLanguageLexer.g:1:200: Real
2354 {
2355 mReal();
2356
2357 }
2358 break;
2359 case 28 :
2360 // InternalSolverLanguageLexer.g:1:205: Then
2361 {
2362 mThen();
2363
2364 }
2365 break;
2366 case 29 :
2367 // InternalSolverLanguageLexer.g:1:210: True
2368 {
2369 mTrue();
2370
2371 }
2372 break;
2373 case 30 :
2374 // InternalSolverLanguageLexer.g:1:215: ADD
2375 {
2376 mADD();
2377
2378 }
2379 break;
2380 case 31 :
2381 // InternalSolverLanguageLexer.g:1:219: DIV
2382 {
2383 mDIV();
2384
2385 }
2386 break;
2387 case 32 :
2388 // InternalSolverLanguageLexer.g:1:223: MUL
2389 {
2390 mMUL();
2391
2392 }
2393 break;
2394 case 33 :
2395 // InternalSolverLanguageLexer.g:1:227: POW
2396 {
2397 mPOW();
2398
2399 }
2400 break;
2401 case 34 :
2402 // InternalSolverLanguageLexer.g:1:231: SUB
2403 {
2404 mSUB();
2405
2406 }
2407 break;
2408 case 35 :
2409 // InternalSolverLanguageLexer.g:1:235: Avg
2410 {
2411 mAvg();
2412
2413 }
2414 break;
2415 case 36 :
2416 // InternalSolverLanguageLexer.g:1:239: Inf
2417 {
2418 mInf();
2419
2420 }
2421 break;
2422 case 37 :
2423 // InternalSolverLanguageLexer.g:1:243: Int
2424 {
2425 mInt();
2426
2427 }
2428 break;
2429 case 38 :
2430 // InternalSolverLanguageLexer.g:1:247: Max
2431 {
2432 mMax();
2433
2434 }
2435 break;
2436 case 39 :
2437 // InternalSolverLanguageLexer.g:1:251: May
2438 {
2439 mMay();
2440
2441 }
2442 break;
2443 case 40 :
2444 // InternalSolverLanguageLexer.g:1:255: Min
2445 {
2446 mMin();
2447
2448 }
2449 break;
2450 case 41 :
2451 // InternalSolverLanguageLexer.g:1:259: Sum
2452 {
2453 mSum();
2454
2455 }
2456 break;
2457 case 42 :
2458 // InternalSolverLanguageLexer.g:1:263: ExclamationMarkEqualsSign
2459 {
2460 mExclamationMarkEqualsSign();
2461
2462 }
2463 break;
2464 case 43 :
2465 // InternalSolverLanguageLexer.g:1:289: HyphenMinusGreaterThanSign
2466 {
2467 mHyphenMinusGreaterThanSign();
2468
2469 }
2470 break;
2471 case 44 :
2472 // InternalSolverLanguageLexer.g:1:316: FullStopFullStop
2473 {
2474 mFullStopFullStop();
2475
2476 }
2477 break;
2478 case 45 :
2479 // InternalSolverLanguageLexer.g:1:333: ColonHyphenMinus
2480 {
2481 mColonHyphenMinus();
2482
2483 }
2484 break;
2485 case 46 :
2486 // InternalSolverLanguageLexer.g:1:350: LessThanSignEqualsSign
2487 {
2488 mLessThanSignEqualsSign();
2489
2490 }
2491 break;
2492 case 47 :
2493 // InternalSolverLanguageLexer.g:1:373: EqualsSignEqualsSign
2494 {
2495 mEqualsSignEqualsSign();
2496
2497 }
2498 break;
2499 case 48 :
2500 // InternalSolverLanguageLexer.g:1:394: GreaterThanSignEqualsSign
2501 {
2502 mGreaterThanSignEqualsSign();
2503
2504 }
2505 break;
2506 case 49 :
2507 // InternalSolverLanguageLexer.g:1:420: EQ
2508 {
2509 mEQ();
2510
2511 }
2512 break;
2513 case 50 :
2514 // InternalSolverLanguageLexer.g:1:423: IN
2515 {
2516 mIN();
2517
2518 }
2519 break;
2520 case 51 :
2521 // InternalSolverLanguageLexer.g:1:426: If
2522 {
2523 mIf();
2524
2525 }
2526 break;
2527 case 52 :
2528 // InternalSolverLanguageLexer.g:1:429: In
2529 {
2530 mIn();
2531
2532 }
2533 break;
2534 case 53 :
2535 // InternalSolverLanguageLexer.g:1:432: ExclamationMark
2536 {
2537 mExclamationMark();
2538
2539 }
2540 break;
2541 case 54 :
2542 // InternalSolverLanguageLexer.g:1:448: LeftParenthesis
2543 {
2544 mLeftParenthesis();
2545
2546 }
2547 break;
2548 case 55 :
2549 // InternalSolverLanguageLexer.g:1:464: RightParenthesis
2550 {
2551 mRightParenthesis();
2552
2553 }
2554 break;
2555 case 56 :
2556 // InternalSolverLanguageLexer.g:1:481: Asterisk
2557 {
2558 mAsterisk();
2559
2560 }
2561 break;
2562 case 57 :
2563 // InternalSolverLanguageLexer.g:1:490: PlusSign
2564 {
2565 mPlusSign();
2566
2567 }
2568 break;
2569 case 58 :
2570 // InternalSolverLanguageLexer.g:1:499: Comma
2571 {
2572 mComma();
2573
2574 }
2575 break;
2576 case 59 :
2577 // InternalSolverLanguageLexer.g:1:505: HyphenMinus
2578 {
2579 mHyphenMinus();
2580
2581 }
2582 break;
2583 case 60 :
2584 // InternalSolverLanguageLexer.g:1:517: FullStop
2585 {
2586 mFullStop();
2587
2588 }
2589 break;
2590 case 61 :
2591 // InternalSolverLanguageLexer.g:1:526: Solidus
2592 {
2593 mSolidus();
2594
2595 }
2596 break;
2597 case 62 :
2598 // InternalSolverLanguageLexer.g:1:534: Colon
2599 {
2600 mColon();
2601
2602 }
2603 break;
2604 case 63 :
2605 // InternalSolverLanguageLexer.g:1:540: Semicolon
2606 {
2607 mSemicolon();
2608
2609 }
2610 break;
2611 case 64 :
2612 // InternalSolverLanguageLexer.g:1:550: LessThanSign
2613 {
2614 mLessThanSign();
2615
2616 }
2617 break;
2618 case 65 :
2619 // InternalSolverLanguageLexer.g:1:563: EqualsSign
2620 {
2621 mEqualsSign();
2622
2623 }
2624 break;
2625 case 66 :
2626 // InternalSolverLanguageLexer.g:1:574: GreaterThanSign
2627 {
2628 mGreaterThanSign();
2629
2630 }
2631 break;
2632 case 67 :
2633 // InternalSolverLanguageLexer.g:1:590: LeftSquareBracket
2634 {
2635 mLeftSquareBracket();
2636
2637 }
2638 break;
2639 case 68 :
2640 // InternalSolverLanguageLexer.g:1:608: RightSquareBracket
2641 {
2642 mRightSquareBracket();
2643
2644 }
2645 break;
2646 case 69 :
2647 // InternalSolverLanguageLexer.g:1:627: CircumflexAccent
2648 {
2649 mCircumflexAccent();
2650
2651 }
2652 break;
2653 case 70 :
2654 // InternalSolverLanguageLexer.g:1:644: LeftCurlyBracket
2655 {
2656 mLeftCurlyBracket();
2657
2658 }
2659 break;
2660 case 71 :
2661 // InternalSolverLanguageLexer.g:1:661: VerticalLine
2662 {
2663 mVerticalLine();
2664
2665 }
2666 break;
2667 case 72 :
2668 // InternalSolverLanguageLexer.g:1:674: RightCurlyBracket
2669 {
2670 mRightCurlyBracket();
2671
2672 }
2673 break;
2674 case 73 :
2675 // InternalSolverLanguageLexer.g:1:692: RULE_STRING
2676 {
2677 mRULE_STRING();
2678
2679 }
2680 break;
2681 case 74 :
2682 // InternalSolverLanguageLexer.g:1:704: RULE_QUOTED_ID
2683 {
2684 mRULE_QUOTED_ID();
2685
2686 }
2687 break;
2688 case 75 :
2689 // InternalSolverLanguageLexer.g:1:719: RULE_SL_COMMENT
2690 {
2691 mRULE_SL_COMMENT();
2692
2693 }
2694 break;
2695 case 76 :
2696 // InternalSolverLanguageLexer.g:1:735: RULE_ID
2697 {
2698 mRULE_ID();
2699
2700 }
2701 break;
2702 case 77 :
2703 // InternalSolverLanguageLexer.g:1:743: RULE_INT
2704 {
2705 mRULE_INT();
2706
2707 }
2708 break;
2709 case 78 :
2710 // InternalSolverLanguageLexer.g:1:752: RULE_ML_COMMENT
2711 {
2712 mRULE_ML_COMMENT();
2713
2714 }
2715 break;
2716 case 79 :
2717 // InternalSolverLanguageLexer.g:1:768: RULE_WS
2718 {
2719 mRULE_WS();
2720
2721 }
2722 break;
2723 case 80 :
2724 // InternalSolverLanguageLexer.g:1:776: RULE_ANY_OTHER
2725 {
2726 mRULE_ANY_OTHER();
2727
2728 }
2729 break;
2730
2731 }
2732
2733 }
2734
2735
2736 protected DFA12 dfa12 = new DFA12(this);
2737 static final String DFA12_eotS =
2738 "\1\uffff\25\64\1\127\1\131\1\133\1\135\1\137\1\141\1\143\2\64\5\uffff\1\155\3\uffff\1\161\3\uffff\2\62\5\uffff\1\64\1\uffff\37\64\1\u009d\1\u009e\16\uffff\1\u009f\1\u00a0\23\uffff\4\64\1\u00a5\4\64\1\u00ab\1\u00ac\1\u00ae\14\64\1\u00bb\4\64\1\u00c0\1\u00c1\1\u00c2\1\u00c3\1\u00c4\1\u00c5\1\u00c6\4\uffff\4\64\1\uffff\5\64\2\uffff\1\64\1\uffff\1\u00d1\1\64\1\u00d3\1\u00d5\4\64\1\u00db\3\64\1\uffff\1\u00df\1\u00e0\1\u00e1\1\u00e2\7\uffff\2\64\1\u00e5\2\64\1\u00e8\1\64\1\u00ea\2\64\1\uffff\1\64\1\uffff\1\64\1\uffff\3\64\1\u00f2\1\u00f3\1\uffff\2\64\1\u00f6\4\uffff\2\64\1\uffff\2\64\1\uffff\1\64\1\uffff\6\64\1\u0102\2\uffff\1\64\1\u0104\1\uffff\1\u0106\3\64\1\u010a\3\64\1\u010e\1\u010f\1\u0110\1\uffff\1\u0111\1\uffff\1\64\1\uffff\1\64\1\u0114\1\u0115\1\uffff\1\u0116\1\u0117\1\u0118\4\uffff\2\64\5\uffff\1\u011b\1\u011c\2\uffff";
2739 static final String DFA12_eofS =
2740 "\u011d\uffff";
2741 static final String DFA12_minS =
2742 "\1\0\1\122\1\141\1\142\1\154\1\141\1\156\1\105\1\145\1\154\1\156\1\117\1\143\1\162\1\145\1\150\1\104\1\111\1\125\1\117\1\125\1\146\1\75\1\76\1\56\1\55\3\75\1\121\1\116\5\uffff\1\52\3\uffff\1\101\3\uffff\2\0\5\uffff\1\105\1\uffff\1\156\1\154\1\163\1\147\1\156\1\162\1\141\1\170\1\156\1\163\1\160\1\154\1\123\1\146\1\164\1\160\1\162\1\163\1\153\1\124\1\157\1\155\1\157\1\141\1\145\1\165\1\104\1\126\1\114\1\127\1\102\2\60\16\uffff\2\60\23\uffff\1\101\1\143\1\163\1\164\1\60\1\164\1\156\1\162\1\163\3\60\1\164\1\157\1\171\1\123\1\141\1\145\1\164\1\157\1\145\1\156\1\137\1\160\1\60\1\144\1\154\1\156\1\145\7\60\4\uffff\1\124\1\164\1\145\1\162\1\uffff\1\141\1\164\1\145\1\163\1\155\2\uffff\1\155\1\uffff\1\60\1\163\2\60\1\165\1\156\1\171\1\162\1\60\1\157\1\105\1\145\1\uffff\4\60\7\uffff\1\105\1\151\1\60\1\141\1\151\1\60\1\156\1\60\2\151\1\uffff\1\151\1\uffff\1\105\1\uffff\1\154\1\144\1\156\2\60\1\uffff\1\167\1\121\1\60\4\uffff\1\122\1\157\1\uffff\1\143\1\156\1\uffff\1\164\1\uffff\2\172\1\164\1\121\1\164\1\163\1\60\2\uffff\1\156\1\60\1\uffff\1\60\1\156\1\164\1\163\1\60\3\145\3\60\1\uffff\1\60\1\uffff\1\105\1\uffff\1\141\2\60\1\uffff\3\60\4\uffff\1\121\1\154\5\uffff\2\60\2\uffff";
2743 static final String DFA12_maxS =
2744 "\1\uffff\1\122\1\165\1\166\2\165\1\160\1\105\1\145\1\170\1\156\1\117\1\165\1\162\1\145\1\162\1\104\1\111\1\125\1\117\1\125\1\156\1\75\1\76\1\56\1\55\3\75\1\121\1\116\5\uffff\1\57\3\uffff\1\172\3\uffff\2\uffff\5\uffff\1\105\1\uffff\1\156\1\154\1\163\1\147\1\165\1\162\1\141\1\171\1\156\1\163\1\160\1\154\1\123\1\146\1\164\1\160\1\162\1\163\1\153\1\124\1\157\1\155\1\157\1\141\1\145\1\165\1\104\1\126\1\114\1\127\1\102\2\172\16\uffff\2\172\23\uffff\1\101\1\143\1\163\1\164\1\172\1\164\1\156\1\162\1\163\3\172\1\164\1\157\1\171\1\123\1\141\1\145\1\164\1\157\1\145\1\156\1\137\1\160\1\172\1\144\1\154\1\156\1\145\7\172\4\uffff\1\124\1\164\1\145\1\162\1\uffff\1\141\1\164\1\145\1\163\1\155\2\uffff\1\155\1\uffff\1\172\1\163\2\172\1\165\1\162\1\171\1\162\1\172\1\157\1\105\1\145\1\uffff\4\172\7\uffff\1\105\1\151\1\172\1\141\1\151\1\172\1\156\1\172\2\151\1\uffff\1\151\1\uffff\1\105\1\uffff\1\154\1\144\1\156\2\172\1\uffff\1\167\1\121\1\172\4\uffff\1\122\1\157\1\uffff\1\143\1\156\1\uffff\1\164\1\uffff\2\172\1\164\1\121\1\164\1\163\1\172\2\uffff\1\156\1\172\1\uffff\1\172\1\156\1\164\1\163\1\172\3\145\3\172\1\uffff\1\172\1\uffff\1\105\1\uffff\1\141\2\172\1\uffff\3\172\4\uffff\1\121\1\154\5\uffff\2\172\2\uffff";
2745 static final String DFA12_acceptS =
2746 "\37\uffff\1\66\1\67\1\70\1\71\1\72\1\uffff\1\77\1\103\1\104\1\uffff\1\106\1\107\1\110\2\uffff\1\113\1\114\1\115\1\117\1\120\1\uffff\1\114\41\uffff\1\52\1\65\1\53\1\73\1\54\1\74\1\55\1\76\1\56\1\100\1\57\1\101\1\60\1\102\2\uffff\1\66\1\67\1\70\1\71\1\72\1\113\1\116\1\75\1\77\1\103\1\104\1\105\1\106\1\107\1\110\1\111\1\112\1\115\1\117\44\uffff\1\64\1\63\1\61\1\62\4\uffff\1\43\5\uffff\1\46\1\47\1\uffff\1\50\14\uffff\1\51\4\uffff\1\36\1\37\1\40\1\41\1\42\1\44\1\45\12\uffff\1\30\1\uffff\1\31\1\uffff\1\26\5\uffff\1\27\3\uffff\1\32\1\33\1\34\1\35\2\uffff\1\24\2\uffff\1\21\1\uffff\1\20\7\uffff\1\22\1\23\2\uffff\1\25\13\uffff\1\17\1\uffff\1\16\1\uffff\1\10\3\uffff\1\12\3\uffff\1\11\1\13\1\14\1\15\2\uffff\1\3\1\4\1\5\1\6\1\7\2\uffff\1\1\1\2";
2747 static final String DFA12_specialS =
2748 "\1\1\53\uffff\1\0\1\2\u00ef\uffff}>";
2749 static final String[] DFA12_transitionS = {
2750 "\11\62\2\61\2\62\1\61\22\62\1\61\1\26\1\54\2\62\1\56\1\62\1\55\1\37\1\40\1\41\1\42\1\43\1\27\1\30\1\44\12\60\1\31\1\45\1\32\1\33\1\34\2\62\1\20\2\57\1\21\1\35\1\57\1\1\1\57\1\36\2\57\1\7\1\22\1\13\1\57\1\23\2\57\1\24\7\57\1\46\1\62\1\47\1\50\1\57\1\62\1\3\1\57\1\4\1\10\1\11\1\2\2\57\1\25\3\57\1\5\1\57\1\6\1\15\1\57\1\16\1\14\1\17\1\12\5\57\1\51\1\52\1\53\uff82\62",
2751 "\1\63",
2752 "\1\66\23\uffff\1\65",
2753 "\1\67\23\uffff\1\70",
2754 "\1\73\2\uffff\1\71\5\uffff\1\72",
2755 "\1\74\7\uffff\1\75\13\uffff\1\76",
2756 "\1\100\1\uffff\1\77",
2757 "\1\101",
2758 "\1\102",
2759 "\1\106\1\104\4\uffff\1\105\5\uffff\1\103",
2760 "\1\107",
2761 "\1\110",
2762 "\1\111\21\uffff\1\112",
2763 "\1\113",
2764 "\1\114",
2765 "\1\115\11\uffff\1\116",
2766 "\1\117",
2767 "\1\120",
2768 "\1\121",
2769 "\1\122",
2770 "\1\123",
2771 "\1\125\7\uffff\1\124",
2772 "\1\126",
2773 "\1\130",
2774 "\1\132",
2775 "\1\134",
2776 "\1\136",
2777 "\1\140",
2778 "\1\142",
2779 "\1\144",
2780 "\1\145",
2781 "",
2782 "",
2783 "",
2784 "",
2785 "",
2786 "\1\154\4\uffff\1\153",
2787 "",
2788 "",
2789 "",
2790 "\32\64\4\uffff\1\64\1\uffff\32\64",
2791 "",
2792 "",
2793 "",
2794 "\0\165",
2795 "\0\166",
2796 "",
2797 "",
2798 "",
2799 "",
2800 "",
2801 "\1\171",
2802 "",
2803 "\1\172",
2804 "\1\173",
2805 "\1\174",
2806 "\1\175",
2807 "\1\176\6\uffff\1\177",
2808 "\1\u0080",
2809 "\1\u0081",
2810 "\1\u0082\1\u0083",
2811 "\1\u0084",
2812 "\1\u0085",
2813 "\1\u0086",
2814 "\1\u0087",
2815 "\1\u0088",
2816 "\1\u0089",
2817 "\1\u008a",
2818 "\1\u008b",
2819 "\1\u008c",
2820 "\1\u008d",
2821 "\1\u008e",
2822 "\1\u008f",
2823 "\1\u0090",
2824 "\1\u0091",
2825 "\1\u0092",
2826 "\1\u0093",
2827 "\1\u0094",
2828 "\1\u0095",
2829 "\1\u0096",
2830 "\1\u0097",
2831 "\1\u0098",
2832 "\1\u0099",
2833 "\1\u009a",
2834 "\12\64\7\uffff\32\64\4\uffff\1\64\1\uffff\5\64\1\u009b\15\64\1\u009c\6\64",
2835 "\12\64\7\uffff\32\64\4\uffff\1\64\1\uffff\32\64",
2836 "",
2837 "",
2838 "",
2839 "",
2840 "",
2841 "",
2842 "",
2843 "",
2844 "",
2845 "",
2846 "",
2847 "",
2848 "",
2849 "",
2850 "\12\64\7\uffff\32\64\4\uffff\1\64\1\uffff\32\64",
2851 "\12\64\7\uffff\32\64\4\uffff\1\64\1\uffff\32\64",
2852 "",
2853 "",
2854 "",
2855 "",
2856 "",
2857 "",
2858 "",
2859 "",
2860 "",
2861 "",
2862 "",
2863 "",
2864 "",
2865 "",
2866 "",
2867 "",
2868 "",
2869 "",
2870 "",
2871 "\1\u00a1",
2872 "\1\u00a2",
2873 "\1\u00a3",
2874 "\1\u00a4",
2875 "\12\64\7\uffff\32\64\4\uffff\1\64\1\uffff\32\64",
2876 "\1\u00a6",
2877 "\1\u00a7",
2878 "\1\u00a8",
2879 "\1\u00a9",
2880 "\12\64\7\uffff\32\64\4\uffff\1\64\1\uffff\10\64\1\u00aa\21\64",
2881 "\12\64\7\uffff\32\64\4\uffff\1\64\1\uffff\32\64",
2882 "\12\64\7\uffff\32\64\4\uffff\1\64\1\uffff\10\64\1\u00ad\21\64",
2883 "\1\u00af",
2884 "\1\u00b0",
2885 "\1\u00b1",
2886 "\1\u00b2",
2887 "\1\u00b3",
2888 "\1\u00b4",
2889 "\1\u00b5",
2890 "\1\u00b6",
2891 "\1\u00b7",
2892 "\1\u00b8",
2893 "\1\u00b9",
2894 "\1\u00ba",
2895 "\12\64\7\uffff\32\64\4\uffff\1\64\1\uffff\32\64",
2896 "\1\u00bc",
2897 "\1\u00bd",
2898 "\1\u00be",
2899 "\1\u00bf",
2900 "\12\64\7\uffff\32\64\4\uffff\1\64\1\uffff\32\64",
2901 "\12\64\7\uffff\32\64\4\uffff\1\64\1\uffff\32\64",
2902 "\12\64\7\uffff\32\64\4\uffff\1\64\1\uffff\32\64",
2903 "\12\64\7\uffff\32\64\4\uffff\1\64\1\uffff\32\64",
2904 "\12\64\7\uffff\32\64\4\uffff\1\64\1\uffff\32\64",
2905 "\12\64\7\uffff\32\64\4\uffff\1\64\1\uffff\32\64",
2906 "\12\64\7\uffff\32\64\4\uffff\1\64\1\uffff\32\64",
2907 "",
2908 "",
2909 "",
2910 "",
2911 "\1\u00c7",
2912 "\1\u00c8",
2913 "\1\u00c9",
2914 "\1\u00ca",
2915 "",
2916 "\1\u00cb",
2917 "\1\u00cc",
2918 "\1\u00cd",
2919 "\1\u00ce",
2920 "\1\u00cf",
2921 "",
2922 "",
2923 "\1\u00d0",
2924 "",
2925 "\12\64\7\uffff\32\64\4\uffff\1\64\1\uffff\32\64",
2926 "\1\u00d2",
2927 "\12\64\7\uffff\32\64\4\uffff\1\64\1\uffff\32\64",
2928 "\12\64\7\uffff\32\64\4\uffff\1\u00d4\1\uffff\32\64",
2929 "\1\u00d6",
2930 "\1\u00d7\3\uffff\1\u00d8",
2931 "\1\u00d9",
2932 "\1\u00da",
2933 "\12\64\7\uffff\32\64\4\uffff\1\64\1\uffff\32\64",
2934 "\1\u00dc",
2935 "\1\u00dd",
2936 "\1\u00de",
2937 "",
2938 "\12\64\7\uffff\32\64\4\uffff\1\64\1\uffff\32\64",
2939 "\12\64\7\uffff\32\64\4\uffff\1\64\1\uffff\32\64",
2940 "\12\64\7\uffff\32\64\4\uffff\1\64\1\uffff\32\64",
2941 "\12\64\7\uffff\32\64\4\uffff\1\64\1\uffff\32\64",
2942 "",
2943 "",
2944 "",
2945 "",
2946 "",
2947 "",
2948 "",
2949 "\1\u00e3",
2950 "\1\u00e4",
2951 "\12\64\7\uffff\32\64\4\uffff\1\64\1\uffff\32\64",
2952 "\1\u00e6",
2953 "\1\u00e7",
2954 "\12\64\7\uffff\32\64\4\uffff\1\64\1\uffff\32\64",
2955 "\1\u00e9",
2956 "\12\64\7\uffff\32\64\4\uffff\1\64\1\uffff\32\64",
2957 "\1\u00eb",
2958 "\1\u00ec",
2959 "",
2960 "\1\u00ed",
2961 "",
2962 "\1\u00ee",
2963 "",
2964 "\1\u00ef",
2965 "\1\u00f0",
2966 "\1\u00f1",
2967 "\12\64\7\uffff\32\64\4\uffff\1\64\1\uffff\32\64",
2968 "\12\64\7\uffff\32\64\4\uffff\1\64\1\uffff\32\64",
2969 "",
2970 "\1\u00f4",
2971 "\1\u00f5",
2972 "\12\64\7\uffff\32\64\4\uffff\1\64\1\uffff\32\64",
2973 "",
2974 "",
2975 "",
2976 "",
2977 "\1\u00f7",
2978 "\1\u00f8",
2979 "",
2980 "\1\u00f9",
2981 "\1\u00fa",
2982 "",
2983 "\1\u00fb",
2984 "",
2985 "\1\u00fc",
2986 "\1\u00fd",
2987 "\1\u00fe",
2988 "\1\u00ff",
2989 "\1\u0100",
2990 "\1\u0101",
2991 "\12\64\7\uffff\32\64\4\uffff\1\64\1\uffff\32\64",
2992 "",
2993 "",
2994 "\1\u0103",
2995 "\12\64\7\uffff\32\64\4\uffff\1\64\1\uffff\32\64",
2996 "",
2997 "\12\64\7\uffff\32\64\4\uffff\1\u0105\1\uffff\32\64",
2998 "\1\u0107",
2999 "\1\u0108",
3000 "\1\u0109",
3001 "\12\64\7\uffff\32\64\4\uffff\1\64\1\uffff\32\64",
3002 "\1\u010b",
3003 "\1\u010c",
3004 "\1\u010d",
3005 "\12\64\7\uffff\32\64\4\uffff\1\64\1\uffff\32\64",
3006 "\12\64\7\uffff\32\64\4\uffff\1\64\1\uffff\32\64",
3007 "\12\64\7\uffff\32\64\4\uffff\1\64\1\uffff\32\64",
3008 "",
3009 "\12\64\7\uffff\32\64\4\uffff\1\64\1\uffff\32\64",
3010 "",
3011 "\1\u0112",
3012 "",
3013 "\1\u0113",
3014 "\12\64\7\uffff\32\64\4\uffff\1\64\1\uffff\32\64",
3015 "\12\64\7\uffff\32\64\4\uffff\1\64\1\uffff\32\64",
3016 "",
3017 "\12\64\7\uffff\32\64\4\uffff\1\64\1\uffff\32\64",
3018 "\12\64\7\uffff\32\64\4\uffff\1\64\1\uffff\32\64",
3019 "\12\64\7\uffff\32\64\4\uffff\1\64\1\uffff\32\64",
3020 "",
3021 "",
3022 "",
3023 "",
3024 "\1\u0119",
3025 "\1\u011a",
3026 "",
3027 "",
3028 "",
3029 "",
3030 "",
3031 "\12\64\7\uffff\32\64\4\uffff\1\64\1\uffff\32\64",
3032 "\12\64\7\uffff\32\64\4\uffff\1\64\1\uffff\32\64",
3033 "",
3034 ""
3035 };
3036
3037 static final short[] DFA12_eot = DFA.unpackEncodedString(DFA12_eotS);
3038 static final short[] DFA12_eof = DFA.unpackEncodedString(DFA12_eofS);
3039 static final char[] DFA12_min = DFA.unpackEncodedStringToUnsignedChars(DFA12_minS);
3040 static final char[] DFA12_max = DFA.unpackEncodedStringToUnsignedChars(DFA12_maxS);
3041 static final short[] DFA12_accept = DFA.unpackEncodedString(DFA12_acceptS);
3042 static final short[] DFA12_special = DFA.unpackEncodedString(DFA12_specialS);
3043 static final short[][] DFA12_transition;
3044
3045 static {
3046 int numStates = DFA12_transitionS.length;
3047 DFA12_transition = new short[numStates][];
3048 for (int i=0; i<numStates; i++) {
3049 DFA12_transition[i] = DFA.unpackEncodedString(DFA12_transitionS[i]);
3050 }
3051 }
3052
3053 class DFA12 extends DFA {
3054
3055 public DFA12(BaseRecognizer recognizer) {
3056 this.recognizer = recognizer;
3057 this.decisionNumber = 12;
3058 this.eot = DFA12_eot;
3059 this.eof = DFA12_eof;
3060 this.min = DFA12_min;
3061 this.max = DFA12_max;
3062 this.accept = DFA12_accept;
3063 this.special = DFA12_special;
3064 this.transition = DFA12_transition;
3065 }
3066 public String getDescription() {
3067 return "1:1: Tokens : ( GREATER_EQ | Functional | Abstract | Contains | Maximize | Minimize | Opposite | GREATER | LESS_EQ | Current | Default | Extends | Unknown | NOT_EQ | Extern | Class | Count | Empty | Error | False | Scope | LESS | Else | Must | Only | Prod | Real | Then | True | ADD | DIV | MUL | POW | SUB | Avg | Inf | Int | Max | May | Min | Sum | ExclamationMarkEqualsSign | HyphenMinusGreaterThanSign | FullStopFullStop | ColonHyphenMinus | LessThanSignEqualsSign | EqualsSignEqualsSign | GreaterThanSignEqualsSign | EQ | IN | If | In | ExclamationMark | LeftParenthesis | RightParenthesis | Asterisk | PlusSign | Comma | HyphenMinus | FullStop | Solidus | Colon | Semicolon | LessThanSign | EqualsSign | GreaterThanSign | LeftSquareBracket | RightSquareBracket | CircumflexAccent | LeftCurlyBracket | VerticalLine | RightCurlyBracket | RULE_STRING | RULE_QUOTED_ID | RULE_SL_COMMENT | RULE_ID | RULE_INT | RULE_ML_COMMENT | RULE_WS | RULE_ANY_OTHER );";
3068 }
3069 public int specialStateTransition(int s, IntStream _input) throws NoViableAltException {
3070 IntStream input = _input;
3071 int _s = s;
3072 switch ( s ) {
3073 case 0 :
3074 int LA12_44 = input.LA(1);
3075
3076 s = -1;
3077 if ( ((LA12_44>='\u0000' && LA12_44<='\uFFFF')) ) {s = 117;}
3078
3079 else s = 50;
3080
3081 if ( s>=0 ) return s;
3082 break;
3083 case 1 :
3084 int LA12_0 = input.LA(1);
3085
3086 s = -1;
3087 if ( (LA12_0=='G') ) {s = 1;}
3088
3089 else if ( (LA12_0=='f') ) {s = 2;}
3090
3091 else if ( (LA12_0=='a') ) {s = 3;}
3092
3093 else if ( (LA12_0=='c') ) {s = 4;}
3094
3095 else if ( (LA12_0=='m') ) {s = 5;}
3096
3097 else if ( (LA12_0=='o') ) {s = 6;}
3098
3099 else if ( (LA12_0=='L') ) {s = 7;}
3100
3101 else if ( (LA12_0=='d') ) {s = 8;}
3102
3103 else if ( (LA12_0=='e') ) {s = 9;}
3104
3105 else if ( (LA12_0=='u') ) {s = 10;}
3106
3107 else if ( (LA12_0=='N') ) {s = 11;}
3108
3109 else if ( (LA12_0=='s') ) {s = 12;}
3110
3111 else if ( (LA12_0=='p') ) {s = 13;}
3112
3113 else if ( (LA12_0=='r') ) {s = 14;}
3114
3115 else if ( (LA12_0=='t') ) {s = 15;}
3116
3117 else if ( (LA12_0=='A') ) {s = 16;}
3118
3119 else if ( (LA12_0=='D') ) {s = 17;}
3120
3121 else if ( (LA12_0=='M') ) {s = 18;}
3122
3123 else if ( (LA12_0=='P') ) {s = 19;}
3124
3125 else if ( (LA12_0=='S') ) {s = 20;}
3126
3127 else if ( (LA12_0=='i') ) {s = 21;}
3128
3129 else if ( (LA12_0=='!') ) {s = 22;}
3130
3131 else if ( (LA12_0=='-') ) {s = 23;}
3132
3133 else if ( (LA12_0=='.') ) {s = 24;}
3134
3135 else if ( (LA12_0==':') ) {s = 25;}
3136
3137 else if ( (LA12_0=='<') ) {s = 26;}
3138
3139 else if ( (LA12_0=='=') ) {s = 27;}
3140
3141 else if ( (LA12_0=='>') ) {s = 28;}
3142
3143 else if ( (LA12_0=='E') ) {s = 29;}
3144
3145 else if ( (LA12_0=='I') ) {s = 30;}
3146
3147 else if ( (LA12_0=='(') ) {s = 31;}
3148
3149 else if ( (LA12_0==')') ) {s = 32;}
3150
3151 else if ( (LA12_0=='*') ) {s = 33;}
3152
3153 else if ( (LA12_0=='+') ) {s = 34;}
3154
3155 else if ( (LA12_0==',') ) {s = 35;}
3156
3157 else if ( (LA12_0=='/') ) {s = 36;}
3158
3159 else if ( (LA12_0==';') ) {s = 37;}
3160
3161 else if ( (LA12_0=='[') ) {s = 38;}
3162
3163 else if ( (LA12_0==']') ) {s = 39;}
3164
3165 else if ( (LA12_0=='^') ) {s = 40;}
3166
3167 else if ( (LA12_0=='{') ) {s = 41;}
3168
3169 else if ( (LA12_0=='|') ) {s = 42;}
3170
3171 else if ( (LA12_0=='}') ) {s = 43;}
3172
3173 else if ( (LA12_0=='\"') ) {s = 44;}
3174
3175 else if ( (LA12_0=='\'') ) {s = 45;}
3176
3177 else if ( (LA12_0=='%') ) {s = 46;}
3178
3179 else if ( ((LA12_0>='B' && LA12_0<='C')||LA12_0=='F'||LA12_0=='H'||(LA12_0>='J' && LA12_0<='K')||LA12_0=='O'||(LA12_0>='Q' && LA12_0<='R')||(LA12_0>='T' && LA12_0<='Z')||LA12_0=='_'||LA12_0=='b'||(LA12_0>='g' && LA12_0<='h')||(LA12_0>='j' && LA12_0<='l')||LA12_0=='n'||LA12_0=='q'||(LA12_0>='v' && LA12_0<='z')) ) {s = 47;}
3180
3181 else if ( ((LA12_0>='0' && LA12_0<='9')) ) {s = 48;}
3182
3183 else if ( ((LA12_0>='\t' && LA12_0<='\n')||LA12_0=='\r'||LA12_0==' ') ) {s = 49;}
3184
3185 else if ( ((LA12_0>='\u0000' && LA12_0<='\b')||(LA12_0>='\u000B' && LA12_0<='\f')||(LA12_0>='\u000E' && LA12_0<='\u001F')||(LA12_0>='#' && LA12_0<='$')||LA12_0=='&'||(LA12_0>='?' && LA12_0<='@')||LA12_0=='\\'||LA12_0=='`'||(LA12_0>='~' && LA12_0<='\uFFFF')) ) {s = 50;}
3186
3187 if ( s>=0 ) return s;
3188 break;
3189 case 2 :
3190 int LA12_45 = input.LA(1);
3191
3192 s = -1;
3193 if ( ((LA12_45>='\u0000' && LA12_45<='\uFFFF')) ) {s = 118;}
3194
3195 else s = 50;
3196
3197 if ( s>=0 ) return s;
3198 break;
3199 }
3200 NoViableAltException nvae =
3201 new NoViableAltException(getDescription(), 12, _s, input);
3202 error(nvae);
3203 throw nvae;
3204 }
3205 }
3206
3207
3208} \ No newline at end of file
generated by cgit v1.2.3-54-g00ecf (git 2.45.2) at 2024-06-29 12:35:11 +0000